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::MouthState mouth_state;

	humotion::GazeState gaze_state;

	humotion::GazeState gaze_state_old;

	bool gaze_state_animation_restart;

#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:

#pragma once

#include <humotion/client/client.h>

class EmotionConfig {

public:

	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?

	if (!emotion_target->is_active()) {

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

	// fetch first end time

	symbol_duration_pair_t symbol_duration_pair = *phonemes_vector_iterator;

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

	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;