[aimc] r294 committed - DISALLOW_COPY_AND_ASSIGN in CARFAC classes and fix a few funny indenta...

[ai...@googlecode.com]

Revision: 294
Author: ro...@google.com
Date: Tue Jun 11 10:59:08 2013
Log: DISALLOW_COPY_AND_ASSIGN in CARFAC classes and fix a few funny
indentations.


http://code.google.com/p/aimc/source/detail?r=294

Modified:
/trunk/carfac/carfac.cc
/trunk/carfac/carfac.h
/trunk/carfac/carfac_output.cc
/trunk/carfac/carfac_output.h
/trunk/carfac/common.h
/trunk/carfac/ear.cc
/trunk/carfac/ear.h

=======================================
--- /trunk/carfac/carfac.cc Tue Jun 11 08:04:55 2013
+++ /trunk/carfac/carfac.cc Tue Jun 11 10:59:08 2013
@@ -27,18 +27,19 @@
using std::vector;

CARFAC::CARFAC(const int num_ears, const FPType sample_rate,
- const CARParams& car_params, const IHCParams&
ihc_params,
- const AGCParams& agc_params) {
+ const CARParams& car_params, const IHCParams& ihc_params,
+ const AGCParams& agc_params) {
+ Reset(num_ears, sample_rate, car_params, ihc_params, agc_params);
+}
+
+void CARFAC::Reset(const int num_ears, const FPType sample_rate,
+ const CARParams& car_params, const IHCParams&
ihc_params,
+ const AGCParams& agc_params) {
num_ears_ = num_ears;
sample_rate_ = sample_rate;
- ears_.resize(num_ears_);
car_params_ = car_params;
ihc_params_ = ihc_params;
agc_params_ = agc_params;
- Reset();
-}
-
-void CARFAC::Reset() {
num_channels_ = 0;
FPType pole_hz = car_params_.first_pole_theta * sample_rate_ / (2 * kPi);
while (pole_hz > car_params_.min_pole_hz) {
@@ -62,8 +63,10 @@
// This code initializes the coefficients for each of the AGC stages.
DesignAGCCoeffs(agc_params_, sample_rate_, &agc_coeffs);
// Once we have the coefficient structure we can design the ears.
- for (auto& ear : ears_) {
- ear.Init(num_channels_, car_coeffs, ihc_coeffs, agc_coeffs);
+ ears_.clear();
+ ears_.reserve(num_ears_);
+ for (int i = 0; i < num_ears_; ++i) {
+ ears_.push_back(new Ear(num_channels_, car_coeffs, ihc_coeffs,
agc_coeffs));
}
}

@@ -76,15 +79,15 @@
for (int32_t timepoint = 0; timepoint < length; ++timepoint) {
for (int audio_channel = 0; audio_channel < num_ears_;
++audio_channel) {
// First we create a reference to the current Ear object.
- Ear& ear = ears_[audio_channel];
+ Ear* ear = ears_[audio_channel];
// This stores the audio sample currently being processed.
FPType input = sound_data[audio_channel][start + timepoint];

// Now we apply the three stages of the model in sequence to the
current
// audio sample.
- ear.CARStep(input);
- ear.IHCStep(ear.car_out());
- updated = ear.AGCStep(ear.ihc_out());
+ ear->CARStep(input);
+ ear->IHCStep(ear->car_out());
+ updated = ear->AGCStep(ear->ihc_out());
}
seg_output->AppendOutput(ears_);
if (updated) {
@@ -99,23 +102,23 @@
}

void CARFAC::CrossCouple() {
- for (int stage = 0; stage < ears_[0].agc_num_stages(); ++stage) {
- if (ears_[0].agc_decim_phase(stage) > 0) {
+ for (int stage = 0; stage < ears_[0]->agc_num_stages(); ++stage) {
+ if (ears_[0]->agc_decim_phase(stage) > 0) {
break;
} else {
- FPType mix_coeff = ears_[0].agc_mix_coeff(stage);
+ FPType mix_coeff = ears_[0]->agc_mix_coeff(stage);
if (mix_coeff > 0) {
ArrayX stage_state;
ArrayX this_stage_values = ArrayX::Zero(num_channels_);
- for (auto& ear : ears_) {
- stage_state = ear.agc_memory(stage);
+ for (const auto& ear : ears_) {
+ stage_state = ear->agc_memory(stage);
this_stage_values += stage_state;
}
this_stage_values /= num_ears_;
- for (auto& ear : ears_) {
- stage_state = ear.agc_memory(stage);
- ear.set_agc_memory(stage, stage_state + mix_coeff *
- (this_stage_values - stage_state));
+ for (const auto& ear : ears_) {
+ stage_state = ear->agc_memory(stage);
+ ear->set_agc_memory(stage, stage_state + mix_coeff *
+ (this_stage_values - stage_state));
}
}
}
@@ -123,13 +126,13 @@
}

void CARFAC::CloseAGCLoop() {
- for (auto& ear: ears_) {
- ArrayX undamping = 1 - ear.agc_memory(0);
+ for (auto& ear : ears_) {
+ ArrayX undamping = 1 - ear->agc_memory(0);
// This updates the target stage gain for the new damping.
- ear.set_dzb_memory((ear.zr_coeffs() * undamping - ear.zb_memory()) /
- ear.agc_decimation(0));
- ear.set_dg_memory((ear.StageGValue(undamping) - ear.g_memory()) /
- ear.agc_decimation(0));
+ ear->set_dzb_memory((ear->zr_coeffs() * undamping - ear->zb_memory()) /
+ ear->agc_decimation(0));
+ ear->set_dg_memory((ear->StageGValue(undamping) - ear->g_memory()) /
+ ear->agc_decimation(0));
}
}

=======================================
--- /trunk/carfac/carfac.h Tue Jun 4 11:30:22 2013
+++ /trunk/carfac/carfac.h Tue Jun 11 10:59:08 2013
@@ -48,19 +48,20 @@
// rate. This initializes a vector of 'Ear' objects -- one for mono, two
for
// stereo, or more.
CARFAC(const int num_ears, const FPType sample_rate,
- const CARParams& car_params, const IHCParams& ihc_params,
- const AGCParams& agc_params);
-
+ const CARParams& car_params, const IHCParams& ihc_params,
+ const AGCParams& agc_params);
+
+ void Reset(const int num_ears, const FPType sample_rate,
+ const CARParams& car_params, const IHCParams& ihc_params,
+ const AGCParams& agc_params);
+
// The 'RunSegment' method processes individual sound segments and
stores the
// output of the model in a CARFACOutput object.
void RunSegment(const std::vector<std::vector<float>>& sound_data,
const int32_t start, const int32_t length,
const bool open_loop, CARFACOutput* seg_output);
- void Reset();

private:
- // TODO (alexbrandmeyer): figure out why this breaks object
initialization.
- //DISALLOW_COPY_AND_ASSIGN(CARFAC);
void DesignCARCoeffs(const CARParams& car_params, const FPType
sample_rate,
const ArrayX& pole_freqs, CARCoeffs* car_coeffs);
void DesignIHCCoeffs(const IHCParams& ihc_params, const FPType
sample_rate,
@@ -69,7 +70,7 @@
std::vector<AGCCoeffs>* agc_coeffs);
void CrossCouple();
void CloseAGCLoop();
-
+
// Function: ERBHz
// Auditory filter nominal Equivalent Rectangular Bandwidth
// Ref: Glasberg and Moore: Hearing Research, 47 (1990), 103-138
@@ -85,10 +86,12 @@
FPType sample_rate_;
int num_channels_;
FPType max_channels_per_octave_;
-
+
// We store a vector of Ear objects for mono/stereo/multichannel
processing:
- std::vector<Ear> ears_;
+ std::vector<Ear*> ears_;
ArrayX pole_freqs_;
+
+ DISALLOW_COPY_AND_ASSIGN(CARFAC);
};

#endif // CARFAC_CARFAC_H
=======================================
--- /trunk/carfac/carfac_output.cc Tue Jun 4 11:30:22 2013
+++ /trunk/carfac/carfac_output.cc Tue Jun 11 10:59:08 2013
@@ -25,8 +25,8 @@
using std::vector;

CARFACOutput::CARFACOutput(const bool store_nap, const bool
store_nap_decim,
- const bool store_bm, const bool store_ohc,
- const bool store_agc) {
+ const bool store_bm, const bool store_ohc,
+ const bool store_agc) {
store_nap_ = store_nap;
store_nap_decim_ = store_nap_decim;
store_bm_ = store_bm;
@@ -35,29 +35,29 @@

}

-void CARFACOutput::AppendOutput(const vector<Ear>& ears) {
+void CARFACOutput::AppendOutput(const vector<Ear*>& ears) {
if (store_nap_) {
nap_.push_back(vector<ArrayX>());
- for (auto ear : ears) {
- nap_.back().push_back(ear.ihc_out());
+ for (const auto& ear : ears) {
+ nap_.back().push_back(ear->ihc_out());
}
}
if (store_ohc_) {
ohc_.push_back(vector<ArrayX>());
- for (auto ear : ears) {
- ohc_.back().push_back(ear.za_memory());
+ for (const auto& ear : ears) {
+ ohc_.back().push_back(ear->za_memory());
}
}
if (store_agc_) {
agc_.push_back(vector<ArrayX>());
- for (auto ear : ears) {
- agc_.back().push_back(ear.zb_memory());
+ for (const auto& ear : ears) {
+ agc_.back().push_back(ear->zb_memory());
}
}
if (store_bm_) {
bm_.push_back(vector<ArrayX>());
- for (auto ear : ears) {
- bm_.back().push_back(ear.zy_memory());
+ for (const auto& ear : ears) {
+ bm_.back().push_back(ear->zy_memory());
}
}
}
=======================================
--- /trunk/carfac/carfac_output.h Tue Jun 4 11:30:22 2013
+++ /trunk/carfac/carfac_output.h Tue Jun 11 10:59:08 2013
@@ -37,28 +37,28 @@
// The constructor takes five boolean values as arguments which indicate
// the portions of the CARFAC model's output to be stored.
CARFACOutput(const bool store_nap, const bool store_nap_decim,
- const bool store_bm, const bool store_ohc, const bool
store_agc);
-
+ const bool store_bm, const bool store_ohc, const bool
store_agc);
+
// The AppendOutput method is called on a sample by sample basis by the
// CARFAC::RunSegemtn method, appending a single frame of n_ears x
n_channels
// data to the end of the individual data members selected for storage.
- void AppendOutput(const std::vector<Ear>& ears);
+ void AppendOutput(const std::vector<Ear*>& ears);
+
const std::deque<std::vector<ArrayX>>& nap() const { return nap_; }
const std::deque<std::vector<ArrayX>>& bm() const { return bm_; }
const std::deque<std::vector<ArrayX>>& nap_decim() const {
- return nap_decim_; }
+ return nap_decim_;
+ }
const std::deque<std::vector<ArrayX>>& ohc() const { return ohc_; }
const std::deque<std::vector<ArrayX>>& agc() const { return agc_; }

private:
- // TODO (alexbrandmeyer): figure out why this breaks object
initialization.
- //DISALLOW_COPY_AND_ASSIGN(CARFACOutput);
bool store_nap_;
bool store_nap_decim_;
bool store_bm_;
bool store_ohc_;
bool store_agc_;
-
+
// CARFAC outputs are stored in nested containers with dimensions:
// n_frames x n_ears x n_channels.
std::deque<std::vector<ArrayX>> nap_;
@@ -66,6 +66,8 @@
std::deque<std::vector<ArrayX>> bm_;
std::deque<std::vector<ArrayX>> ohc_;
std::deque<std::vector<ArrayX>> agc_;
+
+ DISALLOW_COPY_AND_ASSIGN(CARFACOutput);
};

#endif // CARFAC_CARFAC_OUTPUT_H
=======================================
--- /trunk/carfac/ear.cc Tue Jun 4 11:30:22 2013
+++ /trunk/carfac/ear.cc Tue Jun 11 10:59:08 2013
@@ -23,19 +23,25 @@
#include <assert.h>
#include "ear.h"

-void Ear::Init(const int num_channels, const CARCoeffs& car_coeffs,
- const IHCCoeffs& ihc_coeffs,
- const std::vector<AGCCoeffs>& agc_coeffs) {
+Ear::Ear(const int num_channels, const CARCoeffs& car_coeffs,
+ const IHCCoeffs& ihc_coeffs,
+ const std::vector<AGCCoeffs>& agc_coeffs) {
+ Reset(num_channels, car_coeffs, ihc_coeffs, agc_coeffs);
+}
+
+void Ear::Reset(const int num_channels, const CARCoeffs& car_coeffs,
+ const IHCCoeffs& ihc_coeffs,
+ const std::vector<AGCCoeffs>& agc_coeffs) {
num_channels_ = num_channels;
car_coeffs_ = car_coeffs;
ihc_coeffs_ = ihc_coeffs;
agc_coeffs_ = agc_coeffs;
- InitCARState();
- InitIHCState();
- InitAGCState();
+ ResetCARState();
+ ResetIHCState();
+ ResetAGCState();
}

-void Ear::InitCARState() {
+void Ear::ResetCARState() {
car_state_.z1_memory.setZero(num_channels_);
car_state_.z2_memory.setZero(num_channels_);
car_state_.za_memory.setZero(num_channels_);
@@ -46,7 +52,7 @@
car_state_.dg_memory.setZero(num_channels_);
}

-void Ear::InitIHCState() {
+void Ear::ResetIHCState() {
ihc_state_.ihc_accum = ArrayX::Zero(num_channels_);
if (! ihc_coeffs_.just_half_wave_rectify) {
ihc_state_.ac_coupler.setZero(num_channels_);
@@ -61,7 +67,7 @@
}
}

-void Ear::InitAGCState() {
+void Ear::ResetAGCState() {
int n_agc_stages = agc_coeffs_.size();
agc_state_.resize(n_agc_stages);
for (auto& stage_state : agc_state_) {
=======================================
--- /trunk/carfac/ear.h Tue Jun 4 11:30:22 2013
+++ /trunk/carfac/ear.h Tue Jun 11 10:59:08 2013
@@ -33,27 +33,33 @@

// The Ear object carries out the three steps of the CARFAC model on a
single
// channel of audio data, and stores information about the CAR, IHC and AGC
-// coefficients and states.
+// coefficients and states.
class Ear {
public:
-
- // This is the primary initialization function that is called for each
- // Ear object by the CARFAC::Design method.
- void Init(const int num_channels, const CARCoeffs& car_coeffs,
- const IHCCoeffs& ihc_coeffs,
- const std::vector<AGCCoeffs>& agc_coeffs);
-
+ Ear(const int num_channels, const CARCoeffs& car_coeffs,
+ const IHCCoeffs& ihc_coeffs,
+ const std::vector<AGCCoeffs>& agc_coeffs);
+
+ void Reset(const int num_channels, const CARCoeffs& car_coeffs,
+ const IHCCoeffs& ihc_coeffs,
+ const std::vector<AGCCoeffs>& agc_coeffs);
+
// These three methods apply the different steps of the model in sequence
// to individual audio samples during the call to CARFAC::RunSegment.
void CARStep(const FPType input);
+ // TODO(ronw): Consider changing the interface for the following two
+ // methods to access the internal state members directly instead of
+ // requiring callers to confusingly have to call an accessor method
+ // just to pass internal data back into the same object as in:
+ // ear.IHCStep(ear.car_out());
void IHCStep(const ArrayX& car_out);
bool AGCStep(const ArrayX& ihc_out);
-
+
// These accessor functions return portions of the CAR state for storage
in
// the CAROutput structures.
const ArrayX& za_memory() const { return car_state_.za_memory; }
const ArrayX& zb_memory() const { return car_state_.zb_memory; }
-
+
// The zy_memory_ of the CARState is equivalent to the CAR output. A
second
// accessor function is included for documentation purposes.
const ArrayX& zy_memory() const { return car_state_.zy_memory; }
@@ -62,7 +68,7 @@
const ArrayX& ihc_out() const { return ihc_state_.ihc_out; }
const ArrayX& dzb_memory() const { return car_state_.dzb_memory; }
const ArrayX& zr_coeffs() const { return car_coeffs_.zr_coeffs; }
-
+
// These accessor functions return portions of the AGC state during the
cross
// coupling of the ears.
const int agc_num_stages() const { return agc_coeffs_.size(); }
@@ -74,14 +80,14 @@
return agc_state_[stage].agc_memory; }
const int agc_decimation(const int stage) const {
return agc_coeffs_[stage].decimation; }
-
+
// This returns the stage G value during the closing of the AGC loop.
ArrayX StageGValue(const ArrayX& undamping);
-
+
// This function sets the AGC memory during the cross coupling stage.
void set_agc_memory(const int stage, const ArrayX& new_values) {
agc_state_[stage].agc_memory = new_values; }
-
+
// These are the setter functions for the CAR memory states.
void set_dzb_memory(const ArrayX& new_values) {
car_state_.dzb_memory = new_values; }
@@ -89,14 +95,11 @@
car_state_.dg_memory = new_values; }

private:
- // TODO (alexbrandmeyer): figure out why this breaks object
initialization.
- //DISALLOW_COPY_AND_ASSIGN(Ear);
-
// These methodsinitialize the model state variables prior to runtime.
- void InitIHCState();
- void InitAGCState();
- void InitCARState();
-
+ void ResetIHCState();
+ void ResetAGCState();
+ void ResetCARState();
+
// These are the helper sub-functions called during the model runtime.
void OHCNonlinearFunction(const ArrayX& velocities,
ArrayX* nonlinear_fun);
@@ -109,12 +112,14 @@
CARState car_state_;
IHCCoeffs ihc_coeffs_;
IHCState ihc_state_;
-
+
// The AGC coefficient and state variables are both stored in vectors
- // containing one element for each stage (default = 4).
+ // containing one element for each stage (default = 4).
std::vector<AGCCoeffs> agc_coeffs_;
std::vector<AGCState> agc_state_;
int num_channels_;
+
+ DISALLOW_COPY_AND_ASSIGN(Ear);
};

#endif // CARFAC_EAR_H