Synthesiser.h

Go to the documentation of this file.

/*
  ==============================================================================
 
   This file is part of the Water library.
   Copyright (c) 2016 ROLI Ltd.
   Copyright (C) 2018 Filipe Coelho <falktx@falktx.com>
 
   Permission is granted to use this software under the terms of the ISC license
   http://www.isc.org/downloads/software-support-policy/isc-license/
 
   Permission to use, copy, modify, and/or distribute this software for any
   purpose with or without fee is hereby granted, provided that the above
   copyright notice and this permission notice appear in all copies.
 
   THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH REGARD
   TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
   FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT,
   OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
   USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
   TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
   OF THIS SOFTWARE.
 
  ==============================================================================
*/
 
#ifndef WATER_SYNTHESISER_H_INCLUDED
#define WATER_SYNTHESISER_H_INCLUDED
 
#include "../buffers/AudioSampleBuffer.h"
#include "../containers/OwnedArray.h"
#include "../containers/ReferenceCountedArray.h"
 
#include "CarlaJuceUtils.hpp"
#include "CarlaMutex.hpp"
 
namespace water {
 
//==============================================================================
class SynthesiserSound    : public ReferenceCountedObject
{
protected:
    //==============================================================================
    SynthesiserSound();
 
public:
    virtual ~SynthesiserSound();
 
    //==============================================================================
    virtual bool appliesToNote (int midiNoteNumber) = 0;

    virtual bool appliesToChannel (int midiChannel) = 0;

    typedef ReferenceCountedObjectPtr<SynthesiserSound> Ptr;
 
 
private:
    //==============================================================================
    CARLA_LEAK_DETECTOR (SynthesiserSound)
};
 
 
//==============================================================================
class SynthesiserVoice
{
public:
    //==============================================================================
    SynthesiserVoice();

    virtual ~SynthesiserVoice();
 
    //==============================================================================
    int getCurrentlyPlayingNote() const noexcept                        { return currentlyPlayingNote; }

    SynthesiserSound::Ptr getCurrentlyPlayingSound() const noexcept     { return currentlyPlayingSound; }

    virtual bool canPlaySound (SynthesiserSound*) = 0;

    virtual void startNote (int midiNoteNumber,
                            float velocity,
                            SynthesiserSound* sound,
                            int currentPitchWheelPosition) = 0;

    virtual void stopNote (float velocity, bool allowTailOff) = 0;

    virtual bool isVoiceActive() const;

    virtual void pitchWheelMoved (int newPitchWheelValue) = 0;

    virtual void controllerMoved (int controllerNumber, int newControllerValue) = 0;

    virtual void aftertouchChanged (int newAftertouchValue);

    virtual void channelPressureChanged (int newChannelPressureValue);
 
    //==============================================================================
    virtual void renderNextBlock (AudioSampleBuffer& outputBuffer,
                                  int startSample,
                                  int numSamples) = 0;

    virtual void setCurrentPlaybackSampleRate (double newRate);

    virtual bool isPlayingChannel (int midiChannel) const;

    double getSampleRate() const noexcept                       { return currentSampleRate; }

    bool isKeyDown() const noexcept                             { return keyIsDown; }

    bool isSustainPedalDown() const noexcept                    { return sustainPedalDown; }

    bool isSostenutoPedalDown() const noexcept                  { return sostenutoPedalDown; }

    bool isPlayingButReleased() const noexcept
    {
        return isVoiceActive() && ! (isKeyDown() || isSostenutoPedalDown() || isSustainPedalDown());
    }

    bool wasStartedBefore (const SynthesiserVoice& other) const noexcept;
 
protected:
    void clearCurrentNote();
 
 
private:
    //==============================================================================
    friend class Synthesiser;
 
    double currentSampleRate;
    int currentlyPlayingNote, currentPlayingMidiChannel;
    uint32 noteOnTime;
    SynthesiserSound::Ptr currentlyPlayingSound;
    bool keyIsDown, sustainPedalDown, sostenutoPedalDown;
 
    AudioSampleBuffer tempBuffer;
 
