fixup! move __IsReady function into the critical section
[platform/core/api/audio-io.git] / src / cpp / CPulseAudioClient.cpp
index 97be638..57750e4 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
git st* Copyright (c) 2015 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.
  */
 
 
-#include <mm.h>
 #include "CAudioIODef.h"
-
+#include <unistd.h>
+#include <inttypes.h>
+#include <string.h>
+#include <assert.h>
+#include <algorithm>
+#include <vector>
+
+#ifdef ENABLE_DPM
+#include <dpm/restriction.h>
+#endif
 
 using namespace std;
 using namespace tizen_media_audio;
 
+/**
+ * class CMainloopLocker
+ */
+CPulseAudioClient::CPulseThreadLocker::CPulseThreadLocker(pa_threaded_mainloop *mainloop) : ml(nullptr) {
+    if (!mainloop || pa_threaded_mainloop_in_thread(mainloop))
+        return;
+
+    pa_threaded_mainloop_lock(mainloop);
+    ml = mainloop;
+}
+
+CPulseAudioClient::CPulseThreadLocker::~CPulseThreadLocker() {
+    if (ml)
+        pa_threaded_mainloop_unlock(const_cast<pa_threaded_mainloop *>(ml));
+    ml = nullptr;
+}
 
 /**
  * class CPulseAudioClient
  */
 const char* CPulseAudioClient::CLIENT_NAME = "AUDIO_IO_PA_CLIENT";
