[gstreamermm: 71/167] restored event methods (ported to 1.0)

[Murray Cumming <murrayc src gnome org>]

commit 0bb13c179c90c43ff03e1a7f2536ac9d8810f257
Author: Marcin Kolny at Flytronic <marcin kolny flytronic pl>
Date:   Tue Jul 30 09:38:26 2013 +0200

    restored event methods (ported to 1.0)

 gstreamer/src/event.ccg           |  119 ++++++++++++++-
 gstreamer/src/event.hg            |  310 ++++++++++++++++++++++++++++++++++---
 gstreamer/src/segment.hg          |    4 +-
 tools/m4/convert_gst.m4           |    1 +
 tools/m4/plugingen_gstreamermm.m4 |    2 +-
 5 files changed, 409 insertions(+), 27 deletions(-)
---
diff --git a/gstreamer/src/event.ccg b/gstreamer/src/event.ccg
index b957b31..19e63cd 100644
--- a/gstreamer/src/event.ccg
+++ b/gstreamer/src/event.ccg
@@ -68,13 +68,60 @@ bool Event::is_serialized() const
   return GST_EVENT_IS_SERIALIZED(gobj());
 }
 
-Gst::TagList EventTag::parse() const
+Glib::RefPtr<Gst::EventFlushStart> EventFlushStart::create()
 {
-  GstTagList* gst_taglist = gst_tag_list_new_empty();
+  GstEvent* event = gst_event_new_flush_start();
+  return Glib::wrap_event_derived<EventFlushStart>(event, false);
+}
+
+Glib::RefPtr<Gst::EventFlushStop> EventFlushStop::create(bool reset_time)
+{
+  GstEvent* event = gst_event_new_flush_stop(reset_time);
+  return Glib::wrap_event_derived<EventFlushStop>(event, false);
+}
+
+Glib::RefPtr<Gst::EventEos> EventEos::create()
+{
+  GstEvent* event = gst_event_new_eos();
+  return Glib::wrap_event_derived<EventEos>(event, false);
+}
+
+Glib::RefPtr<Gst::EventNewSegment>
+  EventNewSegment::create(const GstSegment* segment)
+{
+  GstEvent* event = gst_event_new_segment(segment);
+  return Glib::wrap_event_derived<EventNewSegment>(event, false);
+}
+
+void EventNewSegment::parse(const GstSegment** segment) const
+{
+  gst_event_parse_segment(const_cast<GstEvent*>(gobj()), segment);
+}
+
+Glib::RefPtr<Gst::EventTag> EventTag::create(const Gst::TagList& taglist)
+{
+  //We create a copy because gst_event_new_tag() takes ownership:
+  GstTagList* c_taglist = gst_tag_list_copy(taglist.gobj());
+  GstEvent* event = gst_event_new_tag(c_taglist);
+  return Glib::wrap_event_derived<EventTag>(event, false);
+}
+
+Gst::TagList EventTag::parse(const Glib::ustring& name) const
+{
+  GstTagList* gst_taglist = gst_tag_list_new(name.c_str());
   gst_event_parse_tag(const_cast<GstEvent*>(gobj()), &gst_taglist);
   return Gst::TagList(gst_taglist);
 }
 
+Glib::RefPtr<Gst::EventBufferSize>
+  EventBufferSize::create(Format format, gint64 minsize, gint64 maxsize,
+  bool async)
+{
+  GstEvent* event = gst_event_new_buffer_size(GstFormat(format), minsize,
+    maxsize, async);
+  return Glib::wrap_event_derived<EventBufferSize>(event, false);
+}
+
 void EventBufferSize::parse(Format& format, gint64& minsize, gint64& maxsize,
   bool& async) const
 {
@@ -115,10 +162,18 @@ bool EventBufferSize::parse_async() const
   return gst_async;
 }
 
