nephele/haiku
nephele
/
haiku
0
0
Fork 0
Code Issues Releases Activity
haiku/src/servers/media/NodeManager.cpp

1409 lines
38 KiB
C++
Raw Permalink Blame History

/*
* Copyright (c) 2015 Dario Casalinuovo
* Copyright (c) 2002, 2003 Marcus Overhagen <Marcus@Overhagen.de>
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files or portions
* thereof (the "Software"), to deal in the Software without restriction,
* including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright notice
* in the binary, as well as this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with
* the distribution.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
#include "NodeManager.h"
#include <Application.h>
#include <Autolock.h>
#include <Entry.h>
#include <MediaAddOn.h>
#include <MediaDefs.h>
#include <Message.h>
#include <Messenger.h>
#include <OS.h>
#include <Path.h>
#include <MediaDebug.h>
#include <MediaMisc.h>
#include <Notifications.h>
#include "AppManager.h"
#include "DefaultManager.h"
#include "media_server.h"
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)
default:
return "unknown";
}
#undef CASE
}
// #pragma mark -
NodeManager::NodeManager()
:
BLocker("node manager"),
fNextAddOnID(1),
fNextNodeID(1),
fDefaultManager(new DefaultManager)
{
}
NodeManager::~NodeManager()
{
delete fDefaultManager;
}
// #pragma mark - Default node management
status_t
NodeManager::SetDefaultNode(node_type type, const media_node* node,
const dormant_node_info* info, const media_input* input)
{
BAutolock _(this);
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 timesource, media_node_id* _nodeID)
{
BAutolock _(this);
registered_node node;
node.timesource_id = timesource;
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;
if ((node.kinds & B_TIME_SOURCE) != 0
&& strcmp(node.name, "System clock") == 0) {
// This may happen when media_addon_server crash,
// we will replace the old timesource.
node.node_id = NODE_SYSTEM_TIMESOURCE_ID;
NodeMap::iterator found = fNodeMap.find(node.node_id);
if (found != fNodeMap.end())
fNodeMap.erase(node.node_id);
*_nodeID = node.node_id;
} else {
node.node_id = fNextNodeID;
*_nodeID = node.node_id;
}
try {
node.team_ref_count.insert(std::make_pair(team, 1));
fNodeMap.insert(std::make_pair(node.node_id, node));
} catch (std::bad_alloc& exception) {
return B_NO_MEMORY;
}
fNextNodeID++;
TRACE("NodeManager::RegisterNode: node %" B_PRId32 ", addon_id %" B_PRId32
", flavor_id %" B_PRId32 ", name \"%s\", kinds %#" B_PRIx64", port %"
B_PRId32 ", team %" B_PRId32 "\n", *_nodeID, addOnID, flavorID, name,
kinds, port, team);
return B_OK;
}
status_t
NodeManager::UnregisterNode(media_node_id id, team_id team,
media_addon_id* _addOnID, int32* _flavorID)
{
TRACE("NodeManager::UnregisterNode enter: node %" B_PRId32 ", team %"
B_PRId32 "\n", id, team);
BAutolock _(this);
NodeMap::iterator found = fNodeMap.find(id);
if (found == fNodeMap.end()) {
ERROR("NodeManager::UnregisterNode: couldn't find node %" B_PRId32
" (team %" B_PRId32 ")\n", id, team);
return B_ERROR;
}
registered_node& node = found->second;
if (node.containing_team != team) {
ERROR("NodeManager::UnregisterNode: team %" B_PRId32 " tried to "
"unregister node %" B_PRId32 ", but it was instantiated by team %"
B_PRId32 "\n", team, id, node.containing_team);
return B_ERROR;
}
if (node.ref_count != 1) {
ERROR("NodeManager::UnregisterNode: node %" B_PRId32 ", team %"
B_PRId32 " has ref count %" B_PRId32 " (should be 1)\n", id, team,
node.ref_count);
//return B_ERROR;
}
if (_addOnID != NULL)
*_addOnID = node.add_on_id;
if (_flavorID != NULL)
*_flavorID = node.flavor_id;
fNodeMap.erase(found);
TRACE("NodeManager::UnregisterNode leave: node %" B_PRId32 ", addon_id %"
B_PRId32 ", flavor_id %" B_PRId32 " team %" B_PRId32 "\n", id,
*_addOnID, *_flavorID, team);
return B_OK;
}
status_t
NodeManager::ReleaseNodeReference(media_node_id id, team_id team)
{
TRACE("NodeManager::ReleaseNodeReference enter: node %" B_PRId32 ", team %"
B_PRId32 "\n", id, team);
BAutolock _(this);
NodeMap::iterator found = fNodeMap.find(id);
if (found == fNodeMap.end()) {
ERROR("NodeManager::ReleaseNodeReference: node %" B_PRId32 " 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()) {
// 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::ReleaseNodeReference: node %" B_PRId32 " has "
"no team %" B_PRId32 " references\n", id, team);
return B_ERROR;
}
}
#if DEBUG
int32 teamCount = teamRef->second - 1;
(void)teamCount;
#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 %" B_PRId32 "\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 %" B_PRId32 "\n", id);
// ignore error
}
}
TRACE("NodeManager::ReleaseNodeReference leave: node %" B_PRId32 ", team %"
B_PRId32 ", ref %" B_PRId32 ", team ref %" B_PRId32 "\n", id, team,
node.ref_count, teamCount);
return B_OK;
}
status_t
NodeManager::ReleaseNodeAll(media_node_id id)
{
TRACE("NodeManager::ReleaseNodeAll enter: node %" B_PRId32 "\n", id);
BAutolock _(this);
NodeMap::iterator found = fNodeMap.find(id);
if (found == fNodeMap.end()) {
ERROR("NodeManager::ReleaseNodeAll: node %" B_PRId32 " not found\n",
id);
return B_ERROR;
}
registered_node& node = found->second;
node.team_ref_count.clear();
node.ref_count = 0;
node_final_release_command command;
status_t status = SendToPort(node.port, NODE_FINAL_RELEASE, &command,
sizeof(command));
if (status != B_OK) {
ERROR("NodeManager::ReleaseNodeAll: can't send command to "
"node %" B_PRId32 "\n", id);
// ignore error
}
TRACE("NodeManager::ReleaseNodeAll leave: node %" B_PRId32 "\n", id);
return B_OK;
}
status_t
NodeManager::SetNodeCreator(media_node_id id, team_id creator)
{
TRACE("NodeManager::SetNodeCreator node %" B_PRId32 ", creator %" B_PRId32
"\n", id, creator);
BAutolock _(this);
NodeMap::iterator found = fNodeMap.find(id);
if (found == fNodeMap.end()) {
ERROR("NodeManager::SetNodeCreator: node %" B_PRId32 " not found\n",
id);
return B_ERROR;
}
registered_node& node = found->second;
if (node.creator != -1) {
ERROR("NodeManager::SetNodeCreator: node %" B_PRId32 " is already"
" assigned creator %" B_PRId32 "\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 %" B_PRId32 " team %"
B_PRId32 "\n", id, team);
BAutolock _(this);
status_t status = _AcquireNodeReference(id, team);
if (status != B_OK) {
ERROR("NodeManager::GetCloneForID: couldn't increment ref count, "
"node %" B_PRId32 " team %" B_PRId32 "\n", id, team);
return status;
}
NodeMap::iterator found = fNodeMap.find(id);
if (found == fNodeMap.end()) {
ERROR("NodeManager::GetCloneForID: node %" B_PRId32 " not found\n",
id);
return B_ERROR;
}
registered_node& registeredNode = found->second;
node->node = registeredNode.node_id;
node->port = registeredNode.port;
node->kind = registeredNode.kinds;
TRACE("NodeManager::GetCloneForID leave: node %" B_PRId32 " team %"
B_PRId32 "\n", id, team);
return B_OK;
}
/*! This function locates the default "node" for the requested "type" and
returns a clone.
If the requested type is AUDIO_OUTPUT_EX, also "input_name" and "input_id"
need to be set and returned, as this is required by
BMediaRoster::GetAudioOutput(media_node *out_node, int32 *out_input_id,
BString *out_input_name).
*/
status_t
NodeManager::GetClone(node_type type, team_id team, media_node* node,
char* inputName, int32* _inputID)
{
BAutolock _(this);
TRACE("NodeManager::GetClone enter: team %" B_PRId32 ", type %d (%s)\n",
team, type, get_node_type(type));
media_node_id id;
status_t status = GetDefaultNode(type, &id, inputName, _inputID);
if (status != B_OK) {
ERROR("NodeManager::GetClone: couldn't GetDefaultNode, team %" B_PRId32
", type %d (%s)\n", team, type, get_node_type(type));
*node = media_node::null;
return status;
}
ASSERT(id > 0);
status = GetCloneForID(id, team, node);
if (status != B_OK) {
ERROR("NodeManager::GetClone: couldn't GetCloneForID, id %" B_PRId32
", team %" B_PRId32 ", 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 %" B_PRId32 ", node port %"
B_PRId32 ", node kind %#" B_PRIx64 "\n", node->node, node->port,
node->kind);
return B_OK;
}
status_t
NodeManager::ReleaseNode(const media_node& node, team_id team)
{
TRACE("NodeManager::ReleaseNode enter: node %" B_PRId32 " team %" B_PRId32
"\n", node.node, team);
if (ReleaseNodeReference(node.node, team) != B_OK) {
ERROR("NodeManager::ReleaseNode: couldn't decrement node %" B_PRId32
" team %" B_PRId32 " ref count\n", node.node, team);
}
return B_OK;
}
status_t
NodeManager::PublishInputs(const media_node& node, const media_input* inputs,
int32 count)
{
BAutolock _(this);
NodeMap::iterator found = fNodeMap.find(node.node);
if (found == fNodeMap.end()) {
ERROR("NodeManager::PublishInputs: node %" B_PRId32 " not found\n",
node.node);
return B_ERROR;
}
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)
{
BAutolock _(this);
NodeMap::iterator found = fNodeMap.find(node.node);
if (found == fNodeMap.end()) {
ERROR("NodeManager::PublishOutputs: node %" B_PRId32 " not found\n",
node.node);
return B_ERROR;
}
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(port_id port, media_node_id* _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 %" B_PRId32 ", node %"
B_PRId32 "\n", port, node.node_id);
return B_OK;
}
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 %" B_PRId32
", node %" B_PRId32 "\n", port, node.node_id);
return B_OK;
}
}
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 %" B_PRId32
", node %" B_PRId32 "\n", port, node.node_id);
return B_OK;
}
}
}
ERROR("NodeManager::FindNodeID failed, port %" B_PRId32 "\n", port);
return B_ERROR;
}
status_t
NodeManager::GetDormantNodeInfo(const media_node& node,
dormant_node_info* nodeInfo)
{
// TODO: not sure if this is correct
BAutolock _(this);
NodeMap::iterator found = fNodeMap.find(node.node);
if (found == fNodeMap.end()) {
ERROR("NodeManager::GetDormantNodeInfo: node %" B_PRId32 " not found"
"\n", node.node);
return B_ERROR;
}
registered_node& registeredNode = found->second;
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 %" B_PRId32 ", add_on_id %" B_PRId32 ", flavor_id %" B_PRId32
", name \"%s\"\n", node.node, registeredNode.add_on_id,
registeredNode.flavor_id, registeredNode.name);
return B_ERROR;
}
ASSERT(node.port == registeredNode.port);
ASSERT((node.kind & NODE_KIND_COMPARE_MASK)
== (registeredNode.kinds & NODE_KIND_COMPARE_MASK));
nodeInfo->addon = registeredNode.add_on_id;
nodeInfo->flavor_id = registeredNode.flavor_id;
strlcpy(nodeInfo->name, registeredNode.name, sizeof(nodeInfo->name));
TRACE("NodeManager::GetDormantNodeInfo node %" B_PRId32 ", add_on_id %"
B_PRId32 ", flavor_id %" B_PRId32 ", name \"%s\"\n", node.node,
registeredNode.add_on_id, registeredNode.flavor_id,
registeredNode.name);
return B_OK;
}
status_t
NodeManager::GetLiveNodeInfo(const media_node& node, live_node_info* liveInfo)
{
BAutolock _(this);
NodeMap::iterator found = fNodeMap.find(node.node);
if (found == fNodeMap.end()) {
ERROR("NodeManager::GetLiveNodeInfo: node %" B_PRId32 " not found\n",
node.node);
return B_ERROR;
}
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 %" B_PRId32 ", 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 %" B_PRId32 " instances for "
"addon_id %" B_PRId32 ", flavor_id %" B_PRId32 "\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 %" B_PRId32 ", in-format %p, "
"out-format %p, name %s, require kinds 0x%" B_PRIx64 "\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 (nameLength != 0) {
if (strncmp(name, node.name, nameLength) != 0)
continue;
}
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 %" B_PRId32 "\n", count);
return B_OK;
}
/*! Add media_node_id of all live nodes to the message
int32 "media_node_id" (multiple items)
*/
status_t
NodeManager::GetLiveNodes(BMessage* message)
{
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;
}
// #pragma mark - Registration of BMediaAddOns
void
NodeManager::RegisterAddOn(const entry_ref& ref, media_addon_id* _newID)
{
BAutolock _(this);
media_addon_id id = fNextAddOnID++;
// printf("NodeManager::RegisterAddOn: ref-name \"%s\", assigning id %"
// B_PRId32 "\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 addOnID)
{
PRINT(1, "NodeManager::UnregisterAddOn: id %" B_PRId32 "\n", addOnID);
BAutolock _(this);
RemoveDormantFlavorInfo(addOnID);
fPathMap.erase(addOnID);
}
status_t
NodeManager::GetAddOnRef(media_addon_id addOnID, entry_ref* ref)
{
BAutolock _(this);
PathMap::iterator found = fPathMap.find(addOnID);
if (found == fPathMap.end())
return B_ERROR;
*ref = found->second;
return B_OK;
}
// #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)
{
PRINT(1, "NodeManager::AddDormantFlavorInfo, addon-id %" B_PRId32 ", "
"flavor-id %" B_PRId32 ", 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);
BAutolock _(this);
// Try to find the addon-id/flavor-id in the list.
// 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 (info.info_valid) {
ERROR("NodeManager::AddDormantFlavorInfo, addon-id %" B_PRId32 ", "
"flavor-id %" B_PRId32 " does already exist\n",
info.info.node_info.addon, info.info.node_info.flavor_id);
}
TRACE("NodeManager::AddDormantFlavorInfo, updating addon-id %" B_PRId32
", flavor-id %" B_PRId32 "\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_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;
try {
fDormantFlavors.push_back(info);
} catch (std::bad_alloc& exception) {
return B_NO_MEMORY;
}
return B_OK;
}
//! This function is only used (indirectly) by the media_addon_server
void
NodeManager::InvalidateDormantFlavorInfo(media_addon_id addOnID)
{
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 %"
B_PRId32 ", flavor-id %" B_PRId32 ", 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 %"
B_PRId32 ", flavor-id %" B_PRId32 ", 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 %"
B_PRId32 ", flavor-id %" B_PRId32 " 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 %" B_PRId32 ", "
"flavor-id %" B_PRId32 " not found\n", addOnID, flavorID);
return B_ERROR;
}
status_t
NodeManager::DecrementFlavorInstancesCount(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;
TeamCountMap::iterator teamInstance
= info.team_instances_count.find(team);
if (teamInstance == info.team_instances_count.end()) {
ERROR("NodeManager::DecrementFlavorInstancesCount addon-id %"
B_PRId32 ", flavor-id %" B_PRId32 " team %" B_PRId32 " 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;
}
ERROR("NodeManager::DecrementFlavorInstancesCount addon-id %" B_PRId32 ", "
"flavor-id %" B_PRId32 " 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);
for (DormantFlavorList::iterator iterator = fDormantFlavors.begin();
iterator != fDormantFlavors.end(); iterator++) {
dormant_add_on_flavor_info& info = *iterator;
// Current instance count is zero since the media_addon_server crashed.
BPrivate::media::notifications::FlavorsChanged(info.add_on_id,
0, info.instances_count);
}
fDormantFlavors.clear();
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--;
}
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::GetDormantFlavorInfoFor(media_addon_id addOnID, int32 flavorID,
dormant_flavor_info* flavorInfo)
{
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;
}
// #pragma mark - Misc.
status_t
NodeManager::SetNodeTimeSource(media_node_id node,
media_node_id timesource)
{
BAutolock _(this);
NodeMap::iterator found = fNodeMap.find(node);
if (found == fNodeMap.end()) {
ERROR("NodeManager::SetNodeTimeSource: node %"
B_PRId32 " not found\n", node);
return B_ERROR;
}
registered_node& registeredNode = found->second;
registeredNode.timesource_id = timesource;
return B_OK;
}
void
NodeManager::CleanupTeam(team_id team)
{
BAutolock _(this);
fDefaultManager->CleanupTeam(team);
PRINT(1, "NodeManager::CleanupTeam: team %" B_PRId32 "\n", team);
// Cleanup node references
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 (node.containing_team == team) {
PRINT(1, "NodeManager::CleanupTeam: removing node id %" B_PRId32
", team %" B_PRId32 "\n", node.node_id, team);
// Ensure the slave node is removed from it's timesource
_NotifyTimeSource(node);
fNodeMap.erase(remove);
BPrivate::media::notifications::NodesDeleted(&node.node_id, 1);
continue;
}
// 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 %" B_PRId32 " refs "
"from node id %" B_PRId32 ", team %" B_PRId32 "\n",
teamRef->second, node.node_id, team);
node.ref_count -= teamRef->second;
if (node.ref_count == 0) {
PRINT(1, "NodeManager::CleanupTeam: removing node id %"
B_PRId32 " that has no teams\n", node.node_id);
// Ensure the slave node is removed from it's timesource
_NotifyTimeSource(node);
fNodeMap.erase(remove);
BPrivate::media::notifications::NodesDeleted(&node.node_id, 1);
} else
node.team_ref_count.erase(teamRef);
}
}
// 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 %" B_PRId32 " "
"instances from addon %" B_PRId32 ", flavor %" B_PRId32 "\n",
instanceCount->second, flavorInfo.add_on_id,
flavorInfo.flavor_id);
int32 count = flavorInfo.instances_count;
flavorInfo.instances_count -= instanceCount->second;
if (flavorInfo.instances_count <= 0) {
fDormantFlavors.erase(fDormantFlavors.begin() + index--);
BPrivate::media::notifications::FlavorsChanged(
flavorInfo.add_on_id, 0, count);
} else
flavorInfo.team_instances_count.erase(team);
}
}
}
status_t
NodeManager::LoadState()
{
BAutolock _(this);
return fDefaultManager->LoadState();
}
status_t
NodeManager::SaveState()
{
BAutolock _(this);
return fDefaultManager->SaveState(this);
}
void
NodeManager::Dump()
{
BAutolock _(this);
// 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 %" B_PRId32 ", path \"%s\"\n", iterator->first,
path.InitCheck() == B_OK ? path.Path() : "INVALID");
}
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");
for (NodeMap::iterator iterator = fNodeMap.begin();
iterator != fNodeMap.end(); iterator++) {
registered_node& node = iterator->second;
printf(" node-id %" B_PRId32 ", addon-id %" B_PRId32 ", addon-flavor-"
"id %" B_PRId32 ", port %" B_PRId32 ", creator %" B_PRId32 ", "
"team %" B_PRId32 ", kinds %#08" B_PRIx64 ", name \"%s\", "
"ref_count %" B_PRId32 "\n", node.node_id, node.add_on_id,
node.flavor_id, node.port, node.creator, node.containing_team,
node.kinds, node.name, node.ref_count);
printf(" teams (refcount): ");
for (TeamCountMap::iterator refsIterator = node.team_ref_count.begin();
refsIterator != node.team_ref_count.end(); refsIterator++) {
printf("%" B_PRId32 " (%" B_PRId32 "), ", refsIterator->first,
refsIterator->second);
}
printf("\n");
for (InputList::iterator inIterator = node.input_list.begin();
inIterator != node.input_list.end(); inIterator++) {
media_input& input = *inIterator;
printf(" media_input: node-id %" B_PRId32 ", node-port %"
B_PRId32 ", source-port %" B_PRId32 ", source-id %" B_PRId32
", dest-port %" B_PRId32 ", dest-id %" B_PRId32 ", name "
"\"%s\"\n", input.node.node, input.node.port, input.source.port,
input.source.id, input.destination.port, input.destination.id,
input.name);
}
if (node.input_list.empty())
printf(" media_input: none\n");
for (OutputList::iterator outIterator = node.output_list.begin();
outIterator != node.output_list.end(); outIterator++) {
media_output& output = *outIterator;
printf(" media_output: node-id %" B_PRId32 ", node-port %"
B_PRId32 ", source-port %" B_PRId32 ", source-id %" B_PRId32
", dest-port %" B_PRId32 ", dest-id %" B_PRId32 ", name "
"\"%s\"\n", output.node.node, output.node.port,
output.source.port, output.source.id, output.destination.port,
output.destination.id, output.name);
}
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");
for (DormantFlavorList::iterator iterator = fDormantFlavors.begin();
iterator != fDormantFlavors.end(); iterator++) {
dormant_add_on_flavor_info& flavorInfo = *iterator;
printf(" addon-id %" B_PRId32 ", flavor-id %" B_PRId32 ", max "
"instances count %" B_PRId32 ", instances count %" B_PRId32 ", "
"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("%" B_PRId32 " (%" B_PRId32 "), ", countIterator->first,
countIterator->second);
}
printf("\n");
if (!flavorInfo.info_valid)
continue;
printf(" addon-id %" B_PRId32 ", addon-flavor-id %" B_PRId32 ", "
"addon-name \"%s\"\n", flavorInfo.info.node_info.addon,
flavorInfo.info.node_info.flavor_id,
flavorInfo.info.node_info.name);
printf(" flavor-kinds %#08" B_PRIx64 ", flavor_flags %#08" B_PRIx32
", internal_id %" B_PRId32 ", possible_count %" B_PRId32 ", "
"in_format_count %" B_PRId32 ", out_format_count %" B_PRId32 "\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();
}
// #pragma mark - private methods
status_t
NodeManager::_AcquireNodeReference(media_node_id id, team_id team)
{
TRACE("NodeManager::_AcquireNodeReference enter: node %" B_PRId32 ", team "
"%" B_PRId32 "\n", id, team);
BAutolock _(this);
NodeMap::iterator found = fNodeMap.find(id);
if (found == fNodeMap.end()) {
ERROR("NodeManager::_AcquireNodeReference: node %" B_PRId32 " 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 %" B_PRId32 ", team "
"%" B_PRId32 ", ref %" B_PRId32 ", team ref %" B_PRId32 "\n", id, team,
node.ref_count, node.team_ref_count.find(team)->second);
return B_OK;
}
void
NodeManager::_NotifyTimeSource(registered_node& node)
{
team_id team = be_app->Team();
media_node timeSource;
// Ensure the timesource ensure still exists
if (GetCloneForID(node.timesource_id, team, &timeSource) != B_OK)
return;
media_node currentNode;
if (GetCloneForID(node.node_id, team,
&currentNode) == B_OK) {
timesource_remove_slave_node_command cmd;
cmd.node = currentNode;
// Notify slave node removal to owner timesource
SendToPort(timeSource.port, TIMESOURCE_REMOVE_SLAVE_NODE,
&cmd, sizeof(cmd));
ReleaseNode(timeSource, team);
}
ReleaseNode(currentNode, team);
}
View Git Blame Copy Permalink