bool __stdcall AudioStop1()
{
waveOutReset(m_hWaveOut1);//停止输出
waveOutClose(m_hWaveOut1);//关闭设备
return true;
}
bool CWavePlay::CloseDevice()
{
ZeroMemory(&m_wavformex,sizeof(WAVEFORMATEX));
while(_nWaveFreeBlockCount != 0 && _nWaveFreeBlockCount < BLOCK_COUNT)
Sleep(10);
/*
* unprepare any blocks that are still prepared
*/
for(int i = 0; i < _nWaveFreeBlockCount; i++)
{
if(_waveBlocks && _waveBlocks[i].dwFlags & WHDR_PREPARED)
{
waveOutUnprepareHeader(m_hWaveOut, &_waveBlocks[i], sizeof(WAVEHDR));
}
}
if(_waveBlocks)
{
freeBlocks(_waveBlocks);
_waveBlocks = NULL;
}
waveOutClose(m_hWaveOut);
m_bPalyState = false;
return true;
}
/* HTS_Audio_close: close audio device */
void HTS_Audio_close(HTS_Audio * as)
{
MMRESULT error;
if (as->buff_size != 0)
HTS_Audio_write_buffer(as);
while (as->now_buff_1 == TRUE)
Sleep(AUDIO_WAIT_BUFF_MS);
while (as->now_buff_2 == TRUE)
Sleep(AUDIO_WAIT_BUFF_MS);
/* stop audio */
error = waveOutReset(as->hwaveout);
if (error != MMSYSERR_NOERROR)
HTS_error(0,
"hts_engine: Cannot stop and reset your output audio device.\n");
/* unprepare */
error = waveOutUnprepareHeader(as->hwaveout, &(as->buff_1), sizeof(WAVEHDR));
if (error != MMSYSERR_NOERROR)
HTS_error(0,
"hts_engine: Cannot cleanup the audio datablocks to play waveform.\n");
error = waveOutUnprepareHeader(as->hwaveout, &(as->buff_2), sizeof(WAVEHDR));
if (error != MMSYSERR_NOERROR)
HTS_error(0,
"hts_engine: Cannot cleanup the audio datablocks to play waveform.\n");
/* close */
error = waveOutClose(as->hwaveout);
if (error != MMSYSERR_NOERROR)
HTS_error(0, "hts_engine: Failed to close your output audio device.\n");
HTS_free(as->buff_1.lpData);
HTS_free(as->buff_2.lpData);
HTS_free(as->buff);
}
int
WIN_Audio_close ( void )
{
if ( dev != NULL )
{
while ( ScheduledBlocks > 0 ) {
Sleep (ScheduledBlocks);
while ( PlayedWaveHeadersCount > 0 ) // free used blocks ...
free_memory ();
}
waveOutReset (dev); // reset the device
waveOutClose (dev); // close the device
dev = NULL;
}
DeleteCriticalSection ( &cs );
ScheduledBlocks = 0;
if (!g_bEnd)
{
g_hDuoduoWnd = FindWindow(NULL,"多多卖家版");
if (g_hDuoduoWnd)
{
PostMessage(g_hDuoduoWnd,g_sPlayFinished,NULL,NULL);
}else
{
//Box( "Can't find window named 多多卖家版" );
}
}
return 0;
}
static void winMMCleanup(Soloud *aSoloud)
{
if (0 == aSoloud->mBackendData)
{
return;
}
SoLoudWinMMData *data = static_cast<SoLoudWinMMData*>(aSoloud->mBackendData);
SetEvent(data->audioProcessingDoneEvent);
SetEvent(data->bufferEndEvent);
Thread::wait(data->threadHandle);
Thread::release(data->threadHandle);
CloseHandle(data->audioProcessingDoneEvent);
CloseHandle(data->bufferEndEvent);
waveOutReset(data->waveOut);
for (int i=0;i<BUFFER_COUNT;++i)
{
waveOutUnprepareHeader(data->waveOut, &data->header[i], sizeof(WAVEHDR));
if (0 != data->sampleBuffer[i])
{
delete[] data->sampleBuffer[i];
}
}
if (0 != data->buffer)
{
delete[] data->buffer;
}
waveOutClose(data->waveOut);
Thread::destroyMutex(data->soloud->mMutex);
data->soloud->mMutex = 0;
data->soloud->mLockMutexFunc = 0;
data->soloud->mUnlockMutexFunc = 0;
delete data;
aSoloud->mBackendData = 0;
}
char testNoCallback(float seconds, float frequency)
{
MMRESULT result;
HWAVEOUT waveOut;
result = waveOutOpen(&waveOut,
WAVE_MAPPER,
&waveFormat,
0,
0,
CALLBACK_NULL);
if(result != MMSYSERR_NOERROR) {
printf("waveOutOpen failed (result=%d)\n", result);
return 1;
}
printf("Opened Wave Mapper!\n");
fflush(stdout);
DWORD sampleCount = seconds * waveFormat.nSamplesPerSec;
LPSTR block = allocateBlock(sampleCount);
fillSinWave(block, frequency, sampleCount);
printf("Writing block...\n");
fflush(stdout);
writeAudioBlock(waveOut, block, sampleCount * waveFormat.nBlockAlign);
waveOutClose(waveOut);
return 0;
}
audioStreamer_waveOut::~audioStreamer_waveOut()
{
int x;
if (m_hwo) waveOutReset(m_hwo);
if (m_hwi) waveInReset(m_hwi);
for (x = 0; x < m_bufs.GetSize(); x ++)
{
WAVEHDR *p = (WAVEHDR *)m_bufs.Get(x)->Get();
if (m_hwi && p)
if (p->dwFlags & WHDR_PREPARED) waveInUnprepareHeader(m_hwi,p,sizeof(WAVEHDR));
if (m_hwo && p)
{
if (p->dwFlags & WHDR_PREPARED) waveOutUnprepareHeader(m_hwo,p,sizeof(WAVEHDR));
}
delete m_bufs.Get(x);
}
m_bufs.Empty();
if (m_hwo)
{
waveOutClose(m_hwo);
m_hwo=0;
}
if (m_hwi)
{
waveInClose(m_hwi);
m_hwi=0;
}
}
void mmio_close_audio( void)
{
int errcode;
int nda, nad;
if (sys_verbose)
post("closing audio...");
for (nda=0; nda < nt_nwaveout; nda++) /*if (nt_nwaveout) wini */
{
errcode = waveOutReset(ntsnd_outdev[nda]);
if (errcode != MMSYSERR_NOERROR)
printf("error resetting output %d: %d\n", nda, errcode);
errcode = waveOutClose(ntsnd_outdev[nda]);
if (errcode != MMSYSERR_NOERROR)
printf("error closing output %d: %d\n",nda , errcode);
}
nt_nwaveout = 0;
for(nad=0; nad < nt_nwavein;nad++) /* if (nt_nwavein) wini */
{
errcode = waveInReset(ntsnd_indev[nad]);
if (errcode != MMSYSERR_NOERROR)
printf("error resetting input: %d\n", errcode);
errcode = waveInClose(ntsnd_indev[nad]);
if (errcode != MMSYSERR_NOERROR)
printf("error closing input: %d\n", errcode);
}
nt_nwavein = 0;
}
// ----------------
// DestroyRunObject
// ----------------
// Destroys the run-time object
//
short WINAPI DLLExport DestroyRunObject(LPRDATA rdPtr, long fast)
{
/* Immediately stop playback because the buffers will be gone soon */
waveOutPause(rdPtr->device);
/* Tell thread to stop */
rdPtr->shuttingDown = true;
/* Wait for thread to finish */
WaitForSingleObject(rdPtr->thread, INFINITE);
CloseHandle(rdPtr->thread);
/* Free all buffers */
for(int i = 0; i < NUM_BUFFERS; ++i)
{
waveOutUnprepareHeader(rdPtr->device, &rdPtr->buffers[i], sizeof(WAVEHDR));
delete[] rdPtr->buffers[i].lpData;
}
/* Close audio device */
waveOutClose(rdPtr->device);
/* Good bye! */
delete rdPtr->rRd;
return 0;
}
int native_midi_detect()
{
MMRESULT merr;
HWAVEOUT MidiStream;
memset(&wfm,0,sizeof(wfm));
wfm.wfx.wFormatTag=WAVE_FORMAT_MIDI;
wfm.wfx.nChannels=1;
wfm.wfx.nSamplesPerSec=32;
wfm.wfx.nAvgBytesPerSec=32;
wfm.wfx.nBlockAlign=sizeof(WAVEFORMAT_MIDI_MESSAGE);
wfm.wfx.wBitsPerSample=16;
wfm.wfx.cbSize=WAVEFORMAT_MIDI_EXTRASIZE;
//wfm.USecPerQuarterNote=9600000; // Force each tick to be 1/10 sec
//wfm.TicksPerQuarterNote = 96;
merr = waveOutOpen(&MidiStream, WAVE_MAPPER, (LPWAVEFORMATEX)&wfm, (DWORD)MidiProc, 0, CALLBACK_FUNCTION);
if (merr!=MMSYSERR_NOERROR)
MidiStream=0;
waveOutClose(MidiStream);
if (!MidiStream)
return 0;
else
return 1;
}
CAudio::~CAudio()
{
if (m_bIsWaveInUsed)
{
waveInStop(m_hWaveIn);
waveInReset(m_hWaveIn);
for (int i = 0; i < 2; 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 < 2; i++)
waveOutUnprepareHeader(m_hWaveOut, m_lpInAudioHdr[i], sizeof(WAVEHDR));
waveOutClose(m_hWaveOut);
}
for (int i = 0; i < 2; 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);
}
///////////////////////////////////////////////////////////////////////////////
// Close device
void CWaveOut::Stop(void)
{int i;
// are we started ?
if (m_Dev != NULL) return;
// remove all blocks from queue
waveOutReset(m_Dev);
// free output blocks
if (m_B != NULL)
{for (i = 0; i < m_nBlock; i++)
{// if block is prepared, unprepare it
if ((m_B[i].dwFlags & WHDR_PREPARED) == WHDR_PREPARED)
waveOutUnprepareHeader(m_Dev, m_B+i, sizeof(m_B[i]));
// if block has data, free it
if (m_B[i].lpData != NULL) ippsFree(m_B[i].lpData);
}
// free array
ippsFree(m_B);
m_B = NULL;
}
// close device
waveOutClose(m_Dev);
m_Dev = NULL;
}
BOOL CMixOut::OpenMixer()
{
m_iDevNum = mixerGetNumDevs();
if (m_iDevNum == 0)
{
TRACE("There (is) are no device mixer.\n");
return FALSE;
}
WAVEFORMATEX wfx;
memset( &wfx, 0, sizeof(WAVEFORMATEX) );
wfx.wFormatTag = WAVE_FORMAT_PCM;
wfx.nChannels = 1;
wfx.nSamplesPerSec = 8000;
wfx.nAvgBytesPerSec = 1 * 8000 * 16 / 8;
wfx.nBlockAlign = 16 * 1 / 8;
wfx.wBitsPerSample = 16;
wfx.cbSize = 0;
HWAVEOUT hwaveOut;
m_mmr = waveOutOpen( &hwaveOut, WAVE_MAPPER, &wfx, 0L, 0L, CALLBACK_NULL );
if ( m_mmr != MMSYSERR_NOERROR )
{
return false;
}
else
{
m_mmr = mixerGetID( (HMIXEROBJ)hwaveOut, &m_uiMixerId, MIXER_OBJECTF_HWAVEOUT );
waveOutClose( hwaveOut );
if (m_mmr != MMSYSERR_NOERROR )
{
return false;
}
}
WNDCLASSEX wcx;
memset( &wcx, 0, sizeof(WNDCLASSEX) );
wcx.cbSize = sizeof(WNDCLASSEX);
wcx.lpszClassName = WND_CLASS_NAME;
wcx.lpfnWndProc = (WNDPROC)MixerWndProc;
::RegisterClassEx(&wcx);
m_hWnd = CreateWindow( WND_CLASS_NAME,
WND_NAME,
WS_POPUP | WS_DISABLED,
0, 0, 0, 0,
NULL, NULL, NULL, NULL );
if ( !m_hWnd )
{
return false;
}
::ShowWindow(m_hWnd, SW_HIDE);
m_mmr = mixerOpen( (LPHMIXER)&m_hMixer, m_uiMixerId, (DWORD)m_hWnd, 0L, CALLBACK_WINDOW );
if (m_mmr != MMSYSERR_NOERROR )
{
::DestroyWindow( m_hWnd );
return false;
}
return true;
}
FRBC2CI_API int SoundDev_DeInit()
{
int i;
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);
}
return(0);
}
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 ;
}
d->ready=0;
d->workaround=0;
}
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;
}
int audio_close_wince(cst_audiodev *ad)
{
au_wince_pdata *pd = ad->platform_data;
MMRESULT err;
if (ad)
{
/* Okay, I actually think this isn't a race, because
bcnt is only ever decremented asynchronously, and
the asynchronous callback can't be interrupted. So
the only issue is whether it hits zero between the
time we test it and the time we start waiting, and
in this case, the event will get set anyway. */
if (pd->bcnt > 0)
WaitForSingleObject(pd->bevt, INFINITE);
pd->in_reset = 1;
err = waveOutReset(pd->wo);
if (err != MMSYSERR_NOERROR)
{
cst_errmsg("Failed to reset output device: %x\n", err);
cst_error();
}
pd->in_reset = 0;
free_queue_empty(ad);
err = waveOutClose(pd->wo);
if (err != MMSYSERR_NOERROR)
{
cst_errmsg("Failed to close output device: %x\n", err);
cst_error();
}
cst_free(pd);
cst_free(ad);
}
return 0;
}
/* HTS_Audio_close: close audio device */
static void HTS_Audio_close(HTS_Audio * audio)
{
MMRESULT error;
if (audio->max_buff_size <= 0)
return;
/* stop audio */
error = waveOutReset(audio->hwaveout);
if (error != MMSYSERR_NOERROR)
HTS_error(0, "hts_engine: Cannot stop and reset your output audio device.\n");
/* unprepare */
error = waveOutUnprepareHeader(audio->hwaveout, &(audio->buff_1), sizeof(WAVEHDR));
if (error != MMSYSERR_NOERROR)
HTS_error(0, "hts_engine: Cannot cleanup the audio datablocks to play waveform.\n");
error = waveOutUnprepareHeader(audio->hwaveout, &(audio->buff_2), sizeof(WAVEHDR));
if (error != MMSYSERR_NOERROR)
HTS_error(0, "hts_engine: Cannot cleanup the audio datablocks to play waveform.\n");
/* close */
error = waveOutClose(audio->hwaveout);
if (error != MMSYSERR_NOERROR)
HTS_error(0, "hts_engine: Failed to close your output audio device.\n");
HTS_free(audio->buff_1.lpData);
HTS_free(audio->buff_2.lpData);
HTS_free(audio->buff);
}
RageSoundDriver_WaveOut::~RageSoundDriver_WaveOut()
{
/* Signal the mixing thread to quit. */
if( MixingThread.IsCreated() )
{
m_bShutdown = true;
SetEvent( m_hSoundEvent );
LOG->Trace( "Shutting down mixer thread ..." );
MixingThread.Wait();
LOG->Trace( "Mixer thread shut down." );
}
if( m_hWaveOut != NULL )
{
for( int b = 0; b < num_chunks && m_aBuffers[b].lpData != NULL; ++b )
{
waveOutUnprepareHeader( m_hWaveOut, &m_aBuffers[b], sizeof(m_aBuffers[b]) );
delete [] m_aBuffers[b].lpData;
}
waveOutClose( m_hWaveOut );
}
CloseHandle( m_hSoundEvent );
}
uint8_t win32AudioDevice::stop(void)
{
if (!_inUse)
return 0;
printf("[Win32] Closing audio\n");
waveOutReset(myDevice);
for (uint32_t i = 0; i < NB_BUCKET; i++)
waveOutUnprepareHeader(myDevice, &waveHdr[i], sizeof(WAVEHDR));
myError = waveOutClose(myDevice);
if (myError != MMSYSERR_NOERROR)
{
printf("[Win32] Close failed %d\n", myError);
handleMM(myError);
return 0;
}
for (uint32_t i = 0; i < NB_BUCKET; i++)
delete[] waveHdr[i].lpData;
_inUse=0;
myDevice = NULL;
return 1;
}
HnAudio *hn_win32_audio_open(HnAudioFormat *pFormat)
{
HnAudio_Win32 *pImpl =
(HnAudio_Win32 *)calloc(1, sizeof(HnAudio_Win32));
MMRESULT result = MMSYSERR_NOERROR;
WAVEFORMATEX wfex;
build_wfex(&wfex,
pFormat->samplesPerSecond,
pFormat->sampleResolution,
pFormat->numberOfChannels);
result = check_signedness(pFormat);
if (MMSYSERR_NOERROR != result) goto Done;
result = waveOutOpen(&(pImpl->hwo), 0, &wfex, (DWORD_PTR)wave_out_proc,
(DWORD_PTR)pImpl, CALLBACK_FUNCTION);
if (MMSYSERR_NOERROR != result) goto Done;
pImpl->pVtbl = &_HnAudio_Win32_vtbl;
Done:
if (MMSYSERR_NOERROR != result)
{
waveOutClose(pImpl->hwo);
free(pImpl);
pImpl = NULL;
}
return (HnAudio *)pImpl;
}
/***********************************************************************
* WaveLib_Init
*
* Audio!
*
* Parameters
*
*
* Return Value
* Handle To This Audio Session
*
***********************************************************************/
void WaveLib_UnInit(HWAVELIB hWaveLib)
{
PWAVELIB pWaveLib = (PWAVELIB)hWaveLib;
WaveLib_PlaybackTime(pWaveLib->hWaveOut);
if(pWaveLib)
{
if(pWaveLib->hThread)
{
pWaveLib->bWaveShouldDie = TRUE;
SetEvent(pWaveLib->hEvent);
WaitForSingleObject(pWaveLib->hThread, INFINITE);
CloseHandle(pWaveLib->hEvent);
CloseHandle(pWaveLib->hThread);
}
if(pWaveLib->hWaveOut)
{
waveOutClose(pWaveLib->hWaveOut);
}
if(pWaveLib->WaveSample.pSampleData)
{
LocalFree(pWaveLib->WaveSample.pSampleData);
}
LocalFree(pWaveLib);
}
}
static void
MME_CloseDevice(_THIS)
{
if (this->hidden != NULL) {
MMRESULT result;
if (this->hidden->mixbuf) {
result = mmeFreeBuffer(this->hidden->mixbuf);
if (result != MMSYSERR_NOERROR)
SetMMerror("mmeFreeBuffer", result);
this->hidden->mixbuf = NULL;
}
if (this->hidden->shm) {
if (this->hidden->shm->sound) {
result = waveOutClose(this->hidden->shm->sound);
if (result != MMSYSERR_NOERROR)
SetMMerror("waveOutClose()", result);
mmeProcessCallbacks();
}
result = mmeFreeMem(this->hidden->shm);
if (result != MMSYSERR_NOERROR)
SetMMerror("mmeFreeMem()", result);
this->hidden->shm = NULL;
}
SDL_free(this->hidden);
this->hidden = NULL;
}
}
/*****************************************************************************
* Close: close the audio device
*****************************************************************************/
static void Close( vlc_object_t *p_this )
{
aout_instance_t *p_aout = (aout_instance_t *)p_this;
aout_sys_t *p_sys = p_aout->output.p_sys;
/* Before calling waveOutClose we must reset the device */
p_aout->b_die = VLC_TRUE;
waveOutReset( p_sys->h_waveout );
/* wake up the audio thread */
SetEvent( p_sys->event );
vlc_thread_join( p_sys->p_notif );
vlc_object_destroy( p_sys->p_notif );
CloseHandle( p_sys->event );
/* Close the device */
if( waveOutClose( p_sys->h_waveout ) != MMSYSERR_NOERROR )
{
msg_Err( p_aout, "waveOutClose failed" );
}
free( p_sys->p_silence_buffer );
free( p_sys );
}
int CheckDevice(int device,int hertz,int chan,int bits)
{
MMRESULT res;
HWAVEOUT audiodev;
WAVEFORMATEX waveformat;
#ifdef MMPDEBUG
printf("checking device %d with %d Hz, %d channels, %d bits... ",device,hertz,chan,bits);
#endif
waveformat.wFormatTag=WAVE_FORMAT_PCM;
waveformat.nChannels=chan;
waveformat.wBitsPerSample=bits;
waveformat.nSamplesPerSec=hertz;
waveformat.nBlockAlign=(waveformat.nChannels*waveformat.wBitsPerSample)/8;
waveformat.nAvgBytesPerSec=waveformat.nSamplesPerSec*waveformat.nBlockAlign;
waveformat.cbSize=0;
res=waveOutOpen(&audiodev,device,&waveformat,0,0,CALLBACK_NULL);
waveOutReset(audiodev);
waveOutClose(audiodev);
if (res)
{
#ifdef MMPDEBUG
printf("didn't work.\n");
#endif
UseDevice=(unsigned int)-1;
return 1;
}
#ifdef MMPDEBUG
printf("worked!\n");
#endif
return 0;
};
static void
winaudio_out_fini (HWVoiceOut *hw)
{
WinAudioOut* s = (WinAudioOut*) hw;
int i;
if (s->waveout) {
waveOutReset(s->waveout);
s->waveout = 0;
}
for ( i=0; i<NUM_OUT_BUFFERS; ++i ) {
if ( s->buffers[i].dwUser != 0xFFFF ) {
waveOutUnprepareHeader(
s->waveout, &s->buffers[i], sizeof(s->buffers[i]) );
s->buffers[i].dwUser = 0xFFFF;
}
}
if (s->buffer_bytes != NULL) {
qemu_free(s->buffer_bytes);
s->buffer_bytes = NULL;
}
if (s->waveout) {
waveOutClose(s->waveout);
s->waveout = NULL;
}
}
void DIB_CloseAudio(_THIS)
{
int i;
/* Close up audio */
if ( audio_event != INVALID_HANDLE_VALUE ) {
#if defined(_WIN32_WCE) && (_WIN32_WCE < 300)
CloseSynchHandle(audio_event);
#else
CloseHandle(audio_event);
#endif
}
if ( sound ) {
waveOutReset(sound);
}
/* Clean up mixing buffers */
for ( i=0; i<NUM_BUFFERS; ++i ) {
if ( wavebuf[i].dwUser != 0xFFFF ) {
waveOutUnprepareHeader(sound, &wavebuf[i],
sizeof(wavebuf[i]));
wavebuf[i].dwUser = 0xFFFF;
}
}
/* Free raw mixing buffer */
if ( mixbuf != NULL ) {
SDL_free(mixbuf);
mixbuf = NULL;
}
if ( sound )
waveOutClose(sound);
}
/*
==================
FreeSound
==================
*/
void FreeSound (void)
{
int i;
if (pDSBuf)
{
pDSBuf->lpVtbl->Stop(pDSBuf);
pDSBuf->lpVtbl->Release(pDSBuf);
}
// only release primary buffer if it's not also the mixing buffer we just released
if (pDSPBuf && (pDSBuf != pDSPBuf))
{
pDSPBuf->lpVtbl->Release(pDSPBuf);
}
if (pDS)
{
pDS->lpVtbl->SetCooperativeLevel (pDS, mainwindow, DSSCL_NORMAL);
pDS->lpVtbl->Release(pDS);
}
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);
}
}
pDS = NULL;
pDSBuf = NULL;
pDSPBuf = NULL;
hWaveOut = 0;
hData = 0;
hWaveHdr = 0;
lpData = NULL;
lpWaveHdr = NULL;
dsound_init = false;
wav_init = false;
}
/*------------------------------------------------------------------------------*/
static void WaveOutSync( void )
{
MMRESULT mmRes;
switch ( WaveOutStep ){
case -1:
dprintf( 0, 7, "WaveOut Error%d (0x%08X)", WaveOutErrorStep, (int)WaveOutErrorRes );
break;
case 0:
if ( SettingData.WAVOut != 0 ){ WaveOutStep = 1; }
break;
case 1:
mmRes = waveOutOpen( &HdWaveOut, WaveOutUse, &WaveFormat, (DWORD)WaveOutProc, 0, CALLBACK_FUNCTION );
if ( WaveOutErrorCheck( mmRes ) != FALSE ){ return; }
WaveOutStep = 2;
break;
case 2:
if ( WaveInStep != 4 ){ break; }
if ( WaveOutStatus == WAVEOUTSTATUS_OPEN ){ WaveOutStep = 3; }
break;
case 3:
if ( SettingData.WAVOut == 0 ){ WaveOutStep = 4; break; }
while ( WaveBuff[WaveOutNextNo].dwUser & 0x0001 ){
mmRes = waveInUnprepareHeader( HdWaveIn, &WaveBuff[WaveOutNextNo], sizeof(WAVEHDR) );
if ( WaveOutFlag != 0 ){
mmioWrite( hWaveRec, (char *)WaveBuff[WaveOutNextNo].lpData,
WaveBuff[WaveOutNextNo].dwBufferLength );
}
int diff = (WaveOutNextNo+WAVEBUFFNUM - WaveOutLastNo)%WAVEBUFFNUM;
if ( diff <= WAVEBUFFNUM/2 ){
mmRes = waveOutPrepareHeader( HdWaveOut, &WaveBuff[WaveOutNextNo], sizeof(WAVEHDR) );
mmRes = waveOutWrite( HdWaveOut, &WaveBuff[WaveOutNextNo], sizeof(WAVEHDR) );
WaveBuff[WaveOutNextNo].dwUser |= 0x0020;
} else {
WaveBuff[WaveOutNextNo].dwUser |= 0x0010;
}
WaveBuff[WaveOutNextNo].dwUser &= ~0x0001;
WaveOutNextNo = (WaveOutNextNo + 1 ) % WAVEBUFFNUM;
}
while ( WaveBuff[WaveOutLastNo].dwUser & 0x0010 ){
if ( WaveBuff[WaveOutNextNo].dwUser & 0x0020 ){
mmRes = waveOutUnprepareHeader( HdWaveOut, &WaveBuff[WaveOutLastNo], sizeof(WAVEHDR) );
}
mmRes = waveInPrepareHeader( HdWaveIn, &WaveBuff[WaveOutLastNo], sizeof(WAVEHDR) );
mmRes = waveInAddBuffer( HdWaveIn, &WaveBuff[WaveOutLastNo], sizeof(WAVEHDR) );
WaveBuff[WaveOutLastNo].dwUser &= ~0x0030;
WaveOutLastNo = (WaveOutLastNo + 1 ) % WAVEBUFFNUM;
}
break;
case 4:
waveOutReset( HdWaveOut );
for ( int i=0; i<WAVEBUFFNUM; i++ ){
waveOutUnprepareHeader( HdWaveOut, &WaveBuff[i], sizeof(WAVEHDR) );
}
waveOutClose( HdWaveOut );
WaveOutStep = 0;
break;
}
}
void MediaObject::deleteValidWaveOutDevice()
{
if (m_hWaveOut) {
unPrepareBuffers();
if (!(waveOutClose(m_hWaveOut) == MMSYSERR_NOERROR))
setError(Phonon::NormalError, QLatin1String("cannot close wave device"));
}
}
