DynamicRangeProcessorHistoryPanel Class Reference

#include <DynamicRangeProcessorHistoryPanel.h>

Inheritance diagram for DynamicRangeProcessorHistoryPanel:

Collaboration diagram for DynamicRangeProcessorHistoryPanel:

Classes
struct	ClockSynchronization

Public Member Functions
	DynamicRangeProcessorHistoryPanel (wxWindow *parent, wxWindowID winid, CompressorInstance &instance, std::function< void(float)> onDbRangeChanged)
void	ShowInput (bool show)
void	ShowOutput (bool show)
void	ShowActual (bool show)
void	ShowTarget (bool show)
	DECLARE_EVENT_TABLE ()
Public Member Functions inherited from wxPanelWrapper
	wxPanelWrapper ()
	wxPanelWrapper (wxWindow *parent, wxWindowID winid=wxID_ANY, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize, long style=wxTAB_TRAVERSAL|wxNO_BORDER, const TranslatableString &name=XO("Panel"))
bool	Create (wxWindow *parent, wxWindowID winid=wxID_ANY, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize, long style=wxTAB_TRAVERSAL|wxNO_BORDER, const TranslatableString &name=XO("Panel"))
void	SetLabel (const TranslatableString &label)
void	SetName (const TranslatableString &name)
void	SetToolTip (const TranslatableString &toolTip)
void	SetName ()
Public Member Functions inherited from wxTabTraversalWrapper< wxPanel >
	wxTabTraversalWrapper (Args &&... args)
	wxTabTraversalWrapper (const wxTabTraversalWrapper &)=delete
	wxTabTraversalWrapper (wxTabTraversalWrapper &&)=delete
wxTabTraversalWrapper &	operator= (const wxTabTraversalWrapper &)=delete
wxTabTraversalWrapper &	operator= (wxTabTraversalWrapper &&)=delete

Static Public Attributes
static constexpr auto	minWidth = 600

Private Member Functions
void	OnPaint (wxPaintEvent &evt)
void	OnSize (wxSizeEvent &evt)
void	OnTimer (wxTimerEvent &evt)
void	InitializeForPlayback (CompressorInstance &instance, double sampleRate)
bool	AcceptsFocus () const override
bool	AcceptsFocusFromKeyboard () const override

Private Attributes
CompressorInstance &	mCompressorInstance
std::shared_ptr< DynamicRangeProcessorOutputPacketQueue >	mOutputQueue
std::vector< DynamicRangeProcessorOutputPacket >	mPacketBuffer
std::optional< DynamicRangeProcessorHistory >	mHistory
DynamicRangeProcessorClock	mClock
const std::function< void(float)>	mOnDbRangeChanged
const Observer::Subscription	mInitializeProcessingSettingsSubscription
const Observer::Subscription	mRealtimeResumeSubscription
const Observer::Subscription	mPlaybackEventSubscription
wxTimer	mTimer
std::optional< ClockSynchronization >	mSync
std::vector< double >	mX
std::vector< wxPoint2DDouble >	mTarget
std::vector< wxPoint2DDouble >	mActual
std::vector< wxPoint2DDouble >	mInput
std::vector< wxPoint2DDouble >	mOutput
bool	mPlaybackAboutToStart = false
bool	mShowInput = true
bool	mShowOutput = true
bool	mShowActual = true
bool	mShowTarget = true

Detailed Description

Definition at line 27 of file DynamicRangeProcessorHistoryPanel.h.

Constructor & Destructor Documentation

DynamicRangeProcessorHistoryPanel()

DynamicRangeProcessorHistoryPanel::DynamicRangeProcessorHistoryPanel	(	wxWindow *	parent,
		wxWindowID	winid,
		CompressorInstance &	instance,
		std::function< void(float)>	onDbRangeChanged
	)

