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

/***************************************************************************** * PlayWaveOut: play a buffer through the WaveOut device *****************************************************************************/static int PlayWaveOut( aout_instance_t *p_aout, HWAVEOUT h_waveout,                        WAVEHDR *p_waveheader, aout_buffer_t *p_buffer ){    MMRESULT result;    /* Prepare the buffer */    if( p_buffer != NULL )        p_waveheader->lpData = p_buffer->p_buffer;    else        /* Use silence buffer instead */        p_waveheader->lpData = p_aout->output.p_sys->p_silence_buffer;    p_waveheader->dwUser = p_buffer ? (DWORD_PTR)p_buffer : (DWORD_PTR)1;    p_waveheader->dwBufferLength = p_aout->output.p_sys->i_buffer_size;    p_waveheader->dwFlags = 0;    result = waveOutPrepareHeader( h_waveout, p_waveheader, sizeof(WAVEHDR) );    if( result != MMSYSERR_NOERROR )    {        msg_Err( p_aout, "waveOutPrepareHeader failed" );        return VLC_EGENERIC;    }    /* Send the buffer to the waveOut queue */    result = waveOutWrite( h_waveout, p_waveheader, sizeof(WAVEHDR) );    if( result != MMSYSERR_NOERROR )    {        msg_Err( p_aout, "waveOutWrite failed" );        return VLC_EGENERIC;    }    return VLC_SUCCESS;}

static void WAV_WriteAudio(GF_AudioOutput *dr){	LPWAVEHDR hdr;	HRESULT hr;	u32 i;	WAVCTX();	if (!ctx->hwo) return;	WaitForSingleObject(ctx->event, INFINITE);	if (ctx->exit_request) return;	for (i=0; i<ctx->num_buffers; i++) {		/*get buffer*/		hdr = &ctx->wav_hdr[i];		if (hdr->dwFlags & WHDR_DONE) {			waveOutUnprepareHeader(ctx->hwo, hdr, sizeof(WAVEHDR));			hdr->dwBufferLength = ctx->buffer_size;			/*update delay*/			ctx->delay = 1000 * i * ctx->buffer_size / ctx->fmt.nAvgBytesPerSec;			/*fill it*/			hdr->dwBufferLength = dr->FillBuffer(dr->audio_renderer, hdr->lpData, ctx->buffer_size);			hdr->dwFlags = 0;		    hr = waveOutPrepareHeader(ctx->hwo, hdr, sizeof(WAVEHDR));			/*write it*/			waveOutWrite(ctx->hwo, hdr, sizeof(WAVEHDR));		}	}}

