From 9c3b4706dd3ed8f9896031973852735223be485c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Axel=20D=C3=B6rfler?= Date: Wed, 9 Dec 2009 16:22:24 +0000 Subject: [PATCH] * Cleaned up the node manager, got rid of its use of Map, and List. * 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 --- headers/private/media/DataExchange.h | 600 ++++--- headers/private/media/ServerInterface.h | 8 +- src/kits/media/DataExchange.cpp | 166 +- src/kits/media/DormantNodeManager.cpp | 24 +- src/kits/media/MediaAddOn.cpp | 7 +- src/kits/media/MediaRoster.cpp | 160 +- src/servers/media/AppManager.cpp | 2 +- src/servers/media/AppManager.h | 2 +- src/servers/media/DefaultManager.cpp | 20 +- src/servers/media/NodeManager.cpp | 1669 ++++++++++-------- src/servers/media/NodeManager.h | 229 ++- src/servers/media/media_server.cpp | 358 ++-- src/servers/media_addon/MediaAddonServer.cpp | 34 +- 13 files changed, 1799 insertions(+), 1480 deletions(-) diff --git a/headers/private/media/DataExchange.h b/headers/private/media/DataExchange.h index 06120094c4..f7e7b27362 100644 --- a/headers/private/media/DataExchange.h +++ b/headers/private/media/DataExchange.h @@ -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; }; diff --git a/headers/private/media/ServerInterface.h b/headers/private/media/ServerInterface.h index fa9bedd810..70a40f6581 100644 --- a/headers/private/media/ServerInterface.h +++ b/headers/private/media/ServerInterface.h @@ -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, diff --git a/src/kits/media/DataExchange.cpp b/src/kits/media/DataExchange.cpp index cd68e3d0bd..3b7d888ba8 100644 --- a/src/kits/media/DataExchange.cpp +++ b/src/kits/media/DataExchange.cpp @@ -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(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(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 diff --git a/src/kits/media/DormantNodeManager.cpp b/src/kits/media/DormantNodeManager.cpp index ccfaf7e97a..7c21eb5610 100644 --- a/src/kits/media/DormantNodeManager.cpp +++ b/src/kits/media/DormantNodeManager.cpp @@ -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)); diff --git a/src/kits/media/MediaAddOn.cpp b/src/kits/media/MediaAddOn.cpp index fee37715c4..dbd2215031 100644 --- a/src/kits/media/MediaAddOn.cpp +++ b/src/kits/media/MediaAddOn.cpp @@ -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)); } /************************************************************* diff --git a/src/kits/media/MediaRoster.cpp b/src/kits/media/MediaRoster.cpp index 8083018898..80e1358c76 100644 --- a/src/kits/media/MediaRoster.cpp +++ b/src/kits/media/MediaRoster.cpp @@ -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(&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(node); - if (ts) - ts->FinishCreate(); + if ((node->Kinds() & B_TIME_SOURCE) != 0) { + if (BTimeSource* timeSource = dynamic_cast(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(node); - if (bp) { + if ((node->Kinds() & B_BUFFER_PRODUCER) != 0) { + if (BBufferProducer* producer = dynamic_cast(node)) { List 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(node); - if (consumer != NULL) { + if (BBufferConsumer* consumer = dynamic_cast(node)) { List 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)); diff --git a/src/servers/media/AppManager.cpp b/src/servers/media/AppManager.cpp index 228164b5fe..c2d0afe8d6 100644 --- a/src/servers/media/AppManager.cpp +++ b/src/servers/media/AppManager.cpp @@ -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) { diff --git a/src/servers/media/AppManager.h b/src/servers/media/AppManager.h index 317d56cfa2..1f865a4218 100644 --- a/src/servers/media/AppManager.h +++ b/src/servers/media/AppManager.h @@ -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); diff --git a/src/servers/media/DefaultManager.cpp b/src/servers/media/DefaultManager.cpp index 447323f269..cffa5c6ee0 100644 --- a/src/servers/media/DefaultManager.cpp +++ b/src/servers/media/DefaultManager.cpp @@ -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; diff --git a/src/servers/media/NodeManager.cpp b/src/servers/media/NodeManager.cpp index cb39afd610..ed31c41015 100644 --- a/src/servers/media/NodeManager.cpp +++ b/src/servers/media/NodeManager.cpp @@ -27,32 +27,55 @@ * */ -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include "debug.h" + #include "NodeManager.h" -#include "DefaultManager.h" + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + #include "AppManager.h" -#include "MediaMisc.h" +#include "DefaultManager.h" +#include "media_server.h" -extern AppManager *gAppManager; -const char *get_node_type(node_type t); +const char* +get_node_type(node_type type) +{ +#define CASE(c) case c: return #c; + switch (type) { + CASE(VIDEO_INPUT) + CASE(AUDIO_INPUT) + CASE(VIDEO_OUTPUT) + CASE(AUDIO_MIXER) + CASE(AUDIO_OUTPUT) + CASE(AUDIO_OUTPUT_EX) + CASE(TIME_SOURCE) + CASE(SYSTEM_TIME_SOURCE) -NodeManager::NodeManager() : + default: + return "unknown"; + } +#undef CASE +} + + +// #pragma mark - + + +NodeManager::NodeManager() + : + BLocker("node manager"), fNextAddOnID(1), fNextNodeID(1), - fLocker(new BLocker("node manager locker")), - fDormantAddonFlavorList(new List), - fAddonPathMap(new Map), - fRegisteredNodeMap(new Map), fDefaultManager(new DefaultManager) { } @@ -60,224 +83,256 @@ NodeManager::NodeManager() : NodeManager::~NodeManager() { - delete fLocker; - delete fDormantAddonFlavorList; - delete fAddonPathMap; - delete fRegisteredNodeMap; delete fDefaultManager; } -/********************************************************************** - * Live node management - **********************************************************************/ + +// #pragma mark - Default node management + status_t -NodeManager::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) +NodeManager::SetDefaultNode(node_type type, const media_node* node, + const dormant_node_info* info, const media_input* input) { - BAutolock lock(fLocker); - bool b; - registered_node rn; - rn.node_id = fNextNodeID; - rn.addon_id = addon_id; - rn.addon_flavor_id = addon_flavor_id; - strcpy(rn.name, name); - rn.kinds = kinds; - rn.port = port; - rn.team = team; - rn.creator = -1; // will be set later - rn.globalrefcount = 1; - rn.teamrefcount.Insert(team, 1); + BAutolock _(this); - b = fRegisteredNodeMap->Insert(fNextNodeID, rn); - ASSERT(b); - *nodeid = fNextNodeID; - fNextNodeID += 1; - TRACE("NodeManager::RegisterNode: node %ld, addon_id %ld, flavor_id %ld, name \"%s\", kinds %#Lx, port %ld, team %ld\n", *nodeid, addon_id, addon_flavor_id, name, kinds, port, team); + status_t status = B_BAD_VALUE; + if (node != NULL) + status = fDefaultManager->Set(node->node, NULL, 0, type); + else if (input != NULL) { + status = fDefaultManager->Set(input->node.node, input->name, + input->destination.id, type); + } else if (info != NULL) { + media_node_id nodeID; + int32 count = 1; + status = GetInstances(info->addon, info->flavor_id, &nodeID, &count, + count); + if (status == B_OK) + status = fDefaultManager->Set(nodeID, NULL, 0, type); + } + + if (status == B_OK && (type == VIDEO_INPUT || type == VIDEO_OUTPUT + || type == AUDIO_OUTPUT || type == AUDIO_INPUT)) { + fDefaultManager->SaveState(this); + Dump(); + } + return status; +} + + +status_t +NodeManager::GetDefaultNode(node_type type, media_node_id* _nodeID, + char* inputName, int32* _inputID) +{ + BAutolock _(this); + return fDefaultManager->Get(_nodeID, inputName, _inputID, type); +} + + +status_t +NodeManager::RescanDefaultNodes() +{ + BAutolock _(this); + return fDefaultManager->Rescan(); +} + + +// #pragma mark - Live node management + + +status_t +NodeManager::RegisterNode(media_addon_id addOnID, int32 flavorID, + const char* name, uint64 kinds, port_id port, team_id team, + media_node_id* _nodeID) +{ + BAutolock _(this); + + registered_node node; + node.node_id = fNextNodeID; + node.add_on_id = addOnID; + node.flavor_id = flavorID; + strlcpy(node.name, name, sizeof(node.name)); + node.kinds = kinds; + node.port = port; + node.containing_team = team; + node.creator = -1; // will be set later + node.ref_count = 1; + + try { + node.team_ref_count.insert(std::make_pair(team, 1)); + + fNodeMap.insert(std::make_pair(fNextNodeID, node)); + } catch (std::bad_alloc& exception) { + return B_NO_MEMORY; + } + + *_nodeID = fNextNodeID++; + + TRACE("NodeManager::RegisterNode: node %ld, addon_id %ld, flavor_id %ld, " + "name \"%s\", kinds %#Lx, port %ld, team %ld\n", *_nodeID, addOnID, + flavorID, name, kinds, port, team); return B_OK; } status_t -NodeManager::UnregisterNode(media_addon_id *addonid, int32 *flavorid, media_node_id nodeid, team_id team) +NodeManager::UnregisterNode(media_node_id id, team_id team, + media_addon_id* _addOnID, int32* _flavorID) { - BAutolock lock(fLocker); - bool b; - registered_node *rn; - TRACE("NodeManager::UnregisterNode enter: node %ld, team %ld\n", nodeid, team); - b = fRegisteredNodeMap->Get(nodeid, &rn); - if (!b) { - ERROR("NodeManager::UnregisterNode: couldn't find node %ld (team %ld)\n", nodeid, team); + TRACE("NodeManager::UnregisterNode enter: node %ld, team %ld\n", id, team); + + BAutolock _(this); + + NodeMap::iterator found = fNodeMap.find(id); + if (found == fNodeMap.end()) { + ERROR("NodeManager::UnregisterNode: couldn't find node %ld (team " + "%ld)\n", id, team); return B_ERROR; } - if (rn->team != team) { - ERROR("NodeManager::UnregisterNode: team %ld tried to unregister node %ld, but it was instantiated by team %ld\n", team, nodeid, rn->team); + + registered_node& node = found->second; + + if (node.containing_team != team) { + ERROR("NodeManager::UnregisterNode: team %ld tried to unregister " + "node %ld, but it was instantiated by team %ld\n", team, id, + node.containing_team); return B_ERROR; } - if (rn->globalrefcount != 1) { - ERROR("NodeManager::UnregisterNode: node %ld, team %ld has globalrefcount %ld (should be 1)\n", nodeid, team, rn->globalrefcount); + if (node.ref_count != 1) { + ERROR("NodeManager::UnregisterNode: node %ld, team %ld has ref count " + "%ld (should be 1)\n", id, team, node.ref_count); //return B_ERROR; } - *addonid = rn->addon_id; - *flavorid = rn->addon_flavor_id; - b = fRegisteredNodeMap->Remove(nodeid); - ASSERT(b); - TRACE("NodeManager::UnregisterNode leave: node %ld, addon_id %ld, flavor_id %ld team %ld\n", nodeid, *addonid, *flavorid, team); + + *_addOnID = node.add_on_id; + *_flavorID = node.flavor_id; + + fNodeMap.erase(found); + + TRACE("NodeManager::UnregisterNode leave: node %ld, addon_id %ld, " + "flavor_id %ld team %ld\n", id, *_addOnID, *_flavorID, team); return B_OK; } status_t -NodeManager::IncrementGlobalRefCount(media_node_id nodeid, team_id team) +NodeManager::ReleaseNodeReference(media_node_id id, team_id team) { - BAutolock lock(fLocker); - registered_node *rn; - bool b; - TRACE("NodeManager::IncrementGlobalRefCount enter: node %ld, team %ld\n", nodeid, team); - b = fRegisteredNodeMap->Get(nodeid, &rn); - if (!b) { - ERROR("NodeManager::IncrementGlobalRefCount: node %ld not found\n", nodeid); + TRACE("NodeManager::ReleaseNodeReference enter: node %ld, team %ld\n", id, + team); + + BAutolock _(this); + + NodeMap::iterator found = fNodeMap.find(id); + if (found == fNodeMap.end()) { + ERROR("NodeManager::ReleaseNodeReference: node %ld not found\n", id); return B_ERROR; } - int32 *count; - int32 debug_count; - b = rn->teamrefcount.Get(team, &count); - if (b) { - *count += 1; - debug_count = *count; - } else { - b = rn->teamrefcount.Insert(team, 1); - ASSERT(b); - debug_count = 1; - } - rn->globalrefcount += 1; - TRACE("NodeManager::IncrementGlobalRefCount leave: node %ld, team %ld, count %ld, globalcount %ld\n", nodeid, team, debug_count, rn->globalrefcount); - return B_OK; -} + registered_node& node = found->second; -status_t -NodeManager::DecrementGlobalRefCount(media_node_id nodeid, team_id team) -{ - BAutolock lock(fLocker); - registered_node *rn; - bool b; - TRACE("NodeManager::DecrementGlobalRefCount enter: node %ld, team %ld\n", nodeid, team); - b = fRegisteredNodeMap->Get(nodeid, &rn); - if (!b) { - ERROR("NodeManager::DecrementGlobalRefCount: node %ld not found\n", nodeid); - return B_ERROR; - } - int32 *count; - b = rn->teamrefcount.Get(team, &count); - if (!b) { - // Normally it is an error to release a node in another team. But we make one - // exception. If the node is global, and the creator team tries to release it, - // we will release it in the the media_addon_server. - team_id addon_server_team; - addon_server_team = gAppManager->AddonServerTeam(); - if (rn->creator == team && rn->teamrefcount.Get(addon_server_team, &count)) { - printf("!!! NodeManager::DecrementGlobalRefCount doing global release!\n"); - rn->creator = -1; //invalidate! - team = addon_server_team; //redirect! - // the count variable was already redirected in if() statement above. + TeamCountMap::iterator teamRef = node.team_ref_count.find(team); + if (teamRef == node.team_ref_count.end()) { + // Normally it is an error to release a node in another team. But we + // make one exception: if the node is global, and the creator team + // tries to release it, we will release it in the the + // media_addon_server. + team_id addOnServer = gAppManager->AddOnServerTeam(); + teamRef = node.team_ref_count.find(addOnServer); + + if (node.creator == team && teamRef != node.team_ref_count.end()) { + PRINT(1, "!!! NodeManager::ReleaseNodeReference doing global " + "release!\n"); + node.creator = -1; // invalidate! + team = addOnServer; } else { - ERROR("NodeManager::DecrementGlobalRefCount: node %ld has no team %ld references\n", nodeid, team); + ERROR("NodeManager::ReleaseNodeReference: node %ld has no team " + "%ld references\n", id, team); return B_ERROR; } } - *count -= 1; - #if DEBUG >= 2 - int32 debug_count = *count; - #endif - if (*count == 0) { - b = rn->teamrefcount.Remove(team); - ASSERT(b); - } - rn->globalrefcount -= 1; - if (rn->globalrefcount == 0) { - printf("NodeManager::DecrementGlobalRefCount: detected released node is now unused, node %ld\n", nodeid); - FinalReleaseNode(nodeid); +#if DEBUG + int32 teamCount = teamRef->second - 1; +#endif + + if (--teamRef->second == 0) + node.team_ref_count.erase(teamRef); + + if (--node.ref_count == 0) { + PRINT(1, "NodeManager::ReleaseNodeReference: detected released node is " + "now unused, node %ld\n", id); + + // TODO: remove! + node_final_release_command command; + status_t status = SendToPort(node.port, NODE_FINAL_RELEASE, &command, + sizeof(command)); + if (status != B_OK) { + ERROR("NodeManager::ReleaseNodeReference: can't send command to " + "node %ld\n", id); + // ignore error + } } - TRACE("NodeManager::DecrementGlobalRefCount leave: node %ld, team %ld, count %ld, globalcount %ld\n", nodeid, team, debug_count, rn->globalrefcount); + TRACE("NodeManager::ReleaseNodeReference leave: node %ld, team %ld, " + "ref %ld, team ref %ld\n", id, team, node.ref_count, teamCount); return B_OK; } -status_t -NodeManager::SetNodeCreator(media_node_id nodeid, team_id creator) -{ - BAutolock lock(fLocker); - registered_node *rn; - bool b; - - TRACE("NodeManager::SetNodeCreator node %ld, creator %ld\n", nodeid, creator); - - b = fRegisteredNodeMap->Get(nodeid, &rn); - if (!b) { - ERROR("NodeManager::SetNodeCreator: node %ld not found\n", nodeid); - return B_ERROR; - } - - if (rn->creator != -1) { - ERROR("NodeManager::SetNodeCreator: node %ld is already assigned creator %ld\n", nodeid, rn->creator); - return B_ERROR; - } - - rn->creator = creator; - return B_OK; -} - -void -NodeManager::FinalReleaseNode(media_node_id nodeid) -{ - BAutolock lock(fLocker); - registered_node *rn; - bool b; - status_t rv; - - TRACE("NodeManager::FinalReleaseNode enter: node %ld\n", nodeid); - b = fRegisteredNodeMap->Get(nodeid, &rn); - if (!b) { - ERROR("NodeManager::FinalReleaseNode: node %ld not found\n", nodeid); - return; - } - - node_final_release_command cmd; - rv = SendToPort(rn->port, NODE_FINAL_RELEASE, &cmd, sizeof(cmd)); - if (rv != B_OK) { - ERROR("NodeManager::FinalReleaseNode: can't send command to node %ld\n", nodeid); - return; - } -} - status_t -NodeManager::GetCloneForID(media_node* node, media_node_id nodeID, team_id team) +NodeManager::SetNodeCreator(media_node_id id, team_id creator) { - BAutolock lock(fLocker); - TRACE("NodeManager::GetCloneForID enter: node %ld team %ld\n", nodeID, - team); + TRACE("NodeManager::SetNodeCreator node %ld, creator %ld\n", id, creator); - if (IncrementGlobalRefCount(nodeID, team) != B_OK) { + BAutolock _(this); + + NodeMap::iterator found = fNodeMap.find(id); + if (found == fNodeMap.end()) { + ERROR("NodeManager::SetNodeCreator: node %ld not found\n", id); + return B_ERROR; + } + + registered_node& node = found->second; + + if (node.creator != -1) { + ERROR("NodeManager::SetNodeCreator: node %ld is already assigned " + "creator %ld\n", id, node.creator); + return B_ERROR; + } + + node.creator = creator; + return B_OK; +} + + +status_t +NodeManager::GetCloneForID(media_node_id id, team_id team, media_node* node) +{ + TRACE("NodeManager::GetCloneForID enter: node %ld team %ld\n", id, team); + + BAutolock _(this); + + status_t status = _AcquireNodeReference(id, team); + if (status != B_OK) { ERROR("NodeManager::GetCloneForID: couldn't increment ref count, " - "node %ld team %ld\n", nodeID, team); + "node %ld team %ld\n", id, team); + return status; + } + + NodeMap::iterator found = fNodeMap.find(id); + if (found == fNodeMap.end()) { + ERROR("NodeManager::GetCloneForID: node %ld not found\n", id); return B_ERROR; } - registered_node* registeredNode; - if (!fRegisteredNodeMap->Get(nodeID, ®isteredNode)) { - ERROR("NodeManager::GetCloneForID: node %ld not found\n", nodeID); - DecrementGlobalRefCount(nodeID, team); - return B_ERROR; - } + registered_node& registeredNode = found->second; - node->node = registeredNode->node_id; - node->port = registeredNode->port; - node->kind = registeredNode->kinds; + node->node = registeredNode.node_id; + node->port = registeredNode.port; + node->kind = registeredNode.kinds; - TRACE("NodeManager::GetCloneForID leave: node %ld team %ld\n", nodeID, - team); + TRACE("NodeManager::GetCloneForID leave: node %ld team %ld\n", id, team); return B_OK; } @@ -290,247 +345,324 @@ NodeManager::GetCloneForID(media_node* node, media_node_id nodeID, team_id team) BString *out_input_name). */ status_t -NodeManager::GetClone(media_node *node, char *input_name, int32 *input_id, - node_type type, team_id team) +NodeManager::GetClone(node_type type, team_id team, media_node* node, + char* inputName, int32* _inputID) { - BAutolock lock(fLocker); - status_t status; - media_node_id id; + BAutolock _(this); TRACE("NodeManager::GetClone enter: team %ld, type %d (%s)\n", team, type, get_node_type(type)); - status = GetDefaultNode(&id, input_name, input_id, type); + media_node_id id; + status_t status = GetDefaultNode(type, &id, inputName, _inputID); if (status != B_OK) { - ERROR("NodeManager::GetClone: couldn't GetDefaultNode, team %ld, type %d (%s)\n", team, type, get_node_type(type)); + ERROR("NodeManager::GetClone: couldn't GetDefaultNode, team %ld, " + "type %d (%s)\n", team, type, get_node_type(type)); *node = media_node::null; return status; } ASSERT(id > 0); - status = GetCloneForID(node, id, team); + status = GetCloneForID(id, team, node); if (status != B_OK) { - ERROR("NodeManager::GetClone: couldn't GetCloneForID, id %ld, team %ld, type %d (%s)\n", id, team, type, get_node_type(type)); + ERROR("NodeManager::GetClone: couldn't GetCloneForID, id %ld, team " + "%ld, type %d (%s)\n", id, team, type, get_node_type(type)); *node = media_node::null; return status; } ASSERT(id == node->node); - TRACE("NodeManager::GetClone leave: node id %ld, node port %ld, node kind %#lx\n", node->node, node->port, node->kind); - + TRACE("NodeManager::GetClone leave: node id %ld, node port %ld, node " + "kind %#lx\n", node->node, node->port, node->kind); return B_OK; } status_t -NodeManager::ReleaseNode(const media_node &node, team_id team) +NodeManager::ReleaseNode(const media_node& node, team_id team) { - BAutolock lock(fLocker); - TRACE("NodeManager::ReleaseNode enter: node %ld team %ld\n", node.node, team); - if (B_OK != DecrementGlobalRefCount(node.node, team)) { - ERROR("NodeManager::ReleaseNode: couldn't decrement node %ld team %ld ref count\n", node.node, team); + TRACE("NodeManager::ReleaseNode enter: node %ld team %ld\n", node.node, + team); + + if (ReleaseNodeReference(node.node, team) != B_OK) { + ERROR("NodeManager::ReleaseNode: couldn't decrement node %ld team %ld " + "ref count\n", node.node, team); } - TRACE("NodeManager::ReleaseNode leave: node %ld team %ld\n", node.node, team); + return B_OK; } status_t -NodeManager::PublishInputs(const media_node &node, const media_input *inputs, int32 count) +NodeManager::PublishInputs(const media_node& node, const media_input* inputs, + int32 count) { - BAutolock lock(fLocker); - registered_node *rn; - bool b; - b = fRegisteredNodeMap->Get(node.node, &rn); - if (!b) { + BAutolock _(this); + + NodeMap::iterator found = fNodeMap.find(node.node); + if (found == fNodeMap.end()) { ERROR("NodeManager::PublishInputs: node %ld not found\n", node.node); return B_ERROR; } - rn->inputlist.MakeEmpty(); - for (int32 i = 0; i < count; i++) - rn->inputlist.Insert(inputs[i]); + + registered_node& registeredNode = found->second; + + registeredNode.input_list.clear(); + + try { + for (int32 i = 0; i < count; i++) + registeredNode.input_list.push_back(inputs[i]); + } catch (std::bad_alloc& exception) { + return B_NO_MEMORY; + } + return B_OK; } status_t -NodeManager::PublishOutputs(const media_node &node, const media_output *outputs, int32 count) +NodeManager::PublishOutputs(const media_node &node, const media_output* outputs, + int32 count) { - BAutolock lock(fLocker); - registered_node *rn; - bool b; - b = fRegisteredNodeMap->Get(node.node, &rn); - if (!b) { + BAutolock _(this); + + NodeMap::iterator found = fNodeMap.find(node.node); + if (found == fNodeMap.end()) { ERROR("NodeManager::PublishOutputs: node %ld not found\n", node.node); return B_ERROR; } - rn->outputlist.MakeEmpty(); - for (int32 i = 0; i < count; i++) - rn->outputlist.Insert(outputs[i]); + + registered_node& registeredNode = found->second; + + registeredNode.output_list.clear(); + + try { + for (int32 i = 0; i < count; i++) + registeredNode.output_list.push_back(outputs[i]); + } catch (std::bad_alloc& exception) { + return B_NO_MEMORY; + } + return B_OK; } status_t -NodeManager::FindNodeID(media_node_id* nodeID, port_id port) +NodeManager::FindNodeID(port_id port, media_node_id* _id) { - BAutolock lock(fLocker); - registered_node *rn; - for (fRegisteredNodeMap->Rewind(); fRegisteredNodeMap->GetNext(&rn); ) { - if (rn->port == port) { - *nodeID = rn->node_id; + BAutolock _(this); + + NodeMap::iterator iterator = fNodeMap.begin(); + for (; iterator != fNodeMap.end(); iterator++) { + registered_node& node = iterator->second; + + if (node.port == port) { + *_id = node.node_id; TRACE("NodeManager::FindNodeID found port %ld, node %ld\n", port, - *nodeID); + node.node_id); return B_OK; } - media_output *output; - for (rn->outputlist.Rewind(); rn->outputlist.GetNext(&output); ) { - if (output->source.port == port) { - *nodeID = rn->node_id; - TRACE("NodeManager::FindNodeID found output port %ld, node %ld\n", port, *nodeid); + + OutputList::iterator outIterator = node.output_list.begin(); + for (; outIterator != node.output_list.end(); outIterator++) { + if (outIterator->source.port == port) { + *_id = node.node_id; + TRACE("NodeManager::FindNodeID found output port %ld, node " + "%ld\n", port, node.node_id); return B_OK; } } - media_input *input; - for (rn->inputlist.Rewind(); rn->inputlist.GetNext(&input); ) { - if (input->destination.port == port) { - *nodeID = rn->node_id; - TRACE("NodeManager::FindNodeID found input port %ld, node %ld\n", port, *nodeid); + + InputList::iterator inIterator = node.input_list.begin(); + for (; inIterator != node.input_list.end(); inIterator++) { + if (inIterator->destination.port == port) { + *_id = node.node_id; + TRACE("NodeManager::FindNodeID found input port %ld, node " + "%ld\n", port, node.node_id); return B_OK; } } } + ERROR("NodeManager::FindNodeID failed, port %ld\n", port); return B_ERROR; } status_t -NodeManager::GetDormantNodeInfo(dormant_node_info *node_info, const media_node &node) +NodeManager::GetDormantNodeInfo(const media_node& node, + dormant_node_info* nodeInfo) { - BAutolock lock(fLocker); - // XXX not sure if this is correct - registered_node *rn; - for (fRegisteredNodeMap->Rewind(); fRegisteredNodeMap->GetNext(&rn); ) { - if (rn->node_id == node.node) { - if (rn->addon_id == -1 && node.node != NODE_SYSTEM_TIMESOURCE_ID) { // This function must return an error if the node is application owned - TRACE("NodeManager::GetDormantNodeInfo NODE IS APPLICATION OWNED! node %ld, addon_id %ld, addon_flavor_id %ld, name \"%s\"\n", node.node, rn->addon_id, rn->addon_flavor_id, rn->name); - return B_ERROR; - } - ASSERT(node.port == rn->port); - ASSERT((node.kind & NODE_KIND_COMPARE_MASK) == (rn->kinds & NODE_KIND_COMPARE_MASK)); - node_info->addon = rn->addon_id; - node_info->flavor_id = rn->addon_flavor_id; - strcpy(node_info->name, rn->name); - TRACE("NodeManager::GetDormantNodeInfo node %ld, addon_id %ld, addon_flavor_id %ld, name \"%s\"\n", node.node, rn->addon_id, rn->addon_flavor_id, rn->name); - return B_OK; - } + // TODO: not sure if this is correct + BAutolock _(this); + + NodeMap::iterator found = fNodeMap.find(node.node); + if (found == fNodeMap.end()) { + ERROR("NodeManager::GetDormantNodeInfo: node %ld not found\n", + node.node); + return B_ERROR; } - ERROR("NodeManager::GetDormantNodeInfo failed, node %ld\n", node.node); - return B_ERROR; -} + registered_node& registeredNode = found->second; -status_t -NodeManager::GetLiveNodeInfo(live_node_info *live_info, const media_node &node) -{ - BAutolock lock(fLocker); - registered_node *rn; - for (fRegisteredNodeMap->Rewind(); fRegisteredNodeMap->GetNext(&rn); ) { - if (rn->node_id == node.node) { - ASSERT(node.port == rn->port); - ASSERT((node.kind & NODE_KIND_COMPARE_MASK) == (rn->kinds & NODE_KIND_COMPARE_MASK)); - live_info->node = node; - live_info->hint_point = BPoint(0, 0); - strcpy(live_info->name, rn->name); - TRACE("NodeManager::GetLiveNodeInfo node %ld, name = \"%s\"\n", node.node, rn->name); - return B_OK; - } + if (registeredNode.add_on_id == -1 + && node.node != NODE_SYSTEM_TIMESOURCE_ID) { + // This function must return an error if the node is application owned + TRACE("NodeManager::GetDormantNodeInfo NODE IS APPLICATION OWNED! " + "node %ld, add_on_id %ld, flavor_id %ld, name \"%s\"\n", node.node, + registeredNode.add_on_id, registeredNode.flavor_id, + registeredNode.name); + return B_ERROR; } - ERROR("NodeManager::GetLiveNodeInfo failed, node %ld\n", node.node); - return B_ERROR; -} + ASSERT(node.port == registeredNode.port); + ASSERT((node.kind & NODE_KIND_COMPARE_MASK) + == (registeredNode.kinds & NODE_KIND_COMPARE_MASK)); -status_t -NodeManager::GetInstances(media_node_id *node_ids, int32* count, int32 maxcount, media_addon_id addon_id, int32 addon_flavor_id) -{ - BAutolock lock(fLocker); - registered_node *rn; - *count = 0; - for (fRegisteredNodeMap->Rewind(); (maxcount > 0) && fRegisteredNodeMap->GetNext(&rn); ) { - if (rn->addon_id == addon_id && rn->addon_flavor_id == addon_flavor_id) { - node_ids[*count] = rn->node_id; - *count += 1; - maxcount -= 1; - } - } - TRACE("NodeManager::GetInstances found %ld instances for addon_id %ld, addon_flavor_id %ld\n", *count, addon_id, addon_flavor_id); + nodeInfo->addon = registeredNode.add_on_id; + nodeInfo->flavor_id = registeredNode.flavor_id; + strlcpy(nodeInfo->name, registeredNode.name, sizeof(nodeInfo->name)); + + TRACE("NodeManager::GetDormantNodeInfo node %ld, add_on_id %ld, " + "flavor_id %ld, name \"%s\"\n", node.node, registeredNode.add_on_id, + registeredNode.flavor_id, registeredNode.name); return B_OK; } status_t -NodeManager::GetLiveNodes(Stack *livenodes, int32 maxcount, const media_format *inputformat /* = NULL */, const media_format *outputformat /* = NULL */, const char* name /* = NULL */, uint64 require_kinds /* = 0 */) +NodeManager::GetLiveNodeInfo(const media_node& node, live_node_info* liveInfo) { - BAutolock lock(fLocker); - registered_node *rn; - int namelen; + BAutolock _(this); - TRACE("NodeManager::GetLiveNodes: maxcount %ld, in-format %p, out-format %p, name %s, require_kinds 0x%Lx\n", - maxcount, inputformat, outputformat, (name ? name : "NULL"), require_kinds); - - // determine the count of byte to compare when checking for a name with(out) wildcard - if (name) { - namelen = strlen(name); - if (namelen > 0 && name[namelen - 1] == '*') - namelen--; // compares without the '*' - } else { - namelen = 0; + NodeMap::iterator found = fNodeMap.find(node.node); + if (found == fNodeMap.end()) { + ERROR("NodeManager::GetLiveNodeInfo: node %ld not found\n", + node.node); + return B_ERROR; } - for (fRegisteredNodeMap->Rewind(); (maxcount > 0) && fRegisteredNodeMap->GetNext(&rn); ) { - if ((rn->kinds & require_kinds) != require_kinds) + registered_node& registeredNode = found->second; + + ASSERT(node.port == registeredNode.port); + ASSERT((node.kind & NODE_KIND_COMPARE_MASK) + == (registeredNode.kinds & NODE_KIND_COMPARE_MASK)); + + liveInfo->node = node; + liveInfo->hint_point = BPoint(0, 0); + strlcpy(liveInfo->name, registeredNode.name, sizeof(liveInfo->name)); + + TRACE("NodeManager::GetLiveNodeInfo node %ld, name = \"%s\"\n", node.node, + registeredNode.name); + return B_OK; +} + + +status_t +NodeManager::GetInstances(media_addon_id addOnID, int32 flavorID, + media_node_id* ids, int32* _count, int32 maxCount) +{ + BAutolock _(this); + + NodeMap::iterator iterator = fNodeMap.begin(); + int32 count = 0; + for (; iterator != fNodeMap.end() && count < maxCount; iterator++) { + registered_node& node = iterator->second; + + if (node.add_on_id == addOnID && node.flavor_id == flavorID) + ids[count++] = node.node_id; + } + + TRACE("NodeManager::GetInstances found %ld instances for addon_id %ld, " + "flavor_id %ld\n", count, addOnID, flavorID); + *_count = count; + return B_OK; +} + + +status_t +NodeManager::GetLiveNodes(LiveNodeList& liveNodes, int32 maxCount, + const media_format* inputFormat, const media_format* outputFormat, + const char* name, uint64 requireKinds) +{ + TRACE("NodeManager::GetLiveNodes: maxCount %ld, in-format %p, out-format " + "%p, name %s, require kinds 0x%Lx\n", maxCount, inputFormat, + outputFormat, name != NULL ? name : "NULL", requireKinds); + + BAutolock _(this); + + // Determine the count of byte to compare when checking for a name with + // or without wildcard + size_t nameLength = 0; + if (name != NULL) { + nameLength = strlen(name); + if (nameLength > 0 && name[nameLength - 1] == '*') + nameLength--; + } + + NodeMap::iterator iterator = fNodeMap.begin(); + int32 count = 0; + for (; iterator != fNodeMap.end() && count < maxCount; iterator++) { + registered_node& node = iterator->second; + + if ((node.kinds & requireKinds) != requireKinds) continue; - if (namelen) { - if (0 != strncmp(name, rn->name, namelen)) - continue; - } - if (inputformat) { - bool hasit = false; - media_input *input; - for (rn->inputlist.Rewind(); rn->inputlist.GetNext(&input); ) { - if (format_is_compatible(*inputformat, input->format)) { - hasit = true; - break; - } - } - if (!hasit) - continue; - } - if (outputformat) { - bool hasit = false; - media_output *output; - for (rn->outputlist.Rewind(); rn->outputlist.GetNext(&output); ) { - if (format_is_compatible(*outputformat, output->format)) { - hasit = true; - break; - } - } - if (!hasit) + + if (nameLength != 0) { + if (strncmp(name, node.name, nameLength) != 0) continue; } - live_node_info lni; - lni.node.node = rn->node_id; - lni.node.port = rn->port; - lni.node.kind = rn->kinds; - lni.hint_point = BPoint(0, 0); - strcpy(lni.name, rn->name); - livenodes->Push(lni); - maxcount -= 1; + if (inputFormat != NULL) { + bool found = false; + + for (InputList::iterator inIterator = node.input_list.begin(); + inIterator != node.input_list.end(); inIterator++) { + media_input& input = *inIterator; + + if (format_is_compatible(*inputFormat, input.format)) { + found = true; + break; + } + } + + if (!found) + continue; + } + + if (outputFormat != NULL) { + bool found = false; + + for (OutputList::iterator outIterator = node.output_list.begin(); + outIterator != node.output_list.end(); outIterator++) { + media_output& output = *outIterator; + + if (format_is_compatible(*outputFormat, output.format)) { + found = true; + break; + } + } + + if (!found) + continue; + } + + live_node_info info; + info.node.node = node.node_id; + info.node.port = node.port; + info.node.kind = node.kinds; + info.hint_point = BPoint(0, 0); + strlcpy(info.name, node.name, sizeof(info.name)); + + try { + liveNodes.push_back(info); + } catch (std::bad_alloc& exception) { + return B_NO_MEMORY; + } + + count++; } - TRACE("NodeManager::GetLiveNodes found %ld\n", livenodes->CountItems()); + TRACE("NodeManager::GetLiveNodes found %ld\n", count); return B_OK; } @@ -539,503 +671,598 @@ NodeManager::GetLiveNodes(Stack *livenodes, int32 maxcount, cons int32 "media_node_id" (multiple items) */ status_t -NodeManager::GetLiveNodes(BMessage *msg) +NodeManager::GetLiveNodes(BMessage* message) { - BAutolock lock(fLocker); - registered_node *rn; - for (fRegisteredNodeMap->Rewind(); fRegisteredNodeMap->GetNext(&rn); ) { - msg->AddInt32("media_node_id", rn->node_id); + BAutolock _(this); + + NodeMap::iterator iterator = fNodeMap.begin(); + for (; iterator != fNodeMap.end(); iterator++) { + registered_node& node = iterator->second; + + if (message->AddInt32("media_node_id", node.node_id) != B_OK) + return B_NO_MEMORY; } + return B_OK; } -/********************************************************************** - * Registration of BMediaAddOns - **********************************************************************/ + +// #pragma mark - Registration of BMediaAddOns + void -NodeManager::RegisterAddon(const entry_ref &ref, media_addon_id *newid) +NodeManager::RegisterAddOn(const entry_ref& ref, media_addon_id* _newID) { - BAutolock lock(fLocker); - media_addon_id id; - id = fNextAddOnID; - fNextAddOnID += 1; + BAutolock _(this); - printf("NodeManager::RegisterAddon: ref-name \"%s\", assigning id %ld\n", ref.name, id); + media_addon_id id = fNextAddOnID++; - fAddonPathMap->Insert(id, ref); - *newid = id; + printf("NodeManager::RegisterAddOn: ref-name \"%s\", assigning id %ld\n", + ref.name, id); + + try { + fPathMap.insert(std::make_pair(id, ref)); + *_newID = id; + } catch (std::bad_alloc& exception) { + *_newID = -1; + } } + void -NodeManager::UnregisterAddon(media_addon_id id) +NodeManager::UnregisterAddOn(media_addon_id addOnID) { - BAutolock lock(fLocker); + PRINT("NodeManager::UnregisterAddOn: id %ld\n", addOnID); - printf("NodeManager::UnregisterAddon: id %ld\n", id); + BAutolock _(this); - RemoveDormantFlavorInfo(id); - fAddonPathMap->Remove(id); + RemoveDormantFlavorInfo(addOnID); + fPathMap.erase(addOnID); } + status_t -NodeManager::GetAddonRef(entry_ref *ref, media_addon_id id) +NodeManager::GetAddOnRef(media_addon_id addOnID, entry_ref* ref) { - BAutolock lock(fLocker); - entry_ref *tempref; + BAutolock _(this); - if (fAddonPathMap->Get(id, &tempref)) { - *ref = *tempref; - return B_OK; - } + PathMap::iterator found = fPathMap.find(addOnID); + if (found == fPathMap.end()) + return B_ERROR; - return B_ERROR; + *ref = found->second; + return B_OK; } -/********************************************************************** - * Registration of node flavors, published by BMediaAddOns - **********************************************************************/ -// this function is only called (indirectly) by the media_addon_server -void -NodeManager::AddDormantFlavorInfo(const dormant_flavor_info &dfi) +// #pragma mark - Registration of node flavors, published by BMediaAddOns + + +//! This function is only used (indirectly) by the media_addon_server. +status_t +NodeManager::AddDormantFlavorInfo(const dormant_flavor_info& flavorInfo) { - BAutolock lock(fLocker); + PRINT("NodeManager::AddDormantFlavorInfo, addon-id %ld, flavor-id %ld, " + "name \"%s\", flavor-name \"%s\", flavor-info \"%s\"\n", + flavorInfo.node_info.addon, flavorInfo.node_info.flavor_id, + flavorInfo.node_info.name, flavorInfo.name, flavorInfo.info); - printf("NodeManager::AddDormantFlavorInfo, addon-id %ld, flavor-id %ld, name \"%s\", flavor-name \"%s\", flavor-info \"%s\"\n", dfi.node_info.addon, dfi.node_info.flavor_id, dfi.node_info.name, dfi.name, dfi.info); + BAutolock _(this); // Try to find the addon-id/flavor-id in the list. - // If it already exists, update the Info, but don't - // change the GlobalInstancesCount - dormant_addon_flavor_info *dafi; - for (fDormantAddonFlavorList->Rewind(); fDormantAddonFlavorList->GetNext(&dafi); ) { - if (dafi->AddonID != dfi.node_info.addon || dafi->AddonFlavorID != dfi.node_info.flavor_id) + // If it already exists, update the info, but don't change its instance + // count. + + for (DormantFlavorList::iterator iterator = fDormantFlavors.begin(); + iterator != fDormantFlavors.end(); iterator++) { + dormant_add_on_flavor_info& info = *iterator; + + if (info.add_on_id != flavorInfo.node_info.addon + || info.flavor_id != flavorInfo.node_info.flavor_id) continue; - if (dafi->InfoValid) { - ERROR("NodeManager::AddDormantFlavorInfo, addon-id %ld, flavor-id %ld does already exist\n", dafi->Info.node_info.addon, dafi->Info.node_info.flavor_id); + + if (info.info_valid) { + ERROR("NodeManager::AddDormantFlavorInfo, addon-id %ld, " + "flavor-id %ld does already exist\n", info.info.node_info.addon, + info.info.node_info.flavor_id); } - TRACE("NodeManager::AddDormantFlavorInfo, updating addon-id %ld, flavor-id %ld\n", dafi->Info.node_info.addon, dafi->Info.node_info.flavor_id); - dafi->MaxInstancesCount = dfi.possible_count > 0 ? dfi.possible_count : 0x7fffffff; - // do NOT modify dafi.GlobalInstancesCount - dafi->InfoValid = true; - dafi->Info = dfi; - return; + + TRACE("NodeManager::AddDormantFlavorInfo, updating addon-id %ld, " + "flavor-id %ld\n", info.info.node_info.addon, + info.info.node_info.flavor_id); + + info.max_instances_count = flavorInfo.possible_count > 0 + ? flavorInfo.possible_count : INT32_MAX; + info.info_valid = true; + info.info = flavorInfo; + return B_OK; } // Insert information into the list - { - dormant_addon_flavor_info dafi; - dafi.AddonID = dfi.node_info.addon; - dafi.AddonFlavorID = dfi.node_info.flavor_id; - dafi.MaxInstancesCount = dfi.possible_count > 0 ? dfi.possible_count : 0x7fffffff; - dafi.GlobalInstancesCount = 0; - dafi.InfoValid = true; - dafi.Info = dfi; - fDormantAddonFlavorList->Insert(dafi); - } -} -// this function is only called (indirectly) by the media_addon_server -void -NodeManager::InvalidateDormantFlavorInfo(media_addon_id id) -{ - BAutolock lock(fLocker); - dormant_addon_flavor_info *dafi; - for (fDormantAddonFlavorList->Rewind(); fDormantAddonFlavorList->GetNext(&dafi); ) { - if (dafi->AddonID == id && dafi->InfoValid == true) { - printf("NodeManager::InvalidateDormantFlavorInfo, addon-id %ld, flavor-id %ld, name \"%s\", flavor-name \"%s\", flavor-info \"%s\"\n", dafi->Info.node_info.addon, dafi->Info.node_info.flavor_id, dafi->Info.node_info.name, dafi->Info.name, dafi->Info.info); - dormant_flavor_info dfi_null; - dafi->Info = dfi_null; - dafi->InfoValid = false; - } - } -} + dormant_add_on_flavor_info info; + info.add_on_id = flavorInfo.node_info.addon; + info.flavor_id = flavorInfo.node_info.flavor_id; + info.max_instances_count = flavorInfo.possible_count > 0 + ? flavorInfo.possible_count : INT32_MAX; + info.instances_count = 0; + info.info_valid = true; + info.info = flavorInfo; -// this function is only called by clean up after gone add-ons -void -NodeManager::RemoveDormantFlavorInfo(media_addon_id id) -{ - BAutolock lock(fLocker); - dormant_addon_flavor_info *dafi; - for (fDormantAddonFlavorList->Rewind(); fDormantAddonFlavorList->GetNext(&dafi); ) { - if (dafi->AddonID == id) { - printf("NodeManager::RemoveDormantFlavorInfo, addon-id %ld, flavor-id %ld, name \"%s\", flavor-name \"%s\", flavor-info \"%s\"\n", dafi->Info.node_info.addon, dafi->Info.node_info.flavor_id, dafi->Info.node_info.name, dafi->Info.name, dafi->Info.info); - fDormantAddonFlavorList->RemoveCurrent(); - } - } -} - -status_t -NodeManager::IncrementAddonFlavorInstancesCount(media_addon_id addonid, int32 flavorid, team_id team) -{ - BAutolock lock(fLocker); - - dormant_addon_flavor_info *dafi; - for (fDormantAddonFlavorList->Rewind(); fDormantAddonFlavorList->GetNext(&dafi); ) { - if (dafi->AddonID != addonid || dafi->AddonFlavorID != flavorid) - continue; - - if (dafi->GlobalInstancesCount >= dafi->MaxInstancesCount) { - ERROR("NodeManager::IncrementAddonFlavorInstancesCount addonid %ld, flavorid %ld maximum (or more) instances already exist\n", addonid, flavorid); - return B_ERROR; // maximum (or more) instances already exist - } - - bool b; - int32 *count; - b = dafi->TeamInstancesCount.Get(team, &count); - if (b) { - *count += 1; - } else { - b = dafi->TeamInstancesCount.Insert(team, 1); - ASSERT(b); - } - dafi->GlobalInstancesCount += 1; - return B_OK; - } - ERROR("NodeManager::IncrementAddonFlavorInstancesCount addonid %ld, flavorid %ld not found\n", addonid, flavorid); - return B_ERROR; -} - -status_t -NodeManager::DecrementAddonFlavorInstancesCount(media_addon_id addonid, int32 flavorid, team_id team) -{ - BAutolock lock(fLocker); - - dormant_addon_flavor_info *dafi; - for (fDormantAddonFlavorList->Rewind(); fDormantAddonFlavorList->GetNext(&dafi); ) { - if (dafi->AddonID != addonid || dafi->AddonFlavorID != flavorid) - continue; - - bool b; - int32 *count; - b = dafi->TeamInstancesCount.Get(team, &count); - if (!b) { - ERROR("NodeManager::DecrementAddonFlavorInstancesCount addonid %ld, flavorid %ld team %ld has no references\n", addonid, flavorid, team); - return B_ERROR; - } - *count -= 1; - if (*count == 0) { - b = dafi->TeamInstancesCount.Remove(team); - ASSERT(b); - } - if (dafi->GlobalInstancesCount > 0) // avoid underflow - dafi->GlobalInstancesCount -= 1; - return B_OK; - } - ERROR("NodeManager::DecrementAddonFlavorInstancesCount addonid %ld, flavorid %ld not found\n", addonid, flavorid); - return B_ERROR; -} - -// this function is called when the media_addon_server has crashed -void -NodeManager::CleanupDormantFlavorInfos() -{ - BAutolock lock(fLocker); - printf("NodeManager::CleanupDormantFlavorInfos\n"); - fDormantAddonFlavorList->MakeEmpty(); - printf("NodeManager::CleanupDormantFlavorInfos done\n"); - // XXX FlavorsChanged(media_addon_id addonid, int32 newcount, int32 gonecount) -} - -status_t -NodeManager::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 */) -{ - BAutolock lock(fLocker); - dormant_addon_flavor_info *dafi; - int32 maxcount; - int namelen; - - // determine the count of byte to compare when checking for a name with(out) wildcard - if (name) { - namelen = strlen(name); - if (namelen > 0 && name[namelen - 1] == '*') - namelen--; // compares without the '*' - } else { - namelen = 0; - } - - maxcount = *io_count; - *io_count = 0; - for (fDormantAddonFlavorList->Rewind(); (*io_count < maxcount) && fDormantAddonFlavorList->GetNext(&dafi); ) { - if (!dafi->InfoValid) - continue; - - dormant_flavor_info *dfi; - dfi = &dafi->Info; - - if ((dfi->kinds & require_kinds) != require_kinds) - continue; - if ((dfi->kinds & deny_kinds) != 0) - continue; - if (namelen) { - if (0 != strncmp(name, dfi->name, namelen)) - continue; - } - if (has_input) { - bool hasit = false; - for (int32 i = 0; i < dfi->in_format_count; i++) - if (format_is_compatible(*has_input, dfi->in_formats[i])) { - hasit = true; - break; - } - if (!hasit) - continue; - } - if (has_output) { - bool hasit = false; - for (int32 i = 0; i < dfi->out_format_count; i++) - if (format_is_compatible(*has_output, dfi->out_formats[i])) { - hasit = true; - break; - } - if (!hasit) - continue; - } - - out_info[*io_count] = dfi->node_info; - *io_count += 1; + try { + fDormantFlavors.push_back(info); + } catch (std::bad_alloc& exception) { + return B_NO_MEMORY; } return B_OK; } -status_t -NodeManager::GetDormantFlavorInfoFor(media_addon_id addon, - int32 flavor_id, - dormant_flavor_info *outFlavor) + +//! This function is only used (indirectly) by the media_addon_server +void +NodeManager::InvalidateDormantFlavorInfo(media_addon_id addOnID) { - BAutolock lock(fLocker); - dormant_addon_flavor_info *dafi; - for (fDormantAddonFlavorList->Rewind(); fDormantAddonFlavorList->GetNext(&dafi); ) { - if (dafi->AddonID == addon && dafi->AddonFlavorID == flavor_id && dafi->InfoValid == true) { - *outFlavor = dafi->Info; - return B_OK; + BAutolock _(this); + + for (DormantFlavorList::iterator iterator = fDormantFlavors.begin(); + iterator != fDormantFlavors.end(); iterator++) { + dormant_add_on_flavor_info& info = *iterator; + + if (info.add_on_id == addOnID && info.info_valid) { + PRINT(1, "NodeManager::InvalidateDormantFlavorInfo, addon-id %ld, " + "flavor-id %ld, name \"%s\", flavor-name \"%s\", flavor-info " + "\"%s\"\n", info.info.node_info.addon, + info.info.node_info.flavor_id, info.info.node_info.name, + info.info.name, info.info.info); + + info.info_valid = false; } } +} + + +//! This function is only used (indirectly) by the media_addon_server +void +NodeManager::RemoveDormantFlavorInfo(media_addon_id addOnID) +{ + BAutolock _(this); + + for (size_t index = 0; index < fDormantFlavors.size(); index++) { + dormant_add_on_flavor_info& info = fDormantFlavors[index]; + + if (info.add_on_id == addOnID) { + PRINT(1, "NodeManager::RemoveDormantFlavorInfo, addon-id %ld, " + "flavor-id %ld, name \"%s\", flavor-name \"%s\", flavor-info " + "\"%s\"\n", info.info.node_info.addon, + info.info.node_info.flavor_id, info.info.node_info.name, + info.info.name, info.info.info); + fDormantFlavors.erase(fDormantFlavors.begin() + index--); + } + } +} + + +status_t +NodeManager::IncrementFlavorInstancesCount(media_addon_id addOnID, + int32 flavorID, team_id team) +{ + BAutolock _(this); + + for (DormantFlavorList::iterator iterator = fDormantFlavors.begin(); + iterator != fDormantFlavors.end(); iterator++) { + dormant_add_on_flavor_info& info = *iterator; + + if (info.add_on_id != addOnID || info.flavor_id != flavorID) + continue; + + if (info.instances_count >= info.max_instances_count) { + // maximum (or more) instances already exist + ERROR("NodeManager::IncrementFlavorInstancesCount addon-id %ld, " + "flavor-id %ld maximum (or more) instances already exist\n", + addOnID, flavorID); + return B_ERROR; + } + + TeamCountMap::iterator teamInstance + = info.team_instances_count.find(team); + if (teamInstance == info.team_instances_count.end()) { + // This is the team's first instance + try { + info.team_instances_count.insert(std::make_pair(team, 1)); + } catch (std::bad_alloc& exception) { + return B_NO_MEMORY; + } + } else { + // Just increase its ref count + teamInstance->second++; + } + + info.instances_count++; + return B_OK; + } + + ERROR("NodeManager::IncrementFlavorInstancesCount addon-id %ld, " + "flavor-id %ld not found\n", addOnID, flavorID); return B_ERROR; } -/********************************************************************** - * Default node management - **********************************************************************/ status_t -NodeManager::SetDefaultNode(node_type type, const media_node *node, const dormant_node_info *info, const media_input *input) +NodeManager::DecrementFlavorInstancesCount(media_addon_id addOnID, + int32 flavorID, team_id team) { - BAutolock lock(fLocker); - status_t err = B_BAD_VALUE; - if (node) - err = fDefaultManager->Set(node->node, NULL, 0, type); - else if (input) - err = fDefaultManager->Set(input->node.node, input->name, input->destination.id, type); - else if (info) { - media_node_id node_id; - int32 count = 1; - if ((err=GetInstances(&node_id, &count, count, info->addon, info->flavor_id))!=B_OK) - return err; - err = fDefaultManager->Set(node_id, NULL, 0, type); + BAutolock _(this); + + for (DormantFlavorList::iterator iterator = fDormantFlavors.begin(); + iterator != fDormantFlavors.end(); iterator++) { + dormant_add_on_flavor_info& info = *iterator; + + if (info.add_on_id != addOnID || info.flavor_id != flavorID) + continue; + + TeamCountMap::iterator teamInstance + = info.team_instances_count.find(team); + if (teamInstance == info.team_instances_count.end()) { + ERROR("NodeManager::DecrementFlavorInstancesCount addon-id %ld, " + "flavor-id %ld team %ld has no references\n", addOnID, flavorID, + team); + return B_ERROR; + } + if (--teamInstance->second == 0) + info.team_instances_count.erase(teamInstance); + + info.instances_count--; + return B_OK; } - if(err==B_OK && (type == VIDEO_INPUT || type == VIDEO_OUTPUT || type == AUDIO_OUTPUT || type == AUDIO_INPUT)) { - fDefaultManager->SaveState(this); - Dump(); + + ERROR("NodeManager::DecrementFlavorInstancesCount addon-id %ld, " + "flavor-id %ld not found\n", addOnID, flavorID); + return B_ERROR; +} + + +//! This function is called when the media_addon_server has crashed +void +NodeManager::CleanupDormantFlavorInfos() +{ + PRINT(1, "NodeManager::CleanupDormantFlavorInfos\n"); + + BAutolock _(this); + fDormantFlavors.clear(); + // TODO: FlavorsChanged() notification + + PRINT(1, "NodeManager::CleanupDormantFlavorInfos done\n"); +} + + +status_t +NodeManager::GetDormantNodes(dormant_node_info* infos, int32* _count, + const media_format* input, const media_format* output, const char* name, + uint64 requireKinds, uint64 denyKinds) +{ + BAutolock _(this); + + // Determine the count of byte to compare when checking for a name with + // or without wildcard + size_t nameLength = 0; + if (name != NULL) { + nameLength = strlen(name); + if (nameLength > 0 && name[nameLength - 1] == '*') + nameLength--; } - return err; + + int32 maxCount = *_count; + int32 count = 0; + + for (DormantFlavorList::iterator iterator = fDormantFlavors.begin(); + iterator != fDormantFlavors.end() && count < maxCount; iterator++) { + dormant_add_on_flavor_info& info = *iterator; + + if (!info.info_valid) + continue; + + if ((info.info.kinds & requireKinds) != requireKinds + || (info.info.kinds & denyKinds) != 0) + continue; + + if (nameLength != 0) { + if (strncmp(name, info.info.name, nameLength) != 0) + continue; + } + + if (input != NULL) { + bool found = false; + + for (int32 i = 0; i < info.info.in_format_count; i++) { + if (format_is_compatible(*input, info.info.in_formats[i])) { + found = true; + break; + } + } + + if (!found) + continue; + } + + if (output != NULL) { + bool found = false; + + for (int32 i = 0; i < info.info.out_format_count; i++) { + if (format_is_compatible(*output, info.info.out_formats[i])) { + found = true; + break; + } + } + + if (!found) + continue; + } + + infos[count++] = info.info.node_info; + } + + *_count = count; + return B_OK; } + status_t -NodeManager::GetDefaultNode(media_node_id *nodeid, char *input_name, int32 *input_id, node_type type) +NodeManager::GetDormantFlavorInfoFor(media_addon_id addOnID, int32 flavorID, + dormant_flavor_info* flavorInfo) { - BAutolock lock(fLocker); - return fDefaultManager->Get(nodeid, input_name, input_id, type); + BAutolock _(this); + + for (DormantFlavorList::iterator iterator = fDormantFlavors.begin(); + iterator != fDormantFlavors.end(); iterator++) { + dormant_add_on_flavor_info& info = *iterator; + + if (info.add_on_id == addOnID && info.flavor_id == flavorID + && info.info_valid) { + *flavorInfo = info.info; + return B_OK; + } + } + + return B_ERROR; } -status_t -NodeManager::RescanDefaultNodes() -{ - BAutolock lock(fLocker); - return fDefaultManager->Rescan(); -} -/********************************************************************** - * Cleanup of dead teams - **********************************************************************/ +// #pragma mark - Misc. + void NodeManager::CleanupTeam(team_id team) { - BAutolock lock(fLocker); + BAutolock _(this); fDefaultManager->CleanupTeam(team); PRINT(1, "NodeManager::CleanupTeam: team %ld\n", team); - // XXX send notifications after removing nodes + // TODO: send notifications after removing nodes // Cleanup node references - registered_node *rn; - for (fRegisteredNodeMap->Rewind(); fRegisteredNodeMap->GetNext(&rn); ) { - // if the gone team was the creator of some global dormant node instance, we now invalidate that - // we may want to remove that global node, but I'm not sure - if (rn->creator == team) { - rn->creator = -1; + for (NodeMap::iterator iterator = fNodeMap.begin(); + iterator != fNodeMap.end();) { + registered_node& node = iterator->second; + NodeMap::iterator remove = iterator++; + + // If the gone team was the creator of some global dormant node + // instance, we now invalidate that we may want to remove that + // global node, but I'm not sure + if (node.creator == team) { + node.creator = -1; // fall through } - // if the team hosting this node is gone, remove node from database - if (rn->team == team) { - PRINT(1, "NodeManager::CleanupTeam: removing node id %ld, team %ld\n", rn->nodeid, team); - fRegisteredNodeMap->RemoveCurrent(); + + // If the team hosting this node is gone, remove node from database + if (node.containing_team == team) { + PRINT(1, "NodeManager::CleanupTeam: removing node id %ld, team " + "%ld\n", node.node_id, team); + fNodeMap.erase(remove); continue; } - // check the list of teams that have references to this node, and remove the team - team_id *pteam; - int32 *prefcount; - for (rn->teamrefcount.Rewind(); rn->teamrefcount.GetNext(&prefcount); ) { - rn->teamrefcount.GetCurrentKey(&pteam); - if (*pteam == team) { - PRINT(1, "NodeManager::CleanupTeam: removing %ld refs from node id %ld, team %ld\n", *prefcount, rn->nodeid, team); - rn->teamrefcount.RemoveCurrent(); - break; - } - } - // if the team refcount is now empty, also remove the node - if (rn->teamrefcount.IsEmpty()) { - PRINT(1, "NodeManager::CleanupTeam: removing node id %ld that has no teams\n", rn->nodeid); - fRegisteredNodeMap->RemoveCurrent(); + + // Check the list of teams that have references to this node, and + // remove the team + TeamCountMap::iterator teamRef = node.team_ref_count.find(team); + if (teamRef != node.team_ref_count.end()) { + PRINT(1, "NodeManager::CleanupTeam: removing %ld refs from node " + "id %ld, team %ld\n", teamRef->second, node.node_id, team); + node.ref_count -= teamRef->second; + if (node.ref_count == 0) { + PRINT(1, "NodeManager::CleanupTeam: removing node id %ld that " + "has no teams\n", node.node_id); + + fNodeMap.erase(remove); + } else + node.team_ref_count.erase(teamRef); } } - // Cleanup addon references - dormant_addon_flavor_info *dafi; - for (fDormantAddonFlavorList->Rewind(); fDormantAddonFlavorList->GetNext(&dafi); ) { - bool b; - int32 *count; - b = dafi->TeamInstancesCount.Get(team, &count); - if (b) { - PRINT(1, "NodeManager::CleanupTeam: removing %ld instances from addon %ld, flavor %ld\n", *count, dafi->AddonID, dafi->AddonFlavorID); - dafi->GlobalInstancesCount -= *count; - if (dafi->GlobalInstancesCount < 0) // avoid underflow - dafi->GlobalInstancesCount = 0; - b = dafi->TeamInstancesCount.Remove(team); - ASSERT(b); + // Cleanup add-on references + + for (size_t index = 0; index < fDormantFlavors.size(); index++) { + dormant_add_on_flavor_info& flavorInfo = fDormantFlavors[index]; + + TeamCountMap::iterator instanceCount + = flavorInfo.team_instances_count.find(team); + if (instanceCount != flavorInfo.team_instances_count.end()) { + PRINT(1, "NodeManager::CleanupTeam: removing %ld instances from " + "addon %ld, flavor %ld\n", instanceCount->second, + flavorInfo.add_on_id, flavorInfo.flavor_id); + + flavorInfo.instances_count -= instanceCount->second; + if (flavorInfo.instances_count <= 0) + fDormantFlavors.erase(fDormantFlavors.begin() + index--); + else + flavorInfo.team_instances_count.erase(team); } } } -/********************************************************************** - * State saving/loading - **********************************************************************/ status_t NodeManager::LoadState() { - BAutolock lock(fLocker); + BAutolock _(this); return fDefaultManager->LoadState(); } status_t NodeManager::SaveState() { - BAutolock lock(fLocker); + BAutolock _(this); return fDefaultManager->SaveState(this); } -/********************************************************************** - * Debugging - **********************************************************************/ void NodeManager::Dump() { - BAutolock lock(fLocker); - printf("\n"); + BAutolock _(this); - /* for each addon-id, the addon path map contains an entry_ref - */ - printf("NodeManager: addon path map follows:\n"); - entry_ref *ref; - media_addon_id *id; - for (fAddonPathMap->Rewind(); fAddonPathMap->GetNext(&ref); ) { - fAddonPathMap->GetCurrentKey(&id); - BPath path(ref); - printf(" addon-id %ld, ref-name \"%s\", path \"%s\"\n", *id, ref->name, (path.InitCheck() == B_OK) ? path.Path() : "INVALID"); + // for each addon-id, the add-on path map contains an entry_ref + + printf("\nNodeManager: addon path map follows:\n"); + + for (PathMap::iterator iterator = fPathMap.begin(); + iterator != fPathMap.end(); iterator++) { + BPath path(&iterator->second); + printf(" addon-id %ld, path \"%s\"\n", iterator->first, + path.InitCheck() == B_OK ? path.Path() : "INVALID"); } - printf("NodeManager: list end\n"); - printf("\n"); - /* for each node-id, the registered node map contians information about source of the node, users, etc. - */ + printf("NodeManager: list end\n\n"); + + // for each node-id, the registered node map contians information about + // source of the node, users, etc. + printf("NodeManager: registered nodes map follows:\n"); - registered_node *rn; - for (fRegisteredNodeMap->Rewind(); fRegisteredNodeMap->GetNext(&rn); ) { - printf(" node-id %ld, addon-id %ld, addon-flavor-id %ld, port %ld, creator %ld, team %ld, kinds %#08Lx, name \"%s\"\n", - rn->node_id, rn->addon_id, rn->addon_flavor_id, rn->port, rn->creator, rn->team, rn->kinds, rn->name); + for (NodeMap::iterator iterator = fNodeMap.begin(); + iterator != fNodeMap.end(); iterator++) { + registered_node& node = iterator->second; + + printf(" node-id %ld, addon-id %ld, addon-flavor-id %ld, port %ld, " + "creator %ld, team %ld, kinds %#08Lx, name \"%s\"\n", node.node_id, + node.add_on_id, node.flavor_id, node.port, node.creator, + node.containing_team, node.kinds, node.name); + printf(" teams (refcount): "); - team_id *team; - int32 *refcount; - for (rn->teamrefcount.Rewind(); rn->teamrefcount.GetNext(&refcount); ) { - rn->teamrefcount.GetCurrentKey(&team); - printf("%ld (%ld), ", *team, *refcount); + for (TeamCountMap::iterator refsIterator = node.team_ref_count.begin(); + refsIterator != node.team_ref_count.end(); refsIterator++) { + printf("%ld (%ld), ", refsIterator->first, refsIterator->second); } printf("\n"); - media_input *input; - for (rn->inputlist.Rewind(); rn->inputlist.GetNext(&input); ) { - printf(" media_input: node-id %ld, node-port %ld, source-port %ld, source-id %ld, dest-port %ld, dest-id %ld, name \"%s\"\n", - input->node.node, input->node.port, input->source.port, input->source.id, input->destination.port, input->destination.id, input->name); + + for (InputList::iterator inIterator = node.input_list.begin(); + inIterator != node.input_list.end(); inIterator++) { + media_input& input = *inIterator; + printf(" media_input: node-id %ld, node-port %ld, source-port " + "%ld, source-id %ld, dest-port %ld, dest-id %ld, name " + "\"%s\"\n", input.node.node, input.node.port, input.source.port, + input.source.id, input.destination.port, input.destination.id, + input.name); } - if (rn->inputlist.IsEmpty()) + if (node.input_list.empty()) printf(" media_input: none\n"); - media_output *output; - for (rn->outputlist.Rewind(); rn->outputlist.GetNext(&output); ) { - printf(" media_output: node-id %ld, node-port %ld, source-port %ld, source-id %ld, dest-port %ld, dest-id %ld, name \"%s\"\n", - output->node.node, output->node.port, output->source.port, output->source.id, output->destination.port, output->destination.id, output->name); + + for (OutputList::iterator outIterator = node.output_list.begin(); + outIterator != node.output_list.end(); outIterator++) { + media_output& output = *outIterator; + printf(" media_output: node-id %ld, node-port %ld, source-port " + "%ld, source-id %ld, dest-port %ld, dest-id %ld, name " + "\"%s\"\n", output.node.node, output.node.port, + output.source.port, output.source.id, output.destination.port, + output.destination.id, output.name); } - if (rn->outputlist.IsEmpty()) + if (node.output_list.empty()) printf(" media_output: none\n"); } + printf("NodeManager: list end\n"); printf("\n"); - /* - */ + // Dormant add-on flavors + printf("NodeManager: dormant flavor list follows:\n"); - dormant_addon_flavor_info *dafi; - for (fDormantAddonFlavorList->Rewind(); fDormantAddonFlavorList->GetNext(&dafi); ) { - printf(" AddonID %ld, AddonFlavorID %ld, MaxInstancesCount %ld, GlobalInstancesCount %ld, InfoValid %s\n", - dafi->AddonID, dafi->AddonFlavorID, dafi->MaxInstancesCount, dafi->GlobalInstancesCount, dafi->InfoValid ? "yes" : "no"); - if (!dafi->InfoValid) + + for (DormantFlavorList::iterator iterator = fDormantFlavors.begin(); + iterator != fDormantFlavors.end(); iterator++) { + dormant_add_on_flavor_info& flavorInfo = *iterator; + + printf(" addon-id %ld, flavor-id %ld, max instances count %ld, " + "instances count %ld, info valid %s\n", + flavorInfo.add_on_id, flavorInfo.flavor_id, + flavorInfo.max_instances_count, flavorInfo.instances_count, + flavorInfo.info_valid ? "yes" : "no"); + printf(" teams (instances): "); + for (TeamCountMap::iterator countIterator + = flavorInfo.team_instances_count.begin(); + countIterator != flavorInfo.team_instances_count.end(); + countIterator++) { + printf("%ld (%ld), ", countIterator->first, countIterator->second); + } + printf("\n"); + if (!flavorInfo.info_valid) continue; + printf(" addon-id %ld, addon-flavor-id %ld, addon-name \"%s\"\n", - dafi->Info.node_info.addon, dafi->Info.node_info.flavor_id, dafi->Info.node_info.name); - printf(" flavor-kinds %#08Lx, flavor_flags %#08lx, internal_id %ld, possible_count %ld, in_format_count %ld, out_format_count %ld\n", - dafi->Info.kinds, dafi->Info.flavor_flags, dafi->Info.internal_id, dafi->Info.possible_count, dafi->Info.in_format_count, dafi->Info.out_format_count); - printf(" flavor-name \"%s\"\n", dafi->Info.name); - printf(" flavor-info \"%s\"\n", dafi->Info.info); + flavorInfo.info.node_info.addon, + flavorInfo.info.node_info.flavor_id, + flavorInfo.info.node_info.name); + printf(" flavor-kinds %#08Lx, flavor_flags %#08lx, internal_id %ld, " + "possible_count %ld, in_format_count %ld, out_format_count %ld\n", + flavorInfo.info.kinds, flavorInfo.info.flavor_flags, + flavorInfo.info.internal_id, flavorInfo.info.possible_count, + flavorInfo.info.in_format_count, flavorInfo.info.out_format_count); + printf(" flavor-name \"%s\"\n", flavorInfo.info.name); + printf(" flavor-info \"%s\"\n", flavorInfo.info.info); } printf("NodeManager: list end\n"); + fDefaultManager->Dump(); } -const char * -get_node_type(node_type t) -{ - switch (t) { - #define CASE(c) case c: return #c; - CASE(VIDEO_INPUT) - CASE(AUDIO_INPUT) - CASE(VIDEO_OUTPUT) - CASE(AUDIO_MIXER) - CASE(AUDIO_OUTPUT) - CASE(AUDIO_OUTPUT_EX) - CASE(TIME_SOURCE) - CASE(SYSTEM_TIME_SOURCE) - default: return "unknown"; - } -}; +// #pragma mark - private methods + + +status_t +NodeManager::_AcquireNodeReference(media_node_id id, team_id team) +{ + TRACE("NodeManager::_AcquireNodeReference enter: node %ld, team %ld\n", id, + team); + + BAutolock _(this); + + NodeMap::iterator found = fNodeMap.find(id); + if (found == fNodeMap.end()) { + ERROR("NodeManager::_AcquireNodeReference: node %ld not found\n", id); + return B_ERROR; + } + + registered_node& node = found->second; + + TeamCountMap::iterator teamRef = node.team_ref_count.find(team); + if (teamRef == node.team_ref_count.end()) { + // This is the team's first reference + try { + node.team_ref_count.insert(std::make_pair(team, 1)); + } catch (std::bad_alloc& exception) { + return B_NO_MEMORY; + } + } else { + // Just increase its ref count + teamRef->second++; + } + + node.ref_count++; + + TRACE("NodeManager::_AcquireNodeReference leave: node %ld, team %ld, " + "ref %ld, team ref %ld\n", id, team, node.ref_count, + node.team_ref_count.find(team)->second); + return B_OK; +} diff --git a/src/servers/media/NodeManager.h b/src/servers/media/NodeManager.h index 8c21022e5b..9e5a888d44 100644 --- a/src/servers/media/NodeManager.h +++ b/src/servers/media/NodeManager.h @@ -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 +#include + +#include -#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 teamrefcount; - List inputlist; - List outputlist; -}; - -struct dormant_addon_flavor_info { - media_addon_id AddonID; - int32 AddonFlavorID; - - int32 MaxInstancesCount; - int32 GlobalInstancesCount; - - Map TeamInstancesCount; - - bool InfoValid; - dormant_flavor_info Info; -}; - class DefaultManager; class BufferManager; -class NodeManager { + +typedef std::map TeamCountMap; +typedef std::vector InputList; +typedef std::vector OutputList; +typedef std::vector 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 *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 *fDormantAddonFlavorList; - Map *fAddonPathMap; - Map *fRegisteredNodeMap; - DefaultManager *fDefaultManager; +private: + typedef std::map NodeMap; + typedef std::vector DormantFlavorList; + typedef std::map PathMap; + + media_addon_id fNextAddOnID; + media_node_id fNextNodeID; + + DormantFlavorList fDormantFlavors; + PathMap fPathMap; + NodeMap fNodeMap; + DefaultManager* fDefaultManager; }; + +#endif // NODE_MANAGER_H diff --git a/src/servers/media/media_server.cpp b/src/servers/media/media_server.cpp index 77d5e217f5..b9aab235b6 100644 --- a/src/servers/media/media_server.cpp +++ b/src/servers/media/media_server.cpp @@ -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(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( - 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(data); + const server_node_id_for_request& request + = *static_cast(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( - 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( - data); + const server_get_live_nodes_request& request + = *static_cast(data); server_get_live_nodes_reply reply; - Stack 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(&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(data); + const server_get_node_for_request& request + = *static_cast(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(data); + const server_release_node_request& request + = *static_cast(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(data); + const server_register_node_request& request + = *static_cast(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( - data); + const server_unregister_node_request& request + = *static_cast(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( - data); + = static_cast(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(&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( - data); + = static_cast(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(&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(data); + const server_get_node_request& request + = *static_cast(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(data); + const server_set_node_request& request + = *static_cast(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( + 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( - data); + const server_get_instances_for_request& request + = *static_cast(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( - data); + = static_cast(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( + 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( - data); + = static_cast(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( - data); + = *static_cast(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( - data); + = *static_cast(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(data); + = static_cast(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(data); + = static_cast(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(data); + = static_cast(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( - data); + = static_cast(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( - data); + = *static_cast(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( - data); + = *static_cast(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(data); + = static_cast(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(data); + = static_cast(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(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(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); diff --git a/src/servers/media_addon/MediaAddonServer.cpp b/src/servers/media_addon/MediaAddonServer.cpp index adc21afd62..f6e6fa315c 100644 --- a/src/servers/media_addon/MediaAddonServer.cpp +++ b/src/servers/media_addon/MediaAddonServer.cpp @@ -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;