+static constexpr auto drain_wait_interval = 10000;
+static constexpr auto drain_wait_max_count = 30;
 
 CPulseAudioClient::CPulseAudioClient(
         EStreamDirection      direction,
@@ -35,35 +61,43 @@ CPulseAudioClient::CPulseAudioClient(
     __mDirection(direction),
     __mSpec(spec),
     __mpListener(listener),
-    __mpMainloop(NULL),
-    __mpContext(NULL),
-    __mpStream(NULL),
-    __mpPropList(NULL),
+    __mpMainloop(nullptr),
+    __mpContext(nullptr),
+    __mpStream(nullptr),
+    __mpPropList(nullptr),
     __mIsInit(false),
     __mIsOperationSuccess(false),
-    __mpSyncReadDataPtr(NULL),
+    __mpSyncReadDataPtr(nullptr),
     __mSyncReadIndex(0),
     __mSyncReadLength(0),
-    __mIsUsedSyncRead(false) {
+    __mIsUsedSyncRead(false),
+    __mIsFirstStream(false),
+    __mIsDraining(false),
+    __mIsStarted(false) {
 }
 
 CPulseAudioClient::~CPulseAudioClient() {
-    finalize();
+    try {
+        finalize();
+    } catch (const CAudioError& e) {
+        AUDIO_IO_LOGE("%s", e.getErrorMsg()); //LCOV_EXCL_LINE
+    }
 }
 
 void CPulseAudioClient::__contextStateChangeCb(pa_context* c, void* user_data) {
-    CPulseAudioClient* pClient = static_cast<CPulseAudioClient*>(user_data);
+    auto pClient = static_cast<CPulseAudioClient*>(user_data);
     assert(pClient);
     assert(c);
 
     switch (pa_context_get_state(c)) {
     case PA_CONTEXT_READY:
-        AUDIO_IO_LOGD("The context is ready!");
+        AUDIO_IO_LOGD("pa_context[%p] is ready", c);
         pa_threaded_mainloop_signal(pClient->__mpMainloop, 0);
         break;
 
     case PA_CONTEXT_FAILED:
     case PA_CONTEXT_TERMINATED:
+        AUDIO_IO_LOGD("pa_context[%p] is lost", c);
         pa_threaded_mainloop_signal(pClient->__mpMainloop, 0);
         break;
 
@@ -75,32 +109,58 @@ void CPulseAudioClient::__contextStateChangeCb(pa_context* c, void* user_data) {
     }
 }
 
-void CPulseAudioClient::__successContextCb(pa_context* c, int success, void* user_data) {
-    AUDIO_IO_LOGD("pa_context[%p], success[%d], user_data[%p]", c, success, user_data);
-    assert(c);
-    assert(user_data);
-
-    CPulseAudioClient* pClient = static_cast<CPulseAudioClient*>(user_data);
-    pClient->__mIsOperationSuccess = static_cast<bool>(success);
+//LCOV_EXCL_START
+static bool __is_microphone_restricted(void) {
+    int state = 1;
+#ifdef ENABLE_DPM
+    device_policy_manager_h dpm_h = nullptr;
+    int ret = 0;
 
-    pa_threaded_mainloop_signal(pClient->__mpMainloop, 0);
+    if ((dpm_h = dpm_manager_create())) {
+        /* state: 0(disallowed), 1(allowed) */
+        if ((ret = dpm_restriction_get_microphone_state(dpm_h, &state)))
+            AUDIO_IO_LOGE("Failed to dpm_restriction_get_microphone_state(), ret(0x%x)", ret);
+        dpm_manager_destroy(dpm_h);
+        AUDIO_IO_LOGD("microphone restriction state: %d(1:allowed, 0:disallowed)", state);
+    } else {
+        AUDIO_IO_LOGE("Failed to dpm_manager_create()");
+    }
+#endif
+    return (state ? false : true);
 }
+//LCOV_EXCL_STOP
 
 void CPulseAudioClient::__streamStateChangeCb(pa_stream* s, void* user_data) {
     assert(s);
     assert(user_data);
 
-    CPulseAudioClient* pClient = static_cast<CPulseAudioClient*>(user_data);
+    auto pClient = static_cast<CPulseAudioClient*>(user_data);
 
     switch (pa_stream_get_state(s)) {
     case PA_STREAM_READY:
-        AUDIO_IO_LOGD("The stream is ready!");
+        AUDIO_IO_LOGD("The pa_stream[%p] is ready", s);
+        pClient->__mpListener->setState(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_RUNNING);
         pClient->__mpListener->onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_RUNNING);
+        if (pClient->__mDirection == EStreamDirection::STREAM_DIRECTION_PLAYBACK)
+            pClient->__mIsFirstStream = true;
+        pClient->__mIsInit = true;
         pa_threaded_mainloop_signal(pClient->__mpMainloop, 0);
         break;
 
+//LCOV_EXCL_START
     case PA_STREAM_FAILED:
+        AUDIO_IO_LOGD("The pa_stream[%p] is failed", s);
+        pClient->__mpListener->setState(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_IDLE);
+        pClient->__mpListener->onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_IDLE,
+                                              __is_microphone_restricted());
+        pa_threaded_mainloop_signal(pClient->__mpMainloop, 0);
+        break;
+//LCOV_EXCL_STOP
+
     case PA_STREAM_TERMINATED:
+        AUDIO_IO_LOGD("The pa_stream[%p] is terminated", s);
+        pClient->__mpListener->setState(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_IDLE);
+        pClient->__mpListener->onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_IDLE);
         pa_threaded_mainloop_signal(pClient->__mpMainloop, 0);
         break;
 
@@ -114,63 +174,154 @@ void CPulseAudioClient::__streamCaptureCb(pa_stream* s, size_t length, void* use
     assert(s);
     assert(user_data);
 
-    CPulseAudioClient* pClient = static_cast<CPulseAudioClient*>(user_data);
+    auto pClient = static_cast<CPulseAudioClient*>(user_data);
     assert(pClient->__mpListener);
     assert(pClient->__mpMainloop);
 
-    if (pClient->__mIsUsedSyncRead == true) {
+    if (pClient->__mIsUsedSyncRead)
         pa_threaded_mainloop_signal(pClient->__mpMainloop, 0);
-    }
 
     pClient->__mpListener->onStream(pClient, length);
 }
 
+static void __dummy_write(pa_stream* s, size_t length) {
+    pa_stream_write(s, std::vector<char>(length).data(), length, NULL, 0LL, PA_SEEK_RELATIVE);
+}
+
 void CPulseAudioClient::__streamPlaybackCb(pa_stream* s, size_t length, void* user_data) {
     assert(s);
     assert(user_data);
 
-    CPulseAudioClient* pClient = static_cast<CPulseAudioClient*>(user_data);
+    auto pClient = static_cast<CPulseAudioClient*>(user_data);
     assert(pClient->__mpListener);
 
-    if (pClient->__mIsInit == false) {
-        AUDIO_IO_LOGD("Occurred this listener when an out stream is on the way to create : Write dummy, length[%d]", length);
-
-        char* dummy = new char[length];
-        memset(dummy, 0, length);
-        pa_stream_write(s, dummy, length, NULL, 0LL, PA_SEEK_RELATIVE);
-        delete [] dummy;
-
+#ifndef DISABLE_MOBILE_BACK_COMP
+    if (!pClient->__mIsInit) {
+        AUDIO_IO_LOGD("pa_stream[%p] is on the way to create : Write dummy, length[%zu]", s, length);
+        __dummy_write(s, length);
+        return;
+    }
+    if (pClient->isCorked()) {
+        AUDIO_IO_LOGD("pa_stream[%p] is CORKED : Write dummy, length[%zu]", s, length);
+        __dummy_write(s, length);
         return;
     }
+#endif
 
     pClient->__mpListener->onStream(pClient, length);
+
+#ifndef DISABLE_MOBILE_BACK_COMP
+    /* If stream is not written in first callback during prepare,
+       then write dummy data to ensure the start */
+    if (pClient->__mSpec.getStreamLatency() == CPulseStreamSpec::EStreamLatency::STREAM_LATENCY_OUTPUT_DEFAULT_ASYNC &&
+        pClient->__mIsFirstStream) {
+        AUDIO_IO_LOGW("[async] pa_stream[%p] : not written in the first callback during prepare, write dummy of length[%zu]",
+                      s, length);
+        __dummy_write(s, length);
+        pClient->__mIsFirstStream = false;
+    }
+#endif
 }
 
 void CPulseAudioClient::__streamLatencyUpdateCb(pa_stream* s, void* user_data) {
     assert(s);
     assert(user_data);
 
-    CPulseAudioClient* pClient = static_cast<CPulseAudioClient*>(user_data);
+    auto pClient = static_cast<CPulseAudioClient*>(user_data);
+
+#ifdef _AUDIO_IO_DEBUG_TIMING_
+    /* FIXME : print some useful latency info */
+    AUDIO_IO_LOGD("pClient[%p] pa_stream[%p] latency updated", pClient, s);
+#endif
 
     pa_threaded_mainloop_signal(pClient->__mpMainloop, 0);
 }
 
+void CPulseAudioClient::__streamStartedCb(pa_stream* s, void* user_data) {
+    assert(s);
+    assert(user_data);
+
+    auto pClient = static_cast<CPulseAudioClient*>(user_data);
+
+    AUDIO_IO_LOGD("pClient[%p] pa_stream[%p] started", pClient, s);
+
+    pClient->__mIsStarted = true;
+}
+
+void CPulseAudioClient::__streamUnderflowCb(pa_stream* s, void* user_data) {
+    assert(s);
+    assert(user_data);
+
+    auto pClient = static_cast<CPulseAudioClient*>(user_data);
+
+    AUDIO_IO_LOGD("pClient[%p] pa_stream[%p] UnderFlow...", pClient, s);
+
+    pClient->__mIsStarted = false;
+}
+
+//LCOV_EXCL_START
+void CPulseAudioClient::__streamEventCb(pa_stream* s, const char *name, pa_proplist *pl, void *user_data) {
+    assert(s);
+    assert(user_data);
+
+    auto pClient = static_cast<CPulseAudioClient*>(user_data);
+
+    AUDIO_IO_LOGW("pClient[%p] pa_stream[%p] : name[%s], proplist[%p]", pClient, s, name, pl);
+
+    if (strcmp(name, PA_STREAM_EVENT_POP_TIMEOUT) == 0)
+        pa_operation_unref(pa_stream_cork(pClient->__mpStream, 1, NULL, NULL));
+}
+//LCOV_EXCL_STOP
+
 void CPulseAudioClient::__successStreamCb(pa_stream* s, int success, void* user_data) {
-    AUDIO_IO_LOGD("pa_stream[%p], success[%d], user_data[%p]", s, success, user_data);
     assert(s);
     assert(user_data);
 
-    CPulseAudioClient* pClient = static_cast<CPulseAudioClient*>(user_data);
+    auto pClient = static_cast<CPulseAudioClient*>(user_data);
+
+    AUDIO_IO_LOGD("pClient[%p], pa_stream[%p], success[%d], user_data[%p]", pClient, s, success, user_data);
+
     pClient->__mIsOperationSuccess = static_cast<bool>(success);
 
+    /* FIXME : verify following action without any waitings */
     pa_threaded_mainloop_signal(pClient->__mpMainloop, 0);
 }
 
-void CPulseAudioClient::initialize() throw (CAudioError) {
-    AUDIO_IO_LOGD("");
-    if (__mIsInit == true) {
+//LCOV_EXCL_START
+void CPulseAudioClient::__successDrainCbInThread(pa_stream* s, int success, void* user_data) {
+    assert(s);
+    assert(user_data);
+
+    auto pClient = static_cast<CPulseAudioClient*>(user_data);
+
+    AUDIO_IO_LOGD("pClient[%p], pa_stream[%p], success[%d], user_data[%p]", pClient, s, success, user_data);
+
+    pClient->__mIsOperationSuccess = static_cast<bool>(success);
+    pClient->__mIsDraining = false;
+}
+//LCOV_EXCL_STOP
+
+void CPulseAudioClient::__successDrainCb(pa_stream* s, int success, void* user_data) {
+    assert(s);
+    assert(user_data);
+
+    auto pClient = static_cast<CPulseAudioClient*>(user_data);
+
+    AUDIO_IO_LOGD("pClient[%p], pa_stream[%p], success[%d], user_data[%p]", pClient, s, success, user_data);
+
+    pClient->__mIsOperationSuccess = static_cast<bool>(success);
+    pClient->__mIsDraining = false;
+
+    pa_threaded_mainloop_signal(pClient->__mpMainloop, 0);
+}
+
+void CPulseAudioClient::__successVolumeCb(pa_context *c, int success, void *user_data) {
+    AUDIO_IO_LOGD("pa_context[%p], success[%d], user_data[%p]", c, success, user_data);
+}
+
+void CPulseAudioClient::initialize() {
+    if (__mIsInit)
         return;
-    }
 
     int ret = 0;
     int err = 0;
@@ -178,52 +329,45 @@ void CPulseAudioClient::initialize() throw (CAudioError) {
     try {
         // Allocates PA proplist
         __mpPropList = pa_proplist_new();
-        if (__mpPropList == NULL) {
-            THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed pa_proplist_new()");
-        }
+        if (!__mpPropList)
+            THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed pa_proplist_new()"); //LCOV_EXCL_LINE
 
         // Adds values on proplist for delivery to PULSEAUDIO
-        char *streamType = NULL;
-        CAudioInfo::EAudioType audioType = __mSpec.getAudioInfo().getAudioType();
-        __mSpec.getAudioInfo().convertAudioType2StreamType(audioType, &streamType);
-        pa_proplist_sets(__mpPropList, PA_PROP_MEDIA_ROLE, streamType);
+        pa_proplist_sets(__mpPropList, PA_PROP_MEDIA_ROLE, __mSpec.getAudioInfo().getConvertedStreamType());
 
         int index = __mSpec.getAudioInfo().getAudioIndex();
-        if (index >= 0) {
+        if (index >= 0)
             pa_proplist_setf(__mpPropList, PA_PROP_MEDIA_PARENT_ID, "%u", (unsigned int) index);
-        }
 
         // Adds latency on proplist for delivery to PULSEAUDIO
-        AUDIO_IO_LOGD("LATENCY : %s[%d]", __mSpec.getStreamLatencyToString(), __mSpec.getStreamLatency());
+        AUDIO_IO_LOGD("LATENCY : %s[%d]", __mSpec.getStreamLatencyToString(), static_cast<int>(__mSpec.getStreamLatency()));
         pa_proplist_setf(__mpPropList, PA_PROP_MEDIA_TIZEN_AUDIO_LATENCY, "%s", __mSpec.getStreamLatencyToString());
 
         // Allocates PA mainloop
         __mpMainloop = pa_threaded_mainloop_new();
-        if (__mpMainloop == NULL) {
-            THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed pa_threaded_mainloop_new()");
-        }
+        if (!__mpMainloop)
+            THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed pa_threaded_mainloop_new()"); //LCOV_EXCL_LINE
 
         // Allocates PA context
         __mpContext = pa_context_new(pa_threaded_mainloop_get_api(__mpMainloop), CLIENT_NAME);
-        if (__mpContext == NULL) {
-            THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed pa_context_new()");
-        }
+        if (!__mpContext)
+            THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed pa_context_new()"); //LCOV_EXCL_LINE
 
         // Sets context state changed callback
         pa_context_set_state_callback(__mpContext, __contextStateChangeCb, this);
 
         // Connects this client with PA server
-        if (pa_context_connect(__mpContext, NULL, PA_CONTEXT_NOFLAGS, NULL) < 0) {
-            THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed pa_context_connect()");
-        }
+        if (pa_context_connect(__mpContext, NULL, PA_CONTEXT_NOFLAGS, NULL) < 0)
+            THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed pa_context_connect()"); //LCOV_EXCL_LINE
 
         // LOCK for synchronous connection
-        pa_threaded_mainloop_lock(__mpMainloop);
+        CPulseThreadLocker locker{__mpMainloop};
 
         // Start mainloop
         if (pa_threaded_mainloop_start(__mpMainloop) < 0) {
-            pa_threaded_mainloop_unlock(__mpMainloop);
+//LCOV_EXCL_START
             THROW_ERROR_MSG(CAudioError::EError::ERROR_FAILED_OPERATION, "Failed pa_threaded_mainloop_start()");
+//LCOV_EXCL_STOP
         }
 
         // Connection process is asynchronously
@@ -233,14 +377,15 @@ void CPulseAudioClient::initialize() throw (CAudioError) {
             pa_context_state_t state;
             state = pa_context_get_state(__mpContext);
 
-            if (state == PA_CONTEXT_READY) {
+            if (state == PA_CONTEXT_READY)
                 break;
-            }
 
             if (!PA_CONTEXT_IS_GOOD(state)) {
+//LCOV_EXCL_START
                 err = pa_context_errno(__mpContext);
-                pa_threaded_mainloop_unlock(__mpMainloop);
-                THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INTERNAL_OPERATION, "pa_context's state is not good : err[%d]", err);
+                THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INTERNAL_OPERATION,
+                                       "pa_context's state is not good : err[%d]", err);
+//LCOV_EXCL_STOP
             }
 
             /* Wait until the context is ready */
@@ -252,9 +397,10 @@ void CPulseAudioClient::initialize() throw (CAudioError) {
         pa_channel_map map  = __mSpec.getChannelMap();
 
         __mpStream = pa_stream_new_with_proplist(__mpContext, __mSpec.getStreamName(), &ss, &map, __mpPropList);
-        if (__mpStream == NULL) {
-            pa_threaded_mainloop_unlock(__mpMainloop);
+        if (!__mpStream) {
+//LCOV_EXCL_START
             THROW_ERROR_MSG(CAudioError::EError::ERROR_FAILED_OPERATION, "Failed pa_stream_new_with_proplist()");
+//LCOV_EXCL_STOP
         }
 
         // Sets stream callbacks
@@ -262,34 +408,46 @@ void CPulseAudioClient::initialize() throw (CAudioError) {
         pa_stream_set_read_callback(__mpStream, __streamCaptureCb, this);
         pa_stream_set_write_callback(__mpStream, __streamPlaybackCb, this);
         pa_stream_set_latency_update_callback(__mpStream, __streamLatencyUpdateCb, this);
+        pa_stream_set_event_callback(__mpStream, __streamEventCb, this);
+        if (__mDirection == EStreamDirection::STREAM_DIRECTION_PLAYBACK) {
+            pa_stream_set_started_callback(__mpStream, __streamStartedCb, this);
+            pa_stream_set_underflow_callback(__mpStream, __streamUnderflowCb, this);
+        }
 
         // Connect stream with PA Server
 
         if (__mDirection == EStreamDirection::STREAM_DIRECTION_PLAYBACK) {
-            pa_stream_flags_t flags = static_cast<pa_stream_flags_t>(
+            auto flags = static_cast<pa_stream_flags_t>(
                     PA_STREAM_INTERPOLATE_TIMING |
                     PA_STREAM_ADJUST_LATENCY     |
+#ifndef DISABLE_MOBILE_BACK_COMP
+                    PA_STREAM_START_CORKED       |
+#endif
                     PA_STREAM_AUTO_TIMING_UPDATE);
 
             ret = pa_stream_connect_playback(__mpStream, NULL, NULL, flags, NULL, NULL);
         } else {
-            pa_stream_flags_t flags = static_cast<pa_stream_flags_t>(
+            auto flags = static_cast<pa_stream_flags_t>(
                     PA_STREAM_INTERPOLATE_TIMING |
                     PA_STREAM_ADJUST_LATENCY     |
+#ifndef DISABLE_MOBILE_BACK_COMP
+                    PA_STREAM_START_CORKED       |
+#endif
                     PA_STREAM_AUTO_TIMING_UPDATE);
 
             ret = pa_stream_connect_record(__mpStream, NULL, NULL, flags);
         }
 
         if (ret != 0) {
+//LCOV_EXCL_START
             err = pa_context_errno(__mpContext);
-            pa_threaded_mainloop_unlock(__mpMainloop);
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_FAILED_OPERATION, "Failed pa_stream_connect() : err[%d]", err);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_FAILED_OPERATION,
+                                   "Failed pa_stream_connect() : err[%d]", err);
+//LCOV_EXCL_STOP
         }
 
         while (true) {
-            pa_stream_state_t state;
-            state = pa_stream_get_state(__mpStream);
+            pa_stream_state_t state = pa_stream_get_state(__mpStream);
 
             if (state == PA_STREAM_READY) {
                 AUDIO_IO_LOGD("STREAM READY");
@@ -298,73 +456,101 @@ void CPulseAudioClient::initialize() throw (CAudioError) {
 
             if (!PA_STREAM_IS_GOOD(state)) {
                 err = pa_context_errno(__mpContext);
-                pa_threaded_mainloop_unlock(__mpMainloop);
-                THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INTERNAL_OPERATION, "pa_stream's state is not good : err[%d]", err);
+                if (err == PA_ERR_ACCESS)
+                    THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_DEVICE_POLICY_RESTRICTION,
+                                           "pa_stream's state is not good : err[%d]", err);
+                else
+                    THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INTERNAL_OPERATION,   //LCOV_EXCL_LINE
+                                           "pa_stream's state is not good : err[%d]", err); //LCOV_EXCL_LINE
             }
 
             /* Wait until the stream is ready */
             pa_threaded_mainloop_wait(__mpMainloop);
         }
 
-        // End of synchronous
-        pa_threaded_mainloop_unlock(__mpMainloop);
-
-        __mIsInit = true;
-    } catch (CAudioError e) {
+        // __mIsInit = true;  // Moved to __streamStateChangeCb()
+    } catch (const CAudioError& e) {
+//LCOV_EXCL_START
         finalize();
-        throw e;
+        throw;
+//LCOV_EXCL_END
     }
+
+    AUDIO_IO_LOGD("Done : pa_context[%p], pa_mainloop[%p], pa_stream[%p]", __mpContext, __mpMainloop, __mpStream);
 }
 
 void CPulseAudioClient::finalize() {
-    AUDIO_IO_LOGD("");
-    if (__mIsInit == false) {
+    AUDIO_IO_LOGD("pa_context[%p], pa_mainloop[%p], pa_stream[%p]", __mpContext, __mpMainloop, __mpStream);
+
+    if (!__mpMainloop)
         return;
+
+    bool is_in_thread = isInThread();
+    if (!is_in_thread)
+        pa_threaded_mainloop_lock(__mpMainloop);
+
+    __mIsInit = false;
+    /* clear callbacks */
+    if (__mpStream) {
+        if (__mDirection == EStreamDirection::STREAM_DIRECTION_PLAYBACK)
+            pa_stream_set_write_callback(__mpStream, NULL, NULL);
+        else
+            pa_stream_set_read_callback(__mpStream, NULL, NULL);
+        pa_stream_set_latency_update_callback(__mpStream, NULL, NULL);
+        pa_stream_set_event_callback(__mpStream, NULL, NULL);
     }
 
-    if (__mpMainloop != NULL) {
-        pa_threaded_mainloop_stop(__mpMainloop);
+    if (!is_in_thread)
+        pa_threaded_mainloop_unlock(__mpMainloop);
+
+    /* Wait for drain complete if draining before finalize */
+    if (__mIsDraining) {
+        unsigned int drain_wait_count = 0;
+        while (__mIsDraining && drain_wait_count++ < drain_wait_max_count)
+            usleep(drain_wait_interval);
+        AUDIO_IO_LOGD("wait for drain complete!!!! [%d * %d usec]",
+                      drain_wait_count, drain_wait_interval);
     }
 
-    if (__mpStream != NULL) {
+    if (__mpMainloop)
+        pa_threaded_mainloop_stop(__mpMainloop);
+
+    if (__mpStream) {
         pa_stream_disconnect(__mpStream);
         pa_stream_unref(__mpStream);
-        __mpStream = NULL;
+        __mpStream = nullptr;
     }
 
-    if (__mpContext != NULL) {
+    if (__mpContext) {
         pa_context_disconnect(__mpContext);
         pa_context_unref(__mpContext);
-        __mpContext = NULL;
+        __mpContext = nullptr;
     }
 
-    if (__mpMainloop != NULL) {
+    if (__mpMainloop) {
         pa_threaded_mainloop_free(__mpMainloop);
-        __mpMainloop = NULL;
+        __mpMainloop = nullptr;
     }
 
-    if (__mpPropList != NULL) {
+    if (__mpPropList) {
         pa_proplist_free(__mpPropList);
-        __mpPropList = NULL;
+        __mpPropList = nullptr;
     }
 
-    __mIsInit = false;
+    AUDIO_IO_LOGD("Done");
 }
 
-int CPulseAudioClient::read(void* buffer, size_t length) throw (CAudioError) {
-    if (__mIsInit == false) {
-        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
-    }
+int CPulseAudioClient::read(void* buffer, size_t length) {
+    if (!__mIsInit)
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "CPulseAudioClient is not initialized"); //LCOV_EXCL_LINE
 
     checkRunningState();
 
-    if (buffer == NULL) {
-        THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "The parameter is invalid : buffer[%p]", buffer);
-    }
+    if (!buffer)
+        THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "invalid parameter : buffer[%p]", buffer); //LCOV_EXCL_LINE
 
-    if (__mDirection == EStreamDirection::STREAM_DIRECTION_PLAYBACK) {
-        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_SUPPORTED, "The Playback client couldn't use this function");
-    }
+    if (__mDirection == EStreamDirection::STREAM_DIRECTION_PLAYBACK)
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_SUPPORTED, "playback client can't use this function"); //LCOV_EXCL_LINE
 
     size_t lengthIter = length;
     int ret = 0;
@@ -372,42 +558,38 @@ int CPulseAudioClient::read(void* buffer, size_t length) throw (CAudioError) {
     __mIsUsedSyncRead = true;
 
     try {
-        pa_threaded_mainloop_lock(__mpMainloop);
+        CPulseThreadLocker locker{__mpMainloop};
 
         while (lengthIter > 0) {
             size_t l;
 
-            while (__mpSyncReadDataPtr == NULL) {
+            while (!__mpSyncReadDataPtr) {
                 ret = pa_stream_peek(__mpStream, &__mpSyncReadDataPtr, &__mSyncReadLength);
-                if (ret != 0) {
-                    THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INTERNAL_OPERATION, "Failed pa_stream_peek() : ret[%d]", ret);
-                }
+                if (ret != 0)
+                    THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INTERNAL_OPERATION, "Failed pa_stream_peek() : ret[%d]", ret); //LCOV_EXCL_LINE
 
                 if (__mSyncReadLength <= 0) {
 #ifdef _AUDIO_IO_DEBUG_TIMING_
-                    AUDIO_IO_LOGD("readLength(%d byte) is not valid. wait...", __mSyncReadLength);
+                    AUDIO_IO_LOGD("readLength(%zu byte) is not valid. wait...", __mSyncReadLength);
 #endif
                     pa_threaded_mainloop_wait(__mpMainloop);
-                } else if (__mpSyncReadDataPtr == NULL) {
+                } else if (!__mpSyncReadDataPtr) {
+// LCOV_EXCL_START
                     // Data peeked, but it doesn't have any data
                     ret = pa_stream_drop(__mpStream);
-                    if (ret != 0) {
+                    if (ret != 0)
                         THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INTERNAL_OPERATION, "Failed pa_stream_drop() : ret[%d]", ret);
-                    }
+//LCOV_EXCL_STOP
                 } else {
                     __mSyncReadIndex = 0;
                 }
             }
 
-            if (__mSyncReadLength < lengthIter) {
-                l = __mSyncReadLength;
-            } else {
-                l = lengthIter;
-            }
+            l = min(__mSyncReadLength, lengthIter);
 
             // Copy partial pcm data on out parameter
 #ifdef _AUDIO_IO_DEBUG_TIMING_
-            AUDIO_IO_LOGD("memcpy() that a peeked buffer[%], index[%d], length[%d] on out buffer", (const uint8_t*)(__mpSyncReadDataPtr) + __mSyncReadIndex, __mSyncReadIndex, l);
+            AUDIO_IO_LOGD("memcpy() that a peeked buffer[%p], index[%zu], length[%zu] on out buffer", (const uint8_t*)(__mpSyncReadDataPtr) + __mSyncReadIndex, __mSyncReadIndex, l);
 #endif
             memcpy(buffer, (const uint8_t*)__mpSyncReadDataPtr + __mSyncReadIndex, l);
 
@@ -424,68 +606,59 @@ int CPulseAudioClient::read(void* buffer, size_t length) throw (CAudioError) {
                 AUDIO_IO_LOGD("__mSyncReadLength is zero, do drop()");
 #endif
                 ret = pa_stream_drop(__mpStream);
-                if (ret != 0) {
-                    THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INTERNAL_OPERATION, "Failed pa_stream_drop() : ret[%d]", ret);
-                }
+                if (ret != 0)
+                    THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INTERNAL_OPERATION, //LCOV_EXCL_LINE
+                                           "Failed pa_stream_drop() : ret[%d]", ret);     //LCOV_EXCL_LINE
 
                 // Reset the internal pointer
-                __mpSyncReadDataPtr = NULL;
+                __mpSyncReadDataPtr = nullptr;
                 __mSyncReadLength   = 0;
                 __mSyncReadIndex    = 0;
             }
         }  // End of while (lengthIter > 0)
 
-        pa_threaded_mainloop_unlock(__mpMainloop);
         __mIsUsedSyncRead = false;
-    } catch (CAudioError e) {
-        pa_threaded_mainloop_unlock(__mpMainloop);
+    } catch (const CAudioError& e) {
+// LCOV_EXCL_START
         __mIsUsedSyncRead = false;
-        throw e;
+        throw;
+// LCOV_EXCL_STOP
     }
 
     return length;
 }
 
-int CPulseAudioClient::peek(const void** buffer, size_t* length) throw (CAudioError) {
-    if (__mIsInit == false) {
-        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
-    }
+int CPulseAudioClient::peek(const void** buffer, size_t* length) {
+    if (!__mIsInit)
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "CPulseAudioClient is not initialized"); // LCOV_EXCL_LINE
 
     checkRunningState();
 
-    if (buffer == NULL || length == NULL) {
-        THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "The parameter is invalid : buffer[%p], length[%p]", buffer, length);
-    }
+    if (!buffer || !length)
+        THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT,                   // LCOV_EXCL_LINE
+                               "invalid parameter : buffer[%p], length[%p]", buffer, length); // LCOV_EXCL_LINE
 
-    if (__mDirection == EStreamDirection::STREAM_DIRECTION_PLAYBACK) {
-        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_SUPPORTED, "The Playback client couldn't use this function");
-    }
+    if (__mDirection == EStreamDirection::STREAM_DIRECTION_PLAYBACK)
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_SUPPORTED, "playback can't use this function"); // LCOV_EXCL_LINE
 
-    int ret = 0;
+    CPulseThreadLocker locker{__mpMainloop};
+
+    int ret = pa_stream_peek(__mpStream, buffer, length);
 
-    if (isInThread() == false) {
-        pa_threaded_mainloop_lock(__mpMainloop);
-        ret = pa_stream_peek(__mpStream, buffer, length);
-        pa_threaded_mainloop_unlock(__mpMainloop);
-    } else {
-        ret = pa_stream_peek(__mpStream, buffer, length);
-    }
 
 #ifdef _AUDIO_IO_DEBUG_TIMING_
-    AUDIO_IO_LOGD("buffer[%p], length[%d]", *buffer, *length);
+    AUDIO_IO_LOGD("buffer[%p], length[%zu]", *buffer, *length);
 #endif
 
-    if (ret < 0) {
-        THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_FAILED_OPERATION, "Failed pa_stream_peek() : err[%d]", ret);
-    }
+    if (ret < 0)
+        THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_FAILED_OPERATION, "Failed pa_stream_peek() : err[%d]", ret); //LCOV_EXCL_LINE
 
     return ret;
 }
 
-int CPulseAudioClient::drop() throw (CAudioError) {
-    if (__mIsInit == false) {
-        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
-    }
+int CPulseAudioClient::drop() {
+    if (!__mIsInit)
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "CPulseAudioClient is not initialized"); // LCOV_EXCL_LINE
 
 #ifdef _AUDIO_IO_DEBUG_TIMING_
     AUDIO_IO_LOGD("");
@@ -493,196 +666,199 @@ int CPulseAudioClient::drop() throw (CAudioError) {
 
     checkRunningState();
 
-    if (__mDirection == EStreamDirection::STREAM_DIRECTION_PLAYBACK) {
-        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_SUPPORTED, "The Playback client couldn't use this function");
-    }
+    if (__mDirection == EStreamDirection::STREAM_DIRECTION_PLAYBACK)
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_SUPPORTED, "playback can't use this function"); // LCOV_EXCL_LINE
 
-    int ret = 0;
+    CPulseThreadLocker locker{__mpMainloop};
 
-    if (isInThread() == false) {
-        pa_threaded_mainloop_lock(__mpMainloop);
-        ret = pa_stream_drop(__mpStream);
-        pa_threaded_mainloop_unlock(__mpMainloop);
-    } else {
-        ret = pa_stream_drop(__mpStream);
-    }
-
-    if (ret < 0) {
-        THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_FAILED_OPERATION, "Failed pa_stream_drop() : err[%d]", ret);
-    }
+    int ret = pa_stream_drop(__mpStream);
+    if (ret < 0)
+        THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_FAILED_OPERATION, "Failed pa_stream_drop() : err[%d]", ret); //LCOV_EXCL_LINE
 
     return ret;
 }
 
