path: root/pico/tts/com_svox_picottsengine.cpp

/*
 * Copyright (C) 2008-2009 SVOX AG, Baslerstr. 30, 8048 Zuerich, Switzerland
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * History:
 * 2009-05-18 -- initial version
 * 2009-06-04 -- updated for new TtsEngine interface
 *
 */

#include <stdio.h>
#include <unistd.h>

#define LOG_TAG "SVOX Pico Engine"

#include <utils/Log.h>
#include <android_runtime/AndroidRuntime.h>
#include <tts/TtsEngine.h>
#include <picoapi.h>
#include <picodefs.h>

using namespace android;

/* adaptation layer defines */
#define PICO_MEM_SIZE       2500000
#define PICO_MIN_RATE       20
/* speaking rate    */
#define PICO_DEF_RATE       100
#define PICO_MAX_RATE       500
#define PICO_MIN_PITCH      50
/* speaking pitch   */
#define PICO_DEF_PITCH      100
#define PICO_MAX_PITCH      200
#define PICO_MIN_VOLUME     0
/* speaking volume  */
#define PICO_DEF_VOLUME     250
#define PICO_MAX_VOLUME     500
/* string constants */
#define MAX_OUTBUF_SIZE     128
const char* PICO_LINGWARE_PATH              = "/sdcard/svox/";
const char* PICO_VOICE_NAME                 = "PicoVoice";
const char* PICO_SPEED_OPEN_TAG             = "<speed level='%d'>";
const char* PICO_SPEED_CLOSE_TAG            = "</speed>";
const char* PICO_PITCH_OPEN_TAG             = "<pitch level='%d'>";
const char* PICO_PITCH_CLOSE_TAG            = "</pitch>";
const char* PICO_VOLUME_OPEN_TAG            = "<volume level='%d'>";
const char* PICO_VOLUME_CLOSE_TAG           = "</volume>";
const char* PICO_PHONEME_OPEN_TAG           = "<phoneme ph=\"%s\">";

/* supported voices     */
const char* picoSupportedLangIso3[]         = { "eng",               "eng",               "deu",               "spa",               "fra",               "ita" };
const char* picoSupportedCountryIso3[]      = { "USA",               "GBR",               "DEU",               "ESP",               "FRA",               "ITA" };
const char* picoSupportedLang[]             = { "en-rUS",           "en-rGB",           "de-rDE",           "es-rES",           "fr-rFR",           "it-rIT" };
const char* picoInternalLang[]              = { "en-US",            "en-GB",            "de-DE",            "es-ES",            "fr-FR",            "it-IT" };
const char* picoInternalTaLingware[]        = { "en-US_ta.bin",     "en-GB_ta.bin",     "de-DE_ta.bin",     "es-ES_ta.bin",     "fr-FR_ta.bin",     "it-IT_ta.bin" };
const char* picoInternalSgLingware[]        = { "en-US_lh0_sg.bin", "en-GB_kh0_sg.bin", "de-DE_gl0_sg.bin", "es-ES_zl0_sg.bin", "fr-FR_nk0_sg.bin", "it-IT_cm0_sg.bin" };
const char* picoInternalUtppLingware[]      = { "en-US_utpp.bin",   "en-GB_utpp.bin",   "de-DE_utpp.bin",   "es-ES_utpp.bin",   "fr-FR_utpp.bin",   "it-IT_utpp.bin" };
const int picoNumSupportedLang              = 6;

/* supported properties */
const char* picoSupportedProperties[]       = { "language", "rate", "pitch", "volume" };
const int picoNumSupportedProperties        = 4;


/* adapation layer global variables */
synthDoneCB_t* picoSynthDoneCBPtr;
void* picoMemArea = NULL;
pico_System     picoSystem = NULL;
pico_Resource   picoTaResource = NULL;
pico_Resource   picoSgResource = NULL;
pico_Resource   picoUtppResource = NULL;
pico_Engine     picoEngine = NULL;
pico_Char* picoTaFileName = NULL;
pico_Char* picoSgFileName = NULL;
pico_Char* picoUtppFileName = NULL;
pico_Char* picoTaResourceName = NULL;
pico_Char* picoSgResourceName = NULL;
pico_Char* picoUtppResourceName = NULL;
int     picoSynthAbort = 0;
char*   picoProp_currLang   = NULL;                 /* current language */
int     picoProp_currRate   = PICO_DEF_RATE;        /* current rate     */
int     picoProp_currPitch  = PICO_DEF_PITCH;       /* current pitch    */
int     picoProp_currVolume = PICO_DEF_VOLUME;      /* current volume   */



