i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

* Rewrote TimeSource.h.

Browse Source 
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@32696 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Axel Dörfler
2009-08-26 11:13:14 +00:00
parent 2d6e435398
commit f808efaf83
1 changed files with 86 additions and 110 deletions
Download Patch File Download Diff File Expand all files Collapse all files
headers/os/media/TimeSource.h
+86 -110
View File
@@ -1,150 +1,126 @@
/******************************************************************************* /*
/ * Copyright 2009, Haiku Inc. All Rights Reserved.
/ File: TimeSource.h * Distributed under the terms of the MIT License.
/ */
/ Description: A BTimeSource is something to which others can slave timing information #ifndef _TIME_SOURCE_H
/ using the Media Kit.
/
/ Copyright 1997-98, Be Incorporated, All Rights Reserved
/
*******************************************************************************/
#if !defined(_TIME_SOURCE_H)
#define _TIME_SOURCE_H #define _TIME_SOURCE_H
#include <MediaDefs.h> #include <MediaDefs.h>
#include <MediaNode.h> #include <MediaNode.h>
class _BSlaveNodeStorageP; class _BSlaveNodeStorageP;
namespace BPrivate { namespace media { namespace BPrivate {
class BMediaRosterEx; namespace media {
class TimeSourceObject; class BMediaRosterEx;
class SystemTimeSourceObject; class TimeSourceObject;
class SlaveNodes; class SystemTimeSourceObject;
struct TimeSourceTransmit; class SlaveNodes;
} } struct TimeSourceTransmit;
}
}
class BTimeSource : class BTimeSource : public virtual BMediaNode {
public virtual BMediaNode
{
protected: protected:
/* this has to be at the top to force a vtable */ virtual ~BTimeSource();
virtual ~BTimeSource();
public: public:
virtual status_t SnoozeUntil(bigtime_t performanceTime,
bigtime_t withLatency = 0,
bool retrySignals = false);
virtual status_t SnoozeUntil( /* returns error if stopped */ bigtime_t Now();
bigtime_t performance_time, bigtime_t PerformanceTimeFor(bigtime_t realTime);
bigtime_t with_latency = 0, bigtime_t RealTimeFor(bigtime_t performanceTime,
bool retry_signals = false); bigtime_t withLatency);
bool IsRunning();
bigtime_t Now(); /* convenience, less accurate */ status_t GetTime(bigtime_t* _performanceTime,
bigtime_t PerformanceTimeFor( /* all three go through GetTime() */ bigtime_t* _realTime, float* _drift);
bigtime_t real_time); status_t GetStartLatency(bigtime_t* _latency);
bigtime_t RealTimeFor(
bigtime_t performance_time,
bigtime_t with_latency);
bool IsRunning();
status_t GetTime( /* return B_OK if reading is usable */ static bigtime_t RealTime();
bigtime_t * performance_time,
bigtime_t * real_time,
float * drift);
static bigtime_t RealTime(); /* this produces real time, nothing else is guaranteed to */
status_t GetStartLatency(
bigtime_t * out_latency);
protected: protected:
BTimeSource();
BTimeSource(); virtual status_t HandleMessage(int32 message, const void* data,
size_t size);
virtual status_t HandleMessage( void PublishTime(bigtime_t performanceTime,
int32 message, bigtime_t realTime, float drift);
const void * data,
size_t size);
void PublishTime( /* call this at convenient times to update approximation */ void BroadcastTimeWarp(bigtime_t atRealTime,
bigtime_t performance_time, bigtime_t newPerformanceTime);
bigtime_t real_time,
float drift);
void BroadcastTimeWarp( void SendRunMode(run_mode mode);
bigtime_t at_real_time, virtual void SetRunMode(run_mode mode);
bigtime_t new_performance_time); /* when running */
void SendRunMode(
run_mode mode);
virtual void SetRunMode( enum time_source_op {
run_mode mode); /* or, instead, SendRunMode() */ B_TIMESOURCE_START = 1,
B_TIMESOURCE_STOP,
B_TIMESOURCE_STOP_IMMEDIATELY,
B_TIMESOURCE_SEEK
};
enum time_source_op { struct time_source_op_info {
B_TIMESOURCE_START = 1, time_source_op op;
B_TIMESOURCE_STOP, int32 _reserved1;
B_TIMESOURCE_STOP_IMMEDIATELY, bigtime_t real_time;
B_TIMESOURCE_SEEK bigtime_t performance_time;
}; int32 _reserved2[6];
struct time_source_op_info { };
time_source_op op;
int32 _reserved1; virtual status_t TimeSourceOp(const time_source_op_info& op,
bigtime_t real_time; void* _reserved) = 0;
bigtime_t performance_time;
int32 _reserved2[6];
};
virtual status_t TimeSourceOp(
const time_source_op_info & op,
void * _reserved) = 0;
private: private:
friend class BMediaNode; friend class BMediaNode;
friend class BMediaRoster; friend class BMediaRoster;
friend class BPrivate::media::BMediaRosterEx; friend class BPrivate::media::BMediaRosterEx;
friend class BPrivate::media::TimeSourceObject;
friend class BPrivate::media::SystemTimeSourceObject; friend class BPrivate::media::SystemTimeSourceObject;
friend class BPrivate::media::TimeSourceObject;
BTimeSource( /* private unimplemented */ BTimeSource(const BTimeSource& other);
const BTimeSource & clone); BTimeSource& operator=(const BTimeSource& other);
BTimeSource & operator=( // not implemented
const BTimeSource & clone);
/* Mmmh, stuffing! */ explicit BTimeSource(media_node_id id);
status_t _Reserved_TimeSource_0(void *); // TimeSourceOp()
virtual status_t _Reserved_TimeSource_1(void *);
virtual status_t _Reserved_TimeSource_2(void *);
virtual status_t _Reserved_TimeSource_3(void *);
virtual status_t _Reserved_TimeSource_4(void *);
virtual status_t _Reserved_TimeSource_5(void *);
bool fStarted; status_t _Reserved_TimeSource_0(void*);
area_id fArea; // used for TimeSourceOp()
volatile BPrivate::media::TimeSourceTransmit *fBuf; virtual status_t _Reserved_TimeSource_1(void*);
BPrivate::media::SlaveNodes *fSlaveNodes; virtual status_t _Reserved_TimeSource_2(void*);
virtual status_t _Reserved_TimeSource_3(void*);
virtual status_t _Reserved_TimeSource_4(void*);
virtual status_t _Reserved_TimeSource_5(void*);
area_id _reserved_area; virtual status_t RemoveMe(BMediaNode* node);
bool fIsRealtime; virtual status_t AddMe(BMediaNode* node);
bool _reserved_bool_[3];
uint32 _reserved_time_source_[10];
explicit BTimeSource( void FinishCreate();
media_node_id id);
void FinishCreate(); /* called by roster and/or server */
virtual status_t RemoveMe(BMediaNode * node); void DirectStart(bigtime_t at);
virtual status_t AddMe(BMediaNode * node); void DirectStop(bigtime_t at, bool immediate);
void DirectSeek(bigtime_t to, bigtime_t at);
void DirectSetRunMode(run_mode mode);
void DirectAddMe(const media_node& node);
void DirectRemoveMe(const media_node& node);
void DirectStart(bigtime_t at); private:
void DirectStop(bigtime_t at, bool immediate); bool fStarted;
void DirectSeek(bigtime_t to, bigtime_t at); area_id fArea;
void DirectSetRunMode(run_mode mode); volatile BPrivate::media::TimeSourceTransmit* fBuf;
void DirectAddMe(const media_node &node); BPrivate::media::SlaveNodes* fSlaveNodes;
void DirectRemoveMe(const media_node &node);
area_id _reserved_area;
bool fIsRealtime;
bool _reserved_bool_[3];
uint32 _reserved_time_source_[10];
}; };
#endif /* _TIME_SOURCE_H */ #endif // _TIME_SOURCE_H