Use PlayerThread class to manage utterance playing thread

Change-Id: I7965754245c4f8422e19771483d63deb45015120
Signed-off-by: Suyeon Hwang <stom.hwang@samsung.com>

diff --git a/server/ttsd_player.cpp b/server/ttsd_player.cpp
index 975466ea461c8ca76430fc1666e1fba7b78b3274..ef07eb36b837e34ad28025823759b3064c3b4eca 100644 (file)
--- a/server/ttsd_player.cpp
+++ b/server/ttsd_player.cpp
@@ -11,9 +11,6 @@
 *  limitations under the License.
 */
 
-#include <Ecore.h>
-#include <pthread.h>
-
 #include "ttsd_main.h"
 #include "ttsd_player.h"
 #include "ttsd_data.h"
@@ -56,8 +53,6 @@ If you choose too big value, it may cause integer overflow issue.
 */
 #define SND_MGR_DUCKING_DURATION 500
 
-static pthread_mutex_t g_play_thread_mutex = PTHREAD_MUTEX_INITIALIZER;
-static pthread_cond_t g_play_thread_cond = PTHREAD_COND_INITIALIZER;
 
 static BackgroundVolume* g_background_volume = nullptr;
 static AudioStream* g_audio_stream = nullptr;
@@ -189,11 +184,6 @@ static void __focus_release_callback()
        return;
 }
 
-static void __end_play_thread(void *data, Ecore_Thread *thread)
-{
-       SLOG(LOG_ERROR, tts_tag(), "@@@ End thread");
-}
-
 static void __set_policy_for_playing(void)
 {
        const char* extra_info = NULL;
@@ -296,7 +286,7 @@ static int __notify_utterance_completed_event(unsigned int uid, int utt_id)
        return TTSD_ERROR_NONE;
 }
 
-static int __play_sound_data(unsigned int uid, sound_data_s* sound_data)
+static int __play_sound_data(PlayerThread* player, unsigned int uid, sound_data_s* sound_data)
 {
        if (TTSD_ERROR_NONE != g_audio_stream->setAudioFormat(sound_data->audio_type, sound_data->rate)) {
                SLOG(LOG_ERROR, tts_tag(), "[Player ERROR] Fail to create audio out");
@@ -348,7 +338,7 @@ static int __play_sound_data(unsigned int uid, sound_data_s* sound_data)
                        return TTSD_ERROR_INVALID_STATE;
                }
 
-               if (false == g_player_thread->isCurrentUid(uid)) {
+               if (false == player->isCurrentUid(uid)) {
                        return TTSD_ERROR_OPERATION_FAILED;
                }
        }
@@ -356,11 +346,11 @@ static int __play_sound_data(unsigned int uid, sound_data_s* sound_data)
        return TTSD_ERROR_NONE;
 }
 