Definition at line 57 of file DynamicRangeProcessorHistoryPanel.cpp.

    : wxPanelWrapper { parent, winid }
    , mCompressorInstance { instance }
    , mOnDbRangeChanged { std::move(onDbRangeChanged) }
    , mInitializeProcessingSettingsSubscription { static_cast<
                                                     InitializeProcessingSettingsPublisher&>(
                                                     instance)
                                                     .Subscribe(
                                                        [&](const std::optional<
                                                            InitializeProcessingSettings>&
                                                               evt) {
                                                           if (evt)
                                                              InitializeForPlayback(
                                                                 instance,
                                                                 evt->sampleRate);
                                                           else
                                                              // Stop the
                                                              // timer-based
                                                              // update but keep
                                                              // the history
                                                              // until playback
                                                              // is resumed.
                                                              mTimer.Stop();
                                                        }) }
    , mRealtimeResumeSubscription { static_cast<RealtimeResumePublisher&>(
                                       instance)
                                       .Subscribe([this](auto) {
                                          if (mHistory)
                                             mHistory->BeginNewSegment();
                                       }) }
    , mPlaybackEventSubscription { AudioIO::Get()->Subscribe(
         [this](const AudioIOEvent& evt) {
            if (evt.type != AudioIOEvent::PAUSE)
               return;
            if (evt.on)
            {
               mTimer.Stop();
               mClock.Pause();
            }
            else
            {
               mClock.Resume();
               mTimer.Start(timerPeriodMs);
            }
         }) }
{
   if (const auto& sampleRate = instance.GetSampleRate();
       sampleRate.has_value())
      // Playback is ongoing, and so the `InitializeProcessingSettings` event
      // was already fired.
      InitializeForPlayback(instance, *sampleRate);
 
   SetDoubleBuffered(true);
   mTimer.SetOwner(this, timerId);
   SetSize({ minWidth, DynamicRangeProcessorPanel::graphMinHeight });
}

Member Function Documentation

AcceptsFocus()

bool DynamicRangeProcessorHistoryPanel::AcceptsFocus ( ) const

overrideprivate

Definition at line 558 of file DynamicRangeProcessorHistoryPanel.cpp.

{
   return false;
}

AcceptsFocusFromKeyboard()

bool DynamicRangeProcessorHistoryPanel::AcceptsFocusFromKeyboard ( ) const

overrideprivate

Definition at line 563 of file DynamicRangeProcessorHistoryPanel.cpp.

{
   return false;
}

DECLARE_EVENT_TABLE()

DynamicRangeProcessorHistoryPanel::DECLARE_EVENT_TABLE

(

)

InitializeForPlayback()

void DynamicRangeProcessorHistoryPanel::InitializeForPlayback ( CompressorInstance &  instance, double  sampleRate  )

private

Definition at line 532 of file DynamicRangeProcessorHistoryPanel.cpp.

{
   mSync.reset();
   mHistory.emplace(sampleRate);
   // We don't know for sure the least packet size (which is variable). 100
   // samples per packet at a rate of 8kHz is 12.5ms, which is quite low
   // latency. For higher sample rates that will be less.
   constexpr auto leastPacketSize = 100;
   const size_t maxQueueSize = DynamicRangeProcessorHistory::maxTimeSeconds *
                               sampleRate / leastPacketSize;
   mPacketBuffer.reserve(maxQueueSize);
   // Although `mOutputQueue` is a shared_ptr, we construct a unique_ptr and
   // invoke the shared_ptr ctor overload that takes a unique_ptr.
   // This way, we avoid the `error: aligned deallocation function of type
   // 'void (void *, std::align_val_t) noexcept' is only available on
   // macOS 10.13 or newer` compilation error.
   mOutputQueue =
      std::make_unique<DynamicRangeProcessorOutputPacketQueue>(maxQueueSize);
   instance.SetOutputQueue(mOutputQueue);
   mTimer.Start(timerPeriodMs);
   mPlaybackAboutToStart = true;
   Refresh(false);
   wxPanelWrapper::Update();
}

References DynamicRangeProcessorHistory::maxTimeSeconds, mHistory, mOutputQueue, mPacketBuffer, mPlaybackAboutToStart, mSync, mTimer, anonymous_namespace{ClipSegmentTest.cpp}::sampleRate, CompressorInstance::SetOutputQueue(), and anonymous_namespace{DynamicRangeProcessorHistoryPanel.cpp}::timerPeriodMs.

Here is the call graph for this function:

OnPaint()

