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

staticint set_pause(int flag){  static int paused;  MMRESULT error;  if (flag && !paused) {    error = waveOutPause(wave_handle);    if (error != MMSYSERR_NOERROR) {      audio_error = error_text(error);      return -1;    }  }  else if (!flag && paused) {    error = waveOutRestart(wave_handle);    if (error != MMSYSERR_NOERROR) {      audio_error = error_text(error);      return -1;    }  }  paused = flag;  return 0;}

/* * Stop stream. */PJ_DEF(pj_status_t) pjmedia_snd_stream_stop(pjmedia_snd_stream *stream){    MMRESULT mr;    PJ_ASSERT_RETURN(stream != NULL, PJ_EINVAL);    if (stream->play_strm.hWave.Out != NULL)    {	mr = waveOutPause(stream->play_strm.hWave.Out);	if (mr != MMSYSERR_NOERROR)	    /* TODO: This macro is supposed to be used for HRESULT, fix. */	    PJ_RETURN_OS_ERROR(mr);	PJ_LOG(5,(THIS_FILE, "Stopped WMME playback stream"));    }    if (stream->rec_strm.hWave.In != NULL)    {	mr = waveInStop(stream->rec_strm.hWave.In);	if (mr != MMSYSERR_NOERROR)	    /* TODO: This macro is supposed to be used for HRESULT, fix. */	    PJ_RETURN_OS_ERROR(mr);	PJ_LOG(5,(THIS_FILE, "Stopped WMME capture stream"));    }    return PJ_SUCCESS;}

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

// 函数实现void* renderopen(void *surface, AVRational frate, int pixfmt, int w, int h,                 int64_t ch_layout, AVSampleFormat sndfmt, int srate){    WAVEFORMATEX wfx = {0};    RENDER *render = (RENDER*)malloc(sizeof(RENDER));    memset(render, 0, sizeof(RENDER));    render->hRenderWnd = (HWND)surface; // save hwnd    // init for audio    wfx.cbSize          = sizeof(wfx);    wfx.wFormatTag      = WAVE_FORMAT_PCM;    wfx.wBitsPerSample  = 16;    // 16bit    wfx.nSamplesPerSec  = 44100; // 44.1k    wfx.nChannels       = 2;     // stereo    wfx.nBlockAlign     = wfx.nChannels * wfx.wBitsPerSample / 8;    wfx.nAvgBytesPerSec = wfx.nBlockAlign * wfx.nSamplesPerSec;    waveOutOpen(&(render->hWaveOut), WAVE_MAPPER, &wfx, (DWORD_PTR)waveOutProc, (DWORD)render, CALLBACK_FUNCTION);    waveOutPause(render->hWaveOut);    wavqueue_create(&(render->WavQueue), render->hWaveOut, ((int64_t)44100 * 4 * frate.den / frate.num) & ~0x3);    /* allocate & init swr context */    render->pSWRContext = swr_alloc_set_opts(NULL, AV_CH_LAYOUT_STEREO, AV_SAMPLE_FMT_S16, 44100,                          ch_layout, sndfmt, srate, 0, NULL);    swr_init(render->pSWRContext);    // init for video    render->nVideoWidth  = w;    render->nVideoHeight = h;    render->nRenderWidth = GetSystemMetrics(SM_CXSCREEN);    render->nRenderHeight= GetSystemMetrics(SM_CYSCREEN);    render->nRenderNewW  = render->nRenderWidth;    render->nRenderNewH  = render->nRenderHeight;    render->PixelFormat  = (PixelFormat)pixfmt;    // create sws context    render->pSWSContext = sws_getContext(                              render->nVideoWidth,                              render->nVideoHeight,                              render->PixelFormat,                              render->nRenderWidth,                              render->nRenderHeight,                              PIX_FMT_RGB32,                              SWS_BILINEAR,                              0, 0, 0);    render->iFrameTick = 1000 * frate.den / frate.num;    render->iSleepTick = render->iFrameTick;    // create dc & bitmaps    render->hRenderDC = GetDC(render->hRenderWnd);    render->hBufferDC = CreateCompatibleDC(render->hRenderDC);    // create bmp queue    bmpqueue_create(&(render->BmpQueue), render->hBufferDC, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN), 32);    render->nRenderStatus = 0;    pthread_create(&(render->hVideoThread), NULL, VideoRenderThreadProc, render);    return render;}