/* internal helper functions */

/** checkForLanguage
 *  Check if the requested language is among the supported languages.
 *  @language -  the language to check, either in xx or xx-rYY format
 *  return index of the language, or -1 if not supported.
*/
static int checkForLanguage( const char * language )
{
     int found = -1;                                         /* language not found   */

    /* Verify that the requested locale is a locale that we support.    */
    for (int i = 0; i < picoNumSupportedLang; i++)
    {
        if (strcmp(language, picoSupportedLang[i]) == 0)
        {
            found = i;
            break;
        }
    };
    if (found < 0)
    {
        /* We didn't find an exact match; it may have been specified with only the first 2 characters.
           This could overmatch ISO 639-3 language codes.                                   */
        for (int i = 0; i < picoNumSupportedLang; i++)
        {
            if (strncmp(language, picoSupportedLang[i], 2) == 0)
            {
                found = i;
                break;
            }
        }
        if (found < 0)
        {
            LOGE("TtsEngine::set language called with unsupported language");
        }
    };
    return found;
}


/** cleanResources
 *  Unloads any loaded Pico resources.
*/
static void cleanResources( void )
{
    if (picoEngine)
    {
        pico_disposeEngine( picoSystem, &picoEngine );
        pico_releaseVoiceDefinition(picoSystem, (pico_Char*)PICO_VOICE_NAME);
        picoEngine = NULL;
    }
    if (picoUtppResource)
    {
        pico_unloadResource( picoSystem, &picoUtppResource );
        picoUtppResource = NULL;
    }
    if (picoTaResource)
    {
        pico_unloadResource( picoSystem, &picoTaResource );
        picoTaResource = NULL;
    }
    if (picoSgResource)
    {
        pico_unloadResource( picoSystem, &picoSgResource );
        picoSgResource = NULL;
    }
}


/** cleanFiles
 *  Frees any memory allocated for file and resource strings.
*/
static void cleanFiles( void )
{
    if (picoProp_currLang)
    {
        free(picoProp_currLang);
        picoProp_currLang = NULL;
    }

    if (picoTaFileName)
    {
        free(picoTaFileName);
        picoTaFileName = NULL;
    }

    if (picoSgFileName)
    {
        free(picoSgFileName);
        picoSgFileName = NULL;
    }

    if (picoUtppFileName)
    {
        free(picoUtppFileName);
        picoUtppFileName = NULL;
    }

    if (picoTaResourceName)
    {
        free(picoTaResourceName);
        picoTaResourceName = NULL;
    }

    if (picoSgResourceName)
    {
        free(picoSgResourceName);
        picoSgResourceName = NULL;
    }

    if (picoUtppResourceName)
    {
        free(picoUtppResourceName);
        picoUtppResourceName = NULL;
    }
}

/** doLanguageSwitchFromLangIndex
 *  Switch to requested language. If language is already loaded it returns
 *  immediately, if another language is loaded this will first be unloaded
 *  and the new one then loaded. If no language is loaded the requested will be loaded.
 *  @langIndex -  the index of the language to load, which is guaranteed to be supported.
 *  return TTS_SUCCESS or TTS_FAILURE
 */
