2 * Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd All Rights Reserved
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 * http://www.apache.org/licenses/LICENSE-2.0
7 * Unless required by applicable law or agreed to in writing, software
8 * distributed under the License is distributed on an "AS IS" BASIS,
9 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
10 * See the License for the specific language governing permissions and
11 * limitations under the License.
18 #include "ttsd_main.h"
19 #include "ttsd_engine_agent.h"
20 #include "ttsd_config.h"
22 #define ENGINE_PATH_SIZE 256
25 * Internal data structure
33 /* info for using engine load*/
39 /* engine base setting */
44 ttspe_funcs_s* pefuncs;
45 ttspd_funcs_s* pdfuncs;
47 int (*ttsp_load_engine)(const ttspd_funcs_s* pdfuncs, ttspe_funcs_s* pefuncs);
48 int (*ttsp_unload_engine)();
55 char* setting_ug_path;
61 static bool g_agent_init;
63 /** TTS engine list */
64 static GList *g_engine_list;
66 /** Current engine information */
67 static ttsengine_s g_cur_engine;
69 /** Result callback function */
70 static synth_result_callback g_result_cb;
73 /** Set current engine */
74 int __internal_set_current_engine(const char* engine_uuid);
76 /** Check engine id */
77 int __internal_check_engine_id(const char* engine_uuid);
79 /** Update engine list */
80 int __internal_update_engine_list();
82 /** Get engine info */
83 int __internal_get_engine_info(const char* filepath, ttsengine_info_s** info);
85 /** Callback function for result */
86 bool __result_cb(ttsp_result_event_e event, const void* data, unsigned int data_size, void *user_data);
88 /** Callback function for voice list */
89 bool __supported_voice_cb(const char* language, ttsp_voice_type_e type, void* user_data);
91 /** Free voice list */
92 void __free_voice_list(GList* voice_list);
94 /** Callback function for engine info */
95 void __engine_info_cb(const char* engine_uuid, const char* engine_name, const char* setting_ug_name,
96 bool use_network, void* user_data);
98 /** Callback fucntion for engine setting */
99 bool __engine_setting_cb(const char* key, const char* value, void* user_data);
102 int ttsd_engine_agent_init(synth_result_callback result_cb)
104 /* initialize static data */
105 if (result_cb == NULL) {
106 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] invalid parameter");
107 return TTSD_ERROR_INVALID_PARAMETER;
110 g_result_cb = result_cb;
112 g_cur_engine.engine_uuid = NULL;
113 g_cur_engine.engine_name = NULL;
114 g_cur_engine.engine_path = NULL;
116 g_cur_engine.is_set = false;
117 g_cur_engine.handle = NULL;
118 g_cur_engine.pefuncs = (ttspe_funcs_s*)g_malloc0( sizeof(ttspe_funcs_s) );
119 g_cur_engine.pdfuncs = (ttspd_funcs_s*)g_malloc0( sizeof(ttspd_funcs_s) );
123 if (0 != ttsd_config_get_default_voice(&(g_cur_engine.default_lang), &(g_cur_engine.default_vctype))) {
124 SLOG(LOG_WARN, get_tag(), "[Server WARNING] There is No default voice in config");
125 /* Set default voice */
126 g_cur_engine.default_lang = strdup("en_US");
127 g_cur_engine.default_vctype = TTSP_VOICE_TYPE_FEMALE;
130 if (0 != ttsd_config_get_default_speed(&(g_cur_engine.default_speed))) {
131 SLOG(LOG_WARN, get_tag(), "[Server WARNING] There is No default speed in config");
132 ttsd_config_set_default_speed((int)TTSP_SPEED_NORMAL);
133 g_cur_engine.default_speed = TTSP_SPEED_NORMAL;
136 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent SUCCESS] Initialize Engine Agent");
141 int ttsd_engine_agent_release()
143 if (false == g_agent_init) {
144 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized");
145 return TTSD_ERROR_OPERATION_FAILED;
148 /* unload current engine */
149 ttsd_engine_agent_unload_current_engine();
151 /* release engine list */
153 ttsengine_s *data = NULL;
155 if (g_list_length(g_engine_list) > 0) {
156 /* Get a first item */
157 iter = g_list_first(g_engine_list);
158 while (NULL != iter) {
159 /* Get data from item */
161 iter = g_list_remove(iter, data);
165 /* release current engine data */
166 if (g_cur_engine.pefuncs != NULL)
167 g_free(g_cur_engine.pefuncs);
169 if (g_cur_engine.pdfuncs != NULL)
170 g_free(g_cur_engine.pdfuncs);
173 g_agent_init = false;
175 if (g_cur_engine.default_lang != NULL)
176 g_free(g_cur_engine.default_lang);
179 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent SUCCESS] Release Engine Agent");
184 int ttsd_engine_agent_initialize_current_engine()
186 if (false == g_agent_init) {
187 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
188 return TTSD_ERROR_OPERATION_FAILED;
191 /* update engine list */
192 if (0 != __internal_update_engine_list()) {
193 SLOG(LOG_WARN, get_tag(), "[Engine Agent WARNING] No engine error");
194 return TTSD_ERROR_OPERATION_FAILED;
197 /* 2. get current engine from config */
198 char* cur_engine_uuid = NULL;
199 bool is_get_engineid_from_config = false;
201 if (0 != ttsd_config_get_default_engine(&cur_engine_uuid)) {
202 /*not set current engine */
203 /*set system default engine*/
205 ttsengine_info_s *data = NULL;
207 if (g_list_length(g_engine_list) > 0) {
208 iter = g_list_first(g_engine_list);
209 char* default_engine = "27F277E9-BBC4-4dca-B553-D9884A3CDAA0";
211 while (NULL != iter) {
214 if (0 == strncmp(data->engine_uuid, default_engine, strlen(default_engine))) {
215 /* current data is default engine */
219 iter = g_list_next(iter);
222 SLOG(LOG_WARN, get_tag(), "[Engine Agent WARNING] Fail to set a engine of engine list");
223 return TTSD_ERROR_OPERATION_FAILED;
226 if (NULL != data->engine_uuid) {
227 cur_engine_uuid = strdup(data->engine_uuid);
229 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Data of current engine is corrupt");
230 return TTSD_ERROR_OPERATION_FAILED;
233 is_get_engineid_from_config = false;
235 is_get_engineid_from_config = true;
238 /* check whether cur engine uuid is valid or not. */
239 if (0 != __internal_check_engine_id(cur_engine_uuid)) {
240 SLOG(LOG_WARN, get_tag(), "[Engine Agent WARNING] It is not valid engine id from config");
244 if (g_list_length(g_engine_list) > 0)
245 iter = g_list_first(g_engine_list);
247 SLOG(LOG_WARN, get_tag(), "[Engine Agent ERROR] NO TTS Engine !!");
248 return TTSD_ERROR_OPERATION_FAILED;
251 if (cur_engine_uuid != NULL)
252 g_free(cur_engine_uuid);
254 ttsengine_info_s *data = NULL;
257 cur_engine_uuid = g_strdup(data->engine_uuid);
259 is_get_engineid_from_config = false;
262 if (NULL != cur_engine_uuid)
263 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent] Current Engine Id : %s", cur_engine_uuid);
265 return TTSD_ERROR_OPERATION_FAILED;
267 /* set current engine */
268 if (0 != __internal_set_current_engine(cur_engine_uuid)) {
269 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] fail to set current engine ");
270 return TTSD_ERROR_OPERATION_FAILED;
273 if (false == is_get_engineid_from_config) {
274 if (0 != ttsd_config_set_default_engine(cur_engine_uuid))
275 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] fail to set id to config");
278 if (NULL != cur_engine_uuid)
279 g_free(cur_engine_uuid);
281 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent SUCCESS] Set current engine");
286 int __internal_check_engine_id(const char* engine_uuid)
289 ttsengine_s *data = NULL;
291 if (g_list_length(g_engine_list) > 0) {
292 iter = g_list_first(g_engine_list);
294 while (NULL != iter) {
297 if (0 == strncmp(engine_uuid, data->engine_uuid, strlen(data->engine_uuid)))
300 iter = g_list_next(iter);
307 void __engine_info_cb(const char* engine_uuid, const char* engine_name, const char* setting_ug_name,
308 bool use_network, void* user_data)
310 ttsengine_info_s* temp = (ttsengine_info_s*)user_data;
312 temp->engine_uuid = g_strdup(engine_uuid);
313 temp->engine_name = g_strdup(engine_name);
314 temp->setting_ug_path = g_strdup(setting_ug_name);
315 temp->use_network = use_network;
318 int __internal_get_engine_info(const char* filepath, ttsengine_info_s** info)
323 handle = dlopen (filepath, RTLD_LAZY );
326 SLOG(LOG_WARN, get_tag(), "[Engine Agent] Invalid engine : %s", filepath);
327 return TTSD_ERROR_OPERATION_FAILED;
330 /* link engine to daemon */
331 dlsym(handle, "ttsp_load_engine");
332 if ((error = dlerror()) != NULL) {
333 SLOG(LOG_WARN, get_tag(), "[Engine Agent] Invalid engine. Fail to open ttsp_load_engine : %s", filepath);
335 return TTSD_ERROR_OPERATION_FAILED;
338 dlsym(handle, "ttsp_unload_engine");
339 if ((error = dlerror()) != NULL) {
340 SLOG(LOG_WARN, get_tag(), "[Engine Agent] Invalid engine. Fail to open ttsp_unload_engine : %s", filepath);
342 return TTSD_ERROR_OPERATION_FAILED;
345 int (*get_engine_info)(ttsp_engine_info_cb callback, void* user_data);
347 get_engine_info = (int (*)(ttsp_engine_info_cb, void*))dlsym(handle, "ttsp_get_engine_info");
348 if (NULL != (error = dlerror()) || NULL == get_engine_info) {
349 SLOG(LOG_WARN, get_tag(), "[Engine Agent] ttsp_get_engine_info() link error");
351 return TTSD_ERROR_OPERATION_FAILED;
354 ttsengine_info_s* temp;
355 temp = (ttsengine_info_s*)g_malloc0(sizeof(ttsengine_info_s));
357 /* get engine info */
358 if (0 != get_engine_info(&__engine_info_cb, (void*)temp)) {
359 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] fail to get engine info");
362 return TTSD_ERROR_OPERATION_FAILED;
368 if (TTSD_MODE_SCREEN_READER == ttsd_get_mode()) {
369 if (true == temp->use_network) {
371 SLOG(LOG_ERROR, get_tag(), "[Engine Agent WARNING] %s is invalid because of network based engine.", temp->engine_name);
372 return TTSD_ERROR_OPERATION_FAILED;
376 temp->engine_path = g_strdup(filepath);
378 SLOG(LOG_DEBUG, get_tag(), "----- Valid engine");
379 SLOG(LOG_DEBUG, get_tag(), "Engine uuid : %s", temp->engine_uuid);
380 SLOG(LOG_DEBUG, get_tag(), "Engine name : %s", temp->engine_name);
381 SLOG(LOG_DEBUG, get_tag(), "Setting ug path : %s", temp->setting_ug_path);
382 SLOG(LOG_DEBUG, get_tag(), "Engine path : %s", temp->engine_path);
383 SLOG(LOG_DEBUG, get_tag(), "Use network : %s", temp->use_network ? "true":"false");
384 SLOG(LOG_DEBUG, get_tag(), "-----");
385 SLOG(LOG_DEBUG, get_tag(), " ");
392 int __internal_update_engine_list()
394 /* relsease engine list */
396 ttsengine_info_s *data = NULL;
398 if (g_list_length(g_engine_list) > 0) {
399 iter = g_list_first(g_engine_list);
401 while (NULL != iter) {
407 g_engine_list = g_list_remove_link(g_engine_list, iter);
408 iter = g_list_first(g_engine_list);
412 /* get file name from engine directory and get engine information from each filename */
415 dp = opendir(ENGINE_DIRECTORY_DEFAULT);
418 while ((dirp = readdir(dp)) != NULL) {
419 ttsengine_info_s* info;
420 char* filepath = NULL;
423 file_size = strlen(ENGINE_DIRECTORY_DEFAULT) + strlen(dirp->d_name) + 5;
424 filepath = (char*)g_malloc0( sizeof(char) * file_size);
426 if (NULL != filepath) {
427 strncpy(filepath, ENGINE_DIRECTORY_DEFAULT, strlen(ENGINE_DIRECTORY_DEFAULT) );
428 strncat(filepath, "/", strlen("/") );
429 strncat(filepath, dirp->d_name, strlen(dirp->d_name) );
431 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not enough memory!!" );
435 /* get its info and update engine list */
436 if (0 == __internal_get_engine_info(filepath, &info)) {
437 /* add engine info to g_engine_list */
438 g_engine_list = g_list_append(g_engine_list, info);
441 if (NULL != filepath)
448 dp = opendir(ENGINE_DIRECTORY_DOWNLOAD);
451 while ((dirp = readdir(dp)) != NULL) {
452 ttsengine_info_s* info;
453 char* filepath = NULL;
456 file_size = strlen(ENGINE_DIRECTORY_DOWNLOAD) + strlen(dirp->d_name) + 5;
457 filepath = (char*)g_malloc0( sizeof(char) * file_size);
459 if (NULL != filepath) {
460 strcpy(filepath, ENGINE_DIRECTORY_DOWNLOAD);
461 strcat(filepath, "/");
462 strcat(filepath, dirp->d_name);
464 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not enough memory!!" );
468 /* get its info and update engine list */
469 if (0 == __internal_get_engine_info(filepath, &info)) {
470 /* add engine info to g_engine_list */
471 g_engine_list = g_list_append(g_engine_list, info);
474 if (NULL != filepath)
481 if (g_list_length(g_engine_list) <= 0) {
482 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] No Engine");
483 return TTSD_ERROR_OPERATION_FAILED;
486 #ifdef ENGINE_AGENT_DEBUG
487 ttsd_print_enginelist();
493 int __internal_set_current_engine(const char* engine_uuid)
495 /* check whether engine id is valid or not. */
497 ttsengine_info_s *data = NULL;
500 if (g_list_length(g_engine_list) > 0) {
501 iter = g_list_first(g_engine_list);
503 while (NULL != iter) {
506 if (0 == strncmp(data->engine_uuid, engine_uuid, strlen(engine_uuid))) {
512 iter = g_list_next(iter);
516 /* If current engine does not exist, return error */
518 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] __internal_set_current_engine : Cannot find engine id");
519 return TTSD_ERROR_OPERATION_FAILED;
521 if (g_cur_engine.engine_uuid != NULL) {
522 /*compare current engine uuid */
523 if (0 == strncmp(g_cur_engine.engine_uuid, data->engine_uuid, strlen(engine_uuid))) {
524 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent] tts engine has already been set");
530 /* set data from g_engine_list */
531 if (g_cur_engine.engine_uuid != NULL) g_free(g_cur_engine.engine_uuid);
532 if (g_cur_engine.engine_name != NULL) g_free(g_cur_engine.engine_name);
533 if (g_cur_engine.engine_path != NULL) g_free(g_cur_engine.engine_path);
535 if (NULL == data->engine_uuid || NULL == data->engine_name || NULL == data->engine_path) {
536 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] __internal_set_current_engine : Engine data is NULL");
537 return TTSD_ERROR_OPERATION_FAILED;
540 g_cur_engine.engine_uuid = g_strdup(data->engine_uuid);
541 g_cur_engine.engine_name = g_strdup(data->engine_name);
542 g_cur_engine.engine_path = g_strdup(data->engine_path);
544 g_cur_engine.handle = NULL;
545 g_cur_engine.is_loaded = false;
546 g_cur_engine.is_set = true;
547 g_cur_engine.need_network = data->use_network;
549 SLOG(LOG_DEBUG, get_tag(), "-----");
550 SLOG(LOG_DEBUG, get_tag(), "Current engine uuid : %s", g_cur_engine.engine_uuid);
551 SLOG(LOG_DEBUG, get_tag(), "Current engine name : %s", g_cur_engine.engine_name);
552 SLOG(LOG_DEBUG, get_tag(), "Current engine path : %s", g_cur_engine.engine_path);
553 SLOG(LOG_DEBUG, get_tag(), "-----");
558 int ttsd_engine_agent_load_current_engine()
560 if (false == g_agent_init) {
561 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
562 return TTSD_ERROR_OPERATION_FAILED;
565 if (false == g_cur_engine.is_set) {
566 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] ttsd_engine_agent_load_current_engine : No Current Engine ");
567 return TTSD_ERROR_OPERATION_FAILED;
570 /* check whether current engine is loaded or not */
571 if (true == g_cur_engine.is_loaded ) {
572 SLOG(LOG_ERROR, get_tag(), "[Engine Agent] ttsd_engine_agent_load_current_engine : Engine has already been loaded " );
576 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent] current engine path : %s", g_cur_engine.engine_path);
580 g_cur_engine.handle = dlopen(g_cur_engine.engine_path, RTLD_LAZY); /* RTLD_LAZY RTLD_NOW*/
582 if (NULL != (error = dlerror()) || NULL == g_cur_engine.handle) {
583 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] fail to get current engine handle : dlopen error ($s)", error);
587 g_cur_engine.ttsp_unload_engine = (int (*)())dlsym(g_cur_engine.handle, "ttsp_unload_engine");
588 if (NULL != (error = dlerror()) || NULL == g_cur_engine.ttsp_unload_engine) {
589 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] fail to link daemon to ttsp_unload_engine() of current engine : (%s)", error);
593 g_cur_engine.ttsp_load_engine = (int (*)(const ttspd_funcs_s* , ttspe_funcs_s*) )dlsym(g_cur_engine.handle, "ttsp_load_engine");
594 if (NULL != (error = dlerror()) || NULL == g_cur_engine.ttsp_load_engine) {
595 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] fail to link daemon to ttsp_load_engine() of current engine : %s", error);
600 g_cur_engine.pdfuncs->version = 1;
601 g_cur_engine.pdfuncs->size = sizeof(ttspd_funcs_s);
604 ret = g_cur_engine.ttsp_load_engine(g_cur_engine.pdfuncs, g_cur_engine.pefuncs);
606 printf("Fail load '%s' engine", g_cur_engine.engine_path);
607 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] fail to load engine : result(%d)");
608 return TTSD_ERROR_OPERATION_FAILED;
611 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent] engine info : version(%d), size(%d)",g_cur_engine.pefuncs->version, g_cur_engine.pefuncs->size );
613 /* engine error check */
614 if (g_cur_engine.pefuncs->size != sizeof(ttspe_funcs_s)) {
615 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] ttsd_engine_agent_load_current_engine : current engine is not valid");
616 return TTSD_ERROR_OPERATION_FAILED;
619 /* initalize engine */
620 if (NULL == g_cur_engine.pefuncs->initialize) {
621 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] init function of engine is NULL!!");
622 return TTSD_ERROR_OPERATION_FAILED;
625 ret = g_cur_engine.pefuncs->initialize(__result_cb);
627 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] fail to initialize current engine : result(%d)", ret);
628 return TTSD_ERROR_OPERATION_FAILED;
631 /* select default voice */
632 bool set_voice = false;
633 if (NULL != g_cur_engine.default_lang) {
634 if (NULL == g_cur_engine.pefuncs->is_valid_voice) {
635 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] is_valid_voice() of engine is NULL!!");
636 return TTSD_ERROR_OPERATION_FAILED;
639 if (true == g_cur_engine.pefuncs->is_valid_voice(g_cur_engine.default_lang, g_cur_engine.default_vctype)) {
641 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent SUCCESS] Set origin default voice to current engine : lang(%s), type(%d)",
642 g_cur_engine.default_lang, g_cur_engine.default_vctype);
644 SLOG(LOG_WARN, get_tag(), "[Engine Agent WARNING] Fail set origin default voice : lang(%s), type(%d)",
645 g_cur_engine.default_lang, g_cur_engine.default_vctype);
649 if (false == set_voice) {
650 if (NULL == g_cur_engine.pefuncs->foreach_voices) {
651 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] get_voice_list of engine is NULL!!");
652 return TTSD_ERROR_OPERATION_FAILED;
655 /* get language list */
657 GList* voice_list = NULL;
659 ret = g_cur_engine.pefuncs->foreach_voices(__supported_voice_cb, &voice_list);
661 if (0 == ret && 0 < g_list_length(voice_list)) {
665 iter = g_list_first(voice_list);
668 while (NULL != iter) {
672 if (0 == strcmp("en_US", voice->language))
676 iter = g_list_next(iter);
679 /* Set selected language and type */
680 if (true != g_cur_engine.pefuncs->is_valid_voice(voice->language, voice->type)) {
681 SLOG(LOG_ERROR, get_tag(), "[Engine ERROR] Fail voice is NOT valid");
682 return TTSD_ERROR_OPERATION_FAILED;
685 ttsd_config_set_default_voice(voice->language, (int)voice->type);
687 g_cur_engine.default_lang = g_strdup(voice->language);
688 g_cur_engine.default_vctype = voice->type;
690 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent SUCCESS] Select default voice : lang(%s), type(%d)",
691 voice->language, voice->type);
693 __free_voice_list(voice_list);
695 SLOG(LOG_ERROR, get_tag(), "[Engine ERROR] Fail to get language list : result(%d)", ret);
696 return TTSD_ERROR_OPERATION_FAILED;
700 g_cur_engine.is_loaded = true;
705 int ttsd_engine_agent_unload_current_engine()
707 if (false == g_agent_init) {
708 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
709 return TTSD_ERROR_OPERATION_FAILED;
712 if (false == g_cur_engine.is_set) {
713 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] No Current Engine ");
714 return TTSD_ERROR_OPERATION_FAILED;
717 if (false == g_cur_engine.is_loaded) {
718 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent] Engine has already been unloaded " );
722 /* shutdown engine */
723 if (NULL == g_cur_engine.pefuncs->deinitialize) {
724 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] The deinitialize() of engine is NULL!!");
727 ret = g_cur_engine.pefuncs->deinitialize();
729 SLOG(LOG_ERROR, get_tag(), "[Engine Agent] Fail deinitialize() : result(%d)", ret);
734 g_cur_engine.ttsp_unload_engine();
736 dlclose(g_cur_engine.handle);
738 /* reset current engine data */
739 g_cur_engine.handle = NULL;
740 g_cur_engine.is_loaded = false;
745 bool ttsd_engine_agent_need_network()
747 if (false == g_agent_init) {
748 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
749 return TTSD_ERROR_OPERATION_FAILED;
752 if (false == g_cur_engine.is_loaded) {
753 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
754 return TTSD_ERROR_OPERATION_FAILED;
757 return g_cur_engine.need_network;
760 bool ttsd_engine_select_valid_voice(const char* lang, int type, char** out_lang, ttsp_voice_type_e* out_type)
762 if (NULL == lang || NULL == out_lang || NULL == out_type) {
766 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent] Select voice : input lang(%s) , input type(%d), default lang(%s), default type(%d)",
767 lang, type, g_cur_engine.default_lang, g_cur_engine.default_vctype);
770 /* case 1 : Both are default */
771 if (0 == strncmp(lang, "default", strlen("default")) && 0 == type) {
772 *out_lang = strdup(g_cur_engine.default_lang);
773 *out_type = g_cur_engine.default_vctype;
778 if (NULL == g_cur_engine.pefuncs->foreach_voices) {
779 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] foreach_voices of engine is NULL!!");
780 return TTSD_ERROR_OPERATION_FAILED;
783 GList* voice_list = NULL;
786 ret = g_cur_engine.pefuncs->foreach_voices(__supported_voice_cb, &voice_list);
787 if (0 != ret || 0 >= g_list_length(voice_list)) {
788 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] fail to get voice list : result(%d)", ret);
798 /* lang and type are not default type */
799 if (0 != strncmp(lang, "default", strlen("default")) && 0 != type) {
800 iter = g_list_first(voice_list);
802 while (NULL != iter) {
803 /* Get handle data from list */
806 if (0 == strncmp(voice->language, lang, strlen(lang)) && voice->type == type) {
807 *out_lang = strdup(voice->language);
808 *out_type = voice->type;
813 iter = g_list_next(iter);
816 } else if (0 != strncmp(lang, "default", strlen("default")) && 0 == type) {
817 /* Only type is default */
818 if (0 == strncmp(lang, g_cur_engine.default_lang, strlen(g_cur_engine.default_lang))) {
819 *out_lang = strdup(g_cur_engine.default_lang);
820 *out_type = g_cur_engine.default_vctype;
823 voice_s* voice_selected = NULL;
824 iter = g_list_first(voice_list);
825 while (NULL != iter) {
826 /* Get handle data from list */
829 if (0 == strncmp(voice->language, lang, strlen(lang))) {
830 voice_selected = voice;
831 if (voice->type == g_cur_engine.default_vctype) {
832 voice_selected = voice;
836 iter = g_list_next(iter);
839 if (NULL != voice_selected) {
840 *out_lang = strdup(voice_selected->language);
841 *out_type = voice_selected->type;
845 } else if (0 == strncmp(lang, "default", strlen("default")) && 0 != type) {
846 /* Only lang is default */
847 if (type == g_cur_engine.default_vctype) {
848 *out_lang = strdup(g_cur_engine.default_lang);
849 *out_type = g_cur_engine.default_vctype;
852 voice_s* voice_selected = NULL;
853 iter = g_list_first(voice_list);
854 while (NULL != iter) {
855 /* Get handle data from list */
858 if (0 == strncmp(voice->language, g_cur_engine.default_lang, strlen(g_cur_engine.default_lang)) ) {
859 voice_selected = voice;
860 if (voice->type == type) {
861 voice_selected = voice;
865 iter = g_list_next(iter);
868 if (NULL != voice_selected) {
869 *out_lang = strdup(voice->language);
870 *out_type = voice_selected->type;
876 if (true == result) {
877 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent] Selected voice : lang(%s), type(%d)", *out_lang, *out_type);
880 __free_voice_list(voice_list);
885 bool ttsd_engine_agent_is_same_engine(const char* engine_id)
887 if (false == g_agent_init) {
888 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
892 if (false == g_cur_engine.is_loaded) {
893 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
897 /* compare current engine and engine id.*/
898 if (0 == strncmp(g_cur_engine.engine_uuid, engine_id, strlen(engine_id))) {
905 int ttsd_engine_agent_set_default_voice(const char* language, ttsp_voice_type_e vctype)
907 if (false == g_agent_init) {
908 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
909 return TTSD_ERROR_OPERATION_FAILED;
912 if (false == g_cur_engine.is_loaded) {
913 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
914 return TTSD_ERROR_OPERATION_FAILED;
917 if (NULL == g_cur_engine.pefuncs->is_valid_voice) {
918 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] The function of engine is NULL!!");
919 return TTSD_ERROR_OPERATION_FAILED;
923 if(false == g_cur_engine.pefuncs->is_valid_voice(language, vctype)) {
924 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Voice is NOT valid !!");
925 return TTSD_ERROR_INVALID_VOICE;
928 if (NULL != g_cur_engine.default_lang)
929 free(g_cur_engine.default_lang);
931 g_cur_engine.default_lang = strdup(language);
932 g_cur_engine.default_vctype = vctype;
934 ret = ttsd_config_set_default_voice(language, (int)vctype);
936 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent SUCCESS] Set default voice : lang(%s), type(%d)",
937 g_cur_engine.default_lang, g_cur_engine.default_vctype);
939 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] fail to write default voice to config (%d)", ret);
940 return TTSD_ERROR_OPERATION_FAILED;
946 /******************************************************************************************
947 * TTS Engine Interfaces for client
948 *******************************************************************************************/
950 int ttsd_engine_start_synthesis(const char* lang, const ttsp_voice_type_e vctype, const char* text, const int speed, void* user_param)
952 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent] start ttsd_engine_start_synthesis()");
954 if (false == g_agent_init) {
955 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
956 return TTSD_ERROR_OPERATION_FAILED;
959 if (false == g_cur_engine.is_loaded) {
960 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
961 return TTSD_ERROR_OPERATION_FAILED;
964 /* select voice for default */
965 char* temp_lang = NULL;
966 ttsp_voice_type_e temp_type;
967 if (true != ttsd_engine_select_valid_voice(lang, vctype, &temp_lang, &temp_type)) {
968 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Fail to select default voice");
969 return TTSD_ERROR_INVALID_VOICE;
971 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent] Start synthesis : language(%s), type(%d), speed(%d), text(%s)",
972 temp_lang, temp_type, speed, text);
975 if (NULL == g_cur_engine.pefuncs->start_synth) {
976 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] start_synth() of engine is NULL!!");
977 return TTSD_ERROR_OPERATION_FAILED;
980 ttsp_speed_e temp_speed;
983 temp_speed = g_cur_engine.default_speed;
988 /* synthesize text */
990 ret = g_cur_engine.pefuncs->start_synth(temp_lang, temp_type, text, temp_speed, user_param);
992 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] ***************************************", ret);
993 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] * synthesize error : result(%6d) *", ret);
994 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] ***************************************", ret);
995 return TTSD_ERROR_OPERATION_FAILED;
998 if (NULL == temp_lang)
1005 int ttsd_engine_cancel_synthesis()
1007 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent] start ttsd_engine_cancel_synthesis()");
1009 if (false == g_agent_init) {
1010 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1011 return TTSD_ERROR_OPERATION_FAILED;
1014 if (false == g_cur_engine.is_loaded) {
1015 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
1016 return TTSD_ERROR_OPERATION_FAILED;
1019 if (NULL == g_cur_engine.pefuncs->cancel_synth) {
1020 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] cancel_synth() of engine is NULL!!");
1021 return TTSD_ERROR_OPERATION_FAILED;
1024 /* stop synthesis */
1026 ret = g_cur_engine.pefuncs->cancel_synth();
1028 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] fail cancel synthesis : result(%d)", ret);
1029 return TTSD_ERROR_OPERATION_FAILED;
1035 int ttsd_engine_get_audio_format( ttsp_audio_type_e* type, int* rate, int* channels)
1037 if (false == g_agent_init) {
1038 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1039 return TTSD_ERROR_OPERATION_FAILED;
1042 if (false == g_cur_engine.is_loaded) {
1043 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
1044 return TTSD_ERROR_OPERATION_FAILED;
1047 if (NULL == g_cur_engine.pefuncs->get_audio_format) {
1048 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] get_audio_format() of engine is NULL!!");
1049 return TTSD_ERROR_OPERATION_FAILED;
1053 ret = g_cur_engine.pefuncs->get_audio_format(type, rate, channels);
1055 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] fail to get audio format : result(%d)", ret);
1056 return TTSD_ERROR_OPERATION_FAILED;
1058 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent] get audio format : type(%d), rate(%d), channel(%d)", *type, *rate, *channels);
1063 bool __supported_voice_cb(const char* language, ttsp_voice_type_e type, void* user_data)
1065 GList** voice_list = (GList**)user_data;
1067 if (NULL == language || NULL == voice_list) {
1068 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Input parameter is NULL in voice list callback!!!!");
1072 SLOG(LOG_DEBUG, get_tag(), "-- Language(%s), Type(%d)", language, type);
1074 voice_s* voice = g_malloc0(sizeof(voice_s));
1075 voice->language = strdup(language);
1078 *voice_list = g_list_append(*voice_list, voice);
1083 int ttsd_engine_get_voice_list(GList** voice_list)
1085 if (false == g_agent_init) {
1086 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1087 return TTSD_ERROR_OPERATION_FAILED;
1090 if (false == g_cur_engine.is_loaded) {
1091 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
1092 return TTSD_ERROR_OPERATION_FAILED;
1095 if (NULL == g_cur_engine.pefuncs->foreach_voices) {
1096 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] The function of engine is NULL!!");
1097 return TTSD_ERROR_OPERATION_FAILED;
1101 ret = g_cur_engine.pefuncs->foreach_voices(__supported_voice_cb, (void*)voice_list);
1103 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Fail to get voice list : result(%d)", ret);
1104 return TTSD_ERROR_OPERATION_FAILED;
1110 int ttsd_engine_get_default_voice( char** lang, ttsp_voice_type_e* vctype )
1112 if (false == g_agent_init) {
1113 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1114 return TTSD_ERROR_OPERATION_FAILED;
1117 if (false == g_cur_engine.is_loaded) {
1118 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
1119 return TTSD_ERROR_OPERATION_FAILED;
1122 if (NULL == lang || NULL == vctype) {
1123 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] BAD Parameter");
1124 return TTSD_ERROR_INVALID_PARAMETER;
1127 if (NULL != g_cur_engine.default_lang) {
1128 *lang = g_strdup(g_cur_engine.default_lang);
1129 *vctype = g_cur_engine.default_vctype;
1131 SLOG(LOG_DEBUG, get_tag(), "[Engine] Get default voice : language(%s), type(%d)", *lang, *vctype);
1133 if (NULL == g_cur_engine.pefuncs->foreach_voices) {
1134 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] get_voice_list of engine is NULL!!");
1135 return TTSD_ERROR_OPERATION_FAILED;
1138 /* get language list */
1140 GList* voice_list = NULL;
1142 ret = g_cur_engine.pefuncs->foreach_voices(__supported_voice_cb, &voice_list);
1144 if (0 == ret && 0 < g_list_length(voice_list)) {
1148 iter = g_list_first(voice_list);
1153 if (true != g_cur_engine.pefuncs->is_valid_voice(voice->language, voice->type)) {
1154 SLOG(LOG_ERROR, get_tag(), "[Engine ERROR] Fail voice is NOT valid ");
1155 return TTSD_ERROR_OPERATION_FAILED;
1158 ttsd_config_set_default_voice(voice->language, (int)voice->type);
1160 if (NULL != g_cur_engine.default_lang)
1161 g_free(g_cur_engine.default_lang);
1163 g_cur_engine.default_lang = g_strdup(voice->language);
1164 g_cur_engine.default_vctype = voice->type;
1166 *lang = g_strdup(g_cur_engine.default_lang);
1167 *vctype = g_cur_engine.default_vctype = voice->type;
1169 SLOG(LOG_DEBUG, get_tag(), "[Engine] Get default voice (New selected) : language(%s), type(%d)", *lang, *vctype);
1171 SLOG(LOG_ERROR, get_tag(), "[Engine ERROR] Fail to get language list : result(%d)", ret);
1172 return TTSD_ERROR_OPERATION_FAILED;
1175 __free_voice_list(voice_list);
1177 SLOG(LOG_ERROR, get_tag(), "[Engine ERROR] Fail to get language list : result(%d)", ret);
1178 return TTSD_ERROR_OPERATION_FAILED;
1186 * TTS Engine Interfaces for setting
1188 int ttsd_engine_setting_get_engine_list(GList** engine_list)
1190 if (false == g_agent_init) {
1191 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1192 return TTSD_ERROR_OPERATION_FAILED;
1195 if (NULL == engine_list) {
1196 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Input parameter is NULL" );
1197 return TTSD_ERROR_INVALID_PARAMETER;
1200 /* update engine list */
1201 if (0 != __internal_update_engine_list()) {
1202 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] fail __internal_update_engine_list()");
1203 return TTSD_ERROR_OPERATION_FAILED;
1207 ttsengine_info_s *data = NULL;
1209 iter = g_list_first(g_engine_list);
1211 SLOG(LOG_DEBUG, get_tag(), "----- [Engine Agent] engine list -----");
1213 while (NULL != iter) {
1214 engine_s* temp_engine;
1216 temp_engine = (engine_s*)g_malloc0(sizeof(engine_s));
1220 temp_engine->engine_id = strdup(data->engine_uuid);
1221 temp_engine->engine_name = strdup(data->engine_name);
1222 temp_engine->ug_name = strdup(data->setting_ug_path);
1224 *engine_list = g_list_append(*engine_list, temp_engine);
1226 iter = g_list_next(iter);
1228 SLOG(LOG_DEBUG, get_tag(), " -- engine id(%s) engine name(%s) ug name(%s)",
1229 temp_engine->engine_id, temp_engine->engine_name, temp_engine->ug_name);
1233 SLOG(LOG_DEBUG, get_tag(), "--------------------------------------");
1238 int ttsd_engine_setting_get_engine(char** engine_id)
1240 if (false == g_agent_init) {
1241 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1242 return TTSD_ERROR_OPERATION_FAILED;
1245 if (false == g_cur_engine.is_loaded) {
1246 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
1247 return TTSD_ERROR_ENGINE_NOT_FOUND;
1250 *engine_id = strdup(g_cur_engine.engine_uuid);
1255 int ttsd_engine_setting_set_engine(const char* engine_id)
1257 if (false == g_agent_init) {
1258 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1259 return TTSD_ERROR_OPERATION_FAILED;
1262 /* compare current engine and new engine.*/
1263 if (0 == strncmp(g_cur_engine.engine_uuid, engine_id, strlen(engine_id))) {
1264 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent] new engine(%s) is the same as current engine(%s)", engine_id, g_cur_engine.engine_uuid);
1268 char* tmp_uuid = NULL;
1269 tmp_uuid = strdup(g_cur_engine.engine_uuid);
1272 if (0 != ttsd_engine_agent_unload_current_engine()) {
1273 SLOG(LOG_ERROR, get_tag(), "[Engine Agent Error] fail to unload current engine");
1275 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent SUCCESS] unload current engine");
1278 /* change current engine */
1279 if (0 != __internal_set_current_engine(engine_id)) {
1280 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] fail __internal_set_current_engine()");
1282 /* roll back to old current engine. */
1283 __internal_set_current_engine(tmp_uuid);
1284 ttsd_engine_agent_load_current_engine();
1286 if (tmp_uuid != NULL)
1289 return TTSD_ERROR_OPERATION_FAILED;
1293 if (0 != ttsd_engine_agent_load_current_engine()) {
1294 SLOG(LOG_ERROR, get_tag(), "[Engine Agent Error] fail to load new engine");
1296 if( tmp_uuid != NULL )
1299 return TTSD_ERROR_OPERATION_FAILED;
1301 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent SUCCESS] load new engine");
1304 /* save engine id to config */
1305 if (0 != ttsd_config_set_default_engine(engine_id)) {
1306 SLOG(LOG_WARN, get_tag(), "[Engine Agent WARNING] Fail to save engine id to config");
1309 if (tmp_uuid != NULL)
1315 int ttsd_engine_setting_get_voice_list(char** engine_id, GList** voice_list)
1317 if (false == g_agent_init) {
1318 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1319 return TTSD_ERROR_OPERATION_FAILED;
1322 if (false == g_cur_engine.is_loaded) {
1323 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
1324 return TTSD_ERROR_OPERATION_FAILED;
1329 /* get language list from engine*/
1330 ret = ttsd_engine_get_voice_list(voice_list);
1332 SLOG(LOG_ERROR, get_tag(), "[Server Error] fail ttsd_engine_get_voice_list() ");
1336 *engine_id = strdup(g_cur_engine.engine_uuid);
1341 int ttsd_engine_setting_get_default_voice(char** language, ttsp_voice_type_e* vctype)
1343 if (false == g_agent_init) {
1344 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1345 return TTSD_ERROR_OPERATION_FAILED;
1348 if (false == g_cur_engine.is_loaded) {
1349 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
1350 return TTSD_ERROR_OPERATION_FAILED;
1353 /* get current language from engine*/
1356 ttsp_voice_type_e temp_int;
1358 ret = ttsd_engine_get_default_voice(&temp_lang, &temp_int);
1360 SLOG(LOG_ERROR, get_tag(), "[Server Error] fail ttsd_engine_get_default_voice()");
1364 if (NULL != temp_lang) {
1365 *language = strdup(temp_lang);
1369 SLOG(LOG_ERROR, get_tag(), "[Server Error] fail to get default language");
1370 return TTSD_ERROR_OPERATION_FAILED;
1376 int ttsd_engine_setting_set_default_voice(const char* language, ttsp_voice_type_e vctype)
1378 if (false == g_agent_init) {
1379 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1380 return TTSD_ERROR_OPERATION_FAILED;
1383 if (false == g_cur_engine.is_loaded) {
1384 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
1385 return TTSD_ERROR_OPERATION_FAILED;
1388 if (NULL == g_cur_engine.pefuncs->is_valid_voice) {
1389 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] The function of engine is NULL!!");
1390 return TTSD_ERROR_OPERATION_FAILED;
1394 if(false == g_cur_engine.pefuncs->is_valid_voice(language, vctype)) {
1395 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Voice is NOT valid !!");
1396 return TTSD_ERROR_INVALID_VOICE;
1399 if (NULL != g_cur_engine.default_lang)
1400 free(g_cur_engine.default_lang);
1402 g_cur_engine.default_lang = strdup(language);
1403 g_cur_engine.default_vctype = vctype;
1405 ret = ttsd_config_set_default_voice(language, (int)vctype);
1407 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent SUCCESS] Set default voice : lang(%s), type(%d)",
1408 g_cur_engine.default_lang, g_cur_engine.default_vctype);
1410 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] fail to write default voice to config (%d)", ret);
1416 int ttsd_engine_setting_get_default_speed(ttsp_speed_e* speed)
1418 if (false == g_agent_init) {
1419 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1420 return TTSD_ERROR_OPERATION_FAILED;
1423 if (false == g_cur_engine.is_loaded) {
1424 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
1425 return TTSD_ERROR_OPERATION_FAILED;
1428 /* get current language */
1429 *speed = g_cur_engine.default_speed;
1434 int ttsd_engine_setting_set_default_speed(const ttsp_speed_e speed)
1436 if (false == g_agent_init) {
1437 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1438 return TTSD_ERROR_OPERATION_FAILED;
1441 if (false == g_cur_engine.is_loaded) {
1442 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
1443 return TTSD_ERROR_OPERATION_FAILED;
1446 g_cur_engine.default_speed = speed;
1448 if (0 != ttsd_config_set_default_speed(speed)) {
1449 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] fail to set default speed to config");
1455 bool __engine_setting_cb(const char* key, const char* value, void* user_data)
1457 GList** engine_setting_list = (GList**)user_data;
1459 if (NULL == engine_setting_list || NULL == key || NULL == value) {
1460 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Input parameter is NULL in engine setting callback!!!!");
1464 engine_setting_s* temp = g_malloc0(sizeof(engine_setting_s));
1465 temp->key = g_strdup(key);
1466 temp->value = g_strdup(value);
1468 *engine_setting_list = g_list_append(*engine_setting_list, temp);
1474 int ttsd_engine_setting_get_engine_setting_info(char** engine_id, GList** setting_list)
1476 if (false == g_agent_init) {
1477 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1478 return TTSD_ERROR_OPERATION_FAILED;
1481 if (false == g_cur_engine.is_loaded) {
1482 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
1483 return TTSD_ERROR_OPERATION_FAILED;
1486 if (NULL == setting_list) {
1487 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Input parameter is NULL");
1488 return TTSD_ERROR_INVALID_PARAMETER;
1491 if (NULL == g_cur_engine.pefuncs->foreach_engine_setting) {
1492 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] foreach_engine_setting() of engine is NULL!!");
1493 return TTSD_ERROR_OPERATION_FAILED;
1496 /* get setting info and move setting info to input parameter */
1499 result = g_cur_engine.pefuncs->foreach_engine_setting(__engine_setting_cb, setting_list);
1501 if (0 == result && 0 < g_list_length(*setting_list)) {
1502 *engine_id = strdup(g_cur_engine.engine_uuid);
1504 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] fail to get setting info : result(%d)", result);
1505 result = TTSD_ERROR_OPERATION_FAILED;
1511 int ttsd_engine_setting_set_engine_setting(const char* key, const char* value)
1513 if (false == g_agent_init) {
1514 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1515 return TTSD_ERROR_OPERATION_FAILED;
1518 if (false == g_cur_engine.is_loaded) {
1519 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
1520 return TTSD_ERROR_OPERATION_FAILED;
1523 if (NULL == g_cur_engine.pefuncs->set_engine_setting) {
1524 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] set_setting_info of engine is NULL!!");
1525 return TTSD_ERROR_OPERATION_FAILED;
1528 /* get setting info and move setting info to input parameter */
1530 ret = g_cur_engine.pefuncs->set_engine_setting(key, value);
1533 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] fail to set engine setting : result(%d)", ret);
1534 return TTSD_ERROR_OPERATION_FAILED;
1540 void __free_voice_list(GList* voice_list)
1543 voice_s* data = NULL;
1545 /* if list have item */
1546 if (g_list_length(voice_list) > 0) {
1547 /* Get a first item */
1548 iter = g_list_first(voice_list);
1550 while (NULL != iter) {
1554 if (NULL != data->language)
1555 g_free(data->language);
1560 voice_list = g_list_remove_link(voice_list, iter);
1562 iter = g_list_first(voice_list);
1568 * TTS Engine Callback Functions ` *
1570 bool __result_cb(ttsp_result_event_e event, const void* data, unsigned int data_size, void *user_data)
1572 g_result_cb(event, data, data_size, user_data);
1577 /* function for debugging */
1578 int ttsd_print_enginelist()
1581 ttsengine_info_s *data = NULL;
1583 if (g_list_length(g_engine_list) > 0) {
1584 iter = g_list_first(g_engine_list);
1586 SLOG(LOG_DEBUG, get_tag(), "----- engine list -----");
1589 while (NULL != iter) {
1592 SLOG(LOG_DEBUG, get_tag(), "[%dth]", i);
1593 SLOG(LOG_DEBUG, get_tag(), "engine uuid : %s", data->engine_uuid);
1594 SLOG(LOG_DEBUG, get_tag(), "engine name : %s", data->engine_name);
1595 SLOG(LOG_DEBUG, get_tag(), "engine path : %s", data->engine_path);
1596 SLOG(LOG_DEBUG, get_tag(), "setting ug path : %s", data->setting_ug_path);
1598 iter = g_list_next(iter);
1601 SLOG(LOG_DEBUG, get_tag(), "-----------------------");
1602 SLOG(LOG_DEBUG, get_tag(), " ");
1604 SLOG(LOG_DEBUG, get_tag(), "----- engine list -----");
1605 SLOG(LOG_DEBUG, get_tag(), "No Engine in directory");
1606 SLOG(LOG_DEBUG, get_tag(), "-----------------------");