#define TTS_TAG_ENGINE_VOICE "voice"
#define TTS_TAG_ENGINE_VOICE_TYPE "type"
#define TTS_TAG_ENGINE_PITCH_SUPPORT "pitch-support"
+#define TTS_TAG_ENGINE_TEXT_SIZE "text-size"
#define TTS_TAG_CONFIG_BASE_TAG "tts-config"
#define TTS_TAG_CONFIG_ENGINE_ID "engine"
#define TTS_TAG_VOICE_TYPE_MALE "male"
#define TTS_TAG_VOICE_TYPE_CHILD "child"
+#define TTS_MAX_TEXT_SIZE 2000
extern char* tts_tag();
static xmlDocPtr g_config_doc = NULL;
+char g_engine_id[128] = {0,};
+char g_setting[128] = {0,};
+char g_language[128] = {0,};
int tts_parser_get_engine_info(const char* path, tts_engine_info_s** engine_info)
{
return -1;
}
+ bool isTextsize = false;
xmlDocPtr doc = NULL;
xmlNodePtr cur = NULL;
xmlChar *key = NULL;
xmlChar *attr = NULL;
- doc = xmlParseFile(path);
- if (doc == NULL) {
+ if (0 == access(path, F_OK)) {
+ SLOG(LOG_DEBUG, tts_tag(), "[DEBUG] Success to access to %s", path);
+ doc = xmlParseFile(path);
+ if (doc == NULL) {
+ SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to parse xml file");
+ return -1;
+ }
+ } else {
+ SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to access to %s", path);
return -1;
}
if (cur == NULL) {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] Empty document");
xmlFreeDoc(doc);
+ doc = NULL;
return -1;
}
if (xmlStrcmp(cur->name, (const xmlChar *)TTS_TAG_ENGINE_BASE_TAG)) {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] The wrong type, root node is NOT 'tts-engine'");
xmlFreeDoc(doc);
+ doc = NULL;
return -1;
}
if (cur == NULL) {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] Empty document");
xmlFreeDoc(doc);
+ doc = NULL;
return -1;
}
if (NULL == temp) {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] Out of memory");
xmlFreeDoc(doc);
+ doc = NULL;
return -1;
}
temp->voices = NULL;
temp->setting = NULL;
temp->pitch_support = false;
+ temp->text_size = 0;
while (cur != NULL) {
if (0 == xmlStrcmp(cur->name, (const xmlChar *)TTS_TAG_ENGINE_NAME)) {
key = xmlNodeGetContent(cur);
if (NULL != key) {
- if (NULL != temp->name) free(temp->name);
+ if (NULL != temp->name) {
+ free(temp->name);
+ temp->name = NULL;
+ }
temp->name = strdup((char*)key);
xmlFree(key);
+ key = NULL;
} else {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] <%s> has no content", TTS_TAG_ENGINE_NAME);
}
} else if (0 == xmlStrcmp(cur->name, (const xmlChar *)TTS_TAG_ENGINE_ID)) {
key = xmlNodeGetContent(cur);
if (NULL != key) {
- if (NULL != temp->uuid) free(temp->uuid);
+ if (NULL != temp->uuid) {
+ free(temp->uuid);
+ temp->uuid = NULL;
+ }
temp->uuid = strdup((char*)key);
xmlFree(key);
+ key = NULL;
} else {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] <%s> has no content", TTS_TAG_ENGINE_ID);
}
} else if (0 == xmlStrcmp(cur->name, (const xmlChar *)TTS_TAG_ENGINE_SETTING)) {
key = xmlNodeGetContent(cur);
if (NULL != key) {
- if (NULL != temp->setting) free(temp->setting);
+ if (NULL != temp->setting) {
+ free(temp->setting);
+ temp->setting = NULL;
+ }
temp->setting = strdup((char*)key);
xmlFree(key);
+ key = NULL;
} else {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] <%s> has no content", TTS_TAG_ENGINE_SETTING);
}
while (NULL != voice_node) {
if (0 == xmlStrcmp(voice_node->name, (const xmlChar *)TTS_TAG_ENGINE_VOICE)) {
-
tts_config_voice_s* temp_voice = (tts_config_voice_s*)calloc(1, sizeof(tts_config_voice_s));
if (NULL == temp_voice) {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] Out of memory");
temp_voice->type = (int)TTS_CONFIG_VOICE_TYPE_USER_DEFINED;
}
xmlFree(attr);
+ attr = NULL;
} else {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] <%s> has no content", TTS_TAG_ENGINE_VOICE_TYPE);
+ free(temp_voice);
+ temp_voice = NULL;
+ continue;
}
key = xmlNodeGetContent(voice_node);
if (NULL != key) {
- if (NULL != temp_voice->language) free(temp_voice->language);
+ if (NULL != temp_voice->language) {
+ free(temp_voice->language);
+ temp_voice->language = NULL;
+ }
temp_voice->language = strdup((char*)key);
xmlFree(key);
+ key = NULL;
temp->voices = g_slist_append(temp->voices, temp_voice);
} else {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] <%s> has no content", TTS_TAG_ENGINE_VOICE);
if (NULL != temp_voice) {
free(temp_voice);
+ temp_voice = NULL;
}
}
}
temp->pitch_support = true;
}
xmlFree(key);
+ key = NULL;
} else {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] <%s> has no content", TTS_TAG_ENGINE_PITCH_SUPPORT);
}
+ } else if (0 == xmlStrcmp(cur->name, (const xmlChar *)TTS_TAG_ENGINE_TEXT_SIZE)) {
+ isTextsize = true;
+ key = xmlNodeGetContent(cur);
+ if (NULL != key) {
+ temp->text_size = atoi((char*)key);
+ xmlFree(key);
+ } else {
+ SLOG(LOG_INFO, tts_tag(), "[INFO] text size is unlimited.");
+ temp->text_size = 0;
+ }
}
cur = cur->next;
}
+ if (false == isTextsize) {
+ temp->text_size = TTS_MAX_TEXT_SIZE;
+ }
+
xmlFreeDoc(doc);
+ doc = NULL;
- if (NULL == temp->name || NULL == temp->uuid) {
+ if (NULL == temp->uuid) {
/* Invalid engine */
SECURE_SLOG(LOG_ERROR, tts_tag(), "[ERROR] Invalid engine : %s", path);
tts_parser_free_engine_info(temp);
return -1;
}
- if (NULL != engine_info->name) free(engine_info->name);
- if (NULL != engine_info->uuid) free(engine_info->uuid);
- if (NULL != engine_info->setting) free(engine_info->setting);
+ if (NULL != engine_info->name) {
+ free(engine_info->name);
+ engine_info->name = NULL;
+ }
+ if (NULL != engine_info->uuid) {
+ free(engine_info->uuid);
+ engine_info->uuid = NULL;
+ }
+ if (NULL != engine_info->setting) {
+ free(engine_info->setting);
+ engine_info->setting = NULL;
+ }
tts_config_voice_s *temp_voice;
temp_voice = g_slist_nth_data(engine_info->voices, 0);
while (NULL != temp_voice) {
if (NULL != temp_voice) {
- if (NULL != temp_voice->language) free(temp_voice->language);
+ if (NULL != temp_voice->language) {
+ free(temp_voice->language);
+ temp_voice->language = NULL;
+ }
engine_info->voices = g_slist_remove(engine_info->voices, temp_voice);
free(temp_voice);
+ temp_voice = NULL;
}
temp_voice = g_slist_nth_data(engine_info->voices, 0);
}
- if (NULL != engine_info) free(engine_info);
+ if (NULL != engine_info) {
+ free(engine_info);
+ engine_info = NULL;
+ }
- return 0;
+ return 0;
}
int tts_parser_print_engine_info(tts_engine_info_s* engine_info)
/* Get a first item */
iter = g_slist_nth(engine_info->voices, 0);
- int i = 1;
+ int i = 1;
while (NULL != iter) {
/*Get handle data from list*/
temp_voice = iter->data;
SLOG(LOG_ERROR, tts_tag(), " Voice is NONE");
}
- SLOG(LOG_DEBUG, tts_tag(), "=====================");
+ SLOG(LOG_DEBUG, tts_tag(), "@@@");
return 0;
}
xmlChar *key;
bool is_default_open = false;
+ /* For Thread safety */
+ xmlInitParser();
+
if (0 != access(TTS_CONFIG, F_OK)) {
doc = xmlParseFile(TTS_DEFAULT_CONFIG);
if (doc == NULL) {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to parse file error : %s", TTS_DEFAULT_CONFIG);
+ xmlCleanupParser();
return -1;
}
is_default_open = true;
if (TTS_RETRY_COUNT == retry_count) {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to parse file error : %s", TTS_CONFIG);
- return -1;
+ doc = xmlParseFile(TTS_DEFAULT_CONFIG);
+ if (NULL == doc) {
+ SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to parse file error : %s", TTS_DEFAULT_CONFIG);
+ xmlCleanupParser();
+ return -1;
+ }
+ is_default_open = true;
+ break;
}
}
}
if (cur == NULL) {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] Empty document");
xmlFreeDoc(doc);
+ doc = NULL;
+ xmlCleanupParser();
return -1;
}
if (xmlStrcmp(cur->name, (const xmlChar *) TTS_TAG_CONFIG_BASE_TAG)) {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] The wrong type, root node is NOT %s", TTS_TAG_CONFIG_BASE_TAG);
xmlFreeDoc(doc);
+ doc = NULL;
+ xmlCleanupParser();
return -1;
}
if (cur == NULL) {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] Empty document");
xmlFreeDoc(doc);
+ doc = NULL;
+ xmlCleanupParser();
return -1;
}
if (NULL == temp) {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] Out of memory");
xmlFreeDoc(doc);
+ doc = NULL;
+ xmlCleanupParser();
return -1;
}
- temp->engine_id = NULL;
- temp->setting = NULL;
- temp->language = NULL;
+ memset(g_engine_id, '\0', sizeof(g_engine_id));
+ memset(g_setting, '\0', sizeof(g_setting));
+ memset(g_language, '\0', sizeof(g_language));
+
+ temp->engine_id = g_engine_id;
+ temp->setting = g_setting;
+ temp->language = g_language;
while (cur != NULL) {
if (0 == xmlStrcmp(cur->name, (const xmlChar *)TTS_TAG_CONFIG_ENGINE_ID)) {
key = xmlNodeGetContent(cur);
if (NULL != key) {
- if (NULL != temp->engine_id) free(temp->engine_id);
- temp->engine_id = strdup((char*)key);
+ strncpy(temp->engine_id, (char*)key, sizeof(g_engine_id) - 1);
xmlFree(key);
+ key = NULL;
} else {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] engine id is NULL");
}
} else if (0 == xmlStrcmp(cur->name, (const xmlChar *)TTS_TAG_CONFIG_ENGINE_SETTING)) {
key = xmlNodeGetContent(cur);
if (NULL != key) {
- if (NULL != temp->setting) free(temp->setting);
- temp->setting = strdup((char*)key);
+ strncpy(temp->setting, (char*)key, sizeof(g_setting) - 1);
xmlFree(key);
+ key = NULL;
} else {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] setting path is NULL");
}
-
} else if (0 == xmlStrcmp(cur->name, (const xmlChar *)TTS_TAG_CONFIG_AUTO_VOICE)) {
key = xmlNodeGetContent(cur);
if (NULL != key) {
}
xmlFree(key);
+ key = NULL;
} else {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] voice type is NULL");
}
}
xmlFree(key);
+ key = NULL;
} else {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] voice type is NULL");
}
} else if (0 == xmlStrcmp(cur->name, (const xmlChar *)TTS_TAG_CONFIG_LANGUAGE)) {
key = xmlNodeGetContent(cur);
if (NULL != key) {
- if (NULL != temp->language) free(temp->language);
- temp->language = strdup((char*)key);
+ strncpy(temp->language, (char*)key, sizeof(g_language) - 1);
xmlFree(key);
+ key = NULL;
} else {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] engine uuid is NULL");
}
if (NULL != key) {
temp->pitch = atoi((char*)key);
xmlFree(key);
+ key = NULL;
} else {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] Pitch is NULL");
}
g_config_doc = doc;
if (true == is_default_open) {
- int ret = xmlSaveFile(TTS_CONFIG, g_config_doc);
- if (0 > ret) {
- SLOG(LOG_ERROR, tts_tag(), "[ERROR] Save result : %d", ret);
- }
+ int retry_count = 0;
+ int ret = -1;
+ do {
+ ret = xmlSaveFile(TTS_CONFIG, g_config_doc);
+ if (0 < ret)
+ break;
+ retry_count++;
+ usleep(10000);
+
+ if (TTS_RETRY_COUNT == retry_count) {
+ SLOG(LOG_ERROR, tts_tag(), "[ERROR] Save result : %d", ret);
+ return -1;
+ }
+ } while (0 != ret);
/* Set mode */
- if (0 > chmod(TTS_CONFIG, 0666)) {
+ if (0 > chmod(TTS_CONFIG, 0600)) {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to change file mode : %d", ret);
}
int tts_parser_unload_config(tts_config_s* config_info)
{
- if (NULL != g_config_doc) xmlFreeDoc(g_config_doc);
+ if (NULL != g_config_doc) {
+ xmlFreeDoc(g_config_doc);
+ g_config_doc = NULL;
+ }
if (NULL != config_info) {
- if (NULL != config_info->engine_id) free(config_info->engine_id);
- if (NULL != config_info->setting) free(config_info->setting);
- if (NULL != config_info->language) free(config_info->language);
free(config_info);
+ config_info = NULL;
}
+ xmlCleanupParser();
+
return 0;
}
}
xmlDocPtr doc = NULL;
- doc = xmlParseFile(original);
- if (doc == NULL) {
- SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to parse file error : %s", original);
+ if (0 == access(original, F_OK)) {
+ SLOG(LOG_DEBUG, tts_tag(), "[DEBUG] Success to access to %s", original);
+ doc = xmlParseFile(original);
+ if (doc == NULL) {
+ SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to parse file error : %s", original);
+ return -1;
+ }
+ } else {
+ SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to access to %s", original);
return -1;
}
int ret = xmlSaveFile(destination, doc);
if (0 > ret) {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] Save result : %d", ret);
+ } else {
+ SLOG(LOG_DEBUG, tts_tag(), "[DEBUG] Success to save %s", destination);
}
/* Set mode */
- if (0 > chmod(destination, 0666)) {
+ if (0 > chmod(destination, 0600)) {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to change file mode : %d", ret);
}
- xmlFreeDoc(doc);
+ xmlFreeDoc(doc);
+ doc = NULL;
SLOG(LOG_DEBUG, tts_tag(), "[SUCCESS] Copying xml");
return 0;
default: xmlNodeSetContent(cur, (const xmlChar*)TTS_TAG_VOICE_TYPE_FEMALE); break;
}
}
-
+
cur = cur->next;
}
int ret = xmlSaveFile(TTS_CONFIG, g_config_doc);
if (0 > ret) {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] Save result : %d", ret);
+ } else {
+ SLOG(LOG_DEBUG, tts_tag(), "[DEBUG] Success to save %s", TTS_CONFIG);
}
return 0;
while (cur != NULL) {
if (0 == xmlStrcmp(cur->name, (const xmlChar *)TTS_TAG_CONFIG_LANGUAGE)) {
xmlNodeSetContent(cur, (const xmlChar *)language);
- }
+ }
if (0 == xmlStrcmp(cur->name, (const xmlChar *)TTS_TAG_CONFIG_VOICE_TYPE)) {
switch (type) {
int ret = xmlSaveFile(TTS_CONFIG, g_config_doc);
if (0 > ret) {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] Save result : %d", ret);
+ } else {
+ SLOG(LOG_DEBUG, tts_tag(), "[DEBUG] Success to save %s", TTS_CONFIG);
}
return 0;
int ret = xmlSaveFile(TTS_CONFIG, g_config_doc);
if (0 > ret) {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] Save result : %d", ret);
+ } else {
+ SLOG(LOG_DEBUG, tts_tag(), "[DEBUG] Success to save %s", TTS_CONFIG);
}
return 0;
int ret = xmlSaveFile(TTS_CONFIG, g_config_doc);
if (0 > ret) {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] Save result : %d", ret);
+ } else {
+ SLOG(LOG_DEBUG, tts_tag(), "[DEBUG] Success to save %s", TTS_CONFIG);
}
return 0;
snprintf(temp, 10, "%d", value);
xmlNodeSetContent(cur, (const xmlChar *)temp);
break;
- }
+ }
cur = cur->next;
}
int ret = xmlSaveFile(TTS_CONFIG, g_config_doc);
if (0 > ret) {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] Save result : %d", ret);
+ } else {
+ SLOG(LOG_DEBUG, tts_tag(), "[DEBUG] Success to save %s", TTS_CONFIG);
}
return 0;
int retry_count = 0;
while (NULL == doc) {
- doc = xmlParseFile(TTS_CONFIG);
- if (NULL != doc) {
- break;
+ if (0 == access(TTS_CONFIG, F_OK)) {
+ SLOG(LOG_DEBUG, tts_tag(), "[DEBUG] Success to access to %s", TTS_CONFIG);
+ doc = xmlParseFile(TTS_CONFIG);
+ if (NULL != doc) {
+ break;
+ }
}
retry_count++;
usleep(10000);
if (cur_new == NULL || cur_old == NULL) {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] Empty document");
xmlFreeDoc(doc);
+ doc = NULL;
return -1;
}
xmlStrcmp(cur_old->name, (const xmlChar*)TTS_TAG_CONFIG_BASE_TAG)) {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] The wrong type, root node is NOT %s", TTS_TAG_CONFIG_BASE_TAG);
xmlFreeDoc(doc);
+ doc = NULL;
return -1;
}
if (cur_new == NULL || cur_old == NULL) {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] Empty document");
xmlFreeDoc(doc);
+ doc = NULL;
return -1;
}
if (0 != xmlStrcmp(key_old, key_new)) {
SLOG(LOG_DEBUG, tts_tag(), "Old engine id(%s), New engine(%s)",
(char*)key_old, (char*)key_new);
- if (NULL != *engine) free(*engine);
+ if (NULL != *engine) {
+ free(*engine);
+ *engine = NULL;
+ }
*engine = strdup((char*)key_new);
}
xmlFree(key_new);
+ key_new = NULL;
}
xmlFree(key_old);
+ key_old = NULL;
}
} else {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] old config and new config are different");
if (0 != xmlStrcmp(key_old, key_new)) {
SLOG(LOG_DEBUG, tts_tag(), "Old engine setting(%s), New engine setting(%s)",
(char*)key_old, (char*)key_new);
- if (NULL != *setting) free(*setting);
+ if (NULL != *setting) {
+ free(*setting);
+ *setting = NULL;
+ }
*setting = strdup((char*)key_new);
}
xmlFree(key_new);
+ key_new = NULL;
}
xmlFree(key_old);
+ key_old = NULL;
}
} else {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] old config and new config are different");
}
}
xmlFree(key_new);
+ key_new = NULL;
}
xmlFree(key_old);
+ key_old = NULL;
}
} else {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] old config and new config are different");
if (0 != xmlStrcmp(key_old, key_new)) {
SLOG(LOG_DEBUG, tts_tag(), "Old language(%s), New language(%s)",
(char*)key_old, (char*)key_new);
- if (NULL != *language) free(*language);
+ if (NULL != *language) {
+ free(*language);
+ *language = NULL;
+ }
*language = strdup((char*)key_new);
}
xmlFree(key_new);
+ key_new = NULL;
}
xmlFree(key_old);
+ key_old = NULL;
}
} else {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] old config and new config are different");
}
}
xmlFree(key_new);
+ key_new = NULL;
}
xmlFree(key_old);
+ key_old = NULL;
}
} else {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] old config and new config are different");
*speech_rate = atoi((char*)key_new);
}
xmlFree(key_new);
+ key_new = NULL;
}
xmlFree(key_old);
+ key_old = NULL;
}
} else {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] old config and new config are different");
*pitch = atoi((char*)key_new);
}
xmlFree(key_new);
+ key_new = NULL;
}
xmlFree(key_old);
+ key_old = NULL;
}
} else {
SLOG(LOG_ERROR, tts_tag(), "[ERROR] old config and new config are different");
cur_new = cur_new->next;
cur_old = cur_old->next;
}
-
- xmlFreeDoc(g_config_doc);
+
+ if (NULL != g_config_doc) {
+ xmlFreeDoc(g_config_doc);
+ g_config_doc = NULL;
+ }
g_config_doc = doc;
return 0;
}
+
+int tts_parser_reset()
+{
+ SLOG(LOG_DEBUG, tts_tag(), "[DEBUG] Reset g_config_doc as %s", TTS_DEFAULT_CONFIG);
+
+ if (NULL != g_config_doc) {
+ xmlFreeDoc(g_config_doc);
+ g_config_doc = NULL;
+ }
+
+ g_config_doc = xmlParseFile(TTS_DEFAULT_CONFIG);
+ if (NULL == g_config_doc) {
+ SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to parse %s", TTS_DEFAULT_CONFIG);
+ return -1;
+ }
+
+ int ret = xmlSaveFile(TTS_CONFIG, g_config_doc);
+ if (0 > ret) {
+ SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to save %s", TTS_CONFIG);
+ }
+
+ return 0;
+}
projects / platform / core / uifw / tts.git / blobdiff