-int CPulseAudioClient::write(const void* data, size_t length) throw (CAudioError) {
-    if (__mIsInit == false) {
-        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
-    }
-
-    checkRunningState();
-
-    if (data == NULL) {
-        THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_ARGUMENT, "The parameter is invalid");
-    }
+int CPulseAudioClient::write(const void* data, size_t length) {
+    if (!data)
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_ARGUMENT, "invalid parameter"); // LCOV_EXCL_LINE
 
-    if (__mDirection == EStreamDirection::STREAM_DIRECTION_RECORD) {
-        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_SUPPORTED, "The Playback client couldn't use this function");
-    }
+    if (__mDirection == EStreamDirection::STREAM_DIRECTION_RECORD)
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_SUPPORTED, "playback can't use this function"); // LCOV_EXCL_LINE
 
     int ret = 0;
 
 #ifdef _AUDIO_IO_DEBUG_TIMING_
-    AUDIO_IO_LOGD("data[%p], length[%d]", data, length);
+    AUDIO_IO_LOGD("data[%p], length[%zu], First[%d]", data, length, __mIsFirstStream);
 #endif
 
-    if (isInThread() == false) {
-        pa_threaded_mainloop_lock(__mpMainloop);
+    if (!isInThread()) {
+        CPulseThreadLocker locker{__mpMainloop};
+        if (pa_stream_is_corked(__mpStream)) {
+            AUDIO_IO_LOGW("stream is corked...do uncork here first!!!!");
+            pa_operation_unref(pa_stream_cork(__mpStream, 0, NULL, this));
+        }
+
         ret = pa_stream_write(__mpStream, data, length, NULL, 0LL, PA_SEEK_RELATIVE);
-        pa_threaded_mainloop_unlock(__mpMainloop);
     } else {
+// LCOV_EXCL_START
+        if (pa_stream_is_corked(__mpStream)) {
+            AUDIO_IO_LOGW("stream is corked...do uncork here first!!!!");
+            pa_operation_unref(pa_stream_cork(__mpStream, 0, NULL, this));
+        }
+
+        if (__mIsFirstStream) {
+            const pa_buffer_attr* attr = pa_stream_get_buffer_attr(__mpStream);
+            uint32_t prebuf = attr->prebuf;
+            // Compensate amount of prebuf in first stream callback when audio-io use prebuf(-1)
+            // Because a stream will never start when an application wrote less than prebuf at first
+            if (length < prebuf)
+                __dummy_write(__mpStream, prebuf - length);
+
+            __mIsFirstStream = false;
+            AUDIO_IO_LOGW("FIRST STREAM CALLBACK : length[%zu], prebuf[%d], dummy[%zu]",
+                          length, prebuf, (length < prebuf) ? prebuf - length : 0);
+        }
         ret = pa_stream_write(__mpStream, data, length, NULL, 0LL, PA_SEEK_RELATIVE);
+// LCOV_EXCL_STOP
     }
 
-    if (ret < 0) {
-        THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_FAILED_OPERATION, "Failed pa_stream_write() : err[%d]", ret);
-    }
+    if (ret < 0)
+        THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_FAILED_OPERATION, "Failed pa_stream_write() : err[%d]", ret); //LCOV_EXCL_LINE
 
     return ret;
 }
 
