tomwalters@32: // Copyright 2010, Thomas Walters
tomwalters@32: //
tomwalters@32: // AIM-C: A C++ implementation of the Auditory Image Model
tomwalters@32: // http://www.acousticscale.org/AIMC
tomwalters@32: //
tomwalters@45: // Licensed under the Apache License, Version 2.0 (the "License");
tomwalters@45: // you may not use this file except in compliance with the License.
tomwalters@45: // You may obtain a copy of the License at
tomwalters@32: //
tomwalters@45: //     http://www.apache.org/licenses/LICENSE-2.0
tomwalters@32: //
tomwalters@45: // Unless required by applicable law or agreed to in writing, software
tomwalters@45: // distributed under the License is distributed on an "AS IS" BASIS,
tomwalters@45: // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
tomwalters@45: // See the License for the specific language governing permissions and
tomwalters@45: // limitations under the License.
tomwalters@32: 
tomwalters@32: /*!
tomwalters@32:  * \file
tomwalters@32:  * \brief 
tomwalters@32:  *
tomwalters@32:  * \author Thomas Walters <tom@acousticscale.org>
tomwalters@32:  * \date created 2010/02/23
tomwalters@32:  * \version \$Id$
tomwalters@32:  */
tomwalters@32: 
tomwalters@32: #include <math.h>
tomwalters@32: #include "Modules/Strobes/ModuleLocalMax.h"
tomwalters@32: 
tomwalters@32: namespace aimc {
tomwalters@32: ModuleLocalMax::ModuleLocalMax(Parameters *params) : Module(params) {
tomwalters@32:   module_description_ = "Local maximum strobe criterion: decaying threshold "
tomwalters@32:                         "with timeout";
tomwalters@32:   module_identifier_ = "local_max";
tomwalters@32:   module_type_ = "strobes";
tomwalters@49:   module_version_ = "$Id: $";
tomwalters@32: 
tomwalters@32:   decay_time_ms_ = parameters_->DefaultFloat("strobes.decay_time_ms", 20.0f);
tomwalters@32:   timeout_ms_ = parameters_->DefaultFloat("strobes.timeout_ms", 3.0f);
tomwalters@32: }
tomwalters@32: 
tomwalters@32: ModuleLocalMax::~ModuleLocalMax() {
tomwalters@32: }
tomwalters@32: 
tomwalters@32: bool ModuleLocalMax::InitializeInternal(const SignalBank &input) {
tomwalters@32:   // Copy the parameters of the input signal bank into internal variables, so
tomwalters@32:   // that they can be checked later.
tomwalters@32:   sample_rate_ = input.sample_rate();
tomwalters@32:   buffer_length_ = input.buffer_length();
tomwalters@32:   channel_count_ = input.channel_count();
tomwalters@32:   output_.Initialize(input);
tomwalters@32:   strobe_timeout_samples_ = floor(timeout_ms_ * sample_rate_ / 1000.0f);
tomwalters@32:   strobe_decay_samples_ = floor(decay_time_ms_ * sample_rate_ / 1000.0f);
tomwalters@32:   ResetInternal();
tomwalters@32:   return true;
tomwalters@32: }
tomwalters@32: 
tomwalters@32: void ModuleLocalMax::ResetInternal() {
tomwalters@32:   threshold_.clear();
tomwalters@32:   threshold_.resize(channel_count_, 0.0f);
tomwalters@32: 
tomwalters@32:   decay_constant_.clear();
tomwalters@32:   decay_constant_.resize(channel_count_, 1.0f);
tomwalters@32: 
tomwalters@32:   prev_sample_.clear();
tomwalters@32:   prev_sample_.resize(channel_count_, 10000.0f);
tomwalters@32:   curr_sample_.clear();
tomwalters@32:   curr_sample_.resize(channel_count_, 5000.0f);
tomwalters@32:   next_sample_.clear();
tomwalters@32:   next_sample_.resize(channel_count_, 0.0f);
tomwalters@32: }
tomwalters@32: 
tomwalters@32: void ModuleLocalMax::Process(const SignalBank &input) {
tomwalters@32:   // Check to see if the module has been initialized. If not, processing
tomwalters@32:   // should not continue.
tomwalters@32:   if (!initialized_) {
tomwalters@32:     LOG_ERROR(_T("Module %s not initialized."), module_identifier_.c_str());
tomwalters@32:     return;
tomwalters@32:   }
tomwalters@32: 
tomwalters@32:   // Check that ths input this time is the same as the input passed to
tomwalters@32:   // Initialize()
tomwalters@32:   if (buffer_length_ != input.buffer_length()
tomwalters@32:       || channel_count_ != input.channel_count()) {
tomwalters@32:     LOG_ERROR(_T("Mismatch between input to Initialize() and input to "
tomwalters@32:                  "Process() in module %s."), module_identifier_.c_str());
tomwalters@32:     return;
tomwalters@32:   }
tomwalters@32: 
tomwalters@32:   for (int ch = 0; ch < output_.channel_count(); ch++) {
tomwalters@32:     output_.ResetStrobes(ch);
tomwalters@32:   }
tomwalters@32:   output_.set_start_time(input.start_time());
tomwalters@32:   for (int i = 0; i < input.buffer_length(); i++) {
tomwalters@32:     for (int ch = 0; ch < input.channel_count(); ++ch) {
tomwalters@32:       // curr_sample is the sample at time (i - 1)
tomwalters@32:       prev_sample_[ch] = curr_sample_[ch];
tomwalters@32:       curr_sample_[ch] = next_sample_[ch];
tomwalters@32:       next_sample_[ch] = input.sample(ch, i);
tomwalters@32:       // Copy input signal to output signal
tomwalters@32:       output_.set_sample(ch, i, input.sample(ch, i));
tomwalters@32: 
tomwalters@32:       // If the current sample is above threshold, the threshold is raised to
tomwalters@32:       // the level of the current sample, and decays from there.
tomwalters@32:       if (curr_sample_[ch] >= threshold_[ch]) {
tomwalters@32:         threshold_[ch] = curr_sample_[ch];
tomwalters@32:         decay_constant_[ch] = threshold_[ch] / strobe_decay_samples_;
tomwalters@32: 
tomwalters@32:         // If the current sample is also a peak, then it is a potential strobe
tomwalters@32:         // point.
tomwalters@32:         if (prev_sample_[ch] < curr_sample_[ch]
tomwalters@32:             && next_sample_[ch] < curr_sample_[ch]) {
tomwalters@32:           // If there are no strobes so far in this channel, then the sample
tomwalters@32:           // is definitely a strobe (this means that the timeout is not 
tomwalters@32:           // respected across frame boundaries. This is a minor bug, but I
tomwalters@32:           // don't believe that it's serious enough to warrant updating the
tomwalters@32:           // samples since last strobe all the time.)
tomwalters@32:           int count = output_.strobe_count(ch);
tomwalters@32:           if (count > 0) {
tomwalters@32:             // If there are previous strobes, then calculate the time since
tomwalters@32:             // the last one. If it's long enough, then this is a strobe point,
tomwalters@32:             // if not, then just move on.
tomwalters@32:             int samples_since_last = (i - 1) - output_.strobe(ch, count - 1);
tomwalters@32:             if (samples_since_last > strobe_timeout_samples_) {
tomwalters@32:               output_.AddStrobe(ch, i - 1);
tomwalters@32:             }
tomwalters@32:           } else {
tomwalters@32:             output_.AddStrobe(ch, i - 1);
tomwalters@32:           }
tomwalters@32:         }
tomwalters@32:       }
tomwalters@32: 
tomwalters@32:       // Update the threshold, decaying as necessary
tomwalters@32:       if (threshold_[ch] > decay_constant_[ch])
tomwalters@32:         threshold_[ch] -= decay_constant_[ch];
tomwalters@32:       else
tomwalters@32:         threshold_[ch] = 0.0f;
tomwalters@32:     }
tomwalters@32:   }
tomwalters@32:   PushOutput();
tomwalters@32: }
tomwalters@32: }  // namespace aimc
tomwalters@32: