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	Initialize ()

void	ProcessSampleFromChannel (float x_in, size_t channel)

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)

void	AddBlockToHistogram (size_t validLen)

Private Attributes
ArrayOf< long int >	mLoudnessHist

Doubles	mBlockRingBuffer

size_t	mSampleCount

size_t	mBlockRingPos

size_t	mBlockRingSize

size_t	mBlockSize

size_t	mBlockOverlap

size_t	mChannelCount

double	mRate

ArrayOf< ArrayOf< Biquad > >	mWeightingFilter

Static Private Attributes
static const 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);
}

References CalcWeightingFilter(), HIST_BIN_COUNT, mBlockOverlap, 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 172 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 48 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, 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
	)

private

Definition at line 154 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:

◆ Initialize()

void EBUR128::Initialize ( )

Definition at line 27 of file EBUR128.cpp.

{
   mSampleCount = 0;
   mBlockRingPos = 0;
   mBlockRingSize = 0;
   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 HIST_BIN_COUNT, mBlockRingPos, mBlockRingSize, mChannelCount, mLoudnessHist, mSampleCount, and mWeightingFilter.

◆ IntegrativeLoudness()

double EBUR128::IntegrativeLoudness ( )

Definition at line 121 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 34 of file EBUR128.h.

35 { return 10 * log10(loudness); }

◆ NextSample()

void EBUR128::NextSample ( )

Definition at line 104 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.

Here is the call graph for this function:

◆ ProcessSampleFromChannel()

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

Definition at line 89 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.

Member Data Documentation

◆ GAMMA_A

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

staticconstexprprivate

EBU R128 absolute threshold.

Definition at line 43 of file EBUR128.h.

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

◆ HIST_BIN_COUNT

const size_t EBUR128::HIST_BIN_COUNT = 65536

staticprivate

Definition at line 41 of file EBUR128.h.

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

◆ mBlockOverlap

size_t EBUR128::mBlockOverlap

private

Definition at line 50 of file EBUR128.h.

Referenced by EBUR128(), and NextSample().

◆ mBlockRingBuffer

Doubles EBUR128::mBlockRingBuffer

private

Definition at line 45 of file EBUR128.h.

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

◆ mBlockRingPos

size_t EBUR128::mBlockRingPos

private

Definition at line 47 of file EBUR128.h.

Referenced by Initialize(), NextSample(), and ProcessSampleFromChannel().

◆ mBlockRingSize

size_t EBUR128::mBlockRingSize

private

Definition at line 48 of file EBUR128.h.

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

◆ mBlockSize

size_t EBUR128::mBlockSize

private

Definition at line 49 of file EBUR128.h.

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

◆ mChannelCount

size_t EBUR128::mChannelCount

private

Definition at line 51 of file EBUR128.h.

Referenced by EBUR128(), and Initialize().

◆ mLoudnessHist

ArrayOf<long int> EBUR128::mLoudnessHist

private

Definition at line 44 of file EBUR128.h.

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

◆ mRate

double EBUR128::mRate

private

Definition at line 52 of file EBUR128.h.

Referenced by EBUR128().

◆ mSampleCount

size_t EBUR128::mSampleCount

private

Definition at line 46 of file EBUR128.h.

Referenced by Initialize(), and 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 58 of file EBUR128.h.

Referenced by EBUR128(), Initialize(), 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()

◆ Initialize()

◆ IntegrativeLoudness()

◆ IntegrativeLoudnessToLUFS()

◆ NextSample()

◆ ProcessSampleFromChannel()

Member Data Documentation

◆ GAMMA_A

◆ HIST_BIN_COUNT

◆ mBlockOverlap

◆ mBlockRingBuffer

◆ mBlockRingPos

◆ mBlockRingSize

◆ mBlockSize

◆ mChannelCount

◆ mLoudnessHist

◆ mRate

◆ mSampleCount

◆ mWeightingFilter