X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=server%2Fttsd_data.cpp;h=bb17c7d1c277a53178960c0adb7378fd29b58286;hb=3431de57d0bcd85982d78b1d304704fdf7ad3cad;hp=2d59d888b28d30474554861a959c159466c75e92;hpb=53d1f6701452b22c2b902e7de38b4081b35a8dd3;p=platform%2Fcore%2Fuifw%2Ftts.git

diff --git a/server/ttsd_data.cpp b/server/ttsd_data.cpp
index 2d59d88..bb17c7d 100644
--- a/server/ttsd_data.cpp
+++ b/server/ttsd_data.cpp
@@ -1,5 +1,5 @@
 /*
-*  Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved 
+*  Copyright (c) 2011-2016 Samsung Electronics Co., Ltd All Rights Reserved 
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
@@ -11,84 +11,149 @@
 *  limitations under the License.
 */
 
+#include <list>
+#include <pthread.h>
+#include <vector>
 
 #include "ttsd_main.h"
 #include "ttsd_data.h"
 
 using namespace std;
 
+typedef struct
+{
+	char*	lang;
+	int	vctype;
+}used_voice_s;
+
+typedef struct
+{
+	int		pid;
+	int		uid;
+	int		utt_id_stopped;
+	app_tts_state_e	state;
+
+	std::list<speak_data_s*> m_speak_data;
+	std::list<sound_data_s*> m_wav_data;
+
+	std::list<used_voice_s> m_used_voice;
+}app_data_s;
+
 static vector<app_data_s> g_app_list;
 
-static bool g_mutex_state = false;
+static pthread_mutex_t g_speak_data_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t g_sound_data_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+
+/* If engine is running */
+static ttsd_synthesis_control_e	g_synth_control;
 
 /*
 * functions for debug
 */