SoundLib2dBuf::SoundLib2dBuf(){	// Allocate the buffer	unsigned int numSamples = g_prefsManager->GetInt("SoundBufferSize", 2000);	m_buffer = new StereoSample[numSamples];	// Clear the buffer	memset(m_buffer, 0, numSamples * sizeof(StereoSample));	// Register the buffer with Windows	memset(&m_header, 0, sizeof(WAVEHDR));	m_header.lpData = (char*)m_buffer;	int blockAlign = 4;		// 2 channels * 2 bytes per sample	m_header.dwBufferLength = numSamples * blockAlign;	m_header.dwFlags = WHDR_DONE;	int result = waveOutPrepareHeader(s_device, &m_header, sizeof(WAVEHDR));	DarwiniaReleaseAssert(result == MMSYSERR_NOERROR, "Couldn't init buffer");	// Play the buffer	static int count = 0;	if (count < 4)	{		count++;		result = waveOutWrite(s_device, &m_header, sizeof(WAVEHDR));		DarwiniaReleaseAssert(result == MMSYSERR_NOERROR, "Couldn't send sound data");	}}

int win32_audio_play(short *buffer, int buffer_len){   int i, current_to_play, remained_to_play;   short *des, *src;   remained_to_play = buffer_len;   while (remained_to_play > 0) {      while (ri == ((wi + 1) % WO_MAX_BUCKETS))         Sleep(100);            /* wait until there are available buckets */      if (WHDR_DONE == (wOutHdr[wi].dwFlags & WHDR_DONE))         waveOutUnprepareHeader(wOutDev, &wOutHdr[wi], sizeof(WAVEHDR));      current_to_play =          (remained_to_play >           WO_BUCKET_SIZE) ? WO_BUCKET_SIZE : remained_to_play;      if (0 < current_to_play) {         des = (short *) wOutHdr[wi].lpData;         src = (short *) &(buffer[buffer_len - remained_to_play]);         for (i = 0; i < current_to_play; i++)            des[i] = src[i];         wOutHdr[wi].dwBufferLength = current_to_play * sizeof(short);         waveOutPrepareHeader(wOutDev, &wOutHdr[wi], sizeof(WAVEHDR));         waveOutWrite(wOutDev, &wOutHdr[wi], sizeof(WAVEHDR));         remained_to_play -= current_to_play;         wi = (wi + 1) % WO_MAX_BUCKETS;      }   }   return (WIN32AUDIO_NO_ERROR);}

    DWORD CALLBACK Thread()    {        static const int BufferSizeBytes = BufferSize * sizeof(T);        while (waveout_running) {            bool didsomething = false;            for (u32 i = 0; i < numBuffers; i++) {                if (!(whbuffer[i].dwFlags & WHDR_DONE))                    continue;                WAVEHDR *buf = whbuffer + i;                buf->dwBytesRecorded = buf->dwBufferLength;                T *t = (T *)buf->lpData;                for (int p = 0; p < PacketsPerBuffer; p++, t += SndOutPacketSize)                    SndBuffer::ReadSamples(t);                whbuffer[i].dwFlags &= ~WHDR_DONE;                waveOutWrite(hwodevice, buf, sizeof(WAVEHDR));                didsomething = true;            }            if (didsomething)                Sleep(1);            else                Sleep(0);        }        return 0;    }

int audio_write_wince(cst_audiodev *ad, void *samples, int num_bytes){    au_wince_pdata *pd = ad->platform_data;    WAVEHDR *hdr;    MMRESULT err;    if (num_bytes == 0)        return 0;    hdr = cst_alloc(WAVEHDR,1);    hdr->lpData = cst_alloc(char,num_bytes);    memcpy(hdr->lpData,samples,num_bytes);    hdr->dwBufferLength = num_bytes;    err = waveOutPrepareHeader(pd->wo, hdr, sizeof(*hdr));    if (err != MMSYSERR_NOERROR)    {        cst_errmsg("Failed to prepare header %p: %x/n", hdr, err);        cst_error();    }    if (InterlockedIncrement(&pd->bcnt) == 8)        WaitForSingleObject(pd->wevt, INFINITE);    err = waveOutWrite(pd->wo, hdr, sizeof(*hdr));    if (err != MMSYSERR_NOERROR)    {        cst_errmsg("Failed to write header %p: %x/n", hdr, err);        cst_error();    }    return num_bytes;}

static size_twinmm_output_play(struct audio_output *ao, const void *chunk, size_t size, GError **error_r){	struct winmm_output *wo = (struct winmm_output *)ao;	/* get the next buffer from the ring and prepare it */	struct winmm_buffer *buffer = &wo->buffers[wo->next_buffer];	if (!winmm_drain_buffer(wo, buffer, error_r) ||	    !winmm_set_buffer(wo, buffer, chunk, size, error_r))		return 0;	/* enqueue the buffer */	MMRESULT result = waveOutWrite(wo->handle, &buffer->hdr,				       sizeof(buffer->hdr));	if (result != MMSYSERR_NOERROR) {		waveOutUnprepareHeader(wo->handle, &buffer->hdr,				       sizeof(buffer->hdr));		g_set_error(error_r, winmm_output_quark(), result,			    "waveOutWrite() failed");		return 0;	}	/* mark our buffer as "used" */	wo->next_buffer = (wo->next_buffer + 1) %		G_N_ELEMENTS(wo->buffers);	return size;}

// put here your synthvoid sound_init(){	CreateThread(0, 0, (LPTHREAD_START_ROUTINE)_4klang_render, lpSoundBuffer, 0, 0);	waveOutOpen(&hWaveOut, WAVE_MAPPER, &WaveFMT, NULL, 0, CALLBACK_NULL);	waveOutPrepareHeader(hWaveOut, &WaveHDR, sizeof(WaveHDR));	waveOutWrite(hWaveOut, &WaveHDR, sizeof(WaveHDR));}

int CMemPlay::Write(char *buf,int len){	// check device open	if (bDeviceopen==FALSE) return(0);// TRACE("Write(%d bytes)/n",len);	// copy to transfer buffer	if (len > (int)iWavebufsize) len = iWavebufsize;	if (len > 0) {		memcpy(pWavehdr[iBufindex]->lpData,buf,len);		pWavehdr[iBufindex]->dwBufferLength = len;		// write to device		pWavehdr[iBufindex]->dwFlags = (DWORD)WHDR_PREPARED;		if (waveOutWrite(hWaveout, pWavehdr[iBufindex],sizeof(WAVEHDR))) {			Stop();			return(0);		}		nPending++;//		TRACE("nPending=%d/n",nPending);		iBufindex = (iBufindex+1)%NBUFFERS;	}	else		iMorebuffers = OFF;	return(len);}

void CALLBACK WaveOutProc(HWAVEOUT hWaveOut, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2){	DWORD readBytes = 0;	LPWAVEHDR pWaveHdr;	LPSTR p;	switch(uMsg)	{	case WOM_DONE:		if(playingFlag == FALSE)		{			return;		}		pWaveHdr = (LPWAVEHDR)dwParam1;		p = pWaveHdr->lpData;		EnterCriticalSection(&cs);		mpg123_read(mh, p, SOUND_BUFFER_LEN, &readBytes);		LeaveCriticalSection(&cs);		if(readBytes == 0)		{			playingFlag = FALSE;			return;		}		waveOutUnprepareHeader(hWaveOut, pWaveHdr, sizeof(WAVEHDR));		ZeroMemory(pWaveHdr, sizeof(WAVEHDR));		pWaveHdr->dwBufferLength = readBytes;		pWaveHdr->lpData = p;		waveOutPrepareHeader(hWaveOut, pWaveHdr, sizeof(WAVEHDR));		waveOutWrite(hWaveOut, pWaveHdr, sizeof(WAVEHDR));		break;	}}

 static void winMMThread(LPVOID aParam) {     SoLoudWinMMData *data = static_cast<SoLoudWinMMData*>(aParam);     while (WAIT_OBJECT_0 != WaitForSingleObject(data->audioProcessingDoneEvent, 0))      {         for (int i=0;i<BUFFER_COUNT;++i)          {             if (0 != (data->header[i].dwFlags & WHDR_INQUEUE))              {                 continue;             }             data->soloud->mix(data->buffer, data->samples);             short *tgtBuf = data->sampleBuffer[i];             for (DWORD j=0;j<(data->header[i].dwBufferLength/sizeof(short));++j)              {                 tgtBuf[j] = static_cast<short>(floor(data->buffer[j]                                                       * static_cast<float>(0x7fff)));             }             if (MMSYSERR_NOERROR != waveOutWrite(data->waveOut, &data->header[i],                                                   sizeof(WAVEHDR)))              {                 return;             }         }         WaitForSingleObject(data->bufferEndEvent, INFINITE);     } }

static ALCboolean WinMMStartPlayback(ALCdevice *device){    WinMMData *pData = (WinMMData*)device->ExtraData;    ALbyte *BufferData;    ALint lBufferSize;    ALuint i;    pData->hWaveThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)PlaybackThreadProc, (LPVOID)device, 0, &pData->ulWaveThreadID);    if(pData->hWaveThread == NULL)        return ALC_FALSE;    pData->lWaveBuffersCommitted = 0;    // Create 4 Buffers    lBufferSize  = device->UpdateSize*device->NumUpdates / 4;    lBufferSize *= FrameSizeFromDevFmt(device->FmtChans, device->FmtType);    BufferData = calloc(4, lBufferSize);    for(i = 0;i < 4;i++)    {        memset(&pData->WaveBuffer[i], 0, sizeof(WAVEHDR));        pData->WaveBuffer[i].dwBufferLength = lBufferSize;        pData->WaveBuffer[i].lpData = ((i==0) ? (LPSTR)BufferData :                                       (pData->WaveBuffer[i-1].lpData +                                        pData->WaveBuffer[i-1].dwBufferLength));        waveOutPrepareHeader(pData->hWaveHandle.Out, &pData->WaveBuffer[i], sizeof(WAVEHDR));        waveOutWrite(pData->hWaveHandle.Out, &pData->WaveBuffer[i], sizeof(WAVEHDR));        InterlockedIncrement(&pData->lWaveBuffersCommitted);    }    return ALC_TRUE;}

// nativeStoreSamples - stores Java samples into a wave buffer for playbackJNIEXPORT void JNICALL Java_craigl_winplayer_WinPlayer_nativeStoreSamples(	JNIEnv *env, jclass jc, jshortArray buffer, jint length) {		static AudioSample *pSamples = NULL;	WAVEHDR *pWaveHdr;	// No more data to process ?	if (length == -1) {		// Release the array		(*env)->ReleaseShortArrayElements(env, buffer, pSamples, 0);		pSamples = NULL;		return;	}		// pSamples points at the Java samples	pSamples = (AudioSample *)(*env)->GetShortArrayElements(env, buffer, 0);			// pWaveHdr points at the buffer to use	pWaveHdr = &waveHdr[currentBufferIndex];	// Set amount of data to process	pWaveHdr->dwBufferLength = length * 2;	// Copy the samples from array into wave buffer	memcpy((byte *) pWaveHdr->lpData, (byte *) pSamples, length * 2);	// Write the wave data to the output device	waveOutWrite(hDevice, pWaveHdr, sizeof(WAVEHDR));	// Update buffer index	currentBufferIndex = (currentBufferIndex + 1) % NUMBEROFBUFFERS;}

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++ wbcFreeMemory函数代码示例
C++ waveOutUnprepareHeader函数代码示例