al_PolySynth.hpp

#ifndef AL_POLYSYNTH_HPP
#define AL_POLYSYNTH_HPP
 
/*  Allolib --
    Multimedia / virtual environment application class library
 
    Copyright (C) 2009. AlloSphere Research Group, Media Arts & Technology,
   UCSB. Copyright (C) 2012-2018. The Regents of the University of California.
    All rights reserved.
 
    Redistribution and use in source and binary forms, with or without
    modification, are permitted provided that the following conditions are met:
 
        Redistributions of source code must retain the above copyright notice,
        this list of conditions and the following disclaimer.
 
        Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
 
        Neither the name of the University of California nor the names of its
        contributors may be used to endorse or promote products derived from
        this software without specific prior written permission.
 
    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
    SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
    INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
    CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
    POSSIBILITY OF SUCH DAMAGE.
 
    File description:
    Polyphonic Synthesizer
 
    File author(s):
    Andrés Cabrera mantaraya36@gmail.com
*/
 
#include <chrono>
#include <cstring>
#include <string>
#include <thread>
#include <typeindex>
#include <vector>
 
#include "al/graphics/al_Graphics.hpp"
#include "al/io/al_AudioIOData.hpp"
#include "al/io/al_File.hpp"
#include "al/types/al_SingleRWRingBuffer.hpp"
#include "al/ui/al_Parameter.hpp"
 
namespace al {
 
int asciiToIndex(int asciiKey, int offset = 0);
 
int asciiToMIDI(int asciiKey, int offset = 0);
 
class SynthVoice {
  friend class PolySynth; // PolySynth needs to access private members like
                          // "next".
public:
  SynthVoice() {}
 
  virtual ~SynthVoice() {}
 
  bool active() { return mActive; }
 
  virtual bool setTriggerParams(float *pFields, int numFields = -1) {
    if (numFields < (int)mTriggerParams.size()) {
      // std::cout << "Pfield size mismatch. Ignoring all." << std::endl;
      return false;
    }
    for (auto &param : mTriggerParams) {
      param->fromFloat(*pFields++);
    }
    return true;
  }
 
  virtual bool setTriggerParams(std::vector<float> &pFields,
                                bool noCalls = false) {
    if (pFields.size() < mTriggerParams.size()) {
      // std::cout << "pField count mismatch. Ignoring." << std::endl;
      return false;
    }
    auto it = pFields.begin();
    if (noCalls) {
      for (auto &param : mTriggerParams) {
        static_cast<Parameter *>(param)->setNoCalls(*it++);
      }
    } else {
      for (auto &param : mTriggerParams) {
        static_cast<Parameter *>(param)->set(*it++);
      }
    }
    return true;
  }
 
  virtual bool setTriggerParams(std::vector<ParameterField> pFields,
                                bool noCalls = false);
 
  virtual int getTriggerParams(float *pFields, int maxParams = -1);
 
  virtual std::vector<ParameterField> getTriggerParams();
 
  virtual void onProcess(AudioIOData & /*io*/) {}
 
  virtual void onProcess(Graphics & /*g*/) {}
 
  virtual void update(double dt = 0) { (void)dt; }
 
  virtual void init() {}
 
  virtual void onTriggerOn() {}
 
  virtual void onTriggerOff() {}
 
  virtual void onFree() {}
 
  void triggerOn(int offsetFrames = 0);
 
  void triggerOff(int offsetFrames = 0);
 
  void id(int idValue) { mId = idValue; }
 
  int id() { return mId; }
 
  int getStartOffsetFrames(unsigned int framesPerBuffer);
 
  int getEndOffsetFrames(unsigned int framesPerBuffer);
 
  void userData(void *ud) { mUserData = ud; }
 
  void *userData() { return mUserData; }
 
  unsigned int numOutChannels() { return mNumOutChannels; }
 
  std::shared_ptr<Parameter>
  createInternalTriggerParameter(std::string name, float defaultValue = 0.0,
                                 float minValue = -9999.0,
                                 float maxValue = 9999.0);
 
