* Cleanup.

git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@33998 a95241bf-73f2-0310-859d-f6bbb57e9c96

src/tests/kits/media/nodetest/ConsumerNode.cpp

@@ -1,10 +1,16 @@
-#include <TimeSource.h>
-#include <Buffer.h>
-#include <stdlib.h>
 #include "ConsumerNode.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <Buffer.h>
+#include <TimeSource.h>
+
 #include "misc.h"
 
-ConsumerNode::ConsumerNode() : 
+
+ConsumerNode::ConsumerNode()
+	:
 	BBufferConsumer(B_MEDIA_RAW_AUDIO),
 	BMediaEventLooper(),
 	BMediaNode("ConsumerNode")
@@ -12,12 +18,14 @@ ConsumerNode::ConsumerNode() :
 	out("ConsumerNode::ConsumerNode\n");
 }
 
+
 ConsumerNode::~ConsumerNode()
 {
 	out("ConsumerNode::~ConsumerNode\n");
 	Quit();
 }
 
+
 void
 ConsumerNode::NodeRegistered()
 {
@@ -27,14 +35,13 @@ ConsumerNode::NodeRegistered()
 	Run();
 }
 
+
 status_t
-ConsumerNode::AcceptFormat(
+ConsumerNode::AcceptFormat(const media_destination& dest, media_format* format)
-				const media_destination & dest,
-				media_format * format)
 {
 	out("ConsumerNode::AcceptFormat\n");
 
-	if (dest != mInput.destination) 
+	if (dest != fInput.destination)
 		return B_MEDIA_BAD_DESTINATION;
 
 	if (format == NULL)
@@ -46,93 +53,95 @@ ConsumerNode::AcceptFormat(
 	return B_OK;
 }
 
+
 status_t
-ConsumerNode::GetNextInput(
+ConsumerNode::GetNextInput(int32* cookie, media_input* _input)
-				int32 * cookie,
-				media_input * out_input)
 {
 	out("ConsumerNode::GetNextInput\n");
 
-	if (out_input == NULL)
+	if (_input == NULL)
 		return B_BAD_VALUE;
 
 	if (++(*cookie) > 1)
 		return B_BAD_INDEX;
 
-	*out_input = mInput;
+	*_input = fInput;
 	return B_OK;
 }
 
+
 void
-ConsumerNode::DisposeInputCookie(
+ConsumerNode::DisposeInputCookie(int32 cookie)
-				int32 cookie)
 {
 	out("ConsumerNode::DisposeInputCookie\n");
 	return;
 }
 
+
 void
-ConsumerNode::BufferReceived(
+ConsumerNode::BufferReceived(BBuffer* buffer)
-				BBuffer * buffer)
 {
-	out("ConsumerNode::BufferReceived, sheduled time = %5.4f\n",buffer->Header()->start_time / 1E6);
+	out("ConsumerNode::BufferReceived, sheduled time = %5.4f\n",
-	media_timed_event event(buffer->Header()->start_time,BTimedEventQueue::B_HANDLE_BUFFER,
+		buffer->Header()->start_time / 1E6);
-							buffer, BTimedEventQueue::B_RECYCLE_BUFFER);
+
+	media_timed_event event(buffer->Header()->start_time,
+		BTimedEventQueue::B_HANDLE_BUFFER, buffer,
+		BTimedEventQueue::B_RECYCLE_BUFFER);
 	EventQueue()->AddEvent(event);
 	return;
 }
 
+
 void
-ConsumerNode::ProducerDataStatus(
+ConsumerNode::ProducerDataStatus(const media_destination& forWhom, int32 status,
-				const media_destination & for_whom,
+	bigtime_t atPerformanceTime)
-				int32 status,
-				bigtime_t at_performance_time)
 {
 	out("ConsumerNode::ProducerDataStatus\n");
-	if (for_whom == mInput.destination) {
+
-		media_timed_event event(at_performance_time,BTimedEventQueue::B_DATA_STATUS,
+	if (forWhom == fInput.destination) {
-								&mInput, BTimedEventQueue::B_NO_CLEANUP, status, 0, NULL);
+		media_timed_event event(atPerformanceTime,
+			BTimedEventQueue::B_DATA_STATUS, &fInput,
+			BTimedEventQueue::B_NO_CLEANUP, status, 0, NULL);
 		EventQueue()->AddEvent(event);
 	}
 }
 
+
 status_t
-ConsumerNode::GetLatencyFor(
+ConsumerNode::GetLatencyFor(const media_destination& forWhom,
-				const media_destination & for_whom,
+	bigtime_t* _latency, media_node_id* _timesource)
-				bigtime_t * out_latency,
-				media_node_id * out_timesource)
 {
 	out("ConsumerNode::GetLatencyFor\n");
 	// make sure this is one of my valid inputs
-	if (for_whom != mInput.destination) 
+	if (forWhom != fInput.destination)
 		return B_MEDIA_BAD_DESTINATION;
 
-	*out_latency = 23000;
+	*_latency = 23000;
-	*out_timesource = TimeSource()->ID();
+	*_timesource = TimeSource()->ID();
 	return B_OK;
 }
 
+
 status_t
-ConsumerNode::Connected(
+ConsumerNode::Connected(const media_source& producer,
-				const media_source & producer,
+	const media_destination& where, const media_format& withFormat,
-				const media_destination & where,
+	media_input* _input)
-				const media_format & with_format,
-				media_input * out_input)
 {
 	out("ConsumerNode::Connected\n");
-	if (where != mInput.destination) 
+	if (where != fInput.destination)
 		return B_MEDIA_BAD_DESTINATION;
 
-	// calculate my latency here, because it may depend on buffer sizes/durations, then
+	// calculate my latency here, because it may depend on buffer
-	// tell the BMediaEventLooper how early we need to get the buffers
+	// sizes/durations, then tell the BMediaEventLooper how early
-	SetEventLatency(10 * 1000); //fixme
+	// we need to get the buffers
+	SetEventLatency(10 * 1000); // TODO: fix me
 
 	/* reserve the connection */
-	mInput.source = producer;
+	fInput.source = producer;
-	mInput.format = with_format;
+	fInput.format = withFormat;
 
 	/* and publish it's name and connection info */
-	*out_input = mInput;
+	*_input = fInput;
 
 #if 0
 	/* create the buffer group */
@@ -150,10 +159,10 @@ ConsumerNode::Connected(
 	return B_OK;
 }
 
+
 void
-ConsumerNode::Disconnected(
+ConsumerNode::Disconnected(const media_source& producer,
-				const media_source & producer,
+	const media_destination& where)
-				const media_destination & where)
 {
 	out("ConsumerNode::Disconnected\n");
 
@@ -171,131 +180,122 @@ ConsumerNode::Disconnected(
 	return;
 }
 
+
 status_t
-ConsumerNode::FormatChanged(
+ConsumerNode::FormatChanged(const media_source& producer,
-				const media_source & producer,
+	const media_destination& consumer, int32 changeTag,
-				const media_destination & consumer, 
+	const media_format& format)
-				int32 change_tag,
-				const media_format & format)
 {
 	out("ConsumerNode::FormatChanged\n");
 	return B_OK;
 }
 
+
 status_t
-ConsumerNode::SeekTagRequested(
+ConsumerNode::SeekTagRequested(const media_destination& destination,
-				const media_destination& destination,
+	bigtime_t targetTime, uint32 flags, media_seek_tag* _seekTag,
-				bigtime_t in_target_time,
+	bigtime_t* _taggedTime, uint32* _flags)
-				uint32 in_flags,
-				media_seek_tag* out_seek_tag,
-				bigtime_t* out_tagged_time,
-				uint32* out_flags)
 {
 	out("ConsumerNode::SeekTagRequested\n");
 	return B_OK;
 }
 
+
 BMediaAddOn*
-ConsumerNode::AddOn(int32 * internal_id) const
+ConsumerNode::AddOn(int32* internalID) const
 {
 	out("ConsumerNode::AddOn\n");
 	return NULL;
 }
 
+
 void
-ConsumerNode::HandleEvent(const media_timed_event *event,
+ConsumerNode::HandleEvent(const media_timed_event* event, bigtime_t lateness,
-						 bigtime_t lateness,
+	bool realTimeEvent)
-						 bool realTimeEvent)
 {
-	switch (event->type)
+	switch (event->type) {
-	{
+		case BTimedEventQueue::B_HANDLE_BUFFER:
-	case BTimedEventQueue::B_HANDLE_BUFFER:
 		{
 			out("ConsumerNode::HandleEvent B_HANDLE_BUFFER\n");
-			BBuffer* buffer = const_cast<BBuffer*>((BBuffer*) event->pointer);
+			BBuffer* buffer = const_cast<BBuffer*>((BBuffer*)event->pointer);
 
-			out("### sheduled time = %5.4f, current time = %5.4f, lateness = %5.4f\n",buffer->Header()->start_time / 1E6,TimeSource()->Now() / 1E6,lateness / 1E6);
+			out("### sheduled time = %5.4f, current time = %5.4f, lateness = "
+				"%5.4f\n", buffer->Header()->start_time / 1E6,
+				TimeSource()->Now() / 1E6,lateness / 1E6);
 
-			snooze((rand()*100) % 200000);
+			snooze((rand() * 100) % 200000);
 
 			if (buffer)
 				buffer->Recycle();
+			break;
 		}
-		break;
 
-	case BTimedEventQueue::B_PARAMETER:
+		case BTimedEventQueue::B_PARAMETER:
-		{
 			out("ConsumerNode::HandleEvent B_PARAMETER\n");
-		}
+			break;
-		break;
 
-	case BTimedEventQueue::B_START:
+		case BTimedEventQueue::B_START:
-		{
 			out("ConsumerNode::HandleEvent B_START\n");
-		}
+			break;
-		break;
 
-	case BTimedEventQueue::B_STOP:
+		case BTimedEventQueue::B_STOP:
-		{
 			out("ConsumerNode::HandleEvent B_STOP\n");
-		}
+			// stopping implies not handling any more buffers.  So, we flush
-		// stopping implies not handling any more buffers.  So, we flush all pending
+			// all pending buffers out of the event queue before returning to
-		// buffers out of the event queue before returning to the event loop.
+			// the event loop.
-		EventQueue()->FlushEvents(0, BTimedEventQueue::B_ALWAYS, true, BTimedEventQueue::B_HANDLE_BUFFER);
+			EventQueue()->FlushEvents(0, BTimedEventQueue::B_ALWAYS, true,
-		break;
+				BTimedEventQueue::B_HANDLE_BUFFER);
+			break;
 
-	case BTimedEventQueue::B_SEEK:
+		case BTimedEventQueue::B_SEEK:
-		{
 			out("ConsumerNode::HandleEvent B_SEEK\n");
-		}
+			break;
-		break;
 
-	case BTimedEventQueue::B_WARP:
+		case BTimedEventQueue::B_WARP:
-		{
 			out("ConsumerNode::HandleEvent B_WARP\n");
-		}
+			// similarly, time warps aren't meaningful to the logger, so just
-		// similarly, time warps aren't meaningful to the logger, so just record it and return
+			// record it and return
-		//mLogger->Log(LOG_WARP_HANDLED, logMsg);
+			//mLogger->Log(LOG_WARP_HANDLED, logMsg);
-		break;
+			break;
 
-	case BTimedEventQueue::B_DATA_STATUS:
+		case BTimedEventQueue::B_DATA_STATUS:
-		{
 			out("ConsumerNode::HandleEvent B_DATA_STATUS\n");
-		}
+			break;
-		break;
 
-	default:
+		default:
-		{
 			out("ConsumerNode::HandleEvent default\n");
-		}
+			break;
-		break;
 	}
 }
 
+
 status_t
-ConsumerNode::HandleMessage(int32 message,const void *data, size_t size)
+ConsumerNode::HandleMessage(int32 message, const void* data, size_t size)
 {
-	out("ConsumerNode::HandleMessage %lx\n",message);
+	out("ConsumerNode::HandleMessage %lx\n", message);
-	if (B_OK == BBufferConsumer::HandleMessage(message,data,size))
+
+	if (BBufferConsumer::HandleMessage(message, data, size) == B_OK
+		|| BMediaEventLooper::HandleMessage(message, data, size) == B_OK)
 		return B_OK;
-	if (B_OK == BMediaEventLooper::HandleMessage(message,data,size))
+
-		return B_OK;
+	return BMediaNode::HandleMessage(message, data, size);
-	return BMediaNode::HandleMessage(message,data,size);
 }
 
+
 void
 ConsumerNode::InitializeInput()
 {
 	out("ConsumerNode::InitializeInput()\n");
-	mInput.source = media_source::null;
+	fInput.source = media_source::null;
-	mInput.destination.port = ControlPort(); 
+	fInput.destination.port = ControlPort();
-	mInput.destination.id = 0; 
+	fInput.destination.id = 0;
-	mInput.node = Node();
+	fInput.node = Node();
-	mInput.format.type = B_MEDIA_RAW_AUDIO;
+	fInput.format.type = B_MEDIA_RAW_AUDIO;
-	mInput.format.u.raw_audio = media_raw_audio_format::wildcard;
+	fInput.format.u.raw_audio = media_raw_audio_format::wildcard;
-	mInput.format.u.raw_audio.format = media_raw_audio_format::B_AUDIO_FLOAT;
+	fInput.format.u.raw_audio.format = media_raw_audio_format::B_AUDIO_FLOAT;
-	mInput.format.u.raw_audio.channel_count = 1;
+	fInput.format.u.raw_audio.channel_count = 1;
-	mInput.format.u.raw_audio.frame_rate = 44100;
+	fInput.format.u.raw_audio.frame_rate = 44100;
-	mInput.format.u.raw_audio.byte_order = (B_HOST_IS_BENDIAN) ? B_MEDIA_BIG_ENDIAN : B_MEDIA_LITTLE_ENDIAN;
+	fInput.format.u.raw_audio.byte_order = B_HOST_IS_BENDIAN
-	strcpy(mInput.name, "this way in"); 
+		? B_MEDIA_BIG_ENDIAN : B_MEDIA_LITTLE_ENDIAN;
+	strcpy(fInput.name, "this way in");
 }

src/tests/kits/media/nodetest/ConsumerNode.h

@@ -2,71 +2,60 @@
 #include <BufferConsumer.h>
 #include <MediaEventLooper.h>
 
-class ConsumerNode : public virtual BBufferConsumer, BMediaEventLooper
+
-{
+class ConsumerNode : public virtual BBufferConsumer, BMediaEventLooper {
 public:
-	ConsumerNode();
+								ConsumerNode();
-	~ConsumerNode();
+	virtual						~ConsumerNode();
 
 protected:
 	/* functionality of BMediaNode */
-virtual		void NodeRegistered();
+	virtual	void				NodeRegistered();
+
 	/* BBufferConsumer */
-virtual	status_t AcceptFormat(
+	virtual	status_t			AcceptFormat(const media_destination& dest,
-				const media_destination & dest,
+									media_format* format);
-				media_format * format);
+	virtual	status_t			GetNextInput(int32* cookie,
-virtual	status_t GetNextInput(
+									media_input* _input);
-				int32 * cookie,
+	virtual	void				DisposeInputCookie(int32 cookie);
-				media_input * out_input);
+	virtual	void				BufferReceived(BBuffer* buffer);
-virtual	void DisposeInputCookie(
+	virtual	void				ProducerDataStatus(
-				int32 cookie);
+									const media_destination& forWhom,
-virtual	void BufferReceived(
+									int32 status, bigtime_t atPerformanceTime);
-				BBuffer * buffer);
+	virtual	status_t			GetLatencyFor(const media_destination& forWhom,
-virtual	void ProducerDataStatus(
+									bigtime_t* _latency,
-				const media_destination & for_whom,
+									media_node_id* _timesource);
-				int32 status,
+	virtual	status_t			Connected(const media_source& producer,
-				bigtime_t at_performance_time);
+									const media_destination& where,
-virtual	status_t GetLatencyFor(
+									const media_format& withFormat,
-				const media_destination & for_whom,
+									media_input* _input);
-				bigtime_t * out_latency,
+	virtual	void				Disconnected(const media_source& producer,
-				media_node_id * out_timesource);
+									const media_destination& where);
-virtual	status_t Connected(
+	virtual	status_t			FormatChanged(const media_source& producer,
-				const media_source & producer,
+									const media_destination& consumer,
-				const media_destination & where,
+									int32 changeTag,
-				const media_format & with_format,
+									const media_format& format);
-				media_input * out_input);
-virtual	void Disconnected(
-				const media_source & producer,
-				const media_destination & where);
-virtual	status_t FormatChanged(
-				const media_source & producer,
-				const media_destination & consumer, 
-				int32 change_tag,
-				const media_format & format);
 
-virtual status_t HandleMessage(int32 message,
+	virtual status_t			HandleMessage(int32 message,
-				const void *data, size_t size);
+									const void* data, size_t size);
 
-virtual status_t SeekTagRequested(
+	virtual status_t			SeekTagRequested(
-				const media_destination& destination,
+									const media_destination& destination,
-				bigtime_t in_target_time,
+									bigtime_t targetTime, uint32 flags,
-				uint32 in_flags,
+									media_seek_tag* _seekTag,
-				media_seek_tag* out_seek_tag,
+									bigtime_t* _taggedTime, uint32* _flags);
-				bigtime_t* out_tagged_time,
-				uint32* out_flags);
 
-/* from BMediaNode */
+	/* from BMediaNode */
-virtual	BMediaAddOn* AddOn(
+	virtual	BMediaAddOn*		AddOn(int32* internalID) const;
-				int32 * internal_id) const;
 
-/* from BMediaEventLooper */
+	/* from BMediaEventLooper */
-virtual void HandleEvent(const media_timed_event *event,
+	virtual void				HandleEvent(const media_timed_event* event,
-						 bigtime_t lateness,
+							 		bigtime_t lateness,
-						 bool realTimeEvent = false);
+							 		bool realTimeEvent = false);
 
-/* our own functionality */
+	/* our own functionality */
-void InitializeInput();
+	void InitializeInput();
 
-	media_input mInput;
+private:
-	media_format mPreferredFormat;
+	media_input fInput;
 };

src/tests/kits/media/nodetest/Jamfile

@@ -1,10 +1,12 @@
 SubDir HAIKU_TOP src tests kits media nodetest ;
 
 SimpleTest NodeTest
-	: main.cpp
+	:
-	  misc.cpp
+	main.cpp
-	  ConsumerNode.cpp
+	misc.cpp
-	  ProducerNode.cpp
+	ConsumerNode.cpp
-	: libmedia.so be root
+	ProducerNode.cpp
+
+	: be media
 ;
 

src/tests/kits/media/nodetest/ProducerNode.cpp

@@ -1,10 +1,19 @@
-#include <TimeSource.h>
-#include <BufferGroup.h>
-#include <Buffer.h>
 #include "ProducerNode.h"
+
+#include <string.h>
+
+#include <Buffer.h>
+#include <BufferGroup.h>
+#include <TimeSource.h>
+
 #include "misc.h"
 
-ProducerNode::ProducerNode() : 
+
+#define DELAY 2000000
+
+
+ProducerNode::ProducerNode()
+	:
 	BBufferProducer(B_MEDIA_RAW_AUDIO),
 	BMediaEventLooper(),
 	BMediaNode("ProducerNode"),
@@ -17,6 +26,7 @@ ProducerNode::ProducerNode() :
 	mBufferGroup = new BBufferGroup(4096,3);
 }
 
+
 ProducerNode::~ProducerNode()
 {
 	out("ProducerNode::~ProducerNode\n");
@@ -24,6 +34,7 @@ ProducerNode::~ProducerNode()
 	delete mBufferGroup;
 }
 
+
 void
 ProducerNode::NodeRegistered()
 {
@@ -35,10 +46,8 @@ ProducerNode::NodeRegistered()
 
 
 status_t
-ProducerNode::FormatSuggestionRequested(
+ProducerNode::FormatSuggestionRequested(media_type type, int32 quality,
-				media_type type,
+	media_format* format)
-				int32 quality,
-				media_format * format)
 {
 	out("ProducerNode::FormatSuggestionRequested\n");
 
@@ -54,10 +63,9 @@ ProducerNode::FormatSuggestionRequested(
 	return B_OK;
 }
 
+
 status_t
-ProducerNode::FormatProposal(
+ProducerNode::FormatProposal(const media_source& output, media_format* format)
-				const media_source & output,
-				media_format * format)
 {
 	out("ProducerNode::FormatProposal\n");
 
@@ -70,54 +78,50 @@ ProducerNode::FormatProposal(
 	return B_OK;
 }
 
+
 status_t
-ProducerNode::FormatChangeRequested(
+ProducerNode::FormatChangeRequested(const media_source& source,
-				const media_source & source,
+	const media_destination& destination, media_format* _format,
-				const media_destination & destination,
+	int32* _deprecated_)
-				media_format * io_format,
-				int32 * _deprecated_)
 {
 	out("ProducerNode::FormatChangeRequested\n");
 	return B_ERROR;
 }
 
+
 status_t
-ProducerNode::GetNextOutput(	/* cookie starts as 0 */
+ProducerNode::GetNextOutput(int32* cookie, media_output* _output)
-				int32 * cookie,
-				media_output * out_output)
 {
 	out("ProducerNode::GetNextOutput\n");
 	if (++(*cookie) > 1)
 		return B_BAD_INDEX;
 
 	mOutput.node = Node();
-	*out_output = mOutput;
+	*_output = mOutput;
 	return B_OK;
 }
 
+
 status_t
-ProducerNode::DisposeOutputCookie(
+ProducerNode::DisposeOutputCookie(int32 cookie)
-				int32 cookie)
 {
 	out("ProducerNode::DisposeOutputCookie\n");
 	return B_OK;
 }
 
-/*********************************************************
+
-* In this function, you should either pass on the group to your upstream guy,
+/*!	In this function, you should either pass on the group to your upstream guy,
-* or delete your current group and hang on to this group. Deleting the previous
+	or delete your current group and hang on to this group. Deleting the
-* group (unless you passed it on with the reclaim flag set to false) is very
+	previous group (unless you passed it on with the reclaim flag set to false)
-* important, else you will 1) leak memory and 2) block someone who may want
+	is very important, else you will 1) leak memory and 2) block someone who may
-* to reclaim the buffers living in that group.
+	want to reclaim the buffers living in that group.
 */
 status_t
-ProducerNode::SetBufferGroup(
+ProducerNode::SetBufferGroup(const media_source& forSource, BBufferGroup* group)
-				const media_source & for_source,
-				BBufferGroup * group)
 {
 	out("ProducerNode::SetBufferGroup\n");
 
-	if (for_source != mOutput.source)
+	if (forSource != mOutput.source)
 		return B_MEDIA_BAD_SOURCE;
 
 #if 0
@@ -146,34 +150,30 @@ ProducerNode::SetBufferGroup(
 	return B_ERROR;
 }
 
+
 status_t
-ProducerNode::VideoClippingChanged(
+ProducerNode::VideoClippingChanged(const media_source& forSource,
-				const media_source & for_source,
+	int16 numShorts, int16* clipData, const media_video_display_info& display,
-				int16 num_shorts,
+	int32* _deprecated_)
-				int16 * clip_data,
-				const media_video_display_info & display,
-				int32 * _deprecated_)
 {
 	out("ProducerNode::VideoClippingChanged\n");
 	return B_ERROR;
 }
 
+
 status_t
-ProducerNode::GetLatency(
+ProducerNode::GetLatency(bigtime_t* _latency)
-				bigtime_t * out_lantency)
 {
 	out("ProducerNode::GetLatency\n");
-	*out_lantency = 23000;
+	*_latency = 23000;
 	return B_OK;
 }
 
+
 status_t
-ProducerNode::PrepareToConnect(
+ProducerNode::PrepareToConnect(const media_source& what,
-				const media_source & what,
+	const media_destination& where, media_format* format, media_source* _source,
-				const media_destination & where,
+	char* _name)
-				media_format * format,
-				media_source * out_source,
-				char * out_name)
 {
 	out("ProducerNode::PrepareToConnect\n");
 
@@ -183,7 +183,7 @@ ProducerNode::PrepareToConnect(
 	if (mOutput.destination != media_destination::null)
 		return B_MEDIA_ALREADY_CONNECTED;
 
-	if (format == NULL || out_source == NULL || out_name == NULL)
+	if (format == NULL || _source == NULL || _name == NULL)
 		return B_BAD_VALUE;
 
 #if 0
@@ -201,20 +201,18 @@ ProducerNode::PrepareToConnect(
 #endif
 
 
-	*out_source = mOutput.source;
+	*_source = mOutput.source;
-	strcpy(out_name,mOutput.name);
+	strcpy(_name, mOutput.name);
 	//mOutput.destination = where; //really now? fixme
 
 	return B_OK;
 }
 
+
 void
-ProducerNode::Connect(
+ProducerNode::Connect(status_t error, const media_source& source,
-				status_t error, 
+	const media_destination& destination, const media_format& format,
-				const media_source & source,
+	char* name)
-				const media_destination & destination,
-				const media_format & format,
-				char * io_name)
 {
 	out("ProducerNode::Connect\n");
 
@@ -235,7 +233,7 @@ ProducerNode::Connect(
 		return;
 	}
 
-	strcpy(io_name,mOutput.name);
+	strcpy(name, mOutput.name);
 
 #if 0
 	trace("format (final and approved):\n");
@@ -247,10 +245,10 @@ ProducerNode::Connect(
 	return;
 }
 
+
 void
-ProducerNode::Disconnect(
+ProducerNode::Disconnect(const media_source& what,
-				const media_source & what,
+	const media_destination& where)
-				const media_destination & where)
 {
 	out("ProducerNode::Disconnect\n");
 	mOutputEnabled = false;
@@ -259,68 +257,63 @@ ProducerNode::Disconnect(
 	InitializeOutput();
 }
 
+
 void
-ProducerNode::LateNoticeReceived(
+ProducerNode::LateNoticeReceived(const media_source& what, bigtime_t howMuch,
-				const media_source & what,
+	bigtime_t performanceTime)
-				bigtime_t how_much,
-				bigtime_t performance_time)
 {
 	out("ProducerNode::LateNoticeReceived\n");
 	return;
 }
 
+
 void
-ProducerNode::EnableOutput(
+ProducerNode::EnableOutput(const media_source& what, bool enabled,
-				const media_source & what,
+	int32* _deprecated_)
-				bool enabled,
-				int32 * _deprecated_)
 {
 	out("ProducerNode::EnableOutput\n");
 	mOutputEnabled = enabled;
 	return;
 }
 
+
 BMediaAddOn*
-ProducerNode::AddOn(int32 * internal_id) const
+ProducerNode::AddOn(int32* internalID) const
 {
 	out("ProducerNode::AddOn\n");
 	return NULL;
 }
 
+
 void
-ProducerNode::HandleEvent(const media_timed_event *event,
+ProducerNode::HandleEvent(const media_timed_event* event, bigtime_t lateness,
-						 bigtime_t lateness,
+	bool realTimeEvent)
-						 bool realTimeEvent)
 {
 	out("ProducerNode::HandleEvent\n");
-	switch (event->type)
+	switch (event->type) {
-	{
+		case BTimedEventQueue::B_HANDLE_BUFFER:
-	case BTimedEventQueue::B_HANDLE_BUFFER:
-		{
 			out("B_HANDLE_BUFFER (should not happen)\n");
-		}
+			break;
-		break;
 
-	case BTimedEventQueue::B_PARAMETER:
+		case BTimedEventQueue::B_PARAMETER:
-		{
 			out("B_PARAMETER\n");
-		}
+			break;
-		break;
 
-	case BTimedEventQueue::B_START:
+		case BTimedEventQueue::B_START:
 		{
 			out("B_START\n");
 			if (mBufferProducer != -1) {
 				out("already running\n");
 				break;
 			}
-			mBufferProducerSem = create_sem(0,"producer blocking sem");
+			mBufferProducerSem = create_sem(0, "producer blocking sem");
-			mBufferProducer = spawn_thread(_bufferproducer,"Buffer Producer",B_NORMAL_PRIORITY,this);
+			mBufferProducer = spawn_thread(_bufferproducer, "Buffer Producer",
+				B_NORMAL_PRIORITY, this);
 			resume_thread(mBufferProducer);
+			break;
 		}
-		break;
 
-	case BTimedEventQueue::B_STOP:
+		case BTimedEventQueue::B_STOP:
 		{
 			out("B_STOP\n");
 			if (mBufferProducer == -1) {
@@ -332,37 +325,33 @@ ProducerNode::HandleEvent(const media_timed_event *event,
 			wait_for_thread(mBufferProducer,&err);
 			mBufferProducer = -1;
 			mBufferProducerSem = -1;
-		}
-		// stopping implies not handling any more buffers.  So, we flush all pending
-		// buffers out of the event queue before returning to the event loop.
-		EventQueue()->FlushEvents(0, BTimedEventQueue::B_ALWAYS, true, BTimedEventQueue::B_HANDLE_BUFFER);
-		break;
 
-	case BTimedEventQueue::B_SEEK:
+			// stopping implies not handling any more buffers.  So, we flush
-		{
+			// all pending buffers out of the event queue before returning to
+			// the event loop.
+			EventQueue()->FlushEvents(0, BTimedEventQueue::B_ALWAYS, true,
+				BTimedEventQueue::B_HANDLE_BUFFER);
+			break;
+		}
+
+		case BTimedEventQueue::B_SEEK:
 			out("B_SEEK\n");
-		}
+			break;
-		break;
 
-	case BTimedEventQueue::B_WARP:
+		case BTimedEventQueue::B_WARP:
-		{
 			out("B_WARP\n");
-		}
+			// similarly, time warps aren't meaningful to the logger, so just
-		// similarly, time warps aren't meaningful to the logger, so just record it and return
+			// record it and return
-		//mLogger->Log(LOG_WARP_HANDLED, logMsg);
+			//mLogger->Log(LOG_WARP_HANDLED, logMsg);
-		break;
+			break;
 
-	case BTimedEventQueue::B_DATA_STATUS:
+		case BTimedEventQueue::B_DATA_STATUS:
-		{
 			out("B_DATA_STATUS\n");
-		}
+			break;
-		break;
 
-	default:
+		default:
-		{
 			out("default\n");
-		}
+			break;
-		break;
 	}
 }
 
@@ -378,27 +367,25 @@ ProducerNode::HandleMessage(int32 message,const void *data, size_t size)
 	return BMediaNode::HandleMessage(message,data,size);
 }
 
+
 void
-ProducerNode::AdditionalBufferRequested(
+ProducerNode::AdditionalBufferRequested(const media_source& source,
-				const media_source & source,
+	media_buffer_id previousBuffer, bigtime_t previousTime,
-				media_buffer_id prev_buffer,
+	const media_seek_tag* previousTag)
-				bigtime_t prev_time,
-				const media_seek_tag * prev_tag)
 {
 	out("ProducerNode::AdditionalBufferRequested\n");
 	release_sem(mBufferProducerSem);
 }
 
+
 void
-ProducerNode::LatencyChanged(
+ProducerNode::LatencyChanged(const media_source& source,
-				const media_source & source,
+	const media_destination& destination, bigtime_t newLatency, uint32 flags)
-				const media_destination & destination,
-				bigtime_t new_latency,
-				uint32 flags)
 {
 	out("ProducerNode::LatencyChanged\n");
 }
 
+
 void
 ProducerNode::InitializeOutput()
 {
@@ -412,18 +399,19 @@ ProducerNode::InitializeOutput()
 	mOutput.format.u.raw_audio.format = media_raw_audio_format::B_AUDIO_FLOAT;
 	mOutput.format.u.raw_audio.channel_count = 1;
 	mOutput.format.u.raw_audio.frame_rate = 44100;
-	mOutput.format.u.raw_audio.byte_order = (B_HOST_IS_BENDIAN) ? B_MEDIA_BIG_ENDIAN : B_MEDIA_LITTLE_ENDIAN;
+	mOutput.format.u.raw_audio.byte_order = B_HOST_IS_BENDIAN
+		? B_MEDIA_BIG_ENDIAN : B_MEDIA_LITTLE_ENDIAN;
 	strcpy(mOutput.name, "this way out");
 }
 
+
 int32
-ProducerNode::_bufferproducer(void *arg)
+ProducerNode::_bufferproducer(void* arg)
 {
-	((ProducerNode *)arg)->BufferProducer();
+	((ProducerNode*)arg)->BufferProducer();
 	return 0;
 }
 
-#define DELAY 2000000
 
 void
 ProducerNode::BufferProducer()
@@ -434,7 +422,7 @@ ProducerNode::BufferProducer()
 
 	status_t rv;
 	for (;;) {
-		rv = acquire_sem_etc(mBufferProducerSem,1,B_RELATIVE_TIMEOUT,DELAY);
+		rv = acquire_sem_etc(mBufferProducerSem, 1, B_RELATIVE_TIMEOUT, DELAY);
 		if (rv == B_INTERRUPTED) {
 			continue;
 		} else if (rv == B_OK) {
@@ -453,7 +441,8 @@ ProducerNode::BufferProducer()
 		if (!buffer) {
 		}
 		buffer->Header()->start_time = TimeSource()->Now() + DELAY / 2;
-		out("ProducerNode: SendBuffer, sheduled time = %5.4f\n",buffer->Header()->start_time / 1E6);
+		out("ProducerNode: SendBuffer, sheduled time = %5.4f\n",
+			buffer->Header()->start_time / 1E6);
 		rv = SendBuffer(buffer, mOutput.destination);
 		if (rv != B_OK) {
 		}