-
 int __data_show_list()
 {
 	int vsize = g_app_list.size();
 
-	SLOG(LOG_DEBUG, TAG_TTSD, "----- client list -----");
+	SLOG(LOG_DEBUG, tts_tag(), "----- client list -----");
 
-	for (int i=0; i<vsize; i++) {
-		SLOG(LOG_DEBUG, TAG_TTSD, "[%dth] pid(%d), uid(%d), state(%d) \n", i, g_app_list[i].pid, g_app_list[i].uid, g_app_list[i].state );
+	for (int i=0; i < vsize; i++) {
+		SECURE_SLOG(LOG_DEBUG, tts_tag(), "[%dth] pid(%d), uid(%d), state(%d)", i, g_app_list[i].pid, g_app_list[i].uid, g_app_list[i].state);
 	}
 
 	if (0 == vsize) {
-		SLOG(LOG_DEBUG, TAG_TTSD, "No Client \n");
+		SLOG(LOG_DEBUG, tts_tag(), "No Client");
 	}
 
-	SLOG(LOG_DEBUG, TAG_TTSD, "-----------------------");
+	SLOG(LOG_DEBUG, tts_tag(), "-----------------------");
+
 	return TTSD_ERROR_NONE;
 }
 
-int __data_show_sound_list(const int index)
+int __data_show_sound_list(int index)
 {
-	SLOG(LOG_DEBUG, TAG_TTSD, "----- Sound list -----");
-	
-	unsigned int i;
-	for (i=0 ; i < g_app_list[index].m_wav_data.size() ; i++) {
-		SLOG(LOG_DEBUG, TAG_TTSD, "[%dth] data size(%ld), uttid(%d), type(%d) \n", 
-			i+1, g_app_list[index].m_wav_data[i].data_size, g_app_list[index].m_wav_data[i].utt_id, g_app_list[index].m_wav_data[i].audio_type );
+	SLOG(LOG_DEBUG, tts_tag(), "----- Sound list -----");
+
+	unsigned int i = 0;
+	if (!g_app_list[index].m_wav_data.empty()) {
+		std::list<sound_data_s*>::iterator iter;
+		for (iter = g_app_list[index].m_wav_data.begin(); (NULL != *iter && iter != g_app_list[index].m_wav_data.end()); ++iter) {
+			SLOG(LOG_DEBUG, tts_tag(), "[%dth][%p] data(%p) data size(%d), uttid(%d), type(%d)",
+					i, *iter, (*iter)->data, (*iter)->data_size, (*iter)->utt_id, (*iter)->audio_type);
+			i++;
+		}
 	}
 
 	if (i == 0) {
-		SLOG(LOG_DEBUG, TAG_TTSD, "No Sound Data \n");
+		SLOG(LOG_DEBUG, tts_tag(), "No Sound Data");
 	}
 
-	SLOG(LOG_DEBUG, TAG_TTSD, "----------------------");
+	SLOG(LOG_DEBUG, tts_tag(), "----------------------");
 	return TTSD_ERROR_NONE;
 }
 
-int __data_show_text_list(const int index)
+int __data_show_text_list(int index)
 {
-	SLOG(LOG_DEBUG, TAG_TTSD, "----- Text list -----");
-
-	unsigned int i;
-	for (i=0 ; i< g_app_list[index].m_speak_data.size() ; i++) {
-		SLOG(LOG_DEBUG, TAG_TTSD, "[%dth] lang(%s), vctype(%d), speed(%d), uttid(%d), text(%s) \n", 
-				i+1, g_app_list[index].m_speak_data[i].lang, g_app_list[index].m_speak_data[i].vctype, g_app_list[index].m_speak_data[i].speed,
-				g_app_list[index].m_speak_data[i].utt_id, g_app_list[index].m_speak_data[i].text );	
+	SLOG(LOG_DEBUG, tts_tag(), "----- Text list -----");
+
+	unsigned int i = 0;
+	if (!g_app_list[index].m_speak_data.empty()) {
+		std::list<speak_data_s*>::iterator iter;
+		for (iter = g_app_list[index].m_speak_data.begin(); (NULL != *iter && iter != g_app_list[index].m_speak_data.end()); ++iter) {
+			SLOG(LOG_DEBUG, tts_tag(), "[%dth][%p] lang(%s), vctype(%d), speed(%d), uttid(%d), text(%s)", 
+					i + 1, *iter, (*iter)->lang, (*iter)->vctype, (*iter)->speed, (*iter)->utt_id, (*iter)->text);
+			i++;
+		}
 	}
 
 	if (0 == i) {
-		SLOG(LOG_DEBUG, TAG_TTSD, "No Text Data \n");
+		SLOG(LOG_DEBUG, tts_tag(), "No Text Data");
 	}
 
-	SLOG(LOG_DEBUG, TAG_TTSD, "---------------------");
+	SLOG(LOG_DEBUG, tts_tag(), "---------------------");
 	return TTSD_ERROR_NONE;
 }
 
+int __data_show_used_voice_list(int index)
+{
+	SLOG(LOG_DEBUG, tts_tag(), "----- Used voice list -----");
+
+	unsigned int i = 0;
+	if (!g_app_list[index].m_used_voice.empty()) {
+		std::list<used_voice_s>::iterator iter;
+		for (iter = g_app_list[index].m_used_voice.begin(); iter != g_app_list[index].m_used_voice.end(); ++iter) {
+			SLOG(LOG_DEBUG, tts_tag(), "[%dth] lang(%s), vctype(%d)", i + 1, iter->lang, iter->vctype);
+			i++;
+		}
+	}
+
+	if (0 == i) {
+		SLOG(LOG_DEBUG, tts_tag(), "No Voice Data");
+	}
+
+	SLOG(LOG_DEBUG, tts_tag(), "---------------------------");
+	return TTSD_ERROR_NONE;
+}
 
 /*
 * ttsd data functions
 */
 
-int ttsd_data_new_client(const int pid, const int uid)
+int ttsd_set_synth_control(ttsd_synthesis_control_e control)
+{
+	g_synth_control = control;
+	return 0;
+}
+
+ttsd_synthesis_control_e ttsd_get_synth_control()
+{
+	return g_synth_control;
+}
+
+int ttsd_data_new_client(int pid, int uid)
 {
 	if( -1 != ttsd_data_is_client(uid) ) {
-		SLOG(LOG_ERROR, TAG_TTSD, "[DATA ERROR] ttsd_data_new_client() : uid is not valid (%d)\n", uid);	
+		SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%d)", uid);
 		return TTSD_ERROR_INVALID_PARAMETER;
 	}
 
@@ -98,27 +163,27 @@ int ttsd_data_new_client(const int pid, const int uid)
 	app.utt_id_stopped = 0;
 	app.state = APP_STATE_READY;
 
-	g_app_list.insert( g_app_list.end(), app);
+	g_app_list.insert(g_app_list.end(), app);
 
 #ifdef DATA_DEBUG
 	__data_show_list();
-#endif 
+#endif
 	return TTSD_ERROR_NONE;
 }
 
-int ttsd_data_delete_client(const int uid)
+int ttsd_data_delete_client(int uid)
 {
 	int index = 0;
 
 	index = ttsd_data_is_client(uid);
-	
+
 	if (index < 0) {
-		SLOG(LOG_ERROR, TAG_TTSD, "[DATA ERROR] ttsd_data_delete_client() : uid is not valid (%d)\n", uid);	
+		SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%d)", uid);
 		return -1;
 	}
 
 	if (0 != ttsd_data_clear_data(uid)) {
-		SLOG(LOG_ERROR, TAG_TTSD, "[DATA ERROR] fail ttsd_data_clear_data()\n");
+		SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] Fail to clear data");
 		return -1;
 	}
 
@@ -126,17 +191,17 @@ int ttsd_data_delete_client(const int uid)
 
 #ifdef DATA_DEBUG
 	__data_show_list();
-#endif 
+#endif
 	return TTSD_ERROR_NONE;
 }
 
