From 8c6a6096e726d70741695920db0818695bcda98f Mon Sep 17 00:00:00 2001 From: beveloper Date: Wed, 2 Oct 2002 22:12:10 +0000 Subject: [PATCH] rewrote BMediaRoster::Connect() and a few related functions git-svn-id: file:///srv/svn/repos/haiku/trunk/current@1347 a95241bf-73f2-0310-859d-f6bbb57e9c96 --- headers/private/media/DataExchange.h | 123 +++++++++++- src/kits/media/BufferConsumer.cpp | 260 +++++++++++++------------ src/kits/media/BufferProducer.cpp | 254 ++++++++++++------------ src/kits/media/DataExchange.cpp | 3 +- src/kits/media/MediaRoster.cpp | 280 ++++++++++++--------------- src/servers/media/NodeManager.cpp | 1 - src/servers/media/ServerInterface.h | 123 +----------- src/servers/media/media_server.cpp | 16 +- src/servers/media_addon/main.cpp | 9 +- 9 files changed, 518 insertions(+), 551 deletions(-) diff --git a/headers/private/media/DataExchange.h b/headers/private/media/DataExchange.h index 12605df222..3a68017ad3 100644 --- a/headers/private/media/DataExchange.h +++ b/headers/private/media/DataExchange.h @@ -39,7 +39,7 @@ struct request_data { port_id reply_port; - void SendReply(reply_data *reply, int replysize) const; + void SendReply(status_t result, reply_data *reply, int replysize) const; }; // The base struct used for all raw replys @@ -55,6 +55,7 @@ struct reply_data using namespace BPrivate::media::dataexchange; +// BMessage based server communication enum { // BMediaRoster notification service @@ -64,15 +65,131 @@ enum { }; -struct request_addonserver_instantiate_dormant_node : public request_data +// Raw port based communication +enum { + SERVER_GET_NODE = 1000, + SERVER_SET_NODE, + CONSUMER_ACCEPT_FORMAT, + CONSUMER_CONNECTED, + PRODUCER_FORMAT_PROPOSAL, + PRODUCER_PREPARE_TO_CONNECT, + PRODUCER_CONNECT, +}; + +// used by SERVER_GET_NODE and SERVER_SET_NODE +enum node_type +{ + VIDEO_INPUT, + AUDIO_INPUT, + VIDEO_OUTPUT, + AUDIO_MIXER, + AUDIO_OUTPUT, + AUDIO_OUTPUT_EX, + TIME_SOURCE, + SYSTEM_TIME_SOURCE +}; + + +struct addonserver_instantiate_dormant_node_request : public request_data { dormant_node_info info; }; -struct reply_addonserver_instantiate_dormant_node : public reply_data +struct addonserver_instantiate_dormant_node_reply : public reply_data { media_node node; }; +struct server_set_node_request : public request_data +{ + node_type type; + bool use_node; + media_node node; + bool use_dni; + dormant_node_info dni; + bool use_input; + media_input input; +}; + +struct server_set_node_reply : public reply_data +{ +}; + +struct server_get_node_request : public request_data +{ + node_type type; +}; + +struct server_get_node_reply : public reply_data +{ + media_node node; + + // for AUDIO_OUTPUT_EX + char input_name[B_MEDIA_NAME_LENGTH]; + int32 input_id; +}; + +struct producer_format_proposal_request : public request_data +{ + media_source output; + media_format format; +}; + +struct producer_format_proposal_reply : public reply_data +{ + media_format format; +}; + +struct producer_prepare_to_connect_request : public request_data +{ + media_source source; + media_destination destination; + media_format format; + char name[B_MEDIA_NAME_LENGTH]; +}; + +struct producer_prepare_to_connect_reply : public reply_data +{ + media_format format; + media_source out_source; + char name[B_MEDIA_NAME_LENGTH]; +}; + +struct producer_connect_request : public request_data +{ + status_t error; + media_source source; + media_destination destination; + media_format format; + char name[B_MEDIA_NAME_LENGTH]; +}; + +struct producer_connect_reply : public reply_data +{ + char name[B_MEDIA_NAME_LENGTH]; +}; + +struct consumer_accept_format_request : public request_data +{ + media_destination dest; + media_format format; +}; + +struct consumer_accept_format_reply : public reply_data +{ + media_format format; +}; + +struct consumer_connected_request : public request_data +{ + media_source producer; + media_destination where; + media_format with_format; +}; + +struct consumer_connected_reply : public reply_data +{ + media_input input; +}; #endif // _DATA_EXCHANGE_H diff --git a/src/kits/media/BufferConsumer.cpp b/src/kits/media/BufferConsumer.cpp index 470e69f74a..73fd420d21 100644 --- a/src/kits/media/BufferConsumer.cpp +++ b/src/kits/media/BufferConsumer.cpp @@ -9,6 +9,7 @@ #include #include #include "debug.h" +#include "DataExchange.h" #include "ServerInterface.h" #include "BufferIdCache.h" @@ -42,7 +43,7 @@ BBufferConsumer::ConsumerType() BBufferConsumer::RegionToClipData(const BRegion *region, int32 *format, int32 *ioSize, - void *data) + void *request) { CALLED(); @@ -50,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, (int16 *)request, count, &count); *ioSize = count * sizeof(int16); *format = BBufferProducer::B_CLIP_SHORT_RUNS; @@ -83,12 +84,12 @@ BBufferConsumer::NotifyLateProducer(const media_source &what_source, if (what_source == media_source::null) return; - xfer_producer_late_notice_received data; - data.source = what_source; - data.how_much = how_much; - data.performance_time = performance_time; + xfer_producer_late_notice_received request; + request.source = what_source; + request.how_much = how_much; + request.performance_time = performance_time; - write_port(what_source.port, PRODUCER_LATE_NOTICE_RECEIVED, &data, sizeof(data)); + write_port(what_source.port, PRODUCER_LATE_NOTICE_RECEIVED, &request, sizeof(request)); } @@ -110,24 +111,24 @@ BBufferConsumer::SetVideoClippingFor(const media_source &output, if (short_count > int(B_MEDIA_MESSAGE_SIZE - sizeof(xfer_producer_video_clipping_changed)) / 2) debugger("BBufferConsumer::SetVideoClippingFor short_count too large (8000 limit)\n"); - xfer_producer_video_clipping_changed *data; + xfer_producer_video_clipping_changed *request; size_t size; status_t rv; size = sizeof(xfer_producer_video_clipping_changed) + short_count * 2; - data = (xfer_producer_video_clipping_changed *) malloc(size); - data->source = output; - data->destination = destination; - data->display = display; - data->user_data = user_data; - data->change_tag = NewChangeTag(); - data->short_count = short_count; - memcpy(data->shorts, shorts, short_count * 2); + request = (xfer_producer_video_clipping_changed *) malloc(size); + request->source = output; + request->destination = destination; + request->display = display; + request->user_data = user_data; + request->change_tag = NewChangeTag(); + request->short_count = short_count; + memcpy(request->shorts, shorts, short_count * 2); if (change_tag != NULL) - *change_tag = data->change_tag; + *change_tag = request->change_tag; - rv = write_port(output.port, PRODUCER_VIDEO_CLIPPING_CHANGED, data, size); - free(data); + rv = write_port(output.port, PRODUCER_VIDEO_CLIPPING_CHANGED, request, size); + free(request); return rv; } @@ -146,17 +147,17 @@ BBufferConsumer::SetOutputEnabled(const media_source &source, if (source == media_source::null) return B_MEDIA_BAD_SOURCE; - xfer_producer_enable_output data; + xfer_producer_enable_output request; - data.source = source; - data.destination = destination; - data.enabled = enabled; - data.user_data = user_data; - data.change_tag = NewChangeTag(); + request.source = source; + request.destination = destination; + request.enabled = enabled; + request.user_data = user_data; + request.change_tag = NewChangeTag(); if (change_tag != NULL) - *change_tag = data.change_tag; + *change_tag = request.change_tag; - return write_port(source.port, PRODUCER_ENABLE_OUTPUT, &data, sizeof(data)); + return write_port(source.port, PRODUCER_ENABLE_OUTPUT, &request, sizeof(request)); } @@ -174,17 +175,17 @@ BBufferConsumer::RequestFormatChange(const media_source &source, if (source == media_source::null) return B_MEDIA_BAD_SOURCE; - xfer_producer_format_change_requested data; + xfer_producer_format_change_requested request; - data.source = source; - data.destination = destination; - data.format = to_format; - data.user_data = user_data; - data.change_tag = NewChangeTag(); + request.source = source; + request.destination = destination; + request.format = to_format; + request.user_data = user_data; + request.change_tag = NewChangeTag(); if (change_tag != NULL) - *change_tag = data.change_tag; + *change_tag = request.change_tag; - return write_port(source.port, PRODUCER_FORMAT_CHANGE_REQUESTED, &data, sizeof(data)); + return write_port(source.port, PRODUCER_FORMAT_CHANGE_REQUESTED, &request, sizeof(request)); } @@ -197,15 +198,15 @@ BBufferConsumer::RequestAdditionalBuffer(const media_source &source, if (source == media_source::null) return B_MEDIA_BAD_SOURCE; - xfer_producer_additional_buffer_requested data; + xfer_producer_additional_buffer_requested request; - data.source = source; - data.prev_buffer = prev_buffer->ID(); - data.prev_time = 0; - data.has_seek_tag = false; - //data.prev_tag = + request.source = source; + request.prev_buffer = prev_buffer->ID(); + request.prev_time = 0; + request.has_seek_tag = false; + //request.prev_tag = - return write_port(source.port, PRODUCER_ADDITIONAL_BUFFER_REQUESTED, &data, sizeof(data)); + return write_port(source.port, PRODUCER_ADDITIONAL_BUFFER_REQUESTED, &request, sizeof(request)); } @@ -218,15 +219,15 @@ BBufferConsumer::RequestAdditionalBuffer(const media_source &source, if (source == media_source::null) return B_MEDIA_BAD_SOURCE; - xfer_producer_additional_buffer_requested data; + xfer_producer_additional_buffer_requested request; - data.source = source; - data.prev_buffer = 0; - data.prev_time = start_time; - data.has_seek_tag = false; - //data.prev_tag = + request.source = source; + request.prev_buffer = 0; + request.prev_time = start_time; + request.has_seek_tag = false; + //request.prev_tag = - return write_port(source.port, PRODUCER_ADDITIONAL_BUFFER_REQUESTED, &data, sizeof(data)); + return write_port(source.port, PRODUCER_ADDITIONAL_BUFFER_REQUESTED, &request, sizeof(request)); } @@ -246,7 +247,7 @@ BBufferConsumer::SetOutputBuffersFor(const media_source &source, if (destination == media_destination::null) return B_MEDIA_BAD_DESTINATION; - xfer_producer_set_buffer_group *data; + xfer_producer_set_buffer_group *request; BBuffer **buffers; int32 buffer_count; size_t size; @@ -270,19 +271,19 @@ BBufferConsumer::SetOutputBuffersFor(const media_source &source, } size = sizeof(xfer_producer_set_buffer_group) + buffer_count * sizeof(media_buffer_id); - data = (xfer_producer_set_buffer_group *) malloc(size); - data->source = source; - data->destination = destination; - data->user_data = user_data; - data->change_tag = NewChangeTag(); - data->buffer_count = buffer_count; + request = (xfer_producer_set_buffer_group *) malloc(size); + request->source = source; + request->destination = destination; + request->user_data = user_data; + request->change_tag = NewChangeTag(); + request->buffer_count = buffer_count; for (int32 i = 0; i < buffer_count; i++) - data->buffers[i] = buffers[i]->ID(); + request->buffers[i] = buffers[i]->ID(); if (change_tag != NULL) - *change_tag = data->change_tag; + *change_tag = request->change_tag; - rv = write_port(source.port, PRODUCER_SET_BUFFER_GROUP, data, size); - free(data); + rv = write_port(source.port, PRODUCER_SET_BUFFER_GROUP, request, size); + free(request); delete [] buffers; if (rv == B_OK) { @@ -306,14 +307,14 @@ BBufferConsumer::SendLatencyChange(const media_source &source, if (source == media_source::null) return B_MEDIA_BAD_SOURCE; - xfer_producer_latency_changed data; + xfer_producer_latency_changed request; - data.source = source; - data.destination = destination; - data.latency = my_new_latency; - data.flags = flags; + request.source = source; + request.destination = destination; + request.latency = my_new_latency; + request.flags = flags; - return write_port(source.port, PRODUCER_LATENCY_CHANGED, &data, sizeof(data)); + return write_port(source.port, PRODUCER_LATENCY_CHANGED, &request, sizeof(request)); } /************************************************************* @@ -326,103 +327,104 @@ BBufferConsumer::HandleMessage(int32 message, size_t size) { CALLED(); + status_t rv; switch (message) { case CONSUMER_ACCEPT_FORMAT: { - const xfer_consumer_accept_format *data = (const xfer_consumer_accept_format *)rawdata; - xfer_consumer_accept_format_reply reply; - reply.format = data->format; - reply.result = AcceptFormat(data->dest, &reply.format); - write_port(data->reply_port, 0, &reply, sizeof(reply)); + const consumer_accept_format_request *request = (const consumer_accept_format_request *)rawdata; + consumer_accept_format_reply reply; + reply.format = request->format; + rv = AcceptFormat(request->dest, &reply.format); + request->SendReply(rv, &reply, sizeof(reply)); return B_OK; } case CONSUMER_GET_NEXT_INPUT: { - const xfer_consumer_get_next_input *data = (const xfer_consumer_get_next_input *)rawdata; + const xfer_consumer_get_next_input *request = (const xfer_consumer_get_next_input *)rawdata; xfer_consumer_get_next_input_reply reply; - reply.cookie = data->cookie; + reply.cookie = request->cookie; reply.result = GetNextInput(&reply.cookie, &reply.input); - write_port(data->reply_port, 0, &reply, sizeof(reply)); + write_port(request->reply_port, 0, &reply, sizeof(reply)); return B_OK; } case CONSUMER_DISPOSE_INPUT_COOKIE: { - const xfer_consumer_dispose_input_cookie *data = (const xfer_consumer_dispose_input_cookie *)rawdata; - DisposeInputCookie(data->cookie); + const xfer_consumer_dispose_input_cookie *request = (const xfer_consumer_dispose_input_cookie *)rawdata; + DisposeInputCookie(request->cookie); return B_OK; } case CONSUMER_BUFFER_RECEIVED: { - const xfer_consumer_buffer_received *data = (const xfer_consumer_buffer_received *)rawdata; + const xfer_consumer_buffer_received *request = (const xfer_consumer_buffer_received *)rawdata; BBuffer *buffer; - buffer = fBufferCache->GetBuffer(data->buffer); - buffer->SetHeader(&data->header); + buffer = fBufferCache->GetBuffer(request->buffer); + buffer->SetHeader(&request->header); BufferReceived(buffer); return B_OK; } case CONSUMER_PRODUCER_DATA_STATUS: { - const xfer_consumer_producer_data_status *data = (const xfer_consumer_producer_data_status *)rawdata; - ProducerDataStatus(data->for_whom, data->status, data->at_performance_time); + const xfer_consumer_producer_data_status *request = (const xfer_consumer_producer_data_status *)rawdata; + ProducerDataStatus(request->for_whom, request->status, request->at_performance_time); return B_OK; } case CONSUMER_GET_LATENCY_FOR: { - const xfer_consumer_get_latency_for *data = (const xfer_consumer_get_latency_for *)rawdata; + const xfer_consumer_get_latency_for *request = (const xfer_consumer_get_latency_for *)rawdata; xfer_consumer_get_latency_for_reply reply; - reply.result = GetLatencyFor(data->for_whom, &reply.latency, &reply.timesource); - write_port(data->reply_port, 0, &reply, sizeof(reply)); + reply.result = GetLatencyFor(request->for_whom, &reply.latency, &reply.timesource); + write_port(request->reply_port, 0, &reply, sizeof(reply)); return B_OK; } case CONSUMER_CONNECTED: { - const xfer_consumer_connected *data = (const xfer_consumer_connected *)rawdata; - xfer_consumer_connected_reply reply; - reply.result = Connected(data->producer, data->where, data->with_format, &reply.input); - write_port(data->reply_port, 0, &reply, sizeof(reply)); + const consumer_connected_request *request = (const consumer_connected_request *)rawdata; + consumer_connected_reply reply; + rv = Connected(request->producer, request->where, request->with_format, &reply.input); + request->SendReply(rv, &reply, sizeof(reply)); return B_OK; } case CONSUMER_DISCONNECTED: { - const xfer_consumer_disconnected *data = (const xfer_consumer_disconnected *)rawdata; - Disconnected(data->producer, data->where); + const xfer_consumer_disconnected *request = (const xfer_consumer_disconnected *)rawdata; + Disconnected(request->producer, request->where); return B_OK; } case CONSUMER_FORMAT_CHANGED: { - const xfer_consumer_format_changed *data = (const xfer_consumer_format_changed *)rawdata; + const xfer_consumer_format_changed *request = (const xfer_consumer_format_changed *)rawdata; xfer_consumer_format_changed_reply reply; - reply.result = FormatChanged(data->producer, data->consumer, data->change_tag, data->format); - write_port(data->reply_port, 0, &reply, sizeof(reply)); + reply.result = FormatChanged(request->producer, request->consumer, request->change_tag, request->format); + write_port(request->reply_port, 0, &reply, sizeof(reply)); // XXX is this RequestCompleted() correct? xfer_node_request_completed completed; completed.info.what = media_request_info::B_FORMAT_CHANGED; - completed.info.change_tag = data->change_tag; + completed.info.change_tag = request->change_tag; completed.info.status = reply.result; //completed.info.cookie completed.info.user_data = 0; - completed.info.source = data->producer; - completed.info.destination = data->consumer; - completed.info.format = data->format; - write_port(data->consumer.port, NODE_REQUEST_COMPLETED, &completed, sizeof(completed)); + completed.info.source = request->producer; + completed.info.destination = request->consumer; + completed.info.format = request->format; + write_port(request->consumer.port, NODE_REQUEST_COMPLETED, &completed, sizeof(completed)); return B_OK; } case CONSUMER_SEEK_TAG_REQUESTED: { - const xfer_consumer_seek_tag_requested *data = (const xfer_consumer_seek_tag_requested *)rawdata; + const xfer_consumer_seek_tag_requested *request = (const xfer_consumer_seek_tag_requested *)rawdata; xfer_consumer_seek_tag_requested_reply reply; - reply.result = SeekTagRequested(data->destination, data->target_time, data->flags, &reply.seek_tag, &reply.tagged_time, &reply.flags); - write_port(data->reply_port, 0, &reply, sizeof(reply)); + reply.result = 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)); return B_OK; } @@ -468,24 +470,24 @@ BBufferConsumer::SetVideoClippingFor(const media_source &output, if (short_count > int(B_MEDIA_MESSAGE_SIZE - sizeof(xfer_producer_video_clipping_changed)) / 2) debugger("BBufferConsumer::SetVideoClippingFor short_count too large (8000 limit)\n"); - xfer_producer_video_clipping_changed *data; + xfer_producer_video_clipping_changed *request; size_t size; status_t rv; size = sizeof(xfer_producer_video_clipping_changed) + short_count * 2; - data = (xfer_producer_video_clipping_changed *) malloc(size); - data->source = output; - data->destination = media_destination::null; - data->display = display; - data->user_data = 0; - data->change_tag = NewChangeTag(); - data->short_count = short_count; - memcpy(data->shorts, shorts, short_count * 2); + request = (xfer_producer_video_clipping_changed *) malloc(size); + request->source = output; + request->destination = media_destination::null; + request->display = display; + request->user_data = 0; + request->change_tag = NewChangeTag(); + request->short_count = short_count; + memcpy(request->shorts, shorts, short_count * 2); if (change_tag != NULL) - *change_tag = data->change_tag; + *change_tag = request->change_tag; - rv = write_port(output.port, PRODUCER_VIDEO_CLIPPING_CHANGED, data, size); - free(data); + rv = write_port(output.port, PRODUCER_VIDEO_CLIPPING_CHANGED, request, size); + free(request); return rv; } @@ -503,17 +505,17 @@ BBufferConsumer::RequestFormatChange(const media_source &source, if (source == media_source::null) return B_MEDIA_BAD_SOURCE; - xfer_producer_format_change_requested data; + xfer_producer_format_change_requested request; - data.source = source; - data.destination = destination; - data.format = *in_to_format; - data.user_data = 0; - data.change_tag = NewChangeTag(); + request.source = source; + request.destination = destination; + request.format = *in_to_format; + request.user_data = 0; + request.change_tag = NewChangeTag(); if (change_tag != NULL) - *change_tag = data.change_tag; + *change_tag = request.change_tag; - return write_port(source.port, PRODUCER_FORMAT_CHANGE_REQUESTED, &data, sizeof(data)); + return write_port(source.port, PRODUCER_FORMAT_CHANGE_REQUESTED, &request, sizeof(request)); } @@ -527,17 +529,17 @@ BBufferConsumer::SetOutputEnabled(const media_source &source, if (source == media_source::null) return B_MEDIA_BAD_SOURCE; - xfer_producer_enable_output data; + xfer_producer_enable_output request; - data.source = source; - data.destination = media_destination::null; - data.enabled = enabled; - data.user_data = 0; - data.change_tag = NewChangeTag(); + request.source = source; + request.destination = media_destination::null; + request.enabled = enabled; + request.user_data = 0; + request.change_tag = NewChangeTag(); if (change_tag != NULL) - *change_tag = data.change_tag; + *change_tag = request.change_tag; - return write_port(source.port, PRODUCER_ENABLE_OUTPUT, &data, sizeof(data)); + return write_port(source.port, PRODUCER_ENABLE_OUTPUT, &request, sizeof(request)); } diff --git a/src/kits/media/BufferProducer.cpp b/src/kits/media/BufferProducer.cpp index d3cbeca10c..84e70ee3b4 100644 --- a/src/kits/media/BufferProducer.cpp +++ b/src/kits/media/BufferProducer.cpp @@ -8,6 +8,7 @@ #include #include "PortPool.h" #include "debug.h" +#include "DataExchange.h" #include "ServerInterface.h" /************************************************************* @@ -26,7 +27,7 @@ BBufferProducer::~BBufferProducer() /* static */ status_t BBufferProducer::ClipDataToRegion(int32 format, int32 size, - const void *data, + const void *request, BRegion *region) { CALLED(); @@ -34,7 +35,7 @@ BBufferProducer::ClipDataToRegion(int32 format, if (format != B_CLIP_SHORT_RUNS) return B_MEDIA_BAD_CLIP_FORMAT; - return clip_shorts_to_region((const int16 *)data, size / sizeof(int16), region); + return clip_shorts_to_region((const int16 *)request, size / sizeof(int16), region); } media_type @@ -103,199 +104,201 @@ BBufferProducer::HandleMessage(int32 message, size_t size) { CALLED(); + status_t rv; switch (message) { case PRODUCER_FORMAT_SUGGESTION_REQUESTED: { - const xfer_producer_format_suggestion_requested *data = (const xfer_producer_format_suggestion_requested *)rawdata; + const xfer_producer_format_suggestion_requested *request = (const xfer_producer_format_suggestion_requested *)rawdata; xfer_producer_format_suggestion_requested_reply reply; - reply.result = FormatSuggestionRequested(data->type, data->quality, &reply.format); - write_port(data->reply_port, 0, &reply, sizeof(reply)); + reply.result = FormatSuggestionRequested(request->type, request->quality, &reply.format); + write_port(request->reply_port, 0, &reply, sizeof(reply)); return B_OK; } case PRODUCER_FORMAT_PROPOSAL: { - const xfer_producer_format_proposal *data = (const xfer_producer_format_proposal *)rawdata; - xfer_producer_format_proposal_reply reply; - reply.result = FormatProposal(data->output, (media_format *)&data->format); - write_port(data->reply_port, 0, &reply, sizeof(reply)); + const producer_format_proposal_request *request = (const producer_format_proposal_request *)rawdata; + producer_format_proposal_reply reply; + reply.format = request->format; + rv = FormatProposal(request->output, &reply.format); + request->SendReply(rv, &reply, sizeof(reply)); return B_OK; } case PRODUCER_PREPARE_TO_CONNECT: { - const xfer_producer_prepare_to_connect *data = (const xfer_producer_prepare_to_connect *)rawdata; - xfer_producer_prepare_to_connect_reply reply; - reply.format = data->format; - reply.name[0] = 0; - reply.result = PrepareToConnect(data->source, data->destination, &reply.format, &reply.out_source, reply.name); - write_port(data->reply_port, 0, &reply, sizeof(reply)); + const producer_prepare_to_connect_request *request = (const producer_prepare_to_connect_request *)rawdata; + producer_prepare_to_connect_reply reply; + reply.format = request->format; + memcpy(reply.name, request->name, B_MEDIA_NAME_LENGTH); + rv = PrepareToConnect(request->source, request->destination, &reply.format, &reply.out_source, reply.name); + request->SendReply(rv, &reply, sizeof(reply)); return B_OK; } case PRODUCER_CONNECT: { - const xfer_producer_connect *data = (const xfer_producer_connect *)rawdata; - xfer_producer_connect_reply reply; - memcpy(reply.name, data->name, B_MEDIA_NAME_LENGTH); - Connect(data->error, data->source, data->destination, data->format, reply.name); - write_port(data->reply_port, 0, &reply, sizeof(reply)); + const producer_connect_request *request = (const producer_connect_request *)rawdata; + producer_connect_reply reply; + memcpy(reply.name, request->name, B_MEDIA_NAME_LENGTH); + Connect(request->error, request->source, request->destination, request->format, reply.name); + request->SendReply(B_OK, &reply, sizeof(reply)); return B_OK; } case PRODUCER_DISCONNECT: { - const xfer_producer_disconnect *data = (const xfer_producer_disconnect *)rawdata; - Disconnect(data->source, data->destination); + const xfer_producer_disconnect *request = (const xfer_producer_disconnect *)rawdata; + Disconnect(request->source, request->destination); return B_OK; } case PRODUCER_GET_INITIAL_LATENCY: { - const xfer_producer_get_initial_latency *data = (const xfer_producer_get_initial_latency *)rawdata; + const xfer_producer_get_initial_latency *request = (const xfer_producer_get_initial_latency *)rawdata; xfer_producer_get_initial_latency_reply reply; reply.initial_latency = fInitialLatency; reply.flags = fInitialFlags; - write_port(data->reply_port, 0, &reply, sizeof(reply)); + write_port(request->reply_port, 0, &reply, sizeof(reply)); return B_OK; } case PRODUCER_SET_PLAY_RATE: { - const xfer_producer_set_play_rate *data = (const xfer_producer_set_play_rate *)rawdata; + const xfer_producer_set_play_rate *request = (const xfer_producer_set_play_rate *)rawdata; xfer_producer_set_play_rate_reply reply; - reply.result = SetPlayRate(data->numer, data->denom); - write_port(data->reply_port, 0, &reply, sizeof(reply)); + reply.result = SetPlayRate(request->numer, request->denom); + write_port(request->reply_port, 0, &reply, sizeof(reply)); return B_OK; } case PRODUCER_GET_LATENCY: { - const xfer_producer_get_latency *data = (const xfer_producer_get_latency *)rawdata; + const xfer_producer_get_latency *request = (const xfer_producer_get_latency *)rawdata; xfer_producer_get_latency_reply reply; reply.result = GetLatency(&reply.latency); - write_port(data->reply_port, 0, &reply, sizeof(reply)); + write_port(request->reply_port, 0, &reply, sizeof(reply)); return B_OK; } case PRODUCER_GET_NEXT_OUTPUT: { - const xfer_producer_get_next_output *data = (const xfer_producer_get_next_output *)rawdata; + const xfer_producer_get_next_output *request = (const xfer_producer_get_next_output *)rawdata; xfer_producer_get_next_output_reply reply; - reply.cookie = data->cookie; + reply.cookie = request->cookie; reply.result = GetNextOutput(&reply.cookie, &reply.output); - write_port(data->reply_port, 0, &reply, sizeof(reply)); + write_port(request->reply_port, 0, &reply, sizeof(reply)); return B_OK; } case PRODUCER_DISPOSE_OUTPUT_COOKIE: { - const xfer_producer_dispose_output_cookie *data = (const xfer_producer_dispose_output_cookie *)rawdata; - DisposeOutputCookie(data->cookie); + const xfer_producer_dispose_output_cookie *request = (const xfer_producer_dispose_output_cookie *)rawdata; + DisposeOutputCookie(request->cookie); return B_OK; } case PRODUCER_SET_BUFFER_GROUP: { - const xfer_producer_set_buffer_group *data = (const xfer_producer_set_buffer_group *)rawdata; + const xfer_producer_set_buffer_group *request = (const xfer_producer_set_buffer_group *)rawdata; xfer_node_request_completed reply; BBufferGroup *group; status_t rv; - group = data->buffer_count != 0 ? new BBufferGroup(data->buffer_count, data->buffers) : NULL; - rv = SetBufferGroup(data->source, group); - if (data->destination == media_destination::null) + group = request->buffer_count != 0 ? new BBufferGroup(request->buffer_count, request->buffers) : NULL; + rv = SetBufferGroup(request->source, group); + if (request->destination == media_destination::null) return B_OK; reply.info.what = media_request_info::B_SET_OUTPUT_BUFFERS_FOR; - reply.info.change_tag = data->change_tag; + reply.info.change_tag = request->change_tag; reply.info.status = rv; reply.info.cookie = (int32)group; - reply.info.user_data = data->user_data; - reply.info.source = data->source; - reply.info.destination = data->destination; - write_port(data->destination.port, NODE_REQUEST_COMPLETED, &reply, sizeof(reply)); + reply.info.user_data = request->user_data; + reply.info.source = request->source; + reply.info.destination = request->destination; + write_port(request->destination.port, NODE_REQUEST_COMPLETED, &reply, sizeof(reply)); return B_OK; } case PRODUCER_FORMAT_CHANGE_REQUESTED: { - const xfer_producer_format_change_requested *data = (const xfer_producer_format_change_requested *)rawdata; + const xfer_producer_format_change_requested *request = (const xfer_producer_format_change_requested *)rawdata; xfer_node_request_completed reply; status_t rv; - reply.info.format = data->format; - rv = FormatChangeRequested(data->source, data->destination, &reply.info.format, NULL); - if (data->destination == media_destination::null) + reply.info.format = request->format; + rv = FormatChangeRequested(request->source, request->destination, &reply.info.format, NULL); + if (request->destination == media_destination::null) return B_OK; reply.info.what = media_request_info::B_REQUEST_FORMAT_CHANGE; - reply.info.change_tag = data->change_tag; + reply.info.change_tag = request->change_tag; reply.info.status = rv; //reply.info.cookie - reply.info.user_data = data->user_data; - reply.info.source = data->source; - reply.info.destination = data->destination; - write_port(data->destination.port, NODE_REQUEST_COMPLETED, &reply, sizeof(reply)); + reply.info.user_data = request->user_data; + reply.info.source = request->source; + reply.info.destination = request->destination; + write_port(request->destination.port, NODE_REQUEST_COMPLETED, &reply, sizeof(reply)); return B_OK; } case PRODUCER_VIDEO_CLIPPING_CHANGED: { - const xfer_producer_video_clipping_changed *data = (const xfer_producer_video_clipping_changed *)rawdata; + const xfer_producer_video_clipping_changed *request = (const xfer_producer_video_clipping_changed *)rawdata; xfer_node_request_completed reply; status_t rv; - rv = VideoClippingChanged(data->source, data->short_count, (int16 *)data->shorts, data->display, NULL); - if (data->destination == media_destination::null) + rv = VideoClippingChanged(request->source, request->short_count, (int16 *)request->shorts, request->display, NULL); + if (request->destination == media_destination::null) return B_OK; reply.info.what = media_request_info::B_SET_VIDEO_CLIPPING_FOR; - reply.info.change_tag = data->change_tag; + reply.info.change_tag = request->change_tag; reply.info.status = rv; //reply.info.cookie - reply.info.user_data = data->user_data; - reply.info.source = data->source; - reply.info.destination = data->destination; + reply.info.user_data = request->user_data; + reply.info.source = request->source; + reply.info.destination = request->destination; reply.info.format.type = B_MEDIA_RAW_VIDEO; - reply.info.format.u.raw_video.display = data->display; - write_port(data->destination.port, NODE_REQUEST_COMPLETED, &reply, sizeof(reply)); + reply.info.format.u.raw_video.display = request->display; + write_port(request->destination.port, NODE_REQUEST_COMPLETED, &reply, sizeof(reply)); return B_OK; } case PRODUCER_ADDITIONAL_BUFFER_REQUESTED: { - const xfer_producer_additional_buffer_requested *data = (const xfer_producer_additional_buffer_requested *)rawdata; - AdditionalBufferRequested(data->source, data->prev_buffer, data->prev_time, data->has_seek_tag ? &data->prev_tag : NULL); + const xfer_producer_additional_buffer_requested *request = (const xfer_producer_additional_buffer_requested *)rawdata; + AdditionalBufferRequested(request->source, request->prev_buffer, request->prev_time, request->has_seek_tag ? &request->prev_tag : NULL); return B_OK; } case PRODUCER_LATENCY_CHANGED: { - const xfer_producer_latency_changed *data = (const xfer_producer_latency_changed *)rawdata; - LatencyChanged(data->source, data->destination, data->latency, data->flags); + const xfer_producer_latency_changed *request = (const xfer_producer_latency_changed *)rawdata; + LatencyChanged(request->source, request->destination, request->latency, request->flags); return B_OK; } case PRODUCER_LATE_NOTICE_RECEIVED: { - const xfer_producer_late_notice_received *data = (const xfer_producer_late_notice_received *)rawdata; - LateNoticeReceived(data->source, data->how_much, data->performance_time); + const xfer_producer_late_notice_received *request = (const xfer_producer_late_notice_received *)rawdata; + LateNoticeReceived(request->source, request->how_much, request->performance_time); return B_OK; } case PRODUCER_ENABLE_OUTPUT: { - const xfer_producer_enable_output *data = (const xfer_producer_enable_output *)rawdata; + const xfer_producer_enable_output *request = (const xfer_producer_enable_output *)rawdata; xfer_node_request_completed reply; - EnableOutput(data->source, data->enabled, NULL); - if (data->destination == media_destination::null) + EnableOutput(request->source, request->enabled, NULL); + if (request->destination == media_destination::null) return B_OK; reply.info.what = media_request_info::B_SET_OUTPUT_ENABLED; - reply.info.change_tag = data->change_tag; + reply.info.change_tag = request->change_tag; reply.info.status = B_OK; //reply.info.cookie - reply.info.user_data = data->user_data; - reply.info.source = data->source; - reply.info.destination = data->destination; + reply.info.user_data = request->user_data; + reply.info.source = request->source; + reply.info.destination = request->destination; //reply.info.format - write_port(data->destination.port, NODE_REQUEST_COMPLETED, &reply, sizeof(reply)); + write_port(request->destination.port, NODE_REQUEST_COMPLETED, &reply, sizeof(reply)); return B_OK; } @@ -336,13 +339,13 @@ BBufferProducer::SendBuffer(BBuffer *buffer, if (buffer == NULL) return B_BAD_VALUE; - xfer_consumer_buffer_received data; - data.buffer = buffer->ID(); - data.header = *(buffer->Header()); - data.header.buffer = data.buffer; - data.header.destination = destination.id; + xfer_consumer_buffer_received request; + request.buffer = buffer->ID(); + request.header = *(buffer->Header()); + request.header.buffer = request.buffer; + request.header.destination = destination.id; - return write_port(destination.port, CONSUMER_BUFFER_RECEIVED, &data, sizeof(data)); + return write_port(destination.port, CONSUMER_BUFFER_RECEIVED, &request, sizeof(request)); } @@ -355,12 +358,12 @@ BBufferProducer::SendDataStatus(int32 status, if (destination == media_destination::null) return B_MEDIA_BAD_DESTINATION; - xfer_consumer_producer_data_status data; - data.for_whom = destination; - data.status = status; - data.at_performance_time = at_time; + xfer_consumer_producer_data_status request; + request.for_whom = destination; + request.status = status; + request.at_performance_time = at_time; - return write_port(destination.port, CONSUMER_PRODUCER_DATA_STATUS, &data, sizeof(data)); + return write_port(destination.port, CONSUMER_PRODUCER_DATA_STATUS, &request, sizeof(request)); } @@ -372,29 +375,18 @@ BBufferProducer::ProposeFormatChange(media_format *format, if (for_destination == media_destination::null) return B_MEDIA_BAD_DESTINATION; + consumer_accept_format_request request; + consumer_accept_format_reply reply; status_t rv; - int32 code; - xfer_consumer_accept_format data; - xfer_consumer_accept_format_reply reply; - - data.dest = for_destination; - data.format = *format; - data.reply_port = _PortPool->GetPort(); - rv = write_port(for_destination.port, CONSUMER_ACCEPT_FORMAT, &data, sizeof(data)); - if (rv != B_OK) { - _PortPool->PutPort(data.reply_port); + request.dest = for_destination; + request.format = *format; + rv = QueryPort(for_destination.port, CONSUMER_ACCEPT_FORMAT, &request, sizeof(request), &reply, sizeof(reply)); + if (rv != B_OK) return rv; - } - rv = read_port(data.reply_port, &code, &reply, sizeof(reply)); - _PortPool->PutPort(data.reply_port); - if (rv < B_OK) - return rv; - *format = reply.format; - - return reply.result; + return B_OK; } @@ -411,22 +403,22 @@ BBufferProducer::ChangeFormat(const media_source &for_source, status_t rv; int32 code; - xfer_consumer_format_changed data; + xfer_consumer_format_changed request; xfer_consumer_format_changed_reply reply; - data.producer = for_source; - data.consumer = for_destination; - data.format = *format; - data.reply_port = _PortPool->GetPort(); + 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, &data, sizeof(data)); + rv = write_port(for_destination.port, CONSUMER_FORMAT_CHANGED, &request, sizeof(request)); if (rv != B_OK) { - _PortPool->PutPort(data.reply_port); + _PortPool->PutPort(request.reply_port); return rv; } - rv = read_port(data.reply_port, &code, &reply, sizeof(reply)); - _PortPool->PutPort(data.reply_port); + rv = read_port(request.reply_port, &code, &reply, sizeof(reply)); + _PortPool->PutPort(request.reply_port); if (rv < B_OK) return rv; @@ -445,20 +437,20 @@ BBufferProducer::FindLatencyFor(const media_destination &for_destination, status_t rv; int32 code; - xfer_consumer_get_latency_for data; + xfer_consumer_get_latency_for request; xfer_consumer_get_latency_for_reply reply; - data.for_whom = for_destination; - data.reply_port = _PortPool->GetPort(); + request.for_whom = for_destination; + request.reply_port = _PortPool->GetPort(); - rv = write_port(for_destination.port, CONSUMER_GET_LATENCY_FOR, &data, sizeof(data)); + rv = write_port(for_destination.port, CONSUMER_GET_LATENCY_FOR, &request, sizeof(request)); if (rv != B_OK) { - _PortPool->PutPort(data.reply_port); + _PortPool->PutPort(request.reply_port); return rv; } - rv = read_port(data.reply_port, &code, &reply, sizeof(reply)); - _PortPool->PutPort(data.reply_port); + rv = read_port(request.reply_port, &code, &reply, sizeof(reply)); + _PortPool->PutPort(request.reply_port); if (rv < B_OK) return rv; @@ -483,22 +475,22 @@ BBufferProducer::FindSeekTag(const media_destination &for_destination, status_t rv; int32 code; - xfer_consumer_seek_tag_requested data; + xfer_consumer_seek_tag_requested request; xfer_consumer_seek_tag_requested_reply reply; - data.destination = for_destination; - data.target_time = in_target_time; - data.flags = in_flags; - data.reply_port = _PortPool->GetPort(); + 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, &data, sizeof(data)); + rv = write_port(for_destination.port, CONSUMER_SEEK_TAG_REQUESTED, &request, sizeof(request)); if (rv != B_OK) { - _PortPool->PutPort(data.reply_port); + _PortPool->PutPort(request.reply_port); return rv; } - rv = read_port(data.reply_port, &code, &reply, sizeof(reply)); - _PortPool->PutPort(data.reply_port); + rv = read_port(request.reply_port, &code, &reply, sizeof(reply)); + _PortPool->PutPort(request.reply_port); if (rv < B_OK) return rv; @@ -548,7 +540,7 @@ status_t BBufferProducer::_Reserved_BufferProducer_15(void *) { return B_ERROR; status_t -BBufferProducer::clip_shorts_to_region(const int16 *data, +BBufferProducer::clip_shorts_to_region(const int16 *request, int count, BRegion *output) { @@ -560,7 +552,7 @@ BBufferProducer::clip_shorts_to_region(const int16 *data, status_t BBufferProducer::clip_region_to_shorts(const BRegion *input, - int16 *data, + int16 *request, int max_count, int *out_count) { diff --git a/src/kits/media/DataExchange.cpp b/src/kits/media/DataExchange.cpp index e47197be8f..e5e6d13eb2 100644 --- a/src/kits/media/DataExchange.cpp +++ b/src/kits/media/DataExchange.cpp @@ -41,8 +41,9 @@ initit _initit; void -request_data::SendReply(reply_data *reply, int replysize) const +request_data::SendReply(status_t result, reply_data *reply, int replysize) const { + reply->result = result; SendToPort(reply_port, 0, reply, replysize); } diff --git a/src/kits/media/MediaRoster.cpp b/src/kits/media/MediaRoster.cpp index 72e291b742..47f4624f81 100644 --- a/src/kits/media/MediaRoster.cpp +++ b/src/kits/media/MediaRoster.cpp @@ -49,67 +49,41 @@ status_t GetNode(node_type type, media_node * out_node, int32 * out_input_id, BS if (out_node == NULL) return B_BAD_VALUE; - xfer_server_get_node msg; - xfer_server_get_node_reply reply; - port_id port; + server_get_node_request request; + server_get_node_reply reply; status_t rv; - int32 code; - port = find_port("media_server port"); - if (port <= B_OK) - return B_ERROR; - - msg.type = type; - msg.reply_port = _PortPool->GetPort(); - rv = write_port(port, SERVER_GET_NODE, &msg, sizeof(msg)); - if (rv != B_OK) { - _PortPool->PutPort(msg.reply_port); - return rv; - } - rv = read_port(msg.reply_port, &code, &reply, sizeof(reply)); - _PortPool->PutPort(msg.reply_port); - if (rv < B_OK) + request.type = type; + rv = QueryServer(SERVER_GET_NODE, &request, sizeof(request), &reply, sizeof(reply)); + if (rv != B_OK) return rv; + *out_node = reply.node; if (out_input_id) *out_input_id = reply.input_id; if (out_input_name) *out_input_name = reply.input_name; - return reply.result; + return rv; } status_t SetNode(node_type type, const media_node *node, const dormant_node_info *info, const media_input *input) { - xfer_server_set_node msg; - xfer_server_set_node_reply reply; - port_id port; + server_set_node_request request; + server_set_node_reply reply; status_t rv; - int32 code; - - port = find_port("media_server port"); - if (port <= B_OK) - return B_ERROR; - msg.type = type; - msg.use_node = node ? true : false; + request.type = type; + request.use_node = node ? true : false; if (node) - msg.node = *node; - msg.use_dni = info ? true : false; + request.node = *node; + request.use_dni = info ? true : false; if (info) - msg.dni = *info; - msg.use_input = input ? true : false; + request.dni = *info; + request.use_input = input ? true : false; if (input) - msg.input = *input; - msg.reply_port = _PortPool->GetPort(); - rv = write_port(port, SERVER_SET_NODE, &msg, sizeof(msg)); - if (rv != B_OK) { - _PortPool->PutPort(msg.reply_port); - return rv; - } - rv = read_port(msg.reply_port, &code, &reply, sizeof(reply)); - _PortPool->PutPort(msg.reply_port); - - return (rv < B_OK) ? rv : reply.result; + request.input = *input; + + return QueryServer(SERVER_SET_NODE, &request, sizeof(request), &reply, sizeof(reply)); } }; @@ -310,125 +284,114 @@ BMediaRoster::Connect(const media_source & from, if (to == media_destination::null) return B_MEDIA_BAD_DESTINATION; - xfer_producer_format_proposal msg1; - xfer_producer_format_proposal_reply reply1; - xfer_consumer_accept_format msg2; - xfer_consumer_accept_format_reply reply2; - xfer_producer_prepare_to_connect msg3; - xfer_producer_prepare_to_connect_reply reply3; - xfer_consumer_connected msg4; - xfer_consumer_connected_reply reply4; - xfer_producer_connect msg5; - xfer_producer_connect_reply reply5; - status_t rv; - port_id port; - int32 code; - - port = _PortPool->GetPort(); - - // BBufferProducer::FormatProposal - msg1.output = from; - msg1.format = *io_format; - msg1.reply_port = port; - rv = write_port(from.port, PRODUCER_FORMAT_PROPOSAL, &msg1, sizeof(msg1)); - if (rv != B_OK) - goto failed; - rv = read_port(port, &code, &reply1, sizeof(reply1)); - if (rv < B_OK) - goto failed; - if (reply1.result != B_OK) { - rv = reply1.result; - goto failed; - } - - // BBufferConsumer::AcceptFormat - msg2.dest = to; - msg2.format = *io_format; - msg2.reply_port = port; - rv = write_port(to.port, CONSUMER_ACCEPT_FORMAT, &msg2, sizeof(msg2)); - if (rv != B_OK) - goto failed; - rv = read_port(port, &code, &reply2, sizeof(reply2)); - if (rv < B_OK) - goto failed; - if (reply2.result != B_OK) { - rv = reply2.result; - goto failed; - } - *io_format = reply2.format; + status_t rv; + producer_format_proposal_request request1; + producer_format_proposal_reply reply1; - // BBufferProducer::PrepareToConnect - msg3.source = from; - msg3.destination = to; - msg3.format = *io_format; - msg3.reply_port = port; - rv = write_port(from.port, PRODUCER_PREPARE_TO_CONNECT, &msg3, sizeof(msg3)); - if (rv != B_OK) - goto failed; - rv = read_port(port, &code, &reply3, sizeof(reply3)); - if (rv < B_OK) - goto failed; - if (reply3.result != B_OK) { - rv = reply3.result; - goto failed; + // BBufferProducer::FormatProposal + request1.output = from; + request1.format = *io_format; + rv = QueryPort(from.port, PRODUCER_FORMAT_PROPOSAL, &request1, sizeof(request1), &reply1, sizeof(reply1)); + if (rv != B_OK) { + TRACE("BMediaRoster::Connect: aborted after BBufferProducer::FormatProposal, status = %#x\n",rv); + return rv; } - *io_format = reply3.format; - //reply3.out_source; - //reply3.name; + // reply1.format now contains the format proposed by the producer + + consumer_accept_format_request request2; + consumer_accept_format_reply reply2; + + // BBufferConsumer::AcceptFormat + request2.dest = to; + request2.format = reply1.format; + rv = QueryPort(to.port, CONSUMER_ACCEPT_FORMAT, &request2, sizeof(request2), &reply2, sizeof(reply2)); + if (rv != B_OK) { + TRACE("BMediaRoster::Connect: aborted after BBufferConsumer::AcceptFormat, status = %#x\n",rv); + return rv; + } + // reply2.format now contains the format accepted by the consumer + + // BBufferProducer::PrepareToConnect + producer_prepare_to_connect_request request3; + producer_prepare_to_connect_reply reply3; + + request3.source = from; + request3.destination = to; + request3.format = reply2.format; + strcpy(request3.name, "XXX some default name"); // XXX fix this + rv = QueryPort(from.port, PRODUCER_PREPARE_TO_CONNECT, &request3, sizeof(request3), &reply3, sizeof(reply3)); + if (rv != B_OK) { + TRACE("BMediaRoster::Connect: aborted after BBufferProducer::PrepareToConnect, status = %#x\n",rv); + return rv; + } + // reply3.format is still our pretty media format + // reply3.out_source the real source to be used for the connection + // reply3.name the name BBufferConsumer::Connected will see in the outInput->name argument // BBufferConsumer::Connected - msg4.producer = reply3.out_source; - msg4.where = to; - msg4.with_format = *io_format; - msg4.reply_port = port; - rv = write_port(to.port, CONSUMER_CONNECTED, &msg4, sizeof(msg4)); - if (rv != B_OK) - goto failed; - rv = read_port(port, &code, &reply4, sizeof(reply4)); - if (rv < B_OK) - goto failed; - if (reply4.result != B_OK) { - rv = reply4.result; - goto failed; + consumer_connected_request request4; + consumer_connected_reply reply4; + status_t con_status; + + request4.producer = reply3.out_source; + request4.where = to; + request4.with_format = reply3.format; + con_status = QueryPort(to.port, CONSUMER_CONNECTED, &request4, sizeof(request4), &reply4, sizeof(reply4)); + if (con_status != B_OK) { + TRACE("BMediaRoster::Connect: aborting after BBufferConsumer::Connected, status = %#x\n",con_status); + // we do NOT return here! } - // reply4.input; + // con_status contains the status code to be supplied to BBufferProducer::Connect's status argument + // reply4.input contains the media_input that describes the connection from the consumer point of view // BBufferProducer::Connect - msg5.error = B_OK; - msg5.source = reply3.out_source; - msg5.destination = to; - msg5.format = *io_format; - msg5.name[0] = 0; - msg5.reply_port = port; - - rv = write_port(from.port, PRODUCER_CONNECT, &msg5, sizeof(msg5)); - if (rv != B_OK) - goto failed; - rv = read_port(port, &code, &reply5, sizeof(reply5)); - if (rv < B_OK) - goto failed; + producer_connect_request request5; + producer_connect_reply reply5; -// out_output->node = - out_output->source = reply3.out_source; - out_output->destination = to;//reply4.input; - out_output->format = *io_format; - strcpy(out_output->name,reply5.name); + request5.error = con_status; + request5.source = reply3.out_source; + request5.destination = reply4.input.destination; + request5.format = reply3.format; // XXX reply4.input.format ??? + strcpy(request5.name, reply4.input.name); + rv = QueryPort(reply4.input.node.port, PRODUCER_CONNECT, &request5, sizeof(request5), &reply5, sizeof(reply5)); + if (con_status != B_OK) { + TRACE("BMediaRoster::Connect: aborted\n"); + return con_status; + } + if (rv != B_OK) { + TRACE("BMediaRoster::Connect: aborted after BBufferProducer::Connect, status = %#x\n",rv); + return rv; + } + // reply5.name contains the name assigned to the connection by the producer + + // find the output node + // XXX isn't there a easier way? + media_node sourcenode; + GetNodeFor(NodeIDFor(from.port), &sourcenode); + ReleaseNode(sourcenode); + + // initilize connection info + *io_format = reply3.format; + *out_input = reply4.input; + out_output->node = sourcenode; + out_output->source = reply4.input.source; + out_output->destination = reply4.input.destination; + out_output->format = reply4.input.format; + strcpy(out_output->name, reply5.name); + + // the connection is now made + + + // XXX register connection with server + + + // XXX if (mute) BBufferProducer::EnableOutput(false) -// out_input->node - out_input->source = reply3.out_source; - out_input->destination = to;//reply4.input; - out_input->format = *io_format; - strcpy(out_input->name,reply3.name); - _PortPool->PutPort(port); return B_OK; +}; -failed: - _PortPool->PutPort(port); - return rv; -} - status_t BMediaRoster::Disconnect(media_node_id source_node, const media_source & source, @@ -1071,8 +1034,8 @@ BMediaRoster::InstantiateDormantNode(const dormant_node_info & in_info, // forward this request into the media_addon_server, // which in turn will call InstantiateDormantNode() // to create it there localy - request_addonserver_instantiate_dormant_node request; - reply_addonserver_instantiate_dormant_node reply; + addonserver_instantiate_dormant_node_request request; + addonserver_instantiate_dormant_node_reply reply; status_t rv; request.info = in_info; @@ -1112,6 +1075,7 @@ BMediaRoster::InstantiateDormantNode(const dormant_node_info & in_info, BMediaNode *node; BMessage config; status_t out_error; + status_t rv; addon = _DormantNodeManager->GetAddon(in_info.addon); if (!addon) { printf("BMediaRoster::InstantiateDormantNode: GetAddon failed\n"); @@ -1125,6 +1089,18 @@ BMediaRoster::InstantiateDormantNode(const dormant_node_info & in_info, _DormantNodeManager->PutAddon(in_info.addon); return B_ERROR; } + rv = RegisterNode(node); + if (rv != B_OK) { + printf("BMediaRoster::InstantiateDormantNode: RegisterNode failed\n"); + delete node; + _DormantNodeManager->PutAddon(in_info.addon); + return B_ERROR; + } + + // XXX we must remember in_info.addon and call + // XXX _DormantNodeManager->PutAddon when the + // XXX node is unregistered + *out_node = node->Node(); return B_OK; } diff --git a/src/servers/media/NodeManager.cpp b/src/servers/media/NodeManager.cpp index c11ade54e8..ffc44f5b59 100644 --- a/src/servers/media/NodeManager.cpp +++ b/src/servers/media/NodeManager.cpp @@ -144,4 +144,3 @@ NodeManager::GetDormantFlavorInfoFor(media_addon_id addon, } return B_ERROR; } - diff --git a/src/servers/media/ServerInterface.h b/src/servers/media/ServerInterface.h index c6e180c37d..f280a9e378 100644 --- a/src/servers/media/ServerInterface.h +++ b/src/servers/media/ServerInterface.h @@ -62,18 +62,15 @@ enum { NODE_REGISTERED, NODE_SET_TIMESOURCE, NODE_REQUEST_COMPLETED, - CONSUMER_ACCEPT_FORMAT, CONSUMER_GET_NEXT_INPUT, CONSUMER_DISPOSE_INPUT_COOKIE, CONSUMER_BUFFER_RECEIVED, CONSUMER_PRODUCER_DATA_STATUS, CONSUMER_GET_LATENCY_FOR, - CONSUMER_CONNECTED, CONSUMER_DISCONNECTED, CONSUMER_FORMAT_CHANGED, CONSUMER_SEEK_TAG_REQUESTED, PRODUCER_LATE_NOTICE_RECEIVED, - PRODUCER_ENABLE_OUTPUT, PRODUCER_LATENCY_CHANGED, PRODUCER_ADDITIONAL_BUFFER_REQUESTED, PRODUCER_VIDEO_CLIPPING_CHANGED, @@ -84,37 +81,21 @@ enum { PRODUCER_DISPOSE_OUTPUT_COOKIE, PRODUCER_GET_INITIAL_LATENCY, PRODUCER_FORMAT_SUGGESTION_REQUESTED, - PRODUCER_FORMAT_PROPOSAL, - PRODUCER_PREPARE_TO_CONNECT, - PRODUCER_CONNECT, PRODUCER_DISCONNECT, PRODUCER_SET_PLAY_RATE, + PRODUCER_ENABLE_OUTPUT, ADDONSERVER_INSTANTIATE_DORMANT_NODE, SERVER_REGISTER_MEDIAADDON, SERVER_UNREGISTER_MEDIAADDON, SERVER_GET_MEDIAADDON_REF, ADDONSERVER_RESCAN_MEDIAADDON_FLAVORS, SERVER_REGISTER_DORMANT_NODE, - SERVER_GET_NODE, - SERVER_SET_NODE, TIMESOURCE_OP, // datablock is a struct time_source_op_info SERVER_GET_DORMANT_NODES, SERVER_GET_DORMANT_FLAVOR_INFO, END }; -enum node_type -{ - VIDEO_INPUT, - AUDIO_INPUT, - VIDEO_OUTPUT, - AUDIO_MIXER, - AUDIO_OUTPUT, - AUDIO_OUTPUT_EX, - TIME_SOURCE, - SYSTEM_TIME_SOURCE -}; - /* 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, @@ -182,39 +163,6 @@ struct xfer_server_get_dormant_nodes_reply int32 count; // if count > 0, a second reply containing count dormant_node_infos is send }; -struct xfer_server_set_node -{ - node_type type; - bool use_node; - media_node node; - bool use_dni; - dormant_node_info dni; - bool use_input; - media_input input; - port_id reply_port; -}; - -struct xfer_server_set_node_reply -{ - status_t result; -}; - -struct xfer_server_get_node -{ - node_type type; - port_id reply_port; -}; - -struct xfer_server_get_node_reply -{ - media_node node; - status_t result; - - // for AUDIO_OUTPUT_EX - char input_name[B_MEDIA_NAME_LENGTH]; - int32 input_id; -}; - struct xfer_server_register_dormant_node { media_addon_id purge_id; // if > 0, server must first remove all dormant_flavor_infos belonging to that id @@ -269,49 +217,6 @@ struct xfer_producer_format_suggestion_requested_reply status_t result; }; -struct xfer_producer_format_proposal -{ - media_source output; - media_format format; - port_id reply_port; -}; - -struct xfer_producer_format_proposal_reply -{ - status_t result; -}; - -struct xfer_producer_prepare_to_connect -{ - media_source source; - media_destination destination; - media_format format; - port_id reply_port; -}; - -struct xfer_producer_prepare_to_connect_reply -{ - media_format format; - media_source out_source; - char name[B_MEDIA_NAME_LENGTH]; - status_t result; -}; - -struct xfer_producer_connect -{ - status_t error; - media_source source; - media_destination destination; - media_format format; - char name[B_MEDIA_NAME_LENGTH]; - port_id reply_port; -}; - -struct xfer_producer_connect_reply -{ - char name[B_MEDIA_NAME_LENGTH]; -}; - struct xfer_producer_disconnect { media_source source; @@ -476,19 +381,6 @@ struct xfer_node_set_timesource media_node_id timesource_id; }; -struct xfer_consumer_accept_format -{ - media_destination dest; - media_format format; - port_id reply_port; -}; - -struct xfer_consumer_accept_format_reply -{ - media_format format; - status_t result; -}; - struct xfer_consumer_get_next_input { int32 cookie; @@ -533,19 +425,6 @@ struct xfer_consumer_get_latency_for_reply status_t result; }; -struct xfer_consumer_connected -{ - media_source producer; - media_destination where; - media_format with_format; - port_id reply_port; -}; - -struct xfer_consumer_connected_reply -{ - media_input input; - status_t result; -}; struct xfer_consumer_disconnected { diff --git a/src/servers/media/media_server.cpp b/src/servers/media/media_server.cpp index 82f6cc03e2..fdf2dc112c 100644 --- a/src/servers/media/media_server.cpp +++ b/src/servers/media/media_server.cpp @@ -171,19 +171,19 @@ ServerApp::HandleMessage(int32 code, void *data, size_t size) case SERVER_GET_NODE: { - xfer_server_get_node *msg = (xfer_server_get_node *)data; - xfer_server_get_node_reply reply; - reply.result = B_ERROR; - write_port(msg->reply_port, 0, &reply, sizeof(reply)); + server_get_node_request *request = (server_get_node_request *)data; + server_get_node_reply reply; + // XXX do something here + request->SendReply(B_ERROR, &reply, sizeof(reply)); break; } case SERVER_SET_NODE: { - xfer_server_set_node *msg = (xfer_server_set_node *)data; - xfer_server_set_node_reply reply; - reply.result = B_ERROR; - write_port(msg->reply_port, 0, &reply, sizeof(reply)); + server_set_node_request *request = (server_set_node_request *)data; + server_set_node_reply reply; + // XXX do something here + request->SendReply(B_ERROR, &reply, sizeof(reply)); break; } diff --git a/src/servers/media_addon/main.cpp b/src/servers/media_addon/main.cpp index 336d80d34f..403b9e2d78 100644 --- a/src/servers/media_addon/main.cpp +++ b/src/servers/media_addon/main.cpp @@ -81,10 +81,11 @@ MediaAddonServer::HandleMessage(int32 code, void *data, size_t size) switch (code) { case ADDONSERVER_INSTANTIATE_DORMANT_NODE: { - const request_addonserver_instantiate_dormant_node *msg = (const request_addonserver_instantiate_dormant_node *)data; - reply_addonserver_instantiate_dormant_node reply; - reply.result = mediaroster->InstantiateDormantNode(msg->info, &reply.node); - msg->SendReply(&reply, sizeof(reply)); + const addonserver_instantiate_dormant_node_request *msg = (const addonserver_instantiate_dormant_node_request *)data; + addonserver_instantiate_dormant_node_reply reply; + status_t rv; + rv = mediaroster->InstantiateDormantNode(msg->info, &reply.node); + msg->SendReply(rv, &reply, sizeof(reply)); break; }