lib_src: Sample rate conversion£££doc/rst/lib_src.html#lib-src-sample-rate-conversion

lib_src: Sample rate conversion$$$Introduction£££doc/rst/introduction.html#introduction

lib_src: Sample rate conversion$$$Introduction$$$lib_src components£££doc/rst/introduction.html#lib-src-components

lib_src provides both synchronous and asynchronous audio sample rate conversion functions.

lib_src includes the following components:

HiFi quality multi-rate sample rate conversion:

Synchronous Sample Rate Converter (SSRC) function

Asynchronous Sample Rate Converter (ASRC) function

HiFi quality fixed factor sample rate conversion:

Synchronous factor of 3 downsample function (src_ds3)

Synchronous factor of 3 oversample function (src_os3)

Voice quality fixed factor sample rate conversion:

Synchronous factor of 3 downsample function (src_ds3_voice)

Synchronous factor of 3 oversample function (src_us3_voice)

Voice quality fixed factor sample rate conversion optimised for XS3:

Synchronous factor of 3 downsample function (src_ff3_96t_ds)

Synchronous factor of 3 oversample function (src_ff3_96t_us)

Synchronous factor of 3/2 downsample function (src_rat_2_3_96t_ds)

Synchronous factor of 3/2 oversample function (src_rat_3_2_96t_us)

Integration support:

Asynchronous FIFO with controller for use with ASRC

The component listing above includes three different component options that support fixed factor of 3 up/downsampling. To order to choose which one to use follow these steps:

If HiFi quality (130 dB SNR) up/downsampling is required, use src_ds3 or src_os3.

If voice quality (65 dB SNR) is required running on xcore-200, use src_ds3_voice or src_us3_voice.

If voice quality (75 dB SNR) is required running xcore-ai, use src_ff3_96t_ds or src_ff3_96t_us.

lib_src: Sample rate conversion$$$Introduction$$$Using lib_src£££doc/rst/introduction.html#using-lib-src

lib_src is intended to be used with the XCommon CMake , the XMOS application build and dependency management system.

To use this library, include lib_src in the application’s APP_DEPENDENT_MODULES list, for example:

set(APP_DEPENDENT_MODULES "lib_src")

Applications should then include the src.h header file.

lib_src: Sample rate conversion$$$HiFi quality multi-rate SRC£££doc/rst/multi_rate_hifi_src.html#hifi-quality-multi-rate-src

Both SSRC and ASRC functions are accessed via standard function calls, making them accessible from C or XC. Both SSRC and ASRC functions are passed an external state structure which provides re-entrancy. The functions may be called in-line with other signal processing or placed in a thread on it’s own to provide guaranteed performance. By placing the calls to SRC functions on separate threads, multiple instances can be processed concurrently.

The API is designed to be simple and intuitive with just two public functions per sample rate converter type.

lib_src: Sample rate conversion$$$HiFi quality multi-rate SRC$$$Initialisation£££doc/rst/multi_rate_hifi_src.html#initialisation

All public ASRC and SSRC functions are declared within the src.h header:

#include "src.h"

There are a number of arrays of structures that must be declared from the application which contain the buffers between the FIR stages, state and adapted coefficients (ASRC only). There must be one element of each structure declared for each channel handled by the SRC instance. The structures are then all linked into a single control structure, allowing a single reference to be passed each time a call to the SRC is made.

For SSRC, the following state structures are required:

//State of SSRC module
ssrc_state_t     ssrc_state[SSRC_CHANNELS_PER_INSTANCE];
//Buffers between processing stages
int              ssrc_stack[SSRC_CHANNELS_PER_INSTANCE][SSRC_STACK_LENGTH_MULT * SSRC_N_IN_SAMPLES];
//SSRC Control structure
ssrc_ctrl_t      ssrc_ctrl[SSRC_CHANNELS_PER_INSTANCE];

For ASRC, the following state structures are required. Note that only one instance of the filter coefficients need be declared because these are shared amongst channels within the instance:

//ASRC state
asrc_state_t       asrc_state[ASRC_CHANNELS_PER_INSTANCE];
int                asrc_stack[ASRC_CHANNELS_PER_INSTANCE][ASRC_STACK_LENGTH_MULT * ASRC_N_IN_SAMPLES];
//Control structure
asrc_ctrl_t        asrc_ctrl[ASRC_CHANNELS_PER_INSTANCE];
//Adaptive filter coefficients
asrc_adfir_coefs_t asrc_adfir_coefs;

Note

lib_src expects SSRC_N_CHANNELS/ASRC_N_CHANNELS and SSRC_N_IN_SAMPLES/ASRC_N_IN_SAMPLES to be defined by the user. It will define SSRC_STACK_LENGTH_MULT/ASRC_STACK_LENGTH_MULT based on these values. SSRC_N_CHANNELS/ASRC_N_CHANNELS values are expected to match the n_in_samples parameter to the initialisation functions.

There is an initialisation call which sets up the variables within the structures associated with the SRC instance and clears the inter-stage buffers. Initialisation ensures the correct selection, ordering and configuration of the filtering stages, be they decimators, interpolators or pass-through blocks. This initialisation call contains arguments defining selected input and output nominal sample rates as well as settings for the sample rate converter:

ssrc_init()

The initialisation call is similar for ASRC:

asrc_init()

The input block size must be a power of 2 and is function of the n_in_samples and n_channels_per_instance arguments - the total number of input samples expected for each processing call is n_in_samples * n_channels_per_instance.

lib_src: Sample rate conversion$$$HiFi quality multi-rate SRC$$$Processing£££doc/rst/multi_rate_hifi_src.html#processing

Following initialisation, the processing API is called for each block of input samples which will then produce a block of output samples as shown in Fig. 1.

../../_images/src_proc.pdf — SRC Operation

The logic is designed so that the final filtering stage always receives a sample to process. The sample rate converters have been designed to handle a maximum decimation of factor four from the first two stages. This architecture requires a minimum input block size of 4 to operate.

The processing function call takes the the input and output buffers and a reference to the control structure as parameters. In the case of ASRC a fractional frequency ratio parameter must also be supplied. The processing functions are as follows:

ssrc_process() asrc_process()

The SRC processing call always returns a whole number of output samples produced by the sample rate conversion. Depending on the sample ratios selected, this number may be between zero and (n_in_samples * n_channels_per_instance * SRC_N_OUT_IN_RATIO_MAX). Where SRC_N_OUT_IN_RATIO_MAX is the maximum number of output samples for a single input sample. For example, if the input frequency is 44.1 kHz and the output rate is 192 kHz then a sample rate conversion of one sample input may produce up to 5 output samples.

The fractional number of samples produced to be carried to the next operation is stored inside the control structure, and additional whole samples are added during subsequent calls to the sample rate converter as necessary.

For example, a sample rate conversion from 44.1 kHz to 48 kHz with a input block size of 4 will produce a 4 sample result with a 5 sample result approximately every third call.

Each SRC processing call returns the integer number of samples produced during the sample rate conversion.

The SSRC is synchronous in nature and assumes that the ratio is equal to the nominal sample rate ratio. For example, to convert from 44.1 kHz to 48 kHz, it is assumed that the sample clocks of the input and output stream are derived from the same master-clock and have an exact ratio of 147:160.

If the sample clocks are derived from separate master-clocks, different oscillators for example, or are not synchronous (for example are derived from each other using a fractional PLL), ASRC must be used rather than SSRC.

lib_src: Sample rate conversion$$$HiFi quality multi-rate SRC$$$Buffer formats£££fig-src-proc.html#buffer-formats

The format of the sample buffers sent and received from each SRC instance is time domain interleaved. How this looks in practice depends on the number of channels and SRC instances. Three examples are shown below, each showing n_in_samples = 4. The ordering of sample indicies is 0 representing the oldest sample and n - 1, where n is the buffer size, representing the newest sample.

In the case where two channels are handled by a single SRC instance Fig. 2 shows that the samples are interleaved into a single buffer of size 8.

../../_images/stereo_single_instance.pdf — Buffer Format for Single Stereo SRC instance

Where a single audio channel is mapped to a single instance, the buffers are simply an array of samples starting with the oldest sample and ending with the newest sample as shown in Fig. 3.

../../_images/stereo_dual_instance.pdf — Buffer Format for Dual Mono SRC instances

In the case where four channels are processed by two instances, channels 0 & 1 are processed by SRC instance 0 and channels 2 & 3 are processed by SRC instance 1 as shown in Fig. 4. For each instance, four pairs of samples are passed into the SRC processing function and n pairs of samples are returned, where n depends on the input and output sample rate ratio.

../../_images/quad_dual_instance.pdf — Buffer Format for Dual Stereo SRC instances (4 channels total)

In addition to the above arguments the asrc_process() call also requires an unsigned Q4.60 fixed point ratio value specifying the actual input to output ratio for the next calculated block of samples. This allows the input and output rates to be fully asynchronous by allowing rate changes on each call to the ASRC. The converter dynamically computes coefficients using a spline interpolation within the last filter stage. It is up to the callee to maintain the input and output sample rate ratio difference.

Further details about these function arguments are contained here: SSRC API.

lib_src: Sample rate conversion$$$HiFi quality multi-rate SRC$$$Performance and resource utilisation£££fig-4-di.html#performance-and-resource-utilisation

lib_src: Sample rate conversion$$$HiFi quality multi-rate SRC$$$Performance and resource utilisation$$$Audio performance£££fig-4-di.html#audio-performance

The performance of the SSRC library is as follows:

THD+N (1 kHz, 0 dBFs): better than -130 dB, depending on the accuracy of the ratio estimation

SNR: 140 dB (or better). Note that when dither is not used, SNR is infinite as output from a zero input signal is zero.

To see frequency plots illustrating the noise floor with respect to a sample rate converted tone refer to the Performance characterisation section of this document.

lib_src: Sample rate conversion$$$HiFi quality multi-rate SRC$$$Performance and resource utilisation$$$SSRC resource utilisation£££fig-4-di.html#ssrc-resource-utilisation

The SSRC algorithm runs a series of cascaded FIR filters to perform the rate conversion. This includes interpolation, decimation and bandwidth limiting filters with a final polyphase FIR filter. The last stage supports the rational rate change of 147:160 or 160:147 allowing conversion between 44.1 kHz family of sample rates to the 48 kHz family of sample rates.

Tip

Table 1 shows the worst case MHz consumption at a given sample rate using the minimum block size of 4 input samples with dithering disabled. The MHz requirement can be reduced by around 8-12%, depending on sample rate, by increasing the input block size to 16. It is not usefully reduced by increasing block size beyond 16.

Tip

Table 1 is timed on xcore-200. When using xcore.ai the performance requirement is roughly halved due to VPU optimisations.

SSRC Processor Usage per Channel (MHz) for xcore-200
		Output rate
		44.1 kHz	48 kHz	88.2 kHz	96 kHz	176.4 kHz	192 kHz
Input rate	44.1 kHz	1 MHz	23 MHz	16 MHz	26 MHz	26 MHz	46 MHz
	48 kHz	26 MHz	1 MHz	28 MHz	17 MHz	48 MHz	29 MHz
	88.2 kHz	18 MHz	43 MHz	1 MHz	46 MHz	32 MHz	53 MHz
	96 kHz	48 MHz	20 MHz	52 MHz	2 MHz	56 MHz	35 MHz
	176.4 kHz	33 MHz	61 MHz	37 MHz	67 MHz	3 MHz	76 MHz
	192 kHz	66 MHz	36 MHz	70 MHz	40 MHz	80 MHz	4 MHz

lib_src: Sample rate conversion$$$HiFi quality multi-rate SRC$$$Performance and resource utilisation$$$ASRC performance£££fig-ssrc-mhz.html#asrc-performance

The performance of the ASRC library is as follows:

THD+N: (1 kHz, 0 dBFs): better than -130 dB

SNR: 135 dB (or better). Note that when dither is not used, SNR is infinite as output from a zero input signal is zero.

To see frequency plots illustrating the noise floor with respect to a sample rate converted tone refer to the Performance characterisation section of this document.

lib_src: Sample rate conversion$$$HiFi quality multi-rate SRC$$$Performance and resource utilisation$$$ASRC latency / group delay£££fig-ssrc-mhz.html#asrc-latency-group-delay

The ASRC algorithm runs a series of cascaded FIR filters to perform the rate conversion including a final adaptive filter to handle the varying rate change between the input and the output. The latency or group delay through the filter depends on the input rate and output rate and the input block size. Table 2 quantifies the amount of latency in milliseconds seen from the filtering. For input block sizes of greater than four please add 1000 * (INPUT_BLOCK_SIZE - 4) / INPUT_SAMPLE_RATE milliseconds to the numbers in the table.

ASRC total filter delay by sample rate in milliseconds for input block size of four
		Output rate
		44.1 kHz	48 kHz	88.2 kHz	96 kHz	176.4 kHz	192 kHz
Input rate	44.1 kHz	0.907	0.899	0.896	0.899	0.896	0.894
	48 kHz	0.910	0.833	0.830	0.823	0.825	0.823
	88.2 kHz	0.907	0.908	0.454	0.450	0.448	0.450
	96 kHz	0.931	0.833	0.455	0.417	0.415	0.411
	176.4 kHz	0.998	0.996	0.317	0.319	0.159	0.157
	192 kHz	0.998	0.917	0.295	0.292	0.148	0.146

lib_src: Sample rate conversion$$$HiFi quality multi-rate SRC$$$Performance and resource utilisation$$$ASRC latency / group delay$$$ASRC resource utilisation£££fig-asrc-delay.html#asrc-resource-utilisation

The ASRC algorithm runs a series of cascaded FIR filters to perform the rate conversion. The final filter is different because it uses adaptive coefficients to handle the varying rate change between the input and the output. The adaptive coefficients must be computed for each output sample period, but can be shared amongst all channels within the ASRC instance. Consequently, the MHz usage of the ASRC is expressed as two tables; Table 3 quantifies the MHz required for the first channel with adaptive coefficients calculation and Table 4 specifies the MHz required for filtering of each additional channel processed by the ASRC instance.

Tip

The below tables show the worst case MHz consumption per sample, using the minimum block size of 4 input samples. The MHz requirement can be reduced by around 8-12% by increasing the input block size to 16.

Tip

Typically some performance headroom is needed for buffering (especially if the system is sample orientated rather than block orientated) and inter-task communication.

Tip

Table 3 is timed on xcore-200. When using xcore.ai the performance requirement is roughly halved due to VPU optimisations.

ASRC Processor Usage (MHz) for the First Channel in the ASRC Instance for xcore-200
		Output rate
		44.1 kHz	48 kHz	88.2 kHz	96 kHz	176.4 kHz	192 kHz
Input rate	44.1 kHz	29 MHz	30 MHz	40 MHz	42 MHz	62 MHz	66 MHz
	48 kHz	33 MHz	32 MHz	42 MHz	43 MHz	63 MHz	66 MHz
	88.2 kHz	47 MHz	50 MHz	58 MHz	61 MHz	80 MHz	85 MHz
	96 kHz	55 MHz	51 MHz	67 MHz	64 MHz	84 MHz	87 MHz
	176.4 kHz	60 MHz	66 MHz	76 MHz	81 MHz	105 MHz	106 MHz
	192 kHz	69 MHz	66 MHz	82 MHz	82 MHz	109 MHz	115 MHz

Caution

Configurations requiring more than 100 MHz may not be able run in real time on a single logical core. The performance limit for a single core on a 500 MHz xcore-200 device is 100 MHz (500/5) however an xcore-ai device running at 600 MHz can provide 120 MHz logical cores.

Tip

Table 4 is timed on xcore-200. When using xcore.ai the performance requirement is roughly halved due to VPU optimisations.

ASRC Processor Usage (MHz) for Subsequent Channels in the ASRC Instance
		Output rate
		44.1 kHz	48 kHz	88.2 kHz	96 kHz	176.4 kHz	192 kHz
Input rate	44.1 kHz	28 MHz	28 MHz	32 MHz	30 MHz	40 MHz	40 MHz
	48 kHz	39 MHz	31 MHz	33 MHz	36 MHz	40 MHz	45 MHz
	88.2 kHz	51 MHz	49 MHz	57 MHz	55 MHz	65 MHz	60 MHz
	96 kHz	51 MHz	56 MHz	57 MHz	62 MHz	66 MHz	71 MHz
	176.4 kHz	60 MHz	66 MHz	76 MHz	79 MHz	92 MHz	91 MHz
	192 kHz	69 MHz	66 MHz	76 MHz	82 MHz	90 MHz	100 MHz

lib_src: Sample rate conversion$$$Asynchronous FIFO$$$Implementation detail£££groupsrcfifo__interp_1gac721c70a1e4b2d964da5d203af9ca2aa.html#implementation-detail

The SSRC and ASRC implementations are closely related to each other and share the majority of the system building blocks. The key difference between them is that SSRC uses fixed polyphase 160:147 and 147:160 final rate change filters whereas the ASRC uses an adaptive polyphase filter. The ASRC adaptive polyphase coefficients are computed for every sample using second order spline based interpolation.

lib_src: Sample rate conversion$$$HiFi quality multi-rate SRC$$$Implementation detail$$$SSRC structure£££fig-asrc-mhz2.html#ssrc-structure

The SSRC algorithm is based on three cascaded FIR filter stages (F1, F2 and F3). These stages are configured differently depending on rate change and only part of them is used in certain cases. Fig. 5 shows an overall view of the SSRC algorithm:

../../_images/ssrc_structure.pdf — SSRC Algorithm Structure

The SSRC algorithm is implemented as a two stage structure:

The bandwidth control stage which includes filters F1 and F2 is responsible for limiting the bandwidth of the input signal and for providing integer rate Sample Rate Conversion. It is also used for signal conditioning in the case of rational non-integer Sample Rate Conversion.

The polyphase filter stage which converts between the 44.1 kHz and the 48 kHz families of sample rates.

lib_src: Sample rate conversion$$$HiFi quality multi-rate SRC$$$Implementation detail$$$ASRC structure£££fig-ssrc-struct.html#asrc-structure

Similar to the SSRC, the ASRC algorithm is based on three cascaded FIR filters (F1, F2 and F3). These are configured differently depending on rate change and F2 is not used in certain rate changes. Fig. 6 shows an overall view of the ASRC algorithm:

../../_images/asrc_structure.pdf — ASRC Algorithm Structure

The ASRC algorithm is implemented as a two stage structure:

The bandwidth control stage includes filters F1 and F2 which are responsible for limiting the bandwidth of the input signal and for providing integer rate sample rate conversion to condition the input signal for the adaptive polyphase stage (F3).

The polyphase filter stage consists of the adaptive polyphase filter F3, which effectively provides the asynchronous connection between the input and output clock domains.

lib_src: Sample rate conversion$$$HiFi quality multi-rate SRC$$$Implementation detail$$$SRC filter list£££fig-asrc-struct.html#src-filter-list

A complete list of the filters supported by the SRC library, both SSRC and ASRC, is shown in Table 5. The filters are implemented in C within the FilterDefs.c function and the coefficients can be found in the /FilterData folder. The particular combination of filters cascaded together for a given sample rate change is specified in ssrc.c and asrc.c.

SRC Filter Specifications
Filter	Fs (norm)	Passband	Stopband	Ripple	Attenuation	Taps	Notes
BL	2	0.454	0.546	0.01 dB	155 dB	144	Down-sampler by two, steep
BL9644	2	0.417	0.501	0.01 dB	155 dB	160	Low-pass filter, steep for 96 to 44.1
BL8848	2	0.494	0.594	0.01 dB	155 dB	144	Low-pass, steep for 88.2 to 48
BLF	2	0.41	0.546	0.01 dB	155 dB	96	Low-pass at half band
BL19288	2	0.365	0.501	0.01 dB	155 dB	96	Low pass, steep for 192 to 88.2
BL17696	2	0.455	0.594	0.01 dB	155 dB	96	Low-pass, steep for 176.4 to 96
UP	2	0.454	0.546	0.01 dB	155 dB	144	Over sample by 2, steep
UP4844	2	0.417	0.501	0.01 dB	155 dB	160	Over sample by 2, steep for 48 to 44.1
UPF	2	0.41	0.546	0.01 dB	155 dB	96	Over sample by 2, steep for 176.4 to 192
UP192176	2	0.365	0.501	0.01 dB	155 dB	96	Over sample by 2, steep for 192 to 176.4
DS	4	0.57	1.39	0.01 dB	160 dB	32	Down sample by 2, relaxed
OS	2	0.57	1.39	0.01 dB	160 dB	32	Over sample by 2, relaxed
HS294	284	0.55	1.39	0.01 dB	155 dB	2352	Polyphase 147/160 rate change
HS320	320	0.55	1.40	0.01 dB	151 dB	2560	Polyphase 160/147 rate change
ADFIR	256	0.45	1.45	0.012 dB	170 dB	1920	Adaptive polyphase prototype filter

lib_src: Sample rate conversion$$$HiFi quality multi-rate SRC$$$File structure and overview£££fig-src-filters.html#file-structure-and-overview

All source files for the SSRC and ASRC are located within the multirate_hifi subdirectory.

src_mrhf_ssrc_wrapper.c / src_mrhf_ssrc_wrapper.h

These wrapper files provide a simplified public API to the SSRC initialization and processing functions.

src_mrhf_asrc_wrapper.c / src_mrhf_asrc_wrapper.h

These wrapper files provide a simplified public API to the ASRC initialization and processing functions.

src_mrhf_ssrc.c / src_mrhf_ssrc.h

These files contain the core of the SSRC algorithm. They set up the correct filtering chains depending on rate change and apply in the processing calls. The table sFiltersIDs declared in SSRC.c contains definitions of the filter chains for all supported rate changes. The files also integrate the code for the optional dithering function.

src_mrhf_asrc.c / src_mrhf_asrc.h

