gearmulator

paqa.c (49814B)

---

 
 /*
  * PortAudio Portable Real-Time Audio Library
  * Latest Version at: http://www.portaudio.com
  *
  * Copyright (c) 1999-2010 Phil Burk and Ross Bencina
  *
  * Permission is hereby granted, free of charge, to any person obtaining
  * a copy of this software and associated documentation files
  * (the "Software"), to deal in the Software without restriction,
  * including without limitation the rights to use, copy, modify, merge,
  * publish, distribute, sublicense, and/or sell copies of the Software,
  * and to permit persons to whom the Software is furnished to do so,
  * subject to the following conditions:
  *
  * The above copyright notice and this permission notice shall be
  * included in all copies or substantial portions of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
  * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
 /*
  * The text above constitutes the entire PortAudio license; however, 
  * the PortAudio community also makes the following non-binding requests:
  *
  * Any person wishing to distribute modifications to the Software is
  * requested to send the modifications to the original developer so that
  * they can be incorporated into the canonical version. It is also 
  * requested that these non-binding requests be included along with the 
  * license above.
  */
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <memory.h>
 #include <math.h>
 #include <string.h>
 
 #include "portaudio.h"
 
 #include "qa_tools.h"
 
 #include "paqa_tools.h"
 #include "audio_analyzer.h"
 #include "test_audio_analyzer.h"
 
 /** Accumulate counts for how many tests pass or fail. */
 int g_testsPassed = 0;
 int g_testsFailed = 0;
 
 #define MAX_NUM_GENERATORS                   (8)
 #define MAX_NUM_RECORDINGS                   (8)
 #define MAX_BACKGROUND_NOISE_RMS             (0.0004)
 #define LOOPBACK_DETECTION_DURATION_SECONDS  (0.8)
 #define DEFAULT_FRAMES_PER_BUFFER            (0)
 #define PAQA_WAIT_STREAM_MSEC                (100)
 #define PAQA_TEST_DURATION                   (1.2)
 
 // Use two separate streams instead of one full duplex stream.
 #define PAQA_FLAG_TWO_STREAMS       (1<<0)
 // Use bloching read/write for loopback.
 #define PAQA_FLAG_USE_BLOCKING_IO   (1<<1)
 
 const char * s_FlagOnNames[] =
 {
 	"Two Streams (Half Duplex)",
 	"Blocking Read/Write"
 };
 
 const char * s_FlagOffNames[] =
 {
 	"One Stream (Full Duplex)",
 	"Callback"
 };
 
 
 /** Parameters that describe a single test run. */
 typedef struct TestParameters_s
 {
 	PaStreamParameters inputParameters;
 	PaStreamParameters outputParameters;
 	double             sampleRate;
 	int                samplesPerFrame;
 	int                framesPerBuffer;
 	int                maxFrames;
 	double             baseFrequency;
 	double             amplitude;
     PaStreamFlags      streamFlags;  // paClipOff, etc
 	int                flags;        // PAQA_FLAG_TWO_STREAMS, PAQA_FLAG_USE_BLOCKING_IO
 } TestParameters;
 
 typedef struct LoopbackContext_s
 {
 	// Generate a unique signal on each channel.
 	PaQaSineGenerator  generators[MAX_NUM_GENERATORS];
 	// Record each channel individually.
 	PaQaRecording      recordings[MAX_NUM_RECORDINGS];
 	
 	// Reported by the stream after it's opened
 	PaTime             streamInfoInputLatency;
 	PaTime             streamInfoOutputLatency;
 
 	// Measured at runtime.
 	volatile int       callbackCount; // incremented for each callback
 	volatile int       inputBufferCount; // incremented if input buffer not NULL
 	int                inputUnderflowCount;
 	int                inputOverflowCount;
 	
 	volatile int       outputBufferCount; // incremented if output buffer not NULL
 	int                outputOverflowCount;
 	int                outputUnderflowCount;
 	
     // Measure whether input or output is lagging behind.
     volatile int       minInputOutputDelta;
     volatile int       maxInputOutputDelta;
     
 	int                minFramesPerBuffer;
 	int                maxFramesPerBuffer;
 	int                primingCount;
 	TestParameters    *test;
 	volatile int       done;
 } LoopbackContext;
 
 typedef struct UserOptions_s
 {
 	int           sampleRate;
 	int           framesPerBuffer;
 	int           inputLatency;
 	int           outputLatency;
 	int           saveBadWaves;
 	int           verbose;
 	int           waveFileCount;
 	const char   *waveFilePath;
 	PaDeviceIndex inputDevice;
 	PaDeviceIndex outputDevice;
 } UserOptions;
 
 #define BIG_BUFFER_SIZE  (sizeof(float) * 2 * 2 * 1024)
 static unsigned char g_ReadWriteBuffer[BIG_BUFFER_SIZE];
 
 #define MAX_CONVERSION_SAMPLES   (2 * 32 * 1024)
 #define CONVERSION_BUFFER_SIZE  (sizeof(float) * 2 * MAX_CONVERSION_SAMPLES)
 static unsigned char g_ConversionBuffer[CONVERSION_BUFFER_SIZE];
 
 /*******************************************************************/
 static int RecordAndPlaySinesCallback( const void *inputBuffer, void *outputBuffer,
 						unsigned long framesPerBuffer,
 						const PaStreamCallbackTimeInfo* timeInfo,
 						PaStreamCallbackFlags statusFlags,
 						void *userData )
 {
 	int i;
 	LoopbackContext *loopbackContext = (LoopbackContext *) userData;
 	
 	
 	loopbackContext->callbackCount += 1;
 	if( statusFlags & paInputUnderflow ) loopbackContext->inputUnderflowCount += 1;
 	if( statusFlags & paInputOverflow ) loopbackContext->inputOverflowCount += 1;
 	if( statusFlags & paOutputUnderflow ) loopbackContext->outputUnderflowCount += 1;
 	if( statusFlags & paOutputOverflow ) loopbackContext->outputOverflowCount += 1;
 	if( statusFlags & paPrimingOutput ) loopbackContext->primingCount += 1;
 	if( framesPerBuffer > loopbackContext->maxFramesPerBuffer )
 	{
 		loopbackContext->maxFramesPerBuffer = framesPerBuffer;
 	}
 	if( framesPerBuffer < loopbackContext->minFramesPerBuffer )
 	{
 		loopbackContext->minFramesPerBuffer = framesPerBuffer;
 	}
 	
     /* This may get called with NULL inputBuffer during initial setup.
 	 * We may also use the same callback with output only streams.
 	 */
 	if( inputBuffer != NULL)
 	{
 		int channelsPerFrame = loopbackContext->test->inputParameters.channelCount;
 		float *in = (float *)inputBuffer;
 		PaSampleFormat inFormat = loopbackContext->test->inputParameters.sampleFormat;
 		
 		loopbackContext->inputBufferCount += 1;
 		
 		if( inFormat != paFloat32 )
 		{
 			int samplesToConvert = framesPerBuffer * channelsPerFrame;
 			in = (float *) g_ConversionBuffer;
 			if( samplesToConvert > MAX_CONVERSION_SAMPLES )
 			{
 				// Hack to prevent buffer overflow.
 				// @todo Loop with small buffer instead of failing.
 				printf("Format conversion buffer too small!\n");
 				return paComplete;
 			}
 			PaQa_ConvertToFloat( inputBuffer, samplesToConvert, inFormat, (float *) g_ConversionBuffer );
 		}
 		
 		// Read each channel from the buffer.
 		for( i=0; i<channelsPerFrame; i++ )
 		{			
 			loopbackContext->done |= PaQa_WriteRecording( &loopbackContext->recordings[i],
 										in + i, 
 										framesPerBuffer,
 										channelsPerFrame );
 		}
 	}
 	
 	if( outputBuffer != NULL )
 	{
 		int channelsPerFrame = loopbackContext->test->outputParameters.channelCount;
 		float *out = (float *)outputBuffer;
 		PaSampleFormat outFormat = loopbackContext->test->outputParameters.sampleFormat;
 		
 		loopbackContext->outputBufferCount += 1;
 		
 		if( outFormat != paFloat32 )
 		{
 			// If we need to convert then mix to the g_ConversionBuffer and then convert into the PA outputBuffer.
 			out = (float *) g_ConversionBuffer;
 		}
 			
 		PaQa_EraseBuffer( out, framesPerBuffer, channelsPerFrame );
 		for( i=0; i<channelsPerFrame; i++ )
 		{
 			PaQa_MixSine( &loopbackContext->generators[i],
 						 out + i,
 						 framesPerBuffer,
 						 channelsPerFrame );
 		}
 		
 		if( outFormat != paFloat32 )
 		{
 			int samplesToConvert = framesPerBuffer * channelsPerFrame;
 			if( samplesToConvert > MAX_CONVERSION_SAMPLES )
 			{
 				printf("Format conversion buffer too small!\n");
 				return paComplete;
 			}			
 			PaQa_ConvertFromFloat( out, framesPerBuffer * channelsPerFrame, outFormat, outputBuffer );
 		}
 		
 	}
     
     // Measure whether the input or output are lagging behind.
     // Don't measure lag at end.
     if( !loopbackContext->done )
     {        
         int inputOutputDelta = loopbackContext->inputBufferCount - loopbackContext->outputBufferCount;
         if( loopbackContext->maxInputOutputDelta < inputOutputDelta )
         {
             loopbackContext->maxInputOutputDelta = inputOutputDelta;
         }
         if( loopbackContext->minInputOutputDelta > inputOutputDelta )
         {
             loopbackContext->minInputOutputDelta = inputOutputDelta;
         }
     }
     
 	return loopbackContext->done ? paComplete : paContinue;
 }
 
 static void CopyStreamInfoToLoopbackContext( LoopbackContext *loopbackContext, PaStream *inputStream, PaStream *outputStream )
 {
 	const PaStreamInfo *inputStreamInfo = Pa_GetStreamInfo( inputStream );
 	const PaStreamInfo *outputStreamInfo = Pa_GetStreamInfo( outputStream );
 
 	loopbackContext->streamInfoInputLatency = inputStreamInfo ? inputStreamInfo->inputLatency : -1;
 	loopbackContext->streamInfoOutputLatency = outputStreamInfo ? outputStreamInfo->outputLatency : -1;
 }
 
 /*******************************************************************/
 /** 
  * Open a full duplex audio stream.
  * Generate sine waves on the output channels and record the input channels.
  * Then close the stream.
  * @return 0 if OK or negative error.
  */
 int PaQa_RunLoopbackFullDuplex( LoopbackContext *loopbackContext )
 {
 	PaStream *stream = NULL;
 	PaError err = 0;
 	TestParameters *test = loopbackContext->test;
 	loopbackContext->done = 0;
 	// Use one full duplex stream.
 	err = Pa_OpenStream(
 					&stream,
 					&test->inputParameters,
 					&test->outputParameters,
 					test->sampleRate,
 					test->framesPerBuffer,
 					paClipOff, /* we won't output out of range samples so don't bother clipping them */
 					RecordAndPlaySinesCallback,
 					loopbackContext );
 	if( err != paNoError ) goto error;
 	
 	CopyStreamInfoToLoopbackContext( loopbackContext, stream, stream );
 
 	err = Pa_StartStream( stream );
 	if( err != paNoError ) goto error;
 		
 	// Wait for stream to finish.
 	while( loopbackContext->done == 0 )
 	{
 		Pa_Sleep(PAQA_WAIT_STREAM_MSEC);
 	}
 	
 	err = Pa_StopStream( stream );
 	if( err != paNoError ) goto error;
 
 	err = Pa_CloseStream( stream );
 	if( err != paNoError ) goto error;
 		
 	return 0;
 	
 error:
 	return err;	
 }
 
 /*******************************************************************/
 /** 
  * Open two audio streams, one for input and one for output.
  * Generate sine waves on the output channels and record the input channels.
  * Then close the stream.
  * @return 0 if OK or paTimedOut.
  */
 
 int PaQa_WaitForStream( LoopbackContext *loopbackContext )
 {
 	int timeoutMSec = 1000 * PAQA_TEST_DURATION * 2;
 	
 	// Wait for stream to finish or timeout.
 	while( (loopbackContext->done == 0) && (timeoutMSec > 0) )
 	{
 		Pa_Sleep(PAQA_WAIT_STREAM_MSEC);
 		timeoutMSec -= PAQA_WAIT_STREAM_MSEC;
 	}
 	
 	if( loopbackContext->done == 0 )
 	{
 		printf("ERROR - stream completion timed out!");
 		return paTimedOut;
 	}
 	return 0;
 }
 
 /*******************************************************************/
 /** 
  * Open two audio streams, one for input and one for output.
  * Generate sine waves on the output channels and record the input channels.
  * Then close the stream.
  * @return 0 if OK or negative error.
  */
 int PaQa_RunLoopbackHalfDuplex( LoopbackContext *loopbackContext )
 {
 	PaStream *inStream = NULL;
 	PaStream *outStream = NULL;
 	PaError err = 0;
 	int timedOut = 0;
 	TestParameters *test = loopbackContext->test;
 	loopbackContext->done = 0;
 	
 	// Use two half duplex streams.
 	err = Pa_OpenStream(
 						&inStream,
 						&test->inputParameters,
 						NULL,
 						test->sampleRate,
 						test->framesPerBuffer,
 						test->streamFlags,
 						RecordAndPlaySinesCallback,
 						loopbackContext );
 	if( err != paNoError ) goto error;
 	err = Pa_OpenStream(
 						&outStream,
 						NULL,
 						&test->outputParameters,
 						test->sampleRate,
 						test->framesPerBuffer,
 						test->streamFlags,
 						RecordAndPlaySinesCallback,
 						loopbackContext );
 	if( err != paNoError ) goto error;
 
 	CopyStreamInfoToLoopbackContext( loopbackContext, inStream, outStream );
 
 	err = Pa_StartStream( inStream );
 	if( err != paNoError ) goto error;
 	
 	// Start output later so we catch the beginning of the waveform.
 	err = Pa_StartStream( outStream );
 	if( err != paNoError ) goto error;
 	
 	timedOut = PaQa_WaitForStream( loopbackContext );
 	
 	err = Pa_StopStream( inStream );
 	if( err != paNoError ) goto error;
 		
 	err = Pa_StopStream( outStream );
 	if( err != paNoError ) goto error;
 	
 	err = Pa_CloseStream( inStream );
 	if( err != paNoError ) goto error;
 	
 	err = Pa_CloseStream( outStream );
 	if( err != paNoError ) goto error;
 	
 	return timedOut;
 	
 error:
 	return err;	
 }
 
 
 /*******************************************************************/
 /** 
  * Open one audio streams, just for input.
  * Record background level.
  * Then close the stream.
  * @return 0 if OK or negative error.
  */
 int PaQa_RunInputOnly( LoopbackContext *loopbackContext )
 {
 	PaStream *inStream = NULL;
 	PaError err = 0;
 	int timedOut = 0;
 	TestParameters *test = loopbackContext->test;
 	loopbackContext->done = 0;
 	
 	// Just open an input stream.
 	err = Pa_OpenStream(
 						&inStream,
 						&test->inputParameters,
 						NULL,
 						test->sampleRate,
 						test->framesPerBuffer,
 						paClipOff, /* We won't output out of range samples so don't bother clipping them. */
 						RecordAndPlaySinesCallback,
 						loopbackContext );
 	if( err != paNoError ) goto error;
 
 	err = Pa_StartStream( inStream );
 	if( err != paNoError ) goto error;
 	
 	timedOut = PaQa_WaitForStream( loopbackContext );
 	
 	err = Pa_StopStream( inStream );
 	if( err != paNoError ) goto error;
 	
 	err = Pa_CloseStream( inStream );
 	if( err != paNoError ) goto error;
 	
 	return timedOut;
 	
 error:
 	return err;	
 }
 
 /*******************************************************************/
 static int RecordAndPlayBlockingIO( PaStream *inStream,
 									  PaStream *outStream,
 									  LoopbackContext *loopbackContext
 									  )
 {	
 	int i;
 	float *in = (float *)g_ReadWriteBuffer;
 	float *out = (float *)g_ReadWriteBuffer;
 	PaError err;
 	int done = 0;
 	long available;
 	const long maxPerBuffer = 64;
 	TestParameters *test = loopbackContext->test;
 	long framesPerBuffer = test->framesPerBuffer;
 	if( framesPerBuffer <= 0 )
 	{
 		framesPerBuffer = maxPerBuffer; // bigger values might run past end of recording
 	}
 	
 	// Read in audio.
 	err = Pa_ReadStream( inStream, in, framesPerBuffer );
 	// Ignore an overflow on the first read.
 	//if( !((loopbackContext->callbackCount == 0) && (err == paInputOverflowed)) )
 	if( err != paInputOverflowed )
 	{
 		QA_ASSERT_EQUALS( "Pa_ReadStream failed", paNoError, err );
 	}
 	else
 	{
 		loopbackContext->inputOverflowCount += 1;
 	}
 
 	
 	// Save in a recording.
 	for( i=0; i<loopbackContext->test->inputParameters.channelCount; i++ )
 	{
 		done |= PaQa_WriteRecording( &loopbackContext->recordings[i],
 		         in + i,
 		         framesPerBuffer,
 		         loopbackContext->test->inputParameters.channelCount );
 	}
 	
 	// Synthesize audio.
 	available = Pa_GetStreamWriteAvailable( outStream );
 	if( available > (2*framesPerBuffer) ) available = (2*framesPerBuffer);
 	PaQa_EraseBuffer( out, available, loopbackContext->test->outputParameters.channelCount );
 	for( i=0; i<loopbackContext->test->outputParameters.channelCount; i++ )
 	{
 		PaQa_MixSine( &loopbackContext->generators[i],
 		          out + i,
 		          available,
 		          loopbackContext->test->outputParameters.channelCount );
 	}
 	
 	// Write out audio.
 	err = Pa_WriteStream( outStream, out, available );
 	// Ignore an underflow on the first write.
 	//if( !((loopbackContext->callbackCount == 0) && (err == paOutputUnderflowed)) )
 	if( err != paOutputUnderflowed )
 	{
 		QA_ASSERT_EQUALS( "Pa_WriteStream failed", paNoError, err );
 	}
 	else
 	{
 		loopbackContext->outputUnderflowCount += 1;
 	}
 	
 		
 	loopbackContext->callbackCount += 1;
 	
 	return done;
 error:
 	return err;
 }
 
 
 /*******************************************************************/
 /** 
  * Open two audio streams with non-blocking IO.
  * Generate sine waves on the output channels and record the input channels.
  * Then close the stream.
  * @return 0 if OK or negative error.
  */
 int PaQa_RunLoopbackHalfDuplexBlockingIO( LoopbackContext *loopbackContext )
 {
 	PaStream *inStream = NULL;
 	PaStream *outStream = NULL;
 	PaError err = 0;
 	TestParameters *test = loopbackContext->test;
 	
 	// Use two half duplex streams.
 	err = Pa_OpenStream(
 						&inStream,
 						&test->inputParameters,
 						NULL,
 						test->sampleRate,
 						test->framesPerBuffer,
 						paClipOff, /* we won't output out of range samples so don't bother clipping them */
 						NULL, // causes non-blocking IO
 						NULL );
 	if( err != paNoError ) goto error1;
 	err = Pa_OpenStream(
 						&outStream,
 						NULL,
 						&test->outputParameters,
 						test->sampleRate,
 						test->framesPerBuffer,
 						paClipOff, /* we won't output out of range samples so don't bother clipping them */
 						NULL, // causes non-blocking IO
 						NULL );
 	if( err != paNoError ) goto error2;
 	
 	CopyStreamInfoToLoopbackContext( loopbackContext, inStream, outStream );
 
 	err = Pa_StartStream( outStream );
 	if( err != paNoError ) goto error3;
 	
 	err = Pa_StartStream( inStream );
 	if( err != paNoError ) goto error3;
 	
 	while( err == 0 )
 	{
 		err = RecordAndPlayBlockingIO( inStream, outStream, loopbackContext );
 		if( err < 0 ) goto error3;
 	}
 	
 	err = Pa_StopStream( inStream );
 	if( err != paNoError ) goto error3;
 	
 	err = Pa_StopStream( outStream );
 	if( err != paNoError ) goto error3;
 	
 	err = Pa_CloseStream( outStream );
 	if( err != paNoError ) goto error2;
 	
 	err = Pa_CloseStream( inStream );
 	if( err != paNoError ) goto error1;
 	
 	
 	return 0;
 	
 error3:
 	Pa_CloseStream( outStream );
 error2:
 	Pa_CloseStream( inStream );
 error1:
 	return err;	
 }
 
 
 /*******************************************************************/
 /** 
  * Open one audio stream with non-blocking IO.
  * Generate sine waves on the output channels and record the input channels.
  * Then close the stream.
  * @return 0 if OK or negative error.
  */
 int PaQa_RunLoopbackFullDuplexBlockingIO( LoopbackContext *loopbackContext )
 {
 	PaStream *stream = NULL;
 	PaError err = 0;
 	TestParameters *test = loopbackContext->test;
 	
 	// Use one full duplex stream.
 	err = Pa_OpenStream(
 						&stream,
 						&test->inputParameters,
 						&test->outputParameters,
 						test->sampleRate,
 						test->framesPerBuffer,
 						paClipOff, /* we won't output out of range samples so don't bother clipping them */
 						NULL, // causes non-blocking IO
 						NULL );
 	if( err != paNoError ) goto error1;
 		
 	CopyStreamInfoToLoopbackContext( loopbackContext, stream, stream );
 
 	err = Pa_StartStream( stream );
 	if( err != paNoError ) goto error2;
 	
 	while( err == 0 )
 	{
 		err = RecordAndPlayBlockingIO( stream, stream, loopbackContext );
 		if( err < 0 ) goto error2;
 	}
 	
 	err = Pa_StopStream( stream );
 	if( err != paNoError ) goto error2;
 	
 	
 	err = Pa_CloseStream( stream );
 	if( err != paNoError ) goto error1;
 	
 	
 	return 0;
 	
 error2:
 	Pa_CloseStream( stream );
 error1:
 	return err;	
 }
 
 
 /*******************************************************************/
 /** 
  * Run some kind of loopback test.
  * @return 0 if OK or negative error.
  */
 int PaQa_RunLoopback( LoopbackContext *loopbackContext )
 {
 	PaError err = 0;
 	TestParameters *test = loopbackContext->test;
 	
 	
 	if( test->flags & PAQA_FLAG_TWO_STREAMS )
 	{
 		if( test->flags & PAQA_FLAG_USE_BLOCKING_IO )
 		{
 			err = PaQa_RunLoopbackHalfDuplexBlockingIO( loopbackContext );
 		}
 		else
 		{
 			err = PaQa_RunLoopbackHalfDuplex( loopbackContext );
 		}
 	}
 	else
 	{
 		if( test->flags & PAQA_FLAG_USE_BLOCKING_IO )
 		{
 			err = PaQa_RunLoopbackFullDuplexBlockingIO( loopbackContext );
 		}
 		else
 		{
 			err = PaQa_RunLoopbackFullDuplex( loopbackContext );
 		}
 	}
 	
 	if( err != paNoError )
 	{
 		printf("PortAudio error = %s\n", Pa_GetErrorText( err ) );
 	}
 	return err;	
 }
 
 /*******************************************************************/
 static int PaQa_SaveTestResultToWaveFile( UserOptions *userOptions, PaQaRecording *recording )
 {
 	if( userOptions->saveBadWaves )
 	{
 		char filename[256];
 #ifdef WIN32
         _snprintf( filename, sizeof(filename), "%s\\paloopback_%d.wav", userOptions->waveFilePath, userOptions->waveFileCount++ );
 #else
 		snprintf( filename, sizeof(filename), "%s/paloopback_%d.wav", userOptions->waveFilePath, userOptions->waveFileCount++ );
 #endif   
 		printf( "\"%s\", ", filename );
 		return PaQa_SaveRecordingToWaveFile( recording, filename );
 	}
 	return 0;
 }
 
 /*******************************************************************/
 static int PaQa_SetupLoopbackContext( LoopbackContext *loopbackContextPtr, TestParameters *testParams )
 {
 	int i;
 	// Setup loopback context.
 	memset( loopbackContextPtr, 0, sizeof(LoopbackContext) );	
 	loopbackContextPtr->test = testParams;
 	for( i=0; i<testParams->samplesPerFrame; i++ )
 	{
 		int err = PaQa_InitializeRecording( &loopbackContextPtr->recordings[i], testParams->maxFrames, testParams->sampleRate );
 		QA_ASSERT_EQUALS( "PaQa_InitializeRecording failed", paNoError, err );
 	}
 	for( i=0; i<testParams->samplesPerFrame; i++ )
 	{
 		PaQa_SetupSineGenerator( &loopbackContextPtr->generators[i], PaQa_GetNthFrequency( testParams->baseFrequency, i ),
 								testParams->amplitude, testParams->sampleRate );
 	}
 	loopbackContextPtr->minFramesPerBuffer = 0x0FFFFFFF;
 	return 0;
 error:
 	return -1;
 }
 
 /*******************************************************************/
 static void PaQa_TeardownLoopbackContext( LoopbackContext *loopbackContextPtr )
 {
 	int i;
 	if( loopbackContextPtr->test != NULL )
 	{
 		for( i=0; i<loopbackContextPtr->test->samplesPerFrame; i++ )
 		{
 			PaQa_TerminateRecording( &loopbackContextPtr->recordings[i] );
 		}
 	}
 }
 
 /*******************************************************************/
 static void PaQa_PrintShortErrorReport( PaQaAnalysisResult *analysisResultPtr, int channel )
 {
 	printf("channel %d ", channel);
 	if( analysisResultPtr->popPosition > 0 )
 	{
 		printf("POP %0.3f at %d, ", (double)analysisResultPtr->popAmplitude, (int)analysisResultPtr->popPosition );	
 	}
 	else
 	{
 		if( analysisResultPtr->addedFramesPosition > 0 )
 		{
 			printf("ADD %d at %d ", (int)analysisResultPtr->numAddedFrames, (int)analysisResultPtr->addedFramesPosition );	
 		}
 		
 		if( analysisResultPtr->droppedFramesPosition > 0 )
 		{
 			printf("DROP %d at %d ", (int)analysisResultPtr->numDroppedFrames, (int)analysisResultPtr->droppedFramesPosition );	
 		}
 	}
 }
 
 /*******************************************************************/
 static void PaQa_PrintFullErrorReport( PaQaAnalysisResult *analysisResultPtr, int channel )
 {
 	printf("\n=== Loopback Analysis ===================\n");
 	printf("             channel: %d\n", channel );
 	printf("             latency: %10.3f\n", analysisResultPtr->latency );
 	printf("      amplitudeRatio: %10.3f\n", (double)analysisResultPtr->amplitudeRatio );	
 	printf("         popPosition: %10.3f\n", (double)analysisResultPtr->popPosition );	
 	printf("        popAmplitude: %10.3f\n", (double)analysisResultPtr->popAmplitude );
 	printf("    num added frames: %10.3f\n", analysisResultPtr->numAddedFrames );
 	printf("     added frames at: %10.3f\n", analysisResultPtr->addedFramesPosition );
 	printf("  num dropped frames: %10.3f\n", analysisResultPtr->numDroppedFrames );
 	printf("   dropped frames at: %10.3f\n", analysisResultPtr->droppedFramesPosition );
 }
 
 /*******************************************************************/
 /** 
  * Test loopback connection using the given parameters.
  * @return number of channels with glitches, or negative error.
  */
 static int PaQa_SingleLoopBackTest( UserOptions *userOptions, TestParameters *testParams )
 {
 	int i;
 	LoopbackContext loopbackContext;
 	PaError err = paNoError;
 	PaQaTestTone testTone;
 	PaQaAnalysisResult analysisResult;
 	int numBadChannels = 0;
 	
 	printf("| %5d | %6d | ", ((int)(testParams->sampleRate+0.5)), testParams->framesPerBuffer );
 	fflush(stdout);
 	
 	testTone.samplesPerFrame = testParams->samplesPerFrame;
 	testTone.sampleRate = testParams->sampleRate;
 	testTone.amplitude = testParams->amplitude;
 	testTone.startDelay = 0;
 	
 	err = PaQa_SetupLoopbackContext( &loopbackContext, testParams );
 	if( err ) return err;
 	
 	err = PaQa_RunLoopback( &loopbackContext );
 	QA_ASSERT_TRUE("loopback did not run", (loopbackContext.callbackCount > 1) );
 
 	printf( "%7.2f %7.2f %7.2f | ",
 		   loopbackContext.streamInfoInputLatency * 1000.0,
 		   loopbackContext.streamInfoOutputLatency * 1000.0,
 		   (loopbackContext.streamInfoInputLatency + loopbackContext.streamInfoOutputLatency) * 1000.0
 		   );
 
 	printf( "%4d/%4d/%4d, %4d/%4d/%4d | ",
 		   loopbackContext.inputOverflowCount,
 		   loopbackContext.inputUnderflowCount,
 		   loopbackContext.inputBufferCount,
 		   loopbackContext.outputOverflowCount,
 		   loopbackContext.outputUnderflowCount,
 		   loopbackContext.outputBufferCount
 		   );
 	
 	// Analyse recording to detect glitches.
 	for( i=0; i<testParams->samplesPerFrame; i++ )
 	{
 		double freq = PaQa_GetNthFrequency( testParams->baseFrequency, i );
 		testTone.frequency = freq;
 		
 		PaQa_AnalyseRecording(  &loopbackContext.recordings[i], &testTone, &analysisResult );
 		
 		if( i==0 )
 		{
             double latencyMSec;
 
 			printf( "%4d-%4d | ",
 				   loopbackContext.minFramesPerBuffer,
 				   loopbackContext.maxFramesPerBuffer
 				   );
 			
 			latencyMSec = 1000.0 * analysisResult.latency / testParams->sampleRate;
 			printf("%7.2f | ", latencyMSec );
 						
 		}
 		
 		if( analysisResult.valid )
 		{
 			int badChannel = ( (analysisResult.popPosition > 0)
 					   || (analysisResult.addedFramesPosition > 0)
 					   || (analysisResult.droppedFramesPosition > 0) );
 			
 			if( badChannel )
 			{	
 				if( userOptions->verbose )
 				{
 					PaQa_PrintFullErrorReport( &analysisResult, i );
 				}
 				else
 				{
 					PaQa_PrintShortErrorReport( &analysisResult, i );
 				}
 				PaQa_SaveTestResultToWaveFile( userOptions, &loopbackContext.recordings[i] );
 			}
 			numBadChannels += badChannel;
 		}
 		else
 		{
 			printf( "[%d] No or low signal, ampRatio = %f", i, analysisResult.amplitudeRatio );
 			numBadChannels += 1;
 		}
 
 	}
 	if( numBadChannels == 0 )
 	{
 		printf( "OK" );
 	}
 
     // Print the # errors so far to make it easier to see where the error occured.
 	printf( " - #errs = %d\n", g_testsFailed );
 
 	PaQa_TeardownLoopbackContext( &loopbackContext );
 	if( numBadChannels > 0 )
 	{
 		g_testsFailed += 1;
 	}
 	return numBadChannels;	
 	
 error:
 	PaQa_TeardownLoopbackContext( &loopbackContext );
 	printf( "\n" );
 	g_testsFailed += 1;
 	return err;	
 }
 
 /*******************************************************************/
 static void PaQa_SetDefaultTestParameters( TestParameters *testParamsPtr, PaDeviceIndex inputDevice, PaDeviceIndex outputDevice )
 {
 	memset( testParamsPtr, 0, sizeof(TestParameters) );
 	
 	testParamsPtr->samplesPerFrame = 2;
 	testParamsPtr->amplitude = 0.5;
 	testParamsPtr->sampleRate = 44100;
 	testParamsPtr->maxFrames = (int) (PAQA_TEST_DURATION * testParamsPtr->sampleRate);
 	testParamsPtr->framesPerBuffer = DEFAULT_FRAMES_PER_BUFFER;
 	testParamsPtr->baseFrequency = 200.0;
 	testParamsPtr->flags = PAQA_FLAG_TWO_STREAMS;
     testParamsPtr->streamFlags = paClipOff; /* we won't output out of range samples so don't bother clipping them */
 	
 	testParamsPtr->inputParameters.device = inputDevice;
 	testParamsPtr->inputParameters.sampleFormat = paFloat32;
 	testParamsPtr->inputParameters.channelCount = testParamsPtr->samplesPerFrame;
 	testParamsPtr->inputParameters.suggestedLatency = Pa_GetDeviceInfo( inputDevice )->defaultLowInputLatency;
 	//testParamsPtr->inputParameters.suggestedLatency = Pa_GetDeviceInfo( inputDevice )->defaultHighInputLatency;
 	
 	testParamsPtr->outputParameters.device = outputDevice;
 	testParamsPtr->outputParameters.sampleFormat = paFloat32;
 	testParamsPtr->outputParameters.channelCount = testParamsPtr->samplesPerFrame;
 	testParamsPtr->outputParameters.suggestedLatency = Pa_GetDeviceInfo( outputDevice )->defaultLowOutputLatency;
 	//testParamsPtr->outputParameters.suggestedLatency = Pa_GetDeviceInfo( outputDevice )->defaultHighOutputLatency;
 }
 
 /*******************************************************************/
 static void PaQa_OverrideTestParameters( TestParameters *testParamsPtr,  UserOptions *userOptions )
 {
 	// Check to see if a specific value was requested.
 	if( userOptions->sampleRate >= 0 )
 	{
 		testParamsPtr->sampleRate = userOptions->sampleRate;
 		testParamsPtr->maxFrames = (int) (PAQA_TEST_DURATION * testParamsPtr->sampleRate);
 	}
 	if( userOptions->framesPerBuffer >= 0 )
 	{
 		testParamsPtr->framesPerBuffer = userOptions->framesPerBuffer;
 	}
 	if( userOptions->inputLatency >= 0 )
 	{
 		testParamsPtr->inputParameters.suggestedLatency = userOptions->inputLatency * 0.001;
 	}
 	if( userOptions->outputLatency >= 0 )
 	{
 		testParamsPtr->outputParameters.suggestedLatency = userOptions->outputLatency * 0.001;
 	}
 	printf( "   Running with suggested latency (msec): input = %5.2f, out = %5.2f\n",
 		(testParamsPtr->inputParameters.suggestedLatency * 1000.0),
 		(testParamsPtr->outputParameters.suggestedLatency * 1000.0) );
 }
 
 /*******************************************************************/
 /** 
  * Run a series of tests on this loopback connection.
  * @return number of bad channel results
  */
 static int PaQa_AnalyzeLoopbackConnection( UserOptions *userOptions, PaDeviceIndex inputDevice, PaDeviceIndex outputDevice )
 {
 	int iFlags;
 	int iRate;
 	int iSize;
 	int iFormat;
 	int savedValue;
 	TestParameters testParams;
 	const PaDeviceInfo *inputDeviceInfo = Pa_GetDeviceInfo( inputDevice );	
 	const PaDeviceInfo *outputDeviceInfo = Pa_GetDeviceInfo( outputDevice );		
     int totalBadChannels = 0;
 
 	// test half duplex first because it is more likely to work.
 	int flagSettings[] = { PAQA_FLAG_TWO_STREAMS, 0 };
 	int numFlagSettings = (sizeof(flagSettings)/sizeof(int));
 
 	double sampleRates[] = { 8000.0, 11025.0, 16000.0, 22050.0, 32000.0, 44100.0, 48000.0, 96000.0 };
 	int numRates = (sizeof(sampleRates)/sizeof(double));
 	
 	// framesPerBuffer==0 means PA decides on the buffer size.
 	int framesPerBuffers[] = { 0, 16, 32, 40, 64, 100, 128, 256, 512, 1024 };
 	int numBufferSizes = (sizeof(framesPerBuffers)/sizeof(int));
 	
 	PaSampleFormat sampleFormats[] = { paFloat32, paUInt8, paInt8, paInt16, paInt32 };
 	const char *sampleFormatNames[] = { "paFloat32", "paUInt8", "paInt8", "paInt16", "paInt32" };
 	int numSampleFormats = (sizeof(sampleFormats)/sizeof(PaSampleFormat));
 	
     printf( "=============== Analysing Loopback %d to %d =====================\n", outputDevice, inputDevice  );
 	printf( "   Devices: %s => %s\n", outputDeviceInfo->name, inputDeviceInfo->name);
 	
 	PaQa_SetDefaultTestParameters( &testParams, inputDevice, outputDevice );
 	
 	PaQa_OverrideTestParameters( &testParams, userOptions );
 	
 	// Loop though combinations of audio parameters.
 	for( iFlags=0; iFlags<numFlagSettings; iFlags++ )
 	{
 		int numRuns = 0;
 
 		testParams.flags = flagSettings[iFlags];
 		printf( "\n************ Mode = %s ************\n",
 			   (( testParams.flags & 1 ) ? s_FlagOnNames[0] : s_FlagOffNames[0]) );
 
 		printf("|-   requested  -|-  stream info latency  -|- measured ------------------------------\n");
 		printf("|-sRate-|-fr/buf-|- in    - out   - total -|- over/under/calls for in, out -|- frm/buf -|-latency-|- channel results -\n");
 
 		// Loop though various sample rates.
 		if( userOptions->sampleRate < 0 )
 		{
 			savedValue = testParams.sampleRate;
 			for( iRate=0; iRate<numRates; iRate++ )
 			{
                 int numBadChannels;
 
 				// SAMPLE RATE
 				testParams.sampleRate = sampleRates[iRate];
 				testParams.maxFrames = (int) (PAQA_TEST_DURATION * testParams.sampleRate);
 				
 				numBadChannels = PaQa_SingleLoopBackTest( userOptions, &testParams );
 				totalBadChannels += numBadChannels;
 			}
 			testParams.sampleRate = savedValue;
 			testParams.maxFrames = (int) (PAQA_TEST_DURATION * testParams.sampleRate);
 			printf( "\n" );
 			numRuns += 1;
 		}
 		
 		// Loop through various buffer sizes.
 		if( userOptions->framesPerBuffer < 0 )
 		{
 			savedValue = testParams.framesPerBuffer;
 			for( iSize=0; iSize<numBufferSizes; iSize++ )
 			{	
                 int numBadChannels;
 
 				// BUFFER SIZE
 				testParams.framesPerBuffer = framesPerBuffers[iSize];
 				
 				numBadChannels = PaQa_SingleLoopBackTest( userOptions, &testParams );
 				totalBadChannels += numBadChannels;			
 			}
 			testParams.framesPerBuffer = savedValue;
 			printf( "\n" );		
 			numRuns += 1;
 		}
 		// Run one with single parameters in case we did not do a series.
 		if( numRuns == 0 )
 		{
 			int numBadChannels = PaQa_SingleLoopBackTest( userOptions, &testParams );
 			totalBadChannels += numBadChannels;						
 		}
 	}
 			
 	printf("\nTest Sample Formats using Half Duplex IO -----\n" );
     
 	PaQa_SetDefaultTestParameters( &testParams, inputDevice, outputDevice );
 	testParams.flags = PAQA_FLAG_TWO_STREAMS;	
     for( iFlags= 0; iFlags<4; iFlags++ )
     {
         // Cycle through combinations of flags.
         testParams.streamFlags = 0;
         if( iFlags & 1 ) testParams.streamFlags |= paClipOff;
         if( iFlags & 2 ) testParams.streamFlags |= paDitherOff;
         
         for( iFormat=0; iFormat<numSampleFormats; iFormat++ )
         {	
             int numBadChannels;
             PaSampleFormat format = sampleFormats[ iFormat ];
             testParams.inputParameters.sampleFormat = format;
             testParams.outputParameters.sampleFormat = format;
             printf("Sample format = %d = %s, PaStreamFlags = 0x%02X\n", (int) format, sampleFormatNames[iFormat], (unsigned int) testParams.streamFlags );
             numBadChannels = PaQa_SingleLoopBackTest( userOptions, &testParams );
             totalBadChannels += numBadChannels;			
         }
     }
 	printf( "\n" );
 	printf( "****************************************\n");
 	
 	return totalBadChannels;
 }
 
 /*******************************************************************/
 int PaQa_CheckForClippedLoopback( LoopbackContext *loopbackContextPtr )
 {
 	int clipped = 0;
 	TestParameters *testParamsPtr = loopbackContextPtr->test;
 	
 	// Start in the middle assuming past latency.
 	int startFrame = testParamsPtr->maxFrames/2;
 	int numFrames = testParamsPtr->maxFrames/2;
 	
 	// Check to see if the signal is clipped.
 	double amplitudeLeft = PaQa_MeasureSineAmplitudeBySlope( &loopbackContextPtr->recordings[0],
 															testParamsPtr->baseFrequency, testParamsPtr->sampleRate,
 															startFrame, numFrames );
 	double gainLeft = amplitudeLeft / testParamsPtr->amplitude;
 	double amplitudeRight = PaQa_MeasureSineAmplitudeBySlope( &loopbackContextPtr->recordings[1],
 															 testParamsPtr->baseFrequency, testParamsPtr->sampleRate,
 															 startFrame, numFrames );
 	double gainRight = amplitudeLeft / testParamsPtr->amplitude;
 	printf("   Loop gain: left = %f, right = %f\n", gainLeft, gainRight );
 
 	if( (amplitudeLeft > 1.0 ) || (amplitudeRight > 1.0) )
 	{
 		printf("ERROR - loop gain is too high. Should be around than 1.0. Please lower output level and/or input gain.\n" );
 		clipped = 1;
 	}
 	return clipped;
 }
 
 /*******************************************************************/
 int PaQa_MeasureBackgroundNoise( LoopbackContext *loopbackContextPtr, double *rmsPtr )
 {
 	int result = 0;
 	*rmsPtr = 0.0;
 	// Rewind so we can record some input.
 	loopbackContextPtr->recordings[0].numFrames = 0;
 	loopbackContextPtr->recordings[1].numFrames = 0;
 	result = PaQa_RunInputOnly( loopbackContextPtr );
 	if( result == 0 )
 	{
 		double leftRMS = PaQa_MeasureRootMeanSquare( loopbackContextPtr->recordings[0].buffer,
 													loopbackContextPtr->recordings[0].numFrames );
 		double rightRMS = PaQa_MeasureRootMeanSquare( loopbackContextPtr->recordings[1].buffer,
 													 loopbackContextPtr->recordings[1].numFrames );
 		*rmsPtr = (leftRMS + rightRMS) / 2.0;
 	}
 	return result;
 }
 
 /*******************************************************************/
 /** 
  * Output a sine wave then try to detect it on input.
  *
  * @return 1 if loopback connected, 0 if not, or negative error.
  */
 int PaQa_CheckForLoopBack( UserOptions *userOptions, PaDeviceIndex inputDevice, PaDeviceIndex outputDevice )
 {
 	TestParameters testParams;
 	LoopbackContext loopbackContext;
     const PaDeviceInfo *inputDeviceInfo;	
     const PaDeviceInfo *outputDeviceInfo;		
 	PaError err = paNoError;
 	double minAmplitude;
 	int loopbackIsConnected;
     int startFrame, numFrames;
     double magLeft, magRight;
 
 	inputDeviceInfo = Pa_GetDeviceInfo( inputDevice );
 	if( inputDeviceInfo == NULL )
 	{
 		printf("ERROR - Pa_GetDeviceInfo for input returned NULL.\n");
 		return paInvalidDevice;
 	}
 	if( inputDeviceInfo->maxInputChannels < 2 )
 	{
 		return 0;
 	}
 	
 	outputDeviceInfo = Pa_GetDeviceInfo( outputDevice );
 	if( outputDeviceInfo == NULL )
 	{
 		printf("ERROR - Pa_GetDeviceInfo for output returned NULL.\n");
 		return paInvalidDevice;
 	}
 	if( outputDeviceInfo->maxOutputChannels < 2 )
 	{
 		return 0;
 	}
 	
 	printf( "Look for loopback cable between \"%s\" => \"%s\"\n", outputDeviceInfo->name, inputDeviceInfo->name);
 	
 	printf( "   Default suggested input latency (msec): low = %5.2f, high = %5.2f\n",
 		(inputDeviceInfo->defaultLowInputLatency * 1000.0),
 		(inputDeviceInfo->defaultHighInputLatency * 1000.0) );
 	printf( "   Default suggested output latency (msec): low = %5.2f, high = %5.2f\n",
 		(outputDeviceInfo->defaultLowOutputLatency * 1000.0),
 		(outputDeviceInfo->defaultHighOutputLatency * 1000.0) );
 		
 	PaQa_SetDefaultTestParameters( &testParams, inputDevice, outputDevice );
 	
 	PaQa_OverrideTestParameters( &testParams, userOptions );
 	
 	testParams.maxFrames = (int) (LOOPBACK_DETECTION_DURATION_SECONDS * testParams.sampleRate);	
 	minAmplitude = testParams.amplitude / 4.0;
 	
 	// Check to see if the selected formats are supported.
 	if( Pa_IsFormatSupported( &testParams.inputParameters, NULL, testParams.sampleRate ) != paFormatIsSupported )
 	{
 		printf( "Input not supported for this format!\n" );
 		return 0;
 	}
 	if( Pa_IsFormatSupported( NULL, &testParams.outputParameters, testParams.sampleRate ) != paFormatIsSupported )
 	{
 		printf( "Output not supported for this format!\n" );
 		return 0;
 	}
 	
 	PaQa_SetupLoopbackContext( &loopbackContext, &testParams );
 			
 	if( inputDevice == outputDevice )
 	{
 		// Use full duplex if checking for loopback on one device.
 		testParams.flags &= ~PAQA_FLAG_TWO_STREAMS;
 	}
 	else
 	{
 		// Use half duplex if checking for loopback on two different device.
 		testParams.flags = PAQA_FLAG_TWO_STREAMS;
 	}
 	err = PaQa_RunLoopback( &loopbackContext );
 	QA_ASSERT_TRUE("loopback detection callback did not run", (loopbackContext.callbackCount > 1) );
 	
 	// Analyse recording to see if we captured the output.
 	// Start in the middle assuming past latency.
 	startFrame = testParams.maxFrames/2;
 	numFrames = testParams.maxFrames/2;
 	magLeft = PaQa_CorrelateSine( &loopbackContext.recordings[0],
 									loopbackContext.generators[0].frequency,
 									testParams.sampleRate,
 									startFrame, numFrames, NULL );
 	magRight = PaQa_CorrelateSine( &loopbackContext.recordings[1],
 									loopbackContext.generators[1].frequency,
 									testParams.sampleRate,
 									startFrame, numFrames, NULL );
 	printf("   Amplitudes: left = %f, right = %f\n", magLeft, magRight );
 	
 	// Check for backwards cable.
     loopbackIsConnected = ((magLeft > minAmplitude) && (magRight > minAmplitude));
 
 	if( !loopbackIsConnected )
 	{
 		double magLeftReverse = PaQa_CorrelateSine( &loopbackContext.recordings[0],
 												   loopbackContext.generators[1].frequency,
 												   testParams.sampleRate,
 												   startFrame, numFrames, NULL );
 		
 		double magRightReverse = PaQa_CorrelateSine( &loopbackContext.recordings[1], 
 													loopbackContext.generators[0].frequency,
 													testParams.sampleRate,
 													startFrame, numFrames, NULL );
 		
 		if ((magLeftReverse > minAmplitude) && (magRightReverse>minAmplitude))
 		{
 			printf("ERROR - You seem to have the left and right channels swapped on the loopback cable!\n");
 		}
 	}
 	else
 	{
 		double rms = 0.0;
 		if( PaQa_CheckForClippedLoopback( &loopbackContext ) )
 		{
 			// Clipped so don't use this loopback.
 			loopbackIsConnected = 0;
 		}
 		
 		err = PaQa_MeasureBackgroundNoise( &loopbackContext, &rms );
 		printf("   Background noise = %f\n", rms );
 		if( err )
 		{
 			printf("ERROR - Could not measure background noise on this input!\n");
 			loopbackIsConnected = 0;
 		}
 		else if( rms > MAX_BACKGROUND_NOISE_RMS )
 		{			
 			printf("ERROR - There is too much background noise on this input!\n");
 			loopbackIsConnected = 0;
 		}
 	}
 	
 	PaQa_TeardownLoopbackContext( &loopbackContext );
 	return loopbackIsConnected;	
 	
 error:
 	PaQa_TeardownLoopbackContext( &loopbackContext );
 	return err;	
 }
 
 /*******************************************************************/
 /**
  * If there is a loopback connection then run the analysis.
  */
 static int CheckLoopbackAndScan( UserOptions *userOptions,
 								PaDeviceIndex iIn, PaDeviceIndex iOut )
 {
 	int loopbackConnected = PaQa_CheckForLoopBack( userOptions, iIn, iOut );
 	if( loopbackConnected > 0 )
 	{
 		PaQa_AnalyzeLoopbackConnection( userOptions, iIn, iOut );
 		return 1;
 	}
 	return 0;
 }
 								
 /*******************************************************************/
 /**
  * Scan every combination of output to input device.
  * If a loopback is found the analyse the combination.
  * The scan can be overriden using the -i and -o command line options.
  */
 static int ScanForLoopback(UserOptions *userOptions)
 {
 	PaDeviceIndex iIn,iOut;
 	int  numLoopbacks = 0;
     int  numDevices;
     numDevices = Pa_GetDeviceCount();    
 		
 	// If both devices are specified then just use that combination.
 	if ((userOptions->inputDevice >= 0) && (userOptions->outputDevice >= 0))
 	{
 		numLoopbacks += CheckLoopbackAndScan( userOptions, userOptions->inputDevice, userOptions->outputDevice );
 	}
 	else if (userOptions->inputDevice >= 0)
 	{
 		// Just scan for output.
 		for( iOut=0; iOut<numDevices; iOut++ )
 		{					
 			numLoopbacks += CheckLoopbackAndScan( userOptions, userOptions->inputDevice, iOut );
 		}
 	}
 	else if (userOptions->outputDevice >= 0)
 	{
 		// Just scan for input.
 		for( iIn=0; iIn<numDevices; iIn++ )
 		{					
 			numLoopbacks += CheckLoopbackAndScan( userOptions, iIn, userOptions->outputDevice );
 		}
 	}
 	else
 	{	
 		// Scan both.
 		for( iOut=0; iOut<numDevices; iOut++ )
 		{
 			for( iIn=0; iIn<numDevices; iIn++ )
 			{				
 				numLoopbacks += CheckLoopbackAndScan( userOptions, iIn, iOut );
 			}
 		}
 	}
 	QA_ASSERT_TRUE( "No good loopback cable found.", (numLoopbacks > 0) );
 	return numLoopbacks;
 	
 error:
 	return -1;
 }
 
 /*==========================================================================================*/
 int TestSampleFormatConversion( void )
 {
 	int i;
 	const float floatInput[] = { 1.0, 0.5, -0.5, -1.0 };
 	
 	const char charInput[] = { 127, 64, -64, -128 };
 	const unsigned char ucharInput[] = { 255, 128+64, 64, 0 };
 	const short shortInput[] = { 32767, 32768/2, -32768/2, -32768 };
 	const int intInput[] = { 2147483647, 2147483647/2, -1073741824 /*-2147483648/2 doesn't work in msvc*/, -2147483648 };
 	
 	float floatOutput[4];
 	short shortOutput[4];
 	int intOutput[4];	
 	unsigned char ucharOutput[4];
 	char charOutput[4];
 	
 	QA_ASSERT_EQUALS("int must be 32-bit", 4, (int) sizeof(int) );
 	QA_ASSERT_EQUALS("short must be 16-bit", 2, (int) sizeof(short) );
 	
 	// from Float ======
 	PaQa_ConvertFromFloat( floatInput, 4, paUInt8, ucharOutput );
 	for( i=0; i<4; i++ )
 	{
 		QA_ASSERT_CLOSE_INT( "paFloat32 -> paUInt8 -> error", ucharInput[i], ucharOutput[i], 1 );
 	}
 	
 	PaQa_ConvertFromFloat( floatInput, 4, paInt8, charOutput );
 	for( i=0; i<4; i++ )
 	{
 		QA_ASSERT_CLOSE_INT( "paFloat32 -> paInt8 -> error", charInput[i], charOutput[i], 1 );
 	}
 	
 	PaQa_ConvertFromFloat( floatInput, 4, paInt16, shortOutput );
 	for( i=0; i<4; i++ )
 	{
 		QA_ASSERT_CLOSE_INT( "paFloat32 -> paInt16 error", shortInput[i], shortOutput[i], 1 );
 	}
 		
 	PaQa_ConvertFromFloat( floatInput, 4, paInt32, intOutput );
 	for( i=0; i<4; i++ )
 	{
 		QA_ASSERT_CLOSE_INT( "paFloat32 -> paInt32 error", intInput[i], intOutput[i], 0x00010000 );
 	}
 	
 	
 	// to Float ======
 	memset( floatOutput, 0, sizeof(floatOutput) );
 	PaQa_ConvertToFloat( ucharInput, 4, paUInt8, floatOutput );
 	for( i=0; i<4; i++ )
 	{
 		QA_ASSERT_CLOSE( "paUInt8 -> paFloat32 error", floatInput[i], floatOutput[i], 0.01 );
 	}
 	
 	memset( floatOutput, 0, sizeof(floatOutput) );
 	PaQa_ConvertToFloat( charInput, 4, paInt8, floatOutput );
 	for( i=0; i<4; i++ )
 	{
 		QA_ASSERT_CLOSE( "paInt8 -> paFloat32 error", floatInput[i], floatOutput[i], 0.01 );
 	}
 	
 	memset( floatOutput, 0, sizeof(floatOutput) );
 	PaQa_ConvertToFloat( shortInput, 4, paInt16, floatOutput );
 	for( i=0; i<4; i++ )
 	{
 		QA_ASSERT_CLOSE( "paInt16 -> paFloat32 error", floatInput[i], floatOutput[i], 0.001 );
 	}
 	
 	memset( floatOutput, 0, sizeof(floatOutput) );
 	PaQa_ConvertToFloat( intInput, 4, paInt32, floatOutput );
 	for( i=0; i<4; i++ )
 	{
 		QA_ASSERT_CLOSE( "paInt32 -> paFloat32 error", floatInput[i], floatOutput[i], 0.00001 );
 	}
 	
 	return 0;
 	
 error:
 	return -1;
 }
 
 
 /*******************************************************************/
 void usage( const char *name )
 {
 	printf("%s [-i# -o# -l# -r# -s# -m -w -dDir]\n", name);
 	printf("  -i# - Input device ID. Will scan for loopback cable if not specified.\n");
 	printf("  -o# - Output device ID. Will scan for loopback if not specified.\n");
 	printf("  -l# - Latency for both input and output in milliseconds.\n");
 	printf("  --inputLatency # Input latency in milliseconds.\n");	
 	printf("  --outputLatency # Output latency in milliseconds.\n");
 	printf("  -r# - Sample Rate in Hz.  Will use multiple common rates if not specified.\n");
 	printf("  -s# - Size of callback buffer in frames, framesPerBuffer. Will use common values if not specified.\n");
 	printf("  -w  - Save bad recordings in a WAV file.\n");
 	printf("  -dDir - Path for Directory for WAV files. Default is current directory.\n");
 	printf("  -m  - Just test the DSP Math code and not the audio devices.\n");
 	printf("  -v  - Verbose reports.\n");
 }
 
 /*******************************************************************/
 int main( int argc, char **argv )
 {
     int i;
 	UserOptions userOptions;
 	int result = 0;
 	int justMath = 0;
     char *executableName = argv[0];
 
 	printf("PortAudio LoopBack Test built " __DATE__ " at " __TIME__ "\n");
 
 	if( argc > 1 ){
 		printf("running with arguments:");
 		for(i=1; i < argc; ++i )
 			printf(" %s", argv[i] );
 		printf("\n");
 	}else{
 		printf("running with no arguments\n");
 	}
 	
 	memset(&userOptions, 0, sizeof(userOptions));
 	userOptions.inputDevice = paNoDevice;
 	userOptions.outputDevice = paNoDevice;
 	userOptions.sampleRate = -1;
 	userOptions.framesPerBuffer = -1;
 	userOptions.inputLatency = -1;
 	userOptions.outputLatency = -1;
 	userOptions.waveFilePath = ".";
 	
 	// Process arguments. Skip name of executable.
 	i = 1;
 	while( i<argc )
 	{
 		char *arg = argv[i];
 		if( arg[0] == '-' )
 		{
 			switch(arg[1])
 			{
 				case 'i':
 					userOptions.inputDevice = atoi(&arg[2]);
 					break;
 				case 'o':
 					userOptions.outputDevice = atoi(&arg[2]);
 					break;
 				case 'l':
 					userOptions.inputLatency = userOptions.outputLatency = atoi(&arg[2]);
 					break;
 				case 'r':
 					userOptions.sampleRate = atoi(&arg[2]);
 					break;
 				case 's':
 					userOptions.framesPerBuffer = atoi(&arg[2]);
 					break;
 					
 				case 'm':
 					printf("Option -m set so just testing math and not the audio devices.\n");
 					justMath = 1;
 					break;
 					
 				case 'w':
 					userOptions.saveBadWaves = 1;
 					break;
 				case 'd':
 					userOptions.waveFilePath = &arg[2];
 					break;
 					
 				case 'v':
 					userOptions.verbose = 1;
 					break;
 					
 				case 'h':
 					usage( executableName );
 					exit(0);
 					break;
 					
 				case '-':
 				{
 					if( strcmp( &arg[2], "inputLatency" ) == 0 )
 					{
 						i += 1;
 						userOptions.inputLatency = atoi(argv[i]);
 					}
 					else if( strcmp( &arg[2], "outputLatency" ) == 0 )
 					{
 						i += 1;
 						userOptions.outputLatency = atoi(argv[i]);					
 					}
 					else
 					{
 						printf("Illegal option: %s\n", arg);
 						usage( executableName );
 						exit(1);
 					}
 
 				}
 					break;
 					
 					
 				default:
 					printf("Illegal option: %s\n", arg);
 					usage( executableName );
 					exit(1);
 					break;
 			}
 		}
 		else
 		{
 			printf("Illegal argument: %s\n", arg);
 			usage( executableName );
 			exit(1);
 
 		}
 		i += 1;
 	}
 		
 	result = PaQa_TestAnalyzer();
 	
 	// Test sample format conversion tool.
 	result = TestSampleFormatConversion();
 	
 	if( (result == 0) && (justMath == 0) )
 	{
 		Pa_Initialize();
 		printf( "PortAudio version number = %d\nPortAudio version text = '%s'\n",
 			   Pa_GetVersion(), Pa_GetVersionText() );
 		printf( "=============== PortAudio Devices ========================\n" );
 		PaQa_ListAudioDevices();
         if( Pa_GetDeviceCount() == 0 )
             printf( "no devices found.\n" );
         
 		printf( "=============== Detect Loopback ==========================\n" );
 		ScanForLoopback(&userOptions);
  
 		Pa_Terminate();
 	}
 
 	if (g_testsFailed == 0)
 	{
 		printf("PortAudio QA SUCCEEDED! %d tests passed, %d tests failed\n", g_testsPassed, g_testsFailed );
 		return 0;
 
 	}
 	else
 	{
 		printf("PortAudio QA FAILED! %d tests passed, %d tests failed\n", g_testsPassed, g_testsFailed );
 		return 1;
 	}	
 }