2 * Copyright (c) 2011-2014 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"
24 * Internal data structure
32 sttpe_funcs_s* pefuncs;
33 sttpd_funcs_s* pdfuncs;
35 int (*sttp_load_engine)(sttpd_funcs_s* pdfuncs, sttpe_funcs_s* pefuncs);
36 int (*sttp_unload_engine)();
39 extern const char* stt_tag();
41 /** stt engine list */
42 static GSList *g_engine_list;
44 static const char* __stt_get_engine_error_code(sttp_error_e err)
47 case STTP_ERROR_NONE: return "STTP_ERROR_NONE";
48 case STTP_ERROR_OUT_OF_MEMORY: return "STTP_ERROR_OUT_OF_MEMORY";
49 case STTP_ERROR_IO_ERROR: return "STTP_ERROR_IO_ERROR";
50 case STTP_ERROR_INVALID_PARAMETER: return "STTP_ERROR_INVALID_PARAMETER";
51 case STTP_ERROR_TIMED_OUT: return "STTP_ERROR_TIMED_OUT";
52 case STTP_ERROR_RECORDER_BUSY: return "STTP_ERROR_RECORDER_BUSY";
53 case STTP_ERROR_OUT_OF_NETWORK: return "STTP_ERROR_OUT_OF_NETWORK";
54 case STTP_ERROR_PERMISSION_DENIED: return "STTP_ERROR_PERMISSION_DENIED";
55 case STTP_ERROR_NOT_SUPPORTED: return "STTP_ERROR_NOT_SUPPORTED";
56 case STTP_ERROR_INVALID_STATE: return "STTP_ERROR_INVALID_STATE";
57 case STTP_ERROR_INVALID_LANGUAGE: return "STTP_ERROR_INVALID_LANGUAGE";
58 case STTP_ERROR_ENGINE_NOT_FOUND: return "STTP_ERROR_ENGINE_NOT_FOUND";
59 case STTP_ERROR_OPERATION_FAILED: return "STTP_ERROR_OPERATION_FAILED";
60 case STTP_ERROR_NOT_SUPPORTED_FEATURE: return "STTP_ERROR_NOT_SUPPORTED_FEATURE";
62 return "Invalid error code";
66 static sttengine_s* __get_engine(int engine_id)
68 /* check whether engine id is valid or not.*/
70 sttengine_s *engine = NULL;
72 if (g_slist_length(g_engine_list) > 0) {
74 iter = g_slist_nth(g_engine_list, 0);
76 while (NULL != iter) {
77 /*Get handle data from list*/
80 if (engine_id == engine->engine_id) {
85 iter = g_slist_next(iter);
92 /* Register engine id */
93 int stt_engine_load(int engine_id, const char* filepath)
95 if (NULL == filepath || engine_id < 0) {
96 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
97 return STTP_ERROR_INVALID_PARAMETER;
100 sttengine_s* engine = NULL;
101 engine = __get_engine(engine_id);
102 if (NULL != engine) {
103 SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is already loaded", engine_id);
107 SECURE_SLOG(LOG_DEBUG, stt_tag(), "[Engine] Load engine id(%d), path(%s)", engine_id, filepath);
109 /* allocation memory */
110 engine = (sttengine_s*)calloc(1, sizeof(sttengine_s));
111 if (NULL == engine) {
112 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
113 return STTP_ERROR_OUT_OF_MEMORY;
119 engine->handle = dlopen(filepath, RTLD_LAZY);
120 if (!engine->handle) {
121 SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine] Invalid engine (Fail dlopen) : %s", filepath);
123 return STTP_ERROR_OPERATION_FAILED;
126 engine->pefuncs = (sttpe_funcs_s*)calloc(1, sizeof(sttpe_funcs_s));
127 if (NULL == engine->pefuncs) {
128 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
129 dlclose(engine->handle);
131 return STTP_ERROR_OUT_OF_MEMORY;
133 engine->pdfuncs = (sttpd_funcs_s*)calloc(1, sizeof(sttpd_funcs_s));
134 if (NULL == engine->pdfuncs) {
135 SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
136 dlclose(engine->handle);
137 free(engine->pefuncs);
139 return STTP_ERROR_OUT_OF_MEMORY;
142 engine->sttp_unload_engine = NULL;
143 engine->sttp_load_engine = NULL;
145 engine->sttp_unload_engine = (int (*)())dlsym(engine->handle, "sttp_unload_engine");
146 if (NULL != (error = dlerror()) || NULL == engine->sttp_unload_engine) {
147 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to link daemon to sttp_unload_engine() : %s", error);
148 dlclose(engine->handle);
149 free(engine->pefuncs);
150 free(engine->pdfuncs);
152 return STTP_ERROR_OPERATION_FAILED;
155 engine->sttp_load_engine = (int (*)(sttpd_funcs_s*, sttpe_funcs_s*))dlsym(engine->handle, "sttp_load_engine");
156 if (NULL != (error = dlerror()) || NULL == engine->sttp_load_engine) {
157 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to link daemon to sttp_load_engine() : %s", error);
158 dlclose(engine->handle);
159 free(engine->pefuncs);
160 free(engine->pdfuncs);
162 return STTP_ERROR_OPERATION_FAILED;
165 engine->engine_id = engine_id;
166 engine->engine_path = strdup(filepath);
168 engine->pdfuncs->version = 1;
169 engine->pdfuncs->size = sizeof(sttpd_funcs_s);
171 int ret = engine->sttp_load_engine(engine->pdfuncs, engine->pefuncs);
173 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail sttp_load_engine() : %s", __stt_get_engine_error_code(ret));
174 dlclose(engine->handle);
175 free(engine->pefuncs);
176 free(engine->pdfuncs);
177 free(engine->engine_path);
179 return STTP_ERROR_OPERATION_FAILED;
182 /* engine error check */
183 if (engine->pefuncs->size != sizeof(sttpe_funcs_s)) {
184 SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine is not valid : function size is not matched");
187 if (NULL == engine->pefuncs->initialize ||
188 NULL == engine->pefuncs->deinitialize ||
189 NULL == engine->pefuncs->foreach_langs ||
190 NULL == engine->pefuncs->is_valid_lang ||
191 NULL == engine->pefuncs->support_silence ||
192 NULL == engine->pefuncs->support_recognition_type ||
193 NULL == engine->pefuncs->get_audio_format ||
194 NULL == engine->pefuncs->set_silence_detection ||
195 NULL == engine->pefuncs->start ||
196 NULL == engine->pefuncs->set_recording ||
197 NULL == engine->pefuncs->stop ||
198 NULL == engine->pefuncs->cancel ||
199 NULL == engine->pefuncs->foreach_result_time)
200 /* Current unused functions
201 NULL == engine->pefuncs->start_file_recognition ||
204 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] The engine functions are NOT valid");
205 dlclose(engine->handle);
206 free(engine->pefuncs);
207 free(engine->pdfuncs);
208 free(engine->engine_path);
211 return STTP_ERROR_OPERATION_FAILED;
214 SLOG(LOG_DEBUG, stt_tag(), "[Engine Success] Load engine : version(%d), size(%d)", engine->pefuncs->version, engine->pefuncs->size);
216 g_engine_list = g_slist_append(g_engine_list, engine);
221 /* Unregister engine id */
222 int stt_engine_unload(int engine_id)
224 sttengine_s* engine = NULL;
225 engine = __get_engine(engine_id);
226 if (NULL == engine) {
227 SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
228 return STTP_ERROR_INVALID_PARAMETER;
232 engine->sttp_unload_engine();
233 dlclose(engine->handle);
235 if (NULL != engine->engine_path) free(engine->engine_path);
236 if (NULL != engine->pefuncs) free(engine->pefuncs);
237 if (NULL != engine->pdfuncs) free(engine->pdfuncs);
239 g_engine_list = g_slist_remove(g_engine_list, engine);
247 /* Initialize / Deinitialize */
248 int stt_engine_initialize(int engine_id, sttpe_result_cb result_cb, sttpe_silence_detected_cb silence_cb)
250 if (NULL == result_cb || NULL == silence_cb) {
251 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
252 return STTP_ERROR_INVALID_PARAMETER;
255 sttengine_s* engine = NULL;
256 engine = __get_engine(engine_id);
257 if (NULL == engine) {
258 SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
259 return STTP_ERROR_INVALID_PARAMETER;
263 ret = engine->pefuncs->initialize(result_cb, silence_cb);
265 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to initialize : %s", __stt_get_engine_error_code(ret));
266 return STTP_ERROR_OPERATION_FAILED;
272 int stt_engine_deinitialize(int engine_id)
274 sttengine_s* engine = NULL;
275 engine = __get_engine(engine_id);
276 if (NULL == engine) {
277 SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
278 return STTP_ERROR_INVALID_PARAMETER;
282 ret = engine->pefuncs->deinitialize();
284 SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] Fail to deinitialize : %s", __stt_get_engine_error_code(ret));
290 static bool __supported_language_cb(const char* language, void* user_data)
292 GSList** lang_list = (GSList**)user_data;
294 if (NULL == language || NULL == lang_list) {
295 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Input parameter is NULL in callback!!!!");
299 char* temp_lang = g_strdup(language);
301 *lang_list = g_slist_append(*lang_list, temp_lang);
307 int stt_engine_get_supported_langs(int engine_id, GSList** lang_list)
309 if (NULL == lang_list) {
310 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
311 return STTP_ERROR_INVALID_PARAMETER;
314 sttengine_s* engine = NULL;
315 engine = __get_engine(engine_id);
316 if (NULL == engine) {
317 SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
318 return STTP_ERROR_INVALID_PARAMETER;
322 ret = engine->pefuncs->foreach_langs(__supported_language_cb, (void*)lang_list);
324 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] get language list error : %s", __stt_get_engine_error_code(ret));
325 return STTP_ERROR_OPERATION_FAILED;
331 int stt_engine_is_valid_language(int engine_id, const char* language, bool *is_valid)
333 if (NULL == language || NULL == is_valid) {
334 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
335 return STTP_ERROR_INVALID_PARAMETER;
338 sttengine_s* engine = NULL;
339 engine = __get_engine(engine_id);
340 if (NULL == engine) {
341 SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
342 return STTP_ERROR_INVALID_PARAMETER;
346 result = engine->pefuncs->is_valid_lang(language);
353 int stt_engine_get_first_language(int engine_id, char** language)
355 if (NULL == language) {
356 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
357 return STTP_ERROR_INVALID_PARAMETER;
360 sttengine_s* engine = NULL;
361 engine = __get_engine(engine_id);
362 if (NULL == engine) {
363 SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
364 return STTP_ERROR_INVALID_PARAMETER;
367 GSList* lang_list = NULL;
369 ret = engine->pefuncs->foreach_langs(__supported_language_cb, &lang_list);
371 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] get language list error : %s", __stt_get_engine_error_code(ret));
372 return STTP_ERROR_OPERATION_FAILED;
378 iter = g_slist_nth(lang_list, 0);
382 if (true == engine->pefuncs->is_valid_lang(data)) {
383 *language = strdup(data);
385 ret = STTP_ERROR_OPERATION_FAILED;
389 /* if list have item */
390 if (g_slist_length(lang_list) > 0) {
391 /* Get a first item */
392 iter = g_slist_nth(lang_list, 0);
394 while (NULL != iter) {
400 lang_list = g_slist_remove_link(lang_list, iter);
402 iter = g_slist_nth(lang_list, 0);
409 int stt_engine_support_silence(int engine_id, bool* support)
411 if (NULL == support) {
412 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
413 return STTP_ERROR_INVALID_PARAMETER;
416 sttengine_s* engine = NULL;
417 engine = __get_engine(engine_id);
418 if (NULL == engine) {
419 SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
420 return STTP_ERROR_INVALID_PARAMETER;
424 result = engine->pefuncs->support_silence();
431 int stt_engine_need_app_credential(int engine_id, bool* need)
434 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
435 return STTP_ERROR_INVALID_PARAMETER;
438 sttengine_s* engine = NULL;
439 engine = __get_engine(engine_id);
440 if (NULL == engine) {
441 SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
442 return STTP_ERROR_INVALID_PARAMETER;
446 if (NULL != engine->pefuncs->need_app_credential) {
447 result = engine->pefuncs->need_app_credential();
449 return STTP_ERROR_NONE;
452 return STTP_ERROR_OPERATION_FAILED;
455 int stt_engine_support_recognition_type(int engine_id, const char* type, bool* support)
457 if (NULL == type || NULL == support) {
458 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
459 return STTP_ERROR_INVALID_PARAMETER;
462 sttengine_s* engine = NULL;
463 engine = __get_engine(engine_id);
464 if (NULL == engine) {
465 SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
466 return STTP_ERROR_INVALID_PARAMETER;
470 if (NULL != engine->pefuncs->support_recognition_type) {
471 result = engine->pefuncs->support_recognition_type(type);
476 return STTP_ERROR_OPERATION_FAILED;
479 int stt_engine_get_audio_type(int engine_id, sttp_audio_type_e* types, int* rate, int* channels)
481 if (NULL == types || NULL == rate || NULL == channels) {
482 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
483 return STTP_ERROR_INVALID_PARAMETER;
486 sttengine_s* engine = NULL;
487 engine = __get_engine(engine_id);
488 if (NULL == engine) {
489 SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
490 return STTP_ERROR_INVALID_PARAMETER;
494 ret = engine->pefuncs->get_audio_format(types, rate, channels);
496 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to get audio format : %s", __stt_get_engine_error_code(ret));
497 return STTP_ERROR_OPERATION_FAILED;
504 int stt_engine_set_silence_detection(int engine_id, bool value)
506 sttengine_s* engine = NULL;
507 engine = __get_engine(engine_id);
508 if (NULL == engine) {
509 SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
510 return STTP_ERROR_INVALID_PARAMETER;
513 int ret = engine->pefuncs->set_silence_detection(value);
514 if (STTP_ERROR_NOT_SUPPORTED_FEATURE == ret) {
515 SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] Not support silence detection");
516 return STTP_ERROR_NOT_SUPPORTED_FEATURE;
517 } else if (0 != ret) {
518 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to set silence detection : %d", ret);
519 return STTP_ERROR_OPERATION_FAILED;
525 int stt_engine_check_app_agreed(int engine_id, const char* appid, bool* value)
527 sttengine_s* engine = NULL;
528 engine = __get_engine(engine_id);
529 if (NULL == engine) {
530 SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
531 return STTP_ERROR_INVALID_PARAMETER;
534 if (NULL == engine->pefuncs->check_app_agreed) {
535 SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] Not support app agreement. All app is available");
540 int ret = engine->pefuncs->check_app_agreed(appid, value);
542 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to get app agreement : %s", __stt_get_engine_error_code(ret));
544 return STTP_ERROR_OPERATION_FAILED;
551 int stt_engine_recognize_start(int engine_id, const char* lang, const char* recognition_type, const char* credential, void* user_param)
553 if (NULL == lang || NULL == recognition_type) {
554 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
555 return STTP_ERROR_INVALID_PARAMETER;
558 sttengine_s* engine = NULL;
559 engine = __get_engine(engine_id);
560 if (NULL == engine) {
561 SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
562 return STTP_ERROR_INVALID_PARAMETER;
565 int ret = engine->pefuncs->start(lang, recognition_type, credential, user_param);
567 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to start recognition : %s", __stt_get_engine_error_code(ret));
568 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to start recognition : lang(%s), recognition_type(%s), credential(%s)", lang, recognition_type, credential);
569 return STTP_ERROR_OPERATION_FAILED;
575 int stt_engine_set_recording_data(int engine_id, const void* data, unsigned int length)
578 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
579 return STTP_ERROR_INVALID_PARAMETER;
582 sttengine_s* engine = NULL;
583 engine = __get_engine(engine_id);
584 if (NULL == engine) {
585 SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
586 return STTP_ERROR_INVALID_PARAMETER;
589 int ret = engine->pefuncs->set_recording(data, length);
591 SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] Fail to set recording : %s", __stt_get_engine_error_code(ret));
592 return STTP_ERROR_OPERATION_FAILED;
598 int stt_engine_recognize_stop(int engine_id)
600 sttengine_s* engine = NULL;
601 engine = __get_engine(engine_id);
602 if (NULL == engine) {
603 SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
604 return STTP_ERROR_INVALID_PARAMETER;
607 int ret = engine->pefuncs->stop();
609 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to stop : %s", __stt_get_engine_error_code(ret));
610 return STTP_ERROR_OPERATION_FAILED;
616 int stt_engine_recognize_cancel(int engine_id)
618 sttengine_s* engine = NULL;
619 engine = __get_engine(engine_id);
620 if (NULL == engine) {
621 SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
622 return STTP_ERROR_INVALID_PARAMETER;
625 int ret = engine->pefuncs->cancel();
627 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to cancel : %s", __stt_get_engine_error_code(ret));
628 return STTP_ERROR_OPERATION_FAILED;
634 int stt_engine_foreach_result_time(int engine_id, void* time_info, sttpe_result_time_cb callback, void* user_data)
636 sttengine_s* engine = NULL;
637 engine = __get_engine(engine_id);
638 if (NULL == engine) {
639 SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
640 return STTP_ERROR_INVALID_PARAMETER;
643 int ret = engine->pefuncs->foreach_result_time(time_info, callback, user_data);
645 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to foreach result time : %s", __stt_get_engine_error_code(ret));
646 return STTP_ERROR_OPERATION_FAILED;
652 int stt_engine_recognize_start_file(int engine_id, const char* lang, const char* recognition_type,
653 const char* filepath, sttp_audio_type_e audio_type, int sample_rate, void* user_param)
655 if (NULL == filepath || NULL == lang || NULL == recognition_type) {
656 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Invalid Parameter");
657 return STTP_ERROR_INVALID_PARAMETER;
660 sttengine_s* engine = NULL;
661 engine = __get_engine(engine_id);
662 if (NULL == engine) {
663 SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
664 return STTP_ERROR_INVALID_PARAMETER;
667 if (NULL == engine->pefuncs->start_file) {
668 SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine API is invalid");
669 return STTP_ERROR_NOT_SUPPORTED_FEATURE;
672 int ret = engine->pefuncs->start_file(lang, recognition_type, filepath, audio_type, sample_rate, user_param);
674 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to start file recognition : %s", __stt_get_engine_error_code(ret));
675 return STTP_ERROR_OPERATION_FAILED;
681 int stt_engine_recognize_cancel_file(int engine_id)
683 sttengine_s* engine = NULL;
684 engine = __get_engine(engine_id);
685 if (NULL == engine) {
686 SECURE_SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine id(%d) is invalid", engine_id);
687 return STTP_ERROR_INVALID_PARAMETER;
690 if (NULL == engine->pefuncs->cancel_file) {
691 SLOG(LOG_WARN, stt_tag(), "[Engine WARNING] engine API is invalid");
692 return STTP_ERROR_NOT_SUPPORTED_FEATURE;
695 int ret = engine->pefuncs->cancel_file();
697 SLOG(LOG_ERROR, stt_tag(), "[Engine ERROR] Fail to start file recognition : %s", __stt_get_engine_error_code(ret));
698 return STTP_ERROR_OPERATION_FAILED;