Implements EBU-R128 loudness measurement. More...

#include <EBUR128.h>

Collaboration diagram for EBUR128:

Public Member Functions
	EBUR128 (double rate, size_t channels)

	EBUR128 (const EBUR128 &)=delete

	EBUR128 (EBUR128 &&)=delete

	~EBUR128 ()=default

void	ProcessSampleFromChannel (float x_in, size_t channel) const

void	NextSample ()

double	IntegrativeLoudness ()

double	IntegrativeLoudnessToLUFS (double loudness)

Static Public Member Functions
static ArrayOf< Biquad >	CalcWeightingFilter (double fs)

Private Member Functions
void	HistogramSums (size_t start_idx, double &sum_v, long int &sum_c) const

void	AddBlockToHistogram (size_t validLen)

Private Attributes
ArrayOf< long int >	mLoudnessHist

Doubles	mBlockRingBuffer

size_t	mSampleCount { 0 }

size_t	mBlockRingPos { 0 }

size_t	mBlockRingSize { 0 }

const size_t	mChannelCount

const double	mRate

const size_t	mBlockSize

const size_t	mBlockOverlap

ArrayOf< ArrayOf< Biquad > >	mWeightingFilter

Static Private Attributes
static constexpr size_t	HIST_BIN_COUNT = 65536

static constexpr double	GAMMA_A = (-70.0 + 0.691) / 10.0
	EBU R128 absolute threshold. More...

Detailed Description

Implements EBU-R128 loudness measurement.

Definition at line 21 of file EBUR128.h.

Constructor & Destructor Documentation

◆ EBUR128() [1/3]

EBUR128::EBUR128	(	double	rate,
		size_t	channels
	)

Definition at line 14 of file EBUR128.cpp.

   : mChannelCount{ channels }
   , mRate{ rate }
   , mBlockSize( ceil(0.4 * mRate) ) // 400 ms blocks
   , mBlockOverlap( ceil(0.1 * mRate) ) // 100 ms overlap
{
   mLoudnessHist.reinit(HIST_BIN_COUNT, false);
   mBlockRingBuffer.reinit(mBlockSize);
   mWeightingFilter.reinit(mChannelCount, false);
   for(size_t channel = 0; channel < mChannelCount; ++channel)
      mWeightingFilter[channel] = CalcWeightingFilter(mRate);
 
   memset(mLoudnessHist.get(), 0, HIST_BIN_COUNT*sizeof(long int));
   for(size_t channel = 0; channel < mChannelCount; ++channel)
   {
      mWeightingFilter[channel][0].Reset();
      mWeightingFilter[channel][1].Reset();
   }
}

References CalcWeightingFilter(), HIST_BIN_COUNT, mBlockRingBuffer, mBlockSize, mChannelCount, mLoudnessHist, mRate, mWeightingFilter, and ArrayOf< X >::reinit().

Here is the call graph for this function:

◆ EBUR128() [2/3]

EBUR128::EBUR128 ( const EBUR128 & )

delete

◆ EBUR128() [3/3]

EBUR128::EBUR128 ( EBUR128 && )

delete

◆ ~EBUR128()

EBUR128::~EBUR128 ( )

default

Member Function Documentation

◆ AddBlockToHistogram()

void EBUR128::AddBlockToHistogram ( size_t validLen )

private

Process new full block. Incomplete blocks shall be discarded according to the EBU R128 specification there is usually no need to call this on the last block. However, allow to override the block size if the audio to be processed is shorter than one block.

Definition at line 167 of file EBUR128.cpp.

{
   // Reset mBlockRingSize to full state to avoid overflow.
   // The actual value of mBlockRingSize does not matter
   // since this is only used to detect if blocks are complete (>= mBlockSize).
   mBlockRingSize = mBlockSize;
 
   size_t idx;
   double blockVal = 0;
   for(size_t i = 0; i < validLen; ++i)
      blockVal += mBlockRingBuffer[i];
 
   // Histogram values are simplified log10() immediate values
   // without -0.691 + 10*(...) to safe computing power. This is
   // possible because these constant cancel out anyway during the
   // following processing steps.
   blockVal = log10(blockVal/double(validLen));
   // log(blockVal) is within ]-inf, 1]
   idx = round((blockVal - GAMMA_A) * double(HIST_BIN_COUNT) / -GAMMA_A - 1);
 
   // idx is within ]-inf, HIST_BIN_COUNT-1], discard indices below 0
   // as they are below the EBU R128 absolute threshold anyway.
   if(idx < HIST_BIN_COUNT)
      ++mLoudnessHist[idx];
}

References GAMMA_A, HIST_BIN_COUNT, mBlockRingBuffer, mBlockRingSize, mBlockSize, mLoudnessHist, and fast_float::round().

Referenced by IntegrativeLoudness(), and NextSample().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CalcWeightingFilter()

ArrayOf< Biquad > EBUR128::CalcWeightingFilter ( double fs )

static

