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

static	DWORD	wodPrepare(WAVEMAPDATA* wom, LPWAVEHDR lpWaveHdrSrc, DWORD dwParam2){    PACMSTREAMHEADER	ash;    DWORD		size;    DWORD		dwRet;    LPWAVEHDR		lpWaveHdrDst;    TRACE("(%p %p %08x)/n", wom, lpWaveHdrSrc, dwParam2);    if (!wom->hAcmStream)	return waveOutPrepareHeader(wom->u.out.hInnerWave, lpWaveHdrSrc, dwParam2);    if (acmStreamSize(wom->hAcmStream, lpWaveHdrSrc->dwBufferLength, &size, ACM_STREAMSIZEF_SOURCE) != MMSYSERR_NOERROR) {        WARN("acmStreamSize failed/n");	return MMSYSERR_ERROR;    }    ash = HeapAlloc(GetProcessHeap(), 0, sizeof(ACMSTREAMHEADER) + sizeof(WAVEHDR) + size);    if (ash == NULL) {        WARN("no memory/n");	return MMSYSERR_NOMEM;    }    ash->cbStruct = sizeof(*ash);    ash->fdwStatus = 0L;    ash->dwUser = (DWORD_PTR)lpWaveHdrSrc;    ash->pbSrc = (LPBYTE)lpWaveHdrSrc->lpData;    ash->cbSrcLength = lpWaveHdrSrc->dwBufferLength;    /* ash->cbSrcLengthUsed */    ash->dwSrcUser = lpWaveHdrSrc->dwUser; /* FIXME ? */    ash->pbDst = (LPBYTE)ash + sizeof(ACMSTREAMHEADER) + sizeof(WAVEHDR);    ash->cbDstLength = size;    /* ash->cbDstLengthUsed */    ash->dwDstUser = 0; /* FIXME ? */    dwRet = acmStreamPrepareHeader(wom->hAcmStream, ash, 0L);    if (dwRet != MMSYSERR_NOERROR) {        WARN("acmStreamPrepareHeader failed/n");	goto errCleanUp;    }    lpWaveHdrDst = (LPWAVEHDR)((LPSTR)ash + sizeof(ACMSTREAMHEADER));    lpWaveHdrDst->lpData = (LPSTR)ash->pbDst;    lpWaveHdrDst->dwBufferLength = size; /* conversion is not done yet */    lpWaveHdrDst->dwFlags = 0;    lpWaveHdrDst->dwLoops = 0;    dwRet = waveOutPrepareHeader(wom->u.out.hInnerWave, lpWaveHdrDst, sizeof(*lpWaveHdrDst));    if (dwRet != MMSYSERR_NOERROR) {        WARN("waveOutPrepareHeader failed/n");	goto errCleanUp;    }    lpWaveHdrSrc->reserved = (DWORD_PTR)ash;    lpWaveHdrSrc->dwFlags = WHDR_PREPARED;    TRACE("=> (0)/n");    return MMSYSERR_NOERROR;errCleanUp:    TRACE("=> (%d)/n", dwRet);    HeapFree(GetProcessHeap(), 0, ash);    return dwRet;}

/* HTS106_Audio_open: open audio device */static void HTS106_Audio_open(HTS106_Audio * audio, int sampling_rate, int max_buff_size){   MMRESULT error;   if (audio->sampling_rate == sampling_rate && audio->max_buff_size == max_buff_size)      return;   HTS106_Audio_close(audio);   audio->sampling_rate = sampling_rate;   audio->max_buff_size = max_buff_size;   if (audio->max_buff_size <= 0)      return;   /* queue */   audio->which_buff = 1;   audio->now_buff_1 = FALSE;   audio->now_buff_2 = FALSE;   audio->buff = (short *) HTS106_calloc(max_buff_size, sizeof(short));   /* format */   audio->waveformatex.wFormatTag = WAVE_FORMAT_PCM;   audio->waveformatex.nChannels = AUDIO_CHANNEL;   audio->waveformatex.nSamplesPerSec = sampling_rate;   audio->waveformatex.wBitsPerSample = sizeof(short) * 8;   audio->waveformatex.nBlockAlign = AUDIO_CHANNEL * audio->waveformatex.wBitsPerSample / 8;   audio->waveformatex.nAvgBytesPerSec = sampling_rate * audio->waveformatex.nBlockAlign;   /* open */   error = waveOutOpen(&audio->hwaveout, WAVE_MAPPER, &audio->waveformatex, (DWORD) HTS106_Audio_callback_function, (DWORD) audio, CALLBACK_FUNCTION);   if (error != MMSYSERR_NOERROR)      HTS106_error(0, "hts_engine: Failed to open your output audio device to play waveform./n");   /* prepare */   audio->buff_1.lpData = (LPSTR) HTS106_calloc(max_buff_size, sizeof(short));   audio->buff_1.dwBufferLength = max_buff_size * sizeof(short);   audio->buff_1.dwFlags = WHDR_BEGINLOOP | WHDR_ENDLOOP;   audio->buff_1.dwLoops = 1;   audio->buff_1.lpNext = 0;   audio->buff_1.reserved = 0;   error = waveOutPrepareHeader(audio->hwaveout, &(audio->buff_1), sizeof(WAVEHDR));   if (error != MMSYSERR_NOERROR)      HTS106_error(0, "hts_engine: Cannot initialize audio datablocks to play waveform./n");   audio->buff_2.lpData = (LPSTR) HTS106_calloc(max_buff_size, sizeof(short));   audio->buff_2.dwBufferLength = max_buff_size * sizeof(short);   audio->buff_2.dwFlags = WHDR_BEGINLOOP | WHDR_ENDLOOP;   audio->buff_2.dwLoops = 1;   audio->buff_2.lpNext = 0;   audio->buff_2.reserved = 0;   error = waveOutPrepareHeader(audio->hwaveout, &(audio->buff_2), sizeof(WAVEHDR));   if (error != MMSYSERR_NOERROR)      HTS106_error(0, "hts_engine: Cannot initialize audio datablocks to play waveform./n");}

