hlrc

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

    MouthConfig mouth_config;

    humotion::GazeState requested_gaze_state;

    humotion::MouthState requested_mouth_state;

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

    void animation_callback(boost::shared_ptr<Animation> ani);

protected:

    Arbiter *arbiter;

    void init(){};

    void tick(){};

    }

#else

    ~MiddlewareROS();

    void init();

    void tick();

private:

    //boost::shared_ptr<ros::NodeHandle> node_handle;

    ~MiddlewareRSB(){}

    void init(){};

    void tick(){};

    }

#else

    ~MiddlewareRSB();

    void init();

    void tick();

private:

    void init_callbacks();

        //everything is ok, will be cleared on failures

        feedback.result = 1;

        //copy values:

            feedback.result = 0;

        }

        //send to application;

        mw->utterance_callback(utterance);

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

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

            printf("> incoming utterance '%s' (%d phone symbols)\n", param->text().c_str(), (int)rst_utterance->phonemes().size());

            //send to application;

            mw->utterance_callback(utterance);

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

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

            //extract format:

            switch (sound_chunk.sample_type()){

                default:

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

            }

            //bitrate

        //endianness

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

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

        }else{

            printf("> invalid SoundChunk byte_format");

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

        }

        //number of channels

    }

    void extract_phonemes(rst::audition::Utterance rst_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;

    emotion_config_current.init_sad();

    emotion_config_current.set_duration(2000);

    emotion_config_default.init_neutral();

}

Arbiter::~Arbiter(){

    }

}

    //lock audio playback as such:

    mutex::scoped_lock scoped_lock_audio(audio_player_mutex);

    scoped_lock.unlock();

    //start audio playback, this function returns once we started playback

    //wait until audio playback was finished:

    while(audio_player->is_playing()){

    }

    //in case the audio output fails, we end up here before the utterance is finished.

    //so check now if the utterance finished as well:

        //save some cpu cycles:

        usleep(1*1000); //1ms

    }

void Arbiter::override_by_utterance(){

    //fetch MouthState by utterance:

        //not playing -> return

        return;

    }

    //fetch symbol

    if ((symbol.empty()) || (symbol == "")){

        return;

    }

//this will return once we start playing

    audio_data = audio;

    //skip empty audio data

        printf("> warning: empty audio data - skipped.\n");

        return;

    }

}

    ao_sample_format ao_format;

    //get bits per sample

    //bitrate

    //endianess

    //number of channels

    //format matrix:

    if (ao_format.channels == 1){

                    playback_state = PLAYING;

                    playback_active = true;

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

                }

                break;

//this will return once we start playing

    audio_data = _audio_data;

    //check if we can play this file:

    while(playback_state != IDLE){

void AudioPlayerRSB::publish_audio_data(){

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

/*

    if (audio_data.sample_big_endian){

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

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

}

    //can we speak this now?

    if (arbiter->speak_active()){

}

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

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

    printf("> WARNING: ros tts call not implemented yet\n");

    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

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

        //try to fetch the result

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

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

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

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

    }

    return utterance;

}

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;

}