void MediaRecorderImpl::unprepareRecorder(recorder_result_t& ret)
{
medvdbg("unprepareRecorder mCurState : %d\n", (recorder_state_t)mCurState);
if (mCurState == RECORDER_STATE_NONE || mCurState == RECORDER_STATE_IDLE) {
meddbg("unprepare Failed : %d\n", (recorder_state_t)mCurState);
return notifySync();
}
audio_manager_result_t result = reset_audio_stream_in();
if (result != AUDIO_MANAGER_SUCCESS) {
meddbg("reset_audio_stream_in failed ret : %d\n", result);
return notifySync();
}
if (mOutputDataSource->isPrepare()) {
mOutputDataSource->close();
}
if (mBuffer) {
delete[] mBuffer;
mBuffer = nullptr;
}
mBuffSize = 0;
mDuration = 0;
mTotalFrames = 0;
mCapturedFrames = 0;
mCurState = RECORDER_STATE_IDLE;
ret = RECORDER_OK;
notifySync();
}
void MediaRecorderImpl::destroyRecorder(recorder_result_t& ret)
{
medvdbg("destroyRecorder mCurState : %d\n", (recorder_state_t)mCurState);
if (mCurState != RECORDER_STATE_IDLE) {
meddbg("mCurState != RECORDER_STATE_IDLE mCurState : %d\n", (recorder_state_t)mCurState);
return notifySync();
}
mCurState = RECORDER_STATE_NONE;
ret = RECORDER_OK;
notifySync();
}
void MediaRecorderImpl::setRecorderDuration(int second, recorder_result_t& ret)
{
medvdbg("setRecorderDuration mCurState : %d\n", (recorder_state_t)mCurState);
if (mCurState != RECORDER_STATE_IDLE) {
meddbg("setRecorderDuration Failed mCurState: %d\n", (recorder_state_t)mCurState);
return notifySync();
}
if (second > 0) {
medvdbg("second is greater than zero, set limit : %d\n", second);
mDuration = second;
}
ret = RECORDER_OK;
notifySync();
}
void MediaRecorderImpl::setRecorderDataSource(std::shared_ptr<stream::OutputDataSource> dataSource, recorder_result_t& ret)
{
if (mCurState != RECORDER_STATE_IDLE) {
meddbg("setDataSource failed mCurState : %d\n", (recorder_state_t)mCurState);
return notifySync();
}
if (!dataSource) {
meddbg("DataSource is nullptr\n");
return notifySync();
}
mOutputDataSource = dataSource;
ret = RECORDER_OK;
notifySync();
}
void MediaRecorderImpl::getRecorderVolume(int& ret)
{
medvdbg("getRecorderVolume\n");
ret = get_input_audio_volume();
notifySync();
}
void MediaRecorderImpl::createRecorder(recorder_result_t& ret)
{
medvdbg("createRecorder mCurState : %d\n", (recorder_state_t)mCurState);
if (mCurState != RECORDER_STATE_NONE) {
meddbg("mCurState != RECORDER_STATE_NONE mCurState : %d\n", (recorder_state_t)mCurState);
return notifySync();
}
audio_manager_result_t result = init_audio_stream_in();
if (result != AUDIO_MANAGER_SUCCESS) {
meddbg("Fail to initialize input audio stream : %d\n", result);
return notifySync();
}
mCurState = RECORDER_STATE_IDLE;
ret = RECORDER_OK;
notifySync();
}
void MediaRecorderImpl::setRecorderVolume(int vol, recorder_result_t& ret)
{
medvdbg("setRecorderVolume\n");
int maxVolume = get_max_audio_volume();
if (vol < 0 || vol > maxVolume) {
meddbg("Volume is out of range vol : %d (recorder ranage 0 ~ %d)\n", vol, maxVolume);
return notifySync();
}
audio_manager_result_t result = set_input_audio_volume((uint8_t)vol);
if (result != AUDIO_MANAGER_SUCCESS) {
meddbg("set_input_audio_volume failed vol : %d ret : %d\n", vol, result);
return notifySync();
}
medvdbg("setVolume is success vol : %d\n", vol);
ret = RECORDER_OK;
notifySync();
}
void MediaRecorderImpl::setRecorderObserver(std::shared_ptr<MediaRecorderObserverInterface> observer)
{
medvdbg("setRecorderObserver\n");
RecorderObserverWorker& row = RecorderObserverWorker::getWorker();
if (mRecorderObserver) {
medvdbg("stopWorker\n");
row.stopWorker();
}
if (observer) {
medvdbg("startWorker\n");
row.startWorker();
}
mRecorderObserver = observer;
notifySync();
}
void MediaRecorderImpl::prepareRecorder(recorder_result_t& ret)
{
medvdbg("prepareRecorder mCurState : %d\n", (recorder_state_t)mCurState);
if (mCurState != RECORDER_STATE_IDLE || mOutputDataSource == nullptr) {
meddbg("prepare Failed mCurState: %d mOutputDataSource : %s\n", (recorder_state_t)mCurState, \
(mOutputDataSource == nullptr ? "nullptr" : "not null"));
return notifySync();
}
if (!mOutputDataSource->open()) {
meddbg("open() failed\n");
return notifySync();
}
audio_manager_result_t result = set_audio_stream_in(mOutputDataSource->getChannels(), mOutputDataSource->getSampleRate(),
(pcm_format)mOutputDataSource->getPcmFormat());
if (result != AUDIO_MANAGER_SUCCESS) {
meddbg("set_audio_stream_in failed : result : %d channel %d sample rate : %d format : %d\n", result, \
mOutputDataSource->getChannels(), mOutputDataSource->getSampleRate(), (pcm_format)mOutputDataSource->getPcmFormat());
mOutputDataSource->close();
return notifySync();
}
mBuffSize = get_input_frames_to_byte(get_input_frame_count());
if (mBuffSize <= 0) {
meddbg("Buffer size is too small size : %d\n", mBuffSize);
mOutputDataSource->close();
return notifySync();
}
medvdbg("mBuffer size : %d\n", mBuffSize);
mBuffer = new unsigned char[mBuffSize];
if (!mBuffer) {
meddbg("mBuffer alloc failed\n");
mOutputDataSource->close();
return notifySync();
}
if (mDuration > 0) {
mTotalFrames = mDuration * mOutputDataSource->getSampleRate();
}
mCurState = RECORDER_STATE_READY;
ret = RECORDER_OK;
notifySync();
}
/// hook of GetMessage
LRESULT CALLBACK getMessageProc(int i_nCode, WPARAM i_wParam, LPARAM i_lParam)
{
if (!g.m_isInitialized)
initialize(false);
if (!g_hookData)
return 0;
MSG &msg = (*(MSG *)i_lParam);
if (i_wParam != PM_REMOVE)
goto finally;
switch (msg.message) {
case WM_COMMAND:
case WM_SYSCOMMAND:
notifyCommand(msg.hwnd, msg.message, msg.wParam, msg.lParam);
break;
case WM_KEYDOWN:
case WM_KEYUP:
case WM_SYSKEYDOWN:
case WM_SYSKEYUP: {
if (HIMC hIMC = ImmGetContext(msg.hwnd)) {
bool prev = g.m_isImeLock;
g.m_isImeLock = !!ImmGetOpenStatus(hIMC);
ImmReleaseContext(msg.hwnd, hIMC);
if (prev != g.m_isImeLock) {
notifyLockState(1);
}
}
int nVirtKey = (int)msg.wParam;
// int repeatCount = (msg.lParam & 0xffff);
BYTE scanCode = (BYTE)((msg.lParam >> 16) & 0xff);
bool isExtended = !!(msg.lParam & (1 << 24));
// bool isAltDown = !!(msg.lParam & (1 << 29));
// bool isKeyup = !!(msg.lParam & (1 << 31));
if (nVirtKey == VK_CAPITAL ||
nVirtKey == VK_NUMLOCK ||
nVirtKey == VK_KANA ||
nVirtKey == VK_SCROLL)
notifyLockState(2);
else if (scanCode == g_hookData->m_syncKey &&
isExtended == g_hookData->m_syncKeyIsExtended)
notifySync();
break;
}
case WM_IME_STARTCOMPOSITION:
g.m_isImeCompositioning = true;
notifyLockState(3);
break;
case WM_IME_ENDCOMPOSITION:
g.m_isImeCompositioning = false;
notifyLockState(4);
break;
default:
if (i_wParam == PM_REMOVE && msg.message == g.m_WM_MAYU_MESSAGE) {
switch (msg.wParam) {
case MayuMessage_notifyName:
notifyName(msg.hwnd);
break;
case MayuMessage_funcRecenter:
funcRecenter(msg.hwnd);
break;
case MayuMessage_funcSetImeStatus:
funcSetImeStatus(msg.hwnd, msg.lParam);
break;
case MayuMessage_funcSetImeString:
funcSetImeString(msg.hwnd, msg.lParam);
break;
}
}
break;
}
finally:
return CallNextHookEx(s_hookDataArch->m_hHookGetMessage,
i_nCode, i_wParam, i_lParam);
}