-static void __wait_sound_data(unsigned int uid)
+static void __wait_sound_data(PlayerThread* player, unsigned int uid)
 {
        while (0 >= ttsd_data_get_sound_data_size(uid)) {
                usleep(10000);
-               if (false == g_player_thread->isCurrentUid(uid)) {
+               if (false == player->isCurrentUid(uid)) {
                        return;
                }
 
@@ -376,47 +366,30 @@ static void __wait_sound_data(unsigned int uid)
        }
 }
 
-static void __play_thread_old(void *data, Ecore_Thread *thread)
+static void __play_utterance_cb(PlayerThread* player, unsigned int uid)
 {
-       SLOG(LOG_DEBUG, tts_tag(), "@@@ Start thread");
-
-       unsigned int uid = g_player_thread->getCurrentUid();
-       sound_data_s* sound_data = nullptr;
-       int ret = -1;
-       while (1) { // 1st while(1)
-               if (false == g_player_thread->isCurrentUid(uid)) {
-                       SLOG(LOG_INFO, tts_tag(), "[Player INFO] uid is not played");
-                       g_audio_stream->unprepareAudioOut();
-                       __unset_policy_for_playing();
-                       return;
-               }
+       SLOG(LOG_DEBUG, tts_tag(), "[PLAYER] Start play utterance. uid(%u)", uid);
 
+       while (player->isCurrentUid(uid)) {
+               sound_data_s* sound_data = ttsd_data_get_first_sound_data(uid);
                if (ttsd_data_is_paused_data_existing(uid)) {
-                       /* Resume player */
-                       sound_data = ttsd_data_get_first_sound_data(uid);
                        ttsd_data_set_paused_data_existing(uid, false);
 
-                       if (NULL == sound_data) {
-                               g_audio_stream->unprepareAudioOut();
-                               __unset_policy_for_playing();
-                               return;
+                       if (nullptr == sound_data) {
+                               break;
                        }
                        __set_playing_status(true);
 
                        SLOG(LOG_INFO, tts_tag(), "[Player] Sound info : id(%d) data(%p) size(%d) audiotype(%d) rate(%d) event(%d)",
                                sound_data->utt_id, sound_data->data, sound_data->data_size, sound_data->audio_type, sound_data->rate, sound_data->event);
                } else { // NO player->is_paused_data
-                       sound_data = ttsd_data_get_first_sound_data(uid);
                        if (nullptr == sound_data) {
-                               /* empty queue */
                                SLOG(LOG_ERROR, tts_tag(), "[Player] No sound data. Waiting mode");
 
-                               __wait_sound_data(uid);
-                               if (false == g_player_thread->isCurrentUid(uid)) {
+                               __wait_sound_data(player, uid);
+                               if (false == player->isCurrentUid(uid)) {
                                        SLOG(LOG_INFO, tts_tag(), "[Player] Finish thread");
-                                       g_audio_stream->unprepareAudioOut();
-                                       __unset_policy_for_playing();
-                                       return;
+                                       break;
                                }
 
                                SLOG(LOG_INFO, tts_tag(), "[Player] Finish to wait for new audio data come");
@@ -432,16 +405,14 @@ static void __play_thread_old(void *data, Ecore_Thread *thread)
                        if (TTSE_RESULT_EVENT_START == sound_data->event || (TTSE_RESULT_EVENT_FINISH == last_event && TTSE_RESULT_EVENT_FINISH == sound_data->event)) {
                                int ret = __notify_utterance_started_event(uid, sound_data->utt_id);
                                if (TTSD_ERROR_INVALID_PARAMETER == ret) {
-                                       g_audio_stream->unprepareAudioOut();
-                                       __unset_policy_for_playing();
-                                       return;
+                                       break;
                                }
                        } // (TTSE_RESULT_EVENT_START == sound_data->event || (TTSE_RESULT_EVENT_FINISH == player->event && TTSE_RESULT_EVENT_FINISH == sound_data->event))
 
                        /* Save last event to check utterance start */
                        ttsd_data_set_last_sound_result_event(uid, sound_data->event);
 
-                       if (NULL == sound_data->data || 0 >= sound_data->data_size) {
+                       if (nullptr == sound_data->data || 0 >= sound_data->data_size) {
                                ttse_result_event_e event = sound_data->event;
                                int utt_id = sound_data->utt_id;
 
@@ -450,33 +421,26 @@ static void __play_thread_old(void *data, Ecore_Thread *thread)
                                }
                                sound_data = nullptr;
 
+                               SLOG(LOG_INFO, tts_tag(), "[Player] No Sound data. Event(%d), uid(%u), uttid(%d)", event, uid, utt_id);
                                if (TTSE_RESULT_EVENT_FINISH == event) {
-                                       SLOG(LOG_DEBUG, tts_tag(), "No sound data");
                                        __unset_policy_for_playing();
-
-                                       ret = __notify_utterance_completed_event(uid, utt_id);
-                                       if (TTSD_ERROR_INVALID_PARAMETER == ret) {
-                                               g_audio_stream->unprepareAudioOut();
-                                               return;
+                                       if (TTSD_ERROR_INVALID_PARAMETER == __notify_utterance_completed_event(uid, utt_id)) {
+                                               break;
                                        }
-                               } // TTSE_RESULT_EVENT_FINISH == event
-                               SLOG(LOG_INFO, tts_tag(), "[Player] Event(%d) utterance : uid(%u), uttid(%d)", event, uid, utt_id);
+                               }
+
                                continue;
                        } // (NULL == sound_data->data || 0 >= sound_data->data_size)
                } // NO player->is_paused_data
 
-               ret = __play_sound_data(uid, sound_data);
+               int ret = __play_sound_data(player, uid, sound_data);
                if (TTSD_ERROR_INVALID_STATE == ret) {
                        SLOG(LOG_DEBUG, tts_tag(), "[Player] Uid(%u) is paused", uid);
                        ttsd_data_set_paused_data_existing(uid, true);
-                       g_audio_stream->unprepareAudioOut();
-                       __unset_policy_for_playing();
-                       return;
+                       break;
                } else if (TTSD_ERROR_NONE != ret) {
                        SLOG(LOG_ERROR, tts_tag(), "[Player] Fail to play audio data. uid(%u)", uid);
-                       g_audio_stream->unprepareAudioOut();
-                       __unset_policy_for_playing();
-                       return;
+                       break;
                }
 
                ttse_result_event_e event = sound_data->event;
@@ -488,11 +452,9 @@ static void __play_thread_old(void *data, Ecore_Thread *thread)
                sound_data = nullptr;
 
                if (TTSE_RESULT_EVENT_FINISH == event) {
-                       ret = __notify_utterance_completed_event(uid, utt_id);
-                       if (TTSD_ERROR_NONE != ret) {
-                               g_audio_stream->unprepareAudioOut();
-                               __unset_policy_for_playing();
-                               return;
+                       __unset_policy_for_playing();
+                       if (TTSD_ERROR_NONE != __notify_utterance_completed_event(uid, utt_id)) {
+                               break;
                        }
                } // (TTSE_RESULT_EVENT_FINISH == event)
 
@@ -500,33 +462,18 @@ static void __play_thread_old(void *data, Ecore_Thread *thread)
                if (APP_STATE_READY == state) {
                        /* player_stop */
                        SLOG(LOG_DEBUG, tts_tag(), "[Player] Stop player thread");
+                       break;
+               } // (NULL == g_playing_info && APP_STATE_READY == player->state)
+       }
 
-                       /* Request prepare */
-                       g_audio_stream->unprepareAudioOut();
-                       /* unset volume policy, volume will be 100% */
-                       __unset_policy_for_playing();
-                       return;
-               } // (APP_STATE_READY == state)
-       } // end of 1st while(1)
-}
+       g_audio_stream->unprepareAudioOut();
+       __unset_policy_for_playing();
 
-static void __play_thread(void *data, Ecore_Thread *thread)
-{
-       SLOG(LOG_INFO, tts_tag(), "[Player] play thread is on");
-
-       while (g_player_init) {
-               SLOG(LOG_INFO, tts_tag(), "[Player] Wait play request...");
-               pthread_mutex_lock(&g_play_thread_mutex);
-               pthread_cond_wait(&g_play_thread_cond, &g_play_thread_mutex);
-               if (false == g_player_init) {
-                       SLOG(LOG_INFO, tts_tag(), "[Player] Player is released");
-                       pthread_mutex_unlock(&g_play_thread_mutex);
-                       break;
-               }
+#ifdef BUF_SAVE_MODE
+       __close_buffer_dump_file();
+#endif
 
-               __play_thread_old(data, thread);
-               pthread_mutex_unlock(&g_play_thread_mutex);
-       }
+       SLOG(LOG_DEBUG, tts_tag(), "[PLAYER] Finish play utterance. uid(%u)", uid);
 }
 
 /*
@@ -536,9 +483,7 @@ int ttsd_player_init()
 {
        g_background_volume = new BackgroundVolume(SND_MGR_DUCKING_DURATION);
        g_audio_stream = new AudioStream(__focus_release_callback);
-       g_player_thread = new PlayerThread(nullptr);
-
-       ecore_thread_run(__play_thread, __end_play_thread, NULL, NULL);
+       g_player_thread = new PlayerThread(__play_utterance_cb);
 
        g_is_set_policy = false;
        g_player_init = true;
@@ -558,39 +503,20 @@ int ttsd_player_release(void)
                return TTSD_ERROR_OPERATION_FAILED;
        }
 
-       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] @@@@@");
-
-       /* The thread should be released */
-       int thread_count = ecore_thread_active_get();
-       int count = 0;
-       while (0 < thread_count) {
-               usleep(10000);
-
-               count++;
-               if (20 == count) {
-                       SLOG(LOG_WARN, tts_tag(), "[Player WARNING!!] Thread is blocked. Player release continue.");
-                       break;
-               }
-
-               thread_count = ecore_thread_active_get();
-       }
-
        g_player_init = false;
        g_player_thread->requestStop();
-       pthread_cond_broadcast(&g_play_thread_cond);
        SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] Thread is released");
 
+       delete g_player_thread;
+       g_player_thread = nullptr;
+
        delete g_audio_stream;
        g_audio_stream = nullptr;
 
        delete g_background_volume;
        g_background_volume = nullptr;
 
-       delete g_player_thread;
-       g_player_thread = nullptr;
-
+       SLOG(LOG_INFO, tts_tag(), "[Player] ttsd_player_release succeed");
        return 0;
 }
 
@@ -619,7 +545,6 @@ int ttsd_player_play(unsigned int uid)
 
        SLOG(LOG_INFO, tts_tag(), "[Player] start play : uid(%u)", uid);
        g_player_thread->requestPlay(uid);
-       pthread_cond_broadcast(&g_play_thread_cond);
 
        return 0;
 }
@@ -633,11 +558,6 @@ int ttsd_player_stop(unsigned int uid)
 
        if (uid == g_player_thread->getCurrentUid()) {
                g_player_thread->requestStop();
-               pthread_cond_broadcast(&g_play_thread_cond);
-
-               pthread_mutex_lock(&g_play_thread_mutex);
-               SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
-               pthread_mutex_unlock(&g_play_thread_mutex);
        } else {
                SLOG(LOG_DEBUG, tts_tag(), "[Player] No current playing");
        }
@@ -672,10 +592,6 @@ int ttsd_player_pause(unsigned int uid)
        if (uid == g_player_thread->getCurrentUid()) {
                SLOG(LOG_DEBUG, tts_tag(), "[Player DEBUG] release current playing info (%u)", uid);
                g_player_thread->requestStop();
-
-               pthread_mutex_lock(&g_play_thread_mutex);
-               SLOG(LOG_ERROR, tts_tag(), "[Player] Active thread count : %d", ecore_thread_active_get());
-               pthread_mutex_unlock(&g_play_thread_mutex);
        }
 
 #ifdef BUF_SAVE_MODE
@@ -703,7 +619,6 @@ int ttsd_player_resume(unsigned int uid)
 
        SLOG(LOG_INFO, tts_tag(), "[Player] Resume to run thread");
        g_player_thread->requestPlay(uid);
-       pthread_cond_broadcast(&g_play_thread_cond);
 
        return 0;
 }