-void CPulseAudioClient::cork(bool cork) throw (CAudioError) {
+void CPulseAudioClient::cork(bool cork) {
     AUDIO_IO_LOGD("cork[%d]", cork);
 
-    if (__mIsInit == false) {
-        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
-    }
+    if (!__mIsInit)
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "CPulseAudioClient is not initialized"); // LCOV_EXCL_LINE
 
-    if (isInThread() == true) {
-        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_SUPPORTED, "This operation is not supported in callback");
-    }
+    if (isInThread())
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_SUPPORTED, "This operation is not supported in callback"); // LCOV_EXCL_LINE
 
     checkRunningState();
 
-    if (isInThread() == false) {
-        pa_threaded_mainloop_lock(__mpMainloop);
-        pa_operation_unref(pa_stream_cork(__mpStream, static_cast<int>(cork), __successStreamCb, this));
-        pa_threaded_mainloop_unlock(__mpMainloop);
-    } else {
-        pa_operation_unref(pa_stream_cork(__mpStream, static_cast<int>(cork), __successStreamCb, this));
-    }
+    // Set __mIsFirstStream flag when uncork(resume) stream, because prebuf will be enable again
+    if (!cork)
+        __mIsFirstStream = true;
+
+    CPulseThreadLocker locker{__mpMainloop};
+
+    /* FIXME: wait for completion like drain? */
+    pa_operation_unref(pa_stream_cork(__mpStream, static_cast<int>(cork), __successStreamCb, this));
 
