bool CSoundChannel::m_bAbort() { DWORD dwErr = MMSYSERR_NOERROR; if(m_hWaveIn != NULL) dwErr = waveInReset(m_hWaveIn); if(m_hWaveOut != NULL) dwErr = waveOutReset(m_hWaveOut); CWaitAndSignal mutex(m_Mutex); for(int i=0; i<m_Buffers.size(); i++) { while(m_Buffers[i]->m_dwRelease() == WAVERR_STILLPLAYING) { if(m_hWaveIn != NULL) dwErr = waveInReset(m_hWaveIn); if(m_hWaveOut != NULL) dwErr = waveOutReset(m_hWaveOut); } } m_iBufByteOffset = 0x7fffffff; m_iBufIndex = 0; m_iPacket = 1; SetEvent(m_hEventDone); if(dwErr != MMSYSERR_NOERROR) return false; else return true; }
/** * win32ai_close() * Terminate recording. * This function discards all data that has been sampled but not read. * Return 0 if happy, -1 if error. */ int win32ai_close(void) { MMRESULT res; int i; // stop device res = waveInReset(wavein); if (checkWaveInResult(wavein, res, "waveInReset")) return -1; // wait for buffers to finish and unprepare them all for (i = 0; i < WaveBuf_N; ++i) { while ((whin[i]->dwFlags & WHDR_DONE) == 0) { // buffer not ready, wait, try again WaitForSingleObject(whinEvent, INFINITE); } // unprepare the buffer res = waveInUnprepareHeader(wavein, whin[i], sizeof(WAVEHDR)); if (checkWaveInResult(wavein, res, "waveInUnprepareHeader")) return -1; // free memory free(whin[i]->lpData); free(whin[i]); } // close device res = waveInClose(wavein); if (checkWaveInResult(wavein, res, "waveInClose")) return -1; return 0; }
int tdav_producer_waveapi_stop(tmedia_producer_t* self) { tdav_producer_waveapi_t* producer = (tdav_producer_waveapi_t*)self; MMRESULT result; if(!self){ TSK_DEBUG_ERROR("Invalid parameter"); return -1; } if(!producer->started){ TSK_DEBUG_WARN("Producer not started"); return 0; } /* stop thread */ if(producer->tid[0]){ SetEvent(producer->events[1]); tsk_thread_join(&(producer->tid[0])); } /* should be done here */ producer->started = tsk_false; if(producer->hWaveIn && (((result = waveInReset(producer->hWaveIn)) != MMSYSERR_NOERROR) || ((result = waveInClose(producer->hWaveIn)) != MMSYSERR_NOERROR))){ print_last_error(result, "waveInReset/waveInClose"); } return 0; }
static void WinMMCloseCapture(ALCdevice *Device) { WinMMData *data = (WinMMData*)Device->ExtraData; void *buffer = NULL; int i; /* Tell the processing thread to quit and wait for it to do so. */ data->killNow = AL_TRUE; PostThreadMessage(data->thread, WM_QUIT, 0, 0); althrd_join(data->thread, &i); /* Make sure capture is stopped and all pending buffers are flushed. */ waveInReset(data->WaveHandle.In); // Release the wave buffers for(i = 0; i < 4; i++) { waveInUnprepareHeader(data->WaveHandle.In, &data->WaveBuffer[i], sizeof(WAVEHDR)); if(i == 0) buffer = data->WaveBuffer[i].lpData; data->WaveBuffer[i].lpData = NULL; } free(buffer); DestroyRingBuffer(data->Ring); data->Ring = NULL; // Close the Wave device waveInClose(data->WaveHandle.In); data->WaveHandle.In = 0; free(data); Device->ExtraData = NULL; }
void RUIAudio::RecordClose() { Stop(); HWAVEIN hTemp = m_hWaveIn; m_hWaveIn = NULL; if (hTemp == NULL) return; RUIBuffer* pRUIBuffer = m_RecBufferList.GetFirst(); while (pRUIBuffer != NULL) { RecRemoveBuffer(pRUIBuffer); pRUIBuffer = m_RecBufferList.GetNext(pRUIBuffer); } if( hTemp == NULL ) return; if (waveInReset(hTemp) != MMSYSERR_NOERROR) ASSERT(FALSE); if (waveInClose(hTemp) != MMSYSERR_NOERROR) ASSERT(FALSE); }
BMID_API int BGBMID_SoundDev_RecDeInit() { int i; waveInStop(hWaveIn); waveInReset(hWaveIn); if(lpInWaveHdr) { for(i=0; i<WAV_BUFFERS; i++) waveInUnprepareHeader(hWaveIn, lpInWaveHdr+i, sizeof(WAVEHDR)); } waveInClose(hWaveIn); if(hInWaveHdr) { GlobalUnlock(hInWaveHdr); GlobalFree(hInWaveHdr); } if(hInData) { GlobalUnlock(hInData); GlobalFree(hInData); } return(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; }
//停止录音 BOOL CWaveIn::CloseRecord() { //已经停止录音 if (!m_bRecord) { //返回 return FALSE; } //录音设备句柄无效 if(!m_hIn) { //返回 return FALSE; } //重置录音设备,停止录音 m_mmr = waveInReset(m_hIn); //出错 if (m_mmr) { //返回 return FALSE; } //设置录音停止标记 m_bRecord = FALSE; //返回 return TRUE; }
static void winwave_fini_in (HWVoiceIn *hw) { int i; MMRESULT mr; WaveVoiceIn *wave = (WaveVoiceIn *) hw; mr = waveInReset (wave->hwi); if (mr != MMSYSERR_NOERROR) { winwave_logerr (mr, "waveInReset"); } for (i = 0; i < conf.adc_headers; ++i) { mr = waveInUnprepareHeader (wave->hwi, &wave->hdrs[i], sizeof (wave->hdrs[i])); if (mr != MMSYSERR_NOERROR) { winwave_logerr (mr, "waveInUnprepareHeader(%d)", i); } } winwave_anal_close_in (wave); if (wave->event) { qemu_del_wait_object (wave->event, winwave_poll, wave); if (!CloseHandle (wave->event)) { dolog ("ADC CloseHandle failed %lx\n", GetLastError ()); } wave->event = NULL; } g_free (wave->pcm_buf); wave->pcm_buf = NULL; g_free (wave->hdrs); wave->hdrs = NULL; }
// stop the capture hardware int BAE_StopAudioCapture(void) { MMRESULT theErr; int i; if (g_captureSound) { g_captureShutdown = TRUE; // stop streaming data theErr = BAE_PauseAudioCapture(); // release all buffers theErr = waveInReset(g_captureSound); // deallocate the capture data buffers // this could really be done in initialiation...? // is waveInReset synchronous? otherwise something bad could happen.... for (i = 0; i < BAE_WAVEIN_NUM_BUFFERS; i++) { BAE_Deallocate(g_audioBufferBlock[i]); } // for } 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; } }
static void winaudio_in_fini (HWVoiceIn *hw) { WinAudioIn* s = (WinAudioIn*) hw; int i; if (s->wavein) { waveInReset(s->wavein); s->wavein = 0; } for ( i=0; i<NUM_OUT_BUFFERS; ++i ) { if ( s->buffers[i].dwUser != 0xFFFF ) { waveInUnprepareHeader( s->wavein, &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->wavein) { waveInClose(s->wavein); s->wavein = NULL; } }
static void ALCwinmmCapture_Destruct(ALCwinmmCapture *self) { void *buffer = NULL; int i; /* Tell the processing thread to quit and wait for it to do so. */ if(!ATOMIC_EXCHANGE(&self->killNow, AL_TRUE, almemory_order_acq_rel)) { PostThreadMessage(self->thread, WM_QUIT, 0, 0); althrd_join(self->thread, &i); /* Make sure capture is stopped and all pending buffers are flushed. */ waveInReset(self->InHdl); // Release the wave buffers for(i = 0;i < 4;i++) { waveInUnprepareHeader(self->InHdl, &self->WaveBuffer[i], sizeof(WAVEHDR)); if(i == 0) buffer = self->WaveBuffer[i].lpData; self->WaveBuffer[i].lpData = NULL; } free(buffer); } ll_ringbuffer_free(self->Ring); self->Ring = NULL; // Close the Wave device if(self->InHdl) waveInClose(self->InHdl); self->InHdl = 0; ALCbackend_Destruct(STATIC_CAST(ALCbackend, self)); }
/* * Class: com_ibm_media_protocol_device_DataSource * Method: disconnectDevice * Signature: ()V */ JNIEXPORT void JNICALL Java_com_ibm_media_protocol_device_DataSource_disconnectDevice (JNIEnv* env, jobject obj) { MMRESULT result; /* first mark all pending buffers as done */ result = waveInReset(hwi); /* DEBUG */ if (result == MMSYSERR_NOERROR) printf("Device reset\n"); else printf("ERROR reseting device !\n"); /* end DEBUG */ result = waveInClose(hwi); /* DEBUG */ if (result == MMSYSERR_NOERROR) printf("Device closed\n"); else printf("ERROR closing device !\n"); /* end DEBUG */ }
int32 ad_stop_rec(ad_rec_t * r) { int32 i, st; if ((!r->opened) || (!r->recording)) return -1; if (waveInStop(r->h_wavein) != 0) return AD_ERR_WAVE; if ((st = waveInReset(r->h_wavein)) != 0) { wavein_error("waveInReset", st); return AD_ERR_WAVE; } /* Wait until all buffers marked done */ for (i = 0; i < r->n_buf; i++) while (!(r->wi_buf[i].p_whdr->dwFlags & WHDR_DONE)); if ((r->lastbuf = r->curbuf - 1) < 0) r->lastbuf = r->n_buf - 1; r->recording = 0; return 0; }
void WaveInStart(WaveIn *waveIn, BOOL prep) { MMRESULT res; res = waveInReset(waveIn->handler); if(res) { return; } // prepare header an add the buffer waveIn->header.lpData = (char *) waveIn->data; waveIn->header.dwBufferLength = waveIn->n * 2; waveIn->header.dwBytesRecorded = 0; waveIn->header.dwFlags = 0L; waveIn->header.dwLoops = 0L; waveIn->header.dwUser = 0L; waveInPrepareHeader(waveIn->handler, &waveIn->header, sizeof(WAVEHDR)); res = waveInAddBuffer(waveIn->handler, &waveIn->header, sizeof(WAVEHDR)); if(res) { return; } res = waveInStart(waveIn->handler); if(res) { return; } }
int audio_close(snd_type snd) { int i; MMRESULT er; buffer_state *bs = (buffer_state *) snd->u.audio.descriptor; if (snd->write_flag == SND_READ) { if (er = waveInReset(bs->u.h_in)) { mm_error_handler(snd, er, snd_fail); return !SND_SUCCESS; } if (er = waveInClose(bs->u.h_in)) { mm_error_handler(snd, er, snd_fail); return !SND_SUCCESS; } } else { // SND_WRITE if (er = waveOutReset(bs->u.h_out)) { mm_error_handler(snd, er, snd_fail); return !SND_SUCCESS; } if (er = waveOutClose(bs->u.h_out)) { mm_error_handler(snd, er, snd_fail); return !SND_SUCCESS; } } for (i = 0; i < bs->numofbuffers; i++) { snd_free(bs->whdr[i].lpData); } snd_free(bs->whdr); snd_free(bs); if (rt_devices_open) { timeEndPeriod(1); rt_devices_open--; } return SND_SUCCESS; }
bool CSoundChannel::m_bCloseAudio() { if(m_bClose) return m_bClose; m_bAbort(); if(m_hWaveOut != NULL) { while(waveOutClose(m_hWaveOut) == WAVERR_STILLPLAYING) //关闭WAVEOUT设备 waveOutReset(m_hWaveOut); m_hWaveOut = NULL; } if(m_hWaveIn != NULL) { while(waveInClose(m_hWaveIn) == WAVERR_STILLPLAYING) //关闭WAVEIN设备 waveInReset(m_hWaveIn); m_hWaveIn = NULL; } m_bAbort(); m_uOldHandle = -1; m_bClose = true; return true; }
void CAudio2Dlg::OnRecStop() {bEnding=TRUE; waveInReset(hWaveIn); }
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); }
//分配内存 BOOL CWaveIn::PerPareBuffer() { //已经分配内存 if (m_bAllocBuffer) { //返回 return FALSE; } //重置录音设备 m_mmr = waveInReset(m_hIn); //出错 if (m_mmr) { //返回 return FALSE; } //循环变量 UINT i; //新建WAVEHDR结构 m_pHdr = new WAVEHDR[NUM_BUF]; for (i = 0; i < NUM_BUF; i++) { //初始化 ZeroMemory(&m_pHdr[i], sizeof(WAVEHDR)); //波形缓存 m_pHdr[i].lpData = new char[SIZE_AUDIO_FRAME]; //缓存大小 m_pHdr[i].dwBufferLength = SIZE_AUDIO_FRAME; m_pHdr[i].dwFlags = WHDR_BEGINLOOP | WHDR_ENDLOOP; m_pHdr[i].dwLoops = 1; //准备缓存 m_mmr = waveInPrepareHeader(m_hIn, &m_pHdr[i], sizeof(WAVEHDR)); //出错 if (m_mmr) { //返回 return FALSE; } //添加缓存到录音设备 m_mmr = waveInAddBuffer(m_hIn, &m_pHdr[i], sizeof(WAVEHDR)); //出错 if (m_mmr) { //返回 return FALSE; } } //设置内存分配标记 m_bAllocBuffer = TRUE; //返回 return TRUE; }
void QAudioInputPrivate::suspend() { if(deviceState == QAudio::ActiveState) { waveInReset(hWaveIn); deviceState = QAudio::SuspendedState; emit stateChanged(deviceState); } }
void ph_media_stop(phcall_t *ca) { phmstream_t *stream = (phmstream_t *) ca->phstream; ca->hasaudio = 0; ca->phstream = 0; stream->running = 0; osip_thread_join(stream->audio_in_thread); osip_thread_join(stream->audio_out_thread); osip_free(stream->audio_in_thread); osip_free(stream->audio_out_thread); rtp_session_signal_disconnect_by_callback(stream->rtp_session, "telephone-event", (RtpCallback)ph_telephone_event); ortp_set_debug_file("oRTP", stdout); ortp_global_stats_display(); ortp_set_debug_file("oRTP", NULL); rtp_session_destroy(stream->rtp_session); #if USE_CODECS if (stream->codec->encoder_cleanup) stream->codec->encoder_cleanup(stream->encoder_ctx); if (stream->codec->decoder_cleanup) stream->codec->decoder_cleanup(stream->decoder_ctx); #endif /* !USE_CODECS */ waveInReset(stream->hWaveIn); waveInClose(stream->hWaveIn); waveOutReset(stream->hWaveOut); waveOutClose(stream->hWaveOut); #if DO_ECHO_CAN printf("\nbytes echoed %d %d\n", stream->sent_cnt, stream->recv_cnt); free(stream->pcm_sent); # if !AEC_BIS if(stream->ec) echo_can_free(stream->ec); # else /* AEC_BIS */ kill_AEC(); # endif /* AEC_BIS */ g_mutex_free(stream->synclock); g_cond_free(stream->sync_cond); g_mutex_free(stream->aec_mutex); #endif /* !DO_ECHO_CAN */ g_mutex_free(stream->dtmfg_lock); osip_free(stream); }
/* * Destroy stream. */ PJ_DEF(pj_status_t) pjmedia_snd_stream_close(pjmedia_snd_stream *stream) { unsigned i; PJ_ASSERT_RETURN(stream != NULL, PJ_EINVAL); pjmedia_snd_stream_stop(stream); if (stream->thread) { SetEvent(stream->thread_quit_event); pj_thread_join(stream->thread); pj_thread_destroy(stream->thread); stream->thread = NULL; } /* Unprepare the headers and close the play device */ if (stream->play_strm.hWave.Out) { waveOutReset(stream->play_strm.hWave.Out); for (i = 0; i < stream->play_strm.dwMaxBufIdx; ++i) waveOutUnprepareHeader(stream->play_strm.hWave.Out, &(stream->play_strm.WaveHdr[i]), sizeof(WAVEHDR)); waveOutClose(stream->play_strm.hWave.Out); stream->play_strm.hWave.Out = NULL; } /* Close the play event */ if (stream->play_strm.hEvent) { CloseHandle(stream->play_strm.hEvent); stream->play_strm.hEvent = NULL; } /* Unprepare the headers and close the record device */ if (stream->rec_strm.hWave.In) { waveInReset(stream->rec_strm.hWave.In); for (i = 0; i < stream->play_strm.dwMaxBufIdx; ++i) waveInUnprepareHeader(stream->rec_strm.hWave.In, &(stream->rec_strm.WaveHdr[i]), sizeof(WAVEHDR)); waveInClose(stream->rec_strm.hWave.In); stream->rec_strm.hWave.In = NULL; } /* Close the record event */ if (stream->rec_strm.hEvent) { CloseHandle(stream->rec_strm.hEvent); stream->rec_strm.hEvent = NULL; } pj_pool_release(stream->pool); return PJ_SUCCESS; }
void CAudioCollect::Stop() { bStart = false; bReset = true; waveOutReset(m_hWaveOut); waveOutClose(m_hWaveOut); waveInReset(m_hWaveIn); waveInClose(m_hWaveIn); }
void HAE_FlushAudioCapture() { TRACE0("> HAE_FlushAudioCapture\n"); if (g_captureSound) { g_flushMode = FLUSHMODE_FLUSHING; /* flush will cease activity, and mark all buffers as done */ waveInReset(g_captureSound); g_flushMode = FLUSHMODE_FLUSHED; } }
void stop_sound(void) { if (sound_recording) { sound_recording = 0; error_code = waveInReset(hwavein); if( error_code != MMSYSERR_NOERROR) errormsg("Unable to stop sound recording.",error_code); stop_encoder(); } SetDlgItemText(hMainDialog,IDC_LISTEN_INDICATOR,""); meter_off(); }
BOOL Mic_DeInit_Physical() { if(!Mic_Inited) return TRUE; INFO("win32 microphone DEinit OK\n"); Mic_Inited = FALSE; waveInReset(waveIn); waveInClose(waveIn); return TRUE; }
bool UBWaveRecorder::close() { if (waveInReset(mWaveInDevice) != MMSYSERR_NOERROR) { setLastErrorMessage("Cannot reset wave in device "); return false; } foreach(WAVEHDR* buffer, mWaveBuffers) { waveInUnprepareHeader(mWaveInDevice, buffer, sizeof(WAVEHDR)); delete [] buffer->lpData; delete buffer; }
void WaveIn::close() { waveInReset(hWaveIn); while (!waveHeaders.IsEmpty()) { LPWAVEHDR pwh = (LPWAVEHDR) waveHeaders.RemoveHead(); waveInUnprepareHeader(hWaveIn, pwh, sizeof(WAVEHDR)); delete []pwh->lpData; delete pwh; } waveInClose(hWaveIn); hWaveIn = NULL; }