hlrc

#include <hlrc_server/speechAction.h>

#include <actionlib/client/simple_action_client.h>

#include <actionlib/client/terminal_state.h>

#endif

#define ROS_ACTION_CALL_TIMEOUT 30.0

	rsb::ListenerPtr hack_listener;

	std::mutex pending_tasks_mutex;

	unsigned int say_task_active;

	unsigned int say_task_done;

	void set_current_saytask(std::string text);

	void check_for_inprotk();

#endif

#endif

};

	// create node handle

	// ros_node_handle = new ros::NodeHandle();

	printf("> setting up ROS action clients...\n");

	animation_ac = create_action_client<hlrc_server::animationAction>(scope + "/animation");

}

void MiddlewareRSB::publish_emotion(string scope_target, RobotEmotion e, bool blocking) {

	switch (e.value) {

		default:

}

void MiddlewareRSB::publish_gaze_target(RobotGaze incoming_target, bool blocking) {

	target->set_azimuth(incoming_target.pan);

	target->set_elevation(incoming_target.tilt);

	request->set_allocated_target(target.get());

	request->set_eye_vergence(incoming_target.vergence);

	offset->set_azimuth(incoming_target.pan_offset);

	offset->set_elevation(incoming_target.tilt_offset);

	request->set_allocated_offset(offset.get());

void MiddlewareRSB::publish_mouth_target(RobotMouth target, bool blocking) {

	/*

	    request->set_position_left(  target.position_left);

	    request->set_position_center(target.position_center);

}

void MiddlewareRSB::publish_head_animation(RobotHeadAnimation a, bool blocking) {

	switch (a.value) {

		default:

void MiddlewareRSB::publish_speech(string text, bool blocking) {

	// say it

	if (blocking) {

		hlrc_server->call<std::string>("speech", request);

#pragma once

#include <string>

#include <vector>

#include <mutex>

#include <humotion/client/client.h>

#include "EmotionState.h"

	void set_default_emotion(EmotionState e);

	void set_current_emotion(EmotionState e);

	void set_mouth_config(MouthConfig m);

	bool speak_active();

	void set_gaze_target(humotion::GazeState g);

	void set_mouth_target(humotion::MouthState target);

	humotion::GazeState get_gaze_state();

	humotion::MouthState get_mouth_state();

	MouthConfig mouth_config;

	humotion::GazeState requested_gaze_state;

	humotion::MouthState requested_mouth_state;

	std::mutex animation_mutex;

	Animation active_animation;

	std::mutex active_animation_vector_mutex;

	active_animation_vector_t active_animation_vector;

#pragma once

#include <string>

#include "AudioData.h"

class AudioPlayer {

		CLOSED

	} PLAYBACKSTATE_T;

	bool is_playing();

protected:

	PLAYBACKSTATE_T playback_state;

	std::string audio_driver;

	bool playback_requested;

	~AudioPlayerLibAO();

	void playback_thread();

	bool is_playing();

private:

	boost::thread* playback_thread_ptr;

	// std::vector<char> audio_data;

	~AudioPlayerRSB();

	void playback_thread();

	bool is_playing();

private:

	virtual void tick() = 0;

	void speak_callback(std::string text);

	void gaze_callback(humotion::GazeState gaze);

	void mouth_callback(humotion::MouthState mouth);

	void default_emotion_callback(EmotionState emotion_state);

	void current_emotion_callback(EmotionState emotion_state);

protected:

	Arbiter* arbiter;

#include "ROS/AnimationCallbackWrapperROS.h"

#include "ROS/SpeechCallbackWrapperROS.h"

#endif

#define ROS_ACTION_CALL_TIMEOUT 30.0

	void init(){};

	void tick(){};

	}

#else

	~MiddlewareROS();

	void init();

	void tick();

private:

	ros::NodeHandle* ros_node_handle;

	bool tick_necessary;

	// listen to tf tree

	tf2_ros::Buffer tfBuffer;

	// FIXME: These pointers are never destroyed. Shouldn't they be shared_ptrs?

	AnimationCallbackWrapper* animation_action_server;

	}

	void init(){};

	void tick(){};

	}

#else

	~MiddlewareRSB();

	void init();

	void tick();

private:

	void init_callbacks();

		hlrc_server::animationGoalConstPtr request = goal;

		printf("> incoming animation (%d)\n", (int)request->target);

		// everything is ok, will be cleared on failures

		feedback.result = 1;

		// everything is ok, will be cleared on failures

		feedback.result = 1;

		// copy values:

		utterance->set_text(request->utterance.text);

		if (!extract_audio(request->utterance.audio, audio_data)) {

			feedback.result = 0;

		}

	}

	// convert ros message audio data to our own implementation

		// extract data:

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

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

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

	}

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

		// fetch animation passed by rsb:

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

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

			case (rst_ani->IDLE):

	~CallbackWrapper() {

	}

protected:

	Middleware* mw;

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

	}

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

		EmotionState emotion_state;

public:

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

	}

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

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

    public:

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

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

            humotion::MouthState mouth_state;

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

	}

		// send to application

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

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

public:

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

	}

		// 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());

		// send to application;

		mw->utterance_callback(utterance);

#include <string>

#include <vector>

#include <chrono>

#include "AudioData.h"

class Utterance {

	void set_phoneme_vector(phonemes_vector_t p);

	void set_text(std::string t);

	void start_playback();

	bool is_playing();

	std::string currently_active_phoneme();

	std::string get_text();

protected:

	std::string text;

	phonemes_vector_t phonemes_vector;

	gaze_state_animation_restart = true;

	emotion_target = &emotion_config_default;

}

Arbiter::~Arbiter() {

}

//! note: this is blocking!

	// incoming animation, check if this would conflict with any pending animations:

	// lock access & iterate over vector:

	std::unique_lock<std::mutex> lock_av(active_animation_vector_mutex);

	active_animation_vector_t::iterator it;

	for (it = active_animation_vector.begin(); it < active_animation_vector.end(); it++) {

		// check if the running animation collides with the incoming animation:

		if (current_ani->collides_with(incoming_animation.get())) {

			// this would fail, we can not play this animation right now!

	// ok, it finished. we can safely remove it now:

	lock_av.lock();

	for (it = active_animation_vector.begin(); it < active_animation_vector.end();) {

		if (*it == incoming_animation) {

			// printf(">match -> remove incoming ani again\n");

			it = active_animation_vector.erase(it);

}

void Arbiter::speak(

	// lock audio playback as such:

	const std::lock_guard<std::mutex> lock_audio(audio_player_mutex);

	const std::lock_guard<std::mutex> lock_av(active_animation_vector_mutex);

	active_animation_vector_t::iterator it;

	for (it = active_animation_vector.begin(); it < active_animation_vector.end(); it++) {

		// gaze_state.dump();

		current_ani->apply_on_gazestate(&gaze_state);

}

// this will return once we start playing

	audio_data = audio;

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

	printf("> playback running.\n");

}

	ao_sample_format ao_format;

	// get bits per sample

}

// this will return once we start playing

	audio_data = _audio_data;

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

	}

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

	playback_requested = true;

}

}

void AudioPlayerRSB::publish_audio_data() {

	request->set_channels(audio_data->sample_channels);

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

	printf("> %s(%s) called\n", __FUNCTION__, text.c_str());

	// call a tts system to convert the text to an utterance:

	// and then process it

	utterance_callback(utterance);

}

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

	// can we speak this now?

	arbiter->set_current_emotion(emotion_state);

}

	arbiter->play_animation(ani);

}

}

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

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

	if (tts_ac == NULL) {

	else {

		// done, return utterance ptr

		ttsResultConstPtr tts_res = tts_ac->getResult();

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

		return utterance;

	}

}

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

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

	// build request

	// try to fetch it asynchronously:

	try {

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

		// try to fetch the result

		// done, return utterance ptr

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

		return utterance;

	}

	}

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

	return utterance;

}

#include "Utterance.h"

using namespace std;

#define DEBUG_PRINT_PHONEMES 1

Utterance::Utterance() {

	playing = false;

	text = "UNINITIALISED UTTERANCE";

}

void Utterance::set_phoneme_vector(phonemes_vector_t p) {

	text = t;

}

	audio_data = a;

}

	return text;

}

	return audio_data;

}