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