gearmulator

Emulation of classic VA synths of the late 90s/2000s that are based on Motorola 56300 family DSPs
Log | Files | Refs | Submodules | README | LICENSE

plugin.h (2390B)

      1 #pragma once
      2 
      3 #include <mutex>
      4 #include <functional>
      5 
      6 #include "midiTypes.h"
      7 #include "resamplerInOut.h"
      8 #include "buildconfig.h"
      9 
     10 #include "dsp56kEmu/ringbuffer.h"
     11 
     12 #include "deviceTypes.h"
     13 #include "midiClock.h"
     14 
     15 namespace synthLib
     16 {
     17 	class Device;
     18 
     19 	class Plugin
     20 	{
     21 	public:
     22 		using CallbackDeviceInvalid = std::function<Device*(Device*)>;
     23 
     24 		Plugin(Device* _device, CallbackDeviceInvalid _callbackDeviceInvalid);
     25 
     26 		void addMidiEvent(const SMidiEvent& _ev);
     27 
     28 		bool setPreferredDeviceSamplerate(float _samplerate);
     29 
     30 		void setHostSamplerate(float _hostSamplerate, float _preferredDeviceSamplerate);
     31 		float getHostSamplerate() const { return m_hostSamplerate; }
     32 		float getHostSamplerateInv() const { return m_hostSamplerateInv; }
     33 
     34 		void setBlockSize(uint32_t _blockSize);
     35 
     36 		uint32_t getLatencyMidiToOutput() const;
     37 		uint32_t getLatencyInputToOutput() const;
     38 
     39 		void process(const TAudioInputs& _inputs, const TAudioOutputs& _outputs, size_t _count, float _bpm, float _ppqPos, bool _isPlaying);
     40 		void getMidiOut(std::vector<SMidiEvent>& _midiOut);
     41 
     42 		bool isValid() const;
     43 
     44 		void setDevice(Device* _device);
     45 
     46 #if !SYNTHLIB_DEMO_MODE
     47 		bool getState(std::vector<uint8_t>& _state, StateType _type) const;
     48 		bool setState(const std::vector<uint8_t>& _state) const;
     49 #endif
     50 		void insertMidiEvent(const SMidiEvent& _ev);
     51 
     52 		bool setLatencyBlocks(uint32_t _latencyBlocks);
     53 		uint32_t getLatencyBlocks() const { return m_extraLatencyBlocks; }
     54 
     55 	private:
     56 		void processMidiClock(float _bpm, float _ppqPos, bool _isPlaying, size_t _sampleCount);
     57 		float* getDummyBuffer(size_t _minimumSize);
     58 		void updateDeviceLatency();
     59 		void processMidiInEvents();
     60 		void processMidiInEvent(const SMidiEvent& _ev);
     61 
     62 		dsp56k::RingBuffer<SMidiEvent, 1024, false> m_midiInRingBuffer;
     63 		std::vector<SMidiEvent> m_midiIn;
     64 		std::vector<SMidiEvent> m_midiOut;
     65 
     66 		SMidiEvent m_pendingSysexInput;
     67 
     68 		ResamplerInOut m_resampler;
     69 		mutable std::recursive_mutex m_lock;
     70 		mutable std::mutex m_lockAddMidiEvent;
     71 
     72 		Device* m_device;
     73 
     74 		std::vector<float> m_dummyBuffer;
     75 
     76 		float m_hostSamplerate = 0.0f;
     77 		float m_hostSamplerateInv = 0.0f;
     78 
     79 		uint32_t m_blockSize = 0;
     80 
     81 		uint32_t m_deviceLatencyMidiToOutput = 0;
     82 		uint32_t m_deviceLatencyInputToOutput = 0;
     83 
     84 		MidiClock m_midiClock;
     85 
     86 		uint32_t m_extraLatencyBlocks = 1;
     87 
     88 		float m_deviceSamplerate = 0.0f;
     89 		CallbackDeviceInvalid m_callbackDeviceInvalid;
     90 	};
     91 }