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

bool __stdcall AudioStop1(){		waveOutReset(m_hWaveOut1);//停止输出	waveOutClose(m_hWaveOut1);//关闭设备    return true;}

bool CWavePlay::CloseDevice(){	ZeroMemory(&m_wavformex,sizeof(WAVEFORMATEX)); 	 while(_nWaveFreeBlockCount != 0 && _nWaveFreeBlockCount < BLOCK_COUNT)        Sleep(10);    /*     * unprepare any blocks that are still prepared     */    for(int i = 0; i < _nWaveFreeBlockCount; i++)	{        if(_waveBlocks && _waveBlocks[i].dwFlags & WHDR_PREPARED)		{            waveOutUnprepareHeader(m_hWaveOut, &_waveBlocks[i], sizeof(WAVEHDR));		}	}	if(_waveBlocks)	{		freeBlocks(_waveBlocks);		_waveBlocks = NULL;	}	waveOutClose(m_hWaveOut);	m_bPalyState = false; 	return true;}

/* HTS_Audio_close: close audio device */void HTS_Audio_close(HTS_Audio * as){   MMRESULT error;   if (as->buff_size != 0)      HTS_Audio_write_buffer(as);   while (as->now_buff_1 == TRUE)      Sleep(AUDIO_WAIT_BUFF_MS);   while (as->now_buff_2 == TRUE)      Sleep(AUDIO_WAIT_BUFF_MS);   /* stop audio */   error = waveOutReset(as->hwaveout);   if (error != MMSYSERR_NOERROR)      HTS_error(0,                "hts_engine: Cannot stop and reset your output audio device./n");   /* unprepare */   error = waveOutUnprepareHeader(as->hwaveout, &(as->buff_1), sizeof(WAVEHDR));   if (error != MMSYSERR_NOERROR)      HTS_error(0,                "hts_engine: Cannot cleanup the audio datablocks to play waveform./n");   error = waveOutUnprepareHeader(as->hwaveout, &(as->buff_2), sizeof(WAVEHDR));   if (error != MMSYSERR_NOERROR)      HTS_error(0,                "hts_engine: Cannot cleanup the audio datablocks to play waveform./n");   /* close */   error = waveOutClose(as->hwaveout);   if (error != MMSYSERR_NOERROR)      HTS_error(0, "hts_engine: Failed to close your output audio device./n");   HTS_free(as->buff_1.lpData);   HTS_free(as->buff_2.lpData);   HTS_free(as->buff);}

intWIN_Audio_close ( void ){	if ( dev != NULL )     {		while ( ScheduledBlocks > 0 ) {			Sleep (ScheduledBlocks);			while ( PlayedWaveHeadersCount > 0 )         // free used blocks ...				free_memory ();		}		waveOutReset (dev);      // reset the device		waveOutClose (dev);      // close the device		dev = NULL;	}	DeleteCriticalSection ( &cs );	ScheduledBlocks = 0;    if (!g_bEnd)    {        g_hDuoduoWnd = FindWindow(NULL,"多多卖家版");        if (g_hDuoduoWnd)        {            PostMessage(g_hDuoduoWnd,g_sPlayFinished,NULL,NULL);        }else        {            //Box( "Can't find window named 多多卖家版" );        }    }	return 0;}

 static void winMMCleanup(Soloud *aSoloud) {     if (0 == aSoloud->mBackendData)     {         return;     }     SoLoudWinMMData *data = static_cast<SoLoudWinMMData*>(aSoloud->mBackendData);     SetEvent(data->audioProcessingDoneEvent);     SetEvent(data->bufferEndEvent);     Thread::wait(data->threadHandle);     Thread::release(data->threadHandle);     CloseHandle(data->audioProcessingDoneEvent);     CloseHandle(data->bufferEndEvent);     waveOutReset(data->waveOut);     for (int i=0;i<BUFFER_COUNT;++i)      {         waveOutUnprepareHeader(data->waveOut, &data->header[i], sizeof(WAVEHDR));         if (0 != data->sampleBuffer[i])         {             delete[] data->sampleBuffer[i];         }     }     if (0 != data->buffer)     {         delete[] data->buffer;     }     waveOutClose(data->waveOut);     Thread::destroyMutex(data->soloud->mMutex);     data->soloud->mMutex = 0;     data->soloud->mLockMutexFunc = 0;     data->soloud->mUnlockMutexFunc = 0;     delete data;     aSoloud->mBackendData = 0; }

char testNoCallback(float seconds, float frequency){  MMRESULT result;  HWAVEOUT waveOut;  result = waveOutOpen(&waveOut,		       WAVE_MAPPER,		       &waveFormat,		       0,		       0,		       CALLBACK_NULL);  if(result != MMSYSERR_NOERROR) {    printf("waveOutOpen failed (result=%d)/n", result);    return 1;  }  printf("Opened Wave Mapper!/n");  fflush(stdout);    DWORD sampleCount = seconds * waveFormat.nSamplesPerSec;  LPSTR block = allocateBlock(sampleCount);  fillSinWave(block, frequency, sampleCount);    printf("Writing block.../n");  fflush(stdout);  writeAudioBlock(waveOut, block, sampleCount * waveFormat.nBlockAlign);  waveOutClose(waveOut);  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;   }}

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

// ----------------// DestroyRunObject// ----------------// Destroys the run-time object// short WINAPI DLLExport DestroyRunObject(LPRDATA rdPtr, long fast){	/* Immediately stop playback because the buffers will be gone soon */	waveOutPause(rdPtr->device);	/* Tell thread to stop */	rdPtr->shuttingDown = true;	/* Wait for thread to finish */	WaitForSingleObject(rdPtr->thread, INFINITE);	CloseHandle(rdPtr->thread);		/* Free all buffers */	for(int i = 0; i < NUM_BUFFERS; ++i)	{		waveOutUnprepareHeader(rdPtr->device, &rdPtr->buffers[i], sizeof(WAVEHDR));		delete[] rdPtr->buffers[i].lpData;	}	/* Close audio device */	waveOutClose(rdPtr->device);	/* Good bye! */	delete rdPtr->rRd;	return 0;}

int native_midi_detect(){	MMRESULT merr;	HWAVEOUT MidiStream;	memset(&wfm,0,sizeof(wfm));	wfm.wfx.wFormatTag=WAVE_FORMAT_MIDI;	wfm.wfx.nChannels=1;	wfm.wfx.nSamplesPerSec=32;	wfm.wfx.nAvgBytesPerSec=32;	wfm.wfx.nBlockAlign=sizeof(WAVEFORMAT_MIDI_MESSAGE);	wfm.wfx.wBitsPerSample=16;	wfm.wfx.cbSize=WAVEFORMAT_MIDI_EXTRASIZE;	//wfm.USecPerQuarterNote=9600000; // Force each tick to be 1/10 sec	//wfm.TicksPerQuarterNote = 96;		merr = waveOutOpen(&MidiStream, WAVE_MAPPER, (LPWAVEFORMATEX)&wfm, (DWORD)MidiProc, 0, CALLBACK_FUNCTION); 	if (merr!=MMSYSERR_NOERROR)		MidiStream=0;	waveOutClose(MidiStream);	if (!MidiStream)		return 0;	else		return 1;}

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

///////////////////////////////////////////////////////////////////////////////// Close devicevoid CWaveOut::Stop(void){int i; // are we started ? if (m_Dev != NULL) return; // remove all blocks from queue waveOutReset(m_Dev); // free output blocks if (m_B != NULL) {for (i = 0; i < m_nBlock; i++)  {// if block is prepared, unprepare it   if ((m_B[i].dwFlags & WHDR_PREPARED) == WHDR_PREPARED)    waveOutUnprepareHeader(m_Dev, m_B+i, sizeof(m_B[i]));     // if block has data, free it   if (m_B[i].lpData != NULL) ippsFree(m_B[i].lpData);  }   // free array  ippsFree(m_B);  m_B = NULL; }  // close device waveOutClose(m_Dev); m_Dev = NULL;}

BOOL CMixOut::OpenMixer(){	m_iDevNum = mixerGetNumDevs();	if (m_iDevNum == 0)	{		TRACE("There (is) are no device mixer./n");		return FALSE;	}	WAVEFORMATEX wfx;	memset( &wfx, 0, sizeof(WAVEFORMATEX) );	wfx.wFormatTag = WAVE_FORMAT_PCM;	wfx.nChannels = 1;	wfx.nSamplesPerSec = 8000;	wfx.nAvgBytesPerSec = 1 * 8000 * 16 / 8;	wfx.nBlockAlign = 16 * 1 / 8;	wfx.wBitsPerSample = 16;	wfx.cbSize = 0;	HWAVEOUT hwaveOut;	m_mmr = waveOutOpen( &hwaveOut, WAVE_MAPPER, &wfx, 0L, 0L, CALLBACK_NULL );	if ( m_mmr != MMSYSERR_NOERROR )	{		return false;	}	else	{		m_mmr = mixerGetID( (HMIXEROBJ)hwaveOut, &m_uiMixerId, MIXER_OBJECTF_HWAVEOUT );		waveOutClose( hwaveOut );		if (m_mmr != MMSYSERR_NOERROR )		{			return false;		}	}	WNDCLASSEX wcx;	memset( &wcx, 0, sizeof(WNDCLASSEX) );		wcx.cbSize = sizeof(WNDCLASSEX);	wcx.lpszClassName = WND_CLASS_NAME;	wcx.lpfnWndProc = (WNDPROC)MixerWndProc;	::RegisterClassEx(&wcx);	m_hWnd = CreateWindow(	WND_CLASS_NAME,							WND_NAME,							WS_POPUP | WS_DISABLED,							0, 0, 0, 0,							NULL, NULL, NULL, NULL );	if ( !m_hWnd )	{			return false;	}	::ShowWindow(m_hWnd, SW_HIDE);	m_mmr = mixerOpen( (LPHMIXER)&m_hMixer, m_uiMixerId, (DWORD)m_hWnd, 0L, CALLBACK_WINDOW );	if (m_mmr != MMSYSERR_NOERROR )	{		::DestroyWindow( m_hWnd );		return false;	}	return true;}

FRBC2CI_API int SoundDev_DeInit(){	int i;	waveOutReset(hWaveOut);	if(lpWaveHdr)	{		for(i=0; i<WAV_BUFFERS; i++)			waveOutUnprepareHeader(hWaveOut, lpWaveHdr+i, sizeof(WAVEHDR));	}	waveOutClose(hWaveOut);	if(hWaveHdr)	{		GlobalUnlock(hWaveHdr); 		GlobalFree(hWaveHdr);	}	if(hData)	{		GlobalUnlock(hData);		GlobalFree(hData);	}	return(0);}

static void winsnd_write_postprocess(MSFilter *f){	WinSnd *d=(WinSnd*)f->data;	MMRESULT mr;	int i;	if (d->outdev==NULL) return;	mr=waveOutReset(d->outdev);	if (mr != MMSYSERR_NOERROR){		ms_error("waveOutReset() error");		return ;	}	for(i=0;i<WINSND_OUT_NBUFS;++i){		WAVEHDR *hdr=&d->hdrs_write[i];		mblk_t *old;		if (hdr->dwFlags & WHDR_DONE){			mr=waveOutUnprepareHeader(d->outdev,hdr,sizeof(*hdr));			if (mr != MMSYSERR_NOERROR){				ms_error("waveOutUnprepareHeader error");			}			old=(mblk_t*)hdr->dwUser;			if (old) freemsg(old);			hdr->dwUser=0;		}	}	mr=waveOutClose(d->outdev);	if (mr != MMSYSERR_NOERROR){		ms_error("waveOutClose() error");		return ;	}	d->ready=0;	d->workaround=0;}

unsigned int WINAPI MaoVoice::Play(PVOID para){	MaoVoice * me = (MaoVoice*)para;	HWAVEOUT hWaveOut;	WAVEFORMATEX wavform;	wavform.wFormatTag = WAVE_FORMAT_PCM;	wavform.nChannels = Channels;	wavform.nSamplesPerSec = Sample_Rate;	wavform.nAvgBytesPerSec = Sample_Rate * Quantize_Bits * Channels / 8;	wavform.nBlockAlign = Channels * Quantize_Bits / 8;	wavform.wBitsPerSample = Quantize_Bits;	wavform.cbSize = 0;	waveOutOpen(&hWaveOut, WAVE_MAPPER, &wavform, (DWORD_PTR)MaoVoice::waveOutProc, 0, CALLBACK_FUNCTION);	char * buf = NULL;	WAVEHDR wavhdr;	while (true)	{		if (true == me->needRelease)		{			break;		}		else if (true == me->canPLAY)		{			EnterCriticalSection(&me->playBufCritical);			if (false == me->playBufQueue.empty())			{				buf = me->playBufQueue.front();				me->playBufQueue.pop();				LeaveCriticalSection(&me->playBufCritical);			}			else			{				LeaveCriticalSection(&me->playBufCritical);				Sleep(1);				continue;			}			wavhdr.dwBufferLength = BUFFER_SIZE;			wavhdr.lpData = buf;			wavhdr.dwFlags = 0;			wavhdr.dwLoops = 0;			waveOutPrepareHeader(hWaveOut, &wavhdr, sizeof(WAVEHDR));			/* 
C++ waveOutGetDevCaps函数代码示例
C++ waveInStart函数代码示例