hlrc

    src/MiddlewareRSB.cpp

    src/AudioPlayerRSB.cpp

/*

 * This file is part of hlrc_server

 *

 * Copyright(c) sschulz <AT> techfak.uni-bielefeld.de

 * http://opensource.cit-ec.de/projects/hlrc_server

 *

 * This file may be licensed under the terms of the

 * GNU General Public License Version 3 (the ``GPL''),

 * or (at your option) any later version.

 *

 * Software distributed under the License is distributed

 * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either

 * express or implied. See the GPL for the specific language

 * governing rights and limitations.

 *

 * You should have received a copy of the GPL along with this

 * program. If not, go to http://www.gnu.org/licenses/gpl.html

 * or write to the Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 *

 * The development of this software was supported by the

 * Excellence Cluster EXC 277 Cognitive Interaction Technology.

 * The Excellence Cluster EXC 277 is a grant of the Deutsche

 * Forschungsgemeinschaft (DFG) in the context of the German

 * Excellence Initiative.

 *

 */

#pragma once

#include "AudioPlayer.h"

#ifdef RSB_SUPPORT

#define BOOST_SIGNALS_NO_DEPRECATION_WARNING 1

#include <rsb/Informer.h>

#include <rst/audition/SoundChunk.pb.h>

class AudioPlayerRSB : public AudioPlayer {

public:

	AudioPlayerRSB(std::string driver);

	~AudioPlayerRSB();

	void playback_thread();

	void play(std::shared_ptr<AudioData> audio);

	bool is_playing();

private:

	boost::thread* playback_thread_ptr;

	void publish_audio_data();

	rsb::Informer<rst::audition::SoundChunk>::DataPtr audio_data_ptr;

	rsb::Informer<rst::audition::SoundChunk>::Ptr informer;

};

#endif

		printf("> ERROR: hlrc was compiled without ROS middleware support. Please use MiddlewareRSB() instead!\n\n");

/*

 * This file is part of hlrc_server

 *

 * Copyright(c) sschulz <AT> techfak.uni-bielefeld.de

 * http://opensource.cit-ec.de/projects/hlrc_server

 *

 * This file may be licensed under the terms of the

 * GNU General Public License Version 3 (the ``GPL''),

 * or (at your option) any later version.

 *

 * Software distributed under the License is distributed

 * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either

 * express or implied. See the GPL for the specific language

 * governing rights and limitations.

 *

 * You should have received a copy of the GPL along with this

 * program. If not, go to http://www.gnu.org/licenses/gpl.html

 * or write to the Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 *

 * The development of this software was supported by the

 * Excellence Cluster EXC 277 Cognitive Interaction Technology.

 * The Excellence Cluster EXC 277 is a grant of the Deutsche

 * Forschungsgemeinschaft (DFG) in the context of the German

 * Excellence Initiative.

 *

 */

#pragma once

#include "Middleware.h"

#ifdef RSB_SUPPORT

#define BOOST_SIGNALS_NO_DEPRECATION_WARNING 1

#include <rsb/Listener.h>

#include <rsb/patterns/LocalServer.h>

#include <rsb/patterns/RemoteServer.h>

#endif

class MiddlewareRSB : public Middleware {

#ifndef RSB_SUPPORT

public:

	MiddlewareRSB(Arbiter* a, std::string _base_scope) : Middleware(a, _base_scope) {

		printf("> ERROR: hlrc was compiled without RSB middleware support. Please use MiddlewareROS() instead!\n\n");

		exit(EXIT_FAILURE);

	}

	~MiddlewareRSB() {

	}

	void init(){};

	void tick(){};

	std::shared_ptr<Utterance> tts_call(std::string text) {

		return std::shared_ptr<Utterance>(new Utterance());

	}

#else

public:

	MiddlewareRSB(Arbiter* a, std::string _base_scope);

	~MiddlewareRSB();

	void init();

	void tick();

	std::shared_ptr<Utterance> tts_call(std::string text);

private:

	void init_callbacks();

	void init_callback(std::string name, rsb::patterns::LocalServer::CallbackPtr callback_ptr);

	rsb::patterns::LocalServerPtr server;

	rsb::patterns::LocalServerPtr server_parallel;

	rsb::patterns::RemoteServerPtr tts_server;

	rsb::ListenerPtr speak_listener;

#endif

};

		//#include "RSB/SpeechCallbackWrapper.h".opening_left   = request->opening_left;

				// throw runtime_error("UtteranceRSB::convert_audio_data() unsupported sample type in soundchunk");

		}

			throw std::runtime_error("UtteranceRSB::convert_audio_data() unsupported byte_format in soundchunk");

