reactos/base/applications/sndrec32/audio_wavein.cpp

420 lines
12 KiB
C++
Raw Normal View History

/* PROJECT: ReactOS sndrec32
* LICENSE: GPL - See COPYING in the top level directory
* FILE: base/applications/sndrec32/audio_wavein.cpp
* PURPOSE: Sound recording
* PROGRAMMERS: Marco Pagliaricci (irc: rendar)
*/
#include "stdafx.h"
#include "audio_wavein.hpp"
_AUDIO_NAMESPACE_START_
void
audio_wavein::init_(void)
{
ZeroMemory((LPVOID)&wave_format, sizeof(WAVEFORMATEX));
wave_format.cbSize = sizeof(WAVEFORMATEX);
wavein_handle = 0;
recthread_id = 0;
wakeup_recthread = 0;
data_flushed_event = 0;
buf_secs = _AUDIO_DEFAULT_WAVEINBUFSECS;
status = WAVEIN_NOTREADY;
}
void
audio_wavein::alloc_buffers_mem_(unsigned int buffs, float secs)
{
unsigned int onebuf_size = 0, tot_size = 0;
/* Release old memory */
if (main_buffer)
delete[] main_buffer;
if (wave_headers)
delete[] wave_headers;
/* Calcs size of the buffers */
onebuf_size = (unsigned int)((float)aud_info.byte_rate() * secs);
tot_size = onebuf_size * buffs;
/* Allocs memory for the audio buffers */
main_buffer = new BYTE[tot_size];
/* Allocs memory for the `WAVEHDR' structures */
wave_headers = (WAVEHDR *)new BYTE[sizeof(WAVEHDR) * buffs];
/* Zeros memory */
ZeroMemory(main_buffer, tot_size);
ZeroMemory(wave_headers, sizeof(WAVEHDR) * buffs);
/* Updates total size of the buffers */
mb_size = tot_size;
}
void
audio_wavein::free_buffers_mem_(void)
{
/* Frees memory */
if (main_buffer)
delete[] main_buffer;
if (wave_headers)
delete[] wave_headers;
main_buffer = 0;
wave_headers = 0;
}
void
audio_wavein::init_headers_(void)
{
/* If there is no memory for memory or headers, simply return */
if ((!wave_headers) || (!main_buffer))
return;
/* This is the size for one buffer */
DWORD buf_sz = mb_size / buffers;
/* This is the base address for one buffer */
BYTE *buf_addr = main_buffer;
/* Initializes headers */
for (unsigned int i = 0; i < buffers; ++i)
{
wave_headers[i].dwBufferLength = mb_size / buffers;
wave_headers[i].lpData = (LPSTR)buf_addr;
buf_addr += buf_sz;
}
}
void
audio_wavein::prep_headers_(void)
{
MMRESULT err;
bool error = false;
/* If there is no memory for memory or headers, throw error */
if ((!wave_headers) || (!main_buffer) || (!wavein_handle))
{
/* TODO: throw error! */
}
for (unsigned int i = 0; i < buffers; ++i)
{
err = waveInPrepareHeader(wavein_handle, &wave_headers[i], sizeof(WAVEHDR));
if (err != MMSYSERR_NOERROR)
error = true;
}
if (error)
MessageBox(0, TEXT("waveInPrepareHeader Error."), 0, 0);
}
void
audio_wavein::unprep_headers_(void)
{
MMRESULT err;
bool error = false;
/* If there is no memory for memory or headers, throw error */
if ((!wave_headers) || (!main_buffer) || (!wavein_handle))
{
/* TODO: throw error! */
}
for (unsigned int i = 0; i < buffers; ++i)
{
err = waveInUnprepareHeader(wavein_handle, &wave_headers[i], sizeof(WAVEHDR));
if (err != MMSYSERR_NOERROR)
error = true;
}
if (error)
MessageBox(0, TEXT("waveInUnPrepareHeader Error."), 0, 0);
}
void
audio_wavein::add_buffers_to_driver_(void)
{
MMRESULT err;
bool error = false;
/* If there is no memory for memory or headers, throw error */
if ((!wave_headers) || (!main_buffer) || (!wavein_handle))
{
/* TODO: throw error! */
}
for (unsigned int i = 0; i < buffers; ++i)
{
err = waveInAddBuffer(wavein_handle, &wave_headers[i], sizeof(WAVEHDR));
if (err != MMSYSERR_NOERROR)
error = true;
}
if (error)
MessageBox(0, TEXT("waveInAddBuffer Error."), 0, 0);
}
void
audio_wavein::close(void)
{
/* If wavein object is already in the status NOTREADY, nothing to do */
if (status == WAVEIN_NOTREADY)
return;
/* If the wavein is recording, then stop recording and close it */
if (status == WAVEIN_RECORDING)
stop_recording();
/* Updating status */
status = WAVEIN_NOTREADY;
/* Waking up recording thread, so it can receive
the `MM_WIM_CLOSE' message then dies */
if (wakeup_recthread)
SetEvent(wakeup_recthread);
/* Closing wavein stream */
while ((waveInClose(wavein_handle)) != MMSYSERR_NOERROR)
Sleep(1);
/* Release buffers memory */
free_buffers_mem_();
/* Re-initialize variables to the initial state */
init_();
}
void
audio_wavein::open(void)
{
MMRESULT err;
HANDLE recthread_handle = 0;
/* Checkin the status of the object */
if (status != WAVEIN_NOTREADY)
{
/* TODO: throw error */
}
/* Creating the EVENT object that will be signaled
when the recording thread has to wake up */
wakeup_recthread = CreateEvent(0, FALSE, FALSE, 0);
data_flushed_event = CreateEvent(0, FALSE, FALSE, 0);
if ((!wakeup_recthread) || (!data_flushed_event))
{
status = WAVEIN_ERR;
MessageBox(0, TEXT("Thread Error."), 0, 0);
/* TODO: throw error */
}
/* Inialize buffers for recording audio data from the wavein audio line */
alloc_buffers_mem_(buffers, buf_secs);
init_headers_();
/* Sound format that will be captured by wavein */
wave_format.wFormatTag = WAVE_FORMAT_PCM;
wave_format.nChannels = aud_info.channels();
wave_format.nSamplesPerSec = aud_info.sample_rate();
wave_format.wBitsPerSample = aud_info.bits();
wave_format.nBlockAlign = aud_info.block_align();
wave_format.nAvgBytesPerSec = aud_info.byte_rate();
/* Creating the recording thread */
recthread_handle = CreateThread(NULL,
0,
audio_wavein::recording_procedure,
(PVOID)this,
0,
&recthread_id);
/* Checking thread handle */
if (!recthread_handle)
{
/* Updating status */
status = WAVEIN_ERR;
MessageBox(0, TEXT("Thread Error."), 0, 0);
/* TODO: throw error */
}
/* We don't need the thread handle anymore, so we can close it from now.
(We'll just need the thread ID for the `waveInOpen' API) */
CloseHandle(recthread_handle);
/* Opening audio line wavein */
err = waveInOpen(&wavein_handle,
0,
&wave_format,
recthread_id,
0,
CALLBACK_THREAD);
if (err != MMSYSERR_NOERROR)
{
/* Updating status */
status = WAVEIN_ERR;
if (err == WAVERR_BADFORMAT)
MessageBox(0, TEXT("waveInOpen Error"), 0, 0);
/* TODO: throw error */
}
/* Update object status */
status = WAVEIN_READY;
/* Now `audio_wavein' object is ready for audio recording! */
}
void
audio_wavein::start_recording(void)
{
MMRESULT err;
BOOL ev;
if ((status != WAVEIN_READY) && (status != WAVEIN_STOP))
{
/* TODO: throw error */
}
/* Updating to the recording status */
status = WAVEIN_RECORDING;
/* Let's prepare header of type WAVEHDR that we will pass to the driver
with our audio informations, and buffer informations */
prep_headers_();
/* The waveInAddBuffer function sends an input buffer to the given waveform-audio
input device. When the buffer is filled, the application is notified. */
add_buffers_to_driver_();
/* Signaling event for waking up the recorder thread */
ev = SetEvent(wakeup_recthread);
if (!ev)
MessageBox(0, TEXT("Event Error."), 0, 0);
/* Start recording */
err = waveInStart(wavein_handle);
if (err != MMSYSERR_NOERROR)
{
/* Updating status */
status = WAVEIN_ERR;
MessageBox(0, TEXT("waveInStart Error."), 0, 0);
/* TODO: throw error */
}
}
void
audio_wavein::stop_recording(void)
{
MMRESULT err;
if (status != WAVEIN_RECORDING)
return;
status = WAVEIN_FLUSHING;
/* waveInReset will make all pending buffer as done */
err = waveInReset(wavein_handle);
if ( err != MMSYSERR_NOERROR )
{
/* TODO: throw error */
MessageBox(0, TEXT("waveInReset Error."), 0, 0);
}
if (data_flushed_event)
WaitForSingleObject(data_flushed_event, INFINITE);
/* Stop recording */
err = waveInStop(wavein_handle);
if (err != MMSYSERR_NOERROR)
{
/* TODO: throw error */
MessageBox(0, TEXT("waveInStop Error."), 0, 0);
}
/* The waveInUnprepareHeader function cleans up the preparation performed
by the waveInPrepareHeader function */
unprep_headers_();
status = WAVEIN_STOP;
}
DWORD WINAPI
audio_wavein::recording_procedure(LPVOID arg)
{
MSG msg;
WAVEHDR *phdr;
audio_wavein *_this = (audio_wavein *)arg;
/* Check the arg pointer */
if (_this == 0)
return 0;
/* The thread can go to sleep for now. It will be wake up only when
there is audio data to be recorded */
if (_this->wakeup_recthread)
WaitForSingleObject(_this->wakeup_recthread, INFINITE);
/* If status of the `audio_wavein' object is not ready or recording the thread can exit */
if ((_this->status != WAVEIN_READY) && (_this->status != WAVEIN_RECORDING))
return 0;
/* Entering main polling loop */
while (GetMessage(&msg, 0, 0, 0))
{
switch (msg.message)
{
case MM_WIM_DATA:
phdr = (WAVEHDR *)msg.lParam;
if ((_this->status == WAVEIN_RECORDING) ||
(_this->status == WAVEIN_FLUSHING))
{
if (phdr->dwFlags & WHDR_DONE)
{
/* Flushes recorded audio data to the `audio_receiver' object */
_this->audio_rcvd.audio_receive((unsigned char *)phdr->lpData,
phdr->dwBytesRecorded);
/* Updating `audio_receiver' total bytes received
_AFTER_ calling `audio_receive' function */
_this->audio_rcvd.bytes_received += phdr->dwBytesRecorded;
}
/* If status is not flushing data, then we can re-add the buffer
for reusing it. Otherwise, if we are flushing pending data,
we cannot re-add buffer because we don't need it anymore */
if (_this->status != WAVEIN_FLUSHING)
{
/* Let the audio driver reuse the buffer */
waveInAddBuffer(_this->wavein_handle, phdr, sizeof(WAVEHDR));
} else {
/* If we are flushing pending data, we have to prepare
to stop recording. Set WAVEHDR flag to 0, and fires
the event `data_flushed_event', that will wake up
the main thread that is sleeping into wavein_in::stop_recording()
member function, waiting the last `MM_WIM_DATA' message
that contain pending data */
phdr->dwFlags = 0;
SetEvent(_this->data_flushed_event);
/* The recording is going to stop, so the recording thread can go to sleep! */
WaitForSingleObject(_this->wakeup_recthread, INFINITE);
}
} /* if WAVEIN_RECORDING || WAVEIN_FLUSHING */
break;
case MM_WIM_CLOSE:
/* The thread can exit now */
return 0;
break;
} /* end switch(msg.message) */
} /* end while(GetMessage(...)) */
return 0;
}
_AUDIO_NAMESPACE_END_