EffectNoiseReduction::Worker Class Reference

Collaboration diagram for EffectNoiseReduction::Worker:

Public Types
typedef EffectNoiseReduction::Settings	Settings
typedef EffectNoiseReduction::Statistics	Statistics

Public Member Functions
	Worker (EffectNoiseReduction &effect, const Settings &settings, Statistics &statistics)
	~Worker ()
bool	Process (eWindowFunctions inWindowType, eWindowFunctions outWindowType, TrackList &tracks, double mT0, double mT1)
void	ApplyFreqSmoothing (FloatVector &gains)
void	GatherStatistics (MyTransformer &transformer)
bool	Classify (MyTransformer &transformer, unsigned nWindows, int band)
void	ReduceNoise (MyTransformer &transformer)
void	FinishTrackStatistics ()

Static Public Member Functions
static bool	Processor (SpectrumTransformer &transformer)

Public Attributes
const bool	mDoProfile
EffectNoiseReduction &	mEffect
const Settings &	mSettings
Statistics &	mStatistics
FloatVector	mFreqSmoothingScratch
const size_t	mFreqSmoothingBins
size_t	mBinLow
size_t	mBinHigh
const int	mNoiseReductionChoice
const int	mMethod
const double	mNewSensitivity
float	mOneBlockAttack
float	mOneBlockRelease
float	mNoiseAttenFactor
float	mOldSensitivityFactor
unsigned	mNWindowsToExamine
unsigned	mCenter
unsigned	mHistoryLen
unsigned	mProgressTrackCount = 0
sampleCount	mLen = 0
sampleCount	mProgressWindowCount = 0

Detailed Description

Definition at line 293 of file NoiseReduction.cpp.

Member Typedef Documentation

Settings

typedef EffectNoiseReduction::Settings EffectNoiseReduction::Worker::Settings

Definition at line 296 of file NoiseReduction.cpp.

Statistics

typedef EffectNoiseReduction::Statistics EffectNoiseReduction::Worker::Statistics

Definition at line 297 of file NoiseReduction.cpp.

Constructor & Destructor Documentation

Worker()

EffectNoiseReduction::Worker::Worker	(	EffectNoiseReduction &	effect,
		const Settings &	settings,
		Statistics &	statistics
	)

Definition at line 835 of file NoiseReduction.cpp.

: mDoProfile{ settings.mDoProfile }
 
, mEffect{ effect }
, mSettings{ settings }
, mStatistics{ statistics }
 
, mFreqSmoothingScratch(mSettings.SpectrumSize())
, mFreqSmoothingBins{ size_t(std::max(0.0, settings.mFreqSmoothingBands)) }
, mBinLow{ 0 }
, mBinHigh{ mSettings.SpectrumSize() }
 
, mNoiseReductionChoice{ settings.mNoiseReductionChoice }
, mMethod{ settings.mMethod }
 