  Parameter &getInternalParameter(std::string name);
 
  float getInternalParameterValue(std::string name);
 
  void setInternalParameterValue(std::string name, float value);
 
  virtual SynthVoice &registerTriggerParameter(ParameterMeta &param) {
    mTriggerParams.push_back(&param);
    return *this;
  }
 
  template <class... Args>
  SynthVoice &registerTriggerParameters(Args &... paramsArgs) {
    std::vector<ParameterMeta *> params{&paramsArgs...};
    for (auto *param : params) {
      registerTriggerParameter(*param);
    }
    return *this;
  }
 
  SynthVoice &operator<<(ParameterMeta &param) {
    return registerTriggerParameter(param);
  }
 
  std::vector<ParameterMeta *> triggerParameters() { return mTriggerParams; }
 
  virtual SynthVoice &registerParameter(ParameterMeta &param) {
    mContinuousParameters.push_back(&param);
    return *this;
  }
 
  template <class... Args>
  SynthVoice &registerParameters(Args &... paramsArgs) {
    std::vector<ParameterMeta *> params{&paramsArgs...};
    for (auto *param : params) {
      registerParameter(*param);
    }
    return *this;
  }
 
  std::vector<ParameterMeta *> parameters() { return mContinuousParameters; }
 
  void free() { mActive = false; } // Mark this voice as done.
 
  SynthVoice *next{nullptr}; // To support SynthVoices as linked lists
 
protected:
  void setNumOutChannels(unsigned int numOutputs) {
    mNumOutChannels = numOutputs;
  }
 
  std::vector<ParameterMeta *> mTriggerParams;
 
  std::vector<ParameterMeta *> mContinuousParameters;
 
  std::vector<std::shared_ptr<Parameter>> mInternalParameters;
 
private:
  int mId{-1};
  bool mActive{false};
  int mOnOffsetFrames{0};
  int mOffOffsetFrames{0};
  void *mUserData;
  unsigned int mNumOutChannels{1};
};
 
class PolySynth {
public:
  friend class SynthSequencer;
 
  PolySynth(TimeMasterMode masterMode = TimeMasterMode::TIME_MASTER_AUDIO);
 
  virtual ~PolySynth();
 
  int triggerOn(SynthVoice *voice, int offsetFrames = 0, int id = -1,
                void *userData = nullptr);
 
  void triggerOff(int id);
 
  virtual void allNotesOff();
 
  template <class TSynthVoice> TSynthVoice *getVoice(bool forceAlloc = false);
 
  SynthVoice *getVoice(std::string name, bool forceAlloc = false);
 
  SynthVoice *getFreeVoice();
 
  virtual void render(AudioIOData &io);
 
  virtual void render(Graphics &g);
 
  virtual void update(double dt = 0);
 
  template <class TSynthVoice> void allocatePolyphony(int number);
 
  template <class TSynthVoice> void disableAllocation();
 
  void disableAllocation(std::string name);
 
  void allocatePolyphony(std::string name, int number);
 
  void insertFreeVoice(SynthVoice *voice);
 
  bool popFreeVoice(SynthVoice *voice);
 
  void setDefaultUserData(void *userData) { mDefaultUserData = userData; }
 
  void setTimeMaster(TimeMasterMode masterMode);
 
  PolySynth &append(AudioCallback &v);
 
  PolySynth &prepend(AudioCallback &v);
 
  PolySynth &insertBefore(AudioCallback &v, AudioCallback &beforeThis);
 
  PolySynth &insertAfter(AudioCallback &v, AudioCallback &afterThis);
 
  PolySynth &remove(AudioCallback &v);
 
  void print(std::ostream &stream = std::cout);
 
  void gain(float gainValue) { mAudioGain = gainValue; }
 
  float gain() { return mAudioGain; }
 
  void registerTriggerOnCallback(
      std::function<bool(SynthVoice *voice, int offsetFrames, int id,
                         void *userData)>
          cb,
      void *userData = nullptr);
 
