NoiseReductionBase::Worker Class Reference

Collaboration diagram for NoiseReductionBase::Worker:

Public Types
typedef NoiseReductionBase::Settings	Settings
typedef NoiseReductionBase::Statistics	Statistics

Public Member Functions
	Worker (NoiseReductionBase &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
NoiseReductionBase &	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 229 of file NoiseReductionBase.cpp.

Member Typedef Documentation

Settings

typedef NoiseReductionBase::Settings NoiseReductionBase::Worker::Settings

Definition at line 232 of file NoiseReductionBase.cpp.

Statistics

typedef NoiseReductionBase::Statistics NoiseReductionBase::Worker::Statistics

Definition at line 233 of file NoiseReductionBase.cpp.

Constructor & Destructor Documentation

Worker()

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

Definition at line 683 of file NoiseReductionBase.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{NoiseReductionBase.cpp}::DM_OLD_METHOD, NoiseReductionBase::Settings::mAttackTime, mBinHigh, mBinLow, mCenter, mDoProfile, mHistoryLen, anonymous_namespace{NoiseReductionBase.cpp}::minSignalTime, mMethod, mNoiseAttenFactor, NoiseReductionBase::Settings::mNoiseGain, mNWindowsToExamine, NoiseReductionBase::Settings::mOldSensitivity, mOldSensitivityFactor, mOneBlockAttack, mOneBlockRelease, NoiseReductionBase::Statistics::mRate, NoiseReductionBase::Settings::mReleaseTime, mSettings, mStatistics, anonymous_namespace{ClipSegmentTest.cpp}::sampleRate, settings(), NoiseReductionBase::Settings::StepSize(), and NoiseReductionBase::Settings::StepsPerWindow().

Here is the call graph for this function:

~Worker()

NoiseReductionBase::Worker::~Worker

(

)

Definition at line 553 of file NoiseReductionBase.cpp.

{
}

Member Function Documentation

ApplyFreqSmoothing()

void NoiseReductionBase::Worker::ApplyFreqSmoothing

(

FloatVector &

gains

)

Definition at line 648 of file NoiseReductionBase.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 NoiseReductionBase::mSettings.

Here is the call graph for this function:

Classify()

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

inline

Definition at line 866 of file NoiseReductionBase.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{NoiseReductionBase.cpp}::DM_MEDIAN, anonymous_namespace{NoiseReductionBase.cpp}::DM_OLD_METHOD, anonymous_namespace{NoiseReductionBase.cpp}::DM_SECOND_GREATEST, min(), MyTransformer::MyWindow::mSpectrums, NoiseReductionBase::mStatistics, MyTransformer::NthWindow(), and fast_float::detail::power().

Here is the call graph for this function:

FinishTrackStatistics()

void NoiseReductionBase::Worker::FinishTrackStatistics

(

)

Definition at line 804 of file NoiseReductionBase.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 NoiseReductionBase::mStatistics.

GatherStatistics()

void NoiseReductionBase::Worker::GatherStatistics

(

MyTransformer &

transformer

)

Definition at line 827 of file NoiseReductionBase.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(), NoiseReductionBase::mSettings, MyTransformer::MyWindow::mSpectrums, NoiseReductionBase::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 NoiseReductionBase::Worker::Process	(	eWindowFunctions	inWindowType,
		eWindowFunctions	outWindowType,
		TrackList &	tracks,
		double	mT0,
		double	mT1
	)

Definition at line 557 of file NoiseReductionBase.cpp.

{
   mProgressTrackCount = 0;
   for (auto track : tracks.Selected<WaveTrack>())
   {
      mProgressWindowCount = 0;
      if (track->GetRate() != mStatistics.mRate)
      {
         if (mDoProfile)
            BasicUI::ShowMessageBox(
               XO("All noise profile data must have the same sample rate."));
         else
            BasicUI::ShowMessageBox(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)
      {
         BasicUI::ShowMessageBox(XO("Selected noise profile is too short."));
         return false;
      }
   }
 
   return true;
}

References details::end(), min(), NoiseReductionBase::mSettings, NoiseReductionBase::mStatistics, TrackSpectrumTransformer::PostProcess(), BasicUI::ShowMessageBox(), tracks, and XO().

Here is the call graph for this function:

Processor()

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

static

Definition at line 770 of file NoiseReductionBase.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 NoiseReductionBase::Worker::ReduceNoise

(

MyTransformer &

transformer

)

Definition at line 941 of file NoiseReductionBase.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, NoiseReductionBase::mSettings, NRC_ISOLATE_NOISE, NRC_LEAVE_RESIDUE, MyTransformer::NthWindow(), and SpectrumTransformer::QueueIsFull().

Here is the call graph for this function:

Member Data Documentation

mBinHigh

size_t NoiseReductionBase::Worker::mBinHigh

Definition at line 268 of file NoiseReductionBase.cpp.

Referenced by Worker().

mBinLow

size_t NoiseReductionBase::Worker::mBinLow

Definition at line 267 of file NoiseReductionBase.cpp.

Referenced by Worker().

mCenter

unsigned NoiseReductionBase::Worker::mCenter

Definition at line 280 of file NoiseReductionBase.cpp.

Referenced by Worker().

mDoProfile

const bool NoiseReductionBase::Worker::mDoProfile

Definition at line 258 of file NoiseReductionBase.cpp.

Referenced by Worker().

mEffect

NoiseReductionBase& NoiseReductionBase::Worker::mEffect

Definition at line 260 of file NoiseReductionBase.cpp.

mFreqSmoothingBins

const size_t NoiseReductionBase::Worker::mFreqSmoothingBins

Definition at line 265 of file NoiseReductionBase.cpp.

mFreqSmoothingScratch

FloatVector NoiseReductionBase::Worker::mFreqSmoothingScratch

Definition at line 264 of file NoiseReductionBase.cpp.

mHistoryLen

unsigned NoiseReductionBase::Worker::mHistoryLen

Definition at line 281 of file NoiseReductionBase.cpp.

Referenced by Worker().

mLen

sampleCount NoiseReductionBase::Worker::mLen = 0

Definition at line 285 of file NoiseReductionBase.cpp.

mMethod

const int NoiseReductionBase::Worker::mMethod

Definition at line 271 of file NoiseReductionBase.cpp.

Referenced by Worker().

mNewSensitivity

const double NoiseReductionBase::Worker::mNewSensitivity

Definition at line 272 of file NoiseReductionBase.cpp.

mNoiseAttenFactor

float NoiseReductionBase::Worker::mNoiseAttenFactor

Definition at line 276 of file NoiseReductionBase.cpp.

Referenced by Worker().

mNoiseReductionChoice

const int NoiseReductionBase::Worker::mNoiseReductionChoice

Definition at line 270 of file NoiseReductionBase.cpp.

mNWindowsToExamine

unsigned NoiseReductionBase::Worker::mNWindowsToExamine

Definition at line 279 of file NoiseReductionBase.cpp.

Referenced by Worker().

mOldSensitivityFactor

float NoiseReductionBase::Worker::mOldSensitivityFactor

Definition at line 277 of file NoiseReductionBase.cpp.

Referenced by Worker().

mOneBlockAttack

float NoiseReductionBase::Worker::mOneBlockAttack

Definition at line 274 of file NoiseReductionBase.cpp.

Referenced by Worker().

mOneBlockRelease

float NoiseReductionBase::Worker::mOneBlockRelease

Definition at line 275 of file NoiseReductionBase.cpp.

Referenced by Worker().

mProgressTrackCount

unsigned NoiseReductionBase::Worker::mProgressTrackCount = 0

Definition at line 284 of file NoiseReductionBase.cpp.

mProgressWindowCount

sampleCount NoiseReductionBase::Worker::mProgressWindowCount = 0

Definition at line 286 of file NoiseReductionBase.cpp.

mSettings

const Settings& NoiseReductionBase::Worker::mSettings

Definition at line 261 of file NoiseReductionBase.cpp.

Referenced by Worker().

mStatistics

Statistics& NoiseReductionBase::Worker::mStatistics

Definition at line 262 of file NoiseReductionBase.cpp.

Referenced by Worker().

---

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

• NoiseReductionBase.cpp