[audio-libsamplerate.git] / libsamplerate / tests / snr_bw_test.c

/*
** Copyright (c) 2002-2016, Erik de Castro Lopo <erikd@mega-nerd.com>
** All rights reserved.
**
** This code is released under 2-clause BSD license. Please see the
** file at : https://github.com/erikd/libsamplerate/blob/master/COPYING
*/

#include "config.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <time.h>

#if (HAVE_FFTW3)

#include <fftw3.h>

#include <samplerate.h>

#include "util.h"

#define	BUFFER_LEN		50000
#define	MAX_FREQS		4
#define	MAX_RATIOS		6
#define	MAX_SPEC_LEN	(1<<15)

#ifndef	M_PI
#define	M_PI			3.14159265358979323846264338
#endif

enum
{	BOOLEAN_FALSE	= 0,
	BOOLEAN_TRUE	= 1
} ;

typedef struct
{	int		freq_count ;
	double	freqs [MAX_FREQS] ;

	double	src_ratio ;
	int		pass_band_peaks ;

	double	snr ;
	double	peak_value ;
} SINGLE_TEST ;

typedef struct
{	int			converter ;
	int			tests ;
	int			do_bandwidth_test ;
	SINGLE_TEST	test_data [10] ;
} CONVERTER_TEST ;

static double snr_test (SINGLE_TEST *snr_test_data, int number, int converter, int verbose) ;
static double find_peak (float *output, int output_len) ;
static double bandwidth_test (int converter, int verbose) ;

int
main (int argc, char *argv [])
{	CONVERTER_TEST snr_test_data [] =
	{
		{	SRC_ZERO_ORDER_HOLD,
			8,
			BOOLEAN_FALSE,
			{	{	1,	{ 0.01111111111 },		3.0,		1,	 28.0,	1.0 },
				{	1,	{ 0.01111111111 },		0.6,		1,	 36.0,	1.0 },
				{	1,	{ 0.01111111111 },		0.3,		1,	 36.0,	1.0 },
				{	1,	{ 0.01111111111 },		1.0,		1,	150.0,	1.0 },
				{	1,	{ 0.01111111111 },		1.001,		1,	 38.0,	1.0 },
				{	2,	{ 0.011111, 0.324 },	1.9999,		2,	 14.0,	1.0 },
				{	2,	{ 0.012345, 0.457 },	0.456789,	1,	 12.0,	1.0 },
				{	1,	{ 0.3511111111 },		1.33,		1,	 10.0,	1.0 }
				}
			},

		{	SRC_LINEAR,
			8,
			BOOLEAN_FALSE,
			{	{	1,	{ 0.01111111111 },		3.0,		1,	 73.0,	1.0 },
				{	1,	{ 0.01111111111 },		0.6,		1,	 73.0,	1.0 },
				{	1,	{ 0.01111111111 },		0.3,		1,	 73.0,	1.0 },
				{	1,	{ 0.01111111111 },		1.0,		1,	150.0,	1.0 },
				{	1,	{ 0.01111111111 },		1.001,		1,	 77.0,	1.0 },
				{	2,	{ 0.011111, 0.324 },	1.9999,		2,	 15.0,	0.94 },
				{	2,	{ 0.012345, 0.457 },	0.456789,	1,	 25.0,	0.96 },
				{	1,	{ 0.3511111111 },		1.33,		1,	 22.0,	0.99 }
				}
			},

		{	SRC_SINC_FASTEST,
			9,
			BOOLEAN_TRUE,
			{	{	1,	{ 0.01111111111 },		3.0,		1,	100.0,	1.0 },
				{	1,	{ 0.01111111111 },		0.6,		1,	 99.0,	1.0 },
				{	1,	{ 0.01111111111 },		0.3,		1,	100.0,	1.0 },
				{	1,	{ 0.01111111111 },		1.0,		1,	150.0,	1.0 },
				{	1,	{ 0.01111111111 },		1.001,		1,	100.0,	1.0 },
				{	2,	{ 0.011111, 0.324 },	1.9999,		2,	 97.0,	1.0 },
				{	2,	{ 0.012345, 0.457 },	0.456789,	1,	100.0,	0.5 },
				{	2,	{ 0.011111, 0.45 },		0.6,		1,	 97.0,	0.5 },
				{	1,	{ 0.3511111111 },		1.33,		1,	 97.0,	1.0 }
				}
			},

		{	SRC_SINC_MEDIUM_QUALITY,
			9,
			BOOLEAN_TRUE,
			{	{	1,	{ 0.01111111111 },		3.0,		1,	145.0,	1.0 },
				{	1,	{ 0.01111111111 },		0.6,		1,	132.0,	1.0 },
				{	1,	{ 0.01111111111 },		0.3,		1,	138.0,	1.0 },
				{	1,	{ 0.01111111111 },		1.0,		1,	157.0,	1.0 },
				{	1,	{ 0.01111111111 },		1.001,		1,	148.0,	1.0 },
				{	2,	{ 0.011111, 0.324 },	1.9999,		2,	127.0,	1.0 },
				{	2,	{ 0.012345, 0.457 },	0.456789,	1,	123.0,	0.5 },
				{	2,	{ 0.011111, 0.45 },		0.6,		1,	126.0,	0.5 },
				{	1,	{ 0.43111111111 },		1.33,		1,	121.0,	1.0 }
				}
			},

		{	SRC_SINC_BEST_QUALITY,
			9,
			BOOLEAN_TRUE,
			{	{	1,	{ 0.01111111111 },		3.0,		1,	147.0,	1.0 },
				{	1,	{ 0.01111111111 },		0.6,		1,	147.0,	1.0 },
				{	1,	{ 0.01111111111 },		0.3,		1,	148.0,	1.0 },
				{	1,	{ 0.01111111111 },		1.0,		1,	155.0,	1.0 },
				{	1,	{ 0.01111111111 },		1.001,		1,	148.0,	1.0 },
				{	2,	{ 0.011111, 0.324 },	1.9999,		2,	146.0,	1.0 },
				{	2,	{ 0.012345, 0.457 },	0.456789,	1,	147.0,	0.5 },
				{	2,	{ 0.011111, 0.45 },		0.6,		1,	144.0,	0.5 },
				{	1,	{ 0.43111111111 },		1.33,		1,	145.0,	1.0 }
				}
			},
		} ; /* snr_test_data */

	double	best_snr, snr, freq3dB ;
	int 	j, k, converter, verbose = 0 ;

	if (argc == 2 && strcmp (argv [1], "--verbose") == 0)
		verbose = 1 ;

	puts ("") ;

	for (j = 0 ; j < ARRAY_LEN (snr_test_data) ; j++)
	{	best_snr = 5000.0 ;

		converter = snr_test_data [j].converter ;

		printf ("    Converter %d : %s\n", converter, src_get_name (converter)) ;
		printf ("    %s\n", src_get_description (converter)) ;

		for (k = 0 ; k < snr_test_data [j].tests ; k++)
		{	snr = snr_test (&(snr_test_data [j].test_data [k]), k, converter, verbose) ;
			if (best_snr > snr)
				best_snr = snr ;
			} ;

		printf ("    Worst case Signal-to-Noise Ratio : %.2f dB.\n", best_snr) ;

		if (snr_test_data [j].do_bandwidth_test == BOOLEAN_FALSE)
		{	puts ("    Bandwith test not performed on this converter.\n") ;
			continue ;
			}

		freq3dB = bandwidth_test (converter, verbose) ;

		printf ("    Measured -3dB rolloff point      : %5.2f %%.\n\n", freq3dB) ;
		} ;

	fftw_cleanup () ;

	return 0 ;
} /* main */

/*==============================================================================
*/

