#include <DynamicRangeProcessorHistory.h>

Collaboration diagram for DynamicRangeProcessorHistory:

Classes
struct	Packet

Public Types
using	Segment = std::vector< Packet >

Public Member Functions
	DynamicRangeProcessorHistory (double sampleRate)

void	Push (const std::vector< DynamicRangeProcessorOutputPacket > &packets)

void	BeginNewSegment ()

const std::vector< Segment > &	GetSegments () const

bool	IsEmpty () const

Static Public Attributes
static constexpr auto	maxTimeSeconds = 2.5f

Private Member Functions
float	GetPacketTime (const DynamicRangeProcessorOutputPacket &packet) const

Private Attributes
const double	mSampleRate

bool	mBeginNewSegment = true

std::vector< Segment >	mSegments

std::optional< long long >	mFirstPacketFirstSampleIndex

std::optional< long long >	mExpectedNextPacketFirstSampleIndex

Detailed Description

Audacity: A Digital Audio Editor

DynamicRangeProcessorHistory.h

Matthieu Hodgkinson

Definition at line 18 of file DynamicRangeProcessorHistory.h.

Member Typedef Documentation

◆ Segment

using DynamicRangeProcessorHistory::Segment = std::vector<Packet>

Definition at line 34 of file DynamicRangeProcessorHistory.h.

Constructor & Destructor Documentation

◆ DynamicRangeProcessorHistory()

DynamicRangeProcessorHistory::DynamicRangeProcessorHistory ( double sampleRate )

Audacity: A Digital Audio Editor

DynamicRangeProcessorHistory.cpp

Matthieu Hodgkinson

Definition at line 17 of file DynamicRangeProcessorHistory.cpp.

    : mSampleRate { sampleRate }
{
}

Member Function Documentation

◆ BeginNewSegment()

void DynamicRangeProcessorHistory::BeginNewSegment ( )

Definition at line 86 of file DynamicRangeProcessorHistory.cpp.

{
   mBeginNewSegment = true;
}

References mBeginNewSegment.

◆ GetPacketTime()

float DynamicRangeProcessorHistory::GetPacketTime ( const DynamicRangeProcessorOutputPacket & packet ) const

private

Definition at line 104 of file DynamicRangeProcessorHistory.cpp.

{
   assert(mFirstPacketFirstSampleIndex.has_value());
   return (packet.indexOfFirstSample -
           mFirstPacketFirstSampleIndex.value_or(0)) /
          mSampleRate;
}

References DynamicRangeProcessorOutputPacket::indexOfFirstSample, mFirstPacketFirstSampleIndex, and mSampleRate.

◆ GetSegments()

const std::vector< DynamicRangeProcessorHistory::Segment > & DynamicRangeProcessorHistory::GetSegments ( ) const

Definition at line 92 of file DynamicRangeProcessorHistory.cpp.

{
   return mSegments;
}

References mSegments.

Referenced by TEST_CASE().

Here is the caller graph for this function:

◆ IsEmpty()

bool DynamicRangeProcessorHistory::IsEmpty ( ) const

Definition at line 97 of file DynamicRangeProcessorHistory.cpp.

{
   return std::all_of(
      mSegments.begin(), mSegments.end(),
      [](const auto& segment) { return segment.empty(); });
}

References mSegments.

◆ Push()

void DynamicRangeProcessorHistory::Push ( const std::vector< DynamicRangeProcessorOutputPacket > & packets )

Definition at line 22 of file DynamicRangeProcessorHistory.cpp.

{
   if (packets.empty())
      return;
 
   if (!mFirstPacketFirstSampleIndex.has_value())
      mFirstPacketFirstSampleIndex = packets.front().indexOfFirstSample;
 
   const int numNewPackets = packets.size();
   const auto lastPacketTime = !mSegments.empty() && !mSegments[0].empty() ?
                                  std::make_optional(mSegments[0].back().time) :
                                  std::nullopt;
 
   const auto firstPacketToInsertIt =
      std::find_if(packets.begin(), packets.end(), [&](const auto& packet) {
         return !lastPacketTime.has_value() ||
                GetPacketTime(packet) > *lastPacketTime;
      });
 
   if (firstPacketToInsertIt == packets.end())
      return;
 
   // Some packets can go lost in the transmission from audio to main thread.
   const auto isContinuous = mExpectedNextPacketFirstSampleIndex.has_value() &&
                             firstPacketToInsertIt->indexOfFirstSample ==
                                *mExpectedNextPacketFirstSampleIndex;
   if (mSegments.empty() || mBeginNewSegment || !isContinuous)
   {
      mSegments.emplace_back();
      mBeginNewSegment = false;
   }
   mExpectedNextPacketFirstSampleIndex =
      packets.back().indexOfFirstSample + packets.back().numSamples;
 
   auto& lastSegment = mSegments.back();
 
   std::transform(
      firstPacketToInsertIt, packets.end(), std::back_inserter(lastSegment),
      [&](const auto& packet) -> Packet {
         const auto t = GetPacketTime(packet);
         return { t, packet.targetCompressionDb, packet.actualCompressionDb,
                  packet.inputDb, packet.outputDb };
      });
 
   // Clean up older packets.
   // Algorithmically it's not completely correct to only do this for the oldest
   // segment, but in practice, `Push` is called much more often than
   // `BeginNewSegment`, so a simpler implementation is sufficient.
   const auto lastTime = lastSegment.back().time;
   auto& firstSegment = mSegments.front();
   const auto it = std::find_if(
      firstSegment.begin(), firstSegment.end(),
      [lastTime](const Packet& packet) {
         // Extend a little bit the time window, to avoid the extremities of a
         // display to tremble.
         return lastTime - packet.time < maxTimeSeconds + 1.f;
      });
   firstSegment.erase(firstSegment.begin(), it);
 
   if (firstSegment.empty())
      mSegments.erase(mSegments.begin());
}