juce_AudioProcessor.h

Go to the documentation of this file.

/*
  ==============================================================================
 
   This file is part of the JUCE library.
   Copyright (c) 2015 - ROLI Ltd.
 
   Permission is granted to use this software under the terms of either:
   a) the GPL v2 (or any later version)
   b) the Affero GPL v3
 
   Details of these licenses can be found at: www.gnu.org/licenses
 
   JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
   A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
 
   ------------------------------------------------------------------------------
 
   To release a closed-source product which uses JUCE, commercial licenses are
   available: visit www.juce.com for more information.
 
  ==============================================================================
*/
 
#ifndef JUCE_AUDIOPROCESSOR_H_INCLUDED
#define JUCE_AUDIOPROCESSOR_H_INCLUDED
 
 
//==============================================================================
class JUCE_API  AudioProcessor
{
protected:
    //==============================================================================
    AudioProcessor();
 
public:
    virtual ~AudioProcessor();
 
    //==============================================================================
    virtual const String getName() const = 0;
 
    //==============================================================================
    virtual void prepareToPlay (double sampleRate,
                                int estimatedSamplesPerBlock) = 0;
 
    virtual void releaseResources() = 0;
 
    virtual void processBlock (AudioSampleBuffer& buffer,
                               MidiBuffer& midiMessages) = 0;
 
    virtual void processBlockBypassed (AudioSampleBuffer& buffer,
                                       MidiBuffer& midiMessages);
 
    //==============================================================================
    AudioPlayHead* getPlayHead() const noexcept                 { return playHead; }
 
 
    //==============================================================================
    double getSampleRate() const noexcept                       { return sampleRate; }
 
    int getBlockSize() const noexcept                           { return blockSize; }
 
    //==============================================================================
    int getNumInputChannels() const noexcept                    { return numInputChannels; }
 
    int getNumOutputChannels() const noexcept                   { return numOutputChannels; }
 
    const String& getInputSpeakerArrangement() const noexcept   { return inputSpeakerArrangement; }
 
    const String& getOutputSpeakerArrangement() const noexcept  { return outputSpeakerArrangement; }
 
    //==============================================================================
    virtual const String getInputChannelName (int channelIndex) const = 0;
 
    virtual const String getOutputChannelName (int channelIndex) const = 0;
 
    virtual bool isInputChannelStereoPair (int index) const = 0;
 
    virtual bool isOutputChannelStereoPair (int index) const = 0;
 
    int getLatencySamples() const noexcept                      { return latencySamples; }
 
    void setLatencySamples (int newLatency);
 
    virtual bool silenceInProducesSilenceOut() const = 0;
 
    virtual double getTailLengthSeconds() const = 0;
 
    virtual bool acceptsMidi() const = 0;
 
    virtual bool producesMidi() const = 0;
 
    //==============================================================================
    const CriticalSection& getCallbackLock() const noexcept     { return callbackLock; }
 
    void suspendProcessing (bool shouldBeSuspended);
 
    bool isSuspended() const noexcept                                   { return suspended; }
 
    virtual void reset();
 
    //==============================================================================
    bool isNonRealtime() const noexcept                                 { return nonRealtime; }
 
    virtual void setNonRealtime (bool isNonRealtime) noexcept;
 
    //==============================================================================
    virtual AudioProcessorEditor* createEditor() = 0;
 
    virtual bool hasEditor() const = 0;
 
    //==============================================================================
    AudioProcessorEditor* getActiveEditor() const noexcept             { return activeEditor; }
 
    AudioProcessorEditor* createEditorIfNeeded();
 
    //==============================================================================
    virtual int getNumParameters();
 
    virtual const String getParameterName (int parameterIndex);
 
    virtual float getParameter (int parameterIndex);
 
    virtual String getParameterName (int parameterIndex, int maximumStringLength);
 
    virtual const String getParameterText (int parameterIndex);
 
    virtual String getParameterText (int parameterIndex, int maximumStringLength);
 
