hlrc

	utterance.msg

	tts.action

utterance utterance

    #include <actionlib/client/simple_action_client.h>

    #include "hlrc_server/utterance.h"

    #include "hlrc_server/ttsAction.h"

#define ROS_ACTION_CALL_TIMEOUT 30.0

    actionlib::SimpleActionClient<hlrc_server::ttsAction> *tts_ac;

        text = "<maryxml version=\"0.4\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns=\"http://mary.dfki.de/2002/MaryXML\" xml:lang=\"en_US\">" +

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

        utterance->set_text(request->utterance.text);

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

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

           text = "<maryxml version=\"0.4\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns=\"http://mary.dfki.de/2002/MaryXML\" xml:lang=\"en_US\">" +

#include <actionlib/client/simple_action_client.h>

#include "ROS/UtteranceROS.h"

template <typename actionspec>

actionlib::SimpleActionClient<actionspec> * create_action_client(string scope){

    printf("> starting SimpleActionClient on %s\n",scope.c_str());

    actionlib::SimpleActionClient<actionspec> *ac = new actionlib::SimpleActionClient<actionspec>(scope, true);

    if (!ac->waitForServer(ros::Duration(1))){

        char buf[256];

        snprintf(buf, 256, "ERROR: action service %s not ready", scope.c_str());

        throw runtime_error(buf);

    }

    return ac;

}

    //create tts client

    tts_ac = create_action_client<hlrc_server::ttsAction>(base_scope + "/tts_provider");

    hlrc_server::ttsGoal goal;

    goal.text = text;

    //send

    tts_ac->sendGoal(goal);

    //call ros:

    bool finished_before_timeout = tts_ac->waitForResult(ros::Duration(ROS_ACTION_CALL_TIMEOUT));

    if (!finished_before_timeout){

        printf("> ERROR: NO REPLY to utterance action call received within %4.2f s\n",ROS_ACTION_CALL_TIMEOUT);

    }else{

        //done, return utterance ptr

        ttsResultConstPtr tts_res = tts_ac->getResult();

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

        printf("> done. got utterance (text=%s)\n",utterance->get_text().c_str());

        return utterance;

    printf("> failed... got no utterance\n");

        RemoteServer::DataFuture<rst::audition::^> future_ptr = tts_server->callAsync<rst::audition::Utterance>("create_utterance", request);

[h]igh [l]evel [r]obot [c]ontrol client project

=======================

This is the python implementation of the hlrc_client

include DESCRIPTION.rst

# Include the test suite (FIXME: does not work yet)

# recursive-include tests *

# If using Python 2.6 or less, then have to include package data, even though

# it's already declared in setup.py

include hlrc/*.dat

[h]igh [l]evel [r]obot [c]ontrol client project

=======================

This is the python implementation of the hlrc_client

#!/usr/bin/python

"""

This file is part of hlrc

Copyright(c) sschulz <AT> techfak.uni-bielefeld.de

http://opensource.cit-ec.de/projects/hlrc

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.

"""

import logging

import rospy

from hlrc_server.msg import *

import time

import sys

import actionlib

from io import BytesIO

import wave

from MaryTTSClient import *

from cStringIO import StringIO

class MaryTTSBridge(object):

    #_feedback = ttsActionFeedback()

    #_result   = ttsActionResult()

    def __init__(self, topic, voice="cmu-slt-hsmm", locale="en_GB", tts_host="127.0.0.1", tts_port=59125, loglevel=logging.WARNING):

	"""initialise

	:param  loglevel: optional log level

	"""

	self.loglevel = loglevel

	self.logger = logging.getLogger(__name__)

	# create nice and actually usable formatter and add it to the handler

	self.config_logger(loglevel)

	self.logger.info("starting MaryTTSBridge")

	self.tts_client = MaryTTSClient(voice, locale, tts_host, tts_port, loglevel)

	rospy.init_node('MaryTTSBridge')

	self._action_name = topic

	self._as = actionlib.SimpleActionServer(self._action_name, ttsAction, execute_cb = self.execute_cb, auto_start = False)

	self._as.start()

    def __del__(self):

	"""destructor

	"""

	self.logger.debug("destructor of MaryTTSBridge called")

    def config_logger(self, level):

	"""initialise a nice logger formatting

	:param  level: log level

	"""

	formatter = logging.Formatter('%(asctime)s %(name)-30s %(levelname)-8s > %(message)s')

	ch = logging.StreamHandler()

	#ch.setLevel(level)

	ch.setFormatter(formatter)

	self.logger.setLevel(level)

	self.logger.addHandler(ch)

    def create_soundchunk(self, audio_data):

	#extract wave from data

	fio = BytesIO(audio_data)

	wav = wave.open(fio)

	s = soundchunk()

	s.channels = wav.getnchannels()

	s.data = audio_data

	s.endianess = s.ENDIAN_LITTLE #guessed?!

	s.rate = wav.getframerate()

	s.samplecount = wav.getnframes()

	#sample format:

	sample_width = wav.getsampwidth()

	if (sample_width == 1):

	    s.sample_type = s.SAMPLE_U8

	elif (sample_width == 2):

	    s.sample_type = s.SAMPLE_U16

	elif (sample_width == 3):

	    s.sample_type = s.SAMPLE_U24

	else:

	    self.logger.error("ERROR: invalid sample width "+str(sample_width) + " detected")

	    s = soundchunk()

	self.logger.info("created soundchunk with "+str(s.samplecount)+" samples")

	return s

    def create_phonemes(self, phoneme_str):

	last = 0.0

	plist = []

	sio = StringIO(phoneme_str)

	for line in sio:

	    if (line[0] != '#'):

		phoneme_list = line.split(" ")

		symbol = phoneme_list[2]

		symbol = symbol.rstrip()

		now = float(phoneme_list[0])

		duration = (now - last)*1000

		last = now

		plist.append(phoneme(symbol, int(duration)))

	self.logger.info("created phonemelist with " + str(len(plist)) + " elements")

	return plist

    def create_utterance(self, text, audio_data, phoneme_list):

	u = utterance()

	u.text  = text

	u.audio    = self.create_soundchunk(audio_data)

	u.phonemes = self.create_phonemes(phoneme_list)

	self.logger.info("created utterance for 'phonemelist with '" + u.text + "'")

	return u

    def execute_cb(self, goal):

	self.logger.info("incoming utterance '" + goal.text + "'")

	success = True

	result   = ttsResult()

	#incoming msg, ask mary tts for data:

	try:

	    audio     = self.tts_client.generate_audio(goal.text)

	    phonelist = self.tts_client.generate_phonemes(goal.text)

	except:

	    self.logger.error("failed to create utterance error = '" + str(sys.exc_info()[1]) + "'")

	    success = False

	if success:

	    #build soundchunk

	    result.utterance = self.create_utterance(goal.text, audio, phonelist)

	    self._as.set_succeeded(result)

	else:

	    self._as.set_aborted(result)

    def run(self):

	#run the main loop

	rospy.spin()

#test code

if __name__ == "__main__":

    if (len(sys.argv) != 2):

	print("> usage: "+sys.argv[0]+" <topic>\n\n")

	sys.exit(1)

    bridge = MaryTTSBridge(topic=sys.argv[1], loglevel=logging.INFO)

    bridge.run()

"""

This file is part of hlrc

Copyright(c) sschulz <AT> techfak.uni-bielefeld.de

http://opensource.cit-ec.de/projects/hlrc

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.

"""

import logging

#try:

#	import rsb

#except ImportError:

#	RSB_SUPPORT = False

#else:

#	from MiddlewareRSB import *

#	RSB_SUPPORT = True

#from MiddlewareROS import *

import sys

import httplib, urllib

import StringIO

import wave

import ctypes

import wave

import sys

class MaryTTSClient:

    def __init__(self, voice="cmu-slt-hsmm", locale="en_US", tts_host="127.0.0.1", tts_port=59125, loglevel=logging.WARNING):

	"""initialise

	:param  loglevel: optional log level

	"""

	self.loglevel = loglevel

	self.logger = logging.getLogger(__name__)

	# create nice and actually usable formatter and add it to the handler

	self.config_logger(loglevel)

	self.logger.info("starting MaryTTSClient (voice="+voice+", locale="+locale+", host="+tts_host+", port="+str(tts_port))

	self.tts_host = tts_host

	self.tts_port = tts_port

	self.locale   = locale

	self.voice    = voice

    def __del__(self):

	"""destructor

	"""

	self.logger.debug("destructor of MaryTTSClient called")

    def config_logger(self, level):

	"""initialise a nice logger formatting

	:param  level: log level

	"""

	formatter = logging.Formatter('%(asctime)s %(name)-30s %(levelname)-8s > %(message)s')

	ch = logging.StreamHandler()

	#ch.setLevel(level)

	ch.setFormatter(formatter)

	self.logger.setLevel(level)

	self.logger.addHandler(ch)

    def generate_audio(self, message):

	"""generate audio from text

	:param message: text to synthesize

	"""

	return self.generate(message, "AUDIO")

    def generate_phonemes(self, message):

	"""generate phoneme list from text

	:param message: text to synthesize

	"""

	return self.generate(message, "REALISED_DURATIONS")

    def generate(self, message, output_type):

	"""generate requested data object from text

	:param message: text to synthesize

	"""

	raw_params = {

	    "INPUT_TEXT": message,

	    "INPUT_TYPE": "RAWMARYXML",

	    "OUTPUT_TYPE": output_type,

	    "LOCALE": self.locale,

	    "AUDIO": "WAVE_FILE",

	    "VOICE": self.voice,

	}

	params = urllib.urlencode(raw_params)

	headers = {}

	#open connection to mary server

	conn = httplib.HTTPConnection(self.tts_host, self.tts_port)

	#conn.set_debuglevel(5)

	conn.request("POST", "/process", params, headers)

	response = conn.getresponse()

	if response.status != 200:

	    print response.getheaders()

	    raise RuntimeError("{0}: {1}".format(response.status,response.reason))

	return response.read()

#test code

if __name__ == "__main__":

    client = MaryTTSClient()

    audio = client.generate_phonemes("test 1 2 3 4 5 6 7 8 9 10")

    print(audio)

from MaryTTSBridge import MaryTTSBridge

[bdist_wheel]

# This flag says that the code is written to work on both Python 2 and Python

# 3. If at all possible, it is good practice to do this. If you cannot, you

# will need to generate wheels for each Python version that you support.

universal=1

"""[h]igh [l]evel [r]obot [c]ontrol client project

See:

http://opensource.cit-ec.uni-bielefeld.de/hlrc

"""

# Always prefer setuptools over distutils

from setuptools import setup, find_packages

# To use a consistent encoding

from codecs import open

from os import path

here = path.abspath(path.dirname(__file__))

# Get the long description from the relevant file

with open(path.join(here, 'DESCRIPTION.rst'), encoding='utf-8') as f:

    long_description = f.read()

setup(

    name='mary_tts_bridge',

    # Versions should comply with PEP440.  For a discussion on single-sourcing

    # the version across setup.py and the project code, see

    # https://packaging.python.org/en/latest/single_source_version.html

    version='0.1',

    description='mary tts provider bridge',

    long_description=long_description,

    # The project's main homepage.

    url='http://opensource.cit-ec.uni-bielefeld.de/hlrc',

    # Author details

    author='Simon Schulz',

    author_email='sschulz@techfak.uni-bielefeld.de',

    # Choose your license

    license='GPLv3',

    # See https://pypi.python.org/pypi?%3Aaction=list_classifiers

    classifiers=[

        # How mature is this project? Common values are

        #   3 - Alpha

        #   4 - Beta

        #   5 - Production/Stable

        'Development Status :: 3 - Alpha',

        # Indicate who your project is intended for

        'Intended Audience :: Developers',

        'Topic :: Scientific/Engineering',

        # Pick your license as you wish (should match "license" above)

        'License :: OSI Approved :: GNU General Public License v3 (GPLv3)',

        # Specify the Python versions you support here. In particular, ensure

        # that you indicate whether you support Python 2, Python 3 or both.

        'Programming Language :: Python :: 2',

        'Programming Language :: Python :: 2.6',

        'Programming Language :: Python :: 2.7',

        'Programming Language :: Python :: 3',

        'Programming Language :: Python :: 3.2',

        'Programming Language :: Python :: 3.3',

        'Programming Language :: Python :: 3.4',

    ],

    # What does your project relate to?

    keywords='sample setuptools development',

    # You can just specify the packages manually here if your project is

    # simple. Or you can use find_packages().

    packages=find_packages(exclude=['contrib', 'docs', 'tests*']),

    # List run-time dependencies here.  These will be installed by pip when

    # your project is installed. For an analysis of "install_requires" vs pip's

    # requirements files see:

    # https://packaging.python.org/en/latest/requirements.html

    install_requires=[],

    # List additional groups of dependencies here (e.g. development

    # dependencies). You can install these using the following syntax,

    # for example:

    # $ pip install -e .[dev,test]

    extras_require={

        'dev': ['check-manifest'],

        'test': ['coverage'],

    },

    # If there are data files included in your packages that need to be

    # installed, specify them here.  If using Python 2.6 or less, then these

    # have to be included in MANIFEST.in as well.

    package_data={

        #'sample': ['package_data.dat'],

    },

    # Although 'package_data' is the preferred approach, in some case you may

    # need to place data files outside of your packages. See:

    # http://docs.python.org/3.4/distutils/setupscript.html#installing-additional-files # noqa

    # In this case, 'data_file' will be installed into '<sys.prefix>/my_data'

    data_files=[], #('my_data', ['data/data_file'])],

    #scripts=['bin/hlrc_test_gui.py'],

    # To provide executable scripts, use entry points in preference to the

    # "scripts" keyword. Entry points provide cross-platform support and allow

    # pip to create the appropriate form of executable for the target platform.

    entry_points={

        'console_scripts': [

            'mary_tts_provider=mary_tts_bridg.MaryTTSBridge:main',

        ],

    },

)