int main( void ) { PaStreamParameters outputParameters; PaError pa_err; SF_INFO sfinfo; signal( SIGINT, interrupt ); gen_default_drums(); pa_err = Pa_Initialize(); outputParameters.device = Pa_GetDefaultOutputDevice(); outputParameters.channelCount = CHANNELS; outputParameters.sampleFormat = paFloat32; outputParameters.suggestedLatency = Pa_GetDeviceInfo( outputParameters.device )->defaultLowOutputLatency; outputParameters.hostApiSpecificStreamInfo = NULL; pa_err = Pa_OpenStream( &stream, NULL, &outputParameters, SAMPLE_RATE, BUFFER_SIZE, paClipOff, audio_callback, NULL ); sfinfo.samplerate = SAMPLE_RATE; sfinfo.channels = CHANNELS; sfinfo.format = SF_FORMAT_WAV | SF_FORMAT_FLOAT; wave_output = sf_open( OUTPUT_FILE, SFM_WRITE, &sfinfo ); srand( time( 0 ) ); bass_z = 0.0f; bass_freq = midi_to_hz( BASE_NOTE ); pa_err = Pa_StartStream( stream ); while( 1 ) Pa_Sleep( 1000 ); sf_close( wave_output ); pa_err = Pa_StopStream( stream ); pa_err = Pa_CloseStream( stream ); Pa_Terminate(); return 0; }
audioSink::~audioSink (void) { if ((ostream != NULL) && !Pa_IsStreamStopped (ostream)) { paCallbackReturn = paAbort; (void) Pa_AbortStream (ostream); while (!Pa_IsStreamStopped (ostream)) Pa_Sleep (1); writerRunning = false; } writerRunning = false; if (ostream != NULL) Pa_CloseStream (ostream); ostream = NULL; if (portAudio) Pa_Terminate (); delete _O_Buffer; delete[] outTable; }
/* * delete_fluid_portaudio_driver */ int delete_fluid_portaudio_driver(fluid_audio_driver_t *p) { fluid_portaudio_driver_t* dev; PaError err; dev = (fluid_portaudio_driver_t*)p; if (dev == NULL) return FLUID_OK; /* PortAudio section */ if (dev->stream) Pa_CloseStream (dev->stream); err = Pa_Terminate(); if (err != paNoError) printf ("PortAudio termination error: %s\n", Pa_GetErrorText (err) ); FLUID_FREE (dev); return FLUID_OK; }
//----------------------------------------------------------------------------- // Name: void stop_portAudio() // Desc: //Stops Port Audio //----------------------------------------------------------------------------- void stop_portAudio() { PaError err; /* Stop audio stream */ err = Pa_StopStream( g_stream ); if (err != paNoError) { printf( "PortAudio error: stop stream: %s\n", Pa_GetErrorText(err)); } /* Close audio stream */ err = Pa_CloseStream(g_stream); if (err != paNoError) { printf("PortAudio error: close stream: %s\n", Pa_GetErrorText(err)); } /* Terminate audio stream */ err = Pa_Terminate(); if (err != paNoError) { printf("PortAudio error: terminate: %s\n", Pa_GetErrorText(err)); } }
int AudioStreamManager::StopAudio() { PaError err; err = Pa_CloseStream(audioStream); if (err != paNoError) goto error; soundDelegate->didEndPlay(); printf("Finished. gNumNoInputs = %d\n", numNoInputs); Pa_Terminate(); return 0; 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)); soundDelegate->didEndPlay(); return -1; }
static void uninit(struct ao *ao, bool cut_audio) { struct priv *priv = ao->priv; if (priv->stream) { if (!cut_audio && Pa_IsStreamActive(priv->stream) == 1) { pthread_mutex_lock(&priv->ring_mutex); priv->play_remaining = true; pthread_mutex_unlock(&priv->ring_mutex); check_pa_ret(Pa_StopStream(priv->stream)); } check_pa_ret(Pa_CloseStream(priv->stream)); } pthread_mutex_destroy(&priv->ring_mutex); Pa_Terminate(); }
bool PaInstance::stopStream () { PaError error; error = Pa_StopStream(mAudioStream); if (error != paNoError) { errorHandler(error); return false; } error = Pa_CloseStream(mAudioStream); if (error != paNoError) { errorHandler(error); return false; } return true; }
/* 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; }
void AudioDevice::addCallback(AudioProcessor *audioProcessor_) { audioProcessor = audioProcessor_; audioProcessor->setNumInputChannels(numInputs); audioProcessor->setNumOutputChannels(numOutputs); audioProcessor->setSampleRate(sampleRate); audioProcessor->setBufferSize(bufferSize); audioProcessor->prepareToPlay(sampleRate, bufferSize); if(stream) { Pa_StopStream(&stream); Pa_CloseStream(&stream); } err = Pa_OpenStream(&stream, &inputParameters, &outputParameters, sampleRate, bufferSize, paClipOff, &callback, audioProcessor); if( err != paNoError ) { std::cout<<"Couldn't open stream"<<std::endl; std::cout<< "Error message: "<< Pa_GetErrorText( err )<<std::endl; } std::cout<< "Error message: "<< Pa_GetErrorText( err )<<std::endl; err = Pa_StartStream( stream ); if( err != paNoError ) { std::cout<<"Couldn't start stream"<<std::endl; std::cout<< "Error message: "<< Pa_GetErrorText( err )<<std::endl; } }
//void* play_sound(void* void_input) { void* play_sound(void* void_input) { (void) void_input; PaStream *stream; printf("PortAudio Test: output sawtooth wave.\n"); /* Initialize our data for use by callback. */ data.left_phase = data.right_phase = 0.0; /* Initialize library before making any other calls. */ err = Pa_Initialize(); if( err != paNoError ) goto error; /* Open an audio I/O stream. */ err = Pa_OpenDefaultStream( &stream, 0, /* no input channels */ 2, /* stereo output */ paFloat32, /* 32 bit floating point output */ SAMPLE_RATE, 256, /* frames per buffer */ patestCallback, &data ); if( err != paNoError ) goto error; err = Pa_StartStream( stream ); if( err != paNoError ) goto error; /* Sleep for several seconds. */ Pa_Sleep(NUM_SECONDS*1000); err = Pa_StopStream( stream ); if( err != paNoError ) goto error; err = Pa_CloseStream( stream ); if( err != paNoError ) goto error; Pa_Terminate(); printf("Test finished.\n"); return NULL; 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 NULL; }
int PortAudioRecordBackend::closeVuMeterStream() { int err; if(vuMeterStream != NULL) { err = Pa_StopStream(vuMeterStream); if(err != paNoError) { qDebug("Error stopping stream:\n %s", Pa_GetErrorText(err)); return -1; } err = Pa_CloseStream(vuMeterStream); if(err != paNoError) { qDebug("Error closing stream:\n %s", Pa_GetErrorText(err)); return -2; } vuMeterStream = NULL; } return 0; }
bool AudioCapture<T>::release() { if ( stream ) { res = Pa_CloseStream( stream ); if ( res != paNoError ) { std::cerr << "ストリームを閉じれませんでした: " << Pa_GetErrorText( res ) << std::endl; return false; } stream = NULL; } res = Pa_Terminate(); if ( res != paNoError ) { std::cerr << "PortAudioの解放に失敗: " << Pa_GetErrorText( res ) << std::endl; return false; } }
void AudioCapturePortAudio::uninitialize() { Q_ASSERT(stream != NULL); PaError err; /* -- Now we stop the stream -- */ err = Pa_StopStream( stream ); if( err != paNoError ) qDebug() << "PortAudio error: " << Pa_GetErrorText( err ); /* -- don't forget to cleanup! -- */ err = Pa_CloseStream( stream ); if( err != paNoError ) qDebug() << "PortAudio error: " << Pa_GetErrorText( err ); stream = NULL; err = Pa_Terminate(); if( err != paNoError ) qDebug() << "PortAudio error: " << Pa_GetErrorText( err ); }
void snd_close(void) { Pa_StopStream(stream); Pa_CloseStream(stream); Pa_Terminate(); free((void*) srconv_stream.data_in); free(srconv_stream.data_out); free((void*) srconv_record.data_in); free(srconv_record.data_out); free(pa_pcm_buf); free(encode_buf); delete[] stream_buf; delete[] record_buf; stream_buf = record_buf = nullptr; delete dsp; dsp = nullptr; }
void CPaCommon::Close() { if (stream) { int err = Pa_AbortStream(stream); if (err != paNoError) { cout << "PortAudio error: " << Pa_GetErrorText(err) << endl; } err = Pa_CloseStream(stream); if (err != paNoError) { cout << "PortAudio error: " << Pa_GetErrorText(err) << endl; } stream = NULL; device_changed = true; } }
void CVoiceRecorder::DeInit(void) { if (m_bEnabled) { m_bEnabled = false; Pa_CloseStream(m_pAudioStream); Pa_Terminate(); // Assumes now that PACallback will not be called in this context m_CS.Lock(); m_CS.Unlock(); // Assumes now that PACallback is not executing in this context m_pAudioStream = NULL; m_iSpeexOutgoingFrameSampleCount = 0; speex_encoder_destroy(m_pSpeexEncoderState); m_pSpeexEncoderState = NULL; speex_preprocess_state_destroy(m_pSpeexPreprocState); m_pSpeexPreprocState = NULL; free(m_pOutgoingBuffer); m_pOutgoingBuffer = NULL; m_VoiceState = VOICESTATE_AWAITING_INPUT; m_SampleRate = SAMPLERATE_WIDEBAND; m_pAudioStream = NULL; m_iSpeexOutgoingFrameSampleCount = 0; m_uiOutgoingReadIndex = 0; m_uiOutgoingWriteIndex = 0; m_bIsSendingVoiceData = false; m_ulTimeOfLastSend = 0; m_uiBufferSizeBytes = 0; } }
PaError TestPlayback( paTestData *dataPtr ) { PortAudioStream *stream; PaError err; int i; /* Playback recorded data. */ dataPtr->frameIndex = 0; printf("Begin playback.\n"); fflush(stdout); err = Pa_OpenStream( &stream, paNoDevice, 0, /* NO input */ PA_SAMPLE_TYPE, NULL, Pa_GetDefaultOutputDeviceID(), dataPtr->samplesPerFrame, /* stereo output */ PA_SAMPLE_TYPE, NULL, SAMPLE_RATE, FRAMES_PER_BUFFER, /* 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 */ playCallback, dataPtr ); if( err != paNoError ) goto error; err = Pa_StartStream( stream ); if( err != paNoError ) goto error; printf("Waiting for playback to finish.\n"); fflush(stdout); for( i=0; i<(NUM_SECONDS*1000/SLEEP_DUR_MSEC); i++ ) { Pa_Sleep(100); printf("index = %d\n", dataPtr->frameIndex ); } err = Pa_CloseStream( stream ); if( err != paNoError ) goto error; error: return err; }
int main( int argc, char * argv[] ) { FILE * file = 0; size_t size = 0; void * data = 0; openmpt_module * mod = 0; size_t count = 0; PaStream * stream = 0; PaStreamParameters streamparameters; memset( &streamparameters, 0, sizeof( PaStreamParameters ) ); (void)argc; file = fopen( argv[1], "rb" ); fseek( file, 0, SEEK_END ); size = ftell( file ); fseek( file, 0, SEEK_SET ); data = malloc( size ); size = fread( data, 1, size, file ); fclose( file ); mod = openmpt_module_create_from_memory( data, size, NULL, NULL, NULL ); free( data ); Pa_Initialize(); streamparameters.device = Pa_GetDefaultOutputDevice(); streamparameters.channelCount = 2; streamparameters.sampleFormat = paInt16 | paNonInterleaved; streamparameters.suggestedLatency = Pa_GetDeviceInfo( streamparameters.device )->defaultHighOutputLatency; Pa_OpenStream( &stream, NULL, &streamparameters, SAMPLERATE, paFramesPerBufferUnspecified, 0, NULL, NULL ); Pa_StartStream( stream ); while ( 1 ) { count = openmpt_module_read_stereo( mod, SAMPLERATE, BUFFERSIZE, left, right ); if ( count == 0 ) { break; } Pa_WriteStream( stream, buffers, count ); } Pa_StopStream( stream ); Pa_CloseStream( stream ); Pa_Terminate(); openmpt_module_destroy( mod ); return 0; }
int main(void) { PortAudioStream *stream; PaError err; err = Pa_Initialize(); if( err != paNoError ) goto error; err = Pa_OpenStream( &stream, Pa_GetDefaultInputDeviceID(), /* default output device */ 2, /* stereo input */ PA_SAMPLE_TYPE, NULL, Pa_GetDefaultOutputDeviceID(), /* default output device */ 2, /* stereo output */ PA_SAMPLE_TYPE, NULL, SAMPLE_RATE, 64, /* 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 */ fuzzCallback, NULL ); if( err != paNoError ) goto error; err = Pa_StartStream( stream ); if( err != paNoError ) goto error; printf("Hit ENTER to stop program.\n"); getchar(); err = Pa_CloseStream( stream ); if( err != paNoError ) goto error; printf("Finished. gNumNoInputs = %d\n", gNumNoInputs ); Pa_Terminate(); return 0; 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 -1; }
int AudioRecorder::stop() { PaError err; if (recording_status_ != STOPPED && stream_) { err = Pa_StopStream( stream_ ); if(err != paNoError) { HANDLE_PA_ERROR(err); } } if (stream_) { err = Pa_CloseStream( stream_ ); if(err != paNoError) { HANDLE_PA_ERROR(err); } stream_ = 0; } Pa_Terminate(); return 0; }
void DevicePortAudio::deviceInputClose() { if( mStreamInput ) { Pa_CloseStream( mStreamInput ); mStreamInput = nullptr; } for( AudioBuffer &AB : mAudioBuffers ) { for( int i = 0 ; i < AB.mChannels ; i++ ) { delete [] AB.mData[ i ]; } delete [] AB.mData; } mInputTimeLatency = 0; mInputChannelCount = 0; }
RTC::ReturnCode_t PortAudioInput::onDeactivated(RTC::UniqueId ec_id) { RTC_DEBUG(("onDeactivated start")); is_active = false; m_mutex.lock(); RTC_DEBUG(("onDeactivated:mutex lock")); try { if ( m_stream ) { if ( !Pa_IsStreamStopped( m_stream ) ) { m_err = Pa_AbortStream( m_stream ); if ( m_err != paNoError ) { throw m_err; } } #ifdef HAVE_LIBPORTMIXER Px_CloseMixer(m_mixer); #elif defined(__linux) if ( m_fd > 0 ) { close( m_fd ); m_fd = -1; } #endif 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 onDeactivated:%s", error_str.c_str())); return RTC::RTC_ERROR; } m_mutex.unlock(); RTC_DEBUG(("onDeactivated:mutex unlock")); RTC_DEBUG(("onDeactivated finish")); return RTC::RTC_OK; }
int closePA() { /* Stop playback */ err = Pa_StopStream( stream ); if( err != paNoError ) goto error; /* Close the stream */ err = Pa_CloseStream( stream ); if( err != paNoError ) goto error; /* Terminate PortAudio */ err = Pa_Terminate(); if( err != paNoError ) goto error; printf("PortAudio terminated.\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; }
static int portaudio_destroy () { g_message ("Destroying PortAudio backend"); ready = FALSE; PaError err; err = Pa_CloseStream (stream); if (err != paNoError) { g_warning ("Closing stream failed: %d, %s", err, Pa_GetErrorText (err)); return -1; } Pa_Terminate (); #ifdef _HAVE_FLUIDSYNTH_ fluidsynth_shutdown (); #endif return 0; }
void PAudioStream::run() { PaError error = paNoError; AudioBridge::output_buffer buff; error = Pa_OpenStream(&_stream, &_inputParam, &_outputParam, SAMPLE_RATE, FRAMES_PER_BUFFER, paClipOff, PAudioBuffer::streamCallBack, _buffer); if (error != paNoError) return ; if (Pa_StartStream(_stream) != paNoError) return ; qDebug() << QThread::currentThreadId() << "RECORDING, SPEAK INTO THE MICROPHONE PLEASE"; _start = true; while (_start && (error = Pa_IsStreamActive(_stream)) == 1) { // lock(audioLock); // if (record.empty() && play.empty()) // waitCondition(dataAvailable); // unlock(audioLock); // _buffer->sendToNetwork(); // _buffer->feed(); } if (Pa_IsStreamActive(_stream) == 1) Pa_StopStream(_stream); qDebug() << QThread::currentThreadId() << "RECORDING ENDED"; if (error < 0) return; if ((error = Pa_CloseStream(_stream)) != paNoError) { std::cout << "PAudioStream::run(): " << Pa_GetErrorText(error) << std::endl; return; } if ((error = Pa_Terminate()) != paNoError) { std::cout << "PAudioStream::run(): " << Pa_GetErrorText(error) << std::endl; return; } }
void PaTestEngine::record() { // Open output file if (filename) ((fid = fopen(filename, "wb"))) ? printf("Opened file '%s' for output.", filename) : printf("Could not open file '%s' for output.", filename); // Set output parameters selectDefaultInputParameters(); // Record some audio. -------------------------------------------- err = Pa_OpenStream( &stream, inputParameters, NULL, //&outputParameters SAMPLE_RATE, FRAMES_PER_BUFFER, paClipOff, // we won't output out of range samples so don't bother clipping them recordCallbackWrapper, this ); checkPaError(); err = Pa_StartStream( stream ); checkPaError(); printf("\n=== Now recording!! Please speak into the microphone. ===\n"); fflush(stdout); // Wait for stream to finish getchar(); err = Pa_CloseStream( stream ); checkPaError(); if (fid) { fclose( fid ); printf("Wrote data to '%s'\n", filename); } }
int main(int argc, char **argv) { ctss_init(&synth); if (argc == 2) { ctss_vm_interpret_file(&synth.vm, argv[1], 4096); PaStream *stream; Pa_Initialize(); PaError err = Pa_OpenDefaultStream( &stream, 0, 1, paFloat32, CTSS_SAMPLE_RATE, 256, render_synth, NULL); if (err == paNoError) { err = Pa_StartStream(stream); if (err == paNoError) { // repl(&synth.vm); fgetc(stdin); Pa_StopStream(stream); Pa_CloseStream(stream); } } Pa_Terminate(); } else { repl(&synth.vm); } return 0; }
int DriverExit(){ PaError err=0; err = Pa_StopStream(stream); if (err!=paNoError) { #ifdef DEBUG printf( "PortAudio error: %s\n", Pa_GetErrorText( err ) ); #endif return 1; } err = Pa_CloseStream( stream ); if( err != paNoError ){ #ifdef DEBUG printf( "PortAudio error: %s\n", Pa_GetErrorText( err ) ); #endif } err = Pa_Terminate(); if( err != paNoError ){ #ifdef DEBUG printf( "PortAudio error: %s\n", Pa_GetErrorText( err ) ); #endif } return 0; }
bool test_open(const char *device, unsigned rates[]) { PaStreamParameters outputParameters; PaError err; unsigned ref[] TEST_RATES; int device_id, i, ind; if ((device_id = pa_device_id(device)) == -1) { LOG_INFO("device %s not found", device); return false; } outputParameters.device = device_id; outputParameters.channelCount = 2; outputParameters.sampleFormat = paInt32; outputParameters.suggestedLatency = output.latency ? (double)output.latency/(double)1000 : Pa_GetDeviceInfo(outputParameters.device)->defaultHighOutputLatency; outputParameters.hostApiSpecificStreamInfo = NULL; // check supported sample rates // Note use Pa_OpenStream as it appears more reliable than Pa_IsFormatSupported on some windows apis for (i = 0, ind = 0; ref[i]; ++i) { err = Pa_OpenStream(&pa.stream, NULL, &outputParameters, (double)ref[i], paFramesPerBufferUnspecified, paNoFlag, pa_callback, NULL); if (err == paNoError) { Pa_CloseStream(pa.stream); rates[ind++] = ref[i]; } } if (!rates[0]) { LOG_WARN("no available rate found"); return false; } pa.stream = NULL; return true; }
int main(int argc, char** argv) { CHECK(argc > 1); wavfile = fopen(argv[1], "r"); CHECK(wavfile != NULL); CHECK(freadStr(wavfile, 4) == "RIFF"); uint32_t wavechunksize = freadNum<uint32_t>(wavfile); CHECK(freadStr(wavfile, 4) == "WAVE"); while(true) { std::string chunkName = freadStr(wavfile, 4); uint32_t chunkLen = freadNum<uint32_t>(wavfile); if(chunkName == "fmt ") readFmtChunk(chunkLen); else if(chunkName == "data") { CHECK(sampleRate != 0); CHECK(numChannels > 0); CHECK(bytesPerSample > 0); printf("len: %.0f secs\n", double(chunkLen) / sampleRate / numChannels / bytesPerSample); break; // start playing now } else { // skip chunk CHECK(fseek(wavfile, chunkLen, SEEK_CUR) == 0); } } printf("start playing...\n"); CHECK(portAudioOpen()); // wait until stream has finished playing while(Pa_IsStreamActive(stream) > 0) usleep(1000); printf("finished\n"); fclose(wavfile); Pa_CloseStream(stream); Pa_Terminate(); }