gstreamer 1.1.0-x86-mingw32

data/README

@@ -0,0 +1,33 @@
+Ruby/GStreamer
+==============
+
+Ruby/GStreamer is a Ruby binding for GStreamer.
+
+Requirements
+------------
+
+    Ruby:       http://www.ruby-lang.org/
+    GStreamer:  http://gstreamer.freedesktop.org/
+
+Install
+-------
+
+    0. install Ruby (>= 1.8.x) and GStreamer (>= 0.10.x).
+    1. ruby extconf.rb
+    2. make
+    3. su
+    4. make install
+
+Copying
+-------
+
+    Copyright (c) 2002-2005 Ruby-GNOME2 Project Team
+
+    This program is free software.
+    You can distribute/modify this program under the terms of
+    the GNU LESSER GENERAL PUBLIC LICENSE Version 2.1.
+
+Project Website
+---------------
+
+    http://ruby-gnome2.sourceforge.jp

data/Rakefile

@@ -0,0 +1,213 @@
+# -*- ruby -*-
+
+require './../glib2/lib/gnome2-raketask'
+require 'open-uri'
+
+package = GNOME2Package.new do |_package|
+  _package.summary = "Ruby/GStreamer is a Ruby binding for GStreamer."
+  _package.description = "Ruby/GStreamer is a Ruby binding for GStreamer."
+  _package.dependency.gem.runtime = ["glib2"]
+  _package.win32.packages = ["libsoup"]
+  _package.win32.dependencies = ["jpeg", "libxml2"]
+  _package.post_install_message = "This library is experimental."
+  _package.cross_compiling do |spec|
+    if /mingw|mswin/ =~ spec.platform.to_s
+      spec.add_runtime_dependency("cairo", ">= 1.10.1")
+      spec.add_runtime_dependency("pango", ">= #{_package.version}")
+      spec.add_runtime_dependency("gdk_pixbuf2", ">= #{_package.version}")
+    end
+  end
+end
+package.define_tasks
+
+namespace :win32 do
+  host = "i686-w64-mingw32"
+
+  dist_dir = Pathname.new("vendor/local").expand_path
+  license_dir = dist_dir + "share" + "license"
+  tmp_dir = Pathname.new("tmp").expand_path
+  download_dir = tmp_dir + "download"
+
+  rcairo_win32_path = ENV["RCAIRO_WIN32_PATH"] || "../../rcairo.win32"
+  rcairo_win32_path = File.expand_path(rcairo_win32_path)
+  rcairo_win32_include_path = "#{rcairo_win32_path}/vendor/local/include"
+  rcairo_win32_lib_path = "#{rcairo_win32_path}/vendor/local/lib"
+
+  xiph_download_url_base = "http://downloads.xiph.org/releases"
+  freedesktop_download_url_base = "http://gstreamer.freedesktop.org/src"
+  packages = [
+    {
+      :name => "libogg",
+      :download_base_url => "#{xiph_download_url_base}/ogg",
+      :label => "Ogg",
+      :version => "1.3.0",
+      :configure_args => [],
+    },
+    {
+      :name => "libvorbis",
+      :download_base_url => "#{xiph_download_url_base}/vorbis",
+      :label => "Vorbis",
+      :version => "1.3.2",
+      :configure_args => [],
+    },
+    {
+      :name => "libtheora",
+      :download_base_url => "#{xiph_download_url_base}/theora",
+      :label => "Theora",
+      :version => "1.1.1",
+      :configure_args => [],
+    },
+    # {
+    #   :name => "flac",
+    #   :download_base_url => "#{xiph_download_url_base}/flac",
+    #   :label => "FLAC",
+    #   :version => "1.2.1",
+    #   :configure_args => ["--disable-cpplibs"],
+    # },
+    {
+      :name => "speex",
+      :download_base_url => "#{xiph_download_url_base}/speex",
+      :label => "Speex",
+      :version => "1.2rc1",
+      :configure_args => [],
+    },
+    {
+      :name => "gstreamer",
+      :download_base_url => "#{freedesktop_download_url_base}/gstreamer",
+      :label => "GStreamer",
+      :version => "0.10.35",
+      :configure_args => ["--enable-check"],
+    },
+    {
+      :name => "gst-plugins-base",
+      :download_base_url => "#{freedesktop_download_url_base}/gst-plugins-base",
+      :label => "GStreamer plugins (base)",
+      :version => "0.10.35",
+      :configure_args => ["--disable-gnome_vfs"],
+    },
+    {
+      :name => "gst-plugins-good",
+      :download_base_url => "#{freedesktop_download_url_base}/gst-plugins-good",
+      :label => "GStreamer plugins (good)",
+      :version => "0.10.30",
+      :configure_args => ["--disable-gconf"],
+    },
+    {
+      :name => "gst-plugins-bad",
+      :download_base_url => "#{freedesktop_download_url_base}/gst-plugins-bad",
+      :label => "GStreamer plugins (bad)",
+      :version => "0.10.22",
+      :configure_args => ["--disable-librfb"],
+    },
+    {
+      :name => "gst-ffmpeg",
+      :download_base_url => "#{freedesktop_download_url_base}/gst-ffmpeg",
+      :label => "GStreamer ffmpeg",
+      :version => "0.10.12",
+      :configure_args => ["--with-ffmpeg-extra-configure=" +
+                            "--cross-prefix=#{host}- " +
+                            "--target-os=mingw32 " +
+                            "--arch=i686 " +
+                            "--pkg-config=pkg-config"],
+      :bundled_packages => [
+        {
+          :name => "libav",
+          :path => "gst-libs/ext/libav",
+          :license_files => ["LICENSE", "CREDITS",
+                             "COPYING.GPLv2", "COPYING.GPLv3",
+                             "COPYING.LGPLv2.1", "COPYING.LGPLv3"],
+        }
+      ],
+    },
+  ]
+
+  namespace :download do
+    packages.each do |_package|
+      base = "#{_package[:name]}-#{_package[:version]}"
+      tar_gz = "#{base}.tar.gz"
+      tar_gz_url = "#{_package[:download_base_url]}/#{tar_gz}"
+      tar_gz_full_path = download_dir + tar_gz
+
+      desc "Download #{_package[:label]} into #{download_dir}."
+      task _package[:name] => tar_gz_full_path.to_s
+
+      directory_path = tar_gz_full_path.dirname
+      directory directory_path.to_s
+      file tar_gz_full_path.to_s => directory_path.to_s do
+        rake_output_message "downloading... #{tar_gz_url}"
+        open(tar_gz_url) do |downloaded_tar_gz|
+          tar_gz_full_path.open("wb") do |tar_gz_file|
+            tar_gz_file.print(downloaded_tar_gz.read)
+          end
+        end
+      end
+    end
+  end
+
+  namespace :build do
+    task :prepare do
+      depended_packages = ["glib2", "atk", "pango", "gdk_pixbuf2", "gtk2"]
+      pkg_config_path = (["gstreamer"] + depended_packages).collect do |_package|
+        "../#{_package}/vendor/local/lib/pkgconfig"
+      end
+      ENV["PKG_CONFIG_PATH"] = pkg_config_path.collect do |path|
+        File.expand_path(path)
+      end.join(":")
+      ENV["PKG_CONFIG_LIBDIR"] = "#{rcairo_win32_path}/vendor/local/lib/pkgconfig"
+    end
+
+    packages.each do |_package|
+      desc "Build #{_package[:label]} and install it into #{dist_dir}."
+      task _package[:name] => [:prepare, "win32:download:#{_package[:name]}"] do
+        package_tmp_dir = tmp_dir + _package[:name]
+        rm_rf(package_tmp_dir)
+        mkdir_p(package_tmp_dir)
+
+        base = "#{_package[:name]}-#{_package[:version]}"
+        tar_gz = "#{base}.tar.gz"
+        tar_gz_full_path = download_dir + tar_gz
+        Dir.chdir(package_tmp_dir.to_s) do
+          sh("tar", "xzf", tar_gz_full_path.to_s) or exit(false)
+        end
+
+        Dir.chdir((package_tmp_dir + base).to_s) do
+          sh("./configure",
+             "CPPFLAGS=-I#{rcairo_win32_include_path} -I#{dist_dir + 'include'}",
+             "LDFLAGS=-L#{rcairo_win32_lib_path} -L#{dist_dir + 'lib'}",
+             "--prefix=#{dist_dir}",
+             "--host=#{host}",
+             *_package[:configure_args]) or exit(false)
+          common_make_args = []
+          common_make_args << "GLIB_COMPILE_SCHEMAS=glib-compile-schemas"
+          build_make_args = common_make_args.dup
+          install_make_args = common_make_args.dup
+          make_n_jobs = ENV["MAKE_N_JOBS"]
+          build_make_args << "-j#{make_n_jobs}" if make_n_jobs
+          ENV["GREP_OPTIONS"] = "--text"
+          sh("nice", "make", *build_make_args) or exit(false)
+          sh("make", "install", *install_make_args) or exit(false)
+
+          package_license_dir = license_dir + _package[:name]
+          mkdir_p(package_license_dir)
+          package_license_files = ["AUTHORS", "COPYING", "COPYING.LIB"]
+          package_license_files = package_license_files.reject do |file|
+            not File.exist?(file)
+          end
+          cp(package_license_files, package_license_dir)
+          bundled_packages = _package[:bundled_packages] || []
+          bundled_packages.each do |bundled_package|
+            bundled_package_license_dir = license_dir + bundled_package[:name]
+            mkdir_p(bundled_package_license_dir)
+            license_files = bundled_package[:license_files].collect do |file|
+              File.join(bundled_package[:path], file)
+            end
+            cp(license_files, bundled_package_license_dir)
+          end
+        end
+      end
+    end
+  end
+
+  desc "Build GStreamer binaries"
+  task :build => packages.collect {|_package| "win32:build:#{_package[:name]}"}
+end