-int ttsd_data_is_client(const int uid)
+int ttsd_data_is_client(int uid)
 {
 	int vsize = g_app_list.size();
 
-	for (int i=0; i<vsize; i++) {
+	for (int i = 0; i < vsize; i++) {
 		if(g_app_list[i].uid == uid) {
-			return i;		
+			return i;
 		}
 	}
 
@@ -148,197 +213,449 @@ int ttsd_data_get_client_count()
 	return g_app_list.size();
 }
 
-int ttsd_data_get_pid(const int uid)
+int ttsd_data_get_pid(int uid)
 {
 	int index;
 
 	index = ttsd_data_is_client(uid);
-	
+
 	if (index < 0)	{
-		SLOG(LOG_ERROR, TAG_TTSD, "[DATA ERROR] ttsd_data_delete_client() : uid is not valid (%d)\n", uid);	
+		SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%d)", uid);
 		return TTSD_ERROR_INVALID_PARAMETER;
 	}
 
 	return g_app_list[index].pid;
 }
 
-int ttsd_data_get_speak_data_size(const int uid)
+int ttsd_data_get_speak_data_size(int uid)
 {
 	int index = 0;
 	index = ttsd_data_is_client(uid);
-	
+
 	if (index < 0) {
-		SLOG(LOG_ERROR, TAG_TTSD, "[DATA ERROR] ttsd_data_get_speak_data_size() : uid is not valid (%d)\n", uid);	
+		SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%d)", uid);
 		return TTSD_ERROR_INVALID_PARAMETER;
 	}
 
+	/* mutex is locked */
+	pthread_mutex_lock(&g_speak_data_mutex);
 	int size = g_app_list[index].m_speak_data.size();
+
+	/* mutex is unlocked */
+	pthread_mutex_unlock(&g_speak_data_mutex);
+
 	return size;
 }
 
-int ttsd_data_add_speak_data(const int uid, const speak_data_s data)
+int ttsd_data_set_used_voice(int uid, const char* lang, int type)
 {
 	int index = 0;
 	index = ttsd_data_is_client(uid);
 
 	if (index < 0) {
-		SLOG(LOG_ERROR, TAG_TTSD, "[DATA ERROR] ttsd_data_add_speak_data() : uid is not valid (%d)\n", uid);	
+		SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%d)", uid);
 		return TTSD_ERROR_INVALID_PARAMETER;
 	}
-	
-	g_app_list[index].m_speak_data.insert(g_app_list[index].m_speak_data.end(), data);
 
-	if (1 == data.utt_id)
-		g_app_list[index].utt_id_stopped = 0;
+	/* Find voice */
+	std::list<used_voice_s>::iterator iter;
+	if (!g_app_list[index].m_used_voice.empty()) {
+		for (iter = g_app_list[index].m_used_voice.begin(); iter != g_app_list[index].m_used_voice.end();++iter) {
+			if (0 == strcmp(lang, iter->lang) && type == iter->vctype) {
+				SLOG(LOG_DEBUG, tts_tag(), "[DATA] The voice is already registered (%s)(%d)", lang, type);
+				return 0;
+			}
+		}
+	}
+
+	/* Add voice */
+	used_voice_s used_voice;
+	used_voice.lang = strdup(lang);
+	used_voice.vctype = type;
+
+	try {
+		iter = g_app_list[index].m_used_voice.insert(g_app_list[index].m_used_voice.end(), used_voice);
+	} catch (const std::bad_alloc&) {
+		SLOG(LOG_ERROR, tts_tag(), "[DATA][ERROR] Fail to insert m_used_voice (bad_alloc)");
+		return -1;
+	}
+	SLOG(LOG_ERROR, tts_tag(), "[DATA] lang(%s), vctype(%d)", iter->lang, iter->vctype);
 
 #ifdef DATA_DEBUG
-	__data_show_text_list(index);
-#endif 
+	__data_show_used_voice_list(index);
+#endif
+
+	return -1;	/* Need to load voice*/
+}
+
+int ttsd_data_reset_used_voice(int uid, ttsd_used_voice_cb callback)
+{
+	int index = 0;
+	index = ttsd_data_is_client(uid);
+
+	if (index < 0) {
+		SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%d)", uid);
+		return TTSD_ERROR_INVALID_PARAMETER;
+	}
+
+	if (NULL == callback) {
+		SLOG(LOG_WARN, tts_tag(), "[DATA WARNING] Used voice callback is NULL");
+	}
+
+	/* Find voice */
+	if (!g_app_list[index].m_used_voice.empty()) {
+		std::list<used_voice_s>::iterator iter;
+
+		for (iter = g_app_list[index].m_used_voice.begin(); iter != g_app_list[index].m_used_voice.end(); ++iter) {
+			if (NULL != callback) {
+				callback(iter->lang, iter->vctype);
+			}
+
+			if (NULL != iter->lang) {
+				free(iter->lang);
+				iter->lang = NULL;
+			}
+		}
+
+		g_app_list[index].m_used_voice.clear();
+	}
+
+#ifdef DATA_DEBUG
+	__data_show_used_voice_list(index);
+#endif
+
 	return TTSD_ERROR_NONE;
 }
 
