gstreamer 1.0.3 → 1.1.0

data/ext/gstreamer/rbgst-buffer.c

@@ -1,25 +1,27 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- * Copyright (C) 2007 Ruby-GNOME2 Project Team
+ *  Copyright (C) 2011-2012  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2007  Ruby-GNOME2 Project Team
  *
- * This file is part of Ruby/GStreamer.
+ *  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.
  *
- * 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.
+ *  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.
  *
- * 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
+ *  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 cBuffer
 #define SELF(obj) (RVAL2GST_BUF(obj))
 #define RVAL2GST_FLAGS(flags) \
     (RVAL2GFLAGS(flags, GST_TYPE_BUFFER_FLAG))
@@ -31,7 +33,7 @@
     (GFLAGS2RVAL(flags, GST_TYPE_BUFFER_COPY_FLAGS))
 
 static VALUE
-initialize(int argc, VALUE *argv, VALUE self)
+rg_initialize(int argc, VALUE *argv, VALUE self)
 {
     VALUE size;
     GstBuffer *buffer;
@@ -49,41 +51,41 @@ initialize(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-get_flags(VALUE self)
+rg_flags(VALUE self)
 {
     return GST_FLAGS2RVAL(GST_BUFFER_FLAGS(SELF(self)));
 }
 
 static VALUE
-set_flags(VALUE self, VALUE flag)
+rg_set_flags(VALUE self, VALUE flag)
 {
     GST_BUFFER_FLAGS(SELF(self)) = RVAL2GST_FLAGS(flag);
     return Qnil;
 }
 
 static VALUE
-raise_flag(VALUE self, VALUE flag)
+rg_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)
+rg_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)
+rg_flag_raised_p(VALUE self, VALUE flag)
 {
     return CBOOL2RVAL(GST_MINI_OBJECT_FLAG_IS_SET(SELF(self),
                                                   RVAL2GST_FLAGS(flag)));
 }
 
 static VALUE
-get_data(VALUE self)
+rg_data(VALUE self)
 {
     GstBuffer *buffer;
     guint size;
@@ -98,7 +100,7 @@ get_data(VALUE self)
 }
 
 static VALUE
-set_data(VALUE self, VALUE data)
+rg_set_data(VALUE self, VALUE data)
 {
     GstBuffer *buffer;
     buffer = SELF(self);
@@ -115,115 +117,115 @@ set_data(VALUE self, VALUE data)
 }
 
 static VALUE
-get_size(VALUE self)
+rg_size(VALUE self)
 {
     return UINT2NUM(GST_BUFFER_SIZE(SELF(self)));
 }
 
 static VALUE
-set_size(VALUE self, VALUE size)
+rg_set_size(VALUE self, VALUE size)
 {
     GST_BUFFER_SIZE(SELF(self)) = NUM2UINT(size);
     return Qnil;
 }
 
 static VALUE
-get_timestamp(VALUE self)
+rg_timestamp(VALUE self)
 {
     return ULL2NUM(GST_BUFFER_TIMESTAMP(SELF(self)));
 }
 
 static VALUE
-set_timestamp(VALUE self, VALUE timestamp)
+rg_set_timestamp(VALUE self, VALUE timestamp)
 {
     GST_BUFFER_TIMESTAMP(SELF(self)) = NUM2ULL(timestamp);
     return Qnil;
 }
 
 static VALUE
-valid_timestamp_p(VALUE self)
+rg_valid_timestamp_p(VALUE self)
 {
     return CBOOL2RVAL(GST_BUFFER_TIMESTAMP_IS_VALID(SELF(self)));
 }
 
 static VALUE
-get_duration(VALUE self)
+rg_duration(VALUE self)
 {
     return ULL2NUM(GST_BUFFER_DURATION(SELF(self)));
 }
 
 static VALUE
-set_duration(VALUE self, VALUE duration)
+rg_set_duration(VALUE self, VALUE duration)
 {
     GST_BUFFER_DURATION(SELF(self)) = NUM2ULL(duration);
     return Qnil;
 }
 
 static VALUE
-valid_duration_p(VALUE self)
+rg_valid_duration_p(VALUE self)
 {
     return CBOOL2RVAL(GST_BUFFER_DURATION_IS_VALID(SELF(self)));
 }
 
 static VALUE
