static void
WINMM_CloseDevice(_THIS)
{
/* Close up audio */
if (this->hidden != NULL) {
int i;
if (this->hidden->audio_sem) {
CloseHandle(this->hidden->audio_sem);
this->hidden->audio_sem = 0;
}
/* Clean up mixing buffers */
for (i = 0; i < NUM_BUFFERS; ++i) {
if (this->hidden->wavebuf[i].dwUser != 0xFFFF) {
waveOutUnprepareHeader(this->hidden->hout,
&this->hidden->wavebuf[i],
sizeof(this->hidden->wavebuf[i]));
this->hidden->wavebuf[i].dwUser = 0xFFFF;
}
}
/* Free raw mixing buffer */
SDL_free(this->hidden->mixbuf);
this->hidden->mixbuf = NULL;
if (this->hidden->hin) {
waveInClose(this->hidden->hin);
this->hidden->hin = 0;
}
if (this->hidden->hout) {
waveOutClose(this->hidden->hout);
this->hidden->hout = 0;
}
SDL_free(this->hidden);
this->hidden = NULL;
}
}
/*
==============
WAVE_Shutdown
Reset the sound device for exiting
===============
*/
static void WAVE_Shutdown(void)
{
int i;
Com_Printf("Shutting down wave sound\n");
if (hWaveOut) {
Com_DPrintf("...resetting waveOut\n");
waveOutReset(hWaveOut);
if (lpWaveHdr) {
Com_DPrintf("...unpreparing headers\n");
for (i = 0; i < WAV_BUFFERS; i++)
waveOutUnprepareHeader(hWaveOut, lpWaveHdr + i, sizeof(WAVEHDR));
}
Com_DPrintf("...closing waveOut\n");
waveOutClose(hWaveOut);
if (hWaveHdr) {
Com_DPrintf("...freeing WAV header\n");
GlobalUnlock(hWaveHdr);
GlobalFree(hWaveHdr);
}
if (hData) {
Com_DPrintf("...freeing WAV buffer\n");
GlobalUnlock(hData);
GlobalFree(hData);
}
}
hWaveOut = 0;
hData = 0;
hWaveHdr = 0;
lpData = NULL;
lpWaveHdr = NULL;
wav_init = false;
}
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 ;
}
ms_message("Shutting down sound device (playing: %i) (d->write_rq.q_mcount=%i) (input-output: %i) (notplayed: %i)", d->nbufs_playing, d->write_rq.q_mcount, d->stat_input - d->stat_output, d->stat_notplayed);
flushq(&d->write_rq,0);
d->ready=0;
d->workaround=0;
#ifndef DISABLE_SPEEX
if (d->pst!=NULL)
speex_preprocess_state_destroy(d->pst);
d->pst=NULL;
d->pst_frame_size=0;
#endif
}
void Platform_Win32_Sound_SoundStream_WMM::Play()
{
if (playing_)
{
return;
}
for (int i=0; i<WaveBlockCount; i++)
{
if(waveBlocks_[i].dwFlags & WHDR_PREPARED)
{
waveOutUnprepareHeader(hWaveOut_, &waveBlocks_[i], sizeof(WAVEHDR));
}
int bytesToWrite=WaveBlockSize-(int)(waveBlocks_[i].dwUser);
int remainder=0;
if (soundPosition_+bytesToWrite>size_)
{
int roomLeft=size_-soundPosition_;
remainder=bytesToWrite-roomLeft;
bytesToWrite=roomLeft;
}
memcpy(waveBlocks_[i].lpData+waveBlocks_[i].dwUser, static_cast<char*>(soundBuffer_)+soundPosition_,bytesToWrite);
soundPosition_+=bytesToWrite;
soundPosition_%=size_;
if (remainder>0)
{
memcpy(waveBlocks_[i].lpData+waveBlocks_[i].dwUser+bytesToWrite, static_cast<char*>(soundBuffer_)+soundPosition_,remainder);
soundPosition_+=remainder;
soundPosition_%=size_;
}
waveBlocks_[i].dwBufferLength = WaveBlockSize;
waveOutPrepareHeader(hWaveOut_, &waveBlocks_[i], sizeof(WAVEHDR));
waveOutWrite(hWaveOut_, &waveBlocks_[i], sizeof(WAVEHDR));
EnterCriticalSection(&waveCriticalSection_);
firstUsedWaveBlock_=0;
LeaveCriticalSection(&waveCriticalSection_);
lastUsedWaveBlock_=WaveBlockCount-1;
}
playing_=true;
}
bool CWaveDevice::InternalClose()
//-------------------------------
{
MPT_TRACE();
if(m_hWaveOut)
{
waveOutReset(m_hWaveOut);
m_JustStarted = false;
InterlockedExchange(&m_nBuffersPending, 0);
m_nWriteBuffer = 0;
m_nDoneBuffer = 0;
while(m_nPreparedHeaders > 0)
{
m_nPreparedHeaders--;
waveOutUnprepareHeader(m_hWaveOut, &m_WaveBuffers[m_nPreparedHeaders], sizeof(WAVEHDR));
}
waveOutClose(m_hWaveOut);
m_hWaveOut = NULL;
}
#ifdef _DEBUG
if(m_DriverBugs.load())
{
SendDeviceMessage(LogError, MPT_USTRING("Errors were detected while playing sound:\n") + GetStatistics().text);
}
#endif
m_DriverBugs = 0;
m_Failed = false;
if(m_ThreadWakeupEvent)
{
CloseHandle(m_ThreadWakeupEvent);
m_ThreadWakeupEvent = NULL;
}
{
MPT_LOCK_GUARD<mpt::mutex> guard(m_PositionWraparoundMutex);
MemsetZero(m_PositionLast);
m_PositionWrappedCount = 0;
}
return true;
}
/*
* if any buffer is non-empty, send it out
* return success when all buffers have been returned empty
*/
int audio_flush(snd_type snd)
{
buffer_state *cur = (buffer_state *) snd->u.audio.descriptor;
int *index = &(cur->pollee);
LPWAVEHDR whdrs = cur->whdr;
int i = 0;
int test = 0;
int processed = 0;
int numbuf = cur->numofbuffers;
MMRESULT er;
if (snd->write_flag != SND_WRITE) return SND_SUCCESS;
if (cur->posinbuffer > 0) { /* flush final partial buffer of data */
cur->whdr[*index].dwBufferLength = cur->posinbuffer;
if (er = waveOutPrepareHeader(cur->u.h_out, &(cur->whdr[*index]), sizeof(WAVEHDR))) {
mm_error_handler(snd, er, snd_fail);
return !SND_SUCCESS;
}
if (er = waveOutWrite(cur->u.h_out, &(cur->whdr[*index]), sizeof(WAVEHDR))) {
waveOutUnprepareHeader(cur->u.h_out, &(cur->whdr[*index]), sizeof(WAVEHDR));
mm_error_handler(snd, er, snd_fail);
return !SND_SUCCESS;
}
cur->posinbuffer = 0;
if (++(*index) >= cur->numofbuffers){
*index = 0;
}
}
for (i = 0; i < numbuf; i++){
if (whdrs[i].dwFlags & WHDR_DONE) {
test++;
}
}
if (test < numbuf) return !SND_SUCCESS;
else return SND_SUCCESS;
}
void Close()
{
// Stop Thread
fprintf(stderr, "* SPU2-X: Waiting for waveOut thread to finish...");
waveout_running = false;
WaitForSingleObject(thread, INFINITE);
CloseHandle(thread);
fprintf(stderr, " Done.\n");
//
// Clean up
//
waveOutReset(hwodevice);
for (u32 i = 0; i < numBuffers; i++) {
waveOutUnprepareHeader(hwodevice, &whbuffer[i], sizeof(WAVEHDR));
}
waveOutClose(hwodevice);
safe_delete_array(qbuffer);
}
DWORD WINAPI thread_func(LPVOID lpParameter)
{
while (true)
{
// Try to unprepare header
if (waveOutUnprepareHeader(hWaveOut, &(header[nextPlayBlock]), sizeof(WAVEHDR))
!= WAVERR_STILLPLAYING)
{
#ifdef USEDSOUND
mzkPlayBlock(myMuzikBlock[nextPlayBlock]);
#endif
waveOutPrepareHeader(hWaveOut, &(header[nextPlayBlock]), sizeof(WAVEHDR));
waveOutWrite(hWaveOut, &(header[nextPlayBlock]), sizeof(WAVEHDR));
nextPlayBlock++;
if (nextPlayBlock >= NUM_PLAY_BLOCKS) nextPlayBlock = 0;
}
else
{
Sleep(1);
}
}
}
void SoundGen_Finalize()
{
if (!m_SoundGenInitialized)
return;
while (waveFreeBlockCount < BLOCK_COUNT)
Sleep(10);
for (int i = 0; i < waveFreeBlockCount; i++)
{
if (waveBlocks[i].dwFlags & WHDR_PREPARED)
waveOutUnprepareHeader(hWaveOut, &waveBlocks[i], sizeof(WAVEHDR));
}
DeleteCriticalSection(&waveCriticalSection);
waveOutClose(hWaveOut);
HeapFree(GetProcessHeap(), 0, waveBlocks);
waveBlocks = nullptr;
m_SoundGenInitialized = false;
}
void CALLBACK SoundGen_FeedDAC(unsigned short L, unsigned short R)
{
unsigned int word;
WAVEHDR* current;
if (!m_SoundGenInitialized)
return;
word = ((unsigned int)R << 16) + L;
memcpy(&buffer[bufcurpos], &word, 4);
bufcurpos += 4;
if (bufcurpos >= BUFSIZE)
{
current = &waveBlocks[waveCurrentBlock];
if (current->dwFlags & WHDR_PREPARED)
waveOutUnprepareHeader(hWaveOut, current, sizeof(WAVEHDR));
memcpy(current->lpData, buffer, BUFSIZE);
current->dwBufferLength = BLOCK_SIZE;
waveOutPrepareHeader(hWaveOut, current, sizeof(WAVEHDR));
waveOutWrite(hWaveOut, current, sizeof(WAVEHDR));
EnterCriticalSection(&waveCriticalSection);
waveFreeBlockCount--;
LeaveCriticalSection(&waveCriticalSection);
while (!waveFreeBlockCount)
Sleep(1);
waveCurrentBlock++;
if (waveCurrentBlock >= BLOCK_COUNT)
waveCurrentBlock = 0;
bufcurpos = 0;
}
}
DWORD CAudio::AudioThreadProc()
{
for (;;)
{
while (m_bContinue&&DataEmpty())
{
DebugPrint("空\n");
WaitForSingleObject(m_hNotEmptyEvent, 100);
}
if (m_bForce || !m_bContinue && DataEmpty())break;
DebugPrint("m_cWaveHdr:index:%u,flags:%u\n", m_dwWaveHdrIndex, m_cWaveHdr[m_dwWaveHdrIndex].dwFlags);
if (m_cWaveHdr[m_dwWaveHdrIndex].dwFlags & WHDR_PREPARED)
{
waveOutUnprepareHeader(m_hWaveOut, m_cWaveHdr + m_dwWaveHdrIndex, sizeof(WAVEHDR));
if (MAX_WAVE_DATA_COUNT == ++m_dwEnd)m_dwEnd = 0;
DebugPrint("减小:%u:%u:%u\n", m_dwStart, m_dwCur, m_dwEnd);
SetEvent(m_hNotFullEvent);
}
m_cWaveHdr[m_dwWaveHdrIndex].lpData = m_cData[m_dwCur].data;
m_cWaveHdr[m_dwWaveHdrIndex].dwBufferLength = (DWORD)m_cData[m_dwCur].len;
if (!m_bAudioStart)
{
m_bAudioStart = true;
SetEvent(m_hStartEvent);
while (!m_bVideoStart)
WaitForSingleObject(m_hStartEvent, 100);
}
waveOutPrepareHeader(m_hWaveOut, m_cWaveHdr + m_dwWaveHdrIndex, sizeof(WAVEHDR));
waveOutWrite(m_hWaveOut, m_cWaveHdr + m_dwWaveHdrIndex, sizeof(WAVEHDR));
if (MAX_WAVE_DATA_COUNT == ++m_dwCur)m_dwCur = 0;
DebugPrint("中间:%u:%u:%u\n", m_dwStart, m_dwCur, m_dwEnd);
if (MAX_WAVE_COUNT == ++m_dwWaveHdrIndex)m_dwWaveHdrIndex = 0;
InterlockedIncrement(&m_dwCount);
while (m_dwCount >= MAX_WAVE_COUNT)WaitForSingleObject(m_hDataEvent, INFINITE);
if (MAX_WAVE_COUNT - 1 != m_dwCount)DebugPrint("%u\n", m_dwCount);
}
while (m_dwCount)WaitForSingleObject(m_hDataEvent, INFINITE);
return 0;
}
static void WinMMStopPlayback(ALCdevice *device)
{
WinMMData *data = (WinMMData*)device->ExtraData;
void *buffer = NULL;
int i;
if(data->killNow)
return;
// Set flag to stop processing headers
data->killNow = AL_TRUE;
althrd_join(data->thread, &i);
// Release the wave buffers
for(i = 0; i < 4; i++)
{
waveOutUnprepareHeader(data->WaveHandle.Out, &data->WaveBuffer[i], sizeof(WAVEHDR));
if(i == 0) buffer = data->WaveBuffer[i].lpData;
data->WaveBuffer[i].lpData = NULL;
}
free(buffer);
}
void NativeSoundMix::CloseNativeDevice()
{
if ( !isOpen ) return;
SetEvent(playEvent); // signal the thread to quit
EnterCritical(); // do this after we kill the timer proc to prevent a deadlock
if ( !isOpen ) {
LeaveCritical();
return; // It is possible for timeKillEvent to call CloseDevice
}
isOpen = false;
HWAVEOUT hW = hWaveOut;
hWaveOut = 0; // flag that we are shutting down so PollSound will bail
int res = waveOutReset(hW);
FLASHASSERT(res == MMSYSERR_NOERROR);
for ( int i = 0; i < nBuffers; i++ ) {
int limit = 50;
while ( limit-- ) {
int res = waveOutUnprepareHeader(hW, waveHDR+i, sizeof(WAVEHDR));
if ( res != WAVERR_STILLPLAYING ) {
FLASHASSERT(res == MMSYSERR_NOERROR);
break;
}
Sleep(1);
}
}
res = waveOutClose(hW);
FLASHASSERT(res == MMSYSERR_NOERROR);
CloseHandle(playThread);
playThread = 0;
LeaveCritical();
}
static DWORD WINAPI waveProc(LPVOID arg) {
MSG msg;
WAVEHDR *pwh;
(void) arg;
while (GetMessage(&msg, 0, 0, 0)) {
switch (msg.message) {
case MM_WOM_DONE:
pwh = (WAVEHDR *)msg.lParam;
// Windows - Let go!
waveOutUnprepareHeader(ah, pwh, sizeof(WAVEHDR));
// Give the buffer back to the Audio Free List
gfxSystemLock();
gaudioPlayReleaseDataBlockI((GDataBuffer *)pwh->dwUser);
gfxSystemUnlock();
pwh->lpData = 0;
nQueuedBuffers--;
// Are we stopping?
if (!isRunning) {
// Have we finished yet?
if (!nQueuedBuffers) {
gfxSystemLock();
gaudioPlayDoneI();
gfxSystemUnlock();
}
break;
}
// Try and get a new block
senddata(pwh);
break;
}
}
return 0;
}
void destroyPlayback()
{
if(_device){
while(true){
bool done = true;
for(int i=0; i<BufferCount; i++){
if(_buffers[i].isUsed){
done = false;
}else{
if(_buffers[i].header.dwFlags & WHDR_PREPARED){
waveOutUnprepareHeader(_device, &_buffers[i].header, sizeof(WAVEHDR));
}
}
}
if(done){
break;
}else{
Sleep(10);
}
}
waveOutClose(_device);
}
}
DWORD CWaveBuffer::m_dwRelease()
{
DWORD dwErr = MMSYSERR_NOERROR;
if(m_hWaveOut != NULL)
{
if((dwErr = waveOutUnprepareHeader(m_hWaveOut, &m_header, sizeof(m_header))) == WAVERR_STILLPLAYING)
return dwErr;
m_hWaveOut = NULL;
}
if(m_hWaveIn != NULL)
{
if((dwErr = waveInUnprepareHeader(m_hWaveIn, &m_header, sizeof(m_header))) == WAVERR_STILLPLAYING)
return dwErr;
m_hWaveIn = NULL;
}
m_header.dwFlags |= WHDR_DONE;
return MMSYSERR_NOERROR;
}
MMRESULT CDeviceWaveIO::StopBuffers()
{
HWAVEOUT hwo = mhandle_out;
HWAVEIN hwi = mhandle_in;
MMRESULT mmres = MMSYSERR_NOERROR;
// Close device - release buffers
for (tint32 iStructIx = 0; iStructIx < miRunningStructs; iStructIx++) {
if (mbOutput) {
MMRESULT mmres1 = waveOutUnprepareHeader(hwo, &mawavehdrOutput[iStructIx], sizeof(WAVEHDR));
if (mmres == MMSYSERR_NOERROR)
mmres = mmres1;
}
if (mbInput) {
MMRESULT mmres2 = waveInUnprepareHeader(hwi, &mawavehdrInput[iStructIx], sizeof(WAVEHDR));
if (mmres == MMSYSERR_NOERROR)
mmres = mmres2;
}
}
return mmres;
} // StopBuffers
DWORD CAudioMgr_recv::AudioOutThreadProc(LPVOID lpParameter)
{
CAudioMgr_recv* pMgr = (CAudioMgr_recv*)lpParameter;
MSG msg;
while(GetMessage(&msg,0,0,0))
{
switch(msg.message)
{
case IOM_AUDIO:
pMgr->m_audioplay.Play((char*)msg.lParam,(int)msg.wParam);
break;
case WOM_DONE:
{
WAVEHDR* pwh=(WAVEHDR*)msg.lParam;
waveOutUnprepareHeader((HWAVEOUT)msg.wParam,pwh,sizeof(WAVEHDR));
delete []pwh->lpData;
delete pwh;
}
break;
}
}
return msg.wParam;
}
void CAudioWave::Shutdown( void )
{
int i;
/////////////////////////////////////////////////////////////////////////////////////////////
if (hWaveOut)
{
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);
}
}
hWaveOut = 0;
hData = 0;
hWaveHdr = 0;
lpData = NULL;
lpWaveHdr = NULL;
}
static
int wait(struct buffer *buffer)
{
MMRESULT error;
if (!buffer->playing)
return 0;
switch (WaitForSingleObject(buffer->event_handle, INFINITE)) {
case WAIT_OBJECT_0:
break;
case WAIT_ABANDONED:
audio_error = _("wait abandoned");
return -1;
case WAIT_TIMEOUT:
audio_error = _("wait timeout");
return -1;
case WAIT_FAILED:
default:
audio_error = _("wait failed");
return -1;
}
buffer->playing = 0;
error = waveOutUnprepareHeader(wave_handle, &buffer->wave_header,
sizeof(buffer->wave_header));
if (error != MMSYSERR_NOERROR) {
audio_error = error_text(error);
return -1;
}
return 0;
}
int Close() {
stopProcessing = true;
SetEvent(hEvent);
if (hThread != NULL) {
#ifdef ENABLE_DEBUG_OUTPUT
std::cout << "Waiting for rendering thread to die\n";
#endif
WaitForSingleObject(hThread, INFINITE);
hThread = NULL;
}
int wResult = waveOutReset(hWaveOut);
if (wResult != MMSYSERR_NOERROR) {
MessageBox(NULL, L"Failed to Reset WaveOut", L"MT32", MB_OK | MB_ICONEXCLAMATION);
return 8;
}
for (UINT i = 0; i < chunks; i++) {
wResult = waveOutUnprepareHeader(hWaveOut, &WaveHdr[i], sizeof(WAVEHDR));
if (wResult != MMSYSERR_NOERROR) {
MessageBox(NULL, L"Failed to Unprepare Wave Header", L"MT32", MB_OK | MB_ICONEXCLAMATION);
return 8;
}
}
delete[] WaveHdr;
WaveHdr = NULL;
wResult = waveOutClose(hWaveOut);
if (wResult != MMSYSERR_NOERROR) {
MessageBox(NULL, L"Failed to Close WaveOut", L"MT32", MB_OK | MB_ICONEXCLAMATION);
return 8;
}
if (hEvent != NULL) {
CloseHandle(hEvent);
hEvent = NULL;
}
return 0;
}
CAudio::~CAudio()
{
if (m_bIsWaveInUsed)
{
// waveInStop(m_hWaveIn);
waveInReset(m_hWaveIn);
for (int i = 0; i < AUDIOCAPBUF_NUM; 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 < AUDIOCAPBUF_NUM; i++)
waveOutUnprepareHeader(m_hWaveOut, m_lpInAudioHdr[i], sizeof(WAVEHDR));
waveOutClose(m_hWaveOut);
}
for (int i = 0; i < AUDIOCAPBUF_NUM; 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);
}
/**
* Wait until the buffer is finished.
*/
static bool
winmm_drain_buffer(struct winmm_output *wo, struct winmm_buffer *buffer,
GError **error_r)
{
if ((buffer->hdr.dwFlags & WHDR_DONE) == WHDR_DONE)
/* already finished */
return true;
while (true) {
MMRESULT result = waveOutUnprepareHeader(wo->handle,
&buffer->hdr,
sizeof(buffer->hdr));
if (result == MMSYSERR_NOERROR)
return true;
else if (result != WAVERR_STILLPLAYING) {
g_set_error(error_r, winmm_output_quark(), result,
"waveOutUnprepareHeader() failed");
return false;
}
/* wait some more */
WaitForSingleObject(wo->event, INFINITE);
}
}
/**
* win32ao_close()
* Terminate playback.
* This function blocks until all data that was written has been played.
* Return 0 if happy, -1 if error.
*/
int win32ao_close(void) {
MMRESULT res;
int i;
// commit possible partially filled buffer
if (commit(whoutBufNo))
return -1;
// unpause (no-op if already unpaused)
res = waveOutRestart(waveout);
if (checkWaveOutResult(waveout, res, "waveOutRestart"))
return -1;
// wait for buffers to finish and unprepare them all
for (i = 0; i < whoutBufCnt; ++i) {
while ((whout[i]->dwFlags & WHDR_INQUEUE) != 0) {
// buffer not ready, wait, try again
WaitForSingleObject(whoutEvent, INFINITE);
}
// unprepare the buffer
res = waveOutUnprepareHeader(waveout, whout[i], sizeof(WAVEHDR));
if (checkWaveOutResult(waveout, res, "waveOutUnprepareHeader"))
return -1;
// free memory
free(whout[i]->lpData);
free(whout[i]);
}
free(whout);
// close
res = waveOutClose(waveout);
if (checkWaveOutResult(waveout, res, "waveOutClose"))
return -1;
return 0;
}
void CSoundPlayer::Close()
{
if (NULL != soundObj.pWaveHdr && soundObj.initWaveHdr == 0x01)
{
MMRESULT mmhr;
for( unsigned int i=0; i<soundObj.waveHdrNum; i++ )
{
//if (soundObj.pWaveHdr[i].dwBufferLength < 1) continue;
soundObj.pWaveHdr[i].dwFlags = 0;
mmhr = waveOutUnprepareHeader( soundObj.hWaveOut, &soundObj.pWaveHdr[i], sizeof(WAVEHDR) );
soundObj.pWaveHdr[i].dwBufferLength = 0;
}
}
soundObj.initWaveHdr = 0x00;
if (NULL != soundObj.hWaveOut)
{
waveOutClose(soundObj.hWaveOut);
soundObj.hWaveOut = NULL;
}
//if( soundObj.hNotify ) CloseHandle( soundObj.hNotify );
//soundObj.hNotify = NULL;
}
void CSoundManager::Streaming()
{
// revisa si hay bloques pendientes que se terminaron:
for(int i=0;i<cant_bloques;++i)
{
if(waveOutUnprepareHeader(hWaveOut, bloques_pendientes[i], sizeof(WAVEHDR))
!=WAVERR_STILLPLAYING)
{
// ya termino de procesarse, (o dio un error, sea como sea: )
// libero la memoria
delete bloques_pendientes[i]->lpData;
delete bloques_pendientes[i];
// marco el bloque para borrar
bloques_pendientes[i] = NULL;
}
}
int ant_cant = cant_bloques;
// pack de bloques
cant_bloques = 0;
for(i=0;i<ant_cant;++i)
if(bloques_pendientes[i]!=NULL)
bloques_pendientes[cant_bloques++] = bloques_pendientes[i];
}
void pcm_close()
{
if (wout) {
waveOutReset(wout);
for (int i = 0; i < buffers; i++)
waveOutUnprepareHeader(wout, &hdr[i], sizeof WAVEHDR);
waveOutClose(wout);
wout = 0;
}
if (buf) {
free(buf);
buf = 0;
}
if (hdr) {
free(hdr);
hdr = 0;
}
if (semaph) {
CloseHandle(semaph);
semaph = 0;
}
memset(&pcm, 0, sizeof pcm);
}
static gboolean
gst_waveform_sink_unprepare (GstAudioSink * asink)
{
GstWaveFormSink *wfsink = GST_WAVEFORM_SINK (asink);
/* free wave buffers */
if (wfsink->wave_buffers) {
guint index;
for (index = 0; index < wfsink->buffer_count; index++) {
if (wfsink->wave_buffers[index].dwFlags & WHDR_PREPARED) {
MMRESULT mmresult =
waveOutUnprepareHeader (wfsink->hwaveout,
&wfsink->wave_buffers[index], sizeof (WAVEHDR));
if (mmresult != MMSYSERR_NOERROR) {
waveOutGetErrorText (mmresult, wfsink->error_string,
ERROR_LENGTH - 1);
GST_CAT_WARNING_OBJECT (waveformsink_debug, wfsink,
"gst_waveform_sink_unprepare: Error unpreparing buffer => %s",
wfsink->error_string);
}
}
g_free (wfsink->wave_buffers[index].lpData);
}
g_free (wfsink->wave_buffers);
wfsink->wave_buffers = NULL;
}
/* close waveform-audio output device */
if (wfsink->hwaveout) {
waveOutClose (wfsink->hwaveout);
wfsink->hwaveout = NULL;
}
return TRUE;
}
void playWaveSingleTime()
{
WAVEHDR whdr;
MMRESULT result;
whdr.lpData = pWave;
whdr.dwBufferLength = waveBufferLength;
whdr.dwFlags = WHDR_BEGINLOOP | WHDR_ENDLOOP;
whdr.dwLoops=1;
result = waveOutPrepareHeader(hWaveOut,&whdr,sizeof(WAVEHDR));
if(MMSYSERR_NOERROR !=result)
{
printf_s("Error:waveOutPrepareHeader! ErrorCode:%x",result);
goto freeandend;
}
result = waveOutWrite(hWaveOut,&whdr,sizeof(WAVEHDR));
if(MMSYSERR_NOERROR !=result)
{
printf_s("Error:waveOutWrite! ErrorCode:%x",result);
goto freeandend;
}
Sleep(waveLengthSecond*500);
freeandend:
result = waveOutReset(hWaveOut);
if(MMSYSERR_NOERROR !=result)
{
printf_s("Error:waveOutReset! ErrorCode:%x",result);
}
result = waveOutUnprepareHeader(hWaveOut,&whdr,sizeof(WAVEHDR));
if(MMSYSERR_NOERROR !=result)
{
printf_s("Error:waveOutUnprepareHeader! ErrorCode:%x",result);
}
free(pWave);
pWave = NULL;
}
void WinSound::fillNextBuffer(void) {
if (isStarted) {
isFilling = TRUE;
// check if the buffer is already prepared (should not !)
if (waveHeader[currentBuffer].dwFlags & WHDR_PREPARED)
waveOutUnprepareHeader(waveOut, &waveHeader[currentBuffer],
sizeof(WAVEHDR));
// Call the user function to fill the buffer
if (userCallback) {
userCallback(soundBuffer[currentBuffer], bufferSize);
}
// Prepare the buffer to be sent to the WaveOut API
waveHeader[currentBuffer].lpData = (char*) soundBuffer[currentBuffer];
waveHeader[currentBuffer].dwBufferLength = bufferSize;
waveOutPrepareHeader(waveOut, &waveHeader[currentBuffer], sizeof(WAVEHDR));
// Send the buffer the the WaveOut queue
waveOutWrite(waveOut, &waveHeader[currentBuffer], sizeof(WAVEHDR));
currentBuffer++;
if (currentBuffer >= WINSOUND_BUFFERCOUNT) {
currentBuffer = 0;
}
isFilling = FALSE;
}
}