// Sensitivity setting is a base 10 log, turn it into a natural log
, mNewSensitivity{ settings.mNewSensitivity * log(10.0) }
{
   const auto sampleRate = mStatistics.mRate;
 
#ifdef SPECTRAL_EDIT_NOISE_REDUCTION
   {
      // mBinLow is inclusive, mBinHigh is exclusive, of
      // the range of frequencies to affect.  Include any
      // bin that partly overlaps the selected range of frequencies.
      const double bin = sampleRate / mWindowSize;
      if (f0 >= 0.0 )
         mBinLow = floor(f0 / bin);
      if (f1 >= 0.0)
         mBinHigh = ceil(f1 / bin);
   }
#endif
 
   const double noiseGain = -settings.mNoiseGain;
   const unsigned nAttackBlocks =
      1 + (int)(settings.mAttackTime * sampleRate / mSettings.StepSize());
   const unsigned nReleaseBlocks =
      1 + (int)(settings.mReleaseTime * sampleRate / mSettings.StepSize());
   // Applies to amplitudes, divide by 20:
   mNoiseAttenFactor = DB_TO_LINEAR(noiseGain);
   // Apply to gain factors which apply to amplitudes, divide by 20:
   mOneBlockAttack = DB_TO_LINEAR(noiseGain / nAttackBlocks);
   mOneBlockRelease = DB_TO_LINEAR(noiseGain / nReleaseBlocks);
   // Applies to power, divide by 10:
   mOldSensitivityFactor = pow(10.0, settings.mOldSensitivity / 10.0);
 
   mNWindowsToExamine = (mMethod == DM_OLD_METHOD)
      ? std::max(2, (int)(minSignalTime * sampleRate / mSettings.StepSize()))
      : 1 + mSettings.StepsPerWindow();
 
   mCenter = mNWindowsToExamine / 2;
   wxASSERT(mCenter >= 1); // release depends on this assumption
 
   if (mDoProfile)
#ifdef OLD_METHOD_AVAILABLE
      mHistoryLen = mNWindowsToExamine;
#else
      mHistoryLen = 1;
#endif
   else {
      // Allow long enough queue for sufficient inspection of the middle
      // and for attack processing
      // See ReduceNoise()
      mHistoryLen = std::max(mNWindowsToExamine, mCenter + nAttackBlocks);
   }
}

References DB_TO_LINEAR, anonymous_namespace{NoiseReduction.cpp}::DM_OLD_METHOD, EffectNoiseReduction::Settings::mAttackTime, mBinHigh, mBinLow, mCenter, mDoProfile, mHistoryLen, anonymous_namespace{NoiseReduction.cpp}::minSignalTime, mMethod, mNoiseAttenFactor, EffectNoiseReduction::Settings::mNoiseGain, mNWindowsToExamine, EffectNoiseReduction::Settings::mOldSensitivity, mOldSensitivityFactor, mOneBlockAttack, mOneBlockRelease, EffectNoiseReduction::Statistics::mRate, EffectNoiseReduction::Settings::mReleaseTime, mSettings, mStatistics, anonymous_namespace{ClipSegmentTest.cpp}::sampleRate, settings(), EffectNoiseReduction::Settings::StepSize(), and EffectNoiseReduction::Settings::StepsPerWindow().

Here is the call graph for this function:

~Worker()

EffectNoiseReduction::Worker::~Worker

(

)

Definition at line 717 of file NoiseReduction.cpp.

{
}

Member Function Documentation

ApplyFreqSmoothing()

void EffectNoiseReduction::Worker::ApplyFreqSmoothing

(

FloatVector &

gains

)

Definition at line 802 of file NoiseReduction.cpp.

{
   // Given an array of gain mutipliers, average them
   // GEOMETRICALLY.  Don't multiply and take nth root --
   // that may quickly cause underflows.  Instead, average the logs.
 
   if (mFreqSmoothingBins == 0)
      return;
 
   const auto spectrumSize = mSettings.SpectrumSize();
 
   {
      auto pScratch = mFreqSmoothingScratch.data();
      std::fill(pScratch, pScratch + spectrumSize, 0.0f);
   }
 
   for (size_t ii = 0; ii < spectrumSize; ++ii)
      gains[ii] = log(gains[ii]);
 
   // ii must be signed
   for (int ii = 0; ii < (int)spectrumSize; ++ii) {
      const int j0 = std::max(0, ii - (int)mFreqSmoothingBins);
      const int j1 = std::min(spectrumSize - 1, ii + mFreqSmoothingBins);
      for(int jj = j0; jj <= j1; ++jj) {
         mFreqSmoothingScratch[ii] += gains[jj];
      }
      mFreqSmoothingScratch[ii] /= (j1 - j0 + 1);
   }
 
   for (size_t ii = 0; ii < spectrumSize; ++ii)
      gains[ii] = exp(mFreqSmoothingScratch[ii]);
}

References min(), and EffectNoiseReduction::mSettings.

Here is the call graph for this function:

