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.

*

*/

#pragma once

#include "hlrc_server/utteranceAction.h"

#include "CallbackWrapperROS.h"

#include "hlrc_server/phoneme.h"

#include "hlrc_server/soundchunk.h"

//callback handler incoming gaze requests:

class UtteranceCallbackWrapper : CallbackWrapper<hlrc_server::utteranceAction>{

protected:

    hlrc_server::utteranceFeedback feedback;

    hlrc_server::utteranceResult result;

public:

    UtteranceCallbackWrapper(Middleware *mw, std::string scope, std::string name) : CallbackWrapper<hlrc_server::utteranceAction>(mw, scope, name, boost::bind(&UtteranceCallbackWrapper::call, this, _1)){

        //

    };

    void call(const GoalConstPtr &goal){

        hlrc_server::utteranceGoalConstPtr request = goal;

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

        //everything is ok, will be cleared on failures

        feedback.result = 1;

        boost::shared_ptr<Utterance> utterance(new Utterance());

        //copy values:

        utterance->set_text(request->text);

        boost::shared_ptr<AudioData> audio_data(new AudioData());

        if (!extract_audio(request->audio, audio_data)){

            feedback.result = 0;

        }

        utterance->set_audio_data(audio_data);

        utterance->set_phoneme_vector(extract_phoneme_vector(request->phonemes));

        //send to application;

        mw->utterance_callback(utterance);

        if (feedback.result){

            result.result = 1;

            as_.setSucceeded(result);

        }else{

            as_.setAborted(result);

        }

    }

    //convert ros message audio data to our own implementation

    bool extract_audio(hlrc_server::soundchunk sound_chunk, boost::shared_ptr<AudioData> audio_data){

        //extract data:

        unsigned int audio_len = sound_chunk.data.size();

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

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

        audio_data->samples.resize(audio_len);

        audio_data->samples.assign(audio_data_char, audio_data_char+audio_len);

        printf("audio samplesize is %d bytes\n",(int)audio_data->samples.size());

        //extract format:

        audio_data->sample_signed = true;

        switch (sound_chunk.sample_type){

            case(hlrc_server::soundchunk::SAMPLE_U8):  audio_data->sample_signed = false; //and fall through:

            case(hlrc_server::soundchunk::SAMPLE_S8):  audio_data->sample_bit =  8; break;

            case(hlrc_server::soundchunk::SAMPLE_U16): audio_data->sample_signed = false; //and fall through:

            case(hlrc_server::soundchunk::SAMPLE_S16): audio_data->sample_bit = 16; break;

            case(hlrc_server::soundchunk::SAMPLE_U24): audio_data->sample_signed = false; //and fall through:

            case(hlrc_server::soundchunk::SAMPLE_S24): audio_data->sample_bit = 24; break;

            default:

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

                return false;

                //throw runtime_error("UtteranceRSB::convert_audio_data() unsupported sample type in soundchunk");

        }

        //bitrate

        audio_data->sample_rate = sound_chunk.rate;

        //endianness

        if (sound_chunk.endianess == hlrc_server::soundchunk::ENDIAN_LITTLE){

            audio_data->sample_big_endian = false;

        }else if (sound_chunk.endianess == hlrc_server::soundchunk::ENDIAN_BIG){

            audio_data->sample_big_endian = true;

        }else{

            printf("> invalid SoundChunk byte_format");

            throw std::runtime_error("UtteranceRSB::convert_audio_data() unsupported byte_format in soundchunk");

        }

        //number of channels

        audio_data->sample_channels = sound_chunk.channels;

        printf("> new AudioData: %s\n",audio_data->to_string().c_str());

        return true;

    }

    //convert ros phoneme vector to out own implementation

    Utterance::phonemes_vector_t extract_phoneme_vector(std::vector<hlrc_server::phoneme> pv){

        Utterance::phonemes_vector_t result;

        //extract phoneme vector

        for(unsigned int i=0; i<pv.size(); i++){

            hlrc_server::phoneme ros_phoneme = pv[i];

            Utterance::symbol_duration_pair_t phoneme = make_pair(ros_phoneme.symbol, ros_phoneme.duration);

            result.push_back(phoneme);

        }

        return result;

    }

};