static tts_result doLanguageSwitchFromLangIndex(int langIndex)
{
    // if we already have a loaded language, check if it's the same one as requested
    if (picoProp_currLang && (strcmp(picoProp_currLang, picoSupportedLang[langIndex]) == 0))
    {
        LOGI("Language already loaded (%s == %s)", picoProp_currLang, picoSupportedLang[langIndex]);
        return TTS_SUCCESS;
    }

    // not the same language, unload the current one first
    cleanResources();

    // allocate memory for file and resource names
    cleanFiles();
    picoProp_currLang = (char*)malloc(10);
    picoTaFileName = (pico_Char*)malloc(PICO_MAX_DATAPATH_NAME_SIZE + PICO_MAX_FILE_NAME_SIZE);
    picoSgFileName = (pico_Char*)malloc(PICO_MAX_DATAPATH_NAME_SIZE + PICO_MAX_FILE_NAME_SIZE);
    picoUtppFileName = (pico_Char*)malloc(PICO_MAX_DATAPATH_NAME_SIZE + PICO_MAX_FILE_NAME_SIZE);
    picoTaResourceName = (pico_Char*)malloc(PICO_MAX_RESOURCE_NAME_SIZE);
    picoSgResourceName = (pico_Char*)malloc(PICO_MAX_RESOURCE_NAME_SIZE);
    picoUtppResourceName = (pico_Char*)malloc(PICO_MAX_RESOURCE_NAME_SIZE);

    // set path and file names for resource files
    strcpy((char*)picoTaFileName, PICO_LINGWARE_PATH);
    strcat((char*)picoTaFileName, (const char*)picoInternalTaLingware[langIndex]);
    strcpy((char*)picoSgFileName, PICO_LINGWARE_PATH);
    strcat((char*)picoSgFileName, (const char*)picoInternalSgLingware[langIndex]);
    strcpy((char*)picoUtppFileName, PICO_LINGWARE_PATH);
    strcat((char*)picoUtppFileName, (const char*)picoInternalUtppLingware[langIndex]);

    // load text analysis Lingware resource file
    int ret = pico_loadResource(picoSystem, picoTaFileName, &picoTaResource);
    if (PICO_OK != ret)
    {
        LOGE("Failed to load textana resource for %s [%d]", picoSupportedLang[langIndex], ret);
        cleanResources();
        cleanFiles();
        return TTS_FAILURE;
    }

    // load signal generation Lingware resource file
    ret = pico_loadResource(picoSystem, picoSgFileName, &picoSgResource);
    if (PICO_OK != ret)
    {
        LOGE("Failed to load siggen resource for %s [%d]", picoSupportedLang[langIndex], ret);
        cleanResources();
        cleanFiles();
        return TTS_FAILURE;
    }

    // Load utpp Lingware resource file if exists - NOTE: this file is optional
    // and is currently not used. Loading is only attempted for future compatibility.
    // If this file is not present the loading will still succeed.
    ret = pico_loadResource(picoSystem, picoUtppFileName, &picoUtppResource);
    if (PICO_OK != ret && ret != PICO_EXC_CANT_OPEN_FILE)
    {
        LOGE("Failed to load utpp resource for %s [%d]", picoSupportedLang[langIndex], ret);
        cleanResources();
        cleanFiles();
        return TTS_FAILURE;
    }

    // Get text analysis resource name
    ret = pico_getResourceName(picoSystem, picoTaResource, (char*)picoTaResourceName);
    if (PICO_OK != ret)
    {
        LOGE("Failed to get textana resource name for %s [%d]", picoSupportedLang[langIndex], ret);
        cleanResources();
        cleanFiles();
        return TTS_FAILURE;
    }

    // Get signal generation resource name
    ret = pico_getResourceName(picoSystem, picoSgResource, (char*)picoSgResourceName);
    if (PICO_OK == ret && picoUtppResource != NULL)
    {
        // Get utpp resource name - optional: see note above
        ret = pico_getResourceName(picoSystem, picoUtppResource, (char*)picoUtppResourceName);
        if (PICO_OK != ret)
        {
            LOGE("Failed to get utpp resource name for %s [%d]", picoSupportedLang[langIndex], ret);
            cleanResources();
            cleanFiles();
            return TTS_FAILURE;
        }
    }
    if (PICO_OK != ret)
    {
        LOGE("Failed to get siggen resource name for %s [%d]", picoSupportedLang[langIndex], ret);
        cleanResources();
        cleanFiles();
        return TTS_FAILURE;
    }

    // create a voice definition
    ret = pico_createVoiceDefinition(picoSystem, (const pico_Char*)PICO_VOICE_NAME);
    if (PICO_OK != ret)
    {
        LOGE("Failed to create voice for %s [%d]", picoSupportedLang[langIndex], ret);
        cleanResources();
        cleanFiles();
        return TTS_FAILURE;
    }

    // add text analysis resource to voice
    ret = pico_addResourceToVoiceDefinition(picoSystem, (const pico_Char*)PICO_VOICE_NAME, picoTaResourceName);
    if (PICO_OK != ret)
    {
        LOGE("Failed to add textana resource to voice for %s [%d]", picoSupportedLang[langIndex], ret);
        cleanResources();
        cleanFiles();
        return TTS_FAILURE;
    }

    // add signal generation resource to voice
    ret = pico_addResourceToVoiceDefinition(picoSystem, (const pico_Char*)PICO_VOICE_NAME, picoSgResourceName);
    if (PICO_OK == ret && picoUtppResource != NULL)
    {
        // add utpp resource to voice - optional: see note above
        ret = pico_addResourceToVoiceDefinition(picoSystem, (const pico_Char*)PICO_VOICE_NAME, picoUtppResourceName);
        if (PICO_OK != ret)
        {
            LOGE("Failed to add utpp resource to voice for %s [%d]", picoSupportedLang[langIndex], ret);
            cleanResources();
            cleanFiles();
            return TTS_FAILURE;
        }
    }

    if (PICO_OK != ret)
    {
        LOGE("Failed to add siggen resource to voice for %s [%d]", picoSupportedLang[langIndex], ret);
        cleanResources();
        cleanFiles();
        return TTS_FAILURE;
    }

    ret = pico_newEngine(picoSystem, (const pico_Char*)PICO_VOICE_NAME, &picoEngine);
    if (PICO_OK != ret)
    {
        LOGE("Failed to create engine for %s [%d]", picoSupportedLang[langIndex], ret);
        cleanResources();
        cleanFiles();
        return TTS_FAILURE;
    }

    strcpy(picoProp_currLang, picoSupportedLang[langIndex]);

    LOGI("loaded %s successfully", picoProp_currLang);

    return TTS_SUCCESS;
}

