From b736c9e853cfb399b09b660aecacf5b8a58c5716 Mon Sep 17 00:00:00 2001 From: Shuchita Khare Date: Fri, 1 Sep 2023 14:04:53 +0100 Subject: [PATCH 1/5] Use 64bit rate ratio, in 4.(28+32) format --- lib_src/api/src.h | 6 +- .../src/multirate_hifi/asrc/src_mrhf_asrc.c | 195 ++++++++++++------ .../src/multirate_hifi/asrc/src_mrhf_asrc.h | 5 +- .../asrc/src_mrhf_asrc_wrapper.c | 29 ++- 4 files changed, 161 insertions(+), 74 deletions(-) diff --git a/lib_src/api/src.h b/lib_src/api/src.h index e380cade..96b79649 100644 --- a/lib_src/api/src.h +++ b/lib_src/api/src.h @@ -60,7 +60,7 @@ unsigned ssrc_process(int in_buff[], int out_buff[], ssrc_ctrl_t ssrc_ctrl[]); * \param dither_on_off Dither to 24b on/off * \returns The nominal sample rate ratio of in to out in Q4.28 format */ -unsigned asrc_init(const fs_code_t sr_in, const fs_code_t sr_out, +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); @@ -72,9 +72,7 @@ unsigned asrc_init(const fs_code_t sr_in, const fs_code_t sr_out, * \param asrc_ctrl Reference to array of ASRC control structures * \returns The number of output samples produced by the SRC operation. */ -unsigned asrc_process(int in_buff[], int out_buff[], unsigned fs_ratio, - asrc_ctrl_t asrc_ctrl[]); - +unsigned asrc_process(int *in_buff, int *out_buff, uint64_t fs_ratio, asrc_ctrl_t asrc_ctrl[]); // To avoid C type definitions when including this file from assembler #ifndef INCLUDE_FROM_ASM diff --git a/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc.c b/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc.c index 65277e12..0c3b119b 100644 --- a/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc.c +++ b/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc.c @@ -45,6 +45,85 @@ #define ASRC_FS_176_F (176400.0) #define ASRC_FS_192_F (192000.0) +#define ASRC_FS_RATIO_UNIT_BIT 28 +#define ASRC_FS_RATIO_44_44_HI (uint32_t)((unsigned long long)(((double)ASRC_FS_44_F / ASRC_FS_44_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_44_44_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_44_F / ASRC_FS_44_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_44_48_HI (uint32_t)((unsigned long long)(((double)ASRC_FS_44_F / ASRC_FS_48_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_44_48_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_44_F / ASRC_FS_48_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_44_88_HI (uint32_t)((unsigned long long)(((double)ASRC_FS_44_F / ASRC_FS_88_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_44_88_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_44_F / ASRC_FS_88_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_44_96_HI (uint32_t)((unsigned long long)(((double)ASRC_FS_44_F / ASRC_FS_96_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_44_96_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_44_F / ASRC_FS_96_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_44_176_HI (uint32_t)((unsigned long long)(((double)ASRC_FS_44_F / ASRC_FS_176_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_44_176_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_44_F / ASRC_FS_176_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_44_192_HI (uint32_t)((unsigned long long)(((double)ASRC_FS_44_F / ASRC_FS_192_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_44_192_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_44_F / ASRC_FS_192_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) + +#define ASRC_FS_RATIO_48_44_HI (uint32_t)((unsigned long long)(((double)ASRC_FS_48_F / ASRC_FS_44_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_48_44_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_48_F / ASRC_FS_44_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_48_48_HI (uint32_t)((unsigned long long)(((double)ASRC_FS_48_F / ASRC_FS_48_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_48_48_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_48_F / ASRC_FS_48_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_48_88_HI (uint32_t)((unsigned long long)(((double)ASRC_FS_48_F / ASRC_FS_88_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_48_88_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_48_F / ASRC_FS_88_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_48_96_HI (uint32_t)((unsigned long long)(((double)ASRC_FS_48_F / ASRC_FS_96_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_48_96_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_48_F / ASRC_FS_96_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_48_176_HI (uint32_t)((unsigned long long)(((double)ASRC_FS_48_F / ASRC_FS_176_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_48_176_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_48_F / ASRC_FS_176_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_48_192_HI (uint32_t)((unsigned long long)(((double)ASRC_FS_48_F / ASRC_FS_192_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_48_192_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_48_F / ASRC_FS_192_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) + +#define ASRC_FS_RATIO_88_44_HI (uint32_t)((unsigned long long)(((double)ASRC_FS_88_F / ASRC_FS_44_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_88_44_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_88_F / ASRC_FS_44_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_88_48_HI (uint32_t)((unsigned long long)(((double)ASRC_FS_88_F / ASRC_FS_48_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_88_48_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_88_F / ASRC_FS_48_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_88_88_HI (uint32_t)((unsigned long long)(((double)ASRC_FS_88_F / ASRC_FS_88_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_88_88_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_88_F / ASRC_FS_88_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_88_96_HI (uint32_t)((unsigned long long)(((double)ASRC_FS_88_F / ASRC_FS_96_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_88_96_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_88_F / ASRC_FS_96_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_88_176_HI (uint32_t)((unsigned long long)(((double)ASRC_FS_88_F / ASRC_FS_176_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_88_176_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_88_F / ASRC_FS_176_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_88_192_HI (uint32_t)((unsigned long long)(((double)ASRC_FS_88_F / ASRC_FS_192_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_88_192_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_88_F / ASRC_FS_192_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) + +#define ASRC_FS_RATIO_96_44_HI (uint32_t)((unsigned long long)(((double)ASRC_FS_96_F / ASRC_FS_44_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_96_44_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_96_F / ASRC_FS_44_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_96_48_HI (uint32_t)((unsigned long long)(((double)ASRC_FS_96_F / ASRC_FS_48_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_96_48_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_96_F / ASRC_FS_48_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_96_88_HI (uint32_t)((unsigned long long)(((double)ASRC_FS_96_F / ASRC_FS_88_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_96_88_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_96_F / ASRC_FS_88_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_96_96_HI (uint32_t)((unsigned long long)(((double)ASRC_FS_96_F / ASRC_FS_96_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_96_96_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_96_F / ASRC_FS_96_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_96_176_HI (uint32_t)((unsigned long long)(((double)ASRC_FS_96_F / ASRC_FS_176_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_96_176_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_96_F / ASRC_FS_176_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_96_192_HI (uint32_t)((unsigned long long)(((double)ASRC_FS_96_F / ASRC_FS_192_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_96_192_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_96_F / ASRC_FS_192_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) + +#define ASRC_FS_RATIO_176_44_HI (uint32_t)((unsigned long long)(((double)ASRC_FS_176_F / ASRC_FS_44_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_176_44_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_176_F / ASRC_FS_44_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_176_48_HI (uint32_t)((unsigned long long)(((double)ASRC_FS_176_F / ASRC_FS_48_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_176_48_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_176_F / ASRC_FS_48_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_176_88_HI (uint32_t)((unsigned long long)(((double)ASRC_FS_176_F / ASRC_FS_88_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_176_88_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_176_F / ASRC_FS_88_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_176_96_HI (uint32_t)((unsigned long long)(((double)ASRC_FS_176_F / ASRC_FS_96_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_176_96_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_176_F / ASRC_FS_96_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_176_176_HI (uint32_t)((unsigned long long)(((double)ASRC_FS_176_F / ASRC_FS_176_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_176_176_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_176_F / ASRC_FS_176_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_176_192_HI (uint32_t)((unsigned long long)(((double)ASRC_FS_176_F / ASRC_FS_192_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_176_192_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_176_F / ASRC_FS_192_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) + +#define ASRC_FS_RATIO_192_44_HI (uint32_t)((unsigned long long)(((double)ASRC_FS_192_F / ASRC_FS_44_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_192_44_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_192_F / ASRC_FS_44_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_192_48_HI (uint32_t)((unsigned long long)(((double)ASRC_FS_192_F / ASRC_FS_48_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_192_48_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_192_F / ASRC_FS_48_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_192_88_HI (uint32_t)((unsigned long long)(((double)ASRC_FS_192_F / ASRC_FS_88_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_192_88_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_192_F / ASRC_FS_88_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_192_96_HI (uint32_t)((unsigned long long)(((double)ASRC_FS_192_F / ASRC_FS_96_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_192_96_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_192_F / ASRC_FS_96_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_192_176_HI (uint32_t)((unsigned long long)(((double)ASRC_FS_192_F / ASRC_FS_176_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_192_176_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_192_F / ASRC_FS_176_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_192_192_HI (uint32_t)((unsigned long long)(((double)ASRC_FS_192_F / ASRC_FS_192_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_192_192_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_192_F / ASRC_FS_192_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) + #define ASRC_FS_RATIO_44_44 (unsigned int)((ASRC_FS_44_F / ASRC_FS_44_F) * ASRC_NOMINAL_FS_SCALE) #define ASRC_FS_RATIO_44_48 (unsigned int)((ASRC_FS_44_F / ASRC_FS_48_F) * ASRC_NOMINAL_FS_SCALE) #define ASRC_FS_RATIO_44_88 (unsigned int)((ASRC_FS_44_F / ASRC_FS_88_F) * ASRC_NOMINAL_FS_SCALE) @@ -93,7 +172,6 @@ #define ASRC_ADFIR_INITIAL_PHASE 32 // Time ratio shift values -#define ASRC_FS_RATIO_UNIT_BIT 28 #define ASRC_FS_RATIO_PHASE_N_BITS 7 #define ASRC_FS_RATIO_BASE_SHIFT (ASRC_FS_RATIO_UNIT_BIT - ASRC_FS_RATIO_PHASE_N_BITS) #define ASRC_FS_RATIO_SHIFT_M1 (ASRC_FS_RATIO_BASE_SHIFT + 1) @@ -175,65 +253,64 @@ ASRCFiltersIDs_t sASRCFiltersIDs[ASRC_N_FS][ASRC_N_FS] = / }; -ASRCFsRatioConfigs_t sFsRatioConfigs[ASRC_N_FS][ASRC_N_FS] = // Fs ratio configuration table [Fsin][Fsout] +ASRCFsRatioConfigs_t sFsRatioConfigs[ASRC_N_FS][ASRC_N_FS] = // Fs ratio configuration table [Fsin][Fsout] { - { // Fsin = 44.1kHz - // Nominal Fs Ratio // Minimal Fs Ratio // Maximal Fs Ratio Shift for time step - {ASRC_FS_RATIO_44_44, (unsigned int)(ASRC_FS_RATIO_44_44 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_44_44 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 44.1kHz - {ASRC_FS_RATIO_44_48, (unsigned int)(ASRC_FS_RATIO_44_48 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_44_48 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 48kHz - {ASRC_FS_RATIO_44_88, (unsigned int)(ASRC_FS_RATIO_44_88 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_44_88 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 88.2kHz - {ASRC_FS_RATIO_44_96, (unsigned int)(ASRC_FS_RATIO_44_96 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_44_96 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 96kHz - {ASRC_FS_RATIO_44_176, (unsigned int)(ASRC_FS_RATIO_44_176 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_44_176 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 176.4kHz - {ASRC_FS_RATIO_44_192, (unsigned int)(ASRC_FS_RATIO_44_192 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_44_192 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1} // Fsout = 192kHz - }, - { // Fsin = 48kHz - // Nominal Fs Ratio // Minimal Fs Ratio // Maximal Fs Ratio Shift for time step - {ASRC_FS_RATIO_48_44, (unsigned int)(ASRC_FS_RATIO_48_44 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_48_44 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 44.1kHz - {ASRC_FS_RATIO_48_48, (unsigned int)(ASRC_FS_RATIO_48_48 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_48_48 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 48kHz - {ASRC_FS_RATIO_48_88, (unsigned int)(ASRC_FS_RATIO_48_88 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_48_88 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 88.2kHz - {ASRC_FS_RATIO_48_96, (unsigned int)(ASRC_FS_RATIO_48_96 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_48_96 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 96kHz - {ASRC_FS_RATIO_48_176, (unsigned int)(ASRC_FS_RATIO_48_176 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_48_176 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 176.4kHz - {ASRC_FS_RATIO_48_192, (unsigned int)(ASRC_FS_RATIO_48_192 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_48_192 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1} // Fsout = 192kHz - }, - { // Fsin = 88.2kHz - // Nominal Fs Ratio // Minimal Fs Ratio // Maximal Fs Ratio Shift for time step - {ASRC_FS_RATIO_88_44, (unsigned int)(ASRC_FS_RATIO_88_44 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_88_44 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_0}, // Fsout = 44.1kHz - {ASRC_FS_RATIO_88_48, (unsigned int)(ASRC_FS_RATIO_88_48 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_88_48 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_0}, // Fsout = 48kHz - {ASRC_FS_RATIO_88_88, (unsigned int)(ASRC_FS_RATIO_88_88 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_88_88 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 88.2kHz - {ASRC_FS_RATIO_88_96, (unsigned int)(ASRC_FS_RATIO_88_96 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_88_96 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 96kHz - {ASRC_FS_RATIO_88_176, (unsigned int)(ASRC_FS_RATIO_88_176 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_88_176 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 176.4kHz - {ASRC_FS_RATIO_88_192, (unsigned int)(ASRC_FS_RATIO_88_192 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_88_192 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1} // Fsout = 192kHz - }, - { // Fsin = 96kHz - // Nominal Fs Ratio // Minimal Fs Ratio // Maximal Fs Ratio Shift for time step - {ASRC_FS_RATIO_96_44, (unsigned int)(ASRC_FS_RATIO_96_44 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_96_44 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_0}, // Fsout = 44.1kHz - {ASRC_FS_RATIO_96_48, (unsigned int)(ASRC_FS_RATIO_96_48 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_96_48 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_0}, // Fsout = 48kHz - {ASRC_FS_RATIO_96_88, (unsigned int)(ASRC_FS_RATIO_96_88 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_96_88 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 88.2kHz - {ASRC_FS_RATIO_96_96, (unsigned int)(ASRC_FS_RATIO_96_96 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_96_96 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 96kHz - {ASRC_FS_RATIO_96_176, (unsigned int)(ASRC_FS_RATIO_96_176 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_96_176 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 176.4kHz - {ASRC_FS_RATIO_96_192, (unsigned int)(ASRC_FS_RATIO_96_192 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_96_192 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1} // Fsout = 192kHz - }, - { // Fsin = 176.4kHz - // Nominal Fs Ratio // Minimal Fs Ratio // Maximal Fs Ratio Shift for time step - {ASRC_FS_RATIO_176_44, (unsigned int)(ASRC_FS_RATIO_176_44 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_176_44 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_M1}, // Fsout = 44.1kHz - {ASRC_FS_RATIO_176_48, (unsigned int)(ASRC_FS_RATIO_176_48 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_176_48 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_M1}, // Fsout = 48kHz - {ASRC_FS_RATIO_176_88, (unsigned int)(ASRC_FS_RATIO_176_88 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_176_88 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_0}, // Fsout = 88.2kHz - {ASRC_FS_RATIO_176_96, (unsigned int)(ASRC_FS_RATIO_176_96 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_176_96 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_0}, // Fsout = 96kHz - {ASRC_FS_RATIO_176_176, (unsigned int)(ASRC_FS_RATIO_176_176 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_176_176 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 176.4kHz - {ASRC_FS_RATIO_176_192, (unsigned int)(ASRC_FS_RATIO_176_192 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_176_192 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1} // Fsout = 192kHz - }, - { // Fsin = 192kHz - // Nominal Fs Ratio // Minimal Fs Ratio // Maximal Fs Ratio Shift for time step - {ASRC_FS_RATIO_192_44, (unsigned int)(ASRC_FS_RATIO_192_44 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_192_44 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_M1}, // Fsout = 44.1kHz - {ASRC_FS_RATIO_192_48, (unsigned int)(ASRC_FS_RATIO_192_48 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_192_48 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_M1}, // Fsout = 48kHz - {ASRC_FS_RATIO_192_88, (unsigned int)(ASRC_FS_RATIO_192_88 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_192_88 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_0}, // Fsout = 88.2kHz - {ASRC_FS_RATIO_192_96, (unsigned int)(ASRC_FS_RATIO_192_96 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_192_96 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_0}, // Fsout = 96kHz - {ASRC_FS_RATIO_192_176, (unsigned int)(ASRC_FS_RATIO_192_176 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_192_176 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 176.4kHz - {ASRC_FS_RATIO_192_192, (unsigned int)(ASRC_FS_RATIO_192_192 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_192_192 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1} // Fsout = 192kHz - } + { // Fsin = 44.1kHz + // Nominal Fs Ratio // Minimal Fs Ratio // Maximal Fs Ratio Shift for time step + {ASRC_FS_RATIO_44_44, ASRC_FS_RATIO_44_44_LO, (unsigned int)(ASRC_FS_RATIO_44_44 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_44_44 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 44.1kHz + {ASRC_FS_RATIO_44_48, ASRC_FS_RATIO_44_48_LO, (unsigned int)(ASRC_FS_RATIO_44_48 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_44_48 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 48kHz + {ASRC_FS_RATIO_44_88, ASRC_FS_RATIO_44_88_LO, (unsigned int)(ASRC_FS_RATIO_44_88 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_44_88 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 88.2kHz + {ASRC_FS_RATIO_44_96, ASRC_FS_RATIO_44_96_LO, (unsigned int)(ASRC_FS_RATIO_44_96 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_44_96 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 96kHz + {ASRC_FS_RATIO_44_176, ASRC_FS_RATIO_44_176_LO, (unsigned int)(ASRC_FS_RATIO_44_176 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_44_176 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 176.4kHz + {ASRC_FS_RATIO_44_192, ASRC_FS_RATIO_44_192_LO, (unsigned int)(ASRC_FS_RATIO_44_192 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_44_192 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1} // Fsout = 192kHz + }, + { // Fsin = 48kHz + // Nominal Fs Ratio // Minimal Fs Ratio // Maximal Fs Ratio Shift for time step + {ASRC_FS_RATIO_48_44, ASRC_FS_RATIO_48_44_LO, (unsigned int)(ASRC_FS_RATIO_48_44 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_48_44 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 44.1kHz + {ASRC_FS_RATIO_48_48, ASRC_FS_RATIO_48_48_LO, (unsigned int)(ASRC_FS_RATIO_48_48 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_48_48 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 48kHz + {ASRC_FS_RATIO_48_88, ASRC_FS_RATIO_48_88_LO, (unsigned int)(ASRC_FS_RATIO_48_88 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_48_88 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 88.2kHz + {ASRC_FS_RATIO_48_96, ASRC_FS_RATIO_48_96_LO, (unsigned int)(ASRC_FS_RATIO_48_96 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_48_96 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 96kHz + {ASRC_FS_RATIO_48_176, ASRC_FS_RATIO_48_176_LO, (unsigned int)(ASRC_FS_RATIO_48_176 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_48_176 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 176.4kHz + {ASRC_FS_RATIO_48_192, ASRC_FS_RATIO_48_192_LO, (unsigned int)(ASRC_FS_RATIO_48_192 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_48_192 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1} // Fsout = 192kHz + }, + { // Fsin = 88.2kHz + // Nominal Fs Ratio // Minimal Fs Ratio // Maximal Fs Ratio Shift for time step + {ASRC_FS_RATIO_88_44, ASRC_FS_RATIO_88_44_LO, (unsigned int)(ASRC_FS_RATIO_88_44 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_88_44 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_0}, // Fsout = 44.1kHz + {ASRC_FS_RATIO_88_48, ASRC_FS_RATIO_88_48_LO, (unsigned int)(ASRC_FS_RATIO_88_48 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_88_48 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_0}, // Fsout = 48kHz + {ASRC_FS_RATIO_88_88, ASRC_FS_RATIO_88_88_LO, (unsigned int)(ASRC_FS_RATIO_88_88 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_88_88 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 88.2kHz + {ASRC_FS_RATIO_88_96, ASRC_FS_RATIO_88_96_LO, (unsigned int)(ASRC_FS_RATIO_88_96 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_88_96 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 96kHz + {ASRC_FS_RATIO_88_176, ASRC_FS_RATIO_88_176_LO, (unsigned int)(ASRC_FS_RATIO_88_176 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_88_176 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 176.4kHz + {ASRC_FS_RATIO_88_192, ASRC_FS_RATIO_88_192_LO, (unsigned int)(ASRC_FS_RATIO_88_192 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_88_192 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1} // Fsout = 192kHz + }, + { // Fsin = 96kHz + // Nominal Fs Ratio // Minimal Fs Ratio // Maximal Fs Ratio Shift for time step + {ASRC_FS_RATIO_96_44, ASRC_FS_RATIO_96_44_LO, (unsigned int)(ASRC_FS_RATIO_96_44 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_96_44 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_0}, // Fsout = 44.1kHz + {ASRC_FS_RATIO_96_48, ASRC_FS_RATIO_96_48_LO, (unsigned int)(ASRC_FS_RATIO_96_48 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_96_48 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_0}, // Fsout = 48kHz + {ASRC_FS_RATIO_96_88, ASRC_FS_RATIO_96_88_LO, (unsigned int)(ASRC_FS_RATIO_96_88 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_96_88 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 88.2kHz + {ASRC_FS_RATIO_96_96, ASRC_FS_RATIO_96_96_LO, (unsigned int)(ASRC_FS_RATIO_96_96 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_96_96 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 96kHz + {ASRC_FS_RATIO_96_176, ASRC_FS_RATIO_96_176_LO, (unsigned int)(ASRC_FS_RATIO_96_176 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_96_176 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 176.4kHz + {ASRC_FS_RATIO_96_192, ASRC_FS_RATIO_96_192_LO, (unsigned int)(ASRC_FS_RATIO_96_192 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_96_192 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1} // Fsout = 192kHz + }, + { // Fsin = 176.4kHz + // Nominal Fs Ratio // Minimal Fs Ratio // Maximal Fs Ratio Shift for time step + {ASRC_FS_RATIO_176_44, ASRC_FS_RATIO_176_44_LO, (unsigned int)(ASRC_FS_RATIO_176_44 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_176_44 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_M1}, // Fsout = 44.1kHz + {ASRC_FS_RATIO_176_48, ASRC_FS_RATIO_176_48_LO, (unsigned int)(ASRC_FS_RATIO_176_48 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_176_48 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_M1}, // Fsout = 48kHz + {ASRC_FS_RATIO_176_88, ASRC_FS_RATIO_176_88_LO, (unsigned int)(ASRC_FS_RATIO_176_88 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_176_88 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_0}, // Fsout = 88.2kHz + {ASRC_FS_RATIO_176_96, ASRC_FS_RATIO_176_96_LO, (unsigned int)(ASRC_FS_RATIO_176_96 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_176_96 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_0}, // Fsout = 96kHz + {ASRC_FS_RATIO_176_176, ASRC_FS_RATIO_176_176_LO, (unsigned int)(ASRC_FS_RATIO_176_176 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_176_176 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 176.4kHz + {ASRC_FS_RATIO_176_192, ASRC_FS_RATIO_176_192_LO, (unsigned int)(ASRC_FS_RATIO_176_192 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_176_192 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1} // Fsout = 192kHz + }, + { // Fsin = 192kHz + // Nominal Fs Ratio // Minimal Fs Ratio // Maximal Fs Ratio Shift for time step + {ASRC_FS_RATIO_192_44, ASRC_FS_RATIO_192_44_LO, (unsigned int)(ASRC_FS_RATIO_192_44 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_192_44 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_M1}, // Fsout = 44.1kHz + {ASRC_FS_RATIO_192_48, ASRC_FS_RATIO_192_48_LO, (unsigned int)(ASRC_FS_RATIO_192_48 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_192_48 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_M1}, // Fsout = 48kHz + {ASRC_FS_RATIO_192_88, ASRC_FS_RATIO_192_88_LO, (unsigned int)(ASRC_FS_RATIO_192_88 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_192_88 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_0}, // Fsout = 88.2kHz + {ASRC_FS_RATIO_192_96, ASRC_FS_RATIO_192_96_LO, (unsigned int)(ASRC_FS_RATIO_192_96 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_192_96 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_0}, // Fsout = 96kHz + {ASRC_FS_RATIO_192_176, ASRC_FS_RATIO_192_176_LO, (unsigned int)(ASRC_FS_RATIO_192_176 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_192_176 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 176.4kHz + {ASRC_FS_RATIO_192_192, ASRC_FS_RATIO_192_192_LO, (unsigned int)(ASRC_FS_RATIO_192_192 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_192_192 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1} // Fsout = 192kHz + } }; - // =========================================================================== // // Local Functions prototypes @@ -315,6 +392,7 @@ ASRCReturnCodes_t ASRC_init(asrc_ctrl_t* pasrc_ctrl) // Set nominal fs ratio pasrc_ctrl->uiFsRatio = sFsRatioConfigs[pasrc_ctrl->eInFs][pasrc_ctrl->eOutFs].uiNominalFsRatio; + pasrc_ctrl->uiFsRatio_lsb = sFsRatioConfigs[pasrc_ctrl->eInFs][pasrc_ctrl->eOutFs].uiNominalFsRatio_lo; // Check that number of input samples is allocated and is a multiple of 4 if(pasrc_ctrl->uiNInSamples == 0) @@ -397,7 +475,6 @@ ASRCReturnCodes_t ASRC_init(asrc_ctrl_t* pasrc_ctrl) // Call sync function if(ASRC_sync(pasrc_ctrl) != ASRC_NO_ERROR) return ASRC_ERROR; - return ASRC_NO_ERROR; } @@ -478,6 +555,7 @@ ASRCReturnCodes_t ASRC_proc_F1_F2(asrc_ctrl_t* pasrc_ctrl) ASRCReturnCodes_t ASRC_update_fs_ratio(asrc_ctrl_t* pasrc_ctrl) { unsigned int uiFsRatio = pasrc_ctrl->uiFsRatio; + unsigned int uiFsRatio_low = pasrc_ctrl->uiFsRatio_lsb; // Check for bounds of new Fs ratio if( (uiFsRatio < sFsRatioConfigs[pasrc_ctrl->eInFs][pasrc_ctrl->eOutFs].uiMinFsRatio) || @@ -487,6 +565,7 @@ ASRCReturnCodes_t ASRC_update_fs_ratio(asrc_ctrl_t* pasrc_ctrl) // Apply shift to time ratio to build integer and fractional parts of time step pasrc_ctrl->iTimeStepInt = uiFsRatio >> (sFsRatioConfigs[pasrc_ctrl->eInFs][pasrc_ctrl->eOutFs].iFsRatioShift); pasrc_ctrl->uiTimeStepFract = uiFsRatio << (32 - sFsRatioConfigs[pasrc_ctrl->eInFs][pasrc_ctrl->eOutFs].iFsRatioShift); + pasrc_ctrl->uiTimeStepFract |= (uint32_t)(uiFsRatio_low >> sFsRatioConfigs[pasrc_ctrl->eInFs][pasrc_ctrl->eOutFs].iFsRatioShift); return ASRC_NO_ERROR; } diff --git a/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc.h b/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc.h index f7144f41..77737847 100644 --- a/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc.h +++ b/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc.h @@ -35,7 +35,7 @@ // --------------- #define ASRC_STACK_LENGTH_MULT (ASRC_N_CHANNELS * 4) // Multiplier for stack length (stack length = this value x the number of input samples to process) #define ASRC_ADFIR_COEFS_LENGTH FILTER_DEFS_ADFIR_PHASE_N_TAPS // Length of AD FIR coefficients buffer - #define ASRC_NOMINAL_FS_SCALE (268435456) //Nominal Fs Ratio scale value in 4.28 format + #define ASRC_NOMINAL_FS_SCALE (1 << ASRC_FS_RATIO_UNIT_BIT) // 2^28 // Parameter values @@ -105,6 +105,7 @@ typedef struct _ASRCFsRatioConfigs { unsigned int uiNominalFsRatio; + unsigned int uiNominalFsRatio_lo; unsigned int uiMinFsRatio; unsigned int uiMaxFsRatio; int iFsRatioShift; @@ -142,6 +143,7 @@ ADFIRCtrl_t sADFIRF3Ctrl; // F3 ADFIR controller unsigned int uiFsRatio; // Fs ratio: Fsin / Fsout + unsigned int uiFsRatio_lsb; int iTimeInt; // Integer part of time unsigned int uiTimeFract; // Fractional part of time @@ -170,6 +172,7 @@ ADFIRCtrl_t sADFIRF3Ctrl; // F3 ADFIR controller unsigned int uiFsRatio; // Fs ratio: Fsin / Fsout + unsigned int uiFsRatio_lsb; int iTimeInt; // Integer part of time unsigned int uiTimeFract; // Fractional part of time diff --git a/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc_wrapper.c b/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc_wrapper.c index c0bfa4f3..298cec63 100644 --- a/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc_wrapper.c +++ b/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc_wrapper.c @@ -23,7 +23,7 @@ static void asrc_error(int code) } -unsigned 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, +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) { unsigned ui; @@ -31,13 +31,13 @@ unsigned asrc_init(const fs_code_t sr_in, const fs_code_t sr_out, asrc_ctrl_t as ASRCReturnCodes_t ret_code; ret_code = ASRC_prepare_coefs(); + if (ret_code != ASRC_NO_ERROR) asrc_error(10); //Check to see if n_channels_per_instance, n_in_samples are reasonable if ((n_in_samples & 0x1) || (n_in_samples < 4)) asrc_error(100); if (n_channels_per_instance < 1) asrc_error(101); - for(ui = 0; ui < n_channels_per_instance; ui++) { // Set number of channels per instance @@ -56,21 +56,23 @@ unsigned asrc_init(const fs_code_t sr_in, const fs_code_t sr_out, asrc_ctrl_t as // Init ASRC instances ret_code = ASRC_init(&asrc_ctrl[ui]); + if (ret_code != ASRC_NO_ERROR) asrc_error(11); } // Sync // ---- // Sync ASRC. This is just to show that the function works and returns success + for(ui = 0; ui < n_channels_per_instance; ui++) { ret_code = ASRC_sync(&asrc_ctrl[ui]); if (ret_code != ASRC_NO_ERROR) asrc_error(12); } - return (asrc_ctrl[0].uiFsRatio); + return (uint64_t)((((uint64_t)asrc_ctrl[0].uiFsRatio) << 32) | asrc_ctrl[0].uiFsRatio_lsb); } -unsigned asrc_process(int *in_buff, int *out_buff, unsigned fs_ratio, asrc_ctrl_t asrc_ctrl[]){ +unsigned asrc_process(int *in_buff, int *out_buff, uint64_t fs_ratio, asrc_ctrl_t asrc_ctrl[]){ int ui, uj; //General counters int uiSplCntr; //Spline counter @@ -78,25 +80,30 @@ unsigned asrc_process(int *in_buff, int *out_buff, unsigned fs_ratio, asrc_ctrl_ // Get the number of channels per instance from first channel const unsigned n_channels_per_instance = asrc_ctrl[0].uiNchannels; + uint32_t fs_ratio_hi = (uint32_t)(fs_ratio >> 32); + uint32_t fs_ratio_lo = (uint32_t)(fs_ratio); for(ui = 0; ui < n_channels_per_instance; ui++) { // Update Fs Ratio - asrc_ctrl[ui].uiFsRatio = fs_ratio; + asrc_ctrl[ui].uiFsRatio = fs_ratio_hi; + asrc_ctrl[ui].uiFsRatio_lsb = fs_ratio_lo; #if DO_FS_BOUNDS_CHECK // Check for bounds of new Fs ratio - if( (fs_ratio < sFsRatioConfigs[asrc_ctrl[ui].eInFs][asrc_ctrl[ui].eOutFs].uiMinFsRatio) || - (fs_ratio > sFsRatioConfigs[asrc_ctrl[ui].eInFs][asrc_ctrl[ui].eOutFs].uiMaxFsRatio) ) + if( (fs_ratio_hi < sFsRatioConfigs[asrc_ctrl[ui].eInFs][asrc_ctrl[ui].eOutFs].uiMinFsRatio) || + (fs_ratio_hi > sFsRatioConfigs[asrc_ctrl[ui].eInFs][asrc_ctrl[ui].eOutFs].uiMaxFsRatio) ) { - //debug_printf("Passed = %x, Nominal = 0x%x\n", fs_ratio, sFsRatioConfigs[asrc_ctrl[ui].eInFs][asrc_ctrl[ui].eOutFs].uiNominalFsRatio); - fs_ratio = sFsRatioConfigs[asrc_ctrl[ui].eInFs][asrc_ctrl[ui].eOutFs].uiNominalFsRatio; //Important to prevent buffer overflow if fs_ratio requests too many samples. + //debug_printf("Passed = %x, Nominal = 0x%x\n", fs_ratio_hi, sFsRatioConfigs[asrc_ctrl[ui].eInFs][asrc_ctrl[ui].eOutFs].uiNominalFsRatio); + fs_ratio_hi = sFsRatioConfigs[asrc_ctrl[ui].eInFs][asrc_ctrl[ui].eOutFs].uiNominalFsRatio; //Important to prevent buffer overflow if fs_ratio requests too many samples. + fs_ratio_lo = sFsRatioConfigs[asrc_ctrl[ui].eInFs][asrc_ctrl[ui].eOutFs].uiNominalFsRatio_lo; //debug_printf("!"); } #endif // Apply shift to time ratio to build integer and fractional parts of time step - asrc_ctrl[ui].iTimeStepInt = fs_ratio >> (sFsRatioConfigs[asrc_ctrl[ui].eInFs][asrc_ctrl[ui].eOutFs].iFsRatioShift); - asrc_ctrl[ui].uiTimeStepFract = fs_ratio << (32 - sFsRatioConfigs[asrc_ctrl[ui].eInFs][asrc_ctrl[ui].eOutFs].iFsRatioShift); + asrc_ctrl[ui].iTimeStepInt = fs_ratio_hi >> (sFsRatioConfigs[asrc_ctrl[ui].eInFs][asrc_ctrl[ui].eOutFs].iFsRatioShift); + asrc_ctrl[ui].uiTimeStepFract = fs_ratio_hi << (32 - sFsRatioConfigs[asrc_ctrl[ui].eInFs][asrc_ctrl[ui].eOutFs].iFsRatioShift); + asrc_ctrl[ui].uiTimeStepFract |= (uint32_t)(fs_ratio_lo >> sFsRatioConfigs[asrc_ctrl[ui].eInFs][asrc_ctrl[ui].eOutFs].iFsRatioShift); From 1f0ef205269790c211b1497710af3c2d4cb170c3 Mon Sep 17 00:00:00 2001 From: Shuchita Khare Date: Tue, 5 Sep 2023 10:35:25 +0100 Subject: [PATCH 2/5] Added 64bit fs ratio support to dut test and golden reference --- lib_src/api/src.h | 10 +- .../src/multirate_hifi/asrc/src_mrhf_asrc.c | 1 - .../src/multirate_hifi/asrc/src_mrhf_asrc.h | 5 +- tests/asrc_test/dut/asrc_test.xc | 28 +- tests/asrc_test/model/ASRC.c | 253 ++++++++++-------- tests/asrc_test/model/ASRC.h | 36 +-- tests/asrc_test/model/Main.c | 9 +- 7 files changed, 185 insertions(+), 157 deletions(-) diff --git a/lib_src/api/src.h b/lib_src/api/src.h index 42358b3d..6c1da408 100644 --- a/lib_src/api/src.h +++ b/lib_src/api/src.h @@ -77,7 +77,7 @@ unsigned ssrc_process(int in_buff[], int out_buff[], ssrc_ctrl_t ssrc_ctrl[]); * \param n_channels_per_instance Number of channels handled by this instance of SSRC * \param n_in_samples Number of input samples per SSRC call * \param dither_on_off Dither to 24b on/off - * \returns The nominal sample rate ratio of in to out in Q4.28 format + * \returns The nominal sample rate ratio of in to out in Q4.60 format */ 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, @@ -87,20 +87,16 @@ uint64_t asrc_init(const fs_code_t sr_in, const fs_code_t sr_out, * * \param in_buff Reference to input sample buffer array * \param out_buff Reference to output sample buffer array - * \param fs_ratio Fixed point ratio of in/out sample rates in Q4.28 format + * \param fs_ratio Fixed point ratio of in/out sample rates in Q4.60 format * \param asrc_ctrl Reference to array of ASRC control structures * \returns The number of output samples produced by the SRC operation. */ -<<<<<<< HEAD -unsigned asrc_process(int *in_buff, int *out_buff, uint64_t fs_ratio, asrc_ctrl_t asrc_ctrl[]); -======= -unsigned asrc_process(int in_buff[], int out_buff[], unsigned fs_ratio, +unsigned asrc_process(int in_buff[], int out_buff[], uint64_t fs_ratio, asrc_ctrl_t asrc_ctrl[]); /**@}*/ // END: addtogroup src_asrc ->>>>>>> af63c324f9eedc1437460c91b7c4b0b3bb2b7bfd // To avoid C type definitions when including this file from assembler #ifndef INCLUDE_FROM_ASM diff --git a/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc.c b/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc.c index e25f9b8b..fca10db6 100644 --- a/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc.c +++ b/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc.c @@ -45,7 +45,6 @@ #define ASRC_FS_176_F (176400.0) #define ASRC_FS_192_F (192000.0) -#define ASRC_FS_RATIO_UNIT_BIT 28 #define ASRC_FS_RATIO_44_44 (uint32_t)((unsigned long long)(((double)ASRC_FS_44_F / ASRC_FS_44_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) #define ASRC_FS_RATIO_44_44_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_44_F / ASRC_FS_44_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) #define ASRC_FS_RATIO_44_48 (uint32_t)((unsigned long long)(((double)ASRC_FS_44_F / ASRC_FS_48_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) diff --git a/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc.h b/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc.h index 77737847..be06d6da 100644 --- a/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc.h +++ b/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc.h @@ -33,9 +33,10 @@ // General defines // --------------- + #define ASRC_FS_RATIO_UNIT_BIT 28 #define ASRC_STACK_LENGTH_MULT (ASRC_N_CHANNELS * 4) // Multiplier for stack length (stack length = this value x the number of input samples to process) - #define ASRC_ADFIR_COEFS_LENGTH FILTER_DEFS_ADFIR_PHASE_N_TAPS // Length of AD FIR coefficients buffer - #define ASRC_NOMINAL_FS_SCALE (1 << ASRC_FS_RATIO_UNIT_BIT) // 2^28 + #define ASRC_ADFIR_COEFS_LENGTH FILTER_DEFS_ADFIR_PHASE_N_TAPS // Length of AD FIR coefficients buffer + #define ASRC_NOMINAL_FS_SCALE (1 << ASRC_FS_RATIO_UNIT_BIT) // Parameter values diff --git a/tests/asrc_test/dut/asrc_test.xc b/tests/asrc_test/dut/asrc_test.xc index 3c54a398..562237aa 100644 --- a/tests/asrc_test/dut/asrc_test.xc +++ b/tests/asrc_test/dut/asrc_test.xc @@ -58,7 +58,7 @@ void dsp_slave(chanend c_dsp) unsigned int n_samps_out = 0; //number of samples produced by last call to ASRC unsigned int n_samps_in_tot = 0; //Total number of input samples through ASRC - unsigned int FsRatio = ASRC_NOMINAL_FS_SCALE; //Deviation between in Fs and out Fs + uint64_t FsRatio = ASRC_NOMINAL_FS_SCALE; //Deviation between in Fs and out Fs for(int ui = 0; ui < ASRC_CHANNELS_PER_INSTANCE; ui++) unsafe { @@ -68,19 +68,6 @@ void dsp_slave(chanend c_dsp) asrc_ctrl[ui].piADCoefs = asrc_adfir_coefs.iASRCADFIRCoefs; } -/* - // Update Fs Ratio - for(int i = 0; i < ASRC_N_CHANNELS; i++) - { - // Make Fs Ratio deviate - asrc_ctrl[i].uiFsRatio = (unsigned int)((double)asrc_ctrl[i].uiFsRatio * fFsRatioDeviation); - if(ASRC_update_fs_ratio(&asrc_ctrl[i]) != ASRC_NO_ERROR) - { - printf("Error updating ASRC fs ratio\n"); - } - } -*/ - memset(out_buff, 0, ASRC_N_IN_SAMPLES * ASRC_N_OUT_IN_RATIO_MAX * ASRC_CHANNELS_PER_INSTANCE * sizeof(int)); while(1){ @@ -120,10 +107,10 @@ void dsp_slave(chanend c_dsp) unsigned InFs = (sr_in_out_new >> 16) & 0xffff; unsigned OutFs = sr_in_out_new & 0xffff; - unsigned nominal_FsRatio = asrc_init(InFs, OutFs, asrc_ctrl, ASRC_CHANNELS_PER_INSTANCE, ASRC_N_IN_SAMPLES, ASRC_DITHER_SETTING); + uint64_t nominal_FsRatio = asrc_init(InFs, OutFs, asrc_ctrl, ASRC_CHANNELS_PER_INSTANCE, ASRC_N_IN_SAMPLES, ASRC_DITHER_SETTING); sr_in_out = sr_in_out_new; - printf("DSP init Initial nominal_FsRatio=%d, SR in=%d, SR out=%d\n", nominal_FsRatio, InFs, OutFs); + printf("DSP init Initial nominal_FsRatio=%lld, SR in=%d, SR out=%d\n", nominal_FsRatio, InFs, OutFs); } t:> t1; n_samps_out = asrc_process(in_buff, out_buff, FsRatio, asrc_ctrl); @@ -139,10 +126,11 @@ void dsp_mgr(chanend c_dsp[], double fFsRatioDeviation){ unsigned count_in = 0, count_out = 0; unsigned iEndOfFile = 0; unsigned int sr_in_out = uiInFs << 16 | uiOutFs ; //Input fs in upper 16bits and Output fs in lower 16bits - unsigned FsRatio = (unsigned) (((unsigned long long)sample_rates[uiInFs] * (unsigned long long)(1<<28)) / (unsigned long long)sample_rates[uiOutFs]); - FsRatio = (unsigned int)((double)FsRatio * fFsRatioDeviation); //Ensure is precisely the same as golden value complete with trucation due to 32b float - printf("Adjusted FsRatio dsp_mgr = %d, 0x%x\n", FsRatio, FsRatio); + uint64_t FsRatio = (unsigned long long)(((double)sample_rates[uiInFs] / sample_rates[uiOutFs]) * ((unsigned long long)1 << (28 + 32))); + + FsRatio = (uint64_t)((double)FsRatio * fFsRatioDeviation); //Ensure is precisely the same as golden value complete with trucation due to 32b float + printf("Adjusted FsRatio dsp_mgr = %lld, 0x%llx\n", FsRatio, FsRatio); @@ -346,7 +334,7 @@ void ParseCmdLine(char *input, char * unsafe * argv, int ui) } } -int main(int argc, char * unsafe argv[]) +int main(unsigned int argc, char * unsafe argv[argc]) { int ui; diff --git a/tests/asrc_test/model/ASRC.c b/tests/asrc_test/model/ASRC.c index 60b9bb45..2a32941e 100644 --- a/tests/asrc_test/model/ASRC.c +++ b/tests/asrc_test/model/ASRC.c @@ -1,6 +1,6 @@ // =========================================================================== // =========================================================================== -// +// // File: ASRC.c // // Top level implementation file for the ASRC @@ -45,47 +45,84 @@ #define ASRC_FS_176_F (176400.0) #define ASRC_FS_192_F (192000.0) -#define ASRC_FS_RATIO_44_44 (unsigned int)((ASRC_FS_44_F / ASRC_FS_44_F) * ASRC_NOMINAL_FS_SCALE) -#define ASRC_FS_RATIO_44_48 (unsigned int)((ASRC_FS_44_F / ASRC_FS_48_F) * ASRC_NOMINAL_FS_SCALE) -#define ASRC_FS_RATIO_44_88 (unsigned int)((ASRC_FS_44_F / ASRC_FS_88_F) * ASRC_NOMINAL_FS_SCALE) -#define ASRC_FS_RATIO_44_96 (unsigned int)((ASRC_FS_44_F / ASRC_FS_96_F) * ASRC_NOMINAL_FS_SCALE) -#define ASRC_FS_RATIO_44_176 (unsigned int)((ASRC_FS_44_F / ASRC_FS_176_F) * ASRC_NOMINAL_FS_SCALE) -#define ASRC_FS_RATIO_44_192 (unsigned int)((ASRC_FS_44_F / ASRC_FS_192_F) * ASRC_NOMINAL_FS_SCALE) - -#define ASRC_FS_RATIO_48_44 (unsigned int)((ASRC_FS_48_F / ASRC_FS_44_F) * ASRC_NOMINAL_FS_SCALE) -#define ASRC_FS_RATIO_48_48 (unsigned int)((ASRC_FS_48_F / ASRC_FS_48_F) * ASRC_NOMINAL_FS_SCALE) -#define ASRC_FS_RATIO_48_88 (unsigned int)((ASRC_FS_48_F / ASRC_FS_88_F) * ASRC_NOMINAL_FS_SCALE) -#define ASRC_FS_RATIO_48_96 (unsigned int)((ASRC_FS_48_F / ASRC_FS_96_F) * ASRC_NOMINAL_FS_SCALE) -#define ASRC_FS_RATIO_48_176 (unsigned int)((ASRC_FS_48_F / ASRC_FS_176_F) * ASRC_NOMINAL_FS_SCALE) -#define ASRC_FS_RATIO_48_192 (unsigned int)((ASRC_FS_48_F / ASRC_FS_192_F) * ASRC_NOMINAL_FS_SCALE) - -#define ASRC_FS_RATIO_88_44 (unsigned int)((ASRC_FS_88_F / ASRC_FS_44_F) * ASRC_NOMINAL_FS_SCALE) -#define ASRC_FS_RATIO_88_48 (unsigned int)((ASRC_FS_88_F / ASRC_FS_48_F) * ASRC_NOMINAL_FS_SCALE) -#define ASRC_FS_RATIO_88_88 (unsigned int)((ASRC_FS_88_F / ASRC_FS_88_F) * ASRC_NOMINAL_FS_SCALE) -#define ASRC_FS_RATIO_88_96 (unsigned int)((ASRC_FS_88_F / ASRC_FS_96_F) * ASRC_NOMINAL_FS_SCALE) -#define ASRC_FS_RATIO_88_176 (unsigned int)((ASRC_FS_88_F / ASRC_FS_176_F) * ASRC_NOMINAL_FS_SCALE) -#define ASRC_FS_RATIO_88_192 (unsigned int)((ASRC_FS_88_F / ASRC_FS_192_F) * ASRC_NOMINAL_FS_SCALE) - -#define ASRC_FS_RATIO_96_44 (unsigned int)((ASRC_FS_96_F / ASRC_FS_44_F) * ASRC_NOMINAL_FS_SCALE) -#define ASRC_FS_RATIO_96_48 (unsigned int)((ASRC_FS_96_F / ASRC_FS_48_F) * ASRC_NOMINAL_FS_SCALE) -#define ASRC_FS_RATIO_96_88 (unsigned int)((ASRC_FS_96_F / ASRC_FS_88_F) * ASRC_NOMINAL_FS_SCALE) -#define ASRC_FS_RATIO_96_96 (unsigned int)((ASRC_FS_96_F / ASRC_FS_96_F) * ASRC_NOMINAL_FS_SCALE) -#define ASRC_FS_RATIO_96_176 (unsigned int)((ASRC_FS_96_F / ASRC_FS_176_F) * ASRC_NOMINAL_FS_SCALE) -#define ASRC_FS_RATIO_96_192 (unsigned int)((ASRC_FS_96_F / ASRC_FS_192_F) * ASRC_NOMINAL_FS_SCALE) - -#define ASRC_FS_RATIO_176_44 (unsigned int)((ASRC_FS_176_F / ASRC_FS_44_F) * ASRC_NOMINAL_FS_SCALE) -#define ASRC_FS_RATIO_176_48 (unsigned int)((ASRC_FS_176_F / ASRC_FS_48_F) * ASRC_NOMINAL_FS_SCALE) -#define ASRC_FS_RATIO_176_88 (unsigned int)((ASRC_FS_176_F / ASRC_FS_88_F) * ASRC_NOMINAL_FS_SCALE) -#define ASRC_FS_RATIO_176_96 (unsigned int)((ASRC_FS_176_F / ASRC_FS_96_F) * ASRC_NOMINAL_FS_SCALE) -#define ASRC_FS_RATIO_176_176 (unsigned int)((ASRC_FS_176_F / ASRC_FS_176_F) * ASRC_NOMINAL_FS_SCALE) -#define ASRC_FS_RATIO_176_192 (unsigned int)((ASRC_FS_176_F / ASRC_FS_192_F) * ASRC_NOMINAL_FS_SCALE) - -#define ASRC_FS_RATIO_192_44 (unsigned int)((ASRC_FS_192_F / ASRC_FS_44_F) * ASRC_NOMINAL_FS_SCALE) -#define ASRC_FS_RATIO_192_48 (unsigned int)((ASRC_FS_192_F / ASRC_FS_48_F) * ASRC_NOMINAL_FS_SCALE) -#define ASRC_FS_RATIO_192_88 (unsigned int)((ASRC_FS_192_F / ASRC_FS_88_F) * ASRC_NOMINAL_FS_SCALE) -#define ASRC_FS_RATIO_192_96 (unsigned int)((ASRC_FS_192_F / ASRC_FS_96_F) * ASRC_NOMINAL_FS_SCALE) -#define ASRC_FS_RATIO_192_176 (unsigned int)((ASRC_FS_192_F / ASRC_FS_176_F) * ASRC_NOMINAL_FS_SCALE) -#define ASRC_FS_RATIO_192_192 (unsigned int)((ASRC_FS_192_F / ASRC_FS_192_F) * ASRC_NOMINAL_FS_SCALE) +#define ASRC_FS_RATIO_44_44 (uint32_t)((unsigned long long)(((double)ASRC_FS_44_F / ASRC_FS_44_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_44_44_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_44_F / ASRC_FS_44_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_44_48 (uint32_t)((unsigned long long)(((double)ASRC_FS_44_F / ASRC_FS_48_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_44_48_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_44_F / ASRC_FS_48_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_44_88 (uint32_t)((unsigned long long)(((double)ASRC_FS_44_F / ASRC_FS_88_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_44_88_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_44_F / ASRC_FS_88_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_44_96 (uint32_t)((unsigned long long)(((double)ASRC_FS_44_F / ASRC_FS_96_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_44_96_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_44_F / ASRC_FS_96_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_44_176 (uint32_t)((unsigned long long)(((double)ASRC_FS_44_F / ASRC_FS_176_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_44_176_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_44_F / ASRC_FS_176_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_44_192 (uint32_t)((unsigned long long)(((double)ASRC_FS_44_F / ASRC_FS_192_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_44_192_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_44_F / ASRC_FS_192_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) + +#define ASRC_FS_RATIO_48_44 (uint32_t)((unsigned long long)(((double)ASRC_FS_48_F / ASRC_FS_44_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_48_44_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_48_F / ASRC_FS_44_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_48_48 (uint32_t)((unsigned long long)(((double)ASRC_FS_48_F / ASRC_FS_48_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_48_48_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_48_F / ASRC_FS_48_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_48_88 (uint32_t)((unsigned long long)(((double)ASRC_FS_48_F / ASRC_FS_88_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_48_88_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_48_F / ASRC_FS_88_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_48_96 (uint32_t)((unsigned long long)(((double)ASRC_FS_48_F / ASRC_FS_96_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_48_96_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_48_F / ASRC_FS_96_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_48_176 (uint32_t)((unsigned long long)(((double)ASRC_FS_48_F / ASRC_FS_176_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_48_176_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_48_F / ASRC_FS_176_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_48_192 (uint32_t)((unsigned long long)(((double)ASRC_FS_48_F / ASRC_FS_192_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_48_192_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_48_F / ASRC_FS_192_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) + +#define ASRC_FS_RATIO_88_44 (uint32_t)((unsigned long long)(((double)ASRC_FS_88_F / ASRC_FS_44_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_88_44_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_88_F / ASRC_FS_44_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_88_48 (uint32_t)((unsigned long long)(((double)ASRC_FS_88_F / ASRC_FS_48_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_88_48_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_88_F / ASRC_FS_48_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_88_88 (uint32_t)((unsigned long long)(((double)ASRC_FS_88_F / ASRC_FS_88_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_88_88_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_88_F / ASRC_FS_88_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_88_96 (uint32_t)((unsigned long long)(((double)ASRC_FS_88_F / ASRC_FS_96_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_88_96_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_88_F / ASRC_FS_96_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_88_176 (uint32_t)((unsigned long long)(((double)ASRC_FS_88_F / ASRC_FS_176_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_88_176_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_88_F / ASRC_FS_176_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_88_192 (uint32_t)((unsigned long long)(((double)ASRC_FS_88_F / ASRC_FS_192_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_88_192_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_88_F / ASRC_FS_192_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) + +#define ASRC_FS_RATIO_96_44 (uint32_t)((unsigned long long)(((double)ASRC_FS_96_F / ASRC_FS_44_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_96_44_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_96_F / ASRC_FS_44_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_96_48 (uint32_t)((unsigned long long)(((double)ASRC_FS_96_F / ASRC_FS_48_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_96_48_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_96_F / ASRC_FS_48_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_96_88 (uint32_t)((unsigned long long)(((double)ASRC_FS_96_F / ASRC_FS_88_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_96_88_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_96_F / ASRC_FS_88_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_96_96 (uint32_t)((unsigned long long)(((double)ASRC_FS_96_F / ASRC_FS_96_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_96_96_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_96_F / ASRC_FS_96_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_96_176 (uint32_t)((unsigned long long)(((double)ASRC_FS_96_F / ASRC_FS_176_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_96_176_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_96_F / ASRC_FS_176_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_96_192 (uint32_t)((unsigned long long)(((double)ASRC_FS_96_F / ASRC_FS_192_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_96_192_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_96_F / ASRC_FS_192_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) + +#define ASRC_FS_RATIO_176_44 (uint32_t)((unsigned long long)(((double)ASRC_FS_176_F / ASRC_FS_44_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_176_44_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_176_F / ASRC_FS_44_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_176_48 (uint32_t)((unsigned long long)(((double)ASRC_FS_176_F / ASRC_FS_48_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_176_48_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_176_F / ASRC_FS_48_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_176_88 (uint32_t)((unsigned long long)(((double)ASRC_FS_176_F / ASRC_FS_88_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_176_88_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_176_F / ASRC_FS_88_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_176_96 (uint32_t)((unsigned long long)(((double)ASRC_FS_176_F / ASRC_FS_96_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_176_96_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_176_F / ASRC_FS_96_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_176_176 (uint32_t)((unsigned long long)(((double)ASRC_FS_176_F / ASRC_FS_176_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_176_176_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_176_F / ASRC_FS_176_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_176_192 (uint32_t)((unsigned long long)(((double)ASRC_FS_176_F / ASRC_FS_192_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_176_192_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_176_F / ASRC_FS_192_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) + +#define ASRC_FS_RATIO_192_44 (uint32_t)((unsigned long long)(((double)ASRC_FS_192_F / ASRC_FS_44_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_192_44_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_192_F / ASRC_FS_44_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_192_48 (uint32_t)((unsigned long long)(((double)ASRC_FS_192_F / ASRC_FS_48_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_192_48_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_192_F / ASRC_FS_48_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_192_88 (uint32_t)((unsigned long long)(((double)ASRC_FS_192_F / ASRC_FS_88_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_192_88_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_192_F / ASRC_FS_88_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_192_96 (uint32_t)((unsigned long long)(((double)ASRC_FS_192_F / ASRC_FS_96_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_192_96_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_192_F / ASRC_FS_96_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_192_176 (uint32_t)((unsigned long long)(((double)ASRC_FS_192_F / ASRC_FS_176_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_192_176_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_192_F / ASRC_FS_176_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) +#define ASRC_FS_RATIO_192_192 (uint32_t)((unsigned long long)(((double)ASRC_FS_192_F / ASRC_FS_192_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32))) >> 32) +#define ASRC_FS_RATIO_192_192_LO (uint32_t)((unsigned long long)(((double)ASRC_FS_192_F / ASRC_FS_192_F) * ((unsigned long long)1 << (ASRC_FS_RATIO_UNIT_BIT + 32)))) + #define ASRC_FS_RATIO_MIN_FACTOR (0.99) #define ASRC_FS_RATIO_MAX_FACTOR (1.01) @@ -103,14 +140,14 @@ // Random number generator / dithering #define ASRC_R_CONS 32767 -#define ASRC_R_BASE 1664525 +#define ASRC_R_BASE 1664525 #define ASRC_RPDF_BITS_SHIFT 16 // Shift to select bits in pseudo-random number #define ASRC_RPDF_MASK 0x0000007F // For dithering at 24bits (in 2.30) #define ASRC_DATA24_MASK 0xFFFFFF00 // Mask for 24bits data (once rescaled to 1.31) #define ASRC_DITHER_BIAS 0xFFFFFFC0 // TPDF dither bias for compensating masking at 24bits but expressed in 2.30 -// Cycle counters +// Cycle counters #define ASRC_FIR_OS2_OVERHEAD_CYCLE_COUNT (15.0) #define ASRC_FIR_OS2_TAP_CYCLE_COUNT (2.125) #define ASRC_FIR_DS2_OVERHEAD_CYCLE_COUNT (15.0) @@ -124,7 +161,7 @@ #define ASRC_ADFIR_MACC_OVERHEAD_CYCLE_COUNT (8.0) #define ASRC_ADFIR_MACC_TAP_CYCLE_COUNT (2.5) -#define ASRC_DITHER_SAMPLE_COUNT (20.0) +#define ASRC_DITHER_SAMPLE_COUNT (20.0) @@ -137,7 +174,7 @@ ASRCFiltersIDs_t sFiltersIDs[ASRC_N_FS][ASRC_N_FS] = // Filter configuration table [Fsin][Fsout] { { // Fsin = 44.1kHz - // F1 F2 + // F1 F2 {FILTER_DEFS_FIR_UP_ID, FILTER_DEFS_FIR_NONE_ID}, // Fsout = 44.1kHz {FILTER_DEFS_FIR_UP_ID, FILTER_DEFS_FIR_NONE_ID}, // Fsout = 48kHz {FILTER_DEFS_FIR_UP_ID, FILTER_DEFS_FIR_NONE_ID}, // Fsout = 88.2kHz @@ -146,7 +183,7 @@ ASRCFiltersIDs_t sFiltersIDs[ASRC_N_FS][ASRC_N_FS] = // Filter configuration {FILTER_DEFS_FIR_UP_ID, FILTER_DEFS_FIR_NONE_ID} // Fsout = 192kHz }, { // Fsin = 48kHz - // F1 F2 + // F1 F2 {FILTER_DEFS_FIR_UP4844_ID, FILTER_DEFS_FIR_NONE_ID}, // Fsout = 44.1kHz {FILTER_DEFS_FIR_UP_ID, FILTER_DEFS_FIR_NONE_ID}, // Fsout = 48kHz {FILTER_DEFS_FIR_UP_ID, FILTER_DEFS_FIR_NONE_ID}, // Fsout = 88.2kHz @@ -155,7 +192,7 @@ ASRCFiltersIDs_t sFiltersIDs[ASRC_N_FS][ASRC_N_FS] = // Filter configuration {FILTER_DEFS_FIR_UP_ID, FILTER_DEFS_FIR_NONE_ID} // Fsout = 192kHz }, { // Fsin = 88.2kHz - // F1 F2 + // F1 F2 {FILTER_DEFS_FIR_BL_ID, FILTER_DEFS_FIR_NONE_ID}, // Fsout = 44.1kHz {FILTER_DEFS_FIR_BL8848_ID, FILTER_DEFS_FIR_NONE_ID}, // Fsout = 48kHz {FILTER_DEFS_FIR_UP_ID, FILTER_DEFS_FIR_NONE_ID}, // Fsout = 88.2kHz @@ -164,7 +201,7 @@ ASRCFiltersIDs_t sFiltersIDs[ASRC_N_FS][ASRC_N_FS] = // Filter configuration {FILTER_DEFS_FIR_UP_ID, FILTER_DEFS_FIR_NONE_ID} // Fsout = 192kHz }, { // Fsin = 96kHz - // F1 F2 + // F1 F2 {FILTER_DEFS_FIR_BL9644_ID, FILTER_DEFS_FIR_NONE_ID}, // Fsout = 44.1kHz {FILTER_DEFS_FIR_BL_ID, FILTER_DEFS_FIR_NONE_ID}, // Fsout = 48kHz {FILTER_DEFS_FIR_UP4844_ID, FILTER_DEFS_FIR_NONE_ID}, // Fsout = 88.2kHz @@ -173,7 +210,7 @@ ASRCFiltersIDs_t sFiltersIDs[ASRC_N_FS][ASRC_N_FS] = // Filter configuration {FILTER_DEFS_FIR_UP_ID, FILTER_DEFS_FIR_NONE_ID} // Fsout = 192kHz }, { // Fsin = 176.4kHz - // F1 F2 + // F1 F2 {FILTER_DEFS_FIR_DS_ID, FILTER_DEFS_FIR_BL_ID}, // Fsout = 44.1kHz {FILTER_DEFS_FIR_DS_ID, FILTER_DEFS_FIR_BL8848_ID}, // Fsout = 48kHz {FITLER_DEFS_FIR_BLF_ID, FILTER_DEFS_FIR_NONE_ID,}, // Fsout = 88.2kHz @@ -182,7 +219,7 @@ ASRCFiltersIDs_t sFiltersIDs[ASRC_N_FS][ASRC_N_FS] = // Filter configuration {FILTER_DEFS_FIR_UPF_ID, FILTER_DEFS_FIR_NONE_ID} // Fsout = 192kHz }, { // Fsin = 192kHz - // F1 F2 + // F1 F2 {FILTER_DEFS_FIR_DS_ID, FILTER_DEFS_FIR_BL9644_ID}, // Fsout = 44.1kHz {FILTER_DEFS_FIR_DS_ID, FILTER_DEFS_FIR_BL_ID}, // Fsout = 48kHz {FITLER_DEFS_FIR_BL19288_ID, FILTER_DEFS_FIR_NONE_ID}, // Fsout = 88.2kHz @@ -192,62 +229,61 @@ ASRCFiltersIDs_t sFiltersIDs[ASRC_N_FS][ASRC_N_FS] = // Filter configuration } }; - ASRCFsRatioConfigs_t sFsRatioConfigs[ASRC_N_FS][ASRC_N_FS] = // Fs ratio configuration table [Fsin][Fsout] { { // Fsin = 44.1kHz // Nominal Fs Ratio // Minimal Fs Ratio // Maximal Fs Ratio Shift for time step - {ASRC_FS_RATIO_44_44, (unsigned int)(ASRC_FS_RATIO_44_44 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_44_44 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 44.1kHz - {ASRC_FS_RATIO_44_48, (unsigned int)(ASRC_FS_RATIO_44_48 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_44_48 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 48kHz - {ASRC_FS_RATIO_44_88, (unsigned int)(ASRC_FS_RATIO_44_88 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_44_88 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 88.2kHz - {ASRC_FS_RATIO_44_96, (unsigned int)(ASRC_FS_RATIO_44_96 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_44_96 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 96kHz - {ASRC_FS_RATIO_44_176, (unsigned int)(ASRC_FS_RATIO_44_176 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_44_176 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 176.4kHz - {ASRC_FS_RATIO_44_192, (unsigned int)(ASRC_FS_RATIO_44_192 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_44_192 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1} // Fsout = 192kHz + {ASRC_FS_RATIO_44_44, ASRC_FS_RATIO_44_44_LO, (unsigned int)(ASRC_FS_RATIO_44_44 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_44_44 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 44.1kHz + {ASRC_FS_RATIO_44_48, ASRC_FS_RATIO_44_48_LO, (unsigned int)(ASRC_FS_RATIO_44_48 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_44_48 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 48kHz + {ASRC_FS_RATIO_44_88, ASRC_FS_RATIO_44_88_LO, (unsigned int)(ASRC_FS_RATIO_44_88 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_44_88 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 88.2kHz + {ASRC_FS_RATIO_44_96, ASRC_FS_RATIO_44_96_LO, (unsigned int)(ASRC_FS_RATIO_44_96 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_44_96 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 96kHz + {ASRC_FS_RATIO_44_176, ASRC_FS_RATIO_44_176_LO, (unsigned int)(ASRC_FS_RATIO_44_176 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_44_176 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 176.4kHz + {ASRC_FS_RATIO_44_192, ASRC_FS_RATIO_44_192_LO, (unsigned int)(ASRC_FS_RATIO_44_192 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_44_192 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1} // Fsout = 192kHz }, { // Fsin = 48kHz // Nominal Fs Ratio // Minimal Fs Ratio // Maximal Fs Ratio Shift for time step - {ASRC_FS_RATIO_48_44, (unsigned int)(ASRC_FS_RATIO_48_44 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_48_44 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 44.1kHz - {ASRC_FS_RATIO_48_48, (unsigned int)(ASRC_FS_RATIO_48_48 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_48_48 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 48kHz - {ASRC_FS_RATIO_48_88, (unsigned int)(ASRC_FS_RATIO_48_88 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_48_88 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 88.2kHz - {ASRC_FS_RATIO_48_96, (unsigned int)(ASRC_FS_RATIO_48_96 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_48_96 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 96kHz - {ASRC_FS_RATIO_48_176, (unsigned int)(ASRC_FS_RATIO_48_176 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_48_176 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 176.4kHz - {ASRC_FS_RATIO_48_192, (unsigned int)(ASRC_FS_RATIO_48_192 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_48_192 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1} // Fsout = 192kHz + {ASRC_FS_RATIO_48_44, ASRC_FS_RATIO_48_44_LO, (unsigned int)(ASRC_FS_RATIO_48_44 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_48_44 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 44.1kHz + {ASRC_FS_RATIO_48_48, ASRC_FS_RATIO_48_48_LO, (unsigned int)(ASRC_FS_RATIO_48_48 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_48_48 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 48kHz + {ASRC_FS_RATIO_48_88, ASRC_FS_RATIO_48_88_LO, (unsigned int)(ASRC_FS_RATIO_48_88 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_48_88 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 88.2kHz + {ASRC_FS_RATIO_48_96, ASRC_FS_RATIO_48_96_LO, (unsigned int)(ASRC_FS_RATIO_48_96 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_48_96 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 96kHz + {ASRC_FS_RATIO_48_176, ASRC_FS_RATIO_48_176_LO, (unsigned int)(ASRC_FS_RATIO_48_176 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_48_176 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 176.4kHz + {ASRC_FS_RATIO_48_192, ASRC_FS_RATIO_48_192_LO, (unsigned int)(ASRC_FS_RATIO_48_192 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_48_192 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1} // Fsout = 192kHz }, { // Fsin = 88.2kHz // Nominal Fs Ratio // Minimal Fs Ratio // Maximal Fs Ratio Shift for time step - {ASRC_FS_RATIO_88_44, (unsigned int)(ASRC_FS_RATIO_88_44 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_88_44 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_0}, // Fsout = 44.1kHz - {ASRC_FS_RATIO_88_48, (unsigned int)(ASRC_FS_RATIO_88_48 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_88_48 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_0}, // Fsout = 48kHz - {ASRC_FS_RATIO_88_88, (unsigned int)(ASRC_FS_RATIO_88_88 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_88_88 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 88.2kHz - {ASRC_FS_RATIO_88_96, (unsigned int)(ASRC_FS_RATIO_88_96 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_88_96 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 96kHz - {ASRC_FS_RATIO_88_176, (unsigned int)(ASRC_FS_RATIO_88_176 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_88_176 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 176.4kHz - {ASRC_FS_RATIO_88_192, (unsigned int)(ASRC_FS_RATIO_88_192 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_88_192 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1} // Fsout = 192kHz + {ASRC_FS_RATIO_88_44, ASRC_FS_RATIO_88_44_LO, (unsigned int)(ASRC_FS_RATIO_88_44 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_88_44 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_0}, // Fsout = 44.1kHz + {ASRC_FS_RATIO_88_48, ASRC_FS_RATIO_88_48_LO, (unsigned int)(ASRC_FS_RATIO_88_48 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_88_48 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_0}, // Fsout = 48kHz + {ASRC_FS_RATIO_88_88, ASRC_FS_RATIO_88_88_LO, (unsigned int)(ASRC_FS_RATIO_88_88 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_88_88 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 88.2kHz + {ASRC_FS_RATIO_88_96, ASRC_FS_RATIO_88_96_LO, (unsigned int)(ASRC_FS_RATIO_88_96 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_88_96 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 96kHz + {ASRC_FS_RATIO_88_176, ASRC_FS_RATIO_88_176_LO, (unsigned int)(ASRC_FS_RATIO_88_176 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_88_176 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 176.4kHz + {ASRC_FS_RATIO_88_192, ASRC_FS_RATIO_88_192_LO, (unsigned int)(ASRC_FS_RATIO_88_192 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_88_192 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1} // Fsout = 192kHz }, { // Fsin = 96kHz // Nominal Fs Ratio // Minimal Fs Ratio // Maximal Fs Ratio Shift for time step - {ASRC_FS_RATIO_96_44, (unsigned int)(ASRC_FS_RATIO_96_44 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_96_44 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_0}, // Fsout = 44.1kHz - {ASRC_FS_RATIO_96_48, (unsigned int)(ASRC_FS_RATIO_96_48 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_96_48 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_0}, // Fsout = 48kHz - {ASRC_FS_RATIO_96_88, (unsigned int)(ASRC_FS_RATIO_96_88 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_96_88 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 88.2kHz - {ASRC_FS_RATIO_96_96, (unsigned int)(ASRC_FS_RATIO_96_96 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_96_96 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 96kHz - {ASRC_FS_RATIO_96_176, (unsigned int)(ASRC_FS_RATIO_96_176 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_96_176 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 176.4kHz - {ASRC_FS_RATIO_96_192, (unsigned int)(ASRC_FS_RATIO_96_192 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_96_192 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1} // Fsout = 192kHz + {ASRC_FS_RATIO_96_44, ASRC_FS_RATIO_96_44_LO, (unsigned int)(ASRC_FS_RATIO_96_44 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_96_44 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_0}, // Fsout = 44.1kHz + {ASRC_FS_RATIO_96_48, ASRC_FS_RATIO_96_48_LO, (unsigned int)(ASRC_FS_RATIO_96_48 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_96_48 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_0}, // Fsout = 48kHz + {ASRC_FS_RATIO_96_88, ASRC_FS_RATIO_96_88_LO, (unsigned int)(ASRC_FS_RATIO_96_88 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_96_88 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 88.2kHz + {ASRC_FS_RATIO_96_96, ASRC_FS_RATIO_96_96_LO, (unsigned int)(ASRC_FS_RATIO_96_96 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_96_96 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 96kHz + {ASRC_FS_RATIO_96_176, ASRC_FS_RATIO_96_176_LO, (unsigned int)(ASRC_FS_RATIO_96_176 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_96_176 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 176.4kHz + {ASRC_FS_RATIO_96_192, ASRC_FS_RATIO_96_192_LO, (unsigned int)(ASRC_FS_RATIO_96_192 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_96_192 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1} // Fsout = 192kHz }, { // Fsin = 176.4kHz // Nominal Fs Ratio // Minimal Fs Ratio // Maximal Fs Ratio Shift for time step - {ASRC_FS_RATIO_176_44, (unsigned int)(ASRC_FS_RATIO_176_44 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_176_44 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_M1}, // Fsout = 44.1kHz - {ASRC_FS_RATIO_176_48, (unsigned int)(ASRC_FS_RATIO_176_48 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_176_48 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_M1}, // Fsout = 48kHz - {ASRC_FS_RATIO_176_88, (unsigned int)(ASRC_FS_RATIO_176_88 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_176_88 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_0}, // Fsout = 88.2kHz - {ASRC_FS_RATIO_176_96, (unsigned int)(ASRC_FS_RATIO_176_96 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_176_96 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_0}, // Fsout = 96kHz - {ASRC_FS_RATIO_176_176, (unsigned int)(ASRC_FS_RATIO_176_176 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_176_176 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 176.4kHz - {ASRC_FS_RATIO_176_192, (unsigned int)(ASRC_FS_RATIO_176_192 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_176_192 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1} // Fsout = 192kHz + {ASRC_FS_RATIO_176_44, ASRC_FS_RATIO_176_44_LO, (unsigned int)(ASRC_FS_RATIO_176_44 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_176_44 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_M1}, // Fsout = 44.1kHz + {ASRC_FS_RATIO_176_48, ASRC_FS_RATIO_176_48_LO, (unsigned int)(ASRC_FS_RATIO_176_48 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_176_48 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_M1}, // Fsout = 48kHz + {ASRC_FS_RATIO_176_88, ASRC_FS_RATIO_176_88_LO, (unsigned int)(ASRC_FS_RATIO_176_88 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_176_88 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_0}, // Fsout = 88.2kHz + {ASRC_FS_RATIO_176_96, ASRC_FS_RATIO_176_96_LO, (unsigned int)(ASRC_FS_RATIO_176_96 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_176_96 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_0}, // Fsout = 96kHz + {ASRC_FS_RATIO_176_176, ASRC_FS_RATIO_176_176_LO, (unsigned int)(ASRC_FS_RATIO_176_176 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_176_176 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 176.4kHz + {ASRC_FS_RATIO_176_192, ASRC_FS_RATIO_176_192_LO, (unsigned int)(ASRC_FS_RATIO_176_192 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_176_192 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1} // Fsout = 192kHz }, { // Fsin = 192kHz // Nominal Fs Ratio // Minimal Fs Ratio // Maximal Fs Ratio Shift for time step - {ASRC_FS_RATIO_192_44, (unsigned int)(ASRC_FS_RATIO_192_44 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_192_44 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_M1}, // Fsout = 44.1kHz - {ASRC_FS_RATIO_192_48, (unsigned int)(ASRC_FS_RATIO_192_48 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_192_48 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_M1}, // Fsout = 48kHz - {ASRC_FS_RATIO_192_88, (unsigned int)(ASRC_FS_RATIO_192_88 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_192_88 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_0}, // Fsout = 88.2kHz - {ASRC_FS_RATIO_192_96, (unsigned int)(ASRC_FS_RATIO_192_96 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_192_96 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_0}, // Fsout = 96kHz - {ASRC_FS_RATIO_192_176, (unsigned int)(ASRC_FS_RATIO_192_176 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_192_176 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 176.4kHz - {ASRC_FS_RATIO_192_192, (unsigned int)(ASRC_FS_RATIO_192_192 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_192_192 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1} // Fsout = 192kHz + {ASRC_FS_RATIO_192_44, ASRC_FS_RATIO_192_44_LO, (unsigned int)(ASRC_FS_RATIO_192_44 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_192_44 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_M1}, // Fsout = 44.1kHz + {ASRC_FS_RATIO_192_48, ASRC_FS_RATIO_192_48_LO, (unsigned int)(ASRC_FS_RATIO_192_48 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_192_48 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_M1}, // Fsout = 48kHz + {ASRC_FS_RATIO_192_88, ASRC_FS_RATIO_192_88_LO, (unsigned int)(ASRC_FS_RATIO_192_88 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_192_88 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_0}, // Fsout = 88.2kHz + {ASRC_FS_RATIO_192_96, ASRC_FS_RATIO_192_96_LO, (unsigned int)(ASRC_FS_RATIO_192_96 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_192_96 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_0}, // Fsout = 96kHz + {ASRC_FS_RATIO_192_176, ASRC_FS_RATIO_192_176_LO, (unsigned int)(ASRC_FS_RATIO_192_176 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_192_176 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1}, // Fsout = 176.4kHz + {ASRC_FS_RATIO_192_192, ASRC_FS_RATIO_192_192_LO, (unsigned int)(ASRC_FS_RATIO_192_192 * ASRC_FS_RATIO_MIN_FACTOR), (unsigned int)(ASRC_FS_RATIO_192_192 * ASRC_FS_RATIO_MAX_FACTOR), ASRC_FS_RATIO_SHIFT_P1} // Fsout = 192kHz } }; @@ -289,7 +325,7 @@ ASRCReturnCodes_t ASRC_prepare_coefs(void) // Zero fill last coefficient iADFirCoefs[ui][FILTER_DEFS_ADFIR_PHASE_N_TAPS - 1] = 0; } - + // Then fill in the two phases which start delayed for(ui = 0; ui < 2; ui++) { @@ -310,7 +346,7 @@ ASRCReturnCodes_t ASRC_prepare_coefs(void) // ASRC_ERROR on failure // // Description: Inits the ASRC passed as argument // // ==================================================================== // -ASRCReturnCodes_t ASRC_init(ASRCCtrl_t* psASRCCtrl) +ASRCReturnCodes_t ASRC_init(ASRCCtrl_t* psASRCCtrl) { ASRCFiltersIDs_t* psFiltersID; FIRDescriptor_t* psFIRDescriptor; @@ -333,6 +369,7 @@ ASRCReturnCodes_t ASRC_init(ASRCCtrl_t* psASRCCtrl) // Set nominal fs ratio psASRCCtrl->uiFsRatio = sFsRatioConfigs[psASRCCtrl->eInFs][psASRCCtrl->eOutFs].uiNominalFsRatio; + psASRCCtrl->uiFsRatio_lsb = sFsRatioConfigs[psASRCCtrl->eInFs][psASRCCtrl->eOutFs].uiNominalFsRatio_lo; // Check that number of input samples is allocated and is a multiple of 4 if(psASRCCtrl->uiNInSamples == 0) @@ -342,10 +379,10 @@ ASRCReturnCodes_t ASRC_init(ASRCCtrl_t* psASRCCtrl) // Load filters ID and number of samples psFiltersID = &sFiltersIDs[psASRCCtrl->eInFs][psASRCCtrl->eOutFs]; - + // Configure filters F1 and F2 from filters ID and number of samples - + // Filter F1 // --------- psFIRDescriptor = &sFirDescriptor[psFiltersID->uiFID[ASRC_F1_INDEX]]; @@ -367,7 +404,7 @@ ASRCReturnCodes_t ASRC_init(ASRCCtrl_t* psASRCCtrl) // Update synchronous number of samples if( psFiltersID->uiFID[ASRC_F1_INDEX] != FILTER_DEFS_FIR_NONE_ID ) psASRCCtrl->uiNSyncSamples = psASRCCtrl->sFIRF1Ctrl.uiNOutSamples; - + // Filter F2 // --------- @@ -379,7 +416,7 @@ ASRCReturnCodes_t ASRC_init(ASRCCtrl_t* psASRCCtrl) psASRCCtrl->sFIRF2Ctrl.piDelayB = psASRCCtrl->psState->iDelayFIRLong; // Set output buffer step psASRCCtrl->sFIRF2Ctrl.uiOutStep = ASRC_N_CHANNELS; - + // Call init for FIR F2 if(FIR_init_from_desc(&psASRCCtrl->sFIRF2Ctrl, psFIRDescriptor) != FIR_NO_ERROR) return FIR_ERROR; @@ -387,7 +424,7 @@ ASRCReturnCodes_t ASRC_init(ASRCCtrl_t* psASRCCtrl) // Update synchronous number of samples if( psFiltersID->uiFID[ASRC_F2_INDEX] != FILTER_DEFS_FIR_NONE_ID ) psASRCCtrl->uiNSyncSamples = psASRCCtrl->sFIRF2Ctrl.uiNOutSamples; - + // Setup fixed input/output buffers for F1 and F2 // ---------------------------------------------- @@ -402,12 +439,12 @@ ASRCReturnCodes_t ASRC_init(ASRCCtrl_t* psASRCCtrl) // Filter F3 // --------- psADFIRDescriptor = &sADFirDescriptor; - + // Set delay line base pointer psASRCCtrl->sADFIRF3Ctrl.piDelayB = psASRCCtrl->psState->iDelayADFIR; - // Set AD coefficients pointer + // Set AD coefficients pointer psASRCCtrl->sADFIRF3Ctrl.piADCoefs = psASRCCtrl->piADCoefs; - + // Call init for ADFIR F3 if(ADFIR_init_from_desc(&psASRCCtrl->sADFIRF3Ctrl, psADFIRDescriptor) != FIR_NO_ERROR) return FIR_ERROR; @@ -428,7 +465,7 @@ ASRCReturnCodes_t ASRC_init(ASRCCtrl_t* psASRCCtrl) // Description: Syncs the ASRC passed as argument // // ==================================================================== // ASRCReturnCodes_t ASRC_sync(ASRCCtrl_t* psASRCCtrl) -{ +{ // Sync the FIR and ADFIR if(FIR_sync(&psASRCCtrl->sFIRF1Ctrl) != FIR_NO_ERROR) return ASRC_ERROR; @@ -457,7 +494,7 @@ ASRCReturnCodes_t ASRC_sync(ASRCCtrl_t* psASRCCtrl) return ASRC_NO_ERROR; } - + // ==================================================================== // // Function: ASRC_proc_F1_F2 // @@ -493,7 +530,7 @@ ASRCReturnCodes_t ASRC_proc_F1_F2(ASRCCtrl_t* psASRCCtrl) psASRCCtrl->fCycleCountF1F2 += psASRCCtrl->uiNInSamples * ( ASRC_FIR_SYNC_OVERHEAD_CYCLE_COUNT + (psASRCCtrl->sFIRF1Ctrl.uiNCoefs * ASRC_FIR_SYNC_TAP_CYCLE_COUNT) ); - + // Check if F2 is enabled if(psASRCCtrl->sFIRF2Ctrl.eEnable == FIR_ON) { @@ -529,6 +566,7 @@ ASRCReturnCodes_t ASRC_proc_F1_F2(ASRCCtrl_t* psASRCCtrl) ASRCReturnCodes_t ASRC_update_fs_ratio(ASRCCtrl_t* psASRCCtrl) { unsigned int uiFsRatio = psASRCCtrl->uiFsRatio; + unsigned int uiFsRatio_low = psASRCCtrl->uiFsRatio_lsb; // Check for bounds of new Fs ratio if( (uiFsRatio < sFsRatioConfigs[psASRCCtrl->eInFs][psASRCCtrl->eOutFs].uiMinFsRatio) || @@ -536,8 +574,9 @@ ASRCReturnCodes_t ASRC_update_fs_ratio(ASRCCtrl_t* psASRCCtrl) return ASRC_ERROR; // Apply shift to time ratio to build integer and fractional parts of time step - psASRCCtrl->iTimeStepInt = uiFsRatio >> (sFsRatioConfigs[psASRCCtrl->eInFs][psASRCCtrl->eOutFs].iFsRatioShift); + psASRCCtrl->iTimeStepInt = uiFsRatio >> (sFsRatioConfigs[psASRCCtrl->eInFs][psASRCCtrl->eOutFs].iFsRatioShift); psASRCCtrl->uiTimeStepFract = uiFsRatio << (32 - sFsRatioConfigs[psASRCCtrl->eInFs][psASRCCtrl->eOutFs].iFsRatioShift); + psASRCCtrl->uiTimeStepFract |= (uint32_t)(uiFsRatio_low >> sFsRatioConfigs[psASRCCtrl->eInFs][psASRCCtrl->eOutFs].iFsRatioShift); return ASRC_NO_ERROR; } @@ -590,7 +629,7 @@ ASRCReturnCodes_t ASRC_proc_F3_time(ASRCCtrl_t* psASRCCtrl) int* piPhase1; int* piPhase2; int* piADCoefs; - + // Check if the next output time instant is in the current time slot // ----------------------------------------------------------------- // if not return value showing that no output sample needs to be produced @@ -608,7 +647,7 @@ ASRCReturnCodes_t ASRC_proc_F3_time(ASRCCtrl_t* psASRCCtrl) // Set register to zero iZero = 0; - + // Compute adative coefficients spline factors // The fractional part of time gives alpha iAlpha = psASRCCtrl->uiTimeFract>>1; // Now alpha can be seen as a signed number @@ -620,7 +659,7 @@ ASRCReturnCodes_t ASRC_proc_F3_time(ASRCCtrl_t* psASRCCtrl) iH1 = iH1 + iAlpha; // H1 = 0.5 + alpha - alpha * alpha; iH2 = iH2 - iAlpha; // H2 = 0.5 - alpha iH2 = iH2 + iH0; // H2 = 0.5 - alpha + 0.5 * alpha * alpha - + // The integer part of time gives the phase piPhase0 = iADFirCoefs[psASRCCtrl->iTimeInt]; piPhase1 = piPhase0 + FILTER_DEFS_ADFIR_PHASE_N_TAPS; @@ -660,7 +699,7 @@ ASRCReturnCodes_t ASRC_proc_F3_time(ASRCCtrl_t* psASRCCtrl) // Step time for next output sample // -------------------------------- // Step to next output time (add integer and fractional parts) - psASRCCtrl->iTimeInt += psASRCCtrl->iTimeStepInt; + psASRCCtrl->iTimeInt += psASRCCtrl->iTimeStepInt; // For fractional part, this can be optimized using the add with carry instruction of XS2 uiTemp = psASRCCtrl->uiTimeFract; psASRCCtrl->uiTimeFract += psASRCCtrl->uiTimeStepFract; @@ -693,7 +732,7 @@ ASRCReturnCodes_t ASRC_proc_F3_macc(ASRCCtrl_t* psASRCCtrl, int* piOutSample) return ASRC_ERROR; psASRCCtrl->uiNASRCOutSamples++; - + // Cycle counter estimation psASRCCtrl->fCycleCountF3 += ASRC_ADFIR_MACC_OVERHEAD_CYCLE_COUNT + (psASRCCtrl->sADFIRF3Ctrl.uiNLoops * 2.0 * ASRC_ADFIR_MACC_TAP_CYCLE_COUNT); diff --git a/tests/asrc_test/model/ASRC.h b/tests/asrc_test/model/ASRC.h index 002c4f74..53476815 100644 --- a/tests/asrc_test/model/ASRC.h +++ b/tests/asrc_test/model/ASRC.h @@ -1,6 +1,6 @@ // =========================================================================== // =========================================================================== -// +// // File: ASRC.h // // Top level definition file for the ASRC @@ -27,7 +27,7 @@ // Defines // // =========================================================================== - + // General defines // --------------- #define ASRC_N_CHANNELS 1 // Number of channels processed by ASRC instance @@ -44,7 +44,7 @@ // ---------------- #define ASRC_ON 1 #define ASRC_OFF 0 - + #define ASRC_DITHER_OFF ASRC_OFF #define ASRC_DITHER_ON ASRC_ON #define ASRC_DITHER_ON_OFF_MIN ASRC_DITHER_OFF @@ -58,7 +58,7 @@ // Defines // // =========================================================================== - + // =========================================================================== // @@ -71,16 +71,16 @@ // ASRC Return Codes // ----------------- - typedef enum _ASRCReturnCodes + typedef enum _ASRCReturnCodes { ASRC_NO_ERROR = 0, ASRC_ERROR = 1 } ASRCReturnCodes_t; - + // Sampling rate codes // ------------------- - typedef enum _ASRCFs + typedef enum _ASRCFs { ASRC_FS_44 = 0, // Fs = 44.1kHz code ASRC_FS_48 = 1, // Fs = 48kHz code @@ -93,14 +93,14 @@ #define ASRC_FS_MIN ASRC_FS_44 #define ASRC_FS_MAX ASRC_FS_192 - + // ASRC Filters IDs structure // -------------------------- #define ASRC_F1_INDEX 0 #define ASRC_F2_INDEX 1 #define ASRC_N_F (ASRC_F2_INDEX + 1) - typedef struct _ASRCFiltersIDs + typedef struct _ASRCFiltersIDs { unsigned int uiFID[ASRC_N_F]; } ASRCFiltersIDs_t; @@ -110,6 +110,7 @@ typedef struct _ASRCFsRatioConfigs { unsigned int uiNominalFsRatio; + unsigned int uiNominalFsRatio_lo; unsigned int uiMinFsRatio; unsigned int uiMaxFsRatio; int iFsRatioShift; @@ -117,24 +118,24 @@ // ASRC State structure // -------------------- - typedef struct _ASRCState + typedef struct _ASRCState { unsigned int uiRndSeed; // Dither random seeds current values int iDelayFIRLong[2 * FILTER_DEFS_FIR_MAX_TAPS_LONG]; // Doubled length for circular buffer simulation int iDelayFIRShort[2 * FILTER_DEFS_FIR_MAX_TAPS_SHORT]; // Doubled length for circular buffer simulation int iDelayADFIR[2 * FILTER_DEFS_ADFIR_PHASE_N_TAPS]; // Doubled length for circular buffer simulation } ASRCState_t; - + // ASRC Control structure // ---------------------- - typedef struct _ASRCCtrl + typedef struct _ASRCCtrl { int* piIn; // Input buffer pointer (PCM, 32bits, 2 channels time domain interleaved data) unsigned int uiNInSamples; // Number of input samples to process in one call to the processing function unsigned int uiNSyncSamples; // Number of synchronous samples produced in one call to the processing function ASRCFs_t eInFs; // Input sampling rate code - int* piOut; // Output buffer poin ter (PCM, 32bits, 2 channels time domain interleaved data) + int* piOut; // Output buffer poin ter (PCM, 32bits, 2 channels time domain interleaved data) unsigned int uiNASRCOutSamples; // Number of output samples produced during last call to the asynchronous processing function ASRCFs_t eOutFs; // Output sampling rate code @@ -143,12 +144,13 @@ ADFIRCtrl_t sADFIRF3Ctrl; // F3 ADFIR controller unsigned int uiFsRatio; // Fs ratio: Fsin / Fsout + unsigned int uiFsRatio_lsb; int iTimeInt; // Integer part of time unsigned int uiTimeFract; // Fractional part of time int iTimeStepInt; // Integer part of time step unsigned int uiTimeStepFract; // Fractional part of time step - + unsigned int uiDitherOnOff; // Dither on/off flag unsigned int uiRndSeedInit; // Dither random seed initial value @@ -186,7 +188,7 @@ // ASRC_ERROR on failure // // Description: Inits the ASRC passed as argument // // ==================================================================== // - ASRCReturnCodes_t ASRC_init(ASRCCtrl_t* psASRCCtrl); + ASRCReturnCodes_t ASRC_init(ASRCCtrl_t* psASRCCtrl); // ==================================================================== // // Function: ASRC_sync // @@ -252,7 +254,7 @@ // Description: Processes dither for a channel // // ==================================================================== // ASRCReturnCodes_t ASRC_proc_dither(ASRCCtrl_t* psASRCCtrl); - + #endif // nINCLUDE_FROM_ASM -#endif // _ASRC_H_ \ No newline at end of file +#endif // _ASRC_H_ diff --git a/tests/asrc_test/model/Main.c b/tests/asrc_test/model/Main.c index 3c9c7f05..e4c633fe 100644 --- a/tests/asrc_test/model/Main.c +++ b/tests/asrc_test/model/Main.c @@ -125,7 +125,7 @@ unsigned int uiFsTable[ASRC_N_FS] = {44100, 48000, 88200, 96000, 176400, 192000} -void main(int argc, char *argv[]) +int main(int argc, char *argv[]) { int *piIn, *piOut; int iNRemainingSamples; @@ -292,7 +292,10 @@ void main(int argc, char *argv[]) for(ui = 0; ui < ASRC_N_IO_CHANNELS; ui++) { // Make Fs Ratio deviate - sASRCCtrl[ui].uiFsRatio = (unsigned int)(sASRCCtrl[ui].uiFsRatio * fFsRatioDeviation); + unsigned long long fs_ratio_full = ((unsigned long long)sASRCCtrl[ui].uiFsRatio << 32) | ((unsigned long long)sASRCCtrl[ui].uiFsRatio_lsb); + fs_ratio_full = (unsigned long long)(fs_ratio_full * fFsRatioDeviation); + sASRCCtrl[ui].uiFsRatio = (uint32_t)(fs_ratio_full >> 32); + sASRCCtrl[ui].uiFsRatio_lsb = (uint32_t)fs_ratio_full; if(ASRC_update_fs_ratio(&sASRCCtrl[ui]) != ASRC_NO_ERROR) { sprintf(pzError, "Error at ASRC update fs ratio"); @@ -440,7 +443,7 @@ void main(int argc, char *argv[]) fprintf(stdout, "Application run finished, press any key to exit\n\n"); getchar(); - exit(0); + return 0; } From c0a59cb723c9c2506942b09f956339ffbe255345 Mon Sep 17 00:00:00 2001 From: Shuchita Khare Date: Tue, 5 Sep 2023 11:01:08 +0100 Subject: [PATCH 3/5] Renamed uiFsRatio_lsb to uiFsRatio_lo --- lib_src/src/multirate_hifi/asrc/src_mrhf_asrc.c | 4 ++-- lib_src/src/multirate_hifi/asrc/src_mrhf_asrc.h | 4 ++-- lib_src/src/multirate_hifi/asrc/src_mrhf_asrc_wrapper.c | 4 ++-- tests/asrc_test/model/ASRC.c | 4 ++-- tests/asrc_test/model/ASRC.h | 2 +- tests/asrc_test/model/Main.c | 4 ++-- 6 files changed, 11 insertions(+), 11 deletions(-) diff --git a/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc.c b/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc.c index fca10db6..a273139f 100644 --- a/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc.c +++ b/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc.c @@ -349,7 +349,7 @@ ASRCReturnCodes_t ASRC_init(asrc_ctrl_t* pasrc_ctrl) // Set nominal fs ratio pasrc_ctrl->uiFsRatio = sFsRatioConfigs[pasrc_ctrl->eInFs][pasrc_ctrl->eOutFs].uiNominalFsRatio; - pasrc_ctrl->uiFsRatio_lsb = sFsRatioConfigs[pasrc_ctrl->eInFs][pasrc_ctrl->eOutFs].uiNominalFsRatio_lo; + pasrc_ctrl->uiFsRatio_lo = sFsRatioConfigs[pasrc_ctrl->eInFs][pasrc_ctrl->eOutFs].uiNominalFsRatio_lo; // Check that number of input samples is allocated and is a multiple of 4 if(pasrc_ctrl->uiNInSamples == 0) @@ -512,7 +512,7 @@ ASRCReturnCodes_t ASRC_proc_F1_F2(asrc_ctrl_t* pasrc_ctrl) ASRCReturnCodes_t ASRC_update_fs_ratio(asrc_ctrl_t* pasrc_ctrl) { unsigned int uiFsRatio = pasrc_ctrl->uiFsRatio; - unsigned int uiFsRatio_low = pasrc_ctrl->uiFsRatio_lsb; + unsigned int uiFsRatio_low = pasrc_ctrl->uiFsRatio_lo; // Check for bounds of new Fs ratio if( (uiFsRatio < sFsRatioConfigs[pasrc_ctrl->eInFs][pasrc_ctrl->eOutFs].uiMinFsRatio) || diff --git a/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc.h b/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc.h index be06d6da..80580501 100644 --- a/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc.h +++ b/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc.h @@ -144,7 +144,7 @@ ADFIRCtrl_t sADFIRF3Ctrl; // F3 ADFIR controller unsigned int uiFsRatio; // Fs ratio: Fsin / Fsout - unsigned int uiFsRatio_lsb; + unsigned int uiFsRatio_lo; int iTimeInt; // Integer part of time unsigned int uiTimeFract; // Fractional part of time @@ -173,7 +173,7 @@ ADFIRCtrl_t sADFIRF3Ctrl; // F3 ADFIR controller unsigned int uiFsRatio; // Fs ratio: Fsin / Fsout - unsigned int uiFsRatio_lsb; + unsigned int uiFsRatio_lo; int iTimeInt; // Integer part of time unsigned int uiTimeFract; // Fractional part of time diff --git a/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc_wrapper.c b/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc_wrapper.c index 298cec63..1f694306 100644 --- a/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc_wrapper.c +++ b/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc_wrapper.c @@ -69,7 +69,7 @@ uint64_t asrc_init(const fs_code_t sr_in, const fs_code_t sr_out, asrc_ctrl_t as if (ret_code != ASRC_NO_ERROR) asrc_error(12); } - return (uint64_t)((((uint64_t)asrc_ctrl[0].uiFsRatio) << 32) | asrc_ctrl[0].uiFsRatio_lsb); + return (uint64_t)((((uint64_t)asrc_ctrl[0].uiFsRatio) << 32) | asrc_ctrl[0].uiFsRatio_lo); } unsigned asrc_process(int *in_buff, int *out_buff, uint64_t fs_ratio, asrc_ctrl_t asrc_ctrl[]){ @@ -87,7 +87,7 @@ unsigned asrc_process(int *in_buff, int *out_buff, uint64_t fs_ratio, asrc_ctrl_ { // Update Fs Ratio asrc_ctrl[ui].uiFsRatio = fs_ratio_hi; - asrc_ctrl[ui].uiFsRatio_lsb = fs_ratio_lo; + asrc_ctrl[ui].uiFsRatio_lo = fs_ratio_lo; #if DO_FS_BOUNDS_CHECK // Check for bounds of new Fs ratio diff --git a/tests/asrc_test/model/ASRC.c b/tests/asrc_test/model/ASRC.c index 2a32941e..3498e4ff 100644 --- a/tests/asrc_test/model/ASRC.c +++ b/tests/asrc_test/model/ASRC.c @@ -369,7 +369,7 @@ ASRCReturnCodes_t ASRC_init(ASRCCtrl_t* psASRCCtrl) // Set nominal fs ratio psASRCCtrl->uiFsRatio = sFsRatioConfigs[psASRCCtrl->eInFs][psASRCCtrl->eOutFs].uiNominalFsRatio; - psASRCCtrl->uiFsRatio_lsb = sFsRatioConfigs[psASRCCtrl->eInFs][psASRCCtrl->eOutFs].uiNominalFsRatio_lo; + psASRCCtrl->uiFsRatio_lo = sFsRatioConfigs[psASRCCtrl->eInFs][psASRCCtrl->eOutFs].uiNominalFsRatio_lo; // Check that number of input samples is allocated and is a multiple of 4 if(psASRCCtrl->uiNInSamples == 0) @@ -566,7 +566,7 @@ ASRCReturnCodes_t ASRC_proc_F1_F2(ASRCCtrl_t* psASRCCtrl) ASRCReturnCodes_t ASRC_update_fs_ratio(ASRCCtrl_t* psASRCCtrl) { unsigned int uiFsRatio = psASRCCtrl->uiFsRatio; - unsigned int uiFsRatio_low = psASRCCtrl->uiFsRatio_lsb; + unsigned int uiFsRatio_low = psASRCCtrl->uiFsRatio_lo; // Check for bounds of new Fs ratio if( (uiFsRatio < sFsRatioConfigs[psASRCCtrl->eInFs][psASRCCtrl->eOutFs].uiMinFsRatio) || diff --git a/tests/asrc_test/model/ASRC.h b/tests/asrc_test/model/ASRC.h index 53476815..3f86f1ce 100644 --- a/tests/asrc_test/model/ASRC.h +++ b/tests/asrc_test/model/ASRC.h @@ -144,7 +144,7 @@ ADFIRCtrl_t sADFIRF3Ctrl; // F3 ADFIR controller unsigned int uiFsRatio; // Fs ratio: Fsin / Fsout - unsigned int uiFsRatio_lsb; + unsigned int uiFsRatio_lo; int iTimeInt; // Integer part of time unsigned int uiTimeFract; // Fractional part of time diff --git a/tests/asrc_test/model/Main.c b/tests/asrc_test/model/Main.c index e4c633fe..fca23b1b 100644 --- a/tests/asrc_test/model/Main.c +++ b/tests/asrc_test/model/Main.c @@ -292,10 +292,10 @@ int main(int argc, char *argv[]) for(ui = 0; ui < ASRC_N_IO_CHANNELS; ui++) { // Make Fs Ratio deviate - unsigned long long fs_ratio_full = ((unsigned long long)sASRCCtrl[ui].uiFsRatio << 32) | ((unsigned long long)sASRCCtrl[ui].uiFsRatio_lsb); + unsigned long long fs_ratio_full = ((unsigned long long)sASRCCtrl[ui].uiFsRatio << 32) | ((unsigned long long)sASRCCtrl[ui].uiFsRatio_lo); fs_ratio_full = (unsigned long long)(fs_ratio_full * fFsRatioDeviation); sASRCCtrl[ui].uiFsRatio = (uint32_t)(fs_ratio_full >> 32); - sASRCCtrl[ui].uiFsRatio_lsb = (uint32_t)fs_ratio_full; + sASRCCtrl[ui].uiFsRatio_lo = (uint32_t)fs_ratio_full; if(ASRC_update_fs_ratio(&sASRCCtrl[ui]) != ASRC_NO_ERROR) { sprintf(pzError, "Error at ASRC update fs ratio"); From 1aed0c0f8762596f15676ca849c9c6f27178968f Mon Sep 17 00:00:00 2001 From: Shuchita Khare Date: Tue, 5 Sep 2023 11:02:44 +0100 Subject: [PATCH 4/5] Copyright check --- lib_src/src/multirate_hifi/asrc/src_mrhf_asrc.c | 2 +- lib_src/src/multirate_hifi/asrc/src_mrhf_asrc.h | 2 +- lib_src/src/multirate_hifi/asrc/src_mrhf_asrc_wrapper.c | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc.c b/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc.c index a273139f..44bc9684 100644 --- a/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc.c +++ b/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc.c @@ -1,4 +1,4 @@ -// Copyright 2016-2021 XMOS LIMITED. +// Copyright 2016-2023 XMOS LIMITED. // This Software is subject to the terms of the XMOS Public Licence: Version 1. // =========================================================================== // =========================================================================== diff --git a/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc.h b/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc.h index 80580501..4783f2f3 100644 --- a/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc.h +++ b/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc.h @@ -1,4 +1,4 @@ -// Copyright 2016-2021 XMOS LIMITED. +// Copyright 2016-2023 XMOS LIMITED. // This Software is subject to the terms of the XMOS Public Licence: Version 1. // =========================================================================== // =========================================================================== diff --git a/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc_wrapper.c b/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc_wrapper.c index 1f694306..a6c9d7be 100644 --- a/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc_wrapper.c +++ b/lib_src/src/multirate_hifi/asrc/src_mrhf_asrc_wrapper.c @@ -1,4 +1,4 @@ -// Copyright 2016-2021 XMOS LIMITED. +// Copyright 2016-2023 XMOS LIMITED. // This Software is subject to the terms of the XMOS Public Licence: Version 1. // General includes #include From d13b965992d2fa16b4b32514443e8e7aea09f0af Mon Sep 17 00:00:00 2001 From: Shuchita Khare Date: Tue, 5 Sep 2023 11:05:00 +0100 Subject: [PATCH 5/5] Update changelog --- CHANGELOG.rst | 2 ++ 1 file changed, 2 insertions(+) diff --git a/CHANGELOG.rst b/CHANGELOG.rst index 1070bd12..967b1116 100644 --- a/CHANGELOG.rst +++ b/CHANGELOG.rst @@ -14,6 +14,8 @@ lib_src change log * REMOVED: AN00231 ASRC App Note. See github.com/xmos/sln_voice/examples * CHANGED: Increased precision of the fFsRatioDeviation used in the C emulator from float to double + * CHANGED: Allow for 64 bits in the rate ratio passed to asrc_process() for + extra precision * Changes to dependencies: