FILE: MediaModule.h
REVS: $Revision: 1.1 $
NAME: marc
Copyright (c) 1997 by Be Incorporated. All Rights Reserved.
================ */
#ifndef _MEDIA_MODULE_H
#define _MEDIA_MODULE_H
#include <List.h>
#include <Locker.h>
typedef double mk_time;
typedef double mk_rate;
typedef void (*mk_deferred_call)(void*);
#define B_UNDEFINED_MK_TIME ((mk_time) -1)
enum transport_status {
B_TRANSPORT_RUNNING,
B_TRANSPORT_STOPPED,
B_TRANSPORT_PAUSED
};
enum channel_selector {
B_VIDEO_MAIN_CHANNEL,
B_VIDEO_MONITOR_CHANNEL,
B_AUDIO_FRONT_CHANNEL,
B_AUDIO_CENTER_CHANNEL,
B_AUDIO_REAR_CHANNEL,
B_AUDIO_SUB_CHANNEL,
B_AUDIO_MONITOR_CHANNEL,
B_MIDI_CHANNEL,
B_MISC_CHANNEL
};
class BMediaRenderer;
class BTransport;
class BTimeBase;
class BMessage;
class BMediaChannel;
class BMediaEvent {
public:
virtual ~BMediaEvent() {};
virtual mk_time Start() = 0;
virtual mk_time Duration();
virtual bigtime_t CaptureTime();
};
class BEventStream {
public:
BEventStream();
virtual ~BEventStream();
virtual mk_time Start();
virtual void SetStart(mk_time);
virtual mk_time Duration();
virtual void SetDuration(mk_time);
virtual BMediaEvent* GetEvent(BMediaChannel* channel) = 0;
virtual BMediaEvent* PeekEvent(BMediaChannel* channel,
mk_time asap = 0) = 0;
virtual status_t SeekToTime(BMediaChannel* channel,
mk_time time);
private:
mk_time fStart;
mk_time fDuration;
};
class BMediaRenderer {
public:
BMediaRenderer(const char* name = NULL, int32 priority = B_NORMAL_PRIORITY);
virtual ~BMediaRenderer();
virtual char* Name();
virtual mk_time Latency();
virtual BTransport* Transport();
virtual void SetTransport(BTransport*);
virtual mk_time Start();
virtual mk_time Duration();
virtual BTimeBase* TimeBase();
virtual void Open();
virtual void Close();
virtual void WakeUp();
virtual void TransportChanged(mk_time time, mk_rate rate,
transport_status status);
virtual void StreamChanged();
virtual void OpenReceived();
virtual void CloseReceived();
virtual void WakeUpReceived();
virtual void TransportChangedReceived(mk_time time, mk_rate rate,
transport_status status);
virtual void StreamChangedReceived();
private:
static int32 _LoopThread(void* arg);
void LoopThread();
thread_id fLoopThread;
sem_id fLoopSem;
int32 fFlags;
mk_time fTCTime;
mk_rate fTCRate;
transport_status fTCStatus;
BLocker fLoopLock;
char* fName;
BTransport* fTransport;
};
class BTransport {
public:
BTransport();
virtual ~BTransport();
virtual BTimeBase* TimeBase();
virtual void SetTimeBase(BTimeBase*);
virtual BList* Renderers();
virtual void AddRenderer(BMediaRenderer*);
virtual bool RemoveRenderer(BMediaRenderer*);
virtual transport_status Status();
virtual void SetStatus(transport_status);
virtual mk_time PerformanceTime();
virtual mk_rate PerformanceRate();
virtual mk_time TimeOffset();
virtual void SetTimeOffset(mk_time);
virtual mk_time MaximumLatency();
virtual mk_time PerformanceStart();
virtual mk_time PerformanceEnd();
virtual void Open();
virtual void Close();
virtual void TransportChanged();
virtual void TimeSkipped();
virtual void RequestWakeUp(mk_time, BMediaRenderer*);
virtual void SeekToTime(mk_time);
virtual BMediaChannel* GetChannel(int32 selector);
private:
BTimeBase* fTimeBase;
BList fRenderers;
BList fChannels;
BLocker fChannelListLock;
transport_status fStatus;
mk_time fTimeOffset;
};
class BTimeBase {
public:
BTimeBase(mk_rate rate = 1.0);
virtual ~BTimeBase();
virtual BList* Transports();
virtual void AddTransport(BTransport*);
virtual bool RemoveTransport(BTransport*);
virtual void TimeSkipped();
virtual status_t CallAt(mk_time time, mk_deferred_call function, void* arg);
virtual mk_time Time();
virtual mk_rate Rate();
virtual mk_time TimeAt(bigtime_t system_time);
virtual bigtime_t SystemTimeAt(mk_time time);
virtual void Sync(mk_time time, bigtime_t system_time);
virtual bool IsAbsolute();
private:
static int32 _SnoozeThread(void* arg);
void SnoozeThread();
BList fTransports;
BList fDeferredCalls;
BLocker fLock;
mk_rate fRate;
mk_time fSyncT;
bigtime_t fSyncS;
mk_time fSnoozeUntil;
thread_id fSnoozeThread;
};
class BMediaChannel {
public:
BMediaChannel(mk_rate rate,
BMediaRenderer* renderer = NULL,
BEventStream* source = NULL);
virtual ~BMediaChannel();
virtual BMediaRenderer* Renderer();
virtual void SetRenderer(BMediaRenderer*);
virtual BEventStream* Source();
virtual void SetSource(BEventStream*);
virtual mk_rate Rate();
virtual void SetRate(mk_rate);
bool LockChannel();
status_t LockWithTimeout(bigtime_t);
void UnlockChannel();
virtual void StreamChanged();
private:
mk_rate fRate;
BMediaRenderer* fRenderer;
BEventStream* fSource;
BLocker fChannelLock;
};
#endif