void InternalPlayer::writeAudio(int16_t *samples, int sampleCount) {		WAVEHDR &h = header[blockPosition];		h.dwBufferLength = sampleCount * 2;		memcpy(h.lpData, samples, sampleCount * 2);		if(h.dwFlags & WHDR_PREPARED) 			waveOutUnprepareHeader(hWaveOut, &h, sizeof(WAVEHDR));		waveOutPrepareHeader(hWaveOut, &h, sizeof(WAVEHDR));		waveOutWrite(hWaveOut, &h, sizeof(WAVEHDR));		lock.lock();		blockCounter++;		lock.unlock();		blockPosition++;		blockPosition = (blockPosition % bufCount);		while(true) {			lock.lock();			int bc = blockCounter;			lock.unlock();			if(bc < bufCount)				break;			Sleep(100);		}	}

/** * Copy data into a buffer, and prepare the wave header. */static boolwinmm_set_buffer(struct winmm_output *wo, struct winmm_buffer *buffer,		 const void *data, size_t size,		 GError **error_r){	void *dest = pcm_buffer_get(&buffer->buffer, size);	if (dest == NULL) {		g_set_error(error_r, winmm_output_quark(), 0,			    "Out of memory");		return false;	}	memcpy(dest, data, size);	memset(&buffer->hdr, 0, sizeof(buffer->hdr));	buffer->hdr.lpData = dest;	buffer->hdr.dwBufferLength = size;	MMRESULT result = waveOutPrepareHeader(wo->handle, &buffer->hdr,					       sizeof(buffer->hdr));	if (result != MMSYSERR_NOERROR) {		g_set_error(error_r, winmm_output_quark(), result,			    "waveOutPrepareHeader() failed");		return false;	}	return true;}