-int ttsd_data_get_speak_data(const int uid, speak_data_s* data)
+int ttsd_data_add_speak_data(int uid, speak_data_s* data)
 {
 	int index = 0;
 	index = ttsd_data_is_client(uid);
 
 	if (index < 0) {
-		SLOG(LOG_ERROR, TAG_TTSD, "[DATA ERROR] ttsd_data_get_speak_data() : uid is not valid(%d)\n", uid);	
+		SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%d)", uid);
 		return TTSD_ERROR_INVALID_PARAMETER;
 	}
 
-	if (0 == g_app_list[index].m_speak_data.size()) {
-		SLOG(LOG_WARN, TAG_TTSD, "[DATA WARNING] There is no speak data\n"); 
-		return -1;
+	/* mutex is locked */
+	pthread_mutex_lock(&g_speak_data_mutex);
+
+	std::list<speak_data_s*>::iterator iter;
+
+	try {
+		iter = g_app_list[index].m_speak_data.insert(g_app_list[index].m_speak_data.end(), data);
+	} catch (const std::bad_alloc&) {
+		SLOG(LOG_ERROR, tts_tag(), "[DATA][ERROR] Fail to insert m_speak_data (bad_alloc)");
+		pthread_mutex_unlock(&g_speak_data_mutex);
+
+		return TTSD_ERROR_OUT_OF_MEMORY;
 	}
+	SLOG(LOG_ERROR, tts_tag(), "[DATA][%p] utt_id(%d), text(%s), lang(%s), vctype(%d), speed(%d)", 
+			*iter, (*iter)->utt_id, (*iter)->text, (*iter)->lang, (*iter)->vctype, (*iter)->speed);
+
+	if (1 == data->utt_id)
+		g_app_list[index].utt_id_stopped = 0;
+
+#ifdef DATA_DEBUG
+	__data_show_text_list(index);
+#endif
+	pthread_mutex_unlock(&g_speak_data_mutex);
 
-	data->lang = g_strdup(g_app_list[index].m_speak_data[0].lang);
-	data->vctype = g_app_list[index].m_speak_data[0].vctype;
-	data->speed = g_app_list[index].m_speak_data[0].speed;
+	return TTSD_ERROR_NONE;
+}
 
-	data->text = g_app_list[index].m_speak_data[0].text;
-	data->utt_id = g_app_list[index].m_speak_data[0].utt_id;
+int __get_speak_data(int index, speak_data_s** data)
+{
+	if (0 == g_app_list[index].m_speak_data.size()) {
+#ifdef DATA_DEBUG
+		SLOG(LOG_WARN, tts_tag(), "[DATA WARNING] There is no speak data");
+#endif
+		return -1;
+	}
 
-	g_app_list[index].m_speak_data.erase(g_app_list[index].m_speak_data.begin());
+	if (!g_app_list[index].m_speak_data.empty()) {
+		std::list<speak_data_s*>::iterator iter = g_app_list[index].m_speak_data.begin();
+		*data = *iter;
+		g_app_list[index].m_speak_data.pop_front();
+	}
 
 #ifdef DATA_DEBUG
 	__data_show_text_list(index);
-#endif 
+#endif
+	return 0;
+}
+
+int ttsd_data_get_speak_data(int uid, speak_data_s** data)
+{
+	int index = 0;
+	index = ttsd_data_is_client(uid);
+
+	if (index < 0) {
+		SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid(%d)", uid);
+		return TTSD_ERROR_INVALID_PARAMETER;
+	}
+
+	/* mutex is locked */
+	pthread_mutex_lock(&g_speak_data_mutex);
+
+	if (0 != __get_speak_data(index, data)) {
+		SLOG(LOG_WARN, tts_tag(), "[DATA WARNING] There is no speak data");
+		pthread_mutex_unlock(&g_speak_data_mutex);
+		return -1;
+	}
+
+	pthread_mutex_unlock(&g_speak_data_mutex);
+
 	return TTSD_ERROR_NONE;
 }
 
