gstreamer 0.90.6

data/ext/gstreamer/rbgstclockentry.c

@@ -0,0 +1,268 @@
+/*
+ * 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::ClockEntry
+ * A wrapper for GstClockID, used to create and start timers
+ * on Gst::Clock objects.
+ */
+
+static GstClockEntry *
+clock_entry_copy (const GstClockEntry * clock_entry)
+{
+    GstClockEntry *new_clock_entry;
+
+    g_return_val_if_fail (clock_entry != NULL, NULL);
+    new_clock_entry = g_new (GstClockEntry, sizeof (GstClockEntry));
+    *new_clock_entry = *clock_entry;
+    return new_clock_entry;
+}
+
+GType
+gst_clock_entry_get_type (void)
+{
+    static GType our_type = 0;
+
+    if (our_type == 0) {
+        our_type = g_boxed_type_register_static ("GstClockID",
+                                                 (GBoxedCopyFunc)
+                                                 clock_entry_copy,
+                                                 (GBoxedFreeFunc) g_free);
+    }
+    return our_type;
+}
+
+/*
+ * Class method: new(clock, time, interval=nil)
+ * clock: a Gst::Clock.
+ * time: a time period, in nanoseconds.
+ * interval: an interval period, in nanoseconds.
+ *
+ * Creates a new Gst::ClockEntry object based on the given Gst::Clock.
+ *
+ * Two types of Gst::ClockEntry objects can be created:
+ *
+ * * One-shot: if the interval is ommited or nil, the entry will trigger a single shot notification, at the requested time (in nanoseconds);
+ * * Periodic: if the interval is not nil, the timer entry will trigger a periodic notification, starting at time (in nanoseconds), and be fired with the given interval (also in nanoseconds).
+ * 
+ * The timer will be issued after Gst::ClockEntry#wait or
+ * Gst::ClockEntry#wait_async.
+ *
+ * Returns: a new Gst::ClockEntry object.
+ */
+static VALUE
+rb_gst_clock_entry_new (int argc, VALUE * argv, VALUE self)
+{
+    VALUE clock, time, interval;
+    GstClockID id;
+
+    rb_scan_args (argc, argv, "21", &clock, &time, &interval);
+
+    /*
+     * Single-shot 
+     */
+    if (NIL_P (interval))
+        id = gst_clock_new_single_shot_id (RVAL2GST_CLOCK (clock), NUM2ULL (time));
+    /*
+     * Periodic 
+     */
+    else
+        id = gst_clock_new_periodic_id (RVAL2GST_CLOCK (clock),
+                                        NUM2ULL (time), NUM2ULL (interval));
+
+    G_INITIALIZE (self, GST_CLOCK_ENTRY (id));
+    return Qnil;
+}
+
+/* Method: single_shot?
+ * Returns: true if the entry is single-shot, false otherwise.
+ */
+static VALUE
+rb_gst_clock_entry_is_single_shot (VALUE self)
+{
+    return CBOOL2RVAL (GST_CLOCK_ENTRY_TYPE (RGST_CLOCK_ENTRY (self)) ==
+                       GST_CLOCK_ENTRY_SINGLE);
+}
+
+/* Method: periodic?
+ * Returns: true if the entry is periodic, false otherwise.
+ */
+static VALUE
+rb_gst_clock_entry_is_periodic (VALUE self)
+{
+    return CBOOL2RVAL (GST_CLOCK_ENTRY_TYPE (RGST_CLOCK_ENTRY (self)) ==
+                       GST_CLOCK_ENTRY_PERIODIC);
+}
+
+/*
+ * Method: unschedule
+ *
+ * Cancels an outstanding async notification request.
+ *
+ * Returns: self.
+ */
+static VALUE
+rb_gst_clock_entry_unschedule (VALUE self)
+{
+    gst_clock_id_unschedule (RGST_CLOCK_ENTRY (self));
+    return self;
+}
+
+/*
+ * Method: wait
+ *
+ * Performs a blocking wait on the entry.
+ *
+ * Returns: a return code (see Gst::Clock::Return).
+ */
+static VALUE
+rb_gst_clock_entry_wait (VALUE self)
+{
+    return GENUM2RVAL (gst_clock_id_wait (RGST_CLOCK_ENTRY (self), NULL),
+                       GST_TYPE_CLOCK_RETURN);
+}
+
+struct __callback {
+    GstClockID id;
+    VALUE callback;
+};
+
+static GSList *__callbacks = NULL;
+
+static struct __callback *
+__callback_get (GstClockID id)
+{
+    GSList *i;
+
+    for (i = __callbacks; i != NULL; i = g_slist_next (i)) {
+        struct __callback *e = (struct __callback *)i->data;
+
+        if (e->id == id)
+            return e;
+    }
+    return NULL;
+}
+
+static gboolean
+__callback_dispatcher (GstClock * clock, GstClockTime time, GstClockID id,
+                       gpointer user_data)
+{
+    struct __callback *e = __callback_get (id);
+
+    g_assert (e != NULL);
+    return RVAL2CBOOL (rb_funcall (e->callback,
+                                   rb_intern ("call"),
+                                   3,
+                                   RGST_CLOCK_NEW (clock),
+                                   ULL2NUM (time), RGST_CLOCK_ENTRY_NEW (id)));
+}
+
+/*
+ * Method: wait_async { |clock, time, clock_entry| ... }
+ *
+ * Registers a block code, which will be called passing references
+ * to the Gst::Clock, the time (in nanoseconds) and the Gst::ClockEntry as
+ * parameters.
+ *
+ * Returns: a return code (see Gst::Clock::Return).
+ */
+static VALUE
+rb_gst_clock_entry_wait_async (VALUE self)
+{
+    GstClockID id = (GstClockID) RGST_CLOCK_ENTRY (self);
+
+    if (__callback_get (id) != NULL)
+        rb_raise (rb_eRuntimeError,
+                  "An asynch callback is already registred to this entry.");
+    else {
+        struct __callback *e = g_malloc (sizeof (struct __callback));
+
+        g_assert (e != NULL);
+        e->id = id;
+        e->callback = rb_block_proc ();
+        __callbacks = g_slist_append (__callbacks, e);
+        return GENUM2RVAL (INT2FIX (gst_clock_id_wait_async (id,
+                                                             __callback_dispatcher,
+                                                             NULL)),
+                           GST_TYPE_CLOCK_RETURN);
+    }
+    return Qnil;
+}
+
+/* Method: time
+ * Returns: the requested time of the entry, in nanoseconds.
+ */
+static VALUE
+rb_gst_clock_entry_get_time (VALUE self)
+{
+    return ULL2NUM (GST_CLOCK_ENTRY_TIME (RGST_CLOCK_ENTRY (self)));
+}
+
+/* Method: interval
+ * Returns: the interval of the entry (in nanoseconds), or 0 
+ * if the entry is not periodic.
+ */
+static VALUE
+rb_gst_clock_entry_get_interval (VALUE self)
+{
+    return ULL2NUM (GST_CLOCK_ENTRY_INTERVAL (RGST_CLOCK_ENTRY (self)));
+}
+
+/* Method: clock
+ * Returns: the owner clock of the entry, as a Gst::Clock object. 
+ */
+static VALUE
+rb_gst_clock_entry_get_clock (VALUE self)
+{
+    return RGST_CLOCK_NEW (GST_CLOCK_ENTRY_CLOCK (RGST_CLOCK_ENTRY (self)));
+}
+
+/* Method: status
+ * Returns: the status of the entry (see Gst::ClockEntry::Return).
+ */
+static VALUE
+rb_gst_clock_entry_get_status (VALUE self)
+{
+    return GENUM2RVAL(GST_CLOCK_ENTRY_STATUS(RGST_CLOCK_ENTRY (self)),
+                      GST_TYPE_CLOCK_RETURN);
+}
+
+void
+Init_gst_clock_entry (void)
+{
+    VALUE c = G_DEF_CLASS (GST_TYPE_CLOCK_ENTRY, "ClockEntry", mGst);
+
+    rb_define_method (c, "initialize", rb_gst_clock_entry_new, -1);
+    rb_define_method (c, "single_shot?", rb_gst_clock_entry_is_single_shot, 0);
+    rb_define_method (c, "periodic?", rb_gst_clock_entry_is_periodic, 0);
+    rb_define_method (c, "wait", rb_gst_clock_entry_wait, 0);
+    rb_define_method (c, "wait_async", rb_gst_clock_entry_wait_async, 0);
+    rb_define_method (c, "unschedule", rb_gst_clock_entry_unschedule, 0);
+    rb_define_method (c, "clock", rb_gst_clock_entry_get_clock, 0);
+    rb_define_method (c, "time", rb_gst_clock_entry_get_time, 0);
+    rb_define_method (c, "interval", rb_gst_clock_entry_get_interval, 0);
+    rb_define_method (c, "status", rb_gst_clock_entry_get_status, 0);
+
+    G_DEF_CLASS (GST_TYPE_CLOCK_ENTRY_TYPE, "Type", c);
+    G_DEF_CONSTANTS (c, GST_TYPE_CLOCK_ENTRY_TYPE, "GST_CLOCK_ENTRY_");
+    G_DEF_CLASS (GST_TYPE_CLOCK_RETURN, "Return", c);
+    G_DEF_CONSTANTS (c, GST_TYPE_CLOCK_RETURN, "GST_CLOCK_");
+}

