status_t
BBufferConsumer::RequestAdditionalBuffer(const media_source& source,
bigtime_t startTime, void *_reserved)
{
CALLED();
if (IS_INVALID_SOURCE(source))
return B_MEDIA_BAD_SOURCE;
producer_additional_buffer_requested_command command;
command.source = source;
command.prev_buffer = 0;
command.prev_time = startTime;
command.has_seek_tag = false;
return SendToPort(source.port, PRODUCER_ADDITIONAL_BUFFER_REQUESTED,
&command, sizeof(command));
}
void
BTimeSource::SendRunMode(run_mode mode)
{
CALLED();
ASSERT(fSlaveNodes != NULL);
// send the run mode change to all slaved nodes
BAutolock lock(fSlaveNodes->locker);
for (int i = 0, n = 0; i < SLAVE_NODES_COUNT && n != fSlaveNodes->count; i++) {
if (fSlaveNodes->node_id[i] != 0) {
node_set_run_mode_command cmd;
cmd.mode = mode;
SendToPort(fSlaveNodes->node_port[i], NODE_SET_RUN_MODE, &cmd, sizeof(cmd));
n++;
}
}
}
status_t
BBufferConsumer::SetVideoClippingFor(const media_source& output,
const media_destination& destination, const int16* shorts, int32 shortCount,
const media_video_display_info& display, void* userData, int32* _changeTag,
void *_reserved_)
{
CALLED();
if (IS_INVALID_SOURCE(output))
return B_MEDIA_BAD_SOURCE;
if (IS_INVALID_DESTINATION(destination))
return B_MEDIA_BAD_DESTINATION;
if (shortCount > int(B_MEDIA_MESSAGE_SIZE
- sizeof(producer_video_clipping_changed_command)) / 2) {
debugger("BBufferConsumer::SetVideoClippingFor short_count too large "
"(8000 limit)\n");
}
producer_video_clipping_changed_command* command;
size_t size = sizeof(producer_video_clipping_changed_command)
+ shortCount * sizeof(short);
command
= static_cast<producer_video_clipping_changed_command*>(malloc(size));
if (command == NULL)
return B_NO_MEMORY;
command->source = output;
command->destination = destination;
command->display = display;
command->user_data = userData;
command->change_tag = NewChangeTag();
command->short_count = shortCount;
memcpy(command->shorts, shorts, shortCount * sizeof(short));
if (_changeTag != NULL)
*_changeTag = command->change_tag;
status_t status = SendToPort(output.port, PRODUCER_VIDEO_CLIPPING_CHANGED,
command, size);
free(command);
return status;
}
/*! Deprecated function for BeOS R4.
*/
/*static*/ status_t
BBufferConsumer::SetOutputEnabled(const media_source& source, bool enabled,
int32* _changeTag)
{
CALLED();
if (IS_INVALID_SOURCE(source))
return B_MEDIA_BAD_SOURCE;
producer_enable_output_command command;
command.source = source;
command.destination = media_destination::null;
command.enabled = enabled;
command.user_data = 0;
command.change_tag = NewChangeTag();
if (_changeTag != NULL)
*_changeTag = command.change_tag;
return SendToPort(source.port, PRODUCER_ENABLE_OUTPUT, &command,
sizeof(command));
}
/*! Deprecated function for BeOS R4.
*/
/*static*/ status_t
BBufferConsumer::RequestFormatChange(const media_source& source,
const media_destination& destination, media_format* format,
int32* _changeTag)
{
CALLED();
if (IS_INVALID_SOURCE(source))
return B_MEDIA_BAD_SOURCE;
if (IS_INVALID_DESTINATION(destination))
return B_MEDIA_BAD_DESTINATION;
producer_format_change_requested_command command;
command.source = source;
command.destination = destination;
command.format = *format;
command.user_data = 0;
command.change_tag = NewChangeTag();
if (_changeTag != NULL)
*_changeTag = command.change_tag;
return SendToPort(source.port, PRODUCER_FORMAT_CHANGE_REQUESTED, &command,
sizeof(command));
}
status_t
BBufferConsumer::SendLatencyChange(const media_source& source,
const media_destination& destination, bigtime_t newLatency, uint32 flags)
{
CALLED();
if (IS_INVALID_SOURCE(source))
return B_MEDIA_BAD_SOURCE;
if (IS_INVALID_DESTINATION(destination))
return B_MEDIA_BAD_DESTINATION;
producer_latency_changed_command command;
command.source = source;
command.destination = destination;
command.latency = newLatency;
command.flags = flags;
TRACE("###### BBufferConsumer::SendLatencyChange: latency from %" B_PRId32 "/%" B_PRId32 " to "
"%" B_PRId32 "/%" B_PRId32 " changed to %" B_PRId64 "\n", source.port, source.id,
destination.port, destination.id, newLatency);
return SendToPort(source.port, PRODUCER_LATENCY_CHANGED, &command,
sizeof(command));
}
//! Raw data based data exchange with the media_server
status_t
SendToServer(int32 msgCode, command_data* msg, size_t size)
{
return SendToPort(sMediaServerPort, msgCode, msg, size);
}
status_t
BBufferConsumer::HandleMessage(int32 message, const void* data, size_t size)
{
PRINT(4, "BBufferConsumer::HandleMessage %#lx, node %ld\n", message, ID());
status_t rv;
switch (message) {
case CONSUMER_ACCEPT_FORMAT:
{
const consumer_accept_format_request* request
= static_cast<const consumer_accept_format_request*>(data);
consumer_accept_format_reply reply;
reply.format = request->format;
status_t status = AcceptFormat(request->dest, &reply.format);
request->SendReply(status, &reply, sizeof(reply));
return B_OK;
}
case CONSUMER_GET_NEXT_INPUT:
{
const consumer_get_next_input_request *request = static_cast<const consumer_get_next_input_request *>(data);
consumer_get_next_input_reply reply;
reply.cookie = request->cookie;
rv = GetNextInput(&reply.cookie, &reply.input);
request->SendReply(rv, &reply, sizeof(reply));
return B_OK;
}
case CONSUMER_DISPOSE_INPUT_COOKIE:
{
const consumer_dispose_input_cookie_request *request = static_cast<const consumer_dispose_input_cookie_request *>(data);
consumer_dispose_input_cookie_reply reply;
DisposeInputCookie(request->cookie);
request->SendReply(B_OK, &reply, sizeof(reply));
return B_OK;
}
case CONSUMER_BUFFER_RECEIVED:
{
const consumer_buffer_received_command* command
= static_cast<const consumer_buffer_received_command*>(data);
BBuffer* buffer = fBufferCache->GetBuffer(command->buffer);
if (buffer == NULL) {
ERROR("BBufferConsumer::CONSUMER_BUFFER_RECEIVED can't"
"find the buffer\n");
} else {
buffer->SetHeader(&command->header);
PRINT(4, "calling BBufferConsumer::BufferReceived buffer %ld "
"at perf %Ld and TimeSource()->Now() is %Ld\n",
buffer->Header()->buffer, buffer->Header()->start_time,
TimeSource()->Now());
BufferReceived(buffer);
}
return B_OK;
}
case CONSUMER_PRODUCER_DATA_STATUS:
{
const consumer_producer_data_status_command *command = static_cast<const consumer_producer_data_status_command *>(data);
ProducerDataStatus(command->for_whom, command->status, command->at_performance_time);
return B_OK;
}
case CONSUMER_GET_LATENCY_FOR:
{
const consumer_get_latency_for_request *request = static_cast<const consumer_get_latency_for_request *>(data);
consumer_get_latency_for_reply reply;
rv = GetLatencyFor(request->for_whom, &reply.latency, &reply.timesource);
request->SendReply(rv, &reply, sizeof(reply));
return B_OK;
}
case CONSUMER_CONNECTED:
{
const consumer_connected_request *request = static_cast<const consumer_connected_request *>(data);
consumer_connected_reply reply;
reply.input = request->input;
rv = Connected(request->input.source, request->input.destination, request->input.format, &reply.input);
request->SendReply(rv, &reply, sizeof(reply));
return B_OK;
}
case CONSUMER_DISCONNECTED:
{
const consumer_disconnected_request *request = static_cast<const consumer_disconnected_request *>(data);
consumer_disconnected_reply reply;
Disconnected(request->source, request->destination);
request->SendReply(B_OK, &reply, sizeof(reply));
return B_OK;
}
case CONSUMER_FORMAT_CHANGED:
{
const consumer_format_changed_request *request = static_cast<const consumer_format_changed_request *>(data);
consumer_format_changed_reply reply;
rv = FormatChanged(request->producer, request->consumer, request->change_tag, request->format);
request->SendReply(rv, &reply, sizeof(reply));
// XXX is this RequestCompleted() correct?
node_request_completed_command completedcommand;
completedcommand.info.what = media_request_info::B_FORMAT_CHANGED;
completedcommand.info.change_tag = request->change_tag;
completedcommand.info.status = reply.result;
//completedcommand.info.cookie
completedcommand.info.user_data = 0;
completedcommand.info.source = request->producer;
completedcommand.info.destination = request->consumer;
completedcommand.info.format = request->format;
SendToPort(request->consumer.port, NODE_REQUEST_COMPLETED, &completedcommand, sizeof(completedcommand));
return B_OK;
}
case CONSUMER_SEEK_TAG_REQUESTED:
{
const consumer_seek_tag_requested_request *request = static_cast<const consumer_seek_tag_requested_request *>(data);
consumer_seek_tag_requested_reply reply;
rv = SeekTagRequested(request->destination, request->target_time, request->flags, &reply.seek_tag, &reply.tagged_time, &reply.flags);
request->SendReply(rv, &reply, sizeof(reply));
return B_OK;
}
}
return B_ERROR;
}
