gnomemm r1402 - in gstreamermm/trunk: . gstreamer/src tests

[jaalburqu svn gnome org]

Author: jaalburqu
Date: Wed Mar 12 03:25:03 2008
New Revision: 1402
URL: http://svn.gnome.org/viewvc/gnomemm?rev=1402&view=rev

Log:
2008-03-11  Josà Alburquerque  <jaalburqu svn gnome org>

	* gstreamer/src/value.ccg:
	* gstreamer/src/value.hg: Added class definitions Fraction, IntRange,
	DoubleRange and FractionRange with docs explaining that these classes
	can be wrapped in a Glib::Value<...> to be used to set GStreamer
	specific fields in Gst::Caps Structures (Still need to look at GDate
	and possibly the GStreamer fourcc gtype GST_TYPE_FOURCC) (Must fix
	config files so these classes appear in docs)

	* gstreamer/src/structure.ccg: Modified get_field() and set_field() to
	"translate" to/from the GStreamer gtypes to the gstreamermm gtypes when
	setting and getting fields.

	* tests/test-structure.cc: Modified source to test the adding and
	retrieving of the new classes in value.hg to a Gst::Structure

Modified:
   gstreamermm/trunk/ChangeLog
   gstreamermm/trunk/gstreamer/src/structure.ccg
   gstreamermm/trunk/gstreamer/src/value.ccg
   gstreamermm/trunk/gstreamer/src/value.hg
   gstreamermm/trunk/tests/test-structure.cc

Modified: gstreamermm/trunk/gstreamer/src/structure.ccg
==============================================================================
--- gstreamermm/trunk/gstreamer/src/structure.ccg	(original)
+++ gstreamermm/trunk/gstreamer/src/structure.ccg	Wed Mar 12 03:25:03 2008
@@ -21,6 +21,7 @@
 
 #include <gst/gstvalue.h> //Must be included before gststructure.h
 #include <gst/gststructure.h>
+#include <gstreamermm/value.h>
 
 static gboolean
 Structure_Foreach_gstreamermm_callback(GQuark field_id, const GValue *value, void* data)
@@ -59,13 +60,100 @@
 void
 Structure::get_field(const Glib::ustring& name, Glib::ValueBase& value) const
 {
-  value.init(gst_structure_get_value(gobj(), name.c_str()));
+  const GValue* v = gst_structure_get_value(gobj(), name.c_str());
+
+  GType type = G_VALUE_TYPE(v);
+
+  if (type == GST_TYPE_FRACTION)
+  {
+    value.init(Glib::Value<Fraction>::value_type());
+
+    Glib::Value<Fraction>* fract =
+        static_cast< Glib::Value<Fraction>* >(&value);
+
+    fract->set(Fraction(gst_value_get_fraction_numerator(v),
+        gst_value_get_fraction_denominator(v)));
+  }
+  else if (type == GST_TYPE_INT_RANGE)
+  {
+    value.init(Glib::Value<IntRange>::value_type());
+
+    Glib::Value<IntRange>* range =
+        static_cast< Glib::Value<IntRange>* >(&value);
+
+    range->set(IntRange(gst_value_get_int_range_min(v),
+        gst_value_get_int_range_max(v)));
+  }
+  else if (type == GST_TYPE_DOUBLE_RANGE)
+  {
+    value.init(Glib::Value<DoubleRange>::value_type());
+
+    Glib::Value<DoubleRange>* range =
+        static_cast< Glib::Value<DoubleRange>* >(&value);
+
+    range->set(DoubleRange(gst_value_get_double_range_min(v),
+        gst_value_get_double_range_max(v)));
+  }
+  else if (type == GST_TYPE_FRACTION_RANGE)
+  {
+    const GValue* min = gst_value_get_fraction_range_min(v);
+    const GValue* max = gst_value_get_fraction_range_max(v);
+
+    value.init(Glib::Value<FractionRange>::value_type());
+
+    Glib::Value<FractionRange>* range =
+        static_cast< Glib::Value<FractionRange>* >(&value);
+
+    range->set(FractionRange(Fraction(gst_value_get_fraction_numerator(min),
+        gst_value_get_fraction_denominator(min)),
+            Fraction(gst_value_get_fraction_numerator(max),
+                gst_value_get_fraction_denominator(max))));
+  }
+  else
+    value.init(v);
 }
 
 Structure&
 Structure::set_field(const Glib::ustring& fieldname, const Glib::ValueBase& value)
 {
-  gst_structure_set_value(gobj(), fieldname.c_str(), value.gobj());
+  GType type = G_VALUE_TYPE(value.gobj());
+
+  if (type == Glib::Value<Fraction>::value_type())
+  {
+     const Glib::Value<Fraction>* fract =
+        static_cast< const Glib::Value<Fraction>* >(&value);
+
+     gst_structure_set(gobj(), fieldname.c_str(), GST_TYPE_FRACTION,
+        fract->get().num, fract->get().denom, NULL);
+  }
+  else if (type == Glib::Value<IntRange>::value_type())
+  {
+     const Glib::Value<IntRange>* range =
+        static_cast< const Glib::Value<IntRange>* >(&value);
+
+     gst_structure_set(gobj(), fieldname.c_str(), GST_TYPE_INT_RANGE,
+        range->get().min, range->get().max, NULL);
+  }
+  else if (type == Glib::Value<DoubleRange>::value_type())
+  {
+     const Glib::Value<DoubleRange>* range =
+        static_cast< const Glib::Value<DoubleRange>* >(&value);
+
+     gst_structure_set(gobj(), fieldname.c_str(), GST_TYPE_DOUBLE_RANGE,
+        range->get().min, range->get().max, NULL);
+  }
+  else if (type == Glib::Value<FractionRange>::value_type())
+  {
+     const Glib::Value<FractionRange>* range =
+        static_cast< const Glib::Value<FractionRange>* >(&value);
+
+     gst_structure_set(gobj(), fieldname.c_str(), GST_TYPE_FRACTION_RANGE,
+         range->get().min.num, range->get().min.denom, range->get().max.num,
+             range->get().max.denom, NULL);
+  }
+  else 
+    gst_structure_set_value(gobj(), fieldname.c_str(), value.gobj());
+
   return *this;
 }
 

