xref: /haiku/src/apps/cortex/RouteApp/ConnectionIO.cpp (revision a0795c6fe30e25338049a952326c61deb7a343b6)

// ConnectionIO.cpp

#include "ConnectionIO.h"
#include "LiveNodeIO.h"
#include "NodeManager.h"
#include "NodeSetIOContext.h"

#include "MediaFormatIO.h"
#include "route_app_io.h"

#include <vector>
#include <Debug.h>

__USE_CORTEX_NAMESPACE

// -------------------------------------------------------- //
// *** ctor/dtor
// -------------------------------------------------------- //

ConnectionIO::~ConnectionIO() {
	if(m_inputNodeIO) delete m_inputNodeIO;
	if(m_outputNodeIO) delete m_outputNodeIO;
}

// initialize for import
ConnectionIO::ConnectionIO() :
	m_inputNodeIO(0),
	m_outputNodeIO(0),
	m_flags(0),
	m_exportValid(false),
	m_importState(IMPORT_NONE) {

	m_outputFormat.type = B_MEDIA_NO_TYPE;
	m_inputFormat.type = B_MEDIA_NO_TYPE;
	m_requestedFormat.type = B_MEDIA_NO_TYPE;
}

// initialize for export
ConnectionIO::ConnectionIO(
	const Connection*				con,
	const NodeManager*			manager,
	const NodeSetIOContext*	context) :

	m_inputNodeIO(0),
	m_outputNodeIO(0),
	m_exportValid(false),
	m_importState(IMPORT_NONE) {

	ASSERT(con);
	ASSERT(manager);
	ASSERT(context);
	status_t err;

	if(!con->isValid()) {
		PRINT((
			"!!! ConnectionIO(): invalid connection\n"));
		return;
	}

	m_outputNodeIO = new LiveNodeIO(
		manager,
		context,
		con->sourceNode());

	// fetch output (connection-point) description
	const char* name;
	if(con->getOutputHint(
		&name,
		&m_outputFormat) == B_OK)
		m_outputName = name;
	else {
		m_outputName = con->outputName();
	}

	m_inputNodeIO = new LiveNodeIO(
		manager,
		context,
		con->destinationNode());

	// fetch input (connection-point) description
	if(con->getInputHint(
		&name,
		&m_inputFormat) == B_OK)
		m_inputName = name;

	else {
		m_inputName = con->inputName();
	}

	m_requestedFormat = con->requestedFormat();
	m_flags = con->flags();

	m_exportValid = true;
}

// -------------------------------------------------------- //
// *** operations
// -------------------------------------------------------- //

// call when object imported to create the described
// connection

// +++++ to do
// smarter input/output matching -- if no name/format provided,
// pick the first available endpoint.  otherwise, make two passes:
// 1) match all nodes w/ given name (pass wildcards through to roster)
// 2) filter by format

status_t ConnectionIO::instantiate(
	NodeManager*						manager,
	const NodeSetIOContext*	context,
	Connection*							outCon) {

	// sanity checks
	ASSERT(manager);
	if(!m_inputNodeIO || !m_outputNodeIO)
		return B_NOT_ALLOWED;

	status_t err;
	media_node_id node;

	// find output node
	NodeRef* outputRef;
	err = m_outputNodeIO->getNode(manager, context, &node);
	if(err < B_OK)
		return err;
	err = manager->getNodeRef(
		node,
		&outputRef);
	if(err < B_OK)
		return err;

	// find output +++++ currently matches by name only
	const int32 outputBufferSize = 16;
	media_output outputs[outputBufferSize];
	int32 count = outputBufferSize;

	//vector<media_output> outputs;
//	err = outputRef->getFreeOutputs(
//		outputs/*,
//		m_outputFormat.type*/);

	err = outputRef->getFreeOutputs(
		outputs,
		outputBufferSize,
		&count);
	if(err < B_OK)
		return err;

	media_output output;
	bool found = false;
	for(int n = 0; n < count; ++n) {
		if(m_outputName == outputs[n].name) {
			output = outputs[n];
			found = true;
			break;
		}
	}
	if(!found) {
		PRINT(("!!! output '%s' of node '%s' not found\n",
			m_outputName.String(),
			outputRef->name()));
		return B_NAME_NOT_FOUND;
	}

	// find input node
	NodeRef* inputRef;
	err = m_inputNodeIO->getNode(manager, context, &node);
	if(err < B_OK)
		return err;
	err = manager->getNodeRef(
		node,
		&inputRef);
	if(err < B_OK)
		return err;

	// find input +++++ currently matches by name only
	vector<media_input> inputs;
	err = inputRef->getFreeInputs(
		inputs /*,
		m_inputFormat.type*/);
	if(err < B_OK)
		return err;

	media_input input;
	found = false;
	for(unsigned int n = 0; n < inputs.size(); ++n) {
		if(m_inputName == inputs[n].name) {
			input = inputs[n];
			found = true;
			break;
		}
	}
	if(!found) {
		PRINT(("!!! input '%s' of node '%s' not found\n",
			m_inputName.String(),
			inputRef->name()));
		return B_NAME_NOT_FOUND;
	}

	// connect
	Connection con;
	if(m_requestedFormat.type != B_MEDIA_NO_TYPE)
		err = manager->connect(
			output,
			input,
			m_requestedFormat,
			&con);
	else
		err = manager->connect(
			output,
			input,
			&con);

	if(err < B_OK)
		return err;

	if(outCon)
		*outCon = con;
	return B_OK;
}