void DynamicRangeProcessorHistoryPanel::OnPaint ( wxPaintEvent &  evt )

private

Definition at line 329 of file DynamicRangeProcessorHistoryPanel.cpp.

{
   wxPaintDC dc(this);
 
   using namespace DynamicRangeProcessorPanel;
 
   const auto gc = MakeGraphicsContext(dc);
   const auto rect = DynamicRangeProcessorPanel::GetPanelRect(*this);
   const auto x = rect.GetX();
   const auto y = rect.GetY();
   const auto width = rect.GetWidth();
   const auto height = rect.GetHeight();
 
   gc->SetBrush(GetGraphBackgroundBrush(*gc, height));
   gc->SetPen(wxTransparentColor);
   gc->DrawRectangle(x, y, width, height);
 
   Finally Do { [&] {
      // The legend is causing problems color-wise, and in the end it may not be
      // so useful since the different elements of the graph can be toggled.
      // Keep it up our sleeve for now, though. (Anyone still sees this in the
      // not-so-near future, feel free to clean up.)
      constexpr auto drawLegend = false;
      if (drawLegend)
         DrawLegend(height, dc, *gc);
      gc->SetBrush(*wxTRANSPARENT_BRUSH);
      gc->SetPen(lineColor);
      gc->DrawRectangle(x, y, width, height);
   } };
 
   if (!mHistory || !mSync)
   {
      if (!mPlaybackAboutToStart)
      {
         const auto text = XO("awaiting playback");
         const wxDCFontChanger changer { dc,
                                         { 16, wxFONTFAMILY_DEFAULT,
                                           wxFONTSTYLE_NORMAL,
                                           wxFONTWEIGHT_NORMAL } };
         const auto textWidth = dc.GetTextExtent(text.Translation()).GetWidth();
         const auto textHeight =
            dc.GetTextExtent(text.Translation()).GetHeight();
         dc.SetTextForeground(wxColor { 128, 128, 128 });
         dc.DrawText(
            text.Translation(), (width - textWidth) / 2,
            (height - textHeight) / 2);
      }
      return;
   }
 
   const auto& segments = mHistory->GetSegments();
   const auto elapsedTimeSinceFirstPacket =
      std::chrono::duration<float>(mSync->now - mSync->start).count();
   const auto rangeDb = DynamicRangeProcessorPanel::GetGraphDbRange(height);
   const auto dbPerPixel = rangeDb / height;
 
   for (const auto& segment : segments)
   {
      mX.clear();
      mTarget.clear();
      mActual.clear();
      mInput.clear();
      mOutput.clear();
 
      mX.resize(segment.size());
      auto lastInvisibleLeft = 0;
      auto firstInvisibleRight = 0;
      std::transform(
         segment.begin(), segment.end(), mX.begin(), [&](const auto& packet) {
            const auto x = GetDisplayPixel(
               elapsedTimeSinceFirstPacket -
                  (packet.time - mSync->firstPacketTime),
               width);
            if (x < 0)
               ++lastInvisibleLeft;
            if (x < width)
               ++firstInvisibleRight;
            return x;
         });
      lastInvisibleLeft = std::max<int>(--lastInvisibleLeft, 0);
      firstInvisibleRight = std::min<int>(++firstInvisibleRight, mX.size());
 
      mX.erase(mX.begin() + firstInvisibleRight, mX.end());
      mX.erase(mX.begin(), mX.begin() + lastInvisibleLeft);
 
      if (mX.size() < 2)
         continue;
 
      auto segmentIndex = lastInvisibleLeft;
      mTarget.reserve(mX.size());
      mActual.reserve(mX.size());
      mInput.reserve(mX.size());
      mOutput.reserve(mX.size());
      std::for_each(mX.begin(), mX.end(), [&](auto x) {
         const auto& packet = segment[segmentIndex++];
         const auto elapsedSincePacket = elapsedTimeSinceFirstPacket -
                                         (packet.time - mSync->firstPacketTime);
         mTarget.emplace_back(x, -packet.target / dbPerPixel);
         mActual.emplace_back(x, -packet.follower / dbPerPixel);
         mInput.emplace_back(x, -packet.input / dbPerPixel);
         mOutput.emplace_back(x, -packet.output / dbPerPixel);
      });
 
      if (mShowInput)
         FillUpTo(mInput, inputColor, *gc, rect);
 
      if (mShowOutput)
      {
         FillUpTo(mOutput, outputColor, *gc, rect);
         const auto outputGc = MakeGraphicsContext(dc);
         outputGc->SetPen({ wxColor { outputColor.GetRGB() }, 2 });
         outputGc->DrawLines(mOutput.size(), mOutput.data());
      }
 
      if (mShowActual)
      {
         // First draw a thick line, and then the thinner line in its center
         // with colors indicating overshoot and undershoot.
         const auto actualGc = MakeGraphicsContext(dc);
 
         actualGc->SetPen(
            wxPen { actualCompressionColor, GetActualCompressionLineWidth() });
         actualGc->DrawLines(mActual.size(), mActual.data());
         if (MayUsePenGradients())
         {
            // So that we can converge to `actualCompressionColor` at the
            // crossings of actual and target compression.
            InsertCrossings(mTarget, mActual);
 
            wxGraphicsGradientStops stops;
            const auto xLeft = mActual.front().m_x;
            const auto xRight = mActual.back().m_x;
            const auto span = xRight - xLeft;
            for (auto i = 0; i < mActual.size(); ++i)
            {
               const auto diff = mTarget[i].m_y - mActual[i].m_y;
               const auto actualIsBelow = diff < 0;
               const auto w = std::min(1.0, std::abs(diff) * dbPerPixel / 6);
               const auto color = GetColorMix(
                                     actualIsBelow ? releaseColor : attackColor,
                                     actualCompressionColor, w)
                                     .GetRGB();
               stops.Add(color, (mActual[i].m_x - xLeft) / span);
            }
            wxGraphicsPenInfo penInfo;
            penInfo
               .LinearGradient(
                  mActual.front().m_x, 0, mActual.back().m_x, 0, stops)
               .Width(targetCompressionLineWidth);
 
            actualGc->SetPen(actualGc->CreatePen(penInfo));
            actualGc->DrawLines(mActual.size(), mActual.data());
         }
      }
 
      if (mShowTarget)
      {
         const auto targetGc = MakeGraphicsContext(dc);
         targetGc->SetPen(
            wxPen { targetCompressionColor, targetCompressionLineWidth });
         targetGc->DrawLines(mTarget.size(), mTarget.data());
      }
   }
}