  void
  registerTriggerOffCallback(std::function<bool(int id, void *userData)> cb,
                             void *userData = nullptr);
  void registerFreeCallback(std::function<bool(int id, void *userData)> cb,
                            void *userData = nullptr);
 
  void
  registerAllocateCallback(std::function<void(SynthVoice *voice, void *)> cb,
                           void *userData = nullptr);
 
  template <class TSynthVoice>
  void registerSynthClass(std::string name = "",
                          bool allowAutoAllocation = true) {
    if (name.size() == 0) {
      name = demangle(typeid(TSynthVoice).name());
    }
    if (mCreators.find(name) != mCreators.end()) {
      if (mVerbose) {
        std::cout << "Warning: Overriding registration of SynthVoice: " << name
                  << std::endl;
      }
    }
    if (!allowAutoAllocation) {
      if (std::find(mNoAllocationList.begin(), mNoAllocationList.end(), name) ==
          mNoAllocationList.end()) {
        mNoAllocationList.push_back(name);
      }
    }
    mCreators[name] = [&]() {
      TSynthVoice *voice = allocateVoice<TSynthVoice>();
      return voice;
    };
  }
 
  SynthVoice *allocateVoice(std::string name);
 
  template <class TSynthVoice> TSynthVoice *allocateVoice() {
    TSynthVoice *voice = new TSynthVoice;
    voice->next = nullptr;
    if (mDefaultUserData) {
      voice->userData(mDefaultUserData);
    }
    voice->init();
    for (auto allocCb : mAllocationCallbacks) {
      allocCb.first(voice, allocCb.second);
    }
    return voice;
  }
 
  bool verbose() { return mVerbose; }
  void verbose(bool verbose) { mVerbose = verbose; }
 
  // Use this function with care as there are no memory protections
  SynthVoice *getActiveVoices() { return mActiveVoices; }
 
  SynthVoice *getFreeVoices() { return mFreeVoices; }
 
  void setVoiceMaxOutputChannels(uint16_t channels);
 
  void setVoiceBusChannels(uint16_t channels) { mVoiceBusChannels = channels; }
 
  typedef const std::function<void(AudioIOData &internalVoiceIO,
                                   Pose &channelPose)>
      BusRoutingCallback;
 
  void setBusRoutingCallback(BusRoutingCallback cb);
 
  void setChannelMap(std::vector<size_t> channelMap);
 
  void setCpuClockGranularity(double timeSecs) {
    mCpuGranularitySec = timeSecs;
  }
 
  inline void processVoices() {
    if (mVoiceToInsertLock.try_lock()) {
      if (mVoicesToInsert) {
        // If lock acquired insert queued voices
        if (mActiveVoices) {
          auto voice = mVoicesToInsert;
          while (voice->next) { // Find last voice to insert
            voice = voice->next;
          }
          voice->next =
              mActiveVoices; // Connect last inserted to previously active
          mActiveVoices = mVoicesToInsert; // Put new voices in head
        } else {
          mActiveVoices = mVoicesToInsert;
        }
        if (verbose()) {
          std::cout << "Voice on " << mVoicesToInsert->id() << std::endl;
        }
 
        mVoicesToInsert = nullptr;
      }
      mVoiceToInsertLock.unlock();
    }
    if (mAllNotesOff) {
      if (mFreeVoiceLock.try_lock()) {
        mAllNotesOff = false;
        if (mActiveVoices) {
          auto voice = mActiveVoices->next;
          SynthVoice *previousVoice = mActiveVoices;
          previousVoice->id(-1);
          while (voice) {
            voice->id(-1);
            previousVoice = voice;
            voice = voice->next;
          }
          previousVoice->next =
              mFreeVoices; // Connect last active voice to first free voice
          mFreeVoices = mActiveVoices; // Move all voices to free voices
          mActiveVoices = nullptr;     // No active voices left
        }
        mFreeVoiceLock.unlock();
      }
    }
  }
 
