fix #266 polysynth voice count and indexing

Author: therewasaguy

src/polysynth.js

@@ -6,18 +6,19 @@ define(function (require) {
   var TimelineSignal = require('Tone/signal/TimelineSignal');
   require('sndcore');
 
+
   /**
     *  An AudioVoice is used as a single voice for sound synthesis.
     *  The PolySynth class holds an array of AudioVoice, and deals
     *  with voices allocations, with setting notes to be played, and
-    *  parameters to be set. 
+    *  parameters to be set.
     *
     *  @class p5.PolySynth
     *  @constructor
-    *  
+    *
     *  @param {Number} [synthVoice]   A monophonic synth voice inheriting
     *                                 the AudioVoice class. Defaults to p5.MonoSynth
-    *  @param {Number} [polyValue] Number of voices, defaults to 8;
+    *  @param {Number} [maxVoices] Number of voices, defaults to 8;
     *
     *
     *  @example
@@ -32,19 +33,19 @@ define(function (require) {
     *    polysynth.play(74,1,0,3);
     *  }
     *  </code></div>
-    *  
+    *
     **/
-  p5.PolySynth = function(audioVoice, polyValue) {
-    //audiovoices will contain polyValue many monophonic synths
+  p5.PolySynth = function(audioVoice, maxVoices) {
+    //audiovoices will contain maxVoices many monophonic synths
     this.audiovoices = [];
 
     /**
-     * An object that holds information about which notes have been played and 
+     * An object that holds information about which notes have been played and
      * which notes are currently being played. New notes are added as keys
      * on the fly. While a note has been attacked, but not released, the value of the
      * key is the audiovoice which is generating that note. When notes are released,
-     * the value of the key becomes undefined. 
-     * @property notes 
+     * the value of the key becomes undefined.
+     * @property notes
      */
     this.notes = {};
 
@@ -56,7 +57,7 @@ define(function (require) {
      * A PolySynth must have at least 1 voice, defaults to 8
      * @property polyvalue
      */
-    this.polyValue = polyValue || 8;
+    this.maxVoices = maxVoices || 8;
 
     /**
      * Monosynth that generates the sound for each note that is triggered. The
@@ -87,7 +88,7 @@ define(function (require) {
    * @method  _allocateVoices
    */
   p5.PolySynth.prototype._allocateVoices = function() {
-    for(var i = 0; i< this.polyValue; i++) {
+    for(var i = 0; i< this.maxVoices; i++) {
       this.audiovoices.push(new this.AudioVoice());
       this.audiovoices[i].disconnect();
       this.audiovoices[i].connect(this.output);
@@ -96,7 +97,7 @@ define(function (require) {
 
   /**
    *  Play a note by triggering noteAttack and noteRelease with sustain time
-   *  
+   *
    *  @method  play
    *  @param  {Number} [note] midi note to play (ranging from 0 to 127 - 60 being a middle C)
    *  @param  {Number} [velocity] velocity of the note to play (ranging from 0 to 1)
@@ -110,12 +111,12 @@ define(function (require) {
   };
 
 
-  /** 
+  /**
    *  noteADSR sets the envelope for a specific note that has just been triggered.
    *  Using this method modifies the envelope of whichever audiovoice is being used
    *  to play the desired note. The envelope should be reset before noteRelease is called
    *  in order to prevent the modified envelope from being used on other notes.
-   *  
+   *
    *  @method  noteADSR
    *  @param {Number} [note]        Midi note on which ADSR should be set.
    *  @param {Number} [attackTime]  Time (in seconds before envelope
@@ -141,10 +142,10 @@ define(function (require) {
   };
 
 
-  /** 
+  /**
    * Set the PolySynths global envelope. This method modifies the envelopes of each
    * monosynth so that all notes are played with this envelope.
-   *  
+   *
    *  @method  setADSR
    *  @param {Number} [note]        Midi note on which ADSR should be set.
    *  @param {Number} [attackTime]  Time (in seconds before envelope
@@ -170,14 +171,14 @@ define(function (require) {
   /**
    *  Trigger the Attack, and Decay portion of a MonoSynth.
    *  Similar to holding down a key on a piano, but it will
-   *  hold the sustain level until you let go. 
+   *  hold the sustain level until you let go.
    *
    *  @method  noteAttack
    *  @param  {Number} [note]           midi note on which attack should be triggered.
    *  @param  {Number} [velocity]       velocity of the note to play (ranging from 0 to 1)/
    *  @param  {Number} [secondsFromNow] time from now (in seconds)
-   *  
-   */  
+   *
+   */
   p5.PolySynth.prototype.noteAttack = function (_note, _velocity, secondsFromNow) {
     var now =  p5sound.audiocontext.currentTime;
 
@@ -201,8 +202,8 @@ define(function (require) {
     }
 
     //Check to see how many voices are in use at the time the note will start
-    if(this._voicesInUse.getValueAtTime(t) < this.polyValue) {
-      currentVoice = this._voicesInUse.getValueAtTime(t);
+    if(this._voicesInUse.getValueAtTime(t) < this.maxVoices) {
+      currentVoice = Math.max(~~this._voicesInUse.getValueAtTime(t), 0);
     }
     //If we are exceeding the polyvalue, bump off the oldest notes and replace
     //with a new note
@@ -211,12 +212,11 @@ define(function (require) {
 
       var oldestNote = p5.prototype.freqToMidi(this.audiovoices[this._oldest].oscillator.freq().value);
       this.noteRelease(oldestNote);
-      this._oldest = ( this._oldest + 1 ) % (this.polyValue - 1);
+      this._oldest = ( this._oldest + 1 ) % (this.maxVoices - 1);
     }
 
-    //Overrite the entry in the notes object. A note (frequency value) 
+    //Overrite the entry in the notes object. A note (frequency value)
     //corresponds to the index of the audiovoice that is playing it
-
     this.notes[note] = new TimelineSignal();
     this.notes[note].setValueAtTime(currentVoice,t);
 
@@ -229,7 +229,6 @@ define(function (require) {
     this._updateAfter(t, 1);
 
     this._newest = currentVoice;
-
     //The audiovoice handles the actual scheduling of the note
     if (typeof velocity === 'number') {
       var maxRange = 1 / this._voicesInUse.getValueAtTime(t) * 2;
@@ -241,7 +240,7 @@ define(function (require) {
   /**
    * Private method to ensure accurate values of this._voicesInUse
    * Any time a new value is scheduled, it is necessary to increment all subsequent
-   * scheduledValues after attack, and decrement all subsequent 
+   * scheduledValues after attack, and decrement all subsequent
    * scheduledValues after release
    *
    * @private
@@ -250,7 +249,6 @@ define(function (require) {
    * @return {[type]}       [description]
    */
   p5.PolySynth.prototype._updateAfter = function(time, value) {
-
     if(this._voicesInUse._searchAfter(time) === null) {
       return;
     } else{
@@ -265,12 +263,12 @@ define(function (require) {
    *  Trigger the Release of an AudioVoice note. This is similar to releasing
    *  the key on a piano and letting the sound fade according to the
    *  release level and release time.
-   *  
+   *
    *  @method  noteRelease
    *  @param  {Number} [note]           midi note on which attack should be triggered.
    *  @param  {Number} [secondsFromNow] time to trigger the release
-   *  
-   */  
+   *
+   */
 
   p5.PolySynth.prototype.noteRelease = function (_note,secondsFromNow) {
     //Make sure note is in frequency inorder to query the this.notes object
@@ -281,24 +279,25 @@ define(function (require) {
       var tFromNow = secondsFromNow || 0;
       var t = now + tFromNow;
 
-    
+
     if (this.notes[note].getValueAtTime(t) === null) {
       console.warn('Cannot release a note that is not already playing');
     } else {
-      
+
 
       //Find the scheduled change in this._voicesInUse that will be previous to this new note
       //subtract 1 and schedule this value at time 't', when this note will stop playing
-      var previousVal = this._voicesInUse._searchBefore(t) === null ? 0 : this._voicesInUse._searchBefore(t).value;
+      var previousVal = Math.max(~~this._voicesInUse.getValueAtTime(t).value, 1);
       this._voicesInUse.setValueAtTime(previousVal - 1, t);
-      //Then update all scheduled values that follow to decrease by 1
-      this._updateAfter(t, -1);
+      //Then update all scheduled values that follow to decrease by 1 but never go below 0
+      if (previousVal > 0) {
+        this._updateAfter(t, -1);
+      }
 
       this.audiovoices[ this.notes[note].getValueAtTime(t) ].triggerRelease(tFromNow);
-      
       this.notes[note].setValueAtTime( null, t);
 
-      this._newest = this._newest === 0 ? 0 : (this._newest - 1) % (this.polyValue - 1);
+      this._newest = this._newest === 0 ? 0 : (this._newest - 1) % (this.maxVoices - 1);
     }
 
   };