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 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;
}
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));
/* ·ÅÒô */
waveOutWrite(hWaveOut, &wavhdr, sizeof(WAVEHDR));
}
else
Sleep(1);
}
waveOutReset(hWaveOut);
waveOutClose(hWaveOut);
return 0;
}
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));
}
void writeAudioBlock(HWAVEOUT hWaveOut, LPSTR block, DWORD size)
{
WAVEHDR header;
/*
* initialise the block header with the size
* and pointer.
*/
ZeroMemory(&header, sizeof(WAVEHDR));
header.dwBufferLength = size;
header.lpData = block;
/*
* prepare the block for playback
*/
waveOutPrepareHeader(hWaveOut, &header, sizeof(WAVEHDR));
/*
* write the block to the device. waveOutWrite returns immediately
* unless a synchronous driver is used (not often).
*/
waveOutWrite(hWaveOut, &header, sizeof(WAVEHDR));
/*
* wait a while for the block to play then start trying
* to unprepare the header. this will fail until the block has
* played.
*/
Sleep(500);
while(waveOutUnprepareHeader(
hWaveOut,
&header,
sizeof(WAVEHDR)
) == WAVERR_STILLPLAYING)
Sleep(100);
}
bool MediaObject::prepareBuffers()
{
memset((void*)m_soundBuffer1.waveHeader, 0, sizeof(WAVEHDR));
m_soundBuffer1.waveHeader->lpData = m_soundBuffer1.data.data();
m_soundBuffer1.waveHeader->dwBufferLength = m_soundBuffer1.data.size();
m_soundBuffer1.waveHeader->dwUser = (DWORD_PTR) this;
ZeroMemory((void*)m_soundBuffer2.waveHeader, sizeof(WAVEHDR));
m_soundBuffer2.waveHeader->lpData = m_soundBuffer2.data.data();
m_soundBuffer2.waveHeader->dwBufferLength = m_soundBuffer1.data.size();
m_soundBuffer2.waveHeader->dwUser = (DWORD_PTR) this;
m_bufferPrepared = (waveOutPrepareHeader(m_hWaveOut, m_soundBuffer1.waveHeader, sizeof(WAVEHDR)) == MMSYSERR_NOERROR)
&& (waveOutPrepareHeader(m_hWaveOut, m_soundBuffer2.waveHeader, sizeof(WAVEHDR)) == MMSYSERR_NOERROR);
return m_bufferPrepared;
}
void play(double frequency, double volume, double duty)
{
if (m_unusedBlocks.empty()) return;
auto pBlock = m_unusedBlocks.front();
m_unusedBlocks.erase(m_unusedBlocks.begin());
m_usedBlocks.push_back(pBlock);
switch (m_type)
{
case Type::Pulse:
if (m_lastFrequency != frequency)
{
m_progress = 0.0;
m_lastFrequency = frequency;
}
break;
case Type::Triangle:
if (volume > 0.0)
{
volume = 1.0;
}
break;
}
fillData(pBlock, frequency, volume, duty);
waveOutPrepareHeader(m_hWaveOut, &pBlock->header, sizeof(WAVEHDR));
waveOutWrite(m_hWaveOut, &pBlock->header, sizeof(WAVEHDR));
}
//播放一块数据
BOOL CAudioPlay::Play(char *buf, UINT uSize)
{
BOOL bRet=FALSE;
char* p;
LPWAVEHDR pwh=new WAVEHDR;
if(!pwh)
goto RET;
p=new char[uSize];//重新分配一块内存(在播放结束后删除)
if(!p)
goto RET;
CopyMemory(p,buf,uSize);
ZeroMemory(pwh,sizeof(WAVEHDR));
pwh->dwBufferLength=uSize;
pwh->lpData=p;
//
m_mmr=waveOutPrepareHeader(m_hOut,pwh,sizeof(WAVEHDR));
if(m_mmr)
goto RET;
m_mmr=waveOutWrite(m_hOut,pwh,sizeof(WAVEHDR));
if(m_mmr)
goto RET;
bRet=TRUE;
RET:
return bRet;
}
/*****************************************************************************
* 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;
}
void
MMAudioDevice::update() {
ADR_GUARD("MMAudioDevice::update");
// if a buffer is done playing, add it to the queue again
for (int i = 0; i < BUFFER_COUNT; ++i) {
WAVEHDR& wh = m_buffers[i];
if (wh.dwFlags & WHDR_DONE) {
// unprepare
MMRESULT result = waveOutUnprepareHeader(m_device, &wh, sizeof(wh));
if (result != MMSYSERR_NOERROR) {
ADR_LOG("waveOutUnprepareHeader failed");
}
// fill with new samples
read(BUFFER_LENGTH / 4, wh.lpData);
wh.dwFlags = 0;
// prepare
result = waveOutPrepareHeader(m_device, &wh, sizeof(wh));
if (result != MMSYSERR_NOERROR) {
ADR_LOG("waveOutPrepareHeader failed");
}
// write
result = waveOutWrite(m_device, &wh, sizeof(wh));
if (result != MMSYSERR_NOERROR) {
ADR_LOG("waveOutWrite failed");
}
}
}
Sleep(10);
}
static ALCboolean ALCwinmmPlayback_start(ALCwinmmPlayback *self)
{
ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
ALbyte *BufferData;
ALint BufferSize;
ALuint i;
ATOMIC_STORE(&self->killNow, AL_FALSE, almemory_order_release);
if(althrd_create(&self->thread, ALCwinmmPlayback_mixerProc, self) != althrd_success)
return ALC_FALSE;
InitRef(&self->WaveBuffersCommitted, 0);
// Create 4 Buffers
BufferSize = device->UpdateSize*device->NumUpdates / 4;
BufferSize *= FrameSizeFromDevFmt(device->FmtChans, device->FmtType, device->AmbiOrder);
BufferData = calloc(4, BufferSize);
for(i = 0;i < 4;i++)
{
memset(&self->WaveBuffer[i], 0, sizeof(WAVEHDR));
self->WaveBuffer[i].dwBufferLength = BufferSize;
self->WaveBuffer[i].lpData = ((i==0) ? (CHAR*)BufferData :
(self->WaveBuffer[i-1].lpData +
self->WaveBuffer[i-1].dwBufferLength));
waveOutPrepareHeader(self->OutHdl, &self->WaveBuffer[i], sizeof(WAVEHDR));
waveOutWrite(self->OutHdl, &self->WaveBuffer[i], sizeof(WAVEHDR));
IncrementRef(&self->WaveBuffersCommitted);
}
return ALC_TRUE;
}
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;
}
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));
}
}
}
int
writePcmData (PcmDevice *pcm, const unsigned char *buffer, int count) {
MMRESULT mmres;
void *newBuf;
if (!count) return 1;
if (count > pcm->bufSize) {
if (!(unprepareHeader(pcm))) return 0;
if (!(newBuf = realloc(pcm->waveHdr.lpData, 2 * count))) {
logSystemError("allocating PCM data buffer");
return 0;
}
pcm->waveHdr.lpData = newBuf;
pcm->waveHdr.dwFlags = 0;
pcm->waveHdr.dwBufferLength = pcm->bufSize = 2 * count;
}
awaitPcmOutput(pcm);
if (!(pcm->waveHdr.dwFlags & WHDR_PREPARED))
if ((mmres = waveOutPrepareHeader(pcm->handle, &pcm->waveHdr, sizeof(pcm->waveHdr))) != MMSYSERR_NOERROR) {
LogWaveOutError(mmres, LOG_ERR, "preparing PCM data header");
return 0;
}
pcm->waveHdr.dwBufferLength = count;
memcpy(pcm->waveHdr.lpData, buffer, count);
ResetEvent(pcm->done);
if ((mmres = waveOutWrite(pcm->handle, &pcm->waveHdr, sizeof(pcm->waveHdr))) != MMSYSERR_NOERROR) {
SetEvent(pcm->done);
LogWaveOutError(mmres, LOG_ERR, "writing PCM data");
return 0;
}
return 1;
}
bool CAudio::InitializeWaveOut()
{
if (!waveOutGetNumDevs())
return false;
for (int i = 0; i < 2; i++)
memset(m_lpOutAudioData[i], 0, m_nBufferLength);
MMRESULT mmResult;
mmResult = waveOutOpen(&m_hWaveOut, (WORD)WAVE_MAPPER, &(m_GSMWavefmt.wfx), (LONG)0, (LONG)0, CALLBACK_NULL);
if (mmResult != MMSYSERR_NOERROR)
return false;
for (int i = 0; i < 2; i++)
{
m_lpOutAudioHdr[i]->lpData = (LPSTR)m_lpOutAudioData[i];
m_lpOutAudioHdr[i]->dwBufferLength = m_nBufferLength;
m_lpOutAudioHdr[i]->dwFlags = 0;
m_lpOutAudioHdr[i]->dwLoops = 0;
waveOutPrepareHeader(m_hWaveOut, m_lpOutAudioHdr[i], sizeof(WAVEHDR));
}
m_bIsWaveOutUsed = true;
return true;
}
static ALCboolean WinMMStartPlayback(ALCdevice *device)
{
WinMMData *data = (WinMMData*)device->ExtraData;
ALbyte *BufferData;
ALint BufferSize;
ALuint i;
data->killNow = AL_FALSE;
if(althrd_create(&data->thread, PlaybackThreadProc, device) != althrd_success)
return ALC_FALSE;
InitRef(&data->WaveBuffersCommitted, 0);
// Create 4 Buffers
BufferSize = device->UpdateSize*device->NumUpdates / 4;
BufferSize *= FrameSizeFromDevFmt(device->FmtChans, device->FmtType);
BufferData = calloc(4, BufferSize);
for(i = 0; i < 4; i++)
{
memset(&data->WaveBuffer[i], 0, sizeof(WAVEHDR));
data->WaveBuffer[i].dwBufferLength = BufferSize;
data->WaveBuffer[i].lpData = ((i==0) ? (CHAR*)BufferData :
(data->WaveBuffer[i-1].lpData +
data->WaveBuffer[i-1].dwBufferLength));
waveOutPrepareHeader(data->WaveHandle.Out, &data->WaveBuffer[i], sizeof(WAVEHDR));
waveOutWrite(data->WaveHandle.Out, &data->WaveBuffer[i], sizeof(WAVEHDR));
IncrementRef(&data->WaveBuffersCommitted);
}
return ALC_TRUE;
}
static void nt_resyncaudio(void)
{
UINT mmresult;
int nad, nda, count;
if (nt_resync_cancelled)
return;
/* for each open input device, eat all buffers which are marked
ready. The next one will thus be "busy". */
post("resyncing audio");
for (nad = 0; nad < nt_nwavein; nad++)
{
int phase = ntsnd_inphase[nad];
for (count = 0; count < MAXRESYNC; count++)
{
WAVEHDR *inwavehdr = ntsnd_invec[nad][phase].lpWaveHdr;
if (!(inwavehdr->dwFlags & WHDR_DONE)) break;
if (inwavehdr->dwFlags & WHDR_PREPARED)
waveInUnprepareHeader(ntsnd_indev[nad],
inwavehdr, sizeof(WAVEHDR));
inwavehdr->dwFlags = 0L;
waveInPrepareHeader(ntsnd_indev[nad], inwavehdr, sizeof(WAVEHDR));
mmresult = waveInAddBuffer(ntsnd_indev[nad], inwavehdr,
sizeof(WAVEHDR));
if (mmresult != MMSYSERR_NOERROR)
nt_waveinerror("waveInAddBuffer: %s\n", mmresult);
ntsnd_inphase[nad] = phase = WRAPFWD(phase + 1);
}
if (count == MAXRESYNC) post("resync error 1");
}
/* Each output buffer which is "ready" is filled with zeros and
queued. */
for (nda = 0; nda < nt_nwaveout; nda++)
{
int phase = ntsnd_outphase[nda];
for (count = 0; count < MAXRESYNC; count++)
{
WAVEHDR *outwavehdr = ntsnd_outvec[nda][phase].lpWaveHdr;
if (!(outwavehdr->dwFlags & WHDR_DONE)) break;
if (outwavehdr->dwFlags & WHDR_PREPARED)
waveOutUnprepareHeader(ntsnd_outdev[nda],
outwavehdr, sizeof(WAVEHDR));
outwavehdr->dwFlags = 0L;
memset((char *)(ntsnd_outvec[nda][phase].lpData),
0, (CHANNELS_PER_DEVICE * SAMPSIZE * nt_realdacblksize));
waveOutPrepareHeader(ntsnd_outdev[nda], outwavehdr,
sizeof(WAVEHDR));
mmresult = waveOutWrite(ntsnd_outdev[nda], outwavehdr,
sizeof(WAVEHDR));
if (mmresult != MMSYSERR_NOERROR)
nt_waveouterror("waveOutAddBuffer: %s\n", mmresult);
ntsnd_outphase[nda] = phase = WRAPFWD(phase + 1);
}
if (count == MAXRESYNC) post("resync error 2");
}
#ifdef MIDI_TIMESTAMP
nt_resetmidisync();
#endif
}
static bool_t senddata(WAVEHDR *pwh) {
GDataBuffer *paud;
// Get the next data block to send
gfxSystemLock();
paud = gaudioPlayGetDataBlockI();
if (!paud && !nQueuedBuffers)
gaudioPlayDoneI();
gfxSystemUnlock();
if (!paud)
return FALSE;
// Prepare the wave header for Windows
pwh->dwUser = (DWORD_PTR)paud;
pwh->lpData = (LPSTR)(paud+1); // The data is on the end of the structure
pwh->dwBufferLength = paud->len;
pwh->dwFlags = 0;
pwh->dwLoops = 0;
if (waveOutPrepareHeader(ah, pwh, sizeof(WAVEHDR))) {
fprintf(stderr, "GAUDIO: Failed to prepare a play buffer");
exit(-1);
}
// Send it to windows
if (waveOutWrite(ah, pwh, sizeof(WAVEHDR))) {
fprintf(stderr, "GAUDIO: Failed to write the play buffer");
exit(-1);
}
nQueuedBuffers++;
return TRUE;
}
static
int write_dev(HWAVEOUT handle, struct buffer *buffer)
{
MMRESULT error;
buffer->wave_header.lpData = buffer->pcm_data;
buffer->wave_header.dwBufferLength = buffer->pcm_length;
buffer->wave_header.dwUser = (DWORD) buffer;
buffer->wave_header.dwFlags = 0;
error = waveOutPrepareHeader(handle, &buffer->wave_header,
sizeof(buffer->wave_header));
if (error != MMSYSERR_NOERROR) {
audio_error = error_text(error);
return -1;
}
error = waveOutWrite(handle, &buffer->wave_header,
sizeof(buffer->wave_header));
if (error != MMSYSERR_NOERROR) {
audio_error = error_text(error);
return -1;
}
buffer->playing = 1;
return 0;
}