-int ttsd_data_add_sound_data(const int uid, const sound_data_s data)
+int ttsd_data_add_sound_data(int uid, sound_data_s* data)
 {
 	int index = 0;
 	index = ttsd_data_is_client(uid);
 
 	if(index < 0) {
-		SLOG(LOG_ERROR, TAG_TTSD, "[DATA ERROR] ttsd_data_add_sound_data() : uid is not valid (%d)\n", uid);	
+		SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%d)", uid);
+		return TTSD_ERROR_INVALID_PARAMETER;
+	}
+
+	if (NULL == data) {
+		SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] sound data is NULL");
 		return TTSD_ERROR_INVALID_PARAMETER;
 	}
+	/* mutex is locked */
+	pthread_mutex_lock(&g_sound_data_mutex);
 
-	g_app_list[index].m_wav_data.insert(g_app_list[index].m_wav_data.end(), data);
+	std::list<sound_data_s*>::iterator iter;
+
+	try {
+		iter = g_app_list[index].m_wav_data.insert(g_app_list[index].m_wav_data.end(), data);
+	} catch (const std::bad_alloc&) {
+		SLOG(LOG_ERROR, tts_tag(), "[DATA][ERROR] Fail to insert m_sound_data (bad_alloc)");
+		pthread_mutex_unlock(&g_sound_data_mutex);
+
+		return TTSD_ERROR_OUT_OF_MEMORY;
+	}
+	SLOG(LOG_ERROR, tts_tag(), "[DATA][%p] utt_id(%d), data(%p) data size(%d), type(%d)", *iter, (*iter)->utt_id, (*iter)->data, (*iter)->data_size, (*iter)->audio_type);
 
 #ifdef DATA_DEBUG
 	__data_show_sound_list(index);
-#endif 
+#endif
+
+	/* mutex is unlocked */
+	pthread_mutex_unlock(&g_sound_data_mutex);
+
 	return TTSD_ERROR_NONE;
 }
 
-int ttsd_data_get_sound_data(const int uid, sound_data_s* data)
+int __get_sound_data(int index, sound_data_s** data)
+{
+	if (0 == g_app_list[index].m_wav_data.size()) {
+#ifdef DATA_DEBUG
+		SLOG(LOG_DEBUG, tts_tag(), "[DATA] There is no wav data");
+#endif
+		return -1;
+	}
+
+	if (!g_app_list[index].m_wav_data.empty()) {
+		std::list<sound_data_s*>::iterator iter = g_app_list[index].m_wav_data.begin();
+		*data = *iter;
+		g_app_list[index].m_wav_data.pop_front();
+	}
+
+#ifdef DATA_DEBUG
+	__data_show_sound_list(index);
+#endif
+	return 0;
+}
+
+int ttsd_data_get_sound_data(int uid, sound_data_s** data)
 {
 	int index = 0;
 	index = ttsd_data_is_client(uid);
 
+	SLOG(LOG_DEBUG, tts_tag(), "[DATA] sound_data_s: %p", *data);
+
 	if (index < 0)	{
-		SLOG(LOG_ERROR, TAG_TTSD, "[DATA ERROR] ttsd_data_get_sound_data() : uid is not valid (%d)\n", uid);	
+		SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%d)", uid);
 		return TTSD_ERROR_INVALID_PARAMETER;
 	}
 
-	if (0 == g_app_list[index].m_wav_data.size()) {
-		SLOG(LOG_WARN, TAG_TTSD, "[DATA WARNING] There is no wav data\n"); 
+	/* mutex is locked */
+	pthread_mutex_lock(&g_sound_data_mutex);
+
+	if (0 != __get_sound_data(index, data)) {
+		SLOG(LOG_DEBUG, tts_tag(), "[DATA] There is no wav data");
+		/* mutex is unlocked */
+		pthread_mutex_unlock(&g_sound_data_mutex);
 		return -1;
 	}
+	/* mutex is unlocked */
+	pthread_mutex_unlock(&g_sound_data_mutex);
 
-	data->data = g_app_list[index].m_wav_data[0].data;
-	data->data_size = g_app_list[index].m_wav_data[0].data_size;
-	data->utt_id = g_app_list[index].m_wav_data[0].utt_id;
-	data->audio_type = g_app_list[index].m_wav_data[0].audio_type;
-	data->rate = g_app_list[index].m_wav_data[0].rate;
-	data->channels = g_app_list[index].m_wav_data[0].channels;
-	data->event = g_app_list[index].m_wav_data[0].event;
-
-	g_app_list[index].m_wav_data.erase(g_app_list[index].m_wav_data.begin());
-
-#ifdef DATA_DEBUG
-	__data_show_sound_list(index);
-#endif 
 	return TTSD_ERROR_NONE;
 }
 
-int ttsd_data_get_sound_data_size(const int uid)
+int ttsd_data_get_sound_data_size(int uid)
 {
 	int index = 0;
+	int data_size = 0;
 	index = ttsd_data_is_client(uid);
 
 	if (index < 0)	{
-		SLOG(LOG_ERROR, TAG_TTSD, "[DATA ERROR] ttsd_data_get_sound_data_size() : uid is not valid (%d)\n", uid);	
+		SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%d)", uid);
 		return TTSD_ERROR_INVALID_PARAMETER;
 	}
 
