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_INFO, 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_INFO, tts_tag(), "[Player] Resume thread");
320 SLOG(LOG_INFO, tts_tag(), "[Player] Finish to wait for new audio data come");
322 /* set volume policy as 40%, when resume play thread*/
323 __set_policy_for_playing(40);
325 /* resume play thread */
326 player->state = APP_STATE_PLAYING;
330 /* If wdata's event is 'start', current wdata is first data of engine for synthesis.
331 * If wdata's event is 'finish', player should check previous event to know whether this wdata is first or not.
332 * When previous wdata's event is 'finish' and current wdata's event is 'finish',
333 * the player should send utt started event.
335 if (TTSE_RESULT_EVENT_START == sound_data->event ||
336 (TTSE_RESULT_EVENT_FINISH == player->event && TTSE_RESULT_EVENT_FINISH == sound_data->event)) {
337 int pid = ttsd_data_get_pid(player->uid);
340 SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid");
341 /* unset volume policy, volume will be 100% */
342 __unset_policy_for_playing();
344 if (NULL != sound_data->data) {
345 free(sound_data->data);
346 sound_data->data = NULL;
353 if (0 != ttsdc_send_utt_start_message(pid, player->uid, sound_data->utt_id)) {
354 SLOG(LOG_ERROR, tts_tag(), "[Send ERROR] Fail to send Utterance Start Signal : pid(%d), uid(%d), uttid(%d)",
355 pid, player->uid, sound_data->utt_id);
357 SLOG(LOG_INFO, tts_tag(), "[Player] Start utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id);
360 /* Save last event to check utterance start */
361 player->event = sound_data->event;
364 if (NULL == sound_data->data || 0 >= sound_data->data_size) {
365 if (TTSE_RESULT_EVENT_FINISH == sound_data->event) {
366 SLOG(LOG_DEBUG, tts_tag(), "No sound data");
367 /* send utterence finish signal */
368 int pid = ttsd_data_get_pid(player->uid);
371 SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid");
372 /* unset volume policy, volume will be 100% */
373 __unset_policy_for_playing();
374 if (NULL != sound_data->data) {
375 free(sound_data->data);
376 sound_data->data = NULL;
382 if (0 != ttsdc_send_utt_finish_message(pid, player->uid, sound_data->utt_id)) {
383 SLOG(LOG_ERROR, tts_tag(), "[Send ERROR] Fail to send Utterance Completed Signal : pid(%d), uid(%d), uttid(%d)",
384 pid, player->uid, sound_data->utt_id);
387 SLOG(LOG_INFO, tts_tag(), "[Player] Finish utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id);
388 if (NULL != sound_data->data) {
389 free(sound_data->data);
390 sound_data->data = NULL;
398 if (g_sampling_rate != sound_data->rate || g_audio_type != sound_data->audio_type) {
399 SLOG(LOG_DEBUG, tts_tag(), "[Player] Change audio handle : org type(%d) org rate(%d)", g_audio_type, g_sampling_rate);
400 if (NULL != g_audio_h) {
401 __destroy_audio_out();
404 if (0 > __create_audio_out(sound_data->audio_type, sound_data->rate)) {
405 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to create audio out");
406 /* unset volume policy, volume will be 100% */
407 __unset_policy_for_playing();
409 if (NULL != sound_data->data) {
410 free(sound_data->data);
411 sound_data->data = NULL;
418 __set_policy_for_playing(40);
421 while (APP_STATE_PLAYING == player->state || APP_STATE_PAUSED == player->state) {
422 if ((unsigned int)idx >= sound_data->data_size)
425 if ((unsigned int)idx + SOUND_BUFFER_LENGTH > sound_data->data_size) {
426 len = sound_data->data_size - idx;
428 len = SOUND_BUFFER_LENGTH;
431 if (AUDIO_STATE_READY == g_audio_state) {
432 /* Request prepare */
433 ret = audio_out_prepare(g_audio_h);
434 if (AUDIO_IO_ERROR_NONE != ret) {
435 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to prepare audio : %d", ret);
436 g_playing_info = NULL;
437 /* unset volume policy, volume will be 100% */
438 __unset_policy_for_playing();
440 if (NULL != sound_data->data) {
441 free(sound_data->data);
442 sound_data->data = NULL;
450 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Prepare audio");
451 g_audio_state = AUDIO_STATE_PLAY;
454 char* temp_data = sound_data->data;
455 ret = audio_out_write(g_audio_h, &temp_data[idx], len);
457 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to audio write - %d", ret);
462 if (NULL == g_playing_info && APP_STATE_PAUSED != player->state) {
463 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Current player is NULL");
464 g_audio_state = AUDIO_STATE_READY;
465 ret = audio_out_unprepare(g_audio_h);
466 if (AUDIO_IO_ERROR_NONE != ret) {
467 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
469 /* unset volume policy, volume will be 100% */
470 __unset_policy_for_playing();
472 if (NULL != sound_data) {
473 if (NULL != sound_data->data) {
474 free(sound_data->data);
475 sound_data->data = NULL;
485 if (APP_STATE_PAUSED == player->state) {
487 player->paused_data = sound_data;
489 player->is_paused_data = true;
492 g_audio_state = AUDIO_STATE_READY;
493 SLOG(LOG_INFO, tts_tag(), "[Player] Stop player thread by pause");
495 /* Request prepare */
496 ret = audio_out_unprepare(g_audio_h);
497 if (AUDIO_IO_ERROR_NONE != ret) {
498 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
500 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio");
502 /* unset volume policy, volume will be 100% */
503 __unset_policy_for_playing();
508 if (NULL == g_playing_info && APP_STATE_READY == player->state) {
510 g_audio_state = AUDIO_STATE_READY;
511 SLOG(LOG_DEBUG, tts_tag(), "[Player] Stop player thread");
513 /* Request prepare */
514 ret = audio_out_unprepare(g_audio_h);
515 if (AUDIO_IO_ERROR_NONE != ret) {
516 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
518 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio");
521 if (NULL != sound_data) {
522 if (NULL != sound_data->data) {
523 free(sound_data->data);
524 sound_data->data = NULL;
530 /* unset volume policy, volume will be 100% */
531 __unset_policy_for_playing();
535 if ((APP_STATE_PLAYING == player->state || APP_STATE_PAUSED == player->state) &&
536 (TTSE_RESULT_EVENT_FINISH == sound_data->event)) {
537 /* send utterence finish signal */
538 int pid = ttsd_data_get_pid(player->uid);
541 SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid");
542 /* unset volume policy, volume will be 100% */
543 __unset_policy_for_playing();
544 if (NULL != sound_data->data) {
545 free(sound_data->data);
546 sound_data->data = NULL;
554 if (0 != ttsdc_send_utt_finish_message(pid, player->uid, sound_data->utt_id)) {
555 SLOG(LOG_ERROR, tts_tag(), "[Send ERROR] Fail to send Utterance Completed Signal : pid(%d), uid(%d), uttid(%d)",
556 pid, player->uid, sound_data->utt_id);
557 /* unset volume policy, volume will be 100% */
558 __unset_policy_for_playing();
559 if (NULL != sound_data->data) {
560 free(sound_data->data);
561 sound_data->data = NULL;
569 SLOG(LOG_INFO, tts_tag(), "[Player] Finish utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id);
572 if (NULL != sound_data) {
573 if (NULL != sound_data->data) {
574 free(sound_data->data);
575 sound_data->data = NULL;
582 if (NULL == g_playing_info) {
583 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Current player is NULL");
584 g_audio_state = AUDIO_STATE_READY;
585 ret = audio_out_unprepare(g_audio_h);
586 if (AUDIO_IO_ERROR_NONE != ret) {
587 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
589 /* unset volume policy, volume will be 100% */
590 __unset_policy_for_playing();
600 int ttsd_player_init()
602 g_playing_info = NULL;
603 g_audio_state = AUDIO_STATE_NONE;
608 ecore_thread_max_set(1);
612 if (0 == access(FOCUS_SERVER_READY, F_OK)) {
613 SLOG(LOG_ERROR, tts_tag(), "[Player SUCCESS] focus server is available");
617 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] focus server is not available");
622 ret = sound_manager_create_stream_information(SOUND_STREAM_TYPE_VOICE_INFORMATION, __player_focus_state_cb, NULL, &g_stream_info_h);
623 if (SOUND_MANAGER_ERROR_NONE != ret) {
624 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to create stream info");
627 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Create stream info");
630 ecore_thread_max_set(1);
632 ret = __create_audio_out(TTSE_AUDIO_TYPE_RAW_S16, 16000);
636 g_player_init = true;
641 int ttsd_player_release(void)
643 if (false == g_player_init) {
644 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
645 return TTSD_ERROR_OPERATION_FAILED;
650 SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] ==========================");
651 SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] Active thread count : %d", ecore_thread_active_get());
652 SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] ==========================");
654 /* The thread should be released */
655 int thread_count = ecore_thread_active_get();
657 while (0 < thread_count) {
662 SLOG(LOG_WARN, tts_tag(), "[Player WARNING!!] Thread is blocked. Player release continue.");
666 thread_count = ecore_thread_active_get();
669 SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] Thread is released");
671 ret = __destroy_audio_out();
675 ret = sound_manager_destroy_stream_information(g_stream_info_h);
676 if (SOUND_MANAGER_ERROR_NONE != ret) {
677 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to destroy stream info");
679 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Destroy stream info");
682 /* clear g_player_list */
683 g_playing_info = NULL;
684 g_player_init = false;
689 int ttsd_player_create_instance(int uid)
691 if (false == g_player_init) {
692 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
696 /* Check uid is duplicated */
697 if (NULL != __player_get_item(uid)) {
698 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is already registered", uid);
702 player_s* new_client = (player_s*)calloc(1, sizeof(player_s));
703 if (NULL == new_client) {
704 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to allocate memory");
705 return TTSE_ERROR_OUT_OF_MEMORY;
708 new_client->uid = uid;
709 new_client->event = TTSE_RESULT_EVENT_FINISH;
710 new_client->state = APP_STATE_READY;
711 new_client->is_paused_data = false;
713 new_client->paused_data = NULL;
715 SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Player] Create player : uid(%d)", uid);
717 g_player_list = g_list_append(g_player_list, new_client);
722 int ttsd_player_destroy_instance(int uid)
724 if (false == g_player_init) {
725 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
730 current = __player_get_item(uid);
731 if (NULL == current) {
732 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
736 if (NULL != g_playing_info) {
737 if (uid == g_playing_info->uid) {
738 g_playing_info = NULL;
743 player_s *data = NULL;
745 if (0 < g_list_length(g_player_list)) {
746 /* Get a first item */
747 iter = g_list_first(g_player_list);
749 while (NULL != iter) {
750 /* Get handle data from list */
751 data = (player_s*)iter->data;
755 if (uid == data->uid) {
756 g_player_list = g_list_remove_link(g_player_list, iter);
764 iter = g_list_next(iter);
768 SLOG(LOG_DEBUG, tts_tag(), "[PLAYER Success] Destroy instance");
773 int ttsd_player_play(int uid)
775 if (false == g_player_init) {
776 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
780 if (NULL != g_playing_info) {
781 if (uid == g_playing_info->uid) {
782 SLOG(LOG_DEBUG, tts_tag(), "[Player] uid(%d) has already played", g_playing_info->uid);
785 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] stop old player (%d)", g_playing_info->uid);
786 ttsd_player_stop(g_playing_info->uid);
790 SLOG(LOG_DEBUG, tts_tag(), "[Player] start play : uid(%d)", uid);
792 /* Check sound queue size */
793 if (0 == ttsd_data_get_sound_data_size(uid)) {
794 SLOG(LOG_WARN, tts_tag(), "[Player WARNING] A sound queue of current player(%d) is empty", uid);
800 current = __player_get_item(uid);
801 if (NULL == current) {
802 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
806 current->state = APP_STATE_PLAYING;
808 g_playing_info = current;
810 SLOG(LOG_INFO, tts_tag(), "[Player DEBUG] Active thread count : %d", ecore_thread_active_get());
812 if (0 < ttsd_data_get_sound_data_size(current->uid)) {
813 SLOG(LOG_INFO, tts_tag(), "[Player] Run thread");
814 ecore_thread_run(__play_thread, __end_play_thread, NULL, NULL);
820 int ttsd_player_stop(int uid)
822 if (false == g_player_init) {
823 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 /* check whether uid is current playing or not */
836 if (NULL != g_playing_info) {
837 if (uid == g_playing_info->uid) {
838 /* release current playing info */
839 g_playing_info = NULL;
842 SLOG(LOG_DEBUG, tts_tag(), "[Player] No current playing");
845 if (true == current->is_paused_data) {
846 if (NULL != current->paused_data) {
847 if (NULL != current->paused_data->data) {
848 free(current->paused_data->data);
849 current->paused_data->data = NULL;
852 free(current->paused_data);
853 current->paused_data = NULL;
857 current->event = TTSE_RESULT_EVENT_FINISH;
858 current->state = APP_STATE_READY;
859 current->is_paused_data = false;
862 if (NULL == g_playing_info) {
863 SLOG(LOG_DEBUG, tts_tag(), "[Player] ==========================");
864 SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
865 SLOG(LOG_DEBUG, tts_tag(), "[Player] ==========================");
867 /* The thread should be released */
868 int thread_count = ecore_thread_active_get();
870 while (0 < thread_count) {
875 SLOG(LOG_WARN, tts_tag(), "[Player WARNING!!] Thread is blocked. Player release continue.");
879 thread_count = ecore_thread_active_get();
882 SLOG(LOG_DEBUG, tts_tag(), "[Player] ==========================");
883 SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
884 SLOG(LOG_DEBUG, tts_tag(), "[Player] ==========================");
887 SLOG(LOG_INFO, tts_tag(), "[Player SUCCESS] Stop player : uid(%d)", uid);
892 int ttsd_player_clear(int uid)
894 if (false == g_player_init) {
895 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
901 current = __player_get_item(uid);
902 if (NULL == current) {
903 SECURE_SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
907 if (true == current->is_paused_data) {
908 if (NULL != current->paused_data) {
909 if (NULL != current->paused_data->data) {
910 free(current->paused_data->data);
911 current->paused_data->data = NULL;
914 free(current->paused_data);
915 current->paused_data = NULL;
919 current->event = TTSE_RESULT_EVENT_FINISH;
920 current->state = APP_STATE_READY;
921 current->is_paused_data = false;
924 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Clear player : uid(%d)", uid);
929 int ttsd_player_pause(int uid)
931 SLOG(LOG_DEBUG, tts_tag(), "[Player] pause player : uid(%d)", uid);
933 if (false == g_player_init) {
934 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
940 current = __player_get_item(uid);
941 if (NULL == current) {
942 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] ttsd_player_pause() : uid(%d) is not valid", uid);
946 /* check whether uid is current playing or not */
947 if (NULL != g_playing_info) {
948 if (uid == g_playing_info->uid) {
949 /* release current playing info */
950 g_playing_info = NULL;
956 current->state = APP_STATE_PAUSED;
958 SLOG(LOG_DEBUG, tts_tag(), "[Player] ==========================");
959 SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
960 SLOG(LOG_DEBUG, tts_tag(), "[Player] ==========================");
962 /* The thread should be released */
963 int thread_count = ecore_thread_active_get();
965 while (0 < thread_count) {
970 SLOG(LOG_WARN, tts_tag(), "[Player WARNING!!] Thread is blocked. Player release continue.");
974 thread_count = ecore_thread_active_get();
977 SLOG(LOG_DEBUG, tts_tag(), "[Player] ==========================");
978 SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
979 SLOG(LOG_DEBUG, tts_tag(), "[Player] ==========================");
981 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Pause player : uid(%d)", uid);
986 int ttsd_player_resume(int uid)
988 SLOG(LOG_DEBUG, tts_tag(), "[Player] Resume player : uid(%d)", uid);
990 if (false == g_player_init) {
991 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
997 current = __player_get_item(uid);
998 if (NULL == current) {
999 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
1003 /* check current player */
1004 if (NULL != g_playing_info)
1005 g_playing_info = NULL;
1007 current->state = APP_STATE_PLAYING;
1008 g_playing_info = current;
1010 SLOG(LOG_INFO, tts_tag(), "[Player] Resume to run thread");
1011 ecore_thread_run(__play_thread, __end_play_thread, NULL, NULL);
1016 int ttsd_player_all_stop()
1018 if (false == g_player_init) {
1019 SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
1023 g_playing_info = NULL;
1026 player_s *data = NULL;
1028 if (0 < g_list_length(g_player_list)) {
1029 /* Get a first item */
1030 iter = g_list_first(g_player_list);
1032 while (NULL != iter) {
1033 /* Get handle data from list */
1034 data = (player_s*)iter->data;
1037 if (0 > ttsd_data_get_client_state(data->uid, &state)) {
1038 SLOG(LOG_ERROR, tts_tag(), "[player ERROR] uid(%d) is not valid", data->uid);
1039 ttsd_player_destroy_instance(data->uid);
1040 iter = g_list_next(iter);
1044 if (APP_STATE_PLAYING == state || APP_STATE_PAUSED == state) {
1045 data->event = TTSE_RESULT_EVENT_FINISH;
1046 data->state = APP_STATE_READY;
1048 if (true == data->is_paused_data) {
1049 if (NULL != data->paused_data) {
1050 if (NULL != data->paused_data->data) {
1051 free(data->paused_data->data);
1052 data->paused_data->data = NULL;
1055 free(data->paused_data);
1056 data->paused_data = NULL;
1060 data->is_paused_data = false;
1065 iter = g_list_next(iter);
1069 SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] player all stop!!");