static double
snr_test (SINGLE_TEST *test_data, int number, int converter, int verbose)
{	static float data [BUFFER_LEN + 1] ;
	static float output [MAX_SPEC_LEN] ;

	SRC_STATE	*src_state ;
	SRC_DATA	src_data ;

	double		output_peak, snr ;
	int 		k, output_len, input_len, error ;

	if (verbose != 0)
	{	printf ("\tSignal-to-Noise Ratio Test %d.\n"
				"\t=====================================\n", number) ;
		printf ("\tFrequencies : [ ") ;
		for (k = 0 ; k < test_data->freq_count ; k++)
			printf ("%6.4f ", test_data->freqs [k]) ;

		printf ("]\n\tSRC Ratio   : %8.4f\n", test_data->src_ratio) ;
		}
	else
	{	printf ("\tSignal-to-Noise Ratio Test %d : ", number) ;
		fflush (stdout) ;
		} ;

	/* Set up the output array. */
	if (test_data->src_ratio >= 1.0)
	{	output_len = MAX_SPEC_LEN ;
		input_len = (int) ceil (MAX_SPEC_LEN / test_data->src_ratio) ;
		if (input_len > BUFFER_LEN)
			input_len = BUFFER_LEN ;
		}
	else
	{	input_len = BUFFER_LEN ;
		output_len = (int) ceil (BUFFER_LEN * test_data->src_ratio) ;
		output_len &= ((~0u) << 4) ;
		if (output_len > MAX_SPEC_LEN)
			output_len = MAX_SPEC_LEN ;
		input_len = (int) ceil (output_len / test_data->src_ratio) ;
		} ;

	memset (output, 0, sizeof (output)) ;

	/* Generate input data array. */
	gen_windowed_sines (test_data->freq_count, test_data->freqs, 1.0, data, input_len) ;

	/* Perform sample rate conversion. */
	if ((src_state = src_new (converter, 1, &error)) == NULL)
	{	printf ("\n\nLine %d : src_new() failed : %s.\n\n", __LINE__, src_strerror (error)) ;
		exit (1) ;
		} ;

	src_data.end_of_input = 1 ; /* Only one buffer worth of input. */

	src_data.data_in = data ;
	src_data.input_frames = input_len ;

	src_data.src_ratio = test_data->src_ratio ;

	src_data.data_out = output ;
	src_data.output_frames = output_len ;

	if ((error = src_process (src_state, &src_data)))
	{	printf ("\n\nLine %d : %s\n\n", __LINE__, src_strerror (error)) ;
		exit (1) ;
		} ;

	src_state = src_delete (src_state) ;

	if (verbose != 0)
		printf ("\tOutput Len  :   %ld\n", src_data.output_frames_gen) ;

	if (abs (src_data.output_frames_gen - output_len) > 4)
	{	printf ("\n\nLine %d : output data length should be %d.\n\n", __LINE__, output_len) ;
		exit (1) ;
		} ;

	/* Check output peak. */
	output_peak = find_peak (output, src_data.output_frames_gen) ;

	if (verbose != 0)
		printf ("\tOutput Peak :   %6.4f\n", output_peak) ;

	if (fabs (output_peak - test_data->peak_value) > 0.01)
	{	printf ("\n\nLine %d : output peak (%6.4f) should be %6.4f\n\n", __LINE__, output_peak, test_data->peak_value) ;
		save_oct_float ("snr_test.dat", data, BUFFER_LEN, output, output_len) ;
		exit (1) ;
		} ;

	/* Calculate signal-to-noise ratio. */
	snr = calculate_snr (output, src_data.output_frames_gen, test_data->pass_band_peaks) ;

	if (snr < 0.0)
	{	/* An error occurred. */
		save_oct_float ("snr_test.dat", data, BUFFER_LEN, output, src_data.output_frames_gen) ;
		exit (1) ;
		} ;

	if (verbose != 0)
		printf ("\tSNR Ratio   :   %.2f dB\n", snr) ;

	if (snr < test_data->snr)
	{	printf ("\n\nLine %d : SNR (%5.2f) should be > %6.2f dB\n\n", __LINE__, snr, test_data->snr) ;
		exit (1) ;
		} ;

	if (verbose != 0)
		puts ("\t-------------------------------------\n\tPass\n") ;
	else
		puts ("Pass") ;

	return snr ;
} /* snr_test */

