haiku.git

/*	Copyright (c) 1998-99, Be Incorporated, All Rights Reserved.
 *	Distributed under the terms of the Be Sample Code license.
 *
 *	Copyright (c) 2000-2008, Ingo Weinhold <ingo_weinhold@gmx.de>,
 *	Copyright (c) 2000-2008, Stephan Aßmus <superstippi@gmx.de>,
 *	All Rights Reserved. Distributed under the terms of the MIT license.
 */
#ifndef AUDIO_PRODUCER_H
#define AUDIO_PRODUCER_H


#include <BufferProducer.h>
#include <MediaEventLooper.h>


class AudioSupplier;
class BHandler;

enum {
	MSG_PEAK_NOTIFICATION		= 'pknt'
};


class AudioProducer : public BBufferProducer, public BMediaEventLooper {
public:
								AudioProducer(const char* name,
									AudioSupplier* supplier,
									bool lowLatency = true);
	virtual						~AudioProducer();

	// BMediaNode interface
	virtual	BMediaAddOn*		AddOn(int32 *internal_id) const;

	// BBufferProducer interface
	virtual	status_t			FormatSuggestionRequested(media_type type,
									int32 quality, media_format* _format);

	virtual	status_t			FormatProposal(const media_source& output,
									media_format* format);

	virtual	status_t			FormatChangeRequested(
									const media_source& source,
									const media_destination& destination,
									media_format* ioFormat,
									int32* _deprecated_);

	virtual	status_t			GetNextOutput(int32* cookie,
									media_output* _output);

	virtual	status_t			DisposeOutputCookie(int32 cookie);

	virtual	status_t			SetBufferGroup(const media_source& forSource,
									BBufferGroup* group);

	virtual	status_t			GetLatency(bigtime_t* _latency);

	virtual	status_t			PrepareToConnect(const media_source& what,
									const media_destination& where,
									media_format* format,
									media_source* outSource, char* outName);

	virtual	void				Connect(status_t error,
									const media_source& source,
									const media_destination& destination,
									const media_format& format,
									char* ioName);

	virtual	void				Disconnect(const media_source &what,
									const media_destination& where);

	virtual	void				LateNoticeReceived(const media_source& what,
									bigtime_t howMuch,
									bigtime_t performanceTime);

	virtual	void				EnableOutput(const media_source& what,
									bool enabled, int32* _deprecated_);

	virtual	status_t			SetPlayRate(int32 numer, int32 denom);

	virtual	status_t			HandleMessage(int32 message,
									const void* data, size_t size);

	virtual	void				AdditionalBufferRequested(
									const media_source& source,
									media_buffer_id prevBuffer,
									bigtime_t prevTime,
									const media_seek_tag* prevTag);
										// may be NULL

	virtual	void				LatencyChanged(const media_source& source,
									const media_destination& destination,
									bigtime_t newLatency, uint32 flags);

	// BMediaEventLooper interface
	virtual	void				NodeRegistered();

	virtual	void				SetRunMode(run_mode mode);

	virtual	void				HandleEvent(const media_timed_event* event,
									bigtime_t lateness,
									bool realTimeEvent = false);

	// AudioProducer
			void				SetPeakListener(BHandler* handler);

			status_t			ChangeFormat(media_format* format);

private:
			status_t			_SpecializeFormat(media_format* format);
			status_t			_ChangeFormat(const media_format& format);
			status_t			_AllocateBuffers(const media_format& format);
			BBuffer*			_FillNextBuffer(bigtime_t eventTime);

			void				_FillSampleBuffer(float* data,
									size_t numSamples);

			BBufferGroup*		fBufferGroup;
			bool				fUsingOurBuffers;
			bigtime_t			fLatency;
			bigtime_t			fInternalLatency;
			bigtime_t			fLastLateNotice;
			bigtime_t			fNextScheduledBuffer;
			bool				fLowLatency;
			media_output		fOutput;
			bool				fOutputEnabled;
			media_format		fPreferredFormat;

			uint64				fFramesSent;
			bigtime_t			fStartTime;

			AudioSupplier*		fSupplier;

			BHandler*			fPeakListener;
};

#endif // AUDIO_PRODUCER_H