00001
00002
00003 #ifndef _GSTREAMERMM_CLOCK_H
00004 #define _GSTREAMERMM_CLOCK_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/gstclock.h>
00031 #include <gstreamermm/object.h>
00032
00033
00034 #ifndef DOXYGEN_SHOULD_SKIP_THIS
00035 typedef struct _GstClock GstClock;
00036 typedef struct _GstClockClass GstClockClass;
00037 #endif
00038
00039
00040 namespace Gst
00041 { class Clock_Class; }
00042 namespace Gst
00043 {
00044
00045 class Clock;
00046
00049 typedef GstClockTime ClockTime;
00050
00053 typedef GstClockTimeDiff ClockTimeDiff;
00054
00057 const ClockTime CLOCK_TIME_NONE = GST_CLOCK_TIME_NONE;
00058
00061 const ClockTime SECOND = GST_SECOND;
00062
00065 const ClockTime MILLI_SECOND = GST_MSECOND;
00066
00069 const ClockTime MICRO_SECOND = GST_USECOND;
00070
00073 const ClockTime NANO_SECOND = GST_NSECOND;
00074
00080 enum ClockEntryType
00081 {
00082 CLOCK_ENTRY_SINGLE,
00083 CLOCK_ENTRY_PERIODIC
00084 };
00085
00086 }
00087
00088
00089 #ifndef DOXYGEN_SHOULD_SKIP_THIS
00090 namespace Glib
00091 {
00092
00093 template <>
00094 class Value<Gst::ClockEntryType> : public Glib::Value_Enum<Gst::ClockEntryType>
00095 {
00096 public:
00097 static GType value_type() G_GNUC_CONST;
00098 };
00099
00100 }
00101 #endif
00102
00103
00104 namespace Gst
00105 {
00106
00110 enum ClockReturn
00111 {
00112 CLOCK_OK,
00113 CLOCK_EARLY,
00114 CLOCK_UNSCHEDULED,
00115 CLOCK_BUSY,
00116 CLOCK_BADTIME,
00117 CLOCK_ERROR,
00118 CLOCK_UNSUPPORTED
00119 };
00120
00121 }
00122
00123
00124 #ifndef DOXYGEN_SHOULD_SKIP_THIS
00125 namespace Glib
00126 {
00127
00128 template <>
00129 class Value<Gst::ClockReturn> : public Glib::Value_Enum<Gst::ClockReturn>
00130 {
00131 public:
00132 static GType value_type() G_GNUC_CONST;
00133 };
00134
00135 }
00136 #endif
00137
00138
00139 namespace Gst
00140 {
00141
00145 enum ClockFlags
00146 {
00147 CLOCK_FLAG_CAN_DO_SINGLE_SYNC = GST_OBJECT_FLAG_LAST << 0,
00148 CLOCK_FLAG_CAN_DO_SINGLE_ASYNC = GST_OBJECT_FLAG_LAST << 1,
00149 CLOCK_FLAG_CAN_DO_PERIODIC_SYNC = GST_OBJECT_FLAG_LAST << 2,
00150 CLOCK_FLAG_CAN_DO_PERIODIC_ASYNC = GST_OBJECT_FLAG_LAST << 3,
00151 CLOCK_FLAG_CAN_SET_RESOLUTION = GST_OBJECT_FLAG_LAST << 4,
00152 CLOCK_FLAG_CAN_SET_MASTER = GST_OBJECT_FLAG_LAST << 5,
00153 CLOCK_FLAG_LAST = GST_OBJECT_FLAG_LAST << 8
00154 };
00155
00156 }
00157
00158
00159 #ifndef DOXYGEN_SHOULD_SKIP_THIS
00160 namespace Glib
00161 {
00162
00163 template <>
00164 class Value<Gst::ClockFlags> : public Glib::Value_Enum<Gst::ClockFlags>
00165 {
00166 public:
00167 static GType value_type() G_GNUC_CONST;
00168 };
00169
00170 }
00171 #endif
00172
00173
00174 namespace Gst
00175 {
00176
00177
00181 class ClockID
00182 {
00183 public:
00184 #ifndef DOXYGEN_SHOULD_SKIP_THIS
00185 typedef ClockID CppObjectType;
00186 typedef GstClockEntry BaseObjectType;
00187 #endif
00188
00189
00190
00191 void reference() const;
00192 void unreference() const;
00193
00195 GstClockEntry* gobj();
00196
00198 const GstClockEntry* gobj() const;
00199
00201 GstClockEntry* gobj_copy() const;
00202
00203 protected:
00204
00205 ClockID();
00206 void operator delete(void*, size_t);
00207
00208 private:
00209
00210 ClockID(const ClockID&);
00211 ClockID& operator=(const ClockID&);
00212
00213
00214 public:
00220 typedef sigc::slot< bool, const Glib::RefPtr<Gst::Clock>&, ClockTime, const Glib::RefPtr<Gst::ClockID>& > SlotClock;
00221
00222
00228 ClockTime get_time() const;
00229
00251 ClockReturn wait(ClockTimeDiff& jitter);
00252
00262 ClockReturn wait();
00263
00272 ClockReturn wait_async(const SlotClock& slot);
00273
00274
00282 void unschedule();
00283
00284
00285 };
00286
00291 guint get_hours(ClockTime time);
00292
00297 guint get_minutes(ClockTime time);
00298
00303 guint get_seconds(ClockTime time);
00304
00309 guint get_milliseconds(ClockTime time);
00310
00315 guint get_microseconds(ClockTime time);
00316
00321 guint get_nanoseconds(ClockTime time);
00322
00327 guint get_fractional_seconds(ClockTime time);
00328
00405 class Clock : public Object
00406 {
00407
00408 #ifndef DOXYGEN_SHOULD_SKIP_THIS
00409
00410 public:
00411 typedef Clock CppObjectType;
00412 typedef Clock_Class CppClassType;
00413 typedef GstClock BaseObjectType;
00414 typedef GstClockClass BaseClassType;
00415
00416 private: friend class Clock_Class;
00417 static CppClassType clock_class_;
00418
00419 private:
00420
00421 Clock(const Clock&);
00422 Clock& operator=(const Clock&);
00423
00424 protected:
00425 explicit Clock(const Glib::ConstructParams& construct_params);
00426 explicit Clock(GstClock* castitem);
00427
00428 #endif
00429
00430 public:
00431 virtual ~Clock();
00432
00433 #ifndef DOXYGEN_SHOULD_SKIP_THIS
00434 static GType get_type() G_GNUC_CONST;
00435 static GType get_base_type() G_GNUC_CONST;
00436 #endif
00437
00439 GstClock* gobj() { return reinterpret_cast<GstClock*>(gobject_); }
00440
00442 const GstClock* gobj() const { return reinterpret_cast<GstClock*>(gobject_); }
00443
00445 GstClock* gobj_copy();
00446
00447 private:
00448
00449
00450 public:
00451
00470 bool add_observation(ClockTime slave_time, ClockTime master_time, gdouble* result);
00471
00489 bool set_master(const Clock& master_clock);
00490
00498 Glib::RefPtr<Gst::Clock> get_master();
00499
00508 ClockTime set_resolution(ClockTime resolution);
00509
00516 ClockTime get_resolution() const;
00517
00526 ClockTime get_time() const;
00527
00536 Glib::RefPtr<Gst::ClockID> create_single_shot_id(ClockTime time);
00537
00548 Glib::RefPtr<Gst::ClockID> create_periodic_id(ClockTime start_time, ClockTime intervals);
00549
00557 ClockTime get_internal_time() const;
00558
00568 ClockTime adjust_unlocked(ClockTime internal_time);
00569
00581 ClockTime unadjust_unlocked(ClockTime external_time);
00582
00595 void get_calibration(ClockTime& internal, ClockTime& external, ClockTime& rate_num, ClockTime& rate_denom);
00596
00626 void set_calibration(ClockTime internal, ClockTime external, ClockTime rate_num, ClockTime rate_denom);
00627
00628 #ifdef GLIBMM_PROPERTIES_ENABLED
00629
00635 Glib::PropertyProxy<bool> property_stats() ;
00636 #endif //#GLIBMM_PROPERTIES_ENABLED
00637
00638 #ifdef GLIBMM_PROPERTIES_ENABLED
00639
00645 Glib::PropertyProxy_ReadOnly<bool> property_stats() const;
00646 #endif //#GLIBMM_PROPERTIES_ENABLED
00647
00648 #ifdef GLIBMM_PROPERTIES_ENABLED
00649
00655 Glib::PropertyProxy<guint64> property_timeout() ;
00656 #endif //#GLIBMM_PROPERTIES_ENABLED
00657
00658 #ifdef GLIBMM_PROPERTIES_ENABLED
00659
00665 Glib::PropertyProxy_ReadOnly<guint64> property_timeout() const;
00666 #endif //#GLIBMM_PROPERTIES_ENABLED
00667
00668 #ifdef GLIBMM_PROPERTIES_ENABLED
00669
00675 Glib::PropertyProxy<int> property_window_size() ;
00676 #endif //#GLIBMM_PROPERTIES_ENABLED
00677
00678 #ifdef GLIBMM_PROPERTIES_ENABLED
00679
00685 Glib::PropertyProxy_ReadOnly<int> property_window_size() const;
00686 #endif //#GLIBMM_PROPERTIES_ENABLED
00687
00688 #ifdef GLIBMM_PROPERTIES_ENABLED
00689
00695 Glib::PropertyProxy<int> property_window_threshold() ;
00696 #endif //#GLIBMM_PROPERTIES_ENABLED
00697
00698 #ifdef GLIBMM_PROPERTIES_ENABLED
00699
00705 Glib::PropertyProxy_ReadOnly<int> property_window_threshold() const;
00706 #endif //#GLIBMM_PROPERTIES_ENABLED
00707
00708
00712 #ifdef GLIBMM_VFUNCS_ENABLED
00713 virtual ClockTime change_resolution_vfunc(ClockTime old_resolution, ClockTime new_resolution);
00714 #endif //GLIBMM_VFUNCS_ENABLED
00715
00716
00719 #ifdef GLIBMM_VFUNCS_ENABLED
00720 virtual ClockTime get_resolution_vfunc();
00721 #endif //GLIBMM_VFUNCS_ENABLED
00722
00723
00726 #ifdef GLIBMM_VFUNCS_ENABLED
00727 virtual ClockTime get_internal_time_vfunc();
00728 #endif //GLIBMM_VFUNCS_ENABLED
00729
00730
00733 #ifdef GLIBMM_VFUNCS_ENABLED
00734 virtual ClockReturn wait_async_vfunc(const Glib::RefPtr<Gst::ClockID>& id);
00735 #endif //GLIBMM_VFUNCS_ENABLED
00736
00737
00740 #ifdef GLIBMM_VFUNCS_ENABLED
00741 virtual void unschedule_vfunc(const Glib::RefPtr<Gst::ClockID>& id);
00742 #endif //GLIBMM_VFUNCS_ENABLED
00743
00744
00748 #ifdef GLIBMM_VFUNCS_ENABLED
00749 virtual ClockReturn wait_jitter_vfunc(const Glib::RefPtr<Gst::ClockID>& id, ClockTimeDiff& jitter);
00750 #endif //GLIBMM_VFUNCS_ENABLED
00751
00752
00753 public:
00754
00755 public:
00756
00757 #ifdef GLIBMM_VFUNCS_ENABLED
00758 #endif //GLIBMM_VFUNCS_ENABLED
00759
00760 protected:
00761
00762 #ifdef GLIBMM_VFUNCS_ENABLED
00763 #endif //GLIBMM_VFUNCS_ENABLED
00764
00765
00766 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
00767 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
00768
00769
00770 };
00771
00772 }
00773
00774
00775 namespace Glib
00776 {
00777
00786 Glib::RefPtr<Gst::ClockID> wrap(GstClockEntry* object, bool take_copy = false);
00787
00788 }
00789
00790
00791 namespace Glib
00792 {
00801 Glib::RefPtr<Gst::Clock> wrap(GstClock* object, bool take_copy = false);
00802 }
00803
00804
00805 #endif
00806