Classify()

bool EffectNoiseReduction::Worker::Classify ( MyTransformer &  transformer, unsigned  nWindows, int  band  )

inline

Definition at line 1008 of file NoiseReduction.cpp.

{
   switch (mMethod) {
#ifdef OLD_METHOD_AVAILABLE
   case DM_OLD_METHOD:
      {
         float min = NthWindow(0).mSpectrums[band];
         for (unsigned ii = 1; ii < nWindows; ++ii)
            min = std::min(min, NthWindow(ii).mSpectrums[band]);
         return
            min <= mOldSensitivityFactor * mStatistics.mNoiseThreshold[band];
      }
#endif
   // New methods suppose an exponential distribution of power values
   // in the noise; NEW sensitivity (which is nonnegative) is meant to be
   // the negative of a log of probability (so the log is nonpositive)
   // that noise strays above the threshold.  Call that probability
   // 1 - F.  The quantile function of an exponential distribution is
   // - log (1 - F) * mean.  Thus simply multiply mean by sensitivity
   // to get the threshold.
   case DM_MEDIAN:
      // This method examines the window and all other windows
      // whose centers lie on or between its boundaries, and takes a median, to
      // avoid being fooled by up and down excursions into
      // either the mistake of classifying noise as not noise
      // (leaving a musical noise chime), or the opposite
      // (distorting the signal with a drop out).
      if (nWindows <= 3)
         // No different from second greatest.
         goto secondGreatest;
      else if (nWindows <= 5)
      {
         float greatest = 0.0, second = 0.0, third = 0.0;
         for (unsigned ii = 0; ii < nWindows; ++ii) {
            const float power = transformer.NthWindow(ii).mSpectrums[band];
            if (power >= greatest)
               third = second, second = greatest, greatest = power;
            else if (power >= second)
               third = second, second = power;
            else if (power >= third)
               third = power;
         }
         return third <= mNewSensitivity * mStatistics.mMeans[band];
      }
      else {
         // not implemented
         wxASSERT(false);
         return true;
      }
   secondGreatest:
   case DM_SECOND_GREATEST:
      {
         // This method just throws out the high outlier.  It
         // should be less prone to distortions and more prone to
         // chimes.
         float greatest = 0.0, second = 0.0;
         for (unsigned ii = 0; ii < nWindows; ++ii) {
            const float power = transformer.NthWindow(ii).mSpectrums[band];
            if (power >= greatest)
               second = greatest, greatest = power;
            else if (power >= second)
               second = power;
         }
         return second <= mNewSensitivity * mStatistics.mMeans[band];
      }
   default:
      wxASSERT(false);
      return true;
   }
}

References anonymous_namespace{NoiseReduction.cpp}::DM_MEDIAN, anonymous_namespace{NoiseReduction.cpp}::DM_OLD_METHOD, anonymous_namespace{NoiseReduction.cpp}::DM_SECOND_GREATEST, min(), MyTransformer::MyWindow::mSpectrums, EffectNoiseReduction::mStatistics, MyTransformer::NthWindow(), and fast_float::detail::power().

Here is the call graph for this function:

FinishTrackStatistics()

void EffectNoiseReduction::Worker::FinishTrackStatistics

(

)

Definition at line 949 of file NoiseReduction.cpp.

{
   const auto windows = mStatistics.mTrackWindows;
 
   // Combine averages in case of multiple profile tracks.
   if (windows) {
      const auto multiplier = mStatistics.mTotalWindows;
      const auto denom = windows + multiplier;
      for (size_t ii = 0, nn = mStatistics.mMeans.size(); ii < nn; ++ii) {
         auto &mean = mStatistics.mMeans[ii];
         auto &sum = mStatistics.mSums[ii];
         mean = (mean * multiplier + sum) / denom;
         // Reset for next track
         sum = 0;
      }
      // Reset for next track
      mStatistics.mTrackWindows = 0;
      mStatistics.mTotalWindows = denom;
   }
}