-void EventQos::parse(QOSType& type, double& proportion, ClockTimeDiff& diff,
+Glib::RefPtr<Gst::EventQos> EventQos::create(GstQOSType type, double proportion,
+  ClockTimeDiff diff, ClockTime timestamp)
+{
+  GstEvent* event = gst_event_new_qos(type, proportion, GstClockTimeDiff(diff),
+    GstClockTime(timestamp));
+  return Glib::wrap_event_derived<EventQos>(event, false);
+}
+
+void EventQos::parse(GstQOSType& type, double& proportion, ClockTimeDiff& diff,
   ClockTime& timestamp) const
 {
-  gst_event_parse_qos(const_cast<GstEvent*>(gobj()), (GstQOSType*)&type, &proportion, &diff,
+  gst_event_parse_qos(const_cast<GstEvent*>(gobj()), &type, &proportion, &diff,
     &timestamp);
 }
 
@@ -132,7 +187,6 @@ double EventQos::parse() const
 Gst::ClockTimeDiff EventQos::parse_diff() const
 {
   GstClockTimeDiff gst_diff = 0;
-
   gst_event_parse_qos(const_cast<GstEvent*>(gobj()), 0, 0, &gst_diff, 0);
   return gst_diff;
 }
@@ -144,6 +198,17 @@ Gst::ClockTime EventQos::parse_timestamp() const
   return gst_timestamp;
 }
 
+Glib::RefPtr<Gst::EventSeek> EventSeek::create(double rate, Format format,
+  SeekFlags flags, SeekType start_type, gint64 start, SeekType stop_type,
+  gint64 stop)
+{
+  GstEvent* event = gst_event_new_seek(rate, GstFormat(format),
+    GstSeekFlags(flags), GstSeekType(start_type), start,
+    GstSeekType(stop_type), stop);
+
+  return Glib::wrap_event_derived<EventSeek>(event, false);
+}
+
 void EventSeek::parse(double& rate, Format& format, SeekFlags& flags,
   SeekType& start_type, gint64& start, SeekType& stop_type, gint64& stop) const
 {
@@ -208,6 +273,21 @@ gint64 EventSeek::parse_stop() const
   return gst_stop;
 }
 
+Glib::RefPtr<Gst::EventNavigation>
+  EventNavigation::create(Gst::Structure& structure)
+{
+  // Make copy because event takes ownership of structure:
+  GstStructure* copy = gst_structure_copy(structure.gobj());
+  GstEvent* event = gst_event_new_navigation(copy);
+  return Glib::wrap_event_derived<EventNavigation>(event, false);
+}
+
+Glib::RefPtr<Gst::EventLatency> EventLatency::create(ClockTime time)
+{
+  GstEvent* event = gst_event_new_latency(GstClockTime(time));
+  return Glib::wrap_event_derived<EventLatency>(event, false);
+}
+
 ClockTime EventLatency::parse() const
 {
   GstClockTime gst_latency = 0;
@@ -215,6 +295,15 @@ ClockTime EventLatency::parse() const
   return gst_latency;
 }
 
+Glib::RefPtr<Gst::EventStep>
+  EventStep::create(Gst::Format format, guint64 amount, double rate,
+  bool flush, bool intermediate)
+{
+  GstEvent* event = gst_event_new_step(static_cast<GstFormat>(format),
+    amount, rate, flush, intermediate);
+  return Glib::wrap_event_derived<EventStep>(event, false);
+}
+
 void EventStep::parse(Gst::Format& format, guint64& amount, double& rate,
   bool& flush, bool& intermediate) const
 {
@@ -265,5 +354,25 @@ bool EventStep::parse_intermediate() const
   return gst_intermediate;
 }
 
+Glib::RefPtr<Gst::EventSinkMessage>
+  EventSinkMessage::create(const Glib::ustring& name, const Glib::RefPtr<Gst::Message>& msg)
+{
+  GstEvent* event = gst_event_new_sink_message(name.c_str(), msg->gobj());
+  return Glib::wrap_event_derived<EventSinkMessage>(event, false);
+}
+
+Glib::RefPtr<Gst::Message> EventSinkMessage::parse()
+{
+  GstMessage* gst_msg = 0;
+  gst_event_parse_sink_message(gobj(), &gst_msg);
+  return Glib::wrap(gst_msg);
+}
+
+Glib::RefPtr<const Gst::Message> EventSinkMessage::parse() const
+{
+  GstMessage* gst_msg = 0;
+  gst_event_parse_sink_message(const_cast<GstEvent*>(gobj()), &gst_msg);
+  return Glib::wrap(gst_msg);
+}
 
 } //namespace Gst
