/*
 * Copyright 2004-2009, Haiku. All rights reserved.
 * Distributed under the terms of the MIT license.
 *
 * Authors:
 *		Marcus Overhagen
 *		Axel Dörfler
 *		Stephan Aßmus <superstippi@gmx.de>
 */
#ifndef _ADD_ON_MANAGER_H
#define _ADD_ON_MANAGER_H


/*!	Manager for codec add-ons (reader, writer, encoder, decoder)
	BMediaAddOn are handled in the NodeManager
*/


#include "DataExchange.h"
#include "TList.h"

#include "DecoderPlugin.h"
#include "EncoderPlugin.h"
#include "ReaderPlugin.h"
#include "StreamerPlugin.h"
#include "WriterPlugin.h"


namespace BPrivate {
namespace media {

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

			static AddOnManager* GetInstance();

			status_t			GetDecoderForFormat(entry_ref* _ref,
									const media_format& format);

			status_t			GetEncoderForFormat(entry_ref* _ref,
									const media_format& outputFormat);

			status_t			GetReaders(entry_ref* _ref,
									int32* _count, int32 maxCount);

			status_t			GetStreamers(entry_ref* _ref,
									int32* _count, int32 maxCount);

			status_t			GetEncoder(entry_ref* _ref, int32 id);

			status_t			GetWriter(entry_ref* _ref,
									uint32 internalID);

			status_t			GetFileFormat(media_file_format* _fileFormat,
									int32 cookie);
			status_t			GetCodecInfo(media_codec_info* _codecInfo,
									media_format_family* _formatFamily,
									media_format* _inputFormat,
									media_format* _outputFormat, int32 cookie);

			void				RegisterAddOns();

private:

			status_t			_RegisterAddOn(const entry_ref& ref);
			status_t			_UnregisterAddOn(const entry_ref& ref);

			void				_RegisterReader(ReaderPlugin* reader,
									const entry_ref& ref);
			void				_RegisterDecoder(DecoderPlugin* decoder,
									const entry_ref& ref);

			void				_RegisterWriter(WriterPlugin* writer,
									const entry_ref& ref);
			void				_RegisterEncoder(EncoderPlugin* encoder,
									const entry_ref& ref);

			void				_RegisterStreamer(StreamerPlugin* streamer,
									const entry_ref& ref);

			bool				_FindDecoder(const media_format& format,
									const BPath& path,
									entry_ref* _decoderRef);

			bool				_FindEncoder(const media_format& format,
									const BPath& path,
									entry_ref* _decoderRef);

			void				_GetReaders(const BPath& path,
									entry_ref* outRefs, int32* outCount,
									int32 maxCount);

private:
			struct reader_info {
				entry_ref			ref;
			};
			struct writer_info {
				entry_ref			ref;
				uint32				internalID;
			};
			struct decoder_info {
				entry_ref			ref;
				List<media_format>	formats;
			};
			struct encoder_info {
				entry_ref			ref;
				uint32				internalID;
				media_codec_info	codecInfo;
				media_format_family	formatFamily;
				media_format		intputFormat;
				media_format		outputFormat;
			};
			struct streamer_info {
				entry_ref			ref;
			};

			BLocker				fLock;
			List<reader_info>	fReaderList;
			List<writer_info>	fWriterList;
			List<decoder_info>	fDecoderList;
			List<encoder_info>	fEncoderList;
			List<streamer_info> fStreamerList;

			List<media_file_format> fWriterFileFormats;

			uint32				fNextWriterFormatFamilyID;
			uint32				fNextEncoderCodecInfoID;

			static AddOnManager	sInstance;
};

} // namespace media
} // namespace BPrivate

#endif // _ADD_ON_MANAGER_H