code cleanup

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

headers/private/media/DataExchange.h

@@ -17,21 +17,22 @@ namespace dataexchange {
 
 struct reply_data;
 struct request_data;
+struct command_data;
 
 // BMessage based data exchange with the media_server
 status_t SendToServer(BMessage *msg);
 status_t QueryServer(BMessage *request, BMessage *reply);
 
 // Raw data based data exchange with the media_server
-status_t SendToServer(int32 msgcode, void *msg, int size);
+status_t SendToServer(int32 msgcode, command_data *msg, int size);
 status_t QueryServer(int32 msgcode, request_data *request, int requestsize, reply_data *reply, int replysize);
 
 // Raw data based data exchange with the media_addon_server
-status_t SendToAddonServer(int32 msgcode, void *msg, int size);
+status_t SendToAddonServer(int32 msgcode, command_data *msg, int size);
 status_t QueryAddonServer(int32 msgcode, request_data *request, int requestsize, reply_data *reply, int replysize);
 
 // Raw data based data exchange with the media_server
-status_t SendToPort(port_id sendport, int32 msgcode, void *msg, int size);
+status_t SendToPort(port_id sendport, int32 msgcode, command_data *msg, int size);
 status_t QueryPort(port_id requestport, int32 msgcode, request_data *request, int requestsize, reply_data *reply, int replysize);
 
 // The base struct used for all raw requests
@@ -48,6 +49,11 @@ struct reply_data
 	status_t result;
 };
 
+// The base struct used for all raw commands (asynchronous, no answer)
+struct command_data
+{
+	// yes, it's empty ;)
+};
 
 }; // dataexchange
 }; // media
@@ -140,6 +146,39 @@ enum {
 	TIMESOURECE_MESSAGE_END,
 };
 
