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"
25 * Internal data structure
35 int uid; /** client id */
36 app_state_e state; /** client state */
38 /* Current utterance information */
39 ttse_result_event_e event; /** event of last utterance */
43 sound_data_s* paused_data;
46 #define SOUND_BUFFER_LENGTH 2048
47 #define FOCUS_SERVER_READY "/tmp/.sound_server_ready"
49 /** player init info */
50 static bool g_player_init = false;
53 static GList *g_player_list;
55 /** current player information */
56 static player_s* g_playing_info;
59 static audio_state_e g_audio_state;
61 static ttse_audio_type_e g_audio_type;
63 static int g_sampling_rate;
65 static audio_out_h g_audio_h;
67 static sound_stream_info_h g_stream_info_h;
73 player_s* __player_get_item(int uid)
76 player_s *data = NULL;
78 if (0 < g_list_length(g_player_list)) {
79 /* Get a first item */
80 iter = g_list_first(g_player_list);
82 while (NULL != iter) {
83 /* Get handle data from list */
84 data = (player_s*)iter->data;
91 iter = g_list_next(iter);
98 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,
99 sound_stream_focus_change_reason_e reason_for_change, int sound_behavior, const char *extra_info, void *user_data)
101 SLOG(LOG_DEBUG, tts_tag(), "===== Focus state changed cb");
103 if (stream_info != g_stream_info_h) {
104 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Invalid stream info handle");
107 SLOG(LOG_WARN, tts_tag(), "[Player] focus state changed to (%d) with reason(%d)", (int)focus_state, (int)reason_for_change);
109 if (AUDIO_STATE_PLAY == g_audio_state && focus_mask == SOUND_STREAM_FOCUS_FOR_PLAYBACK && SOUND_STREAM_FOCUS_STATE_RELEASED == focus_state) {
110 if (TTSD_MODE_DEFAULT == ttsd_get_mode()) {
111 g_audio_state = AUDIO_STATE_READY;
113 if (NULL == g_playing_info) {
114 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] No current player");
118 if (APP_STATE_PLAYING == g_playing_info->state) {
119 int uid = g_playing_info->uid;
121 if (0 != ttsd_player_pause(uid)) {
122 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to pause the player");
126 g_playing_info->state = APP_STATE_PAUSED;
127 ttsd_data_set_client_state(uid, APP_STATE_PAUSED);
128 int pid = ttsd_data_get_pid(uid);
129 /* send message to client about changing state */
130 ttsdc_send_set_state_message(pid, uid, APP_STATE_PAUSED);
133 SLOG(LOG_DEBUG, tts_tag(), "[Player] Ignore focus state cb - mode(%d)", ttsd_get_mode());
137 SLOG(LOG_DEBUG, tts_tag(), "=====");
138 SLOG(LOG_DEBUG, tts_tag(), "");
143 static int __create_audio_out(ttse_audio_type_e type, int rate)
146 audio_sample_type_e sample_type;
148 if (TTSE_AUDIO_TYPE_RAW_S16 == type) {
149 sample_type = AUDIO_SAMPLE_TYPE_S16_LE;
151 sample_type = AUDIO_SAMPLE_TYPE_U8;
154 ret = audio_out_create_new(rate, AUDIO_CHANNEL_MONO, sample_type, &g_audio_h);
155 if (AUDIO_IO_ERROR_NONE != ret) {
156 g_audio_state = AUDIO_STATE_NONE;
158 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to create audio");
161 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Create audio");
165 g_sampling_rate = rate;
167 g_audio_state = AUDIO_STATE_READY;
172 static int __destroy_audio_out()
174 if (NULL == g_audio_h) {
175 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Current handle is not valid");
180 ret = audio_out_destroy(g_audio_h);
181 if (AUDIO_IO_ERROR_NONE != ret) {
182 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to destroy audio");
185 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Destroy audio");
191 g_audio_state = AUDIO_STATE_NONE;
197 static void __end_play_thread(void *data, Ecore_Thread *thread)
199 SLOG(LOG_ERROR, tts_tag(), "===== End thread");
202 static void __set_policy_for_playing(int volume)
204 /* Set stream info */
206 if (TTSD_MODE_DEFAULT == ttsd_get_mode()) {
207 ret = sound_manager_acquire_focus(g_stream_info_h, SOUND_STREAM_FOCUS_FOR_PLAYBACK, SOUND_BEHAVIOR_NONE, NULL);
208 if (SOUND_MANAGER_ERROR_NONE != ret) {
209 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to acquire focus");
212 ret = audio_out_set_sound_stream_info(g_audio_h, g_stream_info_h);
213 if (AUDIO_IO_ERROR_NONE != ret) {
214 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to set stream info");
220 static void __unset_policy_for_playing()
223 /* Unset stream info */
224 if (TTSD_MODE_DEFAULT == ttsd_get_mode()) {
225 sound_stream_focus_state_e state_for_playing = SOUND_STREAM_FOCUS_STATE_ACQUIRED;
226 ret = sound_manager_get_focus_state(g_stream_info_h, &state_for_playing, NULL);
227 if (SOUND_MANAGER_ERROR_NONE != ret) {
228 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to get focus state: %d", ret);
231 if (SOUND_STREAM_FOCUS_STATE_ACQUIRED == state_for_playing) {
232 ret = sound_manager_release_focus(g_stream_info_h, SOUND_STREAM_FOCUS_FOR_PLAYBACK, SOUND_BEHAVIOR_NONE, NULL);
233 if (SOUND_MANAGER_ERROR_NONE != ret) {
234 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to release focus");
242 static void __play_thread(void *data, Ecore_Thread *thread)
244 SLOG(LOG_DEBUG, tts_tag(), "===== Start thread");
246 if (NULL == g_playing_info) {
247 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] No current player");
251 player_s* player = g_playing_info;
252 sound_data_s* sound_data = NULL;
255 int len = SOUND_BUFFER_LENGTH;
258 /* set volume policy as 40% */
259 __set_policy_for_playing(40);
261 if (true == player->is_paused_data) {
263 sound_data = player->paused_data;
264 player->paused_data = NULL;
268 player->is_paused_data = false;
271 if (NULL == sound_data) {
272 /* Request unprepare */
273 ret = audio_out_unprepare(g_audio_h);
274 if (AUDIO_IO_ERROR_NONE != ret) {
275 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
277 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio");
280 g_audio_state = AUDIO_STATE_READY;
282 /* unset volume policy, volume will be 100% */
283 __unset_policy_for_playing();
286 SLOG(LOG_INFO, tts_tag(), "[Player] Sound info : id(%d) data(%p) size(%d) audiotype(%d) rate(%d) event(%d)",
287 sound_data->utt_id, sound_data->data, sound_data->data_size, sound_data->audio_type, sound_data->rate, sound_data->event);
290 ret = ttsd_data_get_sound_data(player->uid, &sound_data);
291 if (0 != ret || NULL == sound_data) {
293 SLOG(LOG_DEBUG, tts_tag(), "[Player] No sound data. Waiting mode");
294 /* release audio & recover session */
295 ret = audio_out_unprepare(g_audio_h);
296 if (AUDIO_IO_ERROR_NONE != ret) {
297 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
299 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio");
301 g_audio_state = AUDIO_STATE_READY;
303 /* unset volume policy, volume will be 100% */
304 __unset_policy_for_playing();
306 /* wait for new audio data come */
309 if (NULL == g_playing_info) {
310 /* current playing uid is replaced */
311 SLOG(LOG_DEBUG, tts_tag(), "[Player] Finish thread");
313 } else if (0 < ttsd_data_get_sound_data_size(player->uid)) {
314 /* new audio data come */
315 SLOG(LOG_DEBUG, tts_tag(), "[Player] Resume thread");
320 /* set volume policy as 40%, when resume play thread*/
321 __set_policy_for_playing(40);
323 /* resume play thread */
324 player->state = APP_STATE_PLAYING;
328 /* If wdata's event is 'start', current wdata is first data of engine for synthesis.
329 * If wdata's event is 'finish', player should check previous event to know whether this wdata is first or not.
330 * When previous wdata's event is 'finish' and current wdata's event is 'finish',
331 * the player should send utt started event.
333 if (TTSE_RESULT_EVENT_START == sound_data->event ||
334 (TTSE_RESULT_EVENT_FINISH == player->event && TTSE_RESULT_EVENT_FINISH == sound_data->event)) {
335 int pid = ttsd_data_get_pid(player->uid);
338 SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid");
339 /* unset volume policy, volume will be 100% */
340 __unset_policy_for_playing();
344 if (0 != ttsdc_send_utt_start_message(pid, player->uid, sound_data->utt_id)) {
345 SLOG(LOG_ERROR, tts_tag(), "[Send ERROR] Fail to send Utterance Start Signal : pid(%d), uid(%d), uttid(%d)",
346 pid, player->uid, sound_data->utt_id);
348 SLOG(LOG_DEBUG, tts_tag(), "[Player] Start utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id);
351 /* Save last event to check utterance start */
352 player->event = sound_data->event;
355 if (NULL == sound_data->data || 0 >= sound_data->data_size) {
356 if (TTSE_RESULT_EVENT_FINISH == sound_data->event) {
357 SLOG(LOG_DEBUG, tts_tag(), "No sound data");
358 /* send utterence finish signal */
359 int pid = ttsd_data_get_pid(player->uid);
362 SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid");
363 /* unset volume policy, volume will be 100% */
364 __unset_policy_for_playing();
367 if (0 != ttsdc_send_utt_finish_message(pid, player->uid, sound_data->utt_id)) {
368 SLOG(LOG_ERROR, tts_tag(), "[Send ERROR] Fail to send Utterance Completed Signal : pid(%d), uid(%d), uttid(%d)",
369 pid, player->uid, sound_data->utt_id);
372 SLOG(LOG_DEBUG, tts_tag(), "[Player] Finish utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id);
377 if (g_sampling_rate != sound_data->rate || g_audio_type != sound_data->audio_type) {
378 SLOG(LOG_DEBUG, tts_tag(), "[Player] Change audio handle : org type(%d) org rate(%d)", g_audio_type, g_sampling_rate);
379 if (NULL != g_audio_h) {
380 __destroy_audio_out();
383 if (0 > __create_audio_out(sound_data->audio_type, sound_data->rate)) {
384 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to create audio out");
385 /* unset volume policy, volume will be 100% */
386 __unset_policy_for_playing();
389 __set_policy_for_playing(40);
392 while (APP_STATE_PLAYING == player->state || APP_STATE_PAUSED == player->state) {
393 if ((unsigned int)idx >= sound_data->data_size)
396 if ((unsigned int)idx + SOUND_BUFFER_LENGTH > sound_data->data_size) {
397 len = sound_data->data_size - idx;
399 len = SOUND_BUFFER_LENGTH;
402 if (AUDIO_STATE_READY == g_audio_state) {
403 /* Request prepare */
404 ret = audio_out_prepare(g_audio_h);
405 if (AUDIO_IO_ERROR_NONE != ret) {
406 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to prepare audio : %d", ret);
407 g_playing_info = NULL;
408 /* unset volume policy, volume will be 100% */
409 __unset_policy_for_playing();
412 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Prepare audio");
413 g_audio_state = AUDIO_STATE_PLAY;
416 char* temp_data = sound_data->data;
417 ret = audio_out_write(g_audio_h, &temp_data[idx], len);
419 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to audio write - %d", ret);
424 if (NULL == g_playing_info && APP_STATE_PAUSED != player->state) {
425 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Current player is NULL");
426 g_audio_state = AUDIO_STATE_READY;
427 ret = audio_out_unprepare(g_audio_h);
428 if (AUDIO_IO_ERROR_NONE != ret) {
429 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
431 /* unset volume policy, volume will be 100% */
432 __unset_policy_for_playing();
434 if (NULL != sound_data) {
435 if (NULL != sound_data->data) {
436 free(sound_data->data);
437 sound_data->data = NULL;
447 if (APP_STATE_PAUSED == player->state) {
449 player->paused_data = sound_data;
451 player->is_paused_data = true;
454 g_audio_state = AUDIO_STATE_READY;
455 SLOG(LOG_DEBUG, tts_tag(), "[Player] Stop player thread by pause");
457 /* Request prepare */
458 ret = audio_out_unprepare(g_audio_h);
459 if (AUDIO_IO_ERROR_NONE != ret) {
460 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
462 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio");
464 /* unset volume policy, volume will be 100% */
465 __unset_policy_for_playing();
470 if (NULL == g_playing_info && APP_STATE_READY == player->state) {
472 g_audio_state = AUDIO_STATE_READY;
473 SLOG(LOG_DEBUG, tts_tag(), "[Player] Stop player thread");
475 /* Request prepare */
476 ret = audio_out_unprepare(g_audio_h);
477 if (AUDIO_IO_ERROR_NONE != ret) {
478 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
480 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio");
483 if (NULL != sound_data) {
484 if (NULL != sound_data->data) {
485 free(sound_data->data);
486 sound_data->data = NULL;
492 /* unset volume policy, volume will be 100% */
493 __unset_policy_for_playing();
497 if ((APP_STATE_PLAYING == player->state || APP_STATE_PAUSED == player->state) &&
498 (TTSE_RESULT_EVENT_FINISH == sound_data->event)) {
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();
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);
512 /* unset volume policy, volume will be 100% */
513 __unset_policy_for_playing();
517 SLOG(LOG_DEBUG, tts_tag(), "[Player] Finish utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id);
520 if (NULL != sound_data) {
521 if (NULL != sound_data->data) {
522 free(sound_data->data);
523 sound_data->data = NULL;
530 if (NULL == g_playing_info) {
531 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Current player is NULL");
532 g_audio_state = AUDIO_STATE_READY;
533 ret = audio_out_unprepare(g_audio_h);
534 if (AUDIO_IO_ERROR_NONE != ret) {
535 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
537 /* unset volume policy, volume will be 100% */
538 __unset_policy_for_playing();
548 int ttsd_player_init()
550 g_playing_info = NULL;
551 g_audio_state = AUDIO_STATE_NONE;
556 ecore_thread_max_set(1);
560 if (0 == access(FOCUS_SERVER_READY, F_OK)) {
561 SLOG(LOG_ERROR, tts_tag(), "[Player SUCCESS] focus server is available");
565 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] focus server is not available");
570 ret = sound_manager_create_stream_information(SOUND_STREAM_TYPE_VOICE_INFORMATION, __player_focus_state_cb, NULL, &g_stream_info_h);
571 if (SOUND_MANAGER_ERROR_NONE != ret) {
572 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to create stream info");
575 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Create stream info");
578 ecore_thread_max_set(1);
580 ret = __create_audio_out(TTSE_AUDIO_TYPE_RAW_S16, 16000);
584 g_player_init = true;
589 int ttsd_player_release(void)
591 if (false == g_player_init) {
592 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
593 return TTSD_ERROR_OPERATION_FAILED;
598 SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] ==========================");
599 SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] Active thread count : %d", ecore_thread_active_get());
600 SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] ==========================");
602 /* The thread should be released */
603 int thread_count = ecore_thread_active_get();
605 while (0 < thread_count) {
610 SLOG(LOG_WARN, tts_tag(), "[Player WARNING!!] Thread is blocked. Player release continue.");
614 thread_count = ecore_thread_active_get();
617 SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] Thread is released");
619 ret = __destroy_audio_out();
623 ret = sound_manager_destroy_stream_information(g_stream_info_h);
624 if (SOUND_MANAGER_ERROR_NONE != ret) {
625 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to destroy stream info");
627 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Destroy stream info");
630 /* clear g_player_list */
631 g_playing_info = NULL;
632 g_player_init = false;
637 int ttsd_player_create_instance(int uid)
639 if (false == g_player_init) {
640 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
644 /* Check uid is duplicated */
645 if (NULL != __player_get_item(uid)) {
646 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is already registered", uid);
650 player_s* new_client = (player_s*)calloc(1, sizeof(player_s));
651 if (NULL == new_client) {
652 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to allocate memory");
653 return TTSE_ERROR_OUT_OF_MEMORY;
656 new_client->uid = uid;
657 new_client->event = TTSE_RESULT_EVENT_FINISH;
658 new_client->state = APP_STATE_READY;
659 new_client->is_paused_data = false;
661 new_client->paused_data = NULL;
663 SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Player] Create player : uid(%d)", uid);
665 g_player_list = g_list_append(g_player_list, new_client);
670 int ttsd_player_destroy_instance(int uid)
672 if (false == g_player_init) {
673 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
678 current = __player_get_item(uid);
679 if (NULL == current) {
680 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
684 if (NULL != g_playing_info) {
685 if (uid == g_playing_info->uid) {
686 g_playing_info = NULL;
691 player_s *data = NULL;
693 if (0 < g_list_length(g_player_list)) {
694 /* Get a first item */
695 iter = g_list_first(g_player_list);
697 while (NULL != iter) {
698 /* Get handle data from list */
699 data = (player_s*)iter->data;
703 if (uid == data->uid) {
704 g_player_list = g_list_remove_link(g_player_list, iter);
712 iter = g_list_next(iter);
716 SLOG(LOG_DEBUG, tts_tag(), "[PLAYER Success] Destroy instance");
721 int ttsd_player_play(int uid)
723 if (false == g_player_init) {
724 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
728 if (NULL != g_playing_info) {
729 if (uid == g_playing_info->uid) {
730 SLOG(LOG_DEBUG, tts_tag(), "[Player] uid(%d) has already played", g_playing_info->uid);
733 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] stop old player (%d)", g_playing_info->uid);
734 ttsd_player_stop(g_playing_info->uid);
738 SLOG(LOG_DEBUG, tts_tag(), "[Player] start play : uid(%d)", uid);
740 /* Check sound queue size */
741 if (0 == ttsd_data_get_sound_data_size(uid)) {
742 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] A sound queue of current player(%d) is empty", uid);
748 current = __player_get_item(uid);
749 if (NULL == current) {
750 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
754 current->state = APP_STATE_PLAYING;
756 g_playing_info = current;
758 SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] Active thread count : %d", ecore_thread_active_get());
760 if (0 < ttsd_data_get_sound_data_size(current->uid)) {
761 SLOG(LOG_DEBUG, tts_tag(), "[Player] Run thread");
762 ecore_thread_run(__play_thread, __end_play_thread, NULL, NULL);
768 int ttsd_player_stop(int uid)
770 if (false == g_player_init) {
771 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
777 current = __player_get_item(uid);
778 if (NULL == current) {
779 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
783 /* check whether uid is current playing or not */
784 if (NULL != g_playing_info) {
785 if (uid == g_playing_info->uid) {
786 /* release current playing info */
787 g_playing_info = NULL;
790 SLOG(LOG_DEBUG, tts_tag(), "[Player] No current playing");
793 if (true == current->is_paused_data) {
794 if (NULL != current->paused_data) {
795 if (NULL != current->paused_data->data) {
796 free(current->paused_data->data);
797 current->paused_data->data = NULL;
800 free(current->paused_data);
801 current->paused_data = NULL;
805 current->event = TTSE_RESULT_EVENT_FINISH;
806 current->state = APP_STATE_READY;
807 current->is_paused_data = false;
810 if (NULL == g_playing_info) {
811 SLOG(LOG_DEBUG, tts_tag(), "[Player] ==========================");
812 SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
813 SLOG(LOG_DEBUG, tts_tag(), "[Player] ==========================");
815 /* The thread should be released */
816 int thread_count = ecore_thread_active_get();
818 while (0 < thread_count) {
823 SLOG(LOG_WARN, tts_tag(), "[Player WARNING!!] Thread is blocked. Player release continue.");
827 thread_count = ecore_thread_active_get();
830 SLOG(LOG_DEBUG, tts_tag(), "[Player] ==========================");
831 SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
832 SLOG(LOG_DEBUG, tts_tag(), "[Player] ==========================");
835 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Stop player : uid(%d)", uid);
840 int ttsd_player_clear(int uid)
842 if (false == g_player_init) {
843 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
849 current = __player_get_item(uid);
850 if (NULL == current) {
851 SECURE_SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
855 if (true == current->is_paused_data) {
856 if (NULL != current->paused_data) {
857 if (NULL != current->paused_data->data) {
858 free(current->paused_data->data);
859 current->paused_data->data = NULL;
862 free(current->paused_data);
863 current->paused_data = NULL;
867 current->event = TTSE_RESULT_EVENT_FINISH;
868 current->state = APP_STATE_READY;
869 current->is_paused_data = false;
872 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Clear player : uid(%d)", uid);
877 int ttsd_player_pause(int uid)
879 SLOG(LOG_DEBUG, tts_tag(), "[Player] pause player : uid(%d)", uid);
881 if (false == g_player_init) {
882 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
888 current = __player_get_item(uid);
889 if (NULL == current) {
890 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] ttsd_player_pause() : uid(%d) is not valid", uid);
894 /* check whether uid is current playing or not */
895 if (NULL != g_playing_info) {
896 if (uid == g_playing_info->uid) {
897 /* release current playing info */
898 g_playing_info = NULL;
904 current->state = APP_STATE_PAUSED;
906 SLOG(LOG_DEBUG, tts_tag(), "[Player] ==========================");
907 SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
908 SLOG(LOG_DEBUG, tts_tag(), "[Player] ==========================");
910 /* The thread should be released */
911 int thread_count = ecore_thread_active_get();
913 while (0 < thread_count) {
918 SLOG(LOG_WARN, tts_tag(), "[Player WARNING!!] Thread is blocked. Player release continue.");
922 thread_count = ecore_thread_active_get();
925 SLOG(LOG_DEBUG, tts_tag(), "[Player] ==========================");
926 SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
927 SLOG(LOG_DEBUG, tts_tag(), "[Player] ==========================");
929 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Pause player : uid(%d)", uid);
934 int ttsd_player_resume(int uid)
936 SLOG(LOG_DEBUG, tts_tag(), "[Player] Resume player : uid(%d)", uid);
938 if (false == g_player_init) {
939 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
945 current = __player_get_item(uid);
946 if (NULL == current) {
947 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
951 /* check current player */
952 if (NULL != g_playing_info)
953 g_playing_info = NULL;
955 current->state = APP_STATE_PLAYING;
956 g_playing_info = current;
958 SLOG(LOG_DEBUG, tts_tag(), "[Player] Run thread");
959 ecore_thread_run(__play_thread, __end_play_thread, NULL, NULL);
964 int ttsd_player_all_stop()
966 if (false == g_player_init) {
967 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
971 g_playing_info = NULL;
974 player_s *data = NULL;
976 if (0 < g_list_length(g_player_list)) {
977 /* Get a first item */
978 iter = g_list_first(g_player_list);
980 while (NULL != iter) {
981 /* Get handle data from list */
982 data = (player_s*)iter->data;
985 if (0 > ttsd_data_get_client_state(data->uid, &state)) {
986 SLOG(LOG_ERROR, tts_tag(), "[player ERROR] uid(%d) is not valid", data->uid);
987 ttsd_player_destroy_instance(data->uid);
988 iter = g_list_next(iter);
992 if (APP_STATE_PLAYING == state || APP_STATE_PAUSED == state) {
993 data->event = TTSE_RESULT_EVENT_FINISH;
994 data->state = APP_STATE_READY;
996 if (true == data->is_paused_data) {
997 if (NULL != data->paused_data) {
998 if (NULL != data->paused_data->data) {
999 free(data->paused_data->data);
1000 data->paused_data->data = NULL;
1003 free(data->paused_data);
1004 data->paused_data = NULL;
1008 data->is_paused_data = false;
1013 iter = g_list_next(iter);
1017 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] player all stop!!");