void renderpause(void *hrender){    if (!hrender) return;    RENDER *render = (RENDER*)hrender;    waveOutPause(render->hWaveOut);    render->nRenderStatus |= RS_PAUSE;}

BOOL COXSound::PlayWithCallback()	//	--- In:	//	--- Out:	//	--- Returns:	BOOL : TRUE if the function is successful	//	---	Effect:		Plays a loaded WAVE asynchronously with callback notification{	// If playing asynchronously, there MUST be a callback	// window to handle processing when the Wave completes.	ASSERT((m_hCallbackWnd != NULL) && ::IsWindow(m_hCallbackWnd));	if(!::SendMessage(m_hCallbackWnd,WM_OX_SOUNDABOUTTOPLAY,NULL,(LPARAM)this))	{		if(m_hWaveOut)		{			waveOutPause(m_hWaveOut);			waveOutReset(m_hWaveOut);		}		CloseWaveOutDevice();		if(!PrepareWaveHeader())		{			return FALSE;		}		return TRUE;	}	return FALSE;}

/* DO NOT CALL FROM CALLBACK THREAD (audio thread)!!!! */VOID DestroySoundInstance(PSOUNDINSTANCE instance){    UINT index = instance - g_soundInstances;    if (instance->WaveOut)    {        waveOutPause(instance->WaveOut);        if (instance->Header)        {            waveOutUnprepareHeader(instance->WaveOut, instance->Header, sizeof(WAVEHDR));            free(instance->Header->lpData);            free(instance->Header);        }        waveOutClose(instance->WaveOut);    }    ZeroMemory(instance, sizeof(SOUNDINSTANCE));    if (index < g_nextFreeInstance)    {        g_nextFreeInstance = index;    }}

static voidwin32_play_data (Win32_Audio_Data *audio_data){	int thisread, readcount ;			readcount = (audio_data->remaining > audio_data->bufferlen) ? audio_data->bufferlen : (int) audio_data->remaining ;	thisread = (int) sf_read_short (audio_data->sndfile, (short *) (audio_data->whdr [audio_data->current].lpData), readcount) ;	audio_data->remaining -= thisread ;	if (thisread > 0)	{	/* Fix buffer length is only a partial block. */		if (thisread * sizeof (short) < audio_data->bufferlen)			audio_data->whdr [audio_data->current].dwBufferLength = thisread * sizeof (short) ;		/* Queue the WAVEHDR */		waveOutWrite (audio_data->hwave, (LPWAVEHDR) &(audio_data->whdr [audio_data->current]), sizeof (WAVEHDR)) ;		}	else	{	/* Stop playback */		waveOutPause (audio_data->hwave) ;		SetEvent (audio_data->Event) ;		} ;	audio_data->current = (audio_data->current + 1) % 2 ;} /* win32_play_data */

void pcm_suspend(){        if (wout) {                waveOutPause(wout);                soundresume = 1;        }}

 /***********************************************************************  * WaveLib_Init  *    *    Audio!  *  * Parameters  *       *   * Return Value  *     Handle To This Audio Session  *  ***********************************************************************/ HWAVELIB WaveLib_Init(PCHAR pWaveFile, BOOL bPause) {     PWAVELIB pWaveLib = NULL;      if(pWaveLib = (PWAVELIB)LocalAlloc(LMEM_ZEROINIT, sizeof(WAVELIB)))     {         pWaveLib->bPaused = bPause;         if(WaveLib_OpenWaveSample(pWaveFile, &pWaveLib->WaveSample))         {             if(waveOutOpen(&pWaveLib->hWaveOut, WAVE_MAPPER, &pWaveLib->WaveSample.WaveFormatEx, (ULONG)WaveLib_WaveOutputCallback, (ULONG)pWaveLib, CALLBACK_FUNCTION) != MMSYSERR_NOERROR)             {                WaveLib_UnInit((HWAVELIB)pWaveLib);                pWaveLib = NULL;             }             else             {                  if(pWaveLib->bPaused)                 {                     waveOutPause(pWaveLib->hWaveOut);                 }                 WaveLib_CreateThread(pWaveLib);             }         }         else         {             WaveLib_UnInit((HWAVELIB)pWaveLib);             pWaveLib = NULL;         }     }     return (HWAVELIB)pWaveLib; }