  inline void processVoiceTurnOff() {
    int voicesToTurnOff[16];
    size_t numVoicesToTurnOff;
    while ((numVoicesToTurnOff = mVoiceIdsToTurnOff.read(
                (char *)voicesToTurnOff, 16 * sizeof(int)))) {
      for (size_t i = 0; i < numVoicesToTurnOff / int(sizeof(int)); i++) {
        auto *voice = mActiveVoices;
        while (voice) {
          if (voice->id() == voicesToTurnOff[i]) {
            if (mVerbose) {
              std::cout << "Voice trigger off " << voice->id() << std::endl;
            }
            voice->triggerOff(); // TODO use offset for turn off
          }
          voice = voice->next;
        }
      }
    }
    size_t numVoicesToFree;
    int voicesToFree[16];
    while ((numVoicesToFree =
                mVoiceIdsToFree.read((char *)voicesToFree, 16 * sizeof(int)))) {
      for (size_t i = 0; i < numVoicesToFree / int(sizeof(int)); i++) {
        if (mVerbose) {
          std::cout << "Voice free " << voicesToFree[i] << std::endl;
        }
        auto *voice = mActiveVoices;
        while (voice) {
          if (voice->id() == voicesToFree[i]) {
            voice->mActive = false;
          }
          voice = voice->next;
        }
      }
    }
  }
 
  inline void processInactiveVoices() {
    // Move inactive voices to free queue
    if (mFreeVoiceLock.try_lock()) { // Attempt to remove inactive voices
      // without waiting.
      auto *voice = mActiveVoices;
      SynthVoice *previousVoice = nullptr;
      while (voice) {
        if (!voice->active()) {
          int id = voice->id();
          //          std::cout << " ****((((())))) **** Remove inactive voice:
          //          " << voice << std::endl;
          if (previousVoice) {
            previousVoice->next = voice->next; // Remove from active list
            voice->next = mFreeVoices;
            mFreeVoices = voice; // Insert as head in free voices
            voice->id(-1);       // Reset voice id
            voice->onFree();
            voice = previousVoice; // prepare next iteration
          } else {                 // Inactive is head of the list
            auto *nextVoice = voice->next;
            mActiveVoices = nextVoice; // Remove voice from list
            voice->next = mFreeVoices;
            mFreeVoices = voice; // Insert as head in free voices
            voice->id(-1);       // Reset voice id
            voice->onFree();
            voice = voice->next; // prepare next iteration
          }
          for (auto cbNode : mFreeCallbacks) {
            cbNode.first(id, cbNode.second);
          }
        }
        previousVoice = voice;
        if (voice) {
          voice = voice->next;
        }
      }
      mFreeVoiceLock.unlock();
    }
  }
 
protected:
  void startCpuClockThread();
 
  inline void processGain(AudioIOData &io) {
    io.frame(0);
    if (mAudioGain != 1.0f) {
      for (unsigned int i = 0; i < io.channelsOut(); i++) {
        float *buffer = io.outBuffer(i);
        uint64_t samps = io.framesPerBuffer();
        while (samps--) {
          *buffer++ *= mAudioGain;
        }
      }
    }
  }
 
  virtual void prepare(AudioIOData &io);
 
  SynthVoice *mVoicesToInsert{nullptr};
  SynthVoice *mFreeVoices{nullptr};
  SynthVoice *mActiveVoices{nullptr};
  std::mutex mVoiceToInsertLock;
  std::mutex mFreeVoiceLock;
  std::mutex mGraphicsLock; // TODO: remove this lock?
 
  bool m_useInternalAudioIO = true;
  bool m_internalAudioConfigured = false;
 
  uint16_t mVoiceMaxOutputChannels = 2;
  uint16_t mVoiceMaxInputChannels = 0;
  uint16_t mVoiceBusChannels = 0;
  std::shared_ptr<BusRoutingCallback> mBusRoutingCallback;
  AudioIOData internalAudioIO;
 
  SingleRWRingBuffer mVoiceIdsToTurnOff{64 * sizeof(int)};
  SingleRWRingBuffer mVoiceIdsToFree{64 * sizeof(int)};
 
  TimeMasterMode mMasterMode;
 
  std::vector<AudioCallback *> mPostProcessing;
 
