void sound::stop(){ Pa_StopStream(input); Pa_AbortStream(input); Pa_CloseStream(input); input = 0; Pa_StopStream(output); Pa_AbortStream(output); Pa_CloseStream(output); output = 0; }
/** * Stop recording. * * @return TRUE on success, FALSE on failure. */ boolean adin_mic_end() { PaError err; if (stream == NULL) return(TRUE); /* stop stream (do not wait callback and buffer flush, stop immediately) */ err = Pa_AbortStream(stream); if (err != paNoError) { jlog("Error: adin_portaudio: failed to stop stream: %s\n", Pa_GetErrorText(err)); return(FALSE); } /* close stream */ err = Pa_CloseStream(stream); if (err != paNoError) { jlog("Error: adin_portaudio: failed to close stream: %s\n", Pa_GetErrorText(err)); return(FALSE); } /* terminate library */ err = Pa_Terminate(); if (err != paNoError) { jlog("Error: adin_portaudio: failed to terminate library: %s\n", Pa_GetErrorText(err)); return(FALSE); } stream = NULL; return TRUE; }
JNIEXPORT jint JNICALL Java_com_github_rjeschke_jpa_JPA_paAbortStream(JNIEnv *env, jclass clazz, jlong jPtr) { JPA_DATA *j = (JPA_DATA*)long2Ptr(jPtr); if(!j->detachThread) waitSync(j); return Pa_AbortStream(j->stream); }
~portaudio_manager_t() { if (input_stream) { Pa_AbortStream(input_stream); Pa_CloseStream(input_stream); } Pa_Terminate(); }
RTC::ReturnCode_t PortAudioInput::onFinalize() { RTC_DEBUG(("onFinalize start")); is_active = false; m_mutex.lock(); RTC_DEBUG(("onFinalize:mutex lock")); try { m_out_dataOut.deactivateInterfaces(); if ( m_stream ) { if ( !Pa_IsStreamStopped( m_stream ) ) { m_err = Pa_AbortStream( m_stream ); if ( m_err != paNoError ) { throw m_err; } } m_err = Pa_CloseStream( m_stream ); if ( m_err != paNoError ) { throw m_err; } m_stream = NULL; } } catch (...) { std::string error_str = Pa_GetErrorText(m_err); RTC_WARN(("PortAudio Stream close failed onFinalize:%s", error_str.c_str())); return RTC::RTC_ERROR; } m_mutex.unlock(); RTC_DEBUG(("onFinalize:mutex unlock")); RTC_DEBUG(("onFinalize finish")); return RTC::RTC_OK; }
bool audioSink::selectDevice (int16_t odev) { PaError err; fprintf (stderr, "select device with %d\n", odev); if (!isValidDevice (odev)) return false; if ((ostream != NULL) && !Pa_IsStreamStopped (ostream)) { paCallbackReturn = paAbort; (void) Pa_AbortStream (ostream); while (!Pa_IsStreamStopped (ostream)) Pa_Sleep (1); writerRunning = false; } if (ostream != NULL) Pa_CloseStream (ostream); outputParameters. device = odev; outputParameters. channelCount = 2; outputParameters. sampleFormat = paFloat32; outputParameters. suggestedLatency = Pa_GetDeviceInfo (odev) -> defaultHighOutputLatency * 6; // bufSize = (int)((float)outputParameters. suggestedLatency); bufSize = 80 * 256; // if (bufSize < 0 || bufSize > 17300) // bufSize = 16384; outputParameters. hostApiSpecificStreamInfo = NULL; // fprintf (stderr, "Suggested size for outputbuffer = %d\n", bufSize); err = Pa_OpenStream ( &ostream, NULL, &outputParameters, 48000, bufSize, 0, this -> paCallback_o, this ); if (err != paNoError) { qDebug ("Open ostream error\n"); return false; } fprintf (stderr, "stream opened\n"); paCallbackReturn = paContinue; err = Pa_StartStream (ostream); if (err != paNoError) { qDebug ("Open startstream error\n"); return false; } fprintf (stderr, "stream started\n"); writerRunning = true; return true; }
int main(int argc, char* argv[]) { PaStream *stream; PaError err; patest1data data; int i; int inputDevice = Pa_GetDefaultInputDeviceID(); int outputDevice = Pa_GetDefaultOutputDeviceID(); /* initialise sinusoidal wavetable */ for( i=0; i<100; i++ ) data.sine[i] = sin( ((double)i/100.) * M_PI * 2. ); data.phase = 0; data.sampsToGo = 44100 * 20; // 20 seconds /* initialise portaudio subsytem */ Pa_Initialize(); err = Pa_OpenStream( &stream, inputDevice, 2, /* stereo input */ paFloat32, /* 32 bit floating point input */ NULL, outputDevice, 2, /* stereo output */ paFloat32, /* 32 bit floating point output */ NULL, 44100., 512, /* small buffers */ 0, /* let PA determine number of buffers */ paClipOff, /* we won't output out of range samples so don't bother clipping them */ patest1Callback, &data ); if( err == paNoError ) { err = Pa_StartStream( stream ); printf( "Press any key to end.\n" ); getc( stdin ); //wait for input before exiting Pa_AbortStream( stream ); printf( "Waiting for stream to complete...\n" ); while( Pa_StreamActive( stream ) ) Pa_Sleep(1000); /* sleep until playback has finished */ err = Pa_CloseStream( stream ); } else { fprintf( stderr, "An error occured while opening the portaudio stream\n" ); if( err == paHostError ) fprintf( stderr, "Host error number: %d\n", Pa_GetHostError() ); else fprintf( stderr, "Error number: %d\n", err ); } Pa_Terminate(); printf( "bye\n" ); return 0; }
int main(void) { PortAudioStream *stream; PaError err; paTestData data; int i; printf("PortAudio Test: output sine wave. SR = %d, BufSize = %d\n", SAMPLE_RATE, FRAMES_PER_BUFFER); /* initialise sinusoidal wavetable */ for( i=0; i<TABLE_SIZE; i++ ) { data.sine[i] = (float) sin( ((double)i/(double)TABLE_SIZE) * M_PI * 2. ); } data.left_phase = data.right_phase = data.sleepTime = 0; err = Pa_Initialize(); if( err != paNoError ) goto error; err = Pa_OpenStream( &stream, paNoDevice,/* default input device */ 0, /* no input */ paFloat32, /* 32 bit floating point input */ NULL, Pa_GetDefaultOutputDeviceID(), /* default output device */ 2, /* stereo output */ paFloat32, /* 32 bit floating point output */ NULL, SAMPLE_RATE, FRAMES_PER_BUFFER, 0, /* number of buffers, if zero then use default minimum */ paClipOff, /* we won't output out of range samples so don't bother clipping them */ patestCallback, &data ); if( err != paNoError ) goto error; err = Pa_StartStream( stream ); if( err != paNoError ) goto error; while( data.sleepTime < (2 * MSEC_PER_BUFFER) ) { printf("SleepTime = %d\n", data.sleepTime ); Pa_Sleep( data.sleepTime ); } printf("Try to stop stream.\n"); err = Pa_StopStream( stream ); /* */ err = Pa_AbortStream( stream ); /* */ if( err != paNoError ) goto error; err = Pa_CloseStream( stream ); if( err != paNoError ) goto error; Pa_Terminate(); printf("Test finished.\n"); return err; error: Pa_Terminate(); fprintf( stderr, "An error occured while using the portaudio stream\n" ); fprintf( stderr, "Error number: %d\n", err ); fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) ); return err; }
JNIEXPORT void JNICALL Java_net_java_sip_communicator_impl_neomedia_portaudio_PortAudio_Pa_1AbortStream (JNIEnv *env, jclass clazz, jlong stream) { PaError errorCode = Pa_AbortStream(((PortAudioStream *) stream)->stream); if (paNoError != errorCode) PortAudio_throwException(env, errorCode); }
int main(void) { PaStreamParameters outputParameters; PaStream *stream; PaError err; paTestData data; int i; printf("PortAudio Test: output sine wave. SR = %d, BufSize = %d\n", SAMPLE_RATE, FRAMES_PER_BUFFER); /* initialise sinusoidal wavetable */ for( i=0; i<TABLE_SIZE; i++ ) { data.sine[i] = (float) sin( ((double)i/(double)TABLE_SIZE) * M_PI * 2. ); } data.left_phase = data.right_phase = data.sleepTime = 0; err = Pa_Initialize(); if( err != paNoError ) goto error; outputParameters.device = Pa_GetDefaultOutputDevice(); /* default output device */ outputParameters.channelCount = 2; /* stereo output */ outputParameters.sampleFormat = paFloat32; /* 32 bit floating point output */ outputParameters.suggestedLatency = Pa_GetDeviceInfo( outputParameters.device )->defaultLowOutputLatency; outputParameters.hostApiSpecificStreamInfo = NULL; err = Pa_OpenStream( &stream, NULL, /* no input */ &outputParameters, SAMPLE_RATE, FRAMES_PER_BUFFER, paClipOff, /* we won't output out of range samples so don't bother clipping them */ patestCallback, &data ); if( err != paNoError ) goto error; err = Pa_StartStream( stream ); if( err != paNoError ) goto error; while( data.sleepTime < (2 * MSEC_PER_BUFFER) ) { printf("SleepTime = %d\n", data.sleepTime ); Pa_Sleep( data.sleepTime ); } printf("Try to stop stream.\n"); err = Pa_StopStream( stream ); /* */ err = Pa_AbortStream( stream ); /* */ if( err != paNoError ) goto error; err = Pa_CloseStream( stream ); if( err != paNoError ) goto error; Pa_Terminate(); printf("Test finished.\n"); return err; error: Pa_Terminate(); fprintf( stderr, "An error occured while using the portaudio stream\n" ); fprintf( stderr, "Error number: %d\n", err ); fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) ); return err; }
// --- Terminate --- bool PortAudioStream::terminate() { fprintf(stderr, "PortAudio --> Termination\n"); Pa_AbortStream(pa_stream); Pa_CloseStream(pa_stream); Pa_Terminate(); return true; }
void PaPlayer::close() { if (m_stream) { Pa_AbortStream( m_stream ); Pa_CloseStream( m_stream ); } m_stream = NULL; m_isPlaying = false; m_playProgress = 0; }
void CEXIMic::StreamStop() { if (pa_stream != nullptr && Pa_IsStreamActive(pa_stream) >= paNoError) Pa_AbortStream(pa_stream); samples_avail = stream_wpos = stream_rpos = 0; delete [] stream_buffer; stream_buffer = nullptr; }
Gear_AudioInput::~Gear_AudioInput() { if (_stream) { Pa_AbortStream(_stream); Pa_CloseStream(_stream); } Pa_Terminate(); pthread_mutex_destroy(_mutex); }
//--------------------------------------------------------- void ofxPortaudioSoundStream::close(){ int err = Pa_AbortStream(audio); if( err != paNoError ) ofLog(OF_LOG_ERROR,"PortAudio close, error: %s\n",Pa_GetErrorText( err )); else cout << "Closed PA stream successfully" << endl; audio = NULL; }
/* * stop portaudio stream capture * args: * audio_ctx - pointer to audio context data * * asserts: * audio_ctx is not null * * returns: error code */ int audio_stop_portaudio(audio_context_t *audio_ctx) { /*assertions*/ assert(audio_ctx != NULL); int ret = 0; int err = paNoError; audio_ctx->stream_flag = AUDIO_STRM_OFF; PaStream *stream = (PaStream *) audio_ctx->stream; /*stops and closes the audio stream*/ if(stream) { if(Pa_IsStreamActive( stream ) > 0) { printf("AUDIO: (portaudio) Aborting audio stream\n"); err = Pa_AbortStream( stream ); } else { printf("AUDIO: (portaudio) Stoping audio stream\n"); err = Pa_StopStream( stream ); } if( err != paNoError ) { fprintf(stderr, "AUDIO: (portaudio) An error occured while stoping the audio stream\n" ); fprintf(stderr, " Error number: %d\n", err ); fprintf(stderr, " Error message: %s\n", Pa_GetErrorText( err ) ); ret = -1; } printf("AUDIO: Closing audio stream...\n"); err = Pa_CloseStream( stream ); if( err != paNoError ) { fprintf(stderr, "AUDIO: (portaudio) An error occured while closing the audio stream\n" ); fprintf(stderr, " Error number: %d\n", err ); fprintf(stderr, " Error message: %s\n", Pa_GetErrorText( err ) ); ret = -1; } } else { fprintf(stderr, "AUDIO: (portaudio) Invalid stream pointer.\n"); ret = -2; } audio_ctx->stream = NULL; return ret; }
AudioController::~AudioController() { PaError error = paNoError; if (_streamIsOpen) Pa_AbortStream(_stream); error = Pa_Terminate(); if (error != paNoError) printf("%s: PaError = %s\n", __PRETTY_FUNCTION__, Pa_GetErrorText(error)); }
void AudioManager::errorAudio() { if (this->_err != paNoError) { this->_run = false; if (this->_streamin) { Pa_AbortStream(this->_streamin); Pa_CloseStream(this->_streamin); } if (this->_streamout) { Pa_AbortStream(this->_streamout); Pa_CloseStream(this->_streamout); } Pa_Terminate(); std::cerr << "Error !" << std::endl; std::cerr << "Error number : " << this->_err << std::endl; std::cerr << "Error message : " << Pa_GetErrorText(this->_err) << std::endl; } }
/** * Function to terminate audio input (disgard buffer) * * @return TRUE on success, FALSE on failure. */ boolean adin_mic_terminate() { PaError err; err = Pa_AbortStream(stream); if (err != paNoError) { jlog("Error: adin_portaudio: failed to terminate stream: %s\n", Pa_GetErrorText(err)); return FALSE; } return TRUE; }
static void do_pa_run(PaDeviceIndex idx, PaTime latency) { PaError err; struct PaStreamParameters param; PaStream *stream = NULL; if(log_len) flow_report(f_log,log_min,log_max,log_len); memset(¶m,0,sizeof(param)); param.device = idx; param.channelCount = 1; param.sampleFormat = paUInt8; param.suggestedLatency = latency; err = Pa_IsFormatSupported(¶m,NULL,rate); do_pa_error(err,"unsupported"); err = Pa_OpenStream(&stream, ¶m, NULL, (double)rate, paFramesPerBufferUnspecified,paNoFlag, /* &do_pa_callback */ NULL, NULL); do_pa_error(err,"open"); err = Pa_StartStream(stream); do_pa_error(err,"start"); while(1) { #if 1 unsigned char buf[128]; FLOW **f = flows; err = Pa_ReadStream(stream,buf,sizeof(buf)); if (err == paInputOverflowed) fprintf(stderr,"Input overflow\n"); else do_pa_error(err, "read"); while(*f) do_pa_callback(buf,NULL,sizeof(buf),NULL,0,*(f++)); #endif err = Pa_IsStreamActive(stream); if (err < 0) do_pa_error(err, "is_active"); if (err == 0) break; #if 0 sleep(60); #endif } err = Pa_AbortStream(stream); do_pa_error(err,"end"); err = Pa_CloseStream(stream); do_pa_error(err,"close"); err = Pa_Terminate(); do_pa_error(err,"exit"); exit(err != 0); }
void Gear_AudioInput::initPortAudio() { std::cout << "Opening PortAudio Stream..." << std::endl; if (_stream) { Pa_AbortStream(_stream); Pa_CloseStream(_stream); } std::cout << Engine::signalInfo().sampleRate() << "hz " << std::endl; int framesPerBuffer = _settings.get(SETTING_FRAMES_PER_BUFFER)->valueInt(); std::cout << "Frames per buffer: " << framesPerBuffer << std::endl; int nbBuffers = _settings.get(SETTING_NB_BUFFERS)->valueInt(); //if nbBuffers is 0, let portaudio set the value if (!nbBuffers) { nbBuffers = Pa_GetMinNumBuffers(framesPerBuffer, Engine::signalInfo().sampleRate()); _settings.get(SETTING_NB_BUFFERS)->valueInt(nbBuffers); } std::cout << "Number of buffers: " << nbBuffers << std::endl; _ringBufferSize = framesPerBuffer; _lBuffer.resize(_ringBufferSize); PaError err = Pa_OpenStream(&_stream, Pa_GetDefaultInputDeviceID(),/* default input device*/ 1, //input paFloat32, NULL, paNoDevice, //no output 0, //mono paFloat32, NULL, Engine::signalInfo().sampleRate(), framesPerBuffer, nbBuffers, /* number of buffers, if zero then use default minimum*/ paClipOff, /* we won't output out of range samples so don't bother clipping them*/ portAudioCallback, this); if (err != paNoError) std::cout << Pa_GetErrorText(err) << std::endl; else std::cout << "Opening PortAudio Stream...done" << std::endl; }
void AudioLoopImplMsw::run() { PaError err = Pa_Initialize(); if (err != paNoError) { fprintf(stderr, "Error message: %s\n", Pa_GetErrorText(err)); return; } PaStreamParameters outputParameters; outputParameters.device = OUTPUT_DEVICE; outputParameters.channelCount = 1; /* MONO output */ outputParameters.sampleFormat = paFloat32; /* 32 bit floating point output */ outputParameters.suggestedLatency = Pa_GetDeviceInfo(outputParameters.device)->defaultLowOutputLatency; outputParameters.hostApiSpecificStreamInfo = NULL; err = Pa_OpenStream( &stream, NULL, /* no input */ &outputParameters, SAMPLE_RATE, FRAMES_PER_BUFFER, paClipOff, /* we won't output out of range samples so don't bother clipping them */ AudioLoopImplMsw::staticQueueCallback, this ); if (err != paNoError) { fprintf(stderr, "Error message: %s\n", Pa_GetErrorText(err) ); return; } initialized = true; // --- err = Pa_StartStream(stream); if (err != paNoError) fprintf(stderr, "Error message: %s\n", Pa_GetErrorText(err)); boost::mutex::scoped_lock lock(mutex); cond.wait(lock); err = Pa_AbortStream(stream); if (err != paNoError) fprintf(stderr, "Error message: %s\n", Pa_GetErrorText(err)); err = Pa_CloseStream(stream); if (err != paNoError) fprintf(stderr, "Error message: %s\n", Pa_GetErrorText(err)); Pa_Terminate(); }
long PortAudio::abort() { if(isStarted) { LOG4CXX_DEBUG(narratorPaLog, "Aborting stream"); mError = Pa_AbortStream(pStream); if(mError != paNoError) LOG4CXX_ERROR(narratorPaLog, "Failed to abort stream: " << Pa_GetErrorText(mError)); ringbuf.flush(); isStarted = false; } return mLatency; }
void pa_close_audio( void) { if (pa_stream) { Pa_AbortStream(pa_stream); Pa_CloseStream(pa_stream); } pa_stream = 0; if (pa_inbuf) free(pa_inbuf), pa_inbuf = 0; if (pa_outbuf) free(pa_outbuf), pa_outbuf = 0; }
void pa_close_audio( void) { if (pa_stream) { Pa_AbortStream(pa_stream); Pa_CloseStream(pa_stream); } pa_stream = 0; #ifdef FAKEBLOCKING if (pa_inbuf) free((char *)pa_inbuf), pa_inbuf = 0; if (pa_outbuf) free((char *)pa_outbuf), pa_outbuf = 0; #endif }
static int pa_stream_abort(lua_State *L) { pa_Stream *stream = NULL; int narg = lua_gettop(L); if(narg == 1 && luaT_isudata(L, 1, "pa.Stream")) stream = luaT_toudata(L, 1, "pa.Stream"); else luaL_error(L, "expected arguments: Stream"); if(!stream->id) luaL_error(L, "attempt to operate on a closed stream"); pa_checkerror(L, Pa_AbortStream(stream->id)); return 0; }
static void fini_stream(MyStream *v, bool abort) { if (v->as) { if (abort) Pa_AbortStream(v->as); else Pa_StopStream(v->as); pthread_cleanup_push(unlock_stream, (void*)v); lock_stream(v); Pa_CloseStream(v->as); v->as = NULL; /* wake up threads waiting to read or write the stream */ if (has_input(v)) pthread_cond_broadcast(&v->in_cond); if (has_output(v)) pthread_cond_broadcast(&v->out_cond); pthread_cleanup_pop(1); } }
paWriter::~paWriter (void) { if ((ostream != NULL) && !Pa_IsStreamStopped (ostream)) { paCallbackReturn = paAbort; (void) Pa_AbortStream (ostream); while (!Pa_IsStreamStopped (ostream)) Pa_Sleep (1); writerRunning = false; } if (ostream != NULL) Pa_CloseStream (ostream); if (portAudio) Pa_Terminate (); delete _O_Buffer; }
audioSink::~audioSink (void) { if ((ostream != NULL) && !Pa_IsStreamStopped (ostream)) { paCallbackReturn = paAbort; (void) Pa_AbortStream (ostream); while (!Pa_IsStreamStopped (ostream)) Pa_Sleep (1); writerRunning = false; } if (ostream != NULL) Pa_CloseStream (ostream); if (portAudio) Pa_Terminate (); delete _O_Buffer; delete[] outTable; streamSelector -> hide (); }
/* Blocks until data can be written. If no data can be written in 2ms*100 the stream gets restarted. returns the amount of data that can be written. */ unsigned int PortAudio::getWriteAvailable() { size_t writeAvailable = 0; int waitCount = 0; int failCount = 0; while( writeAvailable == 0 ) { writeAvailable = ringbuf.getWriteAvailable(); if( writeAvailable == 0 ) { usleep(200000); //200 ms //LOG4CXX_DEBUG(narratorPaLog, "getWriteAvailable = 0, Pa_IsStreamActive = " << Pa_IsStreamActive(pStream)); } if(waitCount++ > 10) { LOG4CXX_ERROR(narratorPaLog, "getWriteAvailable waittime exceeded, restarting stream"); mError = Pa_AbortStream(pStream); // If abortstream fails, try reopening if(failCount++ > 0 || ( mError != paNoError && mError != paStreamIsStopped )) { LOG4CXX_ERROR(narratorPaLog, "Failed to abort stream, trying to close and reopen: " << Pa_GetErrorText(mError)); mError = Pa_CloseStream(pStream); if(mError != paNoError) LOG4CXX_ERROR(narratorPaLog, "Failed to close stream: " << Pa_GetErrorText(mError)); isOpen = false; open(mRate, mChannels); } mError = Pa_StartStream(pStream); if(mError != paNoError) LOG4CXX_ERROR(narratorPaLog, "Failed to start stream: " << Pa_GetErrorText(mError)); isStarted = true; waitCount = 0; } } //LOG4CXX_DEBUG(narratorPaLog, "getWriteAvailable = " << writeAvailable << ", Pa_IsStreamActive = " << Pa_IsStreamActive(pStream)); return writeAvailable; }