S_API s_bool SVoiceDataIsPresent(const SVoice *self, const char *name,
s_erc *error)
{
s_bool key_present;
S_CLR_ERR(error);
if (self == NULL)
{
S_CTX_ERR(error, S_ARGERROR,
"SVoiceDataIsPresent",
"Argument \"self\" is NULL");
return FALSE;
}
if (name == NULL)
{
S_CTX_ERR(error, S_ARGERROR,
"SVoiceDataIsPresent",
"Argument \"name\" is NULL");
return FALSE;
}
key_present = SMapObjectPresent(self->data->dataObjects, name, error);
if (S_CHK_ERR(error, S_CONTERR,
"SVoiceDataIsPresent",
"Call to \"SMapObjectPresent\" failed"))
return FALSE;
return key_present;
}
S_API s_bool SUtteranceFeatureIsPresent(const SUtterance *self, const char *name,
s_erc *error)
{
s_bool feat_present;
S_CLR_ERR(error);
if (self == NULL)
{
S_CTX_ERR(error, S_ARGERROR,
"SUtteranceFeatureIsPresent",
"Argument \"self\" is NULL");
return FALSE;
}
if (name == NULL)
{
S_CTX_ERR(error, S_ARGERROR,
"SUtteranceFeatureIsPresent",
"Argument \"name\" is NULL");
return FALSE;
}
feat_present = SMapObjectPresent(self->features, name, error);
if (S_CHK_ERR(error, S_CONTERR,
"SUtteranceFeatureIsPresent",
"Call to \"SMapObjectPresent\" failed"))
return FALSE;
return feat_present;
}
static const char* setSentenceType(const SItem *phrase, SMap *puncMap, s_erc *error)
{
S_CLR_ERR(error);
const char* result = NULL;
/* types: "decl, "excl", "interrog" */
/* stop at sentence's last token */
const SItem *wordFromCurrentPhrase = SItemPathToItem(phrase, "daughtern", error);
if (S_CHK_ERR(error, S_CONTERR,
"setSentenceType",
"Call to \"SItemPathToItem\" failed"))
return NULL;
SItem *wordAsToken = SItemAs(wordFromCurrentPhrase, "Token", error);
if (S_CHK_ERR(error, S_CONTERR,
"setSentenceType",
"Call to \"SItemAs\" failed"))
return NULL;
SItem *tokenItem = SItemParent(wordAsToken, error);
tokenItem = SItemNext(tokenItem, error);
if (S_CHK_ERR(error, S_CONTERR,
"setSentenceType",
"Call to \"SItemNext\" failed"))
return NULL;
const char *punctStr = SItemGetName(tokenItem, error);
if (S_CHK_ERR(error, S_CONTERR,
"setSentenceType",
"Call to \"SItemGetName\" failed"))
return NULL;
s_bool found= SMapObjectPresent(puncMap, punctStr, error);
if (S_CHK_ERR(error, S_CONTERR,
"setSentenceType",
"Call to \"SMapObjectPresent\" failed"))
return NULL;
result = punctStr;
if( found == TRUE)
{
result = SMapGetString ( puncMap, punctStr, error);
if (S_CHK_ERR(error, S_CONTERR,
"setSentenceType",
"Call to \"SMapGetString\" failed"))
return NULL;
}
else
{
result = NULL;
}
return result;
}
static s_bool searchStringMap(SMap *map, char *str, s_erc *error)
{
S_CLR_ERR(error);
/* Search for the word in the SMap, using it as a Key */
s_bool found= SMapObjectPresent(map, str, error);
if (S_CHK_ERR(error, S_CONTERR,
"searchStringMap",
"Call to \"SMapObjectPresent\" failed"))
return FALSE;
return found;
}
static s_bool UttRelationPresent(const SUtterance *self, const char *name, s_erc *error)
{
s_bool rel_present;
S_CLR_ERR(error);
rel_present = SMapObjectPresent(self->relations, name, error);
if (S_CHK_ERR(error, S_CONTERR,
"UttRelationPresent",
"Call to \"SMapObjectPresent\" failed"))
return FALSE;
return rel_present;
}
static void s_get_phrasing_symbols(const SUttProcessor *uttProc, const char **end_punc,
s_erc *error)
{
s_bool have_symbols;
const SMap *phrasingSymbols;
const char *symbols;
S_CLR_ERR(error);
/* set to default for now */
*end_punc = s_default_phrasing_end_punc_chars;
/* check if symbols are defined */
have_symbols = SUttProcessorFeatureIsPresent(uttProc, "phrasing symbols", error);
if (S_CHK_ERR(error, S_CONTERR,
"s_get_phrasing_symbols",
"Call to \"SUttProcessorFeatureIsPresent\" failed"))
return;
if (!have_symbols)
return; /* no tokenizer symbols defined */
phrasingSymbols = S_CAST(SUttProcessorGetFeature(uttProc, "phrasing symbols", error),
SMap, error);
if (S_CHK_ERR(error, S_CONTERR,
"s_get_phrasing_symbols",
"Failed to get 'phrasing symbols' SMap feature"))
return;
/* check if we have 'end-punctuation' symbols */
have_symbols = SMapObjectPresent(phrasingSymbols, "end-punctuation", error);
if (S_CHK_ERR(error, S_CONTERR,
"s_get_phrasing_symbols",
"Call to \"SMapObjectPresent\" failed"))
return;
if (have_symbols)
{
/* get them and set it in end_punc */
symbols = SObjectGetString(SMapGetObject(phrasingSymbols, "end-punctuation", error),
error);
if (S_CHK_ERR(error, S_CONTERR,
"s_get_phrasing_symbols",
"Failed to get 'end-punctuation' symbols"))
return;
*end_punc = symbols;
}
}
static s_bool InRelation(const SItmContent *self, const char *relation,
s_erc *error)
{
s_bool in_relation;
S_CLR_ERR(error);
in_relation = SMapObjectPresent(self->relations, relation, error);
if (S_CHK_ERR(error, S_CONTERR,
"InRelation",
"Failed to check if relation \"%s\" is in relations map", relation))
return FALSE;
return in_relation;
}
S_API void SVoiceDelData(SVoice *self, const char *key, s_erc *error)
{
s_bool key_present;
S_CLR_ERR(error);
if (self == NULL)
{
S_CTX_ERR(error, S_ARGERROR,
"SVoiceDelData",
"Argument \"self\" is NULL");
return;
}
if (key == NULL)
{
S_CTX_ERR(error, S_ARGERROR,
"SVoiceDelData",
"Argument \"key\" is NULL");
return;
}
/* check if the data is in the configuration */
s_mutex_lock(&self->voice_mutex);
key_present = SMapObjectPresent(self->data->dataObjects, key, error);
if (S_CHK_ERR(error, S_CONTERR,
"SVoiceDelData",
"Call to \"SMapObjectPresent\" failed"))
{
s_mutex_unlock(&self->voice_mutex);
return;
}
if (key_present)
{
/* delete the data and config key */
unload_data_entry(self, key, error);
S_CHK_ERR(error, S_CONTERR,
"SVoiceDelData",
"Call to \"unload_data_entry\" failed");
}
s_mutex_unlock(&self->voice_mutex);
}
S_API void SVoiceDelFeatProc(SVoice *self, const char *key, s_erc *error)
{
s_bool key_present;
S_CLR_ERR(error);
if (self == NULL)
{
S_CTX_ERR(error, S_ARGERROR,
"SVoiceDelFeatProc",
"Argument \"self\" is NULL");
return;
}
if (key == NULL)
{
S_CTX_ERR(error, S_ARGERROR,
"SVoiceDelFeatProc",
"Argument \"key\" is NULL");
return;
}
s_mutex_lock(&self->voice_mutex);
key_present = SMapObjectPresent(self->featProcessors, key, error);
if (S_CHK_ERR(error, S_CONTERR,
"SVoiceDelFeatProc",
"Call to \"SMapObjectPresent\" failed"))
{
s_mutex_unlock(&self->voice_mutex);
return;
}
if (key_present)
SMapObjectDelete(self->featProcessors, key, error);
s_mutex_unlock(&self->voice_mutex);
S_CHK_ERR(error, S_CONTERR,
"SVoiceDelFeatProc",
"Call to \"SMapObjectDelete\" failed");
}
/* setSentenceType should be made out of two parts:
* 1) the first section searchs for the last punctuation element of the sentence
* -> if it is a '.' --> set "decl" type (where should I set this feature value?)
* -> if it is a '!' --> set "excl" type (where should I set this feature value?)
* -> if it is a '?' --> set "interrog" type (where should I set this feature value?)
* 2) if the first part decides for "interrog" type, there should be other controls
* to establish the sentence's complete type
* */
static char* setSentenceType(const SItem *phrase, SMap *prosSymbols, s_erc *error)
{
S_CLR_ERR(error);
char* result = "decl";
/* types: "decl, "excl", "interrog" */
/* stop at sentence's last token */
const SItem *wordFromCurrentPhrase = SItemPathToItem(phrase, "daughter", error);
if (S_CHK_ERR(error, S_CONTERR,
"setSentenceType",
"Call to \"SItemPathToItem\" failed"))
return NULL;
SItem *wordAsToken = SItemAs(wordFromCurrentPhrase, "Token", error);
if (S_CHK_ERR(error, S_CONTERR,
"setSentenceType",
"Call to \"SItemAs\" failed"))
return NULL;
SItem *tokenItem = SItemParent(wordAsToken, error);
SItem *firstTokenItem = tokenItem;
s_bool isPunct = SItemFeatureIsPresent(tokenItem, "IsPunctuation", error);
if (S_CHK_ERR(error, S_CONTERR,
"setSentenceType",
"Call to \"SItemFeatureIsPresent\" failed"))
return NULL;
s_bool isFinalPunct = FALSE;
while (isFinalPunct == FALSE)
{
isPunct = SItemFeatureIsPresent(tokenItem, "IsPunctuation", error);
if (S_CHK_ERR(error, S_CONTERR,
"setSentenceType",
"Call to \"SItemFeatureIsPresent\" failed"))
return NULL;
if (isPunct)
{
const char *punctStr = SItemGetName(tokenItem, error);
if (S_CHK_ERR(error, S_CONTERR,
"setSentenceType",
"Call to \"SItemGetName\" failed"))
return NULL;
if (s_strcmp(punctStr, ".", error) == 0)
{
isFinalPunct = TRUE;
result = "decl";
}
else if (s_strcmp(punctStr, "!", error) == 0)
{
isFinalPunct = TRUE;
result = "excl";
}
else if (s_strcmp(punctStr, "?", error) == 0)
{
isFinalPunct = TRUE;
const char *posValueStr = NULL;
char *posValueStr_filtered = NULL;
s_bool currPosInCurrList;
s_bool have_symbols = FALSE;
SMap* valueMap = NULL;
have_symbols = SMapObjectPresent(prosSymbols, "firstPosInQuestionW", error);
if (S_CHK_ERR(error, S_CONTERR,
"SetSentenceType",
"Call to \"SMapObjectPresent\" failed"))
goto quit_error;
if (have_symbols)
{
valueMap = S_CAST(SMapGetObject(prosSymbols, "firstPosInQuestionW", error), SMap, error);
if (S_CHK_ERR(error, S_CONTERR,
"SetSentenceType",
"Call to \"SMapGetObject\" failed"))
goto quit_error;
}
else
goto quit_error;
posValueStr = SItemGetString(firstTokenItem, "POS", error);
if (S_CHK_ERR(error, S_CONTERR,
"SetSentenceType",
"Call to \"SItemGetString\" failed"))
goto quit_error;
/* filter the current POS tag, remember to free the memory
* pointed to by 'posValueStr_filtered' pointer
*/
posValueStr_filtered = filterPosTag(posValueStr, error);
if (S_CHK_ERR(error, S_CONTERR,
"SetSentenceType",
"Call to \"filterPosTag\" failed"))
goto quit_error;
currPosInCurrList = searchStringMap(valueMap, posValueStr_filtered, error);
if (currPosInCurrList == TRUE)
{
result = "interrogW";
}
else
{
result = "interrog";
}
quit_error:
if (posValueStr_filtered)
{
S_FREE(posValueStr_filtered);
}
break;
}
}
tokenItem = SItemNext(tokenItem, error);
if (S_CHK_ERR(error, S_CONTERR,
"setSentenceType",
"Call to \"SItemNext\" failed"))
return NULL;
if(tokenItem == NULL) {
isFinalPunct = TRUE;
}
}
return result;
}
static SObject *Run(const SFeatProcessor *self, const SItem *item,
s_erc *error)
{
SObject *extractedFeat = NULL;
const SItem *itrItem;
sint32 count;
SWordsToNextPuncFeatProc *castSelf = S_CAST(self, SWordsToNextPuncFeatProc, error);
if (S_CHK_ERR(error, S_CONTERR,
"Initialize",
"Call to S_CAST failed"))
goto quit_error;
S_CLR_ERR(error);
if (item == NULL)
return NULL;
itrItem = SItemPathToItem (item, "R:Token.parent", error);
if (S_CHK_ERR(error, S_CONTERR,
"Run",
"Call to \"SItemPathToItem\" failed"))
goto quit_error;
SMap* posPunctuation = S_CAST( SMapGetObject ( castSelf->symbols, "pos punctuation", error ), SMap, error );
if (S_CHK_ERR(error, S_CONTERR,
"Run",
"Call to \"SMapGetObject\" failed"))
goto quit_error;
if (S_CHK_ERR(error, S_CONTERR,
"Run",
"Call to \"S_CAST\" failed"))
goto quit_error;
count = -1;
s_bool found = FALSE;
while (found == FALSE && itrItem != NULL)
{
count++;
s_bool hasPos = SItemFeatureIsPresent ( itrItem, "POS", error);
if (S_CHK_ERR(error, S_CONTERR,
"Run",
"Call to \"SItemFeatureIsPresent\" failed"))
goto quit_error;
if (hasPos)
{
const char* keyPos = SItemGetString (itrItem, "POS", error);
if (S_CHK_ERR(error, S_CONTERR,
"Run",
"Call to \"SItemGetString\" failed"))
goto quit_error;
found= SMapObjectPresent(posPunctuation, keyPos, error);
if (S_CHK_ERR(error, S_CONTERR,
"Run",
"Call to \"SMapObjectPresent\" failed"))
goto quit_error;
}
itrItem = SItemNext(itrItem, error);
if (S_CHK_ERR(error, S_CONTERR,
"Run",
"Call to \"SItemNext\" failed"))
goto quit_error;
}
extractedFeat = SObjectSetInt(count, error);
if (S_CHK_ERR(error, S_CONTERR,
"Run",
"Call to \"SObjectSetInt\" failed"))
goto quit_error;
/* all OK here */
return extractedFeat;
S_UNUSED(self);
/* error cleanup */
quit_error:
if (extractedFeat != NULL)
S_DELETE(extractedFeat, "Run", error);
return NULL;
}
S_LOCAL void _s_load_voice_utterance_processors(const SMap *voiceConfig, SVoice *voice, s_erc *error)
{
SMap *uttProcessors;
const SObject *tmp;
const SMap *voiceConfigUttProcessors;
s_bool key_present;
SIterator *itr;
const char *uttproc_name;
const char *uttproc_class;
const char *uttproc_plugin;
const SMap *uttProcInfo;
const SMap *uttProcFeats;
SUttProcessor *uProcessor;
SPlugin *plugin;
SList *uttProcPlugins;
S_CLR_ERR(error);
/* create a map container for utterance-processors */
uttProcessors = S_MAP(S_NEW(SMapList, error));
if (S_CHK_ERR(error, S_CONTERR,
"_s_load_voice_utterance_processors",
"Failed to create new map for voice utterance-processors"))
return;
/* look for "utterance-processors" key in voiceConfig map */
key_present = SMapObjectPresent(voiceConfig, "utterance-processors", error);
if (S_CHK_ERR(error, S_CONTERR,
"_s_load_voice_utterance_processors",
"Call to \"SMapObjectPresent\" failed for \'utterance-processors\' key"))
{
S_DELETE(uttProcessors, "_s_load_voice_utterance_processors", error);
return;
}
if (!key_present)
{
/* no defined utterance-processors */
voice->uttProcessors = uttProcessors;
return;
}
/* get utterance-processors from voiceConfig */
tmp = SMapGetObject(voiceConfig, "utterance-processors", error);
if (S_CHK_ERR(error, S_CONTERR,
"_s_load_voice_utterance_processors",
"Call to \"SMapGetObject\" failed"))
{
S_DELETE(uttProcessors, "_s_load_voice_utterance_processors", error);
return;
}
voiceConfigUttProcessors = S_CAST(tmp, SMap, error);
if (S_CHK_ERR(error, S_CONTERR,
"_s_load_voice_utterance_processors",
"Call to \"S_CAST (SMap)\" failed for \'utterance-processors\' object"))
{
S_DELETE(uttProcessors, "_s_load_voice_utterance_processors", error);
return;
}
/*
* iterate through the voiceConfigUttProcessors, create the
* utterance-processors and add their features (if any), and add
* them to the uttProcessors map
*/
itr = S_ITERATOR_GET(voiceConfigUttProcessors, error);
if (S_CHK_ERR(error, S_CONTERR,
"_s_load_voice_utterance_processors",
"Call to \"S_ITERATOR_GET\" failed"))
{
S_DELETE(uttProcessors, "_s_load_voice_utterance_processors", error);
return;
}
if (itr)
{
/* create a plug-in list */
uttProcPlugins = S_LIST(S_NEW(SListList, error));
if (S_CHK_ERR(error, S_CONTERR,
"_s_load_voice_utterance_processors",
"Failed to create new list for voice utterance-processor plug-ins"))
{
S_DELETE(itr, "_s_load_voice_utterance_processors", error);
S_DELETE(uttProcessors, "_s_load_voice_utterance_processors", error);
return;
}
}
else
uttProcPlugins = NULL;
while (itr)
{
/* the utterance-processor name */
uttproc_name = SIteratorKey(itr, error);
if (S_CHK_ERR(error, S_CONTERR,
"_s_load_voice_utterance_processors",
"Call to \"SIteratorKey\" failed"))
{
S_DELETE(itr, "_s_load_voice_utterance_processors", error);
S_DELETE(uttProcessors, "_s_load_voice_utterance_processors", error);
S_DELETE(uttProcPlugins, "_s_load_voice_utterance_processors", error);
return;
}
/* the utterance-processor info (SMap) */
tmp = SIteratorObject(itr, error);
if (S_CHK_ERR(error, S_CONTERR,
"_s_load_voice_utterance_processors",
"Call to \"SIteratorObject\" failed"))
{
S_DELETE(itr, "_s_load_voice_utterance_processors", error);
S_DELETE(uttProcessors, "_s_load_voice_utterance_processors", error);
S_DELETE(uttProcPlugins, "_s_load_voice_utterance_processors", error);
return;
}
uttProcInfo = S_CAST(tmp, SMap, error);
if (S_CHK_ERR(error, S_CONTERR,
"_s_load_voice_utterance_processors",
"Call to \"S_CAST (SMap)\" failed for utterance-processor \'%s\'",
uttproc_name))
{
S_DELETE(itr, "_s_load_voice_utterance_processors", error);
S_DELETE(uttProcessors, "_s_load_voice_utterance_processors", error);
S_DELETE(uttProcPlugins, "_s_load_voice_utterance_processors", error);
return;
}
/*
* uttProcInfo must have "class" and "plug-in" and
* optionally "features"
*/
uttproc_class = SMapGetString(uttProcInfo, "class", error);
if (S_CHK_ERR(error, S_CONTERR,
"_s_load_voice_utterance_processors",
"Call to \"SMapGetString\" failed for \'class\' name of utterance-processor \'%s\'",
uttproc_name))
{
S_DELETE(itr, "_s_load_voice_utterance_processors", error);
S_DELETE(uttProcessors, "_s_load_voice_utterance_processors", error);
S_DELETE(uttProcPlugins, "_s_load_voice_utterance_processors", error);
return;
}
uttproc_plugin = SMapGetString(uttProcInfo, "plug-in", error);
if (S_CHK_ERR(error, S_CONTERR,
"_s_load_voice_utterance_processors",
"Call to \"SMapGetString\" failed for \'plug-in\' name of utterance-processor \'%s\'",
uttproc_name))
{
S_DELETE(itr, "_s_load_voice_utterance_processors", error);
S_DELETE(uttProcessors, "_s_load_voice_utterance_processors", error);
S_DELETE(uttProcPlugins, "_s_load_voice_utterance_processors", error);
return;
}
/*
* load the plug-in, add it to the list of utterance-processor plug-ins and create
* the utterance-processor object
*/
plugin = s_pm_load_plugin(uttproc_plugin, error);
if (S_CHK_ERR(error, S_CONTERR,
"_s_load_voice_utterance_processors",
"Call to \"s_pm_load_plugin\" failed for utterance-processor \'%s\'",
uttproc_name))
{
S_DELETE(itr, "_s_load_voice_utterance_processors", error);
S_DELETE(uttProcessors, "_s_load_voice_utterance_processors", error);
S_DELETE(uttProcPlugins, "_s_load_voice_utterance_processors", error);
return;
}
SListPush(uttProcPlugins, S_OBJECT(plugin), error);
if (S_CHK_ERR(error, S_CONTERR,
"_s_load_voice_utterance_processors",
"Call to \"SListPush\" failed for utterance-processor plug-ins"))
{
S_DELETE(plugin, "_s_load_voice_utterance_processors", error);
S_DELETE(itr, "_s_load_voice_utterance_processors", error);
S_DELETE(uttProcessors, "_s_load_voice_utterance_processors", error);
S_DELETE(uttProcPlugins, "_s_load_voice_utterance_processors", error);
return;
}
uProcessor = S_UTTPROCESSOR(S_NEW_FROM_NAME(uttproc_class, error));
if (S_CHK_ERR(error, S_CONTERR,
"_s_load_voice_utterance_processors",
"Failed to create new utterance-processor of class \'%s\'",
uttproc_class))
{
S_DELETE(itr, "_s_load_voice_utterance_processors", error);
S_DELETE(uttProcessors, "_s_load_voice_utterance_processors", error);
S_DELETE(uttProcPlugins, "_s_load_voice_utterance_processors", error);
return;
}
/* add the utterance-processor to the map of utterance-processors */
SMapSetObject(uttProcessors, uttproc_name, S_OBJECT(uProcessor), error);
if (S_CHK_ERR(error, S_CONTERR,
"_s_load_voice_utterance_processors",
"Call to \"SMapSetObject\" failed"))
{
S_DELETE(uProcessor, "_s_load_voice_utterance_processors", error);
S_DELETE(itr, "_s_load_voice_utterance_processors", error);
S_DELETE(uttProcessors, "_s_load_voice_utterance_processors", error);
S_DELETE(uttProcPlugins, "_s_load_voice_utterance_processors", error);
return;
}
/* Check if this utterance-processor has any defined features */
key_present = SMapObjectPresent(uttProcInfo, "features", error);
if (S_CHK_ERR(error, S_CONTERR,
"_s_load_voice_utterance_processors",
"Call to \"SMapObjectPresent\" failed for \'features\' key of utterance-processor \'%s\'",
uttproc_name))
{
S_DELETE(itr, "_s_load_voice_utterance_processors", error);
S_DELETE(uttProcessors, "_s_load_voice_utterance_processors", error);
S_DELETE(uttProcPlugins, "_s_load_voice_utterance_processors", error);
return;
}
if (key_present)
{
/* get utterance-processors "features" */
tmp = SMapGetObject(uttProcInfo, "features", error);
if (S_CHK_ERR(error, S_CONTERR,
"_s_load_voice_utterance_processors",
"Call to \"SMapGetObject\" failed for \'features\' of utterance-processor \'%s\'",
uttproc_name))
{
S_DELETE(itr, "_s_load_voice_utterance_processors", error);
S_DELETE(uttProcessors, "_s_load_voice_utterance_processors", error);
S_DELETE(uttProcPlugins, "_s_load_voice_utterance_processors", error);
return;
}
uttProcFeats = S_CAST(tmp, SMap, error);
if (S_CHK_ERR(error, S_CONTERR,
"_s_load_voice_utterance_processors",
"Call to \"S_CAST (SMap)\" failed for \'features\' of utterance-processor \'%s\'",
uttproc_name))
{
S_DELETE(itr, "_s_load_voice_utterance_processors", error);
S_DELETE(uttProcessors, "_s_load_voice_utterance_processors", error);
S_DELETE(uttProcPlugins, "_s_load_voice_utterance_processors", error);
return;
}
/* copy them to the utterance-processor */
SMapCopy(uProcessor->features, uttProcFeats, error);
if (S_CHK_ERR(error, S_CONTERR,
"_s_load_voice_utterance_processors",
"Call to \"SMapCopy\" failed for \'features\' of utterance-processor \'%s\'",
uttproc_name))
{
S_DELETE(itr, "_s_load_voice_utterance_processors", error);
S_DELETE(uttProcessors, "_s_load_voice_utterance_processors", error);
S_DELETE(uttProcPlugins, "_s_load_voice_utterance_processors", error);
return;
}
}
/* initialize the utterance processor */
SUttProcessorInit(&uProcessor, voice, error);
if (S_CHK_ERR(error, S_CONTERR,
"_s_load_voice_utterance_processors",
"Call to \"SUttProcessorInit\" failed for utterance-processor of class \'%s\'",
uttproc_class))
{
S_DELETE(itr, "_s_load_voice_utterance_processors", error);
S_DELETE(uttProcessors, "_s_load_voice_utterance_processors", error);
S_DELETE(uttProcPlugins, "_s_load_voice_utterance_processors", error);
return;
}
itr = SIteratorNext(itr);
}
if (uttProcPlugins != NULL)
{
SListMerge(voice->plugins, uttProcPlugins, error);
if (S_CHK_ERR(error, S_CONTERR,
"_s_load_voice_utterance_processors",
"Call to \"SListMerge\" failed"))
{
S_DELETE(uttProcessors, "_s_load_voice_utterance_processors", error);
S_DELETE(uttProcPlugins, "_s_load_voice_utterance_processors", error);
return;
}
S_DELETE(uttProcPlugins, "_s_load_voice_utterance_processors", error);
}
voice->uttProcessors = uttProcessors;
}
static hts_params *get_hts_engine_params(const SMap *features, s_bool *me, s_erc *error)
{
hts_params *engine_params;
const char *tmp;
S_CLR_ERR(error);
engine_params = S_CALLOC(hts_params, 1);
if (engine_params == NULL)
{
S_FTL_ERR(error, S_MEMERROR,
"get_hts_engine_params",
"Failed to allocate memory for 'hts_params' object");
return NULL;
}
engine_params->sampling_rate = (int)SMapGetIntDef(features, "sampling_rate",
SPCT_DEF_SAMPLING_RATE, error);
if (S_CHK_ERR(error, S_CONTERR,
"get_hts_engine_params",
"Call to \"SMapGetIntDef\" failed"))
goto quit_error;
engine_params->fperiod = (int)SMapGetIntDef(features, "fperiod",
SPCT_DEF_FPERIOD, error);
if (S_CHK_ERR(error, S_CONTERR,
"get_hts_engine_params",
"Call to \"SMapGetIntDef\" failed"))
goto quit_error;
engine_params->alpha = (double)SMapGetFloatDef(features, "alpha",
SPCT_DEF_ALPHA, error);
if (S_CHK_ERR(error, S_CONTERR,
"get_hts_engine_params",
"Call to \"SMapGetFloatDef\" failed"))
goto quit_error;
engine_params->stage = (double)SMapGetFloatDef(features, "stage",
SPCT_DEF_STAGE, error);
if (S_CHK_ERR(error, S_CONTERR,
"get_hts_engine_params",
"Call to \"SMapGetFloatDef\" failed"))
goto quit_error;
engine_params->beta = (double)SMapGetFloatDef(features, "beta",
SPCT_DEF_BETA, error);
if (S_CHK_ERR(error, S_CONTERR,
"get_hts_engine_params",
"Call to \"SMapGetFloatDef\" failed"))
goto quit_error;
engine_params->audio_buff_size = (int)SMapGetIntDef(features, "audio_buff_size",
SPCT_DEF_AUDIO_BUFF_SIZE, error);
if (S_CHK_ERR(error, S_CONTERR,
"get_hts_engine_params",
"Call to \"SMapGetIntDef\" failed"))
goto quit_error;
engine_params->uv_threshold = (double)SMapGetFloatDef(features, "uv_threshold",
SPCT_DEF_UV_THRESHOLD, error);
if (S_CHK_ERR(error, S_CONTERR,
"get_hts_engine_params",
"Call to \"SMapGetFloatDef\" failed"))
goto quit_error;
engine_params->gv_weight_lf0 = (double)SMapGetFloatDef(features, "gv_weight_lf0",
SPCT_DEF_GV_WEIGHT_LF0, error);
if (S_CHK_ERR(error, S_CONTERR,
"get_hts_engine_params",
"Call to \"SMapGetFloatDef\" failed"))
goto quit_error;
engine_params->gv_weight_mcp = (double)SMapGetFloatDef(features, "gv_weight_mcp",
SPCT_DEF_GV_WEIGHT_MCP, error);
if (S_CHK_ERR(error, S_CONTERR,
"get_hts_engine_params",
"Call to \"SMapGetFloatDef\" failed"))
goto quit_error;
(*me) = SMapObjectPresent(features, "gv_weight_str", error);
if (S_CHK_ERR(error, S_CONTERR,
"get_hts_engine_params",
"Call to \"SMapObjectPresent\" failed"))
goto quit_error;
if (*me)
{
engine_params->gv_weight_str = (double)SMapGetFloat(features, "gv_weight_str",
error);
if (S_CHK_ERR(error, S_CONTERR,
"get_hts_engine_params",
"Call to \"SMapGetFloat\" failed"))
goto quit_error;
}
/* set "use_log_gain" to FALSE as default */
engine_params->use_log_gain = FALSE;
tmp = SMapGetStringDef(features, "use_log_gain", NULL, error);
if (S_CHK_ERR(error, S_CONTERR,
"get_hts_engine_params",
"Call to \"SMapGetStringDef\" failed"))
goto quit_error;
if (tmp != NULL)
{
int scomp;
scomp = s_strcmp("TRUE", tmp, error);
if (S_CHK_ERR(error, S_CONTERR,
"get_hts_engine_params",
"Call to \"s_strcmp\" failed"))
goto quit_error;
if (scomp == 0)
engine_params->use_log_gain = TRUE;
}
/* all OK, no errors */
return engine_params;
/* error clean up */
quit_error:
S_FREE(engine_params);
return NULL;
}
S_API void SVoiceSetData(SVoice *self, const char *key,
SObject *object, s_erc *error)
{
s_bool key_present;
s_bool vm_loaded_data;
S_CLR_ERR(error);
if (self == NULL)
{
S_CTX_ERR(error, S_ARGERROR,
"SVoiceSetData",
"Argument \"self\" is NULL");
return;
}
if (key == NULL)
{
S_CTX_ERR(error, S_ARGERROR,
"SVoiceSetData",
"Argument \"key\" is NULL");
return;
}
if (object == NULL)
{
S_CTX_ERR(error, S_ARGERROR,
"SVoiceSetData",
"Argument \"object\" is NULL");
return;
}
s_mutex_lock(&self->voice_mutex);
/* check if the data is in the data objects map */
key_present = SMapObjectPresent(self->data->dataObjects, key, error);
if (S_CHK_ERR(error, S_CONTERR,
"SVoiceSetData",
"Call to \"SMapObjectPresent\" failed"))
{
s_mutex_unlock(&self->voice_mutex);
return;
}
if (key_present)
{
/* delete the data and config key */
unload_data_entry(self, key, error);
if (S_CHK_ERR(error, S_CONTERR,
"SVoiceSetData",
"Call to \"unload_data_entry\" failed"))
{
s_mutex_unlock(&self->voice_mutex);
return;
}
}
vm_loaded_data = _s_vm_data_loaded_inc_ref(object, error);
if (S_CHK_ERR(error, S_CONTERR,
"SVoiceSetData",
"Call to \"_s_vm_data_loaded_inc_ref\" failed"))
{
s_mutex_unlock(&self->voice_mutex);
return;
}
if (vm_loaded_data)
{
/* it was loaded previously by vm, just incremented reference
* in _s_vm_data_loaded_inc_ref. Set it in data objects and
* return.
*/
SMapSetObject(self->data->dataObjects, key, object, error);
S_CHK_ERR(error, S_CONTERR,
"SVoiceSetData",
"Call to \"SMapSetObject\" for data '%s' in data config failed",
key); /* data is probably corrupted */
s_mutex_unlock(&self->voice_mutex);
return;
}
/* not previously loaded in voice manager */
SMapSetObject(self->data->dataObjects, key, object, error);
S_CHK_ERR(error, S_CONTERR,
"SVoiceSetData",
"Call to \"SMapSetObject\" failed");
s_mutex_unlock(&self->voice_mutex);
}