/** doLanguageSwitch
 *  Switch to requested language. If language is already loaded it returns
 *  immediately, if another language is loaded this will first be unloaded
 *  and the new one then loaded. If no language is loaded the requested will be loaded.
 *  @language -  the language to check, either in xx or xx-rYY format (i.e "en" or "en-rUS")
 *  return TTS_SUCCESS or TTS_FAILURE
*/
static tts_result doLanguageSwitch(const char* language)
{
    // load new language
    int langIndex = checkForLanguage(language);
    if (langIndex < 0)
    {
        LOGE("Tried to swith to non-supported language %s", language);
        return TTS_FAILURE;
    }
    LOGI("Found supported language %s", picoSupportedLang[langIndex]);

    return doLanguageSwitchFromLangIndex( langIndex );
}

/** doAddProperties
 *  Add <speed>, <pitch> and <volume> tags to text, if the properties have been set to non-default values,
 *  and return the new string.  The calling function is responsible for freeing the returned string.
 *  @str - text to apply tags to
 *  return new string with tags applied
*/
static char* doAddProperties(const char* str)
{
    char* data = NULL;
    int haspitch = 0, hasspeed = 0, hasvol = 0;
    int textlen = strlen(str) + 1;

    if (picoProp_currPitch != PICO_DEF_PITCH)           /* non-default pitch    */
    {
        textlen += strlen(PICO_PITCH_OPEN_TAG) + 5;
        textlen += strlen(PICO_PITCH_CLOSE_TAG);
        haspitch = 1;
    }
    if (picoProp_currRate != PICO_DEF_RATE)             /* non-default rate     */
    {
        textlen += strlen(PICO_SPEED_OPEN_TAG) + 5;
        textlen += strlen(PICO_SPEED_CLOSE_TAG);
        hasspeed = 1;
    }
    if (picoProp_currVolume != PICO_DEF_VOLUME)         /* non-default volume   */
    {
        textlen += strlen(PICO_VOLUME_OPEN_TAG) + 5;
        textlen += strlen(PICO_VOLUME_CLOSE_TAG);
        hasvol = 1;
    }

    data = (char*)malloc(textlen);
    if (!data)
    {
        return NULL;
    }
    memset(data, 0, textlen);                           /* clear it             */
    if (haspitch)
    {
        char* tmp = (char*)malloc(strlen(PICO_PITCH_OPEN_TAG) + strlen(PICO_PITCH_CLOSE_TAG) + 5);
        sprintf(tmp, PICO_PITCH_OPEN_TAG, picoProp_currPitch);
        strcat(data, tmp);
        free(tmp);
    }

    if (hasspeed)
    {
        char* tmp = (char*)malloc(strlen(PICO_SPEED_OPEN_TAG) + strlen(PICO_SPEED_CLOSE_TAG) + 5);
        sprintf(tmp, PICO_SPEED_OPEN_TAG, picoProp_currRate);
        strcat(data, tmp);
        free(tmp);
    }

    if (hasvol)
    {
        char* tmp = (char*)malloc(strlen(PICO_VOLUME_OPEN_TAG) + strlen(PICO_VOLUME_CLOSE_TAG) + 5);
        sprintf(tmp, PICO_VOLUME_OPEN_TAG, picoProp_currVolume);
        strcat(data, tmp);
        free(tmp);
    }

    strcat(data, str);

    if (hasvol)
    {
        strcat(data, PICO_VOLUME_CLOSE_TAG);
    }

    if (hasspeed)
    {
        strcat(data, PICO_SPEED_CLOSE_TAG);
    }

    if (haspitch)
    {
        strcat(data, PICO_PITCH_CLOSE_TAG);
    }

    return data;
}


