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

* Cleaned up the node manager, got rid of its use of Map, and List.

Browse Source 
* Fixed at least two reference counting problems, but nodes from killed teams
  still remain alive (will look into this at a later point).
* GetLiveNodes() is now using transfer_area() as well.
* Made all sizes in the SendTo*() and Query*() functions size_t.
* Replaced reinterpret_casts with static_casts when casting void pointers.
* Ordered the request/reply structures by target.
* Tried to consolidate the use of add_on vs. addon.
* More cleanup.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@34591 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Axel Dörfler
2009-12-09 16:22:24 +00:00
parent 951be023f9
commit 9c3b4706dd
13 changed files with 1799 additions and 1480 deletions
Download Patch File Download Diff File Expand all files Collapse all files
headers/private/media/DataExchange.h
+316 -284
View File
@@ -27,24 +27,24 @@ struct request_data;
struct command_data;
// BMessage based data exchange with the media_server
status_t SendToServer(BMessage *msg);
status_t QueryServer(BMessage &request, BMessage &reply);
status_t SendToServer(BMessage* msg);
status_t QueryServer(BMessage& request, BMessage& reply);
// Raw data based data exchange with the media_server
status_t SendToServer(int32 msgcode, command_data *msg, int size);
status_t QueryServer(int32 msgcode, request_data *request, int requestsize,
reply_data *reply, int replysize);
status_t SendToServer(int32 msgCode, command_data* msg, size_t size);
status_t QueryServer(int32 msgCode, request_data* request, size_t requestSize,
reply_data* reply, size_t replySize);
// Raw data based data exchange with the media_addon_server
status_t SendToAddonServer(int32 msgcode, command_data *msg, int size);
status_t QueryAddonServer(int32 msgcode, request_data *request, int requestSize,
reply_data *reply, int replysize);
status_t SendToAddOnServer(int32 msgCode, command_data *msg, size_t size);
status_t QueryAddOnServer(int32 msgCode, request_data* request,
size_t requestSize, reply_data* reply, size_t replySize);
// Raw data based data exchange with any (media node control-) port
status_t SendToPort(port_id sendport, int32 msgcode, command_data *msg,
int size);
status_t QueryPort(port_id requestport, int32 msgcode, request_data *request,
int requestsize, reply_data *reply, int replysize);
status_t SendToPort(port_id sendPort, int32 msgCode, command_data* msg,
size_t size);
status_t QueryPort(port_id requestPort, int32 msgCode, request_data* request,
size_t requestSize, reply_data* reply, size_t replySize);
// The base struct used for all raw requests
struct request_data {
@@ -104,14 +104,14 @@ enum {
// add_system_beep_event()
MEDIA_SERVER_ADD_SYSTEM_BEEP_EVENT,
// media addon server
MEDIA_ADDON_SERVER_PLAY_MEDIA = '_TRU'
// media add-on server
MEDIA_ADD_ON_SERVER_PLAY_MEDIA = '_TRU'
};
// Raw port based communication
enum {
ADDONSERVER_RESCAN_MEDIAADDON_FLAVORS = 0x50,
ADDONSERVER_RESCAN_FINISHED_NOTIFY,
ADD_ON_SERVER_RESCAN_ADD_ON_FLAVORS = 0x50,
ADD_ON_SERVER_RESCAN_FINISHED_NOTIFY,
SERVER_MESSAGE_START = 0x100,
SERVER_REGISTER_APP,
@@ -134,7 +134,7 @@ enum {
SERVER_UNREGISTER_BUFFER,
SERVER_RESCAN_DEFAULTS,
SERVER_SET_NODE_CREATOR,
SERVER_CHANGE_ADDON_FLAVOR_INSTANCES_COUNT,
SERVER_CHANGE_FLAVOR_INSTANCES_COUNT,
SERVER_GET_MEDIA_FILE_TYPES,
SERVER_GET_MEDIA_FILE_ITEMS,
SERVER_GET_REF_FOR,
@@ -294,16 +294,31 @@ enum {
MAX_READERS = 40,
};
struct addonserver_instantiate_dormant_node_request : request_data {
media_addon_id addon_id;
// #pragma mark - media add-on server commands
struct add_on_server_instantiate_dormant_node_request : request_data {
media_addon_id add_on_id;
int32 flavor_id;
team_id creator_team;
};
struct addonserver_instantiate_dormant_node_reply : reply_data {
struct add_on_server_instantiate_dormant_node_reply : reply_data {
media_node node;
};
struct add_on_server_rescan_flavors_command : command_data {
media_addon_id add_on_id;
};
struct add_on_server_rescan_finished_notify_command : command_data {
};
// #pragma mark - media server commands
struct server_set_node_request : request_data {
node_type type;
bool use_node;
@@ -330,158 +345,6 @@ struct server_get_node_reply : public reply_data {
int32 input_id;
};
struct producer_format_proposal_request : public request_data {
media_source output;
media_format format;
};
struct producer_format_proposal_reply : reply_data {
media_format format;
};
struct producer_prepare_to_connect_request : request_data {
media_source source;
media_destination destination;
media_format format;
char name[B_MEDIA_NAME_LENGTH];
};
struct producer_prepare_to_connect_reply : reply_data {
media_format format;
media_source out_source;
char name[B_MEDIA_NAME_LENGTH];
};
struct producer_connect_request : request_data {
status_t error;
media_source source;
media_destination destination;
media_format format;
char name[B_MEDIA_NAME_LENGTH];
};
struct producer_connect_reply : reply_data {
char name[B_MEDIA_NAME_LENGTH];
};
struct producer_disconnect_request : request_data {
media_source source;
media_destination destination;
};
struct producer_disconnect_reply : reply_data {
};
struct producer_format_suggestion_requested_request : request_data {
media_type type;
int32 quality;
};
struct producer_format_suggestion_requested_reply : reply_data {
media_format format;
};
struct producer_set_play_rate_request : request_data {
int32 numer;
int32 denom;
};
struct producer_set_play_rate_reply : reply_data {
};
struct producer_get_initial_latency_request : request_data {
};
struct producer_get_initial_latency_reply : reply_data {
bigtime_t initial_latency;
uint32 flags;
};
struct producer_get_latency_request : request_data {
};
struct producer_get_latency_reply : reply_data {
bigtime_t latency;
};
struct producer_set_buffer_group_command : command_data {
media_source source;
media_destination destination;
void* user_data;
int32 change_tag;
int32 buffer_count;
media_buffer_id buffers[1];
};
struct producer_format_change_requested_command : command_data {
media_source source;
media_destination destination;
media_format format;
void* user_data;
int32 change_tag;
};
struct producer_video_clipping_changed_command : command_data {
media_source source;
media_destination destination;
media_video_display_info display;
void* user_data;
int32 change_tag;
int32 short_count;
int16 shorts[1];
};
struct producer_additional_buffer_requested_command : command_data {
media_source source;
media_buffer_id prev_buffer;
bigtime_t prev_time;
bool has_seek_tag;
media_seek_tag prev_tag;
};
struct producer_latency_changed_command : command_data {
media_source source;
media_destination destination;
bigtime_t latency;
uint32 flags;
};
struct producer_enable_output_command : command_data {
media_source source;
media_destination destination;
bool enabled;
void* user_data;
int32 change_tag;
};
struct producer_late_notice_received_command : command_data {
media_source source;
bigtime_t how_much;
bigtime_t performance_time;
};
struct producer_set_run_mode_delay_command : command_data {
BMediaNode::run_mode mode;
bigtime_t delay;
};
struct consumer_accept_format_request : request_data {
media_destination dest;
media_format format;
};
struct consumer_accept_format_reply : reply_data {
media_format format;
};
struct consumer_connected_request : request_data {
media_input input;
};
struct consumer_connected_reply : reply_data {
media_input input;
};
struct server_publish_inputs_request : request_data {
media_node node;
int32 count;
@@ -506,90 +369,6 @@ struct server_publish_outputs_request : area_request_data {
struct server_publish_outputs_reply : reply_data {
};
struct producer_get_next_output_request : request_data {
int32 cookie;
};
struct producer_get_next_output_reply : reply_data
{
int32 cookie;
media_output output;
};
struct producer_dispose_output_cookie_request : request_data
{
int32 cookie;
};
struct producer_dispose_output_cookie_reply : reply_data {
};
struct consumer_get_next_input_request : request_data {
int32 cookie;
};
struct consumer_get_next_input_reply : reply_data {
int32 cookie;
media_input input;
};
struct consumer_dispose_input_cookie_request : request_data {
int32 cookie;
};
struct consumer_dispose_input_cookie_reply : reply_data {
};
struct consumer_disconnected_request : request_data {
media_source source;
media_destination destination;
};
struct consumer_disconnected_reply : reply_data {
};
struct consumer_buffer_received_command : command_data {
media_buffer_id buffer;
media_header header;
};
struct consumer_producer_data_status_command : command_data {
media_destination for_whom;
int32 status;
bigtime_t at_performance_time;
};
struct consumer_get_latency_for_request : request_data {
media_destination for_whom;
};
struct consumer_get_latency_for_reply : reply_data {
bigtime_t latency;
media_node_id timesource;
};
struct consumer_format_changed_request : request_data {
media_source producer;
media_destination consumer;
int32 change_tag;
media_format format;
};
struct consumer_format_changed_reply : reply_data {
};
struct consumer_seek_tag_requested_request : request_data {
media_destination destination;
bigtime_t target_time;
uint32 flags;
};
struct consumer_seek_tag_requested_reply : reply_data {
media_seek_tag seek_tag;
bigtime_t tagged_time;
uint32 flags;
};
struct server_register_app_request : request_data {
team_id team;
BMessenger messenger;
@@ -613,19 +392,19 @@ struct server_set_node_creator_request : request_data {
struct server_set_node_creator_reply : reply_data {
};
struct server_change_addon_flavor_instances_count_request : request_data {
media_addon_id addon_id;
struct server_change_flavor_instances_count_request : request_data {
media_addon_id add_on_id;
int32 flavor_id;
int32 delta; // must be +1 or -1
team_id team;
};
struct server_change_addon_flavor_instances_count_reply : reply_data {
struct server_change_flavor_instances_count_reply : reply_data {
};
struct server_register_node_request : request_data {
media_addon_id addon_id;
int32 addon_flavor_id;
media_addon_id add_on_id;
int32 flavor_id;
char name[B_MEDIA_NAME_LENGTH];
uint64 kinds;
port_id port;
@@ -642,7 +421,7 @@ struct server_unregister_node_request : request_data {
};
struct server_unregister_node_reply : reply_data {
media_addon_id addon_id;
media_addon_id add_on_id;
int32 flavor_id;
};
@@ -654,13 +433,13 @@ struct server_get_live_node_info_reply : reply_data {
live_node_info live_info;
};
struct server_get_live_nodes_request : request_data {
int32 maxcount;
struct server_get_live_nodes_request : request_area_data {
int32 max_count;
bool has_input;
bool has_output;
bool has_name;
media_format inputformat;
media_format outputformat;
media_format input_format;
media_format output_format;
char name[B_MEDIA_NAME_LENGTH + 1];
// +1 for a trailing "*"
uint64 require_kinds;
@@ -707,9 +486,9 @@ struct server_get_dormant_node_for_reply : reply_data {
};
struct server_get_instances_for_request : request_data {
int32 maxcount;
media_addon_id addon_id;
int32 addon_flavor_id;
media_addon_id add_on_id;
int32 flavor_id;
int32 max_count;
};
struct server_get_instances_for_reply : reply_data {
@@ -721,30 +500,23 @@ struct server_get_instances_for_reply : reply_data {
struct server_rescan_defaults_command : command_data {
};
struct addonserver_rescan_mediaaddon_flavors_command : command_data {
media_addon_id addon_id;
};
struct addonserver_rescan_finished_notify_command : command_data {
};
struct server_register_mediaaddon_request : request_data {
struct server_register_add_on_request : request_data {
xfer_entry_ref ref;
};
struct server_register_mediaaddon_reply : reply_data {
media_addon_id addon_id;
struct server_register_add_on_reply : reply_data {
media_addon_id add_on_id;
};
struct server_unregister_mediaaddon_command : command_data {
media_addon_id addon_id;
struct server_unregister_add_on_command : command_data {
media_addon_id add_on_id;
};
struct server_get_mediaaddon_ref_request : request_data {
media_addon_id addon_id;
struct server_get_add_on_ref_request : request_data {
media_addon_id add_on_id;
};
struct server_get_mediaaddon_ref_reply : reply_data {
struct server_get_add_on_ref_reply : reply_data {
xfer_entry_ref ref;
};
@@ -893,6 +665,254 @@ struct server_get_codec_info_reply : reply_data {
// the codec info matching the cookie
};
// #pragma mark - buffer producer commands
struct producer_format_proposal_request : public request_data {
media_source output;
media_format format;
};
struct producer_format_proposal_reply : reply_data {
media_format format;
};
struct producer_prepare_to_connect_request : request_data {
media_source source;
media_destination destination;
media_format format;
char name[B_MEDIA_NAME_LENGTH];
};
struct producer_prepare_to_connect_reply : reply_data {
media_format format;
media_source out_source;
char name[B_MEDIA_NAME_LENGTH];
};
struct producer_connect_request : request_data {
status_t error;
media_source source;
media_destination destination;
media_format format;
char name[B_MEDIA_NAME_LENGTH];
};
struct producer_connect_reply : reply_data {
char name[B_MEDIA_NAME_LENGTH];
};
struct producer_disconnect_request : request_data {
media_source source;
media_destination destination;
};
struct producer_disconnect_reply : reply_data {
};
struct producer_format_suggestion_requested_request : request_data {
media_type type;
int32 quality;
};
struct producer_format_suggestion_requested_reply : reply_data {
media_format format;
};
struct producer_set_play_rate_request : request_data {
int32 numer;
int32 denom;
};
struct producer_set_play_rate_reply : reply_data {
};
struct producer_get_initial_latency_request : request_data {
};
struct producer_get_initial_latency_reply : reply_data {
bigtime_t initial_latency;
uint32 flags;
};
struct producer_get_latency_request : request_data {
};
struct producer_get_latency_reply : reply_data {
bigtime_t latency;
};
struct producer_set_buffer_group_command : command_data {
media_source source;
media_destination destination;
void* user_data;
int32 change_tag;
int32 buffer_count;
media_buffer_id buffers[1];
};
struct producer_format_change_requested_command : command_data {
media_source source;
media_destination destination;
media_format format;
void* user_data;
int32 change_tag;
};
struct producer_video_clipping_changed_command : command_data {
media_source source;
media_destination destination;
media_video_display_info display;
void* user_data;
int32 change_tag;
int32 short_count;
int16 shorts[1];
};
struct producer_additional_buffer_requested_command : command_data {
media_source source;
media_buffer_id prev_buffer;
bigtime_t prev_time;
bool has_seek_tag;
media_seek_tag prev_tag;
};
struct producer_latency_changed_command : command_data {
media_source source;
media_destination destination;
bigtime_t latency;
uint32 flags;
};
struct producer_enable_output_command : command_data {
media_source source;
media_destination destination;
bool enabled;
void* user_data;
int32 change_tag;
};
struct producer_late_notice_received_command : command_data {
media_source source;
bigtime_t how_much;
bigtime_t performance_time;
};
struct producer_set_run_mode_delay_command : command_data {
BMediaNode::run_mode mode;
bigtime_t delay;
};
struct producer_get_next_output_request : request_data {
int32 cookie;
};
struct producer_get_next_output_reply : reply_data
{
int32 cookie;
media_output output;
};
struct producer_dispose_output_cookie_request : request_data
{
int32 cookie;
};
struct producer_dispose_output_cookie_reply : reply_data {
};
// #pragma mark - buffer consumer commands
struct consumer_accept_format_request : request_data {
media_destination dest;
media_format format;
};
struct consumer_accept_format_reply : reply_data {
media_format format;
};
struct consumer_connected_request : request_data {
media_input input;
};
struct consumer_connected_reply : reply_data {
media_input input;
};
struct consumer_get_next_input_request : request_data {
int32 cookie;
};
struct consumer_get_next_input_reply : reply_data {
int32 cookie;
media_input input;
};
struct consumer_dispose_input_cookie_request : request_data {
int32 cookie;
};
struct consumer_dispose_input_cookie_reply : reply_data {
};
struct consumer_disconnected_request : request_data {
media_source source;
media_destination destination;
};
struct consumer_disconnected_reply : reply_data {
};
struct consumer_buffer_received_command : command_data {
media_buffer_id buffer;
media_header header;
};
struct consumer_producer_data_status_command : command_data {
media_destination for_whom;
int32 status;
bigtime_t at_performance_time;
};
struct consumer_get_latency_for_request : request_data {
media_destination for_whom;
};
struct consumer_get_latency_for_reply : reply_data {
bigtime_t latency;
media_node_id timesource;
};
struct consumer_format_changed_request : request_data {
media_source producer;
media_destination consumer;
int32 change_tag;
media_format format;
};
struct consumer_format_changed_reply : reply_data {
};
struct consumer_seek_tag_requested_request : request_data {
media_destination destination;
bigtime_t target_time;
uint32 flags;
};
struct consumer_seek_tag_requested_reply : reply_data {
media_seek_tag seek_tag;
bigtime_t tagged_time;
uint32 flags;
};
// #pragma mark - node commands
struct node_request_completed_command : command_data {
media_request_info info;
};
@@ -934,6 +954,10 @@ struct node_get_timesource_reply : reply_data {
struct node_final_release_command : command_data {
};
// #pragma mark - time source commands
struct timesource_add_slave_node_command : command_data {
media_node node;
};
@@ -949,6 +973,10 @@ struct timesource_get_start_latency_reply : reply_data {
bigtime_t start_latency;
};
// #pragma mark - file interface commands
struct fileinterface_set_ref_request : request_data {
dev_t device;
ino_t directory;
@@ -982,6 +1010,10 @@ struct fileinterface_sniff_ref_reply : reply_data {
float capability;
};
// #pragma mark - controllable commands
struct controllable_get_parameter_web_request : area_request_data {
int32 max_size;
};
headers/private/media/ServerInterface.h
+4 -4
View File
@@ -14,10 +14,10 @@
enum {
ADDONSERVER_INSTANTIATE_DORMANT_NODE,
SERVER_REGISTER_MEDIAADDON,
SERVER_UNREGISTER_MEDIAADDON,
SERVER_GET_MEDIAADDON_REF,
ADD_ON_SERVER_INSTANTIATE_DORMANT_NODE,
SERVER_REGISTER_ADD_ON,
SERVER_UNREGISTER_ADD_ON,
SERVER_GET_ADD_ON_REF,
SERVER_REGISTER_DORMANT_NODE,
SERVER_GET_DORMANT_NODES,
SERVER_GET_DORMANT_FLAVOR_INFO,
src/kits/media/DataExchange.cpp
+91 -75
View File
@@ -26,55 +26,55 @@ namespace media {
namespace dataexchange {
BMessenger* MediaServerMessenger;
static port_id MediaServerPort;
static port_id MediaAddonServerPort;
BMessenger* gMediaServerMessenger;
static port_id sMediaServerPort;
static port_id sMediaAddonServerPort;
void find_media_server_port();
void find_media_addon_server_port();
static void find_media_server_port();
static void find_media_addon_server_port();
static BMessenger*
GetMediaServerMessenger()
{
static BMessenger* messenger = new BMessenger(B_MEDIA_SERVER_SIGNATURE);
return MediaServerMessenger = messenger;
return gMediaServerMessenger = messenger;
}
class initit {
public:
initit()
{
MediaServerMessenger = 0;
gMediaServerMessenger = 0;
find_media_server_port();
find_media_addon_server_port();
}
~initit()
{
delete MediaServerMessenger;
delete gMediaServerMessenger;
}
};
initit _initit;
void
static void
find_media_server_port()
{
MediaServerPort = find_port(MEDIA_SERVER_PORT_NAME);
if (MediaServerPort < 0) {
ERROR("couldn't find MediaServerPort\n");
MediaServerPort = BAD_MEDIA_SERVER_PORT; // make this a unique number
sMediaServerPort = find_port(MEDIA_SERVER_PORT_NAME);
if (sMediaServerPort < 0) {
ERROR("couldn't find sMediaServerPort\n");
sMediaServerPort = BAD_MEDIA_SERVER_PORT; // make this a unique number
}
}
void
static void
find_media_addon_server_port()
{
MediaAddonServerPort = find_port(MEDIA_ADDON_SERVER_PORT_NAME);
if (MediaAddonServerPort < 0) {
ERROR("couldn't find MediaAddonServerPort\n");
MediaAddonServerPort = BAD_MEDIA_ADDON_SERVER_PORT; // make this a unique number
sMediaAddonServerPort = find_port(MEDIA_ADDON_SERVER_PORT_NAME);
if (sMediaAddonServerPort < 0) {
ERROR("couldn't find sMediaAddonServerPort\n");
sMediaAddonServerPort = BAD_MEDIA_ADDON_SERVER_PORT; // make this a unique number
}
}
@@ -90,26 +90,27 @@ request_data::SendReply(status_t result, reply_data *reply,
}
// BMessage based data exchange with the media_server
//! BMessage based data exchange with the media_server
status_t
SendToServer(BMessage *msg)
SendToServer(BMessage* msg)
{
status_t rv;
rv = GetMediaServerMessenger()->SendMessage(msg, static_cast<BHandler *>(NULL), TIMEOUT);
if (rv != B_OK) {
ERROR("SendToServer: SendMessage failed, error 0x%08lx (%s)\n", rv, strerror(rv));
status_t status = GetMediaServerMessenger()->SendMessage(msg,
static_cast<BHandler*>(NULL), TIMEOUT);
if (status != B_OK) {
ERROR("SendToServer: SendMessage failed: %s\n", strerror(status));
DEBUG_ONLY(msg->PrintToStream());
}
return rv;
return status;
}
status_t
QueryServer(BMessage &request, BMessage &reply)
QueryServer(BMessage& request, BMessage& reply)
{
status_t status = GetMediaServerMessenger()->SendMessage(&request, &reply, TIMEOUT, TIMEOUT);
status_t status = GetMediaServerMessenger()->SendMessage(&request, &reply,
TIMEOUT, TIMEOUT);
if (status != B_OK) {
ERROR("QueryServer: SendMessage failed, error 0x%08lx (%s)\n", status, strerror(status));
ERROR("QueryServer: SendMessage failed: %s\n", strerror(status));
DEBUG_ONLY(request.PrintToStream());
DEBUG_ONLY(reply.PrintToStream());
}
@@ -117,58 +118,64 @@ QueryServer(BMessage &request, BMessage &reply)
}
// Raw data based data exchange with the media_server
//! Raw data based data exchange with the media_server
status_t
SendToServer(int32 msgcode, command_data *msg, int size)
SendToServer(int32 msgCode, command_data* msg, size_t size)
{
return SendToPort(MediaServerPort, msgcode, msg, size);
return SendToPort(sMediaServerPort, msgCode, msg, size);
}
status_t
QueryServer(int32 msgcode, request_data *request, int requestsize, reply_data *reply, int replysize)
QueryServer(int32 msgCode, request_data* request, size_t requestSize,
reply_data* reply, size_t replySize)
{
return QueryPort(MediaServerPort, msgcode, request, requestsize, reply, replysize);
return QueryPort(sMediaServerPort, msgCode, request, requestSize, reply,
replySize);
}
// Raw data based data exchange with the media_addon_server
//! Raw data based data exchange with the media_addon_server
status_t
SendToAddonServer(int32 msgcode, command_data *msg, int size)
SendToAddOnServer(int32 msgCode, command_data* msg, size_t size)
{
return SendToPort(MediaAddonServerPort, msgcode, msg, size);
return SendToPort(sMediaAddonServerPort, msgCode, msg, size);
}
status_t
QueryAddonServer(int32 msgcode, request_data *request, int requestsize, reply_data *reply, int replysize)
QueryAddOnServer(int32 msgCode, request_data* request, size_t requestSize,
reply_data* reply, size_t replySize)
{
return QueryPort(MediaAddonServerPort, msgcode, request, requestsize, reply, replysize);
return QueryPort(sMediaAddonServerPort, msgCode, request, requestSize,
reply, replySize);
}
// Raw data based data exchange with the media_server
//! Raw data based data exchange with the media_server
status_t
SendToPort(port_id sendport, int32 msgcode, command_data *msg, int size)
SendToPort(port_id sendPort, int32 msgCode, command_data* msg, size_t size)
{
status_t rv;
rv = write_port_etc(sendport, msgcode, msg, size, B_RELATIVE_TIMEOUT, TIMEOUT);
if (rv != B_OK) {
ERROR("SendToPort: write_port failed, msgcode 0x%lx, port %ld, error %#lx (%s)\n", msgcode, sendport, rv, strerror(rv));
if (rv == B_BAD_PORT_ID && sendport == MediaServerPort) {
status_t status = write_port_etc(sendPort, msgCode, msg, size,
B_RELATIVE_TIMEOUT, TIMEOUT);
if (status != B_OK) {
ERROR("SendToPort: write_port failed, msgcode 0x%lx, port %ld: %s\n",
msgCode, sendPort, strerror(status));
if (status == B_BAD_PORT_ID && sendPort == sMediaServerPort) {
find_media_server_port();
sendport = MediaServerPort;
} else if (rv == B_BAD_PORT_ID && sendport == MediaAddonServerPort) {
sendPort = sMediaServerPort;
} else if (status == B_BAD_PORT_ID
&& sendPort == sMediaAddonServerPort) {
find_media_addon_server_port();
sendport = MediaAddonServerPort;
} else {
return rv;
}
sendPort = sMediaAddonServerPort;
} else
return status;
rv = write_port_etc(sendport, msgcode, msg, size, B_RELATIVE_TIMEOUT, TIMEOUT);
if (rv != B_OK) {
ERROR("SendToPort: retrying write_port failed, msgcode 0x%lx, port %ld, error %#lx (%s)\n", msgcode, sendport, rv, strerror(rv));
return rv;
status = write_port_etc(sendPort, msgCode, msg, size,
B_RELATIVE_TIMEOUT, TIMEOUT);
if (status != B_OK) {
ERROR("SendToPort: retrying write_port failed, msgCode 0x%lx, "
"port %ld: %s\n", msgCode, sendPort, strerror(status));
return status;
}
}
return B_OK;
@@ -176,46 +183,55 @@ SendToPort(port_id sendport, int32 msgcode, command_data *msg, int size)
status_t
QueryPort(port_id requestport, int32 msgcode, request_data *request, int requestsize, reply_data *reply, int replysize)
QueryPort(port_id requestPort, int32 msgCode, request_data* request,
size_t requestSize, reply_data* reply, size_t replySize)
{
status_t rv;
int32 code;
request->reply_port = gPortPool->GetPort();
rv = write_port_etc(requestport, msgcode, request, requestsize, B_RELATIVE_TIMEOUT, TIMEOUT);
status_t status = write_port_etc(requestPort, msgCode, request, requestSize,
B_RELATIVE_TIMEOUT, TIMEOUT);
if (status != B_OK) {
ERROR("QueryPort: write_port failed, msgcode 0x%lx, port %ld: %s\n",
msgCode, requestPort, strerror(status));
if (rv != B_OK) {
ERROR("QueryPort: write_port failed, msgcode 0x%lx, port %ld, error %#lx (%s)\n", msgcode, requestport, rv, strerror(rv));
if (rv == B_BAD_PORT_ID && requestport == MediaServerPort) {
if (status == B_BAD_PORT_ID && requestPort == sMediaServerPort) {
find_media_server_port();
requestport = MediaServerPort;
} else if (rv == B_BAD_PORT_ID && requestport == MediaAddonServerPort) {
requestPort = sMediaServerPort;
} else if (status == B_BAD_PORT_ID
&& requestPort == sMediaAddonServerPort) {
find_media_addon_server_port();
requestport = MediaAddonServerPort;
requestPort = sMediaAddonServerPort;
} else {
gPortPool->PutPort(request->reply_port);
return rv;
return status;
}
rv = write_port_etc(requestport, msgcode, request, requestsize, B_RELATIVE_TIMEOUT, TIMEOUT);
if (rv != B_OK) {
ERROR("QueryPort: retrying write_port failed, msgcode 0x%lx, port %ld, error %#lx (%s)\n", msgcode, requestport, rv, strerror(rv));
status = write_port_etc(requestPort, msgCode, request, requestSize,
B_RELATIVE_TIMEOUT, TIMEOUT);
if (status != B_OK) {
ERROR("QueryPort: retrying write_port failed, msgcode 0x%lx, port "
"%ld: %s\n", msgCode, requestPort, strerror(status));
gPortPool->PutPort(request->reply_port);
return rv;
return status;
}
}
rv = read_port_etc(request->reply_port, &code, reply, replysize, B_RELATIVE_TIMEOUT, TIMEOUT);
int32 code;
status = read_port_etc(request->reply_port, &code, reply, replySize,
B_RELATIVE_TIMEOUT, TIMEOUT);
gPortPool->PutPort(request->reply_port);
if (rv < B_OK) {
ERROR("QueryPort: read_port failed, msgcode 0x%lx, port %ld, error %#lx (%s)\n", msgcode, request->reply_port, rv, strerror(rv));
if (status < B_OK) {
ERROR("QueryPort: read_port failed, msgcode 0x%lx, port %ld: %s\n",
msgCode, request->reply_port, strerror(status));
}
return (rv < B_OK) ? rv : reply->result;
return status < B_OK ? status : reply->result;
}
} // dataexchange
} // media
} // BPrivate
src/kits/media/DormantNodeManager.cpp
+12 -12
View File
@@ -197,7 +197,7 @@ DormantNodeManager::RegisterAddOn(const char* path)
{
TRACE("DormantNodeManager::RegisterAddon, path %s\n",path);
server_register_mediaaddon_request msg;
server_register_add_on_request msg;
entry_ref ref;
status_t status = get_ref_for_path(path, &ref);
if (status != B_OK) {
@@ -216,7 +216,7 @@ DormantNodeManager::RegisterAddOn(const char* path)
msg.reply_port = gPortPool->GetPort();
msg.ref = ref;
status = write_port(port, SERVER_REGISTER_MEDIAADDON, &msg, sizeof(msg));
status = write_port(port, SERVER_REGISTER_ADD_ON, &msg, sizeof(msg));
if (status != B_OK) {
gPortPool->PutPort(msg.reply_port);
ERROR("DormantNodeManager::RegisterAddon failed, couldn't talk to "
@@ -224,7 +224,7 @@ DormantNodeManager::RegisterAddOn(const char* path)
return 0;
}
server_register_mediaaddon_reply reply;
server_register_add_on_reply reply;
int32 code;
status = read_port(msg.reply_port, &code, &reply, sizeof(reply));
@@ -237,9 +237,9 @@ DormantNodeManager::RegisterAddOn(const char* path)
}
TRACE("DormantNodeManager::RegisterAddon finished with id %ld\n",
reply.addon_id);
reply.add_on_id);
return reply.addon_id;
return reply.add_on_id;
}
@@ -254,9 +254,9 @@ DormantNodeManager::UnregisterAddOn(media_addon_id id)
if (port < 0)
return;
server_unregister_mediaaddon_command msg;
msg.addon_id = id;
write_port(port, SERVER_UNREGISTER_MEDIAADDON, &msg, sizeof(msg));
server_unregister_add_on_command msg;
msg.add_on_id = id;
write_port(port, SERVER_UNREGISTER_ADD_ON, &msg, sizeof(msg));
}
@@ -267,17 +267,17 @@ DormantNodeManager::FindAddOnPath(BPath* path, media_addon_id id)
if (port < 0)
return B_ERROR;
server_get_mediaaddon_ref_request msg;
msg.addon_id = id;
server_get_add_on_ref_request msg;
msg.add_on_id = id;
msg.reply_port = gPortPool->GetPort();
status_t status = write_port(port, SERVER_GET_MEDIAADDON_REF, &msg,
status_t status = write_port(port, SERVER_GET_ADD_ON_REF, &msg,
sizeof(msg));
if (status != B_OK) {
gPortPool->PutPort(msg.reply_port);
return status;
}
server_get_mediaaddon_ref_reply reply;
server_get_add_on_ref_reply reply;
int32 code;
status = read_port(msg.reply_port, &code, &reply, sizeof(reply));
src/kits/media/MediaAddOn.cpp
+4 -3
View File
@@ -616,9 +616,10 @@ BMediaAddOn::NotifyFlavorChange()
if (fAddon == 0)
return B_ERROR;
addonserver_rescan_mediaaddon_flavors_command command;
command.addon_id = fAddon;
return SendToAddonServer(ADDONSERVER_RESCAN_MEDIAADDON_FLAVORS, &command, sizeof(command));
add_on_server_rescan_flavors_command command;
command.add_on_id = fAddon;
return SendToAddOnServer(ADD_ON_SERVER_RESCAN_ADD_ON_FLAVORS, &command,
sizeof(command));
}
/*************************************************************
src/kits/media/MediaRoster.cpp
+71 -89
View File
@@ -154,14 +154,14 @@ status_t
BMediaRosterEx::IncrementAddonFlavorInstancesCount(media_addon_id addonID,
int32 flavorID)
{
server_change_addon_flavor_instances_count_request request;
server_change_addon_flavor_instances_count_reply reply;
server_change_flavor_instances_count_request request;
server_change_flavor_instances_count_reply reply;
request.addon_id = addonID;
request.add_on_id = addonID;
request.flavor_id = flavorID;
request.delta = 1;
request.team = BPrivate::current_team();
return QueryServer(SERVER_CHANGE_ADDON_FLAVOR_INSTANCES_COUNT, &request,
return QueryServer(SERVER_CHANGE_FLAVOR_INSTANCES_COUNT, &request,
sizeof(request), &reply, sizeof(reply));
}
@@ -170,14 +170,14 @@ status_t
BMediaRosterEx::DecrementAddonFlavorInstancesCount(media_addon_id addonID,
int32 flavorID)
{
server_change_addon_flavor_instances_count_request request;
server_change_addon_flavor_instances_count_reply reply;
server_change_flavor_instances_count_request request;
server_change_flavor_instances_count_reply reply;
request.addon_id = addonID;
request.add_on_id = addonID;
request.flavor_id = flavorID;
request.delta = -1;
request.team = BPrivate::current_team();
return QueryServer(SERVER_CHANGE_ADDON_FLAVOR_INSTANCES_COUNT, &request,
return QueryServer(SERVER_CHANGE_FLAVOR_INSTANCES_COUNT, &request,
sizeof(request), &reply, sizeof(reply));
}
@@ -1419,77 +1419,59 @@ BMediaRoster::GetLiveNodeInfo(const media_node& node,
status_t
BMediaRoster::GetLiveNodes(live_node_info* _liveNodes, int32* _totalCount,
BMediaRoster::GetLiveNodes(live_node_info* liveNodes, int32* _totalCount,
const media_format* hasInput, const media_format* hasOutput,
const char* name, uint64 nodeKinds)
{
CALLED();
if (_liveNodes == NULL || _totalCount == NULL || *_totalCount <= 0)
if (liveNodes == NULL || _totalCount == NULL || *_totalCount <= 0)
return B_BAD_VALUE;
// TODO: we also support the wildcard search as GetDormantNodes does.
// This needs to be documented
server_get_live_nodes_request request;
server_get_live_nodes_reply reply;
status_t rv;
request.team = BPrivate::current_team();
request.maxcount = *_totalCount;
request.max_count = *_totalCount;
request.has_input = hasInput != NULL;
if (hasInput != NULL) {
// TODO: we should not make a flat copy of media_format
request.inputformat = *hasInput;
request.input_format = *hasInput;
}
request.has_output = hasOutput != NULL;
if (hasOutput != NULL) {
// TODO: we should not make a flat copy of media_format
request.outputformat = *hasOutput;
request.output_format = *hasOutput;
}
request.has_name = name != NULL;
if (name != NULL) {
int len = strlen(name);
len = min_c(len, (int)sizeof(request.name) - 1);
memcpy(request.name, name, len);
request.name[len] = 0;
}
if (name != NULL)
strlcpy(request.name, name, sizeof(request.name));
request.require_kinds = nodeKinds;
rv = QueryServer(SERVER_GET_LIVE_NODES, &request, sizeof(request),
&reply, sizeof(reply));
if (rv != B_OK) {
ERROR("BMediaRoster::GetLiveNodes failed querying server\n");
server_get_live_nodes_reply reply;
status_t status = QueryServer(SERVER_GET_LIVE_NODES, &request,
sizeof(request), &reply, sizeof(reply));
if (status != B_OK) {
ERROR("BMediaRoster::GetLiveNodes failed querying server: %s\n",
strerror(status));
*_totalCount = 0;
return rv;
return status;
}
if (reply.count > MAX_LIVE_INFO) {
live_node_info* liveInfo;
area_id clone;
const live_node_info* info;
if (reply.area >= 0)
info = (live_node_info*)reply.address;
else
info = reply.live_info;
clone = clone_area("live_node_info clone",
reinterpret_cast<void **>(&liveInfo), B_ANY_ADDRESS,
B_READ_AREA | B_WRITE_AREA, reply.area);
if (clone < B_OK) {
ERROR("BMediaRoster::GetLiveNodes failed to clone area, %#lx\n",
clone);
delete_area(reply.area);
*_totalCount = 0;
return B_ERROR;
}
for (int32 i = 0; i < reply.count; i++)
liveNodes[i] = info[i];
for (int32 i = 0; i < reply.count; i++) {
_liveNodes[i] = liveInfo[i];
}
delete_area(clone);
if (reply.area >= 0)
delete_area(reply.area);
} else {
for (int32 i = 0; i < reply.count; i++) {
_liveNodes[i] = reply.live_info[i];
}
}
*_totalCount = reply.count;
*_totalCount = reply.count;
return B_OK;
}
@@ -1885,7 +1867,7 @@ BMediaRoster::RegisterNode(BMediaNode* node)
status_t
BMediaRosterEx::RegisterNode(BMediaNode* node, media_addon_id addonID,
BMediaRosterEx::RegisterNode(BMediaNode* node, media_addon_id addOnID,
int32 flavorID)
{
CALLED();
@@ -1899,16 +1881,15 @@ BMediaRosterEx::RegisterNode(BMediaNode* node, media_addon_id addonID,
int32 testFlavorID;
BMediaAddOn* addon = node->AddOn(&testFlavorID);
ASSERT(addonID == addon != NULL ? addon->AddonID() : -1);
ASSERT(addOnID == addon != NULL ? addon->AddonID() : -1);
ASSERT(flavorID == testFlavorID);
);
status_t rv;
server_register_node_request request;
server_register_node_reply reply;
request.addon_id = addonID;
request.addon_flavor_id = flavorID;
request.add_on_id = addOnID;
request.flavor_id = flavorID;
strcpy(request.name, node->Name());
request.kinds = node->Kinds();
request.port = node->ControlPort();
@@ -1918,12 +1899,12 @@ BMediaRosterEx::RegisterNode(BMediaNode* node, media_addon_id addonID,
"%ld, kinds 0x%Lx, team %ld, name '%s'\n", request.port, request.kinds,
request.team, request.name);
rv = QueryServer(SERVER_REGISTER_NODE, &request, sizeof(request), &reply,
sizeof(reply));
if (rv != B_OK) {
ERROR("BMediaRoster::RegisterNode: failed to register node %s (error "
"%#lx)\n", node->Name(), rv);
return rv;
status_t status = QueryServer(SERVER_REGISTER_NODE, &request,
sizeof(request), &reply, sizeof(reply));
if (status != B_OK) {
ERROR("BMediaRoster::RegisterNode: failed to register node %s: %s\n",
node->Name(), strerror(status));
return status;
}
TRACE("BMediaRoster::RegisterNode: QueryServer SERVER_REGISTER_NODE "
@@ -1941,11 +1922,9 @@ BMediaRosterEx::RegisterNode(BMediaNode* node, media_addon_id addonID,
// if the BMediaNode also inherits from BTimeSource, we need to call
// BTimeSource::FinishCreate()
if (node->Kinds() & B_TIME_SOURCE) {
BTimeSource *ts;
ts = dynamic_cast<BTimeSource *>(node);
if (ts)
ts->FinishCreate();
if ((node->Kinds() & B_TIME_SOURCE) != 0) {
if (BTimeSource* timeSource = dynamic_cast<BTimeSource*>(node))
timeSource->FinishCreate();
}
TRACE("BMediaRoster::RegisterNode: publishing inputs/outputs\n");
@@ -1957,18 +1936,15 @@ BMediaRosterEx::RegisterNode(BMediaNode* node, media_addon_id addonID,
// if we send a message and wait for a reply here.
// We have a pointer to the node, and thus call the functions directly
if (node->Kinds() & B_BUFFER_PRODUCER) {
BBufferProducer *bp;
bp = dynamic_cast<BBufferProducer *>(node);
if (bp) {
if ((node->Kinds() & B_BUFFER_PRODUCER) != 0) {
if (BBufferProducer* producer = dynamic_cast<BBufferProducer*>(node)) {
List<media_output> list;
if (B_OK == GetAllOutputs(bp, &list))
if (GetAllOutputs(producer, &list) == B_OK)
PublishOutputs(node->Node(), &list);
}
}
if ((node->Kinds() & B_BUFFER_CONSUMER) != 0) {
BBufferConsumer* consumer = dynamic_cast<BBufferConsumer*>(node);
if (consumer != NULL) {
if (BBufferConsumer* consumer = dynamic_cast<BBufferConsumer*>(node)) {
List<media_input> list;
if (GetAllInputs(consumer, &list) == B_OK)
PublishInputs(node->Node(), &list);
@@ -1982,13 +1958,19 @@ BMediaRosterEx::RegisterNode(BMediaNode* node, media_addon_id addonID,
TRACE("BMediaRoster::RegisterNode: finished\n");
/*
TRACE("BMediaRoster::RegisterNode: registered node name '%s', id %ld, addon %ld, flavor %ld\n", node->Name(), node->ID(), addon_id, addon_flavor_id);
TRACE("BMediaRoster::RegisterNode: registered node name '%s', id %ld,
addon %ld, flavor %ld\n", node->Name(), node->ID(), addOnID, flavorID);
TRACE("BMediaRoster::RegisterNode: node this %p\n", node);
TRACE("BMediaRoster::RegisterNode: node fConsumerThis %p\n", node->fConsumerThis);
TRACE("BMediaRoster::RegisterNode: node fProducerThis %p\n", node->fProducerThis);
TRACE("BMediaRoster::RegisterNode: node fFileInterfaceThis %p\n", node->fFileInterfaceThis);
TRACE("BMediaRoster::RegisterNode: node fControllableThis %p\n", node->fControllableThis);
TRACE("BMediaRoster::RegisterNode: node fTimeSourceThis %p\n", node->fTimeSourceThis);
TRACE("BMediaRoster::RegisterNode: node fConsumerThis %p\n",
node->fConsumerThis);
TRACE("BMediaRoster::RegisterNode: node fProducerThis %p\n",
node->fProducerThis);
TRACE("BMediaRoster::RegisterNode: node fFileInterfaceThis %p\n",
node->fFileInterfaceThis);
TRACE("BMediaRoster::RegisterNode: node fControllableThis %p\n",
node->fControllableThis);
TRACE("BMediaRoster::RegisterNode: node fTimeSourceThis %p\n",
node->fTimeSourceThis);
*/
return B_OK;
}
@@ -2043,7 +2025,7 @@ BMediaRoster::UnregisterNode(BMediaNode* node)
return status;
}
if (reply.addon_id != -1) {
if (reply.add_on_id != -1) {
// TODO: this doesn't look right
// Small problem here, we can't use DormantNodeManager::PutAddOn(), as
// UnregisterNode() is called by a dormant node itself (by the
@@ -2051,10 +2033,10 @@ BMediaRoster::UnregisterNode(BMediaNode* node)
// The add-on that contains the node needs to remain in memory until the
// destructor execution is finished.
// DormantNodeManager::PutAddOnDelayed() will delay unloading.
gDormantNodeManager->PutAddOnDelayed(reply.addon_id);
gDormantNodeManager->PutAddOnDelayed(reply.add_on_id);
status = MediaRosterEx(this)->DecrementAddonFlavorInstancesCount(
reply.addon_id, reply.flavor_id);
reply.add_on_id, reply.flavor_id);
if (status != B_OK) {
ERROR("BMediaRoster::UnregisterNode: "
"DecrementAddonFlavorInstancesCount() failed\n");
@@ -2545,13 +2527,13 @@ BMediaRoster::InstantiateDormantNode(const dormant_node_info& info,
TRACE("BMediaRoster::InstantiateDormantNode: creating global object "
"in media_addon_server\n");
addonserver_instantiate_dormant_node_request request;
addonserver_instantiate_dormant_node_reply reply;
request.addon_id = info.addon;
add_on_server_instantiate_dormant_node_request request;
add_on_server_instantiate_dormant_node_reply reply;
request.add_on_id = info.addon;
request.flavor_id = info.flavor_id;
request.creator_team = BPrivate::current_team();
// creator team is allowed to also release global nodes
rv = QueryAddonServer(ADDONSERVER_INSTANTIATE_DORMANT_NODE, &request,
rv = QueryAddOnServer(ADD_ON_SERVER_INSTANTIATE_DORMANT_NODE, &request,
sizeof(request), &reply, sizeof(reply));
if (rv == B_OK)
*_node = reply.node;
@@ -3045,9 +3027,9 @@ BMediaRoster::GetInstancesFor(media_addon_id addon, int32 flavor,
server_get_instances_for_reply reply;
status_t rv;
request.maxcount = (_count ? *_count : 1);
request.addon_id = addon;
request.addon_flavor_id = flavor;
request.max_count = (_count ? *_count : 1);
request.add_on_id = addon;
request.flavor_id = flavor;
rv = QueryServer(SERVER_GET_INSTANCES_FOR, &request, sizeof(request),
&reply, sizeof(reply));
src/servers/media/AppManager.cpp
+1 -1
View File
@@ -109,7 +109,7 @@ AppManager::UnregisterTeam(team_id team)
team_id
AppManager::AddonServerTeam()
AppManager::AddOnServerTeam()
{
team_id id = be_roster->TeamFor(B_MEDIA_ADDON_SERVER_SIGNATURE);
if (id < 0) {
src/servers/media/AppManager.h
+1 -1
View File
@@ -22,7 +22,7 @@ public:
status_t UnregisterTeam(team_id team);
bool HasTeam(team_id team);
team_id AddonServerTeam();
team_id AddOnServerTeam();
status_t SendMessage(team_id team, BMessage* message);
src/servers/media/DefaultManager.cpp
+10 -10
View File
@@ -136,13 +136,12 @@ DefaultManager::SaveState(NodeManager *node_manager)
dormant_node_info info;
media_node node;
entry_ref ref;
if (node_manager->GetCloneForID(&node, media_node_ids[i], be_app->Team()) != B_OK)
continue;
if (node_manager->GetDormantNodeInfo(&info, node) != B_OK)
continue;
if (node_manager->DecrementGlobalRefCount(media_node_ids[i], be_app->Team()) != B_OK)
continue;
if (node_manager->GetAddonRef(&ref, info.addon)!=B_OK)
if (node_manager->GetCloneForID(media_node_ids[i], be_app->Team(),
&node) != B_OK
|| node_manager->GetDormantNodeInfo(node, &info) != B_OK
|| node_manager->ReleaseNodeReference(media_node_ids[i],
be_app->Team()) != B_OK
|| node_manager->GetAddOnRef(info.addon, &ref) != B_OK)
continue;
BPath path(&ref);
@@ -337,15 +336,16 @@ DefaultManager::RescanThread()
ERROR("DefaultManager: Did not try to connect mixer and soundcard\n");
}
addonserver_rescan_finished_notify_command cmd;
SendToAddonServer(ADDONSERVER_RESCAN_FINISHED_NOTIFY, &cmd, sizeof(cmd));
add_on_server_rescan_finished_notify_command cmd;
SendToAddOnServer(ADD_ON_SERVER_RESCAN_FINISHED_NOTIFY, &cmd, sizeof(cmd));
printf("DefaultManager::RescanThread() leave\n");
}
void
DefaultManager::FindPhysical(volatile media_node_id *id, uint32 default_type, bool isInput, media_type type)
DefaultManager::FindPhysical(volatile media_node_id *id, uint32 default_type,
bool isInput, media_type type)
{
live_node_info info[MAX_NODE_INFOS];
media_format format;
src/servers/media/NodeManager.cpp
+948 -721
View File
File diff suppressed because it is too large Load Diff
src/servers/media/NodeManager.h
+140 -89
View File
@@ -2,116 +2,167 @@
* Copyright 2002, Marcus Overhagen. All rights reserved.
* Distributed under the terms of the MIT License.
*/
#ifndef NODE_MANAGER_H
#define NODE_MANAGER_H
#include <map>
#include <vector>
#include <Locker.h>
#include "TList.h"
#include "TMap.h"
#include "TStack.h"
#include "DataExchange.h"
struct registered_node {
media_node_id node_id;
media_addon_id addon_id;
int32 addon_flavor_id;
char name[B_MEDIA_NAME_LENGTH];
uint64 kinds;
port_id port;
team_id creator; // team that created the node
team_id team; // team that contains the node object
int32 globalrefcount;
Map<team_id, int32> teamrefcount;
List<media_input> inputlist;
List<media_output> outputlist;
};
struct dormant_addon_flavor_info {
media_addon_id AddonID;
int32 AddonFlavorID;
int32 MaxInstancesCount;
int32 GlobalInstancesCount;
Map<team_id, int32> TeamInstancesCount;
bool InfoValid;
dormant_flavor_info Info;
};
class DefaultManager;
class BufferManager;
class NodeManager {
typedef std::map<team_id, int32> TeamCountMap;
typedef std::vector<media_input> InputList;
typedef std::vector<media_output> OutputList;
typedef std::vector<live_node_info> LiveNodeList;
struct registered_node {
media_node_id node_id;
media_addon_id add_on_id;
int32 flavor_id;
char name[B_MEDIA_NAME_LENGTH];
uint64 kinds;
port_id port;
team_id creator; // team that created the node
team_id containing_team;
int32 ref_count;
TeamCountMap team_ref_count;
InputList input_list;
OutputList output_list;
};
struct dormant_add_on_flavor_info {
media_addon_id add_on_id;
int32 flavor_id;
int32 max_instances_count;
int32 instances_count;
TeamCountMap team_instances_count;
bool info_valid;
dormant_flavor_info info;
};
class NodeManager : BLocker {
public:
NodeManager();
~NodeManager();
NodeManager();
~NodeManager();
status_t LoadState();
status_t SaveState();
// Management of system wide default nodes
status_t SetDefaultNode(node_type type,
const media_node* node,
const dormant_node_info* info,
const media_input* input);
status_t GetDefaultNode(node_type type,
media_node_id* _nodeID, char* inputName,
int32* _inputID);
status_t RescanDefaultNodes();
void Dump();
// Management of live nodes
status_t RegisterNode(media_addon_id addOnID,
int32 flavorID, const char* name,
uint64 kinds, port_id port, team_id team,
media_node_id* _nodeID);
status_t UnregisterNode(media_node_id nodeID,
team_id team, media_addon_id* addOnID,
int32* _flavorID);
status_t ReleaseNodeReference(media_node_id id,
team_id team);
status_t GetCloneForID(media_node_id id, team_id team,
media_node* node);
status_t GetClone(node_type type, team_id team,
media_node* node, char* inputName,
int32* _id);
status_t ReleaseNode(const media_node& node,
team_id team);
status_t PublishInputs(const media_node& node,
const media_input* inputs, int32 count);
status_t PublishOutputs(const media_node& node,
const media_output* outputs, int32 count);
status_t FindNodeID(port_id port, media_node_id* _id);
status_t GetLiveNodeInfo(const media_node& node,
live_node_info* liveInfo);
status_t GetInstances(media_addon_id addOnID,
int32 flavorID, media_node_id* ids,
int32* _count, int32 maxCount);
status_t GetLiveNodes(LiveNodeList& liveNodes,
int32 maxCount,
const media_format* inputFormat = NULL,
const media_format* outputFormat = NULL,
const char* name = NULL,
uint64 requireKinds = 0);
status_t GetDormantNodeInfo(const media_node& node,
dormant_node_info* nodeInfo);
status_t SetNodeCreator(media_node_id id,
team_id creator);
/* Management of system wide default nodes */
status_t SetDefaultNode(node_type type, const media_node *node, const dormant_node_info *info, const media_input *input);
status_t GetDefaultNode(media_node_id* nodeID, char* name, int32* id,
node_type type);
status_t RescanDefaultNodes();
// Add media_node_id of all live nodes to the message
// int32 "media_node_id" (multiple items)
status_t GetLiveNodes(BMessage* message);
/* Management of live nodes */
status_t RegisterNode(media_node_id *nodeid, media_addon_id addon_id, int32 addon_flavor_id, const char *name, uint64 kinds, port_id port, team_id team);
status_t UnregisterNode(media_addon_id *addonid, int32 *flavorid, media_node_id nodeid, team_id team);
status_t GetCloneForID(media_node* node, media_node_id nodeID, team_id team);
status_t GetClone(media_node *node, char *input_name, int32 *input_id, node_type type, team_id team);
status_t ReleaseNode(const media_node &node, team_id team);
status_t PublishInputs(const media_node &node, const media_input *inputs, int32 count);
status_t PublishOutputs(const media_node &node, const media_output *outputs, int32 count);
status_t FindNodeID(media_node_id* nodeID, port_id port);
status_t GetLiveNodeInfo(live_node_info *live_info, const media_node &node);
status_t GetInstances(media_node_id *node_ids, int32* count, int32 maxcount, media_addon_id addon_id, int32 addon_flavor_id);
status_t GetLiveNodes(Stack<live_node_info> *livenodes, int32 maxcount, const media_format *inputformat = NULL, const media_format *outputformat = NULL, const char* name = NULL, uint64 require_kinds = 0);
status_t GetDormantNodeInfo(dormant_node_info *node_info, const media_node &node);
status_t IncrementGlobalRefCount(media_node_id nodeid, team_id team);
status_t DecrementGlobalRefCount(media_node_id nodeid, team_id team);
status_t SetNodeCreator(media_node_id nodeid, team_id creator);
void FinalReleaseNode(media_node_id nodeid);
void RegisterAddOn(const entry_ref& ref,
media_addon_id* _newID);
void UnregisterAddOn(media_addon_id id);
/* Add media_node_id of all live nodes to the message
* int32 "media_node_id" (multiple items)
*/
status_t GetLiveNodes(BMessage *msg);
status_t AddDormantFlavorInfo(
const dormant_flavor_info& flavorInfo);
void InvalidateDormantFlavorInfo(media_addon_id id);
void RemoveDormantFlavorInfo(media_addon_id id);
void CleanupDormantFlavorInfos();
void RegisterAddon(const entry_ref &ref, media_addon_id *newid);
void UnregisterAddon(media_addon_id id);
status_t IncrementFlavorInstancesCount(
media_addon_id addOnID, int32 flavorID,
team_id team);
status_t DecrementFlavorInstancesCount(
media_addon_id addOnID, int32 flavorID,
team_id team);
void AddDormantFlavorInfo(const dormant_flavor_info &dfi);
void InvalidateDormantFlavorInfo(media_addon_id id);
void RemoveDormantFlavorInfo(media_addon_id id);
void CleanupDormantFlavorInfos();
status_t GetAddOnRef(media_addon_id addOnID,
entry_ref* ref);
status_t GetDormantNodes(dormant_node_info* infos,
int32* _count, const media_format* hasInput,
const media_format* hasOutput,
const char* name, uint64 requireKinds,
uint64 denyKinds);
status_t IncrementAddonFlavorInstancesCount(media_addon_id addonid, int32 flavorid, team_id team);
status_t DecrementAddonFlavorInstancesCount(media_addon_id addonid, int32 flavorid, team_id team);
status_t GetDormantFlavorInfoFor(media_addon_id addOnID,
int32 flavorID,
dormant_flavor_info* flavorInfo);
status_t GetAddonRef(entry_ref *ref, media_addon_id id);
status_t GetDormantNodes(dormant_node_info * out_info,
int32 * io_count,
const media_format * has_input /* = NULL */,
const media_format * has_output /* = NULL */,
const char * name /* = NULL */,
uint64 require_kinds /* = NULL */,
uint64 deny_kinds /* = NULL */);
void CleanupTeam(team_id team);
status_t GetDormantFlavorInfoFor(media_addon_id addon,
int32 flavor_id,
dormant_flavor_info *outFlavor);
status_t LoadState();
status_t SaveState();
void CleanupTeam(team_id team);
void Dump();
private:
media_addon_id fNextAddOnID;
media_node_id fNextNodeID;
status_t _AcquireNodeReference(media_node_id id,
team_id team);
BLocker *fLocker;
List<dormant_addon_flavor_info> *fDormantAddonFlavorList;
Map<media_addon_id,entry_ref> *fAddonPathMap;
Map<media_node_id,registered_node> *fRegisteredNodeMap;
DefaultManager *fDefaultManager;
private:
typedef std::map<media_addon_id, registered_node> NodeMap;
typedef std::vector<dormant_add_on_flavor_info> DormantFlavorList;
typedef std::map<media_addon_id, entry_ref> PathMap;
media_addon_id fNextAddOnID;
media_node_id fNextNodeID;
DormantFlavorList fDormantFlavors;
PathMap fPathMap;
NodeMap fNodeMap;
DefaultManager* fDefaultManager;
};
#endif // NODE_MANAGER_H
src/servers/media/media_server.cpp
+184 -174
View File
@@ -85,7 +85,7 @@ protected:
virtual void MessageReceived(BMessage* message);
private:
void _HandleMessage(int32 code, void* data,
void _HandleMessage(int32 code, const void* data,
size_t size);
void _LaunchAddOnServer();
void _QuitAddOnServer();
@@ -271,27 +271,27 @@ ServerApp::_QuitAddOnServer()
void
ServerApp::_HandleMessage(int32 code, void* data, size_t size)
ServerApp::_HandleMessage(int32 code, const void* data, size_t size)
{
status_t rv;
TRACE("ServerApp::HandleMessage %#lx enter\n", code);
switch (code) {
case SERVER_CHANGE_ADDON_FLAVOR_INSTANCES_COUNT:
case SERVER_CHANGE_FLAVOR_INSTANCES_COUNT:
{
const server_change_addon_flavor_instances_count_request *request
= reinterpret_cast<
const server_change_addon_flavor_instances_count_request *>(
data);
server_change_addon_flavor_instances_count_reply reply;
ASSERT(request->delta == 1 || request->delta == -1);
if (request->delta == 1) {
rv = gNodeManager->IncrementAddonFlavorInstancesCount(
request->addon_id, request->flavor_id, request->team);
} else {
rv = gNodeManager->DecrementAddonFlavorInstancesCount(
request->addon_id, request->flavor_id, request->team);
const server_change_flavor_instances_count_request& request
= *static_cast<
const server_change_flavor_instances_count_request*>(data);
server_change_flavor_instances_count_reply reply;
status_t status = B_BAD_VALUE;
if (request.delta == 1) {
status = gNodeManager->IncrementFlavorInstancesCount(
request.add_on_id, request.flavor_id, request.team);
} else if (request.delta == -1) {
status = gNodeManager->DecrementFlavorInstancesCount(
request.add_on_id, request.flavor_id, request.team);
}
request->SendReply(rv, &reply, sizeof(reply));
request.SendReply(status, &reply, sizeof(reply));
break;
}
@@ -303,100 +303,112 @@ ServerApp::_HandleMessage(int32 code, void* data, size_t size)
case SERVER_REGISTER_APP:
{
const server_register_app_request *request
= reinterpret_cast<const server_register_app_request *>(data);
const server_register_app_request& request = *static_cast<
const server_register_app_request*>(data);
server_register_app_reply reply;
rv = gAppManager->RegisterTeam(request->team, request->messenger);
request->SendReply(rv, &reply, sizeof(reply));
status_t status = gAppManager->RegisterTeam(request.team,
request.messenger);
request.SendReply(status, &reply, sizeof(reply));
break;
}
case SERVER_UNREGISTER_APP:
{
const server_unregister_app_request *request
= reinterpret_cast<const server_unregister_app_request *>(
data);
const server_unregister_app_request& request = *static_cast<
const server_unregister_app_request*>(data);
server_unregister_app_reply reply;
rv = gAppManager->UnregisterTeam(request->team);
request->SendReply(rv, &reply, sizeof(reply));
status_t status = gAppManager->UnregisterTeam(request.team);
request.SendReply(status, &reply, sizeof(reply));
break;
}
case SERVER_GET_MEDIAADDON_REF:
case SERVER_GET_ADD_ON_REF:
{
server_get_mediaaddon_ref_request *msg
= (server_get_mediaaddon_ref_request *)data;
server_get_mediaaddon_ref_reply reply;
entry_ref tempref;
reply.result = gNodeManager->GetAddonRef(&tempref, msg->addon_id);
reply.ref = tempref;
write_port(msg->reply_port, 0, &reply, sizeof(reply));
const server_get_add_on_ref_request& request = *static_cast<
const server_get_add_on_ref_request*>(data);
server_get_add_on_ref_reply reply;
entry_ref ref;
reply.result = gNodeManager->GetAddOnRef(request.add_on_id, &ref);
reply.ref = ref;
request.SendReply(reply.result, &reply, sizeof(reply));
break;
}
case SERVER_NODE_ID_FOR:
{
const server_node_id_for_request *request
= reinterpret_cast<const server_node_id_for_request *>(data);
const server_node_id_for_request& request
= *static_cast<const server_node_id_for_request*>(data);
server_node_id_for_reply reply;
rv = gNodeManager->FindNodeID(&reply.node_id, request->port);
request->SendReply(rv, &reply, sizeof(reply));
status_t status = gNodeManager->FindNodeID(request.port,
&reply.node_id);
request.SendReply(status, &reply, sizeof(reply));
break;
}
case SERVER_GET_LIVE_NODE_INFO:
{
const server_get_live_node_info_request *request
= reinterpret_cast<const server_get_live_node_info_request *>(
data);
const server_get_live_node_info_request& request = *static_cast<
const server_get_live_node_info_request*>(data);
server_get_live_node_info_reply reply;
rv = gNodeManager->GetLiveNodeInfo(&reply.live_info,
request->node);
request->SendReply(rv, &reply, sizeof(reply));
status_t status = gNodeManager->GetLiveNodeInfo(request.node,
&reply.live_info);
request.SendReply(status, &reply, sizeof(reply));
break;
}
case SERVER_GET_LIVE_NODES:
{
const server_get_live_nodes_request *request
= reinterpret_cast<const server_get_live_nodes_request *>(
data);
const server_get_live_nodes_request& request
= *static_cast<const server_get_live_nodes_request*>(data);
server_get_live_nodes_reply reply;
Stack<live_node_info> livenodes;
rv = gNodeManager->GetLiveNodes(
&livenodes,
request->maxcount,
request->has_input ? &request->inputformat : NULL,
request->has_output ? &request->outputformat : NULL,
request->has_name ? request->name : NULL,
request->require_kinds);
reply.count = livenodes.CountItems();
if (reply.count <= MAX_LIVE_INFO) {
for (int32 index = 0; index < reply.count; index++)
livenodes.Pop(&reply.live_info[index]);
reply.area = -1;
} else {
// we create an area here, and pass it to the library,
// where it will be deleted.
live_node_info *start_addr;
size_t size;
size = ((reply.count * sizeof(live_node_info)) + B_PAGE_SIZE
- 1) & ~(B_PAGE_SIZE - 1);
reply.area = create_area("get live nodes",
reinterpret_cast<void **>(&start_addr), B_ANY_ADDRESS,
size, B_NO_LOCK, B_READ_AREA | B_WRITE_AREA);
if (reply.area < B_OK) {
ERROR("SERVER_GET_LIVE_NODES: failed to create area, "
"error %#lx\n", reply.area);
LiveNodeList nodes;
status_t status = gNodeManager->GetLiveNodes(nodes,
request.max_count,
request.has_input ? &request.input_format : NULL,
request.has_output ? &request.output_format : NULL,
request.has_name ? request.name : NULL, request.require_kinds);
reply.count = nodes.size();
reply.area = -1;
live_node_info* infos = reply.live_info;
area_id area = -1;
if (reply.count > MAX_LIVE_INFO) {
// We create an area here, and transfer it to the client
size_t size = (reply.count * sizeof(live_node_info)
+ B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1);
area = create_area("get live nodes", (void**)&infos,
B_ANY_ADDRESS, size, B_NO_LOCK, B_READ_AREA | B_WRITE_AREA);
if (area < 0) {
reply.area = area;
reply.count = 0;
rv = B_ERROR;
} else {
for (int32 index = 0; index < reply.count; index++)
livenodes.Pop(&start_addr[index]);
}
}
rv = request->SendReply(rv, &reply, sizeof(reply));
if (rv != B_OK) {
for (int32 index = 0; index < reply.count; index++)
infos[index] = nodes[index];
if (area >= 0) {
// transfer the area to the target team
reply.area = _kern_transfer_area(area, &reply.address,
B_ANY_ADDRESS, request.team);
if (reply.area < 0) {
delete_area(area);
reply.count = 0;
}
}
status = request.SendReply(status, &reply, sizeof(reply));
if (status != B_OK && reply.area >= 0) {
// if we couldn't send the message, delete the area
delete_area(reply.area);
}
@@ -405,54 +417,57 @@ ServerApp::_HandleMessage(int32 code, void* data, size_t size)
case SERVER_GET_NODE_FOR:
{
const server_get_node_for_request *request
= reinterpret_cast<const server_get_node_for_request *>(data);
const server_get_node_for_request& request
= *static_cast<const server_get_node_for_request*>(data);
server_get_node_for_reply reply;
rv = gNodeManager->GetCloneForID(&reply.clone, request->node_id,
request->team);
request->SendReply(rv, &reply, sizeof(reply));
status_t status = gNodeManager->GetCloneForID(request.node_id,
request.team, &reply.clone);
request.SendReply(status, &reply, sizeof(reply));
break;
}
case SERVER_RELEASE_NODE:
{
const server_release_node_request *request
= reinterpret_cast<const server_release_node_request *>(data);
const server_release_node_request& request
= *static_cast<const server_release_node_request*>(data);
server_release_node_reply reply;
rv = gNodeManager->ReleaseNode(request->node, request->team);
request->SendReply(rv, &reply, sizeof(reply));
status_t status = gNodeManager->ReleaseNode(request.node,
request.team);
request.SendReply(status, &reply, sizeof(reply));
break;
}
case SERVER_REGISTER_NODE:
{
const server_register_node_request *request
= reinterpret_cast<const server_register_node_request *>(data);
const server_register_node_request& request
= *static_cast<const server_register_node_request*>(data);
server_register_node_reply reply;
rv = gNodeManager->RegisterNode(&reply.node_id, request->addon_id,
request->addon_flavor_id, request->name, request->kinds,
request->port, request->team);
request->SendReply(rv, &reply, sizeof(reply));
status_t status = gNodeManager->RegisterNode(request.add_on_id,
request.flavor_id, request.name, request.kinds, request.port,
request.team, &reply.node_id);
request.SendReply(status, &reply, sizeof(reply));
break;
}
case SERVER_UNREGISTER_NODE:
{
const server_unregister_node_request *request
= reinterpret_cast<const server_unregister_node_request *>(
data);
const server_unregister_node_request& request
= *static_cast<const server_unregister_node_request*>(data);
server_unregister_node_reply reply;
rv = gNodeManager->UnregisterNode(&reply.addon_id, &reply.flavor_id,
request->node_id, request->team);
request->SendReply(rv, &reply, sizeof(reply));
status_t status = gNodeManager->UnregisterNode(request.node_id,
request.team, &reply.add_on_id, &reply.flavor_id);
request.SendReply(status, &reply, sizeof(reply));
break;
}
case SERVER_PUBLISH_INPUTS:
{
const server_publish_inputs_request *request
= reinterpret_cast<const server_publish_inputs_request *>(
data);
= static_cast<const server_publish_inputs_request *>(data);
server_publish_inputs_reply reply;
if (request->count <= MAX_INPUTS) {
rv = gNodeManager->PublishInputs(request->node,
@@ -460,9 +475,8 @@ ServerApp::_HandleMessage(int32 code, void* data, size_t size)
} else {
media_input *inputs;
area_id clone;
clone = clone_area("media_inputs clone",
reinterpret_cast<void **>(&inputs), B_ANY_ADDRESS,
B_READ_AREA | B_WRITE_AREA, request->area);
clone = clone_area("media_inputs clone", (void**)&inputs,
B_ANY_ADDRESS, B_READ_AREA | B_WRITE_AREA, request->area);
if (clone < B_OK) {
ERROR("SERVER_PUBLISH_INPUTS: failed to clone area, "
"error %#lx\n", clone);
@@ -480,8 +494,7 @@ ServerApp::_HandleMessage(int32 code, void* data, size_t size)
case SERVER_PUBLISH_OUTPUTS:
{
const server_publish_outputs_request *request
= reinterpret_cast<const server_publish_outputs_request *>(
data);
= static_cast<const server_publish_outputs_request *>(data);
server_publish_outputs_reply reply;
if (request->count <= MAX_OUTPUTS) {
rv = gNodeManager->PublishOutputs(request->node,
@@ -489,7 +502,8 @@ ServerApp::_HandleMessage(int32 code, void* data, size_t size)
} else {
media_output *outputs;
area_id clone;
clone = clone_area("media_outputs clone", reinterpret_cast<void **>(&outputs), B_ANY_ADDRESS, B_READ_AREA | B_WRITE_AREA, request->area);
clone = clone_area("media_outputs clone", (void**)&outputs,
B_ANY_ADDRESS, B_READ_AREA | B_WRITE_AREA, request->area);
if (clone < B_OK) {
ERROR("SERVER_PUBLISH_OUTPUTS: failed to clone area, "
"error %#lx\n", clone);
@@ -506,74 +520,78 @@ ServerApp::_HandleMessage(int32 code, void* data, size_t size)
case SERVER_GET_NODE:
{
const server_get_node_request *request
= reinterpret_cast<const server_get_node_request *>(data);
const server_get_node_request& request
= *static_cast<const server_get_node_request*>(data);
server_get_node_reply reply;
rv = gNodeManager->GetClone(&reply.node, reply.input_name,
&reply.input_id, request->type, request->team);
request->SendReply(rv, &reply, sizeof(reply));
status_t status = gNodeManager->GetClone(request.type, request.team,
&reply.node, reply.input_name, &reply.input_id);
request.SendReply(status, &reply, sizeof(reply));
break;
}
case SERVER_SET_NODE:
{
const server_set_node_request *request
= reinterpret_cast<const server_set_node_request *>(data);
const server_set_node_request& request
= *static_cast<const server_set_node_request*>(data);
server_set_node_reply reply;
rv = gNodeManager->SetDefaultNode(request->type,
request->use_node ? &request->node : NULL,
request->use_dni ? &request->dni : NULL,
request->use_input ? &request->input : NULL);
request->SendReply(rv, &reply, sizeof(reply));
status_t status = gNodeManager->SetDefaultNode(request.type,
request.use_node ? &request.node : NULL,
request.use_dni ? &request.dni : NULL,
request.use_input ? &request.input : NULL);
request.SendReply(status, &reply, sizeof(reply));
break;
}
case SERVER_GET_DORMANT_NODE_FOR:
{
const server_get_dormant_node_for_request *request
= reinterpret_cast<
const server_get_dormant_node_for_request *>(data);
const server_get_dormant_node_for_request& request
= *static_cast<const server_get_dormant_node_for_request*>(
data);
server_get_dormant_node_for_reply reply;
rv = gNodeManager->GetDormantNodeInfo(&reply.node_info,
request->node);
request->SendReply(rv, &reply, sizeof(reply));
status_t status = gNodeManager->GetDormantNodeInfo(request.node,
&reply.node_info);
request.SendReply(status, &reply, sizeof(reply));
break;
}
case SERVER_GET_INSTANCES_FOR:
{
const server_get_instances_for_request *request
= reinterpret_cast<const server_get_instances_for_request *>(
data);
const server_get_instances_for_request& request
= *static_cast<const server_get_instances_for_request*>(data);
server_get_instances_for_reply reply;
rv = gNodeManager->GetInstances(reply.node_id, &reply.count,
min_c(request->maxcount, MAX_NODE_ID), request->addon_id,
request->addon_flavor_id);
status_t status = gNodeManager->GetInstances(request.add_on_id,
request.flavor_id, reply.node_id, &reply.count,
min_c(request.max_count, MAX_NODE_ID));
if (reply.count == MAX_NODE_ID
&& request->maxcount > MAX_NODE_ID) {
// XXX might be fixed by using an area
&& request.max_count > MAX_NODE_ID) {
// TODO: might be fixed by using an area
PRINT(1, "Warning: SERVER_GET_INSTANCES_FOR: returning "
"possibly truncated list of node id's\n");
}
request->SendReply(rv, &reply, sizeof(reply));
request.SendReply(status, &reply, sizeof(reply));
break;
}
case SERVER_REGISTER_MEDIAADDON:
case SERVER_REGISTER_ADD_ON:
{
server_register_mediaaddon_request *msg
= (server_register_mediaaddon_request *)data;
server_register_mediaaddon_reply reply;
gNodeManager->RegisterAddon(msg->ref, &reply.addon_id);
write_port(msg->reply_port, 0, &reply, sizeof(reply));
const server_register_add_on_request& request = *static_cast<
const server_register_add_on_request*>(data);
server_register_add_on_reply reply;
gNodeManager->RegisterAddOn(request.ref, &reply.add_on_id);
request.SendReply(B_OK, &reply, sizeof(reply));
break;
}
case SERVER_UNREGISTER_MEDIAADDON:
case SERVER_UNREGISTER_ADD_ON:
{
server_unregister_mediaaddon_command *msg
= (server_unregister_mediaaddon_command *)data;
gNodeManager->UnregisterAddon(msg->addon_id);
const server_unregister_add_on_command& request = *static_cast<
const server_unregister_add_on_command*>(data);
gNodeManager->UnregisterAddOn(request.add_on_id);
break;
}
@@ -662,8 +680,7 @@ ServerApp::_HandleMessage(int32 code, void* data, size_t size)
case SERVER_SET_NODE_CREATOR:
{
const server_set_node_creator_request* request
= reinterpret_cast<const server_set_node_creator_request*>(
data);
= static_cast<const server_set_node_creator_request*>(data);
server_set_node_creator_reply reply;
status_t status = gNodeManager->SetNodeCreator(request->node,
request->creator);
@@ -673,21 +690,21 @@ ServerApp::_HandleMessage(int32 code, void* data, size_t size)
case SERVER_GET_SHARED_BUFFER_AREA:
{
const server_get_shared_buffer_area_request *request
= reinterpret_cast<
const server_get_shared_buffer_area_request *>(data);
const server_get_shared_buffer_area_request& request
= *static_cast<const server_get_shared_buffer_area_request*>(
data);
server_get_shared_buffer_area_reply reply;
reply.area = gBufferManager->SharedBufferListArea();
request->SendReply(B_OK, &reply, sizeof(reply));
request.SendReply(reply.area >= 0 ? B_OK : reply.area, &reply,
sizeof(reply));
break;
}
case SERVER_REGISTER_BUFFER:
{
const server_register_buffer_request *request
= reinterpret_cast<const server_register_buffer_request *>(
data);
= static_cast<const server_register_buffer_request *>(data);
server_register_buffer_reply reply;
status_t status;
if (request->info.buffer == 0) {
@@ -710,7 +727,7 @@ ServerApp::_HandleMessage(int32 code, void* data, size_t size)
case SERVER_UNREGISTER_BUFFER:
{
const server_unregister_buffer_command *cmd = reinterpret_cast<
const server_unregister_buffer_command *cmd = static_cast<
const server_unregister_buffer_command *>(data);
gBufferManager->UnregisterBuffer(cmd->team, cmd->buffer_id);
@@ -720,8 +737,7 @@ ServerApp::_HandleMessage(int32 code, void* data, size_t size)
case SERVER_GET_MEDIA_FILE_TYPES:
{
const server_get_media_types_request& request
= *reinterpret_cast<const server_get_media_types_request*>(
data);
= *static_cast<const server_get_media_types_request*>(data);
server_get_media_types_reply reply;
area_id area = gMediaFilesManager->GetTypesArea(reply.count);
@@ -748,8 +764,7 @@ ServerApp::_HandleMessage(int32 code, void* data, size_t size)
case SERVER_GET_MEDIA_FILE_ITEMS:
{
const server_get_media_items_request& request
= *reinterpret_cast<const server_get_media_items_request*>(
data);
= *static_cast<const server_get_media_items_request*>(data);
server_get_media_items_reply reply;
area_id area = gMediaFilesManager->GetItemsArea(request.type,
@@ -778,7 +793,7 @@ ServerApp::_HandleMessage(int32 code, void* data, size_t size)
case SERVER_GET_REF_FOR:
{
const server_get_ref_for_request* request
= reinterpret_cast<const server_get_ref_for_request*>(data);
= static_cast<const server_get_ref_for_request*>(data);
server_get_ref_for_reply reply;
entry_ref* ref;
@@ -794,7 +809,7 @@ ServerApp::_HandleMessage(int32 code, void* data, size_t size)
case SERVER_SET_REF_FOR:
{
const server_set_ref_for_request* request
= reinterpret_cast<const server_set_ref_for_request*>(data);
= static_cast<const server_set_ref_for_request*>(data);
server_set_ref_for_reply reply;
entry_ref ref = request->ref;
@@ -807,7 +822,7 @@ ServerApp::_HandleMessage(int32 code, void* data, size_t size)
case SERVER_INVALIDATE_MEDIA_ITEM:
{
const server_invalidate_item_request* request
= reinterpret_cast<const server_invalidate_item_request*>(data);
= static_cast<const server_invalidate_item_request*>(data);
server_invalidate_item_reply reply;
status_t status = gMediaFilesManager->InvalidateItem(
@@ -819,8 +834,7 @@ ServerApp::_HandleMessage(int32 code, void* data, size_t size)
case SERVER_REMOVE_MEDIA_ITEM:
{
const server_remove_media_item_request* request
= reinterpret_cast<const server_remove_media_item_request*>(
data);
= static_cast<const server_remove_media_item_request*>(data);
server_remove_media_item_reply reply;
status_t status = gMediaFilesManager->RemoveItem(request->type,
@@ -832,8 +846,7 @@ ServerApp::_HandleMessage(int32 code, void* data, size_t size)
case SERVER_GET_ITEM_AUDIO_GAIN:
{
const server_get_item_audio_gain_request& request
= *reinterpret_cast<const server_get_item_audio_gain_request*>(
data);
= *static_cast<const server_get_item_audio_gain_request*>(data);
server_get_item_audio_gain_reply reply;
status_t status = gMediaFilesManager->GetAudioGainFor(request.type,
@@ -845,8 +858,7 @@ ServerApp::_HandleMessage(int32 code, void* data, size_t size)
case SERVER_SET_ITEM_AUDIO_GAIN:
{
const server_set_item_audio_gain_request& request
= *reinterpret_cast<const server_set_item_audio_gain_request*>(
data);
= *static_cast<const server_set_item_audio_gain_request*>(data);
server_set_ref_for_reply reply;
status_t status = gMediaFilesManager->SetAudioGainFor(request.type,
@@ -858,7 +870,7 @@ ServerApp::_HandleMessage(int32 code, void* data, size_t size)
case SERVER_GET_READERS:
{
const server_get_readers_request *request
= reinterpret_cast<const server_get_readers_request *>(data);
= static_cast<const server_get_readers_request *>(data);
server_get_readers_reply reply;
rv = gAddOnManager->GetReaders(reply.ref, &reply.count,
MAX_READERS);
@@ -869,7 +881,7 @@ ServerApp::_HandleMessage(int32 code, void* data, size_t size)
case SERVER_GET_DECODER_FOR_FORMAT:
{
const server_get_decoder_for_format_request *request
= reinterpret_cast<
= static_cast<
const server_get_decoder_for_format_request *>(data);
server_get_decoder_for_format_reply reply;
rv = gAddOnManager->GetDecoderForFormat(&reply.ref,
@@ -881,7 +893,7 @@ ServerApp::_HandleMessage(int32 code, void* data, size_t size)
case SERVER_GET_WRITER_FOR_FORMAT_FAMILY:
{
const server_get_writer_request *request
= reinterpret_cast<const server_get_writer_request *>(data);
= static_cast<const server_get_writer_request *>(data);
server_get_writer_reply reply;
rv = gAddOnManager->GetWriter(&reply.ref, request->internal_id);
request->SendReply(rv, &reply, sizeof(reply));
@@ -891,8 +903,7 @@ ServerApp::_HandleMessage(int32 code, void* data, size_t size)
case SERVER_GET_FILE_FORMAT_FOR_COOKIE:
{
const server_get_file_format_request *request
= reinterpret_cast<
const server_get_file_format_request *>(data);
= static_cast<const server_get_file_format_request *>(data);
server_get_file_format_reply reply;
rv = gAddOnManager->GetFileFormat(&reply.file_format,
request->cookie);
@@ -903,8 +914,7 @@ ServerApp::_HandleMessage(int32 code, void* data, size_t size)
case SERVER_GET_CODEC_INFO_FOR_COOKIE:
{
const server_get_codec_info_request *request
= reinterpret_cast<
const server_get_codec_info_request *>(data);
= static_cast<const server_get_codec_info_request *>(data);
server_get_codec_info_reply reply;
rv = gAddOnManager->GetCodecInfo(&reply.codec_info,
&reply.format_family, &reply.input_format,
@@ -916,7 +926,7 @@ ServerApp::_HandleMessage(int32 code, void* data, size_t size)
case SERVER_GET_ENCODER_FOR_CODEC_INFO:
{
const server_get_encoder_for_codec_info_request *request
= reinterpret_cast<
= static_cast<
const server_get_encoder_for_codec_info_request *>(data);
server_get_encoder_for_codec_info_reply reply;
rv = gAddOnManager->GetEncoder(&reply.ref, request->id);
src/servers/media_addon/MediaAddonServer.cpp
+17 -17
View File
@@ -354,7 +354,7 @@ void
MediaAddonServer::MessageReceived(BMessage* message)
{
switch (message->what) {
case MEDIA_ADDON_SERVER_PLAY_MEDIA:
case MEDIA_ADD_ON_SERVER_PLAY_MEDIA:
{
const char* name;
const char* type;
@@ -381,39 +381,39 @@ void
MediaAddonServer::_HandleMessage(int32 code, const void* data, size_t size)
{
switch (code) {
case ADDONSERVER_INSTANTIATE_DORMANT_NODE:
case ADD_ON_SERVER_INSTANTIATE_DORMANT_NODE:
{
const addonserver_instantiate_dormant_node_request* request
const add_on_server_instantiate_dormant_node_request* request
= static_cast<
const addonserver_instantiate_dormant_node_request*>(data);
addonserver_instantiate_dormant_node_reply reply;
const add_on_server_instantiate_dormant_node_request*>(
data);
add_on_server_instantiate_dormant_node_reply reply;
status_t status
= MediaRosterEx(fMediaRoster)->InstantiateDormantNode(
request->addon_id, request->flavor_id,
request->add_on_id, request->flavor_id,
request->creator_team, &reply.node);
request->SendReply(status, &reply, sizeof(reply));
break;
}
case ADDONSERVER_RESCAN_MEDIAADDON_FLAVORS:
case ADD_ON_SERVER_RESCAN_ADD_ON_FLAVORS:
{
const addonserver_rescan_mediaaddon_flavors_command* command
= static_cast<
const addonserver_rescan_mediaaddon_flavors_command*>(data);
BMediaAddOn* addon
= gDormantNodeManager->GetAddOn(command->addon_id);
if (addon == NULL) {
const add_on_server_rescan_flavors_command* command = static_cast<
const add_on_server_rescan_flavors_command*>(data);
BMediaAddOn* addOn
= gDormantNodeManager->GetAddOn(command->add_on_id);
if (addOn == NULL) {
ERROR("rescan flavors: Can't find a addon object for id %d\n",
(int)command->addon_id);
(int)command->add_on_id);
break;
}
_ScanAddOnFlavors(addon);
gDormantNodeManager->PutAddOn(command->addon_id);
_ScanAddOnFlavors(addOn);
gDormantNodeManager->PutAddOn(command->add_on_id);
break;
}
case ADDONSERVER_RESCAN_FINISHED_NOTIFY:
case ADD_ON_SERVER_RESCAN_FINISHED_NOTIFY:
if (fStartupSound) {
system_beep(MEDIA_SOUNDS_STARTUP);
fStartupSound = false;