static double
find_peak (float *data, int len)
{	double 	peak = 0.0 ;
	int		k = 0 ;

	for (k = 0 ; k < len ; k++)
		if (fabs (data [k]) > peak)
			peak = fabs (data [k]) ;

	return peak ;
} /* find_peak */


static double
find_attenuation (double freq, int converter, int verbose)
{	static float input	[BUFFER_LEN] ;
	static float output [2 * BUFFER_LEN] ;

	SRC_DATA	src_data ;
	double 		output_peak ;
	int			error ;

	gen_windowed_sines (1, &freq, 1.0, input, BUFFER_LEN) ;

	src_data.end_of_input = 1 ; /* Only one buffer worth of input. */

	src_data.data_in = input ;
	src_data.input_frames = BUFFER_LEN ;

	src_data.src_ratio = 1.999 ;

	src_data.data_out = output ;
	src_data.output_frames = ARRAY_LEN (output) ;

	if ((error = src_simple (&src_data, converter, 1)))
	{	printf ("\n\nLine %d : %s\n\n", __LINE__, src_strerror (error)) ;
		exit (1) ;
		} ;

	output_peak = find_peak (output, ARRAY_LEN (output)) ;

	if (verbose)
		printf ("\tFreq : %6f   InPeak : %6f    OutPeak : %6f   Atten : %6.2f dB\n",
				freq, 1.0, output_peak, 20.0 * log10 (1.0 / output_peak)) ;

	return 20.0 * log10 (1.0 / output_peak) ;
} /* find_attenuation */

static double
bandwidth_test (int converter, int verbose)
{	double	f1, f2, a1, a2 ;
	double	freq, atten ;

	f1 = 0.35 ;
	a1 = find_attenuation (f1, converter, verbose) ;

	f2 = 0.495 ;
	a2 = find_attenuation (f2, converter, verbose) ;

	if (a1 > 3.0 || a2 < 3.0)
	{	printf ("\n\nLine %d : cannot bracket 3dB point.\n\n", __LINE__) ;
		exit (1) ;
		} ;

	while (a2 - a1 > 1.0)
	{	freq = f1 + 0.5 * (f2 - f1) ;
		atten = find_attenuation (freq, converter, verbose) ;

		if (atten < 3.0)
		{	f1 = freq ;
			a1 = atten ;
			}
		else
		{	f2 = freq ;
			a2 = atten ;
			} ;
		} ;

	freq = f1 + (3.0 - a1) * (f2 - f1) / (a2 - a1) ;

	return 200.0 * freq ;
} /* bandwidth_test */

#else /* (HAVE_FFTW3) == 0 */

/* Alternative main function when librfftw is not available. */

int
main (void)
{	puts ("\n"
		"****************************************************************\n"
		" This test cannot be run without FFTW (http://www.fftw.org/).\n"
		" Both the real and the complex versions of the library are\n"
		" required.") ;
	puts ("****************************************************************\n") ;

	return 0 ;
} /* main */

