X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=server%2Fttsd_player.c;h=08b2c55bb3e8b79dc25afd7b1cf67b82dc89c455;hb=0f8703fbeb38dbf26dc2184c2d4b538b956954b3;hp=be47d3274a7839d07d664a4fc6efac8e3be19c30;hpb=b8400fd6bf189282f698043f4f62cb5c04d7a86b;p=platform%2Fcore%2Fuifw%2Ftts.git

diff --git a/server/ttsd_player.c b/server/ttsd_player.c
index be47d32..08b2c55 100644
--- a/server/ttsd_player.c
+++ b/server/ttsd_player.c
@@ -49,6 +49,18 @@ typedef struct {
 #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;
 
@@ -69,7 +81,19 @@ static audio_out_h g_audio_h;
 
 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
 */
@@ -110,28 +134,26 @@ void __player_focus_state_cb(sound_stream_info_h stream_info, sound_stream_focus
 	}
 	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());
 		}
@@ -183,40 +205,110 @@ void __player_focus_state_watch_cb(int id, sound_stream_focus_mask_e focus_mask,
 		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] current ducking stream(%s), volume ratio(%d)", __get_ducking_stream(stream_type), 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)
@@ -276,10 +368,17 @@ static int __destroy_audio_out()
 static void __end_play_thread(void *data, Ecore_Thread *thread)
 {
 	SLOG(LOG_ERROR, tts_tag(), "@@@ End thread");
+
+#ifdef BUF_SAVE_MODE
+	fclose(g_pFile);
+#endif
 }
 
 static void __set_policy_for_playing(int volume)
 {
+
+	__change_background_volume();
+
 	/* Set stream info */
 	int ret;
 	ttsd_mode_e mode = ttsd_get_mode();
@@ -333,6 +432,8 @@ static void __unset_policy_for_playing()
 		}
 	}
 
+	__recover_background_volume();
+
 	SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] unset policy for playing");
 
 	return;
@@ -351,7 +452,9 @@ int ttsd_player_check_current_playback_focus(bool *is_current_interrupt)
 
 		ret = sound_manager_get_current_playback_focus(&reason, &sound_behavior, &extra_info);
 
-		if (SOUND_MANAGER_ERROR_NONE == ret && NULL != 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;
@@ -378,6 +481,36 @@ static void __play_thread(void *data, Ecore_Thread *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");
 		return;
@@ -426,17 +559,6 @@ static void __play_thread(void *data, Ecore_Thread *thread)
 			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) {
@@ -444,18 +566,49 @@ static void __play_thread(void *data, Ecore_Thread *thread)
 					if (NULL == g_playing_info) {
 						/* current playing uid is replaced */
 						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_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();
+						}
+					}
 				}
 
 				SLOG(LOG_INFO, tts_tag(), "[Player] Finish to wait for new audio data come");
 
-				/* set volume policy as 40%, when resume play thread*/
-				__set_policy_for_playing(40);
+				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;
@@ -476,12 +629,6 @@ static void __play_thread(void *data, Ecore_Thread *thread)
 					/* unset volume policy, volume will be 100% */
 					__unset_policy_for_playing();
 
-					if (NULL != sound_data->data) {
-						free(sound_data->data);
-						sound_data->data = NULL;
-					}
-					free(sound_data);
-					sound_data = NULL;
 					return;
 				}
 
@@ -506,32 +653,26 @@ static void __play_thread(void *data, Ecore_Thread *thread)
 						SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid");
 						/* unset volume policy, volume will be 100% */
 						__unset_policy_for_playing();
-						if (NULL != sound_data->data) {
-							free(sound_data->data);
-							sound_data->data = NULL;
-						}
-						free(sound_data);
-						sound_data = NULL;
 						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_INFO, tts_tag(), "[Player] Finish utterance : uid(%d), uttid(%d)", player->uid, sound_data->utt_id);
-				if (NULL != sound_data->data) {
-					free(sound_data->data);
-					sound_data->data = NULL;
-				}
-				free(sound_data);
-				sound_data = NULL;
+				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();
 			}
@@ -541,16 +682,12 @@ static void __play_thread(void *data, Ecore_Thread *thread)
 				/* unset volume policy, volume will be 100% */
 				__unset_policy_for_playing();
 
-				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;
 			}
 
+			SLOG(LOG_INFO, tts_tag(), "[Player INFO] Success to destroy and recreate audio out");
 			__set_policy_for_playing(40);
 		}
 
@@ -573,13 +710,7 @@ static void __play_thread(void *data, Ecore_Thread *thread)
 					/* unset volume policy, volume will be 100% */
 					__unset_policy_for_playing();
 
-					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;
 				}
@@ -588,11 +719,18 @@ static void __play_thread(void *data, Ecore_Thread *thread)
 			}
 
 			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) {
@@ -605,27 +743,21 @@ static void __play_thread(void *data, Ecore_Thread *thread)
 				/* 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_INFO, tts_tag(), "[Player] Stop player thread by pause");
 
 				/* Request prepare */
@@ -654,15 +786,7 @@ static void __play_thread(void *data, Ecore_Thread *thread)
 				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;
@@ -677,13 +801,7 @@ static void __play_thread(void *data, Ecore_Thread *thread)
 				SLOG(LOG_WARN, tts_tag(), "[Send WARNIING] Current player is not valid");
 				/* unset volume policy, volume will be 100% */
 				__unset_policy_for_playing();
-				if (NULL != sound_data->data) {
-					free(sound_data->data);
-					sound_data->data = NULL;
-				}
 
-				free(sound_data);
-				sound_data = NULL;
 				return;
 			}
 
@@ -692,28 +810,15 @@ static void __play_thread(void *data, Ecore_Thread *thread)
 					pid, player->uid, sound_data->utt_id);
 				/* unset volume policy, volume will be 100% */
 				__unset_policy_for_playing();
-				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;
 			}
 
 			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");
@@ -730,6 +835,43 @@ static void __play_thread(void *data, Ecore_Thread *thread)
 	}
 }
 
+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
 */
@@ -773,6 +915,13 @@ int ttsd_player_init()
 		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);
@@ -787,6 +936,47 @@ int ttsd_player_init()
 	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) {
@@ -836,6 +1026,12 @@ int ttsd_player_release(void)
 		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;
@@ -1104,36 +1300,44 @@ int ttsd_player_pause(int uid)
 	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] @@@@@");
+	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] @@@@@");
 
-	/* The thread should be released */
-	int thread_count = ecore_thread_active_get();
-	int count = 0;
-	while (0 < thread_count) {
-		usleep(10000);
+		/* The thread should be released */
+		int thread_count = ecore_thread_active_get();
+		int count = 0;
+		while (0 < thread_count) {
+			usleep(10000);
 
-		count++;
-		if (30 == count) {
-			SLOG(LOG_WARN, tts_tag(), "[Player WARNING!!] Thread is blocked. Player release continue.");
-			break;
+			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);
 
@@ -1274,3 +1478,20 @@ int ttsd_player_play_pcm(int uid)
 	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;
+}