static int winwave_ctl_out (HWVoiceOut *hw, int cmd, ...){    MMRESULT mr;    WaveVoiceOut *wave = (WaveVoiceOut *) hw;    switch (cmd) {    case VOICE_ENABLE:        {            va_list ap;            int poll_mode;            va_start (ap, cmd);            poll_mode = va_arg (ap, int);            va_end (ap);            if (poll_mode && !wave->event) {                wave->event = CreateEvent (NULL, TRUE, TRUE, NULL);                if (!wave->event) {                    dolog ("DAC CreateEvent: %lx, poll mode will be disabled/n",                           GetLastError ());                }            }            if (wave->event) {                int ret;                ret = qemu_add_wait_object (wave->event, winwave_poll, wave);                hw->poll_mode = (ret == 0);            }            else {                hw->poll_mode = 0;            }            if (wave->paused) {                mr = waveOutRestart (wave->hwo);                if (mr != MMSYSERR_NOERROR) {                    winwave_logerr (mr, "waveOutRestart");                }                wave->paused = 0;            }        }        return 0;    case VOICE_DISABLE:        if (!wave->paused) {            mr = waveOutPause (wave->hwo);            if (mr != MMSYSERR_NOERROR) {                winwave_logerr (mr, "waveOutPause");            }            else {                wave->paused = 1;            }        }        if (wave->event) {            qemu_del_wait_object (wave->event, winwave_poll, wave);        }        return 0;    }    return -1;}