-get_caps(VALUE self)
+rg_caps(VALUE self)
 {
     return GST_CAPS2RVAL(GST_BUFFER_CAPS(SELF(self)));
 }
 
 static VALUE
-set_caps(VALUE self, VALUE caps)
+rg_set_caps(VALUE self, VALUE caps)
 {
     gst_buffer_set_caps(SELF(self), RVAL2GST_CAPS(caps));
     return Qnil;
 }
 
 static VALUE
-get_offset(VALUE self)
+rg_offset(VALUE self)
 {
     return ULL2NUM(GST_BUFFER_OFFSET(SELF(self)));
 }
 
 static VALUE
-set_offset(VALUE self, VALUE offset)
+rg_set_offset(VALUE self, VALUE offset)
 {
     GST_BUFFER_OFFSET(SELF(self)) = NUM2ULL(offset);
     return Qnil;
 }
 
 static VALUE
-valid_offset_p(VALUE self)
+rg_valid_offset_p(VALUE self)
 {
     return CBOOL2RVAL(GST_BUFFER_OFFSET_IS_VALID(SELF(self)));
 }
 
 static VALUE
-get_offset_end(VALUE self)
+rg_offset_end(VALUE self)
 {
     return ULL2NUM(GST_BUFFER_OFFSET_END(SELF(self)));
 }
 
 static VALUE
-set_offset_end(VALUE self, VALUE offset_end)
+rg_set_offset_end(VALUE self, VALUE offset_end)
 {
     GST_BUFFER_OFFSET_END(SELF(self)) = NUM2ULL(offset_end);
     return Qnil;
 }
 
 static VALUE
-valid_offset_end_p(VALUE self)
+rg_valid_offset_end_p(VALUE self)
 {
     return CBOOL2RVAL(GST_BUFFER_OFFSET_END_IS_VALID(SELF(self)));
 }
 
 static VALUE
-discontinuity_p(VALUE self)
+rg_discontinuity_p(VALUE self)
 {
     return CBOOL2RVAL(GST_BUFFER_IS_DISCONT(SELF(self)));
 }
 
 static VALUE
-copy_metadata(int argc, VALUE *argv, VALUE self)
+rg_copy_metadata(int argc, VALUE *argv, VALUE self)
 {
     VALUE arg1, arg2, copied_dest;
     GstBuffer *dest;
@@ -247,13 +249,13 @@ copy_metadata(int argc, VALUE *argv, VALUE self)
 }
 
 static VALUE
-metadata_writable_p(VALUE self)
+rg_metadata_writable_p(VALUE self)
 {
     return CBOOL2RVAL(gst_buffer_is_metadata_writable(SELF(self)));
 }
 
 static VALUE
-metadata_writable_bang(VALUE self)
+rg_metadata_writable_bang(VALUE self)
 {
     GstBuffer *orig_buffer, *buffer;
     VALUE rb_buffer;
@@ -268,7 +270,7 @@ metadata_writable_bang(VALUE self)
 }
 
 static VALUE
-create_sub(VALUE self, VALUE offset, VALUE size)
+rg_create_sub(VALUE self, VALUE offset, VALUE size)
 {
     GstBuffer *buffer;
     VALUE rb_buffer;
@@ -279,87 +281,85 @@ create_sub(VALUE self, VALUE offset, VALUE size)
 }
 
 static VALUE
-span(VALUE self, VALUE offset, VALUE other, VALUE length)
+rg_span(VALUE self, VALUE offset, VALUE other, VALUE length)
 {
     return GOBJ2RVAL(gst_buffer_span(SELF(self), NUM2UINT(offset),
                                      SELF(other), NUM2UINT(length)));
 }
 
 static VALUE
-span_p(VALUE self, VALUE other)
+rg_span_p(VALUE self, VALUE other)
 {
     return CBOOL2RVAL(gst_buffer_is_span_fast(SELF(self), SELF(other)));
 }
 
 void