References EffectNoiseReduction::mStatistics.

GatherStatistics()

void EffectNoiseReduction::Worker::GatherStatistics

(

MyTransformer &

transformer

)

Definition at line 970 of file NoiseReduction.cpp.

{
   ++mStatistics.mTrackWindows;
 
   {
      // NEW statistics
      auto pPower = transformer.NthWindow(0).mSpectrums.data();
      auto pSum = mStatistics.mSums.data();
      for (size_t jj = 0; jj < mSettings.SpectrumSize(); ++jj) {
         *pSum++ += *pPower++;
      }
   }
 
#ifdef OLD_METHOD_AVAILABLE
   // The noise threshold for each frequency is the maximum
   // level achieved at that frequency for a minimum of
   // mMinSignalBlocks blocks in a row - the max of a min.
 
   auto finish = mHistoryLen;
 
   {
      // old statistics
      auto pPower = NthWindow(0).mSpectrums.data();
      auto pThreshold = mStatistics.mNoiseThreshold.data();
      for (size_t jj = 0; jj < mSpectrumSize; ++jj) {
         float min = *pPower++;
         for (unsigned ii = 1; ii < finish; ++ii)
            min = std::min(min, NthWindow(ii).mSpectrums[jj]);
         *pThreshold = std::max(*pThreshold, min);
         ++pThreshold;
      }
   }
#endif
}

References min(), EffectNoiseReduction::mSettings, MyTransformer::MyWindow::mSpectrums, EffectNoiseReduction::mStatistics, and MyTransformer::NthWindow().

Referenced by Processor().

Here is the call graph for this function:

Here is the caller graph for this function:

Process()

bool EffectNoiseReduction::Worker::Process	(	eWindowFunctions	inWindowType,
		eWindowFunctions	outWindowType,
		TrackList &	tracks,
		double	mT0,
		double	mT1
	)

Definition at line 721 of file NoiseReduction.cpp.

{
   mProgressTrackCount = 0;
   for (auto track : tracks.Selected<WaveTrack>()) {
      mProgressWindowCount = 0;
      if (track->GetRate() != mStatistics.mRate) {
         if (mDoProfile)
            EffectUIServices::DoMessageBox(mEffect,
               XO("All noise profile data must have the same sample rate.") );
         else
            EffectUIServices::DoMessageBox(mEffect,
               XO(
"The sample rate of the noise profile must match that of the sound to be processed.") );
         return false;
      }
 
      double trackStart = track->GetStartTime();
      double trackEnd = track->GetEndTime();
      double t0 = std::max(trackStart, inT0);
      double t1 = std::min(trackEnd, inT1);
 
      if (t1 > t0) {
         auto start = track->TimeToLongSamples(t0);
         auto end = track->TimeToLongSamples(t1);
         const auto len = end - start;
         mLen = len;
         const auto extra =
            (mSettings.StepsPerWindow() - 1) * mSettings.SpectrumSize();
         // Adjust denominator for presence or absence of padding,
         // which makes the number of windows visited either more or less
         // than the number of window steps in the data.
         if (mDoProfile)
            mLen -= extra;
         else
            mLen += extra;
 
         auto t0 = track->LongSamplesToTime(start);
         auto tLen = track->LongSamplesToTime(len);
         std::optional<WaveTrack::Holder> ppTempTrack;
         std::optional<ChannelGroup::ChannelIterator<WaveChannel>> pIter;
         WaveTrack *pFirstTrack{};
         if (!mSettings.mDoProfile) {
            ppTempTrack.emplace(track->EmptyCopy());
            pFirstTrack = ppTempTrack->get();
            pIter.emplace(pFirstTrack->Channels().begin());
         }
         for (const auto pChannel : track->Channels()) {
            auto pOutputTrack = pIter ? *(*pIter)++ : nullptr;
            MyTransformer transformer{ *this, pOutputTrack.get(),
               !mSettings.mDoProfile, inWindowType, outWindowType,
               mSettings.WindowSize(), mSettings.StepsPerWindow(),
               !mSettings.mDoProfile, !mSettings.mDoProfile
            };
            if (!transformer
               .Process(Processor, *pChannel, mHistoryLen, start, len))
               return false;
            ++mProgressTrackCount;
         }
         if (ppTempTrack) {
            TrackSpectrumTransformer::PostProcess(*pFirstTrack, len);
            constexpr auto preserveSplits = true;
            constexpr auto merge = true;
            track->ClearAndPaste(
               t0, t0 + tLen, **ppTempTrack, preserveSplits, merge);
         }
      }
   }
 
   if (mDoProfile) {
      if (mStatistics.mTotalWindows == 0) {
         EffectUIServices::DoMessageBox(mEffect,
            XO("Selected noise profile is too short."));
         return false;
      }
   }
 
   return true;
}

