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);
939 /******************************************************************************************
940 * TTS Engine Interfaces for client
941 *******************************************************************************************/
943 int ttsd_engine_start_synthesis(const char* lang, const ttsp_voice_type_e vctype, const char* text, const int speed, void* user_param)
945 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent] start ttsd_engine_start_synthesis()");
947 if (false == g_agent_init) {
948 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
949 return TTSD_ERROR_OPERATION_FAILED;
952 if (false == g_cur_engine.is_loaded) {
953 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
954 return TTSD_ERROR_OPERATION_FAILED;
957 /* select voice for default */
958 char* temp_lang = NULL;
959 ttsp_voice_type_e temp_type;
960 if (true != ttsd_engine_select_valid_voice(lang, vctype, &temp_lang, &temp_type)) {
961 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Fail to select default voice");
962 return TTSD_ERROR_INVALID_VOICE;
964 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent] Start synthesis : language(%s), type(%d), speed(%d), text(%s)",
965 temp_lang, temp_type, speed, text);
968 if (NULL == g_cur_engine.pefuncs->start_synth) {
969 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] start_synth() of engine is NULL!!");
970 return TTSD_ERROR_OPERATION_FAILED;
973 ttsp_speed_e temp_speed;
976 temp_speed = g_cur_engine.default_speed;
981 /* synthesize text */
983 ret = g_cur_engine.pefuncs->start_synth(temp_lang, temp_type, text, temp_speed, user_param);
985 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] ***************************************", ret);
986 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] * synthesize error : result(%6d) *", ret);
987 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] ***************************************", ret);
988 return TTSD_ERROR_OPERATION_FAILED;
991 if (NULL == temp_lang)
998 int ttsd_engine_cancel_synthesis()
1000 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent] start ttsd_engine_cancel_synthesis()");
1002 if (false == g_agent_init) {
1003 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1004 return TTSD_ERROR_OPERATION_FAILED;
1007 if (false == g_cur_engine.is_loaded) {
1008 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
1009 return TTSD_ERROR_OPERATION_FAILED;
1012 if (NULL == g_cur_engine.pefuncs->cancel_synth) {
1013 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] cancel_synth() of engine is NULL!!");
1014 return TTSD_ERROR_OPERATION_FAILED;
1017 /* stop synthesis */
1019 ret = g_cur_engine.pefuncs->cancel_synth();
1021 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] fail cancel synthesis : result(%d)", ret);
1022 return TTSD_ERROR_OPERATION_FAILED;
1028 int ttsd_engine_get_audio_format( ttsp_audio_type_e* type, int* rate, int* channels)
1030 if (false == g_agent_init) {
1031 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1032 return TTSD_ERROR_OPERATION_FAILED;
1035 if (false == g_cur_engine.is_loaded) {
1036 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
1037 return TTSD_ERROR_OPERATION_FAILED;
1040 if (NULL == g_cur_engine.pefuncs->get_audio_format) {
1041 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] get_audio_format() of engine is NULL!!");
1042 return TTSD_ERROR_OPERATION_FAILED;
1046 ret = g_cur_engine.pefuncs->get_audio_format(type, rate, channels);
1048 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] fail to get audio format : result(%d)", ret);
1049 return TTSD_ERROR_OPERATION_FAILED;
1051 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent] get audio format : type(%d), rate(%d), channel(%d)", *type, *rate, *channels);
1056 bool __supported_voice_cb(const char* language, ttsp_voice_type_e type, void* user_data)
1058 GList** voice_list = (GList**)user_data;
1060 if (NULL == language || NULL == voice_list) {
1061 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Input parameter is NULL in voice list callback!!!!");
1065 SLOG(LOG_DEBUG, get_tag(), "-- Language(%s), Type(%d)", language, type);
1067 voice_s* voice = g_malloc0(sizeof(voice_s));
1068 voice->language = strdup(language);
1071 *voice_list = g_list_append(*voice_list, voice);
1076 int ttsd_engine_get_voice_list(GList** voice_list)
1078 if (false == g_agent_init) {
1079 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1080 return TTSD_ERROR_OPERATION_FAILED;
1083 if (false == g_cur_engine.is_loaded) {
1084 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
1085 return TTSD_ERROR_OPERATION_FAILED;
1088 if (NULL == g_cur_engine.pefuncs->foreach_voices) {
1089 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] The function of engine is NULL!!");
1090 return TTSD_ERROR_OPERATION_FAILED;
1094 ret = g_cur_engine.pefuncs->foreach_voices(__supported_voice_cb, (void*)voice_list);
1096 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Fail to get voice list : result(%d)", ret);
1097 return TTSD_ERROR_OPERATION_FAILED;
1103 int ttsd_engine_get_default_voice( char** lang, ttsp_voice_type_e* vctype )
1105 if (false == g_agent_init) {
1106 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1107 return TTSD_ERROR_OPERATION_FAILED;
1110 if (false == g_cur_engine.is_loaded) {
1111 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
1112 return TTSD_ERROR_OPERATION_FAILED;
1115 if (NULL == lang || NULL == vctype) {
1116 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] BAD Parameter");
1117 return TTSD_ERROR_INVALID_PARAMETER;
1120 if (NULL != g_cur_engine.default_lang) {
1121 *lang = g_strdup(g_cur_engine.default_lang);
1122 *vctype = g_cur_engine.default_vctype;
1124 SLOG(LOG_DEBUG, get_tag(), "[Engine] Get default voice : language(%s), type(%d)\n", *lang, *vctype);
1126 if (NULL == g_cur_engine.pefuncs->foreach_voices) {
1127 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] get_voice_list of engine is NULL!!");
1128 return TTSD_ERROR_OPERATION_FAILED;
1131 /* get language list */
1133 GList* voice_list = NULL;
1135 ret = g_cur_engine.pefuncs->foreach_voices(__supported_voice_cb, &voice_list);
1137 if (0 == ret && 0 < g_list_length(voice_list)) {
1141 iter = g_list_first(voice_list);
1146 if (true != g_cur_engine.pefuncs->is_valid_voice(voice->language, voice->type)) {
1147 SLOG(LOG_ERROR, get_tag(), "[Engine ERROR] Fail voice is NOT valid ");
1148 return TTSD_ERROR_OPERATION_FAILED;
1151 ttsd_config_set_default_voice(voice->language, (int)voice->type);
1153 if (NULL != g_cur_engine.default_lang)
1154 g_free(g_cur_engine.default_lang);
1156 g_cur_engine.default_lang = g_strdup(voice->language);
1157 g_cur_engine.default_vctype = voice->type;
1159 *lang = g_strdup(g_cur_engine.default_lang);
1160 *vctype = g_cur_engine.default_vctype = voice->type;
1162 SLOG(LOG_DEBUG, get_tag(), "[Engine] Get default voice (New selected) : language(%s), type(%d)\n", *lang, *vctype);
1164 SLOG(LOG_ERROR, get_tag(), "[Engine ERROR] Fail to get language list : result(%d)\n", ret);
1165 return TTSD_ERROR_OPERATION_FAILED;
1168 __free_voice_list(voice_list);
1170 SLOG(LOG_ERROR, get_tag(), "[Engine ERROR] Fail to get language list : result(%d)\n", ret);
1171 return TTSD_ERROR_OPERATION_FAILED;
1179 * TTS Engine Interfaces for setting
1181 int ttsd_engine_setting_get_engine_list(GList** engine_list)
1183 if (false == g_agent_init) {
1184 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1185 return TTSD_ERROR_OPERATION_FAILED;
1188 if (NULL == engine_list) {
1189 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Input parameter is NULL" );
1190 return TTSD_ERROR_INVALID_PARAMETER;
1193 /* update engine list */
1194 if (0 != __internal_update_engine_list()) {
1195 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] fail __internal_update_engine_list()");
1196 return TTSD_ERROR_OPERATION_FAILED;
1200 ttsengine_info_s *data = NULL;
1202 iter = g_list_first(g_engine_list);
1204 SLOG(LOG_DEBUG, get_tag(), "----- [Engine Agent] engine list -----");
1206 while (NULL != iter) {
1207 engine_s* temp_engine;
1209 temp_engine = (engine_s*)g_malloc0(sizeof(engine_s));
1213 temp_engine->engine_id = strdup(data->engine_uuid);
1214 temp_engine->engine_name = strdup(data->engine_name);
1215 temp_engine->ug_name = strdup(data->setting_ug_path);
1217 *engine_list = g_list_append(*engine_list, temp_engine);
1219 iter = g_list_next(iter);
1221 SLOG(LOG_DEBUG, get_tag(), " -- engine id(%s) engine name(%s) ug name(%s)",
1222 temp_engine->engine_id, temp_engine->engine_name, temp_engine->ug_name);
1226 SLOG(LOG_DEBUG, get_tag(), "--------------------------------------");
1231 int ttsd_engine_setting_get_engine(char** engine_id)
1233 if (false == g_agent_init) {
1234 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1235 return TTSD_ERROR_OPERATION_FAILED;
1238 if (false == g_cur_engine.is_loaded) {
1239 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
1240 return TTSD_ERROR_ENGINE_NOT_FOUND;
1243 *engine_id = strdup(g_cur_engine.engine_uuid);
1248 int ttsd_engine_setting_set_engine(const char* engine_id)
1250 if (false == g_agent_init) {
1251 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1252 return TTSD_ERROR_OPERATION_FAILED;
1255 /* compare current engine and new engine.*/
1256 if (0 == strncmp(g_cur_engine.engine_uuid, engine_id, strlen(engine_id))) {
1257 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent] new engine(%s) is the same as current engine(%s)", engine_id, g_cur_engine.engine_uuid);
1261 char* tmp_uuid = NULL;
1262 tmp_uuid = strdup(g_cur_engine.engine_uuid);
1265 if (0 != ttsd_engine_agent_unload_current_engine()) {
1266 SLOG(LOG_ERROR, get_tag(), "[Engine Agent Error] fail to unload current engine");
1268 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent SUCCESS] unload current engine");
1271 /* change current engine */
1272 if (0 != __internal_set_current_engine(engine_id)) {
1273 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] fail __internal_set_current_engine()");
1275 /* roll back to old current engine. */
1276 __internal_set_current_engine(tmp_uuid);
1277 ttsd_engine_agent_load_current_engine();
1279 if (tmp_uuid != NULL)
1282 return TTSD_ERROR_OPERATION_FAILED;
1286 if (0 != ttsd_engine_agent_load_current_engine()) {
1287 SLOG(LOG_ERROR, get_tag(), "[Engine Agent Error] fail to load new engine");
1289 if( tmp_uuid != NULL )
1292 return TTSD_ERROR_OPERATION_FAILED;
1294 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent SUCCESS] load new engine");
1297 /* save engine id to config */
1298 if (0 != ttsd_config_set_default_engine(engine_id)) {
1299 SLOG(LOG_WARN, get_tag(), "[Engine Agent WARNING] Fail to save engine id to config");
1302 if (tmp_uuid != NULL)
1308 int ttsd_engine_setting_get_voice_list(char** engine_id, GList** voice_list)
1310 if (false == g_agent_init) {
1311 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1312 return TTSD_ERROR_OPERATION_FAILED;
1315 if (false == g_cur_engine.is_loaded) {
1316 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
1317 return TTSD_ERROR_OPERATION_FAILED;
1322 /* get language list from engine*/
1323 ret = ttsd_engine_get_voice_list(voice_list);
1325 SLOG(LOG_ERROR, get_tag(), "[Server Error] fail ttsd_engine_get_voice_list() ");
1329 *engine_id = strdup(g_cur_engine.engine_uuid);
1334 int ttsd_engine_setting_get_default_voice(char** language, ttsp_voice_type_e* vctype)
1336 if (false == g_agent_init) {
1337 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1338 return TTSD_ERROR_OPERATION_FAILED;
1341 if (false == g_cur_engine.is_loaded) {
1342 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
1343 return TTSD_ERROR_OPERATION_FAILED;
1346 /* get current language from engine*/
1349 ttsp_voice_type_e temp_int;
1351 ret = ttsd_engine_get_default_voice(&temp_lang, &temp_int);
1353 SLOG(LOG_ERROR, get_tag(), "[Server Error] fail ttsd_engine_get_default_voice()");
1357 if (NULL != temp_lang) {
1358 *language = strdup(temp_lang);
1362 SLOG(LOG_ERROR, get_tag(), "[Server Error] fail to get default language");
1363 return TTSD_ERROR_OPERATION_FAILED;
1369 int ttsd_engine_setting_set_default_voice(const char* language, ttsp_voice_type_e vctype)
1371 if (false == g_agent_init) {
1372 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1373 return TTSD_ERROR_OPERATION_FAILED;
1376 if (false == g_cur_engine.is_loaded) {
1377 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
1378 return TTSD_ERROR_OPERATION_FAILED;
1381 if (NULL == g_cur_engine.pefuncs->is_valid_voice) {
1382 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] The function of engine is NULL!!");
1383 return TTSD_ERROR_OPERATION_FAILED;
1387 if(false == g_cur_engine.pefuncs->is_valid_voice(language, vctype)) {
1388 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Voice is NOT valid !!");
1389 return TTSD_ERROR_INVALID_VOICE;
1392 if (NULL != g_cur_engine.default_lang)
1393 free(g_cur_engine.default_lang);
1395 g_cur_engine.default_lang = strdup(language);
1396 g_cur_engine.default_vctype = vctype;
1398 ret = ttsd_config_set_default_voice(language, (int)vctype);
1400 SLOG(LOG_DEBUG, get_tag(), "[Engine Agent SUCCESS] Set default voice : lang(%s), type(%d)",
1401 g_cur_engine.default_lang, g_cur_engine.default_vctype);
1403 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] fail to write default voice to config (%d)", ret);
1409 int ttsd_engine_setting_get_default_speed(ttsp_speed_e* speed)
1411 if (false == g_agent_init) {
1412 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1413 return TTSD_ERROR_OPERATION_FAILED;
1416 if (false == g_cur_engine.is_loaded) {
1417 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
1418 return TTSD_ERROR_OPERATION_FAILED;
1421 /* get current language */
1422 *speed = g_cur_engine.default_speed;
1427 int ttsd_engine_setting_set_default_speed(const ttsp_speed_e speed)
1429 if (false == g_agent_init) {
1430 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1431 return TTSD_ERROR_OPERATION_FAILED;
1434 if (false == g_cur_engine.is_loaded) {
1435 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
1436 return TTSD_ERROR_OPERATION_FAILED;
1439 g_cur_engine.default_speed = speed;
1441 if (0 != ttsd_config_set_default_speed(speed)) {
1442 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] fail to set default speed to config");
1448 bool __engine_setting_cb(const char* key, const char* value, void* user_data)
1450 GList** engine_setting_list = (GList**)user_data;
1452 if (NULL == engine_setting_list || NULL == key || NULL == value) {
1453 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Input parameter is NULL in engine setting callback!!!!");
1457 engine_setting_s* temp = g_malloc0(sizeof(engine_setting_s));
1458 temp->key = g_strdup(key);
1459 temp->value = g_strdup(value);
1461 *engine_setting_list = g_list_append(*engine_setting_list, temp);
1467 int ttsd_engine_setting_get_engine_setting_info(char** engine_id, GList** setting_list)
1469 if (false == g_agent_init) {
1470 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1471 return TTSD_ERROR_OPERATION_FAILED;
1474 if (false == g_cur_engine.is_loaded) {
1475 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
1476 return TTSD_ERROR_OPERATION_FAILED;
1479 if (NULL == setting_list) {
1480 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Input parameter is NULL");
1481 return TTSD_ERROR_INVALID_PARAMETER;
1484 if (NULL == g_cur_engine.pefuncs->foreach_engine_setting) {
1485 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] foreach_engine_setting() of engine is NULL!!");
1486 return TTSD_ERROR_OPERATION_FAILED;
1489 /* get setting info and move setting info to input parameter */
1492 result = g_cur_engine.pefuncs->foreach_engine_setting(__engine_setting_cb, setting_list);
1494 if (0 == result && 0 < g_list_length(*setting_list)) {
1495 *engine_id = strdup(g_cur_engine.engine_uuid);
1497 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] fail to get setting info : result(%d)\n", result);
1498 result = TTSD_ERROR_OPERATION_FAILED;
1504 int ttsd_engine_setting_set_engine_setting(const char* key, const char* value)
1506 if (false == g_agent_init) {
1507 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not Initialized" );
1508 return TTSD_ERROR_OPERATION_FAILED;
1511 if (false == g_cur_engine.is_loaded) {
1512 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] Not loaded engine");
1513 return TTSD_ERROR_OPERATION_FAILED;
1516 if (NULL == g_cur_engine.pefuncs->set_engine_setting) {
1517 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] set_setting_info of engine is NULL!!");
1518 return TTSD_ERROR_OPERATION_FAILED;
1521 /* get setting info and move setting info to input parameter */
1523 ret = g_cur_engine.pefuncs->set_engine_setting(key, value);
1526 SLOG(LOG_ERROR, get_tag(), "[Engine Agent ERROR] fail to set engine setting : result(%d)\n", ret);
1527 return TTSD_ERROR_OPERATION_FAILED;
1533 void __free_voice_list(GList* voice_list)
1536 voice_s* data = NULL;
1538 /* if list have item */
1539 if (g_list_length(voice_list) > 0) {
1540 /* Get a first item */
1541 iter = g_list_first(voice_list);
1543 while (NULL != iter) {
1547 if (NULL != data->language)
1548 g_free(data->language);
1553 voice_list = g_list_remove_link(voice_list, iter);
1555 iter = g_list_first(voice_list);
1561 * TTS Engine Callback Functions ` *
1563 bool __result_cb(ttsp_result_event_e event, const void* data, unsigned int data_size, void *user_data)
1565 g_result_cb(event, data, data_size, user_data);
1570 /* function for debugging */
1571 int ttsd_print_enginelist()
1574 ttsengine_info_s *data = NULL;
1576 if (g_list_length(g_engine_list) > 0) {
1577 iter = g_list_first(g_engine_list);
1579 SLOG(LOG_DEBUG, get_tag(), "----- engine list -----");
1582 while (NULL != iter) {
1585 SLOG(LOG_DEBUG, get_tag(), "[%dth]\n", i);
1586 SLOG(LOG_DEBUG, get_tag(), "engine uuid : %s\n", data->engine_uuid);
1587 SLOG(LOG_DEBUG, get_tag(), "engine name : %s\n", data->engine_name);
1588 SLOG(LOG_DEBUG, get_tag(), "engine path : %s\n", data->engine_path);
1589 SLOG(LOG_DEBUG, get_tag(), "setting ug path : %s\n", data->setting_ug_path);
1591 iter = g_list_next(iter);
1594 SLOG(LOG_DEBUG, get_tag(), "-----------------------");
1595 SLOG(LOG_DEBUG, get_tag(), " ");
1597 SLOG(LOG_DEBUG, get_tag(), "----- engine list -----");
1598 SLOG(LOG_DEBUG, get_tag(), "No Engine in directory");
1599 SLOG(LOG_DEBUG, get_tag(), "-----------------------");