data/ext/gstreamer/depend

@@ -0,0 +1,5 @@
+install:
+	if test -n "$(pkgconfigdir)"; then			\
+	  $(MAKEDIRS) $(pkgconfigdir);				\
+	  $(INSTALL_DATA) ruby-gstreamer.pc $(pkgconfigdir);	\
+	fi

data/ext/gstreamer/extconf.rb

@@ -0,0 +1,69 @@
+=begin
+extconf.rb for Ruby/GStreamer extention library
+=end
+
+require 'pathname'
+
+base_dir = Pathname(__FILE__).dirname.parent.parent.expand_path
+top_dir = base_dir.parent
+top_build_dir = Pathname(".").parent.parent.parent.expand_path
+
+mkmf_gnome2_dir = top_dir + "glib2" + 'lib'
+version_suffix = ""
+unless mkmf_gnome2_dir.exist?
+  if /(-\d+\.\d+\.\d+)\z/ =~ base_dir.basename.to_s
+    version_suffix = $1
+    mkmf_gnome2_dir = top_dir + "glib2#{version_suffix}" + 'lib'
+  end
+end
+
+$LOAD_PATH.unshift(mkmf_gnome2_dir.to_s)
+
+module_name = "gstreamer"
+package_id = "gstreamer-0.10"
+
+begin
+  require 'mkmf-gnome2'
+rescue LoadError
+  require 'rubygems'
+  gem 'glib2'
+  require 'mkmf-gnome2'
+end
+
+["glib2"].each do |package|
+  directory = "#{package}#{version_suffix}"
+  build_dir = "#{directory}/tmp/#{RUBY_PLATFORM}/#{package}/#{RUBY_VERSION}"
+  add_depend_package(package, "#{directory}/ext/#{package}",
+                     top_dir.to_s,
+                     :top_build_dir => top_build_dir.to_s,
+                     :target_build_dir => build_dir)
+end
+
+setup_win32(module_name, base_dir)
+
+PKGConfig.have_package(package_id) or exit 1
+PKGConfig.have_package('gstreamer-plugins-base-0.10') or exit 1
+
+have_header("unistd.h")
+have_header("io.h")
+
+if have_library("gstinterfaces-0.10") and
+    have_header("gst/interfaces/xoverlay.h")
+  $CFLAGS += " -DHAVE_GST_OVERLAY"
+end
+
+if PKGConfig.have_package("gstreamer-pbutils-0.10")
+  $CFLAGS += " -DHAVE_GST_PBUTILS"
+end
+
+create_pkg_config_file("Ruby/GStreamer", package_id)
+$defs << "-DRUBY_GST_COMPILATION"
+create_makefile(module_name)
+pkg_config_dir = with_config("pkg-config-dir")
+if pkg_config_dir.is_a?(String)
+  File.open("Makefile", "ab") do |makefile|
+    makefile.puts
+    makefile.puts("pkgconfigdir=#{pkg_config_dir}")
+  end
+end
+

