/*
 * FireWire DV media addon for Haiku
 *
 * Copyright (c) 2008, JiSheng Zhang (jszhang3@mail.ustc.edu.cn)
 * Distributed under the terms of the MIT License.
 *
 * Based on DVB media addon
 * Copyright (c) 2004-2007 Marcus Overhagen <marcus@overhagen.de>
 */

#ifndef __FIREWIRE_DV_NODE_H
#define __FIREWIRE_DV_NODE_H


#include <OS.h>
#include <media/BufferProducer.h>
//#include <media/BufferConsumer.h>
#include <media/Controllable.h>
#include <media/MediaDefs.h>
#include <media/MediaEventLooper.h>
#include <media/MediaNode.h>
#include <support/Locker.h>


class FireWireCard;
class BParameterGroup;


class FireWireDVNode : public virtual BBufferProducer,
	public virtual BControllable, public virtual BMediaEventLooper {
public:
				FireWireDVNode(BMediaAddOn *addon,
					const char *name, int32 internal_id,
					FireWireCard *card);
	virtual			~FireWireDVNode();

	virtual	status_t	InitCheck() const { return fInitStatus; }

/* BMediaNode */
public:
	virtual	BMediaAddOn	*AddOn(int32 * internal_id) const;
	virtual	status_t 	HandleMessage(int32 message, const void *data,
					size_t size);
protected:
	virtual	void 		Preroll();
	virtual void		SetTimeSource(BTimeSource * time_source);
	virtual void		SetRunMode(run_mode mode);

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

/* BBufferProducer */
protected:
	virtual	status_t	FormatSuggestionRequested(media_type type,
					int32 quality, media_format* format);
	virtual	status_t 	FormatProposal(const media_source &source,
					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 	VideoClippingChanged(
					const media_source& for_source,
					int16 num_shorts, int16* clip_data,
					const media_video_display_info &display,
					int32* _deprecated_);
	virtual	status_t	GetLatency(bigtime_t* out_latency);
	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);

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

/* state */
private:
	void			HandleStart(bigtime_t performance_time);
	void			HandleStop();
	void			HandleTimeWarp(bigtime_t performance_time);
	void			HandleSeek(bigtime_t performance_time);


	BParameterWeb*		CreateParameterWeb();
	void			SetAboutInfo(BParameterGroup *about);

	void			RefreshParameterWeb();

	status_t		StartCapture();
	status_t		StopCapture();
	status_t		StartCaptureThreads();
	status_t		StopCaptureThreads();

	static int32		_card_reader_thread_(void *arg);

	void			card_reader_thread();

	status_t		fInitStatus;
	int32			fInternalID;
	BMediaAddOn*		fAddOn;
	bool			fOutputEnabledEncVideo;
	media_output		fOutputEncVideo;
	media_format		fDefaultFormatEncVideo;
	FireWireCard*		fCard;
	bool			fCaptureThreadsActive;
	thread_id		fThreadIdCardReader;
	volatile bool		fTerminateThreads;
	BBufferGroup*		fBufferGroupEncVideo;
	BParameterWeb*		fWeb;
	bool			fCaptureActive;
	BLocker			fLock;

};

#endif	// __FIREWIRE_DV_NODE_H