Functions
bool	MayUsePenGradients ()

int	GetActualCompressionLineWidth ()

double	GetDisplayPixel (float elapsedSincePacket, int panelWidth)

void	InsertCrossings (std::vector< wxPoint2DDouble > &A, std::vector< wxPoint2DDouble > &B)

void	FillUpTo (std::vector< wxPoint2DDouble > lines, const wxColor &color, wxGraphicsContext &gc, const wxRect &rect)

void	DrawLegend (size_t height, wxPaintDC &dc, wxGraphicsContext &gc)

Variables
constexpr auto	timerId = 7000

constexpr auto	timerPeriodMs = 1000 / 200

Detailed Description

Audacity: A Digital Audio Editor

DynamicRangeProcessorHistoryPanel.cpp

Matthieu Hodgkinson

Function Documentation

◆ DrawLegend()

void anonymous_namespace{DynamicRangeProcessorHistoryPanel.cpp}::DrawLegend	(	size_t	height,
		wxPaintDC &	dc,
		wxGraphicsContext &	gc
	)

Definition at line 206 of file DynamicRangeProcessorHistoryPanel.cpp.

{
   using namespace DynamicRangeProcessorPanel;
 
   constexpr auto legendWidth = 16;
   constexpr auto legendHeight = 16;
   constexpr auto legendSpacing = 8;
   constexpr auto legendX = 5;
   const auto legendY = height - 5 - legendHeight;
   const auto legendTextX = legendX + legendWidth + 5;
   const auto legendTextHeight = dc.GetTextExtent("X").GetHeight();
   const auto legendTextYOffset = (legendHeight - legendTextHeight) / 2;
   const auto legendTextY = legendY + legendTextYOffset;
 
   struct LegendInfo
   {
      const wxColor color;
      const TranslatableString text;
   };
 
   std::vector<LegendInfo> legends = {
      { inputColor, XO("Input") },
      { outputColor, XO("Output") },
   };
 
   int legendTextXOffset = 0;
   dc.SetTextForeground(*wxBLACK);
   dc.SetFont(
      { 10, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL });
   for (const auto& legend : legends)
   {
      // First fill with background color so that transparent foreground colors
      // yield the same result as on the graph.
      gc.SetPen(*wxTRANSPARENT_PEN);
      gc.SetBrush(backgroundColor);
      gc.DrawRectangle(
         legendX + legendTextXOffset, legendY, legendWidth, legendHeight);
 
      gc.SetBrush(wxColor { legend.color.GetRGB() });
      gc.DrawRectangle(
         legendX + legendTextXOffset, legendY, legendWidth, legendHeight);
 
      gc.SetPen(lineColor);
      gc.SetBrush(*wxTRANSPARENT_BRUSH);
      gc.DrawRectangle(
         legendX + legendTextXOffset, legendY, legendWidth, legendHeight);
 
      dc.DrawText(
         legend.text.Translation(), legendTextX + legendTextXOffset,
         legendTextY);
      const auto legendTextWidth =
         dc.GetTextExtent(legend.text.Translation()).GetWidth();
      legendTextXOffset += legendWidth + 5 + legendTextWidth + legendSpacing;
   }
 
   const auto lineY = legendY + legendHeight / 2.;
   constexpr auto lineWidth = 24;
 
   // Actual compression
   const auto actualX = legendX + legendTextXOffset + legendSpacing;
   const std::array<wxPoint2DDouble, 2> actualLine {
      wxPoint2DDouble(actualX, lineY),
      wxPoint2DDouble(actualX + lineWidth, lineY)
   };
 
   gc.SetPen({ actualCompressionColor, GetActualCompressionLineWidth() });
   gc.DrawLines(2, actualLine.data());
 
   if (MayUsePenGradients())
   {
      wxGraphicsPenInfo penInfo;
      wxGraphicsGradientStops stops { actualCompressionColor,
                                      actualCompressionColor };
      stops.Add(attackColor.GetRGB(), 1 / 4.);
      stops.Add(actualCompressionColor, 2 / 4.);
      stops.Add(releaseColor.GetRGB(), 3 / 4.);
      penInfo.LinearGradient(actualX, 0, actualX + lineWidth, 0, stops)
         .Width(targetCompressionLineWidth);
      gc.SetPen(gc.CreatePen(penInfo));
   }
   else
      gc.SetPen(actualCompressionColor);
 
   gc.DrawLines(2, actualLine.data());
   const auto actualText = XO("Actual Compression");
   const auto actualTextX = actualX + lineWidth + legendSpacing;
   dc.DrawText(actualText.Translation(), actualTextX, legendTextY);
 
   // Target compression
   gc.SetPen({ targetCompressionColor, targetCompressionLineWidth });
   const auto targetX =
      actualTextX + dc.GetTextExtent(actualText.Translation()).GetWidth() + 10;
   gc.StrokeLine(targetX, lineY, targetX + lineWidth, lineY);
   const auto compressionText = XO("Target Compression");
   dc.DrawText(
      compressionText.Translation(), targetX + lineWidth + 5, legendTextY);
}

References DynamicRangeProcessorPanel::actualCompressionColor, DynamicRangeProcessorPanel::attackColor, DynamicRangeProcessorPanel::backgroundColor, GetActualCompressionLineWidth(), DynamicRangeProcessorPanel::inputColor, DynamicRangeProcessorPanel::lineColor, MayUsePenGradients(), DynamicRangeProcessorPanel::outputColor, DynamicRangeProcessorPanel::releaseColor, DynamicRangeProcessorPanel::targetCompressionColor, DynamicRangeProcessorPanel::targetCompressionLineWidth, and XO().

