comparison matlab/bmm/carfac/SAI_DesignLayers.m @ 623:b3118c9ed67f

Turn the AGC coeffs inside out: array of structs instead of a struct of little arrays.
In C++ use a vector<AGC_coeffs> for this; each of 4 stages has an entry; many fewer places
need to do indexing by stage, and this removes the temptation to use little eigen arrays
for the 4 stages.
Also latest version of experimental log-lag SAI hacks.

 % distributed under the License is distributed on an "AS IS" BASIS,
 % WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 % See the License for the specific language governing permissions and
 % limitations under the License.
 
-function [layer_array, total_width] = SAI_DesignLayers( ...
-  n_layers, width_per_layer)
+function [layer_array, total_width, lag_period_samples] = SAI_DesignLayers( ...
+  n_layers, width_per_layer, seglen)
 % function [layer_array, total_width] = SAI_DesignLayers( ...
 %   n_layers, width_per_layer)
 %
 % The layer_array is a struct array containing an entry for each layer
 % in a layer of power-of-2 decimated pieces of SAI that get composited

 % otherwise width + left_overlap + right_overlap.  The total width of the
 % final composite SAI is the sum of the widths.
 % Other fields could be added to hold state, such as history buffers for
 % each layer, or those could go in state struct array...
 
-
 % Elevate these to a param struct?
 if nargin < 1
-  n_layers = 11
+  n_layers = 12;
 end
 if nargin < 2
-  width_per_layer = 32;  % resolution "half life" in space
+  width_per_layer = 24;  % resolution "half life" in space; half-semitones
 end
-future_lags = 4 * width_per_layer;
-width_first_layer = future_lags + 1 * width_per_layer;
-width_extra_last_layer = 2 * width_per_layer;
-left_overlap = 15;
-right_overlap = 15;
-first_window_width = 400;  % or maybe use seglen?  or 0.020 * fs?
+future_lags = 0 * width_per_layer;
+width_extra_last_layer = 0 * width_per_layer;
+left_overlap = 10;
+right_overlap = 10;
+first_window_width = seglen;  % Less would be a problem.
 min_window_width = 1*width_per_layer;  % or somewhere on that order
 window_exponent = 1.4;
 alpha_max = 1; 
+
+width_first_layer = future_lags + 2 * width_per_layer;
 
 % Start with NAP_samples_per_SAI_sample, declining to 1 from here:
 max_samples_per = 2^(n_layers - 1);
 % Construct the overall lag-warping function:
 NAP_samples_per_SAI_sample = [ ...
   max_samples_per * ones(1, width_extra_last_layer), ...
   max_samples_per * ...
     2 .^ (-(1:(width_per_layer * (n_layers - 1))) / width_per_layer), ...
-  ones(1, width_first_layer)];
+  ones(1, width_first_layer), ];  % w/o future for now.
+
+lag_period_samples = cumsum(NAP_samples_per_SAI_sample(end:-1:1));
+lag_period_samples = lag_period_samples(end:-1:1);  % Put it back in order.
+lag_period_samples = lag_period_samples - lag_period_samples(end - future_lags);
 
 % Each layer needs a lag_warp for a portion of that, divided by
 % 2^(layer-1), where the portion includes some overlap into its neighbors
 % with higher layer numbers on left, lower on right.
 

   % using two window placements overlapped 50%.
   n_triggers = 2;
   layer_array(layer).n_window_pos = n_triggers;
   layer_array(layer).buffer_width = layer_array(layer).frame_width + ...
     floor((1 + (n_triggers - 1)/2) * layer_array(layer).window_width);
+  % Make sure it's big enough for next layer to shift in what it wants.
+  n_shift = ceil(seglen / (2.0^(layer - 1)));
+  if layer_array(layer).buffer_width < 6 + n_shift;
+    layer_array(layer).buffer_width = 6 + n_shift;
+  end
 end
 
 return