Modified: gstreamermm/trunk/gstreamer/src/value.ccg
==============================================================================
--- gstreamermm/trunk/gstreamer/src/value.ccg	(original)
+++ gstreamermm/trunk/gstreamer/src/value.ccg	Wed Mar 12 03:25:03 2008
@@ -22,33 +22,41 @@
 namespace Gst
 {
 
-Fraction::Fraction() : m_num(0), m_denom(1)
-{
-}
+Fraction::Fraction() : num(0), denom(1)
+{}
 
-Fraction::Fraction(int num, int denom) : m_num(num), m_denom(denom)
-{
-}
+Fraction::Fraction(int num, int denom) : num(num), denom(denom)
+{}
 
-int Fraction::get_num()
-{
-  return m_num;
-}
+Fraction::Fraction(const Fraction& f) : num(f.num), denom(f.denom)
+{}
 
-int Fraction::get_denom()
-{
-  return m_denom;
-}
+IntRange::IntRange() : min(0), max(0)
+{}
 
-void Fraction::set_num(int num)
-{
-  m_num = num;
-}
+IntRange::IntRange(int min, int max) : min(min), max(max)
+{}
 
-void Fraction::set_denom(int denom)
-{
-  m_denom = denom;
-}
+IntRange::IntRange(const IntRange& r) : min(r.min), max(r.max)
+{}
+
+DoubleRange::DoubleRange() : min(0), max(0)
+{}
+
+DoubleRange::DoubleRange(double min, double max) : min(min), max(max)
+{}
+
+DoubleRange::DoubleRange(const DoubleRange& r) : min(r.min), max(r.max)
+{}
+
+FractionRange::FractionRange() : min(), max()
+{}
+
+FractionRange::FractionRange(const Fraction& min, const Fraction& max) : min(min), max(max)
+{}
+
+FractionRange::FractionRange(const FractionRange& r) : min(r.min), max(r.max)
+{}
 
 } //namespace Gst
 

