2 * Copyright (c) 2011-2016 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.
21 #include "stt_engine.h"
25 /** Internal data structure **/
28 stte_request_callback_s *callback;
32 /** Static variables **/
34 static sttengine_s *g_engine = NULL;
35 static bool g_is_from_lib = false;
37 /* Callback functions */
38 static stt_engine_result_cb g_result_cb = NULL;
39 static stte_private_data_set_cb g_set_private_data_cb = NULL;
40 static stte_private_data_requested_cb g_get_private_data_cb = NULL;
41 static stte_audio_type_cb g_set_audio_type_cb = NULL;
42 static void* g_set_audio_type_user_data = NULL;
45 /** Static function **/
46 static int __stt_set_engine_from(bool is_from_lib)
48 g_is_from_lib = is_from_lib;
52 static bool __stt_get_engine_from(void)
57 static const char* __stt_get_engine_error_code(stte_error_e err)
60 case STTE_ERROR_NONE: return "STTE_ERROR_NONE";
61 case STTE_ERROR_OUT_OF_MEMORY: return "STTE_ERROR_OUT_OF_MEMORY";
62 case STTE_ERROR_IO_ERROR: return "STTE_ERROR_IO_ERROR";
63 case STTE_ERROR_INVALID_PARAMETER: return "STTE_ERROR_INVALID_PARAMETER";
64 case STTE_ERROR_NETWORK_DOWN: return "STTE_ERROR_NETWORK_DOWN";
65 case STTE_ERROR_PERMISSION_DENIED: return "STTE_ERROR_PERMISSION_DENIED";
66 case STTE_ERROR_NOT_SUPPORTED: return "STTE_ERROR_NOT_SUPPORTED";
67 case STTE_ERROR_INVALID_STATE: return "STTE_ERROR_INVALID_STATE";
68 case STTE_ERROR_INVALID_LANGUAGE: return "STTE_ERROR_INVALID_LANGUAGE";
69 case STTE_ERROR_OPERATION_FAILED: return "STTE_ERROR_OPERATION_FAILED";
70 case STTE_ERROR_NOT_SUPPORTED_FEATURE: return "STTE_ERROR_NOT_SUPPORTED_FEATURE";
71 case STTE_ERROR_RECORDING_TIMED_OUT: return "STTE_ERROR_RECORDING_TIMED_OUT";
73 return "Invalid error code";
78 /** Public function **/
79 /* Register engine id */
80 int stt_engine_load(const char* filepath, stte_request_callback_s *callback)
82 if (NULL == callback || NULL == filepath) {
83 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid Parameter");
84 return STTE_ERROR_INVALID_PARAMETER;
87 /* allocation memory */
88 if (NULL != g_engine) {
89 SLOG(LOG_WARN, TAG_STTE, "[Engine WARNING] engine is already loaded");
91 g_engine = (sttengine_s*)calloc(1, sizeof(sttengine_s));
92 if (NULL == g_engine) {
93 SLOG(LOG_ERROR, TAG_STTE, "[ERROR] Fail to allocate memory");
94 return STTE_ERROR_OUT_OF_MEMORY;
98 g_engine->callback = callback;
99 g_engine->engine_path = strdup(filepath);
102 SLOG(LOG_DEBUG, TAG_STTE, "[Engine Success] Load engine : version(%d)", g_engine->callback->version);
107 /* Unregister engine id */
108 int stt_engine_unload()
110 if (NULL == g_engine) {
111 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] No engine");
112 return STTE_ERROR_OPERATION_FAILED;
115 g_engine->callback = NULL;
117 if (NULL != g_engine->engine_path) {
118 free(g_engine->engine_path);
119 g_engine->engine_path = NULL;
129 /* Initialize / Deinitialize */
130 int stt_engine_initialize(bool is_from_lib)
132 if (NULL == g_engine) {
133 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] No engine");
134 return STTE_ERROR_OPERATION_FAILED;
137 if (NULL == g_engine->callback) {
138 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
139 return STTE_ERROR_OPERATION_FAILED;
142 if (NULL == g_engine->callback->initialize) {
143 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
144 return STTE_ERROR_OPERATION_FAILED;
148 ret = __stt_set_engine_from(is_from_lib);
150 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to set engine : %s", __stt_get_engine_error_code(ret));
151 return STTE_ERROR_OPERATION_FAILED;
154 SLOG(LOG_INFO, TAG_STTE, "[Engine Info] request to initialize");
156 ret = g_engine->callback->initialize();
158 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to initialize : %s", __stt_get_engine_error_code(ret));
164 int stt_engine_deinitialize()
166 if (NULL == g_engine) {
167 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] No engine");
168 return STTE_ERROR_OPERATION_FAILED;
171 if (NULL == g_engine->callback) {
172 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
173 return STTE_ERROR_OPERATION_FAILED;
176 if (NULL == g_engine->callback->deinitialize) {
177 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
178 return STTE_ERROR_OPERATION_FAILED;
181 SLOG(LOG_INFO, TAG_STTE, "[Engine Info] request to deinitialize");
184 ret = g_engine->callback->deinitialize();
186 SLOG(LOG_WARN, TAG_STTE, "[Engine WARNING] Fail to deinitialize : %s", __stt_get_engine_error_code(ret));
192 static bool __supported_language_cb(const char* language, void* user_data)
194 GSList** lang_list = (GSList**)user_data;
196 if (NULL == language || NULL == lang_list) {
197 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Input parameter is NULL in callback!!!!");
201 char* temp_lang = g_strdup(language);
203 *lang_list = g_slist_append(*lang_list, temp_lang);
209 int stt_engine_get_supported_langs(GSList** lang_list)
211 if (NULL == lang_list) {
212 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid Parameter");
213 return STTE_ERROR_INVALID_PARAMETER;
216 if (NULL == g_engine) {
217 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] No engine");
218 return STTE_ERROR_OPERATION_FAILED;
221 if (NULL == g_engine->callback) {
222 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
223 return STTE_ERROR_OPERATION_FAILED;
226 if (NULL == g_engine->callback->foreach_langs) {
227 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
228 return STTE_ERROR_OPERATION_FAILED;
232 ret = g_engine->callback->foreach_langs(__supported_language_cb, (void*)lang_list);
234 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] get language list error : %s", __stt_get_engine_error_code(ret));
240 int stt_engine_is_valid_language(const char* language, bool *is_valid)
242 if (NULL == language || NULL == is_valid) {
243 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid Parameter");
244 return STTE_ERROR_INVALID_PARAMETER;
247 if (NULL == g_engine) {
248 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] No engine");
249 return STTE_ERROR_OPERATION_FAILED;
252 if (NULL == g_engine->callback) {
253 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
254 return STTE_ERROR_OPERATION_FAILED;
257 if (NULL == g_engine->callback->is_valid_lang) {
258 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
259 return STTE_ERROR_OPERATION_FAILED;
262 int ret = STTE_ERROR_NONE;
263 ret = g_engine->callback->is_valid_lang(language, is_valid);
265 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to check valid language(%d)", ret);
270 int stt_engine_set_private_data(const char* key, const char* data)
272 if (NULL == key || NULL == data) {
273 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid Parameter");
274 return STTE_ERROR_INVALID_PARAMETER;
277 int ret = STTE_ERROR_NONE;
278 if (NULL != g_set_private_data_cb) {
279 ret = g_set_private_data_cb(key, data);
281 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to set private data(%d)", ret);
288 int stt_engine_get_private_data(const char* key, char** data)
290 if (NULL == key || NULL == data) {
291 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid Parameter");
292 return STTE_ERROR_INVALID_PARAMETER;
295 int ret = STTE_ERROR_NONE;
297 if (NULL != g_get_private_data_cb) {
298 ret = g_get_private_data_cb(key, &temp);
300 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to get private data(%d)", ret);
304 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] There's no private data function)");
308 *data = strdup("NULL");
310 *data = strdup(temp);
312 return STTE_ERROR_NONE;
315 int stt_engine_get_first_language(char** language)
317 if (NULL == language) {
318 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid Parameter");
319 return STTE_ERROR_INVALID_PARAMETER;
322 if (NULL == g_engine) {
323 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] No engine");
324 return STTE_ERROR_OPERATION_FAILED;
327 if (NULL == g_engine->callback) {
328 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
329 return STTE_ERROR_OPERATION_FAILED;
332 if (NULL == g_engine->callback->foreach_langs || NULL == g_engine->callback->is_valid_lang) {
333 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
334 return STTE_ERROR_OPERATION_FAILED;
337 GSList* lang_list = NULL;
339 ret = g_engine->callback->foreach_langs(__supported_language_cb, &lang_list);
341 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] get language list error : %s", __stt_get_engine_error_code(ret));
348 iter = g_slist_nth(lang_list, 0);
352 bool is_valid = false;
353 ret = g_engine->callback->is_valid_lang(data, &is_valid);
354 if (0 == ret && true == is_valid) {
355 *language = strdup(data);
357 ret = STTE_ERROR_OPERATION_FAILED;
361 /* if list have item */
362 if (g_slist_length(lang_list) > 0) {
363 /* Get a first item */
364 iter = g_slist_nth(lang_list, 0);
366 while (NULL != iter) {
374 lang_list = g_slist_remove_link(lang_list, iter);
376 iter = g_slist_nth(lang_list, 0);
383 int stt_engine_support_silence(bool* support)
385 if (NULL == support) {
386 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid Parameter");
387 return STTE_ERROR_INVALID_PARAMETER;
390 if (NULL == g_engine) {
391 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] No engine");
392 return STTE_ERROR_OPERATION_FAILED;
395 if (NULL == g_engine->callback) {
396 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
397 return STTE_ERROR_OPERATION_FAILED;
400 SLOG(LOG_INFO, TAG_STTE, "[Engine Info] request to support silence");
402 if (NULL == g_engine->callback->support_silence) {
403 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
404 return STTE_ERROR_OPERATION_FAILED;
408 result = g_engine->callback->support_silence();
411 return STTE_ERROR_NONE;
414 int stt_engine_need_app_credential(bool* need)
417 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid Parameter");
418 return STTE_ERROR_INVALID_PARAMETER;
421 if (NULL == g_engine) {
422 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] No engine");
423 return STTE_ERROR_OPERATION_FAILED;
426 if (NULL == g_engine->callback) {
427 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
428 return STTE_ERROR_OPERATION_FAILED;
431 SLOG(LOG_INFO, TAG_STTE, "[Engine Info] request to need app credential");
433 if (NULL == g_engine->callback->need_app_credential) {
434 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
435 return STTE_ERROR_OPERATION_FAILED;
439 result = g_engine->callback->need_app_credential();
442 return STTE_ERROR_NONE;
445 int stt_engine_support_recognition_type(const char* type, bool* support)
447 if (NULL == type || NULL == support) {
448 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid Parameter");
449 return STTE_ERROR_INVALID_PARAMETER;
452 if (NULL == g_engine) {
453 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] No engine");
454 return STTE_ERROR_OPERATION_FAILED;
457 if (NULL == g_engine->callback) {
458 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
459 return STTE_ERROR_OPERATION_FAILED;
462 if (NULL == g_engine->callback->support_recognition_type) {
463 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR} Invalid engine");
464 return STTE_ERROR_OPERATION_FAILED;
467 SLOG(LOG_INFO, TAG_STTE, "[Engine Info] request to support recognition type, type(%s)", type);
469 int ret = STTE_ERROR_NONE;
470 ret = g_engine->callback->support_recognition_type(type, support);
472 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to get supporting recognition type(%d)", ret);
477 int stt_engine_get_audio_format(stte_audio_type_e* types, int* rate, int* channels)
479 if (NULL == types || NULL == rate || NULL == channels) {
480 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid Parameter");
481 return STTE_ERROR_INVALID_PARAMETER;
484 if (NULL == g_engine) {
485 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] No engine");
486 return STTE_ERROR_OPERATION_FAILED;
489 if (NULL == g_engine->callback) {
490 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
491 return STTE_ERROR_OPERATION_FAILED;
494 if (NULL == g_engine->callback->get_audio_format) {
495 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
496 return STTE_ERROR_OPERATION_FAILED;
499 SLOG(LOG_INFO, TAG_STTE, "[Engine Info] request to get audio format");
502 ret = g_engine->callback->get_audio_format(types, rate, channels);
504 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to get audio format : %s", __stt_get_engine_error_code(ret));
511 int stt_engine_set_silence_detection(bool value)
513 if (NULL == g_engine) {
514 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] No engine");
515 return STTE_ERROR_OPERATION_FAILED;
518 if (NULL == g_engine->callback) {
519 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
520 return STTE_ERROR_OPERATION_FAILED;
523 if (NULL == g_engine->callback->set_silence_detection) {
524 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
525 return STTE_ERROR_OPERATION_FAILED;
528 SLOG(LOG_INFO, TAG_STTE, "[Engine Info] request to set silence detection(%d)", value);
530 int ret = g_engine->callback->set_silence_detection(value);
531 if (STTE_ERROR_NOT_SUPPORTED_FEATURE == ret) {
532 SLOG(LOG_WARN, TAG_STTE, "[Engine WARNING] Not support silence detection");
533 } else if (0 != ret) {
534 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to set silence detection : %d", ret);
539 int stt_engine_check_app_agreed(const char* appid, bool* is_agreed)
541 if (NULL == is_agreed) {
542 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid parameter");
543 return STTE_ERROR_INVALID_PARAMETER;
546 if (NULL == g_engine) {
547 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] No engine");
548 return STTE_ERROR_OPERATION_FAILED;
551 if (NULL == g_engine->callback) {
552 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
553 return STTE_ERROR_OPERATION_FAILED;
556 if (NULL == g_engine->callback->check_app_agreed) {
557 SLOG(LOG_WARN, TAG_STTE, "[Engine WARNING] Not support app agreement. All app is available");
562 SLOG(LOG_INFO, TAG_STTE, "[Engine Info] request to app agreed, appid(%s), is_agreed(%d)", appid, *is_agreed);
564 int ret = g_engine->callback->check_app_agreed(appid, is_agreed);
566 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to get app agreement : %s", __stt_get_engine_error_code(ret));
574 int stt_engine_recognize_start(const char* lang, const char* recognition_type, const char* appid, const char* credential, void* user_param)
576 if (NULL == lang || NULL == recognition_type) {
577 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid Parameter");
578 return STTE_ERROR_INVALID_PARAMETER;
581 if (NULL == g_engine) {
582 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] No engine");
583 return STTE_ERROR_OPERATION_FAILED;
586 if (NULL == g_engine->callback) {
587 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
588 return STTE_ERROR_OPERATION_FAILED;
591 if (NULL == g_engine->callback->start) {
592 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
593 return STTE_ERROR_OPERATION_FAILED;
596 SLOG(LOG_INFO, TAG_STTE, "[Engine Info] request to start, lang(%s), recognition_type(%s), credential(%s)", lang, recognition_type, credential);
598 int ret = g_engine->callback->start(lang, recognition_type, appid, credential, user_param);
601 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to start recognition : %s", __stt_get_engine_error_code(ret));
602 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to start recognition : lang(%s), recognition_type(%s), credential(%s)", lang, recognition_type, credential);
608 int stt_engine_set_recording_data(const void* data, unsigned int length)
611 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid Parameter");
612 return STTE_ERROR_INVALID_PARAMETER;
615 if (NULL == g_engine) {
616 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] No engine");
617 return STTE_ERROR_OPERATION_FAILED;
620 if (NULL == g_engine->callback) {
621 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
622 return STTE_ERROR_OPERATION_FAILED;
625 if (NULL == g_engine->callback->set_recording) {
626 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
627 return STTE_ERROR_OPERATION_FAILED;
630 int ret = g_engine->callback->set_recording(data, length);
632 SLOG(LOG_WARN, TAG_STTE, "[Engine WARNING] Fail to set recording : %s", __stt_get_engine_error_code(ret));
638 int stt_engine_recognize_stop()
640 if (NULL == g_engine) {
641 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] No engine");
642 return STTE_ERROR_OPERATION_FAILED;
645 if (NULL == g_engine->callback) {
646 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
647 return STTE_ERROR_OPERATION_FAILED;
650 if (NULL == g_engine->callback->stop) {
651 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
652 return STTE_ERROR_OPERATION_FAILED;
655 SLOG(LOG_INFO, TAG_STTE, "[Engine Info] request to stop");
657 int ret = g_engine->callback->stop();
659 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to stop : %s", __stt_get_engine_error_code(ret));
665 int stt_engine_recognize_cancel()
667 if (NULL == g_engine) {
668 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] No engine");
669 return STTE_ERROR_OPERATION_FAILED;
672 if (NULL == g_engine->callback) {
673 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
674 return STTE_ERROR_OPERATION_FAILED;
677 if (NULL == g_engine->callback->cancel) {
678 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
679 return STTE_ERROR_OPERATION_FAILED;
682 SLOG(LOG_INFO, TAG_STTE, "[Engine Info] request to cancel");
684 int ret = g_engine->callback->cancel();
686 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to cancel : %s", __stt_get_engine_error_code(ret));
692 int stt_engine_foreach_result_time(void* time_info, stte_result_time_cb callback, void* user_data)
694 if (NULL == g_engine) {
695 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] No engine");
696 return STTE_ERROR_OPERATION_FAILED;
699 if (NULL == g_engine->callback) {
700 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
701 return STTE_ERROR_OPERATION_FAILED;
704 if (NULL == g_engine->callback->foreach_result_time) {
705 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
706 return STTE_ERROR_OPERATION_FAILED;
709 int ret = g_engine->callback->foreach_result_time(time_info, callback, user_data);
711 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to foreach result time : %s", __stt_get_engine_error_code(ret));
717 int stt_engine_recognize_start_file(const char* lang, const char* recognition_type,
718 const char* filepath, stte_audio_type_e audio_type, int sample_rate, void* user_param)
720 if (NULL == filepath || NULL == lang || NULL == recognition_type) {
721 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid Parameter");
722 return STTE_ERROR_INVALID_PARAMETER;
725 if (NULL == g_engine) {
726 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] No engine");
727 return STTE_ERROR_OPERATION_FAILED;
730 if (NULL == g_engine->callback) {
731 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
732 return STTE_ERROR_OPERATION_FAILED;
735 #ifdef __UNUSED_CODES__
736 if (NULL == g_engine->callback->start_file) {
737 SLOG(LOG_WARN, TAG_STTE, "[Engine WARNING] engine API is invalid");
738 return STTE_ERROR_NOT_SUPPORTED_FEATURE;
741 int ret = g_engine->callback->start_file(lang, recognition_type, filepath, audio_type, sample_rate, user_param);
743 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to start file recognition : %s", __stt_get_engine_error_code(ret));
749 int stt_engine_recognize_cancel_file()
751 if (NULL == g_engine) {
752 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] No engine");
753 return STTE_ERROR_OPERATION_FAILED;
756 if (NULL == g_engine->callback) {
757 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid engine");
758 return STTE_ERROR_OPERATION_FAILED;
761 #ifdef __UNUSED_CODES__
762 if (NULL == g_engine->callback->cancel_file) {
763 SLOG(LOG_WARN, TAG_STTE, "[Engine WARNING] engine API is invalid");
764 return STTE_ERROR_NOT_SUPPORTED_FEATURE;
767 int ret = g_engine->callback->cancel_file();
769 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to start file recognition : %s", __stt_get_engine_error_code(ret));
775 int stt_engine_set_recognition_result_cb(stt_engine_result_cb result_cb, void* user_data)
777 if (NULL == result_cb) {
778 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid parameter");
779 return STTE_ERROR_INVALID_PARAMETER;
782 g_result_cb = result_cb;
787 int stt_engine_get_recognition_result_cb(stt_engine_result_cb* result_cb)
789 if (NULL == result_cb) {
790 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid parameter");
791 return STTE_ERROR_INVALID_PARAMETER;
794 if (false == __stt_get_engine_from()) {
795 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Engine is not loaded from file");
796 return STTE_ERROR_NOT_SUPPORTED;
799 *result_cb = g_result_cb;
800 return STTE_ERROR_NONE;
803 int stt_engine_set_private_data_set_cb(stte_private_data_set_cb private_data_set_cb, void* user_data)
805 if (NULL == private_data_set_cb) {
806 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid parameter");
807 return STTE_ERROR_INVALID_PARAMETER;
810 g_set_private_data_cb = private_data_set_cb;
815 int stt_engine_set_private_data_requested_cb(stte_private_data_requested_cb private_data_requested_cb, void* user_data)
817 if (NULL == private_data_requested_cb) {
818 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid parameter");
819 return STTE_ERROR_INVALID_PARAMETER;
822 g_get_private_data_cb = private_data_requested_cb;
827 int stt_engine_set_audio_type(const char* audio_type)
829 if (NULL == audio_type) {
830 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid parameter");
831 return STTE_ERROR_INVALID_PARAMETER;
834 SLOG(LOG_INFO, TAG_STTE, "[Engine Info] set audio type (%s)", audio_type);
836 int ret = STTE_ERROR_NONE;
837 if (NULL != g_set_audio_type_cb) {
838 ret = g_set_audio_type_cb(audio_type, g_set_audio_type_user_data);
840 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Fail to set audio type, ret(%d)", ret);
843 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] There's no set audio function)");
849 int stt_engine_set_audio_type_set_cb(stte_audio_type_cb audio_type_set_cb, void* user_data)
851 if (NULL == audio_type_set_cb) {
852 SLOG(LOG_ERROR, TAG_STTE, "[Engine ERROR] Invalid parameter");
853 return STTE_ERROR_INVALID_PARAMETER;
856 g_set_audio_type_cb = audio_type_set_cb;
857 g_set_audio_type_user_data = user_data;
862 int stt_engine_unset_audio_type_set_cb(void)
864 g_set_audio_type_cb = NULL;
865 g_set_audio_type_user_data = NULL;