RTProcessor.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018-2019 pongasoft
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * 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 "RTState.h"

namespace pongasoft {
namespace VST {
namespace 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);

   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
};

}
}
}