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

static voidWINMM_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_ShutdownReset 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;}

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

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

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