-	return g_app_list[index].m_wav_data.size();
+	/* mutex is locked */
+	pthread_mutex_lock(&g_sound_data_mutex);
+	data_size = g_app_list[index].m_wav_data.size();
+
+	/* mutex is unlocked */
+	pthread_mutex_unlock(&g_sound_data_mutex);
+
+	return data_size;
+}
+
+int ttsd_data_clear_speak_data(int uid, speak_data_s** speak_data)
+{
+	pthread_mutex_lock(&g_speak_data_mutex);
+
+	int index = 0;
+	index = ttsd_data_is_client(uid);
+	if (index >= 0) {
+		if (!g_app_list[index].m_speak_data.empty()) {
+			if (NULL != *speak_data) {
+				SLOG(LOG_DEBUG, tts_tag(), "[DEBUG] utt(%d), text(%s), lang(%s), vctype(%d) speed(%d)", 
+						(*speak_data)->utt_id, (*speak_data)->text, (*speak_data)->lang, (*speak_data)->vctype, (*speak_data)->speed);
+
+				if (NULL != (*speak_data)->text) {
+					free((*speak_data)->text);
+					(*speak_data)->text = NULL;
+				}
+				if (NULL != (*speak_data)->lang) {
+					free((*speak_data)->lang);
+					(*speak_data)->lang = NULL;
+				}
+
+				free(*speak_data);
+				*speak_data = NULL;
+			}
+		}
+	}
+
+	pthread_mutex_unlock(&g_speak_data_mutex);
+
+	return TTSD_ERROR_NONE;
+}
+
+int ttsd_data_clear_sound_data(int uid, sound_data_s** sound_data)
+{
+	pthread_mutex_lock(&g_sound_data_mutex);
+
+	int index = 0;
+	index = ttsd_data_is_client(uid);
+	if (index >= 0) {
+		if (!g_app_list[index].m_wav_data.empty()) {
+			if (NULL != *sound_data) {
+				SLOG(LOG_ERROR, tts_tag(), "[DEBUG][%p] event(%d) data(%p) size(%d) rate(%d) utt(%d)", 
+						(*sound_data), (*sound_data)->event, (*sound_data)->data, (*sound_data)->data_size, (*sound_data)->rate, (*sound_data)->utt_id);
+
+				if (NULL != (*sound_data)->data) {
+					free((*sound_data)->data);
+					(*sound_data)->data = NULL;
+				}
+
+				free(*sound_data);
+				*sound_data = NULL;
+			}
+		}
+	}
+	pthread_mutex_unlock(&g_sound_data_mutex);
+
+	return TTSD_ERROR_NONE;
 }
 
-int ttsd_data_clear_data(const int uid)
+int ttsd_data_clear_data(int uid)
 {
 	int index = 0;
 
 	index = ttsd_data_is_client(uid);
 	if (index < 0) {
-		SLOG(LOG_ERROR, TAG_TTSD, "[DATA ERROR] ttsd_data_clear_data() : uid is not valid (%d)\n", uid);	
+		SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%d)", uid);
 		return TTSD_ERROR_INVALID_PARAMETER;
 	}
 
 	int removed_last_uttid = -1;
+	speak_data_s* temp_speak = NULL;
+	sound_data_s* temp_sound = NULL;
+
 	/* free allocated data */