diff --git a/gstreamer/src/event.hg b/gstreamer/src/event.hg
index ce22748..dc9b6a3 100644
--- a/gstreamer/src/event.hg
+++ b/gstreamer/src/event.hg
@@ -21,18 +21,28 @@
 #include <gstreamermm/miniobject.h>
 #include <gstreamermm/format.h>
 #include <gstreamermm/clock.h>
-
+#include <gstreamermm/segment.h>
 
 _DEFS(gstreamermm,gst)
 
-namespace Gst
+namespace Glib
 {
+    template<typename T>
+    Glib::RefPtr<T> wrap_event_derived(GstEvent* object, bool take_copy)
+    {
+      if(take_copy && object)
+        gst_event_ref(object);
+
+      // See the comment at the top of this file, if you want to know why the cast works.
+      return Glib::RefPtr<T>(reinterpret_cast<T*>(object));
+    }
+
+}
 
-  _WRAP_ENUM(SeekType, GstSeekType)
-  _WRAP_ENUM(SeekFlags, GstSeekFlags)
+namespace Gst
+{
 
 _WRAP_ENUM_DOCS_ONLY(EventType, GstEventType)
-/* this enum must be wrapped manually since automatic generator (enum.pl) doesn't handle commas properly*/
 enum EventType
 {
   EVENT_UNKNOWN = GST_EVENT_UNKNOWN,
@@ -48,6 +58,7 @@ enum EventType
   EVENT_SINK_MESSAGE = GST_EVENT_SINK_MESSAGE,
   EVENT_EOS = GST_EVENT_EOS,
   EVENT_TOC = GST_EVENT_TOC,
+  //EVENT_CONTEXT = GST_EVENT_CONTEXT,
   /* non-sticky downstream serialized */
   EVENT_SEGMENT_DONE = GST_EVENT_SEGMENT_DONE,
   EVENT_GAP = GST_EVENT_GAP,
@@ -146,7 +157,7 @@ public:
 
   /** Checks if an event is writable.  If not, a writable copy is made and
    * returned.
-   * @return A Gst::Event (possibly the same reference) that is writable. 
+   * @return A Gst::Event (possibly the same reference) that is writable.
    */
   Glib::RefPtr<Gst::Event> create_writable();
 
@@ -170,7 +181,6 @@ public:
    * event was created.
    */
   _MEMBER_GET(timestamp, timestamp, ClockTime, guint64)
-
 };
 
 //TODO: Modify create methods of derived Event classes to return
@@ -183,20 +193,74 @@ public:
  */
 class EventFlushStart : public Event
 {
+public:
+  /** Allocate a new flush start event. The flush start event can be sent
+   * upstream and downstream and travels out-of-bounds with the dataflow.
+   *
+   * It marks pads as being flushing and will make them return
+   * Gst::FLOW_WRONG_STATE when used for data flow with Gst::Pad::push(),
+   * Gst::Pad::chain(), Gst::Pad::alloc_buffer(), Gst::Pad::get_range() and
+   * Gst::Pad::pull_range(). Any event (except a Gst::EVENT_FLUSH_STOP)
+   * received on a flushing pad will return false immediately.
+   *
+   * Elements should unlock any blocking functions and exit their streaming
+   * functions as fast as possible when this event is received.
+   *
+   * This event is typically generated after a seek to flush out all queued
+   * data in the pipeline so that the new media is played as soon as possible.
+   *
+   * @return A new flush start event.
+   */
+  static Glib::RefPtr<Gst::EventFlushStart> create();
 };
 
 /**  A flush stop event.  See create() for more details.
  */
 class EventFlushStop : public Event
 {
+public:
 
+ /**
+  * gst_event_new_flush_stop:
+ * @reset_time: if time should be reset
+  *
+  * Allocate a new flush stop event. The flush stop event can be sent
+  * upstream and downstream and travels serialized with the dataflow.
+  * It is typically sent after sending a FLUSH_START event to make the
+  * pads accept data again.
+  *
+  * Elements can process this event synchronized with the dataflow since
+  * the preceeding FLUSH_START event stopped the dataflow.
+  *
+  * This event is typically generated to complete a seek and to resume
+  * dataflow.
+  *
+  * Returns: (transfer full): a new flush stop event.
+  */
+  static Glib::RefPtr<Gst::EventFlushStop> create(bool reset_time);
 };
 
 /** An end of stream event. See create() for more details.
  */
 class EventEos : public Event
 {
+public:
 
+  /** Create a new EOS event. The eos event can only travel downstream
+   * synchronized with the buffer flow. Elements that receive the EOS event on
+   * a pad can return Gst::FLOW_UNEXPECTED as a Gst::FlowReturn when data after
+   * the EOS event arrives.
+   *
+   * The EOS event will travel down to the sink elements in the pipeline which
+   * will then post the Gst::MESSAGE_EOS on the bus after they have finished
+   * playing any buffered data.
+   *
+   * When all sinks have posted an EOS message, an EOS message is forwarded to
+   * the application.
+   *
+   * @return The new EOS event.
+   */
+  static Glib::RefPtr<Gst::EventEos> create();
 };
 
 /** A new segment event.  See create() for more details.
@@ -205,7 +269,53 @@ class EventNewSegment : public Event
 {
 public:
 
+  /** Allocate a new newsegment event with the given format/values tripplets
+   *
+   * The newsegment event marks the range of buffers to be processed. All data
+   * not within the segment range is not to be processed. This can be used
+   * intelligently by plugins to apply more efficient methods of skipping
+   * unneeded data.
+   *
+   * The position value of the segment is used in conjunction with the start
+   * value to convert the buffer timestamps into the stream time. This is
+   * usually done in sinks to report the current stream_time. position
+   * represents the stream_time of a buffer carrying a timestamp of start.
+   * position cannot be -1.
+   *
+   * start cannot be -1, stop can be -1. If there is a valid stop given, it
+   * must be greater or equal the start, including when the indicated playback
+   * rate is < 0.
+   *
+   * The applied_rate value provides information about any rate adjustment that
+   * has already been made to the timestamps and content on the buffers of the
+   * stream. (rate * applied_rate) should always equal the rate that has been
+   * requested for playback. For example, if an element has an input segment
+   * with intended playback rate of 2.0 and applied_rate of 1.0, it can adjust
+   * incoming timestamps and buffer content by half and output a newsegment
+   * event with rate of 1.0 and applied_rate of 2.0
+   *
+   * After a newsegment event, the buffer stream time is calculated with:
+   *
+   * position + (TIMESTAMP(buf) - start) * ABS (rate * applied_rate)
+   *
+   * @param update Is this segment an update to a previous one.
+   * @return A new newsegment event.
+   *
+   * Since 0.10.6
+   */
+  static Glib::RefPtr<Gst::EventNewSegment> create(const GstSegment* segment);
 
+  /**
+   * gst_event_parse_segment:
+   * @event: The event to parse
+   * @segment: (out) (transfer none): a pointer to a #GstSegment
+   *
+   * Parses a segment @event and stores the result in the given @segment location.
+   * @segment remains valid only until the @event is freed. Don't modify the segment
+   * and make a copy if you want to modify it or store it for later use.
+   */
+  void parse(const GstSegment** segment) const;
+  _IGNORE(gst_event_parse_segment)
 };
 
 /** A tag event.
@@ -213,6 +323,7 @@ public:
 class EventTag : public Event
 {
 public:
+
   /** Generates a metadata tag event from the given taglist.
    * @param taglist Metadata list.
    * @return A new Gst::Event.
@@ -220,9 +331,10 @@ public:
   static Glib::RefPtr<Gst::EventTag> create(const Gst::TagList& taglist);
 
   /** Parses a tag event and stores the results in the given taglist location.
+   * @param name Tag name.
    * @return Metadata list.
    */