/*

 * This file is part of hlrc_server

 *

 * Copyright(c) sschulz <AT> techfak.uni-bielefeld.de

 * http://opensource.cit-ec.de/projects/hlrc_server

 *

 * This file may be licensed under the terms of the

 * GNU General Public License Version 3 (the ``GPL''),

 * or (at your option) any later version.

 *

 * Software distributed under the License is distributed

 * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either

 * express or implied. See the GPL for the specific language

 * governing rights and limitations.

 *

 * You should have received a copy of the GPL along with this

 * program. If not, go to http://www.gnu.org/licenses/gpl.html

 * or write to the Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 *

 * The development of this software was supported by the

 * Excellence Cluster EXC 277 Cognitive Interaction Technology.

 * The Excellence Cluster EXC 277 is a grant of the Deutsche

 * Forschungsgemeinschaft (DFG) in the context of the German

 * Excellence Initiative.

 *

 */

#pragma once

#include "CallbackWrapper.h"

#include "Animation.h"

// callback handler incoming animation requests:

class AnimationCallbackWrapper : public CallbackWrapper<rst::animation::HeadAnimation> {

public:

	AnimationCallbackWrapper(Middleware* mw) : CallbackWrapper(mw) {

	}

	void call(const std::string& method_name, std::shared_ptr<rst::animation::HeadAnimation> input) {

		printf("> incomint animation (method = %s)\n", method_name.c_str());

		// fetch animation passed by rsb:

		rst::animation::HeadAnimation* rst_ani = input.get();

		std::shared_ptr<Animation> ani(new Animation());

		switch ((int)rst_ani->animation()) {

			case (rst_ani->IDLE):

				ani->target = Animation::IDLE;

				break;

			case (rst_ani->HEAD_NOD):

				ani->target = Animation::HEAD_NOD;

				break;

			case (rst_ani->HEAD_SHAKE):

				ani->target = Animation::HEAD_SHAKE;

				break;

			case (rst_ani->EYEBLINK_LEFT):

				ani->target = Animation::EYEBLINK_L;

				break;

			case (rst_ani->EYEBLINK_RIGHT):

				ani->target = Animation::EYEBLINK_R;

				break;

			case (rst_ani->EYEBLINK_BOTH):

				ani->target = Animation::EYEBLINK_BOTH;

				break;

			case (rst_ani->EYEBROWS_RAISE):

				ani->target = Animation::EYEBROWS_RAISE;

				break;

			case (rst_ani->EYEBROWS_LOWER):

				ani->target = Animation::EYEBROWS_LOWER;

				break;

			case (rst_ani->ENGAGEMENT_LEFT):

				ani->target = Animation::ENGAGEMENT_LEFT;

				break;

			case (rst_ani->ENGAGEMENT_RIGHT):

				ani->target = Animation::ENGAGEMENT_RIGHT;

				break;

			default:

				ani->target = Animation::IDLE;

				printf("> unhandled animatin target %d\n", (int)rst_ani->animation());

				throw std::runtime_error("AnimationCallback: invalid animation id");

				return;

		}

		ani->repetitions = rst_ani->repetitions();

		ani->duration_each = rst_ani->duration_each();

		ani->scale = rst_ani->emphasis_scale();

		printf("> new Animation: %s\n", ani->as_string().c_str());

		// send to application

		mw->animation_callback(ani);

	}

};

/*

 * This file is part of hlrc_server

 *

 * Copyright(c) sschulz <AT> techfak.uni-bielefeld.de

 * http://opensource.cit-ec.de/projects/hlrc_server

 *

 * This file may be licensed under the terms of the

 * GNU General Public License Version 3 (the ``GPL''),

 * or (at your option) any later version.

 *

 * Software distributed under the License is distributed

 * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either

 * express or implied. See the GPL for the specific language

 * governing rights and limitations.

 *

 * You should have received a copy of the GPL along with this

 * program. If not, go to http://www.gnu.org/licenses/gpl.html

 * or write to the Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 *

 * The development of this software was supported by the

 * Excellence Cluster EXC 277 Cognitive Interaction Technology.

 * The Excellence Cluster EXC 277 is a grant of the Deutsche

 * Forschungsgemeinschaft (DFG) in the context of the German

 * Excellence Initiative.

 *

 */

#pragma once

#include "Middleware.h"

//#include <rst/robot/MouthTarget.pb.h>

#include <rst/animation/EmotionExpression.pb.h>

#include <rst/animation/BinocularHeadGaze.pb.h>

#include <rst/animation/HeadAnimation.pb.h>

#include <rst/audition/Utterance.pb.h>

#include <rst/audition/SoundChunk.pb.h>

#include <rsb/Factory.h>

template <typename T>

class CallbackWrapper : public rsb::patterns::LocalServer::Callback<T, void> {

public:

	CallbackWrapper(Middleware* _mw) {

		mw = _mw;

	}

	~CallbackWrapper() {

	}

	virtual void call(const std::string&, std::shared_ptr<T> param) = 0;

protected:

	Middleware* mw;

};

