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.
16 #include <sound_manager.h>
17 #include <sound_manager_internal.h>
19 #include "ttsd_main.h"
20 #include "ttsd_player.h"
21 #include "ttsd_data.h"
22 #include "ttsd_dbus.h"
24 #include "tts_internal.h"
25 #include "ttsd_server.h"
28 * Internal data structure
38 int uid; /** client id */
39 app_tts_state_e state; /** client state */
41 /* Current utterance information */
42 ttse_result_event_e event; /** event of last utterance */
46 sound_data_s* paused_data;
49 #define SOUND_BUFFER_LENGTH 2048
50 #define FOCUS_SERVER_READY "/tmp/.sound_server_ready"
52 /* Sound buf save for test */
57 static char g_temp_file_name[128] = {'\0',};
61 static int g_count = 1;
64 /** player init info */
65 static bool g_player_init = false;
68 static GList *g_player_list;
70 /** current player information */
71 static player_s* g_playing_info;
74 static audio_state_e g_audio_state;
76 static ttse_audio_type_e g_audio_type;
78 static int g_sampling_rate;
80 static audio_out_h g_audio_h;
82 static sound_stream_info_h g_stream_info_h;
84 static sound_stream_ducking_h g_media_stream_ducking;
85 static sound_stream_ducking_h g_system_stream_ducking;
86 static sound_stream_ducking_h g_notification_stream_ducking;
87 static sound_stream_ducking_h g_alarm_stream_ducking;
89 // static bool ducking_flag;
91 #define SND_MGR_DUCKING_DURATION 500
93 static int g_focus_watch_id;
95 static double g_bg_volume_ratio;
101 player_s* __player_get_item(int uid)
104 player_s *data = NULL;
106 if (0 < g_list_length(g_player_list)) {
107 /* Get a first item */
108 iter = g_list_first(g_player_list);
110 while (NULL != iter) {
111 /* Get handle data from list */
112 data = (player_s*)iter->data;
115 if (uid == data->uid)
119 iter = g_list_next(iter);
126 void __player_focus_state_cb(sound_stream_info_h stream_info, sound_stream_focus_mask_e focus_mask, sound_stream_focus_state_e focus_state,
127 sound_stream_focus_change_reason_e reason_for_change, int sound_behavior, const char *extra_info, void *user_data)
129 SLOG(LOG_DEBUG, tts_tag(), "@@@ Focus state changed cb");
131 if (stream_info != g_stream_info_h) {
132 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Invalid stream info handle");
135 SLOG(LOG_WARN, tts_tag(), "[Player] focus state changed to (%d) with reason(%d) and extra info(%s)", (int)focus_state, (int)reason_for_change, extra_info);
137 if (NULL == g_playing_info) {
138 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] No current player");
142 if (APP_STATE_PLAYING == g_playing_info->state && focus_mask == SOUND_STREAM_FOCUS_FOR_PLAYBACK && SOUND_STREAM_FOCUS_STATE_RELEASED == focus_state) {
143 if (TTSD_MODE_DEFAULT == ttsd_get_mode()) {
144 g_audio_state = AUDIO_STATE_READY;
146 int uid = g_playing_info->uid;
148 if (0 != ttsd_player_pause(uid)) {
149 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to pause the player");
153 ttsd_data_set_client_state(uid, APP_STATE_PAUSED);
154 int pid = ttsd_data_get_pid(uid);
155 /* send message to client about changing state */
156 ttsdc_send_set_state_message(pid, uid, APP_STATE_PAUSED);
158 SLOG(LOG_DEBUG, tts_tag(), "[Player] Ignore focus state cb - mode(%d)", ttsd_get_mode());
162 /* if (AUDIO_STATE_READY == g_audio_state && focus_mask == SOUND_STREAM_FOCUS_FOR_PLAYBACK && SOUND_STREAM_FOCUS_STATE_ACQUIRED == focus_state) {
163 if (TTSD_MODE_DEFAULT == ttsd_get_mode()) {
164 g_audio_state = AUDIO_STATE_PLAY;
166 if (NULL == g_playing_info) {
167 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] No current player");
171 if (APP_STATE_PAUSED == g_playing_info->state) {
172 int uid = g_playing_info->uid;
174 g_audio_state = AUDIO_STATE_PLAY;
175 if (0 != ttsd_player_resume(uid)) {
176 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to resume the player");
177 g_audio_state = AUDIO_STATE_READY;
181 ttsd_data_set_client_state(uid, APP_STATE_PLAYING);
182 int pid = ttsd_data_get_pid(uid);
183 ttsdc_send_set_state_message(pid, uid, APP_STATE_PLAYING);
187 SLOG(LOG_DEBUG, tts_tag(), "[Player] Ignore focus state cb - mode(%d)", ttsd_get_mode());
191 SLOG(LOG_DEBUG, tts_tag(), "@@@");
196 void __player_focus_state_watch_cb(int id, sound_stream_focus_mask_e focus_mask, sound_stream_focus_state_e focus_state, sound_stream_focus_change_reason_e reason,
197 const char *extra_info, void *user_data)
199 SLOG(LOG_DEBUG, tts_tag(), "@@@ Focus state watch cb");
201 ttsd_mode_e mode = ttsd_get_mode();
203 if (TTSD_MODE_SCREEN_READER != mode && TTSD_MODE_NOTIFICATION != mode) {
204 SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] This is not screen-reader mode and notification mode.");
208 if (NULL == g_playing_info) {
209 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] No current player");
213 if (APP_STATE_PLAYING == g_playing_info->state && SOUND_STREAM_FOCUS_CHANGED_BY_VOICE_INFORMATION == reason &&
214 NULL != extra_info && 0 == strncmp(extra_info, "TTSD_MODE_INTERRUPT", strlen(extra_info))) {
215 /* If the focus is changed by "Interrupt" mode and current players of "SR" and "Noti" modes are on going, please stop the current players. */
216 g_audio_state = AUDIO_STATE_READY;
218 int uid = g_playing_info->uid;
220 if (0 != ttsd_server_stop(uid)) {
221 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to stop TTS server");
224 if (0 != ttsd_player_stop(uid)) {
225 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to stop the player");
229 ttsd_data_set_client_state(uid, APP_STATE_READY);
230 int pid = ttsd_data_get_pid(uid);
231 /* send message to client about changing state */
232 ttsdc_send_set_state_message(pid, uid, APP_STATE_READY);
234 SLOG(LOG_DEBUG, tts_tag(), "[Player] Extra info is not Interrupt mode(%s) or not playing state(%d).", extra_info, g_playing_info->state);
240 void __sound_stream_ducking_state_changed_cb(sound_stream_ducking_h stream_ducking, bool is_ducked, void *user_data)
242 SLOG(LOG_DEBUG, tts_tag(), "@@@ ducking state changed cb");
243 SLOG(LOG_DEBUG, tts_tag(), "[Player] is ducked : %d", is_ducked);
244 // ducking_flag = true;
248 static char* __get_ducking_stream(sound_stream_type_e stream_type)
250 if (SOUND_STREAM_TYPE_MEDIA == stream_type)
251 return "Media stream";
252 else if (SOUND_STREAM_TYPE_SYSTEM == stream_type)
253 return "System stream";
254 else if (SOUND_STREAM_TYPE_NOTIFICATION == stream_type)
255 return "Notification stream";
256 else if (SOUND_STREAM_TYPE_ALARM == stream_type)
257 return "Alarm stream";
258 return "Non matched stream";
261 static int __activate_ducking_sound_stream(sound_stream_type_e stream_type, sound_stream_ducking_h stream_ducking_h)
263 bool is_ducked = false;
264 int ret = sound_manager_is_ducked(stream_ducking_h, &is_ducked);
266 SLOG(LOG_DEBUG, tts_tag(), "[Player] The %s is already ducked", __get_ducking_stream(stream_type));
268 ret = sound_manager_activate_ducking(stream_ducking_h, SND_MGR_DUCKING_DURATION, g_bg_volume_ratio);
269 if (SOUND_MANAGER_ERROR_NONE != ret) {
270 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to activate ducking for %s", __get_ducking_stream(stream_type));
272 SLOG(LOG_INFO, tts_tag(), "[Player SUCCESS] Activate ducking for %s", __get_ducking_stream(stream_type));
278 static void __change_background_volume()
280 __activate_ducking_sound_stream(SOUND_STREAM_TYPE_MEDIA, g_media_stream_ducking);
281 __activate_ducking_sound_stream(SOUND_STREAM_TYPE_SYSTEM, g_system_stream_ducking);
282 __activate_ducking_sound_stream(SOUND_STREAM_TYPE_NOTIFICATION, g_notification_stream_ducking);
283 __activate_ducking_sound_stream(SOUND_STREAM_TYPE_ALARM, g_alarm_stream_ducking);
286 static int __deactivate_ducking_sound_stream(sound_stream_type_e stream_type, sound_stream_ducking_h stream_ducking_h)
288 bool is_ducked = false;
289 int ret = sound_manager_is_ducked(stream_ducking_h, &is_ducked);
291 SLOG(LOG_DEBUG, tts_tag(), "[Player] The %s is already recovered from ducking", __get_ducking_stream(stream_type));
293 ret = sound_manager_deactivate_ducking(stream_ducking_h);
294 if (SOUND_MANAGER_ERROR_NONE != ret) {
295 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to deactivate ducking for %s", __get_ducking_stream(stream_type));
297 SLOG(LOG_INFO, tts_tag(), "[Player SUCCESS] Deactivate ducking for %s", __get_ducking_stream(stream_type));
303 static void __recover_background_volume()
305 __deactivate_ducking_sound_stream(SOUND_STREAM_TYPE_MEDIA, g_media_stream_ducking);
306 __deactivate_ducking_sound_stream(SOUND_STREAM_TYPE_SYSTEM, g_system_stream_ducking);
307 __deactivate_ducking_sound_stream(SOUND_STREAM_TYPE_NOTIFICATION, g_notification_stream_ducking);
308 __deactivate_ducking_sound_stream(SOUND_STREAM_TYPE_ALARM, g_alarm_stream_ducking);
311 static int __create_audio_out(ttse_audio_type_e type, int rate)
314 audio_sample_type_e sample_type;
316 if (TTSE_AUDIO_TYPE_RAW_S16 == type) {
317 sample_type = AUDIO_SAMPLE_TYPE_S16_LE;
319 sample_type = AUDIO_SAMPLE_TYPE_U8;
322 ret = audio_out_create_new(rate, AUDIO_CHANNEL_MONO, sample_type, &g_audio_h);
323 if (AUDIO_IO_ERROR_NONE != ret) {
324 g_audio_state = AUDIO_STATE_NONE;
326 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to create audio");
329 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Create audio");
333 g_sampling_rate = rate;
335 g_audio_state = AUDIO_STATE_READY;
340 static int __destroy_audio_out()
342 if (NULL == g_audio_h) {
343 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Current handle is not valid");
348 ret = audio_out_destroy(g_audio_h);
349 if (AUDIO_IO_ERROR_NONE != ret) {
350 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to destroy audio");
353 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Destroy audio");
359 g_audio_state = AUDIO_STATE_NONE;
365 static void __end_play_thread(void *data, Ecore_Thread *thread)
367 SLOG(LOG_ERROR, tts_tag(), "@@@ End thread");
374 static void __set_policy_for_playing(int volume)
377 __change_background_volume();
379 /* Set stream info */
381 ttsd_mode_e mode = ttsd_get_mode();
382 if (TTSD_MODE_DEFAULT == mode) {
383 ret = sound_manager_acquire_focus(g_stream_info_h, SOUND_STREAM_FOCUS_FOR_PLAYBACK, SOUND_BEHAVIOR_NONE, NULL);
384 if (SOUND_MANAGER_ERROR_NONE != ret) {
385 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to acquire focus");
387 SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] Success to acquire focus (default mode)");
389 } else if (TTSD_MODE_INTERRUPT == mode) {
390 ret = sound_manager_acquire_focus(g_stream_info_h, SOUND_STREAM_FOCUS_FOR_PLAYBACK, SOUND_BEHAVIOR_NONE, "TTSD_MODE_INTERRUPT");
391 if (SOUND_MANAGER_ERROR_NONE != ret) {
392 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to acquire focus");
394 SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] Success to acquire focus (interrupt mode)");
398 ret = audio_out_set_sound_stream_info(g_audio_h, g_stream_info_h);
399 if (AUDIO_IO_ERROR_NONE != ret) {
400 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to set stream info");
403 SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] set policy for playing");
408 static void __unset_policy_for_playing()
411 ttsd_mode_e mode = ttsd_get_mode();
412 /* Unset stream info */
413 if (TTSD_MODE_DEFAULT == mode || TTSD_MODE_INTERRUPT == mode) {
414 sound_stream_focus_state_e state_for_playing = SOUND_STREAM_FOCUS_STATE_ACQUIRED;
415 ret = sound_manager_get_focus_state(g_stream_info_h, &state_for_playing, NULL);
416 if (SOUND_MANAGER_ERROR_NONE != ret) {
417 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to get focus state: %d", ret);
420 if (SOUND_STREAM_FOCUS_STATE_ACQUIRED == state_for_playing) {
421 if (TTSD_MODE_DEFAULT == mode || TTSD_MODE_INTERRUPT == mode) {
422 ret = sound_manager_release_focus(g_stream_info_h, SOUND_STREAM_FOCUS_FOR_PLAYBACK, SOUND_BEHAVIOR_NONE, NULL);
423 SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] release focus (mode: %d)", mode);
426 if (SOUND_MANAGER_ERROR_NONE != ret) {
427 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to release focus");
432 __recover_background_volume();
434 SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] unset policy for playing");
439 int ttsd_player_check_current_playback_focus(bool *is_current_interrupt)
442 ttsd_mode_e mode = ttsd_get_mode();
444 if (TTSD_MODE_INTERRUPT != mode) {
445 /* check the current playback focus */
446 sound_stream_focus_change_reason_e reason;
447 int sound_behavior = 0;
448 char *extra_info = NULL;
450 ret = sound_manager_get_current_playback_focus(&reason, &sound_behavior, &extra_info);
452 SLOG(LOG_DEBUG, tts_tag(), "[Player] current playback focus: extra_info(%s), reason(%d), sound_behavior(%d)", extra_info, reason, sound_behavior);
454 if (SOUND_MANAGER_ERROR_NONE == ret && NULL != extra_info && 0 < strlen(extra_info)) {
455 if (SOUND_STREAM_FOCUS_CHANGED_BY_VOICE_INFORMATION == reason && 0 == strncmp(extra_info, "TTSD_MODE_INTERRUPT", strlen(extra_info))) {
456 SLOG(LOG_DEBUG, tts_tag(), "[Player] The current focus in Interrupt. Cannot play the requested sound data");
457 *is_current_interrupt = true;
462 return TTSD_ERROR_NONE;
466 if (NULL != extra_info) {
472 *is_current_interrupt = false;
474 return TTSD_ERROR_NONE;
477 static void __play_thread(void *data, Ecore_Thread *thread)
479 SLOG(LOG_DEBUG, tts_tag(), "@@@ Start thread");
485 snprintf(g_temp_file_name, sizeof(g_temp_file_name), "/tmp/tts_temp_%d_%d", getpid(), g_count);
486 int ret = access(g_temp_file_name, 0);
489 SLOG(LOG_ERROR, tts_tag(), "[Recorder ERROR] File is already exist");
490 if (0 == remove(g_temp_file_name)) {
491 SLOG(LOG_DEBUG, tts_tag(), "[Recorder] Remove file");
501 SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Recorder] Temp file name=[%s]", g_temp_file_name);
504 g_pFile = fopen(g_temp_file_name, "wb+x");
506 SLOG(LOG_ERROR, tts_tag(), "[Recorder ERROR] File not found!");
511 if (NULL == g_playing_info) {
512 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] No current player");
516 player_s* player = g_playing_info;
517 sound_data_s* sound_data = NULL;
520 int len = SOUND_BUFFER_LENGTH;
523 /* set volume policy as 40% */
524 __set_policy_for_playing(40);
526 if (true == player->is_paused_data) {
528 sound_data = player->paused_data;
529 player->paused_data = NULL;
533 player->is_paused_data = false;
536 if (NULL == sound_data) {
537 /* Request unprepare */
538 ret = audio_out_unprepare(g_audio_h);
539 if (AUDIO_IO_ERROR_NONE != ret) {
540 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
542 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio");
545 g_audio_state = AUDIO_STATE_READY;
547 /* unset volume policy, volume will be 100% */
548 __unset_policy_for_playing();
551 SLOG(LOG_INFO, tts_tag(), "[Player] Sound info : id(%d) data(%p) size(%d) audiotype(%d) rate(%d) event(%d)",
552 sound_data->utt_id, sound_data->data, sound_data->data_size, sound_data->audio_type, sound_data->rate, sound_data->event);
555 ret = ttsd_data_get_sound_data(player->uid, &sound_data);
556 if (0 != ret || NULL == sound_data) {
558 SLOG(LOG_DEBUG, tts_tag(), "[Player] No sound data. Waiting mode");
560 /* wait for new audio data come */
563 if (NULL == g_playing_info) {
564 /* current playing uid is replaced */
565 SLOG(LOG_INFO, tts_tag(), "[Player] Finish thread");
566 if (AUDIO_STATE_PLAY == g_audio_state) {
567 /* release audio & recover session */
568 ret = audio_out_unprepare(g_audio_h);
569 if (AUDIO_IO_ERROR_NONE != ret) {
570 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
572 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio");
574 g_audio_state = AUDIO_STATE_READY;
576 /* unset volume policy, volume will be 100% */
577 __unset_policy_for_playing();
579 } else if (0 < ttsd_data_get_sound_data_size(player->uid)) {
580 /* new audio data come */
581 SLOG(LOG_INFO, tts_tag(), "[Player] Resume thread");
585 /* If engine is not on processing */
586 if (TTSD_SYNTHESIS_CONTROL_DOING != ttsd_get_synth_control()) {
587 if (AUDIO_STATE_PLAY == g_audio_state) {
588 /* release audio & recover session */
589 ret = audio_out_unprepare(g_audio_h);
590 if (AUDIO_IO_ERROR_NONE != ret) {
591 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
593 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio");
595 g_audio_state = AUDIO_STATE_READY;
597 /* unset volume policy, volume will be 100% */
598 __unset_policy_for_playing();
603 SLOG(LOG_INFO, tts_tag(), "[Player] Finish to wait for new audio data come");
605 if (AUDIO_STATE_READY == g_audio_state) {
606 /* set volume policy as 40%, when resume play thread*/
607 __set_policy_for_playing(40);
610 /* resume play thread */
611 player->state = APP_STATE_PLAYING;
615 /* If wdata's event is 'start', current wdata is first data of engine for synthesis.
616 * If wdata's event is 'finish', player should check previous event to know whether this wdata is first or not.
617 * When previous wdata's event is 'finish' and current wdata's event is 'finish',
618 * the player should send utt started event.
620 if (TTSE_RESULT_EVENT_START == sound_data->event ||
621 (TTSE_RESULT_EVENT_FINISH == player->event && TTSE_RESULT_EVENT_FINISH == sound_data->event)) {
622 int pid = ttsd_data_get_pid(player->uid);
625 SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid");
626 /* unset volume policy, volume will be 100% */
627 __unset_policy_for_playing();
632 if (0 != ttsdc_send_utt_start_message(pid, player->uid, sound_data->utt_id)) {
633 SLOG(LOG_ERROR, tts_tag(), "[Send ERROR] Fail to send Utterance Start Signal : pid(%d), uid(%d), uttid(%d)",
634 pid, player->uid, sound_data->utt_id);
636 SLOG(LOG_INFO, tts_tag(), "[Player] Start utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id);
639 /* Save last event to check utterance start */
640 player->event = sound_data->event;
643 if (NULL == sound_data->data || 0 >= sound_data->data_size) {
644 if (TTSE_RESULT_EVENT_FINISH == sound_data->event) {
645 SLOG(LOG_DEBUG, tts_tag(), "No sound data");
646 /* send utterence finish signal */
647 int pid = ttsd_data_get_pid(player->uid);
650 SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid");
651 /* unset volume policy, volume will be 100% */
652 __unset_policy_for_playing();
656 __unset_policy_for_playing();
658 if (0 != ttsdc_send_utt_finish_message(pid, player->uid, sound_data->utt_id)) {
659 SLOG(LOG_ERROR, tts_tag(), "[Send ERROR] Fail to send Utterance Completed Signal : pid(%d), uid(%d), uttid(%d)",
660 pid, player->uid, sound_data->utt_id);
662 SLOG(LOG_INFO, tts_tag(), "[Player] Finish utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id);
665 SLOG(LOG_INFO, tts_tag(), "[Player] Event(%d) utterance : uid(%d), uttid(%d)", sound_data->event, player->uid, sound_data->utt_id);
666 ttsd_data_clear_sound_data(player->uid, &sound_data);
671 if (g_sampling_rate != sound_data->rate || g_audio_type != sound_data->audio_type) {
672 SLOG(LOG_INFO, tts_tag(), "[Player] Change audio handle : org type(%d) org rate(%d)", g_audio_type, g_sampling_rate);
673 if (NULL != g_audio_h) {
674 __destroy_audio_out();
677 if (0 > __create_audio_out(sound_data->audio_type, sound_data->rate)) {
678 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to create audio out");
679 /* unset volume policy, volume will be 100% */
680 __unset_policy_for_playing();
682 ttsd_data_clear_sound_data(player->uid, &sound_data);
687 SLOG(LOG_INFO, tts_tag(), "[Player INFO] Success to destroy and recreate audio out");
688 __set_policy_for_playing(40);
691 while (APP_STATE_PLAYING == player->state || APP_STATE_PAUSED == player->state) {
692 if ((unsigned int)idx >= sound_data->data_size)
695 if ((unsigned int)idx + SOUND_BUFFER_LENGTH > sound_data->data_size) {
696 len = sound_data->data_size - idx;
698 len = SOUND_BUFFER_LENGTH;
701 if (AUDIO_STATE_READY == g_audio_state) {
702 /* Request prepare */
703 ret = audio_out_prepare(g_audio_h);
704 if (AUDIO_IO_ERROR_NONE != ret) {
705 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to prepare audio : %d", ret);
706 g_playing_info = NULL;
707 /* unset volume policy, volume will be 100% */
708 __unset_policy_for_playing();
710 ttsd_data_clear_sound_data(player->uid, &sound_data);
714 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Prepare audio");
715 g_audio_state = AUDIO_STATE_PLAY;
718 char* temp_data = sound_data->data;
719 SLOG(LOG_INFO, tts_tag(), "[Player INFO] Before audio_out_write. data(%p), data[%d](%p), uid(%d), utt_id(%d), len(%d)",
720 temp_data, idx, &temp_data[idx], player->uid, sound_data->utt_id, len);
722 /* write pcm buffer */
723 fwrite(&temp_data[idx], 1, len, g_pFile);
725 ret = audio_out_write(g_audio_h, &temp_data[idx], len);
727 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to audio write - %d", ret);
730 SLOG(LOG_INFO, tts_tag(), "[Player INFO] After audio_out_write");
733 if (NULL == g_playing_info && APP_STATE_PAUSED != player->state) {
734 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Current player is NULL");
735 g_audio_state = AUDIO_STATE_READY;
736 ret = audio_out_unprepare(g_audio_h);
737 if (AUDIO_IO_ERROR_NONE != ret) {
738 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
740 /* unset volume policy, volume will be 100% */
741 __unset_policy_for_playing();
743 ttsd_data_clear_sound_data(player->uid, &sound_data);
748 if (APP_STATE_PAUSED == player->state) {
750 SLOG(LOG_DEBUG, tts_tag(), "[Player] player(%p)", player);
751 player->paused_data = sound_data;
753 player->is_paused_data = true;
756 g_audio_state = AUDIO_STATE_READY;
758 SLOG(LOG_INFO, tts_tag(), "[Player] Stop player thread by pause");
760 /* Request prepare */
761 ret = audio_out_unprepare(g_audio_h);
762 if (AUDIO_IO_ERROR_NONE != ret) {
763 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
765 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio");
767 /* unset volume policy, volume will be 100% */
768 __unset_policy_for_playing();
773 if (NULL == g_playing_info && APP_STATE_READY == player->state) {
775 g_audio_state = AUDIO_STATE_READY;
776 SLOG(LOG_DEBUG, tts_tag(), "[Player] Stop player thread");
778 /* Request prepare */
779 ret = audio_out_unprepare(g_audio_h);
780 if (AUDIO_IO_ERROR_NONE != ret) {
781 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
783 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio");
786 ttsd_data_clear_sound_data(player->uid, &sound_data);
787 /* unset volume policy, volume will be 100% */
788 __unset_policy_for_playing();
792 if ((APP_STATE_PLAYING == player->state || APP_STATE_PAUSED == player->state) &&
793 (TTSE_RESULT_EVENT_FINISH == sound_data->event)) {
794 /* send utterence finish signal */
795 int pid = ttsd_data_get_pid(player->uid);
798 SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid");
799 /* unset volume policy, volume will be 100% */
800 __unset_policy_for_playing();
805 if (0 != ttsdc_send_utt_finish_message(pid, player->uid, sound_data->utt_id)) {
806 SLOG(LOG_ERROR, tts_tag(), "[Send ERROR] Fail to send Utterance Completed Signal : pid(%d), uid(%d), uttid(%d)",
807 pid, player->uid, sound_data->utt_id);
808 /* unset volume policy, volume will be 100% */
809 __unset_policy_for_playing();
811 ttsd_data_clear_sound_data(player->uid, &sound_data);
815 SLOG(LOG_INFO, tts_tag(), "[Player] Finish utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id);
818 ttsd_data_clear_sound_data(player->uid, &sound_data);
820 if (NULL == g_playing_info) {
821 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Current player is NULL");
822 g_audio_state = AUDIO_STATE_READY;
823 ret = audio_out_unprepare(g_audio_h);
824 if (AUDIO_IO_ERROR_NONE != ret) {
825 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
827 /* unset volume policy, volume will be 100% */
828 __unset_policy_for_playing();
835 int __create_ducking_handle(void)
838 if (NULL == g_media_stream_ducking) {
839 ret = sound_manager_create_stream_ducking(SOUND_STREAM_TYPE_MEDIA, __sound_stream_ducking_state_changed_cb, NULL, &g_media_stream_ducking);
840 if (SOUND_MANAGER_ERROR_NONE != ret)
841 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to create stream ducking for type media, ret(%d)", ret);
843 SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for media stream is already created");
845 if (NULL == g_system_stream_ducking) {
846 ret = sound_manager_create_stream_ducking(SOUND_TYPE_SYSTEM, __sound_stream_ducking_state_changed_cb, NULL, &g_system_stream_ducking);
847 if (SOUND_MANAGER_ERROR_NONE != ret)
848 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to create stream ducking for system type, ret(%d)", ret);
850 SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for system stream is already created");
853 if (NULL == g_notification_stream_ducking) {
854 ret = sound_manager_create_stream_ducking(SOUND_TYPE_NOTIFICATION, __sound_stream_ducking_state_changed_cb, NULL, &g_notification_stream_ducking);
855 if (SOUND_MANAGER_ERROR_NONE != ret)
856 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to create stream ducking for notification type, ret(%d)", ret);
858 SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for notification stream is already created");
861 if (NULL == g_alarm_stream_ducking) {
862 ret = sound_manager_create_stream_ducking(SOUND_TYPE_ALARM, __sound_stream_ducking_state_changed_cb, NULL, &g_alarm_stream_ducking);
863 if (SOUND_MANAGER_ERROR_NONE != ret)
864 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to create stream ducking for alarm type, ret(%d)", ret);
866 SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for alarm stream is already created");
875 int ttsd_player_init()
877 g_playing_info = NULL;
878 g_audio_state = AUDIO_STATE_NONE;
883 ecore_thread_max_set(1);
887 if (0 == access(FOCUS_SERVER_READY, F_OK)) {
888 SLOG(LOG_ERROR, tts_tag(), "[Player SUCCESS] focus server is available");
892 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] focus server is not available");
897 ret = sound_manager_create_stream_information(SOUND_STREAM_TYPE_VOICE_INFORMATION, __player_focus_state_cb, NULL, &g_stream_info_h);
898 if (SOUND_MANAGER_ERROR_NONE != ret) {
899 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to create stream info");
902 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Create stream info");
905 /* add sound focus state watch callback */
906 ret = sound_manager_add_focus_state_watch_cb(SOUND_STREAM_FOCUS_FOR_PLAYBACK, __player_focus_state_watch_cb, NULL, &g_focus_watch_id);
907 if (SOUND_MANAGER_ERROR_NONE != ret) {
908 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to add sound focus watch callback");
909 sound_manager_destroy_stream_information(g_stream_info_h);
912 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Add sound focus watch callback");
915 ret = __create_ducking_handle();
916 if (SOUND_MANAGER_ERROR_NONE != ret) {
917 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to create ducking handle, ret(%d)", ret);
919 SLOG(LOG_INFO, tts_tag(), "[Player SUCCESS] Create ducking handle");
922 ecore_thread_max_set(1);
924 ret = __create_audio_out(TTSE_AUDIO_TYPE_RAW_S16, 16000);
926 sound_manager_destroy_stream_information(g_stream_info_h);
927 sound_manager_remove_focus_state_watch_cb(g_focus_watch_id);
931 g_player_init = true;
936 int __destroy_ducking_handle(void)
939 if (g_media_stream_ducking) {
940 ret = sound_manager_destroy_stream_ducking(g_media_stream_ducking);
941 if (SOUND_MANAGER_ERROR_NONE != ret)
942 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to destroy media stream ducking, ret(%d)", ret);
943 g_media_stream_ducking = NULL;
945 SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for media stream is already created");
948 if (g_system_stream_ducking) {
949 ret = sound_manager_destroy_stream_ducking(g_system_stream_ducking);
950 if (SOUND_MANAGER_ERROR_NONE != ret)
951 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to destroy system stream ducking, ret(%d)", ret);
952 g_system_stream_ducking = NULL;
954 SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for system stream is already created");
957 if (g_notification_stream_ducking) {
958 ret = sound_manager_destroy_stream_ducking(g_notification_stream_ducking);
959 if (SOUND_MANAGER_ERROR_NONE != ret)
960 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to destroy notification stream ducking, ret(%d)", ret);
961 g_notification_stream_ducking = NULL;
963 SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for notification stream is already created");
966 if (g_alarm_stream_ducking) {
967 ret = sound_manager_destroy_stream_ducking(g_alarm_stream_ducking);
968 if (SOUND_MANAGER_ERROR_NONE != ret)
969 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to destroy alarm stream ducking, ret(%d)", ret);
970 g_alarm_stream_ducking = NULL;
972 SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for alarm stream is already created");
977 int ttsd_player_release(void)
979 if (false == g_player_init) {
980 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
981 return TTSD_ERROR_OPERATION_FAILED;
986 SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] @@@@@");
987 SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] Active thread count : %d", ecore_thread_active_get());
988 SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] @@@@@");
990 /* The thread should be released */
991 int thread_count = ecore_thread_active_get();
993 while (0 < thread_count) {
998 SLOG(LOG_WARN, tts_tag(), "[Player WARNING!!] Thread is blocked. Player release continue.");
1002 thread_count = ecore_thread_active_get();
1005 SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] Thread is released");
1007 ret = __destroy_audio_out();
1011 ret = sound_manager_destroy_stream_information(g_stream_info_h);
1012 if (SOUND_MANAGER_ERROR_NONE != ret) {
1013 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to destroy stream info");
1015 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Destroy stream info");
1018 /* remove focus state watch callback */
1019 ret = sound_manager_remove_focus_state_watch_cb(g_focus_watch_id);
1020 if (SOUND_MANAGER_ERROR_NONE != ret) {
1021 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to remove the focus state watch cb");
1023 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Remove the focus state watch cb");
1026 ret = __destroy_ducking_handle();
1027 if (SOUND_MANAGER_ERROR_NONE != ret)
1028 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to destroy stream ducking, ret(%d)", ret);
1030 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Destroy stream ducking");
1032 /* clear g_player_list */
1033 g_playing_info = NULL;
1034 g_player_init = false;
1039 int ttsd_player_create_instance(int uid)
1041 if (false == g_player_init) {
1042 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
1046 /* Check uid is duplicated */
1047 if (NULL != __player_get_item(uid)) {
1048 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is already registered", uid);
1052 player_s* new_client = (player_s*)calloc(1, sizeof(player_s));
1053 if (NULL == new_client) {
1054 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to allocate memory");
1055 return TTSE_ERROR_OUT_OF_MEMORY;
1058 new_client->uid = uid;
1059 new_client->event = TTSE_RESULT_EVENT_FINISH;
1060 new_client->state = APP_STATE_READY;
1061 new_client->is_paused_data = false;
1062 new_client->idx = 0;
1063 new_client->paused_data = NULL;
1065 SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Player] Create player : uid(%d)", uid);
1067 g_player_list = g_list_append(g_player_list, new_client);
1072 int ttsd_player_destroy_instance(int uid)
1074 if (false == g_player_init) {
1075 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
1080 current = __player_get_item(uid);
1081 if (NULL == current) {
1082 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
1086 if (NULL != g_playing_info) {
1087 if (uid == g_playing_info->uid) {
1088 g_playing_info = NULL;
1093 player_s *data = NULL;
1095 if (0 < g_list_length(g_player_list)) {
1096 /* Get a first item */
1097 iter = g_list_first(g_player_list);
1099 while (NULL != iter) {
1100 /* Get handle data from list */
1101 data = (player_s*)iter->data;
1105 if (uid == data->uid) {
1106 g_player_list = g_list_remove_link(g_player_list, iter);
1114 iter = g_list_next(iter);
1118 SLOG(LOG_DEBUG, tts_tag(), "[PLAYER Success] Destroy instance");
1123 int ttsd_player_play(int uid)
1125 if (false == g_player_init) {
1126 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
1130 if (NULL != g_playing_info) {
1131 if (uid == g_playing_info->uid) {
1132 SLOG(LOG_DEBUG, tts_tag(), "[Player] uid(%d) has already played", g_playing_info->uid);
1135 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] stop old player (%d)", g_playing_info->uid);
1136 ttsd_player_stop(g_playing_info->uid);
1140 SLOG(LOG_DEBUG, tts_tag(), "[Player] start play : uid(%d)", uid);
1142 /* Check sound queue size */
1143 if (0 == ttsd_data_get_sound_data_size(uid)) {
1144 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] A sound queue of current player(%d) is empty", uid);
1150 current = __player_get_item(uid);
1151 if (NULL == current) {
1152 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
1156 current->state = APP_STATE_PLAYING;
1158 g_playing_info = current;
1160 SLOG(LOG_INFO, tts_tag(), "[Player DEBUG] Active thread count : %d", ecore_thread_active_get());
1162 if (0 < ttsd_data_get_sound_data_size(current->uid)) {
1163 SLOG(LOG_INFO, tts_tag(), "[Player] Run thread");
1164 ecore_thread_run(__play_thread, __end_play_thread, NULL, NULL);
1170 int ttsd_player_stop(int uid)
1172 if (false == g_player_init) {
1173 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
1179 current = __player_get_item(uid);
1180 if (NULL == current) {
1181 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
1185 /* check whether uid is current playing or not */
1186 if (NULL != g_playing_info) {
1187 if (uid == g_playing_info->uid) {
1188 /* release current playing info */
1189 g_playing_info = NULL;
1192 SLOG(LOG_DEBUG, tts_tag(), "[Player] No current playing");
1195 if (true == current->is_paused_data) {
1196 if (NULL != current->paused_data) {
1197 if (NULL != current->paused_data->data) {
1198 free(current->paused_data->data);
1199 current->paused_data->data = NULL;
1202 free(current->paused_data);
1203 current->paused_data = NULL;
1207 current->event = TTSE_RESULT_EVENT_FINISH;
1208 current->state = APP_STATE_READY;
1209 current->is_paused_data = false;
1212 if (NULL == g_playing_info) {
1213 SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
1214 SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
1215 SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
1217 /* The thread should be released */
1218 int thread_count = ecore_thread_active_get();
1220 while (0 < thread_count) {
1225 SLOG(LOG_WARN, tts_tag(), "[Player WARNING!!] Thread is blocked. Player release continue.");
1229 thread_count = ecore_thread_active_get();
1232 SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
1233 SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
1234 SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
1237 SLOG(LOG_INFO, tts_tag(), "[Player SUCCESS] Stop player : uid(%d)", uid);
1242 int ttsd_player_clear(int uid)
1244 if (false == g_player_init) {
1245 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
1251 current = __player_get_item(uid);
1252 if (NULL == current) {
1253 SECURE_SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
1257 if (true == current->is_paused_data) {
1258 if (NULL != current->paused_data) {
1259 if (NULL != current->paused_data->data) {
1260 free(current->paused_data->data);
1261 current->paused_data->data = NULL;
1264 free(current->paused_data);
1265 current->paused_data = NULL;
1269 current->event = TTSE_RESULT_EVENT_FINISH;
1270 current->state = APP_STATE_READY;
1271 current->is_paused_data = false;
1274 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Clear player : uid(%d)", uid);
1279 int ttsd_player_pause(int uid)
1281 SLOG(LOG_DEBUG, tts_tag(), "[Player] pause player : uid(%d)", uid);
1283 if (false == g_player_init) {
1284 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
1290 current = __player_get_item(uid);
1291 if (NULL == current) {
1292 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] ttsd_player_pause() : uid(%d) is not valid", uid);
1296 /* check whether uid is current playing or not */
1297 if (NULL != g_playing_info) {
1298 if (uid == g_playing_info->uid) {
1299 /* release current playing info */
1300 SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] release current playing info (%d)", uid);
1301 g_playing_info = NULL;
1307 SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] current player (%p), g_playing_info(%p)", current, g_playing_info);
1309 current->state = APP_STATE_PAUSED;
1311 if (NULL == g_playing_info) {
1312 SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
1313 SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
1314 SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
1316 /* The thread should be released */
1317 int thread_count = ecore_thread_active_get();
1319 while (0 < thread_count) {
1323 SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] current(%p), state(%d)", current, current->state);
1326 SLOG(LOG_WARN, tts_tag(), "[Player WARNING!!] Thread is blocked. Player release continue. current(%p) current state(%d)", current, current->state);
1330 thread_count = ecore_thread_active_get();
1333 SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
1334 SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
1335 SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
1339 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Pause player : uid(%d)", uid);
1344 int ttsd_player_resume(int uid)
1346 SLOG(LOG_DEBUG, tts_tag(), "[Player] Resume player : uid(%d)", uid);
1348 if (false == g_player_init) {
1349 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
1355 current = __player_get_item(uid);
1356 if (NULL == current) {
1357 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
1361 /* check current player */
1362 if (NULL != g_playing_info)
1363 g_playing_info = NULL;
1365 current->state = APP_STATE_PLAYING;
1366 g_playing_info = current;
1368 SLOG(LOG_INFO, tts_tag(), "[Player] Resume to run thread");
1369 ecore_thread_run(__play_thread, __end_play_thread, NULL, NULL);
1374 int ttsd_player_all_stop()
1376 if (false == g_player_init) {
1377 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
1381 g_playing_info = NULL;
1384 player_s *data = NULL;
1386 if (0 < g_list_length(g_player_list)) {
1387 /* Get a first item */
1388 iter = g_list_first(g_player_list);
1390 while (NULL != iter) {
1391 /* Get handle data from list */
1392 data = (player_s*)iter->data;
1394 app_tts_state_e state;
1395 if (0 > ttsd_data_get_client_state(data->uid, &state)) {
1396 SLOG(LOG_ERROR, tts_tag(), "[player ERROR] uid(%d) is not valid", data->uid);
1397 ttsd_player_destroy_instance(data->uid);
1398 iter = g_list_next(iter);
1402 if (APP_STATE_PLAYING == state || APP_STATE_PAUSED == state) {
1403 data->event = TTSE_RESULT_EVENT_FINISH;
1404 data->state = APP_STATE_READY;
1406 if (true == data->is_paused_data) {
1407 if (NULL != data->paused_data) {
1408 if (NULL != data->paused_data->data) {
1409 free(data->paused_data->data);
1410 data->paused_data->data = NULL;
1413 free(data->paused_data);
1414 data->paused_data = NULL;
1418 data->is_paused_data = false;
1423 iter = g_list_next(iter);
1427 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] player all stop!!");
1432 int ttsd_player_play_pcm(int uid)
1434 if (false == g_player_init) {
1435 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
1439 if (NULL != g_playing_info) {
1440 if (uid == g_playing_info->uid) {
1441 SLOG(LOG_DEBUG, tts_tag(), "[Player] uid(%d) has already played", g_playing_info->uid);
1444 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] stop old player (%d)", g_playing_info->uid);
1445 ttsd_player_stop(g_playing_info->uid);
1449 SLOG(LOG_DEBUG, tts_tag(), "[Player] start play : uid(%d)", uid);
1451 /* Check sound queue size */
1452 if (0 == ttsd_data_get_sound_data_size(uid)) {
1453 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] A sound queue of current player(%d) is empty", uid);
1458 current = __player_get_item(uid);
1459 if (NULL == current) {
1460 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
1464 current->state = APP_STATE_PLAYING;
1466 g_playing_info = current;
1468 SLOG(LOG_INFO, tts_tag(), "[Player DEBUG] Active thread count : %d", ecore_thread_active_get());
1470 if (0 <= ttsd_data_get_sound_data_size(current->uid)) {
1471 SLOG(LOG_INFO, tts_tag(), "[Player] Run thread");
1472 ecore_thread_run(__play_thread, __end_play_thread, NULL, NULL);
1478 int ttsd_player_get_background_volume_ratio(double* ratio)
1483 *ratio = g_bg_volume_ratio;
1485 return TTSD_ERROR_NONE;
1488 int ttsd_player_set_background_volume_ratio(double ratio)
1490 SLOG(LOG_INFO, tts_tag(), "[Player DEBUG] ttsd_player_set_background_volume_ratio : %lf", ratio);
1492 g_bg_volume_ratio = ratio;
1493 return TTSD_ERROR_NONE;