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


#include <image.h>

#include <MediaDefs.h>
#include <Flattenable.h>


class BMediaNode;
class BMimeType;
struct entry_ref;

struct dormant_node_info {
								dormant_node_info();
								~dormant_node_info();

			media_addon_id		addon;
			int32				flavor_id;
			char				name[B_MEDIA_NAME_LENGTH];

private:
			char				reserved[128];
};

// flavor_flags
enum {
	B_FLAVOR_IS_GLOBAL	= 0x100000L,		// force in media_addon_server,
											// only one instance
	B_FLAVOR_IS_LOCAL	= 0x200000L			// force in loading app, many
											// instances if none is set, could
											// go either way
};

struct flavor_info {
	const char*			name;
	const char*			info;
	uint64				kinds;				// node kind
	uint32				flavor_flags;
	int32				internal_id;		// For BMediaAddOn internal use
	int32				possible_count;		// 0 for "any number"

	int32				in_format_count;	// for BufferConsumer kinds
	uint32				in_format_flags;	// set to 0
	const media_format*	in_formats;

	int32				out_format_count;	// for BufferProducer kinds
	uint32				out_format_flags;	// set to 0
	const media_format*	out_formats;

	uint32				_reserved_[16];

private:
	flavor_info&		operator=(const flavor_info& other);
};

struct dormant_flavor_info : public flavor_info, public BFlattenable {
								dormant_flavor_info();
	virtual						~dormant_flavor_info();

								dormant_flavor_info(
									const dormant_flavor_info& other);
			dormant_flavor_info& operator=(const dormant_flavor_info& other);
			dormant_flavor_info& operator=(const flavor_info& other);

			dormant_node_info	node_info;

			void				set_name(const char* name);
			void				set_info(const char* info);
			void				add_in_format(const media_format& format);
			void				add_out_format(const media_format& format);

	virtual	bool				IsFixedSize() const;
	virtual	type_code			TypeCode() const;
	virtual	ssize_t				FlattenedSize() const;
	virtual	status_t			Flatten(void* buffer, ssize_t size) const;
	virtual	status_t			Unflatten(type_code type, const void* buffer,
									ssize_t size);
};


namespace BPrivate {
	namespace media {
		class DormantNodeManager;
	};
};


//! a MediaAddOn is something which can manufacture MediaNodes
class BMediaAddOn {
public:
	explicit					BMediaAddOn(image_id image);
	virtual						~BMediaAddOn();

	virtual	status_t			InitCheck(const char** _failureText);
	virtual	int32				CountFlavors();
	virtual	status_t			GetFlavorAt(int32 index,
									const flavor_info** _info);
	virtual	BMediaNode*			InstantiateNodeFor(const flavor_info* info,
									BMessage* config, status_t* _error);
	virtual	status_t			GetConfigurationFor(BMediaNode* yourNode,
									BMessage* intoMessage);
	virtual	bool				WantsAutoStart();
	virtual	status_t			AutoStart(int index, BMediaNode** _node,
									int32* _internalID, bool* _hasMore);

	// NOTE: Only implement if you have a B_FILE_INTERFACE node
	virtual	status_t			SniffRef(const entry_ref& file,
									BMimeType* ioMimeType, float* _quality,
									int32* _internalID);
	// NOTE: This is broken if you deal with producers and consumers both.
	// Implement SniffTypeKind instead. If you implement SniffTypeKind, this
	// doesn't get called.
	virtual	status_t			SniffType(const BMimeType& type,
									float* _quality, int32* _internalID);

	virtual	status_t			GetFileFormatList(int32 forNodeFlavorID,
									media_file_format* _writableFormats,
									int32 writableFormatsCount,
									int32* _writableFormatsTotalCount,
									media_file_format* _readableFormats,
									int32 readableFormatsCount,
									int32* _readableFormatsTotalCount,
									void* _reserved);

	// NOTE: Like SniffType, but for the specific kind(s)
	virtual	status_t			SniffTypeKind(const BMimeType& type,
									uint64 kinds, float* _quality,
									int32* _internalID, void* _reserved);

			image_id			ImageID();
			media_addon_id		AddonID();

protected:
	// Calling this will cause everyone to get notified, and also
	// cause the server to re-scan your flavor info. It is thread safe.
			status_t			NotifyFlavorChange();

	// TODO: Needs a Perform() virtual method!

private:
	// FBC padding and forbidden methods
								BMediaAddOn();
								BMediaAddOn(const BMediaAddOn& other);
			BMediaAddOn&		operator=(const BMediaAddOn& other);

			friend class BPrivate::media::DormantNodeManager;

	virtual	status_t			_Reserved_MediaAddOn_2(void*);
	virtual	status_t			_Reserved_MediaAddOn_3(void*);
	virtual	status_t			_Reserved_MediaAddOn_4(void*);
	virtual	status_t			_Reserved_MediaAddOn_5(void*);
	virtual	status_t			_Reserved_MediaAddOn_6(void*);
	virtual	status_t			_Reserved_MediaAddOn_7(void*);

			image_id 			fImage;
			media_addon_id		fAddon;

			uint32				_reserved_media_add_on_[7];
};


#if BUILDING_MEDIA_ADDON
	extern "C" _EXPORT BMediaAddOn* make_media_addon(image_id yourImage);
#endif


#endif // _MEDIA_ADD_ON_H