static int portaudio_load_default (portaudio_driver_t *driver,
int numDevices,
int capturing,
int playing,
int* inputDeviceID,
int* outputDeviceID)
{
const PaDeviceInfo *pdi;
int i,j;
int found = 0;
PALog("Look for default driver\n");
*inputDeviceID = Pa_GetDefaultInputDeviceID();
*outputDeviceID = Pa_GetDefaultOutputDeviceID();
for(i=0; i<numDevices; i++)
{
pdi = Pa_GetDeviceInfo(i);
PALog("---------------------------------------------- #%d\n", i);
if (i == Pa_GetDefaultInputDeviceID()) {
driver->capture_nchannels = (capturing) ? pdi->maxInputChannels : 0;
strcpy (driver->driver_name,pdi->name);
found = 1;
}
if (i == Pa_GetDefaultOutputDeviceID()){
driver->playback_nchannels = (playing) ? pdi->maxOutputChannels : 0;
strcpy (driver->driver_name,pdi->name);
found = 1;
}
PALog("\nName = %s\n", pdi->name);
PALog("Max Inputs = %d ", pdi->maxInputChannels);
PALog("Max Outputs = %d\n", pdi->maxOutputChannels);
if( pdi->numSampleRates == -1 ){
PALog("Sample Rate Range = %f to %f\n", pdi->sampleRates[0], pdi->sampleRates[1]);
}else{
PALog("Sample Rates =");
for(j=0; j<pdi->numSampleRates; j++){
PALog(" %8.2f,", pdi->sampleRates[j]);
}
PALog("\n");
}
PALog("Native Sample Formats = ");
if (pdi->nativeSampleFormats & paInt8) PALog("paInt8, ");
if (pdi->nativeSampleFormats & paUInt8) PALog("paUInt8, ");
if (pdi->nativeSampleFormats & paInt16) PALog("paInt16, ");
if (pdi->nativeSampleFormats & paInt32) PALog("paInt32, ");
if (pdi->nativeSampleFormats & paFloat32) PALog("paFloat32, ");
if (pdi->nativeSampleFormats & paInt24) PALog("paInt24, ");
if (pdi->nativeSampleFormats & paPackedInt24) PALog("paPackedInt24, ");
PALog("\n");
}
return found;
}
int main(void)
{
PortAudioStream *stream;
PaError err;
err = Pa_Initialize();
if( err != paNoError ) goto error;
printf("PortAudio Test: input device ID = %d\n", Pa_GetDefaultInputDeviceID() );
printf("PortAudio Test: output device ID = %d\n", Pa_GetDefaultOutputDeviceID() );
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,
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 */
wireCallback,
NULL ); /* no data */
if( err != paNoError ) goto error;
err = Pa_StartStream( stream );
if( err != paNoError ) goto error;
printf("Full duplex sound test in progress.\n");
printf("Hit ENTER to exit test.\n"); fflush(stdout);
getchar();
printf("Closing stream.\n");
err = Pa_CloseStream( stream );
if( err != paNoError ) goto error;
Pa_Terminate();
printf("Full duplex sound test complete.\n"); fflush(stdout);
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 main( int argc, char** argv) {
std::ifstream m_f1;
std::string in, out, fat;
if( argc == 2 ) {
fat = "none";
in = argv[1];
} else if( argc == 3 ) {
fat = argv[1];
in = argv[2];
} else {
std::cout << "Usage: " << argv[0] << " [fat_file] input_file" << std::endl;
return EXIT_FAILURE;
}
Adpcm file(in,fat);
PaError pa_err=Pa_Initialize();
PaStream *stream;
pa_err = Pa_OpenStream(&stream, paNoDevice, 0, paInt16, NULL, \
Pa_GetDefaultOutputDeviceID(), \
2, paInt16, NULL, 48000, 1234, 0, 0, \
c_callback, &file.audioQueue);
pa_err=Pa_StartStream(stream);
while( !file.finished() || file.audioQueue.size() > 0) {
sleep(1);
}
pa_err=Pa_CloseStream(stream);
pa_err=Pa_Terminate();
return EXIT_SUCCESS;
}
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 * 4; // 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.,
// 22050, /* half second buffers */
// 4, /* four buffers */
512, /* half second buffers */
0, /* four 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;
}
static int TestBadActions( void )
{
PortAudioStream *stream = NULL;
PaError result;
PaQaData myData;
/* Setup data for synthesis thread. */
myData.framesLeft = (unsigned long) (SAMPLE_RATE * 100); /* 100 seconds */
myData.numChannels = 1;
myData.mode = MODE_OUTPUT;
/* Default output. */
EXPECT( "TestBadActions", ((result = Pa_OpenStream(
&stream,
paNoDevice, 0, paFloat32, NULL,
Pa_GetDefaultOutputDeviceID(), 2, paFloat32, NULL,
SAMPLE_RATE, FRAMES_PER_BUFFER, NUM_BUFFERS,
paClipOff,
QaCallback,
&myData )
) == 0) );
HOPEFOR( "start", ((result = Pa_StartStream( NULL )) == paBadStreamPtr) );
HOPEFOR( "stop", ((result = Pa_StopStream( NULL )) == paBadStreamPtr) );
HOPEFOR( "active?", ((result = Pa_StreamActive( NULL )) == paBadStreamPtr) );
HOPEFOR( "close", ((result = Pa_CloseStream( NULL )) == paBadStreamPtr) );
HOPEFOR( "time?", ((result = (PaError)Pa_StreamTime( NULL )) != 0) );
HOPEFOR( "CPULoad?", ((result = (PaError)Pa_GetCPULoad( NULL )) != 0) );
error:
if( stream != NULL ) Pa_CloseStream( stream );
return result;
}
int main(void)
{
int i,j;
int numDevices;
const PaDeviceInfo *pdi;
PaError err;
Pa_Initialize();
numDevices = Pa_CountDevices();
if( numDevices < 0 )
{
printf("ERROR: Pa_CountDevices returned 0x%x\n", numDevices );
err = numDevices;
goto error;
}
printf("Number of devices = %d\n", numDevices );
for( i=0; i<numDevices; i++ )
{
pdi = Pa_GetDeviceInfo( i );
printf("---------------------------------------------- #%d", i );
if( i == Pa_GetDefaultInputDeviceID() ) printf(" DefaultInput");
if( i == Pa_GetDefaultOutputDeviceID() ) printf(" DefaultOutput");
printf("\nName = %s\n", pdi->name );
printf("Max Inputs = %d", pdi->maxInputChannels );
printf(", Max Outputs = %d\n", pdi->maxOutputChannels );
if( pdi->numSampleRates == -1 )
{
printf("Sample Rate Range = %f to %f\n", pdi->sampleRates[0], pdi->sampleRates[1] );
}
else
{
printf("Sample Rates =");
for( j=0; j<pdi->numSampleRates; j++ )
{
printf(" %8.2f,", pdi->sampleRates[j] );
}
printf("\n");
}
printf("Native Sample Formats = ");
if( pdi->nativeSampleFormats & paInt8 ) printf("paInt8, ");
if( pdi->nativeSampleFormats & paUInt8 ) printf("paUInt8, ");
if( pdi->nativeSampleFormats & paInt16 ) printf("paInt16, ");
if( pdi->nativeSampleFormats & paInt32 ) printf("paInt32, ");
if( pdi->nativeSampleFormats & paFloat32 ) printf("paFloat32, ");
if( pdi->nativeSampleFormats & paInt24 ) printf("paInt24, ");
if( pdi->nativeSampleFormats & paPackedInt24 ) printf("paPackedInt24, ");
printf("\n");
}
Pa_Terminate();
printf("----------------------------------------------\n");
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 err;
}
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;
}
static int
portaudio_driver_set_parameters (portaudio_driver_t* driver,
jack_nframes_t nframes,
jack_nframes_t rate)
{
int capturing = driver->capturing;
int playing = driver->playing;
int err = Pa_OpenStream(
&driver->stream,
((capturing) ? Pa_GetDefaultInputDeviceID() : paNoDevice),
((capturing) ? driver->capture_nchannels : 0),
paFloat32, /* 32-bit float input */
NULL,
((playing) ? Pa_GetDefaultOutputDeviceID() : paNoDevice),
((playing) ? driver->playback_nchannels : 0),
paFloat32, /* 32-bit float output */
NULL,
rate, /* sample rate */
nframes, /* frames per buffer */
0, /* number of buffers = default min */
paClipOff, /* we won't output out of
* range samples so don't
* bother clipping them */
paCallback,
driver);
if (err == paNoError) {
driver->period_usecs = (((float) driver->frames_per_cycle)
/ driver->frame_rate) * 1000000.0f;
driver->frame_rate = rate;
driver->frames_per_cycle = nframes;
/* tell engine about buffer size */
if (driver->engine) {
if (driver->engine->set_buffer_size (
driver->engine, driver->frames_per_cycle)) {
jack_error ("portaudio: cannot set engine buffer size to %d (check MIDI)", driver->frames_per_cycle);
return -1;
}
}
return 0;
} else {
// JOQ: this driver is dead. How do we terminate it?
Pa_Terminate();
jack_error("Unable to set portaudio parameters");
jack_error("Error number: %d", err);
jack_error("Error message: %s", Pa_GetErrorText(err));
return EIO;
}
}
int main(void)
{
PortAudioStream *stream;
PaError err;
paTestData data = {0};
double load;
printf("PortAudio Test: output sine wave. SR = %d, BufSize = %d\n", SAMPLE_RATE, FRAMES_PER_BUFFER);
/* initialise sinusoidal wavetable */
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 */
1, /* mono output */
paFloat32, /* 32 bit floating point output */
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 */
patestCallback,
&data );
if( err != paNoError ) goto error;
err = Pa_StartStream( stream );
if( err != paNoError ) goto error;
do
{
data.numSines++;
Pa_Sleep( 200 );
load = Pa_GetCPULoad( stream );
printf("numSines = %d, CPU load = %f\n", data.numSines, load );
} while( load < 0.8 );
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 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;
}
int main(void)
{
PortAudioStream *stream;
PaError err;
paTestData data;
int totalSamps;
printf("PortAudio Test: output " FORMAT_NAME "\n");
data.left_phase = data.right_phase = 0.0;
data.framesToGo = totalSamps = NUM_SECONDS * SAMPLE_RATE; /* Play for a few seconds. */
err = Pa_Initialize();
if( err != paNoError ) goto error;
err = Pa_OpenStream(
&stream,
paNoDevice,/* default input device */
0, /* no input */
TEST_FORMAT,
NULL,
Pa_GetDefaultOutputDeviceID(), /* default output device */
2, /* stereo output */
TEST_FORMAT,
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;
printf("Waiting %d seconds for sound to finish.\n", NUM_SECONDS );
while( Pa_StreamActive( stream ) ) Pa_Sleep(10);
err = Pa_CloseStream( stream );
if( err != paNoError ) goto error;
Pa_Terminate();
printf("PortAudio Test Finished: " FORMAT_NAME "\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;
}
PaError TestPlayback( paTestData *dataPtr )
{
PaError err;
int i;
int lastIndex = 0;
/* Playback recorded data. */
dataPtr->frameIndex = 0;
printf("Begin playback.\n"); fflush(stdout);
/* Open output stream if not already open. */
if( dataPtr->outputStream == NULL )
{
err = Pa_OpenStream(
&dataPtr->outputStream,
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( dataPtr->outputStream );
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++ )
{
int frameIndex, delta;
Pa_Sleep(SLEEP_DUR_MSEC);
frameIndex = dataPtr->frameIndex;
delta = frameIndex - lastIndex;
lastIndex = frameIndex;
printf("index = %d, delta = %d\n", frameIndex, delta ); fflush(stdout);
}
err = Pa_StopStream( dataPtr->outputStream );
if( err != paNoError ) goto error;
error:
return err;
}
PaError TestOnce( int buffersize )
{
PortAudioStream *stream;
PaError err;
paTestData data;
int i;
int totalSamps;
/* initialise sinusoidal wavetable */
for( i=0; i<TABLE_SIZE; i++ )
{
data.sine[i] = (short) (30000.0 * sin( ((double)i/(double)TABLE_SIZE) * M_PI * 2. ));
}
data.left_phase = data.right_phase = 0;
data.sampsToGo = totalSamps = NUM_SECONDS * SAMPLE_RATE; /* Play for a few seconds. */
err = Pa_Initialize();
if( err != paNoError ) goto error;
err = Pa_OpenStream(
&stream,
paNoDevice,/* default input device */
0, /* no input */
paInt16, /* sample format */
NULL,
Pa_GetDefaultOutputDeviceID(), /* default output device */
2, /* stereo output */
paInt16, /* sample format */
NULL,
SAMPLE_RATE,
buffersize, /* 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 */
paSineCallback,
&data );
if( err != paNoError ) goto error;
err = Pa_StartStream( stream );
if( err != paNoError ) goto error;
printf("Waiting for sound to finish.\n");
fflush(stdout);
Pa_Sleep(1000);
err = Pa_CloseStream( stream );
if( err != paNoError ) goto error;
Pa_Terminate();
return paNoError;
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;
}
long TPortAudioRenderer::OpenDefault(long inChan, long outChan, long bufferSize, long sampleRate)
{
PaError err;
const PaDeviceInfo* pdi;
int numDevices;
int inDevice;
int outDevice;
printf("Opening device : inChan: %ld outChan: %ld bufferSize: %ld sampleRate: %ld\n",
inChan, outChan, bufferSize, sampleRate);
numDevices = Pa_CountDevices();
if (numDevices < 0) {
printf("ERROR: Pa_CountDevices returned 0x%x\n", numDevices);
err = numDevices;
printf("Error while opening device: device open error %s\n", Pa_GetErrorText(err));
fStream = 0;
return OPEN_ERR;
} else {
DisplayDevices();
}
// Compute input and output number : to be checked
inDevice = Pa_GetDefaultInputDeviceID();
pdi = Pa_GetDeviceInfo(inDevice);
if (pdi != 0) {
if (pdi->maxInputChannels == 0) {
inDevice = GetFirstValidInputDevice();
pdi = Pa_GetDeviceInfo(inDevice);
}
inChan = (inChan < pdi->maxInputChannels) ? inChan : pdi->maxInputChannels;
printf("Input channel number %ld\n", inChan);
}
outDevice = Pa_GetDefaultOutputDeviceID();
pdi = Pa_GetDeviceInfo(outDevice);
if (pdi != 0) {
if (pdi->maxOutputChannels == 0) {
outDevice = GetFirstValidOutputDevice();
pdi = Pa_GetDeviceInfo(outDevice);
}
outChan = (outChan < pdi->maxOutputChannels) ? outChan : pdi->maxOutputChannels;
printf("Output channel number %ld\n", outChan);
}
return Open(inDevice, outDevice, inChan, outChan, bufferSize, sampleRate);
}
static const PaDeviceInfo *select_device(const char *device)
{
#if (USE_PORTAUDIO == 19)
int numDevices = Pa_GetDeviceCount();
#else
int numDevices = Pa_CountDevices();
#endif
if (numDevices < 0)
return NULL;
#if (USE_PORTAUDIO == 19)
PaDeviceIndex i = 0, selectedIndex = 0;
#else
PaDeviceID i = 0, selectedIndex = 0;
#endif
const PaDeviceInfo *deviceInfo = NULL;
const PaDeviceInfo *selectedDeviceInfo = NULL;
if (option_device_number >= 0) {
selectedIndex = option_device_number;
selectedDeviceInfo = Pa_GetDeviceInfo(selectedIndex);
}
if (device == NULL) {
#if (USE_PORTAUDIO == 19)
selectedIndex = Pa_GetDefaultOutputDevice();
#else
selectedIndex = Pa_GetDefaultOutputDeviceID();
#endif
selectedDeviceInfo = Pa_GetDeviceInfo(selectedIndex);
}
if (selectedDeviceInfo == NULL) {
for (i = 0; i < numDevices; i++) {
deviceInfo = Pa_GetDeviceInfo(i);
if (deviceInfo != NULL && !strcmp(device, deviceInfo->name)) {
selectedIndex = i;
selectedDeviceInfo = deviceInfo;
}
}
}
if (selectedDeviceInfo)
update_output_parameters(selectedIndex, selectedDeviceInfo);
return selectedDeviceInfo;
}
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,
FRAMES_PER_BUFFER,
0, /* number of buffers, if zero then use default minimum */
0, // 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;
}
void TPortAudioRenderer::DisplayDevices()
{
const PaDeviceInfo *pdi;
int i, j, numDevices;
numDevices = Pa_CountDevices();
printf("Number of devices = %d\n", numDevices);
for (i = 0; i < numDevices; i++) {
pdi = Pa_GetDeviceInfo(i);
printf("---------------------------------------------- #%d", i );
if (i == Pa_GetDefaultInputDeviceID())
printf(" DefaultInput");
if (i == Pa_GetDefaultOutputDeviceID())
printf(" DefaultOutput");
printf("\nName = %s\n", pdi->name);
printf("Max Inputs = %d", pdi->maxInputChannels);
printf(", Max Outputs = %d\n", pdi->maxOutputChannels);
if (pdi->numSampleRates == -1) {
printf("Sample Rate Range = %f to %f\n", pdi->sampleRates[0], pdi->sampleRates[1]);
} else {
printf("Sample Rates =");
for (j = 0; j < pdi->numSampleRates; j++) {
printf(" %8.2f,", pdi->sampleRates[j]);
}
printf("\n");
}
printf("Native Sample Formats = ");
if (pdi->nativeSampleFormats & paInt8)
printf("paInt8, ");
if (pdi->nativeSampleFormats & paUInt8)
printf("paUInt8, ");
if (pdi->nativeSampleFormats & paInt16)
printf("paInt16, ");
if (pdi->nativeSampleFormats & paInt32)
printf("paInt32, ");
if (pdi->nativeSampleFormats & paFloat32)
printf("paFloat32, ");
if (pdi->nativeSampleFormats & paInt24)
printf("paInt24, ");
if (pdi->nativeSampleFormats & paPackedInt24)
printf("paPackedInt24, ");
printf("\n");
}
}
bool SoundDevice::pablio_output(bool state) {
if(state && !aOutStream) {
err = OpenAudioStream( &aOutStream, SAMPLE_RATE, PA_SAMPLE_TYPE,
(PABLIO_WRITE | PABLIO_STEREO) );
if( err != paNoError) {
Pa_Terminate();
error("error opening output sound device: %s",Pa_GetErrorText( err ) );
return false;
} else
info_output = Pa_GetDeviceInfo( Pa_GetDefaultOutputDeviceID() );
} else if(!state && aOutStream) {
CloseAudioStream(aOutStream);
aOutStream = NULL;
info_output = NULL;
}
return true;
}
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;
}
/* Build linked a list with all the available audio devices on this SGI machine (only 1 for now). */
PaError PaHost_Init(void) /* Called by Pa_Initialize() from pa_lib.c. */
{
internalPortAudioDevice* pad;
PaError r = paNoError;
int audioLibFileID; /* To test for the presence of audio. */
if (sDeviceList) /* Allow re-init, only warn, no error. */
{
ERR_RPT(("Warning: PaHost_Init() did not really re-init PA.\n"));
return r;
}
/*------------- ADD THE SGI DEFAULT DEVICE TO THE LIST: ---------------------------------------*/
audioLibFileID = open("/dev/hdsp/hdsp0master", O_RDONLY); /* Try to open Indigo style audio */
if (audioLibFileID < 0) /* IO port. On failure, machine */
{ /* has no audio ability. */
ERR_RPT(("PaHost_Init(): This machine has no (Indigo-style) audio abilities.\n"));
return paHostError;
}
close(audioLibFileID); /* Allocate fast mem to hold device info. */
pad = PaHost_AllocateFastMemory(sizeof(internalPortAudioDevice));
if (pad == NULL)
return paInsufficientMemory;
memset(pad, 0, sizeof(internalPortAudioDevice)); /* "pad->pad_Next = NULL" is more elegant. */
r = Pa_sgiQueryDevice(AL_DEFAULT_DEVICE, /* Set AL device num (AL_DEFAULT_DEVICE). */
Pa_GetDefaultOutputDeviceID(),/* Set PA device num (or InputDeviceID()). */
"AL default", /* A suitable name. */
pad); /* Write args and queried info into pad. */
if (r != paNoError)
{
ERR_RPT(("Pa_QueryDevice for '%s' returned: %d\n", pad->pad_DeviceName, r));
PaHost_FreeFastMemory(pad, sizeof(internalPortAudioDevice)); /* sDeviceList still NULL ! */
}
else
sDeviceList = pad; /* First element in linked list. pad->pad_Next already NULL. */
/*------------- QUERY AND ADD MORE POSSIBLE SGI DEVICES TO THE LINKED LIST: -------------------*/
/*---------------------------------------------------------------------------------------------*/
return r;
}
PaError PlaySine( paTestData *data, PaStreamFlags flags, float amplitude )
{
PortAudioStream *stream;
PaError err;
data->left_phase = data->right_phase = 0;
data->amplitude = amplitude;
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,
1024,
0, /* number of buffers, if zero then use default minimum */
flags, /* we won't output out of range samples so don't bother clipping them */
sineCallback,
(void *)data );
if( err != paNoError ) goto error;
err = Pa_StartStream( stream );
if( err != paNoError ) goto error;
Pa_Sleep( NUM_SECONDS * 1000 );
printf("CPULoad = %8.6f\n", Pa_GetCPULoad( stream ) );
err = Pa_CloseStream( stream );
if( err != paNoError ) goto error;
Pa_Terminate();
return paNoError;
error:
return err;
}
int main(void)
{
PortAudioStream *stream;
PaError err;
paTestData data;
int i;
int timeout;
printf("Play different tone sine waves that alternate between left and right channel.\n");
printf("The low tone should be on the left channel.\n");
/* 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.toggle = 0;
data.countDown = SAMPLE_RATE;
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, /* 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;
printf("Play for several seconds.\n");
timeout = NUM_SECONDS * 4;
while( timeout > 0 )
{
Pa_Sleep( 300 );
timeout -= 1;
}
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 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 wave_open_sound()
{
ENTER("wave_open_sound");
PaError err=paNoError;
PaError active;
#if USE_PORTAUDIO == 18
active = Pa_StreamActive(pa_stream);
#else
active = Pa_IsStreamActive(pa_stream);
#endif
if(active == 1)
{
SHOW_TIME("wave_open_sound > already active");
return(0);
}
if(active < 0)
{
out_channels = 1;
#if USE_PORTAUDIO == 18
// err = Pa_OpenDefaultStream(&pa_stream,0,1,paInt16,wave_samplerate,FRAMES_PER_BUFFER,N_WAV_BUF,pa_callback,(void *)userdata);
PaDeviceID playbackDevice = Pa_GetDefaultOutputDeviceID();
PaError err = Pa_OpenStream( &pa_stream,
/* capture parameters */
paNoDevice,
0,
paInt16,
NULL,
/* playback parameters */
playbackDevice,
out_channels,
paInt16,
NULL,
/* general parameters */
wave_samplerate, FRAMES_PER_BUFFER, 0,
//paClipOff | paDitherOff,
paNoFlag,
pa_callback, (void *)userdata);
SHOW("wave_open_sound > Pa_OpenDefaultStream(1): err=%d (%s)\n",err, Pa_GetErrorText(err));
if(err == paInvalidChannelCount)
{
SHOW_TIME("wave_open_sound > try stereo");
// failed to open with mono, try stereo
out_channels = 2;
// myOutputParameters.channelCount = out_channels;
PaError err = Pa_OpenStream( &pa_stream,
/* capture parameters */
paNoDevice,
0,
paInt16,
NULL,
/* playback parameters */
playbackDevice,
out_channels,
paInt16,
NULL,
/* general parameters */
wave_samplerate, FRAMES_PER_BUFFER, 0,
//paClipOff | paDitherOff,
paNoFlag,
pa_callback, (void *)userdata);
// err = Pa_OpenDefaultStream(&pa_stream,0,2,paInt16,
// wave_samplerate,
// FRAMES_PER_BUFFER,
// N_WAV_BUF,pa_callback,(void *)userdata);
SHOW("wave_open_sound > Pa_OpenDefaultStream(2): err=%d (%s)\n",err, Pa_GetErrorText(err));
err=0; // avoid warning
}
mInCallbackFinishedState = false; // v18 only
#else
myOutputParameters.channelCount = out_channels;
unsigned long framesPerBuffer = paFramesPerBufferUnspecified;
err = Pa_OpenStream(
&pa_stream,
NULL, /* no input */
&myOutputParameters,
wave_samplerate,
framesPerBuffer,
paNoFlag,
// paClipOff | paDitherOff,
pa_callback,
(void *)userdata);
if ((err!=paNoError)
&& (err!=paInvalidChannelCount)) //err==paUnanticipatedHostError
{
fprintf(stderr, "wave_open_sound > Pa_OpenStream : err=%d (%s)\n",err,Pa_GetErrorText(err));
framesPerBuffer = FRAMES_PER_BUFFER;
err = Pa_OpenStream(
&pa_stream,
NULL, /* no input */
&myOutputParameters,
wave_samplerate,
framesPerBuffer,
paNoFlag,
// paClipOff | paDitherOff,
pa_callback,
(void *)userdata);
}
if(err == paInvalidChannelCount)
{
SHOW_TIME("wave_open_sound > try stereo");
// failed to open with mono, try stereo
out_channels = 2;
myOutputParameters.channelCount = out_channels;
err = Pa_OpenStream(
&pa_stream,
NULL, /* no input */
&myOutputParameters,
wave_samplerate,
framesPerBuffer,
paNoFlag,
// paClipOff | paDitherOff,
pa_callback,
(void *)userdata);
// err = Pa_OpenDefaultStream(&pa_stream,0,2,paInt16,(double)wave_samplerate,FRAMES_PER_BUFFER,pa_callback,(void *)userdata);
}
mInCallbackFinishedState = false;
#endif
}
SHOW("wave_open_sound > %s\n","LEAVE");
return (err != paNoError);
}
int main(void)
{
PortAudioStream *stream;
PaError err;
paTestData data;
int i;
int totalFrames;
int numSamples;
int numBytes;
SAMPLE max, average, val;
printf("patest_record.c\n"); fflush(stdout);
data.maxFrameIndex = totalFrames = NUM_SECONDS * SAMPLE_RATE; /* Record for a few seconds. */
data.frameIndex = 0;
numSamples = totalFrames * NUM_CHANNELS;
numBytes = numSamples * sizeof(SAMPLE);
data.recordedSamples = (SAMPLE *) malloc( numBytes );
if( data.recordedSamples == NULL )
{
printf("Could not allocate record array.\n");
exit(1);
}
for( i=0; i<numSamples; i++ ) data.recordedSamples[i] = 0;
err = Pa_Initialize();
if( err != paNoError ) goto error;
/* Record some audio. -------------------------------------------- */
err = Pa_OpenStream(
&stream,
Pa_GetDefaultInputDeviceID(),
NUM_CHANNELS,
PA_SAMPLE_TYPE,
NULL,
paNoDevice,
0,
PA_SAMPLE_TYPE,
NULL,
SAMPLE_RATE,
FRAMES_PER_BUFFER, /* frames per buffer */
0, /* number of buffers, if zero then use default minimum */
0, /* paDitherOff, // flags */
recordCallback,
&data );
if( err != paNoError ) goto error;
err = Pa_StartStream( stream );
if( err != paNoError ) goto error;
printf("Now recording!!\n"); fflush(stdout);
while( Pa_StreamActive( stream ) )
{
Pa_Sleep(1000);
printf("index = %d\n", data.frameIndex ); fflush(stdout);
}
err = Pa_CloseStream( stream );
if( err != paNoError ) goto error;
/* Measure maximum peak amplitude. */
max = 0;
average = 0;
for( i=0; i<numSamples; i++ )
{
val = data.recordedSamples[i];
if( val < 0 ) val = -val; /* ABS */
if( val > max )
{
max = val;
}
average += val;
}
average = average / numSamples;
if( PA_SAMPLE_TYPE == paFloat32 ) /* This should be done at compile-time with "#if" ?? */
{ /* MIPS-compiler warns at the int-version below. */
printf("sample max amplitude = %f\n", max );
printf("sample average = %f\n", average );
}
else
{
printf("sample max amplitude = %d\n", max ); /* <-- This IS compiled anyhow. */
printf("sample average = %d\n", average );
}
/* Write recorded data to a file. */
#if 0
{
FILE *fid;
fid = fopen("recorded.raw", "wb");
if( fid == NULL )
{
printf("Could not open file.");
}
else
{
fwrite( data.recordedSamples, NUM_CHANNELS * sizeof(SAMPLE), totalFrames, fid );
fclose( fid );
printf("Wrote data to 'recorded.raw'\n");
}
}
#endif
/* Playback recorded data. -------------------------------------------- */
data.frameIndex = 0;
printf("Begin playback.\n"); fflush(stdout);
err = Pa_OpenStream(
&stream,
paNoDevice,
0, /* NO input */
PA_SAMPLE_TYPE,
NULL,
Pa_GetDefaultOutputDeviceID(),
NUM_CHANNELS,
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,
&data );
if( err != paNoError ) goto error;
if( stream )
{
err = Pa_StartStream( stream );
if( err != paNoError ) goto error;
printf("Waiting for playback to finish.\n"); fflush(stdout);
while( Pa_StreamActive( stream ) ) Pa_Sleep(100);
err = Pa_CloseStream( stream );
if( err != paNoError ) goto error;
printf("Done.\n"); fflush(stdout);
}
free( data.recordedSamples );
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 main(int argc, char **argv)
{
int num_mixers;
int i;
PaError error;
PortAudioStream *stream;
int recDeviceNum;
int playDeviceNum;
int inputChannels;
int outputChannels;
int num_devices;
int device;
int opt;
int opts=-1, optm=0;
float optv=-2, opto=-2, opti=-2, opth=-2, optb=-2;
printf("px_test: a program to demonstrate the capabilities of PortMixer\n");
printf("By Dominic Mazzoni\n");
printf("\n");
printf("Usage:\n");
printf(" -d [device number]\n");
printf(" -m [mixer number]\n");
printf(" -v [vol] (Master volume)\n");
printf(" -o [vol] (PCM output volume)\n");
printf(" -i [vol] (Input volume)\n");
printf(" -s [source number] (Input source)\n");
printf(" -h [vol] (Playthrough)\n");
printf(" -b [bal] (Balance: -1.0....1.0)\n");
printf("\n");
printf("All volumes are between 0.0 and 1.0.\n");
printf("\n");
error = Pa_Initialize();
if (error != 0) {
printf("PortAudio error: %s\n", Pa_GetErrorText(error));
return -1;
}
num_devices = Pa_CountDevices();
device = Pa_GetDefaultInputDeviceID();
recDeviceNum = paNoDevice;
playDeviceNum = paNoDevice;
inputChannels = 0;
outputChannels = 0;
while(-1 != (opt=getopt(argc, argv, "d:m:v:o:i:s:h:b:"))) {
switch(opt) {
case 'd':
device = atoi(optarg);
printf("Set device to %d\n", device);
break;
case 'm':
optm = atoi(optarg);
printf("Set mixer number to %d\n", optm);
break;
case 'v':
optv = getvolarg(optarg); break;
case 'o':
opto = getvolarg(optarg); break;
case 'i':
opti = getvolarg(optarg); break;
case 'h':
opth = getvolarg(optarg); break;
case 'b':
optb = atof(optarg); break;
case 's':
opts = atoi(optarg); break;
}
}
printf("Devices:\n");
for(i=0; i<num_devices; i++) {
const PaDeviceInfo* deviceInfo = Pa_GetDeviceInfo(i);
if (i==device) {
printf("* ");
if (deviceInfo->maxInputChannels > 0) {
recDeviceNum = device;
inputChannels = deviceInfo->maxInputChannels;
}
if (deviceInfo->maxOutputChannels > 0) {
playDeviceNum = device;
outputChannels = deviceInfo->maxOutputChannels;
}
}
else
printf(" ");
printf("Device %d: %s in=%d out=%d",
i, deviceInfo->name,
deviceInfo->maxInputChannels, deviceInfo->maxOutputChannels);
if (i == Pa_GetDefaultInputDeviceID())
printf(" (default input)");
if (i == Pa_GetDefaultOutputDeviceID())
printf(" (default output)");
printf("\n");
}
printf("\n");
error = Pa_OpenStream(&stream, recDeviceNum, inputChannels, paFloat32, NULL,
playDeviceNum, outputChannels, paFloat32, NULL,
44101, 512, 1, paClipOff | paDitherOff,
DummyCallbackFunc, NULL);
if (error) {
printf("PortAudio error %d: %s\n", error,
Pa_GetErrorText(error));
return -1;
}
num_mixers = Px_GetNumMixers(stream);
printf("Number of mixers for device %d: %d\n", device, num_mixers);
for(i=0; i<num_mixers; i++) {
PxMixer *mixer;
int num;
int j;
printf("Mixer %d: %s\n", i, Px_GetMixerName(stream, i));
mixer = Px_OpenMixer(stream, i);
if (!mixer) {
printf(" Could not open mixer!\n");
continue;
}
if (i == optm) {
if (optv!=-2) {
Px_SetMasterVolume(mixer, optv);
printf(" Set master volume\n");
}
if (opto!=-2) {
Px_SetPCMOutputVolume(mixer, opto);
printf(" Set output volume\n");
}
if (opti!=-2) {
Px_SetInputVolume(mixer, opti);
printf(" Set input volume\n");
}
if (opth!=-2) {
Px_SetPlaythrough(mixer, opth);
printf(" Set playthrough volume\n");
}
if (opts!=-2) {
Px_SetCurrentInputSource(mixer, opts);
printf(" Set input source\n");
}
if (optb!=-2) {
Px_SetOutputBalance(mixer, optb);
printf(" Set balance\n");
}
}
printf(" Master volume: %.2f\n", Px_GetMasterVolume(mixer));
printf(" PCM output volume: %.2f\n", Px_GetPCMOutputVolume(mixer));
num = Px_GetNumOutputVolumes(mixer);
printf(" Num outputs: %d\n", num);
for(j=0; j<num; j++) {
printf(" Output %d (%s): %.2f\n",
j,
Px_GetOutputVolumeName(mixer, j),
Px_GetOutputVolume(mixer, j));
}
num = Px_GetNumInputSources(mixer);
printf(" Num input sources: %d\n", num);
for(j=0; j<num; j++) {
printf(" Input %d (%s) %s\n",
j,
Px_GetInputSourceName(mixer, j),
(Px_GetCurrentInputSource(mixer)==j?
"SELECTED": ""));
}
printf(" Input volume: %.2f\n", Px_GetInputVolume(mixer));
printf(" Playthrough:");
if (Px_SupportsPlaythrough(mixer))
printf(" %.2f\n", Px_GetPlaythrough(mixer));
else
printf(" not supported.\n");
printf(" Output balance:");
if (Px_SupportsOutputBalance(mixer))
printf(" %.2f\n", Px_GetOutputBalance(mixer));
else
printf(" not supported.\n");
Px_CloseMixer(mixer);
}
Pa_CloseStream(stream);
Pa_Terminate();
return 0;
}
// thread execution starts here
void *AudioThread::Entry()
{
PaError err;
err = Pa_OpenStream(
&mPortStream,
paNoDevice,/* default input device */
0, /* no input */
paInt16, /* 32 bit floating point input */
NULL,
Pa_GetDefaultOutputDeviceID(), /* default output device */
2, /* stereo output */
paInt16, /* 32 bit floating point output */
NULL,
mRate,
2,
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 */
AudioThread::CallbackWrapper,
this );
if( err != paNoError )
{
WriteText(wxT("There was a PortAudio Error on start\n"));
Pa_CloseStream( mPortStream );
return NULL;
}
while(true)
{
if ( TestDestroy() )
{
WriteText("Audio Thread Destroyed\n");
break;
}
if (mStatus == doPlay)
{
PaError err;
err = Pa_StartStream( mPortStream );
if( err != paNoError )
{
WriteText(wxT("There was a PortAudio Error on start\n"));
break;
}
else
mStatus = Playing;
}
if (mStatus == doPause)
{
PaError err;
err = Pa_StopStream( mPortStream );
if( err != paNoError )
{
WriteText(wxT("There was a PortAudio Error on stop\n"));
break;
}
else
mStatus = Paused;
}
wxThread::Sleep(500);
}
Pa_AbortStream( mPortStream );
Pa_CloseStream( mPortStream );
return NULL;
}
int main(void)
{
PortAudioStream *stream;
PaError err;
paTestData DATA;
int i;
int totalSamps;
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 = 0;
DATA.framesToGo = totalSamps = NUM_SECONDS * SAMPLE_RATE; /* Play for a few seconds. */
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, /* frames per buffer */
NUM_BUFFERS, /* 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;
DATA.outTime = -1.0; // mark time for callback as undefined
err = Pa_StartStream( stream );
if( err != paNoError ) goto error;
/* Watch until sound is halfway finished. */
printf("Play for %d seconds.\n", NUM_SECONDS/2 ); fflush(stdout);
do
{
ReportStreamTime( stream, &DATA );
Pa_Sleep(100);
} while( Pa_StreamTime( stream ) < (totalSamps/2) );
/* Stop sound until ENTER hit. */
err = Pa_StopStream( stream );
if( err != paNoError ) goto error;
printf("Pause for 2 seconds.\n"); fflush(stdout);
Pa_Sleep( 2000 );
DATA.outTime = -1.0; // mark time for callback as undefined
err = Pa_StartStream( stream );
if( err != paNoError ) goto error;
printf("Play until sound is finished.\n"); fflush(stdout);
do
{
ReportStreamTime( stream, &DATA );
Pa_Sleep(100);
} while( Pa_StreamActive( stream ) );
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;
}
static int open_output(void)
{
double rate;
int n, nrates, include_enc, exclude_enc, ret;
PaSampleFormat SampleFormat, nativeSampleFormats;
if( dpm.name != NULL)
ret = sscanf(dpm.name, "%d", &opt_pa_device_id);
if (dpm.name == NULL || ret == 0 || ret == EOF)
opt_pa_device_id = -2;
#ifdef AU_PORTAUDIO_DLL
#if PORTAUDIO_V19
{
if(&dpm == &portaudio_asio_play_mode){
HostApiTypeId = paASIO;
} else if(&dpm == &portaudio_win_ds_play_mode){
HostApiTypeId = paDirectSound;
} else if(&dpm == &portaudio_win_wmme_play_mode){
HostApiTypeId = paMME;
} else {
return -1;
}
if(load_portaudio_dll(0))
return -1;
}
#else
{
if(&dpm == &portaudio_asio_play_mode){
if(load_portaudio_dll(PA_DLL_ASIO))
return -1;
} else if(&dpm == &portaudio_win_ds_play_mode){
if(load_portaudio_dll(PA_DLL_WIN_DS))
return -1;
} else if(&dpm == &portaudio_win_wmme_play_mode){
if(load_portaudio_dll(PA_DLL_WIN_WMME))
return -1;
} else {
return -1;
}
}
#endif
#endif
/* if call twice Pa_OpenStream causes paDeviceUnavailable error */
if(pa_active == 1) return 0;
if(pa_active == 0){
err = Pa_Initialize();
if( err != paNoError ) goto error;
pa_active = 1;
}
if (opt_pa_device_id == -1){
print_device_list();
goto error2;
}
#ifdef PORTAUDIO_V19
#ifdef AU_PORTAUDIO_DLL
{
PaHostApiIndex i, ApiCount;
i = 0;
ApiCount = Pa_GetHostApiCount();
do{
HostApiInfo=Pa_GetHostApiInfo(i);
if( HostApiInfo->type == HostApiTypeId ) break;
i++;
}while ( i < ApiCount );
if ( i == ApiCount ) goto error;
DeviceIndex = HostApiInfo->defaultOutputDevice;
if(DeviceIndex==paNoDevice) goto error;
}
#else
DeviceIndex = Pa_GetDefaultOutputDevice();
if(DeviceIndex==paNoDevice) goto error;
#endif
DeviceInfo = Pa_GetDeviceInfo( DeviceIndex);
if(DeviceInfo==NULL) goto error;
if(opt_pa_device_id != -2){
const PaDeviceInfo *id_DeviceInfo;
id_DeviceInfo=Pa_GetDeviceInfo((PaDeviceIndex)opt_pa_device_id);
if(id_DeviceInfo==NULL) goto error;
if( DeviceInfo->hostApi == id_DeviceInfo->hostApi){
DeviceIndex=(PaDeviceIndex)opt_pa_device_id;
DeviceInfo = id_DeviceInfo;
}
}
if (dpm.encoding & PE_24BIT) {
SampleFormat = paInt24;
}else if (dpm.encoding & PE_16BIT) {
SampleFormat = paInt16;
}else {
SampleFormat = paInt8;
}
stereo = (dpm.encoding & PE_MONO) ? 1 : 2;
data_nbyte = (dpm.encoding & PE_16BIT) ? 2 : 1;
data_nbyte = (dpm.encoding & PE_24BIT) ? 3 : data_nbyte;
pa_data.samplesToGo = 0;
pa_data.bufpoint = pa_data.buf;
pa_data.bufepoint = pa_data.buf;
// firsttime = 1;
numBuffers = 1; //Pa_GetMinNumBuffers( framesPerBuffer, dpm.rate );
framesPerInBuffer = numBuffers * framesPerBuffer;
if (framesPerInBuffer < 4096) framesPerInBuffer = 4096;
bytesPerInBuffer = framesPerInBuffer * data_nbyte * stereo;
/* set StreamParameters */
StreamParameters.device = DeviceIndex;
StreamParameters.channelCount = stereo;
if(ctl->id_character != 'r' && ctl->id_character != 'A' && ctl->id_character != 'W' && ctl->id_character != 'P'){
StreamParameters.suggestedLatency = DeviceInfo->defaultHighOutputLatency;
}else{
StreamParameters.suggestedLatency = DeviceInfo->defaultLowOutputLatency;
}
StreamParameters.hostApiSpecificStreamInfo = NULL;
if( SampleFormat == paInt16){
StreamParameters.sampleFormat = paInt16;
if( paFormatIsSupported != Pa_IsFormatSupported( NULL ,
&StreamParameters,(double) dpm.rate )){
StreamParameters.sampleFormat = paInt32;
conv16_32 = 1;
} else {
StreamParameters.sampleFormat = paInt16;
conv16_32 = 0;
}
}else{
StreamParameters.sampleFormat = SampleFormat;
}
err = Pa_IsFormatSupported( NULL ,
&StreamParameters,
(double) dpm.rate );
if ( err != paNoError) goto error;
err = Pa_OpenStream(
& stream, /* passes back stream pointer */
NULL, /* inputStreamParameters */
&StreamParameters, /* outputStreamParameters */
(double) dpm.rate, /* sample rate */
paFramesPerBufferUnspecified, /* frames per buffer */
paFramesPerBufferUnspecified, /* PaStreamFlags */
paCallback, /* specify our custom callback */
&pa_data /* pass our data through to callback */
);
// Pa_Sleeep(1);
if ( err != paNoError) goto error;
return 0;
#else
if(opt_pa_device_id == -2){
DeviceID = Pa_GetDefaultOutputDeviceID();
if(DeviceID==paNoDevice) goto error2;
}else{
DeviceID = opt_pa_device_id;
}
DeviceInfo = Pa_GetDeviceInfo( DeviceID);
if(DeviceInfo==NULL) goto error2;
nativeSampleFormats = DeviceInfo->nativeSampleFormats;
exclude_enc = PE_ULAW | PE_ALAW | PE_BYTESWAP;
include_enc = PE_SIGNED;
if (!(nativeSampleFormats & paInt16) && !(nativeSampleFormats & paInt32)) {exclude_enc |= PE_16BIT;}
if (!(nativeSampleFormats & paInt24)) {exclude_enc |= PE_24BIT;}
dpm.encoding = validate_encoding(dpm.encoding, include_enc, exclude_enc);
if (dpm.encoding & PE_24BIT) {
SampleFormat = paInt24;
}else if (dpm.encoding & PE_16BIT) {
if(nativeSampleFormats & paInt16) SampleFormat = paInt16;
else{
SampleFormat = paInt32;
conv16_32 = 1;
}
}else {
SampleFormat = paInt8;
}
stereo = (dpm.encoding & PE_MONO) ? 1 : 2;
data_nbyte = (dpm.encoding & PE_16BIT) ? 2 : 1;
data_nbyte = (dpm.encoding & PE_24BIT) ? 3 : data_nbyte;
nrates = DeviceInfo->numSampleRates;
if (nrates == -1) { /* range supported */
rate = dpm.rate;
if (dpm.rate < DeviceInfo->sampleRates[0]) rate = DeviceInfo->sampleRates[0];
if (dpm.rate > DeviceInfo->sampleRates[1]) rate = DeviceInfo->sampleRates[1];
} else {
rate = DeviceInfo->sampleRates[nrates-1];
for (n = nrates - 1; n >= 0; n--) { /* find nearest sample rate */
if (dpm.rate <= DeviceInfo->sampleRates[n]) rate=DeviceInfo->sampleRates[n];
}
}
dpm.rate = (int32)rate;
pa_data.samplesToGo = 0;
pa_data.bufpoint = pa_data.buf;
pa_data.bufepoint = pa_data.buf;
// firsttime = 1;
numBuffers = Pa_GetMinNumBuffers( framesPerBuffer, dpm.rate );
framesPerInBuffer = numBuffers * framesPerBuffer;
if (framesPerInBuffer < 4096) framesPerInBuffer = 4096;
bytesPerInBuffer = framesPerInBuffer * data_nbyte * stereo;
// printf("%d\n",framesPerInBuffer);
// printf("%d\n",dpm.rate);
err = Pa_OpenDefaultStream(
&stream, /* passes back stream pointer */
0, /* no input channels */
stereo, /* 2:stereo 1:mono output */
SampleFormat, /* 24bit 16bit 8bit output */
(double)dpm.rate, /* sample rate */
framesPerBuffer, /* frames per buffer */
numBuffers, /* number of buffers, if zero then use default minimum */
paCallback, /* specify our custom callback */
&pa_data); /* pass our data through to callback */
if ( err != paNoError && err != paHostError) goto error;
return 0;
#endif
error:
ctl->cmsg( CMSG_ERROR, VERB_NORMAL, "PortAudio error: %s\n", Pa_GetErrorText( err ) );
error2:
Pa_Terminate(); pa_active = 0;
#ifdef AU_PORTAUDIO_DLL
#ifndef PORTAUDIO_V19
free_portaudio_dll();
#endif
#endif
return -1;
}
/* Find audio devices which support stereo */
PaDeviceIndex GetAudioDevices(PaDeviceIndex default_device, char *default_device_name,
char *default_hostapi, bool output_change, bool show_list)
{
int i;
int err;
bool bValidDev = false;
const PaDeviceInfo *pdi;
#ifdef PORTAUDIO_DEV
const PaHostApiInfo *info;
#endif
PaDeviceIndex DefaultDevice;
PaDeviceIndex DeviceCount;
err = Pa_Initialize();
if (err != paNoError) {
printf("PortAudio error4: %s Could not open any audio devices.\n", Pa_GetErrorText(err) );
exit(-1);
}
#ifdef PORTAUDIO_DEV
DeviceCount = Pa_GetDeviceCount();
#else
DeviceCount = Pa_CountDevices();
#endif
if ( DeviceCount < 0 )
{
printf("PortAudio error5: %s\n", Pa_GetErrorText(DeviceCount) );
exit(-1);
}
if ( output_change )
{
/* If name not set, use device index */
if ( default_device_name == NULL )
DefaultDevice = default_device;
else
{
/* Set the initial device to the default.
* If we find a match the device index will be applied.
*/
DefaultDevice = PA_DEFAULT_DEVICE;
for ( i = 0; i < DeviceCount; i++ )
{
pdi = Pa_GetDeviceInfo( i );
if ( pdi->name != NULL )
{
#ifdef PORTAUDIO_DEV
/* Match on audio system if specified */
if ( default_hostapi != NULL )
{
info = Pa_GetHostApiInfo ( pdi->hostApi );
if ( info->name != NULL )
{
/* No match, next */
if ( strncasecmp (info->name, default_hostapi, strlen (info->name)) != 0 )
continue;
}
}
#endif
if ( strncasecmp (pdi->name, default_device_name, strlen (pdi->name)) == 0 )
{
DefaultDevice = i;
break;
}
}
}
if ( DefaultDevice == PA_DEFAULT_DEVICE )
{
output_change = false;
fprintf (stderr, "Named device match failed, using default.\n");
}
}
}
else
DefaultDevice = PA_DEFAULT_DEVICE;
if ( DefaultDevice >= DeviceCount || ((DefaultDevice == PA_DEFAULT_DEVICE) && !output_change) )
{
#ifdef PORTAUDIO_DEV
DefaultDevice = Pa_GetDefaultOutputDevice();
#else
DefaultDevice = Pa_GetDefaultOutputDeviceID();
#endif
}
if ( DefaultDevice == paNoDevice )
{
printf("PortAudio error7: No output devices found.\n" );
exit(-1);
}
if ( show_list )
printf("Output devices:\n");
for ( i = 0; i < DeviceCount; i++ )
{
pdi = Pa_GetDeviceInfo( i );
if ( pdi->name == NULL )
{
printf("PortAudio error6: GetDeviceInfo failed.\n" );
exit(-1);
}
#ifdef PORTAUDIO_DEV
info = Pa_GetHostApiInfo ( pdi->hostApi );
if ( info->name == NULL )
{
printf("PortAudio error8: GetHostApiInfo failed.\n" );
exit(-1);
}
#endif
if ( pdi->maxOutputChannels >= 2 )
{
if ( i == DefaultDevice )
bValidDev = true;
if ( show_list )
{
#ifdef PORTAUDIO_DEV
printf("%c%2d: (%s) %s (%i/%i)\n", i == DefaultDevice ? '*' : ' ', \
i, info->name, pdi->name,
(unsigned int) (pdi->defaultLowOutputLatency * 1000.0),
(unsigned int) (pdi->defaultHighOutputLatency * 1000.0) );
#else
printf("%c%2d: %s\n", i == DefaultDevice ? '*' : ' ', i, pdi->name);
#endif
}
}
}
Pa_Terminate();
if ( !bValidDev )
DefaultDevice = paNoDevice;
return (DefaultDevice) ;
}
int main(void)
{
PortAudioStream *stream;
PaError err;
paTestData data;
int i;
int totalSamps;
#if TEST_UNSIGNED
printf("PortAudio Test: output UNsigned 8 bit sine wave.\n");
#else
printf("PortAudio Test: output signed 8 bit sine wave.\n");
#endif
/* initialise sinusoidal wavetable */
for( i=0; i<TABLE_SIZE; i++ )
{
data.sine[i] = (char) (127.0 * sin( ((double)i/(double)TABLE_SIZE) * M_PI * 2. ));
#if TEST_UNSIGNED
data.sine[i] += (unsigned char) 0x80;
#endif
}
data.left_phase = data.right_phase = 0;
data.framesToGo = totalSamps = NUM_SECONDS * SAMPLE_RATE; /* Play for a few seconds. */
err = Pa_Initialize();
if( err != paNoError ) goto error;
err = Pa_OpenStream(
&stream,
paNoDevice,/* default input device */
0, /* no input */
TEST_FORMAT,
NULL,
Pa_GetDefaultOutputDeviceID(), /* default output device */
2, /* stereo output */
TEST_FORMAT,
NULL,
SAMPLE_RATE,
256, /* 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;
/* Watch until sound is halfway finished. */
while( Pa_StreamTime( stream ) < (totalSamps/2) ) Pa_Sleep(10);
/* Stop sound until ENTER hit. */
err = Pa_StopStream( stream );
if( err != paNoError ) goto error;
printf("Pause for 2 seconds.\n");
Pa_Sleep( 2000 );
err = Pa_StartStream( stream );
if( err != paNoError ) goto error;
printf("Waiting for sound to finish.\n");
while( Pa_StreamActive( stream ) ) Pa_Sleep(10);
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;
}
/** create a new driver instance
*/
static jack_driver_t *
portaudio_driver_new (char *name,
jack_client_t* client,
jack_nframes_t frames_per_cycle,
jack_nframes_t rate,
int capturing,
int playing,
int chan_in,
int chan_out,
DitherAlgorithm dither,
char* driver_name)
{
portaudio_driver_t *driver;
PaError err = paNoError;
int numDevices;
int inputDeviceID,outputDeviceID;
int found;
PALog("portaudio driver version : %d\n", kVersion);
PALog("creating portaudio driver ... %" PRIu32 "|%" PRIu32 "\n",
frames_per_cycle, rate);
driver = (portaudio_driver_t *) calloc (1, sizeof (portaudio_driver_t));
jack_driver_init ((jack_driver_t *) driver);
if (!jack_power_of_two(frames_per_cycle)) {
jack_error ("PA: -p must be a power of two.");
goto error;
}
driver->frames_per_cycle = frames_per_cycle;
driver->frame_rate = rate;
driver->capturing = capturing;
driver->playing = playing;
driver->attach = (JackDriverAttachFunction) portaudio_driver_attach;
driver->detach = (JackDriverDetachFunction) portaudio_driver_detach;
driver->read = (JackDriverReadFunction) portaudio_driver_read;
driver->write = (JackDriverReadFunction) portaudio_driver_write;
driver->null_cycle = (JackDriverNullCycleFunction) portaudio_driver_null_cycle;
driver->bufsize = (JackDriverBufSizeFunction) portaudio_driver_bufsize;
driver->start = (JackDriverStartFunction) portaudio_driver_audio_start;
driver->stop = (JackDriverStopFunction) portaudio_driver_audio_stop;
driver->stream = NULL;
#ifdef JACK_USE_MACH_THREADS
AudioDeviceID device_id;
if (driver_name) {
if (get_device_id_from_uid(driver_name, &device_id) != noErr)
goto error;
if (get_device_name_from_id(device_id, driver->driver_name) != noErr)
goto error;
} else {
if (get_device_id_from_num(0, &device_id) != noErr)
goto error;
if (get_device_name_from_id(device_id, driver->driver_name) != noErr)
goto error;
}
#endif
err = Pa_Initialize();
PALog("Pa_Initialize OK \n");
PALog("Driver name required %s\n",driver->driver_name);
numDevices = Pa_CountDevices();
if( numDevices < 0 ){
PALog("ERROR: Pa_CountDevices returned 0x%x\n", numDevices);
err = numDevices;
goto error;
}
PALog("Number of devices = %d\n", numDevices);
if (strcmp(driver->driver_name,"") == 0) {
found = portaudio_load_default(driver,numDevices,capturing,playing,&inputDeviceID,&outputDeviceID);
if (!found) {
PALog("ERROR : default driver has not been found\n");
err = paHostError;
goto error;
}
}else{
found = portaudio_load_driver(driver,numDevices,capturing,playing,&inputDeviceID,&outputDeviceID,driver->driver_name);
if (!found) {
PALog("ERROR : driver %s has not been found \n",driver->driver_name);
err = paHostError;
goto error;
}
}
if (err != paNoError) goto error;
PALog("Pa_GetDefaultOutputDeviceID() %ld\n", (long)Pa_GetDefaultOutputDeviceID());
PALog("Pa_GetDefaultInputDeviceID() %ld\n", (long)Pa_GetDefaultInputDeviceID());
PALog("--------------------------------------------------\n");
PALog("CoreAudio driver %s will be loaded\n", driver->driver_name);
PALog("inputDeviceID %ld\n", (long)inputDeviceID);
PALog("outputDeviceID %ld\n", (long)outputDeviceID);
PALog("driver->capture_nchannels %ld\n", driver->capture_nchannels);
PALog("driver->playback_nchannels %ld\n", driver->playback_nchannels);
PALog("chan_in, chan_out %ld %ld\n", (long)chan_in, (long)chan_out);
if (chan_in > 0)
driver->capture_nchannels = (driver->capture_nchannels < chan_in) ? driver->capture_nchannels : chan_in;
if (chan_out > 0)
driver->playback_nchannels = (driver->playback_nchannels < chan_out) ? driver->playback_nchannels : chan_out;
PALog("driver->capture_nchannels %ld\n", driver->capture_nchannels);
PALog("driver->playback_nchannels %ld\n", driver->playback_nchannels);
err = Pa_OpenStream(&driver->stream,
((capturing && (driver->capture_nchannels > 0)) ? inputDeviceID : paNoDevice),
((capturing) ? driver->capture_nchannels : 0),
paFloat32, // 32 bit floating point input
NULL,
((playing && (driver->playback_nchannels > 0)) ? outputDeviceID : paNoDevice),
((playing) ? driver->playback_nchannels : 0),
paFloat32, // 32 bit floating point output
NULL,
rate,
frames_per_cycle, // 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
paCallback,
driver);
if (err != paNoError) goto error;
driver->client = client;
driver->period_usecs = (((float) driver->frames_per_cycle) / driver->frame_rate) * 1000000.0f;
return((jack_driver_t *) driver);
error:
Pa_Terminate();
jack_error("An error occured while using the portaudio stream");
jack_error("Error number: %d", err);
jack_error("Error message: %s", Pa_GetErrorText(err));
free(driver);
return NULL;
}