data/ext/gstreamer/misc.c

@@ -0,0 +1,63 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  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-private.h"
+
+VALUE
+rb_str_new_with_format (char *fmt, ...)
+{
+	char buf[1000];
+	va_list ap;
+
+	va_start (ap, fmt);
+	vsnprintf (buf, sizeof buf, fmt, ap);
+	va_end (ap);
+	return CSTR2RVAL (buf);
+}
+
+VALUE
+rb_ary_yield (VALUE arr)
+{
+	if (rb_block_given_p () == Qfalse)
+		rb_raise (rb_eArgError, "No block given");
+	rb_ary_each (arr); 
+	return Qnil;
+}
+
+VALUE
+rbgst_new_gstobject (void *o)
+{
+	GType gtype = G_OBJECT_TYPE (o);
+	const gchar *gtypename = g_type_name (gtype);
+        if (strncmp (gtypename, "Gst", 3) == 0)
+            gtypename += 3;
+        if (!rb_const_defined_at (mGst, rb_intern (gtypename)))
+            G_DEF_CLASS (gtype, gtypename, mGst);
+	return GOBJ2RVAL (o);
+}
+
+void
+rbgst_initialize_gstobject(VALUE obj, GstObject *gstobj)
+{
+	gstobj = gst_object_ref (gstobj);
+	gst_object_sink (gstobj);
+	G_INITIALIZE (obj, gstobj);
+}