// -------------------------------------------------------- //
// *** document-type setup
// -------------------------------------------------------- //

/*static*/
void ConnectionIO::AddTo(
	XML::DocumentType*			docType) {

	// map self
	docType->addMapping(new Mapping<ConnectionIO>(_CONNECTION_ELEMENT));

	// map simple (content-only) elements
	// +++++ should these be added at a higher level, since they're
	//       shared?  no harm is done if one is added more than once,
	//       since they'll always map to StringContent -- but it's way
	//       messy!
	// +++++
	//docType->addMapping(new Mapping<StringContent>(_LIVE_NODE_ELEMENT));
//	docType->addMapping(new Mapping<StringContent>(_NAME_ELEMENT));
//	docType->addMapping(new Mapping<StringContent>(_KIND_ELEMENT));
//	docType->addMapping(new Mapping<StringContent>(_FLAG_ELEMENT));
}

// -------------------------------------------------------- //
// *** IPersistent
// -------------------------------------------------------- //

// -------------------------------------------------------- //
// EXPORT:
// -------------------------------------------------------- //


// -------------------------------------------------------- //
void ConnectionIO::xmlExportBegin(
	ExportContext&						context) const {

	if(!m_exportValid) {
		context.reportError(
			"ConnectionIO::xmlExportBegin():\n"
			"*** invalid ***\n");
		return;
	}

	context.beginElement(_CONNECTION_ELEMENT);
}

void ConnectionIO::xmlExportAttributes(
	ExportContext&						context) const { TOUCH(context); }

void ConnectionIO::xmlExportContent(
	ExportContext&						context) const {

	context.beginContent();

	// write output
	{
		context.beginElement(_OUTPUT_ELEMENT);
		context.beginContent();

		// describe the node
//		LiveNodeIO nodeIO(
//			m_manager,
//			dynamic_cast<NodeSetIOContext*>(&context),
//			m_outputNode);
		context.writeObject(m_outputNodeIO);

//		context.beginElement(_LIVE_NODE_ELEMENT);
//		if(m_outputNodeKey.Length()) {
//			context.writeAttr("key", m_outputNodeKey);
//		}
//		else {
//			_write_simple("name", m_outputNodeName.String(), context);
//			_write_node_kinds(m_outputNodeKind, context);
//		}
//		context.endElement(); // _LIVE_NODE_ELEMENT

		// describe the output

		_write_simple("name", m_outputName.String(), context);

		if(m_outputFormat.type > B_MEDIA_UNKNOWN_TYPE) {
			MediaFormatIO io(m_outputFormat);
			context.writeObject(&io);
		}

		context.endElement(); // _OUTPUT_ELEMENT
	}

	// write input
	{
		context.beginElement(_INPUT_ELEMENT);
		context.beginContent();

		// describe the node
//		LiveNodeIO nodeIO(
//			m_manager,
//			dynamic_cast<NodeSetIOContext*>(&context),
//			m_inputNode);
		context.writeObject(m_inputNodeIO);

//		context.beginElement(_LIVE_NODE_ELEMENT);
//		if(m_inputNodeKey.Length()) {
//			context.writeAttr("key", m_inputNodeKey);
//		}
//		else {
//			_write_simple("name", m_inputNodeName.String(), context);
//			_write_node_kinds(m_inputNodeKind, context);
//		}
//		context.endElement(); // _LIVE_NODE_ELEMENT

		// describe the input

		_write_simple("name", m_inputName.String(), context);

		if(m_inputFormat.type > B_MEDIA_UNKNOWN_TYPE) {
			MediaFormatIO io(m_inputFormat);
			context.writeObject(&io);
		}

		context.endElement(); // _INPUT_ELEMENT
	}

	// write requested format
	if(m_requestedFormat.type > B_MEDIA_UNKNOWN_TYPE) {
		MediaFormatIO io(m_requestedFormat);
		BString comment = "\n";
		comment << context.indentString();
		comment << "<!-- initial requested format -->";
		context.writeString(comment);
		context.writeObject(&io);
	}
}