/* API function implementations */

/** init
 *  Allocates Pico memory block and initializes Pico system.
 *  synthDoneCBPtr - Pointer to callback function which will receive generated samples
 *  return tts_result
*/
tts_result TtsEngine::init( synthDoneCB_t synthDoneCBPtr )
{
    if (synthDoneCBPtr == NULL)
    {
        LOGE("Callback pointer is NULL");
        return TTS_FAILURE;
    }

    picoMemArea = malloc(PICO_MEM_SIZE);
    if (!picoMemArea)
    {
        LOGE("Failed to allocate memory for Pico system");
        return TTS_FAILURE;
    }

    pico_Status ret = pico_initialize(picoMemArea, PICO_MEM_SIZE, &picoSystem);
    if (PICO_OK != ret)
    {
        LOGE("Failed to initialize Pico system");
        free(picoMemArea);
        picoMemArea = NULL;
        return TTS_FAILURE;
    }

    picoSynthDoneCBPtr = synthDoneCBPtr;
    return TTS_SUCCESS;
}


/** shutdown
 *  Unloads all Pico resources; terminates Pico system and frees Pico memory block.
 *  return tts_result
*/
tts_result TtsEngine::shutdown( void )
{
    cleanResources();

    if (picoSystem)
    {
        pico_terminate(&picoSystem);
        picoSystem = NULL;
    }
    if (picoMemArea)
    {
        free(picoMemArea);
        picoMemArea = NULL;
    }

    cleanFiles();

    return TTS_SUCCESS;
}

/** loadLanguage
 *  Load a new language.
 *  @value - language string in xx or xx-rYY format (i.e. "en" or "en-rUS")
 *  @size - size of value
 *  return tts_result
*/
tts_result TtsEngine::loadLanguage( const char * value, const size_t size )
{
    return setProperty("language", value, size);
}

/** setLanguage
 *  Load a new language.
 *  @lang - string with ISO 3 letter language code.
 *  @country - string with ISO 3 letter country code .
 *  @variant - string with language variant for that language and country pair.
 *  return tts_result
 */
tts_result TtsEngine::setLanguage(const char *lang, const char *country, const char *variant) {
    if (lang == NULL) {
        LOGE("TtsEngine::setLanguage called with NULL language");
        return TTS_FAILURE;
    }

    // we look for a match on the language first
    // then we look for a match on the country.
    // if no match on the language:
    //       return an error
    // if match on the language, but no match on the country:
    //       load the language found for the language match
    // if match on the language, and match on the country:
    //       load the language found for the country match

    // find a match on the language
    int langIndex = -1;
    for (int i = 0; i < picoNumSupportedLang; i++)
    {
        if (strcmp(lang, picoSupportedLangIso3[i]) == 0) {
            langIndex = i;
            break;
        }
    }
    if (langIndex < 0) {
        // language isn't supported
        LOGE("TtsEngine::setLanguage called with unsupported language");
        return TTS_FAILURE;
    }

    // find a match on the country
    if (country != NULL) {
        int countryIndex = -1;
        for (int i = langIndex; i < picoNumSupportedLang; i++) {
            if ((strcmp(lang, picoSupportedLangIso3[i]) == 0)
                    && (strcmp(country, picoSupportedCountryIso3[i]) == 0)) {
                countryIndex = i;
                break;
            }
        }

        if (countryIndex < 0)  {
            // we didn't find a match on the country, but we had a match on the language,
            // use that language
            LOGI("TtsEngine::setLanguage found matching language(%s) but not matching country(%s).",
                    lang, country);
        } else {
            // we have a match on the language and the country
            langIndex = countryIndex;
        }
    }

    return doLanguageSwitchFromLangIndex( langIndex );
}