data/ext/gstreamer/rbgst-bin.c

@@ -0,0 +1,458 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2003, 2004 Laurent Sansonetti <lrz@gnome.org>
+ *                      2004 Erwan Loisant <erwan@loisant.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-private.h"
+
+#define RG_TARGET_NAMESPACE cBin
+#define SELF(self) RVAL2GST_BIN(self)
+
+/* Class: Gst::Bin
+ * Base container element.
+ */
+
+/*
+ * Class method: new(name=nil)
+ * name: a name for the bin.
+ *
+ * Constructs a new Gst::Bin object.
+ *
+ * If element name is ommited (or nil), then the bin will receive a guaranteed
+ * unique name, consisting of the "bin" string and a number.
+ * If name is given, it will be given the name supplied.
+ *
+ * Returns: a newly allocated Gst::Bin object.
+ */
+static VALUE
+rg_initialize(int argc, VALUE *argv, VALUE self)
+{
+    GstElement *bin;
+    VALUE name;
+
+    rb_scan_args(argc, argv, "01", &name);
+
+    bin = gst_bin_new(RVAL2CSTR_ACCEPT_NIL(name));
+    if (bin)
+        RBGST_INITIALIZE(self, bin);
+    return Qnil;
+}
+
+/*
+ * Method: size
+ *
+ * Returns: the number of elements in the container.
+ */
+static VALUE
+rg_size(VALUE self)
+{
+    return INT2NUM(GST_BIN_NUMCHILDREN(SELF(self)));
+}
+
+/*
+ * Method: children(interface=nil)
+ * interface: an interface (Ruby class).
+ *
+ * Returns: If interface is nil, an array of all
+ * Gst::Element objects in the container. Otherwise, an
+ * array of Gst::Element objects in the container that
+ * implements the interface.
+ */
+static VALUE
+rg_children(int argc, VALUE *argv, VALUE self)
+{
+    VALUE children, iface;
+
+    rb_scan_args(argc, argv, "01", &iface);
+
+    if (NIL_P(iface)) {
+        const GList *node;
+        children = rb_ary_new();
+        for (node = GST_BIN_CHILDREN(SELF(self));
+             node;
+             node = g_list_next(node)) {
+            rb_ary_push(children, GST_ELEMENT2RVAL(node->data));
+        }
+    } else {
+        GstIterator *iter;
+        iter = gst_bin_iterate_all_by_interface(SELF(self),
+                                                CLASS2GTYPE(iface));
+        children = _rbgst_collect_elements(iter);
+    }
+
+    return children;
+}
+
+/*
+ * Method: children_recurse()
+ *
+ * Returns: an array of all Gst::Element objects in the container and child
+ * bins.
+ */
+static VALUE
+rg_children_recurse(VALUE self)
+{
+   GstIterator *iter;
+   VALUE children;
+
+   iter = gst_bin_iterate_recurse(SELF(self));
+   children = _rbgst_collect_elements(iter);
+
+    return children;
+}
+
+static VALUE
+rg_children_cookie(VALUE self)
+{
+    return UINT2NUM(GST_BIN_CHILDREN_COOKIE(SELF(self)));
+}
+
+static VALUE
+rg_child_bus(VALUE self)
+{
+    return GST_BUS2RVAL(SELF(self)->child_bus);
+}
+
+static VALUE
+rg_messages(VALUE self)
+{
+    GList *node;
+    VALUE messages;
+
+    messages = rb_ary_new();
+    for (node = SELF(self)->messages; node; node = g_list_next(node)) {
+        rb_ary_push(messages, GST_MSG2RVAL(node->data));
+    }
+
+    return messages;
+}
+
+static VALUE
+rg_polling_p(VALUE self)
+{
+    return CBOOL2RVAL(SELF(self)->polling);
+}
+
+static VALUE
+rg_clock_dirty_p(VALUE self)
+{
+    return CBOOL2RVAL(SELF(self)->clock_dirty);
+}
+
+/*
+ * Method: provided_clock
+ *
+ * Gets the current clock of the (scheduler of the) bin,
+ * as a Gst::Clock object.
+ *
+ * Returns: a Gst::Clock object, or nil.
+ */
+static VALUE
+rg_provided_clock(VALUE self)
+{
+    return GST_CLOCK2RVAL(SELF(self)->provided_clock);
+}
+
+/*
+ * Method: provided_clock=(clock)
+ * clock: a Gst::Clock.
+ *
+ * Forces the bin to use the given clock.  Use nil to force it 
+ * to use no clock at all.
+ *
+ * Returns: self.
+ */
+static VALUE
+rg_set_provided_clock(VALUE self, VALUE clock)
+{
+    GstBin *bin;
+
+    bin = SELF(self);
+    if (bin->provided_clock)
+        g_object_unref(bin->provided_clock);
+
+    bin->provided_clock = RVAL2GST_CLOCK(clock);
+    if (bin->provided_clock)
+        g_object_ref(bin->provided_clock);
+
+    return self;
+}
+
+static VALUE
+rg_clock_provider(VALUE self)
+{
+    return GST_ELEMENT2RVAL(SELF(self)->clock_provider);
+}
+
+/*
+ * Method: <<(element)
+ * element: a Gst::Element object.
+ *
+ * Adds a Gst::Element object to the bin.
+ *
+ * Returns: self.
+ */
+static VALUE
+rg_operator_add(VALUE self, VALUE element)
+{
+    VALUE klass = GTYPE2CLASS(GST_TYPE_ELEMENT);
+
+    if (!RVAL2CBOOL(rb_obj_is_kind_of(element, klass))) {
+        rb_raise(rb_eTypeError, "Gst::Element expected");
+    }
+    gst_bin_add(SELF(self), RVAL2GST_ELEMENT(element));
+    G_CHILD_ADD(self, element);
+    return self;
+}
+
+/*
+ * Method: add(*elements)
+ * elements: a list of Gst::Element objects.
+ *
+ * Adds one or more Gst::Element objects to the bin.
+ *
+ * Returns: nil.
+ */
+static VALUE
+rg_add(int argc, VALUE *argv, VALUE self)
+{
+    int i;
+
+    for (i = 0; i < argc; i++) {
+        rg_operator_add(self, argv[i]);
+    }
+    return Qnil;
+}
+
+/*
+ * Method: remove(*elements)
+ * elements: a list of Gst::Element objects.
+ *
+ * Removes one or more Gst::Element objects from the bin, unparenting 
+ * as well.
+ *
+ * Returns: nil.
+ */
+static VALUE
+rg_remove(int argc, VALUE *argv, VALUE self)
+{
+    int i;
+    GstBin *bin;
+
+    bin = SELF(self);
+    for (i = 0; i < argc; i++) {
+        G_CHILD_REMOVE(self, argv[i]);
+        gst_bin_remove(bin, RVAL2GST_ELEMENT(argv[i]));
+    }
+    return Qnil;
+}
+
+/*
+ * Method: clear
+ *
+ * Removes all Gst::Element objects in the bin.
+ *
+ * Returns: nil.
+ */
+static VALUE
+rg_clear(VALUE self)
+{
+    GstBin *bin;
+    GList *node, *children;
+
+    bin = SELF(self);
+    children = g_list_copy(GST_BIN_CHILDREN(bin));
+    for (node = children; node; node = g_list_next(node)) {
+        gst_bin_remove(bin, node->data);
+    }
+    g_list_free(children);
+    return Qnil;
+}
+
+/*
+ * Method: each(interface=nil) {|element| ...}
+ *
+ * Calls the block for each element in the bin, passing a reference to
+ * the Gst::Element as parameter. If the interface isn't nil,
+ * iterated elements should implement the interface.
+ *
+ * Returns: always nil.
+ */
+static VALUE
+rg_each(int argc, VALUE *argv, VALUE self)
+{
+    return rb_ary_yield(rg_children(argc, argv, self));
+}
+
+/*
+ * Method: each_recurse() {|element| ...}
+ *
+ * Calls the block for each element in the bin and its child bins, passing a
+ * reference to the Gst::Element as parameter. 
+ *
+ * Returns: always nil.
+ */
+static VALUE
+rg_each_recurse(VALUE self)
+{
+    return rb_ary_yield(rg_children_recurse(self));
+}
+
+/*
+ * Method: get_child(index)
+ * Method: get_child(name, recurse=false)
+ * Method: get_child(interface)
+ * index: an index.
+ * name: a name.
+ * recurse: search recursively.
+ * interface: an interface (Ruby class).
+ *
+ * 1st: Gets the index-th element.
+ *
+ * 2nd: Gets the element with the given name from the
+ * bin, as a reference to a Gst::Element object. If the
+ * element is not found and recurse is true, a recursion is
+ * performed on the parent bin.
+ *
+ * 3nd: Looks for the first element inside the bin that implements the
+ * given interface. If such an element is found, it returns the element.
+ * If you want all elements that implement the interface, use
+ * Gst::Bin#get_all_by_interface. The method recurses bins inside bins.
+ *
+ * Returns: a Gst::Element reference, or nil if the bin does not contain
+ * an element with the given name nor implementing the interface.
+ */
+static VALUE
+rg_get_child(int argc, VALUE *argv, VALUE self)
+{
+    VALUE index_or_name_or_interface, recurse;
+    GstElement *element = NULL;
+
+    rb_scan_args(argc, argv, "11", &index_or_name_or_interface, &recurse);
+
+    if (RVAL2CBOOL(rb_obj_is_kind_of(index_or_name_or_interface, rb_cInteger))) {
+        int index;
+        GList *node;
+        index = NUM2INT(index_or_name_or_interface);
+        node = g_list_nth(GST_BIN_CHILDREN(SELF(self)), index);
+        if (node)
+            element = node->data;
+    } else if (RVAL2CBOOL(rb_obj_is_kind_of(index_or_name_or_interface,
+                                            rb_cString))) {
+        char *name;
+        name = RVAL2CSTR(index_or_name_or_interface);
+
+        if (RVAL2CBOOL(recurse)) {
+            element = gst_bin_get_by_name_recurse_up(SELF(self), name);
+        } else {
+            element = gst_bin_get_by_name(SELF(self), name);
+        }
+    } else {
+        GType iface;
+        iface = CLASS2GTYPE(index_or_name_or_interface);
+        element = gst_bin_get_by_interface(SELF(self), iface);
+    }
+
+    return GST_ELEMENT2RVAL(element);
+}
+
+static VALUE
+rg_sinks(VALUE self)
+{
+    return _rbgst_collect_elements(gst_bin_iterate_sinks(SELF(self)));
+}
+
+static VALUE
+rg_sources(VALUE self)
+{
+    return _rbgst_collect_elements(gst_bin_iterate_sources(SELF(self)));
+}
+
+#ifdef GST_DEBUG_BIN_TO_DOT_FILE
+static VALUE
+rg_to_dot_file(VALUE self, VALUE details, VALUE filename)
+{
+    GST_DEBUG_BIN_TO_DOT_FILE(SELF(self), NUM2INT(details), RVAL2CSTR(filename));
+    return Qnil;
+}
+
+static VALUE
+rg_to_dot_file_with_ts(VALUE self, VALUE details, VALUE filename)
+{
+    GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS(SELF(self),
+                                      NUM2INT(details),
+                                      RVAL2CSTR(filename));
+    return Qnil;
+}
+#endif
+
+void
+Init_gst_bin (VALUE mGst)
+{
+    VALUE RG_TARGET_NAMESPACE;
+
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(GST_TYPE_BIN, "Bin", mGst);
+
+    rb_include_module(RG_TARGET_NAMESPACE, rb_mEnumerable);
+
+    RG_DEF_METHOD(initialize, -1);
+
+    RG_DEF_METHOD(size, 0);
+    RG_DEF_ALIAS("length", "size");
+
+    RG_DEF_METHOD(children, -1);
+    RG_DEF_METHOD(each, -1);
+
+    RG_DEF_METHOD(children_recurse, 0);
+    RG_DEF_METHOD(each_recurse, 0);
+
+    RG_DEF_METHOD(children_cookie, 0);
+    RG_DEF_METHOD(child_bus, 0);
+    RG_DEF_METHOD(messages, 0);
+    RG_DEF_METHOD_P(polling, 0);
+    RG_DEF_METHOD_P(clock_dirty, 0);
+    RG_DEF_METHOD(provided_clock, 0);
+    RG_DEF_METHOD(set_provided_clock, 1);
+    RG_DEF_METHOD(clock_provider, 0);
+
+    RG_DEF_METHOD_OPERATOR("<<", add, 1);
+    RG_DEF_METHOD(add, -1);
+    RG_DEF_METHOD(remove, -1);
+    RG_DEF_METHOD(clear, 0);
+
+    RG_DEF_METHOD(get_child, -1);
+
+    RG_DEF_METHOD(sinks, 0);
+    RG_DEF_METHOD(sources, 0);
+
+#ifdef GST_DEBUG_BIN_TO_DOT_FILE
+    RG_DEF_METHOD(to_dot_file, 2);
+    RG_DEF_METHOD(to_dot_file_with_ts, 2);
+#endif
+
+    G_DEF_SETTERS(RG_TARGET_NAMESPACE);
+
+    G_DEF_CLASS(GST_TYPE_BIN_FLAGS, "Flags", RG_TARGET_NAMESPACE);
+    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GST_TYPE_BIN_FLAGS, "GST_BIN_");
+#ifdef GST_DEBUG_BIN_TO_DOT_FILE
+    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GST_TYPE_DEBUG_GRAPH_DETAILS,
+        "GST_DEBUG_GRAPH_");
+#endif
+}