Work on FFMpegInvoker

21 files changed, 592 insertions, 567 deletions

diff --git a/src/uscxml/plugins/datamodel/ecmascript/JavaScriptCore/JSCDataModel.cpp b/src/uscxml/plugins/datamodel/ecmascript/JavaScriptCore/JSCDataModel.cpp
index 142f3ec..b2f66b4 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/JavaScriptCore/JSCDataModel.cpp
+++ b/src/uscxml/plugins/datamodel/ecmascript/JavaScriptCore/JSCDataModel.cpp
@@ -223,14 +223,14 @@ void JSCDataModel::setEvent(const Event& event) {
 		if (!eventCopy.params.empty()) {
 			Event::params_t::iterator paramIter = eventCopy.params.begin();
 			while(paramIter != eventCopy.params.end()) {
-				eventCopy.data.compound[paramIter->first] = Data(paramIter->second, Data::VERBATIM);
+				eventCopy.data.compound[paramIter->first] = paramIter->second;
 				paramIter++;
 			}
 		}
 		if (!eventCopy.namelist.empty()) {
 			Event::namelist_t::iterator nameListIter = eventCopy.namelist.begin();
 			while(nameListIter != eventCopy.namelist.end()) {
-				eventCopy.data.compound[nameListIter->first] = Data(nameListIter->second, Data::VERBATIM);
+				eventCopy.data.compound[nameListIter->first] = nameListIter->second;
 				nameListIter++;
 			}
 		}
diff --git a/src/uscxml/plugins/datamodel/ecmascript/v8/V8DataModel.cpp b/src/uscxml/plugins/datamodel/ecmascript/v8/V8DataModel.cpp
index 77efe78..0e72c67 100644
--- a/src/uscxml/plugins/datamodel/ecmascript/v8/V8DataModel.cpp
+++ b/src/uscxml/plugins/datamodel/ecmascript/v8/V8DataModel.cpp
@@ -207,18 +207,19 @@ void V8DataModel::setEvent(const Event& event) {
 		if (!eventCopy.params.empty()) {
 			Event::params_t::iterator paramIter = eventCopy.params.begin();
 			while(paramIter != eventCopy.params.end()) {
-				eventCopy.data.compound[paramIter->first] = Data(paramIter->second, Data::VERBATIM);
+				eventCopy.data.compound[paramIter->first] = paramIter->second;
 				paramIter++;
 			}
 		}
 		if (!eventCopy.namelist.empty()) {
 			Event::namelist_t::iterator nameListIter = eventCopy.namelist.begin();
 			while(nameListIter != eventCopy.namelist.end()) {
-				eventCopy.data.compound[nameListIter->first] = Data(nameListIter->second, Data::VERBATIM);
+				eventCopy.data.compound[nameListIter->first] = nameListIter->second;
 				nameListIter++;
 			}
 		}
 		if (eventCopy.data) {
+//			std::cout << Data::toJSON(eventCopy.data);
 			eventObj->Set(v8::String::New("data"), getDataAsValue(eventCopy.data)); // set data part of _event
 		} else {
 			// test 343 / test 488
@@ -340,6 +341,7 @@ v8::Handle<v8::Value> V8DataModel::getDataAsValue(const Data& data) {
 		v8::Handle<v8::Object> value = v8::Object::New();
 		std::map<std::string, Data>::const_iterator compoundIter = data.compound.begin();
 		while(compoundIter != data.compound.end()) {
+//			std::cout << compoundIter->first.c_str() << std::endl;
 			value->Set(v8::String::New(compoundIter->first.c_str()), getDataAsValue(compoundIter->second));
 			compoundIter++;
 		}
diff --git a/src/uscxml/plugins/datamodel/prolog/swi/SWIDataModel.cpp b/src/uscxml/plugins/datamodel/prolog/swi/SWIDataModel.cpp
index 07cba96..aec044e 100644
--- a/src/uscxml/plugins/datamodel/prolog/swi/SWIDataModel.cpp
+++ b/src/uscxml/plugins/datamodel/prolog/swi/SWIDataModel.cpp
@@ -230,6 +230,8 @@ void SWIDataModel::setEvent(const Event& event) {
 			PlCall(dataInitStr.str().c_str());
 		} else if (event.content.size() > 0) {
 			PlCall("assert", PlCompound("event", PlCompound("data", PlString(Interpreter::spaceNormalize(event.content).c_str()))));
+		} else if (event.data) {
+      LOG(ERROR) << "No support for structured data from events in prolog datamodel yet";
 		}
 
 		// event.params
diff --git a/src/uscxml/plugins/datamodel/xpath/XPathDataModel.cpp b/src/uscxml/plugins/datamodel/xpath/XPathDataModel.cpp
index cb40890..f863bb7 100644
--- a/src/uscxml/plugins/datamodel/xpath/XPathDataModel.cpp
+++ b/src/uscxml/plugins/datamodel/xpath/XPathDataModel.cpp
@@ -139,10 +139,11 @@ void XPathDataModel::setEvent(const Event& event) {
 	}
 
 	if (event.params.size() > 0) {
-		std::multimap<std::string, std::string>::const_iterator paramIter = event.params.begin();
+		std::multimap<std::string, Data>::const_iterator paramIter = event.params.begin();
 		while(paramIter != event.params.end()) {
 			Element<std::string> eventParamElem = _doc.createElement("data");
-			Text<std::string> eventParamText = _doc.createTextNode(paramIter->second);
+			// this is simplified - Data might be more elaborate than a simple string atom
+			Text<std::string> eventParamText = _doc.createTextNode(paramIter->second.atom);
 
 			eventParamElem.setAttribute("id", paramIter->first);
 			eventParamElem.appendChild(eventParamText);
@@ -151,10 +152,11 @@ void XPathDataModel::setEvent(const Event& event) {
 		}
 	}
 	if (event.namelist.size() > 0) {
-		std::map<std::string, std::string>::const_iterator namelistIter = event.namelist.begin();
+		std::map<std::string, Data>::const_iterator namelistIter = event.namelist.begin();
 		while(namelistIter != event.namelist.end()) {
 			Element<std::string> eventNamelistElem = _doc.createElement("data");
-			Text<std::string> eventNamelistText = _doc.createTextNode(namelistIter->second);
+			// this is simplified - Data might be more elaborate than a simple string atom
+			Text<std::string> eventNamelistText = _doc.createTextNode(namelistIter->second.atom);
 
 			eventNamelistElem.setAttribute("id", namelistIter->first);
 			eventNamelistElem.appendChild(eventNamelistText);
diff --git a/src/uscxml/plugins/element/file/FileElement.cpp b/src/uscxml/plugins/element/file/FileElement.cpp
index e51fa70..2b48aba 100644
--- a/src/uscxml/plugins/element/file/FileElement.cpp
+++ b/src/uscxml/plugins/element/file/FileElement.cpp
@@ -34,7 +34,7 @@ void FileElement::enterElement(const Arabica::DOM::Node<std::string>& node) {
 	}
 	_givenUrl = (HAS_ATTR(node, "url") ? ATTR(node, "url") : _interpreter->getDataModel().evalAsString(ATTR(node, "urlexpr")));
 
-  std::string sandBoxStr = (HAS_ATTR(node, "sandboxed") ? ATTR(node, "sandboxed") : "on");
+  std::string sandBoxStr = (HAS_ATTR(node, "sandbox") ? ATTR(node, "sandbox") : "on");
   if (boost::iequals(sandBoxStr, "off") || boost::iequals(sandBoxStr, "false") || boost::iequals(sandBoxStr, "no")) {
     _sandBoxed = false;
   }
diff --git a/src/uscxml/plugins/element/respond/RespondElement.cpp b/src/uscxml/plugins/element/respond/RespondElement.cpp
index 3c47b83..ae81fed 100644
--- a/src/uscxml/plugins/element/respond/RespondElement.cpp
+++ b/src/uscxml/plugins/element/respond/RespondElement.cpp
@@ -63,8 +63,14 @@ void RespondElement::enterElement(const Arabica::DOM::Node<std::string>& node) {
 		if (HAS_ATTR(contents[0], "expr")) { // -- content is evaluated string from datamodel ------
 			if (_interpreter->getDataModel()) {
 				try {
-					std::string contentValue = _interpreter->getDataModel().evalAsString(ATTR(contents[0], "expr"));
-					httpReply.content = contentValue;
+					Data contentData = _interpreter->getDataModel().getStringAsData(ATTR(contents[0], "expr"));
+					if (contentData.atom.length() > 0) {
+						httpReply.content = contentData.atom;
+					} else if (contentData.binary) {
+						httpReply.content = std::string(contentData.binary->_data, contentData.binary->_size);
+					} else {
+						httpReply.content = Data::toJSON(contentData);
+					}
 				} catch (Event e) {
 					LOG(ERROR) << "Syntax error with expr in content child of Respond element:" << std::endl << e << std::endl;
 					return;
@@ -132,20 +138,20 @@ void RespondElement::enterElement(const Arabica::DOM::Node<std::string>& node) {
 		std::string value;
 		if (HAS_ATTR(headers[i], "value")) {
 			value = ATTR(headers[i], "value");
-		} else if(HAS_ATTR(headers[i], "expr")) {
+		} else if(HAS_ATTR(headers[i], "valueexpr")) {
 			if (_interpreter->getDataModel()) {
 				try {
-					value = _interpreter->getDataModel().evalAsString(ATTR(headers[i], "expr"));
+					value = _interpreter->getDataModel().evalAsString(ATTR(headers[i], "valueexpr"));
 				} catch (Event e) {
-					LOG(ERROR) << "Syntax error with expr in header child of Respond element:" << std::endl << e << std::endl;
+					LOG(ERROR) << "Syntax error with valueexpr in header child of Respond element:" << std::endl << e << std::endl;
 					return;
 				}
 			} else {
-				LOG(ERROR) << "header element has expr attribute but no datamodel is specified.";
+				LOG(ERROR) << "header element has valueexpr attribute but no datamodel is specified.";
 				return;
 			}
 		} else {
-			LOG(ERROR) << "header element has no value or expr attribute.";
+			LOG(ERROR) << "header element has no value or valueexpr attribute.";
 			return;
 		}
 
diff --git a/src/uscxml/plugins/invoker/audio/OpenALInvoker.cpp b/src/uscxml/plugins/invoker/audio/OpenALInvoker.cpp
index be6ffc7..73f44ea 100644
--- a/src/uscxml/plugins/invoker/audio/OpenALInvoker.cpp
+++ b/src/uscxml/plugins/invoker/audio/OpenALInvoker.cpp
@@ -72,14 +72,14 @@ void OpenALInvoker::send(const SendRequest& req) {
 			LOG(ERROR) << "Sent event play with no src URL";
 		}
 
-		URL srcURL = req.params.find("src")->second;
+		URL srcURL = req.params.find("src")->second.atom;
 		if (!srcURL.toAbsolute(_interpreter->getBaseURI())) {
 			LOG(ERROR) << "src URL " << req.params.find("src")->second << " is relative with no base URI set for interpreter";
 			return;
 		}
 
 		_sources[req.sendid] = new OpenALSource();
-		_sources[req.sendid]->loop = req.params.find("loop") != req.params.end() && boost::iequals(req.params.find("loop")->second, "true");
+		_sources[req.sendid]->loop = req.params.find("loop") != req.params.end() && boost::iequals(req.params.find("loop")->second.atom, "true");
 		_sources[req.sendid]->file = srcURL;
 #ifdef LIBSNDFILE_FOUND
 		_sources[req.sendid]->transform	= new LibSoundFile(srcURL.asLocalFile(".audio"));
@@ -127,7 +127,7 @@ void OpenALInvoker::send(const SendRequest& req) {
 			LOG(WARNING) << "Cannot move source with no source given in parameters";
 			return;
 		}
-		sourceId = req.params.find("source")->second;
+		sourceId = req.params.find("source")->second.atom;
 
 		if (_sources.find(sourceId) == _sources.end()) {
 			LOG(WARNING) << "Given source '" << sourceId << "' not active or not existing";
@@ -261,14 +261,14 @@ void OpenALInvoker::invoke(const InvokeRequest& req) {
 		throw std::string("__FILE__ __LINE__ openal error opening device");
 	}
 
-	std::multimap<std::string, std::string>::const_iterator paramIter = req.params.begin();
+	std::multimap<std::string, Data>::const_iterator paramIter = req.params.begin();
 	while(paramIter != req.params.end()) {
 		if (boost::iequals(paramIter->first, "maxX"))
-			_maxPos[0] = strTo<float>(paramIter->second);
+			_maxPos[0] = strTo<float>(paramIter->second.atom);
 		if (boost::iequals(paramIter->first, "maxY"))
-			_maxPos[1] = strTo<float>(paramIter->second);
+			_maxPos[1] = strTo<float>(paramIter->second.atom);
 		if (boost::iequals(paramIter->first, "maxZ"))
-			_maxPos[2] = strTo<float>(paramIter->second);
+			_maxPos[2] = strTo<float>(paramIter->second.atom);
 		paramIter++;
 	}
 
@@ -310,7 +310,7 @@ void OpenALInvoker::notifyOfLoop(OpenALSource* src) {
 	returnEvent(ev);
 }
 
-void OpenALInvoker::getPosFromParams(const std::multimap<std::string, std::string>& params, float* position) {
+void OpenALInvoker::getPosFromParams(const std::multimap<std::string, Data>& params, float* position) {
 	// vector explicitly given
 	try {
 		if (params.find("x") != params.end())
diff --git a/src/uscxml/plugins/invoker/audio/OpenALInvoker.h b/src/uscxml/plugins/invoker/audio/OpenALInvoker.h
index 9b71d95..81ced9b 100644
--- a/src/uscxml/plugins/invoker/audio/OpenALInvoker.h
+++ b/src/uscxml/plugins/invoker/audio/OpenALInvoker.h
@@ -78,7 +78,7 @@ protected:
 	void notifyOfLoop(OpenALSource*);
 
 	float posToRadian(const std::string& pos);
-	void getPosFromParams(const std::multimap<std::string, std::string>& params, float* position);
+	void getPosFromParams(const std::multimap<std::string, Data>& params, float* position);
 
 };
 
diff --git a/src/uscxml/plugins/invoker/ffmpeg/FFMPEGInvoker.cpp b/src/uscxml/plugins/invoker/ffmpeg/FFMPEGInvoker.cpp
index ccf65ce..e637f8b 100644
--- a/src/uscxml/plugins/invoker/ffmpeg/FFMPEGInvoker.cpp
+++ b/src/uscxml/plugins/invoker/ffmpeg/FFMPEGInvoker.cpp
@@ -1,15 +1,16 @@
 #include "FFMPEGInvoker.h"
 #include <glog/logging.h>
 
+#include <libavutil/imgutils.h>
+#include <libavcodec/avcodec.h>
+#include <fstream>
 
 #ifdef BUILD_AS_PLUGINS
 #include <Pluma/Connector.hpp>
 #endif
 
-#define STREAM_DURATION   200.0
 #define STREAM_FRAME_RATE 25 /* 25 images/s */
-#define STREAM_NB_FRAMES  ((int)(STREAM_DURATION * STREAM_FRAME_RATE))
-#define STREAM_PIX_FMT    AV_PIX_FMT_YUV420P /* default pix_fmt */
+#define BMP_FORMAT        PIX_FMT_BGR24
 
 namespace uscxml {
 
@@ -29,190 +30,363 @@ FFMPEGInvoker::~FFMPEGInvoker() {
 
 boost::shared_ptr<InvokerImpl> FFMPEGInvoker::create(InterpreterImpl* interpreter) {
 	boost::shared_ptr<FFMPEGInvoker> invoker = boost::shared_ptr<FFMPEGInvoker>(new FFMPEGInvoker());
-	invoker->_interpreter = interpreter;
+	// Register all formats and codecs - this ought to be done just once
+	av_register_all();
 	return invoker;
 }
 
 Data FFMPEGInvoker::getDataModelVariables() {
 	Data data;
+
+	AVCodec* codec = NULL;
+	while((codec = av_codec_next(codec))) {
+		AVCodec* codecInst = avcodec_find_encoder(codec->id);
+		if (!codecInst)
+			continue;
+		
+		switch (codec->type) {
+			case AVMEDIA_TYPE_VIDEO: {
+				Data codecData;
+				codecData.compound["name"] = Data(codec->name, Data::VERBATIM);
+				codecData.compound["longName"] = Data(codec->long_name, Data::VERBATIM);
+				data.compound["video"].compound[codec->name] = codecData;
+				break;
+			}
+			case AVMEDIA_TYPE_AUDIO: {
+				Data codecData;
+				codecData.compound["name"] = Data(codec->name, Data::VERBATIM);
+				codecData.compound["longName"] = Data(codec->long_name, Data::VERBATIM);
+				data.compound["audio"].compound[codec->name] = codecData;
+				break;
+			}
+			default:
+				break;
+		}
+	}
+	
 	return data;
 }
 
+void FFMPEGInvoker::invoke(const InvokeRequest& req) {
+	int nrThreads = 1;
+	Event::getParam(req.params, "threads", nrThreads);
+	
+	_isRunning = true;
+	for (int i = 0; i < nrThreads; i++) {
+		_threads.insert(new tthread::thread(FFMPEGInvoker::run, this));
+	}
+}
+	
 void FFMPEGInvoker::send(const SendRequest& req) {
-	if (boost::iequals(req.name, "add")) {
+	SendRequest reqCopy = req;
+	
+	if (boost::iequals(req.name, "render.start")) {
+		// create a new encoding context
+		int ret;
+		EncodingContext* ctx = new EncodingContext();
+		tthread::lock_guard<tthread::recursive_mutex> lock(ctx->mutex);
+
+		std::string context;
+		Event::getParam(req.params, "context", context);
+
+		ctx->extension = "mpeg";
+		Event::getParam(req.params, "format", ctx->extension);
+
+		Event::getParam(req.params, "width", ctx->width);
+		Event::getParam(req.params, "height", ctx->height);
+
+		if (!ctx->width || !ctx->height)
+			return;
+		
+		ctx->filename = URL::getTmpFilename();
+				
+    /* allocate the output media context */
+    avformat_alloc_output_context2(&ctx->formatCtx, NULL, ctx->extension.c_str(), ctx->filename.c_str());
+    if (!ctx->formatCtx) {
+			printf("Could not deduce output format from file extension: using MPEG.\n");
+			avformat_alloc_output_context2(&ctx->formatCtx, NULL, "mpeg", ctx->filename.c_str());
+    }
+    if (!ctx->formatCtx) {
+			return;
+    }
+    ctx->format = ctx->formatCtx->oformat;
+		
+    /* Add the audio and video streams using the default format codecs
+     * and initialize the codecs. */
+    ctx->videoStream = NULL;
+		
+    if (ctx->format->video_codec != AV_CODEC_ID_NONE) {
+			ctx->videoStream = addStream(ctx, ctx->formatCtx, &ctx->videoCodec, ctx->format->video_codec);
+    }
+		
+    /* Now that all the parameters are set, we can open the audio and
+     * video codecs and allocate the necessary encode buffers. */
+    if (ctx->videoStream)
+			openVideo(ctx, ctx->formatCtx, ctx->videoCodec, ctx->videoStream);
+		
+    /* open the output file, if needed */
+    if (!(ctx->format->flags & AVFMT_NOFILE)) {
+			ret = avio_open(&ctx->formatCtx->pb, ctx->filename.c_str(), AVIO_FLAG_WRITE);
+			if (ret < 0) {
+        // fprintf(stderr, "Could not open '%s': %s\n", ctx->filename.c_str(),
+        //        av_err2str(ret));
+				return;
+			}
+    }
+		
+    /* Write the stream header, if any. */
+    ret = avformat_write_header(ctx->formatCtx, NULL);
+    if (ret < 0) {
+      // fprintf(stderr, "Error occurred when opening output file: %s\n",
+      //        av_err2str(ret));
+			return;
+    }
+		
+    if (ctx->frame)
+			ctx->frame->pts = 0;
+
+		_encoders[context] = ctx;
+	} else if(boost::iequals(req.name, "render.frame")) {
+		_workQueue.push(req);
+	} else if(boost::iequals(req.name, "render.end")) {
+		_workQueue.push(req);
+	}
+}
 
-	} else if(boost::iequals(req.name, "render")) {
+void FFMPEGInvoker::cancel(const std::string sendId) {
+}
 
+void FFMPEGInvoker::run(void* instance) {
+	FFMPEGInvoker* INSTANCE = (FFMPEGInvoker*)instance;
+	while(true) {
+		SendRequest req = INSTANCE->_workQueue.pop();
+		if (INSTANCE->_isRunning) {
+			INSTANCE->process(req);
+		} else {
+			return;
+		}
 	}
 }
 
-void FFMPEGInvoker::cancel(const std::string sendId) {
+void FFMPEGInvoker::finish(EncodingContext* ctx, const SendRequest& req) {
+	av_write_trailer(ctx->formatCtx);
+	
+	/* Close each codec. */
+	if (ctx->videoStream)
+		closeVideo(ctx, ctx->formatCtx, ctx->videoStream);
+	
+	if (!(ctx->formatCtx->oformat->flags & AVFMT_NOFILE))
+	/* Close the output file. */
+		avio_close(ctx->formatCtx->pb);
+	
+	/* free the stream */
+	avformat_free_context(ctx->formatCtx);
+	
+	// read file
+	std::ifstream movieFile(ctx->filename.c_str());
+	movieFile.seekg(0, std::ios::end);
+	size_t length = movieFile.tellg();
+	movieFile.seekg(0, std::ios::beg);
+	
+	char* movieBuffer = (char*)malloc(length);
+	movieFile.read(movieBuffer, length);
+	
+	// move to desktop for checking
+//	int err = rename(ctx->filename.c_str(), "/Users/sradomski/Desktop/foo.mpg");
+//	if (err) {
+//		printf("%s", strerror(errno));
+//	}
+	
+	std::string context;
+	Event::getParam(req.params, "context", context);
+
+	Event event;
+	event.name = "render.done";
+	event.data.compound["context"] = context;
+	event.data.compound["movie"] = Data(movieBuffer, length, true);
+	event.data.compound["mimetype"] = Data("video/mpeg", Data::VERBATIM);
+	event.data.compound["filename"] = Data(std::string("movie.") + ctx->extension, Data::VERBATIM);
+	
+	returnEvent(event);
 }
 
-static AVFrame *frame;
-static AVPicture src_picture, dst_picture;
-static int frame_count;
-static int sws_flags = SWS_BICUBIC;
+void FFMPEGInvoker::process(const SendRequest& req) {
 
-static AVStream *add_stream(AVFormatContext *oc, AVCodec **codec,
-                            enum AVCodecID codec_id) {
+	std::string context;
+	Event::getParam(req.params, "context", context);
+	if (_encoders.find(context) == _encoders.end()) {
+		return;
+	}
+	
+	EncodingContext* ctx = _encoders[context];
+	tthread::lock_guard<tthread::recursive_mutex> lock(ctx->mutex);
+
+	// finish encoding and return
+	if(boost::iequals(req.name, "render.end")) {
+		finish(ctx, req);
+		delete _encoders[context];
+		_encoders.erase(context);
+	}
+	
+	Data image;
+	Event::getParam(req.params, "frame", image);
+	if (!image) {
+		return;
+	}
+
+	std::string format = "bmp";
+	Event::getParam(req.params, "format", format);
+	
+	writeVideoFrame(ctx, ctx->formatCtx, ctx->videoStream, image.binary);
+	ctx->frame->pts += av_rescale_q(1, ctx->videoStream->codec->time_base, ctx->videoStream->time_base);
+
+}
+	
+AVStream* FFMPEGInvoker::addStream(EncodingContext* ctx, AVFormatContext *oc, AVCodec **codec,
+																						 enum AVCodecID codec_id) {
 	AVCodecContext *c;
 	AVStream *st;
-
+	
 	/* find the encoder */
 	*codec = avcodec_find_encoder(codec_id);
 	if (!(*codec)) {
 		fprintf(stderr, "Could not find encoder for '%s'\n",
-		        avcodec_get_name(codec_id));
-		exit(1);
+						avcodec_get_name(codec_id));
+		return NULL;
 	}
-
+	
 	st = avformat_new_stream(oc, *codec);
+	ctx->videoPixFmt = (*codec)->pix_fmts[0];
 	if (!st) {
 		fprintf(stderr, "Could not allocate stream\n");
-		exit(1);
+		return NULL;
 	}
 	st->id = oc->nb_streams-1;
 	c = st->codec;
-
+	
 	switch ((*codec)->type) {
-	case AVMEDIA_TYPE_AUDIO:
-		c->sample_fmt  = AV_SAMPLE_FMT_FLTP;
-		c->bit_rate    = 64000;
-		c->sample_rate = 44100;
-		c->channels    = 2;
-		break;
-
-	case AVMEDIA_TYPE_VIDEO:
-		c->codec_id = codec_id;
-
-		c->bit_rate = 400000;
-		/* Resolution must be a multiple of two. */
-		c->width    = 352;
-		c->height   = 288;
-		/* timebase: This is the fundamental unit of time (in seconds) in terms
-		 * of which frame timestamps are represented. For fixed-fps content,
-		 * timebase should be 1/framerate and timestamp increments should be
-		 * identical to 1. */
-		c->time_base.den = STREAM_FRAME_RATE;
-		c->time_base.num = 1;
-		c->gop_size      = 12; /* emit one intra frame every twelve frames at most */
-		c->pix_fmt       = STREAM_PIX_FMT;
-		if (c->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
-			/* just for testing, we also add B frames */
-			c->max_b_frames = 2;
-		}
-		if (c->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
-			/* Needed to avoid using macroblocks in which some coeffs overflow.
-			 * This does not happen with normal video, it just happens here as
-			 * the motion of the chroma plane does not match the luma plane. */
-			c->mb_decision = 2;
-		}
-		break;
-
-	default:
-		break;
+    case AVMEDIA_TYPE_AUDIO:
+			c->sample_fmt  = AV_SAMPLE_FMT_FLTP;
+			c->bit_rate    = 64000;
+			c->sample_rate = 44100;
+			c->channels    = 2;
+			break;
+			
+    case AVMEDIA_TYPE_VIDEO:
+			c->codec_id = codec_id;
+						
+			c->bit_rate = 800000;
+			/* Resolution must be a multiple of two. */
+			c->width    = ctx->width;
+			c->height   = ctx->height;
+			/* timebase: This is the fundamental unit of time (in seconds) in terms
+			 * of which frame timestamps are represented. For fixed-fps content,
+			 * timebase should be 1/framerate and timestamp increments should be
+			 * identical to 1. */
+			c->time_base.den = STREAM_FRAME_RATE;
+			c->time_base.num = 1;
+			c->gop_size      = 12; /* emit one intra frame every twelve frames at most */
+			c->pix_fmt       = ctx->videoPixFmt;
+			if (c->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
+				/* just for testing, we also add B frames */
+				c->max_b_frames = 2;
+			}
+			if (c->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
+				/* Needed to avoid using macroblocks in which some coeffs overflow.
+				 * This does not happen with normal video, it just happens here as
+				 * the motion of the chroma plane does not match the luma plane. */
+				c->mb_decision = 2;
+			}
+			break;
+			
+    default:
+			break;
 	}
-
+	
 	/* Some formats want stream headers to be separate. */
 	if (oc->oformat->flags & AVFMT_GLOBALHEADER)
 		c->flags |= CODEC_FLAG_GLOBAL_HEADER;
-
+	
 	return st;
 }
 
-static void open_video(AVFormatContext *oc, AVCodec *codec, AVStream *st) {
+void FFMPEGInvoker::openVideo(EncodingContext* ctx, AVFormatContext *oc, AVCodec *codec, AVStream *st) {
 	int ret;
 	AVCodecContext *c = st->codec;
 
 	/* open the codec */
 	ret = avcodec_open2(c, codec, NULL);
 	if (ret < 0) {
-		fprintf(stderr, "Could not open video codec: %s\n", av_err2str(ret));
-		exit(1);
+    // fprintf(stderr, "Could not open video codec: %s\n", av_err2str(ret));
+		return;
 	}
 
 	/* allocate and init a re-usable frame */
-	frame = avcodec_alloc_frame();
-	if (!frame) {
+	ctx->frame = avcodec_alloc_frame();
+	if (!ctx->frame) {
 		fprintf(stderr, "Could not allocate video frame\n");
-		exit(1);
+		return;
 	}
 
 	/* Allocate the encoded raw picture. */
-	ret = avpicture_alloc(&dst_picture, c->pix_fmt, c->width, c->height);
+	ret = avpicture_alloc(&ctx->dst_picture, c->pix_fmt, c->width, c->height);
 	if (ret < 0) {
-		fprintf(stderr, "Could not allocate picture: %s\n", av_err2str(ret));
-		exit(1);
+//		fprintf(stderr, "Could not allocate picture: %s\n", av_err2str(ret));
+		return;
 	}
 
 	/* If the output format is not YUV420P, then a temporary YUV420P
 	 * picture is needed too. It is then converted to the required
 	 * output format. */
-	if (c->pix_fmt != AV_PIX_FMT_YUV420P) {
-		ret = avpicture_alloc(&src_picture, AV_PIX_FMT_YUV420P, c->width, c->height);
+	if (c->pix_fmt != BMP_FORMAT) {
+		ret = avpicture_alloc(&ctx->src_picture, BMP_FORMAT, c->width, c->height);
 		if (ret < 0) {
-			fprintf(stderr, "Could not allocate temporary picture: %s\n",
-			        av_err2str(ret));
-			exit(1);
+      // fprintf(stderr, "Could not allocate temporary picture: %s\n",
+      //         av_err2str(ret));
+			return;
 		}
 	}
 
 	/* copy data and linesize picture pointers to frame */
-	*((AVPicture *)frame) = dst_picture;
+	*((AVPicture *)ctx->frame) = ctx->dst_picture;
 }
-
-/* Prepare a dummy image. */
-static void fill_yuv_image(AVPicture *pict, int frame_index,
-                           int width, int height) {
-	int x, y, i;
-
-	i = frame_index;
-
-	/* Y */
-	for (y = 0; y < height; y++)
-		for (x = 0; x < width; x++)
-			pict->data[0][y * pict->linesize[0] + x] = x + y + i * 3;
-
-	/* Cb and Cr */
-	for (y = 0; y < height / 2; y++) {
-		for (x = 0; x < width / 2; x++) {
-			pict->data[1][y * pict->linesize[1] + x] = 128 + y + i * 2;
-			pict->data[2][y * pict->linesize[2] + x] = 64 + x + i * 5;
-		}
-	}
-}
-
-static void write_video_frame(AVFormatContext *oc, AVStream *st) {
+	
+void FFMPEGInvoker::writeVideoFrame(EncodingContext* ctx, AVFormatContext *oc, AVStream *st, boost::shared_ptr<Blob> image) {
 	int ret;
-	static struct SwsContext *sws_ctx;
 	AVCodecContext *c = st->codec;
 
-	if (frame_count >= STREAM_NB_FRAMES) {
-		/* No more frames to compress. The codec has a latency of a few
-		 * frames if using B-frames, so we get the last frames by
-		 * passing the same picture again. */
-	} else {
-		if (c->pix_fmt != AV_PIX_FMT_YUV420P) {
-			/* as we only generate a YUV420P picture, we must convert it
-			 * to the codec pixel format if needed */
-			if (!sws_ctx) {
-				sws_ctx = sws_getContext(c->width, c->height, AV_PIX_FMT_YUV420P,
-				                         c->width, c->height, c->pix_fmt,
-				                         sws_flags, NULL, NULL, NULL);
-				if (!sws_ctx) {
-					fprintf(stderr,
-					        "Could not initialize the conversion context\n");
-					exit(1);
-				}
+	if (c->pix_fmt != BMP_FORMAT) {
+		/* as we only generate a YUV420P picture, we must convert it
+		 * to the codec pixel format if needed */
+		if (!ctx->sws_ctx) {
+			ctx->sws_ctx = sws_getContext(c->width, c->height, BMP_FORMAT,
+															 c->width, c->height, c->pix_fmt,
+															 ctx->sws_flags, NULL, NULL, NULL);
+			if (!ctx->sws_ctx) {
+				fprintf(stderr,
+								"Could not initialize the conversion context\n");
+				return;
 			}
-			fill_yuv_image(&src_picture, frame_count, c->width, c->height);
-			sws_scale(sws_ctx,
-			          (const uint8_t * const *)src_picture.data, src_picture.linesize,
-			          0, c->height, dst_picture.data, dst_picture.linesize);
-		} else {
-			fill_yuv_image(&dst_picture, frame_count, c->width, c->height);
 		}
+
+		uint32_t headerOffset = 0;
+		headerOffset += image->_data[10] << 0;
+		headerOffset += image->_data[11] << 8;
+		headerOffset += image->_data[12] << 16;
+		headerOffset += image->_data[13] << 24;
+
+//		std::cout << headerOffset + (c->width * c->height) << " / " << image->_size << std::endl;
+		
+		ret = avpicture_fill(&ctx->src_picture, (uint8_t*)(image->_data + headerOffset), BMP_FORMAT, c->width, c->height);
+		if (ret < 0) {
+			fprintf(stderr,
+							"Could not fill image from given bitmap\n");
+		}
+		sws_scale(ctx->sws_ctx,
+							(const uint8_t * const *)ctx->src_picture.data, ctx->src_picture.linesize,
+							0, c->height, ctx->dst_picture.data, ctx->dst_picture.linesize);
+	} else {
+		avpicture_fill(&ctx->dst_picture, (uint8_t*)image->_data, c->pix_fmt, c->width, c->height);
 	}
 
 	if (oc->oformat->flags & AVFMT_RAWPICTURE) {
@@ -222,7 +396,7 @@ static void write_video_frame(AVFormatContext *oc, AVStream *st) {
 
 		pkt.flags        |= AV_PKT_FLAG_KEY;
 		pkt.stream_index  = st->index;
-		pkt.data          = dst_picture.data[0];
+		pkt.data          = ctx->dst_picture.data[0];
 		pkt.size          = sizeof(AVPicture);
 
 		ret = av_interleaved_write_frame(oc, &pkt);
@@ -232,10 +406,10 @@ static void write_video_frame(AVFormatContext *oc, AVStream *st) {
 		av_init_packet(&pkt);
 
 		/* encode the image */
-		ret = avcodec_encode_video2(c, &pkt, frame, &got_packet);
+		ret = avcodec_encode_video2(c, &pkt, ctx->frame, &got_packet);
 		if (ret < 0) {
-			fprintf(stderr, "Error encoding video frame: %s\n", av_err2str(ret));
-			exit(1);
+      // fprintf(stderr, "Error encoding video frame: %s\n", av_err2str(ret));
+			return;
 		}
 		/* If size is zero, it means the image was buffered. */
 
@@ -243,297 +417,25 @@ static void write_video_frame(AVFormatContext *oc, AVStream *st) {
 			pkt.stream_index = st->index;
 
 			/* Write the compressed frame to the media file. */
+//			ret = av_write_frame(oc, &pkt);
 			ret = av_interleaved_write_frame(oc, &pkt);
 		} else {
 			ret = 0;
 		}
 	}
 	if (ret != 0) {
-		fprintf(stderr, "Error while writing video frame: %s\n", av_err2str(ret));
-		exit(1);
-	}
-	frame_count++;
-}
-
-static void close_video(AVFormatContext *oc, AVStream *st) {
-	avcodec_close(st->codec);
-	av_free(src_picture.data[0]);
-	av_free(dst_picture.data[0]);
-	av_free(frame);
-}
-
-static float t, tincr, tincr2;
-
-static uint8_t **src_samples_data;
-static int       src_samples_linesize;
-static int       src_nb_samples;
-
-static int max_dst_nb_samples;
-uint8_t **dst_samples_data;
-int       dst_samples_linesize;
-int       dst_samples_size;
-
-struct SwrContext *swr_ctx = NULL;
-
-static void open_audio(AVFormatContext *oc, AVCodec *codec, AVStream *st) {
-	AVCodecContext *c;
-	int ret;
-
-	c = st->codec;
-
-	/* open it */
-	ret = avcodec_open2(c, codec, NULL);
-	if (ret < 0) {
-		fprintf(stderr, "Could not open audio codec: %s\n", av_err2str(ret));
-		exit(1);
-	}
-
-	/* init signal generator */
-	t     = 0;
-	tincr = 2 * M_PI * 110.0 / c->sample_rate;
-	/* increment frequency by 110 Hz per second */
-	tincr2 = 2 * M_PI * 110.0 / c->sample_rate / c->sample_rate;
-
-	src_nb_samples = c->codec->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE ?
-	                 10000 : c->frame_size;
-
-	ret = av_samples_alloc_array_and_samples(&src_samples_data, &src_samples_linesize, c->channels,
-	        src_nb_samples, c->sample_fmt, 0);
-	if (ret < 0) {
-		fprintf(stderr, "Could not allocate source samples\n");
-		exit(1);
-	}
-
-	/* create resampler context */
-	if (c->sample_fmt != AV_SAMPLE_FMT_S16) {
-		swr_ctx = swr_alloc();
-		if (!swr_ctx) {
-			fprintf(stderr, "Could not allocate resampler context\n");
-			exit(1);
-		}
-
-		/* set options */
-		av_opt_set_int       (swr_ctx, "in_channel_count",   c->channels,       0);
-		av_opt_set_int       (swr_ctx, "in_sample_rate",     c->sample_rate,    0);
-		av_opt_set_sample_fmt(swr_ctx, "in_sample_fmt",      AV_SAMPLE_FMT_S16, 0);
-		av_opt_set_int       (swr_ctx, "out_channel_count",  c->channels,       0);
-		av_opt_set_int       (swr_ctx, "out_sample_rate",    c->sample_rate,    0);
-		av_opt_set_sample_fmt(swr_ctx, "out_sample_fmt",     c->sample_fmt,     0);
-
-		/* initialize the resampling context */
-		if ((ret = swr_init(swr_ctx)) < 0) {
-			fprintf(stderr, "Failed to initialize the resampling context\n");
-			exit(1);
-		}
-	}
-
-	/* compute the number of converted samples: buffering is avoided
-	 * ensuring that the output buffer will contain at least all the
-	 * converted input samples */
-	max_dst_nb_samples = src_nb_samples;
-	ret = av_samples_alloc_array_and_samples(&dst_samples_data, &dst_samples_linesize, c->channels,
-	        max_dst_nb_samples, c->sample_fmt, 0);
-	if (ret < 0) {
-		fprintf(stderr, "Could not allocate destination samples\n");
-		exit(1);
-	}
-	dst_samples_size = av_samples_get_buffer_size(NULL, c->channels, max_dst_nb_samples,
-	                   c->sample_fmt, 0);
-}
-
-/* Prepare a 16 bit dummy audio frame of 'frame_size' samples and
- * 'nb_channels' channels. */
-static void get_audio_frame(int16_t *samples, int frame_size, int nb_channels) {
-	int j, i, v;
-	int16_t *q;
-
-	q = samples;
-	for (j = 0; j < frame_size; j++) {
-		v = (int)(sin(t) * 10000);
-		for (i = 0; i < nb_channels; i++)
-			*q++ = v;
-		t     += tincr;
-		tincr += tincr2;
-	}
-}
-
-static void write_audio_frame(AVFormatContext *oc, AVStream *st) {
-	AVCodecContext *c;
-	AVPacket pkt = { 0 }; // data and size must be 0;
-	AVFrame *frame = avcodec_alloc_frame();
-	int got_packet, ret, dst_nb_samples;
-
-	av_init_packet(&pkt);
-	c = st->codec;
-
-	get_audio_frame((int16_t *)src_samples_data[0], src_nb_samples, c->channels);
-
-	/* convert samples from native format to destination codec format, using the resampler */
-	if (swr_ctx) {
-		/* compute destination number of samples */
-		dst_nb_samples = av_rescale_rnd(swr_get_delay(swr_ctx, c->sample_rate) + src_nb_samples,
-		                                c->sample_rate, c->sample_rate, AV_ROUND_UP);
-		if (dst_nb_samples > max_dst_nb_samples) {
-			av_free(dst_samples_data[0]);
-			ret = av_samples_alloc(dst_samples_data, &dst_samples_linesize, c->channels,
-			                       dst_nb_samples, c->sample_fmt, 0);
-			if (ret < 0)
-				exit(1);
-			max_dst_nb_samples = dst_nb_samples;
-			dst_samples_size = av_samples_get_buffer_size(NULL, c->channels, dst_nb_samples,
-			                   c->sample_fmt, 0);
-		}
-
-		/* convert to destination format */
-		ret = swr_convert(swr_ctx,
-		                  dst_samples_data, dst_nb_samples,
-		                  (const uint8_t **)src_samples_data, src_nb_samples);
-		if (ret < 0) {
-			fprintf(stderr, "Error while converting\n");
-			exit(1);
-		}
-	} else {
-		dst_samples_data[0] = src_samples_data[0];
-		dst_nb_samples = src_nb_samples;
-	}
-
-	frame->nb_samples = dst_nb_samples;
-	avcodec_fill_audio_frame(frame, c->channels, c->sample_fmt,
-	                         dst_samples_data[0], dst_samples_size, 0);
-
-	ret = avcodec_encode_audio2(c, &pkt, frame, &got_packet);
-	if (ret < 0) {
-		fprintf(stderr, "Error encoding audio frame: %s\n", av_err2str(ret));
-		exit(1);
-	}
-
-	if (!got_packet)
+//		fprintf(stderr, "Error while writing video frame: %s\n", av_err2str(ret));
 		return;
-
-	pkt.stream_index = st->index;
-
-	/* Write the compressed frame to the media file. */
-	ret = av_interleaved_write_frame(oc, &pkt);
-	if (ret != 0) {
-		fprintf(stderr, "Error while writing audio frame: %s\n",
-		        av_err2str(ret));
-		exit(1);
 	}
-	avcodec_free_frame(&frame);
+	ctx->frame_count++;
 }
 
-static void close_audio(AVFormatContext *oc, AVStream *st) {
+void FFMPEGInvoker::closeVideo(EncodingContext* ctx, AVFormatContext *oc, AVStream *st) {
 	avcodec_close(st->codec);
-	av_free(src_samples_data[0]);
-	av_free(dst_samples_data[0]);
+//	av_free(ctx->src_picture.data[0]);
+	av_free(ctx->dst_picture.data[0]);
+	av_free(ctx->frame);
 }
 
-void FFMPEGInvoker::invoke(const InvokeRequest& req) {
-
-#if 0
-	const char *filename;
-	AVOutputFormat *fmt;
-	AVFormatContext *oc;
-	AVStream *audio_st, *video_st;
-	AVCodec *audio_codec, *video_codec;
-	double audio_time, video_time;
-	int ret;
-
-	filename = "foo.avi";
-	// Register all formats and codecs
-	av_register_all();
-
-	/* allocate the output media context */
-	avformat_alloc_output_context2(&oc, NULL, NULL, filename);
-	if (!oc) {
-		printf("Could not deduce output format from file extension: using MPEG.\n");
-		avformat_alloc_output_context2(&oc, NULL, "mpeg", filename);
-	}
-	if (!oc) {
-		return 1;
-	}
-	fmt = oc->oformat;
-
-	/* Add the audio and video streams using the default format codecs
-	 * and initialize the codecs. */
-	video_st = NULL;
-	audio_st = NULL;
-
-	if (fmt->video_codec != AV_CODEC_ID_NONE) {
-		video_st = add_stream(oc, &video_codec, fmt->video_codec);
-	}
-	if (fmt->audio_codec != AV_CODEC_ID_NONE) {
-		audio_st = add_stream(oc, &audio_codec, fmt->audio_codec);
-	}
-
-	/* Now that all the parameters are set, we can open the audio and
-	 * video codecs and allocate the necessary encode buffers. */
-	if (video_st)
-		open_video(oc, video_codec, video_st);
-	if (audio_st)
-		open_audio(oc, audio_codec, audio_st);
-
-	av_dump_format(oc, 0, filename, 1);
-
-	/* open the output file, if needed */
-	if (!(fmt->flags & AVFMT_NOFILE)) {
-		ret = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE);
-		if (ret < 0) {
-			fprintf(stderr, "Could not open '%s': %s\n", filename,
-			        av_err2str(ret));
-			return 1;
-		}
-	}
-
-	/* Write the stream header, if any. */
-	ret = avformat_write_header(oc, NULL);
-	if (ret < 0) {
-		fprintf(stderr, "Error occurred when opening output file: %s\n",
-		        av_err2str(ret));
-		return 1;
-	}
-
-	if (frame)
-		frame->pts = 0;
-	for (;;) {
-		/* Compute current audio and video time. */
-		audio_time = audio_st ? audio_st->pts.val * av_q2d(audio_st->time_base) : 0.0;
-		video_time = video_st ? video_st->pts.val * av_q2d(video_st->time_base) : 0.0;
-
-		if ((!audio_st || audio_time >= STREAM_DURATION) &&
-		        (!video_st || video_time >= STREAM_DURATION))
-			break;
-
-		/* write interleaved audio and video frames */
-		if (!video_st || (video_st && audio_st && audio_time < video_time)) {
-			write_audio_frame(oc, audio_st);
-		} else {
-			write_video_frame(oc, video_st);
-			frame->pts += av_rescale_q(1, video_st->codec->time_base, video_st->time_base);
-		}
-	}
-
-	/* Write the trailer, if any. The trailer must be written before you
-	 * close the CodecContexts open when you wrote the header; otherwise
-	 * av_write_trailer() may try to use memory that was freed on
-	 * av_codec_close(). */
-	av_write_trailer(oc);
-
-	/* Close each codec. */
-	if (video_st)
-		close_video(oc, video_st);
-	if (audio_st)
-		close_audio(oc, audio_st);
-
-	if (!(fmt->flags & AVFMT_NOFILE))
-		/* Close the output file. */
-		avio_close(oc->pb);
-
-	/* free the stream */
-	avformat_free_context(oc);
-
-	return 0;
-#endif
-}
 
 }
\ No newline at end of file
diff --git a/src/uscxml/plugins/invoker/ffmpeg/FFMPEGInvoker.h b/src/uscxml/plugins/invoker/ffmpeg/FFMPEGInvoker.h
index 0337f25..e95b32e 100644
--- a/src/uscxml/plugins/invoker/ffmpeg/FFMPEGInvoker.h
+++ b/src/uscxml/plugins/invoker/ffmpeg/FFMPEGInvoker.h
@@ -4,11 +4,9 @@
 #include <uscxml/Interpreter.h>
 
 extern "C" {
-#include <libavutil/opt.h>
-#include <libavutil/mathematics.h>
+#include <libavutil/avutil.h>
 #include <libavformat/avformat.h>
 #include <libswscale/swscale.h>
-#include <libswresample/swresample.h>
 }
 
 #ifdef BUILD_AS_PLUGINS
@@ -37,14 +35,53 @@ public:
 
 protected:
 	class EncodingContext {
+	public:
+		EncodingContext() :
+			format(NULL),
+			formatCtx(NULL),
+			audioStream(NULL), videoStream(NULL),
+			audioCodec(NULL), videoCodec(NULL),
+			audioTime(0), videoTime(0),
+			frame(NULL),
+			frame_count(0),
+			width(0),
+			height(0),
+			sws_flags(SWS_BICUBIC) {}
+
+		virtual ~EncodingContext() {
+			if (sws_ctx)
+				sws_freeContext(sws_ctx);
+		}
+		
+		tthread::recursive_mutex mutex;
+		PixelFormat videoPixFmt;
 		std::string filename;
 		AVOutputFormat* format;
 		AVFormatContext* formatCtx;
-		AVStream *audio_st, *video_st;
-		AVCodec *audio_codec, *video_codec;
-		double audio_time, video_time;
+		AVStream *audioStream, *videoStream;
+		AVCodec *audioCodec, *videoCodec, *imageCodec;
+		double audioTime, videoTime;
+		AVFrame *frame;
+		AVPicture src_picture, dst_picture;
+		int frame_count;
+		size_t width, height;
+		int sws_flags;
+		SwsContext *sws_ctx;
+		std::string extension;
 	};
 
+	AVStream* addStream(EncodingContext* ctx, AVFormatContext *oc, AVCodec **codec, enum AVCodecID codec_id);
+	void openVideo(EncodingContext* ctx, AVFormatContext *oc, AVCodec *codec, AVStream *st);
+	void writeVideoFrame(EncodingContext* ctx, AVFormatContext *oc, AVStream *st, boost::shared_ptr<Blob> image);
+	void closeVideo(EncodingContext* ctx, AVFormatContext *oc, AVStream *st);
+
+	static void run(void*);
+	void finish(EncodingContext* ctx, const SendRequest& req);
+	void process(const SendRequest& req);
+	
+	std::set<tthread::thread*> _threads;
+	uscxml::concurrency::BlockingQueue<SendRequest> _workQueue;
+	bool _isRunning;
 	std::map<std::string, EncodingContext*> _encoders;
 };
 
diff --git a/src/uscxml/plugins/invoker/filesystem/dirmon/DirMonInvoker.cpp b/src/uscxml/plugins/invoker/filesystem/dirmon/DirMonInvoker.cpp
index 0f6b776..1292e3a 100644
--- a/src/uscxml/plugins/invoker/filesystem/dirmon/DirMonInvoker.cpp
+++ b/src/uscxml/plugins/invoker/filesystem/dirmon/DirMonInvoker.cpp
@@ -65,20 +65,21 @@ void DirMonInvoker::invoke(const InvokeRequest& req) {
 		return;
 	}
 
-	if (boost::iequals(req.params.find("reportexisting")->second, "false"))
+	if (req.params.find("reportexisting") != req.params.end() &&
+					boost::iequals(req.params.find("reportexisting")->second.atom, "false"))
 		_reportExisting = false;
 	if (req.params.find("recurse") != req.params.end() &&
-	        boost::iequals(req.params.find("recurse")->second, "true"))
+	        boost::iequals(req.params.find("recurse")->second.atom, "true"))
 		_recurse = true;
 	if (req.params.find("reporthidden") != req.params.end() &&
-	        boost::iequals(req.params.find("reporthidden")->second, "true"))
+	        boost::iequals(req.params.find("reporthidden")->second.atom, "true"))
 		_reportHidden = true;
 
 	std::string suffixList;
 	if (req.params.find("suffix") != req.params.end()) {
-		suffixList = req.params.find("suffix")->second;
+		suffixList = req.params.find("suffix")->second.atom;
 	} else if (req.params.find("suffixes") != req.params.end()) {
-		suffixList = req.params.find("suffixes")->second;
+		suffixList = req.params.find("suffixes")->second.atom;
 	}
 
 	if (suffixList.size() > 0) {
@@ -92,9 +93,10 @@ void DirMonInvoker::invoke(const InvokeRequest& req) {
 		}
 	}
 
-	std::multimap<std::string, std::string>::const_iterator dirIter = req.params.find("dir");
+	std::multimap<std::string, Data>::const_iterator dirIter = req.params.find("dir");
 	while(dirIter != req.params.upper_bound("dir")) {
-		URL url(dirIter->second);
+		// this is simplified - Data might be more elaborate than a simple string atom
+		URL url(dirIter->second.atom);
 		if (!url.toAbsolute(_interpreter->getBaseURI()) || !boost::iequals(url.scheme(), "file")) {
 			LOG(ERROR) << "Given directory '" << dirIter->second << "' cannot be transformed to absolute path";
 		} else {
@@ -266,6 +268,8 @@ void DirectoryWatch::updateEntries(bool reportAsExisting) {
 	}
 
 	if ((unsigned)dirStat.st_mtime >= (unsigned)_lastChecked) {
+//		std::cout << "dirStat.st_mtime: " << dirStat.st_mtime << " / _lastChecked: " << _lastChecked << std::endl;
+		
 		// there are changes in the directory
 		std::set<std::string> currEntries;
 
diff --git a/src/uscxml/plugins/invoker/graphics/openscenegraph/OSGInvoker.cpp b/src/uscxml/plugins/invoker/graphics/openscenegraph/OSGInvoker.cpp
index 090f1b3..2b77baf 100644
--- a/src/uscxml/plugins/invoker/graphics/openscenegraph/OSGInvoker.cpp
+++ b/src/uscxml/plugins/invoker/graphics/openscenegraph/OSGInvoker.cpp
@@ -1,5 +1,6 @@
 #include "OSGInvoker.h"
 #include "uscxml/URL.h"
+#include "uscxml/UUID.h"
 #include <glog/logging.h>
 
 #ifdef BUILD_AS_PLUGINS
@@ -110,7 +111,7 @@ void OSGInvoker::processViewport(const Arabica::DOM::Node<std::string>& element)
 	_nodes[element] = group;
 	sceneView->setSceneData(group);
 
-	std::string name = (HAS_ATTR(element, "id") ? ATTR(element, "id") : Interpreter::getUUID());
+	std::string name = (HAS_ATTR(element, "id") ? ATTR(element, "id") : UUID::getUUID());
 
 	unsigned int actualX = 0;
 	unsigned int actualY = 0;
diff --git a/src/uscxml/plugins/invoker/graphics/openscenegraph/converter/OSGConverter.cpp b/src/uscxml/plugins/invoker/graphics/openscenegraph/converter/OSGConverter.cpp
index e377e5c..0e8430c 100644
--- a/src/uscxml/plugins/invoker/graphics/openscenegraph/converter/OSGConverter.cpp
+++ b/src/uscxml/plugins/invoker/graphics/openscenegraph/converter/OSGConverter.cpp
@@ -21,12 +21,12 @@
 
 #define EVAL_PARAM_EXPR(param, expr, key) \
 if (param.find(key) == param.end() && param.find(expr) != param.end() && _interpreter->getDataModel()) \
-  param.insert(std::make_pair(key, _interpreter->getDataModel().evalAsString(param.find(expr)->second)));
+  param.insert(std::make_pair(key, _interpreter->getDataModel().evalAsString(param.find(expr)->second.atom)));
 
 #define CAST_PARAM(param, var, key, type) \
 if (param.find(key) != param.end()) { \
-  try { var = boost::lexical_cast<type>(param.find(key)->second); } \
-  catch(...) { LOG(ERROR) << "Attribute " key " of sendrequest to osgconverter is of invalid format: " << param.find(key)->second; } \
+  try { var = boost::lexical_cast<type>(param.find(key)->second.atom); } \
+  catch(...) { LOG(ERROR) << "Attribute " key " of sendrequest to osgconverter is of invalid format: " << param.find(key)->second.atom; } \
 }
 
 
@@ -42,6 +42,7 @@ bool connect(pluma::Host& host) {
 
 OSGConverter::OSGConverter() : _isRunning(false) {
 //  osg::setNotifyLevel(osg::DEBUG_FP);
+	osg::setNotifyLevel(osg::FATAL);
 }
 
 OSGConverter::~OSGConverter() {
@@ -76,7 +77,7 @@ void OSGConverter::send(const SendRequest& req) {
 	if (actualReq.params.find("source") == actualReq.params.end()) {
 		// no explicit source
 		if (actualReq.params.find("sourceexpr") != actualReq.params.end() && _interpreter->getDataModel()) {
-			actualReq.params.insert(std::make_pair("source", _interpreter->getDataModel().evalAsString(actualReq.params.find("sourceexpr")->second)));
+			actualReq.params.insert(std::make_pair("source", _interpreter->getDataModel().getStringAsData(actualReq.params.find("sourceexpr")->second)));
 		} else {
 			LOG(ERROR) << "SendRequests for osginvoker missing source or sourceExpr and datamodel";
 			return;
@@ -86,20 +87,16 @@ void OSGConverter::send(const SendRequest& req) {
 	if (actualReq.params.find("dest") == actualReq.params.end()) {
 		// no explicit destination
 		if (actualReq.params.find("destexpr") != actualReq.params.end() && _interpreter->getDataModel()) {
-			actualReq.params.insert(std::make_pair("dest", _interpreter->getDataModel().evalAsString(actualReq.params.find("destexpr")->second)));
-		} else {
-			LOG(ERROR) << "SendRequests for osginvoker missing dest or destExpr and datamodel";
-			return;
+			actualReq.params.insert(std::make_pair("dest", _interpreter->getDataModel().getStringAsData(actualReq.params.find("destexpr")->second)));
+			boost::algorithm::replace_all(actualReq.params.find("dest")->second.atom, "//", "/");
+			boost::algorithm::replace_all(actualReq.params.find("dest")->second.atom, "\\\\", "\\");
 		}
 	}
 
-	boost::algorithm::replace_all(actualReq.params.find("dest")->second, "//", "/");
-	boost::algorithm::replace_all(actualReq.params.find("dest")->second, "\\\\", "\\");
-
 	if (actualReq.params.find("autorotate") == actualReq.params.end()) {
 		if (actualReq.params.find("autorotateexpr") != actualReq.params.end()) {
 			if (_interpreter->getDataModel()) {
-				actualReq.params.insert(std::make_pair("autorotate", _interpreter->getDataModel().evalAsString(actualReq.params.find("autorotateexpr")->second)));
+				actualReq.params.insert(std::make_pair("autorotate", _interpreter->getDataModel().getStringAsData(actualReq.params.find("autorotateexpr")->second)));
 			} else {
 				LOG(ERROR) << "SendRequests for osginvoker ncludes autorotateexpr but no datamodel is specified";
 				return;
@@ -110,34 +107,25 @@ void OSGConverter::send(const SendRequest& req) {
 	if (actualReq.params.find("format") == actualReq.params.end()) {
 		// no explicit format
 		if (actualReq.params.find("formatexpr") != actualReq.params.end() && _interpreter->getDataModel()) {
-			actualReq.params.insert(std::make_pair("format", _interpreter->getDataModel().evalAsString(actualReq.params.find("formatexpr")->second)));
+			actualReq.params.insert(std::make_pair("format", _interpreter->getDataModel().getStringAsData(actualReq.params.find("formatexpr")->second)));
 		} else {
 			std::string format;
-			size_t lastDot;
-			std::string dest = req.params.find("dest")->second;
-			if ((lastDot = dest.find_last_of(".")) != std::string::npos) {
-				lastDot++;
-				format = dest.substr(lastDot, dest.length() - lastDot);
+			std::string dest;
+			if (Event::getParam(actualReq.params, "dest", dest)) {
+				size_t lastDot;
+				if ((lastDot = dest.find_last_of(".")) != std::string::npos) {
+					lastDot++;
+					format = dest.substr(lastDot, dest.length() - lastDot);
+				}
 			}
 			if (format.length() == 0 || format.find_last_of(PATH_SEPERATOR) != std::string::npos) {
 				// empty format or pathseperator in format
 				format = "png";
 			}
-			actualReq.params.insert(std::make_pair("format", format));
+			actualReq.params.insert(std::make_pair("format", Data(format, Data::VERBATIM)));
 		}
 	}
 
-//  assert(osgDB::Registry::instance()->getReaderWriterForExtension("png"));
-//  osgDB::Registry::ReaderWriterList formatList = osgDB::Registry::instance()->getReaderWriterList();
-//  for (int i = 0; i < formatList.size(); i++) {
-//    std::map<std::string, std::string> funcDesc = formatList[i]->supportedProtocols();
-//    std::map<std::string, std::string>::iterator funcDescIter = funcDesc.begin();
-//    while(funcDescIter != funcDesc.end()) {
-//      std::cout << funcDescIter->first << ": " << funcDescIter->second << std::endl;
-//      funcDescIter++;
-//    }
-//  }
-
 	EVAL_PARAM_EXPR(actualReq.params, "heightexpr", "height");
 	EVAL_PARAM_EXPR(actualReq.params, "widthexpr", "width");
 	EVAL_PARAM_EXPR(actualReq.params, "pitchexpr", "pitch");
@@ -157,7 +145,8 @@ void OSGConverter::cancel(const std::string sendId) {
 
 void OSGConverter::invoke(const InvokeRequest& req) {
 	int nrThreads = 1;
-	if (req.params.find("threads") != req.params.end() && isNumeric(req.params.find("threads")->second.c_str(), 10)) {
+	
+	if (req.params.find("threads") != req.params.end() && isNumeric(req.params.find("threads")->second.atom.c_str(), 10)) {
 		nrThreads = strTo<int>(req.params.find("threads")->second);
 	}
 
@@ -185,22 +174,28 @@ void OSGConverter::process(const SendRequest& req) {
 
 	int width = 640;
 	int height = 480;
-	CAST_PARAM(req.params, width, "width", int);
-	CAST_PARAM(req.params, height, "height", int);
+	Event::getParam(req.params, "width", width);
+	Event::getParam(req.params, "height", height);
 
 	assert(req.params.find("source") != req.params.end());
-	assert(req.params.find("dest") != req.params.end());
 	assert(req.params.find("format") != req.params.end());
 
-	std::string source = req.params.find("source")->second;
-	std::string dest = req.params.find("dest")->second;
-	std::string format = req.params.find("format")->second;
+	std::string source;
+	if (!Event::getParam(req.params, "source", source))
+		reportFailure(req);
+
+	std::string dest;
+	Event::getParam(req.params, "dest", dest);
+
+	std::string format;
+	if (!Event::getParam(req.params, "format", format))
+		reportFailure(req);
 
 	bool autoRotate = true;
 	if (req.params.find("autorotate") != req.params.end()) {
-		if (boost::iequals(req.params.find("autorotate")->second, "off") ||
-		        boost::iequals(req.params.find("autorotate")->second, "0") ||
-		        boost::iequals(req.params.find("autorotate")->second, "false")) {
+		if (boost::iequals(req.params.find("autorotate")->second.atom, "off") ||
+				boost::iequals(req.params.find("autorotate")->second.atom, "0") ||
+				boost::iequals(req.params.find("autorotate")->second.atom, "false")) {
 			autoRotate = false;
 		}
 	}
@@ -215,16 +210,22 @@ void OSGConverter::process(const SendRequest& req) {
 	sceneGraph->addChild(model);
 
 	osgDB::ReaderWriter::WriteResult result;
-	if (osgDB::Registry::instance()->getReaderWriterForExtension(format) != NULL) {
-		// write as another 3D file
-		result = osgDB::Registry::instance()->writeNode(*sceneGraph, dest, osgDB::Registry::instance()->getOptions());
+	
+	osg::ref_ptr<osgDB::ReaderWriter> writer = osgDB::Registry::instance()->getReaderWriterForExtension(format);
+	if(writer.valid()) {
+		std::stringstream ss;
+		result = writer->writeNode(*sceneGraph, ss);
 		if (result.success()) {
-			// we can know about success right here
-			reportSuccess(req);
+			if (dest.length() > 0) {
+				std::ofstream outFile(dest.c_str());
+				outFile << ss.str();
+			}
+			Data content(ss.str().c_str(), ss.str().size(), false);
+			reportSuccess(req, content);
 			return;
 		}
 	}
-
+	
 	/**
 	 * If we failed to interpret the extension as another 3D file, try to make a screenshot.
 	 */
@@ -245,53 +246,66 @@ void OSGConverter::process(const SendRequest& req) {
 
 	osgViewer::ScreenCaptureHandler* captureHandler = new osgViewer::ScreenCaptureHandler(cOp, -1);
 
-	osgViewer::Viewer viewer;
-	viewer.setSceneData(sceneGraph);
-	viewer.setCameraManipulator(new osgGA::TrackballManipulator());
-	viewer.addEventHandler(captureHandler);
-	captureHandler->startCapture();
-
-	osg::DisplaySettings* ds = osg::DisplaySettings::instance().get();
-	osg::ref_ptr<osg::GraphicsContext::Traits> traits = new osg::GraphicsContext::Traits(ds);
-	traits->width = width;
-	traits->height = height;
-	traits->pbuffer = true;
-	osg::ref_ptr<osg::GraphicsContext> gc = osg::GraphicsContext::createGraphicsContext(traits.get());
-
-	if (!gc.valid()) {
-		LOG(ERROR) << "Cannot create GraphicsContext!";
-		return;
-	}
+	{
+//		tthread::lock_guard<tthread::recursive_mutex> lock(_viewerMutex);
+		osgViewer::Viewer viewer;
+		osg::ref_ptr<osg::GraphicsContext> gc;
+
+		viewer.setSceneData(sceneGraph);
+		viewer.addEventHandler(captureHandler);
+		captureHandler->startCapture();
+
+		osg::DisplaySettings* ds = osg::DisplaySettings::instance().get();
+		osg::ref_ptr<osg::GraphicsContext::Traits> traits = new osg::GraphicsContext::Traits(ds);
+		traits->width = width;
+		traits->height = height;
+		traits->pbuffer = true;
+		gc = osg::GraphicsContext::createGraphicsContext(traits.get());
+
+		if (!gc.valid()) {
+			LOG(ERROR) << "Cannot create GraphicsContext!";
+			return;
+		}
+
+		GLenum pbuffer = gc->getTraits()->doubleBuffer ? GL_BACK : GL_FRONT;
 
-	GLenum pbuffer = gc->getTraits()->doubleBuffer ? GL_BACK : GL_FRONT;
+		viewer.setCameraManipulator(new osgGA::TrackballManipulator());
+		viewer.getCamera()->setGraphicsContext(gc.get());
+		viewer.getCamera()->setViewport(new osg::Viewport(0,0,traits->width,traits->height));
+		viewer.getCamera()->setDrawBuffer(pbuffer);
+		viewer.getCamera()->setReadBuffer(pbuffer);
 
-	viewer.getCamera()->setGraphicsContext(gc.get());
-	viewer.getCamera()->setViewport(new osg::Viewport(0,0,traits->width,traits->height));
-	viewer.getCamera()->setDrawBuffer(pbuffer);
-	viewer.getCamera()->setReadBuffer(pbuffer);
+		double zoom = 1;
+		CAST_PARAM(req.params, zoom, "zoom", double);
 
-	double zoom = 1;
-	CAST_PARAM(req.params, zoom, "zoom", double);
+		// set background color
+		viewer.getCamera()->setClearColor(osg::Vec4f(1.0f,1.0f,1.0f,1.0f));
+		viewer.getCamera()->setClearMask(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+		viewer.getCameraManipulator()->setByMatrix(osg::Matrix::lookAt(osg::Vec3d(0,0,bs.radius() * (-3.4 * zoom)),  // eye
+						(osg::Vec3d)bs.center(),           // center
+						osg::Vec3d(0,1,0)));               // up
 
-	// set background color
-	viewer.getCamera()->setClearColor(osg::Vec4f(1.0f,1.0f,1.0f,1.0f));
-	viewer.getCamera()->setClearMask(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-	viewer.getCameraManipulator()->setByMatrix(osg::Matrix::lookAt(osg::Vec3d(0,0,bs.radius() * (-3.4 * zoom)),  // eye
-	        (osg::Vec3d)bs.center(),           // center
-	        osg::Vec3d(0,1,0)));               // up
+	//  viewer.home();
 
-//  viewer.home();
+		// perform one viewer iteration
+		viewer.realize();
+		viewer.frame();
 
-	// perform one viewer iteration
-	viewer.realize();
-	viewer.frame();
+		viewer.removeEventHandler(captureHandler);
+	}
+
+//	delete(cOp);
+//	delete(captureHandler);
 }
 
-void OSGConverter::reportSuccess(const SendRequest& req) {
+void OSGConverter::reportSuccess(const SendRequest& req, const Data& content) {
 	Event event(req);
+	
 	if (event.name.length() == 0)
 		event.name = "convert";
 	event.name += ".success";
+	if (content)
+		event.data.compound["content"] = content;
 	returnEvent(event);
 }
 
@@ -366,7 +380,7 @@ osg::ref_ptr<osg::Node> OSGConverter::setupGraph(const std::string filename, boo
 		std::map<std::string, std::pair<long, osg::ref_ptr<osg::Node> > >::iterator modelIter = _models.begin();
 		while(modelIter != _models.end()) {
 			// delete every model unused for 1 minutes
-			if (now - modelIter->second.first > 60000) {
+			if (now - modelIter->second.first > 6000) {
 				_models.erase(modelIter++);
 			} else {
 				modelIter++;
@@ -504,30 +518,79 @@ void OSGConverter::dumpMatrix(const osg::Matrix& m) {
 }
 
 void OSGConverter::NameRespectingWriteToFile::operator()(const osg::Image& image, const unsigned int context_id) {
+	
+	// write to memory first
+	std::string format;
+	if (_req.params.find("format") != _req.params.end()) {
+		format = _req.params.find("format")->second.atom;
+	} else {
+		_converter->reportFailure(_req);
+	}
 
-//  URL fileURL(_filename);
-//  fileURL.path()
+	osg::ref_ptr<osgDB::ReaderWriter::Options> op = new osgDB::ReaderWriter::Options();
+	//op->setOptionString("JPEG_QUALITY 75");
+	//op->setOptionString("PNG_COMPRESSION 9");
 
-	std::string tmpName = _filename;
-	size_t pathSep = _filename.find_last_of(PATH_SEPERATOR);
-	if (pathSep != std::string::npos) {
-		tmpName = _filename.substr(0, pathSep) + PATH_SEPERATOR + ".tmp" + _filename.substr(pathSep + 1, _filename.length() - pathSep - 1);
+	// osgDB got confused when we write to a stringstream
+	std::string tempFile = URL::getTmpFilename(format);
+	osgDB::writeImageFile(image, tempFile, op);
+	
+	char* buffer = NULL;
+	size_t length = 0;
+	{
+		std::ifstream file(tempFile.c_str());
+		
+		file.seekg(0, std::ios::end);
+		length = file.tellg();
+		file.seekg(0, std::ios::beg);
+		buffer = (char*)malloc(length);
+		file.read(buffer, length);
 	}
+	
+	remove(tempFile.c_str());
+//	osg::ref_ptr<osgDB::ReaderWriter> writerFormat = osgDB::Registry::instance()->getReaderWriterForExtension(format);
+//	if(!writerFormat.valid())
+//		_converter->reportFailure(_req);
 
-	bool success = osgDB::writeImageFile(image, tmpName); // <- no plugin to write to .tmp format
-	if (!success) {
-		_converter->reportFailure(_req);
-		return;
-	}
 
-	if (pathSep != std::string::npos) {
-		int err = rename(tmpName.c_str(), _filename.c_str());
-		if (err) {
-			_converter->reportFailure(_req);
+#if 0
+	std::stringstream ssFormat;
+
+	osgDB::ReaderWriter::WriteResult res = writerFormat->writeImage(image, ssFormat, op);
+	
+	if (_filename.length() > 0) {
+		std::string tmpName = _filename;
+		size_t pathSep = _filename.find_last_of(PATH_SEPERATOR);
+		if (pathSep != std::string::npos) {
+			tmpName = _filename.substr(0, pathSep) + PATH_SEPERATOR + ".tmp" + _filename.substr(pathSep + 1, _filename.length() - pathSep - 1);
 		}
-	}
 
-	_converter->reportSuccess(_req);
+		{
+			std::ofstream outFile(tmpName.c_str());
+			outFile << ssFormat.str();
+		}
+		
+		if (pathSep != std::string::npos) {
+			int err = rename(tmpName.c_str(), _filename.c_str());
+			if (err) {
+				_converter->reportFailure(_req);
+			}
+		}
+	}
+#endif
+	
+	Data content;
+	content.compound[format] = Data(buffer, length, false);
+
+	// save image as a raw rgba as well for ffmpeg - we are using the mpb format for now
+//	osg::ref_ptr<osgDB::ReaderWriter> writerRGBA = osgDB::Registry::instance()->getReaderWriterForExtension("rgba");
+//	if(writerRGBA.valid()) {
+//		std::stringstream ssRGBA;
+//		osgDB::ReaderWriter::WriteResult res = writerRGBA->writeImage(image, ssRGBA, op);
+//		content.compound["rgba"] = Data(ssRGBA.str().c_str(), ssRGBA.str().size(), false);
+//	}
+
+	_converter->reportSuccess(_req, content);
 }
 
 }
\ No newline at end of file
diff --git a/src/uscxml/plugins/invoker/graphics/openscenegraph/converter/OSGConverter.h b/src/uscxml/plugins/invoker/graphics/openscenegraph/converter/OSGConverter.h
index 78d6c6c..2bc84a1 100644
--- a/src/uscxml/plugins/invoker/graphics/openscenegraph/converter/OSGConverter.h
+++ b/src/uscxml/plugins/invoker/graphics/openscenegraph/converter/OSGConverter.h
@@ -31,7 +31,7 @@ public:
 	virtual void cancel(const std::string sendId);
 	virtual void invoke(const InvokeRequest& req);
 
-	void reportSuccess(const SendRequest& req);
+	void reportSuccess(const SendRequest& req, const Data& content);
 	void reportFailure(const SendRequest& req);
 
 	osg::Matrix requestToModelPose(const SendRequest& req);
@@ -61,6 +61,8 @@ protected:
 	osg::ref_ptr<osg::Node> setupGraph(const std::string filename, bool autoRotate = false);
 	osg::ref_ptr<osg::Node> getOrigin();
 
+	tthread::recursive_mutex _viewerMutex;
+
 	std::map<std::string, std::pair<long, osg::ref_ptr<osg::Node> > > _models;
 	tthread::recursive_mutex _cacheMutex;
 
diff --git a/src/uscxml/plugins/invoker/heartbeat/HeartbeatInvoker.cpp b/src/uscxml/plugins/invoker/heartbeat/HeartbeatInvoker.cpp
index c7b91f6..5afbc66 100644
--- a/src/uscxml/plugins/invoker/heartbeat/HeartbeatInvoker.cpp
+++ b/src/uscxml/plugins/invoker/heartbeat/HeartbeatInvoker.cpp
@@ -49,8 +49,8 @@ void HeartbeatInvoker::invoke(const InvokeRequest& req) {
 	InvokeRequest::params_t::const_iterator paramIter = req.params.begin();
 	while(paramIter != req.params.end()) {
 		if (boost::iequals(paramIter->first, "interval")) {
-			intervalStr = paramIter->second;
-			NumAttr intervalAttr(paramIter->second);
+			intervalStr = paramIter->second.atom;
+			NumAttr intervalAttr(paramIter->second.atom);
 			interval = strTo<double>(intervalAttr.value);
 			if (false) {
 			} else if (boost::iequals(intervalAttr.unit, "s")) {
@@ -62,7 +62,7 @@ void HeartbeatInvoker::invoke(const InvokeRequest& req) {
 			}
 		}
 		if (boost::iequals(paramIter->first, "eventname")) {
-			_event.name = paramIter->second;
+			_event.name = paramIter->second.atom;
 		}
 		paramIter++;
 	}
diff --git a/src/uscxml/plugins/invoker/http/HTTPServletInvoker.cpp b/src/uscxml/plugins/invoker/http/HTTPServletInvoker.cpp
index 2c395a8..1a95396 100644
--- a/src/uscxml/plugins/invoker/http/HTTPServletInvoker.cpp
+++ b/src/uscxml/plugins/invoker/http/HTTPServletInvoker.cpp
@@ -52,15 +52,15 @@ void HTTPServletInvoker::send(const SendRequest& req) {
 		HTTPServer::Reply httpReply(httpRequest);
 		httpReply.content = req.content;
 
-		std::map<std::string, std::string>::const_iterator nameListIter = req.namelist.begin();
+		std::map<std::string, Data>::const_iterator nameListIter = req.namelist.begin();
 		while(nameListIter != req.namelist.end()) {
-			httpReply.headers[nameListIter->first] = nameListIter->second;
+			httpReply.headers[nameListIter->first] = nameListIter->second.atom;
 			nameListIter++;
 		}
 
-		std::multimap<std::string, std::string>::const_iterator paramIter = req.params.begin();
+		std::multimap<std::string, Data>::const_iterator paramIter = req.params.begin();
 		while(paramIter != req.params.end()) {
-			httpReply.headers[paramIter->first] = paramIter->second;
+			httpReply.headers[paramIter->first] = paramIter->second.atom;
 			paramIter++;
 		}
 
@@ -78,10 +78,10 @@ void HTTPServletInvoker::invoke(const InvokeRequest& req) {
 	if (req.params.find("path") == req.params.end()) {
 		LOG(ERROR) << "Path parameter required with httpserver";
 	}
-	_path = (*req.params.find("path")).second;
+	_path = (*req.params.find("path")).second.atom;
 
 	if (req.params.find("callback") != req.params.end()) {
-		_callback = (*req.params.find("callback")).second;
+		_callback = (*req.params.find("callback")).second.atom;
 	} else {
 		_callback = _path;
 		std::replace(_callback.begin(), _callback.end(), '/', '.');
diff --git a/src/uscxml/plugins/invoker/miles/SpatialAudio.cpp b/src/uscxml/plugins/invoker/miles/SpatialAudio.cpp
index fb91e40..9a26960 100644
--- a/src/uscxml/plugins/invoker/miles/SpatialAudio.cpp
+++ b/src/uscxml/plugins/invoker/miles/SpatialAudio.cpp
@@ -125,7 +125,7 @@ void SpatialAudio::invoke(const InvokeRequest& req) {
 
 	getPosFromParams(req.params, _pos);
 
-	std::multimap<std::string, std::string>::const_iterator paramIter = req.params.begin();
+	std::multimap<std::string, Data>::const_iterator paramIter = req.params.begin();
 	while(paramIter != req.params.end()) {
 		if (boost::iequals(paramIter->first, "maxX"))
 			_maxPos[0] = strTo<float>(paramIter->second);
@@ -150,7 +150,7 @@ void SpatialAudio::invoke(const InvokeRequest& req) {
 	}
 }
 
-void SpatialAudio::getPosFromParams(const std::multimap<std::string, std::string>& params, float* position) {
+void SpatialAudio::getPosFromParams(const std::multimap<std::string, Data>& params, float* position) {
 	// vector explicitly given
 	try {
 		if (params.find("x") != params.end())
diff --git a/src/uscxml/plugins/invoker/miles/SpatialAudio.h b/src/uscxml/plugins/invoker/miles/SpatialAudio.h
index 59ecfdb..e7ab830 100644
--- a/src/uscxml/plugins/invoker/miles/SpatialAudio.h
+++ b/src/uscxml/plugins/invoker/miles/SpatialAudio.h
@@ -34,7 +34,7 @@ public:
 	virtual void invoke(const InvokeRequest& req);
 	virtual void sendToParent(SendRequest& req);
 
-	void getPosFromParams(const std::multimap<std::string, std::string>& params, float* position);
+	void getPosFromParams(const std::multimap<std::string, Data>& params, float* position);
 	static float posToRadian(const std::string& position);
 
 protected:
diff --git a/src/uscxml/plugins/invoker/umundo/UmundoInvoker.cpp b/src/uscxml/plugins/invoker/umundo/UmundoInvoker.cpp
index de5a580..6845280 100644
--- a/src/uscxml/plugins/invoker/umundo/UmundoInvoker.cpp
+++ b/src/uscxml/plugins/invoker/umundo/UmundoInvoker.cpp
@@ -63,7 +63,7 @@ void UmundoInvoker::send(const SendRequest& req) {
 			std::string type;
 			if (req.params.find("type") != req.params.end()) {
 				// we are supposed to build a typed object
-				type = req.params.find("type")->second;
+				type = req.params.find("type")->second.atom;
 
 				const google::protobuf::Message* protoMsg = umundo::PBSerializer::getProto(type);
 				if (protoMsg == NULL) {
@@ -139,17 +139,17 @@ void UmundoInvoker::invoke(const InvokeRequest& req) {
 	std::string serviceName;
 
 	if (req.params.find("channel") != req.params.end()) {
-		channelName = req.params.find("channel")->second;
+		channelName = req.params.find("channel")->second.atom;
 		_isService = false;
 	} else if (req.params.find("service") != req.params.end()) {
-		serviceName = req.params.find("service")->second;
+		serviceName = req.params.find("service")->second.atom;
 		_isService = true;
 	} else {
 		LOG(ERROR) << "Invoking umundo needs a service or a channel param";
 		return;
 	}
 	if (req.params.find("domain") != req.params.end()) {
-		domain = req.params.find("domain")->second;
+		domain = req.params.find("domain")->second.atom;
 	}
 	_node = getNode(_interpreter, domain);
 
@@ -157,7 +157,7 @@ void UmundoInvoker::invoke(const InvokeRequest& req) {
 	if (req.params.find("type") != req.params.end()) {
 		std::pair<InvokeRequest::params_t::const_iterator, InvokeRequest::params_t::const_iterator> typeRange = req.params.equal_range("types");
 		for (InvokeRequest::params_t::const_iterator it = typeRange.first; it != typeRange.second; it++) {
-			URL typeURI(it->second);
+			URL typeURI(it->second.atom);
 			if (typeURI.toAbsolute(_interpreter->getBaseURI())) {
 				std::string filename = typeURI.asLocalFile(".proto");
 				umundo::PBSerializer::addProto(filename);
@@ -171,7 +171,7 @@ void UmundoInvoker::invoke(const InvokeRequest& req) {
 	if (req.params.find("types") != req.params.end()) {
 		std::pair<InvokeRequest::params_t::const_iterator, InvokeRequest::params_t::const_iterator> typeRange = req.params.equal_range("types");
 		for (InvokeRequest::params_t::const_iterator it = typeRange.first; it != typeRange.second; it++) {
-			URL typeURI(it->second);
+			URL typeURI(it->second.atom);
 			if (typeURI.toAbsolute(_interpreter->getBaseURI()) && typeURI.scheme().compare("file") == 0) {
 				umundo::PBSerializer::addProto(typeURI.path());
 			} else {
diff --git a/src/uscxml/plugins/ioprocessor/basichttp/BasicHTTPIOProcessor.cpp b/src/uscxml/plugins/ioprocessor/basichttp/BasicHTTPIOProcessor.cpp
index 90cebc3..74e51d6 100644
--- a/src/uscxml/plugins/ioprocessor/basichttp/BasicHTTPIOProcessor.cpp
+++ b/src/uscxml/plugins/ioprocessor/basichttp/BasicHTTPIOProcessor.cpp
@@ -187,10 +187,11 @@ void BasicHTTPIOProcessor::send(const SendRequest& req) {
 
 	// event namelist
 	if (req.namelist.size() > 0) {
-		std::map<std::string, std::string>::const_iterator namelistIter = req.namelist.begin();
+		std::map<std::string, Data>::const_iterator namelistIter = req.namelist.begin();
 		while (namelistIter != req.namelist.end()) {
 			char* keyCStr = evhttp_encode_uri(namelistIter->first.c_str());
-			char* valueCStr = evhttp_encode_uri(namelistIter->second.c_str());
+			// this is simplified - Data might be more elaborate than a simple string atom
+			char* valueCStr = evhttp_encode_uri(namelistIter->second.atom.c_str());
 			kvps << kvpSeperator << keyCStr << "=" << valueCStr;
 			free(keyCStr);
 			free(valueCStr);
@@ -202,10 +203,11 @@ void BasicHTTPIOProcessor::send(const SendRequest& req) {
 
 	// event params
 	if (req.params.size() > 0) {
-		std::multimap<std::string, std::string>::const_iterator paramIter = req.params.begin();
+		std::multimap<std::string, Data>::const_iterator paramIter = req.params.begin();
 		while (paramIter != req.params.end()) {
 			char* keyCStr = evhttp_encode_uri(paramIter->first.c_str());
-			char* valueCStr = evhttp_encode_uri(paramIter->second.c_str());
+			// this is simplified - Data might be more elaborate than a simple string atom
+			char* valueCStr = evhttp_encode_uri(paramIter->second.atom.c_str());
 			kvps << kvpSeperator << keyCStr << "=" << valueCStr;
 			free(keyCStr);
 			free(valueCStr);
diff --git a/src/uscxml/plugins/ioprocessor/modality/MMIHTTPIOProcessor.cpp b/src/uscxml/plugins/ioprocessor/modality/MMIHTTPIOProcessor.cpp
index 67b518c..0009cc0 100644
--- a/src/uscxml/plugins/ioprocessor/modality/MMIHTTPIOProcessor.cpp
+++ b/src/uscxml/plugins/ioprocessor/modality/MMIHTTPIOProcessor.cpp
@@ -138,9 +138,10 @@ void MMIHTTPIOProcessor::send(const SendRequest& req) {
 
 	// event namelist
 	if (req.namelist.size() > 0) {
-		std::map<std::string, std::string>::const_iterator namelistIter = req.namelist.begin();
+		std::map<std::string, Data>::const_iterator namelistIter = req.namelist.begin();
 		while (namelistIter != req.namelist.end()) {
-			kvps << kvpSeperator << evhttp_encode_uri(namelistIter->first.c_str()) << "=" << evhttp_encode_uri(namelistIter->second.c_str());
+			// this is simplified - Data might be more elaborate than a simple string atom
+			kvps << kvpSeperator << evhttp_encode_uri(namelistIter->first.c_str()) << "=" << evhttp_encode_uri(namelistIter->second.atom.c_str());
 			kvpSeperator = "&";
 //			targetURL.addOutHeader(namelistIter->first, namelistIter->second);
 			namelistIter++;
@@ -149,9 +150,10 @@ void MMIHTTPIOProcessor::send(const SendRequest& req) {
 
 	// event params
 	if (req.params.size() > 0) {
-		std::multimap<std::string, std::string>::const_iterator paramIter = req.params.begin();
+		std::multimap<std::string, Data>::const_iterator paramIter = req.params.begin();
 		while (paramIter != req.params.end()) {
-			kvps << kvpSeperator << evhttp_encode_uri(paramIter->first.c_str()) << "=" << evhttp_encode_uri(paramIter->second.c_str());
+			// this is simplified - Data might be more elaborate than a simple string atom
+			kvps << kvpSeperator << evhttp_encode_uri(paramIter->first.c_str()) << "=" << evhttp_encode_uri(paramIter->second.atom.c_str());
 			kvpSeperator = "&";
 //			targetURL.addOutHeader(paramIter->first, paramIter->second);
 			paramIter++;