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\n");
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\n");
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_NOTIFICATION == ttsd_get_mode() || 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\n");
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\n", 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\n", 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)\n",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)\n", 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)\n",
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);
670 if (true != g_cur_engine.pefuncs->is_valid_voice(voice->language, voice->type)) {
671 SLOG(LOG_ERROR, get_tag(), "[Engine ERROR] Fail voice is NOT valid");
672 return TTSD_ERROR_OPERATION_FAILED;
675 ttsd_config_set_default_voice(voice->language, (int)voice->type);
677 g_cur_engine.default_lang = g_strdup(voice->language);
678 g_cur_engine.default_vctype = voice->type;
680 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent SUCCESS] Select default voice : lang(%s), type(%d)",
681 voice->language, voice->type);
685 SLOG(LOG_ERROR, get_tag(), "[Engine ERROR] Fail to get language list : result(%d)\n", ret);
686 return TTSD_ERROR_OPERATION_FAILED;
689 __free_voice_list(voice_list);
691 SLOG(LOG_ERROR, get_tag(), "[Engine ERROR] Fail to get language list : result(%d)\n", ret);
692 return TTSD_ERROR_OPERATION_FAILED;
696 g_cur_engine.is_loaded = true;
701 int ttsd_engine_agent_unload_current_engine()
703 if (false == g_agent_init) {
704 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
705 return TTSD_ERROR_OPERATION_FAILED;
708 if (false == g_cur_engine.is_set) {
709 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] No Current Engine ");
710 return TTSD_ERROR_OPERATION_FAILED;
713 if (false == g_cur_engine.is_loaded) {
714 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent] Engine has already been unloaded " );
718 /* shutdown engine */
719 if (NULL == g_cur_engine.pefuncs->deinitialize) {
720 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] The deinitialize() of engine is NULL!!");
723 ret = g_cur_engine.pefuncs->deinitialize();
725 SLOG(LOG_ERROR, get_tag(), "[Engine Agent] Fail deinitialize() : result(%d)\n", ret);
730 g_cur_engine.ttsp_unload_engine();
732 dlclose(g_cur_engine.handle);
734 /* reset current engine data */
735 g_cur_engine.handle = NULL;
736 g_cur_engine.is_loaded = false;
741 bool ttsd_engine_agent_need_network()
743 if (false == g_agent_init) {
744 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
745 return TTSD_ERROR_OPERATION_FAILED;
748 if (false == g_cur_engine.is_loaded) {
749 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
750 return TTSD_ERROR_OPERATION_FAILED;
753 return g_cur_engine.need_network;
756 bool ttsd_engine_select_valid_voice(const char* lang, int type, char** out_lang, ttsp_voice_type_e* out_type)
758 if (NULL == lang || NULL == out_lang || NULL == out_type) {
762 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent] Select voice : input lang(%s) , input type(%d), default lang(%s), default type(%d)",
763 lang, type, g_cur_engine.default_lang, g_cur_engine.default_vctype);
766 /* case 1 : Both are default */
767 if (0 == strncmp(lang, "default", strlen("default")) && 0 == type) {
768 *out_lang = strdup(g_cur_engine.default_lang);
769 *out_type = g_cur_engine.default_vctype;
774 if (NULL == g_cur_engine.pefuncs->foreach_voices) {
775 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] foreach_voices of engine is NULL!!");
776 return TTSD_ERROR_OPERATION_FAILED;
779 GList* voice_list = NULL;
782 ret = g_cur_engine.pefuncs->foreach_voices(__supported_voice_cb, &voice_list);
783 if (0 != ret || 0 >= g_list_length(voice_list)) {
784 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] fail to get voice list : result(%d)", ret);
794 /* lang and type are not default type */
795 if (0 != strncmp(lang, "default", strlen("default")) && 0 != type) {
796 iter = g_list_first(voice_list);
798 while (NULL != iter) {
799 /* Get handle data from list */
802 if (0 == strncmp(voice->language, lang, strlen(lang)) && voice->type == type) {
803 *out_lang = strdup(voice->language);
804 *out_type = voice->type;
809 iter = g_list_next(iter);
812 } else if (0 != strncmp(lang, "default", strlen("default")) && 0 == type) {
813 /* Only type is default */
814 if (0 == strncmp(lang, g_cur_engine.default_lang, strlen(g_cur_engine.default_lang))) {
815 *out_lang = strdup(g_cur_engine.default_lang);
816 *out_type = g_cur_engine.default_vctype;
819 voice_s* voice_selected = NULL;
820 iter = g_list_first(voice_list);
821 while (NULL != iter) {
822 /* Get handle data from list */
825 if (0 == strncmp(voice->language, lang, strlen(lang))) {
826 voice_selected = voice;
827 if (voice->type == g_cur_engine.default_vctype) {
828 voice_selected = voice;
832 iter = g_list_next(iter);
835 if (NULL != voice_selected) {
836 *out_lang = strdup(voice_selected->language);
837 *out_type = voice_selected->type;
841 } else if (0 == strncmp(lang, "default", strlen("default")) && 0 != type) {
842 /* Only lang is default */
843 if (type == g_cur_engine.default_vctype) {
844 *out_lang = strdup(g_cur_engine.default_lang);
845 *out_type = g_cur_engine.default_vctype;
848 voice_s* voice_selected = NULL;
849 iter = g_list_first(voice_list);
850 while (NULL != iter) {
851 /* Get handle data from list */
854 if (0 == strncmp(voice->language, g_cur_engine.default_lang, strlen(g_cur_engine.default_lang)) ) {
855 voice_selected = voice;
856 if (voice->type == type) {
857 voice_selected = voice;
861 iter = g_list_next(iter);
864 if (NULL != voice_selected) {
865 *out_lang = strdup(voice->language);
866 *out_type = voice_selected->type;
872 if (true == result) {
873 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent] Selected voice : lang(%s), type(%d)", *out_lang, *out_type);
876 __free_voice_list(voice_list);
881 bool ttsd_engine_agent_is_same_engine(const char* engine_id)
883 if (false == g_agent_init) {
884 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
888 if (false == g_cur_engine.is_loaded) {
889 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
893 /* compare current engine and engine id.*/
894 if (0 == strncmp(g_cur_engine.engine_uuid, engine_id, strlen(engine_id))) {
901 int ttsd_engine_agent_set_default_voice(const char* language, ttsp_voice_type_e vctype)
903 if (false == g_agent_init) {
904 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
905 return TTSD_ERROR_OPERATION_FAILED;
908 if (false == g_cur_engine.is_loaded) {
909 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
910 return TTSD_ERROR_OPERATION_FAILED;
913 if (NULL == g_cur_engine.pefuncs->is_valid_voice) {
914 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] The function of engine is NULL!!");
915 return TTSD_ERROR_OPERATION_FAILED;
919 if(false == g_cur_engine.pefuncs->is_valid_voice(language, vctype)) {
920 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Voice is NOT valid !!");
921 return TTSD_ERROR_INVALID_VOICE;
924 if (NULL != g_cur_engine.default_lang)
925 free(g_cur_engine.default_lang);
927 g_cur_engine.default_lang = strdup(language);
928 g_cur_engine.default_vctype = vctype;
930 ret = ttsd_config_set_default_voice(language, (int)vctype);
932 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent SUCCESS] Set default voice : lang(%s), type(%d)",
933 g_cur_engine.default_lang, g_cur_engine.default_vctype);
935 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] fail to write default voice to config (%d)", ret);
936 return TTSD_ERROR_OPERATION_FAILED;
942 /******************************************************************************************
943 * TTS Engine Interfaces for client
944 *******************************************************************************************/
946 int ttsd_engine_start_synthesis(const char* lang, const ttsp_voice_type_e vctype, const char* text, const int speed, void* user_param)
948 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent] start ttsd_engine_start_synthesis()");
950 if (false == g_agent_init) {
951 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
952 return TTSD_ERROR_OPERATION_FAILED;
955 if (false == g_cur_engine.is_loaded) {
956 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
957 return TTSD_ERROR_OPERATION_FAILED;
960 /* select voice for default */
961 char* temp_lang = NULL;
962 ttsp_voice_type_e temp_type;
963 if (true != ttsd_engine_select_valid_voice(lang, vctype, &temp_lang, &temp_type)) {
964 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Fail to select default voice");
965 return TTSD_ERROR_INVALID_VOICE;
967 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent] Start synthesis : language(%s), type(%d), speed(%d), text(%s)",
968 temp_lang, temp_type, speed, text);
971 if (NULL == g_cur_engine.pefuncs->start_synth) {
972 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] start_synth() of engine is NULL!!");
973 return TTSD_ERROR_OPERATION_FAILED;
976 ttsp_speed_e temp_speed;
979 temp_speed = g_cur_engine.default_speed;
984 /* synthesize text */
986 ret = g_cur_engine.pefuncs->start_synth(temp_lang, temp_type, text, temp_speed, user_param);
988 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] ***************************************", ret);
989 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] * synthesize error : result(%6d) *", ret);
990 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] ***************************************", ret);
991 return TTSD_ERROR_OPERATION_FAILED;
994 if (NULL == temp_lang)
1001 int ttsd_engine_cancel_synthesis()
1003 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent] start ttsd_engine_cancel_synthesis()");
1005 if (false == g_agent_init) {
1006 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1007 return TTSD_ERROR_OPERATION_FAILED;
1010 if (false == g_cur_engine.is_loaded) {
1011 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
1012 return TTSD_ERROR_OPERATION_FAILED;
1015 if (NULL == g_cur_engine.pefuncs->cancel_synth) {
1016 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] cancel_synth() of engine is NULL!!");
1017 return TTSD_ERROR_OPERATION_FAILED;
1020 /* stop synthesis */
1022 ret = g_cur_engine.pefuncs->cancel_synth();
1024 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] fail cancel synthesis : result(%d)", ret);
1025 return TTSD_ERROR_OPERATION_FAILED;
1031 int ttsd_engine_get_audio_format( ttsp_audio_type_e* type, int* rate, int* channels)
1033 if (false == g_agent_init) {
1034 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1035 return TTSD_ERROR_OPERATION_FAILED;
1038 if (false == g_cur_engine.is_loaded) {
1039 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
1040 return TTSD_ERROR_OPERATION_FAILED;
1043 if (NULL == g_cur_engine.pefuncs->get_audio_format) {
1044 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] get_audio_format() of engine is NULL!!");
1045 return TTSD_ERROR_OPERATION_FAILED;
1049 ret = g_cur_engine.pefuncs->get_audio_format(type, rate, channels);
1051 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] fail to get audio format : result(%d)", ret);
1052 return TTSD_ERROR_OPERATION_FAILED;
1054 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent] get audio format : type(%d), rate(%d), channel(%d)", *type, *rate, *channels);
1059 bool __supported_voice_cb(const char* language, ttsp_voice_type_e type, void* user_data)
1061 GList** voice_list = (GList**)user_data;
1063 if (NULL == language || NULL == voice_list) {
1064 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Input parameter is NULL in voice list callback!!!!");
1068 SLOG(LOG_DEBUG, get_tag(), "-- Language(%s), Type(%d)", language, type);
1070 voice_s* voice = g_malloc0(sizeof(voice_s));
1071 voice->language = strdup(language);
1074 *voice_list = g_list_append(*voice_list, voice);
1079 int ttsd_engine_get_voice_list(GList** voice_list)
1081 if (false == g_agent_init) {
1082 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1083 return TTSD_ERROR_OPERATION_FAILED;
1086 if (false == g_cur_engine.is_loaded) {
1087 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
1088 return TTSD_ERROR_OPERATION_FAILED;
1091 if (NULL == g_cur_engine.pefuncs->foreach_voices) {
1092 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] The function of engine is NULL!!");
1093 return TTSD_ERROR_OPERATION_FAILED;
1097 ret = g_cur_engine.pefuncs->foreach_voices(__supported_voice_cb, (void*)voice_list);
1099 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Fail to get voice list : result(%d)", ret);
1100 return TTSD_ERROR_OPERATION_FAILED;
1106 int ttsd_engine_get_default_voice( char** lang, ttsp_voice_type_e* vctype )
1108 if (false == g_agent_init) {
1109 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1110 return TTSD_ERROR_OPERATION_FAILED;
1113 if (false == g_cur_engine.is_loaded) {
1114 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
1115 return TTSD_ERROR_OPERATION_FAILED;
1118 if (NULL == lang || NULL == vctype) {
1119 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] BAD Parameter");
1120 return TTSD_ERROR_INVALID_PARAMETER;
1123 if (NULL != g_cur_engine.default_lang) {
1124 *lang = g_strdup(g_cur_engine.default_lang);
1125 *vctype = g_cur_engine.default_vctype;
1127 SLOG(LOG_DEBUG, get_tag(), "[Engine] Get default voice : language(%s), type(%d)\n", *lang, *vctype);
1129 if (NULL == g_cur_engine.pefuncs->foreach_voices) {
1130 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] get_voice_list of engine is NULL!!");
1131 return TTSD_ERROR_OPERATION_FAILED;
1134 /* get language list */
1136 GList* voice_list = NULL;
1138 ret = g_cur_engine.pefuncs->foreach_voices(__supported_voice_cb, &voice_list);
1140 if (0 == ret && 0 < g_list_length(voice_list)) {
1144 iter = g_list_first(voice_list);
1149 if (true != g_cur_engine.pefuncs->is_valid_voice(voice->language, voice->type)) {
1150 SLOG(LOG_ERROR, get_tag(), "[Engine ERROR] Fail voice is NOT valid ");
1151 return TTSD_ERROR_OPERATION_FAILED;
1154 ttsd_config_set_default_voice(voice->language, (int)voice->type);
1156 if (NULL != g_cur_engine.default_lang)
1157 g_free(g_cur_engine.default_lang);
1159 g_cur_engine.default_lang = g_strdup(voice->language);
1160 g_cur_engine.default_vctype = voice->type;
1162 *lang = g_strdup(g_cur_engine.default_lang);
1163 *vctype = g_cur_engine.default_vctype = voice->type;
1165 SLOG(LOG_DEBUG, get_tag(), "[Engine] Get default voice (New selected) : language(%s), type(%d)\n", *lang, *vctype);
1167 SLOG(LOG_ERROR, get_tag(), "[Engine ERROR] Fail to get language list : result(%d)\n", ret);
1168 return TTSD_ERROR_OPERATION_FAILED;
1171 __free_voice_list(voice_list);
1173 SLOG(LOG_ERROR, get_tag(), "[Engine ERROR] Fail to get language list : result(%d)\n", ret);
1174 return TTSD_ERROR_OPERATION_FAILED;
1182 * TTS Engine Interfaces for setting
1184 int ttsd_engine_setting_get_engine_list(GList** engine_list)
1186 if (false == g_agent_init) {
1187 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1188 return TTSD_ERROR_OPERATION_FAILED;
1191 if (NULL == engine_list) {
1192 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Input parameter is NULL" );
1193 return TTSD_ERROR_INVALID_PARAMETER;
1196 /* update engine list */
1197 if (0 != __internal_update_engine_list()) {
1198 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] fail __internal_update_engine_list()");
1199 return TTSD_ERROR_OPERATION_FAILED;
1203 ttsengine_info_s *data = NULL;
1205 iter = g_list_first(g_engine_list);
1207 SLOG(LOG_DEBUG, get_tag(), "----- [Engine Agent] engine list -----");
1209 while (NULL != iter) {
1210 engine_s* temp_engine;
1212 temp_engine = (engine_s*)g_malloc0(sizeof(engine_s));
1216 temp_engine->engine_id = strdup(data->engine_uuid);
1217 temp_engine->engine_name = strdup(data->engine_name);
1218 temp_engine->ug_name = strdup(data->setting_ug_path);
1220 *engine_list = g_list_append(*engine_list, temp_engine);
1222 iter = g_list_next(iter);
1224 SLOG(LOG_DEBUG, get_tag(), " -- engine id(%s) engine name(%s) ug name(%s)",
1225 temp_engine->engine_id, temp_engine->engine_name, temp_engine->ug_name);
1229 SLOG(LOG_DEBUG, get_tag(), "--------------------------------------");
1234 int ttsd_engine_setting_get_engine(char** engine_id)
1236 if (false == g_agent_init) {
1237 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1238 return TTSD_ERROR_OPERATION_FAILED;
1241 if (false == g_cur_engine.is_loaded) {
1242 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
1243 return TTSD_ERROR_ENGINE_NOT_FOUND;
1246 *engine_id = strdup(g_cur_engine.engine_uuid);
1251 int ttsd_engine_setting_set_engine(const char* engine_id)
1253 if (false == g_agent_init) {
1254 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1255 return TTSD_ERROR_OPERATION_FAILED;
1258 /* compare current engine and new engine.*/
1259 if (0 == strncmp(g_cur_engine.engine_uuid, engine_id, strlen(engine_id))) {
1260 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent] new engine(%s) is the same as current engine(%s)", engine_id, g_cur_engine.engine_uuid);
1264 char* tmp_uuid = NULL;
1265 tmp_uuid = strdup(g_cur_engine.engine_uuid);
1268 if (0 != ttsd_engine_agent_unload_current_engine()) {
1269 SLOG(LOG_ERROR, get_tag(), "[Engine Agent Error] fail to unload current engine");
1271 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent SUCCESS] unload current engine");
1274 /* change current engine */
1275 if (0 != __internal_set_current_engine(engine_id)) {
1276 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] fail __internal_set_current_engine()");
1278 /* roll back to old current engine. */
1279 __internal_set_current_engine(tmp_uuid);
1280 ttsd_engine_agent_load_current_engine();
1282 if (tmp_uuid != NULL)
1285 return TTSD_ERROR_OPERATION_FAILED;
1289 if (0 != ttsd_engine_agent_load_current_engine()) {
1290 SLOG(LOG_ERROR, get_tag(), "[Engine Agent Error] fail to load new engine");
1292 if( tmp_uuid != NULL )
1295 return TTSD_ERROR_OPERATION_FAILED;
1297 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent SUCCESS] load new engine");
1300 /* save engine id to config */
1301 if (0 != ttsd_config_set_default_engine(engine_id)) {
1302 SLOG(LOG_WARN, get_tag(), "[Engine Agent WARNING] Fail to save engine id to config");
1305 if (tmp_uuid != NULL)
1311 int ttsd_engine_setting_get_voice_list(char** engine_id, GList** voice_list)
1313 if (false == g_agent_init) {
1314 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1315 return TTSD_ERROR_OPERATION_FAILED;
1318 if (false == g_cur_engine.is_loaded) {
1319 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
1320 return TTSD_ERROR_OPERATION_FAILED;
1325 /* get language list from engine*/
1326 ret = ttsd_engine_get_voice_list(voice_list);
1328 SLOG(LOG_ERROR, get_tag(), "[Server Error] fail ttsd_engine_get_voice_list() ");
1332 *engine_id = strdup(g_cur_engine.engine_uuid);
1337 int ttsd_engine_setting_get_default_voice(char** language, ttsp_voice_type_e* vctype)
1339 if (false == g_agent_init) {
1340 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1341 return TTSD_ERROR_OPERATION_FAILED;
1344 if (false == g_cur_engine.is_loaded) {
1345 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
1346 return TTSD_ERROR_OPERATION_FAILED;
1349 /* get current language from engine*/
1352 ttsp_voice_type_e temp_int;
1354 ret = ttsd_engine_get_default_voice(&temp_lang, &temp_int);
1356 SLOG(LOG_ERROR, get_tag(), "[Server Error] fail ttsd_engine_get_default_voice()");
1360 if (NULL != temp_lang) {
1361 *language = strdup(temp_lang);
1365 SLOG(LOG_ERROR, get_tag(), "[Server Error] fail to get default language");
1366 return TTSD_ERROR_OPERATION_FAILED;
1372 int ttsd_engine_setting_set_default_voice(const char* language, ttsp_voice_type_e vctype)
1374 if (false == g_agent_init) {
1375 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1376 return TTSD_ERROR_OPERATION_FAILED;
1379 if (false == g_cur_engine.is_loaded) {
1380 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
1381 return TTSD_ERROR_OPERATION_FAILED;
1384 if (NULL == g_cur_engine.pefuncs->is_valid_voice) {
1385 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] The function of engine is NULL!!");
1386 return TTSD_ERROR_OPERATION_FAILED;
1390 if(false == g_cur_engine.pefuncs->is_valid_voice(language, vctype)) {
1391 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Voice is NOT valid !!");
1392 return TTSD_ERROR_INVALID_VOICE;
1395 if (NULL != g_cur_engine.default_lang)
1396 free(g_cur_engine.default_lang);
1398 g_cur_engine.default_lang = strdup(language);
1399 g_cur_engine.default_vctype = vctype;
1401 ret = ttsd_config_set_default_voice(language, (int)vctype);
1403 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent SUCCESS] Set default voice : lang(%s), type(%d)",
1404 g_cur_engine.default_lang, g_cur_engine.default_vctype);
1406 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] fail to write default voice to config (%d)", ret);
1412 int ttsd_engine_setting_get_default_speed(ttsp_speed_e* speed)
1414 if (false == g_agent_init) {
1415 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1416 return TTSD_ERROR_OPERATION_FAILED;
1419 if (false == g_cur_engine.is_loaded) {
1420 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
1421 return TTSD_ERROR_OPERATION_FAILED;
1424 /* get current language */
1425 *speed = g_cur_engine.default_speed;
1430 int ttsd_engine_setting_set_default_speed(const ttsp_speed_e speed)
1432 if (false == g_agent_init) {
1433 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1434 return TTSD_ERROR_OPERATION_FAILED;
1437 if (false == g_cur_engine.is_loaded) {
1438 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
1439 return TTSD_ERROR_OPERATION_FAILED;
1442 g_cur_engine.default_speed = speed;
1444 if (0 != ttsd_config_set_default_speed(speed)) {
1445 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] fail to set default speed to config");
1451 bool __engine_setting_cb(const char* key, const char* value, void* user_data)
1453 GList** engine_setting_list = (GList**)user_data;
1455 if (NULL == engine_setting_list || NULL == key || NULL == value) {
1456 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Input parameter is NULL in engine setting callback!!!!");
1460 engine_setting_s* temp = g_malloc0(sizeof(engine_setting_s));
1461 temp->key = g_strdup(key);
1462 temp->value = g_strdup(value);
1464 *engine_setting_list = g_list_append(*engine_setting_list, temp);
1470 int ttsd_engine_setting_get_engine_setting_info(char** engine_id, GList** setting_list)
1472 if (false == g_agent_init) {
1473 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1474 return TTSD_ERROR_OPERATION_FAILED;
1477 if (false == g_cur_engine.is_loaded) {
1478 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
1479 return TTSD_ERROR_OPERATION_FAILED;
1482 if (NULL == setting_list) {
1483 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Input parameter is NULL");
1484 return TTSD_ERROR_INVALID_PARAMETER;
1487 if (NULL == g_cur_engine.pefuncs->foreach_engine_setting) {
1488 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] foreach_engine_setting() of engine is NULL!!");
1489 return TTSD_ERROR_OPERATION_FAILED;
1492 /* get setting info and move setting info to input parameter */
1495 result = g_cur_engine.pefuncs->foreach_engine_setting(__engine_setting_cb, setting_list);
1497 if (0 == result && 0 < g_list_length(*setting_list)) {
1498 *engine_id = strdup(g_cur_engine.engine_uuid);
1500 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] fail to get setting info : result(%d)\n", result);
1501 result = TTSD_ERROR_OPERATION_FAILED;
1507 int ttsd_engine_setting_set_engine_setting(const char* key, const char* value)
1509 if (false == g_agent_init) {
1510 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1511 return TTSD_ERROR_OPERATION_FAILED;
1514 if (false == g_cur_engine.is_loaded) {
1515 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
1516 return TTSD_ERROR_OPERATION_FAILED;
1519 if (NULL == g_cur_engine.pefuncs->set_engine_setting) {
1520 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] set_setting_info of engine is NULL!!");
1521 return TTSD_ERROR_OPERATION_FAILED;
1524 /* get setting info and move setting info to input parameter */
1526 ret = g_cur_engine.pefuncs->set_engine_setting(key, value);
1529 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] fail to set engine setting : result(%d)\n", ret);
1530 return TTSD_ERROR_OPERATION_FAILED;
1536 void __free_voice_list(GList* voice_list)
1539 voice_s* data = NULL;
1541 /* if list have item */
1542 if (g_list_length(voice_list) > 0) {
1543 /* Get a first item */
1544 iter = g_list_first(voice_list);
1546 while (NULL != iter) {
1550 if (NULL != data->language)
1551 g_free(data->language);
1556 voice_list = g_list_remove_link(voice_list, iter);
1558 iter = g_list_first(voice_list);
1564 * TTS Engine Callback Functions ` *
1566 bool __result_cb(ttsp_result_event_e event, const void* data, unsigned int data_size, void *user_data)
1568 g_result_cb(event, data, data_size, user_data);
1573 /* function for debugging */
1574 int ttsd_print_enginelist()
1577 ttsengine_info_s *data = NULL;
1579 if (g_list_length(g_engine_list) > 0) {
1580 iter = g_list_first(g_engine_list);
1582 SLOG(LOG_DEBUG, get_tag(), "----- engine list -----");
1585 while (NULL != iter) {
1588 SLOG(LOG_DEBUG, get_tag(), "[%dth]\n", i);
1589 SLOG(LOG_DEBUG, get_tag(), "engine uuid : %s\n", data->engine_uuid);
1590 SLOG(LOG_DEBUG, get_tag(), "engine name : %s\n", data->engine_name);
1591 SLOG(LOG_DEBUG, get_tag(), "engine path : %s\n", data->engine_path);
1592 SLOG(LOG_DEBUG, get_tag(), "setting ug path : %s\n", data->setting_ug_path);
1594 iter = g_list_next(iter);
1597 SLOG(LOG_DEBUG, get_tag(), "-----------------------");
1598 SLOG(LOG_DEBUG, get_tag(), " ");
1600 SLOG(LOG_DEBUG, get_tag(), "----- engine list -----");
1601 SLOG(LOG_DEBUG, get_tag(), "No Engine in directory");
1602 SLOG(LOG_DEBUG, get_tag(), "-----------------------");