Definition at line 42 of file EBUR128.cpp.

{
   ArrayOf<Biquad> pBiquad(size_t(2), true);
 
   //
   // HSF pre filter
   //
   double db =    3.999843853973347;
   double f0 = 1681.974450955533;
   double Q  =    0.7071752369554196;
   double K  = tan(M_PI * f0 / fs);
 
   double Vh = pow(10.0, db / 20.0);
   double Vb = pow(Vh, 0.4996667741545416);
 
   double a0 = 1.0 + K / Q + K * K;
 
   pBiquad[0].fNumerCoeffs[Biquad::B0] = (Vh + Vb * K / Q + K * K) / a0;
   pBiquad[0].fNumerCoeffs[Biquad::B1] =       2.0 * (K * K -  Vh) / a0;
   pBiquad[0].fNumerCoeffs[Biquad::B2] = (Vh - Vb * K / Q + K * K) / a0;
 
   pBiquad[0].fDenomCoeffs[Biquad::A1] =   2.0 * (K * K - 1.0) / a0;
   pBiquad[0].fDenomCoeffs[Biquad::A2] = (1.0 - K / Q + K * K) / a0;
 
   //
   // HPF weighting filter
   //
   f0 = 38.13547087602444;
   Q  =  0.5003270373238773;
   K  = tan(M_PI * f0 / fs);
 
   pBiquad[1].fNumerCoeffs[Biquad::B0] =  1.0;
   pBiquad[1].fNumerCoeffs[Biquad::B1] = -2.0;
   pBiquad[1].fNumerCoeffs[Biquad::B2] =  1.0;
 
   pBiquad[1].fDenomCoeffs[Biquad::A1] = 2.0 * (K * K - 1.0) / (1.0 + K / Q + K * K);
   pBiquad[1].fDenomCoeffs[Biquad::A2] = (1.0 - K / Q + K * K) / (1.0 + K / Q + K * K);
 
   return pBiquad;
}

References Biquad::A1, Biquad::A2, Biquad::B0, Biquad::B1, Biquad::B2, crypto::anonymous_namespace{SHA256.cpp}::K, and M_PI.

Referenced by EBUR128().

Here is the caller graph for this function:

◆ HistogramSums()

void EBUR128::HistogramSums	(	size_t	start_idx,
		double &	sum_v,
		long int &	sum_c
	)		const

private

Definition at line 149 of file EBUR128.cpp.

{
    double val;
    sum_v = 0;
    sum_c = 0;
    for(size_t i = start_idx; i < HIST_BIN_COUNT; ++i)
    {
       val = -GAMMA_A / double(HIST_BIN_COUNT) * (i+1) + GAMMA_A;
       sum_v += pow(10, val) * mLoudnessHist[i];
       sum_c += mLoudnessHist[i];
    }
}

References GAMMA_A, HIST_BIN_COUNT, and mLoudnessHist.

Referenced by IntegrativeLoudness().

Here is the caller graph for this function:

◆ IntegrativeLoudness()

double EBUR128::IntegrativeLoudness ( )

Definition at line 115 of file EBUR128.cpp.

{
   // EBU R128: z_i = mean square without root
 
   // Calculate Gamma_R from histogram.
   double sum_v;
   long int sum_c;
   HistogramSums(0, sum_v, sum_c);
 
   // Handle incomplete block if no non-zero block was found.
   if(sum_c == 0)
   {
      AddBlockToHistogram(mBlockRingSize);
      HistogramSums(0, sum_v, sum_c);
   }
 
   // Histogram values are simplified log(x^2) immediate values
   // without -0.691 + 10*(...) to safe computing power. This is
   // possible because they will cancel out anyway.
   // The -1 in the line below is the -10 LUFS from the EBU R128
   // specification without the scaling factor of 10.
   double Gamma_R = log10(sum_v/sum_c) - 1;
   size_t idx_R = round((Gamma_R - GAMMA_A) * double(HIST_BIN_COUNT) / -GAMMA_A - 1);
 
   // Apply Gamma_R threshold and calculate gated loudness (extent).
   HistogramSums(idx_R+1, sum_v, sum_c);
   if(sum_c == 0)
      // Silence was processed.
      return 0;
   // LUFS is defined as -0.691 dB + 10*log10(sum(channels))
   return 0.8529037031 * sum_v / sum_c;
}

References AddBlockToHistogram(), GAMMA_A, HIST_BIN_COUNT, HistogramSums(), mBlockRingSize, and fast_float::round().

Here is the call graph for this function:

◆ IntegrativeLoudnessToLUFS()

double EBUR128::IntegrativeLoudnessToLUFS ( double loudness )

inline

Definition at line 33 of file EBUR128.h.

34 { return 10 * log10(loudness); }

◆ NextSample()

void EBUR128::NextSample ( )

Definition at line 98 of file EBUR128.cpp.