/** * win32ao_open(int sample_rate) * Setup audio for output at specified rate. * returns -1 on error, 0 on happy. */int win32ao_open(int sample_rate, float jitterBufSecs) {	WAVEFORMATEX waveFormat;	MMRESULT res;	int i;	// create an event by which audio driver will notify us	whoutEvent = CreateEvent(NULL, FALSE, FALSE, NULL);	// populate whoutFormat struct	waveFormat.wFormatTag = WAVE_FORMAT_PCM;	waveFormat.nChannels = 1;	waveFormat.nSamplesPerSec = sample_rate;	waveFormat.nAvgBytesPerSec = sample_rate * SAMPLE_BITS / 8;	waveFormat.nBlockAlign = SAMPLE_BITS / 8;	waveFormat.wBitsPerSample = SAMPLE_BITS;	waveFormat.cbSize = 0;	whoutBufNo = 0;	whoutBufIndex = 0;	// open audio device	res = waveOutOpen(&waveout, WAVE_MAPPER, &waveFormat,			  (DWORD) whoutEvent, (DWORD) 0, CALLBACK_EVENT);	if (checkWaveOutResult(waveout, res, "waveOutOpen"))		return -1;	// pause playback (unpause when lo water mark reached)	res = waveOutPause(waveout);	if (checkWaveOutResult(waveout, res, "waveOutPause"))		return -1;	// compute whoutBufCnt	whoutBufCnt = (int) ceil(jitterBufSecs * (float) waveFormat.nAvgBytesPerSec					         / (float) WaveBuf_SIZE);	if (whoutBufCnt < WaveBuf_N_MIN)		whoutBufCnt = WaveBuf_N_MIN;	// create buffers	whout = (WAVEHDR**) malloc(whoutBufCnt * sizeof(WAVEHDR**));	for (i = 0; i < whoutBufCnt; ++i) {		// allocate buffer header		whout[i] = (WAVEHDR*) calloc(1, sizeof(WAVEHDR));		if (whout[i] == NULL) {			perror("calloc WAVEHDR");			return -1;		}		// allocate buffer		whout[i]->lpData = malloc(WaveBuf_SIZE);		if (whout[i]->lpData == NULL) {			perror("malloc lpData");			return -1;		}	}	return 0;}

int EmuOutMod::Pause(int pause) {    if(pause) {        waveOutPause(m_hwo);        m_playing = false;    } else {        waveOutRestart(m_hwo);        m_playing = true;    }    return !pause;}

void COutput::Reset(){	if (!m_hwo)		return;	if (m_fDoubleBuf) {		CAutoLock lockDev(&m_csecDevice);		SetEvent(m_hEvent);		m_cWritten = 0;		m_dwWritten = 0;		m_nCurrent = 0; 		m_nWriteCur = 0;		m_fPaused = TRUE;		m_dwTotalSamples = 0;		if (m_pHdr) {			CAutoLock lock(&m_csecBuff);			for (DWORD i = 0; i < m_cBuf; i++)				m_pHdr[i].dwUser = 0;		}	}	else {		CAutoLock lock(&m_csecDevice);		waveOutPause(m_hwo);		waveOutReset(m_hwo);		SetEvent(m_hEvent);		m_cWritten = 0;		m_dwWritten = 0;		m_nCurrent = 0;		m_nWriteCur = 0;		waveOutPause(m_hwo);	}	m_nLPeek = 0;	m_nRPeek = 0;	if (m_fFade) {		m_nFadeCurrent = FADE_BASE << FADE_BITS;		m_nFadeSamples = m_pcm.wf.nSamplesPerSec * FADE_TIME / 1000;		m_nFadeRate = (int)((((double)1 - FADE_BASE) / m_nFadeSamples) * (1 << FADE_BITS));		m_nFadeRate += 1;	}}

ModPlay::~ModPlay(){	stopped = true; // tell the thread to exit	waveOutPause(hWaveOut); // make sure no buffers are written and played in case of a race condition	waveOutReset(hWaveOut); // calls WOM_DONE for all buffers (thread checks if stopped == true and exits)	WaitForSingleObject(hThread, INFINITE); // Let the thread finish	waveOutClose(hWaveOut);	CloseHandle(hEventDone);	CloseHandle(hThread);	ModPlug_Unload(modFile);}

int pausesound(AUDIO_t *audio) {	if (!audio->init) {		return 0;	}	audio->enabled = FALSE;#ifdef _WINDOWS	waveOutPause(audio->hWaveOut);#endif	return 0;}

 void MediaObject::pause() {     if (!m_paused) {         m_paused = true;         setState(Phonon::PausedState);         if (!(waveOutPause(m_hWaveOut) == MMSYSERR_NOERROR))         {             setError(Phonon::NormalError, QLatin1String("cannot pause (system error)"));         }     } }

// Play audio, starting at a given frame/sampleBOOL CALLBACK aviaudioPlay(HWND hwnd, PAVISTREAM pavi, LONG lStart, LONG lEnd, BOOL fWait){	if (audioPlayable <= 0)		return FALSE;	recalc = 1;	//CString tx;	//tx.Format("audioPlayable %d",audioPlayable);	//MessageBox(NULL,tx,"Note",MB_OK);	CString msx;	if (lStart < 0)		lStart = ::AVIStreamStart(pavi);	if (lEnd < 0)		lEnd = AVIStreamEnd(pavi);	if (lStart >= lEnd) {		return FALSE;	}	if (!aviaudioOpenDevice(hwnd, pavi)) {		MessageBox(NULL,"AudioOpen failed","Note",MB_OK | MB_ICONEXCLAMATION);		return FALSE;	}	if (!sfPlaying) {		// We're beginning play, so pause until we've filled the buffers		// for a seamless start		waveOutPause(shWaveOut);		slBegin = lStart;		slCurrent = lStart;		slEnd = lEnd;		sfPlaying = TRUE;	} else {		slEnd = lEnd;	}	aviaudioiFillBuffers();	// Now unpause the audio and away it goes!	waveOutRestart(shWaveOut);	// Caller wants us not to return until play is finished	if (fWait) {		while (swBuffersOut > 0)			Yield();	}	return TRUE;}

/** Pause audio playback (do not empty the buffer) */int sa_stream_pause(sa_stream_t *s) {  int status;  ERROR_IF_NO_INIT(s);    status = waveOutPause(s->hWaveOut);  HANDLE_WAVE_ERROR(status, "resuming audio playback");  s->playing = 0;  return SA_SUCCESS;}

	MMRESULT TinyWaveOut::Pause()	{		if (hWaveOut == NULL) return S_FALSE;		MMRESULT hRes = waveOutPause(hWaveOut);		if (hRes != MMSYSERR_NOERROR)		{			waveOutClose(hWaveOut);			hWaveOut = NULL;			return S_FALSE;		}		return S_OK;	}

static DWORD CALLBACKwin32_audio_out_callback (HWAVEOUT hwave, UINT msg, DWORD data, DWORD param1, DWORD param2){	WIN32_AUDIO_OUT	*win32_out ;	int		read_count, sample_count, k ;	short	*sptr ;	/*	** I consider this technique of passing a pointer via an integer as	** fundamentally broken but thats the way microsoft has defined the	** interface.	*/	if ((win32_out = (WIN32_AUDIO_OUT*) data) == NULL)	{	printf ("win32_audio_out_callback : AUDIO_OUT is NULL./n") ;		return 1 ;		} ;	if (win32_out->magic != WIN32_MAGIC)	{	printf ("win32_audio_out_callback : Bad magic number (%d %d)./n", win32_out->magic, WIN32_MAGIC) ;		return 1 ;		} ;	if (msg != MM_WOM_DONE)		return 0 ;	/* Do the actual audio. */	sample_count = win32_out->bufferlen ;	read_count = win32_out->callback (win32_out->callback_data, win32_out->float_buffer, sample_count) ;	sptr = (short*) win32_out->whdr [win32_out->current].lpData ;	for (k = 0 ; k < read_count ; k++)		sptr [k] = lrint (32767.0 * win32_out->float_buffer [k]) ;	if (read_count > 0)	{	/* Fix buffer length is only a partial block. */		if (read_count * sizeof (short) < win32_out->bufferlen)			win32_out->whdr [win32_out->current].dwBufferLength = read_count * sizeof (short) ;		/* Queue the WAVEHDR */		waveOutWrite (win32_out->hwave, (LPWAVEHDR) &(win32_out->whdr [win32_out->current]), sizeof (WAVEHDR)) ;		}	else	{	/* Stop playback */		waveOutPause (win32_out->hwave) ;		SetEvent (win32_out->Event) ;		} ;	win32_out->current = (win32_out->current + 1) % 2 ;	return 0 ;} /* win32_audio_out_callback */

int WaveOut::Pause(int pause){	bool waspaused = _paused;	if (pause)	{		if (!waspaused) waveOutPause(_device);		_paused = true;	}	else	{		if (waspaused) waveOutRestart(_device);		_paused = false;	}	return waspaused?1:0;}

void COutput::Pause(BOOL fPause){	if (!m_hwo)		return;	if (m_fDoubleBuf)		m_fPaused = fPause;	else {		CAutoLock lock(&m_csecDevice);		if (fPause)			waveOutPause(m_hwo);		else			waveOutRestart(m_hwo);	}}

void CWaveDevice::StopFromSoundThread()//-------------------------------------{	MPT_TRACE();	if(m_hWaveOut)	{		CheckResult(waveOutPause(m_hWaveOut));		m_JustStarted = false;		{			MPT_LOCK_GUARD<mpt::mutex> guard(m_PositionWraparoundMutex);			MemsetZero(m_PositionLast);			m_PositionWrappedCount = 0;		}	}}

  /***********************************************************************  * WaveLib_Pause  *    *    Audio!  *  * Parameters  *       *   * Return Value  *     Handle To This Audio Session  *  ***********************************************************************/ void WaveLib_Pause(HWAVELIB hWaveLib, BOOL bPause) {     PWAVELIB pWaveLib = (PWAVELIB)hWaveLib;     pWaveLib->bPaused = bPause;     if(pWaveLib->bPaused)     {         waveOutPause(pWaveLib->hWaveOut);     }     else     {         waveOutRestart(pWaveLib->hWaveOut);     } }

static intwinaudio_out_ctl (HWVoiceOut *hw, int cmd, ...){    WinAudioOut*  s = (WinAudioOut*) hw;    switch (cmd) {    case VOICE_ENABLE:        waveOutRestart( s->waveout );        break;    case VOICE_DISABLE:        waveOutPause( s->waveout );        break;    }    return 0;}

intcubeb_stream_stop(cubeb_stream * stm){  MMRESULT r;  EnterCriticalSection(&stm->lock);  r = waveOutPause(stm->waveout);  LeaveCriticalSection(&stm->lock);  if (r != MMSYSERR_NOERROR) {    return CUBEB_ERROR;  }  stm->state_callback(stm, stm->user_ptr, CUBEB_STATE_STOPPED);  return CUBEB_OK;}