*/
-#include <mm.h>
#include <pthread.h>
#include <assert.h>
-#include <glib.h>
#include "CAudioIODef.h"
+#include <sound_manager_internal.h>
using namespace std;
using namespace tizen_media_audio;
/**
* class CAudioIO
*/
+//LCOV_EXCL_START
CAudioIO::CAudioIO() :
- mpAudioSessionHandler(NULL),
mpPulseAudioClient(NULL),
__mMutex(PTHREAD_MUTEX_INITIALIZER),
__mCondMutex(PTHREAD_MUTEX_INITIALIZER),
__mCond(PTHREAD_COND_INITIALIZER),
- __mIsInit(false),
- __mForceIgnore(false) {
- mInterruptCode = IAudioSessionEventListener::EInterruptCode::INTERRUPT_MAX;
+ __mIsInit(false) {
mDirection = CAudioInfo::EAudioDirection::AUDIO_DIRECTION_MAX;
mState = CAudioInfo::EAudioIOState::AUDIO_IO_STATE_NONE;
mStatePrev = CAudioInfo::EAudioIOState::AUDIO_IO_STATE_NONE;
mByPolicy = false;
- mIsInterrupted = false;
-
}
+//LCOV_EXCL_STOP
CAudioIO::CAudioIO(CAudioInfo& audioInfo) :
- mpAudioSessionHandler(NULL),
mpPulseAudioClient(NULL),
__mMutex(PTHREAD_MUTEX_INITIALIZER),
__mCondMutex(PTHREAD_MUTEX_INITIALIZER),
__mCond(PTHREAD_COND_INITIALIZER),
- __mIsInit(false),
- __mForceIgnore(false) {
+ __mIsInit(false) {
mAudioInfo = audioInfo;
- mInterruptCode = IAudioSessionEventListener::EInterruptCode::INTERRUPT_MAX;
mDirection = CAudioInfo::EAudioDirection::AUDIO_DIRECTION_MAX;
mState = CAudioInfo::EAudioIOState::AUDIO_IO_STATE_NONE;
mStatePrev = CAudioInfo::EAudioIOState::AUDIO_IO_STATE_NONE;
mByPolicy = false;
- mIsInterrupted = false;
}
CAudioIO::~CAudioIO() {
}
bool CAudioIO::IsReady() {
- return ((mState == CAudioInfo::EAudioIOState::AUDIO_IO_STATE_RUNNING || mState == CAudioInfo::EAudioIOState::AUDIO_IO_STATE_PAUSED)? true : false);
+ return ((mState == CAudioInfo::EAudioIOState::AUDIO_IO_STATE_RUNNING ||
+ mState == CAudioInfo::EAudioIOState::AUDIO_IO_STATE_PAUSED)? true : false);
}
void CAudioIO::internalLock() {
- if (__mIsInit == false) {
+ if (__mIsInit == false)
THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
- }
- if (pthread_mutex_lock(&__mMutex) != 0) {
- THROW_ERROR_MSG(CAudioError::EError::ERROR_INTERNAL_OPERATION, "Failed pthread_mutex_lock()");
- }
+ if (pthread_mutex_lock(&__mMutex) != 0)
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_INTERNAL_OPERATION, "Failed pthread_mutex_lock()"); //LCOV_EXCL_LINE
#ifdef _AUDIO_IO_DEBUG_TIMING_
AUDIO_IO_LOGD(COLOR_RED "%p LOCKED" COLOR_END, &__mMutex);
}
void CAudioIO::internalUnlock() {
- if (__mIsInit == false) {
+ if (__mIsInit == false)
THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
- }
- if (pthread_mutex_unlock(&__mMutex) != 0) {
- THROW_ERROR_MSG(CAudioError::EError::ERROR_INTERNAL_OPERATION, "Failed pthread_mutex_lock()");
- }
+ if (pthread_mutex_unlock(&__mMutex) != 0)
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_INTERNAL_OPERATION, "Failed pthread_mutex_lock()"); //LCOV_EXCL_LINE
+
#ifdef _AUDIO_IO_DEBUG_TIMING_
AUDIO_IO_LOGD(COLOR_GREEN "%p UNLOCKED" COLOR_END, &__mMutex);
#endif
}
void CAudioIO::internalWait() {
- if (__mIsInit == false) {
+ if (__mIsInit == false)
THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
- }
#ifdef _AUDIO_IO_DEBUG_TIMING_
AUDIO_IO_LOGD(COLOR_RED "WAIT" COLOR_END);
}
void CAudioIO::internalSignal() {
- if (__mIsInit == false) {
+ if (__mIsInit == false)
THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
- }
#ifdef _AUDIO_IO_DEBUG_TIMING_
AUDIO_IO_LOGD(COLOR_GREEN "SIGNAL" COLOR_END);
pthread_mutex_unlock(&__mCondMutex);
}
-bool CAudioIO::isForceIgnore() {
- return __mForceIgnore;
-}
-
void CAudioIO::initialize() {
- if (__mIsInit == true) {
+ if (__mIsInit == true)
return;
- }
AUDIO_IO_LOGD("initialize");
int ret = pthread_mutex_init(&__mMutex, NULL);
- if (ret != 0) {
- THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed pthread_mutex_init()");
- }
+ if (ret != 0)
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed pthread_mutex_init()"); //LCOV_EXCL_LINE
ret = pthread_cond_init(&__mCond, NULL);
- if (ret != 0) {
- THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed pthread_cond_init()");
- }
+ if (ret != 0)
+ THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed pthread_cond_init()"); //LCOV_EXCL_LINE
__mIsInit = true;
}
void CAudioIO::finalize() {
- if (__mIsInit == false) {
+ if (__mIsInit == false)
return;
- }
AUDIO_IO_LOGD("finalize");
bool error_occured = false;
int ret = pthread_mutex_destroy(&__mMutex);
if (ret != 0) {
- AUDIO_IO_LOGE("Failed pthread_mutex_destroy(%p) errno:%d", &__mMutex, ret);
+ AUDIO_IO_LOGE("Failed pthread_mutex_destroy(%p) errno:%d", &__mMutex, ret); //LCOV_EXCL_LINE
error_occured = true;
-
}
+
ret = pthread_mutex_destroy(&__mCondMutex);
if (ret != 0) {
- AUDIO_IO_LOGE("Failed pthread_mutex_destroy(%p) errno:%d", &__mCondMutex, ret);
+//LCOV_EXCL_START
+ AUDIO_IO_LOGE("Failed cond pthread_mutex_destroy(%p) errno:%d", &__mCondMutex, ret);
error_occured = true;
+//LCOV_EXCL_STOP
}
-
ret = pthread_cond_destroy(&__mCond);
if (ret != 0) {
+//LCOV_EXCL_START
AUDIO_IO_LOGE("Failed pthread_cond_destroy(%p) errno:%d", &__mCond, ret);
error_occured = true;
+//LCOV_EXCL_STOP
}
if (error_occured)
AUDIO_IO_LOGD("mStreamCallback.onStream(%p), pClient(%p), length(%zu)", mStreamCallback.onStream, pClient, length);
#endif
- if (mStreamCallback.onStream != NULL) {
+ if (mStreamCallback.onStream != NULL)
mStreamCallback.onStream(length, mStreamCallback.mUserData);
- }
}
void CAudioIO::onStateChanged(CAudioInfo::EAudioIOState state, bool byPolicy) {
assert(state >= CAudioInfo::EAudioIOState::AUDIO_IO_STATE_NONE && state < CAudioInfo::EAudioIOState::AUDIO_IO_STATE_MAX);
mStatePrev = mState;
- mState = state;
- mByPolicy = byPolicy;
+ mState = state;
+ mByPolicy = byPolicy;
if (mState == mStatePrev)
return;
static_cast<int>(mState),
mByPolicy);
- if (mStateChangedCallback.onStateChanged != NULL) {
+ if (mStateChangedCallback.onStateChanged != NULL)
mStateChangedCallback.onStateChanged(mState, mStatePrev, mByPolicy, mStateChangedCallback.mUserData);
- }
}
void CAudioIO::onStateChanged(CAudioInfo::EAudioIOState state) {
return mState;
}
-int CAudioIO::sendInterrupt(void* user_data) {
- CAudioIO *pCaudioIo = (CAudioIO *)user_data;
-
- if (pCaudioIo && pCaudioIo->mInterruptCallback.onInterrupt) {
- AUDIO_IO_LOGD("sending interrupt [%d]", pCaudioIo->mInterruptCode);
- pCaudioIo->mInterruptCallback.onInterrupt(pCaudioIo->mInterruptCode, pCaudioIo->mInterruptCallback.mUserData);
- }
- return 0;
-}
-
-int caudio_gsource_callback(void *user_data) {
- CAudioIO::sendInterrupt(user_data);
- return 0;
-}
-
-void CAudioIO::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) {
- assert(pHandler);
-
- int session_option = pHandler->getOptions();
-
- if (id == -1) {
- ///////////////////////////////////////
- // Triggered by 'focus watch callback'
- ///////////////////////////////////////
-
- if (session_option & (MM_SESSION_OPTION_PAUSE_OTHERS | MM_SESSION_OPTION_UNINTERRUPTIBLE)) {
- AUDIO_IO_LOGD("Session option is pausing others or uninterruptible, skip...");
- return;
- }
-
- if (state == FOCUS_IS_RELEASED) {
- // Focus handle(id) of the other application was released, notify resume
- // Focus watch callback doesn't have focus handle, but it need to convert & report to application for convenience
- state = FOCUS_IS_ACQUIRED;
- } else if (state == FOCUS_IS_ACQUIRED) {
- // Focus handle(id) of the other application was acquired, do pause if possible
- internalLock();
- if (mpPulseAudioClient) {
- mpPulseAudioClient->cork(true);
- }
- mIsInterrupted = true;
- internalUnlock();
-
- // Focus watch callback doesn't have focus handle, but it need to convert & report to application for convenience
- state = FOCUS_IS_RELEASED;
- }
- } else {
- ///////////////////////////////////////
- // Triggered by 'focus callback'
- ///////////////////////////////////////
-
- if (pHandler->getId() != id) {
- AUDIO_IO_LOGW("Id is different, why? [mId : %d]", pHandler->getId());
- }
-
- if (session_option & MM_SESSION_OPTION_UNINTERRUPTIBLE) {
- AUDIO_IO_LOGD("Session option is uninterruptible, skip...");
- return;
- }
-
- if (state == FOCUS_IS_RELEASED) {
- // Focus handle(id) was released, do pause here
- internalLock();
- if (mpPulseAudioClient) {
- mpPulseAudioClient->cork(true);
- }
-
- mIsInterrupted = true;
- internalUnlock();
- } else if (state == FOCUS_IS_ACQUIRED) {
- // Focus handle(id) was acquired again,
- // check reason_for_change ("call-voice","call-video","voip","alarm","notification", ...)
- // do resume here and call interrupt completed callback to application.
- }
- }
-
- if (mInterruptCallback.onInterrupt != NULL) {
- IAudioSessionEventListener::EInterruptCode e = IAudioSessionEventListener::EInterruptCode::INTERRUPT_COMPLETED;
- e = IAudioSessionEventListener::convertInterruptedCode(state, reason_for_change);
-
- if (EInterruptCode::INTERRUPT_COMPLETED == e) {
- mInterruptCode = e;
- g_idle_add(caudio_gsource_callback, this);
- } else {
- mInterruptCallback.onInterrupt(e, mInterruptCallback.mUserData);
- }
- }
-}
-
-void CAudioIO::onSignal(CAudioSessionHandler* pHandler, mm_sound_signal_name_t signal, int value) {
- assert(pHandler);
-
- if (signal == MM_SOUND_SIGNAL_RELEASE_INTERNAL_FOCUS) {
- if (value == 1 && pHandler->getSubscribeId() > 0) {
- // Unregister focus watch callback & disable session handler
- pHandler->disableSessionHandler();
- AUDIO_IO_LOGD("Session handler disabled by signal");
- } else if (value == 0) {
- // Currently do nothing...
- }
- }
-}
-
void CAudioIO::prepare() {
- if (__mIsInit == false) {
+ if (__mIsInit == false)
THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
- }
- if (mDirection == CAudioInfo::EAudioDirection::AUDIO_DIRECTION_IN) {
- AUDIO_IO_LOGD("Prepare for Audio in");
- } else if (mDirection == CAudioInfo::EAudioDirection::AUDIO_DIRECTION_OUT) {
- AUDIO_IO_LOGD("Prepare for Audio Out");
- }
- try {
- if (mIsInterrupted) {
- AUDIO_IO_LOGE("This is preparing during interrupted!!!");
- bool isSkip = mpAudioSessionHandler->isSkipSession();
- if (__mForceIgnore == false && isSkip == false && mpAudioSessionHandler->getId() >= 0) {
- AUDIO_IO_LOGE("Session updatePlaying!!!");
- mpAudioSessionHandler->updatePlaying();
- }
-
- if (mpPulseAudioClient && mpPulseAudioClient->isCorked()) {
- AUDIO_IO_LOGE("Uncork!");
- mpPulseAudioClient->cork(false);
- }
- mIsInterrupted = false;
- }
-
- AUDIO_IO_LOGD("------> prepare done");
- /* Do nothing */
- } catch (CAudioError& e) {
- throw;
- }
}
void CAudioIO::unprepare() {
- if (__mIsInit == false) {
+ if (__mIsInit == false)
THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
- }
-
- try {
- AUDIO_IO_LOGD("unprepare ----->");
- /* Do nothing */
- } catch (CAudioError& e) {
- throw;
- }
}
void CAudioIO::pause() {
- if (__mIsInit == false || IsReady() == false) {
+ if (__mIsInit == false || IsReady() == false)
THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioIO");
- }
try {
internalLock();
}
void CAudioIO::resume() {
- if (__mIsInit == false || IsReady() == false) {
+ if (__mIsInit == false || IsReady() == false)
THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioIO");
- }
try {
internalLock();
}
void CAudioIO::drain() {
- if (__mIsInit == false || IsReady() == false) {
+ if (__mIsInit == false || IsReady() == false)
THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioIO");
- }
try {
if (mpPulseAudioClient->isInThread()) {
internalUnlock();
}
} catch (CAudioError& e) {
- if (!mpPulseAudioClient->isInThread()) {
+ if (!mpPulseAudioClient->isInThread())
internalUnlock();
- }
throw;
}
}
void CAudioIO::flush() {
- if (__mIsInit == false || IsReady() == false) {
+ if (__mIsInit == false || IsReady() == false)
THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize or prepare CAudioIO");
- }
try {
if (mpPulseAudioClient->isInThread()) {
internalUnlock();
}
} catch (CAudioError& e) {
- if (!mpPulseAudioClient->isInThread()) {
+ if (!mpPulseAudioClient->isInThread())
internalUnlock();
- }
throw;
}
}
CAudioInfo& CAudioIO::getAudioInfo() {
- if (__mIsInit == false) {
+ if (__mIsInit == false)
THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
- }
return mAudioInfo;
}
void CAudioIO::setStreamCallback(SStreamCallback callback) {
- if (__mIsInit == false) {
+ if (__mIsInit == false)
THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
- }
mStreamCallback = callback;
}
CAudioIO::SStreamCallback CAudioIO::getStreamCallback() {
- if (__mIsInit == false) {
+ if (__mIsInit == false)
THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
- }
return mStreamCallback;
}
void CAudioIO::setStateChangedCallback(SStateChangedCallback callback) {
- if (__mIsInit == false) {
+ if (__mIsInit == false)
THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
- }
mStateChangedCallback = callback;
}
CAudioIO::SStateChangedCallback CAudioIO::getStateChangedCallback() {
- if (__mIsInit == false) {
- THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
- }
-
- return mStateChangedCallback;
-}
-
-void CAudioIO::setInterruptCallback(SInterruptCallback callback) {
- if (__mIsInit == false) {
- THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
- }
-
- mInterruptCallback = callback;
-}
-
-CAudioIO::SInterruptCallback CAudioIO::getInterruptCallback() {
- if (__mIsInit == false) {
- THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
- }
-
- return mInterruptCallback;
-}
-
-void CAudioIO::ignoreSession() {
if (__mIsInit == false)
THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
- try {
- internalLock();
-
- if (mpPulseAudioClient != NULL && mState == CAudioInfo::EAudioIOState::AUDIO_IO_STATE_RUNNING)
- THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_OPERATION, "An Operation is not permitted while started");
-
- abandonInternalFocus();
-
- internalUnlock();
- } catch (CAudioError& e) {
- internalUnlock();
- throw;
- }
+ return mStateChangedCallback;
}
void CAudioIO::setStreamInfo(sound_stream_info_h stream_info) {
if (mState != CAudioInfo::EAudioIOState::AUDIO_IO_STATE_IDLE)
THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_STATE, "it is not permitted while started");
- abandonInternalFocus();
-
int errorCode = SOUND_MANAGER_ERROR_NONE;
CAudioInfo::EAudioType audioType = CAudioInfo::EAudioType::AUDIO_IN_TYPE_MEDIA;
char *type = NULL;
if ((errorCode = sound_manager_is_available_stream_information(stream_info, NATIVE_API_AUDIO_IO, &avail)) != SOUND_MANAGER_ERROR_NONE)
THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter stream_info is invalid [ret:%d]", errorCode);
-
if (!avail)
THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_NOT_SUPPORTED_TYPE, "Input stream is not supported");
if ((errorCode = sound_manager_get_type_from_stream_information(stream_info, &type)) != SOUND_MANAGER_ERROR_NONE)
- THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter stream_info->stream_type is invalid [ret:%d]", errorCode);
-
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter stream_info->stream_type is invalid [ret:%d]", errorCode); //LCOV_EXCL_LINE
if (mDirection == CAudioInfo::EAudioDirection::AUDIO_DIRECTION_IN)
getAudioInfo().convertInputStreamType2AudioType(type, &audioType);
else
getAudioInfo().setAudioType(audioType);
if ((errorCode = sound_manager_get_index_from_stream_information(stream_info, &index)) != SOUND_MANAGER_ERROR_NONE)
- THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter stream_info->index is invalid [ret:%d]", errorCode);
-
+ THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter stream_info->index is invalid [ret:%d]", errorCode); //LCOV_EXCL_LINE
getAudioInfo().setAudioIndex(index);
- AUDIO_IO_LOGD("stream info(%p) is set", stream_info);
- } catch (CAudioError& e) {
- throw;
- }
-}
-
-void CAudioIO::setInternalStreamInfo() {
- if (__mIsInit == false)
- THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Doesn't initialize CAudioIO");
-
- try {
- if (mState != CAudioInfo::EAudioIOState::AUDIO_IO_STATE_IDLE)
- THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_STATE, "it is not permitted while started");
-
- if (mpAudioSessionHandler &&
- mpAudioSessionHandler->getMultimediaSession() == MM_SESSION_TYPE_VOIP) {
- sound_stream_info_h stream_info = NULL;
- mpAudioSessionHandler->getInternalVoipStreamInfo(&stream_info);
- AUDIO_IO_LOGD("get internal VOIP stream info(%p)", stream_info);
- setStreamInfo(stream_info);
- }
- } catch (CAudioError& e) {
- throw;
- }
-}
-
-void CAudioIO::abandonInternalFocus() {
- bool isSkip = mpAudioSessionHandler->isSkipSession();
- int id = mpAudioSessionHandler->getId();
-
- try {
- if (isSkip == false && id >= 0)
- mpAudioSessionHandler->unregisterSound();
-
- mpAudioSessionHandler->finalize();
- __mForceIgnore = true;
} catch (CAudioError& e) {
throw;
}
projects / platform / core / api / audio-io.git / blobdiff