Codec Kit: Rename classes to BFoo pattern

headers/os/codec/CodecRoster.h

@@ -5,7 +5,8 @@
 #ifndef _CODEC_ROSTER_H
 #define _CODEC_ROSTER_H
 
-
+#include <Decoder.h>
+#include <Encoder.h>
 #include <MediaDefs.h>
 #include <Reader.h>
 #include <Streamer.h>
@@ -19,32 +20,32 @@ namespace media {
 class BCodecRoster {
 public:
 
-	static status_t		InstantiateReader(Reader** reader,
+	static status_t		InstantiateReader(BReader** reader,
 							int32* streamCount, media_file_format* mff,
 							BDataIO* source);
-	static void			ReleaseReader(Reader* reader);
+	static void			ReleaseReader(BReader* reader);
 
-	static status_t		InstantiateDecoder(Decoder** decoder,
+	static status_t		InstantiateDecoder(BDecoder** decoder,
 							const media_format& format);
-	static status_t		InstantiateDecoder(Decoder** decoder,
+	static status_t		InstantiateDecoder(BDecoder** decoder,
 							const media_codec_info& mci);
-	static void			ReleaseDecoder(Decoder* decoder);
+	static void			ReleaseDecoder(BDecoder* decoder);
 	
-	static status_t		InstantiateWriter(Writer** writer,
+	static status_t		InstantiateWriter(BWriter** writer,
 							const media_file_format& mff,
 							BDataIO* target);
-	static void			ReleaseWriter(Writer* writer);
+	static void			ReleaseWriter(BWriter* writer);
 
-	static status_t		InstantiateEncoder(Encoder** encoder,
+	static status_t		InstantiateEncoder(BEncoder** encoder,
 							const media_format& format);
-	static status_t		InstantiateEncoder(Encoder** encoder,
+	static status_t		InstantiateEncoder(BEncoder** encoder,
 							const media_codec_info* codecInfo,
 							uint32 flags);
-	static void			ReleaseEncoder(Encoder* encoder);
+	static void			ReleaseEncoder(BEncoder* encoder);
 
-	static status_t		InstantiateStreamer(Streamer** streamer,
+	static status_t		InstantiateStreamer(BStreamer** streamer,
 							BUrl url, BDataIO** source);
-	static void			ReleaseStreamer(Streamer* streamer);
+	static void			ReleaseStreamer(BStreamer* streamer);
 
 /*!	\brief	Use this to iterate through the available encoders for a given file
 			format.

headers/os/codec/Decoder.h

@@ -12,16 +12,16 @@ namespace BPrivate { namespace media {
 
 class PluginManager;
 
-class ChunkProvider {
+class BChunkProvider {
 public:
-	virtual						~ChunkProvider() {};
+	virtual						~BChunkProvider() {};
 	virtual	status_t			GetNextChunk(const void** chunkBuffer,
 									size_t* chunkSize,
 									media_header* mediaHeader) = 0;
 };
 
 
-class Decoder {
+class BDecoder {
 public:
 	virtual	void				GetCodecInfo(media_codec_info* codecInfo) = 0;
 
@@ -43,19 +43,19 @@ public:
 									size_t* chunkSize,
 									media_header* mediaHeader);
 
-			void				SetChunkProvider(ChunkProvider* provider);
+			void				SetChunkProvider(BChunkProvider* provider);
 
 	virtual status_t			Perform(perform_code code, void* data);
 
 protected:
-								Decoder();
-	virtual						~Decoder();
+								BDecoder();
+	virtual						~BDecoder();
 
 
 private:
-			ChunkProvider*		fChunkProvider;
+			BChunkProvider*		fChunkProvider;
 
-			MediaPlugin*		fMediaPlugin;
+			BMediaPlugin*		fMediaPlugin;
 
 	// needed for plug-in reference count management
 	friend class PluginManager;
@@ -70,11 +70,11 @@ private:
 };
 
 
-class DecoderPlugin : public virtual MediaPlugin {
+class BDecoderPlugin : public virtual BMediaPlugin {
 public:
-								DecoderPlugin();
+								BDecoderPlugin();
 
-	virtual	Decoder*			NewDecoder(uint index) = 0;
+	virtual	BDecoder*			NewDecoder(uint index) = 0;
 	virtual	status_t			GetSupportedFormats(media_format** formats,
 									size_t* count) = 0;
 };

headers/os/codec/Encoder.h

@@ -17,16 +17,16 @@ namespace BPrivate { namespace media {
 
 class PluginManager;
 
-class ChunkWriter {
+class BChunkWriter {
 public:
-	virtual						~ChunkWriter() {};
+	virtual						~BChunkWriter() {};
 	virtual	status_t			WriteChunk(const void* chunkBuffer,
 									size_t chunkSize,
 									media_encode_info* encodeInfo) = 0;
 };
 
 
-class Encoder {
+class BEncoder {
 public:
 	// Some codecs may only support certain input color spaces, or output
 	// color spaces, or multiple of 16 width/height... This method is needed
@@ -75,18 +75,18 @@ public:
 									size_t chunkSize,
 									media_encode_info* encodeInfo);
 
-			void				SetChunkWriter(ChunkWriter* writer);
+			void				SetChunkWriter(BChunkWriter* writer);
 
 	virtual status_t			Perform(perform_code code, void* data);
 
 protected:
-								Encoder();
-	virtual						~Encoder();
+								BEncoder();
+	virtual						~BEncoder();
 
 private:
-			ChunkWriter*		fChunkWriter;
+			BChunkWriter*		fChunkWriter;
 
-			MediaPlugin*		fMediaPlugin;
+			BMediaPlugin*		fMediaPlugin;
 
 	// needed for plug-in reference count management
 	friend class PluginManager;
@@ -117,14 +117,14 @@ private:
 };
 
 
-class EncoderPlugin : public virtual MediaPlugin {
+class BEncoderPlugin : public virtual BMediaPlugin {
 public:
-								EncoderPlugin();
+								BEncoderPlugin();
 
-	virtual	Encoder*			NewEncoder(
+	virtual	BEncoder*			NewEncoder(
 									const media_codec_info& codecInfo) = 0;
 
-	virtual	Encoder*			NewEncoder(
+	virtual	BEncoder*			NewEncoder(
 									const media_format& format) = 0;
 
 	virtual	status_t			RegisterNextEncoder(int32* cookie,

headers/os/codec/MediaExtractor.h

@@ -23,10 +23,10 @@ struct chunk_buffer;
 struct stream_info;
 
 
-class MediaExtractor {
+class BMediaExtractor {
 public:
-								MediaExtractor(BDataIO* source, int32 flags);
-								~MediaExtractor();
+								BMediaExtractor(BDataIO* source, int32 flags);
+								~BMediaExtractor();
 
 			status_t			InitCheck();
 
@@ -55,7 +55,7 @@ public:
 									size_t* _chunkSize,
 									media_header* mediaHeader);
 
-			status_t			CreateDecoder(int32 stream, Decoder** _decoder,
+			status_t			CreateDecoder(int32 stream, BDecoder** _decoder,
 									media_codec_info* codecInfo);
 
 			// TODO: Explore if would be better to add a Start/Stop
@@ -75,7 +75,7 @@ private:
 			thread_id			fExtractorThread;
 
 			BDataIO*			fSource;
-			Reader*				fReader;
+			BReader*			fReader;
 
 			stream_info*		fStreamInfo;
 			int32				fStreamCount;

headers/os/codec/MediaPlugin.h

@@ -14,10 +14,10 @@ namespace BPrivate { namespace media {
 // TODO: This will replace BMediaAddOn in media2,
 // see if we need some more accessor method and
 // add the needed padding.
-class MediaPlugin {
+class BMediaPlugin {
 public:
-								MediaPlugin();
-	virtual						~MediaPlugin();
+								BMediaPlugin();
+	virtual						~BMediaPlugin();
 
 private:
 			int32				fRefCount;
@@ -31,13 +31,13 @@ private:
 			uint32				fReserved[5];
 };
 
-class Decoder;
-class Reader;
+class BDecoder;
+class BReader;
 
 } } // namespace BPrivate::media
 
 using namespace BPrivate::media;
 
-extern "C" MediaPlugin* instantiate_plugin();
+extern "C" BMediaPlugin* instantiate_plugin();
 
 #endif // _MEDIA_PLUGIN_H

headers/os/codec/MediaStreamer.h

@@ -15,16 +15,16 @@ namespace BPrivate {
 namespace media {
 
 
-class MediaStreamer {
+class BMediaStreamer {
 public:
-								MediaStreamer(BUrl url);
-								~MediaStreamer();
+								BMediaStreamer(BUrl url);
+								~BMediaStreamer();
 
 			status_t			CreateAdapter(BDataIO** adapter);
 
 private:
 			BUrl				fUrl;
-			Streamer*			fStreamer;
+			BStreamer*			fStreamer;
 
 			// No virtual padding needed. Looks like a design decision.
 			// Let's respect that, for now.

headers/os/codec/MediaWriter.h

@@ -16,11 +16,11 @@ namespace BPrivate {
 namespace media {
 
 
-class MediaWriter {
+class BMediaWriter {
 public:
-								MediaWriter(BDataIO* target,
+								BMediaWriter(BDataIO* target,
 									const media_file_format& fileFormat);
-								~MediaWriter();
+								~BMediaWriter();
 
 			status_t			InitCheck();
 
@@ -28,7 +28,7 @@ public:
 
 			void				GetFileFormatInfo(media_file_format* mfi) const;
 
-			status_t			CreateEncoder(Encoder** _encoder,
+			status_t			CreateEncoder(BEncoder** _encoder,
 									const media_codec_info* codecInfo,
 									media_format* format, uint32 flags = 0);
 
@@ -55,7 +55,7 @@ private:
 			};
 
 			BDataIO*			fTarget;
-			Writer*				fWriter;
+			BWriter*				fWriter;
 			List<StreamInfo>	fStreamInfos;
 			media_file_format	fFileFormat;
 

headers/os/codec/Reader.h

@@ -18,7 +18,7 @@ enum {
 };
 
 
-class Reader {
+class BReader {
 public:
 	virtual	status_t			Sniff(int32* streamCount) = 0;
 
@@ -51,15 +51,15 @@ public:
 	virtual status_t			Perform(perform_code code, void* data);
 
 protected:
-								Reader();
-	virtual						~Reader();
+								BReader();
+	virtual						~BReader();
 
 private:
 			void				_Setup(BDataIO* source);
 
 			BDataIO*			fSource;
 
-			MediaPlugin*		fMediaPlugin;
+			BMediaPlugin*		fMediaPlugin;
 
 	// needed for plug-in reference count management
 	friend class PluginManager;
@@ -75,9 +75,9 @@ private:
 };
 
 
-class ReaderPlugin : public virtual MediaPlugin {
+class BReaderPlugin : public virtual BMediaPlugin {
 public:
-	virtual	Reader*				NewReader() = 0;
+	virtual	BReader*			NewReader() = 0;
 };
 
 } } // namespace BPrivate::media

headers/os/codec/Streamer.h

@@ -17,16 +17,16 @@ namespace BPrivate { namespace media {
 class PluginManager;
 
 
-class Streamer {
+class BStreamer {
 public:
 	virtual status_t			Sniff(const BUrl& url, BDataIO** source) = 0;
 
 protected:
-								Streamer();
-	virtual						~Streamer();
+								BStreamer();
+	virtual						~BStreamer();
 
 private:
-			MediaPlugin*		fMediaPlugin;
+			BMediaPlugin*		fMediaPlugin;
 
 	friend class PluginManager;
 	friend class MediaStreamer;
@@ -41,11 +41,11 @@ private:
 };
 
 
-class StreamerPlugin : public virtual MediaPlugin {
+class BStreamerPlugin : public virtual BMediaPlugin {
 public:
-								StreamerPlugin();
+								BStreamerPlugin();
 
-	virtual	Streamer*			NewStreamer() = 0;
+	virtual	BStreamer*			NewStreamer() = 0;
 };
 
 } } // namespace BPrivate::media

headers/os/codec/Writer.h

@@ -10,7 +10,7 @@ namespace BPrivate { namespace media {
 
 class PluginManager;
 
-class Writer {
+class BWriter {
 public:
 	virtual	status_t			SetMetaData(BMetaData* data) = 0;
 	virtual	status_t			CommitHeader() = 0;
@@ -38,8 +38,8 @@ public:
 	virtual status_t			Perform(perform_code code, void* data);
 
 protected:
-								Writer();
-	virtual						~Writer();
+								BWriter();
+	virtual						~BWriter();
 
 	virtual	status_t			Init(const media_file_format* fileFormat) = 0;
 
@@ -48,11 +48,11 @@ private:
 
 			BDataIO*			fTarget;
 
-			MediaPlugin*		fMediaPlugin;
+			BMediaPlugin*		fMediaPlugin;
 
 	// needed for plug-in reference count management
 	friend class PluginManager;
-	friend class MediaWriter;
+	friend class BMediaWriter;
 
 	virtual void				_ReservedWriter1();
 	virtual void				_ReservedWriter2();
@@ -64,9 +64,9 @@ private:
 };
 
 
-class WriterPlugin : public virtual MediaPlugin {
+class BWriterPlugin : public virtual BMediaPlugin {
 public:
-	virtual	Writer*				NewWriter() = 0;
+	virtual	BWriter*			NewWriter() = 0;
 	virtual	status_t			GetSupportedFileFormats(
 									const media_file_format** _fileFormats,
 									size_t* _count) = 0;

headers/private/codec/AddOnManager.h

@@ -67,17 +67,17 @@ private:
 			status_t			_RegisterAddOn(const entry_ref& ref);
 			status_t			_UnregisterAddOn(const entry_ref& ref);
 
-			void				_RegisterReader(ReaderPlugin* reader,
+			void				_RegisterReader(BReaderPlugin* reader,
 									const entry_ref& ref);
-			void				_RegisterDecoder(DecoderPlugin* decoder,
+			void				_RegisterDecoder(BDecoderPlugin* decoder,
 									const entry_ref& ref);
 
-			void				_RegisterWriter(WriterPlugin* writer,
+			void				_RegisterWriter(BWriterPlugin* writer,
 									const entry_ref& ref);
-			void				_RegisterEncoder(EncoderPlugin* encoder,
+			void				_RegisterEncoder(BEncoderPlugin* encoder,
 									const entry_ref& ref);
 
-			void				_RegisterStreamer(StreamerPlugin* streamer,
+			void				_RegisterStreamer(BStreamerPlugin* streamer,
 									const entry_ref& ref);
 
 			bool				_FindDecoder(const media_format& format,

headers/private/codec/PluginManager.h

@@ -27,50 +27,50 @@ public:
 								PluginManager();
 								~PluginManager();
 	
-			MediaPlugin*		GetPlugin(const entry_ref& ref);
-			void				PutPlugin(MediaPlugin* plugin);
+			BMediaPlugin*		GetPlugin(const entry_ref& ref);
+			void				PutPlugin(BMediaPlugin* plugin);
 
 	// Readers and Decoders
-			status_t			CreateReader(Reader** reader,
+			status_t			CreateReader(BReader** reader,
 									int32* streamCount, media_file_format* mff,
 									BDataIO* source);
-			void				DestroyReader(Reader* reader);
+			void				DestroyReader(BReader* reader);
 
-			status_t			CreateDecoder(Decoder** decoder,
+			status_t			CreateDecoder(BDecoder** decoder,
 									const media_format& format);
-			status_t			CreateDecoder(Decoder** decoder,
+			status_t			CreateDecoder(BDecoder** decoder,
 									const media_codec_info& mci);
-			status_t			GetDecoderInfo(Decoder* decoder,
+			status_t			GetDecoderInfo(BDecoder* decoder,
 									media_codec_info* _info) const;
-			void				DestroyDecoder(Decoder* decoder);
+			void				DestroyDecoder(BDecoder* decoder);
 
 	// Writers and Encoders	
-			status_t			CreateWriter(Writer** writer,
+			status_t			CreateWriter(BWriter** writer,
 									const media_file_format& mff,
 									BDataIO* target);
-			void				DestroyWriter(Writer* writer);
+			void				DestroyWriter(BWriter* writer);
 
-			status_t			CreateEncoder(Encoder** encoder,
+			status_t			CreateEncoder(BEncoder** encoder,
 									const media_codec_info* codecInfo,
 									uint32 flags);
 
-			status_t			CreateEncoder(Encoder** encoder,
+			status_t			CreateEncoder(BEncoder** encoder,
 									const media_format& format);
 
-			void				DestroyEncoder(Encoder* encoder);
+			void				DestroyEncoder(BEncoder* encoder);
 
-			status_t			CreateStreamer(Streamer** streamer,
+			status_t			CreateStreamer(BStreamer** streamer,
 									BUrl url, BDataIO** source);
-			void				DestroyStreamer(Streamer* streamer);
+			void				DestroyStreamer(BStreamer* streamer);
 
 private:
 			status_t			_LoadPlugin(const entry_ref& ref,
-									MediaPlugin** plugin, image_id* image);
+									BMediaPlugin** plugin, image_id* image);
 
 			struct plugin_info {
 				char			name[260];
 				int				usecount;
-				MediaPlugin*	plugin;
+				BMediaPlugin*	plugin;
 				image_id		image;
 		
 				plugin_info& operator=(const plugin_info& other)

src/kits/codec/AddOnManager.cpp

@@ -345,7 +345,7 @@ AddOnManager::_RegisterAddOn(const entry_ref& ref)
 	if (status != B_OK)
 		return status;
 
-	MediaPlugin* (*instantiate_plugin_func)();
+	BMediaPlugin* (*instantiate_plugin_func)();
 
 	if (get_image_symbol(loader.Image(), "instantiate_plugin",
 			B_SYMBOL_TYPE_TEXT, (void**)&instantiate_plugin_func) < B_OK) {
@@ -354,30 +354,30 @@ AddOnManager::_RegisterAddOn(const entry_ref& ref)
 		return B_BAD_TYPE;
 	}
 
-	MediaPlugin* plugin = (*instantiate_plugin_func)();
+	BMediaPlugin* plugin = (*instantiate_plugin_func)();
 	if (plugin == NULL) {
 		printf("AddOnManager::_RegisterAddOn(): instantiate_plugin in \"%s\" "
 			"returned NULL\n", path.Path());
 		return B_ERROR;
 	}
 
-	ReaderPlugin* reader = dynamic_cast<ReaderPlugin*>(plugin);
+	BReaderPlugin* reader = dynamic_cast<BReaderPlugin*>(plugin);
 	if (reader != NULL)
 		_RegisterReader(reader, ref);
 
-	DecoderPlugin* decoder = dynamic_cast<DecoderPlugin*>(plugin);
+	BDecoderPlugin* decoder = dynamic_cast<BDecoderPlugin*>(plugin);
 	if (decoder != NULL)
 		_RegisterDecoder(decoder, ref);
 
-	WriterPlugin* writer = dynamic_cast<WriterPlugin*>(plugin);
+	BWriterPlugin* writer = dynamic_cast<BWriterPlugin*>(plugin);
 	if (writer != NULL)
 		_RegisterWriter(writer, ref);
 
-	EncoderPlugin* encoder = dynamic_cast<EncoderPlugin*>(plugin);
+	BEncoderPlugin* encoder = dynamic_cast<BEncoderPlugin*>(plugin);
 	if (encoder != NULL)
 		_RegisterEncoder(encoder, ref);
 
-	StreamerPlugin* streamer = dynamic_cast<StreamerPlugin*>(plugin);
+	BStreamerPlugin* streamer = dynamic_cast<BStreamerPlugin*>(plugin);
 	if (streamer != NULL)
 		_RegisterStreamer(streamer, ref);
 
@@ -444,7 +444,7 @@ AddOnManager::_UnregisterAddOn(const entry_ref& ref)
 
 
 void
-AddOnManager::_RegisterReader(ReaderPlugin* reader, const entry_ref& ref)
+AddOnManager::_RegisterReader(BReaderPlugin* reader, const entry_ref& ref)
 {
 	BAutolock locker(fLock);
 
@@ -464,7 +464,7 @@ AddOnManager::_RegisterReader(ReaderPlugin* reader, const entry_ref& ref)
 
 
 void
-AddOnManager::_RegisterDecoder(DecoderPlugin* plugin, const entry_ref& ref)
+AddOnManager::_RegisterDecoder(BDecoderPlugin* plugin, const entry_ref& ref)
 {
 	BAutolock locker(fLock);
 
@@ -494,7 +494,7 @@ AddOnManager::_RegisterDecoder(DecoderPlugin* plugin, const entry_ref& ref)
 
 
 void
-AddOnManager::_RegisterWriter(WriterPlugin* writer, const entry_ref& ref)
+AddOnManager::_RegisterWriter(BWriterPlugin* writer, const entry_ref& ref)
 {
 	BAutolock locker(fLock);
 
@@ -534,7 +534,7 @@ AddOnManager::_RegisterWriter(WriterPlugin* writer, const entry_ref& ref)
 
 
 void
-AddOnManager::_RegisterEncoder(EncoderPlugin* plugin, const entry_ref& ref)
+AddOnManager::_RegisterEncoder(BEncoderPlugin* plugin, const entry_ref& ref)
 {
 	BAutolock locker(fLock);
 
@@ -577,7 +577,7 @@ AddOnManager::_RegisterEncoder(EncoderPlugin* plugin, const entry_ref& ref)
 
 
 void
-AddOnManager::_RegisterStreamer(StreamerPlugin* streamer, const entry_ref& ref)
+AddOnManager::_RegisterStreamer(BStreamerPlugin* streamer, const entry_ref& ref)
 {
 	BAutolock locker(fLock);
 

src/kits/codec/ChunkCache.cpp

@@ -70,7 +70,7 @@ ChunkCache::SpaceLeft() const
 
 
 chunk_buffer*
-ChunkCache::NextChunk(Reader* reader, void* cookie)
+ChunkCache::NextChunk(BReader* reader, void* cookie)
 {
 	ASSERT(IsLocked());
 
@@ -109,7 +109,7 @@ ChunkCache::RecycleChunk(chunk_buffer* chunk)
 
 
 bool
-ChunkCache::ReadNextChunk(Reader* reader, void* cookie)
+ChunkCache::ReadNextChunk(BReader* reader, void* cookie)
 {
 	ASSERT(IsLocked());
 

src/kits/codec/ChunkCache.h

@@ -41,9 +41,9 @@ public:
 			void				MakeEmpty();
 			bool				SpaceLeft() const;
 
-			chunk_buffer*		NextChunk(Reader* reader, void* cookie);
+			chunk_buffer*		NextChunk(BReader* reader, void* cookie);
 			void				RecycleChunk(chunk_buffer* chunk);
-			bool				ReadNextChunk(Reader* reader, void* cookie);
+			bool				ReadNextChunk(BReader* reader, void* cookie);
 
 private:
 			rtm_pool*			fRealTimePool;

src/kits/codec/CodecRoster.cpp

@@ -11,7 +11,7 @@
 
 
 status_t
-BCodecRoster::InstantiateReader(Reader** reader, int32* streamCount,
+BCodecRoster::InstantiateReader(BReader** reader, int32* streamCount,
 	media_file_format* mff, BDataIO* source)
 {
 	return gPluginManager.CreateReader(reader, streamCount, mff, source);
@@ -19,35 +19,35 @@ BCodecRoster::InstantiateReader(Reader** reader, int32* streamCount,
 
 
 void
-BCodecRoster::ReleaseReader(Reader* reader)
+BCodecRoster::ReleaseReader(BReader* reader)
 {
 	return gPluginManager.DestroyReader(reader);
 }
 
 
 status_t
-BCodecRoster::InstantiateDecoder(Decoder** decoder, const media_format& format)
+BCodecRoster::InstantiateDecoder(BDecoder** decoder, const media_format& format)
 {
 	return gPluginManager.CreateDecoder(decoder, format);
 }
 
 
 status_t
-BCodecRoster::InstantiateDecoder(Decoder** decoder, const media_codec_info& mci)
+BCodecRoster::InstantiateDecoder(BDecoder** decoder, const media_codec_info& mci)
 {
 	return gPluginManager.CreateDecoder(decoder, mci);
 }
 
 
 void
-BCodecRoster::ReleaseDecoder(Decoder* decoder)
+BCodecRoster::ReleaseDecoder(BDecoder* decoder)
 {
 	return gPluginManager.DestroyDecoder(decoder);
 }
 
 
 status_t
-BCodecRoster::InstantiateWriter(Writer** writer, const media_file_format& mff,
+BCodecRoster::InstantiateWriter(BWriter** writer, const media_file_format& mff,
 	BDataIO* target)
 {
 	return gPluginManager.CreateWriter(writer, mff, target);
@@ -55,21 +55,21 @@ BCodecRoster::InstantiateWriter(Writer** writer, const media_file_format& mff,
 
 
 void
-BCodecRoster::ReleaseWriter(Writer* writer)
+BCodecRoster::ReleaseWriter(BWriter* writer)
 {
 	return gPluginManager.DestroyWriter(writer);
 }
 
 
 status_t
-BCodecRoster::InstantiateEncoder(Encoder** encoder, const media_format& format)
+BCodecRoster::InstantiateEncoder(BEncoder** encoder, const media_format& format)
 {
 	return gPluginManager.CreateEncoder(encoder, format);
 }
 
 
 status_t
-BCodecRoster::InstantiateEncoder(Encoder** encoder,
+BCodecRoster::InstantiateEncoder(BEncoder** encoder,
 	const media_codec_info* codecInfo, uint32 flags)
 {
 	return gPluginManager.CreateEncoder(encoder, codecInfo, flags);
@@ -77,14 +77,14 @@ BCodecRoster::InstantiateEncoder(Encoder** encoder,
 
 
 void
-BCodecRoster::ReleaseEncoder(Encoder* encoder)
+BCodecRoster::ReleaseEncoder(BEncoder* encoder)
 {
 	return gPluginManager.DestroyEncoder(encoder);
 }
 
 
 status_t
-BCodecRoster::InstantiateStreamer(Streamer** streamer, BUrl url,
+BCodecRoster::InstantiateStreamer(BStreamer** streamer, BUrl url,
 	BDataIO** source)
 {
 	return gPluginManager.CreateStreamer(streamer, url, source);
@@ -92,7 +92,7 @@ BCodecRoster::InstantiateStreamer(Streamer** streamer, BUrl url,
 
 
 void
-BCodecRoster::ReleaseStreamer(Streamer* streamer)
+BCodecRoster::ReleaseStreamer(BStreamer* streamer)
 {
 	return gPluginManager.DestroyStreamer(streamer);
 }

src/kits/codec/Decoder.cpp

@@ -12,7 +12,7 @@
 #include <string.h>
 
 
-Decoder::Decoder()
+BDecoder::BDecoder()
 	:
 	fChunkProvider(NULL),
 	fMediaPlugin(NULL)
@@ -20,14 +20,14 @@ Decoder::Decoder()
 }
 
 
-Decoder::~Decoder()
+BDecoder::~BDecoder()
 {
 	delete fChunkProvider;
 }
 
 	
 status_t
-Decoder::GetNextChunk(const void **chunkBuffer, size_t *chunkSize,
+BDecoder::GetNextChunk(const void **chunkBuffer, size_t *chunkSize,
 					  media_header *mediaHeader)
 {
 	return fChunkProvider->GetNextChunk(chunkBuffer, chunkSize, mediaHeader);
@@ -35,7 +35,7 @@ Decoder::GetNextChunk(const void **chunkBuffer, size_t *chunkSize,
 
 
 void
-Decoder::SetChunkProvider(ChunkProvider *provider)
+BDecoder::SetChunkProvider(BChunkProvider *provider)
 {
 	delete fChunkProvider;
 	fChunkProvider = provider;
@@ -43,19 +43,19 @@ Decoder::SetChunkProvider(ChunkProvider *provider)
 
 
 status_t
-Decoder::Perform(perform_code code, void* _data)
+BDecoder::Perform(perform_code code, void* _data)
 {
 	return B_OK;
 }
 
 
-void Decoder::_ReservedDecoder1() {}
-void Decoder::_ReservedDecoder2() {}
-void Decoder::_ReservedDecoder3() {}
-void Decoder::_ReservedDecoder4() {}
-void Decoder::_ReservedDecoder5() {}
+void BDecoder::_ReservedDecoder1() {}
+void BDecoder::_ReservedDecoder2() {}
+void BDecoder::_ReservedDecoder3() {}
+void BDecoder::_ReservedDecoder4() {}
+void BDecoder::_ReservedDecoder5() {}
 
 
-DecoderPlugin::DecoderPlugin()
+BDecoderPlugin::BDecoderPlugin()
 {
 }

src/kits/codec/Encoder.cpp

@@ -13,7 +13,7 @@
 #include <string.h>
 
 
-Encoder::Encoder()
+BEncoder::BEncoder()
 	:
 	fChunkWriter(NULL),
 	fMediaPlugin(NULL)
@@ -21,7 +21,7 @@ Encoder::Encoder()
 }
 
 
-Encoder::~Encoder()
+BEncoder::~BEncoder()
 {
 	delete fChunkWriter;
 }
@@ -31,49 +31,49 @@ Encoder::~Encoder()
 
 
 status_t
-Encoder::AddTrackInfo(uint32 code, const void* data, size_t size, uint32 flags)
+BEncoder::AddTrackInfo(uint32 code, const void* data, size_t size, uint32 flags)
 {
 	return B_NOT_SUPPORTED;
 }
 
 
 BView*
-Encoder::ParameterView()
+BEncoder::ParameterView()
 {
 	return NULL;
 }
 
 
 BParameterWeb*
-Encoder::ParameterWeb()
+BEncoder::ParameterWeb()
 {
 	return NULL;
 }
 
 
 status_t
-Encoder::GetParameterValue(int32 id, void* value, size_t* size) const
+BEncoder::GetParameterValue(int32 id, void* value, size_t* size) const
 {
 	return B_NOT_SUPPORTED;
 }
 
 
 status_t
-Encoder::SetParameterValue(int32 id, const void* value, size_t size)
+BEncoder::SetParameterValue(int32 id, const void* value, size_t size)
 {
 	return B_NOT_SUPPORTED;
 }
 
 
 status_t
-Encoder::GetEncodeParameters(encode_parameters* parameters) const
+BEncoder::GetEncodeParameters(encode_parameters* parameters) const
 {
 	return B_NOT_SUPPORTED;
 }
 
 
 status_t
-Encoder::SetEncodeParameters(encode_parameters* parameters)
+BEncoder::SetEncodeParameters(encode_parameters* parameters)
 {
 	return B_NOT_SUPPORTED;
 }
@@ -83,7 +83,7 @@ Encoder::SetEncodeParameters(encode_parameters* parameters)
 
 
 status_t
-Encoder::WriteChunk(const void* chunkBuffer, size_t chunkSize,
+BEncoder::WriteChunk(const void* chunkBuffer, size_t chunkSize,
 	media_encode_info* encodeInfo)
 {
 	return fChunkWriter->WriteChunk(chunkBuffer, chunkSize, encodeInfo);
@@ -91,7 +91,7 @@ Encoder::WriteChunk(const void* chunkBuffer, size_t chunkSize,
 
 
 void
-Encoder::SetChunkWriter(ChunkWriter* writer)
+BEncoder::SetChunkWriter(BChunkWriter* writer)
 {
 	delete fChunkWriter;
 	fChunkWriter = writer;
@@ -102,37 +102,37 @@ Encoder::SetChunkWriter(ChunkWriter* writer)
 
 
 status_t
-Encoder::Perform(perform_code code, void* data)
+BEncoder::Perform(perform_code code, void* data)
 {
 	return B_OK;
 }
 
 
-void Encoder::_ReservedEncoder1() {}
-void Encoder::_ReservedEncoder2() {}
-void Encoder::_ReservedEncoder3() {}
-void Encoder::_ReservedEncoder4() {}
-void Encoder::_ReservedEncoder5() {}
-void Encoder::_ReservedEncoder6() {}
-void Encoder::_ReservedEncoder7() {}
-void Encoder::_ReservedEncoder8() {}
-void Encoder::_ReservedEncoder9() {}
-void Encoder::_ReservedEncoder10() {}
-void Encoder::_ReservedEncoder11() {}
-void Encoder::_ReservedEncoder12() {}
-void Encoder::_ReservedEncoder13() {}
-void Encoder::_ReservedEncoder14() {}
-void Encoder::_ReservedEncoder15() {}
-void Encoder::_ReservedEncoder16() {}
-void Encoder::_ReservedEncoder17() {}
-void Encoder::_ReservedEncoder18() {}
-void Encoder::_ReservedEncoder19() {}
-void Encoder::_ReservedEncoder20() {}
+void BEncoder::_ReservedEncoder1() {}
+void BEncoder::_ReservedEncoder2() {}
+void BEncoder::_ReservedEncoder3() {}
+void BEncoder::_ReservedEncoder4() {}
+void BEncoder::_ReservedEncoder5() {}
+void BEncoder::_ReservedEncoder6() {}
+void BEncoder::_ReservedEncoder7() {}
+void BEncoder::_ReservedEncoder8() {}
+void BEncoder::_ReservedEncoder9() {}
+void BEncoder::_ReservedEncoder10() {}
+void BEncoder::_ReservedEncoder11() {}
+void BEncoder::_ReservedEncoder12() {}
+void BEncoder::_ReservedEncoder13() {}
+void BEncoder::_ReservedEncoder14() {}
+void BEncoder::_ReservedEncoder15() {}
+void BEncoder::_ReservedEncoder16() {}
+void BEncoder::_ReservedEncoder17() {}
+void BEncoder::_ReservedEncoder18() {}
+void BEncoder::_ReservedEncoder19() {}
+void BEncoder::_ReservedEncoder20() {}
 
 
 //	#pragma mark - EncoderPlugin
 
 
-EncoderPlugin::EncoderPlugin()
+BEncoderPlugin::BEncoderPlugin()
 {
 }

src/kits/codec/MediaExtractor.cpp

@@ -39,9 +39,9 @@ struct BPrivate::media::stream_info {
 };
 
 
-class MediaExtractorChunkProvider : public ChunkProvider {
+class BMediaExtractorChunkProvider : public BChunkProvider {
 public:
-	MediaExtractorChunkProvider(MediaExtractor* extractor, int32 stream)
+	BMediaExtractorChunkProvider(BMediaExtractor* extractor, int32 stream)
 		:
 		fExtractor(extractor),
 		fStream(stream)
@@ -56,7 +56,7 @@ public:
 	}
 
 private:
-	MediaExtractor*	fExtractor;
+	BMediaExtractor*	fExtractor;
 	int32			fStream;
 };
 
@@ -64,7 +64,7 @@ private:
 // #pragma mark -
 
 
-MediaExtractor::MediaExtractor(BDataIO* source, int32 flags)
+BMediaExtractor::BMediaExtractor(BDataIO* source, int32 flags)
 	:
 	fExtractorThread(-1),
 	fReader(NULL),
@@ -76,7 +76,7 @@ MediaExtractor::MediaExtractor(BDataIO* source, int32 flags)
 
 
 void
-MediaExtractor::_Init(BDataIO* source, int32 flags)
+BMediaExtractor::_Init(BDataIO* source, int32 flags)
 {
 	CALLED();
 
@@ -122,7 +122,7 @@ MediaExtractor::_Init(BDataIO* source, int32 flags)
 			fStreamInfo[i].cookie = 0;
 			fStreamInfo[i].hasCookie = false;
 			fStreamInfo[i].status = B_ERROR;
-			ERROR("MediaExtractor::MediaExtractor: AllocateCookie for stream %"
+			ERROR("BMediaExtractor::BMediaExtractor: AllocateCookie for stream %"
 				B_PRId32 " failed\n", i);
 		} else
 			fStreamInfo[i].hasCookie = true;
@@ -140,7 +140,7 @@ MediaExtractor::_Init(BDataIO* source, int32 flags)
 				&fStreamInfo[i].infoBuffer, &fStreamInfo[i].infoBufferSize)
 					!= B_OK) {
 			fStreamInfo[i].status = B_ERROR;
-			ERROR("MediaExtractor::MediaExtractor: GetStreamInfo for "
+			ERROR("BMediaExtractor::BMediaExtractor: GetStreamInfo for "
 				"stream %" B_PRId32 " failed\n", i);
 		}
 	}
@@ -154,7 +154,7 @@ MediaExtractor::_Init(BDataIO* source, int32 flags)
 }
 
 
-MediaExtractor::~MediaExtractor()
+BMediaExtractor::~BMediaExtractor()
 {
 	CALLED();
 
@@ -178,7 +178,7 @@ MediaExtractor::~MediaExtractor()
 
 
 status_t
-MediaExtractor::InitCheck()
+BMediaExtractor::InitCheck()
 {
 	CALLED();
 	return fInitStatus;
@@ -186,14 +186,14 @@ MediaExtractor::InitCheck()
 
 
 BDataIO*
-MediaExtractor::Source() const
+BMediaExtractor::Source() const
 {
 	return fSource;
 }
 
 
 void
-MediaExtractor::GetFileFormatInfo(media_file_format* fileFormat) const
+BMediaExtractor::GetFileFormatInfo(media_file_format* fileFormat) const
 {
 	CALLED();
 	*fileFormat = fFileFormat;
@@ -201,7 +201,7 @@ MediaExtractor::GetFileFormatInfo(media_file_format* fileFormat) const
 
 
 status_t
-MediaExtractor::GetMetaData(BMetaData* data) const
+BMediaExtractor::GetMetaData(BMetaData* data) const
 {
 	CALLED();
 	return fReader->GetMetaData(data);
@@ -209,7 +209,7 @@ MediaExtractor::GetMetaData(BMetaData* data) const
 
 
 int32
-MediaExtractor::CountStreams()
+BMediaExtractor::CountStreams()
 {
 	CALLED();
 	return fStreamCount;
@@ -217,14 +217,14 @@ MediaExtractor::CountStreams()
 
 
 const media_format*
-MediaExtractor::EncodedFormat(int32 stream)
+BMediaExtractor::EncodedFormat(int32 stream)
 {
 	return &fStreamInfo[stream].encodedFormat;
 }
 
 
 int64
-MediaExtractor::CountFrames(int32 stream) const
+BMediaExtractor::CountFrames(int32 stream) const
 {
 	CALLED();
 	if (fStreamInfo[stream].status != B_OK)
@@ -244,7 +244,7 @@ MediaExtractor::CountFrames(int32 stream) const
 
 
 bigtime_t
-MediaExtractor::Duration(int32 stream) const
+BMediaExtractor::Duration(int32 stream) const
 {
 	CALLED();
 
@@ -265,7 +265,7 @@ MediaExtractor::Duration(int32 stream) const
 
 
 status_t
-MediaExtractor::Seek(int32 stream, uint32 seekTo, int64* _frame,
+BMediaExtractor::Seek(int32 stream, uint32 seekTo, int64* _frame,
 	bigtime_t* _time)
 {
 	CALLED();
@@ -288,7 +288,7 @@ MediaExtractor::Seek(int32 stream, uint32 seekTo, int64* _frame,
 
 
 status_t
-MediaExtractor::FindKeyFrame(int32 stream, uint32 seekTo, int64* _frame,
+BMediaExtractor::FindKeyFrame(int32 stream, uint32 seekTo, int64* _frame,
 	bigtime_t* _time) const
 {
 	CALLED();
@@ -302,7 +302,7 @@ MediaExtractor::FindKeyFrame(int32 stream, uint32 seekTo, int64* _frame,
 
 
 status_t
-MediaExtractor::GetNextChunk(int32 stream, const void** _chunkBuffer,
+BMediaExtractor::GetNextChunk(int32 stream, const void** _chunkBuffer,
 	size_t* _chunkSize, media_header* mediaHeader)
 {
 	stream_info& info = fStreamInfo[stream];
@@ -336,21 +336,21 @@ MediaExtractor::GetNextChunk(int32 stream, const void** _chunkBuffer,
 
 
 status_t
-MediaExtractor::CreateDecoder(int32 stream, Decoder** _decoder,
+BMediaExtractor::CreateDecoder(int32 stream, BDecoder** _decoder,
 	media_codec_info* codecInfo)
 {
 	CALLED();
 
 	status_t status = fStreamInfo[stream].status;
 	if (status != B_OK) {
-		ERROR("MediaExtractor::CreateDecoder can't create decoder for "
+		ERROR("BMediaExtractor::CreateDecoder can't create decoder for "
 			"stream %" B_PRId32 ": %s\n", stream, strerror(status));
 		return status;
 	}
 
 	// TODO: Here we should work out a way so that if there is a setup
 	// failure we can try the next decoder
-	Decoder* decoder;
+	BDecoder* decoder;
 	status = gPluginManager.CreateDecoder(&decoder,
 		fStreamInfo[stream].encodedFormat);
 	if (status != B_OK) {
@@ -359,18 +359,18 @@ MediaExtractor::CreateDecoder(int32 stream, Decoder** _decoder,
 		string_for_format(fStreamInfo[stream].encodedFormat, formatString,
 			sizeof(formatString));
 
-		ERROR("MediaExtractor::CreateDecoder gPluginManager.CreateDecoder "
+		ERROR("BMediaExtractor::CreateDecoder gPluginManager.CreateDecoder "
 			"failed for stream %" B_PRId32 ", format: %s: %s\n", stream,
 			formatString, strerror(status));
 #endif
 		return status;
 	}
 
-	ChunkProvider* chunkProvider
-		= new(std::nothrow) MediaExtractorChunkProvider(this, stream);
+	BChunkProvider* chunkProvider
+		= new(std::nothrow) BMediaExtractorChunkProvider(this, stream);
 	if (chunkProvider == NULL) {
 		gPluginManager.DestroyDecoder(decoder);
-		ERROR("MediaExtractor::CreateDecoder can't create chunk provider "
+		ERROR("BMediaExtractor::CreateDecoder can't create chunk provider "
 			"for stream %" B_PRId32 "\n", stream);
 		return B_NO_MEMORY;
 	}
@@ -381,7 +381,7 @@ MediaExtractor::CreateDecoder(int32 stream, Decoder** _decoder,
 		fStreamInfo[stream].infoBuffer, fStreamInfo[stream].infoBufferSize);
 	if (status != B_OK) {
 		gPluginManager.DestroyDecoder(decoder);
-		ERROR("MediaExtractor::CreateDecoder Setup failed for stream %" B_PRId32
+		ERROR("BMediaExtractor::CreateDecoder Setup failed for stream %" B_PRId32
 			": %s\n", stream, strerror(status));
 		return status;
 	}
@@ -389,7 +389,7 @@ MediaExtractor::CreateDecoder(int32 stream, Decoder** _decoder,
 	status = gPluginManager.GetDecoderInfo(decoder, codecInfo);
 	if (status != B_OK) {
 		gPluginManager.DestroyDecoder(decoder);
-		ERROR("MediaExtractor::CreateDecoder GetCodecInfo failed for stream %"
+		ERROR("BMediaExtractor::CreateDecoder GetCodecInfo failed for stream %"
 			B_PRId32 ": %s\n", stream, strerror(status));
 		return status;
 	}
@@ -400,7 +400,7 @@ MediaExtractor::CreateDecoder(int32 stream, Decoder** _decoder,
 
 
 status_t
-MediaExtractor::GetStreamMetaData(int32 stream, BMetaData* data) const
+BMediaExtractor::GetStreamMetaData(int32 stream, BMetaData* data) const
 {
 	const stream_info& info = fStreamInfo[stream];
 
@@ -412,7 +412,7 @@ MediaExtractor::GetStreamMetaData(int32 stream, BMetaData* data) const
 
 
 void
-MediaExtractor::StopProcessing()
+BMediaExtractor::StopProcessing()
 {
 #if !DISABLE_CHUNK_CACHE
 	if (fExtractorWaitSem > -1) {
@@ -428,7 +428,7 @@ MediaExtractor::StopProcessing()
 
 
 void
-MediaExtractor::_RecycleLastChunk(stream_info& info)
+BMediaExtractor::_RecycleLastChunk(stream_info& info)
 {
 	if (info.lastChunk != NULL) {
 		info.chunkCache->RecycleChunk(info.lastChunk);
@@ -438,15 +438,15 @@ MediaExtractor::_RecycleLastChunk(stream_info& info)
 
 
 status_t
-MediaExtractor::_ExtractorEntry(void* extractor)
+BMediaExtractor::_ExtractorEntry(void* extractor)
 {
-	static_cast<MediaExtractor*>(extractor)->_ExtractorThread();
+	static_cast<BMediaExtractor*>(extractor)->_ExtractorThread();
 	return B_OK;
 }
 
 
 void
-MediaExtractor::_ExtractorThread()
+BMediaExtractor::_ExtractorThread()
 {
 	while (true) {
 		status_t status;

src/kits/codec/MediaPlugin.cpp

@@ -7,18 +7,18 @@
 #include "MediaPlugin.h"
 
 
-MediaPlugin::MediaPlugin()
+BMediaPlugin::BMediaPlugin()
 	:
 	fRefCount(0)
 {
 }
 
 
-MediaPlugin::~MediaPlugin()
+BMediaPlugin::~BMediaPlugin()
 {
 }
 
 
 // FBC
-void MediaPlugin::_ReservedMediaPlugin1() {}
-void MediaPlugin::_ReservedMediaPlugin2() {}
+void BMediaPlugin::_ReservedMediaPlugin1() {}
+void BMediaPlugin::_ReservedMediaPlugin2() {}

src/kits/codec/MediaStreamer.cpp

@@ -14,7 +14,7 @@
 #include "PluginManager.h"
 
 
-MediaStreamer::MediaStreamer(BUrl url)
+BMediaStreamer::BMediaStreamer(BUrl url)
 	:
 	fStreamer(NULL)
 {
@@ -24,7 +24,7 @@ MediaStreamer::MediaStreamer(BUrl url)
 }
 
 
-MediaStreamer::~MediaStreamer()
+BMediaStreamer::~BMediaStreamer()
 {
 	CALLED();
 
@@ -34,7 +34,7 @@ MediaStreamer::~MediaStreamer()
 
 
 status_t
-MediaStreamer::CreateAdapter(BDataIO** adapter)
+BMediaStreamer::CreateAdapter(BDataIO** adapter)
 {
 	CALLED();
 

src/kits/codec/MediaWriter.cpp

@@ -18,9 +18,9 @@
 #include "PluginManager.h"
 
 
-class MediaExtractorChunkWriter : public ChunkWriter {
+class BMediaExtractorChunkWriter : public BChunkWriter {
 public:
-	MediaExtractorChunkWriter(MediaWriter* writer, int32 streamIndex)
+	BMediaExtractorChunkWriter(BMediaWriter* writer, int32 streamIndex)
 		:
 		fWriter(writer),
 		fStreamIndex(streamIndex)
@@ -35,7 +35,7 @@ public:
 	}
 
 private:
-	MediaWriter*	fWriter;
+	BMediaWriter*	fWriter;
 	int32			fStreamIndex;
 };
 
@@ -43,7 +43,7 @@ private:
 // #pragma mark -
 
 
-MediaWriter::MediaWriter(BDataIO* target, const media_file_format& fileFormat)
+BMediaWriter::BMediaWriter(BDataIO* target, const media_file_format& fileFormat)
 	:
 	fTarget(target),
 	fWriter(NULL),
@@ -56,7 +56,7 @@ MediaWriter::MediaWriter(BDataIO* target, const media_file_format& fileFormat)
 }
 
 
-MediaWriter::~MediaWriter()
+BMediaWriter::~BMediaWriter()
 {
 	CALLED();
 
@@ -75,7 +75,7 @@ MediaWriter::~MediaWriter()
 
 
 status_t
-MediaWriter::InitCheck()
+BMediaWriter::InitCheck()
 {
 	CALLED();
 
@@ -84,14 +84,14 @@ MediaWriter::InitCheck()
 
 
 BDataIO*
-MediaWriter::Target() const
+BMediaWriter::Target() const
 {
 	return fTarget;
 }
 
 
 void
-MediaWriter::GetFileFormatInfo(media_file_format* _fileFormat) const
+BMediaWriter::GetFileFormatInfo(media_file_format* _fileFormat) const
 {
 	CALLED();
 
@@ -101,7 +101,7 @@ MediaWriter::GetFileFormatInfo(media_file_format* _fileFormat) const
 
 
 status_t
-MediaWriter::CreateEncoder(Encoder** _encoder,
+BMediaWriter::CreateEncoder(BEncoder** _encoder,
 	const media_codec_info* codecInfo, media_format* format, uint32 flags)
 {
 	CALLED();
@@ -111,10 +111,10 @@ MediaWriter::CreateEncoder(Encoder** _encoder,
 
 	// TODO: Here we should work out a way so that if there is a setup
 	// failure we can try the next encoder.
-	Encoder* encoder;
+	BEncoder* encoder;
 	status_t ret = gPluginManager.CreateEncoder(&encoder, codecInfo, flags);
 	if (ret != B_OK) {
-		ERROR("MediaWriter::CreateEncoder gPluginManager.CreateEncoder "
+		ERROR("BMediaWriter::CreateEncoder gPluginManager.CreateEncoder "
 			"failed, codec: %s\n", codecInfo->pretty_name);
 		return ret;
 	}
@@ -130,16 +130,16 @@ MediaWriter::CreateEncoder(Encoder** _encoder,
 
 	if (!fStreamInfos.Insert(info)) {
 		gPluginManager.DestroyEncoder(encoder);
-		ERROR("MediaWriter::CreateEncoder can't create StreamInfo "
+		ERROR("BMediaWriter::CreateEncoder can't create StreamInfo "
 			"for stream %" B_PRId32 "\n", streamIndex);
 		return B_NO_MEMORY;
 	}
 
-	ChunkWriter* chunkWriter = new(std::nothrow) MediaExtractorChunkWriter(
+	BChunkWriter* chunkWriter = new(std::nothrow) BMediaExtractorChunkWriter(
 		this, streamIndex);
 	if (chunkWriter == NULL) {
 		gPluginManager.DestroyEncoder(encoder);
-		ERROR("MediaWriter::CreateEncoder can't create ChunkWriter "
+		ERROR("BMediaWriter::CreateEncoder can't create ChunkWriter "
 			"for stream %" B_PRId32 "\n", streamIndex);
 		return B_NO_MEMORY;
 	}
@@ -152,7 +152,7 @@ MediaWriter::CreateEncoder(Encoder** _encoder,
 
 
 status_t
-MediaWriter::SetMetaData(BMetaData* data)
+BMediaWriter::SetMetaData(BMetaData* data)
 {
 	if (fWriter == NULL)
 		return B_NO_INIT;
@@ -162,7 +162,7 @@ MediaWriter::SetMetaData(BMetaData* data)
 
 
 status_t
-MediaWriter::SetMetaData(int32 streamIndex, BMetaData* data)
+BMediaWriter::SetMetaData(int32 streamIndex, BMetaData* data)
 {
 	if (fWriter == NULL)
 		return B_NO_INIT;
@@ -176,7 +176,7 @@ MediaWriter::SetMetaData(int32 streamIndex, BMetaData* data)
 
 
 status_t
-MediaWriter::CommitHeader()
+BMediaWriter::CommitHeader()
 {
 	if (fWriter == NULL)
 		return B_NO_INIT;
@@ -186,7 +186,7 @@ MediaWriter::CommitHeader()
 
 
 status_t
-MediaWriter::Flush()
+BMediaWriter::Flush()
 {
 	if (fWriter == NULL)
 		return B_NO_INIT;
@@ -196,7 +196,7 @@ MediaWriter::Flush()
 
 
 status_t
-MediaWriter::Close()
+BMediaWriter::Close()
 {
 	if (fWriter == NULL)
 		return B_NO_INIT;
@@ -206,7 +206,7 @@ MediaWriter::Close()
 
 
 status_t
-MediaWriter::AddTrackInfo(int32 streamIndex, uint32 code,
+BMediaWriter::AddTrackInfo(int32 streamIndex, uint32 code,
 	const void* data, size_t size, uint32 flags)
 {
 	if (fWriter == NULL)
@@ -221,7 +221,7 @@ MediaWriter::AddTrackInfo(int32 streamIndex, uint32 code,
 
 
 status_t
-MediaWriter::WriteChunk(int32 streamIndex, const void* chunkBuffer,
+BMediaWriter::WriteChunk(int32 streamIndex, const void* chunkBuffer,
 	size_t chunkSize, media_encode_info* encodeInfo)
 {
 	if (fWriter == NULL)

src/kits/codec/PluginManager.cpp

@@ -225,7 +225,7 @@ private:
 
 
 status_t
-PluginManager::CreateReader(Reader** reader, int32* streamCount,
+PluginManager::CreateReader(BReader** reader, int32* streamCount,
 	media_file_format* mff, BDataIO* source)
 {
 	TRACE("PluginManager::CreateReader enter\n");
@@ -255,13 +255,13 @@ PluginManager::CreateReader(Reader** reader, int32* streamCount,
 	// try each reader by calling it's Sniff function...
 	for (int32 i = 0; i < count; i++) {
 		entry_ref ref = refs[i];
-		MediaPlugin* plugin = GetPlugin(ref);
+		BMediaPlugin* plugin = GetPlugin(ref);
 		if (plugin == NULL) {
 			printf("PluginManager::CreateReader: GetPlugin failed\n");
 			return B_ERROR;
 		}
 
-		ReaderPlugin* readerPlugin = dynamic_cast<ReaderPlugin*>(plugin);
+		BReaderPlugin* readerPlugin = dynamic_cast<BReaderPlugin*>(plugin);
 		if (readerPlugin == NULL) {
 			printf("PluginManager::CreateReader: dynamic_cast failed\n");
 			PutPlugin(plugin);
@@ -297,7 +297,7 @@ PluginManager::CreateReader(Reader** reader, int32* streamCount,
 
 
 void
-PluginManager::DestroyReader(Reader* reader)
+PluginManager::DestroyReader(BReader* reader)
 {
 	if (reader != NULL) {
 		TRACE("PluginManager::DestroyReader(%p (plugin: %p))\n", reader,
@@ -305,7 +305,7 @@ PluginManager::DestroyReader(Reader* reader)
 		// NOTE: We have to put the plug-in after deleting the reader,
 		// since otherwise we may actually unload the code for the
 		// destructor...
-		MediaPlugin* plugin = reader->fMediaPlugin;
+		BMediaPlugin* plugin = reader->fMediaPlugin;
 		delete reader;
 		PutPlugin(plugin);
 	}
@@ -313,7 +313,7 @@ PluginManager::DestroyReader(Reader* reader)
 
 
 status_t
-PluginManager::CreateDecoder(Decoder** _decoder, const media_format& format)
+PluginManager::CreateDecoder(BDecoder** _decoder, const media_format& format)
 {
 	TRACE("PluginManager::CreateDecoder enter\n");
 
@@ -327,13 +327,13 @@ PluginManager::CreateDecoder(Decoder** _decoder, const media_format& format)
 		return ret;
 	}
 
-	MediaPlugin* plugin = GetPlugin(ref);
+	BMediaPlugin* plugin = GetPlugin(ref);
 	if (plugin == NULL) {
 		printf("PluginManager::CreateDecoder: GetPlugin failed\n");
 		return B_ERROR;
 	}
 	
-	DecoderPlugin* decoderPlugin = dynamic_cast<DecoderPlugin*>(plugin);
+	BDecoderPlugin* decoderPlugin = dynamic_cast<BDecoderPlugin*>(plugin);
 	if (decoderPlugin == NULL) {
 		printf("PluginManager::CreateDecoder: dynamic_cast failed\n");
 		PutPlugin(plugin);
@@ -358,7 +358,7 @@ PluginManager::CreateDecoder(Decoder** _decoder, const media_format& format)
 
 
 status_t
-PluginManager::CreateDecoder(Decoder** decoder, const media_codec_info& mci)
+PluginManager::CreateDecoder(BDecoder** decoder, const media_codec_info& mci)
 {
 	TRACE("PluginManager::CreateDecoder enter\n");
 	entry_ref ref;
@@ -366,13 +366,13 @@ PluginManager::CreateDecoder(Decoder** decoder, const media_codec_info& mci)
 	if (status != B_OK)
 		return status;
 
-	MediaPlugin* plugin = GetPlugin(ref);
+	BMediaPlugin* plugin = GetPlugin(ref);
 	if (plugin == NULL) {
 		ERROR("PluginManager::CreateDecoder: GetPlugin failed\n");
 		return B_ERROR;
 	}
 
-	DecoderPlugin* decoderPlugin = dynamic_cast<DecoderPlugin*>(plugin);
+	BDecoderPlugin* decoderPlugin = dynamic_cast<BDecoderPlugin*>(plugin);
 	if (decoderPlugin == NULL) {
 		ERROR("PluginManager::CreateDecoder: dynamic_cast failed\n");
 		PutPlugin(plugin);
@@ -398,7 +398,7 @@ PluginManager::CreateDecoder(Decoder** decoder, const media_codec_info& mci)
 
 
 status_t
-PluginManager::GetDecoderInfo(Decoder* decoder, media_codec_info* _info) const
+PluginManager::GetDecoderInfo(BDecoder* decoder, media_codec_info* _info) const
 {
 	if (decoder == NULL)
 		return B_BAD_VALUE;
@@ -412,7 +412,7 @@ PluginManager::GetDecoderInfo(Decoder* decoder, media_codec_info* _info) const
 
 
 void
-PluginManager::DestroyDecoder(Decoder* decoder)
+PluginManager::DestroyDecoder(BDecoder* decoder)
 {
 	if (decoder != NULL) {
 		TRACE("PluginManager::DestroyDecoder(%p, plugin: %p)\n", decoder,
@@ -420,7 +420,7 @@ PluginManager::DestroyDecoder(Decoder* decoder)
 		// NOTE: We have to put the plug-in after deleting the decoder,
 		// since otherwise we may actually unload the code for the
 		// destructor...
-		MediaPlugin* plugin = decoder->fMediaPlugin;
+		BMediaPlugin* plugin = decoder->fMediaPlugin;
 		delete decoder;
 		PutPlugin(plugin);
 	}
@@ -431,7 +431,7 @@ PluginManager::DestroyDecoder(Decoder* decoder)
 
 
 status_t
-PluginManager::CreateWriter(Writer** writer, const media_file_format& mff,
+PluginManager::CreateWriter(BWriter** writer, const media_file_format& mff,
 	BDataIO* target)
 {
 	TRACE("PluginManager::CreateWriter enter\n");
@@ -446,13 +446,13 @@ PluginManager::CreateWriter(Writer** writer, const media_file_format& mff,
 		return ret;
 	}
 
-	MediaPlugin* plugin = GetPlugin(ref);
+	BMediaPlugin* plugin = GetPlugin(ref);
 	if (plugin == NULL) {
 		printf("PluginManager::CreateWriter: GetPlugin failed\n");
 		return B_ERROR;
 	}
 
-	WriterPlugin* writerPlugin = dynamic_cast<WriterPlugin*>(plugin);
+	BWriterPlugin* writerPlugin = dynamic_cast<BWriterPlugin*>(plugin);
 	if (writerPlugin == NULL) {
 		printf("PluginManager::CreateWriter: dynamic_cast failed\n");
 		PutPlugin(plugin);
@@ -475,7 +475,7 @@ PluginManager::CreateWriter(Writer** writer, const media_file_format& mff,
 
 
 void
-PluginManager::DestroyWriter(Writer* writer)
+PluginManager::DestroyWriter(BWriter* writer)
 {
 	if (writer != NULL) {
 		TRACE("PluginManager::DestroyWriter(%p (plugin: %p))\n", writer,
@@ -483,7 +483,7 @@ PluginManager::DestroyWriter(Writer* writer)
 		// NOTE: We have to put the plug-in after deleting the writer,
 		// since otherwise we may actually unload the code for the
 		// destructor...
-		MediaPlugin* plugin = writer->fMediaPlugin;
+		BMediaPlugin* plugin = writer->fMediaPlugin;
 		delete writer;
 		PutPlugin(plugin);
 	}
@@ -491,7 +491,7 @@ PluginManager::DestroyWriter(Writer* writer)
 
 
 status_t
-PluginManager::CreateEncoder(Encoder** _encoder,
+PluginManager::CreateEncoder(BEncoder** _encoder,
 	const media_codec_info* codecInfo, uint32 flags)
 {
 	TRACE("PluginManager::CreateEncoder enter\n");
@@ -506,13 +506,13 @@ PluginManager::CreateEncoder(Encoder** _encoder,
 		return ret;
 	}
 
-	MediaPlugin* plugin = GetPlugin(ref);
+	BMediaPlugin* plugin = GetPlugin(ref);
 	if (!plugin) {
 		printf("PluginManager::CreateEncoder: GetPlugin failed\n");
 		return B_ERROR;
 	}
 	
-	EncoderPlugin* encoderPlugin = dynamic_cast<EncoderPlugin*>(plugin);
+	BEncoderPlugin* encoderPlugin = dynamic_cast<BEncoderPlugin*>(plugin);
 	if (encoderPlugin == NULL) {
 		printf("PluginManager::CreateEncoder: dynamic_cast failed\n");
 		PutPlugin(plugin);
@@ -535,7 +535,7 @@ PluginManager::CreateEncoder(Encoder** _encoder,
 
 
 status_t
-PluginManager::CreateEncoder(Encoder** encoder, const media_format& format)
+PluginManager::CreateEncoder(BEncoder** encoder, const media_format& format)
 {
 	TRACE("PluginManager::CreateEncoder enter nr2\n");
 
@@ -550,13 +550,13 @@ PluginManager::CreateEncoder(Encoder** encoder, const media_format& format)
 		return ret;
 	}
 
-	MediaPlugin* plugin = GetPlugin(ref);
+	BMediaPlugin* plugin = GetPlugin(ref);
 	if (plugin == NULL) {
 		ERROR("PluginManager::CreateEncoder: GetPlugin failed\n");
 		return B_ERROR;
 	}
 
-	EncoderPlugin* encoderPlugin = dynamic_cast<EncoderPlugin*>(plugin);
+	BEncoderPlugin* encoderPlugin = dynamic_cast<BEncoderPlugin*>(plugin);
 	if (encoderPlugin == NULL) {
 		ERROR("PluginManager::CreateEncoder: dynamic_cast failed\n");
 		PutPlugin(plugin);
@@ -580,7 +580,7 @@ PluginManager::CreateEncoder(Encoder** encoder, const media_format& format)
 
 
 void
-PluginManager::DestroyEncoder(Encoder* encoder)
+PluginManager::DestroyEncoder(BEncoder* encoder)
 {
 	if (encoder != NULL) {
 		TRACE("PluginManager::DestroyEncoder(%p, plugin: %p)\n", encoder,
@@ -588,7 +588,7 @@ PluginManager::DestroyEncoder(Encoder* encoder)
 		// NOTE: We have to put the plug-in after deleting the encoder,
 		// since otherwise we may actually unload the code for the
 		// destructor...
-		MediaPlugin* plugin = encoder->fMediaPlugin;
+		BMediaPlugin* plugin = encoder->fMediaPlugin;
 		delete encoder;
 		PutPlugin(plugin);
 	}
@@ -596,7 +596,7 @@ PluginManager::DestroyEncoder(Encoder* encoder)
 
 
 status_t
-PluginManager::CreateStreamer(Streamer** streamer, BUrl url, BDataIO** source)
+PluginManager::CreateStreamer(BStreamer** streamer, BUrl url, BDataIO** source)
 {
 	BAutolock _(fLocker);
 
@@ -616,13 +616,13 @@ PluginManager::CreateStreamer(Streamer** streamer, BUrl url, BDataIO** source)
 	// try each reader by calling it's Sniff function...
 	for (int32 i = 0; i < count; i++) {
 		entry_ref ref = refs[i];
-		MediaPlugin* plugin = GetPlugin(ref);
+		BMediaPlugin* plugin = GetPlugin(ref);
 		if (plugin == NULL) {
 			printf("PluginManager::CreateStreamer: GetPlugin failed\n");
 			return B_ERROR;
 		}
 
-		StreamerPlugin* streamerPlugin = dynamic_cast<StreamerPlugin*>(plugin);
+		BStreamerPlugin* streamerPlugin = dynamic_cast<BStreamerPlugin*>(plugin);
 		if (streamerPlugin == NULL) {
 			printf("PluginManager::CreateStreamer: dynamic_cast failed\n");
 			PutPlugin(plugin);
@@ -656,7 +656,7 @@ PluginManager::CreateStreamer(Streamer** streamer, BUrl url, BDataIO** source)
 
 
 void
-PluginManager::DestroyStreamer(Streamer* streamer)
+PluginManager::DestroyStreamer(BStreamer* streamer)
 {
 	BAutolock _(fLocker);
 
@@ -667,7 +667,7 @@ PluginManager::DestroyStreamer(Streamer* streamer)
 		// NOTE: We have to put the plug-in after deleting the streamer,
 		// since otherwise we may actually unload the code for the
 		// destructor...
-		MediaPlugin* plugin = streamer->fMediaPlugin;
+		BMediaPlugin* plugin = streamer->fMediaPlugin;
 		delete streamer;
 
 		// Delete the plugin only when every reference is released
@@ -706,13 +706,13 @@ PluginManager::~PluginManager()
 }
 
 	
-MediaPlugin*
+BMediaPlugin*
 PluginManager::GetPlugin(const entry_ref& ref)
 {
 	TRACE("PluginManager::GetPlugin(%s)\n", ref.name);
 	fLocker.Lock();
 	
-	MediaPlugin* plugin;
+	BMediaPlugin* plugin;
 	plugin_info* pinfo;
 	plugin_info info;
 	
@@ -747,7 +747,7 @@ PluginManager::GetPlugin(const entry_ref& ref)
 
 
 void
-PluginManager::PutPlugin(MediaPlugin* plugin)
+PluginManager::PutPlugin(BMediaPlugin* plugin)
 {
 	TRACE("PluginManager::PutPlugin()\n");
 	fLocker.Lock();
@@ -776,7 +776,7 @@ PluginManager::PutPlugin(MediaPlugin* plugin)
 
 
 status_t
-PluginManager::_LoadPlugin(const entry_ref& ref, MediaPlugin** plugin,
+PluginManager::_LoadPlugin(const entry_ref& ref, BMediaPlugin** plugin,
 	image_id* image)
 {
 	BPath p(&ref);
@@ -790,7 +790,7 @@ PluginManager::_LoadPlugin(const entry_ref& ref, MediaPlugin** plugin,
 		return B_ERROR;
 	}
 		
-	MediaPlugin* (*instantiate_plugin_func)();
+	BMediaPlugin* (*instantiate_plugin_func)();
 	
 	if (get_image_symbol(id, "instantiate_plugin", B_SYMBOL_TYPE_TEXT,
 			(void**)&instantiate_plugin_func) < B_OK) {
@@ -800,7 +800,7 @@ PluginManager::_LoadPlugin(const entry_ref& ref, MediaPlugin** plugin,
 		return B_ERROR;
 	}
 	
-	MediaPlugin *pl;
+	BMediaPlugin *pl;
 	
 	pl = (*instantiate_plugin_func)();
 	if (pl == NULL) {

src/kits/codec/Reader.cpp

@@ -12,7 +12,7 @@
 #include <stdio.h>
 
 
-Reader::Reader()
+BReader::BReader()
 	:
 	fSource(NULL),
 	fMediaPlugin(NULL)
@@ -20,62 +20,62 @@ Reader::Reader()
 }
 
 
-Reader::~Reader()
+BReader::~BReader()
 {
 }
 
 
 status_t
-Reader::GetMetaData(BMetaData* data)
+BReader::GetMetaData(BMetaData* data)
 {
 	return B_NOT_SUPPORTED;
 }
 
 
 status_t
-Reader::Seek(void* cookie, uint32 flags, int64* frame, bigtime_t* time)
+BReader::Seek(void* cookie, uint32 flags, int64* frame, bigtime_t* time)
 {
 	return B_NOT_SUPPORTED;
 }
 
 
 status_t
-Reader::FindKeyFrame(void* cookie, uint32 flags, int64* frame, bigtime_t* time)
+BReader::FindKeyFrame(void* cookie, uint32 flags, int64* frame, bigtime_t* time)
 {
 	return B_NOT_SUPPORTED;
 }
 
 
 status_t
-Reader::GetStreamMetaData(void* cookie, BMetaData* data)
+BReader::GetStreamMetaData(void* cookie, BMetaData* data)
 {
 	return B_NOT_SUPPORTED;
 }
 
 
 BDataIO*
-Reader::Source() const
+BReader::Source() const
 {
 	return fSource;
 }
 
 
 void
-Reader::_Setup(BDataIO *source)
+BReader::_Setup(BDataIO *source)
 {
 	fSource = source;
 }
 
 
 status_t
-Reader::Perform(perform_code code, void* _data)
+BReader::Perform(perform_code code, void* _data)
 {
 	return B_OK;
 }
 
 
-void Reader::_ReservedReader1() {}
-void Reader::_ReservedReader2() {}
-void Reader::_ReservedReader3() {}
-void Reader::_ReservedReader4() {}
-void Reader::_ReservedReader5() {}
+void BReader::_ReservedReader1() {}
+void BReader::_ReservedReader2() {}
+void BReader::_ReservedReader3() {}
+void BReader::_ReservedReader4() {}
+void BReader::_ReservedReader5() {}

src/kits/codec/Streamer.cpp

@@ -7,25 +7,25 @@
 #include <Streamer.h>
 
 
-Streamer::Streamer()
+BStreamer::BStreamer()
 	:
 	fMediaPlugin(NULL)
 {
 }
 
 
-Streamer::~Streamer()
+BStreamer::~BStreamer()
 {
 }
 
 
-void Streamer::_ReservedStreamer1() {}
-void Streamer::_ReservedStreamer2() {}
-void Streamer::_ReservedStreamer3() {}
-void Streamer::_ReservedStreamer4() {}
-void Streamer::_ReservedStreamer5() {}
+void BStreamer::_ReservedStreamer1() {}
+void BStreamer::_ReservedStreamer2() {}
+void BStreamer::_ReservedStreamer3() {}
+void BStreamer::_ReservedStreamer4() {}
+void BStreamer::_ReservedStreamer5() {}
 
 
-StreamerPlugin::StreamerPlugin()
+BStreamerPlugin::BStreamerPlugin()
 {
 }

src/kits/codec/Writer.cpp

@@ -10,7 +10,7 @@
 #include <stdio.h>
 
 
-Writer::Writer()
+BWriter::BWriter()
 	:
 	fTarget(NULL),
 	fMediaPlugin(NULL)
@@ -18,34 +18,34 @@ Writer::Writer()
 }
 
 
-Writer::~Writer()
+BWriter::~BWriter()
 {
 }
 
 
 BDataIO*
-Writer::Target() const
+BWriter::Target() const
 {
 	return fTarget;
 }
 
 
 void
-Writer::_Setup(BDataIO* target)
+BWriter::_Setup(BDataIO* target)
 {
 	fTarget = target;
 }
 
 
 status_t
-Writer::Perform(perform_code code, void* data)
+BWriter::Perform(perform_code code, void* data)
 {
 	return B_OK;
 }
 
 
-void Writer::_ReservedWriter1() {}
-void Writer::_ReservedWriter2() {}
-void Writer::_ReservedWriter3() {}
-void Writer::_ReservedWriter4() {}
-void Writer::_ReservedWriter5() {}
+void BWriter::_ReservedWriter1() {}
+void BWriter::_ReservedWriter2() {}
+void BWriter::_ReservedWriter3() {}
+void BWriter::_ReservedWriter4() {}
+void BWriter::_ReservedWriter5() {}