event.h

Go to the documentation of this file.
00001 // -*- c++ -*-
00002 // Generated by gtkmmproc -- DO NOT MODIFY!
00003 #ifndef _GSTREAMERMM_EVENT_H
00004 #define _GSTREAMERMM_EVENT_H
00005 
00006 
00007 #include <glibmm.h>
00008 
00009 // -*- Mode: C++; indent-tabs-mode: nil; c-basic-offset: 2 -*-
00010 
00011 /* gstreamermm - a C++ wrapper for gstreamer
00012  *
00013  * Copyright 2008 The gstreamermm Development Team
00014  *
00015  * This library is free software; you can redistribute it and/or
00016  * modify it under the terms of the GNU Library General Public
00017  * License as published by the Free Software Foundation; either
00018  * version 2 of the License, or (at your option) any later version.
00019  *
00020  * This library is distributed in the hope that it will be useful,
00021  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00022  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00023  * Library General Public License for more details.
00024  *
00025  * You should have received a copy of the GNU Library General Public
00026  * License along with this library; if not, write to the Free
00027  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
00028  */
00029 
00030 #include <gst/gstevent.h>
00031 #include <gstreamermm/wrap.h>
00032 #include <gstreamermm/format.h>
00033 #include <gstreamermm/clock.h>
00034 
00035 
00036 #ifndef DOXYGEN_SHOULD_SKIP_THIS
00037 typedef struct _GstEvent GstEvent;
00038 typedef struct _GstEventClass GstEventClass;
00039 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
00040 
00041 
00042 namespace Gst
00043 { class Event_Class; } // namespace Gst
00044 namespace Gst
00045 {
00046 
00047 enum EventType
00048 {
00049   EVENT_UNKNOWN = GST_EVENT_UNKNOWN,
00050   /* bidirectional events */
00051   EVENT_FLUSH_START = GST_EVENT_FLUSH_START,
00052   EVENT_FLUSH_STOP = GST_EVENT_FLUSH_STOP,
00053   /* downstream serialized events */
00054   EVENT_EOS = GST_EVENT_EOS,
00055   EVENT_NEWSEGMENT = GST_EVENT_NEWSEGMENT,
00056   EVENT_TAG = GST_EVENT_TAG,
00057   EVENT_BUFFERSIZE = GST_EVENT_BUFFERSIZE,
00058   /* upstream events */
00059   EVENT_QOS = GST_EVENT_QOS,
00060   EVENT_SEEK = GST_EVENT_SEEK,
00061   EVENT_NAVIGATION = GST_EVENT_NAVIGATION,
00062   EVENT_LATENCY = GST_EVENT_LATENCY,
00063 
00064   /* custom events start here */
00065   EVENT_CUSTOM_UPSTREAM = GST_EVENT_CUSTOM_UPSTREAM,
00066   EVENT_CUSTOM_DOWNSTREAM = GST_EVENT_CUSTOM_DOWNSTREAM,
00067   EVENT_CUSTOM_DOWNSTREAM_OOB = GST_EVENT_CUSTOM_DOWNSTREAM_OOB,
00068   EVENT_CUSTOM_BOTH = GST_EVENT_CUSTOM_BOTH,
00069   EVENT_CUSTOM_BOTH_OOB = GST_EVENT_CUSTOM_BOTH_OOB
00070 };
00071 
00077 enum SeekType
00078 {
00079   SEEK_TYPE_NONE,
00080   SEEK_TYPE_CUR,
00081   SEEK_TYPE_SET,
00082   SEEK_TYPE_END
00083 };
00084 
00085 } // namespace Gst
00086 
00087 
00088 #ifndef DOXYGEN_SHOULD_SKIP_THIS
00089 namespace Glib
00090 {
00091 
00092 template <>
00093 class Value<Gst::SeekType> : public Glib::Value_Enum<Gst::SeekType>
00094 {
00095 public:
00096   static GType value_type() G_GNUC_CONST;
00097 };
00098 
00099 } // namespace Glib
00100 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
00101 
00102 
00103 namespace Gst
00104 {
00105 
00117 enum SeekFlags
00118 {
00119   SEEK_FLAG_NONE = 0,
00120   SEEK_FLAG_FLUSH = 1 << 0,
00121   SEEK_FLAG_ACCURATE = 1 << 1,
00122   SEEK_FLAG_KEY_UNIT = 1 << 2,
00123   SEEK_FLAG_SEGMENT = 1 << 3
00124 };
00125 
00127 inline SeekFlags operator|(SeekFlags lhs, SeekFlags rhs)
00128   { return static_cast<SeekFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
00129 
00131 inline SeekFlags operator&(SeekFlags lhs, SeekFlags rhs)
00132   { return static_cast<SeekFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
00133 
00135 inline SeekFlags operator^(SeekFlags lhs, SeekFlags rhs)
00136   { return static_cast<SeekFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
00137 
00139 inline SeekFlags operator~(SeekFlags flags)
00140   { return static_cast<SeekFlags>(~static_cast<unsigned>(flags)); }
00141 
00143 inline SeekFlags& operator|=(SeekFlags& lhs, SeekFlags rhs)
00144   { return (lhs = static_cast<SeekFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
00145 
00147 inline SeekFlags& operator&=(SeekFlags& lhs, SeekFlags rhs)
00148   { return (lhs = static_cast<SeekFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
00149 
00151 inline SeekFlags& operator^=(SeekFlags& lhs, SeekFlags rhs)
00152   { return (lhs = static_cast<SeekFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
00153 
00154 } // namespace Gst
00155 
00156 
00157 #ifndef DOXYGEN_SHOULD_SKIP_THIS
00158 namespace Glib
00159 {
00160 
00161 template <>
00162 class Value<Gst::SeekFlags> : public Glib::Value_Flags<Gst::SeekFlags>
00163 {
00164 public:
00165   static GType value_type() G_GNUC_CONST;
00166 };
00167 
00168 } // namespace Glib
00169 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
00170 
00171 
00172 namespace Gst
00173 {
00174 
00186 enum EventTypeFlags
00187 {
00188   EVENT_TYPE_UPSTREAM = 1 << 0,
00189   EVENT_TYPE_DOWNSTREAM = 1 << 1,
00190   EVENT_TYPE_SERIALIZED = 1 << 2
00191 };
00192 
00194 inline EventTypeFlags operator|(EventTypeFlags lhs, EventTypeFlags rhs)
00195   { return static_cast<EventTypeFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
00196 
00198 inline EventTypeFlags operator&(EventTypeFlags lhs, EventTypeFlags rhs)
00199   { return static_cast<EventTypeFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
00200 
00202 inline EventTypeFlags operator^(EventTypeFlags lhs, EventTypeFlags rhs)
00203   { return static_cast<EventTypeFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
00204 
00206 inline EventTypeFlags operator~(EventTypeFlags flags)
00207   { return static_cast<EventTypeFlags>(~static_cast<unsigned>(flags)); }
00208 
00210 inline EventTypeFlags& operator|=(EventTypeFlags& lhs, EventTypeFlags rhs)
00211   { return (lhs = static_cast<EventTypeFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
00212 
00214 inline EventTypeFlags& operator&=(EventTypeFlags& lhs, EventTypeFlags rhs)
00215   { return (lhs = static_cast<EventTypeFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
00216 
00218 inline EventTypeFlags& operator^=(EventTypeFlags& lhs, EventTypeFlags rhs)
00219   { return (lhs = static_cast<EventTypeFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
00220 
00221 } // namespace Gst
00222 
00223 
00224 #ifndef DOXYGEN_SHOULD_SKIP_THIS
00225 namespace Glib
00226 {
00227 
00228 template <>
00229 class Value<Gst::EventTypeFlags> : public Glib::Value_Flags<Gst::EventTypeFlags>
00230 {
00231 public:
00232   static GType value_type() G_GNUC_CONST;
00233 };
00234 
00235 } // namespace Glib
00236 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
00237 
00238 
00239 namespace Gst
00240 {
00241 
00242 
00243 class Structure;
00244 class TagList;
00245 
00246 namespace Enums
00247 {
00248 
00254 Glib::ustring get_name(EventType t);
00255 
00261 Glib::QueryQuark get_quark(EventType t);
00262 
00263 } //namespace Enums
00264 
00296 class Event : public MiniObject
00297 {
00298 protected:
00299   
00300 #ifndef DOXYGEN_SHOULD_SKIP_THIS
00301 
00302 public:
00303   typedef Event CppObjectType;
00304   typedef Event_Class CppClassType;
00305   typedef GstEvent BaseObjectType;
00306   typedef GstEventClass BaseClassType;
00307 
00308 private:  friend class Event_Class;
00309   static CppClassType event_class_;
00310 
00311 private:
00312   // noncopyable
00313   Event(const Event&);
00314   Event& operator=(const Event&);
00315 
00316 protected:
00317   explicit Event(GstEvent* castitem);
00318 
00319 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
00320 
00321 public:
00322   virtual ~Event();
00323 
00324 #ifndef DOXYGEN_SHOULD_SKIP_THIS
00325   static GType get_type()      G_GNUC_CONST;
00326   static GType get_base_type() G_GNUC_CONST;
00327 #endif
00328 
00330   GstEvent*       gobj()       { return reinterpret_cast<GstEvent*>(gobject_); }
00331 
00333   const GstEvent* gobj() const { return reinterpret_cast<GstEvent*>(gobject_); }
00334 
00336   GstEvent* gobj_copy();
00337 
00338 private:
00339 
00340 
00341 public:
00347   static Glib::RefPtr<Event> wrap(GstEvent* event, bool take_copy=false);
00348 
00352   Structure get_structure() const;
00353 
00356   bool is_downstream() const;
00357 
00360   bool is_serialized() const;
00361 
00364   bool is_upstream() const;
00365 
00368    EventType get_event_type() const;
00369  
00373    ClockTime get_timestamp() const;
00374  
00377    Glib::RefPtr<Gst::Object> get_source();
00378   Glib::RefPtr<const Gst::Object> get_source() const;
00379  
00380 
00381 public:
00382 
00383 public:
00384   //C++ methods used to invoke GTK+ virtual functions:
00385 #ifdef GLIBMM_VFUNCS_ENABLED
00386 #endif //GLIBMM_VFUNCS_ENABLED
00387 
00388 protected:
00389   //GTK+ Virtual Functions (override these to change behaviour):
00390 #ifdef GLIBMM_VFUNCS_ENABLED
00391 #endif //GLIBMM_VFUNCS_ENABLED
00392 
00393   //Default Signal Handlers::
00394 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
00395 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
00396 
00397 
00398 };
00399 
00400 //TODO: Modify create methods of derived Event classes to return
00401 //Glib::RefPtr<...> to the derived class and not just Gst::Event. Must deal
00402 //with GstStructure immutability problem (bug #510301) first because casting
00403 //Glib::RefPtrs references the objects which causes problems when GStreamer API
00404 //tries to modify the GstStructures of the objects.
00405 
00408 class EventBufferSize : public Event
00409 {
00410 public:
00411   explicit EventBufferSize(GstEvent* event);
00412 
00424   static Glib::RefPtr<Event> create(Format format, gint64 minsize, gint64 maxsize, bool async);
00425 
00433   void parse(Format& format, gint64& minsize, gint64& maxsize, bool& async);
00434 };
00435 
00438 class EventEos : public Event
00439 {
00440 public:
00441   explicit EventEos(GstEvent* event);
00442 
00457   static Glib::RefPtr<Event> create();
00458 };
00459 
00462 class EventFlushStart : public Event
00463 {
00464 public:
00465   explicit EventFlushStart(GstEvent* event);
00466 
00484   static Glib::RefPtr<Event> create();
00485 };
00486 
00489 class EventFlushStop : public Event
00490 {
00491 public:
00492   explicit EventFlushStop(GstEvent* event);
00493 
00507   static Glib::RefPtr<Event> create();
00508 };
00509 
00512 class EventLatency : public Event
00513 {
00514 public:
00515   explicit EventLatency(GstEvent* event);
00516 
00529   static Glib::RefPtr<Event> create(ClockTime latency);
00530 
00535   void parse(ClockTime& latency);
00536 };
00537 
00540 class EventNavigation : public Event
00541 {
00542 public:
00543   explicit EventNavigation(GstEvent* event);
00544 
00550   static Glib::RefPtr<Event> create(Structure& structure);
00551 };
00552 
00555 class EventNewSegment : public Event
00556 {
00557 public:
00558   explicit EventNewSegment(GstEvent* event);
00559 
00600   static Glib::RefPtr<Event> create(bool update, double rate, Format format, gint64 strat, gint64 stop, gint64 position, double applied_rate=1.0);
00601 
00612   void parse(bool& update, double& rate, Format& format, gint64& start, gint64& stop, gint64& position);
00613 
00628   void parse(bool& update, double& rate, Format& format, gint64& start, gint64& stop, gint64& position, double& applied_rate);
00629 };
00630 
00633 class EventQos : public Event
00634 {
00635 public:
00636   explicit EventQos(GstEvent* event);
00637 
00675   static Glib::RefPtr<Event> create(double proportion, ClockTimeDiff diff, ClockTime timestamp);
00676 
00684   void parse(double& proportion, ClockTimeDiff& diff, ClockTime& timestamp);
00685 };
00686 
00689 class EventSeek : public Event
00690 {
00691 public:
00692   explicit EventSeek(GstEvent* event);
00693 
00734   static Glib::RefPtr<Event> create(double rate, Format format, SeekFlags flags, SeekType start_type, gint64 start, SeekType stop_type, gint64 stop);
00735 
00748   void parse(double& rate, Format& format, SeekFlags& flags, SeekType& start_type, gint64& start, SeekType& stop_type, gint64& stop);
00749 };
00750 
00753 class EventTag : public Event
00754 {
00755 public:
00756   explicit EventTag(GstEvent* event);
00757 
00762   static Glib::RefPtr<Event> create(const TagList& taglist);
00763 
00767   TagList parse();
00768 };
00769 
00770 } //namespace Gst
00771 
00772 
00773 namespace Gst
00774 {
00780   Glib::RefPtr<Gst::Event> wrap(GstEvent* object, bool take_copy = false);
00781 }
00782 
00783 
00784 #endif /* _GSTREAMERMM_EVENT_H */
00785 

Generated on Sun Jul 27 17:07:20 2008 for gstreamermm by  doxygen 1.5.4