RTProcessor.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018-2019 pongasoft
 *
 * Licensed under the Apache License, Version 2.0 or the MIT license,
 * at your option. You may not use this file except in compliance with
 * one of these licenses. You may obtain copies of the licenses at:
 *
 * https://www.apache.org/licenses/LICENSE-2.0
 * https://opensource.org/licenses/MIT
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 *
 * @author Yan Pujante
 */
#pragma once
 
#include <base/source/timer.h>
#include <public.sdk/source/vst/vstaudioeffect.h>
#include <pongasoft/VST/Timer.h>
#include <chrono>
#include "RTState.h"
 
namespace pongasoft::VST::RT {
 
using namespace Steinberg;
using namespace Steinberg::Vst;

class RTProcessor : public AudioEffect, public IMessageProducer
{
public:
  explicit RTProcessor(Steinberg::FUID const &iControllerUID);
 
  ~RTProcessor() override = default;

  virtual RTState *getRTState() = 0;

  tresult PLUGIN_API initialize(FUnknown *context) override;

  tresult PLUGIN_API setActive(TBool state) override;

  tresult PLUGIN_API process(ProcessData &data) override;

  tresult PLUGIN_API canProcessSampleSize(int32 symbolicSampleSize) override;

  tresult PLUGIN_API setState(IBStream *state) override;

  tresult PLUGIN_API getState(IBStream *state) override;

  tresult PLUGIN_API notify(IMessage *message) SMTG_OVERRIDE;
 
protected:
  virtual bool canProcess32Bits() const { return true; }

  virtual bool canProcess64Bits() const { return true; }

  virtual tresult processInputs(ProcessData &data);

  virtual tresult processInputs32Bits(ProcessData &data) { return kResultOk; }

  virtual tresult processInputs64Bits(ProcessData &data) { return kResultOk; }

  virtual void onGUITimer() {}

  void enableGUITimer(uint32 iUIFrameRateMs);

  template<typename Rep, typename Period>
  void enableGUITimer(std::chrono::duration<Rep, Period> iUIFrameRate)
  {
    enableGUITimer(std::chrono::duration_cast<std::chrono::milliseconds>(iUIFrameRate).count());
  }

  virtual void sendPendingMessages() { getRTState()->sendPendingMessages(this); }
 
protected:
  // interval for gui message timer (can be changed by subclass BEFORE calling `initialize`)
  uint32 fGUIMessageTimerIntervalMs;
 
public:
  // allocateMessage
  IPtr<IMessage> allocateMessage() override;
 
  // sendMessage
  tresult sendMessage(IPtr<IMessage> iMessage) override;
 
private:
  using RTProcessorCallback = void (RTProcessor::*)();
 
  // wrapper class to dispatch the callback
  class GUITimerCallback : public ITimerCallback
  {
  public:
    explicit GUITimerCallback(RTProcessor *iProcessor,
                              RTProcessorCallback iCallback) : fProcessor{iProcessor}, fCallback{iCallback} {}
 
    void onTimer(Timer *timer) override
    {
      (fProcessor->*fCallback)();
    }
  private:
    RTProcessor *fProcessor;
    RTProcessorCallback fCallback;
  };
 
 
 
private:
  // the generic gui timer (enabled with enableGUITimer)
  GUITimerCallback fGUITimerCallback{this, &RTProcessor::onGUITimer};
  uint32 fGUITimerIntervalMs;
  std::unique_ptr<AutoReleaseTimer> fGUITimer;
 
  // the timer that will handle sending messages (enabled when there are messages to handle)
  GUITimerCallback fGUIMessageTimerCallback{this, &RTProcessor::sendPendingMessages};
  std::unique_ptr<AutoReleaseTimer> fGUIMessageTimer;
 
  bool fActive;
 
#ifdef JAMBA_DEBUG_LOGGING
  int32 fSymbolicSampleSize = -1;
#endif
};
 
}