#endif
Commit	Line	Data
	1	/*
	2	** Copyright (c) 2002-2016, Erik de Castro Lopo <erikd@mega-nerd.com>
	3	** All rights reserved.
	4	**
	5	** This code is released under 2-clause BSD license. Please see the
	6	** file at : https://github.com/erikd/libsamplerate/blob/master/COPYING
	7	*/
	8
	9	#include "config.h"
	10
	11	#include <stdio.h>
	12	#include <stdlib.h>
	13	#include <string.h>
	14	#include <math.h>
	15	#include <time.h>
	16
	17	#if (HAVE_FFTW3)
	18
	19	#include <fftw3.h>
	20
	21	#include <samplerate.h>
	22
	23	#include "util.h"
	24
	25	#define BUFFER_LEN 50000
	26	#define MAX_FREQS 4
	27	#define MAX_RATIOS 6
	28	#define MAX_SPEC_LEN (1<<15)
	29
	30	#ifndef M_PI
	31	#define M_PI 3.14159265358979323846264338
	32	#endif
	33
	34	enum
	35	{ BOOLEAN_FALSE = 0,
	36	BOOLEAN_TRUE = 1
	37	} ;
	38
	39	typedef struct
	40	{ int freq_count ;
	41	double freqs [MAX_FREQS] ;
	42
	43	double src_ratio ;
	44	int pass_band_peaks ;
	45
	46	double snr ;
	47	double peak_value ;
	48	} SINGLE_TEST ;
	49
	50	typedef struct
	51	{ int converter ;
	52	int tests ;
	53	int do_bandwidth_test ;
	54	SINGLE_TEST test_data [10] ;
	55	} CONVERTER_TEST ;
	56
	57	static double snr_test (SINGLE_TEST *snr_test_data, int number, int converter, int verbose) ;
	58	static double find_peak (float *output, int output_len) ;
	59	static double bandwidth_test (int converter, int verbose) ;
	60
	61	int
	62	main (int argc, char *argv [])
	63	{ CONVERTER_TEST snr_test_data [] =
	64	{
	65	{ SRC_ZERO_ORDER_HOLD,
	66	8,
	67	BOOLEAN_FALSE,
	68	{ { 1, { 0.01111111111 }, 3.0, 1, 28.0, 1.0 },
	69	{ 1, { 0.01111111111 }, 0.6, 1, 36.0, 1.0 },
	70	{ 1, { 0.01111111111 }, 0.3, 1, 36.0, 1.0 },
	71	{ 1, { 0.01111111111 }, 1.0, 1, 150.0, 1.0 },
	72	{ 1, { 0.01111111111 }, 1.001, 1, 38.0, 1.0 },
	73	{ 2, { 0.011111, 0.324 }, 1.9999, 2, 14.0, 1.0 },
	74	{ 2, { 0.012345, 0.457 }, 0.456789, 1, 12.0, 1.0 },
	75	{ 1, { 0.3511111111 }, 1.33, 1, 10.0, 1.0 }
	76	}
	77	},
	78
	79	{ SRC_LINEAR,
	80	8,
	81	BOOLEAN_FALSE,
	82	{ { 1, { 0.01111111111 }, 3.0, 1, 73.0, 1.0 },
	83	{ 1, { 0.01111111111 }, 0.6, 1, 73.0, 1.0 },
	84	{ 1, { 0.01111111111 }, 0.3, 1, 73.0, 1.0 },
	85	{ 1, { 0.01111111111 }, 1.0, 1, 150.0, 1.0 },
	86	{ 1, { 0.01111111111 }, 1.001, 1, 77.0, 1.0 },
	87	{ 2, { 0.011111, 0.324 }, 1.9999, 2, 15.0, 0.94 },
	88	{ 2, { 0.012345, 0.457 }, 0.456789, 1, 25.0, 0.96 },
	89	{ 1, { 0.3511111111 }, 1.33, 1, 22.0, 0.99 }
	90	}
	91	},
	92
	93	{ SRC_SINC_FASTEST,
	94	9,
	95	BOOLEAN_TRUE,
	96	{ { 1, { 0.01111111111 }, 3.0, 1, 100.0, 1.0 },
	97	{ 1, { 0.01111111111 }, 0.6, 1, 99.0, 1.0 },
	98	{ 1, { 0.01111111111 }, 0.3, 1, 100.0, 1.0 },
	99	{ 1, { 0.01111111111 }, 1.0, 1, 150.0, 1.0 },
	100	{ 1, { 0.01111111111 }, 1.001, 1, 100.0, 1.0 },
	101	{ 2, { 0.011111, 0.324 }, 1.9999, 2, 97.0, 1.0 },
	102	{ 2, { 0.012345, 0.457 }, 0.456789, 1, 100.0, 0.5 },
	103	{ 2, { 0.011111, 0.45 }, 0.6, 1, 97.0, 0.5 },
	104	{ 1, { 0.3511111111 }, 1.33, 1, 97.0, 1.0 }
	105	}
	106	},
	107
	108	{ SRC_SINC_MEDIUM_QUALITY,
	109	9,
	110	BOOLEAN_TRUE,
	111	{ { 1, { 0.01111111111 }, 3.0, 1, 145.0, 1.0 },
	112	{ 1, { 0.01111111111 }, 0.6, 1, 132.0, 1.0 },
	113	{ 1, { 0.01111111111 }, 0.3, 1, 138.0, 1.0 },
	114	{ 1, { 0.01111111111 }, 1.0, 1, 157.0, 1.0 },
	115	{ 1, { 0.01111111111 }, 1.001, 1, 148.0, 1.0 },
	116	{ 2, { 0.011111, 0.324 }, 1.9999, 2, 127.0, 1.0 },
	117	{ 2, { 0.012345, 0.457 }, 0.456789, 1, 123.0, 0.5 },
	118	{ 2, { 0.011111, 0.45 }, 0.6, 1, 126.0, 0.5 },
	119	{ 1, { 0.43111111111 }, 1.33, 1, 121.0, 1.0 }
	120	}
	121	},
	122
	123	{ SRC_SINC_BEST_QUALITY,
	124	9,
	125	BOOLEAN_TRUE,
	126	{ { 1, { 0.01111111111 }, 3.0, 1, 147.0, 1.0 },
	127	{ 1, { 0.01111111111 }, 0.6, 1, 147.0, 1.0 },
	128	{ 1, { 0.01111111111 }, 0.3, 1, 148.0, 1.0 },
	129	{ 1, { 0.01111111111 }, 1.0, 1, 155.0, 1.0 },
	130	{ 1, { 0.01111111111 }, 1.001, 1, 148.0, 1.0 },
	131	{ 2, { 0.011111, 0.324 }, 1.9999, 2, 146.0, 1.0 },
	132	{ 2, { 0.012345, 0.457 }, 0.456789, 1, 147.0, 0.5 },
	133	{ 2, { 0.011111, 0.45 }, 0.6, 1, 144.0, 0.5 },
	134	{ 1, { 0.43111111111 }, 1.33, 1, 145.0, 1.0 }
	135	}
	136	},
	137	} ; /* snr_test_data */
	138
	139	double best_snr, snr, freq3dB ;
	140	int j, k, converter, verbose = 0 ;
	141
	142	if (argc == 2 && strcmp (argv [1], "--verbose") == 0)
	143	verbose = 1 ;
	144
	145	puts ("") ;
	146
	147	for (j = 0 ; j < ARRAY_LEN (snr_test_data) ; j++)
	148	{ best_snr = 5000.0 ;
	149
	150	converter = snr_test_data [j].converter ;
	151
	152	printf (" Converter %d : %s\n", converter, src_get_name (converter)) ;
	153	printf (" %s\n", src_get_description (converter)) ;
	154
	155	for (k = 0 ; k < snr_test_data [j].tests ; k++)
	156	{ snr = snr_test (&(snr_test_data [j].test_data [k]), k, converter, verbose) ;
	157	if (best_snr > snr)
	158	best_snr = snr ;
	159	} ;
	160
	161	printf (" Worst case Signal-to-Noise Ratio : %.2f dB.\n", best_snr) ;
	162
	163	if (snr_test_data [j].do_bandwidth_test == BOOLEAN_FALSE)
	164	{ puts (" Bandwith test not performed on this converter.\n") ;
	165	continue ;
	166	}
	167
	168	freq3dB = bandwidth_test (converter, verbose) ;
	169
	170	printf (" Measured -3dB rolloff point : %5.2f %%.\n\n", freq3dB) ;
	171	} ;
	172
	173	fftw_cleanup () ;
	174
	175	return 0 ;
	176	} /* main */
	177
	178	/*==============================================================================
	179	*/
	180
	181	static double
	182	snr_test (SINGLE_TEST *test_data, int number, int converter, int verbose)
	183	{ static float data [BUFFER_LEN + 1] ;
	184	static float output [MAX_SPEC_LEN] ;
	185
	186	SRC_STATE *src_state ;
	187	SRC_DATA src_data ;
	188
	189	double output_peak, snr ;
	190	int k, output_len, input_len, error ;
	191
	192	if (verbose != 0)
	193	{ printf ("\tSignal-to-Noise Ratio Test %d.\n"
	194	"\t=====================================\n", number) ;
	195	printf ("\tFrequencies : [ ") ;
	196	for (k = 0 ; k < test_data->freq_count ; k++)
	197	printf ("%6.4f ", test_data->freqs [k]) ;
	198
	199	printf ("]\n\tSRC Ratio : %8.4f\n", test_data->src_ratio) ;
	200	}
	201	else
	202	{ printf ("\tSignal-to-Noise Ratio Test %d : ", number) ;
	203	fflush (stdout) ;
	204	} ;
	205
	206	/* Set up the output array. */
	207	if (test_data->src_ratio >= 1.0)
	208	{ output_len = MAX_SPEC_LEN ;
	209	input_len = (int) ceil (MAX_SPEC_LEN / test_data->src_ratio) ;
	210	if (input_len > BUFFER_LEN)
	211	input_len = BUFFER_LEN ;
	212	}
	213	else
	214	{ input_len = BUFFER_LEN ;
	215	output_len = (int) ceil (BUFFER_LEN * test_data->src_ratio) ;
	216	output_len &= ((~0u) << 4) ;
	217	if (output_len > MAX_SPEC_LEN)
	218	output_len = MAX_SPEC_LEN ;
	219	input_len = (int) ceil (output_len / test_data->src_ratio) ;
	220	} ;
	221
	222	memset (output, 0, sizeof (output)) ;
	223
	224	/* Generate input data array. */
	225	gen_windowed_sines (test_data->freq_count, test_data->freqs, 1.0, data, input_len) ;
	226
	227	/* Perform sample rate conversion. */
	228	if ((src_state = src_new (converter, 1, &error)) == NULL)
	229	{ printf ("\n\nLine %d : src_new() failed : %s.\n\n", __LINE__, src_strerror (error)) ;
	230	exit (1) ;
	231	} ;
	232
	233	src_data.end_of_input = 1 ; /* Only one buffer worth of input. */
	234
	235	src_data.data_in = data ;
	236	src_data.input_frames = input_len ;
	237
	238	src_data.src_ratio = test_data->src_ratio ;
	239
	240	src_data.data_out = output ;
	241	src_data.output_frames = output_len ;
	242
	243	if ((error = src_process (src_state, &src_data)))
	244	{ printf ("\n\nLine %d : %s\n\n", __LINE__, src_strerror (error)) ;
	245	exit (1) ;
	246	} ;
	247
	248	src_state = src_delete (src_state) ;
	249
	250	if (verbose != 0)
	251	printf ("\tOutput Len : %ld\n", src_data.output_frames_gen) ;
	252
	253	if (abs (src_data.output_frames_gen - output_len) > 4)
	254	{ printf ("\n\nLine %d : output data length should be %d.\n\n", __LINE__, output_len) ;
	255	exit (1) ;
	256	} ;
	257
	258	/* Check output peak. */
	259	output_peak = find_peak (output, src_data.output_frames_gen) ;
	260
	261	if (verbose != 0)
	262	printf ("\tOutput Peak : %6.4f\n", output_peak) ;
	263
	264	if (fabs (output_peak - test_data->peak_value) > 0.01)
	265	{ printf ("\n\nLine %d : output peak (%6.4f) should be %6.4f\n\n", __LINE__, output_peak, test_data->peak_value) ;
	266	save_oct_float ("snr_test.dat", data, BUFFER_LEN, output, output_len) ;
	267	exit (1) ;
	268	} ;
	269
	270	/* Calculate signal-to-noise ratio. */
	271	snr = calculate_snr (output, src_data.output_frames_gen, test_data->pass_band_peaks) ;
	272
	273	if (snr < 0.0)
	274	{ /* An error occurred. */
	275	save_oct_float ("snr_test.dat", data, BUFFER_LEN, output, src_data.output_frames_gen) ;
	276	exit (1) ;
	277	} ;
	278
	279	if (verbose != 0)
	280	printf ("\tSNR Ratio : %.2f dB\n", snr) ;
	281
	282	if (snr < test_data->snr)
	283	{ printf ("\n\nLine %d : SNR (%5.2f) should be > %6.2f dB\n\n", __LINE__, snr, test_data->snr) ;
	284	exit (1) ;
	285	} ;
	286
	287	if (verbose != 0)
	288	puts ("\t-------------------------------------\n\tPass\n") ;
	289	else
	290	puts ("Pass") ;
	291
	292	return snr ;
	293	} /* snr_test */
	294
	295	static double
	296	find_peak (float *data, int len)
	297	{ double peak = 0.0 ;
	298	int k = 0 ;
	299
	300	for (k = 0 ; k < len ; k++)
	301	if (fabs (data [k]) > peak)
	302	peak = fabs (data [k]) ;
	303
	304	return peak ;
	305	} /* find_peak */
	306
	307
	308	static double
	309	find_attenuation (double freq, int converter, int verbose)
	310	{ static float input [BUFFER_LEN] ;
	311	static float output [2 * BUFFER_LEN] ;
	312
	313	SRC_DATA src_data ;
	314	double output_peak ;
	315	int error ;
	316
	317	gen_windowed_sines (1, &freq, 1.0, input, BUFFER_LEN) ;
	318
	319	src_data.end_of_input = 1 ; /* Only one buffer worth of input. */
	320
	321	src_data.data_in = input ;
	322	src_data.input_frames = BUFFER_LEN ;
	323
	324	src_data.src_ratio = 1.999 ;
	325
	326	src_data.data_out = output ;
	327	src_data.output_frames = ARRAY_LEN (output) ;
	328
	329	if ((error = src_simple (&src_data, converter, 1)))
	330	{ printf ("\n\nLine %d : %s\n\n", __LINE__, src_strerror (error)) ;
	331	exit (1) ;
	332	} ;
	333
	334	output_peak = find_peak (output, ARRAY_LEN (output)) ;
	335
	336	if (verbose)
	337	printf ("\tFreq : %6f InPeak : %6f OutPeak : %6f Atten : %6.2f dB\n",
	338	freq, 1.0, output_peak, 20.0 * log10 (1.0 / output_peak)) ;
	339
	340	return 20.0 * log10 (1.0 / output_peak) ;
	341	} /* find_attenuation */
	342
	343	static double
	344	bandwidth_test (int converter, int verbose)
	345	{ double f1, f2, a1, a2 ;
	346	double freq, atten ;
	347
	348	f1 = 0.35 ;
	349	a1 = find_attenuation (f1, converter, verbose) ;
	350
	351	f2 = 0.495 ;
	352	a2 = find_attenuation (f2, converter, verbose) ;
	353
	354	if (a1 > 3.0 \|\| a2 < 3.0)
	355	{ printf ("\n\nLine %d : cannot bracket 3dB point.\n\n", __LINE__) ;
	356	exit (1) ;
	357	} ;
	358
	359	while (a2 - a1 > 1.0)
	360	{ freq = f1 + 0.5 * (f2 - f1) ;
	361	atten = find_attenuation (freq, converter, verbose) ;
	362
	363	if (atten < 3.0)
	364	{ f1 = freq ;
	365	a1 = atten ;
	366	}
	367	else
	368	{ f2 = freq ;
	369	a2 = atten ;
	370	} ;
	371	} ;
	372
	373	freq = f1 + (3.0 - a1) * (f2 - f1) / (a2 - a1) ;
	374
	375	return 200.0 * freq ;
	376	} /* bandwidth_test */
	377
	378	#else /* (HAVE_FFTW3) == 0 */
	379
	380	/* Alternative main function when librfftw is not available. */
	381
	382	int
	383	main (void)
	384	{ puts ("\n"
	385	"****************************************************************\n"
	386	" This test cannot be run without FFTW (http://www.fftw.org/).\n"
	387	" Both the real and the complex versions of the library are\n"
	388	" required.") ;
	389	puts ("****************************************************************\n") ;
	390
	391	return 0 ;
	392	} /* main */
	393
	394	#endif
	395