return cpp_audio_in_unset_state_changed_cb(input);
}
-
/* Audio Out */
int audio_out_create_new(int sample_rate, audio_channel_e channel, audio_sample_type_e type, audio_out_h *output)
{
CAudioError::EError CAudioError::__mLastError = CAudioError::EError::ERROR_NONE;
char CAudioError::__mLastErrorMsg[CAudioError::MSG_LENGTH];
+//LCOV_EXCL_START
CAudioError::CAudioError(EError err) :
__mError(err) {
__mLastError = __mError;
snprintf(__mLastErrorMsg, CAudioError::MSG_LENGTH, "LastError:%s", __mErrorMsg);
}
+//LCOV_EXCL_STOP
CAudioError::CAudioError(EError err, const char* msg, const char* fileName, const char* parentFunc, int lineNum) :
__mError(err) {
snprintf(__mLastErrorMsg, CAudioError::MSG_LENGTH, "LastError:%s", __mErrorMsg);
}
+//LCOV_EXCL_START
CAudioError::CAudioError(const CAudioError& err) {
__mError = err.__mError;
memcpy(__mErrorMsg, err.__mErrorMsg, MSG_LENGTH);
}
+//LCOV_EXCL_STOP
CAudioError::~CAudioError() {
}
default:
case EError::ERROR_NONE: return COLOR_GREEN "ERROR_NONE" COLOR_END;
case EError::ERROR_INVALID_ARGUMENT: return COLOR_RED "ERROR_INVALID_ARGUMENT" COLOR_END;
+//LCOV_EXCL_START
case EError::ERROR_INVALID_HANDLE: return COLOR_RED "ERROR_INVALID_HANDLE" COLOR_END;
case EError::ERROR_INVALID_SAMPLERATE: return COLOR_RED "ERROR_INVALID_SAMPLERATE" COLOR_END;
case EError::ERROR_INVALID_CHANNEL: return COLOR_RED "ERROR_INVALID_CHANNEL" COLOR_END;
case EError::ERROR_INVALID_FORMAT: return COLOR_RED "ERROR_INVALID_FORMAT" COLOR_END;
case EError::ERROR_INVALID_POINTER: return COLOR_RED "ERROR_INVALID_POINTER" COLOR_END;
+//LCOV_EXCL_STOP
case EError::ERROR_INVALID_OPERATION: return COLOR_RED "ERROR_INVALID_OPERATION" COLOR_END;
case EError::ERROR_INVALID_STATE: return COLOR_RED "ERROR_INVALID_STATE" COLOR_END;
case EError::ERROR_NOT_INITIALIZED: return COLOR_RED "ERROR_NOT_INITIALIZED" COLOR_END;
case EError::ERROR_NOT_SUPPORTED: return COLOR_RED "ERROR_NOT_SUPPORTED" COLOR_END;
case EError::ERROR_NOT_SUPPORTED_TYPE: return COLOR_RED "ERROR_NOT_SUPPORTED_TYPE" COLOR_END;
+//LCOV_EXCL_START
case EError::ERROR_PERMISSION_DENIED: return COLOR_RED "ERROR_PERMISSION_DENIED" COLOR_END;
case EError::ERROR_DEVICE_POLICY_RESTRICTION: return COLOR_RED "ERROR_DEVICE_POLICY_RESTRICTION" COLOR_END;
case EError::ERROR_DEVICE_NOT_OPENED: return COLOR_RED "ERROR_DEVICE_NOT_OPENED" COLOR_END;
case EError::ERROR_POLICY_BLOCKED: return COLOR_RED "ERROR_POLICY_BLOCKED" COLOR_END;
case EError::ERROR_POLICY_INTERRUPTED: return COLOR_RED "ERROR_POLICY_INTERRUPTED" COLOR_END;
case EError::ERROR_POLICY_DUPLICATED: return COLOR_RED "ERROR_POLICY_DUPLICATED" COLOR_END;
+//LCOV_EXCL_STOP
}
}
+//LCOV_EXCL_START
CAudioError::EError CAudioError::getLastError() {
return __mLastError;
}
const char* CAudioError::getLastErrorMsg() {
return __mLastErrorMsg;
}
+//LCOV_EXCL_STOP
CAudioError::EError CAudioError::getError() {
return __mError;
return __mErrorMsg;
}
+//LCOV_EXCL_START
CAudioError& CAudioError::operator = (const EError err) {
__mError = err;
__mLastError = __mError;
bool CAudioError::operator == (const EError err) {
return (__mError == err);
}
+//LCOV_EXCL_STOP
//bool operator == (const CAudioError& src, const CAudioError::EError& err) {
// //return (src.__mLastError == err);
internalUnlock();
throw;
} catch (const std::bad_alloc&) {
+//LCOV_EXCL_START
internalUnlock();
THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed to allocate CPulseAudioClient object");
+//LCOV_EXCL_STOP
}
}
internalUnlock();
throw;
} catch (const std::bad_alloc&) {
+//LCOV_EXCL_START
internalUnlock();
THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed to allocate CPulseAudioClient object");
+//LCOV_EXCL_STOP
}
}
}
}
+//LCOV_EXCL_START
void CPulseAudioClient::__successContextCb(pa_context* c, int success, void* user_data) {
AUDIO_IO_LOGD("pa_context[%p], success[%d], user_data[%p]", c, success, user_data);
assert(c);
#endif
return (state ? false : true);
}
+//LCOV_EXCL_STOP
void CPulseAudioClient::__streamStateChangeCb(pa_stream* s, void* user_data) {
assert(s);
pClient->__mIsStarted = false;
}
+//LCOV_EXCL_START
void CPulseAudioClient::__streamEventCb(pa_stream* s, const char *name, pa_proplist *pl, void *user_data) {
assert(s);
assert(user_data);
pa_operation_unref(pa_stream_cork(pClient->__mpStream, 1, NULL, NULL));
}
}
-
+//LCOV_EXCL_STOP
void CPulseAudioClient::__successStreamCb(pa_stream* s, int success, void* user_data) {
AUDIO_IO_LOGD("pa_stream[%p], success[%d], user_data[%p]", s, success, user_data);
pa_threaded_mainloop_signal(pClient->__mpMainloop, 0);
}
+//LCOV_EXCL_START
void CPulseAudioClient::__successDrainCbInThread(pa_stream* s, int success, void* user_data) {
AUDIO_IO_LOGD("pa_stream[%p], success[%d], user_data[%p]", s, success, user_data);
assert(s);
pClient->__mIsOperationSuccess = static_cast<bool>(success);
pClient->__mIsDraining = false;
}
+//LCOV_EXCL_STOP
void CPulseAudioClient::__successDrainCb(pa_stream* s, int success, void* user_data) {
AUDIO_IO_LOGD("pa_stream[%p], success[%d], user_data[%p]", s, success, user_data);
return static_cast<bool>(ret);
}
+//LCOV_EXCL_START
size_t CPulseAudioClient::getReadableSize() {
if (__mIsInit == false) {
THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
CPulseStreamSpec CPulseAudioClient::getStreamSpec() {
return __mSpec;
}
+//LCOV_EXCL_STOP
// Sets stream name
switch (__mLatency) {
+//LCOV_EXCL_START
case EStreamLatency::STREAM_LATENCY_INPUT_LOW:
__mStreamName = STREAM_NAME_INPUT_LOW_LATENCY;
break;
case EStreamLatency::STREAM_LATENCY_INPUT_VOIP:
__mStreamName = STREAM_NAME_INPUT_VOIP;
break;
+//LCOV_EXCL_STOP
case EStreamLatency::STREAM_LATENCY_INPUT_DEFAULT:
__mStreamName = STREAM_NAME_INPUT_DEFAULT;
break;
+//LCOV_EXCL_START
case EStreamLatency::STREAM_LATENCY_OUTPUT_LOW:
__mStreamName = STREAM_NAME_OUTPUT_LOW_LATENCY;
break;
case EStreamLatency::STREAM_LATENCY_OUTPUT_VOIP:
__mStreamName = STREAM_NAME_OUTPUT_VOIP;
break;
+//LCOV_EXCL_STOP
case EStreamLatency::STREAM_LATENCY_OUTPUT_DEFAULT:
__mStreamName = STREAM_NAME_OUTPUT_DEFAULT;
__mStreamName = STREAM_NAME_OUTPUT_DEFAULT_ASYNC;
break;
+//LCOV_EXCL_START
default:
AUDIO_IO_LOGW("Invalid __mLatency[%d]", static_cast<int>(__mLatency));
break;
}
+//LCOV_EXCL_STOP
}
CPulseStreamSpec::EStreamLatency CPulseStreamSpec::getStreamLatency() {
const char* latency;
switch (__mLatency) {
+//LCOV_EXCL_START
case EStreamLatency::STREAM_LATENCY_INPUT_LOW:
case EStreamLatency::STREAM_LATENCY_OUTPUT_LOW:
latency = STREAM_LATENCY_LOW;
case EStreamLatency::STREAM_LATENCY_OUTPUT_VOIP:
latency = STREAM_LATENCY_VOIP;
break;
+//LCOV_EXCL_STOP
case EStreamLatency::STREAM_LATENCY_INPUT_DEFAULT:
case EStreamLatency::STREAM_LATENCY_OUTPUT_DEFAULT:
latency = STREAM_LATENCY_DEFAULT_ASYNC;
break;
+//LCOV_EXCL_START
default:
AUDIO_IO_LOGW("Invalid __mLatency[%d]", static_cast<int>(__mLatency));
latency = STREAM_LATENCY_DEFAULT;
break;
+//LCOV_EXCL_STOP
}
return latency;
__handle_safe_free(handle, (void *)input, false);
return __convert_CAudioError(e);
} catch (const std::bad_alloc&) {
+//LCOV_EXCL_START
CAudioError e = CAudioError::EError::ERROR_OUT_OF_MEMORY;
AUDIO_IO_LOGE("Failed to allocate handle");
__handle_safe_free(handle, (void *)input, false);
return __convert_CAudioError(e);
+//LCOV_EXCL_STOP
}
return AUDIO_IO_ERROR_NONE;
return AUDIO_IO_ERROR_NONE;
}
+//LCOV_EXCL_START
int cpp_audio_in_drain(audio_in_h input) {
audio_io_s* handle = static_cast<audio_io_s*>(input);
return AUDIO_IO_ERROR_NONE;
}
+//LCOV_EXCL_STOP
int cpp_audio_in_flush(audio_in_h input) {
audio_io_s* handle = static_cast<audio_io_s*>(input);
audioIo->stream_callback.onStream(audioIo, nbytes, audioIo->stream_callback.user_data);
}
+//LCOV_EXCL_START
static void __state_changed_cb_internal(CAudioInfo::EAudioIOState state,
CAudioInfo::EAudioIOState state_prev,
bool by_policy,
__convert_state_type(state), by_policy,
audioIo->state_changed_callback.user_data);
}
+//LCOV_EXCL_STOP
int cpp_audio_in_set_stream_cb(audio_in_h input, audio_in_stream_cb callback, void* user_data) {
audio_io_s* handle = static_cast<audio_io_s*>(input);
__handle_safe_free(handle, (void *)output, true);
return __convert_CAudioError(e);
} catch (const std::bad_alloc&) {
+//LCOV_EXCL_START
CAudioError e = CAudioError::EError::ERROR_OUT_OF_MEMORY;
AUDIO_IO_LOGE("Failed to allocate handle");
__handle_safe_free(handle, (void *)output, true);
return __convert_CAudioError(e);
+//LCOV_EXCL_STOP
}
return AUDIO_IO_ERROR_NONE;