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