-  Gst::TagList parse() const;
+  Gst::TagList parse(const Glib::ustring& name) const;
   _IGNORE(gst_event_parse_tag)
 };
 
@@ -231,7 +343,6 @@ public:
 class EventBufferSize : public Event
 {
 public:
-  explicit EventBufferSize(GstEvent* event);
 
   /** Create a new buffersize event. The event is sent downstream and notifies
    * elements that they should provide a buffer of the specified dimensions.
@@ -289,15 +400,73 @@ class EventQos : public Event
 {
 public:
 
-
-  /** Get the proportion, diff and timestamp in the qos event. See create() for
-   * more information about the different QoS values.
-   *
-   * @param proportion A reference to store the proportion in.
-   * @param diff A reference to store the diff in.
-   * @param timestamp A reference to store the timestamp in.
-   */
-  void parse(QOSType& type, double& proportion, ClockTimeDiff& diff, ClockTime& timestamp) const;
+ /**
+  * gst_event_new_qos:
+  * @type: the QoS type
+  * @proportion: the proportion of the qos message
+  * @diff: The time difference of the last Clock sync
+  * @timestamp: The timestamp of the buffer
+  *
+  * Allocate a new qos event with the given values.
+  * The QOS event is generated in an element that wants an upstream
+  * element to either reduce or increase its rate because of
+  * high/low CPU load or other resource usage such as network performance or
+  * throttling. Typically sinks generate these events for each buffer
+  * they receive.
+  *
+  * @type indicates the reason for the QoS event. #GST_QOS_TYPE_OVERFLOW is
+  * used when a buffer arrived in time or when the sink cannot keep up with
+  * the upstream datarate. #GST_QOS_TYPE_UNDERFLOW is when the sink is not
+  * receiving buffers fast enough and thus has to drop late buffers.
+  * #GST_QOS_TYPE_THROTTLE is used when the datarate is artificially limited
+  * by the application, for example to reduce power consumption.
+  *
+  * @proportion indicates the real-time performance of the streaming in the
+  * element that generated the QoS event (usually the sink). The value is
+  * generally computed based on more long term statistics about the streams
+  * timestamps compared to the clock.
+  * A value < 1.0 indicates that the upstream element is producing data faster
+  * than real-time. A value > 1.0 indicates that the upstream element is not
+  * producing data fast enough. 1.0 is the ideal @proportion value. The
+  * proportion value can safely be used to lower or increase the quality of
+  * the element.
+  *
+  * @diff is the difference against the clock in running time of the last
+  * buffer that caused the element to generate the QOS event. A negative value
+  * means that the buffer with @timestamp arrived in time. A positive value
+  * indicates how late the buffer with @timestamp was. When throttling is
+  * enabled, @diff will be set to the requested throttling interval.
+  *
+  * @timestamp is the timestamp of the last buffer that cause the element
+  * to generate the QOS event. It is expressed in running time and thus an ever
+  * increasing value.
+  *
+  * The upstream element can use the @diff and @timestamp values to decide
+  * whether to process more buffers. For possitive @diff, all buffers with
+  * timestamp <= @timestamp + @diff will certainly arrive late in the sink
+  * as well. A (negative) @diff value so that @timestamp + @diff would yield a
+  * result smaller than 0 is not allowed.
+  *
+  * The application can use general event probes to intercept the QoS
+  * event and implement custom application specific QoS handling.
+  *
+  * Returns: (transfer full): a new QOS event.
+  */
+  static Glib::RefPtr<Gst::EventQos> create(GstQOSType type, double proportion,
+    ClockTimeDiff diff, ClockTime timestamp);
+
+ /**
+  * gst_event_parse_qos:
+  * @event: The event to query
+  * @type: (out): A pointer to store the QoS type in
+  * @proportion: (out): A pointer to store the proportion in
+  * @diff: (out): A pointer to store the diff in
+  * @timestamp: (out): A pointer to store the timestamp in
+  *
+  * Get the type, proportion, diff and timestamp in the qos event. See
+  * gst_event_new_qos() for more information about the different QoS values.
+  */
+  void parse(GstQOSType& type, double& proportion, ClockTimeDiff& diff, ClockTime& timestamp) const;
   _IGNORE(gst_event_parse_qos)
 
   /** Get the proportion in the qos event. See create() for more information
@@ -327,6 +496,50 @@ class EventSeek : public Event
 {
 public:
 
+  /** Allocate a new seek event with the given parameters.
+   *
+   * The seek event configures playback of the pipeline between start to stop
+   * at the speed given in rate, also called a playback segment. The start and
+   * stop values are expressed in format.
+   *
+   * A rate of 1.0 means normal playback rate, 2.0 means double speed.
+   * Negatives values means backwards playback. A value of 0.0 for the rate is
+   * not allowed and should be accomplished instead by PAUSING the pipeline.
+   *
+   * A pipeline has a default playback segment configured with a start position
+   * of 0, a stop position of -1 and a rate of 1.0. The currently configured
+   * playback segment can be queried with Gst::QUERY_SEGMENT.
+   *
+   * start_type and stop_type specify how to adjust the currently configured
+   * start and stop fields in segment. Adjustments can be made relative or
+   * absolute to the last configured values. A type of Gst::SEEK_TYPE_NONE
+   * means that the position should not be updated.
+   *
+   * When the rate is positive and start has been updated, playback will start
+   * from the newly configured start position.
+   *
+   * For negative rates, playback will start from the newly configured stop
+   * position (if any). If the stop position if updated, it must be different
+   * from -1 for negative rates.
+   *
+   * It is not possible to seek relative to the current playback position, to
+   * do this, PAUSE the pipeline, query the current playback position with
+   * Gst::QUERY_POSITION and update the playback segment current position with
+   * a Gst::SEEK_TYPE_SET to the desired position.
+   *
+   * @param rate The new playback rate.
+   * @param format The format of the seek values.
+   * @param flags The optional seek flags.
+   * @param start_type The type and flags for the new start position.
+   * @param start The value of the new start position.
+   * @param stop_type The type and flags for the new stop position.
+   * @param stop The value of the new stop position.
+   * @return A new seek event.
+   */
+  static Glib::RefPtr<Gst::EventSeek> create(double rate, Format format,
+    SeekFlags flags, SeekType start_type, gint64 start, SeekType stop_type,
+    gint64 stop);
+
   /** Parses a seek event and stores the results in the given result locations.
    *
    * @param rate Result location for the rate.
@@ -385,6 +598,13 @@ public:
 class EventNavigation : public Event
 {
 public:
+
+  /** Create a new navigation event from the given description.
+   *
+   * @param structure Description of the event.
+   * @return A new Gst::EventNavigation.
+   */
+  static Glib::RefPtr<Gst::EventNavigation> create(Gst::Structure& structure);
 };
 
 /** A latency event.  See create() for more details.
@@ -392,7 +612,6 @@ public:
 class EventLatency : public Event
 {
 public:
-  explicit EventLatency(GstEvent* event);
 
   /** Create a new latency event. The event is sent upstream from the sinks and
    * notifies elements that they should add an additional latency to the
@@ -410,7 +629,7 @@ public:
 
   /** Get the latency in the latency event.
    *
-   * @return The latency. 
+   * @return The latency.
    */
   ClockTime parse() const;
   _IGNORE(gst_event_parse_latency)
@@ -422,6 +641,31 @@ class EventStep : public Event
 {
 public:
 
+  /** Create a new step event. The purpose of the step event is to instruct a
+   * sink to skip @a amount (expressed in @a format) of media. It can be used
+   * to implement stepping through the video frame by frame or for doing fast
+   * trick modes.
+   *
+   * A rate of <= 0.0 is not allowed, pause the pipeline or reverse the
+   * playback direction of the pipeline to get the same effect.
+   *
+   * The @a flush flag will clear any pending data in the pipeline before
+   * starting the step operation.
+   *
+   * The @a intermediate flag instructs the pipeline that this step operation
+   * is part of a larger step operation.
+   *
+   * @param format The format of amount.
+   * @param amount The amount of data to step.
+   * @param rate The step rate.
+   * @param flush Flushing steps.
+   * @param intermediate Intermediate steps.
+   * @return A new Gst::Event.
+   *
+   * Since 0.10.24.
+   */
+  static Glib::RefPtr<Gst::EventStep> create(Gst::Format format,
+    guint64 amount, double rate, bool flush, bool intermediate);
 
   /** Parse the step event.
    *
@@ -467,6 +711,32 @@ class EventSinkMessage : public Event
 {
 public:
 
+  /**
+   * gst_event_new_sink_message:
+   * @name: a name for the event
+   * @msg: (transfer none): the #GstMessage to be posted
+   *
+   * Create a new sink-message event. The purpose of the sink-message event is
+   * to instruct a sink to post the message contained in the event synchronized
+   * with the stream.
+   *
+   * @name is used to store multiple sticky events on one pad.
+   *
+   * Returns: (transfer full): a new #GstEvent
+   */
+  static Glib::RefPtr<Gst::EventSinkMessage>
+    create(const Glib::ustring& name, const Glib::RefPtr<Gst::Message>& message);
+
+  /** Parse the sink-message event.
+   * @return the sink-messge's event message.
+   */
+  Glib::RefPtr<Gst::Message> parse();
+  _IGNORE(gst_event_parse_sink_message)
+
+  /** Parse the sink-message event.
+   * @return the sink-messge's event message.
+   */
+  Glib::RefPtr<const Gst::Message> parse() const;
 };
 
 } //namespace Gst
