/*
 * Copyright 2012, Gerasim Troeglazov (3dEyes**), 3dEyes@gmail.com.
 * All rights reserved.
 * Distributed under the terms of the MIT License.
 */

#ifndef __EQUALIZER_NODE_H__
#define __EQUALIZER_NODE_H__

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

#include "Equalizer.h"

class BMediaAddOn;
class BBufferGroup;

#define BUFF_SIZE 		0x2000

#define ID_AUDIO_INPUT	1
#define	ID_AUDIO_OUTPUT 2

#define P_PREAMP_LABEL 	100
#define P_PREAMP 		101
#define P_MUTE			102
#define P_BYPASS		103
#define	P_BAND_LABELS 	200
#define P_BANDS 		300

class EqualizerNode : public	BBufferConsumer,
					 public	BBufferProducer,
					 public	BControllable,
					 public	BMediaEventLooper {	
public:
	virtual 				~EqualizerNode();
							EqualizerNode(BMediaAddOn* pAddOn = NULL);
	//BMediaNode
public:
	virtual		BMediaAddOn *AddOn(int32* id) const;
	virtual		status_t 	HandleMessage(int32 code, const void* data,	size_t size);
protected:
	virtual 	void 		NodeRegistered();
	//BControllable
public:	
	virtual 	status_t 	GetParameterValue(int32 id,	bigtime_t* lastChangeTime,
								void* value, size_t* size);
	virtual 	void 		SetParameterValue(int32 id,	bigtime_t changeTime,
								const void* value, size_t size);
	//BBufferConsumer
public:
	virtual 	void 		BufferReceived(BBuffer* buffer);									
	virtual 	status_t 	AcceptFormat(const media_destination &dst,
								media_format* format);
	virtual 	status_t 	GetNextInput(int32* cookie,	media_input* input);
	virtual 	void 		DisposeInputCookie(int32 cookie);
	virtual 	status_t 	FormatChanged(const media_source &src,
								const media_destination &dst,
							int32 change_tag, const media_format &format);
	virtual 	void 		ProducerDataStatus(const media_destination &dst,
								int32 status,
								bigtime_t when);	
	virtual 	status_t 	GetLatencyFor(const media_destination &dst,
								bigtime_t* latency,
								media_node_id* time_src);		
	virtual 	status_t 	Connected(const media_source &src, 
								const media_destination &dst,
								const media_format &format,
								media_input* input);
	virtual 	void 		Disconnected(const media_source &src,
								const media_destination &dst);
	//BBufferProducer
public:
	virtual 	status_t 	FormatSuggestionRequested(media_type type,
								int32 quality, media_format* format);
	virtual 	status_t 	FormatProposal(const media_source &src,
								media_format* format);
	virtual 	status_t 	FormatChangeRequested(const media_source &src,
								const media_destination &dst,
								media_format* format,
								int32* _deprecated_);
	virtual 	void 		LateNoticeReceived(const media_source &src,
								bigtime_t late,	bigtime_t when);
	virtual 	status_t	GetNextOutput(int32 *cookie, media_output* output);
	virtual 	status_t 	DisposeOutputCookie(int32 cookie);
	virtual 	status_t	SetBufferGroup(const media_source &src,
								BBufferGroup* group);
	virtual 	status_t 	PrepareToConnect(const media_source &src,
								const media_destination &dst,
								media_format* format, media_source* source,
								char* name);
	virtual 	void 		Connect(status_t status,
								const media_source &src,
								const media_destination &dst,
								const media_format &format,
								char* name);
	virtual		void 		Disconnect(const media_source &src,
								const media_destination &dst);		
	virtual 	void 		EnableOutput(const media_source &src,
								bool enabled, int32* _deprecated_);
	virtual 	status_t 	GetLatency(bigtime_t* outLatency);
	virtual 	void 		LatencyChanged(	const media_source &src,
								const media_destination &dst,
								bigtime_t latency, uint32 flags);
	//BMediaEventLooper	
protected:
	virtual 	bigtime_t 	OfflineTime();
	//EqualizerNode
protected:
	virtual 	void 		HandleEvent(const media_timed_event* event,
								bigtime_t late,
								bool realTimeEvent = false);
				void 		ParameterEventProcessing(const media_timed_event* event);		
				status_t 	ValidateFormat(const media_format &preferred_format,
								media_format &proposed_format);
				void 		SetOutputFormat(media_format &format);
	virtual 	void 		InitParameterValues(void);
	virtual 	void 		InitParameterWeb(void);
	virtual 	void 		InitFilter(void);
	virtual 	bigtime_t 	GetFilterLatency(void);
	virtual 	void 		FilterBuffer(BBuffer* pBuffer);
	
private:
	BMediaAddOn*			fAddOn;
	BParameterWeb*			fWeb;
	
	Equalizer				fEqualizer;
	
	media_format			fPreferredFormat;
	media_format			fFormat;
	media_input				fInputMedia;
	media_output			fOutputMedia;

	int32					fMute;
	int32					fByPass;
	
	bigtime_t				fMuteLastChanged;
	bigtime_t				fByPassLastChanged;	
	bigtime_t				fPreAmpLastChanged;	
	bigtime_t				fBandsLastChanged[EQ_BANDS];	

	bigtime_t				fProcessLatency;
	bigtime_t				fDownstreamLatency;
	bool					fOutputMediaEnabled;
};

#endif //__EQUALIZER_NODE_H__