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
00246 namespace Enums
00247 {
00248
00254 Glib::ustring get_name(EventType t);
00255
00261 Glib::QueryQuark get_quark(EventType t);
00262
00263 }
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
00313 Event(const Event&);
00314 Event& operator=(const Event&);
00315
00316 protected:
00317 explicit Event(GstEvent* castitem);
00318
00319 #endif
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
00385 #ifdef GLIBMM_VFUNCS_ENABLED
00386 #endif //GLIBMM_VFUNCS_ENABLED
00387
00388 protected:
00389
00390 #ifdef GLIBMM_VFUNCS_ENABLED
00391 #endif //GLIBMM_VFUNCS_ENABLED
00392
00393
00394 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
00395 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
00396
00397
00398 };
00399
00400
00401
00402
00403
00404
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 }
00771
00772
00773 namespace Gst
00774 {
00780 Glib::RefPtr<Gst::Event> wrap(GstEvent* object, bool take_copy = false);
00781 }
00782
00783
00784 #endif
00785