haiku.git

/*
 * 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);
}