i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

rewrote BMediaRoster::Connect() and a few related functions

Browse Source 
git-svn-id: file:///srv/svn/repos/haiku/trunk/current@1347 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
beveloper
2002-10-02 22:12:10 +00:00
parent a7e12e3ed2
commit 8c6a6096e7
9 changed files with 518 additions and 551 deletions
Download Patch File Download Diff File Expand all files Collapse all files
headers/private/media/DataExchange.h
+120 -3
View File
@@ -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
src/kits/media/BufferConsumer.cpp
+131 -129
View File
@@ -9,6 +9,7 @@
#include <Buffer.h>
#include <malloc.h>
#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));
}
src/kits/media/BufferProducer.cpp
+123 -131
View File
@@ -8,6 +8,7 @@
#include <Buffer.h>
#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)
{
src/kits/media/DataExchange.cpp
+2 -1
View File
@@ -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);
}
src/kits/media/MediaRoster.cpp
+128 -152
View File
@@ -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;
}
src/servers/media/NodeManager.cpp
-1
View File
@@ -144,4 +144,3 @@ NodeManager::GetDormantFlavorInfoFor(media_addon_id addon,
}
return B_ERROR;
}
src/servers/media/ServerInterface.h
+1 -122
View File
@@ -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
{
src/servers/media/media_server.cpp
+8 -8
View File
@@ -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;
}
src/servers/media_addon/main.cpp
+5 -4
View File
@@ -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;
}