-    return;
 }
 
-bool CPulseAudioClient::isCorked() throw (CAudioError) {
-    if (__mIsInit == false) {
-        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
-    }
+bool CPulseAudioClient::isCorked() {
+    if (!__mIsInit)
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "CPulseAudioClient is not initialized"); // LCOV_EXCL_LINE
 
     checkRunningState();
 
-    int isCork = 0;
+    CPulseThreadLocker locker{__mpMainloop};
 
-    if (isInThread() == false) {
-        pa_threaded_mainloop_lock(__mpMainloop);
-        isCork = pa_stream_is_corked(__mpStream);
-        pa_threaded_mainloop_unlock(__mpMainloop);
-    } else {
-        isCork = pa_stream_is_corked(__mpStream);
-    }
+    int isCorked = pa_stream_is_corked(__mpStream);
 
-    AUDIO_IO_LOGD("isCork[%d]", isCork);
-    return static_cast<bool>(isCork);
+#ifdef _AUDIO_IO_DEBUG_TIMING_
+    AUDIO_IO_LOGD("isCorked[%d]", isCorked);
+#endif
+    return static_cast<bool>(isCorked);
 }
 
-bool CPulseAudioClient::drain() throw (CAudioError) {
-    AUDIO_IO_LOGD("drain");
+bool CPulseAudioClient::drain() {
+    if (!__mIsInit)
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "CPulseAudioClient is not initialized"); // LCOV_EXCL_LINE
+
+    checkRunningState();
 
-    if (__mIsInit == false) {
-        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
+    if (isCorked()) {
+        AUDIO_IO_LOGW("Corked...");
+        return true;
     }
 
-    checkRunningState();
+    if (__mIsDraining) {
+        AUDIO_IO_LOGW("already draining...");
+        return true;
+    }
 
-    if (isInThread() == false) {
-        pa_threaded_mainloop_lock(__mpMainloop);
-        pa_operation_unref(pa_stream_drain(__mpStream, __successStreamCb, this));
-        pa_threaded_mainloop_unlock(__mpMainloop);
+    if (!__mIsStarted) {
+        AUDIO_IO_LOGW("stream not started yet...skip drain");
+        return true;
+    }
+
+    if (!isInThread()) {
+        AUDIO_IO_LOGD("drain");
+        CPulseThreadLocker locker{__mpMainloop};
+
+        pa_operation* o = pa_stream_drain(__mpStream, __successDrainCb, this);
+        __mIsDraining = true;
+        while (pa_operation_get_state(o) == PA_OPERATION_RUNNING)
+            pa_threaded_mainloop_wait(__mpMainloop);
+        pa_operation_unref(o);
+
+        AUDIO_IO_LOGD("drain done");
     } else {
-        pa_operation_unref(pa_stream_drain(__mpStream, __successStreamCb, this));
+        AUDIO_IO_LOGD("drain in thread");
+        pa_operation_unref(pa_stream_drain(__mpStream, __successDrainCbInThread, this));
+        __mIsDraining = true;
     }
 
     return true;
 }
 
-bool CPulseAudioClient::flush() throw (CAudioError) {
-    AUDIO_IO_LOGD("flush");
-
-    if (__mIsInit == false) {
-        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
-    }
+bool CPulseAudioClient::flush() {
+    if (!__mIsInit)
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "CPulseAudioClient is not initialized"); // LCOV_EXCL_LINE
 
     checkRunningState();
 
-    if (isInThread() == false) {
-        pa_threaded_mainloop_lock(__mpMainloop);
-        pa_operation_unref(pa_stream_flush(__mpStream, __successStreamCb, this));
-        pa_threaded_mainloop_unlock(__mpMainloop);
-    } else {
-        pa_operation_unref(pa_stream_flush(__mpStream, __successStreamCb, this));
-    }
+    CPulseThreadLocker locker{__mpMainloop};
+
+    /* FIXME: wait for completion like drain? */
+    pa_operation_unref(pa_stream_flush(__mpStream, __successStreamCb, this));
 
     return true;
 }
 
-size_t CPulseAudioClient::getWritableSize() throw (CAudioError) {
-    if (__mIsInit == false) {
-        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
-    }
+size_t CPulseAudioClient::getWritableSize() {
+    if (!__mIsInit)
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "CPulseAudioClient is not initialized"); // LCOV_EXCL_LINE
 
     checkRunningState();
 
-    if (__mDirection != EStreamDirection::STREAM_DIRECTION_PLAYBACK) {
-        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_SUPPORTED, "This client is used for Playback");
-    }
-
-    size_t ret = 0;
+    if (__mDirection != EStreamDirection::STREAM_DIRECTION_PLAYBACK)
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_SUPPORTED, "This client is used for Playback"); // LCOV_EXCL_LINE
 
-    if (isInThread() == false) {
-        pa_threaded_mainloop_lock(__mpMainloop);
-        ret = pa_stream_writable_size(__mpStream);
-        pa_threaded_mainloop_unlock(__mpMainloop);
-    } else {
-        ret = pa_stream_writable_size(__mpStream);
-    }
+    CPulseThreadLocker locker{__mpMainloop};
 
-    return ret;
+    return pa_stream_writable_size(__mpStream);
 }
 
