static int PAOpenStream( aout_instance_t *p_aout )
{
aout_sys_t *p_sys = p_aout->output.p_sys;
const PaHostErrorInfo* paLastHostErrorInfo = Pa_GetLastHostErrorInfo();
PaStreamParameters paStreamParameters;
vlc_value_t val;
int i_channels, i_err;
uint32_t i_channel_mask;
if( var_Get( p_aout, "audio-device", &val ) < 0 )
{
return VLC_EGENERIC;
}
if( val.i_int == AOUT_VAR_5_1 )
{
p_aout->output.output.i_physical_channels
= AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
| AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT
| AOUT_CHAN_LFE;
}
else if( val.i_int == AOUT_VAR_3F2R )
{
p_aout->output.output.i_physical_channels
= AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
| AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT;
}
else if( val.i_int == AOUT_VAR_2F2R )
{
p_aout->output.output.i_physical_channels
= AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT
| AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT;
}
else if( val.i_int == AOUT_VAR_MONO )
{
p_aout->output.output.i_physical_channels = AOUT_CHAN_CENTER;
}
else
{
p_aout->output.output.i_physical_channels
= AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT;
}
i_channels = aout_FormatNbChannels( &p_aout->output.output );
msg_Dbg( p_aout, "nb_channels requested = %d", i_channels );
i_channel_mask = p_aout->output.output.i_physical_channels;
/* Calculate the frame size in bytes */
p_sys->i_sample_size = 4 * i_channels;
p_aout->output.i_nb_samples = FRAME_SIZE;
aout_FormatPrepare( &p_aout->output.output );
aout_VolumeSoftInit( p_aout );
/* Check for channel reordering */
p_aout->output.p_sys->i_channel_mask = i_channel_mask;
p_aout->output.p_sys->i_bits_per_sample = 32; /* forced to paFloat32 */
p_aout->output.p_sys->i_channels = i_channels;
p_aout->output.p_sys->b_chan_reorder =
aout_CheckChannelReorder( NULL, pi_channels_out,
i_channel_mask, i_channels,
p_aout->output.p_sys->pi_chan_table );
if( p_aout->output.p_sys->b_chan_reorder )
{
msg_Dbg( p_aout, "channel reordering needed" );
}
paStreamParameters.device = p_sys->i_device_id;
paStreamParameters.channelCount = i_channels;
paStreamParameters.sampleFormat = paFloat32;
paStreamParameters.suggestedLatency =
p_sys->deviceInfo->defaultLowOutputLatency;
paStreamParameters.hostApiSpecificStreamInfo = NULL;
i_err = Pa_OpenStream( &p_sys->p_stream, NULL /* no input */,
&paStreamParameters, (double)p_aout->output.output.i_rate,
FRAME_SIZE, paClipOff, paCallback, p_sys );
if( i_err != paNoError )
{
msg_Err( p_aout, "Pa_OpenStream returns %d : %s", i_err,
Pa_GetErrorText( i_err ) );
if( i_err == paUnanticipatedHostError )
{
msg_Err( p_aout, "type %d code %ld : %s",
paLastHostErrorInfo->hostApiType,
paLastHostErrorInfo->errorCode,
paLastHostErrorInfo->errorText );
}
p_sys->p_stream = 0;
return VLC_EGENERIC;
}
i_err = Pa_StartStream( p_sys->p_stream );
if( i_err != paNoError )
{
msg_Err( p_aout, "Pa_StartStream() failed" );
Pa_CloseStream( p_sys->p_stream );
return VLC_EGENERIC;
}
return VLC_SUCCESS;
}
int main(void)
{
PaStreamParameters outputParameters;
PaStream *stream;
PaError err;
int safeSineCount, stressedSineCount;
int safeUnderflowCount, stressedUnderflowCount;
paTestData data = {0};
double load;
printf("PortAudio Test: output sine waves, count underflows. SR = %d, BufSize = %d. MAX_LOAD = %f\n",
SAMPLE_RATE, FRAMES_PER_BUFFER, (float)MAX_LOAD );
err = Pa_Initialize();
if( err != paNoError ) goto error;
outputParameters.device = Pa_GetDefaultOutputDevice(); /* default output device */
if (outputParameters.device == paNoDevice) {
fprintf(stderr,"Error: No default output device.\n");
goto error;
}
outputParameters.channelCount = 1; /* mono output */
outputParameters.sampleFormat = paFloat32; /* 32 bit floating point output */
outputParameters.suggestedLatency = Pa_GetDeviceInfo( outputParameters.device )->defaultLowOutputLatency;
outputParameters.hostApiSpecificStreamInfo = NULL;
err = Pa_OpenStream(
&stream,
NULL, /* no input */
&outputParameters,
SAMPLE_RATE,
FRAMES_PER_BUFFER,
paClipOff, /* we won't output out of range samples so don't bother clipping them */
patestCallback,
&data );
if( err != paNoError ) goto error;
err = Pa_StartStream( stream );
if( err != paNoError ) goto error;
printf("Establishing load conditions...\n" );
/* Determine number of sines required to get to 50% */
do
{
Pa_Sleep( 100 );
load = Pa_GetStreamCpuLoad( stream );
printf("sineCount = %d, CPU load = %f\n", data.sineCount, load );
if( load < 0.3 )
{
data.sineCount += 10;
}
else if( load < 0.4 )
{
data.sineCount += 2;
}
else
{
data.sineCount += 1;
}
}
while( load < 0.5 && data.sineCount < (MAX_SINES-1));
safeSineCount = data.sineCount;
/* Calculate target stress value then ramp up to that level*/
stressedSineCount = (int) (2.0 * data.sineCount * MAX_LOAD );
if( stressedSineCount > MAX_SINES )
stressedSineCount = MAX_SINES;
for( ; data.sineCount < stressedSineCount; data.sineCount+=4 )
{
Pa_Sleep( 100 );
load = Pa_GetStreamCpuLoad( stream );
printf("STRESSING: sineCount = %d, CPU load = %f\n", data.sineCount, load );
}
printf("Counting underflows for 5 seconds.\n");
data.countUnderflows = 1;
Pa_Sleep( 5000 );
stressedUnderflowCount = data.outputUnderflowCount;
data.countUnderflows = 0;
data.sineCount = safeSineCount;
printf("Resuming safe load...\n");
Pa_Sleep( 1500 );
data.outputUnderflowCount = 0;
Pa_Sleep( 1500 );
load = Pa_GetStreamCpuLoad( stream );
printf("sineCount = %d, CPU load = %f\n", data.sineCount, load );
printf("Counting underflows for 5 seconds.\n");
data.countUnderflows = 1;
Pa_Sleep( 5000 );
safeUnderflowCount = data.outputUnderflowCount;
printf("Stop stream.\n");
err = Pa_StopStream( stream );
if( err != paNoError ) goto error;
err = Pa_CloseStream( stream );
if( err != paNoError ) goto error;
Pa_Terminate();
if( stressedUnderflowCount == 0 )
printf("Test failed, no output underflows detected under stress.\n");
else if( safeUnderflowCount != 0 )
printf("Test failed, %d unexpected underflows detected under safe load.\n", safeUnderflowCount);
else
printf("Test passed, %d expected output underflows detected under stress, 0 unexpected underflows detected under safe load.\n", stressedUnderflowCount );
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)
{
PaError err;
paTestData data = { 0 };
long totalFrames;
long numBytes;
long i;
printf("patest_record.c\n"); fflush(stdout);
/* Set up test data structure and sample array. */
data.frameIndex = 0;
data.samplesPerFrame = 2;
data.maxFrameIndex = totalFrames = NUM_SECONDS*SAMPLE_RATE;
printf("totalFrames = %d\n", totalFrames ); fflush(stdout);
data.numSamples = totalFrames * data.samplesPerFrame;
numBytes = data.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<data.numSamples; i++ ) data.recordedSamples[i] = 0;
err = Pa_Initialize();
if( err != paNoError ) goto error;
/* Record and playback multiple times. */
for( i=0; i<2; i++ )
{
err = TestRecording( &data );
if( err != paNoError ) goto error;
err = TestPlayback( &data );
if( err != paNoError ) goto error;
}
/* Clean up. */
err = Pa_CloseStream( data.inputStream );
if( err != paNoError ) goto error;
err = Pa_CloseStream( data.outputStream );
if( err != paNoError ) goto error;
if( err != paNoError ) goto error;
free( data.recordedSamples );
Pa_Terminate();
printf("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 ) );
if( err == paHostError )
{
fprintf( stderr, "Host Error number: %d\n", Pa_GetHostError() );
}
return -1;
}
PaError OpenStream(PaStream **mStream, PaDeviceIndex Device, double Rate, void* Sound, double &dLatency, PaStreamCallback Callback)
{
PaStreamParameters outputParams;
outputParams.device = Device;
outputParams.channelCount = 2;
outputParams.sampleFormat = paFloat32;
if (!Configuration::GetConfigf("UseHighLatency", "Audio"))
outputParams.suggestedLatency = Pa_GetDeviceInfo(outputParams.device)->defaultLowOutputLatency;
else
outputParams.suggestedLatency = Pa_GetDeviceInfo(outputParams.device)->defaultHighOutputLatency;
#ifndef WIN32
outputParams.hostApiSpecificStreamInfo = NULL;
#else
PaWasapiStreamInfo StreamInfo;
PaWinDirectSoundStreamInfo DSStreamInfo;
if (UseWasapi)
{
outputParams.hostApiSpecificStreamInfo = &StreamInfo;
StreamInfo.hostApiType = paWASAPI;
StreamInfo.size = sizeof(PaWasapiStreamInfo);
StreamInfo.version = 1;
if (!Configuration::GetConfigf("WasapiDontUseExclusiveMode", "Audio"))
{
StreamInfo.threadPriority = eThreadPriorityProAudio;
StreamInfo.flags = paWinWasapiExclusive;
}
else
{
StreamInfo.threadPriority = eThreadPriorityAudio;
StreamInfo.flags = 0;
}
StreamInfo.hostProcessorOutput = NULL;
StreamInfo.hostProcessorInput = NULL;
}
else
{
outputParams.hostApiSpecificStreamInfo = &DSStreamInfo;
DSStreamInfo.size = sizeof(PaWinDirectSoundStreamInfo);
DSStreamInfo.hostApiType = paDirectSound;
DSStreamInfo.version = 2;
DSStreamInfo.flags = 0;
}
#endif
dLatency = outputParams.suggestedLatency;
// fire up portaudio
PaError Err = Pa_OpenStream(mStream, NULL, &outputParams, Rate, 0, paClipOff, Callback, (void*)Sound);
if (Err)
{
Log::Logf("%ls\n", Utility::Widen(Pa_GetErrorText(Err)).c_str());
Log::Logf("Device Selected %d\n", Device);
}
#ifdef LINUX
else
{
Log::Logf("Audio: Enabling real time scheduling\n");
PaAlsa_EnableRealtimeScheduling( mStream, true );
}
#endif
return Err;
}
int main(void)
{
//printf("InfiniteLooper--based on patest_record.c\n"); //fflush(stdout);
//Record for a few seconds.
data.maxFrameIndex = totalFrames = NUM_SECONDS * SAMPLE_RATE;
data.frameIndex = 0;
numSamples = totalFrames * NUM_CHANNELS;
numBytes = numSamples * sizeof(SAMPLE);
// From now on, recordedSamples is initialised.
// 5 minutes of record buffer allocated 5% of free
// on rPi zero. could record 90 minutes on rPi 0
//++++++++++++++++++++++++++++++++++++++++++++++++++++
data.recordedSamples = (SAMPLE*) malloc( numBytes );
//++++++++++++++++++++++++++++++++++++++++++++++++++++
if( data.recordedSamples == NULL )
{
//printf("Could not allocate record array.\n");
goto done;
}
else
{
//printf("allocated %d bytes\n", numBytes );
}
ringbufferWPTR = 0;
ringbufferRPTR = 0;
all_complete = FALSE;
// ******************************************
doState(S_INIT, data.recordedSamples);
// ******************************************
// we do the recording set-up just once and cycle power
// to do it again. This initialization should be moved to
// ilooper_audio if multiple recordings are implemented
err = Pa_Initialize();
if( err != paNoError ) goto done;
// default input device
inputParameters.device = Pa_GetDefaultInputDevice();
if (inputParameters.device == paNoDevice) {
fprintf(stderr,"Error: No default input device.\n");
goto done;
}
inputParameters.channelCount = 2; //stereo input
inputParameters.sampleFormat = PA_SAMPLE_TYPE;
inputParameters.suggestedLatency =
Pa_GetDeviceInfo( inputParameters.device )->defaultLowInputLatency;
inputParameters.hostApiSpecificStreamInfo = NULL;
//Record some audio. --------------------------------------------
err = Pa_OpenStream
(
&stream,
&inputParameters,
NULL, // &outputParameters,
SAMPLE_RATE, // ADC sample rate is a constant
FRAMES_PER_BUFFER,
//we won't output out of range samples so
//don't bother clipping them
//paClipOff,
// ***wm6h for this app, let's clip
paNoFlag,
recordCallback,
&data
);
if( err != paNoError ) goto done;
// the output sample rate is checked in playback()
err = Pa_IsFormatSupported( &inputParameters, NULL, SAMPLE_RATE );
if( err == paFormatIsSupported )
{
//printf("\n ADC samplerate is supported %d, FPB %d\n", \
// SAMPLE_RATE, FRAMES_PER_BUFFER);
}
else
{
//printf("\n ADC samplerate is NOT supported\n");
goto done;
}
//printf(" %s\n", Pa_GetVersionText());
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//GPIO-0 access for Green LED and test
//rPi J8-11 and gnd J8-6
if(wiringPiSetup () < 0 )
{
fprintf(stderr, "Unable to setup wiringPi: %s\n", strerror(errno));
return 1;
}
pinMode (LED_PIN, OUTPUT) ;
digitalWrite (LED_PIN, OFF) ;
pinMode (BUTTON_PIN, INPUT) ;
//pullUpDnControl(BUTTON_PIN, PUD_OFF);
pullUpDnControl(BUTTON_PIN, PUD_UP);
pinMode (DIRECTION_PIN, INPUT) ;
pullUpDnControl(DIRECTION_PIN, PUD_UP);
pinMode (REBOOT_PIN, INPUT) ;
pullUpDnControl(REBOOT_PIN, PUD_UP);
pinMode (ERROR_PIN, OUTPUT) ;
digitalWrite (ERROR_PIN, OFF) ;
sync();
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// underway--shift ship's colors--all ahead 8K sps
//
err = Pa_StartStream( stream );
if( err != paNoError ) goto done;
// =============================================================================
// =============================================================================
// collecting samples phase
// ******************************************
doState(S_COLLECTING, data.recordedSamples);
// ******************************************
// we are running the callbacks
while( ( err = Pa_IsStreamActive( stream ) ) == 1 )
{
Pa_Sleep(500);
if(buttonPress == TRUE)
{
Pa_Sleep(100);
all_complete = TRUE; //stop the sample interrupt, exit while loop
}
else
{
// no button press
// give the state machine a chance to run
// ******************************************
doState(currentSTATE, (void*) NULL);
// ******************************************
}
}
// =============================================================================
// =============================================================================
if( err < 0 ) goto done;
// all stop
err = Pa_CloseStream( stream );
if( err != paNoError ) goto done;
buttonValue = digitalRead(BUTTON_PIN);
//printf("button = %d\n", buttonValue);
if(buttonValue == 0)
{
//if button still pressed, it's a hold
buttonHold = TRUE;
//printf("button hold\n"); //fflush(stdout);
}
else
{ //else, it's a button press
buttonPress = FALSE; //acknowledged, reset flag
//printf("button pressed\n"); //fflush(stdout);
}
// Measure maximum peak amplitude.
// we could indicate over-driving/clipping the audio
// or AGC it
max = 0;
average = 0.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 / (double)numSamples;
//printf("sample max amplitude = "PRINTF_S_FORMAT"\n", max );
//printf("sample average = %lf\n", average );
// Write recorded data to a file.
#if WRITE_TO_FILE
{ // the file size should be 5 minutes of 8K samples * 2
// the entire ring buffer is recorded without regard to the
// read/write pointers. Make sense of the file by editing it in
// Audacity
// todo: write the file in correct time order using rd/wr pointers
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
// initial state after recording
// all future state changes from within state machine
if(buttonHold == FALSE)
{
// ******************************************
doState(S_REWIND_10, (void*) NULL);
// ******************************************
}
else
{
// ******************************************
doState(S_REWIND_PLAYBACK, (void*) NULL);
// ******************************************
}
// |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
// |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
while (1)
{
// advance state in the state machine
// ******************************************
doState(currentSTATE, (void*) NULL);
// ******************************************
Pa_Sleep(100);
if(terminate != FALSE)
goto done;
}
// |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
// |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
done:
Pa_Terminate();
if( data.recordedSamples ) // Sure it is NULL or valid.
free( data.recordedSamples );
if( err != paNoError )
{
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 ) );
fatalError();
err = 1; // Always return 0 or 1, but no other return codes.
}
return err;
}
int main(void)
{
char pad[256];
PortAudioStream *stream;
PaError err;
const PaDeviceInfo *pdi;
paTestData data = {0};
printf("PortAudio Test: output sine wave on each channel.\n" );
err = Pa_Initialize();
if( err != paNoError ) goto error;
pdi = Pa_GetDeviceInfo( OUTPUT_DEVICE );
data.numChannels = pdi->maxOutputChannels;
if( data.numChannels > MAX_CHANNELS ) data.numChannels = MAX_CHANNELS;
printf("Number of Channels = %d\n", data.numChannels );
data.amplitude = 1.0;
err = Pa_OpenStream(
&stream,
paNoDevice, /* default input device */
0, /* no input */
paFloat32, /* 32 bit floating point input */
NULL,
OUTPUT_DEVICE,
data.numChannels,
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
{
printf("Current amplitude = %f\n", data.amplitude );
printf("Enter new amplitude or 'q' to quit.\n");
fflush(stdout);
gets( pad );
if( pad[0] != 'q' )
{
// I tried to use atof but it seems to be broken on Mac OS X 10.1
float amp;
sscanf( pad, "%f", & );
data.amplitude = amp;
}
} while( pad[0] != 'q' );
err = Pa_StopStream( stream );
if( err != paNoError ) goto error;
Pa_CloseStream( stream );
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;
}
s32 Init()
{
started=false;
stream=NULL;
ReadSettings();
PaError err = Pa_Initialize();
if( err != paNoError )
{
fprintf(stderr,"* SPU2-X: PortAudio error: %s\n", Pa_GetErrorText( err ) );
return -1;
}
started=true;
int deviceIndex = -1;
fprintf(stderr,"* SPU2-X: Enumerating PortAudio devices:");
for(int i=0;i<Pa_GetDeviceCount();i++)
{
const PaDeviceInfo * info = Pa_GetDeviceInfo(i);
const PaHostApiInfo * apiinfo = Pa_GetHostApiInfo(info->hostApi);
fprintf(stderr," *** Device %d: '%s' (%s)", i, info->name, apiinfo->name);
if(apiinfo->type == m_ApiId)
{
static wchar_t buffer [1000];
mbstowcs(buffer,info->name,1000);
buffer[999]=0;
if(m_Device == buffer)
{
deviceIndex = i;
fprintf(stderr," (selected)");
}
}
fprintf(stderr,"\n");
}
if(deviceIndex<0 && m_ApiId>=0)
{
for(int i=0;i<Pa_GetHostApiCount();i++)
{
const PaHostApiInfo * apiinfo = Pa_GetHostApiInfo(i);
if(apiinfo->type == m_ApiId)
{
deviceIndex = apiinfo->defaultOutputDevice;
}
}
}
if(deviceIndex>=0)
{
void* infoPtr = NULL;
#ifdef __WIN32__
PaWasapiStreamInfo info = {
sizeof(PaWasapiStreamInfo),
paWASAPI,
1,
paWinWasapiExclusive
};
if((m_ApiId == paWASAPI) && m_WasapiExclusiveMode)
{
// Pass it the Exclusive mode enable flag
infoPtr = &info;
}
#endif
PaStreamParameters outParams = {
// PaDeviceIndex device;
// int channelCount;
// PaSampleFormat sampleFormat;
// PaTime suggestedLatency;
// void *hostApiSpecificStreamInfo;
deviceIndex,
2,
paInt32,
0.2f,
infoPtr
};
err = Pa_OpenStream(&stream,
NULL, &outParams, SampleRate,
SndOutPacketSize,
paNoFlag,
#ifndef __LINUX__
PaCallback,
#else
PaLinuxCallback,
#endif
NULL);
}
else
{
err = Pa_OpenDefaultStream( &stream,
0, 2, paInt32, 48000,
SndOutPacketSize,
#ifndef __LINUX__
PaCallback,
#else
PaLinuxCallback,
#endif
NULL );
}
if( err != paNoError )
{
fprintf(stderr,"* SPU2-X: PortAudio error: %s\n", Pa_GetErrorText( err ) );
Pa_Terminate();
return -1;
}
err = Pa_StartStream( stream );
if( err != paNoError )
{
fprintf(stderr,"* SPU2-X: PortAudio error: %s\n", Pa_GetErrorText( err ) );
Pa_CloseStream(stream);
stream=NULL;
Pa_Terminate();
return -1;
}
return 0;
}
int main(void)
{
PaStream *stream;
PaStreamParameters outputParameters;
PaError err;
paTestData data;
int i;
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 = 0;
data.currentBalance = 0.0;
data.targetBalance = 0.0;
err = Pa_Initialize();
if( err != paNoError ) goto error;
outputParameters.device = Pa_GetDefaultOutputDevice(); /* default output device */
if (outputParameters.device == paNoDevice) {
fprintf(stderr,"Error: No default output device.\n");
goto error;
}
outputParameters.channelCount = 2; /* stereo output */
outputParameters.sampleFormat = paFloat32; /* 32 bit floating point output */
outputParameters.suggestedLatency = Pa_GetDeviceInfo( outputParameters.device )->defaultLowOutputLatency;
outputParameters.hostApiSpecificStreamInfo = NULL;
err = Pa_OpenStream( &stream,
NULL, /* No input. */
&outputParameters, /* As above. */
SAMPLE_RATE,
FRAMES_PER_BUFFER,
paClipOff, /* we won't output out of range samples so don't bother clipping them */
patestCallback,
&data );
if( err != paNoError ) goto error;
err = Pa_StartStream( stream );
if( err != paNoError ) goto error;
printf("Play for several seconds.\n");
for( i=0; i<4; i++ )
{
printf("Hear low sound on left side.\n");
data.targetBalance = 0.01;
Pa_Sleep( 1000 );
printf("Hear high sound on right side.\n");
data.targetBalance = 0.99;
Pa_Sleep( 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 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)
{
PaStreamParameters outputParameters;
PaStream *stream;
PaError err;
paTestData data;
#ifdef __APPLE__
PaMacCoreStreamInfo macInfo;
const SInt32 channelMap[4] = { -1, -1, 0, 1 };
#endif
int i;
printf("PortAudio Test: output sine wave. SR = %d, BufSize = %d\n", SAMPLE_RATE, FRAMES_PER_BUFFER);
printf("Output will be mapped to channels 2 and 3 instead of 0 and 1.\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 = 0;
err = Pa_Initialize();
if( err != paNoError ) goto error;
/** setup host specific info */
#ifdef __APPLE__
PaMacCore_SetupStreamInfo( &macInfo, paMacCorePlayNice );
PaMacCore_SetupChannelMap( &macInfo, channelMap, 4 );
for( i=0; i<4; ++i )
printf( "channel %d name: %s\n", i, PaMacCore_GetChannelName( Pa_GetDefaultOutputDevice(), i, false ) );
#else
printf( "Channel mapping not supported on this platform. Reverting to normal sine test.\n" );
#endif
outputParameters.device = Pa_GetDefaultOutputDevice(); /* default output device */
if (outputParameters.device == paNoDevice) {
fprintf(stderr,"Error: No default output device.\n");
goto error;
}
outputParameters.channelCount = 2; /* stereo output */
outputParameters.sampleFormat = paFloat32; /* 32 bit floating point output */
outputParameters.suggestedLatency = Pa_GetDeviceInfo( outputParameters.device )->defaultLowOutputLatency;
#ifdef __APPLE__
outputParameters.hostApiSpecificStreamInfo = &macInfo;
#else
outputParameters.hostApiSpecificStreamInfo = NULL;
#endif
err = Pa_OpenStream(
&stream,
NULL, /* no input */
&outputParameters,
SAMPLE_RATE,
FRAMES_PER_BUFFER,
paClipOff, /* we won't output out of range samples so don't bother clipping them */
patestCallback,
&data );
if( err != paNoError ) goto error;
err = Pa_StartStream( stream );
if( err != paNoError ) goto error;
printf("Play for %d seconds.\n", NUM_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 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 ALCenum pa_open_capture(ALCdevice *device, const ALCchar *deviceName)
{
PaStreamParameters inParams;
ALuint frame_size;
pa_data *data;
PaError err;
if(!deviceName)
deviceName = pa_device;
else if(strcmp(deviceName, pa_device) != 0)
return ALC_INVALID_VALUE;
data = (pa_data*)calloc(1, sizeof(pa_data));
if(data == NULL)
return ALC_OUT_OF_MEMORY;
frame_size = FrameSizeFromDevFmt(device->FmtChans, device->FmtType);
data->ring = CreateRingBuffer(frame_size, device->UpdateSize*device->NumUpdates);
if(data->ring == NULL)
goto error;
inParams.device = -1;
if(!ConfigValueInt("port", "capture", &inParams.device) || inParams.device < 0)
inParams.device = Pa_GetDefaultOutputDevice();
inParams.suggestedLatency = 0.0f;
inParams.hostApiSpecificStreamInfo = NULL;
switch(device->FmtType)
{
case DevFmtByte:
inParams.sampleFormat = paInt8;
break;
case DevFmtUByte:
inParams.sampleFormat = paUInt8;
break;
case DevFmtShort:
inParams.sampleFormat = paInt16;
break;
case DevFmtFloat:
inParams.sampleFormat = paFloat32;
break;
case DevFmtUShort:
ERR("Unsigned short samples not supported\n");
goto error;
}
inParams.channelCount = ChannelsFromDevFmt(device->FmtChans);
err = Pa_OpenStream(&data->stream, &inParams, NULL, device->Frequency,
paFramesPerBufferUnspecified, paNoFlag, pa_capture_cb, device);
if(err != paNoError)
{
ERR("Pa_OpenStream() returned an error: %s\n", Pa_GetErrorText(err));
goto error;
}
device->szDeviceName = strdup(deviceName);
device->ExtraData = data;
return ALC_NO_ERROR;
error:
DestroyRingBuffer(data->ring);
free(data);
return ALC_INVALID_VALUE;
}
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;
}
static ALCenum pa_open_playback(ALCdevice *device, const ALCchar *deviceName)
{
PaStreamParameters outParams;
pa_data *data;
PaError err;
if(!deviceName)
deviceName = pa_device;
else if(strcmp(deviceName, pa_device) != 0)
return ALC_INVALID_VALUE;
data = (pa_data*)calloc(1, sizeof(pa_data));
data->update_size = device->UpdateSize;
device->ExtraData = data;
outParams.device = -1;
if(!ConfigValueInt("port", "device", &outParams.device) || outParams.device < 0)
outParams.device = Pa_GetDefaultOutputDevice();
outParams.suggestedLatency = (device->UpdateSize*device->NumUpdates) /
(float)device->Frequency;
outParams.hostApiSpecificStreamInfo = NULL;
switch(device->FmtType)
{
case DevFmtByte:
outParams.sampleFormat = paInt8;
break;
case DevFmtUByte:
outParams.sampleFormat = paUInt8;
break;
case DevFmtUShort:
device->FmtType = DevFmtShort;
/* fall-through */
case DevFmtShort:
outParams.sampleFormat = paInt16;
break;
case DevFmtFloat:
outParams.sampleFormat = paFloat32;
break;
}
outParams.channelCount = ((device->FmtChans == DevFmtMono) ? 1 : 2);
SetDefaultChannelOrder(device);
err = Pa_OpenStream(&data->stream, NULL, &outParams, device->Frequency,
device->UpdateSize, paNoFlag, pa_callback, device);
if(err != paNoError)
{
ERR("Pa_OpenStream() returned an error: %s\n", Pa_GetErrorText(err));
device->ExtraData = NULL;
free(data);
return ALC_INVALID_VALUE;
}
device->szDeviceName = strdup(deviceName);
if((ALuint)outParams.channelCount != ChannelsFromDevFmt(device->FmtChans))
{
if(outParams.channelCount != 1 && outParams.channelCount != 2)
{
ERR("Unhandled channel count: %u\n", outParams.channelCount);
Pa_CloseStream(data->stream);
device->ExtraData = NULL;
free(data);
return ALC_INVALID_VALUE;
}
if((device->Flags&DEVICE_CHANNELS_REQUEST))
ERR("Failed to set %s, got %u channels instead\n", DevFmtChannelsString(device->FmtChans), outParams.channelCount);
device->Flags &= ~DEVICE_CHANNELS_REQUEST;
device->FmtChans = ((outParams.channelCount==1) ? DevFmtMono : DevFmtStereo);
}
return ALC_NO_ERROR;
}
JNIEXPORT jstring JNICALL Java_com_github_rjeschke_jpa_JPA_paGetErrorText(JNIEnv *env, jclass clazz, jint error)
{
return makeString(env, (char*)Pa_GetErrorText((PaError)error));
}
/*****************************************************************************
* PORTAUDIOThread: all interactions with libportaudio.a are handled
* in this single thread. Otherwise libportaudio.a is _not_ happy :-(
*****************************************************************************/
static void* PORTAUDIOThread( vlc_object_t *p_this )
{
pa_thread_t *pa_thread = (pa_thread_t*)p_this;
aout_instance_t *p_aout;
aout_sys_t *p_sys;
int i_err;
int canc = vlc_savecancel ();
while( vlc_object_alive (pa_thread) )
{
/* Wait for start of stream */
vlc_mutex_lock( &pa_thread->lock_signal );
if( !pa_thread->b_signal )
vlc_cond_wait( &pa_thread->signal, &pa_thread->lock_signal );
vlc_mutex_unlock( &pa_thread->lock_signal );
pa_thread->b_signal = false;
p_aout = pa_thread->p_aout;
p_sys = p_aout->output.p_sys;
if( PAOpenDevice( p_aout ) != VLC_SUCCESS )
{
msg_Err( p_aout, "cannot open portaudio device" );
pa_thread->b_error = true;
}
if( !pa_thread->b_error && PAOpenStream( p_aout ) != VLC_SUCCESS )
{
msg_Err( p_aout, "cannot open portaudio device" );
pa_thread->b_error = true;
i_err = Pa_Terminate();
if( i_err != paNoError )
{
msg_Err( p_aout, "Pa_Terminate: %d (%s)", i_err,
Pa_GetErrorText( i_err ) );
}
}
/* Tell the main thread that we are ready */
vlc_mutex_lock( &pa_thread->lock_wait );
pa_thread->b_wait = true;
vlc_cond_signal( &pa_thread->wait );
vlc_mutex_unlock( &pa_thread->lock_wait );
/* Wait for end of stream */
vlc_mutex_lock( &pa_thread->lock_signal );
if( !pa_thread->b_signal )
vlc_cond_wait( &pa_thread->signal, &pa_thread->lock_signal );
vlc_mutex_unlock( &pa_thread->lock_signal );
pa_thread->b_signal = false;
if( pa_thread->b_error ) continue;
i_err = Pa_StopStream( p_sys->p_stream );
if( i_err != paNoError )
{
msg_Err( p_aout, "Pa_StopStream: %d (%s)", i_err,
Pa_GetErrorText( i_err ) );
}
i_err = Pa_CloseStream( p_sys->p_stream );
if( i_err != paNoError )
{
msg_Err( p_aout, "Pa_CloseStream: %d (%s)", i_err,
Pa_GetErrorText( i_err ) );
}
i_err = Pa_Terminate();
if( i_err != paNoError )
{
msg_Err( p_aout, "Pa_Terminate: %d (%s)", i_err,
Pa_GetErrorText( i_err ) );
}
/* Tell the main thread that we are ready */
vlc_mutex_lock( &pa_thread->lock_wait );
pa_thread->b_wait = true;
vlc_cond_signal( &pa_thread->wait );
vlc_mutex_unlock( &pa_thread->lock_wait );
}
vlc_restorecancel (canc);
return NULL;
}
int main(int argc, char *argv[])
{
QString cfg_file;
std::string conf;
std::string style;
bool clierr = false;
bool edit_conf = false;
int return_code;
QApplication app(argc, argv);
QCoreApplication::setOrganizationName(GQRX_ORG_NAME);
QCoreApplication::setOrganizationDomain(GQRX_ORG_DOMAIN);
QCoreApplication::setApplicationName(GQRX_APP_NAME);
QCoreApplication::setApplicationVersion(VERSION);
// setup controlport via environment variables
// see http://lists.gnu.org/archive/html/discuss-gnuradio/2013-05/msg00270.html
// Note: tried using gr::prefs().save() but that doesn't have effect until the next time
if (qputenv("GR_CONF_CONTROLPORT_ON", "False"))
qDebug() << "Controlport disabled";
else
qDebug() << "Failed to disable controlport";
// setup the program options
po::options_description desc("Command line options");
desc.add_options()
("help,h", "This help message")
("style,s", po::value<std::string>(&style), "Use the give style (fusion, windows)")
("list,l", "List existing configurations")
("conf,c", po::value<std::string>(&conf), "Start with this config file")
("edit,e", "Edit the config file before using it")
("reset,r", "Reset configuration file")
;
po::variables_map vm;
try
{
po::store(po::parse_command_line(argc, argv, desc), vm);
}
catch(const boost::program_options::invalid_command_line_syntax& ex)
{
/* happens if e.g. -c without file name */
clierr = true;
}
catch(const boost::program_options::unknown_option& ex)
{
/* happens if e.g. -c without file name */
clierr = true;
}
po::notify(vm);
// print the help message
if (vm.count("help") || clierr)
{
std::cout << "Gqrx software defined radio receiver " << VERSION << std::endl;
std::cout << desc << std::endl;
return 1;
}
if (vm.count("style"))
QApplication::setStyle(QString::fromStdString(style));
if (vm.count("list"))
{
list_conf();
return 0;
}
// check whether audio backend is functional
#ifdef WITH_PORTAUDIO
PaError err = Pa_Initialize();
if (err != paNoError)
{
QString message = QString("Portaudio error: %1").arg(Pa_GetErrorText(err));
qCritical() << message;
QMessageBox::critical(0, "Audio Error", message,
QMessageBox::Abort, QMessageBox::NoButton);
return 1;
}
#endif
#ifdef WITH_PULSEAUDIO
int error = 0;
pa_simple *test_sink;
pa_sample_spec ss;
ss.format = PA_SAMPLE_FLOAT32LE;
ss.rate = 48000;
ss.channels = 2;
test_sink = pa_simple_new(NULL, "Gqrx Test", PA_STREAM_PLAYBACK, NULL,
"Test stream", &ss, NULL, NULL, &error);
if (!test_sink)
{
QString message = QString("Pulseaudio error: %1").arg(pa_strerror(error));
qCritical() << message;
QMessageBox::critical(0, "Audio Error", message,
QMessageBox::Abort, QMessageBox::NoButton);
return 1;
}
pa_simple_free(test_sink);
#endif
if (!conf.empty())
{
cfg_file = QString::fromStdString(conf);
qDebug() << "User specified config file:" << cfg_file;
}
else
{
cfg_file = "default.conf";
qDebug() << "No user supplied config file. Using" << cfg_file;
}
if (vm.count("reset"))
reset_conf(cfg_file);
else if (vm.count("edit"))
edit_conf = true;
// Mainwindow will check whether we have a configuration
// and open the config dialog if there is none or the specified
// file does not exist.
MainWindow w(cfg_file, edit_conf);
if (w.configOk)
{
w.show();
return_code = app.exec();
}
else
{
return_code = 1;
}
#ifdef WITH_PORTAUDIO
Pa_Terminate();
#endif
return return_code;
}
int main(int argc, char** argv)
{
struct sockaddr_in server;
int chan;
PaStream *stream;
PaStreamParameters output_parameters;
PaError err;
voice = NULL;
srand(time(NULL));
atexit(at_exit);
set_signal_handlers();
init();
if (argc != 4)
return usage(argv[0]);
set_output_parameters(&output_parameters, atoi(argv[3]));
/* connect to server */
sock = udp_create_socket(&server, sizeof(server), inet_addr(argv[1]), atoi(argv[2]), WAIT_FOR_RECEIVE);
if (sock < 0)
error_and_exit("Cannot create socket", __FILE__, __LINE__);
/* create speech thingies */
si.w = malloc(sizeof(cst_wave) * si.channel_count);
si.pos = malloc(sizeof(long) * si.channel_count);
si.done = malloc(sizeof(int) * si.channel_count);
si.cur_delay = malloc(sizeof(double) * si.channel_count);
si.rate_delay = malloc(sizeof(double) * si.channel_count);
for (chan = 0; chan < si.channel_count; ++chan) {
si.w[chan] = NULL;
next_tweet(&server, chan);
}
err = Pa_OpenStream(&stream, NULL, &output_parameters,
44100., 0, paNoFlag, say_text_callback, &si);
if (paNoError != err) {
fprintf(stderr, "Cannot open stream: %s\n", Pa_GetErrorText(err));
exit(-1);
}
/* Pa_OpenDefaultStream(&stream, 0, si.channel_count, paInt16,
si.w->sample_rate, 0, say_text_callback, &si); */
err = Pa_StartStream(stream);
if (paNoError != err) {
fprintf(stderr, "Cannot start stream: %s\n", Pa_GetErrorText(err));
exit(-1);
}
while (1)
{
usleep(100);
for (chan = 0; chan < si.channel_count; ++chan)
{
if (si.done[chan])
next_tweet(&server, chan);
}
}
//Pa_StopStream(stream);
return 0;
}
int main(void)
{
int i, numDevices, defaultDisplayed;
const PaDeviceInfo *deviceInfo;
PaStreamParameters inputParameters, outputParameters;
PaError err;
Pa_Initialize();
printf( "PortAudio version number = %d\nPortAudio version text = '%s'\n",
Pa_GetVersion(), Pa_GetVersionText() );
numDevices = Pa_GetDeviceCount();
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++ )
{
deviceInfo = Pa_GetDeviceInfo( i );
printf( "--------------------------------------- device #%d\n", i );
/* Mark global and API specific default devices */
defaultDisplayed = 0;
if( i == Pa_GetDefaultInputDevice() )
{
printf( "[ Default Input" );
defaultDisplayed = 1;
}
else if( i == Pa_GetHostApiInfo( deviceInfo->hostApi )->defaultInputDevice )
{
const PaHostApiInfo *hostInfo = Pa_GetHostApiInfo( deviceInfo->hostApi );
printf( "[ Default %s Input", hostInfo->name );
defaultDisplayed = 1;
}
if( i == Pa_GetDefaultOutputDevice() )
{
printf( (defaultDisplayed ? "," : "[") );
printf( " Default Output" );
defaultDisplayed = 1;
}
else if( i == Pa_GetHostApiInfo( deviceInfo->hostApi )->defaultOutputDevice )
{
const PaHostApiInfo *hostInfo = Pa_GetHostApiInfo( deviceInfo->hostApi );
printf( (defaultDisplayed ? "," : "[") );
printf( " Default %s Output", hostInfo->name );
defaultDisplayed = 1;
}
if( defaultDisplayed )
printf( " ]\n" );
/* print device info fields */
printf( "Name = %s\n", deviceInfo->name );
printf( "Host API = %s\n", Pa_GetHostApiInfo( deviceInfo->hostApi )->name );
printf( "Max inputs = %d", deviceInfo->maxInputChannels );
printf( ", Max outputs = %d\n", deviceInfo->maxOutputChannels );
printf( "Default low input latency = %8.3f\n", deviceInfo->defaultLowInputLatency );
printf( "Default low output latency = %8.3f\n", deviceInfo->defaultLowOutputLatency );
printf( "Default high input latency = %8.3f\n", deviceInfo->defaultHighInputLatency );
printf( "Default high output latency = %8.3f\n", deviceInfo->defaultHighOutputLatency );
#ifdef WIN32
#ifndef PA_NO_ASIO
/* ASIO specific latency information */
if( Pa_GetHostApiInfo( deviceInfo->hostApi )->type == paASIO ){
long minLatency, maxLatency, preferredLatency, granularity;
err = PaAsio_GetAvailableLatencyValues( i,
&minLatency, &maxLatency, &preferredLatency, &granularity );
printf( "ASIO minimum buffer size = %ld\n", minLatency );
printf( "ASIO maximum buffer size = %ld\n", maxLatency );
printf( "ASIO preferred buffer size = %ld\n", preferredLatency );
if( granularity == -1 )
printf( "ASIO buffer granularity = power of 2\n" );
else
printf( "ASIO buffer granularity = %ld\n", granularity );
}
#endif /* !PA_NO_ASIO */
#endif /* WIN32 */
printf( "Default sample rate = %8.2f\n", deviceInfo->defaultSampleRate );
/* poll for standard sample rates */
inputParameters.device = i;
inputParameters.channelCount = deviceInfo->maxInputChannels;
inputParameters.sampleFormat = paInt16;
inputParameters.suggestedLatency = 0; /* ignored by Pa_IsFormatSupported() */
inputParameters.hostApiSpecificStreamInfo = NULL;
outputParameters.device = i;
outputParameters.channelCount = deviceInfo->maxOutputChannels;
outputParameters.sampleFormat = paInt16;
outputParameters.suggestedLatency = 0; /* ignored by Pa_IsFormatSupported() */
outputParameters.hostApiSpecificStreamInfo = NULL;
if( inputParameters.channelCount > 0 )
{
printf("Supported standard sample rates\n for half-duplex 16 bit %d channel input = \n",
inputParameters.channelCount );
PrintSupportedStandardSampleRates( &inputParameters, NULL );
}
if( outputParameters.channelCount > 0 )
{
printf("Supported standard sample rates\n for half-duplex 16 bit %d channel output = \n",
outputParameters.channelCount );
PrintSupportedStandardSampleRates( NULL, &outputParameters );
}
if( inputParameters.channelCount > 0 && outputParameters.channelCount > 0 )
{
printf("Supported standard sample rates\n for full-duplex 16 bit %d channel input, %d channel output = \n",
inputParameters.channelCount, outputParameters.channelCount );
PrintSupportedStandardSampleRates( &inputParameters, &outputParameters );
}
}
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)
{
PaStreamParameters outputParameters;
PaStream *stream;
PaError err;
float buffer[FRAMES_PER_BUFFER][2]; /* stereo output buffer */
float sine[TABLE_SIZE]; /* sine wavetable */
int left_phase = 0;
int right_phase = 0;
int left_inc = 1;
int right_inc = 3; /* higher pitch so we can distinguish left and right. */
int i, j, k;
int bufferCount;
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++ )
{
sine[i] = (float) sin( ((double)i/(double)TABLE_SIZE) * M_PI * 2. );
}
err = Pa_Initialize();
if( err != paNoError ) goto error;
outputParameters.device = Pa_GetDefaultOutputDevice(); /* default output device */
outputParameters.channelCount = 2; /* stereo output */
outputParameters.sampleFormat = paFloat32; /* 32 bit floating point output */
outputParameters.suggestedLatency = Pa_GetDeviceInfo( outputParameters.device )->defaultLowOutputLatency;
outputParameters.hostApiSpecificStreamInfo = NULL;
err = Pa_OpenStream(
&stream,
NULL, /* no input */
&outputParameters,
SAMPLE_RATE,
FRAMES_PER_BUFFER,
paClipOff, /* we won't output out of range samples so don't bother clipping them */
NULL, /* no callback, use blocking API */
NULL ); /* no callback, so no callback userData */
if( err != paNoError ) goto error;
printf( "Play 3 times, higher each time.\n" );
for( k=0; k < 3; ++k )
{
err = Pa_StartStream( stream );
if( err != paNoError ) goto error;
printf("Play for %d seconds.\n", NUM_SECONDS );
bufferCount = ((NUM_SECONDS * SAMPLE_RATE) / FRAMES_PER_BUFFER);
for( i=0; i < bufferCount; i++ )
{
for( j=0; j < FRAMES_PER_BUFFER; j++ )
{
buffer[j][0] = sine[left_phase]; /* left */
buffer[j][1] = sine[right_phase]; /* right */
left_phase += left_inc;
if( left_phase >= TABLE_SIZE ) left_phase -= TABLE_SIZE;
right_phase += right_inc;
if( right_phase >= TABLE_SIZE ) right_phase -= TABLE_SIZE;
}
err = Pa_WriteStream( stream, buffer, FRAMES_PER_BUFFER );
if( err != paNoError ) goto error;
}
err = Pa_StopStream( stream );
if( err != paNoError ) goto error;
++left_inc;
++right_inc;
Pa_Sleep( 1000 );
}
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;
}
/*
* pjmedia_strerror()
*/
PJ_DEF(pj_str_t) pjmedia_strerror( pj_status_t statcode,
char *buf, pj_size_t bufsize )
{
pj_str_t errstr;
#if defined(PJ_HAS_ERROR_STRING) && (PJ_HAS_ERROR_STRING != 0)
/* See if the error comes from PortAudio. */
#if PJMEDIA_SOUND_IMPLEMENTATION==PJMEDIA_SOUND_PORTAUDIO_SOUND
if (statcode >= PJMEDIA_ERRNO_FROM_PORTAUDIO(paNotInitialized) &&
statcode < PJMEDIA_ERRNO_FROM_PORTAUDIO(paNotInitialized + 10000))
{
int pa_err = statcode - PJMEDIA_ERRNO_FROM_PORTAUDIO(0);
pj_str_t msg;
msg.ptr = (char*)Pa_GetErrorText(pa_err);
msg.slen = pj_ansi_strlen(msg.ptr);
errstr.ptr = buf;
pj_strncpy_with_null(&errstr, &msg, bufsize);
return errstr;
} else
#endif /* PJMEDIA_SOUND_IMPLEMENTATION */
if (statcode >= PJMEDIA_ERRNO_START &&
statcode < PJMEDIA_ERRNO_START + PJ_ERRNO_SPACE_SIZE)
{
/* Find the error in the table.
* Use binary search!
*/
int first = 0;
int n = PJ_ARRAY_SIZE(err_str);
while (n > 0) {
int half = n/2;
int mid = first + half;
if (err_str[mid].code < statcode) {
first = mid+1;
n -= (half+1);
} else if (err_str[mid].code > statcode) {
n = half;
} else {
first = mid;
break;
}
}
if (PJ_ARRAY_SIZE(err_str) && err_str[first].code == statcode) {
pj_str_t msg;
msg.ptr = (char*)err_str[first].msg;
msg.slen = pj_ansi_strlen(err_str[first].msg);
errstr.ptr = buf;
pj_strncpy_with_null(&errstr, &msg, bufsize);
return errstr;
}
}
#endif /* PJ_HAS_ERROR_STRING */
/* Error not found. */
errstr.ptr = buf;
errstr.slen = pj_ansi_snprintf(buf, bufsize,
"Unknown pjmedia error %d",
statcode);
return errstr;
}
int sdr1000_open(void) {
int arg;
int status;
int rc;
#ifdef PORTAUDIO
PaStreamParameters inputParameters;
PaStreamParameters outputParameters;
const PaStreamInfo *info;
int devices;
int i;
const PaDeviceInfo* deviceInfo;
fprintf(stderr,"sdr1000_open: portaudio\n");
#else
fprintf(stderr,"sdr1000_open: %s\n",sdr1000_get_device());
#endif
#ifdef PORTAUDIO
rc=Pa_Initialize();
if(rc!=paNoError) {
fprintf(stderr,"Pa_Initialize failed: %s\n",Pa_GetErrorText(rc));
exit(1);
}
devices=Pa_GetDeviceCount();
if(devices<0) {
fprintf(stderr,"Px_GetDeviceCount failed: %s\n",Pa_GetErrorText(devices));
} else {
fprintf(stderr,"default input=%d output=%d devices=%d\n",Pa_GetDefaultInputDevice(),Pa_GetDefaultOutputDevice(),devices);
for(i=0;i<devices;i++) {
deviceInfo=Pa_GetDeviceInfo(i);
fprintf(stderr,"%d - %s\n",i,deviceInfo->name);
fprintf(stderr,"maxInputChannels: %d\n",deviceInfo->maxInputChannels);
fprintf(stderr,"maxOututChannels: %d\n",deviceInfo->maxOutputChannels);
//fprintf(stderr,"defaultLowInputLatency: %f\n",deviceInfo->defaultLowInputLatency);
//fprintf(stderr,"defaultLowOutputLatency: %f\n",deviceInfo->defaultLowOutputLatency);
//fprintf(stderr,"defaultHighInputLatency: %f\n",deviceInfo->defaultHighInputLatency);
//fprintf(stderr,"defaultHighOutputLatency: %f\n",deviceInfo->defaultHighOutputLatency);
//fprintf(stderr,"defaultSampleRate: %f\n",deviceInfo->defaultSampleRate);
}
}
inputParameters.device=atoi(sdr1000_get_input());
inputParameters.channelCount=2;
inputParameters.sampleFormat=paFloat32;
inputParameters.suggestedLatency=Pa_GetDeviceInfo(inputParameters.device)->defaultLowInputLatency;
inputParameters.hostApiSpecificStreamInfo=NULL;
outputParameters.device=atoi(sdr1000_get_output());
outputParameters.channelCount=2;
outputParameters.sampleFormat=paFloat32;
outputParameters.suggestedLatency=Pa_GetDeviceInfo(outputParameters.device)->defaultLowOutputLatency;
outputParameters.hostApiSpecificStreamInfo=NULL;
fprintf(stderr,"input device=%d output device=%d\n",inputParameters.device,outputParameters.device);
rc=Pa_OpenStream(&stream,&inputParameters,&outputParameters,(double)sdr1000_get_sample_rate(),(unsigned long)SAMPLES_PER_BUFFER,paNoFlag,NULL,NULL);
if(rc!=paNoError) {
fprintf(stderr,"Pa_OpenStream failed: %s\n",Pa_GetErrorText(rc));
exit(1);
}
rc=Pa_StartStream(stream);
if(rc!=paNoError) {
fprintf(stderr,"Pa_StartStream failed: %s\n",Pa_GetErrorText(rc));
exit(1);
}
info=Pa_GetStreamInfo(stream);
if(info!=NULL) {
fprintf(stderr,"stream.sampleRate=%f\n",info->sampleRate);
fprintf(stderr,"stream.inputLatency=%f\n",info->inputLatency);
fprintf(stderr,"stream.outputLatency=%f\n",info->outputLatency);
} else {
fprintf(stderr,"Pa_GetStreamInfo returned NULL\n");
}
#else
/* open sound device */
fd = open(sdr1000_get_device(), O_RDWR);
if (fd < 0) {
perror("open of audio device failed");
exit(1);
}
/* set sampling parameters */
arg = SAMPLE_SIZE; /* sample size */
status = ioctl(fd, SOUND_PCM_WRITE_BITS, &arg);
if (status == -1)
perror("SOUND_PCM_WRITE_BITS ioctl failed");
if (arg != SAMPLE_SIZE)
perror("unable to set write sample size");
status = ioctl(fd, SOUND_PCM_READ_BITS, &arg);
if (status == -1)
perror("SOUND_PCM_READ_BITS ioctl failed");
if (arg != SAMPLE_SIZE)
perror("unable to set read sample size");
arg = CHANNELS; /* mono or stereo */
status = ioctl(fd, SOUND_PCM_WRITE_CHANNELS, &arg);
if (status == -1)
perror("SOUND_PCM_WRITE_CHANNELS ioctl failed");
if (arg != CHANNELS)
perror("unable to set number of channels");
arg = sdr1000_get_sample_rate(); /* sampling rate */
fprintf(stderr,"sample_rate: %d\n",arg);
status = ioctl(fd, SOUND_PCM_WRITE_RATE, &arg);
if (status == -1)
perror("SOUND_PCM_WRITE_WRITE ioctl failed");
arg = AFMT_S16_LE; /* signed little endian */
status = ioctl(fd, SOUND_PCM_SETFMT, &arg);
if (status == -1)
perror("SOUND_PCM_SETFMTS ioctl failed");
#endif
return 0;
}
int main(void)
{
PaStreamParameters inputParameters,
outputParameters;
PaStream* stream;
PaError err = paNoError;
paTestData data;
int i;
int totalFrames;
int numSamples;
int numBytes;
SAMPLE max, val;
double average;
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 ); /* From now on, recordedSamples is initialised. */
if( data.recordedSamples == NULL )
{
printf("Could not allocate record array.\n");
goto done;
}
for( i=0; i<numSamples; i++ ) data.recordedSamples[i] = 0;
err = Pa_Initialize();
if( err != paNoError ) goto done;
inputParameters.device = Pa_GetDefaultInputDevice(); /* default input device */
inputParameters.channelCount = 2; /* stereo input */
inputParameters.sampleFormat = PA_SAMPLE_TYPE;
inputParameters.suggestedLatency = Pa_GetDeviceInfo( inputParameters.device )->defaultLowInputLatency;
inputParameters.hostApiSpecificStreamInfo = NULL;
/* 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 */
recordCallback,
&data );
if( err != paNoError ) goto done;
err = Pa_StartStream( stream );
if( err != paNoError ) goto done;
printf("Now recording!!\n"); fflush(stdout);
while( ( err = Pa_IsStreamActive( stream ) ) == 1 )
{
Pa_Sleep(1000);
printf("index = %d\n", data.frameIndex ); fflush(stdout);
}
if( err < 0 ) goto done;
err = Pa_CloseStream( stream );
if( err != paNoError ) goto done;
/* Measure maximum peak amplitude. */
max = 0;
average = 0.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 / (double)numSamples;
printf("sample max amplitude = "PRINTF_S_FORMAT"\n", max );
printf("sample average = %lf\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;
outputParameters.device = Pa_GetDefaultOutputDevice(); /* default output device */
outputParameters.channelCount = 2; /* stereo output */
outputParameters.sampleFormat = PA_SAMPLE_TYPE;
outputParameters.suggestedLatency = Pa_GetDeviceInfo( outputParameters.device )->defaultLowOutputLatency;
outputParameters.hostApiSpecificStreamInfo = NULL;
printf("Begin playback.\n"); fflush(stdout);
err = Pa_OpenStream(
&stream,
NULL, /* no input */
&outputParameters,
SAMPLE_RATE,
FRAMES_PER_BUFFER,
paClipOff, /* we won't output out of range samples so don't bother clipping them */
playCallback,
&data );
if( err != paNoError ) goto done;
if( stream )
{
err = Pa_StartStream( stream );
if( err != paNoError ) goto done;
printf("Waiting for playback to finish.\n"); fflush(stdout);
while( ( err = Pa_IsStreamActive( stream ) ) == 1 ) Pa_Sleep(100);
if( err < 0 ) goto done;
err = Pa_CloseStream( stream );
if( err != paNoError ) goto done;
printf("Done.\n"); fflush(stdout);
}
done:
Pa_Terminate();
if( data.recordedSamples ) /* Sure it is NULL or valid. */
free( data.recordedSamples );
if( err != paNoError )
{
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 ) );
err = 1; /* Always return 0 or 1, but no other return codes. */
}
return err;
}
int main(void)
{
PortAudioStream *stream;
PaError err;
int numStress;
paTestData data = {0};
double load;
printf("PortAudio Test: output sine wave. SR = %d, BufSize = %d. MAX_LOAD = %f\n",
SAMPLE_RATE, FRAMES_PER_BUFFER, MAX_LOAD );
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;
/* Determine number of sines required to get to 50% */
do
{
data.numSines++;
Pa_Sleep( 100 );
load = Pa_GetCPULoad( stream );
printf("numSines = %d, CPU load = %f\n", data.numSines, load );
}
while( load < 0.5 );
/* Calculate target stress value then ramp up to that level*/
numStress = (int) (2.0 * data.numSines * MAX_LOAD );
for( ; data.numSines < numStress; data.numSines++ )
{
Pa_Sleep( 200 );
load = Pa_GetCPULoad( stream );
printf("STRESSING: numSines = %d, CPU load = %f\n", data.numSines, load );
}
printf("Suffer for 5 seconds.\n");
Pa_Sleep( 5000 );
printf("Stop stream.\n");
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)
{
PaStreamParameters inputParameters, outputParameters;
PaStream *stream;
PaError err;
err = Pa_Initialize();
if( err != paNoError ) goto error;
inputParameters.device = Pa_GetDefaultInputDevice(); /* default input device */
if (inputParameters.device == paNoDevice) {
fprintf(stderr,"Error: No default input device.\n");
goto error;
}
inputParameters.channelCount = 2; /* stereo input */
inputParameters.sampleFormat = PA_SAMPLE_TYPE;
inputParameters.suggestedLatency = Pa_GetDeviceInfo( inputParameters.device )->defaultLowInputLatency;
inputParameters.hostApiSpecificStreamInfo = NULL;
outputParameters.device = Pa_GetDefaultOutputDevice(); /* default output device */
if (outputParameters.device == paNoDevice) {
fprintf(stderr,"Error: No default output device.\n");
goto error;
}
outputParameters.channelCount = 2; /* stereo output */
outputParameters.sampleFormat = PA_SAMPLE_TYPE;
outputParameters.suggestedLatency = Pa_GetDeviceInfo( outputParameters.device )->defaultLowOutputLatency;
outputParameters.hostApiSpecificStreamInfo = NULL;
/* Instantiate FFT */
fft_new(&fft, FRAMES_PER_BUFFER);
spectrum = malloc(FRAMES_PER_BUFFER * sizeof(double));
/* Instantiate Spectral Features */
spectralFeatures_new(&features, FRAMES_PER_BUFFER);
err = Pa_OpenStream(
&stream,
&inputParameters,
&outputParameters,
SAMPLE_RATE,
FRAMES_PER_BUFFER,
0, /* paClipOff, */ /* we won't output out of range samples so don't bother clipping them */
onsetCallback,
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;
}
/* -- main function -- */
int main( int argc, char **argv ) {
PaStreamParameters inputParameters;
float a[2], b[3], mem1[4], mem2[4];
float data[FFT_SIZE];
float datai[FFT_SIZE];
float window[FFT_SIZE];
float freqTable[FFT_SIZE];
char * noteNameTable[FFT_SIZE];
float notePitchTable[FFT_SIZE];
void * fft = NULL;
PaStream *stream = NULL;
PaError err = 0;
struct sigaction action;
// add signal listen so we know when to exit:
action.sa_handler = signalHandler;
sigemptyset (&action.sa_mask);
action.sa_flags = 0;
sigaction (SIGINT, &action, NULL);
sigaction (SIGHUP, &action, NULL);
sigaction (SIGTERM, &action, NULL);
// build the window, fft, etc
/*
buildHanWindow( window, 30 );
for( int i=0; i<30; ++i ) {
for( int j=0; j<window[i]*50; ++j )
printf( "*" );
printf("\n");
}
exit(0);
*/
buildHanWindow( window, FFT_SIZE );
fft = initfft( FFT_EXP_SIZE );
computeSecondOrderLowPassParameters( SAMPLE_RATE, 330, a, b );
mem1[0] = 0;
mem1[1] = 0;
mem1[2] = 0;
mem1[3] = 0;
mem2[0] = 0;
mem2[1] = 0;
mem2[2] = 0;
mem2[3] = 0;
//freq/note tables
for( int i=0; i<FFT_SIZE; ++i ) {
freqTable[i] = ( SAMPLE_RATE * i ) / (float) ( FFT_SIZE );
}
for( int i=0; i<FFT_SIZE; ++i ) {
noteNameTable[i] = NULL;
notePitchTable[i] = -1;
}
for( int i=0; i<127; ++i ) {
float pitch = ( 440.0 / 32.0 ) * pow( 2, (i-9.0)/12.0 ) ;
if( pitch > SAMPLE_RATE / 2.0 )
break;
//find the closest frequency using brute force.
float min = 1000000000.0;
int index = -1;
for( int j=0; j<FFT_SIZE; ++j ) {
if( fabsf( freqTable[j]-pitch ) < min ) {
min = fabsf( freqTable[j]-pitch );
index = j;
}
}
noteNameTable[index] = NOTES[i%12];
notePitchTable[index] = pitch;
//printf( "%f %d %s\n", pitch, index, noteNameTable[index] );
}
// initialize portaudio
err = Pa_Initialize();
if( err != paNoError ) goto error;
inputParameters.device = Pa_GetDefaultInputDevice();
inputParameters.channelCount = 1;
inputParameters.sampleFormat = paFloat32;
inputParameters.suggestedLatency = Pa_GetDeviceInfo( inputParameters.device )->defaultHighInputLatency ;
inputParameters.hostApiSpecificStreamInfo = NULL;
printf( "Opening %s\n",
Pa_GetDeviceInfo( inputParameters.device )->name );
err = Pa_OpenStream( &stream,
&inputParameters,
NULL, //no output
SAMPLE_RATE,
FFT_SIZE,
paClipOff,
NULL,
NULL );
if( err != paNoError ) goto error;
err = Pa_StartStream( stream );
if( err != paNoError ) goto error;
// this is the main loop where we listen to and
// process audio.
while( running )
{
// read some data
err = Pa_ReadStream( stream, data, FFT_SIZE );
if( err ) goto error; //FIXME: we don't want to err on xrun
// low-pass
//for( int i=0; i<FFT_SIZE; ++i )
// printf( "in %f\n", data[i] );
for( int j=0; j<FFT_SIZE; ++j ) {
data[j] = processSecondOrderFilter( data[j], mem1, a, b );
data[j] = processSecondOrderFilter( data[j], mem2, a, b );
}
// window
applyWindow( window, data, FFT_SIZE );
// do the fft
for( int j=0; j<FFT_SIZE; ++j )
datai[j] = 0;
applyfft( fft, data, datai, false );
//find the peak
float maxVal = -1;
int maxIndex = -1;
for( int j=0; j<FFT_SIZE/2; ++j ) {
float v = data[j] * data[j] + datai[j] * datai[j] ;
/*
printf( "%d: ", j*SAMPLE_RATE/(2*FFT_SIZE) );
for( int i=0; i<sqrt(v)*100000000; ++i )
printf( "*" );
printf( "\n" );
*/
if( v > maxVal ) {
maxVal = v;
maxIndex = j;
}
}
float freq = freqTable[maxIndex];
//find the nearest note:
int nearestNoteDelta=0;
while( true ) {
if( nearestNoteDelta < maxIndex && noteNameTable[maxIndex-nearestNoteDelta] != NULL ) {
nearestNoteDelta = -nearestNoteDelta;
break;
} else if( nearestNoteDelta + maxIndex < FFT_SIZE && noteNameTable[maxIndex+nearestNoteDelta] != NULL ) {
break;
}
++nearestNoteDelta;
}
char * nearestNoteName = noteNameTable[maxIndex+nearestNoteDelta];
float nearestNotePitch = notePitchTable[maxIndex+nearestNoteDelta];
float centsSharp = 1200 * log( freq / nearestNotePitch ) / log( 2.0 );
// now output the results:
printf("\033[2J\033[1;1H"); //clear screen, go to top left
fflush(stdout);
printf( "Tuner listening. Control-C to exit.\n" );
printf( "%f Hz, %d : %f\n", freq, maxIndex, maxVal*1000 );
printf( "Nearest Note: %s\n", nearestNoteName );
if( nearestNoteDelta != 0 ) {
if( centsSharp > 0 )
printf( "%f cents sharp.\n", centsSharp );
if( centsSharp < 0 )
printf( "%f cents flat.\n", -centsSharp );
} else {
printf( "in tune!\n" );
}
printf( "\n" );
int chars = 30;
if( nearestNoteDelta == 0 || centsSharp >= 0 ) {
for( int i=0; i<chars; ++i )
printf( " " );
} else {
for( int i=0; i<chars+centsSharp; ++i )
printf( " " );
for( int i=chars+centsSharp<0?0:chars+centsSharp; i<chars; ++i )
printf( "=" );
}
printf( " %2s ", nearestNoteName );
if( nearestNoteDelta != 0 )
for( int i=0; i<chars && i<centsSharp; ++i )
printf( "=" );
printf("\n");
}
err = Pa_StopStream( stream );
if( err != paNoError ) goto error;
// cleanup
destroyfft( fft );
Pa_Terminate();
return 0;
error:
if( stream ) {
Pa_AbortStream( stream );
Pa_CloseStream( stream );
}
destroyfft( fft );
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(void)
{
PaStreamParameters inputParameters, outputParameters;
PaStream *stream;
PaError err;
SAMPLE *recordedSamples;
int i;
int totalFrames;
int numSamples;
int numBytes;
SAMPLE max, average, val;
printf("patest_read_record.c\n"); fflush(stdout);
totalFrames = NUM_SECONDS * SAMPLE_RATE; /* Record for a few seconds. */
numSamples = totalFrames * NUM_CHANNELS;
numBytes = numSamples * sizeof(SAMPLE);
recordedSamples = (SAMPLE *) malloc( numBytes );
if( recordedSamples == NULL )
{
printf("Could not allocate record array.\n");
exit(1);
}
for( i=0; i<numSamples; i++ ) recordedSamples[i] = 0;
err = Pa_Initialize();
if( err != paNoError ) goto error;
inputParameters.device = Pa_GetDefaultInputDevice(); /* default input device */
if (inputParameters.device == paNoDevice) {
fprintf(stderr,"Error: No default input device.\n");
goto error;
}
inputParameters.channelCount = NUM_CHANNELS;
inputParameters.sampleFormat = PA_SAMPLE_TYPE;
inputParameters.suggestedLatency = Pa_GetDeviceInfo( inputParameters.device )->defaultLowInputLatency;
inputParameters.hostApiSpecificStreamInfo = NULL;
/* 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 */
NULL, /* no callback, use blocking API */
NULL ); /* no callback, so no callback userData */
if( err != paNoError ) goto error;
err = Pa_StartStream( stream );
if( err != paNoError ) goto error;
printf("Now recording!!\n"); fflush(stdout);
err = Pa_ReadStream( stream, recordedSamples, totalFrames );
if( err != paNoError ) goto error;
err = Pa_CloseStream( stream );
if( err != paNoError ) goto error;
/* Measure maximum peak amplitude. */
max = 0;
average = 0;
for( i=0; i<numSamples; i++ )
{
val = recordedSamples[i];
if( val < 0 ) val = -val; /* ABS */
if( val > max )
{
max = val;
}
average += val;
}
average = average / numSamples;
printf("Sample max amplitude = "PRINTF_S_FORMAT"\n", max );
printf("Sample average = "PRINTF_S_FORMAT"\n", average );
/* Was as below. Better choose at compile time because this
keeps generating compiler-warnings:
if( PA_SAMPLE_TYPE == paFloat32 )
{
printf("sample max amplitude = %f\n", max );
printf("sample average = %f\n", average );
}
else
{
printf("sample max amplitude = %d\n", max );
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( recordedSamples, NUM_CHANNELS * sizeof(SAMPLE), totalFrames, fid );
fclose( fid );
printf("Wrote data to 'recorded.raw'\n");
}
}
#endif
/* Playback recorded data. -------------------------------------------- */
outputParameters.device = Pa_GetDefaultOutputDevice(); /* default output device */
if (outputParameters.device == paNoDevice) {
fprintf(stderr,"Error: No default output device.\n");
goto error;
}
outputParameters.channelCount = NUM_CHANNELS;
outputParameters.sampleFormat = PA_SAMPLE_TYPE;
outputParameters.suggestedLatency = Pa_GetDeviceInfo( outputParameters.device )->defaultLowOutputLatency;
outputParameters.hostApiSpecificStreamInfo = NULL;
printf("Begin playback.\n"); fflush(stdout);
err = Pa_OpenStream(
&stream,
NULL, /* no input */
&outputParameters,
SAMPLE_RATE,
FRAMES_PER_BUFFER,
paClipOff, /* we won't output out of range samples so don't bother clipping them */
NULL, /* no callback, use blocking API */
NULL ); /* no callback, so no callback userData */
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);
err = Pa_WriteStream( stream, recordedSamples, totalFrames );
if( err != paNoError ) goto error;
err = Pa_CloseStream( stream );
if( err != paNoError ) goto error;
printf("Done.\n"); fflush(stdout);
}
free( 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(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;
}
int main(void)
{
// PortAudioStream *stream;
// int inputDevice = Pa_GetDefaultInputDeviceID();
// int i,numDevices;
// PaDeviceInfo pdi;
// printf("Channel data acquisition configuration test\n");
// printf("\n"); fflush(stdout);
// numDevices = Pa_CountDevices();
// printf( "Number of total devices : Pa_CountDevices()\t: %d.\n", numDevices );
// for( i=0; i<numDevices; i++ ) {
// pdi = *Pa_GetDeviceInfo( i );
// printf("Device(%d) name \t: %s.\n", i, pdi.name);
// printf("\tMax Inputs = %d\n", pdi.maxInputChannels );
// printf("\tMax Outputs = %d\n", pdi.maxOutputChannels );
// }
// printf("Default Devic id : %d.\n", Pa_GetDefaultInputDeviceID() );
int i,numDevices;
PaDeviceInfo pdi;
PaError err;
err = Pa_Initialize();
if( err != paNoError )
goto error;
numDevices = Pa_CountDevices();
printf( "Number of total devices : Pa_CountDevices()\t: %d.\n", numDevices );
for( i=0; i<numDevices; i++ )
{
pdi = *Pa_GetDeviceInfo( i );
printf("Device(%d) name \t: %s.\n", i, pdi.name);
printf("\tMax Inputs = %d\n", pdi.maxInputChannels );
printf("\tMax Outputs = %d\n", pdi.maxOutputChannels );
}
printf("Default Devic id : %d.\n", Pa_GetDefaultInputDeviceID() );
Pa_Terminate();
printf("\n");
audio_rc_open();
printf("\nNow display channel acquisition 0 up to 9 during 10seconds!!\n");
fflush(stdout);
for( i=0; i<100; i++ )
{
Pa_Sleep(100);
/* launch test */
audio_rc_test();
fflush(stdout);
}
audio_rc_close();
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(void)
{
PaStreamParameters outputParameters;
PaStream *stream;
PaError err;
TestData data;
int i, j;
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. );
}
err = Pa_Initialize();
if( err != paNoError ) goto error;
outputParameters.device = Pa_GetDefaultOutputDevice();
outputParameters.channelCount = 2; /* stereo output */
outputParameters.sampleFormat = paFloat32; /* 32 bit floating point output */
outputParameters.suggestedLatency = Pa_GetDeviceInfo( outputParameters.device )->defaultLowOutputLatency;
outputParameters.hostApiSpecificStreamInfo = NULL;
err = Pa_OpenStream(
&stream,
NULL, /* no input */
&outputParameters,
SAMPLE_RATE,
FRAMES_PER_BUFFER,
paClipOff, /* output will be in-range, so no need to clip */
TestCallback,
&data );
if( err != paNoError ) goto error;
printf("Repeating test %d times.\n", NUM_LOOPS );
for( i=0; i < NUM_LOOPS; ++i )
{
data.phase = 0;
data.generatedFramesCount = 0;
data.callbackReturnedPaComplete = 0;
data.callbackInvokedAfterReturningPaComplete = 0;
err = Pa_StartStream( stream );
if( err != paNoError ) goto error;
printf("Play for %d seconds.\n", NUM_SECONDS );
/* wait for the callback to complete generating NUM_SECONDS of tone */
do
{
Pa_Sleep( 500 );
}
while( !data.callbackReturnedPaComplete );
printf( "Callback returned paComplete.\n" );
printf( "Waiting for buffers to finish playing...\n" );
/* wait for stream to become inactive,
or for a timeout of approximately NUM_SECONDS
*/
j = 0;
while( (err = Pa_IsStreamActive( stream )) == 1 && j < NUM_SECONDS * 2 )
{
printf(".\n" );
Pa_Sleep( 500 );
++j;
}
if( err < 0 )
{
goto error;
}
else if( err == 1 )
{
printf( "TEST FAILED: Timed out waiting for buffers to finish playing.\n" );
}
else
{
printf("Buffers finished.\n" );
}
if( data.callbackInvokedAfterReturningPaComplete )
{
printf( "TEST FAILED: Callback was invoked after returning paComplete.\n" );
}
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 void pa_checkerror(lua_State *L, PaError err)
{
if(err != paNoError)
luaL_error(L, "An error occured while using the portaudio stream: %s", Pa_GetErrorText(err));
}
static int PAOpenDevice( aout_instance_t *p_aout )
{
aout_sys_t *p_sys = p_aout->output.p_sys;
const PaDeviceInfo *p_pdi;
PaError i_err;
vlc_value_t val, text;
int i;
/* Initialize portaudio */
i_err = Pa_Initialize();
if( i_err != paNoError )
{
msg_Err( p_aout, "Pa_Initialize returned %d : %s",
i_err, Pa_GetErrorText( i_err ) );
return VLC_EGENERIC;
}
p_sys->i_devices = Pa_GetDeviceCount();
if( p_sys->i_devices < 0 )
{
i_err = p_sys->i_devices;
msg_Err( p_aout, "Pa_GetDeviceCount returned %d : %s", i_err,
Pa_GetErrorText( i_err ) );
goto error;
}
/* Display all devices info */
msg_Dbg( p_aout, "number of devices = %d", p_sys->i_devices );
for( i = 0; i < p_sys->i_devices; i++ )
{
p_pdi = Pa_GetDeviceInfo( i );
msg_Dbg( p_aout, "------------------------------------- #%d", i );
msg_Dbg( p_aout, "Name = %s", p_pdi->name );
msg_Dbg( p_aout, "Max Inputs = %d, Max Outputs = %d",
p_pdi->maxInputChannels, p_pdi->maxOutputChannels );
}
msg_Dbg( p_aout, "-------------------------------------" );
msg_Dbg( p_aout, "requested device is #%d", p_sys->i_device_id );
if( p_sys->i_device_id >= p_sys->i_devices )
{
msg_Err( p_aout, "device %d does not exist", p_sys->i_device_id );
goto error;
}
p_sys->deviceInfo = Pa_GetDeviceInfo( p_sys->i_device_id );
if( p_sys->deviceInfo->maxOutputChannels < 1 )
{
msg_Err( p_aout, "no channel available" );
goto error;
}
if( var_Type( p_aout, "audio-device" ) == 0 )
{
var_Create( p_aout, "audio-device", VLC_VAR_INTEGER|VLC_VAR_HASCHOICE);
text.psz_string = _("Audio Device");
var_Change( p_aout, "audio-device", VLC_VAR_SETTEXT, &text, NULL );
if( p_sys->deviceInfo->maxOutputChannels >= 1 )
{
val.i_int = AOUT_VAR_MONO;
text.psz_string = _("Mono");
var_Change( p_aout, "audio-device", VLC_VAR_ADDCHOICE,
&val, &text );
msg_Dbg( p_aout, "device supports 1 channel" );
}
if( p_sys->deviceInfo->maxOutputChannels >= 2 )
{
val.i_int = AOUT_VAR_STEREO;
text.psz_string = _("Stereo");
var_Change( p_aout, "audio-device", VLC_VAR_ADDCHOICE,
&val, &text );
var_Change( p_aout, "audio-device", VLC_VAR_SETDEFAULT,
&val, NULL );
var_Set( p_aout, "audio-device", val );
msg_Dbg( p_aout, "device supports 2 channels" );
}
if( p_sys->deviceInfo->maxOutputChannels >= 4 )
{
val.i_int = AOUT_VAR_2F2R;
text.psz_string = _("2 Front 2 Rear");
var_Change( p_aout, "audio-device", VLC_VAR_ADDCHOICE,
&val, &text );
msg_Dbg( p_aout, "device supports 4 channels" );
}
if( p_sys->deviceInfo->maxOutputChannels >= 5 )
{
val.i_int = AOUT_VAR_3F2R;
text.psz_string = _("3 Front 2 Rear");
var_Change( p_aout, "audio-device",
VLC_VAR_ADDCHOICE, &val, &text );
msg_Dbg( p_aout, "device supports 5 channels" );
}
if( p_sys->deviceInfo->maxOutputChannels >= 6 )
{
val.i_int = AOUT_VAR_5_1;
text.psz_string = "5.1";
var_Change( p_aout, "audio-device", VLC_VAR_ADDCHOICE,
&val, &text );
msg_Dbg( p_aout, "device supports 5.1 channels" );
}
var_AddCallback( p_aout, "audio-device", aout_ChannelsRestart, NULL );
var_SetBool( p_aout, "intf-change", true );
}
/* Audio format is paFloat32 (always supported by portaudio v19) */
p_aout->output.output.i_format = VLC_CODEC_FL32;
return VLC_SUCCESS;
error:
if( ( i_err = Pa_Terminate() ) != paNoError )
{
msg_Err( p_aout, "Pa_Terminate returned %d", i_err );
}
return VLC_EGENERIC;
}
