meter_processor.h

// SPDX-FileCopyrightText: © 2020, 2024-2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include "dsp/engine.h"
#include "dsp/kmeter_dsp.h"
#include "dsp/peak_dsp.h"
#include "dsp/port.h"
#include "dsp/true_peak_dsp.h"
#include "utils/types.h"
#include "utils/variant_helpers.h"
 
#include <QtQmlIntegration/qqmlintegration.h>
 
#include <boost/container/static_vector.hpp>
 
namespace zrythm::gui::qquick
{

class MeterProcessor : public QObject
{
  Q_OBJECT
  QML_ELEMENT
  Q_PROPERTY (QVariant port READ port WRITE setPort REQUIRED)
  Q_PROPERTY (int channel READ channel WRITE setChannel)
  Q_PROPERTY (
    zrythm::dsp::AudioEngine * audioEngine READ audioEngine WRITE setAudioEngine
      REQUIRED)
  Q_PROPERTY (
    float currentAmplitude READ currentAmplitude NOTIFY currentAmplitudeChanged)
  Q_PROPERTY (float peakAmplitude READ peakAmplitude NOTIFY peakAmplitudeChanged)
 
public:
  enum class MeterAlgorithm : std::uint8_t
  {
    METER_ALGORITHM_AUTO,
 
    METER_ALGORITHM_DIGITAL_PEAK,

    METER_ALGORITHM_TRUE_PEAK,
    METER_ALGORITHM_RMS,
    METER_ALGORITHM_K,
  };
 
  using MeterPortVariant = std::variant<dsp::MidiPort, dsp::AudioPort>;
  using MeterPortPtrVariant = to_pointer_variant<MeterPortVariant>;
 
  MeterProcessor (QObject * parent = nullptr);
 
  // ================================================================
  // QML Interface
  // ================================================================
 
  QVariant port () const { return QVariant::fromValue (port_obj_); }
  void     setPort (QVariant port_var);
 
  int  channel () const { return channel_; }
  void setChannel (int channel);
 
  dsp::AudioEngine * audioEngine () const { return audio_engine_; }
  void setAudioEngine (dsp::AudioEngine * engine) { audio_engine_ = engine; }
 
  float currentAmplitude () const
  {
    return current_amp_.load (std::memory_order_relaxed);
  }
  Q_SIGNAL void currentAmplitudeChanged (float value);
 
  float peakAmplitude () const
  {
    return peak_amp_.load (std::memory_order_relaxed);
  }
  Q_SIGNAL void peakAmplitudeChanged (float value);
 
  Q_INVOKABLE float toDBFS (float amp) const;
  Q_INVOKABLE float toFader (float amp) const;
 
  // ================================================================
 
private:
  void get_value (AudioValueFormat format, float * val, float * max);
 
public:
  QPointer<QObject> port_obj_;
 
  // RAII request for port ring buffers to be filled
  std::optional<dsp::RingBufferOwningPortMixin::RingBufferReader>
    ring_buffer_reader_;

  std::unique_ptr<zrythm::dsp::TruePeakDsp> true_peak_processor_;
  std::unique_ptr<zrythm::dsp::TruePeakDsp> true_peak_max_processor_;

  float true_peak_ = 0.f;
  float true_peak_max_ = 0.f;

  std::unique_ptr<zrythm::dsp::KMeterDsp> kmeter_processor_;
 
  std::unique_ptr<zrythm::dsp::PeakDsp> peak_processor_;

  MeterAlgorithm algorithm_ = MeterAlgorithm::METER_ALGORITHM_AUTO;

  float prev_max_ = 0.f;

  float last_amp_ = 0.f;

  SteadyTimePoint last_draw_time_;
 
  qint64 last_midi_trigger_time_ = 0;
 
private:
  std::vector<float> tmp_buf_;
 
  std::atomic<float> current_amp_ = 0.f;
  std::atomic<float> peak_amp_ = 0.f;
 
  // Audio port channel, if audio meter.
  int channel_{};
 
  QPointer<dsp::AudioEngine> audio_engine_;
 
  boost::container::static_vector<dsp::MidiEvent, 256> tmp_events_;
};
}