haiku.git

#ifndef _DECODER_PLUGIN_H
#define _DECODER_PLUGIN_H

#include <MediaTrack.h>
#include <MediaFormats.h>
#include "MediaPlugin.h"


namespace BPrivate { namespace media {

class PluginManager;

class ChunkProvider {
public:
	virtual						~ChunkProvider() {};
	virtual	status_t			GetNextChunk(const void** chunkBuffer,
									size_t* chunkSize,
									media_header* mediaHeader) = 0;
};

class Decoder {
public:
								Decoder();
	virtual						~Decoder();

	virtual	void				GetCodecInfo(media_codec_info* codecInfo) = 0;

	// Setup get's called with the info data from Reader::GetStreamInfo
	virtual	status_t			Setup(media_format* ioEncodedFormat,
									const void* infoBuffer,
									size_t infoSize) = 0;

	virtual	status_t			NegotiateOutputFormat(
									media_format* ioDecodedFormat) = 0;
	
	virtual	status_t			SeekedTo(int64 frame, bigtime_t time) = 0;
							 
	virtual status_t			Decode(void* buffer, int64* frameCount,
									media_header* mediaHeader,
									media_decode_info* info = 0) = 0;
							   
			status_t			GetNextChunk(const void** chunkBuffer,
									size_t* chunkSize,
									media_header* mediaHeader);

			void				SetChunkProvider(ChunkProvider* provider);

	virtual status_t			Perform(perform_code code, void* data);

private:
	virtual void				_ReservedDecoder1();
	virtual void				_ReservedDecoder2();
	virtual void				_ReservedDecoder3();
	virtual void				_ReservedDecoder4();
	virtual void				_ReservedDecoder5();

			ChunkProvider*		fChunkProvider;

	// needed for plug-in reference count management
	friend class PluginManager;
			MediaPlugin*		fMediaPlugin;

			uint32				fReserved[5];
};


class DecoderPlugin : public virtual MediaPlugin {
public:
								DecoderPlugin();

	virtual	Decoder*			NewDecoder(uint index) = 0;
	virtual	status_t			GetSupportedFormats(media_format** formats,
									size_t* count) = 0;
};

} } // namespace BPrivate::media

using namespace BPrivate::media;

#endif // _DECODER_PLUGIN_H