  typedef std::pair<
      std::function<bool(SynthVoice *voice, int offsetFrames, int id, void *)>,
      void *>
      TriggerOnCallback;
  std::vector<TriggerOnCallback> mTriggerOnCallbacks;
 
  typedef std::pair<std::function<bool(int id, void *)>, void *>
      TriggerOffCallback;
  std::vector<TriggerOffCallback> mTriggerOffCallbacks;
 
  typedef std::pair<std::function<bool(int id, void *)>, void *> FreeCallback;
  std::vector<FreeCallback> mFreeCallbacks;
 
  typedef std::pair<std::function<void(SynthVoice *voice, void *)>, void *>
      AllocationCallback;
  std::vector<AllocationCallback> mAllocationCallbacks;
 
  float mAudioGain{1.0f};
 
  int mIdCounter{1000};
 
  // Flag used to notify processing to turn off all voices
  bool mAllNotesOff{false};
 
  typedef std::function<SynthVoice *()> VoiceCreatorFunc;
  typedef std::map<std::string, VoiceCreatorFunc> Creators;
 
  void *mDefaultUserData{nullptr};
 
  Creators mCreators;
  // Disallow auto allocation for class name. Set in allocateVoice()
  std::vector<std::string> mNoAllocationList;
  std::vector<size_t> mChannelMap; // Maps synth output to audio channels
 
  bool mRunCPUClock{true};
  double mCpuGranularitySec = 0.001; // 1ms
  std::unique_ptr<std::thread> mCpuClockThread;
 
  bool mVerbose{false};
};
 
template <class TSynthVoice> void PolySynth::disableAllocation() {
  std::string name = demangle(typeid(TSynthVoice).name());
  disableAllocation(name);
}
 
template <class TSynthVoice> TSynthVoice *PolySynth::getVoice(bool forceAlloc) {
  std::unique_lock<std::mutex> lk(
      mFreeVoiceLock); // Only one getVoice() call at a time
  SynthVoice *freeVoice = mFreeVoices;
  SynthVoice *previousVoice = nullptr;
  if (forceAlloc) {
    freeVoice = nullptr;
  } else {
    while (freeVoice) {
      if (std::type_index(typeid(*freeVoice)) ==
          std::type_index(typeid(TSynthVoice))) {
        if (previousVoice) {
          previousVoice->next = freeVoice->next;
        } else {
          mFreeVoices = freeVoice->next;
        }
        break;
      }
      previousVoice = freeVoice;
      freeVoice = freeVoice->next;
    }
  }
  if (!freeVoice) { // No free voice in list, so we need to allocate it
    // TODO report current polyphony for more informed allocation of polyphony
    // TODO check if allocation allowed
    //  But only allocate if allocation has not been disabled
    std::string name = demangle(typeid(TSynthVoice).name());
    if (std::find(mNoAllocationList.begin(), mNoAllocationList.end(), name) ==
        mNoAllocationList.end()) {
      // TODO report current polyphony for more informed allocation of polyphony
      freeVoice = allocateVoice<TSynthVoice>();
      if (mVerbose) {
        std::cout << "Allocating voice of type " << typeid(TSynthVoice).name()
                  << "." << std::endl;
      }
    } else {
      std::cout << "Automatic allocation disabled for voice:" << name
                << std::endl;
    }
  }
  return static_cast<TSynthVoice *>(freeVoice);
}
 
template <class TSynthVoice> void PolySynth::allocatePolyphony(int number) {
  std::unique_lock<std::mutex> lk(mFreeVoiceLock);
  SynthVoice *lastVoice = mFreeVoices;
  if (lastVoice) {
    while (lastVoice->next) {
      lastVoice = lastVoice->next;
    }
  } else {
    lastVoice = mFreeVoices = allocateVoice<TSynthVoice>();
    number--;
  }
  for (int i = 0; i < number; i++) {
    lastVoice->next = allocateVoice<TSynthVoice>();
    lastVoice = lastVoice->next;
  }
}
 
} // namespace al
 
#endif // AL_POLYSYNTH_HPP