Revise exception handling

- Use reference variable on catching exception
- Remove throw specification which mostly useless
- Add few more null checks
- Revise re-throw method
- Fix SVACE defects (WGID:13946)
- Add copy constructor for CAudioError class

[Version] 0.3.79
[Profile] Common
[Issue Type] Enhancement

Change-Id: Iadf4fcceaf0f4c07bf575f2809e16ab0cb60608d

diff --git a/include/CAudioError.h b/include/CAudioError.h
index 2b5fae90ce09fc8b4a1919273e9eec49c06a1df3..a18d0b0844f80a49ac9b4f28c01a36cdf31497bf 100644 (file)
--- a/include/CAudioError.h
+++ b/include/CAudioError.h
@@ -70,7 +70,7 @@ namespace tizen_media_audio {
         CAudioError(EError err);
         CAudioError(EError err, const char* fileName, const char* parentFunc, int lineNum);
         CAudioError(EError err, const char* msg, const char* fileName, const char* parentFunc, int lineNum);
-        //CAudioError(CAudioError& err);
+        CAudioError(const CAudioError& err);
         ~CAudioError();
 
         /* Static Methods */

diff --git a/include/CAudioIO.h b/include/CAudioIO.h
index ebfea6bc2c66ced55b23897ab5e5c0671fb21c9d..abfa359779a755a05fc1cf804261a018a1cb488a 100644 (file)
--- a/include/CAudioIO.h
+++ b/include/CAudioIO.h
@@ -62,44 +62,45 @@ namespace tizen_media_audio {
         virtual ~CAudioIO();
 
         /* Pure Virtual Methods */
-        virtual void initialize() throw(CAudioError) = 0;
+        virtual void initialize() = 0;
         virtual void finalize() = 0;
 
-        virtual void prepare() throw(CAudioError)   = 0;
-        virtual void unprepare() throw(CAudioError) = 0;
+        virtual void prepare() = 0;
+        virtual void unprepare() = 0;
 
-        virtual void pause() throw(CAudioError) = 0;
-        virtual void resume() throw(CAudioError) = 0;
+        virtual void pause() = 0;
+        virtual void resume() = 0;
 
-        virtual void drain() throw(CAudioError) = 0;
-        virtual void flush() throw(CAudioError) = 0;
+        virtual void drain() = 0;
+        virtual void flush() = 0;
 
-        virtual int  getBufferSize() throw(CAudioError) = 0;
+        virtual int  getBufferSize() = 0;
 
         /* Implemented Handlers */
         virtual void onStream(CPulseAudioClient* pClient, size_t length);
         virtual void onStateChanged(CAudioInfo::EAudioIOState state, bool byPolicy);
         virtual void onStateChanged(CAudioInfo::EAudioIOState state);
-        virtual void onInterrupt(CAudioSessionHandler* pHandler, int id, mm_sound_focus_type_e focus_type, mm_sound_focus_state_e state, const char *reason_for_change, const char *additional_info);
+        virtual void onInterrupt(CAudioSessionHandler* pHandler, int id, mm_sound_focus_type_e focus_type,
+                                 mm_sound_focus_state_e state, const char *reason_for_change, const char *additional_info);
         virtual void onSignal(CAudioSessionHandler* pHandler, mm_sound_signal_name_t signal, int value);
 
         /* Methods */
-        CAudioInfo& getAudioInfo() throw(CAudioError);
+        CAudioInfo& getAudioInfo();
 
-        virtual void setStreamCallback(SStreamCallback callback) throw(CAudioError);
-        SStreamCallback getStreamCallback() throw(CAudioError);
+        virtual void setStreamCallback(SStreamCallback callback);
+        SStreamCallback getStreamCallback();
 
-        virtual void setStateChangedCallback(SStateChangedCallback callback) throw(CAudioError);
-        SStateChangedCallback getStateChangedCallback() throw(CAudioError);
+        virtual void setStateChangedCallback(SStateChangedCallback callback);
+        SStateChangedCallback getStateChangedCallback();
 
-        void setInterruptCallback(SInterruptCallback callback) throw(CAudioError);
-        SInterruptCallback getInterruptCallback() throw(CAudioError);
+        void setInterruptCallback(SInterruptCallback callback);
+        SInterruptCallback getInterruptCallback();
 
-        void ignoreSession() throw(CAudioError);
+        void ignoreSession();
 
-        void setStreamInfo(sound_stream_info_h stream_info) throw(CAudioError);
+        void setStreamInfo(sound_stream_info_h stream_info);
 
-        void setInternalStreamInfo() throw(CAudioError); /* this is for session backward compatibility and will be removed later */
+        void setInternalStreamInfo(); /* this is for session backward compatibility and will be removed later */
 
         CAudioInfo::EAudioIOState getState();
 
@@ -109,10 +110,10 @@ namespace tizen_media_audio {
         virtual bool isInit();
         virtual bool IsReady();
 
-        void internalLock()   throw(CAudioError);
-        void internalUnlock() throw(CAudioError);
-        void internalWait()   throw(CAudioError);
-        void internalSignal() throw(CAudioError);
+        void internalLock();
+        void internalUnlock();
+        void internalWait();
+        void internalSignal();
 
         bool isForceIgnore();
 
@@ -135,7 +136,7 @@ namespace tizen_media_audio {
         bool                  __mIsInit;
         bool                  __mForceIgnore;
 
-        void abandonInternalFocus() throw(CAudioError); /* this is for session backward compatibility and will be removed later */
+        void abandonInternalFocus(); /* this is for session backward compatibility and will be removed later */
     };
 
 

diff --git a/include/CAudioInfo.h b/include/CAudioInfo.h
index 6f50e6a0dd745800895585dbaab0f855be497edf..5f3fb13fc2bff45a58ef09fbf2d37860cf669c06 100644 (file)
--- a/include/CAudioInfo.h
+++ b/include/CAudioInfo.h
@@ -105,7 +105,7 @@ namespace tizen_media_audio {
 
         /* Constructors */
         CAudioInfo();
-        CAudioInfo(unsigned int sampleRate, EChannel channel, ESampleType sampleType, EAudioType audioType, int audioIndex) throw(CAudioError);
+        CAudioInfo(unsigned int sampleRate, EChannel channel, ESampleType sampleType, EAudioType audioType, int audioIndex);
 
         /* Setter & Getter */
         unsigned int getSampleRate();

diff --git a/include/CAudioInput.h b/include/CAudioInput.h
index 7ec61e8d82b45c5336e36de0db2f2fcb289d8467..a6619e99d068450debeee41993857204b237ef43 100644 (file)
--- a/include/CAudioInput.h
+++ b/include/CAudioInput.h
@@ -46,27 +46,27 @@ namespace tizen_media_audio {
         virtual void onSignal(CAudioSessionHandler* pHandler, mm_sound_signal_name_t signal, int value);
 
         /* Implemented Methods */
-        virtual void initialize() throw(CAudioError);
+        virtual void initialize();
         virtual void finalize();
 
-        virtual void prepare() throw(CAudioError);
-        virtual void unprepare() throw(CAudioError);
+        virtual void prepare();
+        virtual void unprepare();
 
-        virtual void pause() throw(CAudioError);
-        virtual void resume() throw(CAudioError);
+        virtual void pause();
+        virtual void resume();
 
-        virtual void drain() throw(CAudioError);
-        virtual void flush() throw(CAudioError);
+        virtual void drain();
+        virtual void flush();
 
-        virtual int  getBufferSize() throw(CAudioError);
+        virtual int  getBufferSize();
 
         /* Overridden Methods */
-        virtual void setStreamCallback(SStreamCallback callback) throw(CAudioError);
+        virtual void setStreamCallback(SStreamCallback callback);
 
         /* Methods */
-        size_t read(void* buffer, size_t length) throw(CAudioError);
-        int peek(const void** buffer, size_t* length) throw(CAudioError);
-        int drop() throw(CAudioError);
+        size_t read(void* buffer, size_t length);
+        int peek(const void** buffer, size_t* length);
+        int drop();
 
     private:
         /* Private Methods */

diff --git a/include/CAudioOutput.h b/include/CAudioOutput.h
index 036a723398923522514cf4242bc79ce2121d3548..67050200171a6117f057899a5a21cec224467d60 100644 (file)
--- a/include/CAudioOutput.h
+++ b/include/CAudioOutput.h
@@ -46,22 +46,22 @@ namespace tizen_media_audio {
         virtual void onSignal(CAudioSessionHandler* pHandler, mm_sound_signal_name_t signal, int value);
 
         /* Implemented Methods */
-        virtual void initialize() throw(CAudioError);
+        virtual void initialize();
         virtual void finalize();
 
-        virtual void prepare() throw(CAudioError);
-        virtual void unprepare() throw(CAudioError);
+        virtual void prepare();
+        virtual void unprepare();
 
-        virtual void pause() throw(CAudioError);
-        virtual void resume() throw(CAudioError);
+        virtual void pause();
+        virtual void resume();
 
-        virtual void drain() throw(CAudioError);
-        virtual void flush() throw(CAudioError);
+        virtual void drain();
+        virtual void flush();
 
-        virtual int  getBufferSize() throw(CAudioError);
+        virtual int  getBufferSize();
 
         /* Methods */
-        size_t write(const void* buffer, size_t length) throw(CAudioError);
+        size_t write(const void* buffer, size_t length);
 
     private:
         /* Private Methods */

diff --git a/include/CAudioSessionHandler.h b/include/CAudioSessionHandler.h
index 66bd2ab7c76692969c847d434f91cd8c57a51214..1d151e641e58be66fc389dcbcb0b7950b00424cc 100644 (file)
--- a/include/CAudioSessionHandler.h
+++ b/include/CAudioSessionHandler.h
@@ -46,17 +46,17 @@ namespace tizen_media_audio {
         virtual ~CAudioSessionHandler();
 
         /* Methods */
-        virtual void initialize() throw(CAudioError);
+        virtual void initialize();
         virtual void finalize();
 
         bool isSkipSession();
 
-        void registerSound() throw(CAudioError);
-        void unregisterSound() throw(CAudioError);
+        void registerSound();
+        void unregisterSound();
 
-        void updatePlaying() throw(CAudioError);
-        void updateStop() throw(CAudioError);
-        void disableSessionHandler() throw(CAudioError);
+        void updatePlaying();
+        void updateStop();
+        void disableSessionHandler();
 
         /* Setter & Getter */
         int getId();

diff --git a/include/CPulseAudioClient.h b/include/CPulseAudioClient.h
index cab775746ece738ba1149793f1cdd46e1ce3c118..277e99ffec25043a42980dfc17d23c8dcb924bbb 100644 (file)
--- a/include/CPulseAudioClient.h
+++ b/include/CPulseAudioClient.h
@@ -50,31 +50,31 @@ namespace tizen_media_audio {
         ~CPulseAudioClient();
 
         /* Implemented Methods */
-        void initialize() throw(CAudioError);
+        void initialize();
         void finalize();
 
         /* Methods */
-        int read(void* buffer, size_t length) throw(CAudioError);
-        int peek(const void** buffer, size_t* length) throw(CAudioError);
-        int drop() throw(CAudioError);
-        int write(const void* buffer, size_t length) throw(CAudioError);
+        int read(void* buffer, size_t length);
+        int peek(const void** buffer, size_t* length);
+        int drop();
+        int write(const void* buffer, size_t length);
 
-        void cork(bool cork) throw(CAudioError);
-        bool isCorked() throw(CAudioError);
+        void cork(bool cork);
+        bool isCorked();
 
-        bool drain() throw(CAudioError);
-        bool flush() throw(CAudioError);
+        bool drain();
+        bool flush();
 
-        void checkRunningState() throw(CAudioError);
-        bool isInThread() throw(CAudioError);
+        void checkRunningState();
+        bool isInThread();
 
-        size_t getWritableSize() throw(CAudioError);
-        size_t getReadableSize() throw(CAudioError);
+        size_t getWritableSize();
+        size_t getReadableSize();
 
-        size_t getBufferSize() throw(CAudioError);
+        size_t getBufferSize();
 
-        pa_usec_t getLatency() throw(CAudioError);
-        pa_usec_t getFinalLatency() throw(CAudioError);
+        pa_usec_t getLatency();
+        pa_usec_t getFinalLatency();
 
         /* Setter & Getter */
         EStreamDirection getStreamDirection();

diff --git a/include/CPulseAudioPolicy.h b/include/CPulseAudioPolicy.h
index 32548bb6c15c1e19b1604086009584e60253ef40..2a38ac94ee84f849a52180123b6d947c22fd3aac 100644 (file)
--- a/include/CPulseAudioPolicy.h
+++ b/include/CPulseAudioPolicy.h
@@ -51,7 +51,7 @@ namespace tizen_media_audio {
         ~CPulseAudioPolicy();
 
         /* getter & setter */
-        void setPolicy(EPolicy policy) throw(CAudioError);
+        void setPolicy(EPolicy policy);
         EPolicy getPolicy();
 
         /* Override */

diff --git a/include/CPulseStreamSpec.h b/include/CPulseStreamSpec.h
index 0e9cf09dd4688153f6184b901ce329d4be121a14..16a29f7e8da6126f987f50fc95d8bafc6ecd0a5d 100644 (file)
--- a/include/CPulseStreamSpec.h
+++ b/include/CPulseStreamSpec.h
@@ -48,9 +48,9 @@ namespace tizen_media_audio {
         };
 
         /* Constructor & Destructor */
-        CPulseStreamSpec() throw(CAudioError);
-        CPulseStreamSpec(EStreamLatency latency, CAudioInfo& audioInfo) throw(CAudioError);
-        CPulseStreamSpec(EStreamLatency latency, CAudioInfo& audioInfo, int customLatency) throw(CAudioError);
+        CPulseStreamSpec();
+        CPulseStreamSpec(EStreamLatency latency, CAudioInfo& audioInfo);
+        CPulseStreamSpec(EStreamLatency latency, CAudioInfo& audioInfo, int customLatency);
         ~CPulseStreamSpec();
 
         /* Setter & Getter */
@@ -63,7 +63,7 @@ namespace tizen_media_audio {
 
     private:
         /* Private Methods */
-        void __adjustSpec() throw(CAudioError);
+        void __adjustSpec();
 
         /* Members */
         EStreamLatency __mLatency;

diff --git a/packaging/capi-media-audio-io.spec b/packaging/capi-media-audio-io.spec
index fb0eb02237d36be4bc3912a523db670ce1602d87..e5412e82c2bf34c2d8ea9a03545a3a035c979aca 100644 (file)
--- a/packaging/capi-media-audio-io.spec
+++ b/packaging/capi-media-audio-io.spec
@@ -1,6 +1,6 @@
 Name:           capi-media-audio-io
 Summary:        An Audio Input & Audio Output library in Tizen Native API
-Version:        0.3.78
+Version:        0.3.79
 Release:        0
 Group:          Multimedia/API
 License:        Apache-2.0

diff --git a/src/cpp/CAudioError.cpp b/src/cpp/CAudioError.cpp
index ed61465b6f485cc488ad1f84f67c03ac5e832359..b25a63dcc862886ad46e6d1e2e52bf4e2f312c03 100644 (file)
--- a/src/cpp/CAudioError.cpp
+++ b/src/cpp/CAudioError.cpp
@@ -40,7 +40,8 @@ CAudioError::CAudioError(EError err, const char* fileName, const char* parentFun
     __mLastError = __mError;
 
     const char* findFileName = strrchr(fileName, '/');
-    findFileName++;
+    if (findFileName)
+        findFileName++;
     const char* errStr = __convertErrorToString(__mError);
 
     snprintf(__mErrorMsg, CAudioError::MSG_LENGTH, "["
@@ -56,7 +57,8 @@ CAudioError::CAudioError(EError err, const char* msg, const char* fileName, cons
     __mLastError = __mError;
 
     const char* findFileName = strrchr(fileName, '/');
-    findFileName++;
+    if (findFileName)
+        findFileName++;
     const char* errStr = __convertErrorToString(__mError);
 
     snprintf(__mErrorMsg, CAudioError::MSG_LENGTH, "["
@@ -69,10 +71,10 @@ CAudioError::CAudioError(EError err, const char* msg, const char* fileName, cons
     snprintf(__mLastErrorMsg, CAudioError::MSG_LENGTH, "LastError:%s", __mErrorMsg);
 }
 
-//CAudioError::CAudioError(CAudioError& err) {
-//    __mError = err.__mError;
-//    strncpy(__mErrorMsg, err.__mErrorMsg, MSG_LENGTH);
-//}
+CAudioError::CAudioError(const CAudioError& err) {
+    __mError = err.__mError;
+    memcpy(__mErrorMsg, err.__mErrorMsg, MSG_LENGTH);
+}
 
 CAudioError::~CAudioError() {
 }

diff --git a/src/cpp/CAudioIO.cpp b/src/cpp/CAudioIO.cpp
index 931bae5e54da003636e2b53b0a770394b1aecb84..d5432192a048cc900138a71191c31e95c041c9ac 100644 (file)
--- a/src/cpp/CAudioIO.cpp
+++ b/src/cpp/CAudioIO.cpp
@@ -69,7 +69,7 @@ bool CAudioIO::IsReady() {
     return ((mState == CAudioInfo::EAudioIOState::AUDIO_IO_STATE_RUNNING || mState == CAudioInfo::EAudioIOState::AUDIO_IO_STATE_PAUSED)? true : false);
 }
 
-void CAudioIO::internalLock() throw(CAudioError) {
+void CAudioIO::internalLock() {
     if (__mIsInit == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
     }
@@ -82,7 +82,7 @@ void CAudioIO::internalLock() throw(CAudioError) {
 #endif
 }
 
-void CAudioIO::internalUnlock() throw(CAudioError) {
+void CAudioIO::internalUnlock() {
     if (__mIsInit == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
     }
@@ -95,7 +95,7 @@ void CAudioIO::internalUnlock() throw(CAudioError) {
 #endif
 }
 
-void CAudioIO::internalWait() throw(CAudioError) {
+void CAudioIO::internalWait() {
     if (__mIsInit == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
     }
@@ -107,7 +107,7 @@ void CAudioIO::internalWait() throw(CAudioError) {
     pthread_cond_wait(&__mCond, &__mMutex);
 }
 
-void CAudioIO::internalSignal() throw(CAudioError) {
+void CAudioIO::internalSignal() {
     if (__mIsInit == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
     }
@@ -123,7 +123,7 @@ bool CAudioIO::isForceIgnore() {
     return __mForceIgnore;
 }
 
-void CAudioIO::initialize() throw(CAudioError) {
+void CAudioIO::initialize() {
     if (__mIsInit == true) {
         return;
     }
@@ -318,7 +318,7 @@ void CAudioIO::onSignal(CAudioSessionHandler* pHandler, mm_sound_signal_name_t s
     }
 }
 
-void CAudioIO::prepare() throw(CAudioError) {
+void CAudioIO::prepare() {
     if (__mIsInit == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
     }
@@ -326,12 +326,12 @@ void CAudioIO::prepare() throw(CAudioError) {
     try {
         AUDIO_IO_LOGD("------> prepare done");
         /* Do nothing */
-    } catch (CAudioError e) {
-        throw e;
+    } catch (CAudioError& e) {
+        throw;
     }
 }
 
-void CAudioIO::unprepare() throw(CAudioError) {
+void CAudioIO::unprepare() {
     if (__mIsInit == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
     }
@@ -339,12 +339,12 @@ void CAudioIO::unprepare() throw(CAudioError) {
     try {
         AUDIO_IO_LOGD("unprepare ----->");
         /* Do nothing */
-    } catch (CAudioError e) {
-        throw e;
+    } catch (CAudioError& e) {
+        throw;
     }
 }
 
-void CAudioIO::pause() throw(CAudioError) {
+void CAudioIO::pause() {
     if (__mIsInit == false || IsReady() == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioIO");
     }
@@ -354,13 +354,13 @@ void CAudioIO::pause() throw(CAudioError) {
         AUDIO_IO_LOGD("pause");
         mpPulseAudioClient->cork(true);
         internalUnlock();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         internalUnlock();
-        throw e;
+        throw;
     }
 }
 
-void CAudioIO::resume() throw(CAudioError) {
+void CAudioIO::resume() {
     if (__mIsInit == false || IsReady() == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioIO");
     }
@@ -370,13 +370,13 @@ void CAudioIO::resume() throw(CAudioError) {
         AUDIO_IO_LOGD("resume");
         mpPulseAudioClient->cork(false);
         internalUnlock();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         internalUnlock();
-        throw e;
+        throw;
     }
 }
 
-void CAudioIO::drain() throw(CAudioError) {
+void CAudioIO::drain() {
     if (__mIsInit == false || IsReady() == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioIO");
     }
@@ -389,15 +389,15 @@ void CAudioIO::drain() throw(CAudioError) {
             mpPulseAudioClient->drain();
             internalUnlock();
         }
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         if (!mpPulseAudioClient->isInThread()) {
             internalUnlock();
         }
-        throw e;
+        throw;
     }
 }
 
-void CAudioIO::flush() throw(CAudioError) {
+void CAudioIO::flush() {
     if (__mIsInit == false || IsReady() == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioIO");
     }
@@ -410,15 +410,15 @@ void CAudioIO::flush() throw(CAudioError) {
             mpPulseAudioClient->flush();
             internalUnlock();
         }
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         if (!mpPulseAudioClient->isInThread()) {
             internalUnlock();
         }
-        throw e;
+        throw;
     }
 }
 
-CAudioInfo& CAudioIO::getAudioInfo() throw(CAudioError) {
+CAudioInfo& CAudioIO::getAudioInfo() {
     if (__mIsInit == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
     }
@@ -426,7 +426,7 @@ CAudioInfo& CAudioIO::getAudioInfo() throw(CAudioError) {
     return mAudioInfo;
 }
 
-void CAudioIO::setStreamCallback(SStreamCallback callback) throw(CAudioError) {
+void CAudioIO::setStreamCallback(SStreamCallback callback) {
     if (__mIsInit == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
     }
@@ -434,7 +434,7 @@ void CAudioIO::setStreamCallback(SStreamCallback callback) throw(CAudioError) {
     mStreamCallback = callback;
 }
 
-CAudioIO::SStreamCallback CAudioIO::getStreamCallback() throw(CAudioError) {
+CAudioIO::SStreamCallback CAudioIO::getStreamCallback() {
     if (__mIsInit == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
     }
@@ -442,7 +442,7 @@ CAudioIO::SStreamCallback CAudioIO::getStreamCallback() throw(CAudioError) {
     return mStreamCallback;
 }
 
-void CAudioIO::setStateChangedCallback(SStateChangedCallback callback) throw(CAudioError) {
+void CAudioIO::setStateChangedCallback(SStateChangedCallback callback) {
     if (__mIsInit == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
     }
@@ -450,7 +450,7 @@ void CAudioIO::setStateChangedCallback(SStateChangedCallback callback) throw(CAu
     mStateChangedCallback = callback;
 }
 
-CAudioIO::SStateChangedCallback CAudioIO::getStateChangedCallback() throw(CAudioError) {
+CAudioIO::SStateChangedCallback CAudioIO::getStateChangedCallback() {
     if (__mIsInit == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
     }
@@ -458,7 +458,7 @@ CAudioIO::SStateChangedCallback CAudioIO::getStateChangedCallback() throw(CAudio
     return mStateChangedCallback;
 }
 
-void CAudioIO::setInterruptCallback(SInterruptCallback callback) throw(CAudioError) {
+void CAudioIO::setInterruptCallback(SInterruptCallback callback) {
     if (__mIsInit == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
     }
@@ -466,7 +466,7 @@ void CAudioIO::setInterruptCallback(SInterruptCallback callback) throw(CAudioErr
     mInterruptCallback = callback;
 }
 
-CAudioIO::SInterruptCallback CAudioIO::getInterruptCallback() throw(CAudioError) {
+CAudioIO::SInterruptCallback CAudioIO::getInterruptCallback() {
     if (__mIsInit == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
     }
@@ -474,7 +474,7 @@ CAudioIO::SInterruptCallback CAudioIO::getInterruptCallback() throw(CAudioError)
     return mInterruptCallback;
 }
 
-void CAudioIO::ignoreSession() throw(CAudioError) {
+void CAudioIO::ignoreSession() {
     if (__mIsInit == false)
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
 
@@ -487,13 +487,13 @@ void CAudioIO::ignoreSession() throw(CAudioError) {
         abandonInternalFocus();
 
         internalUnlock();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         internalUnlock();
-        throw e;
+        throw;
     }
 }
 
-void CAudioIO::setStreamInfo(sound_stream_info_h stream_info) throw(CAudioError) {
+void CAudioIO::setStreamInfo(sound_stream_info_h stream_info) {
     if (stream_info == NULL)
         THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_ARGUMENT, "stream_info is NULL");
 
@@ -533,12 +533,12 @@ void CAudioIO::setStreamInfo(sound_stream_info_h stream_info) throw(CAudioError)
         getAudioInfo().setAudioIndex(index);
 
         AUDIO_IO_LOGD("stream info(%p) is set", stream_info);
-    } catch (CAudioError e) {
-        throw e;
+    } catch (CAudioError& e) {
+        throw;
     }
 }
 
-void CAudioIO::setInternalStreamInfo() throw(CAudioError) {
+void CAudioIO::setInternalStreamInfo() {
     if (__mIsInit == false)
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
 
@@ -553,12 +553,12 @@ void CAudioIO::setInternalStreamInfo() throw(CAudioError) {
             AUDIO_IO_LOGD("get internal VOIP stream info(%p)", stream_info);
             setStreamInfo(stream_info);
         }
-    } catch (CAudioError e) {
-        throw e;
+    } catch (CAudioError& e) {
+        throw;
     }
 }
 
-void CAudioIO::abandonInternalFocus() throw(CAudioError) {
+void CAudioIO::abandonInternalFocus() {
     bool isSkip = mpAudioSessionHandler->isSkipSession();
     int id = mpAudioSessionHandler->getId();
 
@@ -568,7 +568,7 @@ void CAudioIO::abandonInternalFocus() throw(CAudioError) {
 
         mpAudioSessionHandler->finalize();
         __mForceIgnore = true;
-    } catch (CAudioError e) {
-        throw e;
+    } catch (CAudioError& e) {
+        throw;
     }
 }

diff --git a/src/cpp/CAudioInfo.cpp b/src/cpp/CAudioInfo.cpp
index 39e29dc68d4326864282e6c7864bde119d84edbc..8b7f40e2e5fb3de9d2c6604f831d75a57c579c04 100644 (file)
--- a/src/cpp/CAudioInfo.cpp
+++ b/src/cpp/CAudioInfo.cpp
@@ -34,7 +34,7 @@ CAudioInfo::CAudioInfo() :
     __mAudioIndex(-1) {
 }
 
-CAudioInfo::CAudioInfo(unsigned int sampleRate, EChannel channel, ESampleType sampleType, EAudioType audioType, int audioIndex) throw(CAudioError) :
+CAudioInfo::CAudioInfo(unsigned int sampleRate, EChannel channel, ESampleType sampleType, EAudioType audioType, int audioIndex) :
     __mSampleRate(sampleRate),
     __mChannel(channel),
     __mSampleType(sampleType),

diff --git a/src/cpp/CAudioInput.cpp b/src/cpp/CAudioInput.cpp
index a5ee5eef7196884a66a9a2a9ce6d854a374a856f..3aea844774add48d451cbc30cc7c6087c436d3a1 100644 (file)
--- a/src/cpp/CAudioInput.cpp
+++ b/src/cpp/CAudioInput.cpp
@@ -202,7 +202,7 @@ static bool __IsPrivilegeAllowed() {
     return prData.isPrivilegeAllowed;
 }
 
-void CAudioInput::initialize() throw(CAudioError) {
+void CAudioInput::initialize() {
     if (__IsInit() == true) {
         return;
     }
@@ -221,10 +221,10 @@ void CAudioInput::initialize() throw(CAudioError) {
 
         __setInit(true);
         CAudioIO::onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_IDLE);
-    } catch (CAudioError err) {
+    } catch (CAudioError& e) {
         finalize();
-        throw err;
-    } catch (std::bad_alloc&) {
+        throw;
+    } catch (const std::bad_alloc&) {
         finalize();
         THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed to allocate CAudioSessionHandler object");
     }
@@ -244,7 +244,7 @@ void CAudioInput::finalize() {
     __setInit(false);
 }
 
-void CAudioInput::prepare() throw(CAudioError) {
+void CAudioInput::prepare() {
     if (__IsInit() == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CAudioInput");
     }
@@ -293,16 +293,16 @@ void CAudioInput::prepare() throw(CAudioError) {
 
         // Do Prepare
         CAudioIO::prepare();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         internalUnlock();
-        throw e;
-    } catch (std::bad_alloc&) {
+        throw;
+    } catch (const std::bad_alloc&) {
         internalUnlock();
         THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed to allocate CPulseAudioClient object");
     }
 }
 
-void CAudioInput::unprepare() throw(CAudioError) {
+void CAudioInput::unprepare() {
     if (__IsInit() == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
                         "Did not initialize CAudioInput");
@@ -332,13 +332,13 @@ void CAudioInput::unprepare() throw(CAudioError) {
         }
 
         CAudioIO::onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_IDLE);
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         internalUnlock();
-        throw e;
+        throw;
     }
 }
 
-void CAudioInput::pause() throw(CAudioError) {
+void CAudioInput::pause() {
     if (__IsInit() == false || __IsReady() == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
                         "Did not initialize or prepare CAudioInput");
@@ -366,13 +366,13 @@ void CAudioInput::pause() throw(CAudioError) {
         internalUnlock();
 
         CAudioIO::onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_PAUSED);
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         internalUnlock();
-        throw e;
+        throw;
     }
 }
 
-void CAudioInput::resume() throw(CAudioError) {
+void CAudioInput::resume() {
     if (__IsInit() == false || __IsReady() == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
                         "Did not initialize or prepare CAudioInput");
@@ -398,17 +398,17 @@ void CAudioInput::resume() throw(CAudioError) {
         CAudioIO::resume();
 
         CAudioIO::onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_RUNNING);
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         internalUnlock();
-        throw e;
+        throw;
     }
 }
 
-void CAudioInput::drain() throw(CAudioError) {
+void CAudioInput::drain() {
     THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_SUPPORTED, "Did not support drain of CAudioInput");
 }
 
-void CAudioInput::flush() throw(CAudioError) {
+void CAudioInput::flush() {
     if (__IsInit() == false || __IsReady() == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
                         "Did not initialize or prepare CAudioInput");
@@ -416,12 +416,12 @@ void CAudioInput::flush() throw(CAudioError) {
 
     try {
         CAudioIO::flush();
-    } catch (CAudioError e) {
-        throw e;
+    } catch (CAudioError& e) {
+        throw;
     }
 }
 
-int CAudioInput::getBufferSize() throw(CAudioError) {
+int CAudioInput::getBufferSize() {
     if (__IsInit() == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CAudioInput");
     }
@@ -430,7 +430,7 @@ int CAudioInput::getBufferSize() throw(CAudioError) {
     return (mAudioInfo.getSampleRate() * DEFAULT_PERIOD_SIZE) / 1000 * mAudioInfo.getSampleSize();
 }
 
-void CAudioInput::setStreamCallback(SStreamCallback callback) throw(CAudioError) {
+void CAudioInput::setStreamCallback(SStreamCallback callback) {
     if (__IsInit() == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CAudioInput");
     }
@@ -446,7 +446,7 @@ void CAudioInput::setStreamCallback(SStreamCallback callback) throw(CAudioError)
     CAudioIO::setStreamCallback(callback);
 }
 
-size_t CAudioInput::read(void* buffer, size_t length) throw(CAudioError) {
+size_t CAudioInput::read(void* buffer, size_t length) {
     if (__IsInit() == false || __IsReady() == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
                         "Did not initialize or prepare CAudioInput");
@@ -480,15 +480,15 @@ size_t CAudioInput::read(void* buffer, size_t length) throw(CAudioError) {
 
         internalUnlock();
         sched_yield();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         internalUnlock();
-        throw e;
+        throw;
     }
 
     return ret;
 }
 
-int CAudioInput::peek(const void** buffer, size_t* length) throw(CAudioError) {
+int CAudioInput::peek(const void** buffer, size_t* length) {
     if (__IsInit() == false || __IsReady() == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
                         "Did not initialize or prepare CAudioInput");
@@ -509,14 +509,14 @@ int CAudioInput::peek(const void** buffer, size_t* length) throw(CAudioError) {
 
     try {
         ret = mpPulseAudioClient->peek(buffer, length);
-    } catch (CAudioError e) {
-        throw e;
+    } catch (CAudioError& e) {
+        throw;
     }
 
     return ret;
 }
 
-int CAudioInput::drop() throw(CAudioError) {
+int CAudioInput::drop() {
     if (__IsInit() == false || __IsReady() == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
                         "Did not initialize or prepare CAudioInput");
@@ -532,8 +532,8 @@ int CAudioInput::drop() throw(CAudioError) {
 
     try {
         ret = mpPulseAudioClient->drop();
-    } catch (CAudioError e) {
-        throw e;
+    } catch (CAudioError& e) {
+        throw;
     }
 
     return ret;

diff --git a/src/cpp/CAudioOutput.cpp b/src/cpp/CAudioOutput.cpp
index 54b921dbca11370ad8a975b8dcd6dc816f06490d..b54c0db56f3def75f575d0863edd265d356871b0 100644 (file)
--- a/src/cpp/CAudioOutput.cpp
+++ b/src/cpp/CAudioOutput.cpp
@@ -97,7 +97,7 @@ bool CAudioOutput::__IsReady() {
     return CAudioIO::IsReady();
 }
 
-void CAudioOutput::initialize() throw(CAudioError) {
+void CAudioOutput::initialize() {
     if (__IsInit() == true) {
         return;
     }
@@ -113,10 +113,10 @@ void CAudioOutput::initialize() throw(CAudioError) {
 
         __setInit(true);
         CAudioIO::onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_IDLE);
-    } catch (CAudioError err) {
+    } catch (CAudioError& e) {
         finalize();
-        throw err;
-    } catch (std::bad_alloc&) {
+        throw;
+    } catch (const std::bad_alloc&) {
         finalize();
         THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed to allocate CAudioSessionHandler object");
     }
@@ -136,7 +136,7 @@ void CAudioOutput::finalize() {
     __setInit(false);
 }
 
-void CAudioOutput::prepare() throw(CAudioError) {
+void CAudioOutput::prepare() {
     if (__IsInit() == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CAudioOutput");
     }
@@ -183,16 +183,16 @@ void CAudioOutput::prepare() throw(CAudioError) {
         internalUnlock();
 
         CAudioIO::prepare();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         internalUnlock();
-        throw e;
-    } catch (std::bad_alloc&) {
+        throw;
+    } catch (const std::bad_alloc&) {
         internalUnlock();
         THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed to allocate CPulseAudioClient object");
     }
 }
 
-void CAudioOutput::unprepare() throw(CAudioError) {
+void CAudioOutput::unprepare() {
     if (__IsInit() == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
                         "Did not initialize CAudioOutput");
@@ -222,13 +222,13 @@ void CAudioOutput::unprepare() throw(CAudioError) {
         }
 
         CAudioIO::onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_IDLE);
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         internalUnlock();
-        throw e;
+        throw;
     }
 }
 
-void CAudioOutput::pause() throw(CAudioError) {
+void CAudioOutput::pause() {
     if (__IsInit() == false || __IsReady() == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
                         "Did not initialize or prepare CAudioOutput");
@@ -255,13 +255,13 @@ void CAudioOutput::pause() throw(CAudioError) {
         internalUnlock();
 
         CAudioIO::onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_PAUSED);
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         internalUnlock();
-        throw e;
+        throw;
     }
 }
 
-void CAudioOutput::resume() throw(CAudioError) {
+void CAudioOutput::resume() {
     if (__IsInit() == false || __IsReady() == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
                         "Did not initialize or prepare CAudioOutput");
@@ -287,13 +287,13 @@ void CAudioOutput::resume() throw(CAudioError) {
         CAudioIO::resume();
 
         CAudioIO::onStateChanged(CAudioInfo::EAudioIOState::AUDIO_IO_STATE_RUNNING);
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         internalUnlock();
-        throw e;
+        throw;
     }
 }
 
-void CAudioOutput::drain() throw(CAudioError) {
+void CAudioOutput::drain() {
     if (__IsInit() == false || __IsReady() == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
                         "Did not initialize or prepare CAudioOutput");
@@ -301,12 +301,12 @@ void CAudioOutput::drain() throw(CAudioError) {
 
     try {
         CAudioIO::drain();
-    } catch (CAudioError e) {
-        throw e;
+    } catch (CAudioError& e) {
+        throw;
     }
 }
 
-void CAudioOutput::flush() throw(CAudioError) {
+void CAudioOutput::flush() {
     if (__IsInit() == false || __IsReady() == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
                         "Did not initialize or prepare CAudioOutput");
@@ -314,12 +314,12 @@ void CAudioOutput::flush() throw(CAudioError) {
 
     try {
         CAudioIO::flush();
-    } catch (CAudioError e) {
-        throw e;
+    } catch (CAudioError& e) {
+        throw;
     }
 }
 
-int CAudioOutput::getBufferSize() throw(CAudioError) {
+int CAudioOutput::getBufferSize() {
     if (__IsInit() == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
                         "Did not initialize or prepare CAudioOutput");
@@ -329,7 +329,7 @@ int CAudioOutput::getBufferSize() throw(CAudioError) {
     return (mAudioInfo.getSampleRate() * DEFAULT_PERIOD_SIZE) / 1000 * mAudioInfo.getSampleSize();
 }
 
-size_t CAudioOutput::write(const void* buffer, size_t length) throw(CAudioError) {
+size_t CAudioOutput::write(const void* buffer, size_t length) {
     if (__IsInit() == false || __IsReady() == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED,
                         "Did not initialize or prepare CAudioOutput");
@@ -404,10 +404,10 @@ size_t CAudioOutput::write(const void* buffer, size_t length) throw(CAudioError)
         __mIsUsedSyncWrite = false;
         internalUnlock();
         sched_yield();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         __mIsUsedSyncWrite = false;
         internalUnlock();
-        throw e;
+        throw;
     }
 
     return length;

diff --git a/src/cpp/CAudioSessionHandler.cpp b/src/cpp/CAudioSessionHandler.cpp
index 267a5ec34040edf645d8b1d21f03da5b1db38dae..27699faa0f3ef948e571da2ba49b51a2dd4bed8a 100644 (file)
--- a/src/cpp/CAudioSessionHandler.cpp
+++ b/src/cpp/CAudioSessionHandler.cpp
@@ -214,7 +214,7 @@ void CAudioSessionHandler::__sound_pcm_signal_cb(mm_sound_signal_name_t signal,
         pHandler->__mpEventListener->onSignal(pHandler, signal, value);
 }
 
-void CAudioSessionHandler::initialize() throw(CAudioError) {
+void CAudioSessionHandler::initialize() {
     AUDIO_IO_LOGD("");
     if (__mIsInit == true) {
         return;
@@ -342,7 +342,7 @@ void CAudioSessionHandler::__sound_pcm_focus_watch_cb(int id, mm_sound_focus_typ
     return;
 }
 
-void CAudioSessionHandler::registerSound() throw(CAudioError) {
+void CAudioSessionHandler::registerSound() {
     if (__mIsInit == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioSessionHandler");
     }
@@ -400,7 +400,7 @@ void CAudioSessionHandler::registerSound() throw(CAudioError) {
     }
 }
 
-void CAudioSessionHandler::unregisterSound() throw(CAudioError) {
+void CAudioSessionHandler::unregisterSound() {
     if (__mIsInit == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioSessionHandler");
     }
@@ -435,7 +435,7 @@ void CAudioSessionHandler::unregisterSound() throw(CAudioError) {
     }
 }
 
-void CAudioSessionHandler::updatePlaying() throw(CAudioError) {
+void CAudioSessionHandler::updatePlaying() {
     if (__mIsInit == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioSessionHandler");
     }
@@ -462,7 +462,7 @@ void CAudioSessionHandler::updatePlaying() throw(CAudioError) {
     }
 }
 
-void CAudioSessionHandler::updateStop() throw(CAudioError) {
+void CAudioSessionHandler::updateStop() {
     if (__mIsInit == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioSessionHandler");
     }
@@ -487,7 +487,7 @@ void CAudioSessionHandler::updateStop() throw(CAudioError) {
     }
 }
 
-void CAudioSessionHandler::disableSessionHandler() throw(CAudioError) {
+void CAudioSessionHandler::disableSessionHandler() {
     CAudioSessionHandler::updateStop();
     CAudioSessionHandler::unregisterSound();
 

diff --git a/src/cpp/CPulseAudioClient.cpp b/src/cpp/CPulseAudioClient.cpp
index 4dd4a8c0fe27734af6679f15a87ee8de00051a68..1ac1c0d6c324725325dad64eab3aac629e832c97 100644 (file)
--- a/src/cpp/CPulseAudioClient.cpp
+++ b/src/cpp/CPulseAudioClient.cpp
@@ -242,7 +242,7 @@ void CPulseAudioClient::__successDrainCb(pa_stream* s, int success, void* user_d
     pa_threaded_mainloop_signal(pClient->__mpMainloop, 0);
 }
 
-void CPulseAudioClient::initialize() throw(CAudioError) {
+void CPulseAudioClient::initialize() {
     if (__mIsInit == true) {
         return;
     }
@@ -390,9 +390,9 @@ void CPulseAudioClient::initialize() throw(CAudioError) {
         pa_threaded_mainloop_unlock(__mpMainloop);
 
         // __mIsInit = true;  // Moved to __streamStateChangeCb()
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         finalize();
-        throw e;
+        throw;
     }
 }
 
@@ -455,7 +455,7 @@ void CPulseAudioClient::finalize() {
     __mIsInit = false;
 }
 
-int CPulseAudioClient::read(void* buffer, size_t length) throw(CAudioError) {
+int CPulseAudioClient::read(void* buffer, size_t length) {
     if (__mIsInit == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
     }
@@ -541,16 +541,16 @@ int CPulseAudioClient::read(void* buffer, size_t length) throw(CAudioError) {
 
         pa_threaded_mainloop_unlock(__mpMainloop);
         __mIsUsedSyncRead = false;
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         pa_threaded_mainloop_unlock(__mpMainloop);
         __mIsUsedSyncRead = false;
-        throw e;
+        throw;
     }
 
     return length;
 }
 
-int CPulseAudioClient::peek(const void** buffer, size_t* length) throw(CAudioError) {
+int CPulseAudioClient::peek(const void** buffer, size_t* length) {
     if (__mIsInit == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
     }
@@ -586,7 +586,7 @@ int CPulseAudioClient::peek(const void** buffer, size_t* length) throw(CAudioErr
     return ret;
 }
 
-int CPulseAudioClient::drop() throw(CAudioError) {
+int CPulseAudioClient::drop() {
     if (__mIsInit == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
     }
@@ -618,7 +618,7 @@ int CPulseAudioClient::drop() throw(CAudioError) {
     return ret;
 }
 
-int CPulseAudioClient::write(const void* data, size_t length) throw(CAudioError) {
+int CPulseAudioClient::write(const void* data, size_t length) {
     if (data == NULL) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_ARGUMENT, "The parameter is invalid");
     }
@@ -667,7 +667,7 @@ int CPulseAudioClient::write(const void* data, size_t length) throw(CAudioError)
     return ret;
 }
 
-void CPulseAudioClient::cork(bool cork) throw(CAudioError) {
+void CPulseAudioClient::cork(bool cork) {
     AUDIO_IO_LOGD("cork[%d]", cork);
 
     if (__mIsInit == false) {
@@ -695,7 +695,7 @@ void CPulseAudioClient::cork(bool cork) throw(CAudioError) {
     return;
 }
 
-bool CPulseAudioClient::isCorked() throw(CAudioError) {
+bool CPulseAudioClient::isCorked() {
     if (__mIsInit == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
     }
@@ -716,7 +716,7 @@ bool CPulseAudioClient::isCorked() throw(CAudioError) {
     return static_cast<bool>(isCork);
 }
 
-bool CPulseAudioClient::drain() throw(CAudioError) {
+bool CPulseAudioClient::drain() {
     if (__mIsInit == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
     }
@@ -745,7 +745,7 @@ bool CPulseAudioClient::drain() throw(CAudioError) {
     return true;
 }
 
-bool CPulseAudioClient::flush() throw(CAudioError) {
+bool CPulseAudioClient::flush() {
     if (__mIsInit == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
     }
@@ -765,7 +765,7 @@ bool CPulseAudioClient::flush() throw(CAudioError) {
     return true;
 }
 
-size_t CPulseAudioClient::getWritableSize() throw(CAudioError) {
+size_t CPulseAudioClient::getWritableSize() {
     if (__mIsInit == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
     }
@@ -789,7 +789,7 @@ size_t CPulseAudioClient::getWritableSize() throw(CAudioError) {
     return ret;
 }
 
-void CPulseAudioClient::checkRunningState() throw(CAudioError) {
+void CPulseAudioClient::checkRunningState() {
     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);
     }
@@ -805,7 +805,7 @@ void CPulseAudioClient::checkRunningState() throw(CAudioError) {
 #endif
 }
 
-bool CPulseAudioClient::isInThread() throw(CAudioError) {
+bool CPulseAudioClient::isInThread() {
     int ret = pa_threaded_mainloop_in_thread(__mpMainloop);
 
 #ifdef _AUDIO_IO_DEBUG_TIMING_
@@ -814,7 +814,7 @@ bool CPulseAudioClient::isInThread() throw(CAudioError) {
     return static_cast<bool>(ret);
 }
 
-size_t CPulseAudioClient::getReadableSize() throw(CAudioError) {
+size_t CPulseAudioClient::getReadableSize() {
     if (__mIsInit == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
     }
@@ -838,7 +838,7 @@ size_t CPulseAudioClient::getReadableSize() throw(CAudioError) {
     return ret;
 }
 
-size_t CPulseAudioClient::getBufferSize() throw(CAudioError) {
+size_t CPulseAudioClient::getBufferSize() {
     if (__mIsInit == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
     }
@@ -865,11 +865,11 @@ size_t CPulseAudioClient::getBufferSize() throw(CAudioError) {
             ret = attr->fragsize;
             AUDIO_IO_LOGD("RECORD buffer size[%d]", ret);
         }
-    } catch (CAudioError err) {
+    } catch (CAudioError& e) {
         if (isInThread() == false) {
             pa_threaded_mainloop_unlock(__mpMainloop);
         }
-        throw err;
+        throw;
     }
 
     if (isInThread() == false) {
@@ -879,7 +879,7 @@ size_t CPulseAudioClient::getBufferSize() throw(CAudioError) {
     return ret;
 }
 
-pa_usec_t CPulseAudioClient::getLatency() throw(CAudioError) {
+pa_usec_t CPulseAudioClient::getLatency() {
     if (__mIsInit == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
     }
@@ -915,9 +915,9 @@ pa_usec_t CPulseAudioClient::getLatency() throw(CAudioError) {
             /* Wait until latency data is available again */
             pa_threaded_mainloop_wait(__mpMainloop);
         }
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         pa_threaded_mainloop_unlock(__mpMainloop);
-        throw e;
+        throw;
     }
 
     pa_threaded_mainloop_unlock(__mpMainloop);
@@ -925,7 +925,7 @@ pa_usec_t CPulseAudioClient::getLatency() throw(CAudioError) {
     return negative ? 0 : ret;
 }
 
-pa_usec_t CPulseAudioClient::getFinalLatency() throw(CAudioError) {
+pa_usec_t CPulseAudioClient::getFinalLatency() {
     if (__mIsInit == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
     }
@@ -965,11 +965,11 @@ pa_usec_t CPulseAudioClient::getFinalLatency() throw(CAudioError) {
         if (isInThread() == false) {
             pa_threaded_mainloop_unlock(__mpMainloop);
         }
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         if (isInThread() == false) {
             pa_threaded_mainloop_unlock(__mpMainloop);
         }
-        throw e;
+        throw;
     }
 
     return ret;

diff --git a/src/cpp/CPulseAudioPolicy.cpp b/src/cpp/CPulseAudioPolicy.cpp
index 5fa67f1e613ec17e07d36228f3cfa864d49cfdb5..1477b81d6cc3df689bd1bc3174703fc5be38d5d9 100644 (file)
--- a/src/cpp/CPulseAudioPolicy.cpp
+++ b/src/cpp/CPulseAudioPolicy.cpp
@@ -37,7 +37,7 @@ CPulseAudioPolicy::CPulseAudioPolicy(EPolicy policy) :
 CPulseAudioPolicy::~CPulseAudioPolicy() {
 }
 
-void CPulseAudioPolicy::setPolicy(EPolicy policy) throw(CAudioError) {
+void CPulseAudioPolicy::setPolicy(EPolicy policy) {
     if (policy < EPolicy::POLICY_DEFAULT || policy >= EPolicy::POLICY_MAX) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_ARGUMENT, "The argument is out of range");
     }

diff --git a/src/cpp/CPulseStreamSpec.cpp b/src/cpp/CPulseStreamSpec.cpp
index 08a445dcee857180bf4eeaa9096addeaead91a32..1ad6ee1801a7277a09e64c88366886c0bb39ae75 100644 (file)
--- a/src/cpp/CPulseStreamSpec.cpp
+++ b/src/cpp/CPulseStreamSpec.cpp
@@ -41,20 +41,20 @@ static const char* STREAM_LATENCY_VOIP    = "voip";
 static const char* STREAM_LATENCY_DEFAULT = "default";
 
 
-CPulseStreamSpec::CPulseStreamSpec() throw(CAudioError) :
+CPulseStreamSpec::CPulseStreamSpec():
     __mLatency(EStreamLatency::STREAM_LATENCY_INPUT_DEFAULT),
     __mStreamName(NULL) {
     __adjustSpec();
 }
 
-CPulseStreamSpec::CPulseStreamSpec(EStreamLatency latency, CAudioInfo& audioInfo) throw(CAudioError) :
+CPulseStreamSpec::CPulseStreamSpec(EStreamLatency latency, CAudioInfo& audioInfo) :
     __mLatency(latency),
     __mAudioInfo(audioInfo),
     __mStreamName(NULL) {
     __adjustSpec();
 }
 
-CPulseStreamSpec::CPulseStreamSpec(EStreamLatency latency, CAudioInfo& audioInfo, int customLatency) throw(CAudioError) :
+CPulseStreamSpec::CPulseStreamSpec(EStreamLatency latency, CAudioInfo& audioInfo, int customLatency) :
     __mLatency(latency),
     __mAudioInfo(audioInfo),
     __mStreamName(NULL) {
@@ -64,7 +64,7 @@ CPulseStreamSpec::CPulseStreamSpec(EStreamLatency latency, CAudioInfo& audioInfo
 CPulseStreamSpec::~CPulseStreamSpec() {
 }
 
-void CPulseStreamSpec::__adjustSpec() throw(CAudioError) {
+void CPulseStreamSpec::__adjustSpec() {
     // Sets a sampleRate
     __mSampleSpec.rate = __mAudioInfo.getSampleRate();
 

diff --git a/src/cpp/cpp_audio_io.cpp b/src/cpp/cpp_audio_io.cpp
index f0a6052c605da5de98c9421b3c066a24b6745283..110d5c338fcf0b482111737e28f625f75d8195a4 100644 (file)
--- a/src/cpp/cpp_audio_io.cpp
+++ b/src/cpp/cpp_audio_io.cpp
@@ -299,7 +299,7 @@ static audio_io_state_e __convert_state_type(const CAudioInfo::EAudioIOState src
     return dst_state;
 }
 
-static void __check_audio_param(int sample_rate, audio_channel_e channel, audio_sample_type_e type) throw(CAudioError) {
+static void __check_audio_param(int sample_rate, audio_channel_e channel, audio_sample_type_e type) {
     if (sample_rate < 0) {
         THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Invalid sample rate :%d", sample_rate);
     }
@@ -313,7 +313,7 @@ static void __check_audio_param(int sample_rate, audio_channel_e channel, audio_
     }
 }
 
-static void __check_audio_param(int sample_rate, audio_channel_e channel, audio_sample_type_e type, sound_type_e sound_type) throw(CAudioError) {
+static void __check_audio_param(int sample_rate, audio_channel_e channel, audio_sample_type_e type, sound_type_e sound_type) {
     __check_audio_param(sample_rate, channel, type);
 
     if (sound_type < SOUND_TYPE_SYSTEM || sound_type > SOUND_TYPE_VOICE) {
@@ -321,7 +321,7 @@ static void __check_audio_param(int sample_rate, audio_channel_e channel, audio_
     }
 }
 
-static CAudioInfo __generate_audio_input_info(int sampleRate, audio_channel_e channel, audio_sample_type_e sample_type) throw(CAudioError) {
+static CAudioInfo __generate_audio_input_info(int sampleRate, audio_channel_e channel, audio_sample_type_e sample_type) {
     CAudioInfo::EChannel     dstChannel;
     CAudioInfo::ESampleType dstSampleType;
     CAudioInfo::EAudioType  dstAudioType = CAudioInfo::EAudioType::AUDIO_IN_TYPE_MEDIA;
@@ -332,7 +332,7 @@ static CAudioInfo __generate_audio_input_info(int sampleRate, audio_channel_e ch
     return CAudioInfo(sampleRate, dstChannel, dstSampleType, dstAudioType, -1);
 }
 
-static CAudioInfo __generate_audio_input_loopback_info(int sampleRate, audio_channel_e channel, audio_sample_type_e sample_type) throw(CAudioError) {
+static CAudioInfo __generate_audio_input_loopback_info(int sampleRate, audio_channel_e channel, audio_sample_type_e sample_type) {
     CAudioInfo::EChannel     dstChannel;
     CAudioInfo::ESampleType dstSampleType;
     CAudioInfo::EAudioType  dstAudioType = CAudioInfo::EAudioType::AUDIO_IN_TYPE_LOOPBACK;
@@ -343,7 +343,7 @@ static CAudioInfo __generate_audio_input_loopback_info(int sampleRate, audio_cha
     return CAudioInfo(sampleRate, dstChannel, dstSampleType, dstAudioType, -1);
 }
 
-static CAudioInfo __generate_audio_output_info(int sampleRate, audio_channel_e channel, audio_sample_type_e sample_type, sound_type_e sound_type) throw(CAudioError) {
+static CAudioInfo __generate_audio_output_info(int sampleRate, audio_channel_e channel, audio_sample_type_e sample_type, sound_type_e sound_type) {
     CAudioInfo::EChannel     dstChannel;
     CAudioInfo::ESampleType dstSampleType;
     CAudioInfo::EAudioType  dstAudioType;
@@ -424,11 +424,11 @@ int cpp_audio_in_create(int sample_rate, audio_channel_e channel, audio_sample_t
         handle->audioIoHandle->initialize();
 
         *input = handle;
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         __handle_safe_free(handle, (void *)input, false);
         return __convert_CAudioError(e);
-    } catch (std::bad_alloc&) {
+    } catch (const std::bad_alloc&) {
         CAudioError e = CAudioError::EError::ERROR_OUT_OF_MEMORY;
         AUDIO_IO_LOGE("Failed to allocate handle");
         __handle_safe_free(handle, (void *)input, false);
@@ -457,11 +457,11 @@ int cpp_audio_in_create_loopback(int sample_rate, audio_channel_e channel, audio
         handle->audioIoHandle->initialize();
 
         *input = handle;
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         __handle_safe_free(handle, (void *)input, false);
         return __convert_CAudioError(e);
-    } catch (std::bad_alloc&) {
+    } catch (const std::bad_alloc&) {
         CAudioError e = CAudioError::EError::ERROR_OUT_OF_MEMORY;
         AUDIO_IO_LOGE("Failed to allocate handle");
         __handle_safe_free(handle, (void *)input, false);
@@ -487,7 +487,7 @@ int cpp_audio_in_destroy(audio_in_h input) {
         SAFE_FINALIZE(handle->audioIoHandle);
         SAFE_DELETE(handle->audioIoHandle);
         SAFE_DELETE(handle);
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -506,7 +506,7 @@ int cpp_audio_in_set_sound_stream_info(audio_in_h input, sound_stream_info_h str
         assert(handle->audioIoHandle);
 
         handle->audioIoHandle->setStreamInfo(stream_info);
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -525,7 +525,7 @@ int cpp_audio_in_prepare(audio_in_h input) {
         assert(handle->audioIoHandle);
 
         handle->audioIoHandle->prepare();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -544,7 +544,7 @@ int cpp_audio_in_unprepare(audio_in_h input) {
         assert(handle->audioIoHandle);
 
         handle->audioIoHandle->unprepare();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -563,7 +563,7 @@ int cpp_audio_in_pause(audio_in_h input) {
         assert(handle->audioIoHandle);
 
         handle->audioIoHandle->pause();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -582,7 +582,7 @@ int cpp_audio_in_resume(audio_in_h input) {
         assert(handle->audioIoHandle);
 
         handle->audioIoHandle->resume();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -601,7 +601,7 @@ int cpp_audio_in_drain(audio_in_h input) {
         assert(handle->audioIoHandle);
 
         handle->audioIoHandle->drain();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -620,7 +620,7 @@ int cpp_audio_in_flush(audio_in_h input) {
         assert(handle->audioIoHandle);
 
         handle->audioIoHandle->flush();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -649,7 +649,7 @@ int cpp_audio_in_read(audio_in_h input, void *buffer, unsigned int length) {
 #ifdef _AUDIO_IO_DEBUG_TIMING_
         AUDIO_IO_LOGD("readn:%d", readn);
 #endif
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -672,7 +672,7 @@ int cpp_audio_in_get_buffer_size(audio_in_h input, int *size) {
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL");
         }
         *size = inputHandle->getBufferSize();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -691,7 +691,7 @@ int cpp_audio_in_get_sample_rate(audio_in_h input, int *sample_rate) {
         assert(handle->audioIoHandle);
 
         *sample_rate = handle->audioIoHandle->getAudioInfo().getSampleRate();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -714,7 +714,7 @@ int cpp_audio_in_get_channel(audio_in_h input, audio_channel_e *channel) {
         __convert_audio_info_channel_2_channel(srcChannel, dstChannel);
 
         *channel = dstChannel;
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -737,7 +737,7 @@ int cpp_audio_in_get_sample_type(audio_in_h input, audio_sample_type_e *type) {
         __convert_audio_info_sample_type_2_sample_type(srcSampleType, dstSampleType);
 
         *type = dstSampleType;
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -774,7 +774,7 @@ int cpp_audio_in_set_interrupted_cb(audio_in_h input, audio_io_interrupted_cb ca
         cb.onInterrupt = __interrupt_cb_internal;
 
         handle->audioIoHandle->setInterruptCallback(cb);
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -800,7 +800,7 @@ int cpp_audio_in_unset_interrupted_cb(audio_in_h input) {
         cb.onInterrupt = NULL;
 
         handle->audioIoHandle->setInterruptCallback(cb);
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -824,7 +824,7 @@ int cpp_audio_in_ignore_session(audio_in_h input) {
         assert(handle->audioIoHandle);
 
         handle->audioIoHandle->ignoreSession();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -873,7 +873,7 @@ int cpp_audio_in_set_stream_cb(audio_in_h input, audio_in_stream_cb callback, vo
         cb.onStream  = __stream_cb_internal;
 
         handle->audioIoHandle->setStreamCallback(cb);
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -899,7 +899,7 @@ int cpp_audio_in_unset_stream_cb(audio_in_h input) {
         cb.onStream  = NULL;
 
         handle->audioIoHandle->setStreamCallback(cb);
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -923,7 +923,7 @@ int cpp_audio_in_peek(audio_in_h input, const void **buffer, unsigned int *lengt
         }
 
         inputHandle->peek(buffer, &_length);
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -948,7 +948,7 @@ int cpp_audio_in_drop(audio_in_h input) {
         }
 
         inputHandle->drop();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -974,7 +974,7 @@ int cpp_audio_in_set_state_changed_cb(audio_in_h input, audio_in_state_changed_c
         cb.onStateChanged = __state_changed_cb_internal;
 
         handle->audioIoHandle->setStateChangedCallback(cb);
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -1000,7 +1000,7 @@ int cpp_audio_in_unset_state_changed_cb(audio_in_h input) {
         cb.onStateChanged  = NULL;
 
         handle->audioIoHandle->setStateChangedCallback(cb);
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -1031,11 +1031,11 @@ int cpp_audio_out_create(int sample_rate, audio_channel_e channel, audio_sample_
         handle->audioIoHandle->initialize();
 
         *output = handle;
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         __handle_safe_free(handle, (void *)output, true);
         return __convert_CAudioError(e);
-    } catch (std::bad_alloc&) {
+    } catch (const std::bad_alloc&) {
         CAudioError e = CAudioError::EError::ERROR_OUT_OF_MEMORY;
         AUDIO_IO_LOGE("Failed to allocate handle");
         __handle_safe_free(handle, (void *)output, true);
@@ -1064,11 +1064,11 @@ int cpp_audio_out_create_new(int sample_rate, audio_channel_e channel, audio_sam
         handle->audioIoHandle->initialize();
 
         *output = handle;
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         __handle_safe_free(handle, (void *)output, true);
         return __convert_CAudioError(e);
-    } catch (std::bad_alloc&) {
+    } catch (const std::bad_alloc&) {
         CAudioError e = CAudioError::EError::ERROR_OUT_OF_MEMORY;
         AUDIO_IO_LOGE("Failed to allocate handle");
         __handle_safe_free(handle, (void *)output, true);
@@ -1094,7 +1094,7 @@ int cpp_audio_out_destroy(audio_out_h output) {
         SAFE_FINALIZE(handle->audioIoHandle);
         SAFE_DELETE(handle->audioIoHandle);
         SAFE_DELETE(handle);
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -1113,7 +1113,7 @@ int cpp_audio_out_set_sound_stream_info(audio_out_h output, sound_stream_info_h
         assert(handle->audioIoHandle);
 
         handle->audioIoHandle->setStreamInfo(stream_info);
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -1132,7 +1132,7 @@ int cpp_audio_out_prepare(audio_out_h output) {
         assert(handle->audioIoHandle);
 
         handle->audioIoHandle->prepare();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -1151,7 +1151,7 @@ int cpp_audio_out_unprepare(audio_out_h output) {
         assert(handle->audioIoHandle);
 
         handle->audioIoHandle->unprepare();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -1170,7 +1170,7 @@ int cpp_audio_out_pause(audio_out_h output) {
         assert(handle->audioIoHandle);
 
         handle->audioIoHandle->pause();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -1189,7 +1189,7 @@ int cpp_audio_out_resume(audio_out_h output) {
         assert(handle->audioIoHandle);
 
         handle->audioIoHandle->resume();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -1208,7 +1208,7 @@ int cpp_audio_out_drain(audio_out_h output) {
         assert(handle->audioIoHandle);
 
         handle->audioIoHandle->drain();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -1227,7 +1227,7 @@ int cpp_audio_out_flush(audio_out_h output) {
         assert(handle->audioIoHandle);
 
         handle->audioIoHandle->flush();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -1256,7 +1256,7 @@ int cpp_audio_out_write(audio_out_h output, void *buffer, unsigned int length) {
 #ifdef _AUDIO_IO_DEBUG_TIMING_
         AUDIO_IO_LOGD("written:%d", written);
 #endif
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -1279,7 +1279,7 @@ int cpp_audio_out_get_buffer_size(audio_out_h output, int *size) {
             THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL");
         }
         *size = outputHandle->getBufferSize();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -1298,7 +1298,7 @@ int cpp_audio_out_get_sample_rate(audio_out_h output, int *sample_rate) {
         assert(handle->audioIoHandle);
 
         *sample_rate = handle->audioIoHandle->getAudioInfo().getSampleRate();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -1321,7 +1321,7 @@ int cpp_audio_out_get_channel(audio_out_h output, audio_channel_e *channel) {
         __convert_audio_info_channel_2_channel(srcChannel, dstChannel);
 
         *channel = dstChannel;
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -1344,7 +1344,7 @@ int cpp_audio_out_get_sample_type(audio_out_h output, audio_sample_type_e *type)
         __convert_audio_info_sample_type_2_sample_type(srcSampleType, dstSampleType);
 
         *type = dstSampleType;
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -1367,7 +1367,7 @@ int cpp_audio_out_get_sound_type(audio_out_h output, sound_type_e *type) {
         __convert_audio_info_audio_type_2_sound_type(srcAudioType, dstSoundType);
 
         *type = dstSoundType;
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -1393,7 +1393,7 @@ int cpp_audio_out_set_interrupted_cb(audio_out_h output, audio_io_interrupted_cb
         cb.onInterrupt = __interrupt_cb_internal;
 
         handle->audioIoHandle->setInterruptCallback(cb);
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -1419,7 +1419,7 @@ int cpp_audio_out_unset_interrupted_cb(audio_out_h output) {
         cb.onInterrupt = NULL;
 
         handle->audioIoHandle->setInterruptCallback(cb);
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -1443,7 +1443,7 @@ int cpp_audio_out_ignore_session(audio_out_h output) {
         assert(handle->audioIoHandle);
 
         handle->audioIoHandle->ignoreSession();
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -1469,7 +1469,7 @@ int cpp_audio_out_set_stream_cb(audio_out_h output, audio_out_stream_cb callback
         cb.onStream  = __stream_cb_internal;
 
         handle->audioIoHandle->setStreamCallback(cb);
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -1495,7 +1495,7 @@ int cpp_audio_out_unset_stream_cb(audio_out_h output) {
         cb.onStream = NULL;
 
         handle->audioIoHandle->setStreamCallback(cb);
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -1521,7 +1521,7 @@ int cpp_audio_out_set_state_changed_cb(audio_out_h output, audio_in_state_change
         cb.onStateChanged = __state_changed_cb_internal;
 
         handle->audioIoHandle->setStateChangedCallback(cb);
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }
@@ -1547,7 +1547,7 @@ int cpp_audio_out_unset_state_changed_cb(audio_out_h output) {
         cb.onStateChanged = NULL;
 
         handle->audioIoHandle->setStateChangedCallback(cb);
-    } catch (CAudioError e) {
+    } catch (CAudioError& e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
         return __convert_CAudioError(e);
     }

diff --git a/test/audio_io_test.c b/test/audio_io_test.c
index 70e6e3a1550518f941e1507b8f6e5478dc19be6a..3b5d98fea5c02023e8174a9c46a02a67b9ce2efe 100644 (file)
--- a/test/audio_io_test.c
+++ b/test/audio_io_test.c
@@ -243,8 +243,9 @@ int audio_io_loopback_in_test()
                        goto exit;
                }
 
+               char *buffer = alloca(size);
+
                while (1) {
-                       char *buffer = alloca(size);
                        if ((ret = audio_in_read(input, (void *)buffer, size)) > AUDIO_IO_ERROR_NONE) {
                                fwrite(buffer, size, sizeof(char), fp);
                                printf("PASS, size=%d, ret=0x%x\n", size, ret);
@@ -266,8 +267,8 @@ int audio_io_loopback_in_test()
 int audio_io_loopback_test()
 {
        int ret, size;
-       audio_in_h input;
-       audio_out_h output;
+       audio_in_h input = NULL;
+       audio_out_h output = NULL;
        char *buffer = NULL;
 
        ret = audio_in_create(16000, AUDIO_CHANNEL_MONO, AUDIO_SAMPLE_TYPE_S16_LE, &input);
@@ -278,19 +279,18 @@ int audio_io_loopback_test()
        ret = audio_out_create_new(16000, AUDIO_CHANNEL_MONO, AUDIO_SAMPLE_TYPE_S16_LE, &output);
        if (ret != AUDIO_IO_ERROR_NONE) {
                printf("audio_out_create failed. \n");
-               return ret;
+               goto exit;
        }
 
        ret = audio_in_prepare(input);
        if (ret != 0) {
                printf("audio_in_prepare failed, err(0x%x)\n", ret);
-               audio_in_destroy(input);
-               return ret;
+               goto exit;
        } else {
                ret = audio_in_get_buffer_size(input, &size);
                if (ret != AUDIO_IO_ERROR_NONE) {
                        printf("audio_in_get_buffer_size failed, err(0x%x)\n", ret);
-                       return 0;
+                       goto exit;
                } else {
                        printf("size(%d)\n", size);
                        buffer = alloca(size);
@@ -300,13 +300,13 @@ int audio_io_loopback_test()
        ret = audio_out_prepare(output);
        if (ret != 0) {
                printf("audio_out_prepare failed, err(0x%x)\n", ret);
-               audio_out_destroy(output);
-               return ret;
+               goto exit;
        }
 
        if (buffer == NULL) {
                printf("buffer is null\n");
-               return -1;
+               ret = -1;
+               goto exit;
        }
 
        while (1) {
@@ -321,6 +321,14 @@ int audio_io_loopback_test()
                        printf("audio read/write failed. buffer(%p), size(%d)\n", buffer, size);
        }
 
+exit:
+       if (input)
+               audio_in_destroy(input);
+       if (output)
+               audio_out_destroy(output);
+
+       return ret;
+
 }
 
 audio_in_h input;