-void CPulseAudioClient::checkRunningState() throw (CAudioError) {
-    if (__mIsInit == false) {
-        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
-    }
+void CPulseAudioClient::checkRunningState() {
+    if (!__mpContext || !PA_CONTEXT_IS_GOOD(pa_context_get_state(__mpContext)))
+        THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_NOT_INITIALIZED,                       // LCOV_EXCL_LINE
+                               "The context[%p] is not created or not good state", __mpContext); // LCOV_EXCL_LINE
 
-    if (__mpContext == NULL || PA_CONTEXT_IS_GOOD(pa_context_get_state(__mpContext)) == 0) {
-        THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_NOT_INITIALIZED, "The context[%p] is not created or not good state", __mpContext);
-    }
-    if (__mpStream == NULL || PA_STREAM_IS_GOOD(pa_stream_get_state(__mpStream)) == 0) {
-        THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_NOT_INITIALIZED, "The stream[%p] is not created or not good state", __mpStream);
-    }
-    if (pa_context_get_state(__mpContext) != PA_CONTEXT_READY || pa_stream_get_state(__mpStream)   != PA_STREAM_READY) {
-        THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_NOT_INITIALIZED, "The context[%p] or stream[%p] state is not ready", __mpContext, __mpStream);
-    }
+    if (!__mpStream || !PA_STREAM_IS_GOOD(pa_stream_get_state(__mpStream)))
+        THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_NOT_INITIALIZED,                     // LCOV_EXCL_LINE
+                               "The stream[%p] is not created or not good state", __mpStream); // LCOV_EXCL_LINE
+
+    if (pa_context_get_state(__mpContext) != PA_CONTEXT_READY || pa_stream_get_state(__mpStream) != PA_STREAM_READY)
+        THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_NOT_INITIALIZED,                                   // LCOV_EXCL_LINE
+                               "The context[%p] or stream[%p] state is not ready", __mpContext, __mpStream); // LCOV_EXCL_LINE
 
 #ifdef _AUDIO_IO_DEBUG_TIMING_
     AUDIO_IO_LOGD("This client is running");
 #endif
 }
 
