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

        void MediaObject::play()        {            if ((m_state == Phonon::PlayingState) && !m_paused && !m_stopped)                return;            if  ((m_state == Phonon::LoadingState) ||                 (m_state == Phonon::BufferingState) ||                 (m_state == Phonon::ErrorState)) {                    setError(Phonon::FatalError, QLatin1String("illegale state for playback"));                    return;            }            if (m_state == Phonon::StoppedState)                stop();            if (m_sourceIsValid) {                setState(Phonon::PlayingState);                if (!m_paused) {                    m_nextBufferIndex = true;                    m_stopped = false;                    playBuffer(m_soundBuffer1.waveHeader);                    playBuffer(m_soundBuffer2.waveHeader);                } else {                    if (!(waveOutRestart(m_hWaveOut) == MMSYSERR_NOERROR))                        setError(Phonon::NormalError, QLatin1String("cannot resume (system)"));                }            } else {                setError(Phonon::FatalError, QLatin1String("cannot playback invalid source"));            }            m_paused = false;        }

/** Start stream.*/PJ_DEF(pj_status_t) pjmedia_snd_stream_start(pjmedia_snd_stream *stream){    MMRESULT mr;    PJ_UNUSED_ARG(stream);    if (stream->play_strm.hWave.Out != NULL)    {	mr = waveOutRestart(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, "WMME playback stream started"));    }    if (stream->rec_strm.hWave.In != NULL)    {	mr = waveInStart(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, "WMME capture stream started"));    }    return PJ_SUCCESS;}

void renderstart(void *hrender){    if (!hrender) return;    RENDER *render = (RENDER*)hrender;    waveOutRestart(render->hWaveOut);    render->nRenderStatus &= ~RS_PAUSE;}

void SoundCardPMO::Resume(void){    if (m_initialized)       waveOutRestart(m_hwo);        PhysicalMediaOutput::Resume();}

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

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

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

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

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

HRESULT DSOUND_PrimaryPlay(DirectSoundDevice *device){    HRESULT err = DS_OK;    TRACE("(%p)/n", device);    err = mmErr(waveOutRestart(device->hwo));    if (err != DS_OK)        WARN("waveOutRestart failed/n");    return err;}