    CARLA_LEAK_DETECTOR (SynthesiserVoice)
};
 
 
//==============================================================================
class Synthesiser
{
public:
    //==============================================================================
    Synthesiser();

    virtual ~Synthesiser();
 
    //==============================================================================
    void clearVoices();

    size_t getNumVoices() const noexcept                            { return voices.size(); }

    SynthesiserVoice* getVoice (int index) const;

    SynthesiserVoice* addVoice (SynthesiserVoice* newVoice);

    void removeVoice (int index);
 
    //==============================================================================
    void clearSounds();

    int getNumSounds() const noexcept                               { return sounds.size(); }

    SynthesiserSound* getSound (int index) const noexcept           { return sounds [index]; }

    SynthesiserSound* addSound (const SynthesiserSound::Ptr& newSound);

    void removeSound (int index);
 
    //==============================================================================
    void setNoteStealingEnabled (bool shouldStealNotes);

    bool isNoteStealingEnabled() const noexcept                     { return shouldStealNotes; }
 
    //==============================================================================
    virtual void noteOn (int midiChannel,
                         int midiNoteNumber,
                         float velocity);

    virtual void noteOff (int midiChannel,
                          int midiNoteNumber,
                          float velocity,
                          bool allowTailOff);

    virtual void allNotesOff (int midiChannel,
                              bool allowTailOff);

    virtual void handlePitchWheel (int midiChannel,
                                   int wheelValue);

    virtual void handleController (int midiChannel,
                                   int controllerNumber,
                                   int controllerValue);

    virtual void handleAftertouch (int midiChannel, int midiNoteNumber, int aftertouchValue);

    virtual void handleChannelPressure (int midiChannel, int channelPressureValue);

    virtual void handleSustainPedal (int midiChannel, bool isDown);

    virtual void handleSostenutoPedal (int midiChannel, bool isDown);

    virtual void handleSoftPedal (int midiChannel, bool isDown);

    virtual void handleProgramChange (int midiChannel,
                                      int programNumber);
 
    //==============================================================================
    virtual void setCurrentPlaybackSampleRate (double sampleRate);

    inline void renderNextBlock (AudioSampleBuffer& outputAudio,
                                 const MidiBuffer& inputMidi,
                                 int startSample,
                                 int numSamples)
        { processNextBlock (outputAudio, inputMidi, startSample, numSamples); }

    double getSampleRate() const noexcept                       { return sampleRate; }

    void setMinimumRenderingSubdivisionSize (int numSamples, bool shouldBeStrict = false) noexcept;

    virtual void renderVoices (AudioSampleBuffer& outputAudio,
                               int startSample, int numSamples);

    virtual void handleMidiEvent (const MidiMessage&);
 
protected:
    //==============================================================================
    OwnedArray<SynthesiserVoice> voices;
    ReferenceCountedArray<SynthesiserSound> sounds;

    int lastPitchWheelValues [16];

    virtual SynthesiserVoice* findFreeVoice (SynthesiserSound* soundToPlay,
                                             int midiChannel,
                                             int midiNoteNumber,
                                             bool stealIfNoneAvailable) const;

    virtual SynthesiserVoice* findVoiceToSteal (SynthesiserSound* soundToPlay,
                                                int midiChannel,
                                                int midiNoteNumber) const;

    void startVoice (SynthesiserVoice* voice,
                     SynthesiserSound* sound,
                     int midiChannel,
                     int midiNoteNumber,
                     float velocity);

    void stopVoice (SynthesiserVoice*, float velocity, bool allowTailOff);
 
private:
    //==============================================================================
    void processNextBlock (AudioSampleBuffer& outputAudio,
                           const MidiBuffer& inputMidi,
                           int startSample,
                           int numSamples);
    //==============================================================================
    double sampleRate;
    uint32 lastNoteOnCounter;
    int minimumSubBlockSize;
    bool subBlockSubdivisionIsStrict;
    bool shouldStealNotes;
    bool sustainPedalsDown[17];
 
    CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (Synthesiser)
};
 
}
 
#endif   // WATER_SYNTHESISER_H_INCLUDED