/*
 * Copyright 2009-2012, Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 */
#ifndef _MEDIA_NODE_H
#define _MEDIA_NODE_H


#include <MediaDefs.h>
#include <Point.h>

#include <new>


class BBufferConsumer;
class BBufferProducer;
class BControllable;
class BFileInterface;
class BMediaAddOn;
class BTimeSource;


class media_node {
public:
								media_node();
								~media_node();

			media_node_id		node;
			port_id				port;
			uint32				kind;

	static const media_node		null;

private:
			uint32				_reserved_[3];
};


struct media_input {
								media_input();
								~media_input();

			media_node			node;
			media_source		source;
			media_destination	destination;
			media_format		format;
			char				name[B_MEDIA_NAME_LENGTH];

private:
			uint32				_reserved_media_input_[4];
};


struct media_output {
								media_output();
								~media_output();

			media_node			node;
			media_source		source;
			media_destination	destination;
			media_format		format;
			char				name[B_MEDIA_NAME_LENGTH];

private:
			uint32				_reserved_media_output_[4];
};


struct live_node_info {
								live_node_info();
								~live_node_info();

			media_node			node;
			BPoint				hint_point;
			char				name[B_MEDIA_NAME_LENGTH];

private:
			char				reserved[160];
};


struct media_request_info {
			enum what_code {
				B_SET_VIDEO_CLIPPING_FOR = 1,
				B_REQUEST_FORMAT_CHANGE,
				B_SET_OUTPUT_ENABLED,
				B_SET_OUTPUT_BUFFERS_FOR,

				B_FORMAT_CHANGED = 4097
			};

			what_code			what;
			int32				change_tag;
			status_t			status;
			void*				cookie;
			void*				user_data;
			media_source		source;
			media_destination	destination;
			media_format		format;

			uint32				_reserved_[32];
};


struct media_node_attribute {
			enum {
				B_R40_COMPILED = 1,
				B_USER_ATTRIBUTE_NAME = 0x1000000,
				B_FIRST_USER_ATTRIBUTE
			};

			uint32				what;
			uint32				flags;
			int64				data;
};


namespace BPrivate {
	namespace media {
		class TimeSourceObject;
		class SystemTimeSourceObject;
		class BMediaRosterEx;
	}
} // BPrivate::media


/*!	BMediaNode is the indirect base class for all Media Kit participants.
	However, you should use the more specific BBufferConsumer, BBufferProducer
	and others rather than BMediaNode directly. It's OK to multiply inherit.
*/
class BMediaNode {
protected:
	// NOTE: Call Release() to destroy a node.
	virtual								~BMediaNode();

public:
			enum run_mode {
				B_OFFLINE = 1,
					// This mode has no realtime constraint.
				B_DECREASE_PRECISION,
					// When late, try to catch up by reducing quality.
				B_INCREASE_LATENCY,
					// When late, increase the presentation time offset.
				B_DROP_DATA,
					// When late, try to catch up by dropping buffers.
				B_RECORDING
					// For nodes on the receiving end of recording.
					// Buffers will always be late.
			};

			BMediaNode*			Acquire();
			BMediaNode*			Release();

			const char*			Name() const;
			media_node_id		ID() const;
			uint64				Kinds() const;
			media_node			Node() const;
			run_mode			RunMode() const;
			BTimeSource*		TimeSource() const;

	// ID of the port used to listen to control messages.
	virtual	port_id				ControlPort() const;

	// Who instantiated this node or NULL for application internal class.
	virtual	BMediaAddOn*		AddOn(int32* internalID) const = 0;

	// Message constants which will be sent to anyone watching the
	// MediaRoster. The message field "be:node_id" will contain the node ID.
			enum node_error {
				// Note that these belong with the notifications in
				// MediaDefs.h! They are here to provide compiler type
				// checking in ReportError().
				B_NODE_FAILED_START					= 'TRI0',
				B_NODE_FAILED_STOP					= 'TRI1',
				B_NODE_FAILED_SEEK					= 'TRI2',
				B_NODE_FAILED_SET_RUN_MODE			= 'TRI3',
				B_NODE_FAILED_TIME_WARP				= 'TRI4',
				B_NODE_FAILED_PREROLL				= 'TRI5',
				B_NODE_FAILED_SET_TIME_SOURCE_FOR	= 'TRI6',
				B_NODE_IN_DISTRESS					= 'TRI7'
				// What field 'TRIA' and up are used in MediaDefs.h
			};

protected:
	// Sends one of the above codes to anybody who's watching. You can
	// provide an optional message with additional information.
			status_t			ReportError(node_error what,
									const BMessage* info = NULL);

	// When you've handled a stop request, call this function. If anyone is
	// listening for stop information from you, they will be notified.
	// Especially important for offline capable Nodes.
			status_t			NodeStopped(bigtime_t performanceTime);
			void				TimerExpired(bigtime_t notifyPerformanceTime,
									int32 cookie, status_t error = B_OK);