Referenced by DynamicRangeProcessorHistoryPanel::OnPaint().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FillUpTo()

void anonymous_namespace{DynamicRangeProcessorHistoryPanel.cpp}::FillUpTo	(	std::vector< wxPoint2DDouble >	lines,
		const wxColor &	color,
		wxGraphicsContext &	gc,
		const wxRect &	rect
	)

Fills the area between the lines and the bottom of the panel with the given color.

Definition at line 188 of file DynamicRangeProcessorHistoryPanel.cpp.

{
   const auto height = rect.GetHeight();
   const auto left = std::max<double>(rect.GetX(), lines.front().m_x);
   const auto right = std::min<double>(rect.GetWidth(), lines.back().m_x);
   auto area = gc.CreatePath();
   area.MoveToPoint(right, height);
   area.AddLineToPoint(left, height);
   std::for_each(lines.begin(), lines.end(), [&area](const auto& p) {
      area.AddLineToPoint(p);
   });
   area.CloseSubpath();
   gc.SetBrush(color);
   gc.FillPath(area);
}

Referenced by DynamicRangeProcessorHistoryPanel::OnPaint().

Here is the caller graph for this function:

◆ GetActualCompressionLineWidth()

int anonymous_namespace{DynamicRangeProcessorHistoryPanel.cpp}::GetActualCompressionLineWidth ( )

Definition at line 44 of file DynamicRangeProcessorHistoryPanel.cpp.

{
   using namespace DynamicRangeProcessorPanel;
   return targetCompressionLineWidth + (MayUsePenGradients() ? 4 : 2);
}

References MayUsePenGradients(), and DynamicRangeProcessorPanel::targetCompressionLineWidth.

Referenced by DrawLegend(), and DynamicRangeProcessorHistoryPanel::OnPaint().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetDisplayPixel()

double anonymous_namespace{DynamicRangeProcessorHistoryPanel.cpp}::GetDisplayPixel	(	float	elapsedSincePacket,
		int	panelWidth
	)

Definition at line 118 of file DynamicRangeProcessorHistoryPanel.cpp.

{
   const auto secondsPerPixel =
      1. * DynamicRangeProcessorHistory::maxTimeSeconds / panelWidth;
   // A display delay to avoid the display to tremble near time zero because the
   // data hasn't arrived yet.
   // This is a trade-off between visual comfort and timely update. It was set
   // empirically, but with a relatively large audio playback delay. Maybe it
   // will be found to lag on lower-latency playbacks. Best would probably be to
   // make it playback-delay dependent.
   constexpr auto displayDelay = 0.2f;
   return panelWidth - 1 -
          (elapsedSincePacket - displayDelay) / secondsPerPixel;
}

References DynamicRangeProcessorHistory::maxTimeSeconds.

◆ InsertCrossings()

void anonymous_namespace{DynamicRangeProcessorHistoryPanel.cpp}::InsertCrossings	(	std::vector< wxPoint2DDouble > &	A,
		std::vector< wxPoint2DDouble > &	B
	)

Wherever A and B cross, evaluates the exact x and y crossing position and adds a point to A and B.

Precondition: A.size() == B.size()

Postcondition: A.size() == B.size()

Definition at line 139 of file DynamicRangeProcessorHistoryPanel.cpp.

{
   assert(A.size() == B.size());
   if (A.size() != B.size())
      return;
   std::optional<bool> aWasBelow;
   auto x0 = 0.;
   auto y0_a = 0.;
   auto y0_b = 0.;
   auto it = A.begin();
   auto jt = B.begin();
   while (it != A.end())
   {
      const auto x2 = it->m_x;
      const auto y2_a = it->m_y;
      const auto y2_b = jt->m_y;
      const auto aIsBelow = y2_a < y2_b;
      if (aWasBelow.has_value() && *aWasBelow != aIsBelow)
      {
         // clang-format off
         // We have a crossing of y2_a and y2_b between x0 and x2.
         //    y_a(x) = y0_a + (x - x0) / (x2 - x0) * (y2_a - y0_a)
         // and likewise for y_b.
         // Let y_a(x1) = y_b(x1) and solve for x1:
         // x1 = x0 + (x2 - x0) * (y0_b - y0_a) / ((a_n - y0_a) - (b_n - y0_b))
         // clang-format on
         const auto x1 =
            x0 + (x2 - x0) * (y0_a - y0_b) / (y2_b - y2_a + y0_a - y0_b);
         const auto y = y0_a + (x1 - x0) / (x2 - x0) * (y2_a - y0_a);
         if (std::isfinite(x1) && std::isfinite(y))
         {
            it = A.emplace(it, x1, y)++;
            jt = B.emplace(jt, x1, y)++;
         };
      }
      x0 = x2;
      y0_a = y2_a;
      y0_b = y2_b;
      aWasBelow = aIsBelow;
      ++it;
      ++jt;
   }
}

References A.

Referenced by DynamicRangeProcessorHistoryPanel::OnPaint().

Here is the caller graph for this function:

◆ MayUsePenGradients()

bool anonymous_namespace{DynamicRangeProcessorHistoryPanel.cpp}::MayUsePenGradients ( )

Definition at line 37 of file DynamicRangeProcessorHistoryPanel.cpp.

{
   // MacOS doesn't cope well with pen gradients. (Freezes in debug and is
   // transperent in release.)
   return wxPlatformInfo::Get().GetOperatingSystemId() & wxOS_WINDOWS;
}