-Init_gst_buffer(void)
+Init_gst_buffer(VALUE mGst)
 {
-    VALUE rb_cGstBuffer, rb_cGstBufferCopyFlags;
+    VALUE RG_TARGET_NAMESPACE, rb_cGstBufferCopyFlags;
 
-    rb_cGstBuffer = G_DEF_CLASS(GST_TYPE_BUFFER, "Buffer", mGst);
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(GST_TYPE_BUFFER, "Buffer", mGst);
 
-    rb_define_const(rb_cGstBuffer, "OFFSET_NONE",
+    rb_define_const(RG_TARGET_NAMESPACE, "OFFSET_NONE",
                     ULL2NUM(GST_BUFFER_OFFSET_NONE));
 
-    G_DEF_CLASS(GST_TYPE_BUFFER_FLAG, "Flags", rb_cGstBuffer);
-    G_DEF_CONSTANTS(rb_cGstBuffer, GST_TYPE_BUFFER_FLAG, "GST_BUFFER_");
+    G_DEF_CLASS(GST_TYPE_BUFFER_FLAG, "Flags", RG_TARGET_NAMESPACE);
+    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GST_TYPE_BUFFER_FLAG, "GST_BUFFER_");
 
     rb_cGstBufferCopyFlags = G_DEF_CLASS(GST_TYPE_BUFFER_COPY_FLAGS,
-                                         "CopyFlags", rb_cGstBuffer);
-    G_DEF_CONSTANTS(rb_cGstBuffer, GST_TYPE_BUFFER_COPY_FLAGS, "GST_BUFFER_");
+                                         "CopyFlags", RG_TARGET_NAMESPACE);
+    G_DEF_CONSTANTS(RG_TARGET_NAMESPACE, GST_TYPE_BUFFER_COPY_FLAGS, "GST_BUFFER_");
     rb_define_const(rb_cGstBufferCopyFlags, "ALL",
                     GST_COPY_FLAGS2RVAL(GST_BUFFER_COPY_ALL));
-    rb_define_const(rb_cGstBuffer, "COPY_ALL",
+    rb_define_const(RG_TARGET_NAMESPACE, "COPY_ALL",
                     GST_COPY_FLAGS2RVAL(GST_BUFFER_COPY_ALL));
 
-    rb_define_method(rb_cGstBuffer, "initialize", initialize, -1);
+    RG_DEF_METHOD(initialize, -1);
 
-    rb_define_method(rb_cGstBuffer, "flags", get_flags, 0);
-    rb_define_method(rb_cGstBuffer, "set_flags", set_flags, 1);
-    rb_define_method(rb_cGstBuffer, "raise_flag", raise_flag, 1);
-    rb_define_method(rb_cGstBuffer, "lower_flag", lower_flag, 1);
-    rb_define_method(rb_cGstBuffer, "flag_raised?", flag_raised_p, 1);
+    RG_DEF_METHOD(flags, 0);
+    RG_DEF_METHOD(set_flags, 1);
+    RG_DEF_METHOD(raise_flag, 1);
+    RG_DEF_METHOD(lower_flag, 1);
+    RG_DEF_METHOD_P(flag_raised, 1);
 
-    rb_define_method(rb_cGstBuffer, "data", get_data, 0);
-    rb_define_method(rb_cGstBuffer, "set_data", set_data, 1);
+    RG_DEF_METHOD(data, 0);
+    RG_DEF_METHOD(set_data, 1);
 
-    rb_define_method(rb_cGstBuffer, "size", get_size, 0);
-    rb_define_method(rb_cGstBuffer, "set_size", set_size, 1);
-    rb_define_alias(rb_cGstBuffer, "length", "size");
-    rb_define_alias(rb_cGstBuffer, "set_length", "set_size");
+    RG_DEF_METHOD(size, 0);
+    RG_DEF_METHOD(set_size, 1);
+    RG_DEF_ALIAS("length", "size");
+    RG_DEF_ALIAS("set_length", "set_size");
 
-    rb_define_method(rb_cGstBuffer, "timestamp", get_timestamp, 0);
-    rb_define_method(rb_cGstBuffer, "set_timestamp", set_timestamp, 1);
-    rb_define_method(rb_cGstBuffer, "valid_timestamp?", valid_timestamp_p, 0);
+    RG_DEF_METHOD(timestamp, 0);
+    RG_DEF_METHOD(set_timestamp, 1);
+    RG_DEF_METHOD_P(valid_timestamp, 0);
 
-    rb_define_method(rb_cGstBuffer, "duration", get_duration, 0);
-    rb_define_method(rb_cGstBuffer, "set_duration", set_duration, 1);
-    rb_define_method(rb_cGstBuffer, "valid_duration?", valid_duration_p, 0);
+    RG_DEF_METHOD(duration, 0);
+    RG_DEF_METHOD(set_duration, 1);
+    RG_DEF_METHOD_P(valid_duration, 0);
 
-    rb_define_method(rb_cGstBuffer, "caps", get_caps, 0);
-    rb_define_method(rb_cGstBuffer, "set_caps", set_caps, 1);
+    RG_DEF_METHOD(caps, 0);
+    RG_DEF_METHOD(set_caps, 1);
 
-    rb_define_method(rb_cGstBuffer, "offset", get_offset, 0);
-    rb_define_method(rb_cGstBuffer, "set_offset", set_offset, 1);
-    rb_define_method(rb_cGstBuffer, "valid_offset?", valid_offset_p, 0);
+    RG_DEF_METHOD(offset, 0);
+    RG_DEF_METHOD(set_offset, 1);
+    RG_DEF_METHOD_P(valid_offset, 0);
 
-    rb_define_method(rb_cGstBuffer, "offset_end", get_offset_end, 0);
-    rb_define_method(rb_cGstBuffer, "set_offset_end", set_offset_end, 1);
-    rb_define_method(rb_cGstBuffer, "valid_offset_end?", valid_offset_end_p, 0);
+    RG_DEF_METHOD(offset_end, 0);
+    RG_DEF_METHOD(set_offset_end, 1);
+    RG_DEF_METHOD_P(valid_offset_end, 0);
 
-    rb_define_method(rb_cGstBuffer, "discontinuity?", discontinuity_p, 0);
+    RG_DEF_METHOD_P(discontinuity, 0);
 
-    rb_define_method(rb_cGstBuffer, "copy_metadata", copy_metadata, -1);
+    RG_DEF_METHOD(copy_metadata, -1);
 
-    rb_define_method(rb_cGstBuffer, "metadata_writable?",
-                     metadata_writable_p, 0);
-    rb_define_method(rb_cGstBuffer, "metadata_writable!",
-                     metadata_writable_bang, 0);
+    RG_DEF_METHOD_P(metadata_writable, 0);
+    RG_DEF_METHOD_BANG(metadata_writable, 0);
 
-    rb_define_method(rb_cGstBuffer, "create_sub", create_sub, 2);
+    RG_DEF_METHOD(create_sub, 2);
 
-    rb_define_method(rb_cGstBuffer, "span", span, 3);
-    rb_define_method(rb_cGstBuffer, "span?", span_p, 1);
+    RG_DEF_METHOD(span, 3);
+    RG_DEF_METHOD_P(span, 1);
 
-    G_DEF_SETTERS(rb_cGstBuffer);
+    G_DEF_SETTERS(RG_TARGET_NAMESPACE);
 }

