00001
00002
00003 #ifndef _GSTREAMERMM_EVENT_H
00004 #define _GSTREAMERMM_EVENT_H
00005
00006
00007 #include <glibmm.h>
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
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
00040
00041
00042 namespace Gst
00043 { class Event_Class; }
00044 namespace Gst
00045 {
00046
00047 enum EventType
00048 {
00049 EVENT_UNKNOWN = GST_EVENT_UNKNOWN,
00050
00051 EVENT_FLUSH_START = GST_EVENT_FLUSH_START,
00052 EVENT_FLUSH_STOP = GST_EVENT_FLUSH_STOP,
00053
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
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
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 }
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 }
00100 #endif
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 SEEK_FLAG_SKIP = 1 << 4
00125 };
00126
00128 inline SeekFlags operator|(SeekFlags lhs, SeekFlags rhs)
00129 { return static_cast<SeekFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
00130
00132 inline SeekFlags operator&(SeekFlags lhs, SeekFlags rhs)
00133 { return static_cast<SeekFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
00134
00136 inline SeekFlags operator^(SeekFlags lhs, SeekFlags rhs)
00137 { return static_cast<SeekFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
00138
00140 inline SeekFlags operator~(SeekFlags flags)
00141 { return static_cast<SeekFlags>(~static_cast<unsigned>(flags)); }
00142
00144 inline SeekFlags& operator|=(SeekFlags& lhs, SeekFlags rhs)
00145 { return (lhs = static_cast<SeekFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
00146
00148 inline SeekFlags& operator&=(SeekFlags& lhs, SeekFlags rhs)
00149 { return (lhs = static_cast<SeekFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
00150
00152 inline SeekFlags& operator^=(SeekFlags& lhs, SeekFlags rhs)
00153 { return (lhs = static_cast<SeekFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
00154
00155 }
00156
00157
00158 #ifndef DOXYGEN_SHOULD_SKIP_THIS
00159 namespace Glib
00160 {
00161
00162 template <>
00163 class Value<Gst::SeekFlags> : public Glib::Value_Flags<Gst::SeekFlags>
00164 {
00165 public:
00166 static GType value_type() G_GNUC_CONST;
00167 };
00168
00169 }
00170 #endif
00171
00172
00173 namespace Gst
00174 {
00175
00187 enum EventTypeFlags
00188 {
00189 EVENT_TYPE_UPSTREAM = 1 << 0,
00190 EVENT_TYPE_DOWNSTREAM = 1 << 1,
00191 EVENT_TYPE_SERIALIZED = 1 << 2
00192 };
00193
00195 inline EventTypeFlags operator|(EventTypeFlags lhs, EventTypeFlags rhs)
00196 { return static_cast<EventTypeFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
00197
00199 inline EventTypeFlags operator&(EventTypeFlags lhs, EventTypeFlags rhs)
00200 { return static_cast<EventTypeFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
00201
00203 inline EventTypeFlags operator^(EventTypeFlags lhs, EventTypeFlags rhs)
00204 { return static_cast<EventTypeFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
00205
00207 inline EventTypeFlags operator~(EventTypeFlags flags)
00208 { return static_cast<EventTypeFlags>(~static_cast<unsigned>(flags)); }
00209
00211 inline EventTypeFlags& operator|=(EventTypeFlags& lhs, EventTypeFlags rhs)
00212 { return (lhs = static_cast<EventTypeFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
00213
00215 inline EventTypeFlags& operator&=(EventTypeFlags& lhs, EventTypeFlags rhs)
00216 { return (lhs = static_cast<EventTypeFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
00217
00219 inline EventTypeFlags& operator^=(EventTypeFlags& lhs, EventTypeFlags rhs)
00220 { return (lhs = static_cast<EventTypeFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
00221
00222 }
00223
00224
00225 #ifndef DOXYGEN_SHOULD_SKIP_THIS
00226 namespace Glib
00227 {
00228
00229 template <>
00230 class Value<Gst::EventTypeFlags> : public Glib::Value_Flags<Gst::EventTypeFlags>
00231 {
00232 public:
00233 static GType value_type() G_GNUC_CONST;
00234 };
00235
00236 }
00237 #endif
00238
00239
00240 namespace Gst
00241 {
00242
00243
00244 class Structure;
00245 class TagList;
00246
00247 namespace Enums
00248 {
00249
00255 Glib::ustring get_name(EventType type);
00256
00262 Glib::QueryQuark get_quark(EventType type);
00263
00268 EventTypeFlags get_flags(EventType type);
00269
00270 }
00271
00303 class Event : public MiniObject
00304 {
00305 protected:
00306
00307 #ifndef DOXYGEN_SHOULD_SKIP_THIS
00308
00309 public:
00310 typedef Event CppObjectType;
00311 typedef Event_Class CppClassType;
00312 typedef GstEvent BaseObjectType;
00313 typedef GstEventClass BaseClassType;
00314
00315 private: friend class Event_Class;
00316 static CppClassType event_class_;
00317
00318 private:
00319
00320 Event(const Event&);
00321 Event& operator=(const Event&);
00322
00323 protected:
00324 explicit Event(GstEvent* castitem);
00325
00326 #endif
00327
00328 public:
00329 virtual ~Event();
00330
00331 #ifndef DOXYGEN_SHOULD_SKIP_THIS
00332 static GType get_type() G_GNUC_CONST;
00333 static GType get_base_type() G_GNUC_CONST;
00334 #endif
00335
00337 GstEvent* gobj() { return reinterpret_cast<GstEvent*>(gobject_); }
00338
00340 const GstEvent* gobj() const { return reinterpret_cast<GstEvent*>(gobject_); }
00341
00343 GstEvent* gobj_copy();
00344
00345 private:
00346
00347
00348 public:
00354 static Glib::RefPtr<Gst::Event> wrap(GstEvent* event, bool take_copy=false);
00355
00359 Glib::RefPtr<Gst::Event> copy() const;
00360
00361
00369 const Gst::Structure get_structure() const;
00370
00378 bool has_name(const Glib::ustring& name);
00379
00384 Glib::RefPtr<Gst::Event> create_writable();
00385
00388 bool is_downstream() const;
00389
00392 bool is_serialized() const;
00393
00396 bool is_upstream() const;
00397
00400 EventType get_event_type() const;
00401
00405 ClockTime get_timestamp() const;
00406
00409 Glib::RefPtr<Gst::Object> get_source();
00410 Glib::RefPtr<const Gst::Object> get_source() const;
00411
00412
00413 public:
00414
00415 public:
00416
00417 #ifdef GLIBMM_VFUNCS_ENABLED
00418 #endif //GLIBMM_VFUNCS_ENABLED
00419
00420 protected:
00421
00422 #ifdef GLIBMM_VFUNCS_ENABLED
00423 #endif //GLIBMM_VFUNCS_ENABLED
00424
00425
00426 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
00427 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
00428
00429
00430 };
00431
00432
00433
00434
00435
00436
00437
00440 class EventFlushStart : public Event
00441 {
00442 public:
00443 explicit EventFlushStart(GstEvent* event);
00444
00462 static Glib::RefPtr<Gst::Event> create();
00463 };
00464
00467 class EventFlushStop : public Event
00468 {
00469 public:
00470 explicit EventFlushStop(GstEvent* event);
00471
00485 static Glib::RefPtr<Gst::Event> create();
00486 };
00487
00490 class EventEos : public Event
00491 {
00492 public:
00493 explicit EventEos(GstEvent* event);
00494
00509 static Glib::RefPtr<Gst::Event> create();
00510 };
00511
00514 class EventNewSegment : public Event
00515 {
00516 public:
00517 explicit EventNewSegment(GstEvent* event);
00518
00559 static Glib::RefPtr<Gst::Event> create(bool update, double rate, Format format, gint64 strat, gint64 stop, gint64 position, double applied_rate=1.0);
00560
00571 void parse(bool& update, double& rate, Format& format, gint64& start, gint64& stop, gint64& position);
00572
00587 void parse(bool& update, double& rate, Format& format, gint64& start, gint64& stop, gint64& position, double& applied_rate);
00588
00589 };
00590
00593 class EventTag : public Event
00594 {
00595 public:
00596 explicit EventTag(GstEvent* event);
00597
00602 static Glib::RefPtr<Gst::Event> create(const Gst::TagList& taglist);
00603
00607 Gst::TagList parse();
00608
00609 };
00610
00613 class EventBufferSize : public Event
00614 {
00615 public:
00616 explicit EventBufferSize(GstEvent* event);
00617
00629 static Glib::RefPtr<Gst::Event> create(Format format, gint64 minsize, gint64 maxsize, bool async);
00630
00638 void parse(Format& format, gint64& minsize, gint64& maxsize, bool& async);
00639
00640 };
00641
00644 class EventQos : public Event
00645 {
00646 public:
00647 explicit EventQos(GstEvent* event);
00648
00686 static Glib::RefPtr<Gst::Event> create(double proportion, ClockTimeDiff diff, ClockTime timestamp);
00687
00695 void parse(double& proportion, ClockTimeDiff& diff, ClockTime& timestamp);
00696
00697 };
00698
00701 class EventSeek : public Event
00702 {
00703 public:
00704 explicit EventSeek(GstEvent* event);
00705
00746 static Glib::RefPtr<Gst::Event> create(double rate, Format format, SeekFlags flags, SeekType start_type, gint64 start, SeekType stop_type, gint64 stop);
00747
00760 void parse(double& rate, Format& format, SeekFlags& flags, SeekType& start_type, gint64& start, SeekType& stop_type, gint64& stop);
00761
00762 };
00763
00766 class EventNavigation : public Event
00767 {
00768 public:
00769 explicit EventNavigation(GstEvent* event);
00770
00776 static Glib::RefPtr<Gst::Event> create(Gst::Structure& structure);
00777 };
00778
00781 class EventLatency : public Event
00782 {
00783 public:
00784 explicit EventLatency(GstEvent* event);
00785
00798 static Glib::RefPtr<Gst::Event> create(ClockTime latency);
00799
00804 void parse(ClockTime& latency);
00805
00806 };
00807
00808 }
00809
00810
00811 namespace Gst
00812 {
00818 Glib::RefPtr<Gst::Event> wrap(GstEvent* object, bool take_copy = false);
00819 }
00820
00821
00822 #endif
00823