void audio_waveout::play(void){    MMRESULT err;    unsigned int i;    if (!main_buffer)    {        /* TODO; throw error, or assert */        return;    }    /* If the status is PAUSED, we have to resume the audio playing */    if (status == WAVEOUT_PAUSED)    {        /* Updates status */        status = WAVEOUT_PLAYING;        /* Tells to the driver to resume audio playing */        waveOutRestart(waveout_handle);        /* Wakeup playing thread */        SetEvent(wakeup_playthread);        return;    } /* if status == WAVEOUT_PAUSED */    if (status != WAVEOUT_READY)        return;    /* Prepares WAVEHDR structures */    prep_headers_();    /* Sets correct status */    status = WAVEOUT_PLAYING;    /* Reads the audio from the start */    //audio_buf.set_position_start();    /* Reads the first N bytes from the audio buffer, where N = the total       size of all little buffers */    audio_buf.read(main_buffer, mb_size);    /* Wakeup the playing thread */    SetEvent(wakeup_playthread);    /* Sends all the little buffers to the audio driver, so it can play       the sound data */    for (i = 0; i < buffers; ++i)    {        err = waveOutWrite(waveout_handle, &wave_headers[i], sizeof(WAVEHDR));        if (err != MMSYSERR_NOERROR)        {            MessageBox(0, _T("waveOutWrite Error"), 0, 0);            /* TODO: throw error */        }    }}

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

/** Resume playing after a pause */int sa_stream_resume(sa_stream_t *s) {  int status;      ERROR_IF_NO_INIT(s);  status = waveOutRestart(s->hWaveOut);  HANDLE_WAVE_ERROR(status, "resuming audio playback");  s->playing = 1;  return SA_SUCCESS;}

bool VDAudioOutputWaveOutW32::Start() {	if (mCurState == kStateSilent)		return true;	if (mCurState < kStateOpened)		return false;	if (MMSYSERR_NOERROR != waveOutRestart(mhWaveOut))		return false;	mCurState = kStatePlaying;	return true;}

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

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

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

void native_midi_pause(int pauseon) //maks{	static int pause = 0;	if(hMidiStream)	{		if(pauseon && !pause)		{			waveOutPause(hMidiStream);			pause = 1;		}		else if(!pauseon && pause)		{			waveOutRestart(hMidiStream);			pause = 0;		}	}}

HRESULT DSOUND_PrimaryPlay(DirectSoundDevice *device){	HRESULT err = DS_OK;	TRACE("(%p)/n", device);	if (device->hwbuf) {		err = IDsDriverBuffer_Play(device->hwbuf, 0, 0, DSBPLAY_LOOPING);		if (err != DS_OK)			WARN("IDsDriverBuffer_Play failed/n");	} else {		err = mmErr(waveOutRestart(device->hwo));		if (err != DS_OK)			WARN("waveOutRestart failed/n");	}	return err;}

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

int playsound(AUDIO_t *audio) {	if (audio->init == 0) {		soundinit(audio);	} else {		int i,b;		audio->PlayTime = tc_elapsed(audio->timer_c) - (BankTime * ((float)BufferBanks));		audio->PlayPnt = (audio->CurPnt-(PreferedSamples * BufferBanks)) % BufferSamples;		for(b = 0; b < BufferBanks; b++) {			for(i = 0; i < PreferedSamples; i++) {				audio->playbuf[b][i].left = 0x80;				audio->playbuf[b][i].right = 0x80;			}		}		waveOutRestart(audio->hWaveOut);		audio->enabled = 1;	}	return 0;}

int playsound(AUDIO_t *audio) {	if (audio->init == 0) {		soundinit(audio);	} else {		audio->PlayTime = audio->timer_c->elapsed - (BANK_TIME * ((float)BUFFER_BANKS));		audio->PlayPnt = (audio->CurPnt - (PREFERED_SAMPLES * BUFFER_BANKS)) % BUFFER_SMAPLES;		for (int b = 0; b < BUFFER_BANKS; b++) {			for (int i = 0; i < PREFERED_SAMPLES; i++) {				audio->playbuf[b][i].left = 0x80;				audio->playbuf[b][i].right = 0x80;			}		}#ifdef _WINDOWS		waveOutRestart(audio->hWaveOut);#endif		audio->enabled = TRUE;	}	return 0;}

/*************************************************************************** * 				MCIAVI_mciResume			[internal] */static	DWORD	MCIAVI_mciResume(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms){    WINE_MCIAVI *wma;    TRACE("(%04x, %08X, %p)/n", wDevID, dwFlags, lpParms);    wma = MCIAVI_mciGetOpenDev(wDevID);    if (wma == NULL)		return MCIERR_INVALID_DEVICE_ID;    if (dwFlags & MCI_TEST)	return 0;    EnterCriticalSection(&wma->cs);    if (wma->dwStatus == MCI_MODE_PAUSE)        wma->dwStatus = MCI_MODE_PLAY;    if (wma->lpWaveFormat) {        LeaveCriticalSection(&wma->cs);        return waveOutRestart(wma->hWave);    }    LeaveCriticalSection(&wma->cs);    return 0;}

int pcm_submit(){        if (!sound || !wout) {                pcm.pos = 0;                return 0;        }        if (pcm.pos) {                hdr[curbuf].dwBufferLength = pcm.pos * cb_per_sample;                hdr[curbuf].dwBytesRecorded = pcm.pos * cb_per_sample;                waveOutPrepareHeader(wout, &hdr[curbuf], sizeof WAVEHDR);                waveOutWrite(wout, &hdr[curbuf], sizeof WAVEHDR);                total_bytes += pcm.pos * cb_per_sample;                if (soundresume)                        waveOutRestart(wout);                if (g_fThrottling) {                        int start = timer_time_in_msec();                        if (WaitForSingleObject(semaph, WOUT_TIMEOUT) == WAIT_TIMEOUT) {                                waveOutReset(wout);                                while (ReleaseSemaphore(semaph, 1, NULL));                                waveOutPause(wout);                                soundresume = 1;                        }                        last_wait_time += timer_time_in_msec() - start;                }                curbuf = (curbuf + 1) % buffers;                pcm.buf = buf + pcm.len * curbuf * cb_per_sample;                pcm.pos = 0;        }        return 0;}

void PauseStream(bool PauseOn){    UINT32 RetVal;    if (! WaveOutOpen)        return;	// Thread is not active#ifdef WIN32    switch(PauseOn)    {    case true:        RetVal = waveOutPause(hWaveOut);        break;    case false:        RetVal = waveOutRestart(hWaveOut);        break;    }    StreamPause = PauseOn;#else    PauseThread = PauseOn;#endif    return;}