+	pthread_mutex_lock(&g_speak_data_mutex);
 	while(1) {
-		speak_data_s temp;
-		if (0 != ttsd_data_get_speak_data(uid, &temp)) {
+		if (0 != __get_speak_data(index, &temp_speak)) {
 			break;
 		}
 
-		if (NULL != temp.text)	free(temp.text);
-		if (NULL != temp.lang)	free(temp.lang);
+		if (NULL != temp_speak) {
+			SLOG(LOG_DEBUG, tts_tag(), "[DEBUG] utt(%d), text(%s), lang(%s), vctype(%d) speed(%d)", 
+					temp_speak->utt_id, temp_speak->text, temp_speak->lang, temp_speak->vctype, temp_speak->speed);
 
-		removed_last_uttid = temp.utt_id;
+			if (NULL != temp_speak->text) {
+				free(temp_speak->text);
+				temp_speak->text = NULL;
+			}
+			if (NULL != temp_speak->lang) {
+				free(temp_speak->lang);
+				temp_speak->lang = NULL;
+			}
+			removed_last_uttid = temp_speak->utt_id;
+
+			free(temp_speak);
+			temp_speak = NULL;
+		}
 	}
 
 	if (-1 != removed_last_uttid) {
 		g_app_list[index].utt_id_stopped = removed_last_uttid;
 	}
 
+	g_app_list[index].m_speak_data.clear();
+	pthread_mutex_unlock(&g_speak_data_mutex);
+
+	pthread_mutex_lock(&g_sound_data_mutex);
 	while(1) {
-		sound_data_s temp;
-		if (0 != ttsd_data_get_sound_data(uid, &temp)) {
+		if (0 != __get_sound_data(index, &temp_sound)) {
 			break;
 		}
 
-		if (NULL != temp.data)	free(temp.data);
+		if (NULL != temp_sound) {
+			SLOG(LOG_ERROR, tts_tag(), "[DEBUG][%p] uid(%d), event(%d) data(%p) size(%d) rate(%d) utt(%d)", 
+				temp_sound, uid, temp_sound->event, temp_sound->data, temp_sound->data_size, temp_sound->rate, temp_sound->utt_id);
+
+			if (NULL != temp_sound->data) {
+				free(temp_sound->data);
+				temp_sound->data = NULL;
+			}
+
+			free(temp_sound);
+			temp_sound = NULL;
+		}
 	}
 
-	g_app_list[index].m_speak_data.clear();
 	g_app_list[index].m_wav_data.clear();
+	pthread_mutex_unlock(&g_sound_data_mutex);
 
 	return TTSD_ERROR_NONE;
 }
 
-int ttsd_data_get_client_state(const int uid, app_state_e* state)
+int ttsd_data_get_client_state(int uid, app_tts_state_e* state)
 {
 	int index = 0;
 
 	index = ttsd_data_is_client(uid);
 	if (index < 0)	{
-		SLOG(LOG_ERROR, TAG_TTSD, "[DATA ERROR] ttsd_data_get_client_state() : uid is not valid (%d)\n", uid);	
+		SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%d)", uid);
 		return TTSD_ERROR_INVALID_PARAMETER;
 	}
 
@@ -347,30 +664,22 @@ int ttsd_data_get_client_state(const int uid, app_state_e* state)
 	return TTSD_ERROR_NONE;
 }
 
-int ttsd_data_set_client_state(const int uid, const app_state_e state)
+int ttsd_data_set_client_state(int uid, app_tts_state_e state)
 {
 	int index = 0;
 
 	index = ttsd_data_is_client(uid);
 	if (index < 0)	{
-		SLOG(LOG_ERROR, TAG_TTSD, "[DATA ERROR] ttsd_data_set_client_state() : uid is not valid (%d)\n", uid);	
+		SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%d)", uid);
 		return TTSD_ERROR_INVALID_PARAMETER;
 	}
 
-	if (true == g_mutex_state) {
-		while(true == g_mutex_state)	{
-		}
-	}
-	
-	g_mutex_state = true;
-
 	/* The client of playing state of all clients is only one. need to check state. */
 	if (APP_STATE_PLAYING == state) {
 		int vsize = g_app_list.size();
-		for (int i=0 ; i<vsize ; i++) {
+		for (int i = 0; i < vsize; i++) {
 			if(g_app_list[i].state == APP_STATE_PLAYING) {
-				SLOG(LOG_ERROR, TAG_TTSD, "[DATA ERROR] ttsd_data_set_client_state() : a playing client has already existed. \n");	
-				g_mutex_state = false;
+				SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] A playing client has already existed.");
 				return -1;
 			}
 		}
@@ -378,8 +687,6 @@ int ttsd_data_set_client_state(const int uid, const app_state_e state)
 
 	g_app_list[index].state = state;
 
-	g_mutex_state = false;
-
 	return TTSD_ERROR_NONE;
 }
 
