KwidgetAudioProcessor.h

Go to the documentation of this file.

#pragma once
 
namespace krotos
{
    class KwidgetAudioProcessor
        : public AudioProcessor,
          public AudioProcessorParameter::Listener,
          public Kwidget_CoreEngine::Listener, // listen to events raised by Kwidgets of type Kwidget_CoreEngine [SOLO]
          public Kwidget_Reformer::Listener,   // listen to events raised by Kwidgets of type Kwidget_Reformer [SOLO]
          public Kwidget_TriggerButton::Listener,
          public Timer
    {
      public:
        using KType = KwidgetFactory::KwidgetType;
        using KMod = KwidgetFactory::KwidgetModifiers;
 
        // A const array defining the "static" kwidget types.
        // A static kwidget is a special type of kwidget which is not fully managed by the processor.
        // Typically they are instantiated in the processor constructor before dynamic kwidgets, and persist across
        // setState calls. The AudioOut kwidget is static as it must be instantiated first, and has a special i/o
        // configuration in the processing chain. Unlike dynamic kwidgets, adding its type to this array prevents
        // removal or recreation during state recall. Instantiation and audio connections must be implemented manually.
        // The static kwidget design is likely to be deprecated in the future, so think carefully before adding a new
        // static kwidget.
        static const StringArray StaticKwidgetTypes;
        static const StringArray StaticKwidgetIDs;
 
        KwidgetAudioProcessor(const BusesProperties& ioLayouts, size_t numBusses, size_t channelsPerStereoBus,
                              size_t numRecorders, size_t numInputChannels, size_t numOutputChannels);
 
        ~KwidgetAudioProcessor() override;
 
        struct KListener
        {
            virtual void kwidgetAdded(Kwidget*) = 0;
            virtual void kwidgetRemoved(Kwidget*) = 0;
            virtual ~KListener() = default;
        };
 
        void addKListener(KListener* l);
        void removeKListener(KListener* l);
 
        void prepareToPlay(double sampleRate, int samplesPerBlock) override;
        void processBlock(AudioBuffer<float>&, MidiBuffer&) override;
        void releaseResources() override {}
 
        void removeEngines();
 
        Kwidget* addUserKwidget(const String& kwidgetType, const String& idModifier = "", int typeInstanceLimit = 0);
 
        Kwidget* addChildKwidget(const String& kwidgetType, const String& parentID = "", const String& childID = "",
                                 int typeInstanceLimit = 0);
 
        Kwidget* addKwidgetFromState(const ValueTree& kwidgetTree);
 
        void removeKwidget(const String& kwidgetID);
 
        void removeDynamicKwidgets();
 
        void removeKwidgetsExcluding(const StringArray& kwidgetsToExclude);
 
        void removeKwidgetsOfType(const StringArray& kwidgetTypesToRemove);
 
        bool addConnection(const String& sourceID, const String& destID);
 
        bool makeStaticConnectionsForKwidget(Kwidget* kwidget);
 
        void clearModulation();
 
        bool setState(const ValueTree& newState);
 
        void loadBundle(const File& bundleDirectory);
 
        bool validateState(const ValueTree& newState, bool repairEnabled);
 
        void notifyAllKwidgetsParametersListeners();
 
        ValueTree getState();
 
        const Array<Kwidget*>& getKwidgets();
 
        Kwidget* getKwidget(const String& kwidgetID);
 
        const Array<Kwidget*> getKwidgetsOfType(const String kwidgetType);
 
        const Array<Kwidget*> getKwidgetsOfTypeWithAccessPermission(const StringRef kwidgetType, const StringRef reqId);
 
        Kwidget* getKwidgetWithAccessPermission(const String& kwidgetID, const StringRef reqId);
 
        void getStateInformation(MemoryBlock& destData) override;
        void setStateInformation(const void* data, int sizeInBytes) override;
        void setLastPresetPath(String inLastPresetPath);
        String& getLastPresetPath();
        const String getName() const override;
        bool acceptsMidi() const override;
        bool producesMidi() const override;
        bool isMidiEffect() const override;
        double getTailLengthSeconds() const override;
        int getNumPrograms() override;
        int getCurrentProgram() override;
        void setCurrentProgram(int index) override;
        const String getProgramName(int index) override;
        void changeProgramName(int index, const String& newName) override;
        bool isBusesLayoutSupported(const BusesLayout&) const override;
 
        void timerCallback() override;
 
        bool isRecording();
        const bool isRecordingTriggerStarted() { return m_recordingTriggerStarted; };
 
        inline const bool isAStaticKwidgetType(const String& kType)
        {
            return std::find(StaticKwidgetTypes.begin(), StaticKwidgetTypes.end(), kType) != StaticKwidgetTypes.end();
        };
 
        const bool isAStaticKwidget(const Kwidget& kwidget);
 
        void setReadSpecificFiles(bool canRead);
 
        bool isKwidgetAddedFromState() const { return m_addedFromState; };
        void setAddedFromState(bool isAddedFromState) { m_addedFromState = isAddedFromState; };
 
        std::function<void()> onAutoplayTimerStop;
 
        ParameterManager parameterManager;
        PresetManager presetManager;
        AssetManager assetManager;
 
        static SettingsFile settingsFile;
 
        PluginHostType host;
 
        std::unique_ptr<ValueTree> presetInfoTree;
 
        // settings consts
        static const String autoPlayMaxDuration;
        static const String recorderReleaseTime;
        static const String DroppedFileNameFormat;
        static const String DefaultDroppedFileNameFormat;
        static const String T2PStrictMode;
 
        /* TODO: KST-1954 - this is a workaround to allow host projects to determine the UNIT_TEST define, due to a
         * currently unknown preprocessor issue */
#if UNIT_TEST == 1
        const bool unitTest{true};
#else
        const bool unitTest{false};
#endif
      protected:
        bool bypassPostFx{false};
 
      private:
        void initialiseSettingsFileValues();
        void initialiseAudioOutConfiguration();
        void initialiseRecorders();
        void initialiseMasterFX();
 
        void setInitialState();
 
        Kwidget* addKwidgetWithID(const String& kwidgetType, const String& kwidgetID, bool useEndParams = false,
                                  bool isChildKwidget = false);
 
        void addKwidgetInternal(std::unique_ptr<Kwidget> kwidget);
        void initialiseStateListeners();
        void triggerRecordingStart(); // trigger recording start with note on
        void triggerRecordingStop();  // trigger recording start with note off, recording stops after release time
 
        virtual void parameterValueChanged(int /*parameterIndex*/, float newValue) override;
        void parameterGestureChanged(int /*parameterIndex*/, bool /*gestureIsStarting*/) override {}
 
        // CoreEngine::Listener functions [SOLO]
        virtual void soloActivated(Kwidget_CoreEngine* engine) override;
        virtual void soloDeActivated(Kwidget_CoreEngine* engine) override;
        virtual void autoPlayChanged(Kwidget_CoreEngine* engine, float newValue) override;
        virtual void loopEnableChanged(Kwidget_CoreEngine* engine, float newValue) override;
 
        // Reformer::Listener functions [SOLO]
        virtual void soloActivated(Kwidget_Reformer* engine) override;
        virtual void soloDeActivated(Kwidget_Reformer* engine) override;
        virtual void autoPlayChanged(Kwidget_Reformer* engine, float newValue) override {}
        virtual void loopEnableChanged(Kwidget_Reformer* engine, float newValue) override {}
 
        void soloActivatedAllEngines(const String& callingID);
 
        void soloDeActivatedAllEngines(const String& callingID);
 
        // TriggerButton::Listener functions
        virtual void onClickChanged(Kwidget_TriggerButton* triggerButton, float newValue,
                                    MIDIMode midiModeValue) override;
 
        void autoPlayGlobalChanged(bool newVal);
 
        void recordOutput(AudioBuffer<float>& buffer, MidiBuffer& midiMessages);
 
        // Set data for all recorders kwidgets drag and drop file naming
        void setRecordersNameData(String currentPresetName);
 
        AudioBuffer<float> extractStereoBuffer(int numChannel1, int numChannel2,
                                               AudioBuffer<float>& multiChannelBuffer);
 
        size_t m_numBusses;
        size_t m_channelsPerStereoBus;
        size_t m_numRecorders;
 
        std::vector<Kwidget*> m_audioOuts;
        const String m_masterAudioOutID{"Master"};
        Kwidget* m_masterAudioOut{nullptr};
 
#if ENABLE_SANDBOX
        Kwidget* m_audioOutSandBox{nullptr};
#endif
        std::unique_ptr<Kwidget> m_masterFilter;
        std::unique_ptr<Kwidget> m_masterReverb;
        std::unique_ptr<Kwidget> m_intensityMacro;
 
        std::vector<std::unique_ptr<Kwidget>> m_recorders{m_numRecorders};
        KParameter* m_audioOutFxEnabledParameter;
        Array<Kwidget_Recorder*> m_recorderPtrs;
 
        String m_initPresetPath;
        String m_lastLoadedPresetPath;
 
        const int m_numVoices;
        bool m_globalAutoplayOn{false};
        std::map<juce::String, bool> m_autoplay;
        bool m_xypadTriggerOn{false};
 
        bool m_addedFromState{false};
 
        bool m_isRecording{false};
        bool m_recordingTriggerStarted{false};
 
        float m_previousTriggerValue{0.0f};
 
        KwidgetProcessorGraph m_mainGraph;      // <CONNECTIONS>
        KwidgetProcessorGraph m_modulatorGraph; // <MODULATIONS>
 
        KwidgetSynth m_synthPoly;  // Synth instance for normal polyphony
        KwidgetSynth m_synthDrone; // Synth instance for autoplay
 
        std::unique_ptr<ValueTreeAttachment> m_connectionAttachment;
        std::unique_ptr<ValueTreeAttachment> m_modulationAttachment;
        OwnedArray<CustomParameter> m_modulationInstances;
 
        Array<Kwidget*> m_kwidgets;
        std::map<String, Kwidget*> m_kwidgetLookup;
 
        ListenerList<KListener> m_listeners;
 
        std::atomic<bool> m_shouldInit{true};
 
        // true only on first plugin Instantiation
        bool m_editorShouldShowWelcomeDialog{false};
 
        bool m_readSpecificFiles{false};
 
        PresetEventMiddleware m_presetEventMiddleware;
 
        CriticalSection m_lock;
 
        WeakReference<KwidgetAudioProcessor>::Master masterReference;
        friend class WeakReference<KwidgetAudioProcessor>;
 
        JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(KwidgetAudioProcessor)
    };
} // namespace krotos