    virtual int getParameterNumSteps (int parameterIndex);
 
    static int getDefaultNumParameterSteps() noexcept;
 
    virtual float getParameterDefaultValue (int parameterIndex);
 
    virtual String getParameterLabel (int index) const;
 
    virtual bool isParameterOrientationInverted (int index) const;
 
    virtual void setParameter (int parameterIndex, float newValue);
 
    void setParameterNotifyingHost (int parameterIndex, float newValue);
 
    virtual bool isParameterAutomatable (int parameterIndex) const;
 
    virtual bool isMetaParameter (int parameterIndex) const;
 
    void beginParameterChangeGesture (int parameterIndex);
 
    void endParameterChangeGesture (int parameterIndex);
 
    void updateHostDisplay();
 
    //==============================================================================
    void addParameter (AudioProcessorParameter*);
 
    const OwnedArray<AudioProcessorParameter>& getParameters() const noexcept;
 
    //==============================================================================
    virtual int getNumPrograms() = 0;
 
    virtual int getCurrentProgram() = 0;
 
    virtual void setCurrentProgram (int index) = 0;
 
    virtual const String getProgramName (int index) = 0;
 
    virtual void changeProgramName (int index, const String& newName) = 0;
 
    //==============================================================================
    virtual void getStateInformation (juce::MemoryBlock& destData) = 0;
 
    virtual void getCurrentProgramStateInformation (juce::MemoryBlock& destData);
 
    virtual void setStateInformation (const void* data, int sizeInBytes) = 0;
 
    virtual void setCurrentProgramStateInformation (const void* data, int sizeInBytes);
 
    virtual void numChannelsChanged();
 
    //==============================================================================
    virtual void addListener (AudioProcessorListener* newListener);
 
    virtual void removeListener (AudioProcessorListener* listenerToRemove);
 
    //==============================================================================
    virtual void setPlayHead (AudioPlayHead* newPlayHead);
 
    //==============================================================================
    void setPlayConfigDetails (int numIns, int numOuts, double sampleRate, int blockSize) noexcept;
 
    //==============================================================================
    void editorBeingDeleted (AudioProcessorEditor*) noexcept;
 
    void setSpeakerArrangement (const String& inputs, const String& outputs);
 
    enum WrapperType
    {
        wrapperType_Undefined = 0,
        wrapperType_VST,
        wrapperType_VST3,
        wrapperType_AudioUnit,
        wrapperType_RTAS,
        wrapperType_AAX,
        wrapperType_Standalone
    };
 
    WrapperType wrapperType;
 
    //==============================================================================
    static void copyXmlToBinary (const XmlElement& xml,
                                 juce::MemoryBlock& destData);
 
    static XmlElement* getXmlFromBinary (const void* data, int sizeInBytes);
 
    static void JUCE_CALLTYPE setTypeOfNextNewPlugin (WrapperType);
 
protected:
    AudioPlayHead* playHead;
 
    void sendParamChangeMessageToListeners (int parameterIndex, float newValue);
 
private:
    Array<AudioProcessorListener*> listeners;
    Component::SafePointer<AudioProcessorEditor> activeEditor;
    double sampleRate;
    int blockSize, numInputChannels, numOutputChannels, latencySamples;
    bool suspended, nonRealtime;
    CriticalSection callbackLock, listenerLock;
    String inputSpeakerArrangement, outputSpeakerArrangement;
 
    OwnedArray<AudioProcessorParameter> managedParameters;
    AudioProcessorParameter* getParamChecked (int) const noexcept;
 
   #if JUCE_DEBUG && ! JUCE_DISABLE_AUDIOPROCESSOR_BEGIN_END_GESTURE_CHECKING
    BigInteger changingParams;
   #endif
 
    AudioProcessorListener* getListenerLocked (int) const noexcept;
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (AudioProcessor)
};
 
 
#endif   // JUCE_AUDIOPROCESSOR_H_INCLUDED