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