/** getLanguage
 *  Get the currently loaded language - if any.
 *  @value - buffer which will receive value
 *  @iosize - size of value - if value is too small to contain the return string, this will contain the actual size needed
 *  return tts_result
*/
tts_result TtsEngine::getLanguage( char * value, size_t * iosize )
{
    return getProperty("language", value, iosize);
}


/** setProperty
 *  Set property. The supported properties are:  language, rate, pitch and volume.
 *  @property - name of property to set
 *  @value - value to set
 *  @size - size of value
 *  return tts_result
*/
tts_result TtsEngine::setProperty( const char * property, const char * value, const size_t size )
{
    /* Sanity check */
    if (property == NULL)
    {
        LOGE("setProperty called with property NULL");
        return TTS_PROPERTY_UNSUPPORTED;
    }

    if (value == NULL)
    {
        LOGE("setProperty called with value NULL");
        return TTS_VALUE_INVALID;
    }

    if (strncmp(property, "language", 8) == 0)
    {
        // verify it's in correct format
        if (strlen(value) != 2 && strlen(value) != 6)
        {
            LOGE("change language called with incorrect format");
            return TTS_VALUE_INVALID;
        }

        // try to switch to specified language
        if (doLanguageSwitch(value) == TTS_FAILURE)
        {
            LOGE("failed to load language");
            return TTS_FAILURE;
        }
        else
        {
            return TTS_SUCCESS;
        }
    }
    else if (strncmp(property, "rate", 4) == 0)
    {
        int rate = atoi(value);
        if (rate < PICO_MIN_RATE) rate = PICO_MIN_RATE;
        if (rate > PICO_MAX_RATE) rate = PICO_MAX_RATE;
        picoProp_currRate = rate;
        return TTS_SUCCESS;
    }
    else if (strncmp(property, "pitch", 5) == 0)
    {
        int pitch = atoi(value);
        if (pitch < PICO_MIN_PITCH) pitch = PICO_MIN_PITCH;
        if (pitch > PICO_MAX_PITCH) pitch = PICO_MAX_PITCH;
        picoProp_currPitch = pitch;
        return TTS_SUCCESS;
    }
    else if (strncmp(property, "volume", 6) == 0)
    {
        int volume = atoi(value);
        if (volume < PICO_MIN_VOLUME) volume = PICO_MIN_VOLUME;
        if (volume > PICO_MAX_VOLUME) volume = PICO_MAX_VOLUME;
        picoProp_currVolume = volume;
        return TTS_SUCCESS;
    }

    return TTS_PROPERTY_UNSUPPORTED;
}


/** getProperty
 *  Get the property.  Supported properties are:  language, rate, pitch and volume.
 *  @property - name of property to get
 *  @value - buffer which will receive value of property
 *  @iosize - size of value - if size is too small on return this will contain actual size needed
 *  return tts_result
*/
tts_result TtsEngine::getProperty(const char *property, char *value, size_t* iosize)
{
    /* sanity check */
    if (property == NULL)
    {
        LOGE("getProperty called with property NULL");
        return TTS_PROPERTY_UNSUPPORTED;
    }

    if (value == NULL)
    {
        LOGE("getProperty called with value NULL");
        return TTS_VALUE_INVALID;
    }

    if (strncmp(property, "language", 8) == 0)
    {
        if (picoProp_currLang == NULL)
        {
            strcpy(value, "");
        }
        else
        {
            if (*iosize < strlen(picoProp_currLang)+1)
            {
                *iosize = strlen(picoProp_currLang) + 1;
                return TTS_PROPERTY_SIZE_TOO_SMALL;
            }
            strcpy(value, picoProp_currLang);
        }
        return TTS_SUCCESS;
    }
    else if (strncmp(property, "rate", 4) == 0)
    {
        char tmprate[4];
        sprintf(tmprate, "%d", picoProp_currRate);
        if (*iosize < strlen(tmprate)+1)
        {
            *iosize = strlen(tmprate) + 1;
            return TTS_PROPERTY_SIZE_TOO_SMALL;
        }
        strcpy(value, tmprate);
        return TTS_SUCCESS;
    }
    else if (strncmp(property, "pitch", 5) == 0)
    {
        char tmppitch[4];
        sprintf(tmppitch, "%d", picoProp_currPitch);
        if (*iosize < strlen(tmppitch)+1)
        {
            *iosize = strlen(tmppitch) + 1;
            return TTS_PROPERTY_SIZE_TOO_SMALL;
        }
        strcpy(value, tmppitch);
        return TTS_SUCCESS;
    }
    else if (strncmp(property, "volume", 6) == 0)
    {
        char tmpvol[4];
        sprintf(tmpvol, "%d", picoProp_currVolume);
        if (*iosize < strlen(tmpvol)+1)
        {
            *iosize = strlen(tmpvol) + 1;
            return TTS_PROPERTY_SIZE_TOO_SMALL;
        }
        strcpy(value, tmpvol);
        return TTS_SUCCESS;
    }
    else
    {
        LOGE("Unsupported property");
        return TTS_PROPERTY_UNSUPPORTED;
    }
}


