191 lines
5.2 KiB
C++
191 lines
5.2 KiB
C++
/******************************************************************************
|
|
|
|
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, /* stream is shut down */
|
|
B_RUNNING, /* stream is running */
|
|
B_STOPPING /* waiting for final buffer to return */
|
|
};
|
|
|
|
|
|
/* ================
|
|
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);
|
|
|
|
/* Get or set the minimum delay between sending out successive buffers.
|
|
* 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);
|
|
|
|
/* If no Buffers return to the StreamManager within a period of time, the
|
|
* 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.
|
|
*
|
|
*/
|
|
|
|
/* Set the pending state to B_RUNNING and, if required, start up
|
|
* the processing thread. The processing thread will start
|
|
* emitting buffers to the stream.
|
|
*/
|
|
stream_state Start();
|
|
|
|
/* Set the pending state to B_STOPPING. The processing thread will
|
|
* 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();
|
|
|
|
/* Set the desired state to B_IDLE. The processing thread will
|
|
* stop immediately and all buffers will be "reclaimed" back
|
|
* to the StreamManager.
|
|
*/
|
|
stream_state Abort();
|
|
|
|
/* Return the current state of the stream (B_RUNNING, B_STOPPING, or B_IDLE).
|
|
*/
|
|
stream_state State() const;
|
|
|
|
/* When NotificationPort is set, the receiver will get a message
|
|
* 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);
|
|
|
|
/* Lock the data structures associated with this StreamManager
|
|
*/
|
|
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();
|
|
|
|
/* Set the state of the stream. If newState is the same as the
|
|
* 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);
|
|
|
|
/* Snooze until the desired time arrives. Returns the
|
|
* 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; /* a BBufferStream object */
|
|
stream_state fState; /* running, stopping, etc. */
|
|
sem_id fSem;
|
|
|
|
int32 fBufferCount; /* desired # of buffers */
|
|
int32 fBufferSize; /* desired size of each buffer */
|
|
bigtime_t fBufferDelay; /* minimum time between sends */
|
|
bigtime_t fTimeout; /* watchdog timer */
|
|
|
|
port_id fNotifyPort; /* when set, send change of state msgs */
|
|
thread_id fProcessingThread; /* thread to dispatch buffers */
|
|
subscriber_id fManagerID; /* StreamManager's subID in fStream */
|
|
|
|
BLocker fLock;
|
|
char* fName;
|
|
uint32 _reserved[4];
|
|
};
|
|
|
|
#endif // #ifdef _BUFFER_STREAM_MANAGER_H
|