File: BufferStreamManager.h
Copyright 1995-97, Be Incorporated
******************************************************************************/
#ifndef _BUFFER_STREAM_MANAGER_H
#define _BUFFER_STREAM_MANAGER_H
#include <OS.h>
#include <SupportDefs.h>
#include <Locker.h>
#include "OldBufferStream.h"
Local Declarations
================ */
#define B_DEFAULT_BSTREAM_COUNT 3
#define B_DEFAULT_BSTREAM_SIZE B_PAGE_SIZE
#define B_DEFAULT_BSTREAM_DELAY 10000
#define B_DEFAULT_BSTREAM_TIMEOUT 5000000
enum stream_state {
B_IDLE = 100,
B_RUNNING,
B_STOPPING
};
Class definition for BBufferStreamManager
================ */
class BBufferStreamManager {
public:
BBufferStreamManager(char* name);
virtual ~BBufferStreamManager();
char *Name() const;
BBufferStream *Stream() const;
int32 BufferCount() const;
void SetBufferCount(int32 count);
int32 BufferSize() const;
void SetBufferSize(int32 bytes);
* Although the StreamManager automatically shuts down when there
* are no more subscribers, setting the minimum delay can prevent
* prevent runaway streams. A zero or negative value means no
* delay.
*/
bigtime_t BufferDelay() const;
void SetBufferDelay(bigtime_t usecs);
* StreamManager will decide that one of the subscribers is broken and
* will go hunting for it. When it finds the offending subscriber,
* it will be removed from the chain with impunity.
*
* The default is B_DEFAULT_TIMEOUT. Setting the timeout to 0 or a
* negative number will disable this.
*/
bigtime_t Timeout() const;
void SetTimeout(bigtime_t usecs);
* Control the running of the stream.
*
*/
* the processing thread. The processing thread will start
* emitting buffers to the stream.
*/
stream_state Start();
* stop emitting new buffers to the stream, and when all buffers
* are accounted for, will automatically set the desired state
* to B_IDLE.
*/
stream_state Stop();
* stop immediately and all buffers will be "reclaimed" back
* to the StreamManager.
*/
stream_state Abort();
*/
stream_state State() const;
* whenever the state of the StreamManager changes. The msg_id of the
* message will be the new state of the StreamManager.
*/
port_id NotificationPort() const;
void SetNotificationPort(port_id port);
*/
bool Lock();
void Unlock();
* Subscribe functions
*/
status_t Subscribe(BBufferStream *stream);
status_t Unsubscribe();
subscriber_id ID() const;
Protected member functions.
================ */
protected:
*
* The processing thread. This thread waits to acquire a Buffer
* (or for the timeout to expire) and takes appropriate action.
*/
virtual void StartProcessing();
virtual void StopProcessing();
static status_t _ProcessingThread(void *arg);
virtual void ProcessingThread();
* current state, this is a no-op. Otherwise, this method will
* notify anyone listening on the notification port about the
* changed state and will send a StateChange buffer through the
* stream.
*/
virtual void SetState(stream_state newState);
* current time upon returning.
*/
bigtime_t SnoozeUntil(bigtime_t sys_time);
Private data.
================ */
private:
virtual void _ReservedBufferStreamManager1();
virtual void _ReservedBufferStreamManager2();
virtual void _ReservedBufferStreamManager3();
*
* Private fields.
*
*/
BBufferStream *fStream;
stream_state fState;
sem_id fSem;
int32 fBufferCount;
int32 fBufferSize;
bigtime_t fBufferDelay;
bigtime_t fTimeout;
port_id fNotifyPort;
thread_id fProcessingThread;
subscriber_id fManagerID;
BLocker fLock;
char* fName;
uint32 _reserved[4];
};
#endif
