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 };
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 }
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 }
00169 #endif
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 }
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 }
00236 #endif
00237
00238
00239 namespace Gst
00240 {
00241
00242
00243 class Structure;
00244 class TagList;
00245
00251 Glib::ustring get_name(EventType t);
00252
00258 Glib::QueryQuark get_quark(EventType t);
00259
00291 class Event : public MiniObject
00292 {
00293 protected:
00294
00295 #ifndef DOXYGEN_SHOULD_SKIP_THIS
00296
00297 public:
00298 typedef Event CppObjectType;
00299 typedef Event_Class CppClassType;
00300 typedef GstEvent BaseObjectType;
00301 typedef GstEventClass BaseClassType;
00302
00303 private: friend class Event_Class;
00304 static CppClassType event_class_;
00305
00306 private:
00307
00308 Event(const Event&);
00309 Event& operator=(const Event&);
00310
00311 protected:
00312 explicit Event(GstEvent* castitem);
00313
00314 #endif
00315
00316 public:
00317 virtual ~Event();
00318
00319 #ifndef DOXYGEN_SHOULD_SKIP_THIS
00320 static GType get_type() G_GNUC_CONST;
00321 static GType get_base_type() G_GNUC_CONST;
00322 #endif
00323
00325 GstEvent* gobj() { return reinterpret_cast<GstEvent*>(gobject_); }
00326
00328 const GstEvent* gobj() const { return reinterpret_cast<GstEvent*>(gobject_); }
00329
00331 GstEvent* gobj_copy();
00332
00333 private:
00334
00335
00336 public:
00342 static Glib::RefPtr<Event> wrap(GstEvent* event, bool take_copy=false);
00343
00347 const Structure* get_structure();
00348
00351 bool is_downstream() const;
00352
00355 bool is_serialized() const;
00356
00359 bool is_upstream() const;
00360
00363 EventType get_event_type() const;
00364
00368 ClockTime get_timestamp() const;
00369
00372 Glib::RefPtr<Gst::Object> get_source();
00373 Glib::RefPtr<const Gst::Object> get_source() const;
00374
00375
00376 public:
00377
00378 public:
00379
00380 #ifdef GLIBMM_VFUNCS_ENABLED
00381 #endif //GLIBMM_VFUNCS_ENABLED
00382
00383 protected:
00384
00385 #ifdef GLIBMM_VFUNCS_ENABLED
00386 #endif //GLIBMM_VFUNCS_ENABLED
00387
00388
00389 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
00390 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
00391
00392
00393 };
00394
00397 class EventBufferSize : public Event
00398 {
00399 public:
00400 explicit EventBufferSize(GstEvent* event);
00401
00413 static Glib::RefPtr<Event> create(Format format, gint64 minsize, gint64 maxsize, bool async);
00414
00422 void parse(Format& format, gint64& minsize, gint64& maxsize, bool& async);
00423 };
00424
00427 class EventEos : public Event
00428 {
00429 public:
00430 explicit EventEos(GstEvent* event);
00431
00446 static Glib::RefPtr<Event> create();
00447 };
00448
00451 class EventFlushStart : public Event
00452 {
00453 public:
00454 explicit EventFlushStart(GstEvent* event);
00455
00473 static Glib::RefPtr<Event> create();
00474 };
00475
00478 class EventFlushStop : public Event
00479 {
00480 public:
00481 explicit EventFlushStop(GstEvent* event);
00482
00496 static Glib::RefPtr<Event> create();
00497 };
00498
00501 class EventLatency : public Event
00502 {
00503 public:
00504 explicit EventLatency(GstEvent* event);
00505
00518 static Glib::RefPtr<Event> create(ClockTime latency);
00519
00524 void parse(ClockTime& latency);
00525 };
00526
00529 class EventNavigation : public Event
00530 {
00531 public:
00532 explicit EventNavigation(GstEvent* event);
00533
00539 static Glib::RefPtr<Event> create(Structure& structure);
00540 };
00541
00544 class EventNewSegment : public Event
00545 {
00546 public:
00547 explicit EventNewSegment(GstEvent* event);
00548
00589 static Glib::RefPtr<Event> create(bool update, double rate, Format format, gint64 strat, gint64 stop, gint64 position, double applied_rate=1.0);
00590
00601 void parse(bool& update, double& rate, Format& format, gint64& start, gint64& stop, gint64& position);
00602
00617 void parse(bool& update, double& rate, Format& format, gint64& start, gint64& stop, gint64& position, double& applied_rate);
00618 };
00619
00622 class EventQos : public Event
00623 {
00624 public:
00625 explicit EventQos(GstEvent* event);
00626
00664 static Glib::RefPtr<Event> create(double proportion, ClockTimeDiff diff, ClockTime timestamp);
00665
00673 void parse(double& proportion, ClockTimeDiff& diff, ClockTime& timestamp);
00674 };
00675
00678 class EventSeek : public Event
00679 {
00680 public:
00681 explicit EventSeek(GstEvent* event);
00682
00723 static Glib::RefPtr<Event> create(double rate, Format format, SeekFlags flags, SeekType start_type, gint64 start, SeekType stop_type, gint64 stop);
00724
00736 void parse(double& rate, Format& format, SeekFlags& flags, SeekType& start_type, gint64& start, SeekType& stop_type, gint64& stop);
00737 };
00738
00741 class EventTag : public Event
00742 {
00743 public:
00744 explicit EventTag(GstEvent* event);
00745
00750 static Glib::RefPtr<Event> create(TagList& taglist);
00751
00755 void parse(TagList& taglist);
00756 };
00757
00758 }
00759
00760
00761 namespace Gst
00762 {
00768 Glib::RefPtr<Gst::Event> wrap(GstEvent* object, bool take_copy = false);
00769 }
00770
00771
00772 #endif
00773