#include "ttsd_data.h"
#include "ttsd_dbus.h"
+#include "tts_internal.h"
+#include "ttsd_server.h"
+
/*
* Internal data structure
*/
typedef struct {
int uid; /** client id */
- app_state_e state; /** client state */
+ app_tts_state_e state; /** client state */
/* Current utterance information */
ttse_result_event_e event; /** event of last utterance */
} player_s;
#define SOUND_BUFFER_LENGTH 2048
+#define FOCUS_SERVER_READY "/tmp/.sound_server_ready"
+
+/* Sound buf save for test */
+/*
+#define BUF_SAVE_MODE
+*/
+#ifdef BUF_SAVE_MODE
+static char g_temp_file_name[128] = {'\0',};
+
+static FILE* g_pFile;
+
+static int g_count = 1;
+#endif
/** player init info */
static bool g_player_init = false;
static sound_stream_info_h g_stream_info_h;
+static sound_stream_ducking_h g_stream_ducking;
+
+static bool ducking_flag;
+
+#define SND_MGR_DUCKING_DURATION 500
+
+static int g_focus_watch_id;
+
+static double g_bg_volume_ratio;
+
/*
* Internal Interfaces
*/
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,
sound_stream_focus_change_reason_e reason_for_change, int sound_behavior, const char *extra_info, void *user_data)
{
- SLOG(LOG_DEBUG, tts_tag(), "===== Focus state changed cb");
+ SLOG(LOG_DEBUG, tts_tag(), "@@@ Focus state changed cb");
if (stream_info != g_stream_info_h) {
SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Invalid stream info handle");
return;
}
- SLOG(LOG_WARN, tts_tag(), "[Player] focus state changed to (%d) with reason(%d)", (int)focus_state, (int)reason_for_change);
+ 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);
if (AUDIO_STATE_PLAY == g_audio_state && focus_mask == SOUND_STREAM_FOCUS_FOR_PLAYBACK && SOUND_STREAM_FOCUS_STATE_RELEASED == focus_state) {
if (TTSD_MODE_DEFAULT == ttsd_get_mode()) {
g_audio_state = AUDIO_STATE_READY;
-
+
if (NULL == g_playing_info) {
- SLOG(LOG_WARN, tts_tag(), "[Player WARNING] No current player");
+ SLOG(LOG_WARN, tts_tag(), "[Player WARNING] No current player");
return;
}
if (APP_STATE_PLAYING == g_playing_info->state) {
- g_playing_info->state = APP_STATE_PAUSED;
-
- ttsd_data_set_client_state(g_playing_info->uid, APP_STATE_PAUSED);
+ int uid = g_playing_info->uid;
- int pid = ttsd_data_get_pid(g_playing_info->uid);
+ if (0 != ttsd_player_pause(uid)) {
+ SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to pause the player");
+ return;
+ }
+ ttsd_data_set_client_state(uid, APP_STATE_PAUSED);
+ int pid = ttsd_data_get_pid(uid);
/* send message to client about changing state */
- ttsdc_send_set_state_message(pid, g_playing_info->uid, APP_STATE_PAUSED);
+ ttsdc_send_set_state_message(pid, uid, APP_STATE_PAUSED);
+ }
+ } else {
+ SLOG(LOG_DEBUG, tts_tag(), "[Player] Ignore focus state cb - mode(%d)", ttsd_get_mode());
+ }
+ }
+
+/* if (AUDIO_STATE_READY == g_audio_state && focus_mask == SOUND_STREAM_FOCUS_FOR_PLAYBACK && SOUND_STREAM_FOCUS_STATE_ACQUIRED == focus_state) {
+ if (TTSD_MODE_DEFAULT == ttsd_get_mode()) {
+ g_audio_state = AUDIO_STATE_PLAY;
+
+ if (NULL == g_playing_info) {
+ SLOG(LOG_WARN, tts_tag(), "[Player WARNING] No current player");
+ return;
}
+
+ if (APP_STATE_PAUSED == g_playing_info->state) {
+ int uid = g_playing_info->uid;
+
+ g_audio_state = AUDIO_STATE_PLAY;
+ if (0 != ttsd_player_resume(uid)) {
+ SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to resume the player");
+ g_audio_state = AUDIO_STATE_READY;
+ return;
+ }
+
+ ttsd_data_set_client_state(uid, APP_STATE_PLAYING);
+ int pid = ttsd_data_get_pid(uid);
+ ttsdc_send_set_state_message(pid, uid, APP_STATE_PLAYING);
+ }
+
} else {
SLOG(LOG_DEBUG, tts_tag(), "[Player] Ignore focus state cb - mode(%d)", ttsd_get_mode());
}
}
+*/
+ SLOG(LOG_DEBUG, tts_tag(), "@@@");
+
+ return;
+}
+
+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,
+ const char *extra_info, void *user_data)
+{
+ SLOG(LOG_DEBUG, tts_tag(), "@@@ Focus state watch cb");
+
+ ttsd_mode_e mode = ttsd_get_mode();
+
+ if (TTSD_MODE_SCREEN_READER != mode && TTSD_MODE_NOTIFICATION != mode) {
+ SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] This is not screen-reader mode and notification mode.");
+ return;
+ }
+
+ if (AUDIO_STATE_PLAY == g_audio_state && SOUND_STREAM_FOCUS_CHANGED_BY_VOICE_INFORMATION == reason &&
+ NULL != extra_info && 0 == strncmp(extra_info, "TTSD_MODE_INTERRUPT", strlen(extra_info))) {
+ /* If the focus is changed by "Interrupt" mode and current players of "SR" and "Noti" modes are on going, please stop the current players. */
+ g_audio_state = AUDIO_STATE_READY;
+
+ if (NULL == g_playing_info) {
+ SLOG(LOG_WARN, tts_tag(), "[Player WARNING] No current player");
+ return;
+ }
+
+ if (APP_STATE_PLAYING == g_playing_info->state) {
+ int uid = g_playing_info->uid;
+
+ if (0 != ttsd_server_stop(uid)) {
+ SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to stop TTS server");
+ return;
+ }
+ if (0 != ttsd_player_stop(uid)) {
+ SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to stop the player");
+ return;
+ }
- SLOG(LOG_DEBUG, tts_tag(), "=====");
- SLOG(LOG_DEBUG, tts_tag(), "");
+ ttsd_data_set_client_state(uid, APP_STATE_READY);
+ int pid = ttsd_data_get_pid(uid);
+ /* send message to client about changing state */
+ ttsdc_send_set_state_message(pid, uid, APP_STATE_READY);
+ } else {
+ SLOG(LOG_DEBUG, tts_tag(), "[Player] Not playing state");
+ }
+ } else {
+ SLOG(LOG_DEBUG, tts_tag(), "[Player] This is not Interrupt mode or not playing state.");
+ }
return;
}
+void __sound_stream_ducking_state_changed_cb(sound_stream_ducking_h stream_ducking, bool is_ducked, void *user_data)
+{
+ SLOG(LOG_DEBUG, tts_tag(), "@@@ ducking state changed cb");
+
+ SLOG(LOG_DEBUG, tts_tag(), "[Player] is ducked : %d", is_ducked);
+
+ ducking_flag = true;
+ return;
+}
+
+static void __change_background_volume()
+{
+ int ret = SOUND_MANAGER_ERROR_NONE;
+ bool is_ducked = false;
+ ret = sound_manager_is_ducked(g_stream_ducking, &is_ducked);
+ if (is_ducked) {
+ SLOG(LOG_DEBUG, tts_tag(), "[Player] The background volume is already ducked");
+ return;
+ }
+
+ ducking_flag = false;
+ ret = sound_manager_activate_ducking(g_stream_ducking, SND_MGR_DUCKING_DURATION, g_bg_volume_ratio);
+ if (SOUND_MANAGER_ERROR_NONE != ret) {
+ SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to activate ducking");
+ return;
+ } else {
+ SLOG(LOG_DEBUG, tts_tag(), "[Player] Activate ducking");
+ }
+
+ while (ducking_flag == false) {
+ usleep(10000);
+ SLOG(LOG_DEBUG, tts_tag(), "ducking waiting");
+ }
+}
+
+static void __recover_background_volume()
+{
+ int ret = SOUND_MANAGER_ERROR_NONE;
+ bool is_ducked = false;
+ ret = sound_manager_is_ducked(g_stream_ducking, &is_ducked);
+ if (!is_ducked) {
+ SLOG(LOG_DEBUG, tts_tag(), "[Player] The background volume is already recovered");
+ return;
+ }
+
+ ret = sound_manager_deactivate_ducking(g_stream_ducking);
+ if (SOUND_MANAGER_ERROR_NONE != ret)
+ SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to deactivate ducking");
+ else
+ SLOG(LOG_WARN, tts_tag(), "[Player] Deactivate ducking");
+}
+
static int __create_audio_out(ttse_audio_type_e type, int rate)
{
int ret = -1;
static void __end_play_thread(void *data, Ecore_Thread *thread)
{
- SLOG(LOG_ERROR, tts_tag(), "===== End thread");
+ SLOG(LOG_ERROR, tts_tag(), "@@@ End thread");
+
+#ifdef BUF_SAVE_MODE
+ fclose(g_pFile);
+#endif
}
static void __set_policy_for_playing(int volume)
{
/* Set stream info */
int ret;
- if (TTSD_MODE_DEFAULT == ttsd_get_mode()) {
+ ttsd_mode_e mode = ttsd_get_mode();
+ if (TTSD_MODE_DEFAULT == mode) {
ret = sound_manager_acquire_focus(g_stream_info_h, SOUND_STREAM_FOCUS_FOR_PLAYBACK, SOUND_BEHAVIOR_NONE, NULL);
if (SOUND_MANAGER_ERROR_NONE != ret) {
SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to acquire focus");
+ } else {
+ SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] Success to acquire focus (default mode)");
+ }
+ } else if (TTSD_MODE_INTERRUPT == mode) {
+ ret = sound_manager_acquire_focus(g_stream_info_h, SOUND_STREAM_FOCUS_FOR_PLAYBACK, SOUND_BEHAVIOR_NONE, "TTSD_MODE_INTERRUPT");
+ if (SOUND_MANAGER_ERROR_NONE != ret) {
+ SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to acquire focus");
+ } else {
+ SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] Success to acquire focus (interrupt mode)");
}
}
+
ret = audio_out_set_sound_stream_info(g_audio_h, g_stream_info_h);
if (AUDIO_IO_ERROR_NONE != ret) {
SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to set stream info");
}
+ __change_background_volume();
+
+ SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] set policy for playing");
+
return;
}
static void __unset_policy_for_playing()
{
int ret;
+ ttsd_mode_e mode = ttsd_get_mode();
/* Unset stream info */
- if (TTSD_MODE_DEFAULT == ttsd_get_mode()) {
- ret = sound_manager_release_focus(g_stream_info_h, SOUND_STREAM_FOCUS_FOR_PLAYBACK, SOUND_BEHAVIOR_NONE, NULL);
+ if (TTSD_MODE_DEFAULT == mode || TTSD_MODE_INTERRUPT == mode) {
+ sound_stream_focus_state_e state_for_playing = SOUND_STREAM_FOCUS_STATE_ACQUIRED;
+ ret = sound_manager_get_focus_state(g_stream_info_h, &state_for_playing, NULL);
if (SOUND_MANAGER_ERROR_NONE != ret) {
- SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to release focus");
+ SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to get focus state: %d", ret);
+ }
+
+ if (SOUND_STREAM_FOCUS_STATE_ACQUIRED == state_for_playing) {
+ if (TTSD_MODE_DEFAULT == mode || TTSD_MODE_INTERRUPT == mode) {
+ ret = sound_manager_release_focus(g_stream_info_h, SOUND_STREAM_FOCUS_FOR_PLAYBACK, SOUND_BEHAVIOR_NONE, NULL);
+ SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] release focus (mode: %d)", mode);
+ }
+
+ if (SOUND_MANAGER_ERROR_NONE != ret) {
+ SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to release focus");
+ }
}
}
+ __recover_background_volume();
+
+ SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] unset policy for playing");
+
return;
}
+int ttsd_player_check_current_playback_focus(bool *is_current_interrupt)
+{
+ int ret;
+ ttsd_mode_e mode = ttsd_get_mode();
+
+ if (TTSD_MODE_INTERRUPT != mode) {
+ /* check the current playback focus */
+ sound_stream_focus_change_reason_e reason;
+ int sound_behavior = 0;
+ char *extra_info = NULL;
+
+ ret = sound_manager_get_current_playback_focus(&reason, &sound_behavior, &extra_info);
+
+ SLOG(LOG_DEBUG, tts_tag(), "[Player] current playback focus: extra_info(%s), reason(%d), sound_behavior(%d)", extra_info, reason, sound_behavior);
+
+ if (SOUND_MANAGER_ERROR_NONE == ret && NULL != extra_info && 0 < strlen(extra_info)) {
+ if (SOUND_STREAM_FOCUS_CHANGED_BY_VOICE_INFORMATION == reason && 0 == strncmp(extra_info, "TTSD_MODE_INTERRUPT", strlen(extra_info))) {
+ SLOG(LOG_DEBUG, tts_tag(), "[Player] The current focus in Interrupt. Cannot play the requested sound data");
+ *is_current_interrupt = true;
+
+ free(extra_info);
+ extra_info = NULL;
+
+ return TTSD_ERROR_NONE;
+ }
+ }
+
+ if (NULL != extra_info) {
+ free(extra_info);
+ extra_info = NULL;
+ }
+ }
+
+ *is_current_interrupt = false;
+
+ return TTSD_ERROR_NONE;
+}
+
static void __play_thread(void *data, Ecore_Thread *thread)
{
- SLOG(LOG_DEBUG, tts_tag(), "===== Start thread");
+ SLOG(LOG_DEBUG, tts_tag(), "@@@ Start thread");
+
+#ifdef BUF_SAVE_MODE
+ g_count++;
+
+ while (1) {
+ snprintf(g_temp_file_name, sizeof(g_temp_file_name), "/tmp/tts_temp_%d_%d", getpid(), g_count);
+ int ret = access(g_temp_file_name, 0);
+
+ if (0 == ret) {
+ SLOG(LOG_ERROR, tts_tag(), "[Recorder ERROR] File is already exist");
+ if (0 == remove(g_temp_file_name)) {
+ SLOG(LOG_DEBUG, tts_tag(), "[Recorder] Remove file");
+ break;
+ } else {
+ g_count++;
+ }
+ } else {
+ break;
+ }
+ }
+
+ SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Recorder] Temp file name=[%s]", g_temp_file_name);
+
+ /* open test file */
+ g_pFile = fopen(g_temp_file_name, "wb+x");
+ if (!g_pFile) {
+ SLOG(LOG_ERROR, tts_tag(), "[Recorder ERROR] File not found!");
+ return;
+ }
+#endif
if (NULL == g_playing_info) {
SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] No current player");
if (0 != ret || NULL == sound_data) {
/* empty queue */
SLOG(LOG_DEBUG, tts_tag(), "[Player] No sound data. Waiting mode");
- /* release audio & recover session */
- ret = audio_out_unprepare(g_audio_h);
- if (AUDIO_IO_ERROR_NONE != ret) {
- SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
- } else {
- SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio");
- }
- g_audio_state = AUDIO_STATE_READY;
-
- /* unset volume policy, volume will be 100% */
- __unset_policy_for_playing();
/* wait for new audio data come */
while (1) {
usleep(10000);
if (NULL == g_playing_info) {
/* current playing uid is replaced */
- SLOG(LOG_DEBUG, tts_tag(), "[Player] Finish thread");
+ SLOG(LOG_INFO, tts_tag(), "[Player] Finish thread");
+ if (AUDIO_STATE_PLAY == g_audio_state) {
+ /* release audio & recover session */
+ ret = audio_out_unprepare(g_audio_h);
+ if (AUDIO_IO_ERROR_NONE != ret) {
+ SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
+ } else {
+ SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio");
+ }
+ g_audio_state = AUDIO_STATE_READY;
+ }
+ /* unset volume policy, volume will be 100% */
+ __unset_policy_for_playing();
return;
} else if (0 < ttsd_data_get_sound_data_size(player->uid)) {
/* new audio data come */
- SLOG(LOG_DEBUG, tts_tag(), "[Player] Resume thread");
+ SLOG(LOG_INFO, tts_tag(), "[Player] Resume thread");
break;
}
+
+ /* If engine is not on processing */
+ if (TTSD_SYNTHESIS_CONTROL_DOING != ttsd_get_synth_control()) {
+ if (AUDIO_STATE_PLAY == g_audio_state) {
+ /* release audio & recover session */
+ ret = audio_out_unprepare(g_audio_h);
+ if (AUDIO_IO_ERROR_NONE != ret) {
+ SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to unprepare audio : %d", ret);
+ } else {
+ SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio");
+ }
+ g_audio_state = AUDIO_STATE_READY;
+
+ /* unset volume policy, volume will be 100% */
+ __unset_policy_for_playing();
+ }
+ }
}
- /* set volume policy as 40%, when resume play thread*/
- __set_policy_for_playing(40);
+ SLOG(LOG_INFO, tts_tag(), "[Player] Finish to wait for new audio data come");
+
+ if (AUDIO_STATE_READY == g_audio_state) {
+ /* set volume policy as 40%, when resume play thread*/
+ __set_policy_for_playing(40);
+ }
/* resume play thread */
player->state = APP_STATE_PLAYING;
SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid");
/* unset volume policy, volume will be 100% */
__unset_policy_for_playing();
+
return;
}
SLOG(LOG_ERROR, tts_tag(), "[Send ERROR] Fail to send Utterance Start Signal : pid(%d), uid(%d), uttid(%d)",
pid, player->uid, sound_data->utt_id);
}
- SLOG(LOG_DEBUG, tts_tag(), "[Player] Start utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id);
+ SLOG(LOG_INFO, tts_tag(), "[Player] Start utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id);
}
/* Save last event to check utterance start */
__unset_policy_for_playing();
return;
}
+
+ __unset_policy_for_playing();
+
if (0 != ttsdc_send_utt_finish_message(pid, player->uid, sound_data->utt_id)) {
SLOG(LOG_ERROR, tts_tag(), "[Send ERROR] Fail to send Utterance Completed Signal : pid(%d), uid(%d), uttid(%d)",
pid, player->uid, sound_data->utt_id);
+ } else {
+ SLOG(LOG_INFO, tts_tag(), "[Player] Finish utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id);
}
}
- SLOG(LOG_DEBUG, tts_tag(), "[Player] Finish utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id);
+ SLOG(LOG_INFO, tts_tag(), "[Player] Event(%d) utterance : uid(%d), uttid(%d)", sound_data->event, player->uid, sound_data->utt_id);
+ ttsd_data_clear_sound_data(player->uid, &sound_data);
continue;
}
}
if (g_sampling_rate != sound_data->rate || g_audio_type != sound_data->audio_type) {
- SLOG(LOG_DEBUG, tts_tag(), "[Player] Change audio handle : org type(%d) org rate(%d)", g_audio_type, g_sampling_rate);
+ SLOG(LOG_INFO, tts_tag(), "[Player] Change audio handle : org type(%d) org rate(%d)", g_audio_type, g_sampling_rate);
if (NULL != g_audio_h) {
__destroy_audio_out();
}
SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to create audio out");
/* unset volume policy, volume will be 100% */
__unset_policy_for_playing();
+
+ ttsd_data_clear_sound_data(player->uid, &sound_data);
+
return;
}
+
+ SLOG(LOG_INFO, tts_tag(), "[Player INFO] Success to destroy and recreate audio out");
__set_policy_for_playing(40);
}
g_playing_info = NULL;
/* unset volume policy, volume will be 100% */
__unset_policy_for_playing();
+
+ ttsd_data_clear_sound_data(player->uid, &sound_data);
+
return;
}
SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Prepare audio");
}
char* temp_data = sound_data->data;
+ SLOG(LOG_INFO, tts_tag(), "[Player INFO] Before audio_out_write. data(%p), data[%d](%p), uid(%d), utt_id(%d), len(%d)",
+ temp_data, idx, &temp_data[idx], player->uid, sound_data->utt_id, len);
+#ifdef BUF_SAVE_MODE
+ /* write pcm buffer */
+ fwrite(&temp_data[idx], 1, len, g_pFile);
+#endif
ret = audio_out_write(g_audio_h, &temp_data[idx], len);
if (0 > ret) {
SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to audio write - %d", ret);
} else {
idx += len;
+ SLOG(LOG_INFO, tts_tag(), "[Player INFO] After audio_out_write");
}
if (NULL == g_playing_info && APP_STATE_PAUSED != player->state) {
/* unset volume policy, volume will be 100% */
__unset_policy_for_playing();
- if (NULL != sound_data) {
- if (NULL != sound_data->data) {
- free(sound_data->data);
- sound_data->data = NULL;
- }
-
- free(sound_data);
- sound_data = NULL;
- }
+ ttsd_data_clear_sound_data(player->uid, &sound_data);
return;
}
if (APP_STATE_PAUSED == player->state) {
/* Save data */
+ SLOG(LOG_DEBUG, tts_tag(), "[Player] player(%p)", player);
player->paused_data = sound_data;
player->is_paused_data = true;
player->idx = idx;
g_audio_state = AUDIO_STATE_READY;
- SLOG(LOG_DEBUG, tts_tag(), "[Player] Stop player thread by pause");
+
+ SLOG(LOG_INFO, tts_tag(), "[Player] Stop player thread by pause");
/* Request prepare */
ret = audio_out_unprepare(g_audio_h);
SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio");
}
- if (NULL != sound_data) {
- if (NULL != sound_data->data) {
- free(sound_data->data);
- sound_data->data = NULL;
- }
-
- free(sound_data);
- sound_data = NULL;
- }
+ ttsd_data_clear_sound_data(player->uid, &sound_data);
/* unset volume policy, volume will be 100% */
__unset_policy_for_playing();
return;
SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid");
/* unset volume policy, volume will be 100% */
__unset_policy_for_playing();
+
return;
}
pid, player->uid, sound_data->utt_id);
/* unset volume policy, volume will be 100% */
__unset_policy_for_playing();
+
+ ttsd_data_clear_sound_data(player->uid, &sound_data);
return;
}
- SLOG(LOG_DEBUG, tts_tag(), "[Player] Finish utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id);
+ SLOG(LOG_INFO, tts_tag(), "[Player] Finish utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id);
}
- if (NULL != sound_data) {
- if (NULL != sound_data->data) {
- free(sound_data->data);
- sound_data->data = NULL;
- }
-
- free(sound_data);
- sound_data = NULL;
- }
+ ttsd_data_clear_sound_data(player->uid, &sound_data);
if (NULL == g_playing_info) {
SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Current player is NULL");
ecore_thread_max_set(1);
+ int cnt = 0;
+ while (1) {
+ if (0 == access(FOCUS_SERVER_READY, F_OK)) {
+ SLOG(LOG_ERROR, tts_tag(), "[Player SUCCESS] focus server is available");
+ break;
+ } else {
+ if (0 == cnt++ % 10)
+ SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] focus server is not available");
+ usleep(50000);
+ }
+ }
+
ret = sound_manager_create_stream_information(SOUND_STREAM_TYPE_VOICE_INFORMATION, __player_focus_state_cb, NULL, &g_stream_info_h);
if (SOUND_MANAGER_ERROR_NONE != ret) {
SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to create stream info");
SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Create stream info");
}
+ /* add sound focus state watch callback */
+ ret = sound_manager_add_focus_state_watch_cb(SOUND_STREAM_FOCUS_FOR_PLAYBACK, __player_focus_state_watch_cb, NULL, &g_focus_watch_id);
+ if (SOUND_MANAGER_ERROR_NONE != ret) {
+ SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to add sound focus watch callback");
+ sound_manager_destroy_stream_information(g_stream_info_h);
+ return -1;
+ } else {
+ SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Add sound focus watch callback");
+ }
+
+ ret = sound_manager_create_stream_ducking(SOUND_STREAM_TYPE_MEDIA, __sound_stream_ducking_state_changed_cb, NULL, &g_stream_ducking);
+ if (SOUND_MANAGER_ERROR_NONE != ret)
+ SLOG(LOG_ERROR, tts_tag(), "[Player WARNING] Fail to create stream ducking");
+ else
+ SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Create stream ducking");
+
ecore_thread_max_set(1);
ret = __create_audio_out(TTSE_AUDIO_TYPE_RAW_S16, 16000);
- if (0 != ret)
+ if (0 != ret) {
+ sound_manager_destroy_stream_information(g_stream_info_h);
+ sound_manager_remove_focus_state_watch_cb(g_focus_watch_id);
return -1;
+ }
g_player_init = true;
int ret;
- SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] ==========================");
+ SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] @@@@@");
SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] Active thread count : %d", ecore_thread_active_get());
- SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] ==========================");
+ SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] @@@@@");
/* The thread should be released */
int thread_count = ecore_thread_active_get();
SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Destroy stream info");
}
+ /* remove focus state watch callback */
+ ret = sound_manager_remove_focus_state_watch_cb(g_focus_watch_id);
+ if (SOUND_MANAGER_ERROR_NONE != ret) {
+ SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to remove the focus state watch cb");
+ } else {
+ SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Remove the focus state watch cb");
+ }
+
+ ret = sound_manager_destroy_stream_ducking(g_stream_ducking);
+ if (SOUND_MANAGER_ERROR_NONE != ret)
+ SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to destroy stream ducking");
+ else
+ SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Destroy stream ducking");
+
/* clear g_player_list */
g_playing_info = NULL;
g_player_init = false;
g_playing_info = current;
- SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] Active thread count : %d", ecore_thread_active_get());
+ SLOG(LOG_INFO, tts_tag(), "[Player DEBUG] Active thread count : %d", ecore_thread_active_get());
if (0 < ttsd_data_get_sound_data_size(current->uid)) {
- SLOG(LOG_DEBUG, tts_tag(), "[Player] Run thread");
+ SLOG(LOG_INFO, tts_tag(), "[Player] Run thread");
ecore_thread_run(__play_thread, __end_play_thread, NULL, NULL);
}
current->idx = 0;
if (NULL == g_playing_info) {
- SLOG(LOG_DEBUG, tts_tag(), "[Player] ==========================");
+ SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
- SLOG(LOG_DEBUG, tts_tag(), "[Player] ==========================");
+ SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
/* The thread should be released */
int thread_count = ecore_thread_active_get();
thread_count = ecore_thread_active_get();
}
- SLOG(LOG_DEBUG, tts_tag(), "[Player] ==========================");
+ SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
- SLOG(LOG_DEBUG, tts_tag(), "[Player] ==========================");
+ SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
}
- SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Stop player : uid(%d)", uid);
+ SLOG(LOG_INFO, tts_tag(), "[Player SUCCESS] Stop player : uid(%d)", uid);
return 0;
}
if (NULL != g_playing_info) {
if (uid == g_playing_info->uid) {
/* release current playing info */
+ SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] release current playing info (%d)", uid);
g_playing_info = NULL;
} else {
/* error case */
}
}
+ SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] current player (%p), g_playing_info(%p)", current, g_playing_info);
+
current->state = APP_STATE_PAUSED;
-
- SLOG(LOG_DEBUG, tts_tag(), "[Player] ==========================");
- SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
- SLOG(LOG_DEBUG, tts_tag(), "[Player] ==========================");
- /* The thread should be released */
- int thread_count = ecore_thread_active_get();
- int count = 0;
- while (0 < thread_count) {
- usleep(10000);
+ if (NULL == g_playing_info) {
+ SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
+ SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
+ SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
- count++;
- if (30 == count) {
- SLOG(LOG_WARN, tts_tag(), "[Player WARNING!!] Thread is blocked. Player release continue.");
- break;
+ /* The thread should be released */
+ int thread_count = ecore_thread_active_get();
+ int count = 0;
+ while (0 < thread_count) {
+ usleep(10000);
+
+ count++;
+ SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] current(%p), state(%d)", current, current->state);
+
+ if (30 == count) {
+ SLOG(LOG_WARN, tts_tag(), "[Player WARNING!!] Thread is blocked. Player release continue. current(%p) current state(%d)", current, current->state);
+ break;
+ }
+
+ thread_count = ecore_thread_active_get();
}
- thread_count = ecore_thread_active_get();
+ SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
+ SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
+ SLOG(LOG_DEBUG, tts_tag(), "[Player] @@@@@");
}
- SLOG(LOG_DEBUG, tts_tag(), "[Player] ==========================");
- SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
- SLOG(LOG_DEBUG, tts_tag(), "[Player] ==========================");
SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Pause player : uid(%d)", uid);
current->state = APP_STATE_PLAYING;
g_playing_info = current;
- SLOG(LOG_DEBUG, tts_tag(), "[Player] Run thread");
+ SLOG(LOG_INFO, tts_tag(), "[Player] Resume to run thread");
ecore_thread_run(__play_thread, __end_play_thread, NULL, NULL);
return 0;
/* Get handle data from list */
data = (player_s*)iter->data;
- app_state_e state;
+ app_tts_state_e state;
if (0 > ttsd_data_get_client_state(data->uid, &state)) {
SLOG(LOG_ERROR, tts_tag(), "[player ERROR] uid(%d) is not valid", data->uid);
ttsd_player_destroy_instance(data->uid);
return 0;
}
+
+int ttsd_player_play_pcm(int uid)
+{
+ if (false == g_player_init) {
+ SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
+ return -1;
+ }
+
+ if (NULL != g_playing_info) {
+ if (uid == g_playing_info->uid) {
+ SLOG(LOG_DEBUG, tts_tag(), "[Player] uid(%d) has already played", g_playing_info->uid);
+ return 0;
+ } else {
+ SLOG(LOG_WARN, tts_tag(), "[Player WARNING] stop old player (%d)", g_playing_info->uid);
+ ttsd_player_stop(g_playing_info->uid);
+ }
+ }
+
+ SLOG(LOG_DEBUG, tts_tag(), "[Player] start play : uid(%d)", uid);
+
+ /* Check sound queue size */
+ if (0 == ttsd_data_get_sound_data_size(uid)) {
+ SLOG(LOG_WARN, tts_tag(), "[Player WARNING] A sound queue of current player(%d) is empty", uid);
+ }
+
+ /* Check uid */
+ player_s* current;
+ current = __player_get_item(uid);
+ if (NULL == current) {
+ SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] uid(%d) is not valid", uid);
+ return -1;
+ }
+
+ current->state = APP_STATE_PLAYING;
+
+ g_playing_info = current;
+
+ SLOG(LOG_INFO, tts_tag(), "[Player DEBUG] Active thread count : %d", ecore_thread_active_get());
+
+ if (0 <= ttsd_data_get_sound_data_size(current->uid)) {
+ SLOG(LOG_INFO, tts_tag(), "[Player] Run thread");
+ ecore_thread_run(__play_thread, __end_play_thread, NULL, NULL);
+ }
+
+ return 0;
+}
+
+int ttsd_player_get_background_volume_ratio(double* ratio)
+{
+ if (NULL == ratio)
+ return -1;
+ else
+ *ratio = g_bg_volume_ratio;
+
+ return TTSD_ERROR_NONE;
+}
+
+int ttsd_player_set_background_volume_ratio(double ratio)
+{
+ SLOG(LOG_INFO, tts_tag(), "[Player DEBUG] ttsd_player_set_background_volume_ratio : %lf", ratio);
+
+ g_bg_volume_ratio = ratio;
+ return TTSD_ERROR_NONE;
+}