@@ -387,32 +694,53 @@ int ttsd_data_get_current_playing()
 {
 	int vsize = g_app_list.size();
 
-	for (int i=0; i<vsize; i++) {
+	for (int i = 0; i < vsize; i++) {
 		if (APP_STATE_PLAYING == g_app_list[i].state) {
+			SLOG(LOG_DEBUG, tts_tag(), "[DATA] uid(%d) is playing", g_app_list[i].uid);
 			return g_app_list[i].uid;
 		}
 	}
 
-	SLOG(LOG_DEBUG, TAG_TTSD, "[DATA] NO CURRENT PLAYING !!");	
-
 	return -1;
 }
 
 int ttsd_data_foreach_clients(ttsd_data_get_client_cb callback, void* user_data)
 {
 	if (NULL == callback) {
-		SLOG(LOG_ERROR, TAG_TTSD, "[DATA ERROR] input data is NULL!!");
+		SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] input data is NULL!!");
 		return -1;
 	}
 
+#ifdef DATA_DEBUG
+	__data_show_list();
+#endif
+
+	/* Copy app info */
+	vector<app_data_s> temp_app_list;
 	int vsize = g_app_list.size();
 
-	for (int i=0; i<vsize; i++) {
-		if (false == callback(g_app_list[i].pid, g_app_list[i].uid, g_app_list[i].state, user_data)) {
+	int i = 0;
+	for (i = 0;i < vsize;i++) {
+		app_data_s app;
+		app.pid = g_app_list[i].pid;
+		app.uid = g_app_list[i].uid;
+		app.utt_id_stopped = 0;
+		app.state = g_app_list[i].state;
+
+		temp_app_list.insert(temp_app_list.end(), app);
+	}
+
+	for (i = 0;i < vsize;i++) {
+		SECURE_SLOG(LOG_DEBUG, tts_tag(), "[%dth] pid(%d), uid(%d), state(%d)", i, temp_app_list[i].pid, temp_app_list[i].uid, temp_app_list[i].state);
+		if (false == callback(temp_app_list[i].pid, temp_app_list[i].uid, temp_app_list[i].state, user_data)) {
 			break;
 		}
 	}
-	
+
+	for (i = 0;i < vsize;i++) {
+		temp_app_list.erase(temp_app_list.begin());
+	}
+
 	return 0;
 }
 
@@ -422,8 +750,8 @@ bool ttsd_data_is_uttid_valid(int uid, int uttid)
 
 	index = ttsd_data_is_client(uid);
 	if (index < 0)	{
-		SLOG(LOG_ERROR, TAG_TTSD, "[DATA ERROR] ttsd_data_set_client_state() : uid is not valid (%d)\n", uid);	
-		return TTSD_ERROR_INVALID_PARAMETER;
+		SECURE_SLOG(LOG_ERROR, tts_tag(), "[DATA ERROR] uid is not valid (%d)", uid);
+		return false;
 	}
 
 	if (uttid < g_app_list[index].utt_id_stopped)
@@ -431,3 +759,91 @@ bool ttsd_data_is_uttid_valid(int uid, int uttid)
 
 	return true;
 }
+
+int ttsd_data_is_current_playing()
+{
+	int vsize = g_app_list.size();
+
+	for (int i = 0; i < vsize; i++) {
+		if(g_app_list[i].state == APP_STATE_PLAYING) {
+			return g_app_list[i].uid;
+		}
+	}
+
+	return -1;
+}
+
+int ttsd_data_get_same_pid_client_count(int pid)
+{
+	int vsize = g_app_list.size();
+	int number = 0;
+
+	for (int i = 0;i < vsize;i++) {
+		if(g_app_list[i].pid == pid) {
+			number++;
+		}
+	}
+
+	return number;
+}
+
+int ttsd_data_save_error_log(int uid, FILE* fp)
+{
+	int ret;
+	int pid;
+	/* pid */
+	pid = ttsd_data_get_pid(uid);
+	if (0 > pid) {
+		SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get pid");
+	} else {
+		fprintf(fp, "pid - %d", pid);
+	}
+	/* app state */
+	app_tts_state_e state;
+	ret = ttsd_data_get_client_state(uid, &state);
+	if (0 != ret) {
+		SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get app state");
+	} else {
+		fprintf(fp, "app state - %d", state);
+	}
+
+	int index = 0;
+	unsigned int i;
+
+	index = ttsd_data_is_client(uid);
+	if (0 > index) {
+		SLOG(LOG_ERROR, tts_tag(), "[ERROR] Invalid client");
+		return -1;
+	}
+
+	/* get sound data */
+	fprintf(fp, "----- Sound list -----");
+
+	i = 0;
+	if (!g_app_list[index].m_wav_data.empty()) {
+		std::list<sound_data_s*>::iterator iter;
+		for (iter = g_app_list[index].m_wav_data.begin(); (NULL != *iter && iter != g_app_list[index].m_wav_data.end()); ++iter) {
+			SLOG(LOG_DEBUG, tts_tag(), "[%dth][%p] data(%p) data size(%d), uttid(%d), type(%d)",
+					i, *iter, (*iter)->data, (*iter)->data_size, (*iter)->utt_id, (*iter)->audio_type);
+			i++;
+		}
+	}
+
+	fprintf(fp, "----------------------");
+
+	/* get speck data */
+	fprintf(fp, "----- Text list -----");
+
+	i = 0;
+	if (!g_app_list[index].m_speak_data.empty()) {
+		std::list<speak_data_s*>::iterator iter_speak;
+		for (iter_speak = g_app_list[index].m_speak_data.begin(); (NULL != *iter_speak && iter_speak != g_app_list[index].m_speak_data.end()); ++iter_speak) {
+			SLOG(LOG_DEBUG, tts_tag(), "[%dth][%p] lang(%s), vctype(%d), speed(%d), uttid(%d), text(%s)",
+					i, *iter_speak, (*iter_speak)->lang, (*iter_speak)->vctype, (*iter_speak)->speed, (*iter_speak)->utt_id, (*iter_speak)->text);
+			i++;
+		}
+	}
+	fprintf(fp, "---------------------");
+
+	return 0;
+}