00001
00002
00003 #ifndef _GSTREAMERMM_MESSAGE_H
00004 #define _GSTREAMERMM_MESSAGE_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/gstmessage.h>
00031 #include <gstreamermm/wrap.h>
00032 #include <gstreamermm/format.h>
00033 #include <gstreamermm/clock.h>
00034 #include <gstreamermm/enums.h>
00035
00036
00037 #ifndef DOXYGEN_SHOULD_SKIP_THIS
00038 typedef struct _GstMessage GstMessage;
00039 typedef struct _GstMessageClass GstMessageClass;
00040 #endif
00041
00042
00043 namespace Gst
00044 { class Message_Class; }
00045 namespace Gst
00046 {
00047
00061 enum MessageType
00062 {
00063 MESSAGE_UNKNOWN = 0,
00064 MESSAGE_EOS = 1 << 0,
00065 MESSAGE_ERROR = 1 << 1,
00066 MESSAGE_WARNING = 1 << 2,
00067 MESSAGE_INFO = 1 << 3,
00068 MESSAGE_TAG = 1 << 4,
00069 MESSAGE_BUFFERING = 1 << 5,
00070 MESSAGE_STATE_CHANGED = 1 << 6,
00071 MESSAGE_STATE_DIRTY = 1 << 7,
00072 MESSAGE_STEP_DONE = 1 << 8,
00073 MESSAGE_CLOCK_PROVIDE = 1 << 9,
00074 MESSAGE_CLOCK_LOST = 1 << 10,
00075 MESSAGE_NEW_CLOCK = 1 << 11,
00076 MESSAGE_STRUCTURE_CHANGE = 1 << 12,
00077 MESSAGE_STREAM_STATUS = 1 << 13,
00078 MESSAGE_APPLICATION = 1 << 14,
00079 MESSAGE_ELEMENT = 1 << 15,
00080 MESSAGE_SEGMENT_START = 1 << 16,
00081 MESSAGE_SEGMENT_DONE = 1 << 17,
00082 MESSAGE_DURATION = 1 << 18,
00083 MESSAGE_LATENCY = 1 << 19,
00084 MESSAGE_ASYNC_START = 1 << 20,
00085 MESSAGE_ASYNC_DONE = 1 << 21,
00086 MESSAGE_ANY = ~0
00087 };
00088
00090 inline MessageType operator|(MessageType lhs, MessageType rhs)
00091 { return static_cast<MessageType>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
00092
00094 inline MessageType operator&(MessageType lhs, MessageType rhs)
00095 { return static_cast<MessageType>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
00096
00098 inline MessageType operator^(MessageType lhs, MessageType rhs)
00099 { return static_cast<MessageType>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
00100
00102 inline MessageType operator~(MessageType flags)
00103 { return static_cast<MessageType>(~static_cast<unsigned>(flags)); }
00104
00106 inline MessageType& operator|=(MessageType& lhs, MessageType rhs)
00107 { return (lhs = static_cast<MessageType>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
00108
00110 inline MessageType& operator&=(MessageType& lhs, MessageType rhs)
00111 { return (lhs = static_cast<MessageType>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
00112
00114 inline MessageType& operator^=(MessageType& lhs, MessageType rhs)
00115 { return (lhs = static_cast<MessageType>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
00116
00117 }
00118
00119
00120 #ifndef DOXYGEN_SHOULD_SKIP_THIS
00121 namespace Glib
00122 {
00123
00124 template <>
00125 class Value<Gst::MessageType> : public Glib::Value_Flags<Gst::MessageType>
00126 {
00127 public:
00128 static GType value_type() G_GNUC_CONST;
00129 };
00130
00131 }
00132 #endif
00133
00134
00135 namespace Gst
00136 {
00137
00138
00139 Glib::ustring get_name(MessageType t);
00140 Glib::QueryQuark get_quark(MessageType t);
00141
00142 class Structure;
00143 class TagList;
00144
00161 class Message : public Gst::MiniObject
00162 {
00163 protected:
00164
00165 #ifndef DOXYGEN_SHOULD_SKIP_THIS
00166
00167 public:
00168 typedef Message CppObjectType;
00169 typedef Message_Class CppClassType;
00170 typedef GstMessage BaseObjectType;
00171 typedef GstMessageClass BaseClassType;
00172
00173 private: friend class Message_Class;
00174 static CppClassType message_class_;
00175
00176 private:
00177
00178 Message(const Message&);
00179 Message& operator=(const Message&);
00180
00181 protected:
00182 explicit Message(GstMessage* castitem);
00183
00184 #endif
00185
00186 public:
00187 virtual ~Message();
00188
00189 #ifndef DOXYGEN_SHOULD_SKIP_THIS
00190 static GType get_type() G_GNUC_CONST;
00191 static GType get_base_type() G_GNUC_CONST;
00192 #endif
00193
00195 GstMessage* gobj() { return reinterpret_cast<GstMessage*>(gobject_); }
00196
00198 const GstMessage* gobj() const { return reinterpret_cast<GstMessage*>(gobject_); }
00199
00201 GstMessage* gobj_copy();
00202
00203 private:
00204
00205
00206 public:
00210 const Structure* get_structure();
00211
00212 public:
00218 static Glib::RefPtr<Message> wrap(GstMessage* message, bool take_copy=false);
00219
00220 MessageType get_message_type() const;
00221 ClockTime get_timestamp() const;
00222 Glib::RefPtr<Gst::Object> get_source();
00223 Glib::RefPtr<const Gst::Object> get_source() const;
00224
00225
00226 public:
00227
00228 public:
00229
00230 #ifdef GLIBMM_VFUNCS_ENABLED
00231 #endif //GLIBMM_VFUNCS_ENABLED
00232
00233 protected:
00234
00235 #ifdef GLIBMM_VFUNCS_ENABLED
00236 #endif //GLIBMM_VFUNCS_ENABLED
00237
00238
00239 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
00240 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
00241
00242
00243 };
00244
00245 class MessageApplication : public Message
00246 {
00247 public:
00248 explicit MessageApplication(GstMessage *message);
00249
00250 static Glib::RefPtr<Message> create(const Glib::RefPtr<Object>& src, Structure& structure);
00251 };
00252
00253 class MessageClockProvide : public Message
00254 {
00255 public:
00256 explicit MessageClockProvide(GstMessage *message);
00257
00258 static Glib::RefPtr<Message> create(const Glib::RefPtr<Object>& src, const Glib::RefPtr<Clock>& clock, bool ready);
00259 void parse(Glib::RefPtr<Clock>& clock, bool& ready);
00260 };
00261
00262 class MessageClockLost : public Message
00263 {
00264 public:
00265 explicit MessageClockLost(GstMessage* castitem);
00266
00267 static Glib::RefPtr<Message> create(const Glib::RefPtr<Object>& src, const Glib::RefPtr<Clock>& clock);
00268 void parse(Glib::RefPtr<Clock>& clock);
00269 };
00270
00271 class MessageCustom : public Message
00272 {
00273 public:
00274 explicit MessageCustom(GstMessage* castitem);
00275
00276 static Glib::RefPtr<Message> create(MessageType type, const Glib::RefPtr<Object>& src, Structure& structure);
00277 };
00278
00279 class MessageElement : public Message
00280 {
00281 public:
00282 explicit MessageElement(GstMessage* castitem);
00283
00284 static Glib::RefPtr<Message> create(const Glib::RefPtr<Object>& src, Structure& structure);
00285 };
00286
00287 class MessageEos : public Message
00288 {
00289 public:
00290 explicit MessageEos(GstMessage* castitem);
00291
00292 static Glib::RefPtr<Message> create(const Glib::RefPtr<Object>& src);
00293 };
00294
00295 class MessageError : public Message
00296 {
00297 public:
00298 explicit MessageError(GstMessage* castitem);
00299
00300 static Glib::RefPtr<Message> create(const Glib::RefPtr<Object>& src, Glib::Error& error, const std::string& debug);
00301 void parse(Glib::Error& error, std::string& debug);
00302 void parse(Glib::Error& error);
00303 };
00304
00305 class MessageInfo : public Message
00306 {
00307 public:
00308 explicit MessageInfo(GstMessage* castitem);
00309
00310 static Glib::RefPtr<Message> create(const Glib::RefPtr<Object>& src, Glib::Error& error, const std::string& debug);
00311 void parse(Glib::Error& error, std::string& debug);
00312 };
00313
00314 class MessageNewClock: public Message
00315 {
00316 public:
00317 explicit MessageNewClock(GstMessage* castitem);
00318
00319 static Glib::RefPtr<Message> create(const Glib::RefPtr<Object>& src, const Glib::RefPtr<Clock>& clock);
00320 void parse(Glib::RefPtr<Clock>& clock);
00321 };
00322
00323 class MessageSegmentDone : public Message
00324 {
00325 public:
00326 explicit MessageSegmentDone(GstMessage* castitem);
00327
00328 static Glib::RefPtr<Message> create(const Glib::RefPtr<Object>& src, Format format, gint64 position);
00329 void parse(Format& format, gint64& position);
00330 };
00331
00332 class MessageSegmentStart : public Message
00333 {
00334 public:
00335 explicit MessageSegmentStart(GstMessage* castitem);
00336
00337 static Glib::RefPtr<Message> create(const Glib::RefPtr<Object>& src, Format format, gint64 position);
00338 void parse(Format& format, gint64& position);
00339 };
00340
00341 class MessageStateChanged : public Message
00342 {
00343 public:
00344 explicit MessageStateChanged(GstMessage* castitem);
00345
00346 static Glib::RefPtr<Message> create(const Glib::RefPtr<Object>& src, State oldstate, State newstate, State pending);
00347 void parse(State& oldstate, State& newstate, State& pending);
00348 };
00349
00350 class MessageTag : public Message
00351 {
00352 public:
00353 explicit MessageTag(GstMessage* castitem);
00354
00355 static Glib::RefPtr<Message> create(const Glib::RefPtr<Object>& src, TagList& taglist);
00356 void parse(TagList& taglist);
00357 };
00358
00359 class MessageBuffering : public Message
00360 {
00361 public:
00362 explicit MessageBuffering(GstMessage* castitem);
00363
00364 static Glib::RefPtr<Message> create(const Glib::RefPtr<Object>& src, int percent);
00365 void parse(int& percent);
00366 };
00367
00368 class MessageWarning : public Message
00369 {
00370 public:
00371 explicit MessageWarning(GstMessage* castitem);
00372
00373 static Glib::RefPtr<Message> create(const Glib::RefPtr<Object>& src, Glib::Error& error, const std::string& debug);
00374 void parse(Glib::Error& error, std::string& debug);
00375 };
00376
00377 class MessageDuration : public Message
00378 {
00379 public:
00380 explicit MessageDuration(GstMessage* castitem);
00381
00382 static Glib::RefPtr<Message> create(const Glib::RefPtr<Object>& src, Format format, gint64 position);
00383 void parse(Format& format, gint64& position);
00384 };
00385
00386 class MessageStateDirty : public Message
00387 {
00388 public:
00389 explicit MessageStateDirty(GstMessage* castitem);
00390
00391 static Glib::RefPtr<Message> create(const Glib::RefPtr<Object>& src);
00392 };
00393
00394 class MessageAsyncStart : public Message
00395 {
00396 public:
00397 explicit MessageAsyncStart(GstMessage* castitem);
00398
00399 static Glib::RefPtr<Message> create(const Glib::RefPtr<Object>& src, bool new_base_time);
00400 void parse(bool& new_base_time);
00401 };
00402
00403 class MessageAsyncDone : public Message
00404 {
00405 public:
00406 explicit MessageAsyncDone(GstMessage* castitem);
00407
00408 static Glib::RefPtr<Message> create(const Glib::RefPtr<Object>& src);
00409 };
00410
00411 class MessageLatency : public Message
00412 {
00413 public:
00414 explicit MessageLatency(GstMessage* castitem);
00415
00416 static Glib::RefPtr<Message> create(const Glib::RefPtr<Object>& src);
00417 };
00418
00419 }
00420
00421
00422 namespace Gst
00423 {
00429 Glib::RefPtr<Gst::Message> wrap(GstMessage* object, bool take_copy = false);
00430 }
00431
00432
00433 #endif
00434