References DynamicRangeProcessorPanel::actualCompressionColor, DynamicRangeProcessorPanel::attackColor, anonymous_namespace{DynamicRangeProcessorHistoryPanel.cpp}::DrawLegend(), anonymous_namespace{DynamicRangeProcessorHistoryPanel.cpp}::FillUpTo(), anonymous_namespace{DynamicRangeProcessorHistoryPanel.cpp}::GetActualCompressionLineWidth(), DynamicRangeProcessorPanel::GetColorMix(), DynamicRangeProcessorPanel::GetGraphBackgroundBrush(), DynamicRangeProcessorPanel::GetGraphDbRange(), DynamicRangeProcessorPanel::GetPanelRect(), DynamicRangeProcessorPanel::inputColor, anonymous_namespace{DynamicRangeProcessorHistoryPanel.cpp}::InsertCrossings(), DynamicRangeProcessorPanel::lineColor, mActual, DynamicRangeProcessorPanel::MakeGraphicsContext(), anonymous_namespace{DynamicRangeProcessorHistoryPanel.cpp}::MayUsePenGradients(), mHistory, min(), mInput, mOutput, mPlaybackAboutToStart, mShowActual, mShowInput, mShowOutput, mShowTarget, mSync, mTarget, mX, DynamicRangeProcessorPanel::outputColor, DynamicRangeProcessorPanel::releaseColor, DynamicRangeProcessorPanel::targetCompressionColor, DynamicRangeProcessorPanel::targetCompressionLineWidth, and XO().

Here is the call graph for this function:

OnSize()

void DynamicRangeProcessorHistoryPanel::OnSize ( wxSizeEvent &  evt )

private

Definition at line 494 of file DynamicRangeProcessorHistoryPanel.cpp.

