haiku/headers/os/media/MediaEventLooper.h

170 lines
6.1 KiB
C
Raw Normal View History

/*******************************************************************************
/
/ File: MediaEventLooper.h
/
/ Description: BMediaEventLooper spawns a thread which calls WaitForMessage,
/ pushes BMediaNode messages onto its BTimedEventQueues.
/ informs you when it is time to handle an event.
/ Report your event latency, push other events onto the queue
/ and override HandleEvent to do your work.
/
/ Copyright 1999, Be Incorporated, All Rights Reserved
/
*******************************************************************************/
#if !defined(_MEDIA_EVENT_LOOPER_H)
#define _MEDIA_EVENT_LOOPER_H
#include <MediaNode.h>
#include <TimedEventQueue.h>
class BMediaEventLooper :
public virtual BMediaNode
{
protected:
enum run_state {
B_IN_DISTRESS = -1,
B_UNREGISTERED,
B_STOPPED,
B_STARTED,
B_QUITTING,
B_TERMINATED,
B_USER_RUN_STATES = 0x4000
};
protected:
/* this has to be on top rather than bottom to force a vtable in mwcc */
virtual ~BMediaEventLooper();
explicit BMediaEventLooper(uint32 apiVersion = B_BEOS_VERSION);
/* from BMediaNode */
protected:
virtual void NodeRegistered();
virtual void Start(bigtime_t performance_time);
virtual void Stop(bigtime_t performance_time, bool immediate);
virtual void Seek(bigtime_t media_time, bigtime_t performance_time);
virtual void TimeWarp(bigtime_t at_real_time, bigtime_t to_performance_time);
virtual status_t AddTimer(bigtime_t at_performance_time, int32 cookie);
virtual void SetRunMode(run_mode mode);
/* BMediaEventLooper Hook functions */
protected:
/* you must override to handle your events! */
/* you should not call HandleEvent directly */
virtual void HandleEvent( const media_timed_event *event,
bigtime_t lateness,
bool realTimeEvent = false) = 0;
/* override to clean up custom events you have added to your queue */
virtual void CleanUpEvent(const media_timed_event *event);
/* called from Offline mode to determine the current time of the node */
/* update your internal information whenever it changes */
virtual bigtime_t OfflineTime();
/* override only if you know what you are doing! */
/* otherwise much badness could occur */
/* the actual control loop function: */
/* waits for messages, Pops events off the queue and calls DispatchEvent */
virtual void ControlLoop();
thread_id ControlThread();
protected:
BTimedEventQueue * EventQueue();
BTimedEventQueue * RealTimeQueue();
int32 Priority() const;
int32 RunState() const;
bigtime_t EventLatency() const;
bigtime_t BufferDuration() const;
bigtime_t SchedulingLatency() const;
/* use the priority constants from OS.h */
/* or suggest_thread_priority from scheduler.h */
/* will clamp priorities to be inbetween 5 and 120 */
status_t SetPriority(int32 priority);
/* set the run state */
void SetRunState(run_state state);
/* clamps to 0 if latency < 0 */
void SetEventLatency(bigtime_t latency);
/* clamps to 0 if duration is < 0 */
void SetBufferDuration(bigtime_t duration);
/* set the offline time returned in OfflineTime */
void SetOfflineTime(bigtime_t offTime);
/* spawn and resume the thread - must be called from NodeRegistered */
void Run();
/* close down the thread - must be called from your destructor */
void Quit();
/* calls HandleEvent and does BMediaEventLooper event work */
void DispatchEvent( const media_timed_event *event,
bigtime_t lateness,
bool realTimeEvent = false);
private:
static int32 _ControlThreadStart(void *arg);
static void _CleanUpEntry(const media_timed_event *event, void *context);
void _DispatchCleanUp(const media_timed_event *event);
BTimedEventQueue fEventQueue;
BTimedEventQueue fRealTimeQueue;
thread_id fControlThread;
int32 fCurrentPriority;
int32 fSetPriority;
volatile int32 fRunState;
bigtime_t fEventLatency;
bigtime_t fSchedulingLatency;
bigtime_t fBufferDuration;
bigtime_t fOfflineTime;
uint32 fApiVersion;
private:
/* unimplemented for your protection */
BMediaEventLooper(const BMediaEventLooper&);
BMediaEventLooper& operator=(const BMediaEventLooper&);
protected:
virtual status_t DeleteHook(BMediaNode * node);
/* fragile base class stuffing */
private:
/* it must be thanksgiving!! lots of stuffing! */
virtual status_t _Reserved_BMediaEventLooper_0(int32 arg, ...);
virtual status_t _Reserved_BMediaEventLooper_1(int32 arg, ...);
virtual status_t _Reserved_BMediaEventLooper_2(int32 arg, ...);
virtual status_t _Reserved_BMediaEventLooper_3(int32 arg, ...);
virtual status_t _Reserved_BMediaEventLooper_4(int32 arg, ...);
virtual status_t _Reserved_BMediaEventLooper_5(int32 arg, ...);
virtual status_t _Reserved_BMediaEventLooper_6(int32 arg, ...);
virtual status_t _Reserved_BMediaEventLooper_7(int32 arg, ...);
virtual status_t _Reserved_BMediaEventLooper_8(int32 arg, ...);
virtual status_t _Reserved_BMediaEventLooper_9(int32 arg, ...);
virtual status_t _Reserved_BMediaEventLooper_10(int32 arg, ...);
virtual status_t _Reserved_BMediaEventLooper_11(int32 arg, ...);
virtual status_t _Reserved_BMediaEventLooper_12(int32 arg, ...);
virtual status_t _Reserved_BMediaEventLooper_13(int32 arg, ...);
virtual status_t _Reserved_BMediaEventLooper_14(int32 arg, ...);
virtual status_t _Reserved_BMediaEventLooper_15(int32 arg, ...);
virtual status_t _Reserved_BMediaEventLooper_16(int32 arg, ...);
virtual status_t _Reserved_BMediaEventLooper_17(int32 arg, ...);
virtual status_t _Reserved_BMediaEventLooper_18(int32 arg, ...);
virtual status_t _Reserved_BMediaEventLooper_19(int32 arg, ...);
virtual status_t _Reserved_BMediaEventLooper_20(int32 arg, ...);
virtual status_t _Reserved_BMediaEventLooper_21(int32 arg, ...);
virtual status_t _Reserved_BMediaEventLooper_22(int32 arg, ...);
virtual status_t _Reserved_BMediaEventLooper_23(int32 arg, ...);
/* turkey for weeks! */
bool _reserved_bool_[4];
uint32 _reserved_BMediaEventLooper_[12];
};
#endif