00001
00002
00003 #ifndef _GSTREAMERMM_BUFFER_H
00004 #define _GSTREAMERMM_BUFFER_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 #include <gst/gstbuffer.h>
00029 #include <gstreamermm/miniobject.h>
00030 #include <gstreamermm/wrap.h>
00031 #include <gstreamermm/caps.h>
00032
00033
00034 #ifndef DOXYGEN_SHOULD_SKIP_THIS
00035 typedef struct _GstBuffer GstBuffer;
00036 typedef struct _GstBufferClass GstBufferClass;
00037 #endif
00038
00039
00040 namespace Gst
00041 { class Buffer_Class; }
00042 namespace Gst
00043 {
00044
00050 enum BufferFlag
00051 {
00052 BUFFER_FLAG_READONLY = GST_MINI_OBJECT_FLAG_READONLY,
00053 BUFFER_FLAG_PREROLL = GST_MINI_OBJECT_FLAG_READONLY << 0,
00054 BUFFER_FLAG_DISCONT = GST_MINI_OBJECT_FLAG_READONLY << 1,
00055 BUFFER_FLAG_IN_CAPS = GST_MINI_OBJECT_FLAG_READONLY << 2,
00056 BUFFER_FLAG_GAP = GST_MINI_OBJECT_FLAG_READONLY << 3,
00057 BUFFER_FLAG_DELTA_UNIT = GST_MINI_OBJECT_FLAG_READONLY << 4,
00058 BUFFER_FLAG_LAST = GST_MINI_OBJECT_FLAG_READONLY << 8
00059 };
00060
00061 }
00062
00063
00064 #ifndef DOXYGEN_SHOULD_SKIP_THIS
00065 namespace Glib
00066 {
00067
00068 template <>
00069 class Value<Gst::BufferFlag> : public Glib::Value_Enum<Gst::BufferFlag>
00070 {
00071 public:
00072 static GType value_type() G_GNUC_CONST;
00073 };
00074
00075 }
00076 #endif
00077
00078
00079 namespace Gst
00080 {
00081
00093 enum BufferCopyFlags
00094 {
00095 BUFFER_COPY_FLAGS = 1 << 0,
00096 BUFFER_COPY_TIMESTAMPS = 1 << 1,
00097 BUFFER_COPY_CAPS = 1 << 2
00098 };
00099
00101 inline BufferCopyFlags operator|(BufferCopyFlags lhs, BufferCopyFlags rhs)
00102 { return static_cast<BufferCopyFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
00103
00105 inline BufferCopyFlags operator&(BufferCopyFlags lhs, BufferCopyFlags rhs)
00106 { return static_cast<BufferCopyFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
00107
00109 inline BufferCopyFlags operator^(BufferCopyFlags lhs, BufferCopyFlags rhs)
00110 { return static_cast<BufferCopyFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
00111
00113 inline BufferCopyFlags operator~(BufferCopyFlags flags)
00114 { return static_cast<BufferCopyFlags>(~static_cast<unsigned>(flags)); }
00115
00117 inline BufferCopyFlags& operator|=(BufferCopyFlags& lhs, BufferCopyFlags rhs)
00118 { return (lhs = static_cast<BufferCopyFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
00119
00121 inline BufferCopyFlags& operator&=(BufferCopyFlags& lhs, BufferCopyFlags rhs)
00122 { return (lhs = static_cast<BufferCopyFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
00123
00125 inline BufferCopyFlags& operator^=(BufferCopyFlags& lhs, BufferCopyFlags rhs)
00126 { return (lhs = static_cast<BufferCopyFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
00127
00128 }
00129
00130
00131 #ifndef DOXYGEN_SHOULD_SKIP_THIS
00132 namespace Glib
00133 {
00134
00135 template <>
00136 class Value<Gst::BufferCopyFlags> : public Glib::Value_Flags<Gst::BufferCopyFlags>
00137 {
00138 public:
00139 static GType value_type() G_GNUC_CONST;
00140 };
00141
00142 }
00143 #endif
00144
00145
00146 namespace Gst
00147 {
00148
00149
00163 class Buffer : public MiniObject
00164 {
00165 protected:
00166
00167 #ifndef DOXYGEN_SHOULD_SKIP_THIS
00168
00169 public:
00170 typedef Buffer CppObjectType;
00171 typedef Buffer_Class CppClassType;
00172 typedef GstBuffer BaseObjectType;
00173 typedef GstBufferClass BaseClassType;
00174
00175 private: friend class Buffer_Class;
00176 static CppClassType buffer_class_;
00177
00178 private:
00179
00180 Buffer(const Buffer&);
00181 Buffer& operator=(const Buffer&);
00182
00183 protected:
00184 explicit Buffer(GstBuffer* castitem);
00185
00186 #endif
00187
00188 public:
00189 virtual ~Buffer();
00190
00191 #ifndef DOXYGEN_SHOULD_SKIP_THIS
00192 static GType get_type() G_GNUC_CONST;
00193 static GType get_base_type() G_GNUC_CONST;
00194 #endif
00195
00197 GstBuffer* gobj() { return reinterpret_cast<GstBuffer*>(gobject_); }
00198
00200 const GstBuffer* gobj() const { return reinterpret_cast<GstBuffer*>(gobject_); }
00201
00203 GstBuffer* gobj_copy();
00204
00205 private:
00206
00207
00208 public:
00209
00215 static Glib::RefPtr<Gst::Buffer> create();
00216
00229 static Glib::RefPtr<Gst::Buffer> create(guint size);
00230
00235 Glib::RefPtr<Gst::Buffer> copy() const;
00236
00237
00251 void copy_metadata(const Glib::RefPtr<Gst::Buffer>& source_buffer, BufferCopyFlags flags);
00252
00258 bool is_metadata_writable() const;
00259
00265 Glib::RefPtr<Gst::Buffer> create_writable();
00266
00267
00268
00278 Glib::RefPtr<Gst::Buffer> make_metadata_writable() const;
00279
00280
00287 Glib::RefPtr<Gst::Caps> get_caps();
00288
00295 Glib::RefPtr<const Gst::Caps> get_caps() const;
00296
00302 void set_caps(const Glib::RefPtr<Gst::Caps>& caps);
00303
00320 Glib::RefPtr<Gst::Buffer> create_sub(const guint& offset, const guint& size);
00321
00338 Glib::RefPtr<const Gst::Buffer> create_sub(const guint& offset, const guint& size) const;
00339
00349 bool is_span_fast(const Glib::RefPtr<const Gst::Buffer>& other_buffer) const;
00350
00351
00352
00371 Glib::RefPtr<Gst::Buffer> span(const guint32& offset, const Glib::RefPtr<Gst::Buffer>& other_buffer, const guint32& len) const;
00372
00373
00374
00375
00376
00377
00378
00389 Glib::RefPtr<Gst::Buffer> merge(const Glib::RefPtr<const Gst::Buffer>& other_buffer) const;
00390
00394 guint8* get_data() const;
00395
00399 guint get_size() const;
00400
00406 ClockTime get_timestamp() const;
00407
00412 ClockTime get_duration() const;
00413
00417 guint64 get_offset() const;
00418
00422 guint64 get_offset_end() const;
00423
00429 guint8* get_malloc_data() const;
00430
00431
00432
00433
00434 public:
00435
00436 public:
00437
00438 #ifdef GLIBMM_VFUNCS_ENABLED
00439 #endif //GLIBMM_VFUNCS_ENABLED
00440
00441 protected:
00442
00443 #ifdef GLIBMM_VFUNCS_ENABLED
00444 #endif //GLIBMM_VFUNCS_ENABLED
00445
00446
00447 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
00448 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
00449
00450
00451 };
00452
00453 }
00454
00455
00456 namespace Gst
00457 {
00463 Glib::RefPtr<Gst::Buffer> wrap(GstBuffer* object, bool take_copy = false);
00464 }
00465
00466
00467 #endif
00468