/*

 * This file is part of hlrc_server

 *

 * Copyright(c) sschulz <AT> techfak.uni-bielefeld.de

 * http://opensource.cit-ec.de/projects/hlrc_server

 *

 * This file may be licensed under the terms of the

 * GNU General Public License Version 3 (the ``GPL''),

 * or (at your option) any later version.

 *

 * Software distributed under the License is distributed

 * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either

 * express or implied. See the GPL for the specific language

 * governing rights and limitations.

 *

 * You should have received a copy of the GPL along with this

 * program. If not, go to http://www.gnu.org/licenses/gpl.html

 * or write to the Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 *

 * The development of this software was supported by the

 * Excellence Cluster EXC 277 Cognitive Interaction Technology.

 * The Excellence Cluster EXC 277 is a grant of the Deutsche

 * Forschungsgemeinschaft (DFG) in the context of the German

 * Excellence Initiative.

 *

 */

#pragma once

#include "CallbackWrapper.h"

// callback handler incoming emotion requests:

class EmotionCallbackWrapper : public CallbackWrapper<rst::animation::EmotionExpression> {

public:

	EmotionCallbackWrapper(Middleware* mw) : CallbackWrapper(mw) {

	}

	void call(const std::string& method_name, std::shared_ptr<rst::animation::EmotionExpression> input) {

		printf("> incoming emotion (%s = %d)\n", method_name.c_str(), (int)input->emotion());

		EmotionState emotion_state;

		rst::animation::EmotionExpression* emotion = input.get();

		// extract data & copy it to our datatype (might be good when we allow multiple middlewares in the feature)

		switch ((int)emotion->emotion()) {

			case (rst::animation::EmotionExpression_Emotion_NEUTRAL):

				emotion_state.value = EmotionConfig::NEUTRAL;

				break;

			case (rst::animation::EmotionExpression_Emotion_HAPPY):

				emotion_state.value = EmotionConfig::HAPPY;

				break;

			case (rst::animation::EmotionExpression_Emotion_SAD):

				emotion_state.value = EmotionConfig::SAD;

				break;

			case (rst::animation::EmotionExpression_Emotion_ANGRY):

				emotion_state.value = EmotionConfig::ANGRY;

				break;

			case (rst::animation::EmotionExpression_Emotion_SURPRISED):

				emotion_state.value = EmotionConfig::SURPRISED;

				break;

			case (rst::animation::EmotionExpression_Emotion_FEAR):

				emotion_state.value = EmotionConfig::FEAR;

				break;

			default:

				printf("> invalid EmotionExpression emotion value. exiting\n");

				exit(EXIT_FAILURE);

		}

		emotion_state.duration = emotion->duration();

		// send to application

		if (method_name == "defaultEmotion") {

			// set default emotion:

			mw->default_emotion_callback(emotion_state);

		}

		else if (method_name == "currentEmotion") {

			// set current emotion:

			mw->current_emotion_callback(emotion_state);

		}

		else {

			printf("> invalid method called '%s'\n", method_name.c_str());

			exit(EXIT_FAILURE);

		}

	}

};

/*

 * This file is part of hlrc_server

 *

 * Copyright(c) sschulz <AT> techfak.uni-bielefeld.de

 * http://opensource.cit-ec.de/projects/hlrc_server

 *

 * This file may be licensed under the terms of the

 * GNU General Public License Version 3 (the ``GPL''),

 * or (at your option) any later version.

 *

 * Software distributed under the License is distributed

 * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either

 * express or implied. See the GPL for the specific language

 * governing rights and limitations.

 *

 * You should have received a copy of the GPL along with this

 * program. If not, go to http://www.gnu.org/licenses/gpl.html

 * or write to the Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 *

 * The development of this software was supported by the

 * Excellence Cluster EXC 277 Cognitive Interaction Technology.

 * The Excellence Cluster EXC 277 is a grant of the Deutsche

 * Forschungsgemeinschaft (DFG) in the context of the German

 * Excellence Initiative.

 *

 */

#pragma once

#include "CallbackWrapper.h"

// callback handler incoming gaze requests:

class GazeCallbackWrapper : public CallbackWrapper<rst::animation::BinocularHeadGaze> {

public:

	GazeCallbackWrapper(Middleware* mw) : CallbackWrapper(mw) {

	}

	void call(const std::string& method_name, std::shared_ptr<rst::animation::BinocularHeadGaze> input) {

		rst::animation::BinocularHeadGaze* gaze = input.get();

		// printf("> incoming gaze (p=%3.1f t=%3.1f r=%3.1f / v=%3.1f)\n", gaze->pan(), gaze->tilt(), gaze->roll(), gaze->vergence());

		humotion::GazeState gaze_state;

		// fill in gaze

		gaze_state.pan = gaze->target().azimuth();

		gaze_state.tilt = gaze->target().elevation();

		gaze_state.roll = 0.0;

		// RSB supports only absolute targets for now...

		gaze_state.timestamp = 123.45; // FIXME!!

		gaze_state.gaze_type = humotion::GazeState::GAZETYPE_ABSOLUTE;

		// vergence

		gaze_state.vergence = (gaze->has_eye_vergence()) ? gaze->eye_vergence() : 0.0;

		// offsets

		gaze_state.pan_offset = (gaze->has_offset()) ? gaze->offset().azimuth() : 0.0;

		gaze_state.tilt_offset = (gaze->has_offset()) ? gaze->offset().elevation() : 0.0;

		// send to application:

		mw->gaze_callback(gaze_state);

	}

};