-bool CPulseAudioClient::isInThread() throw (CAudioError) {
-    if (__mIsInit == false) {
-        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
-    }
+bool CPulseAudioClient::isInThread() const {
+    if (!__mIsInit)
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "__mIsInit is null");
+
+    if (!__mpMainloop)
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "__mpMainloop is null");
 
     int ret = pa_threaded_mainloop_in_thread(__mpMainloop);
 
@@ -692,171 +868,131 @@ bool CPulseAudioClient::isInThread() throw (CAudioError) {
     return static_cast<bool>(ret);
 }
 
-size_t CPulseAudioClient::getReadableSize() throw (CAudioError) {
-    if (__mIsInit == false) {
-        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
-    }
+//LCOV_EXCL_START
+size_t CPulseAudioClient::getReadableSize() {
+    if (!__mIsInit)
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "CPulseAudioClient is not initialized");
 
     checkRunningState();
 
-    if (__mDirection != EStreamDirection::STREAM_DIRECTION_RECORD) {
+    if (__mDirection != EStreamDirection::STREAM_DIRECTION_RECORD)
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_SUPPORTED, "This client is used for Capture");
-    }
 
-    size_t ret = 0;
+    CPulseThreadLocker locker{__mpMainloop};
 
-    if (isInThread() == false) {
-        pa_threaded_mainloop_lock(__mpMainloop);
-        ret = pa_stream_writable_size(__mpStream);
-        pa_threaded_mainloop_unlock(__mpMainloop);
-    } else {
-        ret = pa_stream_writable_size(__mpStream);
-    }
-
-    return ret;
+    return pa_stream_readable_size(__mpStream);
 }
 
-size_t CPulseAudioClient::getBufferSize() throw (CAudioError) {
-    if (__mIsInit == false) {
-        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
-    }
+size_t CPulseAudioClient::getBufferSize() {
+    if (!__mIsInit)
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "CPulseAudioClient is not initialized");
 
     checkRunningState();
 
-    size_t ret = 0;
+    size_t buffer_size = 0;
+    CPulseThreadLocker locker{__mpMainloop};
 
-    try {
-        if (isInThread() == false) {
-            pa_threaded_mainloop_lock(__mpMainloop);
-        }
-
-        const pa_buffer_attr* attr = pa_stream_get_buffer_attr(__mpStream);
-        if (attr == NULL) {
-            int _err = pa_context_errno(__mpContext);
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_FAILED_OPERATION, "Failed pa_stream_get_buffer_attr() : err[%d]", _err);
-        }
-
-        if (__mDirection == EStreamDirection::STREAM_DIRECTION_PLAYBACK) {
-            ret = attr->tlength;
-            AUDIO_IO_LOGD("PLAYBACK buffer size[%d]", ret);
-        } else {
-            ret = attr->fragsize;
-            AUDIO_IO_LOGD("RECORD buffer size[%d]", ret);
-        }
-    } catch (CAudioError err) {
-        if (isInThread() == false) {
-            pa_threaded_mainloop_unlock(__mpMainloop);
-        }
-        throw err;
-    }
+    const pa_buffer_attr* attr = pa_stream_get_buffer_attr(__mpStream);
+    if (!attr)
+        THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_FAILED_OPERATION,
+                               "Failed pa_stream_get_buffer_attr() : err[%d]", pa_context_errno(__mpContext));
 
-    if (isInThread() == false) {
-        pa_threaded_mainloop_unlock(__mpMainloop);
+    if (__mDirection == EStreamDirection::STREAM_DIRECTION_PLAYBACK) {
+        buffer_size = attr->tlength;
+        AUDIO_IO_LOGD("PLAYBACK buffer size[%zu]", buffer_size);
+    } else {
+        buffer_size = attr->fragsize;
+        AUDIO_IO_LOGD("RECORD buffer size[%zu]", buffer_size);
     }
 
-    return ret;
+    return buffer_size;
 }
 
