/*
 * OpenSound media addon for BeOS and Haiku
 *
 * Copyright (c) 2007, François Revol (revol@free.fr)
 * Copyright (c) 2002, 2003 Jerome Duval (jerome.duval@free.fr)
 * Distributed under the terms of the MIT License.
 *
 */
#ifndef _OPENSOUNDNODE_H
#define _OPENSOUNDNODE_H

#include <BufferConsumer.h>
#include <BufferProducer.h>
#include <Controllable.h>
#include <MediaEventLooper.h>
#include <MediaNode.h>
#include <Message.h>
#include <ParameterWeb.h>
#include <TimeSource.h>

class OpenSoundDevice;
class OpenSoundDeviceEngine;
class OpenSoundDeviceMixer;

struct audio_buf_info;
struct flavor_info;

class OpenSoundNode : public BBufferConsumer, public BBufferProducer,
	public BTimeSource, public BMediaEventLooper, public BControllable {

private:
	class NodeInput;
	class NodeOutput;
	friend class NodeInput;
	friend class NodeOutput;

protected:
	virtual						~OpenSoundNode();

public:
	explicit					OpenSoundNode(BMediaAddOn* addon,
									const char* name,
									OpenSoundDevice* device,
									int32 internalID, BMessage* config);

	virtual	status_t			InitCheck() const;

	// BMediaNode interface
public:
	virtual	BMediaAddOn*		AddOn(int32* internalID) const;
		// Who instantiated you -- or NULL for app class

protected:
	virtual	void				Preroll();
		// These don't return errors; instead, they use the global error
		// condition reporter. A node is required to have a queue of at
		// least one pending command (plus TimeWarp) and is recommended to
		// allow for at least one pending command of each type. Allowing an
		// arbitrary number of outstanding commands might be nice, but apps
		// cannot depend on that happening.

public:
	virtual	status_t			HandleMessage(int32 message,
									const void* data, size_t size);
				
protected:
	virtual	void				NodeRegistered();
	virtual	status_t			RequestCompleted(
									const media_request_info& info);
	virtual	void				SetTimeSource(BTimeSource* timeSource);

	// BBufferConsumer interface
protected:
	virtual	status_t			AcceptFormat(
									const media_destination& dest,
									media_format* format);
	virtual	status_t			GetNextInput(int32* cookie,
									media_input* out_input);
	virtual	void				DisposeInputCookie(int32 cookie);
	virtual	void				BufferReceived(BBuffer* buffer);
	virtual	void				ProducerDataStatus(
									const media_destination& for_whom,
									int32 status,
									bigtime_t at_performance_time);
	virtual	status_t			GetLatencyFor(
									const media_destination& for_whom,
									bigtime_t* out_latency,
									media_node_id* out_timesource);
	virtual	status_t			Connected(const media_source& producer,
									const media_destination& where,
									const media_format& with_format,
									media_input* out_input);
			// here's a good place to request buffer group usage

	virtual	void				Disconnected(const media_source& producer,
									const media_destination& where);

	virtual	status_t			FormatChanged(const media_source& producer,
									const media_destination& consumer, 
								int32 change_tag,
								const media_format& format);

	virtual	status_t			SeekTagRequested(
									const media_destination& destination,
									bigtime_t in_target_time,
									uint32 in_flags, 
									media_seek_tag* out_seek_tag,
									bigtime_t* out_tagged_time,
									uint32* out_flags);

	// BBufferProducer interface
protected:
	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* io_format,
									int32* _deprecated_);
	virtual	status_t			GetNextOutput(int32* cookie,
									media_output* out_output);
	virtual	status_t			DisposeOutputCookie(int32 cookie);
	
	virtual	status_t			SetBufferGroup(
									const media_source& for_source,
									BBufferGroup* group);
	
	virtual	status_t			PrepareToConnect(const media_source& what,
									const media_destination& where,
									media_format* format,
									media_source* out_source,
									char* out_name);
	
	virtual	void				Connect(status_t error, 
									const media_source& source,
									const media_destination& destination,
									const media_format& format,
									char* io_name);
	
	virtual	void				Disconnect(const media_source& what,
									const media_destination& where);
	
	virtual	void				LateNoticeReceived(
									const media_source& what,
									bigtime_t how_much,
									bigtime_t performance_time);
	
	virtual	void				EnableOutput(const media_source& what,
									bool enabled, int32* _deprecated_);
	virtual	void				AdditionalBufferRequested(
									const media_source& source,
									media_buffer_id prev_buffer,
									bigtime_t prev_time,
									const media_seek_tag* prev_tag);

	// BMediaEventLooper interface
