static sound_stream_info_h g_stream_info_h;
+static sound_stream_ducking_h g_media_stream_ducking;
+static sound_stream_ducking_h g_system_stream_ducking;
+static sound_stream_ducking_h g_notification_stream_ducking;
+static sound_stream_ducking_h g_alarm_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
}
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 (NULL == g_playing_info) {
+ SLOG(LOG_WARN, tts_tag(), "[Player WARNING] No current player");
+ return;
+ }
+
+ if (APP_STATE_PLAYING == g_playing_info->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");
+ int uid = g_playing_info->uid;
+
+ if (0 != ttsd_player_pause(uid)) {
+ SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to pause the player");
return;
}
- if (APP_STATE_PLAYING == g_playing_info->state) {
- int uid = 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, uid, APP_STATE_PAUSED);
- }
+ 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, uid, APP_STATE_PAUSED);
} else {
SLOG(LOG_DEBUG, tts_tag(), "[Player] Ignore focus state cb - mode(%d)", ttsd_get_mode());
}
return;
}
- if (AUDIO_STATE_PLAY == g_audio_state && SOUND_STREAM_FOCUS_CHANGED_BY_VOICE_INFORMATION == reason &&
+ if (NULL == g_playing_info) {
+ SLOG(LOG_WARN, tts_tag(), "[Player WARNING] No current player");
+ return;
+ }
+
+ if (APP_STATE_PLAYING == g_playing_info->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");
+ 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;
}
- if (APP_STATE_PLAYING == g_playing_info->state) {
- int uid = g_playing_info->uid;
+ 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] Extra info is not Interrupt mode(%s) or not playing state(%d).", extra_info, g_playing_info->state);
+ }
- 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;
- }
+ return;
+}
- 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);
+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 char* __get_ducking_stream(sound_stream_type_e stream_type)
+{
+ if (SOUND_STREAM_TYPE_MEDIA == stream_type)
+ return "Media stream";
+ else if (SOUND_STREAM_TYPE_SYSTEM == stream_type)
+ return "System stream";
+ else if (SOUND_STREAM_TYPE_NOTIFICATION == stream_type)
+ return "Notification stream";
+ else if (SOUND_STREAM_TYPE_ALARM == stream_type)
+ return "Alarm stream";
+ return "Non matched stream";
+}
+
+static int __activate_ducking_sound_stream(sound_stream_type_e stream_type, sound_stream_ducking_h stream_ducking_h)
+{
+ bool is_ducked = false;
+ int ret = sound_manager_is_ducked(stream_ducking_h, &is_ducked);
+ if (is_ducked) {
+ SLOG(LOG_DEBUG, tts_tag(), "[Player] The %s is already ducked", __get_ducking_stream(stream_type));
+ } else {
+ ret = sound_manager_activate_ducking(stream_ducking_h, 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 for %s", __get_ducking_stream(stream_type));
} else {
- SLOG(LOG_DEBUG, tts_tag(), "[Player] Not playing state");
+ SLOG(LOG_INFO, tts_tag(), "[Player SUCCESS] Activate ducking for %s", __get_ducking_stream(stream_type));
}
+ }
+ return ret;
+}
+
+static void __change_background_volume()
+{
+ SLOG(LOG_INFO, tts_tag(), "[Player] volume ratio(%lf)", g_bg_volume_ratio);
+ if (1.0 > g_bg_volume_ratio) {
+ __activate_ducking_sound_stream(SOUND_STREAM_TYPE_MEDIA, g_media_stream_ducking);
+ __activate_ducking_sound_stream(SOUND_STREAM_TYPE_SYSTEM, g_system_stream_ducking);
+ __activate_ducking_sound_stream(SOUND_STREAM_TYPE_NOTIFICATION, g_notification_stream_ducking);
+ __activate_ducking_sound_stream(SOUND_STREAM_TYPE_ALARM, g_alarm_stream_ducking);
+ }
+}
+
+static int __deactivate_ducking_sound_stream(sound_stream_type_e stream_type, sound_stream_ducking_h stream_ducking_h)
+{
+ bool is_ducked = false;
+ int ret = sound_manager_is_ducked(stream_ducking_h, &is_ducked);
+ if (!is_ducked) {
+ SLOG(LOG_DEBUG, tts_tag(), "[Player] The %s is already recovered from ducking", __get_ducking_stream(stream_type));
} else {
- SLOG(LOG_DEBUG, tts_tag(), "[Player] This is not Interrupt mode or not playing state.");
+ ret = sound_manager_deactivate_ducking(stream_ducking_h);
+ if (SOUND_MANAGER_ERROR_NONE != ret) {
+ SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to deactivate ducking for %s", __get_ducking_stream(stream_type));
+ } else {
+ SLOG(LOG_INFO, tts_tag(), "[Player SUCCESS] Deactivate ducking for %s", __get_ducking_stream(stream_type));
+ }
}
+ return ret;
+}
- return;
+static void __recover_background_volume()
+{
+ __deactivate_ducking_sound_stream(SOUND_STREAM_TYPE_MEDIA, g_media_stream_ducking);
+ __deactivate_ducking_sound_stream(SOUND_STREAM_TYPE_SYSTEM, g_system_stream_ducking);
+ __deactivate_ducking_sound_stream(SOUND_STREAM_TYPE_NOTIFICATION, g_notification_stream_ducking);
+ __deactivate_ducking_sound_stream(SOUND_STREAM_TYPE_ALARM, g_alarm_stream_ducking);
}
static int __create_audio_out(ttse_audio_type_e type, int rate)
static void __set_policy_for_playing(int volume)
{
+
+ __change_background_volume();
+
/* Set stream info */
int ret;
ttsd_mode_e mode = ttsd_get_mode();
}
}
+ __recover_background_volume();
+
SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] 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();
-
+ ttsd_data_clear_sound_data(&sound_data);
return;
}
SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid");
/* unset volume policy, volume will be 100% */
__unset_policy_for_playing();
+ ttsd_data_clear_sound_data(&sound_data);
return;
}
}
}
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);
+ ttsd_data_clear_sound_data(&sound_data);
continue;
}
}
/* unset volume policy, volume will be 100% */
__unset_policy_for_playing();
- ttsd_data_clear_sound_data(player->uid, &sound_data);
+ ttsd_data_clear_sound_data(&sound_data);
return;
}
/* unset volume policy, volume will be 100% */
__unset_policy_for_playing();
- ttsd_data_clear_sound_data(player->uid, &sound_data);
+ ttsd_data_clear_sound_data(&sound_data);
return;
}
/* unset volume policy, volume will be 100% */
__unset_policy_for_playing();
- ttsd_data_clear_sound_data(player->uid, &sound_data);
+ ttsd_data_clear_sound_data(&sound_data);
return;
}
SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Unprepare audio");
}
- ttsd_data_clear_sound_data(player->uid, &sound_data);
/* unset volume policy, volume will be 100% */
__unset_policy_for_playing();
+ ttsd_data_clear_sound_data(&sound_data);
return;
}
SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid");
/* unset volume policy, volume will be 100% */
__unset_policy_for_playing();
-
+ ttsd_data_clear_sound_data(&sound_data);
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);
+ ttsd_data_clear_sound_data(&sound_data);
return;
}
SLOG(LOG_INFO, tts_tag(), "[Player] Finish utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id);
}
- ttsd_data_clear_sound_data(player->uid, &sound_data);
+ ttsd_data_clear_sound_data(&sound_data);
if (NULL == g_playing_info) {
SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Current player is NULL");
}
/* unset volume policy, volume will be 100% */
__unset_policy_for_playing();
-
+ ttsd_data_clear_sound_data(&sound_data);
return;
}
}
}
+int __create_ducking_handle(void)
+{
+ int ret = -1;
+ if (NULL == g_media_stream_ducking) {
+ ret = sound_manager_create_stream_ducking(SOUND_STREAM_TYPE_MEDIA, __sound_stream_ducking_state_changed_cb, NULL, &g_media_stream_ducking);
+ if (SOUND_MANAGER_ERROR_NONE != ret)
+ SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to create stream ducking for type media, ret(%d)", ret);
+ } else {
+ SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for media stream is already created");
+ }
+ if (NULL == g_system_stream_ducking) {
+ ret = sound_manager_create_stream_ducking(SOUND_TYPE_SYSTEM, __sound_stream_ducking_state_changed_cb, NULL, &g_system_stream_ducking);
+ if (SOUND_MANAGER_ERROR_NONE != ret)
+ SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to create stream ducking for system type, ret(%d)", ret);
+ } else {
+ SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for system stream is already created");
+ }
+
+ if (NULL == g_notification_stream_ducking) {
+ ret = sound_manager_create_stream_ducking(SOUND_TYPE_NOTIFICATION, __sound_stream_ducking_state_changed_cb, NULL, &g_notification_stream_ducking);
+ if (SOUND_MANAGER_ERROR_NONE != ret)
+ SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to create stream ducking for notification type, ret(%d)", ret);
+ } else {
+ SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for notification stream is already created");
+ }
+
+ if (NULL == g_alarm_stream_ducking) {
+ ret = sound_manager_create_stream_ducking(SOUND_TYPE_ALARM, __sound_stream_ducking_state_changed_cb, NULL, &g_alarm_stream_ducking);
+ if (SOUND_MANAGER_ERROR_NONE != ret)
+ SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to create stream ducking for alarm type, ret(%d)", ret);
+ } else {
+ SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for alarm stream is already created");
+ }
+
+ return ret;
+}
+
/*
* Player Interfaces
*/
SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Add sound focus watch callback");
}
+ ret = __create_ducking_handle();
+ if (SOUND_MANAGER_ERROR_NONE != ret) {
+ SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to create ducking handle, ret(%d)", ret);
+ } else {
+ SLOG(LOG_INFO, tts_tag(), "[Player SUCCESS] Create ducking handle");
+ }
+
ecore_thread_max_set(1);
ret = __create_audio_out(TTSE_AUDIO_TYPE_RAW_S16, 16000);
return 0;
}
+int __destroy_ducking_handle(void)
+{
+ int ret = -1;
+ if (g_media_stream_ducking) {
+ ret = sound_manager_destroy_stream_ducking(g_media_stream_ducking);
+ if (SOUND_MANAGER_ERROR_NONE != ret)
+ SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to destroy media stream ducking, ret(%d)", ret);
+ g_media_stream_ducking = NULL;
+ } else {
+ SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for media stream is already created");
+ }
+
+ if (g_system_stream_ducking) {
+ ret = sound_manager_destroy_stream_ducking(g_system_stream_ducking);
+ if (SOUND_MANAGER_ERROR_NONE != ret)
+ SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to destroy system stream ducking, ret(%d)", ret);
+ g_system_stream_ducking = NULL;
+ } else {
+ SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for system stream is already created");
+ }
+
+ if (g_notification_stream_ducking) {
+ ret = sound_manager_destroy_stream_ducking(g_notification_stream_ducking);
+ if (SOUND_MANAGER_ERROR_NONE != ret)
+ SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to destroy notification stream ducking, ret(%d)", ret);
+ g_notification_stream_ducking = NULL;
+ } else {
+ SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for notification stream is already created");
+ }
+
+ if (g_alarm_stream_ducking) {
+ ret = sound_manager_destroy_stream_ducking(g_alarm_stream_ducking);
+ if (SOUND_MANAGER_ERROR_NONE != ret)
+ SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to destroy alarm stream ducking, ret(%d)", ret);
+ g_alarm_stream_ducking = NULL;
+ } else {
+ SLOG(LOG_INFO, tts_tag(), "[Player INFO] Ducking handle for alarm stream is already created");
+ }
+ return ret;
+}
+
int ttsd_player_release(void)
{
if (false == g_player_init) {
SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Remove the focus state watch cb");
}
+ ret = __destroy_ducking_handle();
+ if (SOUND_MANAGER_ERROR_NONE != ret)
+ SLOG(LOG_WARN, tts_tag(), "[Player WARNING] Fail to destroy stream ducking, ret(%d)", ret);
+ else
+ SLOG(LOG_DEBUG, tts_tag(), "[Player SUCCESS] Destroy stream ducking");
+
/* clear g_player_list */
g_playing_info = NULL;
g_player_init = false;
int ttsd_player_stop(int uid)
{
- if (false == g_player_init) {
- SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Not Initialized");
- return -1;
- }
-
- /* 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;
+ int ret = ttsd_player_clear(uid);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to stop player, ret(%d)", ret);
+ return ret;
}
/* check whether uid is current playing or not */
SLOG(LOG_DEBUG, tts_tag(), "[Player] No current playing");
}
- if (true == current->is_paused_data) {
- if (NULL != current->paused_data) {
- if (NULL != current->paused_data->data) {
- free(current->paused_data->data);
- current->paused_data->data = NULL;
- }
-
- free(current->paused_data);
- current->paused_data = NULL;
- }
- }
-
- current->event = TTSE_RESULT_EVENT_FINISH;
- current->state = APP_STATE_READY;
- current->is_paused_data = false;
- current->idx = 0;
-
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());
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;
+}
projects / platform / core / uifw / tts.git / blobdiff