{
   Refresh(false);
   mOnDbRangeChanged(
      DynamicRangeProcessorPanel::GetGraphDbRange(GetSize().GetHeight()));
}

References DynamicRangeProcessorPanel::GetGraphDbRange(), and mOnDbRangeChanged.

Here is the call graph for this function:

OnTimer()

void DynamicRangeProcessorHistoryPanel::OnTimer ( wxTimerEvent &  evt )

private

Definition at line 501 of file DynamicRangeProcessorHistoryPanel.cpp.

{
   mPacketBuffer.clear();
   DynamicRangeProcessorOutputPacket packet;
   while (mOutputQueue->Get(packet))
      mPacketBuffer.push_back(packet);
   mHistory->Push(mPacketBuffer);
 
   if (mHistory->IsEmpty())
      return;
 
   // Do now get `std::chrono::steady_clock::now()` in the `OnPaint` event,
   // because this can be triggered even when playback is paused.
   const auto now = mClock.GetNow();
   if (!mSync)
      // At the time of writing, the realtime playback doesn't account for
      // varying latencies. When it does, the synchronization will have to be
      // updated on latency change. See
      // https://github.com/audacity/audacity/issues/3223#issuecomment-2137025150.
      mSync.emplace(
         ClockSynchronization { mHistory->GetSegments().front().front().time +
                                   mCompressorInstance.GetLatencyMs() / 1000,
                                now });
   mPlaybackAboutToStart = false;
 
   mSync->now = now;
 
   Refresh(false);
   wxPanelWrapper::Update();
}

References CompressorInstance::GetLatencyMs(), DynamicRangeProcessorClock::GetNow(), mClock, mCompressorInstance, mHistory, mOutputQueue, mPacketBuffer, mPlaybackAboutToStart, and mSync.

Here is the call graph for this function:

ShowActual()

void DynamicRangeProcessorHistoryPanel::ShowActual

(

bool

show

)

Definition at line 317 of file DynamicRangeProcessorHistoryPanel.cpp.

{
   mShowActual = show;
   Refresh(false);
}

References mShowActual.

ShowInput()

void DynamicRangeProcessorHistoryPanel::ShowInput

(

bool

show

)

Definition at line 305 of file DynamicRangeProcessorHistoryPanel.cpp.

{
   mShowInput = show;
   Refresh(false);
}

References mShowInput.

ShowOutput()

void DynamicRangeProcessorHistoryPanel::ShowOutput

(

bool

show

)

Definition at line 311 of file DynamicRangeProcessorHistoryPanel.cpp.

{
   mShowOutput = show;
   Refresh(false);
}

References mShowOutput.

ShowTarget()

void DynamicRangeProcessorHistoryPanel::ShowTarget

(

bool

show

)

Definition at line 323 of file DynamicRangeProcessorHistoryPanel.cpp.

{
   mShowTarget = show;
   Refresh(false);
}

References mShowTarget.

Member Data Documentation

mActual

std::vector<wxPoint2DDouble> DynamicRangeProcessorHistoryPanel::mActual

private

Definition at line 74 of file DynamicRangeProcessorHistoryPanel.h.

Referenced by OnPaint().

mClock

DynamicRangeProcessorClock DynamicRangeProcessorHistoryPanel::mClock

private

Definition at line 65 of file DynamicRangeProcessorHistoryPanel.h.

Referenced by OnTimer().

mCompressorInstance

CompressorInstance& DynamicRangeProcessorHistoryPanel::mCompressorInstance

private

Definition at line 61 of file DynamicRangeProcessorHistoryPanel.h.

Referenced by OnTimer().

mHistory

std::optional<DynamicRangeProcessorHistory> DynamicRangeProcessorHistoryPanel::mHistory

private

Definition at line 64 of file DynamicRangeProcessorHistoryPanel.h.

Referenced by InitializeForPlayback(), OnPaint(), and OnTimer().

mInitializeProcessingSettingsSubscription

const Observer::Subscription DynamicRangeProcessorHistoryPanel::mInitializeProcessingSettingsSubscription

private

Definition at line 67 of file DynamicRangeProcessorHistoryPanel.h.

mInput