/** synthesizeText
 *  Synthesizes a text string.
 *  @text - text to synthesize
 *  @buffer - buffer which will receive generated samples
 *  @bufferSize - size of buffer
 *  @userdata - pointer to user data which will be passed back to callback function
 *  return tts_result
*/
tts_result TtsEngine::synthesizeText(const char *text, int8_t *buffer, size_t bufferSize, void *userdata)
{
    pico_Char* inp = NULL;
    pico_Char* local_text = NULL;
    short outbuf[MAX_OUTBUF_SIZE/2];
    pico_Int16 bytes_sent, bytes_recv, text_remaining, out_data_type;
    pico_Status ret;
    picoSynthAbort = 0;

    if (text == NULL)
    {
        LOGE("synthesizeText called with NULL string");
        return TTS_FAILURE;
    }

    if (buffer == NULL)
    {
        LOGE("synthesizeText called with NULL buffer");
        return TTS_FAILURE;
    }

    /* Add property tags to the string - if any.    */
    local_text = (pico_Char*)doAddProperties(text);
    if (!local_text)
    {
        LOGE("Failed to allocate memory for text string");
        return TTS_FAILURE;
    }

    text_remaining = strlen((const char*)local_text) + 1;

    inp = (pico_Char*)local_text;

    size_t bufused = 0;

    /* synthesis loop   */
    while (text_remaining)
    {
        if (picoSynthAbort)
        {
            ret = pico_resetEngine(picoEngine);
            break;
        }

        /* Feed the text into the engine.   */
        ret = pico_putTextUtf8(picoEngine, inp, text_remaining, &bytes_sent);
        if (ret != PICO_OK)
        {
            LOGE("Error synthesizing string '%s': [%d]", text, ret);
            if (local_text) free(local_text);
            return TTS_FAILURE;
        }

        text_remaining -= bytes_sent;
        inp += bytes_sent;
        do
        {
            if (picoSynthAbort)
            {
                break;
            }
            /* Retrieve the samples and add them to the buffer. */
            ret = pico_getData(picoEngine, (void*)outbuf, MAX_OUTBUF_SIZE, &bytes_recv, &out_data_type);
            if (bytes_recv)
            {
                if ((bufused + bytes_recv) <= bufferSize)
                {
                    memcpy(buffer+bufused, (int8_t*)outbuf, bytes_recv);
                    bufused += bytes_recv;
                }
                else
                {
                    /* The buffer filled; pass this on to the callback function.    */
                    int cbret = picoSynthDoneCBPtr(userdata, 16000, AudioSystem::PCM_16_BIT, 1, buffer, bufused, TTS_SYNTH_PENDING);
                    if (cbret == TTS_CALLBACK_HALT)
                    {
                        LOGI("Halt requested by caller. Halting.");
                        picoSynthAbort = 1;
                        break;
                    }
                    bufused = 0;
                    memcpy(buffer, (int8_t*)outbuf, bytes_recv);
                    bufused += bytes_recv;
                }
            }
        } while (PICO_STEP_BUSY == ret);

        /* The synthesis is finished; notify the caller and pass the remaining samples.
           Use 16 KHz, 16-bit samples.                                              */
        if (!picoSynthAbort)
        {
            picoSynthDoneCBPtr( userdata, 16000, AudioSystem::PCM_16_BIT, 1, buffer, bufused, TTS_SYNTH_DONE);
        }
        picoSynthAbort = 0;

        if (ret != PICO_STEP_IDLE)
        {
            LOGE("Error occurred during synthesis [%d]", ret);
            if (local_text) free(local_text);
            return TTS_FAILURE;
        }
    }

    if (local_text) free(local_text);
    return TTS_SUCCESS;
}