These files contain the core of the ASRC algorithm. They setup the correct filtering chains depending on rate change and apply them for the corresponding processing calls. Note that filters F1, F2 and dithering are implemented using a block based approach similar to SSRC. The adaptive polyphase filter (ADFIR) is implemented on a sample by sample basis. These files also contain functions to compute the adaptive polyphase filter coefficients.

src_mrhf_fir.c / src_mrhf_fir.h

These files provide Finite Impulse Response (FIR) filtering setup, with calls to the assembler-optimized inner loops. They provide functions for handling down-sampling by 2, synchronous or over-sampling by 2 FIRs. They also provides functions for handling polyphase filters used for rational ratio rate change in the SSRC and adaptive FIR filters used in the asynchronous section of the ASRC.

src_mrhf_filter_defs.c / src_mrhf_filter_defs.h

These files define the size and coefficient sources for all the filters used by the SRC algorithms.

/FilterData directory (various files)

This directory contains the pre-computed coefficients for all of the fixed FIR filters. The numbers are stored as signed Q1.31 format and are directly included in the source of FilterDefs.c. Both the .dat files used by the C compiler and the .sfp ScopeFIR (http://iowegian.com/scopefir/) design source files, used to originally create the filters, are included.

src_mrhf_fir_inner_loop_asm.S / src_mrhf_fir_inner_loop_asm.h

Inner loop for the standard FIR function optimized for double-word load and store, 32 bit * 32 bit -> 64 bit MACC and saturation instructions. Even and odd sample long word alignment versions are provided.

src_mrhf_fir_os_inner_loop_asm.S / scr_mrhf_fir_os_inner_loop_asm.h

Inner loop for the oversampling FIR function optimized for double-word load and store, 32 bit * 32 bit -> 64 bit MACC and saturation instructions. Both (long word) even and odd sample input versions are provided.

src_mrhf_spline_coeff_gen_inner_loop_asm.S / src_mrhf_spline_coeff_gen_inner_loop_asm.h

Inner loop for generating the spline interpolated coefficients. This assembler function is optimized for double-word load and store, 32 bit * 32 bit -> 64 bit MACC and saturation instructions.

src_mrhf_adfir_inner_loop_asm.S / src_mrhf_adfir_inner_loop_asm.h

Inner loop for the adaptive FIR function using the previously computed spline interpolated coefficients. It is optimized for double-word load and store, 32 bit * 32 bit -> 64 bit MACC and saturation instructions. Both (long word) even and odd sample input versions are provided.

src_mrhf_int_arithmetic.c / src_mrhf_int_arithmetic.h

These files contain simulation implementations of XMOS ISA specific assembler instructions. These are only used for dithering functions, and may be eliminated during future optimizations.

lib_src: Sample rate conversion$$$HiFi quality multi-rate SRC$$$SSRC API£££fig-src-filters.html#ssrc-api

void ssrc_init(const fs_code_t sr_in, const fs_code_t sr_out, ssrc_ctrl_t ssrc_ctrl[], const unsigned n_channels_per_instance, const unsigned n_in_samples, const dither_flag_t dither_on_off)

initializes synchronous sample rate conversion instance.

Parameters:

sr_in – Nominal sample rate code of input stream
sr_out – Nominal sample rate code of output stream
ssrc_ctrl – Reference to array of SSRC control stuctures
n_channels_per_instance – Number of channels handled by this instance of SSRC
n_in_samples – Number of input samples per SSRC call
dither_on_off – Dither to 24b on/off

unsigned ssrc_process(int in_buff[], int out_buff[], ssrc_ctrl_t ssrc_ctrl[])

Perform synchronous sample rate conversion processing on block of input samples using previously initialized settings.

Parameters:

in_buff – Reference to input sample buffer array
out_buff – Reference to output sample buffer array
ssrc_ctrl – Reference to array of SSRC control stuctures

Returns:

The number of output samples produced by the SRC operation

lib_src: Sample rate conversion$$$HiFi quality multi-rate SRC$$$ASRC API£££groupsrcssrc_1ga226fbd78b09d37bf424a73deb6bac4c8.html#asrc-api

uint64_t asrc_init(const fs_code_t sr_in, const fs_code_t sr_out, asrc_ctrl_t asrc_ctrl[], const unsigned n_channels_per_instance, const unsigned n_in_samples, const dither_flag_t dither_on_off)

initializes asynchronous sample rate conversion instance.

Parameters:

sr_in – Nominal sample rate code of input stream
sr_out – Nominal sample rate code of output stream
asrc_ctrl – Reference to array of ASRC control structures
n_channels_per_instance – Number of channels handled by this instance of SSRC
n_in_samples – Number of input samples per SSRC call
dither_on_off – Dither to 24b on/off

Returns:

The nominal sample rate ratio of in to out in Q4.60 format

unsigned asrc_process(int in_buff[], int out_buff[], uint64_t fs_ratio, asrc_ctrl_t asrc_ctrl[])

Perform asynchronous sample rate conversion processing on block of input samples using previously initialized settings.

Parameters:

in_buff – Reference to input sample buffer array
out_buff – Reference to output sample buffer array
fs_ratio – Fixed point ratio of in/out sample rates in Q4.60 format
asrc_ctrl – Reference to array of ASRC control structures

Returns:

The number of output samples produced by the SRC operation.

lib_src: Sample rate conversion$$$HiFi quality fixed factor of 3 SRC£££doc/rst/fixed_ratio_src.html#hifi-quality-fixed-factor-of-3-src

The SRC library includes synchronous sample rate conversion functions to downsample (decimate) and oversample (upsample or interpolate) by a fixed factor of 3.

These components offer a high quality conversion with an SNR of 130 dB.

In each case, the processing is carried out each time a single output sample is required. In the case of the decimator, three input samples are passed to the filter with a resulting one sample output on calling the processing function. The interpolator produces an output sample each time the processing function is called but will require a single sample to be pushed into the filter every third cycle. All samples use Q1.31 format (left justified signed 32b integer).

Both sample rate converters are based on a 144 tap FIR filter with two sets of coefficients available, depending on application requirements:

firos3_b_144.dat / firds3_b_144.dat - These filters have 20 dB of attenuation at the Nyquist frequency and a higher cutoff frequency

firos3_144.dat / firds3_144.dat - These filters have 60 dB of attenuation at the Nyquist frequency but trade this off with a lower cutoff frequency

The default setting is to use the coefficients that provide 60 dB of attenuation at the Nyquist frequency.

The filter coefficients may be selected by adjusting the line:

#define   FIROS3_COEFS_FILE

and:

#define   FIRDS3_COEFS_FILE

in the files src_ff3_os3.h (API for oversampling) and src_ff3_ds3.h (API for downsampling) respectively.

The OS3 processing takes up to 153 core cycles to compute a sample which translates to 1.53 ${\mu}s$ at 100 MHz or 2.448 ${\mu}s$ at 62.5 MHz core speed. This permits up to 8 channels of 16 kHz -> 48 kHz sample rate conversion in a single 62.5MHz core.

The DS3 processing takes up to 389 core cycles to compute a sample which translates to 3.89 ${\mu}s$ at 100 MHz or 6.224 ${\mu}s$ at 62.5 MHz core speed. This permits up to 9 channels of 48 kHz -> 16 kHz sample rate conversion in a single 62.5MHz core.

Both downsample and oversample functions return ERROR or NO_ERROR status codes as defined in the return code enums listed below. The only way these functions can error is if the passed delay_base structure member is uninitialized (NULL).

The downsampling functions return the following error codes

FIRDS3_NO_ERROR
FIRDS3_ERROR

The upsampling functions return the following error codes

FIROS3_NO_ERROR
FIROS3_ERROR

Tip

There are three different component options that support fixed factor of 3 up/downsampling. To help choose which one to use follow these steps: If HiFi quality (130 dB SNR) up/downsampling is required, use ds3 or os3. If voice quality (65 dB SNR) is required running on xcore-200, use ds3_voice or us3_voice. If voice quality (75 dB SNR) is required running xcore-ai, use ff3_96t_ds or ff3_96t_us

lib_src: Sample rate conversion$$$HiFi quality fixed factor of 3 SRC$$$Shared API items£££doc/rst/fixed_ratio_src.html#shared-api-items

enum src_ff3_return_code_t

Fixed factor of 3 return codes

This type describes the possible error status states from calls to the DS3 and OS3 API.

Values:

enumerator SRC_FF3_NO_ERROR

enumerator SRC_FF3_ERROR

lib_src: Sample rate conversion$$$HiFi quality fixed factor of 3 SRC$$$HiFi quality DS3 API£££src_8h_1ac37f502eba9c4656102949a23f55316ea2d3c74d6bea4792f688c04eb0d86dbe7.html#hifi-quality-ds3-api

struct src_ds3_ctrl_t: Downsample by 3 control structure

src_ff3_return_code_t src_ds3_init(src_ds3_ctrl_t *src_ds3_ctrl)

This function initializes the decimate by 3 function for a given instance

Parameters:

src_ds3_ctrl – DS3 control structure

Returns:

SRC_FF3_NO_ERROR on success, SRC_FF3_ERROR on failure

src_ff3_return_code_t src_ds3_sync(src_ds3_ctrl_t *src_ds3_ctrl)

This function clears the decimate by 3 delay line for a given instance

Parameters:

src_ds3_ctrl – DS3 control structure

Returns:

SRC_FF3_NO_ERROR on success, SRC_FF3_ERROR on failure

src_ff3_return_code_t src_ds3_proc(src_ds3_ctrl_t *src_ds3_ctrl)

This function performs the decimation on three input samples and outputs one sample. The input and output buffers are pointed to by members of the src_ds3_ctrl structure

Parameters:

src_ds3_ctrl – DS3 control structure

Returns:

SRC_FF3_NO_ERROR on success, SRC_FF3_ERROR on failure

lib_src: Sample rate conversion$$$HiFi quality fixed factor of 3 SRC$$$HiFi quality OS3 API£££src_8h_1ad0a9f3f79a2d62601bcf241724553454.html#hifi-quality-os3-api

struct src_os3_ctrl_t: Oversample by 3 control structure

src_ff3_return_code_t src_os3_init(src_os3_ctrl_t *src_os3_ctrl)

This function initializes the oversample by 3 function for a given instance

Parameters:

src_os3_ctrl – OS3 control structure

Returns:

SRC_FF3_NO_ERROR on success, SRC_FF3_ERROR on failure

src_ff3_return_code_t src_os3_sync(src_os3_ctrl_t *src_os3_ctrl)

This function clears the oversample by 3 delay line for a given instance

Parameters:

src_os3_ctrl – OS3 control structure

Returns:

SRC_FF3_NO_ERROR on success, SRC_FF3_ERROR on failure

src_ff3_return_code_t src_os3_input(src_os3_ctrl_t *src_os3_ctrl)

This function pushes a single input sample into the filter. It should be called three times for each FIROS3_proc call

Parameters:

src_os3_ctrl – OS3 control structure

Returns:

SRC_FF3_NO_ERROR on success, SRC_FF3_ERROR on failure

src_ff3_return_code_t src_os3_proc(src_os3_ctrl_t *src_os3_ctrl)

This function performs the oversampling by 3 and outputs one sample. The input and output buffers are pointed to by members of the src_os3_ctrl structure

Parameters:

src_os3_ctrl – OS3 control structure

Returns:

SRC_FF3_NO_ERROR on success, SRC_FF3_ERROR on failure

lib_src: Sample rate conversion$$$Voice quality fixed factor of 3 SRC£££src_8h_1a88ba94525a77cc39dc114812e9098d89.html#voice-quality-fixed-factor-of-3-src

A pair of SRC components supporting upconversion and downconversion by a factor of 3 are provided that are suitable for voice applications. They provide voice quality SNR (around 60 dB) and use a 72 tap Remez FIR filter and are optimized for the XS2 instruction set.

Warning

These SRC components have been deprecated. For new designs using xcore-ai, use the XS3 optimised components which provide both better performance and use approximately half of the MIPS. See ff3_voice_vpu_hdr

lib_src: Sample rate conversion$$$Voice quality fixed factor of 3 SRC$$$Voice quality DS3 API£££src_8h_1a88ba94525a77cc39dc114812e9098d89.html#voice-quality-ds3-api

int64_t src_ds3_voice_add_sample(int64_t sum, int32_t data[], const int32_t coefs[], int32_t sample)

This function performs the first two iterations of the downsampling process

Parameters:

sum – Partially accumulated value returned during previous cycle
data – Data delay line
coefs – FIR filter coefficients
sample – The newest sample

Returns:

Partially accumulated value, passed as sum parameter next cycle

int64_t src_ds3_voice_add_final_sample(int64_t sum, int32_t data[], const int32_t coefs[], int32_t sample)

This function performs the final iteration of the downsampling process

Parameters:

sum – Partially accumulated value returned during previous cycle
data – Data delay line
coefs – FIR filter coefficients
sample – The newest sample

Returns:

The decimated sample

lib_src: Sample rate conversion$$$Voice quality fixed factor of 3 SRC$$$Voice quality US3 API£££src_8h_1a403f2e825ecdf4c8964ca27280fc12c3.html#voice-quality-us3-api

int32_t src_us3_voice_input_sample(int32_t data[], const int32_t coefs[], int32_t sample)

This function performs the initial iteration of the upsampling process

Parameters:

data – Data delay line
coefs – FIR filter coefficients
sample – The newest sample

Returns:

A decimated sample

int32_t src_us3_voice_get_next_sample(int32_t data[], const int32_t coefs[])

This function performs the final two iterations of the upsampling process

Parameters:

data – Data delay line
coefs – FIR filter coefficients

Returns:

A decimated sample

lib_src: Sample rate conversion$$$Voice quality fixed factor of 3 and 3/2 SRC optimised for XS3£££src_8h_1aaf259a7852365c77435bc4517aaea04b.html#voice-quality-fixed-factor-of-3-and-3-2-src-optimised-for-xs3

A set of SRC components are provided which are optimised for the Vector Processing Unit (VPU) and are suitable for voice applications. They cannot be run on XS2 based devices.

The fixed factor of 3 SRC components are designed for conversion between 48 kHz to 16 kHz and the fixed factor of 3/2 are designed for conversion between 48 kHz and 32 kHz.

They have been designed for voice applications and, in particular, conformance to the Microsoft Teams v5 specification.

Warning

Synchronous fixed factor of 3 and 3/2 downsample and oversample functions for voice applications optimised for the XS3 Vector Processing Unit currently overflow rather than saturate in cases where a full scale input causes a perturbation above full scale at the output. To avoid this scenario, ensure that the input amplitude is always 3.5 dB below full scale.

lib_src: Sample rate conversion$$$Voice quality fixed factor of 3 and 3/2 SRC optimised for XS3$$$Fixed factor of 3 VPU implementation£££ff3-voice-vpu-hdr.html#fixed-factor-of-3-vpu-implementation

The filters use less than half of the cycles of the previous fixed factor of 3 functions but at the same time offer a much improved filter response thanks to an increased filter length of 96 taps (compared with 72 taps) and use of a Kaiser window with a beta of 4.0. The filter specification is shown in Table 6.

Fixed Factor of 3 Voice VPU SRC characteristics
Filter	CPU cycles	Passband	Stopband	Ripple	Attenuation	Taps
src_ff3_96t_ds	104	0.475	0.525	0.01 dB	70 dB min	96
src_ff3_96t_us	85	0.475	0.525	0.01 dB	70 dB min	96

The fixed factor of 3 components produce three samples for each call passing one sample in the case of upsampling and produce a single sample for each call passing three samples in the case of downsampling. All input and output samples are signed 32 bit integers. The filter characteristics are shown in Fig. 7 and Fig. 8.

../../_images/src_ff3_vpu.png — Fixed Factor of 3 Voice VPU SRC filter response

../../_images/src_ff3_vpu_pb.png — Fixed Factor of 3 Voice VPU SRC passband ripple

lib_src: Sample rate conversion$$$Voice quality fixed factor of 3 and 3/2 SRC optimised for XS3$$$Voice quality DS3 VPU API£££src-ff3-vpu-pb.html#voice-quality-ds3-vpu-api

static inline void src_ff3_96t_ds(int32_t samp_in[3], int32_t samp_out[1], const int32_t coefs_ff3[3][32], int32_t state_ds[3][32])

Performs VPU-optimised 96 taps polyphase fixed-factor-of-3 downsampling.

Parameters:

samp_in – Values to be downsampled
samp_out – Downsampled output
coefs_ff3 – Three-phase FIR coefficients array with [3][32] dimensions
state_ds – Three-phase FIR state array with [3][32] dimensions

lib_src: Sample rate conversion$$$Voice quality fixed factor of 3 and 3/2 SRC optimised for XS3$$$Voice quality US3 VPU API£££groupsrcff396tds_1ga1bf363fc11bc27ff318415f594c7d7c6.html#voice-quality-us3-vpu-api

static inline void src_ff3_96t_us(int32_t samp_in[1], int32_t samp_out[3], const int32_t coefs_ff3[3][32], int32_t state_us[32])

Performs VPU-optimised 96 taps polyphase fixed-factor-of-3 upsampling.

Note

samp_in and samp_out have to be different memory locations

Parameters:

samp_in – Value to be upsampled
samp_out – Upsampled output
coefs_ff3 – Three-phase FIR coefficients array with [3][32] dimensions
state_us – FIR state array with 32 elements in it

lib_src: Sample rate conversion$$$Voice quality fixed factor of 3 and 3/2 SRC optimised for XS3$$$Fixed factor of 3/2 VPU implementation£££groupsrcff396tus_1ga222799a4919b2e17ef93a1ffaa0bb07c.html#fixed-factor-of-3-2-vpu-implementation

The fixed factor of 3/2 VPU sample rate converts use a rational factor polyphase architecture to achieve the non-integer rate ratio. Downsampling takes two phases while upsampling takes three. The filters have been designed with a Kaiser window with a beta of 3.2. The filter specification is shown in Table 7.

Fixed Factor of 3/2 Voice VPU SRC characteristics
Filter	CPU cycles	Passband	Stopband	Ripple	Attenuation	Taps
src_rat_2_3_96t_ds	112	0.46875	0.53125	0.03 dB	70 dB	96
src_rat_3_2_96t_us	95	0.46875	0.53125	0.03 dB	70 dB	96

The fixed factor of 3/2 components produce three samples for each call passing two samples in the case of upsampling and produce two samples for each call passing three samples in the case of downsampling. All input and output samples are signed 32 bit integers. The filter characteristics are shown in Fig. 9 and Fig. 10.

../../_images/src_rat_vpu.png — Fixed Factor of 3/2 Voice VPU SRC filter response

../../_images/src_rat_vpu_pb.png — Fixed Factor of 3/2 Voice VPU SRC passband ripple

lib_src: Sample rate conversion$$$Voice quality fixed factor of 3 and 3/2 SRC optimised for XS3$$$Voice quality DS3/2 API£££src-ff3-2-vpu-pb.html#voice-quality-ds3-2-api

static inline void src_rat_2_3_96t_ds(int32_t samp_in[3], int32_t samp_out[2], const int32_t coefs_ds[2][48], int32_t state_ds[48])

Performs VPU-optimised 96 taps polyphase rational factor 2/3 downsampling.

Parameters:

samp_in – Values to be downsampled
samp_out – Downsampled output
coefs_ds – Two-phase FIR coefficients array with [2][48] dimensions
state_ds – FIR state array with 48 elements in it

lib_src: Sample rate conversion$$$Voice quality fixed factor of 3 and 3/2 SRC optimised for XS3$$$Voice quality US3/2 API£££groupsrcrat2396tds_1ga5de6e7f211676dd95bc08828b3ffbc75.html#voice-quality-us3-2-api

static inline void src_rat_3_2_96t_us(int32_t samp_in[2], int32_t samp_out[3], const int32_t coefs_us[3][32], int32_t state_us[32])

Performs VPU-optimised 96 taps polyphase rational factor 3/2 upsampling.

Note

samp_in and samp_out have to be different memory locations

Parameters:

samp_in – Values to be upsampled
samp_out – Upsampled output
coefs_us – Three-phase FIR coefficients array with [3][32] dimensions
state_us – FIR state array with 32 elements in it

lib_src: Sample rate conversion$$$Asynchronous FIFO£££doc/rst/asynchronous_fifo/asynchronous_fifo.html#asynchronous-fifo

An Asynchronous FIFO is a non-blocking data structure in which elements gets pushed in on one side and pulled out on the other side. It is primarily designed to be used with the ASRC to help build practical systems. The keys to this component are:

The non-blocking nature of the interfaces on both sides.
An underlying assumption that software on both sides rate-matches their requests.

The asynchronous FIFO has a PID control inside it that can be used to control the rate of either the producer or the consumer.

Two typical use cases are shown in Use cases for the asynchronous FIFO. In the first use case there is an Asynchronous Sample Rate Converter (ASRC) in front of the FIFO. The task of this ASRC is to dynamically introduce or remove samples in order to match the rate of producer and consumer. In the second use case there is a PLL (either hardware or software) that is used to match the rate of the producer and consumer.

../../_images/use-cases.svg — Use cases for the asynchronous FIFO

In order to use the asynchronous FIFO one needs at least two threads that are located on the same tile. A producer thread (on the left), and a consumer thread (on the right). These threads are free-running relative to each other, and the FIFO transports data from the producer to the consumer. Free-running means that the threads can simultaneously access the FIFO without being able to observe a change in timing.

The FIFO has a fixed length, set on creation, and the control algorithm inside the FIFO tries and keep the FIFO half-full at all times. When the producer is slower than the consumer the FIFO will drain a bit until the rates match again, and when the producer is faster than the consumer the FIFO will grow until the rates match again. In order to ensure that the FIFO stays half full, the control algorithm will always slightly overshoot on a change in relative rates. Note that the FIFO is unaware whether it is the producer that is too fast, or the consumer that is too slow. It does not attribute blame for a rate-mismatch. The FIFO just observes the mismatch.

lib_src: Sample rate conversion$$$Asynchronous FIFO$$$Using the asynchronous FIFO£££asynchronous-fifo-use-cases.html#using-the-asynchronous-fifo

An Asynchronous FIFO is allocated as an array of double-word integers:

int64_t array[ASYNCHRONOUS_FIFO_INT64_ELEMENTS(ENTRIES, SAMPLE_SIZE)];

The ASYNCHRONOUS_FIFO_INT64_ELEMENTS() macro calculates the number of double words required for the FIFO given the number of entries in the FIFO, and the number of words that each sample occupies. For example, when transferring stereo Audio through a fifo with 40 elements one would use ASYNCHRONOUS_FIFO_INT64_ELEMENTS(40, 2). Note that the two elements are not interchangeable. The number 40 is the total number of elements in the FIFO, in this case the FIFO will be started half-full, so the first 20 elements read will be zeroes, after which the produced data will appear on the consumer side.

The number of elements in the FIFO is a trade-off that the system designer makes. As the FIFO will always aim to be half-full, a large number of elements will introduce a high latency in the system and occupy a large amount of memory. A short FIFO will contribute little latency but may easily overflow and underflow. More on this in Design parameters.

The Asynchronous FIFO has the following functions to control the FIFO:

asynchronous_fifo_init() initialises the FIFO structure. It needs to know the number of integers that comprise a single sample, the maximum length that has been allocated for the FIFO.
asynchronous_fifo_exit() uninitialises the FIFO structure.
asynchronous_fifo_producer_put() puts N samples into the FIFO. It needs a timestamp that is related to when sample N-1 was obtained.
asynchronous_fifo_consumer_get() gets one sample from the FIFO. It must be given a timestamp related to when this (or the previous) sample is (was) output. It returns 0 if the pulled samples are valid.

All timestamps are measured in 100 MHz ticks.

The asynchronous_fifo_producer_put() function returns the current rate-error observed between the producer and consumer. The rate-error is typically a number close to one, eg, 1.00001231 or 0.99995442, and for convenience the function returns epsilon, where epsilon = rate - 1. That is, it would return the values 0.00001231 or -0.00004558. This epsilon is represented in a signed fixed point value Q32.32. Hence, given an ideal rate the estimated rate is calculated as:

est_rate = ideal_rate + ((epsilon * (int64_t) ideal_rate) >> 32)

in 32-bit precision or for 64-bit precision:

est_rate = (((int64_t)ideal_rate) << 32) + epsilon * (int64_t) ideal_rate

Where ideal_rate is the expected value that would make producer and consumer match if they had no error and epsilon is the value returned by asynchronous_fifo_producer_put(). The number used for ideal_rate may be a PLL setting, or an ASRC ratio value. Note that the above maths can be executed in a single multiply-accumulate instruction on XCORE.

It is important to note that the ideal_rate is never changed; the estimated rate is a linear function combining the error and the ideal rate. Internally the Asynchronous FIFO accumulates the errors so that the epsilon returned will eventually stabilise.

The ASRC Task section provides an example of the integration of the FIFO with an ASRC.

lib_src: Sample rate conversion$$$Asynchronous FIFO$$$Design parameters£££asynchronous-fifo-design-parameters.html#design-parameters

There are three degrees of freedom in this system:

The length of the FIFO
The time constant of the loop filter
The jitter characteristics of the two clocks that can be sustained.

If a long FIFO length is chosen, operation will be guaranteed but a large delay (i.e. latency) between input-signal and output-signal is introduced. If a short time constant for the loop-filter is chosen, the adjustments of the ASRC will be audible as harmonic distortion. If only small changes between the clocks is permitted, then a long time constant on the loop filter can be used with along with a short FIFO.

The value of a third parameter must match the choice of the first two; given the jitter characteristics and the time-constant the FIFO length follows. Alternatively, given the jitter characteristics and the FIFO length the maximum time constant for the loop-filter follows.

lib_src: Sample rate conversion$$$Asynchronous FIFO$$$Design parameters$$$Practical FIFO sizing for ASRC usage£££asynchronous-fifo-practical-sizing.html#practical-fifo-sizing-for-asrc-usage

Typically for most ASRC connected systems, the hardest case for the control loop is to stabilise at startup when the peak PPM difference is first seen. This results in a FIFO depth excursion from the half full state until the control loop has zeroed the error and the FIFO level has settled back to half full. It is not typical to see a large change in PPM difference during operation of practical systems; only small drifts due to voltage and temperature changes but a system always has a startup condition which needs to be accommodated.

The FIFO size must be at least twice the peak expected perturbation to account for either a positive or negative PPM difference. Should the FIFO underflow or overflow due to insufficient depth it will reset and wait to be filled to half and attempt to close the loop again.

A typical FIFO depth plot at startup for a 500 PPM deviation is shown in Fig. 12. Note that the plot appears to be thick line because the ASRC produces on average four samples at a time whereas the FIFO is emptied one sample at a time. This “lumpiness” in the FIFO fill level means the real-time FIFO depth plot looks like a sawtooth waveform when zoomed in.

../../_images/peak_fifo_48000_500ppm.png — Peak FIFO excursion at startup for a 500 PPM deviation at 48 kHz output rate.

The size of the FIFO required depends on:

The nominal output rate of the ASRC. This defines how quickly the FIFO fills. Higher rates require a larger FIFO.
The PPM deviation from normal. This defines the maximum deviation of the nominal sample rates and the peak perturbation from half full. The PPM range of the input and output clocks must be added together. For example if a source can vary by up to +500 PPM and the sink can vary by -500 PPM then the system must account for a 1000 PPM worst-case clock rate difference.
The input block size multiplied by the maximum upsample ratio. This defines the “lumpiness” of the real-time FIFO level and needs to be taken account of to fully buffer the block being written. This needs to be supported in both positive and negative PPM cases.

Using the default constants for the loop filter (settings are conservative resulting in convergence time of around four seconds for a large step change in rate) and using the default (and minimum) input block size of four the FIFO should be sized to at least:

FIFO_LEN = (OUTPUT_RATE * PPM / 16000000) + (2 * SRC_N_IN_SAMPLES x SRC_N_OUT_IN_RATIO_MAX)

A sensible choice is to round up FIFO_LEN to the nearest multiple of 2 to ensure it is symmetrical.

A few examples follow for an ASRC input block size of four. Note that the additional latency/group delay added to the system will nominally be half of FIFO depth divided by the output rate:

Example minimum FIFO length setting
Input Sample Rate	Output Sample Rate	Peak PPM difference	Minimum FIFO length
48000	48000	250	16
48000	48000	500	24
48000	48000	1000	38
48000	48000	2000	68
48000	96000	500	46
48000	192000	500	96
192000	48000	500	20

Note

The above settings are for the case when the timestamps are accurately measured. A time stamp relative offset between input and output values may require longer FIFO lengths since this may result in a FIFO nominal fill level away from half full.

Note

Larger input block sizes will require longer FIFO lengths. Scaling the above number by around 1.5 for a block size of eight and 3.0 for a block size of 16 will help reduce the chance of a FIFO overflow or underflow during a frequency step change.

It is recommended to test a system to the maximum PPM tolerance across all supported sample rates to verify the chosen FIFO setting, especially if the goal is to minimise the latency by reducing the FIFO size, otherwise a conservative FIFO size setting may be applied at the cost of additional latency.

lib_src: Sample rate conversion$$$Asynchronous FIFO$$$Controller settings£££required-fifo-length-table.html#controller-settings

The asynchronous FIFO includes a Proportional–integral–derivative (PID) based controller.

The PID constants can be set in two ways:

When used with an ASRC they can be set based on input and output sample rates to a value that stabilises a 375 ppm change in approximately four seconds at 48,000 Hz.
When used in other situations one can provide ones own Kp and Ki values. Both are represented as 32-bit integers, and a typical value for Ki is 422 (at 48 KHz, smaller for higher frequencies), and a typical value for Kp is 28,000,000 (for X kHz to X KHz; higher when the input frequency goes up, smaller when the output frequency goes up).

lib_src: Sample rate conversion$$$Asynchronous FIFO$$$API£££required-fifo-length-table.html#api

enum asynchronous_fifo_get_return_t_

Return code for asynchronous_fifo_consumer_get()

Values:

enumerator ASYNCH_FIFO_OK

enumerator ASYNCH_FIFO_UNDERFLOW

enumerator ASYNCH_FIFO_IN_RESET

typedef struct asynchronous_fifo_t_ asynchronous_fifo_t: Data structure that holds the status of an asynchronous FIFO

typedef enum asynchronous_fifo_get_return_t_ asynchronous_fifo_get_return_t: Return code for asynchronous_fifo_consumer_get()

void asynchronous_fifo_init(asynchronous_fifo_t *state, int channel_count, int max_fifo_depth)

Function that must be called to initialise the asynchronous FIFO. The state argument should be an int64_t array of ASYNCHRONOUS_FIFO_INT64_ELEMENTS elements that is cast to asynchronous_fifo_t*.

That pointer should also be used for all other operations, including operations both the consumer and producer sides.

After initialising, you must initialise the PID by calling one of asynchronous_fifo_init_PID_fs_codes() or asynchronous_fifo_init_PID_raw()

Parameters:

state – Asynchronous FIFO to be initialised
channel_count – Number of audio channels
max_fifo_depth – Length of the FIFO, delay when stable will be max_fifo_depth/2

void asynchronous_fifo_init_PID_fs_codes(asynchronous_fifo_t *state, int fs_input, int fs_output)

Function that that initialises the PID of a FIFO. Either this function or asynchronous_fifo_init_PID_raw() should be called. This function uses frequency codes as defined in the ASRC for a quick default setup, the raw function allows full control

Parameters:

state – Asynchronous FIFO to be initialised
fs_input – Input FS ratio, used to pick appropriate Kp, and Ki. Must be a number less than 6.
fs_output – Input FS ratio, used to pick appropriate Kp, Ki, ideal phase. Must be a number less than 6.

void asynchronous_fifo_init_PID_raw(asynchronous_fifo_t *state, int Kp, int Ki, int ticks_between_samples)

This function may be called at any time by the producer in order to alter the PID and midpoint settings. It does not reset the error; one of the asynchronous_fifo_init_reset_producer() or asynchronous_fifo_init_reset_consumer() functions should be called for that.

Parameters:

state – Asynchronous FIFO to be initialised
Kp – Proportional constant for the FIFO. This gets multiplied by the differential error measured in ticks (typically -2..2) and added to the ratio_error. A typical value is 30,000,000 - 60,000,000.
Ki – Integral constant for the FIFO. This gets multiplied by the phase error measured in ticks (typically -20,000 - 20,000) and added to the ratio_error. A typical value is 200 - 300.
ticks_between_samples – The number of ticks between samples is used to estimate the expected phase error halfway down the FIFO.

void asynchronous_fifo_reset_producer(asynchronous_fifo_t *state)

Function that that resets the FIFO from the producer side. Either this function should be called on the producing side, or asynchronous_fifo_reset_consumer should be called on the consumer side. In both cases the whole FIFO will be reset back

Parameters:

state – Asynchronous FIFO to be initialised

void asynchronous_fifo_reset_consumer(asynchronous_fifo_t *state)

Function that that resets the FIFO from the consumer side. Either this function should be called on the consuming side, or asynchronous_fifo_reset_producer() should be called on the producer side. In both cases the whole FIFO will be reset back

Parameters:

state – Asynchronous FIFO to be initialised

void asynchronous_fifo_exit(asynchronous_fifo_t *state)

Function that must be called to deinitalise the asynchronous FIFO

Parameters:

state – ASRC structure to be de-initialised

int32_t asynchronous_fifo_producer_put(asynchronous_fifo_t *state, int32_t *samples, int n, int32_t timestamp)

Function that provides the next samples to the asynchronous FIFO.

This function and asynchronous_fifo_consumer_get() function both need a timestamp, which is the time that the last sample was input (this function) or output (asynchronous_fifo_consumer_get()). The asynchronous FIFO will hand the samples across from producer to consumer through an elastic queue, and run a PID algorithm to calculate the best way to equalise the input clock relative to the output clock. Therefore, the timestamps have to be measured on either the same clock or two very similar clocks. It is probably fine to use the reference clocks on two tiles, provided the tiles came out of reset at more or less the same time. Using the clocks from two different chips would require the two chips to share an oscillator, and for them to come out of reset simultaneously.

The output is filtered and should be applied directly as a correction factor eg, multiplied into an ASRC ratio, or multiplied into a PLL timing.

Parameters:

state – ASRC structure to push the sample into
samples – The sample values.
n – The number of samples
timestamp – The number of ticks when this sample was input.

Returns:

The current estimate of the mismatch of input and output frequencies. This is represented as a 32-bit signed number. Zero means no mismatch, a value less than zero means that the producer is faster than the consumer, a value greater than zero means that the producer is slower than the consumer. The value should be scaled by 2**-32. That is, the current best approximation for consumer_speed/producer_speed is 1 + (return_value * 2**-32)

asynchronous_fifo_get_return_t asynchronous_fifo_consumer_get(asynchronous_fifo_t *state, int32_t *samples, int32_t timestamp)

Function that gets an output sample from the asynchronous FIFO

Function that implements the consumer interface. Control communication happens through two variables: reset and sample_data_valid. These shall only be set as the last action, as they signify to the production side that the datastructure can now be read on that side.

Note that the samples are filled in regardless of whether the FIFO is operating or not; the consumer will repeatedly get the same sample if the producer fails. The producer side is reset exactly once on reset. If this is a problem then please use the return flag (0 = OK) to handle.

Parameters:

state – ASRC structure to read a sample out off.
samples – The array where the frame with output samples will be stored.
timestamp – A timestamp taken at the time that the last sample was output. See asynchronous_fifo_produce for requirements.

Returns:

The FIFO status and whether the samples are valid or not

ASYNCHRONOUS_FIFO_INT64_ELEMENTS(N, C): macro that calculates the number of int64_t to be allocated for the fifo for a FIFO of N elements and C channels

struct asynchronous_fifo_t_: #include <asynchronous_fifo.h>

Data structure that holds the status of an asynchronous FIFO

int asrc_timestamp_interpolation(int timestamp, asrc_ctrl_t *asrc_ctrl, int ideal_freq)

Function that interpolates a timestamp for a sample generated by the ASRC. Given a measured timestamp for the sample going into the ASRC, the asrc control structure, and the expected output frequency, this function returns a timestamp for when the last sample was produced by the ASRC.

Parameters:

timestamp – Value of the reference clock taken when the last sample fed into the ASRC was sampled.
asrc_ctrl – ASRC control block
ideal_freq – Expected base frequency to which the ASRC is operating; eg, 48000 or 44100

lib_src: Sample rate conversion$$$Asynchronous FIFO$$$Implementation detail£££groupsrcfifo__interp_1gac721c70a1e4b2d964da5d203af9ca2aa.html#implementation-detail

This section details the inner workings of the FIFO and is intended only for advanced users who wish to understand the operation in more detail.

lib_src: Sample rate conversion$$$Asynchronous FIFO$$$Implementation detail$$$Measurements for the PID£££groupsrcfifo__interp_1gac721c70a1e4b2d964da5d203af9ca2aa.html#measurements-for-the-pid

The asynchronous FIFO uses the phase difference as the input for a PID controller. The phase difference is shown in Measurement of the phase difference. It is defined as the time difference between a sample when it entered the queue and left the queue. Unlike traditional phase differences that are measured in radians and where the maximum phase difference is +/- pi , the phase difference is measured as a time difference, and thereby allow the phase to be off by more than half a sample.

../../_images/phase-difference.svg — Measurement of the phase difference

In a stable situation, it is desirable that the FIFO is half-full, it follows that the desired phase difference is half the maximum length of the FIFO multiplied by the sample rate. For example, for a FIFO of 10 elements the ideal fill level is 5, and at 48 kHz the ideal phase error is 5 x 2.0833 us = 10.4166 us. If the output is running slightly too fast then sample X will enter the FIFO just after X-N/2 leaves the FIFO; if the output is running slightly too slow than sample X will enter the FIFO just before X-N/2 leaves the FIFO.

The phase-error is defined as the difference between the ideal phase-difference and the measured phase difference. Say that the queue has filled up badly and stores 9 items, then the phase difference will account for the 4 extra items in the FIFO, causing a phase difference 18.75 us rather than the desired 10.4166 us, producing a phase error of between 8.33 us. The phase difference is notionally a continuous value (a time stamp) in practice it is measured with the reference clock which has a 10 ns granularity. However, that is of far higher granularity than whole samples (2083 times better at a 48 KHz sample rate)

It is worth noting that the phase difference itself is an integral value; it is the number of samples since the beginning of time that the ASRC is out by. The goal of the rate converter is to make the phase difference stable (ie, it does not move between subsequent samples), and zero (ie, the FIFO is exactly mid level). Hence, the differential of the phase error can be seen as a proportional error, and the phase error itself as an integral error.

lib_src: Sample rate conversion$$$Asynchronous FIFO$$$Implementation detail$$$Implementation of asynchronicity£££asynchronous-fifo-phase-difference.html#implementation-of-asynchronicity

The FIFO straddles two threads; this is essential as the two threads operate on different rates. Hence, the FIFO is a shared-memory element between those two threads. A read-pointer (managed by the consuming thread) and a write-pointer (managed by the producing thread) are maintained independently. The read-pointer and write-pointer are normally N/2 elements apart.

During normal operation the Incoming and outgoing traffic are rate-matched, and the read-pointer and write-pointer will be on opposite ends of the circular buffer.

There are three situations where operation may be abnormal:

Where the consumer is no longer consuming samples
Where the producer is no longer producing samples
Where a larger than expected change in the sample rates has caused the loop filter to require more than N/2 spaces away from the mid-point.

Detecting these cases requires the calculation of the modulo difference between the write-pointer and read-pointer; if that difference is close to zero the FIFO is about to underflow; if it is close to N the FIFO is about to overflow. The notion “close to” is used since the read- and write-pointer are updated independently by different threads, so the pointer may be one less than anticipated, and an update may be missed (i.e. a race condition). Underflow is detected by the thread on the output side, overflow is detected by the thread on the input side. Differentiating overflow/underflow from too large a change in the sample rate may be hard and not necessary if they are all treated in the same way.

The employed method is to use two flags; RESET and DO_NOT_PRODUCE that are owned by the consumer and producer sides respectively.

The RESET flag is set by the consumer if it spots an underflow condition. Once RESET is set, the consumer will no longer advance the FIFO, return the same sample on each call, and wait for RESET to clear. Only the consumer may set RESET, only the producer may clear RESET.
The DO_NOT_PRODUCE flag is set by the producer if it spots on overflow condition. Once set, the producer will no longer advance the FIFO, and wait for the consumer to set the RESET flag once it has come to an underflow (which must happen as the producer has stopped producing), at which point a third action is met.
If the producer spots RESET being high, it resets the FIFO state except for the read-pointer; it leaves that as it is maintained by the consumer. Instead, it sets the write pointer to be at the other side of the buffer. Once the state is reset it will clear DO_NOT_PRODUCE and finally RESET, whereupon all should start running again.

lib_src: Sample rate conversion$$$Asynchronous FIFO$$$Implementation detail$$$Communication and reset protocol summary£££asynchronous-fifo-phase-difference.html#communication-and-reset-protocol-summary

In the thread on the producer side a put() operation performs the following:

If the RESET flag is set:

Set the write-pointer to half-way from the read-pointer

Set fs_ratio to 1

Clear the phase error and reset all other PID state.

Clear the DO_NOT_PRODUCE flag

Clear the RESET flag (this is the last step, unlocking the consumer when it is safe to do so)

else if there is no room left in the FIFO to store all samples:

Set the DO_NOT_PRODUCE flag

else if the DO_NOT_PRODUCE flag is not set:

Copy N frames into the FIFO

Increase the write-pointer

Obtain a timestamp that was queued by the consumer

Calculate the phase-error and the difference with the previous phase error

Update the PID using the difference as the proportional error and the phase-error as the integral error.

In the thread on the consumer side a get() operation performs the following:

Copy the sample at the read-pointer into the buffer provided by the consumer

If the RESET flag is clear and there is at least one sample in the FIFO:

Record the timestamp in the time-stamp queue

Increase the read-pointer.

else if the RESET flag is clear:

Set the RESET flag.

lib_src: Sample rate conversion$$$ASRC Task£££asrc-task-header.html#asrc-task

The ASRC library provides a function call that operates on blocks of samples whereas typical XMOS audio IO libraries provide streaming audio one sample at a time. The ASRC task wraps up the core ASRC function with all of the other lower level APIs (eg. FIFO) and required sample change and initialisation logic. It provides a simple-to-use and generic ASRC conversion block suitable for integration into practical designs. It is fully re-entrant permitting multiple instances within a project supporting multiple (or bi-directional) sample rates and audio clock domain bridges.

lib_src: Sample rate conversion$$$ASRC Task$$$Operation£££asrc-task-header.html#operation

The ASRC task handles bridging between two asynchronous audio sources. It has an input side and output side. The input samples are provided over a channel allowing the source to be placed on a different xcore tile if needed. The output side sample interface is via an asynchronous FIFO meaning the consumer must reside on the same xcore tile as the ASRC. The ASRC task uses a minimum of one thread but may be configured to use many depending on processing requirements.

Both input and output interfaces must specify the nominal sample rate required and additionally the input must specify a channel count. The output channel count will be set to the same as the input channel count automatically once the ASRC has automatically configured itself. A timestamp indicating the time of the production of the last input sample and the consumption of the first output sample must also be supplied which allows the ASRC FIFO to calculate the rate and phase difference. Each time either the input or output nominal sample rate or the channel count changes the ASRC subsystem automatically re-configures itself and restarts with the new settings.

The ASRC Task supports the following nominal sample rates for input and output:

44.1 kHz

48 kHz

88.2 kHz

96 kHz

176.4 kHz

192 kHz

Because the required compute for multi-channel systems may exceed the performance limit of a single thread, the ASRC subsystem is able to make use of multiple threads in parallel to achieve the required conversion within the sample time period. It uses a dynamic fork and join architecture to share the ASRC workload across multiple threads each time a batch of samples is processed. The threads must all reside on the same tile as the ASRC task due to them sharing input and output buffers. The workload and buffer partitioning is dynamically computed by the ASRC task at stream startup and is constrained by the user at compile time to set maximum limits of both channel count and worker threads.

The number of threads that are required depends on the required channel count and sample rates required. Higher sample rates require more MIPS. The amount of thread MHz (and consequently how many threads) required can be roughly calculated using the following formulae:

Total thread MHz required for xcore.ai systems = 0.15 * Max channel count * (Max SR input kHz + Max SR output kHz)

Total thread MHz required for xcore-200 systems = 0.3 * Max channel count * (Max SR input kHz + Max SR output kHz)

The difference between the performance requirement between the two architectures is due to xcore.ai supporting a Vector Processing Unit (VPU) which allows acceleration of the internal filters used by the ASRC. For example:

A two channel system supporting up to 192kHz input and output will require about (0.15 * (192 + 192) * 2) ~= 115 thread MHz. This means a single thread (assuming no more than 5 active threads on an xcore.ai device with a 600MHz clock) will likely be capable of handling this stream.

An eight channel system consisting of either 44.1kHz or 48kHz input with maximum output rate of 192kHz will require about (0.15 * (48 + 192) * 8) ~= 288 thread MHz. This can adequately be provided by four threads (assuming up to 8 active threads on an xcore.ai device with a 600MHz clock).

In reality the amount of thread MHz needed will be lower than the above formulae suggest since subsequent ASRC channels after the first can share some of the calculations. This results in about at 10% performance requirement reduction per additional channel per worker thread. Increasing the input frame size in the ASRC task may also reduce the MHz requirement a few % at the cost of larger buffers and a slight latency increase.

Warning

Exceeding the processing time available by specifying a channel count, input/output rates, number of worker threads or device clock speed may result in at best choppy audio or a blocked ASRC task if the overrun is persistent.

It is strongly recommended that the system is tested for the desired channel count and input and output sample rates. An optional timing calculation and check is provided in the ASRC to allow characterisation at run-time which can be found in the asrc_task.c source code.

The low level ASRC processing function call API accepts a minimum input frame size of four whereas most XMOS audio interfaces provide a single sample period frame. The ASRC subsystem integrates a serial to block back to serial conversion to support this. The input side works by stealing cycles from the ASRC using an interrupt and notifies the main ASRC loop using a single channel end when a complete frame of double buffered is available to process. The ASRC output side is handled by the asynchronous FIFO which supports a block put with single sample get and thus provides de-serialisation intrinsically.

lib_src: Sample rate conversion$$$ASRC Task$$$Latency characterisation£££asrc-task-header.html#latency-characterisation

The latency shown by ASRC Task depends on many factors:

Input sample rate (dynamically variable)

Output sample rate (dynamically variable)

ASRC filter stages latency (fixed based on input and output sample rates)

FIFO sizing (statically or dynamically variable by user)

ASRC sample processing block size (default of 4 which is the minimum for the ASRC and recommended for most applications)

The input and output sample rate are defined by the application and are not negotiable. The ASRC filters have fixed group delay according to the input and output rates. The underlying filter delay can be found in ASRC latency characterisation section and typically dominates the total delay.

The ASRC sample block processing size is nominally 4 but can be increased to 8, 16 or 32 to slightly reduce the MIPS required to run the processing but will incur extra delay. The case for the block size of 4 is already accounted for in the ASRC filter stage figures.

FIFO sizing is the major variable which the user has control over. The FIFO size is configurable and is a trade-off between PPM lock range required, output sample rate and desired latency. It is also partly governed by the maximum upsample ratio since, when upsampling, multiple samples are produced for a single input sample and hence the FIFO needs to be larger to accommodate a whole block.

See the Practical FIFO sizing section for more details.

The total delay can be calculated as follows:

GROUP_DELAY = ((INPUT_BLOCK_SIZE - 4) / INPUT_SAMPLE_RATE) + ASRC_FILTER_DELAY + (OUTPUT_FIFO_LENGTH / OUTPUT_SAMPLE_RATE / 2)

API & usage

The ASRC Task consists of a task to which various data structures must be declared and passed:

A pointer to instance of the asrc_in_out_t structure which contains buffers, stream information and ASRC task state.

A pointer to the FIFO used at the output side of the ASRC task.

The length of the FIFO passed in above.

In addition the following two functions may be declared in a user C file (note that XC does not handle function pointers):

The callback function from ASRC task which receives samples over a channel from the producer.

A callback initialisation function which registers the callback function into the asrc_in_out_t struct

If these are not defined, then a default receive implementation will be used which is matched with the send_asrc_input_samples_default() function on the user’s producer side. This should be sufficient for typical usage.

Note

ASRC task must have asrc_task_config.h defined in the user application which sets various static settings for the ASRC. See ASRC task API for details or reference AN02003: SPDIF/ADAT/I2S Receive to I2S Slave Bridge with ASRC as an example.

An example of calling the ASRC task form and XC main function is provided below. Note use of unsafe permitting the compiler to allow shared memory structures to be accessed by more than one thread:

chan c_producer;

// FIFO and ASRC I/O declaration. Unsafe to allow producer and consumer to access it from XC
#define FIFO_LENGTH     40 // Example only. Depends on rates and PPM - see docs
int64_t array[ASYNCHRONOUS_FIFO_INT64_ELEMENTS(FIFO_LENGTH, MAX_ASRC_CHANNELS_TOTAL)];

unsafe{
    // IO struct for ASRC must be passed to both asrc_proc and consumer
    asrc_in_out_t asrc_io = {{{0}}};
    asrc_in_out_t * unsafe asrc_io_ptr = &asrc_io;
    asynchronous_fifo_t * unsafe fifo = (asynchronous_fifo_t *)array;
    setup_asrc_io_custom_callback(asrc_io_ptr); // Optional user rx function

    par
    {
        producer(c_producer);
        asrc_task(c_producer, asrc_io_ptr, fifo, FIFO_LENGTH);
        consumer(asrc_io_ptr, fifo);

    }
} // unsafe region

An example of the user-defined C function for receiving the input samples is shown below along with the user callback registration function. The receive_asrc_input_samples() function must be as short as possible because it steals cycles from the ASRC task operation. Because this function is not called until the first channel word is received from the producer, the chanend_in_word() operations will happen straight away and not block as long as the producer immediately produces all required samples.

// Default implementation of receive (called from ASRC) which receives samples and config over a channel. This is overridable.
ASRC_TASK_ISR_CALLBACK_ATTR
unsigned receive_asrc_input_samples_cb_default(chanend_t c_asrc_input, asrc_in_out_t *asrc_io, unsigned *new_input_rate){
    static unsigned asrc_in_counter = 0;

    // Get format and timing data from channel
    *new_input_rate = chanend_in_word(c_asrc_input);
    asrc_io->input_timestamp[asrc_io->input_write_idx] = chanend_in_word(c_asrc_input);
    asrc_io->input_channel_count = chanend_in_word(c_asrc_input);

    // Pack into array properly LRLRLRLR for 2ch or 123412341234 for 4ch etc.
    for(int i = 0; i < asrc_io->input_channel_count; i++){
        int idx = i + asrc_io->input_channel_count * asrc_in_counter;
        asrc_io->input_samples[asrc_io->input_write_idx][idx] = chanend_in_word(c_asrc_input);
    }

    if(++asrc_in_counter == SRC_N_IN_SAMPLES){
        asrc_in_counter = 0;
    }

    return asrc_in_counter;
}
// END ASRC_TASK_ISR_CALLBACK_ATTR

Note that the producing side of the above transaction must match the channel protocol. For this example, the producer must send the following items across the channel in order:

The nominal input sample rate.

The input time stamp of the last sample received.

The input channel count of the current frame.

The samples from 0..n.

Because a streaming channel is used the back-pressure on the producer side will be very low because the channel outputs will be buffered and the receive callback will always respond to the received words.

This callback function helps bridge between sample based systems and the block-based nature of the underlying ASRC functions without consuming an extra thread.

The API for ASRC task is shown below:

typedef unsigned (*asrc_task_produce_isr_cb_t)(chanend_t c_asrc_input, asrc_in_out_t *asrc_io, unsigned *new_input_rate): Type definition of the callback function if a user version is required. May only be used from “C” (XC does not support function pointers).

void asrc_task(chanend c_asrc_input, asrc_in_out_t *asrc_io, asynchronous_fifo_t *fifo, unsigned fifo_length)

Main ASRC processor task. Runs forever waiting on new samples from the producer. Spawns up to MAX_ASRC_THREADS during ASRC processing.

Parameters:

c_asrc_input – The channel end used to connect the producer to the ASRC task.
asrc_io – A pointer to the structure used for holding ASRC IO and state.
fifo – A pointer to the FIFO used for outputting samples from the ASRC task to the consumer.
fifo_length – The length (depth) of the output FIFO. This is multiplied by channel count internally.

int pull_samples(asrc_in_out_t *asrc_io, asynchronous_fifo_t *fifo, int32_t *samples, uint32_t output_frequency, int32_t consume_timestamp)

Helper function called by consumer to provide ASRC output samples. Samples are populated in the *samples array and the user must provide the current nominal output frequency and a timestamp of when the last samples were consumed from the 100 MHz ref clock

Parameters:

asrc_io – A pointer to the structure used for holding ASRC IO and state.
fifo – A pointer to the FIFO used for outputting samples from the ASRC task to the consumer.
samples – A pointer to a whole output frame (all channels in a single sample period) to populate.
output_frequency – The nominal output frequency. Used for detecting a sample rate change.
consume_timestamp – The timestamp of the first consumed sample.

void reset_asrc_fifo_consumer(asynchronous_fifo_t *fifo)

Helper function called by consumer to reset the FIFO. Resets to half full and clears the contents to zero.

Parameters:

fifo – A pointer to the FIFO used for outputting samples from the ASRC task to the consumer.

void init_asrc_io_callback(asrc_in_out_t *asrc_io, asrc_task_produce_isr_cb_t asrc_rx_fp)

Prototype that can optionally be defined by the user to initialise the function pointer for the ASRC receive produced samples ISR. If this is not called then receive_asrc_input_samples_cb_default() is used and the you may call send_asrc_input_samples_default() from the application to send samples to the ASRC task.

Must be called before running asrc_task()

Parameters:

asrc_io – A pointer to the structure used for holding ASRC IO and state.
asrc_rx_fp – A pointer to the user asrc_receive_samples function. NOTE - This MUST be decorated by ASRC_TASK_ISR_CALLBACK_ATTR to allow proper stack calculation by the compiler. See receive_asrc_input_samples_cb_default() in asrc_task.c for an example of how to do this.

void send_asrc_input_samples_default(chanend c_asrc_input, unsigned input_frequency, int32_t input_timestamp, unsigned input_channel_count, int32_t *input_samples)

If the init_asrc_io_callback() function is not called then a default implementation of the ASRC receive will be used. This send function (called by the user producer side) mirrors the receive and can be used to push samples into the ASRC.

Parameters:

c_asrc_input – The chan end on the application producer side connecting to the ASRC task.
input_frequency – The sample rate of the input stream (44100, 48000, …).
input_timestamp – The ref clock timestamp of latest received input sample.
input_channel_count – The number of input audio channels (1, 2, 3 …).
input_samples – A pointer to the input samples array (channel 0, 1, …).

ASRC_TASK_ISR_CALLBACK_ATTR: Decorator for user’s ASRC producer receive callback. Must be used to allow stack usage calculation.

MAX_ASRC_CHANNELS_TOTAL: Maximum number of audio channels in total. Used for buffer sizing and FIFO sizing (statically defined).

MAX_ASRC_THREADS: Maximum number of threads to be spawned by ASRC task. Used for buffer sizing and FIFO sizing (statically defined).

SRC_N_IN_SAMPLES: Block size of input to the low level asrc_process function. Must be a power of 2 and minimum value is 4, maximum is 16. Used for buffer sizing and FIFO sizing (statically defined).

SRC_N_OUT_IN_RATIO_MAX: Max ratio between samples out:in per processing step (44.1->192 is worst case). Used for buffer sizing and FIFO sizing (statically defined).

SRC_DITHER_SETTING: Enables or disables quantisation of output with dithering to 24b.

struct asrc_in_out_t: #include <asrc_task.h>

lib_src: Sample rate conversion$$$Performance characterisation£££performance-plots.html#performance-characterisation

The FFT plots in this section provide a visual guide to the performance of the SSRC, ASRC, DS3 and OS3 sample rate converters. Test signals were created allowing analysis of the sample rate converter output across different scenarios.

Two input signals were played through a stereo sample rate converter across a range of input and output sample rates. For Channel 0, a single pure tone was generated ensuring its frequency was well within the overall nyquist rate. For Channel 1, multiple tones spaced logarithmically were generated with the spacing most dense at higher frequencies.

The resulting frequency plot output clearly shows the noise floor relative to the sample rate converted injected tone(s). The plots are annotated with an estimate of the Signal to Noise Ratio (SNR) as well as Total Harmonic Distortion (THD).

For the case of the ASRC, in addition to the nominal input frequency of 0 PPM deviation, the +/-100 PPM frequency deviation cases are also shown.

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations£££performance-plots.html#pure-tone-fft-src-plots-across-sample-rate-combinations

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 0.999900Hz£££performance-plots.html#frequency-error-0-999900hz

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 16,000Hz£££ch1-84998-to-6355-fsi192-fso192-fdev1-000000-asrc-ssrc-xsim-asrc.html#id9

No SRC available for this scenario.

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 32,000Hz£££ch1-84998-to-6355-fsi192-fso192-fdev1-000000-asrc-ssrc-xsim-asrc.html#id10

No SRC available for this scenario.

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 44,100Hz£££ch1-84998-to-6355-fsi192-fso192-fdev1-000000-asrc-ssrc-xsim-asrc.html#id11

Input Fs: 44,100Hz, channel 0
Input Fs: 44,100Hz, channel 1
Input Fs: 48,000Hz, channel 0
Input Fs: 48,000Hz, channel 1
Input Fs: 88,200Hz, channel 0
Input Fs: 88,200Hz, channel 1
Input Fs: 96,000Hz, channel 0
Input Fs: 96,000Hz, channel 1
Input Fs: 176,400Hz, channel 0
Input Fs: 176,400Hz, channel 1
Input Fs: 192,000Hz, channel 0
Input Fs: 192,000Hz, channel 1

../../_images/ch0_2201_fsi44_fso44_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 44,100Hz, Output Fs: 44,100Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch1_17999_to_8966_fsi44_fso44_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 44,100Hz, Output Fs: 44,100Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch0_2204_fsi48_fso44_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 48,000Hz, Output Fs: 44,100Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch1_18000_to_1402_fsi48_fso44_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 48,000Hz, Output Fs: 44,100Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch0_2203_fsi88_fso44_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 88,200Hz, Output Fs: 44,100Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch1_17999_to_8966_fsi88_fso44_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 88,200Hz, Output Fs: 44,100Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch0_2204_fsi96_fso44_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 96,000Hz, Output Fs: 44,100Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch1_18000_to_1402_fsi96_fso44_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 96,000Hz, Output Fs: 44,100Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch0_2204_fsi176_fso44_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 176,400Hz, Output Fs: 44,100Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch1_17999_to_8966_fsi176_fso44_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 176,400Hz, Output Fs: 44,100Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch0_2204_fsi192_fso44_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 192,000Hz, Output Fs: 44,100Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch1_17999_to_1402_fsi192_fso44_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 192,000Hz, Output Fs: 44,100Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 48,000Hz£££ch1-17999-to-1405-fsi192-fso44-fdev1-000100-asrc-xsim-asrc.html#id12

Input Fs: 44,100Hz, channel 0
Input Fs: 44,100Hz, channel 1
Input Fs: 48,000Hz, channel 0
Input Fs: 48,000Hz, channel 1
Input Fs: 88,200Hz, channel 0
Input Fs: 88,200Hz, channel 1
Input Fs: 96,000Hz, channel 0
Input Fs: 96,000Hz, channel 1
Input Fs: 176,400Hz, channel 0
Input Fs: 176,400Hz, channel 1
Input Fs: 192,000Hz, channel 0
Input Fs: 192,000Hz, channel 1

../../_images/ch0_2398_fsi44_fso48_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 44,100Hz, Output Fs: 48,000Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch1_17996_to_7295_fsi44_fso48_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 44,100Hz, Output Fs: 48,000Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch0_2395_fsi48_fso48_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 48,000Hz, Output Fs: 48,000Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch1_21799_to_2136_fsi48_fso48_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 48,000Hz, Output Fs: 48,000Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch0_2398_fsi88_fso48_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 88,200Hz, Output Fs: 48,000Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch1_21799_to_397_fsi88_fso48_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 88,200Hz, Output Fs: 48,000Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch0_2398_fsi96_fso48_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 96,000Hz, Output Fs: 48,000Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch1_21799_to_2136_fsi96_fso48_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 96,000Hz, Output Fs: 48,000Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch0_2400_fsi176_fso48_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 176,400Hz, Output Fs: 48,000Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch1_21799_to_397_fsi176_fso48_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 176,400Hz, Output Fs: 48,000Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch0_2399_fsi192_fso48_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 192,000Hz, Output Fs: 48,000Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch1_21799_to_2136_fsi192_fso48_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 192,000Hz, Output Fs: 48,000Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 88,200Hz£££ch1-21799-to-2141-fsi192-fso48-fdev1-000100-asrc-xsim-asrc.html#id13

Input Fs: 44,100Hz, channel 0
Input Fs: 44,100Hz, channel 1
Input Fs: 48,000Hz, channel 0
Input Fs: 48,000Hz, channel 1
Input Fs: 88,200Hz, channel 0
Input Fs: 88,200Hz, channel 1
Input Fs: 96,000Hz, channel 0
Input Fs: 96,000Hz, channel 1
Input Fs: 176,400Hz, channel 0
Input Fs: 176,400Hz, channel 1
Input Fs: 192,000Hz, channel 0
Input Fs: 192,000Hz, channel 1

../../_images/ch0_4393_fsi44_fso88_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 44,100Hz, Output Fs: 88,200Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch1_17996_to_8963_fsi44_fso88_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 44,100Hz, Output Fs: 88,200Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch0_4409_fsi48_fso88_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 48,000Hz, Output Fs: 88,200Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch1_21787_to_5187_fsi48_fso88_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 48,000Hz, Output Fs: 88,200Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch0_4402_fsi88_fso88_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 88,200Hz, Output Fs: 88,200Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch1_39994_to_3864_fsi88_fso88_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 88,200Hz, Output Fs: 88,200Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch0_4409_fsi96_fso88_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 96,000Hz, Output Fs: 88,200Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch1_39995_to_6800_fsi96_fso88_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 96,000Hz, Output Fs: 88,200Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch0_4406_fsi176_fso88_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 176,400Hz, Output Fs: 88,200Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch1_39998_to_3868_fsi176_fso88_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 176,400Hz, Output Fs: 88,200Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch0_4409_fsi192_fso88_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 192,000Hz, Output Fs: 88,200Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch1_39999_to_6804_fsi192_fso88_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 192,000Hz, Output Fs: 88,200Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 96,000Hz£££ch1-40000-to-6810-fsi192-fso88-fdev1-000100-asrc-xsim-asrc.html#id14

Input Fs: 44,100Hz, channel 0
Input Fs: 44,100Hz, channel 1
Input Fs: 48,000Hz, channel 0
Input Fs: 48,000Hz, channel 1
Input Fs: 88,200Hz, channel 0
Input Fs: 88,200Hz, channel 1
Input Fs: 96,000Hz, channel 0
Input Fs: 96,000Hz, channel 1
Input Fs: 176,400Hz, channel 0
Input Fs: 176,400Hz, channel 1
Input Fs: 192,000Hz, channel 0
Input Fs: 192,000Hz, channel 1

../../_images/ch0_4786_fsi44_fso96_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 44,100Hz, Output Fs: 96,000Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch1_17996_to_7295_fsi44_fso96_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 44,100Hz, Output Fs: 96,000Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch0_4782_fsi48_fso96_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 48,000Hz, Output Fs: 96,000Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch1_21796_to_2132_fsi48_fso96_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 48,000Hz, Output Fs: 96,000Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch0_4797_fsi88_fso96_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 88,200Hz, Output Fs: 96,000Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch1_39995_to_18592_fsi88_fso96_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 88,200Hz, Output Fs: 96,000Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch0_4791_fsi96_fso96_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 96,000Hz, Output Fs: 96,000Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch1_41995_to_2669_fsi96_fso96_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 96,000Hz, Output Fs: 96,000Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch0_4797_fsi176_fso96_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 176,400Hz, Output Fs: 96,000Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch1_41999_to_20597_fsi176_fso96_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 176,400Hz, Output Fs: 96,000Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch0_4796_fsi192_fso96_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 192,000Hz, Output Fs: 96,000Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch1_41999_to_2674_fsi192_fso96_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 192,000Hz, Output Fs: 96,000Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 176,400Hz£££ch1-41996-to-2678-fsi192-fso96-fdev1-000100-asrc-xsim-asrc.html#id15

Input Fs: 44,100Hz, channel 0
Input Fs: 44,100Hz, channel 1
Input Fs: 48,000Hz, channel 0
Input Fs: 48,000Hz, channel 1
Input Fs: 88,200Hz, channel 0
Input Fs: 88,200Hz, channel 1
Input Fs: 96,000Hz, channel 0
Input Fs: 96,000Hz, channel 1
Input Fs: 176,400Hz, channel 0
Input Fs: 176,400Hz, channel 1
Input Fs: 192,000Hz, channel 0
Input Fs: 192,000Hz, channel 1

../../_images/ch0_8753_fsi44_fso176_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 44,100Hz, Output Fs: 176,400Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch1_18000_to_8965_fsi44_fso176_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 44,100Hz, Output Fs: 176,400Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch0_8820_fsi48_fso176_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 48,000Hz, Output Fs: 176,400Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch1_21791_to_5188_fsi48_fso176_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 48,000Hz, Output Fs: 176,400Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch0_8786_fsi88_fso176_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 88,200Hz, Output Fs: 176,400Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch1_39980_to_3846_fsi88_fso176_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 88,200Hz, Output Fs: 176,400Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch0_8818_fsi96_fso176_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 96,000Hz, Output Fs: 176,400Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch1_41985_to_8786_fsi96_fso176_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 96,000Hz, Output Fs: 176,400Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch0_8803_fsi176_fso176_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 176,400Hz, Output Fs: 176,400Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch1_79988_to_7727_fsi176_fso176_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 176,400Hz, Output Fs: 176,400Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch0_8818_fsi192_fso176_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 192,000Hz, Output Fs: 176,400Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch1_79990_to_13599_fsi192_fso176_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 192,000Hz, Output Fs: 176,400Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 192,000Hz£££ch1-79992-to-13613-fsi192-fso176-fdev1-000100-asrc-xsim-asrc.html#id16

Input Fs: 44,100Hz, channel 0
Input Fs: 44,100Hz, channel 1
Input Fs: 48,000Hz, channel 0
Input Fs: 48,000Hz, channel 1
Input Fs: 88,200Hz, channel 0
Input Fs: 88,200Hz, channel 1
Input Fs: 96,000Hz, channel 0
Input Fs: 96,000Hz, channel 1
Input Fs: 176,400Hz, channel 0
Input Fs: 176,400Hz, channel 1
Input Fs: 192,000Hz, channel 0
Input Fs: 192,000Hz, channel 1

../../_images/ch0_9533_fsi44_fso192_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 44,100Hz, Output Fs: 192,000Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch1_17979_to_7275_fsi44_fso192_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 44,100Hz, Output Fs: 192,000Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch0_9527_fsi48_fso192_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 48,000Hz, Output Fs: 192,000Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch1_21743_to_2074_fsi48_fso192_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 48,000Hz, Output Fs: 192,000Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch0_9573_fsi88_fso192_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 88,200Hz, Output Fs: 192,000Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch1_39963_to_18560_fsi88_fso192_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 88,200Hz, Output Fs: 192,000Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch0_9564_fsi96_fso192_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 96,000Hz, Output Fs: 192,000Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch1_41980_to_2650_fsi96_fso192_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 96,000Hz, Output Fs: 192,000Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch0_9594_fsi176_fso192_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 176,400Hz, Output Fs: 192,000Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch1_79990_to_37184_fsi176_fso192_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 176,400Hz, Output Fs: 192,000Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch0_9582_fsi192_fso192_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 192,000Hz, Output Fs: 192,000Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

../../_images/ch1_84988_to_6337_fsi192_fso192_fdev0.999900_asrc_xsim-asrc.png — Input Fs: 192,000Hz, Output Fs: 192,000Hz, Fs error: 0.999900, Results for: asrc, xsim-asrc

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000000Hz£££ch1-84988-to-6337-fsi192-fso192-fdev0-999900-asrc-xsim-asrc.html#frequency-error-1-000000hz

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 16,000Hz£££ch1-84998-to-6355-fsi192-fso192-fdev1-000000-asrc-ssrc-xsim-asrc.html#id9

Input Fs: 48,000Hz, channel 0
Input Fs: 48,000Hz, channel 1

../../_images/ch0_800_fsi48_fso16_fdev1.000000_ds3.png — Input Fs: 48,000Hz, Output Fs: 16,000Hz, Fs error: 1.000000, Results for: ds3

../../_images/ch1_7300_to_2931_fsi48_fso16_fdev1.000000_ds3.png — Input Fs: 48,000Hz, Output Fs: 16,000Hz, Fs error: 1.000000, Results for: ds3

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 32,000Hz£££ch1-84998-to-6355-fsi192-fso192-fdev1-000000-asrc-ssrc-xsim-asrc.html#id10

Input Fs: 96,000Hz, channel 0
Input Fs: 96,000Hz, channel 1

../../_images/ch0_1600_fsi96_fso32_fdev1.000000_ds3.png — Input Fs: 96,000Hz, Output Fs: 32,000Hz, Fs error: 1.000000, Results for: ds3

../../_images/ch1_14599_to_5861_fsi96_fso32_fdev1.000000_ds3.png — Input Fs: 96,000Hz, Output Fs: 32,000Hz, Fs error: 1.000000, Results for: ds3

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 44,100Hz£££ch1-84998-to-6355-fsi192-fso192-fdev1-000000-asrc-ssrc-xsim-asrc.html#id11

Input Fs: 44,100Hz, channel 0
Input Fs: 44,100Hz, channel 1
Input Fs: 48,000Hz, channel 0
Input Fs: 48,000Hz, channel 1
Input Fs: 88,200Hz, channel 0
Input Fs: 88,200Hz, channel 1
Input Fs: 96,000Hz, channel 0
Input Fs: 96,000Hz, channel 1
Input Fs: 176,400Hz, channel 0
Input Fs: 176,400Hz, channel 1
Input Fs: 192,000Hz, channel 0
Input Fs: 192,000Hz, channel 1

../../_images/ch0_2205_fsi44_fso44_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 44,100Hz, Output Fs: 44,100Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch1_17997_to_8966_fsi44_fso44_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 44,100Hz, Output Fs: 44,100Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch0_2204_fsi48_fso44_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 48,000Hz, Output Fs: 44,100Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch1_17998_to_1402_fsi48_fso44_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 48,000Hz, Output Fs: 44,100Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch0_2205_fsi88_fso44_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 88,200Hz, Output Fs: 44,100Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch1_17999_to_8968_fsi88_fso44_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 88,200Hz, Output Fs: 44,100Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch0_2204_fsi96_fso44_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 96,000Hz, Output Fs: 44,100Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch1_17998_to_1402_fsi96_fso44_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 96,000Hz, Output Fs: 44,100Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch0_2205_fsi176_fso44_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 176,400Hz, Output Fs: 44,100Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch1_17999_to_8968_fsi176_fso44_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 176,400Hz, Output Fs: 44,100Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch0_2204_fsi192_fso44_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 192,000Hz, Output Fs: 44,100Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch1_18000_to_1404_fsi192_fso44_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 192,000Hz, Output Fs: 44,100Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 48,000Hz£££ch1-17999-to-1405-fsi192-fso44-fdev1-000100-asrc-xsim-asrc.html#id12

Input Fs: 16,000Hz, channel 0
Input Fs: 16,000Hz, channel 1
Input Fs: 44,100Hz, channel 0
Input Fs: 44,100Hz, channel 1
Input Fs: 48,000Hz, channel 0
Input Fs: 48,000Hz, channel 1
Input Fs: 88,200Hz, channel 0
Input Fs: 88,200Hz, channel 1
Input Fs: 96,000Hz, channel 0
Input Fs: 96,000Hz, channel 1
Input Fs: 176,400Hz, channel 0
Input Fs: 176,400Hz, channel 1
Input Fs: 192,000Hz, channel 0
Input Fs: 192,000Hz, channel 1

../../_images/ch0_2391_fsi16_fso48_fdev1.000000_os3.png — Input Fs: 16,000Hz, Output Fs: 48,000Hz, Fs error: 1.000000, Results for: os3

../../_images/ch1_7287_to_3600_fsi16_fso48_fdev1.000000_os3.png — Input Fs: 16,000Hz, Output Fs: 48,000Hz, Fs error: 1.000000, Results for: os3

../../_images/ch0_2398_fsi44_fso48_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 44,100Hz, Output Fs: 48,000Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch1_17999_to_7299_fsi44_fso48_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 44,100Hz, Output Fs: 48,000Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch0_2400_fsi48_fso48_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 48,000Hz, Output Fs: 48,000Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch1_21797_to_2136_fsi48_fso48_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 48,000Hz, Output Fs: 48,000Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch0_2398_fsi88_fso48_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 88,200Hz, Output Fs: 48,000Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch1_21799_to_400_fsi88_fso48_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 88,200Hz, Output Fs: 48,000Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch0_2400_fsi96_fso48_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 96,000Hz, Output Fs: 48,000Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch1_21799_to_2138_fsi96_fso48_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 96,000Hz, Output Fs: 48,000Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch0_2399_fsi176_fso48_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 176,400Hz, Output Fs: 48,000Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch1_21799_to_400_fsi176_fso48_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 176,400Hz, Output Fs: 48,000Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch0_2400_fsi192_fso48_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 192,000Hz, Output Fs: 48,000Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch1_21799_to_2138_fsi192_fso48_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 192,000Hz, Output Fs: 48,000Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 88,200Hz£££ch1-21799-to-2141-fsi192-fso48-fdev1-000100-asrc-xsim-asrc.html#id13

Input Fs: 44,100Hz, channel 0
Input Fs: 44,100Hz, channel 1
Input Fs: 48,000Hz, channel 0
Input Fs: 48,000Hz, channel 1
Input Fs: 88,200Hz, channel 0
Input Fs: 88,200Hz, channel 1
Input Fs: 96,000Hz, channel 0
Input Fs: 96,000Hz, channel 1
Input Fs: 176,400Hz, channel 0
Input Fs: 176,400Hz, channel 1
Input Fs: 192,000Hz, channel 0
Input Fs: 192,000Hz, channel 1

../../_images/ch0_4410_fsi44_fso88_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 44,100Hz, Output Fs: 88,200Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch1_17993_to_8961_fsi44_fso88_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 44,100Hz, Output Fs: 88,200Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch0_4408_fsi48_fso88_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 48,000Hz, Output Fs: 88,200Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch1_21799_to_5203_fsi48_fso88_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 48,000Hz, Output Fs: 88,200Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch0_4410_fsi88_fso88_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 88,200Hz, Output Fs: 88,200Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch1_39999_to_3872_fsi88_fso88_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 88,200Hz, Output Fs: 88,200Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch0_4408_fsi96_fso88_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 96,000Hz, Output Fs: 88,200Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch1_40000_to_6807_fsi96_fso88_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 96,000Hz, Output Fs: 88,200Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch0_4410_fsi176_fso88_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 176,400Hz, Output Fs: 88,200Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch1_39999_to_3872_fsi176_fso88_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 176,400Hz, Output Fs: 88,200Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch0_4408_fsi192_fso88_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 192,000Hz, Output Fs: 88,200Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch1_40000_to_6807_fsi192_fso88_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 192,000Hz, Output Fs: 88,200Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 96,000Hz£££ch1-40000-to-6810-fsi192-fso88-fdev1-000100-asrc-xsim-asrc.html#id14

Input Fs: 32,000Hz, channel 0
Input Fs: 32,000Hz, channel 1
Input Fs: 44,100Hz, channel 0
Input Fs: 44,100Hz, channel 1
Input Fs: 48,000Hz, channel 0
Input Fs: 48,000Hz, channel 1
Input Fs: 88,200Hz, channel 0
Input Fs: 88,200Hz, channel 1
Input Fs: 96,000Hz, channel 0
Input Fs: 96,000Hz, channel 1
Input Fs: 176,400Hz, channel 0
Input Fs: 176,400Hz, channel 1
Input Fs: 192,000Hz, channel 0
Input Fs: 192,000Hz, channel 1

../../_images/ch0_4781_fsi32_fso96_fdev1.000000_os3.png — Input Fs: 32,000Hz, Output Fs: 96,000Hz, Fs error: 1.000000, Results for: os3

../../_images/ch1_14574_to_7201_fsi32_fso96_fdev1.000000_os3.png — Input Fs: 32,000Hz, Output Fs: 96,000Hz, Fs error: 1.000000, Results for: os3

../../_images/ch0_4786_fsi44_fso96_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 44,100Hz, Output Fs: 96,000Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch1_17996_to_7295_fsi44_fso96_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 44,100Hz, Output Fs: 96,000Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch0_4800_fsi48_fso96_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 48,000Hz, Output Fs: 96,000Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch1_21792_to_2131_fsi48_fso96_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 48,000Hz, Output Fs: 96,000Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch0_4796_fsi88_fso96_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 88,200Hz, Output Fs: 96,000Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch1_39990_to_18590_fsi88_fso96_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 88,200Hz, Output Fs: 96,000Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch0_4800_fsi96_fso96_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 96,000Hz, Output Fs: 96,000Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch1_42000_to_2678_fsi96_fso96_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 96,000Hz, Output Fs: 96,000Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch0_4796_fsi176_fso96_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 176,400Hz, Output Fs: 96,000Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch1_42000_to_20600_fsi176_fso96_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 176,400Hz, Output Fs: 96,000Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch0_4800_fsi192_fso96_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 192,000Hz, Output Fs: 96,000Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch1_42000_to_2678_fsi192_fso96_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 192,000Hz, Output Fs: 96,000Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 176,400Hz£££ch1-41996-to-2678-fsi192-fso96-fdev1-000100-asrc-xsim-asrc.html#id15

Input Fs: 44,100Hz, channel 0
Input Fs: 44,100Hz, channel 1
Input Fs: 48,000Hz, channel 0
Input Fs: 48,000Hz, channel 1
Input Fs: 88,200Hz, channel 0
Input Fs: 88,200Hz, channel 1
Input Fs: 96,000Hz, channel 0
Input Fs: 96,000Hz, channel 1
Input Fs: 176,400Hz, channel 0
Input Fs: 176,400Hz, channel 1
Input Fs: 192,000Hz, channel 0
Input Fs: 192,000Hz, channel 1

../../_images/ch0_8820_fsi44_fso176_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 44,100Hz, Output Fs: 176,400Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch1_17993_to_8961_fsi44_fso176_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 44,100Hz, Output Fs: 176,400Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch0_8817_fsi48_fso176_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 48,000Hz, Output Fs: 176,400Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch1_21783_to_5186_fsi48_fso176_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 48,000Hz, Output Fs: 176,400Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch0_8820_fsi88_fso176_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 88,200Hz, Output Fs: 176,400Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch1_39972_to_3846_fsi88_fso176_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 88,200Hz, Output Fs: 176,400Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch0_8817_fsi96_fso176_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 96,000Hz, Output Fs: 176,400Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch1_41977_to_8784_fsi96_fso176_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 96,000Hz, Output Fs: 176,400Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch0_8820_fsi176_fso176_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 176,400Hz, Output Fs: 176,400Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch1_79997_to_7744_fsi176_fso176_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 176,400Hz, Output Fs: 176,400Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch0_8817_fsi192_fso176_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 192,000Hz, Output Fs: 176,400Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch1_79999_to_13614_fsi192_fso176_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 192,000Hz, Output Fs: 176,400Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 192,000Hz£££ch1-79992-to-13613-fsi192-fso176-fdev1-000100-asrc-xsim-asrc.html#id16

Input Fs: 44,100Hz, channel 0
Input Fs: 44,100Hz, channel 1
Input Fs: 48,000Hz, channel 0
Input Fs: 48,000Hz, channel 1
Input Fs: 88,200Hz, channel 0
Input Fs: 88,200Hz, channel 1
Input Fs: 96,000Hz, channel 0
Input Fs: 96,000Hz, channel 1
Input Fs: 176,400Hz, channel 0
Input Fs: 176,400Hz, channel 1
Input Fs: 192,000Hz, channel 0
Input Fs: 192,000Hz, channel 1

../../_images/ch0_9533_fsi44_fso192_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 44,100Hz, Output Fs: 192,000Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch1_17979_to_7275_fsi44_fso192_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 44,100Hz, Output Fs: 192,000Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch0_9600_fsi48_fso192_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 48,000Hz, Output Fs: 192,000Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch1_21734_to_2074_fsi48_fso192_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 48,000Hz, Output Fs: 192,000Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch0_9573_fsi88_fso192_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 88,200Hz, Output Fs: 192,000Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch1_39963_to_18560_fsi88_fso192_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 88,200Hz, Output Fs: 192,000Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch0_9600_fsi96_fso192_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 96,000Hz, Output Fs: 192,000Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch1_41971_to_2650_fsi96_fso192_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 96,000Hz, Output Fs: 192,000Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch0_9593_fsi176_fso192_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 176,400Hz, Output Fs: 192,000Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch1_79981_to_37179_fsi176_fso192_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 176,400Hz, Output Fs: 192,000Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch0_9600_fsi192_fso192_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 192,000Hz, Output Fs: 192,000Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

../../_images/ch1_84998_to_6355_fsi192_fso192_fdev1.000000_asrc_ssrc_xsim-asrc.png — Input Fs: 192,000Hz, Output Fs: 192,000Hz, Fs error: 1.000000, Results for: asrc, ssrc, xsim-asrc

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz£££ch1-84998-to-6355-fsi192-fso192-fdev1-000000-asrc-ssrc-xsim-asrc.html#frequency-error-1-000100hz

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 16,000Hz£££ch1-84998-to-6355-fsi192-fso192-fdev1-000000-asrc-ssrc-xsim-asrc.html#id9

No SRC available for this scenario.

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 32,000Hz£££ch1-84998-to-6355-fsi192-fso192-fdev1-000000-asrc-ssrc-xsim-asrc.html#id10

No SRC available for this scenario.

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 44,100Hz£££ch1-84998-to-6355-fsi192-fso192-fdev1-000000-asrc-ssrc-xsim-asrc.html#id11

Input Fs: 44,100Hz, channel 0
Input Fs: 44,100Hz, channel 1
Input Fs: 48,000Hz, channel 0
Input Fs: 48,000Hz, channel 1
Input Fs: 88,200Hz, channel 0
Input Fs: 88,200Hz, channel 1
Input Fs: 96,000Hz, channel 0
Input Fs: 96,000Hz, channel 1
Input Fs: 176,400Hz, channel 0
Input Fs: 176,400Hz, channel 1
Input Fs: 192,000Hz, channel 0
Input Fs: 192,000Hz, channel 1

../../_images/ch0_2205_fsi44_fso44_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 44,100Hz, Output Fs: 44,100Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch1_17997_to_8966_fsi44_fso44_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 44,100Hz, Output Fs: 44,100Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch0_2204_fsi48_fso44_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 48,000Hz, Output Fs: 44,100Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch1_17997_to_1402_fsi48_fso44_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 48,000Hz, Output Fs: 44,100Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch0_2205_fsi88_fso44_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 88,200Hz, Output Fs: 44,100Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch1_17999_to_8967_fsi88_fso44_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 88,200Hz, Output Fs: 44,100Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch0_2204_fsi96_fso44_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 96,000Hz, Output Fs: 44,100Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch1_17999_to_1404_fsi96_fso44_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 96,000Hz, Output Fs: 44,100Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch0_2205_fsi176_fso44_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 176,400Hz, Output Fs: 44,100Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch1_17999_to_8968_fsi176_fso44_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 176,400Hz, Output Fs: 44,100Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch0_2205_fsi192_fso44_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 192,000Hz, Output Fs: 44,100Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch1_17999_to_1405_fsi192_fso44_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 192,000Hz, Output Fs: 44,100Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 48,000Hz£££ch1-17999-to-1405-fsi192-fso44-fdev1-000100-asrc-xsim-asrc.html#id12

Input Fs: 44,100Hz, channel 0
Input Fs: 44,100Hz, channel 1
Input Fs: 48,000Hz, channel 0
Input Fs: 48,000Hz, channel 1
Input Fs: 88,200Hz, channel 0
Input Fs: 88,200Hz, channel 1
Input Fs: 96,000Hz, channel 0
Input Fs: 96,000Hz, channel 1
Input Fs: 176,400Hz, channel 0
Input Fs: 176,400Hz, channel 1
Input Fs: 192,000Hz, channel 0
Input Fs: 192,000Hz, channel 1

../../_images/ch0_2398_fsi44_fso48_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 44,100Hz, Output Fs: 48,000Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch1_17997_to_7298_fsi44_fso48_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 44,100Hz, Output Fs: 48,000Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch0_2400_fsi48_fso48_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 48,000Hz, Output Fs: 48,000Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch1_21799_to_2141_fsi48_fso48_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 48,000Hz, Output Fs: 48,000Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch0_2398_fsi88_fso48_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 88,200Hz, Output Fs: 48,000Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch1_21798_to_400_fsi88_fso48_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 88,200Hz, Output Fs: 48,000Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch0_2400_fsi96_fso48_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 96,000Hz, Output Fs: 48,000Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch1_21799_to_2141_fsi96_fso48_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 96,000Hz, Output Fs: 48,000Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch0_2399_fsi176_fso48_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 176,400Hz, Output Fs: 48,000Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch1_21799_to_401_fsi176_fso48_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 176,400Hz, Output Fs: 48,000Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch0_2400_fsi192_fso48_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 192,000Hz, Output Fs: 48,000Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch1_21799_to_2141_fsi192_fso48_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 192,000Hz, Output Fs: 48,000Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 88,200Hz£££ch1-21799-to-2141-fsi192-fso48-fdev1-000100-asrc-xsim-asrc.html#id13

Input Fs: 44,100Hz, channel 0
Input Fs: 44,100Hz, channel 1
Input Fs: 48,000Hz, channel 0
Input Fs: 48,000Hz, channel 1
Input Fs: 88,200Hz, channel 0
Input Fs: 88,200Hz, channel 1
Input Fs: 96,000Hz, channel 0
Input Fs: 96,000Hz, channel 1
Input Fs: 176,400Hz, channel 0
Input Fs: 176,400Hz, channel 1
Input Fs: 192,000Hz, channel 0
Input Fs: 192,000Hz, channel 1

../../_images/ch0_4410_fsi44_fso88_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 44,100Hz, Output Fs: 88,200Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch1_17993_to_8961_fsi44_fso88_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 44,100Hz, Output Fs: 88,200Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch0_4408_fsi48_fso88_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 48,000Hz, Output Fs: 88,200Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch1_21799_to_5203_fsi48_fso88_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 48,000Hz, Output Fs: 88,200Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch0_4410_fsi88_fso88_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 88,200Hz, Output Fs: 88,200Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch1_39999_to_3872_fsi88_fso88_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 88,200Hz, Output Fs: 88,200Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch0_4408_fsi96_fso88_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 96,000Hz, Output Fs: 88,200Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch1_39996_to_6806_fsi96_fso88_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 96,000Hz, Output Fs: 88,200Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch0_4410_fsi176_fso88_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 176,400Hz, Output Fs: 88,200Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch1_39997_to_3872_fsi176_fso88_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 176,400Hz, Output Fs: 88,200Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch0_4408_fsi192_fso88_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 192,000Hz, Output Fs: 88,200Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch1_40000_to_6810_fsi192_fso88_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 192,000Hz, Output Fs: 88,200Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 96,000Hz£££ch1-40000-to-6810-fsi192-fso88-fdev1-000100-asrc-xsim-asrc.html#id14

Input Fs: 44,100Hz, channel 0
Input Fs: 44,100Hz, channel 1
Input Fs: 48,000Hz, channel 0
Input Fs: 48,000Hz, channel 1
Input Fs: 88,200Hz, channel 0
Input Fs: 88,200Hz, channel 1
Input Fs: 96,000Hz, channel 0
Input Fs: 96,000Hz, channel 1
Input Fs: 176,400Hz, channel 0
Input Fs: 176,400Hz, channel 1
Input Fs: 192,000Hz, channel 0
Input Fs: 192,000Hz, channel 1

../../_images/ch0_4785_fsi44_fso96_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 44,100Hz, Output Fs: 96,000Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch1_17992_to_7293_fsi44_fso96_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 44,100Hz, Output Fs: 96,000Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch0_4800_fsi48_fso96_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 48,000Hz, Output Fs: 96,000Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch1_21792_to_2131_fsi48_fso96_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 48,000Hz, Output Fs: 96,000Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch0_4796_fsi88_fso96_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 88,200Hz, Output Fs: 96,000Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch1_39997_to_18598_fsi88_fso96_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 88,200Hz, Output Fs: 96,000Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch0_4800_fsi96_fso96_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 96,000Hz, Output Fs: 96,000Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch1_41996_to_2678_fsi96_fso96_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 96,000Hz, Output Fs: 96,000Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch0_4796_fsi176_fso96_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 176,400Hz, Output Fs: 96,000Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch1_41997_to_20599_fsi176_fso96_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 176,400Hz, Output Fs: 96,000Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch0_4800_fsi192_fso96_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 192,000Hz, Output Fs: 96,000Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch1_41996_to_2678_fsi192_fso96_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 192,000Hz, Output Fs: 96,000Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 176,400Hz£££ch1-41996-to-2678-fsi192-fso96-fdev1-000100-asrc-xsim-asrc.html#id15

Input Fs: 44,100Hz, channel 0
Input Fs: 44,100Hz, channel 1
Input Fs: 48,000Hz, channel 0
Input Fs: 48,000Hz, channel 1
Input Fs: 88,200Hz, channel 0
Input Fs: 88,200Hz, channel 1
Input Fs: 96,000Hz, channel 0
Input Fs: 96,000Hz, channel 1
Input Fs: 176,400Hz, channel 0
Input Fs: 176,400Hz, channel 1
Input Fs: 192,000Hz, channel 0
Input Fs: 192,000Hz, channel 1

../../_images/ch0_8820_fsi44_fso176_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 44,100Hz, Output Fs: 176,400Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch1_17993_to_8961_fsi44_fso176_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 44,100Hz, Output Fs: 176,400Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch0_8817_fsi48_fso176_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 48,000Hz, Output Fs: 176,400Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch1_21783_to_5186_fsi48_fso176_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 48,000Hz, Output Fs: 176,400Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch0_8820_fsi88_fso176_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 88,200Hz, Output Fs: 176,400Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch1_39972_to_3846_fsi88_fso176_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 88,200Hz, Output Fs: 176,400Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch0_8817_fsi96_fso176_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 96,000Hz, Output Fs: 176,400Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch1_41977_to_8784_fsi96_fso176_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 96,000Hz, Output Fs: 176,400Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch0_8820_fsi176_fso176_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 176,400Hz, Output Fs: 176,400Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch1_79997_to_7744_fsi176_fso176_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 176,400Hz, Output Fs: 176,400Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch0_8816_fsi192_fso176_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 192,000Hz, Output Fs: 176,400Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch1_79992_to_13613_fsi192_fso176_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 192,000Hz, Output Fs: 176,400Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 192,000Hz£££ch1-79992-to-13613-fsi192-fso176-fdev1-000100-asrc-xsim-asrc.html#id16

Input Fs: 44,100Hz, channel 0
Input Fs: 44,100Hz, channel 1
Input Fs: 48,000Hz, channel 0
Input Fs: 48,000Hz, channel 1
Input Fs: 88,200Hz, channel 0
Input Fs: 88,200Hz, channel 1
Input Fs: 96,000Hz, channel 0
Input Fs: 96,000Hz, channel 1
Input Fs: 176,400Hz, channel 0
Input Fs: 176,400Hz, channel 1
Input Fs: 192,000Hz, channel 0
Input Fs: 192,000Hz, channel 1

../../_images/ch0_9529_fsi44_fso192_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 44,100Hz, Output Fs: 192,000Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch1_17971_to_7272_fsi44_fso192_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 44,100Hz, Output Fs: 192,000Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch0_9600_fsi48_fso192_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 48,000Hz, Output Fs: 192,000Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch1_21734_to_2074_fsi48_fso192_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 48,000Hz, Output Fs: 192,000Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch0_9571_fsi88_fso192_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 88,200Hz, Output Fs: 192,000Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch1_39997_to_18598_fsi88_fso192_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 88,200Hz, Output Fs: 192,000Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch0_9600_fsi96_fso192_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 96,000Hz, Output Fs: 192,000Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch1_41971_to_2650_fsi96_fso192_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 96,000Hz, Output Fs: 192,000Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch0_9592_fsi176_fso192_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 176,400Hz, Output Fs: 192,000Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch1_79993_to_37196_fsi176_fso192_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 176,400Hz, Output Fs: 192,000Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch0_9599_fsi192_fso192_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 192,000Hz, Output Fs: 192,000Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

../../_images/ch1_84990_to_6355_fsi192_fso192_fdev1.000100_asrc_xsim-asrc.png — Input Fs: 192,000Hz, Output Fs: 192,000Hz, Fs error: 1.000100, Results for: asrc, xsim-asrc

lib_src: Sample rate conversion$$$Performance characterisation$$$Summary table£££ch1-84990-to-6355-fsi192-fso192-fdev1-000100-asrc-xsim-asrc.html#summary-table

Data table
source	ipRate(Hz)	opRate(Hz)	fDev	ch	signals(Hz)	SNR(dB)	THD(dB)
asrc	44100	44100	0.9999	0	2201.030	130.4	-197.2dB
xsim-asrc	44100	44100	0.9999	0	2201.030	129.4	-196.4dB
asrc	44100	44100	0.9999	1	8967.323-18000.810	136.1	NA
xsim-asrc	44100	44100	0.9999	1	8967.323-18000.810	133.8	NA
asrc	48000	44100	0.9999	0	2204.613	125.1	-189.7dB
xsim-asrc	48000	44100	0.9999	0	2204.613	124.8	-187.9dB
asrc	48000	44100	0.9999	1	1402.198-18001.635	131.5	NA
xsim-asrc	48000	44100	0.9999	1	1402.198-18001.635	130.8	NA
asrc	88200	44100	0.9999	0	2203.236	129.5	-198.1dB
xsim-asrc	88200	44100	0.9999	0	2203.236	127.7	-201.4dB
asrc	88200	44100	0.9999	1	8967.323-18000.810	135.5	NA
xsim-asrc	88200	44100	0.9999	1	8967.323-18000.810	131.5	NA
asrc	96000	44100	0.9999	0	2204.613	124.2	-193.8dB
xsim-asrc	96000	44100	0.9999	0	2204.613	123.5	-195.2dB
asrc	96000	44100	0.9999	1	1402.198-18001.635	130.0	NA
xsim-asrc	96000	44100	0.9999	1	1402.198-18001.635	128.6	NA
asrc	176400	44100	0.9999	0	2204.338	128.2	-197.5dB
xsim-asrc	176400	44100	0.9999	0	2204.338	125.8	-202.2dB
asrc	176400	44100	0.9999	1	8967.323-18000.810	134.0	NA
xsim-asrc	176400	44100	0.9999	1	8967.323-18000.810	129.0	NA
asrc	192000	44100	0.9999	0	2204.562	123.0	-196.2dB
xsim-asrc	192000	44100	0.9999	0	2204.562	121.9	-200.3dB
asrc	192000	44100	0.9999	1	1402.166-18001.221	128.6	NA
xsim-asrc	192000	44100	0.9999	1	1402.166-18001.221	126.3	NA
asrc	44100	48000	0.9999	0	2398.672	124.9	-189.8dB
xsim-asrc	44100	48000	0.9999	0	2398.672	124.6	-190.4dB
asrc	44100	48000	0.9999	1	7295.308-17997.881	132.6	NA
xsim-asrc	44100	48000	0.9999	1	7295.308-17997.881	131.9	NA
asrc	48000	48000	0.9999	0	2395.679	130.4	-197.2dB
xsim-asrc	48000	48000	0.9999	0	2395.679	129.4	-196.4dB
asrc	48000	48000	0.9999	1	2136.427-21801.160	135.1	NA
xsim-asrc	48000	48000	0.9999	1	2136.427-21801.160	133.0	NA
asrc	88200	48000	0.9999	0	2398.542	123.6	-197.9dB
xsim-asrc	88200	48000	0.9999	0	2398.542	123.1	-198.4dB
asrc	88200	48000	0.9999	1	397.144-21801.124	129.2	NA
xsim-asrc	88200	48000	0.9999	1	397.144-21801.124	128.2	NA
asrc	96000	48000	0.9999	0	2398.080	129.5	-198.1dB
xsim-asrc	96000	48000	0.9999	0	2398.080	127.7	-201.4dB
asrc	96000	48000	0.9999	1	2136.427-21801.160	134.3	NA
xsim-asrc	96000	48000	0.9999	1	2136.427-21801.160	130.9	NA
asrc	176400	48000	0.9999	0	2399.848	122.9	-196.9dB
xsim-asrc	176400	48000	0.9999	0	2399.848	122.1	-200.7dB
asrc	176400	48000	0.9999	1	397.144-21801.124	127.6	NA
xsim-asrc	176400	48000	0.9999	1	397.144-21801.124	126.0	NA
asrc	192000	48000	0.9999	0	2399.280	128.2	-197.5dB
xsim-asrc	192000	48000	0.9999	0	2399.280	125.8	-202.2dB
asrc	192000	48000	0.9999	1	2136.427-21801.160	132.7	NA
xsim-asrc	192000	48000	0.9999	1	2136.427-21801.160	128.4	NA
asrc	44100	88200	0.9999	0	4393.678	142.8	-197.1dB
xsim-asrc	44100	88200	0.9999	0	4393.678	140.1	-193.2dB
asrc	44100	88200	0.9999	1	8963.809-17998.199	145.2	NA
xsim-asrc	44100	88200	0.9999	1	8963.809-17998.199	141.0	NA
asrc	48000	88200	0.9999	0	4409.630	126.7	-184.2dB
xsim-asrc	48000	88200	0.9999	0	4409.630	126.5	-185.5dB
asrc	48000	88200	0.9999	1	5187.801-21788.762	131.9	NA
xsim-asrc	48000	88200	0.9999	1	5187.801-21788.762	131.5	NA
asrc	88200	88200	0.9999	0	4402.060	130.4	-197.2dB
xsim-asrc	88200	88200	0.9999	0	4402.060	129.4	-196.4dB
asrc	88200	88200	0.9999	1	3863.933-39997.879	135.1	NA
xsim-asrc	88200	88200	0.9999	1	3863.933-39997.879	133.1	NA
asrc	96000	88200	0.9999	0	4409.225	125.1	-189.7dB
xsim-asrc	96000	88200	0.9999	0	4409.225	124.8	-187.9dB
asrc	96000	88200	0.9999	1	6800.257-39999.130	131.7	NA
xsim-asrc	96000	88200	0.9999	1	6800.257-39999.130	130.9	NA
asrc	176400	88200	0.9999	0	4406.471	129.5	-197.0dB
xsim-asrc	176400	88200	0.9999	0	4406.471	127.9	-202.1dB
asrc	176400	88200	0.9999	1	3868.344-40002.290	133.7	NA
xsim-asrc	176400	88200	0.9999	1	3868.344-40002.290	129.8	NA
asrc	192000	88200	0.9999	0	4409.225	124.2	-193.8dB
xsim-asrc	192000	88200	0.9999	0	4409.225	123.6	-193.8dB
asrc	192000	88200	0.9999	1	6804.310-40003.183	129.8	NA
xsim-asrc	192000	88200	0.9999	1	6804.310-40003.183	127.5	NA
asrc	44100	96000	0.9999	0	4786.893	128.8	-187.4dB
xsim-asrc	44100	96000	0.9999	0	4786.893	128.6	-187.0dB
asrc	44100	96000	0.9999	1	7295.308-17997.881	132.9	NA
xsim-asrc	44100	96000	0.9999	1	7295.308-17997.881	132.6	NA
asrc	48000	96000	0.9999	0	4782.235	142.8	-197.1dB
xsim-asrc	48000	96000	0.9999	0	4782.235	140.1	-193.2dB
asrc	48000	96000	0.9999	1	2131.840-21798.539	145.0	NA
xsim-asrc	48000	96000	0.9999	1	2131.840-21798.539	140.9	NA
asrc	88200	96000	0.9999	0	4797.345	124.9	-189.8dB
xsim-asrc	88200	96000	0.9999	0	4797.345	124.6	-190.4dB
asrc	88200	96000	0.9999	1	18593.629-39998.775	130.1	NA
xsim-asrc	88200	96000	0.9999	1	18593.629-39998.775	129.7	NA
asrc	96000	96000	0.9999	0	4791.358	130.4	-197.2dB
xsim-asrc	96000	96000	0.9999	0	4791.358	129.4	-196.4dB
asrc	96000	96000	0.9999	1	2669.334-41998.799	135.5	NA
xsim-asrc	96000	96000	0.9999	1	2669.334-41998.799	133.3	NA
asrc	176400	96000	0.9999	0	4797.083	124.4	-196.3dB
xsim-asrc	176400	96000	0.9999	0	4797.083	123.8	-197.7dB
asrc	176400	96000	0.9999	1	20599.241-42003.221	128.3	NA
xsim-asrc	176400	96000	0.9999	1	20599.241-42003.221	127.4	NA
asrc	192000	96000	0.9999	0	4796.159	129.5	-197.0dB
xsim-asrc	192000	96000	0.9999	0	4796.159	127.9	-202.1dB
asrc	192000	96000	0.9999	1	2674.135-42003.600	134.7	NA
xsim-asrc	192000	96000	0.9999	1	2674.135-42003.600	131.0	NA
asrc	44100	176400	0.9999	0	8753.817	140.4	-189.6dB
xsim-asrc	44100	176400	0.9999	0	8753.817	139.1	-189.3dB
asrc	44100	176400	0.9999	1	8965.602-18001.800	142.7	NA
xsim-asrc	44100	176400	0.9999	1	8965.602-18001.800	140.7	NA
asrc	48000	176400	0.9999	0	8820.882	127.6	-180.5dB
xsim-asrc	48000	176400	0.9999	0	8820.882	127.4	-180.3dB
asrc	48000	176400	0.9999	1	5188.754-21792.768	133.7	NA
xsim-asrc	48000	176400	0.9999	1	5188.754-21792.768	133.4	NA
asrc	88200	176400	0.9999	0	8787.356	142.8	-197.1dB
xsim-asrc	88200	176400	0.9999	0	8787.356	140.1	-193.2dB
asrc	88200	176400	0.9999	1	3846.674-39984.234	145.4	NA
xsim-asrc	88200	176400	0.9999	1	3846.674-39984.234	140.9	NA
asrc	96000	176400	0.9999	0	8819.261	126.7	-184.2dB
xsim-asrc	96000	176400	0.9999	0	8819.261	126.5	-185.5dB
asrc	96000	176400	0.9999	1	8786.837-41988.761	133.0	NA
xsim-asrc	96000	176400	0.9999	1	8786.837-41988.761	132.4	NA
asrc	176400	176400	0.9999	0	8804.121	130.4	-197.7dB
xsim-asrc	176400	176400	0.9999	0	8804.121	129.4	-193.2dB
asrc	176400	176400	0.9999	1	7727.865-79995.758	134.1	NA
xsim-asrc	176400	176400	0.9999	1	7727.865-79995.758	131.8	NA
asrc	192000	176400	0.9999	0	8818.451	125.4	-187.8dB
xsim-asrc	192000	176400	0.9999	0	8818.451	125.0	-187.4dB
asrc	192000	176400	0.9999	1	13600.515-79998.260	130.5	NA
xsim-asrc	192000	176400	0.9999	1	13600.515-79998.260	129.4	NA
asrc	44100	192000	0.9999	0	9534.054	127.5	-179.5dB
xsim-asrc	44100	192000	0.9999	0	9534.054	127.4	-180.1dB
asrc	44100	192000	0.9999	1	7275.989-17980.892	134.7	NA
xsim-asrc	44100	192000	0.9999	1	7275.989-17980.892	134.4	NA
asrc	48000	192000	0.9999	0	9527.964	140.4	-189.6dB
xsim-asrc	48000	192000	0.9999	0	9527.964	139.1	-189.3dB
asrc	48000	192000	0.9999	1	2074.637-21745.272	134.3	NA
xsim-asrc	48000	192000	0.9999	1	2074.637-21745.272	133.6	NA
asrc	88200	192000	0.9999	0	9573.786	128.8	-187.4dB
xsim-asrc	88200	192000	0.9999	0	9573.786	128.6	-187.0dB
asrc	88200	192000	0.9999	1	18562.274-39967.419	131.3	NA
xsim-asrc	88200	192000	0.9999	1	18562.274-39967.419	131.1	NA
asrc	96000	192000	0.9999	0	9564.469	142.8	-197.1dB
xsim-asrc	96000	192000	0.9999	0	9564.469	140.1	-193.2dB
asrc	96000	192000	0.9999	1	2650.395-41983.794	134.1	NA
xsim-asrc	96000	192000	0.9999	1	2650.395-41983.794	133.0	NA
asrc	176400	192000	0.9999	0	9594.689	125.1	-190.0dB
xsim-asrc	176400	192000	0.9999	0	9594.689	124.8	-187.0dB
asrc	176400	192000	0.9999	1	37187.259-79997.549	130.3	NA
xsim-asrc	176400	192000	0.9999	1	37187.259-79997.549	129.6	NA
asrc	192000	192000	0.9999	0	9582.716	130.4	-197.7dB
xsim-asrc	192000	192000	0.9999	0	9582.716	129.4	-193.2dB
asrc	192000	192000	0.9999	1	6337.267-84996.198	134.8	NA
xsim-asrc	192000	192000	0.9999	1	6337.267-84996.198	132.7	NA
ds3	48000	16000	1.0	0	800.000	182.3	-195.0dB
ds3	48000	16000	1.0	1	2930.667-7299.733	146.5	NA
ds3	96000	32000	1.0	0	1600.000	182.3	-195.0dB
ds3	96000	32000	1.0	1	5861.333-14599.467	146.5	NA
asrc	44100	44100	1.0	0	2205.000	175.8	-188.7dB
ssrc	44100	44100	1.0	0	2205.000	189.5	-193.1dB
xsim-asrc	44100	44100	1.0	0	2205.000	164.9	-177.0dB
asrc	44100	44100	1.0	1	8965.530-17997.210	154.9	NA
ssrc	44100	44100	1.0	1	8965.530-17997.210	158.7	NA
xsim-asrc	44100	44100	1.0	1	8965.530-17997.210	141.8	NA
asrc	48000	44100	1.0	0	2204.190	125.7	-196.6dB
ssrc	48000	44100	1.0	0	2204.190	107.9	-176.9dB
xsim-asrc	48000	44100	1.0	0	2204.190	125.2	-194.8dB
asrc	48000	44100	1.0	1	1401.929-17998.181	131.1	NA
ssrc	48000	44100	1.0	1	1401.929-17998.181	112.8	NA
xsim-asrc	48000	44100	1.0	1	1401.929-17998.181	130.4	NA
asrc	88200	44100	1.0	0	2205.000	177.8	-195.5dB
ssrc	88200	44100	1.0	0	2205.000	181.0	-193.3dB
xsim-asrc	88200	44100	1.0	0	2205.000	164.4	-177.2dB
asrc	88200	44100	1.0	1	8967.735-17999.415	153.3	NA
ssrc	88200	44100	1.0	1	8967.735-17999.415	154.6	NA
xsim-asrc	88200	44100	1.0	1	8967.735-17999.415	137.2	NA
asrc	96000	44100	1.0	0	2204.190	124.6	-194.9dB
ssrc	96000	44100	1.0	0	2204.190	106.9	-180.2dB
xsim-asrc	96000	44100	1.0	0	2204.190	123.8	-198.1dB
asrc	96000	44100	1.0	1	1401.929-17998.181	130.2	NA
ssrc	96000	44100	1.0	1	1401.929-17998.181	111.4	NA
xsim-asrc	96000	44100	1.0	1	1401.929-17998.181	128.7	NA
asrc	176400	44100	1.0	0	2205.000	174.9	-194.2dB
ssrc	176400	44100	1.0	0	2205.000	176.3	-190.4dB
xsim-asrc	176400	44100	1.0	0	2205.000	162.3	-176.8dB
asrc	176400	44100	1.0	1	8967.735-17999.415	149.8	NA
ssrc	176400	44100	1.0	1	8967.735-17999.415	151.1	NA
xsim-asrc	176400	44100	1.0	1	8967.735-17999.415	136.0	NA
asrc	192000	44100	1.0	0	2204.139	123.6	-196.9dB
ssrc	192000	44100	1.0	0	2204.139	106.0	-185.4dB
xsim-asrc	192000	44100	1.0	0	2204.139	122.3	-200.1dB
asrc	192000	44100	1.0	1	1403.923-17999.793	128.9	NA
ssrc	192000	44100	1.0	1	1403.923-17999.793	110.4	NA
xsim-asrc	192000	44100	1.0	1	1403.923-17999.793	126.5	NA
os3	16000	48000	1.0	0	2390.639	126.7	-202.5dB
os3	16000	48000	1.0	1	3600.360-7287.129	124.1	NA
asrc	44100	48000	1.0	0	2398.171	127.5	-172.0dB
ssrc	44100	48000	1.0	0	2398.171	106.1	-151.6dB
xsim-asrc	44100	48000	1.0	0	2398.171	126.8	-171.3dB
asrc	44100	48000	1.0	1	7299.009-17999.347	132.7	NA
ssrc	44100	48000	1.0	1	7299.009-17999.347	110.2	NA
xsim-asrc	44100	48000	1.0	1	7299.009-17999.347	131.9	NA
asrc	48000	48000	1.0	0	2400.000	175.8	-188.7dB
ssrc	48000	48000	1.0	0	2400.000	189.5	-193.1dB
xsim-asrc	48000	48000	1.0	0	2400.000	164.9	-177.0dB
asrc	48000	48000	1.0	1	2136.000-21796.800	155.3	NA
ssrc	48000	48000	1.0	1	2136.000-21796.800	158.9	NA
xsim-asrc	48000	48000	1.0	1	2136.000-21796.800	141.8	NA
asrc	88200	48000	1.0	0	2398.041	125.4	-176.8dB
ssrc	88200	48000	1.0	0	2398.041	103.9	-159.0dB
xsim-asrc	88200	48000	1.0	0	2398.041	124.6	-176.6dB
asrc	88200	48000	1.0	1	399.673-21799.184	129.8	NA
ssrc	88200	48000	1.0	1	399.673-21799.184	110.2	NA
xsim-asrc	88200	48000	1.0	1	399.673-21799.184	128.5	NA
asrc	96000	48000	1.0	0	2400.000	177.8	-195.5dB
ssrc	96000	48000	1.0	0	2400.000	181.0	-193.3dB
xsim-asrc	96000	48000	1.0	0	2400.000	164.4	-177.2dB
asrc	96000	48000	1.0	1	2138.400-21799.200	153.1	NA
ssrc	96000	48000	1.0	1	2138.400-21799.200	154.6	NA
xsim-asrc	96000	48000	1.0	1	2138.400-21799.200	137.2	NA
asrc	176400	48000	1.0	0	2399.347	125.8	-174.6dB
ssrc	176400	48000	1.0	0	2399.347	102.5	-151.0dB
xsim-asrc	176400	48000	1.0	0	2399.347	124.0	-174.3dB
asrc	176400	48000	1.0	1	399.673-21799.184	128.3	NA
ssrc	176400	48000	1.0	1	399.673-21799.184	109.3	NA
xsim-asrc	176400	48000	1.0	1	399.673-21799.184	126.2	NA
asrc	192000	48000	1.0	0	2400.000	174.9	-194.2dB
ssrc	192000	48000	1.0	0	2400.000	176.3	-190.4dB
xsim-asrc	192000	48000	1.0	0	2400.000	162.3	-176.8dB
asrc	192000	48000	1.0	1	2138.400-21799.200	149.8	NA
ssrc	192000	48000	1.0	1	2138.400-21799.200	151.2	NA
xsim-asrc	192000	48000	1.0	1	2138.400-21799.200	136.0	NA
asrc	44100	88200	1.0	0	4410.000	166.7	-169.5dB
ssrc	44100	88200	1.0	0	4410.000	156.0	-156.5dB
xsim-asrc	44100	88200	1.0	0	4410.000	161.9	-167.8dB
asrc	44100	88200	1.0	1	8961.120-17992.800	155.1	NA
ssrc	44100	88200	1.0	1	8961.120-17992.800	155.4	NA
xsim-asrc	44100	88200	1.0	1	8961.120-17992.800	146.3	NA
asrc	48000	88200	1.0	0	4408.379	127.2	-183.8dB
ssrc	48000	88200	1.0	0	4408.379	108.7	-168.3dB
xsim-asrc	48000	88200	1.0	0	4408.379	126.8	-184.0dB
asrc	48000	88200	1.0	1	5202.536-21798.787	131.8	NA
ssrc	48000	88200	1.0	1	5202.536-21798.787	115.1	NA
xsim-asrc	48000	88200	1.0	1	5202.536-21798.787	131.4	NA
asrc	88200	88200	1.0	0	4410.000	175.8	-188.7dB
ssrc	88200	88200	1.0	0	4410.000	189.5	-193.1dB
xsim-asrc	88200	88200	1.0	0	4410.000	164.9	-177.0dB
asrc	88200	88200	1.0	1	3871.980-39998.700	155.1	NA
ssrc	88200	88200	1.0	1	3871.980-39998.700	159.1	NA
xsim-asrc	88200	88200	1.0	1	3871.980-39998.700	141.7	NA
asrc	96000	88200	1.0	0	4408.379	125.7	-196.6dB
ssrc	96000	88200	1.0	0	4408.379	107.9	-176.9dB
xsim-asrc	96000	88200	1.0	0	4408.379	125.2	-194.8dB
asrc	96000	88200	1.0	1	6807.056-39999.559	131.8	NA
ssrc	96000	88200	1.0	1	6807.056-39999.559	113.2	NA
xsim-asrc	96000	88200	1.0	1	6807.056-39999.559	131.0	NA
asrc	176400	88200	1.0	0	4410.000	176.1	-189.7dB
ssrc	176400	88200	1.0	0	4410.000	181.0	-193.3dB
xsim-asrc	176400	88200	1.0	0	4410.000	164.6	-174.8dB
asrc	176400	88200	1.0	1	3871.980-39998.700	151.0	NA
ssrc	176400	88200	1.0	1	3871.980-39998.700	154.7	NA
xsim-asrc	176400	88200	1.0	1	3871.980-39998.700	137.6	NA
asrc	192000	88200	1.0	0	4408.379	124.6	-198.1dB
ssrc	192000	88200	1.0	0	4408.379	107.1	-181.9dB
xsim-asrc	192000	88200	1.0	0	4408.379	123.8	-194.5dB
asrc	192000	88200	1.0	1	6807.056-39999.559	130.0	NA
ssrc	192000	88200	1.0	1	6807.056-39999.559	111.5	NA
xsim-asrc	192000	88200	1.0	1	6807.056-39999.559	127.5	NA
os3	32000	96000	1.0	0	4781.278	126.7	-202.5dB
os3	32000	96000	1.0	1	7200.720-14574.257	124.1	NA
asrc	44100	96000	1.0	0	4786.414	130.7	-190.4dB
ssrc	44100	96000	1.0	0	4786.414	108.3	-163.7dB
xsim-asrc	44100	96000	1.0	0	4786.414	130.1	-188.7dB
asrc	44100	96000	1.0	1	7294.579-17996.081	133.5	NA
ssrc	44100	96000	1.0	1	7294.579-17996.081	111.7	NA
xsim-asrc	44100	96000	1.0	1	7294.579-17996.081	133.0	NA
asrc	48000	96000	1.0	0	4800.000	166.7	-169.5dB
ssrc	48000	96000	1.0	0	4800.000	156.0	-156.5dB
xsim-asrc	48000	96000	1.0	0	4800.000	161.9	-167.8dB
asrc	48000	96000	1.0	1	2131.200-21792.000	154.4	NA
ssrc	48000	96000	1.0	1	2131.200-21792.000	154.9	NA
xsim-asrc	48000	96000	1.0	1	2131.200-21792.000	144.0	NA
asrc	88200	96000	1.0	0	4796.343	127.5	-172.0dB
ssrc	88200	96000	1.0	0	4796.343	106.1	-151.6dB
xsim-asrc	88200	96000	1.0	0	4796.343	126.8	-171.3dB
asrc	88200	96000	1.0	1	18589.746-39990.421	129.3	NA
ssrc	88200	96000	1.0	1	18589.746-39990.421	108.6	NA
xsim-asrc	88200	96000	1.0	1	18589.746-39990.421	128.9	NA
asrc	96000	96000	1.0	0	4800.000	175.8	-188.7dB
ssrc	96000	96000	1.0	0	4800.000	189.5	-193.1dB
xsim-asrc	96000	96000	1.0	0	4800.000	164.9	-177.0dB
asrc	96000	96000	1.0	1	2678.400-42000.000	155.2	NA
ssrc	96000	96000	1.0	1	2678.400-42000.000	158.8	NA
xsim-asrc	96000	96000	1.0	1	2678.400-42000.000	141.9	NA
asrc	176400	96000	1.0	0	4796.082	125.0	-177.1dB
ssrc	176400	96000	1.0	0	4796.082	104.6	-156.9dB
xsim-asrc	176400	96000	1.0	0	4796.082	124.3	-177.3dB
asrc	176400	96000	1.0	1	20600.163-41999.673	128.4	NA
ssrc	176400	96000	1.0	1	20600.163-41999.673	108.8	NA
xsim-asrc	176400	96000	1.0	1	20600.163-41999.673	127.4	NA
asrc	192000	96000	1.0	0	4800.000	176.1	-189.7dB
ssrc	192000	96000	1.0	0	4800.000	181.0	-193.3dB
xsim-asrc	192000	96000	1.0	0	4800.000	164.6	-174.8dB
asrc	192000	96000	1.0	1	2678.400-42000.000	152.6	NA
ssrc	192000	96000	1.0	1	2678.400-42000.000	154.7	NA
xsim-asrc	192000	96000	1.0	1	2678.400-42000.000	139.4	NA
asrc	44100	176400	1.0	0	8820.000	165.3	-169.5dB
ssrc	44100	176400	1.0	0	8820.000	163.6	-166.5dB
xsim-asrc	44100	176400	1.0	0	8820.000	161.3	-168.6dB
asrc	44100	176400	1.0	1	8961.120-17992.800	154.3	NA
ssrc	44100	176400	1.0	1	8961.120-17992.800	152.1	NA
xsim-asrc	44100	176400	1.0	1	8961.120-17992.800	146.1	NA
asrc	48000	176400	1.0	0	8816.759	127.6	-182.1dB
ssrc	48000	176400	1.0	0	8816.759	110.0	-163.9dB
xsim-asrc	48000	176400	1.0	0	8816.759	127.4	-181.7dB
asrc	48000	176400	1.0	1	5186.329-21782.580	133.7	NA
ssrc	48000	176400	1.0	1	5186.329-21782.580	115.8	NA
xsim-asrc	48000	176400	1.0	1	5186.329-21782.580	133.4	NA
asrc	88200	176400	1.0	0	8820.000	166.7	-169.5dB
ssrc	88200	176400	1.0	0	8820.000	156.0	-156.5dB
xsim-asrc	88200	176400	1.0	0	8820.000	161.9	-167.8dB
asrc	88200	176400	1.0	1	3845.520-39972.240	154.4	NA
ssrc	88200	176400	1.0	1	3845.520-39972.240	154.9	NA
xsim-asrc	88200	176400	1.0	1	3845.520-39972.240	144.0	NA
asrc	96000	176400	1.0	0	8816.759	127.2	-183.8dB
ssrc	96000	176400	1.0	0	8816.759	108.7	-168.3dB
xsim-asrc	96000	176400	1.0	0	8816.759	126.8	-184.0dB
asrc	96000	176400	1.0	1	8784.344-41976.847	133.8	NA
ssrc	96000	176400	1.0	1	8784.344-41976.847	114.6	NA
xsim-asrc	96000	176400	1.0	1	8784.344-41976.847	133.1	NA
asrc	176400	176400	1.0	0	8820.000	176.1	-189.0dB
ssrc	176400	176400	1.0	0	8820.000	189.5	-193.1dB
xsim-asrc	176400	176400	1.0	0	8820.000	170.2	-181.8dB
asrc	176400	176400	1.0	1	7743.960-79997.400	153.1	NA
ssrc	176400	176400	1.0	1	7743.960-79997.400	159.1	NA
xsim-asrc	176400	176400	1.0	1	7743.960-79997.400	139.9	NA
asrc	192000	176400	1.0	0	8816.759	125.6	-195.7dB
ssrc	192000	176400	1.0	0	8816.759	107.8	-180.8dB
xsim-asrc	192000	176400	1.0	0	8816.759	125.1	-192.7dB
asrc	192000	176400	1.0	1	13614.112-79999.118	130.6	NA
ssrc	192000	176400	1.0	1	13614.112-79999.118	112.7	NA
xsim-asrc	192000	176400	1.0	1	13614.112-79999.118	129.4	NA
asrc	44100	192000	1.0	0	9533.101	127.6	-181.9dB
ssrc	44100	192000	1.0	0	9533.101	107.6	-166.0dB
xsim-asrc	44100	192000	1.0	0	9533.101	127.4	-181.2dB
asrc	44100	192000	1.0	1	7275.261-17979.094	134.7	NA
ssrc	44100	192000	1.0	1	7275.261-17979.094	111.3	NA
xsim-asrc	44100	192000	1.0	1	7275.261-17979.094	134.3	NA
asrc	48000	192000	1.0	0	9600.000	165.3	-169.5dB
ssrc	48000	192000	1.0	0	9600.000	163.6	-166.5dB
xsim-asrc	48000	192000	1.0	0	9600.000	161.3	-168.6dB
asrc	48000	192000	1.0	1	2073.600-21734.400	153.7	NA
ssrc	48000	192000	1.0	1	2073.600-21734.400	152.5	NA
xsim-asrc	48000	192000	1.0	1	2073.600-21734.400	146.0	NA
asrc	88200	192000	1.0	0	9572.828	130.7	-190.4dB
ssrc	88200	192000	1.0	0	9572.828	108.3	-163.7dB
xsim-asrc	88200	192000	1.0	0	9572.828	130.1	-188.7dB
asrc	88200	192000	1.0	1	18560.418-39963.423	131.5	NA
ssrc	88200	192000	1.0	1	18560.418-39963.423	109.2	NA
xsim-asrc	88200	192000	1.0	1	18560.418-39963.423	131.3	NA
asrc	96000	192000	1.0	0	9600.000	166.7	-169.5dB
ssrc	96000	192000	1.0	0	9600.000	156.0	-156.5dB
xsim-asrc	96000	192000	1.0	0	9600.000	161.9	-167.8dB
asrc	96000	192000	1.0	1	2649.600-41971.200	154.3	NA
ssrc	96000	192000	1.0	1	2649.600-41971.200	155.0	NA
xsim-asrc	96000	192000	1.0	1	2649.600-41971.200	143.9	NA
asrc	176400	192000	1.0	0	9592.685	126.1	-170.2dB
ssrc	176400	192000	1.0	0	9592.685	105.5	-151.0dB
xsim-asrc	176400	192000	1.0	0	9592.685	125.8	-169.8dB
asrc	176400	192000	1.0	1	37179.493-79980.842	129.2	NA
ssrc	176400	192000	1.0	1	37179.493-79980.842	108.6	NA
xsim-asrc	176400	192000	1.0	1	37179.493-79980.842	128.6	NA
asrc	192000	192000	1.0	0	9600.000	176.1	-189.0dB
ssrc	192000	192000	1.0	0	9600.000	189.5	-193.1dB
xsim-asrc	192000	192000	1.0	0	9600.000	170.2	-181.8dB
asrc	192000	192000	1.0	1	6355.200-84998.400	154.2	NA
ssrc	192000	192000	1.0	1	6355.200-84998.400	158.8	NA
xsim-asrc	192000	192000	1.0	1	6355.200-84998.400	141.2	NA
asrc	44100	44100	1.0001	0	2204.780	130.4	-197.3dB
xsim-asrc	44100	44100	1.0001	0	2204.780	129.3	-195.1dB
asrc	44100	44100	1.0001	1	8964.634-17995.410	136.6	NA
xsim-asrc	44100	44100	1.0001	1	8964.634-17995.410	134.1	NA
asrc	48000	44100	1.0001	0	2203.767	125.2	-176.9dB
xsim-asrc	48000	44100	1.0001	0	2203.767	124.9	-177.1dB
asrc	48000	44100	1.0001	1	1401.660-17994.728	132.4	NA
xsim-asrc	48000	44100	1.0001	1	1401.660-17994.728	131.4	NA
asrc	88200	44100	1.0001	0	2204.669	129.6	-197.6dB
xsim-asrc	88200	44100	1.0001	0	2204.669	127.7	-202.2dB
asrc	88200	44100	1.0001	1	8966.390-17996.715	134.9	NA
xsim-asrc	88200	44100	1.0001	1	8966.390-17996.715	131.3	NA
asrc	96000	44100	1.0001	0	2203.767	124.0	-178.6dB
xsim-asrc	96000	44100	1.0001	0	2203.767	123.4	-179.0dB
asrc	96000	44100	1.0001	1	1403.686-17996.753	130.4	NA
xsim-asrc	96000	44100	1.0001	1	1403.686-17996.753	128.7	NA
asrc	176400	44100	1.0001	0	2204.614	128.1	-197.8dB
xsim-asrc	176400	44100	1.0001	0	2204.614	125.8	-202.3dB
asrc	176400	44100	1.0001	1	8967.268-17997.368	132.3	NA
xsim-asrc	176400	44100	1.0001	1	8967.268-17997.368	128.1	NA
asrc	192000	44100	1.0001	0	2204.729	123.0	-194.4dB
xsim-asrc	192000	44100	1.0001	0	2204.729	121.9	-195.6dB
asrc	192000	44100	1.0001	1	1404.666-17997.353	128.7	NA
xsim-asrc	192000	44100	1.0001	1	1404.666-17997.353	126.4	NA
asrc	44100	48000	1.0001	0	2397.671	124.9	-180.3dB
xsim-asrc	44100	48000	1.0001	0	2397.671	124.7	-181.2dB
asrc	44100	48000	1.0001	1	7297.485-17995.588	133.6	NA
xsim-asrc	44100	48000	1.0001	1	7297.485-17995.588	132.6	NA
asrc	48000	48000	1.0001	0	2399.520	130.4	-197.0dB
xsim-asrc	48000	48000	1.0001	0	2399.520	129.3	-195.2dB
asrc	48000	48000	1.0001	1	2140.372-21797.240	135.7	NA
xsim-asrc	48000	48000	1.0001	1	2140.372-21797.240	133.5	NA
asrc	88200	48000	1.0001	0	2397.671	123.8	-180.8dB
xsim-asrc	88200	48000	1.0001	0	2397.671	123.3	-181.3dB
asrc	88200	48000	1.0001	1	399.612-21795.818	130.2	NA
xsim-asrc	88200	48000	1.0001	1	399.612-21795.818	128.9	NA
asrc	96000	48000	1.0001	0	2399.520	129.5	-197.3dB
xsim-asrc	96000	48000	1.0001	0	2399.520	127.7	-201.6dB
asrc	96000	48000	1.0001	1	2140.372-21797.240	134.2	NA
xsim-asrc	96000	48000	1.0001	1	2140.372-21797.240	130.8	NA
asrc	176400	48000	1.0001	0	2398.911	122.6	-196.5dB
xsim-asrc	176400	48000	1.0001	0	2398.911	121.8	-198.6dB
asrc	176400	48000	1.0001	1	400.907-21796.531	129.2	NA
xsim-asrc	176400	48000	1.0001	1	400.907-21796.531	126.9	NA
asrc	192000	48000	1.0001	0	2399.520	128.0	-197.5dB
xsim-asrc	192000	48000	1.0001	0	2399.520	125.7	-203.7dB
asrc	192000	48000	1.0001	1	2140.372-21797.240	131.5	NA
xsim-asrc	192000	48000	1.0001	1	2140.372-21797.240	127.7	NA
asrc	44100	88200	1.0001	0	4409.559	132.2	-170.4dB
xsim-asrc	44100	88200	1.0001	0	4409.559	131.6	-170.9dB
asrc	44100	88200	1.0001	1	8960.224-17991.001	137.7	NA
xsim-asrc	44100	88200	1.0001	1	8960.224-17991.001	136.2	NA
asrc	48000	88200	1.0001	0	4407.938	127.2	-189.5dB
xsim-asrc	48000	88200	1.0001	0	4407.938	126.9	-189.7dB
asrc	48000	88200	1.0001	1	5202.016-21796.608	132.4	NA
xsim-asrc	48000	88200	1.0001	1	5202.016-21796.608	132.0	NA
asrc	88200	88200	1.0001	0	4409.559	130.4	-197.3dB
xsim-asrc	88200	88200	1.0001	0	4409.559	129.3	-195.1dB
asrc	88200	88200	1.0001	1	3871.593-39994.701	135.6	NA
xsim-asrc	88200	88200	1.0001	1	3871.593-39994.701	133.5	NA
asrc	96000	88200	1.0001	0	4407.534	125.2	-176.9dB
xsim-asrc	96000	88200	1.0001	0	4407.534	124.9	-177.1dB
asrc	96000	88200	1.0001	1	6805.750-39991.885	132.3	NA
xsim-asrc	96000	88200	1.0001	1	6805.750-39991.885	131.4	NA
asrc	176400	88200	1.0001	0	4409.339	129.5	-198.4dB
xsim-asrc	176400	88200	1.0001	0	4409.339	127.9	-203.5dB
asrc	176400	88200	1.0001	1	3871.399-39992.701	133.3	NA
xsim-asrc	176400	88200	1.0001	1	3871.399-39992.701	129.6	NA
asrc	192000	88200	1.0001	0	4407.534	124.2	-178.1dB
xsim-asrc	192000	88200	1.0001	0	4407.534	123.6	-177.7dB
asrc	192000	88200	1.0001	1	6809.801-39995.936	131.0	NA
xsim-asrc	192000	88200	1.0001	1	6809.801-39995.936	128.0	NA
asrc	44100	96000	1.0001	0	4784.894	129.0	-184.8dB
xsim-asrc	44100	96000	1.0001	0	4784.894	128.6	-184.7dB
asrc	44100	96000	1.0001	1	7292.262-17990.365	133.5	NA
xsim-asrc	44100	96000	1.0001	1	7292.262-17990.365	132.9	NA
asrc	48000	96000	1.0001	0	4799.520	132.2	-170.4dB
xsim-asrc	48000	96000	1.0001	0	4799.520	131.6	-170.9dB
asrc	48000	96000	1.0001	1	2130.987-21789.821	135.4	NA
xsim-asrc	48000	96000	1.0001	1	2130.987-21789.821	134.0	NA
asrc	88200	96000	1.0001	0	4795.341	124.9	-180.3dB
xsim-asrc	88200	96000	1.0001	0	4795.341	124.7	-181.2dB
asrc	88200	96000	1.0001	1	18596.312-39992.518	131.0	NA
xsim-asrc	88200	96000	1.0001	1	18596.312-39992.518	130.4	NA
asrc	96000	96000	1.0001	0	4799.040	130.4	-197.0dB
xsim-asrc	96000	96000	1.0001	0	4799.040	129.3	-195.2dB
asrc	96000	96000	1.0001	1	2677.864-41991.601	136.2	NA
xsim-asrc	96000	96000	1.0001	1	2677.864-41991.601	133.9	NA
asrc	176400	96000	1.0001	0	4795.341	123.7	-181.1dB
xsim-asrc	176400	96000	1.0001	0	4795.341	123.3	-181.5dB
asrc	176400	96000	1.0001	1	20596.983-41993.189	128.3	NA
xsim-asrc	176400	96000	1.0001	1	20596.983-41993.189	127.4	NA
asrc	192000	96000	1.0001	0	4799.040	129.5	-197.7dB
xsim-asrc	192000	96000	1.0001	0	4799.040	127.8	-202.9dB
asrc	192000	96000	1.0001	1	2677.864-41991.601	134.2	NA
xsim-asrc	192000	96000	1.0001	1	2677.864-41991.601	130.7	NA
asrc	44100	176400	1.0001	0	8819.118	130.7	-165.8dB
xsim-asrc	44100	176400	1.0001	0	8819.118	130.2	-165.8dB
asrc	44100	176400	1.0001	1	8960.224-17991.001	136.3	NA
xsim-asrc	44100	176400	1.0001	1	8960.224-17991.001	135.3	NA
asrc	48000	176400	1.0001	0	8815.877	127.5	-188.7dB
xsim-asrc	48000	176400	1.0001	0	8815.877	127.4	-187.2dB
asrc	48000	176400	1.0001	1	5185.810-21780.402	134.2	NA
xsim-asrc	48000	176400	1.0001	1	5185.810-21780.402	133.9	NA
asrc	88200	176400	1.0001	0	8819.118	132.2	-170.4dB
xsim-asrc	88200	176400	1.0001	0	8819.118	131.6	-170.9dB
asrc	88200	176400	1.0001	1	3845.135-39968.243	135.4	NA
xsim-asrc	88200	176400	1.0001	1	3845.135-39968.243	134.0	NA
asrc	96000	176400	1.0001	0	8815.877	127.2	-189.5dB
xsim-asrc	96000	176400	1.0001	0	8815.877	126.9	-189.7dB
asrc	96000	176400	1.0001	1	8783.466-41972.649	134.3	NA
xsim-asrc	96000	176400	1.0001	1	8783.466-41972.649	133.5	NA
asrc	176400	176400	1.0001	0	8819.118	130.4	-198.5dB
xsim-asrc	176400	176400	1.0001	0	8819.118	129.4	-195.1dB
asrc	176400	176400	1.0001	1	7743.186-79989.401	134.3	NA
xsim-asrc	176400	176400	1.0001	1	7743.186-79989.401	132.0	NA
asrc	192000	176400	1.0001	0	8815.067	125.0	-176.7dB
xsim-asrc	192000	176400	1.0001	0	8815.067	124.7	-176.5dB
asrc	192000	176400	1.0001	1	13611.501-79983.770	131.2	NA
xsim-asrc	192000	176400	1.0001	1	13611.501-79983.770	129.9	NA
asrc	44100	192000	1.0001	0	9527.998	127.5	-180.3dB
xsim-asrc	44100	192000	1.0001	0	9527.998	127.4	-179.6dB
asrc	44100	192000	1.0001	1	7271.367-17969.470	134.9	NA
xsim-asrc	44100	192000	1.0001	1	7271.367-17969.470	134.5	NA
asrc	48000	192000	1.0001	0	9599.040	130.7	-165.8dB
xsim-asrc	48000	192000	1.0001	0	9599.040	130.2	-165.8dB
asrc	48000	192000	1.0001	1	2073.393-21732.227	136.2	NA
xsim-asrc	48000	192000	1.0001	1	2073.393-21732.227	135.1	NA
asrc	88200	192000	1.0001	0	9569.787	129.0	-184.8dB
xsim-asrc	88200	192000	1.0001	0	9569.787	128.6	-184.7dB
asrc	88200	192000	1.0001	1	18596.312-39992.518	132.0	NA
xsim-asrc	88200	192000	1.0001	1	18596.312-39992.518	131.6	NA
asrc	96000	192000	1.0001	0	9599.040	132.2	-170.4dB
xsim-asrc	96000	192000	1.0001	0	9599.040	131.6	-170.9dB
asrc	96000	192000	1.0001	1	2649.335-41967.003	142.2	NA
xsim-asrc	96000	192000	1.0001	1	2649.335-41967.003	139.4	NA
asrc	176400	192000	1.0001	0	9590.682	124.8	-180.8dB
xsim-asrc	176400	192000	1.0001	0	9590.682	124.6	-180.8dB
asrc	176400	192000	1.0001	1	37192.624-79985.036	129.9	NA
xsim-asrc	176400	192000	1.0001	1	37192.624-79985.036	129.2	NA
asrc	192000	192000	1.0001	0	9598.080	130.3	-197.9dB
xsim-asrc	192000	192000	1.0001	0	9598.080	129.4	-194.9dB
asrc	192000	192000	1.0001	1	6353.929-84981.403	135.0	NA
xsim-asrc	192000	192000	1.0001	1	6353.929-84981.403	132.9	NA

lib_src: Sample rate conversion£££doc/rst/lib_src.html#lib-src-sample-rate-conversion

lib_src: Sample rate conversion$$$Introduction£££doc/rst/introduction.html#introduction

lib_src: Sample rate conversion$$$Introduction$$$lib_src components£££doc/rst/introduction.html#lib-src-components

lib_src: Sample rate conversion$$$Introduction$$$Using lib_src£££doc/rst/introduction.html#using-lib-src

lib_src: Sample rate conversion$$$HiFi quality multi-rate SRC£££doc/rst/multi_rate_hifi_src.html#hifi-quality-multi-rate-src

lib_src: Sample rate conversion$$$HiFi quality multi-rate SRC$$$Initialisation£££doc/rst/multi_rate_hifi_src.html#initialisation

lib_src: Sample rate conversion$$$HiFi quality multi-rate SRC$$$Processing£££doc/rst/multi_rate_hifi_src.html#processing

lib_src: Sample rate conversion$$$HiFi quality multi-rate SRC$$$Buffer formats£££fig-src-proc.html#buffer-formats

lib_src: Sample rate conversion$$$HiFi quality multi-rate SRC$$$Performance and resource utilisation£££fig-4-di.html#performance-and-resource-utilisation

lib_src: Sample rate conversion$$$HiFi quality multi-rate SRC$$$Performance and resource utilisation$$$Audio performance£££fig-4-di.html#audio-performance

lib_src: Sample rate conversion$$$HiFi quality multi-rate SRC$$$Performance and resource utilisation$$$SSRC resource utilisation£££fig-4-di.html#ssrc-resource-utilisation

lib_src: Sample rate conversion$$$HiFi quality multi-rate SRC$$$Performance and resource utilisation$$$ASRC performance£££fig-ssrc-mhz.html#asrc-performance

lib_src: Sample rate conversion$$$HiFi quality multi-rate SRC$$$Performance and resource utilisation$$$ASRC latency / group delay£££fig-ssrc-mhz.html#asrc-latency-group-delay

lib_src: Sample rate conversion$$$HiFi quality multi-rate SRC$$$Performance and resource utilisation$$$ASRC latency / group delay$$$ASRC resource utilisation£££fig-asrc-delay.html#asrc-resource-utilisation

lib_src: Sample rate conversion$$$Asynchronous FIFO$$$Implementation detail£££group__src__fifo__interp_1gac721c70a1e4b2d964da5d203af9ca2aa.html#implementation-detail

lib_src: Sample rate conversion$$$HiFi quality multi-rate SRC$$$Implementation detail$$$SSRC structure£££fig-asrc-mhz2.html#ssrc-structure

lib_src: Sample rate conversion$$$HiFi quality multi-rate SRC$$$Implementation detail$$$ASRC structure£££fig-ssrc-struct.html#asrc-structure

lib_src: Sample rate conversion$$$HiFi quality multi-rate SRC$$$Implementation detail$$$SRC filter list£££fig-asrc-struct.html#src-filter-list

lib_src: Sample rate conversion$$$HiFi quality multi-rate SRC$$$File structure and overview£££fig-src-filters.html#file-structure-and-overview

lib_src: Sample rate conversion$$$HiFi quality multi-rate SRC$$$SSRC API£££fig-src-filters.html#ssrc-api

lib_src: Sample rate conversion$$$HiFi quality multi-rate SRC$$$ASRC API£££group__src__ssrc_1ga226fbd78b09d37bf424a73deb6bac4c8.html#asrc-api

lib_src: Sample rate conversion$$$HiFi quality fixed factor of 3 SRC£££doc/rst/fixed_ratio_src.html#hifi-quality-fixed-factor-of-3-src

lib_src: Sample rate conversion$$$HiFi quality fixed factor of 3 SRC$$$Shared API items£££doc/rst/fixed_ratio_src.html#shared-api-items

lib_src: Sample rate conversion$$$HiFi quality fixed factor of 3 SRC$$$HiFi quality DS3 API£££src_8h_1ac37f502eba9c4656102949a23f55316ea2d3c74d6bea4792f688c04eb0d86dbe7.html#hifi-quality-ds3-api

lib_src: Sample rate conversion$$$HiFi quality fixed factor of 3 SRC$$$HiFi quality OS3 API£££src_8h_1ad0a9f3f79a2d62601bcf241724553454.html#hifi-quality-os3-api

lib_src: Sample rate conversion$$$Voice quality fixed factor of 3 SRC£££src_8h_1a88ba94525a77cc39dc114812e9098d89.html#voice-quality-fixed-factor-of-3-src

lib_src: Sample rate conversion$$$Voice quality fixed factor of 3 SRC$$$Voice quality DS3 API£££src_8h_1a88ba94525a77cc39dc114812e9098d89.html#voice-quality-ds3-api

lib_src: Sample rate conversion$$$Voice quality fixed factor of 3 SRC$$$Voice quality US3 API£££src_8h_1a403f2e825ecdf4c8964ca27280fc12c3.html#voice-quality-us3-api

lib_src: Sample rate conversion$$$Voice quality fixed factor of 3 and 3/2 SRC optimised for XS3£££src_8h_1aaf259a7852365c77435bc4517aaea04b.html#voice-quality-fixed-factor-of-3-and-3-2-src-optimised-for-xs3

lib_src: Sample rate conversion$$$Voice quality fixed factor of 3 and 3/2 SRC optimised for XS3$$$Fixed factor of 3 VPU implementation£££ff3-voice-vpu-hdr.html#fixed-factor-of-3-vpu-implementation

lib_src: Sample rate conversion$$$Voice quality fixed factor of 3 and 3/2 SRC optimised for XS3$$$Voice quality DS3 VPU API£££src-ff3-vpu-pb.html#voice-quality-ds3-vpu-api

lib_src: Sample rate conversion$$$Voice quality fixed factor of 3 and 3/2 SRC optimised for XS3$$$Voice quality US3 VPU API£££group__src__ff3__96t__ds_1ga1bf363fc11bc27ff318415f594c7d7c6.html#voice-quality-us3-vpu-api

lib_src: Sample rate conversion$$$Voice quality fixed factor of 3 and 3/2 SRC optimised for XS3$$$Fixed factor of 3/2 VPU implementation£££group__src__ff3__96t__us_1ga222799a4919b2e17ef93a1ffaa0bb07c.html#fixed-factor-of-3-2-vpu-implementation

lib_src: Sample rate conversion$$$Voice quality fixed factor of 3 and 3/2 SRC optimised for XS3$$$Voice quality DS3/2 API£££src-ff3-2-vpu-pb.html#voice-quality-ds3-2-api

lib_src: Sample rate conversion$$$Voice quality fixed factor of 3 and 3/2 SRC optimised for XS3$$$Voice quality US3/2 API£££group__src__rat__2__3__96t__ds_1ga5de6e7f211676dd95bc08828b3ffbc75.html#voice-quality-us3-2-api

lib_src: Sample rate conversion$$$Asynchronous FIFO£££doc/rst/asynchronous_fifo/asynchronous_fifo.html#asynchronous-fifo

lib_src: Sample rate conversion$$$Asynchronous FIFO$$$Using the asynchronous FIFO£££asynchronous-fifo-use-cases.html#using-the-asynchronous-fifo

lib_src: Sample rate conversion$$$Asynchronous FIFO$$$Design parameters£££asynchronous-fifo-design-parameters.html#design-parameters

lib_src: Sample rate conversion$$$Asynchronous FIFO$$$Design parameters$$$Practical FIFO sizing for ASRC usage£££asynchronous-fifo-practical-sizing.html#practical-fifo-sizing-for-asrc-usage

lib_src: Sample rate conversion$$$Asynchronous FIFO$$$Controller settings£££required-fifo-length-table.html#controller-settings

lib_src: Sample rate conversion$$$Asynchronous FIFO$$$API£££required-fifo-length-table.html#api

lib_src: Sample rate conversion$$$Asynchronous FIFO$$$Implementation detail£££group__src__fifo__interp_1gac721c70a1e4b2d964da5d203af9ca2aa.html#implementation-detail

lib_src: Sample rate conversion$$$Asynchronous FIFO$$$Implementation detail$$$Measurements for the PID£££group__src__fifo__interp_1gac721c70a1e4b2d964da5d203af9ca2aa.html#measurements-for-the-pid

lib_src: Sample rate conversion$$$Asynchronous FIFO$$$Implementation detail$$$Implementation of asynchronicity£££asynchronous-fifo-phase-difference.html#implementation-of-asynchronicity

lib_src: Sample rate conversion$$$Asynchronous FIFO$$$Implementation detail$$$Communication and reset protocol summary£££asynchronous-fifo-phase-difference.html#communication-and-reset-protocol-summary

lib_src: Sample rate conversion$$$ASRC Task£££asrc-task-header.html#asrc-task

lib_src: Sample rate conversion$$$ASRC Task$$$Operation£££asrc-task-header.html#operation

lib_src: Sample rate conversion$$$ASRC Task$$$Latency characterisation£££asrc-task-header.html#latency-characterisation

API & usage

lib_src: Sample rate conversion$$$Performance characterisation£££performance-plots.html#performance-characterisation

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations£££performance-plots.html#pure-tone-fft-src-plots-across-sample-rate-combinations

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 0.999900Hz£££performance-plots.html#frequency-error-0-999900hz

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 16,000Hz£££ch1-84998-to-6355-fsi192-fso192-fdev1-000000-asrc-ssrc-xsim-asrc.html#id9

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 32,000Hz£££ch1-84998-to-6355-fsi192-fso192-fdev1-000000-asrc-ssrc-xsim-asrc.html#id10

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 44,100Hz£££ch1-84998-to-6355-fsi192-fso192-fdev1-000000-asrc-ssrc-xsim-asrc.html#id11

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 48,000Hz£££ch1-17999-to-1405-fsi192-fso44-fdev1-000100-asrc-xsim-asrc.html#id12

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 88,200Hz£££ch1-21799-to-2141-fsi192-fso48-fdev1-000100-asrc-xsim-asrc.html#id13

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 96,000Hz£££ch1-40000-to-6810-fsi192-fso88-fdev1-000100-asrc-xsim-asrc.html#id14

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 176,400Hz£££ch1-41996-to-2678-fsi192-fso96-fdev1-000100-asrc-xsim-asrc.html#id15

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 192,000Hz£££ch1-79992-to-13613-fsi192-fso176-fdev1-000100-asrc-xsim-asrc.html#id16

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000000Hz£££ch1-84988-to-6337-fsi192-fso192-fdev0-999900-asrc-xsim-asrc.html#frequency-error-1-000000hz

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 16,000Hz£££ch1-84998-to-6355-fsi192-fso192-fdev1-000000-asrc-ssrc-xsim-asrc.html#id9

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 32,000Hz£££ch1-84998-to-6355-fsi192-fso192-fdev1-000000-asrc-ssrc-xsim-asrc.html#id10

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 44,100Hz£££ch1-84998-to-6355-fsi192-fso192-fdev1-000000-asrc-ssrc-xsim-asrc.html#id11

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 48,000Hz£££ch1-17999-to-1405-fsi192-fso44-fdev1-000100-asrc-xsim-asrc.html#id12

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 88,200Hz£££ch1-21799-to-2141-fsi192-fso48-fdev1-000100-asrc-xsim-asrc.html#id13

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 96,000Hz£££ch1-40000-to-6810-fsi192-fso88-fdev1-000100-asrc-xsim-asrc.html#id14

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 176,400Hz£££ch1-41996-to-2678-fsi192-fso96-fdev1-000100-asrc-xsim-asrc.html#id15

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 192,000Hz£££ch1-79992-to-13613-fsi192-fso176-fdev1-000100-asrc-xsim-asrc.html#id16

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz£££ch1-84998-to-6355-fsi192-fso192-fdev1-000000-asrc-ssrc-xsim-asrc.html#frequency-error-1-000100hz

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 16,000Hz£££ch1-84998-to-6355-fsi192-fso192-fdev1-000000-asrc-ssrc-xsim-asrc.html#id9

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 32,000Hz£££ch1-84998-to-6355-fsi192-fso192-fdev1-000000-asrc-ssrc-xsim-asrc.html#id10

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 44,100Hz£££ch1-84998-to-6355-fsi192-fso192-fdev1-000000-asrc-ssrc-xsim-asrc.html#id11

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 48,000Hz£££ch1-17999-to-1405-fsi192-fso44-fdev1-000100-asrc-xsim-asrc.html#id12

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 88,200Hz£££ch1-21799-to-2141-fsi192-fso48-fdev1-000100-asrc-xsim-asrc.html#id13

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 96,000Hz£££ch1-40000-to-6810-fsi192-fso88-fdev1-000100-asrc-xsim-asrc.html#id14

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 176,400Hz£££ch1-41996-to-2678-fsi192-fso96-fdev1-000100-asrc-xsim-asrc.html#id15

lib_src: Sample rate conversion$$$Performance characterisation$$$Pure Tone FFT SRC plots across sample rate combinations$$$Frequency error: 1.000100Hz$$$Output Fs : 192,000Hz£££ch1-79992-to-13613-fsi192-fso176-fdev1-000100-asrc-xsim-asrc.html#id16

lib_src: Sample rate conversion$$$Performance characterisation$$$Summary table£££ch1-84990-to-6355-fsi192-fso192-fdev1-000100-asrc-xsim-asrc.html#summary-table

lib_src: Sample rate conversion$$$Asynchronous FIFO$$$Implementation detail£££groupsrcfifo__interp_1gac721c70a1e4b2d964da5d203af9ca2aa.html#implementation-detail

lib_src: Sample rate conversion$$$HiFi quality multi-rate SRC$$$ASRC API£££groupsrcssrc_1ga226fbd78b09d37bf424a73deb6bac4c8.html#asrc-api

lib_src: Sample rate conversion$$$Voice quality fixed factor of 3 and 3/2 SRC optimised for XS3$$$Voice quality US3 VPU API£££groupsrcff396tds_1ga1bf363fc11bc27ff318415f594c7d7c6.html#voice-quality-us3-vpu-api

lib_src: Sample rate conversion$$$Voice quality fixed factor of 3 and 3/2 SRC optimised for XS3$$$Fixed factor of 3/2 VPU implementation£££groupsrcff396tus_1ga222799a4919b2e17ef93a1ffaa0bb07c.html#fixed-factor-of-3-2-vpu-implementation

lib_src: Sample rate conversion$$$Voice quality fixed factor of 3 and 3/2 SRC optimised for XS3$$$Voice quality US3/2 API£££groupsrcrat2396tds_1ga5de6e7f211676dd95bc08828b3ffbc75.html#voice-quality-us3-2-api

lib_src: Sample rate conversion$$$Asynchronous FIFO$$$Implementation detail£££groupsrcfifo__interp_1gac721c70a1e4b2d964da5d203af9ca2aa.html#implementation-detail

lib_src: Sample rate conversion$$$Asynchronous FIFO$$$Implementation detail$$$Measurements for the PID£££groupsrcfifo__interp_1gac721c70a1e4b2d964da5d203af9ca2aa.html#measurements-for-the-pid