haiku.git

/*
 * Copyright (c) 1999-2000, Eric Moon.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions, and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions, and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */


// 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>

using namespace std;

__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);
	
	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 --