/** synthesizeIpa
 *  Synthesizes a phonetic string in IPA format.
 *  @ipa - phonetic string to synthesize
 *  @buffer - buffer which will receive generated samples
 *  @bufferSize - size of buffer
 *  @userdata - pointer to user data which will be passed back to callback function
 *  return tts_result
*/
tts_result TtsEngine::synthesizeIpa( const char * ipa, int8_t * buffer, size_t bufferSize, void * userdata )
{
    pico_Char*  inp = NULL;
    pico_Char*  local_text = NULL;
    short       outbuf[MAX_OUTBUF_SIZE/2];
    pico_Int16  bytes_sent, bytes_recv, text_remaining, out_data_type;
    pico_Status ret;

    picoSynthAbort = 0;
    if (ipa == NULL)
    {
        LOGE("synthesizeIpa called with NULL string");
        return TTS_FAILURE;
    }

    if (buffer == NULL)
    {
        LOGE("synthesizeIpa called with NULL buffer");
        return TTS_FAILURE;
    }

    /* Append phoneme tag. %%%
       <phoneme ph="xxx"/>  */

    /* Add property tags to the string - if any.    */
    local_text = (pico_Char*)doAddProperties( ipa );
    if (!local_text)
    {
        LOGE("Failed to allocate memory for text string");
        return TTS_FAILURE;
    }

    text_remaining = strlen((const char*)local_text) + 1;

    inp = (pico_Char*)local_text;

    size_t bufused = 0;

    /* synthesis loop   */
    while (text_remaining)
    {
        if (picoSynthAbort)
        {
            ret = pico_resetEngine( picoEngine );
            break;
        }

        /* Feed the text into the engine.   */
        ret = pico_putTextUtf8( picoEngine, inp, text_remaining, &bytes_sent );
        if (ret != PICO_OK)
        {
            LOGE("Error synthesizing string '%s': [%d]", ipa, ret);
            if (local_text) free(local_text);
            return TTS_FAILURE;
        }

        /* Process the remaining string.    */
        text_remaining -= bytes_sent;
        inp += bytes_sent;
        do
        {
            if (picoSynthAbort)
            {
                break;
            }
            /* Retrieve the samples and add them to the buffer. */
            ret = pico_getData( picoEngine, (void*)outbuf, MAX_OUTBUF_SIZE, &bytes_recv, &out_data_type );
            if (bytes_recv)
            {
                if ((bufused + bytes_recv) <= bufferSize)
                {
                    memcpy(buffer+bufused, (int8_t*)outbuf, bytes_recv);
                    bufused += bytes_recv;
                }
                else
                {
                    /* The buffer filled; pass this on to the callback function.    */
                    int cbret = picoSynthDoneCBPtr(userdata, 16000, AudioSystem::PCM_16_BIT, 1, buffer, bufused, TTS_SYNTH_PENDING);
                    if (cbret == TTS_CALLBACK_HALT)
                    {
                        LOGI("Halt requested by caller. Halting.");
                        picoSynthAbort = 1;
                        break;
                    }
                    bufused = 0;
                    memcpy(buffer, (int8_t*)outbuf, bytes_recv);
                    bufused += bytes_recv;
                }
            }
        } while (PICO_STEP_BUSY == ret);

        /* The synthesis is finished; notify the caller and pass the remaining samples.
           Use 16 KHz, 16-bit samples.                                              */
        if (!picoSynthAbort)
        {
            picoSynthDoneCBPtr( userdata, 16000, AudioSystem::PCM_16_BIT, 1, buffer, bufused, TTS_SYNTH_DONE );
        }
        picoSynthAbort = 0;                 /* succeeded    */

        if (ret != PICO_STEP_IDLE)
        {
            LOGE("Error occurred during synthesis [%d]", ret);
            if (local_text) free(local_text);
            return TTS_FAILURE;
        }
    }

    if (local_text)
        free(local_text);
    return TTS_SUCCESS;             /* succeeded    */
}


/** stop
 *  Aborts the running synthesis.
 *  return tts_result
*/
tts_result TtsEngine::stop()
{
    picoSynthAbort = 1;
    return TTS_SUCCESS;
}


#ifdef __cplusplus
extern "C" {
#endif

TtsEngine* getTtsEngine()
{
    return new TtsEngine();
}

#ifdef __cplusplus
}
#endif