/*

 * This file is part of hlrc_server

 *

 * Copyright(c) sschulz <AT> techfak.uni-bielefeld.de

 * http://opensource.cit-ec.de/projects/hlrc_server

 *

 * This file may be licensed under the terms of the

 * GNU General Public License Version 3 (the ``GPL''),

 * or (at your option) any later version.

 *

 * Software distributed under the License is distributed

 * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either

 * express or implied. See the GPL for the specific language

 * governing rights and limitations.

 *

 * You should have received a copy of the GPL along with this

 * program. If not, go to http://www.gnu.org/licenses/gpl.html

 * or write to the Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 *

 * The development of this software was supported by the

 * Excellence Cluster EXC 277 Cognitive Interaction Technology.

 * The Excellence Cluster EXC 277 is a grant of the Deutsche

 * Forschungsgemeinschaft (DFG) in the context of the German

 * Excellence Initiative.

 *

 */

#pragma once

#include "CallbackWrapper.h"

#if 0

DISABLED MOUTH TARGET IN RSB FOR NOW

//callback handler incoming gaze requests:

class MouthCallbackWrapper : public CallbackWrapper<rst::robot::MouthTarget>{

    public:

        MouthCallbackWrapper(Middleware *mw) : CallbackWrapper(mw){}

        void call(const std::string& method_name, std::shared_ptr<rst::robot::MouthTarget> input){

            rst::robot::MouthTarget *mouth = input.get();

            humotion::MouthState mouth_state;

            //fill in mouth

            mouth_state.opening_left   = mouth->opening_left();

            mouth_state.opening_center = mouth->opening_center();

            mouth_state.opening_right  = mouth->opening_right();

            mouth_state.position_left   = mouth->position_left();

            mouth_state.position_center = mouth->position_center();

            mouth_state.position_right  = mouth->position_right();

            //send to application:

            mw->mouth_callback(mouth_state);

        }

};

#endif

/*

 * This file is part of hlrc_server

 *

 * Copyright(c) sschulz <AT> techfak.uni-bielefeld.de

 * http://opensource.cit-ec.de/projects/hlrc_server

 *

 * This file may be licensed under the terms of the

 * GNU General Public License Version 3 (the ``GPL''),

 * or (at your option) any later version.

 *

 * Software distributed under the License is distributed

 * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either

 * express or implied. See the GPL for the specific language

 * governing rights and limitations.

 *

 * You should have received a copy of the GPL along with this

 * program. If not, go to http://www.gnu.org/licenses/gpl.html

 * or write to the Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 *

 * The development of this software was supported by the

 * Excellence Cluster EXC 277 Cognitive Interaction Technology.

 * The Excellence Cluster EXC 277 is a grant of the Deutsche

 * Forschungsgemeinschaft (DFG) in the context of the German

 * Excellence Initiative.

 *

 */

#pragma once

#include "CallbackWrapper.h"

// callback handler incoming speech requests:

class SpeechCallbackWrapper : public CallbackWrapper<std::string> {

public:

	SpeechCallbackWrapper(Middleware* mw) : CallbackWrapper(mw) {

	}

	void call(const std::string&, std::shared_ptr<std::string> _text) {

		// send to application

		std::string text = *_text.get();

		//<voice effect=\"Rate(durScale:1.5) + TractScaler(durScale:1.1)\">" +

		text = "<maryxml version=\"0.4\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" "

		       "xmlns=\"http://mary.dfki.de/2002/MaryXML\" xml:lang=\"en_US\">" +

		       text + "</maryxml>";

		mw->speak_callback(text);

	}

};

/*

 * This file is part of hlrc_server

 *

 * Copyright(c) sschulz <AT> techfak.uni-bielefeld.de

 * http://opensource.cit-ec.de/projects/hlrc_server

 *

 * This file may be licensed under the terms of the

 * GNU General Public License Version 3 (the ``GPL''),

 * or (at your option) any later version.

 *

 * Software distributed under the License is distributed

 * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either

 * express or implied. See the GPL for the specific language

 * governing rights and limitations.

 *

 * You should have received a copy of the GPL along with this

 * program. If not, go to http://www.gnu.org/licenses/gpl.html

 * or write to the Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 *

 * The development of this software was supported by the

 * Excellence Cluster EXC 277 Cognitive Interaction Technology.

 * The Excellence Cluster EXC 277 is a grant of the Deutsche

 * Forschungsgemeinschaft (DFG) in the context of the German

 * Excellence Initiative.

 *

 */

