/*
 * Copyright (c) 2002, Jerome Duval (jerome.duval@free.fr)
 * Distributed under the terms of the MIT License.
 */
#ifndef MULTI_AUDIO_NODE_H
#define MULTI_AUDIO_NODE_H


#include <BufferConsumer.h>
#include <BufferProducer.h>
#include <Controllable.h>
#include <Locker.h>
#include <MediaAddOn.h>
#include <MediaDefs.h>
#include <MediaEventLooper.h>
#include <MediaNode.h>
#include <Message.h>
#include <TimeSource.h>

#include "hmulti_audio.h"
#include "MultiAudioDevice.h"
#include "TimeComputer.h"


class BDiscreteParameter;
class BParameterGroup;

class node_input;
class node_output;


class MultiAudioNode : public BBufferConsumer, public BBufferProducer,
		public BTimeSource,	public BMediaEventLooper, public BControllable {
protected:
	virtual						~MultiAudioNode();

public:
								MultiAudioNode(BMediaAddOn* addon,
									const char* name, MultiAudioDevice* device,
									int32 internalID, BMessage* config);

	virtual status_t			InitCheck() const;

	static	void				GetFlavor(flavor_info* info, int32 id);
	static	void				GetFormat(media_format* outFormat);

			status_t			GetConfigurationFor(BMessage* message);

	// BMediaNode methods
	virtual	BMediaAddOn*		AddOn(int32* internalID) const;
	virtual	status_t			HandleMessage(int32 message, const void* data,
									size_t size);

protected:
	virtual	void				Preroll();
	virtual	void				NodeRegistered();
	virtual	status_t			RequestCompleted(
									const media_request_info& info);
	virtual	void				SetTimeSource(BTimeSource* timeSource);

	// BBufferConsumer methods

	virtual	status_t			AcceptFormat(const media_destination& dest,
									media_format* format);
	virtual	status_t			GetNextInput(int32* cookie, media_input* input);
	virtual	void				DisposeInputCookie(int32 cookie);
	virtual	void				BufferReceived(BBuffer* buffer);
	virtual	void				ProducerDataStatus(
									const media_destination& forWhom,
									int32 status, bigtime_t atPerformanceTime);
	virtual	status_t			GetLatencyFor(const media_destination& forWhom,
									bigtime_t* latency,
									media_node_id* timeSource);
	virtual	status_t	 		Connected(const media_source& producer,
									const media_destination& where,
									const media_format& withFormat,
									media_input* input);
	virtual	void				Disconnected(const media_source& producer,
									const media_destination& where);
	virtual	status_t			FormatChanged(const media_source& producer,
									const media_destination& consumer,
									int32 changeTag,
									const media_format& format);

	virtual	status_t			SeekTagRequested(
									const media_destination& destination,
									bigtime_t targetTime, uint32 flags,
									media_seek_tag* _seekTag,
									bigtime_t* _taggedTime, uint32* _flags);

	// BBufferProducer methods

	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			PrepareToConnect(const media_source& what,
									const media_destination& where,
									media_format* format, media_source* source,
									char* name);

	virtual void				Connect(status_t error,
									const media_source& source,
									const media_destination& destination,
									const media_format& format, char* name);
	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 void				AdditionalBufferRequested(
									const media_source& source,
									media_buffer_id previousBuffer,
									bigtime_t previousTime,
									const media_seek_tag* previousTag);

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

	// BTimeSource methods
	virtual void				SetRunMode(run_mode mode);
	virtual status_t			TimeSourceOp(const time_source_op_info& op,
									void *_reserved);

	// BControllable methods
	virtual status_t			GetParameterValue(int32 id,
									bigtime_t* lastChange, void* value,
									size_t* size);
	virtual void				SetParameterValue(int32 id, bigtime_t when,
									const void* value, size_t size);
	virtual BParameterWeb*		MakeParameterWeb();

private:
	// private unimplemented
								MultiAudioNode(const MultiAudioNode& clone);
	MultiAudioNode& 			operator=(const MultiAudioNode& clone);

			status_t			_HandleStart(const media_timed_event* event,
									bigtime_t lateness,
									bool realTimeEvent = false);
			status_t			_HandleSeek(const media_timed_event* event,
									bigtime_t lateness,
									bool realTimeEvent = false);
			status_t			_HandleWarp(const media_timed_event* event,
									bigtime_t lateness,
									bool realTimeEvent = false);
			status_t			_HandleStop(const media_timed_event* event,
									bigtime_t lateness,
									bool realTimeEvent = false);
			status_t			_HandleBuffer(const media_timed_event* event,
									bigtime_t lateness,
									bool realTimeEvent = false);
			status_t			_HandleDataStatus(
									const media_timed_event* event,
									bigtime_t lateness,
									bool realTimeEvent = false);
			status_t			_HandleParameter(const media_timed_event* event,
									bigtime_t lateness,
									bool realTimeEvent = false);

			char*				_PlaybackBuffer(int32 cycle, int32 channel)
									{ return fDevice->BufferList()
										.playback_buffers
											[cycle][channel].base; }
			uint32				_PlaybackStride(int32 cycle, int32 channel)
									{ return fDevice->BufferList()
										.playback_buffers
											[cycle][channel].stride; }

			char*				_RecordBuffer(int32 cycle, int32 channel)
									{ return fDevice->BufferList()
										.record_buffers
											[cycle][channel].base; }
			uint32				_RecordStride(int32 cycle, int32 channel)
									{ return fDevice->BufferList()
										.record_buffers
											[cycle][channel].stride; }

			void				_WriteZeros(node_input& input,
									uint32 bufferCycle);
			void				_FillWithZeros(node_input& input);
			void				_FillNextBuffer(node_input& channel,
									BBuffer* buffer);

	static	int32				_OutputThreadEntry(void* data);
			int32				_OutputThread();
			status_t			_StartOutputThreadIfNeeded();
			status_t			_StopOutputThread();

			void	 			_AllocateBuffers(node_output& channel);
			BBuffer*	 		_FillNextBuffer(multi_buffer_info& info,
									node_output& output);
			void				_UpdateTimeSource(multi_buffer_info& info,
									node_input& input);

			node_output*	 	_FindOutput(media_source source);
			node_input* 		_FindInput(media_destination destination);
			node_input* 		_FindInput(int32 destinationId);

			const char*			_GetControlName(multi_mix_control& control);
			void 				_ProcessGroup(BParameterGroup* group,
									int32 index, int32& numParameters);
			void 				_ProcessMux(BDiscreteParameter* parameter,
									int32 index);
			void				_CreateFrequencyParameterGroup(
									BParameterGroup* parentGroup,
									const char* name, int32 parameterID,
									uint32 rateMask);

			status_t			_SetNodeInputFrameRate(float frameRate);
			status_t			_SetNodeOutputFrameRate(float frameRate);
			void				_UpdateInternalLatency(
									const media_format& format);

private:
			status_t			fInitStatus;

			BMediaAddOn*		fAddOn;
			int32				fId;

			BLocker				fBufferLock;

			BList				fInputs;
			TimeComputer		fTimeComputer;

			bigtime_t 			fLatency;
			BList				fOutputs;
			media_format 		fOutputPreferredFormat;
			media_format 		fInputPreferredFormat;

			bigtime_t			fInternalLatency;
				// this is computed from the real (negotiated) chunk size and bit rate,
				// not the defaults that are in the parameters
			bigtime_t			fBufferPeriod;

			int32				fQuitThread;
			thread_id			fThread;
			MultiAudioDevice*	fDevice;
			bool 				fTimeSourceStarted;
			BParameterWeb*		fWeb;
			BMessage			fConfig;
};


#endif	// MULTI_AUDIO_NODE_H