References EffectUIServices::DoMessageBox(), details::end(), min(), EffectNoiseReduction::mSettings, EffectNoiseReduction::mStatistics, TrackSpectrumTransformer::PostProcess(), EffectNoiseReduction::Process(), tracks, and XO().

Here is the call graph for this function:

Processor()

bool EffectNoiseReduction::Worker::Processor ( SpectrumTransformer &  transformer )

static

Definition at line 918 of file NoiseReduction.cpp.

{
   auto &transformer = static_cast<MyTransformer &>(trans);
   auto &worker = transformer.mWorker;
   // Compute power spectrum in the newest window
   {
      auto &record = transformer.NthWindow(0);
      float *pSpectrum = &record.mSpectrums[0];
      const double dc = record.mRealFFTs[0];
      *pSpectrum++ = dc * dc;
      float *pReal = &record.mRealFFTs[1], *pImag = &record.mImagFFTs[1];
      for (size_t nn = worker.mSettings.SpectrumSize() - 2; nn--;) {
         const double re = *pReal++, im = *pImag++;
         *pSpectrum++ = re * re + im * im;
      }
      const double nyquist = record.mImagFFTs[0];
      *pSpectrum = nyquist * nyquist;
   }
 
   if (worker.mDoProfile)
      worker.GatherStatistics(transformer);
   else
      worker.ReduceNoise(transformer);
 
   // Update the Progress meter, let user cancel
   return !worker.mEffect.TrackProgress(worker.mProgressTrackCount,
      std::min(1.0,
         ((++worker.mProgressWindowCount).as_double() *
          worker.mSettings.StepSize()) / worker.mLen.as_double()));
}

References GatherStatistics(), min(), and MyTransformer::mWorker.

Here is the call graph for this function:

ReduceNoise()

void EffectNoiseReduction::Worker::ReduceNoise

(

MyTransformer &

transformer

)

Definition at line 1080 of file NoiseReduction.cpp.