int EmuOutMod::Write(char *buf, int len) {    ::WaitForSingleObject(m_mutex, INFINITE);    int rest = m_buf_rest;    ::ReleaseMutex(m_mutex);    if(rest<len) return 1;    waveOutSetVolume(m_hwo, (DWORD)(m_volume<<16)|m_volume);    for(int i=0; i<len; i++) {        m_buf[m_buf_idx%m_ring_size][m_buf_pos++] = buf[i];        rest--;        if(m_buf_pos==m_buf_size) {            waveOutPrepareHeader(m_hwo, &m_wh[m_buf_idx%m_ring_size], sizeof(WAVEHDR)) ;            waveOutWrite(m_hwo, &m_wh[m_buf_idx%m_ring_size], sizeof(WAVEHDR)) ;            if(m_playing) waveOutRestart(m_hwo);            m_buf_pos = 0;            m_buf_idx ++;            //waveOutUnprepareHeader(m_hwo, &m_wh[m_buf_idx%m_ring_size], sizeof(WAVEHDR));        }    }    ::WaitForSingleObject(m_mutex, INFINITE);    m_buf_rest -= len;    ::ReleaseMutex(m_mutex);    return 0;}

BOOL COutput::PrepareBuffer(){	CAutoLock lock(&m_csecBuff);	if (m_pHdr)		return FALSE;	m_cBuf = m_dwBufLen * m_pcm.wf.nAvgBytesPerSec / m_cbBuf / 1000 + 1;	if (m_cBuf < 2) m_cBuf = 2;	m_pHdr = new WAVEHDR[m_cBuf];	if (!m_pHdr)		return FALSE;	m_pbBuf = new BYTE[m_cBuf * m_cbBuf];	if (!m_pbBuf)		return FALSE;	memset(m_pbBuf, 0, m_cBuf * m_cbBuf);	for (UINT i = 0; i < m_cBuf; i++) {		memset(&m_pHdr[i], 0, sizeof(WAVEHDR));		m_pHdr[i].lpData = (LPSTR)m_pbBuf + (m_cbBuf * i);		m_pHdr[i].dwBufferLength = m_cbBuf;		if (m_fDoubleBuf)			m_pHdr[i].dwUser = 0;		else {			m_pHdr[i].dwUser = (DWORD)this;			waveOutPrepareHeader(m_hwo, &m_pHdr[i] , sizeof(WAVEHDR));		}	}	m_nCurrent = 0;	m_cWritten = 0;	m_hEvent = CreateEvent(NULL, TRUE, TRUE, NULL);	return TRUE;}

void playAudio(Audio *audio){   UINT devid;   	WAVEHDR* whdr = (WAVEHDR*)malloc(sizeof(WAVEHDR));	ZeroMemory((void*)whdr, sizeof(WAVEHDR));	whdr->lpData = audio->lpfile+HEADER_SIZE;	whdr->dwBufferLength = audio->file_size-HEADER_SIZE;	whdr->dwUser = (DWORD) audio->loop;	for(devid = 0; devid < waveOutGetNumDevs(); devid++)	{		if(devid == waveOutGetNumDevs()) {         audio->whdr = NULL;			return;      }		if(waveOutOpen(&(audio->hwo), WAVE_MAPPER, &(audio->wfex), (DWORD)WaveOutProc, 0, CALLBACK_FUNCTION) == MMSYSERR_NOERROR)			break;	}	if(waveOutPrepareHeader(audio->hwo, whdr, sizeof(WAVEHDR)) != MMSYSERR_NOERROR) {      audio->whdr = NULL;		return;   }	if(waveOutWrite(audio->hwo, whdr, sizeof(WAVEHDR)) != MMSYSERR_NOERROR) {      audio->whdr = NULL;		return;   }	audio->whdr = whdr;}

  MMAudioDevice::MMAudioDevice(HWAVEOUT device, int rate)    : MixerDevice(rate)  {    ADR_GUARD("MMAudioDevice::MMAudioDevice");    m_device = device;    m_current_buffer = 0;    // fill each buffer with samples and prepare it for output    for (int i = 0; i < BUFFER_COUNT; ++i) {      WAVEHDR& wh = m_buffers[i];      memset(&wh, 0, sizeof(wh));      wh.lpData         = (char*)m_samples + i * BUFFER_LENGTH;      wh.dwBufferLength = BUFFER_LENGTH;      read(BUFFER_LENGTH / 4, wh.lpData);      MMRESULT result = waveOutPrepareHeader(m_device, &wh, sizeof(wh));      if (result != MMSYSERR_NOERROR) {        ADR_LOG("waveOutPrepareHeader failed");      }      result = waveOutWrite(m_device, &wh, sizeof(wh));      if (result != MMSYSERR_NOERROR) {        ADR_LOG("waveOutWrite failed");      }    }  }

Error SoundCardPMO::Write(void *pBuffer, uint32 uSize){   Error    result = kError_NoErr;   WAVEHDR *wavhdr = NULL;   wavhdr = NextHeader();   if (!wavhdr)   {      return kError_Interrupt;   }   if (pBase == NULL)      pBase = (char *)pBuffer;         if ((((char *)pBuffer) + uSize)- pBase > m_pInputBuffer->GetBufferSize())   {      //Debug_v("Diff: %d Size: %u",       //    ((((char *)pBuffer) + uSize) - pBase), m_pInputBuffer->GetBufferSize());      assert(0);   }               wavhdr->dwBufferLength = uSize;   wavhdr->lpData = (char *)pBuffer;   // Prepare & write newest header   waveOutPrepareHeader(m_hwo, wavhdr, m_hdr_size);   waveOutWrite(m_hwo, wavhdr, m_hdr_size);   return result;}

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

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

void W95_PlayStart(MADDriverRec *WinMADDriver){	waveOutSetVolume(0,0xffffffff);		WinMADDriver->WaveOutHdr.lpData= (char*) WinMADDriver->mydata;	WinMADDriver->WaveOutHdr.dwBufferLength = WinMADDriver->WIN95BUFFERSIZE;	WinMADDriver->WaveOutHdr.dwFlags = WHDR_BEGINLOOP | WHDR_ENDLOOP;	WinMADDriver->WaveOutHdr.dwLoops = 0xffffffff;	WinMADDriver->WaveOutHdr.dwUser = 0;	waveOutPrepareHeader(WinMADDriver->hWaveOut, &WinMADDriver->WaveOutHdr, sizeof(WAVEHDR));	waveOutWrite(WinMADDriver->hWaveOut, &WinMADDriver->WaveOutHdr, sizeof(WAVEHDR));	WinMADDriver->mydma = (char*) WinMADDriver->mydata;		WinMADDriver->MICROBUFState = 0;		timeBeginPeriod(20);	/* set the minimum resolution */		WinMADDriver->gwID = timeSetEvent(40,								/* how often                 */									  40,								/* timer resolution          */									  TimeProc,							/* callback function         */									  (unsigned long)  WinMADDriver,	/* info to pass to callback  */									  TIME_PERIODIC);					/* oneshot or periodic?      */							  							  	//////}

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