haiku/headers/private/media/EncoderPlugin.h

/*
 * Copyright 2009-2015, Haiku Inc. All rights reserved.
 * Distributed under the terms of the MIT license.
 */
#ifndef _ENCODER_PLUGIN_H
#define _ENCODER_PLUGIN_H


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


namespace BPrivate { namespace media {

class PluginManager;

class ChunkWriter {
public:
	virtual						~ChunkWriter() {};
	virtual	status_t			WriteChunk(const void* chunkBuffer,
									size_t chunkSize,
									media_encode_info* encodeInfo) = 0;
};


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

	// Some codecs may only support certain input color spaces, or output
	// color spaces, or multiple of 16 width/height... This method is needed
	// for get_next_encoder() functionality. If _acceptedInputFormat is NULL,
	// you simply return a status indicating if proposed format is acceptable.
	// If it contains wildcards for fields that you have restrictions on,
	// return an error. In that case, the user should be using the form of
	// get_next_encoder() that allows to specify the accepted format. If
	// _acceptedInputFormat is not NULL, copy the proposedFormat into
	// _acceptedInputFormat and specialize any wildcards. You must (!) also
	// change non-wildcard fields, like the video width if you want to round to
	// the nearest multiple of 16 for example. Only if the format is completely
	// unacceptable, return an error.
	virtual	status_t			AcceptedFormat(
									const media_format* proposedInputFormat,
									media_format* _acceptedInputFormat = NULL)
										= 0;

	// The passed media_format may not contain wildcards and must be the same
	// format that was passed to get_next_encoder() (or it must be the format
	// returned in _acceptedInputFormat).
	virtual	status_t			SetUp(const media_format* inputFormat) = 0;

	virtual	status_t			AddTrackInfo(uint32 code, const void* data,
									size_t size, uint32 flags = 0);

	// Ownership of the BView and BParameterWeb remain with the Encoder.
	// A window embedding the view must remove it before it is destroyed.
	virtual	BView*				ParameterView();

	virtual	BParameterWeb*		ParameterWeb();
	virtual	status_t			GetParameterValue(int32 id, void* value,
									size_t* size) const;
	virtual	status_t			SetParameterValue(int32 id, const void* value,
									size_t size);

	virtual status_t			GetEncodeParameters(
									encode_parameters* parameters) const;
	virtual status_t			SetEncodeParameters(
									encode_parameters* parameters);

	virtual status_t			Encode(const void* buffer, int64 frameCount,
									media_encode_info* info) = 0;

			status_t			WriteChunk(const void* chunkBuffer,
									size_t chunkSize,
									media_encode_info* encodeInfo);

			void				SetChunkWriter(ChunkWriter* writer);

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

private:
			ChunkWriter*		fChunkWriter;

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

private:
	// FBC padding
			uint32				fReserved[20];

	virtual void				_ReservedEncoder1();
	virtual void				_ReservedEncoder2();
	virtual void				_ReservedEncoder3();
	virtual void				_ReservedEncoder4();
	virtual void				_ReservedEncoder5();
	virtual void				_ReservedEncoder6();
	virtual void				_ReservedEncoder7();
	virtual void				_ReservedEncoder8();
	virtual void				_ReservedEncoder9();
	virtual void				_ReservedEncoder10();
	virtual void				_ReservedEncoder11();
	virtual void				_ReservedEncoder12();
	virtual void				_ReservedEncoder13();
	virtual void				_ReservedEncoder14();
	virtual void				_ReservedEncoder15();
	virtual void				_ReservedEncoder16();
	virtual void				_ReservedEncoder17();
	virtual void				_ReservedEncoder18();
	virtual void				_ReservedEncoder19();
	virtual void				_ReservedEncoder20();
};


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

	virtual	Encoder*			NewEncoder(
									const media_codec_info& codecInfo) = 0;

	virtual	Encoder*			NewEncoder(
									const media_format& format) = 0;

	virtual	status_t			RegisterNextEncoder(int32* cookie,
									media_codec_info* codecInfo,
									media_format_family* formatFamily,
									media_format* inputFormat,
									media_format* outputFormat) = 0;
};

} } // namespace BPrivate::media

using namespace BPrivate::media;

#endif // _ENCODER_PLUGIN_H