data/ext/gstreamer/rbgstformat.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::Format
+ * Dynamically register new formats. 
+ */
+
+static GstFormat *
+format_copy (const GstFormat* format)
+{
+	GstFormat *new_format;
+	g_return_val_if_fail (format != NULL, NULL);
+	new_format = g_new (GstFormat, sizeof (GstFormat));
+	*new_format = *format;
+	return new_format;
+}
+
+GType
+gst_format_get_type2 (void)
+{
+	static GType our_type = 0;
+	if (our_type == 0)
+		our_type = g_boxed_type_register_static ("GstFormatClass",
+			(GBoxedCopyFunc)format_copy,
+			(GBoxedFreeFunc)g_free);
+	return our_type;
+}
+
+/*
+ * Class method: find(nick)
+ * nick: the nick of an existing format.
+ *
+ * Returns: a reference to the Gst::Format object registered with the
+ * given nick, or nil if this query was not registered.
+ */
+static VALUE
+rb_gst_format_find (VALUE self, VALUE nick)
+{
+	GstFormat format = gst_format_get_by_nick (RVAL2CSTR (nick));
+	return format != GST_FORMAT_UNDEFINED
+		? RGST_FORMAT_NEW (&format)
+		: Qnil;
+}
+
+/*
+ * Class method: each { |format| ... }
+ *
+ * Calls the block for each registered format, passing a reference
+ * to the Gst::Format object as parameter.
+ *
+ * Returns: always nil.
+ */
+static VALUE
+rb_gst_format_each (VALUE self)
+{
+    GstIterator *iter;
+    gpointer value;
+
+    iter = gst_format_iterate_definitions();
+    while (gst_iterator_next(iter, &value) == GST_ITERATOR_OK) {
+        GstFormatDefinition *def = (GstFormatDefinition *)value;
+        rb_yield(RGST_FORMAT_NEW(&(def->value)));
+    }
+    gst_iterator_free(iter);
+    return Qnil;
+}
+
+/* Method: type_id
+ * Returns: the type id of this format (see Gst::Format::Type).
+ */
+static VALUE
+rb_gst_format_get_type_id (VALUE self)
+{
+	GstFormat *format = RGST_FORMAT (self);
+	return GENUM2RVAL (*format, GST_TYPE_FORMAT);
+}
+
+/* Method: nick
+ * Returns: the short nick of the format.
+ */
+static VALUE
+rb_gst_format_get_nick (VALUE self)
+{
+	GstFormat *format = RGST_FORMAT (self);
+	return CSTR2RVAL (gst_format_get_details (*format)->nick);
+}
+
+/* Method: description
+ * Returns: a longer description of the format.
+ */
+static VALUE
+rb_gst_format_get_description (VALUE self)
+{
+	GstFormat *format = RGST_FORMAT (self);
+	return CSTR2RVAL (gst_format_get_details (*format)->description);
+}
+
+/*
+ * Method: ==(format)
+ * format: a Gst::Format.
+ *
+ * Checks if two Gst::Format objects are registered under the
+ * same nick.
+ *
+ * Returns: true on success, false on failure.
+ */
+static VALUE
+rb_gst_format_is_equal (VALUE self, VALUE other_format)
+{
+	GstFormat *f1, *f2;
+	gchar *n1, *n2;
+
+	if (NIL_P (other_format))
+		return Qfalse;
+
+	f1 = RGST_FORMAT (self);
+	f2 = RGST_FORMAT (other_format);
+
+	n1 = gst_format_get_details (*f1)->nick;
+	n2 = gst_format_get_details (*f2)->nick;
+
+	return CBOOL2RVAL (strcmp (n1, n2) == 0);
+}
+
+void
+Init_gst_format (void)
+{
+	VALUE c = G_DEF_CLASS (GST_TYPE_FORMAT2, "Format", mGst);
+
+	rb_define_singleton_method (c, "each", rb_gst_format_each, 0);
+	rb_define_singleton_method (c, "find", rb_gst_format_find, 1);
+
+	rb_define_method (c, "type_id", rb_gst_format_get_type_id, 0);
+	rb_define_method (c, "nick",	rb_gst_format_get_nick,	0);
+	rb_define_method (c, "description", rb_gst_format_get_description, 0);
+	rb_define_method (c, "==", rb_gst_format_is_equal, 1);
+
+	G_DEF_CLASS (GST_TYPE_FORMAT, "Type", c);
+	G_DEF_CONSTANTS (c, GST_TYPE_FORMAT, "GST_FORMAT_");
+}

