LRESULT CFirstPageDlg::OnMM_WIM_DATA(UINT wParam, LONG lParam)
{
// TODO: Add your message handler code here and/or call default
// Reallocate save buffer memory
//////////////////////////////////////////////////////////////////////////
pNewBuffer = (PBYTE)realloc (pSaveBuffer, dwDataLength +((PWAVEHDR) lParam)->dwBytesRecorded) ;
if (pNewBuffer == NULL)
{
waveInClose (hWaveIn) ;
MessageBeep (MB_ICONEXCLAMATION) ;
AfxMessageBox(_T("OnMM_WIM_DATA:memory error"));
return 0;
}
pSaveBuffer = pNewBuffer ;
CopyMemory (pSaveBuffer + dwDataLength, ((PWAVEHDR) lParam)->lpData,((PWAVEHDR) lParam)->dwBytesRecorded) ;
dwDataLength += ((PWAVEHDR) lParam)->dwBytesRecorded ;
if (!bRecording)
{
waveInClose (hWaveIn) ;
return 0 ;
}
waveInAddBuffer (hWaveIn, (PWAVEHDR) lParam, sizeof (WAVEHDR)) ;
TRACE("done input data\n");
return 0;
}
/**
* Prepare recording. Initialize and acquire recording resources.
*/
static javacall_result init_recording(recorder_handle* hRecord)
{
WAVEFORMATEX format;
/* Setup wave in format */
format.wFormatTag = WAVE_FORMAT_PCM;
format.cbSize = 0;
format.wBitsPerSample = 16;
format.nSamplesPerSec = 22050;
format.nChannels = 1;
format.nAvgBytesPerSec = format.nSamplesPerSec * (format.wBitsPerSample/8);
format.nBlockAlign = format.nChannels;
/* Open WAV in H/W */
if (NULL == hRecord->hWAVEIN) {
MMRESULT mmReturn = 0;
mmReturn = waveInOpen(&hRecord->hWAVEIN, WAVE_MAPPER, &format,
(DWORD)waveInProc, (DWORD)hRecord, CALLBACK_FUNCTION);
if (MMSYSERR_NOERROR != mmReturn) {
hRecord->hWAVEIN = NULL;
return JAVACALL_FAIL;
}
}
/* Create WAV file for (temp) storage */
if (NULL == hRecord->hFile) {
HMMIO hFile;
/* Create temp file? If there is no pre-setted name. */
if (0x0 == hRecord->fileName[0]) {
GetTempPath(MAX_PATH, hRecord->fileName);
GetTempFileName(hRecord->fileName, "record", 0, hRecord->fileName);
}
if (JAVACALL_SUCCEEDED(create_wav_file(hRecord->fileName, &format, &hFile))) {
hRecord->hFile = hFile;
} else {
waveInClose(hRecord->hWAVEIN);
hRecord->hWAVEIN = NULL;
return JAVACALL_FAIL;
}
}
/* Add input buffer */
if (!JAVACALL_SUCCEEDED(add_input_buffer(hRecord, &format))) {
waveInClose(hRecord->hWAVEIN);
close_wav_file(hRecord);
hRecord->hWAVEIN = NULL;
return JAVACALL_FAIL;
}
return JAVACALL_OK;
}
ad_rec_t *
ad_open_sps_bufsize(int32 sps, int32 bufsize_msec)
{
ad_rec_t *r;
int32 i, j;
HWAVEIN h;
if ((h = wavein_open(sps, sizeof(int16))) == NULL)
return NULL;
if ((r = (ad_rec_t *) malloc(sizeof(ad_rec_t))) == NULL) {
fprintf(stderr, "malloc(%d) failed\n", sizeof(ad_rec_t));
waveInClose(h);
return NULL;
}
r->n_buf = ((sps * bufsize_msec) / 1000) / WI_BUFSIZE;
if (r->n_buf < DEFAULT_N_WI_BUF)
r->n_buf = DEFAULT_N_WI_BUF;
printf("Allocating %d buffers of %d samples each\n", r->n_buf,
WI_BUFSIZE);
if ((r->wi_buf =
(ad_wbuf_t *) calloc(r->n_buf, sizeof(ad_wbuf_t))) == NULL) {
fprintf(stderr, "calloc(%d,%d) failed\n", r->n_buf,
sizeof(ad_wbuf_t));
free(r);
waveInClose(h);
return NULL;
}
for (i = 0; i < r->n_buf; i++) {
if (wavein_alloc_buf(&(r->wi_buf[i]), WI_BUFSIZE) < 0) {
for (j = 0; j < i; j++)
wavein_free_buf(&(r->wi_buf[j]));
free(r->wi_buf);
free(r);
waveInClose(h);
return NULL;
}
}
r->h_wavein = h;
r->opened = 1;
r->recording = 0;
r->curbuf = r->n_buf - 1; /* current buffer with data for application */
r->curlen = 0; /* #samples in curbuf remaining to be consumed */
r->lastbuf = r->curbuf;
r->sps = sps;
r->bps = sizeof(int16); /* HACK!! Hardwired value for bytes/sec */
return r;
}
/* destructor */
static tsk_object_t* tdav_producer_waveapi_dtor(tsk_object_t * self)
{
tdav_producer_waveapi_t *producer = self;
if(producer){
tsk_size_t i;
/* stop */
if(producer->started){
tdav_producer_waveapi_stop(self);
}
/* deinit base */
tdav_producer_audio_deinit(TDAV_PRODUCER_AUDIO(producer));
/* deinit self */
for(i = 0; i< sizeof(producer->hWaveHeaders)/sizeof(LPWAVEHDR); i++){
free_wavehdr(producer, i);
}
if(producer->hWaveIn){
waveInClose(producer->hWaveIn);
}
if(producer->events[0]){
CloseHandle(producer->events[0]);
}
if(producer->events[1]){
CloseHandle(producer->events[1]);
}
DeleteCriticalSection(&producer->cs);
}
return self;
}
int RecData(int i)
{
WORD wResult;
SendInBuffers--;
if (!StopRecord)
{
InFillBuffer(i);
wResult = waveInAddBuffer(hWaveIn,WaveInBuf[i].lpWaveHdr,sizeof(WAVEHDR));
if (wResult != 0)
{
WaveInFreeAll();
return 0;
}
SendInBuffers++;
}
else
{
if (!SendInBuffers)
{
WaveInFreeAll();
StopRecord=FALSE;
waveInClose(hWaveIn);
}
}
return 1;
}
void CloseDevice()
{
MMRESULT mRes=0;
if(m_hWaveIn)
{
UnPrepareBuffers();
mRes=waveInClose(m_hWaveIn);
}
if(m_hOPFile)
{
mRes=mmioAscend(m_hOPFile, &m_stckOut, 0);
if(mRes!=MMSYSERR_NOERROR)
{
FAIL_M("bad");
}
mRes=mmioAscend(m_hOPFile, &m_stckOutRIFF, 0);
if(mRes!=MMSYSERR_NOERROR)
{
FAIL_M("bad");
}
mmioClose(m_hOPFile,0);
m_hOPFile=NULL;
}
m_hWaveIn=NULL;
}
static int32 wavein_close (ad_rec_t *r)
{
int32 i, st;
/* Unprepare all buffers; multiple unprepares of the same buffer are benign */
for (i = 0; i < r->n_buf; i++) {
st = waveInUnprepareHeader(r->h_wavein, r->wi_buf[i].p_whdr, sizeof(WAVEHDR));
if (st != 0) {
wavein_error("waveInUnprepareHeader", st);
return -1;
}
}
/* Free buffers */
for (i = 0; i < r->n_buf; i++)
wavein_free_buf (&(r->wi_buf[i]));
free (r->wi_buf);
if ((st = waveInClose (r->h_wavein)) != 0) {
wavein_error("waveInClose", st);
return -1;
}
free (r);
return 0;
}
/**
* win32ai_close()
* Terminate recording.
* This function discards all data that has been sampled but not read.
* Return 0 if happy, -1 if error.
*/
int win32ai_close(void) {
MMRESULT res;
int i;
// stop device
res = waveInReset(wavein);
if (checkWaveInResult(wavein, res, "waveInReset"))
return -1;
// wait for buffers to finish and unprepare them all
for (i = 0; i < WaveBuf_N; ++i) {
while ((whin[i]->dwFlags & WHDR_DONE) == 0) {
// buffer not ready, wait, try again
WaitForSingleObject(whinEvent, INFINITE);
}
// unprepare the buffer
res = waveInUnprepareHeader(wavein, whin[i], sizeof(WAVEHDR));
if (checkWaveInResult(wavein, res, "waveInUnprepareHeader"))
return -1;
// free memory
free(whin[i]->lpData);
free(whin[i]);
}
// close device
res = waveInClose(wavein);
if (checkWaveInResult(wavein, res, "waveInClose"))
return -1;
return 0;
}
static void ALCwinmmCapture_Destruct(ALCwinmmCapture *self)
{
void *buffer = NULL;
int i;
/* Tell the processing thread to quit and wait for it to do so. */
if(!ATOMIC_EXCHANGE(&self->killNow, AL_TRUE, almemory_order_acq_rel))
{
PostThreadMessage(self->thread, WM_QUIT, 0, 0);
althrd_join(self->thread, &i);
/* Make sure capture is stopped and all pending buffers are flushed. */
waveInReset(self->InHdl);
// Release the wave buffers
for(i = 0;i < 4;i++)
{
waveInUnprepareHeader(self->InHdl, &self->WaveBuffer[i], sizeof(WAVEHDR));
if(i == 0) buffer = self->WaveBuffer[i].lpData;
self->WaveBuffer[i].lpData = NULL;
}
free(buffer);
}
ll_ringbuffer_free(self->Ring);
self->Ring = NULL;
// Close the Wave device
if(self->InHdl)
waveInClose(self->InHdl);
self->InHdl = 0;
ALCbackend_Destruct(STATIC_CAST(ALCbackend, self));
}
void RUIAudio::RecordClose()
{
Stop();
HWAVEIN hTemp = m_hWaveIn;
m_hWaveIn = NULL;
if (hTemp == NULL)
return;
RUIBuffer* pRUIBuffer = m_RecBufferList.GetFirst();
while (pRUIBuffer != NULL)
{
RecRemoveBuffer(pRUIBuffer);
pRUIBuffer = m_RecBufferList.GetNext(pRUIBuffer);
}
if( hTemp == NULL )
return;
if (waveInReset(hTemp) != MMSYSERR_NOERROR)
ASSERT(FALSE);
if (waveInClose(hTemp) != MMSYSERR_NOERROR)
ASSERT(FALSE);
}
bool CSoundChannel::m_bCloseAudio()
{
if(m_bClose)
return m_bClose;
m_bAbort();
if(m_hWaveOut != NULL)
{
while(waveOutClose(m_hWaveOut) == WAVERR_STILLPLAYING) //关闭WAVEOUT设备
waveOutReset(m_hWaveOut);
m_hWaveOut = NULL;
}
if(m_hWaveIn != NULL)
{
while(waveInClose(m_hWaveIn) == WAVERR_STILLPLAYING) //关闭WAVEIN设备
waveInReset(m_hWaveIn);
m_hWaveIn = NULL;
}
m_bAbort();
m_uOldHandle = -1;
m_bClose = true;
return true;
}
void mmio_close_audio( void)
{
int errcode;
int nda, nad;
if (sys_verbose)
post("closing audio...");
for (nda=0; nda < nt_nwaveout; nda++) /*if (nt_nwaveout) wini */
{
errcode = waveOutReset(ntsnd_outdev[nda]);
if (errcode != MMSYSERR_NOERROR)
printf("error resetting output %d: %d\n", nda, errcode);
errcode = waveOutClose(ntsnd_outdev[nda]);
if (errcode != MMSYSERR_NOERROR)
printf("error closing output %d: %d\n",nda , errcode);
}
nt_nwaveout = 0;
for(nad=0; nad < nt_nwavein;nad++) /* if (nt_nwavein) wini */
{
errcode = waveInReset(ntsnd_indev[nad]);
if (errcode != MMSYSERR_NOERROR)
printf("error resetting input: %d\n", errcode);
errcode = waveInClose(ntsnd_indev[nad]);
if (errcode != MMSYSERR_NOERROR)
printf("error closing input: %d\n", errcode);
}
nt_nwavein = 0;
}
static void WinMMCloseCapture(ALCdevice *Device)
{
WinMMData *data = (WinMMData*)Device->ExtraData;
void *buffer = NULL;
int i;
/* Tell the processing thread to quit and wait for it to do so. */
data->killNow = AL_TRUE;
PostThreadMessage(data->thread, WM_QUIT, 0, 0);
althrd_join(data->thread, &i);
/* Make sure capture is stopped and all pending buffers are flushed. */
waveInReset(data->WaveHandle.In);
// Release the wave buffers
for(i = 0; i < 4; i++)
{
waveInUnprepareHeader(data->WaveHandle.In, &data->WaveBuffer[i], sizeof(WAVEHDR));
if(i == 0) buffer = data->WaveBuffer[i].lpData;
data->WaveBuffer[i].lpData = NULL;
}
free(buffer);
DestroyRingBuffer(data->Ring);
data->Ring = NULL;
// Close the Wave device
waveInClose(data->WaveHandle.In);
data->WaveHandle.In = 0;
free(data);
Device->ExtraData = NULL;
}
bool_t gaudio_record_lld_init(uint16_t channel, uint32_t frequency, ArrayDataFormat format) {
WAVEFORMATEX wfx;
if (format != ARRAY_DATA_8BITUNSIGNED && format != ARRAY_DATA_16BITSIGNED)
return FALSE;
if (!waveThread) {
if (!(waveThread = CreateThread(0, 0, (LPTHREAD_START_ROUTINE)waveProc, 0, 0, &threadID))) {
fprintf(stderr, "GAUDIO: Can't create WAVE recording thread\n");
exit(-1);
}
CloseHandle(waveThread);
}
wfx.wFormatTag = WAVE_FORMAT_PCM;
wfx.nChannels = channel == GAUDIO_RECORD_STEREO ? 2 : 1;
wfx.nSamplesPerSec = frequency;
wfx.nBlockAlign = wfx.nChannels * (format == ARRAY_DATA_8BITUNSIGNED ? 1 : 2);
wfx.nAvgBytesPerSec = wfx.nSamplesPerSec * wfx.nBlockAlign;
wfx.wBitsPerSample = (format == ARRAY_DATA_8BITUNSIGNED ? 8 : 16);
wfx.cbSize = 0;
if (ah) {
waveInClose(ah);
ah = 0;
}
if (waveInOpen(&ah, WAVE_MAPPER, &wfx, (DWORD_PTR)threadID, 0, CALLBACK_THREAD)) {
fprintf(stderr, "GAUDIN: Can't open WAVE recording device\n");
exit(-1);
}
return TRUE;
}
BMID_API int BGBMID_SoundDev_RecDeInit()
{
int i;
waveInStop(hWaveIn);
waveInReset(hWaveIn);
if(lpInWaveHdr)
{
for(i=0; i<WAV_BUFFERS; i++)
waveInUnprepareHeader(hWaveIn, lpInWaveHdr+i, sizeof(WAVEHDR));
}
waveInClose(hWaveIn);
if(hInWaveHdr)
{
GlobalUnlock(hInWaveHdr);
GlobalFree(hInWaveHdr);
}
if(hInData)
{
GlobalUnlock(hInData);
GlobalFree(hInData);
}
return(0);
}
audioStreamer_waveOut::~audioStreamer_waveOut()
{
int x;
if (m_hwo) waveOutReset(m_hwo);
if (m_hwi) waveInReset(m_hwi);
for (x = 0; x < m_bufs.GetSize(); x ++)
{
WAVEHDR *p = (WAVEHDR *)m_bufs.Get(x)->Get();
if (m_hwi && p)
if (p->dwFlags & WHDR_PREPARED) waveInUnprepareHeader(m_hwi,p,sizeof(WAVEHDR));
if (m_hwo && p)
{
if (p->dwFlags & WHDR_PREPARED) waveOutUnprepareHeader(m_hwo,p,sizeof(WAVEHDR));
}
delete m_bufs.Get(x);
}
m_bufs.Empty();
if (m_hwo)
{
waveOutClose(m_hwo);
m_hwo=0;
}
if (m_hwi)
{
waveInClose(m_hwi);
m_hwi=0;
}
}
CAudio::~CAudio()
{
if (m_bIsWaveInUsed)
{
waveInStop(m_hWaveIn);
waveInReset(m_hWaveIn);
for (int i = 0; i < 2; i++)
waveInUnprepareHeader(m_hWaveIn, m_lpInAudioHdr[i], sizeof(WAVEHDR));
waveInClose(m_hWaveIn);
TerminateThread(m_hThreadCallBack, -1);
}
if (m_bIsWaveOutUsed)
{
waveOutReset(m_hWaveOut);
for (int i = 0; i < 2; i++)
waveOutUnprepareHeader(m_hWaveOut, m_lpInAudioHdr[i], sizeof(WAVEHDR));
waveOutClose(m_hWaveOut);
}
for (int i = 0; i < 2; i++)
{
delete [] m_lpInAudioData[i];
delete m_lpInAudioHdr[i];
delete [] m_lpOutAudioData[i];
delete m_lpOutAudioHdr[i];
}
CloseHandle(m_hEventWaveIn);
CloseHandle(m_hStartRecord);
CloseHandle(m_hThreadCallBack);
}
static void
winaudio_in_fini (HWVoiceIn *hw)
{
WinAudioIn* s = (WinAudioIn*) hw;
int i;
if (s->wavein) {
waveInReset(s->wavein);
s->wavein = 0;
}
for ( i=0; i<NUM_OUT_BUFFERS; ++i ) {
if ( s->buffers[i].dwUser != 0xFFFF ) {
waveInUnprepareHeader(
s->wavein, &s->buffers[i], sizeof(s->buffers[i]) );
s->buffers[i].dwUser = 0xFFFF;
}
}
if (s->buffer_bytes != NULL) {
qemu_free(s->buffer_bytes);
s->buffer_bytes = NULL;
}
if (s->wavein) {
waveInClose(s->wavein);
s->wavein = NULL;
}
}
/*
* Class: com_ibm_media_protocol_device_DataSource
* Method: disconnectDevice
* Signature: ()V
*/
JNIEXPORT void JNICALL Java_com_ibm_media_protocol_device_DataSource_disconnectDevice
(JNIEnv* env, jobject obj) {
MMRESULT result;
/* first mark all pending buffers as done */
result = waveInReset(hwi);
/* DEBUG */
if (result == MMSYSERR_NOERROR)
printf("Device reset\n");
else
printf("ERROR reseting device !\n");
/* end DEBUG */
result = waveInClose(hwi);
/* DEBUG */
if (result == MMSYSERR_NOERROR)
printf("Device closed\n");
else
printf("ERROR closing device !\n");
/* end DEBUG */
}
int audio_close(snd_type snd)
{
int i;
MMRESULT er;
buffer_state *bs = (buffer_state *) snd->u.audio.descriptor;
if (snd->write_flag == SND_READ) {
if (er = waveInReset(bs->u.h_in)) {
mm_error_handler(snd, er, snd_fail);
return !SND_SUCCESS;
}
if (er = waveInClose(bs->u.h_in)) {
mm_error_handler(snd, er, snd_fail);
return !SND_SUCCESS;
}
} else { // SND_WRITE
if (er = waveOutReset(bs->u.h_out)) {
mm_error_handler(snd, er, snd_fail);
return !SND_SUCCESS;
}
if (er = waveOutClose(bs->u.h_out)) {
mm_error_handler(snd, er, snd_fail);
return !SND_SUCCESS;
}
}
for (i = 0; i < bs->numofbuffers; i++) {
snd_free(bs->whdr[i].lpData);
}
snd_free(bs->whdr);
snd_free(bs);
if (rt_devices_open) {
timeEndPeriod(1);
rt_devices_open--;
}
return SND_SUCCESS;
}
static int32
wavein_close(ad_rec_t * r)
{
int32 i, st;
/* Unprepare all buffers; multiple unprepares of the same buffer are benign */
for (i = 0; i < r->n_buf; i++) {
/* Unpreparing an unprepared buffer, on the other hand, fails
on Win98/WinME, though this is not documented - dhuggins@cs,
2004-07-14 */
if (!(r->wi_buf[i].p_whdr->dwFlags & WHDR_PREPARED))
continue;
st = waveInUnprepareHeader(r->h_wavein,
r->wi_buf[i].p_whdr, sizeof(WAVEHDR));
if (st != 0) {
wavein_error("waveInUnprepareHeader", st);
return -1;
}
}
/* Free buffers */
for (i = 0; i < r->n_buf; i++)
wavein_free_buf(&(r->wi_buf[i]));
free(r->wi_buf);
if ((st = waveInClose(r->h_wavein)) != 0) {
wavein_error("waveInClose", st);
return -1;
}
free(r);
return 0;
}
/*
* Destroy stream.
*/
PJ_DEF(pj_status_t) pjmedia_snd_stream_close(pjmedia_snd_stream *stream)
{
unsigned i;
PJ_ASSERT_RETURN(stream != NULL, PJ_EINVAL);
pjmedia_snd_stream_stop(stream);
if (stream->thread)
{
SetEvent(stream->thread_quit_event);
pj_thread_join(stream->thread);
pj_thread_destroy(stream->thread);
stream->thread = NULL;
}
/* Unprepare the headers and close the play device */
if (stream->play_strm.hWave.Out)
{
waveOutReset(stream->play_strm.hWave.Out);
for (i = 0; i < stream->play_strm.dwMaxBufIdx; ++i)
waveOutUnprepareHeader(stream->play_strm.hWave.Out,
&(stream->play_strm.WaveHdr[i]),
sizeof(WAVEHDR));
waveOutClose(stream->play_strm.hWave.Out);
stream->play_strm.hWave.Out = NULL;
}
/* Close the play event */
if (stream->play_strm.hEvent)
{
CloseHandle(stream->play_strm.hEvent);
stream->play_strm.hEvent = NULL;
}
/* Unprepare the headers and close the record device */
if (stream->rec_strm.hWave.In)
{
waveInReset(stream->rec_strm.hWave.In);
for (i = 0; i < stream->play_strm.dwMaxBufIdx; ++i)
waveInUnprepareHeader(stream->rec_strm.hWave.In,
&(stream->rec_strm.WaveHdr[i]),
sizeof(WAVEHDR));
waveInClose(stream->rec_strm.hWave.In);
stream->rec_strm.hWave.In = NULL;
}
/* Close the record event */
if (stream->rec_strm.hEvent)
{
CloseHandle(stream->rec_strm.hEvent);
stream->rec_strm.hEvent = NULL;
}
pj_pool_release(stream->pool);
return PJ_SUCCESS;
}
void ph_media_stop(phcall_t *ca)
{
phmstream_t *stream = (phmstream_t *) ca->phstream;
ca->hasaudio = 0;
ca->phstream = 0;
stream->running = 0;
osip_thread_join(stream->audio_in_thread);
osip_thread_join(stream->audio_out_thread);
osip_free(stream->audio_in_thread);
osip_free(stream->audio_out_thread);
rtp_session_signal_disconnect_by_callback(stream->rtp_session, "telephone-event",
(RtpCallback)ph_telephone_event);
ortp_set_debug_file("oRTP", stdout);
ortp_global_stats_display();
ortp_set_debug_file("oRTP", NULL);
rtp_session_destroy(stream->rtp_session);
#if USE_CODECS
if (stream->codec->encoder_cleanup)
stream->codec->encoder_cleanup(stream->encoder_ctx);
if (stream->codec->decoder_cleanup)
stream->codec->decoder_cleanup(stream->decoder_ctx);
#endif /* !USE_CODECS */
waveInReset(stream->hWaveIn);
waveInClose(stream->hWaveIn);
waveOutReset(stream->hWaveOut);
waveOutClose(stream->hWaveOut);
#if DO_ECHO_CAN
printf("\nbytes echoed %d %d\n", stream->sent_cnt, stream->recv_cnt);
free(stream->pcm_sent);
# if !AEC_BIS
if(stream->ec)
echo_can_free(stream->ec);
# else /* AEC_BIS */
kill_AEC();
# endif /* AEC_BIS */
g_mutex_free(stream->synclock);
g_cond_free(stream->sync_cond);
g_mutex_free(stream->aec_mutex);
#endif /* !DO_ECHO_CAN */
g_mutex_free(stream->dtmfg_lock);
osip_free(stream);
}
void CAudioCollect::Stop()
{
bStart = false;
bReset = true;
waveOutReset(m_hWaveOut);
waveOutClose(m_hWaveOut);
waveInReset(m_hWaveIn);
waveInClose(m_hWaveIn);
}
static void winwave_anal_close_in (WaveVoiceIn *wave)
{
MMRESULT mr;
mr = waveInClose (wave->hwi);
if (mr != MMSYSERR_NOERROR) {
winwave_logerr (mr, "waveInClose");
}
wave->hwi = NULL;
}
void CAudioInput::CloseMic()
{
Sleep(50); // wait for the thread to terminate
if(h_input){
waveInStop(h_input);
//waveInReset(h_input);
waveInClose(h_input);
}
fclose(fpBufferData);
fclose(fpTempoData);
}
~inAudioCapture()
{
#if WRITEWAVE
finishWaveFile();
#endif
waveInStop(hWaveIn);
std::cout << "Stop Recording.\n" << std::endl;
waveInClose(hWaveIn);
if(!dataIn) delete [] dataIn;
}
static void close_sound(void)
{ if (sound_recording)
stop_sound();
if (!opened)
return;
close_Mixer_data();
error_code = waveInClose(hwavein);
if( error_code != MMSYSERR_NOERROR)
errormsg("Unable to close sound recording.",error_code);
opened=0;
}
int WaveIn::Close()
{
//int nRet;
Clean();
if(m_hWaveIn!=NULL){
m_nRet=waveInClose(m_hWaveIn);
if(m_nRet!=MMSYSERR_NOERROR){
return 0;
}
}
return 1;
}
void CALLBACK waveInProc(HWAVEIN hwi,
UINT uMsg,
DWORD_PTR dwInstance,
DWORD_PTR dwParam1,
DWORD_PTR dwParam2 )
{
LPWAVEHDR pwh = (LPWAVEHDR)dwParam1;
if ((WIM_DATA==uMsg) && (buf_count<BUFFER_SIZE))
{
int size = pwh->dwBytesRecorded;
//relocated memory location
pNewBuffer = (PBYTE)realloc (pSaveBuffer, dwDataLength+ size) ;
if(pNewBuffer ==NULL)
{
waveInClose(hwi);
printf("memory error");
return;
}
//copy data into memory and refresh memory address
pSaveBuffer = pNewBuffer;
buf_count ++;
CopyMemory(pSaveBuffer + dwDataLength, pwh->lpData,size);
dwDataLength += size;
if(!m_record)
{
waveInClose(hwi);
printf("stop recording");
return;
}
waveInAddBuffer(hwi, pwh, sizeof(WAVEHDR));
}
}
