mirror of
https://github.com/juce-framework/JUCE.git
synced 2026-01-23 01:44:22 +00:00
Added Animated App template and examples
This commit is contained in:
Felix Faire
parent
fefcf7aca6
commit
ff6520a89a
1141 changed files with 438491 additions and 94 deletions
|
|
@ -0,0 +1,503 @@
|
|||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the JUCE library.
|
||||
Copyright (c) 2013 - Raw Material Software 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.
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
SynthesiserSound::SynthesiserSound() {}
|
||||
SynthesiserSound::~SynthesiserSound() {}
|
||||
|
||||
//==============================================================================
|
||||
SynthesiserVoice::SynthesiserVoice()
|
||||
: currentSampleRate (44100.0),
|
||||
currentlyPlayingNote (-1),
|
||||
noteOnTime (0),
|
||||
keyIsDown (false),
|
||||
sostenutoPedalDown (false)
|
||||
{
|
||||
}
|
||||
|
||||
SynthesiserVoice::~SynthesiserVoice()
|
||||
{
|
||||
}
|
||||
|
||||
bool SynthesiserVoice::isPlayingChannel (const int midiChannel) const
|
||||
{
|
||||
return currentlyPlayingSound != nullptr
|
||||
&& currentlyPlayingSound->appliesToChannel (midiChannel);
|
||||
}
|
||||
|
||||
void SynthesiserVoice::setCurrentPlaybackSampleRate (const double newRate)
|
||||
{
|
||||
currentSampleRate = newRate;
|
||||
}
|
||||
|
||||
bool SynthesiserVoice::isVoiceActive() const
|
||||
{
|
||||
return getCurrentlyPlayingNote() >= 0;
|
||||
}
|
||||
|
||||
void SynthesiserVoice::clearCurrentNote()
|
||||
{
|
||||
currentlyPlayingNote = -1;
|
||||
currentlyPlayingSound = nullptr;
|
||||
}
|
||||
|
||||
void SynthesiserVoice::aftertouchChanged (int) {}
|
||||
|
||||
bool SynthesiserVoice::wasStartedBefore (const SynthesiserVoice& other) const noexcept
|
||||
{
|
||||
return noteOnTime < other.noteOnTime;
|
||||
}
|
||||
|
||||
//==============================================================================
|
||||
Synthesiser::Synthesiser()
|
||||
: sampleRate (0),
|
||||
lastNoteOnCounter (0),
|
||||
shouldStealNotes (true)
|
||||
{
|
||||
for (int i = 0; i < numElementsInArray (lastPitchWheelValues); ++i)
|
||||
lastPitchWheelValues[i] = 0x2000;
|
||||
}
|
||||
|
||||
Synthesiser::~Synthesiser()
|
||||
{
|
||||
}
|
||||
|
||||
//==============================================================================
|
||||
SynthesiserVoice* Synthesiser::getVoice (const int index) const
|
||||
{
|
||||
const ScopedLock sl (lock);
|
||||
return voices [index];
|
||||
}
|
||||
|
||||
void Synthesiser::clearVoices()
|
||||
{
|
||||
const ScopedLock sl (lock);
|
||||
voices.clear();
|
||||
}
|
||||
|
||||
SynthesiserVoice* Synthesiser::addVoice (SynthesiserVoice* const newVoice)
|
||||
{
|
||||
const ScopedLock sl (lock);
|
||||
return voices.add (newVoice);
|
||||
}
|
||||
|
||||
void Synthesiser::removeVoice (const int index)
|
||||
{
|
||||
const ScopedLock sl (lock);
|
||||
voices.remove (index);
|
||||
}
|
||||
|
||||
void Synthesiser::clearSounds()
|
||||
{
|
||||
const ScopedLock sl (lock);
|
||||
sounds.clear();
|
||||
}
|
||||
|
||||
SynthesiserSound* Synthesiser::addSound (const SynthesiserSound::Ptr& newSound)
|
||||
{
|
||||
const ScopedLock sl (lock);
|
||||
return sounds.add (newSound);
|
||||
}
|
||||
|
||||
void Synthesiser::removeSound (const int index)
|
||||
{
|
||||
const ScopedLock sl (lock);
|
||||
sounds.remove (index);
|
||||
}
|
||||
|
||||
void Synthesiser::setNoteStealingEnabled (const bool shouldSteal)
|
||||
{
|
||||
shouldStealNotes = shouldSteal;
|
||||
}
|
||||
|
||||
//==============================================================================
|
||||
void Synthesiser::setCurrentPlaybackSampleRate (const double newRate)
|
||||
{
|
||||
if (sampleRate != newRate)
|
||||
{
|
||||
const ScopedLock sl (lock);
|
||||
|
||||
allNotesOff (0, false);
|
||||
|
||||
sampleRate = newRate;
|
||||
|
||||
for (int i = voices.size(); --i >= 0;)
|
||||
voices.getUnchecked (i)->setCurrentPlaybackSampleRate (newRate);
|
||||
}
|
||||
}
|
||||
|
||||
void Synthesiser::renderNextBlock (AudioSampleBuffer& outputBuffer, const MidiBuffer& midiData,
|
||||
int startSample, int numSamples)
|
||||
{
|
||||
// must set the sample rate before using this!
|
||||
jassert (sampleRate != 0);
|
||||
|
||||
const ScopedLock sl (lock);
|
||||
|
||||
MidiBuffer::Iterator midiIterator (midiData);
|
||||
midiIterator.setNextSamplePosition (startSample);
|
||||
MidiMessage m (0xf4, 0.0);
|
||||
|
||||
while (numSamples > 0)
|
||||
{
|
||||
int midiEventPos;
|
||||
const bool useEvent = midiIterator.getNextEvent (m, midiEventPos)
|
||||
&& midiEventPos < startSample + numSamples;
|
||||
|
||||
const int numThisTime = useEvent ? midiEventPos - startSample
|
||||
: numSamples;
|
||||
|
||||
if (numThisTime > 0)
|
||||
renderVoices (outputBuffer, startSample, numThisTime);
|
||||
|
||||
if (useEvent)
|
||||
handleMidiEvent (m);
|
||||
|
||||
startSample += numThisTime;
|
||||
numSamples -= numThisTime;
|
||||
}
|
||||
}
|
||||
|
||||
void Synthesiser::renderVoices (AudioSampleBuffer& buffer, int startSample, int numSamples)
|
||||
{
|
||||
for (int i = voices.size(); --i >= 0;)
|
||||
voices.getUnchecked (i)->renderNextBlock (buffer, startSample, numSamples);
|
||||
}
|
||||
|
||||
void Synthesiser::handleMidiEvent (const MidiMessage& m)
|
||||
{
|
||||
if (m.isNoteOn())
|
||||
{
|
||||
noteOn (m.getChannel(), m.getNoteNumber(), m.getFloatVelocity());
|
||||
}
|
||||
else if (m.isNoteOff())
|
||||
{
|
||||
noteOff (m.getChannel(), m.getNoteNumber(), m.getFloatVelocity(), true);
|
||||
}
|
||||
else if (m.isAllNotesOff() || m.isAllSoundOff())
|
||||
{
|
||||
allNotesOff (m.getChannel(), true);
|
||||
}
|
||||
else if (m.isPitchWheel())
|
||||
{
|
||||
const int channel = m.getChannel();
|
||||
const int wheelPos = m.getPitchWheelValue();
|
||||
lastPitchWheelValues [channel - 1] = wheelPos;
|
||||
|
||||
handlePitchWheel (channel, wheelPos);
|
||||
}
|
||||
else if (m.isAftertouch())
|
||||
{
|
||||
handleAftertouch (m.getChannel(), m.getNoteNumber(), m.getAfterTouchValue());
|
||||
}
|
||||
else if (m.isController())
|
||||
{
|
||||
handleController (m.getChannel(), m.getControllerNumber(), m.getControllerValue());
|
||||
}
|
||||
}
|
||||
|
||||
//==============================================================================
|
||||
void Synthesiser::noteOn (const int midiChannel,
|
||||
const int midiNoteNumber,
|
||||
const float velocity)
|
||||
{
|
||||
const ScopedLock sl (lock);
|
||||
|
||||
for (int i = sounds.size(); --i >= 0;)
|
||||
{
|
||||
SynthesiserSound* const sound = sounds.getUnchecked(i);
|
||||
|
||||
if (sound->appliesToNote (midiNoteNumber)
|
||||
&& sound->appliesToChannel (midiChannel))
|
||||
{
|
||||
// If hitting a note that's still ringing, stop it first (it could be
|
||||
// still playing because of the sustain or sostenuto pedal).
|
||||
for (int j = voices.size(); --j >= 0;)
|
||||
{
|
||||
SynthesiserVoice* const voice = voices.getUnchecked (j);
|
||||
|
||||
if (voice->getCurrentlyPlayingNote() == midiNoteNumber
|
||||
&& voice->isPlayingChannel (midiChannel))
|
||||
stopVoice (voice, 1.0f, true);
|
||||
}
|
||||
|
||||
startVoice (findFreeVoice (sound, midiChannel, midiNoteNumber, shouldStealNotes),
|
||||
sound, midiChannel, midiNoteNumber, velocity);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void Synthesiser::startVoice (SynthesiserVoice* const voice,
|
||||
SynthesiserSound* const sound,
|
||||
const int midiChannel,
|
||||
const int midiNoteNumber,
|
||||
const float velocity)
|
||||
{
|
||||
if (voice != nullptr && sound != nullptr)
|
||||
{
|
||||
if (voice->currentlyPlayingSound != nullptr)
|
||||
voice->stopNote (0.0f, false);
|
||||
|
||||
voice->startNote (midiNoteNumber, velocity, sound,
|
||||
lastPitchWheelValues [midiChannel - 1]);
|
||||
|
||||
voice->currentlyPlayingNote = midiNoteNumber;
|
||||
voice->noteOnTime = ++lastNoteOnCounter;
|
||||
voice->currentlyPlayingSound = sound;
|
||||
voice->keyIsDown = true;
|
||||
voice->sostenutoPedalDown = false;
|
||||
}
|
||||
}
|
||||
|
||||
void Synthesiser::stopVoice (SynthesiserVoice* voice, float velocity, const bool allowTailOff)
|
||||
{
|
||||
jassert (voice != nullptr);
|
||||
|
||||
voice->stopNote (velocity, allowTailOff);
|
||||
|
||||
// the subclass MUST call clearCurrentNote() if it's not tailing off! RTFM for stopNote()!
|
||||
jassert (allowTailOff || (voice->getCurrentlyPlayingNote() < 0 && voice->getCurrentlyPlayingSound() == 0));
|
||||
}
|
||||
|
||||
void Synthesiser::noteOff (const int midiChannel,
|
||||
const int midiNoteNumber,
|
||||
const float velocity,
|
||||
const bool allowTailOff)
|
||||
{
|
||||
const ScopedLock sl (lock);
|
||||
|
||||
for (int i = voices.size(); --i >= 0;)
|
||||
{
|
||||
SynthesiserVoice* const voice = voices.getUnchecked (i);
|
||||
|
||||
if (voice->getCurrentlyPlayingNote() == midiNoteNumber)
|
||||
{
|
||||
if (SynthesiserSound* const sound = voice->getCurrentlyPlayingSound())
|
||||
{
|
||||
if (sound->appliesToNote (midiNoteNumber)
|
||||
&& sound->appliesToChannel (midiChannel))
|
||||
{
|
||||
voice->keyIsDown = false;
|
||||
|
||||
if (! (sustainPedalsDown [midiChannel] || voice->sostenutoPedalDown))
|
||||
stopVoice (voice, velocity, allowTailOff);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void Synthesiser::allNotesOff (const int midiChannel, const bool allowTailOff)
|
||||
{
|
||||
const ScopedLock sl (lock);
|
||||
|
||||
for (int i = voices.size(); --i >= 0;)
|
||||
{
|
||||
SynthesiserVoice* const voice = voices.getUnchecked (i);
|
||||
|
||||
if (midiChannel <= 0 || voice->isPlayingChannel (midiChannel))
|
||||
voice->stopNote (1.0f, allowTailOff);
|
||||
}
|
||||
|
||||
sustainPedalsDown.clear();
|
||||
}
|
||||
|
||||
void Synthesiser::handlePitchWheel (const int midiChannel, const int wheelValue)
|
||||
{
|
||||
const ScopedLock sl (lock);
|
||||
|
||||
for (int i = voices.size(); --i >= 0;)
|
||||
{
|
||||
SynthesiserVoice* const voice = voices.getUnchecked (i);
|
||||
|
||||
if (midiChannel <= 0 || voice->isPlayingChannel (midiChannel))
|
||||
voice->pitchWheelMoved (wheelValue);
|
||||
}
|
||||
}
|
||||
|
||||
void Synthesiser::handleController (const int midiChannel,
|
||||
const int controllerNumber,
|
||||
const int controllerValue)
|
||||
{
|
||||
switch (controllerNumber)
|
||||
{
|
||||
case 0x40: handleSustainPedal (midiChannel, controllerValue >= 64); break;
|
||||
case 0x42: handleSostenutoPedal (midiChannel, controllerValue >= 64); break;
|
||||
case 0x43: handleSoftPedal (midiChannel, controllerValue >= 64); break;
|
||||
default: break;
|
||||
}
|
||||
|
||||
const ScopedLock sl (lock);
|
||||
|
||||
for (int i = voices.size(); --i >= 0;)
|
||||
{
|
||||
SynthesiserVoice* const voice = voices.getUnchecked (i);
|
||||
|
||||
if (midiChannel <= 0 || voice->isPlayingChannel (midiChannel))
|
||||
voice->controllerMoved (controllerNumber, controllerValue);
|
||||
}
|
||||
}
|
||||
|
||||
void Synthesiser::handleAftertouch (int midiChannel, int midiNoteNumber, int aftertouchValue)
|
||||
{
|
||||
const ScopedLock sl (lock);
|
||||
|
||||
for (int i = voices.size(); --i >= 0;)
|
||||
{
|
||||
SynthesiserVoice* const voice = voices.getUnchecked (i);
|
||||
|
||||
if (voice->getCurrentlyPlayingNote() == midiNoteNumber
|
||||
&& (midiChannel <= 0 || voice->isPlayingChannel (midiChannel)))
|
||||
voice->aftertouchChanged (aftertouchValue);
|
||||
}
|
||||
}
|
||||
|
||||
void Synthesiser::handleSustainPedal (int midiChannel, bool isDown)
|
||||
{
|
||||
jassert (midiChannel > 0 && midiChannel <= 16);
|
||||
const ScopedLock sl (lock);
|
||||
|
||||
if (isDown)
|
||||
{
|
||||
sustainPedalsDown.setBit (midiChannel);
|
||||
}
|
||||
else
|
||||
{
|
||||
for (int i = voices.size(); --i >= 0;)
|
||||
{
|
||||
SynthesiserVoice* const voice = voices.getUnchecked (i);
|
||||
|
||||
if (voice->isPlayingChannel (midiChannel) && ! voice->keyIsDown)
|
||||
stopVoice (voice, 1.0f, true);
|
||||
}
|
||||
|
||||
sustainPedalsDown.clearBit (midiChannel);
|
||||
}
|
||||
}
|
||||
|
||||
void Synthesiser::handleSostenutoPedal (int midiChannel, bool isDown)
|
||||
{
|
||||
jassert (midiChannel > 0 && midiChannel <= 16);
|
||||
const ScopedLock sl (lock);
|
||||
|
||||
for (int i = voices.size(); --i >= 0;)
|
||||
{
|
||||
SynthesiserVoice* const voice = voices.getUnchecked (i);
|
||||
|
||||
if (voice->isPlayingChannel (midiChannel))
|
||||
{
|
||||
if (isDown)
|
||||
voice->sostenutoPedalDown = true;
|
||||
else if (voice->sostenutoPedalDown)
|
||||
stopVoice (voice, 1.0f, true);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void Synthesiser::handleSoftPedal (int midiChannel, bool /*isDown*/)
|
||||
{
|
||||
(void) midiChannel;
|
||||
jassert (midiChannel > 0 && midiChannel <= 16);
|
||||
}
|
||||
|
||||
//==============================================================================
|
||||
SynthesiserVoice* Synthesiser::findFreeVoice (SynthesiserSound* soundToPlay,
|
||||
int midiChannel, int midiNoteNumber,
|
||||
const bool stealIfNoneAvailable) const
|
||||
{
|
||||
const ScopedLock sl (lock);
|
||||
|
||||
for (int i = 0; i < voices.size(); ++i)
|
||||
{
|
||||
SynthesiserVoice* const voice = voices.getUnchecked (i);
|
||||
|
||||
if ((! voice->isVoiceActive()) && voice->canPlaySound (soundToPlay))
|
||||
return voice;
|
||||
}
|
||||
|
||||
if (stealIfNoneAvailable)
|
||||
return findVoiceToSteal (soundToPlay, midiChannel, midiNoteNumber);
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
struct VoiceAgeSorter
|
||||
{
|
||||
static int compareElements (SynthesiserVoice* v1, SynthesiserVoice* v2) noexcept
|
||||
{
|
||||
return v1->wasStartedBefore (*v2) ? 1 : (v2->wasStartedBefore (*v1) ? -1 : 0);
|
||||
}
|
||||
};
|
||||
|
||||
SynthesiserVoice* Synthesiser::findVoiceToSteal (SynthesiserSound* soundToPlay,
|
||||
int /*midiChannel*/, int midiNoteNumber) const
|
||||
{
|
||||
SynthesiserVoice* bottom = nullptr;
|
||||
SynthesiserVoice* top = nullptr;
|
||||
|
||||
// this is a list of voices we can steal, sorted by how long they've been running
|
||||
Array<SynthesiserVoice*> usableVoices;
|
||||
usableVoices.ensureStorageAllocated (voices.size());
|
||||
|
||||
for (int i = 0; i < voices.size(); ++i)
|
||||
{
|
||||
SynthesiserVoice* const voice = voices.getUnchecked (i);
|
||||
|
||||
if (voice->canPlaySound (soundToPlay))
|
||||
{
|
||||
VoiceAgeSorter sorter;
|
||||
usableVoices.addSorted (sorter, voice);
|
||||
|
||||
const int note = voice->getCurrentlyPlayingNote();
|
||||
|
||||
if (bottom == nullptr || note < bottom->getCurrentlyPlayingNote())
|
||||
bottom = voice;
|
||||
|
||||
if (top == nullptr || note > top->getCurrentlyPlayingNote())
|
||||
top = voice;
|
||||
}
|
||||
}
|
||||
|
||||
jassert (bottom != nullptr && top != nullptr);
|
||||
|
||||
// The oldest note that's playing with the target pitch playing is ideal..
|
||||
for (int i = 0; i < usableVoices.size(); ++i)
|
||||
{
|
||||
SynthesiserVoice* const voice = usableVoices.getUnchecked (i);
|
||||
|
||||
if (voice->getCurrentlyPlayingNote() == midiNoteNumber)
|
||||
return voice;
|
||||
}
|
||||
|
||||
// ..otherwise, look for the oldest note that isn't the top or bottom note..
|
||||
for (int i = 0; i < usableVoices.size(); ++i)
|
||||
{
|
||||
SynthesiserVoice* const voice = usableVoices.getUnchecked (i);
|
||||
|
||||
if (voice != bottom && voice != top)
|
||||
return voice;
|
||||
}
|
||||
|
||||
// ..otherwise, there's only one or two voices to choose from - we'll return the top one..
|
||||
return top;
|
||||
}
|
||||
|
|
@ -0,0 +1,557 @@
|
|||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the JUCE library.
|
||||
Copyright (c) 2013 - Raw Material Software 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_SYNTHESISER_H_INCLUDED
|
||||
#define JUCE_SYNTHESISER_H_INCLUDED
|
||||
|
||||
|
||||
//==============================================================================
|
||||
/**
|
||||
Describes one of the sounds that a Synthesiser can play.
|
||||
|
||||
A synthesiser can contain one or more sounds, and a sound can choose which
|
||||
midi notes and channels can trigger it.
|
||||
|
||||
The SynthesiserSound is a passive class that just describes what the sound is -
|
||||
the actual audio rendering for a sound is done by a SynthesiserVoice. This allows
|
||||
more than one SynthesiserVoice to play the same sound at the same time.
|
||||
|
||||
@see Synthesiser, SynthesiserVoice
|
||||
*/
|
||||
class JUCE_API SynthesiserSound : public ReferenceCountedObject
|
||||
{
|
||||
protected:
|
||||
//==============================================================================
|
||||
SynthesiserSound();
|
||||
|
||||
public:
|
||||
/** Destructor. */
|
||||
virtual ~SynthesiserSound();
|
||||
|
||||
//==============================================================================
|
||||
/** Returns true if this sound should be played when a given midi note is pressed.
|
||||
|
||||
The Synthesiser will use this information when deciding which sounds to trigger
|
||||
for a given note.
|
||||
*/
|
||||
virtual bool appliesToNote (int midiNoteNumber) = 0;
|
||||
|
||||
/** Returns true if the sound should be triggered by midi events on a given channel.
|
||||
|
||||
The Synthesiser will use this information when deciding which sounds to trigger
|
||||
for a given note.
|
||||
*/
|
||||
virtual bool appliesToChannel (int midiChannel) = 0;
|
||||
|
||||
/** The class is reference-counted, so this is a handy pointer class for it. */
|
||||
typedef ReferenceCountedObjectPtr<SynthesiserSound> Ptr;
|
||||
|
||||
|
||||
private:
|
||||
//==============================================================================
|
||||
JUCE_LEAK_DETECTOR (SynthesiserSound)
|
||||
};
|
||||
|
||||
|
||||
//==============================================================================
|
||||
/**
|
||||
Represents a voice that a Synthesiser can use to play a SynthesiserSound.
|
||||
|
||||
A voice plays a single sound at a time, and a synthesiser holds an array of
|
||||
voices so that it can play polyphonically.
|
||||
|
||||
@see Synthesiser, SynthesiserSound
|
||||
*/
|
||||
class JUCE_API SynthesiserVoice
|
||||
{
|
||||
public:
|
||||
//==============================================================================
|
||||
/** Creates a voice. */
|
||||
SynthesiserVoice();
|
||||
|
||||
/** Destructor. */
|
||||
virtual ~SynthesiserVoice();
|
||||
|
||||
//==============================================================================
|
||||
/** Returns the midi note that this voice is currently playing.
|
||||
Returns a value less than 0 if no note is playing.
|
||||
*/
|
||||
int getCurrentlyPlayingNote() const noexcept { return currentlyPlayingNote; }
|
||||
|
||||
/** Returns the sound that this voice is currently playing.
|
||||
Returns nullptr if it's not playing.
|
||||
*/
|
||||
SynthesiserSound::Ptr getCurrentlyPlayingSound() const noexcept { return currentlyPlayingSound; }
|
||||
|
||||
/** Must return true if this voice object is capable of playing the given sound.
|
||||
|
||||
If there are different classes of sound, and different classes of voice, a voice can
|
||||
choose which ones it wants to take on.
|
||||
|
||||
A typical implementation of this method may just return true if there's only one type
|
||||
of voice and sound, or it might check the type of the sound object passed-in and
|
||||
see if it's one that it understands.
|
||||
*/
|
||||
virtual bool canPlaySound (SynthesiserSound*) = 0;
|
||||
|
||||
/** Called to start a new note.
|
||||
This will be called during the rendering callback, so must be fast and thread-safe.
|
||||
*/
|
||||
virtual void startNote (int midiNoteNumber,
|
||||
float velocity,
|
||||
SynthesiserSound* sound,
|
||||
int currentPitchWheelPosition) = 0;
|
||||
|
||||
/** Called to stop a note.
|
||||
|
||||
This will be called during the rendering callback, so must be fast and thread-safe.
|
||||
|
||||
The velocity indicates how quickly the note was released - 0 is slowly, 1 is quickly.
|
||||
|
||||
If allowTailOff is false or the voice doesn't want to tail-off, then it must stop all
|
||||
sound immediately, and must call clearCurrentNote() to reset the state of this voice
|
||||
and allow the synth to reassign it another sound.
|
||||
|
||||
If allowTailOff is true and the voice decides to do a tail-off, then it's allowed to
|
||||
begin fading out its sound, and it can stop playing until it's finished. As soon as it
|
||||
finishes playing (during the rendering callback), it must make sure that it calls
|
||||
clearCurrentNote().
|
||||
*/
|
||||
virtual void stopNote (float velocity, bool allowTailOff) = 0;
|
||||
|
||||
/** Returns true if this voice is currently busy playing a sound.
|
||||
By default this just checks the getCurrentlyPlayingNote() value, but can
|
||||
be overridden for more advanced checking.
|
||||
*/
|
||||
virtual bool isVoiceActive() const;
|
||||
|
||||
/** Called to let the voice know that the pitch wheel has been moved.
|
||||
This will be called during the rendering callback, so must be fast and thread-safe.
|
||||
*/
|
||||
virtual void pitchWheelMoved (int newPitchWheelValue) = 0;
|
||||
|
||||
/** Called to let the voice know that a midi controller has been moved.
|
||||
This will be called during the rendering callback, so must be fast and thread-safe.
|
||||
*/
|
||||
virtual void controllerMoved (int controllerNumber, int newControllerValue) = 0;
|
||||
|
||||
/** Called to let the voice know that the aftertouch has changed.
|
||||
This will be called during the rendering callback, so must be fast and thread-safe.
|
||||
*/
|
||||
virtual void aftertouchChanged (int newAftertouchValue);
|
||||
|
||||
//==============================================================================
|
||||
/** Renders the next block of data for this voice.
|
||||
|
||||
The output audio data must be added to the current contents of the buffer provided.
|
||||
Only the region of the buffer between startSample and (startSample + numSamples)
|
||||
should be altered by this method.
|
||||
|
||||
If the voice is currently silent, it should just return without doing anything.
|
||||
|
||||
If the sound that the voice is playing finishes during the course of this rendered
|
||||
block, it must call clearCurrentNote(), to tell the synthesiser that it has finished.
|
||||
|
||||
The size of the blocks that are rendered can change each time it is called, and may
|
||||
involve rendering as little as 1 sample at a time. In between rendering callbacks,
|
||||
the voice's methods will be called to tell it about note and controller events.
|
||||
*/
|
||||
virtual void renderNextBlock (AudioSampleBuffer& outputBuffer,
|
||||
int startSample,
|
||||
int numSamples) = 0;
|
||||
|
||||
/** Changes the voice's reference sample rate.
|
||||
|
||||
The rate is set so that subclasses know the output rate and can set their pitch
|
||||
accordingly.
|
||||
|
||||
This method is called by the synth, and subclasses can access the current rate with
|
||||
the currentSampleRate member.
|
||||
*/
|
||||
virtual void setCurrentPlaybackSampleRate (double newRate);
|
||||
|
||||
/** Returns the current target sample rate at which rendering is being done.
|
||||
Subclasses may need to know this so that they can pitch things correctly.
|
||||
*/
|
||||
double getSampleRate() const noexcept { return currentSampleRate; }
|
||||
|
||||
/** Returns true if the voice is currently playing a sound which is mapped to the given
|
||||
midi channel.
|
||||
|
||||
If it's not currently playing, this will return false.
|
||||
*/
|
||||
bool isPlayingChannel (int midiChannel) const;
|
||||
|
||||
/** Returns true if the key that triggered this voice is still held down.
|
||||
Note that the voice may still be playing after the key was released (e.g because the
|
||||
sostenuto pedal is down).
|
||||
*/
|
||||
bool isKeyDown() const noexcept { return keyIsDown; }
|
||||
|
||||
/** Returns true if the sostenuto pedal is currently active for this voice. */
|
||||
bool isSostenutoPedalDown() const noexcept { return sostenutoPedalDown; }
|
||||
|
||||
/** Returns true if this voice started playing its current note before the other voice did. */
|
||||
bool wasStartedBefore (const SynthesiserVoice& other) const noexcept;
|
||||
|
||||
protected:
|
||||
/** Resets the state of this voice after a sound has finished playing.
|
||||
|
||||
The subclass must call this when it finishes playing a note and becomes available
|
||||
to play new ones.
|
||||
|
||||
It must either call it in the stopNote() method, or if the voice is tailing off,
|
||||
then it should call it later during the renderNextBlock method, as soon as it
|
||||
finishes its tail-off.
|
||||
|
||||
It can also be called at any time during the render callback if the sound happens
|
||||
to have finished, e.g. if it's playing a sample and the sample finishes.
|
||||
*/
|
||||
void clearCurrentNote();
|
||||
|
||||
|
||||
private:
|
||||
//==============================================================================
|
||||
friend class Synthesiser;
|
||||
|
||||
double currentSampleRate;
|
||||
int currentlyPlayingNote;
|
||||
uint32 noteOnTime;
|
||||
SynthesiserSound::Ptr currentlyPlayingSound;
|
||||
bool keyIsDown, sostenutoPedalDown;
|
||||
|
||||
#if JUCE_CATCH_DEPRECATED_CODE_MISUSE
|
||||
// Note the new parameters for this method.
|
||||
virtual int stopNote (bool) { return 0; }
|
||||
#endif
|
||||
|
||||
JUCE_LEAK_DETECTOR (SynthesiserVoice)
|
||||
};
|
||||
|
||||
|
||||
//==============================================================================
|
||||
/**
|
||||
Base class for a musical device that can play sounds.
|
||||
|
||||
To create a synthesiser, you'll need to create a subclass of SynthesiserSound
|
||||
to describe each sound available to your synth, and a subclass of SynthesiserVoice
|
||||
which can play back one of these sounds.
|
||||
|
||||
Then you can use the addVoice() and addSound() methods to give the synthesiser a
|
||||
set of sounds, and a set of voices it can use to play them. If you only give it
|
||||
one voice it will be monophonic - the more voices it has, the more polyphony it'll
|
||||
have available.
|
||||
|
||||
Then repeatedly call the renderNextBlock() method to produce the audio. Any midi
|
||||
events that go in will be scanned for note on/off messages, and these are used to
|
||||
start and stop the voices playing the appropriate sounds.
|
||||
|
||||
While it's playing, you can also cause notes to be triggered by calling the noteOn(),
|
||||
noteOff() and other controller methods.
|
||||
|
||||
Before rendering, be sure to call the setCurrentPlaybackSampleRate() to tell it
|
||||
what the target playback rate is. This value is passed on to the voices so that
|
||||
they can pitch their output correctly.
|
||||
*/
|
||||
class JUCE_API Synthesiser
|
||||
{
|
||||
public:
|
||||
//==============================================================================
|
||||
/** Creates a new synthesiser.
|
||||
You'll need to add some sounds and voices before it'll make any sound.
|
||||
*/
|
||||
Synthesiser();
|
||||
|
||||
/** Destructor. */
|
||||
virtual ~Synthesiser();
|
||||
|
||||
//==============================================================================
|
||||
/** Deletes all voices. */
|
||||
void clearVoices();
|
||||
|
||||
/** Returns the number of voices that have been added. */
|
||||
int getNumVoices() const noexcept { return voices.size(); }
|
||||
|
||||
/** Returns one of the voices that have been added. */
|
||||
SynthesiserVoice* getVoice (int index) const;
|
||||
|
||||
/** Adds a new voice to the synth.
|
||||
|
||||
All the voices should be the same class of object and are treated equally.
|
||||
|
||||
The object passed in will be managed by the synthesiser, which will delete
|
||||
it later on when no longer needed. The caller should not retain a pointer to the
|
||||
voice.
|
||||
*/
|
||||
SynthesiserVoice* addVoice (SynthesiserVoice* newVoice);
|
||||
|
||||
/** Deletes one of the voices. */
|
||||
void removeVoice (int index);
|
||||
|
||||
//==============================================================================
|
||||
/** Deletes all sounds. */
|
||||
void clearSounds();
|
||||
|
||||
/** Returns the number of sounds that have been added to the synth. */
|
||||
int getNumSounds() const noexcept { return sounds.size(); }
|
||||
|
||||
/** Returns one of the sounds. */
|
||||
SynthesiserSound* getSound (int index) const noexcept { return sounds [index]; }
|
||||
|
||||
/** Adds a new sound to the synthesiser.
|
||||
|
||||
The object passed in is reference counted, so will be deleted when the
|
||||
synthesiser and all voices are no longer using it.
|
||||
*/
|
||||
SynthesiserSound* addSound (const SynthesiserSound::Ptr& newSound);
|
||||
|
||||
/** Removes and deletes one of the sounds. */
|
||||
void removeSound (int index);
|
||||
|
||||
//==============================================================================
|
||||
/** If set to true, then the synth will try to take over an existing voice if
|
||||
it runs out and needs to play another note.
|
||||
|
||||
The value of this boolean is passed into findFreeVoice(), so the result will
|
||||
depend on the implementation of this method.
|
||||
*/
|
||||
void setNoteStealingEnabled (bool shouldStealNotes);
|
||||
|
||||
/** Returns true if note-stealing is enabled.
|
||||
@see setNoteStealingEnabled
|
||||
*/
|
||||
bool isNoteStealingEnabled() const noexcept { return shouldStealNotes; }
|
||||
|
||||
//==============================================================================
|
||||
/** Triggers a note-on event.
|
||||
|
||||
The default method here will find all the sounds that want to be triggered by
|
||||
this note/channel. For each sound, it'll try to find a free voice, and use the
|
||||
voice to start playing the sound.
|
||||
|
||||
Subclasses might want to override this if they need a more complex algorithm.
|
||||
|
||||
This method will be called automatically according to the midi data passed into
|
||||
renderNextBlock(), but may be called explicitly too.
|
||||
|
||||
The midiChannel parameter is the channel, between 1 and 16 inclusive.
|
||||
*/
|
||||
virtual void noteOn (int midiChannel,
|
||||
int midiNoteNumber,
|
||||
float velocity);
|
||||
|
||||
/** Triggers a note-off event.
|
||||
|
||||
This will turn off any voices that are playing a sound for the given note/channel.
|
||||
|
||||
If allowTailOff is true, the voices will be allowed to fade out the notes gracefully
|
||||
(if they can do). If this is false, the notes will all be cut off immediately.
|
||||
|
||||
This method will be called automatically according to the midi data passed into
|
||||
renderNextBlock(), but may be called explicitly too.
|
||||
|
||||
The midiChannel parameter is the channel, between 1 and 16 inclusive.
|
||||
*/
|
||||
virtual void noteOff (int midiChannel,
|
||||
int midiNoteNumber,
|
||||
float velocity,
|
||||
bool allowTailOff);
|
||||
|
||||
/** Turns off all notes.
|
||||
|
||||
This will turn off any voices that are playing a sound on the given midi channel.
|
||||
|
||||
If midiChannel is 0 or less, then all voices will be turned off, regardless of
|
||||
which channel they're playing. Otherwise it represents a valid midi channel, from
|
||||
1 to 16 inclusive.
|
||||
|
||||
If allowTailOff is true, the voices will be allowed to fade out the notes gracefully
|
||||
(if they can do). If this is false, the notes will all be cut off immediately.
|
||||
|
||||
This method will be called automatically according to the midi data passed into
|
||||
renderNextBlock(), but may be called explicitly too.
|
||||
*/
|
||||
virtual void allNotesOff (int midiChannel,
|
||||
bool allowTailOff);
|
||||
|
||||
/** Sends a pitch-wheel message to any active voices.
|
||||
|
||||
This will send a pitch-wheel message to any voices that are playing sounds on
|
||||
the given midi channel.
|
||||
|
||||
This method will be called automatically according to the midi data passed into
|
||||
renderNextBlock(), but may be called explicitly too.
|
||||
|
||||
@param midiChannel the midi channel, from 1 to 16 inclusive
|
||||
@param wheelValue the wheel position, from 0 to 0x3fff, as returned by MidiMessage::getPitchWheelValue()
|
||||
*/
|
||||
virtual void handlePitchWheel (int midiChannel,
|
||||
int wheelValue);
|
||||
|
||||
/** Sends a midi controller message to any active voices.
|
||||
|
||||
This will send a midi controller message to any voices that are playing sounds on
|
||||
the given midi channel.
|
||||
|
||||
This method will be called automatically according to the midi data passed into
|
||||
renderNextBlock(), but may be called explicitly too.
|
||||
|
||||
@param midiChannel the midi channel, from 1 to 16 inclusive
|
||||
@param controllerNumber the midi controller type, as returned by MidiMessage::getControllerNumber()
|
||||
@param controllerValue the midi controller value, between 0 and 127, as returned by MidiMessage::getControllerValue()
|
||||
*/
|
||||
virtual void handleController (int midiChannel,
|
||||
int controllerNumber,
|
||||
int controllerValue);
|
||||
|
||||
/** Sends an aftertouch message.
|
||||
|
||||
This will send an aftertouch message to any voices that are playing sounds on
|
||||
the given midi channel and note number.
|
||||
|
||||
This method will be called automatically according to the midi data passed into
|
||||
renderNextBlock(), but may be called explicitly too.
|
||||
|
||||
@param midiChannel the midi channel, from 1 to 16 inclusive
|
||||
@param midiNoteNumber the midi note number, 0 to 127
|
||||
@param aftertouchValue the aftertouch value, between 0 and 127,
|
||||
as returned by MidiMessage::getAftertouchValue()
|
||||
*/
|
||||
virtual void handleAftertouch (int midiChannel, int midiNoteNumber, int aftertouchValue);
|
||||
|
||||
/** Handles a sustain pedal event. */
|
||||
virtual void handleSustainPedal (int midiChannel, bool isDown);
|
||||
|
||||
/** Handles a sostenuto pedal event. */
|
||||
virtual void handleSostenutoPedal (int midiChannel, bool isDown);
|
||||
|
||||
/** Can be overridden to handle soft pedal events. */
|
||||
virtual void handleSoftPedal (int midiChannel, bool isDown);
|
||||
|
||||
//==============================================================================
|
||||
/** Tells the synthesiser what the sample rate is for the audio it's being used to render.
|
||||
|
||||
This value is propagated to the voices so that they can use it to render the correct
|
||||
pitches.
|
||||
*/
|
||||
virtual void setCurrentPlaybackSampleRate (double sampleRate);
|
||||
|
||||
/** Creates the next block of audio output.
|
||||
|
||||
This will process the next numSamples of data from all the voices, and add that output
|
||||
to the audio block supplied, starting from the offset specified. Note that the
|
||||
data will be added to the current contents of the buffer, so you should clear it
|
||||
before calling this method if necessary.
|
||||
|
||||
The midi events in the inputMidi buffer are parsed for note and controller events,
|
||||
and these are used to trigger the voices. Note that the startSample offset applies
|
||||
both to the audio output buffer and the midi input buffer, so any midi events
|
||||
with timestamps outside the specified region will be ignored.
|
||||
*/
|
||||
void renderNextBlock (AudioSampleBuffer& outputAudio,
|
||||
const MidiBuffer& inputMidi,
|
||||
int startSample,
|
||||
int numSamples);
|
||||
|
||||
/** Returns the current target sample rate at which rendering is being done.
|
||||
Subclasses may need to know this so that they can pitch things correctly.
|
||||
*/
|
||||
double getSampleRate() const noexcept { return sampleRate; }
|
||||
|
||||
protected:
|
||||
//==============================================================================
|
||||
/** This is used to control access to the rendering callback and the note trigger methods. */
|
||||
CriticalSection lock;
|
||||
|
||||
OwnedArray<SynthesiserVoice> voices;
|
||||
ReferenceCountedArray<SynthesiserSound> sounds;
|
||||
|
||||
/** The last pitch-wheel values for each midi channel. */
|
||||
int lastPitchWheelValues [16];
|
||||
|
||||
/** Renders the voices for the given range.
|
||||
By default this just calls renderNextBlock() on each voice, but you may need
|
||||
to override it to handle custom cases.
|
||||
*/
|
||||
virtual void renderVoices (AudioSampleBuffer& outputAudio,
|
||||
int startSample, int numSamples);
|
||||
|
||||
/** Searches through the voices to find one that's not currently playing, and
|
||||
which can play the given sound.
|
||||
|
||||
Returns nullptr if all voices are busy and stealing isn't enabled.
|
||||
|
||||
To implement a custom note-stealing algorithm, you can either override this
|
||||
method, or (preferably) override findVoiceToSteal().
|
||||
*/
|
||||
virtual SynthesiserVoice* findFreeVoice (SynthesiserSound* soundToPlay,
|
||||
int midiChannel,
|
||||
int midiNoteNumber,
|
||||
bool stealIfNoneAvailable) const;
|
||||
|
||||
/** Chooses a voice that is most suitable for being re-used.
|
||||
The default method will attempt to find the oldest voice that isn't the
|
||||
bottom or top note being played. If that's not suitable for your synth,
|
||||
you can override this method and do something more cunning instead.
|
||||
*/
|
||||
virtual SynthesiserVoice* findVoiceToSteal (SynthesiserSound* soundToPlay,
|
||||
int midiChannel,
|
||||
int midiNoteNumber) const;
|
||||
|
||||
/** Starts a specified voice playing a particular sound.
|
||||
|
||||
You'll probably never need to call this, it's used internally by noteOn(), but
|
||||
may be needed by subclasses for custom behaviours.
|
||||
*/
|
||||
void startVoice (SynthesiserVoice* voice,
|
||||
SynthesiserSound* sound,
|
||||
int midiChannel,
|
||||
int midiNoteNumber,
|
||||
float velocity);
|
||||
|
||||
/** Can be overridden to do custom handling of incoming midi events. */
|
||||
virtual void handleMidiEvent (const MidiMessage&);
|
||||
|
||||
private:
|
||||
//==============================================================================
|
||||
double sampleRate;
|
||||
uint32 lastNoteOnCounter;
|
||||
bool shouldStealNotes;
|
||||
BigInteger sustainPedalsDown;
|
||||
|
||||
void stopVoice (SynthesiserVoice*, float velocity, bool allowTailOff);
|
||||
|
||||
#if JUCE_CATCH_DEPRECATED_CODE_MISUSE
|
||||
// Note the new parameters for these methods.
|
||||
virtual int findFreeVoice (const bool) const { return 0; }
|
||||
virtual int noteOff (int, int, int) { return 0; }
|
||||
virtual int findFreeVoice (SynthesiserSound*, const bool) { return 0; }
|
||||
virtual int findVoiceToSteal (SynthesiserSound*) const { return 0; }
|
||||
#endif
|
||||
|
||||
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (Synthesiser)
|
||||
};
|
||||
|
||||
|
||||
#endif // JUCE_SYNTHESISER_H_INCLUDED
|
||||
Loading…
Add table
Add a link
Reference in a new issue