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 /** player init info */
53 static bool g_player_init = false;
56 static GList *g_player_list;
58 /** current player information */
59 static player_s* g_playing_info;
62 static audio_state_e g_audio_state;
64 static ttse_audio_type_e g_audio_type;
66 static int g_sampling_rate;
68 static audio_out_h g_audio_h;
70 static sound_stream_info_h g_stream_info_h;
72 static int g_focus_watch_id;
77 player_s* __player_get_item(int uid)
80 player_s *data = NULL;
82 if (0 < g_list_length(g_player_list)) {
83 /* Get a first item */
84 iter = g_list_first(g_player_list);
86 while (NULL != iter) {
87 /* Get handle data from list */
88 data = (player_s*)iter->data;
95 iter = g_list_next(iter);
102 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,
103 sound_stream_focus_change_reason_e reason_for_change, int sound_behavior, const char *extra_info, void *user_data)
105 SLOG(LOG_DEBUG, tts_tag(), "@@@ Focus state changed cb");
107 if (stream_info != g_stream_info_h) {
108 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Invalid stream info handle");
111 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);
113 if (AUDIO_STATE_PLAY == g_audio_state && focus_mask == SOUND_STREAM_FOCUS_FOR_PLAYBACK && SOUND_STREAM_FOCUS_STATE_RELEASED == focus_state) {
114 if (TTSD_MODE_DEFAULT == ttsd_get_mode()) {
115 g_audio_state = AUDIO_STATE_READY;
117 if (NULL == g_playing_info) {
118 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] No current player");
122 if (APP_STATE_PLAYING == g_playing_info->state) {
123 int uid = g_playing_info->uid;
125 if (0 != ttsd_player_pause(uid)) {
126 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to pause the player");
130 ttsd_data_set_client_state(uid, APP_STATE_PAUSED);
131 int pid = ttsd_data_get_pid(uid);
132 /* send message to client about changing state */
133 ttsdc_send_set_state_message(pid, uid, APP_STATE_PAUSED);
136 SLOG(LOG_DEBUG, tts_tag(), "[Player] Ignore focus state cb - mode(%d)", ttsd_get_mode());
140 /* if (AUDIO_STATE_READY == g_audio_state && focus_mask == SOUND_STREAM_FOCUS_FOR_PLAYBACK && SOUND_STREAM_FOCUS_STATE_ACQUIRED == focus_state) {
141 if (TTSD_MODE_DEFAULT == ttsd_get_mode()) {
142 g_audio_state = AUDIO_STATE_PLAY;
144 if (NULL == g_playing_info) {
145 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] No current player");
149 if (APP_STATE_PAUSED == g_playing_info->state) {
150 int uid = g_playing_info->uid;
152 g_audio_state = AUDIO_STATE_PLAY;
153 if (0 != ttsd_player_resume(uid)) {
154 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to resume the player");
155 g_audio_state = AUDIO_STATE_READY;
159 ttsd_data_set_client_state(uid, APP_STATE_PLAYING);
160 int pid = ttsd_data_get_pid(uid);
161 ttsdc_send_set_state_message(pid, uid, APP_STATE_PLAYING);
165 SLOG(LOG_DEBUG, tts_tag(), "[Player] Ignore focus state cb - mode(%d)", ttsd_get_mode());
169 SLOG(LOG_DEBUG, tts_tag(), "@@@");
174 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,
175 const char *extra_info, void *user_data)
177 SLOG(LOG_DEBUG, tts_tag(), "@@@ Focus state watch cb");
179 ttsd_mode_e mode = ttsd_get_mode();
181 if (TTSD_MODE_SCREEN_READER != mode && TTSD_MODE_NOTIFICATION != mode) {
182 SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] This is not screen-reader mode and notification mode.");
186 if (AUDIO_STATE_PLAY == g_audio_state && SOUND_STREAM_FOCUS_CHANGED_BY_VOICE_INFORMATION == reason &&
187 NULL != extra_info && 0 == strncmp(extra_info, "TTSD_MODE_INTERRUPT", strlen(extra_info))) {
188 /* If the focus is changed by "Interrupt" mode and current players of "SR" and "Noti" modes are on going, please stop the current players. */
189 g_audio_state = AUDIO_STATE_READY;
191 if (NULL == g_playing_info) {
192 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] No current player");
196 if (APP_STATE_PLAYING == g_playing_info->state) {
197 int uid = g_playing_info->uid;
199 if (0 != ttsd_server_stop(uid)) {
200 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to stop TTS server");
203 if (0 != ttsd_player_stop(uid)) {
204 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to stop the player");
208 ttsd_data_set_client_state(uid, APP_STATE_READY);
209 int pid = ttsd_data_get_pid(uid);
210 /* send message to client about changing state */
211 ttsdc_send_set_state_message(pid, uid, APP_STATE_READY);
213 SLOG(LOG_DEBUG, tts_tag(), "[Player] Not playing state");
216 SLOG(LOG_DEBUG, tts_tag(), "[Player] This is not Interrupt mode or not playing state.");
222 static int __create_audio_out(ttse_audio_type_e type, int rate)
225 audio_sample_type_e sample_type;
227 if (TTSE_AUDIO_TYPE_RAW_S16 == type) {
228 sample_type = AUDIO_SAMPLE_TYPE_S16_LE;
230 sample_type = AUDIO_SAMPLE_TYPE_U8;
233 ret = audio_out_create_new(rate, AUDIO_CHANNEL_MONO, sample_type, &g_audio_h);
234 if (AUDIO_IO_ERROR_NONE != ret) {
235 g_audio_state = AUDIO_STATE_NONE;
237 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to create audio");
240 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Create audio");
244 g_sampling_rate = rate;
246 g_audio_state = AUDIO_STATE_READY;
251 static int __destroy_audio_out()
253 if (NULL == g_audio_h) {
254 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Current handle is not valid");
259 ret = audio_out_destroy(g_audio_h);
260 if (AUDIO_IO_ERROR_NONE != ret) {
261 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to destroy audio");
264 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Destroy audio");
270 g_audio_state = AUDIO_STATE_NONE;
276 static void __end_play_thread(void *data, Ecore_Thread *thread)
278 SLOG(LOG_ERROR, tts_tag(), "@@@ End thread");
281 static void __set_policy_for_playing(int volume)
283 /* Set stream info */
285 ttsd_mode_e mode = ttsd_get_mode();
286 if (TTSD_MODE_DEFAULT == mode) {
287 ret = sound_manager_acquire_focus(g_stream_info_h, SOUND_STREAM_FOCUS_FOR_PLAYBACK, SOUND_BEHAVIOR_NONE, NULL);
288 if (SOUND_MANAGER_ERROR_NONE != ret) {
289 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to acquire focus");
291 SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] Success to acquire focus (default mode)");
293 } else if (TTSD_MODE_INTERRUPT == mode) {
294 ret = sound_manager_acquire_focus(g_stream_info_h, SOUND_STREAM_FOCUS_FOR_PLAYBACK, SOUND_BEHAVIOR_NONE, "TTSD_MODE_INTERRUPT");
295 if (SOUND_MANAGER_ERROR_NONE != ret) {
296 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to acquire focus");
298 SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] Success to acquire focus (interrupt mode)");
302 ret = audio_out_set_sound_stream_info(g_audio_h, g_stream_info_h);
303 if (AUDIO_IO_ERROR_NONE != ret) {
304 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to set stream info");
307 SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] set policy for playing");
312 static void __unset_policy_for_playing()
315 ttsd_mode_e mode = ttsd_get_mode();
316 /* Unset stream info */
317 if (TTSD_MODE_DEFAULT == mode || TTSD_MODE_INTERRUPT == mode) {
318 sound_stream_focus_state_e state_for_playing = SOUND_STREAM_FOCUS_STATE_ACQUIRED;
319 ret = sound_manager_get_focus_state(g_stream_info_h, &state_for_playing, NULL);
320 if (SOUND_MANAGER_ERROR_NONE != ret) {
321 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to get focus state: %d", ret);
324 if (SOUND_STREAM_FOCUS_STATE_ACQUIRED == state_for_playing) {
325 if (TTSD_MODE_DEFAULT == mode || TTSD_MODE_INTERRUPT == mode) {
326 ret = sound_manager_release_focus(g_stream_info_h, SOUND_STREAM_FOCUS_FOR_PLAYBACK, SOUND_BEHAVIOR_NONE, NULL);
327 SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] release focus (mode: %d)", mode);
330 if (SOUND_MANAGER_ERROR_NONE != ret) {
331 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to release focus");
336 SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] unset policy for playing");
341 int ttsd_player_check_current_playback_focus(bool *is_current_interrupt)
344 ttsd_mode_e mode = ttsd_get_mode();
346 if (TTSD_MODE_INTERRUPT != mode) {
347 /* check the current playback focus */
348 sound_stream_focus_change_reason_e reason;
349 int sound_behavior = 0;
350 char *extra_info = NULL;
352 ret = sound_manager_get_current_playback_focus(&reason, &sound_behavior, &extra_info);
354 SLOG(LOG_DEBUG, tts_tag(), "[Player] current playback focus: extra_info(%s), reason(%d), sound_behavior(%d)", extra_info, reason, sound_behavior, extra_info);
356 if (SOUND_MANAGER_ERROR_NONE == ret && NULL != extra_info && 0 < strlen(extra_info)) {
357 if (SOUND_STREAM_FOCUS_CHANGED_BY_VOICE_INFORMATION == reason && 0 == strncmp(extra_info, "TTSD_MODE_INTERRUPT", strlen(extra_info))) {
358 SLOG(LOG_DEBUG, tts_tag(), "[Player] The current focus in Interrupt. Cannot play the requested sound data");
359 *is_current_interrupt = true;
364 return TTSD_ERROR_NONE;
368 if (NULL != extra_info) {
374 *is_current_interrupt = false;
376 return TTSD_ERROR_NONE;
379 static void __play_thread(void *data, Ecore_Thread *thread)
381 SLOG(LOG_DEBUG, tts_tag(), "@@@ Start thread");
383 if (NULL == g_playing_info) {
384 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] No current player");
388 player_s* player = g_playing_info;
389 sound_data_s* sound_data = NULL;
392 int len = SOUND_BUFFER_LENGTH;
395 /* set volume policy as 40% */
396 __set_policy_for_playing(40);
398 if (true == player->is_paused_data) {
400 sound_data = player->paused_data;
401 player->paused_data = NULL;
405 player->is_paused_data = false;
408 if (NULL == sound_data) {
409 /* Request unprepare */
410 ret = audio_out_unprepare(g_audio_h);
411 if (AUDIO_IO_ERROR_NONE != ret) {
412 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
414 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio");
417 g_audio_state = AUDIO_STATE_READY;
419 /* unset volume policy, volume will be 100% */
420 __unset_policy_for_playing();
423 SLOG(LOG_INFO, tts_tag(), "[Player] Sound info : id(%d) data(%p) size(%d) audiotype(%d) rate(%d) event(%d)",
424 sound_data->utt_id, sound_data->data, sound_data->data_size, sound_data->audio_type, sound_data->rate, sound_data->event);
427 ret = ttsd_data_get_sound_data(player->uid, &sound_data);
428 if (0 != ret || NULL == sound_data) {
430 SLOG(LOG_DEBUG, tts_tag(), "[Player] No sound data. Waiting mode");
431 /* release audio & recover session */
432 ret = audio_out_unprepare(g_audio_h);
433 if (AUDIO_IO_ERROR_NONE != ret) {
434 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
436 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio");
438 g_audio_state = AUDIO_STATE_READY;
440 /* unset volume policy, volume will be 100% */
441 __unset_policy_for_playing();
443 /* wait for new audio data come */
446 if (NULL == g_playing_info) {
447 /* current playing uid is replaced */
448 SLOG(LOG_INFO, tts_tag(), "[Player] Finish thread");
450 } else if (0 < ttsd_data_get_sound_data_size(player->uid)) {
451 /* new audio data come */
452 SLOG(LOG_INFO, tts_tag(), "[Player] Resume thread");
457 SLOG(LOG_INFO, tts_tag(), "[Player] Finish to wait for new audio data come");
459 /* set volume policy as 40%, when resume play thread*/
460 __set_policy_for_playing(40);
462 /* resume play thread */
463 player->state = APP_STATE_PLAYING;
467 /* If wdata's event is 'start', current wdata is first data of engine for synthesis.
468 * If wdata's event is 'finish', player should check previous event to know whether this wdata is first or not.
469 * When previous wdata's event is 'finish' and current wdata's event is 'finish',
470 * the player should send utt started event.
472 if (TTSE_RESULT_EVENT_START == sound_data->event ||
473 (TTSE_RESULT_EVENT_FINISH == player->event && TTSE_RESULT_EVENT_FINISH == sound_data->event)) {
474 int pid = ttsd_data_get_pid(player->uid);
477 SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid");
478 /* unset volume policy, volume will be 100% */
479 __unset_policy_for_playing();
481 ttsd_data_clear_sound_data(&sound_data);
485 if (0 != ttsdc_send_utt_start_message(pid, player->uid, sound_data->utt_id)) {
486 SLOG(LOG_ERROR, tts_tag(), "[Send ERROR] Fail to send Utterance Start Signal : pid(%d), uid(%d), uttid(%d)",
487 pid, player->uid, sound_data->utt_id);
489 SLOG(LOG_INFO, tts_tag(), "[Player] Start utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id);
492 /* Save last event to check utterance start */
493 player->event = sound_data->event;
496 if (NULL == sound_data->data || 0 >= sound_data->data_size) {
497 if (TTSE_RESULT_EVENT_FINISH == sound_data->event) {
498 SLOG(LOG_DEBUG, tts_tag(), "No sound data");
499 /* send utterence finish signal */
500 int pid = ttsd_data_get_pid(player->uid);
503 SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid");
504 /* unset volume policy, volume will be 100% */
505 __unset_policy_for_playing();
506 ttsd_data_clear_sound_data(&sound_data);
509 if (0 != ttsdc_send_utt_finish_message(pid, player->uid, sound_data->utt_id)) {
510 SLOG(LOG_ERROR, tts_tag(), "[Send ERROR] Fail to send Utterance Completed Signal : pid(%d), uid(%d), uttid(%d)",
511 pid, player->uid, sound_data->utt_id);
514 SLOG(LOG_INFO, tts_tag(), "[Player] Finish utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id);
515 ttsd_data_clear_sound_data(&sound_data);
520 if (g_sampling_rate != sound_data->rate || g_audio_type != sound_data->audio_type) {
521 SLOG(LOG_DEBUG, tts_tag(), "[Player] Change audio handle : org type(%d) org rate(%d)", g_audio_type, g_sampling_rate);
522 if (NULL != g_audio_h) {
523 __destroy_audio_out();
526 if (0 > __create_audio_out(sound_data->audio_type, sound_data->rate)) {
527 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to create audio out");
528 /* unset volume policy, volume will be 100% */
529 __unset_policy_for_playing();
531 ttsd_data_clear_sound_data(&sound_data);
536 __set_policy_for_playing(40);
539 while (APP_STATE_PLAYING == player->state || APP_STATE_PAUSED == player->state) {
540 if ((unsigned int)idx >= sound_data->data_size)
543 if ((unsigned int)idx + SOUND_BUFFER_LENGTH > sound_data->data_size) {
544 len = sound_data->data_size - idx;
546 len = SOUND_BUFFER_LENGTH;
549 if (AUDIO_STATE_READY == g_audio_state) {
550 /* Request prepare */
551 ret = audio_out_prepare(g_audio_h);
552 if (AUDIO_IO_ERROR_NONE != ret) {
553 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to prepare audio : %d", ret);
554 g_playing_info = NULL;
555 /* unset volume policy, volume will be 100% */
556 __unset_policy_for_playing();
558 ttsd_data_clear_sound_data(&sound_data);
562 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Prepare audio");
563 g_audio_state = AUDIO_STATE_PLAY;
566 char* temp_data = sound_data->data;
567 ret = audio_out_write(g_audio_h, &temp_data[idx], len);
569 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to audio write - %d", ret);
574 if (NULL == g_playing_info && APP_STATE_PAUSED != player->state) {
575 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Current player is NULL");
576 g_audio_state = AUDIO_STATE_READY;
577 ret = audio_out_unprepare(g_audio_h);
578 if (AUDIO_IO_ERROR_NONE != ret) {
579 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
581 /* unset volume policy, volume will be 100% */
582 __unset_policy_for_playing();
584 ttsd_data_clear_sound_data(&sound_data);
589 if (APP_STATE_PAUSED == player->state) {
591 player->paused_data = sound_data;
593 player->is_paused_data = true;
596 g_audio_state = AUDIO_STATE_READY;
597 SLOG(LOG_INFO, tts_tag(), "[Player] Stop player thread by pause");
599 /* Request prepare */
600 ret = audio_out_unprepare(g_audio_h);
601 if (AUDIO_IO_ERROR_NONE != ret) {
602 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
604 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio");
606 /* unset volume policy, volume will be 100% */
607 __unset_policy_for_playing();
612 if (NULL == g_playing_info && APP_STATE_READY == player->state) {
614 g_audio_state = AUDIO_STATE_READY;
615 SLOG(LOG_DEBUG, tts_tag(), "[Player] Stop player thread");
617 /* Request prepare */
618 ret = audio_out_unprepare(g_audio_h);
619 if (AUDIO_IO_ERROR_NONE != ret) {
620 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
622 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio");
625 ttsd_data_clear_sound_data(&sound_data);
626 /* unset volume policy, volume will be 100% */
627 __unset_policy_for_playing();
631 if ((APP_STATE_PLAYING == player->state || APP_STATE_PAUSED == player->state) &&
632 (TTSE_RESULT_EVENT_FINISH == sound_data->event)) {
633 /* send utterence finish signal */
634 int pid = ttsd_data_get_pid(player->uid);
637 SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid");
638 /* unset volume policy, volume will be 100% */
639 __unset_policy_for_playing();
641 ttsd_data_clear_sound_data(&sound_data);
645 if (0 != ttsdc_send_utt_finish_message(pid, player->uid, sound_data->utt_id)) {
646 SLOG(LOG_ERROR, tts_tag(), "[Send ERROR] Fail to send Utterance Completed Signal : pid(%d), uid(%d), uttid(%d)",
647 pid, player->uid, sound_data->utt_id);
648 /* unset volume policy, volume will be 100% */
649 __unset_policy_for_playing();
651 ttsd_data_clear_sound_data(&sound_data);
655 SLOG(LOG_INFO, tts_tag(), "[Player] Finish utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id);
658 ttsd_data_clear_sound_data(&sound_data);
660 if (NULL == g_playing_info) {
661 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Current player is NULL");
662 g_audio_state = AUDIO_STATE_READY;
663 ret = audio_out_unprepare(g_audio_h);
664 if (AUDIO_IO_ERROR_NONE != ret) {
665 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
667 /* unset volume policy, volume will be 100% */
668 __unset_policy_for_playing();
678 int ttsd_player_init()
680 g_playing_info = NULL;
681 g_audio_state = AUDIO_STATE_NONE;
686 ecore_thread_max_set(1);
690 if (0 == access(FOCUS_SERVER_READY, F_OK)) {
691 SLOG(LOG_ERROR, tts_tag(), "[Player SUCCESS] focus server is available");
695 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] focus server is not available");
700 ret = sound_manager_create_stream_information(SOUND_STREAM_TYPE_VOICE_INFORMATION, __player_focus_state_cb, NULL, &g_stream_info_h);
701 if (SOUND_MANAGER_ERROR_NONE != ret) {
702 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to create stream info");
705 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Create stream info");
708 /* add sound focus state watch callback */
709 ret = sound_manager_add_focus_state_watch_cb(SOUND_STREAM_FOCUS_FOR_PLAYBACK, __player_focus_state_watch_cb, NULL, &g_focus_watch_id);
710 if (SOUND_MANAGER_ERROR_NONE != ret) {
711 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to add sound focus watch callback");
712 sound_manager_destroy_stream_information(g_stream_info_h);
715 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Add sound focus watch callback");
718 ecore_thread_max_set(1);
720 ret = __create_audio_out(TTSE_AUDIO_TYPE_RAW_S16, 16000);
722 sound_manager_destroy_stream_information(g_stream_info_h);
723 sound_manager_remove_focus_state_watch_cb(g_focus_watch_id);
727 g_player_init = true;
732 int ttsd_player_release(void)
734 if (false == g_player_init) {
735 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
736 return TTSD_ERROR_OPERATION_FAILED;
741 SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] @@@@@");
742 SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] Active thread count : %d", ecore_thread_active_get());
743 SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] @@@@@");
745 /* The thread should be released */
746 int thread_count = ecore_thread_active_get();
748 while (0 < thread_count) {
753 SLOG(LOG_WARN, tts_tag(), "[Player WARNING!!] Thread is blocked. Player release continue.");
757 thread_count = ecore_thread_active_get();
760 SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] Thread is released");
762 ret = __destroy_audio_out();
766 ret = sound_manager_destroy_stream_information(g_stream_info_h);
767 if (SOUND_MANAGER_ERROR_NONE != ret) {
768 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to destroy stream info");
770 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Destroy stream info");
773 /* remove focus state watch callback */
774 ret = sound_manager_remove_focus_state_watch_cb(g_focus_watch_id);
775 if (SOUND_MANAGER_ERROR_NONE != ret) {
776 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to remove the focus state watch cb");
778 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Remove the focus state watch cb");
781 /* clear g_player_list */
782 g_playing_info = NULL;
783 g_player_init = false;
788 int ttsd_player_create_instance(int uid)
790 if (false == g_player_init) {
791 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
795 /* Check uid is duplicated */
796 if (NULL != __player_get_item(uid)) {
797 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is already registered", uid);
801 player_s* new_client = (player_s*)calloc(1, sizeof(player_s));
802 if (NULL == new_client) {
803 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to allocate memory");
804 return TTSE_ERROR_OUT_OF_MEMORY;
807 new_client->uid = uid;
808 new_client->event = TTSE_RESULT_EVENT_FINISH;
809 new_client->state = APP_STATE_READY;
810 new_client->is_paused_data = false;
812 new_client->paused_data = NULL;
814 SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Player] Create player : uid(%d)", uid);
816 g_player_list = g_list_append(g_player_list, new_client);
821 int ttsd_player_destroy_instance(int uid)
823 if (false == g_player_init) {
824 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
829 current = __player_get_item(uid);
830 if (NULL == current) {
831 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
835 if (NULL != g_playing_info) {
836 if (uid == g_playing_info->uid) {
837 g_playing_info = NULL;
842 player_s *data = NULL;
844 if (0 < g_list_length(g_player_list)) {
845 /* Get a first item */
846 iter = g_list_first(g_player_list);
848 while (NULL != iter) {
849 /* Get handle data from list */
850 data = (player_s*)iter->data;
854 if (uid == data->uid) {
855 g_player_list = g_list_remove_link(g_player_list, iter);
863 iter = g_list_next(iter);
867 SLOG(LOG_DEBUG, tts_tag(), "[PLAYER Success] Destroy instance");
872 int ttsd_player_play(int uid)
874 if (false == g_player_init) {
875 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
879 if (NULL != g_playing_info) {
880 if (uid == g_playing_info->uid) {
881 SLOG(LOG_DEBUG, tts_tag(), "[Player] uid(%d) has already played", g_playing_info->uid);
884 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] stop old player (%d)", g_playing_info->uid);
885 ttsd_player_stop(g_playing_info->uid);
889 SLOG(LOG_DEBUG, tts_tag(), "[Player] start play : uid(%d)", uid);
891 /* Check sound queue size */
892 if (0 == ttsd_data_get_sound_data_size(uid)) {
893 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] A sound queue of current player(%d) is empty", uid);
899 current = __player_get_item(uid);
900 if (NULL == current) {
901 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
905 current->state = APP_STATE_PLAYING;
907 g_playing_info = current;
909 SLOG(LOG_INFO, tts_tag(), "[Player DEBUG] Active thread count : %d", ecore_thread_active_get());
911 if (0 < ttsd_data_get_sound_data_size(current->uid)) {
912 SLOG(LOG_INFO, tts_tag(), "[Player] Run thread");
913 ecore_thread_run(__play_thread, __end_play_thread, NULL, NULL);
919 int ttsd_player_stop(int uid)
921 if (false == g_player_init) {
922 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
928 current = __player_get_item(uid);
929 if (NULL == current) {
930 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
934 /* check whether uid is current playing or not */
935 if (NULL != g_playing_info) {
936 if (uid == g_playing_info->uid) {
937 /* release current playing info */
938 g_playing_info = NULL;
941 SLOG(LOG_DEBUG, tts_tag(), "[Player] No current playing");
944 if (true == current->is_paused_data) {
945 if (NULL != current->paused_data) {
946 if (NULL != current->paused_data->data) {
947 free(current->paused_data->data);
948 current->paused_data->data = NULL;
951 free(current->paused_data);
952 current->paused_data = NULL;
956 current->event = TTSE_RESULT_EVENT_FINISH;
957 current->state = APP_STATE_READY;
958 current->is_paused_data = false;
961 if (NULL == g_playing_info) {
962 SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
963 SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
964 SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
966 /* The thread should be released */
967 int thread_count = ecore_thread_active_get();
969 while (0 < thread_count) {
974 SLOG(LOG_WARN, tts_tag(), "[Player WARNING!!] Thread is blocked. Player release continue.");
978 thread_count = ecore_thread_active_get();
981 SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
982 SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
983 SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
986 SLOG(LOG_INFO, tts_tag(), "[Player SUCCESS] Stop player : uid(%d)", uid);
991 int ttsd_player_clear(int uid)
993 if (false == g_player_init) {
994 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
1000 current = __player_get_item(uid);
1001 if (NULL == current) {
1002 SECURE_SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
1006 if (true == current->is_paused_data) {
1007 if (NULL != current->paused_data) {
1008 if (NULL != current->paused_data->data) {
1009 free(current->paused_data->data);
1010 current->paused_data->data = NULL;
1013 free(current->paused_data);
1014 current->paused_data = NULL;
1018 current->event = TTSE_RESULT_EVENT_FINISH;
1019 current->state = APP_STATE_READY;
1020 current->is_paused_data = false;
1023 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Clear player : uid(%d)", uid);
1028 int ttsd_player_pause(int uid)
1030 SLOG(LOG_DEBUG, tts_tag(), "[Player] pause player : uid(%d)", uid);
1032 if (false == g_player_init) {
1033 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
1039 current = __player_get_item(uid);
1040 if (NULL == current) {
1041 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] ttsd_player_pause() : uid(%d) is not valid", uid);
1045 /* check whether uid is current playing or not */
1046 if (NULL != g_playing_info) {
1047 if (uid == g_playing_info->uid) {
1048 /* release current playing info */
1049 g_playing_info = NULL;
1055 current->state = APP_STATE_PAUSED;
1057 SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
1058 SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
1059 SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
1061 /* The thread should be released */
1062 int thread_count = ecore_thread_active_get();
1064 while (0 < thread_count) {
1069 SLOG(LOG_WARN, tts_tag(), "[Player WARNING!!] Thread is blocked. Player release continue.");
1073 thread_count = ecore_thread_active_get();
1076 SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
1077 SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
1078 SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
1080 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Pause player : uid(%d)", uid);
1085 int ttsd_player_resume(int uid)
1087 SLOG(LOG_DEBUG, tts_tag(), "[Player] Resume player : uid(%d)", uid);
1089 if (false == g_player_init) {
1090 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
1096 current = __player_get_item(uid);
1097 if (NULL == current) {
1098 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
1102 /* check current player */
1103 if (NULL != g_playing_info)
1104 g_playing_info = NULL;
1106 current->state = APP_STATE_PLAYING;
1107 g_playing_info = current;
1109 SLOG(LOG_INFO, tts_tag(), "[Player] Resume to run thread");
1110 ecore_thread_run(__play_thread, __end_play_thread, NULL, NULL);
1115 int ttsd_player_all_stop()
1117 if (false == g_player_init) {
1118 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
1122 g_playing_info = NULL;
1125 player_s *data = NULL;
1127 if (0 < g_list_length(g_player_list)) {
1128 /* Get a first item */
1129 iter = g_list_first(g_player_list);
1131 while (NULL != iter) {
1132 /* Get handle data from list */
1133 data = (player_s*)iter->data;
1135 app_tts_state_e state;
1136 if (0 > ttsd_data_get_client_state(data->uid, &state)) {
1137 SLOG(LOG_ERROR, tts_tag(), "[player ERROR] uid(%d) is not valid", data->uid);
1138 ttsd_player_destroy_instance(data->uid);
1139 iter = g_list_next(iter);
1143 if (APP_STATE_PLAYING == state || APP_STATE_PAUSED == state) {
1144 data->event = TTSE_RESULT_EVENT_FINISH;
1145 data->state = APP_STATE_READY;
1147 if (true == data->is_paused_data) {
1148 if (NULL != data->paused_data) {
1149 if (NULL != data->paused_data->data) {
1150 free(data->paused_data->data);
1151 data->paused_data->data = NULL;
1154 free(data->paused_data);
1155 data->paused_data = NULL;
1159 data->is_paused_data = false;
1164 iter = g_list_next(iter);
1168 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] player all stop!!");
1173 int ttsd_player_play_pcm(int uid)
1175 if (false == g_player_init) {
1176 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
1180 if (NULL != g_playing_info) {
1181 if (uid == g_playing_info->uid) {
1182 SLOG(LOG_DEBUG, tts_tag(), "[Player] uid(%d) has already played", g_playing_info->uid);
1185 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] stop old player (%d)", g_playing_info->uid);
1186 ttsd_player_stop(g_playing_info->uid);
1190 SLOG(LOG_DEBUG, tts_tag(), "[Player] start play : uid(%d)", uid);
1192 /* Check sound queue size */
1193 if (0 == ttsd_data_get_sound_data_size(uid)) {
1194 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] A sound queue of current player(%d) is empty", uid);
1199 current = __player_get_item(uid);
1200 if (NULL == current) {
1201 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
1205 current->state = APP_STATE_PLAYING;
1207 g_playing_info = current;
1209 SLOG(LOG_INFO, tts_tag(), "[Player DEBUG] Active thread count : %d", ecore_thread_active_get());
1211 if (0 <= ttsd_data_get_sound_data_size(current->uid)) {
1212 SLOG(LOG_INFO, tts_tag(), "[Player] Run thread");
1213 ecore_thread_run(__play_thread, __end_play_thread, NULL, NULL);