#pragma once

#include "CallbackWrapper.h"

#include "UtteranceRSB.h"

// callback handler incoming Utterance requests:

class UtteranceCallbackWrapper : public CallbackWrapper<rst::audition::Utterance> {

public:

	UtteranceCallbackWrapper(Middleware* mw) : CallbackWrapper(mw) {

	}

	void call(const std::string&, std::shared_ptr<rst::audition::Utterance> param) {

		// convert rsb utterance to out own:

		rst::audition::Utterance* rst_utterance = param.get();

		printf("> incoming utterance '%s' (%d phone symbols)\n", param->textual_representation().c_str(),

		       (int)rst_utterance->phonemes().element().size());

		std::shared_ptr<Utterance> utterance(new UtteranceRSB(*rst_utterance));

		// send to application;

		mw->utterance_callback(utterance);

	}

private:

};

/*

 * This file is part of hlrc_server

 *

 * Copyright(c) sschulz <AT> techfak.uni-bielefeld.de

 * http://opensource.cit-ec.de/projects/hlrc_server

 *

 * This file may be licensed under the terms of the

 * GNU General Public License Version 3 (the ``GPL''),

 * or (at your option) any later version.

 *

 * Software distributed under the License is distributed

 * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either

 * express or implied. See the GPL for the specific language

 * governing rights and limitations.

 *

 * You should have received a copy of the GPL along with this

 * program. If not, go to http://www.gnu.org/licenses/gpl.html

 * or write to the Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 *

 * The development of this software was supported by the

 * Excellence Cluster EXC 277 Cognitive Interaction Technology.

 * The Excellence Cluster EXC 277 is a grant of the Deutsche

 * Forschungsgemeinschaft (DFG) in the context of the German

 * Excellence Initiative.

 *

 */

#pragma once

#include "AudioData.h"

#include <rst/audition/SoundChunk.pb.h>

#include <rst/audition/Utterance.pb.h>

using namespace std;

// converter from rsb utterance

class UtteranceRSB : public Utterance {

public:

	UtteranceRSB(rst::audition::Utterance rst_utterance) {

		// set text:

		set_text(rst_utterance.textual_representation());

		// convert soundchunk to audio data:

		extract_audio_data(rst_utterance.audio());

		// convert phonemes:

		extract_phonemes(rst_utterance);

	}

	~UtteranceRSB(){};

	void extract_audio_data(rst::audition::SoundChunk sound_chunk) {

		// cout << sound_chunk.DebugString();

		// extract data:

		unsigned int audio_len = sound_chunk.data().length();

		char* audio_data_char = (char*)sound_chunk.data().c_str();

		// audio.samples = vector<char>(audio_data_char, audio_data_char+audio_len);

		audio_data->samples.resize(audio_len);

		audio_data->samples.assign(audio_data_char, audio_data_char + audio_len);

		printf("audio samplesize is %d bytes\n", (unsigned int)audio_data->samples.size());

		// extract format:

		audio_data->sample_signed = true;

		switch (sound_chunk.sample_type()) {

			case (rst::audition::SoundChunk::SAMPLE_U8):

				audio_data->sample_signed = false; // and fall through:

			case (rst::audition::SoundChunk::SAMPLE_S8):

				audio_data->sample_bit = 8;

				break;

			case (rst::audition::SoundChunk::SAMPLE_U16):

				audio_data->sample_signed = false; // and fall through:

			case (rst::audition::SoundChunk::SAMPLE_S16):

				audio_data->sample_bit = 16;

				break;

			case (rst::audition::SoundChunk::SAMPLE_U24):

				audio_data->sample_signed = false; // and fall through:

			case (rst::audition::SoundChunk::SAMPLE_S24):

				audio_data->sample_bit = 24;

				break;

			default:

				printf("> invalid sample type %d in RST SoundChunk! ignoring request!\n", sound_chunk.sample_type());

				throw runtime_error("UtteranceRSB::convert_audio_data() unsupported sample type in rst::audition::SoundChunk");

		}

		// bitrate

		audio_data->sample_rate = sound_chunk.rate();

		// endianness

		if (sound_chunk.endianness() == rst::audition::SoundChunk::ENDIAN_LITTLE) {

			audio_data->sample_big_endian = false;

		}

		else if (sound_chunk.endianness() == rst::audition::SoundChunk::ENDIAN_BIG) {

			audio_data->sample_big_endian = true;

		}

		else {

			printf("> invalid SoundChunk byte_format");

			throw runtime_error("UtteranceRSB::convert_audio_data() unsupported byte_format in rst::audition::SoundChunk");

		}

		// number of channels

		audio_data->sample_channels = sound_chunk.channels();

		printf("> new AudioData: %s\n", audio_data->to_string().c_str());

	}

