tom@455: % Copyright 2012, Google, Inc. tom@455: % Author: Richard F. Lyon tom@455: % tom@455: % This Matlab file is part of an implementation of Lyon's cochlear model: tom@455: % "Cascade of Asymmetric Resonators with Fast-Acting Compression" tom@455: % to supplement Lyon's upcoming book "Human and Machine Hearing" tom@455: % tom@455: % Licensed under the Apache License, Version 2.0 (the "License"); tom@455: % you may not use this file except in compliance with the License. tom@455: % You may obtain a copy of the License at tom@455: % tom@455: % http://www.apache.org/licenses/LICENSE-2.0 tom@455: % tom@455: % Unless required by applicable law or agreed to in writing, software tom@455: % distributed under the License is distributed on an "AS IS" BASIS, tom@455: % WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. tom@455: % See the License for the specific language governing permissions and tom@455: % limitations under the License. tom@455: dicklyon@500: function CF = CARFAC_Design(n_ears, fs, CF_CAR_params, CF_AGC_params, CF_IHC_params) dicklyon@473: % function CF = CARFAC_Design(fs, CF_CAR_params, ... tom@455: % CF_AGC_params, ERB_break_freq, ERB_Q, CF_IHC_params) tom@455: % tom@455: % This function designs the CARFAC (Cascade of Asymmetric Resonators with tom@455: % Fast-Acting Compression); that is, it take bundles of parameters and tom@455: % computes all the filter coefficients needed to run it. tom@455: % tom@455: % fs is sample rate (per second) dicklyon@473: % CF_CAR_params bundles all the pole-zero filter cascade parameters tom@455: % CF_AGC_params bundles all the automatic gain control parameters tom@455: % CF_IHC_params bundles all the inner hair cell parameters tom@455: % tom@455: % See other functions for designing and characterizing the CARFAC: tom@455: % [naps, CF] = CARFAC_Run(CF, input_waves) tom@455: % transfns = CARFAC_Transfer_Functions(CF, to_channels, from_channels) tom@455: % tom@455: % Defaults to Glasberg & Moore's ERB curve: tom@455: % ERB_break_freq = 1000/4.37; % 228.833 tom@455: % ERB_Q = 1000/(24.7*4.37); % 9.2645 tom@455: % tom@455: % All args are defaultable; for sample/default args see the code; they tom@455: % make 96 channels at default fs = 22050, 114 channels at 44100. tom@455: dicklyon@500: if nargin < 1 dicklyon@500: n_ears = 1; % if more than 1, make them identical channels; dicklyon@500: % then modify the design if necessary for different reasons dicklyon@500: end dicklyon@500: dicklyon@500: if nargin < 2 dicklyon@500: fs = 22050; dicklyon@500: end dicklyon@500: dicklyon@500: if nargin < 3 dicklyon@500: CF_CAR_params = struct( ... dicklyon@506: 'velocity_scale', 0.1, ... % for the velocity nonlinearity dicklyon@502: 'v_offset', 0.04, ... % offset gives a quadratic part dicklyon@500: 'min_zeta', 0.10, ... % minimum damping factor in mid-freq channels dicklyon@504: 'max_zeta', 0.35, ... % maximum damping factor in mid-freq channels dicklyon@500: 'first_pole_theta', 0.85*pi, ... dicklyon@500: 'zero_ratio', sqrt(2), ... % how far zero is above pole dicklyon@500: 'high_f_damping_compression', 0.5, ... % 0 to 1 to compress zeta dicklyon@500: 'ERB_per_step', 0.5, ... % assume G&M's ERB formula dicklyon@500: 'min_pole_Hz', 30, ... dicklyon@500: 'ERB_break_freq', 165.3, ... % Greenwood map's break freq. dicklyon@500: 'ERB_Q', 1000/(24.7*4.37)); % Glasberg and Moore's high-cf ratio dicklyon@500: end dicklyon@500: dicklyon@492: if nargin < 4 dicklyon@500: CF_AGC_params = struct( ... dicklyon@500: 'n_stages', 4, ... dicklyon@500: 'time_constants', [1, 4, 16, 64]*0.002, ... dicklyon@500: 'AGC_stage_gain', 2, ... % gain from each stage to next slower stage dicklyon@504: 'decimation', [8, 2, 2, 2], ... % how often to update the AGC states dicklyon@500: 'AGC1_scales', [1.0, 1.4, 2.0, 2.8], ... % in units of channels dicklyon@500: 'AGC2_scales', [1.6, 2.25, 3.2, 4.5], ... % spread more toward base dicklyon@500: 'AGC_mix_coeff', 0.5); dicklyon@500: end dicklyon@500: dicklyon@500: if nargin < 5 tom@455: % HACK: these constant control the defaults tom@455: one_cap = 0; % bool; 0 for new two-cap hack tom@455: just_hwr = 0; % book; 0 for normal/fancy IHC; 1 for HWR tom@455: if just_hwr dicklyon@504: CF_IHC_params = struct('just_hwr', 1, ... % just a simple HWR dicklyon@504: 'ac_corner_Hz', 20); tom@455: else tom@455: if one_cap tom@455: CF_IHC_params = struct( ... dicklyon@462: 'just_hwr', just_hwr, ... % not just a simple HWR tom@455: 'one_cap', one_cap, ... % bool; 0 for new two-cap hack tom@455: 'tau_lpf', 0.000080, ... % 80 microseconds smoothing twice tom@455: 'tau_out', 0.0005, ... % depletion tau is pretty fast dicklyon@504: 'tau_in', 0.010, ... % recovery tau is slower dicklyon@504: 'ac_corner_Hz', 20); tom@455: else tom@455: CF_IHC_params = struct( ... dicklyon@462: 'just_hwr', just_hwr, ... % not just a simple HWR tom@455: 'one_cap', one_cap, ... % bool; 0 for new two-cap hack tom@455: 'tau_lpf', 0.000080, ... % 80 microseconds smoothing twice dicklyon@495: 'tau1_out', 0.010, ... % depletion tau is pretty fast tom@455: 'tau1_in', 0.020, ... % recovery tau is slower dicklyon@495: 'tau2_out', 0.0025, ... % depletion tau is pretty fast dicklyon@504: 'tau2_in', 0.005, ... % recovery tau is slower dicklyon@504: 'ac_corner_Hz', 20); tom@455: end tom@455: end tom@455: end tom@455: tom@455: tom@455: tom@455: % first figure out how many filter stages (PZFC/CARFAC channels): dicklyon@473: pole_Hz = CF_CAR_params.first_pole_theta * fs / (2*pi); tom@455: n_ch = 0; dicklyon@473: while pole_Hz > CF_CAR_params.min_pole_Hz tom@455: n_ch = n_ch + 1; dicklyon@473: pole_Hz = pole_Hz - CF_CAR_params.ERB_per_step * ... dicklyon@492: ERB_Hz(pole_Hz, CF_CAR_params.ERB_break_freq, CF_CAR_params.ERB_Q); tom@455: end tom@455: % Now we have n_ch, the number of channels, so can make the array tom@455: % and compute all the frequencies again to put into it: tom@455: pole_freqs = zeros(n_ch, 1); dicklyon@473: pole_Hz = CF_CAR_params.first_pole_theta * fs / (2*pi); tom@455: for ch = 1:n_ch tom@455: pole_freqs(ch) = pole_Hz; dicklyon@473: pole_Hz = pole_Hz - CF_CAR_params.ERB_per_step * ... dicklyon@492: ERB_Hz(pole_Hz, CF_CAR_params.ERB_break_freq, CF_CAR_params.ERB_Q); tom@455: end tom@455: % now we have n_ch, the number of channels, and pole_freqs array tom@455: dicklyon@467: max_channels_per_octave = log(2) / log(pole_freqs(1)/pole_freqs(2)); dicklyon@467: dicklyon@500: % convert to include an ear_array, each w coeffs and state... dicklyon@500: CAR_coeffs = CARFAC_DesignFilters(CF_CAR_params, fs, pole_freqs); dicklyon@500: AGC_coeffs = CARFAC_DesignAGC(CF_AGC_params, fs, n_ch); dicklyon@500: IHC_coeffs = CARFAC_DesignIHC(CF_IHC_params, fs, n_ch); dicklyon@500: % copy same designed coeffs into each ear (can do differently in the dicklyon@500: % future: dicklyon@500: for ear = 1:n_ears dicklyon@500: ears(ear).CAR_coeffs = CAR_coeffs; dicklyon@500: ears(ear).AGC_coeffs = AGC_coeffs; dicklyon@500: ears(ear).IHC_coeffs = IHC_coeffs; dicklyon@500: end dicklyon@500: tom@455: CF = struct( ... tom@455: 'fs', fs, ... dicklyon@467: 'max_channels_per_octave', max_channels_per_octave, ... dicklyon@473: 'CAR_params', CF_CAR_params, ... tom@455: 'AGC_params', CF_AGC_params, ... tom@455: 'IHC_params', CF_IHC_params, ... tom@455: 'n_ch', n_ch, ... tom@455: 'pole_freqs', pole_freqs, ... dicklyon@500: 'ears', ears, ... dicklyon@500: 'n_ears', n_ears ); tom@455: tom@455: dicklyon@473: tom@455: %% Design the filter coeffs: dicklyon@473: function CAR_coeffs = CARFAC_DesignFilters(CAR_params, fs, pole_freqs) tom@455: tom@455: n_ch = length(pole_freqs); tom@455: tom@455: % the filter design coeffs: dicklyon@506: % scalars first: dicklyon@473: CAR_coeffs = struct( ... dicklyon@473: 'n_ch', n_ch, ... dicklyon@473: 'velocity_scale', CAR_params.velocity_scale, ... dicklyon@506: 'v_offset', CAR_params.v_offset ... dicklyon@462: ); tom@455: dicklyon@498: % don't really need these zero arrays, but it's a clue to what fields dicklyon@498: % and types are need in ohter language implementations: dicklyon@473: CAR_coeffs.r1_coeffs = zeros(n_ch, 1); dicklyon@473: CAR_coeffs.a0_coeffs = zeros(n_ch, 1); dicklyon@473: CAR_coeffs.c0_coeffs = zeros(n_ch, 1); dicklyon@473: CAR_coeffs.h_coeffs = zeros(n_ch, 1); dicklyon@473: CAR_coeffs.g0_coeffs = zeros(n_ch, 1); tom@455: tom@455: % zero_ratio comes in via h. In book's circuit D, zero_ratio is 1/sqrt(a), tom@455: % and that a is here 1 / (1+f) where h = f*c. tom@455: % solve for f: 1/zero_ratio^2 = 1 / (1+f) tom@455: % zero_ratio^2 = 1+f => f = zero_ratio^2 - 1 dicklyon@473: f = CAR_params.zero_ratio^2 - 1; % nominally 1 for half-octave tom@455: tom@455: % Make pole positions, s and c coeffs, h and g coeffs, etc., tom@455: % which mostly depend on the pole angle theta: tom@455: theta = pole_freqs .* (2 * pi / fs); tom@455: dicklyon@469: c0 = sin(theta); dicklyon@469: a0 = cos(theta); dicklyon@469: tom@455: % different possible interpretations for min-damping r: dicklyon@473: % r = exp(-theta * CF_CAR_params.min_zeta). dicklyon@469: % Compress theta to give somewhat higher Q at highest thetas: dicklyon@473: ff = CAR_params.high_f_damping_compression; % 0 to 1; typ. 0.5 dicklyon@469: x = theta/pi; dicklyon@504: dicklyon@469: zr_coeffs = pi * (x - ff * x.^3); % when ff is 0, this is just theta, dicklyon@469: % and when ff is 1 it goes to zero at theta = pi. dicklyon@504: max_zeta = CAR_params.max_zeta; dicklyon@504: CAR_coeffs.r1_coeffs = (1 - zr_coeffs .* max_zeta); % "r1" for the max-damping condition dicklyon@469: dicklyon@473: min_zeta = CAR_params.min_zeta; dicklyon@504: % Increase the min damping where channels are spaced out more, by pulling dicklyon@504: % 25% of the way toward ERB_Hz/pole_freqs (close to 0.1 at high f) dicklyon@504: min_zetas = min_zeta + 0.25*(ERB_Hz(pole_freqs, ... dicklyon@492: CAR_params.ERB_break_freq, CAR_params.ERB_Q) ./ pole_freqs - min_zeta); dicklyon@504: CAR_coeffs.zr_coeffs = zr_coeffs .* ... dicklyon@504: (max_zeta - min_zetas); % how r relates to undamping tom@455: tom@455: % undamped coupled-form coefficients: dicklyon@473: CAR_coeffs.a0_coeffs = a0; dicklyon@473: CAR_coeffs.c0_coeffs = c0; tom@455: tom@455: % the zeros follow via the h_coeffs dicklyon@469: h = c0 .* f; dicklyon@473: CAR_coeffs.h_coeffs = h; tom@455: dicklyon@469: % for unity gain at min damping, radius r; only used in CARFAC_Init: dicklyon@504: relative_undamping = ones(n_ch, 1); % max undamping to start dicklyon@473: % this function needs to take CAR_coeffs even if we haven't finished dicklyon@469: % constucting it by putting in the g0_coeffs: dicklyon@504: CAR_coeffs.g0_coeffs = CARFAC_Stage_g(CAR_coeffs, relative_undamping); tom@455: tom@455: tom@455: %% the AGC design coeffs: dicklyon@473: function AGC_coeffs = CARFAC_DesignAGC(AGC_params, fs, n_ch) tom@455: dicklyon@473: n_AGC_stages = AGC_params.n_stages; dicklyon@473: AGC_coeffs = struct( ... dicklyon@473: 'n_ch', n_ch, ... dicklyon@473: 'n_AGC_stages', n_AGC_stages, ... dicklyon@473: 'AGC_stage_gain', AGC_params.AGC_stage_gain); tom@455: tom@455: % AGC1 pass is smoothing from base toward apex; dicklyon@498: % AGC2 pass is back, which is done first now (in double exp. version) tom@455: AGC1_scales = AGC_params.AGC1_scales; tom@455: AGC2_scales = AGC_params.AGC2_scales; tom@455: tom@455: AGC_coeffs.AGC_epsilon = zeros(1, n_AGC_stages); % the 1/(tau*fs) roughly dicklyon@462: decim = 1; dicklyon@462: AGC_coeffs.decimation = AGC_params.decimation; dicklyon@462: dicklyon@462: total_DC_gain = 0; tom@455: for stage = 1:n_AGC_stages dicklyon@464: tau = AGC_params.time_constants(stage); % time constant in seconds dicklyon@464: decim = decim * AGC_params.decimation(stage); % net decim to this stage tom@455: % epsilon is how much new input to take at each update step: tom@455: AGC_coeffs.AGC_epsilon(stage) = 1 - exp(-decim / (tau * fs)); dicklyon@462: % effective number of smoothings in a time constant: dicklyon@464: ntimes = tau * (fs / decim); % typically 5 to 50 dicklyon@463: dicklyon@463: % decide on target spread (variance) and delay (mean) of impulse dicklyon@463: % response as a distribution to be convolved ntimes: dicklyon@464: % TODO (dicklyon): specify spread and delay instead of scales??? dicklyon@463: delay = (AGC2_scales(stage) - AGC1_scales(stage)) / ntimes; dicklyon@463: spread_sq = (AGC1_scales(stage)^2 + AGC2_scales(stage)^2) / ntimes; dicklyon@463: dicklyon@500: % get pole positions to better match intended spread and delay of dicklyon@464: % [[geometric distribution]] in each direction (see wikipedia) dicklyon@463: u = 1 + 1 / spread_sq; % these are based on off-line algebra hacking. dicklyon@463: p = u - sqrt(u^2 - 1); % pole that would give spread if used twice. dicklyon@463: dp = delay * (1 - 2*p +p^2)/2; dicklyon@463: polez1 = p - dp; dicklyon@463: polez2 = p + dp; dicklyon@462: AGC_coeffs.AGC_polez1(stage) = polez1; dicklyon@462: AGC_coeffs.AGC_polez2(stage) = polez2; dicklyon@462: dicklyon@464: % try a 3- or 5-tap FIR as an alternative to the double exponential: dicklyon@464: n_taps = 0; dicklyon@464: FIR_OK = 0; dicklyon@464: n_iterations = 1; dicklyon@464: while ~FIR_OK dicklyon@464: switch n_taps dicklyon@464: case 0 dicklyon@464: % first attempt a 3-point FIR to apply once: dicklyon@464: n_taps = 3; dicklyon@464: case 3 dicklyon@464: % second time through, go wider but stick to 1 iteration dicklyon@464: n_taps = 5; dicklyon@464: case 5 dicklyon@464: % apply FIR multiple times instead of going wider: dicklyon@464: n_iterations = n_iterations + 1; dicklyon@464: if n_iterations > 16 dicklyon@464: error('Too many n_iterations in CARFAC_DesignAGC'); dicklyon@464: end dicklyon@464: otherwise dicklyon@464: % to do other n_taps would need changes in CARFAC_Spatial_Smooth dicklyon@464: % and in Design_FIR_coeffs dicklyon@464: error('Bad n_taps in CARFAC_DesignAGC'); dicklyon@462: end dicklyon@464: [AGC_spatial_FIR, FIR_OK] = Design_FIR_coeffs( ... dicklyon@464: n_taps, spread_sq, delay, n_iterations); dicklyon@462: end dicklyon@464: % when FIR_OK, store the resulting FIR design in coeffs: dicklyon@462: AGC_coeffs.AGC_spatial_iterations(stage) = n_iterations; dicklyon@462: AGC_coeffs.AGC_spatial_FIR(:,stage) = AGC_spatial_FIR; dicklyon@475: AGC_coeffs.AGC_spatial_n_taps(stage) = n_taps; dicklyon@462: dicklyon@464: % accumulate DC gains from all the stages, accounting for stage_gain: dicklyon@462: total_DC_gain = total_DC_gain + AGC_params.AGC_stage_gain^(stage-1); dicklyon@462: dicklyon@464: % TODO (dicklyon) -- is this the best binaural mixing plan? dicklyon@462: if stage == 1 dicklyon@462: AGC_coeffs.AGC_mix_coeffs(stage) = 0; dicklyon@462: else dicklyon@462: AGC_coeffs.AGC_mix_coeffs(stage) = AGC_params.AGC_mix_coeff / ... dicklyon@462: (tau * (fs / decim)); dicklyon@462: end tom@455: end tom@455: dicklyon@463: AGC_coeffs.AGC_gain = total_DC_gain; dicklyon@462: dicklyon@504: % adjust the detect_scale to be the reciprocal DC gain of the AGC filters: dicklyon@504: AGC_coeffs.detect_scale = 1 / total_DC_gain; dicklyon@464: dicklyon@464: dicklyon@464: %% dicklyon@464: function [FIR, OK] = Design_FIR_coeffs(n_taps, var, mn, n_iter) dicklyon@464: % function [FIR, OK] = Design_FIR_coeffs(n_taps, spread_sq, delay, n_iter) dicklyon@464: dicklyon@464: % reduce mean and variance of smoothing distribution by n_iterations: dicklyon@464: mn = mn / n_iter; dicklyon@464: var = var / n_iter; dicklyon@464: switch n_taps dicklyon@464: case 3 dicklyon@464: % based on solving to match mean and variance of [a, 1-a-b, b]: dicklyon@464: a = (var + mn*mn - mn) / 2; dicklyon@464: b = (var + mn*mn + mn) / 2; dicklyon@464: FIR = [a, 1 - a - b, b]; dicklyon@464: OK = FIR(2) >= 0.2; dicklyon@464: case 5 dicklyon@464: % based on solving to match [a/2, a/2, 1-a-b, b/2, b/2]: dicklyon@464: a = ((var + mn*mn)*2/5 - mn*2/3) / 2; dicklyon@464: b = ((var + mn*mn)*2/5 + mn*2/3) / 2; dicklyon@464: % first and last coeffs are implicitly duplicated to make 5-point FIR: dicklyon@464: FIR = [a/2, 1 - a - b, b/2]; dicklyon@464: OK = FIR(2) >= 0.1; dicklyon@464: otherwise dicklyon@464: error('Bad n_taps in AGC_spatial_FIR'); dicklyon@464: end dicklyon@462: tom@455: tom@455: %% the IHC design coeffs: dicklyon@473: function IHC_coeffs = CARFAC_DesignIHC(IHC_params, fs, n_ch) tom@455: tom@455: if IHC_params.just_hwr dicklyon@500: IHC_coeffs = struct( ... dicklyon@500: 'n_ch', n_ch, ... dicklyon@500: 'just_hwr', 1); tom@455: else tom@455: if IHC_params.one_cap dicklyon@504: ro = 1 / CARFAC_Detect(10); % output resistance at a very high level dicklyon@495: c = IHC_params.tau_out / ro; dicklyon@495: ri = IHC_params.tau_in / c; dicklyon@495: % to get steady-state average, double ro for 50% duty cycle dicklyon@495: saturation_output = 1 / (2*ro + ri); dicklyon@495: % also consider the zero-signal equilibrium: dicklyon@495: r0 = 1 / CARFAC_Detect(0); dicklyon@495: current = 1 / (ri + r0); dicklyon@495: cap_voltage = 1 - current * ri; dicklyon@473: IHC_coeffs = struct( ... dicklyon@473: 'n_ch', n_ch, ... tom@455: 'just_hwr', 0, ... tom@455: 'lpf_coeff', 1 - exp(-1/(IHC_params.tau_lpf * fs)), ... dicklyon@495: 'out_rate', ro / (IHC_params.tau_out * fs), ... tom@455: 'in_rate', 1 / (IHC_params.tau_in * fs), ... dicklyon@495: 'one_cap', IHC_params.one_cap, ... dicklyon@495: 'output_gain', 1/ (saturation_output - current), ... dicklyon@495: 'rest_output', current / (saturation_output - current), ... dicklyon@495: 'rest_cap', cap_voltage); dicklyon@495: % one-channel state for testing/verification: dicklyon@495: IHC_state = struct( ... dicklyon@495: 'cap_voltage', IHC_coeffs.rest_cap, ... dicklyon@495: 'lpf1_state', 0, ... dicklyon@495: 'lpf2_state', 0, ... dicklyon@500: 'ihc_accum', 0); dicklyon@499: else dicklyon@504: ro = 1 / CARFAC_Detect(10); % output resistance at a very high level dicklyon@495: c2 = IHC_params.tau2_out / ro; dicklyon@495: r2 = IHC_params.tau2_in / c2; dicklyon@495: c1 = IHC_params.tau1_out / r2; dicklyon@495: r1 = IHC_params.tau1_in / c1; dicklyon@495: % to get steady-state average, double ro for 50% duty cycle dicklyon@495: saturation_output = 1 / (2*ro + r2 + r1); dicklyon@495: % also consider the zero-signal equilibrium: dicklyon@495: r0 = 1 / CARFAC_Detect(0); dicklyon@495: current = 1 / (r1 + r2 + r0); dicklyon@495: cap1_voltage = 1 - current * r1; dicklyon@495: cap2_voltage = cap1_voltage - current * r2; tom@455: IHC_coeffs = struct(... dicklyon@473: 'n_ch', n_ch, ... tom@455: 'just_hwr', 0, ... tom@455: 'lpf_coeff', 1 - exp(-1/(IHC_params.tau_lpf * fs)), ... tom@455: 'out1_rate', 1 / (IHC_params.tau1_out * fs), ... tom@455: 'in1_rate', 1 / (IHC_params.tau1_in * fs), ... dicklyon@495: 'out2_rate', ro / (IHC_params.tau2_out * fs), ... tom@455: 'in2_rate', 1 / (IHC_params.tau2_in * fs), ... dicklyon@495: 'one_cap', IHC_params.one_cap, ... dicklyon@495: 'output_gain', 1/ (saturation_output - current), ... dicklyon@495: 'rest_output', current / (saturation_output - current), ... dicklyon@495: 'rest_cap2', cap2_voltage, ... dicklyon@495: 'rest_cap1', cap1_voltage); dicklyon@495: % one-channel state for testing/verification: dicklyon@495: IHC_state = struct( ... dicklyon@495: 'cap1_voltage', IHC_coeffs.rest_cap1, ... dicklyon@495: 'cap2_voltage', IHC_coeffs.rest_cap2, ... dicklyon@495: 'lpf1_state', 0, ... dicklyon@495: 'lpf2_state', 0, ... dicklyon@495: 'ihc_accum', 0); tom@455: end tom@455: end dicklyon@504: % one more late addition that applies to all cases: dicklyon@504: IHC_coeffs.ac_coeff = 2 * pi * IHC_params.ac_corner_Hz / fs; tom@455: tom@455: %% tom@455: % default design result, running this function with no args, should look tom@455: % like this, before CARFAC_Init puts state storage into it: tom@455: % dicklyon@462: % tom@455: % CF = CARFAC_Design dicklyon@504: % CAR_params = CF.CAR_params dicklyon@504: % AGC_params = CF.AGC_params dicklyon@504: % IHC_params = CF.IHC_params dicklyon@504: % CAR_coeffs = CF.ears(1).CAR_coeffs dicklyon@504: % AGC_coeffs = CF.ears(1).AGC_coeffs dicklyon@504: % AGC_spatial_FIR = AGC_coeffs.AGC_spatial_FIR dicklyon@504: % IHC_coeffs = CF.ears(1).IHC_coeffs dicklyon@504: dicklyon@504: % CF = dicklyon@469: % fs: 22050 dicklyon@495: % max_channels_per_octave: 12.2709 dicklyon@495: % CAR_params: [1x1 struct] dicklyon@469: % AGC_params: [1x1 struct] dicklyon@469: % IHC_params: [1x1 struct] dicklyon@495: % n_ch: 71 dicklyon@495: % pole_freqs: [71x1 double] dicklyon@504: % ears: [1x1 struct] dicklyon@504: % n_ears: 1 dicklyon@504: % CAR_params = dicklyon@504: % velocity_scale: 0.0500 dicklyon@504: % v_offset: 0.0400 dicklyon@469: % v2_corner: 0.2000 dicklyon@472: % min_zeta: 0.1000 dicklyon@504: % max_zeta: 0.3500 dicklyon@469: % first_pole_theta: 2.6704 dicklyon@469: % zero_ratio: 1.4142 dicklyon@469: % high_f_damping_compression: 0.5000 dicklyon@469: % ERB_per_step: 0.5000 dicklyon@469: % min_pole_Hz: 30 dicklyon@495: % ERB_break_freq: 165.3000 dicklyon@495: % ERB_Q: 9.2645 dicklyon@504: % AGC_params = tom@455: % n_stages: 4 tom@455: % time_constants: [0.0020 0.0080 0.0320 0.1280] tom@455: % AGC_stage_gain: 2 dicklyon@462: % decimation: [8 2 2 2] dicklyon@495: % AGC1_scales: [1 1.4000 2 2.8000] dicklyon@495: % AGC2_scales: [1.6000 2.2500 3.2000 4.5000] dicklyon@469: % AGC_mix_coeff: 0.5000 dicklyon@504: % IHC_params = dicklyon@504: % just_hwr: 0 dicklyon@504: % one_cap: 0 dicklyon@504: % tau_lpf: 8.0000e-05 dicklyon@504: % tau1_out: 0.0100 dicklyon@504: % tau1_in: 0.0200 dicklyon@504: % tau2_out: 0.0025 dicklyon@504: % tau2_in: 0.0050 dicklyon@504: % ac_corner_Hz: 20 dicklyon@504: % CAR_coeffs = dicklyon@495: % n_ch: 71 dicklyon@504: % velocity_scale: 0.0500 dicklyon@504: % v_offset: 0.0400 dicklyon@462: % v2_corner: 0.2000 dicklyon@495: % r1_coeffs: [71x1 double] dicklyon@495: % a0_coeffs: [71x1 double] dicklyon@495: % c0_coeffs: [71x1 double] dicklyon@495: % h_coeffs: [71x1 double] dicklyon@495: % g0_coeffs: [71x1 double] dicklyon@495: % zr_coeffs: [71x1 double] dicklyon@504: % AGC_coeffs = dicklyon@495: % n_ch: 71 dicklyon@495: % n_AGC_stages: 4 dicklyon@462: % AGC_stage_gain: 2 dicklyon@462: % AGC_epsilon: [0.1659 0.0867 0.0443 0.0224] dicklyon@462: % decimation: [8 2 2 2] dicklyon@495: % AGC_polez1: [0.1699 0.1780 0.1872 0.1903] dicklyon@495: % AGC_polez2: [0.2388 0.2271 0.2216 0.2148] dicklyon@495: % AGC_spatial_iterations: [1 1 1 1] dicklyon@462: % AGC_spatial_FIR: [3x4 double] dicklyon@495: % AGC_spatial_n_taps: [3 3 3 3] dicklyon@469: % AGC_mix_coeffs: [0 0.0454 0.0227 0.0113] dicklyon@462: % AGC_gain: 15 dicklyon@504: % detect_scale: 0.0667 dicklyon@504: % AGC_spatial_FIR = dicklyon@504: % 0.2744 0.2829 0.2972 0.2999 dicklyon@504: % 0.3423 0.3571 0.3512 0.3616 dicklyon@504: % 0.3832 0.3600 0.3516 0.3385 dicklyon@504: % IHC_coeffs = dicklyon@495: % n_ch: 71 dicklyon@495: % just_hwr: 0 dicklyon@495: % lpf_coeff: 0.4327 dicklyon@495: % out1_rate: 0.0045 dicklyon@495: % in1_rate: 0.0023 dicklyon@504: % out2_rate: 0.0199 dicklyon@495: % in2_rate: 0.0091 dicklyon@495: % one_cap: 0 dicklyon@504: % output_gain: 12.1185 dicklyon@504: % rest_output: 0.3791 dicklyon@504: % rest_cap2: 0.7938 dicklyon@504: % rest_cap1: 0.8625 dicklyon@504: % ac_coeff: 0.0057 dicklyon@504: dicklyon@504: dicklyon@504: