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;

    ~MiddlewareRSB(){}

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

    public:

       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):             ani->target = Animation::IDLE; break;

        ~CallbackWrapper(){}

    protected:

        Middleware *mw;

    public:

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

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

           EmotionState emotion_state;

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

    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;

    public:

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

            //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\">" +

                   "</maryxml>";

            mw->speak_callback(text);

        }

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

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

    }

}

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

}

    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{

        RemoteServer::DataFuture<rst::audition::Utterance> future_ptr = 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;

}