{
   auto historyLen = transformer.CurrentQueueSize();
   auto nWindows = std::min<unsigned>(mNWindowsToExamine, historyLen);
 
   const auto spectrumSize = mSettings.SpectrumSize();
 
   if (mNoiseReductionChoice != NRC_ISOLATE_NOISE)
   {
      auto &record = transformer.NthWindow(0);
      // Default all gains to the reduction factor,
      // until we decide to raise some of them later
      float *pGain = &record.mGains[0];
      std::fill(pGain, pGain + spectrumSize, mNoiseAttenFactor);
   }
 
   // Raise the gain for elements in the center of the sliding history
   // or, if isolating noise, zero out the non-noise
   if (nWindows > mCenter)
   {
      auto pGain = transformer.NthWindow(mCenter).mGains.data();
      if (mNoiseReductionChoice == NRC_ISOLATE_NOISE) {
         // All above or below the selected frequency range is non-noise
         std::fill(pGain, pGain + mBinLow, 0.0f);
         std::fill(pGain + mBinHigh, pGain + spectrumSize, 0.0f);
         pGain += mBinLow;
         for (size_t jj = mBinLow; jj < mBinHigh; ++jj) {
               const bool isNoise = Classify(transformer, nWindows, jj);
            *pGain++ = isNoise ? 1.0 : 0.0;
         }
      }
      else {
         // All above or below the selected frequency range is non-noise
         std::fill(pGain, pGain + mBinLow, 1.0f);
         std::fill(pGain + mBinHigh, pGain + spectrumSize, 1.0f);
         pGain += mBinLow;
         for (size_t jj = mBinLow; jj < mBinHigh; ++jj) {
            const bool isNoise = Classify(transformer, nWindows, jj);
            if (!isNoise)
               *pGain = 1.0;
            ++pGain;
         }
      }
   }
 
   if (mNoiseReductionChoice != NRC_ISOLATE_NOISE)
   {
      // In each direction, define an exponential decay of gain from the
      // center; make actual gains the maximum of mNoiseAttenFactor, and
      // the decay curve, and their prior values.
 
      // First, the attack, which goes backward in time, which is,
      // toward higher indices in the queue.
      for (size_t jj = 0; jj < spectrumSize; ++jj) {
         for (unsigned ii = mCenter + 1; ii < historyLen; ++ii) {
            const float minimum =
               std::max(mNoiseAttenFactor,
                  transformer.NthWindow(ii - 1).mGains[jj] * mOneBlockAttack);
            float &gain = transformer.NthWindow(ii).mGains[jj];
            if (gain < minimum)
               gain = minimum;
            else
               // We can stop now, our attack curve is intersecting
               // the release curve of some window previously processed.
               break;
         }
      }
 
      // Now, release.  We need only look one window ahead.  This part will
      // be visited again when we examine the next window, and
      // carry the decay further.
      {
         auto pNextGain = transformer.NthWindow(mCenter - 1).mGains.data();
         auto pThisGain = transformer.NthWindow(mCenter).mGains.data();
         for (auto nn = mSettings.SpectrumSize(); nn--;) {
            *pNextGain =
               std::max(*pNextGain,
                        std::max(mNoiseAttenFactor,
                                 *pThisGain++ * mOneBlockRelease));
            ++pNextGain;
         }
      }
   }
 
 
   if (transformer.QueueIsFull()) {
      auto &record = transformer.NthWindow(historyLen - 1);  // end of the queue
      const auto last = mSettings.SpectrumSize() - 1;
 
      if (mNoiseReductionChoice != NRC_ISOLATE_NOISE)
         // Apply frequency smoothing to output gain
         // Gains are not less than mNoiseAttenFactor
         ApplyFreqSmoothing(record.mGains);
 
      // Apply gain to FFT
      {
         const float *pGain = &record.mGains[1];
         float *pReal = &record.mRealFFTs[1];
         float *pImag = &record.mImagFFTs[1];
         auto nn = mSettings.SpectrumSize() - 2;
         if (mNoiseReductionChoice == NRC_LEAVE_RESIDUE) {
            for (; nn--;) {
               // Subtract the gain we would otherwise apply from 1, and
               // negate that to flip the phase.
               const double gain = *pGain++ - 1.0;
               *pReal++ *= gain;
               *pImag++ *= gain;
            }
            record.mRealFFTs[0] *= (record.mGains[0] - 1.0);
            // The Fs/2 component is stored as the imaginary part of the DC component
            record.mImagFFTs[0] *= (record.mGains[last] - 1.0);
         }
         else {
            for (; nn--;) {
               const double gain = *pGain++;
               *pReal++ *= gain;
               *pImag++ *= gain;
            }
            record.mRealFFTs[0] *= record.mGains[0];
            // The Fs/2 component is stored as the imaginary part of the DC component
            record.mImagFFTs[0] *= record.mGains[last];
         }
      }
   }
}

