dicklyon@615: % Copyright 2013, Google, Inc. dicklyon@615: % Author: Richard F. Lyon dicklyon@615: % dicklyon@615: % This Matlab file is part of an implementation of Lyon's cochlear model: dicklyon@615: % "Cascade of Asymmetric Resonators with Fast-Acting Compression" dicklyon@615: % to supplement Lyon's upcoming book "Human and Machine Hearing" dicklyon@615: % dicklyon@615: % Licensed under the Apache License, Version 2.0 (the "License"); dicklyon@615: % you may not use this file except in compliance with the License. dicklyon@615: % You may obtain a copy of the License at dicklyon@615: % dicklyon@615: % http://www.apache.org/licenses/LICENSE-2.0 dicklyon@615: % dicklyon@615: % Unless required by applicable law or agreed to in writing, software dicklyon@615: % distributed under the License is distributed on an "AS IS" BASIS, dicklyon@615: % WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. dicklyon@615: % See the License for the specific language governing permissions and dicklyon@615: % limitations under the License. dicklyon@615: dicklyon@615: function [layer_array, total_width] = SAI_DesignLayers( ... dicklyon@615: n_layers, width_per_layer) dicklyon@615: % function [layer_array, total_width] = SAI_DesignLayers( ... dicklyon@615: % n_layers, width_per_layer) dicklyon@615: % dicklyon@615: % The layer_array is a struct array containing an entry for each layer dicklyon@615: % in a layer of power-of-2 decimated pieces of SAI that get composited dicklyon@615: % into a log-lag SAI. dicklyon@615: % Each struct has the following fields: dicklyon@615: % .width - number of pixels occupied in the final composite SAI, dicklyon@615: % not counting the overlap into pixels counted for other layers. dicklyon@615: % .target_indices - column indices in the final composite SAI, dicklyon@615: % counting the overlap region(s). dicklyon@615: % .lag_curve - for each point in the final composite SAI, the float index dicklyon@615: % in the layer's buffer to interp from. dicklyon@615: % .alpha - the blending coefficent, mostly 1, tapering toward 0 in the overlap dicklyon@615: % region(s). dicklyon@615: % Layer 1 has no overlap to it right, and layer n_layers has none to its dicklyon@615: % left, but sizes of the target_indices, lag_curve, and alpha vectors are dicklyon@615: % otherwise width + left_overlap + right_overlap. The total width of the dicklyon@615: % final composite SAI is the sum of the widths. dicklyon@615: % Other fields could be added to hold state, such as history buffers for dicklyon@615: % each layer, or those could go in state struct array... dicklyon@615: dicklyon@615: dicklyon@615: % Elevate these to a param struct? dicklyon@615: if nargin < 1 dicklyon@615: n_layers = 11 dicklyon@615: end dicklyon@615: if nargin < 2 dicklyon@615: width_per_layer = 32; % resolution "half life" in space dicklyon@615: end dicklyon@615: future_lags = 3 * width_per_layer; dicklyon@615: width_first_layer = future_lags + 2 * width_per_layer; dicklyon@615: width_extra_last_layer = 2 * width_per_layer; dicklyon@615: left_overlap = 15; dicklyon@615: right_overlap = 15; dicklyon@615: first_window_width = 400; % or maybe use seglen? or 0.020 * fs? dicklyon@615: min_window_width = 2*width_per_layer; % or somewhere on that order dicklyon@615: window_exponent = 1.4; dicklyon@615: alpha_max = 0.5; dicklyon@615: dicklyon@615: % Start with NAP_samples_per_SAI_sample, declining to 1 from here: dicklyon@615: max_samples_per = 2^(n_layers - 1); dicklyon@615: % Construct the overall lag-warping function: dicklyon@615: NAP_samples_per_SAI_sample = [ ... dicklyon@615: max_samples_per * ones(1, width_extra_last_layer), ... dicklyon@615: max_samples_per * ... dicklyon@615: 2 .^ (-(1:(width_per_layer * (n_layers - 1))) / width_per_layer), ... dicklyon@615: ones(1, width_first_layer)]; dicklyon@615: dicklyon@615: % Each layer needs a lag_warp for a portion of that, divided by dicklyon@615: % 2^(layer-1), where the portion includes some overlap into its neighbors dicklyon@615: % with higher layer numbers on left, lower on right. dicklyon@615: dicklyon@615: % Layer 1, rightmost, representing recent, current and near-future (negative dicklyon@615: % lag) relative to trigger time, has 1 NAP sample per SAI sample. Other dicklyon@615: % layers map more than one NAP sample into 1 SAI sample. Layer 2 is dicklyon@615: % computed as 2X decimated, 2 NAP samples per SAI sample, but then gets dicklyon@615: % interpolated to between 1 and 2 (and outside that range in the overlap dicklyon@615: % regions) to connect up smoothly. Each layer is another 2X decimated. dicklyon@615: % The last layer limits out at 1 (representing 2^(n_layers) SAI samples) dicklyon@615: % at the width_extra_last_layer SAI samples that extend to the far past. dicklyon@615: dicklyon@615: layer_array = []; % to hold a struct array dicklyon@615: for layer = 1:n_layers dicklyon@615: layer_array(layer).width = width_per_layer; dicklyon@615: layer_array(layer).left_overlap = left_overlap; dicklyon@615: layer_array(layer).right_overlap = right_overlap; dicklyon@615: layer_array(layer).future_lags = 0; dicklyon@615: % Layer decimation factors: 1 1 1 1 2 2 2 4 4 4 8 ... dicklyon@615: layer_array(layer).update_interval = max(1, 2 ^ floor((layer - 2) / 3)); dicklyon@615: end dicklyon@615: % Patch up the exceptions. dicklyon@615: layer_array(1).width = width_first_layer; dicklyon@615: layer_array(end).width = layer_array(end).width + width_extra_last_layer; dicklyon@615: layer_array(1).right_overlap = 0; dicklyon@615: layer_array(end).left_overlap = 0; dicklyon@615: layer_array(1).future_lags = future_lags; dicklyon@615: dicklyon@615: % For each layer, working backwards, from left, find the locations they dicklyon@615: % they render into in the final SAI. dicklyon@615: offset = 0; dicklyon@615: for layer = n_layers:-1:1 dicklyon@615: width = layer_array(layer).width; dicklyon@615: left = layer_array(layer).left_overlap; dicklyon@615: right = layer_array(layer).right_overlap; dicklyon@615: dicklyon@615: % Size of the vectors needed. dicklyon@615: n_final_lags = left + width + right; dicklyon@615: layer_array(layer).n_final_lags = n_final_lags; dicklyon@615: dicklyon@615: % Integer indices into the final composite SAI for this layer. dicklyon@615: target_indices = ((1 - left):(width + right)) + offset; dicklyon@615: layer_array(layer).target_indices = target_indices; dicklyon@615: dicklyon@615: % Make a blending coefficient alpha, ramped in the overlap zone. dicklyon@615: alpha = ones(1, n_final_lags); dicklyon@615: alpha(1:left) = alpha(1:left) .* (1:left)/(left + 1); dicklyon@615: alpha(end + 1 - (1:right)) = ... dicklyon@615: alpha(end + 1 - (1:right)) .* (1:right)/(right + 1); dicklyon@615: layer_array(layer).alpha = alpha * alpha_max; dicklyon@615: dicklyon@615: offset = offset + width; % total width from left through this layer. dicklyon@615: end dicklyon@615: total_width = offset; % Return size of SAI this will make. dicklyon@615: dicklyon@615: % for each layer, fill in its lag-resampling function for interp1: dicklyon@615: for layer = 1:n_layers dicklyon@615: width = layer_array(layer).width; dicklyon@615: left = layer_array(layer).left_overlap; dicklyon@615: right = layer_array(layer).right_overlap; dicklyon@615: dicklyon@615: % Still need to adjust this to make lags match at edges: dicklyon@615: target_indices = layer_array(layer).target_indices; dicklyon@615: samples_per = NAP_samples_per_SAI_sample(target_indices); dicklyon@615: % Accumulate lag backwards from the zero-lag point, convert to units of dicklyon@615: % samples in the current layer. dicklyon@615: lag_curve = (cumsum(samples_per(end:-1:1))) / 2^(layer-1); dicklyon@615: lag_curve = lag_curve(end:-1:1); % Turn it back to corrent order. dicklyon@615: % Now adjust it to match the zero-lag point or a lag-point from dicklyon@615: % previous layer, and reverse it back into place. dicklyon@615: if layer == 1 dicklyon@615: lag_adjust = lag_curve(end) - 0; dicklyon@615: else dicklyon@615: % Align right edge to previous layer's left edge, adjusting for 2X dicklyon@615: % scaling factor difference. dicklyon@615: lag_adjust = lag_curve(end - right) - last_left_lag / 2; dicklyon@615: end dicklyon@615: lag_curve = lag_curve - lag_adjust; dicklyon@615: % lag_curve is now offsets from right end of layer's frame. dicklyon@615: layer_array(layer).lag_curve = lag_curve; dicklyon@615: % Specify number of point to generate in pre-warp frame. dicklyon@615: layer_array(layer).frame_width = ceil(1 + lag_curve(1)); dicklyon@615: if layer < n_layers % to avoid the left = 0 unused end case. dicklyon@615: % A point to align next layer to. dicklyon@615: last_left_lag = lag_curve(left) - layer_array(layer).future_lags; dicklyon@615: end dicklyon@615: dicklyon@615: % Specify a good window width (in history buffer, for picking triggers) dicklyon@615: % in samples for this layer, exponentially approaching minimum. dicklyon@615: layer_array(layer).window_width = round(min_window_width + ... dicklyon@615: first_window_width / window_exponent^(layer - 1)); dicklyon@615: dicklyon@615: % Say about how long the history buffer needs to be to shift any trigger dicklyon@615: % location in the range of the window to a fixed location. Assume dicklyon@615: % using two window placements overlapped 50%. dicklyon@615: n_triggers = 2; dicklyon@615: layer_array(layer).buffer_width = layer_array(layer).frame_width + ... dicklyon@615: ceil((1 + (n_triggers - 1)/2) * layer_array(layer).window_width); dicklyon@615: end dicklyon@615: dicklyon@615: return dicklyon@615: