annotate src/Modules/SAI/ModuleSAI.cc @ 0:582cbe817f2c

- Initial add of support code and modules. Not everything is working yet.

// Copyright 2006-2010, Thomas Walters
//
// AIM-C: A C++ implementation of the Auditory Image Model
// http://www.acousticscale.org/AIMC
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

/*! \file
 *  \brief SAI module
 */

/*
 * \author Thomas Walters <[e-mail]>
 * \date created 2007/08/29
 * \version \$Id: ModuleSAI.cc 4 2010-02-03 18:44:58Z tcw $
 */
#include <math.h>

#include "Modules/SAI/ModuleSAI.h"

ModuleSAI::ModuleSAI(Parameters *parameters) : Module(parameters) {
  module_description_ = "Stabilised auditory image";
  module_name_ = "sai2007";
  module_type_ = "sai";
  module_id_ = "$Id: ModuleSAI.cc 4 2010-02-03 18:44:58Z tcw $";

  min_delay_ms_ = parameters_->DefaultFloat("sai.min_delay_ms", 0.0f);
  max_delay_ms_ = parameters_->DefaultFloat("sai.max_delay_ms", 35.0f);
  strobe_weight_alpha_ = parameters_->DefaultFloat("sai.strobe_weight_alpha",
                                                   0.5f);
  buffer_memory_decay_ = parameters_->DefaultFloat("sai.buffer_memory_decay",
                                                   0.03f);
  frame_period_ms_ = parameters_->DefaultFloat("sai.frame_period_ms", 20.0f);

  min_strobe_delay_index_ = 0;
  max_strobe_delay_index_ = 0;
  sai_decay_factor_ = 0.0f;
  max_concurrent_strobes_ = 0;
  output_frame_period_ms_ = 0.0f;
  last_output_frame_time_ms_ = 0.0f;
}

bool ModuleSAI::InitializeInternal(const SignalBank &input) {
  // The SAI output bank must be as long as the SAI's Maximum delay.
  // One sample is added to the SAI buffer length to account for the
  // zero-lag point
  int sai_buffer_length = 1 + Round(input.sample_rate() * max_delay_ms_);

  // Make an output SignalBank with the same number of channels and centre
  // frequencies as the input, but with a different buffer length
  if (!output_.Initialize(input.channel_count(),
                          sai_buffer_length,
                          input.sample_rate());) {
    LOG_ERROR("Failed to create output buffer in SAI module");
    return false;
  }
  for (int i = 0; i < input.channel_count(); ++i ) {
    output_.set_centre_frequency(i, input.get_centre_frequency(i));
  }

  // sai_temp_ will be initialized to zero
  if (!sai_temp_.Initialize(output_)) {
    LOG_ERROR("Failed to create temporary buffer in SAI module");
    return false;
  }

  last_output_time_ms_ = 0.0f;

  frame_period_samples_ = Round(input.sample_rate()
                                * frame_period_ms_ / 1000.0f);

  min_strobe_delay_idx_ = Round(input.sample_rate() * min_delay_ms_ / 1000.0f);
  max_strobe_delay_idx_ = Round(input.sample_rate() * max_delay_ms_ / 1000.0f);

  // Make sure we don't go past the output buffer's upper bound
  if (max_strobe_delay_idx_ > output_.buffer_length()))
    max_strobe_delay_idx_ = output_.buffer_length();

  // Define decay factor from time since last sample (see ti2003)
  sai_decay_factor_ = pow(0.5f, 1.0f / (buffer_memory_decay_
                                        * input.sample_rate()));

  // Maximum strobes that can be active at the same time within maxdelay.
  //! \todo Choose this value in a more principled way
  max_concurrent_strobes_ = Round(1000.0f * max_delay_ * 5);

  // Precompute strobe weights
  strobe_weights_.resize(max_concurrent_strobes_);
  for (int n = 0; n < max_concurrent_strobes_; ++n) {
    strobe_weights_[n] = pow(1.0f / (n + 1)), strobe_weight_alpha_);
  }

  // Active Strobes
  active_strobes_.Resize(input.channel_count());
  for (int i = 0; i < input.channel_count(); ++i) {
    active_strobes_[i].Create(max_concurrent_strobes_);
  }
  next_strobes_.resize(input.channel_count(), 0);

  return true;
}

void ModuleSAI::Reset() {
}

