gstreamer 1.0.3 → 1.1.0

data/ext/gstreamer/rbgst-element-factory.c

@@ -1,27 +1,28 @@
 /* -*- 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
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2007  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2003, 2004 Laurent Sansonetti <lrz@gnome.org>
+ *
+ *  This library 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.
+ *
+ *  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
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
  */
 
-#include "rbgst.h"
+#include "rbgst-private.h"
 
+#define RG_TARGET_NAMESPACE cElementFactory
 #define SELF(self) RVAL2GST_ELEMENT_FACTORY(self)
 
 /* Class: Gst::ElementFactory
@@ -39,16 +40,16 @@
  * unique name, consisting of the element factory name and a number. 
  * If name is given, it will be given the name supplied.
  *
- * 	# Creates a 'mad' GStreamer element, named 'foo':
- * 	elem1 = Gst::ElementFactory.make("mad", "foo")
- *	  
- * 	# This line does exactly the same thing:
- * 	elem2 = Gst::ElementFactory.find("mad").create("foo")
+ *  # Creates a 'mad' GStreamer element, named 'foo':
+ *  elem1 = Gst::ElementFactory.make("mad", "foo")
+ *    
+ *  # This line does exactly the same thing:
+ *  elem2 = Gst::ElementFactory.find("mad").create("foo")
  *
  * Returns: a newly created object based on Gst::Element.
  */
 static VALUE
-rb_gst_elementfactory_make(int argc, VALUE *argv, VALUE self)
+rg_s_make(int argc, VALUE *argv, VALUE self)
 {
     GstElement *element;
     VALUE fname, ename;
@@ -57,7 +58,7 @@ rb_gst_elementfactory_make(int argc, VALUE *argv, VALUE self)
     rb_scan_args(argc, argv, "11", &fname, &ename);
 
     element = gst_element_factory_make(RVAL2CSTR(fname),
-				       RVAL2CSTR_ACCEPT_NIL(ename));
+                                       RVAL2CSTR_ACCEPT_NIL(ename));
 
     if (element == NULL)
         return Qnil;
@@ -78,12 +79,12 @@ rb_gst_elementfactory_make(int argc, VALUE *argv, VALUE self)
  * Returns: a Gst::ElementFactory object if found, nil otherwise.
  */
 static VALUE
-rb_gst_elementfactory_find (VALUE self, VALUE factory_name)
+rg_s_find (VALUE self, VALUE factory_name)
 {
-	GstElementFactory *factory = gst_element_factory_find (RVAL2CSTR (factory_name));
-	return factory != NULL 
-		? RGST_ELEMENT_FACTORY_NEW (factory)
-		: Qnil;
+    GstElementFactory *factory = gst_element_factory_find (RVAL2CSTR (factory_name));
+    return factory != NULL 
+                ? RGST_ELEMENT_FACTORY_NEW (factory)
+                : Qnil;
 }
 
 /*
@@ -99,7 +100,7 @@ rb_gst_elementfactory_find (VALUE self, VALUE factory_name)
  * Returns: a newly created object based on Gst::Element.
  */
 static VALUE
-create(int argc, VALUE *argv, VALUE self)
+rg_create(int argc, VALUE *argv, VALUE self)
 {
     GstElement *element;
     VALUE name;
@@ -111,12 +112,12 @@ create(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-rb_gst_elementfactory_to_s (VALUE self)
+rg_to_s (VALUE self)
 {
-	GstElementFactory *factory = RGST_ELEMENT_FACTORY (self); 
-	return rb_str_new_with_format ("Element: %s (%s)",
-			      GST_PLUGIN_FEATURE_NAME(factory),
-			      factory->details.longname);
+    GstElementFactory *factory = RGST_ELEMENT_FACTORY (self); 
+    return rb_str_new_with_format ("Element: %s (%s)",
+                                  GST_PLUGIN_FEATURE_NAME(factory),
+                                  factory->details.longname);
 }
 
 /*
@@ -127,7 +128,7 @@ rb_gst_elementfactory_to_s (VALUE self)
  * Returns: an array of Gst::PadTemplate objects.
  */
 static VALUE
-rb_gst_elementfactory_get_pad_templates (VALUE self)
+rg_pad_templates (VALUE self)
 {
     GstElementFactory *factory;
     const GList *list;
@@ -153,9 +154,9 @@ rb_gst_elementfactory_get_pad_templates (VALUE self)
  * Returns: always nil. 
  */
 static VALUE
-rb_gst_elementfactory_each_pad_template (VALUE self)
+rg_each_pad_template (VALUE self)
 {
-	return rb_ary_yield (rb_gst_elementfactory_get_pad_templates (self));
+    return rb_ary_yield (rg_pad_templates (self));
 }
 
 /*
@@ -174,82 +175,75 @@ rb_gst_elementfactory_each_pad_template (VALUE self)
  *
  * Here is an example.
  *
- *	# Prints all details related to the 'mad' element:
- *	Gst::ElementFactory.find("mad").details do |k, v| 
- *		p "#{k}: #{v}"
- *	end 
+ *  # Prints all details related to the 'mad' element:
+ *  Gst::ElementFactory.find("mad").details do |k, v| 
+ *      p "#{k}: #{v}"
+ *  end 
  *
  * Returns: a Hash.
  */
 static VALUE
-rb_gst_elementfactory_get_details (VALUE self)
+rg_details (VALUE self)
 {
-	GstElementFactory *factory;
-	VALUE hash;
-  
-	factory = RGST_ELEMENT_FACTORY (self); 
-	
-	hash = rb_hash_new();
-
-	rb_hash_aset (hash, CSTR2RVAL ("longname"), CSTR2RVAL (factory->details.longname));
-	rb_hash_aset (hash, CSTR2RVAL ("klass"), CSTR2RVAL (factory->details.klass)); 
-	rb_hash_aset (hash, CSTR2RVAL ("description"), CSTR2RVAL (factory->details.description));
-	rb_hash_aset (hash, CSTR2RVAL ("author"), CSTR2RVAL (factory->details.author));
-
-	return hash;
+    GstElementFactory *factory;
+    VALUE hash;
+
+    factory = RGST_ELEMENT_FACTORY (self); 
+
+    hash = rb_hash_new();
+
+    rb_hash_aset (hash, CSTR2RVAL ("longname"), CSTR2RVAL (factory->details.longname));
+    rb_hash_aset (hash, CSTR2RVAL ("klass"), CSTR2RVAL (factory->details.klass)); 
+    rb_hash_aset (hash, CSTR2RVAL ("description"), CSTR2RVAL (factory->details.description));
+    rb_hash_aset (hash, CSTR2RVAL ("author"), CSTR2RVAL (factory->details.author));
+
+    return hash;
 }
 
 static VALUE
-get_long_name(VALUE self)
+rg_long_name(VALUE self)
 {
     return CSTR2RVAL(gst_element_factory_get_longname(SELF(self)));
 }
 
 static VALUE
-get_klass(VALUE self)
+rg_klass(VALUE self)
 {
     return CSTR2RVAL(gst_element_factory_get_klass(SELF(self)));
 }
 
 static VALUE
-get_description(VALUE self)
+rg_description(VALUE self)
 {
     return CSTR2RVAL(gst_element_factory_get_description(SELF(self)));
 }
 
 static VALUE
-get_author(VALUE self)
+rg_author(VALUE self)
 {
     return CSTR2RVAL(gst_element_factory_get_author(SELF(self)));
 }
 
-
 void
-Init_gst_elementfactory (void)
+Init_gst_elementfactory (VALUE mGst)
 {
-    VALUE rb_cGstElementFactory;
+    VALUE RG_TARGET_NAMESPACE;
 
-    rb_cGstElementFactory = G_DEF_CLASS(GST_TYPE_ELEMENT_FACTORY,
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(GST_TYPE_ELEMENT_FACTORY,
                                         "ElementFactory",
                                         mGst);
 
-    rb_define_singleton_method(rb_cGstElementFactory, "make",
-                               rb_gst_elementfactory_make, -1);
-    rb_define_singleton_method(rb_cGstElementFactory, "find",
-                               rb_gst_elementfactory_find, 1);
-
-    rb_define_method(rb_cGstElementFactory, "create", create, -1);
-    rb_define_method(rb_cGstElementFactory, "details",
-                     rb_gst_elementfactory_get_details, 0);
-    rb_define_method(rb_cGstElementFactory, "to_s",
-                     rb_gst_elementfactory_to_s, 0);
-    rb_define_method(rb_cGstElementFactory, "pad_templates",
-                     rb_gst_elementfactory_get_pad_templates, 0);
-    rb_define_method(rb_cGstElementFactory, "each_pad_template",
-                     rb_gst_elementfactory_each_pad_template, 0);
-
-    rb_define_method(rb_cGstElementFactory, "long_name", get_long_name, 0);
-    rb_define_method(rb_cGstElementFactory, "klass", get_klass, 0);
-    rb_define_method(rb_cGstElementFactory, "description", get_description, 0);
-    rb_define_method(rb_cGstElementFactory, "author", get_author, 0);
+    RG_DEF_SMETHOD(make, -1);
+    RG_DEF_SMETHOD(find, 1);
+
+    RG_DEF_METHOD(create, -1);
+    RG_DEF_METHOD(details, 0);
+    RG_DEF_METHOD(to_s, 0);
+    RG_DEF_METHOD(pad_templates, 0);
+    RG_DEF_METHOD(each_pad_template, 0);
+
+    RG_DEF_METHOD(long_name, 0);
+    RG_DEF_METHOD(klass, 0);
+    RG_DEF_METHOD(description, 0);
+    RG_DEF_METHOD(author, 0);
 }

data/ext/gstreamer/rbgst-element.c

@@ -1,39 +1,42 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- * Copyright (C) 2003, 2004 Laurent Sansonetti <lrz@gnome.org>
- * Copyright (C) 2007, 2008 Ruby-GNOME2 Project Team
- * Copyright (C) 2006, 2008 Sjoerd Simons <sjoerd@luon.net>
- *
- * 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
+ *  Copyright (C) 2011-2012  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2007, 2008 Ruby-GNOME2 Project Team
+ *  Copyright (C) 2006, 2008 Sjoerd Simons <sjoerd@luon.net>
+ *  Copyright (C) 2003, 2004 Laurent Sansonetti <lrz@gnome.org>
+ *
+ *  This library 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.
+ *
+ *  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
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
  */
 
-#include "rbgst.h"
 #include "rbgst-private.h"
 
-#ifdef HAVE_UNISTD_H
-#  include <unistd.h>
-#endif
-#ifdef HAVE_IO_H
-#  include <io.h>
-#  define pipe(phandles) _pipe(phandles, 128, _O_BINARY)
+#ifdef G_OS_WIN32
+#  ifdef HAVE_IO_H
+#    include <io.h>
+#    define pipe(phandles) _pipe(phandles, 128, _O_BINARY)
+#  endif
+#else
+#  ifdef HAVE_UNISTD_H
+#    include <unistd.h>
+#  endif
 #endif
 #include <fcntl.h>
 #include <errno.h>
 
+#define RG_TARGET_NAMESPACE cElement
 #define SELF(self) RVAL2GST_ELEMENT(self)
 
 #define GST_STATE_CHANGE_RETURN2RVAL(object) \
@@ -66,17 +69,20 @@ typedef struct _SendEventData {
 
 typedef struct _ThreadData {
     GstElement *element;
-    int notify_fd;
+    gint notify_write_fd;
+    gint notify_read_fd;
+    gint errno_on_write;
+    const gchar *context;
     union {
-	SetStateData set_state_data;
-	GetStateData get_state_data;
-	QueryData query_data;
-	SendEventData send_event_data;
+        SetStateData set_state_data;
+        GetStateData get_state_data;
+        QueryData query_data;
+        SendEventData send_event_data;
     } data;
 } ThreadData;
 
-static RGConvertTable table = {0};
-static VALUE rb_cGstElement;
+static RGConvertTable table;
+static VALUE RG_TARGET_NAMESPACE;
 static ID id_gtype;
 static GThreadPool *set_state_thread_pool;
 static GThreadPool *get_state_thread_pool;
@@ -101,7 +107,6 @@ instance2robj(gpointer instance)
     return rbgst_object_instance2robj(instance);
 }
 
-
 /* Class: Gst::Element
  * Base class for all pipeline elements.
  */
@@ -110,13 +115,14 @@ static void
 do_in_thread(GThreadPool *pool, ThreadData *data)
 {
     int notify_fds[2];
-    char buf[NOTIFY_MESSAGE_SIZE];
     GError *error = NULL;
 
     if (pipe(notify_fds) != 0)
         rb_sys_fail("failed to create a pipe to synchronize threaded operation");
 
-    data->notify_fd = notify_fds[1];
+    data->errno_on_write = 0;
+    data->notify_read_fd = notify_fds[0];
+    data->notify_write_fd = notify_fds[1];
     g_thread_pool_push(pool, data, &error);
     if (error) {
         close(notify_fds[0]);
@@ -126,15 +132,56 @@ do_in_thread(GThreadPool *pool, ThreadData *data)
 
     rb_thread_wait_fd(notify_fds[0]);
 
-    read(notify_fds[0], buf, NOTIFY_MESSAGE_SIZE);
+#define BUFFER_SIZE 512
+    if (data->errno_on_write == 0) {
+        char buf[NOTIFY_MESSAGE_SIZE];
+        ssize_t read_size;
+        int saved_errno = 0;
+        read_size = read(notify_fds[0], buf, NOTIFY_MESSAGE_SIZE);
+        if (read_size != NOTIFY_MESSAGE_SIZE) {
+            saved_errno = errno;
+        }
 
+        close(notify_fds[0]);
+        close(notify_fds[1]);
 
-    close(notify_fds[0]);
-    close(notify_fds[1]);
+        if (saved_errno != 0) {
+            char buffer[BUFFER_SIZE];
+            snprintf(buffer, BUFFER_SIZE - 1,
+                     "failed to read notify pipe on %s", data->context);
+            errno = saved_errno;
+            rb_sys_fail(buffer);
+        }
+    } else {
+        char buffer[BUFFER_SIZE];
+        snprintf(buffer, BUFFER_SIZE - 1,
+                 "failed to write notify pipe on %s", data->context);
+        errno = data->errno_on_write;
+        rb_sys_fail(buffer);
+    }
+#undef BUFFER_SIZE
 }
 
 static void
-set_state_in_thread(gpointer data, gpointer user_data)
+notify(ThreadData *thread_data)
+{
+    ssize_t written_size;
+
+    written_size = write(thread_data->notify_write_fd,
+                         NOTIFY_MESSAGE, NOTIFY_MESSAGE_SIZE);
+    if (written_size != NOTIFY_MESSAGE_SIZE) {
+        int read_fd = thread_data->notify_read_fd;
+        int write_fd = thread_data->notify_write_fd;
+        thread_data->errno_on_write = errno;
+        thread_data->notify_read_fd = -1;
+        thread_data->notify_write_fd = -1;
+        close(write_fd);
+        close(read_fd);
+    }
+}
+
+static void
+set_state_in_thread(gpointer data, G_GNUC_UNUSED gpointer user_data)
 {
     ThreadData *thread_data = (ThreadData *)data;
     SetStateData *set_state_data;
@@ -142,27 +189,25 @@ set_state_in_thread(gpointer data, gpointer user_data)
     set_state_data = &(thread_data->data.set_state_data);
     set_state_data->result = gst_element_set_state(thread_data->element,
                                                    set_state_data->state);
-    write(thread_data->notify_fd, NOTIFY_MESSAGE, NOTIFY_MESSAGE_SIZE);
+    notify(thread_data);
 }
 
 static VALUE
 rb_gst_element_set_state_internal(VALUE self, GstState state)
 {
     VALUE result;
-    ThreadData *thread_data;
+    ThreadData thread_data;
     SetStateData *set_state_data;
 
-    thread_data = g_slice_new(ThreadData);
-    thread_data->element = SELF(self);
-    set_state_data = &(thread_data->data.set_state_data);
+    thread_data.element = SELF(self);
+    thread_data.context = "set_state";
+    set_state_data = &(thread_data.data.set_state_data);
     set_state_data->state = state;
 
-    do_in_thread(set_state_thread_pool, thread_data);
+    do_in_thread(set_state_thread_pool, &thread_data);
 
     result = GST_STATE_CHANGE_RETURN2RVAL(set_state_data->result);
 
-    g_slice_free(ThreadData, thread_data);
-
     return result;
 }
 
@@ -179,53 +224,51 @@ rb_gst_element_set_state_internal(VALUE self, GstState state)
  * Returns: a code (see Gst::Element::StateChangeReturn).
  */
 static VALUE
-rb_gst_element_set_state(VALUE self, VALUE state)
+rg_set_state(VALUE self, VALUE state)
 {
     return rb_gst_element_set_state_internal(self,
-					     RVAL2GENUM(state, GST_TYPE_STATE));
+                                             RVAL2GENUM(state, GST_TYPE_STATE));
 }
 
 static void
-get_state_in_thread(gpointer data, gpointer user_data)
+get_state_in_thread(gpointer data, G_GNUC_UNUSED gpointer user_data)
 {
     ThreadData *thread_data = (ThreadData *)data;
     GetStateData *get_state_data;
 
     get_state_data = &(thread_data->data.get_state_data);
     get_state_data->result = gst_element_get_state(thread_data->element,
-						   &(get_state_data->state),
-						   &(get_state_data->pending),
-						   get_state_data->timeout);
-    write(thread_data->notify_fd, NOTIFY_MESSAGE, NOTIFY_MESSAGE_SIZE);
+                                                   &(get_state_data->state),
+                                                   &(get_state_data->pending),
+                                                   get_state_data->timeout);
+    notify(thread_data);
 }
 
 /* Method: get_state(timeout=nil)
  */
 static VALUE
-rb_gst_element_get_state(int argc, VALUE *argv, VALUE self)
+rg_get_state(int argc, VALUE *argv, VALUE self)
 {
     VALUE result, timeout;
-    ThreadData *thread_data;
+    ThreadData thread_data;
     GetStateData *get_state_data;
 
     rb_scan_args(argc, argv, "01", &timeout);
 
-    thread_data = g_slice_new(ThreadData);
-    thread_data->element = SELF(self);
-    get_state_data = &(thread_data->data.get_state_data);
+    thread_data.element = SELF(self);
+    thread_data.context = "get_state";
+    get_state_data = &(thread_data.data.get_state_data);
     if (NIL_P(timeout))
-	get_state_data->timeout = GST_CLOCK_TIME_NONE;
+        get_state_data->timeout = GST_CLOCK_TIME_NONE;
     else
-	get_state_data->timeout = NUM2ULL(timeout);
+        get_state_data->timeout = NUM2ULL(timeout);
 
-    do_in_thread(get_state_thread_pool, thread_data);
+    do_in_thread(get_state_thread_pool, &thread_data);
 
     result = rb_ary_new3(3,
-			 GST_STATE_CHANGE_RETURN2RVAL(get_state_data->result),
-			 GST_STATE2RVAL(get_state_data->state),
-			 GST_STATE2RVAL(get_state_data->pending));
-
-    g_slice_free(ThreadData, thread_data);
+                         GST_STATE_CHANGE_RETURN2RVAL(get_state_data->result),
+                         GST_STATE2RVAL(get_state_data->state),
+                         GST_STATE2RVAL(get_state_data->pending));
 
     return result;
 }
@@ -238,7 +281,7 @@ rb_gst_element_get_state(int argc, VALUE *argv, VALUE self)
  * Returns: a code (see Gst::Element::StateChangeReturn).
  */
 static VALUE
-rb_gst_element_stop(VALUE self)
+rg_stop(VALUE self)
 {
     return rb_gst_element_set_state_internal(self, GST_STATE_NULL);
 }
@@ -251,7 +294,7 @@ rb_gst_element_stop(VALUE self)
  * Returns: a code (see Gst::Element::StateChangeReturn).
  */
 static VALUE
-rb_gst_element_ready(VALUE self)
+rg_ready(VALUE self)
 {
     return rb_gst_element_set_state_internal(self, GST_STATE_READY);
 }
@@ -264,7 +307,7 @@ rb_gst_element_ready(VALUE self)
  * Returns: a code (see Gst::Element::StateChangedReturn).
  */
 static VALUE
-rb_gst_element_pause(VALUE self)
+rg_pause(VALUE self)
 {
     return rb_gst_element_set_state_internal(self, GST_STATE_PAUSED);
 }
@@ -277,7 +320,7 @@ rb_gst_element_pause(VALUE self)
  * Returns: a code (see Gst::Element::StateChangedReturn).
  */
 static VALUE
-rb_gst_element_play(VALUE self)
+rg_play(VALUE self)
 {
     return rb_gst_element_set_state_internal(self, GST_STATE_PLAYING);
 }
@@ -295,7 +338,7 @@ rb_gst_element_play(VALUE self)
  * Returns: the destination element, or nil if the link failed.
  */
 static VALUE
-rb_gst_element_link(VALUE self, VALUE other_element)
+rg_link(VALUE self, VALUE other_element)
 {
     GstElement *element1, *element2;
 
@@ -315,7 +358,7 @@ rb_gst_element_link(VALUE self, VALUE other_element)
  *
  */
 static VALUE
-rb_gst_element_unlink(VALUE self, VALUE other_element)
+rg_unlink(VALUE self, VALUE other_element)
 {
     GstElement *element1, *element2;
 
@@ -340,11 +383,11 @@ rb_gst_element_unlink(VALUE self, VALUE other_element)
  * Returns: the destination element, or nil if the link failed.
  */
 static VALUE
-rb_gst_element_link_filtered(VALUE self, VALUE other_element, VALUE rcaps)
+rg_link_filtered(VALUE self, VALUE other_element, VALUE rcaps)
 {
     GstElement *element1, *element2;
     GstCaps *caps;
-    
+
     element1 = SELF(self);
     element2 = SELF(other_element);
     caps = RGST_CAPS(rcaps);
@@ -357,7 +400,7 @@ rb_gst_element_link_filtered(VALUE self, VALUE other_element, VALUE rcaps)
  * Returns: true if the element requires a clock, false otherwise.
  */
 static VALUE
-rb_gst_element_requires_clock(VALUE self)
+rg_requires_clock_p(VALUE self)
 {
     return CBOOL2RVAL(gst_element_requires_clock(SELF(self)));
 }
@@ -366,7 +409,7 @@ rb_gst_element_requires_clock(VALUE self)
  * Returns: true if the element provides a clock, false otherwise.
  */
 static VALUE
-rb_gst_element_provides_clock(VALUE self)
+rg_provides_clock_p(VALUE self)
 {
     return CBOOL2RVAL(gst_element_provides_clock(SELF(self)));
 }
@@ -376,7 +419,7 @@ rb_gst_element_provides_clock(VALUE self)
  * if this element does not provide a clock.
  */
 static VALUE
-rb_gst_element_get_clock(VALUE self)
+rg_clock(VALUE self)
 {
     GstClock *clock;
 
@@ -394,7 +437,7 @@ rb_gst_element_get_clock(VALUE self)
  * Returns: self.
  */
 static VALUE
-rb_gst_element_set_clock(VALUE self, VALUE clock)
+rg_set_clock(VALUE self, VALUE clock)
 {
     gst_element_set_clock(SELF(self), RVAL2GST_CLOCK(clock));
     return self;
@@ -419,19 +462,19 @@ rb_gst_element_each_pad_body(VALUE user_data)
 
     while (!done) {
         switch (gst_iterator_next(data->iterator, (gpointer)&pad)) {
-	  case GST_ITERATOR_OK:
-	    data->callback(GST_PAD2RVAL(pad), data->user_data);
-	    gst_object_unref(pad);
-	    break;
-	  case GST_ITERATOR_RESYNC:
-	    gst_iterator_resync(data->iterator);
-	    break;
-	  case GST_ITERATOR_ERROR:
-	    rb_raise(rb_eIndexError, "Pad iteration failed");
-	    break;
-	  case GST_ITERATOR_DONE:
-	    done = TRUE;
-	    break;
+          case GST_ITERATOR_OK:
+            data->callback(GST_PAD2RVAL(pad), data->user_data);
+            gst_object_unref(pad);
+            break;
+          case GST_ITERATOR_RESYNC:
+            gst_iterator_resync(data->iterator);
+            break;
+          case GST_ITERATOR_ERROR:
+            rb_raise(rb_eIndexError, "Pad iteration failed");
+            break;
+          case GST_ITERATOR_DONE:
+            done = TRUE;
+            break;
         }
     }
 
@@ -449,8 +492,8 @@ rb_gst_element_each_pad_ensure(VALUE user_data)
 
 static VALUE
 rb_gst_element_each_pad_with_callback(VALUE self,
-				      EachPadCallback callback,
-				      VALUE user_data)
+                                      EachPadCallback callback,
+                                      VALUE user_data)
 {
     EachPadData data;
 
@@ -459,7 +502,7 @@ rb_gst_element_each_pad_with_callback(VALUE self,
     data.user_data = user_data;
     data.iterator = gst_element_iterate_pads(SELF(self));
     return rb_ensure(rb_gst_element_each_pad_body, (VALUE)(&data),
-		     rb_gst_element_each_pad_ensure, (VALUE)(&data));
+             rb_gst_element_each_pad_ensure, (VALUE)(&data));
 }
 
 /*
@@ -473,7 +516,7 @@ rb_gst_element_each_pad_with_callback(VALUE self,
  * Returns: always nil.
  */
 static VALUE
-rb_gst_element_each_pad(VALUE self)
+rg_each_pad(VALUE self)
 {
     rb_gst_element_each_pad_with_callback(self, (EachPadCallback)rb_yield, Qnil);
     return Qnil;
@@ -486,7 +529,7 @@ collect_pad(VALUE pad, VALUE pads)
 }
 
 static VALUE
-rb_gst_element_get_pads(VALUE self)
+rg_pads(VALUE self)
 {
     VALUE pads;
 
@@ -504,7 +547,7 @@ rb_gst_element_get_pads(VALUE self)
  * Returns: a Gst::Pad object, or nil if the pad cannot be found.
  */
 static VALUE
-rb_gst_element_get_pad(VALUE self, VALUE pad_name)
+rg_get_pad(VALUE self, VALUE pad_name)
 {
     GstPad *pad = gst_element_get_pad(SELF(self),
                                        RVAL2CSTR(pad_name));
@@ -524,13 +567,13 @@ rb_gst_element_get_pad(VALUE self, VALUE pad_name)
  * Returns: true on success, false on failure.
  */
 static VALUE
-rb_gst_element_link_pads(VALUE self, VALUE source_pad_name,
-			 VALUE other_element, VALUE destination_pad_name)
+rg_link_pads(VALUE self, VALUE source_pad_name,
+             VALUE other_element, VALUE destination_pad_name)
 {
     return CBOOL2RVAL(gst_element_link_pads(SELF(self),
-					    RVAL2CSTR(source_pad_name),
-					    SELF(other_element),
-					    RVAL2CSTR(destination_pad_name)));
+                                            RVAL2CSTR(source_pad_name),
+                                            SELF(other_element),
+                                            RVAL2CSTR(destination_pad_name)));
 }
 
 /*
@@ -543,13 +586,13 @@ rb_gst_element_link_pads(VALUE self, VALUE source_pad_name,
  * Returns: self.
  */
 static VALUE
-rb_gst_element_unlink_pads(VALUE self, VALUE source_pad_name,
-			   VALUE other_element, VALUE destination_pad_name)
+rg_unlink_pads(VALUE self, VALUE source_pad_name,
+               VALUE other_element, VALUE destination_pad_name)
 {
     gst_element_unlink_pads(SELF(self),
-			    RVAL2CSTR(source_pad_name),
-			    SELF(other_element),
-			    RVAL2CSTR(destination_pad_name));
+                            RVAL2CSTR(source_pad_name),
+                            SELF(other_element),
+                            RVAL2CSTR(destination_pad_name));
     return self;
 }
 
@@ -557,21 +600,21 @@ rb_gst_element_unlink_pads(VALUE self, VALUE source_pad_name,
  * Returns: true if the element can be indexed, false otherwise.
  */
 static VALUE
-rb_gst_element_is_indexable(VALUE self)
+rg_indexable_p(VALUE self)
 {
     return CBOOL2RVAL(gst_element_is_indexable(SELF(self)));
 }
 
 static void
-query_in_thread(gpointer data, gpointer user_data)
+query_in_thread(gpointer data, G_GNUC_UNUSED gpointer user_data)
 {
     ThreadData *thread_data = (ThreadData *)data;
     QueryData *query_data;
 
     query_data = &(thread_data->data.query_data);
     query_data->result = gst_element_query(thread_data->element,
-					   query_data->query);
-    write(thread_data->notify_fd, NOTIFY_MESSAGE, NOTIFY_MESSAGE_SIZE);
+                                           query_data->query);
+    notify(thread_data);
 }
 
 /*
@@ -583,36 +626,34 @@ query_in_thread(gpointer data, gpointer user_data)
  * Returns: true if the query is performed, false otherwise.
  */
 static VALUE
-rb_gst_element_query(VALUE self, VALUE query)
+rg_query(VALUE self, VALUE query)
 {
     VALUE result;
-    ThreadData *thread_data;
+    ThreadData thread_data;
     QueryData *query_data;
 
-    thread_data = g_slice_new(ThreadData);
-    thread_data->element = SELF(self);
-    query_data = &(thread_data->data.query_data);
+    thread_data.element = SELF(self);
+    thread_data.context = "query";
+    query_data = &(thread_data.data.query_data);
     query_data->query = RVAL2GST_QUERY(query);
 
-    do_in_thread(query_thread_pool, thread_data);
+    do_in_thread(query_thread_pool, &thread_data);
 
     result = CBOOL2RVAL(query_data->result);
 
-    g_slice_free(ThreadData, thread_data);
-
     return result;
 }
 
 static void
-send_event_in_thread(gpointer data, gpointer user_data)
+send_event_in_thread(gpointer data, G_GNUC_UNUSED gpointer user_data)
 {
     ThreadData *thread_data = (ThreadData *)data;
     SendEventData *send_event_data;
 
     send_event_data = &(thread_data->data.send_event_data);
     send_event_data->result = gst_element_send_event(thread_data->element,
-						     send_event_data->event);
-    write(thread_data->notify_fd, NOTIFY_MESSAGE, NOTIFY_MESSAGE_SIZE);
+                                                     send_event_data->event);
+    notify(thread_data);
 }
 /*
  * Method: send_event(event)
@@ -626,24 +667,22 @@ send_event_in_thread(gpointer data, gpointer user_data)
  * otherwise.
  */
 static VALUE
-rb_gst_element_send_event(VALUE self, VALUE event)
+rg_send_event(VALUE self, VALUE event)
 {
     VALUE result;
-    ThreadData *thread_data;
+    ThreadData thread_data;
     SendEventData *send_event_data;
 
-    thread_data = g_slice_new(ThreadData);
-    thread_data->element = SELF(self);
-    send_event_data = &(thread_data->data.send_event_data);
+    thread_data.element = SELF(self);
+    thread_data.context = "send_event";
+    send_event_data = &(thread_data.data.send_event_data);
     send_event_data->event = RVAL2GST_EVENT(event);
 
     gst_event_ref(send_event_data->event);
-    do_in_thread(send_event_thread_pool, thread_data);
+    do_in_thread(send_event_thread_pool, &thread_data);
 
     result = CBOOL2RVAL(send_event_data->result);
 
-    g_slice_free(ThreadData, thread_data);
-
     return result;
 }
 
@@ -656,7 +695,7 @@ rb_gst_element_send_event(VALUE self, VALUE event)
  * element base time in Gst::Element::STATE_PAUSED, or -1 otherwise.
  */
 static VALUE
-rb_gst_element_get_base_time(VALUE self)
+rg_base_time(VALUE self)
 {
     return ULL2NUM(gst_element_get_base_time(SELF(self)));
 }
@@ -673,7 +712,7 @@ rb_gst_element_get_base_time(VALUE self)
  * Returns: self.
  */
 static VALUE
-rb_gst_element_set_base_time(VALUE self, VALUE time)
+rg_set_base_time(VALUE self, VALUE time)
 {
     gst_element_set_base_time(SELF(self), NUM2ULL(time));
     return Qnil;
@@ -687,7 +726,7 @@ rb_gst_element_set_base_time(VALUE self, VALUE time)
  * Returns: a Gst::Index or nil when no index was set on the element.
  */
 static VALUE
-rb_gst_element_get_index(VALUE self)
+rg_index(VALUE self)
 {
     GstIndex *index = gst_element_get_index(SELF(self));
 
@@ -704,7 +743,7 @@ rb_gst_element_get_index(VALUE self)
  * Returns: self. 
  */
 static VALUE
-rb_gst_element_set_index(VALUE self, VALUE index)
+rg_set_index(VALUE self, VALUE index)
 {
     gst_element_set_index(SELF(self), RGST_INDEX(index));
     return self;
@@ -720,7 +759,7 @@ rb_gst_element_set_index(VALUE self, VALUE index)
  * Returns: the requested Gst::Pad if found, otherwise nil.
  */
 static VALUE
-rb_gst_element_get_static_pad(VALUE self, VALUE name)
+rg_get_static_pad(VALUE self, VALUE name)
 {
     GstPad *pad =
         gst_element_get_static_pad(SELF(self), RVAL2CSTR(name));
@@ -737,7 +776,7 @@ rb_gst_element_get_static_pad(VALUE self, VALUE name)
  * Returns: the requested Gst::Pad if found, otherwise nil.
  */
 static VALUE
-rb_gst_element_get_request_pad(VALUE self, VALUE name)
+rg_get_request_pad(VALUE self, VALUE name)
 {
     GstPad *pad =
         gst_element_get_request_pad(SELF(self), RVAL2CSTR(name));
@@ -754,7 +793,7 @@ rb_gst_element_get_request_pad(VALUE self, VALUE name)
  * Returns: self.
  */
 static VALUE
-rb_gst_element_release_request_pad(VALUE self, VALUE pad)
+rg_release_request_pad(VALUE self, VALUE pad)
 {
     gst_element_release_request_pad(SELF(self), RGST_PAD(pad));
     return self;
@@ -770,7 +809,7 @@ rb_gst_element_release_request_pad(VALUE self, VALUE pad)
  * Returns: self.
  */
 static VALUE
-rb_gst_element_add_pad(VALUE self, VALUE pad)
+rg_add_pad(VALUE self, VALUE pad)
 {
     gst_element_add_pad(SELF(self), RGST_PAD(pad));
     G_CHILD_ADD(self, pad);
@@ -786,7 +825,7 @@ rb_gst_element_add_pad(VALUE self, VALUE pad)
  * Returns: self.
  */
 static VALUE
-rb_gst_element_remove_pad(VALUE self, VALUE pad)
+rg_remove_pad(VALUE self, VALUE pad)
 {
     gst_element_remove_pad(SELF(self), RGST_PAD(pad));
     return self;
@@ -801,7 +840,7 @@ rb_gst_element_remove_pad(VALUE self, VALUE pad)
  * Returns: the Gst::PadTemplate with the given name, or nil if none was found.
  */
 static VALUE
-rb_gst_element_get_pad_template(VALUE self, VALUE name)
+rg_s_get_pad_template(VALUE self, VALUE name)
 {
     GstElementClass *element_class;
     GstPadTemplate *template;
@@ -820,7 +859,7 @@ rb_gst_element_get_pad_template(VALUE self, VALUE name)
  * Returns: an Array of Gst::PadTemplate objects.
  */
 static VALUE
-rb_gst_element_get_pad_templates(VALUE self)
+rg_s_pad_templates(VALUE self)
 {
     GstElementClass *element_class;
     GList *list, *node;
@@ -846,9 +885,9 @@ rb_gst_element_get_pad_templates(VALUE self)
  * Returns: always nil.
  */
 static VALUE
-rb_gst_element_each_pad_template(VALUE self)
+rg_s_each_pad_template(VALUE self)
 {
-    return rb_ary_yield(rb_gst_element_get_pad_templates(self));
+    return rb_ary_yield(rg_s_pad_templates(self));
 }
 
 /*
@@ -861,7 +900,7 @@ rb_gst_element_each_pad_template(VALUE self)
  * Returns: true if the event was handled.
  */
 static VALUE
-rb_gst_element_seek(VALUE self, VALUE rate, VALUE format, VALUE flags,
+rg_seek(VALUE self, VALUE rate, VALUE format, VALUE flags,
                     VALUE cur_type, VALUE cur, VALUE stop_type, VALUE stop)
 {
     return CBOOL2RVAL(gst_element_seek(SELF(self),
@@ -885,7 +924,7 @@ rb_gst_element_seek(VALUE self, VALUE rate, VALUE format, VALUE flags,
  * Returns: true if the element's state is locked.
  */
 static VALUE
-rb_gst_element_is_locked_state(VALUE self)
+rg_locked_state_p(VALUE self)
 {
     return CBOOL2RVAL(gst_element_is_locked_state(SELF(self)));
 }
@@ -900,7 +939,7 @@ rb_gst_element_is_locked_state(VALUE self)
  * Returns: self.
  */
 static VALUE
-rb_gst_element_set_locked_state(VALUE self, VALUE state)
+rg_set_locked_state(VALUE self, VALUE state)
 {
     gst_element_set_locked_state(SELF(self), RVAL2CBOOL(state));
     return self;
@@ -915,7 +954,7 @@ rb_gst_element_set_locked_state(VALUE self, VALUE state)
  * Returns: true if the element's state could be synced to the parent's state.
  */
 static VALUE
-rb_gst_element_sync_state_with_parent(VALUE self)
+rg_sync_state_with_parent(VALUE self)
 {
     return
         CBOOL2RVAL(gst_element_sync_state_with_parent(SELF(self)));
@@ -934,14 +973,14 @@ rb_gst_element_sync_state_with_parent(VALUE self)
  * Returns: self.
  */
 static VALUE
-rb_gst_element_no_more_pads(VALUE self)
+rg_no_more_pads(VALUE self)
 {
     gst_element_no_more_pads(SELF(self));
     return self;
 }
 
-static VALUE 
-rb_gst_element_found_tag_sig(guint num, const GValue *values)
+static VALUE
+rb_gst_element_found_tag_sig(G_GNUC_UNUSED guint n, const GValue *values)
 {
     GstElement *element, *source;
     GstTagList *tag_list;
@@ -963,13 +1002,15 @@ initialize_thread_pool(GThreadPool **pool, GFunc function)
 
     *pool = g_thread_pool_new(function, NULL, -1, FALSE, &error);
     if (error)
-	RAISE_GERROR(error);
+        RAISE_GERROR(error);
 }
 
 void
-Init_gst_element(void)
+Init_gst_element(VALUE mGst)
 {
+    memset(&table, 0, sizeof(table));
     table.type = GST_TYPE_ELEMENT;
+    table.klass = Qnil;
     table.instance2robj = instance2robj;
     RG_DEF_CONVERSION(&table);
 
@@ -980,59 +1021,53 @@ Init_gst_element(void)
     initialize_thread_pool(&query_thread_pool, query_in_thread);
     initialize_thread_pool(&send_event_thread_pool, send_event_in_thread);
 
-    rb_cGstElement = G_DEF_CLASS(GST_TYPE_ELEMENT, "Element", mGst);
-
-    rb_define_singleton_method(rb_cGstElement, "get_pad_template",
-                               rb_gst_element_get_pad_template, 1);
-    rb_define_singleton_method(rb_cGstElement, "pad_templates",
-                               rb_gst_element_get_pad_templates, 0);
-    rb_define_singleton_method(rb_cGstElement, "each_pad_template",
-                               rb_gst_element_each_pad_template, 0);
-
-    rb_define_method(rb_cGstElement, "set_state", rb_gst_element_set_state, 1);
-    rb_define_method(rb_cGstElement, "get_state", rb_gst_element_get_state, -1);
-    rb_define_method(rb_cGstElement, "stop", rb_gst_element_stop, 0);
-    rb_define_method(rb_cGstElement, "ready", rb_gst_element_ready, 0);
-    rb_define_method(rb_cGstElement, "pause", rb_gst_element_pause, 0);
-    rb_define_method(rb_cGstElement, "play", rb_gst_element_play, 0);
-    rb_define_method(rb_cGstElement, "link", rb_gst_element_link, 1);
-    rb_define_alias(rb_cGstElement, ">>", "link");
-    rb_define_method(rb_cGstElement, "unlink", rb_gst_element_unlink, 1);
-    rb_define_method(rb_cGstElement, "link_filtered", rb_gst_element_link_filtered, 2);
-    rb_define_method(rb_cGstElement, "provides_clock?", rb_gst_element_provides_clock, 0);
-    rb_define_alias(rb_cGstElement, "provide_clock?", "provides_clock?");
-    rb_define_method(rb_cGstElement, "requires_clock?", rb_gst_element_requires_clock, 0);
-    rb_define_alias(rb_cGstElement, "require_clock?", "requires_clock?");
-    rb_define_method(rb_cGstElement, "clock", rb_gst_element_get_clock, 0);
-    rb_define_method(rb_cGstElement, "set_clock", rb_gst_element_set_clock, 1);
-    rb_define_method(rb_cGstElement, "base_time", rb_gst_element_get_base_time, 0);
-    rb_define_method(rb_cGstElement, "set_base_time", rb_gst_element_set_base_time, 1);
-    rb_define_method(rb_cGstElement, "each_pad", rb_gst_element_each_pad, 0);
-    rb_define_method(rb_cGstElement, "pads", rb_gst_element_get_pads, 0);
-    rb_define_method(rb_cGstElement, "get_pad", rb_gst_element_get_pad, 1);
-    rb_define_alias(rb_cGstElement, "[]", "get_pad");
-    rb_define_method(rb_cGstElement, "get_static_pad", rb_gst_element_get_static_pad, 1);
-    rb_define_method(rb_cGstElement, "get_request_pad", rb_gst_element_get_request_pad, 1);
-    rb_define_method(rb_cGstElement, "release_request_pad",
-                     rb_gst_element_release_request_pad, 1);
-    rb_define_method(rb_cGstElement, "link_pads", rb_gst_element_link_pads, 3);
-    rb_define_method(rb_cGstElement, "unlink_pads", rb_gst_element_unlink_pads, 3);
-    rb_define_method(rb_cGstElement, "add_pad", rb_gst_element_add_pad, 1);
-    rb_define_method(rb_cGstElement, "remove_pad", rb_gst_element_remove_pad, 1);
-    rb_define_method(rb_cGstElement, "indexable?", rb_gst_element_is_indexable, 0);
-    rb_define_method(rb_cGstElement, "query", rb_gst_element_query, 1);
-    rb_define_method(rb_cGstElement, "send_event", rb_gst_element_send_event, 1);
-    rb_define_method(rb_cGstElement, "seek", rb_gst_element_seek, 7);
-    rb_define_method(rb_cGstElement, "index", rb_gst_element_get_index, 0);
-    rb_define_method(rb_cGstElement, "set_index", rb_gst_element_set_index, 1);
-    rb_define_method(rb_cGstElement, "locked_state?", rb_gst_element_is_locked_state, 0);
-    rb_define_method(rb_cGstElement, "set_locked_state", rb_gst_element_set_locked_state,
-                     1);
-    rb_define_method(rb_cGstElement, "sync_state_with_parent",
-                     rb_gst_element_sync_state_with_parent, 0);
-    rb_define_method(rb_cGstElement, "no_more_pads", rb_gst_element_no_more_pads, 0);
-
-    G_DEF_SETTERS(rb_cGstElement);
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(GST_TYPE_ELEMENT, "Element", mGst);
+
+    RG_DEF_SMETHOD(get_pad_template, 1);
+    RG_DEF_SMETHOD(pad_templates, 0);
+    RG_DEF_SMETHOD(each_pad_template, 0);
+
+    RG_DEF_METHOD(set_state, 1);
+    RG_DEF_METHOD(get_state, -1);
+    RG_DEF_METHOD(stop, 0);
+    RG_DEF_METHOD(ready, 0);
+    RG_DEF_METHOD(pause, 0);
+    RG_DEF_METHOD(play, 0);
+    RG_DEF_METHOD(link, 1);
+    RG_DEF_ALIAS(">>", "link");
+    RG_DEF_METHOD(unlink, 1);
+    RG_DEF_METHOD(link_filtered, 2);
+    RG_DEF_METHOD_P(provides_clock, 0);
+    RG_DEF_ALIAS("provide_clock?", "provides_clock?");
+    RG_DEF_METHOD_P(requires_clock, 0);
+    RG_DEF_ALIAS("require_clock?", "requires_clock?");
+    RG_DEF_METHOD(clock, 0);
+    RG_DEF_METHOD(set_clock, 1);
+    RG_DEF_METHOD(base_time, 0);
+    RG_DEF_METHOD(set_base_time, 1);
+    RG_DEF_METHOD(each_pad, 0);
+    RG_DEF_METHOD(pads, 0);
+    RG_DEF_METHOD(get_pad, 1);
+    RG_DEF_ALIAS("[]", "get_pad");
+    RG_DEF_METHOD(get_static_pad, 1);
+    RG_DEF_METHOD(get_request_pad, 1);
+    RG_DEF_METHOD(release_request_pad, 1);
+    RG_DEF_METHOD(link_pads, 3);
+    RG_DEF_METHOD(unlink_pads, 3);
+    RG_DEF_METHOD(add_pad, 1);
+    RG_DEF_METHOD(remove_pad, 1);
+    RG_DEF_METHOD_P(indexable, 0);
+    RG_DEF_METHOD(query, 1);
+    RG_DEF_METHOD(send_event, 1);
+    RG_DEF_METHOD(seek, 7);
+    RG_DEF_METHOD(index, 0);
+    RG_DEF_METHOD(set_index, 1);
+    RG_DEF_METHOD_P(locked_state, 0);
+    RG_DEF_METHOD(set_locked_state, 1);
+    RG_DEF_METHOD(sync_state_with_parent, 0);
+    RG_DEF_METHOD(no_more_pads, 0);
+
+    G_DEF_SETTERS(RG_TARGET_NAMESPACE);
 
     G_DEF_CLASS(GST_TYPE_STATE, "State", mGst);
     G_DEF_CONSTANTS(mGst, GST_TYPE_STATE, "GST_");
@@ -1040,14 +1075,14 @@ Init_gst_element(void)
     G_DEF_CONSTANTS(mGst, GST_TYPE_STATE_CHANGE_RETURN, "GST_");
     G_DEF_CLASS(GST_TYPE_STATE_CHANGE, "StateChange", mGst);
     G_DEF_CONSTANTS(mGst, GST_TYPE_STATE_CHANGE, "GST_");
-    G_DEF_CLASS(GST_TYPE_ELEMENT_FLAGS, "Flags", rb_cGstElement);
-    G_DEF_CONSTANTS(rb_cGstElement, GST_TYPE_ELEMENT_FLAGS, "GST_ELEMENT_");
+    G_DEF_CLASS(GST_TYPE_ELEMENT_FLAGS, "Flags", RG_TARGET_NAMESPACE);
+    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GST_TYPE_ELEMENT_FLAGS, "GST_ELEMENT_");
 
     /*
      * TODO:
      * gst_element_clock_wait() 
      */
 
-    G_DEF_SIGNAL_FUNC(rb_cGstElement, "found-tag", 
+    G_DEF_SIGNAL_FUNC(RG_TARGET_NAMESPACE, "found-tag", 
                       (GValToRValSignalFunc)rb_gst_element_found_tag_sig);
 }