data/ext/gstreamer/rbgst-bus.c

@@ -1,30 +1,31 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- * Copyright (C) 2007 Ruby-GNOME2 Project Team
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2007  Ruby-GNOME2 Project Team
  *
- * This file is part of Ruby/GStreamer.
+ *  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.
  *
- * 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.
+ *  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.
  *
- * 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
+ *  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"
 
 /* Class: Gst::Bus
  * Asynchronous message bus subsystem.
  */
 
+#define RG_TARGET_NAMESPACE cBus
 #define SELF(obj) (RVAL2GST_BUS(obj))
 
 static ID id_call;
@@ -56,7 +57,7 @@ destroy_watch_func(gpointer data)
 }
 
 static VALUE
-rb_gst_bus_add_watch(int argc, VALUE *argv, VALUE self)
+rg_add_watch(int argc, VALUE *argv, VALUE self)
 {
     VALUE rb_priority, block, rb_id;
     gint priority;
@@ -78,15 +79,14 @@ rb_gst_bus_add_watch(int argc, VALUE *argv, VALUE self)
     return rb_id;
 }
 
-
 void
-Init_gst_bus (void)
+Init_gst_bus (VALUE mGst)
 {
-    VALUE rb_cGstBus;
+    VALUE RG_TARGET_NAMESPACE;
 
     id_call = rb_intern("call");
 
-    rb_cGstBus = G_DEF_CLASS(GST_TYPE_BUS, "Bus", mGst);
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(GST_TYPE_BUS, "Bus", mGst);
 
-    rb_define_method(rb_cGstBus, "add_watch", rb_gst_bus_add_watch, -1);
+    RG_DEF_METHOD(add_watch, -1);
 }