processor.hh

Go to the documentation of this file.

 // This Source Code Form is licensed MPL-2.0: http://mozilla.org/MPL/2.0
#ifndef __ASE_PROCESSOR_HH__
#define __ASE_PROCESSOR_HH__
 
#include <ase/gadget.hh>
#include <ase/parameter.hh>
#include <ase/midievent.hh>
#include <ase/datautils.hh>
#include <ase/properties.hh>
#include <ase/engine.hh>
#include <ase/atomics.hh>
#include <any>
 
namespace Ase {
 
enum class ParamId : uint32 {};
ASE_DEFINE_ENUM_EQUALITY (ParamId);
 
enum class IBusId : uint16 {};
ASE_DEFINE_ENUM_EQUALITY (IBusId);
 
enum class OBusId : uint16 {};
ASE_DEFINE_ENUM_EQUALITY (OBusId);
 
struct AudioProcessorInfo {
  CString label;        
  CString version;      
  CString category;     
  CString blurb;        
  CString description;  
  CString website_url;  
  CString creator_name; 
  CString creator_url;  
};
 
template<typename T> CString register_audio_processor (const char *aseid = nullptr);
 
struct BusInfo {
  CString            ident;     
  CString            label;     
  CString            hints;     
  CString            blurb;     
  SpeakerArrangement speakers = SpeakerArrangement::NONE; 
  uint               n_channels () const;
};
 
struct AudioParams final {
  using Map = std::map<uint32_t,ParameterC>;
  const uint32_t          *ids = nullptr;
  double                  *values = nullptr;
  std::atomic<uint64_t>   *bits = nullptr;
  const ParameterC        *parameters = nullptr;
  std::weak_ptr<Property> *wprops = nullptr;
  uint32                   count = 0;
  bool                     changed = false;
  void          clear   ();
  void          install (const Map &params);
  ssize_t       index   (uint32_t id) const;
  double        value   (uint32_t id) const;
  double        value   (uint32_t id, double newval);
  bool          dirty   (uint32_t id) const     { return dirty_index (index (id)); }
  void          dirty   (uint32_t id, bool d)   { return dirty_index (index (id), d); }
  /*dtor*/     ~AudioParams();
  bool      dirty_index (uint32_t idx) const;
  void      dirty_index (uint32_t idx, bool d);
};
 
class AudioProcessor : public std::enable_shared_from_this<AudioProcessor>, public FastMemory::NewDeleteBase {
  struct IOBus;
  struct EventStreams;
  struct RenderContext;
  class FloatBuffer;
  friend class ProcessorManager;
  friend class DeviceImpl;
  friend class NativeDeviceImpl;
  friend class AudioEngineThread;
  struct OConnection {
    AudioProcessor *proc = nullptr; IBusId ibusid = {};
    bool operator== (const OConnection &o) const { return proc == o.proc && ibusid == o.ibusid; }
  };
  using OBRange = std::pair<FloatBuffer*,FloatBuffer*>;
  AudioProcessor          *sched_next_ = nullptr;
protected:
#ifndef DOXYGEN
  // Inherit `AudioSignal` concepts in derived classes from other namespaces
  using MinMax = std::pair<double,double>;
#endif
  using MidiEventInput = MidiEventReader<2>;
  enum { INITIALIZED   = 1 << 0,
         //            = 1 << 1,
         SCHEDULED     = 1 << 2,
         PARAMCHANGE   = 1 << 3,
         BUSCONNECT    = 1 << 4,
         BUSDISCONNECT = 1 << 5,
         INSERTION     = 1 << 6,
         REMOVAL       = 1 << 7,
         ENGINE_OUTPUT = 1 << 8,
  };
  std::atomic<uint32>      flags_ = 0;
private:
  uint32                   output_offset_ = 0;
  FloatBuffer             *fbuffers_ = nullptr;
  std::vector<IOBus>       iobuses_;
  AudioParams              params_;
  std::vector<OConnection> outputs_;
  EventStreams            *estreams_ = nullptr;
  AtomicBits              *atomic_bits_ = nullptr;
  uint64_t                 render_stamp_ = 0;
  using MidiEventVector = std::vector<MidiEvent>;
  using MidiEventVectorAP = std::atomic<MidiEventVector*>;
  MidiEventVectorAP        t0events_ = nullptr;
  RenderContext           *render_context_ = nullptr;
  std::vector<CString>     cstrings0_, cstrings1_;
  template<class F> void modify_t0events (const F&);
  void               assign_iobufs      ();
  void               release_iobufs     ();
  void               ensure_initialized (DeviceP devicep);
  const FloatBuffer& float_buffer       (IBusId busid, uint channelindex) const;
  FloatBuffer&       float_buffer       (OBusId busid, uint channelindex, bool resetptr = false);
  static
  const FloatBuffer& zero_buffer        ();
  void               render_block       (uint64 target_stamp);
  void               reset_state        (uint64 target_stamp);
  /*copy*/           AudioProcessor     (const AudioProcessor&) = delete;
  virtual void       render             (uint n_frames) = 0;
  virtual void       reset              (uint64 target_stamp) = 0;
  PropertyS          access_properties  () const;
public:
  struct ProcessorSetup {
    CString      aseid;
    AudioEngine &engine;
  };
protected:
  AudioEngine  &engine_;
  CString       aseid_;
  explicit      AudioProcessor    (const ProcessorSetup&);
  virtual      ~AudioProcessor    ();
  virtual void  initialize        (SpeakerArrangement busses) = 0;
  void          enotify_enqueue_mt (uint32 pushmask);
  uint          schedule_processor ();
  void          reschedule        ();
  virtual uint  schedule_children () { return 0; }
  static uint   schedule_processor (AudioProcessor &p)  { return p.schedule_processor(); }
  // Parameters
  void          install_params    (const AudioParams::Map &params);
  void          apply_event       (const MidiEvent &event);
  void          apply_input_events ();
  virtual void  adjust_param      (uint32_t paramid) {}
  double        peek_param_mt     (Id32 paramid) const;
  // Buses
  IBusId        add_input_bus     (CString uilabel, SpeakerArrangement speakerarrangement,
                                   const String &hints = "", const String &blurb = "");
  OBusId        add_output_bus    (CString uilabel, SpeakerArrangement speakerarrangement,
                                   const String &hints = "", const String &blurb = "");
  void          remove_all_buses  ();
  IOBus&        iobus             (OBusId busid);
  IOBus&        iobus             (IBusId busid);
  const IOBus&  iobus             (OBusId busid) const { return const_cast<AudioProcessor*> (this)->iobus (busid); }
  const IOBus&  iobus             (IBusId busid) const { return const_cast<AudioProcessor*> (this)->iobus (busid); }
  void          disconnect_ibuses ();
  void          disconnect_obuses ();
  void          disconnect        (IBusId ibus);
  void          connect           (IBusId ibus, AudioProcessor &oproc, OBusId obus);
  float*        oblock            (OBusId b, uint c);
  void          assign_oblock     (OBusId b, uint c, float val);
  void          redirect_oblock   (OBusId b, uint c, const float *block);
  // event stream handling
  void             prepare_event_input  ();
  void             prepare_event_output ();
  MidiEventInput   midi_event_input     ();
  MidiEventOutput& midi_event_output    ();
  // Atomic notification bits
  void             atomic_bits_resize (size_t count);
  bool             atomic_bit_notify  (size_t nth);
public:
  AtomicBits::Iter atomic_bits_iter   (size_t pos = 0) const;
  using MakeProcessor = AudioProcessorP (*) (AudioEngine&);
  using MaybeParamId = std::pair<ParamId,bool>;
  static const String GUIONLY;     
  static const String STANDARD;    
  static const String STORAGEONLY; 
  float         note_to_freq      (int note) const;
  String        debug_name        () const;
  AudioEngine&          engine      () const ASE_CONST;
  const AudioTransport& transport   () const ASE_CONST;
  uint                  sample_rate () const ASE_CONST;
  double                nyquist     () const ASE_CONST;
  double                inyquist    () const ASE_CONST;
  // Parameters
  double              get_param             (Id32 paramid);
  bool                send_param            (Id32 paramid, double value);
  ParameterC          parameter             (Id32 paramid) const;
  MaybeParamId        find_param            (const String &identifier) const;
  MinMax              param_range           (Id32 paramid) const;
  bool                check_dirty           (Id32 paramid) const;
  void                adjust_all_params     ();
  virtual String      param_value_to_text   (uint32_t paramid, double value) const;
  virtual double      param_value_from_text (uint32_t paramid, const String &text) const;
  virtual double      value_to_normalized   (Id32 paramid, double value) const;
  virtual double      value_from_normalized (Id32 paramid, double normalized) const;
  double              get_normalized        (Id32 paramid);
  bool                set_normalized        (Id32 paramid, double normalized);
  bool                is_initialized        () const;
  uint                text_param_to_quark   (uint32_t paramid, const String &text);
  String              text_param_from_quark (uint32_t paramid, uint vint);
  // Buses
  IBusId        find_ibus         (const String &name) const;
  OBusId        find_obus         (const String &name) const;
  uint          n_ibuses          () const;
  uint          n_obuses          () const;
  uint          n_ichannels       (IBusId busid) const;
  uint          n_ochannels       (OBusId busid) const;
  BusInfo       bus_info          (IBusId busid) const;
  BusInfo       bus_info          (OBusId busid) const;
  bool          connected         (OBusId obusid) const;
  const float*  ifloats           (IBusId b, uint c) const;
  const float*  ofloats           (OBusId b, uint c) const;
  static uint64 timestamp         ();
  DeviceP       get_device        () const;
  bool          has_event_input   () const;
  bool          has_event_output  () const;
  void          connect_event_input    (AudioProcessor &oproc);
  void          disconnect_event_input ();
  void          enable_engine_output   (bool onoff);
  // MT-Safe accessors
  static double          param_peek_mt   (const AudioProcessorP proc, Id32 paramid);
  // AudioProcessor Registry
  using StaticInfo = void (*) (AudioProcessorInfo&);
  using MakeDeviceP = std::function<DeviceP (const String&, StaticInfo, AudioProcessorP)>;
  using MakeProcessorP = AudioProcessorP (*) (CString,AudioEngine&);
  static void    registry_add     (CString aseid, StaticInfo, MakeProcessorP);
  static DeviceP registry_create  (CString aseid, AudioEngine &engine, const MakeDeviceP&);
  static void    registry_foreach (const std::function<void (const String &aseid, StaticInfo)> &fun);
  template<class AudioProc, class ...Args> std::shared_ptr<AudioProc>
  static         create_processor (AudioEngine &engine, const Args &...args);
private:
  static bool   enotify_pending   ();
  static void   enotify_dispatch  ();
  std::atomic<AudioProcessor*> nqueue_next_ { nullptr }; 
  AudioProcessorP              nqueue_guard_;            
  std::weak_ptr<Device>        device_;
  static constexpr uint32 NOTIFYMASK = PARAMCHANGE | BUSCONNECT | BUSDISCONNECT | INSERTION | REMOVAL;
  static __thread uint64  tls_timestamp;
};
 
class AudioProcessor::FloatBuffer {
  void          check      ();
  alignas (64) float fblock[AUDIO_BLOCK_MAX_RENDER_SIZE] = { 0, };
  const uint64       canary0_ = const_canary;
  const uint64       canary1_ = const_canary;
  struct { uint64 d1, d2, d3, d4; }; // dummy mem
  SpeakerArrangement speaker_arrangement_ = SpeakerArrangement::NONE;
  SpeakerArrangement speaker_arrangement () const;
  static constexpr uint64 const_canary = 0xE14D8A302B97C56F;
  friend class AudioProcessor;
  float             *buffer = &fblock[0];
};
 
// == ProcessorManager ==
class ProcessorManager {
protected:
  static auto pm_remove_all_buses    (AudioProcessor &p)       { return p.remove_all_buses(); }
  static auto pm_disconnect_ibuses   (AudioProcessor &p)       { return p.disconnect_ibuses(); }
  static auto pm_disconnect_obuses   (AudioProcessor &p)       { return p.disconnect_obuses(); }
  static auto pm_connect             (AudioProcessor &p, IBusId i, AudioProcessor &d, OBusId o)
                                     { return p.connect (i, d, o); }
  static auto pm_connect_event_input (AudioProcessor &oproc, AudioProcessor &iproc)
                                     { return iproc.connect_event_input (oproc); }
};
 
// == Inlined Internals ==
// AudioProcessor internal input/output bus book keeping
struct AudioProcessor::IOBus : BusInfo {
  enum IOTag : uint { IBUS = 1, OBUS = 2 };
  union {
    IOTag iotag;
    struct /*IBus*/ {
      IOTag           ibus;
      OBusId          obusid;
      AudioProcessor *oproc;
    };
    struct /*OBus*/ {
      IOTag obus;
      uint  fbuffer_concounter;
      uint  fbuffer_count;
      uint  fbuffer_index; /* = ~0 */
    };
    uint mem_[4] = { 0, 0, 0, 0 };
  };
  explicit IOBus (IOTag io_tag, const String &ident, const String &label, SpeakerArrangement sa);
};
 
// AudioProcessor internal input/output event stream book keeping
struct AudioProcessor::EventStreams {
  static constexpr auto EVENT_ISTREAM = IBusId (0xff01); // *not* an input bus, ID is used for OConnection
  AudioProcessor *oproc = nullptr;
  MidiEventOutput midi_event_output;
  bool            has_event_input = false;
  bool            has_event_output = false;
};
 
inline ssize_t
AudioParams::index (const uint32_t id) const
{
  if (id - 1 < count && ids[id - 1] == id) [[likely]]
    return id - 1;      // fast path for consecutive IDs
  if (id < count && ids[id] == id) [[likely]]
    return id - 1;      // fast handling of 0-based IDs
  auto [it,found] = Aux::binary_lookup_insertion_pos (ids, ids + count,
                                                      [] (auto a, auto b) { return a < b ? -1 : a > b; },
                                                      id);
  return found ? it - ids : -1;
}
 
inline double
AudioParams::value (uint32_t id) const
{
  const auto idx = index (id);
  return idx < 0 ? 0.0 : values[idx];
}
 
inline double
AudioParams::value (uint32_t id, double newval)
{
  const auto idx = index (id);
  if (idx < 0) return 0.0;
  const double old = values[idx];
  values[idx] = newval;
  if (!wprops[idx].expired()) {
    dirty_index (idx, true);
    changed = true;
  }
  return old;
}
 
inline bool
AudioParams::dirty_index (uint32_t idx) const
{
  return bits[idx >> 6] & uint64_t (1) << (idx & (64-1));
}
 
inline void
AudioParams::dirty_index (uint32_t idx, bool d)
{
  if (d)
    bits[idx >> 6] |= uint64_t (1) << (idx & (64-1));
  else
    bits[idx >> 6] &= ~(uint64_t (1) << (idx & (64-1)));
}
 
template<class F> void
AudioProcessor::modify_t0events (const F &mod)
{
  ASE_ASSERT_RETURN (this_thread_is_ase());
  MidiEventVector *t0events = nullptr;
  t0events = t0events_.exchange (t0events);
  if (!t0events)
    t0events = new std::vector<MidiEvent>;
  mod (*t0events);
  if (!t0events->empty())
    t0events = t0events_.exchange (t0events);
  delete t0events;
}
 
inline void
AudioProcessor::apply_event (const MidiEvent &event)
{
  switch (event.type)
    {
    case MidiEvent::PARAM_VALUE:
      params_.value (event.param, event.pvalue);
      break;
    default: ;
    }
}
 
inline void
AudioProcessor::apply_input_events()
{
  MidiEventInput evinput = midi_event_input();
  for (const auto &event : evinput)
    switch (event.type) // event.message()
      {
      case MidiEvent::PARAM_VALUE:
        apply_event (event);
        adjust_param (event.param);
        break;
      default: ;
      }
}
 
inline uint
BusInfo::n_channels () const
{
  return speaker_arrangement_count_channels (speakers);
}
 
inline AudioEngine&
AudioProcessor::engine () const
{
  return engine_;
}
 
inline const AudioTransport&
AudioProcessor::transport () const
{
  return engine_.transport();
}
 
inline uint
AudioProcessor::sample_rate () const
{
  return engine_.sample_rate();
}
 
inline double
AudioProcessor::nyquist () const
{
  return engine_.nyquist();
}
 
inline double
AudioProcessor::inyquist () const
{
  return engine_.inyquist();
}
 
inline bool
AudioProcessor::has_event_input () const
{
  return estreams_ && estreams_->has_event_input;
}
 
inline bool
AudioProcessor::has_event_output () const
{
  return estreams_ && estreams_->has_event_output;
}
 
inline uint
AudioProcessor::n_ibuses () const
{
  return output_offset_;
}
 
inline uint
AudioProcessor::n_obuses () const
{
  return iobuses_.size() - output_offset_;
}
 
inline BusInfo
AudioProcessor::bus_info (IBusId busid) const
{
  return iobus (busid);
}
 
inline BusInfo
AudioProcessor::bus_info (OBusId busid) const
{
  return iobus (busid);
}
 
inline uint
AudioProcessor::n_ichannels (IBusId busid) const
{
  const IOBus &ibus = iobus (busid);
  return ibus.n_channels();
}
 
inline uint
AudioProcessor::n_ochannels (OBusId busid) const
{
  const IOBus &obus = iobus (busid);
  return obus.n_channels();
}
 
// Call adjust_param() for all parameters.
inline void
AudioProcessor::adjust_all_params()
{
  for (size_t idx = 0; idx < params_.count; idx++)
    adjust_param (params_.ids[idx]);
}
 
inline double
AudioProcessor::get_param (Id32 paramid)
{
  const ssize_t idx = params_.index (paramid.id);
  if (idx < 0) [[unlikely]]
    return 0;
  return params_.values[idx];
}
 
inline bool
AudioProcessor::check_dirty (Id32 paramid) const
{
  const ssize_t idx = params_.index (paramid.id);
  if (idx < 0) [[unlikely]]
    return false;
  return params_.dirty_index (idx);
}
 
inline const float*
AudioProcessor::ifloats (IBusId b, uint c) const
{
  return float_buffer (b, c).buffer;
}
 
inline const float*
AudioProcessor::ofloats (OBusId b, uint c) const
{
  return const_cast<AudioProcessor*> (this)->float_buffer (b, c).buffer;
}
 
inline float*
AudioProcessor::oblock (OBusId b, uint c)
{
  return float_buffer (b, c, true).buffer;
}
 
inline uint64
AudioProcessor::timestamp ()
{
  return tls_timestamp;
}
 
inline SpeakerArrangement
AudioProcessor::FloatBuffer::speaker_arrangement () const
{
  return speaker_arrangement_;
}
 
template<typename T> extern inline CString
register_audio_processor (const char *caseid)
{
  CString aseid = caseid ? caseid : typeid_name<T>();
  if constexpr (std::is_constructible<T, const AudioProcessor::ProcessorSetup&>::value)
    {
      auto make_shared = [] (CString aseid, AudioEngine &engine) -> AudioProcessorP {
        const AudioProcessor::ProcessorSetup psetup { aseid, engine };
        return std::make_shared<T> (psetup);
      };
      AudioProcessor::registry_add (aseid, &T::static_info, make_shared);
    }
  else
    static_assert (sizeof (T) < 0, "type `T` must be constructible from `T(AudioEngine&)`");
  return aseid;
}
 
template<class AudioProc, class ...Args> std::shared_ptr<AudioProc>
AudioProcessor::create_processor (AudioEngine &engine, const Args &...args)
{
  String aseid = typeid_name<AudioProc>();
  const ProcessorSetup psetup { aseid, engine };
  std::shared_ptr<AudioProc> proc = std::make_shared<AudioProc> (psetup, args...);
  if (proc) {
    AudioProcessorP aproc = proc;
    aproc->ensure_initialized (nullptr);
  }
  return proc;
}
 
} // Ase
 
#endif // __ASE_PROCESSOR_HH__