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; struct command_data;
// BMessage based data exchange with the media_server // BMessage based data exchange with the media_server
status_t SendToServer(BMessage *msg); status_t SendToServer(BMessage* msg);
status_t QueryServer(BMessage &request, BMessage &reply); status_t 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); status_t SendToServer(int32 msgCode, command_data* msg, size_t size);
status_t QueryServer(int32 msgcode, request_data *request, int requestsize, status_t QueryServer(int32 msgCode, request_data* request, size_t requestSize,
reply_data *reply, int replysize); reply_data* reply, size_t 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); status_t SendToAddOnServer(int32 msgCode, command_data *msg, size_t size);
status_t QueryAddonServer(int32 msgcode, request_data *request, int requestSize, status_t QueryAddOnServer(int32 msgCode, request_data* request,
reply_data *reply, int replysize); size_t requestSize, reply_data* reply, size_t replySize);
// Raw data based data exchange with any (media node control-) port // Raw data based data exchange with any (media node control-) port
status_t SendToPort(port_id sendport, int32 msgcode, command_data *msg, status_t SendToPort(port_id sendPort, int32 msgCode, command_data* msg,
int size); size_t size);
status_t QueryPort(port_id requestport, int32 msgcode, request_data *request, status_t QueryPort(port_id requestPort, int32 msgCode, request_data* request,
int requestsize, reply_data *reply, int replysize); size_t requestSize, reply_data* reply, size_t replySize);
// The base struct used for all raw requests // The base struct used for all raw requests
struct request_data { struct request_data {
@@ -104,14 +104,14 @@ enum {
// add_system_beep_event() // add_system_beep_event()
MEDIA_SERVER_ADD_SYSTEM_BEEP_EVENT, MEDIA_SERVER_ADD_SYSTEM_BEEP_EVENT,
// media addon server // media add-on server
MEDIA_ADDON_SERVER_PLAY_MEDIA = '_TRU' MEDIA_ADD_ON_SERVER_PLAY_MEDIA = '_TRU'
}; };
// Raw port based communication // Raw port based communication
enum { enum {
ADDONSERVER_RESCAN_MEDIAADDON_FLAVORS = 0x50, ADD_ON_SERVER_RESCAN_ADD_ON_FLAVORS = 0x50,
ADDONSERVER_RESCAN_FINISHED_NOTIFY, ADD_ON_SERVER_RESCAN_FINISHED_NOTIFY,
SERVER_MESSAGE_START = 0x100, SERVER_MESSAGE_START = 0x100,
SERVER_REGISTER_APP, SERVER_REGISTER_APP,
@@ -134,7 +134,7 @@ enum {
SERVER_UNREGISTER_BUFFER, SERVER_UNREGISTER_BUFFER,
SERVER_RESCAN_DEFAULTS, SERVER_RESCAN_DEFAULTS,
SERVER_SET_NODE_CREATOR, SERVER_SET_NODE_CREATOR,
SERVER_CHANGE_ADDON_FLAVOR_INSTANCES_COUNT, SERVER_CHANGE_FLAVOR_INSTANCES_COUNT,
SERVER_GET_MEDIA_FILE_TYPES, SERVER_GET_MEDIA_FILE_TYPES,
SERVER_GET_MEDIA_FILE_ITEMS, SERVER_GET_MEDIA_FILE_ITEMS,
SERVER_GET_REF_FOR, SERVER_GET_REF_FOR,
@@ -294,16 +294,31 @@ enum {
MAX_READERS = 40, 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; int32 flavor_id;
team_id creator_team; 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; 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 { struct server_set_node_request : request_data {
node_type type; node_type type;
bool use_node; bool use_node;
@@ -330,158 +345,6 @@ struct server_get_node_reply : public reply_data {
int32 input_id; 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 { struct server_publish_inputs_request : request_data {
media_node node; media_node node;
int32 count; int32 count;
@@ -506,90 +369,6 @@ struct server_publish_outputs_request : area_request_data {
struct server_publish_outputs_reply : reply_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 { struct server_register_app_request : request_data {
team_id team; team_id team;
BMessenger messenger; BMessenger messenger;
@@ -613,19 +392,19 @@ struct server_set_node_creator_request : request_data {
struct server_set_node_creator_reply : reply_data { struct server_set_node_creator_reply : reply_data {
}; };
struct server_change_addon_flavor_instances_count_request : request_data { struct server_change_flavor_instances_count_request : request_data {
media_addon_id addon_id; media_addon_id add_on_id;
int32 flavor_id; int32 flavor_id;
int32 delta; // must be +1 or -1 int32 delta; // must be +1 or -1
team_id team; 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 { struct server_register_node_request : request_data {
media_addon_id addon_id; media_addon_id add_on_id;
int32 addon_flavor_id; int32 flavor_id;
char name[B_MEDIA_NAME_LENGTH]; char name[B_MEDIA_NAME_LENGTH];
uint64 kinds; uint64 kinds;
port_id port; port_id port;
@@ -642,7 +421,7 @@ struct server_unregister_node_request : request_data {
}; };
struct server_unregister_node_reply : reply_data { struct server_unregister_node_reply : reply_data {
media_addon_id addon_id; media_addon_id add_on_id;
int32 flavor_id; int32 flavor_id;
}; };
@@ -654,13 +433,13 @@ struct server_get_live_node_info_reply : reply_data {
live_node_info live_info; live_node_info live_info;
}; };
struct server_get_live_nodes_request : request_data { struct server_get_live_nodes_request : request_area_data {
int32 maxcount; int32 max_count;
bool has_input; bool has_input;
bool has_output; bool has_output;
bool has_name; bool has_name;
media_format inputformat; media_format input_format;
media_format outputformat; media_format output_format;
char name[B_MEDIA_NAME_LENGTH + 1]; char name[B_MEDIA_NAME_LENGTH + 1];
// +1 for a trailing "*" // +1 for a trailing "*"
uint64 require_kinds; uint64 require_kinds;
@@ -707,9 +486,9 @@ struct server_get_dormant_node_for_reply : reply_data {
}; };
struct server_get_instances_for_request : request_data { struct server_get_instances_for_request : request_data {
int32 maxcount; media_addon_id add_on_id;
media_addon_id addon_id; int32 flavor_id;
int32 addon_flavor_id; int32 max_count;
}; };
struct server_get_instances_for_reply : reply_data { 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 server_rescan_defaults_command : command_data {
}; };
struct addonserver_rescan_mediaaddon_flavors_command : command_data { struct server_register_add_on_request : request_data {
media_addon_id addon_id;
};
struct addonserver_rescan_finished_notify_command : command_data {
};
struct server_register_mediaaddon_request : request_data {
xfer_entry_ref ref; xfer_entry_ref ref;
}; };
struct server_register_mediaaddon_reply : reply_data { struct server_register_add_on_reply : reply_data {
media_addon_id addon_id; media_addon_id add_on_id;
}; };
struct server_unregister_mediaaddon_command : command_data { struct server_unregister_add_on_command : command_data {
media_addon_id addon_id; media_addon_id add_on_id;
}; };
struct server_get_mediaaddon_ref_request : request_data { struct server_get_add_on_ref_request : request_data {
media_addon_id addon_id; 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; xfer_entry_ref ref;
}; };
@@ -893,6 +665,254 @@ struct server_get_codec_info_reply : reply_data {
// the codec info matching the cookie // 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 { struct node_request_completed_command : command_data {
media_request_info info; media_request_info info;
}; };
@@ -934,6 +954,10 @@ struct node_get_timesource_reply : reply_data {
struct node_final_release_command : command_data { struct node_final_release_command : command_data {
}; };
// #pragma mark - time source commands
struct timesource_add_slave_node_command : command_data { struct timesource_add_slave_node_command : command_data {
media_node node; media_node node;
}; };
@@ -949,6 +973,10 @@ struct timesource_get_start_latency_reply : reply_data {
bigtime_t start_latency; bigtime_t start_latency;
}; };
// #pragma mark - file interface commands
struct fileinterface_set_ref_request : request_data { struct fileinterface_set_ref_request : request_data {
dev_t device; dev_t device;
ino_t directory; ino_t directory;
@@ -982,6 +1010,10 @@ struct fileinterface_sniff_ref_reply : reply_data {
float capability; float capability;
}; };
// #pragma mark - controllable commands
struct controllable_get_parameter_web_request : area_request_data { struct controllable_get_parameter_web_request : area_request_data {
int32 max_size; int32 max_size;
}; };
headers/private/media/ServerInterface.h
+4 -4
View File
@@ -14,10 +14,10 @@
enum { enum {
ADDONSERVER_INSTANTIATE_DORMANT_NODE, ADD_ON_SERVER_INSTANTIATE_DORMANT_NODE,
SERVER_REGISTER_MEDIAADDON, SERVER_REGISTER_ADD_ON,
SERVER_UNREGISTER_MEDIAADDON, SERVER_UNREGISTER_ADD_ON,
SERVER_GET_MEDIAADDON_REF, SERVER_GET_ADD_ON_REF,
SERVER_REGISTER_DORMANT_NODE, SERVER_REGISTER_DORMANT_NODE,
SERVER_GET_DORMANT_NODES, SERVER_GET_DORMANT_NODES,
SERVER_GET_DORMANT_FLAVOR_INFO, SERVER_GET_DORMANT_FLAVOR_INFO,
src/kits/media/DataExchange.cpp
+91 -75
View File
@@ -26,55 +26,55 @@ namespace media {
namespace dataexchange { namespace dataexchange {
BMessenger* MediaServerMessenger; BMessenger* gMediaServerMessenger;
static port_id MediaServerPort; static port_id sMediaServerPort;
static port_id MediaAddonServerPort; static port_id sMediaAddonServerPort;
void find_media_server_port(); static void find_media_server_port();
void find_media_addon_server_port(); static void find_media_addon_server_port();
static BMessenger* static BMessenger*
GetMediaServerMessenger() GetMediaServerMessenger()
{ {
static BMessenger* messenger = new BMessenger(B_MEDIA_SERVER_SIGNATURE); static BMessenger* messenger = new BMessenger(B_MEDIA_SERVER_SIGNATURE);
return MediaServerMessenger = messenger; return gMediaServerMessenger = messenger;
} }
class initit { class initit {
public: public:
initit() initit()
{ {
MediaServerMessenger = 0; gMediaServerMessenger = 0;
find_media_server_port(); find_media_server_port();
find_media_addon_server_port(); find_media_addon_server_port();
} }
~initit() ~initit()
{ {
delete MediaServerMessenger; delete gMediaServerMessenger;
} }
}; };
initit _initit; initit _initit;
void static void
find_media_server_port() find_media_server_port()
{ {
MediaServerPort = find_port(MEDIA_SERVER_PORT_NAME); sMediaServerPort = find_port(MEDIA_SERVER_PORT_NAME);
if (MediaServerPort < 0) { if (sMediaServerPort < 0) {
ERROR("couldn't find MediaServerPort\n"); ERROR("couldn't find sMediaServerPort\n");
MediaServerPort = BAD_MEDIA_SERVER_PORT; // make this a unique number sMediaServerPort = BAD_MEDIA_SERVER_PORT; // make this a unique number
} }
} }
void static void
find_media_addon_server_port() find_media_addon_server_port()
{ {
MediaAddonServerPort = find_port(MEDIA_ADDON_SERVER_PORT_NAME); sMediaAddonServerPort = find_port(MEDIA_ADDON_SERVER_PORT_NAME);
if (MediaAddonServerPort < 0) { if (sMediaAddonServerPort < 0) {
ERROR("couldn't find MediaAddonServerPort\n"); ERROR("couldn't find sMediaAddonServerPort\n");
MediaAddonServerPort = BAD_MEDIA_ADDON_SERVER_PORT; // make this a unique number 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 status_t
SendToServer(BMessage *msg) SendToServer(BMessage* msg)
{ {
status_t rv; status_t status = GetMediaServerMessenger()->SendMessage(msg,
rv = GetMediaServerMessenger()->SendMessage(msg, static_cast<BHandler *>(NULL), TIMEOUT); static_cast<BHandler*>(NULL), TIMEOUT);
if (rv != B_OK) { if (status != B_OK) {
ERROR("SendToServer: SendMessage failed, error 0x%08lx (%s)\n", rv, strerror(rv)); ERROR("SendToServer: SendMessage failed: %s\n", strerror(status));
DEBUG_ONLY(msg->PrintToStream()); DEBUG_ONLY(msg->PrintToStream());
} }
return rv; return status;
} }
status_t 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) { 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(request.PrintToStream());
DEBUG_ONLY(reply.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 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 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 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 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 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; status_t status = write_port_etc(sendPort, msgCode, msg, size,
B_RELATIVE_TIMEOUT, TIMEOUT);
rv = write_port_etc(sendport, msgcode, msg, size, B_RELATIVE_TIMEOUT, TIMEOUT); if (status != B_OK) {
if (rv != B_OK) { ERROR("SendToPort: write_port failed, msgcode 0x%lx, port %ld: %s\n",
ERROR("SendToPort: write_port failed, msgcode 0x%lx, port %ld, error %#lx (%s)\n", msgcode, sendport, rv, strerror(rv)); msgCode, sendPort, strerror(status));
if (rv == B_BAD_PORT_ID && sendport == MediaServerPort) { if (status == B_BAD_PORT_ID && sendPort == sMediaServerPort) {
find_media_server_port(); find_media_server_port();
sendport = MediaServerPort; sendPort = sMediaServerPort;
} else if (rv == B_BAD_PORT_ID && sendport == MediaAddonServerPort) { } else if (status == B_BAD_PORT_ID
&& sendPort == sMediaAddonServerPort) {
find_media_addon_server_port(); find_media_addon_server_port();
sendport = MediaAddonServerPort; sendPort = sMediaAddonServerPort;
} else { } else
return rv; return status;
}
rv = write_port_etc(sendport, msgcode, msg, size, B_RELATIVE_TIMEOUT, TIMEOUT); status = write_port_etc(sendPort, msgCode, msg, size,
if (rv != B_OK) { B_RELATIVE_TIMEOUT, TIMEOUT);
ERROR("SendToPort: retrying write_port failed, msgcode 0x%lx, port %ld, error %#lx (%s)\n", msgcode, sendport, rv, strerror(rv)); if (status != B_OK) {
return rv; ERROR("SendToPort: retrying write_port failed, msgCode 0x%lx, "
"port %ld: %s\n", msgCode, sendPort, strerror(status));
return status;
} }
} }
return B_OK; return B_OK;
@@ -176,46 +183,55 @@ SendToPort(port_id sendport, int32 msgcode, command_data *msg, int size)
status_t 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(); 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) { if (status == B_BAD_PORT_ID && requestPort == sMediaServerPort) {
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) {
find_media_server_port(); find_media_server_port();
requestport = MediaServerPort; requestPort = sMediaServerPort;
} else if (rv == B_BAD_PORT_ID && requestport == MediaAddonServerPort) { } else if (status == B_BAD_PORT_ID
&& requestPort == sMediaAddonServerPort) {
find_media_addon_server_port(); find_media_addon_server_port();
requestport = MediaAddonServerPort; requestPort = sMediaAddonServerPort;
} else { } else {
gPortPool->PutPort(request->reply_port); gPortPool->PutPort(request->reply_port);
return rv; return status;
} }
rv = write_port_etc(requestport, msgcode, request, requestsize, B_RELATIVE_TIMEOUT, TIMEOUT); status = write_port_etc(requestPort, msgCode, request, requestSize,
if (rv != B_OK) { B_RELATIVE_TIMEOUT, TIMEOUT);
ERROR("QueryPort: retrying write_port failed, msgcode 0x%lx, port %ld, error %#lx (%s)\n", msgcode, requestport, rv, strerror(rv)); 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); 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); gPortPool->PutPort(request->reply_port);
if (rv < B_OK) { if (status < B_OK) {
ERROR("QueryPort: read_port failed, msgcode 0x%lx, port %ld, error %#lx (%s)\n", msgcode, request->reply_port, rv, strerror(rv)); 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 } // dataexchange
} // media } // media
} // BPrivate } // 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); TRACE("DormantNodeManager::RegisterAddon, path %s\n",path);
server_register_mediaaddon_request msg; server_register_add_on_request msg;
entry_ref ref; entry_ref ref;
status_t status = get_ref_for_path(path, &ref); status_t status = get_ref_for_path(path, &ref);
if (status != B_OK) { if (status != B_OK) {
@@ -216,7 +216,7 @@ DormantNodeManager::RegisterAddOn(const char* path)
msg.reply_port = gPortPool->GetPort(); msg.reply_port = gPortPool->GetPort();
msg.ref = ref; 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) { if (status != B_OK) {
gPortPool->PutPort(msg.reply_port); gPortPool->PutPort(msg.reply_port);
ERROR("DormantNodeManager::RegisterAddon failed, couldn't talk to " ERROR("DormantNodeManager::RegisterAddon failed, couldn't talk to "
@@ -224,7 +224,7 @@ DormantNodeManager::RegisterAddOn(const char* path)
return 0; return 0;
} }
server_register_mediaaddon_reply reply; server_register_add_on_reply reply;
int32 code; int32 code;
status = read_port(msg.reply_port, &code, &reply, sizeof(reply)); 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", 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) if (port < 0)
return; return;
server_unregister_mediaaddon_command msg; server_unregister_add_on_command msg;
msg.addon_id = id; msg.add_on_id = id;
write_port(port, SERVER_UNREGISTER_MEDIAADDON, &msg, sizeof(msg)); 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) if (port < 0)
return B_ERROR; return B_ERROR;
server_get_mediaaddon_ref_request msg; server_get_add_on_ref_request msg;
msg.addon_id = id; msg.add_on_id = id;
msg.reply_port = gPortPool->GetPort(); 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)); sizeof(msg));
if (status != B_OK) { if (status != B_OK) {
gPortPool->PutPort(msg.reply_port); gPortPool->PutPort(msg.reply_port);
return status; return status;
} }
server_get_mediaaddon_ref_reply reply; server_get_add_on_ref_reply reply;
int32 code; int32 code;
status = read_port(msg.reply_port, &code, &reply, sizeof(reply)); 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) if (fAddon == 0)
return B_ERROR; return B_ERROR;
addonserver_rescan_mediaaddon_flavors_command command; add_on_server_rescan_flavors_command command;
command.addon_id = fAddon; command.add_on_id = fAddon;
return SendToAddonServer(ADDONSERVER_RESCAN_MEDIAADDON_FLAVORS, &command, sizeof(command)); 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, BMediaRosterEx::IncrementAddonFlavorInstancesCount(media_addon_id addonID,
int32 flavorID) int32 flavorID)
{ {
server_change_addon_flavor_instances_count_request request; server_change_flavor_instances_count_request request;
server_change_addon_flavor_instances_count_reply reply; server_change_flavor_instances_count_reply reply;
request.addon_id = addonID; request.add_on_id = addonID;
request.flavor_id = flavorID; request.flavor_id = flavorID;
request.delta = 1; request.delta = 1;
request.team = BPrivate::current_team(); 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)); sizeof(request), &reply, sizeof(reply));
} }
@@ -170,14 +170,14 @@ status_t
BMediaRosterEx::DecrementAddonFlavorInstancesCount(media_addon_id addonID, BMediaRosterEx::DecrementAddonFlavorInstancesCount(media_addon_id addonID,
int32 flavorID) int32 flavorID)
{ {
server_change_addon_flavor_instances_count_request request; server_change_flavor_instances_count_request request;
server_change_addon_flavor_instances_count_reply reply; server_change_flavor_instances_count_reply reply;
request.addon_id = addonID; request.add_on_id = addonID;
request.flavor_id = flavorID; request.flavor_id = flavorID;
request.delta = -1; request.delta = -1;
request.team = BPrivate::current_team(); 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)); sizeof(request), &reply, sizeof(reply));
} }
@@ -1419,77 +1419,59 @@ BMediaRoster::GetLiveNodeInfo(const media_node& node,
status_t 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 media_format* hasInput, const media_format* hasOutput,
const char* name, uint64 nodeKinds) const char* name, uint64 nodeKinds)
{ {
CALLED(); CALLED();
if (_liveNodes == NULL || _totalCount == NULL || *_totalCount <= 0) if (liveNodes == NULL || _totalCount == NULL || *_totalCount <= 0)
return B_BAD_VALUE; return B_BAD_VALUE;
// TODO: we also support the wildcard search as GetDormantNodes does. // TODO: we also support the wildcard search as GetDormantNodes does.
// This needs to be documented // This needs to be documented
server_get_live_nodes_request request; server_get_live_nodes_request request;
server_get_live_nodes_reply reply; request.team = BPrivate::current_team();
status_t rv;
request.maxcount = *_totalCount; request.max_count = *_totalCount;
request.has_input = hasInput != NULL; request.has_input = hasInput != NULL;
if (hasInput != NULL) { if (hasInput != NULL) {
// TODO: we should not make a flat copy of media_format // TODO: we should not make a flat copy of media_format
request.inputformat = *hasInput; request.input_format = *hasInput;
} }
request.has_output = hasOutput != NULL; request.has_output = hasOutput != NULL;
if (hasOutput != NULL) { if (hasOutput != NULL) {
// TODO: we should not make a flat copy of media_format // TODO: we should not make a flat copy of media_format
request.outputformat = *hasOutput; request.output_format = *hasOutput;
} }
request.has_name = name != NULL; request.has_name = name != NULL;
if (name != NULL) { if (name != NULL)
int len = strlen(name); strlcpy(request.name, name, sizeof(request.name));
len = min_c(len, (int)sizeof(request.name) - 1);
memcpy(request.name, name, len);
request.name[len] = 0;
}
request.require_kinds = nodeKinds; request.require_kinds = nodeKinds;
rv = QueryServer(SERVER_GET_LIVE_NODES, &request, sizeof(request), server_get_live_nodes_reply reply;
&reply, sizeof(reply)); status_t status = QueryServer(SERVER_GET_LIVE_NODES, &request,
if (rv != B_OK) { sizeof(request), &reply, sizeof(reply));
ERROR("BMediaRoster::GetLiveNodes failed querying server\n"); if (status != B_OK) {
ERROR("BMediaRoster::GetLiveNodes failed querying server: %s\n",
strerror(status));
*_totalCount = 0; *_totalCount = 0;
return rv; return status;
} }
if (reply.count > MAX_LIVE_INFO) { const live_node_info* info;
live_node_info* liveInfo; if (reply.area >= 0)
area_id clone; info = (live_node_info*)reply.address;
else
info = reply.live_info;
clone = clone_area("live_node_info clone", for (int32 i = 0; i < reply.count; i++)
reinterpret_cast<void **>(&liveInfo), B_ANY_ADDRESS, liveNodes[i] = info[i];
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++) { if (reply.area >= 0)
_liveNodes[i] = liveInfo[i];
}
delete_area(clone);
delete_area(reply.area); 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; return B_OK;
} }
@@ -1885,7 +1867,7 @@ BMediaRoster::RegisterNode(BMediaNode* node)
status_t status_t
BMediaRosterEx::RegisterNode(BMediaNode* node, media_addon_id addonID, BMediaRosterEx::RegisterNode(BMediaNode* node, media_addon_id addOnID,
int32 flavorID) int32 flavorID)
{ {
CALLED(); CALLED();
@@ -1899,16 +1881,15 @@ BMediaRosterEx::RegisterNode(BMediaNode* node, media_addon_id addonID,
int32 testFlavorID; int32 testFlavorID;
BMediaAddOn* addon = node->AddOn(&testFlavorID); BMediaAddOn* addon = node->AddOn(&testFlavorID);
ASSERT(addonID == addon != NULL ? addon->AddonID() : -1); ASSERT(addOnID == addon != NULL ? addon->AddonID() : -1);
ASSERT(flavorID == testFlavorID); ASSERT(flavorID == testFlavorID);
); );
status_t rv;
server_register_node_request request; server_register_node_request request;
server_register_node_reply reply; server_register_node_reply reply;
request.addon_id = addonID; request.add_on_id = addOnID;
request.addon_flavor_id = flavorID; request.flavor_id = flavorID;
strcpy(request.name, node->Name()); strcpy(request.name, node->Name());
request.kinds = node->Kinds(); request.kinds = node->Kinds();
request.port = node->ControlPort(); 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, "%ld, kinds 0x%Lx, team %ld, name '%s'\n", request.port, request.kinds,
request.team, request.name); request.team, request.name);
rv = QueryServer(SERVER_REGISTER_NODE, &request, sizeof(request), &reply, status_t status = QueryServer(SERVER_REGISTER_NODE, &request,
sizeof(reply)); sizeof(request), &reply, sizeof(reply));
if (rv != B_OK) { if (status != B_OK) {
ERROR("BMediaRoster::RegisterNode: failed to register node %s (error " ERROR("BMediaRoster::RegisterNode: failed to register node %s: %s\n",
"%#lx)\n", node->Name(), rv); node->Name(), strerror(status));
return rv; return status;
} }
TRACE("BMediaRoster::RegisterNode: QueryServer SERVER_REGISTER_NODE " 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 // if the BMediaNode also inherits from BTimeSource, we need to call
// BTimeSource::FinishCreate() // BTimeSource::FinishCreate()
if (node->Kinds() & B_TIME_SOURCE) { if ((node->Kinds() & B_TIME_SOURCE) != 0) {
BTimeSource *ts; if (BTimeSource* timeSource = dynamic_cast<BTimeSource*>(node))
ts = dynamic_cast<BTimeSource *>(node); timeSource->FinishCreate();
if (ts)
ts->FinishCreate();
} }
TRACE("BMediaRoster::RegisterNode: publishing inputs/outputs\n"); 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. // if we send a message and wait for a reply here.
// We have a pointer to the node, and thus call the functions directly // We have a pointer to the node, and thus call the functions directly
if (node->Kinds() & B_BUFFER_PRODUCER) { if ((node->Kinds() & B_BUFFER_PRODUCER) != 0) {
BBufferProducer *bp; if (BBufferProducer* producer = dynamic_cast<BBufferProducer*>(node)) {
bp = dynamic_cast<BBufferProducer *>(node);
if (bp) {
List<media_output> list; List<media_output> list;
if (B_OK == GetAllOutputs(bp, &list)) if (GetAllOutputs(producer, &list) == B_OK)
PublishOutputs(node->Node(), &list); PublishOutputs(node->Node(), &list);
} }
} }
if ((node->Kinds() & B_BUFFER_CONSUMER) != 0) { if ((node->Kinds() & B_BUFFER_CONSUMER) != 0) {
BBufferConsumer* consumer = dynamic_cast<BBufferConsumer*>(node); if (BBufferConsumer* consumer = dynamic_cast<BBufferConsumer*>(node)) {
if (consumer != NULL) {
List<media_input> list; List<media_input> list;
if (GetAllInputs(consumer, &list) == B_OK) if (GetAllInputs(consumer, &list) == B_OK)
PublishInputs(node->Node(), &list); PublishInputs(node->Node(), &list);
@@ -1982,13 +1958,19 @@ BMediaRosterEx::RegisterNode(BMediaNode* node, media_addon_id addonID,
TRACE("BMediaRoster::RegisterNode: finished\n"); 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 this %p\n", node);
TRACE("BMediaRoster::RegisterNode: node fConsumerThis %p\n", node->fConsumerThis); TRACE("BMediaRoster::RegisterNode: node fConsumerThis %p\n",
TRACE("BMediaRoster::RegisterNode: node fProducerThis %p\n", node->fProducerThis); node->fConsumerThis);
TRACE("BMediaRoster::RegisterNode: node fFileInterfaceThis %p\n", node->fFileInterfaceThis); TRACE("BMediaRoster::RegisterNode: node fProducerThis %p\n",
TRACE("BMediaRoster::RegisterNode: node fControllableThis %p\n", node->fControllableThis); node->fProducerThis);
TRACE("BMediaRoster::RegisterNode: node fTimeSourceThis %p\n", node->fTimeSourceThis); 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; return B_OK;
} }
@@ -2043,7 +2025,7 @@ BMediaRoster::UnregisterNode(BMediaNode* node)
return status; return status;
} }
if (reply.addon_id != -1) { if (reply.add_on_id != -1) {
// TODO: this doesn't look right // TODO: this doesn't look right
// Small problem here, we can't use DormantNodeManager::PutAddOn(), as // Small problem here, we can't use DormantNodeManager::PutAddOn(), as
// UnregisterNode() is called by a dormant node itself (by the // 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 // The add-on that contains the node needs to remain in memory until the
// destructor execution is finished. // destructor execution is finished.
// DormantNodeManager::PutAddOnDelayed() will delay unloading. // DormantNodeManager::PutAddOnDelayed() will delay unloading.
gDormantNodeManager->PutAddOnDelayed(reply.addon_id); gDormantNodeManager->PutAddOnDelayed(reply.add_on_id);
status = MediaRosterEx(this)->DecrementAddonFlavorInstancesCount( status = MediaRosterEx(this)->DecrementAddonFlavorInstancesCount(
reply.addon_id, reply.flavor_id); reply.add_on_id, reply.flavor_id);
if (status != B_OK) { if (status != B_OK) {
ERROR("BMediaRoster::UnregisterNode: " ERROR("BMediaRoster::UnregisterNode: "
"DecrementAddonFlavorInstancesCount() failed\n"); "DecrementAddonFlavorInstancesCount() failed\n");
@@ -2545,13 +2527,13 @@ BMediaRoster::InstantiateDormantNode(const dormant_node_info& info,
TRACE("BMediaRoster::InstantiateDormantNode: creating global object " TRACE("BMediaRoster::InstantiateDormantNode: creating global object "
"in media_addon_server\n"); "in media_addon_server\n");
addonserver_instantiate_dormant_node_request request; add_on_server_instantiate_dormant_node_request request;
addonserver_instantiate_dormant_node_reply reply; add_on_server_instantiate_dormant_node_reply reply;
request.addon_id = info.addon; request.add_on_id = info.addon;
request.flavor_id = info.flavor_id; request.flavor_id = info.flavor_id;
request.creator_team = BPrivate::current_team(); request.creator_team = BPrivate::current_team();
// creator team is allowed to also release global nodes // 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)); sizeof(request), &reply, sizeof(reply));
if (rv == B_OK) if (rv == B_OK)
*_node = reply.node; *_node = reply.node;
@@ -3045,9 +3027,9 @@ BMediaRoster::GetInstancesFor(media_addon_id addon, int32 flavor,
server_get_instances_for_reply reply; server_get_instances_for_reply reply;
status_t rv; status_t rv;
request.maxcount = (_count ? *_count : 1); request.max_count = (_count ? *_count : 1);
request.addon_id = addon; request.add_on_id = addon;
request.addon_flavor_id = flavor; request.flavor_id = flavor;
rv = QueryServer(SERVER_GET_INSTANCES_FOR, &request, sizeof(request), rv = QueryServer(SERVER_GET_INSTANCES_FOR, &request, sizeof(request),
&reply, sizeof(reply)); &reply, sizeof(reply));
src/servers/media/AppManager.cpp
+1 -1
View File
@@ -109,7 +109,7 @@ AppManager::UnregisterTeam(team_id team)
team_id team_id
AppManager::AddonServerTeam() AppManager::AddOnServerTeam()
{ {
team_id id = be_roster->TeamFor(B_MEDIA_ADDON_SERVER_SIGNATURE); team_id id = be_roster->TeamFor(B_MEDIA_ADDON_SERVER_SIGNATURE);
if (id < 0) { if (id < 0) {
src/servers/media/AppManager.h
+1 -1
View File
@@ -22,7 +22,7 @@ public:
status_t UnregisterTeam(team_id team); status_t UnregisterTeam(team_id team);
bool HasTeam(team_id team); bool HasTeam(team_id team);
team_id AddonServerTeam(); team_id AddOnServerTeam();
status_t SendMessage(team_id team, BMessage* message); 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; dormant_node_info info;
media_node node; media_node node;
entry_ref ref; entry_ref ref;
if (node_manager->GetCloneForID(&node, media_node_ids[i], be_app->Team()) != B_OK) if (node_manager->GetCloneForID(media_node_ids[i], be_app->Team(),
continue; &node) != B_OK
if (node_manager->GetDormantNodeInfo(&info, node) != B_OK) || node_manager->GetDormantNodeInfo(node, &info) != B_OK
continue; || node_manager->ReleaseNodeReference(media_node_ids[i],
if (node_manager->DecrementGlobalRefCount(media_node_ids[i], be_app->Team()) != B_OK) be_app->Team()) != B_OK
continue; || node_manager->GetAddOnRef(info.addon, &ref) != B_OK)
if (node_manager->GetAddonRef(&ref, info.addon)!=B_OK)
continue; continue;
BPath path(&ref); BPath path(&ref);
@@ -337,15 +336,16 @@ DefaultManager::RescanThread()
ERROR("DefaultManager: Did not try to connect mixer and soundcard\n"); ERROR("DefaultManager: Did not try to connect mixer and soundcard\n");
} }
addonserver_rescan_finished_notify_command cmd; add_on_server_rescan_finished_notify_command cmd;
SendToAddonServer(ADDONSERVER_RESCAN_FINISHED_NOTIFY, &cmd, sizeof(cmd)); SendToAddOnServer(ADD_ON_SERVER_RESCAN_FINISHED_NOTIFY, &cmd, sizeof(cmd));
printf("DefaultManager::RescanThread() leave\n"); printf("DefaultManager::RescanThread() leave\n");
} }
void 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]; live_node_info info[MAX_NODE_INFOS];
media_format format; 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. * Copyright 2002, Marcus Overhagen. All rights reserved.
* Distributed under the terms of the MIT License. * 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 "TStack.h"
#include "DataExchange.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 DefaultManager;
class BufferManager; 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: public:
NodeManager(); NodeManager();
~NodeManager(); ~NodeManager();
status_t LoadState(); // Management of system wide default nodes
status_t SaveState(); 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 */ // Add media_node_id of all live nodes to the message
status_t SetDefaultNode(node_type type, const media_node *node, const dormant_node_info *info, const media_input *input); // int32 "media_node_id" (multiple items)
status_t GetDefaultNode(media_node_id* nodeID, char* name, int32* id, status_t GetLiveNodes(BMessage* message);
node_type type);
status_t RescanDefaultNodes();
/* Management of live nodes */ void RegisterAddOn(const entry_ref& ref,
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); media_addon_id* _newID);
status_t UnregisterNode(media_addon_id *addonid, int32 *flavorid, media_node_id nodeid, team_id team); void UnregisterAddOn(media_addon_id id);
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);
/* Add media_node_id of all live nodes to the message status_t AddDormantFlavorInfo(
* int32 "media_node_id" (multiple items) const dormant_flavor_info& flavorInfo);
*/ void InvalidateDormantFlavorInfo(media_addon_id id);
status_t GetLiveNodes(BMessage *msg); void RemoveDormantFlavorInfo(media_addon_id id);
void CleanupDormantFlavorInfos();
void RegisterAddon(const entry_ref &ref, media_addon_id *newid); status_t IncrementFlavorInstancesCount(
void UnregisterAddon(media_addon_id id); 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); status_t GetAddOnRef(media_addon_id addOnID,
void InvalidateDormantFlavorInfo(media_addon_id id); entry_ref* ref);
void RemoveDormantFlavorInfo(media_addon_id id); status_t GetDormantNodes(dormant_node_info* infos,
void CleanupDormantFlavorInfos(); 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 GetDormantFlavorInfoFor(media_addon_id addOnID,
status_t DecrementAddonFlavorInstancesCount(media_addon_id addonid, int32 flavorid, team_id team); int32 flavorID,
dormant_flavor_info* flavorInfo);
status_t GetAddonRef(entry_ref *ref, media_addon_id id); void CleanupTeam(team_id team);
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 */);
status_t GetDormantFlavorInfoFor(media_addon_id addon, status_t LoadState();
int32 flavor_id, status_t SaveState();
dormant_flavor_info *outFlavor);
void CleanupTeam(team_id team); void Dump();
private: private:
media_addon_id fNextAddOnID; status_t _AcquireNodeReference(media_node_id id,
media_node_id fNextNodeID; team_id team);
BLocker *fLocker; private:
List<dormant_addon_flavor_info> *fDormantAddonFlavorList; typedef std::map<media_addon_id, registered_node> NodeMap;
Map<media_addon_id,entry_ref> *fAddonPathMap; typedef std::vector<dormant_add_on_flavor_info> DormantFlavorList;
Map<media_node_id,registered_node> *fRegisteredNodeMap; typedef std::map<media_addon_id, entry_ref> PathMap;
DefaultManager *fDefaultManager;
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); virtual void MessageReceived(BMessage* message);
private: private:
void _HandleMessage(int32 code, void* data, void _HandleMessage(int32 code, const void* data,
size_t size); size_t size);
void _LaunchAddOnServer(); void _LaunchAddOnServer();
void _QuitAddOnServer(); void _QuitAddOnServer();
@@ -271,27 +271,27 @@ ServerApp::_QuitAddOnServer()
void void
ServerApp::_HandleMessage(int32 code, void* data, size_t size) ServerApp::_HandleMessage(int32 code, const void* data, size_t size)
{ {
status_t rv; status_t rv;
TRACE("ServerApp::HandleMessage %#lx enter\n", code); TRACE("ServerApp::HandleMessage %#lx enter\n", code);
switch (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 const server_change_flavor_instances_count_request& request
= reinterpret_cast< = *static_cast<
const server_change_addon_flavor_instances_count_request *>( const server_change_flavor_instances_count_request*>(data);
data); server_change_flavor_instances_count_reply reply;
server_change_addon_flavor_instances_count_reply reply; status_t status = B_BAD_VALUE;
ASSERT(request->delta == 1 || request->delta == -1);
if (request->delta == 1) { if (request.delta == 1) {
rv = gNodeManager->IncrementAddonFlavorInstancesCount( status = gNodeManager->IncrementFlavorInstancesCount(
request->addon_id, request->flavor_id, request->team); request.add_on_id, request.flavor_id, request.team);
} else { } else if (request.delta == -1) {
rv = gNodeManager->DecrementAddonFlavorInstancesCount( status = gNodeManager->DecrementFlavorInstancesCount(
request->addon_id, request->flavor_id, request->team); request.add_on_id, request.flavor_id, request.team);
} }
request->SendReply(rv, &reply, sizeof(reply)); request.SendReply(status, &reply, sizeof(reply));
break; break;
} }
@@ -303,100 +303,112 @@ ServerApp::_HandleMessage(int32 code, void* data, size_t size)
case SERVER_REGISTER_APP: case SERVER_REGISTER_APP:
{ {
const server_register_app_request *request const server_register_app_request& request = *static_cast<
= reinterpret_cast<const server_register_app_request *>(data); const server_register_app_request*>(data);
server_register_app_reply reply; 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; break;
} }
case SERVER_UNREGISTER_APP: case SERVER_UNREGISTER_APP:
{ {
const server_unregister_app_request *request const server_unregister_app_request& request = *static_cast<
= reinterpret_cast<const server_unregister_app_request *>( const server_unregister_app_request*>(data);
data);
server_unregister_app_reply reply; 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; break;
} }
case SERVER_GET_MEDIAADDON_REF: case SERVER_GET_ADD_ON_REF:
{ {
server_get_mediaaddon_ref_request *msg const server_get_add_on_ref_request& request = *static_cast<
= (server_get_mediaaddon_ref_request *)data; const server_get_add_on_ref_request*>(data);
server_get_mediaaddon_ref_reply reply; server_get_add_on_ref_reply reply;
entry_ref tempref;
reply.result = gNodeManager->GetAddonRef(&tempref, msg->addon_id); entry_ref ref;
reply.ref = tempref; reply.result = gNodeManager->GetAddOnRef(request.add_on_id, &ref);
write_port(msg->reply_port, 0, &reply, sizeof(reply)); reply.ref = ref;
request.SendReply(reply.result, &reply, sizeof(reply));
break; break;
} }
case SERVER_NODE_ID_FOR: case SERVER_NODE_ID_FOR:
{ {
const server_node_id_for_request *request const server_node_id_for_request& request
= reinterpret_cast<const server_node_id_for_request *>(data); = *static_cast<const server_node_id_for_request*>(data);
server_node_id_for_reply reply; 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; break;
} }
case SERVER_GET_LIVE_NODE_INFO: case SERVER_GET_LIVE_NODE_INFO:
{ {
const server_get_live_node_info_request *request const server_get_live_node_info_request& request = *static_cast<
= reinterpret_cast<const server_get_live_node_info_request *>( const server_get_live_node_info_request*>(data);
data);
server_get_live_node_info_reply reply; server_get_live_node_info_reply reply;
rv = gNodeManager->GetLiveNodeInfo(&reply.live_info,
request->node); status_t status = gNodeManager->GetLiveNodeInfo(request.node,
request->SendReply(rv, &reply, sizeof(reply)); &reply.live_info);
request.SendReply(status, &reply, sizeof(reply));
break; break;
} }
case SERVER_GET_LIVE_NODES: case SERVER_GET_LIVE_NODES:
{ {
const server_get_live_nodes_request *request const server_get_live_nodes_request& request
= reinterpret_cast<const server_get_live_nodes_request *>( = *static_cast<const server_get_live_nodes_request*>(data);
data);
server_get_live_nodes_reply reply; server_get_live_nodes_reply reply;
Stack<live_node_info> livenodes; LiveNodeList nodes;
rv = gNodeManager->GetLiveNodes(
&livenodes, status_t status = gNodeManager->GetLiveNodes(nodes,
request->maxcount, request.max_count,
request->has_input ? &request->inputformat : NULL, request.has_input ? &request.input_format : NULL,
request->has_output ? &request->outputformat : NULL, request.has_output ? &request.output_format : NULL,
request->has_name ? request->name : NULL, request.has_name ? request.name : NULL, request.require_kinds);
request->require_kinds);
reply.count = livenodes.CountItems(); reply.count = nodes.size();
if (reply.count <= MAX_LIVE_INFO) { reply.area = -1;
for (int32 index = 0; index < reply.count; index++)
livenodes.Pop(&reply.live_info[index]); live_node_info* infos = reply.live_info;
reply.area = -1; area_id area = -1;
} else {
// we create an area here, and pass it to the library, if (reply.count > MAX_LIVE_INFO) {
// where it will be deleted. // We create an area here, and transfer it to the client
live_node_info *start_addr; size_t size = (reply.count * sizeof(live_node_info)
size_t size; + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1);
size = ((reply.count * sizeof(live_node_info)) + B_PAGE_SIZE
- 1) & ~(B_PAGE_SIZE - 1); area = create_area("get live nodes", (void**)&infos,
reply.area = create_area("get live nodes", B_ANY_ADDRESS, size, B_NO_LOCK, B_READ_AREA | B_WRITE_AREA);
reinterpret_cast<void **>(&start_addr), B_ANY_ADDRESS, if (area < 0) {
size, B_NO_LOCK, B_READ_AREA | B_WRITE_AREA); reply.area = area;
if (reply.area < B_OK) {
ERROR("SERVER_GET_LIVE_NODES: failed to create area, "
"error %#lx\n", reply.area);
reply.count = 0; 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 // if we couldn't send the message, delete the area
delete_area(reply.area); delete_area(reply.area);
} }
@@ -405,54 +417,57 @@ ServerApp::_HandleMessage(int32 code, void* data, size_t size)
case SERVER_GET_NODE_FOR: case SERVER_GET_NODE_FOR:
{ {
const server_get_node_for_request *request const server_get_node_for_request& request
= reinterpret_cast<const server_get_node_for_request *>(data); = *static_cast<const server_get_node_for_request*>(data);
server_get_node_for_reply reply; server_get_node_for_reply reply;
rv = gNodeManager->GetCloneForID(&reply.clone, request->node_id,
request->team); status_t status = gNodeManager->GetCloneForID(request.node_id,
request->SendReply(rv, &reply, sizeof(reply)); request.team, &reply.clone);
request.SendReply(status, &reply, sizeof(reply));
break; break;
} }
case SERVER_RELEASE_NODE: case SERVER_RELEASE_NODE:
{ {
const server_release_node_request *request const server_release_node_request& request
= reinterpret_cast<const server_release_node_request *>(data); = *static_cast<const server_release_node_request*>(data);
server_release_node_reply reply; 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; break;
} }
case SERVER_REGISTER_NODE: case SERVER_REGISTER_NODE:
{ {
const server_register_node_request *request const server_register_node_request& request
= reinterpret_cast<const server_register_node_request *>(data); = *static_cast<const server_register_node_request*>(data);
server_register_node_reply reply; server_register_node_reply reply;
rv = gNodeManager->RegisterNode(&reply.node_id, request->addon_id,
request->addon_flavor_id, request->name, request->kinds, status_t status = gNodeManager->RegisterNode(request.add_on_id,
request->port, request->team); request.flavor_id, request.name, request.kinds, request.port,
request->SendReply(rv, &reply, sizeof(reply)); request.team, &reply.node_id);
request.SendReply(status, &reply, sizeof(reply));
break; break;
} }
case SERVER_UNREGISTER_NODE: case SERVER_UNREGISTER_NODE:
{ {
const server_unregister_node_request *request const server_unregister_node_request& request
= reinterpret_cast<const server_unregister_node_request *>( = *static_cast<const server_unregister_node_request*>(data);
data);
server_unregister_node_reply reply; server_unregister_node_reply reply;
rv = gNodeManager->UnregisterNode(&reply.addon_id, &reply.flavor_id,
request->node_id, request->team); status_t status = gNodeManager->UnregisterNode(request.node_id,
request->SendReply(rv, &reply, sizeof(reply)); request.team, &reply.add_on_id, &reply.flavor_id);
request.SendReply(status, &reply, sizeof(reply));
break; break;
} }
case SERVER_PUBLISH_INPUTS: case SERVER_PUBLISH_INPUTS:
{ {
const server_publish_inputs_request *request const server_publish_inputs_request *request
= reinterpret_cast<const server_publish_inputs_request *>( = static_cast<const server_publish_inputs_request *>(data);
data);
server_publish_inputs_reply reply; server_publish_inputs_reply reply;
if (request->count <= MAX_INPUTS) { if (request->count <= MAX_INPUTS) {
rv = gNodeManager->PublishInputs(request->node, rv = gNodeManager->PublishInputs(request->node,
@@ -460,9 +475,8 @@ ServerApp::_HandleMessage(int32 code, void* data, size_t size)
} else { } else {
media_input *inputs; media_input *inputs;
area_id clone; area_id clone;
clone = clone_area("media_inputs clone", clone = clone_area("media_inputs clone", (void**)&inputs,
reinterpret_cast<void **>(&inputs), B_ANY_ADDRESS, B_ANY_ADDRESS, B_READ_AREA | B_WRITE_AREA, request->area);
B_READ_AREA | B_WRITE_AREA, request->area);
if (clone < B_OK) { if (clone < B_OK) {
ERROR("SERVER_PUBLISH_INPUTS: failed to clone area, " ERROR("SERVER_PUBLISH_INPUTS: failed to clone area, "
"error %#lx\n", clone); "error %#lx\n", clone);
@@ -480,8 +494,7 @@ ServerApp::_HandleMessage(int32 code, void* data, size_t size)
case SERVER_PUBLISH_OUTPUTS: case SERVER_PUBLISH_OUTPUTS:
{ {
const server_publish_outputs_request *request const server_publish_outputs_request *request
= reinterpret_cast<const server_publish_outputs_request *>( = static_cast<const server_publish_outputs_request *>(data);
data);
server_publish_outputs_reply reply; server_publish_outputs_reply reply;
if (request->count <= MAX_OUTPUTS) { if (request->count <= MAX_OUTPUTS) {
rv = gNodeManager->PublishOutputs(request->node, rv = gNodeManager->PublishOutputs(request->node,
@@ -489,7 +502,8 @@ ServerApp::_HandleMessage(int32 code, void* data, size_t size)
} else { } else {
media_output *outputs; media_output *outputs;
area_id clone; 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) { if (clone < B_OK) {
ERROR("SERVER_PUBLISH_OUTPUTS: failed to clone area, " ERROR("SERVER_PUBLISH_OUTPUTS: failed to clone area, "
"error %#lx\n", clone); "error %#lx\n", clone);
@@ -506,74 +520,78 @@ ServerApp::_HandleMessage(int32 code, void* data, size_t size)
case SERVER_GET_NODE: case SERVER_GET_NODE:
{ {
const server_get_node_request *request const server_get_node_request& request
= reinterpret_cast<const server_get_node_request *>(data); = *static_cast<const server_get_node_request*>(data);
server_get_node_reply reply; server_get_node_reply reply;
rv = gNodeManager->GetClone(&reply.node, reply.input_name,
&reply.input_id, request->type, request->team); status_t status = gNodeManager->GetClone(request.type, request.team,
request->SendReply(rv, &reply, sizeof(reply)); &reply.node, reply.input_name, &reply.input_id);
request.SendReply(status, &reply, sizeof(reply));
break; break;
} }
case SERVER_SET_NODE: case SERVER_SET_NODE:
{ {
const server_set_node_request *request const server_set_node_request& request
= reinterpret_cast<const server_set_node_request *>(data); = *static_cast<const server_set_node_request*>(data);
server_set_node_reply reply; server_set_node_reply reply;
rv = gNodeManager->SetDefaultNode(request->type,
request->use_node ? &request->node : NULL, status_t status = gNodeManager->SetDefaultNode(request.type,
request->use_dni ? &request->dni : NULL, request.use_node ? &request.node : NULL,
request->use_input ? &request->input : NULL); request.use_dni ? &request.dni : NULL,
request->SendReply(rv, &reply, sizeof(reply)); request.use_input ? &request.input : NULL);
request.SendReply(status, &reply, sizeof(reply));
break; break;
} }
case SERVER_GET_DORMANT_NODE_FOR: case SERVER_GET_DORMANT_NODE_FOR:
{ {
const server_get_dormant_node_for_request *request const server_get_dormant_node_for_request& request
= reinterpret_cast< = *static_cast<const server_get_dormant_node_for_request*>(
const server_get_dormant_node_for_request *>(data); data);
server_get_dormant_node_for_reply reply; server_get_dormant_node_for_reply reply;
rv = gNodeManager->GetDormantNodeInfo(&reply.node_info,
request->node); status_t status = gNodeManager->GetDormantNodeInfo(request.node,
request->SendReply(rv, &reply, sizeof(reply)); &reply.node_info);
request.SendReply(status, &reply, sizeof(reply));
break; break;
} }
case SERVER_GET_INSTANCES_FOR: case SERVER_GET_INSTANCES_FOR:
{ {
const server_get_instances_for_request *request const server_get_instances_for_request& request
= reinterpret_cast<const server_get_instances_for_request *>( = *static_cast<const server_get_instances_for_request*>(data);
data);
server_get_instances_for_reply reply; server_get_instances_for_reply reply;
rv = gNodeManager->GetInstances(reply.node_id, &reply.count,
min_c(request->maxcount, MAX_NODE_ID), request->addon_id, status_t status = gNodeManager->GetInstances(request.add_on_id,
request->addon_flavor_id); request.flavor_id, reply.node_id, &reply.count,
min_c(request.max_count, MAX_NODE_ID));
if (reply.count == MAX_NODE_ID if (reply.count == MAX_NODE_ID
&& request->maxcount > MAX_NODE_ID) { && request.max_count > MAX_NODE_ID) {
// XXX might be fixed by using an area // TODO: might be fixed by using an area
PRINT(1, "Warning: SERVER_GET_INSTANCES_FOR: returning " PRINT(1, "Warning: SERVER_GET_INSTANCES_FOR: returning "
"possibly truncated list of node id's\n"); "possibly truncated list of node id's\n");
} }
request->SendReply(rv, &reply, sizeof(reply)); request.SendReply(status, &reply, sizeof(reply));
break; break;
} }
case SERVER_REGISTER_MEDIAADDON: case SERVER_REGISTER_ADD_ON:
{ {
server_register_mediaaddon_request *msg const server_register_add_on_request& request = *static_cast<
= (server_register_mediaaddon_request *)data; const server_register_add_on_request*>(data);
server_register_mediaaddon_reply reply; server_register_add_on_reply reply;
gNodeManager->RegisterAddon(msg->ref, &reply.addon_id);
write_port(msg->reply_port, 0, &reply, sizeof(reply)); gNodeManager->RegisterAddOn(request.ref, &reply.add_on_id);
request.SendReply(B_OK, &reply, sizeof(reply));
break; break;
} }
case SERVER_UNREGISTER_MEDIAADDON: case SERVER_UNREGISTER_ADD_ON:
{ {
server_unregister_mediaaddon_command *msg const server_unregister_add_on_command& request = *static_cast<
= (server_unregister_mediaaddon_command *)data; const server_unregister_add_on_command*>(data);
gNodeManager->UnregisterAddon(msg->addon_id); gNodeManager->UnregisterAddOn(request.add_on_id);
break; break;
} }
@@ -662,8 +680,7 @@ ServerApp::_HandleMessage(int32 code, void* data, size_t size)
case SERVER_SET_NODE_CREATOR: case SERVER_SET_NODE_CREATOR:
{ {
const server_set_node_creator_request* request const server_set_node_creator_request* request
= reinterpret_cast<const server_set_node_creator_request*>( = static_cast<const server_set_node_creator_request*>(data);
data);
server_set_node_creator_reply reply; server_set_node_creator_reply reply;
status_t status = gNodeManager->SetNodeCreator(request->node, status_t status = gNodeManager->SetNodeCreator(request->node,
request->creator); request->creator);
@@ -673,21 +690,21 @@ ServerApp::_HandleMessage(int32 code, void* data, size_t size)
case SERVER_GET_SHARED_BUFFER_AREA: case SERVER_GET_SHARED_BUFFER_AREA:
{ {
const server_get_shared_buffer_area_request *request const server_get_shared_buffer_area_request& request
= reinterpret_cast< = *static_cast<const server_get_shared_buffer_area_request*>(
const server_get_shared_buffer_area_request *>(data); data);
server_get_shared_buffer_area_reply reply; server_get_shared_buffer_area_reply reply;
reply.area = gBufferManager->SharedBufferListArea(); reply.area = gBufferManager->SharedBufferListArea();
request->SendReply(B_OK, &reply, sizeof(reply)); request.SendReply(reply.area >= 0 ? B_OK : reply.area, &reply,
sizeof(reply));
break; break;
} }
case SERVER_REGISTER_BUFFER: case SERVER_REGISTER_BUFFER:
{ {
const server_register_buffer_request *request const server_register_buffer_request *request
= reinterpret_cast<const server_register_buffer_request *>( = static_cast<const server_register_buffer_request *>(data);
data);
server_register_buffer_reply reply; server_register_buffer_reply reply;
status_t status; status_t status;
if (request->info.buffer == 0) { if (request->info.buffer == 0) {
@@ -710,7 +727,7 @@ ServerApp::_HandleMessage(int32 code, void* data, size_t size)
case SERVER_UNREGISTER_BUFFER: 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); const server_unregister_buffer_command *>(data);
gBufferManager->UnregisterBuffer(cmd->team, cmd->buffer_id); 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: case SERVER_GET_MEDIA_FILE_TYPES:
{ {
const server_get_media_types_request& request const server_get_media_types_request& request
= *reinterpret_cast<const server_get_media_types_request*>( = *static_cast<const server_get_media_types_request*>(data);
data);
server_get_media_types_reply reply; server_get_media_types_reply reply;
area_id area = gMediaFilesManager->GetTypesArea(reply.count); 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: case SERVER_GET_MEDIA_FILE_ITEMS:
{ {
const server_get_media_items_request& request const server_get_media_items_request& request
= *reinterpret_cast<const server_get_media_items_request*>( = *static_cast<const server_get_media_items_request*>(data);
data);
server_get_media_items_reply reply; server_get_media_items_reply reply;
area_id area = gMediaFilesManager->GetItemsArea(request.type, 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: case SERVER_GET_REF_FOR:
{ {
const server_get_ref_for_request* request 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; server_get_ref_for_reply reply;
entry_ref* ref; entry_ref* ref;
@@ -794,7 +809,7 @@ ServerApp::_HandleMessage(int32 code, void* data, size_t size)
case SERVER_SET_REF_FOR: case SERVER_SET_REF_FOR:
{ {
const server_set_ref_for_request* request 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; server_set_ref_for_reply reply;
entry_ref ref = request->ref; entry_ref ref = request->ref;
@@ -807,7 +822,7 @@ ServerApp::_HandleMessage(int32 code, void* data, size_t size)
case SERVER_INVALIDATE_MEDIA_ITEM: case SERVER_INVALIDATE_MEDIA_ITEM:
{ {
const server_invalidate_item_request* request 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; server_invalidate_item_reply reply;
status_t status = gMediaFilesManager->InvalidateItem( status_t status = gMediaFilesManager->InvalidateItem(
@@ -819,8 +834,7 @@ ServerApp::_HandleMessage(int32 code, void* data, size_t size)
case SERVER_REMOVE_MEDIA_ITEM: case SERVER_REMOVE_MEDIA_ITEM:
{ {
const server_remove_media_item_request* request const server_remove_media_item_request* request
= reinterpret_cast<const server_remove_media_item_request*>( = static_cast<const server_remove_media_item_request*>(data);
data);
server_remove_media_item_reply reply; server_remove_media_item_reply reply;
status_t status = gMediaFilesManager->RemoveItem(request->type, 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: case SERVER_GET_ITEM_AUDIO_GAIN:
{ {
const server_get_item_audio_gain_request& request const server_get_item_audio_gain_request& request
= *reinterpret_cast<const server_get_item_audio_gain_request*>( = *static_cast<const server_get_item_audio_gain_request*>(data);
data);
server_get_item_audio_gain_reply reply; server_get_item_audio_gain_reply reply;
status_t status = gMediaFilesManager->GetAudioGainFor(request.type, 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: case SERVER_SET_ITEM_AUDIO_GAIN:
{ {
const server_set_item_audio_gain_request& request const server_set_item_audio_gain_request& request
= *reinterpret_cast<const server_set_item_audio_gain_request*>( = *static_cast<const server_set_item_audio_gain_request*>(data);
data);
server_set_ref_for_reply reply; server_set_ref_for_reply reply;
status_t status = gMediaFilesManager->SetAudioGainFor(request.type, status_t status = gMediaFilesManager->SetAudioGainFor(request.type,
@@ -858,7 +870,7 @@ ServerApp::_HandleMessage(int32 code, void* data, size_t size)
case SERVER_GET_READERS: case SERVER_GET_READERS:
{ {
const server_get_readers_request *request 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; server_get_readers_reply reply;
rv = gAddOnManager->GetReaders(reply.ref, &reply.count, rv = gAddOnManager->GetReaders(reply.ref, &reply.count,
MAX_READERS); MAX_READERS);
@@ -869,7 +881,7 @@ ServerApp::_HandleMessage(int32 code, void* data, size_t size)
case SERVER_GET_DECODER_FOR_FORMAT: case SERVER_GET_DECODER_FOR_FORMAT:
{ {
const server_get_decoder_for_format_request *request const server_get_decoder_for_format_request *request
= reinterpret_cast< = static_cast<
const server_get_decoder_for_format_request *>(data); const server_get_decoder_for_format_request *>(data);
server_get_decoder_for_format_reply reply; server_get_decoder_for_format_reply reply;
rv = gAddOnManager->GetDecoderForFormat(&reply.ref, 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: case SERVER_GET_WRITER_FOR_FORMAT_FAMILY:
{ {
const server_get_writer_request *request 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; server_get_writer_reply reply;
rv = gAddOnManager->GetWriter(&reply.ref, request->internal_id); rv = gAddOnManager->GetWriter(&reply.ref, request->internal_id);
request->SendReply(rv, &reply, sizeof(reply)); 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: case SERVER_GET_FILE_FORMAT_FOR_COOKIE:
{ {
const server_get_file_format_request *request const server_get_file_format_request *request
= reinterpret_cast< = static_cast<const server_get_file_format_request *>(data);
const server_get_file_format_request *>(data);
server_get_file_format_reply reply; server_get_file_format_reply reply;
rv = gAddOnManager->GetFileFormat(&reply.file_format, rv = gAddOnManager->GetFileFormat(&reply.file_format,
request->cookie); request->cookie);
@@ -903,8 +914,7 @@ ServerApp::_HandleMessage(int32 code, void* data, size_t size)
case SERVER_GET_CODEC_INFO_FOR_COOKIE: case SERVER_GET_CODEC_INFO_FOR_COOKIE:
{ {
const server_get_codec_info_request *request const server_get_codec_info_request *request
= reinterpret_cast< = static_cast<const server_get_codec_info_request *>(data);
const server_get_codec_info_request *>(data);
server_get_codec_info_reply reply; server_get_codec_info_reply reply;
rv = gAddOnManager->GetCodecInfo(&reply.codec_info, rv = gAddOnManager->GetCodecInfo(&reply.codec_info,
&reply.format_family, &reply.input_format, &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: case SERVER_GET_ENCODER_FOR_CODEC_INFO:
{ {
const server_get_encoder_for_codec_info_request *request const server_get_encoder_for_codec_info_request *request
= reinterpret_cast< = static_cast<
const server_get_encoder_for_codec_info_request *>(data); const server_get_encoder_for_codec_info_request *>(data);
server_get_encoder_for_codec_info_reply reply; server_get_encoder_for_codec_info_reply reply;
rv = gAddOnManager->GetEncoder(&reply.ref, request->id); 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) MediaAddonServer::MessageReceived(BMessage* message)
{ {
switch (message->what) { switch (message->what) {
case MEDIA_ADDON_SERVER_PLAY_MEDIA: case MEDIA_ADD_ON_SERVER_PLAY_MEDIA:
{ {
const char* name; const char* name;
const char* type; const char* type;
@@ -381,39 +381,39 @@ void
MediaAddonServer::_HandleMessage(int32 code, const void* data, size_t size) MediaAddonServer::_HandleMessage(int32 code, const void* data, size_t size)
{ {
switch (code) { 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< = static_cast<
const addonserver_instantiate_dormant_node_request*>(data); const add_on_server_instantiate_dormant_node_request*>(
addonserver_instantiate_dormant_node_reply reply; data);
add_on_server_instantiate_dormant_node_reply reply;
status_t status status_t status
= MediaRosterEx(fMediaRoster)->InstantiateDormantNode( = MediaRosterEx(fMediaRoster)->InstantiateDormantNode(
request->addon_id, request->flavor_id, request->add_on_id, request->flavor_id,
request->creator_team, &reply.node); request->creator_team, &reply.node);
request->SendReply(status, &reply, sizeof(reply)); request->SendReply(status, &reply, sizeof(reply));
break; break;
} }
case ADDONSERVER_RESCAN_MEDIAADDON_FLAVORS: case ADD_ON_SERVER_RESCAN_ADD_ON_FLAVORS:
{ {
const addonserver_rescan_mediaaddon_flavors_command* command const add_on_server_rescan_flavors_command* command = static_cast<
= static_cast< const add_on_server_rescan_flavors_command*>(data);
const addonserver_rescan_mediaaddon_flavors_command*>(data); BMediaAddOn* addOn
BMediaAddOn* addon = gDormantNodeManager->GetAddOn(command->add_on_id);
= gDormantNodeManager->GetAddOn(command->addon_id); if (addOn == NULL) {
if (addon == NULL) {
ERROR("rescan flavors: Can't find a addon object for id %d\n", ERROR("rescan flavors: Can't find a addon object for id %d\n",
(int)command->addon_id); (int)command->add_on_id);
break; break;
} }
_ScanAddOnFlavors(addon); _ScanAddOnFlavors(addOn);
gDormantNodeManager->PutAddOn(command->addon_id); gDormantNodeManager->PutAddOn(command->add_on_id);
break; break;
} }
case ADDONSERVER_RESCAN_FINISHED_NOTIFY: case ADD_ON_SERVER_RESCAN_FINISHED_NOTIFY:
if (fStartupSound) { if (fStartupSound) {
system_beep(MEDIA_SOUNDS_STARTUP); system_beep(MEDIA_SOUNDS_STARTUP);
fStartupSound = false; fStartupSound = false;