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; }