	// NOTE: Constructor initializes the reference count to 1.
	explicit					BMediaNode(const char* name);

				status_t		WaitForMessage(bigtime_t waitUntil,
									uint32 flags = 0, void* _reserved_ = 0);

	// 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.
	virtual	void				Start(bigtime_t atPerformanceTime);
	virtual	void				Stop(bigtime_t atPerformanceTime,
									bool immediate);
	virtual	void				Seek(bigtime_t toMediaTime,
									bigtime_t atPerformanceTime);
	virtual	void				SetRunMode(run_mode mode);
	virtual	void				TimeWarp(bigtime_t atRealTime,
									bigtime_t toPerformanceTime);
	virtual	void				Preroll();
	virtual	void				SetTimeSource(BTimeSource* timeSource);

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

	// Call this with messages you and your superclasses don't recognize.
			void				HandleBadMessage(int32 code,
									const void* buffer, size_t size);

	// Called from derived system classes; you don't need to
			void				AddNodeKind(uint64 kind);

	// These just call the default global versions for now.
			void*				operator new(size_t size);
			void*				operator new(size_t size,
									const std::nothrow_t&) throw();
			void				operator delete(void* ptr);
			void				operator delete(void* ptr,
									const std::nothrow_t&) throw();

protected:
	// Hook method which is called when requests have completed, or failed.
	virtual	status_t			RequestCompleted(
									const media_request_info & info);

	virtual	status_t			DeleteHook(BMediaNode* node);

	virtual	void				NodeRegistered();

public:

	// Fill out your attributes in the provided array, returning however
	// many you have.
	virtual	status_t			GetNodeAttributes(
									media_node_attribute* _attributes,
									size_t inMaxCount);

	virtual	status_t			AddTimer(bigtime_t atPerformanceTime,
									int32 cookie);

private:
			friend class BTimeSource;
			friend class BMediaRoster;
			friend class BBufferProducer;
			friend class BPrivate::media::TimeSourceObject;
			friend class BPrivate::media::SystemTimeSourceObject;
			friend class BPrivate::media::BMediaRosterEx;

			// Deprecated in BeOS R4.1
			int32				IncrementChangeTag();
			int32				ChangeTag();
			int32				MintChangeTag();
			status_t			ApplyChangeTag(int32 previouslyReserved);

private:
	// FBC padding and forbidden methods
			status_t			_Reserved_MediaNode_0(void*);
				// RequestCompletionHook()
			status_t			_Reserved_MediaNode_1(void*);
				// DeleteHook()
			status_t			_Reserved_MediaNode_2(void*);
				// NodeRegistered()
			status_t			_Reserved_MediaNode_3(void*);
				// GetNodeAttributes()
			status_t			_Reserved_MediaNode_4(void*);
				// AddTimer()
	virtual	status_t			_Reserved_MediaNode_5(void*);
	virtual	status_t			_Reserved_MediaNode_6(void*);
	virtual	status_t			_Reserved_MediaNode_7(void*);
	virtual	status_t			_Reserved_MediaNode_8(void*);
	virtual	status_t			_Reserved_MediaNode_9(void*);
	virtual	status_t			_Reserved_MediaNode_10(void*);
	virtual	status_t			_Reserved_MediaNode_11(void*);
	virtual	status_t			_Reserved_MediaNode_12(void*);
	virtual	status_t			_Reserved_MediaNode_13(void*);
	virtual	status_t			_Reserved_MediaNode_14(void*);
	virtual	status_t			_Reserved_MediaNode_15(void*);

								BMediaNode();
								BMediaNode(const BMediaNode& other);
			BMediaNode&			operator=(const BMediaNode& other);

private:
								BMediaNode(const char* name,
									media_node_id id, uint32 kinds);

			void				_InitObject(const char* name,
									media_node_id id, uint64 kinds);

private:
			media_node_id		fNodeID;
			BTimeSource*		fTimeSource;
			int32				fRefCount;
			char				fName[B_MEDIA_NAME_LENGTH];
			run_mode			fRunMode;

			int32				_reserved[2];

			uint64				fKinds;
			media_node_id		fTimeSourceID;

			BBufferProducer*	fProducerThis;
			BBufferConsumer*	fConsumerThis;
			BFileInterface*		fFileInterfaceThis;
			BControllable*		fControllableThis;
			BTimeSource*		fTimeSourceThis;

			bool				_reservedBool[4];

	mutable	port_id				fControlPort;

			uint32				_reserved_media_node_[8];

protected:
	static	int32				NewChangeTag();
		// for use by BBufferConsumer, mostly

private:
	// NOTE: Dont' rename this one, it's static and needed for binary
	// compatibility
	static	int32 _m_changeTag;
		// not to be confused with _mChangeCount
};


#endif // _MEDIA_NODE_H