-pa_usec_t CPulseAudioClient::getLatency() throw (CAudioError) {
-    if (__mIsInit == false) {
-        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
-    }
+pa_usec_t CPulseAudioClient::getLatency() {
+    if (!__mIsInit)
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "CPulseAudioClient is not initialized");
 
     checkRunningState();
 
-    pa_usec_t ret = 0;
-    int negative  = 0;
+    pa_usec_t latency = 0;
+    int negative = 0;
 
-    if (isInThread() == false) {
-        if (pa_stream_get_latency(__mpStream, &ret, &negative) < 0) {
+    if (!isInThread()) {
+        if (pa_stream_get_latency(__mpStream, &latency, &negative) < 0) {
             int _err = pa_context_errno(__mpContext);
-            if (_err != PA_ERR_NODATA) {
-                THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_FAILED_OPERATION, "Failed pa_stream_get_latency() : err[%d]", _err);
-            }
+            if (_err != PA_ERR_NODATA)
+                THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_FAILED_OPERATION,
+                                       "Failed pa_stream_get_latency() : err[%d]", _err);
         }
-        return negative ? 0 : ret;
+        return negative ? 0 : latency;
     }
 
-    pa_threaded_mainloop_lock(__mpMainloop);
+    CPulseThreadLocker locker{__mpMainloop};
 
-    try {
-        while (true) {
-            if (pa_stream_get_latency(__mpStream, &ret, &negative) >= 0) {
-                break;
-            }
-
-            int _err = pa_context_errno(__mpContext);
-            if (_err != PA_ERR_NODATA) {
-                THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_FAILED_OPERATION, "Failed pa_stream_get_latency() : err[%d]", _err);
-            }
-
-            /* Wait until latency data is available again */
-            pa_threaded_mainloop_wait(__mpMainloop);
-        }
-    } catch (CAudioError e) {
-        pa_threaded_mainloop_unlock(__mpMainloop);
-        throw e;
+    while (pa_stream_get_latency(__mpStream, &latency, &negative) < 0) {
+        int _err = pa_context_errno(__mpContext);
+        if (_err != PA_ERR_NODATA)
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_FAILED_OPERATION,
+                                   "Failed pa_stream_get_latency() : err[%d]", _err);
+        /* Wait until latency data is available again */
+        pa_threaded_mainloop_wait(__mpMainloop);
     }
 
-    pa_threaded_mainloop_unlock(__mpMainloop);
-
-    return negative ? 0 : ret;
+    return negative ? 0 : latency;
 }
 
-pa_usec_t CPulseAudioClient::getFinalLatency() throw (CAudioError) {
-    if (__mIsInit == false) {
-        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
-    }
+pa_usec_t CPulseAudioClient::getFinalLatency() {
+    if (!__mIsInit)
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "CPulseAudioClient is not initialized");
 
     checkRunningState();
 
-    pa_usec_t ret = 0;
-    uint32_t  ver = 0;
+    pa_usec_t latency = 0;
 
-    try {
-        if (isInThread() == false) {
-            pa_threaded_mainloop_lock(__mpMainloop);
-        }
+    CPulseThreadLocker locker{__mpMainloop};
 
-        ver = pa_context_get_server_protocol_version(__mpContext);
-        if (ver >= 13) {
-            const pa_buffer_attr* buffer_attr = pa_stream_get_buffer_attr(__mpStream);
-            const pa_sample_spec* sample_spec = pa_stream_get_sample_spec(__mpStream);
-            const pa_timing_info* timing_info = pa_stream_get_timing_info(__mpStream);
+    uint32_t ver = pa_context_get_server_protocol_version(__mpContext);
+    if (ver < 13)
+        THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_NOT_SUPPORTED, "This version(ver.%d) is not supported", ver);
 
-            if (buffer_attr == NULL || sample_spec == NULL || timing_info == NULL) {
-                THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed to get buffer_attr[%p] or sample_spec[%p] or timing_info[%p] from a pa_stream",
-                        buffer_attr, sample_spec, timing_info);
-            }
+    const pa_buffer_attr* buffer_attr = pa_stream_get_buffer_attr(__mpStream);
+    const pa_sample_spec* sample_spec = pa_stream_get_sample_spec(__mpStream);
+    const pa_timing_info* timing_info = pa_stream_get_timing_info(__mpStream);
 
-            if (__mDirection == EStreamDirection::STREAM_DIRECTION_PLAYBACK) {
-                ret = (pa_bytes_to_usec(buffer_attr->tlength, sample_spec) + timing_info->configured_sink_usec);
-                AUDIO_IO_LOGD("FINAL PLAYBACK LATENCY[%d]", ret);
-            } else {
-                ret = (pa_bytes_to_usec(buffer_attr->fragsize, sample_spec) + timing_info->configured_source_usec);
-                AUDIO_IO_LOGD("FINAL RECORD LATENCY[%d]", ret);
-            }
-        } else {
-            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_NOT_SUPPORTED, "This version(ver.%d) is not supported", ver);
-        }
+    if (!buffer_attr || !sample_spec || !timing_info)
+        THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_OUT_OF_MEMORY,
+                "Failed to get buffer_attr[%p] or sample_spec[%p] or timing_info[%p] from a pa_stream",
+                buffer_attr, sample_spec, timing_info);
 
-        if (isInThread() == false) {
-            pa_threaded_mainloop_unlock(__mpMainloop);
-        }
-    } catch (CAudioError e) {
-        if (isInThread() == false) {
-            pa_threaded_mainloop_unlock(__mpMainloop);
-        }
-        throw e;
+    if (__mDirection == EStreamDirection::STREAM_DIRECTION_PLAYBACK) {
+        latency = (pa_bytes_to_usec(buffer_attr->tlength, sample_spec) + timing_info->configured_sink_usec);
+        AUDIO_IO_LOGD("FINAL PLAYBACK LATENCY[%" PRIu64 "]", latency);
+    } else {
+        latency = (pa_bytes_to_usec(buffer_attr->fragsize, sample_spec) + timing_info->configured_source_usec);
+        AUDIO_IO_LOGD("FINAL RECORD LATENCY[%" PRIu64 "]", latency);
     }
 
-    return ret;
+    return latency;
 }
+//LCOV_EXCL_STOP
 
-CPulseAudioClient::EStreamDirection CPulseAudioClient::getStreamDirection() {
-    return __mDirection;
-}
+void CPulseAudioClient::applyRecordVolume(double volume) {
+
+    if (!__mIsInit)
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "CPulseAudioClient is not initialized");
+
+    checkRunningState();
+
+    if (__mDirection != EStreamDirection::STREAM_DIRECTION_RECORD)
+        THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_SUPPORTED, "The Playback client can't use this function"); //LCOV_EXCL_LINE
+
+    CPulseThreadLocker locker{__mpMainloop};
+
+    pa_cvolume cv = { 0, };
+    pa_volume_t v = PA_VOLUME_NORM * volume;
+
+    pa_cvolume_set(&cv, __mSpec.getChannelMap().channels, v);
 
-CPulseStreamSpec CPulseAudioClient::getStreamSpec() {
-    return __mSpec;
+    pa_operation_unref(pa_context_set_source_output_volume(__mpContext,
+            pa_stream_get_index(__mpStream), &cv, __successVolumeCb, NULL));
 }