data/ext/gstreamer/rbgstindex.c

@@ -0,0 +1,314 @@
+/*
+ * 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::Index
+ * Generates indexes on objects. 
+ */
+
+/* Class method: new
+ * Returns: a newly allocated Gst::Index object.
+ */
+static VALUE
+rb_gst_index_new (VALUE self)
+{
+    GstIndex *index = gst_index_new ();
+
+    if (index != NULL)
+        RBGST_INITIALIZE (self, index);
+    return Qnil;
+}
+
+/* Method: readable?
+ * Returns: whether the index can be read.
+ */
+static VALUE
+rb_gst_index_is_readable (VALUE self)
+{
+    return CBOOL2RVAL (GST_INDEX_IS_READABLE (RGST_INDEX (self)));
+}
+
+/* Method: writable?
+ * Returns: whether the index can be written.
+ */
+static VALUE
+rb_gst_index_is_writable (VALUE self)
+{
+    return CBOOL2RVAL (GST_INDEX_IS_WRITABLE (RGST_INDEX (self)));
+}
+
+/*
+ * Method: commit(id)
+ * id: the writer that committed the index.
+ *
+ * Tells the index that the writer with the given ID is done with 
+ * this index and is not going to write any more entries to it.
+ *
+ * Returns: self.
+ */
+static VALUE
+rb_gst_index_commit (VALUE self, VALUE id)
+{
+    gst_index_commit (RGST_INDEX (self), FIX2INT (id));
+    return self;
+}
+
+/* Method: group
+ * Returns: the ID of the current group.
+ */
+static VALUE
+rb_gst_index_get_group (VALUE self)
+{
+    return INT2FIX (gst_index_get_group (RGST_INDEX (self)));
+}
+
+/*
+ * Method: new_group
+ *
+ * Creates a new group for the given index.  It will be set as the current
+ * group.
+ *
+ * Returns: the ID of the newly created group.
+ */
+static VALUE
+rb_gst_index_new_group (VALUE self)
+{
+    return INT2FIX (gst_index_new_group (RGST_INDEX (self)));
+}
+
+/*
+ * Method: set_group(group)
+ * group: the number of the group to set.
+ *
+ * Sets the current group number to the given argument.
+ *
+ * Returns: true if the operation succeeded, false if the group did not exist.
+ */
+static VALUE
+rb_gst_index_set_group (VALUE self, VALUE group)
+{
+    return
+        CBOOL2RVAL (gst_index_set_group (RGST_INDEX (self), FIX2INT (group)));
+}
+
+/* Method: certainty
+ * Returns: the certainty of the index (see Gst::Index::Certainty).
+ */
+static VALUE
+rb_gst_index_get_certainty (VALUE self)
+{
+    return GENUM2RVAL (gst_index_get_certainty (RGST_INDEX (self)),
+                       GST_TYPE_INDEX_CERTAINTY);
+}
+
+/* 
+ * Method: set_certainty(certainty)
+ * certainty: the certainty to set (see Gst::Index::Certainty).
+ *
+ * Sets the certainty of the index.
+ *
+ * Returns: self.
+ */
+static VALUE
+rb_gst_index_set_certainty (VALUE self, VALUE certainty)
+{
+    gst_index_set_certainty (RGST_INDEX (self),
+                             RVAL2GENUM (certainty, GST_TYPE_INDEX_CERTAINTY));
+    return self;
+}
+
+#if 0
+static gboolean
+__filter (GstIndex * index, GstIndexEntry * entry)
+{
+
+}
+
+static VALUE
+rb_gst_index_set_filter (VALUE self)
+{
+    /*
+     * TODO 
+     */
+    return self;
+}
+
+static gboolean
+__resolver (GstIndex * index, GstObject * writer, gchar ** writer_string,
+            gpointer user_data)
+{
+    VALUE block = (VALUE) user_data;
+
+    return
+        RVAL2CBOOL (rb_funcall
+                    (block, 2, RGST_INDEX_NEW (index),
+                     RGST_OBJECT_NEW (writer)));
+}
+
+static VALUE
+rb_gst_index_set_resolver (VALUE self)
+{
+    gst_index_set_resolver (RGST_INDEX (self), __resolver,
+                            (gpointer) rb_block_proc ());
+    return self;
+}
+#endif
+
+/*
+ * Method: add(id, *args)
+ * id: the ID of the index writer.
+ * args: additional parameters, see below.
+ *
+ * Adds an entry into the index.  The type of the entry depends of
+ * the number and kind of additional parameters.
+ *
+ *	* For an ID type, args must be a String.
+ *	* For a FORMAT type, args must be a Gst::Format.
+ *	* For an ASSOCIATION type, args must contains an association flag (see Gst::Index::AssocFlags), a Gst::Format and a value for the format.
+ *	* For an OBJECT type, well you must wait, because it is not yet implemented.
+ *
+ * Returns: a reference to the newly allocated entry in the index, as a Gst::EntryIndex object.
+ */
+static VALUE
+rb_gst_index_add (int argc, VALUE * argv, VALUE self)
+{
+    GstIndexEntry *index_entry;
+    VALUE id;
+
+    if (argc == 2) {
+        VALUE var;
+
+        rb_scan_args (argc, argv, "2", &id, &var);
+
+        index_entry = CLASS2GTYPE (CLASS_OF (var)) == GST_TYPE_FORMAT2
+            ? gst_index_add_format (RGST_INDEX (self), FIX2INT (id),
+                                    *RGST_FORMAT (var))
+            : gst_index_add_id (RGST_INDEX (self), FIX2INT (id),
+                                RVAL2CSTR (var));
+
+    } else {
+        VALUE flags, format, value;
+
+        rb_scan_args (argc, argv, "4", &id, &flags, &format, &value);
+
+        index_entry =
+            gst_index_add_association (RGST_INDEX (self), FIX2INT (id),
+                                       RVAL2GFLAGS (flags,
+                                                    GST_TYPE_ASSOC_FLAGS),
+                                       *RGST_FORMAT (format), NUM2ULL (value));
+    }
+
+    return index_entry != NULL ? RGST_INDEX_ENTRY_NEW (index_entry)
+        : Qnil;
+}
+
+static gint
+__compare (gconstpointer a, gconstpointer b, gpointer user_data)
+{
+    VALUE block = (VALUE) user_data;
+
+    return
+        FIX2INT (rb_funcall
+                 (block, rb_intern ("call"), 2, RGST_INDEX_ENTRY_NEW (a),
+                  RGST_INDEX_ENTRY_NEW (b)));
+}
+
+/*
+ * Method: get_assoc_entry(id, method, flags, format, value) { ... }
+ * id: the ID of the index writer.
+ * method: the lookup method to use (see Gst::Index::LookupMethod).
+ * flags: flags for the entry (see Gst::Index::AssocFlags).
+ * format: a Gst::Format object.
+ * value: the value to find.
+ * 
+ * Finds the given format/value in the index.  If a block is given, it will be
+ * called as a compare function, passing references to 2 Gst::IndexEntry objects,
+ * and waiting for a boolean as the return value.
+ *
+ * Returns: the entry associated with the value (as a Gst::IndexEntry object), or nil 
+ * if the value is not found.
+ */
+static VALUE
+rb_gst_index_get_assoc_entry (VALUE self, VALUE id, VALUE method, VALUE flags,
+                              VALUE format, VALUE value)
+{
+    GstIndexEntry *index_entry;
+
+    if (rb_block_given_p () == Qfalse)
+        index_entry =
+            gst_index_get_assoc_entry (RGST_INDEX (self), FIX2INT (id),
+                                       RVAL2GENUM (method,
+                                                   GST_TYPE_INDEX_LOOKUP_METHOD),
+                                       RVAL2GFLAGS (flags,
+                                                    GST_TYPE_ASSOC_FLAGS),
+                                       *RGST_FORMAT (format), NUM2ULL (value));
+    else
+        index_entry =
+            gst_index_get_assoc_entry_full (RGST_INDEX (self), FIX2INT (id),
+                                            RVAL2GENUM (method,
+                                                        GST_TYPE_INDEX_LOOKUP_METHOD),
+                                            RVAL2GFLAGS (flags,
+                                                         GST_TYPE_ASSOC_FLAGS),
+                                            *RGST_FORMAT (format),
+                                            NUM2ULL (value), __compare,
+                                            (gpointer) rb_block_proc ());
+
+    return index_entry != NULL ? RGST_INDEX_ENTRY_NEW (index_entry)
+        : Qnil;
+}
+
+void
+Init_gst_index (void)
+{
+    VALUE c = G_DEF_CLASS (GST_TYPE_INDEX, "Index", mGst);
+
+    rb_define_method (c, "initialize", rb_gst_index_new, 0);
+    rb_define_method (c, "readable?", rb_gst_index_is_readable, 0);
+    rb_define_method (c, "writable?", rb_gst_index_is_writable, 0);
+    rb_define_method (c, "commit", rb_gst_index_commit, 1);
+    rb_define_method (c, "group", rb_gst_index_get_group, 0);
+    rb_define_method (c, "new_group", rb_gst_index_new_group, 0);
+    rb_define_method (c, "set_group", rb_gst_index_set_group, 1);
+    rb_define_method (c, "certainty", rb_gst_index_get_certainty, 0);
+    rb_define_method (c, "set_certainty", rb_gst_index_set_certainty, 1);
+#if 0
+    rb_define_method (c, "set_filter", rb_gst_index_set_filter, 0);
+    rb_define_method (c, "set_resolver", rb_gst_index_set_resolver, 0);
+#endif
+    rb_define_method (c, "add", rb_gst_index_add, -1);
+    rb_define_method (c, "get_assoc_entry", rb_gst_index_get_assoc_entry, 5);
+
+    G_DEF_CLASS (GST_TYPE_INDEX_CERTAINTY, "Certainty", c);
+    G_DEF_CONSTANTS (c, GST_TYPE_INDEX_CERTAINTY, "GST_INDEX_");
+    G_DEF_CLASS (GST_TYPE_INDEX_LOOKUP_METHOD, "LookupMethod", c);
+    G_DEF_CONSTANTS (c, GST_TYPE_INDEX_LOOKUP_METHOD, "GST_INDEX_");
+    G_DEF_CLASS (GST_TYPE_ASSOC_FLAGS, "AssocFlags", c);
+    G_DEF_CONSTANTS (c, GST_TYPE_ASSOC_FLAGS, "GST_");
+    G_DEF_CLASS (GST_TYPE_INDEX_RESOLVER_METHOD, "ResolverMethod", c);
+    G_DEF_CONSTANTS (c, GST_TYPE_INDEX_RESOLVER_METHOD, "GST_INDEX_");
+    G_DEF_CLASS (GST_TYPE_INDEX_FLAGS, "Flags", c);
+    G_DEF_CONSTANTS (c, GST_TYPE_INDEX_FLAGS, "GST_INDEX_");
+
+    G_DEF_SETTERS (c);
+
+    rb_undef_method (c, "resolver");
+    rb_undef_method (c, "resolver=");
+}