hlrc

#pragma once

#include <humotion/gaze_state.h>

class Animation{

public:

    bool active;

    unsigned int repetition_now;

};

#pragma once

#include <string>

#include <humotion/client/client.h>

#include "EmotionState.h"

#include "EmotionConfig.h"

#include "Utterance.h"

#include "AudioPlayer.h"

#include "Animation.h"

class Arbiter{

public:

    humotion::GazeState gaze_state;

    humotion::GazeState gaze_state_old;

    bool gaze_state_animation_restart;

    AudioPlayer *audio_player;

};

#pragma once

#include <string>

#include <boost/shared_ptr.hpp>

#include "AudioData.h"

#pragma once

#include "AudioPlayer.h"

#include <ao/ao.h>

class AudioPlayerLibAO : public AudioPlayer{

public:

    int driver;

};

#pragma once

#include <humotion/client/client.h>

class EmotionConfig{

public:

    //overblend time

    unsigned int overblend_time_ms;

private:

};

#pragma once

#include <string>

#include <vector>

#include "AudioData.h"

class Utterance{

private:

    phonemes_vector_t::iterator phonemes_vector_iterator;

    bool playing;

};

*/

#include "Animation.h"

using namespace std;

Animation::Animation(){

    active = false;

    //Set up end time

    int duration = duration_each * repetitions;

}

bool Animation::is_active(){

    }

    //now check if this animation ended:

    if (now > end_time){

        active = false;

        return;

    }

    //milliseconds from the beginning of this ani:

    float max_elongation = 0.0;

    float profile = 0.0;

#include "AudioPlayerLibAO.h"

#include "AudioPlayerRSB.h"

#include <boost/algorithm/string/predicate.hpp>

using namespace boost;

using namespace std;

void Arbiter::set_default_emotion(EmotionState e){

    //lock access

    //update our config, ignore duration as this is the default emotion

    emotion_config_default.select_config(e.value);

void Arbiter::set_current_emotion(EmotionState e){

    //lock access

    //this will set a emotion override for a given time, after the timeout

    //we will return to the default emotion state:

void Arbiter::set_mouth_config(MouthConfig m){

    //lock access

    mouth_config = m;

}

void Arbiter::set_gaze_target(humotion::GazeState target){

    //lock access

    requested_gaze_state = target;

}

void Arbiter::set_mouth_target(humotion::MouthState target){

    //lock access

    requested_mouth_state = target;

}

void Arbiter::play_animation(boost::shared_ptr<Animation> incoming_animation){

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

    //lock access & iterate over vector:

    active_animation_vector_t::iterator it;

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

        boost::shared_ptr<Animation> current_ani = *it;

void Arbiter::speak(boost::shared_ptr<Utterance> u){ //, ao_sample_format audio_format, char *audio_data, unsigned int audio_len){

    //lock audio playback as such:

    //lock utterance & store data:

    utterance = u;

    scoped_lock.unlock();

    }

    //lock access

    // did the current emotion time out?

        // new incoming target, set up soft fade:

        cout << "NEW EMOTION\n";

        gaze_state_old = gaze_state;

        gaze_state_animation_restart = false;

    }

    // do smooth overblend, all targets should be reached at gaze_state_end_time

        // animation is done, exit now

        return gaze_target;

    } else {

        // do smooth animation

        double tp = 1.0 - diff_ms / static_cast<double>(overblend_time);

        result.pan_offset = gaze_state_old.pan_offset + tp * (gaze_target.pan_offset - gaze_state_old.pan_offset);

void Arbiter::override_by_animation(){

    //lock access & iterate over vector:

    active_animation_vector_t::iterator it;

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

        boost::shared_ptr<Animation> current_ani = *it;

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

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

                break;

            }

*/

#include "EmotionConfig.h"

EmotionConfig::EmotionConfig(){

    select_config(NEUTRAL);

bool EmotionConfig::is_active(){

        return false;

    }

void EmotionConfig::set_duration(unsigned long ms){

    //set a timeout:

}

void EmotionConfig::select_config(EmotionType e){

    mouth_override.position_right  = 11.5250000000000000000;

    mouth_override.opening_right   = 0;//2.412000;

    */

    mouth_override.position_left   = 20;

    mouth_override.opening_left    = 0.0;

    mouth_override.position_center = 22;

    mouth_override.opening_center  = 7.0;

    mouth_override.position_right  = -1+10.5;

    mouth_override.opening_right   = 0.0;*/

    mouth_override.position_left   = 18; //13.56850000000000000000;

    mouth_override.opening_left    = 0; //.791000;

    mouth_override.position_center = 26; //14.18400000000000000000;

    mouth_override.position_right  = 18; //15.31800000000000000000;

    mouth_override.opening_right   = 0; //2.791000;

}

    mouth_override.position_right  = 22.0;

    mouth_override.opening_right   = 0.0;

}

void EmotionConfig::init_fear(){

    //fetch first end time

    symbol_duration_pair_t symbol_duration_pair = *phonemes_vector_iterator;

    printf("> we have %d pairs\n",(int)phonemes_vector.size());

    //empty phoneme list

    if (phonemes_vector.size() == 0) return "";

    while(now > symbol_end_time){

        //fetch next phoneme:

        symbol_duration_pair_t symbol_duration_pair = *phonemes_vector_iterator;

        //printf("time: %d", symbol_duration_pair.second);

        //do we have to increment the iterator or are we done? (NOTE: -1 is necessary here!)

#include <iostream>

#include <stdlib.h>

#include <math.h>

#include <boost/algorithm/string.hpp>

Arbiter *arbiter;

using namespace std;

int main(int argc, char *argv[]) {

    if ((argc != 5) && (argc != 6)){

    //fetch middleware from cmd line

    std::string mw = argv[1];

    //fetch mw for humotion

    std::string mw_humotion = argv[2];

    printf("> all done. hlrc server ready\n");

    while(client->ok()){

        middleware->tick();

        //debug:

        //arbiter->get_mouth_state().dump();

    }

    return EXIT_SUCCESS;

}