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.
22 #include <sound_manager.h>
24 #include <bluetooth.h>
28 #include "sttd_dbus.h"
29 #include "sttd_recorder.h"
30 #include "sttd_main.h"
33 #define FRAME_LENGTH 160
34 #define BUFFER_LENGTH FRAME_LENGTH * 2
36 static pthread_mutex_t sttd_audio_in_handle_mutex = PTHREAD_MUTEX_INITIALIZER;
39 STTD_RECORDER_STATE_NONE = -1,
40 STTD_RECORDER_STATE_READY = 0, /**< Recorder is ready to start */
41 STTD_RECORDER_STATE_RECORDING /**< In the middle of recording */
42 } sttd_recorder_state;
47 stte_audio_type_e audio_type;
50 static stt_recorder_s* g_recorder = NULL;
52 static stt_recorder_audio_cb g_audio_cb;
54 static sound_stream_info_h g_stream_info_h;
56 static stt_recorder_interrupt_cb g_interrupt_cb;
58 static sttd_recorder_state g_recorder_state = STTD_RECORDER_STATE_NONE;
60 static int g_buffer_count;
62 /* Sound buf save for test */
67 static char g_temp_file_name[128] = {'\0',};
71 static int g_count = 1;
75 static float get_volume_decibel(char* data, int size, stte_audio_type_e type);
77 //static stt_recorder_s* __get_recorder(int engine_id);
79 static int g_bt_extend_count;
81 #define SMART_CONTROL_EXTEND_CMD 0x03
82 #define SMART_CONTROL_START_CMD 0x04
84 static void _bt_cb_hid_state_changed(int result, bool connected, const char *remote_address, void *user_data)
86 SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] Bluetooth Event [%d] Received address [%s]", result, remote_address);
89 static void _bt_hid_audio_data_receive_cb(bt_hid_voice_data_s *voice_data, void *user_data)
91 if (STTD_RECORDER_STATE_RECORDING != g_recorder_state) {
92 /* SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] Exit audio reading normal func"); */
96 if (NULL != g_audio_cb) {
97 if (0 != g_audio_cb((void*)voice_data->audio_buf, (unsigned int)voice_data->length)) {
98 SLOG(LOG_ERROR, TAG_STTD, "[Recorder ERROR] Fail to read audio");
102 if (NULL == g_recorder) {
106 float vol_db = get_volume_decibel((char*)voice_data->audio_buf, (int)voice_data->length, g_recorder->audio_type);
107 if (0 != sttdc_send_set_volume(g_recorder->uid, vol_db)) {
108 SLOG(LOG_ERROR, TAG_STTD, "[Recorder] Fail to send recording volume(%f)", vol_db);
112 if (0 == g_buffer_count || 0 == g_buffer_count % 50) {
113 SLOG(LOG_WARN, TAG_STTD, "[Recorder][%d] Recording... : read_size(%d)", g_buffer_count, voice_data->length);
115 if (0 == g_bt_extend_count % 5 && 0 != g_buffer_count) {
116 const unsigned char input_data[2] = {SMART_CONTROL_EXTEND_CMD, 0x10 };
117 if (BT_ERROR_NONE != bt_hid_send_rc_command(NULL, input_data, sizeof(input_data))) {
118 SLOG(LOG_ERROR, TAG_STTD, "[Recorder ERROR] Fail bt_hid_send_rc_command(NULL, %s, %d)", input_data, sizeof(input_data));
120 SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] Extend bt audio recorder");
125 if (100000 == g_buffer_count) {
133 /* write pcm buffer */
134 fwrite(data, 1, len, g_pFile);
141 const char* __stt_get_focus_changed_reason_code(sound_stream_focus_change_reason_e reason)
144 case SOUND_STREAM_FOCUS_CHANGED_BY_MEDIA: return "SOUND_STREAM_FOCUS_CHANGED_BY_MEDIA";
145 case SOUND_STREAM_FOCUS_CHANGED_BY_SYSTEM: return "SOUND_STREAM_FOCUS_CHANGED_BY_SYSTEM";
146 case SOUND_STREAM_FOCUS_CHANGED_BY_ALARM: return "SOUND_STREAM_FOCUS_CHANGED_BY_ALARM";
147 case SOUND_STREAM_FOCUS_CHANGED_BY_NOTIFICATION: return "SOUND_STREAM_FOCUS_CHANGED_BY_NOTIFICATION";
148 case SOUND_STREAM_FOCUS_CHANGED_BY_EMERGENCY: return "SOUND_STREAM_FOCUS_CHANGED_BY_EMERGENCY";
149 case SOUND_STREAM_FOCUS_CHANGED_BY_VOICE_INFORMATION: return "SOUND_STREAM_FOCUS_CHANGED_BY_VOICE_INFORMATION";
150 case SOUND_STREAM_FOCUS_CHANGED_BY_VOICE_RECOGNITION: return "SOUND_STREAM_FOCUS_CHANGED_BY_VOICE_RECOGNITION";
151 case SOUND_STREAM_FOCUS_CHANGED_BY_RINGTONE: return "SOUND_STREAM_FOCUS_CHANGED_BY_RINGTONE";
152 case SOUND_STREAM_FOCUS_CHANGED_BY_VOIP: return "SOUND_STREAM_FOCUS_CHANGED_BY_VOIP";
153 case SOUND_STREAM_FOCUS_CHANGED_BY_CALL: return "SOUND_STREAM_FOCUS_CHANGED_BY_CALL";
154 case SOUND_STREAM_FOCUS_CHANGED_BY_MEDIA_EXTERNAL_ONLY: return "SOUND_STREAM_FOCUS_CHANGED_BY_MEDIA_EXTERNAL_ONLY";
155 default: return "Undefined reason code";
159 void __recorder_focus_state_cb(sound_stream_info_h stream_info, sound_stream_focus_mask_e focus_mask, sound_stream_focus_state_e focus_state,
160 sound_stream_focus_change_reason_e reason, int sound_behavior, const char *extra_info, void *user_data)
162 SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] Focus state changed cb");
164 if (stream_info != g_stream_info_h) {
165 SLOG(LOG_ERROR, TAG_STTD, "[Recorder ERROR] Invalid stream info handle");
168 SLOG(LOG_WARN, TAG_STTD, "[Recorder] focus state changed to (%d) with reason(%s)", (int)focus_state, __stt_get_focus_changed_reason_code(reason));
170 if (STTD_RECORDER_STATE_RECORDING == g_recorder_state && SOUND_STREAM_FOCUS_STATE_RELEASED == focus_state) {
171 SLOG(LOG_WARN, TAG_STTD, "[Recorder] Focus released as interrupt");
172 if (NULL != g_interrupt_cb) {
179 int sttd_recorder_initialize(stt_recorder_audio_cb audio_cb, stt_recorder_interrupt_cb interrupt_cb)
181 if (NULL == audio_cb || NULL == interrupt_cb) {
182 SLOG(LOG_ERROR, TAG_STTD, "[Recorder ERROR] Input param is NOT valid");
183 return STTD_ERROR_INVALID_PARAMETER;
186 if (STTD_RECORDER_STATE_NONE != g_recorder_state) {
187 SLOG(LOG_ERROR, TAG_STTD, "[Recorder ERROR] Current state of recorder is recording");
188 return STTD_ERROR_INVALID_STATE;
191 if (0 != pthread_mutex_init(&sttd_audio_in_handle_mutex, NULL)) {
192 SLOG(LOG_ERROR, TAG_STTD, "[Recorder ERROR] Fail to initialize audio in handle mutex.");
195 g_audio_cb = audio_cb;
196 g_interrupt_cb = interrupt_cb;
197 g_recorder_state = STTD_RECORDER_STATE_NONE;
200 if (0 != sound_manager_create_stream_information(SOUND_STREAM_TYPE_VOICE_RECOGNITION, __recorder_focus_state_cb, NULL, &g_stream_info_h)) {
201 SLOG(LOG_ERROR, TAG_STTD, "[Recorder ERROR] Fail to create stream info");
205 if (BT_ERROR_NONE != bt_initialize()) {
206 SLOG(LOG_ERROR, TAG_STTD, "[Recorder ERROR] Fail to init bt");
207 return STTD_ERROR_OPERATION_FAILED;
210 if (BT_ERROR_NONE != bt_hid_host_initialize(_bt_cb_hid_state_changed, NULL)) {
211 SLOG(LOG_ERROR, TAG_STTD, "[Recorder ERROR] Fail bt_hid_host_initialize()");
212 return STTD_ERROR_OPERATION_FAILED;
219 int sttd_recorder_deinitialize()
221 if (0 != pthread_mutex_destroy(&sttd_audio_in_handle_mutex)) {
222 SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to destroy audio in handle mutex.");
225 if (0 != sound_manager_destroy_stream_information(g_stream_info_h)) {
226 SLOG(LOG_ERROR, TAG_STTD, "[Recorder ERROR] Fail to destroy stream info");
229 if (NULL != g_recorder) {
230 audio_in_destroy(g_recorder->audio_h);
231 g_recorder->audio_h = NULL;
236 #ifdef __UNUSED_CODES__
237 /* Remove all recorder */
239 stt_recorder_s *recorder = NULL;
241 iter = g_slist_nth(g_recorder_list, 0);
243 while (NULL != iter) {
244 recorder = iter->data;
246 if (NULL != recorder) {
247 g_recorder_list = g_slist_remove(g_recorder_list, recorder);
248 if (recorder->audio_h) {
249 audio_in_destroy(recorder->audio_h);
250 recorder->audio_h = NULL;
255 iter = g_slist_nth(g_recorder_list, 0);
260 bt_hid_host_deinitialize();
265 g_recorder_state = STTD_RECORDER_STATE_NONE;
270 int sttd_recorder_set_audio_session()
275 int sttd_recorder_unset_audio_session()
280 int sttd_recorder_create(stte_audio_type_e type, int channel, unsigned int sample_rate)
282 /* Check engine id is valid */
283 if (NULL != g_recorder) {
284 SLOG(LOG_WARN, TAG_STTD, "[Recorder WARNING] Engine id is already registered");
285 return STTD_ERROR_INVALID_PARAMETER;
288 audio_in_h temp_in_h = NULL;
291 audio_channel_e audio_ch;
292 audio_sample_type_e audio_type;
295 case 1: audio_ch = AUDIO_CHANNEL_MONO; break;
296 case 2: audio_ch = AUDIO_CHANNEL_STEREO; break;
298 SLOG(LOG_ERROR, TAG_STTD, "[Recorder ERROR] Input channel is not supported");
299 return STTD_ERROR_OPERATION_FAILED;
304 case STTE_AUDIO_TYPE_PCM_S16_LE: audio_type = AUDIO_SAMPLE_TYPE_S16_LE; break;
305 case STTE_AUDIO_TYPE_PCM_U8: audio_type = AUDIO_SAMPLE_TYPE_U8; break;
307 SLOG(LOG_ERROR, TAG_STTD, "[Recorder ERROR] Invalid Audio Type");
308 return STTD_ERROR_OPERATION_FAILED;
313 ret = audio_in_create(sample_rate, audio_ch, audio_type, &temp_in_h);
314 if (AUDIO_IO_ERROR_NONE != ret) {
315 SLOG(LOG_ERROR, TAG_STTD, "[Recorder ERROR] Fail to create audio handle : %d", ret);
316 return STTD_ERROR_OPERATION_FAILED;
319 if (BT_ERROR_NONE != bt_hid_set_audio_data_receive_cb(_bt_hid_audio_data_receive_cb, NULL)) {
320 SLOG(LOG_ERROR, TAG_STTD, "[Recorder ERROR] Fail bt_hid_set_audio_data_receive_cb()");
321 return STTD_ERROR_OPERATION_FAILED;
325 stt_recorder_s* recorder;
326 recorder = (stt_recorder_s*)calloc(1, sizeof(stt_recorder_s));
327 if (NULL == recorder) {
330 audio_in_destroy(temp_in_h);
334 SLOG(LOG_ERROR, TAG_STTD, "[Recorder ERROR] Fail to allocate memory");
335 return STTD_ERROR_OUT_OF_MEMORY;
339 recorder->audio_h = temp_in_h;
340 recorder->audio_type = type;
342 g_recorder = recorder;
344 g_recorder_state = STTD_RECORDER_STATE_READY;
349 int sttd_recorder_destroy()
351 // critical section required because this function can be called from stt engine thread context
352 SLOG(LOG_WARN, TAG_STTD, "[Recorder WARNING] Enter critical section");
353 pthread_mutex_lock(&sttd_audio_in_handle_mutex);
355 /* Check engine id is valid */
356 if (NULL == g_recorder) {
357 SLOG(LOG_WARN, TAG_STTD, "[Recorder WARNING] Engine id is not valid");
358 pthread_mutex_unlock(&sttd_audio_in_handle_mutex);
359 return STTD_ERROR_INVALID_PARAMETER;
364 if (STTD_RECORDER_STATE_RECORDING == g_recorder_state) {
365 if (g_recorder->audio_h) {
366 ret = audio_in_unprepare(g_recorder->audio_h);
367 if (AUDIO_IO_ERROR_NONE != ret) {
368 SLOG(LOG_ERROR, TAG_STTD, "[Recorder ERROR] Fail to unprepare audioin : %d", ret);
372 g_recorder_state = STTD_RECORDER_STATE_READY;
375 if (g_recorder->audio_h) {
376 ret = audio_in_destroy(g_recorder->audio_h);
377 if (AUDIO_IO_ERROR_NONE != ret) {
378 SLOG(LOG_ERROR, TAG_STTD, "[Recorder ERROR] Fail to destroy audioin : %d", ret);
380 g_recorder->audio_h = NULL;
384 if (STTD_RECORDER_STATE_RECORDING == g_recorder_state) {
385 g_recorder_state = STTD_RECORDER_STATE_READY;
388 bt_hid_unset_audio_data_receive_cb();
394 pthread_mutex_unlock(&sttd_audio_in_handle_mutex);
395 SLOG(LOG_WARN, TAG_STTD, "[Recorder WARNING] Leave critical section");
400 static float get_volume_decibel(char* data, int size, stte_audio_type_e type)
402 #define MAX_AMPLITUDE_MEAN_16 32768
403 #define MAX_AMPLITUDE_MEAN_08 128
410 unsigned long long square_sum = 0;
412 if (type == STTE_AUDIO_TYPE_PCM_S16_LE)
417 for (i = 0; i < size; i += (depthByte<<1)) {
418 if (depthByte == 2) {
420 memcpy(&pcm16, data + i, sizeof(short));
421 square_sum += pcm16 * pcm16;
424 memcpy(&pcm8, data + i, sizeof(char));
425 square_sum += pcm8 * pcm8;
433 rms = sqrt((double)square_sum/count);
436 db = 20 * log10(rms/MAX_AMPLITUDE_MEAN_16);
438 db = 20 * log10(rms/MAX_AMPLITUDE_MEAN_08);
444 Eina_Bool __read_audio_func(void *data)
447 static char g_buffer[BUFFER_LENGTH];
449 /* Check engine id is valid */
450 if (NULL == g_recorder) {
454 if (STTD_RECORDER_STATE_READY == g_recorder_state) {
455 SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] Exit audio reading func");
459 read_byte = audio_in_read(g_recorder->audio_h, g_buffer, BUFFER_LENGTH);
461 SLOG(LOG_WARN, TAG_STTD, "[Recorder WARNING] Fail to read audio : %d", read_byte);
462 g_recorder_state = STTD_RECORDER_STATE_READY;
466 if (0 != g_audio_cb(g_buffer, read_byte)) {
467 SLOG(LOG_WARN, TAG_STTD, "[Recorder WARNING] Fail audio callback");
468 sttd_recorder_stop();
472 if (0 == g_buffer_count % 30) {
473 float vol_db = get_volume_decibel(g_buffer, BUFFER_LENGTH, g_recorder->audio_type);
474 if (0 != sttdc_send_set_volume(g_recorder->uid, vol_db)) {
475 SLOG(LOG_ERROR, TAG_STTD, "[Recorder] Fail to send recording volume(%f)", vol_db);
480 if (0 == g_buffer_count % 50) {
481 SLOG(LOG_DEBUG, TAG_STTD, "[Recorder][%d] Recording... : read_size(%d)", g_buffer_count, read_byte);
483 if (100000 == g_buffer_count) {
491 /* write pcm buffer */
492 fwrite(g_buffer, 1, BUFFER_LENGTH, g_pFile);
499 int sttd_recorder_start(int uid)
501 if (STTD_RECORDER_STATE_RECORDING == g_recorder_state)
506 /* Check engine id is valid */
507 if (NULL == g_recorder) {
508 SLOG(LOG_WARN, TAG_STTD, "[Recorder WARNING] Engine id is not valid");
509 return STTD_ERROR_INVALID_PARAMETER;
512 ret = sound_manager_acquire_focus(g_stream_info_h, SOUND_STREAM_FOCUS_FOR_RECORDING, SOUND_BEHAVIOR_NONE, NULL);
513 if (SOUND_MANAGER_ERROR_NONE != ret) {
514 SLOG(LOG_ERROR, TAG_STTD, "[Recorder ERROR] Fail to acquire focus : %d", ret);
516 ret = audio_in_set_sound_stream_info(g_recorder->audio_h, g_stream_info_h);
517 if (AUDIO_IO_ERROR_NONE != ret) {
518 SLOG(LOG_ERROR, TAG_STTD, "[Recorder ERROR] Fail to set stream info");
522 ret = audio_in_prepare(g_recorder->audio_h);
523 if (AUDIO_IO_ERROR_NONE != ret) {
524 SLOG(LOG_ERROR, TAG_STTD, "[Recorder ERROR] Fail to start audio : %d", ret);
525 return STTD_ERROR_RECORDER_BUSY;
528 /* Add ecore timer to read audio data */
529 ecore_timer_add(0, __read_audio_func, NULL);
532 g_bt_extend_count = 0;
533 const unsigned char input_data[2] = {SMART_CONTROL_START_CMD, 0x00 };
535 bool started = false;
536 while (5 > bt_retry) {
537 ret = bt_hid_send_rc_command(NULL, input_data, sizeof(input_data));
538 if (BT_ERROR_NONE == ret) {
539 SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] Start bt audio recorder");
542 } else if (BT_ERROR_NOW_IN_PROGRESS == ret) {
543 SLOG(LOG_ERROR, TAG_STTD, "[Recorder ERROR] Fail bt_hid_send_rc_command(NULL, %s, %d)", input_data, sizeof(input_data));
550 if (false == started) {
551 SLOG(LOG_ERROR, TAG_STTD, "[Recorder ERROR] Fail to start bt audio");
552 return STTD_ERROR_OPERATION_FAILED;
555 g_recorder_state = STTD_RECORDER_STATE_RECORDING;
556 g_recorder->uid = uid;
563 snprintf(g_temp_file_name, sizeof(g_temp_file_name), "/tmp/stt_temp_%d_%d", getpid(), g_count);
564 SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] Temp file name=[%s]", g_temp_file_name);
567 g_pFile = fopen(g_temp_file_name, "wb+");
569 SLOG(LOG_ERROR, TAG_STTD, "[Recorder ERROR] File not found!");
577 int sttd_recorder_stop()
579 if (STTD_RECORDER_STATE_READY == g_recorder_state)
582 /* Check engine id is valid */
583 if (NULL == g_recorder) {
584 SLOG(LOG_WARN, TAG_STTD, "[Recorder WARNING] Engine id is not valid");
585 return STTD_ERROR_INVALID_PARAMETER;
588 g_recorder->uid = -1;
592 ret = audio_in_unprepare(g_recorder->audio_h);
593 if (AUDIO_IO_ERROR_NONE != ret) {
594 SLOG(LOG_ERROR, TAG_STTD, "[Recorder ERROR] Fail to unprepare audioin : %d", ret);
598 bool stopped = false;
599 while (5 > bt_retry) {
600 ret = bt_hid_rc_stop_sending_voice(NULL);
601 if (BT_ERROR_NONE == ret) {
602 SLOG(LOG_DEBUG, TAG_STTD, "[Recorder] Stop bt audio");
605 } else if (BT_ERROR_NOW_IN_PROGRESS == ret) {
606 SLOG(LOG_ERROR, TAG_STTD, "[Recorder ERROR] Fail bt_hid_rc_stop_sending_voice()");
610 SLOG(LOG_ERROR, TAG_STTD, "[Recorder ERROR] bt_hid_rc_stop_sending_voice(): ret(%d)", ret);
614 if (false == stopped) {
615 SLOG(LOG_ERROR, TAG_STTD, "[Recorder ERROR] Fail to stop bt audio(%d)", ret);
616 // return STTD_ERROR_OPERATION_FAILED;
620 g_recorder_state = STTD_RECORDER_STATE_READY;
622 ret = sound_manager_release_focus(g_stream_info_h, SOUND_STREAM_FOCUS_FOR_RECORDING, SOUND_BEHAVIOR_NONE, NULL);
623 if (SOUND_MANAGER_ERROR_NONE != ret) {
624 SLOG(LOG_ERROR, TAG_STTD, "[Recorder ERROR] Fail to release focus :%d", ret);