void ModuleSAI::Process(const SignalBank &input) {
  int s;
  int c;
  int output_buffer_length = output_.buffer_length();

  // Reset the next strobe times
  next_strobes_.clear();
  next_strobes_.resize(output_.channel_count(), 0);

  // Offset the times on the strobes from the previous buffer
  for (c = 0; c < input.channel_count(), ++c) {
    active_strobes_[c].shiftStrobes(input.buffer_length());
  }

  // Make sure only start time is transferred to the output
  output_.set_start_time(input.start_time());

  // Loop over samples to make the SAI
  for (s = 0; s < input_buffer_length; ++s) {
    float decay_factor = pow(sai_decay_factor_, fire_counter_);
    // Loop over channels
    for (c = 0; c < input.channel_count(); ++c) {
      // Local convenience variables
      StrobeList &active_strobes = active_strobes_[c];
      float centre_frequency = input.get_centre_frequency(c);
      int next_strobe = next_strobes_[c];

      // 1. Update strobes
      // If we are up to or beyond the next strobe...
      if (next_strobe < input.strobe_count(c)) {
        if (s == pSigIn->getStrobe(iNextStrobe)) {
          //A new strobe has arrived
          // if there aren't already too many strobes active...
          if ((active_strobes.getStrobeCount() + 1) < max_concurrent_strobes_) {
            // ...add the active strobe to the list of current strobes
            // calculate the strobe weight
            float weight = 1.0f;
            if (active_strobes.getStrobeCount() > 0) {
              int last_strobe = active_strobes.getTime(
                active_strobes.getStrobeCount());

              // If the strobe occured within 10 impulse-response
              // cycles of the previous strobe, then lower its weight
              weight = (s - iLastStrobe) / input.sample_rate()
                       * centre_frequency / 10.0f;
              if (weight > 1.0f)
                weight = 1.0f;
            }
            pActiveStrobes->addStrobe(iCurrentSample, weight);
            iNextStrobe++;
          } else {
            // We have a problem
            aimASSERT(0);
          }

          // 2. Having updated the strobes, we now need to update the
          // strobe weights
          float total_strobe_weight = 0.0f;
          for (int si = 1; si <= pActiveStrobes->getStrobeCount(); ++si) {
            total_strobe_weight += (pActiveStrobes->getWeight(si) 
              * m_pStrobeWeights[pActiveStrobes->getStrobeCount() - si]);
          }
          for (int si = 1; si <= pActiveStrobes->getStrobeCount(); ++si) {
            active_strobes.setWorkingWeight(si,(active_strobes.getWeight(si)
              * strobe_weights_[active_strobes.getStrobeCount() - si])
                / total_strobe_weight);
          }
        }
      }

      // remove inactive strobes...
      while (pActiveStrobes->getStrobeCount() > 0) {
        // Get the time of the first strobe (ordering of strobes is
        // from one, not zero)
        int iStrobeTime = pActiveStrobes->getTime(1);
        int iDelay = iCurrentSample - iStrobeTime;
        // ... do we now need to remove this strobe?
        if (iDelay > m_maxStrobeDelayIdx)
          pActiveStrobes->deleteFirstStrobe();
        else
          break;
          // Since the strobes are ordered, we don't need to go
          // beyond the first still-active strobe
      }

      // 3. Loop over active strobes
      for (int si = 1; si <= pActiveStrobes->getStrobeCount(); si++) {
        // 3.1 Add effect of active strobe at correct place in the SAI buffer
        // Calculate the time from the strobe event to 'now': iDelay
        int iStrobeTime = pActiveStrobes->getTime(si);
        int iDelay = iCurrentSample - iStrobeTime;

        // If the delay is greater than the (user-set)
        // minimum strobe delay, the strobe can be used
        if (iDelay >= m_minStrobeDelayIdx && iDelay < m_maxStrobeDelayIdx) {
          // The value at be added to the SAI
          float sig = pSigIn->getSample(iCurrentSample, audCh);

          // Weight the sample correctly
          sig *= pActiveStrobes->getWorkingWeight(si);

          // Adjust the weight acording to the number of samples until the
          // next output frame
          sig *= fDecayFactor;

          // Update the temporary SAI buffer
          pSigOut->setSample(iDelay, audCh,
                             pSigOut->getSample(iDelay, audCh)+sig);
        }
      }

      m_pNextStrobes[bankCh]=iNextStrobe;

    } // End loop over channels


    //Check to see if we need to output an SAI frame this sample
    if (m_iFireCounter-- == 0) {
      // Decay the SAI by the correct amount and add the current output frame
      float decay = pow(sai_decay_factor_, fire_period_samples_);

      for (c = 0; c < input.channel_count(); ++c) {
        for (int i = 0; i < output_.buffer_length(); ++i) {
          output_.set_sample(c, i, sai_temp_[c][i] + output_[c][i] * decay);
        }
      }

      // Zero the temporary signal
      for (int ch = 0; ch < sai_temp_.channel_count(); ++ch) {
        for (int i = 0; i < sai_temp_.buffer_length(); ++i) {
          sai_temp_.set_sample(ch, i, 0.0f);
        }
      }

      m_iFireCounter=m_iFirePeriodSamples-1;

      // Make sure the start time is transferred to the output
      m_pOutputData->setStartTime(m_pInputData->getSignal(0)->getStartTime()+(SIGNAL_SAMPLE)((float)iCurrentSample*1000.0f/(float)m_pInputData->getSamplerate()));
      PushOutput();
    }
  } // End loop over samples
}

ModuleSAI::~ModuleSAI() {
}