	void extract_phonemes(rst::audition::Utterance rst_utterance) {

		// extract phoneme vector

		phonemes_vector.clear();

		for (int i = 0; i < rst_utterance.phonemes().element().size(); i++) {

			rst::audition::Phoneme rst_phoneme = rst_utterance.phonemes().element().Get(i);

			Utterance::symbol_duration_pair_t phoneme = make_pair(rst_phoneme.symbol(), rst_phoneme.duration());

			phonemes_vector.push_back(phoneme);

		}

	}

};

	else if (iequals(audio_output.substr(0, 3), "rsb")) {

#ifdef RSB_SUPPORT

		audio_player = new AudioPlayerRSB(audio_output);

#else

		printf("> ERROR: hlc is compiled without RSB support, RSB audio transport not available, defaulting to libao (default "

		       "output!)\n");

		audio_player = new AudioPlayerLibAO("");

#endif

	}

/*

 * This file is part of hlrc_server

 *

 * Copyright(c) sschulz <AT> techfak.uni-bielefeld.de

 * http://opensource.cit-ec.de/projects/hlrc_server

 *

 * This file may be licensed under the terms of the

 * GNU General Public License Version 3 (the ``GPL''),

 * or (at your option) any later version.

 *

 * Software distributed under the License is distributed

 * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either

 * express or implied. See the GPL for the specific language

 * governing rights and limitations.

 *

 * You should have received a copy of the GPL along with this

 * program. If not, go to http://www.gnu.org/licenses/gpl.html

 * or write to the Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 *

 * The development of this software was supported by the

 * Excellence Cluster EXC 277 Cognitive Interaction Technology.

 * The Excellence Cluster EXC 277 is a grant of the Deutsche

 * Forschungsgemeinschaft (DFG) in the context of the German

 * Excellence Initiative.

 *

 */

#include "AudioPlayerRSB.h"

#ifdef RSB_SUPPORT

#include <rsb/converter/Repository.h>

#include <rsb/converter/ProtocolBufferConverter.h>

#include <rsb/Factory.h>

#include <boost/make_shared.hpp>

using namespace std;

using namespace rsb;

using namespace boost;

// new audio player with gievn device type (default is pulse)

AudioPlayerRSB::AudioPlayerRSB(string driver) : AudioPlayer(driver) {

	assert(driver.length() > 3);

	string scope = driver.substr(3);

	printf("> using rsb for playback, scope = '%s'\n", scope.c_str());

	printf("> registering converters\n");

	rsb::converter::Converter<string>::Ptr soundChunkConverter(

	   new rsb::converter::ProtocolBufferConverter<rst::audition::SoundChunk>());

	rsb::converter::converterRepository<string>()->registerConverter(soundChunkConverter);

	// first get a factory instance that is used to create RSB domain objects

	Factory& factory = getFactory();

	// create informer

	informer = factory.createInformer<rst::audition::SoundChunk>(scope);

	// start audio playback thread:

	playback_thread_ptr = new boost::thread(boost::bind(&AudioPlayerRSB::playback_thread, this));

}

// this will return once we start playing

void AudioPlayerRSB::play(std::shared_ptr<AudioData> _audio_data) {

	audio_data = _audio_data;

	printf("> AudioPlayerRSB: play() %d samples requested\n", (int)audio_data->samples.size());

	// check if we can play this file:

	while (playback_state != IDLE) {

		printf("> player not ready yet, waiting for 10ms\n");

		std::this_thread::sleep_for(std::chrono::milliseconds(10));

	}

	// ok, we can play the audio. copy/setup data:

	// audio_data_ptr = std::shared_ptr<rst::audition::SoundChunk>(boost::make_shared<rst::audition::SoundChunk>(*audio_chunk));

	playback_requested = true;

}

void AudioPlayerRSB::playback_thread() {

	printf("> playback thread started\n");

	playback_state = IDLE;

	while (playback_state != EXITING) {

		switch (playback_state) {

			default:

			case (INITIALIZING):

				// waiting to be ready

				break;

			case (IDLE):

				// nothing to do, wait here until we are triggered to play!

				if (playback_requested) {

					printf("> AudioPlayerRSB: loading\n");

					playback_state = LOADING;

				}

				break;

			case (LOADING):

			{

				// send the data

				try {

					publish_audio_data();

				}

				catch (std::exception e) {

					printf(

					   "> AudioPlayerRSB: WARNING: failed to call informer. audio playback probably failed\n> error message = %s",

					   e.what());

					playback_active = false;

					playback_requested = false;

					playback_state = IDLE;

					break;

				}

				// add some delay to meet the delay until playback starts (FIXME: this should be determined!)

				// std::this_thread::sleep_for(std::chrono::milliseconds(100));

				// ok we can now play the data

				printf("> AudioPlayer: playback started\n");

				// mark request as beeing processed

				playback_requested = false;

				// enter actual playing state

				playback_state = PLAYING;

				playback_active = true;

				// now we have to wait until the audio playback finished....

				long sample_count = audio_data_ptr->sample_count();

				int sampling_rate = audio_data_ptr->rate();

				double playback_time = (double)sample_count / (double)sampling_rate;

				printf("> AudioPlayerRSB estimated playbacktime to %5.3lf seconds. will wait now...", playback_time);

				boost::this_thread::sleep(std::chrono::seconds(playback_time));

				printf("> AudioPlayerRSB finished waiting...\n");

				break;

			}

			case (PLAYING):

				// when we reach this case, the playback finshed

				playback_state = IDLE;

				playback_active = false;

				printf("> AudioPlayerRSB: finished playback");

				break;

			case (ERROR):

				printf("> AudioPlayerRSB ERROR! exiting\n");

				exit(EXIT_FAILURE);

				break;

		}

		// 1ms delay to safe cpu time

		std::this_thread::sleep_for(std::chrono::milliseconds(1));

	}

	// done

	playback_state = CLOSED;

}

void AudioPlayerRSB::publish_audio_data() {

	std::shared_ptr<rst::audition::SoundChunk> request(new rst::audition::SoundChunk());

	request->set_channels(audio_data->sample_channels);

	request->set_data(audio_data->samples.data());

	/*

	    if (audio_data.sample_big_endian){

	        request->set_endianness(rst::audition::SoundChunk_EndianNess_ENDIAN_BIG);

	    }else{

	        request->set_endianness(rst::audition::SoundChunk_EndianNess_ENDIAN_LITTLE);

	    }

	    request->set_rate(audio_data.sample_rate);

	    request->set_sample_count(audio_data.samples.size() / audio_data.sample_channels / (audio_data.sample_bit/8));

	    switch (audio_data.sample_bit){

	        case(8):

	            request->set_sample_type(audio_data.sample_signed?(rst::audition::SoundChunk::SAMPLE_S8):(rst::audition::SoundChunk::SAMPLE_U8));

	            break;

	        case(16):

	            request->set_sample_type(audio_data.sample_signed?(rst::audition::SoundChunk::SAMPLE_S16):(rst::audition::SoundChunk::SAMPLE_U16));

	            break;

	        case(24):

	            request->set_sample_type(audio_data.sample_signed?(rst::audition::SoundChunk::SAMPLE_S24):(rst::audition::SoundChunk::SAMPLE_U24));

	            break;

	        default:

	            throw runtime_error("AudioPlayerRSB::publish_audio_data() unsupported sample type bit width");

	    }

	*/

	informer->publish(request);

}

AudioPlayerRSB::~AudioPlayerRSB() {

}

#endif

/*

 * This file is part of hlrc_server

 *

 * Copyright(c) sschulz <AT> techfak.uni-bielefeld.de

 * http://opensource.cit-ec.de/projects/hlrc_server

 *

 * This file may be licensed under the terms of the

 * GNU General Public License Version 3 (the ``GPL''),

 * or (at your option) any later version.

 *

 * Software distributed under the License is distributed

 * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either

 * express or implied. See the GPL for the specific language

 * governing rights and limitations.

 *

 * You should have received a copy of the GPL along with this

 * program. If not, go to http://www.gnu.org/licenses/gpl.html

 * or write to the Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 *

 * The development of this software was supported by the

 * Excellence Cluster EXC 277 Cognitive Interaction Technology.

 * The Excellence Cluster EXC 277 is a grant of the Deutsche

 * Forschungsgemeinschaft (DFG) in the context of the German

 * Excellence Initiative.

 *

 */

#include "MiddlewareRSB.h"

#ifdef RSB_SUPPORT

#include <rsb/converter/Repository.h>

#include <rsb/converter/ProtocolBufferConverter.h>

#include <cstdio>

// CallbackWrapper:

#include "RSB/GazeCallbackWrapper.h"

#include "RSB/MouthCallbackWrapper.h"

#include "RSB/SpeechCallbackWrapper.h"

#include "RSB/UtteranceCallbackWrapper.h"

#include "RSB/EmotionCallbackWrapper.h"

#include "RSB/AnimationCallbackWrapper.h"

#include "RSB/UtteranceRSB.h"

using namespace std;

using namespace rsb;

using namespace rsb::patterns;

MiddlewareRSB::MiddlewareRSB(Arbiter* arbiter, std::string scope) : Middleware(arbiter, scope) {

	init();

}

MiddlewareRSB::~MiddlewareRSB() {

}

void MiddlewareRSB::tick() {

	// nothing to do

}

void MiddlewareRSB::init() {

	printf("> registering converters\n");

	// converter for EmotionState

	try {

		rsb::converter::Converter<string>::Ptr emotionStateConverter(

		   new rsb::converter::ProtocolBufferConverter<rst::animation::EmotionExpression>());

		rsb::converter::converterRepository<string>()->registerConverter(emotionStateConverter);

	}

	catch (...) {

	}

	// converter for SoundChunk

	try {

		rsb::converter::Converter<string>::Ptr SoundChunkConverter(

		   new rsb::converter::ProtocolBufferConverter<rst::audition::SoundChunk>());

		rsb::converter::converterRepository<string>()->registerConverter(SoundChunkConverter);

	}

	catch (...) {

	}

	// converter for Utterance

	try {

		rsb::converter::Converter<string>::Ptr UtteranceConverter(

		   new rsb::converter::ProtocolBufferConverter<rst::audition::Utterance>());

		rsb::converter::converterRepository<string>()->registerConverter(UtteranceConverter);

	}

	catch (...) {

	}

	// converter for GazeTarget

	try {

		rsb::converter::Converter<string>::Ptr gazeTargetConverter(

		   new rsb::converter::ProtocolBufferConverter<rst::animation::BinocularHeadGaze>());

		rsb::converter::converterRepository<string>()->registerConverter(gazeTargetConverter);

	}

	catch (...) {

	}

	// converter for MouthTarget

	// rsb::converter::Converter<string>::Ptr mouthTargetConverter(new

	// rsb::converter::ProtocolBufferConverter<rst::robot::MouthTarget>());

	// rsb::converter::converterRepository<string>()->registerConverter(mouthTargetConverter);

	// converter for Animation

	try {

		rsb::converter::Converter<string>::Ptr animationConverter(

		   new rsb::converter::ProtocolBufferConverter<rst::animation::HeadAnimation>());

		rsb::converter::converterRepository<string>()->registerConverter(animationConverter);

	}

	catch (...) {

	}

	// first get a factory instance that is used to create RSB domain objects

	Factory& factory = getFactory();

	// scope to listen on:

	string scope = base_scope + "/set/";

	// get server

	server = factory.createLocalServer(scope);

	// get tts server:

	string tts_scope = base_scope + "/tts_provider";

	printf("> registering remote server on %s\n", tts_scope.c_str());

	tts_server = factory.createRemoteServer(tts_scope);

	// create local server with parallel exec strategy (HACK!)

	rsb::ParticipantConfig config = factory.getDefaultParticipantConfig();

	rsc::runtime::Properties& properties = config.mutableEventReceivingStrategy().mutableOptions();

	properties.set<string>("parallelhandlercalls", "1");

	// now we can create a server with parallel execution:

	server_parallel = factory.createLocalServer(scope, config);

	// this server will now handle/call these methods in multiple threads:

	server_parallel->registerMethod("animation", LocalServer::CallbackPtr(new AnimationCallbackWrapper(this)));

	// initialise callbacks:

	init_callbacks();

	// informer->publish(gaze_target);

	printf("> MiddlewareRSB initialised\n");

}

void MiddlewareRSB::init_callback(string name, LocalServer::CallbackPtr callback_ptr) {

	printf("> init_callback(%s%s)\n", server->getScope()->toString().c_str(), name.c_str());

	server->registerMethod(name, callback_ptr);

}

void MiddlewareRSB::init_callbacks() {

	printf("> registering callbacks (rpc methods)\n");

	init_callback("speech", LocalServer::CallbackPtr(new SpeechCallbackWrapper(this)));

	init_callback("utterance", LocalServer::CallbackPtr(new UtteranceCallbackWrapper(this)));

	init_callback("gaze", LocalServer::CallbackPtr(new GazeCallbackWrapper(this)));

	/// init_callback("mouth",     LocalServer::CallbackPtr(new MouthCallbackWrapper(this)));

	EmotionCallbackWrapper* emotion_cb = new EmotionCallbackWrapper(this);

	init_callback("defaultEmotion", LocalServer::CallbackPtr(emotion_cb));

	init_callback("currentEmotion", LocalServer::CallbackPtr(emotion_cb));

}

// call a tts system to convert a string to an utterance

std::shared_ptr<Utterance> MiddlewareRSB::tts_call(string text) {

	double tts_timeout = 1.0; // seconds. DO NOT CHANGE THIS!

	// build request

	std::shared_ptr<std::string> request(new string(text));

	// try to fetch it asynchronously:

	try {

		RemoteServer::DataFuture<rst::audition::Utterance> future_ptr =

		   tts_server->callAsync<rst::audition::Utterance>("create_utterance", request);

		// try to fetch the result

		std::shared_ptr<rst::audition::Utterance> utterance_ptr = future_ptr.get(tts_timeout);

		// done, return utterance ptr

		std::shared_ptr<Utterance> utterance(new UtteranceRSB(*(utterance_ptr.get())));

		printf("> done. got utterance (text=%s)\n", utterance->get_text().c_str());

		return utterance;

	}

	catch (rsc::threading::FutureTimeoutException e) {

		printf("> error: tts_call timed out after %3.1f seconds.\n", tts_timeout);

	}

	catch (rsc::threading::FutureTaskExecutionException e) {

		printf("> error: tts_call failed: %s\n", e.what());

	}

	printf("> failed... got no utterance\n");

	std::shared_ptr<Utterance> utterance(new Utterance());

	return utterance;

}

#endif