juce/source/src/audio/synthesisers/juce_Synthesiser.cpp

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library - "Jules' Utility Class Extensions"
   5    Copyright 2004-11 by Raw Material Software Ltd.
   6
   7   ------------------------------------------------------------------------------
   8
   9    JUCE can be redistributed and/or modified under the terms of the GNU General
  10    Public License (Version 2), as published by the Free Software Foundation.
  11    A copy of the license is included in the JUCE distribution, or can be found
  12    online at www.gnu.org/licenses.
  13
  14    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
  15    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  16    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  17
  18   ------------------------------------------------------------------------------
  19
  20    To release a closed-source product which uses JUCE, commercial licenses are
  21    available: visit www.rawmaterialsoftware.com/juce for more information.
  22
  23   ==============================================================================
  24 */
  25
  26 #include "../../core/juce_StandardHeader.h"
  27
  28 BEGIN_JUCE_NAMESPACE
  29
  30 #include "juce_Synthesiser.h"
  31
  32
  33 //==============================================================================
  34 SynthesiserSound::SynthesiserSound()
  35 {
  36 }
  37
  38 SynthesiserSound::~SynthesiserSound()
  39 {
  40 }
  41
  42 //==============================================================================
  43 SynthesiserVoice::SynthesiserVoice()
  44     : currentSampleRate (44100.0),
  45       currentlyPlayingNote (-1),
  46       noteOnTime (0),
  47       keyIsDown (false),
  48       sostenutoPedalDown (false)
  49 {
  50 }
  51
  52 SynthesiserVoice::~SynthesiserVoice()
  53 {
  54 }
  55
  56 bool SynthesiserVoice::isPlayingChannel (const int midiChannel) const
  57 {
  58     return currentlyPlayingSound != nullptr
  59             && currentlyPlayingSound->appliesToChannel (midiChannel);
  60 }
  61
  62 void SynthesiserVoice::setCurrentPlaybackSampleRate (const double newRate)
  63 {
  64     currentSampleRate = newRate;
  65 }
  66
  67 void SynthesiserVoice::clearCurrentNote()
  68 {
  69     currentlyPlayingNote = -1;
  70     currentlyPlayingSound = nullptr;
  71 }
  72
  73 //==============================================================================
  74 Synthesiser::Synthesiser()
  75     : sampleRate (0),
  76       lastNoteOnCounter (0),
  77       shouldStealNotes (true)
  78 {
  79     for (int i = 0; i < numElementsInArray (lastPitchWheelValues); ++i)
  80         lastPitchWheelValues[i] = 0x2000;
  81 }
  82
  83 Synthesiser::~Synthesiser()
  84 {
  85 }
  86
  87 //==============================================================================
  88 SynthesiserVoice* Synthesiser::getVoice (const int index) const
  89 {
  90     const ScopedLock sl (lock);
  91     return voices [index];
  92 }
  93
  94 void Synthesiser::clearVoices()
  95 {
  96     const ScopedLock sl (lock);
  97     voices.clear();
  98 }
  99
 100 void Synthesiser::addVoice (SynthesiserVoice* const newVoice)
 101 {
 102     const ScopedLock sl (lock);
 103     voices.add (newVoice);
 104 }
 105
 106 void Synthesiser::removeVoice (const int index)
 107 {
 108     const ScopedLock sl (lock);
 109     voices.remove (index);
 110 }
 111
 112 void Synthesiser::clearSounds()
 113 {
 114     const ScopedLock sl (lock);
 115     sounds.clear();
 116 }
 117
 118 void Synthesiser::addSound (const SynthesiserSound::Ptr& newSound)
 119 {
 120     const ScopedLock sl (lock);
 121     sounds.add (newSound);
 122 }
 123
 124 void Synthesiser::removeSound (const int index)
 125 {
 126     const ScopedLock sl (lock);
 127     sounds.remove (index);
 128 }
 129
 130 void Synthesiser::setNoteStealingEnabled (const bool shouldStealNotes_)
 131 {
 132     shouldStealNotes = shouldStealNotes_;
 133 }
 134
 135 //==============================================================================
 136 void Synthesiser::setCurrentPlaybackSampleRate (const double newRate)
 137 {
 138     if (sampleRate != newRate)
 139     {
 140         const ScopedLock sl (lock);
 141
 142         allNotesOff (0, false);
 143
 144         sampleRate = newRate;
 145
 146         for (int i = voices.size(); --i >= 0;)
 147             voices.getUnchecked (i)->setCurrentPlaybackSampleRate (newRate);
 148     }
 149 }
 150
 151 void Synthesiser::renderNextBlock (AudioSampleBuffer& outputBuffer,
 152                                    const MidiBuffer& midiData,
 153                                    int startSample,
 154                                    int numSamples)
 155 {
 156     // must set the sample rate before using this!
 157     jassert (sampleRate != 0);
 158
 159     const ScopedLock sl (lock);
 160
 161     MidiBuffer::Iterator midiIterator (midiData);
 162     midiIterator.setNextSamplePosition (startSample);
 163     MidiMessage m (0xf4, 0.0);
 164
 165     while (numSamples > 0)
 166     {
 167         int midiEventPos;
 168         const bool useEvent = midiIterator.getNextEvent (m, midiEventPos)
 169                                 && midiEventPos < startSample + numSamples;
 170
 171         const int numThisTime = useEvent ? midiEventPos - startSample
 172                                          : numSamples;
 173
 174         if (numThisTime > 0)
 175         {
 176             for (int i = voices.size(); --i >= 0;)
 177                 voices.getUnchecked (i)->renderNextBlock (outputBuffer, startSample, numThisTime);
 178         }
 179
 180         if (useEvent)
 181             handleMidiEvent (m);
 182
 183         startSample += numThisTime;
 184         numSamples -= numThisTime;
 185     }
 186 }
 187
 188 void Synthesiser::handleMidiEvent (const MidiMessage& m)
 189 {
 190     if (m.isNoteOn())
 191     {
 192         noteOn (m.getChannel(),
 193                 m.getNoteNumber(),
 194                 m.getFloatVelocity());
 195     }
 196     else if (m.isNoteOff())
 197     {
 198         noteOff (m.getChannel(),
 199                  m.getNoteNumber(),
 200                  true);
 201     }
 202     else if (m.isAllNotesOff() || m.isAllSoundOff())
 203     {
 204         allNotesOff (m.getChannel(), true);
 205     }
 206     else if (m.isPitchWheel())
 207     {
 208         const int channel = m.getChannel();
 209         const int wheelPos = m.getPitchWheelValue();
 210         lastPitchWheelValues [channel - 1] = wheelPos;
 211
 212         handlePitchWheel (channel, wheelPos);
 213     }
 214     else if (m.isController())
 215     {
 216         handleController (m.getChannel(),
 217                           m.getControllerNumber(),
 218                           m.getControllerValue());
 219     }
 220 }
 221
 222 //==============================================================================
 223 void Synthesiser::noteOn (const int midiChannel,
 224                           const int midiNoteNumber,
 225                           const float velocity)
 226 {
 227     const ScopedLock sl (lock);
 228
 229     for (int i = sounds.size(); --i >= 0;)
 230     {
 231         SynthesiserSound* const sound = sounds.getUnchecked(i);
 232
 233         if (sound->appliesToNote (midiNoteNumber)
 234              && sound->appliesToChannel (midiChannel))
 235         {
 236             // If hitting a note that's still ringing, stop it first (it could be
 237             // still playing because of the sustain or sostenuto pedal).
 238             for (int j = voices.size(); --j >= 0;)
 239             {
 240                 SynthesiserVoice* const voice = voices.getUnchecked (j);
 241
 242                 if (voice->getCurrentlyPlayingNote() == midiNoteNumber
 243                      && voice->isPlayingChannel (midiChannel))
 244                     stopVoice (voice, true);
 245             }
 246
 247             startVoice (findFreeVoice (sound, shouldStealNotes),
 248                         sound, midiChannel, midiNoteNumber, velocity);
 249         }
 250     }
 251 }
 252
 253 void Synthesiser::startVoice (SynthesiserVoice* const voice,
 254                               SynthesiserSound* const sound,
 255                               const int midiChannel,
 256                               const int midiNoteNumber,
 257                               const float velocity)
 258 {
 259     if (voice != nullptr && sound != nullptr)
 260     {
 261         if (voice->currentlyPlayingSound != nullptr)
 262             voice->stopNote (false);
 263
 264         voice->startNote (midiNoteNumber, velocity, sound,
 265                           lastPitchWheelValues [midiChannel - 1]);
 266
 267         voice->currentlyPlayingNote = midiNoteNumber;
 268         voice->noteOnTime = ++lastNoteOnCounter;
 269         voice->currentlyPlayingSound = sound;
 270         voice->keyIsDown = true;
 271         voice->sostenutoPedalDown = false;
 272     }
 273 }
 274
 275 void Synthesiser::stopVoice (SynthesiserVoice* voice, const bool allowTailOff)
 276 {
 277     jassert (voice != nullptr);
 278
 279     voice->stopNote (allowTailOff);
 280
 281     // the subclass MUST call clearCurrentNote() if it's not tailing off! RTFM for stopNote()!
 282     jassert (allowTailOff || (voice->getCurrentlyPlayingNote() < 0 && voice->getCurrentlyPlayingSound() == 0));
 283 }
 284
 285 void Synthesiser::noteOff (const int midiChannel,
 286                            const int midiNoteNumber,
 287                            const bool allowTailOff)
 288 {
 289     const ScopedLock sl (lock);
 290
 291     for (int i = voices.size(); --i >= 0;)
 292     {
 293         SynthesiserVoice* const voice = voices.getUnchecked (i);
 294
 295         if (voice->getCurrentlyPlayingNote() == midiNoteNumber)
 296         {
 297             SynthesiserSound* const sound = voice->getCurrentlyPlayingSound();
 298
 299             if (sound != nullptr
 300                  && sound->appliesToNote (midiNoteNumber)
 301                  && sound->appliesToChannel (midiChannel))
 302             {
 303                 voice->keyIsDown = false;
 304
 305                 if (! (sustainPedalsDown [midiChannel] || voice->sostenutoPedalDown))
 306                     stopVoice (voice, allowTailOff);
 307             }
 308         }
 309     }
 310 }
 311
 312 void Synthesiser::allNotesOff (const int midiChannel, const bool allowTailOff)
 313 {
 314     const ScopedLock sl (lock);
 315
 316     for (int i = voices.size(); --i >= 0;)
 317     {
 318         SynthesiserVoice* const voice = voices.getUnchecked (i);
 319
 320         if (midiChannel <= 0 || voice->isPlayingChannel (midiChannel))
 321             voice->stopNote (allowTailOff);
 322     }
 323
 324     sustainPedalsDown.clear();
 325 }
 326
 327 void Synthesiser::handlePitchWheel (const int midiChannel, const int wheelValue)
 328 {
 329     const ScopedLock sl (lock);
 330
 331     for (int i = voices.size(); --i >= 0;)
 332     {
 333         SynthesiserVoice* const voice = voices.getUnchecked (i);
 334
 335         if (midiChannel <= 0 || voice->isPlayingChannel (midiChannel))
 336             voice->pitchWheelMoved (wheelValue);
 337     }
 338 }
 339
 340 void Synthesiser::handleController (const int midiChannel,
 341                                     const int controllerNumber,
 342                                     const int controllerValue)
 343 {
 344     switch (controllerNumber)
 345     {
 346         case 0x40:  handleSustainPedal   (midiChannel, controllerValue >= 64); break;
 347         case 0x42:  handleSostenutoPedal (midiChannel, controllerValue >= 64); break;
 348         case 0x43:  handleSoftPedal      (midiChannel, controllerValue >= 64); break;
 349         default:    break;
 350     }
 351
 352     const ScopedLock sl (lock);
 353
 354     for (int i = voices.size(); --i >= 0;)
 355     {
 356         SynthesiserVoice* const voice = voices.getUnchecked (i);
 357
 358         if (midiChannel <= 0 || voice->isPlayingChannel (midiChannel))
 359             voice->controllerMoved (controllerNumber, controllerValue);
 360     }
 361 }
 362
 363 void Synthesiser::handleSustainPedal (int midiChannel, bool isDown)
 364 {
 365     jassert (midiChannel > 0 && midiChannel <= 16);
 366     const ScopedLock sl (lock);
 367
 368     if (isDown)
 369     {
 370         sustainPedalsDown.setBit (midiChannel);
 371     }
 372     else
 373     {
 374         for (int i = voices.size(); --i >= 0;)
 375         {
 376             SynthesiserVoice* const voice = voices.getUnchecked (i);
 377
 378             if (voice->isPlayingChannel (midiChannel) && ! voice->keyIsDown)
 379                 stopVoice (voice, true);
 380         }
 381
 382         sustainPedalsDown.clearBit (midiChannel);
 383     }
 384 }
 385
 386 void Synthesiser::handleSostenutoPedal (int midiChannel, bool isDown)
 387 {
 388     jassert (midiChannel > 0 && midiChannel <= 16);
 389     const ScopedLock sl (lock);
 390
 391     for (int i = voices.size(); --i >= 0;)
 392     {
 393         SynthesiserVoice* const voice = voices.getUnchecked (i);
 394
 395         if (voice->isPlayingChannel (midiChannel))
 396         {
 397             if (isDown)
 398                 voice->sostenutoPedalDown = true;
 399             else if (voice->sostenutoPedalDown)
 400                 stopVoice (voice, true);
 401         }
 402     }
 403 }
 404
 405 void Synthesiser::handleSoftPedal (int midiChannel, bool /*isDown*/)
 406 {
 407     (void) midiChannel;
 408     jassert (midiChannel > 0 && midiChannel <= 16);
 409 }
 410
 411 //==============================================================================
 412 SynthesiserVoice* Synthesiser::findFreeVoice (SynthesiserSound* soundToPlay,
 413                                               const bool stealIfNoneAvailable) const
 414 {
 415     const ScopedLock sl (lock);
 416
 417     for (int i = voices.size(); --i >= 0;)
 418         if (voices.getUnchecked (i)->getCurrentlyPlayingNote() < 0
 419              && voices.getUnchecked (i)->canPlaySound (soundToPlay))
 420             return voices.getUnchecked (i);
 421
 422     if (stealIfNoneAvailable)
 423     {
 424         // currently this just steals the one that's been playing the longest, but could be made a bit smarter..
 425         SynthesiserVoice* oldest = nullptr;
 426
 427         for (int i = voices.size(); --i >= 0;)
 428         {
 429             SynthesiserVoice* const voice = voices.getUnchecked (i);
 430
 431             if (voice->canPlaySound (soundToPlay)
 432                  && (oldest == nullptr || oldest->noteOnTime > voice->noteOnTime))
 433                 oldest = voice;
 434         }
 435
 436         jassert (oldest != nullptr);
 437         return oldest;
 438     }
 439
 440     return nullptr;
 441 }
 442
 443
 444 END_JUCE_NAMESPACE