/*
 * Copyright 2014-2016, Dario Casalinuovo
 * Copyright 1999, Be Incorporated
 * All Rights Reserved.
 * This file may be used under the terms of the Be Sample Code License.
 */
#ifndef _MEDIA_RECORDER_NODE_H
#define _MEDIA_RECORDER_NODE_H


#include <BufferConsumer.h>
#include <MediaEventLooper.h>
#include <MediaRecorder.h>
#include <String.h>


namespace BPrivate { namespace media {


class BMediaRecorderNode : public BMediaEventLooper,
	public BBufferConsumer {
public:
								BMediaRecorderNode(const char* name,
									BMediaRecorder* recorder,
									media_type type
										= B_MEDIA_UNKNOWN_TYPE);

			//	TODO these are not thread safe; we should fix that...
			void				SetAcceptedFormat(const media_format& format);
			const media_format&	AcceptedFormat() const;

			void				GetInput(media_input* input);

			void				SetDataEnabled(bool enabled);
			void				ActivateInternalConnect(bool connectMode);

protected:

	virtual	BMediaAddOn*		AddOn(int32* id) const;

	virtual void				NodeRegistered();

	virtual void				SetRunMode(run_mode mode);

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

	virtual	void				Start(bigtime_t performanceTime);

	virtual	void				Stop(bigtime_t performanceTime,
									bool immediate);

	virtual	void				Seek(bigtime_t mediaTime,
									bigtime_t performanceTime);

	virtual	void				TimeWarp(bigtime_t realTime,
									bigtime_t performanceTime);

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

			// Someone, probably the producer, is asking you about
			// this format. Give your honest opinion, possibly
			// modifying *format. Do not ask upstream producer about
			//	the format, since he's synchronously waiting for your
			// reply.

	virtual	status_t			AcceptFormat(const media_destination& dest,
									media_format* format);

	virtual	status_t			GetNextInput(int32* cookie,
									media_input* outInput);

	virtual	void				DisposeInputCookie(int32 cookie);

	virtual	void				BufferReceived(BBuffer* buffer);

	virtual	void				ProducerDataStatus(
									const media_destination& destination,
									int32 status,
									bigtime_t performanceTime);

	virtual	status_t			GetLatencyFor(const media_destination& destination,
									bigtime_t* outLatency,
									media_node_id* outTimesource);

	virtual	status_t			Connected(const media_source& producer,
									const media_destination& where,
									const media_format& format,
									media_input* outInput);

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

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

protected:

	virtual						~BMediaRecorderNode();

			BMediaRecorder*		fRecorder;
			media_format		fOKFormat;
			media_input			fInput;
			BString				fName;
			bool				fConnectMode;
};

}
}

using namespace BPrivate::media;

#endif	//	_MEDIA_RECORDER_NODE_H