本文整理汇总了C++中waveOutPrepareHeader函数的典型用法代码示例。如果您正苦于以下问题:C++ waveOutPrepareHeader函数的具体用法?C++ waveOutPrepareHeader怎么用?C++ waveOutPrepareHeader使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了waveOutPrepareHeader函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: wodPrepare
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;
}
示例2: HTS106_Audio_open
/* 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");
}
示例3: memcpy
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);
}
}
示例4: winmm_set_buffer
/**
* Copy data into a buffer, and prepare the wave header.
*/
static bool
winmm_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;
}
示例5: waveOutSetVolume
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;
}
示例6: lock
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;
}
示例7: playAudio
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;
}
示例8: MixerDevice
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");
}
}
}
示例9: NextHeader
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;
}
示例10: win32_audio_play
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);
}
示例11: memset
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");
}
}
示例12: audio_write_wince
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;
}
示例13: W95_PlayStart
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? */
//////
}
示例14: waveOutOpen
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));
/* ·ÅÒô */
waveOutWrite(hWaveOut, &wavhdr, sizeof(WAVEHDR));
}
else
Sleep(1);
}
waveOutReset(hWaveOut);
waveOutClose(hWaveOut);
return 0;
}
示例15: WaitForMultipleObjects
void WaveOutDevice::writeSamples(const void *data, size_t length,
size_t nsamples)
{
void *bp = const_cast<void *>(data);
if (m_asbd.mBitsPerChannel <= 8) {
util::convert_sign(static_cast<uint32_t *>(bp),
nsamples * m_asbd.mChannelsPerFrame);
}
unsigned obpc = m_asbd.mBytesPerFrame / m_asbd.mChannelsPerFrame;
unsigned nbpc = ((m_asbd.mBitsPerChannel + 7) & ~7) >> 3;
util::pack(bp, &length, obpc, nbpc);
size_t pos = m_ibuffer.size();
m_ibuffer.resize(pos + length);
std::memcpy(&m_ibuffer[pos], bp, length);
if (m_ibuffer.size() < m_asbd.mSampleRate / NUMBUFFERS)
return;
DWORD n = WaitForMultipleObjects(util::sizeof_array(m_events), m_events,
0, INFINITE);
n -= WAIT_OBJECT_0;
ResetEvent(m_events[n]);
WAVEHDR& wh = m_packets[n];
TRYMM(waveOutUnprepareHeader(m_device.get(), &wh, sizeof wh));
m_buffers[n] = m_ibuffer;
m_ibuffer.clear();
wh.lpData = &m_buffers[n][0];
wh.dwBufferLength = m_buffers[n].size();
TRYMM(waveOutPrepareHeader(m_device.get(), &wh, sizeof wh));
TRYMM(waveOutWrite(m_device.get(), &wh, sizeof wh));
}