References SpectrumTransformer::CurrentQueueSize(), MyTransformer::MyWindow::mGains, EffectNoiseReduction::mSettings, anonymous_namespace{NoiseReduction.cpp}::NRC_ISOLATE_NOISE, anonymous_namespace{NoiseReduction.cpp}::NRC_LEAVE_RESIDUE, MyTransformer::NthWindow(), and SpectrumTransformer::QueueIsFull().

Here is the call graph for this function:

Member Data Documentation

mBinHigh

size_t EffectNoiseReduction::Worker::mBinHigh

Definition at line 329 of file NoiseReduction.cpp.

Referenced by Worker().

mBinLow

size_t EffectNoiseReduction::Worker::mBinLow

Definition at line 328 of file NoiseReduction.cpp.

Referenced by Worker().

mCenter

unsigned EffectNoiseReduction::Worker::mCenter

Definition at line 341 of file NoiseReduction.cpp.

Referenced by Worker().

mDoProfile

const bool EffectNoiseReduction::Worker::mDoProfile

Definition at line 319 of file NoiseReduction.cpp.

Referenced by Worker().

mEffect

EffectNoiseReduction& EffectNoiseReduction::Worker::mEffect

Definition at line 321 of file NoiseReduction.cpp.

mFreqSmoothingBins

const size_t EffectNoiseReduction::Worker::mFreqSmoothingBins

Definition at line 326 of file NoiseReduction.cpp.

mFreqSmoothingScratch

FloatVector EffectNoiseReduction::Worker::mFreqSmoothingScratch

Definition at line 325 of file NoiseReduction.cpp.

mHistoryLen

unsigned EffectNoiseReduction::Worker::mHistoryLen

Definition at line 342 of file NoiseReduction.cpp.

Referenced by Worker().

mLen

sampleCount EffectNoiseReduction::Worker::mLen = 0

Definition at line 346 of file NoiseReduction.cpp.

mMethod

const int EffectNoiseReduction::Worker::mMethod

Definition at line 332 of file NoiseReduction.cpp.

Referenced by Worker().

mNewSensitivity

const double EffectNoiseReduction::Worker::mNewSensitivity

Definition at line 333 of file NoiseReduction.cpp.

mNoiseAttenFactor

float EffectNoiseReduction::Worker::mNoiseAttenFactor

Definition at line 337 of file NoiseReduction.cpp.

Referenced by Worker().

mNoiseReductionChoice

const int EffectNoiseReduction::Worker::mNoiseReductionChoice

Definition at line 331 of file NoiseReduction.cpp.

mNWindowsToExamine

unsigned EffectNoiseReduction::Worker::mNWindowsToExamine

Definition at line 340 of file NoiseReduction.cpp.

Referenced by Worker().

mOldSensitivityFactor

float EffectNoiseReduction::Worker::mOldSensitivityFactor

Definition at line 338 of file NoiseReduction.cpp.

Referenced by Worker().

mOneBlockAttack

float EffectNoiseReduction::Worker::mOneBlockAttack

Definition at line 335 of file NoiseReduction.cpp.

Referenced by Worker().

mOneBlockRelease

float EffectNoiseReduction::Worker::mOneBlockRelease

Definition at line 336 of file NoiseReduction.cpp.

Referenced by Worker().

mProgressTrackCount

unsigned EffectNoiseReduction::Worker::mProgressTrackCount = 0

Definition at line 345 of file NoiseReduction.cpp.

mProgressWindowCount

sampleCount EffectNoiseReduction::Worker::mProgressWindowCount = 0

Definition at line 347 of file NoiseReduction.cpp.

mSettings

const Settings& EffectNoiseReduction::Worker::mSettings

Definition at line 322 of file NoiseReduction.cpp.

Referenced by Worker().

mStatistics

Statistics& EffectNoiseReduction::Worker::mStatistics

Definition at line 323 of file NoiseReduction.cpp.

Referenced by Worker().

---

The documentation for this class was generated from the following file:

• NoiseReduction.cpp