hlrc

/*

 * 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 "Arbiter.h"

#include "AudioPlayerLibAO.h"

#include "AudioPlayerRSB.h"

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

#include <mutex>

#include <thread>

#include <iostream>

using namespace boost;

using namespace std;

Arbiter::Arbiter(std::string audio_output) {

        // initialize audio player:

        if (iequals(audio_output, "none")) {

                // allow none for no sound output

                audio_player = NULL;

        }

        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

        }

        else {

                audio_player = new AudioPlayerLibAO(audio_output);

        }

        // set default emotion:

        emotion_config_current.init_sad();

        emotion_config_current.set_duration(2000);

        emotion_config_default.init_neutral();

        gaze_state_animation_restart = true;

        emotion_target = &emotion_config_default;

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

}

Arbiter::~Arbiter() {

}

void Arbiter::set_default_emotion(EmotionState e) {

        // lock access

        const std::lock_guard<std::mutex> lock(emotion_config_default_mutex);

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

        emotion_config_default.select_config(e.value);

        emotion_target = &emotion_config_default;

        gaze_state_animation_restart = true;

        printf("> stored default emotion\n");

}

void Arbiter::set_current_emotion(EmotionState e) {

        // lock access

        const std::lock_guard<std::mutex> lock(emotion_config_current_mutex);

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

        // we will return to the default emotion state:

        emotion_config_current.select_config(e.value);

        emotion_config_current.set_duration(e.duration);

        emotion_target = &emotion_config_current;

        gaze_state_animation_restart = true;

        printf("> stored current emotion (val=%d, duration = %dms)\n", e.value, e.duration);

}

void Arbiter::set_mouth_config(MouthConfig m) {

        // lock access

        const std::lock_guard<std::mutex> lock(mouth_config_override_mutex);

        mouth_config = m;

}

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

        // lock access

        const std::lock_guard<std::mutex> lock(requested_gaze_state_mutex);

        requested_gaze_state = target;

}

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

        // lock access

        const std::lock_guard<std::mutex> lock(requested_mouth_state_mutex);

        requested_mouth_state = target;

}

//! note: this is blocking!

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

        // 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++) {

                std::shared_ptr<Animation> current_ani = *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!

                        throw runtime_error("incoming animation collides with unfinished active animation");

                        return;

                }

        }

        // ok, fine. no other animations are active that would collide with the new request

        // thus it is safe to enqueue this item:

        active_animation_vector.push_back(incoming_animation);

        // unlock mutex

        lock_av.unlock();

        // start playback!

        incoming_animation->start();

        // block until ani was played back

        while (incoming_animation->is_active()) {

                std::this_thread::sleep_for(std::chrono::milliseconds(1)); // save cpu cycles

        }

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

        lock_av.lock();

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

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

                if (*it == incoming_animation) {

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

                        it = active_animation_vector.erase(it);

                }

                else {

                        ++it;

                }

        }

}

void Arbiter::speak(

   std::shared_ptr<Utterance> u) { //, ao_sample_format audio_format, char *audio_data, unsigned int audio_len){

        // lock audio playback as such:

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

        {

                // lock utterance & store data:

                const std::lock_guard<std::mutex> lock(utterance_mutex);

                utterance = u;

        }

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

        if (audio_player == NULL) {

                printf("> audio_player disabled, not speaking '%s'\n", u.get()->get_text().c_str());

        }

        else {

                audio_player->play(utterance->get_audio_data());

        }

        utterance->start_playback();

        // wait until audio playback was finished:

        if (audio_player != NULL) {

                while (audio_player->is_playing()) {

                        // save some cpu cycles:

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

                }

        }

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

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

        while (utterance->is_playing()) {

                // save some cpu cycles:

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

        }

}

bool Arbiter::speak_active() {

        if (audio_player == NULL) {

                return false;

        }

        else {

                return audio_player->is_playing();

        }

}

void Arbiter::arbitrate() {

        // handle arbitration, DO NOT RE-ORDER these calls!

        // try to process all incoming requests

        override_by_emotion();

        // overwrite with mouth targets from outside:

        override_by_mouth();

        // lip animation

        override_by_utterance();

        // animations

        override_by_animation();

        // gaze target is set by requested_gaze_target

        override_by_gaze();

}

void Arbiter::override_by_utterance() {

        // fetch MouthState by utterance:

        if (!utterance->is_playing()) {

                // not playing -> return

                return;

        }

        // fetch symbol

        string symbol = utterance->currently_active_phoneme();

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

                return;

        }

        // fetch config

        mouth_config.init_by_symbol(symbol);

        // overwrite mouth with offsets from utterance player

        mouth_config.apply_on_mouth_state(&mouth_state);

}

void Arbiter::override_by_mouth() {

        // external mouth requests can overwrite the mouth targets!

        if ((requested_mouth_state.position_center + requested_mouth_state.position_left + requested_mouth_state.position_right) >

            0.0) {

                // values given -> override emotion data

                mouth_state = requested_mouth_state;

        }

        // requested_mouth_state.dump();

        // mouth_state.dump();

}

void Arbiter::override_by_gaze() {

        // copy from requested target:

        gaze_state.pan = requested_gaze_state.pan;

        gaze_state.tilt = requested_gaze_state.tilt;

        gaze_state.roll = requested_gaze_state.roll;

        gaze_state.gaze_type = requested_gaze_state.gaze_type;

        gaze_state.timestamp = requested_gaze_state.timestamp;

        gaze_state.vergence = requested_gaze_state.vergence;

        // add offset values from user:

        gaze_state.pan_offset += requested_gaze_state.pan_offset;

        gaze_state.tilt_offset += requested_gaze_state.tilt_offset;

}

void Arbiter::override_by_emotion() {

        if (emotion_target == NULL) {

                return;

        }

        // lock access

        const std::lock_guard<std::mutex> lock1(emotion_config_default_mutex);

        // did the current emotion time out?

        if (!emotion_target->is_active()) {

                // revert to default:

                emotion_target = &emotion_config_default;

                // trigger soft fade

                gaze_state_animation_restart = true;

        }

        // emotions will set the mouth state here (will be overwritten by speak)

        mouth_state = emotion_target->mouth_override;

        // mouth_state = ...

        // emotions will add an offset to the gaze state:

        // pan,tilt,roll will be overwritten by override_by_gaze() we only keep the offset values from this!

        // FIXME: change to eyelid opening  upper/lower once humotion supports it

        // eyebrow angles come from this

        humotion::GazeState gaze_state_target = emotion_target->gaze_override;

        // apply a soft overblending to the new gaze target

        gaze_state = soft_overblend_gaze(gaze_state, gaze_state_target, emotion_target->overblend_time_ms);

        // gaze_state.dump();

        // IMPORTANT: clear request from emotion target:

        emotion_target->gaze_override.eyeblink_request_left = 0;

        emotion_target->gaze_override.eyeblink_request_right = 0;

}

humotion::GazeState Arbiter::soft_overblend_gaze(humotion::GazeState gaze_now, humotion::GazeState gaze_target,

                                                 unsigned int overblend_time) {

        humotion::GazeState result = gaze_now;

        result.eyeblink_request_left = 0;

        result.eyeblink_request_right = 0;

        if (gaze_state_animation_restart) {

                // new incoming target, set up soft fade:

                cout << "NEW EMOTION\n";

                gaze_state_old = gaze_state;

                gaze_state_end_time = std::chrono::steady_clock::now() + std::chrono::milliseconds(overblend_time);

                gaze_state_animation_restart = false;

        }

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

        double diff_ms =

           std::chrono::duration<double, std::milli>(gaze_state_end_time - std::chrono::steady_clock::now()).count();

        if (diff_ms < 0) {

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

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

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

                result.eyelid_opening_lower =

                   gaze_state_old.eyelid_opening_lower + tp * (gaze_target.eyelid_opening_lower - gaze_state_old.eyelid_opening_lower);

                result.eyelid_opening_upper =

                   gaze_state_old.eyelid_opening_upper + tp * (gaze_target.eyelid_opening_upper - gaze_state_old.eyelid_opening_upper);

                result.eyebrow_left = gaze_target.eyebrow_left;

                result.eyebrow_right = gaze_target.eyebrow_right;

        }

        return result;

}

void Arbiter::override_by_animation() {

        // lock access & iterate over vector:

        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++) {

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

                // gaze_state.dump();

                current_ani->apply_on_gazestate(&gaze_state);

                // gaze_state.dump();

        }

}

humotion::GazeState Arbiter::get_gaze_state() {

        // gaze_state.dump();

        return gaze_state;

}

humotion::MouthState Arbiter::get_mouth_state() {

        return mouth_state;

}