std::vector<wxPoint2DDouble> DynamicRangeProcessorHistoryPanel::mInput

private

Definition at line 75 of file DynamicRangeProcessorHistoryPanel.h.

Referenced by OnPaint().

minWidth

constexpr auto DynamicRangeProcessorHistoryPanel::minWidth = 600

staticconstexpr

Definition at line 30 of file DynamicRangeProcessorHistoryPanel.h.

mOnDbRangeChanged

const std::function<void(float)> DynamicRangeProcessorHistoryPanel::mOnDbRangeChanged

private

Definition at line 66 of file DynamicRangeProcessorHistoryPanel.h.

Referenced by OnSize().

mOutput

std::vector<wxPoint2DDouble> DynamicRangeProcessorHistoryPanel::mOutput

private

Definition at line 76 of file DynamicRangeProcessorHistoryPanel.h.

Referenced by OnPaint().

mOutputQueue

std::shared_ptr<DynamicRangeProcessorOutputPacketQueue> DynamicRangeProcessorHistoryPanel::mOutputQueue

private

Definition at line 62 of file DynamicRangeProcessorHistoryPanel.h.

Referenced by InitializeForPlayback(), and OnTimer().

mPacketBuffer

std::vector<DynamicRangeProcessorOutputPacket> DynamicRangeProcessorHistoryPanel::mPacketBuffer

private

Definition at line 63 of file DynamicRangeProcessorHistoryPanel.h.

Referenced by InitializeForPlayback(), and OnTimer().

mPlaybackAboutToStart

bool DynamicRangeProcessorHistoryPanel::mPlaybackAboutToStart = false

private

Definition at line 77 of file DynamicRangeProcessorHistoryPanel.h.

Referenced by InitializeForPlayback(), OnPaint(), and OnTimer().

mPlaybackEventSubscription

const Observer::Subscription DynamicRangeProcessorHistoryPanel::mPlaybackEventSubscription

private

Definition at line 69 of file DynamicRangeProcessorHistoryPanel.h.

mRealtimeResumeSubscription

const Observer::Subscription DynamicRangeProcessorHistoryPanel::mRealtimeResumeSubscription

private

Definition at line 68 of file DynamicRangeProcessorHistoryPanel.h.

mShowActual

bool DynamicRangeProcessorHistoryPanel::mShowActual = true

private

Definition at line 80 of file DynamicRangeProcessorHistoryPanel.h.

Referenced by OnPaint(), and ShowActual().

mShowInput

bool DynamicRangeProcessorHistoryPanel::mShowInput = true

private

Definition at line 78 of file DynamicRangeProcessorHistoryPanel.h.

Referenced by OnPaint(), and ShowInput().

mShowOutput

bool DynamicRangeProcessorHistoryPanel::mShowOutput = true

private

Definition at line 79 of file DynamicRangeProcessorHistoryPanel.h.

Referenced by OnPaint(), and ShowOutput().

mShowTarget

bool DynamicRangeProcessorHistoryPanel::mShowTarget = true

private

Definition at line 81 of file DynamicRangeProcessorHistoryPanel.h.

Referenced by OnPaint(), and ShowTarget().

mSync

std::optional<ClockSynchronization> DynamicRangeProcessorHistoryPanel::mSync

private

Definition at line 71 of file DynamicRangeProcessorHistoryPanel.h.

Referenced by InitializeForPlayback(), OnPaint(), and OnTimer().

mTarget

std::vector<wxPoint2DDouble> DynamicRangeProcessorHistoryPanel::mTarget

private

Definition at line 73 of file DynamicRangeProcessorHistoryPanel.h.

Referenced by OnPaint().

mTimer

wxTimer DynamicRangeProcessorHistoryPanel::mTimer

private

Definition at line 70 of file DynamicRangeProcessorHistoryPanel.h.

Referenced by InitializeForPlayback().

mX

std::vector<double> DynamicRangeProcessorHistoryPanel::mX

private

Definition at line 72 of file DynamicRangeProcessorHistoryPanel.h.

Referenced by OnPaint().

---

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

• DynamicRangeProcessorHistoryPanel.h
• DynamicRangeProcessorHistoryPanel.cpp