void WaveInStart(WaveIn *waveIn, BOOL prep)
{
MMRESULT res;
res = waveInReset(waveIn->handler);
if(res) {
return;
}
// prepare header an add the buffer
waveIn->header.lpData = (char *) waveIn->data;
waveIn->header.dwBufferLength = waveIn->n * 2;
waveIn->header.dwBytesRecorded = 0;
waveIn->header.dwFlags = 0L;
waveIn->header.dwLoops = 0L;
waveIn->header.dwUser = 0L;
waveInPrepareHeader(waveIn->handler, &waveIn->header, sizeof(WAVEHDR));
res = waveInAddBuffer(waveIn->handler, &waveIn->header, sizeof(WAVEHDR));
if(res) {
return;
}
res = waveInStart(waveIn->handler);
if(res) {
return;
}
}
//开始录音
BOOL CWaveIn::OpenRecord()
{
//已经开始录音
if (m_bRecord)
{
//返回
return FALSE;
}
//录音设备句柄无效
if(!m_hIn)
{
//返回
return FALSE;
}
//开始录音
m_mmr = waveInStart(m_hIn);
//出错
if (m_mmr)
{
//返回
return FALSE;
}
//设置录音开始标记
m_bRecord = TRUE;
//返回
return TRUE;
}
int main()
{
HWAVEIN inStream;
HWAVEOUT outStream;
WAVEFORMATEX waveFormat;
WAVEHDR buffer[4]; // pingpong buffers
waveFormat.wFormatTag = WAVE_FORMAT_PCM; // PCM audio
waveFormat.nSamplesPerSec = 22050; // really 22050 frames/sec
waveFormat.nChannels = 2; // stereo
waveFormat.wBitsPerSample = 16; // 16bits per sample
waveFormat.cbSize = 0; // no extra data
waveFormat.nBlockAlign =
waveFormat.nChannels * waveFormat.wBitsPerSample / 2;
waveFormat.nAvgBytesPerSec =
waveFormat.nBlockAlign * waveFormat.nSamplesPerSec;
// Event: default security descriptor, Manual Reset, initial non-signaled
HANDLE event = CreateEvent(NULL, TRUE, FALSE, "waveout event");
waveInOpen( &inStream, WAVE_MAPPER, &waveFormat, (unsigned long)event,
0, CALLBACK_EVENT);
waveOutOpen(&outStream, WAVE_MAPPER, &waveFormat, (unsigned long)event,
0, CALLBACK_EVENT);
// initialize the input and output PingPong buffers
int index;
for(index = 0; index < 4; index++) {
buffer[index].dwBufferLength = NUM_FRAMES * waveFormat.nBlockAlign;
buffer[index].lpData =
(void *)malloc(NUM_FRAMES * waveFormat.nBlockAlign);
buffer[index].dwFlags = 0;
waveInPrepareHeader( inStream, &buffer[index], sizeof(WAVEHDR));
}
ResetEvent(event);
for(index= 0; index < 4; index++) // queue all buffers for input
waveInAddBuffer(inStream, &buffer[index], sizeof(WAVEHDR));
waveInStart(inStream);
while(!( buffer[1].dwFlags & WHDR_DONE)); // poll(!) for 2 full input buffers
// move the two full buffers to output
waveOutWrite(outStream, &buffer[0], sizeof(WAVEHDR));
waveOutWrite(outStream, &buffer[1], sizeof(WAVEHDR));
int inIndex = 2, outIndex = 0; // the next input and output to watch
while(1) { // poll for completed input and output buffers
if(buffer[inIndex].dwFlags & WHDR_DONE) { // input buffer complete?
waveInAddBuffer( inStream, &buffer[inIndex], sizeof(WAVEHDR));
inIndex = (inIndex+1)%4; // next buffer to watch for full
}
if(buffer[outIndex].dwFlags & WHDR_DONE) { // output buffer complete?
waveOutWrite( outStream, &buffer[outIndex], sizeof(WAVEHDR));
outIndex = (outIndex+1)%4; // next buffer to watch for empty
}
}
}
bool CAudio::InitializeWaveIn()
{
if (!waveInGetNumDevs())
return false;
MMRESULT mmResult;
DWORD dwThreadID = 0;
m_hThreadCallBack = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)waveInCallBack, (LPVOID)this, CREATE_SUSPENDED, &dwThreadID);
mmResult = waveInOpen(&m_hWaveIn, (WORD)WAVE_MAPPER, &(m_GSMWavefmt.wfx), (LONG)dwThreadID, (LONG)0, CALLBACK_THREAD);
if (mmResult != MMSYSERR_NOERROR)
return false;
for (int i = 0; i < 2; i++)
{
m_lpInAudioHdr[i]->lpData = (LPSTR)m_lpInAudioData[i];
m_lpInAudioHdr[i]->dwBufferLength = m_nBufferLength;
m_lpInAudioHdr[i]->dwFlags = 0;
m_lpInAudioHdr[i]->dwLoops = 0;
waveInPrepareHeader(m_hWaveIn, m_lpInAudioHdr[i], sizeof(WAVEHDR));
}
waveInAddBuffer(m_hWaveIn, m_lpInAudioHdr[m_nWaveInIndex], sizeof(WAVEHDR));
ResumeThread(m_hThreadCallBack);
waveInStart(m_hWaveIn);
m_bIsWaveInUsed = true;
return true;
}
/**
* WAV録音開始
*/
void startWAV() {
if (hwi) {
if (waveInStart(hwi) != MMSYSERR_NOERROR) {
TVPThrowExceptionMessage(L"waveInStart");
}
}
}
/*
* Start stream.
*/
PJ_DEF(pj_status_t) pjmedia_snd_stream_start(pjmedia_snd_stream *stream)
{
MMRESULT mr;
PJ_UNUSED_ARG(stream);
if (stream->play_strm.hWave.Out != NULL)
{
mr = waveOutRestart(stream->play_strm.hWave.Out);
if (mr != MMSYSERR_NOERROR)
/* TODO: This macro is supposed to be used for HRESULT, fix. */
PJ_RETURN_OS_ERROR(mr);
PJ_LOG(5,(THIS_FILE, "WMME playback stream started"));
}
if (stream->rec_strm.hWave.In != NULL)
{
mr = waveInStart(stream->rec_strm.hWave.In);
if (mr != MMSYSERR_NOERROR)
/* TODO: This macro is supposed to be used for HRESULT, fix. */
PJ_RETURN_OS_ERROR(mr);
PJ_LOG(5,(THIS_FILE, "WMME capture stream started"));
}
return PJ_SUCCESS;
}
void start_sound()
{ if (sound_recording)
{ message(0, "already recording");
return;
}
stop_play_file();
open_sound_record();
if (!opened)
return;
sound_recording=1;
SetDlgItemText(hMainDialog,IDC_LISTEN_INDICATOR,"LISTENING");
init_Mixer_data();
set_Mixer_data();
if (!submit_sound_buffer() || !submit_sound_buffer())
{ errormsg("Unable to get buffers for sound recording",0);
stop_sound();
return;
}
reset_volumecompression();
start_encoder();
error_code = waveInStart( hwavein );
if( error_code != MMSYSERR_NOERROR)
{ errormsg("Unable to start sound recording.",error_code);
stop_sound();
return;
}
meter_on();
}
bool CSoundChannel::m_bStartRecording()
{
CWaitAndSignal mutex(m_Mutex);
if(m_iBufByteOffset != 0x7fffffff) //已经开始RECORD了
return true;
//将所有的BUFFER加入到RECORD设备上去采集数据
for(int i=0; i<m_Buffers.size(); i++)
{
CWaveBuffer* buffer = m_Buffers[i];
if(buffer->m_dwPrepare(m_hWaveIn) != MMSYSERR_NOERROR)
return false;
if(waveInAddBuffer(m_hWaveIn, &buffer->m_header, sizeof(WAVEHDR)) != MMSYSERR_NOERROR)
return false;
}//end of for
m_iBufByteOffset = 0;
//开始录音
if(waveInStart(m_hWaveIn) == MMSYSERR_NOERROR)
return true;
m_iBufByteOffset = 0x7fffffff;
return false;
}
void QAudioInputPrivate::resume()
{
if(deviceState == QAudio::SuspendedState) {
deviceState = QAudio::ActiveState;
for(int i=0; i<buffer_size/period_size; i++) {
result = waveInAddBuffer(hWaveIn, &waveBlocks[i], sizeof(WAVEHDR));
if(result != MMSYSERR_NOERROR) {
qWarning("QAudioInput: failed to setup block %d,err=%d",i,result);
errorState = QAudio::OpenError;
deviceState = QAudio::StoppedState;
emit stateChanged(deviceState);
return;
}
}
mutex.lock();
waveFreeBlockCount = buffer_size/period_size;
mutex.unlock();
waveCurrentBlock = 0;
header = 0;
resuming = true;
waveInStart(hWaveIn);
QTimer::singleShot(20,this,SLOT(feedback()));
emit stateChanged(deviceState);
}
}
int openMicAndStartRecording(DWORD threadId)
{
int i;
WAVEFORMATEX m_WaveFormatEx = getDefaultFormat();
if( MMSYSERR_NOERROR != waveInOpen(&g_recordHandler,WAVE_MAPPER,&m_WaveFormatEx,threadId,0,CALLBACK_THREAD)){
printf("ER1!\n");
return -1;
}
for(i=0; i<MAXRECBUFFER; i++){
rechead[i]=CreateWaveHeader();
if(MMSYSERR_NOERROR != waveInPrepareHeader(g_recordHandler,rechead[i], sizeof(WAVEHDR)) ){
printf("ER2! i=%d\n", i);
return -1;
}
if(MMSYSERR_NOERROR != waveInAddBuffer(g_recordHandler, rechead[i], sizeof(WAVEHDR))){
printf("ER3!\n");
return -1;
}
if(MMSYSERR_NOERROR != waveInStart(g_recordHandler)){
printf("ER4!\n");
return -1;
}
}
printf("Start recording OK!\n");
return 0;
}
VOID CSoundRecDlg::StartRecording()
{
MMRESULT mRes;
SetStatus("Recording...");
try
{
OpenDevice();
PrepareBuffers();
mRes=waveInStart(m_hWaveIn);
if(mRes!=0)
{
StoreError(mRes,FALSE,"File: %s ,Line Number:%d",__FILE__,__LINE__);
throw m_csErrorText;
}
while(m_bRun)
{
SleepEx(100,FALSE);
}
}
catch(PCHAR pErrorMsg)
{
AfxMessageBox(pErrorMsg);
}
CloseDevice();
CloseHandle(m_hThread);
m_hThread=NULL;
SetStatus("Recording stopped...");
}
static int winwave_ctl_in (HWVoiceIn *hw, int cmd, ...)
{
MMRESULT mr;
WaveVoiceIn *wave = (WaveVoiceIn *) hw;
switch (cmd) {
case VOICE_ENABLE:
{
va_list ap;
int poll_mode;
va_start (ap, cmd);
poll_mode = va_arg (ap, int);
va_end (ap);
if (poll_mode && !wave->event) {
wave->event = CreateEvent (NULL, TRUE, TRUE, NULL);
if (!wave->event) {
dolog ("ADC CreateEvent: %lx, poll mode will be disabled\n",
GetLastError ());
}
}
if (wave->event) {
int ret;
ret = qemu_add_wait_object (wave->event, winwave_poll, wave);
hw->poll_mode = (ret == 0);
}
else {
hw->poll_mode = 0;
}
if (wave->paused) {
mr = waveInStart (wave->hwi);
if (mr != MMSYSERR_NOERROR) {
winwave_logerr (mr, "waveInStart");
}
wave->paused = 0;
}
}
return 0;
case VOICE_DISABLE:
if (!wave->paused) {
mr = waveInStop (wave->hwi);
if (mr != MMSYSERR_NOERROR) {
winwave_logerr (mr, "waveInStop");
}
else {
wave->paused = 1;
}
}
if (wave->event) {
qemu_del_wait_object (wave->event, winwave_poll, wave);
}
return 0;
}
return 0;
}
int HAE_ResumeAudioCapture(void) {
if (g_captureSound) {
// start streaming data
waveInStart(g_captureSound);
g_waveInStarted = TRUE;
}
return 0;
}
/**
* win32ai_open(int sample_rate)
* Setup audio for input at specified rate.
* returns -1 on error, 0 on happy.
*/
int win32ai_open(int sample_rate) {
WAVEFORMATEX waveFormat;
MMRESULT res;
int i;
// create an event by which audio driver will notify us
whinEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
// populate whinFormat struct
waveFormat.wFormatTag = WAVE_FORMAT_PCM;
waveFormat.nChannels = 1;
waveFormat.nSamplesPerSec = sample_rate;
waveFormat.nAvgBytesPerSec = sample_rate * SAMPLE_BITS / 8;
waveFormat.nBlockAlign = SAMPLE_BITS / 8;
waveFormat.wBitsPerSample = SAMPLE_BITS;
waveFormat.cbSize = 0;
whinBufNo = 0;
whinBufIndex = 0;
// open audio device
res = waveInOpen(&wavein, WAVE_MAPPER, &waveFormat,
(DWORD) whinEvent, (DWORD) 0, CALLBACK_EVENT);
if (checkWaveInResult(wavein, res, "waveInOpen"))
return -1;
// create buffers
for (i = 0; i < WaveBuf_N; ++i) {
// allocate buffer header
whin[i] = (WAVEHDR*) calloc(1, sizeof(WAVEHDR));
if (whin[i] == NULL) {
perror("malloc WAVEHDR");
return -1; /* need to cleanup XXX */
}
// allocate buffer
whin[i]->lpData = malloc(WaveBuf_SIZE);
if (whin[i]->lpData == NULL) {
perror("new char[WaveBuf_SIZE]");
return -1; /* need to cleanup XXX */
}
whin[i]->dwBufferLength = WaveBuf_SIZE;
// prepare buffer
res = waveInPrepareHeader(wavein, whin[i], sizeof(WAVEHDR));
if (checkWaveInResult(wavein, res, "waveInPrepareHeader"))
return -1;
// give buffer to driver
res = waveInAddBuffer(wavein, whin[i], sizeof(WAVEHDR));
if (checkWaveInResult(wavein, res, "waveInAddBuffer"))
return -1; /* need to cleanup XXX */
}
// start device, yeeeeeee haw!
res = waveInStart(wavein);
if (checkWaveInResult(wavein, res, "waveInStart"))
return -1; /* need to cleanup XXX */
return 0;
}
static int read_stream_open(struct ausrc_st *st, const struct ausrc_prm *prm,
unsigned int dev)
{
WAVEFORMATEX wfmt;
MMRESULT res;
uint32_t sampc;
unsigned format;
int i, err = 0;
st->sampsz = aufmt_sample_size(prm->fmt);
format = winwave_get_format(prm->fmt);
if (format == WAVE_FORMAT_UNKNOWN) {
warning("winwave: source: unsupported sample format (%s)\n",
aufmt_name(prm->fmt));
return ENOTSUP;
}
/* Open an audio INPUT stream. */
st->wavein = NULL;
st->pos = 0;
st->rdy = false;
sampc = prm->srate * prm->ch * prm->ptime / 1000;
for (i = 0; i < READ_BUFFERS; i++) {
memset(&st->bufs[i].wh, 0, sizeof(WAVEHDR));
st->bufs[i].mb = mbuf_alloc(st->sampsz * sampc);
if (!st->bufs[i].mb)
return ENOMEM;
}
wfmt.wFormatTag = format;
wfmt.nChannels = prm->ch;
wfmt.nSamplesPerSec = prm->srate;
wfmt.wBitsPerSample = (WORD)(st->sampsz * 8);
wfmt.nBlockAlign = (prm->ch * wfmt.wBitsPerSample) / 8;
wfmt.nAvgBytesPerSec = wfmt.nSamplesPerSec * wfmt.nBlockAlign;
wfmt.cbSize = 0;
res = waveInOpen(&st->wavein, dev, &wfmt,
(DWORD_PTR) waveInCallback,
(DWORD_PTR) st,
CALLBACK_FUNCTION | WAVE_FORMAT_DIRECT);
if (res != MMSYSERR_NOERROR) {
warning("winwave: waveInOpen: failed res=%d\n", res);
return EINVAL;
}
/* Prepare enough IN buffers to suite at least 50ms of data */
for (i = 0; i < READ_BUFFERS; i++)
err |= add_wave_in(st);
waveInStart(st->wavein);
return err;
}
void CAudioInput::OpenMic()
{
SetWaveHDRInit();
SetWaveInitFormat();
waveInOpen(&h_input, 0, &my_wave_format, (DWORD)waveInProc, 0, CALLBACK_FUNCTION);
waveInPrepareHeader(h_input, mp_wave_header, sizeof(WAVEHDR));
waveInAddBuffer(h_input, mp_wave_header, sizeof(WAVEHDR));
waveInStart(h_input);
}
// Define: _start(WORD, DWORD, DWORD) (real)
DWORD waveCapture::_start(const WORD uDevice, const DWORD dwBufferLength, const DWORD dwNumBuffers)
{
// only one start per session is permitted
if(_recording)
return ERR_ALREADYSTARTED;
// I need dwNumBuffers in stop() as well so I'll set __dwNumBuffers under the counter
__dwNumBuffers = dwNumBuffers;
// Define WAVEFORMATEX Structure (WAVEFORMATEX wf):
wf.wFormatTag = WAVE_FORMAT_PCM;
wf.wBitsPerSample = _wBitsPerSample;
wf.nChannels = _nChannels;
wf.nSamplesPerSec = _dwSamplePerSec;
wf.nBlockAlign = (wf.nChannels * wf.wBitsPerSample) / 8;
wf.nAvgBytesPerSec = (wf.nSamplesPerSec * wf.nBlockAlign);
wf.cbSize = 0;
// Create event:
hevent = CreateEvent(NULL,FALSE,FALSE,NULL);
if(hevent == NULL)
return ERR_EVENTNULL;
// WaveInOpen
if(waveInOpen(&hwi,uDevice,(LPWAVEFORMATEX)&wf,(DWORD)hevent,0,CALLBACK_EVENT) != MMSYSERR_NOERROR)
return ERR_WAVEINOPEN;
// Define WAVEHDR Structure:
buff = new WAVEHDR*[dwNumBuffers];
for (int i = 0; i<(int)dwNumBuffers; i++)
{
buff[i] = new WAVEHDR;
ZeroMemory(buff[i],sizeof(WAVEHDR));
buff[i]->lpData = (char*) malloc(dwBufferLength);
buff[i]->dwBufferLength = dwBufferLength;
buff[i]->dwBytesRecorded = 0;
buff[i]->dwUser = 0;
buff[i]->dwFlags = 0;
buff[i]->dwLoops = 0;
if(waveInPrepareHeader(hwi, buff[i], sizeof(WAVEHDR)) != MMSYSERR_NOERROR)
return ERR_WAVEINPREPAREHEADER;
if(waveInAddBuffer(hwi, buff[i], sizeof(WAVEHDR)) != MMSYSERR_NOERROR)
return ERR_WAVEINADDBUFFER;
}
// Start capturing...
if(waveInStart(hwi) != MMSYSERR_NOERROR)
return ERR_WAVEINSTART;
_dwBufferCount = 0;
dwTotalBufferLength = 0;
_recording = true;
return ERR_NOERROR;
}
static void __cdecl ac3_thread(void *p)
{
ac3_decode *ac3=(ac3_decode *)p;
ac3->done=CreateEvent(NULL,0,0,0);
ac3->out_done=CreateEvent(NULL,0,0,0);
ac3->in_done=CreateEvent(NULL,0,0,0);
if(SetThreadPriority((HANDLE)ac3->thread,THREAD_PRIORITY_HIGHEST)==0)
{
debug("kxmixer: error setting thread priority [%x]\n",GetLastError());
}
// else debug("kxmixer: set thread priority to highest [%x]\n",ac3->thread);
if(SetThreadExecutionState(ES_SYSTEM_REQUIRED)==NULL)
{
debug("kxmixer: cannot set execution thread state -- might cause problems with APM...\n");
}
if(ac3->done && ac3->in_done && ac3->out_done)
{
// debug("kxmixer: thread created and active...starting rec...\n");
waveInStart(ac3->wave_in);
ac3->last_out_buffer=1;
ac3->last_in_buffer=1;
while(1)
{
// WaitForMultipleObject including 'done' event...
HANDLE list[3];
list[0]=ac3->done; list[1]=ac3->out_done; list[2]=ac3->in_done;
int ret=WaitForMultipleObjects(3,list,0,INFINITE);
if(ret==WAIT_OBJECT_0) // done
{
break;
}
if(ret==WAIT_OBJECT_0+1) // out
{
}
if(ret==WAIT_OBJECT_0+2) // in
{
waveOutWrite(ac3->wave_out,&ac3->out_buffer[ac3->last_out_buffer-1],sizeof(WAVEHDR));
ac3->last_out_buffer++;
if(ac3->last_out_buffer>TOTAL_BUFFERS)
ac3->last_out_buffer=1;
}
}
waveInStop(ac3->wave_in);
debug("kxmixer: thread exited...\n");
} else debug("kxmixer: error creating thread events\n");
}
int WaveIn::Start()
{
//int nRet;
if(m_hWaveIn!=NULL){
m_nRet=waveInStart(m_hWaveIn);
if(m_nRet!=MMSYSERR_NOERROR){
return 0;
}
}
return 1;
}
void StartRecording()
{
OpenDevice();
m_dp.Init( SAMPLES_PER_SEC );
PrepareBuffers();
MMRESULT mRes=waveInStart(m_hWaveIn);
if(mRes!=0)
FAIL_M("bad");
}
static void winsnd_read_preprocess(MSFilter *f){
WinSnd *d=(WinSnd*)f->data;
MMRESULT mr;
int i;
int bsize;
DWORD dwFlag;
d->stat_input=0;
d->stat_output=0;
d->stat_notplayed=0;
d->stat_minimumbuffer=WINSND_MINIMUMBUFFER;
winsnd_apply_settings(d);
/* Init Microphone device */
dwFlag = CALLBACK_FUNCTION | WAVE_FORMAT_DIRECT;
mr = waveInOpen (&d->indev, d->dev_id, &d->wfx,
(DWORD) read_callback, (DWORD)f, dwFlag);
if (mr != MMSYSERR_NOERROR)
{
ms_error("Failed to prepare windows sound device. (waveInOpen:0x%i)", mr);
if (d->dev_id != WAVE_MAPPER)
dwFlag = WAVE_MAPPED | CALLBACK_FUNCTION;
mr = waveInOpen (&d->indev, d->dev_id, &d->wfx,
(DWORD) read_callback, (DWORD)f, dwFlag);
}
if (mr != MMSYSERR_NOERROR)
{
ms_error("Failed to prepare windows sound device. (waveInOpen:0x%i)", mr);
mr = waveInOpen (&d->indev, WAVE_MAPPER, &d->wfx,
(DWORD) read_callback, (DWORD)f, CALLBACK_FUNCTION);
if (mr != MMSYSERR_NOERROR)
{
d->indev=NULL;
ms_error("Failed to prepare windows sound device. (waveInOpen:0x%i)", mr);
return ;
}
}
bsize=WINSND_NSAMPLES*d->wfx.nAvgBytesPerSec/8000;
ms_debug("Using input buffers of %i bytes",bsize);
for(i=0;i<WINSND_NBUFS;++i){
WAVEHDR *hdr=&d->hdrs_read[i];
add_input_buffer(d,hdr,bsize);
}
d->running=TRUE;
mr=waveInStart(d->indev);
if (mr != MMSYSERR_NOERROR){
ms_error("waveInStart() error");
return ;
}
#ifndef _TRUE_TIME
ms_ticker_set_time_func(f->ticker,winsnd_get_cur_time,d);
#endif
}
/*
* start the actual device
*/
void startDevice() {
MMRESULT result = waveInStart(hwi);
/* DEBUG */
if (result == MMSYSERR_NOERROR)
printf("Device started\n");
else
printf("ERROR starting device !\n");
/* end DEBUG */
isStarted = TRUE;
}
int tdav_producer_waveapi_start(tmedia_producer_t* self)
{
tdav_producer_waveapi_t* producer = (tdav_producer_waveapi_t*)self;
MMRESULT result;
tsk_size_t i;
if(!producer){
TSK_DEBUG_ERROR("Invalid parameter");
return -1;
}
if(producer->started || producer->hWaveIn){
TSK_DEBUG_WARN("Producer already started");
return 0;
}
/* create events */
if(!producer->events[0]){
producer->events[0] = CreateEvent(NULL, FALSE, FALSE, NULL);
}
if(!producer->events[1]){
producer->events[1] = CreateEvent(NULL, FALSE, FALSE, NULL);
}
/* open */
result = waveInOpen((HWAVEIN *)&producer->hWaveIn, /*WAVE_MAPPER*/0, &producer->wfx, (DWORD)producer->events[0], (DWORD_PTR)producer, CALLBACK_EVENT);
if(result != MMSYSERR_NOERROR){
print_last_error(result, "waveInOpen");
return -2;
}
/* start */
result = waveInStart(producer->hWaveIn);
if(result != MMSYSERR_NOERROR){
print_last_error(result, "waveInStart");
return -2;
}
/* start thread */
tsk_thread_create(&producer->tid[0], __record_thread, producer);
/* write */
for(i = 0; i< sizeof(producer->hWaveHeaders)/sizeof(LPWAVEHDR); i++){
add_wavehdr(producer, i);
}
producer->started = tsk_true;
return 0;
}
//--------------------------------------------------------------------------------------
// Class: SoundResources
// Method: (public) _initialize
// Description: This method is called from the driver level to initialize the resorces.
// Notice that some "open paramenters" can be pases as the method parameters. This is
// so to set the parameters to some setup dependent setting
//--------------------------------------------------------------------------------------
int
SoundResources::_initialize (const SoundOpenParameters& params)
{
_init (params);
_prepareBuffers ();
//start continuous acquisition
if ((m_err = waveInStart(m_WaveInHandle))) {
printf("yarpsounddriver: Error starting record! -- %08X\n", m_err);
}
m_InRecord = true;
return YARP_OK;
}
BOOL Mic_Init_Physical()
{
if (Mic_Inited)
return TRUE;
Mic_Inited = FALSE;
HRESULT hr;
WAVEFORMATEX wfx;
memset(Mic_TempBuf, 0x80, MIC_BUFSIZE);
memset(Mic_Buffer[0], 0x80, MIC_BUFSIZE);
memset(Mic_Buffer[1], 0x80, MIC_BUFSIZE);
Mic_BufPos = 0;
Mic_WriteBuf = 0;
Mic_PlayBuf = 1;
memset(&wfx, 0, sizeof(wfx));
wfx.cbSize = 0;
wfx.wFormatTag = WAVE_FORMAT_PCM;
wfx.nChannels = 1;
wfx.nSamplesPerSec = 16000;
wfx.nBlockAlign = 1;
wfx.nAvgBytesPerSec = 16000;
wfx.wBitsPerSample = 8;
hr = waveInOpen(&waveIn, WAVE_MAPPER, &wfx, (DWORD_PTR)waveInProc, 0, CALLBACK_FUNCTION);
MIC_CHECKERR(hr)
memset(&waveHdr, 0, sizeof(waveHdr));
waveHdr.lpData = (LPSTR)Mic_TempBuf;
waveHdr.dwBufferLength = MIC_BUFSIZE;
hr = waveInPrepareHeader(waveIn, &waveHdr, sizeof(WAVEHDR));
MIC_CHECKERR(hr)
hr = waveInAddBuffer(waveIn, &waveHdr, sizeof(WAVEHDR));
MIC_CHECKERR(hr)
hr = waveInStart(waveIn);
MIC_CHECKERR(hr)
Mic_Inited = TRUE;
INFO("win32 microphone init OK\n");
return TRUE;
}
// Start recording speech
int StartRecord(HWAVEIN* hWaveIn)
{
int res;
res = waveInStart(*hWaveIn);
if(res != MMSYSERR_NOERROR)
{
_debug_print("Start recording FAILED!",1);
return -1;
}
else
{
_debug_print("Start recording...",1);
}
return 0;
}
/*------------------------------------------------------------------------------*/
static void WaveInSync( void )
{
MMRESULT mmRes;
switch ( WaveInStep ){
case -1:
dprintf( 0, 0, "WaveIn Error%d (0x%08X)", WaveInErrorStep, (int)WaveInErrorRes );
break;
case 0:
if ( SettingData.WAVOut != 0 ){ WaveInStep = 1; }
break;
case 1:
mmRes = waveInOpen( &HdWaveIn, WaveInUse, &WaveFormat, (DWORD)WaveInProc, 0, CALLBACK_FUNCTION );
if ( WaveInErrorCheck( mmRes ) != FALSE ){ return; }
WaveInStep = 2;
break;
case 2:
if ( WaveInStatus == WAVEINSTATUS_OPEN ){ WaveInStep = 3; }
break;
case 3:
WaveOutNextNo = 0;
WaveOutLastNo = 0;
for ( int i=0; i<WAVEBUFFNUM; i++ ){
WaveBuff[i].dwUser = 0;
mmRes = waveInPrepareHeader( HdWaveIn, &WaveBuff[i],sizeof(WAVEHDR) );
if ( WaveInErrorCheck( mmRes ) != FALSE ){ return; }
mmRes = waveInAddBuffer( HdWaveIn, &WaveBuff[i],sizeof(WAVEHDR) );
if ( WaveInErrorCheck( mmRes ) != FALSE ){ return; }
}
mmRes = waveInStart( HdWaveIn );
if ( WaveInErrorCheck( mmRes ) != FALSE ){ return; }
WaveInStep = 4;
break;
case 4:
if ( SettingData.WAVOut == 0 ){ WaveInStep = 5; }
break;
case 5:
waveInStop( HdWaveIn );
waveInReset( HdWaveIn );
for ( int i=0; i<WAVEBUFFNUM; i++ ){
waveInUnprepareHeader( HdWaveIn, &WaveBuff[i], sizeof(WAVEHDR) );
}
waveInClose( HdWaveIn );
WaveInStep = 0;
break;
}
}
bool UBWaveRecorder::start()
{
if (!mIsRecording)
{
mRecordingStartTime = QTime::currentTime();
mMsTimeStamp = 0;
mIsRecording = true;
}
if (waveInStart(mWaveInDevice) != MMSYSERR_NOERROR)
{
setLastErrorMessage("Cannot start wave in device ");
return false;
}
return true;
}
static int read_stream_open(struct ausrc_st *st, const struct ausrc_prm *prm,
unsigned int dev)
{
WAVEFORMATEX wfmt;
MMRESULT res;
uint32_t sampc;
int i, err = 0;
/* Open an audio INPUT stream. */
st->wavein = NULL;
st->bufs_idx = 0;
sampc = prm->srate * prm->ch * prm->ptime / 1000;
for (i = 0; i < READ_BUFFERS; i++) {
memset(&st->bufs[i].wh, 0, sizeof(WAVEHDR));
st->bufs[i].mb = mbuf_alloc(2 * sampc);
if (!st->bufs[i].mb)
return ENOMEM;
}
wfmt.wFormatTag = WAVE_FORMAT_PCM;
wfmt.nChannels = prm->ch;
wfmt.nSamplesPerSec = prm->srate;
wfmt.wBitsPerSample = 16;
wfmt.nBlockAlign = (prm->ch * wfmt.wBitsPerSample) / 8;
wfmt.nAvgBytesPerSec = wfmt.nSamplesPerSec * wfmt.nBlockAlign;
wfmt.cbSize = 0;
res = waveInOpen(&st->wavein, dev, &wfmt,
(DWORD_PTR) waveInCallback,
(DWORD_PTR) st,
CALLBACK_FUNCTION | WAVE_FORMAT_DIRECT);
if (res != MMSYSERR_NOERROR) {
warning("sinwave: waveInOpen: failed %d\n", err);
return EINVAL;
}
/* Prepare enough IN buffers to suite at least 50ms of data */
for (i = 0; i < READ_BUFFERS; i++)
err |= add_wave_in(st);
waveInStart(st->wavein);
return err;
}
//开始录音
BOOL CAudioRec::Start()
{
BOOL bRet=FALSE;
if(!m_hIn)
goto RET;
if(!AllocBuffer())
goto RET;
m_mmr=waveInStart(m_hIn);
if(m_mmr)
goto RET;
bRet=TRUE;
RET:
return bRet;
}