diff --git a/gstreamer/src/segment.hg b/gstreamer/src/segment.hg
index 5a5662b..262d403 100644
--- a/gstreamer/src/segment.hg
+++ b/gstreamer/src/segment.hg
@@ -19,13 +19,15 @@
 
 #include <gstreamermm/clock.h>
 #include <gstreamermm/format.h>
-#include <gstreamermm/event.h>
 
 _DEFS(gstreamermm,gst)
 
 namespace Gst
 {
 
+_WRAP_ENUM(SeekFlags, GstSeekFlags)
+_WRAP_ENUM(SeekType, GstSeekType)
+
 /** A class that describes the configured region of interest in a media file.
  * This helper structure holds the relevant values for tracking the region of
  * interest in a media file, called a segment.
diff --git a/tools/m4/convert_gst.m4 b/tools/m4/convert_gst.m4
index 2fa80d7..94a7525 100644
--- a/tools/m4/convert_gst.m4
+++ b/tools/m4/convert_gst.m4
@@ -17,6 +17,7 @@ _CONV_ENUM(Gst,ClockTime)
 _CONV_ENUM(Gst,ColorBalanceType)
 _CONV_ENUM(Gst,DiscovererResult)
 _CONV_ENUM(Gst,EventType)
+_CONV_ENUM(Gst,EventTypeFlags)
 _CONV_ENUM(Gst,FlowReturn)
 _CONV_ENUM(Gst,Format)
 _CONV_ENUM(Gst,IndexCertainty)
diff --git a/tools/m4/plugingen_gstreamermm.m4 b/tools/m4/plugingen_gstreamermm.m4
index f5a5238..1db3914 100644
--- a/tools/m4/plugingen_gstreamermm.m4
+++ b/tools/m4/plugingen_gstreamermm.m4
@@ -58,7 +58,6 @@ _ENUM_IS_WRAPPED(GstClockFlags)
 _ENUM_IS_WRAPPED(GstClockReturn)
 _ENUM_IS_WRAPPED(GstColorBalanceType)
 _ENUM_IS_WRAPPED(GstElementFlags)
-_ENUM_IS_WRAPPED(GstEventType)
 _ENUM_IS_WRAPPED(GstEventTypeFlags)
 _ENUM_IS_WRAPPED(GstFlowReturn)
 _ENUM_IS_WRAPPED(GstFormat)
@@ -76,6 +75,7 @@ _ENUM_IS_WRAPPED(GstPadFlags)
 _ENUM_IS_WRAPPED(GstPadLinkReturn)
 _ENUM_IS_WRAPPED(GstPadPresence)
 _ENUM_IS_WRAPPED(GstPadTemplateFlags)
+_ENUM_IS_WRAPPED(GstQOSType)
 _ENUM_IS_WRAPPED(GstQueryType)
 _ENUM_IS_WRAPPED(GstRank)
 _ENUM_IS_WRAPPED(GstSeekFlags)