+
+/* We can't send an entry_ref through a port to another team,
+ * but we can assign it to an xfer_entry_ref and send this one,
+ * when we receive it we can assign it to a normal entry_ref
+ */
+struct xfer_entry_ref
+{
+public:
+	xfer_entry_ref()
+		{
+			device = -1;
+			directory = -1;
+			name[0] = 0;
+		}
+	operator entry_ref() const
+		{
+			entry_ref ref(device, directory, name);
+			return ref;
+		}
+	void operator=(const entry_ref &ref)
+		{
+			device = ref.device;
+			directory = ref.directory;
+			strcpy(name, ref.name);
+		}
+private:
+	dev_t	device;
+	ino_t	directory;
+	char	name[B_FILE_NAME_LENGTH];
+};
+
+
+
 // used by SERVER_GET_NODE and SERVER_SET_NODE
 enum node_type 
 { 
@@ -251,6 +290,165 @@ struct producer_connect_reply : public reply_data
 {
 	char name[B_MEDIA_NAME_LENGTH];
 };
+
+struct producer_disconnect_request : public request_data
+{
+	media_source source;
+	media_destination destination;
+};
+
+struct producer_disconnect_reply : public reply_data
+{
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+struct producer_format_suggestion_requested_request : public request_data
+{
+	media_type type;
+	int32 quality;
+};
+
+struct producer_format_suggestion_requested_reply : public reply_data
+{
+	media_format format;
+};
+
+struct producer_set_play_rate_request : public request_data
+{
+	int32 numer;
+	int32 denom;
+};
+
+struct producer_set_play_rate_reply : public reply_data
+{
+};
+
+struct producer_get_initial_latency_request : public request_data
+{
+};
+
+struct producer_get_initial_latency_reply : public reply_data
+{
+	bigtime_t initial_latency;
+	uint32 flags;
+};
+
+struct producer_get_latency_request : public request_data
+{
+};
+
+struct producer_get_latency_reply : public reply_data
+{
+	bigtime_t latency;
+};
+
+struct producer_set_buffer_group_command : public command_data
+{
+	media_source source;
+	media_destination destination;
+	void *user_data;
+	int32 change_tag;
+	int32 buffer_count;
+	media_buffer_id buffers[1];
+};
+
+struct producer_format_change_requested_command : public command_data
+{
+	media_source source;
+	media_destination destination;
+	media_format format;
+	void *user_data;
+	int32 change_tag;
+};
+
+struct producer_video_clipping_changed_command : public command_data
+{
+	media_source source;
+	media_destination destination;
+	media_video_display_info display;
+	void *user_data;
+	int32 change_tag;
+	int32 short_count;
+	int16 shorts[1];
+};
+
+struct producer_additional_buffer_requested_command : public command_data
+{
+	media_source source;
+	media_buffer_id prev_buffer;
+	bigtime_t prev_time;
+	bool has_seek_tag;
+	media_seek_tag prev_tag;
+};
+
+struct producer_latency_changed_command : public command_data
+{
+	media_source source;
+	media_destination destination;
+	bigtime_t latency;
+	uint32 flags;
+};
+
+struct producer_enable_output_command : public command_data
+{
+	media_source source;
+	media_destination destination;
+	bool enabled;
+	void *user_data;
+	int32 change_tag;
+};
+
+struct producer_late_notice_received_command : public command_data
+{
+	media_source source;
+	bigtime_t how_much;
+	bigtime_t performance_time;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 struct consumer_accept_format_request : public request_data
 {
@@ -353,16 +551,88 @@ struct consumer_disconnected_reply : public reply_data
 {
 };
 
-struct producer_disconnect_request : public request_data
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+struct consumer_buffer_received_command : public command_data
 {
-	media_source source;
+	media_buffer_id buffer;
-	media_destination destination;
+	media_header header;
 };
 
-struct producer_disconnect_reply : public reply_data
+struct consumer_producer_data_status_command : public command_data
+{
+	media_destination for_whom;
+	int32 status;
+	bigtime_t at_performance_time;
+};
+
+struct consumer_get_latency_for_request : public request_data
+{
+	media_destination for_whom;
+};
+
+struct consumer_get_latency_for_reply : public reply_data
+{
+	bigtime_t latency;
+	media_node_id timesource;
+};
+
+struct consumer_format_changed_request : public request_data
+{
+	media_source producer;
+	media_destination consumer;
+	int32 change_tag;
+	media_format format;
+};
+
+struct consumer_format_changed_reply : public reply_data
 {
 };
 
+struct consumer_seek_tag_requested_request : public request_data
+{
+	media_destination destination;
+	bigtime_t target_time;
+	uint32 flags;
+};
+
+struct consumer_seek_tag_requested_reply : public reply_data
+{
+	media_seek_tag seek_tag;
+	bigtime_t tagged_time;
+	uint32 flags;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 struct server_register_node_request : public request_data
 {
 	media_addon_id addon_id;
@@ -474,4 +744,89 @@ struct server_get_instances_for_reply : public reply_data
 };
 
 
+
+
+
+
+
+struct addonserver_rescan_mediaaddon_flavors_command : public command_data
+{
+	media_addon_id addonid;
+};
+
+struct server_register_mediaaddon_request : public request_data
+{
+	xfer_entry_ref	ref; // a ref to the file
+};
+
+struct server_register_mediaaddon_reply : public reply_data
+{
+	media_addon_id addonid;
+};
+
+struct server_unregister_mediaaddon_command : public command_data
+{
+	media_addon_id addonid;
+};
+
+struct server_get_mediaaddon_ref_request : public request_data
+{
+	media_addon_id addonid;
+};
+
+struct server_get_mediaaddon_ref_reply : public reply_data
+{
+	xfer_entry_ref	ref; // a ref to the file
+};
+
+
+
+
+
+
+
+
+
+
+struct node_request_completed_command : public command_data
+{
+	media_request_info info;
+};
+
+struct node_start_command : public command_data
+{
+	bigtime_t performance_time;	
+};
+
+struct node_stop_command : public command_data
+{
+	bigtime_t performance_time;	
+	bool immediate;
+};
+
+struct node_seek_command : public command_data
+{
+	bigtime_t media_time;
+	bigtime_t performance_time;
+};
+
+struct node_set_run_mode_command : public command_data
+{
+	BMediaNode::run_mode mode;
+};
+
+struct node_time_warp_command : public command_data
+{
+	bigtime_t at_real_time;
+	bigtime_t to_performance_time;
+};
+
+struct node_set_timesource_command : public command_data
+{
+	media_node_id timesource_id;
+};
+
+
+
+
 #endif // _DATA_EXCHANGE_H

src/kits/media/BufferConsumer.cpp

@@ -11,7 +11,6 @@
 #define DEBUG 3
 #include "debug.h"
 #include "DataExchange.h"
-#include "ServerInterface.h"
 #include "BufferIdCache.h"
 
 /*************************************************************
@@ -52,7 +51,7 @@ BBufferConsumer::RegionToClipData(const BRegion *region,
 	int count;
 
 	count = *ioSize / sizeof(int16);
-	rv = BBufferProducer::clip_region_to_shorts(region, (int16 *)data, count, &count);
+	rv = BBufferProducer::clip_region_to_shorts(region, static_cast<int16 *>(data), count, &count);
 	*ioSize	= count * sizeof(int16);
 	*format = BBufferProducer::B_CLIP_SHORT_RUNS;
 	
@@ -85,12 +84,12 @@ BBufferConsumer::NotifyLateProducer(const media_source &what_source,
 	if (what_source == media_source::null)
 		return;
 
-	xfer_producer_late_notice_received request;
+	producer_late_notice_received_command command;
-	request.source = what_source;
+	command.source = what_source;
-	request.how_much = how_much;
+	command.how_much = how_much;
-	request.performance_time = performance_time;
+	command.performance_time = performance_time;
 	
-	write_port(what_source.port, PRODUCER_LATE_NOTICE_RECEIVED, &request, sizeof(request));
+	SendToPort(what_source.port, PRODUCER_LATE_NOTICE_RECEIVED, &command, sizeof(command));
 }
 
 
@@ -109,27 +108,27 @@ BBufferConsumer::SetVideoClippingFor(const media_source &output,
 		return B_MEDIA_BAD_SOURCE;
 	if (destination == media_destination::null)
 		return B_MEDIA_BAD_DESTINATION;
-	if (short_count > int(B_MEDIA_MESSAGE_SIZE - sizeof(xfer_producer_video_clipping_changed)) / 2)
+	if (short_count > int(B_MEDIA_MESSAGE_SIZE - sizeof(producer_video_clipping_changed_command)) / 2)
 		debugger("BBufferConsumer::SetVideoClippingFor short_count too large (8000 limit)\n");
 		
-	xfer_producer_video_clipping_changed *request;
+	producer_video_clipping_changed_command *command;
 	size_t size;
 	status_t rv;
 
-	size = sizeof(xfer_producer_video_clipping_changed) + short_count * 2;
+	size = sizeof(producer_video_clipping_changed_command) + short_count * sizeof(short);
-	request = (xfer_producer_video_clipping_changed *) malloc(size);
+	command = static_cast<producer_video_clipping_changed_command *>(malloc(size));
-	request->source = output;
+	command->source = output;
-	request->destination = destination;
+	command->destination = destination;
-	request->display = display;
+	command->display = display;
-	request->user_data = user_data;
+	command->user_data = user_data;
-	request->change_tag = NewChangeTag();
+	command->change_tag = NewChangeTag();
-	request->short_count = short_count;
+	command->short_count = short_count;
-	memcpy(request->shorts, shorts, short_count * 2);
+	memcpy(command->shorts, shorts, short_count * sizeof(short));
 	if (change_tag != NULL)
-		*change_tag = request->change_tag;
+		*change_tag = command->change_tag;
 	
-	rv = write_port(output.port, PRODUCER_VIDEO_CLIPPING_CHANGED, request, size);
+	rv = SendToPort(output.port, PRODUCER_VIDEO_CLIPPING_CHANGED, command, size);
-	free(request);
+	free(command);
 	return rv;
 }
 
@@ -148,17 +147,17 @@ BBufferConsumer::SetOutputEnabled(const media_source &source,
 	if (source == media_source::null)
 		return B_MEDIA_BAD_SOURCE;
 
-	xfer_producer_enable_output request;
+	producer_enable_output_command command;
 	
-	request.source = source;
+	command.source = source;
-	request.destination = destination;
+	command.destination = destination;
-	request.enabled = enabled;
+	command.enabled = enabled;
-	request.user_data = user_data;
+	command.user_data = user_data;
-	request.change_tag = NewChangeTag();
+	command.change_tag = NewChangeTag();
 	if (change_tag != NULL)
-		*change_tag = request.change_tag;
+		*change_tag = command.change_tag;
 	
-	return write_port(source.port, PRODUCER_ENABLE_OUTPUT, &request, sizeof(request));
+	return SendToPort(source.port, PRODUCER_ENABLE_OUTPUT, &command, sizeof(command));
 }
 
 
@@ -176,17 +175,17 @@ BBufferConsumer::RequestFormatChange(const media_source &source,
 	if (source == media_source::null)
 		return B_MEDIA_BAD_SOURCE;
 
-	xfer_producer_format_change_requested request;
+	producer_format_change_requested_command command;
 	
-	request.source = source;
+	command.source = source;
-	request.destination = destination;
+	command.destination = destination;
-	request.format = to_format;
+	command.format = to_format;
-	request.user_data = user_data;
+	command.user_data = user_data;
-	request.change_tag = NewChangeTag();
+	command.change_tag = NewChangeTag();
 	if (change_tag != NULL)
-		*change_tag = request.change_tag;
+		*change_tag = command.change_tag;
 	
-	return write_port(source.port, PRODUCER_FORMAT_CHANGE_REQUESTED, &request, sizeof(request));
+	return SendToPort(source.port, PRODUCER_FORMAT_CHANGE_REQUESTED, &command, sizeof(command));
 }
 
 
@@ -199,15 +198,15 @@ BBufferConsumer::RequestAdditionalBuffer(const media_source &source,
 	if (source == media_source::null)
 		return B_MEDIA_BAD_SOURCE;
 
-	xfer_producer_additional_buffer_requested request;
+	producer_additional_buffer_requested_command command;
 	
-	request.source = source;
+	command.source = source;
-	request.prev_buffer = prev_buffer->ID();
+	command.prev_buffer = prev_buffer->ID();
-	request.prev_time = 0;
+	command.prev_time = 0;
-	request.has_seek_tag = false;
+	command.has_seek_tag = false;
-	//request.prev_tag = 
+	//command.prev_tag = 
 	
-	return write_port(source.port, PRODUCER_ADDITIONAL_BUFFER_REQUESTED, &request, sizeof(request));
+	return SendToPort(source.port, PRODUCER_ADDITIONAL_BUFFER_REQUESTED, &command, sizeof(command));
 }
 
 
@@ -220,15 +219,15 @@ BBufferConsumer::RequestAdditionalBuffer(const media_source &source,
 	if (source == media_source::null)
 		return B_MEDIA_BAD_SOURCE;
 
-	xfer_producer_additional_buffer_requested request;
+	producer_additional_buffer_requested_command command;
 	
-	request.source = source;
+	command.source = source;
-	request.prev_buffer = 0;
+	command.prev_buffer = 0;
-	request.prev_time = start_time;
+	command.prev_time = start_time;
-	request.has_seek_tag = false;
+	command.has_seek_tag = false;
-	//request.prev_tag = 
+	//command.prev_tag = 
 	
-	return write_port(source.port, PRODUCER_ADDITIONAL_BUFFER_REQUESTED, &request, sizeof(request));
+	return SendToPort(source.port, PRODUCER_ADDITIONAL_BUFFER_REQUESTED, &command, sizeof(command));
 }
 
 
@@ -248,7 +247,7 @@ BBufferConsumer::SetOutputBuffersFor(const media_source &source,
 	if (destination == media_destination::null)
 		return B_MEDIA_BAD_DESTINATION;
 	
-	xfer_producer_set_buffer_group *request;
+	producer_set_buffer_group_command *command;
 	BBuffer **buffers;
 	int32 buffer_count;	
 	size_t size;
@@ -264,31 +263,33 @@ BBufferConsumer::SetOutputBuffersFor(const media_source &source,
 	if (buffer_count != 0) {	
 		buffers = new BBuffer * [buffer_count];
 		if (B_OK != group->GetBufferList(buffer_count, buffers)) {
-			delete buffers;
+			delete [] buffers;
 			return B_ERROR;
 		}
 	} else {
 		buffers = NULL;
 	}
 
-	size = sizeof(xfer_producer_set_buffer_group) + buffer_count * sizeof(media_buffer_id);
+	size = sizeof(producer_set_buffer_group_command) + buffer_count * sizeof(media_buffer_id);
-	request = (xfer_producer_set_buffer_group *) malloc(size);
+	command = static_cast<producer_set_buffer_group_command *>(malloc(size));
-	request->source = source;
+	command->source = source;
-	request->destination = destination;
+	command->destination = destination;
-	request->user_data = user_data;
+	command->user_data = user_data;
-	request->change_tag = NewChangeTag();
+	command->change_tag = NewChangeTag();
-	request->buffer_count = buffer_count;
+	command->buffer_count = buffer_count;
 	for (int32 i = 0; i < buffer_count; i++)
-		request->buffers[i] = buffers[i]->ID();
+		command->buffers[i] = buffers[i]->ID();
-	if (change_tag != NULL)
-		*change_tag = request->change_tag;
 
-	rv = write_port(source.port, PRODUCER_SET_BUFFER_GROUP, request, size);
-	free(request);
 	delete [] buffers;
 
+	if (change_tag != NULL)
+		*change_tag = command->change_tag;
+	
+	rv = SendToPort(source.port, PRODUCER_SET_BUFFER_GROUP, command, size);
+	free(command);
+
 	if (rv == B_OK) {	
-		if (fDeleteBufferGroup)
+		if (fDeleteBufferGroup) // XXX will leak memory if port write failed
 			delete fDeleteBufferGroup;
 		fDeleteBufferGroup = will_reclaim ? group : NULL;
 	}
@@ -308,14 +309,14 @@ BBufferConsumer::SendLatencyChange(const media_source &source,
 	if (source == media_source::null)
 		return B_MEDIA_BAD_SOURCE;
 
-	xfer_producer_latency_changed request;
+	producer_latency_changed_command command;
 	
-	request.source = source;
+	command.source = source;
-	request.destination = destination;
+	command.destination = destination;
-	request.latency = my_new_latency;
+	command.latency = my_new_latency;
-	request.flags = flags;
+	command.flags = flags;
 	
-	return write_port(source.port, PRODUCER_LATENCY_CHANGED, &request, sizeof(request));
+	return SendToPort(source.port, PRODUCER_LATENCY_CHANGED, &command, sizeof(command));
 }
 
 /*************************************************************
@@ -324,16 +325,15 @@ BBufferConsumer::SendLatencyChange(const media_source &source,
 
 /* virtual */ status_t
 BBufferConsumer::HandleMessage(int32 message,
-							   const void *rawdata,
+							   const void *data,
 							   size_t size)
 {
-//	CALLED();
 	TRACE("BBufferConsumer::HandleMessage %#lx, node %ld\n", message, ID());
 	status_t rv;
 	switch (message) {
 		case CONSUMER_ACCEPT_FORMAT:
 		{
-			const consumer_accept_format_request *request = (const consumer_accept_format_request *)rawdata;
+			const consumer_accept_format_request *request = static_cast<const consumer_accept_format_request *>(data);
 			consumer_accept_format_reply reply;
 			reply.format = request->format;
 			rv = AcceptFormat(request->dest, &reply.format);
@@ -343,7 +343,7 @@ BBufferConsumer::HandleMessage(int32 message,
 
 		case CONSUMER_GET_NEXT_INPUT:
 		{
-			const consumer_get_next_input_request *request = (const consumer_get_next_input_request *)rawdata;
+			const consumer_get_next_input_request *request = static_cast<const consumer_get_next_input_request *>(data);
 			consumer_get_next_input_reply reply;
 			reply.cookie = request->cookie;
 			rv = GetNextInput(&reply.cookie, &reply.input);
@@ -353,7 +353,7 @@ BBufferConsumer::HandleMessage(int32 message,
 
 		case CONSUMER_DISPOSE_INPUT_COOKIE:
 		{
-			const consumer_dispose_input_cookie_request *request = (const consumer_dispose_input_cookie_request *)rawdata;
+			const consumer_dispose_input_cookie_request *request = static_cast<const consumer_dispose_input_cookie_request *>(data);
 			consumer_dispose_input_cookie_reply reply;
 			DisposeInputCookie(request->cookie);
 			request->SendReply(B_OK, &reply, sizeof(reply));
@@ -362,33 +362,33 @@ BBufferConsumer::HandleMessage(int32 message,
 
 		case CONSUMER_BUFFER_RECEIVED:
 		{
-			const xfer_consumer_buffer_received *request = (const xfer_consumer_buffer_received *)rawdata;
+			const consumer_buffer_received_command *command = static_cast<const consumer_buffer_received_command *>(data);
 			BBuffer *buffer;
-			buffer = fBufferCache->GetBuffer(request->buffer);
+			buffer = fBufferCache->GetBuffer(command->buffer);
-			buffer->SetHeader(&request->header);
+			buffer->SetHeader(&command->header);
 			BufferReceived(buffer);
 			return B_OK;
 		}
 
 		case CONSUMER_PRODUCER_DATA_STATUS:
 		{
-			const xfer_consumer_producer_data_status *request = (const xfer_consumer_producer_data_status *)rawdata;
+			const consumer_producer_data_status_command *command = static_cast<const consumer_producer_data_status_command *>(data);
-			ProducerDataStatus(request->for_whom, request->status, request->at_performance_time);
+			ProducerDataStatus(command->for_whom, command->status, command->at_performance_time);
 			return B_OK;
 		}
 
 		case CONSUMER_GET_LATENCY_FOR:
 		{
-			const xfer_consumer_get_latency_for *request = (const xfer_consumer_get_latency_for *)rawdata;
+			const consumer_get_latency_for_request *request = static_cast<const consumer_get_latency_for_request *>(data);
-			xfer_consumer_get_latency_for_reply reply;
+			consumer_get_latency_for_reply reply;
-			reply.result = GetLatencyFor(request->for_whom, &reply.latency, &reply.timesource);
+			rv = GetLatencyFor(request->for_whom, &reply.latency, &reply.timesource);
-			write_port(request->reply_port, 0, &reply, sizeof(reply));
+			request->SendReply(rv, &reply, sizeof(reply));
 			return B_OK;
 		}
 
 		case CONSUMER_CONNECTED:
 		{
-			const consumer_connected_request *request = (const consumer_connected_request *)rawdata;
+			const consumer_connected_request *request = static_cast<const consumer_connected_request *>(data);
 			consumer_connected_reply reply;
 			rv = Connected(request->producer, request->where, request->with_format, &reply.input);
 			request->SendReply(rv, &reply, sizeof(reply));
@@ -397,7 +397,7 @@ BBufferConsumer::HandleMessage(int32 message,
 				
 		case CONSUMER_DISCONNECTED:
 		{
-			const consumer_disconnected_request *request = (const consumer_disconnected_request *)rawdata;
+			const consumer_disconnected_request *request = static_cast<const consumer_disconnected_request *>(data);
 			consumer_disconnected_reply reply;
 			Disconnected(request->source, request->destination);
 			request->SendReply(B_OK, &reply, sizeof(reply));
@@ -406,31 +406,31 @@ BBufferConsumer::HandleMessage(int32 message,
 
 		case CONSUMER_FORMAT_CHANGED:
 		{
-			const xfer_consumer_format_changed *request = (const xfer_consumer_format_changed *)rawdata;
+			const consumer_format_changed_request *request = static_cast<const consumer_format_changed_request *>(data);
-			xfer_consumer_format_changed_reply reply;
+			consumer_format_changed_reply reply;
-			reply.result = FormatChanged(request->producer, request->consumer, request->change_tag, request->format);
+			rv = FormatChanged(request->producer, request->consumer, request->change_tag, request->format);
-			write_port(request->reply_port, 0, &reply, sizeof(reply));
+			request->SendReply(rv, &reply, sizeof(reply));
 
 			// XXX is this RequestCompleted() correct?
-			xfer_node_request_completed completed;
+			node_request_completed_command completedcommand;
-			completed.info.what = media_request_info::B_FORMAT_CHANGED;
+			completedcommand.info.what = media_request_info::B_FORMAT_CHANGED;
-			completed.info.change_tag = request->change_tag;
+			completedcommand.info.change_tag = request->change_tag;
-			completed.info.status = reply.result;
+			completedcommand.info.status = reply.result;
-			//completed.info.cookie
+			//completedcommand.info.cookie
-			completed.info.user_data = 0;
+			completedcommand.info.user_data = 0;
-			completed.info.source = request->producer;
+			completedcommand.info.source = request->producer;
-			completed.info.destination = request->consumer;
+			completedcommand.info.destination = request->consumer;
-			completed.info.format = request->format;
+			completedcommand.info.format = request->format;
-			write_port(request->consumer.port, NODE_REQUEST_COMPLETED, &completed, sizeof(completed));
+			SendToPort(request->consumer.port, NODE_REQUEST_COMPLETED, &completedcommand, sizeof(completedcommand));
 			return B_OK;
 		}
 
 		case CONSUMER_SEEK_TAG_REQUESTED:
 		{
-			const xfer_consumer_seek_tag_requested *request = (const xfer_consumer_seek_tag_requested *)rawdata;
+			const consumer_seek_tag_requested_request *request = static_cast<const consumer_seek_tag_requested_request *>(data);
-			xfer_consumer_seek_tag_requested_reply reply;
+			consumer_seek_tag_requested_reply reply;
-			reply.result = SeekTagRequested(request->destination, request->target_time, request->flags, &reply.seek_tag, &reply.tagged_time, &reply.flags);
+			rv = SeekTagRequested(request->destination, request->target_time, request->flags, &reply.seek_tag, &reply.tagged_time, &reply.flags);
-			write_port(request->reply_port, 0, &reply, sizeof(reply));
+			request->SendReply(rv, &reply, sizeof(reply));
 			return B_OK;
 		}
 
@@ -473,27 +473,27 @@ BBufferConsumer::SetVideoClippingFor(const media_source &output,
 	CALLED();
 	if (output == media_source::null)
 		return B_MEDIA_BAD_SOURCE;
-	if (short_count > int(B_MEDIA_MESSAGE_SIZE - sizeof(xfer_producer_video_clipping_changed)) / 2)
+	if (short_count > int(B_MEDIA_MESSAGE_SIZE - sizeof(producer_video_clipping_changed_command)) / 2)
 		debugger("BBufferConsumer::SetVideoClippingFor short_count too large (8000 limit)\n");
 		
-	xfer_producer_video_clipping_changed *request;
+	producer_video_clipping_changed_command *command;
 	size_t size;
 	status_t rv;
 
-	size = sizeof(xfer_producer_video_clipping_changed) + short_count * 2;
+	size = sizeof(producer_video_clipping_changed_command) + short_count * sizeof(short);
-	request = (xfer_producer_video_clipping_changed *) malloc(size);
+	command = static_cast<producer_video_clipping_changed_command *>(malloc(size));
-	request->source = output;
+	command->source = output;
-	request->destination = media_destination::null;
+	command->destination = media_destination::null;
-	request->display = display;
+	command->display = display;
-	request->user_data = 0;
+	command->user_data = 0;
-	request->change_tag = NewChangeTag();
+	command->change_tag = NewChangeTag();
-	request->short_count = short_count;
+	command->short_count = short_count;
-	memcpy(request->shorts, shorts, short_count * 2);
+	memcpy(command->shorts, shorts, short_count * sizeof(short));
 	if (change_tag != NULL)
-		*change_tag = request->change_tag;
+		*change_tag = command->change_tag;
 	
-	rv = write_port(output.port, PRODUCER_VIDEO_CLIPPING_CHANGED, request, size);
+	rv = SendToPort(output.port, PRODUCER_VIDEO_CLIPPING_CHANGED, command, size);
-	free(request);
+	free(command);
 	return rv;
 }
 
@@ -511,17 +511,17 @@ BBufferConsumer::RequestFormatChange(const media_source &source,
 	if (source == media_source::null)
 		return B_MEDIA_BAD_SOURCE;
 
-	xfer_producer_format_change_requested request;
+	producer_format_change_requested_command command;
 	
-	request.source = source;
+	command.source = source;
-	request.destination = destination;
+	command.destination = destination;
-	request.format = *in_to_format;
+	command.format = *in_to_format;
-	request.user_data = 0;
+	command.user_data = 0;
-	request.change_tag = NewChangeTag();
+	command.change_tag = NewChangeTag();
 	if (change_tag != NULL)
-		*change_tag = request.change_tag;
+		*change_tag = command.change_tag;
 	
-	return write_port(source.port, PRODUCER_FORMAT_CHANGE_REQUESTED, &request, sizeof(request));
+	return SendToPort(source.port, PRODUCER_FORMAT_CHANGE_REQUESTED, &command, sizeof(command));
 }
 
 
@@ -535,17 +535,17 @@ BBufferConsumer::SetOutputEnabled(const media_source &source,
 	if (source == media_source::null)
 		return B_MEDIA_BAD_SOURCE;
 
-	xfer_producer_enable_output request;
+	producer_enable_output_command command;
 	
-	request.source = source;
+	command.source = source;
-	request.destination = media_destination::null;
+	command.destination = media_destination::null;
-	request.enabled = enabled;
+	command.enabled = enabled;
-	request.user_data = 0;
+	command.user_data = 0;
-	request.change_tag = NewChangeTag();
+	command.change_tag = NewChangeTag();
 	if (change_tag != NULL)
-		*change_tag = request.change_tag;
+		*change_tag = command.change_tag;
 	
-	return write_port(source.port, PRODUCER_ENABLE_OUTPUT, &request, sizeof(request));
+	return SendToPort(source.port, PRODUCER_ENABLE_OUTPUT, &command, sizeof(command));
 }
 
 

src/kits/media/BufferProducer.cpp

@@ -8,9 +8,7 @@
 #include <Buffer.h>
 #define DEBUG 3
 #include "debug.h"
-#include "PortPool.h"
 #include "DataExchange.h"
-#include "ServerInterface.h"
 
 /*************************************************************
  * protected BBufferProducer
@@ -101,26 +99,25 @@ BBufferProducer::SetPlayRate(int32 numer,
 		
 status_t
 BBufferProducer::HandleMessage(int32 message,
-							   const void *rawdata,
+							   const void *data,
 							   size_t size)
 {
-//	CALLED();
 	TRACE("BBufferProducer::HandleMessage %#lx, node %ld\n", message, fNodeID);
 	status_t rv;
 	switch (message) {
 
 		case PRODUCER_FORMAT_SUGGESTION_REQUESTED:
 		{
-			const xfer_producer_format_suggestion_requested *request = (const xfer_producer_format_suggestion_requested *)rawdata;
+			const producer_format_suggestion_requested_request *request = static_cast<const producer_format_suggestion_requested_request *>(data);
-			xfer_producer_format_suggestion_requested_reply reply;
+			producer_format_suggestion_requested_reply reply;
-			reply.result = FormatSuggestionRequested(request->type, request->quality, &reply.format);
+			rv = FormatSuggestionRequested(request->type, request->quality, &reply.format);
-			write_port(request->reply_port, 0, &reply, sizeof(reply));
+			request->SendReply(rv, &reply, sizeof(reply));
 			return B_OK;
 		}
 
 		case PRODUCER_FORMAT_PROPOSAL:
 		{
-			const producer_format_proposal_request *request = (const producer_format_proposal_request *)rawdata;
+			const producer_format_proposal_request *request = static_cast<const producer_format_proposal_request *>(data);
 			producer_format_proposal_reply reply;
 			reply.format = request->format;
 			rv = FormatProposal(request->output, &reply.format);
@@ -130,7 +127,7 @@ BBufferProducer::HandleMessage(int32 message,
 
 		case PRODUCER_PREPARE_TO_CONNECT:
 		{
-			const producer_prepare_to_connect_request *request = (const producer_prepare_to_connect_request *)rawdata;
+			const producer_prepare_to_connect_request *request = static_cast<const producer_prepare_to_connect_request *>(data);
 			producer_prepare_to_connect_reply reply;
 			reply.format = request->format;
 			memcpy(reply.name, request->name, B_MEDIA_NAME_LENGTH);
@@ -141,7 +138,7 @@ BBufferProducer::HandleMessage(int32 message,
 
 		case PRODUCER_CONNECT:
 		{
-			const producer_connect_request *request = (const producer_connect_request *)rawdata;
+			const producer_connect_request *request = static_cast<const producer_connect_request *>(data);
 			producer_connect_reply reply;
 			memcpy(reply.name, request->name, B_MEDIA_NAME_LENGTH);
 			Connect(request->error, request->source, request->destination, request->format, reply.name);
@@ -151,7 +148,7 @@ BBufferProducer::HandleMessage(int32 message,
 
 		case PRODUCER_DISCONNECT:
 		{
-			const producer_disconnect_request *request = (const producer_disconnect_request *)rawdata;
+			const producer_disconnect_request *request = static_cast<const producer_disconnect_request *>(data);
 			producer_disconnect_reply reply;
 			Disconnect(request->source, request->destination);
 			request->SendReply(B_OK, &reply, sizeof(reply));
@@ -160,35 +157,35 @@ BBufferProducer::HandleMessage(int32 message,
 
 		case PRODUCER_GET_INITIAL_LATENCY:
 		{
-			const xfer_producer_get_initial_latency *request = (const xfer_producer_get_initial_latency *)rawdata;
+			const producer_get_initial_latency_request *request = static_cast<const producer_get_initial_latency_request *>(data);
-			xfer_producer_get_initial_latency_reply reply;
+			producer_get_initial_latency_reply reply;
 			reply.initial_latency = fInitialLatency;
 			reply.flags = fInitialFlags;
-			write_port(request->reply_port, 0, &reply, sizeof(reply));
+			request->SendReply(B_OK, &reply, sizeof(reply));
 			return B_OK;
 		}
 
 		case PRODUCER_SET_PLAY_RATE:
 		{
-			const xfer_producer_set_play_rate *request = (const xfer_producer_set_play_rate *)rawdata;
+			const producer_set_play_rate_request *request = static_cast<const producer_set_play_rate_request *>(data);
-			xfer_producer_set_play_rate_reply reply;
+			producer_set_play_rate_reply reply;
-			reply.result = SetPlayRate(request->numer, request->denom);
+			rv = SetPlayRate(request->numer, request->denom);
-			write_port(request->reply_port, 0, &reply, sizeof(reply));
+			request->SendReply(rv, &reply, sizeof(reply));
 			return B_OK;
 		}
 
 		case PRODUCER_GET_LATENCY:
 		{
-			const xfer_producer_get_latency *request = (const xfer_producer_get_latency *)rawdata;
+			const producer_get_latency_request *request = static_cast<const producer_get_latency_request *>(data);
-			xfer_producer_get_latency_reply reply;
+			producer_get_latency_reply reply;
-			reply.result = GetLatency(&reply.latency);
+			rv = GetLatency(&reply.latency);
-			write_port(request->reply_port, 0, &reply, sizeof(reply));
+			request->SendReply(rv, &reply, sizeof(reply));
 			return B_OK;
 		}
 
 		case PRODUCER_GET_NEXT_OUTPUT:
 		{
-			const producer_get_next_output_request *request = (const producer_get_next_output_request *)rawdata;
+			const producer_get_next_output_request *request = static_cast<const producer_get_next_output_request *>(data);
 			producer_get_next_output_reply reply;
 			reply.cookie = request->cookie;
 			rv = GetNextOutput(&reply.cookie, &reply.output);
@@ -198,7 +195,7 @@ BBufferProducer::HandleMessage(int32 message,
 
 		case PRODUCER_DISPOSE_OUTPUT_COOKIE:
 		{
-			const producer_dispose_output_cookie_request *request = (const producer_dispose_output_cookie_request *)rawdata;
+			const producer_dispose_output_cookie_request *request = static_cast<const producer_dispose_output_cookie_request *>(data);
 			producer_dispose_output_cookie_reply reply;
 			DisposeOutputCookie(request->cookie);
 			request->SendReply(B_OK, &reply, sizeof(reply));
@@ -207,104 +204,101 @@ BBufferProducer::HandleMessage(int32 message,
 
 		case PRODUCER_SET_BUFFER_GROUP:
 		{
-			const xfer_producer_set_buffer_group *request = (const xfer_producer_set_buffer_group *)rawdata;
+			const producer_set_buffer_group_command *command = static_cast<const producer_set_buffer_group_command *>(data);
-			xfer_node_request_completed reply;
+			node_request_completed_command replycommand;
 			BBufferGroup *group;
-			status_t rv;
+			group = command->buffer_count != 0 ? new BBufferGroup(command->buffer_count, command->buffers) : NULL;
-			group = request->buffer_count != 0 ? new BBufferGroup(request->buffer_count, request->buffers) : NULL;
+			rv = SetBufferGroup(command->source, group);
-			rv = SetBufferGroup(request->source, group);
+			if (command->destination == media_destination::null)
-			if (request->destination == media_destination::null)
 				return B_OK;
-			reply.info.what = media_request_info::B_SET_OUTPUT_BUFFERS_FOR;
+			replycommand.info.what = media_request_info::B_SET_OUTPUT_BUFFERS_FOR;
-			reply.info.change_tag = request->change_tag;
+			replycommand.info.change_tag = command->change_tag;
-			reply.info.status = rv;
+			replycommand.info.status = rv;
-			reply.info.cookie = (int32)group;
+			replycommand.info.cookie = (int32)group;
-			reply.info.user_data = request->user_data;
+			replycommand.info.user_data = command->user_data;
-			reply.info.source = request->source;
+			replycommand.info.source = command->source;
-			reply.info.destination = request->destination;
+			replycommand.info.destination = command->destination;
-			write_port(request->destination.port, NODE_REQUEST_COMPLETED, &reply, sizeof(reply));
+			SendToPort(command->destination.port, NODE_REQUEST_COMPLETED, &replycommand, sizeof(replycommand));
 			return B_OK;
 		}
 
 		case PRODUCER_FORMAT_CHANGE_REQUESTED:
 		{
-			const xfer_producer_format_change_requested *request = (const xfer_producer_format_change_requested *)rawdata;
+			const producer_format_change_requested_command *command = static_cast<const producer_format_change_requested_command *>(data);
-			xfer_node_request_completed reply;
+			node_request_completed_command replycommand;
-			status_t rv;
+			replycommand.info.format = command->format;
-			reply.info.format = request->format;
+			rv = FormatChangeRequested(command->source, command->destination, &replycommand.info.format, NULL);
-			rv = FormatChangeRequested(request->source, request->destination, &reply.info.format, NULL);
+			if (command->destination == media_destination::null)
-			if (request->destination == media_destination::null)
 				return B_OK;
-			reply.info.what = media_request_info::B_REQUEST_FORMAT_CHANGE;
+			replycommand.info.what = media_request_info::B_REQUEST_FORMAT_CHANGE;
-			reply.info.change_tag = request->change_tag;
+			replycommand.info.change_tag = command->change_tag;
-			reply.info.status = rv;
+			replycommand.info.status = rv;
-			//reply.info.cookie
+			//replycommand.info.cookie
-			reply.info.user_data = request->user_data;
+			replycommand.info.user_data = command->user_data;
-			reply.info.source = request->source;
+			replycommand.info.source = command->source;
-			reply.info.destination = request->destination;
+			replycommand.info.destination = command->destination;
-			write_port(request->destination.port, NODE_REQUEST_COMPLETED, &reply, sizeof(reply));
+			SendToPort(command->destination.port, NODE_REQUEST_COMPLETED, &replycommand, sizeof(replycommand));
 			return B_OK;
 		}
 
 
 		case PRODUCER_VIDEO_CLIPPING_CHANGED:
 		{
-			const xfer_producer_video_clipping_changed *request = (const xfer_producer_video_clipping_changed *)rawdata;
+			const producer_video_clipping_changed_command *command = static_cast<const producer_video_clipping_changed_command *>(data);
-			xfer_node_request_completed reply;
+			node_request_completed_command replycommand;
-			status_t rv;
+			rv = VideoClippingChanged(command->source, command->short_count, (int16 *)command->shorts, command->display, NULL);
-			rv = VideoClippingChanged(request->source, request->short_count, (int16 *)request->shorts, request->display, NULL);
+			if (command->destination == media_destination::null)
-			if (request->destination == media_destination::null)
 				return B_OK;
-			reply.info.what = media_request_info::B_SET_VIDEO_CLIPPING_FOR;
+			replycommand.info.what = media_request_info::B_SET_VIDEO_CLIPPING_FOR;
-			reply.info.change_tag = request->change_tag;
+			replycommand.info.change_tag = command->change_tag;
-			reply.info.status = rv;
+			replycommand.info.status = rv;
-			//reply.info.cookie
+			//replycommand.info.cookie
-			reply.info.user_data = request->user_data;
+			replycommand.info.user_data = command->user_data;
-			reply.info.source = request->source;
+			replycommand.info.source = command->source;
-			reply.info.destination = request->destination;
+			replycommand.info.destination = command->destination;
-			reply.info.format.type = B_MEDIA_RAW_VIDEO;
+			replycommand.info.format.type = B_MEDIA_RAW_VIDEO;
-			reply.info.format.u.raw_video.display = request->display;
+			replycommand.info.format.u.raw_video.display = command->display;
-			write_port(request->destination.port, NODE_REQUEST_COMPLETED, &reply, sizeof(reply));
+			SendToPort(command->destination.port, NODE_REQUEST_COMPLETED, &replycommand, sizeof(replycommand));
 			return B_OK;
 		}
 
 		case PRODUCER_ADDITIONAL_BUFFER_REQUESTED:
 		{
-			const xfer_producer_additional_buffer_requested *request = (const xfer_producer_additional_buffer_requested *)rawdata;
+			const producer_additional_buffer_requested_command *command = static_cast<const producer_additional_buffer_requested_command *>(data);
-			AdditionalBufferRequested(request->source, request->prev_buffer, request->prev_time, request->has_seek_tag ? &request->prev_tag : NULL);
+			AdditionalBufferRequested(command->source, command->prev_buffer, command->prev_time, command->has_seek_tag ? &command->prev_tag : NULL);
 			return B_OK;
 		}
 	
 		case PRODUCER_LATENCY_CHANGED:
 		{
-			const xfer_producer_latency_changed *request = (const xfer_producer_latency_changed *)rawdata;
+			const producer_latency_changed_command *command = static_cast<const producer_latency_changed_command *>(data);
-			LatencyChanged(request->source, request->destination, request->latency, request->flags);
+			LatencyChanged(command->source, command->destination, command->latency, command->flags);
 			return B_OK;
 		}
 
 		case PRODUCER_LATE_NOTICE_RECEIVED:
 		{
-			const xfer_producer_late_notice_received *request = (const xfer_producer_late_notice_received *)rawdata;
+			const producer_late_notice_received_command *command = static_cast<const producer_late_notice_received_command *>(data);
-			LateNoticeReceived(request->source, request->how_much, request->performance_time);
+			LateNoticeReceived(command->source, command->how_much, command->performance_time);
 			return B_OK;
 		}
 
 		case PRODUCER_ENABLE_OUTPUT:
 		{
-			const xfer_producer_enable_output *request = (const xfer_producer_enable_output *)rawdata;
+			const producer_enable_output_command *command = static_cast<const producer_enable_output_command *>(data);
-			xfer_node_request_completed reply;
+			node_request_completed_command replycommand;
-			EnableOutput(request->source, request->enabled, NULL);
+			EnableOutput(command->source, command->enabled, NULL);
-			if (request->destination == media_destination::null)
+			if (command->destination == media_destination::null)
 				return B_OK;
-			reply.info.what = media_request_info::B_SET_OUTPUT_ENABLED;
+			replycommand.info.what = media_request_info::B_SET_OUTPUT_ENABLED;
-			reply.info.change_tag = request->change_tag;
+			replycommand.info.change_tag = command->change_tag;
-			reply.info.status = B_OK;
+			replycommand.info.status = B_OK;
-			//reply.info.cookie
+			//replycommand.info.cookie
-			reply.info.user_data = request->user_data;
+			replycommand.info.user_data = command->user_data;
-			reply.info.source = request->source;
+			replycommand.info.source = command->source;
-			reply.info.destination = request->destination;
+			replycommand.info.destination = command->destination;
-			//reply.info.format
+			//replycommand.info.format
-			write_port(request->destination.port, NODE_REQUEST_COMPLETED, &reply, sizeof(reply));
+			SendToPort(command->destination.port, NODE_REQUEST_COMPLETED, &replycommand, sizeof(replycommand));
 			return B_OK;
 		}
 				
@@ -345,13 +339,13 @@ BBufferProducer::SendBuffer(BBuffer *buffer,
 	if (buffer == NULL)
 		return B_BAD_VALUE;
 
-	xfer_consumer_buffer_received request;
+	consumer_buffer_received_command command;
-	request.buffer = buffer->ID();
+	command.buffer = buffer->ID();
-	request.header = *(buffer->Header());
+	command.header = *(buffer->Header());
-	request.header.buffer = request.buffer;
+	command.header.buffer = command.buffer; // buffer->ID();
-	request.header.destination = destination.id;
+	command.header.destination = destination.id;
 
-	return write_port(destination.port, CONSUMER_BUFFER_RECEIVED, &request, sizeof(request));
+	return SendToPort(destination.port, CONSUMER_BUFFER_RECEIVED, &command, sizeof(command));
 }
 
 
@@ -364,12 +358,12 @@ BBufferProducer::SendDataStatus(int32 status,
 	if (destination == media_destination::null)
 		return B_MEDIA_BAD_DESTINATION;
 		
-	xfer_consumer_producer_data_status request;
+	consumer_producer_data_status_command command;
-	request.for_whom = destination;
+	command.for_whom = destination;
-	request.status = status;
+	command.status = status;
-	request.at_performance_time = at_time;
+	command.at_performance_time = at_time;
 
-	return write_port(destination.port, CONSUMER_PRODUCER_DATA_STATUS, &request, sizeof(request));
+	return SendToPort(destination.port, CONSUMER_PRODUCER_DATA_STATUS, &command, sizeof(command));
 }
 
 
@@ -407,28 +401,15 @@ BBufferProducer::ChangeFormat(const media_source &for_source,
 	if (for_destination == media_destination::null)
 		return B_MEDIA_BAD_DESTINATION;
 		
-	status_t rv;
+	consumer_format_changed_request request;
-	int32 code;
+	consumer_format_changed_reply reply;
-	xfer_consumer_format_changed request;
-	xfer_consumer_format_changed_reply reply;
 
 	request.producer = for_source;
 	request.consumer = for_destination;
 	request.format = *format;
-	request.reply_port = _PortPool->GetPort();
 	
-	rv = write_port(for_destination.port, CONSUMER_FORMAT_CHANGED, &request, sizeof(request));
+	// we use a request/reply to make this synchronous
-	if (rv != B_OK) {
+	return QueryPort(for_destination.port, CONSUMER_FORMAT_CHANGED, &request, sizeof(request), &reply, sizeof(reply));
-		_PortPool->PutPort(request.reply_port);
-		return rv;
-	}
-
-	rv = read_port(request.reply_port, &code, &reply, sizeof(reply));
-	_PortPool->PutPort(request.reply_port);
-	if (rv < B_OK)
-		return rv;
-	
-	return reply.result;
 }
 
 
@@ -442,28 +423,18 @@ BBufferProducer::FindLatencyFor(const media_destination &for_destination,
 		return B_MEDIA_BAD_DESTINATION;
 		
 	status_t rv;
-	int32 code;
+	consumer_get_latency_for_request request;
-	xfer_consumer_get_latency_for request;
+	consumer_get_latency_for_reply reply;
-	xfer_consumer_get_latency_for_reply reply;
 
 	request.for_whom = for_destination;
-	request.reply_port = _PortPool->GetPort();
 	
-	rv = write_port(for_destination.port, CONSUMER_GET_LATENCY_FOR, &request, sizeof(request));
+	rv = QueryPort(for_destination.port, CONSUMER_GET_LATENCY_FOR, &request, sizeof(request), &reply, sizeof(reply));
-	if (rv != B_OK) {
+	if (rv != B_OK)
-		_PortPool->PutPort(request.reply_port);
-		return rv;
-	}
-
-	rv = read_port(request.reply_port, &code, &reply, sizeof(reply));
-	_PortPool->PutPort(request.reply_port);
-	if (rv < B_OK)
 		return rv;
 
 	*out_latency = reply.latency;
 	*out_timesource = reply.timesource;
-
+	return rv;
-	return reply.result;
 }
 
 
@@ -480,31 +451,21 @@ BBufferProducer::FindSeekTag(const media_destination &for_destination,
 		return B_MEDIA_BAD_DESTINATION;
 		
 	status_t rv;
-	int32 code;
+	consumer_seek_tag_requested_request request;
-	xfer_consumer_seek_tag_requested request;
+	consumer_seek_tag_requested_reply reply;
-	xfer_consumer_seek_tag_requested_reply reply;
 
 	request.destination = for_destination;
 	request.target_time = in_target_time;
 	request.flags = in_flags;
-	request.reply_port = _PortPool->GetPort();
 	
-	rv = write_port(for_destination.port, CONSUMER_SEEK_TAG_REQUESTED, &request, sizeof(request));
+	rv = QueryPort(for_destination.port, CONSUMER_SEEK_TAG_REQUESTED, &request, sizeof(request), &reply, sizeof(reply));
-	if (rv != B_OK) {
+	if (rv != B_OK)
-		_PortPool->PutPort(request.reply_port);
-		return rv;
-	}
-
-	rv = read_port(request.reply_port, &code, &reply, sizeof(reply));
-	_PortPool->PutPort(request.reply_port);
-	if (rv < B_OK)
 		return rv;
 
 	*out_tag = reply.seek_tag;
 	*out_tagged_time = reply.tagged_time;
 	*out_flags = reply.flags;
-	
+	return rv;
-	return reply.result;
 }
 
 

src/kits/media/DataExchange.cpp

@@ -49,7 +49,8 @@ status_t
 request_data::SendReply(status_t result, reply_data *reply, int replysize) const
 {
 	reply->result = result;
-	return SendToPort(reply_port, 0, reply, replysize);
+	// we cheat and use the (command_data *) version of SendToPort
+	return SendToPort(reply_port, 0, reinterpret_cast<command_data *>(reply), replysize);
 }
 
 
@@ -75,7 +76,7 @@ status_t QueryServer(BMessage *request, BMessage *reply)
 
 
 // Raw data based data exchange with the media_server
-status_t SendToServer(int32 msgcode, void *msg, int size)
+status_t SendToServer(int32 msgcode, command_data *msg, int size)
 {
 	return SendToPort(MediaServerPort, msgcode, msg, size);
 }
@@ -87,7 +88,7 @@ status_t QueryServer(int32 msgcode, request_data *request, int requestsize, repl
 
 
 // Raw data based data exchange with the media_addon_server
-status_t SendToAddonServer(int32 msgcode, void *msg, int size)
+status_t SendToAddonServer(int32 msgcode, command_data *msg, int size)
 {
 	return SendToPort(MediaAddonServerPort, msgcode, msg, size);
 }
@@ -100,7 +101,7 @@ status_t QueryAddonServer(int32 msgcode, request_data *request, int requestsize,
 
 
 // Raw data based data exchange with the media_server
-status_t SendToPort(port_id sendport, int32 msgcode, void *msg, int size)
+status_t SendToPort(port_id sendport, int32 msgcode, command_data *msg, int size)
 {
 	status_t rv;
 	rv = write_port_etc(sendport, msgcode, msg, size, B_RELATIVE_TIMEOUT, TIMEOUT);

src/kits/media/DormantNodeManager.cpp

@@ -30,6 +30,7 @@
 #include "debug.h"
 #include "PortPool.h"
 #include "ServerInterface.h"
+#include "DataExchange.h"
 #include "DormantNodeManager.h"
 
 static BPrivate::media::DormantNodeManager manager;
@@ -164,8 +165,8 @@ DormantNodeManager::PutAddon(media_addon_id id)
 media_addon_id
 DormantNodeManager::RegisterAddon(const char *path)
 {
-	xfer_server_register_mediaaddon msg;
+	server_register_mediaaddon_request msg;
-	xfer_server_register_mediaaddon_reply reply;
+	server_register_mediaaddon_reply reply;
 	port_id port;
 	status_t rv;
 	int32 code;
@@ -201,7 +202,7 @@ void
 DormantNodeManager::UnregisterAddon(media_addon_id id)
 {
 	ASSERT(id > 0);
-	xfer_server_unregister_mediaaddon msg;
+	server_unregister_mediaaddon_command msg;
 
 	printf("DormantNodeManager::UnregisterAddon id %ld\n",id);
 
@@ -217,8 +218,8 @@ DormantNodeManager::UnregisterAddon(media_addon_id id)
 status_t
 DormantNodeManager::FindAddonPath(BPath *path, media_addon_id id)
 {
-	xfer_server_get_mediaaddon_ref msg;
+	server_get_mediaaddon_ref_request msg;
-	xfer_server_get_mediaaddon_ref_reply reply;
+	server_get_mediaaddon_ref_reply reply;
 	port_id port;
 	entry_ref tempref;
 	status_t rv;

src/kits/media/MediaAddOn.cpp

@@ -10,6 +10,7 @@
 #include "debug.h"
 #include "PortPool.h"
 #include "ServerInterface.h"
+#include "DataExchange.h"
 
 /*
  * some little helper function
@@ -543,7 +544,7 @@ BMediaAddOn::NotifyFlavorChange()
 	if (port <= B_OK)
 		return B_ERROR;
 
-	xfer_addonserver_rescan_mediaaddon_flavors msg;
+	addonserver_rescan_mediaaddon_flavors_command msg;
 	msg.addonid = fAddon;
 	return write_port(port, ADDONSERVER_RESCAN_MEDIAADDON_FLAVORS, &msg, sizeof(msg));
 }

src/kits/media/MediaNode.cpp

@@ -327,7 +327,7 @@ BMediaNode::WaitForMessage(bigtime_t waitUntil,
 			return B_OK;
 	}
 
-	if (fControllableThis && message > CONTROLLABLE_MESSAGE_START && message < CONTROLLABLE_MESSAGE_END) {
+	if (message > CONTROLLABLE_MESSAGE_START && message < CONTROLLABLE_MESSAGE_END) {
 		if (!fControllableThis)
 			fControllableThis = dynamic_cast<BControllable *>(this);
 		TRACE("BMediaNode::WaitForMessage calling BControllable %p\n", fControllableThis);
@@ -335,7 +335,7 @@ BMediaNode::WaitForMessage(bigtime_t waitUntil,
 			return B_OK;
 	}
 
-	if (fTimeSourceThis && message > TIMESOURECE_MESSAGE_START && message < TIMESOURECE_MESSAGE_END) {
+	if (message > TIMESOURECE_MESSAGE_START && message < TIMESOURECE_MESSAGE_END) {
 		if (!fTimeSourceThis)
 			fTimeSourceThis = dynamic_cast<BTimeSource *>(this);
 		TRACE("BMediaNode::WaitForMessage calling BTimeSource %p\n", fTimeSourceThis);
@@ -466,37 +466,37 @@ BMediaNode::HandleMessage(int32 message,
 	switch (message) {
 		case NODE_START:
 		{
-			const xfer_node_start *request = (const xfer_node_start *)data;
+			const node_start_command *command = static_cast<const node_start_command *>(data);
-			Start(request->performance_time);
+			Start(command->performance_time);
 			return B_OK;
 		}
 
 		case NODE_STOP:
 		{
-			const xfer_node_stop *request = (const xfer_node_stop *)data;
+			const node_stop_command *command = static_cast<const node_stop_command *>(data);
-			Stop(request->performance_time, request->immediate);
+			Stop(command->performance_time, command->immediate);
 			return B_OK;
 		}
 
 		case NODE_SEEK:
 		{
-			const xfer_node_seek *request = (const xfer_node_seek *)data;
+			const node_seek_command *command = static_cast<const node_seek_command *>(data);
-			Seek(request->media_time, request->performance_time);
+			Seek(command->media_time, command->performance_time);
 			return B_OK;
 		}
 
 		case NODE_SET_RUN_MODE:
 		{
-			const xfer_node_set_run_mode *request = (const xfer_node_set_run_mode *)data;
+			const node_set_run_mode_command *command = static_cast<const node_set_run_mode_command *>(data);
-			fRunMode = request->mode;
+			fRunMode = command->mode;
 			SetRunMode(fRunMode);
 			return B_OK;
 		}
 
 		case NODE_TIME_WARP:
 		{
-			const xfer_node_time_warp *request = (const xfer_node_time_warp *)data;
+			const node_time_warp_command *command = static_cast<const node_time_warp_command *>(data);
-			TimeWarp(request->at_real_time,request->to_performance_time);
+			TimeWarp(command->at_real_time, command->to_performance_time);
 			return B_OK;
 		}
 
@@ -508,11 +508,11 @@ BMediaNode::HandleMessage(int32 message,
 		
 		case NODE_SET_TIMESOURCE:
 		{
-			const xfer_node_set_timesource *request = (const xfer_node_set_timesource *)data;
+			const node_set_timesource_command *command = static_cast<const node_set_timesource_command *>(data);
 			bool first = (fTimeSourceID == 0);
 			if (fTimeSource)
 				fTimeSource->Release();
-			fTimeSourceID = request->timesource_id;
+			fTimeSourceID = command->timesource_id;
 			fTimeSource = 0; // XXX create timesource object here
 			fTimeSource = new _SysTimeSource;
 			if (!first)
@@ -522,8 +522,8 @@ BMediaNode::HandleMessage(int32 message,
 
 		case NODE_REQUEST_COMPLETED:
 		{
-			const xfer_node_request_completed *request = (const xfer_node_request_completed *)data;
+			const node_request_completed_command *command = static_cast<const node_request_completed_command *>(data);
-			RequestCompleted(request->info);
+			RequestCompleted(command->info);
 			return B_OK;
 		}
 		

src/kits/media/MediaRoster.cpp

@@ -662,7 +662,7 @@ BMediaRoster::StartNode(const media_node & node,
 	if (node.node <= 0)
 		return B_MEDIA_BAD_NODE;
 
-	xfer_node_start msg;
+	node_start_command msg;
 	msg.performance_time = at_performance_time;
 	
 	return write_port(node.port, NODE_START, &msg, sizeof(msg));
@@ -678,7 +678,7 @@ BMediaRoster::StopNode(const media_node & node,
 	if (node.node <= 0)
 		return B_MEDIA_BAD_NODE;
 
-	xfer_node_stop msg;
+	node_stop_command msg;
 	msg.performance_time = at_performance_time;
 	msg.immediate = immediate;
 	
@@ -695,7 +695,7 @@ BMediaRoster::SeekNode(const media_node & node,
 	if (node.node <= 0)
 		return B_MEDIA_BAD_NODE;
 
-	xfer_node_seek msg;
+	node_seek_command msg;
 	msg.media_time = to_media_time;
 	msg.performance_time = at_performance_time;
 	
@@ -778,7 +778,7 @@ BMediaRoster::SetRunModeNode(const media_node & node,
 	if (node.node <= 0)
 		return B_MEDIA_BAD_NODE;
 
-	xfer_node_set_run_mode msg;
+	node_set_run_mode_command msg;
 	msg.mode = mode;
 	
 	return write_port(node.port, NODE_SET_RUN_MODE, &msg, sizeof(msg));
@@ -829,8 +829,8 @@ BMediaRoster::SetProducerRate(const media_node & producer,
 	if ((producer.kind & B_BUFFER_PRODUCER) == 0)
 		return B_MEDIA_BAD_NODE;
 
-	xfer_producer_set_play_rate msg;
+	producer_set_play_rate_request msg;
-	xfer_producer_set_play_rate_reply reply;
+	producer_set_play_rate_reply reply;
 	status_t rv;
 	int32 code;
 

src/kits/media/TimeSource.cpp

@@ -123,7 +123,7 @@ BTimeSource::BTimeSource() :
 
 status_t
 BTimeSource::HandleMessage(int32 message,
-						   const void *rawdata,
+						   const void *data,
 						   size_t size)
 {
 	TRACE("BTimeSource::HandleMessage %#lx, node %ld\n", message, fNodeID);
@@ -131,7 +131,7 @@ BTimeSource::HandleMessage(int32 message,
 	switch (message) {
 		case TIMESOURCE_OP:
 		{
-			const time_source_op_info *data = (const time_source_op_info *)rawdata;
+			const time_source_op_info *data = static_cast<const time_source_op_info *>(data);
 			status_t result;
 			result = TimeSourceOp(*data, NULL);
 			return B_OK;

src/kits/media/TrackReader.cpp

@@ -180,7 +180,7 @@ BTrackReader::ReadFrames(void *in_buffer, int32 frame_count)
 {
 	CALLED();
 
-	uint8 *buffer = (uint8 *)in_buffer;
+	uint8 *buffer = static_cast<uint8 *>(in_buffer);
 	int32 bytes_to_read = frame_count * fFrameSize;
 
 	status_t last_status = B_OK;

src/servers/media/ServerInterface.h

@@ -65,36 +65,6 @@ enum {
 };
 
 
-/* We can't send an entry_ref through a port to another team,
- * but we can assign it to an xfer_entry_ref and send this one,
- * when we receive it we can assign it to a normal entry_ref
- */
-struct xfer_entry_ref
-{
-public:
-	xfer_entry_ref()
-		{
-			device = -1;
-			directory = -1;
-			name[0] = 0;
-		}
-	operator entry_ref() const
-		{
-			entry_ref ref(device, directory, name);
-			return ref;
-		}
-	void operator=(const entry_ref &ref)
-		{
-			device = ref.device;
-			directory = ref.directory;
-			strcpy(name, ref.name);
-		}
-private:
-	dev_t	device;
-	ino_t	directory;
-	char	name[B_FILE_NAME_LENGTH];
-};
-
 
 struct xfer_server_get_dormant_flavor_info
 {
@@ -139,242 +109,8 @@ struct xfer_server_register_dormant_node
 	char 			dfi[1];   // a flattened dormant_flavor_info, dfi_size large
 };
 
-struct xfer_addonserver_rescan_mediaaddon_flavors
-{
-	media_addon_id addonid;
-};
 
-struct xfer_server_register_mediaaddon
-{
-	port_id 	reply_port;
-	xfer_entry_ref	ref; // a ref to the file
-};
 
-struct xfer_server_register_mediaaddon_reply
-{
-	media_addon_id addonid;
-};
-
-struct xfer_server_unregister_mediaaddon
-{
-	media_addon_id addonid;
-};
-
-struct xfer_server_get_mediaaddon_ref
-{
-	media_addon_id addonid;
-	port_id 	reply_port;
-};
-
-struct xfer_server_get_mediaaddon_ref_reply
-{
-	status_t result;
-	xfer_entry_ref	ref; // a ref to the file
-};
-
-struct xfer_producer_format_suggestion_requested
-{
-	media_type type;
-	int32 quality;
-	port_id reply_port;
-};
-
-struct xfer_producer_format_suggestion_requested_reply
-{
-	media_format format;
-	status_t result;
-};
-
-struct xfer_producer_set_play_rate
-{
-	int32 numer;
-	int32 denom;
-	port_id reply_port;
-};
-
-struct xfer_producer_set_play_rate_reply
-{
-	status_t result;
-};
-
-struct xfer_producer_get_initial_latency
-{
-	port_id reply_port;
-};
-
-struct xfer_producer_get_initial_latency_reply
-{
-	bigtime_t initial_latency;
-	uint32 flags;
-};
-
-struct xfer_producer_get_latency
-{
-	port_id reply_port;
-};
-
-struct xfer_producer_get_latency_reply
-{
-	bigtime_t latency;
-	status_t result;
-};
-
-struct xfer_producer_set_buffer_group
-{
-	media_source source;
-	media_destination destination;
-	void *user_data;
-	int32 change_tag;
-	int32 buffer_count;
-	media_buffer_id buffers[1];
-};
-
-struct xfer_producer_format_change_requested
-{
-	media_source source;
-	media_destination destination;
-	media_format format;
-	void *user_data;
-	int32 change_tag;
-};
-
-struct xfer_producer_video_clipping_changed
-{
-	media_source source;
-	media_destination destination;
-	media_video_display_info display;
-	void *user_data;
-	int32 change_tag;
-	int32 short_count;
-	int16 shorts[1];
-};
-
-struct xfer_producer_additional_buffer_requested
-{
-	media_source source;
-	media_buffer_id prev_buffer;
-	bigtime_t prev_time;
-	bool has_seek_tag;
-	media_seek_tag prev_tag;
-};
-
-struct xfer_producer_latency_changed
-{
-	media_source source;
-	media_destination destination;
-	bigtime_t latency;
-	uint32 flags;
-};
-
-struct xfer_node_request_completed
-{
-	media_request_info info;
-};
-
-struct xfer_producer_enable_output
-{
-	media_source source;
-	media_destination destination;
-	bool enabled;
-	void *user_data;
-	int32 change_tag;
-};
-
-struct xfer_producer_late_notice_received
-{
-	media_source source;
-	bigtime_t how_much;
-	bigtime_t performance_time;
-};
-
-struct xfer_node_start
-{
-	bigtime_t performance_time;	
-};
-
-struct xfer_node_stop
-{
-	bigtime_t performance_time;	
-	bool immediate;
-};
-
-struct xfer_node_seek
-{
-	bigtime_t media_time;
-	bigtime_t performance_time;
-};
-
-struct xfer_node_set_run_mode
-{
-	BMediaNode::run_mode mode;
-};
-
-struct xfer_node_time_warp
-{
-	bigtime_t at_real_time;
-	bigtime_t to_performance_time;
-};
-
-struct xfer_node_set_timesource
-{
-	media_node_id timesource_id;
-};
-
-struct xfer_consumer_buffer_received
-{
-	media_buffer_id buffer;
-	media_header header;
-};
-
-struct xfer_consumer_producer_data_status
-{
-	media_destination for_whom;
-	int32 status;
-	bigtime_t at_performance_time;
-};
-
-struct xfer_consumer_get_latency_for
-{
-	media_destination for_whom;
-	port_id reply_port;
-};
-
-struct xfer_consumer_get_latency_for_reply
-{
-	bigtime_t latency;
-	media_node_id timesource;
-	status_t result;
-};
-	
-struct xfer_consumer_format_changed
-{
-	media_source producer;
-	media_destination consumer;
-	int32 change_tag;
-	media_format format;
-	port_id reply_port;
-};
-
-struct xfer_consumer_format_changed_reply
-{
-	status_t result;
-};
-
-struct xfer_consumer_seek_tag_requested
-{
-	media_destination destination;
-	bigtime_t target_time;
-	uint32 flags;
-	port_id reply_port;
-};
-
-struct xfer_consumer_seek_tag_requested_reply
-{
-	media_seek_tag seek_tag;
-	bigtime_t tagged_time;
-	uint32 flags;
-	status_t result;
-};
 
 namespace BPrivate { namespace media { namespace dataexchange {
 	status_t QueryServer(BMessage *query, BMessage *reply);

src/servers/media/media_server.cpp

@@ -92,7 +92,7 @@ public:
 00014e1c T _ServerApp::~_ServerApp(void)
 00014ff4 T _ServerApp::MessageReceived(BMessage *);
 00015840 T _ServerApp::QuitRequested(void)
-00015b50 T _ServerApp::_DoNotify(notify_data *)
+00015b50 T _ServerApp::_DoNotify(command_data *)
 00015d18 T _ServerApp::_UnregisterApp(long, bool)
 00018e90 T _ServerApp::AddOnHost(void)
 00019530 T _ServerApp::AboutRequested(void)
@@ -162,8 +162,8 @@ ServerApp::HandleMessage(int32 code, void *data, size_t size)
 	switch (code) {
 		case SERVER_GET_MEDIAADDON_REF:
 		{
-			xfer_server_get_mediaaddon_ref *msg = (xfer_server_get_mediaaddon_ref *)data;
+			server_get_mediaaddon_ref_request *msg = (server_get_mediaaddon_ref_request *)data;
-			xfer_server_get_mediaaddon_ref_reply reply;
+			server_get_mediaaddon_ref_reply reply;
 			entry_ref tempref;
 			reply.result = gNodeManager->GetAddonRef(&tempref, msg->addonid);
 			reply.ref = tempref;
@@ -349,8 +349,8 @@ ServerApp::HandleMessage(int32 code, void *data, size_t size)
 
 		case SERVER_REGISTER_MEDIAADDON:
 		{
-			xfer_server_register_mediaaddon *msg = (xfer_server_register_mediaaddon *)data;
+			server_register_mediaaddon_request *msg = (server_register_mediaaddon_request *)data;
-			xfer_server_register_mediaaddon_reply reply;
+			server_register_mediaaddon_reply reply;
 			gNodeManager->RegisterAddon(msg->ref, &reply.addonid);
 			write_port(msg->reply_port, 0, &reply, sizeof(reply));
 			break;
@@ -358,7 +358,7 @@ ServerApp::HandleMessage(int32 code, void *data, size_t size)
 		
 		case SERVER_UNREGISTER_MEDIAADDON:
 		{
-			xfer_server_unregister_mediaaddon *msg = (xfer_server_unregister_mediaaddon *)data;
+			server_unregister_mediaaddon_command *msg = (server_unregister_mediaaddon_command *)data;
 			gNodeManager->UnregisterAddon(msg->addonid);
 			break;
 		}

src/servers/media_addon/main.cpp

@@ -91,7 +91,7 @@ MediaAddonServer::HandleMessage(int32 code, void *data, size_t size)
 
 		case ADDONSERVER_RESCAN_MEDIAADDON_FLAVORS:
 		{
-			const xfer_addonserver_rescan_mediaaddon_flavors *msg = (const xfer_addonserver_rescan_mediaaddon_flavors *)data;
+			const addonserver_rescan_mediaaddon_flavors_command *msg = (const addonserver_rescan_mediaaddon_flavors_command *)data;
 			BMediaAddOn *addon;
 			addon = _DormantNodeManager->GetAddon(msg->addonid);
 			if (!addon) {