自学教程：C++ waveInClose函数代码示例

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 voidwinaudio_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 int32wavein_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 - [email
C++ waveInGetDevCaps函数代码示例
C++ waveInAddBuffer函数代码示例