Fix saving of control bindings.

git-svn-id: http://svn.drobilla.net/lad/trunk/ingen@4500 a436a847-0d15-0410-975c-d299462d15a1

5 files changed, 60 insertions, 33 deletions

diff --git a/src/serialisation/Serialiser.cpp b/src/serialisation/Serialiser.cpp
index 1d22ce75..8f82ed5f 100644
--- a/src/serialisation/Serialiser.cpp
+++ b/src/serialisation/Serialiser.cpp
@@ -60,8 +60,14 @@ struct Serialiser::Impl {
 	explicit Impl(Shared::World& world)
 		: _root_path("/")
 		, _world(world)
+		, _model(NULL)
+		, _sratom(sratom_new(&_world.uri_map().urid_map_feature()->urid_map))
 	{}
 
+	~Impl() {
+		sratom_free(_sratom);
+	}
+
 	enum Mode { TO_FILE, TO_STRING };
 
 	void start_to_filename(const std::string& filename);
@@ -101,6 +107,7 @@ struct Serialiser::Impl {
 	std::string              _base_uri;
 	Shared::World&           _world;
 	Sord::Model*             _model;
+	Sratom*                  _sratom;
 };
 
 Serialiser::Serialiser(Shared::World& world)
@@ -550,25 +557,23 @@ void
 Serialiser::Impl::serialise_properties(Sord::Node                     id,
                                        const GraphObject::Properties& props)
 {
-	LV2_URID_Map*   map      = &_world.uri_map().urid_map_feature()->urid_map;
 	LV2_URID_Unmap* unmap    = &_world.uri_map().urid_unmap_feature()->urid_unmap;
-	Sratom*         sratom   = sratom_new(map);
 	SerdNode        base     = serd_node_from_string(SERD_URI,
 	                                                 (const uint8_t*)_base_uri.c_str());
 	SerdEnv*        env      = serd_env_new(&base);
 	SordInserter*   inserter = sord_inserter_new(_model->c_obj(), env);
 
-	sratom_set_sink(sratom, _base_uri.c_str(),
+	sratom_set_sink(_sratom, _base_uri.c_str(),
 	                (SerdStatementSink)sord_inserter_write_statement, NULL,
 	                inserter);
 
-	sratom_set_pretty_numbers(sratom, true);
+	sratom_set_pretty_numbers(_sratom, true);
 
 	typedef GraphObject::Properties::const_iterator iterator;
 	for (iterator v = props.begin(); v != props.end(); ++v) {
 		const Sord::URI key(_model->world(), v->first.str());
 		if (!skip_property(key)) {
-			sratom_write(sratom, unmap, 0,
+			sratom_write(_sratom, unmap, 0,
 			             sord_node_to_serd_node(id.c_obj()),
 			             sord_node_to_serd_node(key.c_obj()),
 			             v->second.type(), v->second.size(), v->second.get_body());
@@ -577,7 +582,6 @@ Serialiser::Impl::serialise_properties(Sord::Node                     id,
 
 	sord_inserter_free(inserter);
 	serd_env_free(env);
-	sratom_free(sratom);
 }
 
 } // namespace Serialisation
diff --git a/src/server/ControlBindings.cpp b/src/server/ControlBindings.cpp
index 82b15408..b224d30a 100644
--- a/src/server/ControlBindings.cpp
+++ b/src/server/ControlBindings.cpp
@@ -65,24 +65,37 @@ ControlBindings::Key
 ControlBindings::binding_key(const Raul::Atom& binding) const
 {
 	const Ingen::Shared::URIs& uris = _engine.world()->uris();
-	Key key;
-	if (binding.type() == _engine.world()->forge().Dict) {
-		const Raul::Atom::DictValue&          dict = binding.get_dict();
-		Raul::Atom::DictValue::const_iterator t    = dict.find(uris.rdf_type);
-		Raul::Atom::DictValue::const_iterator n;
-		if (t == dict.end()) {
-			return key;
-		} else if (t->second == uris.midi_Bender) {
+	Key       key;
+	LV2_Atom* num = NULL;
+	if (binding.type() == uris.atom_Blank) {
+		LV2_Atom_Object* obj = (LV2_Atom_Object*)binding.get_body();
+		if (obj->body.otype == uris.midi_Bender) {
 			key = Key(MIDI_BENDER);
-		} else if (t->second == uris.midi_ChannelPressure) {
+		} else if (obj->body.otype == uris.midi_ChannelPressure) {
 			key = Key(MIDI_CHANNEL_PRESSURE);
-		} else if (t->second == uris.midi_Controller) {
-			if ((n = dict.find(uris.midi_controllerNumber)) != dict.end())
-				key = Key(MIDI_CC, n->second.get_int32());
-		} else if (t->second == uris.midi_NoteOn) {
-			if ((n = dict.find(uris.midi_noteNumber)) != dict.end())
-				key = Key(MIDI_NOTE, n->second.get_int32());
+		} else if (obj->body.otype == uris.midi_Controller) {
+			lv2_atom_object_get(
+				obj, (LV2_URID)uris.midi_controllerNumber, &num, NULL);
+			if (!num) {
+				Raul::error << "Controller binding missing number" << std::endl;
+			} else if (num->type != uris.atom_Int) {
+				Raul::error << "Controller number not an integer" << std::endl;
+			} else {
+				key = Key(MIDI_CC, ((LV2_Atom_Int*)num)->body);
+			}
+		} else if (obj->body.otype == uris.midi_NoteOn) {
+			lv2_atom_object_get(
+				obj, (LV2_URID)uris.midi_noteNumber, &num, NULL);
+			if (!num) {
+				Raul::error << "Note binding missing number" << std::endl;
+			} else if (num->type != uris.atom_Int) {
+				Raul::error << "Note number not an integer" << std::endl;
+			} else {
+				key = Key(MIDI_NOTE, ((LV2_Atom_Int*)num)->body);
+			}
 		}
+	} else {
+		Raul::error << "Unknown binding type " << binding.type() << std::endl;
 	}
 	return key;
 }
diff --git a/src/server/Notification.cpp b/src/server/Notification.cpp
index 88f67137..d3298f8e 100644
--- a/src/server/Notification.cpp
+++ b/src/server/Notification.cpp
@@ -14,6 +14,9 @@
   along with Ingen.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+#include "lv2/lv2plug.in/ns/ext/atom/forge.h"
+
+#include "ingen/shared/URIMap.hpp"
 #include "ingen/shared/URIs.hpp"
 
 #include "Broadcaster.hpp"
@@ -28,8 +31,9 @@ void
 Notification::post_process(Notification& note,
                            Engine&       engine)
 {
-	const Ingen::Shared::URIs& uris  = engine.world()->uris();
-	Ingen::Shared::Forge&      forge = engine.world()->forge();
+	const Ingen::Shared::URIs& uris = engine.world()->uris();
+	LV2_Atom_Forge             forge;
+	uint8_t                    buf[128];
 	switch (note.type) {
 	case PORT_VALUE:
 		engine.broadcaster()->set_property(note.port->path(),
@@ -42,29 +46,36 @@ Notification::post_process(Notification& note,
 		                                   note.value);
 		break;
 	case PORT_BINDING: {
-		Raul::Atom::DictValue dict;
+		lv2_atom_forge_init(
+			&forge, &engine.world()->uri_map().urid_map_feature()->urid_map);
+		lv2_atom_forge_set_buffer(&forge, buf, sizeof(buf));
+		LV2_Atom_Forge_Frame frame;
 		switch (note.binding_type) {
 		case ControlBindings::MIDI_CC:
-			dict[uris.rdf_type]              = uris.midi_Controller;
-			dict[uris.midi_controllerNumber] = note.value;
+			lv2_atom_forge_blank(&forge, &frame, 0, uris.midi_Controller);
+			lv2_atom_forge_property_head(&forge, uris.midi_controllerNumber, 0);
+			lv2_atom_forge_int(&forge, note.value.get_int32());
 			break;
 		case ControlBindings::MIDI_BENDER:
-			dict[uris.rdf_type] = uris.midi_Bender;
+			lv2_atom_forge_blank(&forge, &frame, 0, uris.midi_Bender);
 			break;
 		case ControlBindings::MIDI_CHANNEL_PRESSURE:
-			dict[uris.rdf_type] = uris.midi_ChannelPressure;
+			lv2_atom_forge_blank(&forge, &frame, 0, uris.midi_ChannelPressure);
 			break;
 		case ControlBindings::MIDI_NOTE:
-			dict[uris.rdf_type]        = uris.midi_NoteOn;
-			dict[uris.midi_noteNumber] = note.value;
+			lv2_atom_forge_blank(&forge, &frame, 0, uris.midi_NoteOn);
+			lv2_atom_forge_property_head(&forge, uris.midi_noteNumber, 0);
+			lv2_atom_forge_int(&forge, note.value.get_int32());
 			break;
 		case ControlBindings::MIDI_RPN: // TODO
 		case ControlBindings::MIDI_NRPN: // TODO
 		case ControlBindings::NULL_CONTROL:
 			break;
 		}
+		LV2_Atom* atom = (LV2_Atom*)buf;
 		// FIXME: not thread-safe
-		const Raul::Atom dict_atom = forge.alloc(dict);
+		const Raul::Atom dict_atom = engine.world()->forge().alloc(
+			atom->size, atom->type, LV2_ATOM_BODY(atom));
 		note.port->set_property(uris.ingen_controlBinding, dict_atom);
 		engine.broadcaster()->set_property(note.port->path(),
 		                                   uris.ingen_controlBinding,
diff --git a/src/server/events/Delta.cpp b/src/server/events/Delta.cpp
index 5f6af4a4..891bebdc 100644
--- a/src/server/events/Delta.cpp
+++ b/src/server/events/Delta.cpp
@@ -190,7 +190,7 @@ Delta::pre_process()
 					if (port->is_a(PortType::CONTROL) || port->is_a(PortType::CV)) {
 						if (value == uris.wildcard) {
 							_engine.control_bindings()->learn(port);
-						} else if (value.type() == uris.forge.Dict) {
+						} else if (value.type() == uris.atom_Blank) {
 							op = CONTROL_BINDING;
 						} else {
 							_status = BAD_VALUE_TYPE;
diff --git a/src/shared/Forge.cpp b/src/shared/Forge.cpp
index e5a9dd9b..b667cf1c 100644
--- a/src/shared/Forge.cpp
+++ b/src/shared/Forge.cpp
@@ -32,7 +32,6 @@ Forge::Forge(Shared::URIMap& map)
 	URI    = map.map_uri(LV2_ATOM__URI);
 	URID   = map.map_uri(LV2_ATOM__URID);
 	String = map.map_uri(LV2_ATOM__String);
-	Dict   = map.map_uri(LV2_ATOM__Object);
 }
 
 std::string