Modified: gstreamermm/trunk/gstreamer/src/value.hg
==============================================================================
--- gstreamermm/trunk/gstreamer/src/value.hg	(original)
+++ gstreamermm/trunk/gstreamer/src/value.hg	Wed Mar 12 03:25:03 2008
@@ -27,24 +27,118 @@
 namespace Gst
 {
 
-//TODO: Documenation. What is this?
-//TODO: Put implmenetation in the .ccg file.
-//TODO: Probably use the m_ prefix.
+/** Represents a fraction for use to store in Structures of Caps as a value
+ * representing a property (see GStreamer Application Development Manual
+ * section 8.2.2 for explanation).  The class can be used in setting and
+ * getting a Structure's field like so:
+ *
+ * @code
+ * Glib::Value<Gst::Fraction> fract_value;
+ * fract_value.init(Glib::Value<Gst::Fraction>::value_type());
+ * fract_value.set(Gst::Fraction(25,1));
+ *
+ * Gst::Structure structure("my-structure");
+ * structure.set_field("framerate", fract_value);
+ * ...
+ * Glib::Value<Gst::Fraction> fract_copy;
+ * structure.get_field("framerate", fract_copy);
+ * @code
+ */
 class Fraction
 {
 public:
-  inline Fraction();
-  inline Fraction(int num, int denom);
+  Fraction();
+  Fraction(int num, int denom);
+  Fraction(const Fraction& f);
+public:
+  int num;
+  int denom;
+};
+
 
-  inline int get_num();
-  inline int get_denom();
-  inline void set_num(int num);
-  inline void set_denom(int denom);
-
-private:
-  int m_num;
-  int m_denom;
+/** Represents a integer range (min - max) for use to store in Structures of
+ * Caps as a value representing a property (see GStreamer Application
+ * Development Manual section 8.2.2 for explanation).  The class can be used in
+ * setting and getting a Structure's field like so:
+ *
+ * @code
+ * Glib::Value<Gst::IntRange> range;
+ * range.init(Glib::Value<Gst::IntRange>::value_type());
+ * range.set(Gst::IntRange(8000, 50000));
+ *
+ * Gst::Structure structure("my-structure");
+ * structure.set_field("rate", range);
+ * ...
+ * Glib::Value<Gst::IntRange> range_copy;
+ * structure.get_field("rate", range_copy);
+ * @code
+ */
+class IntRange
+{
+public:
+  IntRange();
+  IntRange(int min, int max);
+  IntRange(const IntRange& r);
+public:
+  int min;
+  int max;
+};
+
+/** Represents a floating (double) range (min - max) for use to store in
+ * Structures of Caps as a value representing a property (see GStreamer
+ * Application Development Manual section 8.2.2 for explanation).  The class
+ * can be used in setting and getting a Structure's field like so:
+ *
+ * @code
+ * Glib::Value<Gst::DoubleRange> range;
+ * range.init(Glib::Value<Gst::DoubleRange>::value_type());
+ * range.set(Gst::DoubleRange(44.1, 48.0));
+ *
+ * Gst::Structure structure("my-structure");
+ * structure.set_field("rate", range);
+ * ...
+ * Glib::Value<Gst::DoubleRange> range_copy;
+ * structure.get_field("rate", range_copy);
+ * @code
+ */
+class DoubleRange
+{
+public:
+  DoubleRange();
+  DoubleRange(double min, double max);
+  DoubleRange(const DoubleRange& r);
+public:
+  double min;
+  double max;
 };
 
-} //namespace Gst
 
+/** Represents a fractional range for use to store in Structures of Caps as a
+ * value representing a property (see GStreamer Application Development Manual
+ * section 8.2.2 for explanation).  The class can be used in setting and
+ * getting a Structure's field like so:
+ *
+ * @code
+ * Glib::Value<Gst::FractionRange> range;
+ * range.init(Glib::Value<Gst::Fraction>::value_type());
+ * range.set(Gst::FractionRange(Gst::Fraction(1,2), Gst::Fraction(3,4));
+ *
+ * Gst::Structure structure("my-structure");
+ * structure.set_field("range", range);
+ * ...
+ * Glib::Value<Gst::FractionRange> range_copy;
+ * structure.get_field("range", range_copy);
+ * @code
+ */
+class FractionRange
+{
+public:
+  FractionRange();
+  FractionRange(const Fraction& min, const Fraction& max);
+  FractionRange(const FractionRange& r);
+public:
+  Fraction min;
+  Fraction max;
+};
+
+} //namespace Gst

Modified: gstreamermm/trunk/tests/test-structure.cc
==============================================================================
--- gstreamermm/trunk/tests/test-structure.cc	(original)
+++ gstreamermm/trunk/tests/test-structure.cc	Wed Mar 12 03:25:03 2008
@@ -36,15 +36,34 @@
   intValue.init(Glib::Value<int>::value_type());
   intValue.set(100);
 
-  structure.set_field(Glib::Quark("string"), stringValue).set_field("integer", intValue);
+  Glib::Value<Gst::Fraction> fractValue;
+  fractValue.init(Glib::Value<Gst::Fraction>::value_type());
+  fractValue.set(Gst::Fraction(1,2));
+
+  Glib::Value<Gst::FractionRange> rangeValue;
+  rangeValue.init(Glib::Value<Gst::FractionRange>::value_type());
+  rangeValue.set(Gst::FractionRange(Gst::Fraction(1,2), Gst::Fraction(3,4)));
+
+  structure.set_field(Glib::Quark("string"), stringValue).set_field("integer", intValue).set_field("fraction", fractValue).set_field("range", rangeValue);
 
   Glib::Value<Glib::ustring> value1;
   structure.get_field("string", value1);
-  std::cout << "value1 = '" << value1.get() << "'" << std::endl;
+  std::cout << "string value = '" << value1.get() << "'" << std::endl;
 
   Glib::Value<int> value2;
   structure.get_field("integer", value2);
-  std::cout << "value2 = '" << value2.get() << "'" << std::endl;
+  std::cout << "integer value = '" << value2.get() << "'" << std::endl;
+
+  Glib::Value<Gst::Fraction> value3;
+  structure.get_field("fraction", value3);
+  std::cout << "fraction value = '" << value3.get().num << "/" <<
+      value3.get().denom << "'" << std::endl;
+
+  Glib::Value<Gst::FractionRange> value4;
+  structure.get_field("range", value4);
+  std::cout << "fractional range value = '[(" << value4.get().min.num << "/" <<
+      value4.get().min.denom << "), (" << value4.get().max.num << "/" <<
+          value4.get().max.denom << ")]'" << std::endl;
 
   return 0;
 }