protected:
		/* you must override to handle your events! */
		/* you should not call HandleEvent directly */
	virtual	void				HandleEvent(const media_timed_event* event,
									bigtime_t lateness,
									bool realTimeEvent = false);

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

	//  BControllable interface
protected:
	virtual	status_t			GetParameterValue(int32 id,
									bigtime_t* last_change,
									void* value, size_t* ioSize);
	virtual	void				SetParameterValue(int32 id,
									bigtime_t when, const void* value,
									size_t size);
	virtual	BParameterWeb*		MakeParameterWeb();

private:
			void 				_ProcessGroup(BParameterGroup* group,
									int32 index, int32& _parameters);
			void 				_ProcessMux(BDiscreteParameter* parameter,
									int32 index);
			status_t			_PropagateParameterChanges(int from,
									int type, const char* id);
		
protected:
	virtual	status_t			HandleStart(const media_timed_event* event,
									bigtime_t lateness,
									bool realTimeEvent = false);
	virtual	status_t			HandleSeek(const media_timed_event* event,
									bigtime_t lateness,
									bool realTimeEvent = false);
	virtual	status_t			HandleWarp(const media_timed_event* event,
									bigtime_t lateness,
									bool realTimeEvent = false);
	virtual	status_t			HandleStop(const media_timed_event* event,
									bigtime_t lateness,
									bool realTimeEvent = false);
	virtual	status_t			HandleBuffer(
									const media_timed_event* event,
									bigtime_t lateness,
									bool realTimeEvent = false);
	virtual	status_t			HandleDataStatus(
									const media_timed_event* event,
									bigtime_t lateness,
									bool realTimeEvent = false);
	virtual	status_t			HandleParameter(
									const media_timed_event* event,
									bigtime_t lateness,
									bool realTimeEvent = false);

public:
	static	void				GetFlavor(flavor_info* outInfo, int32 id);
	static	void				GetFormat(media_format* outFormat);

			status_t			GetConfigurationFor(BMessage* intoMessage);


private:
								OpenSoundNode(const OpenSoundNode& clone);
									// private unimplemented
			OpenSoundNode&		operator=(const OpenSoundNode& clone);	
				
private:
	static	void				_SignalHandler(int sig);

	static	int32				_PlayThreadEntry(void* data);
	static	int32				_RecThreadEntry(void* data);
			int32				_PlayThread(NodeInput* input);
			int32				_RecThread(NodeOutput* output);

			status_t			_StartPlayThread(NodeInput* input);
			status_t			_StopPlayThread(NodeInput* input);
			status_t			_StartRecThread(NodeOutput* output);
			status_t			_StopRecThread(NodeOutput* output);
		
			BBuffer* 			_FillNextBuffer(audio_buf_info* abinfo,
									NodeOutput& channel);
			void				_UpdateTimeSource(bigtime_t performanceTime,
									bigtime_t realTime, float drift);
		
		
			NodeOutput* 		_FindOutput(
									const media_source& source) const;
			NodeInput* 			_FindInput(
									const media_destination& dest) const;
			NodeInput* 			_FindInput(int32 destinationId);
		
private:
			status_t			fInitCheckStatus;

			BMediaAddOn*		fAddOn;
			int32				fId;

			BList				fInputs;
			BList				fOutputs;
		
#if 1
			// TODO: remove and use use a preferred format
			// per NodeInput/NodeOutput channel
			media_format 		fPreferredFormat;
#endif
			bigtime_t 			fLatency;
			bigtime_t			fInternalLatency;
				// this is computed from the real (negotiated) chunk size
				// and bit rate, not the defaults that are in the
				// parameters
			OpenSoundDevice*	fDevice;

			bool 				fTimeSourceStarted;
			bigtime_t			fTimeSourceStartTime;

			BParameterWeb*		fWeb;
			BMessage			fConfig;
};

#endif // _OPENSOUNDNODE_H