{
   ++mBlockRingPos;
   ++mBlockRingSize;
 
   if(mBlockRingPos % mBlockOverlap == 0)
   {
      // A new full block of samples was submitted.
      if(mBlockRingSize >= mBlockSize)
         AddBlockToHistogram(mBlockSize);
   }
   // Close the ring.
   if(mBlockRingPos == mBlockSize)
      mBlockRingPos = 0;
   ++mSampleCount;
}

References AddBlockToHistogram(), mBlockOverlap, mBlockRingPos, mBlockRingSize, mBlockSize, and mSampleCount.

Referenced by LoudnessBase::AnalyseBufferBlock().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ProcessSampleFromChannel()

void EBUR128::ProcessSampleFromChannel	(	float	x_in,
		size_t	channel
	)		const

Definition at line 83 of file EBUR128.cpp.

{
   double value;
   value = mWeightingFilter[channel][0].ProcessOne(x_in);
   value = mWeightingFilter[channel][1].ProcessOne(value);
   if(channel == 0)
      mBlockRingBuffer[mBlockRingPos] = value * value;
   else
   {
      // Add the power of additional channels to the power of first channel.
      // As a result, stereo tracks appear about 3 LUFS louder, as specified.
      mBlockRingBuffer[mBlockRingPos] += value * value;
   }
}

References mBlockRingBuffer, mBlockRingPos, and mWeightingFilter.

Referenced by LoudnessBase::AnalyseBufferBlock().

Here is the caller graph for this function:

Member Data Documentation

◆ GAMMA_A

constexpr double EBUR128::GAMMA_A = (-70.0 + 0.691) / 10.0

staticconstexprprivate

EBU R128 absolute threshold.

Definition at line 42 of file EBUR128.h.

Referenced by AddBlockToHistogram(), HistogramSums(), and IntegrativeLoudness().

◆ HIST_BIN_COUNT

constexpr size_t EBUR128::HIST_BIN_COUNT = 65536

staticconstexprprivate

Definition at line 40 of file EBUR128.h.

Referenced by AddBlockToHistogram(), EBUR128(), HistogramSums(), and IntegrativeLoudness().

◆ mBlockOverlap

const size_t EBUR128::mBlockOverlap

private

Definition at line 51 of file EBUR128.h.

Referenced by NextSample().

◆ mBlockRingBuffer

Doubles EBUR128::mBlockRingBuffer

private

Definition at line 44 of file EBUR128.h.

Referenced by AddBlockToHistogram(), EBUR128(), and ProcessSampleFromChannel().

◆ mBlockRingPos

size_t EBUR128::mBlockRingPos { 0 }

private

Definition at line 46 of file EBUR128.h.

Referenced by NextSample(), and ProcessSampleFromChannel().

◆ mBlockRingSize

size_t EBUR128::mBlockRingSize { 0 }

private

Definition at line 47 of file EBUR128.h.

Referenced by AddBlockToHistogram(), IntegrativeLoudness(), and NextSample().

◆ mBlockSize

const size_t EBUR128::mBlockSize

private

Definition at line 50 of file EBUR128.h.

Referenced by AddBlockToHistogram(), EBUR128(), and NextSample().

◆ mChannelCount

const size_t EBUR128::mChannelCount

private

Definition at line 48 of file EBUR128.h.

Referenced by EBUR128().

◆ mLoudnessHist

ArrayOf<long int> EBUR128::mLoudnessHist

private

Definition at line 43 of file EBUR128.h.

Referenced by AddBlockToHistogram(), EBUR128(), and HistogramSums().

◆ mRate

const double EBUR128::mRate

private

Definition at line 49 of file EBUR128.h.

Referenced by EBUR128().

◆ mSampleCount

size_t EBUR128::mSampleCount { 0 }

private

Definition at line 45 of file EBUR128.h.

Referenced by NextSample().

◆ mWeightingFilter

ArrayOf<ArrayOf<Biquad> > EBUR128::mWeightingFilter

private

This is be an array of arrays of the type mWeightingFilter[CHANNEL][FILTER] with CHANNEL = LEFT/RIGHT (0/1) and FILTER = HSF/HPF (0/1)

Definition at line 57 of file EBUR128.h.

Referenced by EBUR128(), and ProcessSampleFromChannel().

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

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ EBUR128() [1/3]

◆ EBUR128() [2/3]

◆ EBUR128() [3/3]

◆ ~EBUR128()

Member Function Documentation

◆ AddBlockToHistogram()

◆ CalcWeightingFilter()

◆ HistogramSums()

◆ IntegrativeLoudness()

◆ IntegrativeLoudnessToLUFS()

◆ NextSample()

◆ ProcessSampleFromChannel()

Member Data Documentation

◆ GAMMA_A

◆ HIST_BIN_COUNT

◆ mBlockOverlap

◆ mBlockRingBuffer

◆ mBlockRingPos

◆ mBlockRingSize

◆ mBlockSize

◆ mChannelCount

◆ mLoudnessHist

◆ mRate

◆ mSampleCount

◆ mWeightingFilter