void ConnectionIO::xmlExportEnd(
	ExportContext&						context) const {

	context.endElement(); // _CONNECTION_ELEMENT
}

// -------------------------------------------------------- //
// IMPORT:
// -------------------------------------------------------- //

void ConnectionIO::xmlImportBegin(
	ImportContext&						context) { TOUCH(context); }

void ConnectionIO::xmlImportAttribute(
	const char*								key,
	const char*								value,
	ImportContext&						context) { TOUCH(key); TOUCH(value); TOUCH(context); }

void ConnectionIO::xmlImportContent(
	const char*								data,
	uint32										length,
	ImportContext&						context) { TOUCH(data); TOUCH(length); TOUCH(context); }

void ConnectionIO::xmlImportChild(
	IPersistent*							child,
	ImportContext&						context) {

	status_t err;

	if(!strcmp(context.element(), _LIVE_NODE_ELEMENT)) {
		LiveNodeIO* nodeIO = dynamic_cast<LiveNodeIO*>(child);
		ASSERT(nodeIO);

		// store the LiveNodeIO for now; it will be used in
		// instantiate()

		switch(m_importState) {
			case IMPORT_OUTPUT:
				m_outputNodeIO = nodeIO;
				child = 0; // don't delete child object
				break;

			case IMPORT_INPUT:
				m_inputNodeIO = nodeIO;
				child = 0; // don't delete child object
				break;

			case IMPORT_NONE:
				context.reportError("Unexpected node description.\n");
				delete child;
				return;
		}
	}
	else if(!strcmp(context.element(), _NAME_ELEMENT)) {
		StringContent* c = dynamic_cast<StringContent*>(child);
		ASSERT(c);

		switch(m_importState) {
			case IMPORT_OUTPUT:
				m_outputName = c->content;
				break;

			case IMPORT_INPUT:
				m_inputName = c->content;
				break;

			case IMPORT_NONE:
				context.reportError("Unexpected node name.\n");
				delete child;
				return;
		}
	}
	else {
		MediaFormatIO* io = dynamic_cast<MediaFormatIO*>(child);
		if(!io) {
			context.reportError("Unexpected element.\n");
			delete child;
			return;
		}

		media_format f;
		err = io->getFormat(f);
		if(err < B_OK) {
			context.reportError("Malformed format.\n");
			delete child;
			return;
		}

		switch(m_importState) {
			case IMPORT_OUTPUT:
				m_outputFormat = f;
				break;

			case IMPORT_INPUT:
				m_inputFormat = f;
				break;

			case IMPORT_NONE:
				m_requestedFormat = f;
				break;
		}
	}

	if(child)
		delete child;
}

void ConnectionIO::xmlImportComplete(
	ImportContext&						context) {

	// +++++
}

void ConnectionIO::xmlImportChildBegin(
	const char*								name,
	ImportContext&						context) {

	if(!strcmp(name, "input")) {
		if(m_importState != IMPORT_NONE) {
			context.reportError("ConnectionIO: unexpected nested child element\n");
			return;
		}
		m_importState = IMPORT_INPUT;
	}
	else if(!strcmp(name, "output")) {
		if(m_importState != IMPORT_NONE) {
			context.reportError("ConnectionIO: unexpected nested child element\n");
			return;
		}
		m_importState = IMPORT_OUTPUT;
	}
	else
		context.reportError("ConnectionIO: unexpected child element\n");
}

void ConnectionIO::xmlImportChildComplete(
	const char*								name,
	ImportContext&						context) {
	TOUCH(name); TOUCH(context);

	m_importState = IMPORT_NONE;
}

// END -- ConnectionIO.cpp --