diff --git a/lib/p5.sound.js b/lib/p5.sound.js index 8580643c..a67eba88 100644 --- a/lib/p5.sound.js +++ b/lib/p5.sound.js @@ -1,4 +1,4 @@ -/** [p5.sound] Version: 0.3.12 - 2020-01-06 */ +/** [p5.sound] Version: 0.3.12 - 2020-03-27 */ /** *

p5.sound extends p5 with Web Audio functionality including audio input, @@ -242,7 +242,7 @@ var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__; }), (function(module, exports, __webpack_require__) { -var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(0),__webpack_require__(5),__webpack_require__(8),__webpack_require__(22),__webpack_require__(9)], __WEBPACK_AMD_DEFINE_RESULT__ = (function(n){"use strict";return n.Signal=function(){var t=this.optionsObject(arguments,["value","units"],n.Signal.defaults);this.output=this._gain=this.context.createGain(),t.param=this._gain.gain,n.Param.call(this,t),this.input=this._param=this._gain.gain,this.context.getConstant(1).chain(this._gain)},n.extend(n.Signal,n.Param),n.Signal.defaults={value:0,units:n.Type.Default,convert:!0},n.Signal.prototype.connect=n.SignalBase.prototype.connect,n.Signal.prototype.dispose=function(){return n.Param.prototype.dispose.call(this),this._param=null,this._gain.disconnect(),this._gain=null,this},n.Signal}).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), +var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(0),__webpack_require__(6),__webpack_require__(8),__webpack_require__(22),__webpack_require__(9)], __WEBPACK_AMD_DEFINE_RESULT__ = (function(n){"use strict";return n.Signal=function(){var t=this.optionsObject(arguments,["value","units"],n.Signal.defaults);this.output=this._gain=this.context.createGain(),t.param=this._gain.gain,n.Param.call(this,t),this.input=this._param=this._gain.gain,this.context.getConstant(1).chain(this._gain)},n.extend(n.Signal,n.Param),n.Signal.defaults={value:0,units:n.Type.Default,convert:!0},n.Signal.prototype.connect=n.SignalBase.prototype.connect,n.Signal.prototype.dispose=function(){return n.Param.prototype.dispose.call(this),this._param=null,this._gain.disconnect(),this._gain=null,this},n.Signal}).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); }), @@ -433,12 +433,6 @@ var __WEBPACK_AMD_DEFINE_RESULT__; }), (function(module, exports, __webpack_require__) { -var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(0),__webpack_require__(19)], __WEBPACK_AMD_DEFINE_RESULT__ = (function(e){"use strict";return e.WaveShaper=function(e,t){this._shaper=this.input=this.output=this.context.createWaveShaper(),this._curve=null,Array.isArray(e)?this.curve=e:isFinite(e)||this.isUndef(e)?this._curve=new Float32Array(this.defaultArg(e,1024)):this.isFunction(e)&&(this._curve=new Float32Array(this.defaultArg(t,1024)),this.setMap(e))},e.extend(e.WaveShaper,e.SignalBase),e.WaveShaper.prototype.setMap=function(e){for(var t=0,r=this._curve.length;t= 16 && bins <= 1024 && Math.log2(bins) % 1 === 0) + return bins;else { + console.log("the value of bins must be power of two and between 16 and 1024"); + return safeBins; + } + }; + return { convertToWav: convertToWav, midiToFreq: midiToFreq, noteToFreq: noteToFreq, - safeBufferSize: safeBufferSize + safeBufferSize: safeBufferSize, + safeBins: safeBins }; }).call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); @@ -803,6 +813,12 @@ function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterat }), (function(module, exports, __webpack_require__) { +var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(0),__webpack_require__(19)], __WEBPACK_AMD_DEFINE_RESULT__ = (function(e){"use strict";return e.WaveShaper=function(e,t){this._shaper=this.input=this.output=this.context.createWaveShaper(),this._curve=null,Array.isArray(e)?this.curve=e:isFinite(e)||this.isUndef(e)?this._curve=new Float32Array(this.defaultArg(e,1024)):this.isFunction(e)&&(this._curve=new Float32Array(this.defaultArg(t,1024)),this.setMap(e))},e.extend(e.WaveShaper,e.SignalBase),e.WaveShaper.prototype.setMap=function(e){for(var t=0,r=this._curve.length;tFFT (Fast Fourier Transform) is an analysis algorithm that * isolates individual @@ -5608,7 +5627,7 @@ var __WEBPACK_AMD_DEFINE_RESULT__; }); this.smooth(smoothing); - this.bins = bins || 1024; + this.bins = safeBins(bins) || 1024; p5sound.fftMeter.connect(this.analyser); this.freqDomain = new Uint8Array(this.analyser.frequencyBinCount); @@ -5889,7 +5908,7 @@ var __WEBPACK_AMD_DEFINE_RESULT__; * * @method getCentroid * @for p5.FFT - * @return {Number} Spectral Centroid Frequency Frequency of the spectral centroid in Hz. + * @return {Number} Spectral Centroid Frequency of the spectral centroid in Hz. * * * @example @@ -7981,31 +8000,31 @@ var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_ }), (function(module, exports, __webpack_require__) { -var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(0),__webpack_require__(5),__webpack_require__(19)], __WEBPACK_AMD_DEFINE_RESULT__ = (function(s){"use strict";return s.Abs=function(){this._abs=this.input=this.output=new s.WaveShaper(function(s){return 0===s?0:Math.abs(s)},127)},s.extend(s.Abs,s.SignalBase),s.Abs.prototype.dispose=function(){return s.prototype.dispose.call(this),this._abs.dispose(),this._abs=null,this},s.Abs}).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), +var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(0),__webpack_require__(6),__webpack_require__(19)], __WEBPACK_AMD_DEFINE_RESULT__ = (function(s){"use strict";return s.Abs=function(){this._abs=this.input=this.output=new s.WaveShaper(function(s){return 0===s?0:Math.abs(s)},127)},s.extend(s.Abs,s.SignalBase),s.Abs.prototype.dispose=function(){return s.prototype.dispose.call(this),this._abs.dispose(),this._abs=null,this},s.Abs}).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); }), (function(module, exports, __webpack_require__) { -var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(0),__webpack_require__(5),__webpack_require__(3),__webpack_require__(16)], __WEBPACK_AMD_DEFINE_RESULT__ = (function(i){"use strict";return i.Modulo=function(t){this.createInsOuts(1,0),this._shaper=new i.WaveShaper(Math.pow(2,16)),this._multiply=new i.Multiply,this._subtract=this.output=new i.Subtract,this._modSignal=new i.Signal(t),this.input.fan(this._shaper,this._subtract),this._modSignal.connect(this._multiply,0,0),this._shaper.connect(this._multiply,0,1),this._multiply.connect(this._subtract,0,1),this._setWaveShaper(t)},i.extend(i.Modulo,i.SignalBase),i.Modulo.prototype._setWaveShaper=function(i){this._shaper.setMap(function(t){return Math.floor((t+1e-4)/i)})},Object.defineProperty(i.Modulo.prototype,"value",{get:function(){return this._modSignal.value},set:function(t){this._modSignal.value=t,this._setWaveShaper(t)}}),i.Modulo.prototype.dispose=function(){return i.prototype.dispose.call(this),this._shaper.dispose(),this._shaper=null,this._multiply.dispose(),this._multiply=null,this._subtract.dispose(),this._subtract=null,this._modSignal.dispose(),this._modSignal=null,this},i.Modulo}).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), +var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(0),__webpack_require__(6),__webpack_require__(3),__webpack_require__(16)], __WEBPACK_AMD_DEFINE_RESULT__ = (function(i){"use strict";return i.Modulo=function(t){this.createInsOuts(1,0),this._shaper=new i.WaveShaper(Math.pow(2,16)),this._multiply=new i.Multiply,this._subtract=this.output=new i.Subtract,this._modSignal=new i.Signal(t),this.input.fan(this._shaper,this._subtract),this._modSignal.connect(this._multiply,0,0),this._shaper.connect(this._multiply,0,1),this._multiply.connect(this._subtract,0,1),this._setWaveShaper(t)},i.extend(i.Modulo,i.SignalBase),i.Modulo.prototype._setWaveShaper=function(i){this._shaper.setMap(function(t){return Math.floor((t+1e-4)/i)})},Object.defineProperty(i.Modulo.prototype,"value",{get:function(){return this._modSignal.value},set:function(t){this._modSignal.value=t,this._setWaveShaper(t)}}),i.Modulo.prototype.dispose=function(){return i.prototype.dispose.call(this),this._shaper.dispose(),this._shaper=null,this._multiply.dispose(),this._multiply=null,this._subtract.dispose(),this._subtract=null,this._modSignal.dispose(),this._modSignal=null,this},i.Modulo}).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); }), (function(module, exports, __webpack_require__) { -var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(0),__webpack_require__(5)], __WEBPACK_AMD_DEFINE_RESULT__ = (function(t){"use strict";return t.Pow=function(e){this._exp=this.defaultArg(e,1),this._expScaler=this.input=this.output=new t.WaveShaper(this._expFunc(this._exp),8192)},t.extend(t.Pow,t.SignalBase),Object.defineProperty(t.Pow.prototype,"value",{get:function(){return this._exp},set:function(e){this._exp=e,this._expScaler.setMap(this._expFunc(this._exp))}}),t.Pow.prototype._expFunc=function(t){return function(e){return Math.pow(Math.abs(e),t)}},t.Pow.prototype.dispose=function(){return t.prototype.dispose.call(this),this._expScaler.dispose(),this._expScaler=null,this},t.Pow}).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), +var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(0),__webpack_require__(6)], __WEBPACK_AMD_DEFINE_RESULT__ = (function(t){"use strict";return t.Pow=function(e){this._exp=this.defaultArg(e,1),this._expScaler=this.input=this.output=new t.WaveShaper(this._expFunc(this._exp),8192)},t.extend(t.Pow,t.SignalBase),Object.defineProperty(t.Pow.prototype,"value",{get:function(){return this._exp},set:function(e){this._exp=e,this._expScaler.setMap(this._expFunc(this._exp))}}),t.Pow.prototype._expFunc=function(t){return function(e){return Math.pow(Math.abs(e),t)}},t.Pow.prototype.dispose=function(){return t.prototype.dispose.call(this),this._expScaler.dispose(),this._expScaler=null,this},t.Pow}).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); }), (function(module, exports, __webpack_require__) { -var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(0),__webpack_require__(5),__webpack_require__(2)], __WEBPACK_AMD_DEFINE_RESULT__ = (function(n){"use strict";return n.AudioToGain=function(){this._norm=this.input=this.output=new n.WaveShaper(function(n){return(n+1)/2})},n.extend(n.AudioToGain,n.SignalBase),n.AudioToGain.prototype.dispose=function(){return n.prototype.dispose.call(this),this._norm.dispose(),this._norm=null,this},n.AudioToGain}).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), +var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(0),__webpack_require__(6),__webpack_require__(2)], __WEBPACK_AMD_DEFINE_RESULT__ = (function(n){"use strict";return n.AudioToGain=function(){this._norm=this.input=this.output=new n.WaveShaper(function(n){return(n+1)/2})},n.extend(n.AudioToGain,n.SignalBase),n.AudioToGain.prototype.dispose=function(){return n.prototype.dispose.call(this),this._norm.dispose(),this._norm=null,this},n.AudioToGain}).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); }), (function(module, exports, __webpack_require__) { -var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(0),__webpack_require__(5)], __WEBPACK_AMD_DEFINE_RESULT__ = (function(e){"use strict";return e.EqualPowerGain=function(){this._eqPower=this.input=this.output=new e.WaveShaper(function(e){return Math.abs(e)<.001?0:this.equalPowerScale(e)}.bind(this),4096)},e.extend(e.EqualPowerGain,e.SignalBase),e.EqualPowerGain.prototype.dispose=function(){return e.prototype.dispose.call(this),this._eqPower.dispose(),this._eqPower=null,this},e.EqualPowerGain}).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), +var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(0),__webpack_require__(6)], __WEBPACK_AMD_DEFINE_RESULT__ = (function(e){"use strict";return e.EqualPowerGain=function(){this._eqPower=this.input=this.output=new e.WaveShaper(function(e){return Math.abs(e)<.001?0:this.equalPowerScale(e)}.bind(this),4096)},e.extend(e.EqualPowerGain,e.SignalBase),e.EqualPowerGain.prototype.dispose=function(){return e.prototype.dispose.call(this),this._eqPower.dispose(),this._eqPower=null,this},e.EqualPowerGain}).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); }), @@ -10598,7 +10617,7 @@ var __WEBPACK_AMD_DEFINE_RESULT__; } }; /** - * Synchronize loops. Use this method to start two more more loops in synchronization + * Synchronize loops. Use this method to start two or more loops in synchronization * or to start a loop in synchronization with a loop that is already playing * This method will schedule the implicit loop in sync with the explicit master loop * i.e. loopToStart.syncedStart(loopToSyncWith) @@ -11046,7 +11065,7 @@ var __WEBPACK_AMD_DEFINE_RESULT__; !(__WEBPACK_AMD_DEFINE_RESULT__ = (function (require) { var p5sound = __webpack_require__(1); - var _require = __webpack_require__(6), + var _require = __webpack_require__(5), convertToWav = _require.convertToWav, safeBufferSize = _require.safeBufferSize; diff --git a/lib/p5.sound.js.map b/lib/p5.sound.js.map index b495f030..33b0aa21 100644 --- a/lib/p5.sound.js.map +++ b/lib/p5.sound.js.map @@ -1 +1 @@ -{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///../node_modules/tone/Tone/core/Tone.js","webpack:///./master.js","webpack:///../node_modules/tone/Tone/signal/Signal.js","webpack:///../node_modules/tone/Tone/signal/Multiply.js","webpack:///./effect.js","webpack:///../node_modules/tone/Tone/signal/WaveShaper.js","webpack:///./helpers.js","webpack:///../node_modules/tone/Tone/signal/Add.js","webpack:///../node_modules/tone/Tone/type/Type.js","webpack:///../node_modules/tone/Tone/core/Gain.js","webpack:///./audioWorklet/processorNames.js","webpack:///./errorHandler.js","webpack:///../node_modules/tone/Tone/core/Context.js","webpack:///../node_modules/tone/Tone/signal/Scale.js","webpack:///../node_modules/tone/Tone/signal/TimelineSignal.js","webpack:///./filter.js","webpack:///../node_modules/tone/Tone/signal/Subtract.js","webpack:///./audiocontext.js","webpack:///../node_modules/tone/Tone/core/Emitter.js","webpack:///../node_modules/tone/Tone/signal/SignalBase.js","webpack:///../node_modules/tone/Tone/type/Time.js","webpack:///../node_modules/tone/Tone/type/TimeBase.js","webpack:///../node_modules/tone/Tone/core/Param.js","webpack:///./oscillator.js","webpack:///../node_modules/tone/Tone/core/Timeline.js","webpack:///../node_modules/tone/Tone/signal/Negate.js","webpack:///../node_modules/tone/Tone/signal/GreaterThanZero.js","webpack:///../node_modules/tone/Tone/core/Clock.js","webpack:///./monosynth.js","webpack:///./audioVoice.js","webpack:///./polysynth.js","webpack:///./app.js","webpack:///../node_modules/audioworklet-polyfill/dist/audioworklet-polyfill.js","webpack:///./shims.js","webpack:///../node_modules/webpack/buildin/global.js","webpack:///../node_modules/startaudiocontext/StartAudioContext.js","webpack:///./audioWorklet/index.js","webpack:///./audioWorklet/recorderProcessor.js","webpack:///./audioWorklet/soundFileProcessor.js","webpack:///./audioWorklet/amplitudeProcessor.js","webpack:///./panner.js","webpack:///./soundfile.js","webpack:///./amplitude.js","webpack:///./fft.js","webpack:///./signal.js","webpack:///../node_modules/tone/Tone/type/Frequency.js","webpack:///../node_modules/tone/Tone/type/TransportTime.js","webpack:///./envelope.js","webpack:///./pulse.js","webpack:///./noise.js","webpack:///./audioin.js","webpack:///../node_modules/tone/Tone/component/CrossFade.js","webpack:///../node_modules/tone/Tone/signal/Expr.js","webpack:///../node_modules/tone/Tone/signal/GreaterThan.js","webpack:///../node_modules/tone/Tone/signal/Abs.js","webpack:///../node_modules/tone/Tone/signal/Modulo.js","webpack:///../node_modules/tone/Tone/signal/Pow.js","webpack:///../node_modules/tone/Tone/signal/AudioToGain.js","webpack:///../node_modules/tone/Tone/signal/EqualPowerGain.js","webpack:///./eq.js","webpack:///./eqFilter.js","webpack:///./panner3d.js","webpack:///./listener3d.js","webpack:///./delay.js","webpack:///./reverb.js","webpack:///./metro.js","webpack:///../node_modules/tone/Tone/core/TimelineState.js","webpack:///./looper.js","webpack:///./soundLoop.js","webpack:///./compressor.js","webpack:///./soundRecorder.js","webpack:///./peakDetect.js","webpack:///./gain.js","webpack:///./distortion.js"],"names":["define","Tone","inputs","outputs","this","isUndef","input","context","createGain","Array","output","audioContext","prototype","set","params","value","rampTime","isObject","isString","tmpObj","paramLoop","attr","parent","indexOf","attrSplit","split","i","length","splice","innerParam","join","param","Signal","Param","rampTo","AudioParam","get","_collectDefaults","constructor","ret","subRet","j","subAttr","isFunction","constr","defaults","Object","keys","_super","superDefs","push","toString","className","isLetter","match","sameConstructor","defineProperty","isArray","dispose","AudioNode","disconnect","connect","unit","outputNum","inputNum","defaultArg","destination","isNumber","apply","arguments","connectSeries","currentUnit","toUnit","chain","fan","given","fallback","givenProp","fallbackProp","optionsObject","values","options","val","arg","call","isBoolean","noOp","_readOnly","property","writable","enumerable","_writable","State","Started","Stopped","Paused","equalPowerScale","percent","piFactor","Math","PI","sin","dbToGain","db","pow","gainToDb","gain","log","LN10","intervalToFrequencyRatio","interval","now","extend","child","TempConstructor","Context","emit","setContext","ctx","sampleRate","hasAudioContext","window","hasOwnProperty","hasPromises","hasWorkers","version","TONE_SILENCE_VERSION_LOGGING","console","audiocontext","Master","limiter","createDynamicsCompressor","threshold","ratio","knee","meter","fftMeter","soundArray","parts","extensions","p5sound","p5","getMasterVolume","masterVolume","vol","tFromNow","currentTime","currentVol","cancelScheduledValues","linearRampToValueAtTime","soundOut","_silentNode","_gain","_param","getConstant","units","Type","Default","convert","SignalBase","Multiply","createInsOuts","_mult","Gain","require","CrossFade","Effect","ac","_drywet","wet","a","b","amp","drywet","fade","u","index","undefined","WaveShaper","mapping","bufferLen","_shaper","createWaveShaper","_curve","curve","isFinite","Float32Array","setMap","len","normalized","oversample","oversampling","RangeError","processorNames","freqToMidi","f","mathlog2","m","round","midiToFreq","noteToFreq","note","wholeNotes","A","B","C","D","E","F","G","toUpperCase","octave","slice","soundFormats","toLowerCase","disposeSound","registerMethod","_checkFileFormats","paths","path","extTest","pop","isFileSupported","pathSplit","pathCore","extension","supported","p","_mathChain","o","math","thisChain","nextChain","type","mathOps","convertToWav","audioBuffer","leftChannel","rightChannel","getChannelData","numberOfChannels","interleaved","interleave","buffer","ArrayBuffer","view","DataView","writeUTFBytes","setUint32","setUint16","lng","volume","setInt16","result","inputIndex","offset","string","setUint8","charCodeAt","safeBufferSize","idealBufferSize","bufferSize","tempAudioWorkletNode","AudioWorkletNode","soundFileProcessor","ScriptProcessorNode","Add","_sum","Time","Frequency","TransportTime","Ticks","NormalRange","AudioRange","Decibels","Interval","BPM","Positive","Cents","Degrees","MIDI","BarsBeatsSixteenths","Samples","Hertz","Note","Milliseconds","Seconds","Notation","toSeconds","time","TimeBase","toFrequency","freq","valueOf","toTicks","Transport","ticks","GainNode","AudioContext","createGainNode","_gainNode","module","exports","recorderProcessor","amplitudeProcessor","CustomError","name","errorTrace","failedPath","err","Error","tempStack","splitStack","originalStack","stack","filter","ln","toneConnect","outNum","inNum","nativeConnect","e","nativeDisconnect","webkitAudioContext","prop","Emitter","_context","_defineProperty","_latencyHint","_lookAhead","_updateInterval","_computedUpdateInterval","_worker","_createWorker","_constants","mixin","bind","URL","webkitURL","blob","Blob","toFixed","blobUrl","createObjectURL","worker","Worker","addEventListener","_lastUpdate","diff","max","createBuffer","arr","constant","createBufferSource","channelCount","channelCountMode","loop","start","lA","blockTime","postMessage","hint","lookAhead","latencyHint","updateInterval","warn","Scale","outputMin","outputMax","_outputMin","_outputMax","_scale","_add","_setRange","min","TimelineSignal","_events","Timeline","_initial","_fromUnits","Linear","Exponential","Target","Curve","Set","getValueAtTime","_toUnits","convertedVal","setValueAtTime","startTime","add","endTime","exponentialRampToValueAtTime","beforeEvent","_searchBefore","_minOutput","setValue","sampleTime","setTargetAtTime","timeConstant","setValueCurveAtTime","duration","scaling","floats","segmentTime","after","cancel","setRampPoint","before","_searchAfter","linearRampToValueBetween","finish","exponentialRampToValueBetween","getAfter","previouVal","previous","getBefore","_exponentialApproach","_curveInterpolate","_linearInterpolate","_exponentialInterpolate","t0","v0","v1","t","exp","t1","progress","lowerIndex","floor","upperIndex","ceil","lowerVal","upperVal","Filter","biquad","createBiquadFilter","setType","_on","_untoggledType","create","process","src","res","frequency","Q","toggle","LowPass","HighPass","BandPass","Subtract","_neg","Negate","global","StartAudioContext","getAudioContext","userStartAudio","elements","callback","elt","Element","map","on","event","events","eventName","off","ev","eventList","args","object","functions","func","emitterFunc","node","outputNumber","inputNumber","overridden","_plusNow","_unaryExpressions","quantize","regexp","method","rh","nextSubdivision","lh","subdiv","_expr","expr","subdivision","addNow","_defaultExpr","_noOp","copy","toNotation","retNotation","_toNotationHelper","retTripletNotation","testNotations","_notationToUnits","notationTime","multiple","notation","primaryExprs","_primaryExpressions","notationExprs","n","toBarsBeatsSixteenths","quarterTime","_beatsToUnits","quarters","measures","_timeSignature","sixteenths","parseFloat","PPQ","toSamples","toMilliseconds","_defaultUnits","exprString","_parseExprString","clone","instance","parseInt","_ticksToUnits","hz","_frequencyToUnits","tr","q","s","total","_secondsToUnits","samples","default","_binaryExpressions","+","precedence","-","*","/","neg","_syntaxGlue","(",")","_tokenize","position","tokens","token","getNextToken","trim","substr","expressions","group","opName","op","reg","SyntaxError","next","peek","_matchGroup","prec","test","_parseBinary","lexer","_parseUnary","_parsePrimary","matching","beats","bpm","seconds","timeSignature","_pushExpr","sub","mult","div","_lfo","lfo","LFO","currentVal","exponentialRampToValue","linearRampToValue","Mult","Oscillator","started","phaseAmount","oscillator","createOscillator","_freqMods","panPosition","connection","panner","Panner","stop","abs","freqNode","self","getAmp","isNaN","phase","getFreq","getType","oscMods","pan","pval","getPan","osc2","delayAmt","dNode","createDelay","delayTime","sigChain","mathObj","chainSource","num","scale","inMin","inMax","outMin","outMax","mapOutMin","mapOutMax","SinOsc","TriOsc","SawOsc","SqrOsc","_timeline","_toRemove","_iterating","memory","Infinity","_search","remove","shift","cancelBefore","beginning","end","midPoint","nextEvent","_iterate","lowerBound","upperBound","forEach","forEachBefore","forEachAfter","forEachFrom","forEachAtTime","_multiply","GreaterThanZero","_thresh","Clock","_nextTick","_lastState","_state","TimelineState","_boundLoop","_loop","state","setStateAtTime","pause","loopInterval","lag","currentState","tickTime","getStateAtTime","AudioVoice","DEFAULT_SUSTAIN","MonoSynth","env","Envelope","setRange","setExp","setADSR","setInput","play","velocity","secondsFromNow","susTime","triggerAttack","triggerRelease","vel","ramp","attack","decay","sustain","release","defineProperties","aTime","dTime","sPercent","rTime","sustime","PolySynth","audioVoice","maxVoices","audiovoices","notes","_newest","_oldest","_voicesInUse","_allocateVoices","noteAttack","noteRelease","noteADSR","d","r","timeFromNow","voice","_note","_velocity","acTime","currentVoice","oldestNote","previousVal","_updateAfter","maxRange","nextTime","p5SOUND","parameters","fill","processor","realm","exec","inputBuffer","outputBuffer","$$processors","$$context","createScriptProcessor","outputChannelCount","Map","properties","c","l","defaultValue","MessageChannel","port2","Processor","port","port1","onaudioprocess","$$audioWorklet","AudioWorklet","addModule","fetch","then","ok","status","text","AudioWorkletProcessor","registerProcessor","parameterDescriptors","document","createElement","style","cssText","appendChild","contentWindow","createTextNode","body","$hook","documentElement","transpile","String","fixSetTarget","setTargetValueAtTime","createDelayNode","createJavaScriptNode","createPeriodicWave","createWaveTable","internal_createGain","internal_createDelay","maxDelayTime","internal_createBufferSource","when","noteGrainOn","noteOn","internal_start","noteOff","internal_stop","playbackRate","internal_createDynamicsCompressor","reduction","internal_createBiquadFilter","detune","internal_createOscillator","setPeriodicWave","setWaveTable","OfflineAudioContext","webkitOfflineAudioContext","navigator","getUserMedia","webkitGetUserMedia","mozGetUserMedia","msGetUserMedia","el","isSupported","canPlayType","isOGGSupported","isMP3Supported","isWAVSupported","isAACSupported","isAIFSupported","g","Function","root","factory","amd","TapListener","element","_dragged","_element","_bindedMove","_moved","_bindedEnd","_ended","isStarted","source","resume","startContext","removeEventListener","promise","Promise","success","checkLoop","requestAnimationFrame","onStarted","tapListeners","bindTapListener","NodeList","querySelectorAll","jquery","toArray","tap","moduleSources","initializedAudioWorklets","loadAudioWorkletModules","all","moduleSrc","objectURL","audioWorklet","preload","_incrementPreload","onWorkletModulesLoad","_decrementPreload","createStereoPanner","stereoPanner","inputChannels","obj","numInputChannels","left","right","channelInterpretation","splitter","createChannelSplitter","createChannelMerger","v","rightVal","cos","leftVal","numChannels","SoundFile","onload","onerror","whileLoading","url","File","FileReader","FileList","file","_onended","_looping","_playing","_paused","_pauseTime","_cues","_cueIDCounter","_lastPos","_counterNode","_workletNode","bufferSourceNodes","bufferSourceNode","reversed","pauseTime","mode","startMillis","load","_whileLoading","_clearOnEnd","registerPreloadMethod","loadSound","location","origin","cordova","alert","errorCallback","request","XMLHttpRequest","evt","_updateProgress","open","responseType","decodeAudioData","response","buff","msg","error","statusText","message","send","reader","readAsArrayBuffer","lengthComputable","percentComplete","loaded","isLoaded","rate","_cueStart","cueStart","cueEnd","setVolume","isPlaying","_initSourceNode","_initCounterNode","_arrayIndex","loopStart","loopEnd","playMode","str","pTime","setLoop","bool","isLooping","isPaused","stopAll","_time","_rampTime","_tFromNow","getVolume","reverse","reverseBuffer","setPitch","newPlaybackRate","getPlaybackRate","jump","cueTime","cTime","dur","channels","frames","getPeaks","width","sampleSize","sampleStep","peaks","chan","currentPos","curVol","onended","getLevel","setPath","setBuffer","buf","size","newBuffer","channelNum","channel","_createCounterBuffer","audioBuf","arrayBuffer","cNode","workletBufferSize","processorOptions","onmessage","data","_onTimeUpdate","processPeaks","_initThreshold","_minThreshold","_minPeaks","bufLen","allPeaks","initialThreshold","minThreshold","minPeaks","offlineContext","startRendering","oncomplete","filteredBuffer","renderedBuffer","bufferData","getPeaksAtThreshold","intervalCounts","countIntervalsBetweenNearbyPeaks","groups","groupNeighborsByTempo","topTempos","sort","intA","intB","count","tempo","bpmVariance","tempoPeaks","getPeaksAtTopTempo","Peak","sampleIndex","amplitude","tempos","intervals","peaksObj","peak","peaksArray","startPeak","endPeak","startPos","endPos","foundInterval","some","intervalCount","tempoCounts","theoreticalTempo","mapTempo","foundTempo","tempoCount","peaksAtTopTempo","key","intervalBPM","peakTime","dif","Cue","id","addCue","cue","removeCue","cueLength","clearCues","playbackTime","callbackTime","_prevUpdateTime","save","fileName","saveSound","getBlob","dataView","thisBufferSourceNode","target","soundFile","_","Amplitude","smoothing","parameterData","normalize","volNorm","stereoVol","stereoVolNorm","toggleNormalize","smooth","FFT","bins","analyser","createAnalyser","fftSize","configurable","smoothingTimeConstant","freqDomain","Uint8Array","frequencyBinCount","timeDomain","bass","lowMid","mid","highMid","treble","waveform","normalArray","_isSafari","timeToFloat","getFloatTimeDomainData","timeToInt","getByteTimeDomainData","scaled","analyze","freqToFloat","getFloatFrequencyData","freqToInt","getByteFrequencyData","getEnergy","frequency1","frequency2","nyquist","swap","lowIndex","highIndex","numFrequencies","toReturn","freq1","freq2","x","getCentroid","cumulative_sum","centroid_normalization","mean_freq_index","spec_centroid_freq","linAverages","N","spectrum","spectrumLength","spectrumStep","linearAverages","groupIndex","specIndex","logAverages","octaveBands","octaveIndex","specIndexFrequency","hi","getOctaveBands","fCtr0","lastFrequencyBand","lo","ctr","newFrequencyBand","fft","_input","midi","midiToFrequency","pitch","noteNumber","noteToScaleIndex","transpose","harmonize","toMidi","frequencyToMidi","toNote","A4","LN2","scaleIndexToNote","cbb","cb","c#","cx","dbb","d#","dx","ebb","eb","e#","ex","fbb","fb","f#","fx","gbb","gb","g#","gx","abb","ab","a#","ax","bbb","bb","b#","bx","_secondsToTicks","l1","t2","l2","t3","l3","aLevel","dLevel","rLevel","_rampHighPercentage","_rampLowPercentage","control","_init","isExponential","sourceToClear","wasTriggered","_setRampAD","_rampAttackTime","checkExpInput","_rampDecayTime","TCDenominator","_rampAttackTC","_rampDecayTC","setRampPercentages","p1","p2","isExp","lastAttack","valToSet","v2","destination1","destination2","AudioIn","Reverb","Noise","Delay","Env","Pulse","w","dcOffset","createDCOffset","dcGain","mW","sig","SignalAdd","mods","currentFreq","freqMod","bufferSource","assignType","_brownNoise","_pinkNoise","_whiteNoise","whiteBuffer","noiseData","random","pinkBuffer","b0","b1","b2","b3","b4","b5","b6","white","brownBuffer","lastOut","noise","inputSources","stream","mediaStream","currentSource","enabled","MediaStreamTrack","mediaDevices","successCallback","audioSource","constraints","audio","echoCancellation","deviceId","createMediaStreamSource","getTracks","track","getSources","onSuccess","onError","resolve","reject","enumerateDevices","devices","device","kind","setSource","active","initialFade","_equalPowerA","EqualPowerGain","_equalPowerB","_invert","Expr","applyBinary","Constructor","_eval","applyUnary","getNumber","literalNumber","_replacements","inputCount","_parseInputs","_nodes","tree","_parseTree","_disposeNodes","_Expressions","signal","glue",",","Abs","mod","modulus","Modulo","Pow","a2g","AudioToGain","binary","unary","!","NOT","inputArray","inputMax","replace","matchSyntax","syn","matchGroup","groupName","parseExpression","parseUnary","operator","parsePrimary","parseArgumentList","parseFunctionCall","GreaterThan","_gtz","_abs","_subtract","_modSignal","_setWaveShaper","_exp","_expScaler","_expFunc","_norm","_eqPower","EQFilter","EQ","_eqsize","factor","bands","_newBand","Panner3D","createPanner","panningModel","distanceModel","xVal","yVal","zVal","positionX","positionY","positionZ","orient","orientX","orientY","orientZ","orientationX","orientationY","orientationZ","setFalloff","maxDistance","rolloffFactor","maxDist","rolloff","Listener3D","listener","xValF","yValF","zValF","xValU","yValU","zValU","orientForward","orientUp","forwardX","forwardY","forwardZ","upX","upY","upZ","_split","_merge","_leftGain","_rightGain","leftDelay","rightDelay","_leftFilter","_rightFilter","_maxDelay","maxValue","feedback","_delayTime","_feedback","_filter","_initConvolverNode","_seconds","_decay","_reverse","_buildImpulse","convolverNode","createConvolver","_teardownConvolverNode","_setBuffer","decayRate","rebuild","impulse","impulseL","impulseR","Convolver","impulses","_loadBuffer","cReverb","chunks","addImpulse","resetImpulse","toggleImpulse","Metro","clock","ontick","syncedParts","prevTick","tatumTime","tickCallback","elapsedTime","thisPart","incrementStep","phrases","thisPhrase","phraseArray","sequence","bNum","metroTicks","looping","setBPM","beatTime","tatums","getBPM","getRate","resetSync","part","pushSync","beatLength","initial","Phrase","phraseStep","Part","steps","bLength","partStep","noLoop","metro","addPhrase","array","removePhrase","getPhrase","replaceSequence","onStep","Score","currentPart","thisScore","nextPart","resetPart","playNextPart","resetParts","scoreStep","aScore","SoundLoop","musicalTimeMode","_interval","_bpm","maxIterations","iterations","_calcFreq","syncedStart","otherLoop","_update","_convertNotation","Number","_measure","timeSig","Compressor","compressor","number","SoundRecorder","_inputChannels","_outputChannels","buffers","leftBuffer","rightBuffer","_callback","record","sFile","writeFile","PeakDetect","_framesPerPeak","framesPerPeak","framesSinceLastPeak","cutoff","cutoffMult","energy","penergy","currentValue","isDetected","f1","f2","_onPeak","update","fftObject","nrg","onPeak","makeDistortionCurve","amount","k","numSamples","deg","Distortion","curveAmount","waveShaperNode","getAmount","getOversample"],"mappings":"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","file":"p5.sound.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 31);\n","/**\n * Tone.js\n * @author Yotam Mann\n * @license http://opensource.org/licenses/MIT MIT License\n * @copyright 2014-2017 Yotam Mann\n */\ndefine(function(){\n\n\t\"use strict\";\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tTONE\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * @class Tone is the base class of all other classes. It provides \n\t * a lot of methods and functionality to all classes that extend\n\t * it. \n\t * \n\t * @constructor\n\t * @alias Tone\n\t * @param {number} [inputs=1] the number of input nodes\n\t * @param {number} [outputs=1] the number of output nodes\n\t */\n\tvar Tone = function(inputs, outputs){\n\n\t\t/**\n\t\t * the input node(s)\n\t\t * @type {GainNode|Array}\n\t\t */\n\t\tif (this.isUndef(inputs) || inputs === 1){\n\t\t\tthis.input = this.context.createGain();\n\t\t} else if (inputs > 1){\n\t\t\tthis.input = new Array(inputs);\n\t\t}\n\n\t\t/**\n\t\t * the output node(s)\n\t\t * @type {GainNode|Array}\n\t\t */\n\t\tif (this.isUndef(outputs) || outputs === 1){\n\t\t\tthis.output = this.context.createGain();\n\t\t} else if (outputs > 1){\n\t\t\tthis.output = new Array(inputs);\n\t\t}\n\t};\n\n\t/**\n\t * Set the parameters at once. Either pass in an\n\t * object mapping parameters to values, or to set a\n\t * single parameter, by passing in a string and value.\n\t * The last argument is an optional ramp time which \n\t * will ramp any signal values to their destination value\n\t * over the duration of the rampTime.\n\t * @param {Object|string} params\n\t * @param {number=} value\n\t * @param {Time=} rampTime\n\t * @returns {Tone} this\n\t * @example\n\t * //set values using an object\n\t * filter.set({\n\t * \t\"frequency\" : 300,\n\t * \t\"type\" : highpass\n\t * });\n\t * @example\n\t * filter.set(\"type\", \"highpass\");\n\t * @example\n\t * //ramp to the value 220 over 3 seconds. \n\t * oscillator.set({\n\t * \t\"frequency\" : 220\n\t * }, 3);\n\t */\n\tTone.prototype.set = function(params, value, rampTime){\n\t\tif (this.isObject(params)){\n\t\t\trampTime = value;\n\t\t} else if (this.isString(params)){\n\t\t\tvar tmpObj = {};\n\t\t\ttmpObj[params] = value;\n\t\t\tparams = tmpObj;\n\t\t}\n\n\t\tparamLoop:\n\t\tfor (var attr in params){\n\t\t\tvalue = params[attr];\n\t\t\tvar parent = this;\n\t\t\tif (attr.indexOf(\".\") !== -1){\n\t\t\t\tvar attrSplit = attr.split(\".\");\n\t\t\t\tfor (var i = 0; i < attrSplit.length - 1; i++){\n\t\t\t\t\tparent = parent[attrSplit[i]];\n\t\t\t\t\tif (parent instanceof Tone) {\n\t\t\t\t\t\tattrSplit.splice(0,i+1);\n\t\t\t\t\t\tvar innerParam = attrSplit.join(\".\");\n\t\t\t\t\t\tparent.set(innerParam, value);\n\t\t\t\t\t\tcontinue paramLoop;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tattr = attrSplit[attrSplit.length - 1];\n\t\t\t}\n\t\t\tvar param = parent[attr];\n\t\t\tif (this.isUndef(param)){\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif ((Tone.Signal && param instanceof Tone.Signal) || \n\t\t\t\t\t(Tone.Param && param instanceof Tone.Param)){\n\t\t\t\tif (param.value !== value){\n\t\t\t\t\tif (this.isUndef(rampTime)){\n\t\t\t\t\t\tparam.value = value;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tparam.rampTo(value, rampTime);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else if (param instanceof AudioParam){\n\t\t\t\tif (param.value !== value){\n\t\t\t\t\tparam.value = value;\n\t\t\t\t}\t\t\t\t\n\t\t\t} else if (param instanceof Tone){\n\t\t\t\tparam.set(value);\n\t\t\t} else if (param !== value){\n\t\t\t\tparent[attr] = value;\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Get the object's attributes. Given no arguments get\n\t * will return all available object properties and their corresponding\n\t * values. Pass in a single attribute to retrieve or an array\n\t * of attributes. The attribute strings can also include a \".\"\n\t * to access deeper properties.\n\t * @example\n\t * osc.get();\n\t * //returns {\"type\" : \"sine\", \"frequency\" : 440, ...etc}\n\t * @example\n\t * osc.get(\"type\");\n\t * //returns { \"type\" : \"sine\"}\n\t * @example\n\t * //use dot notation to access deep properties\n\t * synth.get([\"envelope.attack\", \"envelope.release\"]);\n\t * //returns {\"envelope\" : {\"attack\" : 0.2, \"release\" : 0.4}}\n\t * @param {Array=|string|undefined} params the parameters to get, otherwise will return \n\t * \t\t\t\t\t all available.\n\t * @returns {Object}\n\t */\n\tTone.prototype.get = function(params){\n\t\tif (this.isUndef(params)){\n\t\t\tparams = this._collectDefaults(this.constructor);\n\t\t} else if (this.isString(params)){\n\t\t\tparams = [params];\n\t\t} \n\t\tvar ret = {};\n\t\tfor (var i = 0; i < params.length; i++){\n\t\t\tvar attr = params[i];\n\t\t\tvar parent = this;\n\t\t\tvar subRet = ret;\n\t\t\tif (attr.indexOf(\".\") !== -1){\n\t\t\t\tvar attrSplit = attr.split(\".\");\n\t\t\t\tfor (var j = 0; j < attrSplit.length - 1; j++){\n\t\t\t\t\tvar subAttr = attrSplit[j];\n\t\t\t\t\tsubRet[subAttr] = subRet[subAttr] || {};\n\t\t\t\t\tsubRet = subRet[subAttr];\n\t\t\t\t\tparent = parent[subAttr];\n\t\t\t\t}\n\t\t\t\tattr = attrSplit[attrSplit.length - 1];\n\t\t\t}\n\t\t\tvar param = parent[attr];\n\t\t\tif (this.isObject(params[attr])){\n\t\t\t\tsubRet[attr] = param.get();\n\t\t\t} else if (Tone.Signal && param instanceof Tone.Signal){\n\t\t\t\tsubRet[attr] = param.value;\n\t\t\t} else if (Tone.Param && param instanceof Tone.Param){\n\t\t\t\tsubRet[attr] = param.value;\n\t\t\t} else if (param instanceof AudioParam){\n\t\t\t\tsubRet[attr] = param.value;\n\t\t\t} else if (param instanceof Tone){\n\t\t\t\tsubRet[attr] = param.get();\n\t\t\t} else if (!this.isFunction(param) && !this.isUndef(param)){\n\t\t\t\tsubRet[attr] = param;\n\t\t\t} \n\t\t}\n\t\treturn ret;\n\t};\n\n\t/**\n\t * collect all of the default attributes in one\n\t * @private\n\t * @param {function} constr the constructor to find the defaults from\n\t * @return {Array} all of the attributes which belong to the class\n\t */\n\tTone.prototype._collectDefaults = function(constr){\n\t\tvar ret = [];\n\t\tif (!this.isUndef(constr.defaults)){\n\t\t\tret = Object.keys(constr.defaults);\n\t\t}\n\t\tif (!this.isUndef(constr._super)){\n\t\t\tvar superDefs = this._collectDefaults(constr._super);\n\t\t\t//filter out repeats\n\t\t\tfor (var i = 0; i < superDefs.length; i++){\n\t\t\t\tif (ret.indexOf(superDefs[i]) === -1){\n\t\t\t\t\tret.push(superDefs[i]);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn ret;\n\t};\n\n\t/**\n\t * @returns {string} returns the name of the class as a string\n\t */\n\tTone.prototype.toString = function(){\n\t\tfor (var className in Tone){\n\t\t\tvar isLetter = className[0].match(/^[A-Z]$/);\n\t\t\tvar sameConstructor = Tone[className] === this.constructor;\n\t\t\tif (this.isFunction(Tone[className]) && isLetter && sameConstructor){\n\t\t\t\treturn className;\n\t\t\t}\n\t\t}\n\t\treturn \"Tone\";\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tCLASS VARS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * The number of inputs feeding into the AudioNode. \n\t * For source nodes, this will be 0.\n\t * @memberOf Tone#\n\t * @name numberOfInputs\n\t * @readOnly\n\t */\n\tObject.defineProperty(Tone.prototype, \"numberOfInputs\", {\n\t\tget : function(){\n\t\t\tif (this.input){\n\t\t\t\tif (this.isArray(this.input)){\n\t\t\t\t\treturn this.input.length;\n\t\t\t\t} else {\n\t\t\t\t\treturn 1;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\treturn 0;\n\t\t\t}\n\t\t}\n\t});\n\n\t/**\n\t * The number of outputs coming out of the AudioNode. \n\t * For source nodes, this will be 0.\n\t * @memberOf Tone#\n\t * @name numberOfInputs\n\t * @readOnly\n\t */\n\tObject.defineProperty(Tone.prototype, \"numberOfOutputs\", {\n\t\tget : function(){\n\t\t\tif (this.output){\n\t\t\t\tif (this.isArray(this.output)){\n\t\t\t\t\treturn this.output.length;\n\t\t\t\t} else {\n\t\t\t\t\treturn 1;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\treturn 0;\n\t\t\t}\n\t\t}\n\t});\n\t\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tCONNECTIONS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * disconnect and dispose\n\t * @returns {Tone} this\n\t */\n\tTone.prototype.dispose = function(){\n\t\tif (!this.isUndef(this.input)){\n\t\t\tif (this.input instanceof AudioNode){\n\t\t\t\tthis.input.disconnect();\n\t\t\t} \n\t\t\tthis.input = null;\n\t\t}\n\t\tif (!this.isUndef(this.output)){\n\t\t\tif (this.output instanceof AudioNode){\n\t\t\t\tthis.output.disconnect();\n\t\t\t} \n\t\t\tthis.output = null;\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * connect the output of a ToneNode to an AudioParam, AudioNode, or ToneNode\n\t * @param {Tone | AudioParam | AudioNode} unit \n\t * @param {number} [outputNum=0] optionally which output to connect from\n\t * @param {number} [inputNum=0] optionally which input to connect to\n\t * @returns {Tone} this\n\t */\n\tTone.prototype.connect = function(unit, outputNum, inputNum){\n\t\tif (Array.isArray(this.output)){\n\t\t\toutputNum = this.defaultArg(outputNum, 0);\n\t\t\tthis.output[outputNum].connect(unit, 0, inputNum);\n\t\t} else {\n\t\t\tthis.output.connect(unit, outputNum, inputNum);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * disconnect the output\n\t * @param {Number|AudioNode} output Either the output index to disconnect\n\t * if the output is an array, or the\n\t * node to disconnect from.\n\t * @returns {Tone} this\n\t */\n\tTone.prototype.disconnect = function(destination, outputNum, inputNum){\n\t\tif (this.isArray(this.output)){\n\t\t\tif (this.isNumber(destination)){\n\t\t\t\tthis.output[destination].disconnect();\n\t\t\t} else {\n\t\t\t\toutputNum = this.defaultArg(outputNum, 0);\n\t\t\t\tthis.output[outputNum].disconnect(destination, 0, inputNum);\n\t\t\t}\n\t\t} else {\n\t\t\tthis.output.disconnect.apply(this.output, arguments);\n\t\t}\n\t};\n\n\t/**\n\t * connect together all of the arguments in series\n\t * @param {...AudioParam|Tone|AudioNode} nodes\n\t * @returns {Tone} this\n\t */\n\tTone.prototype.connectSeries = function(){\n\t\tif (arguments.length > 1){\n\t\t\tvar currentUnit = arguments[0];\n\t\t\tfor (var i = 1; i < arguments.length; i++){\n\t\t\t\tvar toUnit = arguments[i];\n\t\t\t\tcurrentUnit.connect(toUnit);\n\t\t\t\tcurrentUnit = toUnit;\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Connect the output of this node to the rest of the nodes in series.\n\t * @example\n\t * //connect a node to an effect, panVol and then to the master output\n\t * node.chain(effect, panVol, Tone.Master);\n\t * @param {...AudioParam|Tone|AudioNode} nodes\n\t * @returns {Tone} this\n\t */\n\tTone.prototype.chain = function(){\n\t\tif (arguments.length > 0){\n\t\t\tvar currentUnit = this;\n\t\t\tfor (var i = 0; i < arguments.length; i++){\n\t\t\t\tvar toUnit = arguments[i];\n\t\t\t\tcurrentUnit.connect(toUnit);\n\t\t\t\tcurrentUnit = toUnit;\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * connect the output of this node to the rest of the nodes in parallel.\n\t * @param {...AudioParam|Tone|AudioNode} nodes\n\t * @returns {Tone} this\n\t */\n\tTone.prototype.fan = function(){\n\t\tif (arguments.length > 0){\n\t\t\tfor (var i = 0; i < arguments.length; i++){\n\t\t\t\tthis.connect(arguments[i]);\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t};\n\n\t//give native nodes chain and fan methods\n\tAudioNode.prototype.chain = Tone.prototype.chain;\n\tAudioNode.prototype.fan = Tone.prototype.fan;\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tUTILITIES / HELPERS / MATHS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * If the `given` parameter is undefined, use the `fallback`. \n\t * If both `given` and `fallback` are object literals, it will\n\t * return a deep copy which includes all of the parameters from both \n\t * objects. If a parameter is undefined in given, it will return\n\t * the fallback property. \n\t *

\n\t * WARNING: if object is self referential, it will go into an an \n\t * infinite recursive loop.\n\t * \n\t * @param {*} given \n\t * @param {*} fallback \n\t * @return {*} \n\t */\n\tTone.prototype.defaultArg = function(given, fallback){\n\t\tif (this.isObject(given) && this.isObject(fallback)){\n\t\t\tvar ret = {};\n\t\t\t//make a deep copy of the given object\n\t\t\tfor (var givenProp in given) {\n\t\t\t\tret[givenProp] = this.defaultArg(fallback[givenProp], given[givenProp]);\n\t\t\t}\n\t\t\tfor (var fallbackProp in fallback) {\n\t\t\t\tret[fallbackProp] = this.defaultArg(given[fallbackProp], fallback[fallbackProp]);\n\t\t\t}\n\t\t\treturn ret;\n\t\t} else {\n\t\t\treturn this.isUndef(given) ? fallback : given;\n\t\t}\n\t};\n\n\t/**\n\t * returns the args as an options object with given arguments\n\t * mapped to the names provided. \n\t *\n\t * if the args given is an array containing only one object, it is assumed\n\t * that that's already the options object and will just return it. \n\t * \n\t * @param {Array} values the 'arguments' object of the function\n\t * @param {Array} keys the names of the arguments as they\n\t * should appear in the options object\n\t * @param {Object=} defaults optional defaults to mixin to the returned \n\t * options object \n\t * @return {Object} the options object with the names mapped to the arguments\n\t */\n\tTone.prototype.optionsObject = function(values, keys, defaults){\n\t\tvar options = {};\n\t\tif (values.length === 1 && this.isObject(values[0])){\n\t\t\toptions = values[0];\n\t\t} else {\n\t\t\tfor (var i = 0; i < keys.length; i++){\n\t\t\t\toptions[keys[i]] = values[i];\n\t\t\t}\n\t\t}\n\t\tif (!this.isUndef(defaults)){\n\t\t\treturn this.defaultArg(options, defaults);\n\t\t} else {\n\t\t\treturn options;\n\t\t}\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t// TYPE CHECKING\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * test if the arg is undefined\n\t * @param {*} arg the argument to test\n\t * @returns {boolean} true if the arg is undefined\n\t * @function\n\t */\n\tTone.prototype.isUndef = function(val){\n\t\treturn typeof val === \"undefined\";\n\t};\n\n\t/**\n\t * test if the arg is a function\n\t * @param {*} arg the argument to test\n\t * @returns {boolean} true if the arg is a function\n\t * @function\n\t */\n\tTone.prototype.isFunction = function(val){\n\t\treturn typeof val === \"function\";\n\t};\n\n\t/**\n\t * Test if the argument is a number.\n\t * @param {*} arg the argument to test\n\t * @returns {boolean} true if the arg is a number\n\t */\n\tTone.prototype.isNumber = function(arg){\n\t\treturn (typeof arg === \"number\");\n\t};\n\n\t/**\n\t * Test if the given argument is an object literal (i.e. `{}`);\n\t * @param {*} arg the argument to test\n\t * @returns {boolean} true if the arg is an object literal.\n\t */\n\tTone.prototype.isObject = function(arg){\n\t\treturn (Object.prototype.toString.call(arg) === \"[object Object]\" && arg.constructor === Object);\n\t};\n\n\t/**\n\t * Test if the argument is a boolean.\n\t * @param {*} arg the argument to test\n\t * @returns {boolean} true if the arg is a boolean\n\t */\n\tTone.prototype.isBoolean = function(arg){\n\t\treturn (typeof arg === \"boolean\");\n\t};\n\n\t/**\n\t * Test if the argument is an Array\n\t * @param {*} arg the argument to test\n\t * @returns {boolean} true if the arg is an array\n\t */\n\tTone.prototype.isArray = function(arg){\n\t\treturn (Array.isArray(arg));\n\t};\n\n\t/**\n\t * Test if the argument is a string.\n\t * @param {*} arg the argument to test\n\t * @returns {boolean} true if the arg is a string\n\t */\n\tTone.prototype.isString = function(arg){\n\t\treturn (typeof arg === \"string\");\n\t};\n\n \t/**\n\t * An empty function.\n\t * @static\n\t */\n\tTone.noOp = function(){};\n\n\t/**\n\t * Make the property not writable. Internal use only. \n\t * @private\n\t * @param {string} property the property to make not writable\n\t */\n\tTone.prototype._readOnly = function(property){\n\t\tif (Array.isArray(property)){\n\t\t\tfor (var i = 0; i < property.length; i++){\n\t\t\t\tthis._readOnly(property[i]);\n\t\t\t}\n\t\t} else {\n\t\t\tObject.defineProperty(this, property, { \n\t\t\t\twritable: false,\n\t\t\t\tenumerable : true,\n\t\t\t});\n\t\t}\n\t};\n\n\t/**\n\t * Make an attribute writeable. Interal use only. \n\t * @private\n\t * @param {string} property the property to make writable\n\t */\n\tTone.prototype._writable = function(property){\n\t\tif (Array.isArray(property)){\n\t\t\tfor (var i = 0; i < property.length; i++){\n\t\t\t\tthis._writable(property[i]);\n\t\t\t}\n\t\t} else {\n\t\t\tObject.defineProperty(this, property, { \n\t\t\t\twritable: true,\n\t\t\t});\n\t\t}\n\t};\n\n\t/**\n\t * Possible play states. \n\t * @enum {string}\n\t */\n\tTone.State = {\n\t\tStarted : \"started\",\n\t\tStopped : \"stopped\",\n\t\tPaused : \"paused\",\n \t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t// CONVERSIONS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Equal power gain scale. Good for cross-fading.\n\t * @param {NormalRange} percent (0-1)\n\t * @return {Number} output gain (0-1)\n\t */\n\tTone.prototype.equalPowerScale = function(percent){\n\t\tvar piFactor = 0.5 * Math.PI;\n\t\treturn Math.sin(percent * piFactor);\n\t};\n\n\t/**\n\t * Convert decibels into gain.\n\t * @param {Decibels} db\n\t * @return {Number} \n\t */\n\tTone.prototype.dbToGain = function(db) {\n\t\treturn Math.pow(2, db / 6);\n\t};\n\n\t/**\n\t * Convert gain to decibels.\n\t * @param {Number} gain (0-1)\n\t * @return {Decibels} \n\t */\n\tTone.prototype.gainToDb = function(gain) {\n\t\treturn 20 * (Math.log(gain) / Math.LN10);\n\t};\n\n\t/**\n\t * Convert an interval (in semitones) to a frequency ratio.\n\t * @param {Interval} interval the number of semitones above the base note\n\t * @return {number} the frequency ratio\n\t * @example\n\t * tone.intervalToFrequencyRatio(0); // 1\n\t * tone.intervalToFrequencyRatio(12); // 2\n\t * tone.intervalToFrequencyRatio(-12); // 0.5\n\t */\n\tTone.prototype.intervalToFrequencyRatio = function(interval){\n\t\treturn Math.pow(2,(interval/12));\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tTIMING\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Return the current time of the AudioContext clock.\n\t * @return {Number} the currentTime from the AudioContext\n\t */\n\tTone.prototype.now = function(){\n\t\treturn Tone.context.now();\n\t};\n\n\t/**\n\t * Return the current time of the AudioContext clock.\n\t * @return {Number} the currentTime from the AudioContext\n\t * @static\n\t */\n\tTone.now = function(){\n\t\treturn Tone.context.now();\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tINHERITANCE\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * have a child inherit all of Tone's (or a parent's) prototype\n\t * to inherit the parent's properties, make sure to call \n\t * Parent.call(this) in the child's constructor\n\t *\n\t * based on closure library's inherit function\n\t *\n\t * @static\n\t * @param {function} \tchild \n\t * @param {function=} parent (optional) parent to inherit from\n\t * if no parent is supplied, the child\n\t * will inherit from Tone\n\t */\n\tTone.extend = function(child, parent){\n\t\tif (Tone.prototype.isUndef(parent)){\n\t\t\tparent = Tone;\n\t\t}\n\t\tfunction TempConstructor(){}\n\t\tTempConstructor.prototype = parent.prototype;\n\t\tchild.prototype = new TempConstructor();\n\t\t/** @override */\n\t\tchild.prototype.constructor = child;\n\t\tchild._super = parent;\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tCONTEXT\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * The private audio context shared by all Tone Nodes. \n\t * @private\n\t * @type {Tone.Context|undefined}\n\t */\n\tvar audioContext;\n\n\t/**\n\t * A static pointer to the audio context accessible as Tone.context. \n\t * @type {Tone.Context}\n\t * @name context\n\t * @memberOf Tone\n\t */\n\tObject.defineProperty(Tone, \"context\", {\n\t\tget : function(){\n\t\t\treturn audioContext;\n\t\t},\n\t\tset : function(context){\n\t\t\tif (Tone.Context && context instanceof Tone.Context){\n\t\t\t\taudioContext = context;\n\t\t\t} else {\n\t\t\t\taudioContext = new Tone.Context(context);\n\t\t\t}\n\t\t\t//initialize the new audio context\n\t\t\tif (Tone.Context){\n\t\t\t\tTone.Context.emit(\"init\", audioContext);\n\t\t\t}\n\t\t}\n\t});\n\n\t/**\n\t * The AudioContext\n\t * @type {Tone.Context}\n\t * @name context\n\t * @memberOf Tone#\n\t * @readOnly\n\t */\n\tObject.defineProperty(Tone.prototype, \"context\", {\n\t\tget : function(){\n\t\t\treturn Tone.context;\n\t\t}\n\t});\n\n\t/**\n\t * Tone automatically creates a context on init, but if you are working\n\t * with other libraries which also create an AudioContext, it can be\n\t * useful to set your own. If you are going to set your own context, \n\t * be sure to do it at the start of your code, before creating any objects.\n\t * @static\n\t * @param {AudioContext} ctx The new audio context to set\n\t */\n\tTone.setContext = function(ctx){\n\t\tTone.context = ctx;\n\t};\n\n\t/**\n\t * The number of seconds of 1 processing block (128 samples)\n\t * @type {Number}\n\t * @name blockTime\n\t * @memberOf Tone#\n\t * @readOnly\n\t */\n\tObject.defineProperty(Tone.prototype, \"blockTime\", {\n\t\tget : function(){\n\t\t\treturn 128 / this.context.sampleRate;\n\t\t}\n\t});\n\n\t/**\n\t * The duration in seconds of one sample.\n\t * @type {Number}\n\t * @name sampleTime\n\t * @memberOf Tone#\n\t * @readOnly\n\t */\n\tObject.defineProperty(Tone.prototype, \"sampleTime\", {\n\t\tget : function(){\n\t\t\treturn 1 / this.context.sampleRate;\n\t\t}\n\t});\n\n\t/**\n\t * Whether or not all the technologies that Tone.js relies on are supported by the current browser. \n\t * @type {Boolean}\n\t * @name supported\n\t * @memberOf Tone\n\t * @readOnly\n\t */\n\tObject.defineProperty(Tone, \"supported\", {\n\t\tget : function(){\n\t\t\tvar hasAudioContext = window.hasOwnProperty(\"AudioContext\") || window.hasOwnProperty(\"webkitAudioContext\");\n\t\t\tvar hasPromises = window.hasOwnProperty(\"Promise\");\n\t\t\tvar hasWorkers = window.hasOwnProperty(\"Worker\");\n\t\t\treturn hasAudioContext && hasPromises && hasWorkers;\n\t\t}\n\t});\n\n\tTone.version = \"r10\";\n\n\t// allow optional silencing of this log\n\tif (!window.TONE_SILENCE_VERSION_LOGGING) {\n\t\tconsole.log(\"%c * Tone.js \" + Tone.version + \" * \", \"background: #000; color: #fff\");\n\t}\n\n\treturn Tone;\n});\n","'use strict';\n\n\ndefine(['audiocontext'], function (audiocontext) {\n // Master contains the master sound output.\n var Master = function() {\n this.input = audiocontext.createGain();\n this.output = audiocontext.createGain();\n\n //put a hard limiter on the output\n this.limiter = audiocontext.createDynamicsCompressor();\n this.limiter.threshold.value = -3;\n this.limiter.ratio.value = 20;\n this.limiter.knee.value = 1;\n\n this.audiocontext = audiocontext;\n\n this.output.disconnect();\n\n // connect input to limiter\n this.input.connect(this.limiter);\n\n // connect limiter to output\n this.limiter.connect(this.output);\n\n // meter is just for global Amplitude / FFT analysis\n this.meter = audiocontext.createGain();\n this.fftMeter = audiocontext.createGain();\n this.output.connect(this.meter);\n this.output.connect(this.fftMeter);\n\n // connect output to destination\n this.output.connect(this.audiocontext.destination);\n\n // an array of all sounds in the sketch\n this.soundArray = [];\n // an array of all musical parts in the sketch\n this.parts = [];\n\n // file extensions to search for\n this.extensions = [];\n };\n\n // create a single instance of the p5Sound / master output for use within this sketch\n var p5sound = new Master();\n\n /**\n * Returns a number representing the master amplitude (volume) for sound\n * in this sketch.\n *\n * @method getMasterVolume\n * @return {Number} Master amplitude (volume) for sound in this sketch.\n * Should be between 0.0 (silence) and 1.0.\n */\n p5.prototype.getMasterVolume = function() {\n return p5sound.output.gain.value;\n };\n\n /**\n *

Scale the output of all sound in this sketch

\n * Scaled between 0.0 (silence) and 1.0 (full volume).\n * 1.0 is the maximum amplitude of a digital sound, so multiplying\n * by greater than 1.0 may cause digital distortion. To\n * fade, provide a rampTime parameter. For more\n * complex fades, see the Envelope class.\n *\n * Alternately, you can pass in a signal source such as an\n * oscillator to modulate the amplitude with an audio signal.\n *\n *

How This Works: When you load the p5.sound module, it\n * creates a single instance of p5sound. All sound objects in this\n * module output to p5sound before reaching your computer's output.\n * So if you change the amplitude of p5sound, it impacts all of the\n * sound in this module.

\n *\n *

If no value is provided, returns a Web Audio API Gain Node

\n *\n * @method masterVolume\n * @param {Number|Object} volume Volume (amplitude) between 0.0\n * and 1.0 or modulating signal/oscillator\n * @param {Number} [rampTime] Fade for t seconds\n * @param {Number} [timeFromNow] Schedule this event to happen at\n * t seconds in the future\n */\n p5.prototype.masterVolume = function(vol, rampTime, tFromNow) {\n if (typeof vol === 'number') {\n var rampTime = rampTime || 0;\n var tFromNow = tFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n var currentVol = p5sound.output.gain.value;\n p5sound.output.gain.cancelScheduledValues(now + tFromNow);\n p5sound.output.gain.linearRampToValueAtTime(currentVol, now + tFromNow);\n p5sound.output.gain.linearRampToValueAtTime(vol, now + tFromNow + rampTime);\n }\n else if (vol) {\n vol.connect(p5sound.output.gain);\n } else {\n // return the Gain Node\n return p5sound.output.gain;\n }\n };\n\n /**\n * `p5.soundOut` is the p5.sound master output. It sends output to\n * the destination of this window's web audio context. It contains\n * Web Audio API nodes including a dyanmicsCompressor (.limiter),\n * and Gain Nodes for .input and .output.\n *\n * @property {Object} soundOut\n */\n p5.prototype.soundOut = p5.soundOut = p5sound;\n\n // a silent connection to the DesinationNode\n // which will ensure that anything connected to it\n // will not be garbage collected\n p5.soundOut._silentNode = p5sound.audiocontext.createGain();\n p5.soundOut._silentNode.gain.value = 0;\n p5.soundOut._silentNode.connect(p5sound.audiocontext.destination);\n\n\n return p5sound;\n});\n","define([\"Tone/core/Tone\", \"Tone/signal/WaveShaper\", \"Tone/type/Type\", \"Tone/core/Param\", \"Tone/core/Gain\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class A signal is an audio-rate value. Tone.Signal is a core component of the library.\n\t * Unlike a number, Signals can be scheduled with sample-level accuracy. Tone.Signal\n\t * has all of the methods available to native Web Audio \n\t * [AudioParam](http://webaudio.github.io/web-audio-api/#the-audioparam-interface)\n\t * as well as additional conveniences. Read more about working with signals \n\t * [here](https://github.com/Tonejs/Tone.js/wiki/Signals).\n\t *\n\t * @constructor\n\t * @extends {Tone.Param}\n\t * @param {Number|AudioParam} [value] Initial value of the signal. If an AudioParam\n\t * is passed in, that parameter will be wrapped\n\t * and controlled by the Signal. \n\t * @param {string} [units=Number] unit The units the signal is in. \n\t * @example\n\t * var signal = new Tone.Signal(10);\n\t */\n\tTone.Signal = function(){\n\n\t\tvar options = this.optionsObject(arguments, [\"value\", \"units\"], Tone.Signal.defaults);\n\n\t\t/**\n\t\t * The node where the constant signal value is scaled.\n\t\t * @type {GainNode}\n\t\t * @private\n\t\t */\n\t\tthis.output = this._gain = this.context.createGain();\n\n\t\toptions.param = this._gain.gain;\n\t\tTone.Param.call(this, options);\n\n\t\t/**\n\t\t * The node where the value is set.\n\t\t * @type {Tone.Param}\n\t\t * @private\n\t\t */\n\t\tthis.input = this._param = this._gain.gain;\n\n\t\t//connect the const output to the node output\n\t\tthis.context.getConstant(1).chain(this._gain);\n\t};\n\n\tTone.extend(Tone.Signal, Tone.Param);\n\n\t/**\n\t * The default values\n\t * @type {Object}\n\t * @static\n\t * @const\n\t */\n\tTone.Signal.defaults = {\n\t\t\"value\" : 0,\n\t\t\"units\" : Tone.Type.Default,\n\t\t\"convert\" : true,\n\t};\n\n\t/**\n\t * When signals connect to other signals or AudioParams, \n\t * they take over the output value of that signal or AudioParam. \n\t * For all other nodes, the behavior is the same as a default connect. \n\t *\n\t * @override\n\t * @param {AudioParam|AudioNode|Tone.Signal|Tone} node \n\t * @param {number} [outputNumber=0] The output number to connect from.\n\t * @param {number} [inputNumber=0] The input number to connect to.\n\t * @returns {Tone.SignalBase} this\n\t * @method\n\t */\n\tTone.Signal.prototype.connect = Tone.SignalBase.prototype.connect;\n\n\t/**\n\t * dispose and disconnect\n\t * @returns {Tone.Signal} this\n\t */\n\tTone.Signal.prototype.dispose = function(){\n\t\tTone.Param.prototype.dispose.call(this);\n\t\tthis._param = null;\n\t\tthis._gain.disconnect();\n\t\tthis._gain = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.Signal;\n});","define([\"Tone/core/Tone\", \"Tone/signal/Signal\", \"Tone/core/Gain\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Multiply two incoming signals. Or, if a number is given in the constructor, \n\t * multiplies the incoming signal by that value. \n\t *\n\t * @constructor\n\t * @extends {Tone.Signal}\n\t * @param {number=} value Constant value to multiple. If no value is provided,\n\t * it will return the product of the first and second inputs\n\t * @example\n\t * var mult = new Tone.Multiply();\n\t * var sigA = new Tone.Signal(3);\n\t * var sigB = new Tone.Signal(4);\n\t * sigA.connect(mult, 0, 0);\n\t * sigB.connect(mult, 0, 1);\n\t * //output of mult is 12.\n\t * @example\n\t * var mult = new Tone.Multiply(10);\n\t * var sig = new Tone.Signal(2).connect(mult);\n\t * //the output of mult is 20. \n\t */\n\tTone.Multiply = function(value){\n\n\t\tthis.createInsOuts(2, 0);\n\n\t\t/**\n\t\t * the input node is the same as the output node\n\t\t * it is also the GainNode which handles the scaling of incoming signal\n\t\t * \n\t\t * @type {GainNode}\n\t\t * @private\n\t\t */\n\t\tthis._mult = this.input[0] = this.output = new Tone.Gain();\n\n\t\t/**\n\t\t * the scaling parameter\n\t\t * @type {AudioParam}\n\t\t * @private\n\t\t */\n\t\tthis._param = this.input[1] = this.output.gain;\n\t\t\n\t\tthis._param.value = this.defaultArg(value, 0);\n\t};\n\n\tTone.extend(Tone.Multiply, Tone.Signal);\n\n\t/**\n\t * clean up\n\t * @returns {Tone.Multiply} this\n\t */\n\tTone.Multiply.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._mult.dispose();\n\t\tthis._mult = null;\n\t\tthis._param = null;\n\t\treturn this;\n\t}; \n\n\treturn Tone.Multiply;\n});\n","'use strict';\ndefine(function (require) {\n\n var p5sound = require('master');\n var CrossFade = require('Tone/component/CrossFade');\n\n /**\n * Effect is a base class for audio effects in p5.
\n * This module handles the nodes and methods that are\n * common and useful for current and future effects.\n *\n *\n * This class is extended by p5.Distortion,\n * p5.Compressor,\n * p5.Delay,\n * p5.Filter,\n * p5.Reverb.\n *\n * @class p5.Effect\n * @constructor\n *\n * @param {Object} [ac] Reference to the audio context of the p5 object\n * @param {AudioNode} [input] Gain Node effect wrapper\n * @param {AudioNode} [output] Gain Node effect wrapper\n * @param {Object} [_drywet] Tone.JS CrossFade node (defaults to value: 1)\n * @param {AudioNode} [wet] Effects that extend this class should connect\n * to the wet signal to this gain node, so that dry and wet\n * signals are mixed properly.\n */\n p5.Effect = function() {\n this.ac = p5sound.audiocontext;\n\n this.input = this.ac.createGain();\n this.output = this.ac.createGain();\n\n /**\n *\tThe p5.Effect class is built\n * \tusing Tone.js CrossFade\n * \t@private\n */\n\n this._drywet = new CrossFade(1);\n\n /**\n *\tIn classes that extend\n *\tp5.Effect, connect effect nodes\n *\tto the wet parameter\n */\n this.wet = this.ac.createGain();\n\n this.input.connect(this._drywet.a);\n this.wet.connect(this._drywet.b);\n this._drywet.connect(this.output);\n\n this.connect();\n\n //Add to the soundArray\n p5sound.soundArray.push(this);\n };\n\n /**\n * Set the output volume of the filter.\n *\n * @method amp\n * @for p5.Effect\n * @param {Number} [vol] amplitude between 0 and 1.0\n * @param {Number} [rampTime] create a fade that lasts until rampTime\n * @param {Number} [tFromNow] schedule this event to happen in tFromNow seconds\n */\n p5.Effect.prototype.amp = function(vol, rampTime, tFromNow){\n var rampTime = rampTime || 0;\n var tFromNow = tFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n var currentVol = this.output.gain.value;\n this.output.gain.cancelScheduledValues(now);\n this.output.gain.linearRampToValueAtTime(currentVol, now + tFromNow + .001);\n this.output.gain.linearRampToValueAtTime(vol, now + tFromNow + rampTime + .001);\n };\n\n /**\n * Link effects together in a chain\n * Example usage: filter.chain(reverb, delay, panner);\n * May be used with an open-ended number of arguments\n *\n * @method chain\n * @for p5.Effect\n * @param {Object} [arguments] Chain together multiple sound objects\n */\n p5.Effect.prototype.chain = function(){\n if (arguments.length>0){\n this.connect(arguments[0]);\n for(var i=1;i\n * let midiNotes = [60, 64, 67, 72];\n * let noteIndex = 0;\n * let midiVal, freq;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(startSound);\n * osc = new p5.TriOsc();\n * env = new p5.Envelope();\n * }\n *\n * function draw() {\n * background(220);\n * text('tap to play', 10, 20);\n * if (midiVal) {\n * text('MIDI: ' + midiVal, 10, 40);\n * text('Freq: ' + freq, 10, 60);\n * }\n * }\n *\n * function startSound() {\n * // see also: userStartAudio();\n * osc.start();\n *\n * midiVal = midiNotes[noteIndex % midiNotes.length];\n * freq = midiToFreq(midiVal);\n * osc.freq(freq);\n * env.ramp(osc, 0, 1.0, 0);\n *\n * noteIndex++;\n * }\n * \n */\n var midiToFreq = p5.prototype.midiToFreq = function(m) {\n return 440 * Math.pow(2, (m-69)/12.0);\n };\n\n // This method converts ANSI notes specified as a string \"C4\", \"Eb3\" to a frequency\n var noteToFreq = function(note) {\n if (typeof note !== 'string') {\n return note;\n }\n var wholeNotes = {A:21, B:23, C:24, D:26, E:28, F:29, G:31};\n var value = wholeNotes[ note[0].toUpperCase() ];\n var octave = ~~note.slice(-1);\n value += 12 * (octave -1);\n\n switch(note[1]) {\n case '#':\n value += 1;\n break;\n case 'b':\n value -= 1;\n break;\n default:\n break;\n }\n return midiToFreq(value);\n };\n\n /**\n * List the SoundFile formats that you will include. LoadSound\n * will search your directory for these extensions, and will pick\n * a format that is compatable with the client's web browser.\n * Here is a free online file\n * converter.\n *\n * @method soundFormats\n * @param {String} [...formats] i.e. 'mp3', 'wav', 'ogg'\n * @example\n *
\n * function preload() {\n * // set the global sound formats\n * soundFormats('mp3', 'ogg');\n *\n * // load either beatbox.mp3, or .ogg, depending on browser\n * mySound = loadSound('assets/beatbox.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * background(220);\n * text('sound loaded! tap to play', 10, 20, width - 20);\n * cnv.mousePressed(function() {\n * mySound.play();\n * });\n * }\n *
\n */\n p5.prototype.soundFormats = function() {\n // reset extensions array\n p5sound.extensions = [];\n // add extensions\n for (var i = 0; i < arguments.length; i++) {\n arguments[i] = arguments[i].toLowerCase();\n if (['mp3','wav','ogg', 'm4a', 'aac'].indexOf(arguments[i]) > -1) {\n p5sound.extensions.push(arguments[i]);\n } else {\n throw arguments[i] + ' is not a valid sound format!';\n }\n }\n };\n\n p5.prototype.disposeSound = function() {\n for (var i = 0; i < p5sound.soundArray.length; i++) {\n p5sound.soundArray[i].dispose();\n }\n };\n\n // register removeSound to dispose of p5sound SoundFiles, Convolvers,\n // Oscillators etc when sketch ends\n p5.prototype.registerMethod('remove', p5.prototype.disposeSound);\n\n p5.prototype._checkFileFormats = function(paths) {\n var path;\n // if path is a single string, check to see if extension is provided\n if (typeof paths === 'string') {\n path = paths;\n // see if extension is provided\n var extTest = path.split('.').pop();\n // if an extension is provided...\n if (['mp3','wav','ogg', 'm4a', 'aac'].indexOf(extTest) > -1) {\n if (p5.prototype.isFileSupported(extTest)) {\n path = path;\n }\n else {\n var pathSplit = path.split('.');\n var pathCore = pathSplit[pathSplit.length - 1];\n for (var i = 0; i 1) {\n rightChannel = audioBuffer.getChannelData(1);\n } else {\n rightChannel = leftChannel;\n }\n\n var interleaved = interleave(leftChannel, rightChannel);\n\n // create the buffer and view to create the .WAV file\n var buffer = new window.ArrayBuffer(44 + interleaved.length * 2);\n var view = new window.DataView(buffer);\n\n // write the WAV container,\n // check spec at: https://web.archive.org/web/20171215131933/http://tiny.systems/software/soundProgrammer/WavFormatDocs.pdf\n\n // RIFF chunk descriptor\n writeUTFBytes(view, 0, 'RIFF');\n view.setUint32(4, 36 + interleaved.length * 2, true);\n writeUTFBytes(view, 8, 'WAVE');\n // FMT sub-chunk\n writeUTFBytes(view, 12, 'fmt ');\n view.setUint32(16, 16, true);\n view.setUint16(20, 1, true);\n // stereo (2 channels)\n view.setUint16(22, 2, true);\n view.setUint32(24, p5sound.audiocontext.sampleRate, true);\n view.setUint32(28, p5sound.audiocontext.sampleRate * 4, true);\n view.setUint16(32, 4, true);\n view.setUint16(34, 16, true);\n // data sub-chunk\n writeUTFBytes(view, 36, 'data');\n view.setUint32(40, interleaved.length * 2, true);\n\n // write the PCM samples\n var lng = interleaved.length;\n var index = 44;\n var volume = 1;\n for (var i = 0; i < lng; i++) {\n view.setInt16(index, interleaved[i] * (0x7FFF * volume), true);\n index += 2;\n }\n\n return view;\n }\n\n // helper methods to save waves\n function interleave(leftChannel, rightChannel) {\n var length = leftChannel.length + rightChannel.length;\n var result = new Float32Array(length);\n\n var inputIndex = 0;\n\n for (var index = 0; index < length;) {\n result[index++] = leftChannel[inputIndex];\n result[index++] = rightChannel[inputIndex];\n inputIndex++;\n }\n return result;\n }\n\n function writeUTFBytes(view, offset, string) {\n var lng = string.length;\n for (var i = 0; i < lng; i++) {\n view.setUint8(offset + i, string.charCodeAt(i));\n }\n }\n\n function safeBufferSize(idealBufferSize) {\n let bufferSize = idealBufferSize;\n\n // if the AudioWorkletNode is actually a ScriptProcessorNode created via polyfill,\n // make sure that our chosen buffer size isn't smaller than the buffer size automatically\n // selected by the polyfill\n // reference: https://github.com/GoogleChromeLabs/audioworklet-polyfill/issues/13#issuecomment-425014930\n let tempAudioWorkletNode = new AudioWorkletNode(p5sound.audiocontext, processorNames.soundFileProcessor);\n if (tempAudioWorkletNode instanceof ScriptProcessorNode) {\n bufferSize = tempAudioWorkletNode.bufferSize;\n }\n tempAudioWorkletNode.disconnect();\n tempAudioWorkletNode = null;\n\n return bufferSize;\n }\n\n return {\n convertToWav: convertToWav,\n midiToFreq: midiToFreq,\n noteToFreq: noteToFreq,\n safeBufferSize: safeBufferSize\n };\n\n});\n","define([\"Tone/core/Tone\", \"Tone/signal/Signal\", \"Tone/core/Gain\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Add a signal and a number or two signals. When no value is\n\t * passed into the constructor, Tone.Add will sum input[0]\n\t * and input[1]. If a value is passed into the constructor, \n\t * the it will be added to the input.\n\t * \n\t * @constructor\n\t * @extends {Tone.Signal}\n\t * @param {number=} value If no value is provided, Tone.Add will sum the first\n\t * and second inputs. \n\t * @example\n\t * var signal = new Tone.Signal(2);\n\t * var add = new Tone.Add(2);\n\t * signal.connect(add);\n\t * //the output of add equals 4\n\t * @example\n\t * //if constructed with no arguments\n\t * //it will add the first and second inputs\n\t * var add = new Tone.Add();\n\t * var sig0 = new Tone.Signal(3).connect(add, 0, 0);\n\t * var sig1 = new Tone.Signal(4).connect(add, 0, 1);\n\t * //the output of add equals 7. \n\t */\n\tTone.Add = function(value){\n\n\t\tthis.createInsOuts(2, 0);\n\n\t\t/**\n\t\t * the summing node\n\t\t * @type {GainNode}\n\t\t * @private\n\t\t */\n\t\tthis._sum = this.input[0] = this.input[1] = this.output = new Tone.Gain();\n\n\t\t/**\n\t\t * @private\n\t\t * @type {Tone.Signal}\n\t\t */\n\t\tthis._param = this.input[1] = new Tone.Signal(value);\n\n\t\tthis._param.connect(this._sum);\n\t};\n\n\tTone.extend(Tone.Add, Tone.Signal);\n\t\n\t/**\n\t * Clean up.\n\t * @returns {Tone.Add} this\n\t */\n\tTone.Add.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._sum.dispose();\n\t\tthis._sum = null;\n\t\tthis._param.dispose();\n\t\tthis._param = null;\n\t\treturn this;\n\t}; \n\n\treturn Tone.Add;\n});","define([\"Tone/core/Tone\", \"Tone/type/Time\", \"Tone/type/Frequency\", \"Tone/type/TransportTime\", \"Tone/core/Context\"],\nfunction (Tone) {\t\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tTYPES\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Units which a value can take on.\n\t * @enum {String}\n\t */\n\tTone.Type = {\n\t\t/** \n\t\t * Default units\n\t\t * @typedef {Default}\n\t\t */\n\t\tDefault : \"number\",\n\t\t/**\n\t\t * Time can be described in a number of ways. Read more [Time](https://github.com/Tonejs/Tone.js/wiki/Time).\n\t\t *\n\t\t * \n\t\t * \n\t\t * @typedef {Time}\n\t\t */\n\t\tTime : \"time\",\n\t\t/**\n\t\t * Frequency can be described similar to time, except ultimately the\n\t\t * values are converted to frequency instead of seconds. A number\n\t\t * is taken literally as the value in hertz. Additionally any of the \n\t\t * Time encodings can be used. Note names in the form\n\t\t * of NOTE OCTAVE (i.e. C4) are also accepted and converted to their\n\t\t * frequency value. \n\t\t * @typedef {Frequency}\n\t\t */\n\t\tFrequency : \"frequency\",\n\t\t/**\n\t\t * TransportTime describes a position along the Transport's timeline. It is\n\t\t * similar to Time in that it uses all the same encodings, but TransportTime specifically\n\t\t * pertains to the Transport's timeline, which is startable, stoppable, loopable, and seekable. \n\t\t * [Read more](https://github.com/Tonejs/Tone.js/wiki/TransportTime)\n\t\t * @typedef {TransportTime}\n\t\t */\n\t\tTransportTime : \"transportTime\",\n\t\t/** \n\t\t * Ticks are the basic subunit of the Transport. They are\n\t\t * the smallest unit of time that the Transport supports.\n\t\t * @typedef {Ticks}\n\t\t */\n\t\tTicks : \"ticks\",\n\t\t/** \n\t\t * Normal values are within the range [0, 1].\n\t\t * @typedef {NormalRange}\n\t\t */\n\t\tNormalRange : \"normalRange\",\n\t\t/** \n\t\t * AudioRange values are between [-1, 1].\n\t\t * @typedef {AudioRange}\n\t\t */\n\t\tAudioRange : \"audioRange\",\n\t\t/** \n\t\t * Decibels are a logarithmic unit of measurement which is useful for volume\n\t\t * because of the logarithmic way that we perceive loudness. 0 decibels \n\t\t * means no change in volume. -10db is approximately half as loud and 10db \n\t\t * is twice is loud. \n\t\t * @typedef {Decibels}\n\t\t */\n\t\tDecibels : \"db\",\n\t\t/** \n\t\t * Half-step note increments, i.e. 12 is an octave above the root. and 1 is a half-step up.\n\t\t * @typedef {Interval}\n\t\t */\n\t\tInterval : \"interval\",\n\t\t/** \n\t\t * Beats per minute. \n\t\t * @typedef {BPM}\n\t\t */\n\t\tBPM : \"bpm\",\n\t\t/** \n\t\t * The value must be greater than or equal to 0.\n\t\t * @typedef {Positive}\n\t\t */\n\t\tPositive : \"positive\",\n\t\t/** \n\t\t * A cent is a hundredth of a semitone. \n\t\t * @typedef {Cents}\n\t\t */\n\t\tCents : \"cents\",\n\t\t/** \n\t\t * Angle between 0 and 360. \n\t\t * @typedef {Degrees}\n\t\t */\n\t\tDegrees : \"degrees\",\n\t\t/** \n\t\t * A number representing a midi note.\n\t\t * @typedef {MIDI}\n\t\t */\n\t\tMIDI : \"midi\",\n\t\t/** \n\t\t * A colon-separated representation of time in the form of\n\t\t * Bars:Beats:Sixteenths. \n\t\t * @typedef {BarsBeatsSixteenths}\n\t\t */\n\t\tBarsBeatsSixteenths : \"barsBeatsSixteenths\",\n\t\t/** \n\t\t * Sampling is the reduction of a continuous signal to a discrete signal.\n\t\t * Audio is typically sampled 44100 times per second. \n\t\t * @typedef {Samples}\n\t\t */\n\t\tSamples : \"samples\",\n\t\t/** \n\t\t * Hertz are a frequency representation defined as one cycle per second.\n\t\t * @typedef {Hertz}\n\t\t */\n\t\tHertz : \"hertz\",\n\t\t/** \n\t\t * A frequency represented by a letter name, \n\t\t * accidental and octave. This system is known as\n\t\t * [Scientific Pitch Notation](https://en.wikipedia.org/wiki/Scientific_pitch_notation).\n\t\t * @typedef {Note}\n\t\t */\n\t\tNote : \"note\",\n\t\t/** \n\t\t * One millisecond is a thousandth of a second. \n\t\t * @typedef {Milliseconds}\n\t\t */\n\t\tMilliseconds : \"milliseconds\",\n\t\t/** \n\t\t * Seconds are the time unit of the AudioContext. In the end, \n\t\t * all values need to be evaluated to seconds. \n\t\t * @typedef {Seconds}\n\t\t */\n\t\tSeconds : \"seconds\",\n\t\t/** \n\t\t * A string representing a duration relative to a measure. \n\t\t * \n\t\t * @typedef {Notation}\n\t\t */\n\t\tNotation : \"notation\",\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t// AUGMENT TONE's PROTOTYPE\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Convert Time into seconds.\n\t * \n\t * Unlike the method which it overrides, this takes into account \n\t * transporttime and musical notation.\n\t *\n\t * Time : 1.40\n\t * Notation: 4n|1m|2t\n\t * Now Relative: +3n\n\t * Math: 3n+16n or even complicated expressions ((3n*2)/6 + 1)\n\t *\n\t * @param {Time} time \n\t * @return {Seconds} \n\t */\n\tTone.prototype.toSeconds = function(time){\n\t\tif (this.isNumber(time)){\n\t\t\treturn time;\n\t\t} else if (this.isUndef(time)){\n\t\t\treturn this.now();\t\t\t\n\t\t} else if (this.isString(time)){\n\t\t\treturn (new Tone.Time(time)).toSeconds();\n\t\t} else if (time instanceof Tone.TimeBase){\n\t\t\treturn time.toSeconds();\n\t\t}\n\t};\n\n\t/**\n\t * Convert a frequency representation into a number.\n\t * @param {Frequency} freq \n\t * @return {Hertz} the frequency in hertz\n\t */\n\tTone.prototype.toFrequency = function(freq){\n\t\tif (this.isNumber(freq)){\n\t\t\treturn freq;\n\t\t} else if (this.isString(freq) || this.isUndef(freq)){\n\t\t\treturn (new Tone.Frequency(freq)).valueOf();\n\t\t} else if (freq instanceof Tone.TimeBase){\n\t\t\treturn freq.toFrequency();\n\t\t}\n\t};\n\n\t/**\n\t * Convert a time representation into ticks.\n\t * @param {Time} time\n\t * @return {Ticks} the time in ticks\n\t */\n\tTone.prototype.toTicks = function(time){\n\t\tif (this.isNumber(time) || this.isString(time)){\n\t\t\treturn (new Tone.TransportTime(time)).toTicks();\n\t\t} else if (this.isUndef(time)){\n\t\t\treturn Tone.Transport.ticks;\t\t\t\n\t\t} else if (time instanceof Tone.TimeBase){\n\t\t\treturn time.toTicks();\n\t\t}\n\t};\n\n\treturn Tone;\n});","define([\"Tone/core/Tone\", \"Tone/core/Param\", \"Tone/type/Type\"], function (Tone) {\n\n\t\"use strict\";\n\n\t/**\n\t * createGain shim\n\t * @private\n\t */\n\tif (window.GainNode && !AudioContext.prototype.createGain){\n\t\tAudioContext.prototype.createGain = AudioContext.prototype.createGainNode;\n\t}\n\n\t/**\n\t * @class A thin wrapper around the Native Web Audio GainNode.\n\t * The GainNode is a basic building block of the Web Audio\n\t * API and is useful for routing audio and adjusting gains. \n\t * @extends {Tone}\n\t * @param {Number=} gain The initial gain of the GainNode\n\t * @param {Tone.Type=} units The units of the gain parameter. \n\t */\n\tTone.Gain = function(){\n\n\t\tvar options = this.optionsObject(arguments, [\"gain\", \"units\"], Tone.Gain.defaults);\n\n\t\t/**\n\t\t * The GainNode\n\t\t * @type {GainNode}\n\t\t * @private\n\t\t */\n\t\tthis.input = this.output = this._gainNode = this.context.createGain();\n\n\t\t/**\n\t\t * The gain parameter of the gain node.\n\t\t * @type {Tone.Param}\n\t\t * @signal\n\t\t */\n\t\tthis.gain = new Tone.Param({\n\t\t\t\"param\" : this._gainNode.gain, \n\t\t\t\"units\" : options.units,\n\t\t\t\"value\" : options.gain,\n\t\t\t\"convert\" : options.convert\n\t\t});\n\t\tthis._readOnly(\"gain\");\n\t};\n\n\tTone.extend(Tone.Gain);\n\n\t/**\n\t * The defaults\n\t * @const\n\t * @type {Object}\n\t */\n\tTone.Gain.defaults = {\n\t\t\"gain\" : 1,\n\t\t\"convert\" : true,\n\t};\n\n\t/**\n\t * Clean up.\n\t * @return {Tone.Gain} this\n\t */\n\tTone.Gain.prototype.dispose = function(){\n\t\tTone.Param.prototype.dispose.call(this);\n\t\tthis._gainNode.disconnect();\n\t\tthis._gainNode = null;\n\t\tthis._writable(\"gain\");\n\t\tthis.gain.dispose();\n\t\tthis.gain = null;\n\t};\n\n\t//STATIC///////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Create input and outputs for this object.\n\t * @param {Number} input The number of inputs\n\t * @param {Number=} outputs The number of outputs\n\t * @return {Tone} this\n\t * @internal\n\t */\n\tTone.prototype.createInsOuts = function(inputs, outputs){\n\n\t\tif (inputs === 1){\n\t\t\tthis.input = new Tone.Gain();\n\t\t} else if (inputs > 1){\n\t\t\tthis.input = new Array(inputs);\n\t\t}\n\n\t\tif (outputs === 1){\n\t\t\tthis.output = new Tone.Gain();\n\t\t} else if (outputs > 1){\n\t\t\tthis.output = new Array(inputs);\n\t\t}\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\n\treturn Tone.Gain;\n});","module.exports = {\n recorderProcessor: 'recorder-processor',\n soundFileProcessor: 'sound-file-processor',\n amplitudeProcessor: 'amplitude-processor'\n};\n","'use strict';\n\ndefine(function () {\n /*\n Helper function to generate an error\n with a custom stack trace that points to the sketch\n and removes other parts of the stack trace.\n\n @private\n @class customError\n @constructor\n @param {String} name custom error name\n @param {String} errorTrace custom error trace\n @param {String} failedPath path to the file that failed to load\n @property {String} name custom error name\n @property {String} message custom error message\n @property {String} stack trace the error back to a line in the user's sketch.\n Note: this edits out stack trace within p5.js and p5.sound.\n @property {String} originalStack unedited, original stack trace\n @property {String} failedPath path to the file that failed to load\n @return {Error} returns a custom Error object\n */\n var CustomError = function(name, errorTrace, failedPath) {\n var err = new Error();\n var tempStack, splitStack;\n\n err.name = name;\n err.originalStack = err.stack + errorTrace;\n tempStack = err.stack + errorTrace;\n err.failedPath = failedPath;\n\n // only print the part of the stack trace that refers to the user code:\n var splitStack = tempStack.split('\\n');\n splitStack = splitStack.filter(function(ln) {\n return !ln.match(/(p5.|native code|globalInit)/g);\n });\n err.stack = splitStack.join('\\n');\n\n return err; // TODO: is this really a constructor?\n };\n\n return CustomError;\n});\n","define([\"Tone/core/Tone\", \"Tone/core/Emitter\"], function (Tone) {\n\n\t/**\n\t * shim\n\t * @private\n\t */\n\tif (!window.hasOwnProperty(\"AudioContext\") && window.hasOwnProperty(\"webkitAudioContext\")){\n\t\twindow.AudioContext = window.webkitAudioContext;\n\t}\n\n\t/**\n\t * @class Wrapper around the native AudioContext.\n\t * @extends {Tone.Emitter}\n\t * @param {AudioContext=} context optionally pass in a context\n\t */\n\tTone.Context = function(context){\n\n\t\tTone.Emitter.call(this);\n\n\t\tif (!context){\n\t\t\tcontext = new window.AudioContext();\n\t\t}\n\t\tthis._context = context;\n\t\t// extend all of the methods\n\t\tfor (var prop in this._context){\n\t\t\tthis._defineProperty(this._context, prop);\n\t\t}\n\n\t\t///////////////////////////////////////////////////////////////////////\n\t\t// WORKER\n\t\t///////////////////////////////////////////////////////////////////////\n\n\t\t/**\n\t\t * The default latency hint\n\t\t * @type {String}\n\t\t * @private\n\t\t */\n\t\tthis._latencyHint = \"interactive\";\n\n\t\t/**\n\t\t * The amount of time events are scheduled\n\t\t * into the future\n\t\t * @type {Number}\n\t\t * @private\n\t\t */\n\t\tthis._lookAhead = 0.1;\n\n\t\t/**\n\t\t * How often the update look runs\n\t\t * @type {Number}\n\t\t * @private\n\t\t */\n\t\tthis._updateInterval = this._lookAhead/3;\n\n\t\t/**\n\t\t * A reference to the actual computed update interval\n\t\t * @type {Number}\n\t\t * @private\n\t\t */\n\t\tthis._computedUpdateInterval = 0;\n\n\t\t/**\n\t\t * The web worker which is used to update Tone.Clock\n\t\t * @private\n\t\t * @type {WebWorker}\n\t\t */\n\t\tthis._worker = this._createWorker();\n\n\t\t/**\n\t\t * An object containing all of the constants AudioBufferSourceNodes\n\t\t * @type {Object}\n\t\t * @private\n\t\t */\n\t\tthis._constants = {};\n\n\t};\n\n\tTone.extend(Tone.Context, Tone.Emitter);\n\tTone.Emitter.mixin(Tone.Context);\n\n\t/**\n\t * Define a property on this Tone.Context. \n\t * This is used to extend the native AudioContext\n\t * @param {AudioContext} context\n\t * @param {String} prop \n\t * @private\n\t */\n\tTone.Context.prototype._defineProperty = function(context, prop){\n\t\tif (this.isUndef(this[prop])){\n\t\t\tObject.defineProperty(this, prop, {\n\t\t\t\tget : function(){\n\t\t\t\t\tif (typeof context[prop] === \"function\"){\n\t\t\t\t\t\treturn context[prop].bind(context);\n\t\t\t\t\t} else {\n\t\t\t\t\t\treturn context[prop];\n\t\t\t\t\t}\n\t\t\t\t},\n\t\t\t\tset : function(val){\n\t\t\t\t\tcontext[prop] = val;\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\t};\n\n\t/**\n\t * The current audio context time\n\t * @return {Number}\n\t */\n\tTone.Context.prototype.now = function(){\n\t\treturn this._context.currentTime;\n\t};\n\n\t/**\n\t * Generate a web worker\n\t * @return {WebWorker}\n\t * @private\n\t */\n\tTone.Context.prototype._createWorker = function(){\n\t\t\n\t\t//URL Shim\n\t\twindow.URL = window.URL || window.webkitURL;\n\n\t\tvar blob = new Blob([\n\t\t\t//the initial timeout time\n\t\t\t\"var timeoutTime = \"+(this._updateInterval * 1000).toFixed(1)+\";\" +\n\t\t\t//onmessage callback\n\t\t\t\"self.onmessage = function(msg){\" +\n\t\t\t\"\ttimeoutTime = parseInt(msg.data);\" + \n\t\t\t\"};\" + \n\t\t\t//the tick function which posts a message\n\t\t\t//and schedules a new tick\n\t\t\t\"function tick(){\" +\n\t\t\t\"\tsetTimeout(tick, timeoutTime);\" +\n\t\t\t\"\tself.postMessage('tick');\" +\n\t\t\t\"}\" +\n\t\t\t//call tick initially\n\t\t\t\"tick();\"\n\t\t]);\n\t\tvar blobUrl = URL.createObjectURL(blob);\n\t\tvar worker = new Worker(blobUrl);\n\n\t\tworker.addEventListener(\"message\", function(){\n\t\t\t// tick the clock\n\t\t\tthis.emit(\"tick\");\n\t\t}.bind(this));\n\n\t\t//lag compensation\n\t\tworker.addEventListener(\"message\", function(){\n\t\t\tvar now = this.now();\n\t\t\tif (this.isNumber(this._lastUpdate)){\n\t\t\t\tvar diff = now - this._lastUpdate;\n\t\t\t\tthis._computedUpdateInterval = Math.max(diff, this._computedUpdateInterval * 0.97);\n\t\t\t}\n\t\t\tthis._lastUpdate = now;\n\t\t}.bind(this));\n\n\t\treturn worker;\n\t};\n\n\t/**\n\t * Generate a looped buffer at some constant value.\n\t * @param {Number} val\n\t * @return {BufferSourceNode}\n\t */\n\tTone.Context.prototype.getConstant = function(val){\n\t\tif (this._constants[val]){\n\t\t\treturn this._constants[val];\n\t\t} else {\n\t\t\tvar buffer = this._context.createBuffer(1, 128, this._context.sampleRate);\n\t\t\tvar arr = buffer.getChannelData(0);\n\t\t\tfor (var i = 0; i < arr.length; i++){\n\t\t\t\tarr[i] = val;\n\t\t\t}\n\t\t\tvar constant = this._context.createBufferSource();\n\t\t\tconstant.channelCount = 1;\n\t\t\tconstant.channelCountMode = \"explicit\";\n\t\t\tconstant.buffer = buffer;\n\t\t\tconstant.loop = true;\n\t\t\tconstant.start(0);\n\t\t\tthis._constants[val] = constant;\n\t\t\treturn constant;\n\t\t}\n\t};\n\n\t/**\n\t * This is the time that the clock is falling behind\n\t * the scheduled update interval. The Context automatically\n\t * adjusts for the lag and schedules further in advance.\n\t * @type {Number}\n\t * @memberOf Tone.Context\n\t * @name lag\n\t * @static\n\t * @readOnly\n\t */\n\tObject.defineProperty(Tone.Context.prototype, \"lag\", {\n\t\tget : function(){\n\t\t\tvar diff = this._computedUpdateInterval - this._updateInterval;\n\t\t\tdiff = Math.max(diff, 0);\n\t\t\treturn diff;\n\t\t}\n\t});\n\n\t/**\n\t * The amount of time in advance that events are scheduled.\n\t * The lookAhead will adjust slightly in response to the \n\t * measured update time to try to avoid clicks.\n\t * @type {Number}\n\t * @memberOf Tone.Context\n\t * @name lookAhead\n\t * @static\n\t */\n\tObject.defineProperty(Tone.Context.prototype, \"lookAhead\", {\n\t\tget : function(){\n\t\t\treturn this._lookAhead;\n\t\t},\n\t\tset : function(lA){\n\t\t\tthis._lookAhead = lA;\n\t\t}\n\t});\n\n\t/**\n\t * How often the Web Worker callback is invoked.\n\t * This number corresponds to how responsive the scheduling\n\t * can be. Context.updateInterval + Context.lookAhead gives you the\n\t * total latency between scheduling an event and hearing it.\n\t * @type {Number}\n\t * @memberOf Tone.Context\n\t * @name updateInterval\n\t * @static\n\t */\n\tObject.defineProperty(Tone.Context.prototype, \"updateInterval\", {\n\t\tget : function(){\n\t\t\treturn this._updateInterval;\n\t\t},\n\t\tset : function(interval){\n\t\t\tthis._updateInterval = Math.max(interval, Tone.prototype.blockTime);\n\t\t\tthis._worker.postMessage(Math.max(interval * 1000, 1));\n\t\t}\n\t});\n\n\t/**\n\t * The type of playback, which affects tradeoffs between audio \n\t * output latency and responsiveness. \n\t * \n\t * In addition to setting the value in seconds, the latencyHint also\n\t * accepts the strings \"interactive\" (prioritizes low latency), \n\t * \"playback\" (prioritizes sustained playback), \"balanced\" (balances\n\t * latency and performance), and \"fastest\" (lowest latency, might glitch more often). \n\t * @type {String|Seconds}\n\t * @memberOf Tone.Context#\n\t * @name latencyHint\n\t * @static\n\t * @example\n\t * //set the lookAhead to 0.3 seconds\n\t * Tone.context.latencyHint = 0.3;\n\t */\n\tObject.defineProperty(Tone.Context.prototype, \"latencyHint\", {\n\t\tget : function(){\n\t\t\treturn this._latencyHint;\n\t\t},\n\t\tset : function(hint){\n\t\t\tvar lookAhead = hint;\n\t\t\tthis._latencyHint = hint;\n\t\t\tif (this.isString(hint)){\n\t\t\t\tswitch(hint){\n\t\t\t\t\tcase \"interactive\" :\n\t\t\t\t\t\tlookAhead = 0.1;\n\t\t\t\t\t\tthis._context.latencyHint = hint;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase \"playback\" :\n\t\t\t\t\t\tlookAhead = 0.8;\n\t\t\t\t\t\tthis._context.latencyHint = hint;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase \"balanced\" :\n\t\t\t\t\t\tlookAhead = 0.25;\n\t\t\t\t\t\tthis._context.latencyHint = hint;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase \"fastest\" :\n\t\t\t\t\t\tlookAhead = 0.01;\n\t\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis.lookAhead = lookAhead;\n\t\t\tthis.updateInterval = lookAhead/3;\n\t\t}\n\t});\n\n\t/**\n\t * Shim all connect/disconnect and some deprecated methods which are still in\n\t * some older implementations.\n\t * @private\n\t */\n\tfunction shimConnect(){\n\n\t\tvar nativeConnect = AudioNode.prototype.connect;\n\t\tvar nativeDisconnect = AudioNode.prototype.disconnect;\n\n\t\t//replace the old connect method\n\t\tfunction toneConnect(B, outNum, inNum){\n\t\t\tif (B.input){\n\t\t\t\tif (Array.isArray(B.input)){\n\t\t\t\t\tif (Tone.prototype.isUndef(inNum)){\n\t\t\t\t\t\tinNum = 0;\n\t\t\t\t\t}\n\t\t\t\t\tthis.connect(B.input[inNum]);\n\t\t\t\t} else {\n\t\t\t\t\tthis.connect(B.input, outNum, inNum);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\ttry {\n\t\t\t\t\tif (B instanceof AudioNode){\n\t\t\t\t\t\tnativeConnect.call(this, B, outNum, inNum);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tnativeConnect.call(this, B, outNum);\n\t\t\t\t\t}\n\t\t\t\t} catch (e) {\n\t\t\t\t\tthrow new Error(\"error connecting to node: \"+B+\"\\n\"+e);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t//replace the old disconnect method\n\t\tfunction toneDisconnect(B, outNum, inNum){\n\t\t\tif (B && B.input && Array.isArray(B.input)){\n\t\t\t\tif (Tone.prototype.isUndef(inNum)){\n\t\t\t\t\tinNum = 0;\n\t\t\t\t}\n\t\t\t\tthis.disconnect(B.input[inNum], outNum, inNum);\n\t\t\t} else if (B && B.input){\n\t\t\t\tthis.disconnect(B.input, outNum, inNum);\n\t\t\t} else {\n\t\t\t\ttry {\n\t\t\t\t\tnativeDisconnect.apply(this, arguments);\n\t\t\t\t} catch (e) {\n\t\t\t\t\tthrow new Error(\"error disconnecting node: \"+B+\"\\n\"+e);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif (AudioNode.prototype.connect !== toneConnect){\n\t\t\tAudioNode.prototype.connect = toneConnect;\n\t\t\tAudioNode.prototype.disconnect = toneDisconnect;\n\t\t}\n\t}\n\n\t// set the audio context initially\n\tif (Tone.supported){\n\t\tshimConnect();\n\t\tTone.context = new Tone.Context();\n\t} else {\n\t\tconsole.warn(\"This browser does not support Tone.js\");\n\t}\n\n\treturn Tone.Context;\n});","define([\"Tone/core/Tone\", \"Tone/signal/Add\", \"Tone/signal/Multiply\", \"Tone/signal/Signal\"], function(Tone){\n\n\t\"use strict\";\n\t\n\t/**\n\t * @class Performs a linear scaling on an input signal.\n\t * Scales a NormalRange input to between\n\t * outputMin and outputMax.\n\t *\n\t * @constructor\n\t * @extends {Tone.SignalBase}\n\t * @param {number} [outputMin=0] The output value when the input is 0. \n\t * @param {number} [outputMax=1]\tThe output value when the input is 1. \n\t * @example\n\t * var scale = new Tone.Scale(50, 100);\n\t * var signal = new Tone.Signal(0.5).connect(scale);\n\t * //the output of scale equals 75\n\t */\n\tTone.Scale = function(outputMin, outputMax){\n\n\t\t/** \n\t\t * @private\n\t\t * @type {number}\n\t\t */\n\t\tthis._outputMin = this.defaultArg(outputMin, 0);\n\n\t\t/** \n\t\t * @private\n\t\t * @type {number}\n\t\t */\n\t\tthis._outputMax = this.defaultArg(outputMax, 1);\n\n\n\t\t/** \n\t\t * @private\n\t\t * @type {Tone.Multiply}\n\t\t * @private\n\t\t */\n\t\tthis._scale = this.input = new Tone.Multiply(1);\n\t\t\n\t\t/** \n\t\t * @private\n\t\t * @type {Tone.Add}\n\t\t * @private\n\t\t */\n\t\tthis._add = this.output = new Tone.Add(0);\n\n\t\tthis._scale.connect(this._add);\n\t\tthis._setRange();\n\t};\n\n\tTone.extend(Tone.Scale, Tone.SignalBase);\n\n\t/**\n\t * The minimum output value. This number is output when \n\t * the value input value is 0. \n\t * @memberOf Tone.Scale#\n\t * @type {number}\n\t * @name min\n\t */\n\tObject.defineProperty(Tone.Scale.prototype, \"min\", {\n\t\tget : function(){\n\t\t\treturn this._outputMin;\n\t\t},\n\t\tset : function(min){\n\t\t\tthis._outputMin = min;\n\t\t\tthis._setRange();\n\t\t}\n\t});\n\n\t/**\n\t * The maximum output value. This number is output when \n\t * the value input value is 1. \n\t * @memberOf Tone.Scale#\n\t * @type {number}\n\t * @name max\n\t */\n\tObject.defineProperty(Tone.Scale.prototype, \"max\", {\n\t\tget : function(){\n\t\t\treturn this._outputMax;\n\t\t},\n\t\tset : function(max){\n\t\t\tthis._outputMax = max;\n\t\t\tthis._setRange();\n\t\t}\n\t});\n\n\t/**\n\t * set the values\n\t * @private\n\t */\n\tTone.Scale.prototype._setRange = function() {\n\t\tthis._add.value = this._outputMin;\n\t\tthis._scale.value = this._outputMax - this._outputMin;\n\t};\n\n\t/**\n\t * Clean up.\n\t * @returns {Tone.Scale} this\n\t */\n\tTone.Scale.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._add.dispose();\n\t\tthis._add = null;\n\t\tthis._scale.dispose();\n\t\tthis._scale = null;\n\t\treturn this;\n\t}; \n\n\treturn Tone.Scale;\n});\n","define([\"Tone/core/Tone\", \"Tone/signal/Signal\", \"Tone/core/Timeline\"], function (Tone) {\n\n\t\"use strict\";\n\n\t/**\n\t * @class A signal which adds the method getValueAtTime. \n\t * Code and inspiration from https://github.com/jsantell/web-audio-automation-timeline\n\t * @extends {Tone.Param}\n\t * @param {Number=} value The initial value of the signal\n\t * @param {String=} units The conversion units of the signal.\n\t */\n\tTone.TimelineSignal = function(){\n\n\t\tvar options = this.optionsObject(arguments, [\"value\", \"units\"], Tone.Signal.defaults);\n\t\t\n\t\t/**\n\t\t * The scheduled events\n\t\t * @type {Tone.Timeline}\n\t\t * @private\n\t\t */\n\t\tthis._events = new Tone.Timeline(10);\n\n\t\t//constructors\n\t\tTone.Signal.apply(this, options);\n\t\toptions.param = this._param;\n\t\tTone.Param.call(this, options);\n\n\t\t/**\n\t\t * The initial scheduled value\n\t\t * @type {Number}\n\t\t * @private\n\t\t */\n\t\tthis._initial = this._fromUnits(this._param.value);\n\t};\n\n\tTone.extend(Tone.TimelineSignal, Tone.Param);\n\n\t/**\n\t * The event types of a schedulable signal.\n\t * @enum {String}\n\t * @private\n\t */\n\tTone.TimelineSignal.Type = {\n\t\tLinear : \"linear\",\n\t\tExponential : \"exponential\",\n\t\tTarget : \"target\",\n\t\tCurve : \"curve\",\n\t\tSet : \"set\"\n\t};\n\n\t/**\n\t * The current value of the signal. \n\t * @memberOf Tone.TimelineSignal#\n\t * @type {Number}\n\t * @name value\n\t */\n\tObject.defineProperty(Tone.TimelineSignal.prototype, \"value\", {\n\t\tget : function(){\n\t\t\tvar now = this.now();\n\t\t\tvar val = this.getValueAtTime(now);\n\t\t\treturn this._toUnits(val);\n\t\t},\n\t\tset : function(value){\n\t\t\tvar convertedVal = this._fromUnits(value);\n\t\t\tthis._initial = convertedVal;\n\t\t\tthis.cancelScheduledValues();\n\t\t\tthis._param.value = convertedVal;\n\t\t}\n\t});\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tSCHEDULING\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Schedules a parameter value change at the given time.\n\t * @param {*}\tvalue The value to set the signal.\n\t * @param {Time} time The time when the change should occur.\n\t * @returns {Tone.TimelineSignal} this\n\t * @example\n\t * //set the frequency to \"G4\" in exactly 1 second from now. \n\t * freq.setValueAtTime(\"G4\", \"+1\");\n\t */\n\tTone.TimelineSignal.prototype.setValueAtTime = function (value, startTime) {\n\t\tvalue = this._fromUnits(value);\n\t\tstartTime = this.toSeconds(startTime);\n\t\tthis._events.add({\n\t\t\t\"type\" : Tone.TimelineSignal.Type.Set,\n\t\t\t\"value\" : value,\n\t\t\t\"time\" : startTime\n\t\t});\n\t\t//invoke the original event\n\t\tthis._param.setValueAtTime(value, startTime);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Schedules a linear continuous change in parameter value from the \n\t * previous scheduled parameter value to the given value.\n\t * \n\t * @param {number} value \n\t * @param {Time} endTime \n\t * @returns {Tone.TimelineSignal} this\n\t */\n\tTone.TimelineSignal.prototype.linearRampToValueAtTime = function (value, endTime) {\n\t\tvalue = this._fromUnits(value);\n\t\tendTime = this.toSeconds(endTime);\n\t\tthis._events.add({\n\t\t\t\"type\" : Tone.TimelineSignal.Type.Linear,\n\t\t\t\"value\" : value,\n\t\t\t\"time\" : endTime\n\t\t});\n\t\tthis._param.linearRampToValueAtTime(value, endTime);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Schedules an exponential continuous change in parameter value from \n\t * the previous scheduled parameter value to the given value.\n\t * \n\t * @param {number} value \n\t * @param {Time} endTime \n\t * @returns {Tone.TimelineSignal} this\n\t */\n\tTone.TimelineSignal.prototype.exponentialRampToValueAtTime = function (value, endTime) {\n\t\t//get the previous event and make sure it's not starting from 0\n\t\tendTime = this.toSeconds(endTime);\n\t\tvar beforeEvent = this._searchBefore(endTime);\n\t\tif (beforeEvent && beforeEvent.value === 0){\n\t\t\t//reschedule that event\n\t\t\tthis.setValueAtTime(this._minOutput, beforeEvent.time);\n\t\t}\n\t\tvalue = this._fromUnits(value);\n\t\tvar setValue = Math.max(value, this._minOutput);\n\t\tthis._events.add({\n\t\t\t\"type\" : Tone.TimelineSignal.Type.Exponential,\n\t\t\t\"value\" : setValue,\n\t\t\t\"time\" : endTime\n\t\t});\n\t\t//if the ramped to value is 0, make it go to the min output, and then set to 0.\n\t\tif (value < this._minOutput){\n\t\t\tthis._param.exponentialRampToValueAtTime(this._minOutput, endTime - this.sampleTime);\n\t\t\tthis.setValueAtTime(0, endTime);\n\t\t} else {\n\t\t\tthis._param.exponentialRampToValueAtTime(value, endTime);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Start exponentially approaching the target value at the given time with\n\t * a rate having the given time constant.\n\t * @param {number} value \n\t * @param {Time} startTime \n\t * @param {number} timeConstant \n\t * @returns {Tone.TimelineSignal} this \n\t */\n\tTone.TimelineSignal.prototype.setTargetAtTime = function (value, startTime, timeConstant) {\n\t\tvalue = this._fromUnits(value);\n\t\tvalue = Math.max(this._minOutput, value);\n\t\ttimeConstant = Math.max(this._minOutput, timeConstant);\n\t\tstartTime = this.toSeconds(startTime);\n\t\tthis._events.add({\n\t\t\t\"type\" : Tone.TimelineSignal.Type.Target,\n\t\t\t\"value\" : value,\n\t\t\t\"time\" : startTime,\n\t\t\t\"constant\" : timeConstant\n\t\t});\n\t\tthis._param.setTargetAtTime(value, startTime, timeConstant);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Set an array of arbitrary values starting at the given time for the given duration.\n\t * @param {Float32Array} values \n\t * @param {Time} startTime \n\t * @param {Time} duration\n\t * @param {NormalRange} [scaling=1] If the values in the curve should be scaled by some value\n\t * @returns {Tone.TimelineSignal} this \n\t */\n\tTone.TimelineSignal.prototype.setValueCurveAtTime = function (values, startTime, duration, scaling) {\n\t\tscaling = this.defaultArg(scaling, 1);\n\t\t//copy the array\n\t\tvar floats = new Array(values.length);\n\t\tfor (var i = 0; i < floats.length; i++){\n\t\t\tfloats[i] = this._fromUnits(values[i]) * scaling;\n\t\t}\n\t\tstartTime = this.toSeconds(startTime);\n\t\tduration = this.toSeconds(duration);\n\t\tthis._events.add({\n\t\t\t\"type\" : Tone.TimelineSignal.Type.Curve,\n\t\t\t\"value\" : floats,\n\t\t\t\"time\" : startTime,\n\t\t\t\"duration\" : duration\n\t\t});\n\t\t//set the first value\n\t\tthis._param.setValueAtTime(floats[0], startTime);\n\t\t//schedule a lienar ramp for each of the segments\n\t\tfor (var j = 1; j < floats.length; j++){\n\t\t\tvar segmentTime = startTime + (j / (floats.length - 1) * duration);\n\t\t\tthis._param.linearRampToValueAtTime(floats[j], segmentTime);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Cancels all scheduled parameter changes with times greater than or \n\t * equal to startTime.\n\t * \n\t * @param {Time} startTime\n\t * @returns {Tone.TimelineSignal} this\n\t */\n\tTone.TimelineSignal.prototype.cancelScheduledValues = function (after) {\n\t\tafter = this.toSeconds(after);\n\t\tthis._events.cancel(after);\n\t\tthis._param.cancelScheduledValues(after);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Sets the computed value at the given time. This provides\n\t * a point from which a linear or exponential curve\n\t * can be scheduled after. Will cancel events after \n\t * the given time and shorten the currently scheduled\n\t * linear or exponential ramp so that it ends at `time` .\n\t * This is to avoid discontinuities and clicks in envelopes. \n\t * @param {Time} time When to set the ramp point\n\t * @returns {Tone.TimelineSignal} this\n\t */\n\tTone.TimelineSignal.prototype.setRampPoint = function (time) {\n\t\ttime = this.toSeconds(time);\n\t\t//get the value at the given time\n\t\tvar val = this._toUnits(this.getValueAtTime(time));\n\t\t//if there is an event at the given time\n\t\t//and that even is not a \"set\"\n\t\tvar before = this._searchBefore(time);\n\t\tif (before && before.time === time){\n\t\t\t//remove everything after\n\t\t\tthis.cancelScheduledValues(time + this.sampleTime);\n\t\t} else if (before && \n\t\t\t\t before.type === Tone.TimelineSignal.Type.Curve &&\n\t\t\t\t before.time + before.duration > time){\n\t\t\t//if the curve is still playing\n\t\t\t//cancel the curve\n\t\t\tthis.cancelScheduledValues(time);\n\t\t\tthis.linearRampToValueAtTime(val, time);\n\t\t} else {\n\t\t\t//reschedule the next event to end at the given time\n\t\t\tvar after = this._searchAfter(time);\n\t\t\tif (after){\n\t\t\t\t//cancel the next event(s)\n\t\t\t\tthis.cancelScheduledValues(time);\n\t\t\t\tif (after.type === Tone.TimelineSignal.Type.Linear){\n\t\t\t\t\tthis.linearRampToValueAtTime(val, time);\n\t\t\t\t} else if (after.type === Tone.TimelineSignal.Type.Exponential){\n\t\t\t\t\tthis.exponentialRampToValueAtTime(val, time);\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis.setValueAtTime(val, time);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Do a linear ramp to the given value between the start and finish times.\n\t * @param {Number} value The value to ramp to.\n\t * @param {Time} start The beginning anchor point to do the linear ramp\n\t * @param {Time} finish The ending anchor point by which the value of\n\t * the signal will equal the given value.\n\t * @returns {Tone.TimelineSignal} this\n\t */\n\tTone.TimelineSignal.prototype.linearRampToValueBetween = function (value, start, finish) {\n\t\tthis.setRampPoint(start);\n\t\tthis.linearRampToValueAtTime(value, finish);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Do a exponential ramp to the given value between the start and finish times.\n\t * @param {Number} value The value to ramp to.\n\t * @param {Time} start The beginning anchor point to do the exponential ramp\n\t * @param {Time} finish The ending anchor point by which the value of\n\t * the signal will equal the given value.\n\t * @returns {Tone.TimelineSignal} this\n\t */\n\tTone.TimelineSignal.prototype.exponentialRampToValueBetween = function (value, start, finish) {\n\t\tthis.setRampPoint(start);\n\t\tthis.exponentialRampToValueAtTime(value, finish);\n\t\treturn this;\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tGETTING SCHEDULED VALUES\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Returns the value before or equal to the given time\n\t * @param {Number} time The time to query\n\t * @return {Object} The event at or before the given time.\n\t * @private\n\t */\n\tTone.TimelineSignal.prototype._searchBefore = function(time){\n\t\treturn this._events.get(time);\n\t};\n\n\t/**\n\t * The event after the given time\n\t * @param {Number} time The time to query.\n\t * @return {Object} The next event after the given time\n\t * @private\n\t */\n\tTone.TimelineSignal.prototype._searchAfter = function(time){\n\t\treturn this._events.getAfter(time);\n\t};\n\n\t/**\n\t * Get the scheduled value at the given time. This will\n\t * return the unconverted (raw) value.\n\t * @param {Number} time The time in seconds.\n\t * @return {Number} The scheduled value at the given time.\n\t */\n\tTone.TimelineSignal.prototype.getValueAtTime = function(time){\n\t\ttime = this.toSeconds(time);\n\t\tvar after = this._searchAfter(time);\n\t\tvar before = this._searchBefore(time);\n\t\tvar value = this._initial;\n\t\t//if it was set by\n\t\tif (before === null){\n\t\t\tvalue = this._initial;\n\t\t} else if (before.type === Tone.TimelineSignal.Type.Target){\n\t\t\tvar previous = this._events.getBefore(before.time);\n\t\t\tvar previouVal;\n\t\t\tif (previous === null){\n\t\t\t\tpreviouVal = this._initial;\n\t\t\t} else {\n\t\t\t\tpreviouVal = previous.value;\n\t\t\t}\n\t\t\tvalue = this._exponentialApproach(before.time, previouVal, before.value, before.constant, time);\n\t\t} else if (before.type === Tone.TimelineSignal.Type.Curve){\n\t\t\tvalue = this._curveInterpolate(before.time, before.value, before.duration, time);\n\t\t} else if (after === null){\n\t\t\tvalue = before.value;\n\t\t} else if (after.type === Tone.TimelineSignal.Type.Linear){\n\t\t\tvalue = this._linearInterpolate(before.time, before.value, after.time, after.value, time);\n\t\t} else if (after.type === Tone.TimelineSignal.Type.Exponential){\n\t\t\tvalue = this._exponentialInterpolate(before.time, before.value, after.time, after.value, time);\n\t\t} else {\n\t\t\tvalue = before.value;\n\t\t}\n\t\treturn value;\n\t};\n\n\t/**\n\t * When signals connect to other signals or AudioParams, \n\t * they take over the output value of that signal or AudioParam. \n\t * For all other nodes, the behavior is the same as a default connect. \n\t *\n\t * @override\n\t * @param {AudioParam|AudioNode|Tone.Signal|Tone} node \n\t * @param {number} [outputNumber=0] The output number to connect from.\n\t * @param {number} [inputNumber=0] The input number to connect to.\n\t * @returns {Tone.TimelineSignal} this\n\t * @method\n\t */\n\tTone.TimelineSignal.prototype.connect = Tone.SignalBase.prototype.connect;\n\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tAUTOMATION CURVE CALCULATIONS\n\t//\tMIT License, copyright (c) 2014 Jordan Santell\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Calculates the the value along the curve produced by setTargetAtTime\n\t * @private\n\t */\n\tTone.TimelineSignal.prototype._exponentialApproach = function (t0, v0, v1, timeConstant, t) {\n\t\treturn v1 + (v0 - v1) * Math.exp(-(t - t0) / timeConstant);\n\t};\n\n\t/**\n\t * Calculates the the value along the curve produced by linearRampToValueAtTime\n\t * @private\n\t */\n\tTone.TimelineSignal.prototype._linearInterpolate = function (t0, v0, t1, v1, t) {\n\t\treturn v0 + (v1 - v0) * ((t - t0) / (t1 - t0));\n\t};\n\n\t/**\n\t * Calculates the the value along the curve produced by exponentialRampToValueAtTime\n\t * @private\n\t */\n\tTone.TimelineSignal.prototype._exponentialInterpolate = function (t0, v0, t1, v1, t) {\n\t\tv0 = Math.max(this._minOutput, v0);\n\t\treturn v0 * Math.pow(v1 / v0, (t - t0) / (t1 - t0));\n\t};\n\n\t/**\n\t * Calculates the the value along the curve produced by setValueCurveAtTime\n\t * @private\n\t */\n\tTone.TimelineSignal.prototype._curveInterpolate = function (start, curve, duration, time) {\n\t\tvar len = curve.length;\n\t\t// If time is after duration, return the last curve value\n\t\tif (time >= start + duration) {\n\t\t\treturn curve[len - 1];\n\t\t} else if (time <= start){\n\t\t\treturn curve[0];\n\t\t} else {\n\t\t\tvar progress = (time - start) / duration;\n\t\t\tvar lowerIndex = Math.floor((len - 1) * progress);\n\t\t\tvar upperIndex = Math.ceil((len - 1) * progress);\n\t\t\tvar lowerVal = curve[lowerIndex];\n\t\t\tvar upperVal = curve[upperIndex];\n\t\t\tif (upperIndex === lowerIndex){\n\t\t\t\treturn lowerVal;\n\t\t\t} else {\n\t\t\t\treturn this._linearInterpolate(lowerIndex, lowerVal, upperIndex, upperVal, progress * (len - 1));\n\t\t\t}\n\t\t}\n\t};\n\n\t/**\n\t * Clean up.\n\t * @return {Tone.TimelineSignal} this\n\t */\n\tTone.TimelineSignal.prototype.dispose = function(){\n\t\tTone.Signal.prototype.dispose.call(this);\n\t\tTone.Param.prototype.dispose.call(this);\n\t\tthis._events.dispose();\n\t\tthis._events = null;\n\t};\n\n\treturn Tone.TimelineSignal;\n});","'use strict';\n\ndefine(function (require) {\n var Effect = require('effect');\n\n /**\n *

A p5.Filter uses a Web Audio Biquad Filter to filter\n * the frequency response of an input source. Subclasses\n * include:

\n * p5.LowPass:\n * Allows frequencies below the cutoff frequency to pass through,\n * and attenuates frequencies above the cutoff.
\n * p5.HighPass:\n * The opposite of a lowpass filter.
\n * p5.BandPass:\n * Allows a range of frequencies to pass through and attenuates\n * the frequencies below and above this frequency range.
\n *\n * The .res() method controls either width of the\n * bandpass, or resonance of the low/highpass cutoff frequency.\n *\n * This class extends p5.Effect.\n * Methods amp(), chain(),\n * drywet(), connect(), and\n * disconnect() are available.\n *\n * @class p5.Filter\n * @extends p5.Effect\n * @constructor\n * @param {String} [type] 'lowpass' (default), 'highpass', 'bandpass'\n * @example\n *
\n * let fft, noise, filter;\n *\n * function setup() {\n * let cnv = createCanvas(100,100);\n * cnv.mousePressed(makeNoise);\n * fill(255, 0, 255);\n *\n * filter = new p5.BandPass();\n * noise = new p5.Noise();\n * noise.disconnect();\n * noise.connect(filter);\n *\n * fft = new p5.FFT();\n * }\n *\n * function draw() {\n * background(220);\n *\n * // set the BandPass frequency based on mouseX\n * let freq = map(mouseX, 0, width, 20, 10000);\n * freq = constrain(freq, 0, 22050);\n * filter.freq(freq);\n * // give the filter a narrow band (lower res = wider bandpass)\n * filter.res(50);\n *\n * // draw filtered spectrum\n * let spectrum = fft.analyze();\n * noStroke();\n * for (let i = 0; i < spectrum.length; i++) {\n * let x = map(i, 0, spectrum.length, 0, width);\n * let h = -height + map(spectrum[i], 0, 255, height, 0);\n * rect(x, height, width/spectrum.length, h);\n * }\n * if (!noise.started) {\n * text('tap here and drag to change frequency', 10, 20, width - 20);\n * } else {\n * text('Frequency: ' + round(freq)+'Hz', 20, 20, width - 20);\n * }\n * }\n *\n * function makeNoise() {\n * // see also: `userStartAudio()`\n * noise.start();\n * noise.amp(0.5, 0.2);\n * }\n *\n * function mouseReleased() {\n * noise.amp(0, 0.2);\n * }\n *\n *
\n */\n p5.Filter = function (type) {\n\n Effect.call(this);\n //add extend Effect by adding a Biquad Filter\n\n /**\n * The p5.Filter is built with a\n * \n * Web Audio BiquadFilter Node.\n *\n * @property {DelayNode} biquadFilter\n\t */\n\n this.biquad = this.ac.createBiquadFilter();\n\n this.input.connect(this.biquad);\n\n this.biquad.connect(this.wet);\n\n if (type) {\n this.setType(type);\n }\n\n //Properties useful for the toggle method.\n this._on = true;\n this._untoggledType = this.biquad.type;\n };\n p5.Filter.prototype = Object.create(Effect.prototype);\n\n\n /**\n * Filter an audio signal according to a set\n * of filter parameters.\n *\n * @method process\n * @param {Object} Signal An object that outputs audio\n * @param {Number} [freq] Frequency in Hz, from 10 to 22050\n * @param {Number} [res] Resonance/Width of the filter frequency\n * from 0.001 to 1000\n */\n p5.Filter.prototype.process = function(src, freq, res, time) {\n src.connect(this.input);\n this.set(freq, res, time);\n };\n\n\n /**\n * Set the frequency and the resonance of the filter.\n *\n * @method set\n * @param {Number} [freq] Frequency in Hz, from 10 to 22050\n * @param {Number} [res] Resonance (Q) from 0.001 to 1000\n * @param {Number} [timeFromNow] schedule this event to happen\n * seconds from now\n */\n p5.Filter.prototype.set = function(freq, res, time) {\n if (freq) {\n this.freq(freq, time);\n }\n if (res) {\n this.res(res, time);\n }\n };\n\n /**\n * Set the filter frequency, in Hz, from 10 to 22050 (the range of\n * human hearing, although in reality most people hear in a narrower\n * range).\n *\n * @method freq\n * @param {Number} freq Filter Frequency\n * @param {Number} [timeFromNow] schedule this event to happen\n * seconds from now\n * @return {Number} value Returns the current frequency value\n */\n p5.Filter.prototype.freq = function(freq, time) {\n var t = time || 0;\n if (freq <= 0) {\n freq = 1;\n }\n if (typeof freq === 'number') {\n this.biquad.frequency.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.biquad.frequency.exponentialRampToValueAtTime(freq, this.ac.currentTime + 0.02 + t);\n } else if (freq) {\n freq.connect(this.biquad.frequency);\n }\n return this.biquad.frequency.value;\n };\n\n /**\n * Controls either width of a bandpass frequency,\n * or the resonance of a low/highpass cutoff frequency.\n *\n * @method res\n * @param {Number} res Resonance/Width of filter freq\n * from 0.001 to 1000\n * @param {Number} [timeFromNow] schedule this event to happen\n * seconds from now\n * @return {Number} value Returns the current res value\n */\n p5.Filter.prototype.res = function(res, time) {\n var t = time || 0;\n if (typeof res === 'number') {\n this.biquad.Q.value = res;\n this.biquad.Q.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.biquad.Q.linearRampToValueAtTime(res, this.ac.currentTime + 0.02 + t);\n } else if (res) {\n res.connect(this.biquad.Q);\n }\n return this.biquad.Q.value;\n };\n\n /**\n * Controls the gain attribute of a Biquad Filter.\n * This is distinctly different from .amp() which is inherited from p5.Effect\n * .amp() controls the volume via the output gain node\n * p5.Filter.gain() controls the gain parameter of a Biquad Filter node.\n *\n * @method gain\n * @param {Number} gain\n * @return {Number} Returns the current or updated gain value\n */\n p5.Filter.prototype.gain = function(gain, time) {\n var t = time || 0;\n if (typeof gain === 'number') {\n this.biquad.gain.value = gain;\n this.biquad.gain.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.biquad.gain.linearRampToValueAtTime(gain, this.ac.currentTime + 0.02 + t);\n } else if (gain) {\n gain.connect(this.biquad.gain);\n }\n return this.biquad.gain.value;\n };\n\n\n /**\n * Toggle function. Switches between the specified type and allpass\n *\n * @method toggle\n * @return {boolean} [Toggle value]\n */\n p5.Filter.prototype.toggle = function() {\n this._on = !this._on;\n\n if (this._on === true) {\n this.biquad.type = this._untoggledType;\n } else if (this._on === false) {\n this.biquad.type = 'allpass';\n }\n\n return this._on;\n };\n\n /**\n * Set the type of a p5.Filter. Possible types include:\n * \"lowpass\" (default), \"highpass\", \"bandpass\",\n * \"lowshelf\", \"highshelf\", \"peaking\", \"notch\",\n * \"allpass\".\n *\n * @method setType\n * @param {String} t\n */\n p5.Filter.prototype.setType = function(t) {\n this.biquad.type = t;\n this._untoggledType = this.biquad.type;\n };\n\n p5.Filter.prototype.dispose = function() {\n // remove reference from soundArray\n Effect.prototype.dispose.apply(this);\n if (this.biquad) {\n this.biquad.disconnect();\n delete this.biquad;\n }\n };\n\n /**\n * Constructor: new p5.LowPass() Filter.\n * This is the same as creating a p5.Filter and then calling\n * its method setType('lowpass').\n * See p5.Filter for methods.\n *\n * @class p5.LowPass\n * @constructor\n * @extends p5.Filter\n */\n p5.LowPass = function() {\n p5.Filter.call(this, 'lowpass');\n };\n p5.LowPass.prototype = Object.create(p5.Filter.prototype);\n\n /**\n * Constructor: new p5.HighPass() Filter.\n * This is the same as creating a p5.Filter and then calling\n * its method setType('highpass').\n * See p5.Filter for methods.\n *\n * @class p5.HighPass\n * @constructor\n * @extends p5.Filter\n */\n p5.HighPass = function() {\n p5.Filter.call(this, 'highpass');\n };\n p5.HighPass.prototype = Object.create(p5.Filter.prototype);\n\n /**\n * Constructor: new p5.BandPass() Filter.\n * This is the same as creating a p5.Filter and then calling\n * its method setType('bandpass').\n * See p5.Filter for methods.\n *\n * @class p5.BandPass\n * @constructor\n * @extends p5.Filter\n */\n p5.BandPass = function() {\n p5.Filter.call(this, 'bandpass');\n };\n p5.BandPass.prototype = Object.create(p5.Filter.prototype);\n\n return p5.Filter;\n});\n","define([\"Tone/core/Tone\", \"Tone/signal/Add\", \"Tone/signal/Negate\", \"Tone/signal/Signal\", \"Tone/core/Gain\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Subtract the signal connected to input[1] from the signal connected \n\t * to input[0]. If an argument is provided in the constructor, the \n\t * signals .value will be subtracted from the incoming signal.\n\t *\n\t * @extends {Tone.Signal}\n\t * @constructor\n\t * @param {number=} value The value to subtract from the incoming signal. If the value\n\t * is omitted, it will subtract the second signal from the first.\n\t * @example\n\t * var sub = new Tone.Subtract(1);\n\t * var sig = new Tone.Signal(4).connect(sub);\n\t * //the output of sub is 3. \n\t * @example\n\t * var sub = new Tone.Subtract();\n\t * var sigA = new Tone.Signal(10);\n\t * var sigB = new Tone.Signal(2.5);\n\t * sigA.connect(sub, 0, 0);\n\t * sigB.connect(sub, 0, 1);\n\t * //output of sub is 7.5\n\t */\n\tTone.Subtract = function(value){\n\n\t\tthis.createInsOuts(2, 0);\n\n\t\t/**\n\t\t * the summing node\n\t\t * @type {GainNode}\n\t\t * @private\n\t\t */\n\t\tthis._sum = this.input[0] = this.output = new Tone.Gain();\n\n\t\t/**\n\t\t * negate the input of the second input before connecting it\n\t\t * to the summing node.\n\t\t * @type {Tone.Negate}\n\t\t * @private\n\t\t */\n\t\tthis._neg = new Tone.Negate();\n\n\t\t/**\n\t\t * the node where the value is set\n\t\t * @private\n\t\t * @type {Tone.Signal}\n\t\t */\n\t\tthis._param = this.input[1] = new Tone.Signal(value);\n\n\t\tthis._param.chain(this._neg, this._sum);\n\t};\n\n\tTone.extend(Tone.Subtract, Tone.Signal);\n\n\t/**\n\t * Clean up.\n\t * @returns {Tone.SignalBase} this\n\t */\n\tTone.Subtract.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._neg.dispose();\n\t\tthis._neg = null;\n\t\tthis._sum.disconnect();\n\t\tthis._sum = null;\n\t\tthis._param.dispose();\n\t\tthis._param = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.Subtract;\n});","'use strict';\n\nglobal.TONE_SILENCE_VERSION_LOGGING = true;\n\ndefine(['startaudiocontext', 'Tone/core/Context', 'Tone/core/Tone'], function (StartAudioContext, Context, Tone) {\n // Create the Audio Context\n const audiocontext = new window.AudioContext();\n\n // Tone and p5.sound share the same audio context\n Tone.context.dispose();\n Tone.setContext(audiocontext);\n\n /**\n *

Returns the Audio Context for this sketch. Useful for users\n * who would like to dig deeper into the Web Audio API\n * .

\n *\n *

Some browsers require users to startAudioContext\n * with a user gesture, such as touchStarted in the example below.

\n *\n * @for p5\n * @method getAudioContext\n * @return {Object} AudioContext for this sketch\n * @example\n *
\n * function draw() {\n * background(255);\n * textAlign(CENTER);\n *\n * if (getAudioContext().state !== 'running') {\n * text('click to start audio', width/2, height/2);\n * } else {\n * text('audio is enabled', width/2, height/2);\n * }\n * }\n *\n * function touchStarted() {\n * if (getAudioContext().state !== 'running') {\n * getAudioContext().resume();\n * }\n * var synth = new p5.MonoSynth();\n * synth.play('A4', 0.5, 0, 0.2);\n * }\n *\n *
\n */\n p5.prototype.getAudioContext = function() {\n return audiocontext;\n };\n\n\n /**\n *

It is not only a good practice to give users control over starting\n * audio. This policy is enforced by many web browsers, including iOS and\n * Google Chrome, which create the Web Audio API's\n * Audio Context\n * in a suspended state.

\n *\n *

In these browser-specific policies, sound will not play until a user\n * interaction event (i.e. mousePressed()) explicitly resumes\n * the AudioContext, or starts an audio node. This can be accomplished by\n * calling start() on a p5.Oscillator,\n * play() on a p5.SoundFile, or simply\n * userStartAudio().

\n *\n *

userStartAudio() starts the AudioContext on a user\n * gesture. The default behavior will enable audio on any\n * mouseUp or touchEnd event. It can also be placed in a specific\n * interaction function, such as mousePressed() as in the\n * example below. This method utilizes\n * StartAudioContext\n * , a library by Yotam Mann (MIT Licence, 2016).

\n * @param {Element|Array} [element(s)] This argument can be an Element,\n * Selector String, NodeList, p5.Element,\n * jQuery Element, or an Array of any of those.\n * @param {Function} [callback] Callback to invoke when the AudioContext\n * has started\n * @return {Promise} Returns a Promise that resolves when\n * the AudioContext state is 'running'\n * @method userStartAudio\n * @for p5\n * @example\n *
\n * function setup() {\n * // mimics the autoplay policy\n * getAudioContext().suspend();\n *\n * let mySynth = new p5.MonoSynth();\n *\n * // This won't play until the context has resumed\n * mySynth.play('A6');\n * }\n * function draw() {\n * background(220);\n * textAlign(CENTER, CENTER);\n * text(getAudioContext().state, width/2, height/2);\n * }\n * function mousePressed() {\n * userStartAudio();\n * }\n *
\n */\n p5.prototype.userStartAudio = function(elements, callback) {\n var elt = elements;\n if (elements instanceof p5.Element) {\n elt = elements.elt;\n } else if (elements instanceof Array && elements[0] instanceof p5.Element ) {\n elt = elements.map(function(e) { return e.elt});\n }\n return StartAudioContext(audiocontext, elt, callback);\n };\n\n return audiocontext;\n});\n","define([\"Tone/core/Tone\"], function (Tone) {\n\n\t\"use strict\";\n\n\t/**\n\t * @class Tone.Emitter gives classes which extend it\n\t * the ability to listen for and emit events. \n\t * Inspiration and reference from Jerome Etienne's [MicroEvent](https://github.com/jeromeetienne/microevent.js).\n\t * MIT (c) 2011 Jerome Etienne.\n\t * \n\t * @extends {Tone}\n\t */\n\tTone.Emitter = function(){\n\t\t/**\n\t\t * Contains all of the events.\n\t\t * @private\n\t\t * @type {Object}\n\t\t */\n\t\tthis._events = {};\n\t};\n\n\tTone.extend(Tone.Emitter);\n\n\t/**\n\t * Bind a callback to a specific event.\n\t * @param {String} event The name of the event to listen for.\n\t * @param {Function} callback The callback to invoke when the\n\t * event is emitted\n\t * @return {Tone.Emitter} this\n\t */\n\tTone.Emitter.prototype.on = function(event, callback){\n\t\t//split the event\n\t\tvar events = event.split(/\\W+/);\n\t\tfor (var i = 0; i < events.length; i++){\n\t\t\tvar eventName = events[i];\n\t\t\tif (!this._events.hasOwnProperty(eventName)){\n\t\t\t\tthis._events[eventName] = [];\n\t\t\t}\n\t\t\tthis._events[eventName].push(callback);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Remove the event listener.\n\t * @param {String} event The event to stop listening to.\n\t * @param {Function=} callback The callback which was bound to \n\t * the event with Tone.Emitter.on.\n\t * If no callback is given, all callbacks\n\t * events are removed.\n\t * @return {Tone.Emitter} this\n\t */\n\tTone.Emitter.prototype.off = function(event, callback){\n\t\tvar events = event.split(/\\W+/);\n\t\tfor (var ev = 0; ev < events.length; ev++){\n\t\t\tevent = events[ev];\n\t\t\tif (this._events.hasOwnProperty(event)){\n\t\t\t\tif (Tone.prototype.isUndef(callback)){\n\t\t\t\t\tthis._events[event] = [];\n\t\t\t\t} else {\n\t\t\t\t\tvar eventList = this._events[event];\n\t\t\t\t\tfor (var i = 0; i < eventList.length; i++){\n\t\t\t\t\t\tif (eventList[i] === callback){\n\t\t\t\t\t\t\teventList.splice(i, 1);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Invoke all of the callbacks bound to the event\n\t * with any arguments passed in. \n\t * @param {String} event The name of the event.\n\t * @param {*...} args The arguments to pass to the functions listening.\n\t * @return {Tone.Emitter} this\n\t */\n\tTone.Emitter.prototype.emit = function(event){\n\t\tif (this._events){\n\t\t\tvar args = Array.apply(null, arguments).slice(1);\n\t\t\tif (this._events.hasOwnProperty(event)){\n\t\t\t\tvar eventList = this._events[event];\n\t\t\t\tfor (var i = 0, len = eventList.length; i < len; i++){\n\t\t\t\t\teventList[i].apply(this, args);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Add Emitter functions (on/off/emit) to the object\n\t * @param {Object|Function} object The object or class to extend.\n\t */\n\tTone.Emitter.mixin = function(object){\n\t\tvar functions = [\"on\", \"off\", \"emit\"];\n\t\tobject._events = {};\n\t\tfor (var i = 0; i < functions.length; i++){\n\t\t\tvar func = functions[i];\n\t\t\tvar emitterFunc = Tone.Emitter.prototype[func];\n\t\t\tobject[func] = emitterFunc;\n\t\t}\n\t};\n\n\t/**\n\t * Clean up\n\t * @return {Tone.Emitter} this\n\t */\n\tTone.Emitter.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._events = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.Emitter;\n});","define([\"Tone/core/Tone\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Base class for all Signals. Used Internally. \n\t *\n\t * @constructor\n\t * @extends {Tone}\n\t */\n\tTone.SignalBase = function(){};\n\n\tTone.extend(Tone.SignalBase);\n\n\t/**\n\t * When signals connect to other signals or AudioParams, \n\t * they take over the output value of that signal or AudioParam. \n\t * For all other nodes, the behavior is the same as a default connect. \n\t *\n\t * @override\n\t * @param {AudioParam|AudioNode|Tone.Signal|Tone} node \n\t * @param {number} [outputNumber=0] The output number to connect from.\n\t * @param {number} [inputNumber=0] The input number to connect to.\n\t * @returns {Tone.SignalBase} this\n\t */\n\tTone.SignalBase.prototype.connect = function(node, outputNumber, inputNumber){\n\t\t//zero it out so that the signal can have full control\n\t\tif ((Tone.Signal && Tone.Signal === node.constructor) || \n\t\t\t\t(Tone.Param && Tone.Param === node.constructor) || \n\t\t\t\t(Tone.TimelineSignal && Tone.TimelineSignal === node.constructor)){\n\t\t\t//cancel changes\n\t\t\tnode._param.cancelScheduledValues(0);\n\t\t\t//reset the value\n\t\t\tnode._param.value = 0;\n\t\t\t//mark the value as overridden\n\t\t\tnode.overridden = true;\n\t\t} else if (node instanceof AudioParam){\n\t\t\tnode.cancelScheduledValues(0);\n\t\t\tnode.value = 0;\n\t\t} \n\t\tTone.prototype.connect.call(this, node, outputNumber, inputNumber);\n\t\treturn this;\n\t};\n\n\treturn Tone.SignalBase;\n});","define([\"Tone/core/Tone\", \"Tone/type/TimeBase\"], function (Tone) {\n\n\t/**\n\t * @class Tone.Time is a primitive type for encoding Time values. \n\t * Eventually all time values are evaluated to seconds\n\t * using the `eval` method. Tone.Time can be constructed\n\t * with or without the `new` keyword. Tone.Time can be passed\n\t * into the parameter of any method which takes time as an argument. \n\t * @constructor\n\t * @extends {Tone.TimeBase}\n\t * @param {String|Number} val The time value.\n\t * @param {String=} units The units of the value.\n\t * @example\n\t * var t = Tone.Time(\"4n\");//encodes a quarter note\n\t * t.mult(4); // multiply that value by 4\n\t * t.toNotation(); //returns \"1m\"\n\t */\n\tTone.Time = function(val, units){\n\t\tif (this instanceof Tone.Time){\n\n\t\t\t/**\n\t\t\t * If the current clock time should\n\t\t\t * be added to the output\n\t\t\t * @type {Boolean}\n\t\t\t * @private\n\t\t\t */\n\t\t\tthis._plusNow = false;\n\t\t\t\n\t\t\tTone.TimeBase.call(this, val, units);\n\n\t\t} else {\n\t\t\treturn new Tone.Time(val, units);\n\t\t}\n\t};\n\n\tTone.extend(Tone.Time, Tone.TimeBase);\n\n\t//clone the expressions so that \n\t//we can add more without modifying the original\n\tTone.Time.prototype._unaryExpressions = Object.create(Tone.TimeBase.prototype._unaryExpressions);\n\n\t/*\n\t * Adds an additional unary expression\n\t * which quantizes values to the next subdivision\n\t * @type {Object}\n\t * @private\n\t */\n\tTone.Time.prototype._unaryExpressions.quantize = {\n\t\tregexp : /^@/,\n\t\tmethod : function(rh){\n\t\t\treturn Tone.Transport.nextSubdivision(rh());\n\t\t}\n\t};\n\n\t/*\n\t * Adds an additional unary expression\n\t * which adds the current clock time.\n\t * @type {Object}\n\t * @private\n\t */\n\tTone.Time.prototype._unaryExpressions.now = {\n\t\tregexp : /^\\+/,\n\t\tmethod : function(lh){\n\t\t\tthis._plusNow = true;\n\t\t\treturn lh();\n\t\t}\n\t};\n\n\t/**\n\t * Quantize the time by the given subdivision. Optionally add a\n\t * percentage which will move the time value towards the ideal\n\t * quantized value by that percentage. \n\t * @param {Number|Time} val The subdivision to quantize to\n\t * @param {NormalRange} [percent=1] Move the time value\n\t * towards the quantized value by\n\t * a percentage.\n\t * @return {Tone.Time} this\n\t * @example\n\t * Tone.Time(21).quantize(2) //returns 22\n\t * Tone.Time(0.6).quantize(\"4n\", 0.5) //returns 0.55\n\t */\n\tTone.Time.prototype.quantize = function(subdiv, percent){\n\t\tpercent = this.defaultArg(percent, 1);\n\t\tthis._expr = function(expr, subdivision, percent){\n\t\t\texpr = expr();\n\t\t\tsubdivision = subdivision.toSeconds();\n\t\t\tvar multiple = Math.round(expr / subdivision);\n\t\t\tvar ideal = multiple * subdivision;\n\t\t\tvar diff = ideal - expr;\n\t\t\treturn expr + diff * percent;\n\t\t}.bind(this, this._expr, new this.constructor(subdiv), percent);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Adds the clock time to the time expression at the \n\t * moment of evaluation. \n\t * @return {Tone.Time} this\n\t */\n\tTone.Time.prototype.addNow = function(){\n\t\tthis._plusNow = true;\n\t\treturn this;\n\t};\n\n\t/**\n\t * @override\n\t * Override the default value return when no arguments are passed in.\n\t * The default value is 'now'\n\t * @private\n\t */\n\tTone.Time.prototype._defaultExpr = function(){\n\t\tthis._plusNow = true;\n\t\treturn this._noOp;\n\t};\n\n\t/**\n\t * Copies the value of time to this Time\n\t * @param {Tone.Time} time\n\t * @return {Time}\n\t */\n\tTone.Time.prototype.copy = function(time){\n\t\tTone.TimeBase.prototype.copy.call(this, time);\n\t\tthis._plusNow = time._plusNow;\n\t\treturn this;\n\t};\n\n\t//CONVERSIONS//////////////////////////////////////////////////////////////\n\n\t/**\n\t * Convert a Time to Notation. Values will be thresholded to the nearest 128th note. \n\t * @return {Notation} \n\t * @example\n\t * //if the Transport is at 120bpm:\n\t * Tone.Time(2).toNotation();//returns \"1m\"\n\t */\n\tTone.Time.prototype.toNotation = function(){\n\t\tvar time = this.toSeconds();\n\t\tvar testNotations = [\"1m\", \"2n\", \"4n\", \"8n\", \"16n\", \"32n\", \"64n\", \"128n\"];\n\t\tvar retNotation = this._toNotationHelper(time, testNotations);\n\t\t//try the same thing but with tripelets\n\t\tvar testTripletNotations = [\"1m\", \"2n\", \"2t\", \"4n\", \"4t\", \"8n\", \"8t\", \"16n\", \"16t\", \"32n\", \"32t\", \"64n\", \"64t\", \"128n\"];\n\t\tvar retTripletNotation = this._toNotationHelper(time, testTripletNotations);\n\t\t//choose the simpler expression of the two\n\t\tif (retTripletNotation.split(\"+\").length < retNotation.split(\"+\").length){\n\t\t\treturn retTripletNotation;\n\t\t} else {\n\t\t\treturn retNotation;\n\t\t}\n\t};\n\n\t/**\n\t * Helper method for Tone.toNotation\n\t * @param {Number} units \n\t * @param {Array} testNotations\n\t * @return {String}\n\t * @private\n\t */\n\tTone.Time.prototype._toNotationHelper = function(units, testNotations){\n\t\t//the threshold is the last value in the array\n\t\tvar threshold = this._notationToUnits(testNotations[testNotations.length - 1]);\n\t\tvar retNotation = \"\";\n\t\tfor (var i = 0; i < testNotations.length; i++){\n\t\t\tvar notationTime = this._notationToUnits(testNotations[i]);\n\t\t\t//account for floating point errors (i.e. round up if the value is 0.999999)\n\t\t\tvar multiple = units / notationTime;\n\t\t\tvar floatingPointError = 0.000001;\n\t\t\tif (1 - multiple % 1 < floatingPointError){\n\t\t\t\tmultiple += floatingPointError;\n\t\t\t}\n\t\t\tmultiple = Math.floor(multiple);\n\t\t\tif (multiple > 0){\n\t\t\t\tif (multiple === 1){\n\t\t\t\t\tretNotation += testNotations[i];\n\t\t\t\t} else {\n\t\t\t\t\tretNotation += multiple.toString() + \"*\" + testNotations[i];\n\t\t\t\t}\n\t\t\t\tunits -= multiple * notationTime;\n\t\t\t\tif (units < threshold){\n\t\t\t\t\tbreak;\n\t\t\t\t} else {\n\t\t\t\t\tretNotation += \" + \";\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (retNotation === \"\"){\n\t\t\tretNotation = \"0\";\n\t\t}\n\t\treturn retNotation;\n\t};\n\n\t/**\n\t * Convert a notation value to the current units\n\t * @param {Notation} notation \n\t * @return {Number} \n\t * @private\n\t */\n\tTone.Time.prototype._notationToUnits = function(notation){\n\t\tvar primaryExprs = this._primaryExpressions;\n\t\tvar notationExprs = [primaryExprs.n, primaryExprs.t, primaryExprs.m];\n\t\tfor (var i = 0; i < notationExprs.length; i++){\n\t\t\tvar expr = notationExprs[i];\n\t\t\tvar match = notation.match(expr.regexp);\n\t\t\tif (match){\n\t\t\t\treturn expr.method.call(this, match[1]);\n\t\t\t}\n\t\t}\n\t};\n\n\t/**\n\t * Return the time encoded as Bars:Beats:Sixteenths.\n\t * @return {BarsBeatsSixteenths}\n\t */\n\tTone.Time.prototype.toBarsBeatsSixteenths = function(){\n\t\tvar quarterTime = this._beatsToUnits(1);\n\t\tvar quarters = this.toSeconds() / quarterTime;\n\t\tvar measures = Math.floor(quarters / this._timeSignature());\n\t\tvar sixteenths = (quarters % 1) * 4;\n\t\tquarters = Math.floor(quarters) % this._timeSignature();\n\t\tsixteenths = sixteenths.toString();\n\t\tif (sixteenths.length > 3){\n\t\t\tsixteenths = parseFloat(sixteenths).toFixed(3);\n\t\t}\n\t\tvar progress = [measures, quarters, sixteenths];\n\t\treturn progress.join(\":\");\n\t};\n\n\t/**\n\t * Return the time in ticks.\n\t * @return {Ticks}\n\t */\n\tTone.Time.prototype.toTicks = function(){\n\t\tvar quarterTime = this._beatsToUnits(1);\n\t\tvar quarters = this.valueOf() / quarterTime;\n\t\treturn Math.floor(quarters * Tone.Transport.PPQ);\n\t};\n\n\t/**\n\t * Return the time in samples\n\t * @return {Samples} \n\t */\n\tTone.Time.prototype.toSamples = function(){\n\t\treturn this.toSeconds() * this.context.sampleRate;\n\t};\n\n\t/**\n\t * Return the time as a frequency value\n\t * @return {Frequency} \n\t * @example\n\t * Tone.Time(2).toFrequency(); //0.5\n\t */\n\tTone.Time.prototype.toFrequency = function(){\n\t\treturn 1/this.toSeconds();\n\t};\n\n\t/**\n\t * Return the time in seconds.\n\t * @return {Seconds} \n\t */\n\tTone.Time.prototype.toSeconds = function(){\n\t\treturn this.valueOf();\n\t};\n\n\t/**\n\t * Return the time in milliseconds.\n\t * @return {Milliseconds} \n\t */\n\tTone.Time.prototype.toMilliseconds = function(){\n\t\treturn this.toSeconds() * 1000;\n\t};\n\n\t/**\n\t * Return the time in seconds.\n\t * @return {Seconds} \n\t */\n\tTone.Time.prototype.valueOf = function(){\n\t\tvar val = this._expr();\n\t\treturn val + (this._plusNow?this.now():0);\n\t};\n\n\treturn Tone.Time;\n});","define([\"Tone/core/Tone\"], function (Tone) {\n\n\t/**\n\t * @class Tone.TimeBase is a flexible encoding of time\n\t * which can be evaluated to and from a string.\n\t * Parsing code modified from https://code.google.com/p/tapdigit/\n\t * Copyright 2011 2012 Ariya Hidayat, New BSD License\n\t * @extends {Tone}\n\t * @param {Time} val The time value as a number or string\n\t * @param {String=} units Unit values\n\t * @example\n\t * Tone.TimeBase(4, \"n\")\n\t * Tone.TimeBase(2, \"t\")\n\t * Tone.TimeBase(\"2t\").add(\"1m\")\n\t * Tone.TimeBase(\"2t + 1m\");\n\t */\n\tTone.TimeBase = function(val, units){\n\n\t\t//allows it to be constructed with or without 'new'\n\t\tif (this instanceof Tone.TimeBase) {\n\n\t\t\t/**\n\t\t\t * Any expressions parsed from the Time\n\t\t\t * @type {Array}\n\t\t\t * @private\n\t\t\t */\n\t\t\tthis._expr = this._noOp;\n\n\t\t\tif (val instanceof Tone.TimeBase){\n\t\t\t\tthis.copy(val);\n\t\t\t} else if (!this.isUndef(units) || this.isNumber(val)){\n\t\t\t\t//default units\n\t\t\t\tunits = this.defaultArg(units, this._defaultUnits);\n\t\t\t\tvar method = this._primaryExpressions[units].method;\n\t\t\t\tthis._expr = method.bind(this, val);\n\t\t\t} else if (this.isString(val)){\n\t\t\t\tthis.set(val);\n\t\t\t} else if (this.isUndef(val)){\n\t\t\t\t//default expression\n\t\t\t\tthis._expr = this._defaultExpr();\n\t\t\t}\n\t\t} else {\n\n\t\t\treturn new Tone.TimeBase(val, units);\n\t\t}\n\t};\n\n\tTone.extend(Tone.TimeBase);\n\n\t/**\n\t * Repalce the current time value with the value\n\t * given by the expression string.\n\t * @param {String} exprString\n\t * @return {Tone.TimeBase} this\n\t */\n\tTone.TimeBase.prototype.set = function(exprString){\n\t\tthis._expr = this._parseExprString(exprString);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Return a clone of the TimeBase object.\n\t * @return {Tone.TimeBase} The new cloned Tone.TimeBase\n\t */\n\tTone.TimeBase.prototype.clone = function(){\n\t\tvar instance = new this.constructor();\n\t\tinstance.copy(this);\n\t\treturn instance;\n\t};\n\n\t/**\n\t * Copies the value of time to this Time\n\t * @param {Tone.TimeBase} time\n\t * @return {TimeBase}\n\t */\n\tTone.TimeBase.prototype.copy = function(time){\n\t\tvar val = time._expr();\n\t\treturn this.set(val);\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tABSTRACT SYNTAX TREE PARSER\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * All the primary expressions.\n\t * @private\n\t * @type {Object}\n\t */\n\tTone.TimeBase.prototype._primaryExpressions = {\n\t\t\"n\" : {\n\t\t\tregexp : /^(\\d+)n/i,\n\t\t\tmethod : function(value){\n\t\t\t\tvalue = parseInt(value);\n\t\t\t\tif (value === 1){\n\t\t\t\t\treturn this._beatsToUnits(this._timeSignature());\n\t\t\t\t} else {\n\t\t\t\t\treturn this._beatsToUnits(4 / value);\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\t\"t\" : {\n\t\t\tregexp : /^(\\d+)t/i,\n\t\t\tmethod : function(value){\n\t\t\t\tvalue = parseInt(value);\n\t\t\t\treturn this._beatsToUnits(8 / (parseInt(value) * 3));\n\t\t\t}\n\t\t},\n\t\t\"m\" : {\n\t\t\tregexp : /^(\\d+)m/i,\n\t\t\tmethod : function(value){\n\t\t\t\treturn this._beatsToUnits(parseInt(value) * this._timeSignature());\n\t\t\t}\n\t\t},\n\t\t\"i\" : {\n\t\t\tregexp : /^(\\d+)i/i,\n\t\t\tmethod : function(value){\n\t\t\t\treturn this._ticksToUnits(parseInt(value));\n\t\t\t}\n\t\t},\n\t\t\"hz\" : {\n\t\t\tregexp : /^(\\d+(?:\\.\\d+)?)hz/i,\n\t\t\tmethod : function(value){\n\t\t\t\treturn this._frequencyToUnits(parseFloat(value));\n\t\t\t}\n\t\t},\n\t\t\"tr\" : {\n\t\t\tregexp : /^(\\d+(?:\\.\\d+)?):(\\d+(?:\\.\\d+)?):?(\\d+(?:\\.\\d+)?)?/,\n\t\t\tmethod : function(m, q, s){\n\t\t\t\tvar total = 0;\n\t\t\t\tif (m && m !== \"0\"){\n\t\t\t\t\ttotal += this._beatsToUnits(this._timeSignature() * parseFloat(m));\n\t\t\t\t}\n\t\t\t\tif (q && q !== \"0\"){\n\t\t\t\t\ttotal += this._beatsToUnits(parseFloat(q));\n\t\t\t\t}\n\t\t\t\tif (s && s !== \"0\"){\n\t\t\t\t\ttotal += this._beatsToUnits(parseFloat(s) / 4);\n\t\t\t\t}\n\t\t\t\treturn total;\n\t\t\t}\n\t\t},\n\t\t\"s\" : {\n\t\t\tregexp : /^(\\d+(?:\\.\\d+)?s)/,\n\t\t\tmethod : function(value){\n\t\t\t\treturn this._secondsToUnits(parseFloat(value));\n\t\t\t}\n\t\t},\n\t\t\"samples\" : {\n\t\t\tregexp : /^(\\d+)samples/,\n\t\t\tmethod : function(value){\n\t\t\t\treturn parseInt(value) / this.context.sampleRate;\n\t\t\t}\n\t\t},\n\t\t\"default\" : {\n\t\t\tregexp : /^(\\d+(?:\\.\\d+)?)/,\n\t\t\tmethod : function(value){\n\t\t\t\treturn this._primaryExpressions[this._defaultUnits].method.call(this, value);\n\t\t\t}\n\t\t}\n\t};\n\n\t/**\n\t * All the binary expressions that TimeBase can accept.\n\t * @private\n\t * @type {Object}\n\t */\n\tTone.TimeBase.prototype._binaryExpressions = {\n\t\t\"+\" : {\n\t\t\tregexp : /^\\+/,\n\t\t\tprecedence : 2,\n\t\t\tmethod : function(lh, rh){\n\t\t\t\treturn lh() + rh();\n\t\t\t}\n\t\t},\n\t\t\"-\" : {\n\t\t\tregexp : /^\\-/,\n\t\t\tprecedence : 2,\n\t\t\tmethod : function(lh, rh){\n\t\t\t\treturn lh() - rh();\n\t\t\t}\n\t\t},\n\t\t\"*\" : {\n\t\t\tregexp : /^\\*/,\n\t\t\tprecedence : 1,\n\t\t\tmethod : function(lh, rh){\n\t\t\t\treturn lh() * rh();\n\t\t\t}\n\t\t},\n\t\t\"/\" : {\n\t\t\tregexp : /^\\//,\n\t\t\tprecedence : 1,\n\t\t\tmethod : function(lh, rh){\n\t\t\t\treturn lh() / rh();\n\t\t\t}\n\t\t}\n\t};\n\n\t/**\n\t * All the unary expressions.\n\t * @private\n\t * @type {Object}\n\t */\n\tTone.TimeBase.prototype._unaryExpressions = {\n\t\t\"neg\" : {\n\t\t\tregexp : /^\\-/,\n\t\t\tmethod : function(lh){\n\t\t\t\treturn -lh();\n\t\t\t}\n\t\t}\n\t};\n\n\t/**\n\t * Syntactic glue which holds expressions together\n\t * @private\n\t * @type {Object}\n\t */\n\tTone.TimeBase.prototype._syntaxGlue = {\n\t\t\"(\" : {\n\t\t\tregexp : /^\\(/\n\t\t},\n\t\t\")\" : {\n\t\t\tregexp : /^\\)/\n\t\t}\n\t};\n\n\t/**\n\t * tokenize the expression based on the Expressions object\n\t * @param {string} expr \n\t * @return {Object} returns two methods on the tokenized list, next and peek\n\t * @private\n\t */\n\tTone.TimeBase.prototype._tokenize = function(expr){\n\t\tvar position = -1;\n\t\tvar tokens = [];\n\n\t\twhile(expr.length > 0){\n\t\t\texpr = expr.trim();\n\t\t\tvar token = getNextToken(expr, this);\n\t\t\ttokens.push(token);\n\t\t\texpr = expr.substr(token.value.length);\n\t\t}\n\n\t\tfunction getNextToken(expr, context){\n\t\t\tvar expressions = [\"_binaryExpressions\", \"_unaryExpressions\", \"_primaryExpressions\", \"_syntaxGlue\"];\n\t\t\tfor (var i = 0; i < expressions.length; i++){\n\t\t\t\tvar group = context[expressions[i]];\n\t\t\t\tfor (var opName in group){\n\t\t\t\t\tvar op = group[opName];\n\t\t\t\t\tvar reg = op.regexp;\n\t\t\t\t\tvar match = expr.match(reg);\n\t\t\t\t\tif (match !== null){\n\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\tmethod : op.method,\n\t\t\t\t\t\t\tprecedence : op.precedence,\n\t\t\t\t\t\t\tregexp : op.regexp,\n\t\t\t\t\t\t\tvalue : match[0],\n\t\t\t\t\t\t};\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tthrow new SyntaxError(\"Tone.TimeBase: Unexpected token \"+expr);\n\t\t}\n\n\t\treturn {\n\t\t\tnext : function(){\n\t\t\t\treturn tokens[++position];\n\t\t\t},\n\t\t\tpeek : function(){\n\t\t\t\treturn tokens[position + 1];\n\t\t\t}\n\t\t};\n\t};\n\n\t/**\n\t * Given a token, find the value within the groupName\n\t * @param {Object} token\n\t * @param {String} groupName\n\t * @param {Number} precedence\n\t * @private\n\t */\n\tTone.TimeBase.prototype._matchGroup = function(token, group, prec) {\n\t\tvar ret = false;\n\t\tif (!this.isUndef(token)){\n\t\t\tfor (var opName in group){\n\t\t\t\tvar op = group[opName];\n\t\t\t\tif (op.regexp.test(token.value)){\n\t\t\t\t\tif (!this.isUndef(prec)){\n\t\t\t\t\t\tif(op.precedence === prec){\t\n\t\t\t\t\t\t\treturn op;\n\t\t\t\t\t\t}\n\t\t\t\t\t} else {\n\t\t\t\t\t\treturn op;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn ret;\n\t};\n\n\t/**\n\t * Match a binary expression given the token and the precedence\n\t * @param {Lexer} lexer\n\t * @param {Number} precedence\n\t * @private\n\t */\n\tTone.TimeBase.prototype._parseBinary = function(lexer, precedence){\n\t\tif (this.isUndef(precedence)){\n\t\t\tprecedence = 2;\n\t\t}\n\t\tvar expr;\n\t\tif (precedence < 0){\n\t\t\texpr = this._parseUnary(lexer);\n\t\t} else {\n\t\t\texpr = this._parseBinary(lexer, precedence - 1);\n\t\t}\n\t\tvar token = lexer.peek();\n\t\twhile (token && this._matchGroup(token, this._binaryExpressions, precedence)){\n\t\t\ttoken = lexer.next();\n\t\t\texpr = token.method.bind(this, expr, this._parseBinary(lexer, precedence - 1));\n\t\t\ttoken = lexer.peek();\n\t\t}\n\t\treturn expr;\n\t};\n\n\t/**\n\t * Match a unary expression.\n\t * @param {Lexer} lexer\n\t * @private\n\t */\n\tTone.TimeBase.prototype._parseUnary = function(lexer){\n\t\tvar token, expr;\n\t\ttoken = lexer.peek();\n\t\tvar op = this._matchGroup(token, this._unaryExpressions);\n\t\tif (op) {\n\t\t\ttoken = lexer.next();\n\t\t\texpr = this._parseUnary(lexer);\n\t\t\treturn op.method.bind(this, expr);\n\t\t}\n\t\treturn this._parsePrimary(lexer);\n\t};\n\n\t/**\n\t * Match a primary expression (a value).\n\t * @param {Lexer} lexer\n\t * @private\n\t */\n\tTone.TimeBase.prototype._parsePrimary = function(lexer){\n\t\tvar token, expr;\n\t\ttoken = lexer.peek();\n\t\tif (this.isUndef(token)) {\n\t\t\tthrow new SyntaxError(\"Tone.TimeBase: Unexpected end of expression\");\n\t\t}\n\t\tif (this._matchGroup(token, this._primaryExpressions)) {\n\t\t\ttoken = lexer.next();\n\t\t\tvar matching = token.value.match(token.regexp);\n\t\t\treturn token.method.bind(this, matching[1], matching[2], matching[3]);\n\t\t}\n\t\tif (token && token.value === \"(\"){\n\t\t\tlexer.next();\n\t\t\texpr = this._parseBinary(lexer);\n\t\t\ttoken = lexer.next();\n\t\t\tif (!(token && token.value === \")\")) {\n\t\t\t\tthrow new SyntaxError(\"Expected )\");\n\t\t\t}\n\t\t\treturn expr;\n\t\t}\n\t\tthrow new SyntaxError(\"Tone.TimeBase: Cannot process token \" + token.value);\n\t};\n\n\t/**\n\t * Recursively parse the string expression into a syntax tree.\n\t * @param {string} expr \n\t * @return {Function} the bound method to be evaluated later\n\t * @private\n\t */\n\tTone.TimeBase.prototype._parseExprString = function(exprString){\n\t\tif (!this.isString(exprString)){\n\t\t\texprString = exprString.toString();\n\t\t}\n\t\tvar lexer = this._tokenize(exprString);\n\t\tvar tree = this._parseBinary(lexer);\n\t\treturn tree;\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tDEFAULTS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * The initial expression value\n\t * @return {Number} The initial value 0\n\t * @private\n\t */\n\tTone.TimeBase.prototype._noOp = function(){\n\t\treturn 0;\n\t};\n\n\t/**\n\t * The default expression value if no arguments are given\n\t * @private\n\t */\n\tTone.TimeBase.prototype._defaultExpr = function(){\n\t\treturn this._noOp;\n\t};\n\n\t/**\n\t * The default units if none are given.\n\t * @private\n\t */\n\tTone.TimeBase.prototype._defaultUnits = \"s\";\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tUNIT CONVERSIONS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Returns the value of a frequency in the current units\n\t * @param {Frequency} freq\n\t * @return {Number}\n\t * @private\n\t */\n\tTone.TimeBase.prototype._frequencyToUnits = function(freq){\n\t\treturn 1/freq;\n\t};\n\n\t/**\n\t * Return the value of the beats in the current units\n\t * @param {Number} beats\n\t * @return {Number}\n\t * @private\n\t */\n\tTone.TimeBase.prototype._beatsToUnits = function(beats){\n\t\treturn (60 / Tone.Transport.bpm.value) * beats;\n\t};\n\n\t/**\n\t * Returns the value of a second in the current units\n\t * @param {Seconds} seconds\n\t * @return {Number}\n\t * @private\n\t */\n\tTone.TimeBase.prototype._secondsToUnits = function(seconds){\n\t\treturn seconds;\n\t};\n\n\t/**\n\t * Returns the value of a tick in the current time units\n\t * @param {Ticks} ticks\n\t * @return {Number}\n\t * @private\n\t */\n\tTone.TimeBase.prototype._ticksToUnits = function(ticks){\n\t\treturn ticks * (this._beatsToUnits(1) / Tone.Transport.PPQ);\n\t};\n\n\t/**\n\t * Return the time signature.\n\t * @return {Number}\n\t * @private\n\t */\n\tTone.TimeBase.prototype._timeSignature = function(){\n\t\treturn Tone.Transport.timeSignature;\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tEXPRESSIONS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Push an expression onto the expression list\n\t * @param {Time} val\n\t * @param {String} type\n\t * @param {String} units\n\t * @return {Tone.TimeBase} \n\t * @private\n\t */\n\tTone.TimeBase.prototype._pushExpr = function(val, name, units){\n\t\t//create the expression\n\t\tif (!(val instanceof Tone.TimeBase)){\n\t\t\tval = new this.constructor(val, units);\n\t\t}\n\t\tthis._expr = this._binaryExpressions[name].method.bind(this, this._expr, val._expr);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Add to the current value.\n\t * @param {Time} val The value to add\n\t * @param {String=} units Optional units to use with the value.\n\t * @return {Tone.TimeBase} this\n\t * @example\n\t * Tone.TimeBase(\"2m\").add(\"1m\"); //\"3m\"\n\t */\n\tTone.TimeBase.prototype.add = function(val, units){\n\t\treturn this._pushExpr(val, \"+\", units);\n\t};\n\n\t/**\n\t * Subtract the value from the current time.\n\t * @param {Time} val The value to subtract\n\t * @param {String=} units Optional units to use with the value.\n\t * @return {Tone.TimeBase} this\n\t * @example\n\t * Tone.TimeBase(\"2m\").sub(\"1m\"); //\"1m\"\n\t */\n\tTone.TimeBase.prototype.sub = function(val, units){\n\t\treturn this._pushExpr(val, \"-\", units);\n\t};\n\n\t/**\n\t * Multiply the current value by the given time.\n\t * @param {Time} val The value to multiply\n\t * @param {String=} units Optional units to use with the value.\n\t * @return {Tone.TimeBase} this\n\t * @example\n\t * Tone.TimeBase(\"2m\").mult(\"2\"); //\"4m\"\n\t */\n\tTone.TimeBase.prototype.mult = function(val, units){\n\t\treturn this._pushExpr(val, \"*\", units);\n\t};\n\n\t/**\n\t * Divide the current value by the given time.\n\t * @param {Time} val The value to divide by\n\t * @param {String=} units Optional units to use with the value.\n\t * @return {Tone.TimeBase} this\n\t * @example\n\t * Tone.TimeBase(\"2m\").div(2); //\"1m\"\n\t */\n\tTone.TimeBase.prototype.div = function(val, units){\n\t\treturn this._pushExpr(val, \"/\", units);\n\t};\n\n\t/**\n\t * Evaluate the time value. Returns the time\n\t * in seconds.\n\t * @return {Seconds} \n\t */\n\tTone.TimeBase.prototype.valueOf = function(){\n\t\treturn this._expr();\n\t};\n\n\t/**\n\t * Clean up\n\t * @return {Tone.TimeBase} this\n\t */\n\tTone.TimeBase.prototype.dispose = function(){\n\t\tthis._expr = null;\n\t};\n\n\treturn Tone.TimeBase;\n});","define([\"Tone/core/Tone\", \"Tone/type/Type\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Tone.Param wraps the native Web Audio's AudioParam to provide\n\t * additional unit conversion functionality. It also\n\t * serves as a base-class for classes which have a single,\n\t * automatable parameter. \n\t * @extends {Tone}\n\t * @param {AudioParam} param The parameter to wrap.\n\t * @param {Tone.Type} units The units of the audio param.\n\t * @param {Boolean} convert If the param should be converted.\n\t */\n\tTone.Param = function(){\n\n\t\tvar options = this.optionsObject(arguments, [\"param\", \"units\", \"convert\"], Tone.Param.defaults);\n\n\t\t/**\n\t\t * The native parameter to control\n\t\t * @type {AudioParam}\n\t\t * @private\n\t\t */\n\t\tthis._param = this.input = options.param;\n\n\t\t/**\n\t\t * The units of the parameter\n\t\t * @type {Tone.Type}\n\t\t */\n\t\tthis.units = options.units;\n\n\t\t/**\n\t\t * If the value should be converted or not\n\t\t * @type {Boolean}\n\t\t */\n\t\tthis.convert = options.convert;\n\n\t\t/**\n\t\t * True if the signal value is being overridden by \n\t\t * a connected signal.\n\t\t * @readOnly\n\t\t * @type {boolean}\n\t\t * @private\n\t\t */\n\t\tthis.overridden = false;\n\n\t\t/**\n\t\t * If there is an LFO, this is where it is held.\n\t\t * @type {Tone.LFO}\n\t\t * @private\n\t\t */\n\t\tthis._lfo = null;\n\n\t\tif (this.isObject(options.lfo)){\n\t\t\tthis.value = options.lfo;\n\t\t} else if (!this.isUndef(options.value)){\n\t\t\tthis.value = options.value;\n\t\t}\n\t};\n\n\tTone.extend(Tone.Param);\n\t\n\t/**\n\t * Defaults\n\t * @type {Object}\n\t * @const\n\t */\n\tTone.Param.defaults = {\n\t\t\"units\" : Tone.Type.Default,\n\t\t\"convert\" : true,\n\t\t\"param\" : undefined\n\t};\n\n\t/**\n\t * The current value of the parameter. \n\t * @memberOf Tone.Param#\n\t * @type {Number}\n\t * @name value\n\t */\n\tObject.defineProperty(Tone.Param.prototype, \"value\", {\n\t\tget : function(){\n\t\t\treturn this._toUnits(this._param.value);\n\t\t},\n\t\tset : function(value){\n\t\t\tif (this.isObject(value)){\n\t\t\t\t//throw an error if the LFO needs to be included\n\t\t\t\tif (this.isUndef(Tone.LFO)){\n\t\t\t\t\tthrow new Error(\"Include 'Tone.LFO' to use an LFO as a Param value.\");\n\t\t\t\t}\n\t\t\t\t//remove the old one\n\t\t\t\tif (this._lfo){\n\t\t\t\t\tthis._lfo.dispose();\n\t\t\t\t}\n\t\t\t\tthis._lfo = new Tone.LFO(value).start();\n\t\t\t\tthis._lfo.connect(this.input);\n\t\t\t} else {\n\t\t\t\tvar convertedVal = this._fromUnits(value);\n\t\t\t\tthis._param.cancelScheduledValues(0);\n\t\t\t\tthis._param.value = convertedVal;\n\t\t\t}\n\t\t}\n\t});\n\n\t/**\n\t * Convert the given value from the type specified by Tone.Param.units\n\t * into the destination value (such as Gain or Frequency).\n\t * @private\n\t * @param {*} val the value to convert\n\t * @return {number} the number which the value should be set to\n\t */\n\tTone.Param.prototype._fromUnits = function(val){\n\t\tif (this.convert || this.isUndef(this.convert)){\n\t\t\tswitch(this.units){\n\t\t\t\tcase Tone.Type.Time: \n\t\t\t\t\treturn this.toSeconds(val);\n\t\t\t\tcase Tone.Type.Frequency: \n\t\t\t\t\treturn this.toFrequency(val);\n\t\t\t\tcase Tone.Type.Decibels: \n\t\t\t\t\treturn this.dbToGain(val);\n\t\t\t\tcase Tone.Type.NormalRange: \n\t\t\t\t\treturn Math.min(Math.max(val, 0), 1);\n\t\t\t\tcase Tone.Type.AudioRange: \n\t\t\t\t\treturn Math.min(Math.max(val, -1), 1);\n\t\t\t\tcase Tone.Type.Positive: \n\t\t\t\t\treturn Math.max(val, 0);\n\t\t\t\tdefault:\n\t\t\t\t\treturn val;\n\t\t\t}\n\t\t} else {\n\t\t\treturn val;\n\t\t}\n\t};\n\n\t/**\n\t * Convert the parameters value into the units specified by Tone.Param.units.\n\t * @private\n\t * @param {number} val the value to convert\n\t * @return {number}\n\t */\n\tTone.Param.prototype._toUnits = function(val){\n\t\tif (this.convert || this.isUndef(this.convert)){\n\t\t\tswitch(this.units){\n\t\t\t\tcase Tone.Type.Decibels: \n\t\t\t\t\treturn this.gainToDb(val);\n\t\t\t\tdefault:\n\t\t\t\t\treturn val;\n\t\t\t}\n\t\t} else {\n\t\t\treturn val;\n\t\t}\n\t};\n\n\t/**\n\t * the minimum output value\n\t * @type {Number}\n\t * @private\n\t */\n\tTone.Param.prototype._minOutput = 0.00001;\n\n\t/**\n\t * Schedules a parameter value change at the given time.\n\t * @param {*}\tvalue The value to set the signal.\n\t * @param {Time} time The time when the change should occur.\n\t * @returns {Tone.Param} this\n\t * @example\n\t * //set the frequency to \"G4\" in exactly 1 second from now. \n\t * freq.setValueAtTime(\"G4\", \"+1\");\n\t */\n\tTone.Param.prototype.setValueAtTime = function(value, time){\n\t\tvalue = this._fromUnits(value);\n\t\ttime = this.toSeconds(time);\n\t\tif (time <= this.now() + this.blockTime){\n\t\t\tthis._param.value = value;\n\t\t} else {\n\t\t\tthis._param.setValueAtTime(value, time);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Creates a schedule point with the current value at the current time.\n\t * This is useful for creating an automation anchor point in order to \n\t * schedule changes from the current value. \n\t *\n\t * @param {number=} now (Optionally) pass the now value in. \n\t * @returns {Tone.Param} this\n\t */\n\tTone.Param.prototype.setRampPoint = function(now){\n\t\tnow = this.defaultArg(now, this.now());\n\t\tvar currentVal = this._param.value;\n\t\t// exponentialRampToValueAt cannot ever ramp from or to 0\n\t\t// More info: https://bugzilla.mozilla.org/show_bug.cgi?id=1125600#c2\n\t\tif (currentVal === 0){\n\t\t\tcurrentVal = this._minOutput;\n\t\t}\n\t\tthis._param.setValueAtTime(currentVal, now);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Schedules a linear continuous change in parameter value from the \n\t * previous scheduled parameter value to the given value.\n\t * \n\t * @param {number} value \n\t * @param {Time} endTime \n\t * @returns {Tone.Param} this\n\t */\n\tTone.Param.prototype.linearRampToValueAtTime = function(value, endTime){\n\t\tvalue = this._fromUnits(value);\n\t\tthis._param.linearRampToValueAtTime(value, this.toSeconds(endTime));\n\t\treturn this;\n\t};\n\n\t/**\n\t * Schedules an exponential continuous change in parameter value from \n\t * the previous scheduled parameter value to the given value.\n\t * \n\t * @param {number} value \n\t * @param {Time} endTime \n\t * @returns {Tone.Param} this\n\t */\n\tTone.Param.prototype.exponentialRampToValueAtTime = function(value, endTime){\n\t\tvalue = this._fromUnits(value);\n\t\tvalue = Math.max(this._minOutput, value);\n\t\tthis._param.exponentialRampToValueAtTime(value, this.toSeconds(endTime));\n\t\treturn this;\n\t};\n\n\t/**\n\t * Schedules an exponential continuous change in parameter value from \n\t * the current time and current value to the given value over the \n\t * duration of the rampTime.\n\t * \n\t * @param {number} value The value to ramp to.\n\t * @param {Time} rampTime the time that it takes the \n\t * value to ramp from it's current value\n\t * @param {Time}\t[startTime=now] \tWhen the ramp should start. \n\t * @returns {Tone.Param} this\n\t * @example\n\t * //exponentially ramp to the value 2 over 4 seconds. \n\t * signal.exponentialRampToValue(2, 4);\n\t */\n\tTone.Param.prototype.exponentialRampToValue = function(value, rampTime, startTime){\n\t\tstartTime = this.toSeconds(startTime);\n\t\tthis.setRampPoint(startTime);\n\t\tthis.exponentialRampToValueAtTime(value, startTime + this.toSeconds(rampTime));\n\t\treturn this;\n\t};\n\n\t/**\n\t * Schedules an linear continuous change in parameter value from \n\t * the current time and current value to the given value over the \n\t * duration of the rampTime.\n\t * \n\t * @param {number} value The value to ramp to.\n\t * @param {Time} rampTime the time that it takes the \n\t * value to ramp from it's current value\n\t * @param {Time}\t[startTime=now] \tWhen the ramp should start. \n\t * @returns {Tone.Param} this\n\t * @example\n\t * //linearly ramp to the value 4 over 3 seconds. \n\t * signal.linearRampToValue(4, 3);\n\t */\n\tTone.Param.prototype.linearRampToValue = function(value, rampTime, startTime){\n\t\tstartTime = this.toSeconds(startTime);\n\t\tthis.setRampPoint(startTime);\n\t\tthis.linearRampToValueAtTime(value, startTime + this.toSeconds(rampTime));\n\t\treturn this;\n\t};\n\n\t/**\n\t * Start exponentially approaching the target value at the given time with\n\t * a rate having the given time constant.\n\t * @param {number} value \n\t * @param {Time} startTime \n\t * @param {number} timeConstant \n\t * @returns {Tone.Param} this \n\t */\n\tTone.Param.prototype.setTargetAtTime = function(value, startTime, timeConstant){\n\t\tvalue = this._fromUnits(value);\n\t\t// The value will never be able to approach without timeConstant > 0.\n\t\t// http://www.w3.org/TR/webaudio/#dfn-setTargetAtTime, where the equation\n\t\t// is described. 0 results in a division by 0.\n\t\tvalue = Math.max(this._minOutput, value);\n\t\ttimeConstant = Math.max(this._minOutput, timeConstant);\n\t\tthis._param.setTargetAtTime(value, this.toSeconds(startTime), timeConstant);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Sets an array of arbitrary parameter values starting at the given time\n\t * for the given duration.\n\t * \t\n\t * @param {Array} values \n\t * @param {Time} startTime \n\t * @param {Time} duration \n\t * @returns {Tone.Param} this\n\t */\n\tTone.Param.prototype.setValueCurveAtTime = function(values, startTime, duration){\n\t\tfor (var i = 0; i < values.length; i++){\n\t\t\tvalues[i] = this._fromUnits(values[i]);\n\t\t}\n\t\tthis._param.setValueCurveAtTime(values, this.toSeconds(startTime), this.toSeconds(duration));\n\t\treturn this;\n\t};\n\n\t/**\n\t * Cancels all scheduled parameter changes with times greater than or \n\t * equal to startTime.\n\t * \n\t * @param {Time} startTime\n\t * @returns {Tone.Param} this\n\t */\n\tTone.Param.prototype.cancelScheduledValues = function(startTime){\n\t\tthis._param.cancelScheduledValues(this.toSeconds(startTime));\n\t\treturn this;\n\t};\n\n\t/**\n\t * Ramps to the given value over the duration of the rampTime. \n\t * Automatically selects the best ramp type (exponential or linear)\n\t * depending on the `units` of the signal\n\t * \n\t * @param {number} value \n\t * @param {Time} rampTime \tThe time that it takes the \n\t * value to ramp from it's current value\n\t * @param {Time}\t[startTime=now] \tWhen the ramp should start. \n\t * @returns {Tone.Param} this\n\t * @example\n\t * //ramp to the value either linearly or exponentially \n\t * //depending on the \"units\" value of the signal\n\t * signal.rampTo(0, 10);\n\t * @example\n\t * //schedule it to ramp starting at a specific time\n\t * signal.rampTo(0, 10, 5)\n\t */\n\tTone.Param.prototype.rampTo = function(value, rampTime, startTime){\n\t\trampTime = this.defaultArg(rampTime, 0);\n\t\tif (this.units === Tone.Type.Frequency || this.units === Tone.Type.BPM || this.units === Tone.Type.Decibels){\n\t\t\tthis.exponentialRampToValue(value, rampTime, startTime);\n\t\t} else {\n\t\t\tthis.linearRampToValue(value, rampTime, startTime);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * The LFO created by the signal instance. If none\n\t * was created, this is null.\n\t * @type {Tone.LFO}\n\t * @readOnly\n\t * @memberOf Tone.Param#\n\t * @name lfo\n\t */\n\tObject.defineProperty(Tone.Param.prototype, \"lfo\", {\n\t\tget : function(){\n\t\t\treturn this._lfo;\n\t\t}\n\t});\n\n\t/**\n\t * Clean up\n\t * @returns {Tone.Param} this\n\t */\n\tTone.Param.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._param = null;\n\t\tif (this._lfo){\n\t\t\tthis._lfo.dispose();\n\t\t\tthis._lfo = null;\n\t\t}\n\t\treturn this;\n\t};\n\n\treturn Tone.Param;\n});","'use strict';\n\ndefine(function (require) {\n var p5sound = require('master');\n\n var Add = require('Tone/signal/Add');\n var Mult = require('Tone/signal/Multiply');\n var Scale = require('Tone/signal/Scale');\n\n /**\n *

Creates a signal that oscillates between -1.0 and 1.0.\n * By default, the oscillation takes the form of a sinusoidal\n * shape ('sine'). Additional types include 'triangle',\n * 'sawtooth' and 'square'. The frequency defaults to\n * 440 oscillations per second (440Hz, equal to the pitch of an\n * 'A' note).

\n *\n *

Set the type of oscillation with setType(), or by instantiating a\n * specific oscillator: p5.SinOsc, p5.TriOsc, p5.SqrOsc, or p5.SawOsc.\n *

\n *\n * @class p5.Oscillator\n * @constructor\n * @param {Number} [freq] frequency defaults to 440Hz\n * @param {String} [type] type of oscillator. Options:\n * 'sine' (default), 'triangle',\n * 'sawtooth', 'square'\n * @example\n *
\n * let osc, playing, freq, amp;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playOscillator);\n * osc = new p5.Oscillator('sine');\n * }\n *\n * function draw() {\n * background(220)\n * freq = constrain(map(mouseX, 0, width, 100, 500), 100, 500);\n * amp = constrain(map(mouseY, height, 0, 0, 1), 0, 1);\n *\n * text('tap to play', 20, 20);\n * text('freq: ' + freq, 20, 40);\n * text('amp: ' + amp, 20, 60);\n *\n * if (playing) {\n * // smooth the transitions by 0.1 seconds\n * osc.freq(freq, 0.1);\n * osc.amp(amp, 0.1);\n * }\n * }\n *\n * function playOscillator() {\n * // starting an oscillator on a user gesture will enable audio\n * // in browsers that have a strict autoplay policy.\n * // See also: userStartAudio();\n * osc.start();\n * playing = true;\n * }\n *\n * function mouseReleased() {\n * // ramp amplitude to 0 over 0.5 seconds\n * osc.amp(0, 0.5);\n * playing = false;\n * }\n *
\n */\n p5.Oscillator = function(freq, type) {\n if (typeof freq === 'string') {\n var f = type;\n type = freq;\n freq = f;\n } if (typeof type === 'number') {\n var f = type;\n type = freq;\n freq = f;\n }\n this.started = false;\n\n // components\n this.phaseAmount = undefined;\n this.oscillator = p5sound.audiocontext.createOscillator();\n this.f = freq || 440.0; // frequency\n this.oscillator.type = type || 'sine';\n this.oscillator.frequency.setValueAtTime(this.f, p5sound.audiocontext.currentTime);\n\n // connections\n this.output = p5sound.audiocontext.createGain();\n\n this._freqMods = []; // modulators connected to this oscillator's frequency\n\n // set default output gain to 0.5\n this.output.gain.value = 0.5;\n this.output.gain.setValueAtTime(0.5, p5sound.audiocontext.currentTime);\n\n this.oscillator.connect(this.output);\n // stereo panning\n this.panPosition = 0.0;\n this.connection = p5sound.input; // connect to p5sound by default\n this.panner = new p5.Panner(this.output, this.connection, 1);\n\n //array of math operation signal chaining\n this.mathOps = [this.output];\n\n // add to the soundArray so we can dispose of the osc later\n p5sound.soundArray.push(this);\n };\n\n /**\n * Start an oscillator.\n *\n * Starting an oscillator on a user gesture will enable audio in browsers\n * that have a strict autoplay policy, including Chrome and most mobile\n * devices. See also: `userStartAudio()`.\n *\n * @method start\n * @for p5.Oscillator\n * @param {Number} [time] startTime in seconds from now.\n * @param {Number} [frequency] frequency in Hz.\n */\n p5.Oscillator.prototype.start = function(time, f) {\n if (this.started) {\n var now = p5sound.audiocontext.currentTime;\n this.stop(now);\n }\n if (!this.started) {\n var freq = f || this.f;\n var type = this.oscillator.type;\n\n // set old osc free to be garbage collected (memory)\n if (this.oscillator) {\n this.oscillator.disconnect();\n delete this.oscillator;\n }\n\n // var detune = this.oscillator.frequency.value;\n this.oscillator = p5sound.audiocontext.createOscillator();\n this.oscillator.frequency.value = Math.abs(freq);\n this.oscillator.type = type;\n // this.oscillator.detune.value = detune;\n this.oscillator.connect(this.output);\n time = time || 0;\n this.oscillator.start(time + p5sound.audiocontext.currentTime);\n this.freqNode = this.oscillator.frequency;\n\n // if other oscillators are already connected to this osc's freq\n for (var i in this._freqMods) {\n if (typeof this._freqMods[i].connect !== 'undefined') {\n this._freqMods[i].connect(this.oscillator.frequency);\n }\n }\n\n this.started = true;\n }\n };\n\n /**\n * Stop an oscillator. Accepts an optional parameter\n * to determine how long (in seconds from now) until the\n * oscillator stops.\n *\n * @method stop\n * @for p5.Oscillator\n * @param {Number} secondsFromNow Time, in seconds from now.\n */\n p5.Oscillator.prototype.stop = function(time) {\n if (this.started) {\n var t = time || 0;\n var now = p5sound.audiocontext.currentTime;\n this.oscillator.stop(t + now);\n this.started = false;\n }\n };\n\n /**\n * Set the amplitude between 0 and 1.0. Or, pass in an object\n * such as an oscillator to modulate amplitude with an audio signal.\n *\n * @method amp\n * @for p5.Oscillator\n * @param {Number|Object} vol between 0 and 1.0\n * or a modulating signal/oscillator\n * @param {Number} [rampTime] create a fade that lasts rampTime\n * @param {Number} [timeFromNow] schedule this event to happen\n * seconds from now\n * @return {AudioParam} gain If no value is provided,\n * returns the Web Audio API\n * AudioParam that controls\n * this oscillator's\n * gain/amplitude/volume)\n */\n p5.Oscillator.prototype.amp = function(vol, rampTime, tFromNow) {\n var self = this;\n if (typeof vol === 'number') {\n var rampTime = rampTime || 0;\n var tFromNow = tFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n this.output.gain.linearRampToValueAtTime(vol, now + tFromNow + rampTime);\n }\n\n else if (vol) {\n vol.connect(self.output.gain);\n } else {\n // return the Gain Node\n return this.output.gain;\n }\n };\n\n // these are now the same thing\n p5.Oscillator.prototype.fade = p5.Oscillator.prototype.amp;\n\n p5.Oscillator.prototype.getAmp = function() {\n return this.output.gain.value;\n };\n\n /**\n * Set frequency of an oscillator to a value. Or, pass in an object\n * such as an oscillator to modulate the frequency with an audio signal.\n *\n * @method freq\n * @for p5.Oscillator\n * @param {Number|Object} Frequency Frequency in Hz\n * or modulating signal/oscillator\n * @param {Number} [rampTime] Ramp time (in seconds)\n * @param {Number} [timeFromNow] Schedule this event to happen\n * at x seconds from now\n * @return {AudioParam} Frequency If no value is provided,\n * returns the Web Audio API\n * AudioParam that controls\n * this oscillator's frequency\n * @example\n *
\n * let osc;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playOscillator);\n * osc = new p5.Oscillator(300);\n * background(220);\n * text('tap to play', 20, 20);\n * }\n *\n * function playOscillator() {\n * osc.start();\n * osc.amp(0.5);\n * // start at 700Hz\n * osc.freq(700);\n * // ramp to 60Hz over 0.7 seconds\n * osc.freq(60, 0.7);\n * osc.amp(0, 0.1, 0.7);\n * }\n *
\n */\n p5.Oscillator.prototype.freq = function(val, rampTime, tFromNow) {\n if (typeof val === 'number' && !isNaN(val)) {\n this.f = val;\n var now = p5sound.audiocontext.currentTime;\n var rampTime = rampTime || 0;\n var tFromNow = tFromNow || 0;\n var t = now + tFromNow + rampTime;\n // var currentFreq = this.oscillator.frequency.value;\n // this.oscillator.frequency.cancelScheduledValues(now);\n\n if (rampTime === 0) {\n this.oscillator.frequency.setValueAtTime(val, tFromNow + now);\n } else {\n if (val > 0 ) {\n this.oscillator.frequency.exponentialRampToValueAtTime(val, tFromNow + rampTime + now);\n } else {\n this.oscillator.frequency.linearRampToValueAtTime(val, tFromNow + rampTime + now);\n }\n }\n\n // reset phase if oscillator has a phase\n if (this.phaseAmount) {\n this.phase(this.phaseAmount);\n }\n\n } else if (val) {\n if (val.output) {\n val = val.output;\n }\n val.connect(this.oscillator.frequency);\n\n // keep track of what is modulating this param\n // so it can be re-connected if\n this._freqMods.push( val );\n } else {\n // return the Frequency Node\n return this.oscillator.frequency;\n }\n };\n\n p5.Oscillator.prototype.getFreq = function() {\n return this.oscillator.frequency.value;\n };\n\n /**\n * Set type to 'sine', 'triangle', 'sawtooth' or 'square'.\n *\n * @method setType\n * @for p5.Oscillator\n * @param {String} type 'sine', 'triangle', 'sawtooth' or 'square'.\n */\n p5.Oscillator.prototype.setType = function(type) {\n this.oscillator.type = type;\n };\n\n p5.Oscillator.prototype.getType = function() {\n return this.oscillator.type;\n };\n\n /**\n * Connect to a p5.sound / Web Audio object.\n *\n * @method connect\n * @for p5.Oscillator\n * @param {Object} unit A p5.sound or Web Audio object\n */\n p5.Oscillator.prototype.connect = function(unit) {\n if (!unit) {\n this.panner.connect(p5sound.input);\n }\n else if (unit.hasOwnProperty('input')) {\n this.panner.connect(unit.input);\n this.connection = unit.input;\n }\n else {\n this.panner.connect(unit);\n this.connection = unit;\n }\n };\n\n /**\n * Disconnect all outputs\n *\n * @method disconnect\n * @for p5.Oscillator\n */\n p5.Oscillator.prototype.disconnect = function() {\n if (this.output) {\n this.output.disconnect();\n }\n if (this.panner) {\n this.panner.disconnect();\n if (this.output) {\n this.output.connect(this.panner);\n }\n }\n this.oscMods = [];\n };\n\n /**\n * Pan between Left (-1) and Right (1)\n *\n * @method pan\n * @for p5.Oscillator\n * @param {Number} panning Number between -1 and 1\n * @param {Number} timeFromNow schedule this event to happen\n * seconds from now\n */\n p5.Oscillator.prototype.pan = function(pval, tFromNow) {\n this.panPosition = pval;\n this.panner.pan(pval, tFromNow);\n };\n\n p5.Oscillator.prototype.getPan = function() {\n return this.panPosition;\n };\n\n // get rid of the oscillator\n p5.Oscillator.prototype.dispose = function() {\n // remove reference from soundArray\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n\n if (this.oscillator) {\n var now = p5sound.audiocontext.currentTime;\n this.stop(now);\n this.disconnect();\n this.panner = null;\n this.oscillator = null;\n }\n // if it is a Pulse\n if (this.osc2) {\n this.osc2.dispose();\n }\n };\n\n /**\n * Set the phase of an oscillator between 0.0 and 1.0.\n * In this implementation, phase is a delay time\n * based on the oscillator's current frequency.\n *\n * @method phase\n * @for p5.Oscillator\n * @param {Number} phase float between 0.0 and 1.0\n */\n p5.Oscillator.prototype.phase = function(p) {\n var delayAmt = p5.prototype.map(p, 0, 1.0, 0, 1/this.f);\n var now = p5sound.audiocontext.currentTime;\n\n this.phaseAmount = p;\n\n if (!this.dNode) {\n // create a delay node\n this.dNode = p5sound.audiocontext.createDelay();\n // put the delay node in between output and panner\n this.oscillator.disconnect();\n this.oscillator.connect(this.dNode);\n this.dNode.connect(this.output);\n }\n\n // set delay time to match phase:\n this.dNode.delayTime.setValueAtTime(delayAmt, now);\n };\n\n // ========================== //\n // SIGNAL MATH FOR MODULATION //\n // ========================== //\n\n // return sigChain(this, scale, thisChain, nextChain, Scale);\n var sigChain = function(o, mathObj, thisChain, nextChain, type) {\n var chainSource = o.oscillator;\n // if this type of math already exists in the chain, replace it\n for (var i in o.mathOps) {\n if (o.mathOps[i] instanceof type) {\n chainSource.disconnect();\n o.mathOps[i].dispose();\n thisChain = i;\n // assume nextChain is output gain node unless...\n if (thisChain < o.mathOps.length - 2) {\n nextChain = o.mathOps[i+1];\n }\n }\n }\n if (thisChain === o.mathOps.length - 1) {\n o.mathOps.push(nextChain);\n }\n // assume source is the oscillator unless i > 0\n if (i > 0) {\n chainSource = o.mathOps[i-1];\n }\n chainSource.disconnect();\n chainSource.connect(mathObj);\n mathObj.connect(nextChain);\n o.mathOps[thisChain] = mathObj;\n return o;\n };\n\n /**\n * Add a value to the p5.Oscillator's output amplitude,\n * and return the oscillator. Calling this method again\n * will override the initial add() with a new value.\n *\n * @method add\n * @for p5.Oscillator\n * @param {Number} number Constant number to add\n * @return {p5.Oscillator} Oscillator Returns this oscillator\n * with scaled output\n *\n */\n p5.Oscillator.prototype.add = function(num) {\n var add = new Add(num);\n var thisChain = this.mathOps.length-1;\n var nextChain = this.output;\n return sigChain(this, add, thisChain, nextChain, Add);\n };\n\n /**\n * Multiply the p5.Oscillator's output amplitude\n * by a fixed value (i.e. turn it up!). Calling this method\n * again will override the initial mult() with a new value.\n *\n * @method mult\n * @for p5.Oscillator\n * @param {Number} number Constant number to multiply\n * @return {p5.Oscillator} Oscillator Returns this oscillator\n * with multiplied output\n */\n p5.Oscillator.prototype.mult = function(num) {\n var mult = new Mult(num);\n var thisChain = this.mathOps.length-1;\n var nextChain = this.output;\n return sigChain(this, mult, thisChain, nextChain, Mult);\n };\n\n /**\n * Scale this oscillator's amplitude values to a given\n * range, and return the oscillator. Calling this method\n * again will override the initial scale() with new values.\n *\n * @method scale\n * @for p5.Oscillator\n * @param {Number} inMin input range minumum\n * @param {Number} inMax input range maximum\n * @param {Number} outMin input range minumum\n * @param {Number} outMax input range maximum\n * @return {p5.Oscillator} Oscillator Returns this oscillator\n * with scaled output\n */\n p5.Oscillator.prototype.scale = function(inMin, inMax, outMin, outMax) {\n var mapOutMin, mapOutMax;\n if (arguments.length === 4) {\n mapOutMin = p5.prototype.map(outMin, inMin, inMax, 0, 1) - 0.5;\n mapOutMax = p5.prototype.map(outMax, inMin, inMax, 0, 1) - 0.5;\n }\n else {\n mapOutMin = arguments[0];\n mapOutMax = arguments[1];\n }\n var scale = new Scale(mapOutMin, mapOutMax);\n var thisChain = this.mathOps.length-1;\n var nextChain = this.output;\n return sigChain(this, scale, thisChain, nextChain, Scale);\n\n // this.output.disconnect();\n // this.output.connect(scale)\n };\n\n // ============================== //\n // SinOsc, TriOsc, SqrOsc, SawOsc //\n // ============================== //\n\n /**\n * Constructor: new p5.SinOsc().\n * This creates a Sine Wave Oscillator and is\n * equivalent to new p5.Oscillator('sine')\n * or creating a p5.Oscillator and then calling\n * its method setType('sine').\n * See p5.Oscillator for methods.\n *\n * @class p5.SinOsc\n * @constructor\n * @extends p5.Oscillator\n * @param {Number} [freq] Set the frequency\n */\n p5.SinOsc = function(freq) {\n p5.Oscillator.call(this, freq, 'sine');\n };\n\n p5.SinOsc.prototype = Object.create(p5.Oscillator.prototype);\n\n /**\n * Constructor: new p5.TriOsc().\n * This creates a Triangle Wave Oscillator and is\n * equivalent to new p5.Oscillator('triangle')\n * or creating a p5.Oscillator and then calling\n * its method setType('triangle').\n * See p5.Oscillator for methods.\n *\n * @class p5.TriOsc\n * @constructor\n * @extends p5.Oscillator\n * @param {Number} [freq] Set the frequency\n */\n p5.TriOsc = function(freq) {\n p5.Oscillator.call(this, freq, 'triangle');\n };\n\n p5.TriOsc.prototype = Object.create(p5.Oscillator.prototype);\n\n /**\n * Constructor: new p5.SawOsc().\n * This creates a SawTooth Wave Oscillator and is\n * equivalent to new p5.Oscillator('sawtooth')\n * or creating a p5.Oscillator and then calling\n * its method setType('sawtooth').\n * See p5.Oscillator for methods.\n *\n * @class p5.SawOsc\n * @constructor\n * @extends p5.Oscillator\n * @param {Number} [freq] Set the frequency\n */\n p5.SawOsc = function(freq) {\n p5.Oscillator.call(this, freq, 'sawtooth');\n };\n\n p5.SawOsc.prototype = Object.create(p5.Oscillator.prototype);\n\n /**\n * Constructor: new p5.SqrOsc().\n * This creates a Square Wave Oscillator and is\n * equivalent to new p5.Oscillator('square')\n * or creating a p5.Oscillator and then calling\n * its method setType('square').\n * See p5.Oscillator for methods.\n *\n * @class p5.SqrOsc\n * @constructor\n * @extends p5.Oscillator\n * @param {Number} [freq] Set the frequency\n */\n p5.SqrOsc = function(freq) {\n p5.Oscillator.call(this, freq, 'square');\n };\n\n p5.SqrOsc.prototype = Object.create(p5.Oscillator.prototype);\n\n});\n","define([\"Tone/core/Tone\", \"Tone/type/Type\"], function (Tone) {\n\n\t\"use strict\";\n\n\t/**\n\t * @class A Timeline class for scheduling and maintaining state\n\t * along a timeline. All events must have a \"time\" property. \n\t * Internally, events are stored in time order for fast \n\t * retrieval.\n\t * @extends {Tone}\n\t * @param {Positive} [memory=Infinity] The number of previous events that are retained.\n\t */\n\tTone.Timeline = function(){\n\n\t\tvar options = this.optionsObject(arguments, [\"memory\"], Tone.Timeline.defaults);\n\n\t\t/**\n\t\t * The array of scheduled timeline events\n\t\t * @type {Array}\n\t\t * @private\n\t\t */\n\t\tthis._timeline = [];\n\n\t\t/**\n\t\t * An array of items to remove from the list. \n\t\t * @type {Array}\n\t\t * @private\n\t\t */\n\t\tthis._toRemove = [];\n\n\t\t/**\n\t\t * Flag if the tieline is mid iteration\n\t\t * @private\n\t\t * @type {Boolean}\n\t\t */\n\t\tthis._iterating = false;\n\n\t\t/**\n\t\t * The memory of the timeline, i.e.\n\t\t * how many events in the past it will retain\n\t\t * @type {Positive}\n\t\t */\n\t\tthis.memory = options.memory;\n\t};\n\n\tTone.extend(Tone.Timeline);\n\n\t/**\n\t * the default parameters\n\t * @static\n\t * @const\n\t */\n\tTone.Timeline.defaults = {\n\t\t\"memory\" : Infinity\n\t};\n\n\t/**\n\t * The number of items in the timeline.\n\t * @type {Number}\n\t * @memberOf Tone.Timeline#\n\t * @name length\n\t * @readOnly\n\t */\n\tObject.defineProperty(Tone.Timeline.prototype, \"length\", {\n\t\tget : function(){\n\t\t\treturn this._timeline.length;\n\t\t}\n\t});\n\n\t/**\n\t * Insert an event object onto the timeline. Events must have a \"time\" attribute.\n\t * @param {Object} event The event object to insert into the \n\t * timeline. \n\t * @returns {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.add = function(event){\n\t\t//the event needs to have a time attribute\n\t\tif (this.isUndef(event.time)){\n\t\t\tthrow new Error(\"Tone.Timeline: events must have a time attribute\");\n\t\t}\n\t\tif (this._timeline.length){\n\t\t\tvar index = this._search(event.time);\n\t\t\tthis._timeline.splice(index + 1, 0, event);\n\t\t} else {\n\t\t\tthis._timeline.push(event);\t\t\t\n\t\t}\n\t\t//if the length is more than the memory, remove the previous ones\n\t\tif (this.length > this.memory){\n\t\t\tvar diff = this.length - this.memory;\n\t\t\tthis._timeline.splice(0, diff);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Remove an event from the timeline.\n\t * @param {Object} event The event object to remove from the list.\n\t * @returns {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.remove = function(event){\n\t\tif (this._iterating){\n\t\t\tthis._toRemove.push(event);\n\t\t} else {\n\t\t\tvar index = this._timeline.indexOf(event);\n\t\t\tif (index !== -1){\n\t\t\t\tthis._timeline.splice(index, 1);\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Get the nearest event whose time is less than or equal to the given time.\n\t * @param {Number} time The time to query.\n\t * @returns {Object} The event object set after that time.\n\t */\n\tTone.Timeline.prototype.get = function(time){\n\t\tvar index = this._search(time);\n\t\tif (index !== -1){\n\t\t\treturn this._timeline[index];\n\t\t} else {\n\t\t\treturn null;\n\t\t}\n\t};\n\n\t/**\n\t * Return the first event in the timeline without removing it\n\t * @returns {Object} The first event object\n\t */\n\tTone.Timeline.prototype.peek = function(){\n\t\treturn this._timeline[0];\n\t};\n\n\t/**\n\t * Return the first event in the timeline and remove it\n\t * @returns {Object} The first event object\n\t */\n\tTone.Timeline.prototype.shift = function(){\n\t\treturn this._timeline.shift();\n\t};\n\n\t/**\n\t * Get the event which is scheduled after the given time.\n\t * @param {Number} time The time to query.\n\t * @returns {Object} The event object after the given time\n\t */\n\tTone.Timeline.prototype.getAfter = function(time){\n\t\tvar index = this._search(time);\n\t\tif (index + 1 < this._timeline.length){\n\t\t\treturn this._timeline[index + 1];\n\t\t} else {\n\t\t\treturn null;\n\t\t}\n\t};\n\n\t/**\n\t * Get the event before the event at the given time.\n\t * @param {Number} time The time to query.\n\t * @returns {Object} The event object before the given time\n\t */\n\tTone.Timeline.prototype.getBefore = function(time){\n\t\tvar len = this._timeline.length;\n\t\t//if it's after the last item, return the last item\n\t\tif (len > 0 && this._timeline[len - 1].time < time){\n\t\t\treturn this._timeline[len - 1];\n\t\t}\n\t\tvar index = this._search(time);\n\t\tif (index - 1 >= 0){\n\t\t\treturn this._timeline[index - 1];\n\t\t} else {\n\t\t\treturn null;\n\t\t}\n\t};\n\n\t/**\n\t * Cancel events after the given time\n\t * @param {Number} time The time to query.\n\t * @returns {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.cancel = function(after){\n\t\tif (this._timeline.length > 1){\n\t\t\tvar index = this._search(after);\n\t\t\tif (index >= 0){\n\t\t\t\tif (this._timeline[index].time === after){\n\t\t\t\t\t//get the first item with that time\n\t\t\t\t\tfor (var i = index; i >= 0; i--){\n\t\t\t\t\t\tif (this._timeline[i].time === after){\n\t\t\t\t\t\t\tindex = i;\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tthis._timeline = this._timeline.slice(0, index);\n\t\t\t\t} else {\n\t\t\t\t\tthis._timeline = this._timeline.slice(0, index + 1);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tthis._timeline = [];\n\t\t\t}\n\t\t} else if (this._timeline.length === 1){\n\t\t\t//the first item's time\n\t\t\tif (this._timeline[0].time >= after){\n\t\t\t\tthis._timeline = [];\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Cancel events before or equal to the given time.\n\t * @param {Number} time The time to cancel before.\n\t * @returns {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.cancelBefore = function(time){\n\t\tif (this._timeline.length){\n\t\t\tvar index = this._search(time);\n\t\t\tif (index >= 0){\n\t\t\t\tthis._timeline = this._timeline.slice(index + 1);\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Does a binary serach on the timeline array and returns the \n\t * nearest event index whose time is after or equal to the given time.\n\t * If a time is searched before the first index in the timeline, -1 is returned.\n\t * If the time is after the end, the index of the last item is returned.\n\t * @param {Number} time \n\t * @return {Number} the index in the timeline array \n\t * @private\n\t */\n\tTone.Timeline.prototype._search = function(time){\n\t\tvar beginning = 0;\n\t\tvar len = this._timeline.length;\n\t\tvar end = len;\n\t\tif (len > 0 && this._timeline[len - 1].time <= time){\n\t\t\treturn len - 1;\n\t\t}\n\t\twhile (beginning < end){\n\t\t\t// calculate the midpoint for roughly equal partition\n\t\t\tvar midPoint = Math.floor(beginning + (end - beginning) / 2);\n\t\t\tvar event = this._timeline[midPoint];\n\t\t\tvar nextEvent = this._timeline[midPoint + 1];\n\t\t\tif (event.time === time){\n\t\t\t\t//choose the last one that has the same time\n\t\t\t\tfor (var i = midPoint; i < this._timeline.length; i++){\n\t\t\t\t\tvar testEvent = this._timeline[i];\n\t\t\t\t\tif (testEvent.time === time){\n\t\t\t\t\t\tmidPoint = i;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn midPoint;\n\t\t\t} else if (event.time < time && nextEvent.time > time){\n\t\t\t\treturn midPoint;\n\t\t\t} else if (event.time > time){\n\t\t\t\t//search lower\n\t\t\t\tend = midPoint;\n\t\t\t} else if (event.time < time){\n\t\t\t\t//search upper\n\t\t\t\tbeginning = midPoint + 1;\n\t\t\t} \n\t\t}\n\t\treturn -1;\n\t};\n\n\t/**\n\t * Internal iterator. Applies extra safety checks for \n\t * removing items from the array. \n\t * @param {Function} callback \n\t * @param {Number=} lowerBound \n\t * @param {Number=} upperBound \n\t * @private\n\t */\n\tTone.Timeline.prototype._iterate = function(callback, lowerBound, upperBound){\n\t\tthis._iterating = true;\n\t\tlowerBound = this.defaultArg(lowerBound, 0);\n\t\tupperBound = this.defaultArg(upperBound, this._timeline.length - 1);\n\t\tfor (var i = lowerBound; i <= upperBound; i++){\n\t\t\tcallback(this._timeline[i]);\n\t\t}\n\t\tthis._iterating = false;\n\t\tif (this._toRemove.length > 0){\n\t\t\tfor (var j = 0; j < this._toRemove.length; j++){\n\t\t\t\tvar index = this._timeline.indexOf(this._toRemove[j]);\n\t\t\t\tif (index !== -1){\n\t\t\t\t\tthis._timeline.splice(index, 1);\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis._toRemove = [];\n\t\t}\n\t};\n\n\t/**\n\t * Iterate over everything in the array\n\t * @param {Function} callback The callback to invoke with every item\n\t * @returns {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.forEach = function(callback){\n\t\tthis._iterate(callback);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Iterate over everything in the array at or before the given time.\n\t * @param {Number} time The time to check if items are before\n\t * @param {Function} callback The callback to invoke with every item\n\t * @returns {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.forEachBefore = function(time, callback){\n\t\t//iterate over the items in reverse so that removing an item doesn't break things\n\t\tvar upperBound = this._search(time);\n\t\tif (upperBound !== -1){\n\t\t\tthis._iterate(callback, 0, upperBound);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Iterate over everything in the array after the given time.\n\t * @param {Number} time The time to check if items are before\n\t * @param {Function} callback The callback to invoke with every item\n\t * @returns {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.forEachAfter = function(time, callback){\n\t\t//iterate over the items in reverse so that removing an item doesn't break things\n\t\tvar lowerBound = this._search(time);\n\t\tthis._iterate(callback, lowerBound + 1);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Iterate over everything in the array at or after the given time. Similar to \n\t * forEachAfter, but includes the item(s) at the given time.\n\t * @param {Number} time The time to check if items are before\n\t * @param {Function} callback The callback to invoke with every item\n\t * @returns {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.forEachFrom = function(time, callback){\n\t\t//iterate over the items in reverse so that removing an item doesn't break things\n\t\tvar lowerBound = this._search(time);\n\t\t//work backwards until the event time is less than time\n\t\twhile (lowerBound >= 0 && this._timeline[lowerBound].time >= time){\n\t\t\tlowerBound--;\n\t\t}\n\t\tthis._iterate(callback, lowerBound + 1);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Iterate over everything in the array at the given time\n\t * @param {Number} time The time to check if items are before\n\t * @param {Function} callback The callback to invoke with every item\n\t * @returns {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.forEachAtTime = function(time, callback){\n\t\t//iterate over the items in reverse so that removing an item doesn't break things\n\t\tvar upperBound = this._search(time);\n\t\tif (upperBound !== -1){\n\t\t\tthis._iterate(function(event){\n\t\t\t\tif (event.time === time){\n\t\t\t\t\tcallback(event);\n\t\t\t\t} \n\t\t\t}, 0, upperBound);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Clean up.\n\t * @return {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._timeline = null;\n\t\tthis._toRemove = null;\n\t};\n\n\treturn Tone.Timeline;\n});","define([\"Tone/core/Tone\", \"Tone/signal/Multiply\", \"Tone/signal/Signal\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Negate the incoming signal. i.e. an input signal of 10 will output -10\n\t *\n\t * @constructor\n\t * @extends {Tone.SignalBase}\n\t * @example\n\t * var neg = new Tone.Negate();\n\t * var sig = new Tone.Signal(-2).connect(neg);\n\t * //output of neg is positive 2. \n\t */\n\tTone.Negate = function(){\n\t\t/**\n\t\t * negation is done by multiplying by -1\n\t\t * @type {Tone.Multiply}\n\t\t * @private\n\t\t */\n\t\tthis._multiply = this.input = this.output = new Tone.Multiply(-1);\n\t};\n\n\tTone.extend(Tone.Negate, Tone.SignalBase);\n\n\t/**\n\t * clean up\n\t * @returns {Tone.Negate} this\n\t */\n\tTone.Negate.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._multiply.dispose();\n\t\tthis._multiply = null;\n\t\treturn this;\n\t}; \n\n\treturn Tone.Negate;\n});","define([\"Tone/core/Tone\", \"Tone/signal/Signal\", \"Tone/signal/Multiply\", \"Tone/signal/WaveShaper\"], \nfunction(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class GreaterThanZero outputs 1 when the input is strictly greater than zero\n\t * \n\t * @constructor\n\t * @extends {Tone.SignalBase}\n\t * @example\n\t * var gt0 = new Tone.GreaterThanZero();\n\t * var sig = new Tone.Signal(0.01).connect(gt0);\n\t * //the output of gt0 is 1. \n\t * sig.value = 0;\n\t * //the output of gt0 is 0. \n\t */\n\tTone.GreaterThanZero = function(){\n\t\t\n\t\t/**\n\t\t * @type {Tone.WaveShaper}\n\t\t * @private\n\t\t */\n\t\tthis._thresh = this.output = new Tone.WaveShaper(function(val){\n\t\t\tif (val <= 0){\n\t\t\t\treturn 0;\n\t\t\t} else {\n\t\t\t\treturn 1;\n\t\t\t}\n\t\t}, 127);\n\n\t\t/**\n\t\t * scale the first thresholded signal by a large value.\n\t\t * this will help with values which are very close to 0\n\t\t * @type {Tone.Multiply}\n\t\t * @private\n\t\t */\n\t\tthis._scale = this.input = new Tone.Multiply(10000);\n\n\t\t//connections\n\t\tthis._scale.connect(this._thresh);\n\t};\n\n\tTone.extend(Tone.GreaterThanZero, Tone.SignalBase);\n\n\t/**\n\t * dispose method\n\t * @returns {Tone.GreaterThanZero} this\n\t */\n\tTone.GreaterThanZero.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._scale.dispose();\n\t\tthis._scale = null;\n\t\tthis._thresh.dispose();\n\t\tthis._thresh = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.GreaterThanZero;\n});","define([\"Tone/core/Tone\", \"Tone/signal/TimelineSignal\", \"Tone/core/TimelineState\", \n\t\"Tone/core/Emitter\", \"Tone/core/Context\"], function (Tone) {\n\n\t\"use strict\";\n\n\t/**\n\t * @class A sample accurate clock which provides a callback at the given rate. \n\t * While the callback is not sample-accurate (it is still susceptible to\n\t * loose JS timing), the time passed in as the argument to the callback\n\t * is precise. For most applications, it is better to use Tone.Transport\n\t * instead of the Clock by itself since you can synchronize multiple callbacks.\n\t *\n\t * \t@constructor\n\t * @extends {Tone.Emitter}\n\t * \t@param {function} callback The callback to be invoked with the time of the audio event\n\t * \t@param {Frequency} frequency The rate of the callback\n\t * \t@example\n\t * //the callback will be invoked approximately once a second\n\t * //and will print the time exactly once a second apart.\n\t * var clock = new Tone.Clock(function(time){\n\t * \tconsole.log(time);\n\t * }, 1);\n\t */\n\tTone.Clock = function(){\n\n\t\tTone.Emitter.call(this);\n\n\t\tvar options = this.optionsObject(arguments, [\"callback\", \"frequency\"], Tone.Clock.defaults);\n\n\t\t/**\n\t\t * The callback function to invoke at the scheduled tick.\n\t\t * @type {Function}\n\t\t */\n\t\tthis.callback = options.callback;\n\n\t\t/**\n\t\t * The next time the callback is scheduled.\n\t\t * @type {Number}\n\t\t * @private\n\t\t */\n\t\tthis._nextTick = 0;\n\n\t\t/**\n\t\t * The last state of the clock.\n\t\t * @type {State}\n\t\t * @private\n\t\t */\n\t\tthis._lastState = Tone.State.Stopped;\n\n\t\t/**\n\t\t * The rate the callback function should be invoked. \n\t\t * @type {BPM}\n\t\t * @signal\n\t\t */\n\t\tthis.frequency = new Tone.TimelineSignal(options.frequency, Tone.Type.Frequency);\n\t\tthis._readOnly(\"frequency\");\n\n\t\t/**\n\t\t * The number of times the callback was invoked. Starts counting at 0\n\t\t * and increments after the callback was invoked. \n\t\t * @type {Ticks}\n\t\t * @readOnly\n\t\t */\n\t\tthis.ticks = 0;\n\n\t\t/**\n\t\t * The state timeline\n\t\t * @type {Tone.TimelineState}\n\t\t * @private\n\t\t */\n\t\tthis._state = new Tone.TimelineState(Tone.State.Stopped);\n\n\t\t/**\n\t\t * The loop function bound to its context. \n\t\t * This is necessary to remove the event in the end.\n\t\t * @type {Function}\n\t\t * @private\n\t\t */\n\t\tthis._boundLoop = this._loop.bind(this);\n\n\t\t//bind a callback to the worker thread\n \tthis.context.on(\"tick\", this._boundLoop);\n\t};\n\n\tTone.extend(Tone.Clock, Tone.Emitter);\n\n\t/**\n\t * The defaults\n\t * @const\n\t * @type {Object}\n\t */\n\tTone.Clock.defaults = {\n\t\t\"callback\" : Tone.noOp,\n\t\t\"frequency\" : 1,\n\t\t\"lookAhead\" : \"auto\",\n\t};\n\n\t/**\n\t * Returns the playback state of the source, either \"started\", \"stopped\" or \"paused\".\n\t * @type {Tone.State}\n\t * @readOnly\n\t * @memberOf Tone.Clock#\n\t * @name state\n\t */\n\tObject.defineProperty(Tone.Clock.prototype, \"state\", {\n\t\tget : function(){\n\t\t\treturn this._state.getValueAtTime(this.now());\n\t\t}\n\t});\n\n\t/**\n\t * Start the clock at the given time. Optionally pass in an offset\n\t * of where to start the tick counter from.\n\t * @param {Time} time The time the clock should start\n\t * @param {Ticks=} offset Where the tick counter starts counting from.\n\t * @return {Tone.Clock} this\n\t */\n\tTone.Clock.prototype.start = function(time, offset){\n\t\ttime = this.toSeconds(time);\n\t\tif (this._state.getValueAtTime(time) !== Tone.State.Started){\n\t\t\tthis._state.add({\n\t\t\t\t\"state\" : Tone.State.Started, \n\t\t\t\t\"time\" : time,\n\t\t\t\t\"offset\" : offset\n\t\t\t});\n\t\t}\n\t\treturn this;\t\n\t};\n\n\t/**\n\t * Stop the clock. Stopping the clock resets the tick counter to 0.\n\t * @param {Time} [time=now] The time when the clock should stop.\n\t * @returns {Tone.Clock} this\n\t * @example\n\t * clock.stop();\n\t */\n\tTone.Clock.prototype.stop = function(time){\n\t\ttime = this.toSeconds(time);\n\t\tthis._state.cancel(time);\n\t\tthis._state.setStateAtTime(Tone.State.Stopped, time);\n\t\treturn this;\t\n\t};\n\n\n\t/**\n\t * Pause the clock. Pausing does not reset the tick counter.\n\t * @param {Time} [time=now] The time when the clock should stop.\n\t * @returns {Tone.Clock} this\n\t */\n\tTone.Clock.prototype.pause = function(time){\n\t\ttime = this.toSeconds(time);\n\t\tif (this._state.getValueAtTime(time) === Tone.State.Started){\n\t\t\tthis._state.setStateAtTime(Tone.State.Paused, time);\n\t\t}\n\t\treturn this;\t\n\t};\n\n\t/**\n\t * The scheduling loop.\n\t * @param {Number} time The current page time starting from 0\n\t * when the page was loaded.\n\t * @private\n\t */\n\tTone.Clock.prototype._loop = function(){\n\t\t//get the frequency value to compute the value of the next loop\n\t\tvar now = this.now();\n\t\t//if it's started\n\t\tvar lookAhead = this.context.lookAhead;\n\t\tvar updateInterval = this.context.updateInterval;\n\t\tvar lagCompensation = this.context.lag * 2;\n\t\tvar loopInterval = now + lookAhead + updateInterval + lagCompensation;\n\t\twhile (loopInterval > this._nextTick && this._state){\n\t\t\tvar currentState = this._state.getValueAtTime(this._nextTick);\n\t\t\tif (currentState !== this._lastState){\n\t\t\t\tthis._lastState = currentState;\n\t\t\t\tvar event = this._state.get(this._nextTick);\n\t\t\t\t// emit an event\n\t\t\t\tif (currentState === Tone.State.Started){\n\t\t\t\t\t//correct the time\n\t\t\t\t\tthis._nextTick = event.time;\n\t\t\t\t\tif (!this.isUndef(event.offset)){\n\t\t\t\t\t\tthis.ticks = event.offset;\n\t\t\t\t\t}\n\t\t\t\t\tthis.emit(\"start\", event.time, this.ticks);\n\t\t\t\t} else if (currentState === Tone.State.Stopped){\n\t\t\t\t\tthis.ticks = 0;\n\n\t\t\t\t\tthis.emit(\"stop\", event.time);\n\t\t\t\t} else if (currentState === Tone.State.Paused){\n\t\t\t\t\tthis.emit(\"pause\", event.time);\n\t\t\t\t}\n\t\t\t}\n\t\t\tvar tickTime = this._nextTick;\n\t\t\tif (this.frequency){\n\t\t\t\tthis._nextTick += 1 / this.frequency.getValueAtTime(this._nextTick);\n\t\t\t\tif (currentState === Tone.State.Started){\n\t\t\t\t\tthis.callback(tickTime);\n\t\t\t\t\tthis.ticks++;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n\n\t/**\n\t * Returns the scheduled state at the given time.\n\t * @param {Time} time The time to query.\n\t * @return {String} The name of the state input in setStateAtTime.\n\t * @example\n\t * clock.start(\"+0.1\");\n\t * clock.getStateAtTime(\"+0.1\"); //returns \"started\"\n\t */\n\tTone.Clock.prototype.getStateAtTime = function(time){\n\t\ttime = this.toSeconds(time);\n\t\treturn this._state.getValueAtTime(time);\n\t};\n\n\t/**\n\t * Clean up\n\t * @returns {Tone.Clock} this\n\t */\n\tTone.Clock.prototype.dispose = function(){\n\t\tTone.Emitter.prototype.dispose.call(this);\n\t\tthis.context.off(\"tick\", this._boundLoop);\n\t\tthis._writable(\"frequency\");\n\t\tthis.frequency.dispose();\n\t\tthis.frequency = null;\n\t\tthis._boundLoop = null;\n\t\tthis._nextTick = Infinity;\n\t\tthis.callback = null;\n\t\tthis._state.dispose();\n\t\tthis._state = null;\n\t};\n\n\treturn Tone.Clock;\n});","'use strict';\ndefine(function (require) {\n\n var p5sound = require('master');\n var AudioVoice = require('audioVoice');\n var noteToFreq = require('helpers').noteToFreq;\n\n var DEFAULT_SUSTAIN = 0.15;\n\n /**\n * A MonoSynth is used as a single voice for sound synthesis.\n * This is a class to be used in conjunction with the PolySynth\n * class. Custom synthetisers should be built inheriting from\n * this class.\n *\n * @class p5.MonoSynth\n * @constructor\n * @example\n *
\n * let monoSynth;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playSynth);\n * background(220);\n * textAlign(CENTER);\n * text('tap to play', width/2, height/2);\n *\n * monoSynth = new p5.MonoSynth();\n * }\n *\n * function playSynth() {\n * userStartAudio();\n *\n * let note = random(['Fb4', 'G4']);\n * // note velocity (volume, from 0 to 1)\n * let velocity = random();\n * // time from now (in seconds)\n * let time = 0;\n * // note duration (in seconds)\n * let dur = 1/6;\n *\n * monoSynth.play(note, velocity, time, dur);\n * }\n *
\n **/\n\n p5.MonoSynth = function () {\n AudioVoice.call(this);\n\n this.oscillator = new p5.Oscillator();\n\n this.env = new p5.Envelope();\n this.env.setRange(1, 0);\n this.env.setExp(true);\n\n //set params\n this.setADSR(0.02, 0.25, 0.05, 0.35);\n\n // oscillator --> env --> this.output (gain) --> p5.soundOut\n this.oscillator.disconnect();\n this.oscillator.connect(this.output);\n\n this.env.disconnect();\n this.env.setInput(this.output.gain);\n\n // reset oscillator gain to 1.0\n this.oscillator.output.gain.value = 1.0;\n\n this.oscillator.start();\n this.connect();\n\n p5sound.soundArray.push(this);\n };\n\n p5.MonoSynth.prototype = Object.create(p5.AudioVoice.prototype);\n\n /**\n * Play tells the MonoSynth to start playing a note. This method schedules\n * the calling of .triggerAttack and .triggerRelease.\n *\n * @method play\n * @for p5.MonoSynth\n * @param {String | Number} note the note you want to play, specified as a\n * frequency in Hertz (Number) or as a midi\n * value in Note/Octave format (\"C4\", \"Eb3\"...etc\")\n * See \n * Tone. Defaults to 440 hz.\n * @param {Number} [velocity] velocity of the note to play (ranging from 0 to 1)\n * @param {Number} [secondsFromNow] time from now (in seconds) at which to play\n * @param {Number} [sustainTime] time to sustain before releasing the envelope. Defaults to 0.15 seconds.\n * @example\n *
\n * let monoSynth;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playSynth);\n * background(220);\n * textAlign(CENTER);\n * text('tap to play', width/2, height/2);\n *\n * monoSynth = new p5.MonoSynth();\n * }\n *\n * function playSynth() {\n * userStartAudio();\n *\n * let note = random(['Fb4', 'G4']);\n * // note velocity (volume, from 0 to 1)\n * let velocity = random();\n * // time from now (in seconds)\n * let time = 0;\n * // note duration (in seconds)\n * let dur = 1/6;\n *\n * monoSynth.play(note, velocity, time, dur);\n * }\n *
\n *\n */\n p5.MonoSynth.prototype.play = function (note, velocity, secondsFromNow, susTime) {\n this.triggerAttack(note, velocity, ~~secondsFromNow);\n this.triggerRelease(~~secondsFromNow + (susTime || DEFAULT_SUSTAIN));\n };\n\n /**\n * Trigger the Attack, and Decay portion of the Envelope.\n * Similar to holding down a key on a piano, but it will\n * hold the sustain level until you let go.\n *\n * @param {String | Number} note the note you want to play, specified as a\n * frequency in Hertz (Number) or as a midi\n * value in Note/Octave format (\"C4\", \"Eb3\"...etc\")\n * See \n * Tone. Defaults to 440 hz\n * @param {Number} [velocity] velocity of the note to play (ranging from 0 to 1)\n * @param {Number} [secondsFromNow] time from now (in seconds) at which to play\n * @method triggerAttack\n * @for p5.MonoSynth\n * @example\n *
\n * let monoSynth;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(triggerAttack);\n * background(220);\n * text('tap here for attack, let go to release', 5, 20, width - 20);\n * monoSynth = new p5.MonoSynth();\n * }\n *\n * function triggerAttack() {\n * userStartAudio();\n *\n * monoSynth.triggerAttack(\"E3\");\n * }\n *\n * function mouseReleased() {\n * monoSynth.triggerRelease();\n * }\n *
\n */\n p5.MonoSynth.prototype.triggerAttack = function (note, velocity, secondsFromNow) {\n var secondsFromNow = ~~secondsFromNow;\n var freq = noteToFreq(note);\n var vel = velocity || 0.1;\n this.oscillator.freq(freq, 0, secondsFromNow);\n this.env.ramp(this.output.gain, secondsFromNow, vel);\n };\n\n /**\n * Trigger the release of the Envelope. This is similar to releasing\n * the key on a piano and letting the sound fade according to the\n * release level and release time.\n *\n * @param {Number} secondsFromNow time to trigger the release\n * @method triggerRelease\n * @for p5.MonoSynth\n * @example\n *
\n * let monoSynth;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(triggerAttack);\n * background(220);\n * text('tap here for attack, let go to release', 5, 20, width - 20);\n * monoSynth = new p5.MonoSynth();\n * }\n *\n * function triggerAttack() {\n * userStartAudio();\n *\n * monoSynth.triggerAttack(\"E3\");\n * }\n *\n * function mouseReleased() {\n * monoSynth.triggerRelease();\n * }\n *
\n */\n p5.MonoSynth.prototype.triggerRelease = function (secondsFromNow) {\n var secondsFromNow = secondsFromNow || 0;\n this.env.ramp(this.output.gain, secondsFromNow, 0);\n };\n\n /**\n * Set values like a traditional\n * \n * ADSR envelope\n * .\n *\n * @method setADSR\n * @for p5.MonoSynth\n * @param {Number} attackTime Time (in seconds before envelope\n * reaches Attack Level\n * @param {Number} [decayTime] Time (in seconds) before envelope\n * reaches Decay/Sustain Level\n * @param {Number} [susRatio] Ratio between attackLevel and releaseLevel, on a scale from 0 to 1,\n * where 1.0 = attackLevel, 0.0 = releaseLevel.\n * The susRatio determines the decayLevel and the level at which the\n * sustain portion of the envelope will sustain.\n * For example, if attackLevel is 0.4, releaseLevel is 0,\n * and susAmt is 0.5, the decayLevel would be 0.2. If attackLevel is\n * increased to 1.0 (using setRange),\n * then decayLevel would increase proportionally, to become 0.5.\n * @param {Number} [releaseTime] Time in seconds from now (defaults to 0)\n */\n p5.MonoSynth.prototype.setADSR = function (attack,decay,sustain,release) {\n this.env.setADSR(attack, decay, sustain, release);\n };\n\n\n /**\n * Getters and Setters\n * @property {Number} attack\n * @for p5.MonoSynth\n */\n /**\n * @property {Number} decay\n * @for p5.MonoSynth\n */\n /**\n * @property {Number} sustain\n * @for p5.MonoSynth\n */\n /**\n * @property {Number} release\n * @for p5.MonoSynth\n */\n Object.defineProperties(p5.MonoSynth.prototype, {\n 'attack': {\n get : function() {\n return this.env.aTime;\n },\n set : function(attack) {\n this.env.setADSR(attack, this.env.dTime,\n this.env.sPercent, this.env.rTime);\n }\n },\n 'decay': {\n get : function() {\n return this.env.dTime;\n },\n set : function(decay) {\n this.env.setADSR(this.env.aTime, decay,\n this.env.sPercent, this.env.rTime);\n }\n },\n 'sustain': {\n get : function() {\n return this.env.sPercent;\n },\n set : function(sustain) {\n this.env.setADSR(this.env.aTime, this.env.dTime,\n sustain, this.env.rTime);\n }\n },\n 'release': {\n get : function() {\n return this.env.rTime;\n },\n set : function(release) {\n this.env.setADSR(this.env.aTime, this.env.dTime,\n this.env.sPercent, release);\n }\n },\n });\n\n\n /**\n * MonoSynth amp\n * @method amp\n * @for p5.MonoSynth\n * @param {Number} vol desired volume\n * @param {Number} [rampTime] Time to reach new volume\n * @return {Number} new volume value\n */\n p5.MonoSynth.prototype.amp = function(vol, rampTime) {\n var t = rampTime || 0;\n if (typeof vol !== 'undefined') {\n this.oscillator.amp(vol, t);\n }\n return this.oscillator.amp().value;\n };\n\n /**\n * Connect to a p5.sound / Web Audio object.\n *\n * @method connect\n * @for p5.MonoSynth\n * @param {Object} unit A p5.sound or Web Audio object\n */\n\n p5.MonoSynth.prototype.connect = function(unit) {\n var u = unit || p5sound.input;\n this.output.connect(u.input ? u.input : u);\n };\n\n /**\n * Disconnect all outputs\n *\n * @method disconnect\n * @for p5.MonoSynth\n */\n p5.MonoSynth.prototype.disconnect = function() {\n if (this.output) {\n this.output.disconnect();\n }\n };\n\n\n /**\n * Get rid of the MonoSynth and free up its resources / memory.\n *\n * @method dispose\n * @for p5.MonoSynth\n */\n p5.MonoSynth.prototype.dispose = function() {\n AudioVoice.prototype.dispose.apply(this);\n\n if (this.env) {\n this.env.dispose();\n }\n if (this.oscillator) {\n this.oscillator.dispose();\n }\n };\n\n});\n","'use strict';\ndefine(function() {\n var p5sound = require('master');\n\n /**\n * Base class for monophonic synthesizers. Any extensions of this class\n * should follow the API and implement the methods below in order to\n * remain compatible with p5.PolySynth();\n *\n * @class p5.AudioVoice\n * @constructor\n */\n p5.AudioVoice = function () {\n\t this.ac = p5sound.audiocontext;\n\t this.output = this.ac.createGain();\n\t this.connect();\n\t p5sound.soundArray.push(this);\n };\n\n p5.AudioVoice.prototype.play = function (note, velocity, secondsFromNow, sustime) {\n };\n\n p5.AudioVoice.prototype.triggerAttack = function (note, velocity, secondsFromNow) {\n };\n\n p5.AudioVoice.prototype.triggerRelease = function (secondsFromNow) {\n };\n\n p5.AudioVoice.prototype.amp = function(vol, rampTime) {\n };\n\n /**\n * Connect to p5 objects or Web Audio Nodes\n * @method connect\n * @for p5.AudioVoice\n * @param {Object} unit\n */\n p5.AudioVoice.prototype.connect = function(unit) {\n var u = unit || p5sound.input;\n this.output.connect(u.input ? u.input : u);\n };\n\n /**\n * Disconnect from soundOut\n * @method disconnect\n * @for p5.AudioVoice\n */\n p5.AudioVoice.prototype.disconnect = function() {\n this.output.disconnect();\n };\n\n p5.AudioVoice.prototype.dispose = function() {\n if (this.output) {\n this.output.disconnect();\n delete this.output;\n }\n };\n\n return p5.AudioVoice;\n});\n","'use strict';\ndefine(function (require) {\n\n var p5sound = require('master');\n var TimelineSignal = require('Tone/signal/TimelineSignal');\n var noteToFreq = require('helpers').noteToFreq;\n\n /**\n * An AudioVoice is used as a single voice for sound synthesis.\n * The PolySynth class holds an array of AudioVoice, and deals\n * with voices allocations, with setting notes to be played, and\n * parameters to be set.\n *\n * @class p5.PolySynth\n * @constructor\n *\n * @param {Number} [synthVoice] A monophonic synth voice inheriting\n * the AudioVoice class. Defaults to p5.MonoSynth\n * @param {Number} [maxVoices] Number of voices, defaults to 8;\n * @example\n *
\n * let polySynth;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playSynth);\n * background(220);\n * text('click to play', 20, 20);\n *\n * polySynth = new p5.PolySynth();\n * }\n *\n * function playSynth() {\n * userStartAudio();\n *\n * // note duration (in seconds)\n * let dur = 1.5;\n *\n * // time from now (in seconds)\n * let time = 0;\n *\n * // velocity (volume, from 0 to 1)\n * let vel = 0.1;\n *\n * // notes can overlap with each other\n * polySynth.play('G2', vel, 0, dur);\n * polySynth.play('C3', vel, time += 1/3, dur);\n * polySynth.play('G3', vel, time += 1/3, dur);\n * }\n *
\n **/\n p5.PolySynth = function(audioVoice, maxVoices) {\n //audiovoices will contain maxVoices many monophonic synths\n this.audiovoices = [];\n\n /**\n * An object that holds information about which notes have been played and\n * which notes are currently being played. New notes are added as keys\n * on the fly. While a note has been attacked, but not released, the value of the\n * key is the audiovoice which is generating that note. When notes are released,\n * the value of the key becomes undefined.\n * @property notes\n */\n this.notes = {};\n\n //indices of the most recently used, and least recently used audiovoice\n this._newest = 0;\n this._oldest = 0;\n\n /**\n * A PolySynth must have at least 1 voice, defaults to 8\n * @property polyvalue\n */\n this.maxVoices = maxVoices || 8;\n\n /**\n * Monosynth that generates the sound for each note that is triggered. The\n * p5.PolySynth defaults to using the p5.MonoSynth as its voice.\n * @property AudioVoice\n */\n this.AudioVoice = audioVoice === undefined ? p5.MonoSynth : audioVoice;\n\n /**\n * This value must only change as a note is attacked or released. Due to delay\n * and sustain times, Tone.TimelineSignal is required to schedule the change in value.\n\t * @private\n * @property {Tone.TimelineSignal} _voicesInUse\n */\n this._voicesInUse = new TimelineSignal(0);\n\n this.output = p5sound.audiocontext.createGain();\n this.connect();\n\n //Construct the appropriate number of audiovoices\n this._allocateVoices();\n p5sound.soundArray.push(this);\n };\n\n /**\n * Construct the appropriate number of audiovoices\n * @private\n * @for p5.PolySynth\n * @method _allocateVoices\n */\n p5.PolySynth.prototype._allocateVoices = function() {\n for(var i = 0; i< this.maxVoices; i++) {\n this.audiovoices.push(new this.AudioVoice());\n this.audiovoices[i].disconnect();\n this.audiovoices[i].connect(this.output);\n }\n };\n\n /**\n * Play a note by triggering noteAttack and noteRelease with sustain time\n *\n * @method play\n * @for p5.PolySynth\n * @param {Number} [note] midi note to play (ranging from 0 to 127 - 60 being a middle C)\n * @param {Number} [velocity] velocity of the note to play (ranging from 0 to 1)\n * @param {Number} [secondsFromNow] time from now (in seconds) at which to play\n * @param {Number} [sustainTime] time to sustain before releasing the envelope\n * @example\n *
\n * let polySynth;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playSynth);\n * background(220);\n * text('click to play', 20, 20);\n *\n * polySynth = new p5.PolySynth();\n * }\n *\n * function playSynth() {\n * userStartAudio();\n *\n * // note duration (in seconds)\n * let dur = 1.5;\n *\n * // time from now (in seconds)\n * let time = 0;\n *\n * // velocity (volume, from 0 to 1)\n * let vel = 0.1;\n *\n * // notes can overlap with each other\n * polySynth.play('G2', vel, 0, dur);\n * polySynth.play('C3', vel, time += 1/3, dur);\n * polySynth.play('G3', vel, time += 1/3, dur);\n * }\n *
\n */\n p5.PolySynth.prototype.play = function (note,velocity, secondsFromNow, susTime) {\n var susTime = susTime || 1;\n this.noteAttack(note, velocity, secondsFromNow);\n this.noteRelease(note, secondsFromNow + susTime);\n };\n\n\n /**\n * noteADSR sets the envelope for a specific note that has just been triggered.\n * Using this method modifies the envelope of whichever audiovoice is being used\n * to play the desired note. The envelope should be reset before noteRelease is called\n * in order to prevent the modified envelope from being used on other notes.\n *\n * @method noteADSR\n * @for p5.PolySynth\n * @param {Number} [note] Midi note on which ADSR should be set.\n * @param {Number} [attackTime] Time (in seconds before envelope\n * reaches Attack Level\n * @param {Number} [decayTime] Time (in seconds) before envelope\n * reaches Decay/Sustain Level\n * @param {Number} [susRatio] Ratio between attackLevel and releaseLevel, on a scale from 0 to 1,\n * where 1.0 = attackLevel, 0.0 = releaseLevel.\n * The susRatio determines the decayLevel and the level at which the\n * sustain portion of the envelope will sustain.\n * For example, if attackLevel is 0.4, releaseLevel is 0,\n * and susAmt is 0.5, the decayLevel would be 0.2. If attackLevel is\n * increased to 1.0 (using setRange),\n * then decayLevel would increase proportionally, to become 0.5.\n * @param {Number} [releaseTime] Time in seconds from now (defaults to 0)\n **/\n\n p5.PolySynth.prototype.noteADSR = function (note,a,d,s,r,timeFromNow) {\n var now = p5sound.audiocontext.currentTime;\n var timeFromNow = timeFromNow || 0;\n var t = now + timeFromNow\n this.audiovoices[ this.notes[note].getValueAtTime(t) ].setADSR(a,d,s,r);\n };\n\n\n /**\n * Set the PolySynths global envelope. This method modifies the envelopes of each\n * monosynth so that all notes are played with this envelope.\n *\n * @method setADSR\n * @for p5.PolySynth\n * @param {Number} [attackTime] Time (in seconds before envelope\n * reaches Attack Level\n * @param {Number} [decayTime] Time (in seconds) before envelope\n * reaches Decay/Sustain Level\n * @param {Number} [susRatio] Ratio between attackLevel and releaseLevel, on a scale from 0 to 1,\n * where 1.0 = attackLevel, 0.0 = releaseLevel.\n * The susRatio determines the decayLevel and the level at which the\n * sustain portion of the envelope will sustain.\n * For example, if attackLevel is 0.4, releaseLevel is 0,\n * and susAmt is 0.5, the decayLevel would be 0.2. If attackLevel is\n * increased to 1.0 (using setRange),\n * then decayLevel would increase proportionally, to become 0.5.\n * @param {Number} [releaseTime] Time in seconds from now (defaults to 0)\n **/\n p5.PolySynth.prototype.setADSR = function(a,d,s,r) {\n this.audiovoices.forEach(function(voice) {\n voice.setADSR(a,d,s,r);\n });\n };\n\n /**\n * Trigger the Attack, and Decay portion of a MonoSynth.\n * Similar to holding down a key on a piano, but it will\n * hold the sustain level until you let go.\n *\n * @method noteAttack\n * @for p5.PolySynth\n * @param {Number} [note] midi note on which attack should be triggered.\n * @param {Number} [velocity] velocity of the note to play (ranging from 0 to 1)/\n * @param {Number} [secondsFromNow] time from now (in seconds)\n * @example\n *
\n * let polySynth = new p5.PolySynth();\n * let pitches = ['G', 'D', 'G', 'C'];\n * let octaves = [2, 3, 4];\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playChord);\n * background(220);\n * text('tap to play', 20, 20);\n * }\n *\n * function playChord() {\n * userStartAudio();\n *\n * // play a chord: multiple notes at the same time\n * for (let i = 0; i < 4; i++) {\n * let note = random(pitches) + random(octaves);\n * polySynth.noteAttack(note, 0.1);\n * }\n * }\n *\n * function mouseReleased() {\n * // release all voices\n * polySynth.noteRelease();\n * }\n *
\n */\n p5.PolySynth.prototype.noteAttack = function (_note, _velocity, secondsFromNow) {\n //this value goes to the audiovoices which handle their own scheduling\n var secondsFromNow = ~~secondsFromNow;\n\n //this value is used by this._voicesInUse\n var acTime = p5sound.audiocontext.currentTime + secondsFromNow;\n\n //Convert note to frequency if necessary. This is because entries into this.notes\n //should be based on frequency for the sake of consistency.\n var note = noteToFreq(_note);\n var velocity = _velocity || 0.1;\n\n var currentVoice;\n\n //Release the note if it is already playing\n if (this.notes[note] && this.notes[note].getValueAtTime(acTime) !== null) {\n this.noteRelease(note, 0);\n }\n\n //Check to see how many voices are in use at the time the note will start\n if (this._voicesInUse.getValueAtTime(acTime) < this.maxVoices) {\n currentVoice = Math.max(~~this._voicesInUse.getValueAtTime(acTime), 0);\n }\n //If we are exceeding the polyvalue, bump off the oldest notes and replace\n //with a new note\n else {\n currentVoice = this._oldest;\n\n var oldestNote = p5.prototype.freqToMidi(this.audiovoices[this._oldest].oscillator.freq().value);\n this.noteRelease(oldestNote);\n this._oldest = ( this._oldest + 1 ) % (this.maxVoices - 1);\n }\n\n //Overrite the entry in the notes object. A note (frequency value)\n //corresponds to the index of the audiovoice that is playing it\n this.notes[note] = new TimelineSignal();\n this.notes[note].setValueAtTime(currentVoice, acTime);\n\n //Find the scheduled change in this._voicesInUse that will be previous to this new note\n //Add 1 and schedule this value at time 't', when this note will start playing\n var previousVal = this._voicesInUse._searchBefore(acTime) === null ? 0 : this._voicesInUse._searchBefore(acTime).value;\n this._voicesInUse.setValueAtTime(previousVal + 1, acTime);\n\n //Then update all scheduled values that follow to increase by 1\n this._updateAfter(acTime, 1);\n\n this._newest = currentVoice;\n //The audiovoice handles the actual scheduling of the note\n if (typeof velocity === 'number') {\n var maxRange = 1 / this._voicesInUse.getValueAtTime(acTime) * 2;\n velocity = velocity > maxRange ? maxRange : velocity;\n }\n this.audiovoices[currentVoice].triggerAttack(note, velocity, secondsFromNow);\n };\n\n /**\n * Private method to ensure accurate values of this._voicesInUse\n * Any time a new value is scheduled, it is necessary to increment all subsequent\n * scheduledValues after attack, and decrement all subsequent\n * scheduledValues after release\n *\n * @private\n * @for p5.PolySynth\n * @param {[type]} time [description]\n * @param {[type]} value [description]\n * @return {[type]} [description]\n */\n p5.PolySynth.prototype._updateAfter = function(time, value) {\n if(this._voicesInUse._searchAfter(time) === null) {\n return;\n } else{\n this._voicesInUse._searchAfter(time).value += value;\n var nextTime = this._voicesInUse._searchAfter(time).time;\n this._updateAfter(nextTime, value);\n }\n };\n\n\n /**\n * Trigger the Release of an AudioVoice note. This is similar to releasing\n * the key on a piano and letting the sound fade according to the\n * release level and release time.\n *\n * @method noteRelease\n * @for p5.PolySynth\n * @param {Number} [note] midi note on which attack should be triggered.\n * If no value is provided, all notes will be released.\n * @param {Number} [secondsFromNow] time to trigger the release\n * @example\n *
\n * let polySynth = new p5.PolySynth();\n * let pitches = ['G', 'D', 'G', 'C'];\n * let octaves = [2, 3, 4];\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playChord);\n * background(220);\n * text('tap to play', 20, 20);\n * }\n *\n * function playChord() {\n * userStartAudio();\n *\n * // play a chord: multiple notes at the same time\n * for (let i = 0; i < 4; i++) {\n * let note = random(pitches) + random(octaves);\n * polySynth.noteAttack(note, 0.1);\n * }\n * }\n *\n * function mouseReleased() {\n * // release all voices\n * polySynth.noteRelease();\n * }\n *
\n *\n */\n p5.PolySynth.prototype.noteRelease = function (_note,secondsFromNow) {\n var now = p5sound.audiocontext.currentTime;\n var tFromNow = secondsFromNow || 0;\n var t = now + tFromNow;\n\n // if a note value is not provided, release all voices\n if (!_note) {\n this.audiovoices.forEach(function(voice) {\n voice.triggerRelease(tFromNow)\n });\n this._voicesInUse.setValueAtTime(0, t);\n for (var n in this.notes) {\n this.notes[n].dispose();\n delete this.notes[n];\n }\n return;\n }\n\n //Make sure note is in frequency inorder to query the this.notes object\n var note = noteToFreq(_note);\n\n if (!this.notes[note] || this.notes[note].getValueAtTime(t) === null) {\n console.warn('Cannot release a note that is not already playing');\n } else {\n //Find the scheduled change in this._voicesInUse that will be previous to this new note\n //subtract 1 and schedule this value at time 't', when this note will stop playing\n var previousVal = Math.max(~~this._voicesInUse.getValueAtTime(t).value, 1);\n this._voicesInUse.setValueAtTime(previousVal - 1, t);\n //Then update all scheduled values that follow to decrease by 1 but never go below 0\n if (previousVal > 0) {\n this._updateAfter(t, -1);\n }\n\n this.audiovoices[ this.notes[note].getValueAtTime(t) ].triggerRelease(tFromNow);\n this.notes[note].dispose();\n delete this.notes[note];\n\n this._newest = this._newest === 0 ? 0 : (this._newest - 1) % (this.maxVoices - 1);\n }\n\n };\n\n /**\n * Connect to a p5.sound / Web Audio object.\n *\n * @method connect\n * @for p5.PolySynth\n * @param {Object} unit A p5.sound or Web Audio object\n */\n p5.PolySynth.prototype.connect = function (unit) {\n var u = unit || p5sound.input;\n this.output.connect(u.input ? u.input : u);\n };\n\n /**\n * Disconnect all outputs\n *\n * @method disconnect\n * @for p5.PolySynth\n */\n p5.PolySynth.prototype.disconnect = function() {\n if (this.output) {\n this.output.disconnect();\n }\n };\n\n /**\n * Get rid of the MonoSynth and free up its resources / memory.\n *\n * @method dispose\n * @for p5.PolySynth\n */\n p5.PolySynth.prototype.dispose = function() {\n this.audiovoices.forEach(function(voice) {\n voice.dispose();\n });\n\n if (this.output) {\n this.output.disconnect();\n delete this.output;\n }\n };\n\n});\n","'use strict';\n\ndefine(function (require) {\n\n require('audioworklet-polyfill');\n require('shims');\n require('audiocontext');\n var p5SOUND = require('master');\n require('helpers');\n require('errorHandler');\n require('audioWorklet');\n require('panner');\n require('soundfile');\n require('amplitude');\n require('fft');\n require('signal');\n require('oscillator');\n require('envelope');\n require('pulse');\n require('noise');\n require('audioin');\n require('filter');\n require('eq');\n require('panner3d');\n require('listener3d');\n require('delay');\n require('reverb');\n require('metro');\n require('looper');\n require('soundLoop');\n require('compressor');\n require('soundRecorder');\n require('peakDetect');\n require('gain');\n require('monosynth');\n require('polysynth');\n require('distortion');\n require('audioVoice');\n require('monosynth');\n require('polysynth');\n\n return p5SOUND;\n\n});\n","!function(){var e,t=[];function r(e){var r=this,n={},i=-1;this.parameters.forEach(function(e,o){var s=t[++i]||(t[i]=new Float32Array(r.bufferSize));s.fill(e.value),n[o]=s}),this.processor.realm.exec(\"self.sampleRate=sampleRate=\"+this.context.sampleRate+\";self.currentTime=currentTime=\"+this.context.currentTime);var s=o(e.inputBuffer),a=o(e.outputBuffer);this.instance.process([s],[a],n)}function o(e){for(var t=[],r=0;r= this._length) {\\n this._writeIndex = 0;\\n } // For excessive frames, the buffer will be overwritten.\\n\\n\\n this._framesAvailable += sourceLength;\\n\\n if (this._framesAvailable > this._length) {\\n this._framesAvailable = this._length;\\n }\\n }\\n /**\\n * Pull data out of buffer and fill a given sequence of Float32Arrays.\\n *\\n * @param {array} arraySequence An array of Float32Arrays.\\n */\\n\\n }, {\\n key: \\\"pull\\\",\\n value: function pull(arraySequence) {\\n // The channel count of arraySequence and the length of each channel must\\n // match with this buffer obejct.\\n // If the FIFO is completely empty, do nothing.\\n if (this._framesAvailable === 0) {\\n return;\\n }\\n\\n var destinationLength = arraySequence[0].length; // Transfer data from the internal buffer to the |arraySequence| storage.\\n\\n for (var i = 0; i < destinationLength; ++i) {\\n var readIndex = (this._readIndex + i) % this._length;\\n\\n for (var channel = 0; channel < this._channelCount; ++channel) {\\n arraySequence[channel][i] = this._channelData[channel][readIndex];\\n }\\n }\\n\\n this._readIndex += destinationLength;\\n\\n if (this._readIndex >= this._length) {\\n this._readIndex = 0;\\n }\\n\\n this._framesAvailable -= destinationLength;\\n\\n if (this._framesAvailable < 0) {\\n this._framesAvailable = 0;\\n }\\n }\\n }, {\\n key: \\\"framesAvailable\\\",\\n get: function get() {\\n return this._framesAvailable;\\n }\\n }]);\\n\\n return RingBuffer;\\n }()\\n}[\\\"default\\\"];\\n\\nvar RecorderProcessor =\\n/*#__PURE__*/\\nfunction (_AudioWorkletProcesso) {\\n _inherits(RecorderProcessor, _AudioWorkletProcesso);\\n\\n function RecorderProcessor(options) {\\n var _this;\\n\\n _classCallCheck(this, RecorderProcessor);\\n\\n _this = _possibleConstructorReturn(this, _getPrototypeOf(RecorderProcessor).call(this));\\n var processorOptions = options.processorOptions || {};\\n _this.numOutputChannels = options.outputChannelCount || 2;\\n _this.numInputChannels = processorOptions.numInputChannels || 2;\\n _this.bufferSize = processorOptions.bufferSize || 1024;\\n _this.recording = false;\\n\\n _this.clear();\\n\\n _this.port.onmessage = function (event) {\\n var data = event.data;\\n\\n if (data.name === 'start') {\\n _this.record(data.duration);\\n } else if (data.name === 'stop') {\\n _this.stop();\\n }\\n };\\n\\n return _this;\\n }\\n\\n _createClass(RecorderProcessor, [{\\n key: \\\"process\\\",\\n value: function process(inputs) {\\n if (!this.recording) {\\n return true;\\n } else if (this.sampleLimit && this.recordedSamples >= this.sampleLimit) {\\n this.stop();\\n return true;\\n }\\n\\n var input = inputs[0];\\n this.inputRingBuffer.push(input);\\n\\n if (this.inputRingBuffer.framesAvailable >= this.bufferSize) {\\n this.inputRingBuffer.pull(this.inputRingBufferArraySequence);\\n\\n for (var channel = 0; channel < this.numOutputChannels; ++channel) {\\n var inputChannelCopy = this.inputRingBufferArraySequence[channel].slice();\\n\\n if (channel === 0) {\\n this.leftBuffers.push(inputChannelCopy);\\n\\n if (this.numInputChannels === 1) {\\n this.rightBuffers.push(inputChannelCopy);\\n }\\n } else if (channel === 1 && this.numInputChannels > 1) {\\n this.rightBuffers.push(inputChannelCopy);\\n }\\n }\\n\\n this.recordedSamples += this.bufferSize;\\n }\\n\\n return true;\\n }\\n }, {\\n key: \\\"record\\\",\\n value: function record(duration) {\\n if (duration) {\\n this.sampleLimit = Math.round(duration * sampleRate);\\n }\\n\\n this.recording = true;\\n }\\n }, {\\n key: \\\"stop\\\",\\n value: function stop() {\\n this.recording = false;\\n var buffers = this.getBuffers();\\n var leftBuffer = buffers[0].buffer;\\n var rightBuffer = buffers[1].buffer;\\n this.port.postMessage({\\n name: 'buffers',\\n leftBuffer: leftBuffer,\\n rightBuffer: rightBuffer\\n }, [leftBuffer, rightBuffer]);\\n this.clear();\\n }\\n }, {\\n key: \\\"getBuffers\\\",\\n value: function getBuffers() {\\n var buffers = [];\\n buffers.push(this.mergeBuffers(this.leftBuffers));\\n buffers.push(this.mergeBuffers(this.rightBuffers));\\n return buffers;\\n }\\n }, {\\n key: \\\"mergeBuffers\\\",\\n value: function mergeBuffers(channelBuffer) {\\n var result = new Float32Array(this.recordedSamples);\\n var offset = 0;\\n var lng = channelBuffer.length;\\n\\n for (var i = 0; i < lng; i++) {\\n var buffer = channelBuffer[i];\\n result.set(buffer, offset);\\n offset += buffer.length;\\n }\\n\\n return result;\\n }\\n }, {\\n key: \\\"clear\\\",\\n value: function clear() {\\n var _this2 = this;\\n\\n this.leftBuffers = [];\\n this.rightBuffers = [];\\n this.inputRingBuffer = new RingBuffer(this.bufferSize, this.numInputChannels);\\n this.inputRingBufferArraySequence = new Array(this.numInputChannels).fill(null).map(function () {\\n return new Float32Array(_this2.bufferSize);\\n });\\n this.recordedSamples = 0;\\n this.sampleLimit = null;\\n }\\n }]);\\n\\n return RecorderProcessor;\\n}(_wrapNativeSuper(AudioWorkletProcessor));\\n\\nregisterProcessor(processorNames.recorderProcessor, RecorderProcessor);\"","export default \"function _typeof(obj) { if (typeof Symbol === \\\"function\\\" && typeof Symbol.iterator === \\\"symbol\\\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \\\"function\\\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \\\"symbol\\\" : typeof obj; }; } return _typeof(obj); }\\n\\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \\\"object\\\" || typeof call === \\\"function\\\")) { return call; } return _assertThisInitialized(self); }\\n\\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\\\"this hasn't been initialised - super() hasn't been called\\\"); } return self; }\\n\\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \\\"function\\\" && superClass !== null) { throw new TypeError(\\\"Super expression must either be null or a function\\\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }\\n\\nfunction _wrapNativeSuper(Class) { var _cache = typeof Map === \\\"function\\\" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== \\\"function\\\") { throw new TypeError(\\\"Super expression must either be null or a function\\\"); } if (typeof _cache !== \\\"undefined\\\") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }\\n\\nfunction isNativeReflectConstruct() { if (typeof Reflect === \\\"undefined\\\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \\\"function\\\") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\\n\\nfunction _construct(Parent, args, Class) { if (isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }\\n\\nfunction _isNativeFunction(fn) { return Function.toString.call(fn).indexOf(\\\"[native code]\\\") !== -1; }\\n\\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\\n\\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\\n\\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\\\"Cannot call a class as a function\\\"); } }\\n\\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\\\"value\\\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\\n\\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\\n\\n// import dependencies via preval.require so that they're available as values at compile time\\nvar processorNames = {\\n \\\"recorderProcessor\\\": \\\"recorder-processor\\\",\\n \\\"soundFileProcessor\\\": \\\"sound-file-processor\\\",\\n \\\"amplitudeProcessor\\\": \\\"amplitude-processor\\\"\\n};\\nvar RingBuffer = {\\n \\\"default\\\":\\n /*#__PURE__*/\\n function () {\\n /**\\n * @constructor\\n * @param {number} length Buffer length in frames.\\n * @param {number} channelCount Buffer channel count.\\n */\\n function RingBuffer(length, channelCount) {\\n _classCallCheck(this, RingBuffer);\\n\\n this._readIndex = 0;\\n this._writeIndex = 0;\\n this._framesAvailable = 0;\\n this._channelCount = channelCount;\\n this._length = length;\\n this._channelData = [];\\n\\n for (var i = 0; i < this._channelCount; ++i) {\\n this._channelData[i] = new Float32Array(length);\\n }\\n }\\n /**\\n * Getter for Available frames in buffer.\\n *\\n * @return {number} Available frames in buffer.\\n */\\n\\n\\n _createClass(RingBuffer, [{\\n key: \\\"push\\\",\\n\\n /**\\n * Push a sequence of Float32Arrays to buffer.\\n *\\n * @param {array} arraySequence A sequence of Float32Arrays.\\n */\\n value: function push(arraySequence) {\\n // The channel count of arraySequence and the length of each channel must\\n // match with this buffer obejct.\\n // Transfer data from the |arraySequence| storage to the internal buffer.\\n var sourceLength = arraySequence[0].length;\\n\\n for (var i = 0; i < sourceLength; ++i) {\\n var writeIndex = (this._writeIndex + i) % this._length;\\n\\n for (var channel = 0; channel < this._channelCount; ++channel) {\\n this._channelData[channel][writeIndex] = arraySequence[channel][i];\\n }\\n }\\n\\n this._writeIndex += sourceLength;\\n\\n if (this._writeIndex >= this._length) {\\n this._writeIndex = 0;\\n } // For excessive frames, the buffer will be overwritten.\\n\\n\\n this._framesAvailable += sourceLength;\\n\\n if (this._framesAvailable > this._length) {\\n this._framesAvailable = this._length;\\n }\\n }\\n /**\\n * Pull data out of buffer and fill a given sequence of Float32Arrays.\\n *\\n * @param {array} arraySequence An array of Float32Arrays.\\n */\\n\\n }, {\\n key: \\\"pull\\\",\\n value: function pull(arraySequence) {\\n // The channel count of arraySequence and the length of each channel must\\n // match with this buffer obejct.\\n // If the FIFO is completely empty, do nothing.\\n if (this._framesAvailable === 0) {\\n return;\\n }\\n\\n var destinationLength = arraySequence[0].length; // Transfer data from the internal buffer to the |arraySequence| storage.\\n\\n for (var i = 0; i < destinationLength; ++i) {\\n var readIndex = (this._readIndex + i) % this._length;\\n\\n for (var channel = 0; channel < this._channelCount; ++channel) {\\n arraySequence[channel][i] = this._channelData[channel][readIndex];\\n }\\n }\\n\\n this._readIndex += destinationLength;\\n\\n if (this._readIndex >= this._length) {\\n this._readIndex = 0;\\n }\\n\\n this._framesAvailable -= destinationLength;\\n\\n if (this._framesAvailable < 0) {\\n this._framesAvailable = 0;\\n }\\n }\\n }, {\\n key: \\\"framesAvailable\\\",\\n get: function get() {\\n return this._framesAvailable;\\n }\\n }]);\\n\\n return RingBuffer;\\n }()\\n}[\\\"default\\\"];\\n\\nvar SoundFileProcessor =\\n/*#__PURE__*/\\nfunction (_AudioWorkletProcesso) {\\n _inherits(SoundFileProcessor, _AudioWorkletProcesso);\\n\\n function SoundFileProcessor(options) {\\n var _this;\\n\\n _classCallCheck(this, SoundFileProcessor);\\n\\n _this = _possibleConstructorReturn(this, _getPrototypeOf(SoundFileProcessor).call(this));\\n var processorOptions = options.processorOptions || {};\\n _this.bufferSize = processorOptions.bufferSize || 256;\\n _this.inputRingBuffer = new RingBuffer(_this.bufferSize, 1);\\n _this.inputRingBufferArraySequence = [new Float32Array(_this.bufferSize)];\\n return _this;\\n }\\n\\n _createClass(SoundFileProcessor, [{\\n key: \\\"process\\\",\\n value: function process(inputs) {\\n var input = inputs[0]; // we only care about the first input channel, because that contains the position data\\n\\n this.inputRingBuffer.push([input[0]]);\\n\\n if (this.inputRingBuffer.framesAvailable >= this.bufferSize) {\\n this.inputRingBuffer.pull(this.inputRingBufferArraySequence);\\n var inputChannel = this.inputRingBufferArraySequence[0];\\n var position = inputChannel[inputChannel.length - 1] || 0;\\n this.port.postMessage({\\n name: 'position',\\n position: position\\n });\\n }\\n\\n return true;\\n }\\n }]);\\n\\n return SoundFileProcessor;\\n}(_wrapNativeSuper(AudioWorkletProcessor));\\n\\nregisterProcessor(processorNames.soundFileProcessor, SoundFileProcessor);\"","export default \"function _typeof(obj) { if (typeof Symbol === \\\"function\\\" && typeof Symbol.iterator === \\\"symbol\\\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \\\"function\\\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \\\"symbol\\\" : typeof obj; }; } return _typeof(obj); }\\n\\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \\\"object\\\" || typeof call === \\\"function\\\")) { return call; } return _assertThisInitialized(self); }\\n\\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\\\"this hasn't been initialised - super() hasn't been called\\\"); } return self; }\\n\\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \\\"function\\\" && superClass !== null) { throw new TypeError(\\\"Super expression must either be null or a function\\\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }\\n\\nfunction _wrapNativeSuper(Class) { var _cache = typeof Map === \\\"function\\\" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== \\\"function\\\") { throw new TypeError(\\\"Super expression must either be null or a function\\\"); } if (typeof _cache !== \\\"undefined\\\") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }\\n\\nfunction isNativeReflectConstruct() { if (typeof Reflect === \\\"undefined\\\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \\\"function\\\") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\\n\\nfunction _construct(Parent, args, Class) { if (isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }\\n\\nfunction _isNativeFunction(fn) { return Function.toString.call(fn).indexOf(\\\"[native code]\\\") !== -1; }\\n\\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\\n\\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\\n\\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\\\"Cannot call a class as a function\\\"); } }\\n\\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\\\"value\\\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\\n\\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\\n\\n// import dependencies via preval.require so that they're available as values at compile time\\nvar processorNames = {\\n \\\"recorderProcessor\\\": \\\"recorder-processor\\\",\\n \\\"soundFileProcessor\\\": \\\"sound-file-processor\\\",\\n \\\"amplitudeProcessor\\\": \\\"amplitude-processor\\\"\\n};\\nvar RingBuffer = {\\n \\\"default\\\":\\n /*#__PURE__*/\\n function () {\\n /**\\n * @constructor\\n * @param {number} length Buffer length in frames.\\n * @param {number} channelCount Buffer channel count.\\n */\\n function RingBuffer(length, channelCount) {\\n _classCallCheck(this, RingBuffer);\\n\\n this._readIndex = 0;\\n this._writeIndex = 0;\\n this._framesAvailable = 0;\\n this._channelCount = channelCount;\\n this._length = length;\\n this._channelData = [];\\n\\n for (var i = 0; i < this._channelCount; ++i) {\\n this._channelData[i] = new Float32Array(length);\\n }\\n }\\n /**\\n * Getter for Available frames in buffer.\\n *\\n * @return {number} Available frames in buffer.\\n */\\n\\n\\n _createClass(RingBuffer, [{\\n key: \\\"push\\\",\\n\\n /**\\n * Push a sequence of Float32Arrays to buffer.\\n *\\n * @param {array} arraySequence A sequence of Float32Arrays.\\n */\\n value: function push(arraySequence) {\\n // The channel count of arraySequence and the length of each channel must\\n // match with this buffer obejct.\\n // Transfer data from the |arraySequence| storage to the internal buffer.\\n var sourceLength = arraySequence[0].length;\\n\\n for (var i = 0; i < sourceLength; ++i) {\\n var writeIndex = (this._writeIndex + i) % this._length;\\n\\n for (var channel = 0; channel < this._channelCount; ++channel) {\\n this._channelData[channel][writeIndex] = arraySequence[channel][i];\\n }\\n }\\n\\n this._writeIndex += sourceLength;\\n\\n if (this._writeIndex >= this._length) {\\n this._writeIndex = 0;\\n } // For excessive frames, the buffer will be overwritten.\\n\\n\\n this._framesAvailable += sourceLength;\\n\\n if (this._framesAvailable > this._length) {\\n this._framesAvailable = this._length;\\n }\\n }\\n /**\\n * Pull data out of buffer and fill a given sequence of Float32Arrays.\\n *\\n * @param {array} arraySequence An array of Float32Arrays.\\n */\\n\\n }, {\\n key: \\\"pull\\\",\\n value: function pull(arraySequence) {\\n // The channel count of arraySequence and the length of each channel must\\n // match with this buffer obejct.\\n // If the FIFO is completely empty, do nothing.\\n if (this._framesAvailable === 0) {\\n return;\\n }\\n\\n var destinationLength = arraySequence[0].length; // Transfer data from the internal buffer to the |arraySequence| storage.\\n\\n for (var i = 0; i < destinationLength; ++i) {\\n var readIndex = (this._readIndex + i) % this._length;\\n\\n for (var channel = 0; channel < this._channelCount; ++channel) {\\n arraySequence[channel][i] = this._channelData[channel][readIndex];\\n }\\n }\\n\\n this._readIndex += destinationLength;\\n\\n if (this._readIndex >= this._length) {\\n this._readIndex = 0;\\n }\\n\\n this._framesAvailable -= destinationLength;\\n\\n if (this._framesAvailable < 0) {\\n this._framesAvailable = 0;\\n }\\n }\\n }, {\\n key: \\\"framesAvailable\\\",\\n get: function get() {\\n return this._framesAvailable;\\n }\\n }]);\\n\\n return RingBuffer;\\n }()\\n}[\\\"default\\\"];\\n\\nvar AmplitudeProcessor =\\n/*#__PURE__*/\\nfunction (_AudioWorkletProcesso) {\\n _inherits(AmplitudeProcessor, _AudioWorkletProcesso);\\n\\n function AmplitudeProcessor(options) {\\n var _this;\\n\\n _classCallCheck(this, AmplitudeProcessor);\\n\\n _this = _possibleConstructorReturn(this, _getPrototypeOf(AmplitudeProcessor).call(this));\\n var processorOptions = options.processorOptions || {};\\n _this.numOutputChannels = options.outputChannelCount || 1;\\n _this.numInputChannels = processorOptions.numInputChannels || 2;\\n _this.normalize = processorOptions.normalize || false;\\n _this.smoothing = processorOptions.smoothing || 0;\\n _this.bufferSize = processorOptions.bufferSize || 2048;\\n _this.inputRingBuffer = new RingBuffer(_this.bufferSize, _this.numInputChannels);\\n _this.outputRingBuffer = new RingBuffer(_this.bufferSize, _this.numOutputChannels);\\n _this.inputRingBufferArraySequence = new Array(_this.numInputChannels).fill(null).map(function () {\\n return new Float32Array(_this.bufferSize);\\n });\\n _this.stereoVol = [0, 0];\\n _this.stereoVolNorm = [0, 0];\\n _this.volMax = 0.001;\\n\\n _this.port.onmessage = function (event) {\\n var data = event.data;\\n\\n if (data.name === 'toggleNormalize') {\\n _this.normalize = data.normalize;\\n } else if (data.name === 'smoothing') {\\n _this.smoothing = Math.max(0, Math.min(1, data.smoothing));\\n }\\n };\\n\\n return _this;\\n } // TO DO make this stereo / dependent on # of audio channels\\n\\n\\n _createClass(AmplitudeProcessor, [{\\n key: \\\"process\\\",\\n value: function process(inputs, outputs) {\\n var input = inputs[0];\\n var output = outputs[0];\\n var smoothing = this.smoothing;\\n this.inputRingBuffer.push(input);\\n\\n if (this.inputRingBuffer.framesAvailable >= this.bufferSize) {\\n this.inputRingBuffer.pull(this.inputRingBufferArraySequence);\\n\\n for (var channel = 0; channel < this.numInputChannels; ++channel) {\\n var inputBuffer = this.inputRingBufferArraySequence[channel];\\n var bufLength = inputBuffer.length;\\n var sum = 0;\\n\\n for (var i = 0; i < bufLength; i++) {\\n var x = inputBuffer[i];\\n\\n if (this.normalize) {\\n sum += Math.max(Math.min(x / this.volMax, 1), -1) * Math.max(Math.min(x / this.volMax, 1), -1);\\n } else {\\n sum += x * x;\\n }\\n } // ... then take the square root of the sum.\\n\\n\\n var rms = Math.sqrt(sum / bufLength);\\n this.stereoVol[channel] = Math.max(rms, this.stereoVol[channel] * smoothing);\\n this.volMax = Math.max(this.stereoVol[channel], this.volMax);\\n } // calculate stero normalized volume and add volume from all channels together\\n\\n\\n var volSum = 0;\\n\\n for (var index = 0; index < this.stereoVol.length; index++) {\\n this.stereoVolNorm[index] = Math.max(Math.min(this.stereoVol[index] / this.volMax, 1), 0);\\n volSum += this.stereoVol[index];\\n } // volume is average of channels\\n\\n\\n var volume = volSum / this.stereoVol.length; // normalized value\\n\\n var volNorm = Math.max(Math.min(volume / this.volMax, 1), 0);\\n this.port.postMessage({\\n name: 'amplitude',\\n volume: volume,\\n volNorm: volNorm,\\n stereoVol: this.stereoVol,\\n stereoVolNorm: this.stereoVolNorm\\n }); // pass input through to output\\n\\n this.outputRingBuffer.push(this.inputRingBufferArraySequence);\\n } // pull 128 frames out of the ring buffer\\n // if the ring buffer does not have enough frames, the output will be silent\\n\\n\\n this.outputRingBuffer.pull(output);\\n return true;\\n }\\n }]);\\n\\n return AmplitudeProcessor;\\n}(_wrapNativeSuper(AudioWorkletProcessor));\\n\\nregisterProcessor(processorNames.amplitudeProcessor, AmplitudeProcessor);\"","'use strict';\n\ndefine(function (require) {\n\n var p5sound = require('master');\n var ac = p5sound.audiocontext;\n\n // Stereo panner\n // if there is a stereo panner node use it\n if(typeof ac.createStereoPanner !== 'undefined') {\n p5.Panner = function (input, output) {\n this.stereoPanner = this.input = ac.createStereoPanner();\n input.connect(this.stereoPanner);\n this.stereoPanner.connect(output);\n };\n\n p5.Panner.prototype.pan = function(val, tFromNow) {\n var time = tFromNow || 0;\n var t = ac.currentTime + time;\n\n this.stereoPanner.pan.linearRampToValueAtTime(val, t);\n };\n\n //not implemented because stereopanner\n //node does not require this and will automatically\n //convert single channel or multichannel to stereo.\n //tested with single and stereo, not with (>2) multichannel\n p5.Panner.prototype.inputChannels = function() {};\n\n p5.Panner.prototype.connect = function(obj) {\n this.stereoPanner.connect(obj);\n };\n\n p5.Panner.prototype.disconnect = function() {\n if (this.stereoPanner) {\n this.stereoPanner.disconnect();\n }\n };\n\n } else {\n // if there is no createStereoPanner object\n // such as in safari 7.1.7 at the time of writing this\n // use this method to create the effect\n p5.Panner = function(input, output, numInputChannels) {\n this.input = ac.createGain();\n input.connect(this.input);\n\n this.left = ac.createGain();\n this.right = ac.createGain();\n this.left.channelInterpretation = 'discrete';\n this.right.channelInterpretation = 'discrete';\n\n // if input is stereo\n if (numInputChannels > 1) {\n this.splitter = ac.createChannelSplitter(2);\n this.input.connect(this.splitter);\n\n this.splitter.connect(this.left, 1);\n this.splitter.connect(this.right, 0);\n }\n else {\n this.input.connect(this.left);\n this.input.connect(this.right);\n }\n\n this.output = ac.createChannelMerger(2);\n this.left.connect(this.output, 0, 1);\n this.right.connect(this.output, 0, 0);\n this.output.connect(output);\n };\n\n // -1 is left, +1 is right\n p5.Panner.prototype.pan = function(val, tFromNow) {\n var time = tFromNow || 0;\n var t = ac.currentTime + time;\n var v = (val + 1) / 2;\n var rightVal = Math.cos(v*Math.PI/2);\n var leftVal = Math.sin(v * Math.PI/2);\n this.left.gain.linearRampToValueAtTime(leftVal, t);\n this.right.gain.linearRampToValueAtTime(rightVal, t);\n };\n\n p5.Panner.prototype.inputChannels = function(numChannels) {\n if (numChannels === 1) {\n this.input.disconnect();\n this.input.connect(this.left);\n this.input.connect(this.right);\n } else if (numChannels === 2) {\n if (typeof(this.splitter === 'undefined')) {\n this.splitter = ac.createChannelSplitter(2);\n }\n this.input.disconnect();\n this.input.connect(this.splitter);\n this.splitter.connect(this.left, 1);\n this.splitter.connect(this.right, 0);\n }\n };\n\n p5.Panner.prototype.connect = function(obj) {\n this.output.connect(obj);\n };\n\n p5.Panner.prototype.disconnect = function() {\n if (this.output) {\n this.output.disconnect();\n }\n };\n }\n});\n","'use strict';\n\ndefine(function (require) {\n\n const CustomError = require('errorHandler');\n const p5sound = require('master');\n const ac = p5sound.audiocontext;\n const { midiToFreq, convertToWav, safeBufferSize } = require('helpers');\n var processorNames = require('./audioWorklet/processorNames');\n\n /**\n *

SoundFile object with a path to a file.

\n *\n *

The p5.SoundFile may not be available immediately because\n * it loads the file information asynchronously.

\n *\n *

To do something with the sound as soon as it loads\n * pass the name of a function as the second parameter.

\n *\n *

Only one file path is required. However, audio file formats\n * (i.e. mp3, ogg, wav and m4a/aac) are not supported by all\n * web browsers. If you want to ensure compatability, instead of a single\n * file path, you may include an Array of filepaths, and the browser will\n * choose a format that works.

\n *\n * @class p5.SoundFile\n * @constructor\n * @param {String|Array} path path to a sound file (String). Optionally,\n * you may include multiple file formats in\n * an array. Alternately, accepts an object\n * from the HTML5 File API, or a p5.File.\n * @param {Function} [successCallback] Name of a function to call once file loads\n * @param {Function} [errorCallback] Name of a function to call if file fails to\n * load. This function will receive an error or\n * XMLHttpRequest object with information\n * about what went wrong.\n * @param {Function} [whileLoadingCallback] Name of a function to call while file\n * is loading. That function will\n * receive progress of the request to\n * load the sound file\n * (between 0 and 1) as its first\n * parameter. This progress\n * does not account for the additional\n * time needed to decode the audio data.\n *\n * @example\n *
\n * let mySound;\n * function preload() {\n * soundFormats('mp3', 'ogg');\n * mySound = loadSound('assets/doorbell');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * text('tap here to play', 10, 20);\n * }\n *\n * function canvasPressed() {\n * // playing a sound file on a user gesture\n * // is equivalent to `userStartAudio()`\n * mySound.play();\n * }\n *
\n */\n p5.SoundFile = function(paths, onload, onerror, whileLoading) {\n if (typeof paths !== 'undefined') {\n if (typeof paths === 'string' || typeof paths[0] === 'string') {\n var path = p5.prototype._checkFileFormats(paths);\n this.url = path;\n }\n else if(typeof paths === 'object') {\n if (!(window.File && window.FileReader && window.FileList && window.Blob)) {\n // The File API isn't supported in this browser\n throw 'Unable to load file because the File API is not supported';\n }\n }\n\n // if type is a p5.File...get the actual file\n if (paths.file) {\n paths = paths.file;\n }\n\n this.file = paths;\n }\n\n // private _onended callback, set by the method: onended(callback)\n this._onended = function() {};\n\n this._looping = false;\n this._playing = false;\n this._paused = false;\n this._pauseTime = 0;\n\n // cues for scheduling events with addCue() removeCue()\n this._cues = [];\n this._cueIDCounter = 0;\n\n // position of the most recently played sample\n this._lastPos = 0;\n this._counterNode = null;\n this._workletNode = null;\n\n // array of sources so that they can all be stopped!\n this.bufferSourceNodes = [];\n\n // current source\n this.bufferSourceNode = null;\n\n this.buffer = null;\n this.playbackRate = 1;\n\n this.input = p5sound.audiocontext.createGain();\n this.output = p5sound.audiocontext.createGain();\n\n this.reversed = false;\n\n // start and end of playback / loop\n this.startTime = 0;\n this.endTime = null;\n this.pauseTime = 0;\n\n // \"restart\" would stop playback before retriggering\n this.mode = 'sustain';\n\n // time that playback was started, in millis\n this.startMillis = null;\n\n // stereo panning\n this.panPosition = 0.0;\n this.panner = new p5.Panner(this.output, p5sound.input, 2);\n\n // it is possible to instantiate a soundfile with no path\n if (this.url || this.file) {\n this.load(onload, onerror);\n }\n\n // add this p5.SoundFile to the soundArray\n p5sound.soundArray.push(this);\n\n if (typeof whileLoading === 'function') {\n this._whileLoading = whileLoading;\n } else {\n this._whileLoading = function() {};\n }\n\n this._clearOnEnd = _clearOnEnd.bind(this);\n };\n\n // register preload handling of loadSound\n p5.prototype.registerPreloadMethod('loadSound', p5.prototype);\n\n /**\n * loadSound() returns a new p5.SoundFile from a specified\n * path. If called during preload(), the p5.SoundFile will be ready\n * to play in time for setup() and draw(). If called outside of\n * preload, the p5.SoundFile will not be ready immediately, so\n * loadSound accepts a callback as the second parameter. Using a\n * \n * local server is recommended when loading external files.\n *\n * @method loadSound\n * @for p5\n * @param {String|Array} path Path to the sound file, or an array with\n * paths to soundfiles in multiple formats\n * i.e. ['sound.ogg', 'sound.mp3'].\n * Alternately, accepts an object: either\n * from the HTML5 File API, or a p5.File.\n * @param {Function} [successCallback] Name of a function to call once file loads\n * @param {Function} [errorCallback] Name of a function to call if there is\n * an error loading the file.\n * @param {Function} [whileLoading] Name of a function to call while file is loading.\n * This function will receive the percentage loaded\n * so far, from 0.0 to 1.0.\n * @return {SoundFile} Returns a p5.SoundFile\n * @example\n *
\n * let mySound;\n * function preload() {\n * soundFormats('mp3', 'ogg');\n * mySound = loadSound('assets/doorbell');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * text('tap here to play', 10, 20);\n * }\n *\n * function canvasPressed() {\n * // playing a sound file on a user gesture\n * // is equivalent to `userStartAudio()`\n * mySound.play();\n * }\n *
\n */\n p5.prototype.loadSound = function(path, callback, onerror, whileLoading) {\n // if loading locally without a server\n if (window.location.origin.indexOf('file://') > -1 && window.cordova === 'undefined' ) {\n window.alert('This sketch may require a server to load external files. Please see http://bit.ly/1qcInwS');\n }\n\n var self = this;\n var s = new p5.SoundFile(path, function() {\n if(typeof callback === 'function') {\n callback.apply(self, arguments);\n }\n\n if (typeof self._decrementPreload === 'function') {\n self._decrementPreload();\n }\n }, onerror, whileLoading);\n\n return s;\n };\n\n /**\n * This is a helper function that the p5.SoundFile calls to load\n * itself. Accepts a callback (the name of another function)\n * as an optional parameter.\n *\n * @private\n * @for p5.SoundFile\n * @param {Function} [successCallback] Name of a function to call once file loads\n * @param {Function} [errorCallback] Name of a function to call if there is an error\n */\n p5.SoundFile.prototype.load = function(callback, errorCallback) {\n var self = this;\n var errorTrace = new Error().stack;\n\n if (this.url !== undefined && this.url !== '') {\n var request = new XMLHttpRequest();\n request.addEventListener('progress', function(evt) {\n self._updateProgress(evt);\n }, false);\n request.open('GET', this.url, true);\n request.responseType = 'arraybuffer';\n\n request.onload = function() {\n if (request.status === 200) {\n // on sucess loading file:\n if (!self.panner) return;\n ac.decodeAudioData(request.response,\n // success decoding buffer:\n function(buff) {\n if (!self.panner) return;\n self.buffer = buff;\n self.panner.inputChannels(buff.numberOfChannels);\n if (callback) {\n callback(self);\n }\n },\n // error decoding buffer. \"e\" is undefined in Chrome 11/22/2015\n function() {\n if (!self.panner) return;\n var err = new CustomError('decodeAudioData', errorTrace, self.url);\n var msg = 'AudioContext error at decodeAudioData for ' + self.url;\n if (errorCallback) {\n err.msg = msg;\n errorCallback(err);\n } else {\n console.error(msg +'\\n The error stack trace includes: \\n' + err.stack);\n }\n }\n );\n }\n // if request status != 200, it failed\n else {\n if (!self.panner) return;\n var err = new CustomError('loadSound', errorTrace, self.url);\n var msg = 'Unable to load ' + self.url + '. The request status was: ' +\n request.status + ' (' + request.statusText + ')';\n\n if (errorCallback) {\n err.message = msg;\n errorCallback(err);\n } else {\n console.error(msg +'\\n The error stack trace includes: \\n' + err.stack);\n }\n }\n };\n\n // if there is another error, aside from 404...\n request.onerror = function() {\n var err = new CustomError('loadSound', errorTrace, self.url);\n var msg = 'There was no response from the server at ' + self.url + '. Check the url and internet connectivity.';\n\n if (errorCallback) {\n err.message = msg;\n errorCallback(err);\n } else {\n console.error(msg +'\\n The error stack trace includes: \\n' + err.stack);\n }\n };\n\n request.send();\n }\n else if (this.file !== undefined) {\n var reader = new FileReader();\n reader.onload = function() {\n if (!self.panner) return;\n ac.decodeAudioData(reader.result, function(buff) {\n if (!self.panner) return;\n self.buffer = buff;\n self.panner.inputChannels(buff.numberOfChannels);\n if (callback) {\n callback(self);\n }\n });\n };\n reader.onerror = function(e) {\n if (!self.panner) return;\n if (onerror) {\n onerror(e);\n }\n };\n reader.readAsArrayBuffer(this.file);\n }\n };\n\n // TO DO: use this method to create a loading bar that shows progress during file upload/decode.\n p5.SoundFile.prototype._updateProgress = function(evt) {\n if (evt.lengthComputable) {\n var percentComplete = evt.loaded / evt.total * 0.99;\n this._whileLoading(percentComplete, evt);\n // ...\n } else {\n // Unable to compute progress information since the total size is unknown\n this._whileLoading('size unknown');\n }\n };\n\n /**\n * Returns true if the sound file finished loading successfully.\n *\n * @method isLoaded\n * @for p5.SoundFile\n * @return {Boolean}\n */\n p5.SoundFile.prototype.isLoaded = function() {\n if (this.buffer) {\n return true;\n } else {\n return false;\n }\n };\n\n /**\n * Play the p5.SoundFile\n *\n * @method play\n * @for p5.SoundFile\n * @param {Number} [startTime] (optional) schedule playback to start (in seconds from now).\n * @param {Number} [rate] (optional) playback rate\n * @param {Number} [amp] (optional) amplitude (volume)\n * of playback\n * @param {Number} [cueStart] (optional) cue start time in seconds\n * @param {Number} [duration] (optional) duration of playback in seconds\n */\n p5.SoundFile.prototype.play = function(startTime, rate, amp, _cueStart, duration) {\n if (!this.output) {\n console.warn('SoundFile.play() called after dispose');\n return;\n }\n\n var now = p5sound.audiocontext.currentTime;\n var cueStart, cueEnd;\n var time = startTime || 0;\n if (time < 0) {\n time = 0;\n }\n\n time = time + now;\n\n if (typeof rate !== 'undefined') {\n this.rate(rate);\n }\n\n if (typeof amp !== 'undefined') {\n this.setVolume(amp);\n }\n\n // TO DO: if already playing, create array of buffers for easy stop()\n if (this.buffer) {\n // reset the pause time (if it was paused)\n this._pauseTime = 0;\n\n // handle restart playmode\n if (this.mode === 'restart' && this.buffer && this.bufferSourceNode) {\n this.bufferSourceNode.stop(time);\n this._counterNode.stop(time);\n }\n\n //dont create another instance if already playing\n if (this.mode === 'untildone' && this.isPlaying()) {\n return;\n }\n // make a new source and counter. They are automatically assigned playbackRate and buffer\n this.bufferSourceNode = this._initSourceNode();\n\n // garbage collect counterNode and create a new one\n delete this._counterNode;\n this._counterNode = this._initCounterNode();\n\n if (_cueStart) {\n if (_cueStart >=0 && _cueStart < this.buffer.duration) {\n // this.startTime = cueStart;\n cueStart = _cueStart;\n } else { throw 'start time out of range'; }\n } else {\n cueStart = 0;\n }\n\n if (duration) {\n // if duration is greater than buffer.duration, just play entire file anyway rather than throw an error\n duration = duration <= this.buffer.duration - cueStart ? duration : this.buffer.duration;\n }\n\n // if it was paused, play at the pause position\n if (this._paused) {\n this.bufferSourceNode.start(time, this.pauseTime, duration);\n this._counterNode.start(time, this.pauseTime, duration);\n } else {\n this.bufferSourceNode.start(time, cueStart, duration);\n this._counterNode.start(time, cueStart, duration);\n }\n\n this._playing = true;\n this._paused = false;\n\n // add source to sources array, which is used in stopAll()\n this.bufferSourceNodes.push(this.bufferSourceNode);\n this.bufferSourceNode._arrayIndex = this.bufferSourceNodes.length - 1;\n\n this.bufferSourceNode.addEventListener('ended', this._clearOnEnd);\n }\n // If soundFile hasn't loaded the buffer yet, throw an error\n else {\n throw 'not ready to play file, buffer has yet to load. Try preload()';\n }\n\n // if looping, will restart at original time\n this.bufferSourceNode.loop = this._looping;\n this._counterNode.loop = this._looping;\n\n if (this._looping === true) {\n cueEnd = duration ? duration : cueStart - 0.000000000000001;\n this.bufferSourceNode.loopStart = cueStart;\n this.bufferSourceNode.loopEnd = cueEnd;\n this._counterNode.loopStart = cueStart;\n this._counterNode.loopEnd = cueEnd;\n }\n\n };\n\n\n /**\n * p5.SoundFile has two play modes: restart and\n * sustain. Play Mode determines what happens to a\n * p5.SoundFile if it is triggered while in the middle of playback.\n * In sustain mode, playback will continue simultaneous to the\n * new playback. In restart mode, play() will stop playback\n * and start over. With untilDone, a sound will play only if it's\n * not already playing. Sustain is the default mode.\n *\n * @method playMode\n * @for p5.SoundFile\n * @param {String} str 'restart' or 'sustain' or 'untilDone'\n * @example\n *
\n * let mySound;\n * function preload(){\n * mySound = loadSound('assets/Damscray_DancingTiger.mp3');\n * }\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * noFill();\n * rect(0, height/2, width - 1, height/2 - 1);\n * rect(0, 0, width - 1, height/2);\n * textAlign(CENTER, CENTER);\n * fill(20);\n * text('restart', width/2, 1 * height/4);\n * text('sustain', width/2, 3 * height/4);\n * }\n * function canvasPressed() {\n * if (mouseX < height/2) {\n * mySound.playMode('restart');\n * } else {\n * mySound.playMode('sustain');\n * }\n * mySound.play();\n * }\n *\n *
\n */\n p5.SoundFile.prototype.playMode = function(str) {\n var s = str.toLowerCase();\n\n // if restart, stop all other sounds from playing\n if (s === 'restart' && this.buffer && this.bufferSourceNode) {\n for (var i = 0; i < this.bufferSourceNodes.length - 1; i++) {\n var now = p5sound.audiocontext.currentTime;\n this.bufferSourceNodes[i].stop(now);\n }\n }\n\n // set play mode to effect future playback\n if (s === 'restart' || s === 'sustain' || s === 'untildone') {\n this.mode = s;\n } else {\n throw 'Invalid play mode. Must be either \"restart\" or \"sustain\"';\n }\n };\n\n /**\n * Pauses a file that is currently playing. If the file is not\n * playing, then nothing will happen.\n *\n * After pausing, .play() will resume from the paused\n * position.\n * If p5.SoundFile had been set to loop before it was paused,\n * it will continue to loop after it is unpaused with .play().\n *\n * @method pause\n * @for p5.SoundFile\n * @param {Number} [startTime] (optional) schedule event to occur\n * seconds from now\n * @example\n *
\n * let soundFile;\n * function preload() {\n * soundFormats('ogg', 'mp3');\n * soundFile = loadSound('assets/Damscray_-_Dancing_Tiger_02.mp3');\n * }\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * text('tap to play, release to pause', 10, 20, width - 20);\n * }\n * function canvasPressed() {\n * soundFile.loop();\n * background(0, 200, 50);\n * }\n * function mouseReleased() {\n * soundFile.pause();\n * background(220);\n * }\n * \n *
\n */\n p5.SoundFile.prototype.pause = function(startTime) {\n var now = p5sound.audiocontext.currentTime;\n var time = startTime || 0;\n var pTime = time + now;\n\n if (this.isPlaying() && this.buffer && this.bufferSourceNode) {\n this._paused = true;\n this._playing = false;\n\n this.pauseTime = this.currentTime();\n this.bufferSourceNode.stop(pTime);\n this._counterNode.stop(pTime);\n\n this._pauseTime = this.currentTime();\n // TO DO: make sure play() still starts from orig start position\n } else {\n this._pauseTime = 0;\n }\n };\n\n /**\n * Loop the p5.SoundFile. Accepts optional parameters to set the\n * playback rate, playback volume, loopStart, loopEnd.\n *\n * @method loop\n * @for p5.SoundFile\n * @param {Number} [startTime] (optional) schedule event to occur\n * seconds from now\n * @param {Number} [rate] (optional) playback rate\n * @param {Number} [amp] (optional) playback volume\n * @param {Number} [cueLoopStart] (optional) startTime in seconds\n * @param {Number} [duration] (optional) loop duration in seconds\n * @example\n *
\n * let soundFile;\n * let loopStart = 0.5;\n * let loopDuration = 0.2;\n * function preload() {\n * soundFormats('ogg', 'mp3');\n * soundFile = loadSound('assets/Damscray_-_Dancing_Tiger_02.mp3');\n * }\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * text('tap to play, release to pause', 10, 20, width - 20);\n * }\n * function canvasPressed() {\n * soundFile.loop();\n * background(0, 200, 50);\n * }\n * function mouseReleased() {\n * soundFile.pause();\n * background(220);\n * }\n * \n *
\n */\n p5.SoundFile.prototype.loop = function(startTime, rate, amp, loopStart, duration) {\n this._looping = true;\n this.play(startTime, rate, amp, loopStart, duration);\n };\n\n /**\n * Set a p5.SoundFile's looping flag to true or false. If the sound\n * is currently playing, this change will take effect when it\n * reaches the end of the current playback.\n *\n * @method setLoop\n * @for p5.SoundFile\n * @param {Boolean} Boolean set looping to true or false\n */\n p5.SoundFile.prototype.setLoop = function(bool) {\n if (bool === true) {\n this._looping = true;\n }\n else if (bool === false) {\n this._looping = false;\n }\n else {\n throw 'Error: setLoop accepts either true or false';\n }\n if (this.bufferSourceNode) {\n this.bufferSourceNode.loop = this._looping;\n this._counterNode.loop = this._looping;\n }\n };\n\n /**\n * Returns 'true' if a p5.SoundFile is currently looping and playing, 'false' if not.\n *\n * @method isLooping\n * @for p5.SoundFile\n * @return {Boolean}\n */\n p5.SoundFile.prototype.isLooping = function() {\n if (!this.bufferSourceNode) {\n return false;\n }\n if (this._looping === true && this.isPlaying() === true) {\n return true;\n }\n return false;\n };\n\n /**\n * Returns true if a p5.SoundFile is playing, false if not (i.e.\n * paused or stopped).\n *\n * @method isPlaying\n * @for p5.SoundFile\n * @return {Boolean}\n */\n p5.SoundFile.prototype.isPlaying = function() {\n return this._playing;\n };\n\n /**\n * Returns true if a p5.SoundFile is paused, false if not (i.e.\n * playing or stopped).\n *\n * @method isPaused\n * @for p5.SoundFile\n * @return {Boolean}\n */\n p5.SoundFile.prototype.isPaused = function() {\n return this._paused;\n };\n\n /**\n * Stop soundfile playback.\n *\n * @method stop\n * @for p5.SoundFile\n * @param {Number} [startTime] (optional) schedule event to occur\n * in seconds from now\n */\n p5.SoundFile.prototype.stop = function(timeFromNow) {\n var time = timeFromNow || 0;\n\n if (this.mode === 'sustain' || this.mode === 'untildone') {\n this.stopAll(time);\n this._playing = false;\n this.pauseTime = 0;\n this._paused = false;\n }\n else if (this.buffer && this.bufferSourceNode) {\n var now = p5sound.audiocontext.currentTime;\n var t = time || 0;\n this.pauseTime = 0;\n this.bufferSourceNode.stop(now + t);\n this._counterNode.stop(now + t);\n this._playing = false;\n this._paused = false;\n }\n };\n\n /**\n * Stop playback on all of this soundfile's sources.\n * @private\n */\n p5.SoundFile.prototype.stopAll = function(_time) {\n var now = p5sound.audiocontext.currentTime;\n var time = _time || 0;\n if (this.buffer && this.bufferSourceNode) {\n for (var i in this.bufferSourceNodes) {\n const bufferSourceNode = this.bufferSourceNodes[i];\n if (!!bufferSourceNode) {\n try {\n bufferSourceNode.stop(now + time);\n } catch(e) {\n // this was throwing errors only on Safari\n }\n }\n }\n this._counterNode.stop(now + time);\n this._onended(this);\n }\n };\n\n /**\n * Multiply the output volume (amplitude) of a sound file\n * between 0.0 (silence) and 1.0 (full volume).\n * 1.0 is the maximum amplitude of a digital sound, so multiplying\n * by greater than 1.0 may cause digital distortion. To\n * fade, provide a rampTime parameter. For more\n * complex fades, see the Envelope class.\n *\n * Alternately, you can pass in a signal source such as an\n * oscillator to modulate the amplitude with an audio signal.\n *\n * @method setVolume\n * @for p5.SoundFile\n * @param {Number|Object} volume Volume (amplitude) between 0.0\n * and 1.0 or modulating signal/oscillator\n * @param {Number} [rampTime] Fade for t seconds\n * @param {Number} [timeFromNow] Schedule this event to happen at\n * t seconds in the future\n */\n p5.SoundFile.prototype.setVolume = function(vol, _rampTime, _tFromNow) {\n if (typeof vol === 'number') {\n var rampTime = _rampTime || 0;\n var tFromNow = _tFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n var currentVol = this.output.gain.value;\n this.output.gain.cancelScheduledValues(now + tFromNow);\n this.output.gain.linearRampToValueAtTime(currentVol, now + tFromNow);\n this.output.gain.linearRampToValueAtTime(vol, now + tFromNow + rampTime);\n }\n else if (vol) {\n vol.connect(this.output.gain);\n } else {\n // return the Gain Node\n return this.output.gain;\n }\n };\n\n // same as setVolume, to match Processing Sound\n p5.SoundFile.prototype.amp = p5.SoundFile.prototype.setVolume;\n\n // these are the same thing\n p5.SoundFile.prototype.fade = p5.SoundFile.prototype.setVolume;\n\n p5.SoundFile.prototype.getVolume = function() {\n return this.output.gain.value;\n };\n\n /**\n * Set the stereo panning of a p5.sound object to\n * a floating point number between -1.0 (left) and 1.0 (right).\n * Default is 0.0 (center).\n *\n * @method pan\n * @for p5.SoundFile\n * @param {Number} [panValue] Set the stereo panner\n * @param {Number} [timeFromNow] schedule this event to happen\n * seconds from now\n * @example\n *
\n * let ballX = 0;\n * let soundFile;\n *\n * function preload() {\n * soundFormats('ogg', 'mp3');\n * soundFile = loadSound('assets/beatbox.mp3');\n * }\n *\n * function draw() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * ballX = constrain(mouseX, 0, width);\n * ellipse(ballX, height/2, 20, 20);\n * }\n *\n * function canvasPressed(){\n * // map the ball's x location to a panning degree\n * // between -1.0 (left) and 1.0 (right)\n * let panning = map(ballX, 0., width,-1.0, 1.0);\n * soundFile.pan(panning);\n * soundFile.play();\n * }\n *
\n */\n p5.SoundFile.prototype.pan = function(pval, tFromNow) {\n this.panPosition = pval;\n this.panner.pan(pval, tFromNow);\n };\n\n /**\n * Returns the current stereo pan position (-1.0 to 1.0)\n *\n * @method getPan\n * @for p5.SoundFile\n * @return {Number} Returns the stereo pan setting of the Oscillator\n * as a number between -1.0 (left) and 1.0 (right).\n * 0.0 is center and default.\n */\n p5.SoundFile.prototype.getPan = function() {\n return this.panPosition;\n };\n\n /**\n * Set the playback rate of a sound file. Will change the speed and the pitch.\n * Values less than zero will reverse the audio buffer.\n *\n * @method rate\n * @for p5.SoundFile\n * @param {Number} [playbackRate] Set the playback rate. 1.0 is normal,\n * .5 is half-speed, 2.0 is twice as fast.\n * Values less than zero play backwards.\n * @example\n *
\n * let mySound;\n *\n * function preload() {\n * mySound = loadSound('assets/Damscray_DancingTiger.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * }\n * function canvasPressed() {\n * mySound.loop();\n * }\n * function mouseReleased() {\n * mySound.pause();\n * }\n * function draw() {\n * background(220);\n *\n * // Set the rate to a range between 0.1 and 4\n * // Changing the rate also alters the pitch\n * let playbackRate = map(mouseY, 0.1, height, 2, 0);\n * playbackRate = constrain(playbackRate, 0.01, 4);\n * mySound.rate(playbackRate);\n *\n * line(0, mouseY, width, mouseY);\n * text('rate: ' + round(playbackRate * 100) + '%', 10, 20);\n * }\n *\n * \n *
\n *\n */\n p5.SoundFile.prototype.rate = function(playbackRate) {\n var reverse = false;\n if (typeof playbackRate === 'undefined') {\n return this.playbackRate;\n }\n\n this.playbackRate = playbackRate;\n\n if (playbackRate === 0) {\n playbackRate = 0.0000000000001;\n }\n\n else if (playbackRate < 0 && !this.reversed) {\n playbackRate = Math.abs(playbackRate);\n reverse = true;\n }\n\n else if (playbackRate > 0 && this.reversed) {\n reverse = true;\n }\n\n if (this.bufferSourceNode) {\n var now = p5sound.audiocontext.currentTime;\n this.bufferSourceNode.playbackRate.cancelScheduledValues(now);\n this.bufferSourceNode.playbackRate.linearRampToValueAtTime(Math.abs(playbackRate), now);\n this._counterNode.playbackRate.cancelScheduledValues(now);\n this._counterNode.playbackRate.linearRampToValueAtTime(Math.abs(playbackRate), now);\n }\n\n if (reverse) {\n this.reverseBuffer();\n }\n return this.playbackRate;\n };\n\n // TO DO: document this\n p5.SoundFile.prototype.setPitch = function(num) {\n var newPlaybackRate = midiToFreq(num) / midiToFreq(60);\n this.rate(newPlaybackRate);\n };\n\n p5.SoundFile.prototype.getPlaybackRate = function() {\n return this.playbackRate;\n };\n\n /**\n * Returns the duration of a sound file in seconds.\n *\n * @method duration\n * @for p5.SoundFile\n * @return {Number} The duration of the soundFile in seconds.\n */\n p5.SoundFile.prototype.duration = function() {\n // Return Duration\n if (this.buffer) {\n return this.buffer.duration;\n } else {\n return 0;\n }\n };\n\n /**\n * Return the current position of the p5.SoundFile playhead, in seconds.\n * Time is relative to the normal buffer direction, so if `reverseBuffer`\n * has been called, currentTime will count backwards.\n *\n * @method currentTime\n * @for p5.SoundFile\n * @return {Number} currentTime of the soundFile in seconds.\n */\n p5.SoundFile.prototype.currentTime = function() {\n return this.reversed\n ? Math.abs(this._lastPos - this.buffer.length) / ac.sampleRate\n : this._lastPos / ac.sampleRate;\n };\n\n /**\n * Move the playhead of a soundfile that is currently playing to a\n * new position and a new duration, in seconds.\n * If none are given, will reset the file to play entire duration\n * from start to finish. To set the position of a soundfile that is\n * not currently playing, use the `play` or `loop` methods.\n *\n * @method jump\n * @for p5.SoundFile\n * @param {Number} cueTime cueTime of the soundFile in seconds.\n * @param {Number} duration duration in seconds.\n */\n p5.SoundFile.prototype.jump = function(cueTime, duration) {\n if (cueTime < 0 || cueTime > this.buffer.duration) {\n throw 'jump time out of range';\n }\n if (duration > this.buffer.duration - cueTime) {\n throw 'end time out of range';\n }\n\n var cTime = cueTime || 0;\n var dur = duration || undefined;\n if (this.isPlaying()) {\n this.stop(0);\n this.play(0, this.playbackRate, this.output.gain.value, cTime, dur);\n }\n };\n\n /**\n * Return the number of channels in a sound file.\n * For example, Mono = 1, Stereo = 2.\n *\n * @method channels\n * @for p5.SoundFile\n * @return {Number} [channels]\n */\n p5.SoundFile.prototype.channels = function() {\n return this.buffer.numberOfChannels;\n };\n\n /**\n * Return the sample rate of the sound file.\n *\n * @method sampleRate\n * @for p5.SoundFile\n * @return {Number} [sampleRate]\n */\n p5.SoundFile.prototype.sampleRate = function() {\n return this.buffer.sampleRate;\n };\n\n /**\n * Return the number of samples in a sound file.\n * Equal to sampleRate * duration.\n *\n * @method frames\n * @for p5.SoundFile\n * @return {Number} [sampleCount]\n */\n p5.SoundFile.prototype.frames = function() {\n return this.buffer.length;\n };\n\n /**\n * Returns an array of amplitude peaks in a p5.SoundFile that can be\n * used to draw a static waveform. Scans through the p5.SoundFile's\n * audio buffer to find the greatest amplitudes. Accepts one\n * parameter, 'length', which determines size of the array.\n * Larger arrays result in more precise waveform visualizations.\n *\n * Inspired by Wavesurfer.js.\n *\n * @method getPeaks\n * @for p5.SoundFile\n * @params {Number} [length] length is the size of the returned array.\n * Larger length results in more precision.\n * Defaults to 5*width of the browser window.\n * @returns {Float32Array} Array of peaks.\n */\n p5.SoundFile.prototype.getPeaks = function(length) {\n\n if (this.buffer) {\n // set length to window's width if no length is provided\n if (!length) {\n length = window.width*5;\n }\n if (this.buffer) {\n var buffer = this.buffer;\n var sampleSize = buffer.length / length;\n var sampleStep = ~~(sampleSize / 10) || 1;\n var channels = buffer.numberOfChannels;\n var peaks = new Float32Array(Math.round(length));\n\n for (var c = 0; c < channels; c++) {\n var chan = buffer.getChannelData(c);\n for (var i = 0; i < length; i++) {\n var start = ~~(i*sampleSize);\n var end = ~~(start + sampleSize);\n var max = 0;\n for (var j = start; j < end; j+= sampleStep) {\n var value = chan[j];\n if (value > max) {\n max = value;\n // faster than Math.abs\n } else if (-value > max) {\n max = value;\n }\n }\n if (c === 0 || Math.abs(max) > peaks[i]) {\n peaks[i] = max;\n }\n }\n }\n\n return peaks;\n }\n }\n\n else {\n throw 'Cannot load peaks yet, buffer is not loaded';\n }\n };\n\n /**\n * Reverses the p5.SoundFile's buffer source.\n * Playback must be handled separately (see example).\n *\n * @method reverseBuffer\n * @for p5.SoundFile\n * @example\n *
\n * let drum;\n * function preload() {\n * drum = loadSound('assets/drum.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * text('tap to play', 20, 20);\n * }\n *\n * function canvasPressed() {\n * drum.stop();\n * drum.reverseBuffer();\n * drum.play();\n * }\n * \n *
\n */\n p5.SoundFile.prototype.reverseBuffer = function() {\n if (this.buffer) {\n var currentPos = this._lastPos / ac.sampleRate;\n var curVol = this.getVolume();\n this.setVolume(0, 0.001);\n\n const numChannels = this.buffer.numberOfChannels;\n for (var i = 0; i < numChannels; i++) {\n this.buffer.getChannelData(i).reverse();\n }\n // set reversed flag\n this.reversed = !this.reversed;\n\n if (this.isPlaying() && currentPos) {\n this.jump(this.duration() - currentPos);\n }\n this.setVolume(curVol, 0.001);\n } else {\n throw 'SoundFile is not done loading';\n }\n };\n\n /**\n * Schedule an event to be called when the soundfile\n * reaches the end of a buffer. If the soundfile is\n * playing through once, this will be called when it\n * ends. If it is looping, it will be called when\n * stop is called.\n *\n * @method onended\n * @for p5.SoundFile\n * @param {Function} callback function to call when the\n * soundfile has ended.\n */\n p5.SoundFile.prototype.onended = function(callback) {\n this._onended = callback;\n return this;\n };\n\n p5.SoundFile.prototype.add = function() {\n // TO DO\n };\n\n p5.SoundFile.prototype.dispose = function() {\n var now = p5sound.audiocontext.currentTime;\n\n // remove reference to soundfile\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n\n this.stop(now);\n if (this.buffer && this.bufferSourceNode) {\n for (var i = 0; i < this.bufferSourceNodes.length - 1; i++) {\n if (this.bufferSourceNodes[i] !== null) {\n this.bufferSourceNodes[i].disconnect();\n try {\n this.bufferSourceNodes[i].stop(now);\n } catch(e) {\n console.warn('no buffer source node to dispose');\n }\n this.bufferSourceNodes[i] = null;\n }\n }\n if ( this.isPlaying() ) {\n try {\n this._counterNode.stop(now);\n } catch(e) {\n console.log(e);\n }\n this._counterNode = null;\n }\n }\n if (this.output) {\n this.output.disconnect();\n this.output = null;\n }\n if (this.panner) {\n this.panner.disconnect();\n this.panner = null;\n }\n };\n\n /**\n * Connects the output of a p5sound object to input of another\n * p5.sound object. For example, you may connect a p5.SoundFile to an\n * FFT or an Effect. If no parameter is given, it will connect to\n * the master output. Most p5sound objects connect to the master\n * output when they are created.\n *\n * @method connect\n * @for p5.SoundFile\n * @param {Object} [object] Audio object that accepts an input\n */\n p5.SoundFile.prototype.connect = function(unit) {\n if (!unit) {\n this.panner.connect(p5sound.input);\n }\n else {\n if (unit.hasOwnProperty('input')) {\n this.panner.connect(unit.input);\n } else {\n this.panner.connect(unit);\n }\n }\n };\n\n /**\n * Disconnects the output of this p5sound object.\n *\n * @method disconnect\n * @for p5.SoundFile\n */\n p5.SoundFile.prototype.disconnect = function() {\n if (this.panner) {\n this.panner.disconnect();\n }\n };\n\n /**\n */\n p5.SoundFile.prototype.getLevel = function() {\n console.warn('p5.SoundFile.getLevel has been removed from the library. Use p5.Amplitude instead');\n };\n\n /**\n * Reset the source for this SoundFile to a\n * new path (URL).\n *\n * @method setPath\n * @for p5.SoundFile\n * @param {String} path path to audio file\n * @param {Function} callback Callback\n */\n p5.SoundFile.prototype.setPath = function(p, callback) {\n var path = p5.prototype._checkFileFormats(p);\n this.url = path;\n this.load(callback);\n };\n\n /**\n * Replace the current Audio Buffer with a new Buffer.\n *\n * @method setBuffer\n * @for p5.SoundFile\n * @param {Array} buf Array of Float32 Array(s). 2 Float32 Arrays\n * will create a stereo source. 1 will create\n * a mono source.\n */\n p5.SoundFile.prototype.setBuffer = function(buf) {\n var numChannels = buf.length;\n var size = buf[0].length;\n var newBuffer = ac.createBuffer(numChannels, size, ac.sampleRate);\n\n if (!(buf[0] instanceof Float32Array)) {\n buf[0] = new Float32Array(buf[0]);\n }\n\n for (var channelNum = 0; channelNum < numChannels; channelNum++) {\n var channel = newBuffer.getChannelData( channelNum );\n channel.set(buf[channelNum]);\n }\n\n this.buffer = newBuffer;\n\n // set numbers of channels on input to the panner\n this.panner.inputChannels(numChannels);\n };\n\n //////////////////////////////////////////////////\n // script processor node with an empty buffer to help\n // keep a sample-accurate position in playback buffer.\n // Inspired by Chinmay Pendharkar's technique for Sonoport --> http://bit.ly/1HwdCsV\n // Copyright [2015] [Sonoport (Asia) Pte. Ltd.],\n // Licensed under the Apache License http://apache.org/licenses/LICENSE-2.0\n ////////////////////////////////////////////////////////////////////////////////////\n\n var _createCounterBuffer = function(buffer) {\n const len = buffer.length;\n const audioBuf = ac.createBuffer( 1, buffer.length, ac.sampleRate );\n const arrayBuffer = audioBuf.getChannelData(0);\n for (var index = 0; index < len; index++) {\n arrayBuffer[index] = index;\n }\n return audioBuf;\n };\n\n // initialize counterNode, set its initial buffer and playbackRate\n p5.SoundFile.prototype._initCounterNode = function() {\n var self = this;\n var now = ac.currentTime;\n var cNode = ac.createBufferSource();\n\n const workletBufferSize = safeBufferSize(256);\n\n // dispose of worklet node if it already exists\n if (self._workletNode) {\n self._workletNode.disconnect();\n delete self._workletNode;\n }\n self._workletNode = new AudioWorkletNode(ac, processorNames.soundFileProcessor, {\n processorOptions: { bufferSize: workletBufferSize }\n });\n self._workletNode.port.onmessage = event => {\n if (event.data.name === 'position') {\n // event.data.position should only be 0 when paused\n if (event.data.position === 0) {\n return;\n }\n this._lastPos = event.data.position;\n\n // do any callbacks that have been scheduled\n this._onTimeUpdate(self._lastPos);\n }\n };\n\n // create counter buffer of the same length as self.buffer\n cNode.buffer = _createCounterBuffer( self.buffer );\n\n cNode.playbackRate.setValueAtTime(self.playbackRate, now);\n\n cNode.connect(self._workletNode);\n self._workletNode.connect(p5.soundOut._silentNode);\n\n return cNode;\n };\n\n // initialize sourceNode, set its initial buffer and playbackRate\n p5.SoundFile.prototype._initSourceNode = function() {\n var bufferSourceNode = ac.createBufferSource();\n bufferSourceNode.buffer = this.buffer;\n bufferSourceNode.playbackRate.value = this.playbackRate;\n bufferSourceNode.connect(this.output);\n return bufferSourceNode;\n };\n\n /**\n * processPeaks returns an array of timestamps where it thinks there is a beat.\n *\n * This is an asynchronous function that processes the soundfile in an offline audio context,\n * and sends the results to your callback function.\n *\n * The process involves running the soundfile through a lowpass filter, and finding all of the\n * peaks above the initial threshold. If the total number of peaks are below the minimum number of peaks,\n * it decreases the threshold and re-runs the analysis until either minPeaks or minThreshold are reached.\n *\n * @method processPeaks\n * @for p5.SoundFile\n * @param {Function} callback a function to call once this data is returned\n * @param {Number} [initThreshold] initial threshold defaults to 0.9\n * @param {Number} [minThreshold] minimum threshold defaults to 0.22\n * @param {Number} [minPeaks] minimum number of peaks defaults to 200\n * @return {Array} Array of timestamped peaks\n */\n p5.SoundFile.prototype.processPeaks = function(callback, _initThreshold, _minThreshold, _minPeaks) {\n var bufLen = this.buffer.length;\n var sampleRate = this.buffer.sampleRate;\n var buffer = this.buffer;\n var allPeaks = [];\n\n var initialThreshold = _initThreshold || 0.9,\n threshold = initialThreshold,\n minThreshold = _minThreshold || 0.22,\n minPeaks = _minPeaks || 200;\n\n // Create offline context\n var offlineContext = new window.OfflineAudioContext(1, bufLen, sampleRate);\n\n // create buffer source\n var source = offlineContext.createBufferSource();\n source.buffer = buffer;\n\n // Create filter. TO DO: allow custom setting of filter\n var filter = offlineContext.createBiquadFilter();\n filter.type = 'lowpass';\n source.connect(filter);\n filter.connect(offlineContext.destination);\n\n // start playing at time:0\n source.start(0);\n offlineContext.startRendering(); // Render the song\n\n // act on the result\n offlineContext.oncomplete = function(e) {\n if (!self.panner) return;\n var filteredBuffer = e.renderedBuffer;\n var bufferData = filteredBuffer.getChannelData(0);\n\n\n // step 1:\n // create Peak instances, add them to array, with strength and sampleIndex\n do {\n allPeaks = getPeaksAtThreshold(bufferData, threshold);\n threshold -= 0.005;\n } while (Object.keys(allPeaks).length < minPeaks && threshold >= minThreshold);\n\n\n // step 2:\n // find intervals for each peak in the sampleIndex, add tempos array\n var intervalCounts = countIntervalsBetweenNearbyPeaks(allPeaks);\n\n // step 3: find top tempos\n var groups = groupNeighborsByTempo(intervalCounts, filteredBuffer.sampleRate);\n\n // sort top intervals\n var topTempos = groups.sort(function(intA, intB) {\n return intB.count - intA.count;\n\n }).splice(0,5);\n\n // set this SoundFile's tempo to the top tempo ??\n this.tempo = topTempos[0].tempo;\n\n // step 4:\n // new array of peaks at top tempo within a bpmVariance\n var bpmVariance = 5;\n var tempoPeaks = getPeaksAtTopTempo(allPeaks, topTempos[0].tempo, filteredBuffer.sampleRate, bpmVariance);\n\n callback(tempoPeaks);\n };\n };\n\n // process peaks\n var Peak = function(amp, i) {\n this.sampleIndex = i;\n this.amplitude = amp;\n this.tempos = [];\n this.intervals = [];\n };\n\n // 1. for processPeaks() Function to identify peaks above a threshold\n // returns an array of peak indexes as frames (samples) of the original soundfile\n function getPeaksAtThreshold(data, threshold) {\n var peaksObj = {};\n var length = data.length;\n\n for (var i = 0; i < length; i++) {\n if (data[i] > threshold) {\n var amp = data[i];\n var peak = new Peak(amp, i);\n peaksObj[i] = peak;\n // Skip forward ~ 1/8s to get past this peak.\n i += 6000;\n }\n i++;\n }\n return peaksObj;\n }\n\n // 2. for processPeaks()\n function countIntervalsBetweenNearbyPeaks(peaksObj) {\n var intervalCounts = [];\n var peaksArray = Object.keys(peaksObj).sort();\n\n for (var index = 0; index < peaksArray.length; index++) {\n\n // find intervals in comparison to nearby peaks\n for (var i = 0; i < 10; i++) {\n var startPeak = peaksObj[peaksArray[index]];\n var endPeak = peaksObj[peaksArray[index + i]];\n\n if (startPeak && endPeak) {\n var startPos = startPeak.sampleIndex;\n var endPos = endPeak.sampleIndex;\n var interval = endPos - startPos;\n\n // add a sample interval to the startPeak in the allPeaks array\n if (interval > 0) {\n startPeak.intervals.push(interval);\n }\n\n // tally the intervals and return interval counts\n var foundInterval = intervalCounts.some(function(intervalCount) {\n if (intervalCount.interval === interval) {\n intervalCount.count++;\n return intervalCount;\n }\n });\n\n // store with JSON like formatting\n if (!foundInterval) {\n intervalCounts.push({\n interval: interval,\n count: 1,\n });\n }\n }\n }\n }\n\n return intervalCounts;\n }\n\n\n // 3. for processPeaks --> find tempo\n function groupNeighborsByTempo(intervalCounts, sampleRate) {\n var tempoCounts = [];\n\n intervalCounts.forEach(function(intervalCount) {\n\n try {\n // Convert an interval to tempo\n var theoreticalTempo = Math.abs( 60 / (intervalCount.interval / sampleRate ) );\n\n theoreticalTempo = mapTempo(theoreticalTempo);\n\n var foundTempo = tempoCounts.some(function(tempoCount) {\n if (tempoCount.tempo === theoreticalTempo)\n return tempoCount.count += intervalCount.count;\n });\n if (!foundTempo) {\n if (isNaN(theoreticalTempo)) {\n return;\n }\n tempoCounts.push({\n tempo: Math.round(theoreticalTempo),\n count: intervalCount.count\n });\n }\n } catch(e) {\n throw e;\n }\n\n });\n\n return tempoCounts;\n }\n\n // 4. for processPeaks - get peaks at top tempo\n function getPeaksAtTopTempo(peaksObj, tempo, sampleRate, bpmVariance) {\n var peaksAtTopTempo = [];\n var peaksArray = Object.keys(peaksObj).sort();\n\n // TO DO: filter out peaks that have the tempo and return\n for (var i = 0; i < peaksArray.length; i++) {\n var key = peaksArray[i];\n var peak = peaksObj[key];\n\n for (var j = 0; j < peak.intervals.length; j++) {\n var intervalBPM = Math.round(Math.abs( 60 / (peak.intervals[j] / sampleRate) ) );\n\n intervalBPM = mapTempo(intervalBPM);\n\n if ( Math.abs(intervalBPM - tempo) < bpmVariance ) {\n // convert sampleIndex to seconds\n peaksAtTopTempo.push(peak.sampleIndex/sampleRate);\n }\n }\n }\n\n // filter out peaks that are very close to each other\n peaksAtTopTempo = peaksAtTopTempo.filter(function(peakTime, index, arr) {\n var dif = arr[index + 1] - peakTime;\n if (dif > 0.01) {\n return true;\n }\n });\n\n return peaksAtTopTempo;\n }\n\n // helper function for processPeaks\n function mapTempo(theoreticalTempo) {\n // these scenarios create infinite while loop\n if (!isFinite(theoreticalTempo) || theoreticalTempo === 0 ) {\n return;\n }\n\n // Adjust the tempo to fit within the 90-180 BPM range\n while (theoreticalTempo < 90) theoreticalTempo *= 2;\n while (theoreticalTempo > 180 && theoreticalTempo > 90) theoreticalTempo /= 2;\n\n return theoreticalTempo;\n }\n\n\n /*** SCHEDULE EVENTS ***/\n\n // Cue inspired by JavaScript setTimeout, and the\n // Tone.js Transport Timeline Event, MIT License Yotam Mann 2015 tonejs.org\n var Cue = function(callback, time, id, val) {\n this.callback = callback;\n this.time = time;\n this.id = id;\n this.val = val;\n };\n\n /**\n * Schedule events to trigger every time a MediaElement\n * (audio/video) reaches a playback cue point.\n *\n * Accepts a callback function, a time (in seconds) at which to trigger\n * the callback, and an optional parameter for the callback.\n *\n * Time will be passed as the first parameter to the callback function,\n * and param will be the second parameter.\n *\n *\n * @method addCue\n * @for p5.SoundFile\n * @param {Number} time Time in seconds, relative to this media\n * element's playback. For example, to trigger\n * an event every time playback reaches two\n * seconds, pass in the number 2. This will be\n * passed as the first parameter to\n * the callback function.\n * @param {Function} callback Name of a function that will be\n * called at the given time. The callback will\n * receive time and (optionally) param as its\n * two parameters.\n * @param {Object} [value] An object to be passed as the\n * second parameter to the\n * callback function.\n * @return {Number} id ID of this cue,\n * useful for removeCue(id)\n * @example\n *
\n * let mySound;\n * function preload() {\n * mySound = loadSound('assets/Damscray_DancingTiger.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * text('tap to play', 10, 20);\n *\n * // schedule calls to changeText\n * mySound.addCue(0, changeText, \"hello\" );\n * mySound.addCue(0.5, changeText, \"hello,\" );\n * mySound.addCue(1, changeText, \"hello, p5!\");\n * mySound.addCue(1.5, changeText, \"hello, p5!!\");\n * mySound.addCue(2, changeText, \"hello, p5!!!!!\");\n * }\n *\n * function changeText(val) {\n * background(220);\n * text(val, 10, 20);\n * }\n *\n * function canvasPressed() {\n * mySound.play();\n * }\n *
\n */\n p5.SoundFile.prototype.addCue = function(time, callback, val) {\n var id = this._cueIDCounter++;\n\n var cue = new Cue(callback, time, id, val);\n this._cues.push(cue);\n\n // if (!this.elt.ontimeupdate) {\n // this.elt.ontimeupdate = this._onTimeUpdate.bind(this);\n // }\n\n return id;\n };\n\n /**\n * Remove a callback based on its ID. The ID is returned by the\n * addCue method.\n *\n * @method removeCue\n * @for p5.SoundFile\n * @param {Number} id ID of the cue, as returned by addCue\n */\n p5.SoundFile.prototype.removeCue = function(id) {\n var cueLength = this._cues.length;\n for (var i = 0; i < cueLength; i++) {\n var cue = this._cues[i];\n if (cue.id === id) {\n this._cues.splice(i, 1);\n break;\n }\n }\n\n if (this._cues.length === 0) {\n // TO DO: remove callback\n // this.elt.ontimeupdate = null\n }\n };\n\n /**\n * Remove all of the callbacks that had originally been scheduled\n * via the addCue method.\n *\n * @method clearCues\n */\n p5.SoundFile.prototype.clearCues = function() {\n this._cues = [];\n // this.elt.ontimeupdate = null;\n };\n\n // private method that checks for cues to be fired if events\n // have been scheduled using addCue(callback, time).\n p5.SoundFile.prototype._onTimeUpdate = function(position) {\n var playbackTime = position/this.buffer.sampleRate;\n var cueLength = this._cues.length;\n\n for (var i = 0 ; i < cueLength; i++) {\n var cue = this._cues[i];\n var callbackTime = cue.time;\n var val = cue.val;\n\n if (~~this._prevUpdateTime <= callbackTime && callbackTime <= playbackTime) {\n\n // pass the scheduled callbackTime as parameter to the callback\n cue.callback(val);\n }\n\n }\n\n this._prevUpdateTime = playbackTime;\n };\n\n /**\n * Save a p5.SoundFile as a .wav file. The browser will prompt the user\n * to download the file to their device. To upload a file to a server, see\n * getBlob\n *\n * @method save\n * @for p5.SoundFile\n * @param {String} [fileName] name of the resulting .wav file.\n * @example\n *
\n * let mySound;\n * function preload() {\n * mySound = loadSound('assets/doorbell.mp3');\n * }\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * text('tap to download', 10, 20);\n * }\n *\n * function canvasPressed() {\n * mySound.save('my cool filename');\n * }\n *
\n */\n p5.SoundFile.prototype.save = function(fileName) {\n p5.prototype.saveSound(this, fileName, 'wav');\n };\n\n /**\n * This method is useful for sending a SoundFile to a server. It returns the\n * .wav-encoded audio data as a \"Blob\".\n * A Blob is a file-like data object that can be uploaded to a server\n * with an http request. We'll\n * use the `httpDo` options object to send a POST request with some\n * specific options: we encode the request as `multipart/form-data`,\n * and attach the blob as one of the form values using `FormData`.\n *\n *\n * @method getBlob\n * @for p5.SoundFile\n * @returns {Blob} A file-like data object\n * @example\n *
\n * function preload() {\n * mySound = loadSound('assets/doorbell.mp3');\n * }\n *\n * function setup() {\n * noCanvas();\n * let soundBlob = mySound.getBlob();\n *\n * // Now we can send the blob to a server...\n * let serverUrl = 'https://jsonplaceholder.typicode.com/posts';\n * let httpRequestOptions = {\n * method: 'POST',\n * body: new FormData().append('soundBlob', soundBlob),\n * headers: new Headers({\n * 'Content-Type': 'multipart/form-data'\n * })\n * };\n * httpDo(serverUrl, httpRequestOptions);\n *\n * // We can also create an `ObjectURL` pointing to the Blob\n * let blobUrl = URL.createObjectURL(soundBlob);\n *\n * // The `
\n */\n p5.SoundFile.prototype.getBlob = function() {\n const dataView = convertToWav(this.buffer);\n return new Blob([dataView], { type: 'audio/wav' });\n };\n\n // event handler to remove references to the bufferSourceNode when it is done playing\n function _clearOnEnd(e) {\n const thisBufferSourceNode = e.target;\n const soundFile = this;\n\n // delete this.bufferSourceNode from the sources array when it is done playing:\n thisBufferSourceNode._playing = false;\n thisBufferSourceNode.removeEventListener('ended', soundFile._clearOnEnd);\n\n // call the onended callback\n soundFile._onended(soundFile);\n\n // delete bufferSourceNode(s) in soundFile.bufferSourceNodes\n // iterate in reverse order because the index changes by splice\n soundFile.bufferSourceNodes.map((_, i) => i).reverse().forEach(function (i) {\n const n = soundFile.bufferSourceNodes[i];\n\n if (n._playing === false) {\n soundFile.bufferSourceNodes.splice(i, 1);\n }\n });\n\n if (soundFile.bufferSourceNodes.length === 0) {\n soundFile._playing = false;\n }\n }\n});\n","'use strict';\n\ndefine(function (require) {\n const p5sound = require('master');\n const { safeBufferSize } = require('helpers');\n const processorNames = require('./audioWorklet/processorNames');\n\n /**\n * Amplitude measures volume between 0.0 and 1.0.\n * Listens to all p5sound by default, or use setInput()\n * to listen to a specific sound source. Accepts an optional\n * smoothing value, which defaults to 0.\n *\n * @class p5.Amplitude\n * @constructor\n * @param {Number} [smoothing] between 0.0 and .999 to smooth\n * amplitude readings (defaults to 0)\n * @example\n *
\n * let sound, amplitude;\n *\n * function preload(){\n * sound = loadSound('assets/beat.mp3');\n * }\n * function setup() {\n * let cnv = createCanvas(100,100);\n * cnv.mouseClicked(toggleSound);\n * amplitude = new p5.Amplitude();\n * }\n *\n * function draw() {\n * background(220);\n * text('tap to play', 20, 20);\n *\n * let level = amplitude.getLevel();\n * let size = map(level, 0, 1, 0, 200);\n * ellipse(width/2, height/2, size, size);\n * }\n *\n * function toggleSound() {\n * if (sound.isPlaying() ){\n * sound.stop();\n * } else {\n * sound.play();\n * }\n * }\n *\n *
\n */\n p5.Amplitude = function(smoothing) {\n\n // Set to 2048 for now. In future iterations, this should be inherited or parsed from p5sound's default\n this.bufferSize = safeBufferSize(2048);\n\n // set audio context\n this.audiocontext = p5sound.audiocontext;\n this._workletNode = new AudioWorkletNode(this.audiocontext, processorNames.amplitudeProcessor, {\n outputChannelCount: [1],\n\n parameterData: { smoothing: smoothing || 0 },\n processorOptions: {\n normalize: false,\n smoothing: smoothing || 0,\n numInputChannels: 2,\n bufferSize: this.bufferSize\n }\n });\n\n this._workletNode.port.onmessage = function(event) {\n if (event.data.name === 'amplitude') {\n this.volume = event.data.volume;\n this.volNorm = event.data.volNorm;\n this.stereoVol = event.data.stereoVol;\n this.stereoVolNorm = event.data.stereoVolNorm;\n }\n }.bind(this);\n\n // for connections\n this.input = this._workletNode;\n\n this.output = this.audiocontext.createGain();\n\n // the variables to return\n this.volume = 0;\n this.volNorm = 0;\n this.stereoVol = [0, 0];\n this.stereoVolNorm = [0, 0];\n\n this.normalize = false;\n\n this._workletNode.connect(this.output);\n this.output.gain.value = 0;\n\n // this may only be necessary because of a Chrome bug\n this.output.connect(this.audiocontext.destination);\n\n // connect to p5sound master output by default, unless set by input()\n p5sound.meter.connect(this._workletNode);\n\n // add this p5.SoundFile to the soundArray\n p5sound.soundArray.push(this);\n };\n\n /**\n * Connects to the p5sound instance (master output) by default.\n * Optionally, you can pass in a specific source (i.e. a soundfile).\n *\n * @method setInput\n * @for p5.Amplitude\n * @param {soundObject|undefined} [snd] set the sound source\n * (optional, defaults to\n * master output)\n * @param {Number|undefined} [smoothing] a range between 0.0 and 1.0\n * to smooth amplitude readings\n * @example\n *
\n * function preload(){\n * sound1 = loadSound('assets/beat.mp3');\n * sound2 = loadSound('assets/drum.mp3');\n * }\n * function setup(){\n * cnv = createCanvas(100, 100);\n * cnv.mouseClicked(toggleSound);\n *\n * amplitude = new p5.Amplitude();\n * amplitude.setInput(sound2);\n * }\n *\n * function draw() {\n * background(220);\n * text('tap to play', 20, 20);\n *\n * let level = amplitude.getLevel();\n * let size = map(level, 0, 1, 0, 200);\n * ellipse(width/2, height/2, size, size);\n * }\n *\n * function toggleSound(){\n * if (sound1.isPlaying() && sound2.isPlaying()) {\n * sound1.stop();\n * sound2.stop();\n * } else {\n * sound1.play();\n * sound2.play();\n * }\n * }\n *
\n */\n p5.Amplitude.prototype.setInput = function(source, smoothing) {\n\n p5sound.meter.disconnect();\n\n if (smoothing) {\n this._workletNode.parameters.get('smoothing').value = smoothing;\n }\n\n // connect to the master out of p5s instance if no snd is provided\n if (source == null) {\n console.log('Amplitude input source is not ready! Connecting to master output instead');\n p5sound.meter.connect(this._workletNode);\n }\n\n // if it is a p5.Signal\n else if (source instanceof p5.Signal) {\n source.output.connect(this._workletNode);\n }\n // connect to the sound if it is available\n else if (source) {\n source.connect(this._workletNode);\n this._workletNode.disconnect();\n this._workletNode.connect(this.output);\n }\n\n // otherwise, connect to the master out of p5s instance (default)\n else {\n p5sound.meter.connect(this._workletNode);\n }\n };\n\n p5.Amplitude.prototype.connect = function(unit) {\n if (unit) {\n if (unit.hasOwnProperty('input')) {\n this.output.connect(unit.input);\n } else {\n this.output.connect(unit);\n }\n } else {\n this.output.connect(this.panner.connect(p5sound.input));\n }\n };\n\n p5.Amplitude.prototype.disconnect = function() {\n if (this.output) {\n this.output.disconnect();\n }\n };\n\n /**\n * Returns a single Amplitude reading at the moment it is called.\n * For continuous readings, run in the draw loop.\n *\n * @method getLevel\n * @for p5.Amplitude\n * @param {Number} [channel] Optionally return only channel 0 (left) or 1 (right)\n * @return {Number} Amplitude as a number between 0.0 and 1.0\n * @example\n *
\n * function preload(){\n * sound = loadSound('assets/beat.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mouseClicked(toggleSound);\n * amplitude = new p5.Amplitude();\n * }\n *\n * function draw() {\n * background(220, 150);\n * textAlign(CENTER);\n * text('tap to play', width/2, 20);\n *\n * let level = amplitude.getLevel();\n * let size = map(level, 0, 1, 0, 200);\n * ellipse(width/2, height/2, size, size);\n * }\n *\n * function toggleSound(){\n * if (sound.isPlaying()) {\n * sound.stop();\n * } else {\n * sound.play();\n * }\n * }\n *
\n */\n p5.Amplitude.prototype.getLevel = function(channel) {\n if (typeof channel !== 'undefined') {\n if (this.normalize) {\n return this.stereoVolNorm[channel];\n } else {\n return this.stereoVol[channel];\n }\n }\n else if (this.normalize) {\n return this.volNorm;\n }\n else {\n return this.volume;\n }\n };\n\n /**\n * Determines whether the results of Amplitude.process() will be\n * Normalized. To normalize, Amplitude finds the difference the\n * loudest reading it has processed and the maximum amplitude of\n * 1.0. Amplitude adds this difference to all values to produce\n * results that will reliably map between 0.0 and 1.0. However,\n * if a louder moment occurs, the amount that Normalize adds to\n * all the values will change. Accepts an optional boolean parameter\n * (true or false). Normalizing is off by default.\n *\n * @method toggleNormalize\n * @for p5.Amplitude\n * @param {boolean} [boolean] set normalize to true (1) or false (0)\n */\n p5.Amplitude.prototype.toggleNormalize = function(bool) {\n if (typeof bool === 'boolean') {\n this.normalize = bool;\n }\n else {\n this.normalize = !this.normalize;\n }\n this._workletNode.port.postMessage({ name: 'toggleNormalize', normalize: this.normalize });\n };\n\n /**\n * Smooth Amplitude analysis by averaging with the last analysis\n * frame. Off by default.\n *\n * @method smooth\n * @for p5.Amplitude\n * @param {Number} set smoothing from 0.0 <= 1\n */\n p5.Amplitude.prototype.smooth = function(s) {\n if (s >= 0 && s < 1) {\n this._workletNode.port.postMessage({ name: 'smoothing', smoothing: s });\n } else {\n console.log('Error: smoothing must be between 0 and 1');\n }\n };\n\n p5.Amplitude.prototype.dispose = function() {\n // remove reference from soundArray\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n\n if (this.input) {\n this.input.disconnect();\n delete this.input;\n }\n if (this.output) {\n this.output.disconnect();\n delete this.output;\n }\n\n this._workletNode.disconnect();\n delete this._workletNode;\n };\n\n});\n","'use strict';\n\ndefine(function(require) {\n var p5sound = require('master');\n\n /**\n *

FFT (Fast Fourier Transform) is an analysis algorithm that\n * isolates individual\n * \n * audio frequencies within a waveform.

\n *\n *

Once instantiated, a p5.FFT object can return an array based on\n * two types of analyses:
• FFT.waveform() computes\n * amplitude values along the time domain. The array indices correspond\n * to samples across a brief moment in time. Each value represents\n * amplitude of the waveform at that sample of time.
\n * • FFT.analyze() computes amplitude values along the\n * frequency domain. The array indices correspond to frequencies (i.e.\n * pitches), from the lowest to the highest that humans can hear. Each\n * value represents amplitude at that slice of the frequency spectrum.\n * Use with getEnergy() to measure amplitude at specific\n * frequencies, or within a range of frequencies.

\n *\n *

FFT analyzes a very short snapshot of sound called a sample\n * buffer. It returns an array of amplitude measurements, referred\n * to as bins. The array is 1024 bins long by default.\n * You can change the bin array length, but it must be a power of 2\n * between 16 and 1024 in order for the FFT algorithm to function\n * correctly. The actual size of the FFT buffer is twice the\n * number of bins, so given a standard sample rate, the buffer is\n * 2048/44100 seconds long.

\n *\n *\n * @class p5.FFT\n * @constructor\n * @param {Number} [smoothing] Smooth results of Freq Spectrum.\n * 0.0 < smoothing < 1.0.\n * Defaults to 0.8.\n * @param {Number} [bins] Length of resulting array.\n * Must be a power of two between\n * 16 and 1024. Defaults to 1024.\n * @example\n *
\n * function preload(){\n * sound = loadSound('assets/Damscray_DancingTiger.mp3');\n * }\n *\n * function setup(){\n * let cnv = createCanvas(100,100);\n * cnv.mouseClicked(togglePlay);\n * fft = new p5.FFT();\n * sound.amp(0.2);\n * }\n *\n * function draw(){\n * background(220);\n *\n * let spectrum = fft.analyze();\n * noStroke();\n * fill(255, 0, 255);\n * for (let i = 0; i< spectrum.length; i++){\n * let x = map(i, 0, spectrum.length, 0, width);\n * let h = -height + map(spectrum[i], 0, 255, height, 0);\n * rect(x, height, width / spectrum.length, h )\n * }\n *\n * let waveform = fft.waveform();\n * noFill();\n * beginShape();\n * stroke(20);\n * for (let i = 0; i < waveform.length; i++){\n * let x = map(i, 0, waveform.length, 0, width);\n * let y = map( waveform[i], -1, 1, 0, height);\n * vertex(x,y);\n * }\n * endShape();\n *\n * text('tap to play', 20, 20);\n * }\n *\n * function togglePlay() {\n * if (sound.isPlaying()) {\n * sound.pause();\n * } else {\n * sound.loop();\n * }\n * }\n *
\n */\n p5.FFT = function(smoothing, bins) {\n this.input = this.analyser = p5sound.audiocontext.createAnalyser();\n\n Object.defineProperties(this, {\n bins: {\n get: function() {\n return this.analyser.fftSize / 2;\n },\n set: function(b) {\n this.analyser.fftSize = b * 2;\n },\n configurable: true,\n enumerable: true\n },\n smoothing: {\n get: function() {\n return this.analyser.smoothingTimeConstant;\n },\n set: function(s) {\n this.analyser.smoothingTimeConstant = s;\n },\n configurable: true,\n enumerable: true\n }\n });\n\n // set default smoothing and bins\n this.smooth(smoothing);\n this.bins = bins || 1024;\n\n // default connections to p5sound fftMeter\n p5sound.fftMeter.connect(this.analyser);\n\n this.freqDomain = new Uint8Array(this.analyser.frequencyBinCount);\n this.timeDomain = new Uint8Array(this.analyser.frequencyBinCount);\n\n // predefined frequency ranges, these will be tweakable\n this.bass = [20, 140];\n this.lowMid = [140, 400];\n this.mid = [400, 2600];\n this.highMid = [2600, 5200];\n this.treble = [5200, 14000];\n\n // add this p5.SoundFile to the soundArray\n p5sound.soundArray.push(this);\n };\n\n /**\n * Set the input source for the FFT analysis. If no source is\n * provided, FFT will analyze all sound in the sketch.\n *\n * @method setInput\n * @for p5.FFT\n * @param {Object} [source] p5.sound object (or web audio API source node)\n */\n p5.FFT.prototype.setInput = function(source) {\n if (!source) {\n p5sound.fftMeter.connect(this.analyser);\n } else {\n if (source.output) {\n source.output.connect(this.analyser);\n } else if (source.connect) {\n source.connect(this.analyser);\n }\n p5sound.fftMeter.disconnect();\n }\n };\n\n /**\n * Returns an array of amplitude values (between -1.0 and +1.0) that represent\n * a snapshot of amplitude readings in a single buffer. Length will be\n * equal to bins (defaults to 1024). Can be used to draw the waveform\n * of a sound.\n *\n * @method waveform\n * @for p5.FFT\n * @param {Number} [bins] Must be a power of two between\n * 16 and 1024. Defaults to 1024.\n * @param {String} [precision] If any value is provided, will return results\n * in a Float32 Array which is more precise\n * than a regular array.\n * @return {Array} Array Array of amplitude values (-1 to 1)\n * over time. Array length = bins.\n *\n */\n p5.FFT.prototype.waveform = function() {\n var bins, mode, normalArray;\n\n for (var i = 0; i < arguments.length; i++) {\n if (typeof arguments[i] === 'number') {\n bins = arguments[i];\n this.analyser.fftSize = bins * 2;\n }\n if (typeof arguments[i] === 'string') {\n mode = arguments[i];\n }\n }\n\n // getFloatFrequencyData doesnt work in Safari as of 5/2015\n if (mode && !p5.prototype._isSafari()) {\n timeToFloat(this, this.timeDomain);\n this.analyser.getFloatTimeDomainData(this.timeDomain);\n return this.timeDomain;\n } else {\n timeToInt(this, this.timeDomain);\n this.analyser.getByteTimeDomainData(this.timeDomain);\n var normalArray = new Array();\n for (var j = 0; j < this.timeDomain.length; j++) {\n var scaled = p5.prototype.map(this.timeDomain[j], 0, 255, -1, 1);\n normalArray.push(scaled);\n }\n return normalArray;\n }\n };\n\n /**\n * Returns an array of amplitude values (between 0 and 255)\n * across the frequency spectrum. Length is equal to FFT bins\n * (1024 by default). The array indices correspond to frequencies\n * (i.e. pitches), from the lowest to the highest that humans can\n * hear. Each value represents amplitude at that slice of the\n * frequency spectrum. Must be called prior to using\n * getEnergy().\n *\n * @method analyze\n * @for p5.FFT\n * @param {Number} [bins] Must be a power of two between\n * 16 and 1024. Defaults to 1024.\n * @param {Number} [scale] If \"dB,\" returns decibel\n * float measurements between\n * -140 and 0 (max).\n * Otherwise returns integers from 0-255.\n * @return {Array} spectrum Array of energy (amplitude/volume)\n * values across the frequency spectrum.\n * Lowest energy (silence) = 0, highest\n * possible is 255.\n * @example\n *
\n * let osc, fft;\n *\n * function setup(){\n * let cnv = createCanvas(100,100);\n * cnv.mousePressed(startSound);\n * osc = new p5.Oscillator();\n * osc.amp(0);\n * fft = new p5.FFT();\n * }\n *\n * function draw(){\n * background(220);\n *\n * let freq = map(mouseX, 0, windowWidth, 20, 10000);\n * freq = constrain(freq, 1, 20000);\n * osc.freq(freq);\n *\n * let spectrum = fft.analyze();\n * noStroke();\n * fill(255, 0, 255);\n * for (let i = 0; i< spectrum.length; i++){\n * let x = map(i, 0, spectrum.length, 0, width);\n * let h = -height + map(spectrum[i], 0, 255, height, 0);\n * rect(x, height, width / spectrum.length, h );\n * }\n *\n * stroke(255);\n * if (!osc.started) {\n * text('tap here and drag to change frequency', 10, 20, width - 20);\n * } else {\n * text(round(freq)+'Hz', 10, 20);\n * }\n * }\n *\n * function startSound() {\n * osc.start();\n * osc.amp(0.5, 0.2);\n * }\n *\n * function mouseReleased() {\n * osc.amp(0, 0.2);\n * }\n *
\n *\n *\n */\n p5.FFT.prototype.analyze = function() {\n var mode;\n\n for (var i = 0; i < arguments.length; i++) {\n if (typeof arguments[i] === 'number') {\n this.bins = arguments[i];\n this.analyser.fftSize = this.bins * 2;\n }\n if (typeof arguments[i] === 'string') {\n mode = arguments[i];\n }\n }\n\n if (mode && mode.toLowerCase() === 'db') {\n freqToFloat(this);\n this.analyser.getFloatFrequencyData(this.freqDomain);\n return this.freqDomain;\n } else {\n freqToInt(this, this.freqDomain);\n this.analyser.getByteFrequencyData(this.freqDomain);\n var normalArray = Array.apply([], this.freqDomain);\n\n return normalArray;\n }\n };\n\n /**\n * Returns the amount of energy (volume) at a specific\n * \n * frequency, or the average amount of energy between two\n * frequencies. Accepts Number(s) corresponding\n * to frequency (in Hz), or a String corresponding to predefined\n * frequency ranges (\"bass\", \"lowMid\", \"mid\", \"highMid\", \"treble\").\n * Returns a range between 0 (no energy/volume at that frequency) and\n * 255 (maximum energy).\n * NOTE: analyze() must be called prior to getEnergy(). Analyze()\n * tells the FFT to analyze frequency data, and getEnergy() uses\n * the results determine the value at a specific frequency or\n * range of frequencies.

\n *\n * @method getEnergy\n * @for p5.FFT\n * @param {Number|String} frequency1 Will return a value representing\n * energy at this frequency. Alternately,\n * the strings \"bass\", \"lowMid\" \"mid\",\n * \"highMid\", and \"treble\" will return\n * predefined frequency ranges.\n * @param {Number} [frequency2] If a second frequency is given,\n * will return average amount of\n * energy that exists between the\n * two frequencies.\n * @return {Number} Energy Energy (volume/amplitude) from\n * 0 and 255.\n *\n */\n p5.FFT.prototype.getEnergy = function(frequency1, frequency2) {\n var nyquist = p5sound.audiocontext.sampleRate / 2;\n\n if (frequency1 === 'bass') {\n frequency1 = this.bass[0];\n frequency2 = this.bass[1];\n } else if (frequency1 === 'lowMid') {\n frequency1 = this.lowMid[0];\n frequency2 = this.lowMid[1];\n } else if (frequency1 === 'mid') {\n frequency1 = this.mid[0];\n frequency2 = this.mid[1];\n } else if (frequency1 === 'highMid') {\n frequency1 = this.highMid[0];\n frequency2 = this.highMid[1];\n } else if (frequency1 === 'treble') {\n frequency1 = this.treble[0];\n frequency2 = this.treble[1];\n }\n\n if (typeof frequency1 !== 'number') {\n throw 'invalid input for getEnergy()';\n } else if (!frequency2) {\n // if only one parameter:\n var index = Math.round(frequency1 / nyquist * this.freqDomain.length);\n return this.freqDomain[index];\n } else if (frequency1 && frequency2) {\n // if two parameters:\n // if second is higher than first\n if (frequency1 > frequency2) {\n var swap = frequency2;\n frequency2 = frequency1;\n frequency1 = swap;\n }\n var lowIndex = Math.round(frequency1 / nyquist * this.freqDomain.length);\n var highIndex = Math.round(frequency2 / nyquist * this.freqDomain.length);\n\n var total = 0;\n var numFrequencies = 0;\n // add up all of the values for the frequencies\n for (var i = lowIndex; i <= highIndex; i++) {\n total += this.freqDomain[i];\n numFrequencies += 1;\n }\n // divide by total number of frequencies\n var toReturn = total / numFrequencies;\n return toReturn;\n } else {\n throw 'invalid input for getEnergy()';\n }\n };\n\n // compatability with v.012, changed to getEnergy in v.0121. Will be deprecated...\n p5.FFT.prototype.getFreq = function(freq1, freq2) {\n console.log('getFreq() is deprecated. Please use getEnergy() instead.');\n var x = this.getEnergy(freq1, freq2);\n return x;\n };\n\n /**\n * Returns the\n * \n * spectral centroid of the input signal.\n * NOTE: analyze() must be called prior to getCentroid(). Analyze()\n * tells the FFT to analyze frequency data, and getCentroid() uses\n * the results determine the spectral centroid.

\n *\n * @method getCentroid\n * @for p5.FFT\n * @return {Number} Spectral Centroid Frequency Frequency of the spectral centroid in Hz.\n *\n *\n * @example\n *
\n * function setup(){\n * cnv = createCanvas(100,100);\n * cnv.mousePressed(userStartAudio);\n * sound = new p5.AudioIn();\n * sound.start();\n * fft = new p5.FFT();\n * sound.connect(fft);\n *}\n *\n *function draw() {\n * if (getAudioContext().state !== 'running') {\n * background(220);\n * text('tap here and enable mic to begin', 10, 20, width - 20);\n * return;\n * }\n * let centroidplot = 0.0;\n * let spectralCentroid = 0;\n *\n * background(0);\n * stroke(0,255,0);\n * let spectrum = fft.analyze();\n * fill(0,255,0); // spectrum is green\n *\n * //draw the spectrum\n * for (let i = 0; i < spectrum.length; i++){\n * let x = map(log(i), 0, log(spectrum.length), 0, width);\n * let h = map(spectrum[i], 0, 255, 0, height);\n * let rectangle_width = (log(i+1)-log(i))*(width/log(spectrum.length));\n * rect(x, height, rectangle_width, -h )\n * }\n * let nyquist = 22050;\n *\n * // get the centroid\n * spectralCentroid = fft.getCentroid();\n *\n * // the mean_freq_index calculation is for the display.\n * let mean_freq_index = spectralCentroid/(nyquist/spectrum.length);\n *\n * centroidplot = map(log(mean_freq_index), 0, log(spectrum.length), 0, width);\n *\n * stroke(255,0,0); // the line showing where the centroid is will be red\n *\n * rect(centroidplot, 0, width / spectrum.length, height)\n * noStroke();\n * fill(255,255,255); // text is white\n * text('centroid: ', 10, 20);\n * text(round(spectralCentroid)+' Hz', 10, 40);\n *}\n *
\n */\n p5.FFT.prototype.getCentroid = function() {\n var nyquist = p5sound.audiocontext.sampleRate / 2;\n var cumulative_sum = 0;\n var centroid_normalization = 0;\n\n for (var i = 0; i < this.freqDomain.length; i++) {\n cumulative_sum += i * this.freqDomain[i];\n centroid_normalization += this.freqDomain[i];\n }\n\n var mean_freq_index = 0;\n\n if (centroid_normalization !== 0) {\n mean_freq_index = cumulative_sum / centroid_normalization;\n }\n\n var spec_centroid_freq =\n mean_freq_index * (nyquist / this.freqDomain.length);\n return spec_centroid_freq;\n };\n\n /**\n * Smooth FFT analysis by averaging with the last analysis frame.\n *\n * @method smooth\n * @param {Number} smoothing 0.0 < smoothing < 1.0.\n * Defaults to 0.8.\n */\n p5.FFT.prototype.smooth = function(s) {\n if (typeof s !== 'undefined') {\n this.smoothing = s;\n }\n return this.smoothing;\n };\n\n p5.FFT.prototype.dispose = function() {\n // remove reference from soundArray\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n\n if (this.analyser) {\n this.analyser.disconnect();\n delete this.analyser;\n }\n };\n\n /**\n * Returns an array of average amplitude values for a given number\n * of frequency bands split equally. N defaults to 16.\n * NOTE: analyze() must be called prior to linAverages(). Analyze()\n * tells the FFT to analyze frequency data, and linAverages() uses\n * the results to group them into a smaller set of averages.

\n *\n * @method linAverages\n * @for p5.FFT\n * @param {Number} N Number of returned frequency groups\n * @return {Array} linearAverages Array of average amplitude values for each group\n */\n p5.FFT.prototype.linAverages = function(N) {\n var N = N || 16; // This prevents undefined, null or 0 values of N\n\n var spectrum = this.freqDomain;\n var spectrumLength = spectrum.length;\n var spectrumStep = Math.floor(spectrumLength / N);\n\n var linearAverages = new Array(N);\n // Keep a second index for the current average group and place the values accordingly\n // with only one loop in the spectrum data\n var groupIndex = 0;\n\n for (var specIndex = 0; specIndex < spectrumLength; specIndex++) {\n linearAverages[groupIndex] =\n linearAverages[groupIndex] !== undefined\n ? (linearAverages[groupIndex] + spectrum[specIndex]) / 2\n : spectrum[specIndex];\n\n // Increase the group index when the last element of the group is processed\n if (specIndex % spectrumStep === spectrumStep - 1) {\n groupIndex++;\n }\n }\n\n return linearAverages;\n };\n\n /**\n * Returns an array of average amplitude values of the spectrum, for a given\n * set of \n * Octave Bands\n * NOTE: analyze() must be called prior to logAverages(). Analyze()\n * tells the FFT to analyze frequency data, and logAverages() uses\n * the results to group them into a smaller set of averages.

\n *\n * @method logAverages\n * @for p5.FFT\n * @param {Array} octaveBands Array of Octave Bands objects for grouping\n * @return {Array} logAverages Array of average amplitude values for each group\n */\n p5.FFT.prototype.logAverages = function(octaveBands) {\n var nyquist = p5sound.audiocontext.sampleRate / 2;\n var spectrum = this.freqDomain;\n var spectrumLength = spectrum.length;\n\n var logAverages = new Array(octaveBands.length);\n // Keep a second index for the current average group and place the values accordingly\n // With only one loop in the spectrum data\n var octaveIndex = 0;\n\n for (var specIndex = 0; specIndex < spectrumLength; specIndex++) {\n var specIndexFrequency = Math.round(\n specIndex * nyquist / this.freqDomain.length\n );\n\n // Increase the group index if the current frequency exceeds the limits of the band\n if (specIndexFrequency > octaveBands[octaveIndex].hi) {\n octaveIndex++;\n }\n\n logAverages[octaveIndex] =\n logAverages[octaveIndex] !== undefined\n ? (logAverages[octaveIndex] + spectrum[specIndex]) / 2\n : spectrum[specIndex];\n }\n\n return logAverages;\n };\n\n /**\n * Calculates and Returns the 1/N\n * Octave Bands\n * N defaults to 3 and minimum central frequency to 15.625Hz.\n * (1/3 Octave Bands ~= 31 Frequency Bands)\n * Setting fCtr0 to a central value of a higher octave will ignore the lower bands\n * and produce less frequency groups.\n *\n * @method getOctaveBands\n * @for p5.FFT\n * @param {Number} N Specifies the 1/N type of generated octave bands\n * @param {Number} fCtr0 Minimum central frequency for the lowest band\n * @return {Array} octaveBands Array of octave band objects with their bounds\n */\n p5.FFT.prototype.getOctaveBands = function(N, fCtr0) {\n var N = N || 3; // Default to 1/3 Octave Bands\n var fCtr0 = fCtr0 || 15.625; // Minimum central frequency, defaults to 15.625Hz\n\n var octaveBands = [];\n var lastFrequencyBand = {\n lo: fCtr0 / Math.pow(2, 1 / (2 * N)),\n ctr: fCtr0,\n hi: fCtr0 * Math.pow(2, 1 / (2 * N))\n };\n octaveBands.push(lastFrequencyBand);\n\n var nyquist = p5sound.audiocontext.sampleRate / 2;\n while (lastFrequencyBand.hi < nyquist) {\n var newFrequencyBand = {};\n newFrequencyBand.lo = lastFrequencyBand.hi;\n newFrequencyBand.ctr = lastFrequencyBand.ctr * Math.pow(2, 1 / N);\n newFrequencyBand.hi = newFrequencyBand.ctr * Math.pow(2, 1 / (2 * N));\n\n octaveBands.push(newFrequencyBand);\n lastFrequencyBand = newFrequencyBand;\n }\n\n return octaveBands;\n };\n\n // helper methods to convert type from float (dB) to int (0-255)\n var freqToFloat = function(fft) {\n if (fft.freqDomain instanceof Float32Array === false) {\n fft.freqDomain = new Float32Array(fft.analyser.frequencyBinCount);\n }\n };\n var freqToInt = function(fft) {\n if (fft.freqDomain instanceof Uint8Array === false) {\n fft.freqDomain = new Uint8Array(fft.analyser.frequencyBinCount);\n }\n };\n var timeToFloat = function(fft) {\n if (fft.timeDomain instanceof Float32Array === false) {\n fft.timeDomain = new Float32Array(fft.analyser.frequencyBinCount);\n }\n };\n var timeToInt = function(fft) {\n if (fft.timeDomain instanceof Uint8Array === false) {\n fft.timeDomain = new Uint8Array(fft.analyser.frequencyBinCount);\n }\n };\n});\n","'use strict';\n\ndefine(function (require) {\n\n // Signal is built with the Tone.js signal by Yotam Mann\n // https://github.com/TONEnoTONE/Tone.js/\n var Signal = require('Tone/signal/Signal');\n var Add = require('Tone/signal/Add');\n var Mult = require('Tone/signal/Multiply');\n var Scale = require('Tone/signal/Scale');\n\n /**\n *

p5.Signal is a constant audio-rate signal used by p5.Oscillator\n * and p5.Envelope for modulation math.

\n *\n *

This is necessary because Web Audio is processed on a seprate clock.\n * For example, the p5 draw loop runs about 60 times per second. But\n * the audio clock must process samples 44100 times per second. If we\n * want to add a value to each of those samples, we can't do it in the\n * draw loop, but we can do it by adding a constant-rate audio signal.This class mostly functions behind the scenes in p5.sound, and returns\n * a Tone.Signal from the Tone.js library by Yotam Mann.\n * If you want to work directly with audio signals for modular\n * synthesis, check out\n * tone.js.

\n *\n * @class p5.Signal\n * @constructor\n * @return {Tone.Signal} A Signal object from the Tone.js library\n * @example\n *
\n * let carrier, modulator;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * text('tap to play', 20, 20);\n *\n * carrier = new p5.Oscillator('sine');\n * carrier.start();\n * carrier.amp(1); // set amplitude\n * carrier.freq(220); // set frequency\n *\n * modulator = new p5.Oscillator('sawtooth');\n * modulator.disconnect();\n * modulator.start();\n * modulator.amp(1);\n * modulator.freq(4);\n *\n * // Modulator's default amplitude range is -1 to 1.\n * // Multiply it by -200, so the range is -200 to 200\n * // then add 220 so the range is 20 to 420\n * carrier.freq( modulator.mult(-400).add(220) );\n * }\n *\n * function canvasPressed() {\n * userStartAudio();\n * carrier.amp(1.0);\n * }\n *\n * function mouseReleased() {\n * carrier.amp(0);\n * }\n *
\n */\n p5.Signal = function(value) {\n var s = new Signal(value);\n // p5sound.soundArray.push(s);\n return s; // TODO: is this really a constructor?\n };\n\n /**\n * Fade to value, for smooth transitions\n *\n * @method fade\n * @for p5.Signal\n * @param {Number} value Value to set this signal\n * @param {Number} [secondsFromNow] Length of fade, in seconds from now\n */\n Signal.prototype.fade = Signal.prototype.linearRampToValueAtTime;\n Mult.prototype.fade = Signal.prototype.fade;\n Add.prototype.fade = Signal.prototype.fade;\n Scale.prototype.fade = Signal.prototype.fade;\n\n\n /**\n * Connect a p5.sound object or Web Audio node to this\n * p5.Signal so that its amplitude values can be scaled.\n *\n * @method setInput\n * @for p5.Signal\n * @param {Object} input\n */\n Signal.prototype.setInput = function(_input) {\n _input.connect(this);\n };\n Mult.prototype.setInput = Signal.prototype.setInput;\n Add.prototype.setInput = Signal.prototype.setInput;\n Scale.prototype.setInput = Signal.prototype.setInput;\n\n\n // signals can add / mult / scale themselves\n\n /**\n * Add a constant value to this audio signal,\n * and return the resulting audio signal. Does\n * not change the value of the original signal,\n * instead it returns a new p5.SignalAdd.\n *\n * @method add\n * @for p5.Signal\n * @param {Number} number\n * @return {p5.Signal} object\n */\n Signal.prototype.add = function(num) {\n var add = new Add(num);\n // add.setInput(this);\n this.connect(add);\n return add;\n };\n Mult.prototype.add = Signal.prototype.add;\n Add.prototype.add = Signal.prototype.add;\n Scale.prototype.add = Signal.prototype.add;\n\n /**\n * Multiply this signal by a constant value,\n * and return the resulting audio signal. Does\n * not change the value of the original signal,\n * instead it returns a new p5.SignalMult.\n *\n * @method mult\n * @for p5.Signal\n * @param {Number} number to multiply\n * @return {p5.Signal} object\n */\n Signal.prototype.mult = function(num) {\n var mult = new Mult(num);\n // mult.setInput(this);\n this.connect(mult);\n return mult;\n };\n Mult.prototype.mult = Signal.prototype.mult;\n Add.prototype.mult = Signal.prototype.mult;\n Scale.prototype.mult = Signal.prototype.mult;\n\n /**\n * Scale this signal value to a given range,\n * and return the result as an audio signal. Does\n * not change the value of the original signal,\n * instead it returns a new p5.SignalScale.\n *\n * @method scale\n * @for p5.Signal\n * @param {Number} number to multiply\n * @param {Number} inMin input range minumum\n * @param {Number} inMax input range maximum\n * @param {Number} outMin input range minumum\n * @param {Number} outMax input range maximum\n * @return {p5.Signal} object\n */\n Signal.prototype.scale = function(inMin, inMax, outMin, outMax) {\n var mapOutMin, mapOutMax;\n if (arguments.length === 4) {\n mapOutMin = p5.prototype.map(outMin, inMin, inMax, 0, 1) - 0.5;\n mapOutMax = p5.prototype.map(outMax, inMin, inMax, 0, 1) - 0.5;\n }\n else {\n mapOutMin = arguments[0];\n mapOutMax = arguments[1];\n }\n var scale = new Scale(mapOutMin, mapOutMax);\n this.connect(scale);\n return scale;\n };\n Mult.prototype.scale = Signal.prototype.scale;\n Add.prototype.scale = Signal.prototype.scale;\n Scale.prototype.scale = Signal.prototype.scale;\n\n});\n\n\n","define([\"Tone/core/Tone\", \"Tone/type/TimeBase\"], function (Tone) {\n\n\t/**\n\t * @class Tone.Frequency is a primitive type for encoding Frequency values. \n\t * Eventually all time values are evaluated to hertz\n\t * using the `eval` method. \n\t * @constructor\n\t * @extends {Tone.TimeBase}\n\t * @param {String|Number} val The time value.\n\t * @param {String=} units The units of the value.\n\t * @example\n\t * Tone.Frequency(\"C3\") // 261\n\t * Tone.Frequency(38, \"midi\") //\n\t * Tone.Frequency(\"C3\").transpose(4);\n\t */\n\tTone.Frequency = function(val, units){\n\t\tif (this instanceof Tone.Frequency){\n\t\t\t\n\t\t\tTone.TimeBase.call(this, val, units);\n\n\t\t} else {\n\t\t\treturn new Tone.Frequency(val, units);\n\t\t}\n\t};\n\n\tTone.extend(Tone.Frequency, Tone.TimeBase);\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tAUGMENT BASE EXPRESSIONS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t//clone the expressions so that \n\t//we can add more without modifying the original\n\tTone.Frequency.prototype._primaryExpressions = Object.create(Tone.TimeBase.prototype._primaryExpressions);\n\n\t/*\n\t * midi type primary expression\n\t * @type {Object}\n\t * @private\n\t */\n\tTone.Frequency.prototype._primaryExpressions.midi = {\n\t\tregexp : /^(\\d+(?:\\.\\d+)?midi)/,\n\t\tmethod : function(value){\n\t\t\treturn this.midiToFrequency(value);\n\t\t}\t\n\t};\n\n\t/*\n\t * note type primary expression\n\t * @type {Object}\n\t * @private\n\t */\n\tTone.Frequency.prototype._primaryExpressions.note = {\n\t\tregexp : /^([a-g]{1}(?:b|#|x|bb)?)(-?[0-9]+)/i,\n\t\tmethod : function(pitch, octave){\n\t\t\tvar index = noteToScaleIndex[pitch.toLowerCase()];\n\t\t\tvar noteNumber = index + (parseInt(octave) + 1) * 12;\n\t\t\treturn this.midiToFrequency(noteNumber);\n\t\t}\t\n\t};\n\n\t/*\n\t * BeatsBarsSixteenths type primary expression\n\t * @type {Object}\n\t * @private\n\t */\n\tTone.Frequency.prototype._primaryExpressions.tr = {\n\t\t\tregexp : /^(\\d+(?:\\.\\d+)?):(\\d+(?:\\.\\d+)?):?(\\d+(?:\\.\\d+)?)?/,\n\t\t\tmethod : function(m, q, s){\n\t\t\tvar total = 1;\n\t\t\tif (m && m !== \"0\"){\n\t\t\t\ttotal *= this._beatsToUnits(this._timeSignature() * parseFloat(m));\n\t\t\t}\n\t\t\tif (q && q !== \"0\"){\n\t\t\t\ttotal *= this._beatsToUnits(parseFloat(q));\n\t\t\t}\n\t\t\tif (s && s !== \"0\"){\n\t\t\t\ttotal *= this._beatsToUnits(parseFloat(s) / 4);\n\t\t\t}\n\t\t\treturn total;\n\t\t}\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tEXPRESSIONS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Transposes the frequency by the given number of semitones.\n\t * @param {Interval} interval\n\t * @return {Tone.Frequency} this\n\t * @example\n\t * Tone.Frequency(\"A4\").transpose(3); //\"C5\"\n\t */\n\tTone.Frequency.prototype.transpose = function(interval){\n\t\tthis._expr = function(expr, interval){\n\t\t\tvar val = expr();\n\t\t\treturn val * this.intervalToFrequencyRatio(interval);\n\t\t}.bind(this, this._expr, interval);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Takes an array of semitone intervals and returns\n\t * an array of frequencies transposed by those intervals.\n\t * @param {Array} intervals\n\t * @return {Tone.Frequency} this\n\t * @example\n\t * Tone.Frequency(\"A4\").harmonize([0, 3, 7]); //[\"A4\", \"C5\", \"E5\"]\n\t */\n\tTone.Frequency.prototype.harmonize = function(intervals){\n\t\tthis._expr = function(expr, intervals){\n\t\t\tvar val = expr();\n\t\t\tvar ret = [];\n\t\t\tfor (var i = 0; i < intervals.length; i++){\n\t\t\t\tret[i] = val * this.intervalToFrequencyRatio(intervals[i]);\n\t\t\t}\n\t\t\treturn ret;\n\t\t}.bind(this, this._expr, intervals);\n\t\treturn this;\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tUNIT CONVERSIONS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Return the value of the frequency as a MIDI note\n\t * @return {MIDI}\n\t * @example\n\t * Tone.Frequency(\"C4\").toMidi(); //60\n\t */\n\tTone.Frequency.prototype.toMidi = function(){\n\t\treturn this.frequencyToMidi(this.valueOf());\n\t};\n\n\t/**\n\t * Return the value of the frequency in Scientific Pitch Notation\n\t * @return {Note}\n\t * @example\n\t * Tone.Frequency(69, \"midi\").toNote(); //\"A4\"\n\t */\n\tTone.Frequency.prototype.toNote = function(){\n\t\tvar freq = this.valueOf();\n\t\tvar log = Math.log(freq / Tone.Frequency.A4) / Math.LN2;\n\t\tvar noteNumber = Math.round(12 * log) + 57;\n\t\tvar octave = Math.floor(noteNumber/12);\n\t\tif(octave < 0){\n\t\t\tnoteNumber += -12 * octave;\n\t\t}\n\t\tvar noteName = scaleIndexToNote[noteNumber % 12];\n\t\treturn noteName + octave.toString();\n\t};\n\n\t/**\n\t * Return the duration of one cycle in seconds.\n\t * @return {Seconds}\n\t */\n\tTone.Frequency.prototype.toSeconds = function(){\n\t\treturn 1 / this.valueOf();\n\t};\n\n\t/**\n\t * Return the value in Hertz\n\t * @return {Frequency}\n\t */\n\tTone.Frequency.prototype.toFrequency = function(){\n\t\treturn this.valueOf();\n\t};\n\n\t/**\n\t * Return the duration of one cycle in ticks\n\t * @return {Ticks}\n\t */\n\tTone.Frequency.prototype.toTicks = function(){\n\t\tvar quarterTime = this._beatsToUnits(1);\n\t\tvar quarters = this.valueOf() / quarterTime;\n\t\treturn Math.floor(quarters * Tone.Transport.PPQ);\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tUNIT CONVERSIONS HELPERS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Returns the value of a frequency in the current units\n\t * @param {Frequency} freq\n\t * @return {Number}\n\t * @private\n\t */\n\tTone.Frequency.prototype._frequencyToUnits = function(freq){\n\t\treturn freq;\n\t};\n\n\t/**\n\t * Returns the value of a tick in the current time units\n\t * @param {Ticks} ticks\n\t * @return {Number}\n\t * @private\n\t */\n\tTone.Frequency.prototype._ticksToUnits = function(ticks){\n\t\treturn 1 / ((ticks * 60) / (Tone.Transport.bpm.value * Tone.Transport.PPQ));\n\t};\n\n\t/**\n\t * Return the value of the beats in the current units\n\t * @param {Number} beats\n\t * @return {Number}\n\t * @private\n\t */\n\tTone.Frequency.prototype._beatsToUnits = function(beats){\n\t\treturn 1 / Tone.TimeBase.prototype._beatsToUnits.call(this, beats);\n\t};\n\n\t/**\n\t * Returns the value of a second in the current units\n\t * @param {Seconds} seconds\n\t * @return {Number}\n\t * @private\n\t */\n\tTone.Frequency.prototype._secondsToUnits = function(seconds){\n\t\treturn 1 / seconds;\n\t};\n\n\t/**\n\t * The default units if none are given.\n\t * @private\n\t */\n\tTone.Frequency.prototype._defaultUnits = \"hz\";\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tFREQUENCY CONVERSIONS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Note to scale index\n\t * @type {Object}\n\t */\n\tvar noteToScaleIndex = {\n\t\t\"cbb\" : -2, \"cb\" : -1, \"c\" : 0, \"c#\" : 1, \"cx\" : 2, \n\t\t\"dbb\" : 0, \"db\" : 1, \"d\" : 2, \"d#\" : 3, \"dx\" : 4,\n\t\t\"ebb\" : 2, \"eb\" : 3, \"e\" : 4, \"e#\" : 5, \"ex\" : 6, \n\t\t\"fbb\" : 3, \"fb\" : 4, \"f\" : 5, \"f#\" : 6, \"fx\" : 7,\n\t\t\"gbb\" : 5, \"gb\" : 6, \"g\" : 7, \"g#\" : 8, \"gx\" : 9,\n\t\t\"abb\" : 7, \"ab\" : 8, \"a\" : 9, \"a#\" : 10, \"ax\" : 11,\n\t\t\"bbb\" : 9, \"bb\" : 10, \"b\" : 11, \"b#\" : 12, \"bx\" : 13,\n\t};\n\n\t/**\n\t * scale index to note (sharps)\n\t * @type {Array}\n\t */\n\tvar scaleIndexToNote = [\"C\", \"C#\", \"D\", \"D#\", \"E\", \"F\", \"F#\", \"G\", \"G#\", \"A\", \"A#\", \"B\"];\n\n\t/**\n\t * The [concert pitch](https://en.wikipedia.org/wiki/Concert_pitch)\n\t * A4's values in Hertz. \n\t * @type {Frequency}\n\t * @static\n\t */\n\tTone.Frequency.A4 = 440;\n\n\t/**\n\t * Convert a MIDI note to frequency value. \n\t * @param {MIDI} midi The midi number to convert.\n\t * @return {Frequency} the corresponding frequency value\n\t * @example\n\t * tone.midiToFrequency(69); // returns 440\n\t */\n\tTone.Frequency.prototype.midiToFrequency = function(midi){\n\t\treturn Tone.Frequency.A4 * Math.pow(2, (midi - 69) / 12);\n\t};\n\n\t/**\n\t * Convert a frequency value to a MIDI note.\n\t * @param {Frequency} frequency The value to frequency value to convert.\n\t * @returns {MIDI}\n\t * @example\n\t * tone.midiToFrequency(440); // returns 69\n\t */\n\tTone.Frequency.prototype.frequencyToMidi = function(frequency){\n\t\treturn 69 + 12 * Math.log(frequency / Tone.Frequency.A4) / Math.LN2;\n\t};\n\n\treturn Tone.Frequency;\n});","define([\"Tone/core/Tone\", \"Tone/type/Time\"], function (Tone) {\n\n\t/**\n\t * @class Tone.TransportTime is a the time along the Transport's\n\t * timeline. It is similar to Tone.Time, but instead of evaluating\n\t * against the AudioContext's clock, it is evaluated against\n\t * the Transport's position. See [TransportTime wiki](https://github.com/Tonejs/Tone.js/wiki/TransportTime).\n\t * @constructor\n\t * @param {Time} val The time value as a number or string\n\t * @param {String=} units Unit values\n\t * @extends {Tone.Time}\n\t */\n\tTone.TransportTime = function(val, units){\n\t\tif (this instanceof Tone.TransportTime){\n\t\t\t\n\t\t\tTone.Time.call(this, val, units);\n\n\t\t} else {\n\t\t\treturn new Tone.TransportTime(val, units);\n\t\t}\n\t};\n\n\tTone.extend(Tone.TransportTime, Tone.Time);\n\n\t//clone the expressions so that \n\t//we can add more without modifying the original\n\tTone.TransportTime.prototype._unaryExpressions = Object.create(Tone.Time.prototype._unaryExpressions);\n\n\t/**\n\t * Adds an additional unary expression\n\t * which quantizes values to the next subdivision\n\t * @type {Object}\n\t * @private\n\t */\n\tTone.TransportTime.prototype._unaryExpressions.quantize = {\n\t\tregexp : /^@/,\n\t\tmethod : function(rh){\n\t\t\tvar subdivision = this._secondsToTicks(rh());\n\t\t\tvar multiple = Math.ceil(Tone.Transport.ticks / subdivision);\n\t\t\treturn this._ticksToUnits(multiple * subdivision);\n\t\t}\n\t};\n\n\t/**\n\t * Convert seconds into ticks\n\t * @param {Seconds} seconds\n\t * @return {Ticks}\n\t * @private\n\t */\n\tTone.TransportTime.prototype._secondsToTicks = function(seconds){\n\t\tvar quarterTime = this._beatsToUnits(1);\n\t\tvar quarters = seconds / quarterTime;\n\t\treturn Math.round(quarters * Tone.Transport.PPQ);\n\t};\n\n\t/**\n\t * Evaluate the time expression. Returns values in ticks\n\t * @return {Ticks}\n\t */\n\tTone.TransportTime.prototype.valueOf = function(){\n\t\tvar val = this._secondsToTicks(this._expr());\n\t\treturn val + (this._plusNow ? Tone.Transport.ticks : 0);\n\t};\n\n\t/**\n\t * Return the time in ticks.\n\t * @return {Ticks}\n\t */\n\tTone.TransportTime.prototype.toTicks = function(){\n\t\treturn this.valueOf();\n\t};\n\n\t/**\n\t * Return the time in seconds.\n\t * @return {Seconds}\n\t */\n\tTone.TransportTime.prototype.toSeconds = function(){\n\t\tvar val = this._expr();\n\t\treturn val + (this._plusNow ? Tone.Transport.seconds : 0);\n\t};\n\n\t/**\n\t * Return the time as a frequency value\n\t * @return {Frequency} \n\t */\n\tTone.TransportTime.prototype.toFrequency = function(){\n\t\treturn 1/this.toSeconds();\n\t};\n\n\treturn Tone.TransportTime;\n});","'use strict';\n\ndefine(function (require) {\n\n var p5sound = require('master');\n var Add = require('Tone/signal/Add');\n var Mult = require('Tone/signal/Multiply');\n var Scale = require('Tone/signal/Scale');\n var TimelineSignal = require('Tone/signal/TimelineSignal');\n\n /**\n *

Envelopes are pre-defined amplitude distribution over time.\n * Typically, envelopes are used to control the output volume\n * of an object, a series of fades referred to as Attack, Decay,\n * Sustain and Release (\n * ADSR\n * ). Envelopes can also control other Web Audio Parameters—for example, a p5.Envelope can\n * control an Oscillator's frequency like this: osc.freq(env).

\n *

Use setRange to change the attack/release level.\n * Use setADSR to change attackTime, decayTime, sustainPercent and releaseTime.

\n *

Use the play method to play the entire envelope,\n * the ramp method for a pingable trigger,\n * or triggerAttack/\n * triggerRelease to trigger noteOn/noteOff.

\n *\n * @class p5.Envelope\n * @constructor\n * @example\n *
\n * let t1 = 0.1; // attack time in seconds\n * let l1 = 0.7; // attack level 0.0 to 1.0\n * let t2 = 0.3; // decay time in seconds\n * let l2 = 0.1; // decay level 0.0 to 1.0\n *\n * let env;\n * let triOsc;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * background(220);\n * text('tap to play', 20, 20);\n * cnv.mousePressed(playSound);\n *\n * env = new p5.Envelope(t1, l1, t2, l2);\n * triOsc = new p5.Oscillator('triangle');\n * }\n *\n * function playSound() {\n * // starting the oscillator ensures that audio is enabled.\n * triOsc.start();\n * env.play(triOsc);\n * }\n *
\n */\n p5.Envelope = function(t1, l1, t2, l2, t3, l3) {\n /**\n * Time until envelope reaches attackLevel\n * @property attackTime\n */\n this.aTime = t1 || 0.1;\n /**\n * Level once attack is complete.\n * @property attackLevel\n */\n this.aLevel = l1 || 1;\n /**\n * Time until envelope reaches decayLevel.\n * @property decayTime\n */\n this.dTime = t2 || 0.5;\n /**\n * Level after decay. The envelope will sustain here until it is released.\n * @property decayLevel\n */\n this.dLevel = l2 || 0;\n /**\n * Duration of the release portion of the envelope.\n * @property releaseTime\n */\n this.rTime = t3 || 0;\n /**\n * Level at the end of the release.\n * @property releaseLevel\n */\n this.rLevel = l3 || 0;\n\n this._rampHighPercentage = 0.98;\n\n this._rampLowPercentage = 0.02;\n\n\n this.output = p5sound.audiocontext.createGain();\n\n this.control = new TimelineSignal();\n\n this._init(); // this makes sure the envelope starts at zero\n\n this.control.connect(this.output); // connect to the output\n\n this.connection = null; // store connection\n\n //array of math operation signal chaining\n this.mathOps = [this.control];\n\n //whether envelope should be linear or exponential curve\n this.isExponential = false;\n\n // oscillator or buffer source to clear on env complete\n // to save resources if/when it is retriggered\n this.sourceToClear = null;\n\n // set to true if attack is set, then false on release\n this.wasTriggered = false;\n\n\n // add to the soundArray so we can dispose of the env later\n p5sound.soundArray.push(this);\n };\n\n // this init function just smooths the starting value to zero and gives a start point for the timeline\n // - it was necessary to remove glitches at the beginning.\n p5.Envelope.prototype._init = function () {\n var now = p5sound.audiocontext.currentTime;\n var t = now;\n this.control.setTargetAtTime(0.00001, t, .001);\n //also, compute the correct time constants\n this._setRampAD(this.aTime, this.dTime);\n };\n\n /**\n * Reset the envelope with a series of time/value pairs.\n *\n * @method set\n * @for p5.Envelope\n * @param {Number} attackTime Time (in seconds) before level\n * reaches attackLevel\n * @param {Number} attackLevel Typically an amplitude between\n * 0.0 and 1.0\n * @param {Number} decayTime Time\n * @param {Number} decayLevel Amplitude (In a standard ADSR envelope,\n * decayLevel = sustainLevel)\n * @param {Number} releaseTime Release Time (in seconds)\n * @param {Number} releaseLevel Amplitude\n * @example\n *
\n * let attackTime;\n * let l1 = 0.7; // attack level 0.0 to 1.0\n * let t2 = 0.3; // decay time in seconds\n * let l2 = 0.1; // decay level 0.0 to 1.0\n * let l3 = 0.2; // release time in seconds\n *\n * let env, triOsc;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playSound);\n *\n * env = new p5.Envelope();\n * triOsc = new p5.Oscillator('triangle');\n * }\n *\n * function draw() {\n * background(220);\n * text('tap here to play', 5, 20);\n *\n * attackTime = map(mouseX, 0, width, 0.0, 1.0);\n * text('attack time: ' + attackTime, 5, height - 20);\n * }\n *\n * // mouseClick triggers envelope if over canvas\n * function playSound() {\n * env.set(attackTime, l1, t2, l2, l3);\n *\n * triOsc.start();\n * env.play(triOsc);\n * }\n *
\n *\n */\n p5.Envelope.prototype.set = function(t1, l1, t2, l2, t3, l3) {\n this.aTime = t1;\n this.aLevel = l1;\n this.dTime = t2 || 0;\n this.dLevel = l2 || 0;\n this.rTime = t3 || 0;\n this.rLevel = l3 || 0;\n\n // set time constants for ramp\n this._setRampAD(t1, t2);\n };\n\n /**\n * Set values like a traditional\n * \n * ADSR envelope\n * .\n *\n * @method setADSR\n * @for p5.Envelope\n * @param {Number} attackTime Time (in seconds before envelope\n * reaches Attack Level\n * @param {Number} [decayTime] Time (in seconds) before envelope\n * reaches Decay/Sustain Level\n * @param {Number} [susRatio] Ratio between attackLevel and releaseLevel, on a scale from 0 to 1,\n * where 1.0 = attackLevel, 0.0 = releaseLevel.\n * The susRatio determines the decayLevel and the level at which the\n * sustain portion of the envelope will sustain.\n * For example, if attackLevel is 0.4, releaseLevel is 0,\n * and susAmt is 0.5, the decayLevel would be 0.2. If attackLevel is\n * increased to 1.0 (using setRange),\n * then decayLevel would increase proportionally, to become 0.5.\n * @param {Number} [releaseTime] Time in seconds from now (defaults to 0)\n * @example\n *
\n * let attackLevel = 1.0;\n * let releaseLevel = 0;\n *\n * let attackTime = 0.001;\n * let decayTime = 0.2;\n * let susPercent = 0.2;\n * let releaseTime = 0.5;\n *\n * let env, triOsc;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playEnv);\n *\n * env = new p5.Envelope();\n * triOsc = new p5.Oscillator('triangle');\n * triOsc.amp(env);\n * triOsc.freq(220);\n * }\n *\n * function draw() {\n * background(220);\n * text('tap here to play', 5, 20);\n * attackTime = map(mouseX, 0, width, 0, 1.0);\n * text('attack time: ' + attackTime, 5, height - 40);\n * }\n *\n * function playEnv() {\n * triOsc.start();\n * env.setADSR(attackTime, decayTime, susPercent, releaseTime);\n * env.play();\n * }\n *
\n */\n p5.Envelope.prototype.setADSR = function(aTime, dTime, sPercent, rTime) {\n this.aTime = aTime;\n this.dTime = dTime || 0;\n\n // lerp\n this.sPercent = sPercent || 0;\n this.dLevel = typeof sPercent !== 'undefined' ? sPercent * (this.aLevel - this.rLevel) + this.rLevel : 0;\n\n this.rTime = rTime || 0;\n\n // also set time constants for ramp\n this._setRampAD(aTime, dTime);\n };\n\n /**\n * Set max (attackLevel) and min (releaseLevel) of envelope.\n *\n * @method setRange\n * @for p5.Envelope\n * @param {Number} aLevel attack level (defaults to 1)\n * @param {Number} rLevel release level (defaults to 0)\n * @example\n *
\n * let attackLevel = 1.0;\n * let releaseLevel = 0;\n *\n * let attackTime = 0.001;\n * let decayTime = 0.2;\n * let susPercent = 0.2;\n * let releaseTime = 0.5;\n *\n * let env, triOsc;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playEnv);\n *\n * env = new p5.Envelope();\n * triOsc = new p5.Oscillator('triangle');\n * triOsc.amp(env);\n * triOsc.freq(220);\n * }\n *\n * function draw() {\n * background(220);\n * text('tap here to play', 5, 20);\n * attackLevel = map(mouseY, height, 0, 0, 1.0);\n * text('attack level: ' + attackLevel, 5, height - 20);\n * }\n *\n * function playEnv() {\n * triOsc.start();\n * env.setRange(attackLevel, releaseLevel);\n * env.play();\n * }\n *
\n */\n p5.Envelope.prototype.setRange = function(aLevel, rLevel) {\n this.aLevel = aLevel || 1;\n this.rLevel = rLevel || 0;\n\n // not sure if this belongs here:\n\n // {Number} [dLevel] decay/sustain level (optional)\n // if (typeof(dLevel) !== 'undefined') {\n // this.dLevel = dLevel\n // } else if (this.sPercent) {\n // this.dLevel = this.sPercent ? this.sPercent * (this.aLevel - this.rLevel) + this.rLevel : 0;\n // }\n };\n\n // private (undocumented) method called when ADSR is set to set time constants for ramp\n //\n // Set the \n // time constants for simple exponential ramps.\n // The larger the time constant value, the slower the\n // transition will be.\n //\n // method _setRampAD\n // param {Number} attackTimeConstant attack time constant\n // param {Number} decayTimeConstant decay time constant\n //\n p5.Envelope.prototype._setRampAD = function(t1, t2) {\n this._rampAttackTime = this.checkExpInput(t1);\n this._rampDecayTime = this.checkExpInput(t2);\n\n var TCDenominator = 1.0;\n /// Aatish Bhatia's calculation for time constant for rise(to adjust 1/1-e calculation to any percentage)\n TCDenominator = Math.log(1.0 / this.checkExpInput(1.0 - this._rampHighPercentage));\n this._rampAttackTC = t1 / this.checkExpInput(TCDenominator);\n TCDenominator = Math.log(1.0 / this._rampLowPercentage);\n this._rampDecayTC = t2 / this.checkExpInput(TCDenominator);\n };\n\n // private method\n p5.Envelope.prototype.setRampPercentages = function(p1, p2) {\n //set the percentages that the simple exponential ramps go to\n this._rampHighPercentage = this.checkExpInput(p1);\n this._rampLowPercentage = this.checkExpInput(p2);\n var TCDenominator = 1.0;\n //now re-compute the time constants based on those percentages\n /// Aatish Bhatia's calculation for time constant for rise(to adjust 1/1-e calculation to any percentage)\n TCDenominator = Math.log(1.0 / this.checkExpInput(1.0 - this._rampHighPercentage));\n this._rampAttackTC = this._rampAttackTime / this.checkExpInput(TCDenominator);\n TCDenominator = Math.log(1.0 / this._rampLowPercentage);\n this._rampDecayTC = this._rampDecayTime / this.checkExpInput(TCDenominator);\n };\n\n\n /**\n * Assign a parameter to be controlled by this envelope.\n * If a p5.Sound object is given, then the p5.Envelope will control its\n * output gain. If multiple inputs are provided, the env will\n * control all of them.\n *\n * @method setInput\n * @for p5.Envelope\n * @param {Object} [...inputs] A p5.sound object or\n * Web Audio Param.\n */\n p5.Envelope.prototype.setInput = function() {\n for (var i = 0; iPlay tells the envelope to start acting on a given input.\n * If the input is a p5.sound object (i.e. AudioIn, Oscillator,\n * SoundFile), then Envelope will control its output volume.\n * Envelopes can also be used to control any \n * Web Audio Audio Param.

\n *\n * @method play\n * @for p5.Envelope\n * @param {Object} unit A p5.sound object or\n * Web Audio Param.\n * @param {Number} [startTime] time from now (in seconds) at which to play\n * @param {Number} [sustainTime] time to sustain before releasing the envelope\n * @example\n *
\n * let attackLevel = 1.0;\n * let releaseLevel = 0;\n *\n * let attackTime = 0.001;\n * let decayTime = 0.2;\n * let susPercent = 0.2;\n * let releaseTime = 0.5;\n *\n * let env, triOsc;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playEnv);\n *\n * env = new p5.Envelope();\n * triOsc = new p5.Oscillator('triangle');\n * triOsc.amp(env);\n * triOsc.freq(220);\n * triOsc.start();\n * }\n *\n * function draw() {\n * background(220);\n * text('tap here to play', 5, 20);\n * attackTime = map(mouseX, 0, width, 0, 1.0);\n * attackLevel = map(mouseY, height, 0, 0, 1.0);\n * text('attack time: ' + attackTime, 5, height - 40);\n * text('attack level: ' + attackLevel, 5, height - 20);\n * }\n *\n * function playEnv() {\n * // ensure that audio is enabled\n * userStartAudio();\n *\n * env.setADSR(attackTime, decayTime, susPercent, releaseTime);\n * env.setRange(attackLevel, releaseLevel);\n * env.play();\n * }\n *
\n */\n p5.Envelope.prototype.play = function(unit, secondsFromNow, susTime) {\n var tFromNow = secondsFromNow || 0;\n var susTime = susTime || 0;\n\n if (unit) {\n if (this.connection !== unit) {\n this.connect(unit);\n }\n }\n\n this.triggerAttack(unit, tFromNow);\n\n this.triggerRelease(unit, tFromNow + this.aTime + this.dTime + susTime);\n\n };\n\n /**\n * Trigger the Attack, and Decay portion of the Envelope.\n * Similar to holding down a key on a piano, but it will\n * hold the sustain level until you let go. Input can be\n * any p5.sound object, or a \n * Web Audio Param.\n *\n * @method triggerAttack\n * @for p5.Envelope\n * @param {Object} unit p5.sound Object or Web Audio Param\n * @param {Number} secondsFromNow time from now (in seconds)\n * @example\n *
\n * let attackTime = 0.001;\n * let decayTime = 0.2;\n * let susPercent = 0.3;\n * let releaseTime = 0.4;\n * let env, triOsc;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * background(220);\n * textAlign(CENTER);\n * textSize(10);\n * text('tap to triggerAttack', width/2, height/2);\n *\n * env = new p5.Envelope();\n * env.setADSR(attackTime, decayTime, susPercent, releaseTime);\n * env.setRange(1.0, 0.0);\n * triOsc = new p5.Oscillator('triangle');\n * triOsc.freq(220);\n *\n * cnv.mousePressed(envAttack);\n * }\n *\n * function envAttack() {\n * background(0, 255, 255);\n * text('release to release', width/2, height/2);\n *\n * // ensures audio is enabled. See also: `userStartAudio`\n * triOsc.start();\n *\n * env.triggerAttack(triOsc);\n * }\n *\n * function mouseReleased() {\n * background(220);\n * text('tap to triggerAttack', width/2, height/2);\n *\n * env.triggerRelease(triOsc);\n * }\n *
\n */\n p5.Envelope.prototype.triggerAttack = function(unit, secondsFromNow) {\n var now = p5sound.audiocontext.currentTime;\n var tFromNow = secondsFromNow || 0;\n var t = now + tFromNow;\n this.lastAttack = t;\n this.wasTriggered = true;\n\n if (unit) {\n if (this.connection !== unit) {\n this.connect(unit);\n }\n }\n\n // get and set value (with linear ramp) to anchor automation\n var valToSet = this.control.getValueAtTime(t);\n\n if (this.isExponential === true)\n {\n this.control.exponentialRampToValueAtTime(this.checkExpInput(valToSet), t);\n }\n else\n {\n this.control.linearRampToValueAtTime(valToSet, t);\n }\n\n // after each ramp completes, cancel scheduled values\n // (so they can be overridden in case env has been re-triggered)\n // then, set current value (with linearRamp to avoid click)\n // then, schedule the next automation...\n\n // attack\n t += this.aTime;\n if (this.isExponential === true)\n {\n this.control.exponentialRampToValueAtTime(this.checkExpInput(this.aLevel), t);\n valToSet = this.checkExpInput(this.control.getValueAtTime(t));\n this.control.cancelScheduledValues(t);\n this.control.exponentialRampToValueAtTime(valToSet, t);\n }\n else\n {\n this.control.linearRampToValueAtTime(this.aLevel, t);\n valToSet = this.control.getValueAtTime(t);\n this.control.cancelScheduledValues(t);\n this.control.linearRampToValueAtTime(valToSet, t);\n\n }\n\n // decay to decay level (if using ADSR, then decay level == sustain level)\n t += this.dTime;\n if (this.isExponential === true)\n {\n this.control.exponentialRampToValueAtTime(this.checkExpInput(this.dLevel), t);\n valToSet = this.checkExpInput(this.control.getValueAtTime(t));\n this.control.cancelScheduledValues(t);\n this.control.exponentialRampToValueAtTime(valToSet, t);\n }\n else\n {\n this.control.linearRampToValueAtTime(this.dLevel, t);\n valToSet = this.control.getValueAtTime(t);\n this.control.cancelScheduledValues(t);\n this.control.linearRampToValueAtTime(valToSet, t);\n }\n };\n\n /**\n * Trigger the Release of the Envelope. This is similar to releasing\n * the key on a piano and letting the sound fade according to the\n * release level and release time.\n *\n * @method triggerRelease\n * @for p5.Envelope\n * @param {Object} unit p5.sound Object or Web Audio Param\n * @param {Number} secondsFromNow time to trigger the release\n * @example\n *
\n * let attackTime = 0.001;\n * let decayTime = 0.2;\n * let susPercent = 0.3;\n * let releaseTime = 0.4;\n * let env, triOsc;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * background(220);\n * textAlign(CENTER);\n * textSize(10);\n * text('tap to triggerAttack', width/2, height/2);\n *\n * env = new p5.Envelope();\n * env.setADSR(attackTime, decayTime, susPercent, releaseTime);\n * env.setRange(1.0, 0.0);\n * triOsc = new p5.Oscillator('triangle');\n * triOsc.freq(220);\n *\n * cnv.mousePressed(envAttack);\n * }\n *\n * function envAttack() {\n * background(0, 255, 255);\n * text('release to release', width/2, height/2);\n *\n * // ensures audio is enabled. See also: `userStartAudio`\n * triOsc.start();\n *\n * env.triggerAttack(triOsc);\n * }\n *\n * function mouseReleased() {\n * background(220);\n * text('tap to triggerAttack', width/2, height/2);\n *\n * env.triggerRelease(triOsc);\n * }\n *
\n */\n p5.Envelope.prototype.triggerRelease = function(unit, secondsFromNow) {\n\n // only trigger a release if an attack was triggered\n if (!this.wasTriggered) {\n // this currently causes a bit of trouble:\n // if a later release has been scheduled (via the play function)\n // a new earlier release won't interrupt it, because\n // this.wasTriggered has already been set to false.\n // If we want new earlier releases to override, then we need to\n // keep track of the last release time, and if the new release time is\n // earlier, then use it.\n return;\n }\n\n var now = p5sound.audiocontext.currentTime;\n var tFromNow = secondsFromNow || 0;\n var t = now + tFromNow;\n\n if (unit) {\n if (this.connection !== unit) {\n this.connect(unit);\n }\n }\n\n // get and set value (with linear or exponential ramp) to anchor automation\n var valToSet = this.control.getValueAtTime(t);\n\n if (this.isExponential === true)\n {\n this.control.exponentialRampToValueAtTime(this.checkExpInput(valToSet), t);\n }\n else\n {\n this.control.linearRampToValueAtTime(valToSet, t);\n }\n\n // release\n t += this.rTime;\n\n if (this.isExponential === true)\n {\n this.control.exponentialRampToValueAtTime(this.checkExpInput(this.rLevel), t);\n valToSet = this.checkExpInput(this.control.getValueAtTime(t));\n this.control.cancelScheduledValues(t);\n this.control.exponentialRampToValueAtTime(valToSet, t);\n }\n else\n {\n this.control.linearRampToValueAtTime(this.rLevel, t);\n valToSet = this.control.getValueAtTime(t);\n this.control.cancelScheduledValues(t);\n this.control.linearRampToValueAtTime(valToSet, t);\n }\n\n this.wasTriggered = false;\n };\n\n /**\n * Exponentially ramp to a value using the first two\n * values from setADSR(attackTime, decayTime)\n * as \n * time constants for simple exponential ramps.\n * If the value is higher than current value, it uses attackTime,\n * while a decrease uses decayTime.\n *\n * @method ramp\n * @for p5.Envelope\n * @param {Object} unit p5.sound Object or Web Audio Param\n * @param {Number} secondsFromNow When to trigger the ramp\n * @param {Number} v Target value\n * @param {Number} [v2] Second target value (optional)\n * @example\n *
\n * let env, osc, amp;\n *\n * let attackTime = 0.001;\n * let decayTime = 0.2;\n * let attackLevel = 1;\n * let decayLevel = 0;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * fill(0,255,0);\n * noStroke();\n *\n * env = new p5.Envelope();\n * env.setADSR(attackTime, decayTime);\n * osc = new p5.Oscillator();\n * osc.amp(env);\n * amp = new p5.Amplitude();\n *\n * cnv.mousePressed(triggerRamp);\n * }\n *\n * function triggerRamp() {\n * // ensures audio is enabled. See also: `userStartAudio`\n * osc.start();\n *\n * env.ramp(osc, 0, attackLevel, decayLevel);\n * }\n *\n * function draw() {\n * background(20);\n * text('tap to play', 10, 20);\n * let h = map(amp.getLevel(), 0, 0.4, 0, height);;\n * rect(0, height, width, -h);\n * }\n *
\n */\n p5.Envelope.prototype.ramp = function(unit, secondsFromNow, v1, v2) {\n\n var now = p5sound.audiocontext.currentTime;\n var tFromNow = secondsFromNow || 0;\n var t = now + tFromNow;\n var destination1 = this.checkExpInput(v1);\n var destination2 = typeof v2 !== 'undefined' ? this.checkExpInput(v2) : undefined;\n\n // connect env to unit if not already connected\n if (unit) {\n if (this.connection !== unit) {\n this.connect(unit);\n }\n }\n\n //get current value\n var currentVal = this.checkExpInput(this.control.getValueAtTime(t));\n // this.control.cancelScheduledValues(t);\n\n //if it's going up\n if (destination1 > currentVal) {\n this.control.setTargetAtTime(destination1, t, this._rampAttackTC);\n t += this._rampAttackTime;\n }\n\n //if it's going down\n else if (destination1 < currentVal) {\n this.control.setTargetAtTime(destination1, t, this._rampDecayTC);\n t += this._rampDecayTime;\n }\n\n // Now the second part of envelope begins\n if (destination2 === undefined) return;\n\n //if it's going up\n if (destination2 > destination1) {\n this.control.setTargetAtTime(destination2, t, this._rampAttackTC);\n }\n\n //if it's going down\n else if (destination2 < destination1) {\n this.control.setTargetAtTime(destination2, t, this._rampDecayTC);\n }\n };\n\n\n p5.Envelope.prototype.connect = function(unit) {\n this.connection = unit;\n\n // assume we're talking about output gain\n // unless given a different audio param\n if (unit instanceof p5.Oscillator ||\n unit instanceof p5.SoundFile ||\n unit instanceof p5.AudioIn ||\n unit instanceof p5.Reverb ||\n unit instanceof p5.Noise ||\n unit instanceof p5.Filter ||\n unit instanceof p5.Delay\n ) {\n unit = unit.output.gain;\n }\n if (unit instanceof AudioParam) {\n //set the initial value\n unit.setValueAtTime(0, p5sound.audiocontext.currentTime);\n }\n if (unit instanceof p5.Signal) {\n unit.setValue(0);\n }\n this.output.connect(unit);\n };\n\n p5.Envelope.prototype.disconnect = function() {\n if (this.output) {\n this.output.disconnect();\n }\n };\n\n\n // Signal Math\n\n /**\n * Add a value to the p5.Oscillator's output amplitude,\n * and return the oscillator. Calling this method\n * again will override the initial add() with new values.\n *\n * @method add\n * @for p5.Envelope\n * @param {Number} number Constant number to add\n * @return {p5.Envelope} Envelope Returns this envelope\n * with scaled output\n */\n p5.Envelope.prototype.add = function(num) {\n var add = new Add(num);\n var thisChain = this.mathOps.length;\n var nextChain = this.output;\n return p5.prototype._mathChain(this, add, thisChain, nextChain, Add);\n };\n\n /**\n * Multiply the p5.Envelope's output amplitude\n * by a fixed value. Calling this method\n * again will override the initial mult() with new values.\n *\n * @method mult\n * @for p5.Envelope\n * @param {Number} number Constant number to multiply\n * @return {p5.Envelope} Envelope Returns this envelope\n * with scaled output\n */\n p5.Envelope.prototype.mult = function(num) {\n var mult = new Mult(num);\n var thisChain = this.mathOps.length;\n var nextChain = this.output;\n return p5.prototype._mathChain(this, mult, thisChain, nextChain, Mult);\n };\n\n /**\n * Scale this envelope's amplitude values to a given\n * range, and return the envelope. Calling this method\n * again will override the initial scale() with new values.\n *\n * @method scale\n * @for p5.Envelope\n * @param {Number} inMin input range minumum\n * @param {Number} inMax input range maximum\n * @param {Number} outMin input range minumum\n * @param {Number} outMax input range maximum\n * @return {p5.Envelope} Envelope Returns this envelope\n * with scaled output\n */\n p5.Envelope.prototype.scale = function(inMin, inMax, outMin, outMax) {\n var scale = new Scale(inMin, inMax, outMin, outMax);\n var thisChain = this.mathOps.length;\n var nextChain = this.output;\n return p5.prototype._mathChain(this, scale, thisChain, nextChain, Scale);\n };\n\n\n // get rid of the oscillator\n p5.Envelope.prototype.dispose = function() {\n // remove reference from soundArray\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n\n this.disconnect();\n if (this.control) {\n this.control.dispose();\n this.control = null;\n }\n for (var i = 1; i < this.mathOps.length; i++) {\n this.mathOps[i].dispose();\n }\n };\n\n // Different name for backwards compatibility, replicates p5.Envelope class\n p5.Env = function(t1, l1, t2, l2, t3, l3) {\n console.warn('WARNING: p5.Env is now deprecated and may be removed in future versions. ' +\n 'Please use the new p5.Envelope instead.');\n p5.Envelope.call(this, t1, l1, t2, l2, t3, l3);\n };\n p5.Env.prototype = Object.create(p5.Envelope.prototype);\n\n});\n","'use strict';\n\ndefine(function (require) {\n\n var p5sound = require('master');\n require('oscillator');\n\n /**\n * Creates a Pulse object, an oscillator that implements\n * Pulse Width Modulation.\n * The pulse is created with two oscillators.\n * Accepts a parameter for frequency, and to set the\n * width between the pulses. See \n * p5.Oscillator for a full list of methods.\n *\n * @class p5.Pulse\n * @extends p5.Oscillator\n * @constructor\n * @param {Number} [freq] Frequency in oscillations per second (Hz)\n * @param {Number} [w] Width between the pulses (0 to 1.0,\n * defaults to 0)\n * @example\n *
\n * let pulse;\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(startPulse);\n * background(220);\n *\n * pulse = new p5.Pulse();\n * pulse.amp(0.5);\n * pulse.freq(220);\n * }\n * function startPulse() {\n * pulse.start();\n * pulse.amp(0.5, 0.02);\n * }\n * function mouseReleased() {\n * pulse.amp(0, 0.2);\n * }\n * function draw() {\n * background(220);\n * text('tap to play', 5, 20, width - 20);\n * let w = map(mouseX, 0, width, 0, 1);\n * w = constrain(w, 0, 1);\n * pulse.width(w);\n * text('pulse width: ' + w, 5, height - 20);\n * }\n *
\n */\n p5.Pulse = function(freq, w) {\n p5.Oscillator.call(this, freq, 'sawtooth');\n\n // width of PWM, should be betw 0 to 1.0\n this.w = w || 0;\n\n // create a second oscillator with inverse frequency\n this.osc2 = new p5.SawOsc(freq);\n\n // create a delay node\n this.dNode = p5sound.audiocontext.createDelay();\n\n // dc offset\n this.dcOffset = createDCOffset();\n this.dcGain = p5sound.audiocontext.createGain();\n this.dcOffset.connect(this.dcGain);\n this.dcGain.connect(this.output);\n // set delay time based on PWM width\n this.f = freq || 440;\n var mW = this.w / this.oscillator.frequency.value;\n this.dNode.delayTime.value = mW;\n this.dcGain.gain.value = 1.7*(0.5-this.w);\n\n // disconnect osc2 and connect it to delay, which is connected to output\n this.osc2.disconnect();\n this.osc2.panner.disconnect();\n this.osc2.amp(-1); // inverted amplitude\n this.osc2.output.connect(this.dNode);\n this.dNode.connect(this.output);\n\n this.output.gain.value = 1;\n this.output.connect(this.panner);\n };\n\n p5.Pulse.prototype = Object.create(p5.Oscillator.prototype);\n\n /**\n * Set the width of a Pulse object (an oscillator that implements\n * Pulse Width Modulation).\n *\n * @method width\n * @param {Number} [width] Width between the pulses (0 to 1.0,\n * defaults to 0)\n */\n p5.Pulse.prototype.width = function(w) {\n if (typeof w === 'number') {\n if (w <= 1.0 && w >= 0.0) {\n this.w = w;\n // set delay time based on PWM width\n\n // var mW = map(this.w, 0, 1.0, 0, 1/this.f);\n var mW = this.w / this.oscillator.frequency.value;\n this.dNode.delayTime.value = mW;\n }\n\n this.dcGain.gain.value = 1.7*(0.5-this.w);\n } else {\n w.connect(this.dNode.delayTime);\n var sig = new p5.SignalAdd(-0.5);\n sig.setInput(w);\n sig = sig.mult(-1);\n sig = sig.mult(1.7);\n sig.connect(this.dcGain.gain);\n }\n };\n\n p5.Pulse.prototype.start = function(f, time) {\n var now = p5sound.audiocontext.currentTime;\n var t = time || 0;\n if (!this.started) {\n var freq = f || this.f;\n var type = this.oscillator.type;\n this.oscillator = p5sound.audiocontext.createOscillator();\n this.oscillator.frequency.setValueAtTime(freq, now);\n this.oscillator.type = type;\n this.oscillator.connect(this.output);\n this.oscillator.start(t + now);\n\n // set up osc2\n this.osc2.oscillator = p5sound.audiocontext.createOscillator();\n this.osc2.oscillator.frequency.setValueAtTime(freq, t + now);\n this.osc2.oscillator.type = type;\n this.osc2.oscillator.connect(this.osc2.output);\n this.osc2.start(t + now);\n this.freqNode = [this.oscillator.frequency, this.osc2.oscillator.frequency];\n\n // start dcOffset, too\n this.dcOffset = createDCOffset();\n this.dcOffset.connect(this.dcGain);\n this.dcOffset.start(t + now);\n\n // if LFO connections depend on these oscillators\n if (this.mods !== undefined && this.mods.frequency !== undefined) {\n this.mods.frequency.connect(this.freqNode[0]);\n this.mods.frequency.connect(this.freqNode[1]);\n }\n this.started = true;\n this.osc2.started = true;\n }\n };\n\n p5.Pulse.prototype.stop = function(time) {\n if (this.started) {\n var t = time || 0;\n var now = p5sound.audiocontext.currentTime;\n this.oscillator.stop(t + now);\n if (this.osc2.oscillator) {\n this.osc2.oscillator.stop(t + now);\n }\n this.dcOffset.stop(t + now);\n this.started = false;\n this.osc2.started = false;\n }\n };\n\n p5.Pulse.prototype.freq = function(val, rampTime, tFromNow) {\n if (typeof val === 'number') {\n this.f = val;\n var now = p5sound.audiocontext.currentTime;\n var rampTime = rampTime || 0;\n var tFromNow = tFromNow || 0;\n var currentFreq = this.oscillator.frequency.value;\n this.oscillator.frequency.cancelScheduledValues(now);\n this.oscillator.frequency.setValueAtTime(currentFreq, now + tFromNow);\n this.oscillator.frequency.exponentialRampToValueAtTime(val, tFromNow + rampTime + now);\n this.osc2.oscillator.frequency.cancelScheduledValues(now);\n this.osc2.oscillator.frequency.setValueAtTime(currentFreq, now + tFromNow);\n this.osc2.oscillator.frequency.exponentialRampToValueAtTime(val, tFromNow + rampTime + now);\n\n if (this.freqMod) {\n this.freqMod.output.disconnect();\n this.freqMod = null;\n }\n\n } else if (val.output) {\n val.output.disconnect();\n val.output.connect(this.oscillator.frequency);\n val.output.connect(this.osc2.oscillator.frequency);\n this.freqMod = val;\n }\n };\n\n // inspiration: http://webaudiodemos.appspot.com/oscilloscope/\n function createDCOffset() {\n var ac = p5sound.audiocontext;\n var buffer=ac.createBuffer(1,2048,ac.sampleRate);\n var data = buffer.getChannelData(0);\n for (var i=0; i<2048; i++)\n data[i]=1.0;\n var bufferSource=ac.createBufferSource();\n bufferSource.buffer=buffer;\n bufferSource.loop=true;\n return bufferSource;\n }\n\n});\n","'use strict';\n\ndefine(function (require) {\n var p5sound = require('master');\n\n /**\n * Noise is a type of oscillator that generates a buffer with random values.\n *\n * @class p5.Noise\n * @extends p5.Oscillator\n * @constructor\n * @param {String} type Type of noise can be 'white' (default),\n * 'brown' or 'pink'.\n */\n p5.Noise = function(type) {\n var assignType;\n p5.Oscillator.call(this);\n delete this.f;\n delete this.freq;\n delete this.oscillator;\n\n if (type === 'brown') {\n assignType = _brownNoise;\n } else if (type === 'pink') {\n assignType = _pinkNoise;\n } else {\n assignType = _whiteNoise;\n }\n this.buffer = assignType;\n };\n\n p5.Noise.prototype = Object.create(p5.Oscillator.prototype);\n\n // generate noise buffers\n var _whiteNoise = (function() {\n var bufferSize = 2 * p5sound.audiocontext.sampleRate;\n var whiteBuffer = p5sound.audiocontext.createBuffer(1, bufferSize, p5sound.audiocontext.sampleRate);\n var noiseData = whiteBuffer.getChannelData(0);\n for (var i = 0; i < bufferSize; i++) {\n noiseData[i] = Math.random() * 2 - 1;\n }\n whiteBuffer.type = 'white';\n return whiteBuffer;\n })();\n\n var _pinkNoise = (function() {\n var bufferSize = 2 * p5sound.audiocontext.sampleRate;\n var pinkBuffer = p5sound.audiocontext.createBuffer(1, bufferSize, p5sound.audiocontext.sampleRate);\n var noiseData = pinkBuffer.getChannelData(0);\n var b0, b1, b2, b3, b4, b5, b6;\n b0 = b1 = b2 = b3 = b4 = b5 = b6 = 0.0;\n for (var i = 0; i < bufferSize; i++) {\n var white = Math.random() * 2 - 1;\n b0 = 0.99886 * b0 + white * 0.0555179;\n b1 = 0.99332 * b1 + white * 0.0750759;\n b2 = 0.96900 * b2 + white * 0.1538520;\n b3 = 0.86650 * b3 + white * 0.3104856;\n b4 = 0.55000 * b4 + white * 0.5329522;\n b5 = -0.7616 * b5 - white * 0.0168980;\n noiseData[i] = b0 + b1 + b2 + b3 + b4 + b5 + b6 + white * 0.5362;\n noiseData[i] *= 0.11; // (roughly) compensate for gain\n b6 = white * 0.115926;\n }\n pinkBuffer.type = 'pink';\n return pinkBuffer;\n })();\n\n var _brownNoise = (function() {\n var bufferSize = 2 * p5sound.audiocontext.sampleRate;\n var brownBuffer = p5sound.audiocontext.createBuffer(1, bufferSize, p5sound.audiocontext.sampleRate);\n var noiseData = brownBuffer.getChannelData(0);\n var lastOut = 0.0;\n for (var i = 0; i< bufferSize; i++) {\n var white = Math.random() * 2 - 1;\n noiseData[i] = (lastOut + 0.02*white) / 1.02;\n lastOut = noiseData[i];\n noiseData[i] *= 3.5;\n }\n brownBuffer.type = 'brown';\n return brownBuffer;\n })();\n\n /**\n * Set type of noise to 'white', 'pink' or 'brown'.\n * White is the default.\n *\n * @method setType\n * @param {String} [type] 'white', 'pink' or 'brown'\n */\n p5.Noise.prototype.setType = function(type) {\n switch(type) {\n case 'white':\n this.buffer = _whiteNoise;\n break;\n case 'pink':\n this.buffer = _pinkNoise;\n break;\n case 'brown':\n this.buffer = _brownNoise;\n break;\n default:\n this.buffer = _whiteNoise;\n }\n if (this.started) {\n var now = p5sound.audiocontext.currentTime;\n this.stop(now);\n this.start(now+.01);\n }\n };\n\n p5.Noise.prototype.getType = function() {\n return this.buffer.type;\n };\n\n p5.Noise.prototype.start = function() {\n if (this.started) {\n this.stop();\n }\n this.noise = p5sound.audiocontext.createBufferSource();\n this.noise.buffer = this.buffer;\n this.noise.loop = true;\n this.noise.connect(this.output);\n var now = p5sound.audiocontext.currentTime;\n this.noise.start(now);\n this.started = true;\n };\n\n p5.Noise.prototype.stop = function() {\n var now = p5sound.audiocontext.currentTime;\n if (this.noise) {\n this.noise.stop(now);\n this.started = false;\n }\n };\n\n p5.Noise.prototype.dispose = function() {\n var now = p5sound.audiocontext.currentTime;\n\n // remove reference from soundArray\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n\n if (this.noise) {\n this.noise.disconnect();\n this.stop(now);\n }\n if (this.output) {\n this.output.disconnect();\n }\n if (this.panner) {\n this.panner.disconnect();\n }\n this.output = null;\n this.panner = null;\n this.buffer = null;\n this.noise = null;\n };\n\n});\n","'use strict';\n\ndefine(function (require) {\n var p5sound = require('master');\n\n // an array of input sources\n p5sound.inputSources = [];\n\n /**\n *

Get audio from an input, i.e. your computer's microphone.

\n *\n *

Turn the mic on/off with the start() and stop() methods. When the mic\n * is on, its volume can be measured with getLevel or by connecting an\n * FFT object.

\n *\n *

If you want to hear the AudioIn, use the .connect() method.\n * AudioIn does not connect to p5.sound output by default to prevent\n * feedback.

\n *\n *

Note: This uses the getUserMedia/\n * Stream API, which is not supported by certain browsers. Access in Chrome browser\n * is limited to localhost and https, but access over http may be limited.

\n *\n * @class p5.AudioIn\n * @constructor\n * @param {Function} [errorCallback] A function to call if there is an error\n * accessing the AudioIn. For example,\n * Safari and iOS devices do not\n * currently allow microphone access.\n * @example\n *
\n * let mic;\n *\n * function setup(){\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(userStartAudio);\n * textAlign(CENTER);\n * mic = new p5.AudioIn();\n * mic.start();\n * }\n *\n * function draw(){\n * background(0);\n * fill(255);\n * text('tap to start', width/2, 20);\n *\n * micLevel = mic.getLevel();\n * let y = height - micLevel * height;\n * ellipse(width/2, y, 10, 10);\n * }\n *
\n */\n p5.AudioIn = function(errorCallback) {\n // set up audio input\n /**\n * @property {GainNode} input\n */\n this.input = p5sound.audiocontext.createGain();\n /**\n * @property {GainNode} output\n */\n this.output = p5sound.audiocontext.createGain();\n\n /**\n * @property {MediaStream|null} stream\n */\n this.stream = null;\n /**\n * @property {MediaStreamAudioSourceNode|null} mediaStream\n */\n this.mediaStream = null;\n /**\n * @property {Number|null} currentSource\n */\n this.currentSource = null;\n\n /**\n * Client must allow browser to access their microphone / audioin source.\n * Default: false. Will become true when the client enables access.\n *\n * @property {Boolean} enabled\n */\n this.enabled = false;\n\n /**\n * Input amplitude, connect to it by default but not to master out\n *\n * @property {p5.Amplitude} amplitude\n */\n this.amplitude = new p5.Amplitude();\n this.output.connect(this.amplitude.input);\n\n if (!window.MediaStreamTrack || !window.navigator.mediaDevices || !window.navigator.mediaDevices.getUserMedia) {\n errorCallback ? errorCallback() : window.alert('This browser does not support MediaStreamTrack and mediaDevices');\n }\n\n // add to soundArray so we can dispose on close\n p5sound.soundArray.push(this);\n };\n\n /**\n * Start processing audio input. This enables the use of other\n * AudioIn methods like getLevel(). Note that by default, AudioIn\n * is not connected to p5.sound's output. So you won't hear\n * anything unless you use the connect() method.
\n *\n * Certain browsers limit access to the user's microphone. For example,\n * Chrome only allows access from localhost and over https. For this reason,\n * you may want to include an errorCallback—a function that is called in case\n * the browser won't provide mic access.\n *\n * @method start\n * @for p5.AudioIn\n * @param {Function} [successCallback] Name of a function to call on\n * success.\n * @param {Function} [errorCallback] Name of a function to call if\n * there was an error. For example,\n * some browsers do not support\n * getUserMedia.\n */\n p5.AudioIn.prototype.start = function(successCallback, errorCallback) {\n var self = this;\n\n if (this.stream) {\n this.stop();\n }\n\n // set the audio source\n var audioSource = p5sound.inputSources[self.currentSource];\n var constraints = {\n audio: {\n sampleRate: p5sound.audiocontext.sampleRate,\n echoCancellation: false\n }\n };\n\n // if developers determine which source to use\n if (p5sound.inputSources[this.currentSource]) {\n constraints.audio.deviceId = audioSource.deviceId;\n }\n\n window.navigator.mediaDevices.getUserMedia( constraints )\n .then( function(stream) {\n self.stream = stream;\n self.enabled = true;\n // Wrap a MediaStreamSourceNode around the live input\n self.mediaStream = p5sound.audiocontext.createMediaStreamSource(stream);\n self.mediaStream.connect(self.output);\n // only send to the Amplitude reader, so we can see it but not hear it.\n self.amplitude.setInput(self.output);\n if (successCallback) successCallback();\n })\n .catch( function(err) {\n if (errorCallback) errorCallback(err);\n else console.error(err);\n });\n };\n\n /**\n * Turn the AudioIn off. If the AudioIn is stopped, it cannot getLevel().\n * If re-starting, the user may be prompted for permission access.\n *\n * @method stop\n * @for p5.AudioIn\n */\n p5.AudioIn.prototype.stop = function() {\n if (this.stream) {\n this.stream.getTracks().forEach(function(track) {\n track.stop();\n });\n\n this.mediaStream.disconnect();\n\n delete this.mediaStream;\n delete this.stream;\n }\n };\n\n /**\n * Connect to an audio unit. If no parameter is provided, will\n * connect to the master output (i.e. your speakers).
\n *\n * @method connect\n * @for p5.AudioIn\n * @param {Object} [unit] An object that accepts audio input,\n * such as an FFT\n */\n p5.AudioIn.prototype.connect = function(unit) {\n if (unit) {\n if (unit.hasOwnProperty('input')) {\n this.output.connect(unit.input);\n }\n else if (unit.hasOwnProperty('analyser')) {\n this.output.connect(unit.analyser);\n }\n else {\n this.output.connect(unit);\n }\n }\n else {\n this.output.connect(p5sound.input);\n }\n };\n\n /**\n * Disconnect the AudioIn from all audio units. For example, if\n * connect() had been called, disconnect() will stop sending\n * signal to your speakers.
\n *\n * @method disconnect\n * @for p5.AudioIn\n */\n p5.AudioIn.prototype.disconnect = function() {\n if (this.output) {\n this.output.disconnect();\n // stay connected to amplitude even if not outputting to p5\n this.output.connect(this.amplitude.input);\n }\n };\n\n /**\n * Read the Amplitude (volume level) of an AudioIn. The AudioIn\n * class contains its own instance of the Amplitude class to help\n * make it easy to get a microphone's volume level. Accepts an\n * optional smoothing value (0.0 < 1.0). NOTE: AudioIn must\n * .start() before using .getLevel().
\n *\n * @method getLevel\n * @for p5.AudioIn\n * @param {Number} [smoothing] Smoothing is 0.0 by default.\n * Smooths values based on previous values.\n * @return {Number} Volume level (between 0.0 and 1.0)\n */\n p5.AudioIn.prototype.getLevel = function(smoothing) {\n if (smoothing) {\n this.amplitude.smoothing = smoothing;\n }\n return this.amplitude.getLevel();\n };\n\n /**\n * Set amplitude (volume) of a mic input between 0 and 1.0.
\n *\n * @method amp\n * @for p5.AudioIn\n * @param {Number} vol between 0 and 1.0\n * @param {Number} [time] ramp time (optional)\n */\n p5.AudioIn.prototype.amp = function(vol, t) {\n if (t) {\n var rampTime = t || 0;\n var currentVol = this.output.gain.value;\n this.output.gain.cancelScheduledValues(p5sound.audiocontext.currentTime);\n this.output.gain.setValueAtTime(currentVol, p5sound.audiocontext.currentTime);\n this.output.gain.linearRampToValueAtTime(vol, rampTime + p5sound.audiocontext.currentTime);\n } else {\n this.output.gain.cancelScheduledValues(p5sound.audiocontext.currentTime);\n this.output.gain.setValueAtTime(vol, p5sound.audiocontext.currentTime);\n }\n };\n\n /**\n * Returns a list of available input sources. This is a wrapper\n * for and it returns a Promise.\n *\n * @method getSources\n * @for p5.AudioIn\n * @param {Function} [successCallback] This callback function handles the sources when they\n * have been enumerated. The callback function\n * receives the deviceList array as its only argument\n * @param {Function} [errorCallback] This optional callback receives the error\n * message as its argument.\n * @returns {Promise} Returns a Promise that can be used in place of the callbacks, similar\n * to the enumerateDevices() method\n * @example\n *
\n * let audioIn;\n *\n * function setup(){\n * text('getting sources...', 0, 20);\n * audioIn = new p5.AudioIn();\n * audioIn.getSources(gotSources);\n * }\n *\n * function gotSources(deviceList) {\n * if (deviceList.length > 0) {\n * //set the source to the first item in the deviceList array\n * audioIn.setSource(0);\n * let currentSource = deviceList[audioIn.currentSource];\n * text('set source to: ' + currentSource.deviceId, 5, 20, width);\n * }\n * }\n *
\n */\n p5.AudioIn.prototype.getSources = function (onSuccess, onError) {\n return new Promise( function(resolve, reject) {\n window.navigator.mediaDevices.enumerateDevices()\n .then( function(devices) {\n p5sound.inputSources = devices.filter(function(device) {\n return device.kind === 'audioinput';\n });\n resolve(p5sound.inputSources);\n if (onSuccess) {\n onSuccess(p5sound.inputSources);\n }\n })\n .catch( function(error) {\n reject(error);\n if (onError) {\n onError(error);\n } else {\n console.error('This browser does not support MediaStreamTrack.getSources()');\n }\n });\n });\n };\n\n /**\n * Set the input source. Accepts a number representing a\n * position in the array returned by getSources().\n * This is only available in browsers that support\n * navigator.mediaDevices.enumerateDevices().
\n *\n * @method setSource\n * @for p5.AudioIn\n * @param {number} num position of input source in the array\n * @example\n *
\n * let audioIn;\n *\n * function setup(){\n * text('getting sources...', 0, 20);\n * audioIn = new p5.AudioIn();\n * audioIn.getSources(gotSources);\n * }\n *\n * function gotSources(deviceList) {\n * if (deviceList.length > 0) {\n * //set the source to the first item in the deviceList array\n * audioIn.setSource(0);\n * let currentSource = deviceList[audioIn.currentSource];\n * text('set source to: ' + currentSource.deviceId, 5, 20, width);\n * }\n * }\n *
\n */\n p5.AudioIn.prototype.setSource = function(num) {\n if (p5sound.inputSources.length > 0 && num < p5sound.inputSources.length) {\n // set the current source\n this.currentSource = num;\n console.log('set source to ', p5sound.inputSources[this.currentSource]);\n } else {\n console.log('unable to set input source');\n }\n\n // restart stream if currently active\n if (this.stream && this.stream.active) {\n this.start();\n }\n };\n\n // private method\n p5.AudioIn.prototype.dispose = function() {\n // remove reference from soundArray\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n\n this.stop();\n\n if (this.output) {\n this.output.disconnect();\n }\n if (this.amplitude) {\n this.amplitude.disconnect();\n }\n delete this.amplitude;\n delete this.output;\n };\n\n});\n","define([\"Tone/core/Tone\", \"Tone/signal/Signal\", \"Tone/signal/Expr\", \n\t\"Tone/signal/EqualPowerGain\", \"Tone/core/Gain\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Tone.Crossfade provides equal power fading between two inputs. \n\t * More on crossfading technique [here](https://en.wikipedia.org/wiki/Fade_(audio_engineering)#Crossfading).\n\t *\n\t * @constructor\n\t * @extends {Tone}\n\t * @param {NormalRange} [initialFade=0.5]\n\t * @example\n\t * var crossFade = new Tone.CrossFade(0.5);\n\t * //connect effect A to crossfade from\n\t * //effect output 0 to crossfade input 0\n\t * effectA.connect(crossFade, 0, 0);\n\t * //connect effect B to crossfade from\n\t * //effect output 0 to crossfade input 1\n\t * effectB.connect(crossFade, 0, 1);\n\t * crossFade.fade.value = 0;\n\t * // ^ only effectA is output\n\t * crossFade.fade.value = 1;\n\t * // ^ only effectB is output\n\t * crossFade.fade.value = 0.5;\n\t * // ^ the two signals are mixed equally. \n\t */\t\t\n\tTone.CrossFade = function(initialFade){\n\n\t\tthis.createInsOuts(2, 1);\n\n\t\t/**\n\t\t * Alias for input[0]. \n\t\t * @type {Tone.Gain}\n\t\t */\n\t\tthis.a = this.input[0] = new Tone.Gain();\n\n\t\t/**\n\t\t * Alias for input[1]. \n\t\t * @type {Tone.Gain}\n\t\t */\n\t\tthis.b = this.input[1] = new Tone.Gain();\n\n\t\t/**\n\t\t * \tThe mix between the two inputs. A fade value of 0\n\t\t * \twill output 100% input[0] and \n\t\t * \ta value of 1 will output 100% input[1]. \n\t\t * @type {NormalRange}\n\t\t * @signal\n\t\t */\n\t\tthis.fade = new Tone.Signal(this.defaultArg(initialFade, 0.5), Tone.Type.NormalRange);\n\n\t\t/**\n\t\t * equal power gain cross fade\n\t\t * @private\n\t\t * @type {Tone.EqualPowerGain}\n\t\t */\n\t\tthis._equalPowerA = new Tone.EqualPowerGain();\n\n\t\t/**\n\t\t * equal power gain cross fade\n\t\t * @private\n\t\t * @type {Tone.EqualPowerGain}\n\t\t */\n\t\tthis._equalPowerB = new Tone.EqualPowerGain();\n\t\t\n\t\t/**\n\t\t * invert the incoming signal\n\t\t * @private\n\t\t * @type {Tone}\n\t\t */\n\t\tthis._invert = new Tone.Expr(\"1 - $0\");\n\n\t\t//connections\n\t\tthis.a.connect(this.output);\n\t\tthis.b.connect(this.output);\n\t\tthis.fade.chain(this._equalPowerB, this.b.gain);\n\t\tthis.fade.chain(this._invert, this._equalPowerA, this.a.gain);\n\t\tthis._readOnly(\"fade\");\n\t};\n\n\tTone.extend(Tone.CrossFade);\n\n\t/**\n\t * clean up\n\t * @returns {Tone.CrossFade} this\n\t */\n\tTone.CrossFade.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._writable(\"fade\");\n\t\tthis._equalPowerA.dispose();\n\t\tthis._equalPowerA = null;\n\t\tthis._equalPowerB.dispose();\n\t\tthis._equalPowerB = null;\n\t\tthis.fade.dispose();\n\t\tthis.fade = null;\n\t\tthis._invert.dispose();\n\t\tthis._invert = null;\n\t\tthis.a.dispose();\n\t\tthis.a = null;\n\t\tthis.b.dispose();\n\t\tthis.b = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.CrossFade;\n});\n","define([\"Tone/core/Tone\", \"Tone/signal/Add\", \"Tone/signal/Subtract\", \"Tone/signal/Multiply\", \n\t\"Tone/signal/GreaterThan\", \"Tone/signal/GreaterThanZero\", \"Tone/signal/Abs\", \"Tone/signal/Negate\", \n\t\"Tone/signal/Modulo\", \"Tone/signal/Pow\", \"Tone/signal/AudioToGain\"], \n\tfunction(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Evaluate an expression at audio rate.

\n\t * Parsing code modified from https://code.google.com/p/tapdigit/\n\t * Copyright 2011 2012 Ariya Hidayat, New BSD License\n\t *\n\t * @extends {Tone.SignalBase}\n\t * @constructor\n\t * @param {string} expr the expression to generate\n\t * @example\n\t * //adds the signals from input[0] and input[1].\n\t * var expr = new Tone.Expr(\"$0 + $1\");\n\t */\n\tTone.Expr = function(){\n\n\t\tvar expr = this._replacements(Array.prototype.slice.call(arguments));\n\t\tvar inputCount = this._parseInputs(expr);\n\n\t\t/**\n\t\t * hold onto all of the nodes for disposal\n\t\t * @type {Array}\n\t\t * @private\n\t\t */\n\t\tthis._nodes = [];\n\n\t\t/**\n\t\t * The inputs. The length is determined by the expression. \n\t\t * @type {Array}\n\t\t */\n\t\tthis.input = new Array(inputCount);\n\n\t\t//create a gain for each input\n\t\tfor (var i = 0; i < inputCount; i++){\n\t\t\tthis.input[i] = this.context.createGain();\n\t\t}\n\n\t\t//parse the syntax tree\n\t\tvar tree = this._parseTree(expr);\n\t\t//evaluate the results\n\t\tvar result;\n\t\ttry {\n\t\t\tresult = this._eval(tree);\n\t\t} catch (e){\n\t\t\tthis._disposeNodes();\n\t\t\tthrow new Error(\"Tone.Expr: Could evaluate expression: \"+expr);\n\t\t}\n\n\t\t/**\n\t\t * The output node is the result of the expression\n\t\t * @type {Tone}\n\t\t */\n\t\tthis.output = result;\n\t};\n\n\tTone.extend(Tone.Expr, Tone.SignalBase);\n\n\t//some helpers to cut down the amount of code\n\tfunction applyBinary(Constructor, args, self){\n\t\tvar op = new Constructor();\n\t\tself._eval(args[0]).connect(op, 0, 0);\n\t\tself._eval(args[1]).connect(op, 0, 1);\n\t\treturn op;\n\t}\n\tfunction applyUnary(Constructor, args, self){\n\t\tvar op = new Constructor();\n\t\tself._eval(args[0]).connect(op, 0, 0);\n\t\treturn op;\n\t}\n\tfunction getNumber(arg){\n\t\treturn arg ? parseFloat(arg) : undefined;\n\t}\n\tfunction literalNumber(arg){\n\t\treturn arg && arg.args ? parseFloat(arg.args) : undefined;\n\t}\n\n\t/*\n\t * the Expressions that Tone.Expr can parse.\n\t *\n\t * each expression belongs to a group and contains a regexp \n\t * for selecting the operator as well as that operators method\n\t * \n\t * @type {Object}\n\t * @private\n\t */\n\tTone.Expr._Expressions = {\n\t\t//values\n\t\t\"value\" : {\n\t\t\t\"signal\" : {\n\t\t\t\tregexp : /^\\d+\\.\\d+|^\\d+/,\n\t\t\t\tmethod : function(arg){\n\t\t\t\t\tvar sig = new Tone.Signal(getNumber(arg));\n\t\t\t\t\treturn sig;\n\t\t\t\t}\n\t\t\t},\n\t\t\t\"input\" : {\n\t\t\t\tregexp : /^\\$\\d/,\n\t\t\t\tmethod : function(arg, self){\n\t\t\t\t\treturn self.input[getNumber(arg.substr(1))];\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\t//syntactic glue\n\t\t\"glue\" : {\n\t\t\t\"(\" : {\n\t\t\t\tregexp : /^\\(/,\n\t\t\t},\n\t\t\t\")\" : {\n\t\t\t\tregexp : /^\\)/,\n\t\t\t},\n\t\t\t\",\" : {\n\t\t\t\tregexp : /^,/,\n\t\t\t}\n\t\t},\n\t\t//functions\n\t\t\"func\" : {\n\t\t\t\"abs\" : {\n\t\t\t\tregexp : /^abs/,\n\t\t\t\tmethod : applyUnary.bind(this, Tone.Abs)\n\t\t\t},\n\t\t\t\"mod\" : {\n\t\t\t\tregexp : /^mod/,\n\t\t\t\tmethod : function(args, self){\n\t\t\t\t\tvar modulus = literalNumber(args[1]);\n\t\t\t\t\tvar op = new Tone.Modulo(modulus);\n\t\t\t\t\tself._eval(args[0]).connect(op);\n\t\t\t\t\treturn op;\n\t\t\t\t}\n\t\t\t},\n\t\t\t\"pow\" : {\n\t\t\t\tregexp : /^pow/,\n\t\t\t\tmethod : function(args, self){\n\t\t\t\t\tvar exp = literalNumber(args[1]);\n\t\t\t\t\tvar op = new Tone.Pow(exp);\n\t\t\t\t\tself._eval(args[0]).connect(op);\n\t\t\t\t\treturn op;\n\t\t\t\t}\n\t\t\t},\n\t\t\t\"a2g\" : {\n\t\t\t\tregexp : /^a2g/,\n\t\t\t\tmethod : function(args, self){\n\t\t\t\t\tvar op = new Tone.AudioToGain();\n\t\t\t\t\tself._eval(args[0]).connect(op);\n\t\t\t\t\treturn op;\n\t\t\t\t}\n\t\t\t},\n\t\t},\n\t\t//binary expressions\n\t\t\"binary\" : {\n\t\t\t\"+\" : {\n\t\t\t\tregexp : /^\\+/,\n\t\t\t\tprecedence : 1,\n\t\t\t\tmethod : applyBinary.bind(this, Tone.Add)\n\t\t\t},\n\t\t\t\"-\" : {\n\t\t\t\tregexp : /^\\-/,\n\t\t\t\tprecedence : 1,\n\t\t\t\tmethod : function(args, self){\n\t\t\t\t\t//both unary and binary op\n\t\t\t\t\tif (args.length === 1){\n\t\t\t\t\t\treturn applyUnary(Tone.Negate, args, self);\n\t\t\t\t\t} else {\n\t\t\t\t\t\treturn applyBinary(Tone.Subtract, args, self);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t},\n\t\t\t\"*\" : {\n\t\t\t\tregexp : /^\\*/,\n\t\t\t\tprecedence : 0,\n\t\t\t\tmethod : applyBinary.bind(this, Tone.Multiply)\n\t\t\t}\n\t\t},\n\t\t//unary expressions\n\t\t\"unary\" : {\n\t\t\t\"-\" : {\n\t\t\t\tregexp : /^\\-/,\n\t\t\t\tmethod : applyUnary.bind(this, Tone.Negate)\n\t\t\t},\n\t\t\t\"!\" : {\n\t\t\t\tregexp : /^\\!/,\n\t\t\t\tmethod : applyUnary.bind(this, Tone.NOT)\n\t\t\t},\n\t\t},\n\t};\n\t\t\n\t/**\n\t * @param {string} expr the expression string\n\t * @return {number} the input count\n\t * @private\n\t */\n\tTone.Expr.prototype._parseInputs = function(expr){\n\t\tvar inputArray = expr.match(/\\$\\d/g);\n\t\tvar inputMax = 0;\n\t\tif (inputArray !== null){\n\t\t\tfor (var i = 0; i < inputArray.length; i++){\n\t\t\t\tvar inputNum = parseInt(inputArray[i].substr(1)) + 1;\n\t\t\t\tinputMax = Math.max(inputMax, inputNum);\n\t\t\t}\n\t\t}\n\t\treturn inputMax;\n\t};\n\n\t/**\n\t * @param {Array} args \tan array of arguments\n\t * @return {string} the results of the replacements being replaced\n\t * @private\n\t */\n\tTone.Expr.prototype._replacements = function(args){\n\t\tvar expr = args.shift();\n\t\tfor (var i = 0; i < args.length; i++){\n\t\t\texpr = expr.replace(/\\%/i, args[i]);\n\t\t}\n\t\treturn expr;\n\t};\n\n\t/**\n\t * tokenize the expression based on the Expressions object\n\t * @param {string} expr \n\t * @return {Object} returns two methods on the tokenized list, next and peek\n\t * @private\n\t */\n\tTone.Expr.prototype._tokenize = function(expr){\n\t\tvar position = -1;\n\t\tvar tokens = [];\n\n\t\twhile(expr.length > 0){\n\t\t\texpr = expr.trim();\n\t\t\tvar token = getNextToken(expr);\n\t\t\ttokens.push(token);\n\t\t\texpr = expr.substr(token.value.length);\n\t\t}\n\n\t\tfunction getNextToken(expr){\n\t\t\tfor (var type in Tone.Expr._Expressions){\n\t\t\t\tvar group = Tone.Expr._Expressions[type];\n\t\t\t\tfor (var opName in group){\n\t\t\t\t\tvar op = group[opName];\n\t\t\t\t\tvar reg = op.regexp;\n\t\t\t\t\tvar match = expr.match(reg);\n\t\t\t\t\tif (match !== null){\n\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\ttype : type,\n\t\t\t\t\t\t\tvalue : match[0],\n\t\t\t\t\t\t\tmethod : op.method\n\t\t\t\t\t\t};\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tthrow new SyntaxError(\"Tone.Expr: Unexpected token \"+expr);\n\t\t}\n\n\t\treturn {\n\t\t\tnext : function(){\n\t\t\t\treturn tokens[++position];\n\t\t\t},\n\t\t\tpeek : function(){\n\t\t\t\treturn tokens[position + 1];\n\t\t\t}\n\t\t};\n\t};\n\n\t/**\n\t * recursively parse the string expression into a syntax tree\n\t * \n\t * @param {string} expr \n\t * @return {Object}\n\t * @private\n\t */\n\tTone.Expr.prototype._parseTree = function(expr){\n\t\tvar lexer = this._tokenize(expr);\n\t\tvar isUndef = this.isUndef.bind(this);\n\n\t\tfunction matchSyntax(token, syn) {\n\t\t\treturn !isUndef(token) && \n\t\t\t\ttoken.type === \"glue\" &&\n\t\t\t\ttoken.value === syn;\n\t\t}\n\n\t\tfunction matchGroup(token, groupName, prec) {\n\t\t\tvar ret = false;\n\t\t\tvar group = Tone.Expr._Expressions[groupName];\n\t\t\tif (!isUndef(token)){\n\t\t\t\tfor (var opName in group){\n\t\t\t\t\tvar op = group[opName];\n\t\t\t\t\tif (op.regexp.test(token.value)){\n\t\t\t\t\t\tif (!isUndef(prec)){\n\t\t\t\t\t\t\tif(op.precedence === prec){\t\n\t\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn ret;\n\t\t}\n\n\t\tfunction parseExpression(precedence) {\n\t\t\tif (isUndef(precedence)){\n\t\t\t\tprecedence = 5;\n\t\t\t}\n\t\t\tvar expr;\n\t\t\tif (precedence < 0){\n\t\t\t\texpr = parseUnary();\n\t\t\t} else {\n\t\t\t\texpr = parseExpression(precedence-1);\n\t\t\t}\n\t\t\tvar token = lexer.peek();\n\t\t\twhile (matchGroup(token, \"binary\", precedence)) {\n\t\t\t\ttoken = lexer.next();\n\t\t\t\texpr = {\n\t\t\t\t\toperator: token.value,\n\t\t\t\t\tmethod : token.method,\n\t\t\t\t\targs : [\n\t\t\t\t\t\texpr,\n\t\t\t\t\t\tparseExpression(precedence-1)\n\t\t\t\t\t]\n\t\t\t\t};\n\t\t\t\ttoken = lexer.peek();\n\t\t\t}\n\t\t\treturn expr;\n\t\t}\n\n\t\tfunction parseUnary() {\n\t\t\tvar token, expr;\n\t\t\ttoken = lexer.peek();\n\t\t\tif (matchGroup(token, \"unary\")) {\n\t\t\t\ttoken = lexer.next();\n\t\t\t\texpr = parseUnary();\n\t\t\t\treturn {\n\t\t\t\t\toperator: token.value,\n\t\t\t\t\tmethod : token.method,\n\t\t\t\t\targs : [expr]\n\t\t\t\t};\n\t\t\t}\n\t\t\treturn parsePrimary();\n\t\t}\n\n\t\tfunction parsePrimary() {\n\t\t\tvar token, expr;\n\t\t\ttoken = lexer.peek();\n\t\t\tif (isUndef(token)) {\n\t\t\t\tthrow new SyntaxError(\"Tone.Expr: Unexpected termination of expression\");\n\t\t\t}\n\t\t\tif (token.type === \"func\") {\n\t\t\t\ttoken = lexer.next();\n\t\t\t\treturn parseFunctionCall(token);\n\t\t\t}\n\t\t\tif (token.type === \"value\") {\n\t\t\t\ttoken = lexer.next();\n\t\t\t\treturn {\n\t\t\t\t\tmethod : token.method,\n\t\t\t\t\targs : token.value\n\t\t\t\t};\n\t\t\t}\n\t\t\tif (matchSyntax(token, \"(\")) {\n\t\t\t\tlexer.next();\n\t\t\t\texpr = parseExpression();\n\t\t\t\ttoken = lexer.next();\n\t\t\t\tif (!matchSyntax(token, \")\")) {\n\t\t\t\t\tthrow new SyntaxError(\"Expected )\");\n\t\t\t\t}\n\t\t\t\treturn expr;\n\t\t\t}\n\t\t\tthrow new SyntaxError(\"Tone.Expr: Parse error, cannot process token \" + token.value);\n\t\t}\n\n\t\tfunction parseFunctionCall(func) {\n\t\t\tvar token, args = [];\n\t\t\ttoken = lexer.next();\n\t\t\tif (!matchSyntax(token, \"(\")) {\n\t\t\t\tthrow new SyntaxError(\"Tone.Expr: Expected ( in a function call \\\"\" + func.value + \"\\\"\");\n\t\t\t}\n\t\t\ttoken = lexer.peek();\n\t\t\tif (!matchSyntax(token, \")\")) {\n\t\t\t\targs = parseArgumentList();\n\t\t\t}\n\t\t\ttoken = lexer.next();\n\t\t\tif (!matchSyntax(token, \")\")) {\n\t\t\t\tthrow new SyntaxError(\"Tone.Expr: Expected ) in a function call \\\"\" + func.value + \"\\\"\");\n\t\t\t}\n\t\t\treturn {\n\t\t\t\tmethod : func.method,\n\t\t\t\targs : args,\n\t\t\t\tname : name\n\t\t\t};\n\t\t}\n\n\t\tfunction parseArgumentList() {\n\t\t\tvar token, expr, args = [];\n\t\t\twhile (true) {\n\t\t\t\texpr = parseExpression();\n\t\t\t\tif (isUndef(expr)) {\n\t\t\t\t\t// TODO maybe throw exception?\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\targs.push(expr);\n\t\t\t\ttoken = lexer.peek();\n\t\t\t\tif (!matchSyntax(token, \",\")) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\tlexer.next();\n\t\t\t}\n\t\t\treturn args;\n\t\t}\n\n\t\treturn parseExpression();\n\t};\n\n\t/**\n\t * recursively evaluate the expression tree\n\t * @param {Object} tree \n\t * @return {AudioNode} the resulting audio node from the expression\n\t * @private\n\t */\n\tTone.Expr.prototype._eval = function(tree){\n\t\tif (!this.isUndef(tree)){\n\t\t\tvar node = tree.method(tree.args, this);\n\t\t\tthis._nodes.push(node);\n\t\t\treturn node;\n\t\t} \n\t};\n\n\t/**\n\t * dispose all the nodes\n\t * @private\n\t */\n\tTone.Expr.prototype._disposeNodes = function(){\n\t\tfor (var i = 0; i < this._nodes.length; i++){\n\t\t\tvar node = this._nodes[i];\n\t\t\tif (this.isFunction(node.dispose)) {\n\t\t\t\tnode.dispose();\n\t\t\t} else if (this.isFunction(node.disconnect)) {\n\t\t\t\tnode.disconnect();\n\t\t\t}\n\t\t\tnode = null;\n\t\t\tthis._nodes[i] = null;\n\t\t}\n\t\tthis._nodes = null;\n\t};\n\n\t/**\n\t * clean up\n\t */\n\tTone.Expr.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._disposeNodes();\n\t};\n\n\treturn Tone.Expr;\n});","define([\"Tone/core/Tone\", \"Tone/signal/GreaterThanZero\", \"Tone/signal/Subtract\", \"Tone/signal/Signal\"], \n\tfunction(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Output 1 if the signal is greater than the value, otherwise outputs 0.\n\t * can compare two signals or a signal and a number. \n\t * \n\t * @constructor\n\t * @extends {Tone.Signal}\n\t * @param {number} [value=0] the value to compare to the incoming signal\n\t * @example\n\t * var gt = new Tone.GreaterThan(2);\n\t * var sig = new Tone.Signal(4).connect(gt);\n\t * //output of gt is equal 1. \n\t */\n\tTone.GreaterThan = function(value){\n\n\t\tthis.createInsOuts(2, 0);\n\t\t\n\t\t/**\n\t\t * subtract the amount from the incoming signal\n\t\t * @type {Tone.Subtract}\n\t\t * @private\n\t\t */\n\t\tthis._param = this.input[0] = new Tone.Subtract(value);\n\t\tthis.input[1] = this._param.input[1];\n\n\t\t/**\n\t\t * compare that amount to zero\n\t\t * @type {Tone.GreaterThanZero}\n\t\t * @private\n\t\t */\n\t\tthis._gtz = this.output = new Tone.GreaterThanZero();\n\n\t\t//connect\n\t\tthis._param.connect(this._gtz);\n\t};\n\n\tTone.extend(Tone.GreaterThan, Tone.Signal);\n\n\t/**\n\t * dispose method\n\t * @returns {Tone.GreaterThan} this\n\t */\n\tTone.GreaterThan.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._param.dispose();\n\t\tthis._param = null;\n\t\tthis._gtz.dispose();\n\t\tthis._gtz = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.GreaterThan;\n});","define([\"Tone/core/Tone\", \"Tone/signal/WaveShaper\", \"Tone/signal/SignalBase\"], \nfunction(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Return the absolute value of an incoming signal. \n\t * \n\t * @constructor\n\t * @extends {Tone.SignalBase}\n\t * @example\n\t * var signal = new Tone.Signal(-1);\n\t * var abs = new Tone.Abs();\n\t * signal.connect(abs);\n\t * //the output of abs is 1. \n\t */\n\tTone.Abs = function(){\n\t\t/**\n\t\t * @type {Tone.LessThan}\n\t\t * @private\n\t\t */\n\t\tthis._abs = this.input = this.output = new Tone.WaveShaper(function(val){\n\t\t\tif (val === 0){\n\t\t\t\treturn 0;\n\t\t\t} else {\n\t\t\t\treturn Math.abs(val);\n\t\t\t}\n\t\t}, 127);\n\t};\n\n\tTone.extend(Tone.Abs, Tone.SignalBase);\n\n\t/**\n\t * dispose method\n\t * @returns {Tone.Abs} this\n\t */\n\tTone.Abs.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._abs.dispose();\n\t\tthis._abs = null;\n\t\treturn this;\n\t}; \n\n\treturn Tone.Abs;\n});","define([\"Tone/core/Tone\", \"Tone/signal/WaveShaper\", \"Tone/signal/Multiply\", \"Tone/signal/Subtract\"], \nfunction(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Signal-rate modulo operator. Only works in AudioRange [-1, 1] and for modulus\n\t * values in the NormalRange. \n\t *\n\t * @constructor\n\t * @extends {Tone.SignalBase}\n\t * @param {NormalRange} modulus The modulus to apply.\n\t * @example\n\t * var mod = new Tone.Modulo(0.2)\n\t * var sig = new Tone.Signal(0.5).connect(mod);\n\t * //mod outputs 0.1\n\t */\n\tTone.Modulo = function(modulus){\n\n\t\tthis.createInsOuts(1, 0);\n\n\t\t/**\n\t\t * A waveshaper gets the integer multiple of \n\t\t * the input signal and the modulus.\n\t\t * @private\n\t\t * @type {Tone.WaveShaper}\n\t\t */\n\t\tthis._shaper = new Tone.WaveShaper(Math.pow(2, 16));\n\n\t\t/**\n\t\t * the integer multiple is multiplied by the modulus\n\t\t * @type {Tone.Multiply}\n\t\t * @private\n\t\t */\n\t\tthis._multiply = new Tone.Multiply();\n\n\t\t/**\n\t\t * and subtracted from the input signal\n\t\t * @type {Tone.Subtract}\n\t\t * @private\n\t\t */\n\t\tthis._subtract = this.output = new Tone.Subtract();\n\n\t\t/**\n\t\t * the modulus signal\n\t\t * @type {Tone.Signal}\n\t\t * @private\n\t\t */\n\t\tthis._modSignal = new Tone.Signal(modulus);\n\n\t\t//connections\n\t\tthis.input.fan(this._shaper, this._subtract);\n\t\tthis._modSignal.connect(this._multiply, 0, 0);\n\t\tthis._shaper.connect(this._multiply, 0, 1);\n\t\tthis._multiply.connect(this._subtract, 0, 1);\n\t\tthis._setWaveShaper(modulus);\n\t};\n\n\tTone.extend(Tone.Modulo, Tone.SignalBase);\n\n\t/**\n\t * @param {number} mod the modulus to apply\n\t * @private\n\t */\n\tTone.Modulo.prototype._setWaveShaper = function(mod){\n\t\tthis._shaper.setMap(function(val){\n\t\t\tvar multiple = Math.floor((val + 0.0001) / mod);\n\t\t\treturn multiple;\n\t\t});\n\t};\n\n\t/**\n\t * The modulus value.\n\t * @memberOf Tone.Modulo#\n\t * @type {NormalRange}\n\t * @name value\n\t */\n\tObject.defineProperty(Tone.Modulo.prototype, \"value\", {\n\t\tget : function(){\n\t\t\treturn this._modSignal.value;\n\t\t},\n\t\tset : function(mod){\n\t\t\tthis._modSignal.value = mod;\n\t\t\tthis._setWaveShaper(mod);\n\t\t}\n\t});\n\n\t/**\n\t * clean up\n\t * @returns {Tone.Modulo} this\n\t */\n\tTone.Modulo.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._shaper.dispose();\n\t\tthis._shaper = null;\n\t\tthis._multiply.dispose();\n\t\tthis._multiply = null;\n\t\tthis._subtract.dispose();\n\t\tthis._subtract = null;\n\t\tthis._modSignal.dispose();\n\t\tthis._modSignal = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.Modulo;\n});","define([\"Tone/core/Tone\", \"Tone/signal/WaveShaper\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Pow applies an exponent to the incoming signal. The incoming signal\n\t * must be AudioRange.\n\t *\n\t * @extends {Tone.SignalBase}\n\t * @constructor\n\t * @param {Positive} exp The exponent to apply to the incoming signal, must be at least 2. \n\t * @example\n\t * var pow = new Tone.Pow(2);\n\t * var sig = new Tone.Signal(0.5).connect(pow);\n\t * //output of pow is 0.25. \n\t */\n\tTone.Pow = function(exp){\n\n\t\t/**\n\t\t * the exponent\n\t\t * @private\n\t\t * @type {number}\n\t\t */\n\t\tthis._exp = this.defaultArg(exp, 1);\n\n\t\t/**\n\t\t * @type {WaveShaperNode}\n\t\t * @private\n\t\t */\n\t\tthis._expScaler = this.input = this.output = new Tone.WaveShaper(this._expFunc(this._exp), 8192);\n\t};\n\n\tTone.extend(Tone.Pow, Tone.SignalBase);\n\n\t/**\n\t * The value of the exponent.\n\t * @memberOf Tone.Pow#\n\t * @type {number}\n\t * @name value\n\t */\n\tObject.defineProperty(Tone.Pow.prototype, \"value\", {\n\t\tget : function(){\n\t\t\treturn this._exp;\n\t\t},\n\t\tset : function(exp){\n\t\t\tthis._exp = exp;\n\t\t\tthis._expScaler.setMap(this._expFunc(this._exp));\n\t\t}\n\t});\n\n\n\t/**\n\t * the function which maps the waveshaper\n\t * @param {number} exp\n\t * @return {function}\n\t * @private\n\t */\n\tTone.Pow.prototype._expFunc = function(exp){\n\t\treturn function(val){\n\t\t\treturn Math.pow(Math.abs(val), exp);\n\t\t};\n\t};\n\n\t/**\n\t * Clean up.\n\t * @returns {Tone.Pow} this\n\t */\n\tTone.Pow.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._expScaler.dispose();\n\t\tthis._expScaler = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.Pow;\n});","define([\"Tone/core/Tone\", \"Tone/signal/WaveShaper\", \"Tone/signal/Signal\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class AudioToGain converts an input in AudioRange [-1,1] to NormalRange [0,1]. \n\t * See Tone.GainToAudio.\n\t *\n\t * @extends {Tone.SignalBase}\n\t * @constructor\n\t * @example\n\t * var a2g = new Tone.AudioToGain();\n\t */\n\tTone.AudioToGain = function(){\n\n\t\t/**\n\t\t * @type {WaveShaperNode}\n\t\t * @private\n\t\t */\n\t\tthis._norm = this.input = this.output = new Tone.WaveShaper(function(x){\n\t\t\treturn (x + 1) / 2;\n\t\t});\n\t};\n\n\tTone.extend(Tone.AudioToGain, Tone.SignalBase);\n\n\t/**\n\t * clean up\n\t * @returns {Tone.AudioToGain} this\n\t */\n\tTone.AudioToGain.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._norm.dispose();\n\t\tthis._norm = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.AudioToGain;\n});","define([\"Tone/core/Tone\", \"Tone/signal/WaveShaper\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Convert an incoming signal between 0, 1 to an equal power gain scale.\n\t *\n\t * @extends {Tone.SignalBase}\n\t * @constructor\n\t * @example\n\t * var eqPowGain = new Tone.EqualPowerGain();\n\t */\n\tTone.EqualPowerGain = function(){\n\n\t\t/**\n\t\t * @type {Tone.WaveShaper}\n\t\t * @private\n\t\t */\n\t\tthis._eqPower = this.input = this.output = new Tone.WaveShaper(function(val){\n\t\t\tif (Math.abs(val) < 0.001){\n\t\t\t\t//should output 0 when input is 0\n\t\t\t\treturn 0;\n\t\t\t} else {\n\t\t\t\treturn this.equalPowerScale(val);\n\t\t\t}\n\t\t}.bind(this), 4096);\n\t};\n\n\tTone.extend(Tone.EqualPowerGain, Tone.SignalBase);\n\n\t/**\n\t * clean up\n\t * @returns {Tone.EqualPowerGain} this\n\t */\n\tTone.EqualPowerGain.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._eqPower.dispose();\n\t\tthis._eqPower = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.EqualPowerGain;\n});","'use strict';\n\ndefine(function (require) {\n\n var Effect = require('effect');\n var EQFilter = require('eqFilter');\n\n /**\n * p5.EQ is an audio effect that performs the function of a multiband\n * audio equalizer. Equalization is used to adjust the balance of\n * frequency compoenents of an audio signal. This process is commonly used\n * in sound production and recording to change the waveform before it reaches\n * a sound output device. EQ can also be used as an audio effect to create\n * interesting distortions by filtering out parts of the spectrum. p5.EQ is\n * built using a chain of Web Audio Biquad Filter Nodes and can be\n * instantiated with 3 or 8 bands. Bands can be added or removed from\n * the EQ by directly modifying p5.EQ.bands (the array that stores filters).\n *\n * This class extends p5.Effect.\n * Methods amp(), chain(),\n * drywet(), connect(), and\n * disconnect() are available.\n *\n * @class p5.EQ\n * @constructor\n * @extends p5.Effect\n * @param {Number} [_eqsize] Constructor will accept 3 or 8, defaults to 3\n * @return {Object} p5.EQ object\n *\n * @example\n *
\n * let eq, soundFile\n * let eqBandIndex = 0;\n * let eqBandNames = ['lows', 'mids', 'highs'];\n *\n * function preload() {\n * soundFormats('mp3', 'ogg');\n * soundFile = loadSound('assets/beat');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(toggleSound);\n *\n * eq = new p5.EQ(eqBandNames.length);\n * soundFile.disconnect();\n * eq.process(soundFile);\n * }\n *\n * function draw() {\n * background(30);\n * noStroke();\n * fill(255);\n * textAlign(CENTER);\n * text('filtering ', 50, 25);\n *\n * fill(255, 40, 255);\n * textSize(26);\n * text(eqBandNames[eqBandIndex], 50, 55);\n *\n * fill(255);\n * textSize(9);\n *\n * if (!soundFile.isPlaying()) {\n * text('tap to play', 50, 80);\n * } else {\n * text('tap to filter next band', 50, 80)\n * }\n * }\n *\n * function toggleSound() {\n * if (!soundFile.isPlaying()) {\n * soundFile.play();\n * } else {\n * eqBandIndex = (eqBandIndex + 1) % eq.bands.length;\n * }\n *\n * for (let i = 0; i < eq.bands.length; i++) {\n * eq.bands[i].gain(0);\n * }\n * // filter the band we want to filter\n * eq.bands[eqBandIndex].gain(-40);\n * }\n *
\n */\n p5.EQ = function(_eqsize) {\n Effect.call(this);\n\n //p5.EQ can be of size (3) or (8), defaults to 3\n _eqsize = _eqsize === 3 || _eqsize === 8 ? _eqsize : 3;\n\n var factor;\n _eqsize === 3 ? factor = Math.pow(2,3) : factor = 2;\n\n /**\n * The p5.EQ is built with abstracted p5.Filter objects.\n * To modify any bands, use methods of the \n * p5.Filter API, especially `gain` and `freq`.\n * Bands are stored in an array, with indices 0 - 3, or 0 - 7\n * @property {Array} bands\n *\n */\n this.bands = [];\n\n\n var freq, res;\n for (var i = 0; i < _eqsize; i++) {\n if (i === _eqsize - 1) {\n freq = 21000;\n res = .01;\n } else if (i === 0) {\n freq = 100;\n res = .1;\n }\n else if (i===1) {\n freq = _eqsize === 3 ? 360 * factor : 360;\n res = 1;\n }else {\n freq = this.bands[i-1].freq() * factor;\n res = 1;\n }\n this.bands[i] = this._newBand(freq, res);\n\n if (i>0) {\n this.bands[i-1].connect(this.bands[i].biquad);\n } else {\n this.input.connect(this.bands[i].biquad);\n }\n }\n this.bands[_eqsize-1].connect(this.output);\n };\n p5.EQ.prototype = Object.create(Effect.prototype);\n\n /**\n * Process an input by connecting it to the EQ\n * @method process\n * @param {Object} src Audio source\n */\n p5.EQ.prototype.process = function (src) {\n src.connect(this.input);\n };\n\n // /**\n // * Set the frequency and gain of each band in the EQ. This method should be\n // * called with 3 or 8 frequency and gain pairs, depending on the size of the EQ.\n // * ex. eq.set(freq0, gain0, freq1, gain1, freq2, gain2);\n // *\n // * @method set\n // * @for p5.EQ\n // * @param {Number} [freq0] Frequency value for band with index 0\n // * @param {Number} [gain0] Gain value for band with index 0\n // * @param {Number} [freq1] Frequency value for band with index 1\n // * @param {Number} [gain1] Gain value for band with index 1\n // * @param {Number} [freq2] Frequency value for band with index 2\n // * @param {Number} [gain2] Gain value for band with index 2\n // * @param {Number} [freq3] Frequency value for band with index 3\n // * @param {Number} [gain3] Gain value for band with index 3\n // * @param {Number} [freq4] Frequency value for band with index 4\n // * @param {Number} [gain4] Gain value for band with index 4\n // * @param {Number} [freq5] Frequency value for band with index 5\n // * @param {Number} [gain5] Gain value for band with index 5\n // * @param {Number} [freq6] Frequency value for band with index 6\n // * @param {Number} [gain6] Gain value for band with index 6\n // * @param {Number} [freq7] Frequency value for band with index 7\n // * @param {Number} [gain7] Gain value for band with index 7\n // */\n p5.EQ.prototype.set = function() {\n if (arguments.length === this.bands.length * 2) {\n for (var i = 0; i < arguments.length; i+=2) {\n this.bands[i/2].freq(arguments[i]);\n this.bands[i/2].gain(arguments[i+1]);\n }\n }\n else {\n console.error('Argument mismatch. .set() should be called with ' + this.bands.length*2 +\n ' arguments. (one frequency and gain value pair for each band of the eq)');\n }\n };\n\n /**\n * Add a new band. Creates a p5.Filter and strips away everything but\n * the raw biquad filter. This method returns an abstracted p5.Filter,\n * which can be added to p5.EQ.bands, in order to create new EQ bands.\n * @private\n * @for p5.EQ\n * @method _newBand\n * @param {Number} freq\n * @param {Number} res\n * @return {Object} Abstracted Filter\n */\n p5.EQ.prototype._newBand = function(freq, res) {\n return new EQFilter(freq, res);\n };\n\n p5.EQ.prototype.dispose = function () {\n Effect.prototype.dispose.apply(this);\n\n if (this.bands) {\n while (this.bands.length > 0) {\n delete this.bands.pop().dispose();\n }\n delete this.bands;\n }\n };\n\n return p5.EQ;\n});\n","'use strict';\n\ndefine(function (require) {\n var Filter = require('filter');\n var p5sound = require('master');\n\n /**\n * EQFilter extends p5.Filter with constraints\n * necessary for the p5.EQ\n *\n * @private\n */\n var EQFilter = function(freq, res) {\n Filter.call(this, 'peaking');\n this.disconnect();\n this.set(freq, res);\n this.biquad.gain.value = 0;\n delete this.input;\n delete this.output;\n delete this._drywet;\n delete this.wet;\n\n };\n EQFilter.prototype = Object.create(Filter.prototype);\n\n EQFilter.prototype.amp = function() {\n console.warn('`amp()` is not available for p5.EQ bands. Use `.gain()`');\n };\n EQFilter.prototype.drywet = function() {\n console.warn('`drywet()` is not available for p5.EQ bands.');\n };\n EQFilter.prototype.connect = function(unit) {\n var u = unit || p5.soundOut.input;\n if (this.biquad) {\n this.biquad.connect(u.input ? u.input : u);\n } else {\n this.output.connect(u.input ? u.input : u);\n }\n };\n\n EQFilter.prototype.disconnect = function() {\n if (this.biquad) {\n this.biquad.disconnect();\n }\n };\n EQFilter.prototype.dispose = function() {\n // remove reference form soundArray\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n this.disconnect();\n delete this.biquad;\n };\n\n return EQFilter;\n});\n","'use strict'\n\ndefine(function (require) {\n var p5sound = require('master');\n var Effect = require('effect');\n\n /**\n * Panner3D is based on the \n * Web Audio Spatial Panner Node.\n * This panner is a spatial processing node that allows audio to be positioned\n * and oriented in 3D space.\n *\n * The position is relative to an \n * Audio Context Listener, which can be accessed\n * by p5.soundOut.audiocontext.listener\n *\n *\n * @class p5.Panner3D\n * @constructor\n */\n\tp5.Panner3D = function() {\n Effect.call(this);\n\n /**\n * \n * Web Audio Spatial Panner Node\n *\n * Properties include\n * - panningModel: \"equal power\" or \"HRTF\"\n * - distanceModel: \"linear\", \"inverse\", or \"exponential\"\n *\n * @property {AudioNode} panner\n *\n */\n this.panner = this.ac.createPanner();\n this.panner.panningModel = 'HRTF';\n this.panner.distanceModel = 'linear';\n this.panner.connect(this.output);\n this.input.connect(this.panner);\n\t};\n\n p5.Panner3D.prototype = Object.create(Effect.prototype);\n\n\n /**\n * Connect an audio sorce\n *\n * @method process\n * @for p5.Panner3D\n * @param {Object} src Input source\n */\n p5.Panner3D.prototype.process = function(src) {\n src.connect(this.input);\n }\n /**\n * Set the X,Y,Z position of the Panner\n * @method set\n * @for p5.Panner3D\n * @param {Number} xVal\n * @param {Number} yVal\n * @param {Number} zVal\n * @param {Number} time\n * @return {Array} Updated x, y, z values as an array\n */\n p5.Panner3D.prototype.set = function(xVal, yVal, zVal, time) {\n this.positionX(xVal,time);\n this.positionY(yVal,time);\n this.positionZ(zVal,time);\n return [this.panner.positionX.value,\n this.panner.positionY.value,\n this.panner.positionZ.value];\n };\n\n /**\n * Getter and setter methods for position coordinates\n * @method positionX\n * @for p5.Panner3D\n * @return {Number} updated coordinate value\n */\n /**\n * Getter and setter methods for position coordinates\n * @method positionY\n * @for p5.Panner3D\n * @return {Number} updated coordinate value\n */\n /**\n * Getter and setter methods for position coordinates\n * @method positionZ\n * @for p5.Panner3D\n * @return {Number} updated coordinate value\n */\n p5.Panner3D.prototype.positionX = function(xVal, time) {\n var t = time || 0;\n if (typeof xVal === 'number') {\n this.panner.positionX.value = xVal;\n this.panner.positionX.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.panner.positionX.linearRampToValueAtTime(xVal, this.ac.currentTime + 0.02 + t);\n } else if (xVal) {\n xVal.connect(this.panner.positionX);\n }\n return this.panner.positionX.value;\n };\n p5.Panner3D.prototype.positionY = function(yVal, time) {\n var t = time || 0;\n if (typeof yVal === 'number') {\n this.panner.positionY.value = yVal;\n this.panner.positionY.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.panner.positionY.linearRampToValueAtTime(yVal, this.ac.currentTime + 0.02 + t);\n } else if (yVal) {\n yVal.connect(this.panner.positionY);\n }\n return this.panner.positionY.value;\n };\n p5.Panner3D.prototype.positionZ = function(zVal, time) {\n var t = time || 0;\n if (typeof zVal === 'number') {\n this.panner.positionZ.value = zVal;\n this.panner.positionZ.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.panner.positionZ.linearRampToValueAtTime(zVal, this.ac.currentTime + 0.02 + t);\n } else if (zVal) {\n zVal.connect(this.panner.positionZ);\n }\n return this.panner.positionZ.value;\n };\n\n /**\n * Set the X,Y,Z position of the Panner\n * @method orient\n * @for p5.Panner3D\n * @param {Number} xVal\n * @param {Number} yVal\n * @param {Number} zVal\n * @param {Number} time\n * @return {Array} Updated x, y, z values as an array\n */\n p5.Panner3D.prototype.orient = function(xVal, yVal, zVal, time) {\n this.orientX(xVal,time);\n this.orientY(yVal,time);\n this.orientZ(zVal,time);\n return [this.panner.orientationX.value,\n this.panner.orientationY.value,\n this.panner.orientationZ.value];\n };\n\n /**\n * Getter and setter methods for orient coordinates\n * @method orientX\n * @for p5.Panner3D\n * @return {Number} updated coordinate value\n */\n /**\n * Getter and setter methods for orient coordinates\n * @method orientY\n * @for p5.Panner3D\n * @return {Number} updated coordinate value\n */\n /**\n * Getter and setter methods for orient coordinates\n * @method orientZ\n * @for p5.Panner3D\n * @return {Number} updated coordinate value\n */\n p5.Panner3D.prototype.orientX = function(xVal, time) {\n var t = time || 0;\n if (typeof xVal === 'number') {\n this.panner.orientationX.value = xVal;\n this.panner.orientationX.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.panner.orientationX.linearRampToValueAtTime(xVal, this.ac.currentTime + 0.02 + t);\n } else if (xVal) {\n xVal.connect(this.panner.orientationX);\n }\n return this.panner.orientationX.value;\n };\n p5.Panner3D.prototype.orientY = function(yVal, time) {\n var t = time || 0;\n if (typeof yVal === 'number') {\n this.panner.orientationY.value = yVal;\n this.panner.orientationY.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.panner.orientationY.linearRampToValueAtTime(yVal, this.ac.currentTime + 0.02 + t);\n } else if (yVal) {\n yVal.connect(this.panner.orientationY);\n }\n return this.panner.orientationY.value;\n };\n p5.Panner3D.prototype.orientZ = function(zVal, time) {\n var t = time || 0;\n if (typeof zVal === 'number') {\n this.panner.orientationZ.value = zVal;\n this.panner.orientationZ.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.panner.orientationZ.linearRampToValueAtTime(zVal, this.ac.currentTime + 0.02 + t);\n } else if (zVal) {\n zVal.connect(this.panner.orientationZ);\n }\n return this.panner.orientationZ.value;\n };\n\n /**\n * Set the rolloff factor and max distance\n * @method setFalloff\n * @for p5.Panner3D\n * @param {Number} [maxDistance]\n * @param {Number} [rolloffFactor]\n */\n p5.Panner3D.prototype.setFalloff = function(maxDistance, rolloffFactor) {\n this.maxDist(maxDistance);\n this.rolloff(rolloffFactor);\n };\n /**\n * Maxium distance between the source and the listener\n * @method maxDist\n * @for p5.Panner3D\n * @param {Number} maxDistance\n * @return {Number} updated value\n */\n p5.Panner3D.prototype.maxDist = function(maxDistance){\n if (typeof maxDistance === 'number') {\n this.panner.maxDistance = maxDistance;\n }\n return this.panner.maxDistance;\n };\n\n /**\n * How quickly the volume is reduced as the source moves away from the listener\n * @method rollof\n * @for p5.Panner3D\n * @param {Number} rolloffFactor\n * @return {Number} updated value\n */\n p5.Panner3D.prototype.rolloff = function(rolloffFactor){\n if (typeof rolloffFactor === 'number') {\n this.panner.rolloffFactor = rolloffFactor;\n }\n return this.panner.rolloffFactor;\n };\n\n p5.Panner3D.dispose = function() {\n Effect.prototype.dispose.apply(this);\n if (this.panner) {\n this.panner.disconnect();\n delete this.panner;\n }\n };\n\n return p5.Panner3D;\n\n});\n","'use strict'\n\ndefine(function (require) {\n var p5sound = require('master');\n var Effect = require('effect');\n\n// /**\n// * listener is a class that can construct both a Spatial Panner\n// * and a Spatial Listener. The panner is based on the \n// * Web Audio Spatial Panner Node\n// * https://www.w3.org/TR/webaudio/#the-listenernode-interface\n// * This panner is a spatial processing node that allows audio to be positioned\n// * and oriented in 3D space. \n// *\n// * The Listener modifies the properties of the Audio Context Listener. \n// * Both objects types use the same methods. The default is a spatial panner.\n// *\n// * p5.Panner3D - Constructs a Spatial Panner
\n// * p5.Listener3D - Constructs a Spatial Listener
\n// *\n// * @class listener\n// * @constructor\n// * @return {Object} p5.Listener3D Object\n// *\n// * @param {Web Audio Node} listener Web Audio Spatial Panning Node\n// * @param {AudioParam} listener.panningModel \"equal power\" or \"HRTF\"\n// * @param {AudioParam} listener.distanceModel \"linear\", \"inverse\", or \"exponential\"\n// * @param {String} [type] [Specify construction of a spatial panner or listener]\n// */\n \n\tp5.Listener3D = function(type) {\n this.ac = p5sound.audiocontext;\n this.listener = this.ac.listener;\n\t}; \n\n// /**\n// * Connect an audio sorce\n// * @param {Object} src Input source\n// */\n p5.Listener3D.prototype.process = function(src) {\n src.connect(this.input);\n }\n// /**\n// * Set the X,Y,Z position of the Panner\n// * @param {[Number]} xVal\n// * @param {[Number]} yVal\n// * @param {[Number]} zVal\n// * @param {[Number]} time\n// * @return {[Array]} [Updated x, y, z values as an array]\n// */\n p5.Listener3D.prototype.position = function(xVal, yVal, zVal, time) {\n this.positionX(xVal,time);\n this.positionY(yVal,time);\n this.positionZ(zVal,time);\n return [this.listener.positionX.value, \n this.listener.positionY.value,\n this.listener.positionZ.value];\n };\n\n// /**\n// * Getter and setter methods for position coordinates\n// * @return {Number} [updated coordinate value]\n// */\n p5.Listener3D.prototype.positionX = function(xVal, time) {\n var t = time || 0;\n if (typeof xVal === 'number') {\n this.listener.positionX.value = xVal;\n this.listener.positionX.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.listener.positionX.linearRampToValueAtTime(xVal, this.ac.currentTime + 0.02 + t);\n } else if (xVal) {\n xVal.connect(this.listener.positionX);\n }\n return this.listener.positionX.value;\n };\n p5.Listener3D.prototype.positionY = function(yVal, time) {\n var t = time || 0;\n if (typeof yVal === 'number') {\n this.listener.positionY.value = yVal;\n this.listener.positionY.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.listener.positionY.linearRampToValueAtTime(yVal, this.ac.currentTime + 0.02 + t);\n } else if (yVal) {\n yVal.connect(this.listener.positionY);\n }\n return this.listener.positionY.value;\n };\n p5.Listener3D.prototype.positionZ = function(zVal, time) {\n var t = time || 0;\n if (typeof zVal === 'number') {\n this.listener.positionZ.value = zVal;\n this.listener.positionZ.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.listener.positionZ.linearRampToValueAtTime(zVal, this.ac.currentTime + 0.02 + t);\n } else if (zVal) {\n zVal.connect(this.listener.positionZ);\n }\n return this.listener.positionZ.value;\n };\n\n// cannot define method when class definition is commented\n// /**\n// * Overrides the listener orient() method because Listener has slightly\n// * different params. In human terms, Forward vectors are the direction the \n// * nose is pointing. Up vectors are the direction of the top of the head.\n// *\n// * @method orient\n// * @param {Number} xValF Forward vector X direction\n// * @param {Number} yValF Forward vector Y direction\n// * @param {Number} zValF Forward vector Z direction\n// * @param {Number} xValU Up vector X direction\n// * @param {Number} yValU Up vector Y direction\n// * @param {Number} zValU Up vector Z direction\n// * @param {Number} time \n// * @return {Array} All orienation params\n// */\n p5.Listener3D.prototype.orient = function(xValF, yValF, zValF, \n xValU, yValU, zValU, time) {\n\n if (arguments.length === 3 || arguments.length === 4) {\n time = arguments[3];\n this.orientForward(xValF, yValF, zValF, time);\n } else if (arguments.length === 6 || arguments === 7) {\n this.orientForward(xValF, yValF, zValF);\n this.orientUp(xValU, yValU, zValU, time);\n }\n \n return [this.listener.forwardX.value, \n this.listener.forwardY.value,\n this.listener.forwardZ.value,\n this.listener.upX.value,\n this.listener.upY.value,\n this.listener.upZ.value];\n };\n\n\n p5.Listener3D.prototype.orientForward = function(xValF, yValF, zValF, time) {\n this.forwardX(xValF,time);\n this.forwardY(yValF,time);\n this.forwardZ(zValF,time);\n\n return [this.listener.forwardX, \n this.listener.forwardY,\n this.listener.forwardZ];\n };\n\n p5.Listener3D.prototype.orientUp = function(xValU, yValU, zValU, time) {\n this.upX(xValU,time);\n this.upY(yValU,time);\n this.upZ(zValU,time);\n\n return [this.listener.upX, \n this.listener.upY,\n this.listener.upZ];\n };\n// /**\n// * Getter and setter methods for orient coordinates\n// * @return {Number} [updated coordinate value]\n// */\n p5.Listener3D.prototype.forwardX = function(xVal, time) {\n var t = time || 0;\n if (typeof xVal === 'number') {\n this.listener.forwardX.value = xVal;\n this.listener.forwardX.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.listener.forwardX.linearRampToValueAtTime(xVal, this.ac.currentTime + 0.02 + t);\n } else if (xVal) {\n xVal.connect(this.listener.forwardX);\n }\n return this.listener.forwardX.value;\n };\n p5.Listener3D.prototype.forwardY = function(yVal, time) {\n var t = time || 0;\n if (typeof yVal === 'number') {\n this.listener.forwardY.value = yVal;\n this.listener.forwardY.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.listener.forwardY.linearRampToValueAtTime(yVal, this.ac.currentTime + 0.02 + t);\n } else if (yVal) {\n yVal.connect(this.listener.forwardY);\n }\n return this.listener.forwardY.value;\n };\n p5.Listener3D.prototype.forwardZ = function(zVal, time) {\n var t = time || 0;\n if (typeof zVal === 'number') {\n this.listener.forwardZ.value = zVal;\n this.listener.forwardZ.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.listener.forwardZ.linearRampToValueAtTime(zVal, this.ac.currentTime + 0.02 + t);\n } else if (zVal) {\n zVal.connect(this.listener.forwardZ);\n }\n return this.listener.forwardZ.value;\n };\n p5.Listener3D.prototype.upX = function(xVal, time) {\n var t = time || 0;\n if (typeof xVal === 'number') {\n this.listener.upX.value = xVal;\n this.listener.upX.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.listener.upX.linearRampToValueAtTime(xVal, this.ac.currentTime + 0.02 + t);\n } else if (xVal) {\n xVal.connect(this.listener.upX);\n }\n return this.listener.upX.value;\n };\n p5.Listener3D.prototype.upY = function(yVal, time) {\n var t = time || 0;\n if (typeof yVal === 'number') {\n this.listener.upY.value = yVal;\n this.listener.upY.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.listener.upY.linearRampToValueAtTime(yVal, this.ac.currentTime + 0.02 + t);\n } else if (yVal) {\n yVal.connect(this.listener.upY);\n }\n return this.listener.upY.value;\n };\n p5.Listener3D.prototype.upZ = function(zVal, time) {\n var t = time || 0;\n if (typeof zVal === 'number') {\n this.listener.upZ.value = zVal;\n this.listener.upZ.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.listener.upZ.linearRampToValueAtTime(zVal, this.ac.currentTime + 0.02 + t);\n } else if (zVal) {\n zVal.connect(this.listener.upZ);\n }\n return this.listener.upZ.value;\n };\n \n return p5.Listener3D;\n\n});","'use strict';\n\ndefine(function (require) {\n var Filter = require('filter');\n var Effect = require('effect');\n\n /**\n * Delay is an echo effect. It processes an existing sound source,\n * and outputs a delayed version of that sound. The p5.Delay can\n * produce different effects depending on the delayTime, feedback,\n * filter, and type. In the example below, a feedback of 0.5 (the\n * default value) will produce a looping delay that decreases in\n * volume by 50% each repeat. A filter will cut out the high\n * frequencies so that the delay does not sound as piercing as the\n * original source.\n *\n *\n * This class extends p5.Effect.\n * Methods amp(), chain(),\n * drywet(), connect(), and\n * disconnect() are available.\n * @class p5.Delay\n * @extends p5.Effect\n * @constructor\n * @example\n *
\n * let osc;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * background(220);\n * textAlign(CENTER);\n * text('tap to play', width/2, height/2);\n *\n * osc = new p5.Oscillator('square');\n * osc.amp(0.5);\n * delay = new p5.Delay();\n *\n * // delay.process() accepts 4 parameters:\n * // source, delayTime (in seconds), feedback, filter frequency\n * delay.process(osc, 0.12, .7, 2300);\n *\n * cnv.mousePressed(oscStart);\n * }\n *\n * function oscStart() {\n * osc.start();\n * }\n *\n * function mouseReleased() {\n * osc.stop();\n * }\n *
\n */\n p5.Delay = function() {\n \tEffect.call(this);\n\n this._split = this.ac.createChannelSplitter(2);\n this._merge = this.ac.createChannelMerger(2);\n\n this._leftGain = this.ac.createGain();\n this._rightGain = this.ac.createGain();\n\n /**\n * The p5.Delay is built with two\n * \n * Web Audio Delay Nodes, one for each stereo channel.\n *\n * @for p5.Delay\n * @property {DelayNode} leftDelay\n */\n this.leftDelay = this.ac.createDelay();\n /**\n * The p5.Delay is built with two\n * \n * Web Audio Delay Nodes, one for each stereo channel.\n * @for p5.Delay\n * @property {DelayNode} rightDelay\n */\n this.rightDelay = this.ac.createDelay();\n\n this._leftFilter = new Filter();\n this._rightFilter = new Filter();\n this._leftFilter.disconnect();\n this._rightFilter.disconnect();\n\n this._leftFilter.biquad.frequency.setValueAtTime(1200, this.ac.currentTime);\n this._rightFilter.biquad.frequency.setValueAtTime(1200, this.ac.currentTime);\n this._leftFilter.biquad.Q.setValueAtTime(0.3, this.ac.currentTime);\n this._rightFilter.biquad.Q.setValueAtTime(0.3, this.ac.currentTime);\n\n // graph routing\n this.input.connect(this._split);\n this.leftDelay.connect(this._leftGain);\n this.rightDelay.connect(this._rightGain);\n this._leftGain.connect(this._leftFilter.input);\n this._rightGain.connect(this._rightFilter.input);\n this._merge.connect(this.wet);\n\n\n this._leftFilter.biquad.gain.setValueAtTime(1, this.ac.currentTime);\n this._rightFilter.biquad.gain.setValueAtTime(1, this.ac.currentTime);\n\n // default routing\n this.setType(0);\n\n this._maxDelay = this.leftDelay.delayTime.maxValue;\n\n // set initial feedback to 0.5\n this.feedback(0.5);\n\n\n };\n\n p5.Delay.prototype = Object.create(Effect.prototype);\n /**\n * Add delay to an audio signal according to a set\n * of delay parameters.\n *\n * @method process\n * @for p5.Delay\n * @param {Object} Signal An object that outputs audio\n * @param {Number} [delayTime] Time (in seconds) of the delay/echo.\n * Some browsers limit delayTime to\n * 1 second.\n * @param {Number} [feedback] sends the delay back through itself\n * in a loop that decreases in volume\n * each time.\n * @param {Number} [lowPass] Cutoff frequency. Only frequencies\n * below the lowPass will be part of the\n * delay.\n */\n p5.Delay.prototype.process = function(src, _delayTime, _feedback, _filter) {\n var feedback = _feedback || 0;\n var delayTime = _delayTime || 0;\n if (feedback >= 1.0) {\n throw new Error('Feedback value will force a positive feedback loop.');\n }\n if (delayTime >= this._maxDelay) {\n throw new Error('Delay Time exceeds maximum delay time of ' + this._maxDelay + ' second.');\n }\n\n src.connect(this.input);\n this.leftDelay.delayTime.setValueAtTime(delayTime, this.ac.currentTime);\n this.rightDelay.delayTime.setValueAtTime(delayTime, this.ac.currentTime);\n this._leftGain.gain.value = feedback;\n this._rightGain.gain.value = feedback;\n\n if (_filter) {\n this._leftFilter.freq(_filter);\n this._rightFilter.freq(_filter);\n }\n };\n\n /**\n * Set the delay (echo) time, in seconds. Usually this value will be\n * a floating point number between 0.0 and 1.0.\n *\n * @method delayTime\n * @for p5.Delay\n * @param {Number} delayTime Time (in seconds) of the delay\n */\n p5.Delay.prototype.delayTime = function(t) {\n // if t is an audio node...\n if (typeof t !== 'number') {\n t.connect(this.leftDelay.delayTime);\n t.connect(this.rightDelay.delayTime);\n }\n\n else {\n this.leftDelay.delayTime.cancelScheduledValues(this.ac.currentTime);\n this.rightDelay.delayTime.cancelScheduledValues(this.ac.currentTime);\n this.leftDelay.delayTime.linearRampToValueAtTime(t, this.ac.currentTime);\n this.rightDelay.delayTime.linearRampToValueAtTime(t, this.ac.currentTime);\n }\n };\n\n /**\n * Feedback occurs when Delay sends its signal back through its input\n * in a loop. The feedback amount determines how much signal to send each\n * time through the loop. A feedback greater than 1.0 is not desirable because\n * it will increase the overall output each time through the loop,\n * creating an infinite feedback loop. The default value is 0.5\n *\n * @method feedback\n * @for p5.Delay\n * @param {Number|Object} feedback 0.0 to 1.0, or an object such as an\n * Oscillator that can be used to\n * modulate this param\n * @returns {Number} Feedback value\n *\n */\n p5.Delay.prototype.feedback = function(f) {\n // if f is an audio node...\n if (f && typeof f !== 'number') {\n f.connect(this._leftGain.gain);\n f.connect(this._rightGain.gain);\n }\n else if (f >= 1.0) {\n throw new Error('Feedback value will force a positive feedback loop.');\n }\n else if (typeof f === 'number') {\n this._leftGain.gain.value = f;\n this._rightGain.gain.value = f;\n }\n\n // return value of feedback\n return this._leftGain.gain.value;\n };\n\n /**\n * Set a lowpass filter frequency for the delay. A lowpass filter\n * will cut off any frequencies higher than the filter frequency.\n *\n * @method filter\n * @for p5.Delay\n * @param {Number|Object} cutoffFreq A lowpass filter will cut off any\n * frequencies higher than the filter frequency.\n * @param {Number|Object} res Resonance of the filter frequency\n * cutoff, or an object (i.e. a p5.Oscillator)\n * that can be used to modulate this parameter.\n * High numbers (i.e. 15) will produce a resonance,\n * low numbers (i.e. .2) will produce a slope.\n */\n p5.Delay.prototype.filter = function(freq, q) {\n this._leftFilter.set(freq, q);\n this._rightFilter.set(freq, q);\n };\n\n\n /**\n * Choose a preset type of delay. 'pingPong' bounces the signal\n * from the left to the right channel to produce a stereo effect.\n * Any other parameter will revert to the default delay setting.\n *\n * @method setType\n * @for p5.Delay\n * @param {String|Number} type 'pingPong' (1) or 'default' (0)\n */\n p5.Delay.prototype.setType = function(t) {\n if (t === 1) {\n t = 'pingPong';\n }\n this._split.disconnect();\n this._leftFilter.disconnect();\n this._rightFilter.disconnect();\n this._split.connect(this.leftDelay, 0);\n this._split.connect(this.rightDelay, 1);\n switch(t) {\n case 'pingPong':\n this._rightFilter.setType( this._leftFilter.biquad.type );\n this._leftFilter.output.connect(this._merge, 0, 0);\n this._rightFilter.output.connect(this._merge, 0, 1);\n this._leftFilter.output.connect(this.rightDelay);\n this._rightFilter.output.connect(this.leftDelay);\n break;\n default:\n this._leftFilter.output.connect(this._merge, 0, 0);\n this._rightFilter.output.connect(this._merge, 0, 1);\n this._leftFilter.output.connect(this.leftDelay);\n this._rightFilter.output.connect(this.rightDelay);\n }\n };\n\n // DocBlocks for methods inherited from p5.Effect\n /**\n * Set the output level of the delay effect.\n *\n * @method amp\n * @for p5.Delay\n * @param {Number} volume amplitude between 0 and 1.0\n * @param {Number} [rampTime] create a fade that lasts rampTime\n * @param {Number} [timeFromNow] schedule this event to happen\n * seconds from now\n */\n /**\n * Send output to a p5.sound or web audio object\n *\n * @method connect\n * @for p5.Delay\n * @param {Object} unit\n */\n /**\n * Disconnect all output.\n *\n * @method disconnect\n * @for p5.Delay\n */\n\n p5.Delay.prototype.dispose = function() {\n\n Effect.prototype.dispose.apply(this);\n\n this._split.disconnect();\n this._leftFilter.dispose();\n this._rightFilter.dispose();\n this._merge.disconnect();\n this._leftGain.disconnect();\n this._rightGain.disconnect();\n this.leftDelay.disconnect();\n this.rightDelay.disconnect();\n\n this._split = undefined;\n this._leftFilter = undefined;\n this._rightFilter = undefined;\n this._merge = undefined;\n this._leftGain = undefined;\n this._rightGain = undefined;\n this.leftDelay = undefined;\n this.rightDelay = undefined;\n };\n\n});\n","'use strict';\n\ndefine(function (require) {\n var CustomError = require('errorHandler');\n var Effect = require('effect');\n\n /**\n * Reverb adds depth to a sound through a large number of decaying\n * echoes. It creates the perception that sound is occurring in a\n * physical space. The p5.Reverb has paramters for Time (how long does the\n * reverb last) and decayRate (how much the sound decays with each echo)\n * that can be set with the .set() or .process() methods. The p5.Convolver\n * extends p5.Reverb allowing you to recreate the sound of actual physical\n * spaces through convolution.\n *\n * This class extends p5.Effect.\n * Methods amp(), chain(),\n * drywet(), connect(), and\n * disconnect() are available.\n *\n * @class p5.Reverb\n * @extends p5.Effect\n * @constructor\n * @example\n *
\n * let soundFile, reverb;\n * function preload() {\n * soundFile = loadSound('assets/Damscray_DancingTiger.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playSound);\n *\n * reverb = new p5.Reverb();\n * soundFile.disconnect(); // so we'll only hear reverb...\n *\n * // connect soundFile to reverb, process w/\n * // 3 second reverbTime, decayRate of 2%\n * reverb.process(soundFile, 3, 2);\n * }\n *\n * function draw() {\n * let dryWet = constrain(map(mouseX, 0, width, 0, 1), 0, 1);\n * // 1 = all reverb, 0 = no reverb\n * reverb.drywet(dryWet);\n *\n * background(220);\n * text('tap to play', 10, 20);\n * text('dry/wet: ' + round(dryWet * 100) + '%', 10, height - 20);\n * }\n *\n * function playSound() {\n * soundFile.play();\n * }\n *
\n */\n\n\n p5.Reverb = function() {\n Effect.call(this);\n\n this._initConvolverNode();\n\n // otherwise, Safari distorts\n this.input.gain.value = 0.5;\n\n // default params\n this._seconds = 3;\n this._decay = 2;\n this._reverse = false;\n\n this._buildImpulse();\n\n };\n\n p5.Reverb.prototype = Object.create(Effect.prototype);\n\n p5.Reverb.prototype._initConvolverNode = function() {\n this.convolverNode = this.ac.createConvolver();\n this.input.connect(this.convolverNode);\n this.convolverNode.connect(this.wet);\n };\n\n p5.Reverb.prototype._teardownConvolverNode = function() {\n if (this.convolverNode) {\n this.convolverNode.disconnect();\n delete this.convolverNode;\n }\n };\n\n p5.Reverb.prototype._setBuffer = function(audioBuffer) {\n this._teardownConvolverNode();\n this._initConvolverNode();\n this.convolverNode.buffer = audioBuffer;\n };\n /**\n * Connect a source to the reverb, and assign reverb parameters.\n *\n * @method process\n * @for p5.Reverb\n * @param {Object} src p5.sound / Web Audio object with a sound\n * output.\n * @param {Number} [seconds] Duration of the reverb, in seconds.\n * Min: 0, Max: 10. Defaults to 3.\n * @param {Number} [decayRate] Percentage of decay with each echo.\n * Min: 0, Max: 100. Defaults to 2.\n * @param {Boolean} [reverse] Play the reverb backwards or forwards.\n */\n p5.Reverb.prototype.process = function(src, seconds, decayRate, reverse) {\n src.connect(this.input);\n var rebuild = false;\n if (seconds) {\n this._seconds = seconds;\n rebuild = true;\n }\n if (decayRate) {\n this._decay = decayRate;\n }\n if (reverse) {\n this._reverse = reverse;\n }\n if (rebuild) {\n this._buildImpulse();\n }\n };\n\n /**\n * Set the reverb settings. Similar to .process(), but without\n * assigning a new input.\n *\n * @method set\n * @for p5.Reverb\n * @param {Number} [seconds] Duration of the reverb, in seconds.\n * Min: 0, Max: 10. Defaults to 3.\n * @param {Number} [decayRate] Percentage of decay with each echo.\n * Min: 0, Max: 100. Defaults to 2.\n * @param {Boolean} [reverse] Play the reverb backwards or forwards.\n */\n p5.Reverb.prototype.set = function(seconds, decayRate, reverse) {\n var rebuild = false;\n if (seconds) {\n this._seconds = seconds;\n rebuild = true;\n }\n if (decayRate) {\n this._decay = decayRate;\n }\n if (reverse) {\n this._reverse = reverse;\n }\n if (rebuild) {\n this._buildImpulse();\n }\n };\n\n // DocBlocks for methods inherited from p5.Effect\n /**\n * Set the output level of the reverb effect.\n *\n * @method amp\n * @for p5.Reverb\n * @param {Number} volume amplitude between 0 and 1.0\n * @param {Number} [rampTime] create a fade that lasts rampTime\n * @param {Number} [timeFromNow] schedule this event to happen\n * seconds from now\n */\n /**\n * Send output to a p5.sound or web audio object\n *\n * @method connect\n * @for p5.Reverb\n * @param {Object} unit\n */\n /**\n * Disconnect all output.\n *\n * @method disconnect\n * @for p5.Reverb\n */\n\n /**\n * Inspired by Simple Reverb by Jordan Santell\n * https://github.com/web-audio-components/simple-reverb/blob/master/index.js\n *\n * Utility function for building an impulse response\n * based on the module parameters.\n *\n * @private\n */\n p5.Reverb.prototype._buildImpulse = function() {\n var rate = this.ac.sampleRate;\n var length = rate*this._seconds;\n var decay = this._decay;\n var impulse = this.ac.createBuffer(2, length, rate);\n var impulseL = impulse.getChannelData(0);\n var impulseR = impulse.getChannelData(1);\n var n, i;\n for (i = 0; i < length; i++) {\n n = this._reverse ? length - i : i;\n impulseL[i] = (Math.random() * 2 - 1) * Math.pow(1 - n / length, decay);\n impulseR[i] = (Math.random() * 2 - 1) * Math.pow(1 - n / length, decay);\n }\n this._setBuffer(impulse);\n };\n\n p5.Reverb.prototype.dispose = function() {\n Effect.prototype.dispose.apply(this);\n this._teardownConvolverNode();\n };\n\n // =======================================================================\n // *** p5.Convolver ***\n // =======================================================================\n\n /**\n *

p5.Convolver extends p5.Reverb. It can emulate the sound of real\n * physical spaces through a process called \n * convolution.

\n *\n *

Convolution multiplies any audio input by an \"impulse response\"\n * to simulate the dispersion of sound over time. The impulse response is\n * generated from an audio file that you provide. One way to\n * generate an impulse response is to pop a balloon in a reverberant space\n * and record the echo. Convolution can also be used to experiment with\n * sound.

\n *\n *

Use the method createConvolution(path) to instantiate a\n * p5.Convolver with a path to your impulse response audio file.

\n *\n * @class p5.Convolver\n * @extends p5.Effect\n * @constructor\n * @param {String} path path to a sound file\n * @param {Function} [callback] function to call when loading succeeds\n * @param {Function} [errorCallback] function to call if loading fails.\n * This function will receive an error or\n * XMLHttpRequest object with information\n * about what went wrong.\n * @example\n *
\n * let cVerb, sound;\n * function preload() {\n * // We have both MP3 and OGG versions of all sound assets\n * soundFormats('ogg', 'mp3');\n *\n * // Try replacing 'bx-spring' with other soundfiles like\n * // 'concrete-tunnel' 'small-plate' 'drum' 'beatbox'\n * cVerb = createConvolver('assets/bx-spring.mp3');\n *\n * // Try replacing 'Damscray_DancingTiger' with\n * // 'beat', 'doorbell', lucky_dragons_-_power_melody'\n * sound = loadSound('assets/Damscray_DancingTiger.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playSound);\n * background(220);\n * text('tap to play', 20, 20);\n *\n * // disconnect from master output...\n * sound.disconnect();\n *\n * // ...and process with cVerb\n * // so that we only hear the convolution\n * cVerb.process(sound);\n * }\n *\n * function playSound() {\n * sound.play();\n * }\n *
\n */\n p5.Convolver = function(path, callback, errorCallback) {\n \t p5.Reverb.call(this);\n\n /**\n * Internally, the p5.Convolver uses the a\n * \n * Web Audio Convolver Node.\n *\n * @property {ConvolverNode} convolverNode\n */\n this._initConvolverNode();\n\n // otherwise, Safari distorts\n this.input.gain.value = 0.5;\n\n if (path) {\n this.impulses = [];\n this._loadBuffer(path, callback, errorCallback);\n }\n else {\n // parameters\n this._seconds = 3;\n this._decay = 2;\n this._reverse = false;\n\n this._buildImpulse();\n }\n\n };\n\n p5.Convolver.prototype = Object.create(p5.Reverb.prototype);\n\n p5.prototype.registerPreloadMethod('createConvolver', p5.prototype);\n\n /**\n * Create a p5.Convolver. Accepts a path to a soundfile\n * that will be used to generate an impulse response.\n *\n * @method createConvolver\n * @for p5\n * @param {String} path path to a sound file\n * @param {Function} [callback] function to call if loading is successful.\n * The object will be passed in as the argument\n * to the callback function.\n * @param {Function} [errorCallback] function to call if loading is not successful.\n * A custom error will be passed in as the argument\n * to the callback function.\n * @return {p5.Convolver}\n * @example\n *
\n * let cVerb, sound;\n * function preload() {\n * // We have both MP3 and OGG versions of all sound assets\n * soundFormats('ogg', 'mp3');\n *\n * // Try replacing 'bx-spring' with other soundfiles like\n * // 'concrete-tunnel' 'small-plate' 'drum' 'beatbox'\n * cVerb = createConvolver('assets/bx-spring.mp3');\n *\n * // Try replacing 'Damscray_DancingTiger' with\n * // 'beat', 'doorbell', lucky_dragons_-_power_melody'\n * sound = loadSound('assets/Damscray_DancingTiger.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playSound);\n * background(220);\n * text('tap to play', 20, 20);\n *\n * // disconnect from master output...\n * sound.disconnect();\n *\n * // ...and process with cVerb\n * // so that we only hear the convolution\n * cVerb.process(sound);\n * }\n *\n * function playSound() {\n * sound.play();\n * }\n *
\n */\n p5.prototype.createConvolver = function(path, callback, errorCallback) {\n // if loading locally without a server\n if (window.location.origin.indexOf('file://') > -1 && window.cordova === 'undefined') {\n alert('This sketch may require a server to load external files. Please see http://bit.ly/1qcInwS');\n }\n var self = this;\n var cReverb = new p5.Convolver(path, function(buffer) {\n if (typeof callback === 'function') {\n callback(buffer);\n }\n\n if (typeof self._decrementPreload === 'function') {\n self._decrementPreload();\n }\n }, errorCallback);\n cReverb.impulses = [];\n return cReverb;\n };\n\n /**\n * Private method to load a buffer as an Impulse Response,\n * assign it to the convolverNode, and add to the Array of .impulses.\n *\n * @param {String} path\n * @param {Function} callback\n * @param {Function} errorCallback\n * @private\n */\n p5.Convolver.prototype._loadBuffer = function(path, callback, errorCallback) {\n var path = p5.prototype._checkFileFormats(path);\n var self = this;\n var errorTrace = new Error().stack;\n var ac = p5.prototype.getAudioContext();\n\n var request = new XMLHttpRequest();\n request.open('GET', path, true);\n request.responseType = 'arraybuffer';\n\n request.onload = function() {\n if (request.status === 200) {\n // on success loading file:\n ac.decodeAudioData(request.response,\n function(buff) {\n var buffer = {};\n var chunks = path.split('/');\n buffer.name = chunks[chunks.length - 1];\n buffer.audioBuffer = buff;\n self.impulses.push(buffer);\n self._setBuffer(buffer.audioBuffer);\n if (callback) {\n callback(buffer);\n }\n },\n // error decoding buffer. \"e\" is undefined in Chrome 11/22/2015\n function() {\n var err = new CustomError('decodeAudioData', errorTrace, self.url);\n var msg = 'AudioContext error at decodeAudioData for ' + self.url;\n if (errorCallback) {\n err.msg = msg;\n errorCallback(err);\n } else {\n console.error(msg +'\\n The error stack trace includes: \\n' + err.stack);\n }\n }\n );\n }\n // if request status != 200, it failed\n else {\n var err = new CustomError('loadConvolver', errorTrace, self.url);\n var msg = 'Unable to load ' + self.url +\n '. The request status was: ' + request.status + ' (' + request.statusText + ')';\n\n if (errorCallback) {\n err.message = msg;\n errorCallback(err);\n } else {\n console.error(msg +'\\n The error stack trace includes: \\n' + err.stack);\n }\n }\n };\n\n // if there is another error, aside from 404...\n request.onerror = function() {\n var err = new CustomError('loadConvolver', errorTrace, self.url);\n var msg = 'There was no response from the server at ' + self.url + '. Check the url and internet connectivity.';\n\n if (errorCallback) {\n err.message = msg;\n errorCallback(err);\n } else {\n console.error(msg +'\\n The error stack trace includes: \\n' + err.stack);\n }\n };\n request.send();\n };\n\n p5.Convolver.prototype.set = null;\n\n /**\n * Connect a source to the convolver.\n *\n * @method process\n * @for p5.Convolver\n * @param {Object} src p5.sound / Web Audio object with a sound\n * output.\n * @example\n *
\n * let cVerb, sound;\n * function preload() {\n * // We have both MP3 and OGG versions of all sound assets\n * soundFormats('ogg', 'mp3');\n *\n * // Try replacing 'bx-spring' with other soundfiles like\n * // 'concrete-tunnel' 'small-plate' 'drum' 'beatbox'\n * cVerb = createConvolver('assets/bx-spring.mp3');\n *\n * // Try replacing 'Damscray_DancingTiger' with\n * // 'beat', 'doorbell', lucky_dragons_-_power_melody'\n * sound = loadSound('assets/Damscray_DancingTiger.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playSound);\n * background(220);\n * text('tap to play', 20, 20);\n *\n * // disconnect from master output...\n * sound.disconnect();\n *\n * // ...and process with cVerb\n * // so that we only hear the convolution\n * cVerb.process(sound);\n * }\n *\n * function playSound() {\n * sound.play();\n * }\n *\n *
\n */\n p5.Convolver.prototype.process = function(src) {\n src.connect(this.input);\n };\n\n /**\n * If you load multiple impulse files using the .addImpulse method,\n * they will be stored as Objects in this Array. Toggle between them\n * with the toggleImpulse(id) method.\n *\n * @property {Array} impulses\n * @for p5.Convolver\n */\n p5.Convolver.prototype.impulses = [];\n\n /**\n * Load and assign a new Impulse Response to the p5.Convolver.\n * The impulse is added to the .impulses array. Previous\n * impulses can be accessed with the .toggleImpulse(id)\n * method.\n *\n * @method addImpulse\n * @for p5.Convolver\n * @param {String} path path to a sound file\n * @param {Function} callback function (optional)\n * @param {Function} errorCallback function (optional)\n */\n p5.Convolver.prototype.addImpulse = function(path, callback, errorCallback) {\n // if loading locally without a server\n if (window.location.origin.indexOf('file://') > -1 && window.cordova === 'undefined') {\n alert('This sketch may require a server to load external files. Please see http://bit.ly/1qcInwS');\n }\n this._loadBuffer(path, callback, errorCallback);\n };\n\n /**\n * Similar to .addImpulse, except that the .impulses\n * Array is reset to save memory. A new .impulses\n * array is created with this impulse as the only item.\n *\n * @method resetImpulse\n * @for p5.Convolver\n * @param {String} path path to a sound file\n * @param {Function} callback function (optional)\n * @param {Function} errorCallback function (optional)\n */\n p5.Convolver.prototype.resetImpulse = function(path, callback, errorCallback) {\n // if loading locally without a server\n if (window.location.origin.indexOf('file://') > -1 && window.cordova === 'undefined') {\n alert('This sketch may require a server to load external files. Please see http://bit.ly/1qcInwS');\n }\n this.impulses = [];\n this._loadBuffer(path, callback, errorCallback);\n };\n\n /**\n * If you have used .addImpulse() to add multiple impulses\n * to a p5.Convolver, then you can use this method to toggle between\n * the items in the .impulses Array. Accepts a parameter\n * to identify which impulse you wish to use, identified either by its\n * original filename (String) or by its position in the .impulses\n * Array (Number).
\n * You can access the objects in the .impulses Array directly. Each\n * Object has two attributes: an .audioBuffer (type:\n * Web Audio \n * AudioBuffer) and a .name, a String that corresponds\n * with the original filename.\n *\n * @method toggleImpulse\n * @for p5.Convolver\n * @param {String|Number} id Identify the impulse by its original filename\n * (String), or by its position in the\n * .impulses Array (Number).\n */\n p5.Convolver.prototype.toggleImpulse = function(id) {\n if (typeof id === 'number' && id < this.impulses.length) {\n this._setBuffer(this.impulses[id].audioBuffer);\n }\n if (typeof id === 'string') {\n for (var i = 0; i < this.impulses.length; i++) {\n if (this.impulses[i].name === id) {\n this._setBuffer(this.impulses[i].audioBuffer);\n break;\n }\n }\n }\n };\n\n p5.Convolver.prototype.dispose = function() {\n p5.Reverb.prototype.dispose.apply(this);\n\n // remove all the Impulse Response buffers\n for (var i in this.impulses) {\n if (this.impulses[i]) {\n this.impulses[i] = null;\n }\n }\n };\n\n});\n","'use strict';\n\ndefine(function (require) {\n var p5sound = require('master');\n\n // requires the Tone.js library's Clock (MIT license, Yotam Mann)\n // https://github.com/TONEnoTONE/Tone.js/\n var Clock = require('Tone/core/Clock');\n\n p5.Metro = function() {\n this.clock = new Clock({\n 'callback': this.ontick.bind(this)\n });\n this.syncedParts = [];\n this.bpm = 120; // gets overridden by p5.Part\n this._init();\n\n this.prevTick = 0;\n this.tatumTime = 0;\n\n this.tickCallback = function() {};\n };\n\n p5.Metro.prototype.ontick = function(tickTime) {\n var elapsedTime = tickTime - this.prevTick;\n var secondsFromNow = tickTime - p5sound.audiocontext.currentTime;\n if (elapsedTime - this.tatumTime <= -0.02) {\n return;\n } else {\n // console.log('ok', this.syncedParts[0].phrases[0].name);\n this.prevTick = tickTime;\n\n // for all of the active things on the metro:\n var self = this;\n this.syncedParts.forEach(function(thisPart) {\n if (!thisPart.isPlaying) return;\n thisPart.incrementStep(secondsFromNow);\n // each synced source keeps track of its own beat number\n thisPart.phrases.forEach(function(thisPhrase) {\n var phraseArray = thisPhrase.sequence;\n var bNum = self.metroTicks % phraseArray.length;\n if (phraseArray[bNum] !== 0 && (self.metroTicks < phraseArray.length || !thisPhrase.looping) ) {\n thisPhrase.callback(secondsFromNow, phraseArray[bNum]);\n }\n });\n });\n this.metroTicks += 1;\n this.tickCallback(secondsFromNow);\n }\n };\n\n p5.Metro.prototype.setBPM = function(bpm, rampTime) {\n var beatTime = 60 / (bpm*this.tatums);\n var now = p5sound.audiocontext.currentTime;\n this.tatumTime = beatTime;\n\n var rampTime = rampTime || 0;\n this.clock.frequency.setValueAtTime(this.clock.frequency.value, now);\n this.clock.frequency.linearRampToValueAtTime(bpm, now + rampTime);\n this.bpm = bpm;\n };\n\n p5.Metro.prototype.getBPM = function() {\n return this.clock.getRate() / this.tatums * 60;\n };\n\n p5.Metro.prototype._init = function() {\n this.metroTicks = 0;\n // this.setBPM(120);\n };\n\n // clear existing synced parts, add only this one\n p5.Metro.prototype.resetSync = function(part) {\n this.syncedParts = [part];\n };\n\n // push a new synced part to the array\n p5.Metro.prototype.pushSync = function(part) {\n this.syncedParts.push(part);\n };\n\n p5.Metro.prototype.start = function(timeFromNow) {\n var t = timeFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n this.clock.start(now + t);\n this.setBPM(this.bpm);\n };\n\n p5.Metro.prototype.stop = function(timeFromNow) {\n var t = timeFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n this.clock.stop(now + t);\n };\n\n p5.Metro.prototype.beatLength = function(tatums) {\n this.tatums = 1/tatums / 4; // lowest possible division of a beat\n };\n\n});\n","define([\"Tone/core/Tone\", \"Tone/core/Timeline\", \"Tone/type/Type\"], function (Tone) {\n\n\t\"use strict\";\n\n\t/**\n\t * @class A Timeline State. Provides the methods: setStateAtTime(\"state\", time)\n\t * and getValueAtTime(time).\n\t *\n\t * @extends {Tone.Timeline}\n\t * @param {String} initial The initial state of the TimelineState. \n\t * Defaults to undefined\n\t */\n\tTone.TimelineState = function(initial){\n\n\t\tTone.Timeline.call(this);\n\n\t\t/**\n\t\t * The initial state\n\t\t * @private\n\t\t * @type {String}\n\t\t */\n\t\tthis._initial = initial;\n\t};\n\n\tTone.extend(Tone.TimelineState, Tone.Timeline);\n\n\t/**\n\t * Returns the scheduled state scheduled before or at\n\t * the given time.\n\t * @param {Number} time The time to query.\n\t * @return {String} The name of the state input in setStateAtTime.\n\t */\n\tTone.TimelineState.prototype.getValueAtTime = function(time){\n\t\tvar event = this.get(time);\n\t\tif (event !== null){\n\t\t\treturn event.state;\n\t\t} else {\n\t\t\treturn this._initial;\n\t\t}\n\t};\n\n\t/**\n\t * Returns the scheduled state scheduled before or at\n\t * the given time.\n\t * @param {String} state The name of the state to set.\n\t * @param {Number} time The time to query.\n\t */\n\tTone.TimelineState.prototype.setStateAtTime = function(state, time){\n\t\tthis.add({\n\t\t\t\"state\" : state,\n\t\t\t\"time\" : time\n\t\t});\n\t};\n\n\treturn Tone.TimelineState;\n});","'use strict';\n\ndefine(function(require) {\n var p5sound = require('master');\n\n var BPM = 120;\n\n /**\n * Set the global tempo, in beats per minute, for all\n * p5.Parts. This method will impact all active p5.Parts.\n *\n * @method setBPM\n * @for p5\n * @param {Number} BPM Beats Per Minute\n * @param {Number} rampTime Seconds from now\n */\n p5.prototype.setBPM = function(bpm, rampTime) {\n BPM = bpm;\n for (var i in p5sound.parts) {\n if (p5sound.parts[i]) {\n p5sound.parts[i].setBPM(bpm, rampTime);\n }\n }\n };\n\n /**\n *

A phrase is a pattern of musical events over time, i.e.\n * a series of notes and rests.

\n *\n *

Phrases must be added to a p5.Part for playback, and\n * each part can play multiple phrases at the same time.\n * For example, one Phrase might be a kick drum, another\n * could be a snare, and another could be the bassline.

\n *\n *

The first parameter is a name so that the phrase can be\n * modified or deleted later. The callback is a a function that\n * this phrase will call at every step—for example it might be\n * called playNote(value){}. The array determines\n * which value is passed into the callback at each step of the\n * phrase. It can be numbers, an object with multiple numbers,\n * or a zero (0) indicates a rest so the callback won't be called).

\n *\n * @class p5.Phrase\n * @constructor\n * @param {String} name Name so that you can access the Phrase.\n * @param {Function} callback The name of a function that this phrase\n * will call. Typically it will play a sound,\n * and accept two parameters: a time at which\n * to play the sound (in seconds from now),\n * and a value from the sequence array. The\n * time should be passed into the play() or\n * start() method to ensure precision.\n * @param {Array} sequence Array of values to pass into the callback\n * at each step of the phrase.\n * @example\n *
\n * let mySound, myPhrase, myPart;\n * let pattern = [1,0,0,2,0,2,0,0];\n *\n * function preload() {\n * mySound = loadSound('assets/beatbox.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playMyPart);\n * background(220);\n * text('tap to play', width/2, height/2);\n * textAlign(CENTER, CENTER);\n *\n * myPhrase = new p5.Phrase('bbox', onEachStep, pattern);\n * myPart = new p5.Part();\n * myPart.addPhrase(myPhrase);\n * myPart.setBPM(60);\n * }\n *\n * function onEachStep(time, playbackRate) {\n * mySound.rate(playbackRate);\n * mySound.play(time);\n * }\n *\n * function playMyPart() {\n * userStartAudio();\n * myPart.start();\n * }\n *
\n */\n p5.Phrase = function(name, callback, sequence) {\n this.phraseStep = 0;\n this.name = name;\n this.callback = callback;\n /**\n * Array of values to pass into the callback\n * at each step of the phrase. Depending on the callback\n * function's requirements, these values may be numbers,\n * strings, or an object with multiple parameters.\n * Zero (0) indicates a rest.\n *\n * @property {Array} sequence\n */\n this.sequence = sequence;\n };\n\n /**\n *

A p5.Part plays back one or more p5.Phrases. Instantiate a part\n * with steps and tatums. By default, each step represents a 1/16th note.

\n *\n *

See p5.Phrase for more about musical timing.

\n *\n * @class p5.Part\n * @constructor\n * @param {Number} [steps] Steps in the part\n * @param {Number} [tatums] Divisions of a beat, e.g. use 1/4, or 0.25 for a quater note (default is 1/16, a sixteenth note)\n * @example\n *
\n * let box, drum, myPart;\n * let boxPat = [1,0,0,2,0,2,0,0];\n * let drumPat = [0,1,1,0,2,0,1,0];\n *\n * function preload() {\n * box = loadSound('assets/beatbox.mp3');\n * drum = loadSound('assets/drum.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playMyPart);\n * background(220);\n * textAlign(CENTER, CENTER);\n * text('tap to play', width/2, height/2);\n *\n * let boxPhrase = new p5.Phrase('box', playBox, boxPat);\n * let drumPhrase = new p5.Phrase('drum', playDrum, drumPat);\n * myPart = new p5.Part();\n * myPart.addPhrase(boxPhrase);\n * myPart.addPhrase(drumPhrase);\n * myPart.setBPM(60);\n * }\n *\n * function playBox(time, playbackRate) {\n * box.rate(playbackRate);\n * box.play(time);\n * }\n *\n * function playDrum(time, playbackRate) {\n * drum.rate(playbackRate);\n * drum.play(time);\n * }\n *\n * function playMyPart() {\n * userStartAudio();\n *\n * myPart.start();\n * }\n *
\n */\n p5.Part = function(steps, bLength) {\n this.length = steps || 0; // how many beats\n this.partStep = 0;\n this.phrases = [];\n this.isPlaying = false;\n this.noLoop();\n this.tatums = bLength || 0.0625; // defaults to quarter note\n\n this.metro = new p5.Metro();\n this.metro._init();\n this.metro.beatLength(this.tatums);\n this.metro.setBPM(BPM);\n p5sound.parts.push(this);\n this.callback = function() {};\n };\n\n /**\n * Set the tempo of this part, in Beats Per Minute.\n *\n * @method setBPM\n * @for p5.Part\n * @param {Number} BPM Beats Per Minute\n * @param {Number} [rampTime] Seconds from now\n */\n p5.Part.prototype.setBPM = function(tempo, rampTime) {\n this.metro.setBPM(tempo, rampTime);\n };\n\n /**\n * Returns the tempo, in Beats Per Minute, of this part.\n *\n * @method getBPM\n * @for p5.Part\n * @return {Number}\n */\n p5.Part.prototype.getBPM = function() {\n return this.metro.getBPM();\n };\n\n /**\n * Start playback of this part. It will play\n * through all of its phrases at a speed\n * determined by setBPM.\n *\n * @method start\n * @for p5.Part\n * @param {Number} [time] seconds from now\n */\n p5.Part.prototype.start = function(time) {\n if (!this.isPlaying) {\n this.isPlaying = true;\n this.metro.resetSync(this);\n var t = time || 0;\n this.metro.start(t);\n }\n };\n\n /**\n * Loop playback of this part. It will begin\n * looping through all of its phrases at a speed\n * determined by setBPM.\n *\n * @method loop\n * @for p5.Part\n * @param {Number} [time] seconds from now\n */\n p5.Part.prototype.loop = function(time) {\n this.looping = true;\n // rest onended function\n this.onended = function() {\n this.partStep = 0;\n };\n var t = time || 0;\n this.start(t);\n };\n\n /**\n * Tell the part to stop looping.\n *\n * @method noLoop\n * @for p5.Part\n */\n p5.Part.prototype.noLoop = function() {\n this.looping = false;\n // rest onended function\n this.onended = function() {\n this.stop();\n };\n };\n\n /**\n * Stop the part and cue it to step 0. Playback will resume from the begining of the Part when it is played again.\n *\n * @method stop\n * @for p5.Part\n * @param {Number} [time] seconds from now\n */\n p5.Part.prototype.stop = function(time) {\n this.partStep = 0;\n this.pause(time);\n };\n\n /**\n * Pause the part. Playback will resume\n * from the current step.\n *\n * @method pause\n * @for p5.Part\n * @param {Number} time seconds from now\n */\n p5.Part.prototype.pause = function(time) {\n this.isPlaying = false;\n var t = time || 0;\n this.metro.stop(t);\n };\n\n /**\n * Add a p5.Phrase to this Part.\n *\n * @method addPhrase\n * @for p5.Part\n * @param {p5.Phrase} phrase reference to a p5.Phrase\n */\n p5.Part.prototype.addPhrase = function(name, callback, array) {\n var p;\n if (arguments.length === 3) {\n p = new p5.Phrase(name, callback, array);\n } else if (arguments[0] instanceof p5.Phrase) {\n p = arguments[0];\n } else {\n throw 'invalid input. addPhrase accepts name, callback, array or a p5.Phrase';\n }\n this.phrases.push(p);\n // reset the length if phrase is longer than part's existing length\n if (p.sequence.length > this.length) {\n this.length = p.sequence.length;\n }\n };\n\n /**\n * Remove a phrase from this part, based on the name it was\n * given when it was created.\n *\n * @method removePhrase\n * @for p5.Part\n * @param {String} phraseName\n */\n p5.Part.prototype.removePhrase = function(name) {\n for (var i in this.phrases) {\n if (this.phrases[i].name === name) {\n this.phrases.splice(i, 1);\n }\n }\n };\n\n /**\n * Get a phrase from this part, based on the name it was\n * given when it was created. Now you can modify its array.\n *\n * @method getPhrase\n * @for p5.Part\n * @param {String} phraseName\n */\n p5.Part.prototype.getPhrase = function(name) {\n for (var i in this.phrases) {\n if (this.phrases[i].name === name) {\n return this.phrases[i];\n }\n }\n };\n\n /**\n * Find all sequences with the specified name, and replace their patterns with the specified array.\n *\n * @method replaceSequence\n * @for p5.Part\n * @param {String} phraseName\n * @param {Array} sequence Array of values to pass into the callback\n * at each step of the phrase.\n */\n p5.Part.prototype.replaceSequence = function(name, array) {\n for (var i in this.phrases) {\n if (this.phrases[i].name === name) {\n this.phrases[i].sequence = array;\n }\n }\n };\n\n p5.Part.prototype.incrementStep = function(time) {\n if (this.partStep < this.length - 1) {\n this.callback(time);\n this.partStep += 1;\n } else {\n if (!this.looping && this.partStep === this.length - 1) {\n // this.callback(time);\n this.onended();\n }\n }\n };\n\n /**\n * Set the function that will be called at every step. This will clear the previous function.\n *\n * @method onStep\n * @for p5.Part\n * @param {Function} callback The name of the callback\n * you want to fire\n * on every beat/tatum.\n */\n p5.Part.prototype.onStep = function(callback) {\n this.callback = callback;\n };\n\n\n // ===============\n // p5.Score\n // ===============\n\n /**\n * A Score consists of a series of Parts. The parts will\n * be played back in order. For example, you could have an\n * A part, a B part, and a C part, and play them back in this order\n * new p5.Score(a, a, b, a, c)\n *\n * @class p5.Score\n * @constructor\n * @param {p5.Part} [...parts] One or multiple parts, to be played in sequence.\n */\n p5.Score = function() {\n // for all of the arguments\n this.parts = [];\n this.currentPart = 0;\n\n var thisScore = this;\n for (var i in arguments) {\n if (arguments[i] && this.parts[i]) {\n this.parts[i] = arguments[i];\n this.parts[i].nextPart = this.parts[i + 1];\n this.parts[i].onended = function() {\n thisScore.resetPart(i);\n playNextPart(thisScore);\n };\n }\n }\n this.looping = false;\n };\n\n p5.Score.prototype.onended = function() {\n if (this.looping) {\n // this.resetParts();\n this.parts[0].start();\n } else {\n this.parts[this.parts.length - 1].onended = function() {\n this.stop();\n this.resetParts();\n };\n }\n this.currentPart = 0;\n };\n\n /**\n * Start playback of the score.\n *\n * @method start\n * @for p5.Score\n */\n p5.Score.prototype.start = function() {\n this.parts[this.currentPart].start();\n this.scoreStep = 0;\n };\n\n /**\n * Stop playback of the score.\n *\n * @method stop\n * @for p5.Score\n */\n p5.Score.prototype.stop = function() {\n this.parts[this.currentPart].stop();\n this.currentPart = 0;\n this.scoreStep = 0;\n };\n\n /**\n * Pause playback of the score.\n *\n * @method pause\n * @for p5.Score\n */\n p5.Score.prototype.pause = function() {\n this.parts[this.currentPart].stop();\n };\n\n /**\n * Loop playback of the score.\n *\n * @method loop\n * @for p5.Score\n */\n p5.Score.prototype.loop = function() {\n this.looping = true;\n this.start();\n };\n\n /**\n * Stop looping playback of the score. If it\n * is currently playing, this will go into effect\n * after the current round of playback completes.\n *\n * @method noLoop\n * @for p5.Score\n */\n p5.Score.prototype.noLoop = function() {\n this.looping = false;\n };\n\n p5.Score.prototype.resetParts = function() {\n var self = this;\n this.parts.forEach(function(part) {\n self.resetParts[part];\n });\n };\n\n p5.Score.prototype.resetPart = function(i) {\n this.parts[i].stop();\n this.parts[i].partStep = 0;\n for (var p in this.parts[i].phrases) {\n if (this.parts[i]) {\n this.parts[i].phrases[p].phraseStep = 0;\n }\n }\n };\n\n /**\n * Set the tempo for all parts in the score\n *\n * @method setBPM\n * @for p5.Score\n * @param {Number} BPM Beats Per Minute\n * @param {Number} rampTime Seconds from now\n */\n p5.Score.prototype.setBPM = function(bpm, rampTime) {\n for (var i in this.parts) {\n if (this.parts[i]) {\n this.parts[i].setBPM(bpm, rampTime);\n }\n }\n };\n\n function playNextPart(aScore) {\n aScore.currentPart++;\n if (aScore.currentPart >= aScore.parts.length) {\n aScore.scoreStep = 0;\n aScore.onended();\n } else {\n aScore.scoreStep = 0;\n aScore.parts[aScore.currentPart - 1].stop();\n aScore.parts[aScore.currentPart].start();\n }\n }\n\n});\n","'use strict';\n\ndefine(function (require) {\n var p5sound = require('master');\n var Clock = require('Tone/core/Clock');\n\n /**\n * SoundLoop\n *\n * @class p5.SoundLoop\n * @constructor\n *\n * @param {Function} callback this function will be called on each iteration of theloop\n * @param {Number|String} [interval] amount of time (if a number) or beats (if a string, following Tone.Time convention) for each iteration of the loop. Defaults to 1 second.\n *\n * @example\n *
\n * let synth, soundLoop;\n * let notePattern = [60, 62, 64, 67, 69, 72];\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * colorMode(HSB);\n * background(0, 0, 86);\n * text('tap to start/stop', 10, 20);\n *\n * //the looper's callback is passed the timeFromNow\n * //this value should be used as a reference point from\n * //which to schedule sounds\n * let intervalInSeconds = 0.2;\n * soundLoop = new p5.SoundLoop(onSoundLoop, intervalInSeconds);\n *\n * synth = new p5.MonoSynth();\n * }\n *\n * function canvasPressed() {\n * // ensure audio is enabled\n * userStartAudio();\n *\n * if (soundLoop.isPlaying) {\n * soundLoop.stop();\n * } else {\n * // start the loop\n * soundLoop.start();\n * }\n * }\n *\n * function onSoundLoop(timeFromNow) {\n * let noteIndex = (soundLoop.iterations - 1) % notePattern.length;\n * let note = midiToFreq(notePattern[noteIndex]);\n * synth.play(note, 0.5, timeFromNow);\n * background(noteIndex * 360 / notePattern.length, 50, 100);\n * }\n *
\n */\n p5.SoundLoop = function(callback, interval) {\n this.callback = callback;\n /**\n * musicalTimeMode uses Tone.Time convention\n * true if string, false if number\n * @property {Boolean} musicalTimeMode\n */\n this.musicalTimeMode = typeof this._interval === 'number' ? false : true;\n\n this._interval = interval || 1;\n\n /**\n * musicalTimeMode variables\n * modify these only when the interval is specified in musicalTime format as a string\n */\n this._timeSignature = 4;\n this._bpm = 60;\n\n this.isPlaying = false;\n\n /**\n * Set a limit to the number of loops to play. defaults to Infinity\n * @property {Number} maxIterations\n */\n this.maxIterations = Infinity;\n var self = this;\n\n this.clock = new Clock({\n 'callback' : function(time) {\n var timeFromNow = time - p5sound.audiocontext.currentTime;\n /**\n * Do not initiate the callback if timeFromNow is < 0\n * This ususually occurs for a few milliseconds when the page\n * is not fully loaded\n *\n * The callback should only be called until maxIterations is reached\n */\n if (timeFromNow > 0 && self.iterations <= self.maxIterations) {\n self.callback(timeFromNow);}\n },\n 'frequency' : this._calcFreq()\n });\n };\n\n /**\n * Start the loop\n * @method start\n * @for p5.SoundLoop\n * @param {Number} [timeFromNow] schedule a starting time\n */\n p5.SoundLoop.prototype.start = function(timeFromNow) {\n var t = timeFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n if (!this.isPlaying) {\n this.clock.start(now + t);\n this.isPlaying = true;\n }\n };\n\n /**\n * Stop the loop\n * @method stop\n * @for p5.SoundLoop\n * @param {Number} [timeFromNow] schedule a stopping time\n */\n p5.SoundLoop.prototype.stop = function(timeFromNow) {\n var t = timeFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n if (this.isPlaying) {\n this.clock.stop(now + t);\n this.isPlaying = false;\n }\n };\n /**\n * Pause the loop\n * @method pause\n * @for p5.SoundLoop\n * @param {Number} [timeFromNow] schedule a pausing time\n */\n p5.SoundLoop.prototype.pause = function(timeFromNow) {\n var t = timeFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n if (this.isPlaying) {\n this.clock.pause(now + t);\n this.isPlaying = false;\n }\n };\n\n\n /**\n * Synchronize loops. Use this method to start two more more loops in synchronization\n * or to start a loop in synchronization with a loop that is already playing\n * This method will schedule the implicit loop in sync with the explicit master loop\n * i.e. loopToStart.syncedStart(loopToSyncWith)\n *\n * @method syncedStart\n * @for p5.SoundLoop\n * @param {Object} otherLoop a p5.SoundLoop to sync with\n * @param {Number} [timeFromNow] Start the loops in sync after timeFromNow seconds\n */\n p5.SoundLoop.prototype.syncedStart = function(otherLoop, timeFromNow) {\n var t = timeFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n\n if (!otherLoop.isPlaying) {\n otherLoop.clock.start(now + t);\n otherLoop.isPlaying = true;\n this.clock.start(now + t);\n this.isPlaying = true;\n } else if (otherLoop.isPlaying) {\n var time = otherLoop.clock._nextTick - p5sound.audiocontext.currentTime;\n this.clock.start(now + time);\n this.isPlaying = true;\n }\n };\n\n\n /**\n * Updates frequency value, reflected in next callback\n * @private\n * @for p5.SoundLoop\n * @method _update\n */\n p5.SoundLoop.prototype._update = function() {\n this.clock.frequency.value = this._calcFreq();\n };\n\n /**\n * Calculate the frequency of the clock's callback based on bpm, interval, and timesignature\n * @private\n * @for p5.SoundLoop\n * @method _calcFreq\n * @return {Number} new clock frequency value\n */\n p5.SoundLoop.prototype._calcFreq = function() {\n //Seconds mode, bpm / timesignature has no effect\n if (typeof this._interval === 'number') {\n this.musicalTimeMode = false;\n return 1 / this._interval;\n }\n //Musical timing mode, calculate interval based bpm, interval,and time signature\n else if (typeof this._interval === 'string') {\n this.musicalTimeMode = true;\n return this._bpm / 60 / this._convertNotation(this._interval) * (this._timeSignature / 4);\n }\n };\n\n /**\n * Convert notation from musical time format to seconds\n * Uses Tone.Time convention\n * @private\n * @for p5.SoundLoop\n * @method _convertNotation\n * @param {String} value value to be converted\n * @return {Number} converted value in seconds\n */\n p5.SoundLoop.prototype._convertNotation = function(value) {\n var type = value.slice(-1);\n value = Number(value.slice(0,-1));\n switch (type) {\n case 'm':\n return this._measure(value);\n case 'n':\n return this._note(value);\n default:\n console.warn('Specified interval is not formatted correctly. See Tone.js '+\n 'timing reference for more info: https://github.com/Tonejs/Tone.js/wiki/Time');\n }\n };\n\n /**\n * Helper conversion methods of measure and note\n * @private\n * @for p5.SoundLoop\n * @method _measure\n */\n p5.SoundLoop.prototype._measure = function(value) {\n return value * this._timeSignature;\n };\n\n /**\n * @private\n * @method _note\n * @for p5.SoundLoop\n */\n p5.SoundLoop.prototype._note = function(value) {\n return this._timeSignature / value ;\n };\n\n\n /**\n * Getters and Setters, setting any paramter will result in a change in the clock's\n * frequency, that will be reflected after the next callback\n * beats per minute (defaults to 60)\n * @property {Number} bpm\n * @for p5.SoundLoop\n */\n Object.defineProperty(p5.SoundLoop.prototype, 'bpm', {\n get : function() {\n return this._bpm;\n },\n set : function(bpm) {\n if (!this.musicalTimeMode) {\n console.warn('Changing the BPM in \"seconds\" mode has no effect. '+\n 'BPM is only relevant in musicalTimeMode '+\n 'when the interval is specified as a string '+\n '(\"2n\", \"4n\", \"1m\"...etc)');\n }\n this._bpm = bpm;\n this._update();\n }\n });\n\n /**\n * number of quarter notes in a measure (defaults to 4)\n * @property {Number} timeSignature\n * @for p5.SoundLoop\n */\n Object.defineProperty(p5.SoundLoop.prototype, 'timeSignature', {\n get : function() {\n return this._timeSignature;\n },\n set : function(timeSig) {\n if (!this.musicalTimeMode) {\n console.warn('Changing the timeSignature in \"seconds\" mode has no effect. '+\n 'BPM is only relevant in musicalTimeMode '+\n 'when the interval is specified as a string '+\n '(\"2n\", \"4n\", \"1m\"...etc)');\n }\n this._timeSignature = timeSig;\n this._update();\n }\n });\n\n /**\n * length of the loops interval\n * @property {Number|String} interval\n * @for p5.SoundLoop\n */\n Object.defineProperty(p5.SoundLoop.prototype, 'interval', {\n get : function() {\n return this._interval;\n },\n set : function(interval) {\n this.musicalTimeMode = typeof interval === 'Number'? false : true;\n this._interval = interval;\n this._update();\n }\n });\n\n /**\n * how many times the callback has been called so far\n * @property {Number} iterations\n * @for p5.SoundLoop\n * @readonly\n */\n Object.defineProperty(p5.SoundLoop.prototype, 'iterations', {\n get : function() {\n return this.clock.ticks;\n }\n });\n\n return p5.SoundLoop;\n});\n","define(function (require) {\n\t'use strict';\n\n\tvar p5sound = require('master');\n\tvar Effect = require('effect');\n var CustomError = require('errorHandler');\n\n /**\n * Compressor is an audio effect class that performs dynamics compression\n * on an audio input source. This is a very commonly used technique in music\n * and sound production. Compression creates an overall louder, richer,\n * and fuller sound by lowering the volume of louds and raising that of softs.\n * Compression can be used to avoid clipping (sound distortion due to\n * peaks in volume) and is especially useful when many sounds are played\n * at once. Compression can be used on indivudal sound sources in addition\n * to the master output.\n *\n * This class extends p5.Effect.\n * Methods amp(), chain(),\n * drywet(), connect(), and\n * disconnect() are available.\n *\n * @class p5.Compressor\n * @constructor\n * @extends p5.Effect\n *\n *\n */\n\tp5.Compressor = function() {\n\t\tEffect.call(this);\n\n /**\n * The p5.Compressor is built with a Web Audio Dynamics Compressor Node\n * \n * @property {AudioNode} compressor\n */\n\n\n\t\tthis.compressor = this.ac.createDynamicsCompressor();\n\n this.input.connect(this.compressor);\n this.compressor.connect(this.wet);\n\t};\n\n\tp5.Compressor.prototype = Object.create(Effect.prototype);\n\n /**\n * Performs the same function as .connect, but also accepts\n * optional parameters to set compressor's audioParams\n * @method process\n * @for p5.Compressor\n *\n * @param {Object} src Sound source to be connected\n *\n * @param {Number} [attack] The amount of time (in seconds) to reduce the gain by 10dB,\n * default = .003, range 0 - 1\n * @param {Number} [knee] A decibel value representing the range above the\n * threshold where the curve smoothly transitions to the \"ratio\" portion.\n * default = 30, range 0 - 40\n * @param {Number} [ratio] The amount of dB change in input for a 1 dB change in output\n * default = 12, range 1 - 20\n * @param {Number} [threshold] The decibel value above which the compression will start taking effect\n * default = -24, range -100 - 0\n * @param {Number} [release] The amount of time (in seconds) to increase the gain by 10dB\n * default = .25, range 0 - 1\n */\n\tp5.Compressor.prototype.process = function(src, attack, knee,\n ratio, threshold, release) {\n\t\tsrc.connect(this.input);\n\t\tthis.set(attack, knee, ratio, threshold, release);\n\t};\n\n /**\n * Set the paramters of a compressor.\n * @method set\n * @for p5.Compressor\n * @param {Number} attack The amount of time (in seconds) to reduce the gain by 10dB,\n * default = .003, range 0 - 1\n * @param {Number} knee A decibel value representing the range above the\n * threshold where the curve smoothly transitions to the \"ratio\" portion.\n * default = 30, range 0 - 40\n * @param {Number} ratio The amount of dB change in input for a 1 dB change in output\n * default = 12, range 1 - 20\n * @param {Number} threshold The decibel value above which the compression will start taking effect\n * default = -24, range -100 - 0\n * @param {Number} release The amount of time (in seconds) to increase the gain by 10dB\n * default = .25, range 0 - 1\n */\n p5.Compressor.prototype.set = function (attack, knee,\n ratio, threshold, release) {\n\n if (typeof attack !== 'undefined') {this.attack(attack);}\n if (typeof knee !== 'undefined') {this.knee(knee);}\n if (typeof ratio !== 'undefined') {this.ratio(ratio);}\n if (typeof threshold !== 'undefined') {this.threshold(threshold);}\n if (typeof release !== 'undefined') {this.release(release);}\n };\n\n\n /**\n * Get current attack or set value w/ time ramp\n *\n *\n * @method attack\n * @for p5.Compressor\n * @param {Number} [attack] Attack is the amount of time (in seconds) to reduce the gain by 10dB,\n * default = .003, range 0 - 1\n * @param {Number} [time] Assign time value to schedule the change in value\n */\n p5.Compressor.prototype.attack = function (attack, time){\n var t = time || 0;\n if (typeof attack == 'number'){\n this.compressor.attack.value = attack;\n this.compressor.attack.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.compressor.attack.linearRampToValueAtTime(attack, this.ac.currentTime + 0.02 + t);\n } else if (typeof attack !== 'undefined') {\n attack.connect(this.compressor.attack);\n }\n return this.compressor.attack.value;\n };\n\n\n /**\n * Get current knee or set value w/ time ramp\n *\n * @method knee\n * @for p5.Compressor\n * @param {Number} [knee] A decibel value representing the range above the\n * threshold where the curve smoothly transitions to the \"ratio\" portion.\n * default = 30, range 0 - 40\n * @param {Number} [time] Assign time value to schedule the change in value\n */\n p5.Compressor.prototype.knee = function (knee, time){\n var t = time || 0;\n if (typeof knee == 'number'){\n this.compressor.knee.value = knee;\n this.compressor.knee.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.compressor.knee.linearRampToValueAtTime(knee, this.ac.currentTime + 0.02 + t);\n } else if (typeof knee !== 'undefined') {\n knee.connect(this.compressor.knee);\n }\n return this.compressor.knee.value;\n };\n\n\n /**\n * Get current ratio or set value w/ time ramp\n * @method ratio\n * @for p5.Compressor\n * @param {Number} [ratio] The amount of dB change in input for a 1 dB change in output\n * default = 12, range 1 - 20\n * @param {Number} [time] Assign time value to schedule the change in value\n */\n p5.Compressor.prototype.ratio = function (ratio, time){\n var t = time || 0;\n if (typeof ratio == 'number'){\n this.compressor.ratio.value = ratio;\n this.compressor.ratio.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.compressor.ratio.linearRampToValueAtTime(ratio, this.ac.currentTime + 0.02 + t);\n } else if (typeof ratio !== 'undefined') {\n ratio.connect(this.compressor.ratio);\n }\n return this.compressor.ratio.value;\n };\n\n\n /**\n * Get current threshold or set value w/ time ramp\n * @method threshold\n * @for p5.Compressor\n * @param {Number} threshold The decibel value above which the compression will start taking effect\n * default = -24, range -100 - 0\n * @param {Number} [time] Assign time value to schedule the change in value\n */\n p5.Compressor.prototype.threshold = function (threshold, time){\n var t = time || 0;\n if (typeof threshold == 'number'){\n this.compressor.threshold.value = threshold;\n this.compressor.threshold.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.compressor.threshold.linearRampToValueAtTime(threshold, this.ac.currentTime + 0.02 + t);\n } else if (typeof threshold !== 'undefined') {\n threshold.connect(this.compressor.threshold);\n }\n return this.compressor.threshold.value;\n };\n\n\n /**\n * Get current release or set value w/ time ramp\n * @method release\n * @for p5.Compressor\n * @param {Number} release The amount of time (in seconds) to increase the gain by 10dB\n * default = .25, range 0 - 1\n *\n * @param {Number} [time] Assign time value to schedule the change in value\n */\n p5.Compressor.prototype.release = function (release, time){\n var t = time || 0;\n if (typeof release == 'number'){\n this.compressor.release.value = release;\n this.compressor.release.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.compressor.release.linearRampToValueAtTime(release, this.ac.currentTime + 0.02 + t);\n } else if (typeof number !== 'undefined') {\n release.connect(this.compressor.release);\n }\n return this.compressor.release.value;\n };\n\n /**\n * Return the current reduction value\n *\n * @method reduction\n * @for p5.Compressor\n * @return {Number} Value of the amount of gain reduction that is applied to the signal\n */\n p5.Compressor.prototype.reduction =function() {\n return this.compressor.reduction.value;\n };\n\n\n\tp5.Compressor.prototype.dispose = function() {\n Effect.prototype.dispose.apply(this);\n if (this.compressor) {\n this.compressor.disconnect();\n delete this.compressor;\n }\n\t};\n\n return p5.Compressor;\n});\n","'use strict';\n\ndefine(function (require) {\n\n // inspiration: recorder.js, Tone.js & typedarray.org\n\n const p5sound = require('master');\n const { convertToWav, safeBufferSize } = require('helpers');\n const processorNames = require('./audioWorklet/processorNames');\n const ac = p5sound.audiocontext;\n\n /**\n *

Record sounds for playback and/or to save as a .wav file.\n * The p5.SoundRecorder records all sound output from your sketch,\n * or can be assigned a specific source with setInput().

\n *

The record() method accepts a p5.SoundFile as a parameter.\n * When playback is stopped (either after the given amount of time,\n * or with the stop() method), the p5.SoundRecorder will send its\n * recording to that p5.SoundFile for playback.

\n *\n * @class p5.SoundRecorder\n * @constructor\n * @example\n *
\n * let mic, recorder, soundFile;\n * let state = 0;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * textAlign(CENTER, CENTER);\n *\n * // create an audio in\n * mic = new p5.AudioIn();\n *\n * // prompts user to enable their browser mic\n * mic.start();\n *\n * // create a sound recorder\n * recorder = new p5.SoundRecorder();\n *\n * // connect the mic to the recorder\n * recorder.setInput(mic);\n *\n * // this sound file will be used to\n * // playback & save the recording\n * soundFile = new p5.SoundFile();\n *\n * text('tap to record', width/2, height/2);\n * }\n *\n * function canvasPressed() {\n * // ensure audio is enabled\n * userStartAudio();\n *\n * // make sure user enabled the mic\n * if (state === 0 && mic.enabled) {\n *\n * // record to our p5.SoundFile\n * recorder.record(soundFile);\n *\n * background(255,0,0);\n * text('Recording!', width/2, height/2);\n * state++;\n * }\n * else if (state === 1) {\n * background(0,255,0);\n *\n * // stop recorder and\n * // send result to soundFile\n * recorder.stop();\n *\n * text('Done! Tap to play and download', width/2, height/2, width - 20);\n * state++;\n * }\n *\n * else if (state === 2) {\n * soundFile.play(); // play the result!\n * save(soundFile, 'mySound.wav');\n * state++;\n * }\n * }\n *
\n */\n p5.SoundRecorder = function() {\n this.input = ac.createGain();\n this.output = ac.createGain();\n\n this._inputChannels = 2;\n this._outputChannels = 2; // stereo output, even if input is mono\n\n const workletBufferSize = safeBufferSize(1024);\n\n this._workletNode = new AudioWorkletNode(ac, processorNames.recorderProcessor, {\n outputChannelCount: [this._outputChannels],\n processorOptions: {\n numInputChannels: this._inputChannels,\n bufferSize: workletBufferSize\n }\n });\n\n this._workletNode.port.onmessage = function(event) {\n if (event.data.name === 'buffers') {\n const buffers = [\n new Float32Array(event.data.leftBuffer),\n new Float32Array(event.data.rightBuffer)\n ];\n this._callback(buffers);\n }\n }.bind(this);\n\n /**\n * callback invoked when the recording is over\n * @private\n * @type Function(Float32Array)\n */\n this._callback = function() {};\n\n // connections\n this._workletNode.connect(p5.soundOut._silentNode);\n this.setInput();\n\n // add this p5.SoundFile to the soundArray\n p5sound.soundArray.push(this);\n };\n\n /**\n * Connect a specific device to the p5.SoundRecorder.\n * If no parameter is given, p5.SoundRecorer will record\n * all audible p5.sound from your sketch.\n *\n * @method setInput\n * @for p5.SoundRecorder\n * @param {Object} [unit] p5.sound object or a web audio unit\n * that outputs sound\n */\n p5.SoundRecorder.prototype.setInput = function(unit) {\n this.input.disconnect();\n this.input = null;\n this.input = ac.createGain();\n this.input.connect(this._workletNode);\n this.input.connect(this.output);\n if (unit) {\n unit.connect(this.input);\n } else {\n p5.soundOut.output.connect(this.input);\n }\n };\n\n /**\n * Start recording. To access the recording, provide\n * a p5.SoundFile as the first parameter. The p5.SoundRecorder\n * will send its recording to that p5.SoundFile for playback once\n * recording is complete. Optional parameters include duration\n * (in seconds) of the recording, and a callback function that\n * will be called once the complete recording has been\n * transfered to the p5.SoundFile.\n *\n * @method record\n * @for p5.SoundRecorder\n * @param {p5.SoundFile} soundFile p5.SoundFile\n * @param {Number} [duration] Time (in seconds)\n * @param {Function} [callback] The name of a function that will be\n * called once the recording completes\n */\n p5.SoundRecorder.prototype.record = function(sFile, duration, callback) {\n this._workletNode.port.postMessage({ name: 'start', duration: duration });\n\n if (sFile && callback) {\n this._callback = function(buffer) {\n sFile.setBuffer(buffer);\n callback();\n };\n }\n else if (sFile) {\n this._callback = function(buffer) {\n sFile.setBuffer(buffer);\n };\n }\n };\n\n /**\n * Stop the recording. Once the recording is stopped,\n * the results will be sent to the p5.SoundFile that\n * was given on .record(), and if a callback function\n * was provided on record, that function will be called.\n *\n * @method stop\n * @for p5.SoundRecorder\n */\n p5.SoundRecorder.prototype.stop = function() {\n this._workletNode.port.postMessage({ name: 'stop' });\n };\n\n p5.SoundRecorder.prototype.dispose = function() {\n // remove reference from soundArray\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n\n this._callback = function() {};\n if (this.input) {\n this.input.disconnect();\n }\n this.input = null;\n this._workletNode = null;\n };\n\n\n /**\n * Save a p5.SoundFile as a .wav file. The browser will prompt the user\n * to download the file to their device.\n * For uploading audio to a server, use\n * `p5.SoundFile.saveBlob`.\n *\n * @for p5\n * @method saveSound\n * @param {p5.SoundFile} soundFile p5.SoundFile that you wish to save\n * @param {String} fileName name of the resulting .wav file.\n */\n // add to p5.prototype as this is used by the p5 `save()` method.\n p5.prototype.saveSound = function (soundFile, fileName) {\n const dataView = convertToWav(soundFile.buffer);\n p5.prototype.writeFile([dataView], fileName, 'wav');\n };\n});\n","'use strict';\n\ndefine(function () {\n /**\n *

PeakDetect works in conjunction with p5.FFT to\n * look for onsets in some or all of the frequency spectrum.\n *

\n *

\n * To use p5.PeakDetect, call update in the draw loop\n * and pass in a p5.FFT object.\n *

\n *

\n * You can listen for a specific part of the frequency spectrum by\n * setting the range between freq1 and freq2.\n *

\n *\n *

threshold is the threshold for detecting a peak,\n * scaled between 0 and 1. It is logarithmic, so 0.1 is half as loud\n * as 1.0.

\n *\n *

\n * The update method is meant to be run in the draw loop, and\n * frames determines how many loops must pass before\n * another peak can be detected.\n * For example, if the frameRate() = 60, you could detect the beat of a\n * 120 beat-per-minute song with this equation:\n * framesPerPeak = 60 / (estimatedBPM / 60 );\n *

\n *\n *

\n * Based on example contribtued by @b2renger, and a simple beat detection\n * explanation by Felix Turner.\n *

\n *\n * @class p5.PeakDetect\n * @constructor\n * @param {Number} [freq1] lowFrequency - defaults to 20Hz\n * @param {Number} [freq2] highFrequency - defaults to 20000 Hz\n * @param {Number} [threshold] Threshold for detecting a beat between 0 and 1\n * scaled logarithmically where 0.1 is 1/2 the loudness\n * of 1.0. Defaults to 0.35.\n * @param {Number} [framesPerPeak] Defaults to 20.\n * @example\n *
\n *\n * var cnv, soundFile, fft, peakDetect;\n * var ellipseWidth = 10;\n *\n * function preload() {\n * soundFile = loadSound('assets/beat.mp3');\n * }\n *\n * function setup() {\n * background(0);\n * noStroke();\n * fill(255);\n * textAlign(CENTER);\n *\n * // p5.PeakDetect requires a p5.FFT\n * fft = new p5.FFT();\n * peakDetect = new p5.PeakDetect();\n * }\n *\n * function draw() {\n * background(0);\n * text('click to play/pause', width/2, height/2);\n *\n * // peakDetect accepts an fft post-analysis\n * fft.analyze();\n * peakDetect.update(fft);\n *\n * if ( peakDetect.isDetected ) {\n * ellipseWidth = 50;\n * } else {\n * ellipseWidth *= 0.95;\n * }\n *\n * ellipse(width/2, height/2, ellipseWidth, ellipseWidth);\n * }\n *\n * // toggle play/stop when canvas is clicked\n * function mouseClicked() {\n * if (mouseX > 0 && mouseX < width && mouseY > 0 && mouseY < height) {\n * if (soundFile.isPlaying() ) {\n * soundFile.stop();\n * } else {\n * soundFile.play();\n * }\n * }\n * }\n *
\n */\n p5.PeakDetect = function(freq1, freq2, threshold, _framesPerPeak) {\n // framesPerPeak determines how often to look for a beat.\n // If a beat is provided, try to look for a beat based on bpm\n this.framesPerPeak = _framesPerPeak || 20;\n this.framesSinceLastPeak = 0;\n this.decayRate = 0.95;\n\n this.threshold = threshold || 0.35;\n this.cutoff = 0;\n\n // how much to increase the cutoff\n // TO DO: document this / figure out how to make it accessible\n this.cutoffMult = 1.5;\n\n this.energy = 0;\n this.penergy = 0;\n\n // TO DO: document this property / figure out how to make it accessible\n this.currentValue = 0;\n\n /**\n * isDetected is set to true when a peak is detected.\n *\n * @attribute isDetected {Boolean}\n * @default false\n */\n this.isDetected = false;\n\n this.f1 = freq1 || 40;\n this.f2 = freq2 || 20000;\n\n // function to call when a peak is detected\n this._onPeak = function() {};\n };\n\n\n /**\n * The update method is run in the draw loop.\n *\n * Accepts an FFT object. You must call .analyze()\n * on the FFT object prior to updating the peakDetect\n * because it relies on a completed FFT analysis.\n *\n * @method update\n * @param {p5.FFT} fftObject A p5.FFT object\n */\n p5.PeakDetect.prototype.update = function(fftObject) {\n var nrg = this.energy = fftObject.getEnergy(this.f1,this.f2)/255;\n if (nrg > this.cutoff && nrg > this.threshold && nrg-this.penergy > 0) {\n\n // trigger callback\n this._onPeak();\n this.isDetected = true;\n\n // debounce\n this.cutoff = nrg * this.cutoffMult;\n this.framesSinceLastPeak = 0;\n } else {\n this.isDetected = false;\n if (this.framesSinceLastPeak <= this.framesPerPeak) {\n this.framesSinceLastPeak++;\n } else {\n this.cutoff *= this.decayRate;\n this.cutoff = Math.max(this.cutoff, this.threshold);\n }\n }\n\n this.currentValue = nrg;\n this.penergy = nrg;\n };\n\n /**\n * onPeak accepts two arguments: a function to call when\n * a peak is detected. The value of the peak,\n * between 0.0 and 1.0, is passed to the callback.\n *\n * @method onPeak\n * @param {Function} callback Name of a function that will\n * be called when a peak is\n * detected.\n * @param {Object} [val] Optional value to pass\n * into the function when\n * a peak is detected.\n * @example\n *
\n * var cnv, soundFile, fft, peakDetect;\n * var ellipseWidth = 0;\n *\n * function preload() {\n * soundFile = loadSound('assets/beat.mp3');\n * }\n *\n * function setup() {\n * cnv = createCanvas(100,100);\n * textAlign(CENTER);\n *\n * fft = new p5.FFT();\n * peakDetect = new p5.PeakDetect();\n *\n * setupSound();\n *\n * // when a beat is detected, call triggerBeat()\n * peakDetect.onPeak(triggerBeat);\n * }\n *\n * function draw() {\n * background(0);\n * fill(255);\n * text('click to play', width/2, height/2);\n *\n * fft.analyze();\n * peakDetect.update(fft);\n *\n * ellipseWidth *= 0.95;\n * ellipse(width/2, height/2, ellipseWidth, ellipseWidth);\n * }\n *\n * // this function is called by peakDetect.onPeak\n * function triggerBeat() {\n * ellipseWidth = 50;\n * }\n *\n * // mouseclick starts/stops sound\n * function setupSound() {\n * cnv.mouseClicked( function() {\n * if (soundFile.isPlaying() ) {\n * soundFile.stop();\n * } else {\n * soundFile.play();\n * }\n * });\n * }\n *
\n */\n p5.PeakDetect.prototype.onPeak = function(callback, val) {\n var self = this;\n\n self._onPeak = function() {\n callback(self.energy, val);\n };\n };\n\n});\n","'use strict';\n\ndefine(function (require) {\n var p5sound = require('master');\n\n /**\n * A gain node is usefull to set the relative volume of sound.\n * It's typically used to build mixers.\n *\n * @class p5.Gain\n * @constructor\n * @example\n *
\n *\n * // load two soundfile and crossfade beetween them\n * let sound1,sound2;\n * let sound1Gain, sound2Gain, masterGain;\n * function preload(){\n * soundFormats('ogg', 'mp3');\n * sound1 = loadSound('assets/Damscray_-_Dancing_Tiger_01');\n * sound2 = loadSound('assets/beat');\n * }\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(startSound);\n * // create a 'master' gain to which we will connect both soundfiles\n * masterGain = new p5.Gain();\n * masterGain.connect();\n * sound1.disconnect(); // diconnect from p5 output\n * sound1Gain = new p5.Gain(); // setup a gain node\n * sound1Gain.setInput(sound1); // connect the first sound to its input\n * sound1Gain.connect(masterGain); // connect its output to the 'master'\n * sound2.disconnect();\n * sound2Gain = new p5.Gain();\n * sound2Gain.setInput(sound2);\n * sound2Gain.connect(masterGain);\n * }\n * function startSound() {\n * sound1.loop();\n * sound2.loop();\n * loop();\n * }\n * function mouseReleased() {\n * sound1.stop();\n * sound2.stop();\n * }\n * function draw(){\n * background(220);\n * textAlign(CENTER);\n * textSize(11);\n * fill(0);\n * if (!sound1.isPlaying()) {\n * text('tap and drag to play', width/2, height/2);\n * return;\n * }\n * // map the horizontal position of the mouse to values useable for volume * control of sound1\n * var sound1Volume = constrain(map(mouseX,width,0,0,1), 0, 1);\n * var sound2Volume = 1-sound1Volume;\n * sound1Gain.amp(sound1Volume);\n * sound2Gain.amp(sound2Volume);\n * // map the vertical position of the mouse to values useable for 'master * volume control'\n * var masterVolume = constrain(map(mouseY,height,0,0,1), 0, 1);\n * masterGain.amp(masterVolume);\n * text('master', width/2, height - masterVolume * height * 0.9)\n * fill(255, 0, 255);\n * textAlign(LEFT);\n * text('sound1', 5, height - sound1Volume * height * 0.9);\n * textAlign(RIGHT);\n * text('sound2', width - 5, height - sound2Volume * height * 0.9);\n * }\n *
\n */\n\n p5.Gain = function() {\n this.ac = p5sound.audiocontext;\n\n this.input = this.ac.createGain();\n this.output = this.ac.createGain();\n\n // otherwise, Safari distorts\n this.input.gain.value = 0.5;\n this.input.connect(this.output);\n\n // add to the soundArray\n p5sound.soundArray.push(this);\n };\n\n /**\n * Connect a source to the gain node.\n *\n * @method setInput\n * @for p5.Gain\n * @param {Object} src p5.sound / Web Audio object with a sound\n * output.\n */\n\n\n p5.Gain.prototype.setInput = function(src) {\n src.connect(this.input);\n };\n\n /**\n * Send output to a p5.sound or web audio object\n *\n * @method connect\n * @for p5.Gain\n * @param {Object} unit\n */\n p5.Gain.prototype.connect = function(unit) {\n var u = unit || p5.soundOut.input;\n this.output.connect(u.input ? u.input : u);\n };\n\n /**\n * Disconnect all output.\n *\n * @method disconnect\n * @for p5.Gain\n */\n p5.Gain.prototype.disconnect = function() {\n if (this.output) {\n this.output.disconnect();\n }\n };\n\n /**\n * Set the output level of the gain node.\n *\n * @method amp\n * @for p5.Gain\n * @param {Number} volume amplitude between 0 and 1.0\n * @param {Number} [rampTime] create a fade that lasts rampTime\n * @param {Number} [timeFromNow] schedule this event to happen\n * seconds from now\n */\n p5.Gain.prototype.amp = function(vol, rampTime, tFromNow) {\n var rampTime = rampTime || 0;\n var tFromNow = tFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n var currentVol = this.output.gain.value;\n this.output.gain.cancelScheduledValues(now);\n this.output.gain.linearRampToValueAtTime(currentVol, now + tFromNow);\n this.output.gain.linearRampToValueAtTime(vol, now + tFromNow + rampTime);\n };\n\n p5.Gain.prototype.dispose = function() {\n // remove reference from soundArray\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n if (this.output) {\n this.output.disconnect();\n delete this.output;\n }\n if (this.input) {\n this.input.disconnect();\n delete this.input;\n }\n };\n\n});\n","'use strict';\n\ndefine(function (require) {\n\n var Effect = require('effect');\n\n /*\n * Adapted from [Kevin Ennis on StackOverflow](http://stackoverflow.com/questions/22312841/waveshaper-node-in-webaudio-how-to-emulate-distortion)\n */\n function makeDistortionCurve(amount) {\n var k = typeof amount === 'number' ? amount : 50;\n var numSamples = 44100;\n var curve = new Float32Array(numSamples);\n var deg = Math.PI / 180;\n var i = 0;\n var x;\n for ( ; i < numSamples; ++i ) {\n x = i * 2 / numSamples - 1;\n curve[i] = ( 3 + k ) * x * 20 * deg / ( Math.PI + k * Math.abs(x) );\n }\n return curve;\n }\n\n /**\n * A Distortion effect created with a Waveshaper Node,\n * with an approach adapted from\n * [Kevin Ennis](http://stackoverflow.com/questions/22312841/waveshaper-node-in-webaudio-how-to-emulate-distortion)\n *\n * This class extends p5.Effect.\n * Methods amp(), chain(),\n * drywet(), connect(), and\n * disconnect() are available.\n *\n * @class p5.Distortion\n * @extends p5.Effect\n * @constructor\n * @param {Number} [amount=0.25] Unbounded distortion amount.\n * Normal values range from 0-1.\n * @param {String} [oversample='none'] 'none', '2x', or '4x'.\n *\n */\n p5.Distortion = function(amount, oversample) {\n Effect.call(this);\n\n if (typeof amount === 'undefined') {\n amount = 0.25;\n } if (typeof amount !== 'number') {\n throw new Error('amount must be a number');\n } if (typeof oversample === 'undefined') {\n oversample = '2x';\n } if (typeof oversample !== 'string') {\n throw new Error('oversample must be a String');\n }\n\n var curveAmount = p5.prototype.map(amount, 0.0, 1.0, 0, 2000);\n\n /**\n * The p5.Distortion is built with a\n * \n * Web Audio WaveShaper Node.\n *\n * @property {AudioNode} WaveShaperNode\n */\n this.waveShaperNode = this.ac.createWaveShaper();\n\n this.amount = curveAmount;\n this.waveShaperNode.curve = makeDistortionCurve(curveAmount);\n this.waveShaperNode.oversample = oversample;\n\n this.input.connect(this.waveShaperNode);\n\n this.waveShaperNode.connect(this.wet);\n };\n\n p5.Distortion.prototype = Object.create(Effect.prototype);\n\n\n /**\n * Process a sound source, optionally specify amount and oversample values.\n *\n * @method process\n * @for p5.Distortion\n * @param {Number} [amount=0.25] Unbounded distortion amount.\n * Normal values range from 0-1.\n * @param {String} [oversample='none'] 'none', '2x', or '4x'.\n */\n p5.Distortion.prototype.process = function(src, amount, oversample) {\n src.connect(this.input);\n this.set(amount, oversample);\n };\n\n /**\n * Set the amount and oversample of the waveshaper distortion.\n *\n * @method set\n * @for p5.Distortion\n * @param {Number} [amount=0.25] Unbounded distortion amount.\n * Normal values range from 0-1.\n * @param {String} [oversample='none'] 'none', '2x', or '4x'.\n */\n p5.Distortion.prototype.set = function(amount, oversample) {\n if (amount) {\n var curveAmount = p5.prototype.map(amount, 0.0, 1.0, 0, 2000);\n this.amount = curveAmount;\n this.waveShaperNode.curve = makeDistortionCurve(curveAmount);\n }\n if (oversample) {\n this.waveShaperNode.oversample = oversample;\n }\n };\n\n /**\n * Return the distortion amount, typically between 0-1.\n *\n * @method getAmount\n * @for p5.Distortion\n * @return {Number} Unbounded distortion amount.\n * Normal values range from 0-1.\n */\n p5.Distortion.prototype.getAmount = function() {\n return this.amount;\n };\n\n /**\n * Return the oversampling.\n *\n * @method getOversample\n * @for p5.Distortion\n * @return {String} Oversample can either be 'none', '2x', or '4x'.\n */\n p5.Distortion.prototype.getOversample = function() {\n return this.waveShaperNode.oversample;\n };\n\n\n p5.Distortion.prototype.dispose = function() {\n Effect.prototype.dispose.apply(this);\n if (this.waveShaperNode) {\n this.waveShaperNode.disconnect();\n this.waveShaperNode = null;\n }\n };\n});\n"],"sourceRoot":""} \ No newline at end of file +{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///../node_modules/tone/Tone/core/Tone.js","webpack:///./master.js","webpack:///../node_modules/tone/Tone/signal/Signal.js","webpack:///../node_modules/tone/Tone/signal/Multiply.js","webpack:///./effect.js","webpack:///./helpers.js","webpack:///../node_modules/tone/Tone/signal/WaveShaper.js","webpack:///../node_modules/tone/Tone/signal/Add.js","webpack:///../node_modules/tone/Tone/type/Type.js","webpack:///../node_modules/tone/Tone/core/Gain.js","webpack:///./audioWorklet/processorNames.js","webpack:///./errorHandler.js","webpack:///../node_modules/tone/Tone/core/Context.js","webpack:///../node_modules/tone/Tone/signal/Scale.js","webpack:///../node_modules/tone/Tone/signal/TimelineSignal.js","webpack:///./filter.js","webpack:///../node_modules/tone/Tone/signal/Subtract.js","webpack:///./audiocontext.js","webpack:///../node_modules/tone/Tone/core/Emitter.js","webpack:///../node_modules/tone/Tone/signal/SignalBase.js","webpack:///../node_modules/tone/Tone/type/Time.js","webpack:///../node_modules/tone/Tone/type/TimeBase.js","webpack:///../node_modules/tone/Tone/core/Param.js","webpack:///./oscillator.js","webpack:///../node_modules/tone/Tone/core/Timeline.js","webpack:///../node_modules/tone/Tone/signal/Negate.js","webpack:///../node_modules/tone/Tone/signal/GreaterThanZero.js","webpack:///../node_modules/tone/Tone/core/Clock.js","webpack:///./monosynth.js","webpack:///./audioVoice.js","webpack:///./polysynth.js","webpack:///./app.js","webpack:///../node_modules/audioworklet-polyfill/dist/audioworklet-polyfill.js","webpack:///./shims.js","webpack:///../node_modules/webpack/buildin/global.js","webpack:///../node_modules/startaudiocontext/StartAudioContext.js","webpack:///./audioWorklet/index.js","webpack:///./audioWorklet/recorderProcessor.js","webpack:///./audioWorklet/soundFileProcessor.js","webpack:///./audioWorklet/amplitudeProcessor.js","webpack:///./panner.js","webpack:///./soundfile.js","webpack:///./amplitude.js","webpack:///./fft.js","webpack:///./signal.js","webpack:///../node_modules/tone/Tone/type/Frequency.js","webpack:///../node_modules/tone/Tone/type/TransportTime.js","webpack:///./envelope.js","webpack:///./pulse.js","webpack:///./noise.js","webpack:///./audioin.js","webpack:///../node_modules/tone/Tone/component/CrossFade.js","webpack:///../node_modules/tone/Tone/signal/Expr.js","webpack:///../node_modules/tone/Tone/signal/GreaterThan.js","webpack:///../node_modules/tone/Tone/signal/Abs.js","webpack:///../node_modules/tone/Tone/signal/Modulo.js","webpack:///../node_modules/tone/Tone/signal/Pow.js","webpack:///../node_modules/tone/Tone/signal/AudioToGain.js","webpack:///../node_modules/tone/Tone/signal/EqualPowerGain.js","webpack:///./eq.js","webpack:///./eqFilter.js","webpack:///./panner3d.js","webpack:///./listener3d.js","webpack:///./delay.js","webpack:///./reverb.js","webpack:///./metro.js","webpack:///../node_modules/tone/Tone/core/TimelineState.js","webpack:///./looper.js","webpack:///./soundLoop.js","webpack:///./compressor.js","webpack:///./soundRecorder.js","webpack:///./peakDetect.js","webpack:///./gain.js","webpack:///./distortion.js"],"names":["define","Tone","inputs","outputs","this","isUndef","input","context","createGain","Array","output","audioContext","prototype","set","params","value","rampTime","isObject","isString","tmpObj","paramLoop","attr","parent","indexOf","attrSplit","split","i","length","splice","innerParam","join","param","Signal","Param","rampTo","AudioParam","get","_collectDefaults","constructor","ret","subRet","j","subAttr","isFunction","constr","defaults","Object","keys","_super","superDefs","push","toString","className","isLetter","match","sameConstructor","defineProperty","isArray","dispose","AudioNode","disconnect","connect","unit","outputNum","inputNum","defaultArg","destination","isNumber","apply","arguments","connectSeries","currentUnit","toUnit","chain","fan","given","fallback","givenProp","fallbackProp","optionsObject","values","options","val","arg","call","isBoolean","noOp","_readOnly","property","writable","enumerable","_writable","State","Started","Stopped","Paused","equalPowerScale","percent","piFactor","Math","PI","sin","dbToGain","db","pow","gainToDb","gain","log","LN10","intervalToFrequencyRatio","interval","now","extend","child","TempConstructor","Context","emit","setContext","ctx","sampleRate","hasAudioContext","window","hasOwnProperty","hasPromises","hasWorkers","version","TONE_SILENCE_VERSION_LOGGING","console","audiocontext","Master","limiter","createDynamicsCompressor","threshold","ratio","knee","meter","fftMeter","soundArray","parts","extensions","p5sound","p5","getMasterVolume","masterVolume","vol","tFromNow","currentTime","currentVol","cancelScheduledValues","linearRampToValueAtTime","soundOut","_silentNode","_gain","_param","getConstant","units","Type","Default","convert","SignalBase","Multiply","createInsOuts","_mult","Gain","require","CrossFade","Effect","ac","_drywet","wet","a","b","amp","drywet","fade","u","index","undefined","processorNames","freqToMidi","f","mathlog2","m","round","midiToFreq","noteToFreq","note","wholeNotes","A","B","C","D","E","F","G","toUpperCase","octave","slice","soundFormats","toLowerCase","disposeSound","registerMethod","_checkFileFormats","paths","path","extTest","pop","isFileSupported","pathSplit","pathCore","extension","supported","p","_mathChain","o","math","thisChain","nextChain","type","mathOps","convertToWav","audioBuffer","leftChannel","rightChannel","getChannelData","numberOfChannels","interleaved","interleave","buffer","ArrayBuffer","view","DataView","writeUTFBytes","setUint32","setUint16","lng","volume","setInt16","result","Float32Array","inputIndex","offset","string","setUint8","charCodeAt","safeBufferSize","idealBufferSize","bufferSize","tempAudioWorkletNode","AudioWorkletNode","soundFileProcessor","ScriptProcessorNode","safeBins","bins","log2","WaveShaper","mapping","bufferLen","_shaper","createWaveShaper","_curve","curve","isFinite","setMap","len","normalized","oversample","oversampling","RangeError","Add","_sum","Time","Frequency","TransportTime","Ticks","NormalRange","AudioRange","Decibels","Interval","BPM","Positive","Cents","Degrees","MIDI","BarsBeatsSixteenths","Samples","Hertz","Note","Milliseconds","Seconds","Notation","toSeconds","time","TimeBase","toFrequency","freq","valueOf","toTicks","Transport","ticks","GainNode","AudioContext","createGainNode","_gainNode","module","exports","recorderProcessor","amplitudeProcessor","CustomError","name","errorTrace","failedPath","err","Error","tempStack","splitStack","originalStack","stack","filter","ln","toneConnect","outNum","inNum","nativeConnect","e","nativeDisconnect","webkitAudioContext","prop","Emitter","_context","_defineProperty","_latencyHint","_lookAhead","_updateInterval","_computedUpdateInterval","_worker","_createWorker","_constants","mixin","bind","URL","webkitURL","blob","Blob","toFixed","blobUrl","createObjectURL","worker","Worker","addEventListener","_lastUpdate","diff","max","createBuffer","arr","constant","createBufferSource","channelCount","channelCountMode","loop","start","lA","blockTime","postMessage","hint","lookAhead","latencyHint","updateInterval","warn","Scale","outputMin","outputMax","_outputMin","_outputMax","_scale","_add","_setRange","min","TimelineSignal","_events","Timeline","_initial","_fromUnits","Linear","Exponential","Target","Curve","Set","getValueAtTime","_toUnits","convertedVal","setValueAtTime","startTime","add","endTime","exponentialRampToValueAtTime","beforeEvent","_searchBefore","_minOutput","setValue","sampleTime","setTargetAtTime","timeConstant","setValueCurveAtTime","duration","scaling","floats","segmentTime","after","cancel","setRampPoint","before","_searchAfter","linearRampToValueBetween","finish","exponentialRampToValueBetween","getAfter","previouVal","previous","getBefore","_exponentialApproach","_curveInterpolate","_linearInterpolate","_exponentialInterpolate","t0","v0","v1","t","exp","t1","progress","lowerIndex","floor","upperIndex","ceil","lowerVal","upperVal","Filter","biquad","createBiquadFilter","setType","_on","_untoggledType","create","process","src","res","frequency","Q","toggle","LowPass","HighPass","BandPass","Subtract","_neg","Negate","global","StartAudioContext","getAudioContext","userStartAudio","elements","callback","elt","Element","map","on","event","events","eventName","off","ev","eventList","args","object","functions","func","emitterFunc","node","outputNumber","inputNumber","overridden","_plusNow","_unaryExpressions","quantize","regexp","method","rh","nextSubdivision","lh","subdiv","_expr","expr","subdivision","addNow","_defaultExpr","_noOp","copy","toNotation","retNotation","_toNotationHelper","retTripletNotation","testNotations","_notationToUnits","notationTime","multiple","notation","primaryExprs","_primaryExpressions","notationExprs","n","toBarsBeatsSixteenths","quarterTime","_beatsToUnits","quarters","measures","_timeSignature","sixteenths","parseFloat","PPQ","toSamples","toMilliseconds","_defaultUnits","exprString","_parseExprString","clone","instance","parseInt","_ticksToUnits","hz","_frequencyToUnits","tr","q","s","total","_secondsToUnits","samples","default","_binaryExpressions","+","precedence","-","*","/","neg","_syntaxGlue","(",")","_tokenize","position","tokens","token","getNextToken","trim","substr","expressions","group","opName","op","reg","SyntaxError","next","peek","_matchGroup","prec","test","_parseBinary","lexer","_parseUnary","_parsePrimary","matching","beats","bpm","seconds","timeSignature","_pushExpr","sub","mult","div","_lfo","lfo","LFO","currentVal","exponentialRampToValue","linearRampToValue","Mult","Oscillator","started","phaseAmount","oscillator","createOscillator","_freqMods","panPosition","connection","panner","Panner","stop","abs","freqNode","self","getAmp","isNaN","phase","getFreq","getType","oscMods","pan","pval","getPan","osc2","delayAmt","dNode","createDelay","delayTime","sigChain","mathObj","chainSource","num","scale","inMin","inMax","outMin","outMax","mapOutMin","mapOutMax","SinOsc","TriOsc","SawOsc","SqrOsc","_timeline","_toRemove","_iterating","memory","Infinity","_search","remove","shift","cancelBefore","beginning","end","midPoint","nextEvent","_iterate","lowerBound","upperBound","forEach","forEachBefore","forEachAfter","forEachFrom","forEachAtTime","_multiply","GreaterThanZero","_thresh","Clock","_nextTick","_lastState","_state","TimelineState","_boundLoop","_loop","state","setStateAtTime","pause","loopInterval","lag","currentState","tickTime","getStateAtTime","AudioVoice","DEFAULT_SUSTAIN","MonoSynth","env","Envelope","setRange","setExp","setADSR","setInput","play","velocity","secondsFromNow","susTime","triggerAttack","triggerRelease","vel","ramp","attack","decay","sustain","release","defineProperties","aTime","dTime","sPercent","rTime","sustime","PolySynth","audioVoice","maxVoices","audiovoices","notes","_newest","_oldest","_voicesInUse","_allocateVoices","noteAttack","noteRelease","noteADSR","d","r","timeFromNow","voice","_note","_velocity","acTime","currentVoice","oldestNote","previousVal","_updateAfter","maxRange","nextTime","p5SOUND","parameters","fill","processor","realm","exec","inputBuffer","outputBuffer","$$processors","$$context","createScriptProcessor","outputChannelCount","Map","properties","c","l","defaultValue","MessageChannel","port2","Processor","port","port1","onaudioprocess","$$audioWorklet","AudioWorklet","addModule","fetch","then","ok","status","text","AudioWorkletProcessor","registerProcessor","parameterDescriptors","document","createElement","style","cssText","appendChild","contentWindow","createTextNode","body","$hook","documentElement","transpile","String","fixSetTarget","setTargetValueAtTime","createDelayNode","createJavaScriptNode","createPeriodicWave","createWaveTable","internal_createGain","internal_createDelay","maxDelayTime","internal_createBufferSource","when","noteGrainOn","noteOn","internal_start","noteOff","internal_stop","playbackRate","internal_createDynamicsCompressor","reduction","internal_createBiquadFilter","detune","internal_createOscillator","setPeriodicWave","setWaveTable","OfflineAudioContext","webkitOfflineAudioContext","navigator","getUserMedia","webkitGetUserMedia","mozGetUserMedia","msGetUserMedia","el","isSupported","canPlayType","isOGGSupported","isMP3Supported","isWAVSupported","isAACSupported","isAIFSupported","g","Function","root","factory","amd","TapListener","element","_dragged","_element","_bindedMove","_moved","_bindedEnd","_ended","isStarted","source","resume","startContext","removeEventListener","promise","Promise","success","checkLoop","requestAnimationFrame","onStarted","tapListeners","bindTapListener","NodeList","querySelectorAll","jquery","toArray","tap","moduleSources","initializedAudioWorklets","loadAudioWorkletModules","all","moduleSrc","objectURL","audioWorklet","preload","_incrementPreload","onWorkletModulesLoad","_decrementPreload","createStereoPanner","stereoPanner","inputChannels","obj","numInputChannels","left","right","channelInterpretation","splitter","createChannelSplitter","createChannelMerger","v","rightVal","cos","leftVal","numChannels","SoundFile","onload","onerror","whileLoading","url","File","FileReader","FileList","file","_onended","_looping","_playing","_paused","_pauseTime","_cues","_cueIDCounter","_lastPos","_counterNode","_workletNode","bufferSourceNodes","bufferSourceNode","reversed","pauseTime","mode","startMillis","load","_whileLoading","_clearOnEnd","registerPreloadMethod","loadSound","location","origin","cordova","alert","errorCallback","request","XMLHttpRequest","evt","_updateProgress","open","responseType","decodeAudioData","response","buff","msg","error","statusText","message","send","reader","readAsArrayBuffer","lengthComputable","percentComplete","loaded","isLoaded","rate","_cueStart","cueStart","cueEnd","setVolume","isPlaying","_initSourceNode","_initCounterNode","_arrayIndex","loopStart","loopEnd","playMode","str","pTime","setLoop","bool","isLooping","isPaused","stopAll","_time","_rampTime","_tFromNow","getVolume","reverse","reverseBuffer","setPitch","newPlaybackRate","getPlaybackRate","jump","cueTime","cTime","dur","channels","frames","getPeaks","width","sampleSize","sampleStep","peaks","chan","currentPos","curVol","onended","getLevel","setPath","setBuffer","buf","size","newBuffer","channelNum","channel","_createCounterBuffer","audioBuf","arrayBuffer","cNode","workletBufferSize","processorOptions","onmessage","data","_onTimeUpdate","processPeaks","_initThreshold","_minThreshold","_minPeaks","bufLen","allPeaks","initialThreshold","minThreshold","minPeaks","offlineContext","startRendering","oncomplete","filteredBuffer","renderedBuffer","bufferData","getPeaksAtThreshold","intervalCounts","countIntervalsBetweenNearbyPeaks","groups","groupNeighborsByTempo","topTempos","sort","intA","intB","count","tempo","bpmVariance","tempoPeaks","getPeaksAtTopTempo","Peak","sampleIndex","amplitude","tempos","intervals","peaksObj","peak","peaksArray","startPeak","endPeak","startPos","endPos","foundInterval","some","intervalCount","tempoCounts","theoreticalTempo","mapTempo","foundTempo","tempoCount","peaksAtTopTempo","key","intervalBPM","peakTime","dif","Cue","id","addCue","cue","removeCue","cueLength","clearCues","playbackTime","callbackTime","_prevUpdateTime","save","fileName","saveSound","getBlob","dataView","thisBufferSourceNode","target","soundFile","_","Amplitude","smoothing","parameterData","normalize","volNorm","stereoVol","stereoVolNorm","toggleNormalize","smooth","FFT","analyser","createAnalyser","fftSize","configurable","smoothingTimeConstant","freqDomain","Uint8Array","frequencyBinCount","timeDomain","bass","lowMid","mid","highMid","treble","waveform","normalArray","_isSafari","timeToFloat","getFloatTimeDomainData","timeToInt","getByteTimeDomainData","scaled","analyze","freqToFloat","getFloatFrequencyData","freqToInt","getByteFrequencyData","getEnergy","frequency1","frequency2","nyquist","swap","lowIndex","highIndex","numFrequencies","toReturn","freq1","freq2","x","getCentroid","cumulative_sum","centroid_normalization","mean_freq_index","spec_centroid_freq","linAverages","N","spectrum","spectrumLength","spectrumStep","linearAverages","groupIndex","specIndex","logAverages","octaveBands","octaveIndex","specIndexFrequency","hi","getOctaveBands","fCtr0","lastFrequencyBand","lo","ctr","newFrequencyBand","fft","_input","midi","midiToFrequency","pitch","noteNumber","noteToScaleIndex","transpose","harmonize","toMidi","frequencyToMidi","toNote","A4","LN2","scaleIndexToNote","cbb","cb","c#","cx","dbb","d#","dx","ebb","eb","e#","ex","fbb","fb","f#","fx","gbb","gb","g#","gx","abb","ab","a#","ax","bbb","bb","b#","bx","_secondsToTicks","l1","t2","l2","t3","l3","aLevel","dLevel","rLevel","_rampHighPercentage","_rampLowPercentage","control","_init","isExponential","sourceToClear","wasTriggered","_setRampAD","_rampAttackTime","checkExpInput","_rampDecayTime","TCDenominator","_rampAttackTC","_rampDecayTC","setRampPercentages","p1","p2","isExp","lastAttack","valToSet","v2","destination1","destination2","AudioIn","Reverb","Noise","Delay","Env","Pulse","w","dcOffset","createDCOffset","dcGain","mW","sig","SignalAdd","mods","currentFreq","freqMod","bufferSource","assignType","_brownNoise","_pinkNoise","_whiteNoise","whiteBuffer","noiseData","random","pinkBuffer","b0","b1","b2","b3","b4","b5","b6","white","brownBuffer","lastOut","noise","inputSources","stream","mediaStream","currentSource","enabled","MediaStreamTrack","mediaDevices","successCallback","audioSource","constraints","audio","echoCancellation","deviceId","createMediaStreamSource","getTracks","track","getSources","onSuccess","onError","resolve","reject","enumerateDevices","devices","device","kind","setSource","active","initialFade","_equalPowerA","EqualPowerGain","_equalPowerB","_invert","Expr","applyBinary","Constructor","_eval","applyUnary","getNumber","literalNumber","_replacements","inputCount","_parseInputs","_nodes","tree","_parseTree","_disposeNodes","_Expressions","signal","glue",",","Abs","mod","modulus","Modulo","Pow","a2g","AudioToGain","binary","unary","!","NOT","inputArray","inputMax","replace","matchSyntax","syn","matchGroup","groupName","parseExpression","parseUnary","operator","parsePrimary","parseArgumentList","parseFunctionCall","GreaterThan","_gtz","_abs","_subtract","_modSignal","_setWaveShaper","_exp","_expScaler","_expFunc","_norm","_eqPower","EQFilter","EQ","_eqsize","factor","bands","_newBand","Panner3D","createPanner","panningModel","distanceModel","xVal","yVal","zVal","positionX","positionY","positionZ","orient","orientX","orientY","orientZ","orientationX","orientationY","orientationZ","setFalloff","maxDistance","rolloffFactor","maxDist","rolloff","Listener3D","listener","xValF","yValF","zValF","xValU","yValU","zValU","orientForward","orientUp","forwardX","forwardY","forwardZ","upX","upY","upZ","_split","_merge","_leftGain","_rightGain","leftDelay","rightDelay","_leftFilter","_rightFilter","_maxDelay","maxValue","feedback","_delayTime","_feedback","_filter","_initConvolverNode","_seconds","_decay","_reverse","_buildImpulse","convolverNode","createConvolver","_teardownConvolverNode","_setBuffer","decayRate","rebuild","impulse","impulseL","impulseR","Convolver","impulses","_loadBuffer","cReverb","chunks","addImpulse","resetImpulse","toggleImpulse","Metro","clock","ontick","syncedParts","prevTick","tatumTime","tickCallback","elapsedTime","thisPart","incrementStep","phrases","thisPhrase","phraseArray","sequence","bNum","metroTicks","looping","setBPM","beatTime","tatums","getBPM","getRate","resetSync","part","pushSync","beatLength","initial","Phrase","phraseStep","Part","steps","bLength","partStep","noLoop","metro","addPhrase","array","removePhrase","getPhrase","replaceSequence","onStep","Score","currentPart","thisScore","nextPart","resetPart","playNextPart","resetParts","scoreStep","aScore","SoundLoop","musicalTimeMode","_interval","_bpm","maxIterations","iterations","_calcFreq","syncedStart","otherLoop","_update","_convertNotation","Number","_measure","timeSig","Compressor","compressor","number","SoundRecorder","_inputChannels","_outputChannels","buffers","leftBuffer","rightBuffer","_callback","record","sFile","writeFile","PeakDetect","_framesPerPeak","framesPerPeak","framesSinceLastPeak","cutoff","cutoffMult","energy","penergy","currentValue","isDetected","f1","f2","_onPeak","update","fftObject","nrg","onPeak","makeDistortionCurve","amount","k","numSamples","deg","Distortion","curveAmount","waveShaperNode","getAmount","getOversample"],"mappings":"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","file":"p5.sound.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 31);\n","/**\n * Tone.js\n * @author Yotam Mann\n * @license http://opensource.org/licenses/MIT MIT License\n * @copyright 2014-2017 Yotam Mann\n */\ndefine(function(){\n\n\t\"use strict\";\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tTONE\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * @class Tone is the base class of all other classes. It provides \n\t * a lot of methods and functionality to all classes that extend\n\t * it. \n\t * \n\t * @constructor\n\t * @alias Tone\n\t * @param {number} [inputs=1] the number of input nodes\n\t * @param {number} [outputs=1] the number of output nodes\n\t */\n\tvar Tone = function(inputs, outputs){\n\n\t\t/**\n\t\t * the input node(s)\n\t\t * @type {GainNode|Array}\n\t\t */\n\t\tif (this.isUndef(inputs) || inputs === 1){\n\t\t\tthis.input = this.context.createGain();\n\t\t} else if (inputs > 1){\n\t\t\tthis.input = new Array(inputs);\n\t\t}\n\n\t\t/**\n\t\t * the output node(s)\n\t\t * @type {GainNode|Array}\n\t\t */\n\t\tif (this.isUndef(outputs) || outputs === 1){\n\t\t\tthis.output = this.context.createGain();\n\t\t} else if (outputs > 1){\n\t\t\tthis.output = new Array(inputs);\n\t\t}\n\t};\n\n\t/**\n\t * Set the parameters at once. Either pass in an\n\t * object mapping parameters to values, or to set a\n\t * single parameter, by passing in a string and value.\n\t * The last argument is an optional ramp time which \n\t * will ramp any signal values to their destination value\n\t * over the duration of the rampTime.\n\t * @param {Object|string} params\n\t * @param {number=} value\n\t * @param {Time=} rampTime\n\t * @returns {Tone} this\n\t * @example\n\t * //set values using an object\n\t * filter.set({\n\t * \t\"frequency\" : 300,\n\t * \t\"type\" : highpass\n\t * });\n\t * @example\n\t * filter.set(\"type\", \"highpass\");\n\t * @example\n\t * //ramp to the value 220 over 3 seconds. \n\t * oscillator.set({\n\t * \t\"frequency\" : 220\n\t * }, 3);\n\t */\n\tTone.prototype.set = function(params, value, rampTime){\n\t\tif (this.isObject(params)){\n\t\t\trampTime = value;\n\t\t} else if (this.isString(params)){\n\t\t\tvar tmpObj = {};\n\t\t\ttmpObj[params] = value;\n\t\t\tparams = tmpObj;\n\t\t}\n\n\t\tparamLoop:\n\t\tfor (var attr in params){\n\t\t\tvalue = params[attr];\n\t\t\tvar parent = this;\n\t\t\tif (attr.indexOf(\".\") !== -1){\n\t\t\t\tvar attrSplit = attr.split(\".\");\n\t\t\t\tfor (var i = 0; i < attrSplit.length - 1; i++){\n\t\t\t\t\tparent = parent[attrSplit[i]];\n\t\t\t\t\tif (parent instanceof Tone) {\n\t\t\t\t\t\tattrSplit.splice(0,i+1);\n\t\t\t\t\t\tvar innerParam = attrSplit.join(\".\");\n\t\t\t\t\t\tparent.set(innerParam, value);\n\t\t\t\t\t\tcontinue paramLoop;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tattr = attrSplit[attrSplit.length - 1];\n\t\t\t}\n\t\t\tvar param = parent[attr];\n\t\t\tif (this.isUndef(param)){\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif ((Tone.Signal && param instanceof Tone.Signal) || \n\t\t\t\t\t(Tone.Param && param instanceof Tone.Param)){\n\t\t\t\tif (param.value !== value){\n\t\t\t\t\tif (this.isUndef(rampTime)){\n\t\t\t\t\t\tparam.value = value;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tparam.rampTo(value, rampTime);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else if (param instanceof AudioParam){\n\t\t\t\tif (param.value !== value){\n\t\t\t\t\tparam.value = value;\n\t\t\t\t}\t\t\t\t\n\t\t\t} else if (param instanceof Tone){\n\t\t\t\tparam.set(value);\n\t\t\t} else if (param !== value){\n\t\t\t\tparent[attr] = value;\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Get the object's attributes. Given no arguments get\n\t * will return all available object properties and their corresponding\n\t * values. Pass in a single attribute to retrieve or an array\n\t * of attributes. The attribute strings can also include a \".\"\n\t * to access deeper properties.\n\t * @example\n\t * osc.get();\n\t * //returns {\"type\" : \"sine\", \"frequency\" : 440, ...etc}\n\t * @example\n\t * osc.get(\"type\");\n\t * //returns { \"type\" : \"sine\"}\n\t * @example\n\t * //use dot notation to access deep properties\n\t * synth.get([\"envelope.attack\", \"envelope.release\"]);\n\t * //returns {\"envelope\" : {\"attack\" : 0.2, \"release\" : 0.4}}\n\t * @param {Array=|string|undefined} params the parameters to get, otherwise will return \n\t * \t\t\t\t\t all available.\n\t * @returns {Object}\n\t */\n\tTone.prototype.get = function(params){\n\t\tif (this.isUndef(params)){\n\t\t\tparams = this._collectDefaults(this.constructor);\n\t\t} else if (this.isString(params)){\n\t\t\tparams = [params];\n\t\t} \n\t\tvar ret = {};\n\t\tfor (var i = 0; i < params.length; i++){\n\t\t\tvar attr = params[i];\n\t\t\tvar parent = this;\n\t\t\tvar subRet = ret;\n\t\t\tif (attr.indexOf(\".\") !== -1){\n\t\t\t\tvar attrSplit = attr.split(\".\");\n\t\t\t\tfor (var j = 0; j < attrSplit.length - 1; j++){\n\t\t\t\t\tvar subAttr = attrSplit[j];\n\t\t\t\t\tsubRet[subAttr] = subRet[subAttr] || {};\n\t\t\t\t\tsubRet = subRet[subAttr];\n\t\t\t\t\tparent = parent[subAttr];\n\t\t\t\t}\n\t\t\t\tattr = attrSplit[attrSplit.length - 1];\n\t\t\t}\n\t\t\tvar param = parent[attr];\n\t\t\tif (this.isObject(params[attr])){\n\t\t\t\tsubRet[attr] = param.get();\n\t\t\t} else if (Tone.Signal && param instanceof Tone.Signal){\n\t\t\t\tsubRet[attr] = param.value;\n\t\t\t} else if (Tone.Param && param instanceof Tone.Param){\n\t\t\t\tsubRet[attr] = param.value;\n\t\t\t} else if (param instanceof AudioParam){\n\t\t\t\tsubRet[attr] = param.value;\n\t\t\t} else if (param instanceof Tone){\n\t\t\t\tsubRet[attr] = param.get();\n\t\t\t} else if (!this.isFunction(param) && !this.isUndef(param)){\n\t\t\t\tsubRet[attr] = param;\n\t\t\t} \n\t\t}\n\t\treturn ret;\n\t};\n\n\t/**\n\t * collect all of the default attributes in one\n\t * @private\n\t * @param {function} constr the constructor to find the defaults from\n\t * @return {Array} all of the attributes which belong to the class\n\t */\n\tTone.prototype._collectDefaults = function(constr){\n\t\tvar ret = [];\n\t\tif (!this.isUndef(constr.defaults)){\n\t\t\tret = Object.keys(constr.defaults);\n\t\t}\n\t\tif (!this.isUndef(constr._super)){\n\t\t\tvar superDefs = this._collectDefaults(constr._super);\n\t\t\t//filter out repeats\n\t\t\tfor (var i = 0; i < superDefs.length; i++){\n\t\t\t\tif (ret.indexOf(superDefs[i]) === -1){\n\t\t\t\t\tret.push(superDefs[i]);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn ret;\n\t};\n\n\t/**\n\t * @returns {string} returns the name of the class as a string\n\t */\n\tTone.prototype.toString = function(){\n\t\tfor (var className in Tone){\n\t\t\tvar isLetter = className[0].match(/^[A-Z]$/);\n\t\t\tvar sameConstructor = Tone[className] === this.constructor;\n\t\t\tif (this.isFunction(Tone[className]) && isLetter && sameConstructor){\n\t\t\t\treturn className;\n\t\t\t}\n\t\t}\n\t\treturn \"Tone\";\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tCLASS VARS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * The number of inputs feeding into the AudioNode. \n\t * For source nodes, this will be 0.\n\t * @memberOf Tone#\n\t * @name numberOfInputs\n\t * @readOnly\n\t */\n\tObject.defineProperty(Tone.prototype, \"numberOfInputs\", {\n\t\tget : function(){\n\t\t\tif (this.input){\n\t\t\t\tif (this.isArray(this.input)){\n\t\t\t\t\treturn this.input.length;\n\t\t\t\t} else {\n\t\t\t\t\treturn 1;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\treturn 0;\n\t\t\t}\n\t\t}\n\t});\n\n\t/**\n\t * The number of outputs coming out of the AudioNode. \n\t * For source nodes, this will be 0.\n\t * @memberOf Tone#\n\t * @name numberOfInputs\n\t * @readOnly\n\t */\n\tObject.defineProperty(Tone.prototype, \"numberOfOutputs\", {\n\t\tget : function(){\n\t\t\tif (this.output){\n\t\t\t\tif (this.isArray(this.output)){\n\t\t\t\t\treturn this.output.length;\n\t\t\t\t} else {\n\t\t\t\t\treturn 1;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\treturn 0;\n\t\t\t}\n\t\t}\n\t});\n\t\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tCONNECTIONS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * disconnect and dispose\n\t * @returns {Tone} this\n\t */\n\tTone.prototype.dispose = function(){\n\t\tif (!this.isUndef(this.input)){\n\t\t\tif (this.input instanceof AudioNode){\n\t\t\t\tthis.input.disconnect();\n\t\t\t} \n\t\t\tthis.input = null;\n\t\t}\n\t\tif (!this.isUndef(this.output)){\n\t\t\tif (this.output instanceof AudioNode){\n\t\t\t\tthis.output.disconnect();\n\t\t\t} \n\t\t\tthis.output = null;\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * connect the output of a ToneNode to an AudioParam, AudioNode, or ToneNode\n\t * @param {Tone | AudioParam | AudioNode} unit \n\t * @param {number} [outputNum=0] optionally which output to connect from\n\t * @param {number} [inputNum=0] optionally which input to connect to\n\t * @returns {Tone} this\n\t */\n\tTone.prototype.connect = function(unit, outputNum, inputNum){\n\t\tif (Array.isArray(this.output)){\n\t\t\toutputNum = this.defaultArg(outputNum, 0);\n\t\t\tthis.output[outputNum].connect(unit, 0, inputNum);\n\t\t} else {\n\t\t\tthis.output.connect(unit, outputNum, inputNum);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * disconnect the output\n\t * @param {Number|AudioNode} output Either the output index to disconnect\n\t * if the output is an array, or the\n\t * node to disconnect from.\n\t * @returns {Tone} this\n\t */\n\tTone.prototype.disconnect = function(destination, outputNum, inputNum){\n\t\tif (this.isArray(this.output)){\n\t\t\tif (this.isNumber(destination)){\n\t\t\t\tthis.output[destination].disconnect();\n\t\t\t} else {\n\t\t\t\toutputNum = this.defaultArg(outputNum, 0);\n\t\t\t\tthis.output[outputNum].disconnect(destination, 0, inputNum);\n\t\t\t}\n\t\t} else {\n\t\t\tthis.output.disconnect.apply(this.output, arguments);\n\t\t}\n\t};\n\n\t/**\n\t * connect together all of the arguments in series\n\t * @param {...AudioParam|Tone|AudioNode} nodes\n\t * @returns {Tone} this\n\t */\n\tTone.prototype.connectSeries = function(){\n\t\tif (arguments.length > 1){\n\t\t\tvar currentUnit = arguments[0];\n\t\t\tfor (var i = 1; i < arguments.length; i++){\n\t\t\t\tvar toUnit = arguments[i];\n\t\t\t\tcurrentUnit.connect(toUnit);\n\t\t\t\tcurrentUnit = toUnit;\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Connect the output of this node to the rest of the nodes in series.\n\t * @example\n\t * //connect a node to an effect, panVol and then to the master output\n\t * node.chain(effect, panVol, Tone.Master);\n\t * @param {...AudioParam|Tone|AudioNode} nodes\n\t * @returns {Tone} this\n\t */\n\tTone.prototype.chain = function(){\n\t\tif (arguments.length > 0){\n\t\t\tvar currentUnit = this;\n\t\t\tfor (var i = 0; i < arguments.length; i++){\n\t\t\t\tvar toUnit = arguments[i];\n\t\t\t\tcurrentUnit.connect(toUnit);\n\t\t\t\tcurrentUnit = toUnit;\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * connect the output of this node to the rest of the nodes in parallel.\n\t * @param {...AudioParam|Tone|AudioNode} nodes\n\t * @returns {Tone} this\n\t */\n\tTone.prototype.fan = function(){\n\t\tif (arguments.length > 0){\n\t\t\tfor (var i = 0; i < arguments.length; i++){\n\t\t\t\tthis.connect(arguments[i]);\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t};\n\n\t//give native nodes chain and fan methods\n\tAudioNode.prototype.chain = Tone.prototype.chain;\n\tAudioNode.prototype.fan = Tone.prototype.fan;\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tUTILITIES / HELPERS / MATHS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * If the `given` parameter is undefined, use the `fallback`. \n\t * If both `given` and `fallback` are object literals, it will\n\t * return a deep copy which includes all of the parameters from both \n\t * objects. If a parameter is undefined in given, it will return\n\t * the fallback property. \n\t *

\n\t * WARNING: if object is self referential, it will go into an an \n\t * infinite recursive loop.\n\t * \n\t * @param {*} given \n\t * @param {*} fallback \n\t * @return {*} \n\t */\n\tTone.prototype.defaultArg = function(given, fallback){\n\t\tif (this.isObject(given) && this.isObject(fallback)){\n\t\t\tvar ret = {};\n\t\t\t//make a deep copy of the given object\n\t\t\tfor (var givenProp in given) {\n\t\t\t\tret[givenProp] = this.defaultArg(fallback[givenProp], given[givenProp]);\n\t\t\t}\n\t\t\tfor (var fallbackProp in fallback) {\n\t\t\t\tret[fallbackProp] = this.defaultArg(given[fallbackProp], fallback[fallbackProp]);\n\t\t\t}\n\t\t\treturn ret;\n\t\t} else {\n\t\t\treturn this.isUndef(given) ? fallback : given;\n\t\t}\n\t};\n\n\t/**\n\t * returns the args as an options object with given arguments\n\t * mapped to the names provided. \n\t *\n\t * if the args given is an array containing only one object, it is assumed\n\t * that that's already the options object and will just return it. \n\t * \n\t * @param {Array} values the 'arguments' object of the function\n\t * @param {Array} keys the names of the arguments as they\n\t * should appear in the options object\n\t * @param {Object=} defaults optional defaults to mixin to the returned \n\t * options object \n\t * @return {Object} the options object with the names mapped to the arguments\n\t */\n\tTone.prototype.optionsObject = function(values, keys, defaults){\n\t\tvar options = {};\n\t\tif (values.length === 1 && this.isObject(values[0])){\n\t\t\toptions = values[0];\n\t\t} else {\n\t\t\tfor (var i = 0; i < keys.length; i++){\n\t\t\t\toptions[keys[i]] = values[i];\n\t\t\t}\n\t\t}\n\t\tif (!this.isUndef(defaults)){\n\t\t\treturn this.defaultArg(options, defaults);\n\t\t} else {\n\t\t\treturn options;\n\t\t}\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t// TYPE CHECKING\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * test if the arg is undefined\n\t * @param {*} arg the argument to test\n\t * @returns {boolean} true if the arg is undefined\n\t * @function\n\t */\n\tTone.prototype.isUndef = function(val){\n\t\treturn typeof val === \"undefined\";\n\t};\n\n\t/**\n\t * test if the arg is a function\n\t * @param {*} arg the argument to test\n\t * @returns {boolean} true if the arg is a function\n\t * @function\n\t */\n\tTone.prototype.isFunction = function(val){\n\t\treturn typeof val === \"function\";\n\t};\n\n\t/**\n\t * Test if the argument is a number.\n\t * @param {*} arg the argument to test\n\t * @returns {boolean} true if the arg is a number\n\t */\n\tTone.prototype.isNumber = function(arg){\n\t\treturn (typeof arg === \"number\");\n\t};\n\n\t/**\n\t * Test if the given argument is an object literal (i.e. `{}`);\n\t * @param {*} arg the argument to test\n\t * @returns {boolean} true if the arg is an object literal.\n\t */\n\tTone.prototype.isObject = function(arg){\n\t\treturn (Object.prototype.toString.call(arg) === \"[object Object]\" && arg.constructor === Object);\n\t};\n\n\t/**\n\t * Test if the argument is a boolean.\n\t * @param {*} arg the argument to test\n\t * @returns {boolean} true if the arg is a boolean\n\t */\n\tTone.prototype.isBoolean = function(arg){\n\t\treturn (typeof arg === \"boolean\");\n\t};\n\n\t/**\n\t * Test if the argument is an Array\n\t * @param {*} arg the argument to test\n\t * @returns {boolean} true if the arg is an array\n\t */\n\tTone.prototype.isArray = function(arg){\n\t\treturn (Array.isArray(arg));\n\t};\n\n\t/**\n\t * Test if the argument is a string.\n\t * @param {*} arg the argument to test\n\t * @returns {boolean} true if the arg is a string\n\t */\n\tTone.prototype.isString = function(arg){\n\t\treturn (typeof arg === \"string\");\n\t};\n\n \t/**\n\t * An empty function.\n\t * @static\n\t */\n\tTone.noOp = function(){};\n\n\t/**\n\t * Make the property not writable. Internal use only. \n\t * @private\n\t * @param {string} property the property to make not writable\n\t */\n\tTone.prototype._readOnly = function(property){\n\t\tif (Array.isArray(property)){\n\t\t\tfor (var i = 0; i < property.length; i++){\n\t\t\t\tthis._readOnly(property[i]);\n\t\t\t}\n\t\t} else {\n\t\t\tObject.defineProperty(this, property, { \n\t\t\t\twritable: false,\n\t\t\t\tenumerable : true,\n\t\t\t});\n\t\t}\n\t};\n\n\t/**\n\t * Make an attribute writeable. Interal use only. \n\t * @private\n\t * @param {string} property the property to make writable\n\t */\n\tTone.prototype._writable = function(property){\n\t\tif (Array.isArray(property)){\n\t\t\tfor (var i = 0; i < property.length; i++){\n\t\t\t\tthis._writable(property[i]);\n\t\t\t}\n\t\t} else {\n\t\t\tObject.defineProperty(this, property, { \n\t\t\t\twritable: true,\n\t\t\t});\n\t\t}\n\t};\n\n\t/**\n\t * Possible play states. \n\t * @enum {string}\n\t */\n\tTone.State = {\n\t\tStarted : \"started\",\n\t\tStopped : \"stopped\",\n\t\tPaused : \"paused\",\n \t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t// CONVERSIONS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Equal power gain scale. Good for cross-fading.\n\t * @param {NormalRange} percent (0-1)\n\t * @return {Number} output gain (0-1)\n\t */\n\tTone.prototype.equalPowerScale = function(percent){\n\t\tvar piFactor = 0.5 * Math.PI;\n\t\treturn Math.sin(percent * piFactor);\n\t};\n\n\t/**\n\t * Convert decibels into gain.\n\t * @param {Decibels} db\n\t * @return {Number} \n\t */\n\tTone.prototype.dbToGain = function(db) {\n\t\treturn Math.pow(2, db / 6);\n\t};\n\n\t/**\n\t * Convert gain to decibels.\n\t * @param {Number} gain (0-1)\n\t * @return {Decibels} \n\t */\n\tTone.prototype.gainToDb = function(gain) {\n\t\treturn 20 * (Math.log(gain) / Math.LN10);\n\t};\n\n\t/**\n\t * Convert an interval (in semitones) to a frequency ratio.\n\t * @param {Interval} interval the number of semitones above the base note\n\t * @return {number} the frequency ratio\n\t * @example\n\t * tone.intervalToFrequencyRatio(0); // 1\n\t * tone.intervalToFrequencyRatio(12); // 2\n\t * tone.intervalToFrequencyRatio(-12); // 0.5\n\t */\n\tTone.prototype.intervalToFrequencyRatio = function(interval){\n\t\treturn Math.pow(2,(interval/12));\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tTIMING\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Return the current time of the AudioContext clock.\n\t * @return {Number} the currentTime from the AudioContext\n\t */\n\tTone.prototype.now = function(){\n\t\treturn Tone.context.now();\n\t};\n\n\t/**\n\t * Return the current time of the AudioContext clock.\n\t * @return {Number} the currentTime from the AudioContext\n\t * @static\n\t */\n\tTone.now = function(){\n\t\treturn Tone.context.now();\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tINHERITANCE\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * have a child inherit all of Tone's (or a parent's) prototype\n\t * to inherit the parent's properties, make sure to call \n\t * Parent.call(this) in the child's constructor\n\t *\n\t * based on closure library's inherit function\n\t *\n\t * @static\n\t * @param {function} \tchild \n\t * @param {function=} parent (optional) parent to inherit from\n\t * if no parent is supplied, the child\n\t * will inherit from Tone\n\t */\n\tTone.extend = function(child, parent){\n\t\tif (Tone.prototype.isUndef(parent)){\n\t\t\tparent = Tone;\n\t\t}\n\t\tfunction TempConstructor(){}\n\t\tTempConstructor.prototype = parent.prototype;\n\t\tchild.prototype = new TempConstructor();\n\t\t/** @override */\n\t\tchild.prototype.constructor = child;\n\t\tchild._super = parent;\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tCONTEXT\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * The private audio context shared by all Tone Nodes. \n\t * @private\n\t * @type {Tone.Context|undefined}\n\t */\n\tvar audioContext;\n\n\t/**\n\t * A static pointer to the audio context accessible as Tone.context. \n\t * @type {Tone.Context}\n\t * @name context\n\t * @memberOf Tone\n\t */\n\tObject.defineProperty(Tone, \"context\", {\n\t\tget : function(){\n\t\t\treturn audioContext;\n\t\t},\n\t\tset : function(context){\n\t\t\tif (Tone.Context && context instanceof Tone.Context){\n\t\t\t\taudioContext = context;\n\t\t\t} else {\n\t\t\t\taudioContext = new Tone.Context(context);\n\t\t\t}\n\t\t\t//initialize the new audio context\n\t\t\tif (Tone.Context){\n\t\t\t\tTone.Context.emit(\"init\", audioContext);\n\t\t\t}\n\t\t}\n\t});\n\n\t/**\n\t * The AudioContext\n\t * @type {Tone.Context}\n\t * @name context\n\t * @memberOf Tone#\n\t * @readOnly\n\t */\n\tObject.defineProperty(Tone.prototype, \"context\", {\n\t\tget : function(){\n\t\t\treturn Tone.context;\n\t\t}\n\t});\n\n\t/**\n\t * Tone automatically creates a context on init, but if you are working\n\t * with other libraries which also create an AudioContext, it can be\n\t * useful to set your own. If you are going to set your own context, \n\t * be sure to do it at the start of your code, before creating any objects.\n\t * @static\n\t * @param {AudioContext} ctx The new audio context to set\n\t */\n\tTone.setContext = function(ctx){\n\t\tTone.context = ctx;\n\t};\n\n\t/**\n\t * The number of seconds of 1 processing block (128 samples)\n\t * @type {Number}\n\t * @name blockTime\n\t * @memberOf Tone#\n\t * @readOnly\n\t */\n\tObject.defineProperty(Tone.prototype, \"blockTime\", {\n\t\tget : function(){\n\t\t\treturn 128 / this.context.sampleRate;\n\t\t}\n\t});\n\n\t/**\n\t * The duration in seconds of one sample.\n\t * @type {Number}\n\t * @name sampleTime\n\t * @memberOf Tone#\n\t * @readOnly\n\t */\n\tObject.defineProperty(Tone.prototype, \"sampleTime\", {\n\t\tget : function(){\n\t\t\treturn 1 / this.context.sampleRate;\n\t\t}\n\t});\n\n\t/**\n\t * Whether or not all the technologies that Tone.js relies on are supported by the current browser. \n\t * @type {Boolean}\n\t * @name supported\n\t * @memberOf Tone\n\t * @readOnly\n\t */\n\tObject.defineProperty(Tone, \"supported\", {\n\t\tget : function(){\n\t\t\tvar hasAudioContext = window.hasOwnProperty(\"AudioContext\") || window.hasOwnProperty(\"webkitAudioContext\");\n\t\t\tvar hasPromises = window.hasOwnProperty(\"Promise\");\n\t\t\tvar hasWorkers = window.hasOwnProperty(\"Worker\");\n\t\t\treturn hasAudioContext && hasPromises && hasWorkers;\n\t\t}\n\t});\n\n\tTone.version = \"r10\";\n\n\t// allow optional silencing of this log\n\tif (!window.TONE_SILENCE_VERSION_LOGGING) {\n\t\tconsole.log(\"%c * Tone.js \" + Tone.version + \" * \", \"background: #000; color: #fff\");\n\t}\n\n\treturn Tone;\n});\n","'use strict';\n\n\ndefine(['audiocontext'], function (audiocontext) {\n // Master contains the master sound output.\n var Master = function() {\n this.input = audiocontext.createGain();\n this.output = audiocontext.createGain();\n\n //put a hard limiter on the output\n this.limiter = audiocontext.createDynamicsCompressor();\n this.limiter.threshold.value = -3;\n this.limiter.ratio.value = 20;\n this.limiter.knee.value = 1;\n\n this.audiocontext = audiocontext;\n\n this.output.disconnect();\n\n // connect input to limiter\n this.input.connect(this.limiter);\n\n // connect limiter to output\n this.limiter.connect(this.output);\n\n // meter is just for global Amplitude / FFT analysis\n this.meter = audiocontext.createGain();\n this.fftMeter = audiocontext.createGain();\n this.output.connect(this.meter);\n this.output.connect(this.fftMeter);\n\n // connect output to destination\n this.output.connect(this.audiocontext.destination);\n\n // an array of all sounds in the sketch\n this.soundArray = [];\n // an array of all musical parts in the sketch\n this.parts = [];\n\n // file extensions to search for\n this.extensions = [];\n };\n\n // create a single instance of the p5Sound / master output for use within this sketch\n var p5sound = new Master();\n\n /**\n * Returns a number representing the master amplitude (volume) for sound\n * in this sketch.\n *\n * @method getMasterVolume\n * @return {Number} Master amplitude (volume) for sound in this sketch.\n * Should be between 0.0 (silence) and 1.0.\n */\n p5.prototype.getMasterVolume = function() {\n return p5sound.output.gain.value;\n };\n\n /**\n *

Scale the output of all sound in this sketch

\n * Scaled between 0.0 (silence) and 1.0 (full volume).\n * 1.0 is the maximum amplitude of a digital sound, so multiplying\n * by greater than 1.0 may cause digital distortion. To\n * fade, provide a rampTime parameter. For more\n * complex fades, see the Envelope class.\n *\n * Alternately, you can pass in a signal source such as an\n * oscillator to modulate the amplitude with an audio signal.\n *\n *

How This Works: When you load the p5.sound module, it\n * creates a single instance of p5sound. All sound objects in this\n * module output to p5sound before reaching your computer's output.\n * So if you change the amplitude of p5sound, it impacts all of the\n * sound in this module.

\n *\n *

If no value is provided, returns a Web Audio API Gain Node

\n *\n * @method masterVolume\n * @param {Number|Object} volume Volume (amplitude) between 0.0\n * and 1.0 or modulating signal/oscillator\n * @param {Number} [rampTime] Fade for t seconds\n * @param {Number} [timeFromNow] Schedule this event to happen at\n * t seconds in the future\n */\n p5.prototype.masterVolume = function(vol, rampTime, tFromNow) {\n if (typeof vol === 'number') {\n var rampTime = rampTime || 0;\n var tFromNow = tFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n var currentVol = p5sound.output.gain.value;\n p5sound.output.gain.cancelScheduledValues(now + tFromNow);\n p5sound.output.gain.linearRampToValueAtTime(currentVol, now + tFromNow);\n p5sound.output.gain.linearRampToValueAtTime(vol, now + tFromNow + rampTime);\n }\n else if (vol) {\n vol.connect(p5sound.output.gain);\n } else {\n // return the Gain Node\n return p5sound.output.gain;\n }\n };\n\n /**\n * `p5.soundOut` is the p5.sound master output. It sends output to\n * the destination of this window's web audio context. It contains\n * Web Audio API nodes including a dyanmicsCompressor (.limiter),\n * and Gain Nodes for .input and .output.\n *\n * @property {Object} soundOut\n */\n p5.prototype.soundOut = p5.soundOut = p5sound;\n\n // a silent connection to the DesinationNode\n // which will ensure that anything connected to it\n // will not be garbage collected\n p5.soundOut._silentNode = p5sound.audiocontext.createGain();\n p5.soundOut._silentNode.gain.value = 0;\n p5.soundOut._silentNode.connect(p5sound.audiocontext.destination);\n\n\n return p5sound;\n});\n","define([\"Tone/core/Tone\", \"Tone/signal/WaveShaper\", \"Tone/type/Type\", \"Tone/core/Param\", \"Tone/core/Gain\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class A signal is an audio-rate value. Tone.Signal is a core component of the library.\n\t * Unlike a number, Signals can be scheduled with sample-level accuracy. Tone.Signal\n\t * has all of the methods available to native Web Audio \n\t * [AudioParam](http://webaudio.github.io/web-audio-api/#the-audioparam-interface)\n\t * as well as additional conveniences. Read more about working with signals \n\t * [here](https://github.com/Tonejs/Tone.js/wiki/Signals).\n\t *\n\t * @constructor\n\t * @extends {Tone.Param}\n\t * @param {Number|AudioParam} [value] Initial value of the signal. If an AudioParam\n\t * is passed in, that parameter will be wrapped\n\t * and controlled by the Signal. \n\t * @param {string} [units=Number] unit The units the signal is in. \n\t * @example\n\t * var signal = new Tone.Signal(10);\n\t */\n\tTone.Signal = function(){\n\n\t\tvar options = this.optionsObject(arguments, [\"value\", \"units\"], Tone.Signal.defaults);\n\n\t\t/**\n\t\t * The node where the constant signal value is scaled.\n\t\t * @type {GainNode}\n\t\t * @private\n\t\t */\n\t\tthis.output = this._gain = this.context.createGain();\n\n\t\toptions.param = this._gain.gain;\n\t\tTone.Param.call(this, options);\n\n\t\t/**\n\t\t * The node where the value is set.\n\t\t * @type {Tone.Param}\n\t\t * @private\n\t\t */\n\t\tthis.input = this._param = this._gain.gain;\n\n\t\t//connect the const output to the node output\n\t\tthis.context.getConstant(1).chain(this._gain);\n\t};\n\n\tTone.extend(Tone.Signal, Tone.Param);\n\n\t/**\n\t * The default values\n\t * @type {Object}\n\t * @static\n\t * @const\n\t */\n\tTone.Signal.defaults = {\n\t\t\"value\" : 0,\n\t\t\"units\" : Tone.Type.Default,\n\t\t\"convert\" : true,\n\t};\n\n\t/**\n\t * When signals connect to other signals or AudioParams, \n\t * they take over the output value of that signal or AudioParam. \n\t * For all other nodes, the behavior is the same as a default connect. \n\t *\n\t * @override\n\t * @param {AudioParam|AudioNode|Tone.Signal|Tone} node \n\t * @param {number} [outputNumber=0] The output number to connect from.\n\t * @param {number} [inputNumber=0] The input number to connect to.\n\t * @returns {Tone.SignalBase} this\n\t * @method\n\t */\n\tTone.Signal.prototype.connect = Tone.SignalBase.prototype.connect;\n\n\t/**\n\t * dispose and disconnect\n\t * @returns {Tone.Signal} this\n\t */\n\tTone.Signal.prototype.dispose = function(){\n\t\tTone.Param.prototype.dispose.call(this);\n\t\tthis._param = null;\n\t\tthis._gain.disconnect();\n\t\tthis._gain = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.Signal;\n});","define([\"Tone/core/Tone\", \"Tone/signal/Signal\", \"Tone/core/Gain\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Multiply two incoming signals. Or, if a number is given in the constructor, \n\t * multiplies the incoming signal by that value. \n\t *\n\t * @constructor\n\t * @extends {Tone.Signal}\n\t * @param {number=} value Constant value to multiple. If no value is provided,\n\t * it will return the product of the first and second inputs\n\t * @example\n\t * var mult = new Tone.Multiply();\n\t * var sigA = new Tone.Signal(3);\n\t * var sigB = new Tone.Signal(4);\n\t * sigA.connect(mult, 0, 0);\n\t * sigB.connect(mult, 0, 1);\n\t * //output of mult is 12.\n\t * @example\n\t * var mult = new Tone.Multiply(10);\n\t * var sig = new Tone.Signal(2).connect(mult);\n\t * //the output of mult is 20. \n\t */\n\tTone.Multiply = function(value){\n\n\t\tthis.createInsOuts(2, 0);\n\n\t\t/**\n\t\t * the input node is the same as the output node\n\t\t * it is also the GainNode which handles the scaling of incoming signal\n\t\t * \n\t\t * @type {GainNode}\n\t\t * @private\n\t\t */\n\t\tthis._mult = this.input[0] = this.output = new Tone.Gain();\n\n\t\t/**\n\t\t * the scaling parameter\n\t\t * @type {AudioParam}\n\t\t * @private\n\t\t */\n\t\tthis._param = this.input[1] = this.output.gain;\n\t\t\n\t\tthis._param.value = this.defaultArg(value, 0);\n\t};\n\n\tTone.extend(Tone.Multiply, Tone.Signal);\n\n\t/**\n\t * clean up\n\t * @returns {Tone.Multiply} this\n\t */\n\tTone.Multiply.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._mult.dispose();\n\t\tthis._mult = null;\n\t\tthis._param = null;\n\t\treturn this;\n\t}; \n\n\treturn Tone.Multiply;\n});\n","'use strict';\ndefine(function (require) {\n\n var p5sound = require('master');\n var CrossFade = require('Tone/component/CrossFade');\n\n /**\n * Effect is a base class for audio effects in p5.
\n * This module handles the nodes and methods that are\n * common and useful for current and future effects.\n *\n *\n * This class is extended by p5.Distortion,\n * p5.Compressor,\n * p5.Delay,\n * p5.Filter,\n * p5.Reverb.\n *\n * @class p5.Effect\n * @constructor\n *\n * @param {Object} [ac] Reference to the audio context of the p5 object\n * @param {AudioNode} [input] Gain Node effect wrapper\n * @param {AudioNode} [output] Gain Node effect wrapper\n * @param {Object} [_drywet] Tone.JS CrossFade node (defaults to value: 1)\n * @param {AudioNode} [wet] Effects that extend this class should connect\n * to the wet signal to this gain node, so that dry and wet\n * signals are mixed properly.\n */\n p5.Effect = function() {\n this.ac = p5sound.audiocontext;\n\n this.input = this.ac.createGain();\n this.output = this.ac.createGain();\n\n /**\n *\tThe p5.Effect class is built\n * \tusing Tone.js CrossFade\n * \t@private\n */\n\n this._drywet = new CrossFade(1);\n\n /**\n *\tIn classes that extend\n *\tp5.Effect, connect effect nodes\n *\tto the wet parameter\n */\n this.wet = this.ac.createGain();\n\n this.input.connect(this._drywet.a);\n this.wet.connect(this._drywet.b);\n this._drywet.connect(this.output);\n\n this.connect();\n\n //Add to the soundArray\n p5sound.soundArray.push(this);\n };\n\n /**\n * Set the output volume of the filter.\n *\n * @method amp\n * @for p5.Effect\n * @param {Number} [vol] amplitude between 0 and 1.0\n * @param {Number} [rampTime] create a fade that lasts until rampTime\n * @param {Number} [tFromNow] schedule this event to happen in tFromNow seconds\n */\n p5.Effect.prototype.amp = function(vol, rampTime, tFromNow){\n var rampTime = rampTime || 0;\n var tFromNow = tFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n var currentVol = this.output.gain.value;\n this.output.gain.cancelScheduledValues(now);\n this.output.gain.linearRampToValueAtTime(currentVol, now + tFromNow + .001);\n this.output.gain.linearRampToValueAtTime(vol, now + tFromNow + rampTime + .001);\n };\n\n /**\n * Link effects together in a chain\n * Example usage: filter.chain(reverb, delay, panner);\n * May be used with an open-ended number of arguments\n *\n * @method chain\n * @for p5.Effect\n * @param {Object} [arguments] Chain together multiple sound objects\n */\n p5.Effect.prototype.chain = function(){\n if (arguments.length>0){\n this.connect(arguments[0]);\n for(var i=1;i\n * let midiNotes = [60, 64, 67, 72];\n * let noteIndex = 0;\n * let midiVal, freq;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(startSound);\n * osc = new p5.TriOsc();\n * env = new p5.Envelope();\n * }\n *\n * function draw() {\n * background(220);\n * text('tap to play', 10, 20);\n * if (midiVal) {\n * text('MIDI: ' + midiVal, 10, 40);\n * text('Freq: ' + freq, 10, 60);\n * }\n * }\n *\n * function startSound() {\n * // see also: userStartAudio();\n * osc.start();\n *\n * midiVal = midiNotes[noteIndex % midiNotes.length];\n * freq = midiToFreq(midiVal);\n * osc.freq(freq);\n * env.ramp(osc, 0, 1.0, 0);\n *\n * noteIndex++;\n * }\n * \n */\n var midiToFreq = p5.prototype.midiToFreq = function(m) {\n return 440 * Math.pow(2, (m-69)/12.0);\n };\n\n // This method converts ANSI notes specified as a string \"C4\", \"Eb3\" to a frequency\n var noteToFreq = function(note) {\n if (typeof note !== 'string') {\n return note;\n }\n var wholeNotes = {A:21, B:23, C:24, D:26, E:28, F:29, G:31};\n var value = wholeNotes[ note[0].toUpperCase() ];\n var octave = ~~note.slice(-1);\n value += 12 * (octave -1);\n\n switch(note[1]) {\n case '#':\n value += 1;\n break;\n case 'b':\n value -= 1;\n break;\n default:\n break;\n }\n return midiToFreq(value);\n };\n\n /**\n * List the SoundFile formats that you will include. LoadSound\n * will search your directory for these extensions, and will pick\n * a format that is compatable with the client's web browser.\n * Here is a free online file\n * converter.\n *\n * @method soundFormats\n * @param {String} [...formats] i.e. 'mp3', 'wav', 'ogg'\n * @example\n *
\n * function preload() {\n * // set the global sound formats\n * soundFormats('mp3', 'ogg');\n *\n * // load either beatbox.mp3, or .ogg, depending on browser\n * mySound = loadSound('assets/beatbox.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * background(220);\n * text('sound loaded! tap to play', 10, 20, width - 20);\n * cnv.mousePressed(function() {\n * mySound.play();\n * });\n * }\n *
\n */\n p5.prototype.soundFormats = function() {\n // reset extensions array\n p5sound.extensions = [];\n // add extensions\n for (var i = 0; i < arguments.length; i++) {\n arguments[i] = arguments[i].toLowerCase();\n if (['mp3','wav','ogg', 'm4a', 'aac'].indexOf(arguments[i]) > -1) {\n p5sound.extensions.push(arguments[i]);\n } else {\n throw arguments[i] + ' is not a valid sound format!';\n }\n }\n };\n\n p5.prototype.disposeSound = function() {\n for (var i = 0; i < p5sound.soundArray.length; i++) {\n p5sound.soundArray[i].dispose();\n }\n };\n\n // register removeSound to dispose of p5sound SoundFiles, Convolvers,\n // Oscillators etc when sketch ends\n p5.prototype.registerMethod('remove', p5.prototype.disposeSound);\n\n p5.prototype._checkFileFormats = function(paths) {\n var path;\n // if path is a single string, check to see if extension is provided\n if (typeof paths === 'string') {\n path = paths;\n // see if extension is provided\n var extTest = path.split('.').pop();\n // if an extension is provided...\n if (['mp3','wav','ogg', 'm4a', 'aac'].indexOf(extTest) > -1) {\n if (p5.prototype.isFileSupported(extTest)) {\n path = path;\n }\n else {\n var pathSplit = path.split('.');\n var pathCore = pathSplit[pathSplit.length - 1];\n for (var i = 0; i 1) {\n rightChannel = audioBuffer.getChannelData(1);\n } else {\n rightChannel = leftChannel;\n }\n\n var interleaved = interleave(leftChannel, rightChannel);\n\n // create the buffer and view to create the .WAV file\n var buffer = new window.ArrayBuffer(44 + interleaved.length * 2);\n var view = new window.DataView(buffer);\n\n // write the WAV container,\n // check spec at: https://web.archive.org/web/20171215131933/http://tiny.systems/software/soundProgrammer/WavFormatDocs.pdf\n\n // RIFF chunk descriptor\n writeUTFBytes(view, 0, 'RIFF');\n view.setUint32(4, 36 + interleaved.length * 2, true);\n writeUTFBytes(view, 8, 'WAVE');\n // FMT sub-chunk\n writeUTFBytes(view, 12, 'fmt ');\n view.setUint32(16, 16, true);\n view.setUint16(20, 1, true);\n // stereo (2 channels)\n view.setUint16(22, 2, true);\n view.setUint32(24, p5sound.audiocontext.sampleRate, true);\n view.setUint32(28, p5sound.audiocontext.sampleRate * 4, true);\n view.setUint16(32, 4, true);\n view.setUint16(34, 16, true);\n // data sub-chunk\n writeUTFBytes(view, 36, 'data');\n view.setUint32(40, interleaved.length * 2, true);\n\n // write the PCM samples\n var lng = interleaved.length;\n var index = 44;\n var volume = 1;\n for (var i = 0; i < lng; i++) {\n view.setInt16(index, interleaved[i] * (0x7FFF * volume), true);\n index += 2;\n }\n\n return view;\n }\n\n // helper methods to save waves\n function interleave(leftChannel, rightChannel) {\n var length = leftChannel.length + rightChannel.length;\n var result = new Float32Array(length);\n\n var inputIndex = 0;\n\n for (var index = 0; index < length;) {\n result[index++] = leftChannel[inputIndex];\n result[index++] = rightChannel[inputIndex];\n inputIndex++;\n }\n return result;\n }\n\n function writeUTFBytes(view, offset, string) {\n var lng = string.length;\n for (var i = 0; i < lng; i++) {\n view.setUint8(offset + i, string.charCodeAt(i));\n }\n }\n\n function safeBufferSize(idealBufferSize) {\n let bufferSize = idealBufferSize; \n\n // if the AudioWorkletNode is actually a ScriptProcessorNode created via polyfill,\n // make sure that our chosen buffer size isn't smaller than the buffer size automatically\n // selected by the polyfill\n // reference: https://github.com/GoogleChromeLabs/audioworklet-polyfill/issues/13#issuecomment-425014930\n let tempAudioWorkletNode = new AudioWorkletNode(p5sound.audiocontext, processorNames.soundFileProcessor);\n if (tempAudioWorkletNode instanceof ScriptProcessorNode) {\n bufferSize = tempAudioWorkletNode.bufferSize;\n }\n tempAudioWorkletNode.disconnect();\n tempAudioWorkletNode = null;\n\n return bufferSize;\n }\n var safeBins = p5.prototype.safeBins = function(bins) {\n let safeBins = 1024;\n if(typeof(bins)===\"string\"){\n console.log(\"the value of bins must be power of two and between 16 and 1024\");\n return safeBins\n }\n if(bins && bins>=16 && bins<=1024 && Math.log2(bins)%1===0 ) // \n return bins;\n else {\n console.log(\"the value of bins must be power of two and between 16 and 1024\");\n return safeBins\n }\n \n }\n\n return {\n convertToWav: convertToWav,\n midiToFreq: midiToFreq,\n noteToFreq: noteToFreq,\n safeBufferSize: safeBufferSize,\n safeBins:safeBins\n };\n\n});\n","define([\"Tone/core/Tone\", \"Tone/signal/SignalBase\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Wraps the native Web Audio API \n\t * [WaveShaperNode](http://webaudio.github.io/web-audio-api/#the-waveshapernode-interface).\n\t *\n\t * @extends {Tone.SignalBase}\n\t * @constructor\n\t * @param {function|Array|Number} mapping The function used to define the values. \n\t * The mapping function should take two arguments: \n\t * the first is the value at the current position \n\t * and the second is the array position. \n\t * If the argument is an array, that array will be\n\t * set as the wave shaping function. The input\n\t * signal is an AudioRange [-1, 1] value and the output\n\t * signal can take on any numerical values. \n\t * \n\t * @param {Number} [bufferLen=1024] The length of the WaveShaperNode buffer.\n\t * @example\n\t * var timesTwo = new Tone.WaveShaper(function(val){\n\t * \treturn val * 2;\n\t * }, 2048);\n\t * @example\n\t * //a waveshaper can also be constructed with an array of values\n\t * var invert = new Tone.WaveShaper([1, -1]);\n\t */\n\tTone.WaveShaper = function(mapping, bufferLen){\n\n\t\t/**\n\t\t * the waveshaper\n\t\t * @type {WaveShaperNode}\n\t\t * @private\n\t\t */\n\t\tthis._shaper = this.input = this.output = this.context.createWaveShaper();\n\n\t\t/**\n\t\t * the waveshapers curve\n\t\t * @type {Float32Array}\n\t\t * @private\n\t\t */\n\t\tthis._curve = null;\n\n\t\tif (Array.isArray(mapping)){\n\t\t\tthis.curve = mapping;\n\t\t} else if (isFinite(mapping) || this.isUndef(mapping)){\n\t\t\tthis._curve = new Float32Array(this.defaultArg(mapping, 1024));\n\t\t} else if (this.isFunction(mapping)){\n\t\t\tthis._curve = new Float32Array(this.defaultArg(bufferLen, 1024));\n\t\t\tthis.setMap(mapping);\n\t\t} \n\t};\n\n\tTone.extend(Tone.WaveShaper, Tone.SignalBase);\n\n\t/**\n\t * Uses a mapping function to set the value of the curve. \n\t * @param {function} mapping The function used to define the values. \n\t * The mapping function take two arguments: \n\t * the first is the value at the current position \n\t * which goes from -1 to 1 over the number of elements\n\t * in the curve array. The second argument is the array position. \n\t * @returns {Tone.WaveShaper} this\n\t * @example\n\t * //map the input signal from [-1, 1] to [0, 10]\n\t * shaper.setMap(function(val, index){\n\t * \treturn (val + 1) * 5;\n\t * })\n\t */\n\tTone.WaveShaper.prototype.setMap = function(mapping){\n\t\tfor (var i = 0, len = this._curve.length; i < len; i++){\n\t\t\tvar normalized = (i / (len - 1)) * 2 - 1;\n\t\t\tthis._curve[i] = mapping(normalized, i);\n\t\t}\n\t\tthis._shaper.curve = this._curve;\n\t\treturn this;\n\t};\n\n\t/**\n\t * The array to set as the waveshaper curve. For linear curves\n\t * array length does not make much difference, but for complex curves\n\t * longer arrays will provide smoother interpolation. \n\t * @memberOf Tone.WaveShaper#\n\t * @type {Array}\n\t * @name curve\n\t */\n\tObject.defineProperty(Tone.WaveShaper.prototype, \"curve\", {\n\t\tget : function(){\n\t\t\treturn this._shaper.curve;\n\t\t},\n\t\tset : function(mapping){\n\t\t\tthis._curve = new Float32Array(mapping);\n\t\t\tthis._shaper.curve = this._curve;\n\t\t}\n\t});\n\n\t/**\n\t * Specifies what type of oversampling (if any) should be used when \n\t * applying the shaping curve. Can either be \"none\", \"2x\" or \"4x\". \n\t * @memberOf Tone.WaveShaper#\n\t * @type {string}\n\t * @name oversample\n\t */\n\tObject.defineProperty(Tone.WaveShaper.prototype, \"oversample\", {\n\t\tget : function(){\n\t\t\treturn this._shaper.oversample;\n\t\t},\n\t\tset : function(oversampling){\n\t\t\tif ([\"none\", \"2x\", \"4x\"].indexOf(oversampling) !== -1){\n\t\t\t\tthis._shaper.oversample = oversampling;\n\t\t\t} else {\n\t\t\t\tthrow new RangeError(\"Tone.WaveShaper: oversampling must be either 'none', '2x', or '4x'\");\n\t\t\t}\n\t\t}\n\t});\n\n\t/**\n\t * Clean up.\n\t * @returns {Tone.WaveShaper} this\n\t */\n\tTone.WaveShaper.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._shaper.disconnect();\n\t\tthis._shaper = null;\n\t\tthis._curve = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.WaveShaper;\n});","define([\"Tone/core/Tone\", \"Tone/signal/Signal\", \"Tone/core/Gain\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Add a signal and a number or two signals. When no value is\n\t * passed into the constructor, Tone.Add will sum input[0]\n\t * and input[1]. If a value is passed into the constructor, \n\t * the it will be added to the input.\n\t * \n\t * @constructor\n\t * @extends {Tone.Signal}\n\t * @param {number=} value If no value is provided, Tone.Add will sum the first\n\t * and second inputs. \n\t * @example\n\t * var signal = new Tone.Signal(2);\n\t * var add = new Tone.Add(2);\n\t * signal.connect(add);\n\t * //the output of add equals 4\n\t * @example\n\t * //if constructed with no arguments\n\t * //it will add the first and second inputs\n\t * var add = new Tone.Add();\n\t * var sig0 = new Tone.Signal(3).connect(add, 0, 0);\n\t * var sig1 = new Tone.Signal(4).connect(add, 0, 1);\n\t * //the output of add equals 7. \n\t */\n\tTone.Add = function(value){\n\n\t\tthis.createInsOuts(2, 0);\n\n\t\t/**\n\t\t * the summing node\n\t\t * @type {GainNode}\n\t\t * @private\n\t\t */\n\t\tthis._sum = this.input[0] = this.input[1] = this.output = new Tone.Gain();\n\n\t\t/**\n\t\t * @private\n\t\t * @type {Tone.Signal}\n\t\t */\n\t\tthis._param = this.input[1] = new Tone.Signal(value);\n\n\t\tthis._param.connect(this._sum);\n\t};\n\n\tTone.extend(Tone.Add, Tone.Signal);\n\t\n\t/**\n\t * Clean up.\n\t * @returns {Tone.Add} this\n\t */\n\tTone.Add.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._sum.dispose();\n\t\tthis._sum = null;\n\t\tthis._param.dispose();\n\t\tthis._param = null;\n\t\treturn this;\n\t}; \n\n\treturn Tone.Add;\n});","define([\"Tone/core/Tone\", \"Tone/type/Time\", \"Tone/type/Frequency\", \"Tone/type/TransportTime\", \"Tone/core/Context\"],\nfunction (Tone) {\t\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tTYPES\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Units which a value can take on.\n\t * @enum {String}\n\t */\n\tTone.Type = {\n\t\t/** \n\t\t * Default units\n\t\t * @typedef {Default}\n\t\t */\n\t\tDefault : \"number\",\n\t\t/**\n\t\t * Time can be described in a number of ways. Read more [Time](https://github.com/Tonejs/Tone.js/wiki/Time).\n\t\t *\n\t\t *
    \n\t\t *
  • Numbers, which will be taken literally as the time (in seconds).
    • \n\t\t *
  • Notation, (\"4n\", \"8t\") describes time in BPM and time signature relative values.
    • \n\t\t *
  • TransportTime, (\"4:3:2\") will also provide tempo and time signature relative times \n\t\t * in the form BARS:QUARTERS:SIXTEENTHS.
    • \n\t\t *
  • Frequency, (\"8hz\") is converted to the length of the cycle in seconds.
    • \n\t\t *
  • Now-Relative, (\"+1\") prefix any of the above with \"+\" and it will be interpreted as \n\t\t * \"the current time plus whatever expression follows\".
    • \n\t\t *
  • Expressions, (\"3:0 + 2 - (1m / 7)\") any of the above can also be combined \n\t\t * into a mathematical expression which will be evaluated to compute the desired time.
    • \n\t\t *
  • No Argument, for methods which accept time, no argument will be interpreted as \n\t\t * \"now\" (i.e. the currentTime).
    • \n\t\t *
\n\t\t * \n\t\t * @typedef {Time}\n\t\t */\n\t\tTime : \"time\",\n\t\t/**\n\t\t * Frequency can be described similar to time, except ultimately the\n\t\t * values are converted to frequency instead of seconds. A number\n\t\t * is taken literally as the value in hertz. Additionally any of the \n\t\t * Time encodings can be used. Note names in the form\n\t\t * of NOTE OCTAVE (i.e. C4) are also accepted and converted to their\n\t\t * frequency value. \n\t\t * @typedef {Frequency}\n\t\t */\n\t\tFrequency : \"frequency\",\n\t\t/**\n\t\t * TransportTime describes a position along the Transport's timeline. It is\n\t\t * similar to Time in that it uses all the same encodings, but TransportTime specifically\n\t\t * pertains to the Transport's timeline, which is startable, stoppable, loopable, and seekable. \n\t\t * [Read more](https://github.com/Tonejs/Tone.js/wiki/TransportTime)\n\t\t * @typedef {TransportTime}\n\t\t */\n\t\tTransportTime : \"transportTime\",\n\t\t/** \n\t\t * Ticks are the basic subunit of the Transport. They are\n\t\t * the smallest unit of time that the Transport supports.\n\t\t * @typedef {Ticks}\n\t\t */\n\t\tTicks : \"ticks\",\n\t\t/** \n\t\t * Normal values are within the range [0, 1].\n\t\t * @typedef {NormalRange}\n\t\t */\n\t\tNormalRange : \"normalRange\",\n\t\t/** \n\t\t * AudioRange values are between [-1, 1].\n\t\t * @typedef {AudioRange}\n\t\t */\n\t\tAudioRange : \"audioRange\",\n\t\t/** \n\t\t * Decibels are a logarithmic unit of measurement which is useful for volume\n\t\t * because of the logarithmic way that we perceive loudness. 0 decibels \n\t\t * means no change in volume. -10db is approximately half as loud and 10db \n\t\t * is twice is loud. \n\t\t * @typedef {Decibels}\n\t\t */\n\t\tDecibels : \"db\",\n\t\t/** \n\t\t * Half-step note increments, i.e. 12 is an octave above the root. and 1 is a half-step up.\n\t\t * @typedef {Interval}\n\t\t */\n\t\tInterval : \"interval\",\n\t\t/** \n\t\t * Beats per minute. \n\t\t * @typedef {BPM}\n\t\t */\n\t\tBPM : \"bpm\",\n\t\t/** \n\t\t * The value must be greater than or equal to 0.\n\t\t * @typedef {Positive}\n\t\t */\n\t\tPositive : \"positive\",\n\t\t/** \n\t\t * A cent is a hundredth of a semitone. \n\t\t * @typedef {Cents}\n\t\t */\n\t\tCents : \"cents\",\n\t\t/** \n\t\t * Angle between 0 and 360. \n\t\t * @typedef {Degrees}\n\t\t */\n\t\tDegrees : \"degrees\",\n\t\t/** \n\t\t * A number representing a midi note.\n\t\t * @typedef {MIDI}\n\t\t */\n\t\tMIDI : \"midi\",\n\t\t/** \n\t\t * A colon-separated representation of time in the form of\n\t\t * Bars:Beats:Sixteenths. \n\t\t * @typedef {BarsBeatsSixteenths}\n\t\t */\n\t\tBarsBeatsSixteenths : \"barsBeatsSixteenths\",\n\t\t/** \n\t\t * Sampling is the reduction of a continuous signal to a discrete signal.\n\t\t * Audio is typically sampled 44100 times per second. \n\t\t * @typedef {Samples}\n\t\t */\n\t\tSamples : \"samples\",\n\t\t/** \n\t\t * Hertz are a frequency representation defined as one cycle per second.\n\t\t * @typedef {Hertz}\n\t\t */\n\t\tHertz : \"hertz\",\n\t\t/** \n\t\t * A frequency represented by a letter name, \n\t\t * accidental and octave. This system is known as\n\t\t * [Scientific Pitch Notation](https://en.wikipedia.org/wiki/Scientific_pitch_notation).\n\t\t * @typedef {Note}\n\t\t */\n\t\tNote : \"note\",\n\t\t/** \n\t\t * One millisecond is a thousandth of a second. \n\t\t * @typedef {Milliseconds}\n\t\t */\n\t\tMilliseconds : \"milliseconds\",\n\t\t/** \n\t\t * Seconds are the time unit of the AudioContext. In the end, \n\t\t * all values need to be evaluated to seconds. \n\t\t * @typedef {Seconds}\n\t\t */\n\t\tSeconds : \"seconds\",\n\t\t/** \n\t\t * A string representing a duration relative to a measure. \n\t\t *
    \n\t\t * \t
  • \"4n\" = quarter note
    • \n\t\t * \t
  • \"2m\" = two measures
    • \n\t\t * \t
  • \"8t\" = eighth-note triplet
    • \n\t\t *
\n\t\t * @typedef {Notation}\n\t\t */\n\t\tNotation : \"notation\",\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t// AUGMENT TONE's PROTOTYPE\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Convert Time into seconds.\n\t * \n\t * Unlike the method which it overrides, this takes into account \n\t * transporttime and musical notation.\n\t *\n\t * Time : 1.40\n\t * Notation: 4n|1m|2t\n\t * Now Relative: +3n\n\t * Math: 3n+16n or even complicated expressions ((3n*2)/6 + 1)\n\t *\n\t * @param {Time} time \n\t * @return {Seconds} \n\t */\n\tTone.prototype.toSeconds = function(time){\n\t\tif (this.isNumber(time)){\n\t\t\treturn time;\n\t\t} else if (this.isUndef(time)){\n\t\t\treturn this.now();\t\t\t\n\t\t} else if (this.isString(time)){\n\t\t\treturn (new Tone.Time(time)).toSeconds();\n\t\t} else if (time instanceof Tone.TimeBase){\n\t\t\treturn time.toSeconds();\n\t\t}\n\t};\n\n\t/**\n\t * Convert a frequency representation into a number.\n\t * @param {Frequency} freq \n\t * @return {Hertz} the frequency in hertz\n\t */\n\tTone.prototype.toFrequency = function(freq){\n\t\tif (this.isNumber(freq)){\n\t\t\treturn freq;\n\t\t} else if (this.isString(freq) || this.isUndef(freq)){\n\t\t\treturn (new Tone.Frequency(freq)).valueOf();\n\t\t} else if (freq instanceof Tone.TimeBase){\n\t\t\treturn freq.toFrequency();\n\t\t}\n\t};\n\n\t/**\n\t * Convert a time representation into ticks.\n\t * @param {Time} time\n\t * @return {Ticks} the time in ticks\n\t */\n\tTone.prototype.toTicks = function(time){\n\t\tif (this.isNumber(time) || this.isString(time)){\n\t\t\treturn (new Tone.TransportTime(time)).toTicks();\n\t\t} else if (this.isUndef(time)){\n\t\t\treturn Tone.Transport.ticks;\t\t\t\n\t\t} else if (time instanceof Tone.TimeBase){\n\t\t\treturn time.toTicks();\n\t\t}\n\t};\n\n\treturn Tone;\n});","define([\"Tone/core/Tone\", \"Tone/core/Param\", \"Tone/type/Type\"], function (Tone) {\n\n\t\"use strict\";\n\n\t/**\n\t * createGain shim\n\t * @private\n\t */\n\tif (window.GainNode && !AudioContext.prototype.createGain){\n\t\tAudioContext.prototype.createGain = AudioContext.prototype.createGainNode;\n\t}\n\n\t/**\n\t * @class A thin wrapper around the Native Web Audio GainNode.\n\t * The GainNode is a basic building block of the Web Audio\n\t * API and is useful for routing audio and adjusting gains. \n\t * @extends {Tone}\n\t * @param {Number=} gain The initial gain of the GainNode\n\t * @param {Tone.Type=} units The units of the gain parameter. \n\t */\n\tTone.Gain = function(){\n\n\t\tvar options = this.optionsObject(arguments, [\"gain\", \"units\"], Tone.Gain.defaults);\n\n\t\t/**\n\t\t * The GainNode\n\t\t * @type {GainNode}\n\t\t * @private\n\t\t */\n\t\tthis.input = this.output = this._gainNode = this.context.createGain();\n\n\t\t/**\n\t\t * The gain parameter of the gain node.\n\t\t * @type {Tone.Param}\n\t\t * @signal\n\t\t */\n\t\tthis.gain = new Tone.Param({\n\t\t\t\"param\" : this._gainNode.gain, \n\t\t\t\"units\" : options.units,\n\t\t\t\"value\" : options.gain,\n\t\t\t\"convert\" : options.convert\n\t\t});\n\t\tthis._readOnly(\"gain\");\n\t};\n\n\tTone.extend(Tone.Gain);\n\n\t/**\n\t * The defaults\n\t * @const\n\t * @type {Object}\n\t */\n\tTone.Gain.defaults = {\n\t\t\"gain\" : 1,\n\t\t\"convert\" : true,\n\t};\n\n\t/**\n\t * Clean up.\n\t * @return {Tone.Gain} this\n\t */\n\tTone.Gain.prototype.dispose = function(){\n\t\tTone.Param.prototype.dispose.call(this);\n\t\tthis._gainNode.disconnect();\n\t\tthis._gainNode = null;\n\t\tthis._writable(\"gain\");\n\t\tthis.gain.dispose();\n\t\tthis.gain = null;\n\t};\n\n\t//STATIC///////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Create input and outputs for this object.\n\t * @param {Number} input The number of inputs\n\t * @param {Number=} outputs The number of outputs\n\t * @return {Tone} this\n\t * @internal\n\t */\n\tTone.prototype.createInsOuts = function(inputs, outputs){\n\n\t\tif (inputs === 1){\n\t\t\tthis.input = new Tone.Gain();\n\t\t} else if (inputs > 1){\n\t\t\tthis.input = new Array(inputs);\n\t\t}\n\n\t\tif (outputs === 1){\n\t\t\tthis.output = new Tone.Gain();\n\t\t} else if (outputs > 1){\n\t\t\tthis.output = new Array(inputs);\n\t\t}\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\n\treturn Tone.Gain;\n});","module.exports = {\n recorderProcessor: 'recorder-processor',\n soundFileProcessor: 'sound-file-processor',\n amplitudeProcessor: 'amplitude-processor'\n};\n","'use strict';\n\ndefine(function () {\n /*\n Helper function to generate an error\n with a custom stack trace that points to the sketch\n and removes other parts of the stack trace.\n\n @private\n @class customError\n @constructor\n @param {String} name custom error name\n @param {String} errorTrace custom error trace\n @param {String} failedPath path to the file that failed to load\n @property {String} name custom error name\n @property {String} message custom error message\n @property {String} stack trace the error back to a line in the user's sketch.\n Note: this edits out stack trace within p5.js and p5.sound.\n @property {String} originalStack unedited, original stack trace\n @property {String} failedPath path to the file that failed to load\n @return {Error} returns a custom Error object\n */\n var CustomError = function(name, errorTrace, failedPath) {\n var err = new Error();\n var tempStack, splitStack;\n\n err.name = name;\n err.originalStack = err.stack + errorTrace;\n tempStack = err.stack + errorTrace;\n err.failedPath = failedPath;\n\n // only print the part of the stack trace that refers to the user code:\n var splitStack = tempStack.split('\\n');\n splitStack = splitStack.filter(function(ln) {\n return !ln.match(/(p5.|native code|globalInit)/g);\n });\n err.stack = splitStack.join('\\n');\n\n return err; // TODO: is this really a constructor?\n };\n\n return CustomError;\n});\n","define([\"Tone/core/Tone\", \"Tone/core/Emitter\"], function (Tone) {\n\n\t/**\n\t * shim\n\t * @private\n\t */\n\tif (!window.hasOwnProperty(\"AudioContext\") && window.hasOwnProperty(\"webkitAudioContext\")){\n\t\twindow.AudioContext = window.webkitAudioContext;\n\t}\n\n\t/**\n\t * @class Wrapper around the native AudioContext.\n\t * @extends {Tone.Emitter}\n\t * @param {AudioContext=} context optionally pass in a context\n\t */\n\tTone.Context = function(context){\n\n\t\tTone.Emitter.call(this);\n\n\t\tif (!context){\n\t\t\tcontext = new window.AudioContext();\n\t\t}\n\t\tthis._context = context;\n\t\t// extend all of the methods\n\t\tfor (var prop in this._context){\n\t\t\tthis._defineProperty(this._context, prop);\n\t\t}\n\n\t\t///////////////////////////////////////////////////////////////////////\n\t\t// WORKER\n\t\t///////////////////////////////////////////////////////////////////////\n\n\t\t/**\n\t\t * The default latency hint\n\t\t * @type {String}\n\t\t * @private\n\t\t */\n\t\tthis._latencyHint = \"interactive\";\n\n\t\t/**\n\t\t * The amount of time events are scheduled\n\t\t * into the future\n\t\t * @type {Number}\n\t\t * @private\n\t\t */\n\t\tthis._lookAhead = 0.1;\n\n\t\t/**\n\t\t * How often the update look runs\n\t\t * @type {Number}\n\t\t * @private\n\t\t */\n\t\tthis._updateInterval = this._lookAhead/3;\n\n\t\t/**\n\t\t * A reference to the actual computed update interval\n\t\t * @type {Number}\n\t\t * @private\n\t\t */\n\t\tthis._computedUpdateInterval = 0;\n\n\t\t/**\n\t\t * The web worker which is used to update Tone.Clock\n\t\t * @private\n\t\t * @type {WebWorker}\n\t\t */\n\t\tthis._worker = this._createWorker();\n\n\t\t/**\n\t\t * An object containing all of the constants AudioBufferSourceNodes\n\t\t * @type {Object}\n\t\t * @private\n\t\t */\n\t\tthis._constants = {};\n\n\t};\n\n\tTone.extend(Tone.Context, Tone.Emitter);\n\tTone.Emitter.mixin(Tone.Context);\n\n\t/**\n\t * Define a property on this Tone.Context. \n\t * This is used to extend the native AudioContext\n\t * @param {AudioContext} context\n\t * @param {String} prop \n\t * @private\n\t */\n\tTone.Context.prototype._defineProperty = function(context, prop){\n\t\tif (this.isUndef(this[prop])){\n\t\t\tObject.defineProperty(this, prop, {\n\t\t\t\tget : function(){\n\t\t\t\t\tif (typeof context[prop] === \"function\"){\n\t\t\t\t\t\treturn context[prop].bind(context);\n\t\t\t\t\t} else {\n\t\t\t\t\t\treturn context[prop];\n\t\t\t\t\t}\n\t\t\t\t},\n\t\t\t\tset : function(val){\n\t\t\t\t\tcontext[prop] = val;\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\t};\n\n\t/**\n\t * The current audio context time\n\t * @return {Number}\n\t */\n\tTone.Context.prototype.now = function(){\n\t\treturn this._context.currentTime;\n\t};\n\n\t/**\n\t * Generate a web worker\n\t * @return {WebWorker}\n\t * @private\n\t */\n\tTone.Context.prototype._createWorker = function(){\n\t\t\n\t\t//URL Shim\n\t\twindow.URL = window.URL || window.webkitURL;\n\n\t\tvar blob = new Blob([\n\t\t\t//the initial timeout time\n\t\t\t\"var timeoutTime = \"+(this._updateInterval * 1000).toFixed(1)+\";\" +\n\t\t\t//onmessage callback\n\t\t\t\"self.onmessage = function(msg){\" +\n\t\t\t\"\ttimeoutTime = parseInt(msg.data);\" + \n\t\t\t\"};\" + \n\t\t\t//the tick function which posts a message\n\t\t\t//and schedules a new tick\n\t\t\t\"function tick(){\" +\n\t\t\t\"\tsetTimeout(tick, timeoutTime);\" +\n\t\t\t\"\tself.postMessage('tick');\" +\n\t\t\t\"}\" +\n\t\t\t//call tick initially\n\t\t\t\"tick();\"\n\t\t]);\n\t\tvar blobUrl = URL.createObjectURL(blob);\n\t\tvar worker = new Worker(blobUrl);\n\n\t\tworker.addEventListener(\"message\", function(){\n\t\t\t// tick the clock\n\t\t\tthis.emit(\"tick\");\n\t\t}.bind(this));\n\n\t\t//lag compensation\n\t\tworker.addEventListener(\"message\", function(){\n\t\t\tvar now = this.now();\n\t\t\tif (this.isNumber(this._lastUpdate)){\n\t\t\t\tvar diff = now - this._lastUpdate;\n\t\t\t\tthis._computedUpdateInterval = Math.max(diff, this._computedUpdateInterval * 0.97);\n\t\t\t}\n\t\t\tthis._lastUpdate = now;\n\t\t}.bind(this));\n\n\t\treturn worker;\n\t};\n\n\t/**\n\t * Generate a looped buffer at some constant value.\n\t * @param {Number} val\n\t * @return {BufferSourceNode}\n\t */\n\tTone.Context.prototype.getConstant = function(val){\n\t\tif (this._constants[val]){\n\t\t\treturn this._constants[val];\n\t\t} else {\n\t\t\tvar buffer = this._context.createBuffer(1, 128, this._context.sampleRate);\n\t\t\tvar arr = buffer.getChannelData(0);\n\t\t\tfor (var i = 0; i < arr.length; i++){\n\t\t\t\tarr[i] = val;\n\t\t\t}\n\t\t\tvar constant = this._context.createBufferSource();\n\t\t\tconstant.channelCount = 1;\n\t\t\tconstant.channelCountMode = \"explicit\";\n\t\t\tconstant.buffer = buffer;\n\t\t\tconstant.loop = true;\n\t\t\tconstant.start(0);\n\t\t\tthis._constants[val] = constant;\n\t\t\treturn constant;\n\t\t}\n\t};\n\n\t/**\n\t * This is the time that the clock is falling behind\n\t * the scheduled update interval. The Context automatically\n\t * adjusts for the lag and schedules further in advance.\n\t * @type {Number}\n\t * @memberOf Tone.Context\n\t * @name lag\n\t * @static\n\t * @readOnly\n\t */\n\tObject.defineProperty(Tone.Context.prototype, \"lag\", {\n\t\tget : function(){\n\t\t\tvar diff = this._computedUpdateInterval - this._updateInterval;\n\t\t\tdiff = Math.max(diff, 0);\n\t\t\treturn diff;\n\t\t}\n\t});\n\n\t/**\n\t * The amount of time in advance that events are scheduled.\n\t * The lookAhead will adjust slightly in response to the \n\t * measured update time to try to avoid clicks.\n\t * @type {Number}\n\t * @memberOf Tone.Context\n\t * @name lookAhead\n\t * @static\n\t */\n\tObject.defineProperty(Tone.Context.prototype, \"lookAhead\", {\n\t\tget : function(){\n\t\t\treturn this._lookAhead;\n\t\t},\n\t\tset : function(lA){\n\t\t\tthis._lookAhead = lA;\n\t\t}\n\t});\n\n\t/**\n\t * How often the Web Worker callback is invoked.\n\t * This number corresponds to how responsive the scheduling\n\t * can be. Context.updateInterval + Context.lookAhead gives you the\n\t * total latency between scheduling an event and hearing it.\n\t * @type {Number}\n\t * @memberOf Tone.Context\n\t * @name updateInterval\n\t * @static\n\t */\n\tObject.defineProperty(Tone.Context.prototype, \"updateInterval\", {\n\t\tget : function(){\n\t\t\treturn this._updateInterval;\n\t\t},\n\t\tset : function(interval){\n\t\t\tthis._updateInterval = Math.max(interval, Tone.prototype.blockTime);\n\t\t\tthis._worker.postMessage(Math.max(interval * 1000, 1));\n\t\t}\n\t});\n\n\t/**\n\t * The type of playback, which affects tradeoffs between audio \n\t * output latency and responsiveness. \n\t * \n\t * In addition to setting the value in seconds, the latencyHint also\n\t * accepts the strings \"interactive\" (prioritizes low latency), \n\t * \"playback\" (prioritizes sustained playback), \"balanced\" (balances\n\t * latency and performance), and \"fastest\" (lowest latency, might glitch more often). \n\t * @type {String|Seconds}\n\t * @memberOf Tone.Context#\n\t * @name latencyHint\n\t * @static\n\t * @example\n\t * //set the lookAhead to 0.3 seconds\n\t * Tone.context.latencyHint = 0.3;\n\t */\n\tObject.defineProperty(Tone.Context.prototype, \"latencyHint\", {\n\t\tget : function(){\n\t\t\treturn this._latencyHint;\n\t\t},\n\t\tset : function(hint){\n\t\t\tvar lookAhead = hint;\n\t\t\tthis._latencyHint = hint;\n\t\t\tif (this.isString(hint)){\n\t\t\t\tswitch(hint){\n\t\t\t\t\tcase \"interactive\" :\n\t\t\t\t\t\tlookAhead = 0.1;\n\t\t\t\t\t\tthis._context.latencyHint = hint;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase \"playback\" :\n\t\t\t\t\t\tlookAhead = 0.8;\n\t\t\t\t\t\tthis._context.latencyHint = hint;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase \"balanced\" :\n\t\t\t\t\t\tlookAhead = 0.25;\n\t\t\t\t\t\tthis._context.latencyHint = hint;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase \"fastest\" :\n\t\t\t\t\t\tlookAhead = 0.01;\n\t\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis.lookAhead = lookAhead;\n\t\t\tthis.updateInterval = lookAhead/3;\n\t\t}\n\t});\n\n\t/**\n\t * Shim all connect/disconnect and some deprecated methods which are still in\n\t * some older implementations.\n\t * @private\n\t */\n\tfunction shimConnect(){\n\n\t\tvar nativeConnect = AudioNode.prototype.connect;\n\t\tvar nativeDisconnect = AudioNode.prototype.disconnect;\n\n\t\t//replace the old connect method\n\t\tfunction toneConnect(B, outNum, inNum){\n\t\t\tif (B.input){\n\t\t\t\tif (Array.isArray(B.input)){\n\t\t\t\t\tif (Tone.prototype.isUndef(inNum)){\n\t\t\t\t\t\tinNum = 0;\n\t\t\t\t\t}\n\t\t\t\t\tthis.connect(B.input[inNum]);\n\t\t\t\t} else {\n\t\t\t\t\tthis.connect(B.input, outNum, inNum);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\ttry {\n\t\t\t\t\tif (B instanceof AudioNode){\n\t\t\t\t\t\tnativeConnect.call(this, B, outNum, inNum);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tnativeConnect.call(this, B, outNum);\n\t\t\t\t\t}\n\t\t\t\t} catch (e) {\n\t\t\t\t\tthrow new Error(\"error connecting to node: \"+B+\"\\n\"+e);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t//replace the old disconnect method\n\t\tfunction toneDisconnect(B, outNum, inNum){\n\t\t\tif (B && B.input && Array.isArray(B.input)){\n\t\t\t\tif (Tone.prototype.isUndef(inNum)){\n\t\t\t\t\tinNum = 0;\n\t\t\t\t}\n\t\t\t\tthis.disconnect(B.input[inNum], outNum, inNum);\n\t\t\t} else if (B && B.input){\n\t\t\t\tthis.disconnect(B.input, outNum, inNum);\n\t\t\t} else {\n\t\t\t\ttry {\n\t\t\t\t\tnativeDisconnect.apply(this, arguments);\n\t\t\t\t} catch (e) {\n\t\t\t\t\tthrow new Error(\"error disconnecting node: \"+B+\"\\n\"+e);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif (AudioNode.prototype.connect !== toneConnect){\n\t\t\tAudioNode.prototype.connect = toneConnect;\n\t\t\tAudioNode.prototype.disconnect = toneDisconnect;\n\t\t}\n\t}\n\n\t// set the audio context initially\n\tif (Tone.supported){\n\t\tshimConnect();\n\t\tTone.context = new Tone.Context();\n\t} else {\n\t\tconsole.warn(\"This browser does not support Tone.js\");\n\t}\n\n\treturn Tone.Context;\n});","define([\"Tone/core/Tone\", \"Tone/signal/Add\", \"Tone/signal/Multiply\", \"Tone/signal/Signal\"], function(Tone){\n\n\t\"use strict\";\n\t\n\t/**\n\t * @class Performs a linear scaling on an input signal.\n\t * Scales a NormalRange input to between\n\t * outputMin and outputMax.\n\t *\n\t * @constructor\n\t * @extends {Tone.SignalBase}\n\t * @param {number} [outputMin=0] The output value when the input is 0. \n\t * @param {number} [outputMax=1]\tThe output value when the input is 1. \n\t * @example\n\t * var scale = new Tone.Scale(50, 100);\n\t * var signal = new Tone.Signal(0.5).connect(scale);\n\t * //the output of scale equals 75\n\t */\n\tTone.Scale = function(outputMin, outputMax){\n\n\t\t/** \n\t\t * @private\n\t\t * @type {number}\n\t\t */\n\t\tthis._outputMin = this.defaultArg(outputMin, 0);\n\n\t\t/** \n\t\t * @private\n\t\t * @type {number}\n\t\t */\n\t\tthis._outputMax = this.defaultArg(outputMax, 1);\n\n\n\t\t/** \n\t\t * @private\n\t\t * @type {Tone.Multiply}\n\t\t * @private\n\t\t */\n\t\tthis._scale = this.input = new Tone.Multiply(1);\n\t\t\n\t\t/** \n\t\t * @private\n\t\t * @type {Tone.Add}\n\t\t * @private\n\t\t */\n\t\tthis._add = this.output = new Tone.Add(0);\n\n\t\tthis._scale.connect(this._add);\n\t\tthis._setRange();\n\t};\n\n\tTone.extend(Tone.Scale, Tone.SignalBase);\n\n\t/**\n\t * The minimum output value. This number is output when \n\t * the value input value is 0. \n\t * @memberOf Tone.Scale#\n\t * @type {number}\n\t * @name min\n\t */\n\tObject.defineProperty(Tone.Scale.prototype, \"min\", {\n\t\tget : function(){\n\t\t\treturn this._outputMin;\n\t\t},\n\t\tset : function(min){\n\t\t\tthis._outputMin = min;\n\t\t\tthis._setRange();\n\t\t}\n\t});\n\n\t/**\n\t * The maximum output value. This number is output when \n\t * the value input value is 1. \n\t * @memberOf Tone.Scale#\n\t * @type {number}\n\t * @name max\n\t */\n\tObject.defineProperty(Tone.Scale.prototype, \"max\", {\n\t\tget : function(){\n\t\t\treturn this._outputMax;\n\t\t},\n\t\tset : function(max){\n\t\t\tthis._outputMax = max;\n\t\t\tthis._setRange();\n\t\t}\n\t});\n\n\t/**\n\t * set the values\n\t * @private\n\t */\n\tTone.Scale.prototype._setRange = function() {\n\t\tthis._add.value = this._outputMin;\n\t\tthis._scale.value = this._outputMax - this._outputMin;\n\t};\n\n\t/**\n\t * Clean up.\n\t * @returns {Tone.Scale} this\n\t */\n\tTone.Scale.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._add.dispose();\n\t\tthis._add = null;\n\t\tthis._scale.dispose();\n\t\tthis._scale = null;\n\t\treturn this;\n\t}; \n\n\treturn Tone.Scale;\n});\n","define([\"Tone/core/Tone\", \"Tone/signal/Signal\", \"Tone/core/Timeline\"], function (Tone) {\n\n\t\"use strict\";\n\n\t/**\n\t * @class A signal which adds the method getValueAtTime. \n\t * Code and inspiration from https://github.com/jsantell/web-audio-automation-timeline\n\t * @extends {Tone.Param}\n\t * @param {Number=} value The initial value of the signal\n\t * @param {String=} units The conversion units of the signal.\n\t */\n\tTone.TimelineSignal = function(){\n\n\t\tvar options = this.optionsObject(arguments, [\"value\", \"units\"], Tone.Signal.defaults);\n\t\t\n\t\t/**\n\t\t * The scheduled events\n\t\t * @type {Tone.Timeline}\n\t\t * @private\n\t\t */\n\t\tthis._events = new Tone.Timeline(10);\n\n\t\t//constructors\n\t\tTone.Signal.apply(this, options);\n\t\toptions.param = this._param;\n\t\tTone.Param.call(this, options);\n\n\t\t/**\n\t\t * The initial scheduled value\n\t\t * @type {Number}\n\t\t * @private\n\t\t */\n\t\tthis._initial = this._fromUnits(this._param.value);\n\t};\n\n\tTone.extend(Tone.TimelineSignal, Tone.Param);\n\n\t/**\n\t * The event types of a schedulable signal.\n\t * @enum {String}\n\t * @private\n\t */\n\tTone.TimelineSignal.Type = {\n\t\tLinear : \"linear\",\n\t\tExponential : \"exponential\",\n\t\tTarget : \"target\",\n\t\tCurve : \"curve\",\n\t\tSet : \"set\"\n\t};\n\n\t/**\n\t * The current value of the signal. \n\t * @memberOf Tone.TimelineSignal#\n\t * @type {Number}\n\t * @name value\n\t */\n\tObject.defineProperty(Tone.TimelineSignal.prototype, \"value\", {\n\t\tget : function(){\n\t\t\tvar now = this.now();\n\t\t\tvar val = this.getValueAtTime(now);\n\t\t\treturn this._toUnits(val);\n\t\t},\n\t\tset : function(value){\n\t\t\tvar convertedVal = this._fromUnits(value);\n\t\t\tthis._initial = convertedVal;\n\t\t\tthis.cancelScheduledValues();\n\t\t\tthis._param.value = convertedVal;\n\t\t}\n\t});\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tSCHEDULING\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Schedules a parameter value change at the given time.\n\t * @param {*}\tvalue The value to set the signal.\n\t * @param {Time} time The time when the change should occur.\n\t * @returns {Tone.TimelineSignal} this\n\t * @example\n\t * //set the frequency to \"G4\" in exactly 1 second from now. \n\t * freq.setValueAtTime(\"G4\", \"+1\");\n\t */\n\tTone.TimelineSignal.prototype.setValueAtTime = function (value, startTime) {\n\t\tvalue = this._fromUnits(value);\n\t\tstartTime = this.toSeconds(startTime);\n\t\tthis._events.add({\n\t\t\t\"type\" : Tone.TimelineSignal.Type.Set,\n\t\t\t\"value\" : value,\n\t\t\t\"time\" : startTime\n\t\t});\n\t\t//invoke the original event\n\t\tthis._param.setValueAtTime(value, startTime);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Schedules a linear continuous change in parameter value from the \n\t * previous scheduled parameter value to the given value.\n\t * \n\t * @param {number} value \n\t * @param {Time} endTime \n\t * @returns {Tone.TimelineSignal} this\n\t */\n\tTone.TimelineSignal.prototype.linearRampToValueAtTime = function (value, endTime) {\n\t\tvalue = this._fromUnits(value);\n\t\tendTime = this.toSeconds(endTime);\n\t\tthis._events.add({\n\t\t\t\"type\" : Tone.TimelineSignal.Type.Linear,\n\t\t\t\"value\" : value,\n\t\t\t\"time\" : endTime\n\t\t});\n\t\tthis._param.linearRampToValueAtTime(value, endTime);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Schedules an exponential continuous change in parameter value from \n\t * the previous scheduled parameter value to the given value.\n\t * \n\t * @param {number} value \n\t * @param {Time} endTime \n\t * @returns {Tone.TimelineSignal} this\n\t */\n\tTone.TimelineSignal.prototype.exponentialRampToValueAtTime = function (value, endTime) {\n\t\t//get the previous event and make sure it's not starting from 0\n\t\tendTime = this.toSeconds(endTime);\n\t\tvar beforeEvent = this._searchBefore(endTime);\n\t\tif (beforeEvent && beforeEvent.value === 0){\n\t\t\t//reschedule that event\n\t\t\tthis.setValueAtTime(this._minOutput, beforeEvent.time);\n\t\t}\n\t\tvalue = this._fromUnits(value);\n\t\tvar setValue = Math.max(value, this._minOutput);\n\t\tthis._events.add({\n\t\t\t\"type\" : Tone.TimelineSignal.Type.Exponential,\n\t\t\t\"value\" : setValue,\n\t\t\t\"time\" : endTime\n\t\t});\n\t\t//if the ramped to value is 0, make it go to the min output, and then set to 0.\n\t\tif (value < this._minOutput){\n\t\t\tthis._param.exponentialRampToValueAtTime(this._minOutput, endTime - this.sampleTime);\n\t\t\tthis.setValueAtTime(0, endTime);\n\t\t} else {\n\t\t\tthis._param.exponentialRampToValueAtTime(value, endTime);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Start exponentially approaching the target value at the given time with\n\t * a rate having the given time constant.\n\t * @param {number} value \n\t * @param {Time} startTime \n\t * @param {number} timeConstant \n\t * @returns {Tone.TimelineSignal} this \n\t */\n\tTone.TimelineSignal.prototype.setTargetAtTime = function (value, startTime, timeConstant) {\n\t\tvalue = this._fromUnits(value);\n\t\tvalue = Math.max(this._minOutput, value);\n\t\ttimeConstant = Math.max(this._minOutput, timeConstant);\n\t\tstartTime = this.toSeconds(startTime);\n\t\tthis._events.add({\n\t\t\t\"type\" : Tone.TimelineSignal.Type.Target,\n\t\t\t\"value\" : value,\n\t\t\t\"time\" : startTime,\n\t\t\t\"constant\" : timeConstant\n\t\t});\n\t\tthis._param.setTargetAtTime(value, startTime, timeConstant);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Set an array of arbitrary values starting at the given time for the given duration.\n\t * @param {Float32Array} values \n\t * @param {Time} startTime \n\t * @param {Time} duration\n\t * @param {NormalRange} [scaling=1] If the values in the curve should be scaled by some value\n\t * @returns {Tone.TimelineSignal} this \n\t */\n\tTone.TimelineSignal.prototype.setValueCurveAtTime = function (values, startTime, duration, scaling) {\n\t\tscaling = this.defaultArg(scaling, 1);\n\t\t//copy the array\n\t\tvar floats = new Array(values.length);\n\t\tfor (var i = 0; i < floats.length; i++){\n\t\t\tfloats[i] = this._fromUnits(values[i]) * scaling;\n\t\t}\n\t\tstartTime = this.toSeconds(startTime);\n\t\tduration = this.toSeconds(duration);\n\t\tthis._events.add({\n\t\t\t\"type\" : Tone.TimelineSignal.Type.Curve,\n\t\t\t\"value\" : floats,\n\t\t\t\"time\" : startTime,\n\t\t\t\"duration\" : duration\n\t\t});\n\t\t//set the first value\n\t\tthis._param.setValueAtTime(floats[0], startTime);\n\t\t//schedule a lienar ramp for each of the segments\n\t\tfor (var j = 1; j < floats.length; j++){\n\t\t\tvar segmentTime = startTime + (j / (floats.length - 1) * duration);\n\t\t\tthis._param.linearRampToValueAtTime(floats[j], segmentTime);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Cancels all scheduled parameter changes with times greater than or \n\t * equal to startTime.\n\t * \n\t * @param {Time} startTime\n\t * @returns {Tone.TimelineSignal} this\n\t */\n\tTone.TimelineSignal.prototype.cancelScheduledValues = function (after) {\n\t\tafter = this.toSeconds(after);\n\t\tthis._events.cancel(after);\n\t\tthis._param.cancelScheduledValues(after);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Sets the computed value at the given time. This provides\n\t * a point from which a linear or exponential curve\n\t * can be scheduled after. Will cancel events after \n\t * the given time and shorten the currently scheduled\n\t * linear or exponential ramp so that it ends at `time` .\n\t * This is to avoid discontinuities and clicks in envelopes. \n\t * @param {Time} time When to set the ramp point\n\t * @returns {Tone.TimelineSignal} this\n\t */\n\tTone.TimelineSignal.prototype.setRampPoint = function (time) {\n\t\ttime = this.toSeconds(time);\n\t\t//get the value at the given time\n\t\tvar val = this._toUnits(this.getValueAtTime(time));\n\t\t//if there is an event at the given time\n\t\t//and that even is not a \"set\"\n\t\tvar before = this._searchBefore(time);\n\t\tif (before && before.time === time){\n\t\t\t//remove everything after\n\t\t\tthis.cancelScheduledValues(time + this.sampleTime);\n\t\t} else if (before && \n\t\t\t\t before.type === Tone.TimelineSignal.Type.Curve &&\n\t\t\t\t before.time + before.duration > time){\n\t\t\t//if the curve is still playing\n\t\t\t//cancel the curve\n\t\t\tthis.cancelScheduledValues(time);\n\t\t\tthis.linearRampToValueAtTime(val, time);\n\t\t} else {\n\t\t\t//reschedule the next event to end at the given time\n\t\t\tvar after = this._searchAfter(time);\n\t\t\tif (after){\n\t\t\t\t//cancel the next event(s)\n\t\t\t\tthis.cancelScheduledValues(time);\n\t\t\t\tif (after.type === Tone.TimelineSignal.Type.Linear){\n\t\t\t\t\tthis.linearRampToValueAtTime(val, time);\n\t\t\t\t} else if (after.type === Tone.TimelineSignal.Type.Exponential){\n\t\t\t\t\tthis.exponentialRampToValueAtTime(val, time);\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis.setValueAtTime(val, time);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Do a linear ramp to the given value between the start and finish times.\n\t * @param {Number} value The value to ramp to.\n\t * @param {Time} start The beginning anchor point to do the linear ramp\n\t * @param {Time} finish The ending anchor point by which the value of\n\t * the signal will equal the given value.\n\t * @returns {Tone.TimelineSignal} this\n\t */\n\tTone.TimelineSignal.prototype.linearRampToValueBetween = function (value, start, finish) {\n\t\tthis.setRampPoint(start);\n\t\tthis.linearRampToValueAtTime(value, finish);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Do a exponential ramp to the given value between the start and finish times.\n\t * @param {Number} value The value to ramp to.\n\t * @param {Time} start The beginning anchor point to do the exponential ramp\n\t * @param {Time} finish The ending anchor point by which the value of\n\t * the signal will equal the given value.\n\t * @returns {Tone.TimelineSignal} this\n\t */\n\tTone.TimelineSignal.prototype.exponentialRampToValueBetween = function (value, start, finish) {\n\t\tthis.setRampPoint(start);\n\t\tthis.exponentialRampToValueAtTime(value, finish);\n\t\treturn this;\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tGETTING SCHEDULED VALUES\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Returns the value before or equal to the given time\n\t * @param {Number} time The time to query\n\t * @return {Object} The event at or before the given time.\n\t * @private\n\t */\n\tTone.TimelineSignal.prototype._searchBefore = function(time){\n\t\treturn this._events.get(time);\n\t};\n\n\t/**\n\t * The event after the given time\n\t * @param {Number} time The time to query.\n\t * @return {Object} The next event after the given time\n\t * @private\n\t */\n\tTone.TimelineSignal.prototype._searchAfter = function(time){\n\t\treturn this._events.getAfter(time);\n\t};\n\n\t/**\n\t * Get the scheduled value at the given time. This will\n\t * return the unconverted (raw) value.\n\t * @param {Number} time The time in seconds.\n\t * @return {Number} The scheduled value at the given time.\n\t */\n\tTone.TimelineSignal.prototype.getValueAtTime = function(time){\n\t\ttime = this.toSeconds(time);\n\t\tvar after = this._searchAfter(time);\n\t\tvar before = this._searchBefore(time);\n\t\tvar value = this._initial;\n\t\t//if it was set by\n\t\tif (before === null){\n\t\t\tvalue = this._initial;\n\t\t} else if (before.type === Tone.TimelineSignal.Type.Target){\n\t\t\tvar previous = this._events.getBefore(before.time);\n\t\t\tvar previouVal;\n\t\t\tif (previous === null){\n\t\t\t\tpreviouVal = this._initial;\n\t\t\t} else {\n\t\t\t\tpreviouVal = previous.value;\n\t\t\t}\n\t\t\tvalue = this._exponentialApproach(before.time, previouVal, before.value, before.constant, time);\n\t\t} else if (before.type === Tone.TimelineSignal.Type.Curve){\n\t\t\tvalue = this._curveInterpolate(before.time, before.value, before.duration, time);\n\t\t} else if (after === null){\n\t\t\tvalue = before.value;\n\t\t} else if (after.type === Tone.TimelineSignal.Type.Linear){\n\t\t\tvalue = this._linearInterpolate(before.time, before.value, after.time, after.value, time);\n\t\t} else if (after.type === Tone.TimelineSignal.Type.Exponential){\n\t\t\tvalue = this._exponentialInterpolate(before.time, before.value, after.time, after.value, time);\n\t\t} else {\n\t\t\tvalue = before.value;\n\t\t}\n\t\treturn value;\n\t};\n\n\t/**\n\t * When signals connect to other signals or AudioParams, \n\t * they take over the output value of that signal or AudioParam. \n\t * For all other nodes, the behavior is the same as a default connect. \n\t *\n\t * @override\n\t * @param {AudioParam|AudioNode|Tone.Signal|Tone} node \n\t * @param {number} [outputNumber=0] The output number to connect from.\n\t * @param {number} [inputNumber=0] The input number to connect to.\n\t * @returns {Tone.TimelineSignal} this\n\t * @method\n\t */\n\tTone.TimelineSignal.prototype.connect = Tone.SignalBase.prototype.connect;\n\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tAUTOMATION CURVE CALCULATIONS\n\t//\tMIT License, copyright (c) 2014 Jordan Santell\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Calculates the the value along the curve produced by setTargetAtTime\n\t * @private\n\t */\n\tTone.TimelineSignal.prototype._exponentialApproach = function (t0, v0, v1, timeConstant, t) {\n\t\treturn v1 + (v0 - v1) * Math.exp(-(t - t0) / timeConstant);\n\t};\n\n\t/**\n\t * Calculates the the value along the curve produced by linearRampToValueAtTime\n\t * @private\n\t */\n\tTone.TimelineSignal.prototype._linearInterpolate = function (t0, v0, t1, v1, t) {\n\t\treturn v0 + (v1 - v0) * ((t - t0) / (t1 - t0));\n\t};\n\n\t/**\n\t * Calculates the the value along the curve produced by exponentialRampToValueAtTime\n\t * @private\n\t */\n\tTone.TimelineSignal.prototype._exponentialInterpolate = function (t0, v0, t1, v1, t) {\n\t\tv0 = Math.max(this._minOutput, v0);\n\t\treturn v0 * Math.pow(v1 / v0, (t - t0) / (t1 - t0));\n\t};\n\n\t/**\n\t * Calculates the the value along the curve produced by setValueCurveAtTime\n\t * @private\n\t */\n\tTone.TimelineSignal.prototype._curveInterpolate = function (start, curve, duration, time) {\n\t\tvar len = curve.length;\n\t\t// If time is after duration, return the last curve value\n\t\tif (time >= start + duration) {\n\t\t\treturn curve[len - 1];\n\t\t} else if (time <= start){\n\t\t\treturn curve[0];\n\t\t} else {\n\t\t\tvar progress = (time - start) / duration;\n\t\t\tvar lowerIndex = Math.floor((len - 1) * progress);\n\t\t\tvar upperIndex = Math.ceil((len - 1) * progress);\n\t\t\tvar lowerVal = curve[lowerIndex];\n\t\t\tvar upperVal = curve[upperIndex];\n\t\t\tif (upperIndex === lowerIndex){\n\t\t\t\treturn lowerVal;\n\t\t\t} else {\n\t\t\t\treturn this._linearInterpolate(lowerIndex, lowerVal, upperIndex, upperVal, progress * (len - 1));\n\t\t\t}\n\t\t}\n\t};\n\n\t/**\n\t * Clean up.\n\t * @return {Tone.TimelineSignal} this\n\t */\n\tTone.TimelineSignal.prototype.dispose = function(){\n\t\tTone.Signal.prototype.dispose.call(this);\n\t\tTone.Param.prototype.dispose.call(this);\n\t\tthis._events.dispose();\n\t\tthis._events = null;\n\t};\n\n\treturn Tone.TimelineSignal;\n});","'use strict';\n\ndefine(function (require) {\n var Effect = require('effect');\n\n /**\n *

A p5.Filter uses a Web Audio Biquad Filter to filter\n * the frequency response of an input source. Subclasses\n * include:

\n * p5.LowPass:\n * Allows frequencies below the cutoff frequency to pass through,\n * and attenuates frequencies above the cutoff.
\n * p5.HighPass:\n * The opposite of a lowpass filter.
\n * p5.BandPass:\n * Allows a range of frequencies to pass through and attenuates\n * the frequencies below and above this frequency range.
\n *\n * The .res() method controls either width of the\n * bandpass, or resonance of the low/highpass cutoff frequency.\n *\n * This class extends p5.Effect.\n * Methods amp(), chain(),\n * drywet(), connect(), and\n * disconnect() are available.\n *\n * @class p5.Filter\n * @extends p5.Effect\n * @constructor\n * @param {String} [type] 'lowpass' (default), 'highpass', 'bandpass'\n * @example\n *
\n * let fft, noise, filter;\n *\n * function setup() {\n * let cnv = createCanvas(100,100);\n * cnv.mousePressed(makeNoise);\n * fill(255, 0, 255);\n *\n * filter = new p5.BandPass();\n * noise = new p5.Noise();\n * noise.disconnect();\n * noise.connect(filter);\n *\n * fft = new p5.FFT();\n * }\n *\n * function draw() {\n * background(220);\n *\n * // set the BandPass frequency based on mouseX\n * let freq = map(mouseX, 0, width, 20, 10000);\n * freq = constrain(freq, 0, 22050);\n * filter.freq(freq);\n * // give the filter a narrow band (lower res = wider bandpass)\n * filter.res(50);\n *\n * // draw filtered spectrum\n * let spectrum = fft.analyze();\n * noStroke();\n * for (let i = 0; i < spectrum.length; i++) {\n * let x = map(i, 0, spectrum.length, 0, width);\n * let h = -height + map(spectrum[i], 0, 255, height, 0);\n * rect(x, height, width/spectrum.length, h);\n * }\n * if (!noise.started) {\n * text('tap here and drag to change frequency', 10, 20, width - 20);\n * } else {\n * text('Frequency: ' + round(freq)+'Hz', 20, 20, width - 20);\n * }\n * }\n *\n * function makeNoise() {\n * // see also: `userStartAudio()`\n * noise.start();\n * noise.amp(0.5, 0.2);\n * }\n *\n * function mouseReleased() {\n * noise.amp(0, 0.2);\n * }\n *\n *
\n */\n p5.Filter = function (type) {\n\n Effect.call(this);\n //add extend Effect by adding a Biquad Filter\n\n /**\n * The p5.Filter is built with a\n * \n * Web Audio BiquadFilter Node.\n *\n * @property {DelayNode} biquadFilter\n\t */\n\n this.biquad = this.ac.createBiquadFilter();\n\n this.input.connect(this.biquad);\n\n this.biquad.connect(this.wet);\n\n if (type) {\n this.setType(type);\n }\n\n //Properties useful for the toggle method.\n this._on = true;\n this._untoggledType = this.biquad.type;\n };\n p5.Filter.prototype = Object.create(Effect.prototype);\n\n\n /**\n * Filter an audio signal according to a set\n * of filter parameters.\n *\n * @method process\n * @param {Object} Signal An object that outputs audio\n * @param {Number} [freq] Frequency in Hz, from 10 to 22050\n * @param {Number} [res] Resonance/Width of the filter frequency\n * from 0.001 to 1000\n */\n p5.Filter.prototype.process = function(src, freq, res, time) {\n src.connect(this.input);\n this.set(freq, res, time);\n };\n\n\n /**\n * Set the frequency and the resonance of the filter.\n *\n * @method set\n * @param {Number} [freq] Frequency in Hz, from 10 to 22050\n * @param {Number} [res] Resonance (Q) from 0.001 to 1000\n * @param {Number} [timeFromNow] schedule this event to happen\n * seconds from now\n */\n p5.Filter.prototype.set = function(freq, res, time) {\n if (freq) {\n this.freq(freq, time);\n }\n if (res) {\n this.res(res, time);\n }\n };\n\n /**\n * Set the filter frequency, in Hz, from 10 to 22050 (the range of\n * human hearing, although in reality most people hear in a narrower\n * range).\n *\n * @method freq\n * @param {Number} freq Filter Frequency\n * @param {Number} [timeFromNow] schedule this event to happen\n * seconds from now\n * @return {Number} value Returns the current frequency value\n */\n p5.Filter.prototype.freq = function(freq, time) {\n var t = time || 0;\n if (freq <= 0) {\n freq = 1;\n }\n if (typeof freq === 'number') {\n this.biquad.frequency.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.biquad.frequency.exponentialRampToValueAtTime(freq, this.ac.currentTime + 0.02 + t);\n } else if (freq) {\n freq.connect(this.biquad.frequency);\n }\n return this.biquad.frequency.value;\n };\n\n /**\n * Controls either width of a bandpass frequency,\n * or the resonance of a low/highpass cutoff frequency.\n *\n * @method res\n * @param {Number} res Resonance/Width of filter freq\n * from 0.001 to 1000\n * @param {Number} [timeFromNow] schedule this event to happen\n * seconds from now\n * @return {Number} value Returns the current res value\n */\n p5.Filter.prototype.res = function(res, time) {\n var t = time || 0;\n if (typeof res === 'number') {\n this.biquad.Q.value = res;\n this.biquad.Q.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.biquad.Q.linearRampToValueAtTime(res, this.ac.currentTime + 0.02 + t);\n } else if (res) {\n res.connect(this.biquad.Q);\n }\n return this.biquad.Q.value;\n };\n\n /**\n * Controls the gain attribute of a Biquad Filter.\n * This is distinctly different from .amp() which is inherited from p5.Effect\n * .amp() controls the volume via the output gain node\n * p5.Filter.gain() controls the gain parameter of a Biquad Filter node.\n *\n * @method gain\n * @param {Number} gain\n * @return {Number} Returns the current or updated gain value\n */\n p5.Filter.prototype.gain = function(gain, time) {\n var t = time || 0;\n if (typeof gain === 'number') {\n this.biquad.gain.value = gain;\n this.biquad.gain.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.biquad.gain.linearRampToValueAtTime(gain, this.ac.currentTime + 0.02 + t);\n } else if (gain) {\n gain.connect(this.biquad.gain);\n }\n return this.biquad.gain.value;\n };\n\n\n /**\n * Toggle function. Switches between the specified type and allpass\n *\n * @method toggle\n * @return {boolean} [Toggle value]\n */\n p5.Filter.prototype.toggle = function() {\n this._on = !this._on;\n\n if (this._on === true) {\n this.biquad.type = this._untoggledType;\n } else if (this._on === false) {\n this.biquad.type = 'allpass';\n }\n\n return this._on;\n };\n\n /**\n * Set the type of a p5.Filter. Possible types include:\n * \"lowpass\" (default), \"highpass\", \"bandpass\",\n * \"lowshelf\", \"highshelf\", \"peaking\", \"notch\",\n * \"allpass\".\n *\n * @method setType\n * @param {String} t\n */\n p5.Filter.prototype.setType = function(t) {\n this.biquad.type = t;\n this._untoggledType = this.biquad.type;\n };\n\n p5.Filter.prototype.dispose = function() {\n // remove reference from soundArray\n Effect.prototype.dispose.apply(this);\n if (this.biquad) {\n this.biquad.disconnect();\n delete this.biquad;\n }\n };\n\n /**\n * Constructor: new p5.LowPass() Filter.\n * This is the same as creating a p5.Filter and then calling\n * its method setType('lowpass').\n * See p5.Filter for methods.\n *\n * @class p5.LowPass\n * @constructor\n * @extends p5.Filter\n */\n p5.LowPass = function() {\n p5.Filter.call(this, 'lowpass');\n };\n p5.LowPass.prototype = Object.create(p5.Filter.prototype);\n\n /**\n * Constructor: new p5.HighPass() Filter.\n * This is the same as creating a p5.Filter and then calling\n * its method setType('highpass').\n * See p5.Filter for methods.\n *\n * @class p5.HighPass\n * @constructor\n * @extends p5.Filter\n */\n p5.HighPass = function() {\n p5.Filter.call(this, 'highpass');\n };\n p5.HighPass.prototype = Object.create(p5.Filter.prototype);\n\n /**\n * Constructor: new p5.BandPass() Filter.\n * This is the same as creating a p5.Filter and then calling\n * its method setType('bandpass').\n * See p5.Filter for methods.\n *\n * @class p5.BandPass\n * @constructor\n * @extends p5.Filter\n */\n p5.BandPass = function() {\n p5.Filter.call(this, 'bandpass');\n };\n p5.BandPass.prototype = Object.create(p5.Filter.prototype);\n\n return p5.Filter;\n});\n","define([\"Tone/core/Tone\", \"Tone/signal/Add\", \"Tone/signal/Negate\", \"Tone/signal/Signal\", \"Tone/core/Gain\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Subtract the signal connected to input[1] from the signal connected \n\t * to input[0]. If an argument is provided in the constructor, the \n\t * signals .value will be subtracted from the incoming signal.\n\t *\n\t * @extends {Tone.Signal}\n\t * @constructor\n\t * @param {number=} value The value to subtract from the incoming signal. If the value\n\t * is omitted, it will subtract the second signal from the first.\n\t * @example\n\t * var sub = new Tone.Subtract(1);\n\t * var sig = new Tone.Signal(4).connect(sub);\n\t * //the output of sub is 3. \n\t * @example\n\t * var sub = new Tone.Subtract();\n\t * var sigA = new Tone.Signal(10);\n\t * var sigB = new Tone.Signal(2.5);\n\t * sigA.connect(sub, 0, 0);\n\t * sigB.connect(sub, 0, 1);\n\t * //output of sub is 7.5\n\t */\n\tTone.Subtract = function(value){\n\n\t\tthis.createInsOuts(2, 0);\n\n\t\t/**\n\t\t * the summing node\n\t\t * @type {GainNode}\n\t\t * @private\n\t\t */\n\t\tthis._sum = this.input[0] = this.output = new Tone.Gain();\n\n\t\t/**\n\t\t * negate the input of the second input before connecting it\n\t\t * to the summing node.\n\t\t * @type {Tone.Negate}\n\t\t * @private\n\t\t */\n\t\tthis._neg = new Tone.Negate();\n\n\t\t/**\n\t\t * the node where the value is set\n\t\t * @private\n\t\t * @type {Tone.Signal}\n\t\t */\n\t\tthis._param = this.input[1] = new Tone.Signal(value);\n\n\t\tthis._param.chain(this._neg, this._sum);\n\t};\n\n\tTone.extend(Tone.Subtract, Tone.Signal);\n\n\t/**\n\t * Clean up.\n\t * @returns {Tone.SignalBase} this\n\t */\n\tTone.Subtract.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._neg.dispose();\n\t\tthis._neg = null;\n\t\tthis._sum.disconnect();\n\t\tthis._sum = null;\n\t\tthis._param.dispose();\n\t\tthis._param = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.Subtract;\n});","'use strict';\n\nglobal.TONE_SILENCE_VERSION_LOGGING = true;\n\ndefine(['startaudiocontext', 'Tone/core/Context', 'Tone/core/Tone'], function (StartAudioContext, Context, Tone) {\n // Create the Audio Context\n const audiocontext = new window.AudioContext();\n\n // Tone and p5.sound share the same audio context\n Tone.context.dispose();\n Tone.setContext(audiocontext);\n\n /**\n *

Returns the Audio Context for this sketch. Useful for users\n * who would like to dig deeper into the Web Audio API\n * .

\n *\n *

Some browsers require users to startAudioContext\n * with a user gesture, such as touchStarted in the example below.

\n *\n * @for p5\n * @method getAudioContext\n * @return {Object} AudioContext for this sketch\n * @example\n *
\n * function draw() {\n * background(255);\n * textAlign(CENTER);\n *\n * if (getAudioContext().state !== 'running') {\n * text('click to start audio', width/2, height/2);\n * } else {\n * text('audio is enabled', width/2, height/2);\n * }\n * }\n *\n * function touchStarted() {\n * if (getAudioContext().state !== 'running') {\n * getAudioContext().resume();\n * }\n * var synth = new p5.MonoSynth();\n * synth.play('A4', 0.5, 0, 0.2);\n * }\n *\n *
\n */\n p5.prototype.getAudioContext = function() {\n return audiocontext;\n };\n\n\n /**\n *

It is not only a good practice to give users control over starting\n * audio. This policy is enforced by many web browsers, including iOS and\n * Google Chrome, which create the Web Audio API's\n * Audio Context\n * in a suspended state.

\n *\n *

In these browser-specific policies, sound will not play until a user\n * interaction event (i.e. mousePressed()) explicitly resumes\n * the AudioContext, or starts an audio node. This can be accomplished by\n * calling start() on a p5.Oscillator,\n * play() on a p5.SoundFile, or simply\n * userStartAudio().

\n *\n *

userStartAudio() starts the AudioContext on a user\n * gesture. The default behavior will enable audio on any\n * mouseUp or touchEnd event. It can also be placed in a specific\n * interaction function, such as mousePressed() as in the\n * example below. This method utilizes\n * StartAudioContext\n * , a library by Yotam Mann (MIT Licence, 2016).

\n * @param {Element|Array} [element(s)] This argument can be an Element,\n * Selector String, NodeList, p5.Element,\n * jQuery Element, or an Array of any of those.\n * @param {Function} [callback] Callback to invoke when the AudioContext\n * has started\n * @return {Promise} Returns a Promise that resolves when\n * the AudioContext state is 'running'\n * @method userStartAudio\n * @for p5\n * @example\n *
\n * function setup() {\n * // mimics the autoplay policy\n * getAudioContext().suspend();\n *\n * let mySynth = new p5.MonoSynth();\n *\n * // This won't play until the context has resumed\n * mySynth.play('A6');\n * }\n * function draw() {\n * background(220);\n * textAlign(CENTER, CENTER);\n * text(getAudioContext().state, width/2, height/2);\n * }\n * function mousePressed() {\n * userStartAudio();\n * }\n *
\n */\n p5.prototype.userStartAudio = function(elements, callback) {\n var elt = elements;\n if (elements instanceof p5.Element) {\n elt = elements.elt;\n } else if (elements instanceof Array && elements[0] instanceof p5.Element ) {\n elt = elements.map(function(e) { return e.elt});\n }\n return StartAudioContext(audiocontext, elt, callback);\n };\n\n return audiocontext;\n});\n","define([\"Tone/core/Tone\"], function (Tone) {\n\n\t\"use strict\";\n\n\t/**\n\t * @class Tone.Emitter gives classes which extend it\n\t * the ability to listen for and emit events. \n\t * Inspiration and reference from Jerome Etienne's [MicroEvent](https://github.com/jeromeetienne/microevent.js).\n\t * MIT (c) 2011 Jerome Etienne.\n\t * \n\t * @extends {Tone}\n\t */\n\tTone.Emitter = function(){\n\t\t/**\n\t\t * Contains all of the events.\n\t\t * @private\n\t\t * @type {Object}\n\t\t */\n\t\tthis._events = {};\n\t};\n\n\tTone.extend(Tone.Emitter);\n\n\t/**\n\t * Bind a callback to a specific event.\n\t * @param {String} event The name of the event to listen for.\n\t * @param {Function} callback The callback to invoke when the\n\t * event is emitted\n\t * @return {Tone.Emitter} this\n\t */\n\tTone.Emitter.prototype.on = function(event, callback){\n\t\t//split the event\n\t\tvar events = event.split(/\\W+/);\n\t\tfor (var i = 0; i < events.length; i++){\n\t\t\tvar eventName = events[i];\n\t\t\tif (!this._events.hasOwnProperty(eventName)){\n\t\t\t\tthis._events[eventName] = [];\n\t\t\t}\n\t\t\tthis._events[eventName].push(callback);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Remove the event listener.\n\t * @param {String} event The event to stop listening to.\n\t * @param {Function=} callback The callback which was bound to \n\t * the event with Tone.Emitter.on.\n\t * If no callback is given, all callbacks\n\t * events are removed.\n\t * @return {Tone.Emitter} this\n\t */\n\tTone.Emitter.prototype.off = function(event, callback){\n\t\tvar events = event.split(/\\W+/);\n\t\tfor (var ev = 0; ev < events.length; ev++){\n\t\t\tevent = events[ev];\n\t\t\tif (this._events.hasOwnProperty(event)){\n\t\t\t\tif (Tone.prototype.isUndef(callback)){\n\t\t\t\t\tthis._events[event] = [];\n\t\t\t\t} else {\n\t\t\t\t\tvar eventList = this._events[event];\n\t\t\t\t\tfor (var i = 0; i < eventList.length; i++){\n\t\t\t\t\t\tif (eventList[i] === callback){\n\t\t\t\t\t\t\teventList.splice(i, 1);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Invoke all of the callbacks bound to the event\n\t * with any arguments passed in. \n\t * @param {String} event The name of the event.\n\t * @param {*...} args The arguments to pass to the functions listening.\n\t * @return {Tone.Emitter} this\n\t */\n\tTone.Emitter.prototype.emit = function(event){\n\t\tif (this._events){\n\t\t\tvar args = Array.apply(null, arguments).slice(1);\n\t\t\tif (this._events.hasOwnProperty(event)){\n\t\t\t\tvar eventList = this._events[event];\n\t\t\t\tfor (var i = 0, len = eventList.length; i < len; i++){\n\t\t\t\t\teventList[i].apply(this, args);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Add Emitter functions (on/off/emit) to the object\n\t * @param {Object|Function} object The object or class to extend.\n\t */\n\tTone.Emitter.mixin = function(object){\n\t\tvar functions = [\"on\", \"off\", \"emit\"];\n\t\tobject._events = {};\n\t\tfor (var i = 0; i < functions.length; i++){\n\t\t\tvar func = functions[i];\n\t\t\tvar emitterFunc = Tone.Emitter.prototype[func];\n\t\t\tobject[func] = emitterFunc;\n\t\t}\n\t};\n\n\t/**\n\t * Clean up\n\t * @return {Tone.Emitter} this\n\t */\n\tTone.Emitter.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._events = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.Emitter;\n});","define([\"Tone/core/Tone\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Base class for all Signals. Used Internally. \n\t *\n\t * @constructor\n\t * @extends {Tone}\n\t */\n\tTone.SignalBase = function(){};\n\n\tTone.extend(Tone.SignalBase);\n\n\t/**\n\t * When signals connect to other signals or AudioParams, \n\t * they take over the output value of that signal or AudioParam. \n\t * For all other nodes, the behavior is the same as a default connect. \n\t *\n\t * @override\n\t * @param {AudioParam|AudioNode|Tone.Signal|Tone} node \n\t * @param {number} [outputNumber=0] The output number to connect from.\n\t * @param {number} [inputNumber=0] The input number to connect to.\n\t * @returns {Tone.SignalBase} this\n\t */\n\tTone.SignalBase.prototype.connect = function(node, outputNumber, inputNumber){\n\t\t//zero it out so that the signal can have full control\n\t\tif ((Tone.Signal && Tone.Signal === node.constructor) || \n\t\t\t\t(Tone.Param && Tone.Param === node.constructor) || \n\t\t\t\t(Tone.TimelineSignal && Tone.TimelineSignal === node.constructor)){\n\t\t\t//cancel changes\n\t\t\tnode._param.cancelScheduledValues(0);\n\t\t\t//reset the value\n\t\t\tnode._param.value = 0;\n\t\t\t//mark the value as overridden\n\t\t\tnode.overridden = true;\n\t\t} else if (node instanceof AudioParam){\n\t\t\tnode.cancelScheduledValues(0);\n\t\t\tnode.value = 0;\n\t\t} \n\t\tTone.prototype.connect.call(this, node, outputNumber, inputNumber);\n\t\treturn this;\n\t};\n\n\treturn Tone.SignalBase;\n});","define([\"Tone/core/Tone\", \"Tone/type/TimeBase\"], function (Tone) {\n\n\t/**\n\t * @class Tone.Time is a primitive type for encoding Time values. \n\t * Eventually all time values are evaluated to seconds\n\t * using the `eval` method. Tone.Time can be constructed\n\t * with or without the `new` keyword. Tone.Time can be passed\n\t * into the parameter of any method which takes time as an argument. \n\t * @constructor\n\t * @extends {Tone.TimeBase}\n\t * @param {String|Number} val The time value.\n\t * @param {String=} units The units of the value.\n\t * @example\n\t * var t = Tone.Time(\"4n\");//encodes a quarter note\n\t * t.mult(4); // multiply that value by 4\n\t * t.toNotation(); //returns \"1m\"\n\t */\n\tTone.Time = function(val, units){\n\t\tif (this instanceof Tone.Time){\n\n\t\t\t/**\n\t\t\t * If the current clock time should\n\t\t\t * be added to the output\n\t\t\t * @type {Boolean}\n\t\t\t * @private\n\t\t\t */\n\t\t\tthis._plusNow = false;\n\t\t\t\n\t\t\tTone.TimeBase.call(this, val, units);\n\n\t\t} else {\n\t\t\treturn new Tone.Time(val, units);\n\t\t}\n\t};\n\n\tTone.extend(Tone.Time, Tone.TimeBase);\n\n\t//clone the expressions so that \n\t//we can add more without modifying the original\n\tTone.Time.prototype._unaryExpressions = Object.create(Tone.TimeBase.prototype._unaryExpressions);\n\n\t/*\n\t * Adds an additional unary expression\n\t * which quantizes values to the next subdivision\n\t * @type {Object}\n\t * @private\n\t */\n\tTone.Time.prototype._unaryExpressions.quantize = {\n\t\tregexp : /^@/,\n\t\tmethod : function(rh){\n\t\t\treturn Tone.Transport.nextSubdivision(rh());\n\t\t}\n\t};\n\n\t/*\n\t * Adds an additional unary expression\n\t * which adds the current clock time.\n\t * @type {Object}\n\t * @private\n\t */\n\tTone.Time.prototype._unaryExpressions.now = {\n\t\tregexp : /^\\+/,\n\t\tmethod : function(lh){\n\t\t\tthis._plusNow = true;\n\t\t\treturn lh();\n\t\t}\n\t};\n\n\t/**\n\t * Quantize the time by the given subdivision. Optionally add a\n\t * percentage which will move the time value towards the ideal\n\t * quantized value by that percentage. \n\t * @param {Number|Time} val The subdivision to quantize to\n\t * @param {NormalRange} [percent=1] Move the time value\n\t * towards the quantized value by\n\t * a percentage.\n\t * @return {Tone.Time} this\n\t * @example\n\t * Tone.Time(21).quantize(2) //returns 22\n\t * Tone.Time(0.6).quantize(\"4n\", 0.5) //returns 0.55\n\t */\n\tTone.Time.prototype.quantize = function(subdiv, percent){\n\t\tpercent = this.defaultArg(percent, 1);\n\t\tthis._expr = function(expr, subdivision, percent){\n\t\t\texpr = expr();\n\t\t\tsubdivision = subdivision.toSeconds();\n\t\t\tvar multiple = Math.round(expr / subdivision);\n\t\t\tvar ideal = multiple * subdivision;\n\t\t\tvar diff = ideal - expr;\n\t\t\treturn expr + diff * percent;\n\t\t}.bind(this, this._expr, new this.constructor(subdiv), percent);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Adds the clock time to the time expression at the \n\t * moment of evaluation. \n\t * @return {Tone.Time} this\n\t */\n\tTone.Time.prototype.addNow = function(){\n\t\tthis._plusNow = true;\n\t\treturn this;\n\t};\n\n\t/**\n\t * @override\n\t * Override the default value return when no arguments are passed in.\n\t * The default value is 'now'\n\t * @private\n\t */\n\tTone.Time.prototype._defaultExpr = function(){\n\t\tthis._plusNow = true;\n\t\treturn this._noOp;\n\t};\n\n\t/**\n\t * Copies the value of time to this Time\n\t * @param {Tone.Time} time\n\t * @return {Time}\n\t */\n\tTone.Time.prototype.copy = function(time){\n\t\tTone.TimeBase.prototype.copy.call(this, time);\n\t\tthis._plusNow = time._plusNow;\n\t\treturn this;\n\t};\n\n\t//CONVERSIONS//////////////////////////////////////////////////////////////\n\n\t/**\n\t * Convert a Time to Notation. Values will be thresholded to the nearest 128th note. \n\t * @return {Notation} \n\t * @example\n\t * //if the Transport is at 120bpm:\n\t * Tone.Time(2).toNotation();//returns \"1m\"\n\t */\n\tTone.Time.prototype.toNotation = function(){\n\t\tvar time = this.toSeconds();\n\t\tvar testNotations = [\"1m\", \"2n\", \"4n\", \"8n\", \"16n\", \"32n\", \"64n\", \"128n\"];\n\t\tvar retNotation = this._toNotationHelper(time, testNotations);\n\t\t//try the same thing but with tripelets\n\t\tvar testTripletNotations = [\"1m\", \"2n\", \"2t\", \"4n\", \"4t\", \"8n\", \"8t\", \"16n\", \"16t\", \"32n\", \"32t\", \"64n\", \"64t\", \"128n\"];\n\t\tvar retTripletNotation = this._toNotationHelper(time, testTripletNotations);\n\t\t//choose the simpler expression of the two\n\t\tif (retTripletNotation.split(\"+\").length < retNotation.split(\"+\").length){\n\t\t\treturn retTripletNotation;\n\t\t} else {\n\t\t\treturn retNotation;\n\t\t}\n\t};\n\n\t/**\n\t * Helper method for Tone.toNotation\n\t * @param {Number} units \n\t * @param {Array} testNotations\n\t * @return {String}\n\t * @private\n\t */\n\tTone.Time.prototype._toNotationHelper = function(units, testNotations){\n\t\t//the threshold is the last value in the array\n\t\tvar threshold = this._notationToUnits(testNotations[testNotations.length - 1]);\n\t\tvar retNotation = \"\";\n\t\tfor (var i = 0; i < testNotations.length; i++){\n\t\t\tvar notationTime = this._notationToUnits(testNotations[i]);\n\t\t\t//account for floating point errors (i.e. round up if the value is 0.999999)\n\t\t\tvar multiple = units / notationTime;\n\t\t\tvar floatingPointError = 0.000001;\n\t\t\tif (1 - multiple % 1 < floatingPointError){\n\t\t\t\tmultiple += floatingPointError;\n\t\t\t}\n\t\t\tmultiple = Math.floor(multiple);\n\t\t\tif (multiple > 0){\n\t\t\t\tif (multiple === 1){\n\t\t\t\t\tretNotation += testNotations[i];\n\t\t\t\t} else {\n\t\t\t\t\tretNotation += multiple.toString() + \"*\" + testNotations[i];\n\t\t\t\t}\n\t\t\t\tunits -= multiple * notationTime;\n\t\t\t\tif (units < threshold){\n\t\t\t\t\tbreak;\n\t\t\t\t} else {\n\t\t\t\t\tretNotation += \" + \";\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (retNotation === \"\"){\n\t\t\tretNotation = \"0\";\n\t\t}\n\t\treturn retNotation;\n\t};\n\n\t/**\n\t * Convert a notation value to the current units\n\t * @param {Notation} notation \n\t * @return {Number} \n\t * @private\n\t */\n\tTone.Time.prototype._notationToUnits = function(notation){\n\t\tvar primaryExprs = this._primaryExpressions;\n\t\tvar notationExprs = [primaryExprs.n, primaryExprs.t, primaryExprs.m];\n\t\tfor (var i = 0; i < notationExprs.length; i++){\n\t\t\tvar expr = notationExprs[i];\n\t\t\tvar match = notation.match(expr.regexp);\n\t\t\tif (match){\n\t\t\t\treturn expr.method.call(this, match[1]);\n\t\t\t}\n\t\t}\n\t};\n\n\t/**\n\t * Return the time encoded as Bars:Beats:Sixteenths.\n\t * @return {BarsBeatsSixteenths}\n\t */\n\tTone.Time.prototype.toBarsBeatsSixteenths = function(){\n\t\tvar quarterTime = this._beatsToUnits(1);\n\t\tvar quarters = this.toSeconds() / quarterTime;\n\t\tvar measures = Math.floor(quarters / this._timeSignature());\n\t\tvar sixteenths = (quarters % 1) * 4;\n\t\tquarters = Math.floor(quarters) % this._timeSignature();\n\t\tsixteenths = sixteenths.toString();\n\t\tif (sixteenths.length > 3){\n\t\t\tsixteenths = parseFloat(sixteenths).toFixed(3);\n\t\t}\n\t\tvar progress = [measures, quarters, sixteenths];\n\t\treturn progress.join(\":\");\n\t};\n\n\t/**\n\t * Return the time in ticks.\n\t * @return {Ticks}\n\t */\n\tTone.Time.prototype.toTicks = function(){\n\t\tvar quarterTime = this._beatsToUnits(1);\n\t\tvar quarters = this.valueOf() / quarterTime;\n\t\treturn Math.floor(quarters * Tone.Transport.PPQ);\n\t};\n\n\t/**\n\t * Return the time in samples\n\t * @return {Samples} \n\t */\n\tTone.Time.prototype.toSamples = function(){\n\t\treturn this.toSeconds() * this.context.sampleRate;\n\t};\n\n\t/**\n\t * Return the time as a frequency value\n\t * @return {Frequency} \n\t * @example\n\t * Tone.Time(2).toFrequency(); //0.5\n\t */\n\tTone.Time.prototype.toFrequency = function(){\n\t\treturn 1/this.toSeconds();\n\t};\n\n\t/**\n\t * Return the time in seconds.\n\t * @return {Seconds} \n\t */\n\tTone.Time.prototype.toSeconds = function(){\n\t\treturn this.valueOf();\n\t};\n\n\t/**\n\t * Return the time in milliseconds.\n\t * @return {Milliseconds} \n\t */\n\tTone.Time.prototype.toMilliseconds = function(){\n\t\treturn this.toSeconds() * 1000;\n\t};\n\n\t/**\n\t * Return the time in seconds.\n\t * @return {Seconds} \n\t */\n\tTone.Time.prototype.valueOf = function(){\n\t\tvar val = this._expr();\n\t\treturn val + (this._plusNow?this.now():0);\n\t};\n\n\treturn Tone.Time;\n});","define([\"Tone/core/Tone\"], function (Tone) {\n\n\t/**\n\t * @class Tone.TimeBase is a flexible encoding of time\n\t * which can be evaluated to and from a string.\n\t * Parsing code modified from https://code.google.com/p/tapdigit/\n\t * Copyright 2011 2012 Ariya Hidayat, New BSD License\n\t * @extends {Tone}\n\t * @param {Time} val The time value as a number or string\n\t * @param {String=} units Unit values\n\t * @example\n\t * Tone.TimeBase(4, \"n\")\n\t * Tone.TimeBase(2, \"t\")\n\t * Tone.TimeBase(\"2t\").add(\"1m\")\n\t * Tone.TimeBase(\"2t + 1m\");\n\t */\n\tTone.TimeBase = function(val, units){\n\n\t\t//allows it to be constructed with or without 'new'\n\t\tif (this instanceof Tone.TimeBase) {\n\n\t\t\t/**\n\t\t\t * Any expressions parsed from the Time\n\t\t\t * @type {Array}\n\t\t\t * @private\n\t\t\t */\n\t\t\tthis._expr = this._noOp;\n\n\t\t\tif (val instanceof Tone.TimeBase){\n\t\t\t\tthis.copy(val);\n\t\t\t} else if (!this.isUndef(units) || this.isNumber(val)){\n\t\t\t\t//default units\n\t\t\t\tunits = this.defaultArg(units, this._defaultUnits);\n\t\t\t\tvar method = this._primaryExpressions[units].method;\n\t\t\t\tthis._expr = method.bind(this, val);\n\t\t\t} else if (this.isString(val)){\n\t\t\t\tthis.set(val);\n\t\t\t} else if (this.isUndef(val)){\n\t\t\t\t//default expression\n\t\t\t\tthis._expr = this._defaultExpr();\n\t\t\t}\n\t\t} else {\n\n\t\t\treturn new Tone.TimeBase(val, units);\n\t\t}\n\t};\n\n\tTone.extend(Tone.TimeBase);\n\n\t/**\n\t * Repalce the current time value with the value\n\t * given by the expression string.\n\t * @param {String} exprString\n\t * @return {Tone.TimeBase} this\n\t */\n\tTone.TimeBase.prototype.set = function(exprString){\n\t\tthis._expr = this._parseExprString(exprString);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Return a clone of the TimeBase object.\n\t * @return {Tone.TimeBase} The new cloned Tone.TimeBase\n\t */\n\tTone.TimeBase.prototype.clone = function(){\n\t\tvar instance = new this.constructor();\n\t\tinstance.copy(this);\n\t\treturn instance;\n\t};\n\n\t/**\n\t * Copies the value of time to this Time\n\t * @param {Tone.TimeBase} time\n\t * @return {TimeBase}\n\t */\n\tTone.TimeBase.prototype.copy = function(time){\n\t\tvar val = time._expr();\n\t\treturn this.set(val);\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tABSTRACT SYNTAX TREE PARSER\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * All the primary expressions.\n\t * @private\n\t * @type {Object}\n\t */\n\tTone.TimeBase.prototype._primaryExpressions = {\n\t\t\"n\" : {\n\t\t\tregexp : /^(\\d+)n/i,\n\t\t\tmethod : function(value){\n\t\t\t\tvalue = parseInt(value);\n\t\t\t\tif (value === 1){\n\t\t\t\t\treturn this._beatsToUnits(this._timeSignature());\n\t\t\t\t} else {\n\t\t\t\t\treturn this._beatsToUnits(4 / value);\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\t\"t\" : {\n\t\t\tregexp : /^(\\d+)t/i,\n\t\t\tmethod : function(value){\n\t\t\t\tvalue = parseInt(value);\n\t\t\t\treturn this._beatsToUnits(8 / (parseInt(value) * 3));\n\t\t\t}\n\t\t},\n\t\t\"m\" : {\n\t\t\tregexp : /^(\\d+)m/i,\n\t\t\tmethod : function(value){\n\t\t\t\treturn this._beatsToUnits(parseInt(value) * this._timeSignature());\n\t\t\t}\n\t\t},\n\t\t\"i\" : {\n\t\t\tregexp : /^(\\d+)i/i,\n\t\t\tmethod : function(value){\n\t\t\t\treturn this._ticksToUnits(parseInt(value));\n\t\t\t}\n\t\t},\n\t\t\"hz\" : {\n\t\t\tregexp : /^(\\d+(?:\\.\\d+)?)hz/i,\n\t\t\tmethod : function(value){\n\t\t\t\treturn this._frequencyToUnits(parseFloat(value));\n\t\t\t}\n\t\t},\n\t\t\"tr\" : {\n\t\t\tregexp : /^(\\d+(?:\\.\\d+)?):(\\d+(?:\\.\\d+)?):?(\\d+(?:\\.\\d+)?)?/,\n\t\t\tmethod : function(m, q, s){\n\t\t\t\tvar total = 0;\n\t\t\t\tif (m && m !== \"0\"){\n\t\t\t\t\ttotal += this._beatsToUnits(this._timeSignature() * parseFloat(m));\n\t\t\t\t}\n\t\t\t\tif (q && q !== \"0\"){\n\t\t\t\t\ttotal += this._beatsToUnits(parseFloat(q));\n\t\t\t\t}\n\t\t\t\tif (s && s !== \"0\"){\n\t\t\t\t\ttotal += this._beatsToUnits(parseFloat(s) / 4);\n\t\t\t\t}\n\t\t\t\treturn total;\n\t\t\t}\n\t\t},\n\t\t\"s\" : {\n\t\t\tregexp : /^(\\d+(?:\\.\\d+)?s)/,\n\t\t\tmethod : function(value){\n\t\t\t\treturn this._secondsToUnits(parseFloat(value));\n\t\t\t}\n\t\t},\n\t\t\"samples\" : {\n\t\t\tregexp : /^(\\d+)samples/,\n\t\t\tmethod : function(value){\n\t\t\t\treturn parseInt(value) / this.context.sampleRate;\n\t\t\t}\n\t\t},\n\t\t\"default\" : {\n\t\t\tregexp : /^(\\d+(?:\\.\\d+)?)/,\n\t\t\tmethod : function(value){\n\t\t\t\treturn this._primaryExpressions[this._defaultUnits].method.call(this, value);\n\t\t\t}\n\t\t}\n\t};\n\n\t/**\n\t * All the binary expressions that TimeBase can accept.\n\t * @private\n\t * @type {Object}\n\t */\n\tTone.TimeBase.prototype._binaryExpressions = {\n\t\t\"+\" : {\n\t\t\tregexp : /^\\+/,\n\t\t\tprecedence : 2,\n\t\t\tmethod : function(lh, rh){\n\t\t\t\treturn lh() + rh();\n\t\t\t}\n\t\t},\n\t\t\"-\" : {\n\t\t\tregexp : /^\\-/,\n\t\t\tprecedence : 2,\n\t\t\tmethod : function(lh, rh){\n\t\t\t\treturn lh() - rh();\n\t\t\t}\n\t\t},\n\t\t\"*\" : {\n\t\t\tregexp : /^\\*/,\n\t\t\tprecedence : 1,\n\t\t\tmethod : function(lh, rh){\n\t\t\t\treturn lh() * rh();\n\t\t\t}\n\t\t},\n\t\t\"/\" : {\n\t\t\tregexp : /^\\//,\n\t\t\tprecedence : 1,\n\t\t\tmethod : function(lh, rh){\n\t\t\t\treturn lh() / rh();\n\t\t\t}\n\t\t}\n\t};\n\n\t/**\n\t * All the unary expressions.\n\t * @private\n\t * @type {Object}\n\t */\n\tTone.TimeBase.prototype._unaryExpressions = {\n\t\t\"neg\" : {\n\t\t\tregexp : /^\\-/,\n\t\t\tmethod : function(lh){\n\t\t\t\treturn -lh();\n\t\t\t}\n\t\t}\n\t};\n\n\t/**\n\t * Syntactic glue which holds expressions together\n\t * @private\n\t * @type {Object}\n\t */\n\tTone.TimeBase.prototype._syntaxGlue = {\n\t\t\"(\" : {\n\t\t\tregexp : /^\\(/\n\t\t},\n\t\t\")\" : {\n\t\t\tregexp : /^\\)/\n\t\t}\n\t};\n\n\t/**\n\t * tokenize the expression based on the Expressions object\n\t * @param {string} expr \n\t * @return {Object} returns two methods on the tokenized list, next and peek\n\t * @private\n\t */\n\tTone.TimeBase.prototype._tokenize = function(expr){\n\t\tvar position = -1;\n\t\tvar tokens = [];\n\n\t\twhile(expr.length > 0){\n\t\t\texpr = expr.trim();\n\t\t\tvar token = getNextToken(expr, this);\n\t\t\ttokens.push(token);\n\t\t\texpr = expr.substr(token.value.length);\n\t\t}\n\n\t\tfunction getNextToken(expr, context){\n\t\t\tvar expressions = [\"_binaryExpressions\", \"_unaryExpressions\", \"_primaryExpressions\", \"_syntaxGlue\"];\n\t\t\tfor (var i = 0; i < expressions.length; i++){\n\t\t\t\tvar group = context[expressions[i]];\n\t\t\t\tfor (var opName in group){\n\t\t\t\t\tvar op = group[opName];\n\t\t\t\t\tvar reg = op.regexp;\n\t\t\t\t\tvar match = expr.match(reg);\n\t\t\t\t\tif (match !== null){\n\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\tmethod : op.method,\n\t\t\t\t\t\t\tprecedence : op.precedence,\n\t\t\t\t\t\t\tregexp : op.regexp,\n\t\t\t\t\t\t\tvalue : match[0],\n\t\t\t\t\t\t};\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tthrow new SyntaxError(\"Tone.TimeBase: Unexpected token \"+expr);\n\t\t}\n\n\t\treturn {\n\t\t\tnext : function(){\n\t\t\t\treturn tokens[++position];\n\t\t\t},\n\t\t\tpeek : function(){\n\t\t\t\treturn tokens[position + 1];\n\t\t\t}\n\t\t};\n\t};\n\n\t/**\n\t * Given a token, find the value within the groupName\n\t * @param {Object} token\n\t * @param {String} groupName\n\t * @param {Number} precedence\n\t * @private\n\t */\n\tTone.TimeBase.prototype._matchGroup = function(token, group, prec) {\n\t\tvar ret = false;\n\t\tif (!this.isUndef(token)){\n\t\t\tfor (var opName in group){\n\t\t\t\tvar op = group[opName];\n\t\t\t\tif (op.regexp.test(token.value)){\n\t\t\t\t\tif (!this.isUndef(prec)){\n\t\t\t\t\t\tif(op.precedence === prec){\t\n\t\t\t\t\t\t\treturn op;\n\t\t\t\t\t\t}\n\t\t\t\t\t} else {\n\t\t\t\t\t\treturn op;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn ret;\n\t};\n\n\t/**\n\t * Match a binary expression given the token and the precedence\n\t * @param {Lexer} lexer\n\t * @param {Number} precedence\n\t * @private\n\t */\n\tTone.TimeBase.prototype._parseBinary = function(lexer, precedence){\n\t\tif (this.isUndef(precedence)){\n\t\t\tprecedence = 2;\n\t\t}\n\t\tvar expr;\n\t\tif (precedence < 0){\n\t\t\texpr = this._parseUnary(lexer);\n\t\t} else {\n\t\t\texpr = this._parseBinary(lexer, precedence - 1);\n\t\t}\n\t\tvar token = lexer.peek();\n\t\twhile (token && this._matchGroup(token, this._binaryExpressions, precedence)){\n\t\t\ttoken = lexer.next();\n\t\t\texpr = token.method.bind(this, expr, this._parseBinary(lexer, precedence - 1));\n\t\t\ttoken = lexer.peek();\n\t\t}\n\t\treturn expr;\n\t};\n\n\t/**\n\t * Match a unary expression.\n\t * @param {Lexer} lexer\n\t * @private\n\t */\n\tTone.TimeBase.prototype._parseUnary = function(lexer){\n\t\tvar token, expr;\n\t\ttoken = lexer.peek();\n\t\tvar op = this._matchGroup(token, this._unaryExpressions);\n\t\tif (op) {\n\t\t\ttoken = lexer.next();\n\t\t\texpr = this._parseUnary(lexer);\n\t\t\treturn op.method.bind(this, expr);\n\t\t}\n\t\treturn this._parsePrimary(lexer);\n\t};\n\n\t/**\n\t * Match a primary expression (a value).\n\t * @param {Lexer} lexer\n\t * @private\n\t */\n\tTone.TimeBase.prototype._parsePrimary = function(lexer){\n\t\tvar token, expr;\n\t\ttoken = lexer.peek();\n\t\tif (this.isUndef(token)) {\n\t\t\tthrow new SyntaxError(\"Tone.TimeBase: Unexpected end of expression\");\n\t\t}\n\t\tif (this._matchGroup(token, this._primaryExpressions)) {\n\t\t\ttoken = lexer.next();\n\t\t\tvar matching = token.value.match(token.regexp);\n\t\t\treturn token.method.bind(this, matching[1], matching[2], matching[3]);\n\t\t}\n\t\tif (token && token.value === \"(\"){\n\t\t\tlexer.next();\n\t\t\texpr = this._parseBinary(lexer);\n\t\t\ttoken = lexer.next();\n\t\t\tif (!(token && token.value === \")\")) {\n\t\t\t\tthrow new SyntaxError(\"Expected )\");\n\t\t\t}\n\t\t\treturn expr;\n\t\t}\n\t\tthrow new SyntaxError(\"Tone.TimeBase: Cannot process token \" + token.value);\n\t};\n\n\t/**\n\t * Recursively parse the string expression into a syntax tree.\n\t * @param {string} expr \n\t * @return {Function} the bound method to be evaluated later\n\t * @private\n\t */\n\tTone.TimeBase.prototype._parseExprString = function(exprString){\n\t\tif (!this.isString(exprString)){\n\t\t\texprString = exprString.toString();\n\t\t}\n\t\tvar lexer = this._tokenize(exprString);\n\t\tvar tree = this._parseBinary(lexer);\n\t\treturn tree;\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tDEFAULTS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * The initial expression value\n\t * @return {Number} The initial value 0\n\t * @private\n\t */\n\tTone.TimeBase.prototype._noOp = function(){\n\t\treturn 0;\n\t};\n\n\t/**\n\t * The default expression value if no arguments are given\n\t * @private\n\t */\n\tTone.TimeBase.prototype._defaultExpr = function(){\n\t\treturn this._noOp;\n\t};\n\n\t/**\n\t * The default units if none are given.\n\t * @private\n\t */\n\tTone.TimeBase.prototype._defaultUnits = \"s\";\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tUNIT CONVERSIONS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Returns the value of a frequency in the current units\n\t * @param {Frequency} freq\n\t * @return {Number}\n\t * @private\n\t */\n\tTone.TimeBase.prototype._frequencyToUnits = function(freq){\n\t\treturn 1/freq;\n\t};\n\n\t/**\n\t * Return the value of the beats in the current units\n\t * @param {Number} beats\n\t * @return {Number}\n\t * @private\n\t */\n\tTone.TimeBase.prototype._beatsToUnits = function(beats){\n\t\treturn (60 / Tone.Transport.bpm.value) * beats;\n\t};\n\n\t/**\n\t * Returns the value of a second in the current units\n\t * @param {Seconds} seconds\n\t * @return {Number}\n\t * @private\n\t */\n\tTone.TimeBase.prototype._secondsToUnits = function(seconds){\n\t\treturn seconds;\n\t};\n\n\t/**\n\t * Returns the value of a tick in the current time units\n\t * @param {Ticks} ticks\n\t * @return {Number}\n\t * @private\n\t */\n\tTone.TimeBase.prototype._ticksToUnits = function(ticks){\n\t\treturn ticks * (this._beatsToUnits(1) / Tone.Transport.PPQ);\n\t};\n\n\t/**\n\t * Return the time signature.\n\t * @return {Number}\n\t * @private\n\t */\n\tTone.TimeBase.prototype._timeSignature = function(){\n\t\treturn Tone.Transport.timeSignature;\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tEXPRESSIONS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Push an expression onto the expression list\n\t * @param {Time} val\n\t * @param {String} type\n\t * @param {String} units\n\t * @return {Tone.TimeBase} \n\t * @private\n\t */\n\tTone.TimeBase.prototype._pushExpr = function(val, name, units){\n\t\t//create the expression\n\t\tif (!(val instanceof Tone.TimeBase)){\n\t\t\tval = new this.constructor(val, units);\n\t\t}\n\t\tthis._expr = this._binaryExpressions[name].method.bind(this, this._expr, val._expr);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Add to the current value.\n\t * @param {Time} val The value to add\n\t * @param {String=} units Optional units to use with the value.\n\t * @return {Tone.TimeBase} this\n\t * @example\n\t * Tone.TimeBase(\"2m\").add(\"1m\"); //\"3m\"\n\t */\n\tTone.TimeBase.prototype.add = function(val, units){\n\t\treturn this._pushExpr(val, \"+\", units);\n\t};\n\n\t/**\n\t * Subtract the value from the current time.\n\t * @param {Time} val The value to subtract\n\t * @param {String=} units Optional units to use with the value.\n\t * @return {Tone.TimeBase} this\n\t * @example\n\t * Tone.TimeBase(\"2m\").sub(\"1m\"); //\"1m\"\n\t */\n\tTone.TimeBase.prototype.sub = function(val, units){\n\t\treturn this._pushExpr(val, \"-\", units);\n\t};\n\n\t/**\n\t * Multiply the current value by the given time.\n\t * @param {Time} val The value to multiply\n\t * @param {String=} units Optional units to use with the value.\n\t * @return {Tone.TimeBase} this\n\t * @example\n\t * Tone.TimeBase(\"2m\").mult(\"2\"); //\"4m\"\n\t */\n\tTone.TimeBase.prototype.mult = function(val, units){\n\t\treturn this._pushExpr(val, \"*\", units);\n\t};\n\n\t/**\n\t * Divide the current value by the given time.\n\t * @param {Time} val The value to divide by\n\t * @param {String=} units Optional units to use with the value.\n\t * @return {Tone.TimeBase} this\n\t * @example\n\t * Tone.TimeBase(\"2m\").div(2); //\"1m\"\n\t */\n\tTone.TimeBase.prototype.div = function(val, units){\n\t\treturn this._pushExpr(val, \"/\", units);\n\t};\n\n\t/**\n\t * Evaluate the time value. Returns the time\n\t * in seconds.\n\t * @return {Seconds} \n\t */\n\tTone.TimeBase.prototype.valueOf = function(){\n\t\treturn this._expr();\n\t};\n\n\t/**\n\t * Clean up\n\t * @return {Tone.TimeBase} this\n\t */\n\tTone.TimeBase.prototype.dispose = function(){\n\t\tthis._expr = null;\n\t};\n\n\treturn Tone.TimeBase;\n});","define([\"Tone/core/Tone\", \"Tone/type/Type\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Tone.Param wraps the native Web Audio's AudioParam to provide\n\t * additional unit conversion functionality. It also\n\t * serves as a base-class for classes which have a single,\n\t * automatable parameter. \n\t * @extends {Tone}\n\t * @param {AudioParam} param The parameter to wrap.\n\t * @param {Tone.Type} units The units of the audio param.\n\t * @param {Boolean} convert If the param should be converted.\n\t */\n\tTone.Param = function(){\n\n\t\tvar options = this.optionsObject(arguments, [\"param\", \"units\", \"convert\"], Tone.Param.defaults);\n\n\t\t/**\n\t\t * The native parameter to control\n\t\t * @type {AudioParam}\n\t\t * @private\n\t\t */\n\t\tthis._param = this.input = options.param;\n\n\t\t/**\n\t\t * The units of the parameter\n\t\t * @type {Tone.Type}\n\t\t */\n\t\tthis.units = options.units;\n\n\t\t/**\n\t\t * If the value should be converted or not\n\t\t * @type {Boolean}\n\t\t */\n\t\tthis.convert = options.convert;\n\n\t\t/**\n\t\t * True if the signal value is being overridden by \n\t\t * a connected signal.\n\t\t * @readOnly\n\t\t * @type {boolean}\n\t\t * @private\n\t\t */\n\t\tthis.overridden = false;\n\n\t\t/**\n\t\t * If there is an LFO, this is where it is held.\n\t\t * @type {Tone.LFO}\n\t\t * @private\n\t\t */\n\t\tthis._lfo = null;\n\n\t\tif (this.isObject(options.lfo)){\n\t\t\tthis.value = options.lfo;\n\t\t} else if (!this.isUndef(options.value)){\n\t\t\tthis.value = options.value;\n\t\t}\n\t};\n\n\tTone.extend(Tone.Param);\n\t\n\t/**\n\t * Defaults\n\t * @type {Object}\n\t * @const\n\t */\n\tTone.Param.defaults = {\n\t\t\"units\" : Tone.Type.Default,\n\t\t\"convert\" : true,\n\t\t\"param\" : undefined\n\t};\n\n\t/**\n\t * The current value of the parameter. \n\t * @memberOf Tone.Param#\n\t * @type {Number}\n\t * @name value\n\t */\n\tObject.defineProperty(Tone.Param.prototype, \"value\", {\n\t\tget : function(){\n\t\t\treturn this._toUnits(this._param.value);\n\t\t},\n\t\tset : function(value){\n\t\t\tif (this.isObject(value)){\n\t\t\t\t//throw an error if the LFO needs to be included\n\t\t\t\tif (this.isUndef(Tone.LFO)){\n\t\t\t\t\tthrow new Error(\"Include 'Tone.LFO' to use an LFO as a Param value.\");\n\t\t\t\t}\n\t\t\t\t//remove the old one\n\t\t\t\tif (this._lfo){\n\t\t\t\t\tthis._lfo.dispose();\n\t\t\t\t}\n\t\t\t\tthis._lfo = new Tone.LFO(value).start();\n\t\t\t\tthis._lfo.connect(this.input);\n\t\t\t} else {\n\t\t\t\tvar convertedVal = this._fromUnits(value);\n\t\t\t\tthis._param.cancelScheduledValues(0);\n\t\t\t\tthis._param.value = convertedVal;\n\t\t\t}\n\t\t}\n\t});\n\n\t/**\n\t * Convert the given value from the type specified by Tone.Param.units\n\t * into the destination value (such as Gain or Frequency).\n\t * @private\n\t * @param {*} val the value to convert\n\t * @return {number} the number which the value should be set to\n\t */\n\tTone.Param.prototype._fromUnits = function(val){\n\t\tif (this.convert || this.isUndef(this.convert)){\n\t\t\tswitch(this.units){\n\t\t\t\tcase Tone.Type.Time: \n\t\t\t\t\treturn this.toSeconds(val);\n\t\t\t\tcase Tone.Type.Frequency: \n\t\t\t\t\treturn this.toFrequency(val);\n\t\t\t\tcase Tone.Type.Decibels: \n\t\t\t\t\treturn this.dbToGain(val);\n\t\t\t\tcase Tone.Type.NormalRange: \n\t\t\t\t\treturn Math.min(Math.max(val, 0), 1);\n\t\t\t\tcase Tone.Type.AudioRange: \n\t\t\t\t\treturn Math.min(Math.max(val, -1), 1);\n\t\t\t\tcase Tone.Type.Positive: \n\t\t\t\t\treturn Math.max(val, 0);\n\t\t\t\tdefault:\n\t\t\t\t\treturn val;\n\t\t\t}\n\t\t} else {\n\t\t\treturn val;\n\t\t}\n\t};\n\n\t/**\n\t * Convert the parameters value into the units specified by Tone.Param.units.\n\t * @private\n\t * @param {number} val the value to convert\n\t * @return {number}\n\t */\n\tTone.Param.prototype._toUnits = function(val){\n\t\tif (this.convert || this.isUndef(this.convert)){\n\t\t\tswitch(this.units){\n\t\t\t\tcase Tone.Type.Decibels: \n\t\t\t\t\treturn this.gainToDb(val);\n\t\t\t\tdefault:\n\t\t\t\t\treturn val;\n\t\t\t}\n\t\t} else {\n\t\t\treturn val;\n\t\t}\n\t};\n\n\t/**\n\t * the minimum output value\n\t * @type {Number}\n\t * @private\n\t */\n\tTone.Param.prototype._minOutput = 0.00001;\n\n\t/**\n\t * Schedules a parameter value change at the given time.\n\t * @param {*}\tvalue The value to set the signal.\n\t * @param {Time} time The time when the change should occur.\n\t * @returns {Tone.Param} this\n\t * @example\n\t * //set the frequency to \"G4\" in exactly 1 second from now. \n\t * freq.setValueAtTime(\"G4\", \"+1\");\n\t */\n\tTone.Param.prototype.setValueAtTime = function(value, time){\n\t\tvalue = this._fromUnits(value);\n\t\ttime = this.toSeconds(time);\n\t\tif (time <= this.now() + this.blockTime){\n\t\t\tthis._param.value = value;\n\t\t} else {\n\t\t\tthis._param.setValueAtTime(value, time);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Creates a schedule point with the current value at the current time.\n\t * This is useful for creating an automation anchor point in order to \n\t * schedule changes from the current value. \n\t *\n\t * @param {number=} now (Optionally) pass the now value in. \n\t * @returns {Tone.Param} this\n\t */\n\tTone.Param.prototype.setRampPoint = function(now){\n\t\tnow = this.defaultArg(now, this.now());\n\t\tvar currentVal = this._param.value;\n\t\t// exponentialRampToValueAt cannot ever ramp from or to 0\n\t\t// More info: https://bugzilla.mozilla.org/show_bug.cgi?id=1125600#c2\n\t\tif (currentVal === 0){\n\t\t\tcurrentVal = this._minOutput;\n\t\t}\n\t\tthis._param.setValueAtTime(currentVal, now);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Schedules a linear continuous change in parameter value from the \n\t * previous scheduled parameter value to the given value.\n\t * \n\t * @param {number} value \n\t * @param {Time} endTime \n\t * @returns {Tone.Param} this\n\t */\n\tTone.Param.prototype.linearRampToValueAtTime = function(value, endTime){\n\t\tvalue = this._fromUnits(value);\n\t\tthis._param.linearRampToValueAtTime(value, this.toSeconds(endTime));\n\t\treturn this;\n\t};\n\n\t/**\n\t * Schedules an exponential continuous change in parameter value from \n\t * the previous scheduled parameter value to the given value.\n\t * \n\t * @param {number} value \n\t * @param {Time} endTime \n\t * @returns {Tone.Param} this\n\t */\n\tTone.Param.prototype.exponentialRampToValueAtTime = function(value, endTime){\n\t\tvalue = this._fromUnits(value);\n\t\tvalue = Math.max(this._minOutput, value);\n\t\tthis._param.exponentialRampToValueAtTime(value, this.toSeconds(endTime));\n\t\treturn this;\n\t};\n\n\t/**\n\t * Schedules an exponential continuous change in parameter value from \n\t * the current time and current value to the given value over the \n\t * duration of the rampTime.\n\t * \n\t * @param {number} value The value to ramp to.\n\t * @param {Time} rampTime the time that it takes the \n\t * value to ramp from it's current value\n\t * @param {Time}\t[startTime=now] \tWhen the ramp should start. \n\t * @returns {Tone.Param} this\n\t * @example\n\t * //exponentially ramp to the value 2 over 4 seconds. \n\t * signal.exponentialRampToValue(2, 4);\n\t */\n\tTone.Param.prototype.exponentialRampToValue = function(value, rampTime, startTime){\n\t\tstartTime = this.toSeconds(startTime);\n\t\tthis.setRampPoint(startTime);\n\t\tthis.exponentialRampToValueAtTime(value, startTime + this.toSeconds(rampTime));\n\t\treturn this;\n\t};\n\n\t/**\n\t * Schedules an linear continuous change in parameter value from \n\t * the current time and current value to the given value over the \n\t * duration of the rampTime.\n\t * \n\t * @param {number} value The value to ramp to.\n\t * @param {Time} rampTime the time that it takes the \n\t * value to ramp from it's current value\n\t * @param {Time}\t[startTime=now] \tWhen the ramp should start. \n\t * @returns {Tone.Param} this\n\t * @example\n\t * //linearly ramp to the value 4 over 3 seconds. \n\t * signal.linearRampToValue(4, 3);\n\t */\n\tTone.Param.prototype.linearRampToValue = function(value, rampTime, startTime){\n\t\tstartTime = this.toSeconds(startTime);\n\t\tthis.setRampPoint(startTime);\n\t\tthis.linearRampToValueAtTime(value, startTime + this.toSeconds(rampTime));\n\t\treturn this;\n\t};\n\n\t/**\n\t * Start exponentially approaching the target value at the given time with\n\t * a rate having the given time constant.\n\t * @param {number} value \n\t * @param {Time} startTime \n\t * @param {number} timeConstant \n\t * @returns {Tone.Param} this \n\t */\n\tTone.Param.prototype.setTargetAtTime = function(value, startTime, timeConstant){\n\t\tvalue = this._fromUnits(value);\n\t\t// The value will never be able to approach without timeConstant > 0.\n\t\t// http://www.w3.org/TR/webaudio/#dfn-setTargetAtTime, where the equation\n\t\t// is described. 0 results in a division by 0.\n\t\tvalue = Math.max(this._minOutput, value);\n\t\ttimeConstant = Math.max(this._minOutput, timeConstant);\n\t\tthis._param.setTargetAtTime(value, this.toSeconds(startTime), timeConstant);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Sets an array of arbitrary parameter values starting at the given time\n\t * for the given duration.\n\t * \t\n\t * @param {Array} values \n\t * @param {Time} startTime \n\t * @param {Time} duration \n\t * @returns {Tone.Param} this\n\t */\n\tTone.Param.prototype.setValueCurveAtTime = function(values, startTime, duration){\n\t\tfor (var i = 0; i < values.length; i++){\n\t\t\tvalues[i] = this._fromUnits(values[i]);\n\t\t}\n\t\tthis._param.setValueCurveAtTime(values, this.toSeconds(startTime), this.toSeconds(duration));\n\t\treturn this;\n\t};\n\n\t/**\n\t * Cancels all scheduled parameter changes with times greater than or \n\t * equal to startTime.\n\t * \n\t * @param {Time} startTime\n\t * @returns {Tone.Param} this\n\t */\n\tTone.Param.prototype.cancelScheduledValues = function(startTime){\n\t\tthis._param.cancelScheduledValues(this.toSeconds(startTime));\n\t\treturn this;\n\t};\n\n\t/**\n\t * Ramps to the given value over the duration of the rampTime. \n\t * Automatically selects the best ramp type (exponential or linear)\n\t * depending on the `units` of the signal\n\t * \n\t * @param {number} value \n\t * @param {Time} rampTime \tThe time that it takes the \n\t * value to ramp from it's current value\n\t * @param {Time}\t[startTime=now] \tWhen the ramp should start. \n\t * @returns {Tone.Param} this\n\t * @example\n\t * //ramp to the value either linearly or exponentially \n\t * //depending on the \"units\" value of the signal\n\t * signal.rampTo(0, 10);\n\t * @example\n\t * //schedule it to ramp starting at a specific time\n\t * signal.rampTo(0, 10, 5)\n\t */\n\tTone.Param.prototype.rampTo = function(value, rampTime, startTime){\n\t\trampTime = this.defaultArg(rampTime, 0);\n\t\tif (this.units === Tone.Type.Frequency || this.units === Tone.Type.BPM || this.units === Tone.Type.Decibels){\n\t\t\tthis.exponentialRampToValue(value, rampTime, startTime);\n\t\t} else {\n\t\t\tthis.linearRampToValue(value, rampTime, startTime);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * The LFO created by the signal instance. If none\n\t * was created, this is null.\n\t * @type {Tone.LFO}\n\t * @readOnly\n\t * @memberOf Tone.Param#\n\t * @name lfo\n\t */\n\tObject.defineProperty(Tone.Param.prototype, \"lfo\", {\n\t\tget : function(){\n\t\t\treturn this._lfo;\n\t\t}\n\t});\n\n\t/**\n\t * Clean up\n\t * @returns {Tone.Param} this\n\t */\n\tTone.Param.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._param = null;\n\t\tif (this._lfo){\n\t\t\tthis._lfo.dispose();\n\t\t\tthis._lfo = null;\n\t\t}\n\t\treturn this;\n\t};\n\n\treturn Tone.Param;\n});","'use strict';\n\ndefine(function (require) {\n var p5sound = require('master');\n\n var Add = require('Tone/signal/Add');\n var Mult = require('Tone/signal/Multiply');\n var Scale = require('Tone/signal/Scale');\n\n /**\n *

Creates a signal that oscillates between -1.0 and 1.0.\n * By default, the oscillation takes the form of a sinusoidal\n * shape ('sine'). Additional types include 'triangle',\n * 'sawtooth' and 'square'. The frequency defaults to\n * 440 oscillations per second (440Hz, equal to the pitch of an\n * 'A' note).

\n *\n *

Set the type of oscillation with setType(), or by instantiating a\n * specific oscillator: p5.SinOsc, p5.TriOsc, p5.SqrOsc, or p5.SawOsc.\n *

\n *\n * @class p5.Oscillator\n * @constructor\n * @param {Number} [freq] frequency defaults to 440Hz\n * @param {String} [type] type of oscillator. Options:\n * 'sine' (default), 'triangle',\n * 'sawtooth', 'square'\n * @example\n *
\n * let osc, playing, freq, amp;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playOscillator);\n * osc = new p5.Oscillator('sine');\n * }\n *\n * function draw() {\n * background(220)\n * freq = constrain(map(mouseX, 0, width, 100, 500), 100, 500);\n * amp = constrain(map(mouseY, height, 0, 0, 1), 0, 1);\n *\n * text('tap to play', 20, 20);\n * text('freq: ' + freq, 20, 40);\n * text('amp: ' + amp, 20, 60);\n *\n * if (playing) {\n * // smooth the transitions by 0.1 seconds\n * osc.freq(freq, 0.1);\n * osc.amp(amp, 0.1);\n * }\n * }\n *\n * function playOscillator() {\n * // starting an oscillator on a user gesture will enable audio\n * // in browsers that have a strict autoplay policy.\n * // See also: userStartAudio();\n * osc.start();\n * playing = true;\n * }\n *\n * function mouseReleased() {\n * // ramp amplitude to 0 over 0.5 seconds\n * osc.amp(0, 0.5);\n * playing = false;\n * }\n *
\n */\n p5.Oscillator = function(freq, type) {\n if (typeof freq === 'string') {\n var f = type;\n type = freq;\n freq = f;\n } if (typeof type === 'number') {\n var f = type;\n type = freq;\n freq = f;\n }\n this.started = false;\n\n // components\n this.phaseAmount = undefined;\n this.oscillator = p5sound.audiocontext.createOscillator();\n this.f = freq || 440.0; // frequency\n this.oscillator.type = type || 'sine';\n this.oscillator.frequency.setValueAtTime(this.f, p5sound.audiocontext.currentTime);\n\n // connections\n this.output = p5sound.audiocontext.createGain();\n\n this._freqMods = []; // modulators connected to this oscillator's frequency\n\n // set default output gain to 0.5\n this.output.gain.value = 0.5;\n this.output.gain.setValueAtTime(0.5, p5sound.audiocontext.currentTime);\n\n this.oscillator.connect(this.output);\n // stereo panning\n this.panPosition = 0.0;\n this.connection = p5sound.input; // connect to p5sound by default\n this.panner = new p5.Panner(this.output, this.connection, 1);\n\n //array of math operation signal chaining\n this.mathOps = [this.output];\n\n // add to the soundArray so we can dispose of the osc later\n p5sound.soundArray.push(this);\n };\n\n /**\n * Start an oscillator.\n *\n * Starting an oscillator on a user gesture will enable audio in browsers\n * that have a strict autoplay policy, including Chrome and most mobile\n * devices. See also: `userStartAudio()`.\n *\n * @method start\n * @for p5.Oscillator\n * @param {Number} [time] startTime in seconds from now.\n * @param {Number} [frequency] frequency in Hz.\n */\n p5.Oscillator.prototype.start = function(time, f) {\n if (this.started) {\n var now = p5sound.audiocontext.currentTime;\n this.stop(now);\n }\n if (!this.started) {\n var freq = f || this.f;\n var type = this.oscillator.type;\n\n // set old osc free to be garbage collected (memory)\n if (this.oscillator) {\n this.oscillator.disconnect();\n delete this.oscillator;\n }\n\n // var detune = this.oscillator.frequency.value;\n this.oscillator = p5sound.audiocontext.createOscillator();\n this.oscillator.frequency.value = Math.abs(freq);\n this.oscillator.type = type;\n // this.oscillator.detune.value = detune;\n this.oscillator.connect(this.output);\n time = time || 0;\n this.oscillator.start(time + p5sound.audiocontext.currentTime);\n this.freqNode = this.oscillator.frequency;\n\n // if other oscillators are already connected to this osc's freq\n for (var i in this._freqMods) {\n if (typeof this._freqMods[i].connect !== 'undefined') {\n this._freqMods[i].connect(this.oscillator.frequency);\n }\n }\n\n this.started = true;\n }\n };\n\n /**\n * Stop an oscillator. Accepts an optional parameter\n * to determine how long (in seconds from now) until the\n * oscillator stops.\n *\n * @method stop\n * @for p5.Oscillator\n * @param {Number} secondsFromNow Time, in seconds from now.\n */\n p5.Oscillator.prototype.stop = function(time) {\n if (this.started) {\n var t = time || 0;\n var now = p5sound.audiocontext.currentTime;\n this.oscillator.stop(t + now);\n this.started = false;\n }\n };\n\n /**\n * Set the amplitude between 0 and 1.0. Or, pass in an object\n * such as an oscillator to modulate amplitude with an audio signal.\n *\n * @method amp\n * @for p5.Oscillator\n * @param {Number|Object} vol between 0 and 1.0\n * or a modulating signal/oscillator\n * @param {Number} [rampTime] create a fade that lasts rampTime\n * @param {Number} [timeFromNow] schedule this event to happen\n * seconds from now\n * @return {AudioParam} gain If no value is provided,\n * returns the Web Audio API\n * AudioParam that controls\n * this oscillator's\n * gain/amplitude/volume)\n */\n p5.Oscillator.prototype.amp = function(vol, rampTime, tFromNow) {\n var self = this;\n if (typeof vol === 'number') {\n var rampTime = rampTime || 0;\n var tFromNow = tFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n this.output.gain.linearRampToValueAtTime(vol, now + tFromNow + rampTime);\n }\n\n else if (vol) {\n vol.connect(self.output.gain);\n } else {\n // return the Gain Node\n return this.output.gain;\n }\n };\n\n // these are now the same thing\n p5.Oscillator.prototype.fade = p5.Oscillator.prototype.amp;\n\n p5.Oscillator.prototype.getAmp = function() {\n return this.output.gain.value;\n };\n\n /**\n * Set frequency of an oscillator to a value. Or, pass in an object\n * such as an oscillator to modulate the frequency with an audio signal.\n *\n * @method freq\n * @for p5.Oscillator\n * @param {Number|Object} Frequency Frequency in Hz\n * or modulating signal/oscillator\n * @param {Number} [rampTime] Ramp time (in seconds)\n * @param {Number} [timeFromNow] Schedule this event to happen\n * at x seconds from now\n * @return {AudioParam} Frequency If no value is provided,\n * returns the Web Audio API\n * AudioParam that controls\n * this oscillator's frequency\n * @example\n *
\n * let osc;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playOscillator);\n * osc = new p5.Oscillator(300);\n * background(220);\n * text('tap to play', 20, 20);\n * }\n *\n * function playOscillator() {\n * osc.start();\n * osc.amp(0.5);\n * // start at 700Hz\n * osc.freq(700);\n * // ramp to 60Hz over 0.7 seconds\n * osc.freq(60, 0.7);\n * osc.amp(0, 0.1, 0.7);\n * }\n *
\n */\n p5.Oscillator.prototype.freq = function(val, rampTime, tFromNow) {\n if (typeof val === 'number' && !isNaN(val)) {\n this.f = val;\n var now = p5sound.audiocontext.currentTime;\n var rampTime = rampTime || 0;\n var tFromNow = tFromNow || 0;\n var t = now + tFromNow + rampTime;\n // var currentFreq = this.oscillator.frequency.value;\n // this.oscillator.frequency.cancelScheduledValues(now);\n\n if (rampTime === 0) {\n this.oscillator.frequency.setValueAtTime(val, tFromNow + now);\n } else {\n if (val > 0 ) {\n this.oscillator.frequency.exponentialRampToValueAtTime(val, tFromNow + rampTime + now);\n } else {\n this.oscillator.frequency.linearRampToValueAtTime(val, tFromNow + rampTime + now);\n }\n }\n\n // reset phase if oscillator has a phase\n if (this.phaseAmount) {\n this.phase(this.phaseAmount);\n }\n\n } else if (val) {\n if (val.output) {\n val = val.output;\n }\n val.connect(this.oscillator.frequency);\n\n // keep track of what is modulating this param\n // so it can be re-connected if\n this._freqMods.push( val );\n } else {\n // return the Frequency Node\n return this.oscillator.frequency;\n }\n };\n\n p5.Oscillator.prototype.getFreq = function() {\n return this.oscillator.frequency.value;\n };\n\n /**\n * Set type to 'sine', 'triangle', 'sawtooth' or 'square'.\n *\n * @method setType\n * @for p5.Oscillator\n * @param {String} type 'sine', 'triangle', 'sawtooth' or 'square'.\n */\n p5.Oscillator.prototype.setType = function(type) {\n this.oscillator.type = type;\n };\n\n p5.Oscillator.prototype.getType = function() {\n return this.oscillator.type;\n };\n\n /**\n * Connect to a p5.sound / Web Audio object.\n *\n * @method connect\n * @for p5.Oscillator\n * @param {Object} unit A p5.sound or Web Audio object\n */\n p5.Oscillator.prototype.connect = function(unit) {\n if (!unit) {\n this.panner.connect(p5sound.input);\n }\n else if (unit.hasOwnProperty('input')) {\n this.panner.connect(unit.input);\n this.connection = unit.input;\n }\n else {\n this.panner.connect(unit);\n this.connection = unit;\n }\n };\n\n /**\n * Disconnect all outputs\n *\n * @method disconnect\n * @for p5.Oscillator\n */\n p5.Oscillator.prototype.disconnect = function() {\n if (this.output) {\n this.output.disconnect();\n }\n if (this.panner) {\n this.panner.disconnect();\n if (this.output) {\n this.output.connect(this.panner);\n }\n }\n this.oscMods = [];\n };\n\n /**\n * Pan between Left (-1) and Right (1)\n *\n * @method pan\n * @for p5.Oscillator\n * @param {Number} panning Number between -1 and 1\n * @param {Number} timeFromNow schedule this event to happen\n * seconds from now\n */\n p5.Oscillator.prototype.pan = function(pval, tFromNow) {\n this.panPosition = pval;\n this.panner.pan(pval, tFromNow);\n };\n\n p5.Oscillator.prototype.getPan = function() {\n return this.panPosition;\n };\n\n // get rid of the oscillator\n p5.Oscillator.prototype.dispose = function() {\n // remove reference from soundArray\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n\n if (this.oscillator) {\n var now = p5sound.audiocontext.currentTime;\n this.stop(now);\n this.disconnect();\n this.panner = null;\n this.oscillator = null;\n }\n // if it is a Pulse\n if (this.osc2) {\n this.osc2.dispose();\n }\n };\n\n /**\n * Set the phase of an oscillator between 0.0 and 1.0.\n * In this implementation, phase is a delay time\n * based on the oscillator's current frequency.\n *\n * @method phase\n * @for p5.Oscillator\n * @param {Number} phase float between 0.0 and 1.0\n */\n p5.Oscillator.prototype.phase = function(p) {\n var delayAmt = p5.prototype.map(p, 0, 1.0, 0, 1/this.f);\n var now = p5sound.audiocontext.currentTime;\n\n this.phaseAmount = p;\n\n if (!this.dNode) {\n // create a delay node\n this.dNode = p5sound.audiocontext.createDelay();\n // put the delay node in between output and panner\n this.oscillator.disconnect();\n this.oscillator.connect(this.dNode);\n this.dNode.connect(this.output);\n }\n\n // set delay time to match phase:\n this.dNode.delayTime.setValueAtTime(delayAmt, now);\n };\n\n // ========================== //\n // SIGNAL MATH FOR MODULATION //\n // ========================== //\n\n // return sigChain(this, scale, thisChain, nextChain, Scale);\n var sigChain = function(o, mathObj, thisChain, nextChain, type) {\n var chainSource = o.oscillator;\n // if this type of math already exists in the chain, replace it\n for (var i in o.mathOps) {\n if (o.mathOps[i] instanceof type) {\n chainSource.disconnect();\n o.mathOps[i].dispose();\n thisChain = i;\n // assume nextChain is output gain node unless...\n if (thisChain < o.mathOps.length - 2) {\n nextChain = o.mathOps[i+1];\n }\n }\n }\n if (thisChain === o.mathOps.length - 1) {\n o.mathOps.push(nextChain);\n }\n // assume source is the oscillator unless i > 0\n if (i > 0) {\n chainSource = o.mathOps[i-1];\n }\n chainSource.disconnect();\n chainSource.connect(mathObj);\n mathObj.connect(nextChain);\n o.mathOps[thisChain] = mathObj;\n return o;\n };\n\n /**\n * Add a value to the p5.Oscillator's output amplitude,\n * and return the oscillator. Calling this method again\n * will override the initial add() with a new value.\n *\n * @method add\n * @for p5.Oscillator\n * @param {Number} number Constant number to add\n * @return {p5.Oscillator} Oscillator Returns this oscillator\n * with scaled output\n *\n */\n p5.Oscillator.prototype.add = function(num) {\n var add = new Add(num);\n var thisChain = this.mathOps.length-1;\n var nextChain = this.output;\n return sigChain(this, add, thisChain, nextChain, Add);\n };\n\n /**\n * Multiply the p5.Oscillator's output amplitude\n * by a fixed value (i.e. turn it up!). Calling this method\n * again will override the initial mult() with a new value.\n *\n * @method mult\n * @for p5.Oscillator\n * @param {Number} number Constant number to multiply\n * @return {p5.Oscillator} Oscillator Returns this oscillator\n * with multiplied output\n */\n p5.Oscillator.prototype.mult = function(num) {\n var mult = new Mult(num);\n var thisChain = this.mathOps.length-1;\n var nextChain = this.output;\n return sigChain(this, mult, thisChain, nextChain, Mult);\n };\n\n /**\n * Scale this oscillator's amplitude values to a given\n * range, and return the oscillator. Calling this method\n * again will override the initial scale() with new values.\n *\n * @method scale\n * @for p5.Oscillator\n * @param {Number} inMin input range minumum\n * @param {Number} inMax input range maximum\n * @param {Number} outMin input range minumum\n * @param {Number} outMax input range maximum\n * @return {p5.Oscillator} Oscillator Returns this oscillator\n * with scaled output\n */\n p5.Oscillator.prototype.scale = function(inMin, inMax, outMin, outMax) {\n var mapOutMin, mapOutMax;\n if (arguments.length === 4) {\n mapOutMin = p5.prototype.map(outMin, inMin, inMax, 0, 1) - 0.5;\n mapOutMax = p5.prototype.map(outMax, inMin, inMax, 0, 1) - 0.5;\n }\n else {\n mapOutMin = arguments[0];\n mapOutMax = arguments[1];\n }\n var scale = new Scale(mapOutMin, mapOutMax);\n var thisChain = this.mathOps.length-1;\n var nextChain = this.output;\n return sigChain(this, scale, thisChain, nextChain, Scale);\n\n // this.output.disconnect();\n // this.output.connect(scale)\n };\n\n // ============================== //\n // SinOsc, TriOsc, SqrOsc, SawOsc //\n // ============================== //\n\n /**\n * Constructor: new p5.SinOsc().\n * This creates a Sine Wave Oscillator and is\n * equivalent to new p5.Oscillator('sine')\n * or creating a p5.Oscillator and then calling\n * its method setType('sine').\n * See p5.Oscillator for methods.\n *\n * @class p5.SinOsc\n * @constructor\n * @extends p5.Oscillator\n * @param {Number} [freq] Set the frequency\n */\n p5.SinOsc = function(freq) {\n p5.Oscillator.call(this, freq, 'sine');\n };\n\n p5.SinOsc.prototype = Object.create(p5.Oscillator.prototype);\n\n /**\n * Constructor: new p5.TriOsc().\n * This creates a Triangle Wave Oscillator and is\n * equivalent to new p5.Oscillator('triangle')\n * or creating a p5.Oscillator and then calling\n * its method setType('triangle').\n * See p5.Oscillator for methods.\n *\n * @class p5.TriOsc\n * @constructor\n * @extends p5.Oscillator\n * @param {Number} [freq] Set the frequency\n */\n p5.TriOsc = function(freq) {\n p5.Oscillator.call(this, freq, 'triangle');\n };\n\n p5.TriOsc.prototype = Object.create(p5.Oscillator.prototype);\n\n /**\n * Constructor: new p5.SawOsc().\n * This creates a SawTooth Wave Oscillator and is\n * equivalent to new p5.Oscillator('sawtooth')\n * or creating a p5.Oscillator and then calling\n * its method setType('sawtooth').\n * See p5.Oscillator for methods.\n *\n * @class p5.SawOsc\n * @constructor\n * @extends p5.Oscillator\n * @param {Number} [freq] Set the frequency\n */\n p5.SawOsc = function(freq) {\n p5.Oscillator.call(this, freq, 'sawtooth');\n };\n\n p5.SawOsc.prototype = Object.create(p5.Oscillator.prototype);\n\n /**\n * Constructor: new p5.SqrOsc().\n * This creates a Square Wave Oscillator and is\n * equivalent to new p5.Oscillator('square')\n * or creating a p5.Oscillator and then calling\n * its method setType('square').\n * See p5.Oscillator for methods.\n *\n * @class p5.SqrOsc\n * @constructor\n * @extends p5.Oscillator\n * @param {Number} [freq] Set the frequency\n */\n p5.SqrOsc = function(freq) {\n p5.Oscillator.call(this, freq, 'square');\n };\n\n p5.SqrOsc.prototype = Object.create(p5.Oscillator.prototype);\n\n});\n","define([\"Tone/core/Tone\", \"Tone/type/Type\"], function (Tone) {\n\n\t\"use strict\";\n\n\t/**\n\t * @class A Timeline class for scheduling and maintaining state\n\t * along a timeline. All events must have a \"time\" property. \n\t * Internally, events are stored in time order for fast \n\t * retrieval.\n\t * @extends {Tone}\n\t * @param {Positive} [memory=Infinity] The number of previous events that are retained.\n\t */\n\tTone.Timeline = function(){\n\n\t\tvar options = this.optionsObject(arguments, [\"memory\"], Tone.Timeline.defaults);\n\n\t\t/**\n\t\t * The array of scheduled timeline events\n\t\t * @type {Array}\n\t\t * @private\n\t\t */\n\t\tthis._timeline = [];\n\n\t\t/**\n\t\t * An array of items to remove from the list. \n\t\t * @type {Array}\n\t\t * @private\n\t\t */\n\t\tthis._toRemove = [];\n\n\t\t/**\n\t\t * Flag if the tieline is mid iteration\n\t\t * @private\n\t\t * @type {Boolean}\n\t\t */\n\t\tthis._iterating = false;\n\n\t\t/**\n\t\t * The memory of the timeline, i.e.\n\t\t * how many events in the past it will retain\n\t\t * @type {Positive}\n\t\t */\n\t\tthis.memory = options.memory;\n\t};\n\n\tTone.extend(Tone.Timeline);\n\n\t/**\n\t * the default parameters\n\t * @static\n\t * @const\n\t */\n\tTone.Timeline.defaults = {\n\t\t\"memory\" : Infinity\n\t};\n\n\t/**\n\t * The number of items in the timeline.\n\t * @type {Number}\n\t * @memberOf Tone.Timeline#\n\t * @name length\n\t * @readOnly\n\t */\n\tObject.defineProperty(Tone.Timeline.prototype, \"length\", {\n\t\tget : function(){\n\t\t\treturn this._timeline.length;\n\t\t}\n\t});\n\n\t/**\n\t * Insert an event object onto the timeline. Events must have a \"time\" attribute.\n\t * @param {Object} event The event object to insert into the \n\t * timeline. \n\t * @returns {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.add = function(event){\n\t\t//the event needs to have a time attribute\n\t\tif (this.isUndef(event.time)){\n\t\t\tthrow new Error(\"Tone.Timeline: events must have a time attribute\");\n\t\t}\n\t\tif (this._timeline.length){\n\t\t\tvar index = this._search(event.time);\n\t\t\tthis._timeline.splice(index + 1, 0, event);\n\t\t} else {\n\t\t\tthis._timeline.push(event);\t\t\t\n\t\t}\n\t\t//if the length is more than the memory, remove the previous ones\n\t\tif (this.length > this.memory){\n\t\t\tvar diff = this.length - this.memory;\n\t\t\tthis._timeline.splice(0, diff);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Remove an event from the timeline.\n\t * @param {Object} event The event object to remove from the list.\n\t * @returns {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.remove = function(event){\n\t\tif (this._iterating){\n\t\t\tthis._toRemove.push(event);\n\t\t} else {\n\t\t\tvar index = this._timeline.indexOf(event);\n\t\t\tif (index !== -1){\n\t\t\t\tthis._timeline.splice(index, 1);\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Get the nearest event whose time is less than or equal to the given time.\n\t * @param {Number} time The time to query.\n\t * @returns {Object} The event object set after that time.\n\t */\n\tTone.Timeline.prototype.get = function(time){\n\t\tvar index = this._search(time);\n\t\tif (index !== -1){\n\t\t\treturn this._timeline[index];\n\t\t} else {\n\t\t\treturn null;\n\t\t}\n\t};\n\n\t/**\n\t * Return the first event in the timeline without removing it\n\t * @returns {Object} The first event object\n\t */\n\tTone.Timeline.prototype.peek = function(){\n\t\treturn this._timeline[0];\n\t};\n\n\t/**\n\t * Return the first event in the timeline and remove it\n\t * @returns {Object} The first event object\n\t */\n\tTone.Timeline.prototype.shift = function(){\n\t\treturn this._timeline.shift();\n\t};\n\n\t/**\n\t * Get the event which is scheduled after the given time.\n\t * @param {Number} time The time to query.\n\t * @returns {Object} The event object after the given time\n\t */\n\tTone.Timeline.prototype.getAfter = function(time){\n\t\tvar index = this._search(time);\n\t\tif (index + 1 < this._timeline.length){\n\t\t\treturn this._timeline[index + 1];\n\t\t} else {\n\t\t\treturn null;\n\t\t}\n\t};\n\n\t/**\n\t * Get the event before the event at the given time.\n\t * @param {Number} time The time to query.\n\t * @returns {Object} The event object before the given time\n\t */\n\tTone.Timeline.prototype.getBefore = function(time){\n\t\tvar len = this._timeline.length;\n\t\t//if it's after the last item, return the last item\n\t\tif (len > 0 && this._timeline[len - 1].time < time){\n\t\t\treturn this._timeline[len - 1];\n\t\t}\n\t\tvar index = this._search(time);\n\t\tif (index - 1 >= 0){\n\t\t\treturn this._timeline[index - 1];\n\t\t} else {\n\t\t\treturn null;\n\t\t}\n\t};\n\n\t/**\n\t * Cancel events after the given time\n\t * @param {Number} time The time to query.\n\t * @returns {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.cancel = function(after){\n\t\tif (this._timeline.length > 1){\n\t\t\tvar index = this._search(after);\n\t\t\tif (index >= 0){\n\t\t\t\tif (this._timeline[index].time === after){\n\t\t\t\t\t//get the first item with that time\n\t\t\t\t\tfor (var i = index; i >= 0; i--){\n\t\t\t\t\t\tif (this._timeline[i].time === after){\n\t\t\t\t\t\t\tindex = i;\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tthis._timeline = this._timeline.slice(0, index);\n\t\t\t\t} else {\n\t\t\t\t\tthis._timeline = this._timeline.slice(0, index + 1);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tthis._timeline = [];\n\t\t\t}\n\t\t} else if (this._timeline.length === 1){\n\t\t\t//the first item's time\n\t\t\tif (this._timeline[0].time >= after){\n\t\t\t\tthis._timeline = [];\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Cancel events before or equal to the given time.\n\t * @param {Number} time The time to cancel before.\n\t * @returns {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.cancelBefore = function(time){\n\t\tif (this._timeline.length){\n\t\t\tvar index = this._search(time);\n\t\t\tif (index >= 0){\n\t\t\t\tthis._timeline = this._timeline.slice(index + 1);\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Does a binary serach on the timeline array and returns the \n\t * nearest event index whose time is after or equal to the given time.\n\t * If a time is searched before the first index in the timeline, -1 is returned.\n\t * If the time is after the end, the index of the last item is returned.\n\t * @param {Number} time \n\t * @return {Number} the index in the timeline array \n\t * @private\n\t */\n\tTone.Timeline.prototype._search = function(time){\n\t\tvar beginning = 0;\n\t\tvar len = this._timeline.length;\n\t\tvar end = len;\n\t\tif (len > 0 && this._timeline[len - 1].time <= time){\n\t\t\treturn len - 1;\n\t\t}\n\t\twhile (beginning < end){\n\t\t\t// calculate the midpoint for roughly equal partition\n\t\t\tvar midPoint = Math.floor(beginning + (end - beginning) / 2);\n\t\t\tvar event = this._timeline[midPoint];\n\t\t\tvar nextEvent = this._timeline[midPoint + 1];\n\t\t\tif (event.time === time){\n\t\t\t\t//choose the last one that has the same time\n\t\t\t\tfor (var i = midPoint; i < this._timeline.length; i++){\n\t\t\t\t\tvar testEvent = this._timeline[i];\n\t\t\t\t\tif (testEvent.time === time){\n\t\t\t\t\t\tmidPoint = i;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn midPoint;\n\t\t\t} else if (event.time < time && nextEvent.time > time){\n\t\t\t\treturn midPoint;\n\t\t\t} else if (event.time > time){\n\t\t\t\t//search lower\n\t\t\t\tend = midPoint;\n\t\t\t} else if (event.time < time){\n\t\t\t\t//search upper\n\t\t\t\tbeginning = midPoint + 1;\n\t\t\t} \n\t\t}\n\t\treturn -1;\n\t};\n\n\t/**\n\t * Internal iterator. Applies extra safety checks for \n\t * removing items from the array. \n\t * @param {Function} callback \n\t * @param {Number=} lowerBound \n\t * @param {Number=} upperBound \n\t * @private\n\t */\n\tTone.Timeline.prototype._iterate = function(callback, lowerBound, upperBound){\n\t\tthis._iterating = true;\n\t\tlowerBound = this.defaultArg(lowerBound, 0);\n\t\tupperBound = this.defaultArg(upperBound, this._timeline.length - 1);\n\t\tfor (var i = lowerBound; i <= upperBound; i++){\n\t\t\tcallback(this._timeline[i]);\n\t\t}\n\t\tthis._iterating = false;\n\t\tif (this._toRemove.length > 0){\n\t\t\tfor (var j = 0; j < this._toRemove.length; j++){\n\t\t\t\tvar index = this._timeline.indexOf(this._toRemove[j]);\n\t\t\t\tif (index !== -1){\n\t\t\t\t\tthis._timeline.splice(index, 1);\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis._toRemove = [];\n\t\t}\n\t};\n\n\t/**\n\t * Iterate over everything in the array\n\t * @param {Function} callback The callback to invoke with every item\n\t * @returns {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.forEach = function(callback){\n\t\tthis._iterate(callback);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Iterate over everything in the array at or before the given time.\n\t * @param {Number} time The time to check if items are before\n\t * @param {Function} callback The callback to invoke with every item\n\t * @returns {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.forEachBefore = function(time, callback){\n\t\t//iterate over the items in reverse so that removing an item doesn't break things\n\t\tvar upperBound = this._search(time);\n\t\tif (upperBound !== -1){\n\t\t\tthis._iterate(callback, 0, upperBound);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Iterate over everything in the array after the given time.\n\t * @param {Number} time The time to check if items are before\n\t * @param {Function} callback The callback to invoke with every item\n\t * @returns {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.forEachAfter = function(time, callback){\n\t\t//iterate over the items in reverse so that removing an item doesn't break things\n\t\tvar lowerBound = this._search(time);\n\t\tthis._iterate(callback, lowerBound + 1);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Iterate over everything in the array at or after the given time. Similar to \n\t * forEachAfter, but includes the item(s) at the given time.\n\t * @param {Number} time The time to check if items are before\n\t * @param {Function} callback The callback to invoke with every item\n\t * @returns {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.forEachFrom = function(time, callback){\n\t\t//iterate over the items in reverse so that removing an item doesn't break things\n\t\tvar lowerBound = this._search(time);\n\t\t//work backwards until the event time is less than time\n\t\twhile (lowerBound >= 0 && this._timeline[lowerBound].time >= time){\n\t\t\tlowerBound--;\n\t\t}\n\t\tthis._iterate(callback, lowerBound + 1);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Iterate over everything in the array at the given time\n\t * @param {Number} time The time to check if items are before\n\t * @param {Function} callback The callback to invoke with every item\n\t * @returns {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.forEachAtTime = function(time, callback){\n\t\t//iterate over the items in reverse so that removing an item doesn't break things\n\t\tvar upperBound = this._search(time);\n\t\tif (upperBound !== -1){\n\t\t\tthis._iterate(function(event){\n\t\t\t\tif (event.time === time){\n\t\t\t\t\tcallback(event);\n\t\t\t\t} \n\t\t\t}, 0, upperBound);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Clean up.\n\t * @return {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._timeline = null;\n\t\tthis._toRemove = null;\n\t};\n\n\treturn Tone.Timeline;\n});","define([\"Tone/core/Tone\", \"Tone/signal/Multiply\", \"Tone/signal/Signal\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Negate the incoming signal. i.e. an input signal of 10 will output -10\n\t *\n\t * @constructor\n\t * @extends {Tone.SignalBase}\n\t * @example\n\t * var neg = new Tone.Negate();\n\t * var sig = new Tone.Signal(-2).connect(neg);\n\t * //output of neg is positive 2. \n\t */\n\tTone.Negate = function(){\n\t\t/**\n\t\t * negation is done by multiplying by -1\n\t\t * @type {Tone.Multiply}\n\t\t * @private\n\t\t */\n\t\tthis._multiply = this.input = this.output = new Tone.Multiply(-1);\n\t};\n\n\tTone.extend(Tone.Negate, Tone.SignalBase);\n\n\t/**\n\t * clean up\n\t * @returns {Tone.Negate} this\n\t */\n\tTone.Negate.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._multiply.dispose();\n\t\tthis._multiply = null;\n\t\treturn this;\n\t}; \n\n\treturn Tone.Negate;\n});","define([\"Tone/core/Tone\", \"Tone/signal/Signal\", \"Tone/signal/Multiply\", \"Tone/signal/WaveShaper\"], \nfunction(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class GreaterThanZero outputs 1 when the input is strictly greater than zero\n\t * \n\t * @constructor\n\t * @extends {Tone.SignalBase}\n\t * @example\n\t * var gt0 = new Tone.GreaterThanZero();\n\t * var sig = new Tone.Signal(0.01).connect(gt0);\n\t * //the output of gt0 is 1. \n\t * sig.value = 0;\n\t * //the output of gt0 is 0. \n\t */\n\tTone.GreaterThanZero = function(){\n\t\t\n\t\t/**\n\t\t * @type {Tone.WaveShaper}\n\t\t * @private\n\t\t */\n\t\tthis._thresh = this.output = new Tone.WaveShaper(function(val){\n\t\t\tif (val <= 0){\n\t\t\t\treturn 0;\n\t\t\t} else {\n\t\t\t\treturn 1;\n\t\t\t}\n\t\t}, 127);\n\n\t\t/**\n\t\t * scale the first thresholded signal by a large value.\n\t\t * this will help with values which are very close to 0\n\t\t * @type {Tone.Multiply}\n\t\t * @private\n\t\t */\n\t\tthis._scale = this.input = new Tone.Multiply(10000);\n\n\t\t//connections\n\t\tthis._scale.connect(this._thresh);\n\t};\n\n\tTone.extend(Tone.GreaterThanZero, Tone.SignalBase);\n\n\t/**\n\t * dispose method\n\t * @returns {Tone.GreaterThanZero} this\n\t */\n\tTone.GreaterThanZero.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._scale.dispose();\n\t\tthis._scale = null;\n\t\tthis._thresh.dispose();\n\t\tthis._thresh = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.GreaterThanZero;\n});","define([\"Tone/core/Tone\", \"Tone/signal/TimelineSignal\", \"Tone/core/TimelineState\", \n\t\"Tone/core/Emitter\", \"Tone/core/Context\"], function (Tone) {\n\n\t\"use strict\";\n\n\t/**\n\t * @class A sample accurate clock which provides a callback at the given rate. \n\t * While the callback is not sample-accurate (it is still susceptible to\n\t * loose JS timing), the time passed in as the argument to the callback\n\t * is precise. For most applications, it is better to use Tone.Transport\n\t * instead of the Clock by itself since you can synchronize multiple callbacks.\n\t *\n\t * \t@constructor\n\t * @extends {Tone.Emitter}\n\t * \t@param {function} callback The callback to be invoked with the time of the audio event\n\t * \t@param {Frequency} frequency The rate of the callback\n\t * \t@example\n\t * //the callback will be invoked approximately once a second\n\t * //and will print the time exactly once a second apart.\n\t * var clock = new Tone.Clock(function(time){\n\t * \tconsole.log(time);\n\t * }, 1);\n\t */\n\tTone.Clock = function(){\n\n\t\tTone.Emitter.call(this);\n\n\t\tvar options = this.optionsObject(arguments, [\"callback\", \"frequency\"], Tone.Clock.defaults);\n\n\t\t/**\n\t\t * The callback function to invoke at the scheduled tick.\n\t\t * @type {Function}\n\t\t */\n\t\tthis.callback = options.callback;\n\n\t\t/**\n\t\t * The next time the callback is scheduled.\n\t\t * @type {Number}\n\t\t * @private\n\t\t */\n\t\tthis._nextTick = 0;\n\n\t\t/**\n\t\t * The last state of the clock.\n\t\t * @type {State}\n\t\t * @private\n\t\t */\n\t\tthis._lastState = Tone.State.Stopped;\n\n\t\t/**\n\t\t * The rate the callback function should be invoked. \n\t\t * @type {BPM}\n\t\t * @signal\n\t\t */\n\t\tthis.frequency = new Tone.TimelineSignal(options.frequency, Tone.Type.Frequency);\n\t\tthis._readOnly(\"frequency\");\n\n\t\t/**\n\t\t * The number of times the callback was invoked. Starts counting at 0\n\t\t * and increments after the callback was invoked. \n\t\t * @type {Ticks}\n\t\t * @readOnly\n\t\t */\n\t\tthis.ticks = 0;\n\n\t\t/**\n\t\t * The state timeline\n\t\t * @type {Tone.TimelineState}\n\t\t * @private\n\t\t */\n\t\tthis._state = new Tone.TimelineState(Tone.State.Stopped);\n\n\t\t/**\n\t\t * The loop function bound to its context. \n\t\t * This is necessary to remove the event in the end.\n\t\t * @type {Function}\n\t\t * @private\n\t\t */\n\t\tthis._boundLoop = this._loop.bind(this);\n\n\t\t//bind a callback to the worker thread\n \tthis.context.on(\"tick\", this._boundLoop);\n\t};\n\n\tTone.extend(Tone.Clock, Tone.Emitter);\n\n\t/**\n\t * The defaults\n\t * @const\n\t * @type {Object}\n\t */\n\tTone.Clock.defaults = {\n\t\t\"callback\" : Tone.noOp,\n\t\t\"frequency\" : 1,\n\t\t\"lookAhead\" : \"auto\",\n\t};\n\n\t/**\n\t * Returns the playback state of the source, either \"started\", \"stopped\" or \"paused\".\n\t * @type {Tone.State}\n\t * @readOnly\n\t * @memberOf Tone.Clock#\n\t * @name state\n\t */\n\tObject.defineProperty(Tone.Clock.prototype, \"state\", {\n\t\tget : function(){\n\t\t\treturn this._state.getValueAtTime(this.now());\n\t\t}\n\t});\n\n\t/**\n\t * Start the clock at the given time. Optionally pass in an offset\n\t * of where to start the tick counter from.\n\t * @param {Time} time The time the clock should start\n\t * @param {Ticks=} offset Where the tick counter starts counting from.\n\t * @return {Tone.Clock} this\n\t */\n\tTone.Clock.prototype.start = function(time, offset){\n\t\ttime = this.toSeconds(time);\n\t\tif (this._state.getValueAtTime(time) !== Tone.State.Started){\n\t\t\tthis._state.add({\n\t\t\t\t\"state\" : Tone.State.Started, \n\t\t\t\t\"time\" : time,\n\t\t\t\t\"offset\" : offset\n\t\t\t});\n\t\t}\n\t\treturn this;\t\n\t};\n\n\t/**\n\t * Stop the clock. Stopping the clock resets the tick counter to 0.\n\t * @param {Time} [time=now] The time when the clock should stop.\n\t * @returns {Tone.Clock} this\n\t * @example\n\t * clock.stop();\n\t */\n\tTone.Clock.prototype.stop = function(time){\n\t\ttime = this.toSeconds(time);\n\t\tthis._state.cancel(time);\n\t\tthis._state.setStateAtTime(Tone.State.Stopped, time);\n\t\treturn this;\t\n\t};\n\n\n\t/**\n\t * Pause the clock. Pausing does not reset the tick counter.\n\t * @param {Time} [time=now] The time when the clock should stop.\n\t * @returns {Tone.Clock} this\n\t */\n\tTone.Clock.prototype.pause = function(time){\n\t\ttime = this.toSeconds(time);\n\t\tif (this._state.getValueAtTime(time) === Tone.State.Started){\n\t\t\tthis._state.setStateAtTime(Tone.State.Paused, time);\n\t\t}\n\t\treturn this;\t\n\t};\n\n\t/**\n\t * The scheduling loop.\n\t * @param {Number} time The current page time starting from 0\n\t * when the page was loaded.\n\t * @private\n\t */\n\tTone.Clock.prototype._loop = function(){\n\t\t//get the frequency value to compute the value of the next loop\n\t\tvar now = this.now();\n\t\t//if it's started\n\t\tvar lookAhead = this.context.lookAhead;\n\t\tvar updateInterval = this.context.updateInterval;\n\t\tvar lagCompensation = this.context.lag * 2;\n\t\tvar loopInterval = now + lookAhead + updateInterval + lagCompensation;\n\t\twhile (loopInterval > this._nextTick && this._state){\n\t\t\tvar currentState = this._state.getValueAtTime(this._nextTick);\n\t\t\tif (currentState !== this._lastState){\n\t\t\t\tthis._lastState = currentState;\n\t\t\t\tvar event = this._state.get(this._nextTick);\n\t\t\t\t// emit an event\n\t\t\t\tif (currentState === Tone.State.Started){\n\t\t\t\t\t//correct the time\n\t\t\t\t\tthis._nextTick = event.time;\n\t\t\t\t\tif (!this.isUndef(event.offset)){\n\t\t\t\t\t\tthis.ticks = event.offset;\n\t\t\t\t\t}\n\t\t\t\t\tthis.emit(\"start\", event.time, this.ticks);\n\t\t\t\t} else if (currentState === Tone.State.Stopped){\n\t\t\t\t\tthis.ticks = 0;\n\n\t\t\t\t\tthis.emit(\"stop\", event.time);\n\t\t\t\t} else if (currentState === Tone.State.Paused){\n\t\t\t\t\tthis.emit(\"pause\", event.time);\n\t\t\t\t}\n\t\t\t}\n\t\t\tvar tickTime = this._nextTick;\n\t\t\tif (this.frequency){\n\t\t\t\tthis._nextTick += 1 / this.frequency.getValueAtTime(this._nextTick);\n\t\t\t\tif (currentState === Tone.State.Started){\n\t\t\t\t\tthis.callback(tickTime);\n\t\t\t\t\tthis.ticks++;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n\n\t/**\n\t * Returns the scheduled state at the given time.\n\t * @param {Time} time The time to query.\n\t * @return {String} The name of the state input in setStateAtTime.\n\t * @example\n\t * clock.start(\"+0.1\");\n\t * clock.getStateAtTime(\"+0.1\"); //returns \"started\"\n\t */\n\tTone.Clock.prototype.getStateAtTime = function(time){\n\t\ttime = this.toSeconds(time);\n\t\treturn this._state.getValueAtTime(time);\n\t};\n\n\t/**\n\t * Clean up\n\t * @returns {Tone.Clock} this\n\t */\n\tTone.Clock.prototype.dispose = function(){\n\t\tTone.Emitter.prototype.dispose.call(this);\n\t\tthis.context.off(\"tick\", this._boundLoop);\n\t\tthis._writable(\"frequency\");\n\t\tthis.frequency.dispose();\n\t\tthis.frequency = null;\n\t\tthis._boundLoop = null;\n\t\tthis._nextTick = Infinity;\n\t\tthis.callback = null;\n\t\tthis._state.dispose();\n\t\tthis._state = null;\n\t};\n\n\treturn Tone.Clock;\n});","'use strict';\ndefine(function (require) {\n\n var p5sound = require('master');\n var AudioVoice = require('audioVoice');\n var noteToFreq = require('helpers').noteToFreq;\n\n var DEFAULT_SUSTAIN = 0.15;\n\n /**\n * A MonoSynth is used as a single voice for sound synthesis.\n * This is a class to be used in conjunction with the PolySynth\n * class. Custom synthetisers should be built inheriting from\n * this class.\n *\n * @class p5.MonoSynth\n * @constructor\n * @example\n *
\n * let monoSynth;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playSynth);\n * background(220);\n * textAlign(CENTER);\n * text('tap to play', width/2, height/2);\n *\n * monoSynth = new p5.MonoSynth();\n * }\n *\n * function playSynth() {\n * userStartAudio();\n *\n * let note = random(['Fb4', 'G4']);\n * // note velocity (volume, from 0 to 1)\n * let velocity = random();\n * // time from now (in seconds)\n * let time = 0;\n * // note duration (in seconds)\n * let dur = 1/6;\n *\n * monoSynth.play(note, velocity, time, dur);\n * }\n *
\n **/\n\n p5.MonoSynth = function () {\n AudioVoice.call(this);\n\n this.oscillator = new p5.Oscillator();\n\n this.env = new p5.Envelope();\n this.env.setRange(1, 0);\n this.env.setExp(true);\n\n //set params\n this.setADSR(0.02, 0.25, 0.05, 0.35);\n\n // oscillator --> env --> this.output (gain) --> p5.soundOut\n this.oscillator.disconnect();\n this.oscillator.connect(this.output);\n\n this.env.disconnect();\n this.env.setInput(this.output.gain);\n\n // reset oscillator gain to 1.0\n this.oscillator.output.gain.value = 1.0;\n\n this.oscillator.start();\n this.connect();\n\n p5sound.soundArray.push(this);\n };\n\n p5.MonoSynth.prototype = Object.create(p5.AudioVoice.prototype);\n\n /**\n * Play tells the MonoSynth to start playing a note. This method schedules\n * the calling of .triggerAttack and .triggerRelease.\n *\n * @method play\n * @for p5.MonoSynth\n * @param {String | Number} note the note you want to play, specified as a\n * frequency in Hertz (Number) or as a midi\n * value in Note/Octave format (\"C4\", \"Eb3\"...etc\")\n * See \n * Tone. Defaults to 440 hz.\n * @param {Number} [velocity] velocity of the note to play (ranging from 0 to 1)\n * @param {Number} [secondsFromNow] time from now (in seconds) at which to play\n * @param {Number} [sustainTime] time to sustain before releasing the envelope. Defaults to 0.15 seconds.\n * @example\n *
\n * let monoSynth;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playSynth);\n * background(220);\n * textAlign(CENTER);\n * text('tap to play', width/2, height/2);\n *\n * monoSynth = new p5.MonoSynth();\n * }\n *\n * function playSynth() {\n * userStartAudio();\n *\n * let note = random(['Fb4', 'G4']);\n * // note velocity (volume, from 0 to 1)\n * let velocity = random();\n * // time from now (in seconds)\n * let time = 0;\n * // note duration (in seconds)\n * let dur = 1/6;\n *\n * monoSynth.play(note, velocity, time, dur);\n * }\n *
\n *\n */\n p5.MonoSynth.prototype.play = function (note, velocity, secondsFromNow, susTime) {\n this.triggerAttack(note, velocity, ~~secondsFromNow);\n this.triggerRelease(~~secondsFromNow + (susTime || DEFAULT_SUSTAIN));\n };\n\n /**\n * Trigger the Attack, and Decay portion of the Envelope.\n * Similar to holding down a key on a piano, but it will\n * hold the sustain level until you let go.\n *\n * @param {String | Number} note the note you want to play, specified as a\n * frequency in Hertz (Number) or as a midi\n * value in Note/Octave format (\"C4\", \"Eb3\"...etc\")\n * See \n * Tone. Defaults to 440 hz\n * @param {Number} [velocity] velocity of the note to play (ranging from 0 to 1)\n * @param {Number} [secondsFromNow] time from now (in seconds) at which to play\n * @method triggerAttack\n * @for p5.MonoSynth\n * @example\n *
\n * let monoSynth;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(triggerAttack);\n * background(220);\n * text('tap here for attack, let go to release', 5, 20, width - 20);\n * monoSynth = new p5.MonoSynth();\n * }\n *\n * function triggerAttack() {\n * userStartAudio();\n *\n * monoSynth.triggerAttack(\"E3\");\n * }\n *\n * function mouseReleased() {\n * monoSynth.triggerRelease();\n * }\n *
\n */\n p5.MonoSynth.prototype.triggerAttack = function (note, velocity, secondsFromNow) {\n var secondsFromNow = ~~secondsFromNow;\n var freq = noteToFreq(note);\n var vel = velocity || 0.1;\n this.oscillator.freq(freq, 0, secondsFromNow);\n this.env.ramp(this.output.gain, secondsFromNow, vel);\n };\n\n /**\n * Trigger the release of the Envelope. This is similar to releasing\n * the key on a piano and letting the sound fade according to the\n * release level and release time.\n *\n * @param {Number} secondsFromNow time to trigger the release\n * @method triggerRelease\n * @for p5.MonoSynth\n * @example\n *
\n * let monoSynth;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(triggerAttack);\n * background(220);\n * text('tap here for attack, let go to release', 5, 20, width - 20);\n * monoSynth = new p5.MonoSynth();\n * }\n *\n * function triggerAttack() {\n * userStartAudio();\n *\n * monoSynth.triggerAttack(\"E3\");\n * }\n *\n * function mouseReleased() {\n * monoSynth.triggerRelease();\n * }\n *
\n */\n p5.MonoSynth.prototype.triggerRelease = function (secondsFromNow) {\n var secondsFromNow = secondsFromNow || 0;\n this.env.ramp(this.output.gain, secondsFromNow, 0);\n };\n\n /**\n * Set values like a traditional\n * \n * ADSR envelope\n * .\n *\n * @method setADSR\n * @for p5.MonoSynth\n * @param {Number} attackTime Time (in seconds before envelope\n * reaches Attack Level\n * @param {Number} [decayTime] Time (in seconds) before envelope\n * reaches Decay/Sustain Level\n * @param {Number} [susRatio] Ratio between attackLevel and releaseLevel, on a scale from 0 to 1,\n * where 1.0 = attackLevel, 0.0 = releaseLevel.\n * The susRatio determines the decayLevel and the level at which the\n * sustain portion of the envelope will sustain.\n * For example, if attackLevel is 0.4, releaseLevel is 0,\n * and susAmt is 0.5, the decayLevel would be 0.2. If attackLevel is\n * increased to 1.0 (using setRange),\n * then decayLevel would increase proportionally, to become 0.5.\n * @param {Number} [releaseTime] Time in seconds from now (defaults to 0)\n */\n p5.MonoSynth.prototype.setADSR = function (attack,decay,sustain,release) {\n this.env.setADSR(attack, decay, sustain, release);\n };\n\n\n /**\n * Getters and Setters\n * @property {Number} attack\n * @for p5.MonoSynth\n */\n /**\n * @property {Number} decay\n * @for p5.MonoSynth\n */\n /**\n * @property {Number} sustain\n * @for p5.MonoSynth\n */\n /**\n * @property {Number} release\n * @for p5.MonoSynth\n */\n Object.defineProperties(p5.MonoSynth.prototype, {\n 'attack': {\n get : function() {\n return this.env.aTime;\n },\n set : function(attack) {\n this.env.setADSR(attack, this.env.dTime,\n this.env.sPercent, this.env.rTime);\n }\n },\n 'decay': {\n get : function() {\n return this.env.dTime;\n },\n set : function(decay) {\n this.env.setADSR(this.env.aTime, decay,\n this.env.sPercent, this.env.rTime);\n }\n },\n 'sustain': {\n get : function() {\n return this.env.sPercent;\n },\n set : function(sustain) {\n this.env.setADSR(this.env.aTime, this.env.dTime,\n sustain, this.env.rTime);\n }\n },\n 'release': {\n get : function() {\n return this.env.rTime;\n },\n set : function(release) {\n this.env.setADSR(this.env.aTime, this.env.dTime,\n this.env.sPercent, release);\n }\n },\n });\n\n\n /**\n * MonoSynth amp\n * @method amp\n * @for p5.MonoSynth\n * @param {Number} vol desired volume\n * @param {Number} [rampTime] Time to reach new volume\n * @return {Number} new volume value\n */\n p5.MonoSynth.prototype.amp = function(vol, rampTime) {\n var t = rampTime || 0;\n if (typeof vol !== 'undefined') {\n this.oscillator.amp(vol, t);\n }\n return this.oscillator.amp().value;\n };\n\n /**\n * Connect to a p5.sound / Web Audio object.\n *\n * @method connect\n * @for p5.MonoSynth\n * @param {Object} unit A p5.sound or Web Audio object\n */\n\n p5.MonoSynth.prototype.connect = function(unit) {\n var u = unit || p5sound.input;\n this.output.connect(u.input ? u.input : u);\n };\n\n /**\n * Disconnect all outputs\n *\n * @method disconnect\n * @for p5.MonoSynth\n */\n p5.MonoSynth.prototype.disconnect = function() {\n if (this.output) {\n this.output.disconnect();\n }\n };\n\n\n /**\n * Get rid of the MonoSynth and free up its resources / memory.\n *\n * @method dispose\n * @for p5.MonoSynth\n */\n p5.MonoSynth.prototype.dispose = function() {\n AudioVoice.prototype.dispose.apply(this);\n\n if (this.env) {\n this.env.dispose();\n }\n if (this.oscillator) {\n this.oscillator.dispose();\n }\n };\n\n});\n","'use strict';\ndefine(function() {\n var p5sound = require('master');\n\n /**\n * Base class for monophonic synthesizers. Any extensions of this class\n * should follow the API and implement the methods below in order to\n * remain compatible with p5.PolySynth();\n *\n * @class p5.AudioVoice\n * @constructor\n */\n p5.AudioVoice = function () {\n\t this.ac = p5sound.audiocontext;\n\t this.output = this.ac.createGain();\n\t this.connect();\n\t p5sound.soundArray.push(this);\n };\n\n p5.AudioVoice.prototype.play = function (note, velocity, secondsFromNow, sustime) {\n };\n\n p5.AudioVoice.prototype.triggerAttack = function (note, velocity, secondsFromNow) {\n };\n\n p5.AudioVoice.prototype.triggerRelease = function (secondsFromNow) {\n };\n\n p5.AudioVoice.prototype.amp = function(vol, rampTime) {\n };\n\n /**\n * Connect to p5 objects or Web Audio Nodes\n * @method connect\n * @for p5.AudioVoice\n * @param {Object} unit\n */\n p5.AudioVoice.prototype.connect = function(unit) {\n var u = unit || p5sound.input;\n this.output.connect(u.input ? u.input : u);\n };\n\n /**\n * Disconnect from soundOut\n * @method disconnect\n * @for p5.AudioVoice\n */\n p5.AudioVoice.prototype.disconnect = function() {\n this.output.disconnect();\n };\n\n p5.AudioVoice.prototype.dispose = function() {\n if (this.output) {\n this.output.disconnect();\n delete this.output;\n }\n };\n\n return p5.AudioVoice;\n});\n","'use strict';\ndefine(function (require) {\n\n var p5sound = require('master');\n var TimelineSignal = require('Tone/signal/TimelineSignal');\n var noteToFreq = require('helpers').noteToFreq;\n\n /**\n * An AudioVoice is used as a single voice for sound synthesis.\n * The PolySynth class holds an array of AudioVoice, and deals\n * with voices allocations, with setting notes to be played, and\n * parameters to be set.\n *\n * @class p5.PolySynth\n * @constructor\n *\n * @param {Number} [synthVoice] A monophonic synth voice inheriting\n * the AudioVoice class. Defaults to p5.MonoSynth\n * @param {Number} [maxVoices] Number of voices, defaults to 8;\n * @example\n *
\n * let polySynth;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playSynth);\n * background(220);\n * text('click to play', 20, 20);\n *\n * polySynth = new p5.PolySynth();\n * }\n *\n * function playSynth() {\n * userStartAudio();\n *\n * // note duration (in seconds)\n * let dur = 1.5;\n *\n * // time from now (in seconds)\n * let time = 0;\n *\n * // velocity (volume, from 0 to 1)\n * let vel = 0.1;\n *\n * // notes can overlap with each other\n * polySynth.play('G2', vel, 0, dur);\n * polySynth.play('C3', vel, time += 1/3, dur);\n * polySynth.play('G3', vel, time += 1/3, dur);\n * }\n *
\n **/\n p5.PolySynth = function(audioVoice, maxVoices) {\n //audiovoices will contain maxVoices many monophonic synths\n this.audiovoices = [];\n\n /**\n * An object that holds information about which notes have been played and\n * which notes are currently being played. New notes are added as keys\n * on the fly. While a note has been attacked, but not released, the value of the\n * key is the audiovoice which is generating that note. When notes are released,\n * the value of the key becomes undefined.\n * @property notes\n */\n this.notes = {};\n\n //indices of the most recently used, and least recently used audiovoice\n this._newest = 0;\n this._oldest = 0;\n\n /**\n * A PolySynth must have at least 1 voice, defaults to 8\n * @property polyvalue\n */\n this.maxVoices = maxVoices || 8;\n\n /**\n * Monosynth that generates the sound for each note that is triggered. The\n * p5.PolySynth defaults to using the p5.MonoSynth as its voice.\n * @property AudioVoice\n */\n this.AudioVoice = audioVoice === undefined ? p5.MonoSynth : audioVoice;\n\n /**\n * This value must only change as a note is attacked or released. Due to delay\n * and sustain times, Tone.TimelineSignal is required to schedule the change in value.\n\t * @private\n * @property {Tone.TimelineSignal} _voicesInUse\n */\n this._voicesInUse = new TimelineSignal(0);\n\n this.output = p5sound.audiocontext.createGain();\n this.connect();\n\n //Construct the appropriate number of audiovoices\n this._allocateVoices();\n p5sound.soundArray.push(this);\n };\n\n /**\n * Construct the appropriate number of audiovoices\n * @private\n * @for p5.PolySynth\n * @method _allocateVoices\n */\n p5.PolySynth.prototype._allocateVoices = function() {\n for(var i = 0; i< this.maxVoices; i++) {\n this.audiovoices.push(new this.AudioVoice());\n this.audiovoices[i].disconnect();\n this.audiovoices[i].connect(this.output);\n }\n };\n\n /**\n * Play a note by triggering noteAttack and noteRelease with sustain time\n *\n * @method play\n * @for p5.PolySynth\n * @param {Number} [note] midi note to play (ranging from 0 to 127 - 60 being a middle C)\n * @param {Number} [velocity] velocity of the note to play (ranging from 0 to 1)\n * @param {Number} [secondsFromNow] time from now (in seconds) at which to play\n * @param {Number} [sustainTime] time to sustain before releasing the envelope\n * @example\n *
\n * let polySynth;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playSynth);\n * background(220);\n * text('click to play', 20, 20);\n *\n * polySynth = new p5.PolySynth();\n * }\n *\n * function playSynth() {\n * userStartAudio();\n *\n * // note duration (in seconds)\n * let dur = 1.5;\n *\n * // time from now (in seconds)\n * let time = 0;\n *\n * // velocity (volume, from 0 to 1)\n * let vel = 0.1;\n *\n * // notes can overlap with each other\n * polySynth.play('G2', vel, 0, dur);\n * polySynth.play('C3', vel, time += 1/3, dur);\n * polySynth.play('G3', vel, time += 1/3, dur);\n * }\n *
\n */\n p5.PolySynth.prototype.play = function (note,velocity, secondsFromNow, susTime) {\n var susTime = susTime || 1;\n this.noteAttack(note, velocity, secondsFromNow);\n this.noteRelease(note, secondsFromNow + susTime);\n };\n\n\n /**\n * noteADSR sets the envelope for a specific note that has just been triggered.\n * Using this method modifies the envelope of whichever audiovoice is being used\n * to play the desired note. The envelope should be reset before noteRelease is called\n * in order to prevent the modified envelope from being used on other notes.\n *\n * @method noteADSR\n * @for p5.PolySynth\n * @param {Number} [note] Midi note on which ADSR should be set.\n * @param {Number} [attackTime] Time (in seconds before envelope\n * reaches Attack Level\n * @param {Number} [decayTime] Time (in seconds) before envelope\n * reaches Decay/Sustain Level\n * @param {Number} [susRatio] Ratio between attackLevel and releaseLevel, on a scale from 0 to 1,\n * where 1.0 = attackLevel, 0.0 = releaseLevel.\n * The susRatio determines the decayLevel and the level at which the\n * sustain portion of the envelope will sustain.\n * For example, if attackLevel is 0.4, releaseLevel is 0,\n * and susAmt is 0.5, the decayLevel would be 0.2. If attackLevel is\n * increased to 1.0 (using setRange),\n * then decayLevel would increase proportionally, to become 0.5.\n * @param {Number} [releaseTime] Time in seconds from now (defaults to 0)\n **/\n\n p5.PolySynth.prototype.noteADSR = function (note,a,d,s,r,timeFromNow) {\n var now = p5sound.audiocontext.currentTime;\n var timeFromNow = timeFromNow || 0;\n var t = now + timeFromNow\n this.audiovoices[ this.notes[note].getValueAtTime(t) ].setADSR(a,d,s,r);\n };\n\n\n /**\n * Set the PolySynths global envelope. This method modifies the envelopes of each\n * monosynth so that all notes are played with this envelope.\n *\n * @method setADSR\n * @for p5.PolySynth\n * @param {Number} [attackTime] Time (in seconds before envelope\n * reaches Attack Level\n * @param {Number} [decayTime] Time (in seconds) before envelope\n * reaches Decay/Sustain Level\n * @param {Number} [susRatio] Ratio between attackLevel and releaseLevel, on a scale from 0 to 1,\n * where 1.0 = attackLevel, 0.0 = releaseLevel.\n * The susRatio determines the decayLevel and the level at which the\n * sustain portion of the envelope will sustain.\n * For example, if attackLevel is 0.4, releaseLevel is 0,\n * and susAmt is 0.5, the decayLevel would be 0.2. If attackLevel is\n * increased to 1.0 (using setRange),\n * then decayLevel would increase proportionally, to become 0.5.\n * @param {Number} [releaseTime] Time in seconds from now (defaults to 0)\n **/\n p5.PolySynth.prototype.setADSR = function(a,d,s,r) {\n this.audiovoices.forEach(function(voice) {\n voice.setADSR(a,d,s,r);\n });\n };\n\n /**\n * Trigger the Attack, and Decay portion of a MonoSynth.\n * Similar to holding down a key on a piano, but it will\n * hold the sustain level until you let go.\n *\n * @method noteAttack\n * @for p5.PolySynth\n * @param {Number} [note] midi note on which attack should be triggered.\n * @param {Number} [velocity] velocity of the note to play (ranging from 0 to 1)/\n * @param {Number} [secondsFromNow] time from now (in seconds)\n * @example\n *
\n * let polySynth = new p5.PolySynth();\n * let pitches = ['G', 'D', 'G', 'C'];\n * let octaves = [2, 3, 4];\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playChord);\n * background(220);\n * text('tap to play', 20, 20);\n * }\n *\n * function playChord() {\n * userStartAudio();\n *\n * // play a chord: multiple notes at the same time\n * for (let i = 0; i < 4; i++) {\n * let note = random(pitches) + random(octaves);\n * polySynth.noteAttack(note, 0.1);\n * }\n * }\n *\n * function mouseReleased() {\n * // release all voices\n * polySynth.noteRelease();\n * }\n *
\n */\n p5.PolySynth.prototype.noteAttack = function (_note, _velocity, secondsFromNow) {\n //this value goes to the audiovoices which handle their own scheduling\n var secondsFromNow = ~~secondsFromNow;\n\n //this value is used by this._voicesInUse\n var acTime = p5sound.audiocontext.currentTime + secondsFromNow;\n\n //Convert note to frequency if necessary. This is because entries into this.notes\n //should be based on frequency for the sake of consistency.\n var note = noteToFreq(_note);\n var velocity = _velocity || 0.1;\n\n var currentVoice;\n\n //Release the note if it is already playing\n if (this.notes[note] && this.notes[note].getValueAtTime(acTime) !== null) {\n this.noteRelease(note, 0);\n }\n\n //Check to see how many voices are in use at the time the note will start\n if (this._voicesInUse.getValueAtTime(acTime) < this.maxVoices) {\n currentVoice = Math.max(~~this._voicesInUse.getValueAtTime(acTime), 0);\n }\n //If we are exceeding the polyvalue, bump off the oldest notes and replace\n //with a new note\n else {\n currentVoice = this._oldest;\n\n var oldestNote = p5.prototype.freqToMidi(this.audiovoices[this._oldest].oscillator.freq().value);\n this.noteRelease(oldestNote);\n this._oldest = ( this._oldest + 1 ) % (this.maxVoices - 1);\n }\n\n //Overrite the entry in the notes object. A note (frequency value)\n //corresponds to the index of the audiovoice that is playing it\n this.notes[note] = new TimelineSignal();\n this.notes[note].setValueAtTime(currentVoice, acTime);\n\n //Find the scheduled change in this._voicesInUse that will be previous to this new note\n //Add 1 and schedule this value at time 't', when this note will start playing\n var previousVal = this._voicesInUse._searchBefore(acTime) === null ? 0 : this._voicesInUse._searchBefore(acTime).value;\n this._voicesInUse.setValueAtTime(previousVal + 1, acTime);\n\n //Then update all scheduled values that follow to increase by 1\n this._updateAfter(acTime, 1);\n\n this._newest = currentVoice;\n //The audiovoice handles the actual scheduling of the note\n if (typeof velocity === 'number') {\n var maxRange = 1 / this._voicesInUse.getValueAtTime(acTime) * 2;\n velocity = velocity > maxRange ? maxRange : velocity;\n }\n this.audiovoices[currentVoice].triggerAttack(note, velocity, secondsFromNow);\n };\n\n /**\n * Private method to ensure accurate values of this._voicesInUse\n * Any time a new value is scheduled, it is necessary to increment all subsequent\n * scheduledValues after attack, and decrement all subsequent\n * scheduledValues after release\n *\n * @private\n * @for p5.PolySynth\n * @param {[type]} time [description]\n * @param {[type]} value [description]\n * @return {[type]} [description]\n */\n p5.PolySynth.prototype._updateAfter = function(time, value) {\n if(this._voicesInUse._searchAfter(time) === null) {\n return;\n } else{\n this._voicesInUse._searchAfter(time).value += value;\n var nextTime = this._voicesInUse._searchAfter(time).time;\n this._updateAfter(nextTime, value);\n }\n };\n\n\n /**\n * Trigger the Release of an AudioVoice note. This is similar to releasing\n * the key on a piano and letting the sound fade according to the\n * release level and release time.\n *\n * @method noteRelease\n * @for p5.PolySynth\n * @param {Number} [note] midi note on which attack should be triggered.\n * If no value is provided, all notes will be released.\n * @param {Number} [secondsFromNow] time to trigger the release\n * @example\n *
\n * let polySynth = new p5.PolySynth();\n * let pitches = ['G', 'D', 'G', 'C'];\n * let octaves = [2, 3, 4];\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playChord);\n * background(220);\n * text('tap to play', 20, 20);\n * }\n *\n * function playChord() {\n * userStartAudio();\n *\n * // play a chord: multiple notes at the same time\n * for (let i = 0; i < 4; i++) {\n * let note = random(pitches) + random(octaves);\n * polySynth.noteAttack(note, 0.1);\n * }\n * }\n *\n * function mouseReleased() {\n * // release all voices\n * polySynth.noteRelease();\n * }\n *
\n *\n */\n p5.PolySynth.prototype.noteRelease = function (_note,secondsFromNow) {\n var now = p5sound.audiocontext.currentTime;\n var tFromNow = secondsFromNow || 0;\n var t = now + tFromNow;\n\n // if a note value is not provided, release all voices\n if (!_note) {\n this.audiovoices.forEach(function(voice) {\n voice.triggerRelease(tFromNow)\n });\n this._voicesInUse.setValueAtTime(0, t);\n for (var n in this.notes) {\n this.notes[n].dispose();\n delete this.notes[n];\n }\n return;\n }\n\n //Make sure note is in frequency inorder to query the this.notes object\n var note = noteToFreq(_note);\n\n if (!this.notes[note] || this.notes[note].getValueAtTime(t) === null) {\n console.warn('Cannot release a note that is not already playing');\n } else {\n //Find the scheduled change in this._voicesInUse that will be previous to this new note\n //subtract 1 and schedule this value at time 't', when this note will stop playing\n var previousVal = Math.max(~~this._voicesInUse.getValueAtTime(t).value, 1);\n this._voicesInUse.setValueAtTime(previousVal - 1, t);\n //Then update all scheduled values that follow to decrease by 1 but never go below 0\n if (previousVal > 0) {\n this._updateAfter(t, -1);\n }\n\n this.audiovoices[ this.notes[note].getValueAtTime(t) ].triggerRelease(tFromNow);\n this.notes[note].dispose();\n delete this.notes[note];\n\n this._newest = this._newest === 0 ? 0 : (this._newest - 1) % (this.maxVoices - 1);\n }\n\n };\n\n /**\n * Connect to a p5.sound / Web Audio object.\n *\n * @method connect\n * @for p5.PolySynth\n * @param {Object} unit A p5.sound or Web Audio object\n */\n p5.PolySynth.prototype.connect = function (unit) {\n var u = unit || p5sound.input;\n this.output.connect(u.input ? u.input : u);\n };\n\n /**\n * Disconnect all outputs\n *\n * @method disconnect\n * @for p5.PolySynth\n */\n p5.PolySynth.prototype.disconnect = function() {\n if (this.output) {\n this.output.disconnect();\n }\n };\n\n /**\n * Get rid of the MonoSynth and free up its resources / memory.\n *\n * @method dispose\n * @for p5.PolySynth\n */\n p5.PolySynth.prototype.dispose = function() {\n this.audiovoices.forEach(function(voice) {\n voice.dispose();\n });\n\n if (this.output) {\n this.output.disconnect();\n delete this.output;\n }\n };\n\n});\n","'use strict';\n\ndefine(function (require) {\n\n require('audioworklet-polyfill');\n require('shims');\n require('audiocontext');\n var p5SOUND = require('master');\n require('helpers');\n require('errorHandler');\n require('audioWorklet');\n require('panner');\n require('soundfile');\n require('amplitude');\n require('fft');\n require('signal');\n require('oscillator');\n require('envelope');\n require('pulse');\n require('noise');\n require('audioin');\n require('filter');\n require('eq');\n require('panner3d');\n require('listener3d');\n require('delay');\n require('reverb');\n require('metro');\n require('looper');\n require('soundLoop');\n require('compressor');\n require('soundRecorder');\n require('peakDetect');\n require('gain');\n require('monosynth');\n require('polysynth');\n require('distortion');\n require('audioVoice');\n require('monosynth');\n require('polysynth');\n\n return p5SOUND;\n\n});\n","!function(){var e,t=[];function r(e){var r=this,n={},i=-1;this.parameters.forEach(function(e,o){var s=t[++i]||(t[i]=new Float32Array(r.bufferSize));s.fill(e.value),n[o]=s}),this.processor.realm.exec(\"self.sampleRate=sampleRate=\"+this.context.sampleRate+\";self.currentTime=currentTime=\"+this.context.currentTime);var s=o(e.inputBuffer),a=o(e.outputBuffer);this.instance.process([s],[a],n)}function o(e){for(var t=[],r=0;r= this._length) {\\n this._writeIndex = 0;\\n } // For excessive frames, the buffer will be overwritten.\\n\\n\\n this._framesAvailable += sourceLength;\\n\\n if (this._framesAvailable > this._length) {\\n this._framesAvailable = this._length;\\n }\\n }\\n /**\\n * Pull data out of buffer and fill a given sequence of Float32Arrays.\\n *\\n * @param {array} arraySequence An array of Float32Arrays.\\n */\\n\\n }, {\\n key: \\\"pull\\\",\\n value: function pull(arraySequence) {\\n // The channel count of arraySequence and the length of each channel must\\n // match with this buffer obejct.\\n // If the FIFO is completely empty, do nothing.\\n if (this._framesAvailable === 0) {\\n return;\\n }\\n\\n var destinationLength = arraySequence[0].length; // Transfer data from the internal buffer to the |arraySequence| storage.\\n\\n for (var i = 0; i < destinationLength; ++i) {\\n var readIndex = (this._readIndex + i) % this._length;\\n\\n for (var channel = 0; channel < this._channelCount; ++channel) {\\n arraySequence[channel][i] = this._channelData[channel][readIndex];\\n }\\n }\\n\\n this._readIndex += destinationLength;\\n\\n if (this._readIndex >= this._length) {\\n this._readIndex = 0;\\n }\\n\\n this._framesAvailable -= destinationLength;\\n\\n if (this._framesAvailable < 0) {\\n this._framesAvailable = 0;\\n }\\n }\\n }, {\\n key: \\\"framesAvailable\\\",\\n get: function get() {\\n return this._framesAvailable;\\n }\\n }]);\\n\\n return RingBuffer;\\n }()\\n}[\\\"default\\\"];\\n\\nvar RecorderProcessor =\\n/*#__PURE__*/\\nfunction (_AudioWorkletProcesso) {\\n _inherits(RecorderProcessor, _AudioWorkletProcesso);\\n\\n function RecorderProcessor(options) {\\n var _this;\\n\\n _classCallCheck(this, RecorderProcessor);\\n\\n _this = _possibleConstructorReturn(this, _getPrototypeOf(RecorderProcessor).call(this));\\n var processorOptions = options.processorOptions || {};\\n _this.numOutputChannels = options.outputChannelCount || 2;\\n _this.numInputChannels = processorOptions.numInputChannels || 2;\\n _this.bufferSize = processorOptions.bufferSize || 1024;\\n _this.recording = false;\\n\\n _this.clear();\\n\\n _this.port.onmessage = function (event) {\\n var data = event.data;\\n\\n if (data.name === 'start') {\\n _this.record(data.duration);\\n } else if (data.name === 'stop') {\\n _this.stop();\\n }\\n };\\n\\n return _this;\\n }\\n\\n _createClass(RecorderProcessor, [{\\n key: \\\"process\\\",\\n value: function process(inputs) {\\n if (!this.recording) {\\n return true;\\n } else if (this.sampleLimit && this.recordedSamples >= this.sampleLimit) {\\n this.stop();\\n return true;\\n }\\n\\n var input = inputs[0];\\n this.inputRingBuffer.push(input);\\n\\n if (this.inputRingBuffer.framesAvailable >= this.bufferSize) {\\n this.inputRingBuffer.pull(this.inputRingBufferArraySequence);\\n\\n for (var channel = 0; channel < this.numOutputChannels; ++channel) {\\n var inputChannelCopy = this.inputRingBufferArraySequence[channel].slice();\\n\\n if (channel === 0) {\\n this.leftBuffers.push(inputChannelCopy);\\n\\n if (this.numInputChannels === 1) {\\n this.rightBuffers.push(inputChannelCopy);\\n }\\n } else if (channel === 1 && this.numInputChannels > 1) {\\n this.rightBuffers.push(inputChannelCopy);\\n }\\n }\\n\\n this.recordedSamples += this.bufferSize;\\n }\\n\\n return true;\\n }\\n }, {\\n key: \\\"record\\\",\\n value: function record(duration) {\\n if (duration) {\\n this.sampleLimit = Math.round(duration * sampleRate);\\n }\\n\\n this.recording = true;\\n }\\n }, {\\n key: \\\"stop\\\",\\n value: function stop() {\\n this.recording = false;\\n var buffers = this.getBuffers();\\n var leftBuffer = buffers[0].buffer;\\n var rightBuffer = buffers[1].buffer;\\n this.port.postMessage({\\n name: 'buffers',\\n leftBuffer: leftBuffer,\\n rightBuffer: rightBuffer\\n }, [leftBuffer, rightBuffer]);\\n this.clear();\\n }\\n }, {\\n key: \\\"getBuffers\\\",\\n value: function getBuffers() {\\n var buffers = [];\\n buffers.push(this.mergeBuffers(this.leftBuffers));\\n buffers.push(this.mergeBuffers(this.rightBuffers));\\n return buffers;\\n }\\n }, {\\n key: \\\"mergeBuffers\\\",\\n value: function mergeBuffers(channelBuffer) {\\n var result = new Float32Array(this.recordedSamples);\\n var offset = 0;\\n var lng = channelBuffer.length;\\n\\n for (var i = 0; i < lng; i++) {\\n var buffer = channelBuffer[i];\\n result.set(buffer, offset);\\n offset += buffer.length;\\n }\\n\\n return result;\\n }\\n }, {\\n key: \\\"clear\\\",\\n value: function clear() {\\n var _this2 = this;\\n\\n this.leftBuffers = [];\\n this.rightBuffers = [];\\n this.inputRingBuffer = new RingBuffer(this.bufferSize, this.numInputChannels);\\n this.inputRingBufferArraySequence = new Array(this.numInputChannels).fill(null).map(function () {\\n return new Float32Array(_this2.bufferSize);\\n });\\n this.recordedSamples = 0;\\n this.sampleLimit = null;\\n }\\n }]);\\n\\n return RecorderProcessor;\\n}(_wrapNativeSuper(AudioWorkletProcessor));\\n\\nregisterProcessor(processorNames.recorderProcessor, RecorderProcessor);\"","export default \"function _typeof(obj) { if (typeof Symbol === \\\"function\\\" && typeof Symbol.iterator === \\\"symbol\\\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \\\"function\\\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \\\"symbol\\\" : typeof obj; }; } return _typeof(obj); }\\n\\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \\\"object\\\" || typeof call === \\\"function\\\")) { return call; } return _assertThisInitialized(self); }\\n\\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\\\"this hasn't been initialised - super() hasn't been called\\\"); } return self; }\\n\\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \\\"function\\\" && superClass !== null) { throw new TypeError(\\\"Super expression must either be null or a function\\\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }\\n\\nfunction _wrapNativeSuper(Class) { var _cache = typeof Map === \\\"function\\\" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== \\\"function\\\") { throw new TypeError(\\\"Super expression must either be null or a function\\\"); } if (typeof _cache !== \\\"undefined\\\") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }\\n\\nfunction isNativeReflectConstruct() { if (typeof Reflect === \\\"undefined\\\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \\\"function\\\") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\\n\\nfunction _construct(Parent, args, Class) { if (isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }\\n\\nfunction _isNativeFunction(fn) { return Function.toString.call(fn).indexOf(\\\"[native code]\\\") !== -1; }\\n\\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\\n\\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\\n\\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\\\"Cannot call a class as a function\\\"); } }\\n\\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\\\"value\\\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\\n\\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\\n\\n// import dependencies via preval.require so that they're available as values at compile time\\nvar processorNames = {\\n \\\"recorderProcessor\\\": \\\"recorder-processor\\\",\\n \\\"soundFileProcessor\\\": \\\"sound-file-processor\\\",\\n \\\"amplitudeProcessor\\\": \\\"amplitude-processor\\\"\\n};\\nvar RingBuffer = {\\n \\\"default\\\":\\n /*#__PURE__*/\\n function () {\\n /**\\n * @constructor\\n * @param {number} length Buffer length in frames.\\n * @param {number} channelCount Buffer channel count.\\n */\\n function RingBuffer(length, channelCount) {\\n _classCallCheck(this, RingBuffer);\\n\\n this._readIndex = 0;\\n this._writeIndex = 0;\\n this._framesAvailable = 0;\\n this._channelCount = channelCount;\\n this._length = length;\\n this._channelData = [];\\n\\n for (var i = 0; i < this._channelCount; ++i) {\\n this._channelData[i] = new Float32Array(length);\\n }\\n }\\n /**\\n * Getter for Available frames in buffer.\\n *\\n * @return {number} Available frames in buffer.\\n */\\n\\n\\n _createClass(RingBuffer, [{\\n key: \\\"push\\\",\\n\\n /**\\n * Push a sequence of Float32Arrays to buffer.\\n *\\n * @param {array} arraySequence A sequence of Float32Arrays.\\n */\\n value: function push(arraySequence) {\\n // The channel count of arraySequence and the length of each channel must\\n // match with this buffer obejct.\\n // Transfer data from the |arraySequence| storage to the internal buffer.\\n var sourceLength = arraySequence[0].length;\\n\\n for (var i = 0; i < sourceLength; ++i) {\\n var writeIndex = (this._writeIndex + i) % this._length;\\n\\n for (var channel = 0; channel < this._channelCount; ++channel) {\\n this._channelData[channel][writeIndex] = arraySequence[channel][i];\\n }\\n }\\n\\n this._writeIndex += sourceLength;\\n\\n if (this._writeIndex >= this._length) {\\n this._writeIndex = 0;\\n } // For excessive frames, the buffer will be overwritten.\\n\\n\\n this._framesAvailable += sourceLength;\\n\\n if (this._framesAvailable > this._length) {\\n this._framesAvailable = this._length;\\n }\\n }\\n /**\\n * Pull data out of buffer and fill a given sequence of Float32Arrays.\\n *\\n * @param {array} arraySequence An array of Float32Arrays.\\n */\\n\\n }, {\\n key: \\\"pull\\\",\\n value: function pull(arraySequence) {\\n // The channel count of arraySequence and the length of each channel must\\n // match with this buffer obejct.\\n // If the FIFO is completely empty, do nothing.\\n if (this._framesAvailable === 0) {\\n return;\\n }\\n\\n var destinationLength = arraySequence[0].length; // Transfer data from the internal buffer to the |arraySequence| storage.\\n\\n for (var i = 0; i < destinationLength; ++i) {\\n var readIndex = (this._readIndex + i) % this._length;\\n\\n for (var channel = 0; channel < this._channelCount; ++channel) {\\n arraySequence[channel][i] = this._channelData[channel][readIndex];\\n }\\n }\\n\\n this._readIndex += destinationLength;\\n\\n if (this._readIndex >= this._length) {\\n this._readIndex = 0;\\n }\\n\\n this._framesAvailable -= destinationLength;\\n\\n if (this._framesAvailable < 0) {\\n this._framesAvailable = 0;\\n }\\n }\\n }, {\\n key: \\\"framesAvailable\\\",\\n get: function get() {\\n return this._framesAvailable;\\n }\\n }]);\\n\\n return RingBuffer;\\n }()\\n}[\\\"default\\\"];\\n\\nvar SoundFileProcessor =\\n/*#__PURE__*/\\nfunction (_AudioWorkletProcesso) {\\n _inherits(SoundFileProcessor, _AudioWorkletProcesso);\\n\\n function SoundFileProcessor(options) {\\n var _this;\\n\\n _classCallCheck(this, SoundFileProcessor);\\n\\n _this = _possibleConstructorReturn(this, _getPrototypeOf(SoundFileProcessor).call(this));\\n var processorOptions = options.processorOptions || {};\\n _this.bufferSize = processorOptions.bufferSize || 256;\\n _this.inputRingBuffer = new RingBuffer(_this.bufferSize, 1);\\n _this.inputRingBufferArraySequence = [new Float32Array(_this.bufferSize)];\\n return _this;\\n }\\n\\n _createClass(SoundFileProcessor, [{\\n key: \\\"process\\\",\\n value: function process(inputs) {\\n var input = inputs[0]; // we only care about the first input channel, because that contains the position data\\n\\n this.inputRingBuffer.push([input[0]]);\\n\\n if (this.inputRingBuffer.framesAvailable >= this.bufferSize) {\\n this.inputRingBuffer.pull(this.inputRingBufferArraySequence);\\n var inputChannel = this.inputRingBufferArraySequence[0];\\n var position = inputChannel[inputChannel.length - 1] || 0;\\n this.port.postMessage({\\n name: 'position',\\n position: position\\n });\\n }\\n\\n return true;\\n }\\n }]);\\n\\n return SoundFileProcessor;\\n}(_wrapNativeSuper(AudioWorkletProcessor));\\n\\nregisterProcessor(processorNames.soundFileProcessor, SoundFileProcessor);\"","export default \"function _typeof(obj) { if (typeof Symbol === \\\"function\\\" && typeof Symbol.iterator === \\\"symbol\\\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \\\"function\\\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \\\"symbol\\\" : typeof obj; }; } return _typeof(obj); }\\n\\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \\\"object\\\" || typeof call === \\\"function\\\")) { return call; } return _assertThisInitialized(self); }\\n\\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\\\"this hasn't been initialised - super() hasn't been called\\\"); } return self; }\\n\\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \\\"function\\\" && superClass !== null) { throw new TypeError(\\\"Super expression must either be null or a function\\\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }\\n\\nfunction _wrapNativeSuper(Class) { var _cache = typeof Map === \\\"function\\\" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== \\\"function\\\") { throw new TypeError(\\\"Super expression must either be null or a function\\\"); } if (typeof _cache !== \\\"undefined\\\") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }\\n\\nfunction isNativeReflectConstruct() { if (typeof Reflect === \\\"undefined\\\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \\\"function\\\") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\\n\\nfunction _construct(Parent, args, Class) { if (isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }\\n\\nfunction _isNativeFunction(fn) { return Function.toString.call(fn).indexOf(\\\"[native code]\\\") !== -1; }\\n\\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\\n\\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\\n\\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\\\"Cannot call a class as a function\\\"); } }\\n\\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\\\"value\\\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\\n\\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\\n\\n// import dependencies via preval.require so that they're available as values at compile time\\nvar processorNames = {\\n \\\"recorderProcessor\\\": \\\"recorder-processor\\\",\\n \\\"soundFileProcessor\\\": \\\"sound-file-processor\\\",\\n \\\"amplitudeProcessor\\\": \\\"amplitude-processor\\\"\\n};\\nvar RingBuffer = {\\n \\\"default\\\":\\n /*#__PURE__*/\\n function () {\\n /**\\n * @constructor\\n * @param {number} length Buffer length in frames.\\n * @param {number} channelCount Buffer channel count.\\n */\\n function RingBuffer(length, channelCount) {\\n _classCallCheck(this, RingBuffer);\\n\\n this._readIndex = 0;\\n this._writeIndex = 0;\\n this._framesAvailable = 0;\\n this._channelCount = channelCount;\\n this._length = length;\\n this._channelData = [];\\n\\n for (var i = 0; i < this._channelCount; ++i) {\\n this._channelData[i] = new Float32Array(length);\\n }\\n }\\n /**\\n * Getter for Available frames in buffer.\\n *\\n * @return {number} Available frames in buffer.\\n */\\n\\n\\n _createClass(RingBuffer, [{\\n key: \\\"push\\\",\\n\\n /**\\n * Push a sequence of Float32Arrays to buffer.\\n *\\n * @param {array} arraySequence A sequence of Float32Arrays.\\n */\\n value: function push(arraySequence) {\\n // The channel count of arraySequence and the length of each channel must\\n // match with this buffer obejct.\\n // Transfer data from the |arraySequence| storage to the internal buffer.\\n var sourceLength = arraySequence[0].length;\\n\\n for (var i = 0; i < sourceLength; ++i) {\\n var writeIndex = (this._writeIndex + i) % this._length;\\n\\n for (var channel = 0; channel < this._channelCount; ++channel) {\\n this._channelData[channel][writeIndex] = arraySequence[channel][i];\\n }\\n }\\n\\n this._writeIndex += sourceLength;\\n\\n if (this._writeIndex >= this._length) {\\n this._writeIndex = 0;\\n } // For excessive frames, the buffer will be overwritten.\\n\\n\\n this._framesAvailable += sourceLength;\\n\\n if (this._framesAvailable > this._length) {\\n this._framesAvailable = this._length;\\n }\\n }\\n /**\\n * Pull data out of buffer and fill a given sequence of Float32Arrays.\\n *\\n * @param {array} arraySequence An array of Float32Arrays.\\n */\\n\\n }, {\\n key: \\\"pull\\\",\\n value: function pull(arraySequence) {\\n // The channel count of arraySequence and the length of each channel must\\n // match with this buffer obejct.\\n // If the FIFO is completely empty, do nothing.\\n if (this._framesAvailable === 0) {\\n return;\\n }\\n\\n var destinationLength = arraySequence[0].length; // Transfer data from the internal buffer to the |arraySequence| storage.\\n\\n for (var i = 0; i < destinationLength; ++i) {\\n var readIndex = (this._readIndex + i) % this._length;\\n\\n for (var channel = 0; channel < this._channelCount; ++channel) {\\n arraySequence[channel][i] = this._channelData[channel][readIndex];\\n }\\n }\\n\\n this._readIndex += destinationLength;\\n\\n if (this._readIndex >= this._length) {\\n this._readIndex = 0;\\n }\\n\\n this._framesAvailable -= destinationLength;\\n\\n if (this._framesAvailable < 0) {\\n this._framesAvailable = 0;\\n }\\n }\\n }, {\\n key: \\\"framesAvailable\\\",\\n get: function get() {\\n return this._framesAvailable;\\n }\\n }]);\\n\\n return RingBuffer;\\n }()\\n}[\\\"default\\\"];\\n\\nvar AmplitudeProcessor =\\n/*#__PURE__*/\\nfunction (_AudioWorkletProcesso) {\\n _inherits(AmplitudeProcessor, _AudioWorkletProcesso);\\n\\n function AmplitudeProcessor(options) {\\n var _this;\\n\\n _classCallCheck(this, AmplitudeProcessor);\\n\\n _this = _possibleConstructorReturn(this, _getPrototypeOf(AmplitudeProcessor).call(this));\\n var processorOptions = options.processorOptions || {};\\n _this.numOutputChannels = options.outputChannelCount || 1;\\n _this.numInputChannels = processorOptions.numInputChannels || 2;\\n _this.normalize = processorOptions.normalize || false;\\n _this.smoothing = processorOptions.smoothing || 0;\\n _this.bufferSize = processorOptions.bufferSize || 2048;\\n _this.inputRingBuffer = new RingBuffer(_this.bufferSize, _this.numInputChannels);\\n _this.outputRingBuffer = new RingBuffer(_this.bufferSize, _this.numOutputChannels);\\n _this.inputRingBufferArraySequence = new Array(_this.numInputChannels).fill(null).map(function () {\\n return new Float32Array(_this.bufferSize);\\n });\\n _this.stereoVol = [0, 0];\\n _this.stereoVolNorm = [0, 0];\\n _this.volMax = 0.001;\\n\\n _this.port.onmessage = function (event) {\\n var data = event.data;\\n\\n if (data.name === 'toggleNormalize') {\\n _this.normalize = data.normalize;\\n } else if (data.name === 'smoothing') {\\n _this.smoothing = Math.max(0, Math.min(1, data.smoothing));\\n }\\n };\\n\\n return _this;\\n } // TO DO make this stereo / dependent on # of audio channels\\n\\n\\n _createClass(AmplitudeProcessor, [{\\n key: \\\"process\\\",\\n value: function process(inputs, outputs) {\\n var input = inputs[0];\\n var output = outputs[0];\\n var smoothing = this.smoothing;\\n this.inputRingBuffer.push(input);\\n\\n if (this.inputRingBuffer.framesAvailable >= this.bufferSize) {\\n this.inputRingBuffer.pull(this.inputRingBufferArraySequence);\\n\\n for (var channel = 0; channel < this.numInputChannels; ++channel) {\\n var inputBuffer = this.inputRingBufferArraySequence[channel];\\n var bufLength = inputBuffer.length;\\n var sum = 0;\\n\\n for (var i = 0; i < bufLength; i++) {\\n var x = inputBuffer[i];\\n\\n if (this.normalize) {\\n sum += Math.max(Math.min(x / this.volMax, 1), -1) * Math.max(Math.min(x / this.volMax, 1), -1);\\n } else {\\n sum += x * x;\\n }\\n } // ... then take the square root of the sum.\\n\\n\\n var rms = Math.sqrt(sum / bufLength);\\n this.stereoVol[channel] = Math.max(rms, this.stereoVol[channel] * smoothing);\\n this.volMax = Math.max(this.stereoVol[channel], this.volMax);\\n } // calculate stero normalized volume and add volume from all channels together\\n\\n\\n var volSum = 0;\\n\\n for (var index = 0; index < this.stereoVol.length; index++) {\\n this.stereoVolNorm[index] = Math.max(Math.min(this.stereoVol[index] / this.volMax, 1), 0);\\n volSum += this.stereoVol[index];\\n } // volume is average of channels\\n\\n\\n var volume = volSum / this.stereoVol.length; // normalized value\\n\\n var volNorm = Math.max(Math.min(volume / this.volMax, 1), 0);\\n this.port.postMessage({\\n name: 'amplitude',\\n volume: volume,\\n volNorm: volNorm,\\n stereoVol: this.stereoVol,\\n stereoVolNorm: this.stereoVolNorm\\n }); // pass input through to output\\n\\n this.outputRingBuffer.push(this.inputRingBufferArraySequence);\\n } // pull 128 frames out of the ring buffer\\n // if the ring buffer does not have enough frames, the output will be silent\\n\\n\\n this.outputRingBuffer.pull(output);\\n return true;\\n }\\n }]);\\n\\n return AmplitudeProcessor;\\n}(_wrapNativeSuper(AudioWorkletProcessor));\\n\\nregisterProcessor(processorNames.amplitudeProcessor, AmplitudeProcessor);\"","'use strict';\n\ndefine(function (require) {\n\n var p5sound = require('master');\n var ac = p5sound.audiocontext;\n\n // Stereo panner\n // if there is a stereo panner node use it\n if(typeof ac.createStereoPanner !== 'undefined') {\n p5.Panner = function (input, output) {\n this.stereoPanner = this.input = ac.createStereoPanner();\n input.connect(this.stereoPanner);\n this.stereoPanner.connect(output);\n };\n\n p5.Panner.prototype.pan = function(val, tFromNow) {\n var time = tFromNow || 0;\n var t = ac.currentTime + time;\n\n this.stereoPanner.pan.linearRampToValueAtTime(val, t);\n };\n\n //not implemented because stereopanner\n //node does not require this and will automatically\n //convert single channel or multichannel to stereo.\n //tested with single and stereo, not with (>2) multichannel\n p5.Panner.prototype.inputChannels = function() {};\n\n p5.Panner.prototype.connect = function(obj) {\n this.stereoPanner.connect(obj);\n };\n\n p5.Panner.prototype.disconnect = function() {\n if (this.stereoPanner) {\n this.stereoPanner.disconnect();\n }\n };\n\n } else {\n // if there is no createStereoPanner object\n // such as in safari 7.1.7 at the time of writing this\n // use this method to create the effect\n p5.Panner = function(input, output, numInputChannels) {\n this.input = ac.createGain();\n input.connect(this.input);\n\n this.left = ac.createGain();\n this.right = ac.createGain();\n this.left.channelInterpretation = 'discrete';\n this.right.channelInterpretation = 'discrete';\n\n // if input is stereo\n if (numInputChannels > 1) {\n this.splitter = ac.createChannelSplitter(2);\n this.input.connect(this.splitter);\n\n this.splitter.connect(this.left, 1);\n this.splitter.connect(this.right, 0);\n }\n else {\n this.input.connect(this.left);\n this.input.connect(this.right);\n }\n\n this.output = ac.createChannelMerger(2);\n this.left.connect(this.output, 0, 1);\n this.right.connect(this.output, 0, 0);\n this.output.connect(output);\n };\n\n // -1 is left, +1 is right\n p5.Panner.prototype.pan = function(val, tFromNow) {\n var time = tFromNow || 0;\n var t = ac.currentTime + time;\n var v = (val + 1) / 2;\n var rightVal = Math.cos(v*Math.PI/2);\n var leftVal = Math.sin(v * Math.PI/2);\n this.left.gain.linearRampToValueAtTime(leftVal, t);\n this.right.gain.linearRampToValueAtTime(rightVal, t);\n };\n\n p5.Panner.prototype.inputChannels = function(numChannels) {\n if (numChannels === 1) {\n this.input.disconnect();\n this.input.connect(this.left);\n this.input.connect(this.right);\n } else if (numChannels === 2) {\n if (typeof(this.splitter === 'undefined')) {\n this.splitter = ac.createChannelSplitter(2);\n }\n this.input.disconnect();\n this.input.connect(this.splitter);\n this.splitter.connect(this.left, 1);\n this.splitter.connect(this.right, 0);\n }\n };\n\n p5.Panner.prototype.connect = function(obj) {\n this.output.connect(obj);\n };\n\n p5.Panner.prototype.disconnect = function() {\n if (this.output) {\n this.output.disconnect();\n }\n };\n }\n});\n","'use strict';\n\ndefine(function (require) {\n\n const CustomError = require('errorHandler');\n const p5sound = require('master');\n const ac = p5sound.audiocontext;\n const { midiToFreq, convertToWav, safeBufferSize } = require('helpers');\n var processorNames = require('./audioWorklet/processorNames');\n\n /**\n *

SoundFile object with a path to a file.

\n *\n *

The p5.SoundFile may not be available immediately because\n * it loads the file information asynchronously.

\n *\n *

To do something with the sound as soon as it loads\n * pass the name of a function as the second parameter.

\n *\n *

Only one file path is required. However, audio file formats\n * (i.e. mp3, ogg, wav and m4a/aac) are not supported by all\n * web browsers. If you want to ensure compatability, instead of a single\n * file path, you may include an Array of filepaths, and the browser will\n * choose a format that works.

\n *\n * @class p5.SoundFile\n * @constructor\n * @param {String|Array} path path to a sound file (String). Optionally,\n * you may include multiple file formats in\n * an array. Alternately, accepts an object\n * from the HTML5 File API, or a p5.File.\n * @param {Function} [successCallback] Name of a function to call once file loads\n * @param {Function} [errorCallback] Name of a function to call if file fails to\n * load. This function will receive an error or\n * XMLHttpRequest object with information\n * about what went wrong.\n * @param {Function} [whileLoadingCallback] Name of a function to call while file\n * is loading. That function will\n * receive progress of the request to\n * load the sound file\n * (between 0 and 1) as its first\n * parameter. This progress\n * does not account for the additional\n * time needed to decode the audio data.\n *\n * @example\n *
\n * let mySound;\n * function preload() {\n * soundFormats('mp3', 'ogg');\n * mySound = loadSound('assets/doorbell');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * text('tap here to play', 10, 20);\n * }\n *\n * function canvasPressed() {\n * // playing a sound file on a user gesture\n * // is equivalent to `userStartAudio()`\n * mySound.play();\n * }\n *
\n */\n p5.SoundFile = function(paths, onload, onerror, whileLoading) {\n if (typeof paths !== 'undefined') {\n if (typeof paths === 'string' || typeof paths[0] === 'string') {\n var path = p5.prototype._checkFileFormats(paths);\n this.url = path;\n }\n else if(typeof paths === 'object') {\n if (!(window.File && window.FileReader && window.FileList && window.Blob)) {\n // The File API isn't supported in this browser\n throw 'Unable to load file because the File API is not supported';\n }\n }\n\n // if type is a p5.File...get the actual file\n if (paths.file) {\n paths = paths.file;\n }\n\n this.file = paths;\n }\n\n // private _onended callback, set by the method: onended(callback)\n this._onended = function() {};\n\n this._looping = false;\n this._playing = false;\n this._paused = false;\n this._pauseTime = 0;\n\n // cues for scheduling events with addCue() removeCue()\n this._cues = [];\n this._cueIDCounter = 0;\n\n // position of the most recently played sample\n this._lastPos = 0;\n this._counterNode = null;\n this._workletNode = null;\n\n // array of sources so that they can all be stopped!\n this.bufferSourceNodes = [];\n\n // current source\n this.bufferSourceNode = null;\n\n this.buffer = null;\n this.playbackRate = 1;\n\n this.input = p5sound.audiocontext.createGain();\n this.output = p5sound.audiocontext.createGain();\n\n this.reversed = false;\n\n // start and end of playback / loop\n this.startTime = 0;\n this.endTime = null;\n this.pauseTime = 0;\n\n // \"restart\" would stop playback before retriggering\n this.mode = 'sustain';\n\n // time that playback was started, in millis\n this.startMillis = null;\n\n // stereo panning\n this.panPosition = 0.0;\n this.panner = new p5.Panner(this.output, p5sound.input, 2);\n\n // it is possible to instantiate a soundfile with no path\n if (this.url || this.file) {\n this.load(onload, onerror);\n }\n\n // add this p5.SoundFile to the soundArray\n p5sound.soundArray.push(this);\n\n if (typeof whileLoading === 'function') {\n this._whileLoading = whileLoading;\n } else {\n this._whileLoading = function() {};\n }\n\n this._clearOnEnd = _clearOnEnd.bind(this);\n };\n\n // register preload handling of loadSound\n p5.prototype.registerPreloadMethod('loadSound', p5.prototype);\n\n /**\n * loadSound() returns a new p5.SoundFile from a specified\n * path. If called during preload(), the p5.SoundFile will be ready\n * to play in time for setup() and draw(). If called outside of\n * preload, the p5.SoundFile will not be ready immediately, so\n * loadSound accepts a callback as the second parameter. Using a\n * \n * local server is recommended when loading external files.\n *\n * @method loadSound\n * @for p5\n * @param {String|Array} path Path to the sound file, or an array with\n * paths to soundfiles in multiple formats\n * i.e. ['sound.ogg', 'sound.mp3'].\n * Alternately, accepts an object: either\n * from the HTML5 File API, or a p5.File.\n * @param {Function} [successCallback] Name of a function to call once file loads\n * @param {Function} [errorCallback] Name of a function to call if there is\n * an error loading the file.\n * @param {Function} [whileLoading] Name of a function to call while file is loading.\n * This function will receive the percentage loaded\n * so far, from 0.0 to 1.0.\n * @return {SoundFile} Returns a p5.SoundFile\n * @example\n *
\n * let mySound;\n * function preload() {\n * soundFormats('mp3', 'ogg');\n * mySound = loadSound('assets/doorbell');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * text('tap here to play', 10, 20);\n * }\n *\n * function canvasPressed() {\n * // playing a sound file on a user gesture\n * // is equivalent to `userStartAudio()`\n * mySound.play();\n * }\n *
\n */\n p5.prototype.loadSound = function(path, callback, onerror, whileLoading) {\n // if loading locally without a server\n if (window.location.origin.indexOf('file://') > -1 && window.cordova === 'undefined' ) {\n window.alert('This sketch may require a server to load external files. Please see http://bit.ly/1qcInwS');\n }\n\n var self = this;\n var s = new p5.SoundFile(path, function() {\n if(typeof callback === 'function') {\n callback.apply(self, arguments);\n }\n\n if (typeof self._decrementPreload === 'function') {\n self._decrementPreload();\n }\n }, onerror, whileLoading);\n\n return s;\n };\n\n /**\n * This is a helper function that the p5.SoundFile calls to load\n * itself. Accepts a callback (the name of another function)\n * as an optional parameter.\n *\n * @private\n * @for p5.SoundFile\n * @param {Function} [successCallback] Name of a function to call once file loads\n * @param {Function} [errorCallback] Name of a function to call if there is an error\n */\n p5.SoundFile.prototype.load = function(callback, errorCallback) {\n var self = this;\n var errorTrace = new Error().stack;\n\n if (this.url !== undefined && this.url !== '') {\n var request = new XMLHttpRequest();\n request.addEventListener('progress', function(evt) {\n self._updateProgress(evt);\n }, false);\n request.open('GET', this.url, true);\n request.responseType = 'arraybuffer';\n\n request.onload = function() {\n if (request.status === 200) {\n // on sucess loading file:\n if (!self.panner) return;\n ac.decodeAudioData(request.response,\n // success decoding buffer:\n function(buff) {\n if (!self.panner) return;\n self.buffer = buff;\n self.panner.inputChannels(buff.numberOfChannels);\n if (callback) {\n callback(self);\n }\n },\n // error decoding buffer. \"e\" is undefined in Chrome 11/22/2015\n function() {\n if (!self.panner) return;\n var err = new CustomError('decodeAudioData', errorTrace, self.url);\n var msg = 'AudioContext error at decodeAudioData for ' + self.url;\n if (errorCallback) {\n err.msg = msg;\n errorCallback(err);\n } else {\n console.error(msg +'\\n The error stack trace includes: \\n' + err.stack);\n }\n }\n );\n }\n // if request status != 200, it failed\n else {\n if (!self.panner) return;\n var err = new CustomError('loadSound', errorTrace, self.url);\n var msg = 'Unable to load ' + self.url + '. The request status was: ' +\n request.status + ' (' + request.statusText + ')';\n\n if (errorCallback) {\n err.message = msg;\n errorCallback(err);\n } else {\n console.error(msg +'\\n The error stack trace includes: \\n' + err.stack);\n }\n }\n };\n\n // if there is another error, aside from 404...\n request.onerror = function() {\n var err = new CustomError('loadSound', errorTrace, self.url);\n var msg = 'There was no response from the server at ' + self.url + '. Check the url and internet connectivity.';\n\n if (errorCallback) {\n err.message = msg;\n errorCallback(err);\n } else {\n console.error(msg +'\\n The error stack trace includes: \\n' + err.stack);\n }\n };\n\n request.send();\n }\n else if (this.file !== undefined) {\n var reader = new FileReader();\n reader.onload = function() {\n if (!self.panner) return;\n ac.decodeAudioData(reader.result, function(buff) {\n if (!self.panner) return;\n self.buffer = buff;\n self.panner.inputChannels(buff.numberOfChannels);\n if (callback) {\n callback(self);\n }\n });\n };\n reader.onerror = function(e) {\n if (!self.panner) return;\n if (onerror) {\n onerror(e);\n }\n };\n reader.readAsArrayBuffer(this.file);\n }\n };\n\n // TO DO: use this method to create a loading bar that shows progress during file upload/decode.\n p5.SoundFile.prototype._updateProgress = function(evt) {\n if (evt.lengthComputable) {\n var percentComplete = evt.loaded / evt.total * 0.99;\n this._whileLoading(percentComplete, evt);\n // ...\n } else {\n // Unable to compute progress information since the total size is unknown\n this._whileLoading('size unknown');\n }\n };\n\n /**\n * Returns true if the sound file finished loading successfully.\n *\n * @method isLoaded\n * @for p5.SoundFile\n * @return {Boolean}\n */\n p5.SoundFile.prototype.isLoaded = function() {\n if (this.buffer) {\n return true;\n } else {\n return false;\n }\n };\n\n /**\n * Play the p5.SoundFile\n *\n * @method play\n * @for p5.SoundFile\n * @param {Number} [startTime] (optional) schedule playback to start (in seconds from now).\n * @param {Number} [rate] (optional) playback rate\n * @param {Number} [amp] (optional) amplitude (volume)\n * of playback\n * @param {Number} [cueStart] (optional) cue start time in seconds\n * @param {Number} [duration] (optional) duration of playback in seconds\n */\n p5.SoundFile.prototype.play = function(startTime, rate, amp, _cueStart, duration) {\n if (!this.output) {\n console.warn('SoundFile.play() called after dispose');\n return;\n }\n\n var now = p5sound.audiocontext.currentTime;\n var cueStart, cueEnd;\n var time = startTime || 0;\n if (time < 0) {\n time = 0;\n }\n\n time = time + now;\n\n if (typeof rate !== 'undefined') {\n this.rate(rate);\n }\n\n if (typeof amp !== 'undefined') {\n this.setVolume(amp);\n }\n\n // TO DO: if already playing, create array of buffers for easy stop()\n if (this.buffer) {\n // reset the pause time (if it was paused)\n this._pauseTime = 0;\n\n // handle restart playmode\n if (this.mode === 'restart' && this.buffer && this.bufferSourceNode) {\n this.bufferSourceNode.stop(time);\n this._counterNode.stop(time);\n }\n\n //dont create another instance if already playing\n if (this.mode === 'untildone' && this.isPlaying()) {\n return;\n }\n // make a new source and counter. They are automatically assigned playbackRate and buffer\n this.bufferSourceNode = this._initSourceNode();\n\n // garbage collect counterNode and create a new one\n delete this._counterNode;\n this._counterNode = this._initCounterNode();\n\n if (_cueStart) {\n if (_cueStart >=0 && _cueStart < this.buffer.duration) {\n // this.startTime = cueStart;\n cueStart = _cueStart;\n } else { throw 'start time out of range'; }\n } else {\n cueStart = 0;\n }\n\n if (duration) {\n // if duration is greater than buffer.duration, just play entire file anyway rather than throw an error\n duration = duration <= this.buffer.duration - cueStart ? duration : this.buffer.duration;\n }\n\n // if it was paused, play at the pause position\n if (this._paused) {\n this.bufferSourceNode.start(time, this.pauseTime, duration);\n this._counterNode.start(time, this.pauseTime, duration);\n } else {\n this.bufferSourceNode.start(time, cueStart, duration);\n this._counterNode.start(time, cueStart, duration);\n }\n\n this._playing = true;\n this._paused = false;\n\n // add source to sources array, which is used in stopAll()\n this.bufferSourceNodes.push(this.bufferSourceNode);\n this.bufferSourceNode._arrayIndex = this.bufferSourceNodes.length - 1;\n\n this.bufferSourceNode.addEventListener('ended', this._clearOnEnd);\n }\n // If soundFile hasn't loaded the buffer yet, throw an error\n else {\n throw 'not ready to play file, buffer has yet to load. Try preload()';\n }\n\n // if looping, will restart at original time\n this.bufferSourceNode.loop = this._looping;\n this._counterNode.loop = this._looping;\n\n if (this._looping === true) {\n cueEnd = duration ? duration : cueStart - 0.000000000000001;\n this.bufferSourceNode.loopStart = cueStart;\n this.bufferSourceNode.loopEnd = cueEnd;\n this._counterNode.loopStart = cueStart;\n this._counterNode.loopEnd = cueEnd;\n }\n\n };\n\n\n /**\n * p5.SoundFile has two play modes: restart and\n * sustain. Play Mode determines what happens to a\n * p5.SoundFile if it is triggered while in the middle of playback.\n * In sustain mode, playback will continue simultaneous to the\n * new playback. In restart mode, play() will stop playback\n * and start over. With untilDone, a sound will play only if it's\n * not already playing. Sustain is the default mode.\n *\n * @method playMode\n * @for p5.SoundFile\n * @param {String} str 'restart' or 'sustain' or 'untilDone'\n * @example\n *
\n * let mySound;\n * function preload(){\n * mySound = loadSound('assets/Damscray_DancingTiger.mp3');\n * }\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * noFill();\n * rect(0, height/2, width - 1, height/2 - 1);\n * rect(0, 0, width - 1, height/2);\n * textAlign(CENTER, CENTER);\n * fill(20);\n * text('restart', width/2, 1 * height/4);\n * text('sustain', width/2, 3 * height/4);\n * }\n * function canvasPressed() {\n * if (mouseX < height/2) {\n * mySound.playMode('restart');\n * } else {\n * mySound.playMode('sustain');\n * }\n * mySound.play();\n * }\n *\n *
\n */\n p5.SoundFile.prototype.playMode = function(str) {\n var s = str.toLowerCase();\n\n // if restart, stop all other sounds from playing\n if (s === 'restart' && this.buffer && this.bufferSourceNode) {\n for (var i = 0; i < this.bufferSourceNodes.length - 1; i++) {\n var now = p5sound.audiocontext.currentTime;\n this.bufferSourceNodes[i].stop(now);\n }\n }\n\n // set play mode to effect future playback\n if (s === 'restart' || s === 'sustain' || s === 'untildone') {\n this.mode = s;\n } else {\n throw 'Invalid play mode. Must be either \"restart\" or \"sustain\"';\n }\n };\n\n /**\n * Pauses a file that is currently playing. If the file is not\n * playing, then nothing will happen.\n *\n * After pausing, .play() will resume from the paused\n * position.\n * If p5.SoundFile had been set to loop before it was paused,\n * it will continue to loop after it is unpaused with .play().\n *\n * @method pause\n * @for p5.SoundFile\n * @param {Number} [startTime] (optional) schedule event to occur\n * seconds from now\n * @example\n *
\n * let soundFile;\n * function preload() {\n * soundFormats('ogg', 'mp3');\n * soundFile = loadSound('assets/Damscray_-_Dancing_Tiger_02.mp3');\n * }\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * text('tap to play, release to pause', 10, 20, width - 20);\n * }\n * function canvasPressed() {\n * soundFile.loop();\n * background(0, 200, 50);\n * }\n * function mouseReleased() {\n * soundFile.pause();\n * background(220);\n * }\n * \n *
\n */\n p5.SoundFile.prototype.pause = function(startTime) {\n var now = p5sound.audiocontext.currentTime;\n var time = startTime || 0;\n var pTime = time + now;\n\n if (this.isPlaying() && this.buffer && this.bufferSourceNode) {\n this._paused = true;\n this._playing = false;\n\n this.pauseTime = this.currentTime();\n this.bufferSourceNode.stop(pTime);\n this._counterNode.stop(pTime);\n\n this._pauseTime = this.currentTime();\n // TO DO: make sure play() still starts from orig start position\n } else {\n this._pauseTime = 0;\n }\n };\n\n /**\n * Loop the p5.SoundFile. Accepts optional parameters to set the\n * playback rate, playback volume, loopStart, loopEnd.\n *\n * @method loop\n * @for p5.SoundFile\n * @param {Number} [startTime] (optional) schedule event to occur\n * seconds from now\n * @param {Number} [rate] (optional) playback rate\n * @param {Number} [amp] (optional) playback volume\n * @param {Number} [cueLoopStart] (optional) startTime in seconds\n * @param {Number} [duration] (optional) loop duration in seconds\n * @example\n *
\n * let soundFile;\n * let loopStart = 0.5;\n * let loopDuration = 0.2;\n * function preload() {\n * soundFormats('ogg', 'mp3');\n * soundFile = loadSound('assets/Damscray_-_Dancing_Tiger_02.mp3');\n * }\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * text('tap to play, release to pause', 10, 20, width - 20);\n * }\n * function canvasPressed() {\n * soundFile.loop();\n * background(0, 200, 50);\n * }\n * function mouseReleased() {\n * soundFile.pause();\n * background(220);\n * }\n * \n *
\n */\n p5.SoundFile.prototype.loop = function(startTime, rate, amp, loopStart, duration) {\n this._looping = true;\n this.play(startTime, rate, amp, loopStart, duration);\n };\n\n /**\n * Set a p5.SoundFile's looping flag to true or false. If the sound\n * is currently playing, this change will take effect when it\n * reaches the end of the current playback.\n *\n * @method setLoop\n * @for p5.SoundFile\n * @param {Boolean} Boolean set looping to true or false\n */\n p5.SoundFile.prototype.setLoop = function(bool) {\n if (bool === true) {\n this._looping = true;\n }\n else if (bool === false) {\n this._looping = false;\n }\n else {\n throw 'Error: setLoop accepts either true or false';\n }\n if (this.bufferSourceNode) {\n this.bufferSourceNode.loop = this._looping;\n this._counterNode.loop = this._looping;\n }\n };\n\n /**\n * Returns 'true' if a p5.SoundFile is currently looping and playing, 'false' if not.\n *\n * @method isLooping\n * @for p5.SoundFile\n * @return {Boolean}\n */\n p5.SoundFile.prototype.isLooping = function() {\n if (!this.bufferSourceNode) {\n return false;\n }\n if (this._looping === true && this.isPlaying() === true) {\n return true;\n }\n return false;\n };\n\n /**\n * Returns true if a p5.SoundFile is playing, false if not (i.e.\n * paused or stopped).\n *\n * @method isPlaying\n * @for p5.SoundFile\n * @return {Boolean}\n */\n p5.SoundFile.prototype.isPlaying = function() {\n return this._playing;\n };\n\n /**\n * Returns true if a p5.SoundFile is paused, false if not (i.e.\n * playing or stopped).\n *\n * @method isPaused\n * @for p5.SoundFile\n * @return {Boolean}\n */\n p5.SoundFile.prototype.isPaused = function() {\n return this._paused;\n };\n\n /**\n * Stop soundfile playback.\n *\n * @method stop\n * @for p5.SoundFile\n * @param {Number} [startTime] (optional) schedule event to occur\n * in seconds from now\n */\n p5.SoundFile.prototype.stop = function(timeFromNow) {\n var time = timeFromNow || 0;\n\n if (this.mode === 'sustain' || this.mode === 'untildone') {\n this.stopAll(time);\n this._playing = false;\n this.pauseTime = 0;\n this._paused = false;\n }\n else if (this.buffer && this.bufferSourceNode) {\n var now = p5sound.audiocontext.currentTime;\n var t = time || 0;\n this.pauseTime = 0;\n this.bufferSourceNode.stop(now + t);\n this._counterNode.stop(now + t);\n this._playing = false;\n this._paused = false;\n }\n };\n\n /**\n * Stop playback on all of this soundfile's sources.\n * @private\n */\n p5.SoundFile.prototype.stopAll = function(_time) {\n var now = p5sound.audiocontext.currentTime;\n var time = _time || 0;\n if (this.buffer && this.bufferSourceNode) {\n for (var i in this.bufferSourceNodes) {\n const bufferSourceNode = this.bufferSourceNodes[i];\n if (!!bufferSourceNode) {\n try {\n bufferSourceNode.stop(now + time);\n } catch(e) {\n // this was throwing errors only on Safari\n }\n }\n }\n this._counterNode.stop(now + time);\n this._onended(this);\n }\n };\n\n /**\n * Multiply the output volume (amplitude) of a sound file\n * between 0.0 (silence) and 1.0 (full volume).\n * 1.0 is the maximum amplitude of a digital sound, so multiplying\n * by greater than 1.0 may cause digital distortion. To\n * fade, provide a rampTime parameter. For more\n * complex fades, see the Envelope class.\n *\n * Alternately, you can pass in a signal source such as an\n * oscillator to modulate the amplitude with an audio signal.\n *\n * @method setVolume\n * @for p5.SoundFile\n * @param {Number|Object} volume Volume (amplitude) between 0.0\n * and 1.0 or modulating signal/oscillator\n * @param {Number} [rampTime] Fade for t seconds\n * @param {Number} [timeFromNow] Schedule this event to happen at\n * t seconds in the future\n */\n p5.SoundFile.prototype.setVolume = function(vol, _rampTime, _tFromNow) {\n if (typeof vol === 'number') {\n var rampTime = _rampTime || 0;\n var tFromNow = _tFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n var currentVol = this.output.gain.value;\n this.output.gain.cancelScheduledValues(now + tFromNow);\n this.output.gain.linearRampToValueAtTime(currentVol, now + tFromNow);\n this.output.gain.linearRampToValueAtTime(vol, now + tFromNow + rampTime);\n }\n else if (vol) {\n vol.connect(this.output.gain);\n } else {\n // return the Gain Node\n return this.output.gain;\n }\n };\n\n // same as setVolume, to match Processing Sound\n p5.SoundFile.prototype.amp = p5.SoundFile.prototype.setVolume;\n\n // these are the same thing\n p5.SoundFile.prototype.fade = p5.SoundFile.prototype.setVolume;\n\n p5.SoundFile.prototype.getVolume = function() {\n return this.output.gain.value;\n };\n\n /**\n * Set the stereo panning of a p5.sound object to\n * a floating point number between -1.0 (left) and 1.0 (right).\n * Default is 0.0 (center).\n *\n * @method pan\n * @for p5.SoundFile\n * @param {Number} [panValue] Set the stereo panner\n * @param {Number} [timeFromNow] schedule this event to happen\n * seconds from now\n * @example\n *
\n * let ballX = 0;\n * let soundFile;\n *\n * function preload() {\n * soundFormats('ogg', 'mp3');\n * soundFile = loadSound('assets/beatbox.mp3');\n * }\n *\n * function draw() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * ballX = constrain(mouseX, 0, width);\n * ellipse(ballX, height/2, 20, 20);\n * }\n *\n * function canvasPressed(){\n * // map the ball's x location to a panning degree\n * // between -1.0 (left) and 1.0 (right)\n * let panning = map(ballX, 0., width,-1.0, 1.0);\n * soundFile.pan(panning);\n * soundFile.play();\n * }\n *
\n */\n p5.SoundFile.prototype.pan = function(pval, tFromNow) {\n this.panPosition = pval;\n this.panner.pan(pval, tFromNow);\n };\n\n /**\n * Returns the current stereo pan position (-1.0 to 1.0)\n *\n * @method getPan\n * @for p5.SoundFile\n * @return {Number} Returns the stereo pan setting of the Oscillator\n * as a number between -1.0 (left) and 1.0 (right).\n * 0.0 is center and default.\n */\n p5.SoundFile.prototype.getPan = function() {\n return this.panPosition;\n };\n\n /**\n * Set the playback rate of a sound file. Will change the speed and the pitch.\n * Values less than zero will reverse the audio buffer.\n *\n * @method rate\n * @for p5.SoundFile\n * @param {Number} [playbackRate] Set the playback rate. 1.0 is normal,\n * .5 is half-speed, 2.0 is twice as fast.\n * Values less than zero play backwards.\n * @example\n *
\n * let mySound;\n *\n * function preload() {\n * mySound = loadSound('assets/Damscray_DancingTiger.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * }\n * function canvasPressed() {\n * mySound.loop();\n * }\n * function mouseReleased() {\n * mySound.pause();\n * }\n * function draw() {\n * background(220);\n *\n * // Set the rate to a range between 0.1 and 4\n * // Changing the rate also alters the pitch\n * let playbackRate = map(mouseY, 0.1, height, 2, 0);\n * playbackRate = constrain(playbackRate, 0.01, 4);\n * mySound.rate(playbackRate);\n *\n * line(0, mouseY, width, mouseY);\n * text('rate: ' + round(playbackRate * 100) + '%', 10, 20);\n * }\n *\n * \n *
\n *\n */\n p5.SoundFile.prototype.rate = function(playbackRate) {\n var reverse = false;\n if (typeof playbackRate === 'undefined') {\n return this.playbackRate;\n }\n\n this.playbackRate = playbackRate;\n\n if (playbackRate === 0) {\n playbackRate = 0.0000000000001;\n }\n\n else if (playbackRate < 0 && !this.reversed) {\n playbackRate = Math.abs(playbackRate);\n reverse = true;\n }\n\n else if (playbackRate > 0 && this.reversed) {\n reverse = true;\n }\n\n if (this.bufferSourceNode) {\n var now = p5sound.audiocontext.currentTime;\n this.bufferSourceNode.playbackRate.cancelScheduledValues(now);\n this.bufferSourceNode.playbackRate.linearRampToValueAtTime(Math.abs(playbackRate), now);\n this._counterNode.playbackRate.cancelScheduledValues(now);\n this._counterNode.playbackRate.linearRampToValueAtTime(Math.abs(playbackRate), now);\n }\n\n if (reverse) {\n this.reverseBuffer();\n }\n return this.playbackRate;\n };\n\n // TO DO: document this\n p5.SoundFile.prototype.setPitch = function(num) {\n var newPlaybackRate = midiToFreq(num) / midiToFreq(60);\n this.rate(newPlaybackRate);\n };\n\n p5.SoundFile.prototype.getPlaybackRate = function() {\n return this.playbackRate;\n };\n\n /**\n * Returns the duration of a sound file in seconds.\n *\n * @method duration\n * @for p5.SoundFile\n * @return {Number} The duration of the soundFile in seconds.\n */\n p5.SoundFile.prototype.duration = function() {\n // Return Duration\n if (this.buffer) {\n return this.buffer.duration;\n } else {\n return 0;\n }\n };\n\n /**\n * Return the current position of the p5.SoundFile playhead, in seconds.\n * Time is relative to the normal buffer direction, so if `reverseBuffer`\n * has been called, currentTime will count backwards.\n *\n * @method currentTime\n * @for p5.SoundFile\n * @return {Number} currentTime of the soundFile in seconds.\n */\n p5.SoundFile.prototype.currentTime = function() {\n return this.reversed\n ? Math.abs(this._lastPos - this.buffer.length) / ac.sampleRate\n : this._lastPos / ac.sampleRate;\n };\n\n /**\n * Move the playhead of a soundfile that is currently playing to a\n * new position and a new duration, in seconds.\n * If none are given, will reset the file to play entire duration\n * from start to finish. To set the position of a soundfile that is\n * not currently playing, use the `play` or `loop` methods.\n *\n * @method jump\n * @for p5.SoundFile\n * @param {Number} cueTime cueTime of the soundFile in seconds.\n * @param {Number} duration duration in seconds.\n */\n p5.SoundFile.prototype.jump = function(cueTime, duration) {\n if (cueTime < 0 || cueTime > this.buffer.duration) {\n throw 'jump time out of range';\n }\n if (duration > this.buffer.duration - cueTime) {\n throw 'end time out of range';\n }\n\n var cTime = cueTime || 0;\n var dur = duration || undefined;\n if (this.isPlaying()) {\n this.stop(0);\n this.play(0, this.playbackRate, this.output.gain.value, cTime, dur);\n }\n };\n\n /**\n * Return the number of channels in a sound file.\n * For example, Mono = 1, Stereo = 2.\n *\n * @method channels\n * @for p5.SoundFile\n * @return {Number} [channels]\n */\n p5.SoundFile.prototype.channels = function() {\n return this.buffer.numberOfChannels;\n };\n\n /**\n * Return the sample rate of the sound file.\n *\n * @method sampleRate\n * @for p5.SoundFile\n * @return {Number} [sampleRate]\n */\n p5.SoundFile.prototype.sampleRate = function() {\n return this.buffer.sampleRate;\n };\n\n /**\n * Return the number of samples in a sound file.\n * Equal to sampleRate * duration.\n *\n * @method frames\n * @for p5.SoundFile\n * @return {Number} [sampleCount]\n */\n p5.SoundFile.prototype.frames = function() {\n return this.buffer.length;\n };\n\n /**\n * Returns an array of amplitude peaks in a p5.SoundFile that can be\n * used to draw a static waveform. Scans through the p5.SoundFile's\n * audio buffer to find the greatest amplitudes. Accepts one\n * parameter, 'length', which determines size of the array.\n * Larger arrays result in more precise waveform visualizations.\n *\n * Inspired by Wavesurfer.js.\n *\n * @method getPeaks\n * @for p5.SoundFile\n * @params {Number} [length] length is the size of the returned array.\n * Larger length results in more precision.\n * Defaults to 5*width of the browser window.\n * @returns {Float32Array} Array of peaks.\n */\n p5.SoundFile.prototype.getPeaks = function(length) {\n\n if (this.buffer) {\n // set length to window's width if no length is provided\n if (!length) {\n length = window.width*5;\n }\n if (this.buffer) {\n var buffer = this.buffer;\n var sampleSize = buffer.length / length;\n var sampleStep = ~~(sampleSize / 10) || 1;\n var channels = buffer.numberOfChannels;\n var peaks = new Float32Array(Math.round(length));\n\n for (var c = 0; c < channels; c++) {\n var chan = buffer.getChannelData(c);\n for (var i = 0; i < length; i++) {\n var start = ~~(i*sampleSize);\n var end = ~~(start + sampleSize);\n var max = 0;\n for (var j = start; j < end; j+= sampleStep) {\n var value = chan[j];\n if (value > max) {\n max = value;\n // faster than Math.abs\n } else if (-value > max) {\n max = value;\n }\n }\n if (c === 0 || Math.abs(max) > peaks[i]) {\n peaks[i] = max;\n }\n }\n }\n\n return peaks;\n }\n }\n\n else {\n throw 'Cannot load peaks yet, buffer is not loaded';\n }\n };\n\n /**\n * Reverses the p5.SoundFile's buffer source.\n * Playback must be handled separately (see example).\n *\n * @method reverseBuffer\n * @for p5.SoundFile\n * @example\n *
\n * let drum;\n * function preload() {\n * drum = loadSound('assets/drum.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * text('tap to play', 20, 20);\n * }\n *\n * function canvasPressed() {\n * drum.stop();\n * drum.reverseBuffer();\n * drum.play();\n * }\n * \n *
\n */\n p5.SoundFile.prototype.reverseBuffer = function() {\n if (this.buffer) {\n var currentPos = this._lastPos / ac.sampleRate;\n var curVol = this.getVolume();\n this.setVolume(0, 0.001);\n\n const numChannels = this.buffer.numberOfChannels;\n for (var i = 0; i < numChannels; i++) {\n this.buffer.getChannelData(i).reverse();\n }\n // set reversed flag\n this.reversed = !this.reversed;\n\n if (this.isPlaying() && currentPos) {\n this.jump(this.duration() - currentPos);\n }\n this.setVolume(curVol, 0.001);\n } else {\n throw 'SoundFile is not done loading';\n }\n };\n\n /**\n * Schedule an event to be called when the soundfile\n * reaches the end of a buffer. If the soundfile is\n * playing through once, this will be called when it\n * ends. If it is looping, it will be called when\n * stop is called.\n *\n * @method onended\n * @for p5.SoundFile\n * @param {Function} callback function to call when the\n * soundfile has ended.\n */\n p5.SoundFile.prototype.onended = function(callback) {\n this._onended = callback;\n return this;\n };\n\n p5.SoundFile.prototype.add = function() {\n // TO DO\n };\n\n p5.SoundFile.prototype.dispose = function() {\n var now = p5sound.audiocontext.currentTime;\n\n // remove reference to soundfile\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n\n this.stop(now);\n if (this.buffer && this.bufferSourceNode) {\n for (var i = 0; i < this.bufferSourceNodes.length - 1; i++) {\n if (this.bufferSourceNodes[i] !== null) {\n this.bufferSourceNodes[i].disconnect();\n try {\n this.bufferSourceNodes[i].stop(now);\n } catch(e) {\n console.warn('no buffer source node to dispose');\n }\n this.bufferSourceNodes[i] = null;\n }\n }\n if ( this.isPlaying() ) {\n try {\n this._counterNode.stop(now);\n } catch(e) {\n console.log(e);\n }\n this._counterNode = null;\n }\n }\n if (this.output) {\n this.output.disconnect();\n this.output = null;\n }\n if (this.panner) {\n this.panner.disconnect();\n this.panner = null;\n }\n };\n\n /**\n * Connects the output of a p5sound object to input of another\n * p5.sound object. For example, you may connect a p5.SoundFile to an\n * FFT or an Effect. If no parameter is given, it will connect to\n * the master output. Most p5sound objects connect to the master\n * output when they are created.\n *\n * @method connect\n * @for p5.SoundFile\n * @param {Object} [object] Audio object that accepts an input\n */\n p5.SoundFile.prototype.connect = function(unit) {\n if (!unit) {\n this.panner.connect(p5sound.input);\n }\n else {\n if (unit.hasOwnProperty('input')) {\n this.panner.connect(unit.input);\n } else {\n this.panner.connect(unit);\n }\n }\n };\n\n /**\n * Disconnects the output of this p5sound object.\n *\n * @method disconnect\n * @for p5.SoundFile\n */\n p5.SoundFile.prototype.disconnect = function() {\n if (this.panner) {\n this.panner.disconnect();\n }\n };\n\n /**\n */\n p5.SoundFile.prototype.getLevel = function() {\n console.warn('p5.SoundFile.getLevel has been removed from the library. Use p5.Amplitude instead');\n };\n\n /**\n * Reset the source for this SoundFile to a\n * new path (URL).\n *\n * @method setPath\n * @for p5.SoundFile\n * @param {String} path path to audio file\n * @param {Function} callback Callback\n */\n p5.SoundFile.prototype.setPath = function(p, callback) {\n var path = p5.prototype._checkFileFormats(p);\n this.url = path;\n this.load(callback);\n };\n\n /**\n * Replace the current Audio Buffer with a new Buffer.\n *\n * @method setBuffer\n * @for p5.SoundFile\n * @param {Array} buf Array of Float32 Array(s). 2 Float32 Arrays\n * will create a stereo source. 1 will create\n * a mono source.\n */\n p5.SoundFile.prototype.setBuffer = function(buf) {\n var numChannels = buf.length;\n var size = buf[0].length;\n var newBuffer = ac.createBuffer(numChannels, size, ac.sampleRate);\n\n if (!(buf[0] instanceof Float32Array)) {\n buf[0] = new Float32Array(buf[0]);\n }\n\n for (var channelNum = 0; channelNum < numChannels; channelNum++) {\n var channel = newBuffer.getChannelData( channelNum );\n channel.set(buf[channelNum]);\n }\n\n this.buffer = newBuffer;\n\n // set numbers of channels on input to the panner\n this.panner.inputChannels(numChannels);\n };\n\n //////////////////////////////////////////////////\n // script processor node with an empty buffer to help\n // keep a sample-accurate position in playback buffer.\n // Inspired by Chinmay Pendharkar's technique for Sonoport --> http://bit.ly/1HwdCsV\n // Copyright [2015] [Sonoport (Asia) Pte. Ltd.],\n // Licensed under the Apache License http://apache.org/licenses/LICENSE-2.0\n ////////////////////////////////////////////////////////////////////////////////////\n\n var _createCounterBuffer = function(buffer) {\n const len = buffer.length;\n const audioBuf = ac.createBuffer( 1, buffer.length, ac.sampleRate );\n const arrayBuffer = audioBuf.getChannelData(0);\n for (var index = 0; index < len; index++) {\n arrayBuffer[index] = index;\n }\n return audioBuf;\n };\n\n // initialize counterNode, set its initial buffer and playbackRate\n p5.SoundFile.prototype._initCounterNode = function() {\n var self = this;\n var now = ac.currentTime;\n var cNode = ac.createBufferSource();\n\n const workletBufferSize = safeBufferSize(256);\n\n // dispose of worklet node if it already exists\n if (self._workletNode) {\n self._workletNode.disconnect();\n delete self._workletNode;\n }\n self._workletNode = new AudioWorkletNode(ac, processorNames.soundFileProcessor, {\n processorOptions: { bufferSize: workletBufferSize }\n });\n self._workletNode.port.onmessage = event => {\n if (event.data.name === 'position') {\n // event.data.position should only be 0 when paused\n if (event.data.position === 0) {\n return;\n }\n this._lastPos = event.data.position;\n\n // do any callbacks that have been scheduled\n this._onTimeUpdate(self._lastPos);\n }\n };\n\n // create counter buffer of the same length as self.buffer\n cNode.buffer = _createCounterBuffer( self.buffer );\n\n cNode.playbackRate.setValueAtTime(self.playbackRate, now);\n\n cNode.connect(self._workletNode);\n self._workletNode.connect(p5.soundOut._silentNode);\n\n return cNode;\n };\n\n // initialize sourceNode, set its initial buffer and playbackRate\n p5.SoundFile.prototype._initSourceNode = function() {\n var bufferSourceNode = ac.createBufferSource();\n bufferSourceNode.buffer = this.buffer;\n bufferSourceNode.playbackRate.value = this.playbackRate;\n bufferSourceNode.connect(this.output);\n return bufferSourceNode;\n };\n\n /**\n * processPeaks returns an array of timestamps where it thinks there is a beat.\n *\n * This is an asynchronous function that processes the soundfile in an offline audio context,\n * and sends the results to your callback function.\n *\n * The process involves running the soundfile through a lowpass filter, and finding all of the\n * peaks above the initial threshold. If the total number of peaks are below the minimum number of peaks,\n * it decreases the threshold and re-runs the analysis until either minPeaks or minThreshold are reached.\n *\n * @method processPeaks\n * @for p5.SoundFile\n * @param {Function} callback a function to call once this data is returned\n * @param {Number} [initThreshold] initial threshold defaults to 0.9\n * @param {Number} [minThreshold] minimum threshold defaults to 0.22\n * @param {Number} [minPeaks] minimum number of peaks defaults to 200\n * @return {Array} Array of timestamped peaks\n */\n p5.SoundFile.prototype.processPeaks = function(callback, _initThreshold, _minThreshold, _minPeaks) {\n var bufLen = this.buffer.length;\n var sampleRate = this.buffer.sampleRate;\n var buffer = this.buffer;\n var allPeaks = [];\n\n var initialThreshold = _initThreshold || 0.9,\n threshold = initialThreshold,\n minThreshold = _minThreshold || 0.22,\n minPeaks = _minPeaks || 200;\n\n // Create offline context\n var offlineContext = new window.OfflineAudioContext(1, bufLen, sampleRate);\n\n // create buffer source\n var source = offlineContext.createBufferSource();\n source.buffer = buffer;\n\n // Create filter. TO DO: allow custom setting of filter\n var filter = offlineContext.createBiquadFilter();\n filter.type = 'lowpass';\n source.connect(filter);\n filter.connect(offlineContext.destination);\n\n // start playing at time:0\n source.start(0);\n offlineContext.startRendering(); // Render the song\n\n // act on the result\n offlineContext.oncomplete = function(e) {\n if (!self.panner) return;\n var filteredBuffer = e.renderedBuffer;\n var bufferData = filteredBuffer.getChannelData(0);\n\n\n // step 1:\n // create Peak instances, add them to array, with strength and sampleIndex\n do {\n allPeaks = getPeaksAtThreshold(bufferData, threshold);\n threshold -= 0.005;\n } while (Object.keys(allPeaks).length < minPeaks && threshold >= minThreshold);\n\n\n // step 2:\n // find intervals for each peak in the sampleIndex, add tempos array\n var intervalCounts = countIntervalsBetweenNearbyPeaks(allPeaks);\n\n // step 3: find top tempos\n var groups = groupNeighborsByTempo(intervalCounts, filteredBuffer.sampleRate);\n\n // sort top intervals\n var topTempos = groups.sort(function(intA, intB) {\n return intB.count - intA.count;\n\n }).splice(0,5);\n\n // set this SoundFile's tempo to the top tempo ??\n this.tempo = topTempos[0].tempo;\n\n // step 4:\n // new array of peaks at top tempo within a bpmVariance\n var bpmVariance = 5;\n var tempoPeaks = getPeaksAtTopTempo(allPeaks, topTempos[0].tempo, filteredBuffer.sampleRate, bpmVariance);\n\n callback(tempoPeaks);\n };\n };\n\n // process peaks\n var Peak = function(amp, i) {\n this.sampleIndex = i;\n this.amplitude = amp;\n this.tempos = [];\n this.intervals = [];\n };\n\n // 1. for processPeaks() Function to identify peaks above a threshold\n // returns an array of peak indexes as frames (samples) of the original soundfile\n function getPeaksAtThreshold(data, threshold) {\n var peaksObj = {};\n var length = data.length;\n\n for (var i = 0; i < length; i++) {\n if (data[i] > threshold) {\n var amp = data[i];\n var peak = new Peak(amp, i);\n peaksObj[i] = peak;\n // Skip forward ~ 1/8s to get past this peak.\n i += 6000;\n }\n i++;\n }\n return peaksObj;\n }\n\n // 2. for processPeaks()\n function countIntervalsBetweenNearbyPeaks(peaksObj) {\n var intervalCounts = [];\n var peaksArray = Object.keys(peaksObj).sort();\n\n for (var index = 0; index < peaksArray.length; index++) {\n\n // find intervals in comparison to nearby peaks\n for (var i = 0; i < 10; i++) {\n var startPeak = peaksObj[peaksArray[index]];\n var endPeak = peaksObj[peaksArray[index + i]];\n\n if (startPeak && endPeak) {\n var startPos = startPeak.sampleIndex;\n var endPos = endPeak.sampleIndex;\n var interval = endPos - startPos;\n\n // add a sample interval to the startPeak in the allPeaks array\n if (interval > 0) {\n startPeak.intervals.push(interval);\n }\n\n // tally the intervals and return interval counts\n var foundInterval = intervalCounts.some(function(intervalCount) {\n if (intervalCount.interval === interval) {\n intervalCount.count++;\n return intervalCount;\n }\n });\n\n // store with JSON like formatting\n if (!foundInterval) {\n intervalCounts.push({\n interval: interval,\n count: 1,\n });\n }\n }\n }\n }\n\n return intervalCounts;\n }\n\n\n // 3. for processPeaks --> find tempo\n function groupNeighborsByTempo(intervalCounts, sampleRate) {\n var tempoCounts = [];\n\n intervalCounts.forEach(function(intervalCount) {\n\n try {\n // Convert an interval to tempo\n var theoreticalTempo = Math.abs( 60 / (intervalCount.interval / sampleRate ) );\n\n theoreticalTempo = mapTempo(theoreticalTempo);\n\n var foundTempo = tempoCounts.some(function(tempoCount) {\n if (tempoCount.tempo === theoreticalTempo)\n return tempoCount.count += intervalCount.count;\n });\n if (!foundTempo) {\n if (isNaN(theoreticalTempo)) {\n return;\n }\n tempoCounts.push({\n tempo: Math.round(theoreticalTempo),\n count: intervalCount.count\n });\n }\n } catch(e) {\n throw e;\n }\n\n });\n\n return tempoCounts;\n }\n\n // 4. for processPeaks - get peaks at top tempo\n function getPeaksAtTopTempo(peaksObj, tempo, sampleRate, bpmVariance) {\n var peaksAtTopTempo = [];\n var peaksArray = Object.keys(peaksObj).sort();\n\n // TO DO: filter out peaks that have the tempo and return\n for (var i = 0; i < peaksArray.length; i++) {\n var key = peaksArray[i];\n var peak = peaksObj[key];\n\n for (var j = 0; j < peak.intervals.length; j++) {\n var intervalBPM = Math.round(Math.abs( 60 / (peak.intervals[j] / sampleRate) ) );\n\n intervalBPM = mapTempo(intervalBPM);\n\n if ( Math.abs(intervalBPM - tempo) < bpmVariance ) {\n // convert sampleIndex to seconds\n peaksAtTopTempo.push(peak.sampleIndex/sampleRate);\n }\n }\n }\n\n // filter out peaks that are very close to each other\n peaksAtTopTempo = peaksAtTopTempo.filter(function(peakTime, index, arr) {\n var dif = arr[index + 1] - peakTime;\n if (dif > 0.01) {\n return true;\n }\n });\n\n return peaksAtTopTempo;\n }\n\n // helper function for processPeaks\n function mapTempo(theoreticalTempo) {\n // these scenarios create infinite while loop\n if (!isFinite(theoreticalTempo) || theoreticalTempo === 0 ) {\n return;\n }\n\n // Adjust the tempo to fit within the 90-180 BPM range\n while (theoreticalTempo < 90) theoreticalTempo *= 2;\n while (theoreticalTempo > 180 && theoreticalTempo > 90) theoreticalTempo /= 2;\n\n return theoreticalTempo;\n }\n\n\n /*** SCHEDULE EVENTS ***/\n\n // Cue inspired by JavaScript setTimeout, and the\n // Tone.js Transport Timeline Event, MIT License Yotam Mann 2015 tonejs.org\n var Cue = function(callback, time, id, val) {\n this.callback = callback;\n this.time = time;\n this.id = id;\n this.val = val;\n };\n\n /**\n * Schedule events to trigger every time a MediaElement\n * (audio/video) reaches a playback cue point.\n *\n * Accepts a callback function, a time (in seconds) at which to trigger\n * the callback, and an optional parameter for the callback.\n *\n * Time will be passed as the first parameter to the callback function,\n * and param will be the second parameter.\n *\n *\n * @method addCue\n * @for p5.SoundFile\n * @param {Number} time Time in seconds, relative to this media\n * element's playback. For example, to trigger\n * an event every time playback reaches two\n * seconds, pass in the number 2. This will be\n * passed as the first parameter to\n * the callback function.\n * @param {Function} callback Name of a function that will be\n * called at the given time. The callback will\n * receive time and (optionally) param as its\n * two parameters.\n * @param {Object} [value] An object to be passed as the\n * second parameter to the\n * callback function.\n * @return {Number} id ID of this cue,\n * useful for removeCue(id)\n * @example\n *
\n * let mySound;\n * function preload() {\n * mySound = loadSound('assets/Damscray_DancingTiger.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * text('tap to play', 10, 20);\n *\n * // schedule calls to changeText\n * mySound.addCue(0, changeText, \"hello\" );\n * mySound.addCue(0.5, changeText, \"hello,\" );\n * mySound.addCue(1, changeText, \"hello, p5!\");\n * mySound.addCue(1.5, changeText, \"hello, p5!!\");\n * mySound.addCue(2, changeText, \"hello, p5!!!!!\");\n * }\n *\n * function changeText(val) {\n * background(220);\n * text(val, 10, 20);\n * }\n *\n * function canvasPressed() {\n * mySound.play();\n * }\n *
\n */\n p5.SoundFile.prototype.addCue = function(time, callback, val) {\n var id = this._cueIDCounter++;\n\n var cue = new Cue(callback, time, id, val);\n this._cues.push(cue);\n\n // if (!this.elt.ontimeupdate) {\n // this.elt.ontimeupdate = this._onTimeUpdate.bind(this);\n // }\n\n return id;\n };\n\n /**\n * Remove a callback based on its ID. The ID is returned by the\n * addCue method.\n *\n * @method removeCue\n * @for p5.SoundFile\n * @param {Number} id ID of the cue, as returned by addCue\n */\n p5.SoundFile.prototype.removeCue = function(id) {\n var cueLength = this._cues.length;\n for (var i = 0; i < cueLength; i++) {\n var cue = this._cues[i];\n if (cue.id === id) {\n this._cues.splice(i, 1);\n break;\n }\n }\n\n if (this._cues.length === 0) {\n // TO DO: remove callback\n // this.elt.ontimeupdate = null\n }\n };\n\n /**\n * Remove all of the callbacks that had originally been scheduled\n * via the addCue method.\n *\n * @method clearCues\n */\n p5.SoundFile.prototype.clearCues = function() {\n this._cues = [];\n // this.elt.ontimeupdate = null;\n };\n\n // private method that checks for cues to be fired if events\n // have been scheduled using addCue(callback, time).\n p5.SoundFile.prototype._onTimeUpdate = function(position) {\n var playbackTime = position/this.buffer.sampleRate;\n var cueLength = this._cues.length;\n\n for (var i = 0 ; i < cueLength; i++) {\n var cue = this._cues[i];\n var callbackTime = cue.time;\n var val = cue.val;\n\n if (~~this._prevUpdateTime <= callbackTime && callbackTime <= playbackTime) {\n\n // pass the scheduled callbackTime as parameter to the callback\n cue.callback(val);\n }\n\n }\n\n this._prevUpdateTime = playbackTime;\n };\n\n /**\n * Save a p5.SoundFile as a .wav file. The browser will prompt the user\n * to download the file to their device. To upload a file to a server, see\n * getBlob\n *\n * @method save\n * @for p5.SoundFile\n * @param {String} [fileName] name of the resulting .wav file.\n * @example\n *
\n * let mySound;\n * function preload() {\n * mySound = loadSound('assets/doorbell.mp3');\n * }\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * text('tap to download', 10, 20);\n * }\n *\n * function canvasPressed() {\n * mySound.save('my cool filename');\n * }\n *
\n */\n p5.SoundFile.prototype.save = function(fileName) {\n p5.prototype.saveSound(this, fileName, 'wav');\n };\n\n /**\n * This method is useful for sending a SoundFile to a server. It returns the\n * .wav-encoded audio data as a \"Blob\".\n * A Blob is a file-like data object that can be uploaded to a server\n * with an http request. We'll\n * use the `httpDo` options object to send a POST request with some\n * specific options: we encode the request as `multipart/form-data`,\n * and attach the blob as one of the form values using `FormData`.\n *\n *\n * @method getBlob\n * @for p5.SoundFile\n * @returns {Blob} A file-like data object\n * @example\n *
\n * function preload() {\n * mySound = loadSound('assets/doorbell.mp3');\n * }\n *\n * function setup() {\n * noCanvas();\n * let soundBlob = mySound.getBlob();\n *\n * // Now we can send the blob to a server...\n * let serverUrl = 'https://jsonplaceholder.typicode.com/posts';\n * let httpRequestOptions = {\n * method: 'POST',\n * body: new FormData().append('soundBlob', soundBlob),\n * headers: new Headers({\n * 'Content-Type': 'multipart/form-data'\n * })\n * };\n * httpDo(serverUrl, httpRequestOptions);\n *\n * // We can also create an `ObjectURL` pointing to the Blob\n * let blobUrl = URL.createObjectURL(soundBlob);\n *\n * // The `
\n */\n p5.SoundFile.prototype.getBlob = function() {\n const dataView = convertToWav(this.buffer);\n return new Blob([dataView], { type: 'audio/wav' });\n };\n\n // event handler to remove references to the bufferSourceNode when it is done playing\n function _clearOnEnd(e) {\n const thisBufferSourceNode = e.target;\n const soundFile = this;\n\n // delete this.bufferSourceNode from the sources array when it is done playing:\n thisBufferSourceNode._playing = false;\n thisBufferSourceNode.removeEventListener('ended', soundFile._clearOnEnd);\n\n // call the onended callback\n soundFile._onended(soundFile);\n\n // delete bufferSourceNode(s) in soundFile.bufferSourceNodes\n // iterate in reverse order because the index changes by splice\n soundFile.bufferSourceNodes.map((_, i) => i).reverse().forEach(function (i) {\n const n = soundFile.bufferSourceNodes[i];\n\n if (n._playing === false) {\n soundFile.bufferSourceNodes.splice(i, 1);\n }\n });\n\n if (soundFile.bufferSourceNodes.length === 0) {\n soundFile._playing = false;\n }\n }\n});\n","'use strict';\n\ndefine(function (require) {\n const p5sound = require('master');\n const { safeBufferSize } = require('helpers');\n const processorNames = require('./audioWorklet/processorNames');\n\n /**\n * Amplitude measures volume between 0.0 and 1.0.\n * Listens to all p5sound by default, or use setInput()\n * to listen to a specific sound source. Accepts an optional\n * smoothing value, which defaults to 0.\n *\n * @class p5.Amplitude\n * @constructor\n * @param {Number} [smoothing] between 0.0 and .999 to smooth\n * amplitude readings (defaults to 0)\n * @example\n *
\n * let sound, amplitude;\n *\n * function preload(){\n * sound = loadSound('assets/beat.mp3');\n * }\n * function setup() {\n * let cnv = createCanvas(100,100);\n * cnv.mouseClicked(toggleSound);\n * amplitude = new p5.Amplitude();\n * }\n *\n * function draw() {\n * background(220);\n * text('tap to play', 20, 20);\n *\n * let level = amplitude.getLevel();\n * let size = map(level, 0, 1, 0, 200);\n * ellipse(width/2, height/2, size, size);\n * }\n *\n * function toggleSound() {\n * if (sound.isPlaying() ){\n * sound.stop();\n * } else {\n * sound.play();\n * }\n * }\n *\n *
\n */\n p5.Amplitude = function(smoothing) {\n\n // Set to 2048 for now. In future iterations, this should be inherited or parsed from p5sound's default\n this.bufferSize = safeBufferSize(2048);\n\n // set audio context\n this.audiocontext = p5sound.audiocontext;\n this._workletNode = new AudioWorkletNode(this.audiocontext, processorNames.amplitudeProcessor, {\n outputChannelCount: [1],\n\n parameterData: { smoothing: smoothing || 0 },\n processorOptions: {\n normalize: false,\n smoothing: smoothing || 0,\n numInputChannels: 2,\n bufferSize: this.bufferSize\n }\n });\n\n this._workletNode.port.onmessage = function(event) {\n if (event.data.name === 'amplitude') {\n this.volume = event.data.volume;\n this.volNorm = event.data.volNorm;\n this.stereoVol = event.data.stereoVol;\n this.stereoVolNorm = event.data.stereoVolNorm;\n }\n }.bind(this);\n\n // for connections\n this.input = this._workletNode;\n\n this.output = this.audiocontext.createGain();\n\n // the variables to return\n this.volume = 0;\n this.volNorm = 0;\n this.stereoVol = [0, 0];\n this.stereoVolNorm = [0, 0];\n\n this.normalize = false;\n\n this._workletNode.connect(this.output);\n this.output.gain.value = 0;\n\n // this may only be necessary because of a Chrome bug\n this.output.connect(this.audiocontext.destination);\n\n // connect to p5sound master output by default, unless set by input()\n p5sound.meter.connect(this._workletNode);\n\n // add this p5.SoundFile to the soundArray\n p5sound.soundArray.push(this);\n };\n\n /**\n * Connects to the p5sound instance (master output) by default.\n * Optionally, you can pass in a specific source (i.e. a soundfile).\n *\n * @method setInput\n * @for p5.Amplitude\n * @param {soundObject|undefined} [snd] set the sound source\n * (optional, defaults to\n * master output)\n * @param {Number|undefined} [smoothing] a range between 0.0 and 1.0\n * to smooth amplitude readings\n * @example\n *
\n * function preload(){\n * sound1 = loadSound('assets/beat.mp3');\n * sound2 = loadSound('assets/drum.mp3');\n * }\n * function setup(){\n * cnv = createCanvas(100, 100);\n * cnv.mouseClicked(toggleSound);\n *\n * amplitude = new p5.Amplitude();\n * amplitude.setInput(sound2);\n * }\n *\n * function draw() {\n * background(220);\n * text('tap to play', 20, 20);\n *\n * let level = amplitude.getLevel();\n * let size = map(level, 0, 1, 0, 200);\n * ellipse(width/2, height/2, size, size);\n * }\n *\n * function toggleSound(){\n * if (sound1.isPlaying() && sound2.isPlaying()) {\n * sound1.stop();\n * sound2.stop();\n * } else {\n * sound1.play();\n * sound2.play();\n * }\n * }\n *
\n */\n p5.Amplitude.prototype.setInput = function(source, smoothing) {\n\n p5sound.meter.disconnect();\n\n if (smoothing) {\n this._workletNode.parameters.get('smoothing').value = smoothing;\n }\n\n // connect to the master out of p5s instance if no snd is provided\n if (source == null) {\n console.log('Amplitude input source is not ready! Connecting to master output instead');\n p5sound.meter.connect(this._workletNode);\n }\n\n // if it is a p5.Signal\n else if (source instanceof p5.Signal) {\n source.output.connect(this._workletNode);\n }\n // connect to the sound if it is available\n else if (source) {\n source.connect(this._workletNode);\n this._workletNode.disconnect();\n this._workletNode.connect(this.output);\n }\n\n // otherwise, connect to the master out of p5s instance (default)\n else {\n p5sound.meter.connect(this._workletNode);\n }\n };\n\n p5.Amplitude.prototype.connect = function(unit) {\n if (unit) {\n if (unit.hasOwnProperty('input')) {\n this.output.connect(unit.input);\n } else {\n this.output.connect(unit);\n }\n } else {\n this.output.connect(this.panner.connect(p5sound.input));\n }\n };\n\n p5.Amplitude.prototype.disconnect = function() {\n if (this.output) {\n this.output.disconnect();\n }\n };\n\n /**\n * Returns a single Amplitude reading at the moment it is called.\n * For continuous readings, run in the draw loop.\n *\n * @method getLevel\n * @for p5.Amplitude\n * @param {Number} [channel] Optionally return only channel 0 (left) or 1 (right)\n * @return {Number} Amplitude as a number between 0.0 and 1.0\n * @example\n *
\n * function preload(){\n * sound = loadSound('assets/beat.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mouseClicked(toggleSound);\n * amplitude = new p5.Amplitude();\n * }\n *\n * function draw() {\n * background(220, 150);\n * textAlign(CENTER);\n * text('tap to play', width/2, 20);\n *\n * let level = amplitude.getLevel();\n * let size = map(level, 0, 1, 0, 200);\n * ellipse(width/2, height/2, size, size);\n * }\n *\n * function toggleSound(){\n * if (sound.isPlaying()) {\n * sound.stop();\n * } else {\n * sound.play();\n * }\n * }\n *
\n */\n p5.Amplitude.prototype.getLevel = function(channel) {\n if (typeof channel !== 'undefined') {\n if (this.normalize) {\n return this.stereoVolNorm[channel];\n } else {\n return this.stereoVol[channel];\n }\n }\n else if (this.normalize) {\n return this.volNorm;\n }\n else {\n return this.volume;\n }\n };\n\n /**\n * Determines whether the results of Amplitude.process() will be\n * Normalized. To normalize, Amplitude finds the difference the\n * loudest reading it has processed and the maximum amplitude of\n * 1.0. Amplitude adds this difference to all values to produce\n * results that will reliably map between 0.0 and 1.0. However,\n * if a louder moment occurs, the amount that Normalize adds to\n * all the values will change. Accepts an optional boolean parameter\n * (true or false). Normalizing is off by default.\n *\n * @method toggleNormalize\n * @for p5.Amplitude\n * @param {boolean} [boolean] set normalize to true (1) or false (0)\n */\n p5.Amplitude.prototype.toggleNormalize = function(bool) {\n if (typeof bool === 'boolean') {\n this.normalize = bool;\n }\n else {\n this.normalize = !this.normalize;\n }\n this._workletNode.port.postMessage({ name: 'toggleNormalize', normalize: this.normalize });\n };\n\n /**\n * Smooth Amplitude analysis by averaging with the last analysis\n * frame. Off by default.\n *\n * @method smooth\n * @for p5.Amplitude\n * @param {Number} set smoothing from 0.0 <= 1\n */\n p5.Amplitude.prototype.smooth = function(s) {\n if (s >= 0 && s < 1) {\n this._workletNode.port.postMessage({ name: 'smoothing', smoothing: s });\n } else {\n console.log('Error: smoothing must be between 0 and 1');\n }\n };\n\n p5.Amplitude.prototype.dispose = function() {\n // remove reference from soundArray\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n\n if (this.input) {\n this.input.disconnect();\n delete this.input;\n }\n if (this.output) {\n this.output.disconnect();\n delete this.output;\n }\n\n this._workletNode.disconnect();\n delete this._workletNode;\n };\n\n});\n","'use strict';\n\ndefine(function(require) {\n var p5sound = require('master');\n const {safeBins} = require('helpers');\n\n /**\n *

FFT (Fast Fourier Transform) is an analysis algorithm that\n * isolates individual\n * \n * audio frequencies within a waveform.

\n *\n *

Once instantiated, a p5.FFT object can return an array based on\n * two types of analyses:
• FFT.waveform() computes\n * amplitude values along the time domain. The array indices correspond\n * to samples across a brief moment in time. Each value represents\n * amplitude of the waveform at that sample of time.
\n * • FFT.analyze() computes amplitude values along the\n * frequency domain. The array indices correspond to frequencies (i.e.\n * pitches), from the lowest to the highest that humans can hear. Each\n * value represents amplitude at that slice of the frequency spectrum.\n * Use with getEnergy() to measure amplitude at specific\n * frequencies, or within a range of frequencies.

\n *\n *

FFT analyzes a very short snapshot of sound called a sample\n * buffer. It returns an array of amplitude measurements, referred\n * to as bins. The array is 1024 bins long by default.\n * You can change the bin array length, but it must be a power of 2\n * between 16 and 1024 in order for the FFT algorithm to function\n * correctly. The actual size of the FFT buffer is twice the\n * number of bins, so given a standard sample rate, the buffer is\n * 2048/44100 seconds long.

\n *\n *\n * @class p5.FFT\n * @constructor\n * @param {Number} [smoothing] Smooth results of Freq Spectrum.\n * 0.0 < smoothing < 1.0.\n * Defaults to 0.8.\n * @param {Number} [bins] Length of resulting array.\n * Must be a power of two between\n * 16 and 1024. Defaults to 1024.\n * @example\n *
\n * function preload(){\n * sound = loadSound('assets/Damscray_DancingTiger.mp3');\n * }\n *\n * function setup(){\n * let cnv = createCanvas(100,100);\n * cnv.mouseClicked(togglePlay);\n * fft = new p5.FFT();\n * sound.amp(0.2);\n * }\n *\n * function draw(){\n * background(220);\n *\n * let spectrum = fft.analyze();\n * noStroke();\n * fill(255, 0, 255);\n * for (let i = 0; i< spectrum.length; i++){\n * let x = map(i, 0, spectrum.length, 0, width);\n * let h = -height + map(spectrum[i], 0, 255, height, 0);\n * rect(x, height, width / spectrum.length, h )\n * }\n *\n * let waveform = fft.waveform();\n * noFill();\n * beginShape();\n * stroke(20);\n * for (let i = 0; i < waveform.length; i++){\n * let x = map(i, 0, waveform.length, 0, width);\n * let y = map( waveform[i], -1, 1, 0, height);\n * vertex(x,y);\n * }\n * endShape();\n *\n * text('tap to play', 20, 20);\n * }\n *\n * function togglePlay() {\n * if (sound.isPlaying()) {\n * sound.pause();\n * } else {\n * sound.loop();\n * }\n * }\n *
\n */\n p5.FFT = function(smoothing, bins) {\n this.input = this.analyser = p5sound.audiocontext.createAnalyser();\n\n Object.defineProperties(this, {\n bins: {\n get: function() {\n return this.analyser.fftSize / 2;\n },\n set: function(b) {\n this.analyser.fftSize = b * 2;\n },\n configurable: true,\n enumerable: true\n },\n smoothing: {\n get: function() {\n return this.analyser.smoothingTimeConstant;\n },\n set: function(s) {\n this.analyser.smoothingTimeConstant = s;\n },\n configurable: true,\n enumerable: true\n }\n });\n\n // set default smoothing and bins\n this.smooth(smoothing);\n this.bins = safeBins(bins) || 1024;\n\n // default connections to p5sound fftMeter\n p5sound.fftMeter.connect(this.analyser);\n\n this.freqDomain = new Uint8Array(this.analyser.frequencyBinCount);\n this.timeDomain = new Uint8Array(this.analyser.frequencyBinCount);\n\n // predefined frequency ranges, these will be tweakable\n this.bass = [20, 140];\n this.lowMid = [140, 400];\n this.mid = [400, 2600];\n this.highMid = [2600, 5200];\n this.treble = [5200, 14000];\n\n // add this p5.SoundFile to the soundArray\n p5sound.soundArray.push(this);\n };\n\n /**\n * Set the input source for the FFT analysis. If no source is\n * provided, FFT will analyze all sound in the sketch.\n *\n * @method setInput\n * @for p5.FFT\n * @param {Object} [source] p5.sound object (or web audio API source node)\n */\n p5.FFT.prototype.setInput = function(source) {\n if (!source) {\n p5sound.fftMeter.connect(this.analyser);\n } else {\n if (source.output) {\n source.output.connect(this.analyser);\n } else if (source.connect) {\n source.connect(this.analyser);\n }\n p5sound.fftMeter.disconnect();\n }\n };\n\n /**\n * Returns an array of amplitude values (between -1.0 and +1.0) that represent\n * a snapshot of amplitude readings in a single buffer. Length will be\n * equal to bins (defaults to 1024). Can be used to draw the waveform\n * of a sound.\n *\n * @method waveform\n * @for p5.FFT\n * @param {Number} [bins] Must be a power of two between\n * 16 and 1024. Defaults to 1024.\n * @param {String} [precision] If any value is provided, will return results\n * in a Float32 Array which is more precise\n * than a regular array.\n * @return {Array} Array Array of amplitude values (-1 to 1)\n * over time. Array length = bins.\n *\n */\n p5.FFT.prototype.waveform = function() {\n var bins, mode, normalArray;\n\n for (var i = 0; i < arguments.length; i++) {\n if (typeof arguments[i] === 'number') {\n bins = arguments[i];\n this.analyser.fftSize = bins * 2;\n }\n if (typeof arguments[i] === 'string') {\n mode = arguments[i];\n }\n }\n\n // getFloatFrequencyData doesnt work in Safari as of 5/2015\n if (mode && !p5.prototype._isSafari()) {\n timeToFloat(this, this.timeDomain);\n this.analyser.getFloatTimeDomainData(this.timeDomain);\n return this.timeDomain;\n } else {\n timeToInt(this, this.timeDomain);\n this.analyser.getByteTimeDomainData(this.timeDomain);\n var normalArray = new Array();\n for (var j = 0; j < this.timeDomain.length; j++) {\n var scaled = p5.prototype.map(this.timeDomain[j], 0, 255, -1, 1);\n normalArray.push(scaled);\n }\n return normalArray;\n }\n };\n\n /**\n * Returns an array of amplitude values (between 0 and 255)\n * across the frequency spectrum. Length is equal to FFT bins\n * (1024 by default). The array indices correspond to frequencies\n * (i.e. pitches), from the lowest to the highest that humans can\n * hear. Each value represents amplitude at that slice of the\n * frequency spectrum. Must be called prior to using\n * getEnergy().\n *\n * @method analyze\n * @for p5.FFT\n * @param {Number} [bins] Must be a power of two between\n * 16 and 1024. Defaults to 1024.\n * @param {Number} [scale] If \"dB,\" returns decibel\n * float measurements between\n * -140 and 0 (max).\n * Otherwise returns integers from 0-255.\n * @return {Array} spectrum Array of energy (amplitude/volume)\n * values across the frequency spectrum.\n * Lowest energy (silence) = 0, highest\n * possible is 255.\n * @example\n *
\n * let osc, fft;\n *\n * function setup(){\n * let cnv = createCanvas(100,100);\n * cnv.mousePressed(startSound);\n * osc = new p5.Oscillator();\n * osc.amp(0);\n * fft = new p5.FFT();\n * }\n *\n * function draw(){\n * background(220);\n *\n * let freq = map(mouseX, 0, windowWidth, 20, 10000);\n * freq = constrain(freq, 1, 20000);\n * osc.freq(freq);\n *\n * let spectrum = fft.analyze();\n * noStroke();\n * fill(255, 0, 255);\n * for (let i = 0; i< spectrum.length; i++){\n * let x = map(i, 0, spectrum.length, 0, width);\n * let h = -height + map(spectrum[i], 0, 255, height, 0);\n * rect(x, height, width / spectrum.length, h );\n * }\n *\n * stroke(255);\n * if (!osc.started) {\n * text('tap here and drag to change frequency', 10, 20, width - 20);\n * } else {\n * text(round(freq)+'Hz', 10, 20);\n * }\n * }\n *\n * function startSound() {\n * osc.start();\n * osc.amp(0.5, 0.2);\n * }\n *\n * function mouseReleased() {\n * osc.amp(0, 0.2);\n * }\n *
\n *\n *\n */\n p5.FFT.prototype.analyze = function() {\n var mode;\n\n for (var i = 0; i < arguments.length; i++) {\n if (typeof arguments[i] === 'number') {\n this.bins = arguments[i];\n this.analyser.fftSize = this.bins * 2;\n }\n if (typeof arguments[i] === 'string') {\n mode = arguments[i];\n }\n }\n\n if (mode && mode.toLowerCase() === 'db') {\n freqToFloat(this);\n this.analyser.getFloatFrequencyData(this.freqDomain);\n return this.freqDomain;\n } else {\n freqToInt(this, this.freqDomain);\n this.analyser.getByteFrequencyData(this.freqDomain);\n var normalArray = Array.apply([], this.freqDomain);\n\n return normalArray;\n }\n };\n\n /**\n * Returns the amount of energy (volume) at a specific\n * \n * frequency, or the average amount of energy between two\n * frequencies. Accepts Number(s) corresponding\n * to frequency (in Hz), or a String corresponding to predefined\n * frequency ranges (\"bass\", \"lowMid\", \"mid\", \"highMid\", \"treble\").\n * Returns a range between 0 (no energy/volume at that frequency) and\n * 255 (maximum energy).\n * NOTE: analyze() must be called prior to getEnergy(). Analyze()\n * tells the FFT to analyze frequency data, and getEnergy() uses\n * the results determine the value at a specific frequency or\n * range of frequencies.

\n *\n * @method getEnergy\n * @for p5.FFT\n * @param {Number|String} frequency1 Will return a value representing\n * energy at this frequency. Alternately,\n * the strings \"bass\", \"lowMid\" \"mid\",\n * \"highMid\", and \"treble\" will return\n * predefined frequency ranges.\n * @param {Number} [frequency2] If a second frequency is given,\n * will return average amount of\n * energy that exists between the\n * two frequencies.\n * @return {Number} Energy Energy (volume/amplitude) from\n * 0 and 255.\n *\n */\n p5.FFT.prototype.getEnergy = function(frequency1, frequency2) {\n var nyquist = p5sound.audiocontext.sampleRate / 2;\n\n if (frequency1 === 'bass') {\n frequency1 = this.bass[0];\n frequency2 = this.bass[1];\n } else if (frequency1 === 'lowMid') {\n frequency1 = this.lowMid[0];\n frequency2 = this.lowMid[1];\n } else if (frequency1 === 'mid') {\n frequency1 = this.mid[0];\n frequency2 = this.mid[1];\n } else if (frequency1 === 'highMid') {\n frequency1 = this.highMid[0];\n frequency2 = this.highMid[1];\n } else if (frequency1 === 'treble') {\n frequency1 = this.treble[0];\n frequency2 = this.treble[1];\n }\n\n if (typeof frequency1 !== 'number') {\n throw 'invalid input for getEnergy()';\n } else if (!frequency2) {\n // if only one parameter:\n var index = Math.round(frequency1 / nyquist * this.freqDomain.length);\n return this.freqDomain[index];\n } else if (frequency1 && frequency2) {\n // if two parameters:\n // if second is higher than first\n if (frequency1 > frequency2) {\n var swap = frequency2;\n frequency2 = frequency1;\n frequency1 = swap;\n }\n var lowIndex = Math.round(frequency1 / nyquist * this.freqDomain.length);\n var highIndex = Math.round(frequency2 / nyquist * this.freqDomain.length);\n\n var total = 0;\n var numFrequencies = 0;\n // add up all of the values for the frequencies\n for (var i = lowIndex; i <= highIndex; i++) {\n total += this.freqDomain[i];\n numFrequencies += 1;\n }\n // divide by total number of frequencies\n var toReturn = total / numFrequencies;\n return toReturn;\n } else {\n throw 'invalid input for getEnergy()';\n }\n };\n\n // compatability with v.012, changed to getEnergy in v.0121. Will be deprecated...\n p5.FFT.prototype.getFreq = function(freq1, freq2) {\n console.log('getFreq() is deprecated. Please use getEnergy() instead.');\n var x = this.getEnergy(freq1, freq2);\n return x;\n };\n\n /**\n * Returns the\n * \n * spectral centroid of the input signal.\n * NOTE: analyze() must be called prior to getCentroid(). Analyze()\n * tells the FFT to analyze frequency data, and getCentroid() uses\n * the results determine the spectral centroid.

\n *\n * @method getCentroid\n * @for p5.FFT\n * @return {Number} Spectral Centroid Frequency of the spectral centroid in Hz.\n *\n *\n * @example\n *
\n * function setup(){\n * cnv = createCanvas(100,100);\n * cnv.mousePressed(userStartAudio);\n * sound = new p5.AudioIn();\n * sound.start();\n * fft = new p5.FFT();\n * sound.connect(fft);\n *}\n *\n *function draw() {\n * if (getAudioContext().state !== 'running') {\n * background(220);\n * text('tap here and enable mic to begin', 10, 20, width - 20);\n * return;\n * }\n * let centroidplot = 0.0;\n * let spectralCentroid = 0;\n *\n * background(0);\n * stroke(0,255,0);\n * let spectrum = fft.analyze();\n * fill(0,255,0); // spectrum is green\n *\n * //draw the spectrum\n * for (let i = 0; i < spectrum.length; i++){\n * let x = map(log(i), 0, log(spectrum.length), 0, width);\n * let h = map(spectrum[i], 0, 255, 0, height);\n * let rectangle_width = (log(i+1)-log(i))*(width/log(spectrum.length));\n * rect(x, height, rectangle_width, -h )\n * }\n * let nyquist = 22050;\n *\n * // get the centroid\n * spectralCentroid = fft.getCentroid();\n *\n * // the mean_freq_index calculation is for the display.\n * let mean_freq_index = spectralCentroid/(nyquist/spectrum.length);\n *\n * centroidplot = map(log(mean_freq_index), 0, log(spectrum.length), 0, width);\n *\n * stroke(255,0,0); // the line showing where the centroid is will be red\n *\n * rect(centroidplot, 0, width / spectrum.length, height)\n * noStroke();\n * fill(255,255,255); // text is white\n * text('centroid: ', 10, 20);\n * text(round(spectralCentroid)+' Hz', 10, 40);\n *}\n *
\n */\n p5.FFT.prototype.getCentroid = function() {\n var nyquist = p5sound.audiocontext.sampleRate / 2;\n var cumulative_sum = 0;\n var centroid_normalization = 0;\n\n for (var i = 0; i < this.freqDomain.length; i++) {\n cumulative_sum += i * this.freqDomain[i];\n centroid_normalization += this.freqDomain[i];\n }\n\n var mean_freq_index = 0;\n\n if (centroid_normalization !== 0) {\n mean_freq_index = cumulative_sum / centroid_normalization;\n }\n\n var spec_centroid_freq =\n mean_freq_index * (nyquist / this.freqDomain.length);\n return spec_centroid_freq;\n };\n\n /**\n * Smooth FFT analysis by averaging with the last analysis frame.\n *\n * @method smooth\n * @param {Number} smoothing 0.0 < smoothing < 1.0.\n * Defaults to 0.8.\n */\n p5.FFT.prototype.smooth = function(s) {\n if (typeof s !== 'undefined') {\n this.smoothing = s;\n }\n return this.smoothing;\n };\n\n p5.FFT.prototype.dispose = function() {\n // remove reference from soundArray\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n\n if (this.analyser) {\n this.analyser.disconnect();\n delete this.analyser;\n }\n };\n\n /**\n * Returns an array of average amplitude values for a given number\n * of frequency bands split equally. N defaults to 16.\n * NOTE: analyze() must be called prior to linAverages(). Analyze()\n * tells the FFT to analyze frequency data, and linAverages() uses\n * the results to group them into a smaller set of averages.

\n *\n * @method linAverages\n * @for p5.FFT\n * @param {Number} N Number of returned frequency groups\n * @return {Array} linearAverages Array of average amplitude values for each group\n */\n p5.FFT.prototype.linAverages = function(N) {\n var N = N || 16; // This prevents undefined, null or 0 values of N\n\n var spectrum = this.freqDomain;\n var spectrumLength = spectrum.length;\n var spectrumStep = Math.floor(spectrumLength / N);\n\n var linearAverages = new Array(N);\n // Keep a second index for the current average group and place the values accordingly\n // with only one loop in the spectrum data\n var groupIndex = 0;\n\n for (var specIndex = 0; specIndex < spectrumLength; specIndex++) {\n linearAverages[groupIndex] =\n linearAverages[groupIndex] !== undefined\n ? (linearAverages[groupIndex] + spectrum[specIndex]) / 2\n : spectrum[specIndex];\n\n // Increase the group index when the last element of the group is processed\n if (specIndex % spectrumStep === spectrumStep - 1) {\n groupIndex++;\n }\n }\n\n return linearAverages;\n };\n\n /**\n * Returns an array of average amplitude values of the spectrum, for a given\n * set of \n * Octave Bands\n * NOTE: analyze() must be called prior to logAverages(). Analyze()\n * tells the FFT to analyze frequency data, and logAverages() uses\n * the results to group them into a smaller set of averages.

\n *\n * @method logAverages\n * @for p5.FFT\n * @param {Array} octaveBands Array of Octave Bands objects for grouping\n * @return {Array} logAverages Array of average amplitude values for each group\n */\n p5.FFT.prototype.logAverages = function(octaveBands) {\n var nyquist = p5sound.audiocontext.sampleRate / 2;\n var spectrum = this.freqDomain;\n var spectrumLength = spectrum.length;\n\n var logAverages = new Array(octaveBands.length);\n // Keep a second index for the current average group and place the values accordingly\n // With only one loop in the spectrum data\n var octaveIndex = 0;\n\n for (var specIndex = 0; specIndex < spectrumLength; specIndex++) {\n var specIndexFrequency = Math.round(\n specIndex * nyquist / this.freqDomain.length\n );\n\n // Increase the group index if the current frequency exceeds the limits of the band\n if (specIndexFrequency > octaveBands[octaveIndex].hi) {\n octaveIndex++;\n }\n\n logAverages[octaveIndex] =\n logAverages[octaveIndex] !== undefined\n ? (logAverages[octaveIndex] + spectrum[specIndex]) / 2\n : spectrum[specIndex];\n }\n\n return logAverages;\n };\n\n /**\n * Calculates and Returns the 1/N\n * Octave Bands\n * N defaults to 3 and minimum central frequency to 15.625Hz.\n * (1/3 Octave Bands ~= 31 Frequency Bands)\n * Setting fCtr0 to a central value of a higher octave will ignore the lower bands\n * and produce less frequency groups.\n *\n * @method getOctaveBands\n * @for p5.FFT\n * @param {Number} N Specifies the 1/N type of generated octave bands\n * @param {Number} fCtr0 Minimum central frequency for the lowest band\n * @return {Array} octaveBands Array of octave band objects with their bounds\n */\n p5.FFT.prototype.getOctaveBands = function(N, fCtr0) {\n var N = N || 3; // Default to 1/3 Octave Bands\n var fCtr0 = fCtr0 || 15.625; // Minimum central frequency, defaults to 15.625Hz\n\n var octaveBands = [];\n var lastFrequencyBand = {\n lo: fCtr0 / Math.pow(2, 1 / (2 * N)),\n ctr: fCtr0,\n hi: fCtr0 * Math.pow(2, 1 / (2 * N))\n };\n octaveBands.push(lastFrequencyBand);\n\n var nyquist = p5sound.audiocontext.sampleRate / 2;\n while (lastFrequencyBand.hi < nyquist) {\n var newFrequencyBand = {};\n newFrequencyBand.lo = lastFrequencyBand.hi;\n newFrequencyBand.ctr = lastFrequencyBand.ctr * Math.pow(2, 1 / N);\n newFrequencyBand.hi = newFrequencyBand.ctr * Math.pow(2, 1 / (2 * N));\n\n octaveBands.push(newFrequencyBand);\n lastFrequencyBand = newFrequencyBand;\n }\n\n return octaveBands;\n };\n\n // helper methods to convert type from float (dB) to int (0-255)\n var freqToFloat = function(fft) {\n if (fft.freqDomain instanceof Float32Array === false) {\n fft.freqDomain = new Float32Array(fft.analyser.frequencyBinCount);\n }\n };\n var freqToInt = function(fft) {\n if (fft.freqDomain instanceof Uint8Array === false) {\n fft.freqDomain = new Uint8Array(fft.analyser.frequencyBinCount);\n }\n };\n var timeToFloat = function(fft) {\n if (fft.timeDomain instanceof Float32Array === false) {\n fft.timeDomain = new Float32Array(fft.analyser.frequencyBinCount);\n }\n };\n var timeToInt = function(fft) {\n if (fft.timeDomain instanceof Uint8Array === false) {\n fft.timeDomain = new Uint8Array(fft.analyser.frequencyBinCount);\n }\n };\n});\n","'use strict';\n\ndefine(function (require) {\n\n // Signal is built with the Tone.js signal by Yotam Mann\n // https://github.com/TONEnoTONE/Tone.js/\n var Signal = require('Tone/signal/Signal');\n var Add = require('Tone/signal/Add');\n var Mult = require('Tone/signal/Multiply');\n var Scale = require('Tone/signal/Scale');\n\n /**\n *

p5.Signal is a constant audio-rate signal used by p5.Oscillator\n * and p5.Envelope for modulation math.

\n *\n *

This is necessary because Web Audio is processed on a seprate clock.\n * For example, the p5 draw loop runs about 60 times per second. But\n * the audio clock must process samples 44100 times per second. If we\n * want to add a value to each of those samples, we can't do it in the\n * draw loop, but we can do it by adding a constant-rate audio signal.This class mostly functions behind the scenes in p5.sound, and returns\n * a Tone.Signal from the Tone.js library by Yotam Mann.\n * If you want to work directly with audio signals for modular\n * synthesis, check out\n * tone.js.

\n *\n * @class p5.Signal\n * @constructor\n * @return {Tone.Signal} A Signal object from the Tone.js library\n * @example\n *
\n * let carrier, modulator;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * text('tap to play', 20, 20);\n *\n * carrier = new p5.Oscillator('sine');\n * carrier.start();\n * carrier.amp(1); // set amplitude\n * carrier.freq(220); // set frequency\n *\n * modulator = new p5.Oscillator('sawtooth');\n * modulator.disconnect();\n * modulator.start();\n * modulator.amp(1);\n * modulator.freq(4);\n *\n * // Modulator's default amplitude range is -1 to 1.\n * // Multiply it by -200, so the range is -200 to 200\n * // then add 220 so the range is 20 to 420\n * carrier.freq( modulator.mult(-400).add(220) );\n * }\n *\n * function canvasPressed() {\n * userStartAudio();\n * carrier.amp(1.0);\n * }\n *\n * function mouseReleased() {\n * carrier.amp(0);\n * }\n *
\n */\n p5.Signal = function(value) {\n var s = new Signal(value);\n // p5sound.soundArray.push(s);\n return s; // TODO: is this really a constructor?\n };\n\n /**\n * Fade to value, for smooth transitions\n *\n * @method fade\n * @for p5.Signal\n * @param {Number} value Value to set this signal\n * @param {Number} [secondsFromNow] Length of fade, in seconds from now\n */\n Signal.prototype.fade = Signal.prototype.linearRampToValueAtTime;\n Mult.prototype.fade = Signal.prototype.fade;\n Add.prototype.fade = Signal.prototype.fade;\n Scale.prototype.fade = Signal.prototype.fade;\n\n\n /**\n * Connect a p5.sound object or Web Audio node to this\n * p5.Signal so that its amplitude values can be scaled.\n *\n * @method setInput\n * @for p5.Signal\n * @param {Object} input\n */\n Signal.prototype.setInput = function(_input) {\n _input.connect(this);\n };\n Mult.prototype.setInput = Signal.prototype.setInput;\n Add.prototype.setInput = Signal.prototype.setInput;\n Scale.prototype.setInput = Signal.prototype.setInput;\n\n\n // signals can add / mult / scale themselves\n\n /**\n * Add a constant value to this audio signal,\n * and return the resulting audio signal. Does\n * not change the value of the original signal,\n * instead it returns a new p5.SignalAdd.\n *\n * @method add\n * @for p5.Signal\n * @param {Number} number\n * @return {p5.Signal} object\n */\n Signal.prototype.add = function(num) {\n var add = new Add(num);\n // add.setInput(this);\n this.connect(add);\n return add;\n };\n Mult.prototype.add = Signal.prototype.add;\n Add.prototype.add = Signal.prototype.add;\n Scale.prototype.add = Signal.prototype.add;\n\n /**\n * Multiply this signal by a constant value,\n * and return the resulting audio signal. Does\n * not change the value of the original signal,\n * instead it returns a new p5.SignalMult.\n *\n * @method mult\n * @for p5.Signal\n * @param {Number} number to multiply\n * @return {p5.Signal} object\n */\n Signal.prototype.mult = function(num) {\n var mult = new Mult(num);\n // mult.setInput(this);\n this.connect(mult);\n return mult;\n };\n Mult.prototype.mult = Signal.prototype.mult;\n Add.prototype.mult = Signal.prototype.mult;\n Scale.prototype.mult = Signal.prototype.mult;\n\n /**\n * Scale this signal value to a given range,\n * and return the result as an audio signal. Does\n * not change the value of the original signal,\n * instead it returns a new p5.SignalScale.\n *\n * @method scale\n * @for p5.Signal\n * @param {Number} number to multiply\n * @param {Number} inMin input range minumum\n * @param {Number} inMax input range maximum\n * @param {Number} outMin input range minumum\n * @param {Number} outMax input range maximum\n * @return {p5.Signal} object\n */\n Signal.prototype.scale = function(inMin, inMax, outMin, outMax) {\n var mapOutMin, mapOutMax;\n if (arguments.length === 4) {\n mapOutMin = p5.prototype.map(outMin, inMin, inMax, 0, 1) - 0.5;\n mapOutMax = p5.prototype.map(outMax, inMin, inMax, 0, 1) - 0.5;\n }\n else {\n mapOutMin = arguments[0];\n mapOutMax = arguments[1];\n }\n var scale = new Scale(mapOutMin, mapOutMax);\n this.connect(scale);\n return scale;\n };\n Mult.prototype.scale = Signal.prototype.scale;\n Add.prototype.scale = Signal.prototype.scale;\n Scale.prototype.scale = Signal.prototype.scale;\n\n});\n\n\n","define([\"Tone/core/Tone\", \"Tone/type/TimeBase\"], function (Tone) {\n\n\t/**\n\t * @class Tone.Frequency is a primitive type for encoding Frequency values. \n\t * Eventually all time values are evaluated to hertz\n\t * using the `eval` method. \n\t * @constructor\n\t * @extends {Tone.TimeBase}\n\t * @param {String|Number} val The time value.\n\t * @param {String=} units The units of the value.\n\t * @example\n\t * Tone.Frequency(\"C3\") // 261\n\t * Tone.Frequency(38, \"midi\") //\n\t * Tone.Frequency(\"C3\").transpose(4);\n\t */\n\tTone.Frequency = function(val, units){\n\t\tif (this instanceof Tone.Frequency){\n\t\t\t\n\t\t\tTone.TimeBase.call(this, val, units);\n\n\t\t} else {\n\t\t\treturn new Tone.Frequency(val, units);\n\t\t}\n\t};\n\n\tTone.extend(Tone.Frequency, Tone.TimeBase);\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tAUGMENT BASE EXPRESSIONS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t//clone the expressions so that \n\t//we can add more without modifying the original\n\tTone.Frequency.prototype._primaryExpressions = Object.create(Tone.TimeBase.prototype._primaryExpressions);\n\n\t/*\n\t * midi type primary expression\n\t * @type {Object}\n\t * @private\n\t */\n\tTone.Frequency.prototype._primaryExpressions.midi = {\n\t\tregexp : /^(\\d+(?:\\.\\d+)?midi)/,\n\t\tmethod : function(value){\n\t\t\treturn this.midiToFrequency(value);\n\t\t}\t\n\t};\n\n\t/*\n\t * note type primary expression\n\t * @type {Object}\n\t * @private\n\t */\n\tTone.Frequency.prototype._primaryExpressions.note = {\n\t\tregexp : /^([a-g]{1}(?:b|#|x|bb)?)(-?[0-9]+)/i,\n\t\tmethod : function(pitch, octave){\n\t\t\tvar index = noteToScaleIndex[pitch.toLowerCase()];\n\t\t\tvar noteNumber = index + (parseInt(octave) + 1) * 12;\n\t\t\treturn this.midiToFrequency(noteNumber);\n\t\t}\t\n\t};\n\n\t/*\n\t * BeatsBarsSixteenths type primary expression\n\t * @type {Object}\n\t * @private\n\t */\n\tTone.Frequency.prototype._primaryExpressions.tr = {\n\t\t\tregexp : /^(\\d+(?:\\.\\d+)?):(\\d+(?:\\.\\d+)?):?(\\d+(?:\\.\\d+)?)?/,\n\t\t\tmethod : function(m, q, s){\n\t\t\tvar total = 1;\n\t\t\tif (m && m !== \"0\"){\n\t\t\t\ttotal *= this._beatsToUnits(this._timeSignature() * parseFloat(m));\n\t\t\t}\n\t\t\tif (q && q !== \"0\"){\n\t\t\t\ttotal *= this._beatsToUnits(parseFloat(q));\n\t\t\t}\n\t\t\tif (s && s !== \"0\"){\n\t\t\t\ttotal *= this._beatsToUnits(parseFloat(s) / 4);\n\t\t\t}\n\t\t\treturn total;\n\t\t}\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tEXPRESSIONS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Transposes the frequency by the given number of semitones.\n\t * @param {Interval} interval\n\t * @return {Tone.Frequency} this\n\t * @example\n\t * Tone.Frequency(\"A4\").transpose(3); //\"C5\"\n\t */\n\tTone.Frequency.prototype.transpose = function(interval){\n\t\tthis._expr = function(expr, interval){\n\t\t\tvar val = expr();\n\t\t\treturn val * this.intervalToFrequencyRatio(interval);\n\t\t}.bind(this, this._expr, interval);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Takes an array of semitone intervals and returns\n\t * an array of frequencies transposed by those intervals.\n\t * @param {Array} intervals\n\t * @return {Tone.Frequency} this\n\t * @example\n\t * Tone.Frequency(\"A4\").harmonize([0, 3, 7]); //[\"A4\", \"C5\", \"E5\"]\n\t */\n\tTone.Frequency.prototype.harmonize = function(intervals){\n\t\tthis._expr = function(expr, intervals){\n\t\t\tvar val = expr();\n\t\t\tvar ret = [];\n\t\t\tfor (var i = 0; i < intervals.length; i++){\n\t\t\t\tret[i] = val * this.intervalToFrequencyRatio(intervals[i]);\n\t\t\t}\n\t\t\treturn ret;\n\t\t}.bind(this, this._expr, intervals);\n\t\treturn this;\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tUNIT CONVERSIONS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Return the value of the frequency as a MIDI note\n\t * @return {MIDI}\n\t * @example\n\t * Tone.Frequency(\"C4\").toMidi(); //60\n\t */\n\tTone.Frequency.prototype.toMidi = function(){\n\t\treturn this.frequencyToMidi(this.valueOf());\n\t};\n\n\t/**\n\t * Return the value of the frequency in Scientific Pitch Notation\n\t * @return {Note}\n\t * @example\n\t * Tone.Frequency(69, \"midi\").toNote(); //\"A4\"\n\t */\n\tTone.Frequency.prototype.toNote = function(){\n\t\tvar freq = this.valueOf();\n\t\tvar log = Math.log(freq / Tone.Frequency.A4) / Math.LN2;\n\t\tvar noteNumber = Math.round(12 * log) + 57;\n\t\tvar octave = Math.floor(noteNumber/12);\n\t\tif(octave < 0){\n\t\t\tnoteNumber += -12 * octave;\n\t\t}\n\t\tvar noteName = scaleIndexToNote[noteNumber % 12];\n\t\treturn noteName + octave.toString();\n\t};\n\n\t/**\n\t * Return the duration of one cycle in seconds.\n\t * @return {Seconds}\n\t */\n\tTone.Frequency.prototype.toSeconds = function(){\n\t\treturn 1 / this.valueOf();\n\t};\n\n\t/**\n\t * Return the value in Hertz\n\t * @return {Frequency}\n\t */\n\tTone.Frequency.prototype.toFrequency = function(){\n\t\treturn this.valueOf();\n\t};\n\n\t/**\n\t * Return the duration of one cycle in ticks\n\t * @return {Ticks}\n\t */\n\tTone.Frequency.prototype.toTicks = function(){\n\t\tvar quarterTime = this._beatsToUnits(1);\n\t\tvar quarters = this.valueOf() / quarterTime;\n\t\treturn Math.floor(quarters * Tone.Transport.PPQ);\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tUNIT CONVERSIONS HELPERS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Returns the value of a frequency in the current units\n\t * @param {Frequency} freq\n\t * @return {Number}\n\t * @private\n\t */\n\tTone.Frequency.prototype._frequencyToUnits = function(freq){\n\t\treturn freq;\n\t};\n\n\t/**\n\t * Returns the value of a tick in the current time units\n\t * @param {Ticks} ticks\n\t * @return {Number}\n\t * @private\n\t */\n\tTone.Frequency.prototype._ticksToUnits = function(ticks){\n\t\treturn 1 / ((ticks * 60) / (Tone.Transport.bpm.value * Tone.Transport.PPQ));\n\t};\n\n\t/**\n\t * Return the value of the beats in the current units\n\t * @param {Number} beats\n\t * @return {Number}\n\t * @private\n\t */\n\tTone.Frequency.prototype._beatsToUnits = function(beats){\n\t\treturn 1 / Tone.TimeBase.prototype._beatsToUnits.call(this, beats);\n\t};\n\n\t/**\n\t * Returns the value of a second in the current units\n\t * @param {Seconds} seconds\n\t * @return {Number}\n\t * @private\n\t */\n\tTone.Frequency.prototype._secondsToUnits = function(seconds){\n\t\treturn 1 / seconds;\n\t};\n\n\t/**\n\t * The default units if none are given.\n\t * @private\n\t */\n\tTone.Frequency.prototype._defaultUnits = \"hz\";\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tFREQUENCY CONVERSIONS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Note to scale index\n\t * @type {Object}\n\t */\n\tvar noteToScaleIndex = {\n\t\t\"cbb\" : -2, \"cb\" : -1, \"c\" : 0, \"c#\" : 1, \"cx\" : 2, \n\t\t\"dbb\" : 0, \"db\" : 1, \"d\" : 2, \"d#\" : 3, \"dx\" : 4,\n\t\t\"ebb\" : 2, \"eb\" : 3, \"e\" : 4, \"e#\" : 5, \"ex\" : 6, \n\t\t\"fbb\" : 3, \"fb\" : 4, \"f\" : 5, \"f#\" : 6, \"fx\" : 7,\n\t\t\"gbb\" : 5, \"gb\" : 6, \"g\" : 7, \"g#\" : 8, \"gx\" : 9,\n\t\t\"abb\" : 7, \"ab\" : 8, \"a\" : 9, \"a#\" : 10, \"ax\" : 11,\n\t\t\"bbb\" : 9, \"bb\" : 10, \"b\" : 11, \"b#\" : 12, \"bx\" : 13,\n\t};\n\n\t/**\n\t * scale index to note (sharps)\n\t * @type {Array}\n\t */\n\tvar scaleIndexToNote = [\"C\", \"C#\", \"D\", \"D#\", \"E\", \"F\", \"F#\", \"G\", \"G#\", \"A\", \"A#\", \"B\"];\n\n\t/**\n\t * The [concert pitch](https://en.wikipedia.org/wiki/Concert_pitch)\n\t * A4's values in Hertz. \n\t * @type {Frequency}\n\t * @static\n\t */\n\tTone.Frequency.A4 = 440;\n\n\t/**\n\t * Convert a MIDI note to frequency value. \n\t * @param {MIDI} midi The midi number to convert.\n\t * @return {Frequency} the corresponding frequency value\n\t * @example\n\t * tone.midiToFrequency(69); // returns 440\n\t */\n\tTone.Frequency.prototype.midiToFrequency = function(midi){\n\t\treturn Tone.Frequency.A4 * Math.pow(2, (midi - 69) / 12);\n\t};\n\n\t/**\n\t * Convert a frequency value to a MIDI note.\n\t * @param {Frequency} frequency The value to frequency value to convert.\n\t * @returns {MIDI}\n\t * @example\n\t * tone.midiToFrequency(440); // returns 69\n\t */\n\tTone.Frequency.prototype.frequencyToMidi = function(frequency){\n\t\treturn 69 + 12 * Math.log(frequency / Tone.Frequency.A4) / Math.LN2;\n\t};\n\n\treturn Tone.Frequency;\n});","define([\"Tone/core/Tone\", \"Tone/type/Time\"], function (Tone) {\n\n\t/**\n\t * @class Tone.TransportTime is a the time along the Transport's\n\t * timeline. It is similar to Tone.Time, but instead of evaluating\n\t * against the AudioContext's clock, it is evaluated against\n\t * the Transport's position. See [TransportTime wiki](https://github.com/Tonejs/Tone.js/wiki/TransportTime).\n\t * @constructor\n\t * @param {Time} val The time value as a number or string\n\t * @param {String=} units Unit values\n\t * @extends {Tone.Time}\n\t */\n\tTone.TransportTime = function(val, units){\n\t\tif (this instanceof Tone.TransportTime){\n\t\t\t\n\t\t\tTone.Time.call(this, val, units);\n\n\t\t} else {\n\t\t\treturn new Tone.TransportTime(val, units);\n\t\t}\n\t};\n\n\tTone.extend(Tone.TransportTime, Tone.Time);\n\n\t//clone the expressions so that \n\t//we can add more without modifying the original\n\tTone.TransportTime.prototype._unaryExpressions = Object.create(Tone.Time.prototype._unaryExpressions);\n\n\t/**\n\t * Adds an additional unary expression\n\t * which quantizes values to the next subdivision\n\t * @type {Object}\n\t * @private\n\t */\n\tTone.TransportTime.prototype._unaryExpressions.quantize = {\n\t\tregexp : /^@/,\n\t\tmethod : function(rh){\n\t\t\tvar subdivision = this._secondsToTicks(rh());\n\t\t\tvar multiple = Math.ceil(Tone.Transport.ticks / subdivision);\n\t\t\treturn this._ticksToUnits(multiple * subdivision);\n\t\t}\n\t};\n\n\t/**\n\t * Convert seconds into ticks\n\t * @param {Seconds} seconds\n\t * @return {Ticks}\n\t * @private\n\t */\n\tTone.TransportTime.prototype._secondsToTicks = function(seconds){\n\t\tvar quarterTime = this._beatsToUnits(1);\n\t\tvar quarters = seconds / quarterTime;\n\t\treturn Math.round(quarters * Tone.Transport.PPQ);\n\t};\n\n\t/**\n\t * Evaluate the time expression. Returns values in ticks\n\t * @return {Ticks}\n\t */\n\tTone.TransportTime.prototype.valueOf = function(){\n\t\tvar val = this._secondsToTicks(this._expr());\n\t\treturn val + (this._plusNow ? Tone.Transport.ticks : 0);\n\t};\n\n\t/**\n\t * Return the time in ticks.\n\t * @return {Ticks}\n\t */\n\tTone.TransportTime.prototype.toTicks = function(){\n\t\treturn this.valueOf();\n\t};\n\n\t/**\n\t * Return the time in seconds.\n\t * @return {Seconds}\n\t */\n\tTone.TransportTime.prototype.toSeconds = function(){\n\t\tvar val = this._expr();\n\t\treturn val + (this._plusNow ? Tone.Transport.seconds : 0);\n\t};\n\n\t/**\n\t * Return the time as a frequency value\n\t * @return {Frequency} \n\t */\n\tTone.TransportTime.prototype.toFrequency = function(){\n\t\treturn 1/this.toSeconds();\n\t};\n\n\treturn Tone.TransportTime;\n});","'use strict';\n\ndefine(function (require) {\n\n var p5sound = require('master');\n var Add = require('Tone/signal/Add');\n var Mult = require('Tone/signal/Multiply');\n var Scale = require('Tone/signal/Scale');\n var TimelineSignal = require('Tone/signal/TimelineSignal');\n\n /**\n *

Envelopes are pre-defined amplitude distribution over time.\n * Typically, envelopes are used to control the output volume\n * of an object, a series of fades referred to as Attack, Decay,\n * Sustain and Release (\n * ADSR\n * ). Envelopes can also control other Web Audio Parameters—for example, a p5.Envelope can\n * control an Oscillator's frequency like this: osc.freq(env).

\n *

Use setRange to change the attack/release level.\n * Use setADSR to change attackTime, decayTime, sustainPercent and releaseTime.

\n *

Use the play method to play the entire envelope,\n * the ramp method for a pingable trigger,\n * or triggerAttack/\n * triggerRelease to trigger noteOn/noteOff.

\n *\n * @class p5.Envelope\n * @constructor\n * @example\n *
\n * let t1 = 0.1; // attack time in seconds\n * let l1 = 0.7; // attack level 0.0 to 1.0\n * let t2 = 0.3; // decay time in seconds\n * let l2 = 0.1; // decay level 0.0 to 1.0\n *\n * let env;\n * let triOsc;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * background(220);\n * text('tap to play', 20, 20);\n * cnv.mousePressed(playSound);\n *\n * env = new p5.Envelope(t1, l1, t2, l2);\n * triOsc = new p5.Oscillator('triangle');\n * }\n *\n * function playSound() {\n * // starting the oscillator ensures that audio is enabled.\n * triOsc.start();\n * env.play(triOsc);\n * }\n *
\n */\n p5.Envelope = function(t1, l1, t2, l2, t3, l3) {\n /**\n * Time until envelope reaches attackLevel\n * @property attackTime\n */\n this.aTime = t1 || 0.1;\n /**\n * Level once attack is complete.\n * @property attackLevel\n */\n this.aLevel = l1 || 1;\n /**\n * Time until envelope reaches decayLevel.\n * @property decayTime\n */\n this.dTime = t2 || 0.5;\n /**\n * Level after decay. The envelope will sustain here until it is released.\n * @property decayLevel\n */\n this.dLevel = l2 || 0;\n /**\n * Duration of the release portion of the envelope.\n * @property releaseTime\n */\n this.rTime = t3 || 0;\n /**\n * Level at the end of the release.\n * @property releaseLevel\n */\n this.rLevel = l3 || 0;\n\n this._rampHighPercentage = 0.98;\n\n this._rampLowPercentage = 0.02;\n\n\n this.output = p5sound.audiocontext.createGain();\n\n this.control = new TimelineSignal();\n\n this._init(); // this makes sure the envelope starts at zero\n\n this.control.connect(this.output); // connect to the output\n\n this.connection = null; // store connection\n\n //array of math operation signal chaining\n this.mathOps = [this.control];\n\n //whether envelope should be linear or exponential curve\n this.isExponential = false;\n\n // oscillator or buffer source to clear on env complete\n // to save resources if/when it is retriggered\n this.sourceToClear = null;\n\n // set to true if attack is set, then false on release\n this.wasTriggered = false;\n\n\n // add to the soundArray so we can dispose of the env later\n p5sound.soundArray.push(this);\n };\n\n // this init function just smooths the starting value to zero and gives a start point for the timeline\n // - it was necessary to remove glitches at the beginning.\n p5.Envelope.prototype._init = function () {\n var now = p5sound.audiocontext.currentTime;\n var t = now;\n this.control.setTargetAtTime(0.00001, t, .001);\n //also, compute the correct time constants\n this._setRampAD(this.aTime, this.dTime);\n };\n\n /**\n * Reset the envelope with a series of time/value pairs.\n *\n * @method set\n * @for p5.Envelope\n * @param {Number} attackTime Time (in seconds) before level\n * reaches attackLevel\n * @param {Number} attackLevel Typically an amplitude between\n * 0.0 and 1.0\n * @param {Number} decayTime Time\n * @param {Number} decayLevel Amplitude (In a standard ADSR envelope,\n * decayLevel = sustainLevel)\n * @param {Number} releaseTime Release Time (in seconds)\n * @param {Number} releaseLevel Amplitude\n * @example\n *
\n * let attackTime;\n * let l1 = 0.7; // attack level 0.0 to 1.0\n * let t2 = 0.3; // decay time in seconds\n * let l2 = 0.1; // decay level 0.0 to 1.0\n * let l3 = 0.2; // release time in seconds\n *\n * let env, triOsc;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playSound);\n *\n * env = new p5.Envelope();\n * triOsc = new p5.Oscillator('triangle');\n * }\n *\n * function draw() {\n * background(220);\n * text('tap here to play', 5, 20);\n *\n * attackTime = map(mouseX, 0, width, 0.0, 1.0);\n * text('attack time: ' + attackTime, 5, height - 20);\n * }\n *\n * // mouseClick triggers envelope if over canvas\n * function playSound() {\n * env.set(attackTime, l1, t2, l2, l3);\n *\n * triOsc.start();\n * env.play(triOsc);\n * }\n *
\n *\n */\n p5.Envelope.prototype.set = function(t1, l1, t2, l2, t3, l3) {\n this.aTime = t1;\n this.aLevel = l1;\n this.dTime = t2 || 0;\n this.dLevel = l2 || 0;\n this.rTime = t3 || 0;\n this.rLevel = l3 || 0;\n\n // set time constants for ramp\n this._setRampAD(t1, t2);\n };\n\n /**\n * Set values like a traditional\n * \n * ADSR envelope\n * .\n *\n * @method setADSR\n * @for p5.Envelope\n * @param {Number} attackTime Time (in seconds before envelope\n * reaches Attack Level\n * @param {Number} [decayTime] Time (in seconds) before envelope\n * reaches Decay/Sustain Level\n * @param {Number} [susRatio] Ratio between attackLevel and releaseLevel, on a scale from 0 to 1,\n * where 1.0 = attackLevel, 0.0 = releaseLevel.\n * The susRatio determines the decayLevel and the level at which the\n * sustain portion of the envelope will sustain.\n * For example, if attackLevel is 0.4, releaseLevel is 0,\n * and susAmt is 0.5, the decayLevel would be 0.2. If attackLevel is\n * increased to 1.0 (using setRange),\n * then decayLevel would increase proportionally, to become 0.5.\n * @param {Number} [releaseTime] Time in seconds from now (defaults to 0)\n * @example\n *
\n * let attackLevel = 1.0;\n * let releaseLevel = 0;\n *\n * let attackTime = 0.001;\n * let decayTime = 0.2;\n * let susPercent = 0.2;\n * let releaseTime = 0.5;\n *\n * let env, triOsc;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playEnv);\n *\n * env = new p5.Envelope();\n * triOsc = new p5.Oscillator('triangle');\n * triOsc.amp(env);\n * triOsc.freq(220);\n * }\n *\n * function draw() {\n * background(220);\n * text('tap here to play', 5, 20);\n * attackTime = map(mouseX, 0, width, 0, 1.0);\n * text('attack time: ' + attackTime, 5, height - 40);\n * }\n *\n * function playEnv() {\n * triOsc.start();\n * env.setADSR(attackTime, decayTime, susPercent, releaseTime);\n * env.play();\n * }\n *
\n */\n p5.Envelope.prototype.setADSR = function(aTime, dTime, sPercent, rTime) {\n this.aTime = aTime;\n this.dTime = dTime || 0;\n\n // lerp\n this.sPercent = sPercent || 0;\n this.dLevel = typeof sPercent !== 'undefined' ? sPercent * (this.aLevel - this.rLevel) + this.rLevel : 0;\n\n this.rTime = rTime || 0;\n\n // also set time constants for ramp\n this._setRampAD(aTime, dTime);\n };\n\n /**\n * Set max (attackLevel) and min (releaseLevel) of envelope.\n *\n * @method setRange\n * @for p5.Envelope\n * @param {Number} aLevel attack level (defaults to 1)\n * @param {Number} rLevel release level (defaults to 0)\n * @example\n *
\n * let attackLevel = 1.0;\n * let releaseLevel = 0;\n *\n * let attackTime = 0.001;\n * let decayTime = 0.2;\n * let susPercent = 0.2;\n * let releaseTime = 0.5;\n *\n * let env, triOsc;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playEnv);\n *\n * env = new p5.Envelope();\n * triOsc = new p5.Oscillator('triangle');\n * triOsc.amp(env);\n * triOsc.freq(220);\n * }\n *\n * function draw() {\n * background(220);\n * text('tap here to play', 5, 20);\n * attackLevel = map(mouseY, height, 0, 0, 1.0);\n * text('attack level: ' + attackLevel, 5, height - 20);\n * }\n *\n * function playEnv() {\n * triOsc.start();\n * env.setRange(attackLevel, releaseLevel);\n * env.play();\n * }\n *
\n */\n p5.Envelope.prototype.setRange = function(aLevel, rLevel) {\n this.aLevel = aLevel || 1;\n this.rLevel = rLevel || 0;\n\n // not sure if this belongs here:\n\n // {Number} [dLevel] decay/sustain level (optional)\n // if (typeof(dLevel) !== 'undefined') {\n // this.dLevel = dLevel\n // } else if (this.sPercent) {\n // this.dLevel = this.sPercent ? this.sPercent * (this.aLevel - this.rLevel) + this.rLevel : 0;\n // }\n };\n\n // private (undocumented) method called when ADSR is set to set time constants for ramp\n //\n // Set the \n // time constants for simple exponential ramps.\n // The larger the time constant value, the slower the\n // transition will be.\n //\n // method _setRampAD\n // param {Number} attackTimeConstant attack time constant\n // param {Number} decayTimeConstant decay time constant\n //\n p5.Envelope.prototype._setRampAD = function(t1, t2) {\n this._rampAttackTime = this.checkExpInput(t1);\n this._rampDecayTime = this.checkExpInput(t2);\n\n var TCDenominator = 1.0;\n /// Aatish Bhatia's calculation for time constant for rise(to adjust 1/1-e calculation to any percentage)\n TCDenominator = Math.log(1.0 / this.checkExpInput(1.0 - this._rampHighPercentage));\n this._rampAttackTC = t1 / this.checkExpInput(TCDenominator);\n TCDenominator = Math.log(1.0 / this._rampLowPercentage);\n this._rampDecayTC = t2 / this.checkExpInput(TCDenominator);\n };\n\n // private method\n p5.Envelope.prototype.setRampPercentages = function(p1, p2) {\n //set the percentages that the simple exponential ramps go to\n this._rampHighPercentage = this.checkExpInput(p1);\n this._rampLowPercentage = this.checkExpInput(p2);\n var TCDenominator = 1.0;\n //now re-compute the time constants based on those percentages\n /// Aatish Bhatia's calculation for time constant for rise(to adjust 1/1-e calculation to any percentage)\n TCDenominator = Math.log(1.0 / this.checkExpInput(1.0 - this._rampHighPercentage));\n this._rampAttackTC = this._rampAttackTime / this.checkExpInput(TCDenominator);\n TCDenominator = Math.log(1.0 / this._rampLowPercentage);\n this._rampDecayTC = this._rampDecayTime / this.checkExpInput(TCDenominator);\n };\n\n\n /**\n * Assign a parameter to be controlled by this envelope.\n * If a p5.Sound object is given, then the p5.Envelope will control its\n * output gain. If multiple inputs are provided, the env will\n * control all of them.\n *\n * @method setInput\n * @for p5.Envelope\n * @param {Object} [...inputs] A p5.sound object or\n * Web Audio Param.\n */\n p5.Envelope.prototype.setInput = function() {\n for (var i = 0; iPlay tells the envelope to start acting on a given input.\n * If the input is a p5.sound object (i.e. AudioIn, Oscillator,\n * SoundFile), then Envelope will control its output volume.\n * Envelopes can also be used to control any \n * Web Audio Audio Param.

\n *\n * @method play\n * @for p5.Envelope\n * @param {Object} unit A p5.sound object or\n * Web Audio Param.\n * @param {Number} [startTime] time from now (in seconds) at which to play\n * @param {Number} [sustainTime] time to sustain before releasing the envelope\n * @example\n *
\n * let attackLevel = 1.0;\n * let releaseLevel = 0;\n *\n * let attackTime = 0.001;\n * let decayTime = 0.2;\n * let susPercent = 0.2;\n * let releaseTime = 0.5;\n *\n * let env, triOsc;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playEnv);\n *\n * env = new p5.Envelope();\n * triOsc = new p5.Oscillator('triangle');\n * triOsc.amp(env);\n * triOsc.freq(220);\n * triOsc.start();\n * }\n *\n * function draw() {\n * background(220);\n * text('tap here to play', 5, 20);\n * attackTime = map(mouseX, 0, width, 0, 1.0);\n * attackLevel = map(mouseY, height, 0, 0, 1.0);\n * text('attack time: ' + attackTime, 5, height - 40);\n * text('attack level: ' + attackLevel, 5, height - 20);\n * }\n *\n * function playEnv() {\n * // ensure that audio is enabled\n * userStartAudio();\n *\n * env.setADSR(attackTime, decayTime, susPercent, releaseTime);\n * env.setRange(attackLevel, releaseLevel);\n * env.play();\n * }\n *
\n */\n p5.Envelope.prototype.play = function(unit, secondsFromNow, susTime) {\n var tFromNow = secondsFromNow || 0;\n var susTime = susTime || 0;\n\n if (unit) {\n if (this.connection !== unit) {\n this.connect(unit);\n }\n }\n\n this.triggerAttack(unit, tFromNow);\n\n this.triggerRelease(unit, tFromNow + this.aTime + this.dTime + susTime);\n\n };\n\n /**\n * Trigger the Attack, and Decay portion of the Envelope.\n * Similar to holding down a key on a piano, but it will\n * hold the sustain level until you let go. Input can be\n * any p5.sound object, or a \n * Web Audio Param.\n *\n * @method triggerAttack\n * @for p5.Envelope\n * @param {Object} unit p5.sound Object or Web Audio Param\n * @param {Number} secondsFromNow time from now (in seconds)\n * @example\n *
\n * let attackTime = 0.001;\n * let decayTime = 0.2;\n * let susPercent = 0.3;\n * let releaseTime = 0.4;\n * let env, triOsc;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * background(220);\n * textAlign(CENTER);\n * textSize(10);\n * text('tap to triggerAttack', width/2, height/2);\n *\n * env = new p5.Envelope();\n * env.setADSR(attackTime, decayTime, susPercent, releaseTime);\n * env.setRange(1.0, 0.0);\n * triOsc = new p5.Oscillator('triangle');\n * triOsc.freq(220);\n *\n * cnv.mousePressed(envAttack);\n * }\n *\n * function envAttack() {\n * background(0, 255, 255);\n * text('release to release', width/2, height/2);\n *\n * // ensures audio is enabled. See also: `userStartAudio`\n * triOsc.start();\n *\n * env.triggerAttack(triOsc);\n * }\n *\n * function mouseReleased() {\n * background(220);\n * text('tap to triggerAttack', width/2, height/2);\n *\n * env.triggerRelease(triOsc);\n * }\n *
\n */\n p5.Envelope.prototype.triggerAttack = function(unit, secondsFromNow) {\n var now = p5sound.audiocontext.currentTime;\n var tFromNow = secondsFromNow || 0;\n var t = now + tFromNow;\n this.lastAttack = t;\n this.wasTriggered = true;\n\n if (unit) {\n if (this.connection !== unit) {\n this.connect(unit);\n }\n }\n\n // get and set value (with linear ramp) to anchor automation\n var valToSet = this.control.getValueAtTime(t);\n\n if (this.isExponential === true)\n {\n this.control.exponentialRampToValueAtTime(this.checkExpInput(valToSet), t);\n }\n else\n {\n this.control.linearRampToValueAtTime(valToSet, t);\n }\n\n // after each ramp completes, cancel scheduled values\n // (so they can be overridden in case env has been re-triggered)\n // then, set current value (with linearRamp to avoid click)\n // then, schedule the next automation...\n\n // attack\n t += this.aTime;\n if (this.isExponential === true)\n {\n this.control.exponentialRampToValueAtTime(this.checkExpInput(this.aLevel), t);\n valToSet = this.checkExpInput(this.control.getValueAtTime(t));\n this.control.cancelScheduledValues(t);\n this.control.exponentialRampToValueAtTime(valToSet, t);\n }\n else\n {\n this.control.linearRampToValueAtTime(this.aLevel, t);\n valToSet = this.control.getValueAtTime(t);\n this.control.cancelScheduledValues(t);\n this.control.linearRampToValueAtTime(valToSet, t);\n\n }\n\n // decay to decay level (if using ADSR, then decay level == sustain level)\n t += this.dTime;\n if (this.isExponential === true)\n {\n this.control.exponentialRampToValueAtTime(this.checkExpInput(this.dLevel), t);\n valToSet = this.checkExpInput(this.control.getValueAtTime(t));\n this.control.cancelScheduledValues(t);\n this.control.exponentialRampToValueAtTime(valToSet, t);\n }\n else\n {\n this.control.linearRampToValueAtTime(this.dLevel, t);\n valToSet = this.control.getValueAtTime(t);\n this.control.cancelScheduledValues(t);\n this.control.linearRampToValueAtTime(valToSet, t);\n }\n };\n\n /**\n * Trigger the Release of the Envelope. This is similar to releasing\n * the key on a piano and letting the sound fade according to the\n * release level and release time.\n *\n * @method triggerRelease\n * @for p5.Envelope\n * @param {Object} unit p5.sound Object or Web Audio Param\n * @param {Number} secondsFromNow time to trigger the release\n * @example\n *
\n * let attackTime = 0.001;\n * let decayTime = 0.2;\n * let susPercent = 0.3;\n * let releaseTime = 0.4;\n * let env, triOsc;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * background(220);\n * textAlign(CENTER);\n * textSize(10);\n * text('tap to triggerAttack', width/2, height/2);\n *\n * env = new p5.Envelope();\n * env.setADSR(attackTime, decayTime, susPercent, releaseTime);\n * env.setRange(1.0, 0.0);\n * triOsc = new p5.Oscillator('triangle');\n * triOsc.freq(220);\n *\n * cnv.mousePressed(envAttack);\n * }\n *\n * function envAttack() {\n * background(0, 255, 255);\n * text('release to release', width/2, height/2);\n *\n * // ensures audio is enabled. See also: `userStartAudio`\n * triOsc.start();\n *\n * env.triggerAttack(triOsc);\n * }\n *\n * function mouseReleased() {\n * background(220);\n * text('tap to triggerAttack', width/2, height/2);\n *\n * env.triggerRelease(triOsc);\n * }\n *
\n */\n p5.Envelope.prototype.triggerRelease = function(unit, secondsFromNow) {\n\n // only trigger a release if an attack was triggered\n if (!this.wasTriggered) {\n // this currently causes a bit of trouble:\n // if a later release has been scheduled (via the play function)\n // a new earlier release won't interrupt it, because\n // this.wasTriggered has already been set to false.\n // If we want new earlier releases to override, then we need to\n // keep track of the last release time, and if the new release time is\n // earlier, then use it.\n return;\n }\n\n var now = p5sound.audiocontext.currentTime;\n var tFromNow = secondsFromNow || 0;\n var t = now + tFromNow;\n\n if (unit) {\n if (this.connection !== unit) {\n this.connect(unit);\n }\n }\n\n // get and set value (with linear or exponential ramp) to anchor automation\n var valToSet = this.control.getValueAtTime(t);\n\n if (this.isExponential === true)\n {\n this.control.exponentialRampToValueAtTime(this.checkExpInput(valToSet), t);\n }\n else\n {\n this.control.linearRampToValueAtTime(valToSet, t);\n }\n\n // release\n t += this.rTime;\n\n if (this.isExponential === true)\n {\n this.control.exponentialRampToValueAtTime(this.checkExpInput(this.rLevel), t);\n valToSet = this.checkExpInput(this.control.getValueAtTime(t));\n this.control.cancelScheduledValues(t);\n this.control.exponentialRampToValueAtTime(valToSet, t);\n }\n else\n {\n this.control.linearRampToValueAtTime(this.rLevel, t);\n valToSet = this.control.getValueAtTime(t);\n this.control.cancelScheduledValues(t);\n this.control.linearRampToValueAtTime(valToSet, t);\n }\n\n this.wasTriggered = false;\n };\n\n /**\n * Exponentially ramp to a value using the first two\n * values from setADSR(attackTime, decayTime)\n * as \n * time constants for simple exponential ramps.\n * If the value is higher than current value, it uses attackTime,\n * while a decrease uses decayTime.\n *\n * @method ramp\n * @for p5.Envelope\n * @param {Object} unit p5.sound Object or Web Audio Param\n * @param {Number} secondsFromNow When to trigger the ramp\n * @param {Number} v Target value\n * @param {Number} [v2] Second target value (optional)\n * @example\n *
\n * let env, osc, amp;\n *\n * let attackTime = 0.001;\n * let decayTime = 0.2;\n * let attackLevel = 1;\n * let decayLevel = 0;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * fill(0,255,0);\n * noStroke();\n *\n * env = new p5.Envelope();\n * env.setADSR(attackTime, decayTime);\n * osc = new p5.Oscillator();\n * osc.amp(env);\n * amp = new p5.Amplitude();\n *\n * cnv.mousePressed(triggerRamp);\n * }\n *\n * function triggerRamp() {\n * // ensures audio is enabled. See also: `userStartAudio`\n * osc.start();\n *\n * env.ramp(osc, 0, attackLevel, decayLevel);\n * }\n *\n * function draw() {\n * background(20);\n * text('tap to play', 10, 20);\n * let h = map(amp.getLevel(), 0, 0.4, 0, height);;\n * rect(0, height, width, -h);\n * }\n *
\n */\n p5.Envelope.prototype.ramp = function(unit, secondsFromNow, v1, v2) {\n\n var now = p5sound.audiocontext.currentTime;\n var tFromNow = secondsFromNow || 0;\n var t = now + tFromNow;\n var destination1 = this.checkExpInput(v1);\n var destination2 = typeof v2 !== 'undefined' ? this.checkExpInput(v2) : undefined;\n\n // connect env to unit if not already connected\n if (unit) {\n if (this.connection !== unit) {\n this.connect(unit);\n }\n }\n\n //get current value\n var currentVal = this.checkExpInput(this.control.getValueAtTime(t));\n // this.control.cancelScheduledValues(t);\n\n //if it's going up\n if (destination1 > currentVal) {\n this.control.setTargetAtTime(destination1, t, this._rampAttackTC);\n t += this._rampAttackTime;\n }\n\n //if it's going down\n else if (destination1 < currentVal) {\n this.control.setTargetAtTime(destination1, t, this._rampDecayTC);\n t += this._rampDecayTime;\n }\n\n // Now the second part of envelope begins\n if (destination2 === undefined) return;\n\n //if it's going up\n if (destination2 > destination1) {\n this.control.setTargetAtTime(destination2, t, this._rampAttackTC);\n }\n\n //if it's going down\n else if (destination2 < destination1) {\n this.control.setTargetAtTime(destination2, t, this._rampDecayTC);\n }\n };\n\n\n p5.Envelope.prototype.connect = function(unit) {\n this.connection = unit;\n\n // assume we're talking about output gain\n // unless given a different audio param\n if (unit instanceof p5.Oscillator ||\n unit instanceof p5.SoundFile ||\n unit instanceof p5.AudioIn ||\n unit instanceof p5.Reverb ||\n unit instanceof p5.Noise ||\n unit instanceof p5.Filter ||\n unit instanceof p5.Delay\n ) {\n unit = unit.output.gain;\n }\n if (unit instanceof AudioParam) {\n //set the initial value\n unit.setValueAtTime(0, p5sound.audiocontext.currentTime);\n }\n if (unit instanceof p5.Signal) {\n unit.setValue(0);\n }\n this.output.connect(unit);\n };\n\n p5.Envelope.prototype.disconnect = function() {\n if (this.output) {\n this.output.disconnect();\n }\n };\n\n\n // Signal Math\n\n /**\n * Add a value to the p5.Oscillator's output amplitude,\n * and return the oscillator. Calling this method\n * again will override the initial add() with new values.\n *\n * @method add\n * @for p5.Envelope\n * @param {Number} number Constant number to add\n * @return {p5.Envelope} Envelope Returns this envelope\n * with scaled output\n */\n p5.Envelope.prototype.add = function(num) {\n var add = new Add(num);\n var thisChain = this.mathOps.length;\n var nextChain = this.output;\n return p5.prototype._mathChain(this, add, thisChain, nextChain, Add);\n };\n\n /**\n * Multiply the p5.Envelope's output amplitude\n * by a fixed value. Calling this method\n * again will override the initial mult() with new values.\n *\n * @method mult\n * @for p5.Envelope\n * @param {Number} number Constant number to multiply\n * @return {p5.Envelope} Envelope Returns this envelope\n * with scaled output\n */\n p5.Envelope.prototype.mult = function(num) {\n var mult = new Mult(num);\n var thisChain = this.mathOps.length;\n var nextChain = this.output;\n return p5.prototype._mathChain(this, mult, thisChain, nextChain, Mult);\n };\n\n /**\n * Scale this envelope's amplitude values to a given\n * range, and return the envelope. Calling this method\n * again will override the initial scale() with new values.\n *\n * @method scale\n * @for p5.Envelope\n * @param {Number} inMin input range minumum\n * @param {Number} inMax input range maximum\n * @param {Number} outMin input range minumum\n * @param {Number} outMax input range maximum\n * @return {p5.Envelope} Envelope Returns this envelope\n * with scaled output\n */\n p5.Envelope.prototype.scale = function(inMin, inMax, outMin, outMax) {\n var scale = new Scale(inMin, inMax, outMin, outMax);\n var thisChain = this.mathOps.length;\n var nextChain = this.output;\n return p5.prototype._mathChain(this, scale, thisChain, nextChain, Scale);\n };\n\n\n // get rid of the oscillator\n p5.Envelope.prototype.dispose = function() {\n // remove reference from soundArray\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n\n this.disconnect();\n if (this.control) {\n this.control.dispose();\n this.control = null;\n }\n for (var i = 1; i < this.mathOps.length; i++) {\n this.mathOps[i].dispose();\n }\n };\n\n // Different name for backwards compatibility, replicates p5.Envelope class\n p5.Env = function(t1, l1, t2, l2, t3, l3) {\n console.warn('WARNING: p5.Env is now deprecated and may be removed in future versions. ' +\n 'Please use the new p5.Envelope instead.');\n p5.Envelope.call(this, t1, l1, t2, l2, t3, l3);\n };\n p5.Env.prototype = Object.create(p5.Envelope.prototype);\n\n});\n","'use strict';\n\ndefine(function (require) {\n\n var p5sound = require('master');\n require('oscillator');\n\n /**\n * Creates a Pulse object, an oscillator that implements\n * Pulse Width Modulation.\n * The pulse is created with two oscillators.\n * Accepts a parameter for frequency, and to set the\n * width between the pulses. See \n * p5.Oscillator for a full list of methods.\n *\n * @class p5.Pulse\n * @extends p5.Oscillator\n * @constructor\n * @param {Number} [freq] Frequency in oscillations per second (Hz)\n * @param {Number} [w] Width between the pulses (0 to 1.0,\n * defaults to 0)\n * @example\n *
\n * let pulse;\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(startPulse);\n * background(220);\n *\n * pulse = new p5.Pulse();\n * pulse.amp(0.5);\n * pulse.freq(220);\n * }\n * function startPulse() {\n * pulse.start();\n * pulse.amp(0.5, 0.02);\n * }\n * function mouseReleased() {\n * pulse.amp(0, 0.2);\n * }\n * function draw() {\n * background(220);\n * text('tap to play', 5, 20, width - 20);\n * let w = map(mouseX, 0, width, 0, 1);\n * w = constrain(w, 0, 1);\n * pulse.width(w);\n * text('pulse width: ' + w, 5, height - 20);\n * }\n *
\n */\n p5.Pulse = function(freq, w) {\n p5.Oscillator.call(this, freq, 'sawtooth');\n\n // width of PWM, should be betw 0 to 1.0\n this.w = w || 0;\n\n // create a second oscillator with inverse frequency\n this.osc2 = new p5.SawOsc(freq);\n\n // create a delay node\n this.dNode = p5sound.audiocontext.createDelay();\n\n // dc offset\n this.dcOffset = createDCOffset();\n this.dcGain = p5sound.audiocontext.createGain();\n this.dcOffset.connect(this.dcGain);\n this.dcGain.connect(this.output);\n // set delay time based on PWM width\n this.f = freq || 440;\n var mW = this.w / this.oscillator.frequency.value;\n this.dNode.delayTime.value = mW;\n this.dcGain.gain.value = 1.7*(0.5-this.w);\n\n // disconnect osc2 and connect it to delay, which is connected to output\n this.osc2.disconnect();\n this.osc2.panner.disconnect();\n this.osc2.amp(-1); // inverted amplitude\n this.osc2.output.connect(this.dNode);\n this.dNode.connect(this.output);\n\n this.output.gain.value = 1;\n this.output.connect(this.panner);\n };\n\n p5.Pulse.prototype = Object.create(p5.Oscillator.prototype);\n\n /**\n * Set the width of a Pulse object (an oscillator that implements\n * Pulse Width Modulation).\n *\n * @method width\n * @param {Number} [width] Width between the pulses (0 to 1.0,\n * defaults to 0)\n */\n p5.Pulse.prototype.width = function(w) {\n if (typeof w === 'number') {\n if (w <= 1.0 && w >= 0.0) {\n this.w = w;\n // set delay time based on PWM width\n\n // var mW = map(this.w, 0, 1.0, 0, 1/this.f);\n var mW = this.w / this.oscillator.frequency.value;\n this.dNode.delayTime.value = mW;\n }\n\n this.dcGain.gain.value = 1.7*(0.5-this.w);\n } else {\n w.connect(this.dNode.delayTime);\n var sig = new p5.SignalAdd(-0.5);\n sig.setInput(w);\n sig = sig.mult(-1);\n sig = sig.mult(1.7);\n sig.connect(this.dcGain.gain);\n }\n };\n\n p5.Pulse.prototype.start = function(f, time) {\n var now = p5sound.audiocontext.currentTime;\n var t = time || 0;\n if (!this.started) {\n var freq = f || this.f;\n var type = this.oscillator.type;\n this.oscillator = p5sound.audiocontext.createOscillator();\n this.oscillator.frequency.setValueAtTime(freq, now);\n this.oscillator.type = type;\n this.oscillator.connect(this.output);\n this.oscillator.start(t + now);\n\n // set up osc2\n this.osc2.oscillator = p5sound.audiocontext.createOscillator();\n this.osc2.oscillator.frequency.setValueAtTime(freq, t + now);\n this.osc2.oscillator.type = type;\n this.osc2.oscillator.connect(this.osc2.output);\n this.osc2.start(t + now);\n this.freqNode = [this.oscillator.frequency, this.osc2.oscillator.frequency];\n\n // start dcOffset, too\n this.dcOffset = createDCOffset();\n this.dcOffset.connect(this.dcGain);\n this.dcOffset.start(t + now);\n\n // if LFO connections depend on these oscillators\n if (this.mods !== undefined && this.mods.frequency !== undefined) {\n this.mods.frequency.connect(this.freqNode[0]);\n this.mods.frequency.connect(this.freqNode[1]);\n }\n this.started = true;\n this.osc2.started = true;\n }\n };\n\n p5.Pulse.prototype.stop = function(time) {\n if (this.started) {\n var t = time || 0;\n var now = p5sound.audiocontext.currentTime;\n this.oscillator.stop(t + now);\n if (this.osc2.oscillator) {\n this.osc2.oscillator.stop(t + now);\n }\n this.dcOffset.stop(t + now);\n this.started = false;\n this.osc2.started = false;\n }\n };\n\n p5.Pulse.prototype.freq = function(val, rampTime, tFromNow) {\n if (typeof val === 'number') {\n this.f = val;\n var now = p5sound.audiocontext.currentTime;\n var rampTime = rampTime || 0;\n var tFromNow = tFromNow || 0;\n var currentFreq = this.oscillator.frequency.value;\n this.oscillator.frequency.cancelScheduledValues(now);\n this.oscillator.frequency.setValueAtTime(currentFreq, now + tFromNow);\n this.oscillator.frequency.exponentialRampToValueAtTime(val, tFromNow + rampTime + now);\n this.osc2.oscillator.frequency.cancelScheduledValues(now);\n this.osc2.oscillator.frequency.setValueAtTime(currentFreq, now + tFromNow);\n this.osc2.oscillator.frequency.exponentialRampToValueAtTime(val, tFromNow + rampTime + now);\n\n if (this.freqMod) {\n this.freqMod.output.disconnect();\n this.freqMod = null;\n }\n\n } else if (val.output) {\n val.output.disconnect();\n val.output.connect(this.oscillator.frequency);\n val.output.connect(this.osc2.oscillator.frequency);\n this.freqMod = val;\n }\n };\n\n // inspiration: http://webaudiodemos.appspot.com/oscilloscope/\n function createDCOffset() {\n var ac = p5sound.audiocontext;\n var buffer=ac.createBuffer(1,2048,ac.sampleRate);\n var data = buffer.getChannelData(0);\n for (var i=0; i<2048; i++)\n data[i]=1.0;\n var bufferSource=ac.createBufferSource();\n bufferSource.buffer=buffer;\n bufferSource.loop=true;\n return bufferSource;\n }\n\n});\n","'use strict';\n\ndefine(function (require) {\n var p5sound = require('master');\n\n /**\n * Noise is a type of oscillator that generates a buffer with random values.\n *\n * @class p5.Noise\n * @extends p5.Oscillator\n * @constructor\n * @param {String} type Type of noise can be 'white' (default),\n * 'brown' or 'pink'.\n */\n p5.Noise = function(type) {\n var assignType;\n p5.Oscillator.call(this);\n delete this.f;\n delete this.freq;\n delete this.oscillator;\n\n if (type === 'brown') {\n assignType = _brownNoise;\n } else if (type === 'pink') {\n assignType = _pinkNoise;\n } else {\n assignType = _whiteNoise;\n }\n this.buffer = assignType;\n };\n\n p5.Noise.prototype = Object.create(p5.Oscillator.prototype);\n\n // generate noise buffers\n var _whiteNoise = (function() {\n var bufferSize = 2 * p5sound.audiocontext.sampleRate;\n var whiteBuffer = p5sound.audiocontext.createBuffer(1, bufferSize, p5sound.audiocontext.sampleRate);\n var noiseData = whiteBuffer.getChannelData(0);\n for (var i = 0; i < bufferSize; i++) {\n noiseData[i] = Math.random() * 2 - 1;\n }\n whiteBuffer.type = 'white';\n return whiteBuffer;\n })();\n\n var _pinkNoise = (function() {\n var bufferSize = 2 * p5sound.audiocontext.sampleRate;\n var pinkBuffer = p5sound.audiocontext.createBuffer(1, bufferSize, p5sound.audiocontext.sampleRate);\n var noiseData = pinkBuffer.getChannelData(0);\n var b0, b1, b2, b3, b4, b5, b6;\n b0 = b1 = b2 = b3 = b4 = b5 = b6 = 0.0;\n for (var i = 0; i < bufferSize; i++) {\n var white = Math.random() * 2 - 1;\n b0 = 0.99886 * b0 + white * 0.0555179;\n b1 = 0.99332 * b1 + white * 0.0750759;\n b2 = 0.96900 * b2 + white * 0.1538520;\n b3 = 0.86650 * b3 + white * 0.3104856;\n b4 = 0.55000 * b4 + white * 0.5329522;\n b5 = -0.7616 * b5 - white * 0.0168980;\n noiseData[i] = b0 + b1 + b2 + b3 + b4 + b5 + b6 + white * 0.5362;\n noiseData[i] *= 0.11; // (roughly) compensate for gain\n b6 = white * 0.115926;\n }\n pinkBuffer.type = 'pink';\n return pinkBuffer;\n })();\n\n var _brownNoise = (function() {\n var bufferSize = 2 * p5sound.audiocontext.sampleRate;\n var brownBuffer = p5sound.audiocontext.createBuffer(1, bufferSize, p5sound.audiocontext.sampleRate);\n var noiseData = brownBuffer.getChannelData(0);\n var lastOut = 0.0;\n for (var i = 0; i< bufferSize; i++) {\n var white = Math.random() * 2 - 1;\n noiseData[i] = (lastOut + 0.02*white) / 1.02;\n lastOut = noiseData[i];\n noiseData[i] *= 3.5;\n }\n brownBuffer.type = 'brown';\n return brownBuffer;\n })();\n\n /**\n * Set type of noise to 'white', 'pink' or 'brown'.\n * White is the default.\n *\n * @method setType\n * @param {String} [type] 'white', 'pink' or 'brown'\n */\n p5.Noise.prototype.setType = function(type) {\n switch(type) {\n case 'white':\n this.buffer = _whiteNoise;\n break;\n case 'pink':\n this.buffer = _pinkNoise;\n break;\n case 'brown':\n this.buffer = _brownNoise;\n break;\n default:\n this.buffer = _whiteNoise;\n }\n if (this.started) {\n var now = p5sound.audiocontext.currentTime;\n this.stop(now);\n this.start(now+.01);\n }\n };\n\n p5.Noise.prototype.getType = function() {\n return this.buffer.type;\n };\n\n p5.Noise.prototype.start = function() {\n if (this.started) {\n this.stop();\n }\n this.noise = p5sound.audiocontext.createBufferSource();\n this.noise.buffer = this.buffer;\n this.noise.loop = true;\n this.noise.connect(this.output);\n var now = p5sound.audiocontext.currentTime;\n this.noise.start(now);\n this.started = true;\n };\n\n p5.Noise.prototype.stop = function() {\n var now = p5sound.audiocontext.currentTime;\n if (this.noise) {\n this.noise.stop(now);\n this.started = false;\n }\n };\n\n p5.Noise.prototype.dispose = function() {\n var now = p5sound.audiocontext.currentTime;\n\n // remove reference from soundArray\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n\n if (this.noise) {\n this.noise.disconnect();\n this.stop(now);\n }\n if (this.output) {\n this.output.disconnect();\n }\n if (this.panner) {\n this.panner.disconnect();\n }\n this.output = null;\n this.panner = null;\n this.buffer = null;\n this.noise = null;\n };\n\n});\n","'use strict';\n\ndefine(function (require) {\n var p5sound = require('master');\n\n // an array of input sources\n p5sound.inputSources = [];\n\n /**\n *

Get audio from an input, i.e. your computer's microphone.

\n *\n *

Turn the mic on/off with the start() and stop() methods. When the mic\n * is on, its volume can be measured with getLevel or by connecting an\n * FFT object.

\n *\n *

If you want to hear the AudioIn, use the .connect() method.\n * AudioIn does not connect to p5.sound output by default to prevent\n * feedback.

\n *\n *

Note: This uses the getUserMedia/\n * Stream API, which is not supported by certain browsers. Access in Chrome browser\n * is limited to localhost and https, but access over http may be limited.

\n *\n * @class p5.AudioIn\n * @constructor\n * @param {Function} [errorCallback] A function to call if there is an error\n * accessing the AudioIn. For example,\n * Safari and iOS devices do not\n * currently allow microphone access.\n * @example\n *
\n * let mic;\n *\n * function setup(){\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(userStartAudio);\n * textAlign(CENTER);\n * mic = new p5.AudioIn();\n * mic.start();\n * }\n *\n * function draw(){\n * background(0);\n * fill(255);\n * text('tap to start', width/2, 20);\n *\n * micLevel = mic.getLevel();\n * let y = height - micLevel * height;\n * ellipse(width/2, y, 10, 10);\n * }\n *
\n */\n p5.AudioIn = function(errorCallback) {\n // set up audio input\n /**\n * @property {GainNode} input\n */\n this.input = p5sound.audiocontext.createGain();\n /**\n * @property {GainNode} output\n */\n this.output = p5sound.audiocontext.createGain();\n\n /**\n * @property {MediaStream|null} stream\n */\n this.stream = null;\n /**\n * @property {MediaStreamAudioSourceNode|null} mediaStream\n */\n this.mediaStream = null;\n /**\n * @property {Number|null} currentSource\n */\n this.currentSource = null;\n\n /**\n * Client must allow browser to access their microphone / audioin source.\n * Default: false. Will become true when the client enables access.\n *\n * @property {Boolean} enabled\n */\n this.enabled = false;\n\n /**\n * Input amplitude, connect to it by default but not to master out\n *\n * @property {p5.Amplitude} amplitude\n */\n this.amplitude = new p5.Amplitude();\n this.output.connect(this.amplitude.input);\n\n if (!window.MediaStreamTrack || !window.navigator.mediaDevices || !window.navigator.mediaDevices.getUserMedia) {\n errorCallback ? errorCallback() : window.alert('This browser does not support MediaStreamTrack and mediaDevices');\n }\n\n // add to soundArray so we can dispose on close\n p5sound.soundArray.push(this);\n };\n\n /**\n * Start processing audio input. This enables the use of other\n * AudioIn methods like getLevel(). Note that by default, AudioIn\n * is not connected to p5.sound's output. So you won't hear\n * anything unless you use the connect() method.
\n *\n * Certain browsers limit access to the user's microphone. For example,\n * Chrome only allows access from localhost and over https. For this reason,\n * you may want to include an errorCallback—a function that is called in case\n * the browser won't provide mic access.\n *\n * @method start\n * @for p5.AudioIn\n * @param {Function} [successCallback] Name of a function to call on\n * success.\n * @param {Function} [errorCallback] Name of a function to call if\n * there was an error. For example,\n * some browsers do not support\n * getUserMedia.\n */\n p5.AudioIn.prototype.start = function(successCallback, errorCallback) {\n var self = this;\n\n if (this.stream) {\n this.stop();\n }\n\n // set the audio source\n var audioSource = p5sound.inputSources[self.currentSource];\n var constraints = {\n audio: {\n sampleRate: p5sound.audiocontext.sampleRate,\n echoCancellation: false\n }\n };\n\n // if developers determine which source to use\n if (p5sound.inputSources[this.currentSource]) {\n constraints.audio.deviceId = audioSource.deviceId;\n }\n\n window.navigator.mediaDevices.getUserMedia( constraints )\n .then( function(stream) {\n self.stream = stream;\n self.enabled = true;\n // Wrap a MediaStreamSourceNode around the live input\n self.mediaStream = p5sound.audiocontext.createMediaStreamSource(stream);\n self.mediaStream.connect(self.output);\n // only send to the Amplitude reader, so we can see it but not hear it.\n self.amplitude.setInput(self.output);\n if (successCallback) successCallback();\n })\n .catch( function(err) {\n if (errorCallback) errorCallback(err);\n else console.error(err);\n });\n };\n\n /**\n * Turn the AudioIn off. If the AudioIn is stopped, it cannot getLevel().\n * If re-starting, the user may be prompted for permission access.\n *\n * @method stop\n * @for p5.AudioIn\n */\n p5.AudioIn.prototype.stop = function() {\n if (this.stream) {\n this.stream.getTracks().forEach(function(track) {\n track.stop();\n });\n\n this.mediaStream.disconnect();\n\n delete this.mediaStream;\n delete this.stream;\n }\n };\n\n /**\n * Connect to an audio unit. If no parameter is provided, will\n * connect to the master output (i.e. your speakers).
\n *\n * @method connect\n * @for p5.AudioIn\n * @param {Object} [unit] An object that accepts audio input,\n * such as an FFT\n */\n p5.AudioIn.prototype.connect = function(unit) {\n if (unit) {\n if (unit.hasOwnProperty('input')) {\n this.output.connect(unit.input);\n }\n else if (unit.hasOwnProperty('analyser')) {\n this.output.connect(unit.analyser);\n }\n else {\n this.output.connect(unit);\n }\n }\n else {\n this.output.connect(p5sound.input);\n }\n };\n\n /**\n * Disconnect the AudioIn from all audio units. For example, if\n * connect() had been called, disconnect() will stop sending\n * signal to your speakers.
\n *\n * @method disconnect\n * @for p5.AudioIn\n */\n p5.AudioIn.prototype.disconnect = function() {\n if (this.output) {\n this.output.disconnect();\n // stay connected to amplitude even if not outputting to p5\n this.output.connect(this.amplitude.input);\n }\n };\n\n /**\n * Read the Amplitude (volume level) of an AudioIn. The AudioIn\n * class contains its own instance of the Amplitude class to help\n * make it easy to get a microphone's volume level. Accepts an\n * optional smoothing value (0.0 < 1.0). NOTE: AudioIn must\n * .start() before using .getLevel().
\n *\n * @method getLevel\n * @for p5.AudioIn\n * @param {Number} [smoothing] Smoothing is 0.0 by default.\n * Smooths values based on previous values.\n * @return {Number} Volume level (between 0.0 and 1.0)\n */\n p5.AudioIn.prototype.getLevel = function(smoothing) {\n if (smoothing) {\n this.amplitude.smoothing = smoothing;\n }\n return this.amplitude.getLevel();\n };\n\n /**\n * Set amplitude (volume) of a mic input between 0 and 1.0.
\n *\n * @method amp\n * @for p5.AudioIn\n * @param {Number} vol between 0 and 1.0\n * @param {Number} [time] ramp time (optional)\n */\n p5.AudioIn.prototype.amp = function(vol, t) {\n if (t) {\n var rampTime = t || 0;\n var currentVol = this.output.gain.value;\n this.output.gain.cancelScheduledValues(p5sound.audiocontext.currentTime);\n this.output.gain.setValueAtTime(currentVol, p5sound.audiocontext.currentTime);\n this.output.gain.linearRampToValueAtTime(vol, rampTime + p5sound.audiocontext.currentTime);\n } else {\n this.output.gain.cancelScheduledValues(p5sound.audiocontext.currentTime);\n this.output.gain.setValueAtTime(vol, p5sound.audiocontext.currentTime);\n }\n };\n\n /**\n * Returns a list of available input sources. This is a wrapper\n * for and it returns a Promise.\n *\n * @method getSources\n * @for p5.AudioIn\n * @param {Function} [successCallback] This callback function handles the sources when they\n * have been enumerated. The callback function\n * receives the deviceList array as its only argument\n * @param {Function} [errorCallback] This optional callback receives the error\n * message as its argument.\n * @returns {Promise} Returns a Promise that can be used in place of the callbacks, similar\n * to the enumerateDevices() method\n * @example\n *
\n * let audioIn;\n *\n * function setup(){\n * text('getting sources...', 0, 20);\n * audioIn = new p5.AudioIn();\n * audioIn.getSources(gotSources);\n * }\n *\n * function gotSources(deviceList) {\n * if (deviceList.length > 0) {\n * //set the source to the first item in the deviceList array\n * audioIn.setSource(0);\n * let currentSource = deviceList[audioIn.currentSource];\n * text('set source to: ' + currentSource.deviceId, 5, 20, width);\n * }\n * }\n *
\n */\n p5.AudioIn.prototype.getSources = function (onSuccess, onError) {\n return new Promise( function(resolve, reject) {\n window.navigator.mediaDevices.enumerateDevices()\n .then( function(devices) {\n p5sound.inputSources = devices.filter(function(device) {\n return device.kind === 'audioinput';\n });\n resolve(p5sound.inputSources);\n if (onSuccess) {\n onSuccess(p5sound.inputSources);\n }\n })\n .catch( function(error) {\n reject(error);\n if (onError) {\n onError(error);\n } else {\n console.error('This browser does not support MediaStreamTrack.getSources()');\n }\n });\n });\n };\n\n /**\n * Set the input source. Accepts a number representing a\n * position in the array returned by getSources().\n * This is only available in browsers that support\n * navigator.mediaDevices.enumerateDevices().
\n *\n * @method setSource\n * @for p5.AudioIn\n * @param {number} num position of input source in the array\n * @example\n *
\n * let audioIn;\n *\n * function setup(){\n * text('getting sources...', 0, 20);\n * audioIn = new p5.AudioIn();\n * audioIn.getSources(gotSources);\n * }\n *\n * function gotSources(deviceList) {\n * if (deviceList.length > 0) {\n * //set the source to the first item in the deviceList array\n * audioIn.setSource(0);\n * let currentSource = deviceList[audioIn.currentSource];\n * text('set source to: ' + currentSource.deviceId, 5, 20, width);\n * }\n * }\n *
\n */\n p5.AudioIn.prototype.setSource = function(num) {\n if (p5sound.inputSources.length > 0 && num < p5sound.inputSources.length) {\n // set the current source\n this.currentSource = num;\n console.log('set source to ', p5sound.inputSources[this.currentSource]);\n } else {\n console.log('unable to set input source');\n }\n\n // restart stream if currently active\n if (this.stream && this.stream.active) {\n this.start();\n }\n };\n\n // private method\n p5.AudioIn.prototype.dispose = function() {\n // remove reference from soundArray\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n\n this.stop();\n\n if (this.output) {\n this.output.disconnect();\n }\n if (this.amplitude) {\n this.amplitude.disconnect();\n }\n delete this.amplitude;\n delete this.output;\n };\n\n});\n","define([\"Tone/core/Tone\", \"Tone/signal/Signal\", \"Tone/signal/Expr\", \n\t\"Tone/signal/EqualPowerGain\", \"Tone/core/Gain\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Tone.Crossfade provides equal power fading between two inputs. \n\t * More on crossfading technique [here](https://en.wikipedia.org/wiki/Fade_(audio_engineering)#Crossfading).\n\t *\n\t * @constructor\n\t * @extends {Tone}\n\t * @param {NormalRange} [initialFade=0.5]\n\t * @example\n\t * var crossFade = new Tone.CrossFade(0.5);\n\t * //connect effect A to crossfade from\n\t * //effect output 0 to crossfade input 0\n\t * effectA.connect(crossFade, 0, 0);\n\t * //connect effect B to crossfade from\n\t * //effect output 0 to crossfade input 1\n\t * effectB.connect(crossFade, 0, 1);\n\t * crossFade.fade.value = 0;\n\t * // ^ only effectA is output\n\t * crossFade.fade.value = 1;\n\t * // ^ only effectB is output\n\t * crossFade.fade.value = 0.5;\n\t * // ^ the two signals are mixed equally. \n\t */\t\t\n\tTone.CrossFade = function(initialFade){\n\n\t\tthis.createInsOuts(2, 1);\n\n\t\t/**\n\t\t * Alias for input[0]. \n\t\t * @type {Tone.Gain}\n\t\t */\n\t\tthis.a = this.input[0] = new Tone.Gain();\n\n\t\t/**\n\t\t * Alias for input[1]. \n\t\t * @type {Tone.Gain}\n\t\t */\n\t\tthis.b = this.input[1] = new Tone.Gain();\n\n\t\t/**\n\t\t * \tThe mix between the two inputs. A fade value of 0\n\t\t * \twill output 100% input[0] and \n\t\t * \ta value of 1 will output 100% input[1]. \n\t\t * @type {NormalRange}\n\t\t * @signal\n\t\t */\n\t\tthis.fade = new Tone.Signal(this.defaultArg(initialFade, 0.5), Tone.Type.NormalRange);\n\n\t\t/**\n\t\t * equal power gain cross fade\n\t\t * @private\n\t\t * @type {Tone.EqualPowerGain}\n\t\t */\n\t\tthis._equalPowerA = new Tone.EqualPowerGain();\n\n\t\t/**\n\t\t * equal power gain cross fade\n\t\t * @private\n\t\t * @type {Tone.EqualPowerGain}\n\t\t */\n\t\tthis._equalPowerB = new Tone.EqualPowerGain();\n\t\t\n\t\t/**\n\t\t * invert the incoming signal\n\t\t * @private\n\t\t * @type {Tone}\n\t\t */\n\t\tthis._invert = new Tone.Expr(\"1 - $0\");\n\n\t\t//connections\n\t\tthis.a.connect(this.output);\n\t\tthis.b.connect(this.output);\n\t\tthis.fade.chain(this._equalPowerB, this.b.gain);\n\t\tthis.fade.chain(this._invert, this._equalPowerA, this.a.gain);\n\t\tthis._readOnly(\"fade\");\n\t};\n\n\tTone.extend(Tone.CrossFade);\n\n\t/**\n\t * clean up\n\t * @returns {Tone.CrossFade} this\n\t */\n\tTone.CrossFade.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._writable(\"fade\");\n\t\tthis._equalPowerA.dispose();\n\t\tthis._equalPowerA = null;\n\t\tthis._equalPowerB.dispose();\n\t\tthis._equalPowerB = null;\n\t\tthis.fade.dispose();\n\t\tthis.fade = null;\n\t\tthis._invert.dispose();\n\t\tthis._invert = null;\n\t\tthis.a.dispose();\n\t\tthis.a = null;\n\t\tthis.b.dispose();\n\t\tthis.b = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.CrossFade;\n});\n","define([\"Tone/core/Tone\", \"Tone/signal/Add\", \"Tone/signal/Subtract\", \"Tone/signal/Multiply\", \n\t\"Tone/signal/GreaterThan\", \"Tone/signal/GreaterThanZero\", \"Tone/signal/Abs\", \"Tone/signal/Negate\", \n\t\"Tone/signal/Modulo\", \"Tone/signal/Pow\", \"Tone/signal/AudioToGain\"], \n\tfunction(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Evaluate an expression at audio rate.

\n\t * Parsing code modified from https://code.google.com/p/tapdigit/\n\t * Copyright 2011 2012 Ariya Hidayat, New BSD License\n\t *\n\t * @extends {Tone.SignalBase}\n\t * @constructor\n\t * @param {string} expr the expression to generate\n\t * @example\n\t * //adds the signals from input[0] and input[1].\n\t * var expr = new Tone.Expr(\"$0 + $1\");\n\t */\n\tTone.Expr = function(){\n\n\t\tvar expr = this._replacements(Array.prototype.slice.call(arguments));\n\t\tvar inputCount = this._parseInputs(expr);\n\n\t\t/**\n\t\t * hold onto all of the nodes for disposal\n\t\t * @type {Array}\n\t\t * @private\n\t\t */\n\t\tthis._nodes = [];\n\n\t\t/**\n\t\t * The inputs. The length is determined by the expression. \n\t\t * @type {Array}\n\t\t */\n\t\tthis.input = new Array(inputCount);\n\n\t\t//create a gain for each input\n\t\tfor (var i = 0; i < inputCount; i++){\n\t\t\tthis.input[i] = this.context.createGain();\n\t\t}\n\n\t\t//parse the syntax tree\n\t\tvar tree = this._parseTree(expr);\n\t\t//evaluate the results\n\t\tvar result;\n\t\ttry {\n\t\t\tresult = this._eval(tree);\n\t\t} catch (e){\n\t\t\tthis._disposeNodes();\n\t\t\tthrow new Error(\"Tone.Expr: Could evaluate expression: \"+expr);\n\t\t}\n\n\t\t/**\n\t\t * The output node is the result of the expression\n\t\t * @type {Tone}\n\t\t */\n\t\tthis.output = result;\n\t};\n\n\tTone.extend(Tone.Expr, Tone.SignalBase);\n\n\t//some helpers to cut down the amount of code\n\tfunction applyBinary(Constructor, args, self){\n\t\tvar op = new Constructor();\n\t\tself._eval(args[0]).connect(op, 0, 0);\n\t\tself._eval(args[1]).connect(op, 0, 1);\n\t\treturn op;\n\t}\n\tfunction applyUnary(Constructor, args, self){\n\t\tvar op = new Constructor();\n\t\tself._eval(args[0]).connect(op, 0, 0);\n\t\treturn op;\n\t}\n\tfunction getNumber(arg){\n\t\treturn arg ? parseFloat(arg) : undefined;\n\t}\n\tfunction literalNumber(arg){\n\t\treturn arg && arg.args ? parseFloat(arg.args) : undefined;\n\t}\n\n\t/*\n\t * the Expressions that Tone.Expr can parse.\n\t *\n\t * each expression belongs to a group and contains a regexp \n\t * for selecting the operator as well as that operators method\n\t * \n\t * @type {Object}\n\t * @private\n\t */\n\tTone.Expr._Expressions = {\n\t\t//values\n\t\t\"value\" : {\n\t\t\t\"signal\" : {\n\t\t\t\tregexp : /^\\d+\\.\\d+|^\\d+/,\n\t\t\t\tmethod : function(arg){\n\t\t\t\t\tvar sig = new Tone.Signal(getNumber(arg));\n\t\t\t\t\treturn sig;\n\t\t\t\t}\n\t\t\t},\n\t\t\t\"input\" : {\n\t\t\t\tregexp : /^\\$\\d/,\n\t\t\t\tmethod : function(arg, self){\n\t\t\t\t\treturn self.input[getNumber(arg.substr(1))];\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\t//syntactic glue\n\t\t\"glue\" : {\n\t\t\t\"(\" : {\n\t\t\t\tregexp : /^\\(/,\n\t\t\t},\n\t\t\t\")\" : {\n\t\t\t\tregexp : /^\\)/,\n\t\t\t},\n\t\t\t\",\" : {\n\t\t\t\tregexp : /^,/,\n\t\t\t}\n\t\t},\n\t\t//functions\n\t\t\"func\" : {\n\t\t\t\"abs\" : {\n\t\t\t\tregexp : /^abs/,\n\t\t\t\tmethod : applyUnary.bind(this, Tone.Abs)\n\t\t\t},\n\t\t\t\"mod\" : {\n\t\t\t\tregexp : /^mod/,\n\t\t\t\tmethod : function(args, self){\n\t\t\t\t\tvar modulus = literalNumber(args[1]);\n\t\t\t\t\tvar op = new Tone.Modulo(modulus);\n\t\t\t\t\tself._eval(args[0]).connect(op);\n\t\t\t\t\treturn op;\n\t\t\t\t}\n\t\t\t},\n\t\t\t\"pow\" : {\n\t\t\t\tregexp : /^pow/,\n\t\t\t\tmethod : function(args, self){\n\t\t\t\t\tvar exp = literalNumber(args[1]);\n\t\t\t\t\tvar op = new Tone.Pow(exp);\n\t\t\t\t\tself._eval(args[0]).connect(op);\n\t\t\t\t\treturn op;\n\t\t\t\t}\n\t\t\t},\n\t\t\t\"a2g\" : {\n\t\t\t\tregexp : /^a2g/,\n\t\t\t\tmethod : function(args, self){\n\t\t\t\t\tvar op = new Tone.AudioToGain();\n\t\t\t\t\tself._eval(args[0]).connect(op);\n\t\t\t\t\treturn op;\n\t\t\t\t}\n\t\t\t},\n\t\t},\n\t\t//binary expressions\n\t\t\"binary\" : {\n\t\t\t\"+\" : {\n\t\t\t\tregexp : /^\\+/,\n\t\t\t\tprecedence : 1,\n\t\t\t\tmethod : applyBinary.bind(this, Tone.Add)\n\t\t\t},\n\t\t\t\"-\" : {\n\t\t\t\tregexp : /^\\-/,\n\t\t\t\tprecedence : 1,\n\t\t\t\tmethod : function(args, self){\n\t\t\t\t\t//both unary and binary op\n\t\t\t\t\tif (args.length === 1){\n\t\t\t\t\t\treturn applyUnary(Tone.Negate, args, self);\n\t\t\t\t\t} else {\n\t\t\t\t\t\treturn applyBinary(Tone.Subtract, args, self);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t},\n\t\t\t\"*\" : {\n\t\t\t\tregexp : /^\\*/,\n\t\t\t\tprecedence : 0,\n\t\t\t\tmethod : applyBinary.bind(this, Tone.Multiply)\n\t\t\t}\n\t\t},\n\t\t//unary expressions\n\t\t\"unary\" : {\n\t\t\t\"-\" : {\n\t\t\t\tregexp : /^\\-/,\n\t\t\t\tmethod : applyUnary.bind(this, Tone.Negate)\n\t\t\t},\n\t\t\t\"!\" : {\n\t\t\t\tregexp : /^\\!/,\n\t\t\t\tmethod : applyUnary.bind(this, Tone.NOT)\n\t\t\t},\n\t\t},\n\t};\n\t\t\n\t/**\n\t * @param {string} expr the expression string\n\t * @return {number} the input count\n\t * @private\n\t */\n\tTone.Expr.prototype._parseInputs = function(expr){\n\t\tvar inputArray = expr.match(/\\$\\d/g);\n\t\tvar inputMax = 0;\n\t\tif (inputArray !== null){\n\t\t\tfor (var i = 0; i < inputArray.length; i++){\n\t\t\t\tvar inputNum = parseInt(inputArray[i].substr(1)) + 1;\n\t\t\t\tinputMax = Math.max(inputMax, inputNum);\n\t\t\t}\n\t\t}\n\t\treturn inputMax;\n\t};\n\n\t/**\n\t * @param {Array} args \tan array of arguments\n\t * @return {string} the results of the replacements being replaced\n\t * @private\n\t */\n\tTone.Expr.prototype._replacements = function(args){\n\t\tvar expr = args.shift();\n\t\tfor (var i = 0; i < args.length; i++){\n\t\t\texpr = expr.replace(/\\%/i, args[i]);\n\t\t}\n\t\treturn expr;\n\t};\n\n\t/**\n\t * tokenize the expression based on the Expressions object\n\t * @param {string} expr \n\t * @return {Object} returns two methods on the tokenized list, next and peek\n\t * @private\n\t */\n\tTone.Expr.prototype._tokenize = function(expr){\n\t\tvar position = -1;\n\t\tvar tokens = [];\n\n\t\twhile(expr.length > 0){\n\t\t\texpr = expr.trim();\n\t\t\tvar token = getNextToken(expr);\n\t\t\ttokens.push(token);\n\t\t\texpr = expr.substr(token.value.length);\n\t\t}\n\n\t\tfunction getNextToken(expr){\n\t\t\tfor (var type in Tone.Expr._Expressions){\n\t\t\t\tvar group = Tone.Expr._Expressions[type];\n\t\t\t\tfor (var opName in group){\n\t\t\t\t\tvar op = group[opName];\n\t\t\t\t\tvar reg = op.regexp;\n\t\t\t\t\tvar match = expr.match(reg);\n\t\t\t\t\tif (match !== null){\n\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\ttype : type,\n\t\t\t\t\t\t\tvalue : match[0],\n\t\t\t\t\t\t\tmethod : op.method\n\t\t\t\t\t\t};\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tthrow new SyntaxError(\"Tone.Expr: Unexpected token \"+expr);\n\t\t}\n\n\t\treturn {\n\t\t\tnext : function(){\n\t\t\t\treturn tokens[++position];\n\t\t\t},\n\t\t\tpeek : function(){\n\t\t\t\treturn tokens[position + 1];\n\t\t\t}\n\t\t};\n\t};\n\n\t/**\n\t * recursively parse the string expression into a syntax tree\n\t * \n\t * @param {string} expr \n\t * @return {Object}\n\t * @private\n\t */\n\tTone.Expr.prototype._parseTree = function(expr){\n\t\tvar lexer = this._tokenize(expr);\n\t\tvar isUndef = this.isUndef.bind(this);\n\n\t\tfunction matchSyntax(token, syn) {\n\t\t\treturn !isUndef(token) && \n\t\t\t\ttoken.type === \"glue\" &&\n\t\t\t\ttoken.value === syn;\n\t\t}\n\n\t\tfunction matchGroup(token, groupName, prec) {\n\t\t\tvar ret = false;\n\t\t\tvar group = Tone.Expr._Expressions[groupName];\n\t\t\tif (!isUndef(token)){\n\t\t\t\tfor (var opName in group){\n\t\t\t\t\tvar op = group[opName];\n\t\t\t\t\tif (op.regexp.test(token.value)){\n\t\t\t\t\t\tif (!isUndef(prec)){\n\t\t\t\t\t\t\tif(op.precedence === prec){\t\n\t\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn ret;\n\t\t}\n\n\t\tfunction parseExpression(precedence) {\n\t\t\tif (isUndef(precedence)){\n\t\t\t\tprecedence = 5;\n\t\t\t}\n\t\t\tvar expr;\n\t\t\tif (precedence < 0){\n\t\t\t\texpr = parseUnary();\n\t\t\t} else {\n\t\t\t\texpr = parseExpression(precedence-1);\n\t\t\t}\n\t\t\tvar token = lexer.peek();\n\t\t\twhile (matchGroup(token, \"binary\", precedence)) {\n\t\t\t\ttoken = lexer.next();\n\t\t\t\texpr = {\n\t\t\t\t\toperator: token.value,\n\t\t\t\t\tmethod : token.method,\n\t\t\t\t\targs : [\n\t\t\t\t\t\texpr,\n\t\t\t\t\t\tparseExpression(precedence-1)\n\t\t\t\t\t]\n\t\t\t\t};\n\t\t\t\ttoken = lexer.peek();\n\t\t\t}\n\t\t\treturn expr;\n\t\t}\n\n\t\tfunction parseUnary() {\n\t\t\tvar token, expr;\n\t\t\ttoken = lexer.peek();\n\t\t\tif (matchGroup(token, \"unary\")) {\n\t\t\t\ttoken = lexer.next();\n\t\t\t\texpr = parseUnary();\n\t\t\t\treturn {\n\t\t\t\t\toperator: token.value,\n\t\t\t\t\tmethod : token.method,\n\t\t\t\t\targs : [expr]\n\t\t\t\t};\n\t\t\t}\n\t\t\treturn parsePrimary();\n\t\t}\n\n\t\tfunction parsePrimary() {\n\t\t\tvar token, expr;\n\t\t\ttoken = lexer.peek();\n\t\t\tif (isUndef(token)) {\n\t\t\t\tthrow new SyntaxError(\"Tone.Expr: Unexpected termination of expression\");\n\t\t\t}\n\t\t\tif (token.type === \"func\") {\n\t\t\t\ttoken = lexer.next();\n\t\t\t\treturn parseFunctionCall(token);\n\t\t\t}\n\t\t\tif (token.type === \"value\") {\n\t\t\t\ttoken = lexer.next();\n\t\t\t\treturn {\n\t\t\t\t\tmethod : token.method,\n\t\t\t\t\targs : token.value\n\t\t\t\t};\n\t\t\t}\n\t\t\tif (matchSyntax(token, \"(\")) {\n\t\t\t\tlexer.next();\n\t\t\t\texpr = parseExpression();\n\t\t\t\ttoken = lexer.next();\n\t\t\t\tif (!matchSyntax(token, \")\")) {\n\t\t\t\t\tthrow new SyntaxError(\"Expected )\");\n\t\t\t\t}\n\t\t\t\treturn expr;\n\t\t\t}\n\t\t\tthrow new SyntaxError(\"Tone.Expr: Parse error, cannot process token \" + token.value);\n\t\t}\n\n\t\tfunction parseFunctionCall(func) {\n\t\t\tvar token, args = [];\n\t\t\ttoken = lexer.next();\n\t\t\tif (!matchSyntax(token, \"(\")) {\n\t\t\t\tthrow new SyntaxError(\"Tone.Expr: Expected ( in a function call \\\"\" + func.value + \"\\\"\");\n\t\t\t}\n\t\t\ttoken = lexer.peek();\n\t\t\tif (!matchSyntax(token, \")\")) {\n\t\t\t\targs = parseArgumentList();\n\t\t\t}\n\t\t\ttoken = lexer.next();\n\t\t\tif (!matchSyntax(token, \")\")) {\n\t\t\t\tthrow new SyntaxError(\"Tone.Expr: Expected ) in a function call \\\"\" + func.value + \"\\\"\");\n\t\t\t}\n\t\t\treturn {\n\t\t\t\tmethod : func.method,\n\t\t\t\targs : args,\n\t\t\t\tname : name\n\t\t\t};\n\t\t}\n\n\t\tfunction parseArgumentList() {\n\t\t\tvar token, expr, args = [];\n\t\t\twhile (true) {\n\t\t\t\texpr = parseExpression();\n\t\t\t\tif (isUndef(expr)) {\n\t\t\t\t\t// TODO maybe throw exception?\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\targs.push(expr);\n\t\t\t\ttoken = lexer.peek();\n\t\t\t\tif (!matchSyntax(token, \",\")) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\tlexer.next();\n\t\t\t}\n\t\t\treturn args;\n\t\t}\n\n\t\treturn parseExpression();\n\t};\n\n\t/**\n\t * recursively evaluate the expression tree\n\t * @param {Object} tree \n\t * @return {AudioNode} the resulting audio node from the expression\n\t * @private\n\t */\n\tTone.Expr.prototype._eval = function(tree){\n\t\tif (!this.isUndef(tree)){\n\t\t\tvar node = tree.method(tree.args, this);\n\t\t\tthis._nodes.push(node);\n\t\t\treturn node;\n\t\t} \n\t};\n\n\t/**\n\t * dispose all the nodes\n\t * @private\n\t */\n\tTone.Expr.prototype._disposeNodes = function(){\n\t\tfor (var i = 0; i < this._nodes.length; i++){\n\t\t\tvar node = this._nodes[i];\n\t\t\tif (this.isFunction(node.dispose)) {\n\t\t\t\tnode.dispose();\n\t\t\t} else if (this.isFunction(node.disconnect)) {\n\t\t\t\tnode.disconnect();\n\t\t\t}\n\t\t\tnode = null;\n\t\t\tthis._nodes[i] = null;\n\t\t}\n\t\tthis._nodes = null;\n\t};\n\n\t/**\n\t * clean up\n\t */\n\tTone.Expr.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._disposeNodes();\n\t};\n\n\treturn Tone.Expr;\n});","define([\"Tone/core/Tone\", \"Tone/signal/GreaterThanZero\", \"Tone/signal/Subtract\", \"Tone/signal/Signal\"], \n\tfunction(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Output 1 if the signal is greater than the value, otherwise outputs 0.\n\t * can compare two signals or a signal and a number. \n\t * \n\t * @constructor\n\t * @extends {Tone.Signal}\n\t * @param {number} [value=0] the value to compare to the incoming signal\n\t * @example\n\t * var gt = new Tone.GreaterThan(2);\n\t * var sig = new Tone.Signal(4).connect(gt);\n\t * //output of gt is equal 1. \n\t */\n\tTone.GreaterThan = function(value){\n\n\t\tthis.createInsOuts(2, 0);\n\t\t\n\t\t/**\n\t\t * subtract the amount from the incoming signal\n\t\t * @type {Tone.Subtract}\n\t\t * @private\n\t\t */\n\t\tthis._param = this.input[0] = new Tone.Subtract(value);\n\t\tthis.input[1] = this._param.input[1];\n\n\t\t/**\n\t\t * compare that amount to zero\n\t\t * @type {Tone.GreaterThanZero}\n\t\t * @private\n\t\t */\n\t\tthis._gtz = this.output = new Tone.GreaterThanZero();\n\n\t\t//connect\n\t\tthis._param.connect(this._gtz);\n\t};\n\n\tTone.extend(Tone.GreaterThan, Tone.Signal);\n\n\t/**\n\t * dispose method\n\t * @returns {Tone.GreaterThan} this\n\t */\n\tTone.GreaterThan.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._param.dispose();\n\t\tthis._param = null;\n\t\tthis._gtz.dispose();\n\t\tthis._gtz = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.GreaterThan;\n});","define([\"Tone/core/Tone\", \"Tone/signal/WaveShaper\", \"Tone/signal/SignalBase\"], \nfunction(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Return the absolute value of an incoming signal. \n\t * \n\t * @constructor\n\t * @extends {Tone.SignalBase}\n\t * @example\n\t * var signal = new Tone.Signal(-1);\n\t * var abs = new Tone.Abs();\n\t * signal.connect(abs);\n\t * //the output of abs is 1. \n\t */\n\tTone.Abs = function(){\n\t\t/**\n\t\t * @type {Tone.LessThan}\n\t\t * @private\n\t\t */\n\t\tthis._abs = this.input = this.output = new Tone.WaveShaper(function(val){\n\t\t\tif (val === 0){\n\t\t\t\treturn 0;\n\t\t\t} else {\n\t\t\t\treturn Math.abs(val);\n\t\t\t}\n\t\t}, 127);\n\t};\n\n\tTone.extend(Tone.Abs, Tone.SignalBase);\n\n\t/**\n\t * dispose method\n\t * @returns {Tone.Abs} this\n\t */\n\tTone.Abs.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._abs.dispose();\n\t\tthis._abs = null;\n\t\treturn this;\n\t}; \n\n\treturn Tone.Abs;\n});","define([\"Tone/core/Tone\", \"Tone/signal/WaveShaper\", \"Tone/signal/Multiply\", \"Tone/signal/Subtract\"], \nfunction(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Signal-rate modulo operator. Only works in AudioRange [-1, 1] and for modulus\n\t * values in the NormalRange. \n\t *\n\t * @constructor\n\t * @extends {Tone.SignalBase}\n\t * @param {NormalRange} modulus The modulus to apply.\n\t * @example\n\t * var mod = new Tone.Modulo(0.2)\n\t * var sig = new Tone.Signal(0.5).connect(mod);\n\t * //mod outputs 0.1\n\t */\n\tTone.Modulo = function(modulus){\n\n\t\tthis.createInsOuts(1, 0);\n\n\t\t/**\n\t\t * A waveshaper gets the integer multiple of \n\t\t * the input signal and the modulus.\n\t\t * @private\n\t\t * @type {Tone.WaveShaper}\n\t\t */\n\t\tthis._shaper = new Tone.WaveShaper(Math.pow(2, 16));\n\n\t\t/**\n\t\t * the integer multiple is multiplied by the modulus\n\t\t * @type {Tone.Multiply}\n\t\t * @private\n\t\t */\n\t\tthis._multiply = new Tone.Multiply();\n\n\t\t/**\n\t\t * and subtracted from the input signal\n\t\t * @type {Tone.Subtract}\n\t\t * @private\n\t\t */\n\t\tthis._subtract = this.output = new Tone.Subtract();\n\n\t\t/**\n\t\t * the modulus signal\n\t\t * @type {Tone.Signal}\n\t\t * @private\n\t\t */\n\t\tthis._modSignal = new Tone.Signal(modulus);\n\n\t\t//connections\n\t\tthis.input.fan(this._shaper, this._subtract);\n\t\tthis._modSignal.connect(this._multiply, 0, 0);\n\t\tthis._shaper.connect(this._multiply, 0, 1);\n\t\tthis._multiply.connect(this._subtract, 0, 1);\n\t\tthis._setWaveShaper(modulus);\n\t};\n\n\tTone.extend(Tone.Modulo, Tone.SignalBase);\n\n\t/**\n\t * @param {number} mod the modulus to apply\n\t * @private\n\t */\n\tTone.Modulo.prototype._setWaveShaper = function(mod){\n\t\tthis._shaper.setMap(function(val){\n\t\t\tvar multiple = Math.floor((val + 0.0001) / mod);\n\t\t\treturn multiple;\n\t\t});\n\t};\n\n\t/**\n\t * The modulus value.\n\t * @memberOf Tone.Modulo#\n\t * @type {NormalRange}\n\t * @name value\n\t */\n\tObject.defineProperty(Tone.Modulo.prototype, \"value\", {\n\t\tget : function(){\n\t\t\treturn this._modSignal.value;\n\t\t},\n\t\tset : function(mod){\n\t\t\tthis._modSignal.value = mod;\n\t\t\tthis._setWaveShaper(mod);\n\t\t}\n\t});\n\n\t/**\n\t * clean up\n\t * @returns {Tone.Modulo} this\n\t */\n\tTone.Modulo.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._shaper.dispose();\n\t\tthis._shaper = null;\n\t\tthis._multiply.dispose();\n\t\tthis._multiply = null;\n\t\tthis._subtract.dispose();\n\t\tthis._subtract = null;\n\t\tthis._modSignal.dispose();\n\t\tthis._modSignal = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.Modulo;\n});","define([\"Tone/core/Tone\", \"Tone/signal/WaveShaper\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Pow applies an exponent to the incoming signal. The incoming signal\n\t * must be AudioRange.\n\t *\n\t * @extends {Tone.SignalBase}\n\t * @constructor\n\t * @param {Positive} exp The exponent to apply to the incoming signal, must be at least 2. \n\t * @example\n\t * var pow = new Tone.Pow(2);\n\t * var sig = new Tone.Signal(0.5).connect(pow);\n\t * //output of pow is 0.25. \n\t */\n\tTone.Pow = function(exp){\n\n\t\t/**\n\t\t * the exponent\n\t\t * @private\n\t\t * @type {number}\n\t\t */\n\t\tthis._exp = this.defaultArg(exp, 1);\n\n\t\t/**\n\t\t * @type {WaveShaperNode}\n\t\t * @private\n\t\t */\n\t\tthis._expScaler = this.input = this.output = new Tone.WaveShaper(this._expFunc(this._exp), 8192);\n\t};\n\n\tTone.extend(Tone.Pow, Tone.SignalBase);\n\n\t/**\n\t * The value of the exponent.\n\t * @memberOf Tone.Pow#\n\t * @type {number}\n\t * @name value\n\t */\n\tObject.defineProperty(Tone.Pow.prototype, \"value\", {\n\t\tget : function(){\n\t\t\treturn this._exp;\n\t\t},\n\t\tset : function(exp){\n\t\t\tthis._exp = exp;\n\t\t\tthis._expScaler.setMap(this._expFunc(this._exp));\n\t\t}\n\t});\n\n\n\t/**\n\t * the function which maps the waveshaper\n\t * @param {number} exp\n\t * @return {function}\n\t * @private\n\t */\n\tTone.Pow.prototype._expFunc = function(exp){\n\t\treturn function(val){\n\t\t\treturn Math.pow(Math.abs(val), exp);\n\t\t};\n\t};\n\n\t/**\n\t * Clean up.\n\t * @returns {Tone.Pow} this\n\t */\n\tTone.Pow.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._expScaler.dispose();\n\t\tthis._expScaler = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.Pow;\n});","define([\"Tone/core/Tone\", \"Tone/signal/WaveShaper\", \"Tone/signal/Signal\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class AudioToGain converts an input in AudioRange [-1,1] to NormalRange [0,1]. \n\t * See Tone.GainToAudio.\n\t *\n\t * @extends {Tone.SignalBase}\n\t * @constructor\n\t * @example\n\t * var a2g = new Tone.AudioToGain();\n\t */\n\tTone.AudioToGain = function(){\n\n\t\t/**\n\t\t * @type {WaveShaperNode}\n\t\t * @private\n\t\t */\n\t\tthis._norm = this.input = this.output = new Tone.WaveShaper(function(x){\n\t\t\treturn (x + 1) / 2;\n\t\t});\n\t};\n\n\tTone.extend(Tone.AudioToGain, Tone.SignalBase);\n\n\t/**\n\t * clean up\n\t * @returns {Tone.AudioToGain} this\n\t */\n\tTone.AudioToGain.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._norm.dispose();\n\t\tthis._norm = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.AudioToGain;\n});","define([\"Tone/core/Tone\", \"Tone/signal/WaveShaper\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Convert an incoming signal between 0, 1 to an equal power gain scale.\n\t *\n\t * @extends {Tone.SignalBase}\n\t * @constructor\n\t * @example\n\t * var eqPowGain = new Tone.EqualPowerGain();\n\t */\n\tTone.EqualPowerGain = function(){\n\n\t\t/**\n\t\t * @type {Tone.WaveShaper}\n\t\t * @private\n\t\t */\n\t\tthis._eqPower = this.input = this.output = new Tone.WaveShaper(function(val){\n\t\t\tif (Math.abs(val) < 0.001){\n\t\t\t\t//should output 0 when input is 0\n\t\t\t\treturn 0;\n\t\t\t} else {\n\t\t\t\treturn this.equalPowerScale(val);\n\t\t\t}\n\t\t}.bind(this), 4096);\n\t};\n\n\tTone.extend(Tone.EqualPowerGain, Tone.SignalBase);\n\n\t/**\n\t * clean up\n\t * @returns {Tone.EqualPowerGain} this\n\t */\n\tTone.EqualPowerGain.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._eqPower.dispose();\n\t\tthis._eqPower = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.EqualPowerGain;\n});","'use strict';\n\ndefine(function (require) {\n\n var Effect = require('effect');\n var EQFilter = require('eqFilter');\n\n /**\n * p5.EQ is an audio effect that performs the function of a multiband\n * audio equalizer. Equalization is used to adjust the balance of\n * frequency compoenents of an audio signal. This process is commonly used\n * in sound production and recording to change the waveform before it reaches\n * a sound output device. EQ can also be used as an audio effect to create\n * interesting distortions by filtering out parts of the spectrum. p5.EQ is\n * built using a chain of Web Audio Biquad Filter Nodes and can be\n * instantiated with 3 or 8 bands. Bands can be added or removed from\n * the EQ by directly modifying p5.EQ.bands (the array that stores filters).\n *\n * This class extends p5.Effect.\n * Methods amp(), chain(),\n * drywet(), connect(), and\n * disconnect() are available.\n *\n * @class p5.EQ\n * @constructor\n * @extends p5.Effect\n * @param {Number} [_eqsize] Constructor will accept 3 or 8, defaults to 3\n * @return {Object} p5.EQ object\n *\n * @example\n *
\n * let eq, soundFile\n * let eqBandIndex = 0;\n * let eqBandNames = ['lows', 'mids', 'highs'];\n *\n * function preload() {\n * soundFormats('mp3', 'ogg');\n * soundFile = loadSound('assets/beat');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(toggleSound);\n *\n * eq = new p5.EQ(eqBandNames.length);\n * soundFile.disconnect();\n * eq.process(soundFile);\n * }\n *\n * function draw() {\n * background(30);\n * noStroke();\n * fill(255);\n * textAlign(CENTER);\n * text('filtering ', 50, 25);\n *\n * fill(255, 40, 255);\n * textSize(26);\n * text(eqBandNames[eqBandIndex], 50, 55);\n *\n * fill(255);\n * textSize(9);\n *\n * if (!soundFile.isPlaying()) {\n * text('tap to play', 50, 80);\n * } else {\n * text('tap to filter next band', 50, 80)\n * }\n * }\n *\n * function toggleSound() {\n * if (!soundFile.isPlaying()) {\n * soundFile.play();\n * } else {\n * eqBandIndex = (eqBandIndex + 1) % eq.bands.length;\n * }\n *\n * for (let i = 0; i < eq.bands.length; i++) {\n * eq.bands[i].gain(0);\n * }\n * // filter the band we want to filter\n * eq.bands[eqBandIndex].gain(-40);\n * }\n *
\n */\n p5.EQ = function(_eqsize) {\n Effect.call(this);\n\n //p5.EQ can be of size (3) or (8), defaults to 3\n _eqsize = _eqsize === 3 || _eqsize === 8 ? _eqsize : 3;\n\n var factor;\n _eqsize === 3 ? factor = Math.pow(2,3) : factor = 2;\n\n /**\n * The p5.EQ is built with abstracted p5.Filter objects.\n * To modify any bands, use methods of the \n * p5.Filter API, especially `gain` and `freq`.\n * Bands are stored in an array, with indices 0 - 3, or 0 - 7\n * @property {Array} bands\n *\n */\n this.bands = [];\n\n\n var freq, res;\n for (var i = 0; i < _eqsize; i++) {\n if (i === _eqsize - 1) {\n freq = 21000;\n res = .01;\n } else if (i === 0) {\n freq = 100;\n res = .1;\n }\n else if (i===1) {\n freq = _eqsize === 3 ? 360 * factor : 360;\n res = 1;\n }else {\n freq = this.bands[i-1].freq() * factor;\n res = 1;\n }\n this.bands[i] = this._newBand(freq, res);\n\n if (i>0) {\n this.bands[i-1].connect(this.bands[i].biquad);\n } else {\n this.input.connect(this.bands[i].biquad);\n }\n }\n this.bands[_eqsize-1].connect(this.output);\n };\n p5.EQ.prototype = Object.create(Effect.prototype);\n\n /**\n * Process an input by connecting it to the EQ\n * @method process\n * @param {Object} src Audio source\n */\n p5.EQ.prototype.process = function (src) {\n src.connect(this.input);\n };\n\n // /**\n // * Set the frequency and gain of each band in the EQ. This method should be\n // * called with 3 or 8 frequency and gain pairs, depending on the size of the EQ.\n // * ex. eq.set(freq0, gain0, freq1, gain1, freq2, gain2);\n // *\n // * @method set\n // * @for p5.EQ\n // * @param {Number} [freq0] Frequency value for band with index 0\n // * @param {Number} [gain0] Gain value for band with index 0\n // * @param {Number} [freq1] Frequency value for band with index 1\n // * @param {Number} [gain1] Gain value for band with index 1\n // * @param {Number} [freq2] Frequency value for band with index 2\n // * @param {Number} [gain2] Gain value for band with index 2\n // * @param {Number} [freq3] Frequency value for band with index 3\n // * @param {Number} [gain3] Gain value for band with index 3\n // * @param {Number} [freq4] Frequency value for band with index 4\n // * @param {Number} [gain4] Gain value for band with index 4\n // * @param {Number} [freq5] Frequency value for band with index 5\n // * @param {Number} [gain5] Gain value for band with index 5\n // * @param {Number} [freq6] Frequency value for band with index 6\n // * @param {Number} [gain6] Gain value for band with index 6\n // * @param {Number} [freq7] Frequency value for band with index 7\n // * @param {Number} [gain7] Gain value for band with index 7\n // */\n p5.EQ.prototype.set = function() {\n if (arguments.length === this.bands.length * 2) {\n for (var i = 0; i < arguments.length; i+=2) {\n this.bands[i/2].freq(arguments[i]);\n this.bands[i/2].gain(arguments[i+1]);\n }\n }\n else {\n console.error('Argument mismatch. .set() should be called with ' + this.bands.length*2 +\n ' arguments. (one frequency and gain value pair for each band of the eq)');\n }\n };\n\n /**\n * Add a new band. Creates a p5.Filter and strips away everything but\n * the raw biquad filter. This method returns an abstracted p5.Filter,\n * which can be added to p5.EQ.bands, in order to create new EQ bands.\n * @private\n * @for p5.EQ\n * @method _newBand\n * @param {Number} freq\n * @param {Number} res\n * @return {Object} Abstracted Filter\n */\n p5.EQ.prototype._newBand = function(freq, res) {\n return new EQFilter(freq, res);\n };\n\n p5.EQ.prototype.dispose = function () {\n Effect.prototype.dispose.apply(this);\n\n if (this.bands) {\n while (this.bands.length > 0) {\n delete this.bands.pop().dispose();\n }\n delete this.bands;\n }\n };\n\n return p5.EQ;\n});\n","'use strict';\n\ndefine(function (require) {\n var Filter = require('filter');\n var p5sound = require('master');\n\n /**\n * EQFilter extends p5.Filter with constraints\n * necessary for the p5.EQ\n *\n * @private\n */\n var EQFilter = function(freq, res) {\n Filter.call(this, 'peaking');\n this.disconnect();\n this.set(freq, res);\n this.biquad.gain.value = 0;\n delete this.input;\n delete this.output;\n delete this._drywet;\n delete this.wet;\n\n };\n EQFilter.prototype = Object.create(Filter.prototype);\n\n EQFilter.prototype.amp = function() {\n console.warn('`amp()` is not available for p5.EQ bands. Use `.gain()`');\n };\n EQFilter.prototype.drywet = function() {\n console.warn('`drywet()` is not available for p5.EQ bands.');\n };\n EQFilter.prototype.connect = function(unit) {\n var u = unit || p5.soundOut.input;\n if (this.biquad) {\n this.biquad.connect(u.input ? u.input : u);\n } else {\n this.output.connect(u.input ? u.input : u);\n }\n };\n\n EQFilter.prototype.disconnect = function() {\n if (this.biquad) {\n this.biquad.disconnect();\n }\n };\n EQFilter.prototype.dispose = function() {\n // remove reference form soundArray\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n this.disconnect();\n delete this.biquad;\n };\n\n return EQFilter;\n});\n","'use strict'\n\ndefine(function (require) {\n var p5sound = require('master');\n var Effect = require('effect');\n\n /**\n * Panner3D is based on the \n * Web Audio Spatial Panner Node.\n * This panner is a spatial processing node that allows audio to be positioned\n * and oriented in 3D space.\n *\n * The position is relative to an \n * Audio Context Listener, which can be accessed\n * by p5.soundOut.audiocontext.listener\n *\n *\n * @class p5.Panner3D\n * @constructor\n */\n\tp5.Panner3D = function() {\n Effect.call(this);\n\n /**\n * \n * Web Audio Spatial Panner Node\n *\n * Properties include\n * - panningModel: \"equal power\" or \"HRTF\"\n * - distanceModel: \"linear\", \"inverse\", or \"exponential\"\n *\n * @property {AudioNode} panner\n *\n */\n this.panner = this.ac.createPanner();\n this.panner.panningModel = 'HRTF';\n this.panner.distanceModel = 'linear';\n this.panner.connect(this.output);\n this.input.connect(this.panner);\n\t};\n\n p5.Panner3D.prototype = Object.create(Effect.prototype);\n\n\n /**\n * Connect an audio sorce\n *\n * @method process\n * @for p5.Panner3D\n * @param {Object} src Input source\n */\n p5.Panner3D.prototype.process = function(src) {\n src.connect(this.input);\n }\n /**\n * Set the X,Y,Z position of the Panner\n * @method set\n * @for p5.Panner3D\n * @param {Number} xVal\n * @param {Number} yVal\n * @param {Number} zVal\n * @param {Number} time\n * @return {Array} Updated x, y, z values as an array\n */\n p5.Panner3D.prototype.set = function(xVal, yVal, zVal, time) {\n this.positionX(xVal,time);\n this.positionY(yVal,time);\n this.positionZ(zVal,time);\n return [this.panner.positionX.value,\n this.panner.positionY.value,\n this.panner.positionZ.value];\n };\n\n /**\n * Getter and setter methods for position coordinates\n * @method positionX\n * @for p5.Panner3D\n * @return {Number} updated coordinate value\n */\n /**\n * Getter and setter methods for position coordinates\n * @method positionY\n * @for p5.Panner3D\n * @return {Number} updated coordinate value\n */\n /**\n * Getter and setter methods for position coordinates\n * @method positionZ\n * @for p5.Panner3D\n * @return {Number} updated coordinate value\n */\n p5.Panner3D.prototype.positionX = function(xVal, time) {\n var t = time || 0;\n if (typeof xVal === 'number') {\n this.panner.positionX.value = xVal;\n this.panner.positionX.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.panner.positionX.linearRampToValueAtTime(xVal, this.ac.currentTime + 0.02 + t);\n } else if (xVal) {\n xVal.connect(this.panner.positionX);\n }\n return this.panner.positionX.value;\n };\n p5.Panner3D.prototype.positionY = function(yVal, time) {\n var t = time || 0;\n if (typeof yVal === 'number') {\n this.panner.positionY.value = yVal;\n this.panner.positionY.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.panner.positionY.linearRampToValueAtTime(yVal, this.ac.currentTime + 0.02 + t);\n } else if (yVal) {\n yVal.connect(this.panner.positionY);\n }\n return this.panner.positionY.value;\n };\n p5.Panner3D.prototype.positionZ = function(zVal, time) {\n var t = time || 0;\n if (typeof zVal === 'number') {\n this.panner.positionZ.value = zVal;\n this.panner.positionZ.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.panner.positionZ.linearRampToValueAtTime(zVal, this.ac.currentTime + 0.02 + t);\n } else if (zVal) {\n zVal.connect(this.panner.positionZ);\n }\n return this.panner.positionZ.value;\n };\n\n /**\n * Set the X,Y,Z position of the Panner\n * @method orient\n * @for p5.Panner3D\n * @param {Number} xVal\n * @param {Number} yVal\n * @param {Number} zVal\n * @param {Number} time\n * @return {Array} Updated x, y, z values as an array\n */\n p5.Panner3D.prototype.orient = function(xVal, yVal, zVal, time) {\n this.orientX(xVal,time);\n this.orientY(yVal,time);\n this.orientZ(zVal,time);\n return [this.panner.orientationX.value,\n this.panner.orientationY.value,\n this.panner.orientationZ.value];\n };\n\n /**\n * Getter and setter methods for orient coordinates\n * @method orientX\n * @for p5.Panner3D\n * @return {Number} updated coordinate value\n */\n /**\n * Getter and setter methods for orient coordinates\n * @method orientY\n * @for p5.Panner3D\n * @return {Number} updated coordinate value\n */\n /**\n * Getter and setter methods for orient coordinates\n * @method orientZ\n * @for p5.Panner3D\n * @return {Number} updated coordinate value\n */\n p5.Panner3D.prototype.orientX = function(xVal, time) {\n var t = time || 0;\n if (typeof xVal === 'number') {\n this.panner.orientationX.value = xVal;\n this.panner.orientationX.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.panner.orientationX.linearRampToValueAtTime(xVal, this.ac.currentTime + 0.02 + t);\n } else if (xVal) {\n xVal.connect(this.panner.orientationX);\n }\n return this.panner.orientationX.value;\n };\n p5.Panner3D.prototype.orientY = function(yVal, time) {\n var t = time || 0;\n if (typeof yVal === 'number') {\n this.panner.orientationY.value = yVal;\n this.panner.orientationY.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.panner.orientationY.linearRampToValueAtTime(yVal, this.ac.currentTime + 0.02 + t);\n } else if (yVal) {\n yVal.connect(this.panner.orientationY);\n }\n return this.panner.orientationY.value;\n };\n p5.Panner3D.prototype.orientZ = function(zVal, time) {\n var t = time || 0;\n if (typeof zVal === 'number') {\n this.panner.orientationZ.value = zVal;\n this.panner.orientationZ.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.panner.orientationZ.linearRampToValueAtTime(zVal, this.ac.currentTime + 0.02 + t);\n } else if (zVal) {\n zVal.connect(this.panner.orientationZ);\n }\n return this.panner.orientationZ.value;\n };\n\n /**\n * Set the rolloff factor and max distance\n * @method setFalloff\n * @for p5.Panner3D\n * @param {Number} [maxDistance]\n * @param {Number} [rolloffFactor]\n */\n p5.Panner3D.prototype.setFalloff = function(maxDistance, rolloffFactor) {\n this.maxDist(maxDistance);\n this.rolloff(rolloffFactor);\n };\n /**\n * Maxium distance between the source and the listener\n * @method maxDist\n * @for p5.Panner3D\n * @param {Number} maxDistance\n * @return {Number} updated value\n */\n p5.Panner3D.prototype.maxDist = function(maxDistance){\n if (typeof maxDistance === 'number') {\n this.panner.maxDistance = maxDistance;\n }\n return this.panner.maxDistance;\n };\n\n /**\n * How quickly the volume is reduced as the source moves away from the listener\n * @method rollof\n * @for p5.Panner3D\n * @param {Number} rolloffFactor\n * @return {Number} updated value\n */\n p5.Panner3D.prototype.rolloff = function(rolloffFactor){\n if (typeof rolloffFactor === 'number') {\n this.panner.rolloffFactor = rolloffFactor;\n }\n return this.panner.rolloffFactor;\n };\n\n p5.Panner3D.dispose = function() {\n Effect.prototype.dispose.apply(this);\n if (this.panner) {\n this.panner.disconnect();\n delete this.panner;\n }\n };\n\n return p5.Panner3D;\n\n});\n","'use strict'\n\ndefine(function (require) {\n var p5sound = require('master');\n var Effect = require('effect');\n\n// /**\n// * listener is a class that can construct both a Spatial Panner\n// * and a Spatial Listener. The panner is based on the \n// * Web Audio Spatial Panner Node\n// * https://www.w3.org/TR/webaudio/#the-listenernode-interface\n// * This panner is a spatial processing node that allows audio to be positioned\n// * and oriented in 3D space. \n// *\n// * The Listener modifies the properties of the Audio Context Listener. \n// * Both objects types use the same methods. The default is a spatial panner.\n// *\n// * p5.Panner3D - Constructs a Spatial Panner
\n// * p5.Listener3D - Constructs a Spatial Listener
\n// *\n// * @class listener\n// * @constructor\n// * @return {Object} p5.Listener3D Object\n// *\n// * @param {Web Audio Node} listener Web Audio Spatial Panning Node\n// * @param {AudioParam} listener.panningModel \"equal power\" or \"HRTF\"\n// * @param {AudioParam} listener.distanceModel \"linear\", \"inverse\", or \"exponential\"\n// * @param {String} [type] [Specify construction of a spatial panner or listener]\n// */\n \n\tp5.Listener3D = function(type) {\n this.ac = p5sound.audiocontext;\n this.listener = this.ac.listener;\n\t}; \n\n// /**\n// * Connect an audio sorce\n// * @param {Object} src Input source\n// */\n p5.Listener3D.prototype.process = function(src) {\n src.connect(this.input);\n }\n// /**\n// * Set the X,Y,Z position of the Panner\n// * @param {[Number]} xVal\n// * @param {[Number]} yVal\n// * @param {[Number]} zVal\n// * @param {[Number]} time\n// * @return {[Array]} [Updated x, y, z values as an array]\n// */\n p5.Listener3D.prototype.position = function(xVal, yVal, zVal, time) {\n this.positionX(xVal,time);\n this.positionY(yVal,time);\n this.positionZ(zVal,time);\n return [this.listener.positionX.value, \n this.listener.positionY.value,\n this.listener.positionZ.value];\n };\n\n// /**\n// * Getter and setter methods for position coordinates\n// * @return {Number} [updated coordinate value]\n// */\n p5.Listener3D.prototype.positionX = function(xVal, time) {\n var t = time || 0;\n if (typeof xVal === 'number') {\n this.listener.positionX.value = xVal;\n this.listener.positionX.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.listener.positionX.linearRampToValueAtTime(xVal, this.ac.currentTime + 0.02 + t);\n } else if (xVal) {\n xVal.connect(this.listener.positionX);\n }\n return this.listener.positionX.value;\n };\n p5.Listener3D.prototype.positionY = function(yVal, time) {\n var t = time || 0;\n if (typeof yVal === 'number') {\n this.listener.positionY.value = yVal;\n this.listener.positionY.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.listener.positionY.linearRampToValueAtTime(yVal, this.ac.currentTime + 0.02 + t);\n } else if (yVal) {\n yVal.connect(this.listener.positionY);\n }\n return this.listener.positionY.value;\n };\n p5.Listener3D.prototype.positionZ = function(zVal, time) {\n var t = time || 0;\n if (typeof zVal === 'number') {\n this.listener.positionZ.value = zVal;\n this.listener.positionZ.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.listener.positionZ.linearRampToValueAtTime(zVal, this.ac.currentTime + 0.02 + t);\n } else if (zVal) {\n zVal.connect(this.listener.positionZ);\n }\n return this.listener.positionZ.value;\n };\n\n// cannot define method when class definition is commented\n// /**\n// * Overrides the listener orient() method because Listener has slightly\n// * different params. In human terms, Forward vectors are the direction the \n// * nose is pointing. Up vectors are the direction of the top of the head.\n// *\n// * @method orient\n// * @param {Number} xValF Forward vector X direction\n// * @param {Number} yValF Forward vector Y direction\n// * @param {Number} zValF Forward vector Z direction\n// * @param {Number} xValU Up vector X direction\n// * @param {Number} yValU Up vector Y direction\n// * @param {Number} zValU Up vector Z direction\n// * @param {Number} time \n// * @return {Array} All orienation params\n// */\n p5.Listener3D.prototype.orient = function(xValF, yValF, zValF, \n xValU, yValU, zValU, time) {\n\n if (arguments.length === 3 || arguments.length === 4) {\n time = arguments[3];\n this.orientForward(xValF, yValF, zValF, time);\n } else if (arguments.length === 6 || arguments === 7) {\n this.orientForward(xValF, yValF, zValF);\n this.orientUp(xValU, yValU, zValU, time);\n }\n \n return [this.listener.forwardX.value, \n this.listener.forwardY.value,\n this.listener.forwardZ.value,\n this.listener.upX.value,\n this.listener.upY.value,\n this.listener.upZ.value];\n };\n\n\n p5.Listener3D.prototype.orientForward = function(xValF, yValF, zValF, time) {\n this.forwardX(xValF,time);\n this.forwardY(yValF,time);\n this.forwardZ(zValF,time);\n\n return [this.listener.forwardX, \n this.listener.forwardY,\n this.listener.forwardZ];\n };\n\n p5.Listener3D.prototype.orientUp = function(xValU, yValU, zValU, time) {\n this.upX(xValU,time);\n this.upY(yValU,time);\n this.upZ(zValU,time);\n\n return [this.listener.upX, \n this.listener.upY,\n this.listener.upZ];\n };\n// /**\n// * Getter and setter methods for orient coordinates\n// * @return {Number} [updated coordinate value]\n// */\n p5.Listener3D.prototype.forwardX = function(xVal, time) {\n var t = time || 0;\n if (typeof xVal === 'number') {\n this.listener.forwardX.value = xVal;\n this.listener.forwardX.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.listener.forwardX.linearRampToValueAtTime(xVal, this.ac.currentTime + 0.02 + t);\n } else if (xVal) {\n xVal.connect(this.listener.forwardX);\n }\n return this.listener.forwardX.value;\n };\n p5.Listener3D.prototype.forwardY = function(yVal, time) {\n var t = time || 0;\n if (typeof yVal === 'number') {\n this.listener.forwardY.value = yVal;\n this.listener.forwardY.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.listener.forwardY.linearRampToValueAtTime(yVal, this.ac.currentTime + 0.02 + t);\n } else if (yVal) {\n yVal.connect(this.listener.forwardY);\n }\n return this.listener.forwardY.value;\n };\n p5.Listener3D.prototype.forwardZ = function(zVal, time) {\n var t = time || 0;\n if (typeof zVal === 'number') {\n this.listener.forwardZ.value = zVal;\n this.listener.forwardZ.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.listener.forwardZ.linearRampToValueAtTime(zVal, this.ac.currentTime + 0.02 + t);\n } else if (zVal) {\n zVal.connect(this.listener.forwardZ);\n }\n return this.listener.forwardZ.value;\n };\n p5.Listener3D.prototype.upX = function(xVal, time) {\n var t = time || 0;\n if (typeof xVal === 'number') {\n this.listener.upX.value = xVal;\n this.listener.upX.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.listener.upX.linearRampToValueAtTime(xVal, this.ac.currentTime + 0.02 + t);\n } else if (xVal) {\n xVal.connect(this.listener.upX);\n }\n return this.listener.upX.value;\n };\n p5.Listener3D.prototype.upY = function(yVal, time) {\n var t = time || 0;\n if (typeof yVal === 'number') {\n this.listener.upY.value = yVal;\n this.listener.upY.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.listener.upY.linearRampToValueAtTime(yVal, this.ac.currentTime + 0.02 + t);\n } else if (yVal) {\n yVal.connect(this.listener.upY);\n }\n return this.listener.upY.value;\n };\n p5.Listener3D.prototype.upZ = function(zVal, time) {\n var t = time || 0;\n if (typeof zVal === 'number') {\n this.listener.upZ.value = zVal;\n this.listener.upZ.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.listener.upZ.linearRampToValueAtTime(zVal, this.ac.currentTime + 0.02 + t);\n } else if (zVal) {\n zVal.connect(this.listener.upZ);\n }\n return this.listener.upZ.value;\n };\n \n return p5.Listener3D;\n\n});","'use strict';\n\ndefine(function (require) {\n var Filter = require('filter');\n var Effect = require('effect');\n\n /**\n * Delay is an echo effect. It processes an existing sound source,\n * and outputs a delayed version of that sound. The p5.Delay can\n * produce different effects depending on the delayTime, feedback,\n * filter, and type. In the example below, a feedback of 0.5 (the\n * default value) will produce a looping delay that decreases in\n * volume by 50% each repeat. A filter will cut out the high\n * frequencies so that the delay does not sound as piercing as the\n * original source.\n *\n *\n * This class extends p5.Effect.\n * Methods amp(), chain(),\n * drywet(), connect(), and\n * disconnect() are available.\n * @class p5.Delay\n * @extends p5.Effect\n * @constructor\n * @example\n *
\n * let osc;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * background(220);\n * textAlign(CENTER);\n * text('tap to play', width/2, height/2);\n *\n * osc = new p5.Oscillator('square');\n * osc.amp(0.5);\n * delay = new p5.Delay();\n *\n * // delay.process() accepts 4 parameters:\n * // source, delayTime (in seconds), feedback, filter frequency\n * delay.process(osc, 0.12, .7, 2300);\n *\n * cnv.mousePressed(oscStart);\n * }\n *\n * function oscStart() {\n * osc.start();\n * }\n *\n * function mouseReleased() {\n * osc.stop();\n * }\n *
\n */\n p5.Delay = function() {\n \tEffect.call(this);\n\n this._split = this.ac.createChannelSplitter(2);\n this._merge = this.ac.createChannelMerger(2);\n\n this._leftGain = this.ac.createGain();\n this._rightGain = this.ac.createGain();\n\n /**\n * The p5.Delay is built with two\n * \n * Web Audio Delay Nodes, one for each stereo channel.\n *\n * @for p5.Delay\n * @property {DelayNode} leftDelay\n */\n this.leftDelay = this.ac.createDelay();\n /**\n * The p5.Delay is built with two\n * \n * Web Audio Delay Nodes, one for each stereo channel.\n * @for p5.Delay\n * @property {DelayNode} rightDelay\n */\n this.rightDelay = this.ac.createDelay();\n\n this._leftFilter = new Filter();\n this._rightFilter = new Filter();\n this._leftFilter.disconnect();\n this._rightFilter.disconnect();\n\n this._leftFilter.biquad.frequency.setValueAtTime(1200, this.ac.currentTime);\n this._rightFilter.biquad.frequency.setValueAtTime(1200, this.ac.currentTime);\n this._leftFilter.biquad.Q.setValueAtTime(0.3, this.ac.currentTime);\n this._rightFilter.biquad.Q.setValueAtTime(0.3, this.ac.currentTime);\n\n // graph routing\n this.input.connect(this._split);\n this.leftDelay.connect(this._leftGain);\n this.rightDelay.connect(this._rightGain);\n this._leftGain.connect(this._leftFilter.input);\n this._rightGain.connect(this._rightFilter.input);\n this._merge.connect(this.wet);\n\n\n this._leftFilter.biquad.gain.setValueAtTime(1, this.ac.currentTime);\n this._rightFilter.biquad.gain.setValueAtTime(1, this.ac.currentTime);\n\n // default routing\n this.setType(0);\n\n this._maxDelay = this.leftDelay.delayTime.maxValue;\n\n // set initial feedback to 0.5\n this.feedback(0.5);\n\n\n };\n\n p5.Delay.prototype = Object.create(Effect.prototype);\n /**\n * Add delay to an audio signal according to a set\n * of delay parameters.\n *\n * @method process\n * @for p5.Delay\n * @param {Object} Signal An object that outputs audio\n * @param {Number} [delayTime] Time (in seconds) of the delay/echo.\n * Some browsers limit delayTime to\n * 1 second.\n * @param {Number} [feedback] sends the delay back through itself\n * in a loop that decreases in volume\n * each time.\n * @param {Number} [lowPass] Cutoff frequency. Only frequencies\n * below the lowPass will be part of the\n * delay.\n */\n p5.Delay.prototype.process = function(src, _delayTime, _feedback, _filter) {\n var feedback = _feedback || 0;\n var delayTime = _delayTime || 0;\n if (feedback >= 1.0) {\n throw new Error('Feedback value will force a positive feedback loop.');\n }\n if (delayTime >= this._maxDelay) {\n throw new Error('Delay Time exceeds maximum delay time of ' + this._maxDelay + ' second.');\n }\n\n src.connect(this.input);\n this.leftDelay.delayTime.setValueAtTime(delayTime, this.ac.currentTime);\n this.rightDelay.delayTime.setValueAtTime(delayTime, this.ac.currentTime);\n this._leftGain.gain.value = feedback;\n this._rightGain.gain.value = feedback;\n\n if (_filter) {\n this._leftFilter.freq(_filter);\n this._rightFilter.freq(_filter);\n }\n };\n\n /**\n * Set the delay (echo) time, in seconds. Usually this value will be\n * a floating point number between 0.0 and 1.0.\n *\n * @method delayTime\n * @for p5.Delay\n * @param {Number} delayTime Time (in seconds) of the delay\n */\n p5.Delay.prototype.delayTime = function(t) {\n // if t is an audio node...\n if (typeof t !== 'number') {\n t.connect(this.leftDelay.delayTime);\n t.connect(this.rightDelay.delayTime);\n }\n\n else {\n this.leftDelay.delayTime.cancelScheduledValues(this.ac.currentTime);\n this.rightDelay.delayTime.cancelScheduledValues(this.ac.currentTime);\n this.leftDelay.delayTime.linearRampToValueAtTime(t, this.ac.currentTime);\n this.rightDelay.delayTime.linearRampToValueAtTime(t, this.ac.currentTime);\n }\n };\n\n /**\n * Feedback occurs when Delay sends its signal back through its input\n * in a loop. The feedback amount determines how much signal to send each\n * time through the loop. A feedback greater than 1.0 is not desirable because\n * it will increase the overall output each time through the loop,\n * creating an infinite feedback loop. The default value is 0.5\n *\n * @method feedback\n * @for p5.Delay\n * @param {Number|Object} feedback 0.0 to 1.0, or an object such as an\n * Oscillator that can be used to\n * modulate this param\n * @returns {Number} Feedback value\n *\n */\n p5.Delay.prototype.feedback = function(f) {\n // if f is an audio node...\n if (f && typeof f !== 'number') {\n f.connect(this._leftGain.gain);\n f.connect(this._rightGain.gain);\n }\n else if (f >= 1.0) {\n throw new Error('Feedback value will force a positive feedback loop.');\n }\n else if (typeof f === 'number') {\n this._leftGain.gain.value = f;\n this._rightGain.gain.value = f;\n }\n\n // return value of feedback\n return this._leftGain.gain.value;\n };\n\n /**\n * Set a lowpass filter frequency for the delay. A lowpass filter\n * will cut off any frequencies higher than the filter frequency.\n *\n * @method filter\n * @for p5.Delay\n * @param {Number|Object} cutoffFreq A lowpass filter will cut off any\n * frequencies higher than the filter frequency.\n * @param {Number|Object} res Resonance of the filter frequency\n * cutoff, or an object (i.e. a p5.Oscillator)\n * that can be used to modulate this parameter.\n * High numbers (i.e. 15) will produce a resonance,\n * low numbers (i.e. .2) will produce a slope.\n */\n p5.Delay.prototype.filter = function(freq, q) {\n this._leftFilter.set(freq, q);\n this._rightFilter.set(freq, q);\n };\n\n\n /**\n * Choose a preset type of delay. 'pingPong' bounces the signal\n * from the left to the right channel to produce a stereo effect.\n * Any other parameter will revert to the default delay setting.\n *\n * @method setType\n * @for p5.Delay\n * @param {String|Number} type 'pingPong' (1) or 'default' (0)\n */\n p5.Delay.prototype.setType = function(t) {\n if (t === 1) {\n t = 'pingPong';\n }\n this._split.disconnect();\n this._leftFilter.disconnect();\n this._rightFilter.disconnect();\n this._split.connect(this.leftDelay, 0);\n this._split.connect(this.rightDelay, 1);\n switch(t) {\n case 'pingPong':\n this._rightFilter.setType( this._leftFilter.biquad.type );\n this._leftFilter.output.connect(this._merge, 0, 0);\n this._rightFilter.output.connect(this._merge, 0, 1);\n this._leftFilter.output.connect(this.rightDelay);\n this._rightFilter.output.connect(this.leftDelay);\n break;\n default:\n this._leftFilter.output.connect(this._merge, 0, 0);\n this._rightFilter.output.connect(this._merge, 0, 1);\n this._leftFilter.output.connect(this.leftDelay);\n this._rightFilter.output.connect(this.rightDelay);\n }\n };\n\n // DocBlocks for methods inherited from p5.Effect\n /**\n * Set the output level of the delay effect.\n *\n * @method amp\n * @for p5.Delay\n * @param {Number} volume amplitude between 0 and 1.0\n * @param {Number} [rampTime] create a fade that lasts rampTime\n * @param {Number} [timeFromNow] schedule this event to happen\n * seconds from now\n */\n /**\n * Send output to a p5.sound or web audio object\n *\n * @method connect\n * @for p5.Delay\n * @param {Object} unit\n */\n /**\n * Disconnect all output.\n *\n * @method disconnect\n * @for p5.Delay\n */\n\n p5.Delay.prototype.dispose = function() {\n\n Effect.prototype.dispose.apply(this);\n\n this._split.disconnect();\n this._leftFilter.dispose();\n this._rightFilter.dispose();\n this._merge.disconnect();\n this._leftGain.disconnect();\n this._rightGain.disconnect();\n this.leftDelay.disconnect();\n this.rightDelay.disconnect();\n\n this._split = undefined;\n this._leftFilter = undefined;\n this._rightFilter = undefined;\n this._merge = undefined;\n this._leftGain = undefined;\n this._rightGain = undefined;\n this.leftDelay = undefined;\n this.rightDelay = undefined;\n };\n\n});\n","'use strict';\n\ndefine(function (require) {\n var CustomError = require('errorHandler');\n var Effect = require('effect');\n\n /**\n * Reverb adds depth to a sound through a large number of decaying\n * echoes. It creates the perception that sound is occurring in a\n * physical space. The p5.Reverb has paramters for Time (how long does the\n * reverb last) and decayRate (how much the sound decays with each echo)\n * that can be set with the .set() or .process() methods. The p5.Convolver\n * extends p5.Reverb allowing you to recreate the sound of actual physical\n * spaces through convolution.\n *\n * This class extends p5.Effect.\n * Methods amp(), chain(),\n * drywet(), connect(), and\n * disconnect() are available.\n *\n * @class p5.Reverb\n * @extends p5.Effect\n * @constructor\n * @example\n *
\n * let soundFile, reverb;\n * function preload() {\n * soundFile = loadSound('assets/Damscray_DancingTiger.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playSound);\n *\n * reverb = new p5.Reverb();\n * soundFile.disconnect(); // so we'll only hear reverb...\n *\n * // connect soundFile to reverb, process w/\n * // 3 second reverbTime, decayRate of 2%\n * reverb.process(soundFile, 3, 2);\n * }\n *\n * function draw() {\n * let dryWet = constrain(map(mouseX, 0, width, 0, 1), 0, 1);\n * // 1 = all reverb, 0 = no reverb\n * reverb.drywet(dryWet);\n *\n * background(220);\n * text('tap to play', 10, 20);\n * text('dry/wet: ' + round(dryWet * 100) + '%', 10, height - 20);\n * }\n *\n * function playSound() {\n * soundFile.play();\n * }\n *
\n */\n\n\n p5.Reverb = function() {\n Effect.call(this);\n\n this._initConvolverNode();\n\n // otherwise, Safari distorts\n this.input.gain.value = 0.5;\n\n // default params\n this._seconds = 3;\n this._decay = 2;\n this._reverse = false;\n\n this._buildImpulse();\n\n };\n\n p5.Reverb.prototype = Object.create(Effect.prototype);\n\n p5.Reverb.prototype._initConvolverNode = function() {\n this.convolverNode = this.ac.createConvolver();\n this.input.connect(this.convolverNode);\n this.convolverNode.connect(this.wet);\n };\n\n p5.Reverb.prototype._teardownConvolverNode = function() {\n if (this.convolverNode) {\n this.convolverNode.disconnect();\n delete this.convolverNode;\n }\n };\n\n p5.Reverb.prototype._setBuffer = function(audioBuffer) {\n this._teardownConvolverNode();\n this._initConvolverNode();\n this.convolverNode.buffer = audioBuffer;\n };\n /**\n * Connect a source to the reverb, and assign reverb parameters.\n *\n * @method process\n * @for p5.Reverb\n * @param {Object} src p5.sound / Web Audio object with a sound\n * output.\n * @param {Number} [seconds] Duration of the reverb, in seconds.\n * Min: 0, Max: 10. Defaults to 3.\n * @param {Number} [decayRate] Percentage of decay with each echo.\n * Min: 0, Max: 100. Defaults to 2.\n * @param {Boolean} [reverse] Play the reverb backwards or forwards.\n */\n p5.Reverb.prototype.process = function(src, seconds, decayRate, reverse) {\n src.connect(this.input);\n var rebuild = false;\n if (seconds) {\n this._seconds = seconds;\n rebuild = true;\n }\n if (decayRate) {\n this._decay = decayRate;\n }\n if (reverse) {\n this._reverse = reverse;\n }\n if (rebuild) {\n this._buildImpulse();\n }\n };\n\n /**\n * Set the reverb settings. Similar to .process(), but without\n * assigning a new input.\n *\n * @method set\n * @for p5.Reverb\n * @param {Number} [seconds] Duration of the reverb, in seconds.\n * Min: 0, Max: 10. Defaults to 3.\n * @param {Number} [decayRate] Percentage of decay with each echo.\n * Min: 0, Max: 100. Defaults to 2.\n * @param {Boolean} [reverse] Play the reverb backwards or forwards.\n */\n p5.Reverb.prototype.set = function(seconds, decayRate, reverse) {\n var rebuild = false;\n if (seconds) {\n this._seconds = seconds;\n rebuild = true;\n }\n if (decayRate) {\n this._decay = decayRate;\n }\n if (reverse) {\n this._reverse = reverse;\n }\n if (rebuild) {\n this._buildImpulse();\n }\n };\n\n // DocBlocks for methods inherited from p5.Effect\n /**\n * Set the output level of the reverb effect.\n *\n * @method amp\n * @for p5.Reverb\n * @param {Number} volume amplitude between 0 and 1.0\n * @param {Number} [rampTime] create a fade that lasts rampTime\n * @param {Number} [timeFromNow] schedule this event to happen\n * seconds from now\n */\n /**\n * Send output to a p5.sound or web audio object\n *\n * @method connect\n * @for p5.Reverb\n * @param {Object} unit\n */\n /**\n * Disconnect all output.\n *\n * @method disconnect\n * @for p5.Reverb\n */\n\n /**\n * Inspired by Simple Reverb by Jordan Santell\n * https://github.com/web-audio-components/simple-reverb/blob/master/index.js\n *\n * Utility function for building an impulse response\n * based on the module parameters.\n *\n * @private\n */\n p5.Reverb.prototype._buildImpulse = function() {\n var rate = this.ac.sampleRate;\n var length = rate*this._seconds;\n var decay = this._decay;\n var impulse = this.ac.createBuffer(2, length, rate);\n var impulseL = impulse.getChannelData(0);\n var impulseR = impulse.getChannelData(1);\n var n, i;\n for (i = 0; i < length; i++) {\n n = this._reverse ? length - i : i;\n impulseL[i] = (Math.random() * 2 - 1) * Math.pow(1 - n / length, decay);\n impulseR[i] = (Math.random() * 2 - 1) * Math.pow(1 - n / length, decay);\n }\n this._setBuffer(impulse);\n };\n\n p5.Reverb.prototype.dispose = function() {\n Effect.prototype.dispose.apply(this);\n this._teardownConvolverNode();\n };\n\n // =======================================================================\n // *** p5.Convolver ***\n // =======================================================================\n\n /**\n *

p5.Convolver extends p5.Reverb. It can emulate the sound of real\n * physical spaces through a process called \n * convolution.

\n *\n *

Convolution multiplies any audio input by an \"impulse response\"\n * to simulate the dispersion of sound over time. The impulse response is\n * generated from an audio file that you provide. One way to\n * generate an impulse response is to pop a balloon in a reverberant space\n * and record the echo. Convolution can also be used to experiment with\n * sound.

\n *\n *

Use the method createConvolution(path) to instantiate a\n * p5.Convolver with a path to your impulse response audio file.

\n *\n * @class p5.Convolver\n * @extends p5.Effect\n * @constructor\n * @param {String} path path to a sound file\n * @param {Function} [callback] function to call when loading succeeds\n * @param {Function} [errorCallback] function to call if loading fails.\n * This function will receive an error or\n * XMLHttpRequest object with information\n * about what went wrong.\n * @example\n *
\n * let cVerb, sound;\n * function preload() {\n * // We have both MP3 and OGG versions of all sound assets\n * soundFormats('ogg', 'mp3');\n *\n * // Try replacing 'bx-spring' with other soundfiles like\n * // 'concrete-tunnel' 'small-plate' 'drum' 'beatbox'\n * cVerb = createConvolver('assets/bx-spring.mp3');\n *\n * // Try replacing 'Damscray_DancingTiger' with\n * // 'beat', 'doorbell', lucky_dragons_-_power_melody'\n * sound = loadSound('assets/Damscray_DancingTiger.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playSound);\n * background(220);\n * text('tap to play', 20, 20);\n *\n * // disconnect from master output...\n * sound.disconnect();\n *\n * // ...and process with cVerb\n * // so that we only hear the convolution\n * cVerb.process(sound);\n * }\n *\n * function playSound() {\n * sound.play();\n * }\n *
\n */\n p5.Convolver = function(path, callback, errorCallback) {\n \t p5.Reverb.call(this);\n\n /**\n * Internally, the p5.Convolver uses the a\n * \n * Web Audio Convolver Node.\n *\n * @property {ConvolverNode} convolverNode\n */\n this._initConvolverNode();\n\n // otherwise, Safari distorts\n this.input.gain.value = 0.5;\n\n if (path) {\n this.impulses = [];\n this._loadBuffer(path, callback, errorCallback);\n }\n else {\n // parameters\n this._seconds = 3;\n this._decay = 2;\n this._reverse = false;\n\n this._buildImpulse();\n }\n\n };\n\n p5.Convolver.prototype = Object.create(p5.Reverb.prototype);\n\n p5.prototype.registerPreloadMethod('createConvolver', p5.prototype);\n\n /**\n * Create a p5.Convolver. Accepts a path to a soundfile\n * that will be used to generate an impulse response.\n *\n * @method createConvolver\n * @for p5\n * @param {String} path path to a sound file\n * @param {Function} [callback] function to call if loading is successful.\n * The object will be passed in as the argument\n * to the callback function.\n * @param {Function} [errorCallback] function to call if loading is not successful.\n * A custom error will be passed in as the argument\n * to the callback function.\n * @return {p5.Convolver}\n * @example\n *
\n * let cVerb, sound;\n * function preload() {\n * // We have both MP3 and OGG versions of all sound assets\n * soundFormats('ogg', 'mp3');\n *\n * // Try replacing 'bx-spring' with other soundfiles like\n * // 'concrete-tunnel' 'small-plate' 'drum' 'beatbox'\n * cVerb = createConvolver('assets/bx-spring.mp3');\n *\n * // Try replacing 'Damscray_DancingTiger' with\n * // 'beat', 'doorbell', lucky_dragons_-_power_melody'\n * sound = loadSound('assets/Damscray_DancingTiger.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playSound);\n * background(220);\n * text('tap to play', 20, 20);\n *\n * // disconnect from master output...\n * sound.disconnect();\n *\n * // ...and process with cVerb\n * // so that we only hear the convolution\n * cVerb.process(sound);\n * }\n *\n * function playSound() {\n * sound.play();\n * }\n *
\n */\n p5.prototype.createConvolver = function(path, callback, errorCallback) {\n // if loading locally without a server\n if (window.location.origin.indexOf('file://') > -1 && window.cordova === 'undefined') {\n alert('This sketch may require a server to load external files. Please see http://bit.ly/1qcInwS');\n }\n var self = this;\n var cReverb = new p5.Convolver(path, function(buffer) {\n if (typeof callback === 'function') {\n callback(buffer);\n }\n\n if (typeof self._decrementPreload === 'function') {\n self._decrementPreload();\n }\n }, errorCallback);\n cReverb.impulses = [];\n return cReverb;\n };\n\n /**\n * Private method to load a buffer as an Impulse Response,\n * assign it to the convolverNode, and add to the Array of .impulses.\n *\n * @param {String} path\n * @param {Function} callback\n * @param {Function} errorCallback\n * @private\n */\n p5.Convolver.prototype._loadBuffer = function(path, callback, errorCallback) {\n var path = p5.prototype._checkFileFormats(path);\n var self = this;\n var errorTrace = new Error().stack;\n var ac = p5.prototype.getAudioContext();\n\n var request = new XMLHttpRequest();\n request.open('GET', path, true);\n request.responseType = 'arraybuffer';\n\n request.onload = function() {\n if (request.status === 200) {\n // on success loading file:\n ac.decodeAudioData(request.response,\n function(buff) {\n var buffer = {};\n var chunks = path.split('/');\n buffer.name = chunks[chunks.length - 1];\n buffer.audioBuffer = buff;\n self.impulses.push(buffer);\n self._setBuffer(buffer.audioBuffer);\n if (callback) {\n callback(buffer);\n }\n },\n // error decoding buffer. \"e\" is undefined in Chrome 11/22/2015\n function() {\n var err = new CustomError('decodeAudioData', errorTrace, self.url);\n var msg = 'AudioContext error at decodeAudioData for ' + self.url;\n if (errorCallback) {\n err.msg = msg;\n errorCallback(err);\n } else {\n console.error(msg +'\\n The error stack trace includes: \\n' + err.stack);\n }\n }\n );\n }\n // if request status != 200, it failed\n else {\n var err = new CustomError('loadConvolver', errorTrace, self.url);\n var msg = 'Unable to load ' + self.url +\n '. The request status was: ' + request.status + ' (' + request.statusText + ')';\n\n if (errorCallback) {\n err.message = msg;\n errorCallback(err);\n } else {\n console.error(msg +'\\n The error stack trace includes: \\n' + err.stack);\n }\n }\n };\n\n // if there is another error, aside from 404...\n request.onerror = function() {\n var err = new CustomError('loadConvolver', errorTrace, self.url);\n var msg = 'There was no response from the server at ' + self.url + '. Check the url and internet connectivity.';\n\n if (errorCallback) {\n err.message = msg;\n errorCallback(err);\n } else {\n console.error(msg +'\\n The error stack trace includes: \\n' + err.stack);\n }\n };\n request.send();\n };\n\n p5.Convolver.prototype.set = null;\n\n /**\n * Connect a source to the convolver.\n *\n * @method process\n * @for p5.Convolver\n * @param {Object} src p5.sound / Web Audio object with a sound\n * output.\n * @example\n *
\n * let cVerb, sound;\n * function preload() {\n * // We have both MP3 and OGG versions of all sound assets\n * soundFormats('ogg', 'mp3');\n *\n * // Try replacing 'bx-spring' with other soundfiles like\n * // 'concrete-tunnel' 'small-plate' 'drum' 'beatbox'\n * cVerb = createConvolver('assets/bx-spring.mp3');\n *\n * // Try replacing 'Damscray_DancingTiger' with\n * // 'beat', 'doorbell', lucky_dragons_-_power_melody'\n * sound = loadSound('assets/Damscray_DancingTiger.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playSound);\n * background(220);\n * text('tap to play', 20, 20);\n *\n * // disconnect from master output...\n * sound.disconnect();\n *\n * // ...and process with cVerb\n * // so that we only hear the convolution\n * cVerb.process(sound);\n * }\n *\n * function playSound() {\n * sound.play();\n * }\n *\n *
\n */\n p5.Convolver.prototype.process = function(src) {\n src.connect(this.input);\n };\n\n /**\n * If you load multiple impulse files using the .addImpulse method,\n * they will be stored as Objects in this Array. Toggle between them\n * with the toggleImpulse(id) method.\n *\n * @property {Array} impulses\n * @for p5.Convolver\n */\n p5.Convolver.prototype.impulses = [];\n\n /**\n * Load and assign a new Impulse Response to the p5.Convolver.\n * The impulse is added to the .impulses array. Previous\n * impulses can be accessed with the .toggleImpulse(id)\n * method.\n *\n * @method addImpulse\n * @for p5.Convolver\n * @param {String} path path to a sound file\n * @param {Function} callback function (optional)\n * @param {Function} errorCallback function (optional)\n */\n p5.Convolver.prototype.addImpulse = function(path, callback, errorCallback) {\n // if loading locally without a server\n if (window.location.origin.indexOf('file://') > -1 && window.cordova === 'undefined') {\n alert('This sketch may require a server to load external files. Please see http://bit.ly/1qcInwS');\n }\n this._loadBuffer(path, callback, errorCallback);\n };\n\n /**\n * Similar to .addImpulse, except that the .impulses\n * Array is reset to save memory. A new .impulses\n * array is created with this impulse as the only item.\n *\n * @method resetImpulse\n * @for p5.Convolver\n * @param {String} path path to a sound file\n * @param {Function} callback function (optional)\n * @param {Function} errorCallback function (optional)\n */\n p5.Convolver.prototype.resetImpulse = function(path, callback, errorCallback) {\n // if loading locally without a server\n if (window.location.origin.indexOf('file://') > -1 && window.cordova === 'undefined') {\n alert('This sketch may require a server to load external files. Please see http://bit.ly/1qcInwS');\n }\n this.impulses = [];\n this._loadBuffer(path, callback, errorCallback);\n };\n\n /**\n * If you have used .addImpulse() to add multiple impulses\n * to a p5.Convolver, then you can use this method to toggle between\n * the items in the .impulses Array. Accepts a parameter\n * to identify which impulse you wish to use, identified either by its\n * original filename (String) or by its position in the .impulses\n * Array (Number).
\n * You can access the objects in the .impulses Array directly. Each\n * Object has two attributes: an .audioBuffer (type:\n * Web Audio \n * AudioBuffer) and a .name, a String that corresponds\n * with the original filename.\n *\n * @method toggleImpulse\n * @for p5.Convolver\n * @param {String|Number} id Identify the impulse by its original filename\n * (String), or by its position in the\n * .impulses Array (Number).\n */\n p5.Convolver.prototype.toggleImpulse = function(id) {\n if (typeof id === 'number' && id < this.impulses.length) {\n this._setBuffer(this.impulses[id].audioBuffer);\n }\n if (typeof id === 'string') {\n for (var i = 0; i < this.impulses.length; i++) {\n if (this.impulses[i].name === id) {\n this._setBuffer(this.impulses[i].audioBuffer);\n break;\n }\n }\n }\n };\n\n p5.Convolver.prototype.dispose = function() {\n p5.Reverb.prototype.dispose.apply(this);\n\n // remove all the Impulse Response buffers\n for (var i in this.impulses) {\n if (this.impulses[i]) {\n this.impulses[i] = null;\n }\n }\n };\n\n});\n","'use strict';\n\ndefine(function (require) {\n var p5sound = require('master');\n\n // requires the Tone.js library's Clock (MIT license, Yotam Mann)\n // https://github.com/TONEnoTONE/Tone.js/\n var Clock = require('Tone/core/Clock');\n\n p5.Metro = function() {\n this.clock = new Clock({\n 'callback': this.ontick.bind(this)\n });\n this.syncedParts = [];\n this.bpm = 120; // gets overridden by p5.Part\n this._init();\n\n this.prevTick = 0;\n this.tatumTime = 0;\n\n this.tickCallback = function() {};\n };\n\n p5.Metro.prototype.ontick = function(tickTime) {\n var elapsedTime = tickTime - this.prevTick;\n var secondsFromNow = tickTime - p5sound.audiocontext.currentTime;\n if (elapsedTime - this.tatumTime <= -0.02) {\n return;\n } else {\n // console.log('ok', this.syncedParts[0].phrases[0].name);\n this.prevTick = tickTime;\n\n // for all of the active things on the metro:\n var self = this;\n this.syncedParts.forEach(function(thisPart) {\n if (!thisPart.isPlaying) return;\n thisPart.incrementStep(secondsFromNow);\n // each synced source keeps track of its own beat number\n thisPart.phrases.forEach(function(thisPhrase) {\n var phraseArray = thisPhrase.sequence;\n var bNum = self.metroTicks % phraseArray.length;\n if (phraseArray[bNum] !== 0 && (self.metroTicks < phraseArray.length || !thisPhrase.looping) ) {\n thisPhrase.callback(secondsFromNow, phraseArray[bNum]);\n }\n });\n });\n this.metroTicks += 1;\n this.tickCallback(secondsFromNow);\n }\n };\n\n p5.Metro.prototype.setBPM = function(bpm, rampTime) {\n var beatTime = 60 / (bpm*this.tatums);\n var now = p5sound.audiocontext.currentTime;\n this.tatumTime = beatTime;\n\n var rampTime = rampTime || 0;\n this.clock.frequency.setValueAtTime(this.clock.frequency.value, now);\n this.clock.frequency.linearRampToValueAtTime(bpm, now + rampTime);\n this.bpm = bpm;\n };\n\n p5.Metro.prototype.getBPM = function() {\n return this.clock.getRate() / this.tatums * 60;\n };\n\n p5.Metro.prototype._init = function() {\n this.metroTicks = 0;\n // this.setBPM(120);\n };\n\n // clear existing synced parts, add only this one\n p5.Metro.prototype.resetSync = function(part) {\n this.syncedParts = [part];\n };\n\n // push a new synced part to the array\n p5.Metro.prototype.pushSync = function(part) {\n this.syncedParts.push(part);\n };\n\n p5.Metro.prototype.start = function(timeFromNow) {\n var t = timeFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n this.clock.start(now + t);\n this.setBPM(this.bpm);\n };\n\n p5.Metro.prototype.stop = function(timeFromNow) {\n var t = timeFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n this.clock.stop(now + t);\n };\n\n p5.Metro.prototype.beatLength = function(tatums) {\n this.tatums = 1/tatums / 4; // lowest possible division of a beat\n };\n\n});\n","define([\"Tone/core/Tone\", \"Tone/core/Timeline\", \"Tone/type/Type\"], function (Tone) {\n\n\t\"use strict\";\n\n\t/**\n\t * @class A Timeline State. Provides the methods: setStateAtTime(\"state\", time)\n\t * and getValueAtTime(time).\n\t *\n\t * @extends {Tone.Timeline}\n\t * @param {String} initial The initial state of the TimelineState. \n\t * Defaults to undefined\n\t */\n\tTone.TimelineState = function(initial){\n\n\t\tTone.Timeline.call(this);\n\n\t\t/**\n\t\t * The initial state\n\t\t * @private\n\t\t * @type {String}\n\t\t */\n\t\tthis._initial = initial;\n\t};\n\n\tTone.extend(Tone.TimelineState, Tone.Timeline);\n\n\t/**\n\t * Returns the scheduled state scheduled before or at\n\t * the given time.\n\t * @param {Number} time The time to query.\n\t * @return {String} The name of the state input in setStateAtTime.\n\t */\n\tTone.TimelineState.prototype.getValueAtTime = function(time){\n\t\tvar event = this.get(time);\n\t\tif (event !== null){\n\t\t\treturn event.state;\n\t\t} else {\n\t\t\treturn this._initial;\n\t\t}\n\t};\n\n\t/**\n\t * Returns the scheduled state scheduled before or at\n\t * the given time.\n\t * @param {String} state The name of the state to set.\n\t * @param {Number} time The time to query.\n\t */\n\tTone.TimelineState.prototype.setStateAtTime = function(state, time){\n\t\tthis.add({\n\t\t\t\"state\" : state,\n\t\t\t\"time\" : time\n\t\t});\n\t};\n\n\treturn Tone.TimelineState;\n});","'use strict';\n\ndefine(function(require) {\n var p5sound = require('master');\n\n var BPM = 120;\n\n /**\n * Set the global tempo, in beats per minute, for all\n * p5.Parts. This method will impact all active p5.Parts.\n *\n * @method setBPM\n * @for p5\n * @param {Number} BPM Beats Per Minute\n * @param {Number} rampTime Seconds from now\n */\n p5.prototype.setBPM = function(bpm, rampTime) {\n BPM = bpm;\n for (var i in p5sound.parts) {\n if (p5sound.parts[i]) {\n p5sound.parts[i].setBPM(bpm, rampTime);\n }\n }\n };\n\n /**\n *

A phrase is a pattern of musical events over time, i.e.\n * a series of notes and rests.

\n *\n *

Phrases must be added to a p5.Part for playback, and\n * each part can play multiple phrases at the same time.\n * For example, one Phrase might be a kick drum, another\n * could be a snare, and another could be the bassline.

\n *\n *

The first parameter is a name so that the phrase can be\n * modified or deleted later. The callback is a a function that\n * this phrase will call at every step—for example it might be\n * called playNote(value){}. The array determines\n * which value is passed into the callback at each step of the\n * phrase. It can be numbers, an object with multiple numbers,\n * or a zero (0) indicates a rest so the callback won't be called).

\n *\n * @class p5.Phrase\n * @constructor\n * @param {String} name Name so that you can access the Phrase.\n * @param {Function} callback The name of a function that this phrase\n * will call. Typically it will play a sound,\n * and accept two parameters: a time at which\n * to play the sound (in seconds from now),\n * and a value from the sequence array. The\n * time should be passed into the play() or\n * start() method to ensure precision.\n * @param {Array} sequence Array of values to pass into the callback\n * at each step of the phrase.\n * @example\n *
\n * let mySound, myPhrase, myPart;\n * let pattern = [1,0,0,2,0,2,0,0];\n *\n * function preload() {\n * mySound = loadSound('assets/beatbox.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playMyPart);\n * background(220);\n * text('tap to play', width/2, height/2);\n * textAlign(CENTER, CENTER);\n *\n * myPhrase = new p5.Phrase('bbox', onEachStep, pattern);\n * myPart = new p5.Part();\n * myPart.addPhrase(myPhrase);\n * myPart.setBPM(60);\n * }\n *\n * function onEachStep(time, playbackRate) {\n * mySound.rate(playbackRate);\n * mySound.play(time);\n * }\n *\n * function playMyPart() {\n * userStartAudio();\n * myPart.start();\n * }\n *
\n */\n p5.Phrase = function(name, callback, sequence) {\n this.phraseStep = 0;\n this.name = name;\n this.callback = callback;\n /**\n * Array of values to pass into the callback\n * at each step of the phrase. Depending on the callback\n * function's requirements, these values may be numbers,\n * strings, or an object with multiple parameters.\n * Zero (0) indicates a rest.\n *\n * @property {Array} sequence\n */\n this.sequence = sequence;\n };\n\n /**\n *

A p5.Part plays back one or more p5.Phrases. Instantiate a part\n * with steps and tatums. By default, each step represents a 1/16th note.

\n *\n *

See p5.Phrase for more about musical timing.

\n *\n * @class p5.Part\n * @constructor\n * @param {Number} [steps] Steps in the part\n * @param {Number} [tatums] Divisions of a beat, e.g. use 1/4, or 0.25 for a quater note (default is 1/16, a sixteenth note)\n * @example\n *
\n * let box, drum, myPart;\n * let boxPat = [1,0,0,2,0,2,0,0];\n * let drumPat = [0,1,1,0,2,0,1,0];\n *\n * function preload() {\n * box = loadSound('assets/beatbox.mp3');\n * drum = loadSound('assets/drum.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playMyPart);\n * background(220);\n * textAlign(CENTER, CENTER);\n * text('tap to play', width/2, height/2);\n *\n * let boxPhrase = new p5.Phrase('box', playBox, boxPat);\n * let drumPhrase = new p5.Phrase('drum', playDrum, drumPat);\n * myPart = new p5.Part();\n * myPart.addPhrase(boxPhrase);\n * myPart.addPhrase(drumPhrase);\n * myPart.setBPM(60);\n * }\n *\n * function playBox(time, playbackRate) {\n * box.rate(playbackRate);\n * box.play(time);\n * }\n *\n * function playDrum(time, playbackRate) {\n * drum.rate(playbackRate);\n * drum.play(time);\n * }\n *\n * function playMyPart() {\n * userStartAudio();\n *\n * myPart.start();\n * }\n *
\n */\n p5.Part = function(steps, bLength) {\n this.length = steps || 0; // how many beats\n this.partStep = 0;\n this.phrases = [];\n this.isPlaying = false;\n this.noLoop();\n this.tatums = bLength || 0.0625; // defaults to quarter note\n\n this.metro = new p5.Metro();\n this.metro._init();\n this.metro.beatLength(this.tatums);\n this.metro.setBPM(BPM);\n p5sound.parts.push(this);\n this.callback = function() {};\n };\n\n /**\n * Set the tempo of this part, in Beats Per Minute.\n *\n * @method setBPM\n * @for p5.Part\n * @param {Number} BPM Beats Per Minute\n * @param {Number} [rampTime] Seconds from now\n */\n p5.Part.prototype.setBPM = function(tempo, rampTime) {\n this.metro.setBPM(tempo, rampTime);\n };\n\n /**\n * Returns the tempo, in Beats Per Minute, of this part.\n *\n * @method getBPM\n * @for p5.Part\n * @return {Number}\n */\n p5.Part.prototype.getBPM = function() {\n return this.metro.getBPM();\n };\n\n /**\n * Start playback of this part. It will play\n * through all of its phrases at a speed\n * determined by setBPM.\n *\n * @method start\n * @for p5.Part\n * @param {Number} [time] seconds from now\n */\n p5.Part.prototype.start = function(time) {\n if (!this.isPlaying) {\n this.isPlaying = true;\n this.metro.resetSync(this);\n var t = time || 0;\n this.metro.start(t);\n }\n };\n\n /**\n * Loop playback of this part. It will begin\n * looping through all of its phrases at a speed\n * determined by setBPM.\n *\n * @method loop\n * @for p5.Part\n * @param {Number} [time] seconds from now\n */\n p5.Part.prototype.loop = function(time) {\n this.looping = true;\n // rest onended function\n this.onended = function() {\n this.partStep = 0;\n };\n var t = time || 0;\n this.start(t);\n };\n\n /**\n * Tell the part to stop looping.\n *\n * @method noLoop\n * @for p5.Part\n */\n p5.Part.prototype.noLoop = function() {\n this.looping = false;\n // rest onended function\n this.onended = function() {\n this.stop();\n };\n };\n\n /**\n * Stop the part and cue it to step 0. Playback will resume from the begining of the Part when it is played again.\n *\n * @method stop\n * @for p5.Part\n * @param {Number} [time] seconds from now\n */\n p5.Part.prototype.stop = function(time) {\n this.partStep = 0;\n this.pause(time);\n };\n\n /**\n * Pause the part. Playback will resume\n * from the current step.\n *\n * @method pause\n * @for p5.Part\n * @param {Number} time seconds from now\n */\n p5.Part.prototype.pause = function(time) {\n this.isPlaying = false;\n var t = time || 0;\n this.metro.stop(t);\n };\n\n /**\n * Add a p5.Phrase to this Part.\n *\n * @method addPhrase\n * @for p5.Part\n * @param {p5.Phrase} phrase reference to a p5.Phrase\n */\n p5.Part.prototype.addPhrase = function(name, callback, array) {\n var p;\n if (arguments.length === 3) {\n p = new p5.Phrase(name, callback, array);\n } else if (arguments[0] instanceof p5.Phrase) {\n p = arguments[0];\n } else {\n throw 'invalid input. addPhrase accepts name, callback, array or a p5.Phrase';\n }\n this.phrases.push(p);\n // reset the length if phrase is longer than part's existing length\n if (p.sequence.length > this.length) {\n this.length = p.sequence.length;\n }\n };\n\n /**\n * Remove a phrase from this part, based on the name it was\n * given when it was created.\n *\n * @method removePhrase\n * @for p5.Part\n * @param {String} phraseName\n */\n p5.Part.prototype.removePhrase = function(name) {\n for (var i in this.phrases) {\n if (this.phrases[i].name === name) {\n this.phrases.splice(i, 1);\n }\n }\n };\n\n /**\n * Get a phrase from this part, based on the name it was\n * given when it was created. Now you can modify its array.\n *\n * @method getPhrase\n * @for p5.Part\n * @param {String} phraseName\n */\n p5.Part.prototype.getPhrase = function(name) {\n for (var i in this.phrases) {\n if (this.phrases[i].name === name) {\n return this.phrases[i];\n }\n }\n };\n\n /**\n * Find all sequences with the specified name, and replace their patterns with the specified array.\n *\n * @method replaceSequence\n * @for p5.Part\n * @param {String} phraseName\n * @param {Array} sequence Array of values to pass into the callback\n * at each step of the phrase.\n */\n p5.Part.prototype.replaceSequence = function(name, array) {\n for (var i in this.phrases) {\n if (this.phrases[i].name === name) {\n this.phrases[i].sequence = array;\n }\n }\n };\n\n p5.Part.prototype.incrementStep = function(time) {\n if (this.partStep < this.length - 1) {\n this.callback(time);\n this.partStep += 1;\n } else {\n if (!this.looping && this.partStep === this.length - 1) {\n // this.callback(time);\n this.onended();\n }\n }\n };\n\n /**\n * Set the function that will be called at every step. This will clear the previous function.\n *\n * @method onStep\n * @for p5.Part\n * @param {Function} callback The name of the callback\n * you want to fire\n * on every beat/tatum.\n */\n p5.Part.prototype.onStep = function(callback) {\n this.callback = callback;\n };\n\n\n // ===============\n // p5.Score\n // ===============\n\n /**\n * A Score consists of a series of Parts. The parts will\n * be played back in order. For example, you could have an\n * A part, a B part, and a C part, and play them back in this order\n * new p5.Score(a, a, b, a, c)\n *\n * @class p5.Score\n * @constructor\n * @param {p5.Part} [...parts] One or multiple parts, to be played in sequence.\n */\n p5.Score = function() {\n // for all of the arguments\n this.parts = [];\n this.currentPart = 0;\n\n var thisScore = this;\n for (var i in arguments) {\n if (arguments[i] && this.parts[i]) {\n this.parts[i] = arguments[i];\n this.parts[i].nextPart = this.parts[i + 1];\n this.parts[i].onended = function() {\n thisScore.resetPart(i);\n playNextPart(thisScore);\n };\n }\n }\n this.looping = false;\n };\n\n p5.Score.prototype.onended = function() {\n if (this.looping) {\n // this.resetParts();\n this.parts[0].start();\n } else {\n this.parts[this.parts.length - 1].onended = function() {\n this.stop();\n this.resetParts();\n };\n }\n this.currentPart = 0;\n };\n\n /**\n * Start playback of the score.\n *\n * @method start\n * @for p5.Score\n */\n p5.Score.prototype.start = function() {\n this.parts[this.currentPart].start();\n this.scoreStep = 0;\n };\n\n /**\n * Stop playback of the score.\n *\n * @method stop\n * @for p5.Score\n */\n p5.Score.prototype.stop = function() {\n this.parts[this.currentPart].stop();\n this.currentPart = 0;\n this.scoreStep = 0;\n };\n\n /**\n * Pause playback of the score.\n *\n * @method pause\n * @for p5.Score\n */\n p5.Score.prototype.pause = function() {\n this.parts[this.currentPart].stop();\n };\n\n /**\n * Loop playback of the score.\n *\n * @method loop\n * @for p5.Score\n */\n p5.Score.prototype.loop = function() {\n this.looping = true;\n this.start();\n };\n\n /**\n * Stop looping playback of the score. If it\n * is currently playing, this will go into effect\n * after the current round of playback completes.\n *\n * @method noLoop\n * @for p5.Score\n */\n p5.Score.prototype.noLoop = function() {\n this.looping = false;\n };\n\n p5.Score.prototype.resetParts = function() {\n var self = this;\n this.parts.forEach(function(part) {\n self.resetParts[part];\n });\n };\n\n p5.Score.prototype.resetPart = function(i) {\n this.parts[i].stop();\n this.parts[i].partStep = 0;\n for (var p in this.parts[i].phrases) {\n if (this.parts[i]) {\n this.parts[i].phrases[p].phraseStep = 0;\n }\n }\n };\n\n /**\n * Set the tempo for all parts in the score\n *\n * @method setBPM\n * @for p5.Score\n * @param {Number} BPM Beats Per Minute\n * @param {Number} rampTime Seconds from now\n */\n p5.Score.prototype.setBPM = function(bpm, rampTime) {\n for (var i in this.parts) {\n if (this.parts[i]) {\n this.parts[i].setBPM(bpm, rampTime);\n }\n }\n };\n\n function playNextPart(aScore) {\n aScore.currentPart++;\n if (aScore.currentPart >= aScore.parts.length) {\n aScore.scoreStep = 0;\n aScore.onended();\n } else {\n aScore.scoreStep = 0;\n aScore.parts[aScore.currentPart - 1].stop();\n aScore.parts[aScore.currentPart].start();\n }\n }\n\n});\n","'use strict';\n\ndefine(function (require) {\n var p5sound = require('master');\n var Clock = require('Tone/core/Clock');\n\n /**\n * SoundLoop\n *\n * @class p5.SoundLoop\n * @constructor\n *\n * @param {Function} callback this function will be called on each iteration of theloop\n * @param {Number|String} [interval] amount of time (if a number) or beats (if a string, following Tone.Time convention) for each iteration of the loop. Defaults to 1 second.\n *\n * @example\n *
\n * let synth, soundLoop;\n * let notePattern = [60, 62, 64, 67, 69, 72];\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * colorMode(HSB);\n * background(0, 0, 86);\n * text('tap to start/stop', 10, 20);\n *\n * //the looper's callback is passed the timeFromNow\n * //this value should be used as a reference point from\n * //which to schedule sounds\n * let intervalInSeconds = 0.2;\n * soundLoop = new p5.SoundLoop(onSoundLoop, intervalInSeconds);\n *\n * synth = new p5.MonoSynth();\n * }\n *\n * function canvasPressed() {\n * // ensure audio is enabled\n * userStartAudio();\n *\n * if (soundLoop.isPlaying) {\n * soundLoop.stop();\n * } else {\n * // start the loop\n * soundLoop.start();\n * }\n * }\n *\n * function onSoundLoop(timeFromNow) {\n * let noteIndex = (soundLoop.iterations - 1) % notePattern.length;\n * let note = midiToFreq(notePattern[noteIndex]);\n * synth.play(note, 0.5, timeFromNow);\n * background(noteIndex * 360 / notePattern.length, 50, 100);\n * }\n *
\n */\n p5.SoundLoop = function(callback, interval) {\n this.callback = callback;\n /**\n * musicalTimeMode uses Tone.Time convention\n * true if string, false if number\n * @property {Boolean} musicalTimeMode\n */\n this.musicalTimeMode = typeof this._interval === 'number' ? false : true;\n\n this._interval = interval || 1;\n\n /**\n * musicalTimeMode variables\n * modify these only when the interval is specified in musicalTime format as a string\n */\n this._timeSignature = 4;\n this._bpm = 60;\n\n this.isPlaying = false;\n\n /**\n * Set a limit to the number of loops to play. defaults to Infinity\n * @property {Number} maxIterations\n */\n this.maxIterations = Infinity;\n var self = this;\n\n this.clock = new Clock({\n 'callback' : function(time) {\n var timeFromNow = time - p5sound.audiocontext.currentTime;\n /**\n * Do not initiate the callback if timeFromNow is < 0\n * This ususually occurs for a few milliseconds when the page\n * is not fully loaded\n *\n * The callback should only be called until maxIterations is reached\n */\n if (timeFromNow > 0 && self.iterations <= self.maxIterations) {\n self.callback(timeFromNow);}\n },\n 'frequency' : this._calcFreq()\n });\n };\n\n /**\n * Start the loop\n * @method start\n * @for p5.SoundLoop\n * @param {Number} [timeFromNow] schedule a starting time\n */\n p5.SoundLoop.prototype.start = function(timeFromNow) {\n var t = timeFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n if (!this.isPlaying) {\n this.clock.start(now + t);\n this.isPlaying = true;\n }\n };\n\n /**\n * Stop the loop\n * @method stop\n * @for p5.SoundLoop\n * @param {Number} [timeFromNow] schedule a stopping time\n */\n p5.SoundLoop.prototype.stop = function(timeFromNow) {\n var t = timeFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n if (this.isPlaying) {\n this.clock.stop(now + t);\n this.isPlaying = false;\n }\n };\n /**\n * Pause the loop\n * @method pause\n * @for p5.SoundLoop\n * @param {Number} [timeFromNow] schedule a pausing time\n */\n p5.SoundLoop.prototype.pause = function(timeFromNow) {\n var t = timeFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n if (this.isPlaying) {\n this.clock.pause(now + t);\n this.isPlaying = false;\n }\n };\n\n\n /**\n * Synchronize loops. Use this method to start two or more loops in synchronization\n * or to start a loop in synchronization with a loop that is already playing\n * This method will schedule the implicit loop in sync with the explicit master loop\n * i.e. loopToStart.syncedStart(loopToSyncWith)\n *\n * @method syncedStart\n * @for p5.SoundLoop\n * @param {Object} otherLoop a p5.SoundLoop to sync with\n * @param {Number} [timeFromNow] Start the loops in sync after timeFromNow seconds\n */\n p5.SoundLoop.prototype.syncedStart = function(otherLoop, timeFromNow) {\n var t = timeFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n\n if (!otherLoop.isPlaying) {\n otherLoop.clock.start(now + t);\n otherLoop.isPlaying = true;\n this.clock.start(now + t);\n this.isPlaying = true;\n } else if (otherLoop.isPlaying) {\n var time = otherLoop.clock._nextTick - p5sound.audiocontext.currentTime;\n this.clock.start(now + time);\n this.isPlaying = true;\n }\n };\n\n\n /**\n * Updates frequency value, reflected in next callback\n * @private\n * @for p5.SoundLoop\n * @method _update\n */\n p5.SoundLoop.prototype._update = function() {\n this.clock.frequency.value = this._calcFreq();\n };\n\n /**\n * Calculate the frequency of the clock's callback based on bpm, interval, and timesignature\n * @private\n * @for p5.SoundLoop\n * @method _calcFreq\n * @return {Number} new clock frequency value\n */\n p5.SoundLoop.prototype._calcFreq = function() {\n //Seconds mode, bpm / timesignature has no effect\n if (typeof this._interval === 'number') {\n this.musicalTimeMode = false;\n return 1 / this._interval;\n }\n //Musical timing mode, calculate interval based bpm, interval,and time signature\n else if (typeof this._interval === 'string') {\n this.musicalTimeMode = true;\n return this._bpm / 60 / this._convertNotation(this._interval) * (this._timeSignature / 4);\n }\n };\n\n /**\n * Convert notation from musical time format to seconds\n * Uses Tone.Time convention\n * @private\n * @for p5.SoundLoop\n * @method _convertNotation\n * @param {String} value value to be converted\n * @return {Number} converted value in seconds\n */\n p5.SoundLoop.prototype._convertNotation = function(value) {\n var type = value.slice(-1);\n value = Number(value.slice(0,-1));\n switch (type) {\n case 'm':\n return this._measure(value);\n case 'n':\n return this._note(value);\n default:\n console.warn('Specified interval is not formatted correctly. See Tone.js '+\n 'timing reference for more info: https://github.com/Tonejs/Tone.js/wiki/Time');\n }\n };\n\n /**\n * Helper conversion methods of measure and note\n * @private\n * @for p5.SoundLoop\n * @method _measure\n */\n p5.SoundLoop.prototype._measure = function(value) {\n return value * this._timeSignature;\n };\n\n /**\n * @private\n * @method _note\n * @for p5.SoundLoop\n */\n p5.SoundLoop.prototype._note = function(value) {\n return this._timeSignature / value ;\n };\n\n\n /**\n * Getters and Setters, setting any paramter will result in a change in the clock's\n * frequency, that will be reflected after the next callback\n * beats per minute (defaults to 60)\n * @property {Number} bpm\n * @for p5.SoundLoop\n */\n Object.defineProperty(p5.SoundLoop.prototype, 'bpm', {\n get : function() {\n return this._bpm;\n },\n set : function(bpm) {\n if (!this.musicalTimeMode) {\n console.warn('Changing the BPM in \"seconds\" mode has no effect. '+\n 'BPM is only relevant in musicalTimeMode '+\n 'when the interval is specified as a string '+\n '(\"2n\", \"4n\", \"1m\"...etc)');\n }\n this._bpm = bpm;\n this._update();\n }\n });\n\n /**\n * number of quarter notes in a measure (defaults to 4)\n * @property {Number} timeSignature\n * @for p5.SoundLoop\n */\n Object.defineProperty(p5.SoundLoop.prototype, 'timeSignature', {\n get : function() {\n return this._timeSignature;\n },\n set : function(timeSig) {\n if (!this.musicalTimeMode) {\n console.warn('Changing the timeSignature in \"seconds\" mode has no effect. '+\n 'BPM is only relevant in musicalTimeMode '+\n 'when the interval is specified as a string '+\n '(\"2n\", \"4n\", \"1m\"...etc)');\n }\n this._timeSignature = timeSig;\n this._update();\n }\n });\n\n /**\n * length of the loops interval\n * @property {Number|String} interval\n * @for p5.SoundLoop\n */\n Object.defineProperty(p5.SoundLoop.prototype, 'interval', {\n get : function() {\n return this._interval;\n },\n set : function(interval) {\n this.musicalTimeMode = typeof interval === 'Number'? false : true;\n this._interval = interval;\n this._update();\n }\n });\n\n /**\n * how many times the callback has been called so far\n * @property {Number} iterations\n * @for p5.SoundLoop\n * @readonly\n */\n Object.defineProperty(p5.SoundLoop.prototype, 'iterations', {\n get : function() {\n return this.clock.ticks;\n }\n });\n\n return p5.SoundLoop;\n});\n","define(function (require) {\n\t'use strict';\n\n\tvar p5sound = require('master');\n\tvar Effect = require('effect');\n var CustomError = require('errorHandler');\n\n /**\n * Compressor is an audio effect class that performs dynamics compression\n * on an audio input source. This is a very commonly used technique in music\n * and sound production. Compression creates an overall louder, richer,\n * and fuller sound by lowering the volume of louds and raising that of softs.\n * Compression can be used to avoid clipping (sound distortion due to\n * peaks in volume) and is especially useful when many sounds are played\n * at once. Compression can be used on indivudal sound sources in addition\n * to the master output.\n *\n * This class extends p5.Effect.\n * Methods amp(), chain(),\n * drywet(), connect(), and\n * disconnect() are available.\n *\n * @class p5.Compressor\n * @constructor\n * @extends p5.Effect\n *\n *\n */\n\tp5.Compressor = function() {\n\t\tEffect.call(this);\n\n /**\n * The p5.Compressor is built with a Web Audio Dynamics Compressor Node\n * \n * @property {AudioNode} compressor\n */\n\n\n\t\tthis.compressor = this.ac.createDynamicsCompressor();\n\n this.input.connect(this.compressor);\n this.compressor.connect(this.wet);\n\t};\n\n\tp5.Compressor.prototype = Object.create(Effect.prototype);\n\n /**\n * Performs the same function as .connect, but also accepts\n * optional parameters to set compressor's audioParams\n * @method process\n * @for p5.Compressor\n *\n * @param {Object} src Sound source to be connected\n *\n * @param {Number} [attack] The amount of time (in seconds) to reduce the gain by 10dB,\n * default = .003, range 0 - 1\n * @param {Number} [knee] A decibel value representing the range above the\n * threshold where the curve smoothly transitions to the \"ratio\" portion.\n * default = 30, range 0 - 40\n * @param {Number} [ratio] The amount of dB change in input for a 1 dB change in output\n * default = 12, range 1 - 20\n * @param {Number} [threshold] The decibel value above which the compression will start taking effect\n * default = -24, range -100 - 0\n * @param {Number} [release] The amount of time (in seconds) to increase the gain by 10dB\n * default = .25, range 0 - 1\n */\n\tp5.Compressor.prototype.process = function(src, attack, knee,\n ratio, threshold, release) {\n\t\tsrc.connect(this.input);\n\t\tthis.set(attack, knee, ratio, threshold, release);\n\t};\n\n /**\n * Set the paramters of a compressor.\n * @method set\n * @for p5.Compressor\n * @param {Number} attack The amount of time (in seconds) to reduce the gain by 10dB,\n * default = .003, range 0 - 1\n * @param {Number} knee A decibel value representing the range above the\n * threshold where the curve smoothly transitions to the \"ratio\" portion.\n * default = 30, range 0 - 40\n * @param {Number} ratio The amount of dB change in input for a 1 dB change in output\n * default = 12, range 1 - 20\n * @param {Number} threshold The decibel value above which the compression will start taking effect\n * default = -24, range -100 - 0\n * @param {Number} release The amount of time (in seconds) to increase the gain by 10dB\n * default = .25, range 0 - 1\n */\n p5.Compressor.prototype.set = function (attack, knee,\n ratio, threshold, release) {\n\n if (typeof attack !== 'undefined') {this.attack(attack);}\n if (typeof knee !== 'undefined') {this.knee(knee);}\n if (typeof ratio !== 'undefined') {this.ratio(ratio);}\n if (typeof threshold !== 'undefined') {this.threshold(threshold);}\n if (typeof release !== 'undefined') {this.release(release);}\n };\n\n\n /**\n * Get current attack or set value w/ time ramp\n *\n *\n * @method attack\n * @for p5.Compressor\n * @param {Number} [attack] Attack is the amount of time (in seconds) to reduce the gain by 10dB,\n * default = .003, range 0 - 1\n * @param {Number} [time] Assign time value to schedule the change in value\n */\n p5.Compressor.prototype.attack = function (attack, time){\n var t = time || 0;\n if (typeof attack == 'number'){\n this.compressor.attack.value = attack;\n this.compressor.attack.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.compressor.attack.linearRampToValueAtTime(attack, this.ac.currentTime + 0.02 + t);\n } else if (typeof attack !== 'undefined') {\n attack.connect(this.compressor.attack);\n }\n return this.compressor.attack.value;\n };\n\n\n /**\n * Get current knee or set value w/ time ramp\n *\n * @method knee\n * @for p5.Compressor\n * @param {Number} [knee] A decibel value representing the range above the\n * threshold where the curve smoothly transitions to the \"ratio\" portion.\n * default = 30, range 0 - 40\n * @param {Number} [time] Assign time value to schedule the change in value\n */\n p5.Compressor.prototype.knee = function (knee, time){\n var t = time || 0;\n if (typeof knee == 'number'){\n this.compressor.knee.value = knee;\n this.compressor.knee.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.compressor.knee.linearRampToValueAtTime(knee, this.ac.currentTime + 0.02 + t);\n } else if (typeof knee !== 'undefined') {\n knee.connect(this.compressor.knee);\n }\n return this.compressor.knee.value;\n };\n\n\n /**\n * Get current ratio or set value w/ time ramp\n * @method ratio\n * @for p5.Compressor\n * @param {Number} [ratio] The amount of dB change in input for a 1 dB change in output\n * default = 12, range 1 - 20\n * @param {Number} [time] Assign time value to schedule the change in value\n */\n p5.Compressor.prototype.ratio = function (ratio, time){\n var t = time || 0;\n if (typeof ratio == 'number'){\n this.compressor.ratio.value = ratio;\n this.compressor.ratio.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.compressor.ratio.linearRampToValueAtTime(ratio, this.ac.currentTime + 0.02 + t);\n } else if (typeof ratio !== 'undefined') {\n ratio.connect(this.compressor.ratio);\n }\n return this.compressor.ratio.value;\n };\n\n\n /**\n * Get current threshold or set value w/ time ramp\n * @method threshold\n * @for p5.Compressor\n * @param {Number} threshold The decibel value above which the compression will start taking effect\n * default = -24, range -100 - 0\n * @param {Number} [time] Assign time value to schedule the change in value\n */\n p5.Compressor.prototype.threshold = function (threshold, time){\n var t = time || 0;\n if (typeof threshold == 'number'){\n this.compressor.threshold.value = threshold;\n this.compressor.threshold.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.compressor.threshold.linearRampToValueAtTime(threshold, this.ac.currentTime + 0.02 + t);\n } else if (typeof threshold !== 'undefined') {\n threshold.connect(this.compressor.threshold);\n }\n return this.compressor.threshold.value;\n };\n\n\n /**\n * Get current release or set value w/ time ramp\n * @method release\n * @for p5.Compressor\n * @param {Number} release The amount of time (in seconds) to increase the gain by 10dB\n * default = .25, range 0 - 1\n *\n * @param {Number} [time] Assign time value to schedule the change in value\n */\n p5.Compressor.prototype.release = function (release, time){\n var t = time || 0;\n if (typeof release == 'number'){\n this.compressor.release.value = release;\n this.compressor.release.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.compressor.release.linearRampToValueAtTime(release, this.ac.currentTime + 0.02 + t);\n } else if (typeof number !== 'undefined') {\n release.connect(this.compressor.release);\n }\n return this.compressor.release.value;\n };\n\n /**\n * Return the current reduction value\n *\n * @method reduction\n * @for p5.Compressor\n * @return {Number} Value of the amount of gain reduction that is applied to the signal\n */\n p5.Compressor.prototype.reduction =function() {\n return this.compressor.reduction.value;\n };\n\n\n\tp5.Compressor.prototype.dispose = function() {\n Effect.prototype.dispose.apply(this);\n if (this.compressor) {\n this.compressor.disconnect();\n delete this.compressor;\n }\n\t};\n\n return p5.Compressor;\n});\n","'use strict';\n\ndefine(function (require) {\n\n // inspiration: recorder.js, Tone.js & typedarray.org\n\n const p5sound = require('master');\n const { convertToWav, safeBufferSize } = require('helpers');\n const processorNames = require('./audioWorklet/processorNames');\n const ac = p5sound.audiocontext;\n\n /**\n *

Record sounds for playback and/or to save as a .wav file.\n * The p5.SoundRecorder records all sound output from your sketch,\n * or can be assigned a specific source with setInput().

\n *

The record() method accepts a p5.SoundFile as a parameter.\n * When playback is stopped (either after the given amount of time,\n * or with the stop() method), the p5.SoundRecorder will send its\n * recording to that p5.SoundFile for playback.

\n *\n * @class p5.SoundRecorder\n * @constructor\n * @example\n *
\n * let mic, recorder, soundFile;\n * let state = 0;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * textAlign(CENTER, CENTER);\n *\n * // create an audio in\n * mic = new p5.AudioIn();\n *\n * // prompts user to enable their browser mic\n * mic.start();\n *\n * // create a sound recorder\n * recorder = new p5.SoundRecorder();\n *\n * // connect the mic to the recorder\n * recorder.setInput(mic);\n *\n * // this sound file will be used to\n * // playback & save the recording\n * soundFile = new p5.SoundFile();\n *\n * text('tap to record', width/2, height/2);\n * }\n *\n * function canvasPressed() {\n * // ensure audio is enabled\n * userStartAudio();\n *\n * // make sure user enabled the mic\n * if (state === 0 && mic.enabled) {\n *\n * // record to our p5.SoundFile\n * recorder.record(soundFile);\n *\n * background(255,0,0);\n * text('Recording!', width/2, height/2);\n * state++;\n * }\n * else if (state === 1) {\n * background(0,255,0);\n *\n * // stop recorder and\n * // send result to soundFile\n * recorder.stop();\n *\n * text('Done! Tap to play and download', width/2, height/2, width - 20);\n * state++;\n * }\n *\n * else if (state === 2) {\n * soundFile.play(); // play the result!\n * save(soundFile, 'mySound.wav');\n * state++;\n * }\n * }\n *
\n */\n p5.SoundRecorder = function() {\n this.input = ac.createGain();\n this.output = ac.createGain();\n\n this._inputChannels = 2;\n this._outputChannels = 2; // stereo output, even if input is mono\n\n const workletBufferSize = safeBufferSize(1024);\n\n this._workletNode = new AudioWorkletNode(ac, processorNames.recorderProcessor, {\n outputChannelCount: [this._outputChannels],\n processorOptions: {\n numInputChannels: this._inputChannels,\n bufferSize: workletBufferSize\n }\n });\n\n this._workletNode.port.onmessage = function(event) {\n if (event.data.name === 'buffers') {\n const buffers = [\n new Float32Array(event.data.leftBuffer),\n new Float32Array(event.data.rightBuffer)\n ];\n this._callback(buffers);\n }\n }.bind(this);\n\n /**\n * callback invoked when the recording is over\n * @private\n * @type Function(Float32Array)\n */\n this._callback = function() {};\n\n // connections\n this._workletNode.connect(p5.soundOut._silentNode);\n this.setInput();\n\n // add this p5.SoundFile to the soundArray\n p5sound.soundArray.push(this);\n };\n\n /**\n * Connect a specific device to the p5.SoundRecorder.\n * If no parameter is given, p5.SoundRecorer will record\n * all audible p5.sound from your sketch.\n *\n * @method setInput\n * @for p5.SoundRecorder\n * @param {Object} [unit] p5.sound object or a web audio unit\n * that outputs sound\n */\n p5.SoundRecorder.prototype.setInput = function(unit) {\n this.input.disconnect();\n this.input = null;\n this.input = ac.createGain();\n this.input.connect(this._workletNode);\n this.input.connect(this.output);\n if (unit) {\n unit.connect(this.input);\n } else {\n p5.soundOut.output.connect(this.input);\n }\n };\n\n /**\n * Start recording. To access the recording, provide\n * a p5.SoundFile as the first parameter. The p5.SoundRecorder\n * will send its recording to that p5.SoundFile for playback once\n * recording is complete. Optional parameters include duration\n * (in seconds) of the recording, and a callback function that\n * will be called once the complete recording has been\n * transfered to the p5.SoundFile.\n *\n * @method record\n * @for p5.SoundRecorder\n * @param {p5.SoundFile} soundFile p5.SoundFile\n * @param {Number} [duration] Time (in seconds)\n * @param {Function} [callback] The name of a function that will be\n * called once the recording completes\n */\n p5.SoundRecorder.prototype.record = function(sFile, duration, callback) {\n this._workletNode.port.postMessage({ name: 'start', duration: duration });\n\n if (sFile && callback) {\n this._callback = function(buffer) {\n sFile.setBuffer(buffer);\n callback();\n };\n }\n else if (sFile) {\n this._callback = function(buffer) {\n sFile.setBuffer(buffer);\n };\n }\n };\n\n /**\n * Stop the recording. Once the recording is stopped,\n * the results will be sent to the p5.SoundFile that\n * was given on .record(), and if a callback function\n * was provided on record, that function will be called.\n *\n * @method stop\n * @for p5.SoundRecorder\n */\n p5.SoundRecorder.prototype.stop = function() {\n this._workletNode.port.postMessage({ name: 'stop' });\n };\n\n p5.SoundRecorder.prototype.dispose = function() {\n // remove reference from soundArray\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n\n this._callback = function() {};\n if (this.input) {\n this.input.disconnect();\n }\n this.input = null;\n this._workletNode = null;\n };\n\n\n /**\n * Save a p5.SoundFile as a .wav file. The browser will prompt the user\n * to download the file to their device.\n * For uploading audio to a server, use\n * `p5.SoundFile.saveBlob`.\n *\n * @for p5\n * @method saveSound\n * @param {p5.SoundFile} soundFile p5.SoundFile that you wish to save\n * @param {String} fileName name of the resulting .wav file.\n */\n // add to p5.prototype as this is used by the p5 `save()` method.\n p5.prototype.saveSound = function (soundFile, fileName) {\n const dataView = convertToWav(soundFile.buffer);\n p5.prototype.writeFile([dataView], fileName, 'wav');\n };\n});\n","'use strict';\n\ndefine(function () {\n /**\n *

PeakDetect works in conjunction with p5.FFT to\n * look for onsets in some or all of the frequency spectrum.\n *

\n *

\n * To use p5.PeakDetect, call update in the draw loop\n * and pass in a p5.FFT object.\n *

\n *

\n * You can listen for a specific part of the frequency spectrum by\n * setting the range between freq1 and freq2.\n *

\n *\n *

threshold is the threshold for detecting a peak,\n * scaled between 0 and 1. It is logarithmic, so 0.1 is half as loud\n * as 1.0.

\n *\n *

\n * The update method is meant to be run in the draw loop, and\n * frames determines how many loops must pass before\n * another peak can be detected.\n * For example, if the frameRate() = 60, you could detect the beat of a\n * 120 beat-per-minute song with this equation:\n * framesPerPeak = 60 / (estimatedBPM / 60 );\n *

\n *\n *

\n * Based on example contribtued by @b2renger, and a simple beat detection\n * explanation by Felix Turner.\n *

\n *\n * @class p5.PeakDetect\n * @constructor\n * @param {Number} [freq1] lowFrequency - defaults to 20Hz\n * @param {Number} [freq2] highFrequency - defaults to 20000 Hz\n * @param {Number} [threshold] Threshold for detecting a beat between 0 and 1\n * scaled logarithmically where 0.1 is 1/2 the loudness\n * of 1.0. Defaults to 0.35.\n * @param {Number} [framesPerPeak] Defaults to 20.\n * @example\n *
\n *\n * var cnv, soundFile, fft, peakDetect;\n * var ellipseWidth = 10;\n *\n * function preload() {\n * soundFile = loadSound('assets/beat.mp3');\n * }\n *\n * function setup() {\n * background(0);\n * noStroke();\n * fill(255);\n * textAlign(CENTER);\n *\n * // p5.PeakDetect requires a p5.FFT\n * fft = new p5.FFT();\n * peakDetect = new p5.PeakDetect();\n * }\n *\n * function draw() {\n * background(0);\n * text('click to play/pause', width/2, height/2);\n *\n * // peakDetect accepts an fft post-analysis\n * fft.analyze();\n * peakDetect.update(fft);\n *\n * if ( peakDetect.isDetected ) {\n * ellipseWidth = 50;\n * } else {\n * ellipseWidth *= 0.95;\n * }\n *\n * ellipse(width/2, height/2, ellipseWidth, ellipseWidth);\n * }\n *\n * // toggle play/stop when canvas is clicked\n * function mouseClicked() {\n * if (mouseX > 0 && mouseX < width && mouseY > 0 && mouseY < height) {\n * if (soundFile.isPlaying() ) {\n * soundFile.stop();\n * } else {\n * soundFile.play();\n * }\n * }\n * }\n *
\n */\n p5.PeakDetect = function(freq1, freq2, threshold, _framesPerPeak) {\n // framesPerPeak determines how often to look for a beat.\n // If a beat is provided, try to look for a beat based on bpm\n this.framesPerPeak = _framesPerPeak || 20;\n this.framesSinceLastPeak = 0;\n this.decayRate = 0.95;\n\n this.threshold = threshold || 0.35;\n this.cutoff = 0;\n\n // how much to increase the cutoff\n // TO DO: document this / figure out how to make it accessible\n this.cutoffMult = 1.5;\n\n this.energy = 0;\n this.penergy = 0;\n\n // TO DO: document this property / figure out how to make it accessible\n this.currentValue = 0;\n\n /**\n * isDetected is set to true when a peak is detected.\n *\n * @attribute isDetected {Boolean}\n * @default false\n */\n this.isDetected = false;\n\n this.f1 = freq1 || 40;\n this.f2 = freq2 || 20000;\n\n // function to call when a peak is detected\n this._onPeak = function() {};\n };\n\n\n /**\n * The update method is run in the draw loop.\n *\n * Accepts an FFT object. You must call .analyze()\n * on the FFT object prior to updating the peakDetect\n * because it relies on a completed FFT analysis.\n *\n * @method update\n * @param {p5.FFT} fftObject A p5.FFT object\n */\n p5.PeakDetect.prototype.update = function(fftObject) {\n var nrg = this.energy = fftObject.getEnergy(this.f1,this.f2)/255;\n if (nrg > this.cutoff && nrg > this.threshold && nrg-this.penergy > 0) {\n\n // trigger callback\n this._onPeak();\n this.isDetected = true;\n\n // debounce\n this.cutoff = nrg * this.cutoffMult;\n this.framesSinceLastPeak = 0;\n } else {\n this.isDetected = false;\n if (this.framesSinceLastPeak <= this.framesPerPeak) {\n this.framesSinceLastPeak++;\n } else {\n this.cutoff *= this.decayRate;\n this.cutoff = Math.max(this.cutoff, this.threshold);\n }\n }\n\n this.currentValue = nrg;\n this.penergy = nrg;\n };\n\n /**\n * onPeak accepts two arguments: a function to call when\n * a peak is detected. The value of the peak,\n * between 0.0 and 1.0, is passed to the callback.\n *\n * @method onPeak\n * @param {Function} callback Name of a function that will\n * be called when a peak is\n * detected.\n * @param {Object} [val] Optional value to pass\n * into the function when\n * a peak is detected.\n * @example\n *
\n * var cnv, soundFile, fft, peakDetect;\n * var ellipseWidth = 0;\n *\n * function preload() {\n * soundFile = loadSound('assets/beat.mp3');\n * }\n *\n * function setup() {\n * cnv = createCanvas(100,100);\n * textAlign(CENTER);\n *\n * fft = new p5.FFT();\n * peakDetect = new p5.PeakDetect();\n *\n * setupSound();\n *\n * // when a beat is detected, call triggerBeat()\n * peakDetect.onPeak(triggerBeat);\n * }\n *\n * function draw() {\n * background(0);\n * fill(255);\n * text('click to play', width/2, height/2);\n *\n * fft.analyze();\n * peakDetect.update(fft);\n *\n * ellipseWidth *= 0.95;\n * ellipse(width/2, height/2, ellipseWidth, ellipseWidth);\n * }\n *\n * // this function is called by peakDetect.onPeak\n * function triggerBeat() {\n * ellipseWidth = 50;\n * }\n *\n * // mouseclick starts/stops sound\n * function setupSound() {\n * cnv.mouseClicked( function() {\n * if (soundFile.isPlaying() ) {\n * soundFile.stop();\n * } else {\n * soundFile.play();\n * }\n * });\n * }\n *
\n */\n p5.PeakDetect.prototype.onPeak = function(callback, val) {\n var self = this;\n\n self._onPeak = function() {\n callback(self.energy, val);\n };\n };\n\n});\n","'use strict';\n\ndefine(function (require) {\n var p5sound = require('master');\n\n /**\n * A gain node is usefull to set the relative volume of sound.\n * It's typically used to build mixers.\n *\n * @class p5.Gain\n * @constructor\n * @example\n *
\n *\n * // load two soundfile and crossfade beetween them\n * let sound1,sound2;\n * let sound1Gain, sound2Gain, masterGain;\n * function preload(){\n * soundFormats('ogg', 'mp3');\n * sound1 = loadSound('assets/Damscray_-_Dancing_Tiger_01');\n * sound2 = loadSound('assets/beat');\n * }\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(startSound);\n * // create a 'master' gain to which we will connect both soundfiles\n * masterGain = new p5.Gain();\n * masterGain.connect();\n * sound1.disconnect(); // diconnect from p5 output\n * sound1Gain = new p5.Gain(); // setup a gain node\n * sound1Gain.setInput(sound1); // connect the first sound to its input\n * sound1Gain.connect(masterGain); // connect its output to the 'master'\n * sound2.disconnect();\n * sound2Gain = new p5.Gain();\n * sound2Gain.setInput(sound2);\n * sound2Gain.connect(masterGain);\n * }\n * function startSound() {\n * sound1.loop();\n * sound2.loop();\n * loop();\n * }\n * function mouseReleased() {\n * sound1.stop();\n * sound2.stop();\n * }\n * function draw(){\n * background(220);\n * textAlign(CENTER);\n * textSize(11);\n * fill(0);\n * if (!sound1.isPlaying()) {\n * text('tap and drag to play', width/2, height/2);\n * return;\n * }\n * // map the horizontal position of the mouse to values useable for volume * control of sound1\n * var sound1Volume = constrain(map(mouseX,width,0,0,1), 0, 1);\n * var sound2Volume = 1-sound1Volume;\n * sound1Gain.amp(sound1Volume);\n * sound2Gain.amp(sound2Volume);\n * // map the vertical position of the mouse to values useable for 'master * volume control'\n * var masterVolume = constrain(map(mouseY,height,0,0,1), 0, 1);\n * masterGain.amp(masterVolume);\n * text('master', width/2, height - masterVolume * height * 0.9)\n * fill(255, 0, 255);\n * textAlign(LEFT);\n * text('sound1', 5, height - sound1Volume * height * 0.9);\n * textAlign(RIGHT);\n * text('sound2', width - 5, height - sound2Volume * height * 0.9);\n * }\n *
\n */\n\n p5.Gain = function() {\n this.ac = p5sound.audiocontext;\n\n this.input = this.ac.createGain();\n this.output = this.ac.createGain();\n\n // otherwise, Safari distorts\n this.input.gain.value = 0.5;\n this.input.connect(this.output);\n\n // add to the soundArray\n p5sound.soundArray.push(this);\n };\n\n /**\n * Connect a source to the gain node.\n *\n * @method setInput\n * @for p5.Gain\n * @param {Object} src p5.sound / Web Audio object with a sound\n * output.\n */\n\n\n p5.Gain.prototype.setInput = function(src) {\n src.connect(this.input);\n };\n\n /**\n * Send output to a p5.sound or web audio object\n *\n * @method connect\n * @for p5.Gain\n * @param {Object} unit\n */\n p5.Gain.prototype.connect = function(unit) {\n var u = unit || p5.soundOut.input;\n this.output.connect(u.input ? u.input : u);\n };\n\n /**\n * Disconnect all output.\n *\n * @method disconnect\n * @for p5.Gain\n */\n p5.Gain.prototype.disconnect = function() {\n if (this.output) {\n this.output.disconnect();\n }\n };\n\n /**\n * Set the output level of the gain node.\n *\n * @method amp\n * @for p5.Gain\n * @param {Number} volume amplitude between 0 and 1.0\n * @param {Number} [rampTime] create a fade that lasts rampTime\n * @param {Number} [timeFromNow] schedule this event to happen\n * seconds from now\n */\n p5.Gain.prototype.amp = function(vol, rampTime, tFromNow) {\n var rampTime = rampTime || 0;\n var tFromNow = tFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n var currentVol = this.output.gain.value;\n this.output.gain.cancelScheduledValues(now);\n this.output.gain.linearRampToValueAtTime(currentVol, now + tFromNow);\n this.output.gain.linearRampToValueAtTime(vol, now + tFromNow + rampTime);\n };\n\n p5.Gain.prototype.dispose = function() {\n // remove reference from soundArray\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n if (this.output) {\n this.output.disconnect();\n delete this.output;\n }\n if (this.input) {\n this.input.disconnect();\n delete this.input;\n }\n };\n\n});\n","'use strict';\n\ndefine(function (require) {\n\n var Effect = require('effect');\n\n /*\n * Adapted from [Kevin Ennis on StackOverflow](http://stackoverflow.com/questions/22312841/waveshaper-node-in-webaudio-how-to-emulate-distortion)\n */\n function makeDistortionCurve(amount) {\n var k = typeof amount === 'number' ? amount : 50;\n var numSamples = 44100;\n var curve = new Float32Array(numSamples);\n var deg = Math.PI / 180;\n var i = 0;\n var x;\n for ( ; i < numSamples; ++i ) {\n x = i * 2 / numSamples - 1;\n curve[i] = ( 3 + k ) * x * 20 * deg / ( Math.PI + k * Math.abs(x) );\n }\n return curve;\n }\n\n /**\n * A Distortion effect created with a Waveshaper Node,\n * with an approach adapted from\n * [Kevin Ennis](http://stackoverflow.com/questions/22312841/waveshaper-node-in-webaudio-how-to-emulate-distortion)\n *\n * This class extends p5.Effect.\n * Methods amp(), chain(),\n * drywet(), connect(), and\n * disconnect() are available.\n *\n * @class p5.Distortion\n * @extends p5.Effect\n * @constructor\n * @param {Number} [amount=0.25] Unbounded distortion amount.\n * Normal values range from 0-1.\n * @param {String} [oversample='none'] 'none', '2x', or '4x'.\n *\n */\n p5.Distortion = function(amount, oversample) {\n Effect.call(this);\n\n if (typeof amount === 'undefined') {\n amount = 0.25;\n } if (typeof amount !== 'number') {\n throw new Error('amount must be a number');\n } if (typeof oversample === 'undefined') {\n oversample = '2x';\n } if (typeof oversample !== 'string') {\n throw new Error('oversample must be a String');\n }\n\n var curveAmount = p5.prototype.map(amount, 0.0, 1.0, 0, 2000);\n\n /**\n * The p5.Distortion is built with a\n * \n * Web Audio WaveShaper Node.\n *\n * @property {AudioNode} WaveShaperNode\n */\n this.waveShaperNode = this.ac.createWaveShaper();\n\n this.amount = curveAmount;\n this.waveShaperNode.curve = makeDistortionCurve(curveAmount);\n this.waveShaperNode.oversample = oversample;\n\n this.input.connect(this.waveShaperNode);\n\n this.waveShaperNode.connect(this.wet);\n };\n\n p5.Distortion.prototype = Object.create(Effect.prototype);\n\n\n /**\n * Process a sound source, optionally specify amount and oversample values.\n *\n * @method process\n * @for p5.Distortion\n * @param {Number} [amount=0.25] Unbounded distortion amount.\n * Normal values range from 0-1.\n * @param {String} [oversample='none'] 'none', '2x', or '4x'.\n */\n p5.Distortion.prototype.process = function(src, amount, oversample) {\n src.connect(this.input);\n this.set(amount, oversample);\n };\n\n /**\n * Set the amount and oversample of the waveshaper distortion.\n *\n * @method set\n * @for p5.Distortion\n * @param {Number} [amount=0.25] Unbounded distortion amount.\n * Normal values range from 0-1.\n * @param {String} [oversample='none'] 'none', '2x', or '4x'.\n */\n p5.Distortion.prototype.set = function(amount, oversample) {\n if (amount) {\n var curveAmount = p5.prototype.map(amount, 0.0, 1.0, 0, 2000);\n this.amount = curveAmount;\n this.waveShaperNode.curve = makeDistortionCurve(curveAmount);\n }\n if (oversample) {\n this.waveShaperNode.oversample = oversample;\n }\n };\n\n /**\n * Return the distortion amount, typically between 0-1.\n *\n * @method getAmount\n * @for p5.Distortion\n * @return {Number} Unbounded distortion amount.\n * Normal values range from 0-1.\n */\n p5.Distortion.prototype.getAmount = function() {\n return this.amount;\n };\n\n /**\n * Return the oversampling.\n *\n * @method getOversample\n * @for p5.Distortion\n * @return {String} Oversample can either be 'none', '2x', or '4x'.\n */\n p5.Distortion.prototype.getOversample = function() {\n return this.waveShaperNode.oversample;\n };\n\n\n p5.Distortion.prototype.dispose = function() {\n Effect.prototype.dispose.apply(this);\n if (this.waveShaperNode) {\n this.waveShaperNode.disconnect();\n this.waveShaperNode = null;\n }\n };\n});\n"],"sourceRoot":""} \ No newline at end of file diff --git a/lib/p5.sound.min.js b/lib/p5.sound.min.js index fe65a81f..0667db9d 100644 --- a/lib/p5.sound.min.js +++ b/lib/p5.sound.min.js @@ -1,3 +1,3 @@ -/** [p5.sound] Version: 0.3.12 - 2020-01-06 */ - !function(n){var i={};function o(t){if(i[t])return i[t].exports;var e=i[t]={i:t,l:!1,exports:{}};return n[t].call(e.exports,e,e.exports,o),e.l=!0,e.exports}o.m=n,o.c=i,o.d=function(t,e,n){o.o(t,e)||Object.defineProperty(t,e,{enumerable:!0,get:n})},o.r=function(t){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(t,"__esModule",{value:!0})},o.t=function(e,t){if(1&t&&(e=o(e)),8&t)return e;if(4&t&&"object"==typeof e&&e&&e.__esModule)return e;var n=Object.create(null);if(o.r(n),Object.defineProperty(n,"default",{enumerable:!0,value:e}),2&t&&"string"!=typeof e)for(var i in e)o.d(n,i,function(t){return e[t]}.bind(null,i));return n},o.n=function(t){var e=t&&t.__esModule?function(){return t.default}:function(){return t};return o.d(e,"a",e),e},o.o=function(t,e){return Object.prototype.hasOwnProperty.call(t,e)},o.p="",o(o.s=31)}([function(t,e,n){var i;void 0===(i=function(){"use strict";function c(t,e){this.isUndef(t)||1===t?this.input=this.context.createGain():1t)this.cancelScheduledValues(t),this.linearRampToValueAtTime(e,t);else{var i=this._searchAfter(t);i&&(this.cancelScheduledValues(t),i.type===u.TimelineSignal.Type.Linear?this.linearRampToValueAtTime(e,t):i.type===u.TimelineSignal.Type.Exponential&&this.exponentialRampToValueAtTime(e,t)),this.setValueAtTime(e,t)}return this},u.TimelineSignal.prototype.linearRampToValueBetween=function(t,e,n){return this.setRampPoint(e),this.linearRampToValueAtTime(t,n),this},u.TimelineSignal.prototype.exponentialRampToValueBetween=function(t,e,n){return this.setRampPoint(e),this.exponentialRampToValueAtTime(t,n),this},u.TimelineSignal.prototype._searchBefore=function(t){return this._events.get(t)},u.TimelineSignal.prototype._searchAfter=function(t){return this._events.getAfter(t)},u.TimelineSignal.prototype.getValueAtTime=function(t){t=this.toSeconds(t);var e=this._searchAfter(t),n=this._searchBefore(t),i=this._initial;if(null===n)i=this._initial;else if(n.type===u.TimelineSignal.Type.Target){var o,r=this._events.getBefore(n.time);o=null===r?this._initial:r.value,i=this._exponentialApproach(n.time,o,n.value,n.constant,t)}else i=n.type===u.TimelineSignal.Type.Curve?this._curveInterpolate(n.time,n.value,n.duration,t):null===e?n.value:e.type===u.TimelineSignal.Type.Linear?this._linearInterpolate(n.time,n.value,e.time,e.value,t):e.type===u.TimelineSignal.Type.Exponential?this._exponentialInterpolate(n.time,n.value,e.time,e.value,t):n.value;return i},u.TimelineSignal.prototype.connect=u.SignalBase.prototype.connect,u.TimelineSignal.prototype._exponentialApproach=function(t,e,n,i,o){return n+(e-n)*Math.exp(-(o-t)/i)},u.TimelineSignal.prototype._linearInterpolate=function(t,e,n,i,o){return e+(o-t)/(n-t)*(i-e)},u.TimelineSignal.prototype._exponentialInterpolate=function(t,e,n,i,o){return(e=Math.max(this._minOutput,e))*Math.pow(i/e,(o-t)/(n-t))},u.TimelineSignal.prototype._curveInterpolate=function(t,e,n,i){var o=e.length;if(t+n<=i)return e[o-1];if(i<=t)return e[0];var r=(i-t)/n,s=Math.floor((o-1)*r),a=Math.ceil((o-1)*r),u=e[s],p=e[a];return a===s?u:this._linearInterpolate(s,u,a,p,r*(o-1))},u.TimelineSignal.prototype.dispose=function(){u.Signal.prototype.dispose.call(this),u.Param.prototype.dispose.call(this),this._events.dispose(),this._events=null},u.TimelineSignal}.apply(e,i))||(t.exports=o)},function(t,e,n){"use strict";var i;void 0===(i=function(t){var e=n(4);return p5.Filter=function(t){e.call(this),this.biquad=this.ac.createBiquadFilter(),this.input.connect(this.biquad),this.biquad.connect(this.wet),t&&this.setType(t),this._on=!0,this._untoggledType=this.biquad.type},p5.Filter.prototype=Object.create(e.prototype),p5.Filter.prototype.process=function(t,e,n,i){t.connect(this.input),this.set(e,n,i)},p5.Filter.prototype.set=function(t,e,n){t&&this.freq(t,n),e&&this.res(e,n)},p5.Filter.prototype.freq=function(t,e){var n=e||0;return t<=0&&(t=1),"number"==typeof t?(this.biquad.frequency.cancelScheduledValues(this.ac.currentTime+.01+n),this.biquad.frequency.exponentialRampToValueAtTime(t,this.ac.currentTime+.02+n)):t&&t.connect(this.biquad.frequency),this.biquad.frequency.value},p5.Filter.prototype.res=function(t,e){var n=e||0;return"number"==typeof t?(this.biquad.Q.value=t,this.biquad.Q.cancelScheduledValues(this.ac.currentTime+.01+n),this.biquad.Q.linearRampToValueAtTime(t,this.ac.currentTime+.02+n)):t&&t.connect(this.biquad.Q),this.biquad.Q.value},p5.Filter.prototype.gain=function(t,e){var n=e||0;return"number"==typeof t?(this.biquad.gain.value=t,this.biquad.gain.cancelScheduledValues(this.ac.currentTime+.01+n),this.biquad.gain.linearRampToValueAtTime(t,this.ac.currentTime+.02+n)):t&&t.connect(this.biquad.gain),this.biquad.gain.value},p5.Filter.prototype.toggle=function(){return this._on=!this._on,!0===this._on?this.biquad.type=this._untoggledType:!1===this._on&&(this.biquad.type="allpass"),this._on},p5.Filter.prototype.setType=function(t){this.biquad.type=t,this._untoggledType=this.biquad.type},p5.Filter.prototype.dispose=function(){e.prototype.dispose.apply(this),this.biquad&&(this.biquad.disconnect(),delete this.biquad)},p5.LowPass=function(){p5.Filter.call(this,"lowpass")},p5.LowPass.prototype=Object.create(p5.Filter.prototype),p5.HighPass=function(){p5.Filter.call(this,"highpass")},p5.HighPass.prototype=Object.create(p5.Filter.prototype),p5.BandPass=function(){p5.Filter.call(this,"bandpass")},p5.BandPass.prototype=Object.create(p5.Filter.prototype),p5.Filter}.call(e,n,e,t))||(t.exports=i)},function(t,e,n){var i,o;i=[n(0),n(7),n(25),n(2),n(9)],void 0===(o=function(e){"use strict";return e.Subtract=function(t){this.createInsOuts(2,0),this._sum=this.input[0]=this.output=new e.Gain,this._neg=new e.Negate,this._param=this.input[1]=new e.Signal(t),this._param.chain(this._neg,this._sum)},e.extend(e.Subtract,e.Signal),e.Subtract.prototype.dispose=function(){return e.prototype.dispose.call(this),this._neg.dispose(),this._neg=null,this._sum.disconnect(),this._sum=null,this._param.dispose(),this._param=null,this},e.Subtract}.apply(e,i))||(t.exports=o)},function(i,o,r){"use strict";(function(t){var e,n;t.TONE_SILENCE_VERSION_LOGGING=!0,e=[r(35),r(12),r(0)],void 0===(n=function(i,t,e){var o=new window.AudioContext;return e.context.dispose(),e.setContext(o),p5.prototype.getAudioContext=function(){return o},p5.prototype.userStartAudio=function(t,e){var n=t;return t instanceof p5.Element?n=t.elt:t instanceof Array&&t[0]instanceof p5.Element&&(n=t.map(function(t){return t.elt})),i(o,n,e)},o}.apply(o,e))||(i.exports=n)}).call(this,r(34))},function(t,e,n){var i,o;i=[n(0)],void 0===(o=function(s){"use strict";return s.Emitter=function(){this._events={}},s.extend(s.Emitter),s.Emitter.prototype.on=function(t,e){for(var n=t.split(/\W+/),i=0;ithis.memory){var n=this.length-this.memory;this._timeline.splice(0,n)}return this},e.Timeline.prototype.remove=function(t){if(this._iterating)this._toRemove.push(t);else{var e=this._timeline.indexOf(t);-1!==e&&this._timeline.splice(e,1)}return this},e.Timeline.prototype.get=function(t){var e=this._search(t);return-1!==e?this._timeline[e]:null},e.Timeline.prototype.peek=function(){return this._timeline[0]},e.Timeline.prototype.shift=function(){return this._timeline.shift()},e.Timeline.prototype.getAfter=function(t){var e=this._search(t);return e+1=t&&(this._timeline=[]);return this},e.Timeline.prototype.cancelBefore=function(t){if(this._timeline.length){var e=this._search(t);0<=e&&(this._timeline=this._timeline.slice(e+1))}return this},e.Timeline.prototype._search=function(t){var e=0,n=this._timeline.length,i=n;if(0t)return o;r.time>t?i=o:r.time=t;)n--;return this._iterate(e,n+1),this},e.Timeline.prototype.forEachAtTime=function(e,n){var t=this._search(e);return-1!==t&&this._iterate(function(t){t.time===e&&n(t)},0,t),this},e.Timeline.prototype.dispose=function(){e.prototype.dispose.call(this),this._timeline=null,this._toRemove=null},e.Timeline}.apply(e,i))||(t.exports=o)},function(t,e,n){var i,o;i=[n(0),n(3),n(2)],void 0===(o=function(t){"use strict";return t.Negate=function(){this._multiply=this.input=this.output=new t.Multiply(-1)},t.extend(t.Negate,t.SignalBase),t.Negate.prototype.dispose=function(){return t.prototype.dispose.call(this),this._multiply.dispose(),this._multiply=null,this},t.Negate}.apply(e,i))||(t.exports=o)},function(t,e,n){var i,o;i=[n(0),n(2),n(3),n(5)],void 0===(o=function(t){"use strict";return t.GreaterThanZero=function(){this._thresh=this.output=new t.WaveShaper(function(t){return t<=0?0:1},127),this._scale=this.input=new t.Multiply(1e4),this._scale.connect(this._thresh)},t.extend(t.GreaterThanZero,t.SignalBase),t.GreaterThanZero.prototype.dispose=function(){return t.prototype.dispose.call(this),this._scale.dispose(),this._scale=null,this._thresh.dispose(),this._thresh=null,this},t.GreaterThanZero}.apply(e,i))||(t.exports=o)},function(t,e,n){var i,o;i=[n(0),n(14),n(66),n(18),n(12)],void 0===(o=function(o){"use strict";return o.Clock=function(){o.Emitter.call(this);var t=this.optionsObject(arguments,["callback","frequency"],o.Clock.defaults);this.callback=t.callback,this._nextTick=0,this._lastState=o.State.Stopped,this.frequency=new o.TimelineSignal(t.frequency,o.Type.Frequency),this._readOnly("frequency"),this.ticks=0,this._state=new o.TimelineState(o.State.Stopped),this._boundLoop=this._loop.bind(this),this.context.on("tick",this._boundLoop)},o.extend(o.Clock,o.Emitter),o.Clock.defaults={callback:o.noOp,frequency:1,lookAhead:"auto"},Object.defineProperty(o.Clock.prototype,"state",{get:function(){return this._state.getValueAtTime(this.now())}}),o.Clock.prototype.start=function(t,e){return t=this.toSeconds(t),this._state.getValueAtTime(t)!==o.State.Started&&this._state.add({state:o.State.Started,time:t,offset:e}),this},o.Clock.prototype.stop=function(t){return t=this.toSeconds(t),this._state.cancel(t),this._state.setStateAtTime(o.State.Stopped,t),this},o.Clock.prototype.pause=function(t){return t=this.toSeconds(t),this._state.getValueAtTime(t)===o.State.Started&&this._state.setStateAtTime(o.State.Paused,t),this},o.Clock.prototype._loop=function(){for(var t=this.now()+this.context.lookAhead+this.context.updateInterval+2*this.context.lag;t>this._nextTick&&this._state;){var e=this._state.getValueAtTime(this._nextTick);if(e!==this._lastState){this._lastState=e;var n=this._state.get(this._nextTick);e===o.State.Started?(this._nextTick=n.time,this.isUndef(n.offset)||(this.ticks=n.offset),this.emit("start",n.time,this.ticks)):e===o.State.Stopped?(this.ticks=0,this.emit("stop",n.time)):e===o.State.Paused&&this.emit("pause",n.time)}var i=this._nextTick;this.frequency&&(this._nextTick+=1/this.frequency.getValueAtTime(this._nextTick),e===o.State.Started&&(this.callback(i),this.ticks++))}},o.Clock.prototype.getStateAtTime=function(t){return t=this.toSeconds(t),this._state.getValueAtTime(t)},o.Clock.prototype.dispose=function(){o.Emitter.prototype.dispose.call(this),this.context.off("tick",this._boundLoop),this._writable("frequency"),this.frequency.dispose(),this.frequency=null,this._boundLoop=null,this._nextTick=1/0,this.callback=null,this._state.dispose(),this._state=null},o.Clock}.apply(e,i))||(t.exports=o)},function(t,e,i){"use strict";var n;void 0===(n=function(t){var n=i(1),e=i(29),r=i(6).noteToFreq;p5.MonoSynth=function(){e.call(this),this.oscillator=new p5.Oscillator,this.env=new p5.Envelope,this.env.setRange(1,0),this.env.setExp(!0),this.setADSR(.02,.25,.05,.35),this.oscillator.disconnect(),this.oscillator.connect(this.output),this.env.disconnect(),this.env.setInput(this.output.gain),this.oscillator.output.gain.value=1,this.oscillator.start(),this.connect(),n.soundArray.push(this)},p5.MonoSynth.prototype=Object.create(p5.AudioVoice.prototype),p5.MonoSynth.prototype.play=function(t,e,n,i){this.triggerAttack(t,e,~~n),this.triggerRelease(~~n+(i||.15))},p5.MonoSynth.prototype.triggerAttack=function(t,e,n){n=~~n;var i=r(t),o=e||.1;this.oscillator.freq(i,0,n),this.env.ramp(this.output.gain,n,o)},p5.MonoSynth.prototype.triggerRelease=function(t){t=t||0;this.env.ramp(this.output.gain,t,0)},p5.MonoSynth.prototype.setADSR=function(t,e,n,i){this.env.setADSR(t,e,n,i)},Object.defineProperties(p5.MonoSynth.prototype,{attack:{get:function(){return this.env.aTime},set:function(t){this.env.setADSR(t,this.env.dTime,this.env.sPercent,this.env.rTime)}},decay:{get:function(){return this.env.dTime},set:function(t){this.env.setADSR(this.env.aTime,t,this.env.sPercent,this.env.rTime)}},sustain:{get:function(){return this.env.sPercent},set:function(t){this.env.setADSR(this.env.aTime,this.env.dTime,t,this.env.rTime)}},release:{get:function(){return this.env.rTime},set:function(t){this.env.setADSR(this.env.aTime,this.env.dTime,this.env.sPercent,t)}}}),p5.MonoSynth.prototype.amp=function(t,e){var n=e||0;return void 0!==t&&this.oscillator.amp(t,n),this.oscillator.amp().value},p5.MonoSynth.prototype.connect=function(t){var e=t||n.input;this.output.connect(e.input?e.input:e)},p5.MonoSynth.prototype.disconnect=function(){this.output&&this.output.disconnect()},p5.MonoSynth.prototype.dispose=function(){e.prototype.dispose.apply(this),this.env&&this.env.dispose(),this.oscillator&&this.oscillator.dispose()}}.call(e,i,e,t))||(t.exports=n)},function(t,e,i){"use strict";var n;void 0===(n=function(){var n=i(1);return p5.AudioVoice=function(){this.ac=n.audiocontext,this.output=this.ac.createGain(),this.connect(),n.soundArray.push(this)},p5.AudioVoice.prototype.play=function(t,e,n,i){},p5.AudioVoice.prototype.triggerAttack=function(t,e,n){},p5.AudioVoice.prototype.triggerRelease=function(t){},p5.AudioVoice.prototype.amp=function(t,e){},p5.AudioVoice.prototype.connect=function(t){var e=t||n.input;this.output.connect(e.input?e.input:e)},p5.AudioVoice.prototype.disconnect=function(){this.output.disconnect()},p5.AudioVoice.prototype.dispose=function(){this.output&&(this.output.disconnect(),delete this.output)},p5.AudioVoice}.call(e,i,e,t))||(t.exports=n)},function(t,e,n){"use strict";var i;void 0===(i=function(t){var c=n(1),h=n(14),l=n(6).noteToFreq;p5.PolySynth=function(t,e){this.audiovoices=[],this.notes={},this._newest=0,this._oldest=0,this.maxVoices=e||8,this.AudioVoice=void 0===t?p5.MonoSynth:t,this._voicesInUse=new h(0),this.output=c.audiocontext.createGain(),this.connect(),this._allocateVoices(),c.soundArray.push(this)},p5.PolySynth.prototype._allocateVoices=function(){for(var t=0;t= this._length) {\n this._writeIndex = 0;\n } // For excessive frames, the buffer will be overwritten.\n\n\n this._framesAvailable += sourceLength;\n\n if (this._framesAvailable > this._length) {\n this._framesAvailable = this._length;\n }\n }\n /**\n * Pull data out of buffer and fill a given sequence of Float32Arrays.\n *\n * @param {array} arraySequence An array of Float32Arrays.\n */\n\n }, {\n key: "pull",\n value: function pull(arraySequence) {\n // The channel count of arraySequence and the length of each channel must\n // match with this buffer obejct.\n // If the FIFO is completely empty, do nothing.\n if (this._framesAvailable === 0) {\n return;\n }\n\n var destinationLength = arraySequence[0].length; // Transfer data from the internal buffer to the |arraySequence| storage.\n\n for (var i = 0; i < destinationLength; ++i) {\n var readIndex = (this._readIndex + i) % this._length;\n\n for (var channel = 0; channel < this._channelCount; ++channel) {\n arraySequence[channel][i] = this._channelData[channel][readIndex];\n }\n }\n\n this._readIndex += destinationLength;\n\n if (this._readIndex >= this._length) {\n this._readIndex = 0;\n }\n\n this._framesAvailable -= destinationLength;\n\n if (this._framesAvailable < 0) {\n this._framesAvailable = 0;\n }\n }\n }, {\n key: "framesAvailable",\n get: function get() {\n return this._framesAvailable;\n }\n }]);\n\n return RingBuffer;\n }()\n}["default"];\n\nvar RecorderProcessor =\n/*#__PURE__*/\nfunction (_AudioWorkletProcesso) {\n _inherits(RecorderProcessor, _AudioWorkletProcesso);\n\n function RecorderProcessor(options) {\n var _this;\n\n _classCallCheck(this, RecorderProcessor);\n\n _this = _possibleConstructorReturn(this, _getPrototypeOf(RecorderProcessor).call(this));\n var processorOptions = options.processorOptions || {};\n _this.numOutputChannels = options.outputChannelCount || 2;\n _this.numInputChannels = processorOptions.numInputChannels || 2;\n _this.bufferSize = processorOptions.bufferSize || 1024;\n _this.recording = false;\n\n _this.clear();\n\n _this.port.onmessage = function (event) {\n var data = event.data;\n\n if (data.name === \'start\') {\n _this.record(data.duration);\n } else if (data.name === \'stop\') {\n _this.stop();\n }\n };\n\n return _this;\n }\n\n _createClass(RecorderProcessor, [{\n key: "process",\n value: function process(inputs) {\n if (!this.recording) {\n return true;\n } else if (this.sampleLimit && this.recordedSamples >= this.sampleLimit) {\n this.stop();\n return true;\n }\n\n var input = inputs[0];\n this.inputRingBuffer.push(input);\n\n if (this.inputRingBuffer.framesAvailable >= this.bufferSize) {\n this.inputRingBuffer.pull(this.inputRingBufferArraySequence);\n\n for (var channel = 0; channel < this.numOutputChannels; ++channel) {\n var inputChannelCopy = this.inputRingBufferArraySequence[channel].slice();\n\n if (channel === 0) {\n this.leftBuffers.push(inputChannelCopy);\n\n if (this.numInputChannels === 1) {\n this.rightBuffers.push(inputChannelCopy);\n }\n } else if (channel === 1 && this.numInputChannels > 1) {\n this.rightBuffers.push(inputChannelCopy);\n }\n }\n\n this.recordedSamples += this.bufferSize;\n }\n\n return true;\n }\n }, {\n key: "record",\n value: function record(duration) {\n if (duration) {\n this.sampleLimit = Math.round(duration * sampleRate);\n }\n\n this.recording = true;\n }\n }, {\n key: "stop",\n value: function stop() {\n this.recording = false;\n var buffers = this.getBuffers();\n var leftBuffer = buffers[0].buffer;\n var rightBuffer = buffers[1].buffer;\n this.port.postMessage({\n name: \'buffers\',\n leftBuffer: leftBuffer,\n rightBuffer: rightBuffer\n }, [leftBuffer, rightBuffer]);\n this.clear();\n }\n }, {\n key: "getBuffers",\n value: function getBuffers() {\n var buffers = [];\n buffers.push(this.mergeBuffers(this.leftBuffers));\n buffers.push(this.mergeBuffers(this.rightBuffers));\n return buffers;\n }\n }, {\n key: "mergeBuffers",\n value: function mergeBuffers(channelBuffer) {\n var result = new Float32Array(this.recordedSamples);\n var offset = 0;\n var lng = channelBuffer.length;\n\n for (var i = 0; i < lng; i++) {\n var buffer = channelBuffer[i];\n result.set(buffer, offset);\n offset += buffer.length;\n }\n\n return result;\n }\n }, {\n key: "clear",\n value: function clear() {\n var _this2 = this;\n\n this.leftBuffers = [];\n this.rightBuffers = [];\n this.inputRingBuffer = new RingBuffer(this.bufferSize, this.numInputChannels);\n this.inputRingBufferArraySequence = new Array(this.numInputChannels).fill(null).map(function () {\n return new Float32Array(_this2.bufferSize);\n });\n this.recordedSamples = 0;\n this.sampleLimit = null;\n }\n }]);\n\n return RecorderProcessor;\n}(_wrapNativeSuper(AudioWorkletProcessor));\n\nregisterProcessor(processorNames.recorderProcessor, RecorderProcessor);'},function(t,e,n){"use strict";n.r(e),e.default='function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }\n\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }\n\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn\'t been initialised - super() hasn\'t been called"); } return self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\nfunction _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }\n\nfunction isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\n\nfunction _construct(Parent, args, Class) { if (isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }\n\nfunction _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }\n\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\n// import dependencies via preval.require so that they\'re available as values at compile time\nvar processorNames = {\n "recorderProcessor": "recorder-processor",\n "soundFileProcessor": "sound-file-processor",\n "amplitudeProcessor": "amplitude-processor"\n};\nvar RingBuffer = {\n "default":\n /*#__PURE__*/\n function () {\n /**\n * @constructor\n * @param {number} length Buffer length in frames.\n * @param {number} channelCount Buffer channel count.\n */\n function RingBuffer(length, channelCount) {\n _classCallCheck(this, RingBuffer);\n\n this._readIndex = 0;\n this._writeIndex = 0;\n this._framesAvailable = 0;\n this._channelCount = channelCount;\n this._length = length;\n this._channelData = [];\n\n for (var i = 0; i < this._channelCount; ++i) {\n this._channelData[i] = new Float32Array(length);\n }\n }\n /**\n * Getter for Available frames in buffer.\n *\n * @return {number} Available frames in buffer.\n */\n\n\n _createClass(RingBuffer, [{\n key: "push",\n\n /**\n * Push a sequence of Float32Arrays to buffer.\n *\n * @param {array} arraySequence A sequence of Float32Arrays.\n */\n value: function push(arraySequence) {\n // The channel count of arraySequence and the length of each channel must\n // match with this buffer obejct.\n // Transfer data from the |arraySequence| storage to the internal buffer.\n var sourceLength = arraySequence[0].length;\n\n for (var i = 0; i < sourceLength; ++i) {\n var writeIndex = (this._writeIndex + i) % this._length;\n\n for (var channel = 0; channel < this._channelCount; ++channel) {\n this._channelData[channel][writeIndex] = arraySequence[channel][i];\n }\n }\n\n this._writeIndex += sourceLength;\n\n if (this._writeIndex >= this._length) {\n this._writeIndex = 0;\n } // For excessive frames, the buffer will be overwritten.\n\n\n this._framesAvailable += sourceLength;\n\n if (this._framesAvailable > this._length) {\n this._framesAvailable = this._length;\n }\n }\n /**\n * Pull data out of buffer and fill a given sequence of Float32Arrays.\n *\n * @param {array} arraySequence An array of Float32Arrays.\n */\n\n }, {\n key: "pull",\n value: function pull(arraySequence) {\n // The channel count of arraySequence and the length of each channel must\n // match with this buffer obejct.\n // If the FIFO is completely empty, do nothing.\n if (this._framesAvailable === 0) {\n return;\n }\n\n var destinationLength = arraySequence[0].length; // Transfer data from the internal buffer to the |arraySequence| storage.\n\n for (var i = 0; i < destinationLength; ++i) {\n var readIndex = (this._readIndex + i) % this._length;\n\n for (var channel = 0; channel < this._channelCount; ++channel) {\n arraySequence[channel][i] = this._channelData[channel][readIndex];\n }\n }\n\n this._readIndex += destinationLength;\n\n if (this._readIndex >= this._length) {\n this._readIndex = 0;\n }\n\n this._framesAvailable -= destinationLength;\n\n if (this._framesAvailable < 0) {\n this._framesAvailable = 0;\n }\n }\n }, {\n key: "framesAvailable",\n get: function get() {\n return this._framesAvailable;\n }\n }]);\n\n return RingBuffer;\n }()\n}["default"];\n\nvar SoundFileProcessor =\n/*#__PURE__*/\nfunction (_AudioWorkletProcesso) {\n _inherits(SoundFileProcessor, _AudioWorkletProcesso);\n\n function SoundFileProcessor(options) {\n var _this;\n\n _classCallCheck(this, SoundFileProcessor);\n\n _this = _possibleConstructorReturn(this, _getPrototypeOf(SoundFileProcessor).call(this));\n var processorOptions = options.processorOptions || {};\n _this.bufferSize = processorOptions.bufferSize || 256;\n _this.inputRingBuffer = new RingBuffer(_this.bufferSize, 1);\n _this.inputRingBufferArraySequence = [new Float32Array(_this.bufferSize)];\n return _this;\n }\n\n _createClass(SoundFileProcessor, [{\n key: "process",\n value: function process(inputs) {\n var input = inputs[0]; // we only care about the first input channel, because that contains the position data\n\n this.inputRingBuffer.push([input[0]]);\n\n if (this.inputRingBuffer.framesAvailable >= this.bufferSize) {\n this.inputRingBuffer.pull(this.inputRingBufferArraySequence);\n var inputChannel = this.inputRingBufferArraySequence[0];\n var position = inputChannel[inputChannel.length - 1] || 0;\n this.port.postMessage({\n name: \'position\',\n position: position\n });\n }\n\n return true;\n }\n }]);\n\n return SoundFileProcessor;\n}(_wrapNativeSuper(AudioWorkletProcessor));\n\nregisterProcessor(processorNames.soundFileProcessor, SoundFileProcessor);'},function(t,e,n){"use strict";n.r(e),e.default='function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }\n\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }\n\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn\'t been initialised - super() hasn\'t been called"); } return self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\nfunction _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }\n\nfunction isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\n\nfunction _construct(Parent, args, Class) { if (isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }\n\nfunction _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }\n\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\n// import dependencies via preval.require so that they\'re available as values at compile time\nvar processorNames = {\n "recorderProcessor": "recorder-processor",\n "soundFileProcessor": "sound-file-processor",\n "amplitudeProcessor": "amplitude-processor"\n};\nvar RingBuffer = {\n "default":\n /*#__PURE__*/\n function () {\n /**\n * @constructor\n * @param {number} length Buffer length in frames.\n * @param {number} channelCount Buffer channel count.\n */\n function RingBuffer(length, channelCount) {\n _classCallCheck(this, RingBuffer);\n\n this._readIndex = 0;\n this._writeIndex = 0;\n this._framesAvailable = 0;\n this._channelCount = channelCount;\n this._length = length;\n this._channelData = [];\n\n for (var i = 0; i < this._channelCount; ++i) {\n this._channelData[i] = new Float32Array(length);\n }\n }\n /**\n * Getter for Available frames in buffer.\n *\n * @return {number} Available frames in buffer.\n */\n\n\n _createClass(RingBuffer, [{\n key: "push",\n\n /**\n * Push a sequence of Float32Arrays to buffer.\n *\n * @param {array} arraySequence A sequence of Float32Arrays.\n */\n value: function push(arraySequence) {\n // The channel count of arraySequence and the length of each channel must\n // match with this buffer obejct.\n // Transfer data from the |arraySequence| storage to the internal buffer.\n var sourceLength = arraySequence[0].length;\n\n for (var i = 0; i < sourceLength; ++i) {\n var writeIndex = (this._writeIndex + i) % this._length;\n\n for (var channel = 0; channel < this._channelCount; ++channel) {\n this._channelData[channel][writeIndex] = arraySequence[channel][i];\n }\n }\n\n this._writeIndex += sourceLength;\n\n if (this._writeIndex >= this._length) {\n this._writeIndex = 0;\n } // For excessive frames, the buffer will be overwritten.\n\n\n this._framesAvailable += sourceLength;\n\n if (this._framesAvailable > this._length) {\n this._framesAvailable = this._length;\n }\n }\n /**\n * Pull data out of buffer and fill a given sequence of Float32Arrays.\n *\n * @param {array} arraySequence An array of Float32Arrays.\n */\n\n }, {\n key: "pull",\n value: function pull(arraySequence) {\n // The channel count of arraySequence and the length of each channel must\n // match with this buffer obejct.\n // If the FIFO is completely empty, do nothing.\n if (this._framesAvailable === 0) {\n return;\n }\n\n var destinationLength = arraySequence[0].length; // Transfer data from the internal buffer to the |arraySequence| storage.\n\n for (var i = 0; i < destinationLength; ++i) {\n var readIndex = (this._readIndex + i) % this._length;\n\n for (var channel = 0; channel < this._channelCount; ++channel) {\n arraySequence[channel][i] = this._channelData[channel][readIndex];\n }\n }\n\n this._readIndex += destinationLength;\n\n if (this._readIndex >= this._length) {\n this._readIndex = 0;\n }\n\n this._framesAvailable -= destinationLength;\n\n if (this._framesAvailable < 0) {\n this._framesAvailable = 0;\n }\n }\n }, {\n key: "framesAvailable",\n get: function get() {\n return this._framesAvailable;\n }\n }]);\n\n return RingBuffer;\n }()\n}["default"];\n\nvar AmplitudeProcessor =\n/*#__PURE__*/\nfunction (_AudioWorkletProcesso) {\n _inherits(AmplitudeProcessor, _AudioWorkletProcesso);\n\n function AmplitudeProcessor(options) {\n var _this;\n\n _classCallCheck(this, AmplitudeProcessor);\n\n _this = _possibleConstructorReturn(this, _getPrototypeOf(AmplitudeProcessor).call(this));\n var processorOptions = options.processorOptions || {};\n _this.numOutputChannels = options.outputChannelCount || 1;\n _this.numInputChannels = processorOptions.numInputChannels || 2;\n _this.normalize = processorOptions.normalize || false;\n _this.smoothing = processorOptions.smoothing || 0;\n _this.bufferSize = processorOptions.bufferSize || 2048;\n _this.inputRingBuffer = new RingBuffer(_this.bufferSize, _this.numInputChannels);\n _this.outputRingBuffer = new RingBuffer(_this.bufferSize, _this.numOutputChannels);\n _this.inputRingBufferArraySequence = new Array(_this.numInputChannels).fill(null).map(function () {\n return new Float32Array(_this.bufferSize);\n });\n _this.stereoVol = [0, 0];\n _this.stereoVolNorm = [0, 0];\n _this.volMax = 0.001;\n\n _this.port.onmessage = function (event) {\n var data = event.data;\n\n if (data.name === \'toggleNormalize\') {\n _this.normalize = data.normalize;\n } else if (data.name === \'smoothing\') {\n _this.smoothing = Math.max(0, Math.min(1, data.smoothing));\n }\n };\n\n return _this;\n } // TO DO make this stereo / dependent on # of audio channels\n\n\n _createClass(AmplitudeProcessor, [{\n key: "process",\n value: function process(inputs, outputs) {\n var input = inputs[0];\n var output = outputs[0];\n var smoothing = this.smoothing;\n this.inputRingBuffer.push(input);\n\n if (this.inputRingBuffer.framesAvailable >= this.bufferSize) {\n this.inputRingBuffer.pull(this.inputRingBufferArraySequence);\n\n for (var channel = 0; channel < this.numInputChannels; ++channel) {\n var inputBuffer = this.inputRingBufferArraySequence[channel];\n var bufLength = inputBuffer.length;\n var sum = 0;\n\n for (var i = 0; i < bufLength; i++) {\n var x = inputBuffer[i];\n\n if (this.normalize) {\n sum += Math.max(Math.min(x / this.volMax, 1), -1) * Math.max(Math.min(x / this.volMax, 1), -1);\n } else {\n sum += x * x;\n }\n } // ... then take the square root of the sum.\n\n\n var rms = Math.sqrt(sum / bufLength);\n this.stereoVol[channel] = Math.max(rms, this.stereoVol[channel] * smoothing);\n this.volMax = Math.max(this.stereoVol[channel], this.volMax);\n } // calculate stero normalized volume and add volume from all channels together\n\n\n var volSum = 0;\n\n for (var index = 0; index < this.stereoVol.length; index++) {\n this.stereoVolNorm[index] = Math.max(Math.min(this.stereoVol[index] / this.volMax, 1), 0);\n volSum += this.stereoVol[index];\n } // volume is average of channels\n\n\n var volume = volSum / this.stereoVol.length; // normalized value\n\n var volNorm = Math.max(Math.min(volume / this.volMax, 1), 0);\n this.port.postMessage({\n name: \'amplitude\',\n volume: volume,\n volNorm: volNorm,\n stereoVol: this.stereoVol,\n stereoVolNorm: this.stereoVolNorm\n }); // pass input through to output\n\n this.outputRingBuffer.push(this.inputRingBufferArraySequence);\n } // pull 128 frames out of the ring buffer\n // if the ring buffer does not have enough frames, the output will be silent\n\n\n this.outputRingBuffer.pull(output);\n return true;\n }\n }]);\n\n return AmplitudeProcessor;\n}(_wrapNativeSuper(AudioWorkletProcessor));\n\nregisterProcessor(processorNames.amplitudeProcessor, AmplitudeProcessor);'},function(t,e,n){"use strict";var i;function o(t){return(o="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}void 0===(i=function(t){var a=n(1).audiocontext;void 0!==a.createStereoPanner?(p5.Panner=function(t,e){this.stereoPanner=this.input=a.createStereoPanner(),t.connect(this.stereoPanner),this.stereoPanner.connect(e)},p5.Panner.prototype.pan=function(t,e){var n=e||0,i=a.currentTime+n;this.stereoPanner.pan.linearRampToValueAtTime(t,i)},p5.Panner.prototype.inputChannels=function(){},p5.Panner.prototype.connect=function(t){this.stereoPanner.connect(t)},p5.Panner.prototype.disconnect=function(){this.stereoPanner&&this.stereoPanner.disconnect()}):(p5.Panner=function(t,e,n){this.input=a.createGain(),t.connect(this.input),this.left=a.createGain(),this.right=a.createGain(),this.left.channelInterpretation="discrete",this.right.channelInterpretation="discrete",1this.buffer.duration)throw"jump time out of range";if(e>this.buffer.duration-t)throw"end time out of range";var n=t||0,i=e||void 0;this.isPlaying()&&(this.stop(0),this.play(0,this.playbackRate,this.output.gain.value,n,i))},p5.SoundFile.prototype.channels=function(){return this.buffer.numberOfChannels},p5.SoundFile.prototype.sampleRate=function(){return this.buffer.sampleRate},p5.SoundFile.prototype.frames=function(){return this.buffer.length},p5.SoundFile.prototype.getPeaks=function(t){if(!this.buffer)throw"Cannot load peaks yet, buffer is not loaded";if(t=t||5*window.width,this.buffer){for(var e=this.buffer,n=e.length/t,i=~~(n/10)||1,o=e.numberOfChannels,r=new Float32Array(Math.round(t)),s=0;sr[u])&&(r[u]=h)}return r}},p5.SoundFile.prototype.reverseBuffer=function(){if(!this.buffer)throw"SoundFile is not done loading";var t=this._lastPos/p.sampleRate,e=this.getVolume();this.setVolume(0,.001);for(var n=this.buffer.numberOfChannels,i=0;ie){var r=t[o],s=new c(r,o);n[o]=s,o+=6e3}o++}return n}function m(t){if(isFinite(t)&&0!==t){for(;t<90;)t*=2;for(;180t[r].hi&&r++,o[r]=void 0!==o[r]?(o[r]+n[s])/2:n[s]}return o},p5.FFT.prototype.getOctaveBands=function(t,e){t=t||3;var n=[],i={lo:(e=e||15.625)/Math.pow(2,1/(2*t)),ctr:e,hi:e*Math.pow(2,1/(2*t))};n.push(i);for(var o=c.audiocontext.sampleRate/2;i.hi=this._maxDelay)throw new Error("Delay Time exceeds maximum delay time of "+this._maxDelay+" second.");t.connect(this.input),this.leftDelay.delayTime.setValueAtTime(r,this.ac.currentTime),this.rightDelay.delayTime.setValueAtTime(r,this.ac.currentTime),this._leftGain.gain.value=o,this._rightGain.gain.value=o,i&&(this._leftFilter.freq(i),this._rightFilter.freq(i))},p5.Delay.prototype.delayTime=function(t){"number"!=typeof t?(t.connect(this.leftDelay.delayTime),t.connect(this.rightDelay.delayTime)):(this.leftDelay.delayTime.cancelScheduledValues(this.ac.currentTime),this.rightDelay.delayTime.cancelScheduledValues(this.ac.currentTime),this.leftDelay.delayTime.linearRampToValueAtTime(t,this.ac.currentTime),this.rightDelay.delayTime.linearRampToValueAtTime(t,this.ac.currentTime))},p5.Delay.prototype.feedback=function(t){if(t&&"number"!=typeof t)t.connect(this._leftGain.gain),t.connect(this._rightGain.gain);else{if(1<=t)throw new Error("Feedback value will force a positive feedback loop.");"number"==typeof t&&(this._leftGain.gain.value=t,this._rightGain.gain.value=t)}return this._leftGain.gain.value},p5.Delay.prototype.filter=function(t,e){this._leftFilter.set(t,e),this._rightFilter.set(t,e)},p5.Delay.prototype.setType=function(t){switch(1===t&&(t="pingPong"),this._split.disconnect(),this._leftFilter.disconnect(),this._rightFilter.disconnect(),this._split.connect(this.leftDelay,0),this._split.connect(this.rightDelay,1),t){case"pingPong":this._rightFilter.setType(this._leftFilter.biquad.type),this._leftFilter.output.connect(this._merge,0,0),this._rightFilter.output.connect(this._merge,0,1),this._leftFilter.output.connect(this.rightDelay),this._rightFilter.output.connect(this.leftDelay);break;default:this._leftFilter.output.connect(this._merge,0,0),this._rightFilter.output.connect(this._merge,0,1),this._leftFilter.output.connect(this.leftDelay),this._rightFilter.output.connect(this.rightDelay)}},p5.Delay.prototype.dispose=function(){n.prototype.dispose.apply(this),this._split.disconnect(),this._leftFilter.dispose(),this._rightFilter.dispose(),this._merge.disconnect(),this._leftGain.disconnect(),this._rightGain.disconnect(),this.leftDelay.disconnect(),this.rightDelay.disconnect(),this._split=void 0,this._leftFilter=void 0,this._rightFilter=void 0,this._merge=void 0,this._leftGain=void 0,this._rightGain=void 0,this.leftDelay=void 0,this.rightDelay=void 0}}.call(e,i,e,t))||(t.exports=n)},function(t,e,n){"use strict";var i;void 0===(i=function(t){var p=n(11),e=n(4);p5.Reverb=function(){e.call(this),this._initConvolverNode(),this.input.gain.value=.5,this._seconds=3,this._decay=2,this._reverse=!1,this._buildImpulse()},p5.Reverb.prototype=Object.create(e.prototype),p5.Reverb.prototype._initConvolverNode=function(){this.convolverNode=this.ac.createConvolver(),this.input.connect(this.convolverNode),this.convolverNode.connect(this.wet)},p5.Reverb.prototype._teardownConvolverNode=function(){this.convolverNode&&(this.convolverNode.disconnect(),delete this.convolverNode)},p5.Reverb.prototype._setBuffer=function(t){this._teardownConvolverNode(),this._initConvolverNode(),this.convolverNode.buffer=t},p5.Reverb.prototype.process=function(t,e,n,i){t.connect(this.input);var o=!1;e&&(this._seconds=e,o=!0),n&&(this._decay=n),i&&(this._reverse=i),o&&this._buildImpulse()},p5.Reverb.prototype.set=function(t,e,n){var i=!1;t&&(this._seconds=t,i=!0),e&&(this._decay=e),n&&(this._reverse=n),i&&this._buildImpulse()},p5.Reverb.prototype._buildImpulse=function(){var t,e,n=this.ac.sampleRate,i=n*this._seconds,o=this._decay,r=this.ac.createBuffer(2,i,n),s=r.getChannelData(0),a=r.getChannelData(1);for(e=0;e=t.parts.length?(t.scoreStep=0,t.onended()):(t.scoreStep=0,t.parts[t.currentPart-1].stop(),t.parts[t.currentPart].start())}p5.prototype.setBPM=function(t,e){for(var n in o=t,i.parts)i.parts[n]&&i.parts[n].setBPM(t,e)},p5.Phrase=function(t,e,n){this.phraseStep=0,this.name=t,this.callback=e,this.sequence=n},p5.Part=function(t,e){this.length=t||0,this.partStep=0,this.phrases=[],this.isPlaying=!1,this.noLoop(),this.tatums=e||.0625,this.metro=new p5.Metro,this.metro._init(),this.metro.beatLength(this.tatums),this.metro.setBPM(o),i.parts.push(this),this.callback=function(){}},p5.Part.prototype.setBPM=function(t,e){this.metro.setBPM(t,e)},p5.Part.prototype.getBPM=function(){return this.metro.getBPM()},p5.Part.prototype.start=function(t){if(!this.isPlaying){this.isPlaying=!0,this.metro.resetSync(this);var e=t||0;this.metro.start(e)}},p5.Part.prototype.loop=function(t){this.looping=!0,this.onended=function(){this.partStep=0};var e=t||0;this.start(e)},p5.Part.prototype.noLoop=function(){this.looping=!1,this.onended=function(){this.stop()}},p5.Part.prototype.stop=function(t){this.partStep=0,this.pause(t)},p5.Part.prototype.pause=function(t){this.isPlaying=!1;var e=t||0;this.metro.stop(e)},p5.Part.prototype.addPhrase=function(t,e,n){var i;if(3===arguments.length)i=new p5.Phrase(t,e,n);else{if(!(t instanceof p5.Phrase))throw"invalid input. addPhrase accepts name, callback, array or a p5.Phrase";i=t}this.phrases.push(i),i.sequence.length>this.length&&(this.length=i.sequence.length)},p5.Part.prototype.removePhrase=function(t){for(var e in this.phrases)this.phrases[e].name===t&&this.phrases.splice(e,1)},p5.Part.prototype.getPhrase=function(t){for(var e in this.phrases)if(this.phrases[e].name===t)return this.phrases[e]},p5.Part.prototype.replaceSequence=function(t,e){for(var n in this.phrases)this.phrases[n].name===t&&(this.phrases[n].sequence=e)},p5.Part.prototype.incrementStep=function(t){this.partStepthis.cutoff&&e>this.threshold&&0t)this.cancelScheduledValues(t),this.linearRampToValueAtTime(e,t);else{var i=this._searchAfter(t);i&&(this.cancelScheduledValues(t),i.type===u.TimelineSignal.Type.Linear?this.linearRampToValueAtTime(e,t):i.type===u.TimelineSignal.Type.Exponential&&this.exponentialRampToValueAtTime(e,t)),this.setValueAtTime(e,t)}return this},u.TimelineSignal.prototype.linearRampToValueBetween=function(t,e,n){return this.setRampPoint(e),this.linearRampToValueAtTime(t,n),this},u.TimelineSignal.prototype.exponentialRampToValueBetween=function(t,e,n){return this.setRampPoint(e),this.exponentialRampToValueAtTime(t,n),this},u.TimelineSignal.prototype._searchBefore=function(t){return this._events.get(t)},u.TimelineSignal.prototype._searchAfter=function(t){return this._events.getAfter(t)},u.TimelineSignal.prototype.getValueAtTime=function(t){t=this.toSeconds(t);var e=this._searchAfter(t),n=this._searchBefore(t),i=this._initial;if(null===n)i=this._initial;else if(n.type===u.TimelineSignal.Type.Target){var o,r=this._events.getBefore(n.time);o=null===r?this._initial:r.value,i=this._exponentialApproach(n.time,o,n.value,n.constant,t)}else i=n.type===u.TimelineSignal.Type.Curve?this._curveInterpolate(n.time,n.value,n.duration,t):null===e?n.value:e.type===u.TimelineSignal.Type.Linear?this._linearInterpolate(n.time,n.value,e.time,e.value,t):e.type===u.TimelineSignal.Type.Exponential?this._exponentialInterpolate(n.time,n.value,e.time,e.value,t):n.value;return i},u.TimelineSignal.prototype.connect=u.SignalBase.prototype.connect,u.TimelineSignal.prototype._exponentialApproach=function(t,e,n,i,o){return n+(e-n)*Math.exp(-(o-t)/i)},u.TimelineSignal.prototype._linearInterpolate=function(t,e,n,i,o){return e+(o-t)/(n-t)*(i-e)},u.TimelineSignal.prototype._exponentialInterpolate=function(t,e,n,i,o){return(e=Math.max(this._minOutput,e))*Math.pow(i/e,(o-t)/(n-t))},u.TimelineSignal.prototype._curveInterpolate=function(t,e,n,i){var o=e.length;if(t+n<=i)return e[o-1];if(i<=t)return e[0];var r=(i-t)/n,s=Math.floor((o-1)*r),a=Math.ceil((o-1)*r),u=e[s],p=e[a];return a===s?u:this._linearInterpolate(s,u,a,p,r*(o-1))},u.TimelineSignal.prototype.dispose=function(){u.Signal.prototype.dispose.call(this),u.Param.prototype.dispose.call(this),this._events.dispose(),this._events=null},u.TimelineSignal}.apply(e,i))||(t.exports=o)},function(t,e,n){"use strict";var i;void 0===(i=function(t){var e=n(4);return p5.Filter=function(t){e.call(this),this.biquad=this.ac.createBiquadFilter(),this.input.connect(this.biquad),this.biquad.connect(this.wet),t&&this.setType(t),this._on=!0,this._untoggledType=this.biquad.type},p5.Filter.prototype=Object.create(e.prototype),p5.Filter.prototype.process=function(t,e,n,i){t.connect(this.input),this.set(e,n,i)},p5.Filter.prototype.set=function(t,e,n){t&&this.freq(t,n),e&&this.res(e,n)},p5.Filter.prototype.freq=function(t,e){var n=e||0;return t<=0&&(t=1),"number"==typeof t?(this.biquad.frequency.cancelScheduledValues(this.ac.currentTime+.01+n),this.biquad.frequency.exponentialRampToValueAtTime(t,this.ac.currentTime+.02+n)):t&&t.connect(this.biquad.frequency),this.biquad.frequency.value},p5.Filter.prototype.res=function(t,e){var n=e||0;return"number"==typeof t?(this.biquad.Q.value=t,this.biquad.Q.cancelScheduledValues(this.ac.currentTime+.01+n),this.biquad.Q.linearRampToValueAtTime(t,this.ac.currentTime+.02+n)):t&&t.connect(this.biquad.Q),this.biquad.Q.value},p5.Filter.prototype.gain=function(t,e){var n=e||0;return"number"==typeof t?(this.biquad.gain.value=t,this.biquad.gain.cancelScheduledValues(this.ac.currentTime+.01+n),this.biquad.gain.linearRampToValueAtTime(t,this.ac.currentTime+.02+n)):t&&t.connect(this.biquad.gain),this.biquad.gain.value},p5.Filter.prototype.toggle=function(){return this._on=!this._on,!0===this._on?this.biquad.type=this._untoggledType:!1===this._on&&(this.biquad.type="allpass"),this._on},p5.Filter.prototype.setType=function(t){this.biquad.type=t,this._untoggledType=this.biquad.type},p5.Filter.prototype.dispose=function(){e.prototype.dispose.apply(this),this.biquad&&(this.biquad.disconnect(),delete this.biquad)},p5.LowPass=function(){p5.Filter.call(this,"lowpass")},p5.LowPass.prototype=Object.create(p5.Filter.prototype),p5.HighPass=function(){p5.Filter.call(this,"highpass")},p5.HighPass.prototype=Object.create(p5.Filter.prototype),p5.BandPass=function(){p5.Filter.call(this,"bandpass")},p5.BandPass.prototype=Object.create(p5.Filter.prototype),p5.Filter}.call(e,n,e,t))||(t.exports=i)},function(t,e,n){var i,o;i=[n(0),n(7),n(25),n(2),n(9)],void 0===(o=function(e){"use strict";return e.Subtract=function(t){this.createInsOuts(2,0),this._sum=this.input[0]=this.output=new e.Gain,this._neg=new e.Negate,this._param=this.input[1]=new e.Signal(t),this._param.chain(this._neg,this._sum)},e.extend(e.Subtract,e.Signal),e.Subtract.prototype.dispose=function(){return e.prototype.dispose.call(this),this._neg.dispose(),this._neg=null,this._sum.disconnect(),this._sum=null,this._param.dispose(),this._param=null,this},e.Subtract}.apply(e,i))||(t.exports=o)},function(i,o,r){"use strict";(function(t){var e,n;t.TONE_SILENCE_VERSION_LOGGING=!0,e=[r(35),r(12),r(0)],void 0===(n=function(i,t,e){var o=new window.AudioContext;return e.context.dispose(),e.setContext(o),p5.prototype.getAudioContext=function(){return o},p5.prototype.userStartAudio=function(t,e){var n=t;return t instanceof p5.Element?n=t.elt:t instanceof Array&&t[0]instanceof p5.Element&&(n=t.map(function(t){return t.elt})),i(o,n,e)},o}.apply(o,e))||(i.exports=n)}).call(this,r(34))},function(t,e,n){var i,o;i=[n(0)],void 0===(o=function(s){"use strict";return s.Emitter=function(){this._events={}},s.extend(s.Emitter),s.Emitter.prototype.on=function(t,e){for(var n=t.split(/\W+/),i=0;ithis.memory){var n=this.length-this.memory;this._timeline.splice(0,n)}return this},e.Timeline.prototype.remove=function(t){if(this._iterating)this._toRemove.push(t);else{var e=this._timeline.indexOf(t);-1!==e&&this._timeline.splice(e,1)}return this},e.Timeline.prototype.get=function(t){var e=this._search(t);return-1!==e?this._timeline[e]:null},e.Timeline.prototype.peek=function(){return this._timeline[0]},e.Timeline.prototype.shift=function(){return this._timeline.shift()},e.Timeline.prototype.getAfter=function(t){var e=this._search(t);return e+1=t&&(this._timeline=[]);return this},e.Timeline.prototype.cancelBefore=function(t){if(this._timeline.length){var e=this._search(t);0<=e&&(this._timeline=this._timeline.slice(e+1))}return this},e.Timeline.prototype._search=function(t){var e=0,n=this._timeline.length,i=n;if(0t)return o;r.time>t?i=o:r.time=t;)n--;return this._iterate(e,n+1),this},e.Timeline.prototype.forEachAtTime=function(e,n){var t=this._search(e);return-1!==t&&this._iterate(function(t){t.time===e&&n(t)},0,t),this},e.Timeline.prototype.dispose=function(){e.prototype.dispose.call(this),this._timeline=null,this._toRemove=null},e.Timeline}.apply(e,i))||(t.exports=o)},function(t,e,n){var i,o;i=[n(0),n(3),n(2)],void 0===(o=function(t){"use strict";return t.Negate=function(){this._multiply=this.input=this.output=new t.Multiply(-1)},t.extend(t.Negate,t.SignalBase),t.Negate.prototype.dispose=function(){return t.prototype.dispose.call(this),this._multiply.dispose(),this._multiply=null,this},t.Negate}.apply(e,i))||(t.exports=o)},function(t,e,n){var i,o;i=[n(0),n(2),n(3),n(6)],void 0===(o=function(t){"use strict";return t.GreaterThanZero=function(){this._thresh=this.output=new t.WaveShaper(function(t){return t<=0?0:1},127),this._scale=this.input=new t.Multiply(1e4),this._scale.connect(this._thresh)},t.extend(t.GreaterThanZero,t.SignalBase),t.GreaterThanZero.prototype.dispose=function(){return t.prototype.dispose.call(this),this._scale.dispose(),this._scale=null,this._thresh.dispose(),this._thresh=null,this},t.GreaterThanZero}.apply(e,i))||(t.exports=o)},function(t,e,n){var i,o;i=[n(0),n(14),n(66),n(18),n(12)],void 0===(o=function(o){"use strict";return o.Clock=function(){o.Emitter.call(this);var t=this.optionsObject(arguments,["callback","frequency"],o.Clock.defaults);this.callback=t.callback,this._nextTick=0,this._lastState=o.State.Stopped,this.frequency=new o.TimelineSignal(t.frequency,o.Type.Frequency),this._readOnly("frequency"),this.ticks=0,this._state=new o.TimelineState(o.State.Stopped),this._boundLoop=this._loop.bind(this),this.context.on("tick",this._boundLoop)},o.extend(o.Clock,o.Emitter),o.Clock.defaults={callback:o.noOp,frequency:1,lookAhead:"auto"},Object.defineProperty(o.Clock.prototype,"state",{get:function(){return this._state.getValueAtTime(this.now())}}),o.Clock.prototype.start=function(t,e){return t=this.toSeconds(t),this._state.getValueAtTime(t)!==o.State.Started&&this._state.add({state:o.State.Started,time:t,offset:e}),this},o.Clock.prototype.stop=function(t){return t=this.toSeconds(t),this._state.cancel(t),this._state.setStateAtTime(o.State.Stopped,t),this},o.Clock.prototype.pause=function(t){return t=this.toSeconds(t),this._state.getValueAtTime(t)===o.State.Started&&this._state.setStateAtTime(o.State.Paused,t),this},o.Clock.prototype._loop=function(){for(var t=this.now()+this.context.lookAhead+this.context.updateInterval+2*this.context.lag;t>this._nextTick&&this._state;){var e=this._state.getValueAtTime(this._nextTick);if(e!==this._lastState){this._lastState=e;var n=this._state.get(this._nextTick);e===o.State.Started?(this._nextTick=n.time,this.isUndef(n.offset)||(this.ticks=n.offset),this.emit("start",n.time,this.ticks)):e===o.State.Stopped?(this.ticks=0,this.emit("stop",n.time)):e===o.State.Paused&&this.emit("pause",n.time)}var i=this._nextTick;this.frequency&&(this._nextTick+=1/this.frequency.getValueAtTime(this._nextTick),e===o.State.Started&&(this.callback(i),this.ticks++))}},o.Clock.prototype.getStateAtTime=function(t){return t=this.toSeconds(t),this._state.getValueAtTime(t)},o.Clock.prototype.dispose=function(){o.Emitter.prototype.dispose.call(this),this.context.off("tick",this._boundLoop),this._writable("frequency"),this.frequency.dispose(),this.frequency=null,this._boundLoop=null,this._nextTick=1/0,this.callback=null,this._state.dispose(),this._state=null},o.Clock}.apply(e,i))||(t.exports=o)},function(t,e,i){"use strict";var n;void 0===(n=function(t){var n=i(1),e=i(29),r=i(5).noteToFreq;p5.MonoSynth=function(){e.call(this),this.oscillator=new p5.Oscillator,this.env=new p5.Envelope,this.env.setRange(1,0),this.env.setExp(!0),this.setADSR(.02,.25,.05,.35),this.oscillator.disconnect(),this.oscillator.connect(this.output),this.env.disconnect(),this.env.setInput(this.output.gain),this.oscillator.output.gain.value=1,this.oscillator.start(),this.connect(),n.soundArray.push(this)},p5.MonoSynth.prototype=Object.create(p5.AudioVoice.prototype),p5.MonoSynth.prototype.play=function(t,e,n,i){this.triggerAttack(t,e,~~n),this.triggerRelease(~~n+(i||.15))},p5.MonoSynth.prototype.triggerAttack=function(t,e,n){n=~~n;var i=r(t),o=e||.1;this.oscillator.freq(i,0,n),this.env.ramp(this.output.gain,n,o)},p5.MonoSynth.prototype.triggerRelease=function(t){t=t||0;this.env.ramp(this.output.gain,t,0)},p5.MonoSynth.prototype.setADSR=function(t,e,n,i){this.env.setADSR(t,e,n,i)},Object.defineProperties(p5.MonoSynth.prototype,{attack:{get:function(){return this.env.aTime},set:function(t){this.env.setADSR(t,this.env.dTime,this.env.sPercent,this.env.rTime)}},decay:{get:function(){return this.env.dTime},set:function(t){this.env.setADSR(this.env.aTime,t,this.env.sPercent,this.env.rTime)}},sustain:{get:function(){return this.env.sPercent},set:function(t){this.env.setADSR(this.env.aTime,this.env.dTime,t,this.env.rTime)}},release:{get:function(){return this.env.rTime},set:function(t){this.env.setADSR(this.env.aTime,this.env.dTime,this.env.sPercent,t)}}}),p5.MonoSynth.prototype.amp=function(t,e){var n=e||0;return void 0!==t&&this.oscillator.amp(t,n),this.oscillator.amp().value},p5.MonoSynth.prototype.connect=function(t){var e=t||n.input;this.output.connect(e.input?e.input:e)},p5.MonoSynth.prototype.disconnect=function(){this.output&&this.output.disconnect()},p5.MonoSynth.prototype.dispose=function(){e.prototype.dispose.apply(this),this.env&&this.env.dispose(),this.oscillator&&this.oscillator.dispose()}}.call(e,i,e,t))||(t.exports=n)},function(t,e,i){"use strict";var n;void 0===(n=function(){var n=i(1);return p5.AudioVoice=function(){this.ac=n.audiocontext,this.output=this.ac.createGain(),this.connect(),n.soundArray.push(this)},p5.AudioVoice.prototype.play=function(t,e,n,i){},p5.AudioVoice.prototype.triggerAttack=function(t,e,n){},p5.AudioVoice.prototype.triggerRelease=function(t){},p5.AudioVoice.prototype.amp=function(t,e){},p5.AudioVoice.prototype.connect=function(t){var e=t||n.input;this.output.connect(e.input?e.input:e)},p5.AudioVoice.prototype.disconnect=function(){this.output.disconnect()},p5.AudioVoice.prototype.dispose=function(){this.output&&(this.output.disconnect(),delete this.output)},p5.AudioVoice}.call(e,i,e,t))||(t.exports=n)},function(t,e,n){"use strict";var i;void 0===(i=function(t){var c=n(1),h=n(14),l=n(5).noteToFreq;p5.PolySynth=function(t,e){this.audiovoices=[],this.notes={},this._newest=0,this._oldest=0,this.maxVoices=e||8,this.AudioVoice=void 0===t?p5.MonoSynth:t,this._voicesInUse=new h(0),this.output=c.audiocontext.createGain(),this.connect(),this._allocateVoices(),c.soundArray.push(this)},p5.PolySynth.prototype._allocateVoices=function(){for(var t=0;t= this._length) {\n this._writeIndex = 0;\n } // For excessive frames, the buffer will be overwritten.\n\n\n this._framesAvailable += sourceLength;\n\n if (this._framesAvailable > this._length) {\n this._framesAvailable = this._length;\n }\n }\n /**\n * Pull data out of buffer and fill a given sequence of Float32Arrays.\n *\n * @param {array} arraySequence An array of Float32Arrays.\n */\n\n }, {\n key: "pull",\n value: function pull(arraySequence) {\n // The channel count of arraySequence and the length of each channel must\n // match with this buffer obejct.\n // If the FIFO is completely empty, do nothing.\n if (this._framesAvailable === 0) {\n return;\n }\n\n var destinationLength = arraySequence[0].length; // Transfer data from the internal buffer to the |arraySequence| storage.\n\n for (var i = 0; i < destinationLength; ++i) {\n var readIndex = (this._readIndex + i) % this._length;\n\n for (var channel = 0; channel < this._channelCount; ++channel) {\n arraySequence[channel][i] = this._channelData[channel][readIndex];\n }\n }\n\n this._readIndex += destinationLength;\n\n if (this._readIndex >= this._length) {\n this._readIndex = 0;\n }\n\n this._framesAvailable -= destinationLength;\n\n if (this._framesAvailable < 0) {\n this._framesAvailable = 0;\n }\n }\n }, {\n key: "framesAvailable",\n get: function get() {\n return this._framesAvailable;\n }\n }]);\n\n return RingBuffer;\n }()\n}["default"];\n\nvar RecorderProcessor =\n/*#__PURE__*/\nfunction (_AudioWorkletProcesso) {\n _inherits(RecorderProcessor, _AudioWorkletProcesso);\n\n function RecorderProcessor(options) {\n var _this;\n\n _classCallCheck(this, RecorderProcessor);\n\n _this = _possibleConstructorReturn(this, _getPrototypeOf(RecorderProcessor).call(this));\n var processorOptions = options.processorOptions || {};\n _this.numOutputChannels = options.outputChannelCount || 2;\n _this.numInputChannels = processorOptions.numInputChannels || 2;\n _this.bufferSize = processorOptions.bufferSize || 1024;\n _this.recording = false;\n\n _this.clear();\n\n _this.port.onmessage = function (event) {\n var data = event.data;\n\n if (data.name === \'start\') {\n _this.record(data.duration);\n } else if (data.name === \'stop\') {\n _this.stop();\n }\n };\n\n return _this;\n }\n\n _createClass(RecorderProcessor, [{\n key: "process",\n value: function process(inputs) {\n if (!this.recording) {\n return true;\n } else if (this.sampleLimit && this.recordedSamples >= this.sampleLimit) {\n this.stop();\n return true;\n }\n\n var input = inputs[0];\n this.inputRingBuffer.push(input);\n\n if (this.inputRingBuffer.framesAvailable >= this.bufferSize) {\n this.inputRingBuffer.pull(this.inputRingBufferArraySequence);\n\n for (var channel = 0; channel < this.numOutputChannels; ++channel) {\n var inputChannelCopy = this.inputRingBufferArraySequence[channel].slice();\n\n if (channel === 0) {\n this.leftBuffers.push(inputChannelCopy);\n\n if (this.numInputChannels === 1) {\n this.rightBuffers.push(inputChannelCopy);\n }\n } else if (channel === 1 && this.numInputChannels > 1) {\n this.rightBuffers.push(inputChannelCopy);\n }\n }\n\n this.recordedSamples += this.bufferSize;\n }\n\n return true;\n }\n }, {\n key: "record",\n value: function record(duration) {\n if (duration) {\n this.sampleLimit = Math.round(duration * sampleRate);\n }\n\n this.recording = true;\n }\n }, {\n key: "stop",\n value: function stop() {\n this.recording = false;\n var buffers = this.getBuffers();\n var leftBuffer = buffers[0].buffer;\n var rightBuffer = buffers[1].buffer;\n this.port.postMessage({\n name: \'buffers\',\n leftBuffer: leftBuffer,\n rightBuffer: rightBuffer\n }, [leftBuffer, rightBuffer]);\n this.clear();\n }\n }, {\n key: "getBuffers",\n value: function getBuffers() {\n var buffers = [];\n buffers.push(this.mergeBuffers(this.leftBuffers));\n buffers.push(this.mergeBuffers(this.rightBuffers));\n return buffers;\n }\n }, {\n key: "mergeBuffers",\n value: function mergeBuffers(channelBuffer) {\n var result = new Float32Array(this.recordedSamples);\n var offset = 0;\n var lng = channelBuffer.length;\n\n for (var i = 0; i < lng; i++) {\n var buffer = channelBuffer[i];\n result.set(buffer, offset);\n offset += buffer.length;\n }\n\n return result;\n }\n }, {\n key: "clear",\n value: function clear() {\n var _this2 = this;\n\n this.leftBuffers = [];\n this.rightBuffers = [];\n this.inputRingBuffer = new RingBuffer(this.bufferSize, this.numInputChannels);\n this.inputRingBufferArraySequence = new Array(this.numInputChannels).fill(null).map(function () {\n return new Float32Array(_this2.bufferSize);\n });\n this.recordedSamples = 0;\n this.sampleLimit = null;\n }\n }]);\n\n return RecorderProcessor;\n}(_wrapNativeSuper(AudioWorkletProcessor));\n\nregisterProcessor(processorNames.recorderProcessor, RecorderProcessor);'},function(t,e,n){"use strict";n.r(e),e.default='function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }\n\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }\n\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn\'t been initialised - super() hasn\'t been called"); } return self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\nfunction _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }\n\nfunction isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\n\nfunction _construct(Parent, args, Class) { if (isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }\n\nfunction _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }\n\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\n// import dependencies via preval.require so that they\'re available as values at compile time\nvar processorNames = {\n "recorderProcessor": "recorder-processor",\n "soundFileProcessor": "sound-file-processor",\n "amplitudeProcessor": "amplitude-processor"\n};\nvar RingBuffer = {\n "default":\n /*#__PURE__*/\n function () {\n /**\n * @constructor\n * @param {number} length Buffer length in frames.\n * @param {number} channelCount Buffer channel count.\n */\n function RingBuffer(length, channelCount) {\n _classCallCheck(this, RingBuffer);\n\n this._readIndex = 0;\n this._writeIndex = 0;\n this._framesAvailable = 0;\n this._channelCount = channelCount;\n this._length = length;\n this._channelData = [];\n\n for (var i = 0; i < this._channelCount; ++i) {\n this._channelData[i] = new Float32Array(length);\n }\n }\n /**\n * Getter for Available frames in buffer.\n *\n * @return {number} Available frames in buffer.\n */\n\n\n _createClass(RingBuffer, [{\n key: "push",\n\n /**\n * Push a sequence of Float32Arrays to buffer.\n *\n * @param {array} arraySequence A sequence of Float32Arrays.\n */\n value: function push(arraySequence) {\n // The channel count of arraySequence and the length of each channel must\n // match with this buffer obejct.\n // Transfer data from the |arraySequence| storage to the internal buffer.\n var sourceLength = arraySequence[0].length;\n\n for (var i = 0; i < sourceLength; ++i) {\n var writeIndex = (this._writeIndex + i) % this._length;\n\n for (var channel = 0; channel < this._channelCount; ++channel) {\n this._channelData[channel][writeIndex] = arraySequence[channel][i];\n }\n }\n\n this._writeIndex += sourceLength;\n\n if (this._writeIndex >= this._length) {\n this._writeIndex = 0;\n } // For excessive frames, the buffer will be overwritten.\n\n\n this._framesAvailable += sourceLength;\n\n if (this._framesAvailable > this._length) {\n this._framesAvailable = this._length;\n }\n }\n /**\n * Pull data out of buffer and fill a given sequence of Float32Arrays.\n *\n * @param {array} arraySequence An array of Float32Arrays.\n */\n\n }, {\n key: "pull",\n value: function pull(arraySequence) {\n // The channel count of arraySequence and the length of each channel must\n // match with this buffer obejct.\n // If the FIFO is completely empty, do nothing.\n if (this._framesAvailable === 0) {\n return;\n }\n\n var destinationLength = arraySequence[0].length; // Transfer data from the internal buffer to the |arraySequence| storage.\n\n for (var i = 0; i < destinationLength; ++i) {\n var readIndex = (this._readIndex + i) % this._length;\n\n for (var channel = 0; channel < this._channelCount; ++channel) {\n arraySequence[channel][i] = this._channelData[channel][readIndex];\n }\n }\n\n this._readIndex += destinationLength;\n\n if (this._readIndex >= this._length) {\n this._readIndex = 0;\n }\n\n this._framesAvailable -= destinationLength;\n\n if (this._framesAvailable < 0) {\n this._framesAvailable = 0;\n }\n }\n }, {\n key: "framesAvailable",\n get: function get() {\n return this._framesAvailable;\n }\n }]);\n\n return RingBuffer;\n }()\n}["default"];\n\nvar SoundFileProcessor =\n/*#__PURE__*/\nfunction (_AudioWorkletProcesso) {\n _inherits(SoundFileProcessor, _AudioWorkletProcesso);\n\n function SoundFileProcessor(options) {\n var _this;\n\n _classCallCheck(this, SoundFileProcessor);\n\n _this = _possibleConstructorReturn(this, _getPrototypeOf(SoundFileProcessor).call(this));\n var processorOptions = options.processorOptions || {};\n _this.bufferSize = processorOptions.bufferSize || 256;\n _this.inputRingBuffer = new RingBuffer(_this.bufferSize, 1);\n _this.inputRingBufferArraySequence = [new Float32Array(_this.bufferSize)];\n return _this;\n }\n\n _createClass(SoundFileProcessor, [{\n key: "process",\n value: function process(inputs) {\n var input = inputs[0]; // we only care about the first input channel, because that contains the position data\n\n this.inputRingBuffer.push([input[0]]);\n\n if (this.inputRingBuffer.framesAvailable >= this.bufferSize) {\n this.inputRingBuffer.pull(this.inputRingBufferArraySequence);\n var inputChannel = this.inputRingBufferArraySequence[0];\n var position = inputChannel[inputChannel.length - 1] || 0;\n this.port.postMessage({\n name: \'position\',\n position: position\n });\n }\n\n return true;\n }\n }]);\n\n return SoundFileProcessor;\n}(_wrapNativeSuper(AudioWorkletProcessor));\n\nregisterProcessor(processorNames.soundFileProcessor, SoundFileProcessor);'},function(t,e,n){"use strict";n.r(e),e.default='function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }\n\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }\n\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn\'t been initialised - super() hasn\'t been called"); } return self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\nfunction _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }\n\nfunction isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\n\nfunction _construct(Parent, args, Class) { if (isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }\n\nfunction _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }\n\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\n// import dependencies via preval.require so that they\'re available as values at compile time\nvar processorNames = {\n "recorderProcessor": "recorder-processor",\n "soundFileProcessor": "sound-file-processor",\n "amplitudeProcessor": "amplitude-processor"\n};\nvar RingBuffer = {\n "default":\n /*#__PURE__*/\n function () {\n /**\n * @constructor\n * @param {number} length Buffer length in frames.\n * @param {number} channelCount Buffer channel count.\n */\n function RingBuffer(length, channelCount) {\n _classCallCheck(this, RingBuffer);\n\n this._readIndex = 0;\n this._writeIndex = 0;\n this._framesAvailable = 0;\n this._channelCount = channelCount;\n this._length = length;\n this._channelData = [];\n\n for (var i = 0; i < this._channelCount; ++i) {\n this._channelData[i] = new Float32Array(length);\n }\n }\n /**\n * Getter for Available frames in buffer.\n *\n * @return {number} Available frames in buffer.\n */\n\n\n _createClass(RingBuffer, [{\n key: "push",\n\n /**\n * Push a sequence of Float32Arrays to buffer.\n *\n * @param {array} arraySequence A sequence of Float32Arrays.\n */\n value: function push(arraySequence) {\n // The channel count of arraySequence and the length of each channel must\n // match with this buffer obejct.\n // Transfer data from the |arraySequence| storage to the internal buffer.\n var sourceLength = arraySequence[0].length;\n\n for (var i = 0; i < sourceLength; ++i) {\n var writeIndex = (this._writeIndex + i) % this._length;\n\n for (var channel = 0; channel < this._channelCount; ++channel) {\n this._channelData[channel][writeIndex] = arraySequence[channel][i];\n }\n }\n\n this._writeIndex += sourceLength;\n\n if (this._writeIndex >= this._length) {\n this._writeIndex = 0;\n } // For excessive frames, the buffer will be overwritten.\n\n\n this._framesAvailable += sourceLength;\n\n if (this._framesAvailable > this._length) {\n this._framesAvailable = this._length;\n }\n }\n /**\n * Pull data out of buffer and fill a given sequence of Float32Arrays.\n *\n * @param {array} arraySequence An array of Float32Arrays.\n */\n\n }, {\n key: "pull",\n value: function pull(arraySequence) {\n // The channel count of arraySequence and the length of each channel must\n // match with this buffer obejct.\n // If the FIFO is completely empty, do nothing.\n if (this._framesAvailable === 0) {\n return;\n }\n\n var destinationLength = arraySequence[0].length; // Transfer data from the internal buffer to the |arraySequence| storage.\n\n for (var i = 0; i < destinationLength; ++i) {\n var readIndex = (this._readIndex + i) % this._length;\n\n for (var channel = 0; channel < this._channelCount; ++channel) {\n arraySequence[channel][i] = this._channelData[channel][readIndex];\n }\n }\n\n this._readIndex += destinationLength;\n\n if (this._readIndex >= this._length) {\n this._readIndex = 0;\n }\n\n this._framesAvailable -= destinationLength;\n\n if (this._framesAvailable < 0) {\n this._framesAvailable = 0;\n }\n }\n }, {\n key: "framesAvailable",\n get: function get() {\n return this._framesAvailable;\n }\n }]);\n\n return RingBuffer;\n }()\n}["default"];\n\nvar AmplitudeProcessor =\n/*#__PURE__*/\nfunction (_AudioWorkletProcesso) {\n _inherits(AmplitudeProcessor, _AudioWorkletProcesso);\n\n function AmplitudeProcessor(options) {\n var _this;\n\n _classCallCheck(this, AmplitudeProcessor);\n\n _this = _possibleConstructorReturn(this, _getPrototypeOf(AmplitudeProcessor).call(this));\n var processorOptions = options.processorOptions || {};\n _this.numOutputChannels = options.outputChannelCount || 1;\n _this.numInputChannels = processorOptions.numInputChannels || 2;\n _this.normalize = processorOptions.normalize || false;\n _this.smoothing = processorOptions.smoothing || 0;\n _this.bufferSize = processorOptions.bufferSize || 2048;\n _this.inputRingBuffer = new RingBuffer(_this.bufferSize, _this.numInputChannels);\n _this.outputRingBuffer = new RingBuffer(_this.bufferSize, _this.numOutputChannels);\n _this.inputRingBufferArraySequence = new Array(_this.numInputChannels).fill(null).map(function () {\n return new Float32Array(_this.bufferSize);\n });\n _this.stereoVol = [0, 0];\n _this.stereoVolNorm = [0, 0];\n _this.volMax = 0.001;\n\n _this.port.onmessage = function (event) {\n var data = event.data;\n\n if (data.name === \'toggleNormalize\') {\n _this.normalize = data.normalize;\n } else if (data.name === \'smoothing\') {\n _this.smoothing = Math.max(0, Math.min(1, data.smoothing));\n }\n };\n\n return _this;\n } // TO DO make this stereo / dependent on # of audio channels\n\n\n _createClass(AmplitudeProcessor, [{\n key: "process",\n value: function process(inputs, outputs) {\n var input = inputs[0];\n var output = outputs[0];\n var smoothing = this.smoothing;\n this.inputRingBuffer.push(input);\n\n if (this.inputRingBuffer.framesAvailable >= this.bufferSize) {\n this.inputRingBuffer.pull(this.inputRingBufferArraySequence);\n\n for (var channel = 0; channel < this.numInputChannels; ++channel) {\n var inputBuffer = this.inputRingBufferArraySequence[channel];\n var bufLength = inputBuffer.length;\n var sum = 0;\n\n for (var i = 0; i < bufLength; i++) {\n var x = inputBuffer[i];\n\n if (this.normalize) {\n sum += Math.max(Math.min(x / this.volMax, 1), -1) * Math.max(Math.min(x / this.volMax, 1), -1);\n } else {\n sum += x * x;\n }\n } // ... then take the square root of the sum.\n\n\n var rms = Math.sqrt(sum / bufLength);\n this.stereoVol[channel] = Math.max(rms, this.stereoVol[channel] * smoothing);\n this.volMax = Math.max(this.stereoVol[channel], this.volMax);\n } // calculate stero normalized volume and add volume from all channels together\n\n\n var volSum = 0;\n\n for (var index = 0; index < this.stereoVol.length; index++) {\n this.stereoVolNorm[index] = Math.max(Math.min(this.stereoVol[index] / this.volMax, 1), 0);\n volSum += this.stereoVol[index];\n } // volume is average of channels\n\n\n var volume = volSum / this.stereoVol.length; // normalized value\n\n var volNorm = Math.max(Math.min(volume / this.volMax, 1), 0);\n this.port.postMessage({\n name: \'amplitude\',\n volume: volume,\n volNorm: volNorm,\n stereoVol: this.stereoVol,\n stereoVolNorm: this.stereoVolNorm\n }); // pass input through to output\n\n this.outputRingBuffer.push(this.inputRingBufferArraySequence);\n } // pull 128 frames out of the ring buffer\n // if the ring buffer does not have enough frames, the output will be silent\n\n\n this.outputRingBuffer.pull(output);\n return true;\n }\n }]);\n\n return AmplitudeProcessor;\n}(_wrapNativeSuper(AudioWorkletProcessor));\n\nregisterProcessor(processorNames.amplitudeProcessor, AmplitudeProcessor);'},function(t,e,n){"use strict";var i;function o(t){return(o="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}void 0===(i=function(t){var a=n(1).audiocontext;void 0!==a.createStereoPanner?(p5.Panner=function(t,e){this.stereoPanner=this.input=a.createStereoPanner(),t.connect(this.stereoPanner),this.stereoPanner.connect(e)},p5.Panner.prototype.pan=function(t,e){var n=e||0,i=a.currentTime+n;this.stereoPanner.pan.linearRampToValueAtTime(t,i)},p5.Panner.prototype.inputChannels=function(){},p5.Panner.prototype.connect=function(t){this.stereoPanner.connect(t)},p5.Panner.prototype.disconnect=function(){this.stereoPanner&&this.stereoPanner.disconnect()}):(p5.Panner=function(t,e,n){this.input=a.createGain(),t.connect(this.input),this.left=a.createGain(),this.right=a.createGain(),this.left.channelInterpretation="discrete",this.right.channelInterpretation="discrete",1this.buffer.duration)throw"jump time out of range";if(e>this.buffer.duration-t)throw"end time out of range";var n=t||0,i=e||void 0;this.isPlaying()&&(this.stop(0),this.play(0,this.playbackRate,this.output.gain.value,n,i))},p5.SoundFile.prototype.channels=function(){return this.buffer.numberOfChannels},p5.SoundFile.prototype.sampleRate=function(){return this.buffer.sampleRate},p5.SoundFile.prototype.frames=function(){return this.buffer.length},p5.SoundFile.prototype.getPeaks=function(t){if(!this.buffer)throw"Cannot load peaks yet, buffer is not loaded";if(t=t||5*window.width,this.buffer){for(var e=this.buffer,n=e.length/t,i=~~(n/10)||1,o=e.numberOfChannels,r=new Float32Array(Math.round(t)),s=0;sr[u])&&(r[u]=h)}return r}},p5.SoundFile.prototype.reverseBuffer=function(){if(!this.buffer)throw"SoundFile is not done loading";var t=this._lastPos/p.sampleRate,e=this.getVolume();this.setVolume(0,.001);for(var n=this.buffer.numberOfChannels,i=0;ie){var r=t[o],s=new c(r,o);n[o]=s,o+=6e3}o++}return n}function m(t){if(isFinite(t)&&0!==t){for(;t<90;)t*=2;for(;180t[r].hi&&r++,o[r]=void 0!==o[r]?(o[r]+n[s])/2:n[s]}return o},p5.FFT.prototype.getOctaveBands=function(t,e){t=t||3;var n=[],i={lo:(e=e||15.625)/Math.pow(2,1/(2*t)),ctr:e,hi:e*Math.pow(2,1/(2*t))};n.push(i);for(var o=c.audiocontext.sampleRate/2;i.hi=this._maxDelay)throw new Error("Delay Time exceeds maximum delay time of "+this._maxDelay+" second.");t.connect(this.input),this.leftDelay.delayTime.setValueAtTime(r,this.ac.currentTime),this.rightDelay.delayTime.setValueAtTime(r,this.ac.currentTime),this._leftGain.gain.value=o,this._rightGain.gain.value=o,i&&(this._leftFilter.freq(i),this._rightFilter.freq(i))},p5.Delay.prototype.delayTime=function(t){"number"!=typeof t?(t.connect(this.leftDelay.delayTime),t.connect(this.rightDelay.delayTime)):(this.leftDelay.delayTime.cancelScheduledValues(this.ac.currentTime),this.rightDelay.delayTime.cancelScheduledValues(this.ac.currentTime),this.leftDelay.delayTime.linearRampToValueAtTime(t,this.ac.currentTime),this.rightDelay.delayTime.linearRampToValueAtTime(t,this.ac.currentTime))},p5.Delay.prototype.feedback=function(t){if(t&&"number"!=typeof t)t.connect(this._leftGain.gain),t.connect(this._rightGain.gain);else{if(1<=t)throw new Error("Feedback value will force a positive feedback loop.");"number"==typeof t&&(this._leftGain.gain.value=t,this._rightGain.gain.value=t)}return this._leftGain.gain.value},p5.Delay.prototype.filter=function(t,e){this._leftFilter.set(t,e),this._rightFilter.set(t,e)},p5.Delay.prototype.setType=function(t){switch(1===t&&(t="pingPong"),this._split.disconnect(),this._leftFilter.disconnect(),this._rightFilter.disconnect(),this._split.connect(this.leftDelay,0),this._split.connect(this.rightDelay,1),t){case"pingPong":this._rightFilter.setType(this._leftFilter.biquad.type),this._leftFilter.output.connect(this._merge,0,0),this._rightFilter.output.connect(this._merge,0,1),this._leftFilter.output.connect(this.rightDelay),this._rightFilter.output.connect(this.leftDelay);break;default:this._leftFilter.output.connect(this._merge,0,0),this._rightFilter.output.connect(this._merge,0,1),this._leftFilter.output.connect(this.leftDelay),this._rightFilter.output.connect(this.rightDelay)}},p5.Delay.prototype.dispose=function(){n.prototype.dispose.apply(this),this._split.disconnect(),this._leftFilter.dispose(),this._rightFilter.dispose(),this._merge.disconnect(),this._leftGain.disconnect(),this._rightGain.disconnect(),this.leftDelay.disconnect(),this.rightDelay.disconnect(),this._split=void 0,this._leftFilter=void 0,this._rightFilter=void 0,this._merge=void 0,this._leftGain=void 0,this._rightGain=void 0,this.leftDelay=void 0,this.rightDelay=void 0}}.call(e,i,e,t))||(t.exports=n)},function(t,e,n){"use strict";var i;void 0===(i=function(t){var p=n(11),e=n(4);p5.Reverb=function(){e.call(this),this._initConvolverNode(),this.input.gain.value=.5,this._seconds=3,this._decay=2,this._reverse=!1,this._buildImpulse()},p5.Reverb.prototype=Object.create(e.prototype),p5.Reverb.prototype._initConvolverNode=function(){this.convolverNode=this.ac.createConvolver(),this.input.connect(this.convolverNode),this.convolverNode.connect(this.wet)},p5.Reverb.prototype._teardownConvolverNode=function(){this.convolverNode&&(this.convolverNode.disconnect(),delete this.convolverNode)},p5.Reverb.prototype._setBuffer=function(t){this._teardownConvolverNode(),this._initConvolverNode(),this.convolverNode.buffer=t},p5.Reverb.prototype.process=function(t,e,n,i){t.connect(this.input);var o=!1;e&&(this._seconds=e,o=!0),n&&(this._decay=n),i&&(this._reverse=i),o&&this._buildImpulse()},p5.Reverb.prototype.set=function(t,e,n){var i=!1;t&&(this._seconds=t,i=!0),e&&(this._decay=e),n&&(this._reverse=n),i&&this._buildImpulse()},p5.Reverb.prototype._buildImpulse=function(){var t,e,n=this.ac.sampleRate,i=n*this._seconds,o=this._decay,r=this.ac.createBuffer(2,i,n),s=r.getChannelData(0),a=r.getChannelData(1);for(e=0;e=t.parts.length?(t.scoreStep=0,t.onended()):(t.scoreStep=0,t.parts[t.currentPart-1].stop(),t.parts[t.currentPart].start())}p5.prototype.setBPM=function(t,e){for(var n in o=t,i.parts)i.parts[n]&&i.parts[n].setBPM(t,e)},p5.Phrase=function(t,e,n){this.phraseStep=0,this.name=t,this.callback=e,this.sequence=n},p5.Part=function(t,e){this.length=t||0,this.partStep=0,this.phrases=[],this.isPlaying=!1,this.noLoop(),this.tatums=e||.0625,this.metro=new p5.Metro,this.metro._init(),this.metro.beatLength(this.tatums),this.metro.setBPM(o),i.parts.push(this),this.callback=function(){}},p5.Part.prototype.setBPM=function(t,e){this.metro.setBPM(t,e)},p5.Part.prototype.getBPM=function(){return this.metro.getBPM()},p5.Part.prototype.start=function(t){if(!this.isPlaying){this.isPlaying=!0,this.metro.resetSync(this);var e=t||0;this.metro.start(e)}},p5.Part.prototype.loop=function(t){this.looping=!0,this.onended=function(){this.partStep=0};var e=t||0;this.start(e)},p5.Part.prototype.noLoop=function(){this.looping=!1,this.onended=function(){this.stop()}},p5.Part.prototype.stop=function(t){this.partStep=0,this.pause(t)},p5.Part.prototype.pause=function(t){this.isPlaying=!1;var e=t||0;this.metro.stop(e)},p5.Part.prototype.addPhrase=function(t,e,n){var i;if(3===arguments.length)i=new p5.Phrase(t,e,n);else{if(!(t instanceof p5.Phrase))throw"invalid input. addPhrase accepts name, callback, array or a p5.Phrase";i=t}this.phrases.push(i),i.sequence.length>this.length&&(this.length=i.sequence.length)},p5.Part.prototype.removePhrase=function(t){for(var e in this.phrases)this.phrases[e].name===t&&this.phrases.splice(e,1)},p5.Part.prototype.getPhrase=function(t){for(var e in this.phrases)if(this.phrases[e].name===t)return this.phrases[e]},p5.Part.prototype.replaceSequence=function(t,e){for(var n in this.phrases)this.phrases[n].name===t&&(this.phrases[n].sequence=e)},p5.Part.prototype.incrementStep=function(t){this.partStepthis.cutoff&&e>this.threshold&&0 1){\n\t\t\tthis.input = new Array(inputs);\n\t\t}\n\n\t\t/**\n\t\t * the output node(s)\n\t\t * @type {GainNode|Array}\n\t\t */\n\t\tif (this.isUndef(outputs) || outputs === 1){\n\t\t\tthis.output = this.context.createGain();\n\t\t} else if (outputs > 1){\n\t\t\tthis.output = new Array(inputs);\n\t\t}\n\t};\n\n\t/**\n\t * Set the parameters at once. Either pass in an\n\t * object mapping parameters to values, or to set a\n\t * single parameter, by passing in a string and value.\n\t * The last argument is an optional ramp time which \n\t * will ramp any signal values to their destination value\n\t * over the duration of the rampTime.\n\t * @param {Object|string} params\n\t * @param {number=} value\n\t * @param {Time=} rampTime\n\t * @returns {Tone} this\n\t * @example\n\t * //set values using an object\n\t * filter.set({\n\t * \t\"frequency\" : 300,\n\t * \t\"type\" : highpass\n\t * });\n\t * @example\n\t * filter.set(\"type\", \"highpass\");\n\t * @example\n\t * //ramp to the value 220 over 3 seconds. \n\t * oscillator.set({\n\t * \t\"frequency\" : 220\n\t * }, 3);\n\t */\n\tTone.prototype.set = function(params, value, rampTime){\n\t\tif (this.isObject(params)){\n\t\t\trampTime = value;\n\t\t} else if (this.isString(params)){\n\t\t\tvar tmpObj = {};\n\t\t\ttmpObj[params] = value;\n\t\t\tparams = tmpObj;\n\t\t}\n\n\t\tparamLoop:\n\t\tfor (var attr in params){\n\t\t\tvalue = params[attr];\n\t\t\tvar parent = this;\n\t\t\tif (attr.indexOf(\".\") !== -1){\n\t\t\t\tvar attrSplit = attr.split(\".\");\n\t\t\t\tfor (var i = 0; i < attrSplit.length - 1; i++){\n\t\t\t\t\tparent = parent[attrSplit[i]];\n\t\t\t\t\tif (parent instanceof Tone) {\n\t\t\t\t\t\tattrSplit.splice(0,i+1);\n\t\t\t\t\t\tvar innerParam = attrSplit.join(\".\");\n\t\t\t\t\t\tparent.set(innerParam, value);\n\t\t\t\t\t\tcontinue paramLoop;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tattr = attrSplit[attrSplit.length - 1];\n\t\t\t}\n\t\t\tvar param = parent[attr];\n\t\t\tif (this.isUndef(param)){\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif ((Tone.Signal && param instanceof Tone.Signal) || \n\t\t\t\t\t(Tone.Param && param instanceof Tone.Param)){\n\t\t\t\tif (param.value !== value){\n\t\t\t\t\tif (this.isUndef(rampTime)){\n\t\t\t\t\t\tparam.value = value;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tparam.rampTo(value, rampTime);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else if (param instanceof AudioParam){\n\t\t\t\tif (param.value !== value){\n\t\t\t\t\tparam.value = value;\n\t\t\t\t}\t\t\t\t\n\t\t\t} else if (param instanceof Tone){\n\t\t\t\tparam.set(value);\n\t\t\t} else if (param !== value){\n\t\t\t\tparent[attr] = value;\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Get the object's attributes. Given no arguments get\n\t * will return all available object properties and their corresponding\n\t * values. Pass in a single attribute to retrieve or an array\n\t * of attributes. The attribute strings can also include a \".\"\n\t * to access deeper properties.\n\t * @example\n\t * osc.get();\n\t * //returns {\"type\" : \"sine\", \"frequency\" : 440, ...etc}\n\t * @example\n\t * osc.get(\"type\");\n\t * //returns { \"type\" : \"sine\"}\n\t * @example\n\t * //use dot notation to access deep properties\n\t * synth.get([\"envelope.attack\", \"envelope.release\"]);\n\t * //returns {\"envelope\" : {\"attack\" : 0.2, \"release\" : 0.4}}\n\t * @param {Array=|string|undefined} params the parameters to get, otherwise will return \n\t * \t\t\t\t\t all available.\n\t * @returns {Object}\n\t */\n\tTone.prototype.get = function(params){\n\t\tif (this.isUndef(params)){\n\t\t\tparams = this._collectDefaults(this.constructor);\n\t\t} else if (this.isString(params)){\n\t\t\tparams = [params];\n\t\t} \n\t\tvar ret = {};\n\t\tfor (var i = 0; i < params.length; i++){\n\t\t\tvar attr = params[i];\n\t\t\tvar parent = this;\n\t\t\tvar subRet = ret;\n\t\t\tif (attr.indexOf(\".\") !== -1){\n\t\t\t\tvar attrSplit = attr.split(\".\");\n\t\t\t\tfor (var j = 0; j < attrSplit.length - 1; j++){\n\t\t\t\t\tvar subAttr = attrSplit[j];\n\t\t\t\t\tsubRet[subAttr] = subRet[subAttr] || {};\n\t\t\t\t\tsubRet = subRet[subAttr];\n\t\t\t\t\tparent = parent[subAttr];\n\t\t\t\t}\n\t\t\t\tattr = attrSplit[attrSplit.length - 1];\n\t\t\t}\n\t\t\tvar param = parent[attr];\n\t\t\tif (this.isObject(params[attr])){\n\t\t\t\tsubRet[attr] = param.get();\n\t\t\t} else if (Tone.Signal && param instanceof Tone.Signal){\n\t\t\t\tsubRet[attr] = param.value;\n\t\t\t} else if (Tone.Param && param instanceof Tone.Param){\n\t\t\t\tsubRet[attr] = param.value;\n\t\t\t} else if (param instanceof AudioParam){\n\t\t\t\tsubRet[attr] = param.value;\n\t\t\t} else if (param instanceof Tone){\n\t\t\t\tsubRet[attr] = param.get();\n\t\t\t} else if (!this.isFunction(param) && !this.isUndef(param)){\n\t\t\t\tsubRet[attr] = param;\n\t\t\t} \n\t\t}\n\t\treturn ret;\n\t};\n\n\t/**\n\t * collect all of the default attributes in one\n\t * @private\n\t * @param {function} constr the constructor to find the defaults from\n\t * @return {Array} all of the attributes which belong to the class\n\t */\n\tTone.prototype._collectDefaults = function(constr){\n\t\tvar ret = [];\n\t\tif (!this.isUndef(constr.defaults)){\n\t\t\tret = Object.keys(constr.defaults);\n\t\t}\n\t\tif (!this.isUndef(constr._super)){\n\t\t\tvar superDefs = this._collectDefaults(constr._super);\n\t\t\t//filter out repeats\n\t\t\tfor (var i = 0; i < superDefs.length; i++){\n\t\t\t\tif (ret.indexOf(superDefs[i]) === -1){\n\t\t\t\t\tret.push(superDefs[i]);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn ret;\n\t};\n\n\t/**\n\t * @returns {string} returns the name of the class as a string\n\t */\n\tTone.prototype.toString = function(){\n\t\tfor (var className in Tone){\n\t\t\tvar isLetter = className[0].match(/^[A-Z]$/);\n\t\t\tvar sameConstructor = Tone[className] === this.constructor;\n\t\t\tif (this.isFunction(Tone[className]) && isLetter && sameConstructor){\n\t\t\t\treturn className;\n\t\t\t}\n\t\t}\n\t\treturn \"Tone\";\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tCLASS VARS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * The number of inputs feeding into the AudioNode. \n\t * For source nodes, this will be 0.\n\t * @memberOf Tone#\n\t * @name numberOfInputs\n\t * @readOnly\n\t */\n\tObject.defineProperty(Tone.prototype, \"numberOfInputs\", {\n\t\tget : function(){\n\t\t\tif (this.input){\n\t\t\t\tif (this.isArray(this.input)){\n\t\t\t\t\treturn this.input.length;\n\t\t\t\t} else {\n\t\t\t\t\treturn 1;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\treturn 0;\n\t\t\t}\n\t\t}\n\t});\n\n\t/**\n\t * The number of outputs coming out of the AudioNode. \n\t * For source nodes, this will be 0.\n\t * @memberOf Tone#\n\t * @name numberOfInputs\n\t * @readOnly\n\t */\n\tObject.defineProperty(Tone.prototype, \"numberOfOutputs\", {\n\t\tget : function(){\n\t\t\tif (this.output){\n\t\t\t\tif (this.isArray(this.output)){\n\t\t\t\t\treturn this.output.length;\n\t\t\t\t} else {\n\t\t\t\t\treturn 1;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\treturn 0;\n\t\t\t}\n\t\t}\n\t});\n\t\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tCONNECTIONS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * disconnect and dispose\n\t * @returns {Tone} this\n\t */\n\tTone.prototype.dispose = function(){\n\t\tif (!this.isUndef(this.input)){\n\t\t\tif (this.input instanceof AudioNode){\n\t\t\t\tthis.input.disconnect();\n\t\t\t} \n\t\t\tthis.input = null;\n\t\t}\n\t\tif (!this.isUndef(this.output)){\n\t\t\tif (this.output instanceof AudioNode){\n\t\t\t\tthis.output.disconnect();\n\t\t\t} \n\t\t\tthis.output = null;\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * connect the output of a ToneNode to an AudioParam, AudioNode, or ToneNode\n\t * @param {Tone | AudioParam | AudioNode} unit \n\t * @param {number} [outputNum=0] optionally which output to connect from\n\t * @param {number} [inputNum=0] optionally which input to connect to\n\t * @returns {Tone} this\n\t */\n\tTone.prototype.connect = function(unit, outputNum, inputNum){\n\t\tif (Array.isArray(this.output)){\n\t\t\toutputNum = this.defaultArg(outputNum, 0);\n\t\t\tthis.output[outputNum].connect(unit, 0, inputNum);\n\t\t} else {\n\t\t\tthis.output.connect(unit, outputNum, inputNum);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * disconnect the output\n\t * @param {Number|AudioNode} output Either the output index to disconnect\n\t * if the output is an array, or the\n\t * node to disconnect from.\n\t * @returns {Tone} this\n\t */\n\tTone.prototype.disconnect = function(destination, outputNum, inputNum){\n\t\tif (this.isArray(this.output)){\n\t\t\tif (this.isNumber(destination)){\n\t\t\t\tthis.output[destination].disconnect();\n\t\t\t} else {\n\t\t\t\toutputNum = this.defaultArg(outputNum, 0);\n\t\t\t\tthis.output[outputNum].disconnect(destination, 0, inputNum);\n\t\t\t}\n\t\t} else {\n\t\t\tthis.output.disconnect.apply(this.output, arguments);\n\t\t}\n\t};\n\n\t/**\n\t * connect together all of the arguments in series\n\t * @param {...AudioParam|Tone|AudioNode} nodes\n\t * @returns {Tone} this\n\t */\n\tTone.prototype.connectSeries = function(){\n\t\tif (arguments.length > 1){\n\t\t\tvar currentUnit = arguments[0];\n\t\t\tfor (var i = 1; i < arguments.length; i++){\n\t\t\t\tvar toUnit = arguments[i];\n\t\t\t\tcurrentUnit.connect(toUnit);\n\t\t\t\tcurrentUnit = toUnit;\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Connect the output of this node to the rest of the nodes in series.\n\t * @example\n\t * //connect a node to an effect, panVol and then to the master output\n\t * node.chain(effect, panVol, Tone.Master);\n\t * @param {...AudioParam|Tone|AudioNode} nodes\n\t * @returns {Tone} this\n\t */\n\tTone.prototype.chain = function(){\n\t\tif (arguments.length > 0){\n\t\t\tvar currentUnit = this;\n\t\t\tfor (var i = 0; i < arguments.length; i++){\n\t\t\t\tvar toUnit = arguments[i];\n\t\t\t\tcurrentUnit.connect(toUnit);\n\t\t\t\tcurrentUnit = toUnit;\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * connect the output of this node to the rest of the nodes in parallel.\n\t * @param {...AudioParam|Tone|AudioNode} nodes\n\t * @returns {Tone} this\n\t */\n\tTone.prototype.fan = function(){\n\t\tif (arguments.length > 0){\n\t\t\tfor (var i = 0; i < arguments.length; i++){\n\t\t\t\tthis.connect(arguments[i]);\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t};\n\n\t//give native nodes chain and fan methods\n\tAudioNode.prototype.chain = Tone.prototype.chain;\n\tAudioNode.prototype.fan = Tone.prototype.fan;\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tUTILITIES / HELPERS / MATHS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * If the `given` parameter is undefined, use the `fallback`. \n\t * If both `given` and `fallback` are object literals, it will\n\t * return a deep copy which includes all of the parameters from both \n\t * objects. If a parameter is undefined in given, it will return\n\t * the fallback property. \n\t *

\n\t * WARNING: if object is self referential, it will go into an an \n\t * infinite recursive loop.\n\t * \n\t * @param {*} given \n\t * @param {*} fallback \n\t * @return {*} \n\t */\n\tTone.prototype.defaultArg = function(given, fallback){\n\t\tif (this.isObject(given) && this.isObject(fallback)){\n\t\t\tvar ret = {};\n\t\t\t//make a deep copy of the given object\n\t\t\tfor (var givenProp in given) {\n\t\t\t\tret[givenProp] = this.defaultArg(fallback[givenProp], given[givenProp]);\n\t\t\t}\n\t\t\tfor (var fallbackProp in fallback) {\n\t\t\t\tret[fallbackProp] = this.defaultArg(given[fallbackProp], fallback[fallbackProp]);\n\t\t\t}\n\t\t\treturn ret;\n\t\t} else {\n\t\t\treturn this.isUndef(given) ? fallback : given;\n\t\t}\n\t};\n\n\t/**\n\t * returns the args as an options object with given arguments\n\t * mapped to the names provided. \n\t *\n\t * if the args given is an array containing only one object, it is assumed\n\t * that that's already the options object and will just return it. \n\t * \n\t * @param {Array} values the 'arguments' object of the function\n\t * @param {Array} keys the names of the arguments as they\n\t * should appear in the options object\n\t * @param {Object=} defaults optional defaults to mixin to the returned \n\t * options object \n\t * @return {Object} the options object with the names mapped to the arguments\n\t */\n\tTone.prototype.optionsObject = function(values, keys, defaults){\n\t\tvar options = {};\n\t\tif (values.length === 1 && this.isObject(values[0])){\n\t\t\toptions = values[0];\n\t\t} else {\n\t\t\tfor (var i = 0; i < keys.length; i++){\n\t\t\t\toptions[keys[i]] = values[i];\n\t\t\t}\n\t\t}\n\t\tif (!this.isUndef(defaults)){\n\t\t\treturn this.defaultArg(options, defaults);\n\t\t} else {\n\t\t\treturn options;\n\t\t}\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t// TYPE CHECKING\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * test if the arg is undefined\n\t * @param {*} arg the argument to test\n\t * @returns {boolean} true if the arg is undefined\n\t * @function\n\t */\n\tTone.prototype.isUndef = function(val){\n\t\treturn typeof val === \"undefined\";\n\t};\n\n\t/**\n\t * test if the arg is a function\n\t * @param {*} arg the argument to test\n\t * @returns {boolean} true if the arg is a function\n\t * @function\n\t */\n\tTone.prototype.isFunction = function(val){\n\t\treturn typeof val === \"function\";\n\t};\n\n\t/**\n\t * Test if the argument is a number.\n\t * @param {*} arg the argument to test\n\t * @returns {boolean} true if the arg is a number\n\t */\n\tTone.prototype.isNumber = function(arg){\n\t\treturn (typeof arg === \"number\");\n\t};\n\n\t/**\n\t * Test if the given argument is an object literal (i.e. `{}`);\n\t * @param {*} arg the argument to test\n\t * @returns {boolean} true if the arg is an object literal.\n\t */\n\tTone.prototype.isObject = function(arg){\n\t\treturn (Object.prototype.toString.call(arg) === \"[object Object]\" && arg.constructor === Object);\n\t};\n\n\t/**\n\t * Test if the argument is a boolean.\n\t * @param {*} arg the argument to test\n\t * @returns {boolean} true if the arg is a boolean\n\t */\n\tTone.prototype.isBoolean = function(arg){\n\t\treturn (typeof arg === \"boolean\");\n\t};\n\n\t/**\n\t * Test if the argument is an Array\n\t * @param {*} arg the argument to test\n\t * @returns {boolean} true if the arg is an array\n\t */\n\tTone.prototype.isArray = function(arg){\n\t\treturn (Array.isArray(arg));\n\t};\n\n\t/**\n\t * Test if the argument is a string.\n\t * @param {*} arg the argument to test\n\t * @returns {boolean} true if the arg is a string\n\t */\n\tTone.prototype.isString = function(arg){\n\t\treturn (typeof arg === \"string\");\n\t};\n\n \t/**\n\t * An empty function.\n\t * @static\n\t */\n\tTone.noOp = function(){};\n\n\t/**\n\t * Make the property not writable. Internal use only. \n\t * @private\n\t * @param {string} property the property to make not writable\n\t */\n\tTone.prototype._readOnly = function(property){\n\t\tif (Array.isArray(property)){\n\t\t\tfor (var i = 0; i < property.length; i++){\n\t\t\t\tthis._readOnly(property[i]);\n\t\t\t}\n\t\t} else {\n\t\t\tObject.defineProperty(this, property, { \n\t\t\t\twritable: false,\n\t\t\t\tenumerable : true,\n\t\t\t});\n\t\t}\n\t};\n\n\t/**\n\t * Make an attribute writeable. Interal use only. \n\t * @private\n\t * @param {string} property the property to make writable\n\t */\n\tTone.prototype._writable = function(property){\n\t\tif (Array.isArray(property)){\n\t\t\tfor (var i = 0; i < property.length; i++){\n\t\t\t\tthis._writable(property[i]);\n\t\t\t}\n\t\t} else {\n\t\t\tObject.defineProperty(this, property, { \n\t\t\t\twritable: true,\n\t\t\t});\n\t\t}\n\t};\n\n\t/**\n\t * Possible play states. \n\t * @enum {string}\n\t */\n\tTone.State = {\n\t\tStarted : \"started\",\n\t\tStopped : \"stopped\",\n\t\tPaused : \"paused\",\n \t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t// CONVERSIONS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Equal power gain scale. Good for cross-fading.\n\t * @param {NormalRange} percent (0-1)\n\t * @return {Number} output gain (0-1)\n\t */\n\tTone.prototype.equalPowerScale = function(percent){\n\t\tvar piFactor = 0.5 * Math.PI;\n\t\treturn Math.sin(percent * piFactor);\n\t};\n\n\t/**\n\t * Convert decibels into gain.\n\t * @param {Decibels} db\n\t * @return {Number} \n\t */\n\tTone.prototype.dbToGain = function(db) {\n\t\treturn Math.pow(2, db / 6);\n\t};\n\n\t/**\n\t * Convert gain to decibels.\n\t * @param {Number} gain (0-1)\n\t * @return {Decibels} \n\t */\n\tTone.prototype.gainToDb = function(gain) {\n\t\treturn 20 * (Math.log(gain) / Math.LN10);\n\t};\n\n\t/**\n\t * Convert an interval (in semitones) to a frequency ratio.\n\t * @param {Interval} interval the number of semitones above the base note\n\t * @return {number} the frequency ratio\n\t * @example\n\t * tone.intervalToFrequencyRatio(0); // 1\n\t * tone.intervalToFrequencyRatio(12); // 2\n\t * tone.intervalToFrequencyRatio(-12); // 0.5\n\t */\n\tTone.prototype.intervalToFrequencyRatio = function(interval){\n\t\treturn Math.pow(2,(interval/12));\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tTIMING\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Return the current time of the AudioContext clock.\n\t * @return {Number} the currentTime from the AudioContext\n\t */\n\tTone.prototype.now = function(){\n\t\treturn Tone.context.now();\n\t};\n\n\t/**\n\t * Return the current time of the AudioContext clock.\n\t * @return {Number} the currentTime from the AudioContext\n\t * @static\n\t */\n\tTone.now = function(){\n\t\treturn Tone.context.now();\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tINHERITANCE\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * have a child inherit all of Tone's (or a parent's) prototype\n\t * to inherit the parent's properties, make sure to call \n\t * Parent.call(this) in the child's constructor\n\t *\n\t * based on closure library's inherit function\n\t *\n\t * @static\n\t * @param {function} \tchild \n\t * @param {function=} parent (optional) parent to inherit from\n\t * if no parent is supplied, the child\n\t * will inherit from Tone\n\t */\n\tTone.extend = function(child, parent){\n\t\tif (Tone.prototype.isUndef(parent)){\n\t\t\tparent = Tone;\n\t\t}\n\t\tfunction TempConstructor(){}\n\t\tTempConstructor.prototype = parent.prototype;\n\t\tchild.prototype = new TempConstructor();\n\t\t/** @override */\n\t\tchild.prototype.constructor = child;\n\t\tchild._super = parent;\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tCONTEXT\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * The private audio context shared by all Tone Nodes. \n\t * @private\n\t * @type {Tone.Context|undefined}\n\t */\n\tvar audioContext;\n\n\t/**\n\t * A static pointer to the audio context accessible as Tone.context. \n\t * @type {Tone.Context}\n\t * @name context\n\t * @memberOf Tone\n\t */\n\tObject.defineProperty(Tone, \"context\", {\n\t\tget : function(){\n\t\t\treturn audioContext;\n\t\t},\n\t\tset : function(context){\n\t\t\tif (Tone.Context && context instanceof Tone.Context){\n\t\t\t\taudioContext = context;\n\t\t\t} else {\n\t\t\t\taudioContext = new Tone.Context(context);\n\t\t\t}\n\t\t\t//initialize the new audio context\n\t\t\tif (Tone.Context){\n\t\t\t\tTone.Context.emit(\"init\", audioContext);\n\t\t\t}\n\t\t}\n\t});\n\n\t/**\n\t * The AudioContext\n\t * @type {Tone.Context}\n\t * @name context\n\t * @memberOf Tone#\n\t * @readOnly\n\t */\n\tObject.defineProperty(Tone.prototype, \"context\", {\n\t\tget : function(){\n\t\t\treturn Tone.context;\n\t\t}\n\t});\n\n\t/**\n\t * Tone automatically creates a context on init, but if you are working\n\t * with other libraries which also create an AudioContext, it can be\n\t * useful to set your own. If you are going to set your own context, \n\t * be sure to do it at the start of your code, before creating any objects.\n\t * @static\n\t * @param {AudioContext} ctx The new audio context to set\n\t */\n\tTone.setContext = function(ctx){\n\t\tTone.context = ctx;\n\t};\n\n\t/**\n\t * The number of seconds of 1 processing block (128 samples)\n\t * @type {Number}\n\t * @name blockTime\n\t * @memberOf Tone#\n\t * @readOnly\n\t */\n\tObject.defineProperty(Tone.prototype, \"blockTime\", {\n\t\tget : function(){\n\t\t\treturn 128 / this.context.sampleRate;\n\t\t}\n\t});\n\n\t/**\n\t * The duration in seconds of one sample.\n\t * @type {Number}\n\t * @name sampleTime\n\t * @memberOf Tone#\n\t * @readOnly\n\t */\n\tObject.defineProperty(Tone.prototype, \"sampleTime\", {\n\t\tget : function(){\n\t\t\treturn 1 / this.context.sampleRate;\n\t\t}\n\t});\n\n\t/**\n\t * Whether or not all the technologies that Tone.js relies on are supported by the current browser. \n\t * @type {Boolean}\n\t * @name supported\n\t * @memberOf Tone\n\t * @readOnly\n\t */\n\tObject.defineProperty(Tone, \"supported\", {\n\t\tget : function(){\n\t\t\tvar hasAudioContext = window.hasOwnProperty(\"AudioContext\") || window.hasOwnProperty(\"webkitAudioContext\");\n\t\t\tvar hasPromises = window.hasOwnProperty(\"Promise\");\n\t\t\tvar hasWorkers = window.hasOwnProperty(\"Worker\");\n\t\t\treturn hasAudioContext && hasPromises && hasWorkers;\n\t\t}\n\t});\n\n\tTone.version = \"r10\";\n\n\t// allow optional silencing of this log\n\tif (!window.TONE_SILENCE_VERSION_LOGGING) {\n\t\tconsole.log(\"%c * Tone.js \" + Tone.version + \" * \", \"background: #000; color: #fff\");\n\t}\n\n\treturn Tone;\n});\n","'use strict';\n\n\ndefine(['audiocontext'], function (audiocontext) {\n // Master contains the master sound output.\n var Master = function() {\n this.input = audiocontext.createGain();\n this.output = audiocontext.createGain();\n\n //put a hard limiter on the output\n this.limiter = audiocontext.createDynamicsCompressor();\n this.limiter.threshold.value = -3;\n this.limiter.ratio.value = 20;\n this.limiter.knee.value = 1;\n\n this.audiocontext = audiocontext;\n\n this.output.disconnect();\n\n // connect input to limiter\n this.input.connect(this.limiter);\n\n // connect limiter to output\n this.limiter.connect(this.output);\n\n // meter is just for global Amplitude / FFT analysis\n this.meter = audiocontext.createGain();\n this.fftMeter = audiocontext.createGain();\n this.output.connect(this.meter);\n this.output.connect(this.fftMeter);\n\n // connect output to destination\n this.output.connect(this.audiocontext.destination);\n\n // an array of all sounds in the sketch\n this.soundArray = [];\n // an array of all musical parts in the sketch\n this.parts = [];\n\n // file extensions to search for\n this.extensions = [];\n };\n\n // create a single instance of the p5Sound / master output for use within this sketch\n var p5sound = new Master();\n\n /**\n * Returns a number representing the master amplitude (volume) for sound\n * in this sketch.\n *\n * @method getMasterVolume\n * @return {Number} Master amplitude (volume) for sound in this sketch.\n * Should be between 0.0 (silence) and 1.0.\n */\n p5.prototype.getMasterVolume = function() {\n return p5sound.output.gain.value;\n };\n\n /**\n *

Scale the output of all sound in this sketch

\n * Scaled between 0.0 (silence) and 1.0 (full volume).\n * 1.0 is the maximum amplitude of a digital sound, so multiplying\n * by greater than 1.0 may cause digital distortion. To\n * fade, provide a rampTime parameter. For more\n * complex fades, see the Envelope class.\n *\n * Alternately, you can pass in a signal source such as an\n * oscillator to modulate the amplitude with an audio signal.\n *\n *

How This Works: When you load the p5.sound module, it\n * creates a single instance of p5sound. All sound objects in this\n * module output to p5sound before reaching your computer's output.\n * So if you change the amplitude of p5sound, it impacts all of the\n * sound in this module.

\n *\n *

If no value is provided, returns a Web Audio API Gain Node

\n *\n * @method masterVolume\n * @param {Number|Object} volume Volume (amplitude) between 0.0\n * and 1.0 or modulating signal/oscillator\n * @param {Number} [rampTime] Fade for t seconds\n * @param {Number} [timeFromNow] Schedule this event to happen at\n * t seconds in the future\n */\n p5.prototype.masterVolume = function(vol, rampTime, tFromNow) {\n if (typeof vol === 'number') {\n var rampTime = rampTime || 0;\n var tFromNow = tFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n var currentVol = p5sound.output.gain.value;\n p5sound.output.gain.cancelScheduledValues(now + tFromNow);\n p5sound.output.gain.linearRampToValueAtTime(currentVol, now + tFromNow);\n p5sound.output.gain.linearRampToValueAtTime(vol, now + tFromNow + rampTime);\n }\n else if (vol) {\n vol.connect(p5sound.output.gain);\n } else {\n // return the Gain Node\n return p5sound.output.gain;\n }\n };\n\n /**\n * `p5.soundOut` is the p5.sound master output. It sends output to\n * the destination of this window's web audio context. It contains\n * Web Audio API nodes including a dyanmicsCompressor (.limiter),\n * and Gain Nodes for .input and .output.\n *\n * @property {Object} soundOut\n */\n p5.prototype.soundOut = p5.soundOut = p5sound;\n\n // a silent connection to the DesinationNode\n // which will ensure that anything connected to it\n // will not be garbage collected\n p5.soundOut._silentNode = p5sound.audiocontext.createGain();\n p5.soundOut._silentNode.gain.value = 0;\n p5.soundOut._silentNode.connect(p5sound.audiocontext.destination);\n\n\n return p5sound;\n});\n","define([\"Tone/core/Tone\", \"Tone/signal/WaveShaper\", \"Tone/type/Type\", \"Tone/core/Param\", \"Tone/core/Gain\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class A signal is an audio-rate value. Tone.Signal is a core component of the library.\n\t * Unlike a number, Signals can be scheduled with sample-level accuracy. Tone.Signal\n\t * has all of the methods available to native Web Audio \n\t * [AudioParam](http://webaudio.github.io/web-audio-api/#the-audioparam-interface)\n\t * as well as additional conveniences. Read more about working with signals \n\t * [here](https://github.com/Tonejs/Tone.js/wiki/Signals).\n\t *\n\t * @constructor\n\t * @extends {Tone.Param}\n\t * @param {Number|AudioParam} [value] Initial value of the signal. If an AudioParam\n\t * is passed in, that parameter will be wrapped\n\t * and controlled by the Signal. \n\t * @param {string} [units=Number] unit The units the signal is in. \n\t * @example\n\t * var signal = new Tone.Signal(10);\n\t */\n\tTone.Signal = function(){\n\n\t\tvar options = this.optionsObject(arguments, [\"value\", \"units\"], Tone.Signal.defaults);\n\n\t\t/**\n\t\t * The node where the constant signal value is scaled.\n\t\t * @type {GainNode}\n\t\t * @private\n\t\t */\n\t\tthis.output = this._gain = this.context.createGain();\n\n\t\toptions.param = this._gain.gain;\n\t\tTone.Param.call(this, options);\n\n\t\t/**\n\t\t * The node where the value is set.\n\t\t * @type {Tone.Param}\n\t\t * @private\n\t\t */\n\t\tthis.input = this._param = this._gain.gain;\n\n\t\t//connect the const output to the node output\n\t\tthis.context.getConstant(1).chain(this._gain);\n\t};\n\n\tTone.extend(Tone.Signal, Tone.Param);\n\n\t/**\n\t * The default values\n\t * @type {Object}\n\t * @static\n\t * @const\n\t */\n\tTone.Signal.defaults = {\n\t\t\"value\" : 0,\n\t\t\"units\" : Tone.Type.Default,\n\t\t\"convert\" : true,\n\t};\n\n\t/**\n\t * When signals connect to other signals or AudioParams, \n\t * they take over the output value of that signal or AudioParam. \n\t * For all other nodes, the behavior is the same as a default connect. \n\t *\n\t * @override\n\t * @param {AudioParam|AudioNode|Tone.Signal|Tone} node \n\t * @param {number} [outputNumber=0] The output number to connect from.\n\t * @param {number} [inputNumber=0] The input number to connect to.\n\t * @returns {Tone.SignalBase} this\n\t * @method\n\t */\n\tTone.Signal.prototype.connect = Tone.SignalBase.prototype.connect;\n\n\t/**\n\t * dispose and disconnect\n\t * @returns {Tone.Signal} this\n\t */\n\tTone.Signal.prototype.dispose = function(){\n\t\tTone.Param.prototype.dispose.call(this);\n\t\tthis._param = null;\n\t\tthis._gain.disconnect();\n\t\tthis._gain = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.Signal;\n});","define([\"Tone/core/Tone\", \"Tone/signal/Signal\", \"Tone/core/Gain\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Multiply two incoming signals. Or, if a number is given in the constructor, \n\t * multiplies the incoming signal by that value. \n\t *\n\t * @constructor\n\t * @extends {Tone.Signal}\n\t * @param {number=} value Constant value to multiple. If no value is provided,\n\t * it will return the product of the first and second inputs\n\t * @example\n\t * var mult = new Tone.Multiply();\n\t * var sigA = new Tone.Signal(3);\n\t * var sigB = new Tone.Signal(4);\n\t * sigA.connect(mult, 0, 0);\n\t * sigB.connect(mult, 0, 1);\n\t * //output of mult is 12.\n\t * @example\n\t * var mult = new Tone.Multiply(10);\n\t * var sig = new Tone.Signal(2).connect(mult);\n\t * //the output of mult is 20. \n\t */\n\tTone.Multiply = function(value){\n\n\t\tthis.createInsOuts(2, 0);\n\n\t\t/**\n\t\t * the input node is the same as the output node\n\t\t * it is also the GainNode which handles the scaling of incoming signal\n\t\t * \n\t\t * @type {GainNode}\n\t\t * @private\n\t\t */\n\t\tthis._mult = this.input[0] = this.output = new Tone.Gain();\n\n\t\t/**\n\t\t * the scaling parameter\n\t\t * @type {AudioParam}\n\t\t * @private\n\t\t */\n\t\tthis._param = this.input[1] = this.output.gain;\n\t\t\n\t\tthis._param.value = this.defaultArg(value, 0);\n\t};\n\n\tTone.extend(Tone.Multiply, Tone.Signal);\n\n\t/**\n\t * clean up\n\t * @returns {Tone.Multiply} this\n\t */\n\tTone.Multiply.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._mult.dispose();\n\t\tthis._mult = null;\n\t\tthis._param = null;\n\t\treturn this;\n\t}; \n\n\treturn Tone.Multiply;\n});\n","'use strict';\ndefine(function (require) {\n\n var p5sound = require('master');\n var CrossFade = require('Tone/component/CrossFade');\n\n /**\n * Effect is a base class for audio effects in p5.
\n * This module handles the nodes and methods that are\n * common and useful for current and future effects.\n *\n *\n * This class is extended by p5.Distortion,\n * p5.Compressor,\n * p5.Delay,\n * p5.Filter,\n * p5.Reverb.\n *\n * @class p5.Effect\n * @constructor\n *\n * @param {Object} [ac] Reference to the audio context of the p5 object\n * @param {AudioNode} [input] Gain Node effect wrapper\n * @param {AudioNode} [output] Gain Node effect wrapper\n * @param {Object} [_drywet] Tone.JS CrossFade node (defaults to value: 1)\n * @param {AudioNode} [wet] Effects that extend this class should connect\n * to the wet signal to this gain node, so that dry and wet\n * signals are mixed properly.\n */\n p5.Effect = function() {\n this.ac = p5sound.audiocontext;\n\n this.input = this.ac.createGain();\n this.output = this.ac.createGain();\n\n /**\n *\tThe p5.Effect class is built\n * \tusing Tone.js CrossFade\n * \t@private\n */\n\n this._drywet = new CrossFade(1);\n\n /**\n *\tIn classes that extend\n *\tp5.Effect, connect effect nodes\n *\tto the wet parameter\n */\n this.wet = this.ac.createGain();\n\n this.input.connect(this._drywet.a);\n this.wet.connect(this._drywet.b);\n this._drywet.connect(this.output);\n\n this.connect();\n\n //Add to the soundArray\n p5sound.soundArray.push(this);\n };\n\n /**\n * Set the output volume of the filter.\n *\n * @method amp\n * @for p5.Effect\n * @param {Number} [vol] amplitude between 0 and 1.0\n * @param {Number} [rampTime] create a fade that lasts until rampTime\n * @param {Number} [tFromNow] schedule this event to happen in tFromNow seconds\n */\n p5.Effect.prototype.amp = function(vol, rampTime, tFromNow){\n var rampTime = rampTime || 0;\n var tFromNow = tFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n var currentVol = this.output.gain.value;\n this.output.gain.cancelScheduledValues(now);\n this.output.gain.linearRampToValueAtTime(currentVol, now + tFromNow + .001);\n this.output.gain.linearRampToValueAtTime(vol, now + tFromNow + rampTime + .001);\n };\n\n /**\n * Link effects together in a chain\n * Example usage: filter.chain(reverb, delay, panner);\n * May be used with an open-ended number of arguments\n *\n * @method chain\n * @for p5.Effect\n * @param {Object} [arguments] Chain together multiple sound objects\n */\n p5.Effect.prototype.chain = function(){\n if (arguments.length>0){\n this.connect(arguments[0]);\n for(var i=1;i\n * let midiNotes = [60, 64, 67, 72];\n * let noteIndex = 0;\n * let midiVal, freq;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(startSound);\n * osc = new p5.TriOsc();\n * env = new p5.Envelope();\n * }\n *\n * function draw() {\n * background(220);\n * text('tap to play', 10, 20);\n * if (midiVal) {\n * text('MIDI: ' + midiVal, 10, 40);\n * text('Freq: ' + freq, 10, 60);\n * }\n * }\n *\n * function startSound() {\n * // see also: userStartAudio();\n * osc.start();\n *\n * midiVal = midiNotes[noteIndex % midiNotes.length];\n * freq = midiToFreq(midiVal);\n * osc.freq(freq);\n * env.ramp(osc, 0, 1.0, 0);\n *\n * noteIndex++;\n * }\n * \n */\n var midiToFreq = p5.prototype.midiToFreq = function(m) {\n return 440 * Math.pow(2, (m-69)/12.0);\n };\n\n // This method converts ANSI notes specified as a string \"C4\", \"Eb3\" to a frequency\n var noteToFreq = function(note) {\n if (typeof note !== 'string') {\n return note;\n }\n var wholeNotes = {A:21, B:23, C:24, D:26, E:28, F:29, G:31};\n var value = wholeNotes[ note[0].toUpperCase() ];\n var octave = ~~note.slice(-1);\n value += 12 * (octave -1);\n\n switch(note[1]) {\n case '#':\n value += 1;\n break;\n case 'b':\n value -= 1;\n break;\n default:\n break;\n }\n return midiToFreq(value);\n };\n\n /**\n * List the SoundFile formats that you will include. LoadSound\n * will search your directory for these extensions, and will pick\n * a format that is compatable with the client's web browser.\n * Here is a free online file\n * converter.\n *\n * @method soundFormats\n * @param {String} [...formats] i.e. 'mp3', 'wav', 'ogg'\n * @example\n *
\n * function preload() {\n * // set the global sound formats\n * soundFormats('mp3', 'ogg');\n *\n * // load either beatbox.mp3, or .ogg, depending on browser\n * mySound = loadSound('assets/beatbox.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * background(220);\n * text('sound loaded! tap to play', 10, 20, width - 20);\n * cnv.mousePressed(function() {\n * mySound.play();\n * });\n * }\n *
\n */\n p5.prototype.soundFormats = function() {\n // reset extensions array\n p5sound.extensions = [];\n // add extensions\n for (var i = 0; i < arguments.length; i++) {\n arguments[i] = arguments[i].toLowerCase();\n if (['mp3','wav','ogg', 'm4a', 'aac'].indexOf(arguments[i]) > -1) {\n p5sound.extensions.push(arguments[i]);\n } else {\n throw arguments[i] + ' is not a valid sound format!';\n }\n }\n };\n\n p5.prototype.disposeSound = function() {\n for (var i = 0; i < p5sound.soundArray.length; i++) {\n p5sound.soundArray[i].dispose();\n }\n };\n\n // register removeSound to dispose of p5sound SoundFiles, Convolvers,\n // Oscillators etc when sketch ends\n p5.prototype.registerMethod('remove', p5.prototype.disposeSound);\n\n p5.prototype._checkFileFormats = function(paths) {\n var path;\n // if path is a single string, check to see if extension is provided\n if (typeof paths === 'string') {\n path = paths;\n // see if extension is provided\n var extTest = path.split('.').pop();\n // if an extension is provided...\n if (['mp3','wav','ogg', 'm4a', 'aac'].indexOf(extTest) > -1) {\n if (p5.prototype.isFileSupported(extTest)) {\n path = path;\n }\n else {\n var pathSplit = path.split('.');\n var pathCore = pathSplit[pathSplit.length - 1];\n for (var i = 0; i 1) {\n rightChannel = audioBuffer.getChannelData(1);\n } else {\n rightChannel = leftChannel;\n }\n\n var interleaved = interleave(leftChannel, rightChannel);\n\n // create the buffer and view to create the .WAV file\n var buffer = new window.ArrayBuffer(44 + interleaved.length * 2);\n var view = new window.DataView(buffer);\n\n // write the WAV container,\n // check spec at: https://web.archive.org/web/20171215131933/http://tiny.systems/software/soundProgrammer/WavFormatDocs.pdf\n\n // RIFF chunk descriptor\n writeUTFBytes(view, 0, 'RIFF');\n view.setUint32(4, 36 + interleaved.length * 2, true);\n writeUTFBytes(view, 8, 'WAVE');\n // FMT sub-chunk\n writeUTFBytes(view, 12, 'fmt ');\n view.setUint32(16, 16, true);\n view.setUint16(20, 1, true);\n // stereo (2 channels)\n view.setUint16(22, 2, true);\n view.setUint32(24, p5sound.audiocontext.sampleRate, true);\n view.setUint32(28, p5sound.audiocontext.sampleRate * 4, true);\n view.setUint16(32, 4, true);\n view.setUint16(34, 16, true);\n // data sub-chunk\n writeUTFBytes(view, 36, 'data');\n view.setUint32(40, interleaved.length * 2, true);\n\n // write the PCM samples\n var lng = interleaved.length;\n var index = 44;\n var volume = 1;\n for (var i = 0; i < lng; i++) {\n view.setInt16(index, interleaved[i] * (0x7FFF * volume), true);\n index += 2;\n }\n\n return view;\n }\n\n // helper methods to save waves\n function interleave(leftChannel, rightChannel) {\n var length = leftChannel.length + rightChannel.length;\n var result = new Float32Array(length);\n\n var inputIndex = 0;\n\n for (var index = 0; index < length;) {\n result[index++] = leftChannel[inputIndex];\n result[index++] = rightChannel[inputIndex];\n inputIndex++;\n }\n return result;\n }\n\n function writeUTFBytes(view, offset, string) {\n var lng = string.length;\n for (var i = 0; i < lng; i++) {\n view.setUint8(offset + i, string.charCodeAt(i));\n }\n }\n\n function safeBufferSize(idealBufferSize) {\n let bufferSize = idealBufferSize;\n\n // if the AudioWorkletNode is actually a ScriptProcessorNode created via polyfill,\n // make sure that our chosen buffer size isn't smaller than the buffer size automatically\n // selected by the polyfill\n // reference: https://github.com/GoogleChromeLabs/audioworklet-polyfill/issues/13#issuecomment-425014930\n let tempAudioWorkletNode = new AudioWorkletNode(p5sound.audiocontext, processorNames.soundFileProcessor);\n if (tempAudioWorkletNode instanceof ScriptProcessorNode) {\n bufferSize = tempAudioWorkletNode.bufferSize;\n }\n tempAudioWorkletNode.disconnect();\n tempAudioWorkletNode = null;\n\n return bufferSize;\n }\n\n return {\n convertToWav: convertToWav,\n midiToFreq: midiToFreq,\n noteToFreq: noteToFreq,\n safeBufferSize: safeBufferSize\n };\n\n});\n","define([\"Tone/core/Tone\", \"Tone/signal/Signal\", \"Tone/core/Gain\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Add a signal and a number or two signals. When no value is\n\t * passed into the constructor, Tone.Add will sum input[0]\n\t * and input[1]. If a value is passed into the constructor, \n\t * the it will be added to the input.\n\t * \n\t * @constructor\n\t * @extends {Tone.Signal}\n\t * @param {number=} value If no value is provided, Tone.Add will sum the first\n\t * and second inputs. \n\t * @example\n\t * var signal = new Tone.Signal(2);\n\t * var add = new Tone.Add(2);\n\t * signal.connect(add);\n\t * //the output of add equals 4\n\t * @example\n\t * //if constructed with no arguments\n\t * //it will add the first and second inputs\n\t * var add = new Tone.Add();\n\t * var sig0 = new Tone.Signal(3).connect(add, 0, 0);\n\t * var sig1 = new Tone.Signal(4).connect(add, 0, 1);\n\t * //the output of add equals 7. \n\t */\n\tTone.Add = function(value){\n\n\t\tthis.createInsOuts(2, 0);\n\n\t\t/**\n\t\t * the summing node\n\t\t * @type {GainNode}\n\t\t * @private\n\t\t */\n\t\tthis._sum = this.input[0] = this.input[1] = this.output = new Tone.Gain();\n\n\t\t/**\n\t\t * @private\n\t\t * @type {Tone.Signal}\n\t\t */\n\t\tthis._param = this.input[1] = new Tone.Signal(value);\n\n\t\tthis._param.connect(this._sum);\n\t};\n\n\tTone.extend(Tone.Add, Tone.Signal);\n\t\n\t/**\n\t * Clean up.\n\t * @returns {Tone.Add} this\n\t */\n\tTone.Add.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._sum.dispose();\n\t\tthis._sum = null;\n\t\tthis._param.dispose();\n\t\tthis._param = null;\n\t\treturn this;\n\t}; \n\n\treturn Tone.Add;\n});","define([\"Tone/core/Tone\", \"Tone/type/Time\", \"Tone/type/Frequency\", \"Tone/type/TransportTime\", \"Tone/core/Context\"],\nfunction (Tone) {\t\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tTYPES\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Units which a value can take on.\n\t * @enum {String}\n\t */\n\tTone.Type = {\n\t\t/** \n\t\t * Default units\n\t\t * @typedef {Default}\n\t\t */\n\t\tDefault : \"number\",\n\t\t/**\n\t\t * Time can be described in a number of ways. Read more [Time](https://github.com/Tonejs/Tone.js/wiki/Time).\n\t\t *\n\t\t *
    \n\t\t *
  • Numbers, which will be taken literally as the time (in seconds).
    • \n\t\t *
  • Notation, (\"4n\", \"8t\") describes time in BPM and time signature relative values.
    • \n\t\t *
  • TransportTime, (\"4:3:2\") will also provide tempo and time signature relative times \n\t\t * in the form BARS:QUARTERS:SIXTEENTHS.
    • \n\t\t *
  • Frequency, (\"8hz\") is converted to the length of the cycle in seconds.
    • \n\t\t *
  • Now-Relative, (\"+1\") prefix any of the above with \"+\" and it will be interpreted as \n\t\t * \"the current time plus whatever expression follows\".
    • \n\t\t *
  • Expressions, (\"3:0 + 2 - (1m / 7)\") any of the above can also be combined \n\t\t * into a mathematical expression which will be evaluated to compute the desired time.
    • \n\t\t *
  • No Argument, for methods which accept time, no argument will be interpreted as \n\t\t * \"now\" (i.e. the currentTime).
    • \n\t\t *
\n\t\t * \n\t\t * @typedef {Time}\n\t\t */\n\t\tTime : \"time\",\n\t\t/**\n\t\t * Frequency can be described similar to time, except ultimately the\n\t\t * values are converted to frequency instead of seconds. A number\n\t\t * is taken literally as the value in hertz. Additionally any of the \n\t\t * Time encodings can be used. Note names in the form\n\t\t * of NOTE OCTAVE (i.e. C4) are also accepted and converted to their\n\t\t * frequency value. \n\t\t * @typedef {Frequency}\n\t\t */\n\t\tFrequency : \"frequency\",\n\t\t/**\n\t\t * TransportTime describes a position along the Transport's timeline. It is\n\t\t * similar to Time in that it uses all the same encodings, but TransportTime specifically\n\t\t * pertains to the Transport's timeline, which is startable, stoppable, loopable, and seekable. \n\t\t * [Read more](https://github.com/Tonejs/Tone.js/wiki/TransportTime)\n\t\t * @typedef {TransportTime}\n\t\t */\n\t\tTransportTime : \"transportTime\",\n\t\t/** \n\t\t * Ticks are the basic subunit of the Transport. They are\n\t\t * the smallest unit of time that the Transport supports.\n\t\t * @typedef {Ticks}\n\t\t */\n\t\tTicks : \"ticks\",\n\t\t/** \n\t\t * Normal values are within the range [0, 1].\n\t\t * @typedef {NormalRange}\n\t\t */\n\t\tNormalRange : \"normalRange\",\n\t\t/** \n\t\t * AudioRange values are between [-1, 1].\n\t\t * @typedef {AudioRange}\n\t\t */\n\t\tAudioRange : \"audioRange\",\n\t\t/** \n\t\t * Decibels are a logarithmic unit of measurement which is useful for volume\n\t\t * because of the logarithmic way that we perceive loudness. 0 decibels \n\t\t * means no change in volume. -10db is approximately half as loud and 10db \n\t\t * is twice is loud. \n\t\t * @typedef {Decibels}\n\t\t */\n\t\tDecibels : \"db\",\n\t\t/** \n\t\t * Half-step note increments, i.e. 12 is an octave above the root. and 1 is a half-step up.\n\t\t * @typedef {Interval}\n\t\t */\n\t\tInterval : \"interval\",\n\t\t/** \n\t\t * Beats per minute. \n\t\t * @typedef {BPM}\n\t\t */\n\t\tBPM : \"bpm\",\n\t\t/** \n\t\t * The value must be greater than or equal to 0.\n\t\t * @typedef {Positive}\n\t\t */\n\t\tPositive : \"positive\",\n\t\t/** \n\t\t * A cent is a hundredth of a semitone. \n\t\t * @typedef {Cents}\n\t\t */\n\t\tCents : \"cents\",\n\t\t/** \n\t\t * Angle between 0 and 360. \n\t\t * @typedef {Degrees}\n\t\t */\n\t\tDegrees : \"degrees\",\n\t\t/** \n\t\t * A number representing a midi note.\n\t\t * @typedef {MIDI}\n\t\t */\n\t\tMIDI : \"midi\",\n\t\t/** \n\t\t * A colon-separated representation of time in the form of\n\t\t * Bars:Beats:Sixteenths. \n\t\t * @typedef {BarsBeatsSixteenths}\n\t\t */\n\t\tBarsBeatsSixteenths : \"barsBeatsSixteenths\",\n\t\t/** \n\t\t * Sampling is the reduction of a continuous signal to a discrete signal.\n\t\t * Audio is typically sampled 44100 times per second. \n\t\t * @typedef {Samples}\n\t\t */\n\t\tSamples : \"samples\",\n\t\t/** \n\t\t * Hertz are a frequency representation defined as one cycle per second.\n\t\t * @typedef {Hertz}\n\t\t */\n\t\tHertz : \"hertz\",\n\t\t/** \n\t\t * A frequency represented by a letter name, \n\t\t * accidental and octave. This system is known as\n\t\t * [Scientific Pitch Notation](https://en.wikipedia.org/wiki/Scientific_pitch_notation).\n\t\t * @typedef {Note}\n\t\t */\n\t\tNote : \"note\",\n\t\t/** \n\t\t * One millisecond is a thousandth of a second. \n\t\t * @typedef {Milliseconds}\n\t\t */\n\t\tMilliseconds : \"milliseconds\",\n\t\t/** \n\t\t * Seconds are the time unit of the AudioContext. In the end, \n\t\t * all values need to be evaluated to seconds. \n\t\t * @typedef {Seconds}\n\t\t */\n\t\tSeconds : \"seconds\",\n\t\t/** \n\t\t * A string representing a duration relative to a measure. \n\t\t *
    \n\t\t * \t
  • \"4n\" = quarter note
    • \n\t\t * \t
  • \"2m\" = two measures
    • \n\t\t * \t
  • \"8t\" = eighth-note triplet
    • \n\t\t *
\n\t\t * @typedef {Notation}\n\t\t */\n\t\tNotation : \"notation\",\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t// AUGMENT TONE's PROTOTYPE\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Convert Time into seconds.\n\t * \n\t * Unlike the method which it overrides, this takes into account \n\t * transporttime and musical notation.\n\t *\n\t * Time : 1.40\n\t * Notation: 4n|1m|2t\n\t * Now Relative: +3n\n\t * Math: 3n+16n or even complicated expressions ((3n*2)/6 + 1)\n\t *\n\t * @param {Time} time \n\t * @return {Seconds} \n\t */\n\tTone.prototype.toSeconds = function(time){\n\t\tif (this.isNumber(time)){\n\t\t\treturn time;\n\t\t} else if (this.isUndef(time)){\n\t\t\treturn this.now();\t\t\t\n\t\t} else if (this.isString(time)){\n\t\t\treturn (new Tone.Time(time)).toSeconds();\n\t\t} else if (time instanceof Tone.TimeBase){\n\t\t\treturn time.toSeconds();\n\t\t}\n\t};\n\n\t/**\n\t * Convert a frequency representation into a number.\n\t * @param {Frequency} freq \n\t * @return {Hertz} the frequency in hertz\n\t */\n\tTone.prototype.toFrequency = function(freq){\n\t\tif (this.isNumber(freq)){\n\t\t\treturn freq;\n\t\t} else if (this.isString(freq) || this.isUndef(freq)){\n\t\t\treturn (new Tone.Frequency(freq)).valueOf();\n\t\t} else if (freq instanceof Tone.TimeBase){\n\t\t\treturn freq.toFrequency();\n\t\t}\n\t};\n\n\t/**\n\t * Convert a time representation into ticks.\n\t * @param {Time} time\n\t * @return {Ticks} the time in ticks\n\t */\n\tTone.prototype.toTicks = function(time){\n\t\tif (this.isNumber(time) || this.isString(time)){\n\t\t\treturn (new Tone.TransportTime(time)).toTicks();\n\t\t} else if (this.isUndef(time)){\n\t\t\treturn Tone.Transport.ticks;\t\t\t\n\t\t} else if (time instanceof Tone.TimeBase){\n\t\t\treturn time.toTicks();\n\t\t}\n\t};\n\n\treturn Tone;\n});","define([\"Tone/core/Tone\", \"Tone/core/Param\", \"Tone/type/Type\"], function (Tone) {\n\n\t\"use strict\";\n\n\t/**\n\t * createGain shim\n\t * @private\n\t */\n\tif (window.GainNode && !AudioContext.prototype.createGain){\n\t\tAudioContext.prototype.createGain = AudioContext.prototype.createGainNode;\n\t}\n\n\t/**\n\t * @class A thin wrapper around the Native Web Audio GainNode.\n\t * The GainNode is a basic building block of the Web Audio\n\t * API and is useful for routing audio and adjusting gains. \n\t * @extends {Tone}\n\t * @param {Number=} gain The initial gain of the GainNode\n\t * @param {Tone.Type=} units The units of the gain parameter. \n\t */\n\tTone.Gain = function(){\n\n\t\tvar options = this.optionsObject(arguments, [\"gain\", \"units\"], Tone.Gain.defaults);\n\n\t\t/**\n\t\t * The GainNode\n\t\t * @type {GainNode}\n\t\t * @private\n\t\t */\n\t\tthis.input = this.output = this._gainNode = this.context.createGain();\n\n\t\t/**\n\t\t * The gain parameter of the gain node.\n\t\t * @type {Tone.Param}\n\t\t * @signal\n\t\t */\n\t\tthis.gain = new Tone.Param({\n\t\t\t\"param\" : this._gainNode.gain, \n\t\t\t\"units\" : options.units,\n\t\t\t\"value\" : options.gain,\n\t\t\t\"convert\" : options.convert\n\t\t});\n\t\tthis._readOnly(\"gain\");\n\t};\n\n\tTone.extend(Tone.Gain);\n\n\t/**\n\t * The defaults\n\t * @const\n\t * @type {Object}\n\t */\n\tTone.Gain.defaults = {\n\t\t\"gain\" : 1,\n\t\t\"convert\" : true,\n\t};\n\n\t/**\n\t * Clean up.\n\t * @return {Tone.Gain} this\n\t */\n\tTone.Gain.prototype.dispose = function(){\n\t\tTone.Param.prototype.dispose.call(this);\n\t\tthis._gainNode.disconnect();\n\t\tthis._gainNode = null;\n\t\tthis._writable(\"gain\");\n\t\tthis.gain.dispose();\n\t\tthis.gain = null;\n\t};\n\n\t//STATIC///////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Create input and outputs for this object.\n\t * @param {Number} input The number of inputs\n\t * @param {Number=} outputs The number of outputs\n\t * @return {Tone} this\n\t * @internal\n\t */\n\tTone.prototype.createInsOuts = function(inputs, outputs){\n\n\t\tif (inputs === 1){\n\t\t\tthis.input = new Tone.Gain();\n\t\t} else if (inputs > 1){\n\t\t\tthis.input = new Array(inputs);\n\t\t}\n\n\t\tif (outputs === 1){\n\t\t\tthis.output = new Tone.Gain();\n\t\t} else if (outputs > 1){\n\t\t\tthis.output = new Array(inputs);\n\t\t}\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\n\treturn Tone.Gain;\n});","module.exports = {\n recorderProcessor: 'recorder-processor',\n soundFileProcessor: 'sound-file-processor',\n amplitudeProcessor: 'amplitude-processor'\n};\n","'use strict';\n\ndefine(function () {\n /*\n Helper function to generate an error\n with a custom stack trace that points to the sketch\n and removes other parts of the stack trace.\n\n @private\n @class customError\n @constructor\n @param {String} name custom error name\n @param {String} errorTrace custom error trace\n @param {String} failedPath path to the file that failed to load\n @property {String} name custom error name\n @property {String} message custom error message\n @property {String} stack trace the error back to a line in the user's sketch.\n Note: this edits out stack trace within p5.js and p5.sound.\n @property {String} originalStack unedited, original stack trace\n @property {String} failedPath path to the file that failed to load\n @return {Error} returns a custom Error object\n */\n var CustomError = function(name, errorTrace, failedPath) {\n var err = new Error();\n var tempStack, splitStack;\n\n err.name = name;\n err.originalStack = err.stack + errorTrace;\n tempStack = err.stack + errorTrace;\n err.failedPath = failedPath;\n\n // only print the part of the stack trace that refers to the user code:\n var splitStack = tempStack.split('\\n');\n splitStack = splitStack.filter(function(ln) {\n return !ln.match(/(p5.|native code|globalInit)/g);\n });\n err.stack = splitStack.join('\\n');\n\n return err; // TODO: is this really a constructor?\n };\n\n return CustomError;\n});\n","define([\"Tone/core/Tone\", \"Tone/core/Emitter\"], function (Tone) {\n\n\t/**\n\t * shim\n\t * @private\n\t */\n\tif (!window.hasOwnProperty(\"AudioContext\") && window.hasOwnProperty(\"webkitAudioContext\")){\n\t\twindow.AudioContext = window.webkitAudioContext;\n\t}\n\n\t/**\n\t * @class Wrapper around the native AudioContext.\n\t * @extends {Tone.Emitter}\n\t * @param {AudioContext=} context optionally pass in a context\n\t */\n\tTone.Context = function(context){\n\n\t\tTone.Emitter.call(this);\n\n\t\tif (!context){\n\t\t\tcontext = new window.AudioContext();\n\t\t}\n\t\tthis._context = context;\n\t\t// extend all of the methods\n\t\tfor (var prop in this._context){\n\t\t\tthis._defineProperty(this._context, prop);\n\t\t}\n\n\t\t///////////////////////////////////////////////////////////////////////\n\t\t// WORKER\n\t\t///////////////////////////////////////////////////////////////////////\n\n\t\t/**\n\t\t * The default latency hint\n\t\t * @type {String}\n\t\t * @private\n\t\t */\n\t\tthis._latencyHint = \"interactive\";\n\n\t\t/**\n\t\t * The amount of time events are scheduled\n\t\t * into the future\n\t\t * @type {Number}\n\t\t * @private\n\t\t */\n\t\tthis._lookAhead = 0.1;\n\n\t\t/**\n\t\t * How often the update look runs\n\t\t * @type {Number}\n\t\t * @private\n\t\t */\n\t\tthis._updateInterval = this._lookAhead/3;\n\n\t\t/**\n\t\t * A reference to the actual computed update interval\n\t\t * @type {Number}\n\t\t * @private\n\t\t */\n\t\tthis._computedUpdateInterval = 0;\n\n\t\t/**\n\t\t * The web worker which is used to update Tone.Clock\n\t\t * @private\n\t\t * @type {WebWorker}\n\t\t */\n\t\tthis._worker = this._createWorker();\n\n\t\t/**\n\t\t * An object containing all of the constants AudioBufferSourceNodes\n\t\t * @type {Object}\n\t\t * @private\n\t\t */\n\t\tthis._constants = {};\n\n\t};\n\n\tTone.extend(Tone.Context, Tone.Emitter);\n\tTone.Emitter.mixin(Tone.Context);\n\n\t/**\n\t * Define a property on this Tone.Context. \n\t * This is used to extend the native AudioContext\n\t * @param {AudioContext} context\n\t * @param {String} prop \n\t * @private\n\t */\n\tTone.Context.prototype._defineProperty = function(context, prop){\n\t\tif (this.isUndef(this[prop])){\n\t\t\tObject.defineProperty(this, prop, {\n\t\t\t\tget : function(){\n\t\t\t\t\tif (typeof context[prop] === \"function\"){\n\t\t\t\t\t\treturn context[prop].bind(context);\n\t\t\t\t\t} else {\n\t\t\t\t\t\treturn context[prop];\n\t\t\t\t\t}\n\t\t\t\t},\n\t\t\t\tset : function(val){\n\t\t\t\t\tcontext[prop] = val;\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\t};\n\n\t/**\n\t * The current audio context time\n\t * @return {Number}\n\t */\n\tTone.Context.prototype.now = function(){\n\t\treturn this._context.currentTime;\n\t};\n\n\t/**\n\t * Generate a web worker\n\t * @return {WebWorker}\n\t * @private\n\t */\n\tTone.Context.prototype._createWorker = function(){\n\t\t\n\t\t//URL Shim\n\t\twindow.URL = window.URL || window.webkitURL;\n\n\t\tvar blob = new Blob([\n\t\t\t//the initial timeout time\n\t\t\t\"var timeoutTime = \"+(this._updateInterval * 1000).toFixed(1)+\";\" +\n\t\t\t//onmessage callback\n\t\t\t\"self.onmessage = function(msg){\" +\n\t\t\t\"\ttimeoutTime = parseInt(msg.data);\" + \n\t\t\t\"};\" + \n\t\t\t//the tick function which posts a message\n\t\t\t//and schedules a new tick\n\t\t\t\"function tick(){\" +\n\t\t\t\"\tsetTimeout(tick, timeoutTime);\" +\n\t\t\t\"\tself.postMessage('tick');\" +\n\t\t\t\"}\" +\n\t\t\t//call tick initially\n\t\t\t\"tick();\"\n\t\t]);\n\t\tvar blobUrl = URL.createObjectURL(blob);\n\t\tvar worker = new Worker(blobUrl);\n\n\t\tworker.addEventListener(\"message\", function(){\n\t\t\t// tick the clock\n\t\t\tthis.emit(\"tick\");\n\t\t}.bind(this));\n\n\t\t//lag compensation\n\t\tworker.addEventListener(\"message\", function(){\n\t\t\tvar now = this.now();\n\t\t\tif (this.isNumber(this._lastUpdate)){\n\t\t\t\tvar diff = now - this._lastUpdate;\n\t\t\t\tthis._computedUpdateInterval = Math.max(diff, this._computedUpdateInterval * 0.97);\n\t\t\t}\n\t\t\tthis._lastUpdate = now;\n\t\t}.bind(this));\n\n\t\treturn worker;\n\t};\n\n\t/**\n\t * Generate a looped buffer at some constant value.\n\t * @param {Number} val\n\t * @return {BufferSourceNode}\n\t */\n\tTone.Context.prototype.getConstant = function(val){\n\t\tif (this._constants[val]){\n\t\t\treturn this._constants[val];\n\t\t} else {\n\t\t\tvar buffer = this._context.createBuffer(1, 128, this._context.sampleRate);\n\t\t\tvar arr = buffer.getChannelData(0);\n\t\t\tfor (var i = 0; i < arr.length; i++){\n\t\t\t\tarr[i] = val;\n\t\t\t}\n\t\t\tvar constant = this._context.createBufferSource();\n\t\t\tconstant.channelCount = 1;\n\t\t\tconstant.channelCountMode = \"explicit\";\n\t\t\tconstant.buffer = buffer;\n\t\t\tconstant.loop = true;\n\t\t\tconstant.start(0);\n\t\t\tthis._constants[val] = constant;\n\t\t\treturn constant;\n\t\t}\n\t};\n\n\t/**\n\t * This is the time that the clock is falling behind\n\t * the scheduled update interval. The Context automatically\n\t * adjusts for the lag and schedules further in advance.\n\t * @type {Number}\n\t * @memberOf Tone.Context\n\t * @name lag\n\t * @static\n\t * @readOnly\n\t */\n\tObject.defineProperty(Tone.Context.prototype, \"lag\", {\n\t\tget : function(){\n\t\t\tvar diff = this._computedUpdateInterval - this._updateInterval;\n\t\t\tdiff = Math.max(diff, 0);\n\t\t\treturn diff;\n\t\t}\n\t});\n\n\t/**\n\t * The amount of time in advance that events are scheduled.\n\t * The lookAhead will adjust slightly in response to the \n\t * measured update time to try to avoid clicks.\n\t * @type {Number}\n\t * @memberOf Tone.Context\n\t * @name lookAhead\n\t * @static\n\t */\n\tObject.defineProperty(Tone.Context.prototype, \"lookAhead\", {\n\t\tget : function(){\n\t\t\treturn this._lookAhead;\n\t\t},\n\t\tset : function(lA){\n\t\t\tthis._lookAhead = lA;\n\t\t}\n\t});\n\n\t/**\n\t * How often the Web Worker callback is invoked.\n\t * This number corresponds to how responsive the scheduling\n\t * can be. Context.updateInterval + Context.lookAhead gives you the\n\t * total latency between scheduling an event and hearing it.\n\t * @type {Number}\n\t * @memberOf Tone.Context\n\t * @name updateInterval\n\t * @static\n\t */\n\tObject.defineProperty(Tone.Context.prototype, \"updateInterval\", {\n\t\tget : function(){\n\t\t\treturn this._updateInterval;\n\t\t},\n\t\tset : function(interval){\n\t\t\tthis._updateInterval = Math.max(interval, Tone.prototype.blockTime);\n\t\t\tthis._worker.postMessage(Math.max(interval * 1000, 1));\n\t\t}\n\t});\n\n\t/**\n\t * The type of playback, which affects tradeoffs between audio \n\t * output latency and responsiveness. \n\t * \n\t * In addition to setting the value in seconds, the latencyHint also\n\t * accepts the strings \"interactive\" (prioritizes low latency), \n\t * \"playback\" (prioritizes sustained playback), \"balanced\" (balances\n\t * latency and performance), and \"fastest\" (lowest latency, might glitch more often). \n\t * @type {String|Seconds}\n\t * @memberOf Tone.Context#\n\t * @name latencyHint\n\t * @static\n\t * @example\n\t * //set the lookAhead to 0.3 seconds\n\t * Tone.context.latencyHint = 0.3;\n\t */\n\tObject.defineProperty(Tone.Context.prototype, \"latencyHint\", {\n\t\tget : function(){\n\t\t\treturn this._latencyHint;\n\t\t},\n\t\tset : function(hint){\n\t\t\tvar lookAhead = hint;\n\t\t\tthis._latencyHint = hint;\n\t\t\tif (this.isString(hint)){\n\t\t\t\tswitch(hint){\n\t\t\t\t\tcase \"interactive\" :\n\t\t\t\t\t\tlookAhead = 0.1;\n\t\t\t\t\t\tthis._context.latencyHint = hint;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase \"playback\" :\n\t\t\t\t\t\tlookAhead = 0.8;\n\t\t\t\t\t\tthis._context.latencyHint = hint;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase \"balanced\" :\n\t\t\t\t\t\tlookAhead = 0.25;\n\t\t\t\t\t\tthis._context.latencyHint = hint;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase \"fastest\" :\n\t\t\t\t\t\tlookAhead = 0.01;\n\t\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis.lookAhead = lookAhead;\n\t\t\tthis.updateInterval = lookAhead/3;\n\t\t}\n\t});\n\n\t/**\n\t * Shim all connect/disconnect and some deprecated methods which are still in\n\t * some older implementations.\n\t * @private\n\t */\n\tfunction shimConnect(){\n\n\t\tvar nativeConnect = AudioNode.prototype.connect;\n\t\tvar nativeDisconnect = AudioNode.prototype.disconnect;\n\n\t\t//replace the old connect method\n\t\tfunction toneConnect(B, outNum, inNum){\n\t\t\tif (B.input){\n\t\t\t\tif (Array.isArray(B.input)){\n\t\t\t\t\tif (Tone.prototype.isUndef(inNum)){\n\t\t\t\t\t\tinNum = 0;\n\t\t\t\t\t}\n\t\t\t\t\tthis.connect(B.input[inNum]);\n\t\t\t\t} else {\n\t\t\t\t\tthis.connect(B.input, outNum, inNum);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\ttry {\n\t\t\t\t\tif (B instanceof AudioNode){\n\t\t\t\t\t\tnativeConnect.call(this, B, outNum, inNum);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tnativeConnect.call(this, B, outNum);\n\t\t\t\t\t}\n\t\t\t\t} catch (e) {\n\t\t\t\t\tthrow new Error(\"error connecting to node: \"+B+\"\\n\"+e);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t//replace the old disconnect method\n\t\tfunction toneDisconnect(B, outNum, inNum){\n\t\t\tif (B && B.input && Array.isArray(B.input)){\n\t\t\t\tif (Tone.prototype.isUndef(inNum)){\n\t\t\t\t\tinNum = 0;\n\t\t\t\t}\n\t\t\t\tthis.disconnect(B.input[inNum], outNum, inNum);\n\t\t\t} else if (B && B.input){\n\t\t\t\tthis.disconnect(B.input, outNum, inNum);\n\t\t\t} else {\n\t\t\t\ttry {\n\t\t\t\t\tnativeDisconnect.apply(this, arguments);\n\t\t\t\t} catch (e) {\n\t\t\t\t\tthrow new Error(\"error disconnecting node: \"+B+\"\\n\"+e);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif (AudioNode.prototype.connect !== toneConnect){\n\t\t\tAudioNode.prototype.connect = toneConnect;\n\t\t\tAudioNode.prototype.disconnect = toneDisconnect;\n\t\t}\n\t}\n\n\t// set the audio context initially\n\tif (Tone.supported){\n\t\tshimConnect();\n\t\tTone.context = new Tone.Context();\n\t} else {\n\t\tconsole.warn(\"This browser does not support Tone.js\");\n\t}\n\n\treturn Tone.Context;\n});","define([\"Tone/core/Tone\", \"Tone/signal/Add\", \"Tone/signal/Multiply\", \"Tone/signal/Signal\"], function(Tone){\n\n\t\"use strict\";\n\t\n\t/**\n\t * @class Performs a linear scaling on an input signal.\n\t * Scales a NormalRange input to between\n\t * outputMin and outputMax.\n\t *\n\t * @constructor\n\t * @extends {Tone.SignalBase}\n\t * @param {number} [outputMin=0] The output value when the input is 0. \n\t * @param {number} [outputMax=1]\tThe output value when the input is 1. \n\t * @example\n\t * var scale = new Tone.Scale(50, 100);\n\t * var signal = new Tone.Signal(0.5).connect(scale);\n\t * //the output of scale equals 75\n\t */\n\tTone.Scale = function(outputMin, outputMax){\n\n\t\t/** \n\t\t * @private\n\t\t * @type {number}\n\t\t */\n\t\tthis._outputMin = this.defaultArg(outputMin, 0);\n\n\t\t/** \n\t\t * @private\n\t\t * @type {number}\n\t\t */\n\t\tthis._outputMax = this.defaultArg(outputMax, 1);\n\n\n\t\t/** \n\t\t * @private\n\t\t * @type {Tone.Multiply}\n\t\t * @private\n\t\t */\n\t\tthis._scale = this.input = new Tone.Multiply(1);\n\t\t\n\t\t/** \n\t\t * @private\n\t\t * @type {Tone.Add}\n\t\t * @private\n\t\t */\n\t\tthis._add = this.output = new Tone.Add(0);\n\n\t\tthis._scale.connect(this._add);\n\t\tthis._setRange();\n\t};\n\n\tTone.extend(Tone.Scale, Tone.SignalBase);\n\n\t/**\n\t * The minimum output value. This number is output when \n\t * the value input value is 0. \n\t * @memberOf Tone.Scale#\n\t * @type {number}\n\t * @name min\n\t */\n\tObject.defineProperty(Tone.Scale.prototype, \"min\", {\n\t\tget : function(){\n\t\t\treturn this._outputMin;\n\t\t},\n\t\tset : function(min){\n\t\t\tthis._outputMin = min;\n\t\t\tthis._setRange();\n\t\t}\n\t});\n\n\t/**\n\t * The maximum output value. This number is output when \n\t * the value input value is 1. \n\t * @memberOf Tone.Scale#\n\t * @type {number}\n\t * @name max\n\t */\n\tObject.defineProperty(Tone.Scale.prototype, \"max\", {\n\t\tget : function(){\n\t\t\treturn this._outputMax;\n\t\t},\n\t\tset : function(max){\n\t\t\tthis._outputMax = max;\n\t\t\tthis._setRange();\n\t\t}\n\t});\n\n\t/**\n\t * set the values\n\t * @private\n\t */\n\tTone.Scale.prototype._setRange = function() {\n\t\tthis._add.value = this._outputMin;\n\t\tthis._scale.value = this._outputMax - this._outputMin;\n\t};\n\n\t/**\n\t * Clean up.\n\t * @returns {Tone.Scale} this\n\t */\n\tTone.Scale.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._add.dispose();\n\t\tthis._add = null;\n\t\tthis._scale.dispose();\n\t\tthis._scale = null;\n\t\treturn this;\n\t}; \n\n\treturn Tone.Scale;\n});\n","define([\"Tone/core/Tone\", \"Tone/signal/Signal\", \"Tone/core/Timeline\"], function (Tone) {\n\n\t\"use strict\";\n\n\t/**\n\t * @class A signal which adds the method getValueAtTime. \n\t * Code and inspiration from https://github.com/jsantell/web-audio-automation-timeline\n\t * @extends {Tone.Param}\n\t * @param {Number=} value The initial value of the signal\n\t * @param {String=} units The conversion units of the signal.\n\t */\n\tTone.TimelineSignal = function(){\n\n\t\tvar options = this.optionsObject(arguments, [\"value\", \"units\"], Tone.Signal.defaults);\n\t\t\n\t\t/**\n\t\t * The scheduled events\n\t\t * @type {Tone.Timeline}\n\t\t * @private\n\t\t */\n\t\tthis._events = new Tone.Timeline(10);\n\n\t\t//constructors\n\t\tTone.Signal.apply(this, options);\n\t\toptions.param = this._param;\n\t\tTone.Param.call(this, options);\n\n\t\t/**\n\t\t * The initial scheduled value\n\t\t * @type {Number}\n\t\t * @private\n\t\t */\n\t\tthis._initial = this._fromUnits(this._param.value);\n\t};\n\n\tTone.extend(Tone.TimelineSignal, Tone.Param);\n\n\t/**\n\t * The event types of a schedulable signal.\n\t * @enum {String}\n\t * @private\n\t */\n\tTone.TimelineSignal.Type = {\n\t\tLinear : \"linear\",\n\t\tExponential : \"exponential\",\n\t\tTarget : \"target\",\n\t\tCurve : \"curve\",\n\t\tSet : \"set\"\n\t};\n\n\t/**\n\t * The current value of the signal. \n\t * @memberOf Tone.TimelineSignal#\n\t * @type {Number}\n\t * @name value\n\t */\n\tObject.defineProperty(Tone.TimelineSignal.prototype, \"value\", {\n\t\tget : function(){\n\t\t\tvar now = this.now();\n\t\t\tvar val = this.getValueAtTime(now);\n\t\t\treturn this._toUnits(val);\n\t\t},\n\t\tset : function(value){\n\t\t\tvar convertedVal = this._fromUnits(value);\n\t\t\tthis._initial = convertedVal;\n\t\t\tthis.cancelScheduledValues();\n\t\t\tthis._param.value = convertedVal;\n\t\t}\n\t});\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tSCHEDULING\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Schedules a parameter value change at the given time.\n\t * @param {*}\tvalue The value to set the signal.\n\t * @param {Time} time The time when the change should occur.\n\t * @returns {Tone.TimelineSignal} this\n\t * @example\n\t * //set the frequency to \"G4\" in exactly 1 second from now. \n\t * freq.setValueAtTime(\"G4\", \"+1\");\n\t */\n\tTone.TimelineSignal.prototype.setValueAtTime = function (value, startTime) {\n\t\tvalue = this._fromUnits(value);\n\t\tstartTime = this.toSeconds(startTime);\n\t\tthis._events.add({\n\t\t\t\"type\" : Tone.TimelineSignal.Type.Set,\n\t\t\t\"value\" : value,\n\t\t\t\"time\" : startTime\n\t\t});\n\t\t//invoke the original event\n\t\tthis._param.setValueAtTime(value, startTime);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Schedules a linear continuous change in parameter value from the \n\t * previous scheduled parameter value to the given value.\n\t * \n\t * @param {number} value \n\t * @param {Time} endTime \n\t * @returns {Tone.TimelineSignal} this\n\t */\n\tTone.TimelineSignal.prototype.linearRampToValueAtTime = function (value, endTime) {\n\t\tvalue = this._fromUnits(value);\n\t\tendTime = this.toSeconds(endTime);\n\t\tthis._events.add({\n\t\t\t\"type\" : Tone.TimelineSignal.Type.Linear,\n\t\t\t\"value\" : value,\n\t\t\t\"time\" : endTime\n\t\t});\n\t\tthis._param.linearRampToValueAtTime(value, endTime);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Schedules an exponential continuous change in parameter value from \n\t * the previous scheduled parameter value to the given value.\n\t * \n\t * @param {number} value \n\t * @param {Time} endTime \n\t * @returns {Tone.TimelineSignal} this\n\t */\n\tTone.TimelineSignal.prototype.exponentialRampToValueAtTime = function (value, endTime) {\n\t\t//get the previous event and make sure it's not starting from 0\n\t\tendTime = this.toSeconds(endTime);\n\t\tvar beforeEvent = this._searchBefore(endTime);\n\t\tif (beforeEvent && beforeEvent.value === 0){\n\t\t\t//reschedule that event\n\t\t\tthis.setValueAtTime(this._minOutput, beforeEvent.time);\n\t\t}\n\t\tvalue = this._fromUnits(value);\n\t\tvar setValue = Math.max(value, this._minOutput);\n\t\tthis._events.add({\n\t\t\t\"type\" : Tone.TimelineSignal.Type.Exponential,\n\t\t\t\"value\" : setValue,\n\t\t\t\"time\" : endTime\n\t\t});\n\t\t//if the ramped to value is 0, make it go to the min output, and then set to 0.\n\t\tif (value < this._minOutput){\n\t\t\tthis._param.exponentialRampToValueAtTime(this._minOutput, endTime - this.sampleTime);\n\t\t\tthis.setValueAtTime(0, endTime);\n\t\t} else {\n\t\t\tthis._param.exponentialRampToValueAtTime(value, endTime);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Start exponentially approaching the target value at the given time with\n\t * a rate having the given time constant.\n\t * @param {number} value \n\t * @param {Time} startTime \n\t * @param {number} timeConstant \n\t * @returns {Tone.TimelineSignal} this \n\t */\n\tTone.TimelineSignal.prototype.setTargetAtTime = function (value, startTime, timeConstant) {\n\t\tvalue = this._fromUnits(value);\n\t\tvalue = Math.max(this._minOutput, value);\n\t\ttimeConstant = Math.max(this._minOutput, timeConstant);\n\t\tstartTime = this.toSeconds(startTime);\n\t\tthis._events.add({\n\t\t\t\"type\" : Tone.TimelineSignal.Type.Target,\n\t\t\t\"value\" : value,\n\t\t\t\"time\" : startTime,\n\t\t\t\"constant\" : timeConstant\n\t\t});\n\t\tthis._param.setTargetAtTime(value, startTime, timeConstant);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Set an array of arbitrary values starting at the given time for the given duration.\n\t * @param {Float32Array} values \n\t * @param {Time} startTime \n\t * @param {Time} duration\n\t * @param {NormalRange} [scaling=1] If the values in the curve should be scaled by some value\n\t * @returns {Tone.TimelineSignal} this \n\t */\n\tTone.TimelineSignal.prototype.setValueCurveAtTime = function (values, startTime, duration, scaling) {\n\t\tscaling = this.defaultArg(scaling, 1);\n\t\t//copy the array\n\t\tvar floats = new Array(values.length);\n\t\tfor (var i = 0; i < floats.length; i++){\n\t\t\tfloats[i] = this._fromUnits(values[i]) * scaling;\n\t\t}\n\t\tstartTime = this.toSeconds(startTime);\n\t\tduration = this.toSeconds(duration);\n\t\tthis._events.add({\n\t\t\t\"type\" : Tone.TimelineSignal.Type.Curve,\n\t\t\t\"value\" : floats,\n\t\t\t\"time\" : startTime,\n\t\t\t\"duration\" : duration\n\t\t});\n\t\t//set the first value\n\t\tthis._param.setValueAtTime(floats[0], startTime);\n\t\t//schedule a lienar ramp for each of the segments\n\t\tfor (var j = 1; j < floats.length; j++){\n\t\t\tvar segmentTime = startTime + (j / (floats.length - 1) * duration);\n\t\t\tthis._param.linearRampToValueAtTime(floats[j], segmentTime);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Cancels all scheduled parameter changes with times greater than or \n\t * equal to startTime.\n\t * \n\t * @param {Time} startTime\n\t * @returns {Tone.TimelineSignal} this\n\t */\n\tTone.TimelineSignal.prototype.cancelScheduledValues = function (after) {\n\t\tafter = this.toSeconds(after);\n\t\tthis._events.cancel(after);\n\t\tthis._param.cancelScheduledValues(after);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Sets the computed value at the given time. This provides\n\t * a point from which a linear or exponential curve\n\t * can be scheduled after. Will cancel events after \n\t * the given time and shorten the currently scheduled\n\t * linear or exponential ramp so that it ends at `time` .\n\t * This is to avoid discontinuities and clicks in envelopes. \n\t * @param {Time} time When to set the ramp point\n\t * @returns {Tone.TimelineSignal} this\n\t */\n\tTone.TimelineSignal.prototype.setRampPoint = function (time) {\n\t\ttime = this.toSeconds(time);\n\t\t//get the value at the given time\n\t\tvar val = this._toUnits(this.getValueAtTime(time));\n\t\t//if there is an event at the given time\n\t\t//and that even is not a \"set\"\n\t\tvar before = this._searchBefore(time);\n\t\tif (before && before.time === time){\n\t\t\t//remove everything after\n\t\t\tthis.cancelScheduledValues(time + this.sampleTime);\n\t\t} else if (before && \n\t\t\t\t before.type === Tone.TimelineSignal.Type.Curve &&\n\t\t\t\t before.time + before.duration > time){\n\t\t\t//if the curve is still playing\n\t\t\t//cancel the curve\n\t\t\tthis.cancelScheduledValues(time);\n\t\t\tthis.linearRampToValueAtTime(val, time);\n\t\t} else {\n\t\t\t//reschedule the next event to end at the given time\n\t\t\tvar after = this._searchAfter(time);\n\t\t\tif (after){\n\t\t\t\t//cancel the next event(s)\n\t\t\t\tthis.cancelScheduledValues(time);\n\t\t\t\tif (after.type === Tone.TimelineSignal.Type.Linear){\n\t\t\t\t\tthis.linearRampToValueAtTime(val, time);\n\t\t\t\t} else if (after.type === Tone.TimelineSignal.Type.Exponential){\n\t\t\t\t\tthis.exponentialRampToValueAtTime(val, time);\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis.setValueAtTime(val, time);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Do a linear ramp to the given value between the start and finish times.\n\t * @param {Number} value The value to ramp to.\n\t * @param {Time} start The beginning anchor point to do the linear ramp\n\t * @param {Time} finish The ending anchor point by which the value of\n\t * the signal will equal the given value.\n\t * @returns {Tone.TimelineSignal} this\n\t */\n\tTone.TimelineSignal.prototype.linearRampToValueBetween = function (value, start, finish) {\n\t\tthis.setRampPoint(start);\n\t\tthis.linearRampToValueAtTime(value, finish);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Do a exponential ramp to the given value between the start and finish times.\n\t * @param {Number} value The value to ramp to.\n\t * @param {Time} start The beginning anchor point to do the exponential ramp\n\t * @param {Time} finish The ending anchor point by which the value of\n\t * the signal will equal the given value.\n\t * @returns {Tone.TimelineSignal} this\n\t */\n\tTone.TimelineSignal.prototype.exponentialRampToValueBetween = function (value, start, finish) {\n\t\tthis.setRampPoint(start);\n\t\tthis.exponentialRampToValueAtTime(value, finish);\n\t\treturn this;\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tGETTING SCHEDULED VALUES\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Returns the value before or equal to the given time\n\t * @param {Number} time The time to query\n\t * @return {Object} The event at or before the given time.\n\t * @private\n\t */\n\tTone.TimelineSignal.prototype._searchBefore = function(time){\n\t\treturn this._events.get(time);\n\t};\n\n\t/**\n\t * The event after the given time\n\t * @param {Number} time The time to query.\n\t * @return {Object} The next event after the given time\n\t * @private\n\t */\n\tTone.TimelineSignal.prototype._searchAfter = function(time){\n\t\treturn this._events.getAfter(time);\n\t};\n\n\t/**\n\t * Get the scheduled value at the given time. This will\n\t * return the unconverted (raw) value.\n\t * @param {Number} time The time in seconds.\n\t * @return {Number} The scheduled value at the given time.\n\t */\n\tTone.TimelineSignal.prototype.getValueAtTime = function(time){\n\t\ttime = this.toSeconds(time);\n\t\tvar after = this._searchAfter(time);\n\t\tvar before = this._searchBefore(time);\n\t\tvar value = this._initial;\n\t\t//if it was set by\n\t\tif (before === null){\n\t\t\tvalue = this._initial;\n\t\t} else if (before.type === Tone.TimelineSignal.Type.Target){\n\t\t\tvar previous = this._events.getBefore(before.time);\n\t\t\tvar previouVal;\n\t\t\tif (previous === null){\n\t\t\t\tpreviouVal = this._initial;\n\t\t\t} else {\n\t\t\t\tpreviouVal = previous.value;\n\t\t\t}\n\t\t\tvalue = this._exponentialApproach(before.time, previouVal, before.value, before.constant, time);\n\t\t} else if (before.type === Tone.TimelineSignal.Type.Curve){\n\t\t\tvalue = this._curveInterpolate(before.time, before.value, before.duration, time);\n\t\t} else if (after === null){\n\t\t\tvalue = before.value;\n\t\t} else if (after.type === Tone.TimelineSignal.Type.Linear){\n\t\t\tvalue = this._linearInterpolate(before.time, before.value, after.time, after.value, time);\n\t\t} else if (after.type === Tone.TimelineSignal.Type.Exponential){\n\t\t\tvalue = this._exponentialInterpolate(before.time, before.value, after.time, after.value, time);\n\t\t} else {\n\t\t\tvalue = before.value;\n\t\t}\n\t\treturn value;\n\t};\n\n\t/**\n\t * When signals connect to other signals or AudioParams, \n\t * they take over the output value of that signal or AudioParam. \n\t * For all other nodes, the behavior is the same as a default connect. \n\t *\n\t * @override\n\t * @param {AudioParam|AudioNode|Tone.Signal|Tone} node \n\t * @param {number} [outputNumber=0] The output number to connect from.\n\t * @param {number} [inputNumber=0] The input number to connect to.\n\t * @returns {Tone.TimelineSignal} this\n\t * @method\n\t */\n\tTone.TimelineSignal.prototype.connect = Tone.SignalBase.prototype.connect;\n\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tAUTOMATION CURVE CALCULATIONS\n\t//\tMIT License, copyright (c) 2014 Jordan Santell\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Calculates the the value along the curve produced by setTargetAtTime\n\t * @private\n\t */\n\tTone.TimelineSignal.prototype._exponentialApproach = function (t0, v0, v1, timeConstant, t) {\n\t\treturn v1 + (v0 - v1) * Math.exp(-(t - t0) / timeConstant);\n\t};\n\n\t/**\n\t * Calculates the the value along the curve produced by linearRampToValueAtTime\n\t * @private\n\t */\n\tTone.TimelineSignal.prototype._linearInterpolate = function (t0, v0, t1, v1, t) {\n\t\treturn v0 + (v1 - v0) * ((t - t0) / (t1 - t0));\n\t};\n\n\t/**\n\t * Calculates the the value along the curve produced by exponentialRampToValueAtTime\n\t * @private\n\t */\n\tTone.TimelineSignal.prototype._exponentialInterpolate = function (t0, v0, t1, v1, t) {\n\t\tv0 = Math.max(this._minOutput, v0);\n\t\treturn v0 * Math.pow(v1 / v0, (t - t0) / (t1 - t0));\n\t};\n\n\t/**\n\t * Calculates the the value along the curve produced by setValueCurveAtTime\n\t * @private\n\t */\n\tTone.TimelineSignal.prototype._curveInterpolate = function (start, curve, duration, time) {\n\t\tvar len = curve.length;\n\t\t// If time is after duration, return the last curve value\n\t\tif (time >= start + duration) {\n\t\t\treturn curve[len - 1];\n\t\t} else if (time <= start){\n\t\t\treturn curve[0];\n\t\t} else {\n\t\t\tvar progress = (time - start) / duration;\n\t\t\tvar lowerIndex = Math.floor((len - 1) * progress);\n\t\t\tvar upperIndex = Math.ceil((len - 1) * progress);\n\t\t\tvar lowerVal = curve[lowerIndex];\n\t\t\tvar upperVal = curve[upperIndex];\n\t\t\tif (upperIndex === lowerIndex){\n\t\t\t\treturn lowerVal;\n\t\t\t} else {\n\t\t\t\treturn this._linearInterpolate(lowerIndex, lowerVal, upperIndex, upperVal, progress * (len - 1));\n\t\t\t}\n\t\t}\n\t};\n\n\t/**\n\t * Clean up.\n\t * @return {Tone.TimelineSignal} this\n\t */\n\tTone.TimelineSignal.prototype.dispose = function(){\n\t\tTone.Signal.prototype.dispose.call(this);\n\t\tTone.Param.prototype.dispose.call(this);\n\t\tthis._events.dispose();\n\t\tthis._events = null;\n\t};\n\n\treturn Tone.TimelineSignal;\n});","'use strict';\n\ndefine(function (require) {\n var Effect = require('effect');\n\n /**\n *

A p5.Filter uses a Web Audio Biquad Filter to filter\n * the frequency response of an input source. Subclasses\n * include:

\n * p5.LowPass:\n * Allows frequencies below the cutoff frequency to pass through,\n * and attenuates frequencies above the cutoff.
\n * p5.HighPass:\n * The opposite of a lowpass filter.
\n * p5.BandPass:\n * Allows a range of frequencies to pass through and attenuates\n * the frequencies below and above this frequency range.
\n *\n * The .res() method controls either width of the\n * bandpass, or resonance of the low/highpass cutoff frequency.\n *\n * This class extends p5.Effect.\n * Methods amp(), chain(),\n * drywet(), connect(), and\n * disconnect() are available.\n *\n * @class p5.Filter\n * @extends p5.Effect\n * @constructor\n * @param {String} [type] 'lowpass' (default), 'highpass', 'bandpass'\n * @example\n *
\n * let fft, noise, filter;\n *\n * function setup() {\n * let cnv = createCanvas(100,100);\n * cnv.mousePressed(makeNoise);\n * fill(255, 0, 255);\n *\n * filter = new p5.BandPass();\n * noise = new p5.Noise();\n * noise.disconnect();\n * noise.connect(filter);\n *\n * fft = new p5.FFT();\n * }\n *\n * function draw() {\n * background(220);\n *\n * // set the BandPass frequency based on mouseX\n * let freq = map(mouseX, 0, width, 20, 10000);\n * freq = constrain(freq, 0, 22050);\n * filter.freq(freq);\n * // give the filter a narrow band (lower res = wider bandpass)\n * filter.res(50);\n *\n * // draw filtered spectrum\n * let spectrum = fft.analyze();\n * noStroke();\n * for (let i = 0; i < spectrum.length; i++) {\n * let x = map(i, 0, spectrum.length, 0, width);\n * let h = -height + map(spectrum[i], 0, 255, height, 0);\n * rect(x, height, width/spectrum.length, h);\n * }\n * if (!noise.started) {\n * text('tap here and drag to change frequency', 10, 20, width - 20);\n * } else {\n * text('Frequency: ' + round(freq)+'Hz', 20, 20, width - 20);\n * }\n * }\n *\n * function makeNoise() {\n * // see also: `userStartAudio()`\n * noise.start();\n * noise.amp(0.5, 0.2);\n * }\n *\n * function mouseReleased() {\n * noise.amp(0, 0.2);\n * }\n *\n *
\n */\n p5.Filter = function (type) {\n\n Effect.call(this);\n //add extend Effect by adding a Biquad Filter\n\n /**\n * The p5.Filter is built with a\n * \n * Web Audio BiquadFilter Node.\n *\n * @property {DelayNode} biquadFilter\n\t */\n\n this.biquad = this.ac.createBiquadFilter();\n\n this.input.connect(this.biquad);\n\n this.biquad.connect(this.wet);\n\n if (type) {\n this.setType(type);\n }\n\n //Properties useful for the toggle method.\n this._on = true;\n this._untoggledType = this.biquad.type;\n };\n p5.Filter.prototype = Object.create(Effect.prototype);\n\n\n /**\n * Filter an audio signal according to a set\n * of filter parameters.\n *\n * @method process\n * @param {Object} Signal An object that outputs audio\n * @param {Number} [freq] Frequency in Hz, from 10 to 22050\n * @param {Number} [res] Resonance/Width of the filter frequency\n * from 0.001 to 1000\n */\n p5.Filter.prototype.process = function(src, freq, res, time) {\n src.connect(this.input);\n this.set(freq, res, time);\n };\n\n\n /**\n * Set the frequency and the resonance of the filter.\n *\n * @method set\n * @param {Number} [freq] Frequency in Hz, from 10 to 22050\n * @param {Number} [res] Resonance (Q) from 0.001 to 1000\n * @param {Number} [timeFromNow] schedule this event to happen\n * seconds from now\n */\n p5.Filter.prototype.set = function(freq, res, time) {\n if (freq) {\n this.freq(freq, time);\n }\n if (res) {\n this.res(res, time);\n }\n };\n\n /**\n * Set the filter frequency, in Hz, from 10 to 22050 (the range of\n * human hearing, although in reality most people hear in a narrower\n * range).\n *\n * @method freq\n * @param {Number} freq Filter Frequency\n * @param {Number} [timeFromNow] schedule this event to happen\n * seconds from now\n * @return {Number} value Returns the current frequency value\n */\n p5.Filter.prototype.freq = function(freq, time) {\n var t = time || 0;\n if (freq <= 0) {\n freq = 1;\n }\n if (typeof freq === 'number') {\n this.biquad.frequency.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.biquad.frequency.exponentialRampToValueAtTime(freq, this.ac.currentTime + 0.02 + t);\n } else if (freq) {\n freq.connect(this.biquad.frequency);\n }\n return this.biquad.frequency.value;\n };\n\n /**\n * Controls either width of a bandpass frequency,\n * or the resonance of a low/highpass cutoff frequency.\n *\n * @method res\n * @param {Number} res Resonance/Width of filter freq\n * from 0.001 to 1000\n * @param {Number} [timeFromNow] schedule this event to happen\n * seconds from now\n * @return {Number} value Returns the current res value\n */\n p5.Filter.prototype.res = function(res, time) {\n var t = time || 0;\n if (typeof res === 'number') {\n this.biquad.Q.value = res;\n this.biquad.Q.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.biquad.Q.linearRampToValueAtTime(res, this.ac.currentTime + 0.02 + t);\n } else if (res) {\n res.connect(this.biquad.Q);\n }\n return this.biquad.Q.value;\n };\n\n /**\n * Controls the gain attribute of a Biquad Filter.\n * This is distinctly different from .amp() which is inherited from p5.Effect\n * .amp() controls the volume via the output gain node\n * p5.Filter.gain() controls the gain parameter of a Biquad Filter node.\n *\n * @method gain\n * @param {Number} gain\n * @return {Number} Returns the current or updated gain value\n */\n p5.Filter.prototype.gain = function(gain, time) {\n var t = time || 0;\n if (typeof gain === 'number') {\n this.biquad.gain.value = gain;\n this.biquad.gain.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.biquad.gain.linearRampToValueAtTime(gain, this.ac.currentTime + 0.02 + t);\n } else if (gain) {\n gain.connect(this.biquad.gain);\n }\n return this.biquad.gain.value;\n };\n\n\n /**\n * Toggle function. Switches between the specified type and allpass\n *\n * @method toggle\n * @return {boolean} [Toggle value]\n */\n p5.Filter.prototype.toggle = function() {\n this._on = !this._on;\n\n if (this._on === true) {\n this.biquad.type = this._untoggledType;\n } else if (this._on === false) {\n this.biquad.type = 'allpass';\n }\n\n return this._on;\n };\n\n /**\n * Set the type of a p5.Filter. Possible types include:\n * \"lowpass\" (default), \"highpass\", \"bandpass\",\n * \"lowshelf\", \"highshelf\", \"peaking\", \"notch\",\n * \"allpass\".\n *\n * @method setType\n * @param {String} t\n */\n p5.Filter.prototype.setType = function(t) {\n this.biquad.type = t;\n this._untoggledType = this.biquad.type;\n };\n\n p5.Filter.prototype.dispose = function() {\n // remove reference from soundArray\n Effect.prototype.dispose.apply(this);\n if (this.biquad) {\n this.biquad.disconnect();\n delete this.biquad;\n }\n };\n\n /**\n * Constructor: new p5.LowPass() Filter.\n * This is the same as creating a p5.Filter and then calling\n * its method setType('lowpass').\n * See p5.Filter for methods.\n *\n * @class p5.LowPass\n * @constructor\n * @extends p5.Filter\n */\n p5.LowPass = function() {\n p5.Filter.call(this, 'lowpass');\n };\n p5.LowPass.prototype = Object.create(p5.Filter.prototype);\n\n /**\n * Constructor: new p5.HighPass() Filter.\n * This is the same as creating a p5.Filter and then calling\n * its method setType('highpass').\n * See p5.Filter for methods.\n *\n * @class p5.HighPass\n * @constructor\n * @extends p5.Filter\n */\n p5.HighPass = function() {\n p5.Filter.call(this, 'highpass');\n };\n p5.HighPass.prototype = Object.create(p5.Filter.prototype);\n\n /**\n * Constructor: new p5.BandPass() Filter.\n * This is the same as creating a p5.Filter and then calling\n * its method setType('bandpass').\n * See p5.Filter for methods.\n *\n * @class p5.BandPass\n * @constructor\n * @extends p5.Filter\n */\n p5.BandPass = function() {\n p5.Filter.call(this, 'bandpass');\n };\n p5.BandPass.prototype = Object.create(p5.Filter.prototype);\n\n return p5.Filter;\n});\n","define([\"Tone/core/Tone\", \"Tone/signal/Add\", \"Tone/signal/Negate\", \"Tone/signal/Signal\", \"Tone/core/Gain\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Subtract the signal connected to input[1] from the signal connected \n\t * to input[0]. If an argument is provided in the constructor, the \n\t * signals .value will be subtracted from the incoming signal.\n\t *\n\t * @extends {Tone.Signal}\n\t * @constructor\n\t * @param {number=} value The value to subtract from the incoming signal. If the value\n\t * is omitted, it will subtract the second signal from the first.\n\t * @example\n\t * var sub = new Tone.Subtract(1);\n\t * var sig = new Tone.Signal(4).connect(sub);\n\t * //the output of sub is 3. \n\t * @example\n\t * var sub = new Tone.Subtract();\n\t * var sigA = new Tone.Signal(10);\n\t * var sigB = new Tone.Signal(2.5);\n\t * sigA.connect(sub, 0, 0);\n\t * sigB.connect(sub, 0, 1);\n\t * //output of sub is 7.5\n\t */\n\tTone.Subtract = function(value){\n\n\t\tthis.createInsOuts(2, 0);\n\n\t\t/**\n\t\t * the summing node\n\t\t * @type {GainNode}\n\t\t * @private\n\t\t */\n\t\tthis._sum = this.input[0] = this.output = new Tone.Gain();\n\n\t\t/**\n\t\t * negate the input of the second input before connecting it\n\t\t * to the summing node.\n\t\t * @type {Tone.Negate}\n\t\t * @private\n\t\t */\n\t\tthis._neg = new Tone.Negate();\n\n\t\t/**\n\t\t * the node where the value is set\n\t\t * @private\n\t\t * @type {Tone.Signal}\n\t\t */\n\t\tthis._param = this.input[1] = new Tone.Signal(value);\n\n\t\tthis._param.chain(this._neg, this._sum);\n\t};\n\n\tTone.extend(Tone.Subtract, Tone.Signal);\n\n\t/**\n\t * Clean up.\n\t * @returns {Tone.SignalBase} this\n\t */\n\tTone.Subtract.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._neg.dispose();\n\t\tthis._neg = null;\n\t\tthis._sum.disconnect();\n\t\tthis._sum = null;\n\t\tthis._param.dispose();\n\t\tthis._param = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.Subtract;\n});","'use strict';\n\nglobal.TONE_SILENCE_VERSION_LOGGING = true;\n\ndefine(['startaudiocontext', 'Tone/core/Context', 'Tone/core/Tone'], function (StartAudioContext, Context, Tone) {\n // Create the Audio Context\n const audiocontext = new window.AudioContext();\n\n // Tone and p5.sound share the same audio context\n Tone.context.dispose();\n Tone.setContext(audiocontext);\n\n /**\n *

Returns the Audio Context for this sketch. Useful for users\n * who would like to dig deeper into the Web Audio API\n * .

\n *\n *

Some browsers require users to startAudioContext\n * with a user gesture, such as touchStarted in the example below.

\n *\n * @for p5\n * @method getAudioContext\n * @return {Object} AudioContext for this sketch\n * @example\n *
\n * function draw() {\n * background(255);\n * textAlign(CENTER);\n *\n * if (getAudioContext().state !== 'running') {\n * text('click to start audio', width/2, height/2);\n * } else {\n * text('audio is enabled', width/2, height/2);\n * }\n * }\n *\n * function touchStarted() {\n * if (getAudioContext().state !== 'running') {\n * getAudioContext().resume();\n * }\n * var synth = new p5.MonoSynth();\n * synth.play('A4', 0.5, 0, 0.2);\n * }\n *\n *
\n */\n p5.prototype.getAudioContext = function() {\n return audiocontext;\n };\n\n\n /**\n *

It is not only a good practice to give users control over starting\n * audio. This policy is enforced by many web browsers, including iOS and\n * Google Chrome, which create the Web Audio API's\n * Audio Context\n * in a suspended state.

\n *\n *

In these browser-specific policies, sound will not play until a user\n * interaction event (i.e. mousePressed()) explicitly resumes\n * the AudioContext, or starts an audio node. This can be accomplished by\n * calling start() on a p5.Oscillator,\n * play() on a p5.SoundFile, or simply\n * userStartAudio().

\n *\n *

userStartAudio() starts the AudioContext on a user\n * gesture. The default behavior will enable audio on any\n * mouseUp or touchEnd event. It can also be placed in a specific\n * interaction function, such as mousePressed() as in the\n * example below. This method utilizes\n * StartAudioContext\n * , a library by Yotam Mann (MIT Licence, 2016).

\n * @param {Element|Array} [element(s)] This argument can be an Element,\n * Selector String, NodeList, p5.Element,\n * jQuery Element, or an Array of any of those.\n * @param {Function} [callback] Callback to invoke when the AudioContext\n * has started\n * @return {Promise} Returns a Promise that resolves when\n * the AudioContext state is 'running'\n * @method userStartAudio\n * @for p5\n * @example\n *
\n * function setup() {\n * // mimics the autoplay policy\n * getAudioContext().suspend();\n *\n * let mySynth = new p5.MonoSynth();\n *\n * // This won't play until the context has resumed\n * mySynth.play('A6');\n * }\n * function draw() {\n * background(220);\n * textAlign(CENTER, CENTER);\n * text(getAudioContext().state, width/2, height/2);\n * }\n * function mousePressed() {\n * userStartAudio();\n * }\n *
\n */\n p5.prototype.userStartAudio = function(elements, callback) {\n var elt = elements;\n if (elements instanceof p5.Element) {\n elt = elements.elt;\n } else if (elements instanceof Array && elements[0] instanceof p5.Element ) {\n elt = elements.map(function(e) { return e.elt});\n }\n return StartAudioContext(audiocontext, elt, callback);\n };\n\n return audiocontext;\n});\n","define([\"Tone/core/Tone\"], function (Tone) {\n\n\t\"use strict\";\n\n\t/**\n\t * @class Tone.Emitter gives classes which extend it\n\t * the ability to listen for and emit events. \n\t * Inspiration and reference from Jerome Etienne's [MicroEvent](https://github.com/jeromeetienne/microevent.js).\n\t * MIT (c) 2011 Jerome Etienne.\n\t * \n\t * @extends {Tone}\n\t */\n\tTone.Emitter = function(){\n\t\t/**\n\t\t * Contains all of the events.\n\t\t * @private\n\t\t * @type {Object}\n\t\t */\n\t\tthis._events = {};\n\t};\n\n\tTone.extend(Tone.Emitter);\n\n\t/**\n\t * Bind a callback to a specific event.\n\t * @param {String} event The name of the event to listen for.\n\t * @param {Function} callback The callback to invoke when the\n\t * event is emitted\n\t * @return {Tone.Emitter} this\n\t */\n\tTone.Emitter.prototype.on = function(event, callback){\n\t\t//split the event\n\t\tvar events = event.split(/\\W+/);\n\t\tfor (var i = 0; i < events.length; i++){\n\t\t\tvar eventName = events[i];\n\t\t\tif (!this._events.hasOwnProperty(eventName)){\n\t\t\t\tthis._events[eventName] = [];\n\t\t\t}\n\t\t\tthis._events[eventName].push(callback);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Remove the event listener.\n\t * @param {String} event The event to stop listening to.\n\t * @param {Function=} callback The callback which was bound to \n\t * the event with Tone.Emitter.on.\n\t * If no callback is given, all callbacks\n\t * events are removed.\n\t * @return {Tone.Emitter} this\n\t */\n\tTone.Emitter.prototype.off = function(event, callback){\n\t\tvar events = event.split(/\\W+/);\n\t\tfor (var ev = 0; ev < events.length; ev++){\n\t\t\tevent = events[ev];\n\t\t\tif (this._events.hasOwnProperty(event)){\n\t\t\t\tif (Tone.prototype.isUndef(callback)){\n\t\t\t\t\tthis._events[event] = [];\n\t\t\t\t} else {\n\t\t\t\t\tvar eventList = this._events[event];\n\t\t\t\t\tfor (var i = 0; i < eventList.length; i++){\n\t\t\t\t\t\tif (eventList[i] === callback){\n\t\t\t\t\t\t\teventList.splice(i, 1);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Invoke all of the callbacks bound to the event\n\t * with any arguments passed in. \n\t * @param {String} event The name of the event.\n\t * @param {*...} args The arguments to pass to the functions listening.\n\t * @return {Tone.Emitter} this\n\t */\n\tTone.Emitter.prototype.emit = function(event){\n\t\tif (this._events){\n\t\t\tvar args = Array.apply(null, arguments).slice(1);\n\t\t\tif (this._events.hasOwnProperty(event)){\n\t\t\t\tvar eventList = this._events[event];\n\t\t\t\tfor (var i = 0, len = eventList.length; i < len; i++){\n\t\t\t\t\teventList[i].apply(this, args);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Add Emitter functions (on/off/emit) to the object\n\t * @param {Object|Function} object The object or class to extend.\n\t */\n\tTone.Emitter.mixin = function(object){\n\t\tvar functions = [\"on\", \"off\", \"emit\"];\n\t\tobject._events = {};\n\t\tfor (var i = 0; i < functions.length; i++){\n\t\t\tvar func = functions[i];\n\t\t\tvar emitterFunc = Tone.Emitter.prototype[func];\n\t\t\tobject[func] = emitterFunc;\n\t\t}\n\t};\n\n\t/**\n\t * Clean up\n\t * @return {Tone.Emitter} this\n\t */\n\tTone.Emitter.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._events = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.Emitter;\n});","define([\"Tone/core/Tone\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Base class for all Signals. Used Internally. \n\t *\n\t * @constructor\n\t * @extends {Tone}\n\t */\n\tTone.SignalBase = function(){};\n\n\tTone.extend(Tone.SignalBase);\n\n\t/**\n\t * When signals connect to other signals or AudioParams, \n\t * they take over the output value of that signal or AudioParam. \n\t * For all other nodes, the behavior is the same as a default connect. \n\t *\n\t * @override\n\t * @param {AudioParam|AudioNode|Tone.Signal|Tone} node \n\t * @param {number} [outputNumber=0] The output number to connect from.\n\t * @param {number} [inputNumber=0] The input number to connect to.\n\t * @returns {Tone.SignalBase} this\n\t */\n\tTone.SignalBase.prototype.connect = function(node, outputNumber, inputNumber){\n\t\t//zero it out so that the signal can have full control\n\t\tif ((Tone.Signal && Tone.Signal === node.constructor) || \n\t\t\t\t(Tone.Param && Tone.Param === node.constructor) || \n\t\t\t\t(Tone.TimelineSignal && Tone.TimelineSignal === node.constructor)){\n\t\t\t//cancel changes\n\t\t\tnode._param.cancelScheduledValues(0);\n\t\t\t//reset the value\n\t\t\tnode._param.value = 0;\n\t\t\t//mark the value as overridden\n\t\t\tnode.overridden = true;\n\t\t} else if (node instanceof AudioParam){\n\t\t\tnode.cancelScheduledValues(0);\n\t\t\tnode.value = 0;\n\t\t} \n\t\tTone.prototype.connect.call(this, node, outputNumber, inputNumber);\n\t\treturn this;\n\t};\n\n\treturn Tone.SignalBase;\n});","define([\"Tone/core/Tone\", \"Tone/type/TimeBase\"], function (Tone) {\n\n\t/**\n\t * @class Tone.Time is a primitive type for encoding Time values. \n\t * Eventually all time values are evaluated to seconds\n\t * using the `eval` method. Tone.Time can be constructed\n\t * with or without the `new` keyword. Tone.Time can be passed\n\t * into the parameter of any method which takes time as an argument. \n\t * @constructor\n\t * @extends {Tone.TimeBase}\n\t * @param {String|Number} val The time value.\n\t * @param {String=} units The units of the value.\n\t * @example\n\t * var t = Tone.Time(\"4n\");//encodes a quarter note\n\t * t.mult(4); // multiply that value by 4\n\t * t.toNotation(); //returns \"1m\"\n\t */\n\tTone.Time = function(val, units){\n\t\tif (this instanceof Tone.Time){\n\n\t\t\t/**\n\t\t\t * If the current clock time should\n\t\t\t * be added to the output\n\t\t\t * @type {Boolean}\n\t\t\t * @private\n\t\t\t */\n\t\t\tthis._plusNow = false;\n\t\t\t\n\t\t\tTone.TimeBase.call(this, val, units);\n\n\t\t} else {\n\t\t\treturn new Tone.Time(val, units);\n\t\t}\n\t};\n\n\tTone.extend(Tone.Time, Tone.TimeBase);\n\n\t//clone the expressions so that \n\t//we can add more without modifying the original\n\tTone.Time.prototype._unaryExpressions = Object.create(Tone.TimeBase.prototype._unaryExpressions);\n\n\t/*\n\t * Adds an additional unary expression\n\t * which quantizes values to the next subdivision\n\t * @type {Object}\n\t * @private\n\t */\n\tTone.Time.prototype._unaryExpressions.quantize = {\n\t\tregexp : /^@/,\n\t\tmethod : function(rh){\n\t\t\treturn Tone.Transport.nextSubdivision(rh());\n\t\t}\n\t};\n\n\t/*\n\t * Adds an additional unary expression\n\t * which adds the current clock time.\n\t * @type {Object}\n\t * @private\n\t */\n\tTone.Time.prototype._unaryExpressions.now = {\n\t\tregexp : /^\\+/,\n\t\tmethod : function(lh){\n\t\t\tthis._plusNow = true;\n\t\t\treturn lh();\n\t\t}\n\t};\n\n\t/**\n\t * Quantize the time by the given subdivision. Optionally add a\n\t * percentage which will move the time value towards the ideal\n\t * quantized value by that percentage. \n\t * @param {Number|Time} val The subdivision to quantize to\n\t * @param {NormalRange} [percent=1] Move the time value\n\t * towards the quantized value by\n\t * a percentage.\n\t * @return {Tone.Time} this\n\t * @example\n\t * Tone.Time(21).quantize(2) //returns 22\n\t * Tone.Time(0.6).quantize(\"4n\", 0.5) //returns 0.55\n\t */\n\tTone.Time.prototype.quantize = function(subdiv, percent){\n\t\tpercent = this.defaultArg(percent, 1);\n\t\tthis._expr = function(expr, subdivision, percent){\n\t\t\texpr = expr();\n\t\t\tsubdivision = subdivision.toSeconds();\n\t\t\tvar multiple = Math.round(expr / subdivision);\n\t\t\tvar ideal = multiple * subdivision;\n\t\t\tvar diff = ideal - expr;\n\t\t\treturn expr + diff * percent;\n\t\t}.bind(this, this._expr, new this.constructor(subdiv), percent);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Adds the clock time to the time expression at the \n\t * moment of evaluation. \n\t * @return {Tone.Time} this\n\t */\n\tTone.Time.prototype.addNow = function(){\n\t\tthis._plusNow = true;\n\t\treturn this;\n\t};\n\n\t/**\n\t * @override\n\t * Override the default value return when no arguments are passed in.\n\t * The default value is 'now'\n\t * @private\n\t */\n\tTone.Time.prototype._defaultExpr = function(){\n\t\tthis._plusNow = true;\n\t\treturn this._noOp;\n\t};\n\n\t/**\n\t * Copies the value of time to this Time\n\t * @param {Tone.Time} time\n\t * @return {Time}\n\t */\n\tTone.Time.prototype.copy = function(time){\n\t\tTone.TimeBase.prototype.copy.call(this, time);\n\t\tthis._plusNow = time._plusNow;\n\t\treturn this;\n\t};\n\n\t//CONVERSIONS//////////////////////////////////////////////////////////////\n\n\t/**\n\t * Convert a Time to Notation. Values will be thresholded to the nearest 128th note. \n\t * @return {Notation} \n\t * @example\n\t * //if the Transport is at 120bpm:\n\t * Tone.Time(2).toNotation();//returns \"1m\"\n\t */\n\tTone.Time.prototype.toNotation = function(){\n\t\tvar time = this.toSeconds();\n\t\tvar testNotations = [\"1m\", \"2n\", \"4n\", \"8n\", \"16n\", \"32n\", \"64n\", \"128n\"];\n\t\tvar retNotation = this._toNotationHelper(time, testNotations);\n\t\t//try the same thing but with tripelets\n\t\tvar testTripletNotations = [\"1m\", \"2n\", \"2t\", \"4n\", \"4t\", \"8n\", \"8t\", \"16n\", \"16t\", \"32n\", \"32t\", \"64n\", \"64t\", \"128n\"];\n\t\tvar retTripletNotation = this._toNotationHelper(time, testTripletNotations);\n\t\t//choose the simpler expression of the two\n\t\tif (retTripletNotation.split(\"+\").length < retNotation.split(\"+\").length){\n\t\t\treturn retTripletNotation;\n\t\t} else {\n\t\t\treturn retNotation;\n\t\t}\n\t};\n\n\t/**\n\t * Helper method for Tone.toNotation\n\t * @param {Number} units \n\t * @param {Array} testNotations\n\t * @return {String}\n\t * @private\n\t */\n\tTone.Time.prototype._toNotationHelper = function(units, testNotations){\n\t\t//the threshold is the last value in the array\n\t\tvar threshold = this._notationToUnits(testNotations[testNotations.length - 1]);\n\t\tvar retNotation = \"\";\n\t\tfor (var i = 0; i < testNotations.length; i++){\n\t\t\tvar notationTime = this._notationToUnits(testNotations[i]);\n\t\t\t//account for floating point errors (i.e. round up if the value is 0.999999)\n\t\t\tvar multiple = units / notationTime;\n\t\t\tvar floatingPointError = 0.000001;\n\t\t\tif (1 - multiple % 1 < floatingPointError){\n\t\t\t\tmultiple += floatingPointError;\n\t\t\t}\n\t\t\tmultiple = Math.floor(multiple);\n\t\t\tif (multiple > 0){\n\t\t\t\tif (multiple === 1){\n\t\t\t\t\tretNotation += testNotations[i];\n\t\t\t\t} else {\n\t\t\t\t\tretNotation += multiple.toString() + \"*\" + testNotations[i];\n\t\t\t\t}\n\t\t\t\tunits -= multiple * notationTime;\n\t\t\t\tif (units < threshold){\n\t\t\t\t\tbreak;\n\t\t\t\t} else {\n\t\t\t\t\tretNotation += \" + \";\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (retNotation === \"\"){\n\t\t\tretNotation = \"0\";\n\t\t}\n\t\treturn retNotation;\n\t};\n\n\t/**\n\t * Convert a notation value to the current units\n\t * @param {Notation} notation \n\t * @return {Number} \n\t * @private\n\t */\n\tTone.Time.prototype._notationToUnits = function(notation){\n\t\tvar primaryExprs = this._primaryExpressions;\n\t\tvar notationExprs = [primaryExprs.n, primaryExprs.t, primaryExprs.m];\n\t\tfor (var i = 0; i < notationExprs.length; i++){\n\t\t\tvar expr = notationExprs[i];\n\t\t\tvar match = notation.match(expr.regexp);\n\t\t\tif (match){\n\t\t\t\treturn expr.method.call(this, match[1]);\n\t\t\t}\n\t\t}\n\t};\n\n\t/**\n\t * Return the time encoded as Bars:Beats:Sixteenths.\n\t * @return {BarsBeatsSixteenths}\n\t */\n\tTone.Time.prototype.toBarsBeatsSixteenths = function(){\n\t\tvar quarterTime = this._beatsToUnits(1);\n\t\tvar quarters = this.toSeconds() / quarterTime;\n\t\tvar measures = Math.floor(quarters / this._timeSignature());\n\t\tvar sixteenths = (quarters % 1) * 4;\n\t\tquarters = Math.floor(quarters) % this._timeSignature();\n\t\tsixteenths = sixteenths.toString();\n\t\tif (sixteenths.length > 3){\n\t\t\tsixteenths = parseFloat(sixteenths).toFixed(3);\n\t\t}\n\t\tvar progress = [measures, quarters, sixteenths];\n\t\treturn progress.join(\":\");\n\t};\n\n\t/**\n\t * Return the time in ticks.\n\t * @return {Ticks}\n\t */\n\tTone.Time.prototype.toTicks = function(){\n\t\tvar quarterTime = this._beatsToUnits(1);\n\t\tvar quarters = this.valueOf() / quarterTime;\n\t\treturn Math.floor(quarters * Tone.Transport.PPQ);\n\t};\n\n\t/**\n\t * Return the time in samples\n\t * @return {Samples} \n\t */\n\tTone.Time.prototype.toSamples = function(){\n\t\treturn this.toSeconds() * this.context.sampleRate;\n\t};\n\n\t/**\n\t * Return the time as a frequency value\n\t * @return {Frequency} \n\t * @example\n\t * Tone.Time(2).toFrequency(); //0.5\n\t */\n\tTone.Time.prototype.toFrequency = function(){\n\t\treturn 1/this.toSeconds();\n\t};\n\n\t/**\n\t * Return the time in seconds.\n\t * @return {Seconds} \n\t */\n\tTone.Time.prototype.toSeconds = function(){\n\t\treturn this.valueOf();\n\t};\n\n\t/**\n\t * Return the time in milliseconds.\n\t * @return {Milliseconds} \n\t */\n\tTone.Time.prototype.toMilliseconds = function(){\n\t\treturn this.toSeconds() * 1000;\n\t};\n\n\t/**\n\t * Return the time in seconds.\n\t * @return {Seconds} \n\t */\n\tTone.Time.prototype.valueOf = function(){\n\t\tvar val = this._expr();\n\t\treturn val + (this._plusNow?this.now():0);\n\t};\n\n\treturn Tone.Time;\n});","define([\"Tone/core/Tone\"], function (Tone) {\n\n\t/**\n\t * @class Tone.TimeBase is a flexible encoding of time\n\t * which can be evaluated to and from a string.\n\t * Parsing code modified from https://code.google.com/p/tapdigit/\n\t * Copyright 2011 2012 Ariya Hidayat, New BSD License\n\t * @extends {Tone}\n\t * @param {Time} val The time value as a number or string\n\t * @param {String=} units Unit values\n\t * @example\n\t * Tone.TimeBase(4, \"n\")\n\t * Tone.TimeBase(2, \"t\")\n\t * Tone.TimeBase(\"2t\").add(\"1m\")\n\t * Tone.TimeBase(\"2t + 1m\");\n\t */\n\tTone.TimeBase = function(val, units){\n\n\t\t//allows it to be constructed with or without 'new'\n\t\tif (this instanceof Tone.TimeBase) {\n\n\t\t\t/**\n\t\t\t * Any expressions parsed from the Time\n\t\t\t * @type {Array}\n\t\t\t * @private\n\t\t\t */\n\t\t\tthis._expr = this._noOp;\n\n\t\t\tif (val instanceof Tone.TimeBase){\n\t\t\t\tthis.copy(val);\n\t\t\t} else if (!this.isUndef(units) || this.isNumber(val)){\n\t\t\t\t//default units\n\t\t\t\tunits = this.defaultArg(units, this._defaultUnits);\n\t\t\t\tvar method = this._primaryExpressions[units].method;\n\t\t\t\tthis._expr = method.bind(this, val);\n\t\t\t} else if (this.isString(val)){\n\t\t\t\tthis.set(val);\n\t\t\t} else if (this.isUndef(val)){\n\t\t\t\t//default expression\n\t\t\t\tthis._expr = this._defaultExpr();\n\t\t\t}\n\t\t} else {\n\n\t\t\treturn new Tone.TimeBase(val, units);\n\t\t}\n\t};\n\n\tTone.extend(Tone.TimeBase);\n\n\t/**\n\t * Repalce the current time value with the value\n\t * given by the expression string.\n\t * @param {String} exprString\n\t * @return {Tone.TimeBase} this\n\t */\n\tTone.TimeBase.prototype.set = function(exprString){\n\t\tthis._expr = this._parseExprString(exprString);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Return a clone of the TimeBase object.\n\t * @return {Tone.TimeBase} The new cloned Tone.TimeBase\n\t */\n\tTone.TimeBase.prototype.clone = function(){\n\t\tvar instance = new this.constructor();\n\t\tinstance.copy(this);\n\t\treturn instance;\n\t};\n\n\t/**\n\t * Copies the value of time to this Time\n\t * @param {Tone.TimeBase} time\n\t * @return {TimeBase}\n\t */\n\tTone.TimeBase.prototype.copy = function(time){\n\t\tvar val = time._expr();\n\t\treturn this.set(val);\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tABSTRACT SYNTAX TREE PARSER\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * All the primary expressions.\n\t * @private\n\t * @type {Object}\n\t */\n\tTone.TimeBase.prototype._primaryExpressions = {\n\t\t\"n\" : {\n\t\t\tregexp : /^(\\d+)n/i,\n\t\t\tmethod : function(value){\n\t\t\t\tvalue = parseInt(value);\n\t\t\t\tif (value === 1){\n\t\t\t\t\treturn this._beatsToUnits(this._timeSignature());\n\t\t\t\t} else {\n\t\t\t\t\treturn this._beatsToUnits(4 / value);\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\t\"t\" : {\n\t\t\tregexp : /^(\\d+)t/i,\n\t\t\tmethod : function(value){\n\t\t\t\tvalue = parseInt(value);\n\t\t\t\treturn this._beatsToUnits(8 / (parseInt(value) * 3));\n\t\t\t}\n\t\t},\n\t\t\"m\" : {\n\t\t\tregexp : /^(\\d+)m/i,\n\t\t\tmethod : function(value){\n\t\t\t\treturn this._beatsToUnits(parseInt(value) * this._timeSignature());\n\t\t\t}\n\t\t},\n\t\t\"i\" : {\n\t\t\tregexp : /^(\\d+)i/i,\n\t\t\tmethod : function(value){\n\t\t\t\treturn this._ticksToUnits(parseInt(value));\n\t\t\t}\n\t\t},\n\t\t\"hz\" : {\n\t\t\tregexp : /^(\\d+(?:\\.\\d+)?)hz/i,\n\t\t\tmethod : function(value){\n\t\t\t\treturn this._frequencyToUnits(parseFloat(value));\n\t\t\t}\n\t\t},\n\t\t\"tr\" : {\n\t\t\tregexp : /^(\\d+(?:\\.\\d+)?):(\\d+(?:\\.\\d+)?):?(\\d+(?:\\.\\d+)?)?/,\n\t\t\tmethod : function(m, q, s){\n\t\t\t\tvar total = 0;\n\t\t\t\tif (m && m !== \"0\"){\n\t\t\t\t\ttotal += this._beatsToUnits(this._timeSignature() * parseFloat(m));\n\t\t\t\t}\n\t\t\t\tif (q && q !== \"0\"){\n\t\t\t\t\ttotal += this._beatsToUnits(parseFloat(q));\n\t\t\t\t}\n\t\t\t\tif (s && s !== \"0\"){\n\t\t\t\t\ttotal += this._beatsToUnits(parseFloat(s) / 4);\n\t\t\t\t}\n\t\t\t\treturn total;\n\t\t\t}\n\t\t},\n\t\t\"s\" : {\n\t\t\tregexp : /^(\\d+(?:\\.\\d+)?s)/,\n\t\t\tmethod : function(value){\n\t\t\t\treturn this._secondsToUnits(parseFloat(value));\n\t\t\t}\n\t\t},\n\t\t\"samples\" : {\n\t\t\tregexp : /^(\\d+)samples/,\n\t\t\tmethod : function(value){\n\t\t\t\treturn parseInt(value) / this.context.sampleRate;\n\t\t\t}\n\t\t},\n\t\t\"default\" : {\n\t\t\tregexp : /^(\\d+(?:\\.\\d+)?)/,\n\t\t\tmethod : function(value){\n\t\t\t\treturn this._primaryExpressions[this._defaultUnits].method.call(this, value);\n\t\t\t}\n\t\t}\n\t};\n\n\t/**\n\t * All the binary expressions that TimeBase can accept.\n\t * @private\n\t * @type {Object}\n\t */\n\tTone.TimeBase.prototype._binaryExpressions = {\n\t\t\"+\" : {\n\t\t\tregexp : /^\\+/,\n\t\t\tprecedence : 2,\n\t\t\tmethod : function(lh, rh){\n\t\t\t\treturn lh() + rh();\n\t\t\t}\n\t\t},\n\t\t\"-\" : {\n\t\t\tregexp : /^\\-/,\n\t\t\tprecedence : 2,\n\t\t\tmethod : function(lh, rh){\n\t\t\t\treturn lh() - rh();\n\t\t\t}\n\t\t},\n\t\t\"*\" : {\n\t\t\tregexp : /^\\*/,\n\t\t\tprecedence : 1,\n\t\t\tmethod : function(lh, rh){\n\t\t\t\treturn lh() * rh();\n\t\t\t}\n\t\t},\n\t\t\"/\" : {\n\t\t\tregexp : /^\\//,\n\t\t\tprecedence : 1,\n\t\t\tmethod : function(lh, rh){\n\t\t\t\treturn lh() / rh();\n\t\t\t}\n\t\t}\n\t};\n\n\t/**\n\t * All the unary expressions.\n\t * @private\n\t * @type {Object}\n\t */\n\tTone.TimeBase.prototype._unaryExpressions = {\n\t\t\"neg\" : {\n\t\t\tregexp : /^\\-/,\n\t\t\tmethod : function(lh){\n\t\t\t\treturn -lh();\n\t\t\t}\n\t\t}\n\t};\n\n\t/**\n\t * Syntactic glue which holds expressions together\n\t * @private\n\t * @type {Object}\n\t */\n\tTone.TimeBase.prototype._syntaxGlue = {\n\t\t\"(\" : {\n\t\t\tregexp : /^\\(/\n\t\t},\n\t\t\")\" : {\n\t\t\tregexp : /^\\)/\n\t\t}\n\t};\n\n\t/**\n\t * tokenize the expression based on the Expressions object\n\t * @param {string} expr \n\t * @return {Object} returns two methods on the tokenized list, next and peek\n\t * @private\n\t */\n\tTone.TimeBase.prototype._tokenize = function(expr){\n\t\tvar position = -1;\n\t\tvar tokens = [];\n\n\t\twhile(expr.length > 0){\n\t\t\texpr = expr.trim();\n\t\t\tvar token = getNextToken(expr, this);\n\t\t\ttokens.push(token);\n\t\t\texpr = expr.substr(token.value.length);\n\t\t}\n\n\t\tfunction getNextToken(expr, context){\n\t\t\tvar expressions = [\"_binaryExpressions\", \"_unaryExpressions\", \"_primaryExpressions\", \"_syntaxGlue\"];\n\t\t\tfor (var i = 0; i < expressions.length; i++){\n\t\t\t\tvar group = context[expressions[i]];\n\t\t\t\tfor (var opName in group){\n\t\t\t\t\tvar op = group[opName];\n\t\t\t\t\tvar reg = op.regexp;\n\t\t\t\t\tvar match = expr.match(reg);\n\t\t\t\t\tif (match !== null){\n\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\tmethod : op.method,\n\t\t\t\t\t\t\tprecedence : op.precedence,\n\t\t\t\t\t\t\tregexp : op.regexp,\n\t\t\t\t\t\t\tvalue : match[0],\n\t\t\t\t\t\t};\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tthrow new SyntaxError(\"Tone.TimeBase: Unexpected token \"+expr);\n\t\t}\n\n\t\treturn {\n\t\t\tnext : function(){\n\t\t\t\treturn tokens[++position];\n\t\t\t},\n\t\t\tpeek : function(){\n\t\t\t\treturn tokens[position + 1];\n\t\t\t}\n\t\t};\n\t};\n\n\t/**\n\t * Given a token, find the value within the groupName\n\t * @param {Object} token\n\t * @param {String} groupName\n\t * @param {Number} precedence\n\t * @private\n\t */\n\tTone.TimeBase.prototype._matchGroup = function(token, group, prec) {\n\t\tvar ret = false;\n\t\tif (!this.isUndef(token)){\n\t\t\tfor (var opName in group){\n\t\t\t\tvar op = group[opName];\n\t\t\t\tif (op.regexp.test(token.value)){\n\t\t\t\t\tif (!this.isUndef(prec)){\n\t\t\t\t\t\tif(op.precedence === prec){\t\n\t\t\t\t\t\t\treturn op;\n\t\t\t\t\t\t}\n\t\t\t\t\t} else {\n\t\t\t\t\t\treturn op;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn ret;\n\t};\n\n\t/**\n\t * Match a binary expression given the token and the precedence\n\t * @param {Lexer} lexer\n\t * @param {Number} precedence\n\t * @private\n\t */\n\tTone.TimeBase.prototype._parseBinary = function(lexer, precedence){\n\t\tif (this.isUndef(precedence)){\n\t\t\tprecedence = 2;\n\t\t}\n\t\tvar expr;\n\t\tif (precedence < 0){\n\t\t\texpr = this._parseUnary(lexer);\n\t\t} else {\n\t\t\texpr = this._parseBinary(lexer, precedence - 1);\n\t\t}\n\t\tvar token = lexer.peek();\n\t\twhile (token && this._matchGroup(token, this._binaryExpressions, precedence)){\n\t\t\ttoken = lexer.next();\n\t\t\texpr = token.method.bind(this, expr, this._parseBinary(lexer, precedence - 1));\n\t\t\ttoken = lexer.peek();\n\t\t}\n\t\treturn expr;\n\t};\n\n\t/**\n\t * Match a unary expression.\n\t * @param {Lexer} lexer\n\t * @private\n\t */\n\tTone.TimeBase.prototype._parseUnary = function(lexer){\n\t\tvar token, expr;\n\t\ttoken = lexer.peek();\n\t\tvar op = this._matchGroup(token, this._unaryExpressions);\n\t\tif (op) {\n\t\t\ttoken = lexer.next();\n\t\t\texpr = this._parseUnary(lexer);\n\t\t\treturn op.method.bind(this, expr);\n\t\t}\n\t\treturn this._parsePrimary(lexer);\n\t};\n\n\t/**\n\t * Match a primary expression (a value).\n\t * @param {Lexer} lexer\n\t * @private\n\t */\n\tTone.TimeBase.prototype._parsePrimary = function(lexer){\n\t\tvar token, expr;\n\t\ttoken = lexer.peek();\n\t\tif (this.isUndef(token)) {\n\t\t\tthrow new SyntaxError(\"Tone.TimeBase: Unexpected end of expression\");\n\t\t}\n\t\tif (this._matchGroup(token, this._primaryExpressions)) {\n\t\t\ttoken = lexer.next();\n\t\t\tvar matching = token.value.match(token.regexp);\n\t\t\treturn token.method.bind(this, matching[1], matching[2], matching[3]);\n\t\t}\n\t\tif (token && token.value === \"(\"){\n\t\t\tlexer.next();\n\t\t\texpr = this._parseBinary(lexer);\n\t\t\ttoken = lexer.next();\n\t\t\tif (!(token && token.value === \")\")) {\n\t\t\t\tthrow new SyntaxError(\"Expected )\");\n\t\t\t}\n\t\t\treturn expr;\n\t\t}\n\t\tthrow new SyntaxError(\"Tone.TimeBase: Cannot process token \" + token.value);\n\t};\n\n\t/**\n\t * Recursively parse the string expression into a syntax tree.\n\t * @param {string} expr \n\t * @return {Function} the bound method to be evaluated later\n\t * @private\n\t */\n\tTone.TimeBase.prototype._parseExprString = function(exprString){\n\t\tif (!this.isString(exprString)){\n\t\t\texprString = exprString.toString();\n\t\t}\n\t\tvar lexer = this._tokenize(exprString);\n\t\tvar tree = this._parseBinary(lexer);\n\t\treturn tree;\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tDEFAULTS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * The initial expression value\n\t * @return {Number} The initial value 0\n\t * @private\n\t */\n\tTone.TimeBase.prototype._noOp = function(){\n\t\treturn 0;\n\t};\n\n\t/**\n\t * The default expression value if no arguments are given\n\t * @private\n\t */\n\tTone.TimeBase.prototype._defaultExpr = function(){\n\t\treturn this._noOp;\n\t};\n\n\t/**\n\t * The default units if none are given.\n\t * @private\n\t */\n\tTone.TimeBase.prototype._defaultUnits = \"s\";\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tUNIT CONVERSIONS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Returns the value of a frequency in the current units\n\t * @param {Frequency} freq\n\t * @return {Number}\n\t * @private\n\t */\n\tTone.TimeBase.prototype._frequencyToUnits = function(freq){\n\t\treturn 1/freq;\n\t};\n\n\t/**\n\t * Return the value of the beats in the current units\n\t * @param {Number} beats\n\t * @return {Number}\n\t * @private\n\t */\n\tTone.TimeBase.prototype._beatsToUnits = function(beats){\n\t\treturn (60 / Tone.Transport.bpm.value) * beats;\n\t};\n\n\t/**\n\t * Returns the value of a second in the current units\n\t * @param {Seconds} seconds\n\t * @return {Number}\n\t * @private\n\t */\n\tTone.TimeBase.prototype._secondsToUnits = function(seconds){\n\t\treturn seconds;\n\t};\n\n\t/**\n\t * Returns the value of a tick in the current time units\n\t * @param {Ticks} ticks\n\t * @return {Number}\n\t * @private\n\t */\n\tTone.TimeBase.prototype._ticksToUnits = function(ticks){\n\t\treturn ticks * (this._beatsToUnits(1) / Tone.Transport.PPQ);\n\t};\n\n\t/**\n\t * Return the time signature.\n\t * @return {Number}\n\t * @private\n\t */\n\tTone.TimeBase.prototype._timeSignature = function(){\n\t\treturn Tone.Transport.timeSignature;\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tEXPRESSIONS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Push an expression onto the expression list\n\t * @param {Time} val\n\t * @param {String} type\n\t * @param {String} units\n\t * @return {Tone.TimeBase} \n\t * @private\n\t */\n\tTone.TimeBase.prototype._pushExpr = function(val, name, units){\n\t\t//create the expression\n\t\tif (!(val instanceof Tone.TimeBase)){\n\t\t\tval = new this.constructor(val, units);\n\t\t}\n\t\tthis._expr = this._binaryExpressions[name].method.bind(this, this._expr, val._expr);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Add to the current value.\n\t * @param {Time} val The value to add\n\t * @param {String=} units Optional units to use with the value.\n\t * @return {Tone.TimeBase} this\n\t * @example\n\t * Tone.TimeBase(\"2m\").add(\"1m\"); //\"3m\"\n\t */\n\tTone.TimeBase.prototype.add = function(val, units){\n\t\treturn this._pushExpr(val, \"+\", units);\n\t};\n\n\t/**\n\t * Subtract the value from the current time.\n\t * @param {Time} val The value to subtract\n\t * @param {String=} units Optional units to use with the value.\n\t * @return {Tone.TimeBase} this\n\t * @example\n\t * Tone.TimeBase(\"2m\").sub(\"1m\"); //\"1m\"\n\t */\n\tTone.TimeBase.prototype.sub = function(val, units){\n\t\treturn this._pushExpr(val, \"-\", units);\n\t};\n\n\t/**\n\t * Multiply the current value by the given time.\n\t * @param {Time} val The value to multiply\n\t * @param {String=} units Optional units to use with the value.\n\t * @return {Tone.TimeBase} this\n\t * @example\n\t * Tone.TimeBase(\"2m\").mult(\"2\"); //\"4m\"\n\t */\n\tTone.TimeBase.prototype.mult = function(val, units){\n\t\treturn this._pushExpr(val, \"*\", units);\n\t};\n\n\t/**\n\t * Divide the current value by the given time.\n\t * @param {Time} val The value to divide by\n\t * @param {String=} units Optional units to use with the value.\n\t * @return {Tone.TimeBase} this\n\t * @example\n\t * Tone.TimeBase(\"2m\").div(2); //\"1m\"\n\t */\n\tTone.TimeBase.prototype.div = function(val, units){\n\t\treturn this._pushExpr(val, \"/\", units);\n\t};\n\n\t/**\n\t * Evaluate the time value. Returns the time\n\t * in seconds.\n\t * @return {Seconds} \n\t */\n\tTone.TimeBase.prototype.valueOf = function(){\n\t\treturn this._expr();\n\t};\n\n\t/**\n\t * Clean up\n\t * @return {Tone.TimeBase} this\n\t */\n\tTone.TimeBase.prototype.dispose = function(){\n\t\tthis._expr = null;\n\t};\n\n\treturn Tone.TimeBase;\n});","define([\"Tone/core/Tone\", \"Tone/type/Type\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Tone.Param wraps the native Web Audio's AudioParam to provide\n\t * additional unit conversion functionality. It also\n\t * serves as a base-class for classes which have a single,\n\t * automatable parameter. \n\t * @extends {Tone}\n\t * @param {AudioParam} param The parameter to wrap.\n\t * @param {Tone.Type} units The units of the audio param.\n\t * @param {Boolean} convert If the param should be converted.\n\t */\n\tTone.Param = function(){\n\n\t\tvar options = this.optionsObject(arguments, [\"param\", \"units\", \"convert\"], Tone.Param.defaults);\n\n\t\t/**\n\t\t * The native parameter to control\n\t\t * @type {AudioParam}\n\t\t * @private\n\t\t */\n\t\tthis._param = this.input = options.param;\n\n\t\t/**\n\t\t * The units of the parameter\n\t\t * @type {Tone.Type}\n\t\t */\n\t\tthis.units = options.units;\n\n\t\t/**\n\t\t * If the value should be converted or not\n\t\t * @type {Boolean}\n\t\t */\n\t\tthis.convert = options.convert;\n\n\t\t/**\n\t\t * True if the signal value is being overridden by \n\t\t * a connected signal.\n\t\t * @readOnly\n\t\t * @type {boolean}\n\t\t * @private\n\t\t */\n\t\tthis.overridden = false;\n\n\t\t/**\n\t\t * If there is an LFO, this is where it is held.\n\t\t * @type {Tone.LFO}\n\t\t * @private\n\t\t */\n\t\tthis._lfo = null;\n\n\t\tif (this.isObject(options.lfo)){\n\t\t\tthis.value = options.lfo;\n\t\t} else if (!this.isUndef(options.value)){\n\t\t\tthis.value = options.value;\n\t\t}\n\t};\n\n\tTone.extend(Tone.Param);\n\t\n\t/**\n\t * Defaults\n\t * @type {Object}\n\t * @const\n\t */\n\tTone.Param.defaults = {\n\t\t\"units\" : Tone.Type.Default,\n\t\t\"convert\" : true,\n\t\t\"param\" : undefined\n\t};\n\n\t/**\n\t * The current value of the parameter. \n\t * @memberOf Tone.Param#\n\t * @type {Number}\n\t * @name value\n\t */\n\tObject.defineProperty(Tone.Param.prototype, \"value\", {\n\t\tget : function(){\n\t\t\treturn this._toUnits(this._param.value);\n\t\t},\n\t\tset : function(value){\n\t\t\tif (this.isObject(value)){\n\t\t\t\t//throw an error if the LFO needs to be included\n\t\t\t\tif (this.isUndef(Tone.LFO)){\n\t\t\t\t\tthrow new Error(\"Include 'Tone.LFO' to use an LFO as a Param value.\");\n\t\t\t\t}\n\t\t\t\t//remove the old one\n\t\t\t\tif (this._lfo){\n\t\t\t\t\tthis._lfo.dispose();\n\t\t\t\t}\n\t\t\t\tthis._lfo = new Tone.LFO(value).start();\n\t\t\t\tthis._lfo.connect(this.input);\n\t\t\t} else {\n\t\t\t\tvar convertedVal = this._fromUnits(value);\n\t\t\t\tthis._param.cancelScheduledValues(0);\n\t\t\t\tthis._param.value = convertedVal;\n\t\t\t}\n\t\t}\n\t});\n\n\t/**\n\t * Convert the given value from the type specified by Tone.Param.units\n\t * into the destination value (such as Gain or Frequency).\n\t * @private\n\t * @param {*} val the value to convert\n\t * @return {number} the number which the value should be set to\n\t */\n\tTone.Param.prototype._fromUnits = function(val){\n\t\tif (this.convert || this.isUndef(this.convert)){\n\t\t\tswitch(this.units){\n\t\t\t\tcase Tone.Type.Time: \n\t\t\t\t\treturn this.toSeconds(val);\n\t\t\t\tcase Tone.Type.Frequency: \n\t\t\t\t\treturn this.toFrequency(val);\n\t\t\t\tcase Tone.Type.Decibels: \n\t\t\t\t\treturn this.dbToGain(val);\n\t\t\t\tcase Tone.Type.NormalRange: \n\t\t\t\t\treturn Math.min(Math.max(val, 0), 1);\n\t\t\t\tcase Tone.Type.AudioRange: \n\t\t\t\t\treturn Math.min(Math.max(val, -1), 1);\n\t\t\t\tcase Tone.Type.Positive: \n\t\t\t\t\treturn Math.max(val, 0);\n\t\t\t\tdefault:\n\t\t\t\t\treturn val;\n\t\t\t}\n\t\t} else {\n\t\t\treturn val;\n\t\t}\n\t};\n\n\t/**\n\t * Convert the parameters value into the units specified by Tone.Param.units.\n\t * @private\n\t * @param {number} val the value to convert\n\t * @return {number}\n\t */\n\tTone.Param.prototype._toUnits = function(val){\n\t\tif (this.convert || this.isUndef(this.convert)){\n\t\t\tswitch(this.units){\n\t\t\t\tcase Tone.Type.Decibels: \n\t\t\t\t\treturn this.gainToDb(val);\n\t\t\t\tdefault:\n\t\t\t\t\treturn val;\n\t\t\t}\n\t\t} else {\n\t\t\treturn val;\n\t\t}\n\t};\n\n\t/**\n\t * the minimum output value\n\t * @type {Number}\n\t * @private\n\t */\n\tTone.Param.prototype._minOutput = 0.00001;\n\n\t/**\n\t * Schedules a parameter value change at the given time.\n\t * @param {*}\tvalue The value to set the signal.\n\t * @param {Time} time The time when the change should occur.\n\t * @returns {Tone.Param} this\n\t * @example\n\t * //set the frequency to \"G4\" in exactly 1 second from now. \n\t * freq.setValueAtTime(\"G4\", \"+1\");\n\t */\n\tTone.Param.prototype.setValueAtTime = function(value, time){\n\t\tvalue = this._fromUnits(value);\n\t\ttime = this.toSeconds(time);\n\t\tif (time <= this.now() + this.blockTime){\n\t\t\tthis._param.value = value;\n\t\t} else {\n\t\t\tthis._param.setValueAtTime(value, time);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Creates a schedule point with the current value at the current time.\n\t * This is useful for creating an automation anchor point in order to \n\t * schedule changes from the current value. \n\t *\n\t * @param {number=} now (Optionally) pass the now value in. \n\t * @returns {Tone.Param} this\n\t */\n\tTone.Param.prototype.setRampPoint = function(now){\n\t\tnow = this.defaultArg(now, this.now());\n\t\tvar currentVal = this._param.value;\n\t\t// exponentialRampToValueAt cannot ever ramp from or to 0\n\t\t// More info: https://bugzilla.mozilla.org/show_bug.cgi?id=1125600#c2\n\t\tif (currentVal === 0){\n\t\t\tcurrentVal = this._minOutput;\n\t\t}\n\t\tthis._param.setValueAtTime(currentVal, now);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Schedules a linear continuous change in parameter value from the \n\t * previous scheduled parameter value to the given value.\n\t * \n\t * @param {number} value \n\t * @param {Time} endTime \n\t * @returns {Tone.Param} this\n\t */\n\tTone.Param.prototype.linearRampToValueAtTime = function(value, endTime){\n\t\tvalue = this._fromUnits(value);\n\t\tthis._param.linearRampToValueAtTime(value, this.toSeconds(endTime));\n\t\treturn this;\n\t};\n\n\t/**\n\t * Schedules an exponential continuous change in parameter value from \n\t * the previous scheduled parameter value to the given value.\n\t * \n\t * @param {number} value \n\t * @param {Time} endTime \n\t * @returns {Tone.Param} this\n\t */\n\tTone.Param.prototype.exponentialRampToValueAtTime = function(value, endTime){\n\t\tvalue = this._fromUnits(value);\n\t\tvalue = Math.max(this._minOutput, value);\n\t\tthis._param.exponentialRampToValueAtTime(value, this.toSeconds(endTime));\n\t\treturn this;\n\t};\n\n\t/**\n\t * Schedules an exponential continuous change in parameter value from \n\t * the current time and current value to the given value over the \n\t * duration of the rampTime.\n\t * \n\t * @param {number} value The value to ramp to.\n\t * @param {Time} rampTime the time that it takes the \n\t * value to ramp from it's current value\n\t * @param {Time}\t[startTime=now] \tWhen the ramp should start. \n\t * @returns {Tone.Param} this\n\t * @example\n\t * //exponentially ramp to the value 2 over 4 seconds. \n\t * signal.exponentialRampToValue(2, 4);\n\t */\n\tTone.Param.prototype.exponentialRampToValue = function(value, rampTime, startTime){\n\t\tstartTime = this.toSeconds(startTime);\n\t\tthis.setRampPoint(startTime);\n\t\tthis.exponentialRampToValueAtTime(value, startTime + this.toSeconds(rampTime));\n\t\treturn this;\n\t};\n\n\t/**\n\t * Schedules an linear continuous change in parameter value from \n\t * the current time and current value to the given value over the \n\t * duration of the rampTime.\n\t * \n\t * @param {number} value The value to ramp to.\n\t * @param {Time} rampTime the time that it takes the \n\t * value to ramp from it's current value\n\t * @param {Time}\t[startTime=now] \tWhen the ramp should start. \n\t * @returns {Tone.Param} this\n\t * @example\n\t * //linearly ramp to the value 4 over 3 seconds. \n\t * signal.linearRampToValue(4, 3);\n\t */\n\tTone.Param.prototype.linearRampToValue = function(value, rampTime, startTime){\n\t\tstartTime = this.toSeconds(startTime);\n\t\tthis.setRampPoint(startTime);\n\t\tthis.linearRampToValueAtTime(value, startTime + this.toSeconds(rampTime));\n\t\treturn this;\n\t};\n\n\t/**\n\t * Start exponentially approaching the target value at the given time with\n\t * a rate having the given time constant.\n\t * @param {number} value \n\t * @param {Time} startTime \n\t * @param {number} timeConstant \n\t * @returns {Tone.Param} this \n\t */\n\tTone.Param.prototype.setTargetAtTime = function(value, startTime, timeConstant){\n\t\tvalue = this._fromUnits(value);\n\t\t// The value will never be able to approach without timeConstant > 0.\n\t\t// http://www.w3.org/TR/webaudio/#dfn-setTargetAtTime, where the equation\n\t\t// is described. 0 results in a division by 0.\n\t\tvalue = Math.max(this._minOutput, value);\n\t\ttimeConstant = Math.max(this._minOutput, timeConstant);\n\t\tthis._param.setTargetAtTime(value, this.toSeconds(startTime), timeConstant);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Sets an array of arbitrary parameter values starting at the given time\n\t * for the given duration.\n\t * \t\n\t * @param {Array} values \n\t * @param {Time} startTime \n\t * @param {Time} duration \n\t * @returns {Tone.Param} this\n\t */\n\tTone.Param.prototype.setValueCurveAtTime = function(values, startTime, duration){\n\t\tfor (var i = 0; i < values.length; i++){\n\t\t\tvalues[i] = this._fromUnits(values[i]);\n\t\t}\n\t\tthis._param.setValueCurveAtTime(values, this.toSeconds(startTime), this.toSeconds(duration));\n\t\treturn this;\n\t};\n\n\t/**\n\t * Cancels all scheduled parameter changes with times greater than or \n\t * equal to startTime.\n\t * \n\t * @param {Time} startTime\n\t * @returns {Tone.Param} this\n\t */\n\tTone.Param.prototype.cancelScheduledValues = function(startTime){\n\t\tthis._param.cancelScheduledValues(this.toSeconds(startTime));\n\t\treturn this;\n\t};\n\n\t/**\n\t * Ramps to the given value over the duration of the rampTime. \n\t * Automatically selects the best ramp type (exponential or linear)\n\t * depending on the `units` of the signal\n\t * \n\t * @param {number} value \n\t * @param {Time} rampTime \tThe time that it takes the \n\t * value to ramp from it's current value\n\t * @param {Time}\t[startTime=now] \tWhen the ramp should start. \n\t * @returns {Tone.Param} this\n\t * @example\n\t * //ramp to the value either linearly or exponentially \n\t * //depending on the \"units\" value of the signal\n\t * signal.rampTo(0, 10);\n\t * @example\n\t * //schedule it to ramp starting at a specific time\n\t * signal.rampTo(0, 10, 5)\n\t */\n\tTone.Param.prototype.rampTo = function(value, rampTime, startTime){\n\t\trampTime = this.defaultArg(rampTime, 0);\n\t\tif (this.units === Tone.Type.Frequency || this.units === Tone.Type.BPM || this.units === Tone.Type.Decibels){\n\t\t\tthis.exponentialRampToValue(value, rampTime, startTime);\n\t\t} else {\n\t\t\tthis.linearRampToValue(value, rampTime, startTime);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * The LFO created by the signal instance. If none\n\t * was created, this is null.\n\t * @type {Tone.LFO}\n\t * @readOnly\n\t * @memberOf Tone.Param#\n\t * @name lfo\n\t */\n\tObject.defineProperty(Tone.Param.prototype, \"lfo\", {\n\t\tget : function(){\n\t\t\treturn this._lfo;\n\t\t}\n\t});\n\n\t/**\n\t * Clean up\n\t * @returns {Tone.Param} this\n\t */\n\tTone.Param.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._param = null;\n\t\tif (this._lfo){\n\t\t\tthis._lfo.dispose();\n\t\t\tthis._lfo = null;\n\t\t}\n\t\treturn this;\n\t};\n\n\treturn Tone.Param;\n});","'use strict';\n\ndefine(function (require) {\n var p5sound = require('master');\n\n var Add = require('Tone/signal/Add');\n var Mult = require('Tone/signal/Multiply');\n var Scale = require('Tone/signal/Scale');\n\n /**\n *

Creates a signal that oscillates between -1.0 and 1.0.\n * By default, the oscillation takes the form of a sinusoidal\n * shape ('sine'). Additional types include 'triangle',\n * 'sawtooth' and 'square'. The frequency defaults to\n * 440 oscillations per second (440Hz, equal to the pitch of an\n * 'A' note).

\n *\n *

Set the type of oscillation with setType(), or by instantiating a\n * specific oscillator: p5.SinOsc, p5.TriOsc, p5.SqrOsc, or p5.SawOsc.\n *

\n *\n * @class p5.Oscillator\n * @constructor\n * @param {Number} [freq] frequency defaults to 440Hz\n * @param {String} [type] type of oscillator. Options:\n * 'sine' (default), 'triangle',\n * 'sawtooth', 'square'\n * @example\n *
\n * let osc, playing, freq, amp;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playOscillator);\n * osc = new p5.Oscillator('sine');\n * }\n *\n * function draw() {\n * background(220)\n * freq = constrain(map(mouseX, 0, width, 100, 500), 100, 500);\n * amp = constrain(map(mouseY, height, 0, 0, 1), 0, 1);\n *\n * text('tap to play', 20, 20);\n * text('freq: ' + freq, 20, 40);\n * text('amp: ' + amp, 20, 60);\n *\n * if (playing) {\n * // smooth the transitions by 0.1 seconds\n * osc.freq(freq, 0.1);\n * osc.amp(amp, 0.1);\n * }\n * }\n *\n * function playOscillator() {\n * // starting an oscillator on a user gesture will enable audio\n * // in browsers that have a strict autoplay policy.\n * // See also: userStartAudio();\n * osc.start();\n * playing = true;\n * }\n *\n * function mouseReleased() {\n * // ramp amplitude to 0 over 0.5 seconds\n * osc.amp(0, 0.5);\n * playing = false;\n * }\n *
\n */\n p5.Oscillator = function(freq, type) {\n if (typeof freq === 'string') {\n var f = type;\n type = freq;\n freq = f;\n } if (typeof type === 'number') {\n var f = type;\n type = freq;\n freq = f;\n }\n this.started = false;\n\n // components\n this.phaseAmount = undefined;\n this.oscillator = p5sound.audiocontext.createOscillator();\n this.f = freq || 440.0; // frequency\n this.oscillator.type = type || 'sine';\n this.oscillator.frequency.setValueAtTime(this.f, p5sound.audiocontext.currentTime);\n\n // connections\n this.output = p5sound.audiocontext.createGain();\n\n this._freqMods = []; // modulators connected to this oscillator's frequency\n\n // set default output gain to 0.5\n this.output.gain.value = 0.5;\n this.output.gain.setValueAtTime(0.5, p5sound.audiocontext.currentTime);\n\n this.oscillator.connect(this.output);\n // stereo panning\n this.panPosition = 0.0;\n this.connection = p5sound.input; // connect to p5sound by default\n this.panner = new p5.Panner(this.output, this.connection, 1);\n\n //array of math operation signal chaining\n this.mathOps = [this.output];\n\n // add to the soundArray so we can dispose of the osc later\n p5sound.soundArray.push(this);\n };\n\n /**\n * Start an oscillator.\n *\n * Starting an oscillator on a user gesture will enable audio in browsers\n * that have a strict autoplay policy, including Chrome and most mobile\n * devices. See also: `userStartAudio()`.\n *\n * @method start\n * @for p5.Oscillator\n * @param {Number} [time] startTime in seconds from now.\n * @param {Number} [frequency] frequency in Hz.\n */\n p5.Oscillator.prototype.start = function(time, f) {\n if (this.started) {\n var now = p5sound.audiocontext.currentTime;\n this.stop(now);\n }\n if (!this.started) {\n var freq = f || this.f;\n var type = this.oscillator.type;\n\n // set old osc free to be garbage collected (memory)\n if (this.oscillator) {\n this.oscillator.disconnect();\n delete this.oscillator;\n }\n\n // var detune = this.oscillator.frequency.value;\n this.oscillator = p5sound.audiocontext.createOscillator();\n this.oscillator.frequency.value = Math.abs(freq);\n this.oscillator.type = type;\n // this.oscillator.detune.value = detune;\n this.oscillator.connect(this.output);\n time = time || 0;\n this.oscillator.start(time + p5sound.audiocontext.currentTime);\n this.freqNode = this.oscillator.frequency;\n\n // if other oscillators are already connected to this osc's freq\n for (var i in this._freqMods) {\n if (typeof this._freqMods[i].connect !== 'undefined') {\n this._freqMods[i].connect(this.oscillator.frequency);\n }\n }\n\n this.started = true;\n }\n };\n\n /**\n * Stop an oscillator. Accepts an optional parameter\n * to determine how long (in seconds from now) until the\n * oscillator stops.\n *\n * @method stop\n * @for p5.Oscillator\n * @param {Number} secondsFromNow Time, in seconds from now.\n */\n p5.Oscillator.prototype.stop = function(time) {\n if (this.started) {\n var t = time || 0;\n var now = p5sound.audiocontext.currentTime;\n this.oscillator.stop(t + now);\n this.started = false;\n }\n };\n\n /**\n * Set the amplitude between 0 and 1.0. Or, pass in an object\n * such as an oscillator to modulate amplitude with an audio signal.\n *\n * @method amp\n * @for p5.Oscillator\n * @param {Number|Object} vol between 0 and 1.0\n * or a modulating signal/oscillator\n * @param {Number} [rampTime] create a fade that lasts rampTime\n * @param {Number} [timeFromNow] schedule this event to happen\n * seconds from now\n * @return {AudioParam} gain If no value is provided,\n * returns the Web Audio API\n * AudioParam that controls\n * this oscillator's\n * gain/amplitude/volume)\n */\n p5.Oscillator.prototype.amp = function(vol, rampTime, tFromNow) {\n var self = this;\n if (typeof vol === 'number') {\n var rampTime = rampTime || 0;\n var tFromNow = tFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n this.output.gain.linearRampToValueAtTime(vol, now + tFromNow + rampTime);\n }\n\n else if (vol) {\n vol.connect(self.output.gain);\n } else {\n // return the Gain Node\n return this.output.gain;\n }\n };\n\n // these are now the same thing\n p5.Oscillator.prototype.fade = p5.Oscillator.prototype.amp;\n\n p5.Oscillator.prototype.getAmp = function() {\n return this.output.gain.value;\n };\n\n /**\n * Set frequency of an oscillator to a value. Or, pass in an object\n * such as an oscillator to modulate the frequency with an audio signal.\n *\n * @method freq\n * @for p5.Oscillator\n * @param {Number|Object} Frequency Frequency in Hz\n * or modulating signal/oscillator\n * @param {Number} [rampTime] Ramp time (in seconds)\n * @param {Number} [timeFromNow] Schedule this event to happen\n * at x seconds from now\n * @return {AudioParam} Frequency If no value is provided,\n * returns the Web Audio API\n * AudioParam that controls\n * this oscillator's frequency\n * @example\n *
\n * let osc;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playOscillator);\n * osc = new p5.Oscillator(300);\n * background(220);\n * text('tap to play', 20, 20);\n * }\n *\n * function playOscillator() {\n * osc.start();\n * osc.amp(0.5);\n * // start at 700Hz\n * osc.freq(700);\n * // ramp to 60Hz over 0.7 seconds\n * osc.freq(60, 0.7);\n * osc.amp(0, 0.1, 0.7);\n * }\n *
\n */\n p5.Oscillator.prototype.freq = function(val, rampTime, tFromNow) {\n if (typeof val === 'number' && !isNaN(val)) {\n this.f = val;\n var now = p5sound.audiocontext.currentTime;\n var rampTime = rampTime || 0;\n var tFromNow = tFromNow || 0;\n var t = now + tFromNow + rampTime;\n // var currentFreq = this.oscillator.frequency.value;\n // this.oscillator.frequency.cancelScheduledValues(now);\n\n if (rampTime === 0) {\n this.oscillator.frequency.setValueAtTime(val, tFromNow + now);\n } else {\n if (val > 0 ) {\n this.oscillator.frequency.exponentialRampToValueAtTime(val, tFromNow + rampTime + now);\n } else {\n this.oscillator.frequency.linearRampToValueAtTime(val, tFromNow + rampTime + now);\n }\n }\n\n // reset phase if oscillator has a phase\n if (this.phaseAmount) {\n this.phase(this.phaseAmount);\n }\n\n } else if (val) {\n if (val.output) {\n val = val.output;\n }\n val.connect(this.oscillator.frequency);\n\n // keep track of what is modulating this param\n // so it can be re-connected if\n this._freqMods.push( val );\n } else {\n // return the Frequency Node\n return this.oscillator.frequency;\n }\n };\n\n p5.Oscillator.prototype.getFreq = function() {\n return this.oscillator.frequency.value;\n };\n\n /**\n * Set type to 'sine', 'triangle', 'sawtooth' or 'square'.\n *\n * @method setType\n * @for p5.Oscillator\n * @param {String} type 'sine', 'triangle', 'sawtooth' or 'square'.\n */\n p5.Oscillator.prototype.setType = function(type) {\n this.oscillator.type = type;\n };\n\n p5.Oscillator.prototype.getType = function() {\n return this.oscillator.type;\n };\n\n /**\n * Connect to a p5.sound / Web Audio object.\n *\n * @method connect\n * @for p5.Oscillator\n * @param {Object} unit A p5.sound or Web Audio object\n */\n p5.Oscillator.prototype.connect = function(unit) {\n if (!unit) {\n this.panner.connect(p5sound.input);\n }\n else if (unit.hasOwnProperty('input')) {\n this.panner.connect(unit.input);\n this.connection = unit.input;\n }\n else {\n this.panner.connect(unit);\n this.connection = unit;\n }\n };\n\n /**\n * Disconnect all outputs\n *\n * @method disconnect\n * @for p5.Oscillator\n */\n p5.Oscillator.prototype.disconnect = function() {\n if (this.output) {\n this.output.disconnect();\n }\n if (this.panner) {\n this.panner.disconnect();\n if (this.output) {\n this.output.connect(this.panner);\n }\n }\n this.oscMods = [];\n };\n\n /**\n * Pan between Left (-1) and Right (1)\n *\n * @method pan\n * @for p5.Oscillator\n * @param {Number} panning Number between -1 and 1\n * @param {Number} timeFromNow schedule this event to happen\n * seconds from now\n */\n p5.Oscillator.prototype.pan = function(pval, tFromNow) {\n this.panPosition = pval;\n this.panner.pan(pval, tFromNow);\n };\n\n p5.Oscillator.prototype.getPan = function() {\n return this.panPosition;\n };\n\n // get rid of the oscillator\n p5.Oscillator.prototype.dispose = function() {\n // remove reference from soundArray\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n\n if (this.oscillator) {\n var now = p5sound.audiocontext.currentTime;\n this.stop(now);\n this.disconnect();\n this.panner = null;\n this.oscillator = null;\n }\n // if it is a Pulse\n if (this.osc2) {\n this.osc2.dispose();\n }\n };\n\n /**\n * Set the phase of an oscillator between 0.0 and 1.0.\n * In this implementation, phase is a delay time\n * based on the oscillator's current frequency.\n *\n * @method phase\n * @for p5.Oscillator\n * @param {Number} phase float between 0.0 and 1.0\n */\n p5.Oscillator.prototype.phase = function(p) {\n var delayAmt = p5.prototype.map(p, 0, 1.0, 0, 1/this.f);\n var now = p5sound.audiocontext.currentTime;\n\n this.phaseAmount = p;\n\n if (!this.dNode) {\n // create a delay node\n this.dNode = p5sound.audiocontext.createDelay();\n // put the delay node in between output and panner\n this.oscillator.disconnect();\n this.oscillator.connect(this.dNode);\n this.dNode.connect(this.output);\n }\n\n // set delay time to match phase:\n this.dNode.delayTime.setValueAtTime(delayAmt, now);\n };\n\n // ========================== //\n // SIGNAL MATH FOR MODULATION //\n // ========================== //\n\n // return sigChain(this, scale, thisChain, nextChain, Scale);\n var sigChain = function(o, mathObj, thisChain, nextChain, type) {\n var chainSource = o.oscillator;\n // if this type of math already exists in the chain, replace it\n for (var i in o.mathOps) {\n if (o.mathOps[i] instanceof type) {\n chainSource.disconnect();\n o.mathOps[i].dispose();\n thisChain = i;\n // assume nextChain is output gain node unless...\n if (thisChain < o.mathOps.length - 2) {\n nextChain = o.mathOps[i+1];\n }\n }\n }\n if (thisChain === o.mathOps.length - 1) {\n o.mathOps.push(nextChain);\n }\n // assume source is the oscillator unless i > 0\n if (i > 0) {\n chainSource = o.mathOps[i-1];\n }\n chainSource.disconnect();\n chainSource.connect(mathObj);\n mathObj.connect(nextChain);\n o.mathOps[thisChain] = mathObj;\n return o;\n };\n\n /**\n * Add a value to the p5.Oscillator's output amplitude,\n * and return the oscillator. Calling this method again\n * will override the initial add() with a new value.\n *\n * @method add\n * @for p5.Oscillator\n * @param {Number} number Constant number to add\n * @return {p5.Oscillator} Oscillator Returns this oscillator\n * with scaled output\n *\n */\n p5.Oscillator.prototype.add = function(num) {\n var add = new Add(num);\n var thisChain = this.mathOps.length-1;\n var nextChain = this.output;\n return sigChain(this, add, thisChain, nextChain, Add);\n };\n\n /**\n * Multiply the p5.Oscillator's output amplitude\n * by a fixed value (i.e. turn it up!). Calling this method\n * again will override the initial mult() with a new value.\n *\n * @method mult\n * @for p5.Oscillator\n * @param {Number} number Constant number to multiply\n * @return {p5.Oscillator} Oscillator Returns this oscillator\n * with multiplied output\n */\n p5.Oscillator.prototype.mult = function(num) {\n var mult = new Mult(num);\n var thisChain = this.mathOps.length-1;\n var nextChain = this.output;\n return sigChain(this, mult, thisChain, nextChain, Mult);\n };\n\n /**\n * Scale this oscillator's amplitude values to a given\n * range, and return the oscillator. Calling this method\n * again will override the initial scale() with new values.\n *\n * @method scale\n * @for p5.Oscillator\n * @param {Number} inMin input range minumum\n * @param {Number} inMax input range maximum\n * @param {Number} outMin input range minumum\n * @param {Number} outMax input range maximum\n * @return {p5.Oscillator} Oscillator Returns this oscillator\n * with scaled output\n */\n p5.Oscillator.prototype.scale = function(inMin, inMax, outMin, outMax) {\n var mapOutMin, mapOutMax;\n if (arguments.length === 4) {\n mapOutMin = p5.prototype.map(outMin, inMin, inMax, 0, 1) - 0.5;\n mapOutMax = p5.prototype.map(outMax, inMin, inMax, 0, 1) - 0.5;\n }\n else {\n mapOutMin = arguments[0];\n mapOutMax = arguments[1];\n }\n var scale = new Scale(mapOutMin, mapOutMax);\n var thisChain = this.mathOps.length-1;\n var nextChain = this.output;\n return sigChain(this, scale, thisChain, nextChain, Scale);\n\n // this.output.disconnect();\n // this.output.connect(scale)\n };\n\n // ============================== //\n // SinOsc, TriOsc, SqrOsc, SawOsc //\n // ============================== //\n\n /**\n * Constructor: new p5.SinOsc().\n * This creates a Sine Wave Oscillator and is\n * equivalent to new p5.Oscillator('sine')\n * or creating a p5.Oscillator and then calling\n * its method setType('sine').\n * See p5.Oscillator for methods.\n *\n * @class p5.SinOsc\n * @constructor\n * @extends p5.Oscillator\n * @param {Number} [freq] Set the frequency\n */\n p5.SinOsc = function(freq) {\n p5.Oscillator.call(this, freq, 'sine');\n };\n\n p5.SinOsc.prototype = Object.create(p5.Oscillator.prototype);\n\n /**\n * Constructor: new p5.TriOsc().\n * This creates a Triangle Wave Oscillator and is\n * equivalent to new p5.Oscillator('triangle')\n * or creating a p5.Oscillator and then calling\n * its method setType('triangle').\n * See p5.Oscillator for methods.\n *\n * @class p5.TriOsc\n * @constructor\n * @extends p5.Oscillator\n * @param {Number} [freq] Set the frequency\n */\n p5.TriOsc = function(freq) {\n p5.Oscillator.call(this, freq, 'triangle');\n };\n\n p5.TriOsc.prototype = Object.create(p5.Oscillator.prototype);\n\n /**\n * Constructor: new p5.SawOsc().\n * This creates a SawTooth Wave Oscillator and is\n * equivalent to new p5.Oscillator('sawtooth')\n * or creating a p5.Oscillator and then calling\n * its method setType('sawtooth').\n * See p5.Oscillator for methods.\n *\n * @class p5.SawOsc\n * @constructor\n * @extends p5.Oscillator\n * @param {Number} [freq] Set the frequency\n */\n p5.SawOsc = function(freq) {\n p5.Oscillator.call(this, freq, 'sawtooth');\n };\n\n p5.SawOsc.prototype = Object.create(p5.Oscillator.prototype);\n\n /**\n * Constructor: new p5.SqrOsc().\n * This creates a Square Wave Oscillator and is\n * equivalent to new p5.Oscillator('square')\n * or creating a p5.Oscillator and then calling\n * its method setType('square').\n * See p5.Oscillator for methods.\n *\n * @class p5.SqrOsc\n * @constructor\n * @extends p5.Oscillator\n * @param {Number} [freq] Set the frequency\n */\n p5.SqrOsc = function(freq) {\n p5.Oscillator.call(this, freq, 'square');\n };\n\n p5.SqrOsc.prototype = Object.create(p5.Oscillator.prototype);\n\n});\n","define([\"Tone/core/Tone\", \"Tone/type/Type\"], function (Tone) {\n\n\t\"use strict\";\n\n\t/**\n\t * @class A Timeline class for scheduling and maintaining state\n\t * along a timeline. All events must have a \"time\" property. \n\t * Internally, events are stored in time order for fast \n\t * retrieval.\n\t * @extends {Tone}\n\t * @param {Positive} [memory=Infinity] The number of previous events that are retained.\n\t */\n\tTone.Timeline = function(){\n\n\t\tvar options = this.optionsObject(arguments, [\"memory\"], Tone.Timeline.defaults);\n\n\t\t/**\n\t\t * The array of scheduled timeline events\n\t\t * @type {Array}\n\t\t * @private\n\t\t */\n\t\tthis._timeline = [];\n\n\t\t/**\n\t\t * An array of items to remove from the list. \n\t\t * @type {Array}\n\t\t * @private\n\t\t */\n\t\tthis._toRemove = [];\n\n\t\t/**\n\t\t * Flag if the tieline is mid iteration\n\t\t * @private\n\t\t * @type {Boolean}\n\t\t */\n\t\tthis._iterating = false;\n\n\t\t/**\n\t\t * The memory of the timeline, i.e.\n\t\t * how many events in the past it will retain\n\t\t * @type {Positive}\n\t\t */\n\t\tthis.memory = options.memory;\n\t};\n\n\tTone.extend(Tone.Timeline);\n\n\t/**\n\t * the default parameters\n\t * @static\n\t * @const\n\t */\n\tTone.Timeline.defaults = {\n\t\t\"memory\" : Infinity\n\t};\n\n\t/**\n\t * The number of items in the timeline.\n\t * @type {Number}\n\t * @memberOf Tone.Timeline#\n\t * @name length\n\t * @readOnly\n\t */\n\tObject.defineProperty(Tone.Timeline.prototype, \"length\", {\n\t\tget : function(){\n\t\t\treturn this._timeline.length;\n\t\t}\n\t});\n\n\t/**\n\t * Insert an event object onto the timeline. Events must have a \"time\" attribute.\n\t * @param {Object} event The event object to insert into the \n\t * timeline. \n\t * @returns {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.add = function(event){\n\t\t//the event needs to have a time attribute\n\t\tif (this.isUndef(event.time)){\n\t\t\tthrow new Error(\"Tone.Timeline: events must have a time attribute\");\n\t\t}\n\t\tif (this._timeline.length){\n\t\t\tvar index = this._search(event.time);\n\t\t\tthis._timeline.splice(index + 1, 0, event);\n\t\t} else {\n\t\t\tthis._timeline.push(event);\t\t\t\n\t\t}\n\t\t//if the length is more than the memory, remove the previous ones\n\t\tif (this.length > this.memory){\n\t\t\tvar diff = this.length - this.memory;\n\t\t\tthis._timeline.splice(0, diff);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Remove an event from the timeline.\n\t * @param {Object} event The event object to remove from the list.\n\t * @returns {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.remove = function(event){\n\t\tif (this._iterating){\n\t\t\tthis._toRemove.push(event);\n\t\t} else {\n\t\t\tvar index = this._timeline.indexOf(event);\n\t\t\tif (index !== -1){\n\t\t\t\tthis._timeline.splice(index, 1);\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Get the nearest event whose time is less than or equal to the given time.\n\t * @param {Number} time The time to query.\n\t * @returns {Object} The event object set after that time.\n\t */\n\tTone.Timeline.prototype.get = function(time){\n\t\tvar index = this._search(time);\n\t\tif (index !== -1){\n\t\t\treturn this._timeline[index];\n\t\t} else {\n\t\t\treturn null;\n\t\t}\n\t};\n\n\t/**\n\t * Return the first event in the timeline without removing it\n\t * @returns {Object} The first event object\n\t */\n\tTone.Timeline.prototype.peek = function(){\n\t\treturn this._timeline[0];\n\t};\n\n\t/**\n\t * Return the first event in the timeline and remove it\n\t * @returns {Object} The first event object\n\t */\n\tTone.Timeline.prototype.shift = function(){\n\t\treturn this._timeline.shift();\n\t};\n\n\t/**\n\t * Get the event which is scheduled after the given time.\n\t * @param {Number} time The time to query.\n\t * @returns {Object} The event object after the given time\n\t */\n\tTone.Timeline.prototype.getAfter = function(time){\n\t\tvar index = this._search(time);\n\t\tif (index + 1 < this._timeline.length){\n\t\t\treturn this._timeline[index + 1];\n\t\t} else {\n\t\t\treturn null;\n\t\t}\n\t};\n\n\t/**\n\t * Get the event before the event at the given time.\n\t * @param {Number} time The time to query.\n\t * @returns {Object} The event object before the given time\n\t */\n\tTone.Timeline.prototype.getBefore = function(time){\n\t\tvar len = this._timeline.length;\n\t\t//if it's after the last item, return the last item\n\t\tif (len > 0 && this._timeline[len - 1].time < time){\n\t\t\treturn this._timeline[len - 1];\n\t\t}\n\t\tvar index = this._search(time);\n\t\tif (index - 1 >= 0){\n\t\t\treturn this._timeline[index - 1];\n\t\t} else {\n\t\t\treturn null;\n\t\t}\n\t};\n\n\t/**\n\t * Cancel events after the given time\n\t * @param {Number} time The time to query.\n\t * @returns {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.cancel = function(after){\n\t\tif (this._timeline.length > 1){\n\t\t\tvar index = this._search(after);\n\t\t\tif (index >= 0){\n\t\t\t\tif (this._timeline[index].time === after){\n\t\t\t\t\t//get the first item with that time\n\t\t\t\t\tfor (var i = index; i >= 0; i--){\n\t\t\t\t\t\tif (this._timeline[i].time === after){\n\t\t\t\t\t\t\tindex = i;\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tthis._timeline = this._timeline.slice(0, index);\n\t\t\t\t} else {\n\t\t\t\t\tthis._timeline = this._timeline.slice(0, index + 1);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tthis._timeline = [];\n\t\t\t}\n\t\t} else if (this._timeline.length === 1){\n\t\t\t//the first item's time\n\t\t\tif (this._timeline[0].time >= after){\n\t\t\t\tthis._timeline = [];\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Cancel events before or equal to the given time.\n\t * @param {Number} time The time to cancel before.\n\t * @returns {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.cancelBefore = function(time){\n\t\tif (this._timeline.length){\n\t\t\tvar index = this._search(time);\n\t\t\tif (index >= 0){\n\t\t\t\tthis._timeline = this._timeline.slice(index + 1);\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Does a binary serach on the timeline array and returns the \n\t * nearest event index whose time is after or equal to the given time.\n\t * If a time is searched before the first index in the timeline, -1 is returned.\n\t * If the time is after the end, the index of the last item is returned.\n\t * @param {Number} time \n\t * @return {Number} the index in the timeline array \n\t * @private\n\t */\n\tTone.Timeline.prototype._search = function(time){\n\t\tvar beginning = 0;\n\t\tvar len = this._timeline.length;\n\t\tvar end = len;\n\t\tif (len > 0 && this._timeline[len - 1].time <= time){\n\t\t\treturn len - 1;\n\t\t}\n\t\twhile (beginning < end){\n\t\t\t// calculate the midpoint for roughly equal partition\n\t\t\tvar midPoint = Math.floor(beginning + (end - beginning) / 2);\n\t\t\tvar event = this._timeline[midPoint];\n\t\t\tvar nextEvent = this._timeline[midPoint + 1];\n\t\t\tif (event.time === time){\n\t\t\t\t//choose the last one that has the same time\n\t\t\t\tfor (var i = midPoint; i < this._timeline.length; i++){\n\t\t\t\t\tvar testEvent = this._timeline[i];\n\t\t\t\t\tif (testEvent.time === time){\n\t\t\t\t\t\tmidPoint = i;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn midPoint;\n\t\t\t} else if (event.time < time && nextEvent.time > time){\n\t\t\t\treturn midPoint;\n\t\t\t} else if (event.time > time){\n\t\t\t\t//search lower\n\t\t\t\tend = midPoint;\n\t\t\t} else if (event.time < time){\n\t\t\t\t//search upper\n\t\t\t\tbeginning = midPoint + 1;\n\t\t\t} \n\t\t}\n\t\treturn -1;\n\t};\n\n\t/**\n\t * Internal iterator. Applies extra safety checks for \n\t * removing items from the array. \n\t * @param {Function} callback \n\t * @param {Number=} lowerBound \n\t * @param {Number=} upperBound \n\t * @private\n\t */\n\tTone.Timeline.prototype._iterate = function(callback, lowerBound, upperBound){\n\t\tthis._iterating = true;\n\t\tlowerBound = this.defaultArg(lowerBound, 0);\n\t\tupperBound = this.defaultArg(upperBound, this._timeline.length - 1);\n\t\tfor (var i = lowerBound; i <= upperBound; i++){\n\t\t\tcallback(this._timeline[i]);\n\t\t}\n\t\tthis._iterating = false;\n\t\tif (this._toRemove.length > 0){\n\t\t\tfor (var j = 0; j < this._toRemove.length; j++){\n\t\t\t\tvar index = this._timeline.indexOf(this._toRemove[j]);\n\t\t\t\tif (index !== -1){\n\t\t\t\t\tthis._timeline.splice(index, 1);\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis._toRemove = [];\n\t\t}\n\t};\n\n\t/**\n\t * Iterate over everything in the array\n\t * @param {Function} callback The callback to invoke with every item\n\t * @returns {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.forEach = function(callback){\n\t\tthis._iterate(callback);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Iterate over everything in the array at or before the given time.\n\t * @param {Number} time The time to check if items are before\n\t * @param {Function} callback The callback to invoke with every item\n\t * @returns {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.forEachBefore = function(time, callback){\n\t\t//iterate over the items in reverse so that removing an item doesn't break things\n\t\tvar upperBound = this._search(time);\n\t\tif (upperBound !== -1){\n\t\t\tthis._iterate(callback, 0, upperBound);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Iterate over everything in the array after the given time.\n\t * @param {Number} time The time to check if items are before\n\t * @param {Function} callback The callback to invoke with every item\n\t * @returns {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.forEachAfter = function(time, callback){\n\t\t//iterate over the items in reverse so that removing an item doesn't break things\n\t\tvar lowerBound = this._search(time);\n\t\tthis._iterate(callback, lowerBound + 1);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Iterate over everything in the array at or after the given time. Similar to \n\t * forEachAfter, but includes the item(s) at the given time.\n\t * @param {Number} time The time to check if items are before\n\t * @param {Function} callback The callback to invoke with every item\n\t * @returns {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.forEachFrom = function(time, callback){\n\t\t//iterate over the items in reverse so that removing an item doesn't break things\n\t\tvar lowerBound = this._search(time);\n\t\t//work backwards until the event time is less than time\n\t\twhile (lowerBound >= 0 && this._timeline[lowerBound].time >= time){\n\t\t\tlowerBound--;\n\t\t}\n\t\tthis._iterate(callback, lowerBound + 1);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Iterate over everything in the array at the given time\n\t * @param {Number} time The time to check if items are before\n\t * @param {Function} callback The callback to invoke with every item\n\t * @returns {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.forEachAtTime = function(time, callback){\n\t\t//iterate over the items in reverse so that removing an item doesn't break things\n\t\tvar upperBound = this._search(time);\n\t\tif (upperBound !== -1){\n\t\t\tthis._iterate(function(event){\n\t\t\t\tif (event.time === time){\n\t\t\t\t\tcallback(event);\n\t\t\t\t} \n\t\t\t}, 0, upperBound);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Clean up.\n\t * @return {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._timeline = null;\n\t\tthis._toRemove = null;\n\t};\n\n\treturn Tone.Timeline;\n});","define([\"Tone/core/Tone\", \"Tone/signal/Multiply\", \"Tone/signal/Signal\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Negate the incoming signal. i.e. an input signal of 10 will output -10\n\t *\n\t * @constructor\n\t * @extends {Tone.SignalBase}\n\t * @example\n\t * var neg = new Tone.Negate();\n\t * var sig = new Tone.Signal(-2).connect(neg);\n\t * //output of neg is positive 2. \n\t */\n\tTone.Negate = function(){\n\t\t/**\n\t\t * negation is done by multiplying by -1\n\t\t * @type {Tone.Multiply}\n\t\t * @private\n\t\t */\n\t\tthis._multiply = this.input = this.output = new Tone.Multiply(-1);\n\t};\n\n\tTone.extend(Tone.Negate, Tone.SignalBase);\n\n\t/**\n\t * clean up\n\t * @returns {Tone.Negate} this\n\t */\n\tTone.Negate.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._multiply.dispose();\n\t\tthis._multiply = null;\n\t\treturn this;\n\t}; \n\n\treturn Tone.Negate;\n});","define([\"Tone/core/Tone\", \"Tone/signal/Signal\", \"Tone/signal/Multiply\", \"Tone/signal/WaveShaper\"], \nfunction(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class GreaterThanZero outputs 1 when the input is strictly greater than zero\n\t * \n\t * @constructor\n\t * @extends {Tone.SignalBase}\n\t * @example\n\t * var gt0 = new Tone.GreaterThanZero();\n\t * var sig = new Tone.Signal(0.01).connect(gt0);\n\t * //the output of gt0 is 1. \n\t * sig.value = 0;\n\t * //the output of gt0 is 0. \n\t */\n\tTone.GreaterThanZero = function(){\n\t\t\n\t\t/**\n\t\t * @type {Tone.WaveShaper}\n\t\t * @private\n\t\t */\n\t\tthis._thresh = this.output = new Tone.WaveShaper(function(val){\n\t\t\tif (val <= 0){\n\t\t\t\treturn 0;\n\t\t\t} else {\n\t\t\t\treturn 1;\n\t\t\t}\n\t\t}, 127);\n\n\t\t/**\n\t\t * scale the first thresholded signal by a large value.\n\t\t * this will help with values which are very close to 0\n\t\t * @type {Tone.Multiply}\n\t\t * @private\n\t\t */\n\t\tthis._scale = this.input = new Tone.Multiply(10000);\n\n\t\t//connections\n\t\tthis._scale.connect(this._thresh);\n\t};\n\n\tTone.extend(Tone.GreaterThanZero, Tone.SignalBase);\n\n\t/**\n\t * dispose method\n\t * @returns {Tone.GreaterThanZero} this\n\t */\n\tTone.GreaterThanZero.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._scale.dispose();\n\t\tthis._scale = null;\n\t\tthis._thresh.dispose();\n\t\tthis._thresh = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.GreaterThanZero;\n});","define([\"Tone/core/Tone\", \"Tone/signal/TimelineSignal\", \"Tone/core/TimelineState\", \n\t\"Tone/core/Emitter\", \"Tone/core/Context\"], function (Tone) {\n\n\t\"use strict\";\n\n\t/**\n\t * @class A sample accurate clock which provides a callback at the given rate. \n\t * While the callback is not sample-accurate (it is still susceptible to\n\t * loose JS timing), the time passed in as the argument to the callback\n\t * is precise. For most applications, it is better to use Tone.Transport\n\t * instead of the Clock by itself since you can synchronize multiple callbacks.\n\t *\n\t * \t@constructor\n\t * @extends {Tone.Emitter}\n\t * \t@param {function} callback The callback to be invoked with the time of the audio event\n\t * \t@param {Frequency} frequency The rate of the callback\n\t * \t@example\n\t * //the callback will be invoked approximately once a second\n\t * //and will print the time exactly once a second apart.\n\t * var clock = new Tone.Clock(function(time){\n\t * \tconsole.log(time);\n\t * }, 1);\n\t */\n\tTone.Clock = function(){\n\n\t\tTone.Emitter.call(this);\n\n\t\tvar options = this.optionsObject(arguments, [\"callback\", \"frequency\"], Tone.Clock.defaults);\n\n\t\t/**\n\t\t * The callback function to invoke at the scheduled tick.\n\t\t * @type {Function}\n\t\t */\n\t\tthis.callback = options.callback;\n\n\t\t/**\n\t\t * The next time the callback is scheduled.\n\t\t * @type {Number}\n\t\t * @private\n\t\t */\n\t\tthis._nextTick = 0;\n\n\t\t/**\n\t\t * The last state of the clock.\n\t\t * @type {State}\n\t\t * @private\n\t\t */\n\t\tthis._lastState = Tone.State.Stopped;\n\n\t\t/**\n\t\t * The rate the callback function should be invoked. \n\t\t * @type {BPM}\n\t\t * @signal\n\t\t */\n\t\tthis.frequency = new Tone.TimelineSignal(options.frequency, Tone.Type.Frequency);\n\t\tthis._readOnly(\"frequency\");\n\n\t\t/**\n\t\t * The number of times the callback was invoked. Starts counting at 0\n\t\t * and increments after the callback was invoked. \n\t\t * @type {Ticks}\n\t\t * @readOnly\n\t\t */\n\t\tthis.ticks = 0;\n\n\t\t/**\n\t\t * The state timeline\n\t\t * @type {Tone.TimelineState}\n\t\t * @private\n\t\t */\n\t\tthis._state = new Tone.TimelineState(Tone.State.Stopped);\n\n\t\t/**\n\t\t * The loop function bound to its context. \n\t\t * This is necessary to remove the event in the end.\n\t\t * @type {Function}\n\t\t * @private\n\t\t */\n\t\tthis._boundLoop = this._loop.bind(this);\n\n\t\t//bind a callback to the worker thread\n \tthis.context.on(\"tick\", this._boundLoop);\n\t};\n\n\tTone.extend(Tone.Clock, Tone.Emitter);\n\n\t/**\n\t * The defaults\n\t * @const\n\t * @type {Object}\n\t */\n\tTone.Clock.defaults = {\n\t\t\"callback\" : Tone.noOp,\n\t\t\"frequency\" : 1,\n\t\t\"lookAhead\" : \"auto\",\n\t};\n\n\t/**\n\t * Returns the playback state of the source, either \"started\", \"stopped\" or \"paused\".\n\t * @type {Tone.State}\n\t * @readOnly\n\t * @memberOf Tone.Clock#\n\t * @name state\n\t */\n\tObject.defineProperty(Tone.Clock.prototype, \"state\", {\n\t\tget : function(){\n\t\t\treturn this._state.getValueAtTime(this.now());\n\t\t}\n\t});\n\n\t/**\n\t * Start the clock at the given time. Optionally pass in an offset\n\t * of where to start the tick counter from.\n\t * @param {Time} time The time the clock should start\n\t * @param {Ticks=} offset Where the tick counter starts counting from.\n\t * @return {Tone.Clock} this\n\t */\n\tTone.Clock.prototype.start = function(time, offset){\n\t\ttime = this.toSeconds(time);\n\t\tif (this._state.getValueAtTime(time) !== Tone.State.Started){\n\t\t\tthis._state.add({\n\t\t\t\t\"state\" : Tone.State.Started, \n\t\t\t\t\"time\" : time,\n\t\t\t\t\"offset\" : offset\n\t\t\t});\n\t\t}\n\t\treturn this;\t\n\t};\n\n\t/**\n\t * Stop the clock. Stopping the clock resets the tick counter to 0.\n\t * @param {Time} [time=now] The time when the clock should stop.\n\t * @returns {Tone.Clock} this\n\t * @example\n\t * clock.stop();\n\t */\n\tTone.Clock.prototype.stop = function(time){\n\t\ttime = this.toSeconds(time);\n\t\tthis._state.cancel(time);\n\t\tthis._state.setStateAtTime(Tone.State.Stopped, time);\n\t\treturn this;\t\n\t};\n\n\n\t/**\n\t * Pause the clock. Pausing does not reset the tick counter.\n\t * @param {Time} [time=now] The time when the clock should stop.\n\t * @returns {Tone.Clock} this\n\t */\n\tTone.Clock.prototype.pause = function(time){\n\t\ttime = this.toSeconds(time);\n\t\tif (this._state.getValueAtTime(time) === Tone.State.Started){\n\t\t\tthis._state.setStateAtTime(Tone.State.Paused, time);\n\t\t}\n\t\treturn this;\t\n\t};\n\n\t/**\n\t * The scheduling loop.\n\t * @param {Number} time The current page time starting from 0\n\t * when the page was loaded.\n\t * @private\n\t */\n\tTone.Clock.prototype._loop = function(){\n\t\t//get the frequency value to compute the value of the next loop\n\t\tvar now = this.now();\n\t\t//if it's started\n\t\tvar lookAhead = this.context.lookAhead;\n\t\tvar updateInterval = this.context.updateInterval;\n\t\tvar lagCompensation = this.context.lag * 2;\n\t\tvar loopInterval = now + lookAhead + updateInterval + lagCompensation;\n\t\twhile (loopInterval > this._nextTick && this._state){\n\t\t\tvar currentState = this._state.getValueAtTime(this._nextTick);\n\t\t\tif (currentState !== this._lastState){\n\t\t\t\tthis._lastState = currentState;\n\t\t\t\tvar event = this._state.get(this._nextTick);\n\t\t\t\t// emit an event\n\t\t\t\tif (currentState === Tone.State.Started){\n\t\t\t\t\t//correct the time\n\t\t\t\t\tthis._nextTick = event.time;\n\t\t\t\t\tif (!this.isUndef(event.offset)){\n\t\t\t\t\t\tthis.ticks = event.offset;\n\t\t\t\t\t}\n\t\t\t\t\tthis.emit(\"start\", event.time, this.ticks);\n\t\t\t\t} else if (currentState === Tone.State.Stopped){\n\t\t\t\t\tthis.ticks = 0;\n\n\t\t\t\t\tthis.emit(\"stop\", event.time);\n\t\t\t\t} else if (currentState === Tone.State.Paused){\n\t\t\t\t\tthis.emit(\"pause\", event.time);\n\t\t\t\t}\n\t\t\t}\n\t\t\tvar tickTime = this._nextTick;\n\t\t\tif (this.frequency){\n\t\t\t\tthis._nextTick += 1 / this.frequency.getValueAtTime(this._nextTick);\n\t\t\t\tif (currentState === Tone.State.Started){\n\t\t\t\t\tthis.callback(tickTime);\n\t\t\t\t\tthis.ticks++;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n\n\t/**\n\t * Returns the scheduled state at the given time.\n\t * @param {Time} time The time to query.\n\t * @return {String} The name of the state input in setStateAtTime.\n\t * @example\n\t * clock.start(\"+0.1\");\n\t * clock.getStateAtTime(\"+0.1\"); //returns \"started\"\n\t */\n\tTone.Clock.prototype.getStateAtTime = function(time){\n\t\ttime = this.toSeconds(time);\n\t\treturn this._state.getValueAtTime(time);\n\t};\n\n\t/**\n\t * Clean up\n\t * @returns {Tone.Clock} this\n\t */\n\tTone.Clock.prototype.dispose = function(){\n\t\tTone.Emitter.prototype.dispose.call(this);\n\t\tthis.context.off(\"tick\", this._boundLoop);\n\t\tthis._writable(\"frequency\");\n\t\tthis.frequency.dispose();\n\t\tthis.frequency = null;\n\t\tthis._boundLoop = null;\n\t\tthis._nextTick = Infinity;\n\t\tthis.callback = null;\n\t\tthis._state.dispose();\n\t\tthis._state = null;\n\t};\n\n\treturn Tone.Clock;\n});","'use strict';\ndefine(function (require) {\n\n var p5sound = require('master');\n var AudioVoice = require('audioVoice');\n var noteToFreq = require('helpers').noteToFreq;\n\n var DEFAULT_SUSTAIN = 0.15;\n\n /**\n * A MonoSynth is used as a single voice for sound synthesis.\n * This is a class to be used in conjunction with the PolySynth\n * class. Custom synthetisers should be built inheriting from\n * this class.\n *\n * @class p5.MonoSynth\n * @constructor\n * @example\n *
\n * let monoSynth;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playSynth);\n * background(220);\n * textAlign(CENTER);\n * text('tap to play', width/2, height/2);\n *\n * monoSynth = new p5.MonoSynth();\n * }\n *\n * function playSynth() {\n * userStartAudio();\n *\n * let note = random(['Fb4', 'G4']);\n * // note velocity (volume, from 0 to 1)\n * let velocity = random();\n * // time from now (in seconds)\n * let time = 0;\n * // note duration (in seconds)\n * let dur = 1/6;\n *\n * monoSynth.play(note, velocity, time, dur);\n * }\n *
\n **/\n\n p5.MonoSynth = function () {\n AudioVoice.call(this);\n\n this.oscillator = new p5.Oscillator();\n\n this.env = new p5.Envelope();\n this.env.setRange(1, 0);\n this.env.setExp(true);\n\n //set params\n this.setADSR(0.02, 0.25, 0.05, 0.35);\n\n // oscillator --> env --> this.output (gain) --> p5.soundOut\n this.oscillator.disconnect();\n this.oscillator.connect(this.output);\n\n this.env.disconnect();\n this.env.setInput(this.output.gain);\n\n // reset oscillator gain to 1.0\n this.oscillator.output.gain.value = 1.0;\n\n this.oscillator.start();\n this.connect();\n\n p5sound.soundArray.push(this);\n };\n\n p5.MonoSynth.prototype = Object.create(p5.AudioVoice.prototype);\n\n /**\n * Play tells the MonoSynth to start playing a note. This method schedules\n * the calling of .triggerAttack and .triggerRelease.\n *\n * @method play\n * @for p5.MonoSynth\n * @param {String | Number} note the note you want to play, specified as a\n * frequency in Hertz (Number) or as a midi\n * value in Note/Octave format (\"C4\", \"Eb3\"...etc\")\n * See \n * Tone. Defaults to 440 hz.\n * @param {Number} [velocity] velocity of the note to play (ranging from 0 to 1)\n * @param {Number} [secondsFromNow] time from now (in seconds) at which to play\n * @param {Number} [sustainTime] time to sustain before releasing the envelope. Defaults to 0.15 seconds.\n * @example\n *
\n * let monoSynth;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playSynth);\n * background(220);\n * textAlign(CENTER);\n * text('tap to play', width/2, height/2);\n *\n * monoSynth = new p5.MonoSynth();\n * }\n *\n * function playSynth() {\n * userStartAudio();\n *\n * let note = random(['Fb4', 'G4']);\n * // note velocity (volume, from 0 to 1)\n * let velocity = random();\n * // time from now (in seconds)\n * let time = 0;\n * // note duration (in seconds)\n * let dur = 1/6;\n *\n * monoSynth.play(note, velocity, time, dur);\n * }\n *
\n *\n */\n p5.MonoSynth.prototype.play = function (note, velocity, secondsFromNow, susTime) {\n this.triggerAttack(note, velocity, ~~secondsFromNow);\n this.triggerRelease(~~secondsFromNow + (susTime || DEFAULT_SUSTAIN));\n };\n\n /**\n * Trigger the Attack, and Decay portion of the Envelope.\n * Similar to holding down a key on a piano, but it will\n * hold the sustain level until you let go.\n *\n * @param {String | Number} note the note you want to play, specified as a\n * frequency in Hertz (Number) or as a midi\n * value in Note/Octave format (\"C4\", \"Eb3\"...etc\")\n * See \n * Tone. Defaults to 440 hz\n * @param {Number} [velocity] velocity of the note to play (ranging from 0 to 1)\n * @param {Number} [secondsFromNow] time from now (in seconds) at which to play\n * @method triggerAttack\n * @for p5.MonoSynth\n * @example\n *
\n * let monoSynth;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(triggerAttack);\n * background(220);\n * text('tap here for attack, let go to release', 5, 20, width - 20);\n * monoSynth = new p5.MonoSynth();\n * }\n *\n * function triggerAttack() {\n * userStartAudio();\n *\n * monoSynth.triggerAttack(\"E3\");\n * }\n *\n * function mouseReleased() {\n * monoSynth.triggerRelease();\n * }\n *
\n */\n p5.MonoSynth.prototype.triggerAttack = function (note, velocity, secondsFromNow) {\n var secondsFromNow = ~~secondsFromNow;\n var freq = noteToFreq(note);\n var vel = velocity || 0.1;\n this.oscillator.freq(freq, 0, secondsFromNow);\n this.env.ramp(this.output.gain, secondsFromNow, vel);\n };\n\n /**\n * Trigger the release of the Envelope. This is similar to releasing\n * the key on a piano and letting the sound fade according to the\n * release level and release time.\n *\n * @param {Number} secondsFromNow time to trigger the release\n * @method triggerRelease\n * @for p5.MonoSynth\n * @example\n *
\n * let monoSynth;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(triggerAttack);\n * background(220);\n * text('tap here for attack, let go to release', 5, 20, width - 20);\n * monoSynth = new p5.MonoSynth();\n * }\n *\n * function triggerAttack() {\n * userStartAudio();\n *\n * monoSynth.triggerAttack(\"E3\");\n * }\n *\n * function mouseReleased() {\n * monoSynth.triggerRelease();\n * }\n *
\n */\n p5.MonoSynth.prototype.triggerRelease = function (secondsFromNow) {\n var secondsFromNow = secondsFromNow || 0;\n this.env.ramp(this.output.gain, secondsFromNow, 0);\n };\n\n /**\n * Set values like a traditional\n * \n * ADSR envelope\n * .\n *\n * @method setADSR\n * @for p5.MonoSynth\n * @param {Number} attackTime Time (in seconds before envelope\n * reaches Attack Level\n * @param {Number} [decayTime] Time (in seconds) before envelope\n * reaches Decay/Sustain Level\n * @param {Number} [susRatio] Ratio between attackLevel and releaseLevel, on a scale from 0 to 1,\n * where 1.0 = attackLevel, 0.0 = releaseLevel.\n * The susRatio determines the decayLevel and the level at which the\n * sustain portion of the envelope will sustain.\n * For example, if attackLevel is 0.4, releaseLevel is 0,\n * and susAmt is 0.5, the decayLevel would be 0.2. If attackLevel is\n * increased to 1.0 (using setRange),\n * then decayLevel would increase proportionally, to become 0.5.\n * @param {Number} [releaseTime] Time in seconds from now (defaults to 0)\n */\n p5.MonoSynth.prototype.setADSR = function (attack,decay,sustain,release) {\n this.env.setADSR(attack, decay, sustain, release);\n };\n\n\n /**\n * Getters and Setters\n * @property {Number} attack\n * @for p5.MonoSynth\n */\n /**\n * @property {Number} decay\n * @for p5.MonoSynth\n */\n /**\n * @property {Number} sustain\n * @for p5.MonoSynth\n */\n /**\n * @property {Number} release\n * @for p5.MonoSynth\n */\n Object.defineProperties(p5.MonoSynth.prototype, {\n 'attack': {\n get : function() {\n return this.env.aTime;\n },\n set : function(attack) {\n this.env.setADSR(attack, this.env.dTime,\n this.env.sPercent, this.env.rTime);\n }\n },\n 'decay': {\n get : function() {\n return this.env.dTime;\n },\n set : function(decay) {\n this.env.setADSR(this.env.aTime, decay,\n this.env.sPercent, this.env.rTime);\n }\n },\n 'sustain': {\n get : function() {\n return this.env.sPercent;\n },\n set : function(sustain) {\n this.env.setADSR(this.env.aTime, this.env.dTime,\n sustain, this.env.rTime);\n }\n },\n 'release': {\n get : function() {\n return this.env.rTime;\n },\n set : function(release) {\n this.env.setADSR(this.env.aTime, this.env.dTime,\n this.env.sPercent, release);\n }\n },\n });\n\n\n /**\n * MonoSynth amp\n * @method amp\n * @for p5.MonoSynth\n * @param {Number} vol desired volume\n * @param {Number} [rampTime] Time to reach new volume\n * @return {Number} new volume value\n */\n p5.MonoSynth.prototype.amp = function(vol, rampTime) {\n var t = rampTime || 0;\n if (typeof vol !== 'undefined') {\n this.oscillator.amp(vol, t);\n }\n return this.oscillator.amp().value;\n };\n\n /**\n * Connect to a p5.sound / Web Audio object.\n *\n * @method connect\n * @for p5.MonoSynth\n * @param {Object} unit A p5.sound or Web Audio object\n */\n\n p5.MonoSynth.prototype.connect = function(unit) {\n var u = unit || p5sound.input;\n this.output.connect(u.input ? u.input : u);\n };\n\n /**\n * Disconnect all outputs\n *\n * @method disconnect\n * @for p5.MonoSynth\n */\n p5.MonoSynth.prototype.disconnect = function() {\n if (this.output) {\n this.output.disconnect();\n }\n };\n\n\n /**\n * Get rid of the MonoSynth and free up its resources / memory.\n *\n * @method dispose\n * @for p5.MonoSynth\n */\n p5.MonoSynth.prototype.dispose = function() {\n AudioVoice.prototype.dispose.apply(this);\n\n if (this.env) {\n this.env.dispose();\n }\n if (this.oscillator) {\n this.oscillator.dispose();\n }\n };\n\n});\n","'use strict';\ndefine(function() {\n var p5sound = require('master');\n\n /**\n * Base class for monophonic synthesizers. Any extensions of this class\n * should follow the API and implement the methods below in order to\n * remain compatible with p5.PolySynth();\n *\n * @class p5.AudioVoice\n * @constructor\n */\n p5.AudioVoice = function () {\n\t this.ac = p5sound.audiocontext;\n\t this.output = this.ac.createGain();\n\t this.connect();\n\t p5sound.soundArray.push(this);\n };\n\n p5.AudioVoice.prototype.play = function (note, velocity, secondsFromNow, sustime) {\n };\n\n p5.AudioVoice.prototype.triggerAttack = function (note, velocity, secondsFromNow) {\n };\n\n p5.AudioVoice.prototype.triggerRelease = function (secondsFromNow) {\n };\n\n p5.AudioVoice.prototype.amp = function(vol, rampTime) {\n };\n\n /**\n * Connect to p5 objects or Web Audio Nodes\n * @method connect\n * @for p5.AudioVoice\n * @param {Object} unit\n */\n p5.AudioVoice.prototype.connect = function(unit) {\n var u = unit || p5sound.input;\n this.output.connect(u.input ? u.input : u);\n };\n\n /**\n * Disconnect from soundOut\n * @method disconnect\n * @for p5.AudioVoice\n */\n p5.AudioVoice.prototype.disconnect = function() {\n this.output.disconnect();\n };\n\n p5.AudioVoice.prototype.dispose = function() {\n if (this.output) {\n this.output.disconnect();\n delete this.output;\n }\n };\n\n return p5.AudioVoice;\n});\n","'use strict';\ndefine(function (require) {\n\n var p5sound = require('master');\n var TimelineSignal = require('Tone/signal/TimelineSignal');\n var noteToFreq = require('helpers').noteToFreq;\n\n /**\n * An AudioVoice is used as a single voice for sound synthesis.\n * The PolySynth class holds an array of AudioVoice, and deals\n * with voices allocations, with setting notes to be played, and\n * parameters to be set.\n *\n * @class p5.PolySynth\n * @constructor\n *\n * @param {Number} [synthVoice] A monophonic synth voice inheriting\n * the AudioVoice class. Defaults to p5.MonoSynth\n * @param {Number} [maxVoices] Number of voices, defaults to 8;\n * @example\n *
\n * let polySynth;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playSynth);\n * background(220);\n * text('click to play', 20, 20);\n *\n * polySynth = new p5.PolySynth();\n * }\n *\n * function playSynth() {\n * userStartAudio();\n *\n * // note duration (in seconds)\n * let dur = 1.5;\n *\n * // time from now (in seconds)\n * let time = 0;\n *\n * // velocity (volume, from 0 to 1)\n * let vel = 0.1;\n *\n * // notes can overlap with each other\n * polySynth.play('G2', vel, 0, dur);\n * polySynth.play('C3', vel, time += 1/3, dur);\n * polySynth.play('G3', vel, time += 1/3, dur);\n * }\n *
\n **/\n p5.PolySynth = function(audioVoice, maxVoices) {\n //audiovoices will contain maxVoices many monophonic synths\n this.audiovoices = [];\n\n /**\n * An object that holds information about which notes have been played and\n * which notes are currently being played. New notes are added as keys\n * on the fly. While a note has been attacked, but not released, the value of the\n * key is the audiovoice which is generating that note. When notes are released,\n * the value of the key becomes undefined.\n * @property notes\n */\n this.notes = {};\n\n //indices of the most recently used, and least recently used audiovoice\n this._newest = 0;\n this._oldest = 0;\n\n /**\n * A PolySynth must have at least 1 voice, defaults to 8\n * @property polyvalue\n */\n this.maxVoices = maxVoices || 8;\n\n /**\n * Monosynth that generates the sound for each note that is triggered. The\n * p5.PolySynth defaults to using the p5.MonoSynth as its voice.\n * @property AudioVoice\n */\n this.AudioVoice = audioVoice === undefined ? p5.MonoSynth : audioVoice;\n\n /**\n * This value must only change as a note is attacked or released. Due to delay\n * and sustain times, Tone.TimelineSignal is required to schedule the change in value.\n\t * @private\n * @property {Tone.TimelineSignal} _voicesInUse\n */\n this._voicesInUse = new TimelineSignal(0);\n\n this.output = p5sound.audiocontext.createGain();\n this.connect();\n\n //Construct the appropriate number of audiovoices\n this._allocateVoices();\n p5sound.soundArray.push(this);\n };\n\n /**\n * Construct the appropriate number of audiovoices\n * @private\n * @for p5.PolySynth\n * @method _allocateVoices\n */\n p5.PolySynth.prototype._allocateVoices = function() {\n for(var i = 0; i< this.maxVoices; i++) {\n this.audiovoices.push(new this.AudioVoice());\n this.audiovoices[i].disconnect();\n this.audiovoices[i].connect(this.output);\n }\n };\n\n /**\n * Play a note by triggering noteAttack and noteRelease with sustain time\n *\n * @method play\n * @for p5.PolySynth\n * @param {Number} [note] midi note to play (ranging from 0 to 127 - 60 being a middle C)\n * @param {Number} [velocity] velocity of the note to play (ranging from 0 to 1)\n * @param {Number} [secondsFromNow] time from now (in seconds) at which to play\n * @param {Number} [sustainTime] time to sustain before releasing the envelope\n * @example\n *
\n * let polySynth;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playSynth);\n * background(220);\n * text('click to play', 20, 20);\n *\n * polySynth = new p5.PolySynth();\n * }\n *\n * function playSynth() {\n * userStartAudio();\n *\n * // note duration (in seconds)\n * let dur = 1.5;\n *\n * // time from now (in seconds)\n * let time = 0;\n *\n * // velocity (volume, from 0 to 1)\n * let vel = 0.1;\n *\n * // notes can overlap with each other\n * polySynth.play('G2', vel, 0, dur);\n * polySynth.play('C3', vel, time += 1/3, dur);\n * polySynth.play('G3', vel, time += 1/3, dur);\n * }\n *
\n */\n p5.PolySynth.prototype.play = function (note,velocity, secondsFromNow, susTime) {\n var susTime = susTime || 1;\n this.noteAttack(note, velocity, secondsFromNow);\n this.noteRelease(note, secondsFromNow + susTime);\n };\n\n\n /**\n * noteADSR sets the envelope for a specific note that has just been triggered.\n * Using this method modifies the envelope of whichever audiovoice is being used\n * to play the desired note. The envelope should be reset before noteRelease is called\n * in order to prevent the modified envelope from being used on other notes.\n *\n * @method noteADSR\n * @for p5.PolySynth\n * @param {Number} [note] Midi note on which ADSR should be set.\n * @param {Number} [attackTime] Time (in seconds before envelope\n * reaches Attack Level\n * @param {Number} [decayTime] Time (in seconds) before envelope\n * reaches Decay/Sustain Level\n * @param {Number} [susRatio] Ratio between attackLevel and releaseLevel, on a scale from 0 to 1,\n * where 1.0 = attackLevel, 0.0 = releaseLevel.\n * The susRatio determines the decayLevel and the level at which the\n * sustain portion of the envelope will sustain.\n * For example, if attackLevel is 0.4, releaseLevel is 0,\n * and susAmt is 0.5, the decayLevel would be 0.2. If attackLevel is\n * increased to 1.0 (using setRange),\n * then decayLevel would increase proportionally, to become 0.5.\n * @param {Number} [releaseTime] Time in seconds from now (defaults to 0)\n **/\n\n p5.PolySynth.prototype.noteADSR = function (note,a,d,s,r,timeFromNow) {\n var now = p5sound.audiocontext.currentTime;\n var timeFromNow = timeFromNow || 0;\n var t = now + timeFromNow\n this.audiovoices[ this.notes[note].getValueAtTime(t) ].setADSR(a,d,s,r);\n };\n\n\n /**\n * Set the PolySynths global envelope. This method modifies the envelopes of each\n * monosynth so that all notes are played with this envelope.\n *\n * @method setADSR\n * @for p5.PolySynth\n * @param {Number} [attackTime] Time (in seconds before envelope\n * reaches Attack Level\n * @param {Number} [decayTime] Time (in seconds) before envelope\n * reaches Decay/Sustain Level\n * @param {Number} [susRatio] Ratio between attackLevel and releaseLevel, on a scale from 0 to 1,\n * where 1.0 = attackLevel, 0.0 = releaseLevel.\n * The susRatio determines the decayLevel and the level at which the\n * sustain portion of the envelope will sustain.\n * For example, if attackLevel is 0.4, releaseLevel is 0,\n * and susAmt is 0.5, the decayLevel would be 0.2. If attackLevel is\n * increased to 1.0 (using setRange),\n * then decayLevel would increase proportionally, to become 0.5.\n * @param {Number} [releaseTime] Time in seconds from now (defaults to 0)\n **/\n p5.PolySynth.prototype.setADSR = function(a,d,s,r) {\n this.audiovoices.forEach(function(voice) {\n voice.setADSR(a,d,s,r);\n });\n };\n\n /**\n * Trigger the Attack, and Decay portion of a MonoSynth.\n * Similar to holding down a key on a piano, but it will\n * hold the sustain level until you let go.\n *\n * @method noteAttack\n * @for p5.PolySynth\n * @param {Number} [note] midi note on which attack should be triggered.\n * @param {Number} [velocity] velocity of the note to play (ranging from 0 to 1)/\n * @param {Number} [secondsFromNow] time from now (in seconds)\n * @example\n *
\n * let polySynth = new p5.PolySynth();\n * let pitches = ['G', 'D', 'G', 'C'];\n * let octaves = [2, 3, 4];\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playChord);\n * background(220);\n * text('tap to play', 20, 20);\n * }\n *\n * function playChord() {\n * userStartAudio();\n *\n * // play a chord: multiple notes at the same time\n * for (let i = 0; i < 4; i++) {\n * let note = random(pitches) + random(octaves);\n * polySynth.noteAttack(note, 0.1);\n * }\n * }\n *\n * function mouseReleased() {\n * // release all voices\n * polySynth.noteRelease();\n * }\n *
\n */\n p5.PolySynth.prototype.noteAttack = function (_note, _velocity, secondsFromNow) {\n //this value goes to the audiovoices which handle their own scheduling\n var secondsFromNow = ~~secondsFromNow;\n\n //this value is used by this._voicesInUse\n var acTime = p5sound.audiocontext.currentTime + secondsFromNow;\n\n //Convert note to frequency if necessary. This is because entries into this.notes\n //should be based on frequency for the sake of consistency.\n var note = noteToFreq(_note);\n var velocity = _velocity || 0.1;\n\n var currentVoice;\n\n //Release the note if it is already playing\n if (this.notes[note] && this.notes[note].getValueAtTime(acTime) !== null) {\n this.noteRelease(note, 0);\n }\n\n //Check to see how many voices are in use at the time the note will start\n if (this._voicesInUse.getValueAtTime(acTime) < this.maxVoices) {\n currentVoice = Math.max(~~this._voicesInUse.getValueAtTime(acTime), 0);\n }\n //If we are exceeding the polyvalue, bump off the oldest notes and replace\n //with a new note\n else {\n currentVoice = this._oldest;\n\n var oldestNote = p5.prototype.freqToMidi(this.audiovoices[this._oldest].oscillator.freq().value);\n this.noteRelease(oldestNote);\n this._oldest = ( this._oldest + 1 ) % (this.maxVoices - 1);\n }\n\n //Overrite the entry in the notes object. A note (frequency value)\n //corresponds to the index of the audiovoice that is playing it\n this.notes[note] = new TimelineSignal();\n this.notes[note].setValueAtTime(currentVoice, acTime);\n\n //Find the scheduled change in this._voicesInUse that will be previous to this new note\n //Add 1 and schedule this value at time 't', when this note will start playing\n var previousVal = this._voicesInUse._searchBefore(acTime) === null ? 0 : this._voicesInUse._searchBefore(acTime).value;\n this._voicesInUse.setValueAtTime(previousVal + 1, acTime);\n\n //Then update all scheduled values that follow to increase by 1\n this._updateAfter(acTime, 1);\n\n this._newest = currentVoice;\n //The audiovoice handles the actual scheduling of the note\n if (typeof velocity === 'number') {\n var maxRange = 1 / this._voicesInUse.getValueAtTime(acTime) * 2;\n velocity = velocity > maxRange ? maxRange : velocity;\n }\n this.audiovoices[currentVoice].triggerAttack(note, velocity, secondsFromNow);\n };\n\n /**\n * Private method to ensure accurate values of this._voicesInUse\n * Any time a new value is scheduled, it is necessary to increment all subsequent\n * scheduledValues after attack, and decrement all subsequent\n * scheduledValues after release\n *\n * @private\n * @for p5.PolySynth\n * @param {[type]} time [description]\n * @param {[type]} value [description]\n * @return {[type]} [description]\n */\n p5.PolySynth.prototype._updateAfter = function(time, value) {\n if(this._voicesInUse._searchAfter(time) === null) {\n return;\n } else{\n this._voicesInUse._searchAfter(time).value += value;\n var nextTime = this._voicesInUse._searchAfter(time).time;\n this._updateAfter(nextTime, value);\n }\n };\n\n\n /**\n * Trigger the Release of an AudioVoice note. This is similar to releasing\n * the key on a piano and letting the sound fade according to the\n * release level and release time.\n *\n * @method noteRelease\n * @for p5.PolySynth\n * @param {Number} [note] midi note on which attack should be triggered.\n * If no value is provided, all notes will be released.\n * @param {Number} [secondsFromNow] time to trigger the release\n * @example\n *
\n * let polySynth = new p5.PolySynth();\n * let pitches = ['G', 'D', 'G', 'C'];\n * let octaves = [2, 3, 4];\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playChord);\n * background(220);\n * text('tap to play', 20, 20);\n * }\n *\n * function playChord() {\n * userStartAudio();\n *\n * // play a chord: multiple notes at the same time\n * for (let i = 0; i < 4; i++) {\n * let note = random(pitches) + random(octaves);\n * polySynth.noteAttack(note, 0.1);\n * }\n * }\n *\n * function mouseReleased() {\n * // release all voices\n * polySynth.noteRelease();\n * }\n *
\n *\n */\n p5.PolySynth.prototype.noteRelease = function (_note,secondsFromNow) {\n var now = p5sound.audiocontext.currentTime;\n var tFromNow = secondsFromNow || 0;\n var t = now + tFromNow;\n\n // if a note value is not provided, release all voices\n if (!_note) {\n this.audiovoices.forEach(function(voice) {\n voice.triggerRelease(tFromNow)\n });\n this._voicesInUse.setValueAtTime(0, t);\n for (var n in this.notes) {\n this.notes[n].dispose();\n delete this.notes[n];\n }\n return;\n }\n\n //Make sure note is in frequency inorder to query the this.notes object\n var note = noteToFreq(_note);\n\n if (!this.notes[note] || this.notes[note].getValueAtTime(t) === null) {\n console.warn('Cannot release a note that is not already playing');\n } else {\n //Find the scheduled change in this._voicesInUse that will be previous to this new note\n //subtract 1 and schedule this value at time 't', when this note will stop playing\n var previousVal = Math.max(~~this._voicesInUse.getValueAtTime(t).value, 1);\n this._voicesInUse.setValueAtTime(previousVal - 1, t);\n //Then update all scheduled values that follow to decrease by 1 but never go below 0\n if (previousVal > 0) {\n this._updateAfter(t, -1);\n }\n\n this.audiovoices[ this.notes[note].getValueAtTime(t) ].triggerRelease(tFromNow);\n this.notes[note].dispose();\n delete this.notes[note];\n\n this._newest = this._newest === 0 ? 0 : (this._newest - 1) % (this.maxVoices - 1);\n }\n\n };\n\n /**\n * Connect to a p5.sound / Web Audio object.\n *\n * @method connect\n * @for p5.PolySynth\n * @param {Object} unit A p5.sound or Web Audio object\n */\n p5.PolySynth.prototype.connect = function (unit) {\n var u = unit || p5sound.input;\n this.output.connect(u.input ? u.input : u);\n };\n\n /**\n * Disconnect all outputs\n *\n * @method disconnect\n * @for p5.PolySynth\n */\n p5.PolySynth.prototype.disconnect = function() {\n if (this.output) {\n this.output.disconnect();\n }\n };\n\n /**\n * Get rid of the MonoSynth and free up its resources / memory.\n *\n * @method dispose\n * @for p5.PolySynth\n */\n p5.PolySynth.prototype.dispose = function() {\n this.audiovoices.forEach(function(voice) {\n voice.dispose();\n });\n\n if (this.output) {\n this.output.disconnect();\n delete this.output;\n }\n };\n\n});\n","'use strict';\n\ndefine(function (require) {\n\n require('audioworklet-polyfill');\n require('shims');\n require('audiocontext');\n var p5SOUND = require('master');\n require('helpers');\n require('errorHandler');\n require('audioWorklet');\n require('panner');\n require('soundfile');\n require('amplitude');\n require('fft');\n require('signal');\n require('oscillator');\n require('envelope');\n require('pulse');\n require('noise');\n require('audioin');\n require('filter');\n require('eq');\n require('panner3d');\n require('listener3d');\n require('delay');\n require('reverb');\n require('metro');\n require('looper');\n require('soundLoop');\n require('compressor');\n require('soundRecorder');\n require('peakDetect');\n require('gain');\n require('monosynth');\n require('polysynth');\n require('distortion');\n require('audioVoice');\n require('monosynth');\n require('polysynth');\n\n return p5SOUND;\n\n});\n","!function(){var e,t=[];function r(e){var r=this,n={},i=-1;this.parameters.forEach(function(e,o){var s=t[++i]||(t[i]=new Float32Array(r.bufferSize));s.fill(e.value),n[o]=s}),this.processor.realm.exec(\"self.sampleRate=sampleRate=\"+this.context.sampleRate+\";self.currentTime=currentTime=\"+this.context.currentTime);var s=o(e.inputBuffer),a=o(e.outputBuffer);this.instance.process([s],[a],n)}function o(e){for(var t=[],r=0;r= this._length) {\\n this._writeIndex = 0;\\n } // For excessive frames, the buffer will be overwritten.\\n\\n\\n this._framesAvailable += sourceLength;\\n\\n if (this._framesAvailable > this._length) {\\n this._framesAvailable = this._length;\\n }\\n }\\n /**\\n * Pull data out of buffer and fill a given sequence of Float32Arrays.\\n *\\n * @param {array} arraySequence An array of Float32Arrays.\\n */\\n\\n }, {\\n key: \\\"pull\\\",\\n value: function pull(arraySequence) {\\n // The channel count of arraySequence and the length of each channel must\\n // match with this buffer obejct.\\n // If the FIFO is completely empty, do nothing.\\n if (this._framesAvailable === 0) {\\n return;\\n }\\n\\n var destinationLength = arraySequence[0].length; // Transfer data from the internal buffer to the |arraySequence| storage.\\n\\n for (var i = 0; i < destinationLength; ++i) {\\n var readIndex = (this._readIndex + i) % this._length;\\n\\n for (var channel = 0; channel < this._channelCount; ++channel) {\\n arraySequence[channel][i] = this._channelData[channel][readIndex];\\n }\\n }\\n\\n this._readIndex += destinationLength;\\n\\n if (this._readIndex >= this._length) {\\n this._readIndex = 0;\\n }\\n\\n this._framesAvailable -= destinationLength;\\n\\n if (this._framesAvailable < 0) {\\n this._framesAvailable = 0;\\n }\\n }\\n }, {\\n key: \\\"framesAvailable\\\",\\n get: function get() {\\n return this._framesAvailable;\\n }\\n }]);\\n\\n return RingBuffer;\\n }()\\n}[\\\"default\\\"];\\n\\nvar RecorderProcessor =\\n/*#__PURE__*/\\nfunction (_AudioWorkletProcesso) {\\n _inherits(RecorderProcessor, _AudioWorkletProcesso);\\n\\n function RecorderProcessor(options) {\\n var _this;\\n\\n _classCallCheck(this, RecorderProcessor);\\n\\n _this = _possibleConstructorReturn(this, _getPrototypeOf(RecorderProcessor).call(this));\\n var processorOptions = options.processorOptions || {};\\n _this.numOutputChannels = options.outputChannelCount || 2;\\n _this.numInputChannels = processorOptions.numInputChannels || 2;\\n _this.bufferSize = processorOptions.bufferSize || 1024;\\n _this.recording = false;\\n\\n _this.clear();\\n\\n _this.port.onmessage = function (event) {\\n var data = event.data;\\n\\n if (data.name === 'start') {\\n _this.record(data.duration);\\n } else if (data.name === 'stop') {\\n _this.stop();\\n }\\n };\\n\\n return _this;\\n }\\n\\n _createClass(RecorderProcessor, [{\\n key: \\\"process\\\",\\n value: function process(inputs) {\\n if (!this.recording) {\\n return true;\\n } else if (this.sampleLimit && this.recordedSamples >= this.sampleLimit) {\\n this.stop();\\n return true;\\n }\\n\\n var input = inputs[0];\\n this.inputRingBuffer.push(input);\\n\\n if (this.inputRingBuffer.framesAvailable >= this.bufferSize) {\\n this.inputRingBuffer.pull(this.inputRingBufferArraySequence);\\n\\n for (var channel = 0; channel < this.numOutputChannels; ++channel) {\\n var inputChannelCopy = this.inputRingBufferArraySequence[channel].slice();\\n\\n if (channel === 0) {\\n this.leftBuffers.push(inputChannelCopy);\\n\\n if (this.numInputChannels === 1) {\\n this.rightBuffers.push(inputChannelCopy);\\n }\\n } else if (channel === 1 && this.numInputChannels > 1) {\\n this.rightBuffers.push(inputChannelCopy);\\n }\\n }\\n\\n this.recordedSamples += this.bufferSize;\\n }\\n\\n return true;\\n }\\n }, {\\n key: \\\"record\\\",\\n value: function record(duration) {\\n if (duration) {\\n this.sampleLimit = Math.round(duration * sampleRate);\\n }\\n\\n this.recording = true;\\n }\\n }, {\\n key: \\\"stop\\\",\\n value: function stop() {\\n this.recording = false;\\n var buffers = this.getBuffers();\\n var leftBuffer = buffers[0].buffer;\\n var rightBuffer = buffers[1].buffer;\\n this.port.postMessage({\\n name: 'buffers',\\n leftBuffer: leftBuffer,\\n rightBuffer: rightBuffer\\n }, [leftBuffer, rightBuffer]);\\n this.clear();\\n }\\n }, {\\n key: \\\"getBuffers\\\",\\n value: function getBuffers() {\\n var buffers = [];\\n buffers.push(this.mergeBuffers(this.leftBuffers));\\n buffers.push(this.mergeBuffers(this.rightBuffers));\\n return buffers;\\n }\\n }, {\\n key: \\\"mergeBuffers\\\",\\n value: function mergeBuffers(channelBuffer) {\\n var result = new Float32Array(this.recordedSamples);\\n var offset = 0;\\n var lng = channelBuffer.length;\\n\\n for (var i = 0; i < lng; i++) {\\n var buffer = channelBuffer[i];\\n result.set(buffer, offset);\\n offset += buffer.length;\\n }\\n\\n return result;\\n }\\n }, {\\n key: \\\"clear\\\",\\n value: function clear() {\\n var _this2 = this;\\n\\n this.leftBuffers = [];\\n this.rightBuffers = [];\\n this.inputRingBuffer = new RingBuffer(this.bufferSize, this.numInputChannels);\\n this.inputRingBufferArraySequence = new Array(this.numInputChannels).fill(null).map(function () {\\n return new Float32Array(_this2.bufferSize);\\n });\\n this.recordedSamples = 0;\\n this.sampleLimit = null;\\n }\\n }]);\\n\\n return RecorderProcessor;\\n}(_wrapNativeSuper(AudioWorkletProcessor));\\n\\nregisterProcessor(processorNames.recorderProcessor, RecorderProcessor);\"","export default \"function _typeof(obj) { if (typeof Symbol === \\\"function\\\" && typeof Symbol.iterator === \\\"symbol\\\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \\\"function\\\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \\\"symbol\\\" : typeof obj; }; } return _typeof(obj); }\\n\\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \\\"object\\\" || typeof call === \\\"function\\\")) { return call; } return _assertThisInitialized(self); }\\n\\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\\\"this hasn't been initialised - super() hasn't been called\\\"); } return self; }\\n\\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \\\"function\\\" && superClass !== null) { throw new TypeError(\\\"Super expression must either be null or a function\\\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }\\n\\nfunction _wrapNativeSuper(Class) { var _cache = typeof Map === \\\"function\\\" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== \\\"function\\\") { throw new TypeError(\\\"Super expression must either be null or a function\\\"); } if (typeof _cache !== \\\"undefined\\\") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }\\n\\nfunction isNativeReflectConstruct() { if (typeof Reflect === \\\"undefined\\\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \\\"function\\\") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\\n\\nfunction _construct(Parent, args, Class) { if (isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }\\n\\nfunction _isNativeFunction(fn) { return Function.toString.call(fn).indexOf(\\\"[native code]\\\") !== -1; }\\n\\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\\n\\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\\n\\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\\\"Cannot call a class as a function\\\"); } }\\n\\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\\\"value\\\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\\n\\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\\n\\n// import dependencies via preval.require so that they're available as values at compile time\\nvar processorNames = {\\n \\\"recorderProcessor\\\": \\\"recorder-processor\\\",\\n \\\"soundFileProcessor\\\": \\\"sound-file-processor\\\",\\n \\\"amplitudeProcessor\\\": \\\"amplitude-processor\\\"\\n};\\nvar RingBuffer = {\\n \\\"default\\\":\\n /*#__PURE__*/\\n function () {\\n /**\\n * @constructor\\n * @param {number} length Buffer length in frames.\\n * @param {number} channelCount Buffer channel count.\\n */\\n function RingBuffer(length, channelCount) {\\n _classCallCheck(this, RingBuffer);\\n\\n this._readIndex = 0;\\n this._writeIndex = 0;\\n this._framesAvailable = 0;\\n this._channelCount = channelCount;\\n this._length = length;\\n this._channelData = [];\\n\\n for (var i = 0; i < this._channelCount; ++i) {\\n this._channelData[i] = new Float32Array(length);\\n }\\n }\\n /**\\n * Getter for Available frames in buffer.\\n *\\n * @return {number} Available frames in buffer.\\n */\\n\\n\\n _createClass(RingBuffer, [{\\n key: \\\"push\\\",\\n\\n /**\\n * Push a sequence of Float32Arrays to buffer.\\n *\\n * @param {array} arraySequence A sequence of Float32Arrays.\\n */\\n value: function push(arraySequence) {\\n // The channel count of arraySequence and the length of each channel must\\n // match with this buffer obejct.\\n // Transfer data from the |arraySequence| storage to the internal buffer.\\n var sourceLength = arraySequence[0].length;\\n\\n for (var i = 0; i < sourceLength; ++i) {\\n var writeIndex = (this._writeIndex + i) % this._length;\\n\\n for (var channel = 0; channel < this._channelCount; ++channel) {\\n this._channelData[channel][writeIndex] = arraySequence[channel][i];\\n }\\n }\\n\\n this._writeIndex += sourceLength;\\n\\n if (this._writeIndex >= this._length) {\\n this._writeIndex = 0;\\n } // For excessive frames, the buffer will be overwritten.\\n\\n\\n this._framesAvailable += sourceLength;\\n\\n if (this._framesAvailable > this._length) {\\n this._framesAvailable = this._length;\\n }\\n }\\n /**\\n * Pull data out of buffer and fill a given sequence of Float32Arrays.\\n *\\n * @param {array} arraySequence An array of Float32Arrays.\\n */\\n\\n }, {\\n key: \\\"pull\\\",\\n value: function pull(arraySequence) {\\n // The channel count of arraySequence and the length of each channel must\\n // match with this buffer obejct.\\n // If the FIFO is completely empty, do nothing.\\n if (this._framesAvailable === 0) {\\n return;\\n }\\n\\n var destinationLength = arraySequence[0].length; // Transfer data from the internal buffer to the |arraySequence| storage.\\n\\n for (var i = 0; i < destinationLength; ++i) {\\n var readIndex = (this._readIndex + i) % this._length;\\n\\n for (var channel = 0; channel < this._channelCount; ++channel) {\\n arraySequence[channel][i] = this._channelData[channel][readIndex];\\n }\\n }\\n\\n this._readIndex += destinationLength;\\n\\n if (this._readIndex >= this._length) {\\n this._readIndex = 0;\\n }\\n\\n this._framesAvailable -= destinationLength;\\n\\n if (this._framesAvailable < 0) {\\n this._framesAvailable = 0;\\n }\\n }\\n }, {\\n key: \\\"framesAvailable\\\",\\n get: function get() {\\n return this._framesAvailable;\\n }\\n }]);\\n\\n return RingBuffer;\\n }()\\n}[\\\"default\\\"];\\n\\nvar SoundFileProcessor =\\n/*#__PURE__*/\\nfunction (_AudioWorkletProcesso) {\\n _inherits(SoundFileProcessor, _AudioWorkletProcesso);\\n\\n function SoundFileProcessor(options) {\\n var _this;\\n\\n _classCallCheck(this, SoundFileProcessor);\\n\\n _this = _possibleConstructorReturn(this, _getPrototypeOf(SoundFileProcessor).call(this));\\n var processorOptions = options.processorOptions || {};\\n _this.bufferSize = processorOptions.bufferSize || 256;\\n _this.inputRingBuffer = new RingBuffer(_this.bufferSize, 1);\\n _this.inputRingBufferArraySequence = [new Float32Array(_this.bufferSize)];\\n return _this;\\n }\\n\\n _createClass(SoundFileProcessor, [{\\n key: \\\"process\\\",\\n value: function process(inputs) {\\n var input = inputs[0]; // we only care about the first input channel, because that contains the position data\\n\\n this.inputRingBuffer.push([input[0]]);\\n\\n if (this.inputRingBuffer.framesAvailable >= this.bufferSize) {\\n this.inputRingBuffer.pull(this.inputRingBufferArraySequence);\\n var inputChannel = this.inputRingBufferArraySequence[0];\\n var position = inputChannel[inputChannel.length - 1] || 0;\\n this.port.postMessage({\\n name: 'position',\\n position: position\\n });\\n }\\n\\n return true;\\n }\\n }]);\\n\\n return SoundFileProcessor;\\n}(_wrapNativeSuper(AudioWorkletProcessor));\\n\\nregisterProcessor(processorNames.soundFileProcessor, SoundFileProcessor);\"","export default \"function _typeof(obj) { if (typeof Symbol === \\\"function\\\" && typeof Symbol.iterator === \\\"symbol\\\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \\\"function\\\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \\\"symbol\\\" : typeof obj; }; } return _typeof(obj); }\\n\\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \\\"object\\\" || typeof call === \\\"function\\\")) { return call; } return _assertThisInitialized(self); }\\n\\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\\\"this hasn't been initialised - super() hasn't been called\\\"); } return self; }\\n\\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \\\"function\\\" && superClass !== null) { throw new TypeError(\\\"Super expression must either be null or a function\\\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }\\n\\nfunction _wrapNativeSuper(Class) { var _cache = typeof Map === \\\"function\\\" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== \\\"function\\\") { throw new TypeError(\\\"Super expression must either be null or a function\\\"); } if (typeof _cache !== \\\"undefined\\\") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }\\n\\nfunction isNativeReflectConstruct() { if (typeof Reflect === \\\"undefined\\\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \\\"function\\\") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\\n\\nfunction _construct(Parent, args, Class) { if (isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }\\n\\nfunction _isNativeFunction(fn) { return Function.toString.call(fn).indexOf(\\\"[native code]\\\") !== -1; }\\n\\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\\n\\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\\n\\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\\\"Cannot call a class as a function\\\"); } }\\n\\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\\\"value\\\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\\n\\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\\n\\n// import dependencies via preval.require so that they're available as values at compile time\\nvar processorNames = {\\n \\\"recorderProcessor\\\": \\\"recorder-processor\\\",\\n \\\"soundFileProcessor\\\": \\\"sound-file-processor\\\",\\n \\\"amplitudeProcessor\\\": \\\"amplitude-processor\\\"\\n};\\nvar RingBuffer = {\\n \\\"default\\\":\\n /*#__PURE__*/\\n function () {\\n /**\\n * @constructor\\n * @param {number} length Buffer length in frames.\\n * @param {number} channelCount Buffer channel count.\\n */\\n function RingBuffer(length, channelCount) {\\n _classCallCheck(this, RingBuffer);\\n\\n this._readIndex = 0;\\n this._writeIndex = 0;\\n this._framesAvailable = 0;\\n this._channelCount = channelCount;\\n this._length = length;\\n this._channelData = [];\\n\\n for (var i = 0; i < this._channelCount; ++i) {\\n this._channelData[i] = new Float32Array(length);\\n }\\n }\\n /**\\n * Getter for Available frames in buffer.\\n *\\n * @return {number} Available frames in buffer.\\n */\\n\\n\\n _createClass(RingBuffer, [{\\n key: \\\"push\\\",\\n\\n /**\\n * Push a sequence of Float32Arrays to buffer.\\n *\\n * @param {array} arraySequence A sequence of Float32Arrays.\\n */\\n value: function push(arraySequence) {\\n // The channel count of arraySequence and the length of each channel must\\n // match with this buffer obejct.\\n // Transfer data from the |arraySequence| storage to the internal buffer.\\n var sourceLength = arraySequence[0].length;\\n\\n for (var i = 0; i < sourceLength; ++i) {\\n var writeIndex = (this._writeIndex + i) % this._length;\\n\\n for (var channel = 0; channel < this._channelCount; ++channel) {\\n this._channelData[channel][writeIndex] = arraySequence[channel][i];\\n }\\n }\\n\\n this._writeIndex += sourceLength;\\n\\n if (this._writeIndex >= this._length) {\\n this._writeIndex = 0;\\n } // For excessive frames, the buffer will be overwritten.\\n\\n\\n this._framesAvailable += sourceLength;\\n\\n if (this._framesAvailable > this._length) {\\n this._framesAvailable = this._length;\\n }\\n }\\n /**\\n * Pull data out of buffer and fill a given sequence of Float32Arrays.\\n *\\n * @param {array} arraySequence An array of Float32Arrays.\\n */\\n\\n }, {\\n key: \\\"pull\\\",\\n value: function pull(arraySequence) {\\n // The channel count of arraySequence and the length of each channel must\\n // match with this buffer obejct.\\n // If the FIFO is completely empty, do nothing.\\n if (this._framesAvailable === 0) {\\n return;\\n }\\n\\n var destinationLength = arraySequence[0].length; // Transfer data from the internal buffer to the |arraySequence| storage.\\n\\n for (var i = 0; i < destinationLength; ++i) {\\n var readIndex = (this._readIndex + i) % this._length;\\n\\n for (var channel = 0; channel < this._channelCount; ++channel) {\\n arraySequence[channel][i] = this._channelData[channel][readIndex];\\n }\\n }\\n\\n this._readIndex += destinationLength;\\n\\n if (this._readIndex >= this._length) {\\n this._readIndex = 0;\\n }\\n\\n this._framesAvailable -= destinationLength;\\n\\n if (this._framesAvailable < 0) {\\n this._framesAvailable = 0;\\n }\\n }\\n }, {\\n key: \\\"framesAvailable\\\",\\n get: function get() {\\n return this._framesAvailable;\\n }\\n }]);\\n\\n return RingBuffer;\\n }()\\n}[\\\"default\\\"];\\n\\nvar AmplitudeProcessor =\\n/*#__PURE__*/\\nfunction (_AudioWorkletProcesso) {\\n _inherits(AmplitudeProcessor, _AudioWorkletProcesso);\\n\\n function AmplitudeProcessor(options) {\\n var _this;\\n\\n _classCallCheck(this, AmplitudeProcessor);\\n\\n _this = _possibleConstructorReturn(this, _getPrototypeOf(AmplitudeProcessor).call(this));\\n var processorOptions = options.processorOptions || {};\\n _this.numOutputChannels = options.outputChannelCount || 1;\\n _this.numInputChannels = processorOptions.numInputChannels || 2;\\n _this.normalize = processorOptions.normalize || false;\\n _this.smoothing = processorOptions.smoothing || 0;\\n _this.bufferSize = processorOptions.bufferSize || 2048;\\n _this.inputRingBuffer = new RingBuffer(_this.bufferSize, _this.numInputChannels);\\n _this.outputRingBuffer = new RingBuffer(_this.bufferSize, _this.numOutputChannels);\\n _this.inputRingBufferArraySequence = new Array(_this.numInputChannels).fill(null).map(function () {\\n return new Float32Array(_this.bufferSize);\\n });\\n _this.stereoVol = [0, 0];\\n _this.stereoVolNorm = [0, 0];\\n _this.volMax = 0.001;\\n\\n _this.port.onmessage = function (event) {\\n var data = event.data;\\n\\n if (data.name === 'toggleNormalize') {\\n _this.normalize = data.normalize;\\n } else if (data.name === 'smoothing') {\\n _this.smoothing = Math.max(0, Math.min(1, data.smoothing));\\n }\\n };\\n\\n return _this;\\n } // TO DO make this stereo / dependent on # of audio channels\\n\\n\\n _createClass(AmplitudeProcessor, [{\\n key: \\\"process\\\",\\n value: function process(inputs, outputs) {\\n var input = inputs[0];\\n var output = outputs[0];\\n var smoothing = this.smoothing;\\n this.inputRingBuffer.push(input);\\n\\n if (this.inputRingBuffer.framesAvailable >= this.bufferSize) {\\n this.inputRingBuffer.pull(this.inputRingBufferArraySequence);\\n\\n for (var channel = 0; channel < this.numInputChannels; ++channel) {\\n var inputBuffer = this.inputRingBufferArraySequence[channel];\\n var bufLength = inputBuffer.length;\\n var sum = 0;\\n\\n for (var i = 0; i < bufLength; i++) {\\n var x = inputBuffer[i];\\n\\n if (this.normalize) {\\n sum += Math.max(Math.min(x / this.volMax, 1), -1) * Math.max(Math.min(x / this.volMax, 1), -1);\\n } else {\\n sum += x * x;\\n }\\n } // ... then take the square root of the sum.\\n\\n\\n var rms = Math.sqrt(sum / bufLength);\\n this.stereoVol[channel] = Math.max(rms, this.stereoVol[channel] * smoothing);\\n this.volMax = Math.max(this.stereoVol[channel], this.volMax);\\n } // calculate stero normalized volume and add volume from all channels together\\n\\n\\n var volSum = 0;\\n\\n for (var index = 0; index < this.stereoVol.length; index++) {\\n this.stereoVolNorm[index] = Math.max(Math.min(this.stereoVol[index] / this.volMax, 1), 0);\\n volSum += this.stereoVol[index];\\n } // volume is average of channels\\n\\n\\n var volume = volSum / this.stereoVol.length; // normalized value\\n\\n var volNorm = Math.max(Math.min(volume / this.volMax, 1), 0);\\n this.port.postMessage({\\n name: 'amplitude',\\n volume: volume,\\n volNorm: volNorm,\\n stereoVol: this.stereoVol,\\n stereoVolNorm: this.stereoVolNorm\\n }); // pass input through to output\\n\\n this.outputRingBuffer.push(this.inputRingBufferArraySequence);\\n } // pull 128 frames out of the ring buffer\\n // if the ring buffer does not have enough frames, the output will be silent\\n\\n\\n this.outputRingBuffer.pull(output);\\n return true;\\n }\\n }]);\\n\\n return AmplitudeProcessor;\\n}(_wrapNativeSuper(AudioWorkletProcessor));\\n\\nregisterProcessor(processorNames.amplitudeProcessor, AmplitudeProcessor);\"","'use strict';\n\ndefine(function (require) {\n\n var p5sound = require('master');\n var ac = p5sound.audiocontext;\n\n // Stereo panner\n // if there is a stereo panner node use it\n if(typeof ac.createStereoPanner !== 'undefined') {\n p5.Panner = function (input, output) {\n this.stereoPanner = this.input = ac.createStereoPanner();\n input.connect(this.stereoPanner);\n this.stereoPanner.connect(output);\n };\n\n p5.Panner.prototype.pan = function(val, tFromNow) {\n var time = tFromNow || 0;\n var t = ac.currentTime + time;\n\n this.stereoPanner.pan.linearRampToValueAtTime(val, t);\n };\n\n //not implemented because stereopanner\n //node does not require this and will automatically\n //convert single channel or multichannel to stereo.\n //tested with single and stereo, not with (>2) multichannel\n p5.Panner.prototype.inputChannels = function() {};\n\n p5.Panner.prototype.connect = function(obj) {\n this.stereoPanner.connect(obj);\n };\n\n p5.Panner.prototype.disconnect = function() {\n if (this.stereoPanner) {\n this.stereoPanner.disconnect();\n }\n };\n\n } else {\n // if there is no createStereoPanner object\n // such as in safari 7.1.7 at the time of writing this\n // use this method to create the effect\n p5.Panner = function(input, output, numInputChannels) {\n this.input = ac.createGain();\n input.connect(this.input);\n\n this.left = ac.createGain();\n this.right = ac.createGain();\n this.left.channelInterpretation = 'discrete';\n this.right.channelInterpretation = 'discrete';\n\n // if input is stereo\n if (numInputChannels > 1) {\n this.splitter = ac.createChannelSplitter(2);\n this.input.connect(this.splitter);\n\n this.splitter.connect(this.left, 1);\n this.splitter.connect(this.right, 0);\n }\n else {\n this.input.connect(this.left);\n this.input.connect(this.right);\n }\n\n this.output = ac.createChannelMerger(2);\n this.left.connect(this.output, 0, 1);\n this.right.connect(this.output, 0, 0);\n this.output.connect(output);\n };\n\n // -1 is left, +1 is right\n p5.Panner.prototype.pan = function(val, tFromNow) {\n var time = tFromNow || 0;\n var t = ac.currentTime + time;\n var v = (val + 1) / 2;\n var rightVal = Math.cos(v*Math.PI/2);\n var leftVal = Math.sin(v * Math.PI/2);\n this.left.gain.linearRampToValueAtTime(leftVal, t);\n this.right.gain.linearRampToValueAtTime(rightVal, t);\n };\n\n p5.Panner.prototype.inputChannels = function(numChannels) {\n if (numChannels === 1) {\n this.input.disconnect();\n this.input.connect(this.left);\n this.input.connect(this.right);\n } else if (numChannels === 2) {\n if (typeof(this.splitter === 'undefined')) {\n this.splitter = ac.createChannelSplitter(2);\n }\n this.input.disconnect();\n this.input.connect(this.splitter);\n this.splitter.connect(this.left, 1);\n this.splitter.connect(this.right, 0);\n }\n };\n\n p5.Panner.prototype.connect = function(obj) {\n this.output.connect(obj);\n };\n\n p5.Panner.prototype.disconnect = function() {\n if (this.output) {\n this.output.disconnect();\n }\n };\n }\n});\n","'use strict';\n\ndefine(function (require) {\n\n const CustomError = require('errorHandler');\n const p5sound = require('master');\n const ac = p5sound.audiocontext;\n const { midiToFreq, convertToWav, safeBufferSize } = require('helpers');\n var processorNames = require('./audioWorklet/processorNames');\n\n /**\n *

SoundFile object with a path to a file.

\n *\n *

The p5.SoundFile may not be available immediately because\n * it loads the file information asynchronously.

\n *\n *

To do something with the sound as soon as it loads\n * pass the name of a function as the second parameter.

\n *\n *

Only one file path is required. However, audio file formats\n * (i.e. mp3, ogg, wav and m4a/aac) are not supported by all\n * web browsers. If you want to ensure compatability, instead of a single\n * file path, you may include an Array of filepaths, and the browser will\n * choose a format that works.

\n *\n * @class p5.SoundFile\n * @constructor\n * @param {String|Array} path path to a sound file (String). Optionally,\n * you may include multiple file formats in\n * an array. Alternately, accepts an object\n * from the HTML5 File API, or a p5.File.\n * @param {Function} [successCallback] Name of a function to call once file loads\n * @param {Function} [errorCallback] Name of a function to call if file fails to\n * load. This function will receive an error or\n * XMLHttpRequest object with information\n * about what went wrong.\n * @param {Function} [whileLoadingCallback] Name of a function to call while file\n * is loading. That function will\n * receive progress of the request to\n * load the sound file\n * (between 0 and 1) as its first\n * parameter. This progress\n * does not account for the additional\n * time needed to decode the audio data.\n *\n * @example\n *
\n * let mySound;\n * function preload() {\n * soundFormats('mp3', 'ogg');\n * mySound = loadSound('assets/doorbell');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * text('tap here to play', 10, 20);\n * }\n *\n * function canvasPressed() {\n * // playing a sound file on a user gesture\n * // is equivalent to `userStartAudio()`\n * mySound.play();\n * }\n *
\n */\n p5.SoundFile = function(paths, onload, onerror, whileLoading) {\n if (typeof paths !== 'undefined') {\n if (typeof paths === 'string' || typeof paths[0] === 'string') {\n var path = p5.prototype._checkFileFormats(paths);\n this.url = path;\n }\n else if(typeof paths === 'object') {\n if (!(window.File && window.FileReader && window.FileList && window.Blob)) {\n // The File API isn't supported in this browser\n throw 'Unable to load file because the File API is not supported';\n }\n }\n\n // if type is a p5.File...get the actual file\n if (paths.file) {\n paths = paths.file;\n }\n\n this.file = paths;\n }\n\n // private _onended callback, set by the method: onended(callback)\n this._onended = function() {};\n\n this._looping = false;\n this._playing = false;\n this._paused = false;\n this._pauseTime = 0;\n\n // cues for scheduling events with addCue() removeCue()\n this._cues = [];\n this._cueIDCounter = 0;\n\n // position of the most recently played sample\n this._lastPos = 0;\n this._counterNode = null;\n this._workletNode = null;\n\n // array of sources so that they can all be stopped!\n this.bufferSourceNodes = [];\n\n // current source\n this.bufferSourceNode = null;\n\n this.buffer = null;\n this.playbackRate = 1;\n\n this.input = p5sound.audiocontext.createGain();\n this.output = p5sound.audiocontext.createGain();\n\n this.reversed = false;\n\n // start and end of playback / loop\n this.startTime = 0;\n this.endTime = null;\n this.pauseTime = 0;\n\n // \"restart\" would stop playback before retriggering\n this.mode = 'sustain';\n\n // time that playback was started, in millis\n this.startMillis = null;\n\n // stereo panning\n this.panPosition = 0.0;\n this.panner = new p5.Panner(this.output, p5sound.input, 2);\n\n // it is possible to instantiate a soundfile with no path\n if (this.url || this.file) {\n this.load(onload, onerror);\n }\n\n // add this p5.SoundFile to the soundArray\n p5sound.soundArray.push(this);\n\n if (typeof whileLoading === 'function') {\n this._whileLoading = whileLoading;\n } else {\n this._whileLoading = function() {};\n }\n\n this._clearOnEnd = _clearOnEnd.bind(this);\n };\n\n // register preload handling of loadSound\n p5.prototype.registerPreloadMethod('loadSound', p5.prototype);\n\n /**\n * loadSound() returns a new p5.SoundFile from a specified\n * path. If called during preload(), the p5.SoundFile will be ready\n * to play in time for setup() and draw(). If called outside of\n * preload, the p5.SoundFile will not be ready immediately, so\n * loadSound accepts a callback as the second parameter. Using a\n * \n * local server is recommended when loading external files.\n *\n * @method loadSound\n * @for p5\n * @param {String|Array} path Path to the sound file, or an array with\n * paths to soundfiles in multiple formats\n * i.e. ['sound.ogg', 'sound.mp3'].\n * Alternately, accepts an object: either\n * from the HTML5 File API, or a p5.File.\n * @param {Function} [successCallback] Name of a function to call once file loads\n * @param {Function} [errorCallback] Name of a function to call if there is\n * an error loading the file.\n * @param {Function} [whileLoading] Name of a function to call while file is loading.\n * This function will receive the percentage loaded\n * so far, from 0.0 to 1.0.\n * @return {SoundFile} Returns a p5.SoundFile\n * @example\n *
\n * let mySound;\n * function preload() {\n * soundFormats('mp3', 'ogg');\n * mySound = loadSound('assets/doorbell');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * text('tap here to play', 10, 20);\n * }\n *\n * function canvasPressed() {\n * // playing a sound file on a user gesture\n * // is equivalent to `userStartAudio()`\n * mySound.play();\n * }\n *
\n */\n p5.prototype.loadSound = function(path, callback, onerror, whileLoading) {\n // if loading locally without a server\n if (window.location.origin.indexOf('file://') > -1 && window.cordova === 'undefined' ) {\n window.alert('This sketch may require a server to load external files. Please see http://bit.ly/1qcInwS');\n }\n\n var self = this;\n var s = new p5.SoundFile(path, function() {\n if(typeof callback === 'function') {\n callback.apply(self, arguments);\n }\n\n if (typeof self._decrementPreload === 'function') {\n self._decrementPreload();\n }\n }, onerror, whileLoading);\n\n return s;\n };\n\n /**\n * This is a helper function that the p5.SoundFile calls to load\n * itself. Accepts a callback (the name of another function)\n * as an optional parameter.\n *\n * @private\n * @for p5.SoundFile\n * @param {Function} [successCallback] Name of a function to call once file loads\n * @param {Function} [errorCallback] Name of a function to call if there is an error\n */\n p5.SoundFile.prototype.load = function(callback, errorCallback) {\n var self = this;\n var errorTrace = new Error().stack;\n\n if (this.url !== undefined && this.url !== '') {\n var request = new XMLHttpRequest();\n request.addEventListener('progress', function(evt) {\n self._updateProgress(evt);\n }, false);\n request.open('GET', this.url, true);\n request.responseType = 'arraybuffer';\n\n request.onload = function() {\n if (request.status === 200) {\n // on sucess loading file:\n if (!self.panner) return;\n ac.decodeAudioData(request.response,\n // success decoding buffer:\n function(buff) {\n if (!self.panner) return;\n self.buffer = buff;\n self.panner.inputChannels(buff.numberOfChannels);\n if (callback) {\n callback(self);\n }\n },\n // error decoding buffer. \"e\" is undefined in Chrome 11/22/2015\n function() {\n if (!self.panner) return;\n var err = new CustomError('decodeAudioData', errorTrace, self.url);\n var msg = 'AudioContext error at decodeAudioData for ' + self.url;\n if (errorCallback) {\n err.msg = msg;\n errorCallback(err);\n } else {\n console.error(msg +'\\n The error stack trace includes: \\n' + err.stack);\n }\n }\n );\n }\n // if request status != 200, it failed\n else {\n if (!self.panner) return;\n var err = new CustomError('loadSound', errorTrace, self.url);\n var msg = 'Unable to load ' + self.url + '. The request status was: ' +\n request.status + ' (' + request.statusText + ')';\n\n if (errorCallback) {\n err.message = msg;\n errorCallback(err);\n } else {\n console.error(msg +'\\n The error stack trace includes: \\n' + err.stack);\n }\n }\n };\n\n // if there is another error, aside from 404...\n request.onerror = function() {\n var err = new CustomError('loadSound', errorTrace, self.url);\n var msg = 'There was no response from the server at ' + self.url + '. Check the url and internet connectivity.';\n\n if (errorCallback) {\n err.message = msg;\n errorCallback(err);\n } else {\n console.error(msg +'\\n The error stack trace includes: \\n' + err.stack);\n }\n };\n\n request.send();\n }\n else if (this.file !== undefined) {\n var reader = new FileReader();\n reader.onload = function() {\n if (!self.panner) return;\n ac.decodeAudioData(reader.result, function(buff) {\n if (!self.panner) return;\n self.buffer = buff;\n self.panner.inputChannels(buff.numberOfChannels);\n if (callback) {\n callback(self);\n }\n });\n };\n reader.onerror = function(e) {\n if (!self.panner) return;\n if (onerror) {\n onerror(e);\n }\n };\n reader.readAsArrayBuffer(this.file);\n }\n };\n\n // TO DO: use this method to create a loading bar that shows progress during file upload/decode.\n p5.SoundFile.prototype._updateProgress = function(evt) {\n if (evt.lengthComputable) {\n var percentComplete = evt.loaded / evt.total * 0.99;\n this._whileLoading(percentComplete, evt);\n // ...\n } else {\n // Unable to compute progress information since the total size is unknown\n this._whileLoading('size unknown');\n }\n };\n\n /**\n * Returns true if the sound file finished loading successfully.\n *\n * @method isLoaded\n * @for p5.SoundFile\n * @return {Boolean}\n */\n p5.SoundFile.prototype.isLoaded = function() {\n if (this.buffer) {\n return true;\n } else {\n return false;\n }\n };\n\n /**\n * Play the p5.SoundFile\n *\n * @method play\n * @for p5.SoundFile\n * @param {Number} [startTime] (optional) schedule playback to start (in seconds from now).\n * @param {Number} [rate] (optional) playback rate\n * @param {Number} [amp] (optional) amplitude (volume)\n * of playback\n * @param {Number} [cueStart] (optional) cue start time in seconds\n * @param {Number} [duration] (optional) duration of playback in seconds\n */\n p5.SoundFile.prototype.play = function(startTime, rate, amp, _cueStart, duration) {\n if (!this.output) {\n console.warn('SoundFile.play() called after dispose');\n return;\n }\n\n var now = p5sound.audiocontext.currentTime;\n var cueStart, cueEnd;\n var time = startTime || 0;\n if (time < 0) {\n time = 0;\n }\n\n time = time + now;\n\n if (typeof rate !== 'undefined') {\n this.rate(rate);\n }\n\n if (typeof amp !== 'undefined') {\n this.setVolume(amp);\n }\n\n // TO DO: if already playing, create array of buffers for easy stop()\n if (this.buffer) {\n // reset the pause time (if it was paused)\n this._pauseTime = 0;\n\n // handle restart playmode\n if (this.mode === 'restart' && this.buffer && this.bufferSourceNode) {\n this.bufferSourceNode.stop(time);\n this._counterNode.stop(time);\n }\n\n //dont create another instance if already playing\n if (this.mode === 'untildone' && this.isPlaying()) {\n return;\n }\n // make a new source and counter. They are automatically assigned playbackRate and buffer\n this.bufferSourceNode = this._initSourceNode();\n\n // garbage collect counterNode and create a new one\n delete this._counterNode;\n this._counterNode = this._initCounterNode();\n\n if (_cueStart) {\n if (_cueStart >=0 && _cueStart < this.buffer.duration) {\n // this.startTime = cueStart;\n cueStart = _cueStart;\n } else { throw 'start time out of range'; }\n } else {\n cueStart = 0;\n }\n\n if (duration) {\n // if duration is greater than buffer.duration, just play entire file anyway rather than throw an error\n duration = duration <= this.buffer.duration - cueStart ? duration : this.buffer.duration;\n }\n\n // if it was paused, play at the pause position\n if (this._paused) {\n this.bufferSourceNode.start(time, this.pauseTime, duration);\n this._counterNode.start(time, this.pauseTime, duration);\n } else {\n this.bufferSourceNode.start(time, cueStart, duration);\n this._counterNode.start(time, cueStart, duration);\n }\n\n this._playing = true;\n this._paused = false;\n\n // add source to sources array, which is used in stopAll()\n this.bufferSourceNodes.push(this.bufferSourceNode);\n this.bufferSourceNode._arrayIndex = this.bufferSourceNodes.length - 1;\n\n this.bufferSourceNode.addEventListener('ended', this._clearOnEnd);\n }\n // If soundFile hasn't loaded the buffer yet, throw an error\n else {\n throw 'not ready to play file, buffer has yet to load. Try preload()';\n }\n\n // if looping, will restart at original time\n this.bufferSourceNode.loop = this._looping;\n this._counterNode.loop = this._looping;\n\n if (this._looping === true) {\n cueEnd = duration ? duration : cueStart - 0.000000000000001;\n this.bufferSourceNode.loopStart = cueStart;\n this.bufferSourceNode.loopEnd = cueEnd;\n this._counterNode.loopStart = cueStart;\n this._counterNode.loopEnd = cueEnd;\n }\n\n };\n\n\n /**\n * p5.SoundFile has two play modes: restart and\n * sustain. Play Mode determines what happens to a\n * p5.SoundFile if it is triggered while in the middle of playback.\n * In sustain mode, playback will continue simultaneous to the\n * new playback. In restart mode, play() will stop playback\n * and start over. With untilDone, a sound will play only if it's\n * not already playing. Sustain is the default mode.\n *\n * @method playMode\n * @for p5.SoundFile\n * @param {String} str 'restart' or 'sustain' or 'untilDone'\n * @example\n *
\n * let mySound;\n * function preload(){\n * mySound = loadSound('assets/Damscray_DancingTiger.mp3');\n * }\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * noFill();\n * rect(0, height/2, width - 1, height/2 - 1);\n * rect(0, 0, width - 1, height/2);\n * textAlign(CENTER, CENTER);\n * fill(20);\n * text('restart', width/2, 1 * height/4);\n * text('sustain', width/2, 3 * height/4);\n * }\n * function canvasPressed() {\n * if (mouseX < height/2) {\n * mySound.playMode('restart');\n * } else {\n * mySound.playMode('sustain');\n * }\n * mySound.play();\n * }\n *\n *
\n */\n p5.SoundFile.prototype.playMode = function(str) {\n var s = str.toLowerCase();\n\n // if restart, stop all other sounds from playing\n if (s === 'restart' && this.buffer && this.bufferSourceNode) {\n for (var i = 0; i < this.bufferSourceNodes.length - 1; i++) {\n var now = p5sound.audiocontext.currentTime;\n this.bufferSourceNodes[i].stop(now);\n }\n }\n\n // set play mode to effect future playback\n if (s === 'restart' || s === 'sustain' || s === 'untildone') {\n this.mode = s;\n } else {\n throw 'Invalid play mode. Must be either \"restart\" or \"sustain\"';\n }\n };\n\n /**\n * Pauses a file that is currently playing. If the file is not\n * playing, then nothing will happen.\n *\n * After pausing, .play() will resume from the paused\n * position.\n * If p5.SoundFile had been set to loop before it was paused,\n * it will continue to loop after it is unpaused with .play().\n *\n * @method pause\n * @for p5.SoundFile\n * @param {Number} [startTime] (optional) schedule event to occur\n * seconds from now\n * @example\n *
\n * let soundFile;\n * function preload() {\n * soundFormats('ogg', 'mp3');\n * soundFile = loadSound('assets/Damscray_-_Dancing_Tiger_02.mp3');\n * }\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * text('tap to play, release to pause', 10, 20, width - 20);\n * }\n * function canvasPressed() {\n * soundFile.loop();\n * background(0, 200, 50);\n * }\n * function mouseReleased() {\n * soundFile.pause();\n * background(220);\n * }\n * \n *
\n */\n p5.SoundFile.prototype.pause = function(startTime) {\n var now = p5sound.audiocontext.currentTime;\n var time = startTime || 0;\n var pTime = time + now;\n\n if (this.isPlaying() && this.buffer && this.bufferSourceNode) {\n this._paused = true;\n this._playing = false;\n\n this.pauseTime = this.currentTime();\n this.bufferSourceNode.stop(pTime);\n this._counterNode.stop(pTime);\n\n this._pauseTime = this.currentTime();\n // TO DO: make sure play() still starts from orig start position\n } else {\n this._pauseTime = 0;\n }\n };\n\n /**\n * Loop the p5.SoundFile. Accepts optional parameters to set the\n * playback rate, playback volume, loopStart, loopEnd.\n *\n * @method loop\n * @for p5.SoundFile\n * @param {Number} [startTime] (optional) schedule event to occur\n * seconds from now\n * @param {Number} [rate] (optional) playback rate\n * @param {Number} [amp] (optional) playback volume\n * @param {Number} [cueLoopStart] (optional) startTime in seconds\n * @param {Number} [duration] (optional) loop duration in seconds\n * @example\n *
\n * let soundFile;\n * let loopStart = 0.5;\n * let loopDuration = 0.2;\n * function preload() {\n * soundFormats('ogg', 'mp3');\n * soundFile = loadSound('assets/Damscray_-_Dancing_Tiger_02.mp3');\n * }\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * text('tap to play, release to pause', 10, 20, width - 20);\n * }\n * function canvasPressed() {\n * soundFile.loop();\n * background(0, 200, 50);\n * }\n * function mouseReleased() {\n * soundFile.pause();\n * background(220);\n * }\n * \n *
\n */\n p5.SoundFile.prototype.loop = function(startTime, rate, amp, loopStart, duration) {\n this._looping = true;\n this.play(startTime, rate, amp, loopStart, duration);\n };\n\n /**\n * Set a p5.SoundFile's looping flag to true or false. If the sound\n * is currently playing, this change will take effect when it\n * reaches the end of the current playback.\n *\n * @method setLoop\n * @for p5.SoundFile\n * @param {Boolean} Boolean set looping to true or false\n */\n p5.SoundFile.prototype.setLoop = function(bool) {\n if (bool === true) {\n this._looping = true;\n }\n else if (bool === false) {\n this._looping = false;\n }\n else {\n throw 'Error: setLoop accepts either true or false';\n }\n if (this.bufferSourceNode) {\n this.bufferSourceNode.loop = this._looping;\n this._counterNode.loop = this._looping;\n }\n };\n\n /**\n * Returns 'true' if a p5.SoundFile is currently looping and playing, 'false' if not.\n *\n * @method isLooping\n * @for p5.SoundFile\n * @return {Boolean}\n */\n p5.SoundFile.prototype.isLooping = function() {\n if (!this.bufferSourceNode) {\n return false;\n }\n if (this._looping === true && this.isPlaying() === true) {\n return true;\n }\n return false;\n };\n\n /**\n * Returns true if a p5.SoundFile is playing, false if not (i.e.\n * paused or stopped).\n *\n * @method isPlaying\n * @for p5.SoundFile\n * @return {Boolean}\n */\n p5.SoundFile.prototype.isPlaying = function() {\n return this._playing;\n };\n\n /**\n * Returns true if a p5.SoundFile is paused, false if not (i.e.\n * playing or stopped).\n *\n * @method isPaused\n * @for p5.SoundFile\n * @return {Boolean}\n */\n p5.SoundFile.prototype.isPaused = function() {\n return this._paused;\n };\n\n /**\n * Stop soundfile playback.\n *\n * @method stop\n * @for p5.SoundFile\n * @param {Number} [startTime] (optional) schedule event to occur\n * in seconds from now\n */\n p5.SoundFile.prototype.stop = function(timeFromNow) {\n var time = timeFromNow || 0;\n\n if (this.mode === 'sustain' || this.mode === 'untildone') {\n this.stopAll(time);\n this._playing = false;\n this.pauseTime = 0;\n this._paused = false;\n }\n else if (this.buffer && this.bufferSourceNode) {\n var now = p5sound.audiocontext.currentTime;\n var t = time || 0;\n this.pauseTime = 0;\n this.bufferSourceNode.stop(now + t);\n this._counterNode.stop(now + t);\n this._playing = false;\n this._paused = false;\n }\n };\n\n /**\n * Stop playback on all of this soundfile's sources.\n * @private\n */\n p5.SoundFile.prototype.stopAll = function(_time) {\n var now = p5sound.audiocontext.currentTime;\n var time = _time || 0;\n if (this.buffer && this.bufferSourceNode) {\n for (var i in this.bufferSourceNodes) {\n const bufferSourceNode = this.bufferSourceNodes[i];\n if (!!bufferSourceNode) {\n try {\n bufferSourceNode.stop(now + time);\n } catch(e) {\n // this was throwing errors only on Safari\n }\n }\n }\n this._counterNode.stop(now + time);\n this._onended(this);\n }\n };\n\n /**\n * Multiply the output volume (amplitude) of a sound file\n * between 0.0 (silence) and 1.0 (full volume).\n * 1.0 is the maximum amplitude of a digital sound, so multiplying\n * by greater than 1.0 may cause digital distortion. To\n * fade, provide a rampTime parameter. For more\n * complex fades, see the Envelope class.\n *\n * Alternately, you can pass in a signal source such as an\n * oscillator to modulate the amplitude with an audio signal.\n *\n * @method setVolume\n * @for p5.SoundFile\n * @param {Number|Object} volume Volume (amplitude) between 0.0\n * and 1.0 or modulating signal/oscillator\n * @param {Number} [rampTime] Fade for t seconds\n * @param {Number} [timeFromNow] Schedule this event to happen at\n * t seconds in the future\n */\n p5.SoundFile.prototype.setVolume = function(vol, _rampTime, _tFromNow) {\n if (typeof vol === 'number') {\n var rampTime = _rampTime || 0;\n var tFromNow = _tFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n var currentVol = this.output.gain.value;\n this.output.gain.cancelScheduledValues(now + tFromNow);\n this.output.gain.linearRampToValueAtTime(currentVol, now + tFromNow);\n this.output.gain.linearRampToValueAtTime(vol, now + tFromNow + rampTime);\n }\n else if (vol) {\n vol.connect(this.output.gain);\n } else {\n // return the Gain Node\n return this.output.gain;\n }\n };\n\n // same as setVolume, to match Processing Sound\n p5.SoundFile.prototype.amp = p5.SoundFile.prototype.setVolume;\n\n // these are the same thing\n p5.SoundFile.prototype.fade = p5.SoundFile.prototype.setVolume;\n\n p5.SoundFile.prototype.getVolume = function() {\n return this.output.gain.value;\n };\n\n /**\n * Set the stereo panning of a p5.sound object to\n * a floating point number between -1.0 (left) and 1.0 (right).\n * Default is 0.0 (center).\n *\n * @method pan\n * @for p5.SoundFile\n * @param {Number} [panValue] Set the stereo panner\n * @param {Number} [timeFromNow] schedule this event to happen\n * seconds from now\n * @example\n *
\n * let ballX = 0;\n * let soundFile;\n *\n * function preload() {\n * soundFormats('ogg', 'mp3');\n * soundFile = loadSound('assets/beatbox.mp3');\n * }\n *\n * function draw() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * ballX = constrain(mouseX, 0, width);\n * ellipse(ballX, height/2, 20, 20);\n * }\n *\n * function canvasPressed(){\n * // map the ball's x location to a panning degree\n * // between -1.0 (left) and 1.0 (right)\n * let panning = map(ballX, 0., width,-1.0, 1.0);\n * soundFile.pan(panning);\n * soundFile.play();\n * }\n *
\n */\n p5.SoundFile.prototype.pan = function(pval, tFromNow) {\n this.panPosition = pval;\n this.panner.pan(pval, tFromNow);\n };\n\n /**\n * Returns the current stereo pan position (-1.0 to 1.0)\n *\n * @method getPan\n * @for p5.SoundFile\n * @return {Number} Returns the stereo pan setting of the Oscillator\n * as a number between -1.0 (left) and 1.0 (right).\n * 0.0 is center and default.\n */\n p5.SoundFile.prototype.getPan = function() {\n return this.panPosition;\n };\n\n /**\n * Set the playback rate of a sound file. Will change the speed and the pitch.\n * Values less than zero will reverse the audio buffer.\n *\n * @method rate\n * @for p5.SoundFile\n * @param {Number} [playbackRate] Set the playback rate. 1.0 is normal,\n * .5 is half-speed, 2.0 is twice as fast.\n * Values less than zero play backwards.\n * @example\n *
\n * let mySound;\n *\n * function preload() {\n * mySound = loadSound('assets/Damscray_DancingTiger.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * }\n * function canvasPressed() {\n * mySound.loop();\n * }\n * function mouseReleased() {\n * mySound.pause();\n * }\n * function draw() {\n * background(220);\n *\n * // Set the rate to a range between 0.1 and 4\n * // Changing the rate also alters the pitch\n * let playbackRate = map(mouseY, 0.1, height, 2, 0);\n * playbackRate = constrain(playbackRate, 0.01, 4);\n * mySound.rate(playbackRate);\n *\n * line(0, mouseY, width, mouseY);\n * text('rate: ' + round(playbackRate * 100) + '%', 10, 20);\n * }\n *\n * \n *
\n *\n */\n p5.SoundFile.prototype.rate = function(playbackRate) {\n var reverse = false;\n if (typeof playbackRate === 'undefined') {\n return this.playbackRate;\n }\n\n this.playbackRate = playbackRate;\n\n if (playbackRate === 0) {\n playbackRate = 0.0000000000001;\n }\n\n else if (playbackRate < 0 && !this.reversed) {\n playbackRate = Math.abs(playbackRate);\n reverse = true;\n }\n\n else if (playbackRate > 0 && this.reversed) {\n reverse = true;\n }\n\n if (this.bufferSourceNode) {\n var now = p5sound.audiocontext.currentTime;\n this.bufferSourceNode.playbackRate.cancelScheduledValues(now);\n this.bufferSourceNode.playbackRate.linearRampToValueAtTime(Math.abs(playbackRate), now);\n this._counterNode.playbackRate.cancelScheduledValues(now);\n this._counterNode.playbackRate.linearRampToValueAtTime(Math.abs(playbackRate), now);\n }\n\n if (reverse) {\n this.reverseBuffer();\n }\n return this.playbackRate;\n };\n\n // TO DO: document this\n p5.SoundFile.prototype.setPitch = function(num) {\n var newPlaybackRate = midiToFreq(num) / midiToFreq(60);\n this.rate(newPlaybackRate);\n };\n\n p5.SoundFile.prototype.getPlaybackRate = function() {\n return this.playbackRate;\n };\n\n /**\n * Returns the duration of a sound file in seconds.\n *\n * @method duration\n * @for p5.SoundFile\n * @return {Number} The duration of the soundFile in seconds.\n */\n p5.SoundFile.prototype.duration = function() {\n // Return Duration\n if (this.buffer) {\n return this.buffer.duration;\n } else {\n return 0;\n }\n };\n\n /**\n * Return the current position of the p5.SoundFile playhead, in seconds.\n * Time is relative to the normal buffer direction, so if `reverseBuffer`\n * has been called, currentTime will count backwards.\n *\n * @method currentTime\n * @for p5.SoundFile\n * @return {Number} currentTime of the soundFile in seconds.\n */\n p5.SoundFile.prototype.currentTime = function() {\n return this.reversed\n ? Math.abs(this._lastPos - this.buffer.length) / ac.sampleRate\n : this._lastPos / ac.sampleRate;\n };\n\n /**\n * Move the playhead of a soundfile that is currently playing to a\n * new position and a new duration, in seconds.\n * If none are given, will reset the file to play entire duration\n * from start to finish. To set the position of a soundfile that is\n * not currently playing, use the `play` or `loop` methods.\n *\n * @method jump\n * @for p5.SoundFile\n * @param {Number} cueTime cueTime of the soundFile in seconds.\n * @param {Number} duration duration in seconds.\n */\n p5.SoundFile.prototype.jump = function(cueTime, duration) {\n if (cueTime < 0 || cueTime > this.buffer.duration) {\n throw 'jump time out of range';\n }\n if (duration > this.buffer.duration - cueTime) {\n throw 'end time out of range';\n }\n\n var cTime = cueTime || 0;\n var dur = duration || undefined;\n if (this.isPlaying()) {\n this.stop(0);\n this.play(0, this.playbackRate, this.output.gain.value, cTime, dur);\n }\n };\n\n /**\n * Return the number of channels in a sound file.\n * For example, Mono = 1, Stereo = 2.\n *\n * @method channels\n * @for p5.SoundFile\n * @return {Number} [channels]\n */\n p5.SoundFile.prototype.channels = function() {\n return this.buffer.numberOfChannels;\n };\n\n /**\n * Return the sample rate of the sound file.\n *\n * @method sampleRate\n * @for p5.SoundFile\n * @return {Number} [sampleRate]\n */\n p5.SoundFile.prototype.sampleRate = function() {\n return this.buffer.sampleRate;\n };\n\n /**\n * Return the number of samples in a sound file.\n * Equal to sampleRate * duration.\n *\n * @method frames\n * @for p5.SoundFile\n * @return {Number} [sampleCount]\n */\n p5.SoundFile.prototype.frames = function() {\n return this.buffer.length;\n };\n\n /**\n * Returns an array of amplitude peaks in a p5.SoundFile that can be\n * used to draw a static waveform. Scans through the p5.SoundFile's\n * audio buffer to find the greatest amplitudes. Accepts one\n * parameter, 'length', which determines size of the array.\n * Larger arrays result in more precise waveform visualizations.\n *\n * Inspired by Wavesurfer.js.\n *\n * @method getPeaks\n * @for p5.SoundFile\n * @params {Number} [length] length is the size of the returned array.\n * Larger length results in more precision.\n * Defaults to 5*width of the browser window.\n * @returns {Float32Array} Array of peaks.\n */\n p5.SoundFile.prototype.getPeaks = function(length) {\n\n if (this.buffer) {\n // set length to window's width if no length is provided\n if (!length) {\n length = window.width*5;\n }\n if (this.buffer) {\n var buffer = this.buffer;\n var sampleSize = buffer.length / length;\n var sampleStep = ~~(sampleSize / 10) || 1;\n var channels = buffer.numberOfChannels;\n var peaks = new Float32Array(Math.round(length));\n\n for (var c = 0; c < channels; c++) {\n var chan = buffer.getChannelData(c);\n for (var i = 0; i < length; i++) {\n var start = ~~(i*sampleSize);\n var end = ~~(start + sampleSize);\n var max = 0;\n for (var j = start; j < end; j+= sampleStep) {\n var value = chan[j];\n if (value > max) {\n max = value;\n // faster than Math.abs\n } else if (-value > max) {\n max = value;\n }\n }\n if (c === 0 || Math.abs(max) > peaks[i]) {\n peaks[i] = max;\n }\n }\n }\n\n return peaks;\n }\n }\n\n else {\n throw 'Cannot load peaks yet, buffer is not loaded';\n }\n };\n\n /**\n * Reverses the p5.SoundFile's buffer source.\n * Playback must be handled separately (see example).\n *\n * @method reverseBuffer\n * @for p5.SoundFile\n * @example\n *
\n * let drum;\n * function preload() {\n * drum = loadSound('assets/drum.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * text('tap to play', 20, 20);\n * }\n *\n * function canvasPressed() {\n * drum.stop();\n * drum.reverseBuffer();\n * drum.play();\n * }\n * \n *
\n */\n p5.SoundFile.prototype.reverseBuffer = function() {\n if (this.buffer) {\n var currentPos = this._lastPos / ac.sampleRate;\n var curVol = this.getVolume();\n this.setVolume(0, 0.001);\n\n const numChannels = this.buffer.numberOfChannels;\n for (var i = 0; i < numChannels; i++) {\n this.buffer.getChannelData(i).reverse();\n }\n // set reversed flag\n this.reversed = !this.reversed;\n\n if (this.isPlaying() && currentPos) {\n this.jump(this.duration() - currentPos);\n }\n this.setVolume(curVol, 0.001);\n } else {\n throw 'SoundFile is not done loading';\n }\n };\n\n /**\n * Schedule an event to be called when the soundfile\n * reaches the end of a buffer. If the soundfile is\n * playing through once, this will be called when it\n * ends. If it is looping, it will be called when\n * stop is called.\n *\n * @method onended\n * @for p5.SoundFile\n * @param {Function} callback function to call when the\n * soundfile has ended.\n */\n p5.SoundFile.prototype.onended = function(callback) {\n this._onended = callback;\n return this;\n };\n\n p5.SoundFile.prototype.add = function() {\n // TO DO\n };\n\n p5.SoundFile.prototype.dispose = function() {\n var now = p5sound.audiocontext.currentTime;\n\n // remove reference to soundfile\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n\n this.stop(now);\n if (this.buffer && this.bufferSourceNode) {\n for (var i = 0; i < this.bufferSourceNodes.length - 1; i++) {\n if (this.bufferSourceNodes[i] !== null) {\n this.bufferSourceNodes[i].disconnect();\n try {\n this.bufferSourceNodes[i].stop(now);\n } catch(e) {\n console.warn('no buffer source node to dispose');\n }\n this.bufferSourceNodes[i] = null;\n }\n }\n if ( this.isPlaying() ) {\n try {\n this._counterNode.stop(now);\n } catch(e) {\n console.log(e);\n }\n this._counterNode = null;\n }\n }\n if (this.output) {\n this.output.disconnect();\n this.output = null;\n }\n if (this.panner) {\n this.panner.disconnect();\n this.panner = null;\n }\n };\n\n /**\n * Connects the output of a p5sound object to input of another\n * p5.sound object. For example, you may connect a p5.SoundFile to an\n * FFT or an Effect. If no parameter is given, it will connect to\n * the master output. Most p5sound objects connect to the master\n * output when they are created.\n *\n * @method connect\n * @for p5.SoundFile\n * @param {Object} [object] Audio object that accepts an input\n */\n p5.SoundFile.prototype.connect = function(unit) {\n if (!unit) {\n this.panner.connect(p5sound.input);\n }\n else {\n if (unit.hasOwnProperty('input')) {\n this.panner.connect(unit.input);\n } else {\n this.panner.connect(unit);\n }\n }\n };\n\n /**\n * Disconnects the output of this p5sound object.\n *\n * @method disconnect\n * @for p5.SoundFile\n */\n p5.SoundFile.prototype.disconnect = function() {\n if (this.panner) {\n this.panner.disconnect();\n }\n };\n\n /**\n */\n p5.SoundFile.prototype.getLevel = function() {\n console.warn('p5.SoundFile.getLevel has been removed from the library. Use p5.Amplitude instead');\n };\n\n /**\n * Reset the source for this SoundFile to a\n * new path (URL).\n *\n * @method setPath\n * @for p5.SoundFile\n * @param {String} path path to audio file\n * @param {Function} callback Callback\n */\n p5.SoundFile.prototype.setPath = function(p, callback) {\n var path = p5.prototype._checkFileFormats(p);\n this.url = path;\n this.load(callback);\n };\n\n /**\n * Replace the current Audio Buffer with a new Buffer.\n *\n * @method setBuffer\n * @for p5.SoundFile\n * @param {Array} buf Array of Float32 Array(s). 2 Float32 Arrays\n * will create a stereo source. 1 will create\n * a mono source.\n */\n p5.SoundFile.prototype.setBuffer = function(buf) {\n var numChannels = buf.length;\n var size = buf[0].length;\n var newBuffer = ac.createBuffer(numChannels, size, ac.sampleRate);\n\n if (!(buf[0] instanceof Float32Array)) {\n buf[0] = new Float32Array(buf[0]);\n }\n\n for (var channelNum = 0; channelNum < numChannels; channelNum++) {\n var channel = newBuffer.getChannelData( channelNum );\n channel.set(buf[channelNum]);\n }\n\n this.buffer = newBuffer;\n\n // set numbers of channels on input to the panner\n this.panner.inputChannels(numChannels);\n };\n\n //////////////////////////////////////////////////\n // script processor node with an empty buffer to help\n // keep a sample-accurate position in playback buffer.\n // Inspired by Chinmay Pendharkar's technique for Sonoport --> http://bit.ly/1HwdCsV\n // Copyright [2015] [Sonoport (Asia) Pte. Ltd.],\n // Licensed under the Apache License http://apache.org/licenses/LICENSE-2.0\n ////////////////////////////////////////////////////////////////////////////////////\n\n var _createCounterBuffer = function(buffer) {\n const len = buffer.length;\n const audioBuf = ac.createBuffer( 1, buffer.length, ac.sampleRate );\n const arrayBuffer = audioBuf.getChannelData(0);\n for (var index = 0; index < len; index++) {\n arrayBuffer[index] = index;\n }\n return audioBuf;\n };\n\n // initialize counterNode, set its initial buffer and playbackRate\n p5.SoundFile.prototype._initCounterNode = function() {\n var self = this;\n var now = ac.currentTime;\n var cNode = ac.createBufferSource();\n\n const workletBufferSize = safeBufferSize(256);\n\n // dispose of worklet node if it already exists\n if (self._workletNode) {\n self._workletNode.disconnect();\n delete self._workletNode;\n }\n self._workletNode = new AudioWorkletNode(ac, processorNames.soundFileProcessor, {\n processorOptions: { bufferSize: workletBufferSize }\n });\n self._workletNode.port.onmessage = event => {\n if (event.data.name === 'position') {\n // event.data.position should only be 0 when paused\n if (event.data.position === 0) {\n return;\n }\n this._lastPos = event.data.position;\n\n // do any callbacks that have been scheduled\n this._onTimeUpdate(self._lastPos);\n }\n };\n\n // create counter buffer of the same length as self.buffer\n cNode.buffer = _createCounterBuffer( self.buffer );\n\n cNode.playbackRate.setValueAtTime(self.playbackRate, now);\n\n cNode.connect(self._workletNode);\n self._workletNode.connect(p5.soundOut._silentNode);\n\n return cNode;\n };\n\n // initialize sourceNode, set its initial buffer and playbackRate\n p5.SoundFile.prototype._initSourceNode = function() {\n var bufferSourceNode = ac.createBufferSource();\n bufferSourceNode.buffer = this.buffer;\n bufferSourceNode.playbackRate.value = this.playbackRate;\n bufferSourceNode.connect(this.output);\n return bufferSourceNode;\n };\n\n /**\n * processPeaks returns an array of timestamps where it thinks there is a beat.\n *\n * This is an asynchronous function that processes the soundfile in an offline audio context,\n * and sends the results to your callback function.\n *\n * The process involves running the soundfile through a lowpass filter, and finding all of the\n * peaks above the initial threshold. If the total number of peaks are below the minimum number of peaks,\n * it decreases the threshold and re-runs the analysis until either minPeaks or minThreshold are reached.\n *\n * @method processPeaks\n * @for p5.SoundFile\n * @param {Function} callback a function to call once this data is returned\n * @param {Number} [initThreshold] initial threshold defaults to 0.9\n * @param {Number} [minThreshold] minimum threshold defaults to 0.22\n * @param {Number} [minPeaks] minimum number of peaks defaults to 200\n * @return {Array} Array of timestamped peaks\n */\n p5.SoundFile.prototype.processPeaks = function(callback, _initThreshold, _minThreshold, _minPeaks) {\n var bufLen = this.buffer.length;\n var sampleRate = this.buffer.sampleRate;\n var buffer = this.buffer;\n var allPeaks = [];\n\n var initialThreshold = _initThreshold || 0.9,\n threshold = initialThreshold,\n minThreshold = _minThreshold || 0.22,\n minPeaks = _minPeaks || 200;\n\n // Create offline context\n var offlineContext = new window.OfflineAudioContext(1, bufLen, sampleRate);\n\n // create buffer source\n var source = offlineContext.createBufferSource();\n source.buffer = buffer;\n\n // Create filter. TO DO: allow custom setting of filter\n var filter = offlineContext.createBiquadFilter();\n filter.type = 'lowpass';\n source.connect(filter);\n filter.connect(offlineContext.destination);\n\n // start playing at time:0\n source.start(0);\n offlineContext.startRendering(); // Render the song\n\n // act on the result\n offlineContext.oncomplete = function(e) {\n if (!self.panner) return;\n var filteredBuffer = e.renderedBuffer;\n var bufferData = filteredBuffer.getChannelData(0);\n\n\n // step 1:\n // create Peak instances, add them to array, with strength and sampleIndex\n do {\n allPeaks = getPeaksAtThreshold(bufferData, threshold);\n threshold -= 0.005;\n } while (Object.keys(allPeaks).length < minPeaks && threshold >= minThreshold);\n\n\n // step 2:\n // find intervals for each peak in the sampleIndex, add tempos array\n var intervalCounts = countIntervalsBetweenNearbyPeaks(allPeaks);\n\n // step 3: find top tempos\n var groups = groupNeighborsByTempo(intervalCounts, filteredBuffer.sampleRate);\n\n // sort top intervals\n var topTempos = groups.sort(function(intA, intB) {\n return intB.count - intA.count;\n\n }).splice(0,5);\n\n // set this SoundFile's tempo to the top tempo ??\n this.tempo = topTempos[0].tempo;\n\n // step 4:\n // new array of peaks at top tempo within a bpmVariance\n var bpmVariance = 5;\n var tempoPeaks = getPeaksAtTopTempo(allPeaks, topTempos[0].tempo, filteredBuffer.sampleRate, bpmVariance);\n\n callback(tempoPeaks);\n };\n };\n\n // process peaks\n var Peak = function(amp, i) {\n this.sampleIndex = i;\n this.amplitude = amp;\n this.tempos = [];\n this.intervals = [];\n };\n\n // 1. for processPeaks() Function to identify peaks above a threshold\n // returns an array of peak indexes as frames (samples) of the original soundfile\n function getPeaksAtThreshold(data, threshold) {\n var peaksObj = {};\n var length = data.length;\n\n for (var i = 0; i < length; i++) {\n if (data[i] > threshold) {\n var amp = data[i];\n var peak = new Peak(amp, i);\n peaksObj[i] = peak;\n // Skip forward ~ 1/8s to get past this peak.\n i += 6000;\n }\n i++;\n }\n return peaksObj;\n }\n\n // 2. for processPeaks()\n function countIntervalsBetweenNearbyPeaks(peaksObj) {\n var intervalCounts = [];\n var peaksArray = Object.keys(peaksObj).sort();\n\n for (var index = 0; index < peaksArray.length; index++) {\n\n // find intervals in comparison to nearby peaks\n for (var i = 0; i < 10; i++) {\n var startPeak = peaksObj[peaksArray[index]];\n var endPeak = peaksObj[peaksArray[index + i]];\n\n if (startPeak && endPeak) {\n var startPos = startPeak.sampleIndex;\n var endPos = endPeak.sampleIndex;\n var interval = endPos - startPos;\n\n // add a sample interval to the startPeak in the allPeaks array\n if (interval > 0) {\n startPeak.intervals.push(interval);\n }\n\n // tally the intervals and return interval counts\n var foundInterval = intervalCounts.some(function(intervalCount) {\n if (intervalCount.interval === interval) {\n intervalCount.count++;\n return intervalCount;\n }\n });\n\n // store with JSON like formatting\n if (!foundInterval) {\n intervalCounts.push({\n interval: interval,\n count: 1,\n });\n }\n }\n }\n }\n\n return intervalCounts;\n }\n\n\n // 3. for processPeaks --> find tempo\n function groupNeighborsByTempo(intervalCounts, sampleRate) {\n var tempoCounts = [];\n\n intervalCounts.forEach(function(intervalCount) {\n\n try {\n // Convert an interval to tempo\n var theoreticalTempo = Math.abs( 60 / (intervalCount.interval / sampleRate ) );\n\n theoreticalTempo = mapTempo(theoreticalTempo);\n\n var foundTempo = tempoCounts.some(function(tempoCount) {\n if (tempoCount.tempo === theoreticalTempo)\n return tempoCount.count += intervalCount.count;\n });\n if (!foundTempo) {\n if (isNaN(theoreticalTempo)) {\n return;\n }\n tempoCounts.push({\n tempo: Math.round(theoreticalTempo),\n count: intervalCount.count\n });\n }\n } catch(e) {\n throw e;\n }\n\n });\n\n return tempoCounts;\n }\n\n // 4. for processPeaks - get peaks at top tempo\n function getPeaksAtTopTempo(peaksObj, tempo, sampleRate, bpmVariance) {\n var peaksAtTopTempo = [];\n var peaksArray = Object.keys(peaksObj).sort();\n\n // TO DO: filter out peaks that have the tempo and return\n for (var i = 0; i < peaksArray.length; i++) {\n var key = peaksArray[i];\n var peak = peaksObj[key];\n\n for (var j = 0; j < peak.intervals.length; j++) {\n var intervalBPM = Math.round(Math.abs( 60 / (peak.intervals[j] / sampleRate) ) );\n\n intervalBPM = mapTempo(intervalBPM);\n\n if ( Math.abs(intervalBPM - tempo) < bpmVariance ) {\n // convert sampleIndex to seconds\n peaksAtTopTempo.push(peak.sampleIndex/sampleRate);\n }\n }\n }\n\n // filter out peaks that are very close to each other\n peaksAtTopTempo = peaksAtTopTempo.filter(function(peakTime, index, arr) {\n var dif = arr[index + 1] - peakTime;\n if (dif > 0.01) {\n return true;\n }\n });\n\n return peaksAtTopTempo;\n }\n\n // helper function for processPeaks\n function mapTempo(theoreticalTempo) {\n // these scenarios create infinite while loop\n if (!isFinite(theoreticalTempo) || theoreticalTempo === 0 ) {\n return;\n }\n\n // Adjust the tempo to fit within the 90-180 BPM range\n while (theoreticalTempo < 90) theoreticalTempo *= 2;\n while (theoreticalTempo > 180 && theoreticalTempo > 90) theoreticalTempo /= 2;\n\n return theoreticalTempo;\n }\n\n\n /*** SCHEDULE EVENTS ***/\n\n // Cue inspired by JavaScript setTimeout, and the\n // Tone.js Transport Timeline Event, MIT License Yotam Mann 2015 tonejs.org\n var Cue = function(callback, time, id, val) {\n this.callback = callback;\n this.time = time;\n this.id = id;\n this.val = val;\n };\n\n /**\n * Schedule events to trigger every time a MediaElement\n * (audio/video) reaches a playback cue point.\n *\n * Accepts a callback function, a time (in seconds) at which to trigger\n * the callback, and an optional parameter for the callback.\n *\n * Time will be passed as the first parameter to the callback function,\n * and param will be the second parameter.\n *\n *\n * @method addCue\n * @for p5.SoundFile\n * @param {Number} time Time in seconds, relative to this media\n * element's playback. For example, to trigger\n * an event every time playback reaches two\n * seconds, pass in the number 2. This will be\n * passed as the first parameter to\n * the callback function.\n * @param {Function} callback Name of a function that will be\n * called at the given time. The callback will\n * receive time and (optionally) param as its\n * two parameters.\n * @param {Object} [value] An object to be passed as the\n * second parameter to the\n * callback function.\n * @return {Number} id ID of this cue,\n * useful for removeCue(id)\n * @example\n *
\n * let mySound;\n * function preload() {\n * mySound = loadSound('assets/Damscray_DancingTiger.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * text('tap to play', 10, 20);\n *\n * // schedule calls to changeText\n * mySound.addCue(0, changeText, \"hello\" );\n * mySound.addCue(0.5, changeText, \"hello,\" );\n * mySound.addCue(1, changeText, \"hello, p5!\");\n * mySound.addCue(1.5, changeText, \"hello, p5!!\");\n * mySound.addCue(2, changeText, \"hello, p5!!!!!\");\n * }\n *\n * function changeText(val) {\n * background(220);\n * text(val, 10, 20);\n * }\n *\n * function canvasPressed() {\n * mySound.play();\n * }\n *
\n */\n p5.SoundFile.prototype.addCue = function(time, callback, val) {\n var id = this._cueIDCounter++;\n\n var cue = new Cue(callback, time, id, val);\n this._cues.push(cue);\n\n // if (!this.elt.ontimeupdate) {\n // this.elt.ontimeupdate = this._onTimeUpdate.bind(this);\n // }\n\n return id;\n };\n\n /**\n * Remove a callback based on its ID. The ID is returned by the\n * addCue method.\n *\n * @method removeCue\n * @for p5.SoundFile\n * @param {Number} id ID of the cue, as returned by addCue\n */\n p5.SoundFile.prototype.removeCue = function(id) {\n var cueLength = this._cues.length;\n for (var i = 0; i < cueLength; i++) {\n var cue = this._cues[i];\n if (cue.id === id) {\n this._cues.splice(i, 1);\n break;\n }\n }\n\n if (this._cues.length === 0) {\n // TO DO: remove callback\n // this.elt.ontimeupdate = null\n }\n };\n\n /**\n * Remove all of the callbacks that had originally been scheduled\n * via the addCue method.\n *\n * @method clearCues\n */\n p5.SoundFile.prototype.clearCues = function() {\n this._cues = [];\n // this.elt.ontimeupdate = null;\n };\n\n // private method that checks for cues to be fired if events\n // have been scheduled using addCue(callback, time).\n p5.SoundFile.prototype._onTimeUpdate = function(position) {\n var playbackTime = position/this.buffer.sampleRate;\n var cueLength = this._cues.length;\n\n for (var i = 0 ; i < cueLength; i++) {\n var cue = this._cues[i];\n var callbackTime = cue.time;\n var val = cue.val;\n\n if (~~this._prevUpdateTime <= callbackTime && callbackTime <= playbackTime) {\n\n // pass the scheduled callbackTime as parameter to the callback\n cue.callback(val);\n }\n\n }\n\n this._prevUpdateTime = playbackTime;\n };\n\n /**\n * Save a p5.SoundFile as a .wav file. The browser will prompt the user\n * to download the file to their device. To upload a file to a server, see\n * getBlob\n *\n * @method save\n * @for p5.SoundFile\n * @param {String} [fileName] name of the resulting .wav file.\n * @example\n *
\n * let mySound;\n * function preload() {\n * mySound = loadSound('assets/doorbell.mp3');\n * }\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * text('tap to download', 10, 20);\n * }\n *\n * function canvasPressed() {\n * mySound.save('my cool filename');\n * }\n *
\n */\n p5.SoundFile.prototype.save = function(fileName) {\n p5.prototype.saveSound(this, fileName, 'wav');\n };\n\n /**\n * This method is useful for sending a SoundFile to a server. It returns the\n * .wav-encoded audio data as a \"Blob\".\n * A Blob is a file-like data object that can be uploaded to a server\n * with an http request. We'll\n * use the `httpDo` options object to send a POST request with some\n * specific options: we encode the request as `multipart/form-data`,\n * and attach the blob as one of the form values using `FormData`.\n *\n *\n * @method getBlob\n * @for p5.SoundFile\n * @returns {Blob} A file-like data object\n * @example\n *
\n * function preload() {\n * mySound = loadSound('assets/doorbell.mp3');\n * }\n *\n * function setup() {\n * noCanvas();\n * let soundBlob = mySound.getBlob();\n *\n * // Now we can send the blob to a server...\n * let serverUrl = 'https://jsonplaceholder.typicode.com/posts';\n * let httpRequestOptions = {\n * method: 'POST',\n * body: new FormData().append('soundBlob', soundBlob),\n * headers: new Headers({\n * 'Content-Type': 'multipart/form-data'\n * })\n * };\n * httpDo(serverUrl, httpRequestOptions);\n *\n * // We can also create an `ObjectURL` pointing to the Blob\n * let blobUrl = URL.createObjectURL(soundBlob);\n *\n * // The `
\n */\n p5.SoundFile.prototype.getBlob = function() {\n const dataView = convertToWav(this.buffer);\n return new Blob([dataView], { type: 'audio/wav' });\n };\n\n // event handler to remove references to the bufferSourceNode when it is done playing\n function _clearOnEnd(e) {\n const thisBufferSourceNode = e.target;\n const soundFile = this;\n\n // delete this.bufferSourceNode from the sources array when it is done playing:\n thisBufferSourceNode._playing = false;\n thisBufferSourceNode.removeEventListener('ended', soundFile._clearOnEnd);\n\n // call the onended callback\n soundFile._onended(soundFile);\n\n // delete bufferSourceNode(s) in soundFile.bufferSourceNodes\n // iterate in reverse order because the index changes by splice\n soundFile.bufferSourceNodes.map((_, i) => i).reverse().forEach(function (i) {\n const n = soundFile.bufferSourceNodes[i];\n\n if (n._playing === false) {\n soundFile.bufferSourceNodes.splice(i, 1);\n }\n });\n\n if (soundFile.bufferSourceNodes.length === 0) {\n soundFile._playing = false;\n }\n }\n});\n","'use strict';\n\ndefine(function (require) {\n const p5sound = require('master');\n const { safeBufferSize } = require('helpers');\n const processorNames = require('./audioWorklet/processorNames');\n\n /**\n * Amplitude measures volume between 0.0 and 1.0.\n * Listens to all p5sound by default, or use setInput()\n * to listen to a specific sound source. Accepts an optional\n * smoothing value, which defaults to 0.\n *\n * @class p5.Amplitude\n * @constructor\n * @param {Number} [smoothing] between 0.0 and .999 to smooth\n * amplitude readings (defaults to 0)\n * @example\n *
\n * let sound, amplitude;\n *\n * function preload(){\n * sound = loadSound('assets/beat.mp3');\n * }\n * function setup() {\n * let cnv = createCanvas(100,100);\n * cnv.mouseClicked(toggleSound);\n * amplitude = new p5.Amplitude();\n * }\n *\n * function draw() {\n * background(220);\n * text('tap to play', 20, 20);\n *\n * let level = amplitude.getLevel();\n * let size = map(level, 0, 1, 0, 200);\n * ellipse(width/2, height/2, size, size);\n * }\n *\n * function toggleSound() {\n * if (sound.isPlaying() ){\n * sound.stop();\n * } else {\n * sound.play();\n * }\n * }\n *\n *
\n */\n p5.Amplitude = function(smoothing) {\n\n // Set to 2048 for now. In future iterations, this should be inherited or parsed from p5sound's default\n this.bufferSize = safeBufferSize(2048);\n\n // set audio context\n this.audiocontext = p5sound.audiocontext;\n this._workletNode = new AudioWorkletNode(this.audiocontext, processorNames.amplitudeProcessor, {\n outputChannelCount: [1],\n\n parameterData: { smoothing: smoothing || 0 },\n processorOptions: {\n normalize: false,\n smoothing: smoothing || 0,\n numInputChannels: 2,\n bufferSize: this.bufferSize\n }\n });\n\n this._workletNode.port.onmessage = function(event) {\n if (event.data.name === 'amplitude') {\n this.volume = event.data.volume;\n this.volNorm = event.data.volNorm;\n this.stereoVol = event.data.stereoVol;\n this.stereoVolNorm = event.data.stereoVolNorm;\n }\n }.bind(this);\n\n // for connections\n this.input = this._workletNode;\n\n this.output = this.audiocontext.createGain();\n\n // the variables to return\n this.volume = 0;\n this.volNorm = 0;\n this.stereoVol = [0, 0];\n this.stereoVolNorm = [0, 0];\n\n this.normalize = false;\n\n this._workletNode.connect(this.output);\n this.output.gain.value = 0;\n\n // this may only be necessary because of a Chrome bug\n this.output.connect(this.audiocontext.destination);\n\n // connect to p5sound master output by default, unless set by input()\n p5sound.meter.connect(this._workletNode);\n\n // add this p5.SoundFile to the soundArray\n p5sound.soundArray.push(this);\n };\n\n /**\n * Connects to the p5sound instance (master output) by default.\n * Optionally, you can pass in a specific source (i.e. a soundfile).\n *\n * @method setInput\n * @for p5.Amplitude\n * @param {soundObject|undefined} [snd] set the sound source\n * (optional, defaults to\n * master output)\n * @param {Number|undefined} [smoothing] a range between 0.0 and 1.0\n * to smooth amplitude readings\n * @example\n *
\n * function preload(){\n * sound1 = loadSound('assets/beat.mp3');\n * sound2 = loadSound('assets/drum.mp3');\n * }\n * function setup(){\n * cnv = createCanvas(100, 100);\n * cnv.mouseClicked(toggleSound);\n *\n * amplitude = new p5.Amplitude();\n * amplitude.setInput(sound2);\n * }\n *\n * function draw() {\n * background(220);\n * text('tap to play', 20, 20);\n *\n * let level = amplitude.getLevel();\n * let size = map(level, 0, 1, 0, 200);\n * ellipse(width/2, height/2, size, size);\n * }\n *\n * function toggleSound(){\n * if (sound1.isPlaying() && sound2.isPlaying()) {\n * sound1.stop();\n * sound2.stop();\n * } else {\n * sound1.play();\n * sound2.play();\n * }\n * }\n *
\n */\n p5.Amplitude.prototype.setInput = function(source, smoothing) {\n\n p5sound.meter.disconnect();\n\n if (smoothing) {\n this._workletNode.parameters.get('smoothing').value = smoothing;\n }\n\n // connect to the master out of p5s instance if no snd is provided\n if (source == null) {\n console.log('Amplitude input source is not ready! Connecting to master output instead');\n p5sound.meter.connect(this._workletNode);\n }\n\n // if it is a p5.Signal\n else if (source instanceof p5.Signal) {\n source.output.connect(this._workletNode);\n }\n // connect to the sound if it is available\n else if (source) {\n source.connect(this._workletNode);\n this._workletNode.disconnect();\n this._workletNode.connect(this.output);\n }\n\n // otherwise, connect to the master out of p5s instance (default)\n else {\n p5sound.meter.connect(this._workletNode);\n }\n };\n\n p5.Amplitude.prototype.connect = function(unit) {\n if (unit) {\n if (unit.hasOwnProperty('input')) {\n this.output.connect(unit.input);\n } else {\n this.output.connect(unit);\n }\n } else {\n this.output.connect(this.panner.connect(p5sound.input));\n }\n };\n\n p5.Amplitude.prototype.disconnect = function() {\n if (this.output) {\n this.output.disconnect();\n }\n };\n\n /**\n * Returns a single Amplitude reading at the moment it is called.\n * For continuous readings, run in the draw loop.\n *\n * @method getLevel\n * @for p5.Amplitude\n * @param {Number} [channel] Optionally return only channel 0 (left) or 1 (right)\n * @return {Number} Amplitude as a number between 0.0 and 1.0\n * @example\n *
\n * function preload(){\n * sound = loadSound('assets/beat.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mouseClicked(toggleSound);\n * amplitude = new p5.Amplitude();\n * }\n *\n * function draw() {\n * background(220, 150);\n * textAlign(CENTER);\n * text('tap to play', width/2, 20);\n *\n * let level = amplitude.getLevel();\n * let size = map(level, 0, 1, 0, 200);\n * ellipse(width/2, height/2, size, size);\n * }\n *\n * function toggleSound(){\n * if (sound.isPlaying()) {\n * sound.stop();\n * } else {\n * sound.play();\n * }\n * }\n *
\n */\n p5.Amplitude.prototype.getLevel = function(channel) {\n if (typeof channel !== 'undefined') {\n if (this.normalize) {\n return this.stereoVolNorm[channel];\n } else {\n return this.stereoVol[channel];\n }\n }\n else if (this.normalize) {\n return this.volNorm;\n }\n else {\n return this.volume;\n }\n };\n\n /**\n * Determines whether the results of Amplitude.process() will be\n * Normalized. To normalize, Amplitude finds the difference the\n * loudest reading it has processed and the maximum amplitude of\n * 1.0. Amplitude adds this difference to all values to produce\n * results that will reliably map between 0.0 and 1.0. However,\n * if a louder moment occurs, the amount that Normalize adds to\n * all the values will change. Accepts an optional boolean parameter\n * (true or false). Normalizing is off by default.\n *\n * @method toggleNormalize\n * @for p5.Amplitude\n * @param {boolean} [boolean] set normalize to true (1) or false (0)\n */\n p5.Amplitude.prototype.toggleNormalize = function(bool) {\n if (typeof bool === 'boolean') {\n this.normalize = bool;\n }\n else {\n this.normalize = !this.normalize;\n }\n this._workletNode.port.postMessage({ name: 'toggleNormalize', normalize: this.normalize });\n };\n\n /**\n * Smooth Amplitude analysis by averaging with the last analysis\n * frame. Off by default.\n *\n * @method smooth\n * @for p5.Amplitude\n * @param {Number} set smoothing from 0.0 <= 1\n */\n p5.Amplitude.prototype.smooth = function(s) {\n if (s >= 0 && s < 1) {\n this._workletNode.port.postMessage({ name: 'smoothing', smoothing: s });\n } else {\n console.log('Error: smoothing must be between 0 and 1');\n }\n };\n\n p5.Amplitude.prototype.dispose = function() {\n // remove reference from soundArray\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n\n if (this.input) {\n this.input.disconnect();\n delete this.input;\n }\n if (this.output) {\n this.output.disconnect();\n delete this.output;\n }\n\n this._workletNode.disconnect();\n delete this._workletNode;\n };\n\n});\n","'use strict';\n\ndefine(function(require) {\n var p5sound = require('master');\n\n /**\n *

FFT (Fast Fourier Transform) is an analysis algorithm that\n * isolates individual\n * \n * audio frequencies within a waveform.

\n *\n *

Once instantiated, a p5.FFT object can return an array based on\n * two types of analyses:
• FFT.waveform() computes\n * amplitude values along the time domain. The array indices correspond\n * to samples across a brief moment in time. Each value represents\n * amplitude of the waveform at that sample of time.
\n * • FFT.analyze() computes amplitude values along the\n * frequency domain. The array indices correspond to frequencies (i.e.\n * pitches), from the lowest to the highest that humans can hear. Each\n * value represents amplitude at that slice of the frequency spectrum.\n * Use with getEnergy() to measure amplitude at specific\n * frequencies, or within a range of frequencies.

\n *\n *

FFT analyzes a very short snapshot of sound called a sample\n * buffer. It returns an array of amplitude measurements, referred\n * to as bins. The array is 1024 bins long by default.\n * You can change the bin array length, but it must be a power of 2\n * between 16 and 1024 in order for the FFT algorithm to function\n * correctly. The actual size of the FFT buffer is twice the\n * number of bins, so given a standard sample rate, the buffer is\n * 2048/44100 seconds long.

\n *\n *\n * @class p5.FFT\n * @constructor\n * @param {Number} [smoothing] Smooth results of Freq Spectrum.\n * 0.0 < smoothing < 1.0.\n * Defaults to 0.8.\n * @param {Number} [bins] Length of resulting array.\n * Must be a power of two between\n * 16 and 1024. Defaults to 1024.\n * @example\n *
\n * function preload(){\n * sound = loadSound('assets/Damscray_DancingTiger.mp3');\n * }\n *\n * function setup(){\n * let cnv = createCanvas(100,100);\n * cnv.mouseClicked(togglePlay);\n * fft = new p5.FFT();\n * sound.amp(0.2);\n * }\n *\n * function draw(){\n * background(220);\n *\n * let spectrum = fft.analyze();\n * noStroke();\n * fill(255, 0, 255);\n * for (let i = 0; i< spectrum.length; i++){\n * let x = map(i, 0, spectrum.length, 0, width);\n * let h = -height + map(spectrum[i], 0, 255, height, 0);\n * rect(x, height, width / spectrum.length, h )\n * }\n *\n * let waveform = fft.waveform();\n * noFill();\n * beginShape();\n * stroke(20);\n * for (let i = 0; i < waveform.length; i++){\n * let x = map(i, 0, waveform.length, 0, width);\n * let y = map( waveform[i], -1, 1, 0, height);\n * vertex(x,y);\n * }\n * endShape();\n *\n * text('tap to play', 20, 20);\n * }\n *\n * function togglePlay() {\n * if (sound.isPlaying()) {\n * sound.pause();\n * } else {\n * sound.loop();\n * }\n * }\n *
\n */\n p5.FFT = function(smoothing, bins) {\n this.input = this.analyser = p5sound.audiocontext.createAnalyser();\n\n Object.defineProperties(this, {\n bins: {\n get: function() {\n return this.analyser.fftSize / 2;\n },\n set: function(b) {\n this.analyser.fftSize = b * 2;\n },\n configurable: true,\n enumerable: true\n },\n smoothing: {\n get: function() {\n return this.analyser.smoothingTimeConstant;\n },\n set: function(s) {\n this.analyser.smoothingTimeConstant = s;\n },\n configurable: true,\n enumerable: true\n }\n });\n\n // set default smoothing and bins\n this.smooth(smoothing);\n this.bins = bins || 1024;\n\n // default connections to p5sound fftMeter\n p5sound.fftMeter.connect(this.analyser);\n\n this.freqDomain = new Uint8Array(this.analyser.frequencyBinCount);\n this.timeDomain = new Uint8Array(this.analyser.frequencyBinCount);\n\n // predefined frequency ranges, these will be tweakable\n this.bass = [20, 140];\n this.lowMid = [140, 400];\n this.mid = [400, 2600];\n this.highMid = [2600, 5200];\n this.treble = [5200, 14000];\n\n // add this p5.SoundFile to the soundArray\n p5sound.soundArray.push(this);\n };\n\n /**\n * Set the input source for the FFT analysis. If no source is\n * provided, FFT will analyze all sound in the sketch.\n *\n * @method setInput\n * @for p5.FFT\n * @param {Object} [source] p5.sound object (or web audio API source node)\n */\n p5.FFT.prototype.setInput = function(source) {\n if (!source) {\n p5sound.fftMeter.connect(this.analyser);\n } else {\n if (source.output) {\n source.output.connect(this.analyser);\n } else if (source.connect) {\n source.connect(this.analyser);\n }\n p5sound.fftMeter.disconnect();\n }\n };\n\n /**\n * Returns an array of amplitude values (between -1.0 and +1.0) that represent\n * a snapshot of amplitude readings in a single buffer. Length will be\n * equal to bins (defaults to 1024). Can be used to draw the waveform\n * of a sound.\n *\n * @method waveform\n * @for p5.FFT\n * @param {Number} [bins] Must be a power of two between\n * 16 and 1024. Defaults to 1024.\n * @param {String} [precision] If any value is provided, will return results\n * in a Float32 Array which is more precise\n * than a regular array.\n * @return {Array} Array Array of amplitude values (-1 to 1)\n * over time. Array length = bins.\n *\n */\n p5.FFT.prototype.waveform = function() {\n var bins, mode, normalArray;\n\n for (var i = 0; i < arguments.length; i++) {\n if (typeof arguments[i] === 'number') {\n bins = arguments[i];\n this.analyser.fftSize = bins * 2;\n }\n if (typeof arguments[i] === 'string') {\n mode = arguments[i];\n }\n }\n\n // getFloatFrequencyData doesnt work in Safari as of 5/2015\n if (mode && !p5.prototype._isSafari()) {\n timeToFloat(this, this.timeDomain);\n this.analyser.getFloatTimeDomainData(this.timeDomain);\n return this.timeDomain;\n } else {\n timeToInt(this, this.timeDomain);\n this.analyser.getByteTimeDomainData(this.timeDomain);\n var normalArray = new Array();\n for (var j = 0; j < this.timeDomain.length; j++) {\n var scaled = p5.prototype.map(this.timeDomain[j], 0, 255, -1, 1);\n normalArray.push(scaled);\n }\n return normalArray;\n }\n };\n\n /**\n * Returns an array of amplitude values (between 0 and 255)\n * across the frequency spectrum. Length is equal to FFT bins\n * (1024 by default). The array indices correspond to frequencies\n * (i.e. pitches), from the lowest to the highest that humans can\n * hear. Each value represents amplitude at that slice of the\n * frequency spectrum. Must be called prior to using\n * getEnergy().\n *\n * @method analyze\n * @for p5.FFT\n * @param {Number} [bins] Must be a power of two between\n * 16 and 1024. Defaults to 1024.\n * @param {Number} [scale] If \"dB,\" returns decibel\n * float measurements between\n * -140 and 0 (max).\n * Otherwise returns integers from 0-255.\n * @return {Array} spectrum Array of energy (amplitude/volume)\n * values across the frequency spectrum.\n * Lowest energy (silence) = 0, highest\n * possible is 255.\n * @example\n *
\n * let osc, fft;\n *\n * function setup(){\n * let cnv = createCanvas(100,100);\n * cnv.mousePressed(startSound);\n * osc = new p5.Oscillator();\n * osc.amp(0);\n * fft = new p5.FFT();\n * }\n *\n * function draw(){\n * background(220);\n *\n * let freq = map(mouseX, 0, windowWidth, 20, 10000);\n * freq = constrain(freq, 1, 20000);\n * osc.freq(freq);\n *\n * let spectrum = fft.analyze();\n * noStroke();\n * fill(255, 0, 255);\n * for (let i = 0; i< spectrum.length; i++){\n * let x = map(i, 0, spectrum.length, 0, width);\n * let h = -height + map(spectrum[i], 0, 255, height, 0);\n * rect(x, height, width / spectrum.length, h );\n * }\n *\n * stroke(255);\n * if (!osc.started) {\n * text('tap here and drag to change frequency', 10, 20, width - 20);\n * } else {\n * text(round(freq)+'Hz', 10, 20);\n * }\n * }\n *\n * function startSound() {\n * osc.start();\n * osc.amp(0.5, 0.2);\n * }\n *\n * function mouseReleased() {\n * osc.amp(0, 0.2);\n * }\n *
\n *\n *\n */\n p5.FFT.prototype.analyze = function() {\n var mode;\n\n for (var i = 0; i < arguments.length; i++) {\n if (typeof arguments[i] === 'number') {\n this.bins = arguments[i];\n this.analyser.fftSize = this.bins * 2;\n }\n if (typeof arguments[i] === 'string') {\n mode = arguments[i];\n }\n }\n\n if (mode && mode.toLowerCase() === 'db') {\n freqToFloat(this);\n this.analyser.getFloatFrequencyData(this.freqDomain);\n return this.freqDomain;\n } else {\n freqToInt(this, this.freqDomain);\n this.analyser.getByteFrequencyData(this.freqDomain);\n var normalArray = Array.apply([], this.freqDomain);\n\n return normalArray;\n }\n };\n\n /**\n * Returns the amount of energy (volume) at a specific\n * \n * frequency, or the average amount of energy between two\n * frequencies. Accepts Number(s) corresponding\n * to frequency (in Hz), or a String corresponding to predefined\n * frequency ranges (\"bass\", \"lowMid\", \"mid\", \"highMid\", \"treble\").\n * Returns a range between 0 (no energy/volume at that frequency) and\n * 255 (maximum energy).\n * NOTE: analyze() must be called prior to getEnergy(). Analyze()\n * tells the FFT to analyze frequency data, and getEnergy() uses\n * the results determine the value at a specific frequency or\n * range of frequencies.

\n *\n * @method getEnergy\n * @for p5.FFT\n * @param {Number|String} frequency1 Will return a value representing\n * energy at this frequency. Alternately,\n * the strings \"bass\", \"lowMid\" \"mid\",\n * \"highMid\", and \"treble\" will return\n * predefined frequency ranges.\n * @param {Number} [frequency2] If a second frequency is given,\n * will return average amount of\n * energy that exists between the\n * two frequencies.\n * @return {Number} Energy Energy (volume/amplitude) from\n * 0 and 255.\n *\n */\n p5.FFT.prototype.getEnergy = function(frequency1, frequency2) {\n var nyquist = p5sound.audiocontext.sampleRate / 2;\n\n if (frequency1 === 'bass') {\n frequency1 = this.bass[0];\n frequency2 = this.bass[1];\n } else if (frequency1 === 'lowMid') {\n frequency1 = this.lowMid[0];\n frequency2 = this.lowMid[1];\n } else if (frequency1 === 'mid') {\n frequency1 = this.mid[0];\n frequency2 = this.mid[1];\n } else if (frequency1 === 'highMid') {\n frequency1 = this.highMid[0];\n frequency2 = this.highMid[1];\n } else if (frequency1 === 'treble') {\n frequency1 = this.treble[0];\n frequency2 = this.treble[1];\n }\n\n if (typeof frequency1 !== 'number') {\n throw 'invalid input for getEnergy()';\n } else if (!frequency2) {\n // if only one parameter:\n var index = Math.round(frequency1 / nyquist * this.freqDomain.length);\n return this.freqDomain[index];\n } else if (frequency1 && frequency2) {\n // if two parameters:\n // if second is higher than first\n if (frequency1 > frequency2) {\n var swap = frequency2;\n frequency2 = frequency1;\n frequency1 = swap;\n }\n var lowIndex = Math.round(frequency1 / nyquist * this.freqDomain.length);\n var highIndex = Math.round(frequency2 / nyquist * this.freqDomain.length);\n\n var total = 0;\n var numFrequencies = 0;\n // add up all of the values for the frequencies\n for (var i = lowIndex; i <= highIndex; i++) {\n total += this.freqDomain[i];\n numFrequencies += 1;\n }\n // divide by total number of frequencies\n var toReturn = total / numFrequencies;\n return toReturn;\n } else {\n throw 'invalid input for getEnergy()';\n }\n };\n\n // compatability with v.012, changed to getEnergy in v.0121. Will be deprecated...\n p5.FFT.prototype.getFreq = function(freq1, freq2) {\n console.log('getFreq() is deprecated. Please use getEnergy() instead.');\n var x = this.getEnergy(freq1, freq2);\n return x;\n };\n\n /**\n * Returns the\n * \n * spectral centroid of the input signal.\n * NOTE: analyze() must be called prior to getCentroid(). Analyze()\n * tells the FFT to analyze frequency data, and getCentroid() uses\n * the results determine the spectral centroid.

\n *\n * @method getCentroid\n * @for p5.FFT\n * @return {Number} Spectral Centroid Frequency Frequency of the spectral centroid in Hz.\n *\n *\n * @example\n *
\n * function setup(){\n * cnv = createCanvas(100,100);\n * cnv.mousePressed(userStartAudio);\n * sound = new p5.AudioIn();\n * sound.start();\n * fft = new p5.FFT();\n * sound.connect(fft);\n *}\n *\n *function draw() {\n * if (getAudioContext().state !== 'running') {\n * background(220);\n * text('tap here and enable mic to begin', 10, 20, width - 20);\n * return;\n * }\n * let centroidplot = 0.0;\n * let spectralCentroid = 0;\n *\n * background(0);\n * stroke(0,255,0);\n * let spectrum = fft.analyze();\n * fill(0,255,0); // spectrum is green\n *\n * //draw the spectrum\n * for (let i = 0; i < spectrum.length; i++){\n * let x = map(log(i), 0, log(spectrum.length), 0, width);\n * let h = map(spectrum[i], 0, 255, 0, height);\n * let rectangle_width = (log(i+1)-log(i))*(width/log(spectrum.length));\n * rect(x, height, rectangle_width, -h )\n * }\n * let nyquist = 22050;\n *\n * // get the centroid\n * spectralCentroid = fft.getCentroid();\n *\n * // the mean_freq_index calculation is for the display.\n * let mean_freq_index = spectralCentroid/(nyquist/spectrum.length);\n *\n * centroidplot = map(log(mean_freq_index), 0, log(spectrum.length), 0, width);\n *\n * stroke(255,0,0); // the line showing where the centroid is will be red\n *\n * rect(centroidplot, 0, width / spectrum.length, height)\n * noStroke();\n * fill(255,255,255); // text is white\n * text('centroid: ', 10, 20);\n * text(round(spectralCentroid)+' Hz', 10, 40);\n *}\n *
\n */\n p5.FFT.prototype.getCentroid = function() {\n var nyquist = p5sound.audiocontext.sampleRate / 2;\n var cumulative_sum = 0;\n var centroid_normalization = 0;\n\n for (var i = 0; i < this.freqDomain.length; i++) {\n cumulative_sum += i * this.freqDomain[i];\n centroid_normalization += this.freqDomain[i];\n }\n\n var mean_freq_index = 0;\n\n if (centroid_normalization !== 0) {\n mean_freq_index = cumulative_sum / centroid_normalization;\n }\n\n var spec_centroid_freq =\n mean_freq_index * (nyquist / this.freqDomain.length);\n return spec_centroid_freq;\n };\n\n /**\n * Smooth FFT analysis by averaging with the last analysis frame.\n *\n * @method smooth\n * @param {Number} smoothing 0.0 < smoothing < 1.0.\n * Defaults to 0.8.\n */\n p5.FFT.prototype.smooth = function(s) {\n if (typeof s !== 'undefined') {\n this.smoothing = s;\n }\n return this.smoothing;\n };\n\n p5.FFT.prototype.dispose = function() {\n // remove reference from soundArray\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n\n if (this.analyser) {\n this.analyser.disconnect();\n delete this.analyser;\n }\n };\n\n /**\n * Returns an array of average amplitude values for a given number\n * of frequency bands split equally. N defaults to 16.\n * NOTE: analyze() must be called prior to linAverages(). Analyze()\n * tells the FFT to analyze frequency data, and linAverages() uses\n * the results to group them into a smaller set of averages.

\n *\n * @method linAverages\n * @for p5.FFT\n * @param {Number} N Number of returned frequency groups\n * @return {Array} linearAverages Array of average amplitude values for each group\n */\n p5.FFT.prototype.linAverages = function(N) {\n var N = N || 16; // This prevents undefined, null or 0 values of N\n\n var spectrum = this.freqDomain;\n var spectrumLength = spectrum.length;\n var spectrumStep = Math.floor(spectrumLength / N);\n\n var linearAverages = new Array(N);\n // Keep a second index for the current average group and place the values accordingly\n // with only one loop in the spectrum data\n var groupIndex = 0;\n\n for (var specIndex = 0; specIndex < spectrumLength; specIndex++) {\n linearAverages[groupIndex] =\n linearAverages[groupIndex] !== undefined\n ? (linearAverages[groupIndex] + spectrum[specIndex]) / 2\n : spectrum[specIndex];\n\n // Increase the group index when the last element of the group is processed\n if (specIndex % spectrumStep === spectrumStep - 1) {\n groupIndex++;\n }\n }\n\n return linearAverages;\n };\n\n /**\n * Returns an array of average amplitude values of the spectrum, for a given\n * set of \n * Octave Bands\n * NOTE: analyze() must be called prior to logAverages(). Analyze()\n * tells the FFT to analyze frequency data, and logAverages() uses\n * the results to group them into a smaller set of averages.

\n *\n * @method logAverages\n * @for p5.FFT\n * @param {Array} octaveBands Array of Octave Bands objects for grouping\n * @return {Array} logAverages Array of average amplitude values for each group\n */\n p5.FFT.prototype.logAverages = function(octaveBands) {\n var nyquist = p5sound.audiocontext.sampleRate / 2;\n var spectrum = this.freqDomain;\n var spectrumLength = spectrum.length;\n\n var logAverages = new Array(octaveBands.length);\n // Keep a second index for the current average group and place the values accordingly\n // With only one loop in the spectrum data\n var octaveIndex = 0;\n\n for (var specIndex = 0; specIndex < spectrumLength; specIndex++) {\n var specIndexFrequency = Math.round(\n specIndex * nyquist / this.freqDomain.length\n );\n\n // Increase the group index if the current frequency exceeds the limits of the band\n if (specIndexFrequency > octaveBands[octaveIndex].hi) {\n octaveIndex++;\n }\n\n logAverages[octaveIndex] =\n logAverages[octaveIndex] !== undefined\n ? (logAverages[octaveIndex] + spectrum[specIndex]) / 2\n : spectrum[specIndex];\n }\n\n return logAverages;\n };\n\n /**\n * Calculates and Returns the 1/N\n * Octave Bands\n * N defaults to 3 and minimum central frequency to 15.625Hz.\n * (1/3 Octave Bands ~= 31 Frequency Bands)\n * Setting fCtr0 to a central value of a higher octave will ignore the lower bands\n * and produce less frequency groups.\n *\n * @method getOctaveBands\n * @for p5.FFT\n * @param {Number} N Specifies the 1/N type of generated octave bands\n * @param {Number} fCtr0 Minimum central frequency for the lowest band\n * @return {Array} octaveBands Array of octave band objects with their bounds\n */\n p5.FFT.prototype.getOctaveBands = function(N, fCtr0) {\n var N = N || 3; // Default to 1/3 Octave Bands\n var fCtr0 = fCtr0 || 15.625; // Minimum central frequency, defaults to 15.625Hz\n\n var octaveBands = [];\n var lastFrequencyBand = {\n lo: fCtr0 / Math.pow(2, 1 / (2 * N)),\n ctr: fCtr0,\n hi: fCtr0 * Math.pow(2, 1 / (2 * N))\n };\n octaveBands.push(lastFrequencyBand);\n\n var nyquist = p5sound.audiocontext.sampleRate / 2;\n while (lastFrequencyBand.hi < nyquist) {\n var newFrequencyBand = {};\n newFrequencyBand.lo = lastFrequencyBand.hi;\n newFrequencyBand.ctr = lastFrequencyBand.ctr * Math.pow(2, 1 / N);\n newFrequencyBand.hi = newFrequencyBand.ctr * Math.pow(2, 1 / (2 * N));\n\n octaveBands.push(newFrequencyBand);\n lastFrequencyBand = newFrequencyBand;\n }\n\n return octaveBands;\n };\n\n // helper methods to convert type from float (dB) to int (0-255)\n var freqToFloat = function(fft) {\n if (fft.freqDomain instanceof Float32Array === false) {\n fft.freqDomain = new Float32Array(fft.analyser.frequencyBinCount);\n }\n };\n var freqToInt = function(fft) {\n if (fft.freqDomain instanceof Uint8Array === false) {\n fft.freqDomain = new Uint8Array(fft.analyser.frequencyBinCount);\n }\n };\n var timeToFloat = function(fft) {\n if (fft.timeDomain instanceof Float32Array === false) {\n fft.timeDomain = new Float32Array(fft.analyser.frequencyBinCount);\n }\n };\n var timeToInt = function(fft) {\n if (fft.timeDomain instanceof Uint8Array === false) {\n fft.timeDomain = new Uint8Array(fft.analyser.frequencyBinCount);\n }\n };\n});\n","'use strict';\n\ndefine(function (require) {\n\n // Signal is built with the Tone.js signal by Yotam Mann\n // https://github.com/TONEnoTONE/Tone.js/\n var Signal = require('Tone/signal/Signal');\n var Add = require('Tone/signal/Add');\n var Mult = require('Tone/signal/Multiply');\n var Scale = require('Tone/signal/Scale');\n\n /**\n *

p5.Signal is a constant audio-rate signal used by p5.Oscillator\n * and p5.Envelope for modulation math.

\n *\n *

This is necessary because Web Audio is processed on a seprate clock.\n * For example, the p5 draw loop runs about 60 times per second. But\n * the audio clock must process samples 44100 times per second. If we\n * want to add a value to each of those samples, we can't do it in the\n * draw loop, but we can do it by adding a constant-rate audio signal.This class mostly functions behind the scenes in p5.sound, and returns\n * a Tone.Signal from the Tone.js library by Yotam Mann.\n * If you want to work directly with audio signals for modular\n * synthesis, check out\n * tone.js.

\n *\n * @class p5.Signal\n * @constructor\n * @return {Tone.Signal} A Signal object from the Tone.js library\n * @example\n *
\n * let carrier, modulator;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * text('tap to play', 20, 20);\n *\n * carrier = new p5.Oscillator('sine');\n * carrier.start();\n * carrier.amp(1); // set amplitude\n * carrier.freq(220); // set frequency\n *\n * modulator = new p5.Oscillator('sawtooth');\n * modulator.disconnect();\n * modulator.start();\n * modulator.amp(1);\n * modulator.freq(4);\n *\n * // Modulator's default amplitude range is -1 to 1.\n * // Multiply it by -200, so the range is -200 to 200\n * // then add 220 so the range is 20 to 420\n * carrier.freq( modulator.mult(-400).add(220) );\n * }\n *\n * function canvasPressed() {\n * userStartAudio();\n * carrier.amp(1.0);\n * }\n *\n * function mouseReleased() {\n * carrier.amp(0);\n * }\n *
\n */\n p5.Signal = function(value) {\n var s = new Signal(value);\n // p5sound.soundArray.push(s);\n return s; // TODO: is this really a constructor?\n };\n\n /**\n * Fade to value, for smooth transitions\n *\n * @method fade\n * @for p5.Signal\n * @param {Number} value Value to set this signal\n * @param {Number} [secondsFromNow] Length of fade, in seconds from now\n */\n Signal.prototype.fade = Signal.prototype.linearRampToValueAtTime;\n Mult.prototype.fade = Signal.prototype.fade;\n Add.prototype.fade = Signal.prototype.fade;\n Scale.prototype.fade = Signal.prototype.fade;\n\n\n /**\n * Connect a p5.sound object or Web Audio node to this\n * p5.Signal so that its amplitude values can be scaled.\n *\n * @method setInput\n * @for p5.Signal\n * @param {Object} input\n */\n Signal.prototype.setInput = function(_input) {\n _input.connect(this);\n };\n Mult.prototype.setInput = Signal.prototype.setInput;\n Add.prototype.setInput = Signal.prototype.setInput;\n Scale.prototype.setInput = Signal.prototype.setInput;\n\n\n // signals can add / mult / scale themselves\n\n /**\n * Add a constant value to this audio signal,\n * and return the resulting audio signal. Does\n * not change the value of the original signal,\n * instead it returns a new p5.SignalAdd.\n *\n * @method add\n * @for p5.Signal\n * @param {Number} number\n * @return {p5.Signal} object\n */\n Signal.prototype.add = function(num) {\n var add = new Add(num);\n // add.setInput(this);\n this.connect(add);\n return add;\n };\n Mult.prototype.add = Signal.prototype.add;\n Add.prototype.add = Signal.prototype.add;\n Scale.prototype.add = Signal.prototype.add;\n\n /**\n * Multiply this signal by a constant value,\n * and return the resulting audio signal. Does\n * not change the value of the original signal,\n * instead it returns a new p5.SignalMult.\n *\n * @method mult\n * @for p5.Signal\n * @param {Number} number to multiply\n * @return {p5.Signal} object\n */\n Signal.prototype.mult = function(num) {\n var mult = new Mult(num);\n // mult.setInput(this);\n this.connect(mult);\n return mult;\n };\n Mult.prototype.mult = Signal.prototype.mult;\n Add.prototype.mult = Signal.prototype.mult;\n Scale.prototype.mult = Signal.prototype.mult;\n\n /**\n * Scale this signal value to a given range,\n * and return the result as an audio signal. Does\n * not change the value of the original signal,\n * instead it returns a new p5.SignalScale.\n *\n * @method scale\n * @for p5.Signal\n * @param {Number} number to multiply\n * @param {Number} inMin input range minumum\n * @param {Number} inMax input range maximum\n * @param {Number} outMin input range minumum\n * @param {Number} outMax input range maximum\n * @return {p5.Signal} object\n */\n Signal.prototype.scale = function(inMin, inMax, outMin, outMax) {\n var mapOutMin, mapOutMax;\n if (arguments.length === 4) {\n mapOutMin = p5.prototype.map(outMin, inMin, inMax, 0, 1) - 0.5;\n mapOutMax = p5.prototype.map(outMax, inMin, inMax, 0, 1) - 0.5;\n }\n else {\n mapOutMin = arguments[0];\n mapOutMax = arguments[1];\n }\n var scale = new Scale(mapOutMin, mapOutMax);\n this.connect(scale);\n return scale;\n };\n Mult.prototype.scale = Signal.prototype.scale;\n Add.prototype.scale = Signal.prototype.scale;\n Scale.prototype.scale = Signal.prototype.scale;\n\n});\n\n\n","define([\"Tone/core/Tone\", \"Tone/type/TimeBase\"], function (Tone) {\n\n\t/**\n\t * @class Tone.Frequency is a primitive type for encoding Frequency values. \n\t * Eventually all time values are evaluated to hertz\n\t * using the `eval` method. \n\t * @constructor\n\t * @extends {Tone.TimeBase}\n\t * @param {String|Number} val The time value.\n\t * @param {String=} units The units of the value.\n\t * @example\n\t * Tone.Frequency(\"C3\") // 261\n\t * Tone.Frequency(38, \"midi\") //\n\t * Tone.Frequency(\"C3\").transpose(4);\n\t */\n\tTone.Frequency = function(val, units){\n\t\tif (this instanceof Tone.Frequency){\n\t\t\t\n\t\t\tTone.TimeBase.call(this, val, units);\n\n\t\t} else {\n\t\t\treturn new Tone.Frequency(val, units);\n\t\t}\n\t};\n\n\tTone.extend(Tone.Frequency, Tone.TimeBase);\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tAUGMENT BASE EXPRESSIONS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t//clone the expressions so that \n\t//we can add more without modifying the original\n\tTone.Frequency.prototype._primaryExpressions = Object.create(Tone.TimeBase.prototype._primaryExpressions);\n\n\t/*\n\t * midi type primary expression\n\t * @type {Object}\n\t * @private\n\t */\n\tTone.Frequency.prototype._primaryExpressions.midi = {\n\t\tregexp : /^(\\d+(?:\\.\\d+)?midi)/,\n\t\tmethod : function(value){\n\t\t\treturn this.midiToFrequency(value);\n\t\t}\t\n\t};\n\n\t/*\n\t * note type primary expression\n\t * @type {Object}\n\t * @private\n\t */\n\tTone.Frequency.prototype._primaryExpressions.note = {\n\t\tregexp : /^([a-g]{1}(?:b|#|x|bb)?)(-?[0-9]+)/i,\n\t\tmethod : function(pitch, octave){\n\t\t\tvar index = noteToScaleIndex[pitch.toLowerCase()];\n\t\t\tvar noteNumber = index + (parseInt(octave) + 1) * 12;\n\t\t\treturn this.midiToFrequency(noteNumber);\n\t\t}\t\n\t};\n\n\t/*\n\t * BeatsBarsSixteenths type primary expression\n\t * @type {Object}\n\t * @private\n\t */\n\tTone.Frequency.prototype._primaryExpressions.tr = {\n\t\t\tregexp : /^(\\d+(?:\\.\\d+)?):(\\d+(?:\\.\\d+)?):?(\\d+(?:\\.\\d+)?)?/,\n\t\t\tmethod : function(m, q, s){\n\t\t\tvar total = 1;\n\t\t\tif (m && m !== \"0\"){\n\t\t\t\ttotal *= this._beatsToUnits(this._timeSignature() * parseFloat(m));\n\t\t\t}\n\t\t\tif (q && q !== \"0\"){\n\t\t\t\ttotal *= this._beatsToUnits(parseFloat(q));\n\t\t\t}\n\t\t\tif (s && s !== \"0\"){\n\t\t\t\ttotal *= this._beatsToUnits(parseFloat(s) / 4);\n\t\t\t}\n\t\t\treturn total;\n\t\t}\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tEXPRESSIONS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Transposes the frequency by the given number of semitones.\n\t * @param {Interval} interval\n\t * @return {Tone.Frequency} this\n\t * @example\n\t * Tone.Frequency(\"A4\").transpose(3); //\"C5\"\n\t */\n\tTone.Frequency.prototype.transpose = function(interval){\n\t\tthis._expr = function(expr, interval){\n\t\t\tvar val = expr();\n\t\t\treturn val * this.intervalToFrequencyRatio(interval);\n\t\t}.bind(this, this._expr, interval);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Takes an array of semitone intervals and returns\n\t * an array of frequencies transposed by those intervals.\n\t * @param {Array} intervals\n\t * @return {Tone.Frequency} this\n\t * @example\n\t * Tone.Frequency(\"A4\").harmonize([0, 3, 7]); //[\"A4\", \"C5\", \"E5\"]\n\t */\n\tTone.Frequency.prototype.harmonize = function(intervals){\n\t\tthis._expr = function(expr, intervals){\n\t\t\tvar val = expr();\n\t\t\tvar ret = [];\n\t\t\tfor (var i = 0; i < intervals.length; i++){\n\t\t\t\tret[i] = val * this.intervalToFrequencyRatio(intervals[i]);\n\t\t\t}\n\t\t\treturn ret;\n\t\t}.bind(this, this._expr, intervals);\n\t\treturn this;\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tUNIT CONVERSIONS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Return the value of the frequency as a MIDI note\n\t * @return {MIDI}\n\t * @example\n\t * Tone.Frequency(\"C4\").toMidi(); //60\n\t */\n\tTone.Frequency.prototype.toMidi = function(){\n\t\treturn this.frequencyToMidi(this.valueOf());\n\t};\n\n\t/**\n\t * Return the value of the frequency in Scientific Pitch Notation\n\t * @return {Note}\n\t * @example\n\t * Tone.Frequency(69, \"midi\").toNote(); //\"A4\"\n\t */\n\tTone.Frequency.prototype.toNote = function(){\n\t\tvar freq = this.valueOf();\n\t\tvar log = Math.log(freq / Tone.Frequency.A4) / Math.LN2;\n\t\tvar noteNumber = Math.round(12 * log) + 57;\n\t\tvar octave = Math.floor(noteNumber/12);\n\t\tif(octave < 0){\n\t\t\tnoteNumber += -12 * octave;\n\t\t}\n\t\tvar noteName = scaleIndexToNote[noteNumber % 12];\n\t\treturn noteName + octave.toString();\n\t};\n\n\t/**\n\t * Return the duration of one cycle in seconds.\n\t * @return {Seconds}\n\t */\n\tTone.Frequency.prototype.toSeconds = function(){\n\t\treturn 1 / this.valueOf();\n\t};\n\n\t/**\n\t * Return the value in Hertz\n\t * @return {Frequency}\n\t */\n\tTone.Frequency.prototype.toFrequency = function(){\n\t\treturn this.valueOf();\n\t};\n\n\t/**\n\t * Return the duration of one cycle in ticks\n\t * @return {Ticks}\n\t */\n\tTone.Frequency.prototype.toTicks = function(){\n\t\tvar quarterTime = this._beatsToUnits(1);\n\t\tvar quarters = this.valueOf() / quarterTime;\n\t\treturn Math.floor(quarters * Tone.Transport.PPQ);\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tUNIT CONVERSIONS HELPERS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Returns the value of a frequency in the current units\n\t * @param {Frequency} freq\n\t * @return {Number}\n\t * @private\n\t */\n\tTone.Frequency.prototype._frequencyToUnits = function(freq){\n\t\treturn freq;\n\t};\n\n\t/**\n\t * Returns the value of a tick in the current time units\n\t * @param {Ticks} ticks\n\t * @return {Number}\n\t * @private\n\t */\n\tTone.Frequency.prototype._ticksToUnits = function(ticks){\n\t\treturn 1 / ((ticks * 60) / (Tone.Transport.bpm.value * Tone.Transport.PPQ));\n\t};\n\n\t/**\n\t * Return the value of the beats in the current units\n\t * @param {Number} beats\n\t * @return {Number}\n\t * @private\n\t */\n\tTone.Frequency.prototype._beatsToUnits = function(beats){\n\t\treturn 1 / Tone.TimeBase.prototype._beatsToUnits.call(this, beats);\n\t};\n\n\t/**\n\t * Returns the value of a second in the current units\n\t * @param {Seconds} seconds\n\t * @return {Number}\n\t * @private\n\t */\n\tTone.Frequency.prototype._secondsToUnits = function(seconds){\n\t\treturn 1 / seconds;\n\t};\n\n\t/**\n\t * The default units if none are given.\n\t * @private\n\t */\n\tTone.Frequency.prototype._defaultUnits = \"hz\";\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tFREQUENCY CONVERSIONS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Note to scale index\n\t * @type {Object}\n\t */\n\tvar noteToScaleIndex = {\n\t\t\"cbb\" : -2, \"cb\" : -1, \"c\" : 0, \"c#\" : 1, \"cx\" : 2, \n\t\t\"dbb\" : 0, \"db\" : 1, \"d\" : 2, \"d#\" : 3, \"dx\" : 4,\n\t\t\"ebb\" : 2, \"eb\" : 3, \"e\" : 4, \"e#\" : 5, \"ex\" : 6, \n\t\t\"fbb\" : 3, \"fb\" : 4, \"f\" : 5, \"f#\" : 6, \"fx\" : 7,\n\t\t\"gbb\" : 5, \"gb\" : 6, \"g\" : 7, \"g#\" : 8, \"gx\" : 9,\n\t\t\"abb\" : 7, \"ab\" : 8, \"a\" : 9, \"a#\" : 10, \"ax\" : 11,\n\t\t\"bbb\" : 9, \"bb\" : 10, \"b\" : 11, \"b#\" : 12, \"bx\" : 13,\n\t};\n\n\t/**\n\t * scale index to note (sharps)\n\t * @type {Array}\n\t */\n\tvar scaleIndexToNote = [\"C\", \"C#\", \"D\", \"D#\", \"E\", \"F\", \"F#\", \"G\", \"G#\", \"A\", \"A#\", \"B\"];\n\n\t/**\n\t * The [concert pitch](https://en.wikipedia.org/wiki/Concert_pitch)\n\t * A4's values in Hertz. \n\t * @type {Frequency}\n\t * @static\n\t */\n\tTone.Frequency.A4 = 440;\n\n\t/**\n\t * Convert a MIDI note to frequency value. \n\t * @param {MIDI} midi The midi number to convert.\n\t * @return {Frequency} the corresponding frequency value\n\t * @example\n\t * tone.midiToFrequency(69); // returns 440\n\t */\n\tTone.Frequency.prototype.midiToFrequency = function(midi){\n\t\treturn Tone.Frequency.A4 * Math.pow(2, (midi - 69) / 12);\n\t};\n\n\t/**\n\t * Convert a frequency value to a MIDI note.\n\t * @param {Frequency} frequency The value to frequency value to convert.\n\t * @returns {MIDI}\n\t * @example\n\t * tone.midiToFrequency(440); // returns 69\n\t */\n\tTone.Frequency.prototype.frequencyToMidi = function(frequency){\n\t\treturn 69 + 12 * Math.log(frequency / Tone.Frequency.A4) / Math.LN2;\n\t};\n\n\treturn Tone.Frequency;\n});","define([\"Tone/core/Tone\", \"Tone/type/Time\"], function (Tone) {\n\n\t/**\n\t * @class Tone.TransportTime is a the time along the Transport's\n\t * timeline. It is similar to Tone.Time, but instead of evaluating\n\t * against the AudioContext's clock, it is evaluated against\n\t * the Transport's position. See [TransportTime wiki](https://github.com/Tonejs/Tone.js/wiki/TransportTime).\n\t * @constructor\n\t * @param {Time} val The time value as a number or string\n\t * @param {String=} units Unit values\n\t * @extends {Tone.Time}\n\t */\n\tTone.TransportTime = function(val, units){\n\t\tif (this instanceof Tone.TransportTime){\n\t\t\t\n\t\t\tTone.Time.call(this, val, units);\n\n\t\t} else {\n\t\t\treturn new Tone.TransportTime(val, units);\n\t\t}\n\t};\n\n\tTone.extend(Tone.TransportTime, Tone.Time);\n\n\t//clone the expressions so that \n\t//we can add more without modifying the original\n\tTone.TransportTime.prototype._unaryExpressions = Object.create(Tone.Time.prototype._unaryExpressions);\n\n\t/**\n\t * Adds an additional unary expression\n\t * which quantizes values to the next subdivision\n\t * @type {Object}\n\t * @private\n\t */\n\tTone.TransportTime.prototype._unaryExpressions.quantize = {\n\t\tregexp : /^@/,\n\t\tmethod : function(rh){\n\t\t\tvar subdivision = this._secondsToTicks(rh());\n\t\t\tvar multiple = Math.ceil(Tone.Transport.ticks / subdivision);\n\t\t\treturn this._ticksToUnits(multiple * subdivision);\n\t\t}\n\t};\n\n\t/**\n\t * Convert seconds into ticks\n\t * @param {Seconds} seconds\n\t * @return {Ticks}\n\t * @private\n\t */\n\tTone.TransportTime.prototype._secondsToTicks = function(seconds){\n\t\tvar quarterTime = this._beatsToUnits(1);\n\t\tvar quarters = seconds / quarterTime;\n\t\treturn Math.round(quarters * Tone.Transport.PPQ);\n\t};\n\n\t/**\n\t * Evaluate the time expression. Returns values in ticks\n\t * @return {Ticks}\n\t */\n\tTone.TransportTime.prototype.valueOf = function(){\n\t\tvar val = this._secondsToTicks(this._expr());\n\t\treturn val + (this._plusNow ? Tone.Transport.ticks : 0);\n\t};\n\n\t/**\n\t * Return the time in ticks.\n\t * @return {Ticks}\n\t */\n\tTone.TransportTime.prototype.toTicks = function(){\n\t\treturn this.valueOf();\n\t};\n\n\t/**\n\t * Return the time in seconds.\n\t * @return {Seconds}\n\t */\n\tTone.TransportTime.prototype.toSeconds = function(){\n\t\tvar val = this._expr();\n\t\treturn val + (this._plusNow ? Tone.Transport.seconds : 0);\n\t};\n\n\t/**\n\t * Return the time as a frequency value\n\t * @return {Frequency} \n\t */\n\tTone.TransportTime.prototype.toFrequency = function(){\n\t\treturn 1/this.toSeconds();\n\t};\n\n\treturn Tone.TransportTime;\n});","'use strict';\n\ndefine(function (require) {\n\n var p5sound = require('master');\n var Add = require('Tone/signal/Add');\n var Mult = require('Tone/signal/Multiply');\n var Scale = require('Tone/signal/Scale');\n var TimelineSignal = require('Tone/signal/TimelineSignal');\n\n /**\n *

Envelopes are pre-defined amplitude distribution over time.\n * Typically, envelopes are used to control the output volume\n * of an object, a series of fades referred to as Attack, Decay,\n * Sustain and Release (\n * ADSR\n * ). Envelopes can also control other Web Audio Parameters—for example, a p5.Envelope can\n * control an Oscillator's frequency like this: osc.freq(env).

\n *

Use setRange to change the attack/release level.\n * Use setADSR to change attackTime, decayTime, sustainPercent and releaseTime.

\n *

Use the play method to play the entire envelope,\n * the ramp method for a pingable trigger,\n * or triggerAttack/\n * triggerRelease to trigger noteOn/noteOff.

\n *\n * @class p5.Envelope\n * @constructor\n * @example\n *
\n * let t1 = 0.1; // attack time in seconds\n * let l1 = 0.7; // attack level 0.0 to 1.0\n * let t2 = 0.3; // decay time in seconds\n * let l2 = 0.1; // decay level 0.0 to 1.0\n *\n * let env;\n * let triOsc;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * background(220);\n * text('tap to play', 20, 20);\n * cnv.mousePressed(playSound);\n *\n * env = new p5.Envelope(t1, l1, t2, l2);\n * triOsc = new p5.Oscillator('triangle');\n * }\n *\n * function playSound() {\n * // starting the oscillator ensures that audio is enabled.\n * triOsc.start();\n * env.play(triOsc);\n * }\n *
\n */\n p5.Envelope = function(t1, l1, t2, l2, t3, l3) {\n /**\n * Time until envelope reaches attackLevel\n * @property attackTime\n */\n this.aTime = t1 || 0.1;\n /**\n * Level once attack is complete.\n * @property attackLevel\n */\n this.aLevel = l1 || 1;\n /**\n * Time until envelope reaches decayLevel.\n * @property decayTime\n */\n this.dTime = t2 || 0.5;\n /**\n * Level after decay. The envelope will sustain here until it is released.\n * @property decayLevel\n */\n this.dLevel = l2 || 0;\n /**\n * Duration of the release portion of the envelope.\n * @property releaseTime\n */\n this.rTime = t3 || 0;\n /**\n * Level at the end of the release.\n * @property releaseLevel\n */\n this.rLevel = l3 || 0;\n\n this._rampHighPercentage = 0.98;\n\n this._rampLowPercentage = 0.02;\n\n\n this.output = p5sound.audiocontext.createGain();\n\n this.control = new TimelineSignal();\n\n this._init(); // this makes sure the envelope starts at zero\n\n this.control.connect(this.output); // connect to the output\n\n this.connection = null; // store connection\n\n //array of math operation signal chaining\n this.mathOps = [this.control];\n\n //whether envelope should be linear or exponential curve\n this.isExponential = false;\n\n // oscillator or buffer source to clear on env complete\n // to save resources if/when it is retriggered\n this.sourceToClear = null;\n\n // set to true if attack is set, then false on release\n this.wasTriggered = false;\n\n\n // add to the soundArray so we can dispose of the env later\n p5sound.soundArray.push(this);\n };\n\n // this init function just smooths the starting value to zero and gives a start point for the timeline\n // - it was necessary to remove glitches at the beginning.\n p5.Envelope.prototype._init = function () {\n var now = p5sound.audiocontext.currentTime;\n var t = now;\n this.control.setTargetAtTime(0.00001, t, .001);\n //also, compute the correct time constants\n this._setRampAD(this.aTime, this.dTime);\n };\n\n /**\n * Reset the envelope with a series of time/value pairs.\n *\n * @method set\n * @for p5.Envelope\n * @param {Number} attackTime Time (in seconds) before level\n * reaches attackLevel\n * @param {Number} attackLevel Typically an amplitude between\n * 0.0 and 1.0\n * @param {Number} decayTime Time\n * @param {Number} decayLevel Amplitude (In a standard ADSR envelope,\n * decayLevel = sustainLevel)\n * @param {Number} releaseTime Release Time (in seconds)\n * @param {Number} releaseLevel Amplitude\n * @example\n *
\n * let attackTime;\n * let l1 = 0.7; // attack level 0.0 to 1.0\n * let t2 = 0.3; // decay time in seconds\n * let l2 = 0.1; // decay level 0.0 to 1.0\n * let l3 = 0.2; // release time in seconds\n *\n * let env, triOsc;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playSound);\n *\n * env = new p5.Envelope();\n * triOsc = new p5.Oscillator('triangle');\n * }\n *\n * function draw() {\n * background(220);\n * text('tap here to play', 5, 20);\n *\n * attackTime = map(mouseX, 0, width, 0.0, 1.0);\n * text('attack time: ' + attackTime, 5, height - 20);\n * }\n *\n * // mouseClick triggers envelope if over canvas\n * function playSound() {\n * env.set(attackTime, l1, t2, l2, l3);\n *\n * triOsc.start();\n * env.play(triOsc);\n * }\n *
\n *\n */\n p5.Envelope.prototype.set = function(t1, l1, t2, l2, t3, l3) {\n this.aTime = t1;\n this.aLevel = l1;\n this.dTime = t2 || 0;\n this.dLevel = l2 || 0;\n this.rTime = t3 || 0;\n this.rLevel = l3 || 0;\n\n // set time constants for ramp\n this._setRampAD(t1, t2);\n };\n\n /**\n * Set values like a traditional\n * \n * ADSR envelope\n * .\n *\n * @method setADSR\n * @for p5.Envelope\n * @param {Number} attackTime Time (in seconds before envelope\n * reaches Attack Level\n * @param {Number} [decayTime] Time (in seconds) before envelope\n * reaches Decay/Sustain Level\n * @param {Number} [susRatio] Ratio between attackLevel and releaseLevel, on a scale from 0 to 1,\n * where 1.0 = attackLevel, 0.0 = releaseLevel.\n * The susRatio determines the decayLevel and the level at which the\n * sustain portion of the envelope will sustain.\n * For example, if attackLevel is 0.4, releaseLevel is 0,\n * and susAmt is 0.5, the decayLevel would be 0.2. If attackLevel is\n * increased to 1.0 (using setRange),\n * then decayLevel would increase proportionally, to become 0.5.\n * @param {Number} [releaseTime] Time in seconds from now (defaults to 0)\n * @example\n *
\n * let attackLevel = 1.0;\n * let releaseLevel = 0;\n *\n * let attackTime = 0.001;\n * let decayTime = 0.2;\n * let susPercent = 0.2;\n * let releaseTime = 0.5;\n *\n * let env, triOsc;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playEnv);\n *\n * env = new p5.Envelope();\n * triOsc = new p5.Oscillator('triangle');\n * triOsc.amp(env);\n * triOsc.freq(220);\n * }\n *\n * function draw() {\n * background(220);\n * text('tap here to play', 5, 20);\n * attackTime = map(mouseX, 0, width, 0, 1.0);\n * text('attack time: ' + attackTime, 5, height - 40);\n * }\n *\n * function playEnv() {\n * triOsc.start();\n * env.setADSR(attackTime, decayTime, susPercent, releaseTime);\n * env.play();\n * }\n *
\n */\n p5.Envelope.prototype.setADSR = function(aTime, dTime, sPercent, rTime) {\n this.aTime = aTime;\n this.dTime = dTime || 0;\n\n // lerp\n this.sPercent = sPercent || 0;\n this.dLevel = typeof sPercent !== 'undefined' ? sPercent * (this.aLevel - this.rLevel) + this.rLevel : 0;\n\n this.rTime = rTime || 0;\n\n // also set time constants for ramp\n this._setRampAD(aTime, dTime);\n };\n\n /**\n * Set max (attackLevel) and min (releaseLevel) of envelope.\n *\n * @method setRange\n * @for p5.Envelope\n * @param {Number} aLevel attack level (defaults to 1)\n * @param {Number} rLevel release level (defaults to 0)\n * @example\n *
\n * let attackLevel = 1.0;\n * let releaseLevel = 0;\n *\n * let attackTime = 0.001;\n * let decayTime = 0.2;\n * let susPercent = 0.2;\n * let releaseTime = 0.5;\n *\n * let env, triOsc;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playEnv);\n *\n * env = new p5.Envelope();\n * triOsc = new p5.Oscillator('triangle');\n * triOsc.amp(env);\n * triOsc.freq(220);\n * }\n *\n * function draw() {\n * background(220);\n * text('tap here to play', 5, 20);\n * attackLevel = map(mouseY, height, 0, 0, 1.0);\n * text('attack level: ' + attackLevel, 5, height - 20);\n * }\n *\n * function playEnv() {\n * triOsc.start();\n * env.setRange(attackLevel, releaseLevel);\n * env.play();\n * }\n *
\n */\n p5.Envelope.prototype.setRange = function(aLevel, rLevel) {\n this.aLevel = aLevel || 1;\n this.rLevel = rLevel || 0;\n\n // not sure if this belongs here:\n\n // {Number} [dLevel] decay/sustain level (optional)\n // if (typeof(dLevel) !== 'undefined') {\n // this.dLevel = dLevel\n // } else if (this.sPercent) {\n // this.dLevel = this.sPercent ? this.sPercent * (this.aLevel - this.rLevel) + this.rLevel : 0;\n // }\n };\n\n // private (undocumented) method called when ADSR is set to set time constants for ramp\n //\n // Set the \n // time constants for simple exponential ramps.\n // The larger the time constant value, the slower the\n // transition will be.\n //\n // method _setRampAD\n // param {Number} attackTimeConstant attack time constant\n // param {Number} decayTimeConstant decay time constant\n //\n p5.Envelope.prototype._setRampAD = function(t1, t2) {\n this._rampAttackTime = this.checkExpInput(t1);\n this._rampDecayTime = this.checkExpInput(t2);\n\n var TCDenominator = 1.0;\n /// Aatish Bhatia's calculation for time constant for rise(to adjust 1/1-e calculation to any percentage)\n TCDenominator = Math.log(1.0 / this.checkExpInput(1.0 - this._rampHighPercentage));\n this._rampAttackTC = t1 / this.checkExpInput(TCDenominator);\n TCDenominator = Math.log(1.0 / this._rampLowPercentage);\n this._rampDecayTC = t2 / this.checkExpInput(TCDenominator);\n };\n\n // private method\n p5.Envelope.prototype.setRampPercentages = function(p1, p2) {\n //set the percentages that the simple exponential ramps go to\n this._rampHighPercentage = this.checkExpInput(p1);\n this._rampLowPercentage = this.checkExpInput(p2);\n var TCDenominator = 1.0;\n //now re-compute the time constants based on those percentages\n /// Aatish Bhatia's calculation for time constant for rise(to adjust 1/1-e calculation to any percentage)\n TCDenominator = Math.log(1.0 / this.checkExpInput(1.0 - this._rampHighPercentage));\n this._rampAttackTC = this._rampAttackTime / this.checkExpInput(TCDenominator);\n TCDenominator = Math.log(1.0 / this._rampLowPercentage);\n this._rampDecayTC = this._rampDecayTime / this.checkExpInput(TCDenominator);\n };\n\n\n /**\n * Assign a parameter to be controlled by this envelope.\n * If a p5.Sound object is given, then the p5.Envelope will control its\n * output gain. If multiple inputs are provided, the env will\n * control all of them.\n *\n * @method setInput\n * @for p5.Envelope\n * @param {Object} [...inputs] A p5.sound object or\n * Web Audio Param.\n */\n p5.Envelope.prototype.setInput = function() {\n for (var i = 0; iPlay tells the envelope to start acting on a given input.\n * If the input is a p5.sound object (i.e. AudioIn, Oscillator,\n * SoundFile), then Envelope will control its output volume.\n * Envelopes can also be used to control any \n * Web Audio Audio Param.

\n *\n * @method play\n * @for p5.Envelope\n * @param {Object} unit A p5.sound object or\n * Web Audio Param.\n * @param {Number} [startTime] time from now (in seconds) at which to play\n * @param {Number} [sustainTime] time to sustain before releasing the envelope\n * @example\n *
\n * let attackLevel = 1.0;\n * let releaseLevel = 0;\n *\n * let attackTime = 0.001;\n * let decayTime = 0.2;\n * let susPercent = 0.2;\n * let releaseTime = 0.5;\n *\n * let env, triOsc;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playEnv);\n *\n * env = new p5.Envelope();\n * triOsc = new p5.Oscillator('triangle');\n * triOsc.amp(env);\n * triOsc.freq(220);\n * triOsc.start();\n * }\n *\n * function draw() {\n * background(220);\n * text('tap here to play', 5, 20);\n * attackTime = map(mouseX, 0, width, 0, 1.0);\n * attackLevel = map(mouseY, height, 0, 0, 1.0);\n * text('attack time: ' + attackTime, 5, height - 40);\n * text('attack level: ' + attackLevel, 5, height - 20);\n * }\n *\n * function playEnv() {\n * // ensure that audio is enabled\n * userStartAudio();\n *\n * env.setADSR(attackTime, decayTime, susPercent, releaseTime);\n * env.setRange(attackLevel, releaseLevel);\n * env.play();\n * }\n *
\n */\n p5.Envelope.prototype.play = function(unit, secondsFromNow, susTime) {\n var tFromNow = secondsFromNow || 0;\n var susTime = susTime || 0;\n\n if (unit) {\n if (this.connection !== unit) {\n this.connect(unit);\n }\n }\n\n this.triggerAttack(unit, tFromNow);\n\n this.triggerRelease(unit, tFromNow + this.aTime + this.dTime + susTime);\n\n };\n\n /**\n * Trigger the Attack, and Decay portion of the Envelope.\n * Similar to holding down a key on a piano, but it will\n * hold the sustain level until you let go. Input can be\n * any p5.sound object, or a \n * Web Audio Param.\n *\n * @method triggerAttack\n * @for p5.Envelope\n * @param {Object} unit p5.sound Object or Web Audio Param\n * @param {Number} secondsFromNow time from now (in seconds)\n * @example\n *
\n * let attackTime = 0.001;\n * let decayTime = 0.2;\n * let susPercent = 0.3;\n * let releaseTime = 0.4;\n * let env, triOsc;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * background(220);\n * textAlign(CENTER);\n * textSize(10);\n * text('tap to triggerAttack', width/2, height/2);\n *\n * env = new p5.Envelope();\n * env.setADSR(attackTime, decayTime, susPercent, releaseTime);\n * env.setRange(1.0, 0.0);\n * triOsc = new p5.Oscillator('triangle');\n * triOsc.freq(220);\n *\n * cnv.mousePressed(envAttack);\n * }\n *\n * function envAttack() {\n * background(0, 255, 255);\n * text('release to release', width/2, height/2);\n *\n * // ensures audio is enabled. See also: `userStartAudio`\n * triOsc.start();\n *\n * env.triggerAttack(triOsc);\n * }\n *\n * function mouseReleased() {\n * background(220);\n * text('tap to triggerAttack', width/2, height/2);\n *\n * env.triggerRelease(triOsc);\n * }\n *
\n */\n p5.Envelope.prototype.triggerAttack = function(unit, secondsFromNow) {\n var now = p5sound.audiocontext.currentTime;\n var tFromNow = secondsFromNow || 0;\n var t = now + tFromNow;\n this.lastAttack = t;\n this.wasTriggered = true;\n\n if (unit) {\n if (this.connection !== unit) {\n this.connect(unit);\n }\n }\n\n // get and set value (with linear ramp) to anchor automation\n var valToSet = this.control.getValueAtTime(t);\n\n if (this.isExponential === true)\n {\n this.control.exponentialRampToValueAtTime(this.checkExpInput(valToSet), t);\n }\n else\n {\n this.control.linearRampToValueAtTime(valToSet, t);\n }\n\n // after each ramp completes, cancel scheduled values\n // (so they can be overridden in case env has been re-triggered)\n // then, set current value (with linearRamp to avoid click)\n // then, schedule the next automation...\n\n // attack\n t += this.aTime;\n if (this.isExponential === true)\n {\n this.control.exponentialRampToValueAtTime(this.checkExpInput(this.aLevel), t);\n valToSet = this.checkExpInput(this.control.getValueAtTime(t));\n this.control.cancelScheduledValues(t);\n this.control.exponentialRampToValueAtTime(valToSet, t);\n }\n else\n {\n this.control.linearRampToValueAtTime(this.aLevel, t);\n valToSet = this.control.getValueAtTime(t);\n this.control.cancelScheduledValues(t);\n this.control.linearRampToValueAtTime(valToSet, t);\n\n }\n\n // decay to decay level (if using ADSR, then decay level == sustain level)\n t += this.dTime;\n if (this.isExponential === true)\n {\n this.control.exponentialRampToValueAtTime(this.checkExpInput(this.dLevel), t);\n valToSet = this.checkExpInput(this.control.getValueAtTime(t));\n this.control.cancelScheduledValues(t);\n this.control.exponentialRampToValueAtTime(valToSet, t);\n }\n else\n {\n this.control.linearRampToValueAtTime(this.dLevel, t);\n valToSet = this.control.getValueAtTime(t);\n this.control.cancelScheduledValues(t);\n this.control.linearRampToValueAtTime(valToSet, t);\n }\n };\n\n /**\n * Trigger the Release of the Envelope. This is similar to releasing\n * the key on a piano and letting the sound fade according to the\n * release level and release time.\n *\n * @method triggerRelease\n * @for p5.Envelope\n * @param {Object} unit p5.sound Object or Web Audio Param\n * @param {Number} secondsFromNow time to trigger the release\n * @example\n *
\n * let attackTime = 0.001;\n * let decayTime = 0.2;\n * let susPercent = 0.3;\n * let releaseTime = 0.4;\n * let env, triOsc;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * background(220);\n * textAlign(CENTER);\n * textSize(10);\n * text('tap to triggerAttack', width/2, height/2);\n *\n * env = new p5.Envelope();\n * env.setADSR(attackTime, decayTime, susPercent, releaseTime);\n * env.setRange(1.0, 0.0);\n * triOsc = new p5.Oscillator('triangle');\n * triOsc.freq(220);\n *\n * cnv.mousePressed(envAttack);\n * }\n *\n * function envAttack() {\n * background(0, 255, 255);\n * text('release to release', width/2, height/2);\n *\n * // ensures audio is enabled. See also: `userStartAudio`\n * triOsc.start();\n *\n * env.triggerAttack(triOsc);\n * }\n *\n * function mouseReleased() {\n * background(220);\n * text('tap to triggerAttack', width/2, height/2);\n *\n * env.triggerRelease(triOsc);\n * }\n *
\n */\n p5.Envelope.prototype.triggerRelease = function(unit, secondsFromNow) {\n\n // only trigger a release if an attack was triggered\n if (!this.wasTriggered) {\n // this currently causes a bit of trouble:\n // if a later release has been scheduled (via the play function)\n // a new earlier release won't interrupt it, because\n // this.wasTriggered has already been set to false.\n // If we want new earlier releases to override, then we need to\n // keep track of the last release time, and if the new release time is\n // earlier, then use it.\n return;\n }\n\n var now = p5sound.audiocontext.currentTime;\n var tFromNow = secondsFromNow || 0;\n var t = now + tFromNow;\n\n if (unit) {\n if (this.connection !== unit) {\n this.connect(unit);\n }\n }\n\n // get and set value (with linear or exponential ramp) to anchor automation\n var valToSet = this.control.getValueAtTime(t);\n\n if (this.isExponential === true)\n {\n this.control.exponentialRampToValueAtTime(this.checkExpInput(valToSet), t);\n }\n else\n {\n this.control.linearRampToValueAtTime(valToSet, t);\n }\n\n // release\n t += this.rTime;\n\n if (this.isExponential === true)\n {\n this.control.exponentialRampToValueAtTime(this.checkExpInput(this.rLevel), t);\n valToSet = this.checkExpInput(this.control.getValueAtTime(t));\n this.control.cancelScheduledValues(t);\n this.control.exponentialRampToValueAtTime(valToSet, t);\n }\n else\n {\n this.control.linearRampToValueAtTime(this.rLevel, t);\n valToSet = this.control.getValueAtTime(t);\n this.control.cancelScheduledValues(t);\n this.control.linearRampToValueAtTime(valToSet, t);\n }\n\n this.wasTriggered = false;\n };\n\n /**\n * Exponentially ramp to a value using the first two\n * values from setADSR(attackTime, decayTime)\n * as \n * time constants for simple exponential ramps.\n * If the value is higher than current value, it uses attackTime,\n * while a decrease uses decayTime.\n *\n * @method ramp\n * @for p5.Envelope\n * @param {Object} unit p5.sound Object or Web Audio Param\n * @param {Number} secondsFromNow When to trigger the ramp\n * @param {Number} v Target value\n * @param {Number} [v2] Second target value (optional)\n * @example\n *
\n * let env, osc, amp;\n *\n * let attackTime = 0.001;\n * let decayTime = 0.2;\n * let attackLevel = 1;\n * let decayLevel = 0;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * fill(0,255,0);\n * noStroke();\n *\n * env = new p5.Envelope();\n * env.setADSR(attackTime, decayTime);\n * osc = new p5.Oscillator();\n * osc.amp(env);\n * amp = new p5.Amplitude();\n *\n * cnv.mousePressed(triggerRamp);\n * }\n *\n * function triggerRamp() {\n * // ensures audio is enabled. See also: `userStartAudio`\n * osc.start();\n *\n * env.ramp(osc, 0, attackLevel, decayLevel);\n * }\n *\n * function draw() {\n * background(20);\n * text('tap to play', 10, 20);\n * let h = map(amp.getLevel(), 0, 0.4, 0, height);;\n * rect(0, height, width, -h);\n * }\n *
\n */\n p5.Envelope.prototype.ramp = function(unit, secondsFromNow, v1, v2) {\n\n var now = p5sound.audiocontext.currentTime;\n var tFromNow = secondsFromNow || 0;\n var t = now + tFromNow;\n var destination1 = this.checkExpInput(v1);\n var destination2 = typeof v2 !== 'undefined' ? this.checkExpInput(v2) : undefined;\n\n // connect env to unit if not already connected\n if (unit) {\n if (this.connection !== unit) {\n this.connect(unit);\n }\n }\n\n //get current value\n var currentVal = this.checkExpInput(this.control.getValueAtTime(t));\n // this.control.cancelScheduledValues(t);\n\n //if it's going up\n if (destination1 > currentVal) {\n this.control.setTargetAtTime(destination1, t, this._rampAttackTC);\n t += this._rampAttackTime;\n }\n\n //if it's going down\n else if (destination1 < currentVal) {\n this.control.setTargetAtTime(destination1, t, this._rampDecayTC);\n t += this._rampDecayTime;\n }\n\n // Now the second part of envelope begins\n if (destination2 === undefined) return;\n\n //if it's going up\n if (destination2 > destination1) {\n this.control.setTargetAtTime(destination2, t, this._rampAttackTC);\n }\n\n //if it's going down\n else if (destination2 < destination1) {\n this.control.setTargetAtTime(destination2, t, this._rampDecayTC);\n }\n };\n\n\n p5.Envelope.prototype.connect = function(unit) {\n this.connection = unit;\n\n // assume we're talking about output gain\n // unless given a different audio param\n if (unit instanceof p5.Oscillator ||\n unit instanceof p5.SoundFile ||\n unit instanceof p5.AudioIn ||\n unit instanceof p5.Reverb ||\n unit instanceof p5.Noise ||\n unit instanceof p5.Filter ||\n unit instanceof p5.Delay\n ) {\n unit = unit.output.gain;\n }\n if (unit instanceof AudioParam) {\n //set the initial value\n unit.setValueAtTime(0, p5sound.audiocontext.currentTime);\n }\n if (unit instanceof p5.Signal) {\n unit.setValue(0);\n }\n this.output.connect(unit);\n };\n\n p5.Envelope.prototype.disconnect = function() {\n if (this.output) {\n this.output.disconnect();\n }\n };\n\n\n // Signal Math\n\n /**\n * Add a value to the p5.Oscillator's output amplitude,\n * and return the oscillator. Calling this method\n * again will override the initial add() with new values.\n *\n * @method add\n * @for p5.Envelope\n * @param {Number} number Constant number to add\n * @return {p5.Envelope} Envelope Returns this envelope\n * with scaled output\n */\n p5.Envelope.prototype.add = function(num) {\n var add = new Add(num);\n var thisChain = this.mathOps.length;\n var nextChain = this.output;\n return p5.prototype._mathChain(this, add, thisChain, nextChain, Add);\n };\n\n /**\n * Multiply the p5.Envelope's output amplitude\n * by a fixed value. Calling this method\n * again will override the initial mult() with new values.\n *\n * @method mult\n * @for p5.Envelope\n * @param {Number} number Constant number to multiply\n * @return {p5.Envelope} Envelope Returns this envelope\n * with scaled output\n */\n p5.Envelope.prototype.mult = function(num) {\n var mult = new Mult(num);\n var thisChain = this.mathOps.length;\n var nextChain = this.output;\n return p5.prototype._mathChain(this, mult, thisChain, nextChain, Mult);\n };\n\n /**\n * Scale this envelope's amplitude values to a given\n * range, and return the envelope. Calling this method\n * again will override the initial scale() with new values.\n *\n * @method scale\n * @for p5.Envelope\n * @param {Number} inMin input range minumum\n * @param {Number} inMax input range maximum\n * @param {Number} outMin input range minumum\n * @param {Number} outMax input range maximum\n * @return {p5.Envelope} Envelope Returns this envelope\n * with scaled output\n */\n p5.Envelope.prototype.scale = function(inMin, inMax, outMin, outMax) {\n var scale = new Scale(inMin, inMax, outMin, outMax);\n var thisChain = this.mathOps.length;\n var nextChain = this.output;\n return p5.prototype._mathChain(this, scale, thisChain, nextChain, Scale);\n };\n\n\n // get rid of the oscillator\n p5.Envelope.prototype.dispose = function() {\n // remove reference from soundArray\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n\n this.disconnect();\n if (this.control) {\n this.control.dispose();\n this.control = null;\n }\n for (var i = 1; i < this.mathOps.length; i++) {\n this.mathOps[i].dispose();\n }\n };\n\n // Different name for backwards compatibility, replicates p5.Envelope class\n p5.Env = function(t1, l1, t2, l2, t3, l3) {\n console.warn('WARNING: p5.Env is now deprecated and may be removed in future versions. ' +\n 'Please use the new p5.Envelope instead.');\n p5.Envelope.call(this, t1, l1, t2, l2, t3, l3);\n };\n p5.Env.prototype = Object.create(p5.Envelope.prototype);\n\n});\n","'use strict';\n\ndefine(function (require) {\n\n var p5sound = require('master');\n require('oscillator');\n\n /**\n * Creates a Pulse object, an oscillator that implements\n * Pulse Width Modulation.\n * The pulse is created with two oscillators.\n * Accepts a parameter for frequency, and to set the\n * width between the pulses. See \n * p5.Oscillator for a full list of methods.\n *\n * @class p5.Pulse\n * @extends p5.Oscillator\n * @constructor\n * @param {Number} [freq] Frequency in oscillations per second (Hz)\n * @param {Number} [w] Width between the pulses (0 to 1.0,\n * defaults to 0)\n * @example\n *
\n * let pulse;\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(startPulse);\n * background(220);\n *\n * pulse = new p5.Pulse();\n * pulse.amp(0.5);\n * pulse.freq(220);\n * }\n * function startPulse() {\n * pulse.start();\n * pulse.amp(0.5, 0.02);\n * }\n * function mouseReleased() {\n * pulse.amp(0, 0.2);\n * }\n * function draw() {\n * background(220);\n * text('tap to play', 5, 20, width - 20);\n * let w = map(mouseX, 0, width, 0, 1);\n * w = constrain(w, 0, 1);\n * pulse.width(w);\n * text('pulse width: ' + w, 5, height - 20);\n * }\n *
\n */\n p5.Pulse = function(freq, w) {\n p5.Oscillator.call(this, freq, 'sawtooth');\n\n // width of PWM, should be betw 0 to 1.0\n this.w = w || 0;\n\n // create a second oscillator with inverse frequency\n this.osc2 = new p5.SawOsc(freq);\n\n // create a delay node\n this.dNode = p5sound.audiocontext.createDelay();\n\n // dc offset\n this.dcOffset = createDCOffset();\n this.dcGain = p5sound.audiocontext.createGain();\n this.dcOffset.connect(this.dcGain);\n this.dcGain.connect(this.output);\n // set delay time based on PWM width\n this.f = freq || 440;\n var mW = this.w / this.oscillator.frequency.value;\n this.dNode.delayTime.value = mW;\n this.dcGain.gain.value = 1.7*(0.5-this.w);\n\n // disconnect osc2 and connect it to delay, which is connected to output\n this.osc2.disconnect();\n this.osc2.panner.disconnect();\n this.osc2.amp(-1); // inverted amplitude\n this.osc2.output.connect(this.dNode);\n this.dNode.connect(this.output);\n\n this.output.gain.value = 1;\n this.output.connect(this.panner);\n };\n\n p5.Pulse.prototype = Object.create(p5.Oscillator.prototype);\n\n /**\n * Set the width of a Pulse object (an oscillator that implements\n * Pulse Width Modulation).\n *\n * @method width\n * @param {Number} [width] Width between the pulses (0 to 1.0,\n * defaults to 0)\n */\n p5.Pulse.prototype.width = function(w) {\n if (typeof w === 'number') {\n if (w <= 1.0 && w >= 0.0) {\n this.w = w;\n // set delay time based on PWM width\n\n // var mW = map(this.w, 0, 1.0, 0, 1/this.f);\n var mW = this.w / this.oscillator.frequency.value;\n this.dNode.delayTime.value = mW;\n }\n\n this.dcGain.gain.value = 1.7*(0.5-this.w);\n } else {\n w.connect(this.dNode.delayTime);\n var sig = new p5.SignalAdd(-0.5);\n sig.setInput(w);\n sig = sig.mult(-1);\n sig = sig.mult(1.7);\n sig.connect(this.dcGain.gain);\n }\n };\n\n p5.Pulse.prototype.start = function(f, time) {\n var now = p5sound.audiocontext.currentTime;\n var t = time || 0;\n if (!this.started) {\n var freq = f || this.f;\n var type = this.oscillator.type;\n this.oscillator = p5sound.audiocontext.createOscillator();\n this.oscillator.frequency.setValueAtTime(freq, now);\n this.oscillator.type = type;\n this.oscillator.connect(this.output);\n this.oscillator.start(t + now);\n\n // set up osc2\n this.osc2.oscillator = p5sound.audiocontext.createOscillator();\n this.osc2.oscillator.frequency.setValueAtTime(freq, t + now);\n this.osc2.oscillator.type = type;\n this.osc2.oscillator.connect(this.osc2.output);\n this.osc2.start(t + now);\n this.freqNode = [this.oscillator.frequency, this.osc2.oscillator.frequency];\n\n // start dcOffset, too\n this.dcOffset = createDCOffset();\n this.dcOffset.connect(this.dcGain);\n this.dcOffset.start(t + now);\n\n // if LFO connections depend on these oscillators\n if (this.mods !== undefined && this.mods.frequency !== undefined) {\n this.mods.frequency.connect(this.freqNode[0]);\n this.mods.frequency.connect(this.freqNode[1]);\n }\n this.started = true;\n this.osc2.started = true;\n }\n };\n\n p5.Pulse.prototype.stop = function(time) {\n if (this.started) {\n var t = time || 0;\n var now = p5sound.audiocontext.currentTime;\n this.oscillator.stop(t + now);\n if (this.osc2.oscillator) {\n this.osc2.oscillator.stop(t + now);\n }\n this.dcOffset.stop(t + now);\n this.started = false;\n this.osc2.started = false;\n }\n };\n\n p5.Pulse.prototype.freq = function(val, rampTime, tFromNow) {\n if (typeof val === 'number') {\n this.f = val;\n var now = p5sound.audiocontext.currentTime;\n var rampTime = rampTime || 0;\n var tFromNow = tFromNow || 0;\n var currentFreq = this.oscillator.frequency.value;\n this.oscillator.frequency.cancelScheduledValues(now);\n this.oscillator.frequency.setValueAtTime(currentFreq, now + tFromNow);\n this.oscillator.frequency.exponentialRampToValueAtTime(val, tFromNow + rampTime + now);\n this.osc2.oscillator.frequency.cancelScheduledValues(now);\n this.osc2.oscillator.frequency.setValueAtTime(currentFreq, now + tFromNow);\n this.osc2.oscillator.frequency.exponentialRampToValueAtTime(val, tFromNow + rampTime + now);\n\n if (this.freqMod) {\n this.freqMod.output.disconnect();\n this.freqMod = null;\n }\n\n } else if (val.output) {\n val.output.disconnect();\n val.output.connect(this.oscillator.frequency);\n val.output.connect(this.osc2.oscillator.frequency);\n this.freqMod = val;\n }\n };\n\n // inspiration: http://webaudiodemos.appspot.com/oscilloscope/\n function createDCOffset() {\n var ac = p5sound.audiocontext;\n var buffer=ac.createBuffer(1,2048,ac.sampleRate);\n var data = buffer.getChannelData(0);\n for (var i=0; i<2048; i++)\n data[i]=1.0;\n var bufferSource=ac.createBufferSource();\n bufferSource.buffer=buffer;\n bufferSource.loop=true;\n return bufferSource;\n }\n\n});\n","'use strict';\n\ndefine(function (require) {\n var p5sound = require('master');\n\n /**\n * Noise is a type of oscillator that generates a buffer with random values.\n *\n * @class p5.Noise\n * @extends p5.Oscillator\n * @constructor\n * @param {String} type Type of noise can be 'white' (default),\n * 'brown' or 'pink'.\n */\n p5.Noise = function(type) {\n var assignType;\n p5.Oscillator.call(this);\n delete this.f;\n delete this.freq;\n delete this.oscillator;\n\n if (type === 'brown') {\n assignType = _brownNoise;\n } else if (type === 'pink') {\n assignType = _pinkNoise;\n } else {\n assignType = _whiteNoise;\n }\n this.buffer = assignType;\n };\n\n p5.Noise.prototype = Object.create(p5.Oscillator.prototype);\n\n // generate noise buffers\n var _whiteNoise = (function() {\n var bufferSize = 2 * p5sound.audiocontext.sampleRate;\n var whiteBuffer = p5sound.audiocontext.createBuffer(1, bufferSize, p5sound.audiocontext.sampleRate);\n var noiseData = whiteBuffer.getChannelData(0);\n for (var i = 0; i < bufferSize; i++) {\n noiseData[i] = Math.random() * 2 - 1;\n }\n whiteBuffer.type = 'white';\n return whiteBuffer;\n })();\n\n var _pinkNoise = (function() {\n var bufferSize = 2 * p5sound.audiocontext.sampleRate;\n var pinkBuffer = p5sound.audiocontext.createBuffer(1, bufferSize, p5sound.audiocontext.sampleRate);\n var noiseData = pinkBuffer.getChannelData(0);\n var b0, b1, b2, b3, b4, b5, b6;\n b0 = b1 = b2 = b3 = b4 = b5 = b6 = 0.0;\n for (var i = 0; i < bufferSize; i++) {\n var white = Math.random() * 2 - 1;\n b0 = 0.99886 * b0 + white * 0.0555179;\n b1 = 0.99332 * b1 + white * 0.0750759;\n b2 = 0.96900 * b2 + white * 0.1538520;\n b3 = 0.86650 * b3 + white * 0.3104856;\n b4 = 0.55000 * b4 + white * 0.5329522;\n b5 = -0.7616 * b5 - white * 0.0168980;\n noiseData[i] = b0 + b1 + b2 + b3 + b4 + b5 + b6 + white * 0.5362;\n noiseData[i] *= 0.11; // (roughly) compensate for gain\n b6 = white * 0.115926;\n }\n pinkBuffer.type = 'pink';\n return pinkBuffer;\n })();\n\n var _brownNoise = (function() {\n var bufferSize = 2 * p5sound.audiocontext.sampleRate;\n var brownBuffer = p5sound.audiocontext.createBuffer(1, bufferSize, p5sound.audiocontext.sampleRate);\n var noiseData = brownBuffer.getChannelData(0);\n var lastOut = 0.0;\n for (var i = 0; i< bufferSize; i++) {\n var white = Math.random() * 2 - 1;\n noiseData[i] = (lastOut + 0.02*white) / 1.02;\n lastOut = noiseData[i];\n noiseData[i] *= 3.5;\n }\n brownBuffer.type = 'brown';\n return brownBuffer;\n })();\n\n /**\n * Set type of noise to 'white', 'pink' or 'brown'.\n * White is the default.\n *\n * @method setType\n * @param {String} [type] 'white', 'pink' or 'brown'\n */\n p5.Noise.prototype.setType = function(type) {\n switch(type) {\n case 'white':\n this.buffer = _whiteNoise;\n break;\n case 'pink':\n this.buffer = _pinkNoise;\n break;\n case 'brown':\n this.buffer = _brownNoise;\n break;\n default:\n this.buffer = _whiteNoise;\n }\n if (this.started) {\n var now = p5sound.audiocontext.currentTime;\n this.stop(now);\n this.start(now+.01);\n }\n };\n\n p5.Noise.prototype.getType = function() {\n return this.buffer.type;\n };\n\n p5.Noise.prototype.start = function() {\n if (this.started) {\n this.stop();\n }\n this.noise = p5sound.audiocontext.createBufferSource();\n this.noise.buffer = this.buffer;\n this.noise.loop = true;\n this.noise.connect(this.output);\n var now = p5sound.audiocontext.currentTime;\n this.noise.start(now);\n this.started = true;\n };\n\n p5.Noise.prototype.stop = function() {\n var now = p5sound.audiocontext.currentTime;\n if (this.noise) {\n this.noise.stop(now);\n this.started = false;\n }\n };\n\n p5.Noise.prototype.dispose = function() {\n var now = p5sound.audiocontext.currentTime;\n\n // remove reference from soundArray\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n\n if (this.noise) {\n this.noise.disconnect();\n this.stop(now);\n }\n if (this.output) {\n this.output.disconnect();\n }\n if (this.panner) {\n this.panner.disconnect();\n }\n this.output = null;\n this.panner = null;\n this.buffer = null;\n this.noise = null;\n };\n\n});\n","'use strict';\n\ndefine(function (require) {\n var p5sound = require('master');\n\n // an array of input sources\n p5sound.inputSources = [];\n\n /**\n *

Get audio from an input, i.e. your computer's microphone.

\n *\n *

Turn the mic on/off with the start() and stop() methods. When the mic\n * is on, its volume can be measured with getLevel or by connecting an\n * FFT object.

\n *\n *

If you want to hear the AudioIn, use the .connect() method.\n * AudioIn does not connect to p5.sound output by default to prevent\n * feedback.

\n *\n *

Note: This uses the getUserMedia/\n * Stream API, which is not supported by certain browsers. Access in Chrome browser\n * is limited to localhost and https, but access over http may be limited.

\n *\n * @class p5.AudioIn\n * @constructor\n * @param {Function} [errorCallback] A function to call if there is an error\n * accessing the AudioIn. For example,\n * Safari and iOS devices do not\n * currently allow microphone access.\n * @example\n *
\n * let mic;\n *\n * function setup(){\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(userStartAudio);\n * textAlign(CENTER);\n * mic = new p5.AudioIn();\n * mic.start();\n * }\n *\n * function draw(){\n * background(0);\n * fill(255);\n * text('tap to start', width/2, 20);\n *\n * micLevel = mic.getLevel();\n * let y = height - micLevel * height;\n * ellipse(width/2, y, 10, 10);\n * }\n *
\n */\n p5.AudioIn = function(errorCallback) {\n // set up audio input\n /**\n * @property {GainNode} input\n */\n this.input = p5sound.audiocontext.createGain();\n /**\n * @property {GainNode} output\n */\n this.output = p5sound.audiocontext.createGain();\n\n /**\n * @property {MediaStream|null} stream\n */\n this.stream = null;\n /**\n * @property {MediaStreamAudioSourceNode|null} mediaStream\n */\n this.mediaStream = null;\n /**\n * @property {Number|null} currentSource\n */\n this.currentSource = null;\n\n /**\n * Client must allow browser to access their microphone / audioin source.\n * Default: false. Will become true when the client enables access.\n *\n * @property {Boolean} enabled\n */\n this.enabled = false;\n\n /**\n * Input amplitude, connect to it by default but not to master out\n *\n * @property {p5.Amplitude} amplitude\n */\n this.amplitude = new p5.Amplitude();\n this.output.connect(this.amplitude.input);\n\n if (!window.MediaStreamTrack || !window.navigator.mediaDevices || !window.navigator.mediaDevices.getUserMedia) {\n errorCallback ? errorCallback() : window.alert('This browser does not support MediaStreamTrack and mediaDevices');\n }\n\n // add to soundArray so we can dispose on close\n p5sound.soundArray.push(this);\n };\n\n /**\n * Start processing audio input. This enables the use of other\n * AudioIn methods like getLevel(). Note that by default, AudioIn\n * is not connected to p5.sound's output. So you won't hear\n * anything unless you use the connect() method.
\n *\n * Certain browsers limit access to the user's microphone. For example,\n * Chrome only allows access from localhost and over https. For this reason,\n * you may want to include an errorCallback—a function that is called in case\n * the browser won't provide mic access.\n *\n * @method start\n * @for p5.AudioIn\n * @param {Function} [successCallback] Name of a function to call on\n * success.\n * @param {Function} [errorCallback] Name of a function to call if\n * there was an error. For example,\n * some browsers do not support\n * getUserMedia.\n */\n p5.AudioIn.prototype.start = function(successCallback, errorCallback) {\n var self = this;\n\n if (this.stream) {\n this.stop();\n }\n\n // set the audio source\n var audioSource = p5sound.inputSources[self.currentSource];\n var constraints = {\n audio: {\n sampleRate: p5sound.audiocontext.sampleRate,\n echoCancellation: false\n }\n };\n\n // if developers determine which source to use\n if (p5sound.inputSources[this.currentSource]) {\n constraints.audio.deviceId = audioSource.deviceId;\n }\n\n window.navigator.mediaDevices.getUserMedia( constraints )\n .then( function(stream) {\n self.stream = stream;\n self.enabled = true;\n // Wrap a MediaStreamSourceNode around the live input\n self.mediaStream = p5sound.audiocontext.createMediaStreamSource(stream);\n self.mediaStream.connect(self.output);\n // only send to the Amplitude reader, so we can see it but not hear it.\n self.amplitude.setInput(self.output);\n if (successCallback) successCallback();\n })\n .catch( function(err) {\n if (errorCallback) errorCallback(err);\n else console.error(err);\n });\n };\n\n /**\n * Turn the AudioIn off. If the AudioIn is stopped, it cannot getLevel().\n * If re-starting, the user may be prompted for permission access.\n *\n * @method stop\n * @for p5.AudioIn\n */\n p5.AudioIn.prototype.stop = function() {\n if (this.stream) {\n this.stream.getTracks().forEach(function(track) {\n track.stop();\n });\n\n this.mediaStream.disconnect();\n\n delete this.mediaStream;\n delete this.stream;\n }\n };\n\n /**\n * Connect to an audio unit. If no parameter is provided, will\n * connect to the master output (i.e. your speakers).
\n *\n * @method connect\n * @for p5.AudioIn\n * @param {Object} [unit] An object that accepts audio input,\n * such as an FFT\n */\n p5.AudioIn.prototype.connect = function(unit) {\n if (unit) {\n if (unit.hasOwnProperty('input')) {\n this.output.connect(unit.input);\n }\n else if (unit.hasOwnProperty('analyser')) {\n this.output.connect(unit.analyser);\n }\n else {\n this.output.connect(unit);\n }\n }\n else {\n this.output.connect(p5sound.input);\n }\n };\n\n /**\n * Disconnect the AudioIn from all audio units. For example, if\n * connect() had been called, disconnect() will stop sending\n * signal to your speakers.
\n *\n * @method disconnect\n * @for p5.AudioIn\n */\n p5.AudioIn.prototype.disconnect = function() {\n if (this.output) {\n this.output.disconnect();\n // stay connected to amplitude even if not outputting to p5\n this.output.connect(this.amplitude.input);\n }\n };\n\n /**\n * Read the Amplitude (volume level) of an AudioIn. The AudioIn\n * class contains its own instance of the Amplitude class to help\n * make it easy to get a microphone's volume level. Accepts an\n * optional smoothing value (0.0 < 1.0). NOTE: AudioIn must\n * .start() before using .getLevel().
\n *\n * @method getLevel\n * @for p5.AudioIn\n * @param {Number} [smoothing] Smoothing is 0.0 by default.\n * Smooths values based on previous values.\n * @return {Number} Volume level (between 0.0 and 1.0)\n */\n p5.AudioIn.prototype.getLevel = function(smoothing) {\n if (smoothing) {\n this.amplitude.smoothing = smoothing;\n }\n return this.amplitude.getLevel();\n };\n\n /**\n * Set amplitude (volume) of a mic input between 0 and 1.0.
\n *\n * @method amp\n * @for p5.AudioIn\n * @param {Number} vol between 0 and 1.0\n * @param {Number} [time] ramp time (optional)\n */\n p5.AudioIn.prototype.amp = function(vol, t) {\n if (t) {\n var rampTime = t || 0;\n var currentVol = this.output.gain.value;\n this.output.gain.cancelScheduledValues(p5sound.audiocontext.currentTime);\n this.output.gain.setValueAtTime(currentVol, p5sound.audiocontext.currentTime);\n this.output.gain.linearRampToValueAtTime(vol, rampTime + p5sound.audiocontext.currentTime);\n } else {\n this.output.gain.cancelScheduledValues(p5sound.audiocontext.currentTime);\n this.output.gain.setValueAtTime(vol, p5sound.audiocontext.currentTime);\n }\n };\n\n /**\n * Returns a list of available input sources. This is a wrapper\n * for and it returns a Promise.\n *\n * @method getSources\n * @for p5.AudioIn\n * @param {Function} [successCallback] This callback function handles the sources when they\n * have been enumerated. The callback function\n * receives the deviceList array as its only argument\n * @param {Function} [errorCallback] This optional callback receives the error\n * message as its argument.\n * @returns {Promise} Returns a Promise that can be used in place of the callbacks, similar\n * to the enumerateDevices() method\n * @example\n *
\n * let audioIn;\n *\n * function setup(){\n * text('getting sources...', 0, 20);\n * audioIn = new p5.AudioIn();\n * audioIn.getSources(gotSources);\n * }\n *\n * function gotSources(deviceList) {\n * if (deviceList.length > 0) {\n * //set the source to the first item in the deviceList array\n * audioIn.setSource(0);\n * let currentSource = deviceList[audioIn.currentSource];\n * text('set source to: ' + currentSource.deviceId, 5, 20, width);\n * }\n * }\n *
\n */\n p5.AudioIn.prototype.getSources = function (onSuccess, onError) {\n return new Promise( function(resolve, reject) {\n window.navigator.mediaDevices.enumerateDevices()\n .then( function(devices) {\n p5sound.inputSources = devices.filter(function(device) {\n return device.kind === 'audioinput';\n });\n resolve(p5sound.inputSources);\n if (onSuccess) {\n onSuccess(p5sound.inputSources);\n }\n })\n .catch( function(error) {\n reject(error);\n if (onError) {\n onError(error);\n } else {\n console.error('This browser does not support MediaStreamTrack.getSources()');\n }\n });\n });\n };\n\n /**\n * Set the input source. Accepts a number representing a\n * position in the array returned by getSources().\n * This is only available in browsers that support\n * navigator.mediaDevices.enumerateDevices().
\n *\n * @method setSource\n * @for p5.AudioIn\n * @param {number} num position of input source in the array\n * @example\n *
\n * let audioIn;\n *\n * function setup(){\n * text('getting sources...', 0, 20);\n * audioIn = new p5.AudioIn();\n * audioIn.getSources(gotSources);\n * }\n *\n * function gotSources(deviceList) {\n * if (deviceList.length > 0) {\n * //set the source to the first item in the deviceList array\n * audioIn.setSource(0);\n * let currentSource = deviceList[audioIn.currentSource];\n * text('set source to: ' + currentSource.deviceId, 5, 20, width);\n * }\n * }\n *
\n */\n p5.AudioIn.prototype.setSource = function(num) {\n if (p5sound.inputSources.length > 0 && num < p5sound.inputSources.length) {\n // set the current source\n this.currentSource = num;\n console.log('set source to ', p5sound.inputSources[this.currentSource]);\n } else {\n console.log('unable to set input source');\n }\n\n // restart stream if currently active\n if (this.stream && this.stream.active) {\n this.start();\n }\n };\n\n // private method\n p5.AudioIn.prototype.dispose = function() {\n // remove reference from soundArray\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n\n this.stop();\n\n if (this.output) {\n this.output.disconnect();\n }\n if (this.amplitude) {\n this.amplitude.disconnect();\n }\n delete this.amplitude;\n delete this.output;\n };\n\n});\n","define([\"Tone/core/Tone\", \"Tone/signal/Signal\", \"Tone/signal/Expr\", \n\t\"Tone/signal/EqualPowerGain\", \"Tone/core/Gain\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Tone.Crossfade provides equal power fading between two inputs. \n\t * More on crossfading technique [here](https://en.wikipedia.org/wiki/Fade_(audio_engineering)#Crossfading).\n\t *\n\t * @constructor\n\t * @extends {Tone}\n\t * @param {NormalRange} [initialFade=0.5]\n\t * @example\n\t * var crossFade = new Tone.CrossFade(0.5);\n\t * //connect effect A to crossfade from\n\t * //effect output 0 to crossfade input 0\n\t * effectA.connect(crossFade, 0, 0);\n\t * //connect effect B to crossfade from\n\t * //effect output 0 to crossfade input 1\n\t * effectB.connect(crossFade, 0, 1);\n\t * crossFade.fade.value = 0;\n\t * // ^ only effectA is output\n\t * crossFade.fade.value = 1;\n\t * // ^ only effectB is output\n\t * crossFade.fade.value = 0.5;\n\t * // ^ the two signals are mixed equally. \n\t */\t\t\n\tTone.CrossFade = function(initialFade){\n\n\t\tthis.createInsOuts(2, 1);\n\n\t\t/**\n\t\t * Alias for input[0]. \n\t\t * @type {Tone.Gain}\n\t\t */\n\t\tthis.a = this.input[0] = new Tone.Gain();\n\n\t\t/**\n\t\t * Alias for input[1]. \n\t\t * @type {Tone.Gain}\n\t\t */\n\t\tthis.b = this.input[1] = new Tone.Gain();\n\n\t\t/**\n\t\t * \tThe mix between the two inputs. A fade value of 0\n\t\t * \twill output 100% input[0] and \n\t\t * \ta value of 1 will output 100% input[1]. \n\t\t * @type {NormalRange}\n\t\t * @signal\n\t\t */\n\t\tthis.fade = new Tone.Signal(this.defaultArg(initialFade, 0.5), Tone.Type.NormalRange);\n\n\t\t/**\n\t\t * equal power gain cross fade\n\t\t * @private\n\t\t * @type {Tone.EqualPowerGain}\n\t\t */\n\t\tthis._equalPowerA = new Tone.EqualPowerGain();\n\n\t\t/**\n\t\t * equal power gain cross fade\n\t\t * @private\n\t\t * @type {Tone.EqualPowerGain}\n\t\t */\n\t\tthis._equalPowerB = new Tone.EqualPowerGain();\n\t\t\n\t\t/**\n\t\t * invert the incoming signal\n\t\t * @private\n\t\t * @type {Tone}\n\t\t */\n\t\tthis._invert = new Tone.Expr(\"1 - $0\");\n\n\t\t//connections\n\t\tthis.a.connect(this.output);\n\t\tthis.b.connect(this.output);\n\t\tthis.fade.chain(this._equalPowerB, this.b.gain);\n\t\tthis.fade.chain(this._invert, this._equalPowerA, this.a.gain);\n\t\tthis._readOnly(\"fade\");\n\t};\n\n\tTone.extend(Tone.CrossFade);\n\n\t/**\n\t * clean up\n\t * @returns {Tone.CrossFade} this\n\t */\n\tTone.CrossFade.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._writable(\"fade\");\n\t\tthis._equalPowerA.dispose();\n\t\tthis._equalPowerA = null;\n\t\tthis._equalPowerB.dispose();\n\t\tthis._equalPowerB = null;\n\t\tthis.fade.dispose();\n\t\tthis.fade = null;\n\t\tthis._invert.dispose();\n\t\tthis._invert = null;\n\t\tthis.a.dispose();\n\t\tthis.a = null;\n\t\tthis.b.dispose();\n\t\tthis.b = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.CrossFade;\n});\n","define([\"Tone/core/Tone\", \"Tone/signal/Add\", \"Tone/signal/Subtract\", \"Tone/signal/Multiply\", \n\t\"Tone/signal/GreaterThan\", \"Tone/signal/GreaterThanZero\", \"Tone/signal/Abs\", \"Tone/signal/Negate\", \n\t\"Tone/signal/Modulo\", \"Tone/signal/Pow\", \"Tone/signal/AudioToGain\"], \n\tfunction(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Evaluate an expression at audio rate.

\n\t * Parsing code modified from https://code.google.com/p/tapdigit/\n\t * Copyright 2011 2012 Ariya Hidayat, New BSD License\n\t *\n\t * @extends {Tone.SignalBase}\n\t * @constructor\n\t * @param {string} expr the expression to generate\n\t * @example\n\t * //adds the signals from input[0] and input[1].\n\t * var expr = new Tone.Expr(\"$0 + $1\");\n\t */\n\tTone.Expr = function(){\n\n\t\tvar expr = this._replacements(Array.prototype.slice.call(arguments));\n\t\tvar inputCount = this._parseInputs(expr);\n\n\t\t/**\n\t\t * hold onto all of the nodes for disposal\n\t\t * @type {Array}\n\t\t * @private\n\t\t */\n\t\tthis._nodes = [];\n\n\t\t/**\n\t\t * The inputs. The length is determined by the expression. \n\t\t * @type {Array}\n\t\t */\n\t\tthis.input = new Array(inputCount);\n\n\t\t//create a gain for each input\n\t\tfor (var i = 0; i < inputCount; i++){\n\t\t\tthis.input[i] = this.context.createGain();\n\t\t}\n\n\t\t//parse the syntax tree\n\t\tvar tree = this._parseTree(expr);\n\t\t//evaluate the results\n\t\tvar result;\n\t\ttry {\n\t\t\tresult = this._eval(tree);\n\t\t} catch (e){\n\t\t\tthis._disposeNodes();\n\t\t\tthrow new Error(\"Tone.Expr: Could evaluate expression: \"+expr);\n\t\t}\n\n\t\t/**\n\t\t * The output node is the result of the expression\n\t\t * @type {Tone}\n\t\t */\n\t\tthis.output = result;\n\t};\n\n\tTone.extend(Tone.Expr, Tone.SignalBase);\n\n\t//some helpers to cut down the amount of code\n\tfunction applyBinary(Constructor, args, self){\n\t\tvar op = new Constructor();\n\t\tself._eval(args[0]).connect(op, 0, 0);\n\t\tself._eval(args[1]).connect(op, 0, 1);\n\t\treturn op;\n\t}\n\tfunction applyUnary(Constructor, args, self){\n\t\tvar op = new Constructor();\n\t\tself._eval(args[0]).connect(op, 0, 0);\n\t\treturn op;\n\t}\n\tfunction getNumber(arg){\n\t\treturn arg ? parseFloat(arg) : undefined;\n\t}\n\tfunction literalNumber(arg){\n\t\treturn arg && arg.args ? parseFloat(arg.args) : undefined;\n\t}\n\n\t/*\n\t * the Expressions that Tone.Expr can parse.\n\t *\n\t * each expression belongs to a group and contains a regexp \n\t * for selecting the operator as well as that operators method\n\t * \n\t * @type {Object}\n\t * @private\n\t */\n\tTone.Expr._Expressions = {\n\t\t//values\n\t\t\"value\" : {\n\t\t\t\"signal\" : {\n\t\t\t\tregexp : /^\\d+\\.\\d+|^\\d+/,\n\t\t\t\tmethod : function(arg){\n\t\t\t\t\tvar sig = new Tone.Signal(getNumber(arg));\n\t\t\t\t\treturn sig;\n\t\t\t\t}\n\t\t\t},\n\t\t\t\"input\" : {\n\t\t\t\tregexp : /^\\$\\d/,\n\t\t\t\tmethod : function(arg, self){\n\t\t\t\t\treturn self.input[getNumber(arg.substr(1))];\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\t//syntactic glue\n\t\t\"glue\" : {\n\t\t\t\"(\" : {\n\t\t\t\tregexp : /^\\(/,\n\t\t\t},\n\t\t\t\")\" : {\n\t\t\t\tregexp : /^\\)/,\n\t\t\t},\n\t\t\t\",\" : {\n\t\t\t\tregexp : /^,/,\n\t\t\t}\n\t\t},\n\t\t//functions\n\t\t\"func\" : {\n\t\t\t\"abs\" : {\n\t\t\t\tregexp : /^abs/,\n\t\t\t\tmethod : applyUnary.bind(this, Tone.Abs)\n\t\t\t},\n\t\t\t\"mod\" : {\n\t\t\t\tregexp : /^mod/,\n\t\t\t\tmethod : function(args, self){\n\t\t\t\t\tvar modulus = literalNumber(args[1]);\n\t\t\t\t\tvar op = new Tone.Modulo(modulus);\n\t\t\t\t\tself._eval(args[0]).connect(op);\n\t\t\t\t\treturn op;\n\t\t\t\t}\n\t\t\t},\n\t\t\t\"pow\" : {\n\t\t\t\tregexp : /^pow/,\n\t\t\t\tmethod : function(args, self){\n\t\t\t\t\tvar exp = literalNumber(args[1]);\n\t\t\t\t\tvar op = new Tone.Pow(exp);\n\t\t\t\t\tself._eval(args[0]).connect(op);\n\t\t\t\t\treturn op;\n\t\t\t\t}\n\t\t\t},\n\t\t\t\"a2g\" : {\n\t\t\t\tregexp : /^a2g/,\n\t\t\t\tmethod : function(args, self){\n\t\t\t\t\tvar op = new Tone.AudioToGain();\n\t\t\t\t\tself._eval(args[0]).connect(op);\n\t\t\t\t\treturn op;\n\t\t\t\t}\n\t\t\t},\n\t\t},\n\t\t//binary expressions\n\t\t\"binary\" : {\n\t\t\t\"+\" : {\n\t\t\t\tregexp : /^\\+/,\n\t\t\t\tprecedence : 1,\n\t\t\t\tmethod : applyBinary.bind(this, Tone.Add)\n\t\t\t},\n\t\t\t\"-\" : {\n\t\t\t\tregexp : /^\\-/,\n\t\t\t\tprecedence : 1,\n\t\t\t\tmethod : function(args, self){\n\t\t\t\t\t//both unary and binary op\n\t\t\t\t\tif (args.length === 1){\n\t\t\t\t\t\treturn applyUnary(Tone.Negate, args, self);\n\t\t\t\t\t} else {\n\t\t\t\t\t\treturn applyBinary(Tone.Subtract, args, self);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t},\n\t\t\t\"*\" : {\n\t\t\t\tregexp : /^\\*/,\n\t\t\t\tprecedence : 0,\n\t\t\t\tmethod : applyBinary.bind(this, Tone.Multiply)\n\t\t\t}\n\t\t},\n\t\t//unary expressions\n\t\t\"unary\" : {\n\t\t\t\"-\" : {\n\t\t\t\tregexp : /^\\-/,\n\t\t\t\tmethod : applyUnary.bind(this, Tone.Negate)\n\t\t\t},\n\t\t\t\"!\" : {\n\t\t\t\tregexp : /^\\!/,\n\t\t\t\tmethod : applyUnary.bind(this, Tone.NOT)\n\t\t\t},\n\t\t},\n\t};\n\t\t\n\t/**\n\t * @param {string} expr the expression string\n\t * @return {number} the input count\n\t * @private\n\t */\n\tTone.Expr.prototype._parseInputs = function(expr){\n\t\tvar inputArray = expr.match(/\\$\\d/g);\n\t\tvar inputMax = 0;\n\t\tif (inputArray !== null){\n\t\t\tfor (var i = 0; i < inputArray.length; i++){\n\t\t\t\tvar inputNum = parseInt(inputArray[i].substr(1)) + 1;\n\t\t\t\tinputMax = Math.max(inputMax, inputNum);\n\t\t\t}\n\t\t}\n\t\treturn inputMax;\n\t};\n\n\t/**\n\t * @param {Array} args \tan array of arguments\n\t * @return {string} the results of the replacements being replaced\n\t * @private\n\t */\n\tTone.Expr.prototype._replacements = function(args){\n\t\tvar expr = args.shift();\n\t\tfor (var i = 0; i < args.length; i++){\n\t\t\texpr = expr.replace(/\\%/i, args[i]);\n\t\t}\n\t\treturn expr;\n\t};\n\n\t/**\n\t * tokenize the expression based on the Expressions object\n\t * @param {string} expr \n\t * @return {Object} returns two methods on the tokenized list, next and peek\n\t * @private\n\t */\n\tTone.Expr.prototype._tokenize = function(expr){\n\t\tvar position = -1;\n\t\tvar tokens = [];\n\n\t\twhile(expr.length > 0){\n\t\t\texpr = expr.trim();\n\t\t\tvar token = getNextToken(expr);\n\t\t\ttokens.push(token);\n\t\t\texpr = expr.substr(token.value.length);\n\t\t}\n\n\t\tfunction getNextToken(expr){\n\t\t\tfor (var type in Tone.Expr._Expressions){\n\t\t\t\tvar group = Tone.Expr._Expressions[type];\n\t\t\t\tfor (var opName in group){\n\t\t\t\t\tvar op = group[opName];\n\t\t\t\t\tvar reg = op.regexp;\n\t\t\t\t\tvar match = expr.match(reg);\n\t\t\t\t\tif (match !== null){\n\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\ttype : type,\n\t\t\t\t\t\t\tvalue : match[0],\n\t\t\t\t\t\t\tmethod : op.method\n\t\t\t\t\t\t};\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tthrow new SyntaxError(\"Tone.Expr: Unexpected token \"+expr);\n\t\t}\n\n\t\treturn {\n\t\t\tnext : function(){\n\t\t\t\treturn tokens[++position];\n\t\t\t},\n\t\t\tpeek : function(){\n\t\t\t\treturn tokens[position + 1];\n\t\t\t}\n\t\t};\n\t};\n\n\t/**\n\t * recursively parse the string expression into a syntax tree\n\t * \n\t * @param {string} expr \n\t * @return {Object}\n\t * @private\n\t */\n\tTone.Expr.prototype._parseTree = function(expr){\n\t\tvar lexer = this._tokenize(expr);\n\t\tvar isUndef = this.isUndef.bind(this);\n\n\t\tfunction matchSyntax(token, syn) {\n\t\t\treturn !isUndef(token) && \n\t\t\t\ttoken.type === \"glue\" &&\n\t\t\t\ttoken.value === syn;\n\t\t}\n\n\t\tfunction matchGroup(token, groupName, prec) {\n\t\t\tvar ret = false;\n\t\t\tvar group = Tone.Expr._Expressions[groupName];\n\t\t\tif (!isUndef(token)){\n\t\t\t\tfor (var opName in group){\n\t\t\t\t\tvar op = group[opName];\n\t\t\t\t\tif (op.regexp.test(token.value)){\n\t\t\t\t\t\tif (!isUndef(prec)){\n\t\t\t\t\t\t\tif(op.precedence === prec){\t\n\t\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn ret;\n\t\t}\n\n\t\tfunction parseExpression(precedence) {\n\t\t\tif (isUndef(precedence)){\n\t\t\t\tprecedence = 5;\n\t\t\t}\n\t\t\tvar expr;\n\t\t\tif (precedence < 0){\n\t\t\t\texpr = parseUnary();\n\t\t\t} else {\n\t\t\t\texpr = parseExpression(precedence-1);\n\t\t\t}\n\t\t\tvar token = lexer.peek();\n\t\t\twhile (matchGroup(token, \"binary\", precedence)) {\n\t\t\t\ttoken = lexer.next();\n\t\t\t\texpr = {\n\t\t\t\t\toperator: token.value,\n\t\t\t\t\tmethod : token.method,\n\t\t\t\t\targs : [\n\t\t\t\t\t\texpr,\n\t\t\t\t\t\tparseExpression(precedence-1)\n\t\t\t\t\t]\n\t\t\t\t};\n\t\t\t\ttoken = lexer.peek();\n\t\t\t}\n\t\t\treturn expr;\n\t\t}\n\n\t\tfunction parseUnary() {\n\t\t\tvar token, expr;\n\t\t\ttoken = lexer.peek();\n\t\t\tif (matchGroup(token, \"unary\")) {\n\t\t\t\ttoken = lexer.next();\n\t\t\t\texpr = parseUnary();\n\t\t\t\treturn {\n\t\t\t\t\toperator: token.value,\n\t\t\t\t\tmethod : token.method,\n\t\t\t\t\targs : [expr]\n\t\t\t\t};\n\t\t\t}\n\t\t\treturn parsePrimary();\n\t\t}\n\n\t\tfunction parsePrimary() {\n\t\t\tvar token, expr;\n\t\t\ttoken = lexer.peek();\n\t\t\tif (isUndef(token)) {\n\t\t\t\tthrow new SyntaxError(\"Tone.Expr: Unexpected termination of expression\");\n\t\t\t}\n\t\t\tif (token.type === \"func\") {\n\t\t\t\ttoken = lexer.next();\n\t\t\t\treturn parseFunctionCall(token);\n\t\t\t}\n\t\t\tif (token.type === \"value\") {\n\t\t\t\ttoken = lexer.next();\n\t\t\t\treturn {\n\t\t\t\t\tmethod : token.method,\n\t\t\t\t\targs : token.value\n\t\t\t\t};\n\t\t\t}\n\t\t\tif (matchSyntax(token, \"(\")) {\n\t\t\t\tlexer.next();\n\t\t\t\texpr = parseExpression();\n\t\t\t\ttoken = lexer.next();\n\t\t\t\tif (!matchSyntax(token, \")\")) {\n\t\t\t\t\tthrow new SyntaxError(\"Expected )\");\n\t\t\t\t}\n\t\t\t\treturn expr;\n\t\t\t}\n\t\t\tthrow new SyntaxError(\"Tone.Expr: Parse error, cannot process token \" + token.value);\n\t\t}\n\n\t\tfunction parseFunctionCall(func) {\n\t\t\tvar token, args = [];\n\t\t\ttoken = lexer.next();\n\t\t\tif (!matchSyntax(token, \"(\")) {\n\t\t\t\tthrow new SyntaxError(\"Tone.Expr: Expected ( in a function call \\\"\" + func.value + \"\\\"\");\n\t\t\t}\n\t\t\ttoken = lexer.peek();\n\t\t\tif (!matchSyntax(token, \")\")) {\n\t\t\t\targs = parseArgumentList();\n\t\t\t}\n\t\t\ttoken = lexer.next();\n\t\t\tif (!matchSyntax(token, \")\")) {\n\t\t\t\tthrow new SyntaxError(\"Tone.Expr: Expected ) in a function call \\\"\" + func.value + \"\\\"\");\n\t\t\t}\n\t\t\treturn {\n\t\t\t\tmethod : func.method,\n\t\t\t\targs : args,\n\t\t\t\tname : name\n\t\t\t};\n\t\t}\n\n\t\tfunction parseArgumentList() {\n\t\t\tvar token, expr, args = [];\n\t\t\twhile (true) {\n\t\t\t\texpr = parseExpression();\n\t\t\t\tif (isUndef(expr)) {\n\t\t\t\t\t// TODO maybe throw exception?\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\targs.push(expr);\n\t\t\t\ttoken = lexer.peek();\n\t\t\t\tif (!matchSyntax(token, \",\")) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\tlexer.next();\n\t\t\t}\n\t\t\treturn args;\n\t\t}\n\n\t\treturn parseExpression();\n\t};\n\n\t/**\n\t * recursively evaluate the expression tree\n\t * @param {Object} tree \n\t * @return {AudioNode} the resulting audio node from the expression\n\t * @private\n\t */\n\tTone.Expr.prototype._eval = function(tree){\n\t\tif (!this.isUndef(tree)){\n\t\t\tvar node = tree.method(tree.args, this);\n\t\t\tthis._nodes.push(node);\n\t\t\treturn node;\n\t\t} \n\t};\n\n\t/**\n\t * dispose all the nodes\n\t * @private\n\t */\n\tTone.Expr.prototype._disposeNodes = function(){\n\t\tfor (var i = 0; i < this._nodes.length; i++){\n\t\t\tvar node = this._nodes[i];\n\t\t\tif (this.isFunction(node.dispose)) {\n\t\t\t\tnode.dispose();\n\t\t\t} else if (this.isFunction(node.disconnect)) {\n\t\t\t\tnode.disconnect();\n\t\t\t}\n\t\t\tnode = null;\n\t\t\tthis._nodes[i] = null;\n\t\t}\n\t\tthis._nodes = null;\n\t};\n\n\t/**\n\t * clean up\n\t */\n\tTone.Expr.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._disposeNodes();\n\t};\n\n\treturn Tone.Expr;\n});","define([\"Tone/core/Tone\", \"Tone/signal/GreaterThanZero\", \"Tone/signal/Subtract\", \"Tone/signal/Signal\"], \n\tfunction(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Output 1 if the signal is greater than the value, otherwise outputs 0.\n\t * can compare two signals or a signal and a number. \n\t * \n\t * @constructor\n\t * @extends {Tone.Signal}\n\t * @param {number} [value=0] the value to compare to the incoming signal\n\t * @example\n\t * var gt = new Tone.GreaterThan(2);\n\t * var sig = new Tone.Signal(4).connect(gt);\n\t * //output of gt is equal 1. \n\t */\n\tTone.GreaterThan = function(value){\n\n\t\tthis.createInsOuts(2, 0);\n\t\t\n\t\t/**\n\t\t * subtract the amount from the incoming signal\n\t\t * @type {Tone.Subtract}\n\t\t * @private\n\t\t */\n\t\tthis._param = this.input[0] = new Tone.Subtract(value);\n\t\tthis.input[1] = this._param.input[1];\n\n\t\t/**\n\t\t * compare that amount to zero\n\t\t * @type {Tone.GreaterThanZero}\n\t\t * @private\n\t\t */\n\t\tthis._gtz = this.output = new Tone.GreaterThanZero();\n\n\t\t//connect\n\t\tthis._param.connect(this._gtz);\n\t};\n\n\tTone.extend(Tone.GreaterThan, Tone.Signal);\n\n\t/**\n\t * dispose method\n\t * @returns {Tone.GreaterThan} this\n\t */\n\tTone.GreaterThan.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._param.dispose();\n\t\tthis._param = null;\n\t\tthis._gtz.dispose();\n\t\tthis._gtz = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.GreaterThan;\n});","define([\"Tone/core/Tone\", \"Tone/signal/WaveShaper\", \"Tone/signal/SignalBase\"], \nfunction(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Return the absolute value of an incoming signal. \n\t * \n\t * @constructor\n\t * @extends {Tone.SignalBase}\n\t * @example\n\t * var signal = new Tone.Signal(-1);\n\t * var abs = new Tone.Abs();\n\t * signal.connect(abs);\n\t * //the output of abs is 1. \n\t */\n\tTone.Abs = function(){\n\t\t/**\n\t\t * @type {Tone.LessThan}\n\t\t * @private\n\t\t */\n\t\tthis._abs = this.input = this.output = new Tone.WaveShaper(function(val){\n\t\t\tif (val === 0){\n\t\t\t\treturn 0;\n\t\t\t} else {\n\t\t\t\treturn Math.abs(val);\n\t\t\t}\n\t\t}, 127);\n\t};\n\n\tTone.extend(Tone.Abs, Tone.SignalBase);\n\n\t/**\n\t * dispose method\n\t * @returns {Tone.Abs} this\n\t */\n\tTone.Abs.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._abs.dispose();\n\t\tthis._abs = null;\n\t\treturn this;\n\t}; \n\n\treturn Tone.Abs;\n});","define([\"Tone/core/Tone\", \"Tone/signal/WaveShaper\", \"Tone/signal/Multiply\", \"Tone/signal/Subtract\"], \nfunction(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Signal-rate modulo operator. Only works in AudioRange [-1, 1] and for modulus\n\t * values in the NormalRange. \n\t *\n\t * @constructor\n\t * @extends {Tone.SignalBase}\n\t * @param {NormalRange} modulus The modulus to apply.\n\t * @example\n\t * var mod = new Tone.Modulo(0.2)\n\t * var sig = new Tone.Signal(0.5).connect(mod);\n\t * //mod outputs 0.1\n\t */\n\tTone.Modulo = function(modulus){\n\n\t\tthis.createInsOuts(1, 0);\n\n\t\t/**\n\t\t * A waveshaper gets the integer multiple of \n\t\t * the input signal and the modulus.\n\t\t * @private\n\t\t * @type {Tone.WaveShaper}\n\t\t */\n\t\tthis._shaper = new Tone.WaveShaper(Math.pow(2, 16));\n\n\t\t/**\n\t\t * the integer multiple is multiplied by the modulus\n\t\t * @type {Tone.Multiply}\n\t\t * @private\n\t\t */\n\t\tthis._multiply = new Tone.Multiply();\n\n\t\t/**\n\t\t * and subtracted from the input signal\n\t\t * @type {Tone.Subtract}\n\t\t * @private\n\t\t */\n\t\tthis._subtract = this.output = new Tone.Subtract();\n\n\t\t/**\n\t\t * the modulus signal\n\t\t * @type {Tone.Signal}\n\t\t * @private\n\t\t */\n\t\tthis._modSignal = new Tone.Signal(modulus);\n\n\t\t//connections\n\t\tthis.input.fan(this._shaper, this._subtract);\n\t\tthis._modSignal.connect(this._multiply, 0, 0);\n\t\tthis._shaper.connect(this._multiply, 0, 1);\n\t\tthis._multiply.connect(this._subtract, 0, 1);\n\t\tthis._setWaveShaper(modulus);\n\t};\n\n\tTone.extend(Tone.Modulo, Tone.SignalBase);\n\n\t/**\n\t * @param {number} mod the modulus to apply\n\t * @private\n\t */\n\tTone.Modulo.prototype._setWaveShaper = function(mod){\n\t\tthis._shaper.setMap(function(val){\n\t\t\tvar multiple = Math.floor((val + 0.0001) / mod);\n\t\t\treturn multiple;\n\t\t});\n\t};\n\n\t/**\n\t * The modulus value.\n\t * @memberOf Tone.Modulo#\n\t * @type {NormalRange}\n\t * @name value\n\t */\n\tObject.defineProperty(Tone.Modulo.prototype, \"value\", {\n\t\tget : function(){\n\t\t\treturn this._modSignal.value;\n\t\t},\n\t\tset : function(mod){\n\t\t\tthis._modSignal.value = mod;\n\t\t\tthis._setWaveShaper(mod);\n\t\t}\n\t});\n\n\t/**\n\t * clean up\n\t * @returns {Tone.Modulo} this\n\t */\n\tTone.Modulo.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._shaper.dispose();\n\t\tthis._shaper = null;\n\t\tthis._multiply.dispose();\n\t\tthis._multiply = null;\n\t\tthis._subtract.dispose();\n\t\tthis._subtract = null;\n\t\tthis._modSignal.dispose();\n\t\tthis._modSignal = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.Modulo;\n});","define([\"Tone/core/Tone\", \"Tone/signal/WaveShaper\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Pow applies an exponent to the incoming signal. The incoming signal\n\t * must be AudioRange.\n\t *\n\t * @extends {Tone.SignalBase}\n\t * @constructor\n\t * @param {Positive} exp The exponent to apply to the incoming signal, must be at least 2. \n\t * @example\n\t * var pow = new Tone.Pow(2);\n\t * var sig = new Tone.Signal(0.5).connect(pow);\n\t * //output of pow is 0.25. \n\t */\n\tTone.Pow = function(exp){\n\n\t\t/**\n\t\t * the exponent\n\t\t * @private\n\t\t * @type {number}\n\t\t */\n\t\tthis._exp = this.defaultArg(exp, 1);\n\n\t\t/**\n\t\t * @type {WaveShaperNode}\n\t\t * @private\n\t\t */\n\t\tthis._expScaler = this.input = this.output = new Tone.WaveShaper(this._expFunc(this._exp), 8192);\n\t};\n\n\tTone.extend(Tone.Pow, Tone.SignalBase);\n\n\t/**\n\t * The value of the exponent.\n\t * @memberOf Tone.Pow#\n\t * @type {number}\n\t * @name value\n\t */\n\tObject.defineProperty(Tone.Pow.prototype, \"value\", {\n\t\tget : function(){\n\t\t\treturn this._exp;\n\t\t},\n\t\tset : function(exp){\n\t\t\tthis._exp = exp;\n\t\t\tthis._expScaler.setMap(this._expFunc(this._exp));\n\t\t}\n\t});\n\n\n\t/**\n\t * the function which maps the waveshaper\n\t * @param {number} exp\n\t * @return {function}\n\t * @private\n\t */\n\tTone.Pow.prototype._expFunc = function(exp){\n\t\treturn function(val){\n\t\t\treturn Math.pow(Math.abs(val), exp);\n\t\t};\n\t};\n\n\t/**\n\t * Clean up.\n\t * @returns {Tone.Pow} this\n\t */\n\tTone.Pow.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._expScaler.dispose();\n\t\tthis._expScaler = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.Pow;\n});","define([\"Tone/core/Tone\", \"Tone/signal/WaveShaper\", \"Tone/signal/Signal\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class AudioToGain converts an input in AudioRange [-1,1] to NormalRange [0,1]. \n\t * See Tone.GainToAudio.\n\t *\n\t * @extends {Tone.SignalBase}\n\t * @constructor\n\t * @example\n\t * var a2g = new Tone.AudioToGain();\n\t */\n\tTone.AudioToGain = function(){\n\n\t\t/**\n\t\t * @type {WaveShaperNode}\n\t\t * @private\n\t\t */\n\t\tthis._norm = this.input = this.output = new Tone.WaveShaper(function(x){\n\t\t\treturn (x + 1) / 2;\n\t\t});\n\t};\n\n\tTone.extend(Tone.AudioToGain, Tone.SignalBase);\n\n\t/**\n\t * clean up\n\t * @returns {Tone.AudioToGain} this\n\t */\n\tTone.AudioToGain.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._norm.dispose();\n\t\tthis._norm = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.AudioToGain;\n});","define([\"Tone/core/Tone\", \"Tone/signal/WaveShaper\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Convert an incoming signal between 0, 1 to an equal power gain scale.\n\t *\n\t * @extends {Tone.SignalBase}\n\t * @constructor\n\t * @example\n\t * var eqPowGain = new Tone.EqualPowerGain();\n\t */\n\tTone.EqualPowerGain = function(){\n\n\t\t/**\n\t\t * @type {Tone.WaveShaper}\n\t\t * @private\n\t\t */\n\t\tthis._eqPower = this.input = this.output = new Tone.WaveShaper(function(val){\n\t\t\tif (Math.abs(val) < 0.001){\n\t\t\t\t//should output 0 when input is 0\n\t\t\t\treturn 0;\n\t\t\t} else {\n\t\t\t\treturn this.equalPowerScale(val);\n\t\t\t}\n\t\t}.bind(this), 4096);\n\t};\n\n\tTone.extend(Tone.EqualPowerGain, Tone.SignalBase);\n\n\t/**\n\t * clean up\n\t * @returns {Tone.EqualPowerGain} this\n\t */\n\tTone.EqualPowerGain.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._eqPower.dispose();\n\t\tthis._eqPower = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.EqualPowerGain;\n});","'use strict';\n\ndefine(function (require) {\n\n var Effect = require('effect');\n var EQFilter = require('eqFilter');\n\n /**\n * p5.EQ is an audio effect that performs the function of a multiband\n * audio equalizer. Equalization is used to adjust the balance of\n * frequency compoenents of an audio signal. This process is commonly used\n * in sound production and recording to change the waveform before it reaches\n * a sound output device. EQ can also be used as an audio effect to create\n * interesting distortions by filtering out parts of the spectrum. p5.EQ is\n * built using a chain of Web Audio Biquad Filter Nodes and can be\n * instantiated with 3 or 8 bands. Bands can be added or removed from\n * the EQ by directly modifying p5.EQ.bands (the array that stores filters).\n *\n * This class extends p5.Effect.\n * Methods amp(), chain(),\n * drywet(), connect(), and\n * disconnect() are available.\n *\n * @class p5.EQ\n * @constructor\n * @extends p5.Effect\n * @param {Number} [_eqsize] Constructor will accept 3 or 8, defaults to 3\n * @return {Object} p5.EQ object\n *\n * @example\n *
\n * let eq, soundFile\n * let eqBandIndex = 0;\n * let eqBandNames = ['lows', 'mids', 'highs'];\n *\n * function preload() {\n * soundFormats('mp3', 'ogg');\n * soundFile = loadSound('assets/beat');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(toggleSound);\n *\n * eq = new p5.EQ(eqBandNames.length);\n * soundFile.disconnect();\n * eq.process(soundFile);\n * }\n *\n * function draw() {\n * background(30);\n * noStroke();\n * fill(255);\n * textAlign(CENTER);\n * text('filtering ', 50, 25);\n *\n * fill(255, 40, 255);\n * textSize(26);\n * text(eqBandNames[eqBandIndex], 50, 55);\n *\n * fill(255);\n * textSize(9);\n *\n * if (!soundFile.isPlaying()) {\n * text('tap to play', 50, 80);\n * } else {\n * text('tap to filter next band', 50, 80)\n * }\n * }\n *\n * function toggleSound() {\n * if (!soundFile.isPlaying()) {\n * soundFile.play();\n * } else {\n * eqBandIndex = (eqBandIndex + 1) % eq.bands.length;\n * }\n *\n * for (let i = 0; i < eq.bands.length; i++) {\n * eq.bands[i].gain(0);\n * }\n * // filter the band we want to filter\n * eq.bands[eqBandIndex].gain(-40);\n * }\n *
\n */\n p5.EQ = function(_eqsize) {\n Effect.call(this);\n\n //p5.EQ can be of size (3) or (8), defaults to 3\n _eqsize = _eqsize === 3 || _eqsize === 8 ? _eqsize : 3;\n\n var factor;\n _eqsize === 3 ? factor = Math.pow(2,3) : factor = 2;\n\n /**\n * The p5.EQ is built with abstracted p5.Filter objects.\n * To modify any bands, use methods of the \n * p5.Filter API, especially `gain` and `freq`.\n * Bands are stored in an array, with indices 0 - 3, or 0 - 7\n * @property {Array} bands\n *\n */\n this.bands = [];\n\n\n var freq, res;\n for (var i = 0; i < _eqsize; i++) {\n if (i === _eqsize - 1) {\n freq = 21000;\n res = .01;\n } else if (i === 0) {\n freq = 100;\n res = .1;\n }\n else if (i===1) {\n freq = _eqsize === 3 ? 360 * factor : 360;\n res = 1;\n }else {\n freq = this.bands[i-1].freq() * factor;\n res = 1;\n }\n this.bands[i] = this._newBand(freq, res);\n\n if (i>0) {\n this.bands[i-1].connect(this.bands[i].biquad);\n } else {\n this.input.connect(this.bands[i].biquad);\n }\n }\n this.bands[_eqsize-1].connect(this.output);\n };\n p5.EQ.prototype = Object.create(Effect.prototype);\n\n /**\n * Process an input by connecting it to the EQ\n * @method process\n * @param {Object} src Audio source\n */\n p5.EQ.prototype.process = function (src) {\n src.connect(this.input);\n };\n\n // /**\n // * Set the frequency and gain of each band in the EQ. This method should be\n // * called with 3 or 8 frequency and gain pairs, depending on the size of the EQ.\n // * ex. eq.set(freq0, gain0, freq1, gain1, freq2, gain2);\n // *\n // * @method set\n // * @for p5.EQ\n // * @param {Number} [freq0] Frequency value for band with index 0\n // * @param {Number} [gain0] Gain value for band with index 0\n // * @param {Number} [freq1] Frequency value for band with index 1\n // * @param {Number} [gain1] Gain value for band with index 1\n // * @param {Number} [freq2] Frequency value for band with index 2\n // * @param {Number} [gain2] Gain value for band with index 2\n // * @param {Number} [freq3] Frequency value for band with index 3\n // * @param {Number} [gain3] Gain value for band with index 3\n // * @param {Number} [freq4] Frequency value for band with index 4\n // * @param {Number} [gain4] Gain value for band with index 4\n // * @param {Number} [freq5] Frequency value for band with index 5\n // * @param {Number} [gain5] Gain value for band with index 5\n // * @param {Number} [freq6] Frequency value for band with index 6\n // * @param {Number} [gain6] Gain value for band with index 6\n // * @param {Number} [freq7] Frequency value for band with index 7\n // * @param {Number} [gain7] Gain value for band with index 7\n // */\n p5.EQ.prototype.set = function() {\n if (arguments.length === this.bands.length * 2) {\n for (var i = 0; i < arguments.length; i+=2) {\n this.bands[i/2].freq(arguments[i]);\n this.bands[i/2].gain(arguments[i+1]);\n }\n }\n else {\n console.error('Argument mismatch. .set() should be called with ' + this.bands.length*2 +\n ' arguments. (one frequency and gain value pair for each band of the eq)');\n }\n };\n\n /**\n * Add a new band. Creates a p5.Filter and strips away everything but\n * the raw biquad filter. This method returns an abstracted p5.Filter,\n * which can be added to p5.EQ.bands, in order to create new EQ bands.\n * @private\n * @for p5.EQ\n * @method _newBand\n * @param {Number} freq\n * @param {Number} res\n * @return {Object} Abstracted Filter\n */\n p5.EQ.prototype._newBand = function(freq, res) {\n return new EQFilter(freq, res);\n };\n\n p5.EQ.prototype.dispose = function () {\n Effect.prototype.dispose.apply(this);\n\n if (this.bands) {\n while (this.bands.length > 0) {\n delete this.bands.pop().dispose();\n }\n delete this.bands;\n }\n };\n\n return p5.EQ;\n});\n","'use strict';\n\ndefine(function (require) {\n var Filter = require('filter');\n var p5sound = require('master');\n\n /**\n * EQFilter extends p5.Filter with constraints\n * necessary for the p5.EQ\n *\n * @private\n */\n var EQFilter = function(freq, res) {\n Filter.call(this, 'peaking');\n this.disconnect();\n this.set(freq, res);\n this.biquad.gain.value = 0;\n delete this.input;\n delete this.output;\n delete this._drywet;\n delete this.wet;\n\n };\n EQFilter.prototype = Object.create(Filter.prototype);\n\n EQFilter.prototype.amp = function() {\n console.warn('`amp()` is not available for p5.EQ bands. Use `.gain()`');\n };\n EQFilter.prototype.drywet = function() {\n console.warn('`drywet()` is not available for p5.EQ bands.');\n };\n EQFilter.prototype.connect = function(unit) {\n var u = unit || p5.soundOut.input;\n if (this.biquad) {\n this.biquad.connect(u.input ? u.input : u);\n } else {\n this.output.connect(u.input ? u.input : u);\n }\n };\n\n EQFilter.prototype.disconnect = function() {\n if (this.biquad) {\n this.biquad.disconnect();\n }\n };\n EQFilter.prototype.dispose = function() {\n // remove reference form soundArray\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n this.disconnect();\n delete this.biquad;\n };\n\n return EQFilter;\n});\n","'use strict'\n\ndefine(function (require) {\n var p5sound = require('master');\n var Effect = require('effect');\n\n /**\n * Panner3D is based on the \n * Web Audio Spatial Panner Node.\n * This panner is a spatial processing node that allows audio to be positioned\n * and oriented in 3D space.\n *\n * The position is relative to an \n * Audio Context Listener, which can be accessed\n * by p5.soundOut.audiocontext.listener\n *\n *\n * @class p5.Panner3D\n * @constructor\n */\n\tp5.Panner3D = function() {\n Effect.call(this);\n\n /**\n * \n * Web Audio Spatial Panner Node\n *\n * Properties include\n * - panningModel: \"equal power\" or \"HRTF\"\n * - distanceModel: \"linear\", \"inverse\", or \"exponential\"\n *\n * @property {AudioNode} panner\n *\n */\n this.panner = this.ac.createPanner();\n this.panner.panningModel = 'HRTF';\n this.panner.distanceModel = 'linear';\n this.panner.connect(this.output);\n this.input.connect(this.panner);\n\t};\n\n p5.Panner3D.prototype = Object.create(Effect.prototype);\n\n\n /**\n * Connect an audio sorce\n *\n * @method process\n * @for p5.Panner3D\n * @param {Object} src Input source\n */\n p5.Panner3D.prototype.process = function(src) {\n src.connect(this.input);\n }\n /**\n * Set the X,Y,Z position of the Panner\n * @method set\n * @for p5.Panner3D\n * @param {Number} xVal\n * @param {Number} yVal\n * @param {Number} zVal\n * @param {Number} time\n * @return {Array} Updated x, y, z values as an array\n */\n p5.Panner3D.prototype.set = function(xVal, yVal, zVal, time) {\n this.positionX(xVal,time);\n this.positionY(yVal,time);\n this.positionZ(zVal,time);\n return [this.panner.positionX.value,\n this.panner.positionY.value,\n this.panner.positionZ.value];\n };\n\n /**\n * Getter and setter methods for position coordinates\n * @method positionX\n * @for p5.Panner3D\n * @return {Number} updated coordinate value\n */\n /**\n * Getter and setter methods for position coordinates\n * @method positionY\n * @for p5.Panner3D\n * @return {Number} updated coordinate value\n */\n /**\n * Getter and setter methods for position coordinates\n * @method positionZ\n * @for p5.Panner3D\n * @return {Number} updated coordinate value\n */\n p5.Panner3D.prototype.positionX = function(xVal, time) {\n var t = time || 0;\n if (typeof xVal === 'number') {\n this.panner.positionX.value = xVal;\n this.panner.positionX.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.panner.positionX.linearRampToValueAtTime(xVal, this.ac.currentTime + 0.02 + t);\n } else if (xVal) {\n xVal.connect(this.panner.positionX);\n }\n return this.panner.positionX.value;\n };\n p5.Panner3D.prototype.positionY = function(yVal, time) {\n var t = time || 0;\n if (typeof yVal === 'number') {\n this.panner.positionY.value = yVal;\n this.panner.positionY.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.panner.positionY.linearRampToValueAtTime(yVal, this.ac.currentTime + 0.02 + t);\n } else if (yVal) {\n yVal.connect(this.panner.positionY);\n }\n return this.panner.positionY.value;\n };\n p5.Panner3D.prototype.positionZ = function(zVal, time) {\n var t = time || 0;\n if (typeof zVal === 'number') {\n this.panner.positionZ.value = zVal;\n this.panner.positionZ.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.panner.positionZ.linearRampToValueAtTime(zVal, this.ac.currentTime + 0.02 + t);\n } else if (zVal) {\n zVal.connect(this.panner.positionZ);\n }\n return this.panner.positionZ.value;\n };\n\n /**\n * Set the X,Y,Z position of the Panner\n * @method orient\n * @for p5.Panner3D\n * @param {Number} xVal\n * @param {Number} yVal\n * @param {Number} zVal\n * @param {Number} time\n * @return {Array} Updated x, y, z values as an array\n */\n p5.Panner3D.prototype.orient = function(xVal, yVal, zVal, time) {\n this.orientX(xVal,time);\n this.orientY(yVal,time);\n this.orientZ(zVal,time);\n return [this.panner.orientationX.value,\n this.panner.orientationY.value,\n this.panner.orientationZ.value];\n };\n\n /**\n * Getter and setter methods for orient coordinates\n * @method orientX\n * @for p5.Panner3D\n * @return {Number} updated coordinate value\n */\n /**\n * Getter and setter methods for orient coordinates\n * @method orientY\n * @for p5.Panner3D\n * @return {Number} updated coordinate value\n */\n /**\n * Getter and setter methods for orient coordinates\n * @method orientZ\n * @for p5.Panner3D\n * @return {Number} updated coordinate value\n */\n p5.Panner3D.prototype.orientX = function(xVal, time) {\n var t = time || 0;\n if (typeof xVal === 'number') {\n this.panner.orientationX.value = xVal;\n this.panner.orientationX.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.panner.orientationX.linearRampToValueAtTime(xVal, this.ac.currentTime + 0.02 + t);\n } else if (xVal) {\n xVal.connect(this.panner.orientationX);\n }\n return this.panner.orientationX.value;\n };\n p5.Panner3D.prototype.orientY = function(yVal, time) {\n var t = time || 0;\n if (typeof yVal === 'number') {\n this.panner.orientationY.value = yVal;\n this.panner.orientationY.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.panner.orientationY.linearRampToValueAtTime(yVal, this.ac.currentTime + 0.02 + t);\n } else if (yVal) {\n yVal.connect(this.panner.orientationY);\n }\n return this.panner.orientationY.value;\n };\n p5.Panner3D.prototype.orientZ = function(zVal, time) {\n var t = time || 0;\n if (typeof zVal === 'number') {\n this.panner.orientationZ.value = zVal;\n this.panner.orientationZ.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.panner.orientationZ.linearRampToValueAtTime(zVal, this.ac.currentTime + 0.02 + t);\n } else if (zVal) {\n zVal.connect(this.panner.orientationZ);\n }\n return this.panner.orientationZ.value;\n };\n\n /**\n * Set the rolloff factor and max distance\n * @method setFalloff\n * @for p5.Panner3D\n * @param {Number} [maxDistance]\n * @param {Number} [rolloffFactor]\n */\n p5.Panner3D.prototype.setFalloff = function(maxDistance, rolloffFactor) {\n this.maxDist(maxDistance);\n this.rolloff(rolloffFactor);\n };\n /**\n * Maxium distance between the source and the listener\n * @method maxDist\n * @for p5.Panner3D\n * @param {Number} maxDistance\n * @return {Number} updated value\n */\n p5.Panner3D.prototype.maxDist = function(maxDistance){\n if (typeof maxDistance === 'number') {\n this.panner.maxDistance = maxDistance;\n }\n return this.panner.maxDistance;\n };\n\n /**\n * How quickly the volume is reduced as the source moves away from the listener\n * @method rollof\n * @for p5.Panner3D\n * @param {Number} rolloffFactor\n * @return {Number} updated value\n */\n p5.Panner3D.prototype.rolloff = function(rolloffFactor){\n if (typeof rolloffFactor === 'number') {\n this.panner.rolloffFactor = rolloffFactor;\n }\n return this.panner.rolloffFactor;\n };\n\n p5.Panner3D.dispose = function() {\n Effect.prototype.dispose.apply(this);\n if (this.panner) {\n this.panner.disconnect();\n delete this.panner;\n }\n };\n\n return p5.Panner3D;\n\n});\n","'use strict'\n\ndefine(function (require) {\n var p5sound = require('master');\n var Effect = require('effect');\n\n// /**\n// * listener is a class that can construct both a Spatial Panner\n// * and a Spatial Listener. The panner is based on the \n// * Web Audio Spatial Panner Node\n// * https://www.w3.org/TR/webaudio/#the-listenernode-interface\n// * This panner is a spatial processing node that allows audio to be positioned\n// * and oriented in 3D space. \n// *\n// * The Listener modifies the properties of the Audio Context Listener. \n// * Both objects types use the same methods. The default is a spatial panner.\n// *\n// * p5.Panner3D - Constructs a Spatial Panner
\n// * p5.Listener3D - Constructs a Spatial Listener
\n// *\n// * @class listener\n// * @constructor\n// * @return {Object} p5.Listener3D Object\n// *\n// * @param {Web Audio Node} listener Web Audio Spatial Panning Node\n// * @param {AudioParam} listener.panningModel \"equal power\" or \"HRTF\"\n// * @param {AudioParam} listener.distanceModel \"linear\", \"inverse\", or \"exponential\"\n// * @param {String} [type] [Specify construction of a spatial panner or listener]\n// */\n \n\tp5.Listener3D = function(type) {\n this.ac = p5sound.audiocontext;\n this.listener = this.ac.listener;\n\t}; \n\n// /**\n// * Connect an audio sorce\n// * @param {Object} src Input source\n// */\n p5.Listener3D.prototype.process = function(src) {\n src.connect(this.input);\n }\n// /**\n// * Set the X,Y,Z position of the Panner\n// * @param {[Number]} xVal\n// * @param {[Number]} yVal\n// * @param {[Number]} zVal\n// * @param {[Number]} time\n// * @return {[Array]} [Updated x, y, z values as an array]\n// */\n p5.Listener3D.prototype.position = function(xVal, yVal, zVal, time) {\n this.positionX(xVal,time);\n this.positionY(yVal,time);\n this.positionZ(zVal,time);\n return [this.listener.positionX.value, \n this.listener.positionY.value,\n this.listener.positionZ.value];\n };\n\n// /**\n// * Getter and setter methods for position coordinates\n// * @return {Number} [updated coordinate value]\n// */\n p5.Listener3D.prototype.positionX = function(xVal, time) {\n var t = time || 0;\n if (typeof xVal === 'number') {\n this.listener.positionX.value = xVal;\n this.listener.positionX.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.listener.positionX.linearRampToValueAtTime(xVal, this.ac.currentTime + 0.02 + t);\n } else if (xVal) {\n xVal.connect(this.listener.positionX);\n }\n return this.listener.positionX.value;\n };\n p5.Listener3D.prototype.positionY = function(yVal, time) {\n var t = time || 0;\n if (typeof yVal === 'number') {\n this.listener.positionY.value = yVal;\n this.listener.positionY.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.listener.positionY.linearRampToValueAtTime(yVal, this.ac.currentTime + 0.02 + t);\n } else if (yVal) {\n yVal.connect(this.listener.positionY);\n }\n return this.listener.positionY.value;\n };\n p5.Listener3D.prototype.positionZ = function(zVal, time) {\n var t = time || 0;\n if (typeof zVal === 'number') {\n this.listener.positionZ.value = zVal;\n this.listener.positionZ.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.listener.positionZ.linearRampToValueAtTime(zVal, this.ac.currentTime + 0.02 + t);\n } else if (zVal) {\n zVal.connect(this.listener.positionZ);\n }\n return this.listener.positionZ.value;\n };\n\n// cannot define method when class definition is commented\n// /**\n// * Overrides the listener orient() method because Listener has slightly\n// * different params. In human terms, Forward vectors are the direction the \n// * nose is pointing. Up vectors are the direction of the top of the head.\n// *\n// * @method orient\n// * @param {Number} xValF Forward vector X direction\n// * @param {Number} yValF Forward vector Y direction\n// * @param {Number} zValF Forward vector Z direction\n// * @param {Number} xValU Up vector X direction\n// * @param {Number} yValU Up vector Y direction\n// * @param {Number} zValU Up vector Z direction\n// * @param {Number} time \n// * @return {Array} All orienation params\n// */\n p5.Listener3D.prototype.orient = function(xValF, yValF, zValF, \n xValU, yValU, zValU, time) {\n\n if (arguments.length === 3 || arguments.length === 4) {\n time = arguments[3];\n this.orientForward(xValF, yValF, zValF, time);\n } else if (arguments.length === 6 || arguments === 7) {\n this.orientForward(xValF, yValF, zValF);\n this.orientUp(xValU, yValU, zValU, time);\n }\n \n return [this.listener.forwardX.value, \n this.listener.forwardY.value,\n this.listener.forwardZ.value,\n this.listener.upX.value,\n this.listener.upY.value,\n this.listener.upZ.value];\n };\n\n\n p5.Listener3D.prototype.orientForward = function(xValF, yValF, zValF, time) {\n this.forwardX(xValF,time);\n this.forwardY(yValF,time);\n this.forwardZ(zValF,time);\n\n return [this.listener.forwardX, \n this.listener.forwardY,\n this.listener.forwardZ];\n };\n\n p5.Listener3D.prototype.orientUp = function(xValU, yValU, zValU, time) {\n this.upX(xValU,time);\n this.upY(yValU,time);\n this.upZ(zValU,time);\n\n return [this.listener.upX, \n this.listener.upY,\n this.listener.upZ];\n };\n// /**\n// * Getter and setter methods for orient coordinates\n// * @return {Number} [updated coordinate value]\n// */\n p5.Listener3D.prototype.forwardX = function(xVal, time) {\n var t = time || 0;\n if (typeof xVal === 'number') {\n this.listener.forwardX.value = xVal;\n this.listener.forwardX.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.listener.forwardX.linearRampToValueAtTime(xVal, this.ac.currentTime + 0.02 + t);\n } else if (xVal) {\n xVal.connect(this.listener.forwardX);\n }\n return this.listener.forwardX.value;\n };\n p5.Listener3D.prototype.forwardY = function(yVal, time) {\n var t = time || 0;\n if (typeof yVal === 'number') {\n this.listener.forwardY.value = yVal;\n this.listener.forwardY.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.listener.forwardY.linearRampToValueAtTime(yVal, this.ac.currentTime + 0.02 + t);\n } else if (yVal) {\n yVal.connect(this.listener.forwardY);\n }\n return this.listener.forwardY.value;\n };\n p5.Listener3D.prototype.forwardZ = function(zVal, time) {\n var t = time || 0;\n if (typeof zVal === 'number') {\n this.listener.forwardZ.value = zVal;\n this.listener.forwardZ.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.listener.forwardZ.linearRampToValueAtTime(zVal, this.ac.currentTime + 0.02 + t);\n } else if (zVal) {\n zVal.connect(this.listener.forwardZ);\n }\n return this.listener.forwardZ.value;\n };\n p5.Listener3D.prototype.upX = function(xVal, time) {\n var t = time || 0;\n if (typeof xVal === 'number') {\n this.listener.upX.value = xVal;\n this.listener.upX.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.listener.upX.linearRampToValueAtTime(xVal, this.ac.currentTime + 0.02 + t);\n } else if (xVal) {\n xVal.connect(this.listener.upX);\n }\n return this.listener.upX.value;\n };\n p5.Listener3D.prototype.upY = function(yVal, time) {\n var t = time || 0;\n if (typeof yVal === 'number') {\n this.listener.upY.value = yVal;\n this.listener.upY.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.listener.upY.linearRampToValueAtTime(yVal, this.ac.currentTime + 0.02 + t);\n } else if (yVal) {\n yVal.connect(this.listener.upY);\n }\n return this.listener.upY.value;\n };\n p5.Listener3D.prototype.upZ = function(zVal, time) {\n var t = time || 0;\n if (typeof zVal === 'number') {\n this.listener.upZ.value = zVal;\n this.listener.upZ.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.listener.upZ.linearRampToValueAtTime(zVal, this.ac.currentTime + 0.02 + t);\n } else if (zVal) {\n zVal.connect(this.listener.upZ);\n }\n return this.listener.upZ.value;\n };\n \n return p5.Listener3D;\n\n});","'use strict';\n\ndefine(function (require) {\n var Filter = require('filter');\n var Effect = require('effect');\n\n /**\n * Delay is an echo effect. It processes an existing sound source,\n * and outputs a delayed version of that sound. The p5.Delay can\n * produce different effects depending on the delayTime, feedback,\n * filter, and type. In the example below, a feedback of 0.5 (the\n * default value) will produce a looping delay that decreases in\n * volume by 50% each repeat. A filter will cut out the high\n * frequencies so that the delay does not sound as piercing as the\n * original source.\n *\n *\n * This class extends p5.Effect.\n * Methods amp(), chain(),\n * drywet(), connect(), and\n * disconnect() are available.\n * @class p5.Delay\n * @extends p5.Effect\n * @constructor\n * @example\n *
\n * let osc;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * background(220);\n * textAlign(CENTER);\n * text('tap to play', width/2, height/2);\n *\n * osc = new p5.Oscillator('square');\n * osc.amp(0.5);\n * delay = new p5.Delay();\n *\n * // delay.process() accepts 4 parameters:\n * // source, delayTime (in seconds), feedback, filter frequency\n * delay.process(osc, 0.12, .7, 2300);\n *\n * cnv.mousePressed(oscStart);\n * }\n *\n * function oscStart() {\n * osc.start();\n * }\n *\n * function mouseReleased() {\n * osc.stop();\n * }\n *
\n */\n p5.Delay = function() {\n \tEffect.call(this);\n\n this._split = this.ac.createChannelSplitter(2);\n this._merge = this.ac.createChannelMerger(2);\n\n this._leftGain = this.ac.createGain();\n this._rightGain = this.ac.createGain();\n\n /**\n * The p5.Delay is built with two\n * \n * Web Audio Delay Nodes, one for each stereo channel.\n *\n * @for p5.Delay\n * @property {DelayNode} leftDelay\n */\n this.leftDelay = this.ac.createDelay();\n /**\n * The p5.Delay is built with two\n * \n * Web Audio Delay Nodes, one for each stereo channel.\n * @for p5.Delay\n * @property {DelayNode} rightDelay\n */\n this.rightDelay = this.ac.createDelay();\n\n this._leftFilter = new Filter();\n this._rightFilter = new Filter();\n this._leftFilter.disconnect();\n this._rightFilter.disconnect();\n\n this._leftFilter.biquad.frequency.setValueAtTime(1200, this.ac.currentTime);\n this._rightFilter.biquad.frequency.setValueAtTime(1200, this.ac.currentTime);\n this._leftFilter.biquad.Q.setValueAtTime(0.3, this.ac.currentTime);\n this._rightFilter.biquad.Q.setValueAtTime(0.3, this.ac.currentTime);\n\n // graph routing\n this.input.connect(this._split);\n this.leftDelay.connect(this._leftGain);\n this.rightDelay.connect(this._rightGain);\n this._leftGain.connect(this._leftFilter.input);\n this._rightGain.connect(this._rightFilter.input);\n this._merge.connect(this.wet);\n\n\n this._leftFilter.biquad.gain.setValueAtTime(1, this.ac.currentTime);\n this._rightFilter.biquad.gain.setValueAtTime(1, this.ac.currentTime);\n\n // default routing\n this.setType(0);\n\n this._maxDelay = this.leftDelay.delayTime.maxValue;\n\n // set initial feedback to 0.5\n this.feedback(0.5);\n\n\n };\n\n p5.Delay.prototype = Object.create(Effect.prototype);\n /**\n * Add delay to an audio signal according to a set\n * of delay parameters.\n *\n * @method process\n * @for p5.Delay\n * @param {Object} Signal An object that outputs audio\n * @param {Number} [delayTime] Time (in seconds) of the delay/echo.\n * Some browsers limit delayTime to\n * 1 second.\n * @param {Number} [feedback] sends the delay back through itself\n * in a loop that decreases in volume\n * each time.\n * @param {Number} [lowPass] Cutoff frequency. Only frequencies\n * below the lowPass will be part of the\n * delay.\n */\n p5.Delay.prototype.process = function(src, _delayTime, _feedback, _filter) {\n var feedback = _feedback || 0;\n var delayTime = _delayTime || 0;\n if (feedback >= 1.0) {\n throw new Error('Feedback value will force a positive feedback loop.');\n }\n if (delayTime >= this._maxDelay) {\n throw new Error('Delay Time exceeds maximum delay time of ' + this._maxDelay + ' second.');\n }\n\n src.connect(this.input);\n this.leftDelay.delayTime.setValueAtTime(delayTime, this.ac.currentTime);\n this.rightDelay.delayTime.setValueAtTime(delayTime, this.ac.currentTime);\n this._leftGain.gain.value = feedback;\n this._rightGain.gain.value = feedback;\n\n if (_filter) {\n this._leftFilter.freq(_filter);\n this._rightFilter.freq(_filter);\n }\n };\n\n /**\n * Set the delay (echo) time, in seconds. Usually this value will be\n * a floating point number between 0.0 and 1.0.\n *\n * @method delayTime\n * @for p5.Delay\n * @param {Number} delayTime Time (in seconds) of the delay\n */\n p5.Delay.prototype.delayTime = function(t) {\n // if t is an audio node...\n if (typeof t !== 'number') {\n t.connect(this.leftDelay.delayTime);\n t.connect(this.rightDelay.delayTime);\n }\n\n else {\n this.leftDelay.delayTime.cancelScheduledValues(this.ac.currentTime);\n this.rightDelay.delayTime.cancelScheduledValues(this.ac.currentTime);\n this.leftDelay.delayTime.linearRampToValueAtTime(t, this.ac.currentTime);\n this.rightDelay.delayTime.linearRampToValueAtTime(t, this.ac.currentTime);\n }\n };\n\n /**\n * Feedback occurs when Delay sends its signal back through its input\n * in a loop. The feedback amount determines how much signal to send each\n * time through the loop. A feedback greater than 1.0 is not desirable because\n * it will increase the overall output each time through the loop,\n * creating an infinite feedback loop. The default value is 0.5\n *\n * @method feedback\n * @for p5.Delay\n * @param {Number|Object} feedback 0.0 to 1.0, or an object such as an\n * Oscillator that can be used to\n * modulate this param\n * @returns {Number} Feedback value\n *\n */\n p5.Delay.prototype.feedback = function(f) {\n // if f is an audio node...\n if (f && typeof f !== 'number') {\n f.connect(this._leftGain.gain);\n f.connect(this._rightGain.gain);\n }\n else if (f >= 1.0) {\n throw new Error('Feedback value will force a positive feedback loop.');\n }\n else if (typeof f === 'number') {\n this._leftGain.gain.value = f;\n this._rightGain.gain.value = f;\n }\n\n // return value of feedback\n return this._leftGain.gain.value;\n };\n\n /**\n * Set a lowpass filter frequency for the delay. A lowpass filter\n * will cut off any frequencies higher than the filter frequency.\n *\n * @method filter\n * @for p5.Delay\n * @param {Number|Object} cutoffFreq A lowpass filter will cut off any\n * frequencies higher than the filter frequency.\n * @param {Number|Object} res Resonance of the filter frequency\n * cutoff, or an object (i.e. a p5.Oscillator)\n * that can be used to modulate this parameter.\n * High numbers (i.e. 15) will produce a resonance,\n * low numbers (i.e. .2) will produce a slope.\n */\n p5.Delay.prototype.filter = function(freq, q) {\n this._leftFilter.set(freq, q);\n this._rightFilter.set(freq, q);\n };\n\n\n /**\n * Choose a preset type of delay. 'pingPong' bounces the signal\n * from the left to the right channel to produce a stereo effect.\n * Any other parameter will revert to the default delay setting.\n *\n * @method setType\n * @for p5.Delay\n * @param {String|Number} type 'pingPong' (1) or 'default' (0)\n */\n p5.Delay.prototype.setType = function(t) {\n if (t === 1) {\n t = 'pingPong';\n }\n this._split.disconnect();\n this._leftFilter.disconnect();\n this._rightFilter.disconnect();\n this._split.connect(this.leftDelay, 0);\n this._split.connect(this.rightDelay, 1);\n switch(t) {\n case 'pingPong':\n this._rightFilter.setType( this._leftFilter.biquad.type );\n this._leftFilter.output.connect(this._merge, 0, 0);\n this._rightFilter.output.connect(this._merge, 0, 1);\n this._leftFilter.output.connect(this.rightDelay);\n this._rightFilter.output.connect(this.leftDelay);\n break;\n default:\n this._leftFilter.output.connect(this._merge, 0, 0);\n this._rightFilter.output.connect(this._merge, 0, 1);\n this._leftFilter.output.connect(this.leftDelay);\n this._rightFilter.output.connect(this.rightDelay);\n }\n };\n\n // DocBlocks for methods inherited from p5.Effect\n /**\n * Set the output level of the delay effect.\n *\n * @method amp\n * @for p5.Delay\n * @param {Number} volume amplitude between 0 and 1.0\n * @param {Number} [rampTime] create a fade that lasts rampTime\n * @param {Number} [timeFromNow] schedule this event to happen\n * seconds from now\n */\n /**\n * Send output to a p5.sound or web audio object\n *\n * @method connect\n * @for p5.Delay\n * @param {Object} unit\n */\n /**\n * Disconnect all output.\n *\n * @method disconnect\n * @for p5.Delay\n */\n\n p5.Delay.prototype.dispose = function() {\n\n Effect.prototype.dispose.apply(this);\n\n this._split.disconnect();\n this._leftFilter.dispose();\n this._rightFilter.dispose();\n this._merge.disconnect();\n this._leftGain.disconnect();\n this._rightGain.disconnect();\n this.leftDelay.disconnect();\n this.rightDelay.disconnect();\n\n this._split = undefined;\n this._leftFilter = undefined;\n this._rightFilter = undefined;\n this._merge = undefined;\n this._leftGain = undefined;\n this._rightGain = undefined;\n this.leftDelay = undefined;\n this.rightDelay = undefined;\n };\n\n});\n","'use strict';\n\ndefine(function (require) {\n var CustomError = require('errorHandler');\n var Effect = require('effect');\n\n /**\n * Reverb adds depth to a sound through a large number of decaying\n * echoes. It creates the perception that sound is occurring in a\n * physical space. The p5.Reverb has paramters for Time (how long does the\n * reverb last) and decayRate (how much the sound decays with each echo)\n * that can be set with the .set() or .process() methods. The p5.Convolver\n * extends p5.Reverb allowing you to recreate the sound of actual physical\n * spaces through convolution.\n *\n * This class extends p5.Effect.\n * Methods amp(), chain(),\n * drywet(), connect(), and\n * disconnect() are available.\n *\n * @class p5.Reverb\n * @extends p5.Effect\n * @constructor\n * @example\n *
\n * let soundFile, reverb;\n * function preload() {\n * soundFile = loadSound('assets/Damscray_DancingTiger.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playSound);\n *\n * reverb = new p5.Reverb();\n * soundFile.disconnect(); // so we'll only hear reverb...\n *\n * // connect soundFile to reverb, process w/\n * // 3 second reverbTime, decayRate of 2%\n * reverb.process(soundFile, 3, 2);\n * }\n *\n * function draw() {\n * let dryWet = constrain(map(mouseX, 0, width, 0, 1), 0, 1);\n * // 1 = all reverb, 0 = no reverb\n * reverb.drywet(dryWet);\n *\n * background(220);\n * text('tap to play', 10, 20);\n * text('dry/wet: ' + round(dryWet * 100) + '%', 10, height - 20);\n * }\n *\n * function playSound() {\n * soundFile.play();\n * }\n *
\n */\n\n\n p5.Reverb = function() {\n Effect.call(this);\n\n this._initConvolverNode();\n\n // otherwise, Safari distorts\n this.input.gain.value = 0.5;\n\n // default params\n this._seconds = 3;\n this._decay = 2;\n this._reverse = false;\n\n this._buildImpulse();\n\n };\n\n p5.Reverb.prototype = Object.create(Effect.prototype);\n\n p5.Reverb.prototype._initConvolverNode = function() {\n this.convolverNode = this.ac.createConvolver();\n this.input.connect(this.convolverNode);\n this.convolverNode.connect(this.wet);\n };\n\n p5.Reverb.prototype._teardownConvolverNode = function() {\n if (this.convolverNode) {\n this.convolverNode.disconnect();\n delete this.convolverNode;\n }\n };\n\n p5.Reverb.prototype._setBuffer = function(audioBuffer) {\n this._teardownConvolverNode();\n this._initConvolverNode();\n this.convolverNode.buffer = audioBuffer;\n };\n /**\n * Connect a source to the reverb, and assign reverb parameters.\n *\n * @method process\n * @for p5.Reverb\n * @param {Object} src p5.sound / Web Audio object with a sound\n * output.\n * @param {Number} [seconds] Duration of the reverb, in seconds.\n * Min: 0, Max: 10. Defaults to 3.\n * @param {Number} [decayRate] Percentage of decay with each echo.\n * Min: 0, Max: 100. Defaults to 2.\n * @param {Boolean} [reverse] Play the reverb backwards or forwards.\n */\n p5.Reverb.prototype.process = function(src, seconds, decayRate, reverse) {\n src.connect(this.input);\n var rebuild = false;\n if (seconds) {\n this._seconds = seconds;\n rebuild = true;\n }\n if (decayRate) {\n this._decay = decayRate;\n }\n if (reverse) {\n this._reverse = reverse;\n }\n if (rebuild) {\n this._buildImpulse();\n }\n };\n\n /**\n * Set the reverb settings. Similar to .process(), but without\n * assigning a new input.\n *\n * @method set\n * @for p5.Reverb\n * @param {Number} [seconds] Duration of the reverb, in seconds.\n * Min: 0, Max: 10. Defaults to 3.\n * @param {Number} [decayRate] Percentage of decay with each echo.\n * Min: 0, Max: 100. Defaults to 2.\n * @param {Boolean} [reverse] Play the reverb backwards or forwards.\n */\n p5.Reverb.prototype.set = function(seconds, decayRate, reverse) {\n var rebuild = false;\n if (seconds) {\n this._seconds = seconds;\n rebuild = true;\n }\n if (decayRate) {\n this._decay = decayRate;\n }\n if (reverse) {\n this._reverse = reverse;\n }\n if (rebuild) {\n this._buildImpulse();\n }\n };\n\n // DocBlocks for methods inherited from p5.Effect\n /**\n * Set the output level of the reverb effect.\n *\n * @method amp\n * @for p5.Reverb\n * @param {Number} volume amplitude between 0 and 1.0\n * @param {Number} [rampTime] create a fade that lasts rampTime\n * @param {Number} [timeFromNow] schedule this event to happen\n * seconds from now\n */\n /**\n * Send output to a p5.sound or web audio object\n *\n * @method connect\n * @for p5.Reverb\n * @param {Object} unit\n */\n /**\n * Disconnect all output.\n *\n * @method disconnect\n * @for p5.Reverb\n */\n\n /**\n * Inspired by Simple Reverb by Jordan Santell\n * https://github.com/web-audio-components/simple-reverb/blob/master/index.js\n *\n * Utility function for building an impulse response\n * based on the module parameters.\n *\n * @private\n */\n p5.Reverb.prototype._buildImpulse = function() {\n var rate = this.ac.sampleRate;\n var length = rate*this._seconds;\n var decay = this._decay;\n var impulse = this.ac.createBuffer(2, length, rate);\n var impulseL = impulse.getChannelData(0);\n var impulseR = impulse.getChannelData(1);\n var n, i;\n for (i = 0; i < length; i++) {\n n = this._reverse ? length - i : i;\n impulseL[i] = (Math.random() * 2 - 1) * Math.pow(1 - n / length, decay);\n impulseR[i] = (Math.random() * 2 - 1) * Math.pow(1 - n / length, decay);\n }\n this._setBuffer(impulse);\n };\n\n p5.Reverb.prototype.dispose = function() {\n Effect.prototype.dispose.apply(this);\n this._teardownConvolverNode();\n };\n\n // =======================================================================\n // *** p5.Convolver ***\n // =======================================================================\n\n /**\n *

p5.Convolver extends p5.Reverb. It can emulate the sound of real\n * physical spaces through a process called \n * convolution.

\n *\n *

Convolution multiplies any audio input by an \"impulse response\"\n * to simulate the dispersion of sound over time. The impulse response is\n * generated from an audio file that you provide. One way to\n * generate an impulse response is to pop a balloon in a reverberant space\n * and record the echo. Convolution can also be used to experiment with\n * sound.

\n *\n *

Use the method createConvolution(path) to instantiate a\n * p5.Convolver with a path to your impulse response audio file.

\n *\n * @class p5.Convolver\n * @extends p5.Effect\n * @constructor\n * @param {String} path path to a sound file\n * @param {Function} [callback] function to call when loading succeeds\n * @param {Function} [errorCallback] function to call if loading fails.\n * This function will receive an error or\n * XMLHttpRequest object with information\n * about what went wrong.\n * @example\n *
\n * let cVerb, sound;\n * function preload() {\n * // We have both MP3 and OGG versions of all sound assets\n * soundFormats('ogg', 'mp3');\n *\n * // Try replacing 'bx-spring' with other soundfiles like\n * // 'concrete-tunnel' 'small-plate' 'drum' 'beatbox'\n * cVerb = createConvolver('assets/bx-spring.mp3');\n *\n * // Try replacing 'Damscray_DancingTiger' with\n * // 'beat', 'doorbell', lucky_dragons_-_power_melody'\n * sound = loadSound('assets/Damscray_DancingTiger.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playSound);\n * background(220);\n * text('tap to play', 20, 20);\n *\n * // disconnect from master output...\n * sound.disconnect();\n *\n * // ...and process with cVerb\n * // so that we only hear the convolution\n * cVerb.process(sound);\n * }\n *\n * function playSound() {\n * sound.play();\n * }\n *
\n */\n p5.Convolver = function(path, callback, errorCallback) {\n \t p5.Reverb.call(this);\n\n /**\n * Internally, the p5.Convolver uses the a\n * \n * Web Audio Convolver Node.\n *\n * @property {ConvolverNode} convolverNode\n */\n this._initConvolverNode();\n\n // otherwise, Safari distorts\n this.input.gain.value = 0.5;\n\n if (path) {\n this.impulses = [];\n this._loadBuffer(path, callback, errorCallback);\n }\n else {\n // parameters\n this._seconds = 3;\n this._decay = 2;\n this._reverse = false;\n\n this._buildImpulse();\n }\n\n };\n\n p5.Convolver.prototype = Object.create(p5.Reverb.prototype);\n\n p5.prototype.registerPreloadMethod('createConvolver', p5.prototype);\n\n /**\n * Create a p5.Convolver. Accepts a path to a soundfile\n * that will be used to generate an impulse response.\n *\n * @method createConvolver\n * @for p5\n * @param {String} path path to a sound file\n * @param {Function} [callback] function to call if loading is successful.\n * The object will be passed in as the argument\n * to the callback function.\n * @param {Function} [errorCallback] function to call if loading is not successful.\n * A custom error will be passed in as the argument\n * to the callback function.\n * @return {p5.Convolver}\n * @example\n *
\n * let cVerb, sound;\n * function preload() {\n * // We have both MP3 and OGG versions of all sound assets\n * soundFormats('ogg', 'mp3');\n *\n * // Try replacing 'bx-spring' with other soundfiles like\n * // 'concrete-tunnel' 'small-plate' 'drum' 'beatbox'\n * cVerb = createConvolver('assets/bx-spring.mp3');\n *\n * // Try replacing 'Damscray_DancingTiger' with\n * // 'beat', 'doorbell', lucky_dragons_-_power_melody'\n * sound = loadSound('assets/Damscray_DancingTiger.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playSound);\n * background(220);\n * text('tap to play', 20, 20);\n *\n * // disconnect from master output...\n * sound.disconnect();\n *\n * // ...and process with cVerb\n * // so that we only hear the convolution\n * cVerb.process(sound);\n * }\n *\n * function playSound() {\n * sound.play();\n * }\n *
\n */\n p5.prototype.createConvolver = function(path, callback, errorCallback) {\n // if loading locally without a server\n if (window.location.origin.indexOf('file://') > -1 && window.cordova === 'undefined') {\n alert('This sketch may require a server to load external files. Please see http://bit.ly/1qcInwS');\n }\n var self = this;\n var cReverb = new p5.Convolver(path, function(buffer) {\n if (typeof callback === 'function') {\n callback(buffer);\n }\n\n if (typeof self._decrementPreload === 'function') {\n self._decrementPreload();\n }\n }, errorCallback);\n cReverb.impulses = [];\n return cReverb;\n };\n\n /**\n * Private method to load a buffer as an Impulse Response,\n * assign it to the convolverNode, and add to the Array of .impulses.\n *\n * @param {String} path\n * @param {Function} callback\n * @param {Function} errorCallback\n * @private\n */\n p5.Convolver.prototype._loadBuffer = function(path, callback, errorCallback) {\n var path = p5.prototype._checkFileFormats(path);\n var self = this;\n var errorTrace = new Error().stack;\n var ac = p5.prototype.getAudioContext();\n\n var request = new XMLHttpRequest();\n request.open('GET', path, true);\n request.responseType = 'arraybuffer';\n\n request.onload = function() {\n if (request.status === 200) {\n // on success loading file:\n ac.decodeAudioData(request.response,\n function(buff) {\n var buffer = {};\n var chunks = path.split('/');\n buffer.name = chunks[chunks.length - 1];\n buffer.audioBuffer = buff;\n self.impulses.push(buffer);\n self._setBuffer(buffer.audioBuffer);\n if (callback) {\n callback(buffer);\n }\n },\n // error decoding buffer. \"e\" is undefined in Chrome 11/22/2015\n function() {\n var err = new CustomError('decodeAudioData', errorTrace, self.url);\n var msg = 'AudioContext error at decodeAudioData for ' + self.url;\n if (errorCallback) {\n err.msg = msg;\n errorCallback(err);\n } else {\n console.error(msg +'\\n The error stack trace includes: \\n' + err.stack);\n }\n }\n );\n }\n // if request status != 200, it failed\n else {\n var err = new CustomError('loadConvolver', errorTrace, self.url);\n var msg = 'Unable to load ' + self.url +\n '. The request status was: ' + request.status + ' (' + request.statusText + ')';\n\n if (errorCallback) {\n err.message = msg;\n errorCallback(err);\n } else {\n console.error(msg +'\\n The error stack trace includes: \\n' + err.stack);\n }\n }\n };\n\n // if there is another error, aside from 404...\n request.onerror = function() {\n var err = new CustomError('loadConvolver', errorTrace, self.url);\n var msg = 'There was no response from the server at ' + self.url + '. Check the url and internet connectivity.';\n\n if (errorCallback) {\n err.message = msg;\n errorCallback(err);\n } else {\n console.error(msg +'\\n The error stack trace includes: \\n' + err.stack);\n }\n };\n request.send();\n };\n\n p5.Convolver.prototype.set = null;\n\n /**\n * Connect a source to the convolver.\n *\n * @method process\n * @for p5.Convolver\n * @param {Object} src p5.sound / Web Audio object with a sound\n * output.\n * @example\n *
\n * let cVerb, sound;\n * function preload() {\n * // We have both MP3 and OGG versions of all sound assets\n * soundFormats('ogg', 'mp3');\n *\n * // Try replacing 'bx-spring' with other soundfiles like\n * // 'concrete-tunnel' 'small-plate' 'drum' 'beatbox'\n * cVerb = createConvolver('assets/bx-spring.mp3');\n *\n * // Try replacing 'Damscray_DancingTiger' with\n * // 'beat', 'doorbell', lucky_dragons_-_power_melody'\n * sound = loadSound('assets/Damscray_DancingTiger.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playSound);\n * background(220);\n * text('tap to play', 20, 20);\n *\n * // disconnect from master output...\n * sound.disconnect();\n *\n * // ...and process with cVerb\n * // so that we only hear the convolution\n * cVerb.process(sound);\n * }\n *\n * function playSound() {\n * sound.play();\n * }\n *\n *
\n */\n p5.Convolver.prototype.process = function(src) {\n src.connect(this.input);\n };\n\n /**\n * If you load multiple impulse files using the .addImpulse method,\n * they will be stored as Objects in this Array. Toggle between them\n * with the toggleImpulse(id) method.\n *\n * @property {Array} impulses\n * @for p5.Convolver\n */\n p5.Convolver.prototype.impulses = [];\n\n /**\n * Load and assign a new Impulse Response to the p5.Convolver.\n * The impulse is added to the .impulses array. Previous\n * impulses can be accessed with the .toggleImpulse(id)\n * method.\n *\n * @method addImpulse\n * @for p5.Convolver\n * @param {String} path path to a sound file\n * @param {Function} callback function (optional)\n * @param {Function} errorCallback function (optional)\n */\n p5.Convolver.prototype.addImpulse = function(path, callback, errorCallback) {\n // if loading locally without a server\n if (window.location.origin.indexOf('file://') > -1 && window.cordova === 'undefined') {\n alert('This sketch may require a server to load external files. Please see http://bit.ly/1qcInwS');\n }\n this._loadBuffer(path, callback, errorCallback);\n };\n\n /**\n * Similar to .addImpulse, except that the .impulses\n * Array is reset to save memory. A new .impulses\n * array is created with this impulse as the only item.\n *\n * @method resetImpulse\n * @for p5.Convolver\n * @param {String} path path to a sound file\n * @param {Function} callback function (optional)\n * @param {Function} errorCallback function (optional)\n */\n p5.Convolver.prototype.resetImpulse = function(path, callback, errorCallback) {\n // if loading locally without a server\n if (window.location.origin.indexOf('file://') > -1 && window.cordova === 'undefined') {\n alert('This sketch may require a server to load external files. Please see http://bit.ly/1qcInwS');\n }\n this.impulses = [];\n this._loadBuffer(path, callback, errorCallback);\n };\n\n /**\n * If you have used .addImpulse() to add multiple impulses\n * to a p5.Convolver, then you can use this method to toggle between\n * the items in the .impulses Array. Accepts a parameter\n * to identify which impulse you wish to use, identified either by its\n * original filename (String) or by its position in the .impulses\n * Array (Number).
\n * You can access the objects in the .impulses Array directly. Each\n * Object has two attributes: an .audioBuffer (type:\n * Web Audio \n * AudioBuffer) and a .name, a String that corresponds\n * with the original filename.\n *\n * @method toggleImpulse\n * @for p5.Convolver\n * @param {String|Number} id Identify the impulse by its original filename\n * (String), or by its position in the\n * .impulses Array (Number).\n */\n p5.Convolver.prototype.toggleImpulse = function(id) {\n if (typeof id === 'number' && id < this.impulses.length) {\n this._setBuffer(this.impulses[id].audioBuffer);\n }\n if (typeof id === 'string') {\n for (var i = 0; i < this.impulses.length; i++) {\n if (this.impulses[i].name === id) {\n this._setBuffer(this.impulses[i].audioBuffer);\n break;\n }\n }\n }\n };\n\n p5.Convolver.prototype.dispose = function() {\n p5.Reverb.prototype.dispose.apply(this);\n\n // remove all the Impulse Response buffers\n for (var i in this.impulses) {\n if (this.impulses[i]) {\n this.impulses[i] = null;\n }\n }\n };\n\n});\n","'use strict';\n\ndefine(function (require) {\n var p5sound = require('master');\n\n // requires the Tone.js library's Clock (MIT license, Yotam Mann)\n // https://github.com/TONEnoTONE/Tone.js/\n var Clock = require('Tone/core/Clock');\n\n p5.Metro = function() {\n this.clock = new Clock({\n 'callback': this.ontick.bind(this)\n });\n this.syncedParts = [];\n this.bpm = 120; // gets overridden by p5.Part\n this._init();\n\n this.prevTick = 0;\n this.tatumTime = 0;\n\n this.tickCallback = function() {};\n };\n\n p5.Metro.prototype.ontick = function(tickTime) {\n var elapsedTime = tickTime - this.prevTick;\n var secondsFromNow = tickTime - p5sound.audiocontext.currentTime;\n if (elapsedTime - this.tatumTime <= -0.02) {\n return;\n } else {\n // console.log('ok', this.syncedParts[0].phrases[0].name);\n this.prevTick = tickTime;\n\n // for all of the active things on the metro:\n var self = this;\n this.syncedParts.forEach(function(thisPart) {\n if (!thisPart.isPlaying) return;\n thisPart.incrementStep(secondsFromNow);\n // each synced source keeps track of its own beat number\n thisPart.phrases.forEach(function(thisPhrase) {\n var phraseArray = thisPhrase.sequence;\n var bNum = self.metroTicks % phraseArray.length;\n if (phraseArray[bNum] !== 0 && (self.metroTicks < phraseArray.length || !thisPhrase.looping) ) {\n thisPhrase.callback(secondsFromNow, phraseArray[bNum]);\n }\n });\n });\n this.metroTicks += 1;\n this.tickCallback(secondsFromNow);\n }\n };\n\n p5.Metro.prototype.setBPM = function(bpm, rampTime) {\n var beatTime = 60 / (bpm*this.tatums);\n var now = p5sound.audiocontext.currentTime;\n this.tatumTime = beatTime;\n\n var rampTime = rampTime || 0;\n this.clock.frequency.setValueAtTime(this.clock.frequency.value, now);\n this.clock.frequency.linearRampToValueAtTime(bpm, now + rampTime);\n this.bpm = bpm;\n };\n\n p5.Metro.prototype.getBPM = function() {\n return this.clock.getRate() / this.tatums * 60;\n };\n\n p5.Metro.prototype._init = function() {\n this.metroTicks = 0;\n // this.setBPM(120);\n };\n\n // clear existing synced parts, add only this one\n p5.Metro.prototype.resetSync = function(part) {\n this.syncedParts = [part];\n };\n\n // push a new synced part to the array\n p5.Metro.prototype.pushSync = function(part) {\n this.syncedParts.push(part);\n };\n\n p5.Metro.prototype.start = function(timeFromNow) {\n var t = timeFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n this.clock.start(now + t);\n this.setBPM(this.bpm);\n };\n\n p5.Metro.prototype.stop = function(timeFromNow) {\n var t = timeFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n this.clock.stop(now + t);\n };\n\n p5.Metro.prototype.beatLength = function(tatums) {\n this.tatums = 1/tatums / 4; // lowest possible division of a beat\n };\n\n});\n","define([\"Tone/core/Tone\", \"Tone/core/Timeline\", \"Tone/type/Type\"], function (Tone) {\n\n\t\"use strict\";\n\n\t/**\n\t * @class A Timeline State. Provides the methods: setStateAtTime(\"state\", time)\n\t * and getValueAtTime(time).\n\t *\n\t * @extends {Tone.Timeline}\n\t * @param {String} initial The initial state of the TimelineState. \n\t * Defaults to undefined\n\t */\n\tTone.TimelineState = function(initial){\n\n\t\tTone.Timeline.call(this);\n\n\t\t/**\n\t\t * The initial state\n\t\t * @private\n\t\t * @type {String}\n\t\t */\n\t\tthis._initial = initial;\n\t};\n\n\tTone.extend(Tone.TimelineState, Tone.Timeline);\n\n\t/**\n\t * Returns the scheduled state scheduled before or at\n\t * the given time.\n\t * @param {Number} time The time to query.\n\t * @return {String} The name of the state input in setStateAtTime.\n\t */\n\tTone.TimelineState.prototype.getValueAtTime = function(time){\n\t\tvar event = this.get(time);\n\t\tif (event !== null){\n\t\t\treturn event.state;\n\t\t} else {\n\t\t\treturn this._initial;\n\t\t}\n\t};\n\n\t/**\n\t * Returns the scheduled state scheduled before or at\n\t * the given time.\n\t * @param {String} state The name of the state to set.\n\t * @param {Number} time The time to query.\n\t */\n\tTone.TimelineState.prototype.setStateAtTime = function(state, time){\n\t\tthis.add({\n\t\t\t\"state\" : state,\n\t\t\t\"time\" : time\n\t\t});\n\t};\n\n\treturn Tone.TimelineState;\n});","'use strict';\n\ndefine(function(require) {\n var p5sound = require('master');\n\n var BPM = 120;\n\n /**\n * Set the global tempo, in beats per minute, for all\n * p5.Parts. This method will impact all active p5.Parts.\n *\n * @method setBPM\n * @for p5\n * @param {Number} BPM Beats Per Minute\n * @param {Number} rampTime Seconds from now\n */\n p5.prototype.setBPM = function(bpm, rampTime) {\n BPM = bpm;\n for (var i in p5sound.parts) {\n if (p5sound.parts[i]) {\n p5sound.parts[i].setBPM(bpm, rampTime);\n }\n }\n };\n\n /**\n *

A phrase is a pattern of musical events over time, i.e.\n * a series of notes and rests.

\n *\n *

Phrases must be added to a p5.Part for playback, and\n * each part can play multiple phrases at the same time.\n * For example, one Phrase might be a kick drum, another\n * could be a snare, and another could be the bassline.

\n *\n *

The first parameter is a name so that the phrase can be\n * modified or deleted later. The callback is a a function that\n * this phrase will call at every step—for example it might be\n * called playNote(value){}. The array determines\n * which value is passed into the callback at each step of the\n * phrase. It can be numbers, an object with multiple numbers,\n * or a zero (0) indicates a rest so the callback won't be called).

\n *\n * @class p5.Phrase\n * @constructor\n * @param {String} name Name so that you can access the Phrase.\n * @param {Function} callback The name of a function that this phrase\n * will call. Typically it will play a sound,\n * and accept two parameters: a time at which\n * to play the sound (in seconds from now),\n * and a value from the sequence array. The\n * time should be passed into the play() or\n * start() method to ensure precision.\n * @param {Array} sequence Array of values to pass into the callback\n * at each step of the phrase.\n * @example\n *
\n * let mySound, myPhrase, myPart;\n * let pattern = [1,0,0,2,0,2,0,0];\n *\n * function preload() {\n * mySound = loadSound('assets/beatbox.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playMyPart);\n * background(220);\n * text('tap to play', width/2, height/2);\n * textAlign(CENTER, CENTER);\n *\n * myPhrase = new p5.Phrase('bbox', onEachStep, pattern);\n * myPart = new p5.Part();\n * myPart.addPhrase(myPhrase);\n * myPart.setBPM(60);\n * }\n *\n * function onEachStep(time, playbackRate) {\n * mySound.rate(playbackRate);\n * mySound.play(time);\n * }\n *\n * function playMyPart() {\n * userStartAudio();\n * myPart.start();\n * }\n *
\n */\n p5.Phrase = function(name, callback, sequence) {\n this.phraseStep = 0;\n this.name = name;\n this.callback = callback;\n /**\n * Array of values to pass into the callback\n * at each step of the phrase. Depending on the callback\n * function's requirements, these values may be numbers,\n * strings, or an object with multiple parameters.\n * Zero (0) indicates a rest.\n *\n * @property {Array} sequence\n */\n this.sequence = sequence;\n };\n\n /**\n *

A p5.Part plays back one or more p5.Phrases. Instantiate a part\n * with steps and tatums. By default, each step represents a 1/16th note.

\n *\n *

See p5.Phrase for more about musical timing.

\n *\n * @class p5.Part\n * @constructor\n * @param {Number} [steps] Steps in the part\n * @param {Number} [tatums] Divisions of a beat, e.g. use 1/4, or 0.25 for a quater note (default is 1/16, a sixteenth note)\n * @example\n *
\n * let box, drum, myPart;\n * let boxPat = [1,0,0,2,0,2,0,0];\n * let drumPat = [0,1,1,0,2,0,1,0];\n *\n * function preload() {\n * box = loadSound('assets/beatbox.mp3');\n * drum = loadSound('assets/drum.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playMyPart);\n * background(220);\n * textAlign(CENTER, CENTER);\n * text('tap to play', width/2, height/2);\n *\n * let boxPhrase = new p5.Phrase('box', playBox, boxPat);\n * let drumPhrase = new p5.Phrase('drum', playDrum, drumPat);\n * myPart = new p5.Part();\n * myPart.addPhrase(boxPhrase);\n * myPart.addPhrase(drumPhrase);\n * myPart.setBPM(60);\n * }\n *\n * function playBox(time, playbackRate) {\n * box.rate(playbackRate);\n * box.play(time);\n * }\n *\n * function playDrum(time, playbackRate) {\n * drum.rate(playbackRate);\n * drum.play(time);\n * }\n *\n * function playMyPart() {\n * userStartAudio();\n *\n * myPart.start();\n * }\n *
\n */\n p5.Part = function(steps, bLength) {\n this.length = steps || 0; // how many beats\n this.partStep = 0;\n this.phrases = [];\n this.isPlaying = false;\n this.noLoop();\n this.tatums = bLength || 0.0625; // defaults to quarter note\n\n this.metro = new p5.Metro();\n this.metro._init();\n this.metro.beatLength(this.tatums);\n this.metro.setBPM(BPM);\n p5sound.parts.push(this);\n this.callback = function() {};\n };\n\n /**\n * Set the tempo of this part, in Beats Per Minute.\n *\n * @method setBPM\n * @for p5.Part\n * @param {Number} BPM Beats Per Minute\n * @param {Number} [rampTime] Seconds from now\n */\n p5.Part.prototype.setBPM = function(tempo, rampTime) {\n this.metro.setBPM(tempo, rampTime);\n };\n\n /**\n * Returns the tempo, in Beats Per Minute, of this part.\n *\n * @method getBPM\n * @for p5.Part\n * @return {Number}\n */\n p5.Part.prototype.getBPM = function() {\n return this.metro.getBPM();\n };\n\n /**\n * Start playback of this part. It will play\n * through all of its phrases at a speed\n * determined by setBPM.\n *\n * @method start\n * @for p5.Part\n * @param {Number} [time] seconds from now\n */\n p5.Part.prototype.start = function(time) {\n if (!this.isPlaying) {\n this.isPlaying = true;\n this.metro.resetSync(this);\n var t = time || 0;\n this.metro.start(t);\n }\n };\n\n /**\n * Loop playback of this part. It will begin\n * looping through all of its phrases at a speed\n * determined by setBPM.\n *\n * @method loop\n * @for p5.Part\n * @param {Number} [time] seconds from now\n */\n p5.Part.prototype.loop = function(time) {\n this.looping = true;\n // rest onended function\n this.onended = function() {\n this.partStep = 0;\n };\n var t = time || 0;\n this.start(t);\n };\n\n /**\n * Tell the part to stop looping.\n *\n * @method noLoop\n * @for p5.Part\n */\n p5.Part.prototype.noLoop = function() {\n this.looping = false;\n // rest onended function\n this.onended = function() {\n this.stop();\n };\n };\n\n /**\n * Stop the part and cue it to step 0. Playback will resume from the begining of the Part when it is played again.\n *\n * @method stop\n * @for p5.Part\n * @param {Number} [time] seconds from now\n */\n p5.Part.prototype.stop = function(time) {\n this.partStep = 0;\n this.pause(time);\n };\n\n /**\n * Pause the part. Playback will resume\n * from the current step.\n *\n * @method pause\n * @for p5.Part\n * @param {Number} time seconds from now\n */\n p5.Part.prototype.pause = function(time) {\n this.isPlaying = false;\n var t = time || 0;\n this.metro.stop(t);\n };\n\n /**\n * Add a p5.Phrase to this Part.\n *\n * @method addPhrase\n * @for p5.Part\n * @param {p5.Phrase} phrase reference to a p5.Phrase\n */\n p5.Part.prototype.addPhrase = function(name, callback, array) {\n var p;\n if (arguments.length === 3) {\n p = new p5.Phrase(name, callback, array);\n } else if (arguments[0] instanceof p5.Phrase) {\n p = arguments[0];\n } else {\n throw 'invalid input. addPhrase accepts name, callback, array or a p5.Phrase';\n }\n this.phrases.push(p);\n // reset the length if phrase is longer than part's existing length\n if (p.sequence.length > this.length) {\n this.length = p.sequence.length;\n }\n };\n\n /**\n * Remove a phrase from this part, based on the name it was\n * given when it was created.\n *\n * @method removePhrase\n * @for p5.Part\n * @param {String} phraseName\n */\n p5.Part.prototype.removePhrase = function(name) {\n for (var i in this.phrases) {\n if (this.phrases[i].name === name) {\n this.phrases.splice(i, 1);\n }\n }\n };\n\n /**\n * Get a phrase from this part, based on the name it was\n * given when it was created. Now you can modify its array.\n *\n * @method getPhrase\n * @for p5.Part\n * @param {String} phraseName\n */\n p5.Part.prototype.getPhrase = function(name) {\n for (var i in this.phrases) {\n if (this.phrases[i].name === name) {\n return this.phrases[i];\n }\n }\n };\n\n /**\n * Find all sequences with the specified name, and replace their patterns with the specified array.\n *\n * @method replaceSequence\n * @for p5.Part\n * @param {String} phraseName\n * @param {Array} sequence Array of values to pass into the callback\n * at each step of the phrase.\n */\n p5.Part.prototype.replaceSequence = function(name, array) {\n for (var i in this.phrases) {\n if (this.phrases[i].name === name) {\n this.phrases[i].sequence = array;\n }\n }\n };\n\n p5.Part.prototype.incrementStep = function(time) {\n if (this.partStep < this.length - 1) {\n this.callback(time);\n this.partStep += 1;\n } else {\n if (!this.looping && this.partStep === this.length - 1) {\n // this.callback(time);\n this.onended();\n }\n }\n };\n\n /**\n * Set the function that will be called at every step. This will clear the previous function.\n *\n * @method onStep\n * @for p5.Part\n * @param {Function} callback The name of the callback\n * you want to fire\n * on every beat/tatum.\n */\n p5.Part.prototype.onStep = function(callback) {\n this.callback = callback;\n };\n\n\n // ===============\n // p5.Score\n // ===============\n\n /**\n * A Score consists of a series of Parts. The parts will\n * be played back in order. For example, you could have an\n * A part, a B part, and a C part, and play them back in this order\n * new p5.Score(a, a, b, a, c)\n *\n * @class p5.Score\n * @constructor\n * @param {p5.Part} [...parts] One or multiple parts, to be played in sequence.\n */\n p5.Score = function() {\n // for all of the arguments\n this.parts = [];\n this.currentPart = 0;\n\n var thisScore = this;\n for (var i in arguments) {\n if (arguments[i] && this.parts[i]) {\n this.parts[i] = arguments[i];\n this.parts[i].nextPart = this.parts[i + 1];\n this.parts[i].onended = function() {\n thisScore.resetPart(i);\n playNextPart(thisScore);\n };\n }\n }\n this.looping = false;\n };\n\n p5.Score.prototype.onended = function() {\n if (this.looping) {\n // this.resetParts();\n this.parts[0].start();\n } else {\n this.parts[this.parts.length - 1].onended = function() {\n this.stop();\n this.resetParts();\n };\n }\n this.currentPart = 0;\n };\n\n /**\n * Start playback of the score.\n *\n * @method start\n * @for p5.Score\n */\n p5.Score.prototype.start = function() {\n this.parts[this.currentPart].start();\n this.scoreStep = 0;\n };\n\n /**\n * Stop playback of the score.\n *\n * @method stop\n * @for p5.Score\n */\n p5.Score.prototype.stop = function() {\n this.parts[this.currentPart].stop();\n this.currentPart = 0;\n this.scoreStep = 0;\n };\n\n /**\n * Pause playback of the score.\n *\n * @method pause\n * @for p5.Score\n */\n p5.Score.prototype.pause = function() {\n this.parts[this.currentPart].stop();\n };\n\n /**\n * Loop playback of the score.\n *\n * @method loop\n * @for p5.Score\n */\n p5.Score.prototype.loop = function() {\n this.looping = true;\n this.start();\n };\n\n /**\n * Stop looping playback of the score. If it\n * is currently playing, this will go into effect\n * after the current round of playback completes.\n *\n * @method noLoop\n * @for p5.Score\n */\n p5.Score.prototype.noLoop = function() {\n this.looping = false;\n };\n\n p5.Score.prototype.resetParts = function() {\n var self = this;\n this.parts.forEach(function(part) {\n self.resetParts[part];\n });\n };\n\n p5.Score.prototype.resetPart = function(i) {\n this.parts[i].stop();\n this.parts[i].partStep = 0;\n for (var p in this.parts[i].phrases) {\n if (this.parts[i]) {\n this.parts[i].phrases[p].phraseStep = 0;\n }\n }\n };\n\n /**\n * Set the tempo for all parts in the score\n *\n * @method setBPM\n * @for p5.Score\n * @param {Number} BPM Beats Per Minute\n * @param {Number} rampTime Seconds from now\n */\n p5.Score.prototype.setBPM = function(bpm, rampTime) {\n for (var i in this.parts) {\n if (this.parts[i]) {\n this.parts[i].setBPM(bpm, rampTime);\n }\n }\n };\n\n function playNextPart(aScore) {\n aScore.currentPart++;\n if (aScore.currentPart >= aScore.parts.length) {\n aScore.scoreStep = 0;\n aScore.onended();\n } else {\n aScore.scoreStep = 0;\n aScore.parts[aScore.currentPart - 1].stop();\n aScore.parts[aScore.currentPart].start();\n }\n }\n\n});\n","'use strict';\n\ndefine(function (require) {\n var p5sound = require('master');\n var Clock = require('Tone/core/Clock');\n\n /**\n * SoundLoop\n *\n * @class p5.SoundLoop\n * @constructor\n *\n * @param {Function} callback this function will be called on each iteration of theloop\n * @param {Number|String} [interval] amount of time (if a number) or beats (if a string, following Tone.Time convention) for each iteration of the loop. Defaults to 1 second.\n *\n * @example\n *
\n * let synth, soundLoop;\n * let notePattern = [60, 62, 64, 67, 69, 72];\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * colorMode(HSB);\n * background(0, 0, 86);\n * text('tap to start/stop', 10, 20);\n *\n * //the looper's callback is passed the timeFromNow\n * //this value should be used as a reference point from\n * //which to schedule sounds\n * let intervalInSeconds = 0.2;\n * soundLoop = new p5.SoundLoop(onSoundLoop, intervalInSeconds);\n *\n * synth = new p5.MonoSynth();\n * }\n *\n * function canvasPressed() {\n * // ensure audio is enabled\n * userStartAudio();\n *\n * if (soundLoop.isPlaying) {\n * soundLoop.stop();\n * } else {\n * // start the loop\n * soundLoop.start();\n * }\n * }\n *\n * function onSoundLoop(timeFromNow) {\n * let noteIndex = (soundLoop.iterations - 1) % notePattern.length;\n * let note = midiToFreq(notePattern[noteIndex]);\n * synth.play(note, 0.5, timeFromNow);\n * background(noteIndex * 360 / notePattern.length, 50, 100);\n * }\n *
\n */\n p5.SoundLoop = function(callback, interval) {\n this.callback = callback;\n /**\n * musicalTimeMode uses Tone.Time convention\n * true if string, false if number\n * @property {Boolean} musicalTimeMode\n */\n this.musicalTimeMode = typeof this._interval === 'number' ? false : true;\n\n this._interval = interval || 1;\n\n /**\n * musicalTimeMode variables\n * modify these only when the interval is specified in musicalTime format as a string\n */\n this._timeSignature = 4;\n this._bpm = 60;\n\n this.isPlaying = false;\n\n /**\n * Set a limit to the number of loops to play. defaults to Infinity\n * @property {Number} maxIterations\n */\n this.maxIterations = Infinity;\n var self = this;\n\n this.clock = new Clock({\n 'callback' : function(time) {\n var timeFromNow = time - p5sound.audiocontext.currentTime;\n /**\n * Do not initiate the callback if timeFromNow is < 0\n * This ususually occurs for a few milliseconds when the page\n * is not fully loaded\n *\n * The callback should only be called until maxIterations is reached\n */\n if (timeFromNow > 0 && self.iterations <= self.maxIterations) {\n self.callback(timeFromNow);}\n },\n 'frequency' : this._calcFreq()\n });\n };\n\n /**\n * Start the loop\n * @method start\n * @for p5.SoundLoop\n * @param {Number} [timeFromNow] schedule a starting time\n */\n p5.SoundLoop.prototype.start = function(timeFromNow) {\n var t = timeFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n if (!this.isPlaying) {\n this.clock.start(now + t);\n this.isPlaying = true;\n }\n };\n\n /**\n * Stop the loop\n * @method stop\n * @for p5.SoundLoop\n * @param {Number} [timeFromNow] schedule a stopping time\n */\n p5.SoundLoop.prototype.stop = function(timeFromNow) {\n var t = timeFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n if (this.isPlaying) {\n this.clock.stop(now + t);\n this.isPlaying = false;\n }\n };\n /**\n * Pause the loop\n * @method pause\n * @for p5.SoundLoop\n * @param {Number} [timeFromNow] schedule a pausing time\n */\n p5.SoundLoop.prototype.pause = function(timeFromNow) {\n var t = timeFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n if (this.isPlaying) {\n this.clock.pause(now + t);\n this.isPlaying = false;\n }\n };\n\n\n /**\n * Synchronize loops. Use this method to start two more more loops in synchronization\n * or to start a loop in synchronization with a loop that is already playing\n * This method will schedule the implicit loop in sync with the explicit master loop\n * i.e. loopToStart.syncedStart(loopToSyncWith)\n *\n * @method syncedStart\n * @for p5.SoundLoop\n * @param {Object} otherLoop a p5.SoundLoop to sync with\n * @param {Number} [timeFromNow] Start the loops in sync after timeFromNow seconds\n */\n p5.SoundLoop.prototype.syncedStart = function(otherLoop, timeFromNow) {\n var t = timeFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n\n if (!otherLoop.isPlaying) {\n otherLoop.clock.start(now + t);\n otherLoop.isPlaying = true;\n this.clock.start(now + t);\n this.isPlaying = true;\n } else if (otherLoop.isPlaying) {\n var time = otherLoop.clock._nextTick - p5sound.audiocontext.currentTime;\n this.clock.start(now + time);\n this.isPlaying = true;\n }\n };\n\n\n /**\n * Updates frequency value, reflected in next callback\n * @private\n * @for p5.SoundLoop\n * @method _update\n */\n p5.SoundLoop.prototype._update = function() {\n this.clock.frequency.value = this._calcFreq();\n };\n\n /**\n * Calculate the frequency of the clock's callback based on bpm, interval, and timesignature\n * @private\n * @for p5.SoundLoop\n * @method _calcFreq\n * @return {Number} new clock frequency value\n */\n p5.SoundLoop.prototype._calcFreq = function() {\n //Seconds mode, bpm / timesignature has no effect\n if (typeof this._interval === 'number') {\n this.musicalTimeMode = false;\n return 1 / this._interval;\n }\n //Musical timing mode, calculate interval based bpm, interval,and time signature\n else if (typeof this._interval === 'string') {\n this.musicalTimeMode = true;\n return this._bpm / 60 / this._convertNotation(this._interval) * (this._timeSignature / 4);\n }\n };\n\n /**\n * Convert notation from musical time format to seconds\n * Uses Tone.Time convention\n * @private\n * @for p5.SoundLoop\n * @method _convertNotation\n * @param {String} value value to be converted\n * @return {Number} converted value in seconds\n */\n p5.SoundLoop.prototype._convertNotation = function(value) {\n var type = value.slice(-1);\n value = Number(value.slice(0,-1));\n switch (type) {\n case 'm':\n return this._measure(value);\n case 'n':\n return this._note(value);\n default:\n console.warn('Specified interval is not formatted correctly. See Tone.js '+\n 'timing reference for more info: https://github.com/Tonejs/Tone.js/wiki/Time');\n }\n };\n\n /**\n * Helper conversion methods of measure and note\n * @private\n * @for p5.SoundLoop\n * @method _measure\n */\n p5.SoundLoop.prototype._measure = function(value) {\n return value * this._timeSignature;\n };\n\n /**\n * @private\n * @method _note\n * @for p5.SoundLoop\n */\n p5.SoundLoop.prototype._note = function(value) {\n return this._timeSignature / value ;\n };\n\n\n /**\n * Getters and Setters, setting any paramter will result in a change in the clock's\n * frequency, that will be reflected after the next callback\n * beats per minute (defaults to 60)\n * @property {Number} bpm\n * @for p5.SoundLoop\n */\n Object.defineProperty(p5.SoundLoop.prototype, 'bpm', {\n get : function() {\n return this._bpm;\n },\n set : function(bpm) {\n if (!this.musicalTimeMode) {\n console.warn('Changing the BPM in \"seconds\" mode has no effect. '+\n 'BPM is only relevant in musicalTimeMode '+\n 'when the interval is specified as a string '+\n '(\"2n\", \"4n\", \"1m\"...etc)');\n }\n this._bpm = bpm;\n this._update();\n }\n });\n\n /**\n * number of quarter notes in a measure (defaults to 4)\n * @property {Number} timeSignature\n * @for p5.SoundLoop\n */\n Object.defineProperty(p5.SoundLoop.prototype, 'timeSignature', {\n get : function() {\n return this._timeSignature;\n },\n set : function(timeSig) {\n if (!this.musicalTimeMode) {\n console.warn('Changing the timeSignature in \"seconds\" mode has no effect. '+\n 'BPM is only relevant in musicalTimeMode '+\n 'when the interval is specified as a string '+\n '(\"2n\", \"4n\", \"1m\"...etc)');\n }\n this._timeSignature = timeSig;\n this._update();\n }\n });\n\n /**\n * length of the loops interval\n * @property {Number|String} interval\n * @for p5.SoundLoop\n */\n Object.defineProperty(p5.SoundLoop.prototype, 'interval', {\n get : function() {\n return this._interval;\n },\n set : function(interval) {\n this.musicalTimeMode = typeof interval === 'Number'? false : true;\n this._interval = interval;\n this._update();\n }\n });\n\n /**\n * how many times the callback has been called so far\n * @property {Number} iterations\n * @for p5.SoundLoop\n * @readonly\n */\n Object.defineProperty(p5.SoundLoop.prototype, 'iterations', {\n get : function() {\n return this.clock.ticks;\n }\n });\n\n return p5.SoundLoop;\n});\n","define(function (require) {\n\t'use strict';\n\n\tvar p5sound = require('master');\n\tvar Effect = require('effect');\n var CustomError = require('errorHandler');\n\n /**\n * Compressor is an audio effect class that performs dynamics compression\n * on an audio input source. This is a very commonly used technique in music\n * and sound production. Compression creates an overall louder, richer,\n * and fuller sound by lowering the volume of louds and raising that of softs.\n * Compression can be used to avoid clipping (sound distortion due to\n * peaks in volume) and is especially useful when many sounds are played\n * at once. Compression can be used on indivudal sound sources in addition\n * to the master output.\n *\n * This class extends p5.Effect.\n * Methods amp(), chain(),\n * drywet(), connect(), and\n * disconnect() are available.\n *\n * @class p5.Compressor\n * @constructor\n * @extends p5.Effect\n *\n *\n */\n\tp5.Compressor = function() {\n\t\tEffect.call(this);\n\n /**\n * The p5.Compressor is built with a Web Audio Dynamics Compressor Node\n * \n * @property {AudioNode} compressor\n */\n\n\n\t\tthis.compressor = this.ac.createDynamicsCompressor();\n\n this.input.connect(this.compressor);\n this.compressor.connect(this.wet);\n\t};\n\n\tp5.Compressor.prototype = Object.create(Effect.prototype);\n\n /**\n * Performs the same function as .connect, but also accepts\n * optional parameters to set compressor's audioParams\n * @method process\n * @for p5.Compressor\n *\n * @param {Object} src Sound source to be connected\n *\n * @param {Number} [attack] The amount of time (in seconds) to reduce the gain by 10dB,\n * default = .003, range 0 - 1\n * @param {Number} [knee] A decibel value representing the range above the\n * threshold where the curve smoothly transitions to the \"ratio\" portion.\n * default = 30, range 0 - 40\n * @param {Number} [ratio] The amount of dB change in input for a 1 dB change in output\n * default = 12, range 1 - 20\n * @param {Number} [threshold] The decibel value above which the compression will start taking effect\n * default = -24, range -100 - 0\n * @param {Number} [release] The amount of time (in seconds) to increase the gain by 10dB\n * default = .25, range 0 - 1\n */\n\tp5.Compressor.prototype.process = function(src, attack, knee,\n ratio, threshold, release) {\n\t\tsrc.connect(this.input);\n\t\tthis.set(attack, knee, ratio, threshold, release);\n\t};\n\n /**\n * Set the paramters of a compressor.\n * @method set\n * @for p5.Compressor\n * @param {Number} attack The amount of time (in seconds) to reduce the gain by 10dB,\n * default = .003, range 0 - 1\n * @param {Number} knee A decibel value representing the range above the\n * threshold where the curve smoothly transitions to the \"ratio\" portion.\n * default = 30, range 0 - 40\n * @param {Number} ratio The amount of dB change in input for a 1 dB change in output\n * default = 12, range 1 - 20\n * @param {Number} threshold The decibel value above which the compression will start taking effect\n * default = -24, range -100 - 0\n * @param {Number} release The amount of time (in seconds) to increase the gain by 10dB\n * default = .25, range 0 - 1\n */\n p5.Compressor.prototype.set = function (attack, knee,\n ratio, threshold, release) {\n\n if (typeof attack !== 'undefined') {this.attack(attack);}\n if (typeof knee !== 'undefined') {this.knee(knee);}\n if (typeof ratio !== 'undefined') {this.ratio(ratio);}\n if (typeof threshold !== 'undefined') {this.threshold(threshold);}\n if (typeof release !== 'undefined') {this.release(release);}\n };\n\n\n /**\n * Get current attack or set value w/ time ramp\n *\n *\n * @method attack\n * @for p5.Compressor\n * @param {Number} [attack] Attack is the amount of time (in seconds) to reduce the gain by 10dB,\n * default = .003, range 0 - 1\n * @param {Number} [time] Assign time value to schedule the change in value\n */\n p5.Compressor.prototype.attack = function (attack, time){\n var t = time || 0;\n if (typeof attack == 'number'){\n this.compressor.attack.value = attack;\n this.compressor.attack.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.compressor.attack.linearRampToValueAtTime(attack, this.ac.currentTime + 0.02 + t);\n } else if (typeof attack !== 'undefined') {\n attack.connect(this.compressor.attack);\n }\n return this.compressor.attack.value;\n };\n\n\n /**\n * Get current knee or set value w/ time ramp\n *\n * @method knee\n * @for p5.Compressor\n * @param {Number} [knee] A decibel value representing the range above the\n * threshold where the curve smoothly transitions to the \"ratio\" portion.\n * default = 30, range 0 - 40\n * @param {Number} [time] Assign time value to schedule the change in value\n */\n p5.Compressor.prototype.knee = function (knee, time){\n var t = time || 0;\n if (typeof knee == 'number'){\n this.compressor.knee.value = knee;\n this.compressor.knee.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.compressor.knee.linearRampToValueAtTime(knee, this.ac.currentTime + 0.02 + t);\n } else if (typeof knee !== 'undefined') {\n knee.connect(this.compressor.knee);\n }\n return this.compressor.knee.value;\n };\n\n\n /**\n * Get current ratio or set value w/ time ramp\n * @method ratio\n * @for p5.Compressor\n * @param {Number} [ratio] The amount of dB change in input for a 1 dB change in output\n * default = 12, range 1 - 20\n * @param {Number} [time] Assign time value to schedule the change in value\n */\n p5.Compressor.prototype.ratio = function (ratio, time){\n var t = time || 0;\n if (typeof ratio == 'number'){\n this.compressor.ratio.value = ratio;\n this.compressor.ratio.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.compressor.ratio.linearRampToValueAtTime(ratio, this.ac.currentTime + 0.02 + t);\n } else if (typeof ratio !== 'undefined') {\n ratio.connect(this.compressor.ratio);\n }\n return this.compressor.ratio.value;\n };\n\n\n /**\n * Get current threshold or set value w/ time ramp\n * @method threshold\n * @for p5.Compressor\n * @param {Number} threshold The decibel value above which the compression will start taking effect\n * default = -24, range -100 - 0\n * @param {Number} [time] Assign time value to schedule the change in value\n */\n p5.Compressor.prototype.threshold = function (threshold, time){\n var t = time || 0;\n if (typeof threshold == 'number'){\n this.compressor.threshold.value = threshold;\n this.compressor.threshold.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.compressor.threshold.linearRampToValueAtTime(threshold, this.ac.currentTime + 0.02 + t);\n } else if (typeof threshold !== 'undefined') {\n threshold.connect(this.compressor.threshold);\n }\n return this.compressor.threshold.value;\n };\n\n\n /**\n * Get current release or set value w/ time ramp\n * @method release\n * @for p5.Compressor\n * @param {Number} release The amount of time (in seconds) to increase the gain by 10dB\n * default = .25, range 0 - 1\n *\n * @param {Number} [time] Assign time value to schedule the change in value\n */\n p5.Compressor.prototype.release = function (release, time){\n var t = time || 0;\n if (typeof release == 'number'){\n this.compressor.release.value = release;\n this.compressor.release.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.compressor.release.linearRampToValueAtTime(release, this.ac.currentTime + 0.02 + t);\n } else if (typeof number !== 'undefined') {\n release.connect(this.compressor.release);\n }\n return this.compressor.release.value;\n };\n\n /**\n * Return the current reduction value\n *\n * @method reduction\n * @for p5.Compressor\n * @return {Number} Value of the amount of gain reduction that is applied to the signal\n */\n p5.Compressor.prototype.reduction =function() {\n return this.compressor.reduction.value;\n };\n\n\n\tp5.Compressor.prototype.dispose = function() {\n Effect.prototype.dispose.apply(this);\n if (this.compressor) {\n this.compressor.disconnect();\n delete this.compressor;\n }\n\t};\n\n return p5.Compressor;\n});\n","'use strict';\n\ndefine(function (require) {\n\n // inspiration: recorder.js, Tone.js & typedarray.org\n\n const p5sound = require('master');\n const { convertToWav, safeBufferSize } = require('helpers');\n const processorNames = require('./audioWorklet/processorNames');\n const ac = p5sound.audiocontext;\n\n /**\n *

Record sounds for playback and/or to save as a .wav file.\n * The p5.SoundRecorder records all sound output from your sketch,\n * or can be assigned a specific source with setInput().

\n *

The record() method accepts a p5.SoundFile as a parameter.\n * When playback is stopped (either after the given amount of time,\n * or with the stop() method), the p5.SoundRecorder will send its\n * recording to that p5.SoundFile for playback.

\n *\n * @class p5.SoundRecorder\n * @constructor\n * @example\n *
\n * let mic, recorder, soundFile;\n * let state = 0;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * textAlign(CENTER, CENTER);\n *\n * // create an audio in\n * mic = new p5.AudioIn();\n *\n * // prompts user to enable their browser mic\n * mic.start();\n *\n * // create a sound recorder\n * recorder = new p5.SoundRecorder();\n *\n * // connect the mic to the recorder\n * recorder.setInput(mic);\n *\n * // this sound file will be used to\n * // playback & save the recording\n * soundFile = new p5.SoundFile();\n *\n * text('tap to record', width/2, height/2);\n * }\n *\n * function canvasPressed() {\n * // ensure audio is enabled\n * userStartAudio();\n *\n * // make sure user enabled the mic\n * if (state === 0 && mic.enabled) {\n *\n * // record to our p5.SoundFile\n * recorder.record(soundFile);\n *\n * background(255,0,0);\n * text('Recording!', width/2, height/2);\n * state++;\n * }\n * else if (state === 1) {\n * background(0,255,0);\n *\n * // stop recorder and\n * // send result to soundFile\n * recorder.stop();\n *\n * text('Done! Tap to play and download', width/2, height/2, width - 20);\n * state++;\n * }\n *\n * else if (state === 2) {\n * soundFile.play(); // play the result!\n * save(soundFile, 'mySound.wav');\n * state++;\n * }\n * }\n *
\n */\n p5.SoundRecorder = function() {\n this.input = ac.createGain();\n this.output = ac.createGain();\n\n this._inputChannels = 2;\n this._outputChannels = 2; // stereo output, even if input is mono\n\n const workletBufferSize = safeBufferSize(1024);\n\n this._workletNode = new AudioWorkletNode(ac, processorNames.recorderProcessor, {\n outputChannelCount: [this._outputChannels],\n processorOptions: {\n numInputChannels: this._inputChannels,\n bufferSize: workletBufferSize\n }\n });\n\n this._workletNode.port.onmessage = function(event) {\n if (event.data.name === 'buffers') {\n const buffers = [\n new Float32Array(event.data.leftBuffer),\n new Float32Array(event.data.rightBuffer)\n ];\n this._callback(buffers);\n }\n }.bind(this);\n\n /**\n * callback invoked when the recording is over\n * @private\n * @type Function(Float32Array)\n */\n this._callback = function() {};\n\n // connections\n this._workletNode.connect(p5.soundOut._silentNode);\n this.setInput();\n\n // add this p5.SoundFile to the soundArray\n p5sound.soundArray.push(this);\n };\n\n /**\n * Connect a specific device to the p5.SoundRecorder.\n * If no parameter is given, p5.SoundRecorer will record\n * all audible p5.sound from your sketch.\n *\n * @method setInput\n * @for p5.SoundRecorder\n * @param {Object} [unit] p5.sound object or a web audio unit\n * that outputs sound\n */\n p5.SoundRecorder.prototype.setInput = function(unit) {\n this.input.disconnect();\n this.input = null;\n this.input = ac.createGain();\n this.input.connect(this._workletNode);\n this.input.connect(this.output);\n if (unit) {\n unit.connect(this.input);\n } else {\n p5.soundOut.output.connect(this.input);\n }\n };\n\n /**\n * Start recording. To access the recording, provide\n * a p5.SoundFile as the first parameter. The p5.SoundRecorder\n * will send its recording to that p5.SoundFile for playback once\n * recording is complete. Optional parameters include duration\n * (in seconds) of the recording, and a callback function that\n * will be called once the complete recording has been\n * transfered to the p5.SoundFile.\n *\n * @method record\n * @for p5.SoundRecorder\n * @param {p5.SoundFile} soundFile p5.SoundFile\n * @param {Number} [duration] Time (in seconds)\n * @param {Function} [callback] The name of a function that will be\n * called once the recording completes\n */\n p5.SoundRecorder.prototype.record = function(sFile, duration, callback) {\n this._workletNode.port.postMessage({ name: 'start', duration: duration });\n\n if (sFile && callback) {\n this._callback = function(buffer) {\n sFile.setBuffer(buffer);\n callback();\n };\n }\n else if (sFile) {\n this._callback = function(buffer) {\n sFile.setBuffer(buffer);\n };\n }\n };\n\n /**\n * Stop the recording. Once the recording is stopped,\n * the results will be sent to the p5.SoundFile that\n * was given on .record(), and if a callback function\n * was provided on record, that function will be called.\n *\n * @method stop\n * @for p5.SoundRecorder\n */\n p5.SoundRecorder.prototype.stop = function() {\n this._workletNode.port.postMessage({ name: 'stop' });\n };\n\n p5.SoundRecorder.prototype.dispose = function() {\n // remove reference from soundArray\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n\n this._callback = function() {};\n if (this.input) {\n this.input.disconnect();\n }\n this.input = null;\n this._workletNode = null;\n };\n\n\n /**\n * Save a p5.SoundFile as a .wav file. The browser will prompt the user\n * to download the file to their device.\n * For uploading audio to a server, use\n * `p5.SoundFile.saveBlob`.\n *\n * @for p5\n * @method saveSound\n * @param {p5.SoundFile} soundFile p5.SoundFile that you wish to save\n * @param {String} fileName name of the resulting .wav file.\n */\n // add to p5.prototype as this is used by the p5 `save()` method.\n p5.prototype.saveSound = function (soundFile, fileName) {\n const dataView = convertToWav(soundFile.buffer);\n p5.prototype.writeFile([dataView], fileName, 'wav');\n };\n});\n","'use strict';\n\ndefine(function () {\n /**\n *

PeakDetect works in conjunction with p5.FFT to\n * look for onsets in some or all of the frequency spectrum.\n *

\n *

\n * To use p5.PeakDetect, call update in the draw loop\n * and pass in a p5.FFT object.\n *

\n *

\n * You can listen for a specific part of the frequency spectrum by\n * setting the range between freq1 and freq2.\n *

\n *\n *

threshold is the threshold for detecting a peak,\n * scaled between 0 and 1. It is logarithmic, so 0.1 is half as loud\n * as 1.0.

\n *\n *

\n * The update method is meant to be run in the draw loop, and\n * frames determines how many loops must pass before\n * another peak can be detected.\n * For example, if the frameRate() = 60, you could detect the beat of a\n * 120 beat-per-minute song with this equation:\n * framesPerPeak = 60 / (estimatedBPM / 60 );\n *

\n *\n *

\n * Based on example contribtued by @b2renger, and a simple beat detection\n * explanation by Felix Turner.\n *

\n *\n * @class p5.PeakDetect\n * @constructor\n * @param {Number} [freq1] lowFrequency - defaults to 20Hz\n * @param {Number} [freq2] highFrequency - defaults to 20000 Hz\n * @param {Number} [threshold] Threshold for detecting a beat between 0 and 1\n * scaled logarithmically where 0.1 is 1/2 the loudness\n * of 1.0. Defaults to 0.35.\n * @param {Number} [framesPerPeak] Defaults to 20.\n * @example\n *
\n *\n * var cnv, soundFile, fft, peakDetect;\n * var ellipseWidth = 10;\n *\n * function preload() {\n * soundFile = loadSound('assets/beat.mp3');\n * }\n *\n * function setup() {\n * background(0);\n * noStroke();\n * fill(255);\n * textAlign(CENTER);\n *\n * // p5.PeakDetect requires a p5.FFT\n * fft = new p5.FFT();\n * peakDetect = new p5.PeakDetect();\n * }\n *\n * function draw() {\n * background(0);\n * text('click to play/pause', width/2, height/2);\n *\n * // peakDetect accepts an fft post-analysis\n * fft.analyze();\n * peakDetect.update(fft);\n *\n * if ( peakDetect.isDetected ) {\n * ellipseWidth = 50;\n * } else {\n * ellipseWidth *= 0.95;\n * }\n *\n * ellipse(width/2, height/2, ellipseWidth, ellipseWidth);\n * }\n *\n * // toggle play/stop when canvas is clicked\n * function mouseClicked() {\n * if (mouseX > 0 && mouseX < width && mouseY > 0 && mouseY < height) {\n * if (soundFile.isPlaying() ) {\n * soundFile.stop();\n * } else {\n * soundFile.play();\n * }\n * }\n * }\n *
\n */\n p5.PeakDetect = function(freq1, freq2, threshold, _framesPerPeak) {\n // framesPerPeak determines how often to look for a beat.\n // If a beat is provided, try to look for a beat based on bpm\n this.framesPerPeak = _framesPerPeak || 20;\n this.framesSinceLastPeak = 0;\n this.decayRate = 0.95;\n\n this.threshold = threshold || 0.35;\n this.cutoff = 0;\n\n // how much to increase the cutoff\n // TO DO: document this / figure out how to make it accessible\n this.cutoffMult = 1.5;\n\n this.energy = 0;\n this.penergy = 0;\n\n // TO DO: document this property / figure out how to make it accessible\n this.currentValue = 0;\n\n /**\n * isDetected is set to true when a peak is detected.\n *\n * @attribute isDetected {Boolean}\n * @default false\n */\n this.isDetected = false;\n\n this.f1 = freq1 || 40;\n this.f2 = freq2 || 20000;\n\n // function to call when a peak is detected\n this._onPeak = function() {};\n };\n\n\n /**\n * The update method is run in the draw loop.\n *\n * Accepts an FFT object. You must call .analyze()\n * on the FFT object prior to updating the peakDetect\n * because it relies on a completed FFT analysis.\n *\n * @method update\n * @param {p5.FFT} fftObject A p5.FFT object\n */\n p5.PeakDetect.prototype.update = function(fftObject) {\n var nrg = this.energy = fftObject.getEnergy(this.f1,this.f2)/255;\n if (nrg > this.cutoff && nrg > this.threshold && nrg-this.penergy > 0) {\n\n // trigger callback\n this._onPeak();\n this.isDetected = true;\n\n // debounce\n this.cutoff = nrg * this.cutoffMult;\n this.framesSinceLastPeak = 0;\n } else {\n this.isDetected = false;\n if (this.framesSinceLastPeak <= this.framesPerPeak) {\n this.framesSinceLastPeak++;\n } else {\n this.cutoff *= this.decayRate;\n this.cutoff = Math.max(this.cutoff, this.threshold);\n }\n }\n\n this.currentValue = nrg;\n this.penergy = nrg;\n };\n\n /**\n * onPeak accepts two arguments: a function to call when\n * a peak is detected. The value of the peak,\n * between 0.0 and 1.0, is passed to the callback.\n *\n * @method onPeak\n * @param {Function} callback Name of a function that will\n * be called when a peak is\n * detected.\n * @param {Object} [val] Optional value to pass\n * into the function when\n * a peak is detected.\n * @example\n *
\n * var cnv, soundFile, fft, peakDetect;\n * var ellipseWidth = 0;\n *\n * function preload() {\n * soundFile = loadSound('assets/beat.mp3');\n * }\n *\n * function setup() {\n * cnv = createCanvas(100,100);\n * textAlign(CENTER);\n *\n * fft = new p5.FFT();\n * peakDetect = new p5.PeakDetect();\n *\n * setupSound();\n *\n * // when a beat is detected, call triggerBeat()\n * peakDetect.onPeak(triggerBeat);\n * }\n *\n * function draw() {\n * background(0);\n * fill(255);\n * text('click to play', width/2, height/2);\n *\n * fft.analyze();\n * peakDetect.update(fft);\n *\n * ellipseWidth *= 0.95;\n * ellipse(width/2, height/2, ellipseWidth, ellipseWidth);\n * }\n *\n * // this function is called by peakDetect.onPeak\n * function triggerBeat() {\n * ellipseWidth = 50;\n * }\n *\n * // mouseclick starts/stops sound\n * function setupSound() {\n * cnv.mouseClicked( function() {\n * if (soundFile.isPlaying() ) {\n * soundFile.stop();\n * } else {\n * soundFile.play();\n * }\n * });\n * }\n *
\n */\n p5.PeakDetect.prototype.onPeak = function(callback, val) {\n var self = this;\n\n self._onPeak = function() {\n callback(self.energy, val);\n };\n };\n\n});\n","'use strict';\n\ndefine(function (require) {\n var p5sound = require('master');\n\n /**\n * A gain node is usefull to set the relative volume of sound.\n * It's typically used to build mixers.\n *\n * @class p5.Gain\n * @constructor\n * @example\n *
\n *\n * // load two soundfile and crossfade beetween them\n * let sound1,sound2;\n * let sound1Gain, sound2Gain, masterGain;\n * function preload(){\n * soundFormats('ogg', 'mp3');\n * sound1 = loadSound('assets/Damscray_-_Dancing_Tiger_01');\n * sound2 = loadSound('assets/beat');\n * }\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(startSound);\n * // create a 'master' gain to which we will connect both soundfiles\n * masterGain = new p5.Gain();\n * masterGain.connect();\n * sound1.disconnect(); // diconnect from p5 output\n * sound1Gain = new p5.Gain(); // setup a gain node\n * sound1Gain.setInput(sound1); // connect the first sound to its input\n * sound1Gain.connect(masterGain); // connect its output to the 'master'\n * sound2.disconnect();\n * sound2Gain = new p5.Gain();\n * sound2Gain.setInput(sound2);\n * sound2Gain.connect(masterGain);\n * }\n * function startSound() {\n * sound1.loop();\n * sound2.loop();\n * loop();\n * }\n * function mouseReleased() {\n * sound1.stop();\n * sound2.stop();\n * }\n * function draw(){\n * background(220);\n * textAlign(CENTER);\n * textSize(11);\n * fill(0);\n * if (!sound1.isPlaying()) {\n * text('tap and drag to play', width/2, height/2);\n * return;\n * }\n * // map the horizontal position of the mouse to values useable for volume * control of sound1\n * var sound1Volume = constrain(map(mouseX,width,0,0,1), 0, 1);\n * var sound2Volume = 1-sound1Volume;\n * sound1Gain.amp(sound1Volume);\n * sound2Gain.amp(sound2Volume);\n * // map the vertical position of the mouse to values useable for 'master * volume control'\n * var masterVolume = constrain(map(mouseY,height,0,0,1), 0, 1);\n * masterGain.amp(masterVolume);\n * text('master', width/2, height - masterVolume * height * 0.9)\n * fill(255, 0, 255);\n * textAlign(LEFT);\n * text('sound1', 5, height - sound1Volume * height * 0.9);\n * textAlign(RIGHT);\n * text('sound2', width - 5, height - sound2Volume * height * 0.9);\n * }\n *
\n */\n\n p5.Gain = function() {\n this.ac = p5sound.audiocontext;\n\n this.input = this.ac.createGain();\n this.output = this.ac.createGain();\n\n // otherwise, Safari distorts\n this.input.gain.value = 0.5;\n this.input.connect(this.output);\n\n // add to the soundArray\n p5sound.soundArray.push(this);\n };\n\n /**\n * Connect a source to the gain node.\n *\n * @method setInput\n * @for p5.Gain\n * @param {Object} src p5.sound / Web Audio object with a sound\n * output.\n */\n\n\n p5.Gain.prototype.setInput = function(src) {\n src.connect(this.input);\n };\n\n /**\n * Send output to a p5.sound or web audio object\n *\n * @method connect\n * @for p5.Gain\n * @param {Object} unit\n */\n p5.Gain.prototype.connect = function(unit) {\n var u = unit || p5.soundOut.input;\n this.output.connect(u.input ? u.input : u);\n };\n\n /**\n * Disconnect all output.\n *\n * @method disconnect\n * @for p5.Gain\n */\n p5.Gain.prototype.disconnect = function() {\n if (this.output) {\n this.output.disconnect();\n }\n };\n\n /**\n * Set the output level of the gain node.\n *\n * @method amp\n * @for p5.Gain\n * @param {Number} volume amplitude between 0 and 1.0\n * @param {Number} [rampTime] create a fade that lasts rampTime\n * @param {Number} [timeFromNow] schedule this event to happen\n * seconds from now\n */\n p5.Gain.prototype.amp = function(vol, rampTime, tFromNow) {\n var rampTime = rampTime || 0;\n var tFromNow = tFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n var currentVol = this.output.gain.value;\n this.output.gain.cancelScheduledValues(now);\n this.output.gain.linearRampToValueAtTime(currentVol, now + tFromNow);\n this.output.gain.linearRampToValueAtTime(vol, now + tFromNow + rampTime);\n };\n\n p5.Gain.prototype.dispose = function() {\n // remove reference from soundArray\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n if (this.output) {\n this.output.disconnect();\n delete this.output;\n }\n if (this.input) {\n this.input.disconnect();\n delete this.input;\n }\n };\n\n});\n","'use strict';\n\ndefine(function (require) {\n\n var Effect = require('effect');\n\n /*\n * Adapted from [Kevin Ennis on StackOverflow](http://stackoverflow.com/questions/22312841/waveshaper-node-in-webaudio-how-to-emulate-distortion)\n */\n function makeDistortionCurve(amount) {\n var k = typeof amount === 'number' ? amount : 50;\n var numSamples = 44100;\n var curve = new Float32Array(numSamples);\n var deg = Math.PI / 180;\n var i = 0;\n var x;\n for ( ; i < numSamples; ++i ) {\n x = i * 2 / numSamples - 1;\n curve[i] = ( 3 + k ) * x * 20 * deg / ( Math.PI + k * Math.abs(x) );\n }\n return curve;\n }\n\n /**\n * A Distortion effect created with a Waveshaper Node,\n * with an approach adapted from\n * [Kevin Ennis](http://stackoverflow.com/questions/22312841/waveshaper-node-in-webaudio-how-to-emulate-distortion)\n *\n * This class extends p5.Effect.\n * Methods amp(), chain(),\n * drywet(), connect(), and\n * disconnect() are available.\n *\n * @class p5.Distortion\n * @extends p5.Effect\n * @constructor\n * @param {Number} [amount=0.25] Unbounded distortion amount.\n * Normal values range from 0-1.\n * @param {String} [oversample='none'] 'none', '2x', or '4x'.\n *\n */\n p5.Distortion = function(amount, oversample) {\n Effect.call(this);\n\n if (typeof amount === 'undefined') {\n amount = 0.25;\n } if (typeof amount !== 'number') {\n throw new Error('amount must be a number');\n } if (typeof oversample === 'undefined') {\n oversample = '2x';\n } if (typeof oversample !== 'string') {\n throw new Error('oversample must be a String');\n }\n\n var curveAmount = p5.prototype.map(amount, 0.0, 1.0, 0, 2000);\n\n /**\n * The p5.Distortion is built with a\n * \n * Web Audio WaveShaper Node.\n *\n * @property {AudioNode} WaveShaperNode\n */\n this.waveShaperNode = this.ac.createWaveShaper();\n\n this.amount = curveAmount;\n this.waveShaperNode.curve = makeDistortionCurve(curveAmount);\n this.waveShaperNode.oversample = oversample;\n\n this.input.connect(this.waveShaperNode);\n\n this.waveShaperNode.connect(this.wet);\n };\n\n p5.Distortion.prototype = Object.create(Effect.prototype);\n\n\n /**\n * Process a sound source, optionally specify amount and oversample values.\n *\n * @method process\n * @for p5.Distortion\n * @param {Number} [amount=0.25] Unbounded distortion amount.\n * Normal values range from 0-1.\n * @param {String} [oversample='none'] 'none', '2x', or '4x'.\n */\n p5.Distortion.prototype.process = function(src, amount, oversample) {\n src.connect(this.input);\n this.set(amount, oversample);\n };\n\n /**\n * Set the amount and oversample of the waveshaper distortion.\n *\n * @method set\n * @for p5.Distortion\n * @param {Number} [amount=0.25] Unbounded distortion amount.\n * Normal values range from 0-1.\n * @param {String} [oversample='none'] 'none', '2x', or '4x'.\n */\n p5.Distortion.prototype.set = function(amount, oversample) {\n if (amount) {\n var curveAmount = p5.prototype.map(amount, 0.0, 1.0, 0, 2000);\n this.amount = curveAmount;\n this.waveShaperNode.curve = makeDistortionCurve(curveAmount);\n }\n if (oversample) {\n this.waveShaperNode.oversample = oversample;\n }\n };\n\n /**\n * Return the distortion amount, typically between 0-1.\n *\n * @method getAmount\n * @for p5.Distortion\n * @return {Number} Unbounded distortion amount.\n * Normal values range from 0-1.\n */\n p5.Distortion.prototype.getAmount = function() {\n return this.amount;\n };\n\n /**\n * Return the oversampling.\n *\n * @method getOversample\n * @for p5.Distortion\n * @return {String} Oversample can either be 'none', '2x', or '4x'.\n */\n p5.Distortion.prototype.getOversample = function() {\n return this.waveShaperNode.oversample;\n };\n\n\n p5.Distortion.prototype.dispose = function() {\n Effect.prototype.dispose.apply(this);\n if (this.waveShaperNode) {\n this.waveShaperNode.disconnect();\n this.waveShaperNode = null;\n }\n };\n});\n"],"sourceRoot":""} \ No newline at end of file +{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///../node_modules/tone/Tone/core/Tone.js","webpack:///./master.js","webpack:///../node_modules/tone/Tone/signal/Signal.js","webpack:///../node_modules/tone/Tone/signal/Multiply.js","webpack:///./effect.js","webpack:///./helpers.js","webpack:///../node_modules/tone/Tone/signal/WaveShaper.js","webpack:///../node_modules/tone/Tone/signal/Add.js","webpack:///../node_modules/tone/Tone/type/Type.js","webpack:///../node_modules/tone/Tone/core/Gain.js","webpack:///./audioWorklet/processorNames.js","webpack:///./errorHandler.js","webpack:///../node_modules/tone/Tone/core/Context.js","webpack:///../node_modules/tone/Tone/signal/Scale.js","webpack:///../node_modules/tone/Tone/signal/TimelineSignal.js","webpack:///./filter.js","webpack:///../node_modules/tone/Tone/signal/Subtract.js","webpack:///./audiocontext.js","webpack:///../node_modules/tone/Tone/core/Emitter.js","webpack:///../node_modules/tone/Tone/signal/SignalBase.js","webpack:///../node_modules/tone/Tone/type/Time.js","webpack:///../node_modules/tone/Tone/type/TimeBase.js","webpack:///../node_modules/tone/Tone/core/Param.js","webpack:///./oscillator.js","webpack:///../node_modules/tone/Tone/core/Timeline.js","webpack:///../node_modules/tone/Tone/signal/Negate.js","webpack:///../node_modules/tone/Tone/signal/GreaterThanZero.js","webpack:///../node_modules/tone/Tone/core/Clock.js","webpack:///./monosynth.js","webpack:///./audioVoice.js","webpack:///./polysynth.js","webpack:///./app.js","webpack:///../node_modules/audioworklet-polyfill/dist/audioworklet-polyfill.js","webpack:///./shims.js","webpack:///../node_modules/webpack/buildin/global.js","webpack:///../node_modules/startaudiocontext/StartAudioContext.js","webpack:///./audioWorklet/index.js","webpack:///./audioWorklet/recorderProcessor.js","webpack:///./audioWorklet/soundFileProcessor.js","webpack:///./audioWorklet/amplitudeProcessor.js","webpack:///./panner.js","webpack:///./soundfile.js","webpack:///./amplitude.js","webpack:///./fft.js","webpack:///./signal.js","webpack:///../node_modules/tone/Tone/type/Frequency.js","webpack:///../node_modules/tone/Tone/type/TransportTime.js","webpack:///./envelope.js","webpack:///./pulse.js","webpack:///./noise.js","webpack:///./audioin.js","webpack:///../node_modules/tone/Tone/component/CrossFade.js","webpack:///../node_modules/tone/Tone/signal/Expr.js","webpack:///../node_modules/tone/Tone/signal/GreaterThan.js","webpack:///../node_modules/tone/Tone/signal/Abs.js","webpack:///../node_modules/tone/Tone/signal/Modulo.js","webpack:///../node_modules/tone/Tone/signal/Pow.js","webpack:///../node_modules/tone/Tone/signal/AudioToGain.js","webpack:///../node_modules/tone/Tone/signal/EqualPowerGain.js","webpack:///./eq.js","webpack:///./eqFilter.js","webpack:///./panner3d.js","webpack:///./listener3d.js","webpack:///./delay.js","webpack:///./reverb.js","webpack:///./metro.js","webpack:///../node_modules/tone/Tone/core/TimelineState.js","webpack:///./looper.js","webpack:///./soundLoop.js","webpack:///./compressor.js","webpack:///./soundRecorder.js","webpack:///./peakDetect.js","webpack:///./gain.js","webpack:///./distortion.js"],"names":["installedModules","__webpack_require__","moduleId","exports","module","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","define","Tone","inputs","outputs","this","isUndef","input","context","createGain","Array","output","audioContext","set","params","rampTime","isObject","isString","tmpObj","paramLoop","attr","parent","indexOf","attrSplit","split","length","splice","innerParam","join","param","Signal","Param","rampTo","AudioParam","_collectDefaults","constructor","ret","subRet","j","subAttr","isFunction","constr","defaults","keys","_super","superDefs","push","toString","className","isLetter","match","sameConstructor","isArray","dispose","AudioNode","disconnect","connect","unit","outputNum","inputNum","defaultArg","destination","isNumber","apply","arguments","connectSeries","currentUnit","toUnit","chain","fan","given","fallback","givenProp","fallbackProp","optionsObject","values","options","val","arg","isBoolean","noOp","_readOnly","writable","_writable","State","Started","Stopped","Paused","equalPowerScale","percent","piFactor","Math","PI","sin","dbToGain","db","pow","gainToDb","gain","log","LN10","intervalToFrequencyRatio","interval","now","extend","child","TempConstructor","Context","emit","setContext","ctx","sampleRate","hasAudioContext","window","hasPromises","hasWorkers","version","TONE_SILENCE_VERSION_LOGGING","__WEBPACK_AMD_DEFINE_ARRAY__","__WEBPACK_AMD_DEFINE_RESULT__","undefined","audiocontext","p5sound","limiter","createDynamicsCompressor","threshold","ratio","knee","meter","fftMeter","soundArray","parts","extensions","p5","getMasterVolume","masterVolume","vol","tFromNow","currentTime","currentVol","cancelScheduledValues","linearRampToValueAtTime","soundOut","_silentNode","_gain","_param","getConstant","units","Type","Default","convert","SignalBase","Multiply","createInsOuts","_mult","Gain","require","CrossFade","Effect","ac","_drywet","wet","a","b","amp","drywet","fade","u","index","processorNames","freqToMidi","f","mathlog2","round","midiToFreq","writeUTFBytes","view","offset","string","lng","setUint8","charCodeAt","soundFormats","toLowerCase","disposeSound","registerMethod","_checkFileFormats","paths","path","extTest","pop","isFileSupported","pathSplit","pathCore","extension","_typeof","_mathChain","math","thisChain","nextChain","type","mathOps","safeBins","bins","log2","convertToWav","audioBuffer","leftChannel","interleaved","rightChannel","result","Float32Array","inputIndex","interleave","getChannelData","numberOfChannels","buffer","ArrayBuffer","DataView","setUint32","setUint16","setInt16","noteToFreq","note","A","B","C","D","E","F","G","toUpperCase","slice","safeBufferSize","idealBufferSize","bufferSize","tempAudioWorkletNode","AudioWorkletNode","soundFileProcessor","ScriptProcessorNode","WaveShaper","mapping","bufferLen","_shaper","createWaveShaper","_curve","curve","isFinite","setMap","len","normalized","oversample","oversampling","RangeError","Add","_sum","Time","Frequency","TransportTime","Ticks","NormalRange","AudioRange","Decibels","Interval","BPM","Positive","Cents","Degrees","MIDI","BarsBeatsSixteenths","Samples","Hertz","Note","Milliseconds","Seconds","Notation","toSeconds","time","TimeBase","toFrequency","freq","valueOf","toTicks","Transport","ticks","GainNode","AudioContext","createGainNode","_gainNode","recorderProcessor","amplitudeProcessor","errorTrace","failedPath","tempStack","splitStack","err","Error","originalStack","stack","filter","ln","toneConnect","outNum","inNum","nativeConnect","e","nativeDisconnect","webkitAudioContext","prop","Emitter","_context","_defineProperty","_latencyHint","_lookAhead","_updateInterval","_computedUpdateInterval","_worker","_createWorker","_constants","mixin","URL","webkitURL","blob","Blob","toFixed","blobUrl","createObjectURL","worker","Worker","addEventListener","_lastUpdate","diff","max","createBuffer","arr","constant","createBufferSource","channelCount","channelCountMode","loop","start","lA","blockTime","postMessage","hint","lookAhead","latencyHint","updateInterval","supported","Scale","outputMin","outputMax","_outputMin","_outputMax","_scale","_add","_setRange","min","TimelineSignal","_events","Timeline","_initial","_fromUnits","Linear","Exponential","Target","Curve","Set","getValueAtTime","_toUnits","convertedVal","setValueAtTime","startTime","add","endTime","exponentialRampToValueAtTime","beforeEvent","_searchBefore","_minOutput","setValue","sampleTime","setTargetAtTime","timeConstant","setValueCurveAtTime","duration","scaling","floats","segmentTime","after","cancel","setRampPoint","before","_searchAfter","linearRampToValueBetween","finish","exponentialRampToValueBetween","getAfter","previouVal","previous","getBefore","_exponentialApproach","_curveInterpolate","_linearInterpolate","_exponentialInterpolate","t0","v0","v1","exp","t1","progress","lowerIndex","floor","upperIndex","ceil","lowerVal","upperVal","Filter","biquad","createBiquadFilter","setType","_on","_untoggledType","process","src","res","frequency","Q","toggle","LowPass","HighPass","BandPass","Subtract","_neg","Negate","global","StartAudioContext","getAudioContext","userStartAudio","elements","callback","elt","Element","map","on","event","events","eventName","off","ev","eventList","args","functions","func","emitterFunc","node","outputNumber","inputNumber","overridden","_plusNow","_unaryExpressions","quantize","regexp","method","rh","nextSubdivision","lh","subdiv","_expr","expr","subdivision","addNow","_defaultExpr","_noOp","copy","toNotation","retNotation","_toNotationHelper","retTripletNotation","testNotations","_notationToUnits","notationTime","multiple","notation","primaryExprs","_primaryExpressions","notationExprs","toBarsBeatsSixteenths","quarterTime","_beatsToUnits","quarters","measures","_timeSignature","sixteenths","parseFloat","PPQ","toSamples","toMilliseconds","_defaultUnits","exprString","_parseExprString","clone","instance","parseInt","_ticksToUnits","hz","_frequencyToUnits","tr","q","total","_secondsToUnits","samples","default","_binaryExpressions","+","precedence","-","*","/","neg","_syntaxGlue","(",")","_tokenize","position","tokens","token","getNextToken","trim","substr","expressions","group","opName","op","reg","SyntaxError","next","peek","_matchGroup","prec","test","_parseBinary","lexer","_parseUnary","_parsePrimary","matching","beats","bpm","seconds","timeSignature","_pushExpr","sub","mult","div","_lfo","lfo","LFO","currentVal","exponentialRampToValue","linearRampToValue","Mult","Oscillator","started","phaseAmount","oscillator","createOscillator","_freqMods","panPosition","connection","panner","Panner","stop","abs","freqNode","getAmp","isNaN","phase","getFreq","getType","oscMods","pan","pval","getPan","osc2","delayAmt","dNode","createDelay","delayTime","sigChain","mathObj","chainSource","num","scale","inMin","inMax","outMin","outMax","mapOutMin","mapOutMax","SinOsc","TriOsc","SawOsc","SqrOsc","_timeline","_toRemove","_iterating","memory","Infinity","_search","remove","shift","cancelBefore","beginning","end","midPoint","nextEvent","_iterate","lowerBound","upperBound","forEach","forEachBefore","forEachAfter","forEachFrom","forEachAtTime","_multiply","GreaterThanZero","_thresh","Clock","_nextTick","_lastState","_state","TimelineState","_boundLoop","_loop","state","setStateAtTime","pause","loopInterval","lag","currentState","tickTime","getStateAtTime","AudioVoice","MonoSynth","env","Envelope","setRange","setExp","setADSR","setInput","play","velocity","secondsFromNow","susTime","triggerAttack","triggerRelease","vel","ramp","attack","decay","sustain","release","defineProperties","aTime","dTime","sPercent","rTime","sustime","PolySynth","audioVoice","maxVoices","audiovoices","notes","_newest","_oldest","_voicesInUse","_allocateVoices","noteAttack","noteRelease","noteADSR","timeFromNow","voice","_note","_velocity","currentVoice","acTime","oldestNote","previousVal","_updateAfter","maxRange","nextTime","p5SOUND","parameters","fill","processor","realm","exec","inputBuffer","outputBuffer","$$processors","$$context","self","createScriptProcessor","outputChannelCount","Map","properties","defaultValue","MessageChannel","port2","Processor","port","port1","onaudioprocess","$$audioWorklet","AudioWorklet","addModule","fetch","then","ok","status","text","AudioWorkletProcessor","registerProcessor","parameterDescriptors","document","createElement","style","cssText","appendChild","contentWindow","createTextNode","body","$hook","console","documentElement","transpile","String","fixSetTarget","setTargetValueAtTime","createDelayNode","createJavaScriptNode","createPeriodicWave","createWaveTable","internal_createGain","internal_createDelay","maxDelayTime","internal_createBufferSource","internal_start","when","noteGrainOn","noteOn","internal_stop","noteOff","playbackRate","internal_createDynamicsCompressor","reduction","internal_createBiquadFilter","detune","internal_createOscillator","setPeriodicWave","setWaveTable","OfflineAudioContext","webkitOfflineAudioContext","navigator","getUserMedia","webkitGetUserMedia","mozGetUserMedia","msGetUserMedia","el","isSupported","canPlayType","g","Function","factory","__WEBPACK_AMD_DEFINE_FACTORY__","TapListener","element","_dragged","_element","_bindedMove","_moved","_bindedEnd","_ended","isStarted","source","resume","removeEventListener","promise","Promise","success","checkLoop","requestAnimationFrame","tapListeners","bindTapListener","NodeList","querySelectorAll","jquery","toArray","tap","moduleSources","initializedAudioWorklets","preload","_incrementPreload","onWorkletModulesLoad","_decrementPreload","all","moduleSrc","objectURL","audioWorklet","__webpack_exports__","createStereoPanner","stereoPanner","inputChannels","obj","numInputChannels","left","right","channelInterpretation","splitter","createChannelSplitter","createChannelMerger","v","rightVal","cos","leftVal","numChannels","CustomError","_require","SoundFile","onload","onerror","whileLoading","url","File","FileReader","FileList","file","_onended","_looping","_playing","_paused","_pauseTime","_cues","_cueIDCounter","_lastPos","_counterNode","_workletNode","bufferSourceNodes","bufferSourceNode","reversed","pauseTime","startMillis","load","_whileLoading","_clearOnEnd","thisBufferSourceNode","target","soundFile","_","reverse","registerPreloadMethod","loadSound","location","origin","cordova","alert","errorCallback","request","XMLHttpRequest","evt","_updateProgress","open","responseType","decodeAudioData","response","buff","msg","statusText","message","send","reader","readAsArrayBuffer","lengthComputable","percentComplete","loaded","isLoaded","rate","_cueStart","cueStart","cueEnd","setVolume","isPlaying","_initSourceNode","_initCounterNode","_arrayIndex","loopStart","loopEnd","playMode","str","pTime","setLoop","bool","isLooping","isPaused","stopAll","_time","_rampTime","_tFromNow","getVolume","reverseBuffer","setPitch","newPlaybackRate","getPlaybackRate","jump","cueTime","cTime","dur","channels","frames","getPeaks","width","sampleSize","sampleStep","peaks","chan","currentPos","curVol","onended","getLevel","setPath","setBuffer","buf","size","newBuffer","channelNum","_this","cNode","workletBufferSize","processorOptions","onmessage","data","_onTimeUpdate","audioBuf","arrayBuffer","_createCounterBuffer","processPeaks","_initThreshold","_minThreshold","_minPeaks","bufLen","allPeaks","minThreshold","minPeaks","offlineContext","startRendering","oncomplete","filteredBuffer","renderedBuffer","bufferData","getPeaksAtThreshold","topTempos","intervalCounts","tempoCounts","intervalCount","theoreticalTempo","mapTempo","some","tempoCount","tempo","count","groupNeighborsByTempo","peaksObj","peaksArray","sort","startPeak","endPeak","startPos","sampleIndex","intervals","countIntervalsBetweenNearbyPeaks","intA","intB","tempoPeaks","bpmVariance","peaksAtTopTempo","peak","intervalBPM","peakTime","getPeaksAtTopTempo","Peak","amplitude","tempos","Cue","id","addCue","cue","removeCue","cueLength","clearCues","playbackTime","callbackTime","_prevUpdateTime","save","fileName","saveSound","getBlob","dataView","Amplitude","smoothing","parameterData","normalize","volume","volNorm","stereoVol","stereoVolNorm","channel","toggleNormalize","smooth","FFT","analyser","createAnalyser","fftSize","configurable","smoothingTimeConstant","freqDomain","Uint8Array","frequencyBinCount","timeDomain","bass","lowMid","mid","highMid","treble","waveform","_isSafari","timeToFloat","getFloatTimeDomainData","timeToInt","getByteTimeDomainData","normalArray","scaled","analyze","freqToFloat","getFloatFrequencyData","freqToInt","getByteFrequencyData","getEnergy","frequency1","frequency2","nyquist","swap","lowIndex","highIndex","numFrequencies","freq1","freq2","getCentroid","cumulative_sum","centroid_normalization","mean_freq_index","linAverages","N","spectrum","spectrumLength","spectrumStep","linearAverages","groupIndex","specIndex","logAverages","octaveBands","octaveIndex","hi","getOctaveBands","fCtr0","lastFrequencyBand","lo","ctr","newFrequencyBand","fft","_input","midi","midiToFrequency","pitch","octave","noteNumber","noteToScaleIndex","transpose","harmonize","toMidi","frequencyToMidi","toNote","A4","LN2","scaleIndexToNote","cbb","cb","c#","cx","dbb","d#","dx","ebb","eb","e#","ex","fbb","fb","f#","fx","gbb","gb","g#","gx","abb","ab","a#","ax","bbb","bb","b#","bx","_secondsToTicks","l1","t2","l2","t3","l3","aLevel","dLevel","rLevel","_rampHighPercentage","_rampLowPercentage","control","_init","isExponential","sourceToClear","wasTriggered","_setRampAD","_rampAttackTime","checkExpInput","_rampDecayTime","TCDenominator","_rampAttackTC","_rampDecayTC","setRampPercentages","p1","p2","isExp","lastAttack","valToSet","v2","destination1","destination2","AudioIn","Reverb","Noise","Delay","Env","createDCOffset","bufferSource","Pulse","w","dcOffset","dcGain","mW","sig","SignalAdd","mods","currentFreq","freqMod","assignType","_brownNoise","_pinkNoise","_whiteNoise","whiteBuffer","noiseData","random","b0","b1","b2","b3","b4","b5","b6","pinkBuffer","white","brownBuffer","lastOut","noise","inputSources","stream","mediaStream","currentSource","enabled","MediaStreamTrack","mediaDevices","successCallback","audioSource","constraints","audio","echoCancellation","deviceId","createMediaStreamSource","getTracks","track","getSources","onSuccess","onError","resolve","reject","enumerateDevices","devices","device","kind","error","setSource","active","initialFade","_equalPowerA","EqualPowerGain","_equalPowerB","_invert","Expr","applyBinary","Constructor","_eval","applyUnary","getNumber","literalNumber","_replacements","inputCount","_parseInputs","_nodes","tree","_parseTree","_disposeNodes","_Expressions","signal","glue",",","Abs","mod","modulus","Modulo","Pow","a2g","AudioToGain","binary","unary","!","NOT","inputArray","inputMax","replace","matchSyntax","syn","matchGroup","groupName","parseExpression","parseUnary","operator","parsePrimary","GreaterThan","_gtz","_abs","_subtract","_modSignal","_setWaveShaper","_exp","_expScaler","_expFunc","_norm","x","_eqPower","EQFilter","EQ","_eqsize","factor","bands","_newBand","Panner3D","createPanner","panningModel","distanceModel","xVal","yVal","zVal","positionX","positionY","positionZ","orient","orientX","orientY","orientZ","orientationX","orientationY","orientationZ","setFalloff","maxDistance","rolloffFactor","maxDist","rolloff","Listener3D","listener","xValF","yValF","zValF","xValU","yValU","zValU","orientForward","orientUp","forwardX","forwardY","forwardZ","upX","upY","upZ","_split","_merge","_leftGain","_rightGain","leftDelay","rightDelay","_leftFilter","_rightFilter","_maxDelay","maxValue","feedback","_delayTime","_feedback","_filter","_initConvolverNode","_seconds","_decay","_reverse","_buildImpulse","convolverNode","createConvolver","_teardownConvolverNode","_setBuffer","decayRate","rebuild","impulse","impulseL","impulseR","Convolver","impulses","_loadBuffer","cReverb","chunks","addImpulse","resetImpulse","toggleImpulse","Metro","clock","ontick","syncedParts","prevTick","tatumTime","tickCallback","elapsedTime","thisPart","incrementStep","phrases","thisPhrase","phraseArray","sequence","bNum","metroTicks","looping","setBPM","beatTime","tatums","getBPM","getRate","resetSync","part","pushSync","beatLength","initial","playNextPart","aScore","currentPart","scoreStep","Phrase","phraseStep","Part","steps","bLength","partStep","noLoop","metro","addPhrase","array","removePhrase","getPhrase","replaceSequence","onStep","Score","thisScore","nextPart","resetPart","resetParts","SoundLoop","musicalTimeMode","_interval","_bpm","maxIterations","iterations","_calcFreq","syncedStart","otherLoop","_update","_convertNotation","Number","_measure","timeSig","Compressor","compressor","number","SoundRecorder","_inputChannels","_outputChannels","buffers","leftBuffer","rightBuffer","_callback","record","sFile","writeFile","PeakDetect","_framesPerPeak","framesPerPeak","framesSinceLastPeak","cutoff","cutoffMult","energy","penergy","currentValue","isDetected","f1","f2","_onPeak","update","fftObject","nrg","onPeak","makeDistortionCurve","amount","k","deg","Distortion","curveAmount","waveShaperNode","getAmount","getOversample"],"mappings":"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","file":"p5.sound.min.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 31);\n","/**\n * Tone.js\n * @author Yotam Mann\n * @license http://opensource.org/licenses/MIT MIT License\n * @copyright 2014-2017 Yotam Mann\n */\ndefine(function(){\n\n\t\"use strict\";\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tTONE\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * @class Tone is the base class of all other classes. It provides \n\t * a lot of methods and functionality to all classes that extend\n\t * it. \n\t * \n\t * @constructor\n\t * @alias Tone\n\t * @param {number} [inputs=1] the number of input nodes\n\t * @param {number} [outputs=1] the number of output nodes\n\t */\n\tvar Tone = function(inputs, outputs){\n\n\t\t/**\n\t\t * the input node(s)\n\t\t * @type {GainNode|Array}\n\t\t */\n\t\tif (this.isUndef(inputs) || inputs === 1){\n\t\t\tthis.input = this.context.createGain();\n\t\t} else if (inputs > 1){\n\t\t\tthis.input = new Array(inputs);\n\t\t}\n\n\t\t/**\n\t\t * the output node(s)\n\t\t * @type {GainNode|Array}\n\t\t */\n\t\tif (this.isUndef(outputs) || outputs === 1){\n\t\t\tthis.output = this.context.createGain();\n\t\t} else if (outputs > 1){\n\t\t\tthis.output = new Array(inputs);\n\t\t}\n\t};\n\n\t/**\n\t * Set the parameters at once. Either pass in an\n\t * object mapping parameters to values, or to set a\n\t * single parameter, by passing in a string and value.\n\t * The last argument is an optional ramp time which \n\t * will ramp any signal values to their destination value\n\t * over the duration of the rampTime.\n\t * @param {Object|string} params\n\t * @param {number=} value\n\t * @param {Time=} rampTime\n\t * @returns {Tone} this\n\t * @example\n\t * //set values using an object\n\t * filter.set({\n\t * \t\"frequency\" : 300,\n\t * \t\"type\" : highpass\n\t * });\n\t * @example\n\t * filter.set(\"type\", \"highpass\");\n\t * @example\n\t * //ramp to the value 220 over 3 seconds. \n\t * oscillator.set({\n\t * \t\"frequency\" : 220\n\t * }, 3);\n\t */\n\tTone.prototype.set = function(params, value, rampTime){\n\t\tif (this.isObject(params)){\n\t\t\trampTime = value;\n\t\t} else if (this.isString(params)){\n\t\t\tvar tmpObj = {};\n\t\t\ttmpObj[params] = value;\n\t\t\tparams = tmpObj;\n\t\t}\n\n\t\tparamLoop:\n\t\tfor (var attr in params){\n\t\t\tvalue = params[attr];\n\t\t\tvar parent = this;\n\t\t\tif (attr.indexOf(\".\") !== -1){\n\t\t\t\tvar attrSplit = attr.split(\".\");\n\t\t\t\tfor (var i = 0; i < attrSplit.length - 1; i++){\n\t\t\t\t\tparent = parent[attrSplit[i]];\n\t\t\t\t\tif (parent instanceof Tone) {\n\t\t\t\t\t\tattrSplit.splice(0,i+1);\n\t\t\t\t\t\tvar innerParam = attrSplit.join(\".\");\n\t\t\t\t\t\tparent.set(innerParam, value);\n\t\t\t\t\t\tcontinue paramLoop;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tattr = attrSplit[attrSplit.length - 1];\n\t\t\t}\n\t\t\tvar param = parent[attr];\n\t\t\tif (this.isUndef(param)){\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif ((Tone.Signal && param instanceof Tone.Signal) || \n\t\t\t\t\t(Tone.Param && param instanceof Tone.Param)){\n\t\t\t\tif (param.value !== value){\n\t\t\t\t\tif (this.isUndef(rampTime)){\n\t\t\t\t\t\tparam.value = value;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tparam.rampTo(value, rampTime);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else if (param instanceof AudioParam){\n\t\t\t\tif (param.value !== value){\n\t\t\t\t\tparam.value = value;\n\t\t\t\t}\t\t\t\t\n\t\t\t} else if (param instanceof Tone){\n\t\t\t\tparam.set(value);\n\t\t\t} else if (param !== value){\n\t\t\t\tparent[attr] = value;\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Get the object's attributes. Given no arguments get\n\t * will return all available object properties and their corresponding\n\t * values. Pass in a single attribute to retrieve or an array\n\t * of attributes. The attribute strings can also include a \".\"\n\t * to access deeper properties.\n\t * @example\n\t * osc.get();\n\t * //returns {\"type\" : \"sine\", \"frequency\" : 440, ...etc}\n\t * @example\n\t * osc.get(\"type\");\n\t * //returns { \"type\" : \"sine\"}\n\t * @example\n\t * //use dot notation to access deep properties\n\t * synth.get([\"envelope.attack\", \"envelope.release\"]);\n\t * //returns {\"envelope\" : {\"attack\" : 0.2, \"release\" : 0.4}}\n\t * @param {Array=|string|undefined} params the parameters to get, otherwise will return \n\t * \t\t\t\t\t all available.\n\t * @returns {Object}\n\t */\n\tTone.prototype.get = function(params){\n\t\tif (this.isUndef(params)){\n\t\t\tparams = this._collectDefaults(this.constructor);\n\t\t} else if (this.isString(params)){\n\t\t\tparams = [params];\n\t\t} \n\t\tvar ret = {};\n\t\tfor (var i = 0; i < params.length; i++){\n\t\t\tvar attr = params[i];\n\t\t\tvar parent = this;\n\t\t\tvar subRet = ret;\n\t\t\tif (attr.indexOf(\".\") !== -1){\n\t\t\t\tvar attrSplit = attr.split(\".\");\n\t\t\t\tfor (var j = 0; j < attrSplit.length - 1; j++){\n\t\t\t\t\tvar subAttr = attrSplit[j];\n\t\t\t\t\tsubRet[subAttr] = subRet[subAttr] || {};\n\t\t\t\t\tsubRet = subRet[subAttr];\n\t\t\t\t\tparent = parent[subAttr];\n\t\t\t\t}\n\t\t\t\tattr = attrSplit[attrSplit.length - 1];\n\t\t\t}\n\t\t\tvar param = parent[attr];\n\t\t\tif (this.isObject(params[attr])){\n\t\t\t\tsubRet[attr] = param.get();\n\t\t\t} else if (Tone.Signal && param instanceof Tone.Signal){\n\t\t\t\tsubRet[attr] = param.value;\n\t\t\t} else if (Tone.Param && param instanceof Tone.Param){\n\t\t\t\tsubRet[attr] = param.value;\n\t\t\t} else if (param instanceof AudioParam){\n\t\t\t\tsubRet[attr] = param.value;\n\t\t\t} else if (param instanceof Tone){\n\t\t\t\tsubRet[attr] = param.get();\n\t\t\t} else if (!this.isFunction(param) && !this.isUndef(param)){\n\t\t\t\tsubRet[attr] = param;\n\t\t\t} \n\t\t}\n\t\treturn ret;\n\t};\n\n\t/**\n\t * collect all of the default attributes in one\n\t * @private\n\t * @param {function} constr the constructor to find the defaults from\n\t * @return {Array} all of the attributes which belong to the class\n\t */\n\tTone.prototype._collectDefaults = function(constr){\n\t\tvar ret = [];\n\t\tif (!this.isUndef(constr.defaults)){\n\t\t\tret = Object.keys(constr.defaults);\n\t\t}\n\t\tif (!this.isUndef(constr._super)){\n\t\t\tvar superDefs = this._collectDefaults(constr._super);\n\t\t\t//filter out repeats\n\t\t\tfor (var i = 0; i < superDefs.length; i++){\n\t\t\t\tif (ret.indexOf(superDefs[i]) === -1){\n\t\t\t\t\tret.push(superDefs[i]);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn ret;\n\t};\n\n\t/**\n\t * @returns {string} returns the name of the class as a string\n\t */\n\tTone.prototype.toString = function(){\n\t\tfor (var className in Tone){\n\t\t\tvar isLetter = className[0].match(/^[A-Z]$/);\n\t\t\tvar sameConstructor = Tone[className] === this.constructor;\n\t\t\tif (this.isFunction(Tone[className]) && isLetter && sameConstructor){\n\t\t\t\treturn className;\n\t\t\t}\n\t\t}\n\t\treturn \"Tone\";\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tCLASS VARS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * The number of inputs feeding into the AudioNode. \n\t * For source nodes, this will be 0.\n\t * @memberOf Tone#\n\t * @name numberOfInputs\n\t * @readOnly\n\t */\n\tObject.defineProperty(Tone.prototype, \"numberOfInputs\", {\n\t\tget : function(){\n\t\t\tif (this.input){\n\t\t\t\tif (this.isArray(this.input)){\n\t\t\t\t\treturn this.input.length;\n\t\t\t\t} else {\n\t\t\t\t\treturn 1;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\treturn 0;\n\t\t\t}\n\t\t}\n\t});\n\n\t/**\n\t * The number of outputs coming out of the AudioNode. \n\t * For source nodes, this will be 0.\n\t * @memberOf Tone#\n\t * @name numberOfInputs\n\t * @readOnly\n\t */\n\tObject.defineProperty(Tone.prototype, \"numberOfOutputs\", {\n\t\tget : function(){\n\t\t\tif (this.output){\n\t\t\t\tif (this.isArray(this.output)){\n\t\t\t\t\treturn this.output.length;\n\t\t\t\t} else {\n\t\t\t\t\treturn 1;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\treturn 0;\n\t\t\t}\n\t\t}\n\t});\n\t\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tCONNECTIONS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * disconnect and dispose\n\t * @returns {Tone} this\n\t */\n\tTone.prototype.dispose = function(){\n\t\tif (!this.isUndef(this.input)){\n\t\t\tif (this.input instanceof AudioNode){\n\t\t\t\tthis.input.disconnect();\n\t\t\t} \n\t\t\tthis.input = null;\n\t\t}\n\t\tif (!this.isUndef(this.output)){\n\t\t\tif (this.output instanceof AudioNode){\n\t\t\t\tthis.output.disconnect();\n\t\t\t} \n\t\t\tthis.output = null;\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * connect the output of a ToneNode to an AudioParam, AudioNode, or ToneNode\n\t * @param {Tone | AudioParam | AudioNode} unit \n\t * @param {number} [outputNum=0] optionally which output to connect from\n\t * @param {number} [inputNum=0] optionally which input to connect to\n\t * @returns {Tone} this\n\t */\n\tTone.prototype.connect = function(unit, outputNum, inputNum){\n\t\tif (Array.isArray(this.output)){\n\t\t\toutputNum = this.defaultArg(outputNum, 0);\n\t\t\tthis.output[outputNum].connect(unit, 0, inputNum);\n\t\t} else {\n\t\t\tthis.output.connect(unit, outputNum, inputNum);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * disconnect the output\n\t * @param {Number|AudioNode} output Either the output index to disconnect\n\t * if the output is an array, or the\n\t * node to disconnect from.\n\t * @returns {Tone} this\n\t */\n\tTone.prototype.disconnect = function(destination, outputNum, inputNum){\n\t\tif (this.isArray(this.output)){\n\t\t\tif (this.isNumber(destination)){\n\t\t\t\tthis.output[destination].disconnect();\n\t\t\t} else {\n\t\t\t\toutputNum = this.defaultArg(outputNum, 0);\n\t\t\t\tthis.output[outputNum].disconnect(destination, 0, inputNum);\n\t\t\t}\n\t\t} else {\n\t\t\tthis.output.disconnect.apply(this.output, arguments);\n\t\t}\n\t};\n\n\t/**\n\t * connect together all of the arguments in series\n\t * @param {...AudioParam|Tone|AudioNode} nodes\n\t * @returns {Tone} this\n\t */\n\tTone.prototype.connectSeries = function(){\n\t\tif (arguments.length > 1){\n\t\t\tvar currentUnit = arguments[0];\n\t\t\tfor (var i = 1; i < arguments.length; i++){\n\t\t\t\tvar toUnit = arguments[i];\n\t\t\t\tcurrentUnit.connect(toUnit);\n\t\t\t\tcurrentUnit = toUnit;\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Connect the output of this node to the rest of the nodes in series.\n\t * @example\n\t * //connect a node to an effect, panVol and then to the master output\n\t * node.chain(effect, panVol, Tone.Master);\n\t * @param {...AudioParam|Tone|AudioNode} nodes\n\t * @returns {Tone} this\n\t */\n\tTone.prototype.chain = function(){\n\t\tif (arguments.length > 0){\n\t\t\tvar currentUnit = this;\n\t\t\tfor (var i = 0; i < arguments.length; i++){\n\t\t\t\tvar toUnit = arguments[i];\n\t\t\t\tcurrentUnit.connect(toUnit);\n\t\t\t\tcurrentUnit = toUnit;\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * connect the output of this node to the rest of the nodes in parallel.\n\t * @param {...AudioParam|Tone|AudioNode} nodes\n\t * @returns {Tone} this\n\t */\n\tTone.prototype.fan = function(){\n\t\tif (arguments.length > 0){\n\t\t\tfor (var i = 0; i < arguments.length; i++){\n\t\t\t\tthis.connect(arguments[i]);\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t};\n\n\t//give native nodes chain and fan methods\n\tAudioNode.prototype.chain = Tone.prototype.chain;\n\tAudioNode.prototype.fan = Tone.prototype.fan;\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tUTILITIES / HELPERS / MATHS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * If the `given` parameter is undefined, use the `fallback`. \n\t * If both `given` and `fallback` are object literals, it will\n\t * return a deep copy which includes all of the parameters from both \n\t * objects. If a parameter is undefined in given, it will return\n\t * the fallback property. \n\t *

\n\t * WARNING: if object is self referential, it will go into an an \n\t * infinite recursive loop.\n\t * \n\t * @param {*} given \n\t * @param {*} fallback \n\t * @return {*} \n\t */\n\tTone.prototype.defaultArg = function(given, fallback){\n\t\tif (this.isObject(given) && this.isObject(fallback)){\n\t\t\tvar ret = {};\n\t\t\t//make a deep copy of the given object\n\t\t\tfor (var givenProp in given) {\n\t\t\t\tret[givenProp] = this.defaultArg(fallback[givenProp], given[givenProp]);\n\t\t\t}\n\t\t\tfor (var fallbackProp in fallback) {\n\t\t\t\tret[fallbackProp] = this.defaultArg(given[fallbackProp], fallback[fallbackProp]);\n\t\t\t}\n\t\t\treturn ret;\n\t\t} else {\n\t\t\treturn this.isUndef(given) ? fallback : given;\n\t\t}\n\t};\n\n\t/**\n\t * returns the args as an options object with given arguments\n\t * mapped to the names provided. \n\t *\n\t * if the args given is an array containing only one object, it is assumed\n\t * that that's already the options object and will just return it. \n\t * \n\t * @param {Array} values the 'arguments' object of the function\n\t * @param {Array} keys the names of the arguments as they\n\t * should appear in the options object\n\t * @param {Object=} defaults optional defaults to mixin to the returned \n\t * options object \n\t * @return {Object} the options object with the names mapped to the arguments\n\t */\n\tTone.prototype.optionsObject = function(values, keys, defaults){\n\t\tvar options = {};\n\t\tif (values.length === 1 && this.isObject(values[0])){\n\t\t\toptions = values[0];\n\t\t} else {\n\t\t\tfor (var i = 0; i < keys.length; i++){\n\t\t\t\toptions[keys[i]] = values[i];\n\t\t\t}\n\t\t}\n\t\tif (!this.isUndef(defaults)){\n\t\t\treturn this.defaultArg(options, defaults);\n\t\t} else {\n\t\t\treturn options;\n\t\t}\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t// TYPE CHECKING\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * test if the arg is undefined\n\t * @param {*} arg the argument to test\n\t * @returns {boolean} true if the arg is undefined\n\t * @function\n\t */\n\tTone.prototype.isUndef = function(val){\n\t\treturn typeof val === \"undefined\";\n\t};\n\n\t/**\n\t * test if the arg is a function\n\t * @param {*} arg the argument to test\n\t * @returns {boolean} true if the arg is a function\n\t * @function\n\t */\n\tTone.prototype.isFunction = function(val){\n\t\treturn typeof val === \"function\";\n\t};\n\n\t/**\n\t * Test if the argument is a number.\n\t * @param {*} arg the argument to test\n\t * @returns {boolean} true if the arg is a number\n\t */\n\tTone.prototype.isNumber = function(arg){\n\t\treturn (typeof arg === \"number\");\n\t};\n\n\t/**\n\t * Test if the given argument is an object literal (i.e. `{}`);\n\t * @param {*} arg the argument to test\n\t * @returns {boolean} true if the arg is an object literal.\n\t */\n\tTone.prototype.isObject = function(arg){\n\t\treturn (Object.prototype.toString.call(arg) === \"[object Object]\" && arg.constructor === Object);\n\t};\n\n\t/**\n\t * Test if the argument is a boolean.\n\t * @param {*} arg the argument to test\n\t * @returns {boolean} true if the arg is a boolean\n\t */\n\tTone.prototype.isBoolean = function(arg){\n\t\treturn (typeof arg === \"boolean\");\n\t};\n\n\t/**\n\t * Test if the argument is an Array\n\t * @param {*} arg the argument to test\n\t * @returns {boolean} true if the arg is an array\n\t */\n\tTone.prototype.isArray = function(arg){\n\t\treturn (Array.isArray(arg));\n\t};\n\n\t/**\n\t * Test if the argument is a string.\n\t * @param {*} arg the argument to test\n\t * @returns {boolean} true if the arg is a string\n\t */\n\tTone.prototype.isString = function(arg){\n\t\treturn (typeof arg === \"string\");\n\t};\n\n \t/**\n\t * An empty function.\n\t * @static\n\t */\n\tTone.noOp = function(){};\n\n\t/**\n\t * Make the property not writable. Internal use only. \n\t * @private\n\t * @param {string} property the property to make not writable\n\t */\n\tTone.prototype._readOnly = function(property){\n\t\tif (Array.isArray(property)){\n\t\t\tfor (var i = 0; i < property.length; i++){\n\t\t\t\tthis._readOnly(property[i]);\n\t\t\t}\n\t\t} else {\n\t\t\tObject.defineProperty(this, property, { \n\t\t\t\twritable: false,\n\t\t\t\tenumerable : true,\n\t\t\t});\n\t\t}\n\t};\n\n\t/**\n\t * Make an attribute writeable. Interal use only. \n\t * @private\n\t * @param {string} property the property to make writable\n\t */\n\tTone.prototype._writable = function(property){\n\t\tif (Array.isArray(property)){\n\t\t\tfor (var i = 0; i < property.length; i++){\n\t\t\t\tthis._writable(property[i]);\n\t\t\t}\n\t\t} else {\n\t\t\tObject.defineProperty(this, property, { \n\t\t\t\twritable: true,\n\t\t\t});\n\t\t}\n\t};\n\n\t/**\n\t * Possible play states. \n\t * @enum {string}\n\t */\n\tTone.State = {\n\t\tStarted : \"started\",\n\t\tStopped : \"stopped\",\n\t\tPaused : \"paused\",\n \t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t// CONVERSIONS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Equal power gain scale. Good for cross-fading.\n\t * @param {NormalRange} percent (0-1)\n\t * @return {Number} output gain (0-1)\n\t */\n\tTone.prototype.equalPowerScale = function(percent){\n\t\tvar piFactor = 0.5 * Math.PI;\n\t\treturn Math.sin(percent * piFactor);\n\t};\n\n\t/**\n\t * Convert decibels into gain.\n\t * @param {Decibels} db\n\t * @return {Number} \n\t */\n\tTone.prototype.dbToGain = function(db) {\n\t\treturn Math.pow(2, db / 6);\n\t};\n\n\t/**\n\t * Convert gain to decibels.\n\t * @param {Number} gain (0-1)\n\t * @return {Decibels} \n\t */\n\tTone.prototype.gainToDb = function(gain) {\n\t\treturn 20 * (Math.log(gain) / Math.LN10);\n\t};\n\n\t/**\n\t * Convert an interval (in semitones) to a frequency ratio.\n\t * @param {Interval} interval the number of semitones above the base note\n\t * @return {number} the frequency ratio\n\t * @example\n\t * tone.intervalToFrequencyRatio(0); // 1\n\t * tone.intervalToFrequencyRatio(12); // 2\n\t * tone.intervalToFrequencyRatio(-12); // 0.5\n\t */\n\tTone.prototype.intervalToFrequencyRatio = function(interval){\n\t\treturn Math.pow(2,(interval/12));\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tTIMING\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Return the current time of the AudioContext clock.\n\t * @return {Number} the currentTime from the AudioContext\n\t */\n\tTone.prototype.now = function(){\n\t\treturn Tone.context.now();\n\t};\n\n\t/**\n\t * Return the current time of the AudioContext clock.\n\t * @return {Number} the currentTime from the AudioContext\n\t * @static\n\t */\n\tTone.now = function(){\n\t\treturn Tone.context.now();\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tINHERITANCE\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * have a child inherit all of Tone's (or a parent's) prototype\n\t * to inherit the parent's properties, make sure to call \n\t * Parent.call(this) in the child's constructor\n\t *\n\t * based on closure library's inherit function\n\t *\n\t * @static\n\t * @param {function} \tchild \n\t * @param {function=} parent (optional) parent to inherit from\n\t * if no parent is supplied, the child\n\t * will inherit from Tone\n\t */\n\tTone.extend = function(child, parent){\n\t\tif (Tone.prototype.isUndef(parent)){\n\t\t\tparent = Tone;\n\t\t}\n\t\tfunction TempConstructor(){}\n\t\tTempConstructor.prototype = parent.prototype;\n\t\tchild.prototype = new TempConstructor();\n\t\t/** @override */\n\t\tchild.prototype.constructor = child;\n\t\tchild._super = parent;\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tCONTEXT\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * The private audio context shared by all Tone Nodes. \n\t * @private\n\t * @type {Tone.Context|undefined}\n\t */\n\tvar audioContext;\n\n\t/**\n\t * A static pointer to the audio context accessible as Tone.context. \n\t * @type {Tone.Context}\n\t * @name context\n\t * @memberOf Tone\n\t */\n\tObject.defineProperty(Tone, \"context\", {\n\t\tget : function(){\n\t\t\treturn audioContext;\n\t\t},\n\t\tset : function(context){\n\t\t\tif (Tone.Context && context instanceof Tone.Context){\n\t\t\t\taudioContext = context;\n\t\t\t} else {\n\t\t\t\taudioContext = new Tone.Context(context);\n\t\t\t}\n\t\t\t//initialize the new audio context\n\t\t\tif (Tone.Context){\n\t\t\t\tTone.Context.emit(\"init\", audioContext);\n\t\t\t}\n\t\t}\n\t});\n\n\t/**\n\t * The AudioContext\n\t * @type {Tone.Context}\n\t * @name context\n\t * @memberOf Tone#\n\t * @readOnly\n\t */\n\tObject.defineProperty(Tone.prototype, \"context\", {\n\t\tget : function(){\n\t\t\treturn Tone.context;\n\t\t}\n\t});\n\n\t/**\n\t * Tone automatically creates a context on init, but if you are working\n\t * with other libraries which also create an AudioContext, it can be\n\t * useful to set your own. If you are going to set your own context, \n\t * be sure to do it at the start of your code, before creating any objects.\n\t * @static\n\t * @param {AudioContext} ctx The new audio context to set\n\t */\n\tTone.setContext = function(ctx){\n\t\tTone.context = ctx;\n\t};\n\n\t/**\n\t * The number of seconds of 1 processing block (128 samples)\n\t * @type {Number}\n\t * @name blockTime\n\t * @memberOf Tone#\n\t * @readOnly\n\t */\n\tObject.defineProperty(Tone.prototype, \"blockTime\", {\n\t\tget : function(){\n\t\t\treturn 128 / this.context.sampleRate;\n\t\t}\n\t});\n\n\t/**\n\t * The duration in seconds of one sample.\n\t * @type {Number}\n\t * @name sampleTime\n\t * @memberOf Tone#\n\t * @readOnly\n\t */\n\tObject.defineProperty(Tone.prototype, \"sampleTime\", {\n\t\tget : function(){\n\t\t\treturn 1 / this.context.sampleRate;\n\t\t}\n\t});\n\n\t/**\n\t * Whether or not all the technologies that Tone.js relies on are supported by the current browser. \n\t * @type {Boolean}\n\t * @name supported\n\t * @memberOf Tone\n\t * @readOnly\n\t */\n\tObject.defineProperty(Tone, \"supported\", {\n\t\tget : function(){\n\t\t\tvar hasAudioContext = window.hasOwnProperty(\"AudioContext\") || window.hasOwnProperty(\"webkitAudioContext\");\n\t\t\tvar hasPromises = window.hasOwnProperty(\"Promise\");\n\t\t\tvar hasWorkers = window.hasOwnProperty(\"Worker\");\n\t\t\treturn hasAudioContext && hasPromises && hasWorkers;\n\t\t}\n\t});\n\n\tTone.version = \"r10\";\n\n\t// allow optional silencing of this log\n\tif (!window.TONE_SILENCE_VERSION_LOGGING) {\n\t\tconsole.log(\"%c * Tone.js \" + Tone.version + \" * \", \"background: #000; color: #fff\");\n\t}\n\n\treturn Tone;\n});\n","'use strict';\n\n\ndefine(['audiocontext'], function (audiocontext) {\n // Master contains the master sound output.\n var Master = function() {\n this.input = audiocontext.createGain();\n this.output = audiocontext.createGain();\n\n //put a hard limiter on the output\n this.limiter = audiocontext.createDynamicsCompressor();\n this.limiter.threshold.value = -3;\n this.limiter.ratio.value = 20;\n this.limiter.knee.value = 1;\n\n this.audiocontext = audiocontext;\n\n this.output.disconnect();\n\n // connect input to limiter\n this.input.connect(this.limiter);\n\n // connect limiter to output\n this.limiter.connect(this.output);\n\n // meter is just for global Amplitude / FFT analysis\n this.meter = audiocontext.createGain();\n this.fftMeter = audiocontext.createGain();\n this.output.connect(this.meter);\n this.output.connect(this.fftMeter);\n\n // connect output to destination\n this.output.connect(this.audiocontext.destination);\n\n // an array of all sounds in the sketch\n this.soundArray = [];\n // an array of all musical parts in the sketch\n this.parts = [];\n\n // file extensions to search for\n this.extensions = [];\n };\n\n // create a single instance of the p5Sound / master output for use within this sketch\n var p5sound = new Master();\n\n /**\n * Returns a number representing the master amplitude (volume) for sound\n * in this sketch.\n *\n * @method getMasterVolume\n * @return {Number} Master amplitude (volume) for sound in this sketch.\n * Should be between 0.0 (silence) and 1.0.\n */\n p5.prototype.getMasterVolume = function() {\n return p5sound.output.gain.value;\n };\n\n /**\n *

Scale the output of all sound in this sketch

\n * Scaled between 0.0 (silence) and 1.0 (full volume).\n * 1.0 is the maximum amplitude of a digital sound, so multiplying\n * by greater than 1.0 may cause digital distortion. To\n * fade, provide a rampTime parameter. For more\n * complex fades, see the Envelope class.\n *\n * Alternately, you can pass in a signal source such as an\n * oscillator to modulate the amplitude with an audio signal.\n *\n *

How This Works: When you load the p5.sound module, it\n * creates a single instance of p5sound. All sound objects in this\n * module output to p5sound before reaching your computer's output.\n * So if you change the amplitude of p5sound, it impacts all of the\n * sound in this module.

\n *\n *

If no value is provided, returns a Web Audio API Gain Node

\n *\n * @method masterVolume\n * @param {Number|Object} volume Volume (amplitude) between 0.0\n * and 1.0 or modulating signal/oscillator\n * @param {Number} [rampTime] Fade for t seconds\n * @param {Number} [timeFromNow] Schedule this event to happen at\n * t seconds in the future\n */\n p5.prototype.masterVolume = function(vol, rampTime, tFromNow) {\n if (typeof vol === 'number') {\n var rampTime = rampTime || 0;\n var tFromNow = tFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n var currentVol = p5sound.output.gain.value;\n p5sound.output.gain.cancelScheduledValues(now + tFromNow);\n p5sound.output.gain.linearRampToValueAtTime(currentVol, now + tFromNow);\n p5sound.output.gain.linearRampToValueAtTime(vol, now + tFromNow + rampTime);\n }\n else if (vol) {\n vol.connect(p5sound.output.gain);\n } else {\n // return the Gain Node\n return p5sound.output.gain;\n }\n };\n\n /**\n * `p5.soundOut` is the p5.sound master output. It sends output to\n * the destination of this window's web audio context. It contains\n * Web Audio API nodes including a dyanmicsCompressor (.limiter),\n * and Gain Nodes for .input and .output.\n *\n * @property {Object} soundOut\n */\n p5.prototype.soundOut = p5.soundOut = p5sound;\n\n // a silent connection to the DesinationNode\n // which will ensure that anything connected to it\n // will not be garbage collected\n p5.soundOut._silentNode = p5sound.audiocontext.createGain();\n p5.soundOut._silentNode.gain.value = 0;\n p5.soundOut._silentNode.connect(p5sound.audiocontext.destination);\n\n\n return p5sound;\n});\n","define([\"Tone/core/Tone\", \"Tone/signal/WaveShaper\", \"Tone/type/Type\", \"Tone/core/Param\", \"Tone/core/Gain\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class A signal is an audio-rate value. Tone.Signal is a core component of the library.\n\t * Unlike a number, Signals can be scheduled with sample-level accuracy. Tone.Signal\n\t * has all of the methods available to native Web Audio \n\t * [AudioParam](http://webaudio.github.io/web-audio-api/#the-audioparam-interface)\n\t * as well as additional conveniences. Read more about working with signals \n\t * [here](https://github.com/Tonejs/Tone.js/wiki/Signals).\n\t *\n\t * @constructor\n\t * @extends {Tone.Param}\n\t * @param {Number|AudioParam} [value] Initial value of the signal. If an AudioParam\n\t * is passed in, that parameter will be wrapped\n\t * and controlled by the Signal. \n\t * @param {string} [units=Number] unit The units the signal is in. \n\t * @example\n\t * var signal = new Tone.Signal(10);\n\t */\n\tTone.Signal = function(){\n\n\t\tvar options = this.optionsObject(arguments, [\"value\", \"units\"], Tone.Signal.defaults);\n\n\t\t/**\n\t\t * The node where the constant signal value is scaled.\n\t\t * @type {GainNode}\n\t\t * @private\n\t\t */\n\t\tthis.output = this._gain = this.context.createGain();\n\n\t\toptions.param = this._gain.gain;\n\t\tTone.Param.call(this, options);\n\n\t\t/**\n\t\t * The node where the value is set.\n\t\t * @type {Tone.Param}\n\t\t * @private\n\t\t */\n\t\tthis.input = this._param = this._gain.gain;\n\n\t\t//connect the const output to the node output\n\t\tthis.context.getConstant(1).chain(this._gain);\n\t};\n\n\tTone.extend(Tone.Signal, Tone.Param);\n\n\t/**\n\t * The default values\n\t * @type {Object}\n\t * @static\n\t * @const\n\t */\n\tTone.Signal.defaults = {\n\t\t\"value\" : 0,\n\t\t\"units\" : Tone.Type.Default,\n\t\t\"convert\" : true,\n\t};\n\n\t/**\n\t * When signals connect to other signals or AudioParams, \n\t * they take over the output value of that signal or AudioParam. \n\t * For all other nodes, the behavior is the same as a default connect. \n\t *\n\t * @override\n\t * @param {AudioParam|AudioNode|Tone.Signal|Tone} node \n\t * @param {number} [outputNumber=0] The output number to connect from.\n\t * @param {number} [inputNumber=0] The input number to connect to.\n\t * @returns {Tone.SignalBase} this\n\t * @method\n\t */\n\tTone.Signal.prototype.connect = Tone.SignalBase.prototype.connect;\n\n\t/**\n\t * dispose and disconnect\n\t * @returns {Tone.Signal} this\n\t */\n\tTone.Signal.prototype.dispose = function(){\n\t\tTone.Param.prototype.dispose.call(this);\n\t\tthis._param = null;\n\t\tthis._gain.disconnect();\n\t\tthis._gain = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.Signal;\n});","define([\"Tone/core/Tone\", \"Tone/signal/Signal\", \"Tone/core/Gain\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Multiply two incoming signals. Or, if a number is given in the constructor, \n\t * multiplies the incoming signal by that value. \n\t *\n\t * @constructor\n\t * @extends {Tone.Signal}\n\t * @param {number=} value Constant value to multiple. If no value is provided,\n\t * it will return the product of the first and second inputs\n\t * @example\n\t * var mult = new Tone.Multiply();\n\t * var sigA = new Tone.Signal(3);\n\t * var sigB = new Tone.Signal(4);\n\t * sigA.connect(mult, 0, 0);\n\t * sigB.connect(mult, 0, 1);\n\t * //output of mult is 12.\n\t * @example\n\t * var mult = new Tone.Multiply(10);\n\t * var sig = new Tone.Signal(2).connect(mult);\n\t * //the output of mult is 20. \n\t */\n\tTone.Multiply = function(value){\n\n\t\tthis.createInsOuts(2, 0);\n\n\t\t/**\n\t\t * the input node is the same as the output node\n\t\t * it is also the GainNode which handles the scaling of incoming signal\n\t\t * \n\t\t * @type {GainNode}\n\t\t * @private\n\t\t */\n\t\tthis._mult = this.input[0] = this.output = new Tone.Gain();\n\n\t\t/**\n\t\t * the scaling parameter\n\t\t * @type {AudioParam}\n\t\t * @private\n\t\t */\n\t\tthis._param = this.input[1] = this.output.gain;\n\t\t\n\t\tthis._param.value = this.defaultArg(value, 0);\n\t};\n\n\tTone.extend(Tone.Multiply, Tone.Signal);\n\n\t/**\n\t * clean up\n\t * @returns {Tone.Multiply} this\n\t */\n\tTone.Multiply.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._mult.dispose();\n\t\tthis._mult = null;\n\t\tthis._param = null;\n\t\treturn this;\n\t}; \n\n\treturn Tone.Multiply;\n});\n","'use strict';\ndefine(function (require) {\n\n var p5sound = require('master');\n var CrossFade = require('Tone/component/CrossFade');\n\n /**\n * Effect is a base class for audio effects in p5.
\n * This module handles the nodes and methods that are\n * common and useful for current and future effects.\n *\n *\n * This class is extended by p5.Distortion,\n * p5.Compressor,\n * p5.Delay,\n * p5.Filter,\n * p5.Reverb.\n *\n * @class p5.Effect\n * @constructor\n *\n * @param {Object} [ac] Reference to the audio context of the p5 object\n * @param {AudioNode} [input] Gain Node effect wrapper\n * @param {AudioNode} [output] Gain Node effect wrapper\n * @param {Object} [_drywet] Tone.JS CrossFade node (defaults to value: 1)\n * @param {AudioNode} [wet] Effects that extend this class should connect\n * to the wet signal to this gain node, so that dry and wet\n * signals are mixed properly.\n */\n p5.Effect = function() {\n this.ac = p5sound.audiocontext;\n\n this.input = this.ac.createGain();\n this.output = this.ac.createGain();\n\n /**\n *\tThe p5.Effect class is built\n * \tusing Tone.js CrossFade\n * \t@private\n */\n\n this._drywet = new CrossFade(1);\n\n /**\n *\tIn classes that extend\n *\tp5.Effect, connect effect nodes\n *\tto the wet parameter\n */\n this.wet = this.ac.createGain();\n\n this.input.connect(this._drywet.a);\n this.wet.connect(this._drywet.b);\n this._drywet.connect(this.output);\n\n this.connect();\n\n //Add to the soundArray\n p5sound.soundArray.push(this);\n };\n\n /**\n * Set the output volume of the filter.\n *\n * @method amp\n * @for p5.Effect\n * @param {Number} [vol] amplitude between 0 and 1.0\n * @param {Number} [rampTime] create a fade that lasts until rampTime\n * @param {Number} [tFromNow] schedule this event to happen in tFromNow seconds\n */\n p5.Effect.prototype.amp = function(vol, rampTime, tFromNow){\n var rampTime = rampTime || 0;\n var tFromNow = tFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n var currentVol = this.output.gain.value;\n this.output.gain.cancelScheduledValues(now);\n this.output.gain.linearRampToValueAtTime(currentVol, now + tFromNow + .001);\n this.output.gain.linearRampToValueAtTime(vol, now + tFromNow + rampTime + .001);\n };\n\n /**\n * Link effects together in a chain\n * Example usage: filter.chain(reverb, delay, panner);\n * May be used with an open-ended number of arguments\n *\n * @method chain\n * @for p5.Effect\n * @param {Object} [arguments] Chain together multiple sound objects\n */\n p5.Effect.prototype.chain = function(){\n if (arguments.length>0){\n this.connect(arguments[0]);\n for(var i=1;i\n * let midiNotes = [60, 64, 67, 72];\n * let noteIndex = 0;\n * let midiVal, freq;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(startSound);\n * osc = new p5.TriOsc();\n * env = new p5.Envelope();\n * }\n *\n * function draw() {\n * background(220);\n * text('tap to play', 10, 20);\n * if (midiVal) {\n * text('MIDI: ' + midiVal, 10, 40);\n * text('Freq: ' + freq, 10, 60);\n * }\n * }\n *\n * function startSound() {\n * // see also: userStartAudio();\n * osc.start();\n *\n * midiVal = midiNotes[noteIndex % midiNotes.length];\n * freq = midiToFreq(midiVal);\n * osc.freq(freq);\n * env.ramp(osc, 0, 1.0, 0);\n *\n * noteIndex++;\n * }\n * \n */\n var midiToFreq = p5.prototype.midiToFreq = function(m) {\n return 440 * Math.pow(2, (m-69)/12.0);\n };\n\n // This method converts ANSI notes specified as a string \"C4\", \"Eb3\" to a frequency\n var noteToFreq = function(note) {\n if (typeof note !== 'string') {\n return note;\n }\n var wholeNotes = {A:21, B:23, C:24, D:26, E:28, F:29, G:31};\n var value = wholeNotes[ note[0].toUpperCase() ];\n var octave = ~~note.slice(-1);\n value += 12 * (octave -1);\n\n switch(note[1]) {\n case '#':\n value += 1;\n break;\n case 'b':\n value -= 1;\n break;\n default:\n break;\n }\n return midiToFreq(value);\n };\n\n /**\n * List the SoundFile formats that you will include. LoadSound\n * will search your directory for these extensions, and will pick\n * a format that is compatable with the client's web browser.\n * Here is a free online file\n * converter.\n *\n * @method soundFormats\n * @param {String} [...formats] i.e. 'mp3', 'wav', 'ogg'\n * @example\n *
\n * function preload() {\n * // set the global sound formats\n * soundFormats('mp3', 'ogg');\n *\n * // load either beatbox.mp3, or .ogg, depending on browser\n * mySound = loadSound('assets/beatbox.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * background(220);\n * text('sound loaded! tap to play', 10, 20, width - 20);\n * cnv.mousePressed(function() {\n * mySound.play();\n * });\n * }\n *
\n */\n p5.prototype.soundFormats = function() {\n // reset extensions array\n p5sound.extensions = [];\n // add extensions\n for (var i = 0; i < arguments.length; i++) {\n arguments[i] = arguments[i].toLowerCase();\n if (['mp3','wav','ogg', 'm4a', 'aac'].indexOf(arguments[i]) > -1) {\n p5sound.extensions.push(arguments[i]);\n } else {\n throw arguments[i] + ' is not a valid sound format!';\n }\n }\n };\n\n p5.prototype.disposeSound = function() {\n for (var i = 0; i < p5sound.soundArray.length; i++) {\n p5sound.soundArray[i].dispose();\n }\n };\n\n // register removeSound to dispose of p5sound SoundFiles, Convolvers,\n // Oscillators etc when sketch ends\n p5.prototype.registerMethod('remove', p5.prototype.disposeSound);\n\n p5.prototype._checkFileFormats = function(paths) {\n var path;\n // if path is a single string, check to see if extension is provided\n if (typeof paths === 'string') {\n path = paths;\n // see if extension is provided\n var extTest = path.split('.').pop();\n // if an extension is provided...\n if (['mp3','wav','ogg', 'm4a', 'aac'].indexOf(extTest) > -1) {\n if (p5.prototype.isFileSupported(extTest)) {\n path = path;\n }\n else {\n var pathSplit = path.split('.');\n var pathCore = pathSplit[pathSplit.length - 1];\n for (var i = 0; i 1) {\n rightChannel = audioBuffer.getChannelData(1);\n } else {\n rightChannel = leftChannel;\n }\n\n var interleaved = interleave(leftChannel, rightChannel);\n\n // create the buffer and view to create the .WAV file\n var buffer = new window.ArrayBuffer(44 + interleaved.length * 2);\n var view = new window.DataView(buffer);\n\n // write the WAV container,\n // check spec at: https://web.archive.org/web/20171215131933/http://tiny.systems/software/soundProgrammer/WavFormatDocs.pdf\n\n // RIFF chunk descriptor\n writeUTFBytes(view, 0, 'RIFF');\n view.setUint32(4, 36 + interleaved.length * 2, true);\n writeUTFBytes(view, 8, 'WAVE');\n // FMT sub-chunk\n writeUTFBytes(view, 12, 'fmt ');\n view.setUint32(16, 16, true);\n view.setUint16(20, 1, true);\n // stereo (2 channels)\n view.setUint16(22, 2, true);\n view.setUint32(24, p5sound.audiocontext.sampleRate, true);\n view.setUint32(28, p5sound.audiocontext.sampleRate * 4, true);\n view.setUint16(32, 4, true);\n view.setUint16(34, 16, true);\n // data sub-chunk\n writeUTFBytes(view, 36, 'data');\n view.setUint32(40, interleaved.length * 2, true);\n\n // write the PCM samples\n var lng = interleaved.length;\n var index = 44;\n var volume = 1;\n for (var i = 0; i < lng; i++) {\n view.setInt16(index, interleaved[i] * (0x7FFF * volume), true);\n index += 2;\n }\n\n return view;\n }\n\n // helper methods to save waves\n function interleave(leftChannel, rightChannel) {\n var length = leftChannel.length + rightChannel.length;\n var result = new Float32Array(length);\n\n var inputIndex = 0;\n\n for (var index = 0; index < length;) {\n result[index++] = leftChannel[inputIndex];\n result[index++] = rightChannel[inputIndex];\n inputIndex++;\n }\n return result;\n }\n\n function writeUTFBytes(view, offset, string) {\n var lng = string.length;\n for (var i = 0; i < lng; i++) {\n view.setUint8(offset + i, string.charCodeAt(i));\n }\n }\n\n function safeBufferSize(idealBufferSize) {\n let bufferSize = idealBufferSize; \n\n // if the AudioWorkletNode is actually a ScriptProcessorNode created via polyfill,\n // make sure that our chosen buffer size isn't smaller than the buffer size automatically\n // selected by the polyfill\n // reference: https://github.com/GoogleChromeLabs/audioworklet-polyfill/issues/13#issuecomment-425014930\n let tempAudioWorkletNode = new AudioWorkletNode(p5sound.audiocontext, processorNames.soundFileProcessor);\n if (tempAudioWorkletNode instanceof ScriptProcessorNode) {\n bufferSize = tempAudioWorkletNode.bufferSize;\n }\n tempAudioWorkletNode.disconnect();\n tempAudioWorkletNode = null;\n\n return bufferSize;\n }\n var safeBins = p5.prototype.safeBins = function(bins) {\n let safeBins = 1024;\n if(typeof(bins)===\"string\"){\n console.log(\"the value of bins must be power of two and between 16 and 1024\");\n return safeBins\n }\n if(bins && bins>=16 && bins<=1024 && Math.log2(bins)%1===0 ) // \n return bins;\n else {\n console.log(\"the value of bins must be power of two and between 16 and 1024\");\n return safeBins\n }\n \n }\n\n return {\n convertToWav: convertToWav,\n midiToFreq: midiToFreq,\n noteToFreq: noteToFreq,\n safeBufferSize: safeBufferSize,\n safeBins:safeBins\n };\n\n});\n","define([\"Tone/core/Tone\", \"Tone/signal/SignalBase\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Wraps the native Web Audio API \n\t * [WaveShaperNode](http://webaudio.github.io/web-audio-api/#the-waveshapernode-interface).\n\t *\n\t * @extends {Tone.SignalBase}\n\t * @constructor\n\t * @param {function|Array|Number} mapping The function used to define the values. \n\t * The mapping function should take two arguments: \n\t * the first is the value at the current position \n\t * and the second is the array position. \n\t * If the argument is an array, that array will be\n\t * set as the wave shaping function. The input\n\t * signal is an AudioRange [-1, 1] value and the output\n\t * signal can take on any numerical values. \n\t * \n\t * @param {Number} [bufferLen=1024] The length of the WaveShaperNode buffer.\n\t * @example\n\t * var timesTwo = new Tone.WaveShaper(function(val){\n\t * \treturn val * 2;\n\t * }, 2048);\n\t * @example\n\t * //a waveshaper can also be constructed with an array of values\n\t * var invert = new Tone.WaveShaper([1, -1]);\n\t */\n\tTone.WaveShaper = function(mapping, bufferLen){\n\n\t\t/**\n\t\t * the waveshaper\n\t\t * @type {WaveShaperNode}\n\t\t * @private\n\t\t */\n\t\tthis._shaper = this.input = this.output = this.context.createWaveShaper();\n\n\t\t/**\n\t\t * the waveshapers curve\n\t\t * @type {Float32Array}\n\t\t * @private\n\t\t */\n\t\tthis._curve = null;\n\n\t\tif (Array.isArray(mapping)){\n\t\t\tthis.curve = mapping;\n\t\t} else if (isFinite(mapping) || this.isUndef(mapping)){\n\t\t\tthis._curve = new Float32Array(this.defaultArg(mapping, 1024));\n\t\t} else if (this.isFunction(mapping)){\n\t\t\tthis._curve = new Float32Array(this.defaultArg(bufferLen, 1024));\n\t\t\tthis.setMap(mapping);\n\t\t} \n\t};\n\n\tTone.extend(Tone.WaveShaper, Tone.SignalBase);\n\n\t/**\n\t * Uses a mapping function to set the value of the curve. \n\t * @param {function} mapping The function used to define the values. \n\t * The mapping function take two arguments: \n\t * the first is the value at the current position \n\t * which goes from -1 to 1 over the number of elements\n\t * in the curve array. The second argument is the array position. \n\t * @returns {Tone.WaveShaper} this\n\t * @example\n\t * //map the input signal from [-1, 1] to [0, 10]\n\t * shaper.setMap(function(val, index){\n\t * \treturn (val + 1) * 5;\n\t * })\n\t */\n\tTone.WaveShaper.prototype.setMap = function(mapping){\n\t\tfor (var i = 0, len = this._curve.length; i < len; i++){\n\t\t\tvar normalized = (i / (len - 1)) * 2 - 1;\n\t\t\tthis._curve[i] = mapping(normalized, i);\n\t\t}\n\t\tthis._shaper.curve = this._curve;\n\t\treturn this;\n\t};\n\n\t/**\n\t * The array to set as the waveshaper curve. For linear curves\n\t * array length does not make much difference, but for complex curves\n\t * longer arrays will provide smoother interpolation. \n\t * @memberOf Tone.WaveShaper#\n\t * @type {Array}\n\t * @name curve\n\t */\n\tObject.defineProperty(Tone.WaveShaper.prototype, \"curve\", {\n\t\tget : function(){\n\t\t\treturn this._shaper.curve;\n\t\t},\n\t\tset : function(mapping){\n\t\t\tthis._curve = new Float32Array(mapping);\n\t\t\tthis._shaper.curve = this._curve;\n\t\t}\n\t});\n\n\t/**\n\t * Specifies what type of oversampling (if any) should be used when \n\t * applying the shaping curve. Can either be \"none\", \"2x\" or \"4x\". \n\t * @memberOf Tone.WaveShaper#\n\t * @type {string}\n\t * @name oversample\n\t */\n\tObject.defineProperty(Tone.WaveShaper.prototype, \"oversample\", {\n\t\tget : function(){\n\t\t\treturn this._shaper.oversample;\n\t\t},\n\t\tset : function(oversampling){\n\t\t\tif ([\"none\", \"2x\", \"4x\"].indexOf(oversampling) !== -1){\n\t\t\t\tthis._shaper.oversample = oversampling;\n\t\t\t} else {\n\t\t\t\tthrow new RangeError(\"Tone.WaveShaper: oversampling must be either 'none', '2x', or '4x'\");\n\t\t\t}\n\t\t}\n\t});\n\n\t/**\n\t * Clean up.\n\t * @returns {Tone.WaveShaper} this\n\t */\n\tTone.WaveShaper.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._shaper.disconnect();\n\t\tthis._shaper = null;\n\t\tthis._curve = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.WaveShaper;\n});","define([\"Tone/core/Tone\", \"Tone/signal/Signal\", \"Tone/core/Gain\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Add a signal and a number or two signals. When no value is\n\t * passed into the constructor, Tone.Add will sum input[0]\n\t * and input[1]. If a value is passed into the constructor, \n\t * the it will be added to the input.\n\t * \n\t * @constructor\n\t * @extends {Tone.Signal}\n\t * @param {number=} value If no value is provided, Tone.Add will sum the first\n\t * and second inputs. \n\t * @example\n\t * var signal = new Tone.Signal(2);\n\t * var add = new Tone.Add(2);\n\t * signal.connect(add);\n\t * //the output of add equals 4\n\t * @example\n\t * //if constructed with no arguments\n\t * //it will add the first and second inputs\n\t * var add = new Tone.Add();\n\t * var sig0 = new Tone.Signal(3).connect(add, 0, 0);\n\t * var sig1 = new Tone.Signal(4).connect(add, 0, 1);\n\t * //the output of add equals 7. \n\t */\n\tTone.Add = function(value){\n\n\t\tthis.createInsOuts(2, 0);\n\n\t\t/**\n\t\t * the summing node\n\t\t * @type {GainNode}\n\t\t * @private\n\t\t */\n\t\tthis._sum = this.input[0] = this.input[1] = this.output = new Tone.Gain();\n\n\t\t/**\n\t\t * @private\n\t\t * @type {Tone.Signal}\n\t\t */\n\t\tthis._param = this.input[1] = new Tone.Signal(value);\n\n\t\tthis._param.connect(this._sum);\n\t};\n\n\tTone.extend(Tone.Add, Tone.Signal);\n\t\n\t/**\n\t * Clean up.\n\t * @returns {Tone.Add} this\n\t */\n\tTone.Add.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._sum.dispose();\n\t\tthis._sum = null;\n\t\tthis._param.dispose();\n\t\tthis._param = null;\n\t\treturn this;\n\t}; \n\n\treturn Tone.Add;\n});","define([\"Tone/core/Tone\", \"Tone/type/Time\", \"Tone/type/Frequency\", \"Tone/type/TransportTime\", \"Tone/core/Context\"],\nfunction (Tone) {\t\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tTYPES\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Units which a value can take on.\n\t * @enum {String}\n\t */\n\tTone.Type = {\n\t\t/** \n\t\t * Default units\n\t\t * @typedef {Default}\n\t\t */\n\t\tDefault : \"number\",\n\t\t/**\n\t\t * Time can be described in a number of ways. Read more [Time](https://github.com/Tonejs/Tone.js/wiki/Time).\n\t\t *\n\t\t *
    \n\t\t *
  • Numbers, which will be taken literally as the time (in seconds).
    • \n\t\t *
  • Notation, (\"4n\", \"8t\") describes time in BPM and time signature relative values.
    • \n\t\t *
  • TransportTime, (\"4:3:2\") will also provide tempo and time signature relative times \n\t\t * in the form BARS:QUARTERS:SIXTEENTHS.
    • \n\t\t *
  • Frequency, (\"8hz\") is converted to the length of the cycle in seconds.
    • \n\t\t *
  • Now-Relative, (\"+1\") prefix any of the above with \"+\" and it will be interpreted as \n\t\t * \"the current time plus whatever expression follows\".
    • \n\t\t *
  • Expressions, (\"3:0 + 2 - (1m / 7)\") any of the above can also be combined \n\t\t * into a mathematical expression which will be evaluated to compute the desired time.
    • \n\t\t *
  • No Argument, for methods which accept time, no argument will be interpreted as \n\t\t * \"now\" (i.e. the currentTime).
    • \n\t\t *
\n\t\t * \n\t\t * @typedef {Time}\n\t\t */\n\t\tTime : \"time\",\n\t\t/**\n\t\t * Frequency can be described similar to time, except ultimately the\n\t\t * values are converted to frequency instead of seconds. A number\n\t\t * is taken literally as the value in hertz. Additionally any of the \n\t\t * Time encodings can be used. Note names in the form\n\t\t * of NOTE OCTAVE (i.e. C4) are also accepted and converted to their\n\t\t * frequency value. \n\t\t * @typedef {Frequency}\n\t\t */\n\t\tFrequency : \"frequency\",\n\t\t/**\n\t\t * TransportTime describes a position along the Transport's timeline. It is\n\t\t * similar to Time in that it uses all the same encodings, but TransportTime specifically\n\t\t * pertains to the Transport's timeline, which is startable, stoppable, loopable, and seekable. \n\t\t * [Read more](https://github.com/Tonejs/Tone.js/wiki/TransportTime)\n\t\t * @typedef {TransportTime}\n\t\t */\n\t\tTransportTime : \"transportTime\",\n\t\t/** \n\t\t * Ticks are the basic subunit of the Transport. They are\n\t\t * the smallest unit of time that the Transport supports.\n\t\t * @typedef {Ticks}\n\t\t */\n\t\tTicks : \"ticks\",\n\t\t/** \n\t\t * Normal values are within the range [0, 1].\n\t\t * @typedef {NormalRange}\n\t\t */\n\t\tNormalRange : \"normalRange\",\n\t\t/** \n\t\t * AudioRange values are between [-1, 1].\n\t\t * @typedef {AudioRange}\n\t\t */\n\t\tAudioRange : \"audioRange\",\n\t\t/** \n\t\t * Decibels are a logarithmic unit of measurement which is useful for volume\n\t\t * because of the logarithmic way that we perceive loudness. 0 decibels \n\t\t * means no change in volume. -10db is approximately half as loud and 10db \n\t\t * is twice is loud. \n\t\t * @typedef {Decibels}\n\t\t */\n\t\tDecibels : \"db\",\n\t\t/** \n\t\t * Half-step note increments, i.e. 12 is an octave above the root. and 1 is a half-step up.\n\t\t * @typedef {Interval}\n\t\t */\n\t\tInterval : \"interval\",\n\t\t/** \n\t\t * Beats per minute. \n\t\t * @typedef {BPM}\n\t\t */\n\t\tBPM : \"bpm\",\n\t\t/** \n\t\t * The value must be greater than or equal to 0.\n\t\t * @typedef {Positive}\n\t\t */\n\t\tPositive : \"positive\",\n\t\t/** \n\t\t * A cent is a hundredth of a semitone. \n\t\t * @typedef {Cents}\n\t\t */\n\t\tCents : \"cents\",\n\t\t/** \n\t\t * Angle between 0 and 360. \n\t\t * @typedef {Degrees}\n\t\t */\n\t\tDegrees : \"degrees\",\n\t\t/** \n\t\t * A number representing a midi note.\n\t\t * @typedef {MIDI}\n\t\t */\n\t\tMIDI : \"midi\",\n\t\t/** \n\t\t * A colon-separated representation of time in the form of\n\t\t * Bars:Beats:Sixteenths. \n\t\t * @typedef {BarsBeatsSixteenths}\n\t\t */\n\t\tBarsBeatsSixteenths : \"barsBeatsSixteenths\",\n\t\t/** \n\t\t * Sampling is the reduction of a continuous signal to a discrete signal.\n\t\t * Audio is typically sampled 44100 times per second. \n\t\t * @typedef {Samples}\n\t\t */\n\t\tSamples : \"samples\",\n\t\t/** \n\t\t * Hertz are a frequency representation defined as one cycle per second.\n\t\t * @typedef {Hertz}\n\t\t */\n\t\tHertz : \"hertz\",\n\t\t/** \n\t\t * A frequency represented by a letter name, \n\t\t * accidental and octave. This system is known as\n\t\t * [Scientific Pitch Notation](https://en.wikipedia.org/wiki/Scientific_pitch_notation).\n\t\t * @typedef {Note}\n\t\t */\n\t\tNote : \"note\",\n\t\t/** \n\t\t * One millisecond is a thousandth of a second. \n\t\t * @typedef {Milliseconds}\n\t\t */\n\t\tMilliseconds : \"milliseconds\",\n\t\t/** \n\t\t * Seconds are the time unit of the AudioContext. In the end, \n\t\t * all values need to be evaluated to seconds. \n\t\t * @typedef {Seconds}\n\t\t */\n\t\tSeconds : \"seconds\",\n\t\t/** \n\t\t * A string representing a duration relative to a measure. \n\t\t *
    \n\t\t * \t
  • \"4n\" = quarter note
    • \n\t\t * \t
  • \"2m\" = two measures
    • \n\t\t * \t
  • \"8t\" = eighth-note triplet
    • \n\t\t *
\n\t\t * @typedef {Notation}\n\t\t */\n\t\tNotation : \"notation\",\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t// AUGMENT TONE's PROTOTYPE\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Convert Time into seconds.\n\t * \n\t * Unlike the method which it overrides, this takes into account \n\t * transporttime and musical notation.\n\t *\n\t * Time : 1.40\n\t * Notation: 4n|1m|2t\n\t * Now Relative: +3n\n\t * Math: 3n+16n or even complicated expressions ((3n*2)/6 + 1)\n\t *\n\t * @param {Time} time \n\t * @return {Seconds} \n\t */\n\tTone.prototype.toSeconds = function(time){\n\t\tif (this.isNumber(time)){\n\t\t\treturn time;\n\t\t} else if (this.isUndef(time)){\n\t\t\treturn this.now();\t\t\t\n\t\t} else if (this.isString(time)){\n\t\t\treturn (new Tone.Time(time)).toSeconds();\n\t\t} else if (time instanceof Tone.TimeBase){\n\t\t\treturn time.toSeconds();\n\t\t}\n\t};\n\n\t/**\n\t * Convert a frequency representation into a number.\n\t * @param {Frequency} freq \n\t * @return {Hertz} the frequency in hertz\n\t */\n\tTone.prototype.toFrequency = function(freq){\n\t\tif (this.isNumber(freq)){\n\t\t\treturn freq;\n\t\t} else if (this.isString(freq) || this.isUndef(freq)){\n\t\t\treturn (new Tone.Frequency(freq)).valueOf();\n\t\t} else if (freq instanceof Tone.TimeBase){\n\t\t\treturn freq.toFrequency();\n\t\t}\n\t};\n\n\t/**\n\t * Convert a time representation into ticks.\n\t * @param {Time} time\n\t * @return {Ticks} the time in ticks\n\t */\n\tTone.prototype.toTicks = function(time){\n\t\tif (this.isNumber(time) || this.isString(time)){\n\t\t\treturn (new Tone.TransportTime(time)).toTicks();\n\t\t} else if (this.isUndef(time)){\n\t\t\treturn Tone.Transport.ticks;\t\t\t\n\t\t} else if (time instanceof Tone.TimeBase){\n\t\t\treturn time.toTicks();\n\t\t}\n\t};\n\n\treturn Tone;\n});","define([\"Tone/core/Tone\", \"Tone/core/Param\", \"Tone/type/Type\"], function (Tone) {\n\n\t\"use strict\";\n\n\t/**\n\t * createGain shim\n\t * @private\n\t */\n\tif (window.GainNode && !AudioContext.prototype.createGain){\n\t\tAudioContext.prototype.createGain = AudioContext.prototype.createGainNode;\n\t}\n\n\t/**\n\t * @class A thin wrapper around the Native Web Audio GainNode.\n\t * The GainNode is a basic building block of the Web Audio\n\t * API and is useful for routing audio and adjusting gains. \n\t * @extends {Tone}\n\t * @param {Number=} gain The initial gain of the GainNode\n\t * @param {Tone.Type=} units The units of the gain parameter. \n\t */\n\tTone.Gain = function(){\n\n\t\tvar options = this.optionsObject(arguments, [\"gain\", \"units\"], Tone.Gain.defaults);\n\n\t\t/**\n\t\t * The GainNode\n\t\t * @type {GainNode}\n\t\t * @private\n\t\t */\n\t\tthis.input = this.output = this._gainNode = this.context.createGain();\n\n\t\t/**\n\t\t * The gain parameter of the gain node.\n\t\t * @type {Tone.Param}\n\t\t * @signal\n\t\t */\n\t\tthis.gain = new Tone.Param({\n\t\t\t\"param\" : this._gainNode.gain, \n\t\t\t\"units\" : options.units,\n\t\t\t\"value\" : options.gain,\n\t\t\t\"convert\" : options.convert\n\t\t});\n\t\tthis._readOnly(\"gain\");\n\t};\n\n\tTone.extend(Tone.Gain);\n\n\t/**\n\t * The defaults\n\t * @const\n\t * @type {Object}\n\t */\n\tTone.Gain.defaults = {\n\t\t\"gain\" : 1,\n\t\t\"convert\" : true,\n\t};\n\n\t/**\n\t * Clean up.\n\t * @return {Tone.Gain} this\n\t */\n\tTone.Gain.prototype.dispose = function(){\n\t\tTone.Param.prototype.dispose.call(this);\n\t\tthis._gainNode.disconnect();\n\t\tthis._gainNode = null;\n\t\tthis._writable(\"gain\");\n\t\tthis.gain.dispose();\n\t\tthis.gain = null;\n\t};\n\n\t//STATIC///////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Create input and outputs for this object.\n\t * @param {Number} input The number of inputs\n\t * @param {Number=} outputs The number of outputs\n\t * @return {Tone} this\n\t * @internal\n\t */\n\tTone.prototype.createInsOuts = function(inputs, outputs){\n\n\t\tif (inputs === 1){\n\t\t\tthis.input = new Tone.Gain();\n\t\t} else if (inputs > 1){\n\t\t\tthis.input = new Array(inputs);\n\t\t}\n\n\t\tif (outputs === 1){\n\t\t\tthis.output = new Tone.Gain();\n\t\t} else if (outputs > 1){\n\t\t\tthis.output = new Array(inputs);\n\t\t}\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\n\treturn Tone.Gain;\n});","module.exports = {\n recorderProcessor: 'recorder-processor',\n soundFileProcessor: 'sound-file-processor',\n amplitudeProcessor: 'amplitude-processor'\n};\n","'use strict';\n\ndefine(function () {\n /*\n Helper function to generate an error\n with a custom stack trace that points to the sketch\n and removes other parts of the stack trace.\n\n @private\n @class customError\n @constructor\n @param {String} name custom error name\n @param {String} errorTrace custom error trace\n @param {String} failedPath path to the file that failed to load\n @property {String} name custom error name\n @property {String} message custom error message\n @property {String} stack trace the error back to a line in the user's sketch.\n Note: this edits out stack trace within p5.js and p5.sound.\n @property {String} originalStack unedited, original stack trace\n @property {String} failedPath path to the file that failed to load\n @return {Error} returns a custom Error object\n */\n var CustomError = function(name, errorTrace, failedPath) {\n var err = new Error();\n var tempStack, splitStack;\n\n err.name = name;\n err.originalStack = err.stack + errorTrace;\n tempStack = err.stack + errorTrace;\n err.failedPath = failedPath;\n\n // only print the part of the stack trace that refers to the user code:\n var splitStack = tempStack.split('\\n');\n splitStack = splitStack.filter(function(ln) {\n return !ln.match(/(p5.|native code|globalInit)/g);\n });\n err.stack = splitStack.join('\\n');\n\n return err; // TODO: is this really a constructor?\n };\n\n return CustomError;\n});\n","define([\"Tone/core/Tone\", \"Tone/core/Emitter\"], function (Tone) {\n\n\t/**\n\t * shim\n\t * @private\n\t */\n\tif (!window.hasOwnProperty(\"AudioContext\") && window.hasOwnProperty(\"webkitAudioContext\")){\n\t\twindow.AudioContext = window.webkitAudioContext;\n\t}\n\n\t/**\n\t * @class Wrapper around the native AudioContext.\n\t * @extends {Tone.Emitter}\n\t * @param {AudioContext=} context optionally pass in a context\n\t */\n\tTone.Context = function(context){\n\n\t\tTone.Emitter.call(this);\n\n\t\tif (!context){\n\t\t\tcontext = new window.AudioContext();\n\t\t}\n\t\tthis._context = context;\n\t\t// extend all of the methods\n\t\tfor (var prop in this._context){\n\t\t\tthis._defineProperty(this._context, prop);\n\t\t}\n\n\t\t///////////////////////////////////////////////////////////////////////\n\t\t// WORKER\n\t\t///////////////////////////////////////////////////////////////////////\n\n\t\t/**\n\t\t * The default latency hint\n\t\t * @type {String}\n\t\t * @private\n\t\t */\n\t\tthis._latencyHint = \"interactive\";\n\n\t\t/**\n\t\t * The amount of time events are scheduled\n\t\t * into the future\n\t\t * @type {Number}\n\t\t * @private\n\t\t */\n\t\tthis._lookAhead = 0.1;\n\n\t\t/**\n\t\t * How often the update look runs\n\t\t * @type {Number}\n\t\t * @private\n\t\t */\n\t\tthis._updateInterval = this._lookAhead/3;\n\n\t\t/**\n\t\t * A reference to the actual computed update interval\n\t\t * @type {Number}\n\t\t * @private\n\t\t */\n\t\tthis._computedUpdateInterval = 0;\n\n\t\t/**\n\t\t * The web worker which is used to update Tone.Clock\n\t\t * @private\n\t\t * @type {WebWorker}\n\t\t */\n\t\tthis._worker = this._createWorker();\n\n\t\t/**\n\t\t * An object containing all of the constants AudioBufferSourceNodes\n\t\t * @type {Object}\n\t\t * @private\n\t\t */\n\t\tthis._constants = {};\n\n\t};\n\n\tTone.extend(Tone.Context, Tone.Emitter);\n\tTone.Emitter.mixin(Tone.Context);\n\n\t/**\n\t * Define a property on this Tone.Context. \n\t * This is used to extend the native AudioContext\n\t * @param {AudioContext} context\n\t * @param {String} prop \n\t * @private\n\t */\n\tTone.Context.prototype._defineProperty = function(context, prop){\n\t\tif (this.isUndef(this[prop])){\n\t\t\tObject.defineProperty(this, prop, {\n\t\t\t\tget : function(){\n\t\t\t\t\tif (typeof context[prop] === \"function\"){\n\t\t\t\t\t\treturn context[prop].bind(context);\n\t\t\t\t\t} else {\n\t\t\t\t\t\treturn context[prop];\n\t\t\t\t\t}\n\t\t\t\t},\n\t\t\t\tset : function(val){\n\t\t\t\t\tcontext[prop] = val;\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\t};\n\n\t/**\n\t * The current audio context time\n\t * @return {Number}\n\t */\n\tTone.Context.prototype.now = function(){\n\t\treturn this._context.currentTime;\n\t};\n\n\t/**\n\t * Generate a web worker\n\t * @return {WebWorker}\n\t * @private\n\t */\n\tTone.Context.prototype._createWorker = function(){\n\t\t\n\t\t//URL Shim\n\t\twindow.URL = window.URL || window.webkitURL;\n\n\t\tvar blob = new Blob([\n\t\t\t//the initial timeout time\n\t\t\t\"var timeoutTime = \"+(this._updateInterval * 1000).toFixed(1)+\";\" +\n\t\t\t//onmessage callback\n\t\t\t\"self.onmessage = function(msg){\" +\n\t\t\t\"\ttimeoutTime = parseInt(msg.data);\" + \n\t\t\t\"};\" + \n\t\t\t//the tick function which posts a message\n\t\t\t//and schedules a new tick\n\t\t\t\"function tick(){\" +\n\t\t\t\"\tsetTimeout(tick, timeoutTime);\" +\n\t\t\t\"\tself.postMessage('tick');\" +\n\t\t\t\"}\" +\n\t\t\t//call tick initially\n\t\t\t\"tick();\"\n\t\t]);\n\t\tvar blobUrl = URL.createObjectURL(blob);\n\t\tvar worker = new Worker(blobUrl);\n\n\t\tworker.addEventListener(\"message\", function(){\n\t\t\t// tick the clock\n\t\t\tthis.emit(\"tick\");\n\t\t}.bind(this));\n\n\t\t//lag compensation\n\t\tworker.addEventListener(\"message\", function(){\n\t\t\tvar now = this.now();\n\t\t\tif (this.isNumber(this._lastUpdate)){\n\t\t\t\tvar diff = now - this._lastUpdate;\n\t\t\t\tthis._computedUpdateInterval = Math.max(diff, this._computedUpdateInterval * 0.97);\n\t\t\t}\n\t\t\tthis._lastUpdate = now;\n\t\t}.bind(this));\n\n\t\treturn worker;\n\t};\n\n\t/**\n\t * Generate a looped buffer at some constant value.\n\t * @param {Number} val\n\t * @return {BufferSourceNode}\n\t */\n\tTone.Context.prototype.getConstant = function(val){\n\t\tif (this._constants[val]){\n\t\t\treturn this._constants[val];\n\t\t} else {\n\t\t\tvar buffer = this._context.createBuffer(1, 128, this._context.sampleRate);\n\t\t\tvar arr = buffer.getChannelData(0);\n\t\t\tfor (var i = 0; i < arr.length; i++){\n\t\t\t\tarr[i] = val;\n\t\t\t}\n\t\t\tvar constant = this._context.createBufferSource();\n\t\t\tconstant.channelCount = 1;\n\t\t\tconstant.channelCountMode = \"explicit\";\n\t\t\tconstant.buffer = buffer;\n\t\t\tconstant.loop = true;\n\t\t\tconstant.start(0);\n\t\t\tthis._constants[val] = constant;\n\t\t\treturn constant;\n\t\t}\n\t};\n\n\t/**\n\t * This is the time that the clock is falling behind\n\t * the scheduled update interval. The Context automatically\n\t * adjusts for the lag and schedules further in advance.\n\t * @type {Number}\n\t * @memberOf Tone.Context\n\t * @name lag\n\t * @static\n\t * @readOnly\n\t */\n\tObject.defineProperty(Tone.Context.prototype, \"lag\", {\n\t\tget : function(){\n\t\t\tvar diff = this._computedUpdateInterval - this._updateInterval;\n\t\t\tdiff = Math.max(diff, 0);\n\t\t\treturn diff;\n\t\t}\n\t});\n\n\t/**\n\t * The amount of time in advance that events are scheduled.\n\t * The lookAhead will adjust slightly in response to the \n\t * measured update time to try to avoid clicks.\n\t * @type {Number}\n\t * @memberOf Tone.Context\n\t * @name lookAhead\n\t * @static\n\t */\n\tObject.defineProperty(Tone.Context.prototype, \"lookAhead\", {\n\t\tget : function(){\n\t\t\treturn this._lookAhead;\n\t\t},\n\t\tset : function(lA){\n\t\t\tthis._lookAhead = lA;\n\t\t}\n\t});\n\n\t/**\n\t * How often the Web Worker callback is invoked.\n\t * This number corresponds to how responsive the scheduling\n\t * can be. Context.updateInterval + Context.lookAhead gives you the\n\t * total latency between scheduling an event and hearing it.\n\t * @type {Number}\n\t * @memberOf Tone.Context\n\t * @name updateInterval\n\t * @static\n\t */\n\tObject.defineProperty(Tone.Context.prototype, \"updateInterval\", {\n\t\tget : function(){\n\t\t\treturn this._updateInterval;\n\t\t},\n\t\tset : function(interval){\n\t\t\tthis._updateInterval = Math.max(interval, Tone.prototype.blockTime);\n\t\t\tthis._worker.postMessage(Math.max(interval * 1000, 1));\n\t\t}\n\t});\n\n\t/**\n\t * The type of playback, which affects tradeoffs between audio \n\t * output latency and responsiveness. \n\t * \n\t * In addition to setting the value in seconds, the latencyHint also\n\t * accepts the strings \"interactive\" (prioritizes low latency), \n\t * \"playback\" (prioritizes sustained playback), \"balanced\" (balances\n\t * latency and performance), and \"fastest\" (lowest latency, might glitch more often). \n\t * @type {String|Seconds}\n\t * @memberOf Tone.Context#\n\t * @name latencyHint\n\t * @static\n\t * @example\n\t * //set the lookAhead to 0.3 seconds\n\t * Tone.context.latencyHint = 0.3;\n\t */\n\tObject.defineProperty(Tone.Context.prototype, \"latencyHint\", {\n\t\tget : function(){\n\t\t\treturn this._latencyHint;\n\t\t},\n\t\tset : function(hint){\n\t\t\tvar lookAhead = hint;\n\t\t\tthis._latencyHint = hint;\n\t\t\tif (this.isString(hint)){\n\t\t\t\tswitch(hint){\n\t\t\t\t\tcase \"interactive\" :\n\t\t\t\t\t\tlookAhead = 0.1;\n\t\t\t\t\t\tthis._context.latencyHint = hint;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase \"playback\" :\n\t\t\t\t\t\tlookAhead = 0.8;\n\t\t\t\t\t\tthis._context.latencyHint = hint;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase \"balanced\" :\n\t\t\t\t\t\tlookAhead = 0.25;\n\t\t\t\t\t\tthis._context.latencyHint = hint;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase \"fastest\" :\n\t\t\t\t\t\tlookAhead = 0.01;\n\t\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis.lookAhead = lookAhead;\n\t\t\tthis.updateInterval = lookAhead/3;\n\t\t}\n\t});\n\n\t/**\n\t * Shim all connect/disconnect and some deprecated methods which are still in\n\t * some older implementations.\n\t * @private\n\t */\n\tfunction shimConnect(){\n\n\t\tvar nativeConnect = AudioNode.prototype.connect;\n\t\tvar nativeDisconnect = AudioNode.prototype.disconnect;\n\n\t\t//replace the old connect method\n\t\tfunction toneConnect(B, outNum, inNum){\n\t\t\tif (B.input){\n\t\t\t\tif (Array.isArray(B.input)){\n\t\t\t\t\tif (Tone.prototype.isUndef(inNum)){\n\t\t\t\t\t\tinNum = 0;\n\t\t\t\t\t}\n\t\t\t\t\tthis.connect(B.input[inNum]);\n\t\t\t\t} else {\n\t\t\t\t\tthis.connect(B.input, outNum, inNum);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\ttry {\n\t\t\t\t\tif (B instanceof AudioNode){\n\t\t\t\t\t\tnativeConnect.call(this, B, outNum, inNum);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tnativeConnect.call(this, B, outNum);\n\t\t\t\t\t}\n\t\t\t\t} catch (e) {\n\t\t\t\t\tthrow new Error(\"error connecting to node: \"+B+\"\\n\"+e);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t//replace the old disconnect method\n\t\tfunction toneDisconnect(B, outNum, inNum){\n\t\t\tif (B && B.input && Array.isArray(B.input)){\n\t\t\t\tif (Tone.prototype.isUndef(inNum)){\n\t\t\t\t\tinNum = 0;\n\t\t\t\t}\n\t\t\t\tthis.disconnect(B.input[inNum], outNum, inNum);\n\t\t\t} else if (B && B.input){\n\t\t\t\tthis.disconnect(B.input, outNum, inNum);\n\t\t\t} else {\n\t\t\t\ttry {\n\t\t\t\t\tnativeDisconnect.apply(this, arguments);\n\t\t\t\t} catch (e) {\n\t\t\t\t\tthrow new Error(\"error disconnecting node: \"+B+\"\\n\"+e);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif (AudioNode.prototype.connect !== toneConnect){\n\t\t\tAudioNode.prototype.connect = toneConnect;\n\t\t\tAudioNode.prototype.disconnect = toneDisconnect;\n\t\t}\n\t}\n\n\t// set the audio context initially\n\tif (Tone.supported){\n\t\tshimConnect();\n\t\tTone.context = new Tone.Context();\n\t} else {\n\t\tconsole.warn(\"This browser does not support Tone.js\");\n\t}\n\n\treturn Tone.Context;\n});","define([\"Tone/core/Tone\", \"Tone/signal/Add\", \"Tone/signal/Multiply\", \"Tone/signal/Signal\"], function(Tone){\n\n\t\"use strict\";\n\t\n\t/**\n\t * @class Performs a linear scaling on an input signal.\n\t * Scales a NormalRange input to between\n\t * outputMin and outputMax.\n\t *\n\t * @constructor\n\t * @extends {Tone.SignalBase}\n\t * @param {number} [outputMin=0] The output value when the input is 0. \n\t * @param {number} [outputMax=1]\tThe output value when the input is 1. \n\t * @example\n\t * var scale = new Tone.Scale(50, 100);\n\t * var signal = new Tone.Signal(0.5).connect(scale);\n\t * //the output of scale equals 75\n\t */\n\tTone.Scale = function(outputMin, outputMax){\n\n\t\t/** \n\t\t * @private\n\t\t * @type {number}\n\t\t */\n\t\tthis._outputMin = this.defaultArg(outputMin, 0);\n\n\t\t/** \n\t\t * @private\n\t\t * @type {number}\n\t\t */\n\t\tthis._outputMax = this.defaultArg(outputMax, 1);\n\n\n\t\t/** \n\t\t * @private\n\t\t * @type {Tone.Multiply}\n\t\t * @private\n\t\t */\n\t\tthis._scale = this.input = new Tone.Multiply(1);\n\t\t\n\t\t/** \n\t\t * @private\n\t\t * @type {Tone.Add}\n\t\t * @private\n\t\t */\n\t\tthis._add = this.output = new Tone.Add(0);\n\n\t\tthis._scale.connect(this._add);\n\t\tthis._setRange();\n\t};\n\n\tTone.extend(Tone.Scale, Tone.SignalBase);\n\n\t/**\n\t * The minimum output value. This number is output when \n\t * the value input value is 0. \n\t * @memberOf Tone.Scale#\n\t * @type {number}\n\t * @name min\n\t */\n\tObject.defineProperty(Tone.Scale.prototype, \"min\", {\n\t\tget : function(){\n\t\t\treturn this._outputMin;\n\t\t},\n\t\tset : function(min){\n\t\t\tthis._outputMin = min;\n\t\t\tthis._setRange();\n\t\t}\n\t});\n\n\t/**\n\t * The maximum output value. This number is output when \n\t * the value input value is 1. \n\t * @memberOf Tone.Scale#\n\t * @type {number}\n\t * @name max\n\t */\n\tObject.defineProperty(Tone.Scale.prototype, \"max\", {\n\t\tget : function(){\n\t\t\treturn this._outputMax;\n\t\t},\n\t\tset : function(max){\n\t\t\tthis._outputMax = max;\n\t\t\tthis._setRange();\n\t\t}\n\t});\n\n\t/**\n\t * set the values\n\t * @private\n\t */\n\tTone.Scale.prototype._setRange = function() {\n\t\tthis._add.value = this._outputMin;\n\t\tthis._scale.value = this._outputMax - this._outputMin;\n\t};\n\n\t/**\n\t * Clean up.\n\t * @returns {Tone.Scale} this\n\t */\n\tTone.Scale.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._add.dispose();\n\t\tthis._add = null;\n\t\tthis._scale.dispose();\n\t\tthis._scale = null;\n\t\treturn this;\n\t}; \n\n\treturn Tone.Scale;\n});\n","define([\"Tone/core/Tone\", \"Tone/signal/Signal\", \"Tone/core/Timeline\"], function (Tone) {\n\n\t\"use strict\";\n\n\t/**\n\t * @class A signal which adds the method getValueAtTime. \n\t * Code and inspiration from https://github.com/jsantell/web-audio-automation-timeline\n\t * @extends {Tone.Param}\n\t * @param {Number=} value The initial value of the signal\n\t * @param {String=} units The conversion units of the signal.\n\t */\n\tTone.TimelineSignal = function(){\n\n\t\tvar options = this.optionsObject(arguments, [\"value\", \"units\"], Tone.Signal.defaults);\n\t\t\n\t\t/**\n\t\t * The scheduled events\n\t\t * @type {Tone.Timeline}\n\t\t * @private\n\t\t */\n\t\tthis._events = new Tone.Timeline(10);\n\n\t\t//constructors\n\t\tTone.Signal.apply(this, options);\n\t\toptions.param = this._param;\n\t\tTone.Param.call(this, options);\n\n\t\t/**\n\t\t * The initial scheduled value\n\t\t * @type {Number}\n\t\t * @private\n\t\t */\n\t\tthis._initial = this._fromUnits(this._param.value);\n\t};\n\n\tTone.extend(Tone.TimelineSignal, Tone.Param);\n\n\t/**\n\t * The event types of a schedulable signal.\n\t * @enum {String}\n\t * @private\n\t */\n\tTone.TimelineSignal.Type = {\n\t\tLinear : \"linear\",\n\t\tExponential : \"exponential\",\n\t\tTarget : \"target\",\n\t\tCurve : \"curve\",\n\t\tSet : \"set\"\n\t};\n\n\t/**\n\t * The current value of the signal. \n\t * @memberOf Tone.TimelineSignal#\n\t * @type {Number}\n\t * @name value\n\t */\n\tObject.defineProperty(Tone.TimelineSignal.prototype, \"value\", {\n\t\tget : function(){\n\t\t\tvar now = this.now();\n\t\t\tvar val = this.getValueAtTime(now);\n\t\t\treturn this._toUnits(val);\n\t\t},\n\t\tset : function(value){\n\t\t\tvar convertedVal = this._fromUnits(value);\n\t\t\tthis._initial = convertedVal;\n\t\t\tthis.cancelScheduledValues();\n\t\t\tthis._param.value = convertedVal;\n\t\t}\n\t});\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tSCHEDULING\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Schedules a parameter value change at the given time.\n\t * @param {*}\tvalue The value to set the signal.\n\t * @param {Time} time The time when the change should occur.\n\t * @returns {Tone.TimelineSignal} this\n\t * @example\n\t * //set the frequency to \"G4\" in exactly 1 second from now. \n\t * freq.setValueAtTime(\"G4\", \"+1\");\n\t */\n\tTone.TimelineSignal.prototype.setValueAtTime = function (value, startTime) {\n\t\tvalue = this._fromUnits(value);\n\t\tstartTime = this.toSeconds(startTime);\n\t\tthis._events.add({\n\t\t\t\"type\" : Tone.TimelineSignal.Type.Set,\n\t\t\t\"value\" : value,\n\t\t\t\"time\" : startTime\n\t\t});\n\t\t//invoke the original event\n\t\tthis._param.setValueAtTime(value, startTime);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Schedules a linear continuous change in parameter value from the \n\t * previous scheduled parameter value to the given value.\n\t * \n\t * @param {number} value \n\t * @param {Time} endTime \n\t * @returns {Tone.TimelineSignal} this\n\t */\n\tTone.TimelineSignal.prototype.linearRampToValueAtTime = function (value, endTime) {\n\t\tvalue = this._fromUnits(value);\n\t\tendTime = this.toSeconds(endTime);\n\t\tthis._events.add({\n\t\t\t\"type\" : Tone.TimelineSignal.Type.Linear,\n\t\t\t\"value\" : value,\n\t\t\t\"time\" : endTime\n\t\t});\n\t\tthis._param.linearRampToValueAtTime(value, endTime);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Schedules an exponential continuous change in parameter value from \n\t * the previous scheduled parameter value to the given value.\n\t * \n\t * @param {number} value \n\t * @param {Time} endTime \n\t * @returns {Tone.TimelineSignal} this\n\t */\n\tTone.TimelineSignal.prototype.exponentialRampToValueAtTime = function (value, endTime) {\n\t\t//get the previous event and make sure it's not starting from 0\n\t\tendTime = this.toSeconds(endTime);\n\t\tvar beforeEvent = this._searchBefore(endTime);\n\t\tif (beforeEvent && beforeEvent.value === 0){\n\t\t\t//reschedule that event\n\t\t\tthis.setValueAtTime(this._minOutput, beforeEvent.time);\n\t\t}\n\t\tvalue = this._fromUnits(value);\n\t\tvar setValue = Math.max(value, this._minOutput);\n\t\tthis._events.add({\n\t\t\t\"type\" : Tone.TimelineSignal.Type.Exponential,\n\t\t\t\"value\" : setValue,\n\t\t\t\"time\" : endTime\n\t\t});\n\t\t//if the ramped to value is 0, make it go to the min output, and then set to 0.\n\t\tif (value < this._minOutput){\n\t\t\tthis._param.exponentialRampToValueAtTime(this._minOutput, endTime - this.sampleTime);\n\t\t\tthis.setValueAtTime(0, endTime);\n\t\t} else {\n\t\t\tthis._param.exponentialRampToValueAtTime(value, endTime);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Start exponentially approaching the target value at the given time with\n\t * a rate having the given time constant.\n\t * @param {number} value \n\t * @param {Time} startTime \n\t * @param {number} timeConstant \n\t * @returns {Tone.TimelineSignal} this \n\t */\n\tTone.TimelineSignal.prototype.setTargetAtTime = function (value, startTime, timeConstant) {\n\t\tvalue = this._fromUnits(value);\n\t\tvalue = Math.max(this._minOutput, value);\n\t\ttimeConstant = Math.max(this._minOutput, timeConstant);\n\t\tstartTime = this.toSeconds(startTime);\n\t\tthis._events.add({\n\t\t\t\"type\" : Tone.TimelineSignal.Type.Target,\n\t\t\t\"value\" : value,\n\t\t\t\"time\" : startTime,\n\t\t\t\"constant\" : timeConstant\n\t\t});\n\t\tthis._param.setTargetAtTime(value, startTime, timeConstant);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Set an array of arbitrary values starting at the given time for the given duration.\n\t * @param {Float32Array} values \n\t * @param {Time} startTime \n\t * @param {Time} duration\n\t * @param {NormalRange} [scaling=1] If the values in the curve should be scaled by some value\n\t * @returns {Tone.TimelineSignal} this \n\t */\n\tTone.TimelineSignal.prototype.setValueCurveAtTime = function (values, startTime, duration, scaling) {\n\t\tscaling = this.defaultArg(scaling, 1);\n\t\t//copy the array\n\t\tvar floats = new Array(values.length);\n\t\tfor (var i = 0; i < floats.length; i++){\n\t\t\tfloats[i] = this._fromUnits(values[i]) * scaling;\n\t\t}\n\t\tstartTime = this.toSeconds(startTime);\n\t\tduration = this.toSeconds(duration);\n\t\tthis._events.add({\n\t\t\t\"type\" : Tone.TimelineSignal.Type.Curve,\n\t\t\t\"value\" : floats,\n\t\t\t\"time\" : startTime,\n\t\t\t\"duration\" : duration\n\t\t});\n\t\t//set the first value\n\t\tthis._param.setValueAtTime(floats[0], startTime);\n\t\t//schedule a lienar ramp for each of the segments\n\t\tfor (var j = 1; j < floats.length; j++){\n\t\t\tvar segmentTime = startTime + (j / (floats.length - 1) * duration);\n\t\t\tthis._param.linearRampToValueAtTime(floats[j], segmentTime);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Cancels all scheduled parameter changes with times greater than or \n\t * equal to startTime.\n\t * \n\t * @param {Time} startTime\n\t * @returns {Tone.TimelineSignal} this\n\t */\n\tTone.TimelineSignal.prototype.cancelScheduledValues = function (after) {\n\t\tafter = this.toSeconds(after);\n\t\tthis._events.cancel(after);\n\t\tthis._param.cancelScheduledValues(after);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Sets the computed value at the given time. This provides\n\t * a point from which a linear or exponential curve\n\t * can be scheduled after. Will cancel events after \n\t * the given time and shorten the currently scheduled\n\t * linear or exponential ramp so that it ends at `time` .\n\t * This is to avoid discontinuities and clicks in envelopes. \n\t * @param {Time} time When to set the ramp point\n\t * @returns {Tone.TimelineSignal} this\n\t */\n\tTone.TimelineSignal.prototype.setRampPoint = function (time) {\n\t\ttime = this.toSeconds(time);\n\t\t//get the value at the given time\n\t\tvar val = this._toUnits(this.getValueAtTime(time));\n\t\t//if there is an event at the given time\n\t\t//and that even is not a \"set\"\n\t\tvar before = this._searchBefore(time);\n\t\tif (before && before.time === time){\n\t\t\t//remove everything after\n\t\t\tthis.cancelScheduledValues(time + this.sampleTime);\n\t\t} else if (before && \n\t\t\t\t before.type === Tone.TimelineSignal.Type.Curve &&\n\t\t\t\t before.time + before.duration > time){\n\t\t\t//if the curve is still playing\n\t\t\t//cancel the curve\n\t\t\tthis.cancelScheduledValues(time);\n\t\t\tthis.linearRampToValueAtTime(val, time);\n\t\t} else {\n\t\t\t//reschedule the next event to end at the given time\n\t\t\tvar after = this._searchAfter(time);\n\t\t\tif (after){\n\t\t\t\t//cancel the next event(s)\n\t\t\t\tthis.cancelScheduledValues(time);\n\t\t\t\tif (after.type === Tone.TimelineSignal.Type.Linear){\n\t\t\t\t\tthis.linearRampToValueAtTime(val, time);\n\t\t\t\t} else if (after.type === Tone.TimelineSignal.Type.Exponential){\n\t\t\t\t\tthis.exponentialRampToValueAtTime(val, time);\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis.setValueAtTime(val, time);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Do a linear ramp to the given value between the start and finish times.\n\t * @param {Number} value The value to ramp to.\n\t * @param {Time} start The beginning anchor point to do the linear ramp\n\t * @param {Time} finish The ending anchor point by which the value of\n\t * the signal will equal the given value.\n\t * @returns {Tone.TimelineSignal} this\n\t */\n\tTone.TimelineSignal.prototype.linearRampToValueBetween = function (value, start, finish) {\n\t\tthis.setRampPoint(start);\n\t\tthis.linearRampToValueAtTime(value, finish);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Do a exponential ramp to the given value between the start and finish times.\n\t * @param {Number} value The value to ramp to.\n\t * @param {Time} start The beginning anchor point to do the exponential ramp\n\t * @param {Time} finish The ending anchor point by which the value of\n\t * the signal will equal the given value.\n\t * @returns {Tone.TimelineSignal} this\n\t */\n\tTone.TimelineSignal.prototype.exponentialRampToValueBetween = function (value, start, finish) {\n\t\tthis.setRampPoint(start);\n\t\tthis.exponentialRampToValueAtTime(value, finish);\n\t\treturn this;\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tGETTING SCHEDULED VALUES\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Returns the value before or equal to the given time\n\t * @param {Number} time The time to query\n\t * @return {Object} The event at or before the given time.\n\t * @private\n\t */\n\tTone.TimelineSignal.prototype._searchBefore = function(time){\n\t\treturn this._events.get(time);\n\t};\n\n\t/**\n\t * The event after the given time\n\t * @param {Number} time The time to query.\n\t * @return {Object} The next event after the given time\n\t * @private\n\t */\n\tTone.TimelineSignal.prototype._searchAfter = function(time){\n\t\treturn this._events.getAfter(time);\n\t};\n\n\t/**\n\t * Get the scheduled value at the given time. This will\n\t * return the unconverted (raw) value.\n\t * @param {Number} time The time in seconds.\n\t * @return {Number} The scheduled value at the given time.\n\t */\n\tTone.TimelineSignal.prototype.getValueAtTime = function(time){\n\t\ttime = this.toSeconds(time);\n\t\tvar after = this._searchAfter(time);\n\t\tvar before = this._searchBefore(time);\n\t\tvar value = this._initial;\n\t\t//if it was set by\n\t\tif (before === null){\n\t\t\tvalue = this._initial;\n\t\t} else if (before.type === Tone.TimelineSignal.Type.Target){\n\t\t\tvar previous = this._events.getBefore(before.time);\n\t\t\tvar previouVal;\n\t\t\tif (previous === null){\n\t\t\t\tpreviouVal = this._initial;\n\t\t\t} else {\n\t\t\t\tpreviouVal = previous.value;\n\t\t\t}\n\t\t\tvalue = this._exponentialApproach(before.time, previouVal, before.value, before.constant, time);\n\t\t} else if (before.type === Tone.TimelineSignal.Type.Curve){\n\t\t\tvalue = this._curveInterpolate(before.time, before.value, before.duration, time);\n\t\t} else if (after === null){\n\t\t\tvalue = before.value;\n\t\t} else if (after.type === Tone.TimelineSignal.Type.Linear){\n\t\t\tvalue = this._linearInterpolate(before.time, before.value, after.time, after.value, time);\n\t\t} else if (after.type === Tone.TimelineSignal.Type.Exponential){\n\t\t\tvalue = this._exponentialInterpolate(before.time, before.value, after.time, after.value, time);\n\t\t} else {\n\t\t\tvalue = before.value;\n\t\t}\n\t\treturn value;\n\t};\n\n\t/**\n\t * When signals connect to other signals or AudioParams, \n\t * they take over the output value of that signal or AudioParam. \n\t * For all other nodes, the behavior is the same as a default connect. \n\t *\n\t * @override\n\t * @param {AudioParam|AudioNode|Tone.Signal|Tone} node \n\t * @param {number} [outputNumber=0] The output number to connect from.\n\t * @param {number} [inputNumber=0] The input number to connect to.\n\t * @returns {Tone.TimelineSignal} this\n\t * @method\n\t */\n\tTone.TimelineSignal.prototype.connect = Tone.SignalBase.prototype.connect;\n\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tAUTOMATION CURVE CALCULATIONS\n\t//\tMIT License, copyright (c) 2014 Jordan Santell\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Calculates the the value along the curve produced by setTargetAtTime\n\t * @private\n\t */\n\tTone.TimelineSignal.prototype._exponentialApproach = function (t0, v0, v1, timeConstant, t) {\n\t\treturn v1 + (v0 - v1) * Math.exp(-(t - t0) / timeConstant);\n\t};\n\n\t/**\n\t * Calculates the the value along the curve produced by linearRampToValueAtTime\n\t * @private\n\t */\n\tTone.TimelineSignal.prototype._linearInterpolate = function (t0, v0, t1, v1, t) {\n\t\treturn v0 + (v1 - v0) * ((t - t0) / (t1 - t0));\n\t};\n\n\t/**\n\t * Calculates the the value along the curve produced by exponentialRampToValueAtTime\n\t * @private\n\t */\n\tTone.TimelineSignal.prototype._exponentialInterpolate = function (t0, v0, t1, v1, t) {\n\t\tv0 = Math.max(this._minOutput, v0);\n\t\treturn v0 * Math.pow(v1 / v0, (t - t0) / (t1 - t0));\n\t};\n\n\t/**\n\t * Calculates the the value along the curve produced by setValueCurveAtTime\n\t * @private\n\t */\n\tTone.TimelineSignal.prototype._curveInterpolate = function (start, curve, duration, time) {\n\t\tvar len = curve.length;\n\t\t// If time is after duration, return the last curve value\n\t\tif (time >= start + duration) {\n\t\t\treturn curve[len - 1];\n\t\t} else if (time <= start){\n\t\t\treturn curve[0];\n\t\t} else {\n\t\t\tvar progress = (time - start) / duration;\n\t\t\tvar lowerIndex = Math.floor((len - 1) * progress);\n\t\t\tvar upperIndex = Math.ceil((len - 1) * progress);\n\t\t\tvar lowerVal = curve[lowerIndex];\n\t\t\tvar upperVal = curve[upperIndex];\n\t\t\tif (upperIndex === lowerIndex){\n\t\t\t\treturn lowerVal;\n\t\t\t} else {\n\t\t\t\treturn this._linearInterpolate(lowerIndex, lowerVal, upperIndex, upperVal, progress * (len - 1));\n\t\t\t}\n\t\t}\n\t};\n\n\t/**\n\t * Clean up.\n\t * @return {Tone.TimelineSignal} this\n\t */\n\tTone.TimelineSignal.prototype.dispose = function(){\n\t\tTone.Signal.prototype.dispose.call(this);\n\t\tTone.Param.prototype.dispose.call(this);\n\t\tthis._events.dispose();\n\t\tthis._events = null;\n\t};\n\n\treturn Tone.TimelineSignal;\n});","'use strict';\n\ndefine(function (require) {\n var Effect = require('effect');\n\n /**\n *

A p5.Filter uses a Web Audio Biquad Filter to filter\n * the frequency response of an input source. Subclasses\n * include:

\n * p5.LowPass:\n * Allows frequencies below the cutoff frequency to pass through,\n * and attenuates frequencies above the cutoff.
\n * p5.HighPass:\n * The opposite of a lowpass filter.
\n * p5.BandPass:\n * Allows a range of frequencies to pass through and attenuates\n * the frequencies below and above this frequency range.
\n *\n * The .res() method controls either width of the\n * bandpass, or resonance of the low/highpass cutoff frequency.\n *\n * This class extends p5.Effect.\n * Methods amp(), chain(),\n * drywet(), connect(), and\n * disconnect() are available.\n *\n * @class p5.Filter\n * @extends p5.Effect\n * @constructor\n * @param {String} [type] 'lowpass' (default), 'highpass', 'bandpass'\n * @example\n *
\n * let fft, noise, filter;\n *\n * function setup() {\n * let cnv = createCanvas(100,100);\n * cnv.mousePressed(makeNoise);\n * fill(255, 0, 255);\n *\n * filter = new p5.BandPass();\n * noise = new p5.Noise();\n * noise.disconnect();\n * noise.connect(filter);\n *\n * fft = new p5.FFT();\n * }\n *\n * function draw() {\n * background(220);\n *\n * // set the BandPass frequency based on mouseX\n * let freq = map(mouseX, 0, width, 20, 10000);\n * freq = constrain(freq, 0, 22050);\n * filter.freq(freq);\n * // give the filter a narrow band (lower res = wider bandpass)\n * filter.res(50);\n *\n * // draw filtered spectrum\n * let spectrum = fft.analyze();\n * noStroke();\n * for (let i = 0; i < spectrum.length; i++) {\n * let x = map(i, 0, spectrum.length, 0, width);\n * let h = -height + map(spectrum[i], 0, 255, height, 0);\n * rect(x, height, width/spectrum.length, h);\n * }\n * if (!noise.started) {\n * text('tap here and drag to change frequency', 10, 20, width - 20);\n * } else {\n * text('Frequency: ' + round(freq)+'Hz', 20, 20, width - 20);\n * }\n * }\n *\n * function makeNoise() {\n * // see also: `userStartAudio()`\n * noise.start();\n * noise.amp(0.5, 0.2);\n * }\n *\n * function mouseReleased() {\n * noise.amp(0, 0.2);\n * }\n *\n *
\n */\n p5.Filter = function (type) {\n\n Effect.call(this);\n //add extend Effect by adding a Biquad Filter\n\n /**\n * The p5.Filter is built with a\n * \n * Web Audio BiquadFilter Node.\n *\n * @property {DelayNode} biquadFilter\n\t */\n\n this.biquad = this.ac.createBiquadFilter();\n\n this.input.connect(this.biquad);\n\n this.biquad.connect(this.wet);\n\n if (type) {\n this.setType(type);\n }\n\n //Properties useful for the toggle method.\n this._on = true;\n this._untoggledType = this.biquad.type;\n };\n p5.Filter.prototype = Object.create(Effect.prototype);\n\n\n /**\n * Filter an audio signal according to a set\n * of filter parameters.\n *\n * @method process\n * @param {Object} Signal An object that outputs audio\n * @param {Number} [freq] Frequency in Hz, from 10 to 22050\n * @param {Number} [res] Resonance/Width of the filter frequency\n * from 0.001 to 1000\n */\n p5.Filter.prototype.process = function(src, freq, res, time) {\n src.connect(this.input);\n this.set(freq, res, time);\n };\n\n\n /**\n * Set the frequency and the resonance of the filter.\n *\n * @method set\n * @param {Number} [freq] Frequency in Hz, from 10 to 22050\n * @param {Number} [res] Resonance (Q) from 0.001 to 1000\n * @param {Number} [timeFromNow] schedule this event to happen\n * seconds from now\n */\n p5.Filter.prototype.set = function(freq, res, time) {\n if (freq) {\n this.freq(freq, time);\n }\n if (res) {\n this.res(res, time);\n }\n };\n\n /**\n * Set the filter frequency, in Hz, from 10 to 22050 (the range of\n * human hearing, although in reality most people hear in a narrower\n * range).\n *\n * @method freq\n * @param {Number} freq Filter Frequency\n * @param {Number} [timeFromNow] schedule this event to happen\n * seconds from now\n * @return {Number} value Returns the current frequency value\n */\n p5.Filter.prototype.freq = function(freq, time) {\n var t = time || 0;\n if (freq <= 0) {\n freq = 1;\n }\n if (typeof freq === 'number') {\n this.biquad.frequency.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.biquad.frequency.exponentialRampToValueAtTime(freq, this.ac.currentTime + 0.02 + t);\n } else if (freq) {\n freq.connect(this.biquad.frequency);\n }\n return this.biquad.frequency.value;\n };\n\n /**\n * Controls either width of a bandpass frequency,\n * or the resonance of a low/highpass cutoff frequency.\n *\n * @method res\n * @param {Number} res Resonance/Width of filter freq\n * from 0.001 to 1000\n * @param {Number} [timeFromNow] schedule this event to happen\n * seconds from now\n * @return {Number} value Returns the current res value\n */\n p5.Filter.prototype.res = function(res, time) {\n var t = time || 0;\n if (typeof res === 'number') {\n this.biquad.Q.value = res;\n this.biquad.Q.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.biquad.Q.linearRampToValueAtTime(res, this.ac.currentTime + 0.02 + t);\n } else if (res) {\n res.connect(this.biquad.Q);\n }\n return this.biquad.Q.value;\n };\n\n /**\n * Controls the gain attribute of a Biquad Filter.\n * This is distinctly different from .amp() which is inherited from p5.Effect\n * .amp() controls the volume via the output gain node\n * p5.Filter.gain() controls the gain parameter of a Biquad Filter node.\n *\n * @method gain\n * @param {Number} gain\n * @return {Number} Returns the current or updated gain value\n */\n p5.Filter.prototype.gain = function(gain, time) {\n var t = time || 0;\n if (typeof gain === 'number') {\n this.biquad.gain.value = gain;\n this.biquad.gain.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.biquad.gain.linearRampToValueAtTime(gain, this.ac.currentTime + 0.02 + t);\n } else if (gain) {\n gain.connect(this.biquad.gain);\n }\n return this.biquad.gain.value;\n };\n\n\n /**\n * Toggle function. Switches between the specified type and allpass\n *\n * @method toggle\n * @return {boolean} [Toggle value]\n */\n p5.Filter.prototype.toggle = function() {\n this._on = !this._on;\n\n if (this._on === true) {\n this.biquad.type = this._untoggledType;\n } else if (this._on === false) {\n this.biquad.type = 'allpass';\n }\n\n return this._on;\n };\n\n /**\n * Set the type of a p5.Filter. Possible types include:\n * \"lowpass\" (default), \"highpass\", \"bandpass\",\n * \"lowshelf\", \"highshelf\", \"peaking\", \"notch\",\n * \"allpass\".\n *\n * @method setType\n * @param {String} t\n */\n p5.Filter.prototype.setType = function(t) {\n this.biquad.type = t;\n this._untoggledType = this.biquad.type;\n };\n\n p5.Filter.prototype.dispose = function() {\n // remove reference from soundArray\n Effect.prototype.dispose.apply(this);\n if (this.biquad) {\n this.biquad.disconnect();\n delete this.biquad;\n }\n };\n\n /**\n * Constructor: new p5.LowPass() Filter.\n * This is the same as creating a p5.Filter and then calling\n * its method setType('lowpass').\n * See p5.Filter for methods.\n *\n * @class p5.LowPass\n * @constructor\n * @extends p5.Filter\n */\n p5.LowPass = function() {\n p5.Filter.call(this, 'lowpass');\n };\n p5.LowPass.prototype = Object.create(p5.Filter.prototype);\n\n /**\n * Constructor: new p5.HighPass() Filter.\n * This is the same as creating a p5.Filter and then calling\n * its method setType('highpass').\n * See p5.Filter for methods.\n *\n * @class p5.HighPass\n * @constructor\n * @extends p5.Filter\n */\n p5.HighPass = function() {\n p5.Filter.call(this, 'highpass');\n };\n p5.HighPass.prototype = Object.create(p5.Filter.prototype);\n\n /**\n * Constructor: new p5.BandPass() Filter.\n * This is the same as creating a p5.Filter and then calling\n * its method setType('bandpass').\n * See p5.Filter for methods.\n *\n * @class p5.BandPass\n * @constructor\n * @extends p5.Filter\n */\n p5.BandPass = function() {\n p5.Filter.call(this, 'bandpass');\n };\n p5.BandPass.prototype = Object.create(p5.Filter.prototype);\n\n return p5.Filter;\n});\n","define([\"Tone/core/Tone\", \"Tone/signal/Add\", \"Tone/signal/Negate\", \"Tone/signal/Signal\", \"Tone/core/Gain\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Subtract the signal connected to input[1] from the signal connected \n\t * to input[0]. If an argument is provided in the constructor, the \n\t * signals .value will be subtracted from the incoming signal.\n\t *\n\t * @extends {Tone.Signal}\n\t * @constructor\n\t * @param {number=} value The value to subtract from the incoming signal. If the value\n\t * is omitted, it will subtract the second signal from the first.\n\t * @example\n\t * var sub = new Tone.Subtract(1);\n\t * var sig = new Tone.Signal(4).connect(sub);\n\t * //the output of sub is 3. \n\t * @example\n\t * var sub = new Tone.Subtract();\n\t * var sigA = new Tone.Signal(10);\n\t * var sigB = new Tone.Signal(2.5);\n\t * sigA.connect(sub, 0, 0);\n\t * sigB.connect(sub, 0, 1);\n\t * //output of sub is 7.5\n\t */\n\tTone.Subtract = function(value){\n\n\t\tthis.createInsOuts(2, 0);\n\n\t\t/**\n\t\t * the summing node\n\t\t * @type {GainNode}\n\t\t * @private\n\t\t */\n\t\tthis._sum = this.input[0] = this.output = new Tone.Gain();\n\n\t\t/**\n\t\t * negate the input of the second input before connecting it\n\t\t * to the summing node.\n\t\t * @type {Tone.Negate}\n\t\t * @private\n\t\t */\n\t\tthis._neg = new Tone.Negate();\n\n\t\t/**\n\t\t * the node where the value is set\n\t\t * @private\n\t\t * @type {Tone.Signal}\n\t\t */\n\t\tthis._param = this.input[1] = new Tone.Signal(value);\n\n\t\tthis._param.chain(this._neg, this._sum);\n\t};\n\n\tTone.extend(Tone.Subtract, Tone.Signal);\n\n\t/**\n\t * Clean up.\n\t * @returns {Tone.SignalBase} this\n\t */\n\tTone.Subtract.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._neg.dispose();\n\t\tthis._neg = null;\n\t\tthis._sum.disconnect();\n\t\tthis._sum = null;\n\t\tthis._param.dispose();\n\t\tthis._param = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.Subtract;\n});","'use strict';\n\nglobal.TONE_SILENCE_VERSION_LOGGING = true;\n\ndefine(['startaudiocontext', 'Tone/core/Context', 'Tone/core/Tone'], function (StartAudioContext, Context, Tone) {\n // Create the Audio Context\n const audiocontext = new window.AudioContext();\n\n // Tone and p5.sound share the same audio context\n Tone.context.dispose();\n Tone.setContext(audiocontext);\n\n /**\n *

Returns the Audio Context for this sketch. Useful for users\n * who would like to dig deeper into the Web Audio API\n * .

\n *\n *

Some browsers require users to startAudioContext\n * with a user gesture, such as touchStarted in the example below.

\n *\n * @for p5\n * @method getAudioContext\n * @return {Object} AudioContext for this sketch\n * @example\n *
\n * function draw() {\n * background(255);\n * textAlign(CENTER);\n *\n * if (getAudioContext().state !== 'running') {\n * text('click to start audio', width/2, height/2);\n * } else {\n * text('audio is enabled', width/2, height/2);\n * }\n * }\n *\n * function touchStarted() {\n * if (getAudioContext().state !== 'running') {\n * getAudioContext().resume();\n * }\n * var synth = new p5.MonoSynth();\n * synth.play('A4', 0.5, 0, 0.2);\n * }\n *\n *
\n */\n p5.prototype.getAudioContext = function() {\n return audiocontext;\n };\n\n\n /**\n *

It is not only a good practice to give users control over starting\n * audio. This policy is enforced by many web browsers, including iOS and\n * Google Chrome, which create the Web Audio API's\n * Audio Context\n * in a suspended state.

\n *\n *

In these browser-specific policies, sound will not play until a user\n * interaction event (i.e. mousePressed()) explicitly resumes\n * the AudioContext, or starts an audio node. This can be accomplished by\n * calling start() on a p5.Oscillator,\n * play() on a p5.SoundFile, or simply\n * userStartAudio().

\n *\n *

userStartAudio() starts the AudioContext on a user\n * gesture. The default behavior will enable audio on any\n * mouseUp or touchEnd event. It can also be placed in a specific\n * interaction function, such as mousePressed() as in the\n * example below. This method utilizes\n * StartAudioContext\n * , a library by Yotam Mann (MIT Licence, 2016).

\n * @param {Element|Array} [element(s)] This argument can be an Element,\n * Selector String, NodeList, p5.Element,\n * jQuery Element, or an Array of any of those.\n * @param {Function} [callback] Callback to invoke when the AudioContext\n * has started\n * @return {Promise} Returns a Promise that resolves when\n * the AudioContext state is 'running'\n * @method userStartAudio\n * @for p5\n * @example\n *
\n * function setup() {\n * // mimics the autoplay policy\n * getAudioContext().suspend();\n *\n * let mySynth = new p5.MonoSynth();\n *\n * // This won't play until the context has resumed\n * mySynth.play('A6');\n * }\n * function draw() {\n * background(220);\n * textAlign(CENTER, CENTER);\n * text(getAudioContext().state, width/2, height/2);\n * }\n * function mousePressed() {\n * userStartAudio();\n * }\n *
\n */\n p5.prototype.userStartAudio = function(elements, callback) {\n var elt = elements;\n if (elements instanceof p5.Element) {\n elt = elements.elt;\n } else if (elements instanceof Array && elements[0] instanceof p5.Element ) {\n elt = elements.map(function(e) { return e.elt});\n }\n return StartAudioContext(audiocontext, elt, callback);\n };\n\n return audiocontext;\n});\n","define([\"Tone/core/Tone\"], function (Tone) {\n\n\t\"use strict\";\n\n\t/**\n\t * @class Tone.Emitter gives classes which extend it\n\t * the ability to listen for and emit events. \n\t * Inspiration and reference from Jerome Etienne's [MicroEvent](https://github.com/jeromeetienne/microevent.js).\n\t * MIT (c) 2011 Jerome Etienne.\n\t * \n\t * @extends {Tone}\n\t */\n\tTone.Emitter = function(){\n\t\t/**\n\t\t * Contains all of the events.\n\t\t * @private\n\t\t * @type {Object}\n\t\t */\n\t\tthis._events = {};\n\t};\n\n\tTone.extend(Tone.Emitter);\n\n\t/**\n\t * Bind a callback to a specific event.\n\t * @param {String} event The name of the event to listen for.\n\t * @param {Function} callback The callback to invoke when the\n\t * event is emitted\n\t * @return {Tone.Emitter} this\n\t */\n\tTone.Emitter.prototype.on = function(event, callback){\n\t\t//split the event\n\t\tvar events = event.split(/\\W+/);\n\t\tfor (var i = 0; i < events.length; i++){\n\t\t\tvar eventName = events[i];\n\t\t\tif (!this._events.hasOwnProperty(eventName)){\n\t\t\t\tthis._events[eventName] = [];\n\t\t\t}\n\t\t\tthis._events[eventName].push(callback);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Remove the event listener.\n\t * @param {String} event The event to stop listening to.\n\t * @param {Function=} callback The callback which was bound to \n\t * the event with Tone.Emitter.on.\n\t * If no callback is given, all callbacks\n\t * events are removed.\n\t * @return {Tone.Emitter} this\n\t */\n\tTone.Emitter.prototype.off = function(event, callback){\n\t\tvar events = event.split(/\\W+/);\n\t\tfor (var ev = 0; ev < events.length; ev++){\n\t\t\tevent = events[ev];\n\t\t\tif (this._events.hasOwnProperty(event)){\n\t\t\t\tif (Tone.prototype.isUndef(callback)){\n\t\t\t\t\tthis._events[event] = [];\n\t\t\t\t} else {\n\t\t\t\t\tvar eventList = this._events[event];\n\t\t\t\t\tfor (var i = 0; i < eventList.length; i++){\n\t\t\t\t\t\tif (eventList[i] === callback){\n\t\t\t\t\t\t\teventList.splice(i, 1);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Invoke all of the callbacks bound to the event\n\t * with any arguments passed in. \n\t * @param {String} event The name of the event.\n\t * @param {*...} args The arguments to pass to the functions listening.\n\t * @return {Tone.Emitter} this\n\t */\n\tTone.Emitter.prototype.emit = function(event){\n\t\tif (this._events){\n\t\t\tvar args = Array.apply(null, arguments).slice(1);\n\t\t\tif (this._events.hasOwnProperty(event)){\n\t\t\t\tvar eventList = this._events[event];\n\t\t\t\tfor (var i = 0, len = eventList.length; i < len; i++){\n\t\t\t\t\teventList[i].apply(this, args);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Add Emitter functions (on/off/emit) to the object\n\t * @param {Object|Function} object The object or class to extend.\n\t */\n\tTone.Emitter.mixin = function(object){\n\t\tvar functions = [\"on\", \"off\", \"emit\"];\n\t\tobject._events = {};\n\t\tfor (var i = 0; i < functions.length; i++){\n\t\t\tvar func = functions[i];\n\t\t\tvar emitterFunc = Tone.Emitter.prototype[func];\n\t\t\tobject[func] = emitterFunc;\n\t\t}\n\t};\n\n\t/**\n\t * Clean up\n\t * @return {Tone.Emitter} this\n\t */\n\tTone.Emitter.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._events = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.Emitter;\n});","define([\"Tone/core/Tone\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Base class for all Signals. Used Internally. \n\t *\n\t * @constructor\n\t * @extends {Tone}\n\t */\n\tTone.SignalBase = function(){};\n\n\tTone.extend(Tone.SignalBase);\n\n\t/**\n\t * When signals connect to other signals or AudioParams, \n\t * they take over the output value of that signal or AudioParam. \n\t * For all other nodes, the behavior is the same as a default connect. \n\t *\n\t * @override\n\t * @param {AudioParam|AudioNode|Tone.Signal|Tone} node \n\t * @param {number} [outputNumber=0] The output number to connect from.\n\t * @param {number} [inputNumber=0] The input number to connect to.\n\t * @returns {Tone.SignalBase} this\n\t */\n\tTone.SignalBase.prototype.connect = function(node, outputNumber, inputNumber){\n\t\t//zero it out so that the signal can have full control\n\t\tif ((Tone.Signal && Tone.Signal === node.constructor) || \n\t\t\t\t(Tone.Param && Tone.Param === node.constructor) || \n\t\t\t\t(Tone.TimelineSignal && Tone.TimelineSignal === node.constructor)){\n\t\t\t//cancel changes\n\t\t\tnode._param.cancelScheduledValues(0);\n\t\t\t//reset the value\n\t\t\tnode._param.value = 0;\n\t\t\t//mark the value as overridden\n\t\t\tnode.overridden = true;\n\t\t} else if (node instanceof AudioParam){\n\t\t\tnode.cancelScheduledValues(0);\n\t\t\tnode.value = 0;\n\t\t} \n\t\tTone.prototype.connect.call(this, node, outputNumber, inputNumber);\n\t\treturn this;\n\t};\n\n\treturn Tone.SignalBase;\n});","define([\"Tone/core/Tone\", \"Tone/type/TimeBase\"], function (Tone) {\n\n\t/**\n\t * @class Tone.Time is a primitive type for encoding Time values. \n\t * Eventually all time values are evaluated to seconds\n\t * using the `eval` method. Tone.Time can be constructed\n\t * with or without the `new` keyword. Tone.Time can be passed\n\t * into the parameter of any method which takes time as an argument. \n\t * @constructor\n\t * @extends {Tone.TimeBase}\n\t * @param {String|Number} val The time value.\n\t * @param {String=} units The units of the value.\n\t * @example\n\t * var t = Tone.Time(\"4n\");//encodes a quarter note\n\t * t.mult(4); // multiply that value by 4\n\t * t.toNotation(); //returns \"1m\"\n\t */\n\tTone.Time = function(val, units){\n\t\tif (this instanceof Tone.Time){\n\n\t\t\t/**\n\t\t\t * If the current clock time should\n\t\t\t * be added to the output\n\t\t\t * @type {Boolean}\n\t\t\t * @private\n\t\t\t */\n\t\t\tthis._plusNow = false;\n\t\t\t\n\t\t\tTone.TimeBase.call(this, val, units);\n\n\t\t} else {\n\t\t\treturn new Tone.Time(val, units);\n\t\t}\n\t};\n\n\tTone.extend(Tone.Time, Tone.TimeBase);\n\n\t//clone the expressions so that \n\t//we can add more without modifying the original\n\tTone.Time.prototype._unaryExpressions = Object.create(Tone.TimeBase.prototype._unaryExpressions);\n\n\t/*\n\t * Adds an additional unary expression\n\t * which quantizes values to the next subdivision\n\t * @type {Object}\n\t * @private\n\t */\n\tTone.Time.prototype._unaryExpressions.quantize = {\n\t\tregexp : /^@/,\n\t\tmethod : function(rh){\n\t\t\treturn Tone.Transport.nextSubdivision(rh());\n\t\t}\n\t};\n\n\t/*\n\t * Adds an additional unary expression\n\t * which adds the current clock time.\n\t * @type {Object}\n\t * @private\n\t */\n\tTone.Time.prototype._unaryExpressions.now = {\n\t\tregexp : /^\\+/,\n\t\tmethod : function(lh){\n\t\t\tthis._plusNow = true;\n\t\t\treturn lh();\n\t\t}\n\t};\n\n\t/**\n\t * Quantize the time by the given subdivision. Optionally add a\n\t * percentage which will move the time value towards the ideal\n\t * quantized value by that percentage. \n\t * @param {Number|Time} val The subdivision to quantize to\n\t * @param {NormalRange} [percent=1] Move the time value\n\t * towards the quantized value by\n\t * a percentage.\n\t * @return {Tone.Time} this\n\t * @example\n\t * Tone.Time(21).quantize(2) //returns 22\n\t * Tone.Time(0.6).quantize(\"4n\", 0.5) //returns 0.55\n\t */\n\tTone.Time.prototype.quantize = function(subdiv, percent){\n\t\tpercent = this.defaultArg(percent, 1);\n\t\tthis._expr = function(expr, subdivision, percent){\n\t\t\texpr = expr();\n\t\t\tsubdivision = subdivision.toSeconds();\n\t\t\tvar multiple = Math.round(expr / subdivision);\n\t\t\tvar ideal = multiple * subdivision;\n\t\t\tvar diff = ideal - expr;\n\t\t\treturn expr + diff * percent;\n\t\t}.bind(this, this._expr, new this.constructor(subdiv), percent);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Adds the clock time to the time expression at the \n\t * moment of evaluation. \n\t * @return {Tone.Time} this\n\t */\n\tTone.Time.prototype.addNow = function(){\n\t\tthis._plusNow = true;\n\t\treturn this;\n\t};\n\n\t/**\n\t * @override\n\t * Override the default value return when no arguments are passed in.\n\t * The default value is 'now'\n\t * @private\n\t */\n\tTone.Time.prototype._defaultExpr = function(){\n\t\tthis._plusNow = true;\n\t\treturn this._noOp;\n\t};\n\n\t/**\n\t * Copies the value of time to this Time\n\t * @param {Tone.Time} time\n\t * @return {Time}\n\t */\n\tTone.Time.prototype.copy = function(time){\n\t\tTone.TimeBase.prototype.copy.call(this, time);\n\t\tthis._plusNow = time._plusNow;\n\t\treturn this;\n\t};\n\n\t//CONVERSIONS//////////////////////////////////////////////////////////////\n\n\t/**\n\t * Convert a Time to Notation. Values will be thresholded to the nearest 128th note. \n\t * @return {Notation} \n\t * @example\n\t * //if the Transport is at 120bpm:\n\t * Tone.Time(2).toNotation();//returns \"1m\"\n\t */\n\tTone.Time.prototype.toNotation = function(){\n\t\tvar time = this.toSeconds();\n\t\tvar testNotations = [\"1m\", \"2n\", \"4n\", \"8n\", \"16n\", \"32n\", \"64n\", \"128n\"];\n\t\tvar retNotation = this._toNotationHelper(time, testNotations);\n\t\t//try the same thing but with tripelets\n\t\tvar testTripletNotations = [\"1m\", \"2n\", \"2t\", \"4n\", \"4t\", \"8n\", \"8t\", \"16n\", \"16t\", \"32n\", \"32t\", \"64n\", \"64t\", \"128n\"];\n\t\tvar retTripletNotation = this._toNotationHelper(time, testTripletNotations);\n\t\t//choose the simpler expression of the two\n\t\tif (retTripletNotation.split(\"+\").length < retNotation.split(\"+\").length){\n\t\t\treturn retTripletNotation;\n\t\t} else {\n\t\t\treturn retNotation;\n\t\t}\n\t};\n\n\t/**\n\t * Helper method for Tone.toNotation\n\t * @param {Number} units \n\t * @param {Array} testNotations\n\t * @return {String}\n\t * @private\n\t */\n\tTone.Time.prototype._toNotationHelper = function(units, testNotations){\n\t\t//the threshold is the last value in the array\n\t\tvar threshold = this._notationToUnits(testNotations[testNotations.length - 1]);\n\t\tvar retNotation = \"\";\n\t\tfor (var i = 0; i < testNotations.length; i++){\n\t\t\tvar notationTime = this._notationToUnits(testNotations[i]);\n\t\t\t//account for floating point errors (i.e. round up if the value is 0.999999)\n\t\t\tvar multiple = units / notationTime;\n\t\t\tvar floatingPointError = 0.000001;\n\t\t\tif (1 - multiple % 1 < floatingPointError){\n\t\t\t\tmultiple += floatingPointError;\n\t\t\t}\n\t\t\tmultiple = Math.floor(multiple);\n\t\t\tif (multiple > 0){\n\t\t\t\tif (multiple === 1){\n\t\t\t\t\tretNotation += testNotations[i];\n\t\t\t\t} else {\n\t\t\t\t\tretNotation += multiple.toString() + \"*\" + testNotations[i];\n\t\t\t\t}\n\t\t\t\tunits -= multiple * notationTime;\n\t\t\t\tif (units < threshold){\n\t\t\t\t\tbreak;\n\t\t\t\t} else {\n\t\t\t\t\tretNotation += \" + \";\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (retNotation === \"\"){\n\t\t\tretNotation = \"0\";\n\t\t}\n\t\treturn retNotation;\n\t};\n\n\t/**\n\t * Convert a notation value to the current units\n\t * @param {Notation} notation \n\t * @return {Number} \n\t * @private\n\t */\n\tTone.Time.prototype._notationToUnits = function(notation){\n\t\tvar primaryExprs = this._primaryExpressions;\n\t\tvar notationExprs = [primaryExprs.n, primaryExprs.t, primaryExprs.m];\n\t\tfor (var i = 0; i < notationExprs.length; i++){\n\t\t\tvar expr = notationExprs[i];\n\t\t\tvar match = notation.match(expr.regexp);\n\t\t\tif (match){\n\t\t\t\treturn expr.method.call(this, match[1]);\n\t\t\t}\n\t\t}\n\t};\n\n\t/**\n\t * Return the time encoded as Bars:Beats:Sixteenths.\n\t * @return {BarsBeatsSixteenths}\n\t */\n\tTone.Time.prototype.toBarsBeatsSixteenths = function(){\n\t\tvar quarterTime = this._beatsToUnits(1);\n\t\tvar quarters = this.toSeconds() / quarterTime;\n\t\tvar measures = Math.floor(quarters / this._timeSignature());\n\t\tvar sixteenths = (quarters % 1) * 4;\n\t\tquarters = Math.floor(quarters) % this._timeSignature();\n\t\tsixteenths = sixteenths.toString();\n\t\tif (sixteenths.length > 3){\n\t\t\tsixteenths = parseFloat(sixteenths).toFixed(3);\n\t\t}\n\t\tvar progress = [measures, quarters, sixteenths];\n\t\treturn progress.join(\":\");\n\t};\n\n\t/**\n\t * Return the time in ticks.\n\t * @return {Ticks}\n\t */\n\tTone.Time.prototype.toTicks = function(){\n\t\tvar quarterTime = this._beatsToUnits(1);\n\t\tvar quarters = this.valueOf() / quarterTime;\n\t\treturn Math.floor(quarters * Tone.Transport.PPQ);\n\t};\n\n\t/**\n\t * Return the time in samples\n\t * @return {Samples} \n\t */\n\tTone.Time.prototype.toSamples = function(){\n\t\treturn this.toSeconds() * this.context.sampleRate;\n\t};\n\n\t/**\n\t * Return the time as a frequency value\n\t * @return {Frequency} \n\t * @example\n\t * Tone.Time(2).toFrequency(); //0.5\n\t */\n\tTone.Time.prototype.toFrequency = function(){\n\t\treturn 1/this.toSeconds();\n\t};\n\n\t/**\n\t * Return the time in seconds.\n\t * @return {Seconds} \n\t */\n\tTone.Time.prototype.toSeconds = function(){\n\t\treturn this.valueOf();\n\t};\n\n\t/**\n\t * Return the time in milliseconds.\n\t * @return {Milliseconds} \n\t */\n\tTone.Time.prototype.toMilliseconds = function(){\n\t\treturn this.toSeconds() * 1000;\n\t};\n\n\t/**\n\t * Return the time in seconds.\n\t * @return {Seconds} \n\t */\n\tTone.Time.prototype.valueOf = function(){\n\t\tvar val = this._expr();\n\t\treturn val + (this._plusNow?this.now():0);\n\t};\n\n\treturn Tone.Time;\n});","define([\"Tone/core/Tone\"], function (Tone) {\n\n\t/**\n\t * @class Tone.TimeBase is a flexible encoding of time\n\t * which can be evaluated to and from a string.\n\t * Parsing code modified from https://code.google.com/p/tapdigit/\n\t * Copyright 2011 2012 Ariya Hidayat, New BSD License\n\t * @extends {Tone}\n\t * @param {Time} val The time value as a number or string\n\t * @param {String=} units Unit values\n\t * @example\n\t * Tone.TimeBase(4, \"n\")\n\t * Tone.TimeBase(2, \"t\")\n\t * Tone.TimeBase(\"2t\").add(\"1m\")\n\t * Tone.TimeBase(\"2t + 1m\");\n\t */\n\tTone.TimeBase = function(val, units){\n\n\t\t//allows it to be constructed with or without 'new'\n\t\tif (this instanceof Tone.TimeBase) {\n\n\t\t\t/**\n\t\t\t * Any expressions parsed from the Time\n\t\t\t * @type {Array}\n\t\t\t * @private\n\t\t\t */\n\t\t\tthis._expr = this._noOp;\n\n\t\t\tif (val instanceof Tone.TimeBase){\n\t\t\t\tthis.copy(val);\n\t\t\t} else if (!this.isUndef(units) || this.isNumber(val)){\n\t\t\t\t//default units\n\t\t\t\tunits = this.defaultArg(units, this._defaultUnits);\n\t\t\t\tvar method = this._primaryExpressions[units].method;\n\t\t\t\tthis._expr = method.bind(this, val);\n\t\t\t} else if (this.isString(val)){\n\t\t\t\tthis.set(val);\n\t\t\t} else if (this.isUndef(val)){\n\t\t\t\t//default expression\n\t\t\t\tthis._expr = this._defaultExpr();\n\t\t\t}\n\t\t} else {\n\n\t\t\treturn new Tone.TimeBase(val, units);\n\t\t}\n\t};\n\n\tTone.extend(Tone.TimeBase);\n\n\t/**\n\t * Repalce the current time value with the value\n\t * given by the expression string.\n\t * @param {String} exprString\n\t * @return {Tone.TimeBase} this\n\t */\n\tTone.TimeBase.prototype.set = function(exprString){\n\t\tthis._expr = this._parseExprString(exprString);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Return a clone of the TimeBase object.\n\t * @return {Tone.TimeBase} The new cloned Tone.TimeBase\n\t */\n\tTone.TimeBase.prototype.clone = function(){\n\t\tvar instance = new this.constructor();\n\t\tinstance.copy(this);\n\t\treturn instance;\n\t};\n\n\t/**\n\t * Copies the value of time to this Time\n\t * @param {Tone.TimeBase} time\n\t * @return {TimeBase}\n\t */\n\tTone.TimeBase.prototype.copy = function(time){\n\t\tvar val = time._expr();\n\t\treturn this.set(val);\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tABSTRACT SYNTAX TREE PARSER\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * All the primary expressions.\n\t * @private\n\t * @type {Object}\n\t */\n\tTone.TimeBase.prototype._primaryExpressions = {\n\t\t\"n\" : {\n\t\t\tregexp : /^(\\d+)n/i,\n\t\t\tmethod : function(value){\n\t\t\t\tvalue = parseInt(value);\n\t\t\t\tif (value === 1){\n\t\t\t\t\treturn this._beatsToUnits(this._timeSignature());\n\t\t\t\t} else {\n\t\t\t\t\treturn this._beatsToUnits(4 / value);\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\t\"t\" : {\n\t\t\tregexp : /^(\\d+)t/i,\n\t\t\tmethod : function(value){\n\t\t\t\tvalue = parseInt(value);\n\t\t\t\treturn this._beatsToUnits(8 / (parseInt(value) * 3));\n\t\t\t}\n\t\t},\n\t\t\"m\" : {\n\t\t\tregexp : /^(\\d+)m/i,\n\t\t\tmethod : function(value){\n\t\t\t\treturn this._beatsToUnits(parseInt(value) * this._timeSignature());\n\t\t\t}\n\t\t},\n\t\t\"i\" : {\n\t\t\tregexp : /^(\\d+)i/i,\n\t\t\tmethod : function(value){\n\t\t\t\treturn this._ticksToUnits(parseInt(value));\n\t\t\t}\n\t\t},\n\t\t\"hz\" : {\n\t\t\tregexp : /^(\\d+(?:\\.\\d+)?)hz/i,\n\t\t\tmethod : function(value){\n\t\t\t\treturn this._frequencyToUnits(parseFloat(value));\n\t\t\t}\n\t\t},\n\t\t\"tr\" : {\n\t\t\tregexp : /^(\\d+(?:\\.\\d+)?):(\\d+(?:\\.\\d+)?):?(\\d+(?:\\.\\d+)?)?/,\n\t\t\tmethod : function(m, q, s){\n\t\t\t\tvar total = 0;\n\t\t\t\tif (m && m !== \"0\"){\n\t\t\t\t\ttotal += this._beatsToUnits(this._timeSignature() * parseFloat(m));\n\t\t\t\t}\n\t\t\t\tif (q && q !== \"0\"){\n\t\t\t\t\ttotal += this._beatsToUnits(parseFloat(q));\n\t\t\t\t}\n\t\t\t\tif (s && s !== \"0\"){\n\t\t\t\t\ttotal += this._beatsToUnits(parseFloat(s) / 4);\n\t\t\t\t}\n\t\t\t\treturn total;\n\t\t\t}\n\t\t},\n\t\t\"s\" : {\n\t\t\tregexp : /^(\\d+(?:\\.\\d+)?s)/,\n\t\t\tmethod : function(value){\n\t\t\t\treturn this._secondsToUnits(parseFloat(value));\n\t\t\t}\n\t\t},\n\t\t\"samples\" : {\n\t\t\tregexp : /^(\\d+)samples/,\n\t\t\tmethod : function(value){\n\t\t\t\treturn parseInt(value) / this.context.sampleRate;\n\t\t\t}\n\t\t},\n\t\t\"default\" : {\n\t\t\tregexp : /^(\\d+(?:\\.\\d+)?)/,\n\t\t\tmethod : function(value){\n\t\t\t\treturn this._primaryExpressions[this._defaultUnits].method.call(this, value);\n\t\t\t}\n\t\t}\n\t};\n\n\t/**\n\t * All the binary expressions that TimeBase can accept.\n\t * @private\n\t * @type {Object}\n\t */\n\tTone.TimeBase.prototype._binaryExpressions = {\n\t\t\"+\" : {\n\t\t\tregexp : /^\\+/,\n\t\t\tprecedence : 2,\n\t\t\tmethod : function(lh, rh){\n\t\t\t\treturn lh() + rh();\n\t\t\t}\n\t\t},\n\t\t\"-\" : {\n\t\t\tregexp : /^\\-/,\n\t\t\tprecedence : 2,\n\t\t\tmethod : function(lh, rh){\n\t\t\t\treturn lh() - rh();\n\t\t\t}\n\t\t},\n\t\t\"*\" : {\n\t\t\tregexp : /^\\*/,\n\t\t\tprecedence : 1,\n\t\t\tmethod : function(lh, rh){\n\t\t\t\treturn lh() * rh();\n\t\t\t}\n\t\t},\n\t\t\"/\" : {\n\t\t\tregexp : /^\\//,\n\t\t\tprecedence : 1,\n\t\t\tmethod : function(lh, rh){\n\t\t\t\treturn lh() / rh();\n\t\t\t}\n\t\t}\n\t};\n\n\t/**\n\t * All the unary expressions.\n\t * @private\n\t * @type {Object}\n\t */\n\tTone.TimeBase.prototype._unaryExpressions = {\n\t\t\"neg\" : {\n\t\t\tregexp : /^\\-/,\n\t\t\tmethod : function(lh){\n\t\t\t\treturn -lh();\n\t\t\t}\n\t\t}\n\t};\n\n\t/**\n\t * Syntactic glue which holds expressions together\n\t * @private\n\t * @type {Object}\n\t */\n\tTone.TimeBase.prototype._syntaxGlue = {\n\t\t\"(\" : {\n\t\t\tregexp : /^\\(/\n\t\t},\n\t\t\")\" : {\n\t\t\tregexp : /^\\)/\n\t\t}\n\t};\n\n\t/**\n\t * tokenize the expression based on the Expressions object\n\t * @param {string} expr \n\t * @return {Object} returns two methods on the tokenized list, next and peek\n\t * @private\n\t */\n\tTone.TimeBase.prototype._tokenize = function(expr){\n\t\tvar position = -1;\n\t\tvar tokens = [];\n\n\t\twhile(expr.length > 0){\n\t\t\texpr = expr.trim();\n\t\t\tvar token = getNextToken(expr, this);\n\t\t\ttokens.push(token);\n\t\t\texpr = expr.substr(token.value.length);\n\t\t}\n\n\t\tfunction getNextToken(expr, context){\n\t\t\tvar expressions = [\"_binaryExpressions\", \"_unaryExpressions\", \"_primaryExpressions\", \"_syntaxGlue\"];\n\t\t\tfor (var i = 0; i < expressions.length; i++){\n\t\t\t\tvar group = context[expressions[i]];\n\t\t\t\tfor (var opName in group){\n\t\t\t\t\tvar op = group[opName];\n\t\t\t\t\tvar reg = op.regexp;\n\t\t\t\t\tvar match = expr.match(reg);\n\t\t\t\t\tif (match !== null){\n\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\tmethod : op.method,\n\t\t\t\t\t\t\tprecedence : op.precedence,\n\t\t\t\t\t\t\tregexp : op.regexp,\n\t\t\t\t\t\t\tvalue : match[0],\n\t\t\t\t\t\t};\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tthrow new SyntaxError(\"Tone.TimeBase: Unexpected token \"+expr);\n\t\t}\n\n\t\treturn {\n\t\t\tnext : function(){\n\t\t\t\treturn tokens[++position];\n\t\t\t},\n\t\t\tpeek : function(){\n\t\t\t\treturn tokens[position + 1];\n\t\t\t}\n\t\t};\n\t};\n\n\t/**\n\t * Given a token, find the value within the groupName\n\t * @param {Object} token\n\t * @param {String} groupName\n\t * @param {Number} precedence\n\t * @private\n\t */\n\tTone.TimeBase.prototype._matchGroup = function(token, group, prec) {\n\t\tvar ret = false;\n\t\tif (!this.isUndef(token)){\n\t\t\tfor (var opName in group){\n\t\t\t\tvar op = group[opName];\n\t\t\t\tif (op.regexp.test(token.value)){\n\t\t\t\t\tif (!this.isUndef(prec)){\n\t\t\t\t\t\tif(op.precedence === prec){\t\n\t\t\t\t\t\t\treturn op;\n\t\t\t\t\t\t}\n\t\t\t\t\t} else {\n\t\t\t\t\t\treturn op;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn ret;\n\t};\n\n\t/**\n\t * Match a binary expression given the token and the precedence\n\t * @param {Lexer} lexer\n\t * @param {Number} precedence\n\t * @private\n\t */\n\tTone.TimeBase.prototype._parseBinary = function(lexer, precedence){\n\t\tif (this.isUndef(precedence)){\n\t\t\tprecedence = 2;\n\t\t}\n\t\tvar expr;\n\t\tif (precedence < 0){\n\t\t\texpr = this._parseUnary(lexer);\n\t\t} else {\n\t\t\texpr = this._parseBinary(lexer, precedence - 1);\n\t\t}\n\t\tvar token = lexer.peek();\n\t\twhile (token && this._matchGroup(token, this._binaryExpressions, precedence)){\n\t\t\ttoken = lexer.next();\n\t\t\texpr = token.method.bind(this, expr, this._parseBinary(lexer, precedence - 1));\n\t\t\ttoken = lexer.peek();\n\t\t}\n\t\treturn expr;\n\t};\n\n\t/**\n\t * Match a unary expression.\n\t * @param {Lexer} lexer\n\t * @private\n\t */\n\tTone.TimeBase.prototype._parseUnary = function(lexer){\n\t\tvar token, expr;\n\t\ttoken = lexer.peek();\n\t\tvar op = this._matchGroup(token, this._unaryExpressions);\n\t\tif (op) {\n\t\t\ttoken = lexer.next();\n\t\t\texpr = this._parseUnary(lexer);\n\t\t\treturn op.method.bind(this, expr);\n\t\t}\n\t\treturn this._parsePrimary(lexer);\n\t};\n\n\t/**\n\t * Match a primary expression (a value).\n\t * @param {Lexer} lexer\n\t * @private\n\t */\n\tTone.TimeBase.prototype._parsePrimary = function(lexer){\n\t\tvar token, expr;\n\t\ttoken = lexer.peek();\n\t\tif (this.isUndef(token)) {\n\t\t\tthrow new SyntaxError(\"Tone.TimeBase: Unexpected end of expression\");\n\t\t}\n\t\tif (this._matchGroup(token, this._primaryExpressions)) {\n\t\t\ttoken = lexer.next();\n\t\t\tvar matching = token.value.match(token.regexp);\n\t\t\treturn token.method.bind(this, matching[1], matching[2], matching[3]);\n\t\t}\n\t\tif (token && token.value === \"(\"){\n\t\t\tlexer.next();\n\t\t\texpr = this._parseBinary(lexer);\n\t\t\ttoken = lexer.next();\n\t\t\tif (!(token && token.value === \")\")) {\n\t\t\t\tthrow new SyntaxError(\"Expected )\");\n\t\t\t}\n\t\t\treturn expr;\n\t\t}\n\t\tthrow new SyntaxError(\"Tone.TimeBase: Cannot process token \" + token.value);\n\t};\n\n\t/**\n\t * Recursively parse the string expression into a syntax tree.\n\t * @param {string} expr \n\t * @return {Function} the bound method to be evaluated later\n\t * @private\n\t */\n\tTone.TimeBase.prototype._parseExprString = function(exprString){\n\t\tif (!this.isString(exprString)){\n\t\t\texprString = exprString.toString();\n\t\t}\n\t\tvar lexer = this._tokenize(exprString);\n\t\tvar tree = this._parseBinary(lexer);\n\t\treturn tree;\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tDEFAULTS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * The initial expression value\n\t * @return {Number} The initial value 0\n\t * @private\n\t */\n\tTone.TimeBase.prototype._noOp = function(){\n\t\treturn 0;\n\t};\n\n\t/**\n\t * The default expression value if no arguments are given\n\t * @private\n\t */\n\tTone.TimeBase.prototype._defaultExpr = function(){\n\t\treturn this._noOp;\n\t};\n\n\t/**\n\t * The default units if none are given.\n\t * @private\n\t */\n\tTone.TimeBase.prototype._defaultUnits = \"s\";\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tUNIT CONVERSIONS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Returns the value of a frequency in the current units\n\t * @param {Frequency} freq\n\t * @return {Number}\n\t * @private\n\t */\n\tTone.TimeBase.prototype._frequencyToUnits = function(freq){\n\t\treturn 1/freq;\n\t};\n\n\t/**\n\t * Return the value of the beats in the current units\n\t * @param {Number} beats\n\t * @return {Number}\n\t * @private\n\t */\n\tTone.TimeBase.prototype._beatsToUnits = function(beats){\n\t\treturn (60 / Tone.Transport.bpm.value) * beats;\n\t};\n\n\t/**\n\t * Returns the value of a second in the current units\n\t * @param {Seconds} seconds\n\t * @return {Number}\n\t * @private\n\t */\n\tTone.TimeBase.prototype._secondsToUnits = function(seconds){\n\t\treturn seconds;\n\t};\n\n\t/**\n\t * Returns the value of a tick in the current time units\n\t * @param {Ticks} ticks\n\t * @return {Number}\n\t * @private\n\t */\n\tTone.TimeBase.prototype._ticksToUnits = function(ticks){\n\t\treturn ticks * (this._beatsToUnits(1) / Tone.Transport.PPQ);\n\t};\n\n\t/**\n\t * Return the time signature.\n\t * @return {Number}\n\t * @private\n\t */\n\tTone.TimeBase.prototype._timeSignature = function(){\n\t\treturn Tone.Transport.timeSignature;\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tEXPRESSIONS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Push an expression onto the expression list\n\t * @param {Time} val\n\t * @param {String} type\n\t * @param {String} units\n\t * @return {Tone.TimeBase} \n\t * @private\n\t */\n\tTone.TimeBase.prototype._pushExpr = function(val, name, units){\n\t\t//create the expression\n\t\tif (!(val instanceof Tone.TimeBase)){\n\t\t\tval = new this.constructor(val, units);\n\t\t}\n\t\tthis._expr = this._binaryExpressions[name].method.bind(this, this._expr, val._expr);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Add to the current value.\n\t * @param {Time} val The value to add\n\t * @param {String=} units Optional units to use with the value.\n\t * @return {Tone.TimeBase} this\n\t * @example\n\t * Tone.TimeBase(\"2m\").add(\"1m\"); //\"3m\"\n\t */\n\tTone.TimeBase.prototype.add = function(val, units){\n\t\treturn this._pushExpr(val, \"+\", units);\n\t};\n\n\t/**\n\t * Subtract the value from the current time.\n\t * @param {Time} val The value to subtract\n\t * @param {String=} units Optional units to use with the value.\n\t * @return {Tone.TimeBase} this\n\t * @example\n\t * Tone.TimeBase(\"2m\").sub(\"1m\"); //\"1m\"\n\t */\n\tTone.TimeBase.prototype.sub = function(val, units){\n\t\treturn this._pushExpr(val, \"-\", units);\n\t};\n\n\t/**\n\t * Multiply the current value by the given time.\n\t * @param {Time} val The value to multiply\n\t * @param {String=} units Optional units to use with the value.\n\t * @return {Tone.TimeBase} this\n\t * @example\n\t * Tone.TimeBase(\"2m\").mult(\"2\"); //\"4m\"\n\t */\n\tTone.TimeBase.prototype.mult = function(val, units){\n\t\treturn this._pushExpr(val, \"*\", units);\n\t};\n\n\t/**\n\t * Divide the current value by the given time.\n\t * @param {Time} val The value to divide by\n\t * @param {String=} units Optional units to use with the value.\n\t * @return {Tone.TimeBase} this\n\t * @example\n\t * Tone.TimeBase(\"2m\").div(2); //\"1m\"\n\t */\n\tTone.TimeBase.prototype.div = function(val, units){\n\t\treturn this._pushExpr(val, \"/\", units);\n\t};\n\n\t/**\n\t * Evaluate the time value. Returns the time\n\t * in seconds.\n\t * @return {Seconds} \n\t */\n\tTone.TimeBase.prototype.valueOf = function(){\n\t\treturn this._expr();\n\t};\n\n\t/**\n\t * Clean up\n\t * @return {Tone.TimeBase} this\n\t */\n\tTone.TimeBase.prototype.dispose = function(){\n\t\tthis._expr = null;\n\t};\n\n\treturn Tone.TimeBase;\n});","define([\"Tone/core/Tone\", \"Tone/type/Type\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Tone.Param wraps the native Web Audio's AudioParam to provide\n\t * additional unit conversion functionality. It also\n\t * serves as a base-class for classes which have a single,\n\t * automatable parameter. \n\t * @extends {Tone}\n\t * @param {AudioParam} param The parameter to wrap.\n\t * @param {Tone.Type} units The units of the audio param.\n\t * @param {Boolean} convert If the param should be converted.\n\t */\n\tTone.Param = function(){\n\n\t\tvar options = this.optionsObject(arguments, [\"param\", \"units\", \"convert\"], Tone.Param.defaults);\n\n\t\t/**\n\t\t * The native parameter to control\n\t\t * @type {AudioParam}\n\t\t * @private\n\t\t */\n\t\tthis._param = this.input = options.param;\n\n\t\t/**\n\t\t * The units of the parameter\n\t\t * @type {Tone.Type}\n\t\t */\n\t\tthis.units = options.units;\n\n\t\t/**\n\t\t * If the value should be converted or not\n\t\t * @type {Boolean}\n\t\t */\n\t\tthis.convert = options.convert;\n\n\t\t/**\n\t\t * True if the signal value is being overridden by \n\t\t * a connected signal.\n\t\t * @readOnly\n\t\t * @type {boolean}\n\t\t * @private\n\t\t */\n\t\tthis.overridden = false;\n\n\t\t/**\n\t\t * If there is an LFO, this is where it is held.\n\t\t * @type {Tone.LFO}\n\t\t * @private\n\t\t */\n\t\tthis._lfo = null;\n\n\t\tif (this.isObject(options.lfo)){\n\t\t\tthis.value = options.lfo;\n\t\t} else if (!this.isUndef(options.value)){\n\t\t\tthis.value = options.value;\n\t\t}\n\t};\n\n\tTone.extend(Tone.Param);\n\t\n\t/**\n\t * Defaults\n\t * @type {Object}\n\t * @const\n\t */\n\tTone.Param.defaults = {\n\t\t\"units\" : Tone.Type.Default,\n\t\t\"convert\" : true,\n\t\t\"param\" : undefined\n\t};\n\n\t/**\n\t * The current value of the parameter. \n\t * @memberOf Tone.Param#\n\t * @type {Number}\n\t * @name value\n\t */\n\tObject.defineProperty(Tone.Param.prototype, \"value\", {\n\t\tget : function(){\n\t\t\treturn this._toUnits(this._param.value);\n\t\t},\n\t\tset : function(value){\n\t\t\tif (this.isObject(value)){\n\t\t\t\t//throw an error if the LFO needs to be included\n\t\t\t\tif (this.isUndef(Tone.LFO)){\n\t\t\t\t\tthrow new Error(\"Include 'Tone.LFO' to use an LFO as a Param value.\");\n\t\t\t\t}\n\t\t\t\t//remove the old one\n\t\t\t\tif (this._lfo){\n\t\t\t\t\tthis._lfo.dispose();\n\t\t\t\t}\n\t\t\t\tthis._lfo = new Tone.LFO(value).start();\n\t\t\t\tthis._lfo.connect(this.input);\n\t\t\t} else {\n\t\t\t\tvar convertedVal = this._fromUnits(value);\n\t\t\t\tthis._param.cancelScheduledValues(0);\n\t\t\t\tthis._param.value = convertedVal;\n\t\t\t}\n\t\t}\n\t});\n\n\t/**\n\t * Convert the given value from the type specified by Tone.Param.units\n\t * into the destination value (such as Gain or Frequency).\n\t * @private\n\t * @param {*} val the value to convert\n\t * @return {number} the number which the value should be set to\n\t */\n\tTone.Param.prototype._fromUnits = function(val){\n\t\tif (this.convert || this.isUndef(this.convert)){\n\t\t\tswitch(this.units){\n\t\t\t\tcase Tone.Type.Time: \n\t\t\t\t\treturn this.toSeconds(val);\n\t\t\t\tcase Tone.Type.Frequency: \n\t\t\t\t\treturn this.toFrequency(val);\n\t\t\t\tcase Tone.Type.Decibels: \n\t\t\t\t\treturn this.dbToGain(val);\n\t\t\t\tcase Tone.Type.NormalRange: \n\t\t\t\t\treturn Math.min(Math.max(val, 0), 1);\n\t\t\t\tcase Tone.Type.AudioRange: \n\t\t\t\t\treturn Math.min(Math.max(val, -1), 1);\n\t\t\t\tcase Tone.Type.Positive: \n\t\t\t\t\treturn Math.max(val, 0);\n\t\t\t\tdefault:\n\t\t\t\t\treturn val;\n\t\t\t}\n\t\t} else {\n\t\t\treturn val;\n\t\t}\n\t};\n\n\t/**\n\t * Convert the parameters value into the units specified by Tone.Param.units.\n\t * @private\n\t * @param {number} val the value to convert\n\t * @return {number}\n\t */\n\tTone.Param.prototype._toUnits = function(val){\n\t\tif (this.convert || this.isUndef(this.convert)){\n\t\t\tswitch(this.units){\n\t\t\t\tcase Tone.Type.Decibels: \n\t\t\t\t\treturn this.gainToDb(val);\n\t\t\t\tdefault:\n\t\t\t\t\treturn val;\n\t\t\t}\n\t\t} else {\n\t\t\treturn val;\n\t\t}\n\t};\n\n\t/**\n\t * the minimum output value\n\t * @type {Number}\n\t * @private\n\t */\n\tTone.Param.prototype._minOutput = 0.00001;\n\n\t/**\n\t * Schedules a parameter value change at the given time.\n\t * @param {*}\tvalue The value to set the signal.\n\t * @param {Time} time The time when the change should occur.\n\t * @returns {Tone.Param} this\n\t * @example\n\t * //set the frequency to \"G4\" in exactly 1 second from now. \n\t * freq.setValueAtTime(\"G4\", \"+1\");\n\t */\n\tTone.Param.prototype.setValueAtTime = function(value, time){\n\t\tvalue = this._fromUnits(value);\n\t\ttime = this.toSeconds(time);\n\t\tif (time <= this.now() + this.blockTime){\n\t\t\tthis._param.value = value;\n\t\t} else {\n\t\t\tthis._param.setValueAtTime(value, time);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Creates a schedule point with the current value at the current time.\n\t * This is useful for creating an automation anchor point in order to \n\t * schedule changes from the current value. \n\t *\n\t * @param {number=} now (Optionally) pass the now value in. \n\t * @returns {Tone.Param} this\n\t */\n\tTone.Param.prototype.setRampPoint = function(now){\n\t\tnow = this.defaultArg(now, this.now());\n\t\tvar currentVal = this._param.value;\n\t\t// exponentialRampToValueAt cannot ever ramp from or to 0\n\t\t// More info: https://bugzilla.mozilla.org/show_bug.cgi?id=1125600#c2\n\t\tif (currentVal === 0){\n\t\t\tcurrentVal = this._minOutput;\n\t\t}\n\t\tthis._param.setValueAtTime(currentVal, now);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Schedules a linear continuous change in parameter value from the \n\t * previous scheduled parameter value to the given value.\n\t * \n\t * @param {number} value \n\t * @param {Time} endTime \n\t * @returns {Tone.Param} this\n\t */\n\tTone.Param.prototype.linearRampToValueAtTime = function(value, endTime){\n\t\tvalue = this._fromUnits(value);\n\t\tthis._param.linearRampToValueAtTime(value, this.toSeconds(endTime));\n\t\treturn this;\n\t};\n\n\t/**\n\t * Schedules an exponential continuous change in parameter value from \n\t * the previous scheduled parameter value to the given value.\n\t * \n\t * @param {number} value \n\t * @param {Time} endTime \n\t * @returns {Tone.Param} this\n\t */\n\tTone.Param.prototype.exponentialRampToValueAtTime = function(value, endTime){\n\t\tvalue = this._fromUnits(value);\n\t\tvalue = Math.max(this._minOutput, value);\n\t\tthis._param.exponentialRampToValueAtTime(value, this.toSeconds(endTime));\n\t\treturn this;\n\t};\n\n\t/**\n\t * Schedules an exponential continuous change in parameter value from \n\t * the current time and current value to the given value over the \n\t * duration of the rampTime.\n\t * \n\t * @param {number} value The value to ramp to.\n\t * @param {Time} rampTime the time that it takes the \n\t * value to ramp from it's current value\n\t * @param {Time}\t[startTime=now] \tWhen the ramp should start. \n\t * @returns {Tone.Param} this\n\t * @example\n\t * //exponentially ramp to the value 2 over 4 seconds. \n\t * signal.exponentialRampToValue(2, 4);\n\t */\n\tTone.Param.prototype.exponentialRampToValue = function(value, rampTime, startTime){\n\t\tstartTime = this.toSeconds(startTime);\n\t\tthis.setRampPoint(startTime);\n\t\tthis.exponentialRampToValueAtTime(value, startTime + this.toSeconds(rampTime));\n\t\treturn this;\n\t};\n\n\t/**\n\t * Schedules an linear continuous change in parameter value from \n\t * the current time and current value to the given value over the \n\t * duration of the rampTime.\n\t * \n\t * @param {number} value The value to ramp to.\n\t * @param {Time} rampTime the time that it takes the \n\t * value to ramp from it's current value\n\t * @param {Time}\t[startTime=now] \tWhen the ramp should start. \n\t * @returns {Tone.Param} this\n\t * @example\n\t * //linearly ramp to the value 4 over 3 seconds. \n\t * signal.linearRampToValue(4, 3);\n\t */\n\tTone.Param.prototype.linearRampToValue = function(value, rampTime, startTime){\n\t\tstartTime = this.toSeconds(startTime);\n\t\tthis.setRampPoint(startTime);\n\t\tthis.linearRampToValueAtTime(value, startTime + this.toSeconds(rampTime));\n\t\treturn this;\n\t};\n\n\t/**\n\t * Start exponentially approaching the target value at the given time with\n\t * a rate having the given time constant.\n\t * @param {number} value \n\t * @param {Time} startTime \n\t * @param {number} timeConstant \n\t * @returns {Tone.Param} this \n\t */\n\tTone.Param.prototype.setTargetAtTime = function(value, startTime, timeConstant){\n\t\tvalue = this._fromUnits(value);\n\t\t// The value will never be able to approach without timeConstant > 0.\n\t\t// http://www.w3.org/TR/webaudio/#dfn-setTargetAtTime, where the equation\n\t\t// is described. 0 results in a division by 0.\n\t\tvalue = Math.max(this._minOutput, value);\n\t\ttimeConstant = Math.max(this._minOutput, timeConstant);\n\t\tthis._param.setTargetAtTime(value, this.toSeconds(startTime), timeConstant);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Sets an array of arbitrary parameter values starting at the given time\n\t * for the given duration.\n\t * \t\n\t * @param {Array} values \n\t * @param {Time} startTime \n\t * @param {Time} duration \n\t * @returns {Tone.Param} this\n\t */\n\tTone.Param.prototype.setValueCurveAtTime = function(values, startTime, duration){\n\t\tfor (var i = 0; i < values.length; i++){\n\t\t\tvalues[i] = this._fromUnits(values[i]);\n\t\t}\n\t\tthis._param.setValueCurveAtTime(values, this.toSeconds(startTime), this.toSeconds(duration));\n\t\treturn this;\n\t};\n\n\t/**\n\t * Cancels all scheduled parameter changes with times greater than or \n\t * equal to startTime.\n\t * \n\t * @param {Time} startTime\n\t * @returns {Tone.Param} this\n\t */\n\tTone.Param.prototype.cancelScheduledValues = function(startTime){\n\t\tthis._param.cancelScheduledValues(this.toSeconds(startTime));\n\t\treturn this;\n\t};\n\n\t/**\n\t * Ramps to the given value over the duration of the rampTime. \n\t * Automatically selects the best ramp type (exponential or linear)\n\t * depending on the `units` of the signal\n\t * \n\t * @param {number} value \n\t * @param {Time} rampTime \tThe time that it takes the \n\t * value to ramp from it's current value\n\t * @param {Time}\t[startTime=now] \tWhen the ramp should start. \n\t * @returns {Tone.Param} this\n\t * @example\n\t * //ramp to the value either linearly or exponentially \n\t * //depending on the \"units\" value of the signal\n\t * signal.rampTo(0, 10);\n\t * @example\n\t * //schedule it to ramp starting at a specific time\n\t * signal.rampTo(0, 10, 5)\n\t */\n\tTone.Param.prototype.rampTo = function(value, rampTime, startTime){\n\t\trampTime = this.defaultArg(rampTime, 0);\n\t\tif (this.units === Tone.Type.Frequency || this.units === Tone.Type.BPM || this.units === Tone.Type.Decibels){\n\t\t\tthis.exponentialRampToValue(value, rampTime, startTime);\n\t\t} else {\n\t\t\tthis.linearRampToValue(value, rampTime, startTime);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * The LFO created by the signal instance. If none\n\t * was created, this is null.\n\t * @type {Tone.LFO}\n\t * @readOnly\n\t * @memberOf Tone.Param#\n\t * @name lfo\n\t */\n\tObject.defineProperty(Tone.Param.prototype, \"lfo\", {\n\t\tget : function(){\n\t\t\treturn this._lfo;\n\t\t}\n\t});\n\n\t/**\n\t * Clean up\n\t * @returns {Tone.Param} this\n\t */\n\tTone.Param.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._param = null;\n\t\tif (this._lfo){\n\t\t\tthis._lfo.dispose();\n\t\t\tthis._lfo = null;\n\t\t}\n\t\treturn this;\n\t};\n\n\treturn Tone.Param;\n});","'use strict';\n\ndefine(function (require) {\n var p5sound = require('master');\n\n var Add = require('Tone/signal/Add');\n var Mult = require('Tone/signal/Multiply');\n var Scale = require('Tone/signal/Scale');\n\n /**\n *

Creates a signal that oscillates between -1.0 and 1.0.\n * By default, the oscillation takes the form of a sinusoidal\n * shape ('sine'). Additional types include 'triangle',\n * 'sawtooth' and 'square'. The frequency defaults to\n * 440 oscillations per second (440Hz, equal to the pitch of an\n * 'A' note).

\n *\n *

Set the type of oscillation with setType(), or by instantiating a\n * specific oscillator: p5.SinOsc, p5.TriOsc, p5.SqrOsc, or p5.SawOsc.\n *

\n *\n * @class p5.Oscillator\n * @constructor\n * @param {Number} [freq] frequency defaults to 440Hz\n * @param {String} [type] type of oscillator. Options:\n * 'sine' (default), 'triangle',\n * 'sawtooth', 'square'\n * @example\n *
\n * let osc, playing, freq, amp;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playOscillator);\n * osc = new p5.Oscillator('sine');\n * }\n *\n * function draw() {\n * background(220)\n * freq = constrain(map(mouseX, 0, width, 100, 500), 100, 500);\n * amp = constrain(map(mouseY, height, 0, 0, 1), 0, 1);\n *\n * text('tap to play', 20, 20);\n * text('freq: ' + freq, 20, 40);\n * text('amp: ' + amp, 20, 60);\n *\n * if (playing) {\n * // smooth the transitions by 0.1 seconds\n * osc.freq(freq, 0.1);\n * osc.amp(amp, 0.1);\n * }\n * }\n *\n * function playOscillator() {\n * // starting an oscillator on a user gesture will enable audio\n * // in browsers that have a strict autoplay policy.\n * // See also: userStartAudio();\n * osc.start();\n * playing = true;\n * }\n *\n * function mouseReleased() {\n * // ramp amplitude to 0 over 0.5 seconds\n * osc.amp(0, 0.5);\n * playing = false;\n * }\n *
\n */\n p5.Oscillator = function(freq, type) {\n if (typeof freq === 'string') {\n var f = type;\n type = freq;\n freq = f;\n } if (typeof type === 'number') {\n var f = type;\n type = freq;\n freq = f;\n }\n this.started = false;\n\n // components\n this.phaseAmount = undefined;\n this.oscillator = p5sound.audiocontext.createOscillator();\n this.f = freq || 440.0; // frequency\n this.oscillator.type = type || 'sine';\n this.oscillator.frequency.setValueAtTime(this.f, p5sound.audiocontext.currentTime);\n\n // connections\n this.output = p5sound.audiocontext.createGain();\n\n this._freqMods = []; // modulators connected to this oscillator's frequency\n\n // set default output gain to 0.5\n this.output.gain.value = 0.5;\n this.output.gain.setValueAtTime(0.5, p5sound.audiocontext.currentTime);\n\n this.oscillator.connect(this.output);\n // stereo panning\n this.panPosition = 0.0;\n this.connection = p5sound.input; // connect to p5sound by default\n this.panner = new p5.Panner(this.output, this.connection, 1);\n\n //array of math operation signal chaining\n this.mathOps = [this.output];\n\n // add to the soundArray so we can dispose of the osc later\n p5sound.soundArray.push(this);\n };\n\n /**\n * Start an oscillator.\n *\n * Starting an oscillator on a user gesture will enable audio in browsers\n * that have a strict autoplay policy, including Chrome and most mobile\n * devices. See also: `userStartAudio()`.\n *\n * @method start\n * @for p5.Oscillator\n * @param {Number} [time] startTime in seconds from now.\n * @param {Number} [frequency] frequency in Hz.\n */\n p5.Oscillator.prototype.start = function(time, f) {\n if (this.started) {\n var now = p5sound.audiocontext.currentTime;\n this.stop(now);\n }\n if (!this.started) {\n var freq = f || this.f;\n var type = this.oscillator.type;\n\n // set old osc free to be garbage collected (memory)\n if (this.oscillator) {\n this.oscillator.disconnect();\n delete this.oscillator;\n }\n\n // var detune = this.oscillator.frequency.value;\n this.oscillator = p5sound.audiocontext.createOscillator();\n this.oscillator.frequency.value = Math.abs(freq);\n this.oscillator.type = type;\n // this.oscillator.detune.value = detune;\n this.oscillator.connect(this.output);\n time = time || 0;\n this.oscillator.start(time + p5sound.audiocontext.currentTime);\n this.freqNode = this.oscillator.frequency;\n\n // if other oscillators are already connected to this osc's freq\n for (var i in this._freqMods) {\n if (typeof this._freqMods[i].connect !== 'undefined') {\n this._freqMods[i].connect(this.oscillator.frequency);\n }\n }\n\n this.started = true;\n }\n };\n\n /**\n * Stop an oscillator. Accepts an optional parameter\n * to determine how long (in seconds from now) until the\n * oscillator stops.\n *\n * @method stop\n * @for p5.Oscillator\n * @param {Number} secondsFromNow Time, in seconds from now.\n */\n p5.Oscillator.prototype.stop = function(time) {\n if (this.started) {\n var t = time || 0;\n var now = p5sound.audiocontext.currentTime;\n this.oscillator.stop(t + now);\n this.started = false;\n }\n };\n\n /**\n * Set the amplitude between 0 and 1.0. Or, pass in an object\n * such as an oscillator to modulate amplitude with an audio signal.\n *\n * @method amp\n * @for p5.Oscillator\n * @param {Number|Object} vol between 0 and 1.0\n * or a modulating signal/oscillator\n * @param {Number} [rampTime] create a fade that lasts rampTime\n * @param {Number} [timeFromNow] schedule this event to happen\n * seconds from now\n * @return {AudioParam} gain If no value is provided,\n * returns the Web Audio API\n * AudioParam that controls\n * this oscillator's\n * gain/amplitude/volume)\n */\n p5.Oscillator.prototype.amp = function(vol, rampTime, tFromNow) {\n var self = this;\n if (typeof vol === 'number') {\n var rampTime = rampTime || 0;\n var tFromNow = tFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n this.output.gain.linearRampToValueAtTime(vol, now + tFromNow + rampTime);\n }\n\n else if (vol) {\n vol.connect(self.output.gain);\n } else {\n // return the Gain Node\n return this.output.gain;\n }\n };\n\n // these are now the same thing\n p5.Oscillator.prototype.fade = p5.Oscillator.prototype.amp;\n\n p5.Oscillator.prototype.getAmp = function() {\n return this.output.gain.value;\n };\n\n /**\n * Set frequency of an oscillator to a value. Or, pass in an object\n * such as an oscillator to modulate the frequency with an audio signal.\n *\n * @method freq\n * @for p5.Oscillator\n * @param {Number|Object} Frequency Frequency in Hz\n * or modulating signal/oscillator\n * @param {Number} [rampTime] Ramp time (in seconds)\n * @param {Number} [timeFromNow] Schedule this event to happen\n * at x seconds from now\n * @return {AudioParam} Frequency If no value is provided,\n * returns the Web Audio API\n * AudioParam that controls\n * this oscillator's frequency\n * @example\n *
\n * let osc;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playOscillator);\n * osc = new p5.Oscillator(300);\n * background(220);\n * text('tap to play', 20, 20);\n * }\n *\n * function playOscillator() {\n * osc.start();\n * osc.amp(0.5);\n * // start at 700Hz\n * osc.freq(700);\n * // ramp to 60Hz over 0.7 seconds\n * osc.freq(60, 0.7);\n * osc.amp(0, 0.1, 0.7);\n * }\n *
\n */\n p5.Oscillator.prototype.freq = function(val, rampTime, tFromNow) {\n if (typeof val === 'number' && !isNaN(val)) {\n this.f = val;\n var now = p5sound.audiocontext.currentTime;\n var rampTime = rampTime || 0;\n var tFromNow = tFromNow || 0;\n var t = now + tFromNow + rampTime;\n // var currentFreq = this.oscillator.frequency.value;\n // this.oscillator.frequency.cancelScheduledValues(now);\n\n if (rampTime === 0) {\n this.oscillator.frequency.setValueAtTime(val, tFromNow + now);\n } else {\n if (val > 0 ) {\n this.oscillator.frequency.exponentialRampToValueAtTime(val, tFromNow + rampTime + now);\n } else {\n this.oscillator.frequency.linearRampToValueAtTime(val, tFromNow + rampTime + now);\n }\n }\n\n // reset phase if oscillator has a phase\n if (this.phaseAmount) {\n this.phase(this.phaseAmount);\n }\n\n } else if (val) {\n if (val.output) {\n val = val.output;\n }\n val.connect(this.oscillator.frequency);\n\n // keep track of what is modulating this param\n // so it can be re-connected if\n this._freqMods.push( val );\n } else {\n // return the Frequency Node\n return this.oscillator.frequency;\n }\n };\n\n p5.Oscillator.prototype.getFreq = function() {\n return this.oscillator.frequency.value;\n };\n\n /**\n * Set type to 'sine', 'triangle', 'sawtooth' or 'square'.\n *\n * @method setType\n * @for p5.Oscillator\n * @param {String} type 'sine', 'triangle', 'sawtooth' or 'square'.\n */\n p5.Oscillator.prototype.setType = function(type) {\n this.oscillator.type = type;\n };\n\n p5.Oscillator.prototype.getType = function() {\n return this.oscillator.type;\n };\n\n /**\n * Connect to a p5.sound / Web Audio object.\n *\n * @method connect\n * @for p5.Oscillator\n * @param {Object} unit A p5.sound or Web Audio object\n */\n p5.Oscillator.prototype.connect = function(unit) {\n if (!unit) {\n this.panner.connect(p5sound.input);\n }\n else if (unit.hasOwnProperty('input')) {\n this.panner.connect(unit.input);\n this.connection = unit.input;\n }\n else {\n this.panner.connect(unit);\n this.connection = unit;\n }\n };\n\n /**\n * Disconnect all outputs\n *\n * @method disconnect\n * @for p5.Oscillator\n */\n p5.Oscillator.prototype.disconnect = function() {\n if (this.output) {\n this.output.disconnect();\n }\n if (this.panner) {\n this.panner.disconnect();\n if (this.output) {\n this.output.connect(this.panner);\n }\n }\n this.oscMods = [];\n };\n\n /**\n * Pan between Left (-1) and Right (1)\n *\n * @method pan\n * @for p5.Oscillator\n * @param {Number} panning Number between -1 and 1\n * @param {Number} timeFromNow schedule this event to happen\n * seconds from now\n */\n p5.Oscillator.prototype.pan = function(pval, tFromNow) {\n this.panPosition = pval;\n this.panner.pan(pval, tFromNow);\n };\n\n p5.Oscillator.prototype.getPan = function() {\n return this.panPosition;\n };\n\n // get rid of the oscillator\n p5.Oscillator.prototype.dispose = function() {\n // remove reference from soundArray\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n\n if (this.oscillator) {\n var now = p5sound.audiocontext.currentTime;\n this.stop(now);\n this.disconnect();\n this.panner = null;\n this.oscillator = null;\n }\n // if it is a Pulse\n if (this.osc2) {\n this.osc2.dispose();\n }\n };\n\n /**\n * Set the phase of an oscillator between 0.0 and 1.0.\n * In this implementation, phase is a delay time\n * based on the oscillator's current frequency.\n *\n * @method phase\n * @for p5.Oscillator\n * @param {Number} phase float between 0.0 and 1.0\n */\n p5.Oscillator.prototype.phase = function(p) {\n var delayAmt = p5.prototype.map(p, 0, 1.0, 0, 1/this.f);\n var now = p5sound.audiocontext.currentTime;\n\n this.phaseAmount = p;\n\n if (!this.dNode) {\n // create a delay node\n this.dNode = p5sound.audiocontext.createDelay();\n // put the delay node in between output and panner\n this.oscillator.disconnect();\n this.oscillator.connect(this.dNode);\n this.dNode.connect(this.output);\n }\n\n // set delay time to match phase:\n this.dNode.delayTime.setValueAtTime(delayAmt, now);\n };\n\n // ========================== //\n // SIGNAL MATH FOR MODULATION //\n // ========================== //\n\n // return sigChain(this, scale, thisChain, nextChain, Scale);\n var sigChain = function(o, mathObj, thisChain, nextChain, type) {\n var chainSource = o.oscillator;\n // if this type of math already exists in the chain, replace it\n for (var i in o.mathOps) {\n if (o.mathOps[i] instanceof type) {\n chainSource.disconnect();\n o.mathOps[i].dispose();\n thisChain = i;\n // assume nextChain is output gain node unless...\n if (thisChain < o.mathOps.length - 2) {\n nextChain = o.mathOps[i+1];\n }\n }\n }\n if (thisChain === o.mathOps.length - 1) {\n o.mathOps.push(nextChain);\n }\n // assume source is the oscillator unless i > 0\n if (i > 0) {\n chainSource = o.mathOps[i-1];\n }\n chainSource.disconnect();\n chainSource.connect(mathObj);\n mathObj.connect(nextChain);\n o.mathOps[thisChain] = mathObj;\n return o;\n };\n\n /**\n * Add a value to the p5.Oscillator's output amplitude,\n * and return the oscillator. Calling this method again\n * will override the initial add() with a new value.\n *\n * @method add\n * @for p5.Oscillator\n * @param {Number} number Constant number to add\n * @return {p5.Oscillator} Oscillator Returns this oscillator\n * with scaled output\n *\n */\n p5.Oscillator.prototype.add = function(num) {\n var add = new Add(num);\n var thisChain = this.mathOps.length-1;\n var nextChain = this.output;\n return sigChain(this, add, thisChain, nextChain, Add);\n };\n\n /**\n * Multiply the p5.Oscillator's output amplitude\n * by a fixed value (i.e. turn it up!). Calling this method\n * again will override the initial mult() with a new value.\n *\n * @method mult\n * @for p5.Oscillator\n * @param {Number} number Constant number to multiply\n * @return {p5.Oscillator} Oscillator Returns this oscillator\n * with multiplied output\n */\n p5.Oscillator.prototype.mult = function(num) {\n var mult = new Mult(num);\n var thisChain = this.mathOps.length-1;\n var nextChain = this.output;\n return sigChain(this, mult, thisChain, nextChain, Mult);\n };\n\n /**\n * Scale this oscillator's amplitude values to a given\n * range, and return the oscillator. Calling this method\n * again will override the initial scale() with new values.\n *\n * @method scale\n * @for p5.Oscillator\n * @param {Number} inMin input range minumum\n * @param {Number} inMax input range maximum\n * @param {Number} outMin input range minumum\n * @param {Number} outMax input range maximum\n * @return {p5.Oscillator} Oscillator Returns this oscillator\n * with scaled output\n */\n p5.Oscillator.prototype.scale = function(inMin, inMax, outMin, outMax) {\n var mapOutMin, mapOutMax;\n if (arguments.length === 4) {\n mapOutMin = p5.prototype.map(outMin, inMin, inMax, 0, 1) - 0.5;\n mapOutMax = p5.prototype.map(outMax, inMin, inMax, 0, 1) - 0.5;\n }\n else {\n mapOutMin = arguments[0];\n mapOutMax = arguments[1];\n }\n var scale = new Scale(mapOutMin, mapOutMax);\n var thisChain = this.mathOps.length-1;\n var nextChain = this.output;\n return sigChain(this, scale, thisChain, nextChain, Scale);\n\n // this.output.disconnect();\n // this.output.connect(scale)\n };\n\n // ============================== //\n // SinOsc, TriOsc, SqrOsc, SawOsc //\n // ============================== //\n\n /**\n * Constructor: new p5.SinOsc().\n * This creates a Sine Wave Oscillator and is\n * equivalent to new p5.Oscillator('sine')\n * or creating a p5.Oscillator and then calling\n * its method setType('sine').\n * See p5.Oscillator for methods.\n *\n * @class p5.SinOsc\n * @constructor\n * @extends p5.Oscillator\n * @param {Number} [freq] Set the frequency\n */\n p5.SinOsc = function(freq) {\n p5.Oscillator.call(this, freq, 'sine');\n };\n\n p5.SinOsc.prototype = Object.create(p5.Oscillator.prototype);\n\n /**\n * Constructor: new p5.TriOsc().\n * This creates a Triangle Wave Oscillator and is\n * equivalent to new p5.Oscillator('triangle')\n * or creating a p5.Oscillator and then calling\n * its method setType('triangle').\n * See p5.Oscillator for methods.\n *\n * @class p5.TriOsc\n * @constructor\n * @extends p5.Oscillator\n * @param {Number} [freq] Set the frequency\n */\n p5.TriOsc = function(freq) {\n p5.Oscillator.call(this, freq, 'triangle');\n };\n\n p5.TriOsc.prototype = Object.create(p5.Oscillator.prototype);\n\n /**\n * Constructor: new p5.SawOsc().\n * This creates a SawTooth Wave Oscillator and is\n * equivalent to new p5.Oscillator('sawtooth')\n * or creating a p5.Oscillator and then calling\n * its method setType('sawtooth').\n * See p5.Oscillator for methods.\n *\n * @class p5.SawOsc\n * @constructor\n * @extends p5.Oscillator\n * @param {Number} [freq] Set the frequency\n */\n p5.SawOsc = function(freq) {\n p5.Oscillator.call(this, freq, 'sawtooth');\n };\n\n p5.SawOsc.prototype = Object.create(p5.Oscillator.prototype);\n\n /**\n * Constructor: new p5.SqrOsc().\n * This creates a Square Wave Oscillator and is\n * equivalent to new p5.Oscillator('square')\n * or creating a p5.Oscillator and then calling\n * its method setType('square').\n * See p5.Oscillator for methods.\n *\n * @class p5.SqrOsc\n * @constructor\n * @extends p5.Oscillator\n * @param {Number} [freq] Set the frequency\n */\n p5.SqrOsc = function(freq) {\n p5.Oscillator.call(this, freq, 'square');\n };\n\n p5.SqrOsc.prototype = Object.create(p5.Oscillator.prototype);\n\n});\n","define([\"Tone/core/Tone\", \"Tone/type/Type\"], function (Tone) {\n\n\t\"use strict\";\n\n\t/**\n\t * @class A Timeline class for scheduling and maintaining state\n\t * along a timeline. All events must have a \"time\" property. \n\t * Internally, events are stored in time order for fast \n\t * retrieval.\n\t * @extends {Tone}\n\t * @param {Positive} [memory=Infinity] The number of previous events that are retained.\n\t */\n\tTone.Timeline = function(){\n\n\t\tvar options = this.optionsObject(arguments, [\"memory\"], Tone.Timeline.defaults);\n\n\t\t/**\n\t\t * The array of scheduled timeline events\n\t\t * @type {Array}\n\t\t * @private\n\t\t */\n\t\tthis._timeline = [];\n\n\t\t/**\n\t\t * An array of items to remove from the list. \n\t\t * @type {Array}\n\t\t * @private\n\t\t */\n\t\tthis._toRemove = [];\n\n\t\t/**\n\t\t * Flag if the tieline is mid iteration\n\t\t * @private\n\t\t * @type {Boolean}\n\t\t */\n\t\tthis._iterating = false;\n\n\t\t/**\n\t\t * The memory of the timeline, i.e.\n\t\t * how many events in the past it will retain\n\t\t * @type {Positive}\n\t\t */\n\t\tthis.memory = options.memory;\n\t};\n\n\tTone.extend(Tone.Timeline);\n\n\t/**\n\t * the default parameters\n\t * @static\n\t * @const\n\t */\n\tTone.Timeline.defaults = {\n\t\t\"memory\" : Infinity\n\t};\n\n\t/**\n\t * The number of items in the timeline.\n\t * @type {Number}\n\t * @memberOf Tone.Timeline#\n\t * @name length\n\t * @readOnly\n\t */\n\tObject.defineProperty(Tone.Timeline.prototype, \"length\", {\n\t\tget : function(){\n\t\t\treturn this._timeline.length;\n\t\t}\n\t});\n\n\t/**\n\t * Insert an event object onto the timeline. Events must have a \"time\" attribute.\n\t * @param {Object} event The event object to insert into the \n\t * timeline. \n\t * @returns {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.add = function(event){\n\t\t//the event needs to have a time attribute\n\t\tif (this.isUndef(event.time)){\n\t\t\tthrow new Error(\"Tone.Timeline: events must have a time attribute\");\n\t\t}\n\t\tif (this._timeline.length){\n\t\t\tvar index = this._search(event.time);\n\t\t\tthis._timeline.splice(index + 1, 0, event);\n\t\t} else {\n\t\t\tthis._timeline.push(event);\t\t\t\n\t\t}\n\t\t//if the length is more than the memory, remove the previous ones\n\t\tif (this.length > this.memory){\n\t\t\tvar diff = this.length - this.memory;\n\t\t\tthis._timeline.splice(0, diff);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Remove an event from the timeline.\n\t * @param {Object} event The event object to remove from the list.\n\t * @returns {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.remove = function(event){\n\t\tif (this._iterating){\n\t\t\tthis._toRemove.push(event);\n\t\t} else {\n\t\t\tvar index = this._timeline.indexOf(event);\n\t\t\tif (index !== -1){\n\t\t\t\tthis._timeline.splice(index, 1);\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Get the nearest event whose time is less than or equal to the given time.\n\t * @param {Number} time The time to query.\n\t * @returns {Object} The event object set after that time.\n\t */\n\tTone.Timeline.prototype.get = function(time){\n\t\tvar index = this._search(time);\n\t\tif (index !== -1){\n\t\t\treturn this._timeline[index];\n\t\t} else {\n\t\t\treturn null;\n\t\t}\n\t};\n\n\t/**\n\t * Return the first event in the timeline without removing it\n\t * @returns {Object} The first event object\n\t */\n\tTone.Timeline.prototype.peek = function(){\n\t\treturn this._timeline[0];\n\t};\n\n\t/**\n\t * Return the first event in the timeline and remove it\n\t * @returns {Object} The first event object\n\t */\n\tTone.Timeline.prototype.shift = function(){\n\t\treturn this._timeline.shift();\n\t};\n\n\t/**\n\t * Get the event which is scheduled after the given time.\n\t * @param {Number} time The time to query.\n\t * @returns {Object} The event object after the given time\n\t */\n\tTone.Timeline.prototype.getAfter = function(time){\n\t\tvar index = this._search(time);\n\t\tif (index + 1 < this._timeline.length){\n\t\t\treturn this._timeline[index + 1];\n\t\t} else {\n\t\t\treturn null;\n\t\t}\n\t};\n\n\t/**\n\t * Get the event before the event at the given time.\n\t * @param {Number} time The time to query.\n\t * @returns {Object} The event object before the given time\n\t */\n\tTone.Timeline.prototype.getBefore = function(time){\n\t\tvar len = this._timeline.length;\n\t\t//if it's after the last item, return the last item\n\t\tif (len > 0 && this._timeline[len - 1].time < time){\n\t\t\treturn this._timeline[len - 1];\n\t\t}\n\t\tvar index = this._search(time);\n\t\tif (index - 1 >= 0){\n\t\t\treturn this._timeline[index - 1];\n\t\t} else {\n\t\t\treturn null;\n\t\t}\n\t};\n\n\t/**\n\t * Cancel events after the given time\n\t * @param {Number} time The time to query.\n\t * @returns {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.cancel = function(after){\n\t\tif (this._timeline.length > 1){\n\t\t\tvar index = this._search(after);\n\t\t\tif (index >= 0){\n\t\t\t\tif (this._timeline[index].time === after){\n\t\t\t\t\t//get the first item with that time\n\t\t\t\t\tfor (var i = index; i >= 0; i--){\n\t\t\t\t\t\tif (this._timeline[i].time === after){\n\t\t\t\t\t\t\tindex = i;\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tthis._timeline = this._timeline.slice(0, index);\n\t\t\t\t} else {\n\t\t\t\t\tthis._timeline = this._timeline.slice(0, index + 1);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tthis._timeline = [];\n\t\t\t}\n\t\t} else if (this._timeline.length === 1){\n\t\t\t//the first item's time\n\t\t\tif (this._timeline[0].time >= after){\n\t\t\t\tthis._timeline = [];\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Cancel events before or equal to the given time.\n\t * @param {Number} time The time to cancel before.\n\t * @returns {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.cancelBefore = function(time){\n\t\tif (this._timeline.length){\n\t\t\tvar index = this._search(time);\n\t\t\tif (index >= 0){\n\t\t\t\tthis._timeline = this._timeline.slice(index + 1);\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Does a binary serach on the timeline array and returns the \n\t * nearest event index whose time is after or equal to the given time.\n\t * If a time is searched before the first index in the timeline, -1 is returned.\n\t * If the time is after the end, the index of the last item is returned.\n\t * @param {Number} time \n\t * @return {Number} the index in the timeline array \n\t * @private\n\t */\n\tTone.Timeline.prototype._search = function(time){\n\t\tvar beginning = 0;\n\t\tvar len = this._timeline.length;\n\t\tvar end = len;\n\t\tif (len > 0 && this._timeline[len - 1].time <= time){\n\t\t\treturn len - 1;\n\t\t}\n\t\twhile (beginning < end){\n\t\t\t// calculate the midpoint for roughly equal partition\n\t\t\tvar midPoint = Math.floor(beginning + (end - beginning) / 2);\n\t\t\tvar event = this._timeline[midPoint];\n\t\t\tvar nextEvent = this._timeline[midPoint + 1];\n\t\t\tif (event.time === time){\n\t\t\t\t//choose the last one that has the same time\n\t\t\t\tfor (var i = midPoint; i < this._timeline.length; i++){\n\t\t\t\t\tvar testEvent = this._timeline[i];\n\t\t\t\t\tif (testEvent.time === time){\n\t\t\t\t\t\tmidPoint = i;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn midPoint;\n\t\t\t} else if (event.time < time && nextEvent.time > time){\n\t\t\t\treturn midPoint;\n\t\t\t} else if (event.time > time){\n\t\t\t\t//search lower\n\t\t\t\tend = midPoint;\n\t\t\t} else if (event.time < time){\n\t\t\t\t//search upper\n\t\t\t\tbeginning = midPoint + 1;\n\t\t\t} \n\t\t}\n\t\treturn -1;\n\t};\n\n\t/**\n\t * Internal iterator. Applies extra safety checks for \n\t * removing items from the array. \n\t * @param {Function} callback \n\t * @param {Number=} lowerBound \n\t * @param {Number=} upperBound \n\t * @private\n\t */\n\tTone.Timeline.prototype._iterate = function(callback, lowerBound, upperBound){\n\t\tthis._iterating = true;\n\t\tlowerBound = this.defaultArg(lowerBound, 0);\n\t\tupperBound = this.defaultArg(upperBound, this._timeline.length - 1);\n\t\tfor (var i = lowerBound; i <= upperBound; i++){\n\t\t\tcallback(this._timeline[i]);\n\t\t}\n\t\tthis._iterating = false;\n\t\tif (this._toRemove.length > 0){\n\t\t\tfor (var j = 0; j < this._toRemove.length; j++){\n\t\t\t\tvar index = this._timeline.indexOf(this._toRemove[j]);\n\t\t\t\tif (index !== -1){\n\t\t\t\t\tthis._timeline.splice(index, 1);\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis._toRemove = [];\n\t\t}\n\t};\n\n\t/**\n\t * Iterate over everything in the array\n\t * @param {Function} callback The callback to invoke with every item\n\t * @returns {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.forEach = function(callback){\n\t\tthis._iterate(callback);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Iterate over everything in the array at or before the given time.\n\t * @param {Number} time The time to check if items are before\n\t * @param {Function} callback The callback to invoke with every item\n\t * @returns {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.forEachBefore = function(time, callback){\n\t\t//iterate over the items in reverse so that removing an item doesn't break things\n\t\tvar upperBound = this._search(time);\n\t\tif (upperBound !== -1){\n\t\t\tthis._iterate(callback, 0, upperBound);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Iterate over everything in the array after the given time.\n\t * @param {Number} time The time to check if items are before\n\t * @param {Function} callback The callback to invoke with every item\n\t * @returns {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.forEachAfter = function(time, callback){\n\t\t//iterate over the items in reverse so that removing an item doesn't break things\n\t\tvar lowerBound = this._search(time);\n\t\tthis._iterate(callback, lowerBound + 1);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Iterate over everything in the array at or after the given time. Similar to \n\t * forEachAfter, but includes the item(s) at the given time.\n\t * @param {Number} time The time to check if items are before\n\t * @param {Function} callback The callback to invoke with every item\n\t * @returns {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.forEachFrom = function(time, callback){\n\t\t//iterate over the items in reverse so that removing an item doesn't break things\n\t\tvar lowerBound = this._search(time);\n\t\t//work backwards until the event time is less than time\n\t\twhile (lowerBound >= 0 && this._timeline[lowerBound].time >= time){\n\t\t\tlowerBound--;\n\t\t}\n\t\tthis._iterate(callback, lowerBound + 1);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Iterate over everything in the array at the given time\n\t * @param {Number} time The time to check if items are before\n\t * @param {Function} callback The callback to invoke with every item\n\t * @returns {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.forEachAtTime = function(time, callback){\n\t\t//iterate over the items in reverse so that removing an item doesn't break things\n\t\tvar upperBound = this._search(time);\n\t\tif (upperBound !== -1){\n\t\t\tthis._iterate(function(event){\n\t\t\t\tif (event.time === time){\n\t\t\t\t\tcallback(event);\n\t\t\t\t} \n\t\t\t}, 0, upperBound);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Clean up.\n\t * @return {Tone.Timeline} this\n\t */\n\tTone.Timeline.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._timeline = null;\n\t\tthis._toRemove = null;\n\t};\n\n\treturn Tone.Timeline;\n});","define([\"Tone/core/Tone\", \"Tone/signal/Multiply\", \"Tone/signal/Signal\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Negate the incoming signal. i.e. an input signal of 10 will output -10\n\t *\n\t * @constructor\n\t * @extends {Tone.SignalBase}\n\t * @example\n\t * var neg = new Tone.Negate();\n\t * var sig = new Tone.Signal(-2).connect(neg);\n\t * //output of neg is positive 2. \n\t */\n\tTone.Negate = function(){\n\t\t/**\n\t\t * negation is done by multiplying by -1\n\t\t * @type {Tone.Multiply}\n\t\t * @private\n\t\t */\n\t\tthis._multiply = this.input = this.output = new Tone.Multiply(-1);\n\t};\n\n\tTone.extend(Tone.Negate, Tone.SignalBase);\n\n\t/**\n\t * clean up\n\t * @returns {Tone.Negate} this\n\t */\n\tTone.Negate.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._multiply.dispose();\n\t\tthis._multiply = null;\n\t\treturn this;\n\t}; \n\n\treturn Tone.Negate;\n});","define([\"Tone/core/Tone\", \"Tone/signal/Signal\", \"Tone/signal/Multiply\", \"Tone/signal/WaveShaper\"], \nfunction(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class GreaterThanZero outputs 1 when the input is strictly greater than zero\n\t * \n\t * @constructor\n\t * @extends {Tone.SignalBase}\n\t * @example\n\t * var gt0 = new Tone.GreaterThanZero();\n\t * var sig = new Tone.Signal(0.01).connect(gt0);\n\t * //the output of gt0 is 1. \n\t * sig.value = 0;\n\t * //the output of gt0 is 0. \n\t */\n\tTone.GreaterThanZero = function(){\n\t\t\n\t\t/**\n\t\t * @type {Tone.WaveShaper}\n\t\t * @private\n\t\t */\n\t\tthis._thresh = this.output = new Tone.WaveShaper(function(val){\n\t\t\tif (val <= 0){\n\t\t\t\treturn 0;\n\t\t\t} else {\n\t\t\t\treturn 1;\n\t\t\t}\n\t\t}, 127);\n\n\t\t/**\n\t\t * scale the first thresholded signal by a large value.\n\t\t * this will help with values which are very close to 0\n\t\t * @type {Tone.Multiply}\n\t\t * @private\n\t\t */\n\t\tthis._scale = this.input = new Tone.Multiply(10000);\n\n\t\t//connections\n\t\tthis._scale.connect(this._thresh);\n\t};\n\n\tTone.extend(Tone.GreaterThanZero, Tone.SignalBase);\n\n\t/**\n\t * dispose method\n\t * @returns {Tone.GreaterThanZero} this\n\t */\n\tTone.GreaterThanZero.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._scale.dispose();\n\t\tthis._scale = null;\n\t\tthis._thresh.dispose();\n\t\tthis._thresh = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.GreaterThanZero;\n});","define([\"Tone/core/Tone\", \"Tone/signal/TimelineSignal\", \"Tone/core/TimelineState\", \n\t\"Tone/core/Emitter\", \"Tone/core/Context\"], function (Tone) {\n\n\t\"use strict\";\n\n\t/**\n\t * @class A sample accurate clock which provides a callback at the given rate. \n\t * While the callback is not sample-accurate (it is still susceptible to\n\t * loose JS timing), the time passed in as the argument to the callback\n\t * is precise. For most applications, it is better to use Tone.Transport\n\t * instead of the Clock by itself since you can synchronize multiple callbacks.\n\t *\n\t * \t@constructor\n\t * @extends {Tone.Emitter}\n\t * \t@param {function} callback The callback to be invoked with the time of the audio event\n\t * \t@param {Frequency} frequency The rate of the callback\n\t * \t@example\n\t * //the callback will be invoked approximately once a second\n\t * //and will print the time exactly once a second apart.\n\t * var clock = new Tone.Clock(function(time){\n\t * \tconsole.log(time);\n\t * }, 1);\n\t */\n\tTone.Clock = function(){\n\n\t\tTone.Emitter.call(this);\n\n\t\tvar options = this.optionsObject(arguments, [\"callback\", \"frequency\"], Tone.Clock.defaults);\n\n\t\t/**\n\t\t * The callback function to invoke at the scheduled tick.\n\t\t * @type {Function}\n\t\t */\n\t\tthis.callback = options.callback;\n\n\t\t/**\n\t\t * The next time the callback is scheduled.\n\t\t * @type {Number}\n\t\t * @private\n\t\t */\n\t\tthis._nextTick = 0;\n\n\t\t/**\n\t\t * The last state of the clock.\n\t\t * @type {State}\n\t\t * @private\n\t\t */\n\t\tthis._lastState = Tone.State.Stopped;\n\n\t\t/**\n\t\t * The rate the callback function should be invoked. \n\t\t * @type {BPM}\n\t\t * @signal\n\t\t */\n\t\tthis.frequency = new Tone.TimelineSignal(options.frequency, Tone.Type.Frequency);\n\t\tthis._readOnly(\"frequency\");\n\n\t\t/**\n\t\t * The number of times the callback was invoked. Starts counting at 0\n\t\t * and increments after the callback was invoked. \n\t\t * @type {Ticks}\n\t\t * @readOnly\n\t\t */\n\t\tthis.ticks = 0;\n\n\t\t/**\n\t\t * The state timeline\n\t\t * @type {Tone.TimelineState}\n\t\t * @private\n\t\t */\n\t\tthis._state = new Tone.TimelineState(Tone.State.Stopped);\n\n\t\t/**\n\t\t * The loop function bound to its context. \n\t\t * This is necessary to remove the event in the end.\n\t\t * @type {Function}\n\t\t * @private\n\t\t */\n\t\tthis._boundLoop = this._loop.bind(this);\n\n\t\t//bind a callback to the worker thread\n \tthis.context.on(\"tick\", this._boundLoop);\n\t};\n\n\tTone.extend(Tone.Clock, Tone.Emitter);\n\n\t/**\n\t * The defaults\n\t * @const\n\t * @type {Object}\n\t */\n\tTone.Clock.defaults = {\n\t\t\"callback\" : Tone.noOp,\n\t\t\"frequency\" : 1,\n\t\t\"lookAhead\" : \"auto\",\n\t};\n\n\t/**\n\t * Returns the playback state of the source, either \"started\", \"stopped\" or \"paused\".\n\t * @type {Tone.State}\n\t * @readOnly\n\t * @memberOf Tone.Clock#\n\t * @name state\n\t */\n\tObject.defineProperty(Tone.Clock.prototype, \"state\", {\n\t\tget : function(){\n\t\t\treturn this._state.getValueAtTime(this.now());\n\t\t}\n\t});\n\n\t/**\n\t * Start the clock at the given time. Optionally pass in an offset\n\t * of where to start the tick counter from.\n\t * @param {Time} time The time the clock should start\n\t * @param {Ticks=} offset Where the tick counter starts counting from.\n\t * @return {Tone.Clock} this\n\t */\n\tTone.Clock.prototype.start = function(time, offset){\n\t\ttime = this.toSeconds(time);\n\t\tif (this._state.getValueAtTime(time) !== Tone.State.Started){\n\t\t\tthis._state.add({\n\t\t\t\t\"state\" : Tone.State.Started, \n\t\t\t\t\"time\" : time,\n\t\t\t\t\"offset\" : offset\n\t\t\t});\n\t\t}\n\t\treturn this;\t\n\t};\n\n\t/**\n\t * Stop the clock. Stopping the clock resets the tick counter to 0.\n\t * @param {Time} [time=now] The time when the clock should stop.\n\t * @returns {Tone.Clock} this\n\t * @example\n\t * clock.stop();\n\t */\n\tTone.Clock.prototype.stop = function(time){\n\t\ttime = this.toSeconds(time);\n\t\tthis._state.cancel(time);\n\t\tthis._state.setStateAtTime(Tone.State.Stopped, time);\n\t\treturn this;\t\n\t};\n\n\n\t/**\n\t * Pause the clock. Pausing does not reset the tick counter.\n\t * @param {Time} [time=now] The time when the clock should stop.\n\t * @returns {Tone.Clock} this\n\t */\n\tTone.Clock.prototype.pause = function(time){\n\t\ttime = this.toSeconds(time);\n\t\tif (this._state.getValueAtTime(time) === Tone.State.Started){\n\t\t\tthis._state.setStateAtTime(Tone.State.Paused, time);\n\t\t}\n\t\treturn this;\t\n\t};\n\n\t/**\n\t * The scheduling loop.\n\t * @param {Number} time The current page time starting from 0\n\t * when the page was loaded.\n\t * @private\n\t */\n\tTone.Clock.prototype._loop = function(){\n\t\t//get the frequency value to compute the value of the next loop\n\t\tvar now = this.now();\n\t\t//if it's started\n\t\tvar lookAhead = this.context.lookAhead;\n\t\tvar updateInterval = this.context.updateInterval;\n\t\tvar lagCompensation = this.context.lag * 2;\n\t\tvar loopInterval = now + lookAhead + updateInterval + lagCompensation;\n\t\twhile (loopInterval > this._nextTick && this._state){\n\t\t\tvar currentState = this._state.getValueAtTime(this._nextTick);\n\t\t\tif (currentState !== this._lastState){\n\t\t\t\tthis._lastState = currentState;\n\t\t\t\tvar event = this._state.get(this._nextTick);\n\t\t\t\t// emit an event\n\t\t\t\tif (currentState === Tone.State.Started){\n\t\t\t\t\t//correct the time\n\t\t\t\t\tthis._nextTick = event.time;\n\t\t\t\t\tif (!this.isUndef(event.offset)){\n\t\t\t\t\t\tthis.ticks = event.offset;\n\t\t\t\t\t}\n\t\t\t\t\tthis.emit(\"start\", event.time, this.ticks);\n\t\t\t\t} else if (currentState === Tone.State.Stopped){\n\t\t\t\t\tthis.ticks = 0;\n\n\t\t\t\t\tthis.emit(\"stop\", event.time);\n\t\t\t\t} else if (currentState === Tone.State.Paused){\n\t\t\t\t\tthis.emit(\"pause\", event.time);\n\t\t\t\t}\n\t\t\t}\n\t\t\tvar tickTime = this._nextTick;\n\t\t\tif (this.frequency){\n\t\t\t\tthis._nextTick += 1 / this.frequency.getValueAtTime(this._nextTick);\n\t\t\t\tif (currentState === Tone.State.Started){\n\t\t\t\t\tthis.callback(tickTime);\n\t\t\t\t\tthis.ticks++;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n\n\t/**\n\t * Returns the scheduled state at the given time.\n\t * @param {Time} time The time to query.\n\t * @return {String} The name of the state input in setStateAtTime.\n\t * @example\n\t * clock.start(\"+0.1\");\n\t * clock.getStateAtTime(\"+0.1\"); //returns \"started\"\n\t */\n\tTone.Clock.prototype.getStateAtTime = function(time){\n\t\ttime = this.toSeconds(time);\n\t\treturn this._state.getValueAtTime(time);\n\t};\n\n\t/**\n\t * Clean up\n\t * @returns {Tone.Clock} this\n\t */\n\tTone.Clock.prototype.dispose = function(){\n\t\tTone.Emitter.prototype.dispose.call(this);\n\t\tthis.context.off(\"tick\", this._boundLoop);\n\t\tthis._writable(\"frequency\");\n\t\tthis.frequency.dispose();\n\t\tthis.frequency = null;\n\t\tthis._boundLoop = null;\n\t\tthis._nextTick = Infinity;\n\t\tthis.callback = null;\n\t\tthis._state.dispose();\n\t\tthis._state = null;\n\t};\n\n\treturn Tone.Clock;\n});","'use strict';\ndefine(function (require) {\n\n var p5sound = require('master');\n var AudioVoice = require('audioVoice');\n var noteToFreq = require('helpers').noteToFreq;\n\n var DEFAULT_SUSTAIN = 0.15;\n\n /**\n * A MonoSynth is used as a single voice for sound synthesis.\n * This is a class to be used in conjunction with the PolySynth\n * class. Custom synthetisers should be built inheriting from\n * this class.\n *\n * @class p5.MonoSynth\n * @constructor\n * @example\n *
\n * let monoSynth;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playSynth);\n * background(220);\n * textAlign(CENTER);\n * text('tap to play', width/2, height/2);\n *\n * monoSynth = new p5.MonoSynth();\n * }\n *\n * function playSynth() {\n * userStartAudio();\n *\n * let note = random(['Fb4', 'G4']);\n * // note velocity (volume, from 0 to 1)\n * let velocity = random();\n * // time from now (in seconds)\n * let time = 0;\n * // note duration (in seconds)\n * let dur = 1/6;\n *\n * monoSynth.play(note, velocity, time, dur);\n * }\n *
\n **/\n\n p5.MonoSynth = function () {\n AudioVoice.call(this);\n\n this.oscillator = new p5.Oscillator();\n\n this.env = new p5.Envelope();\n this.env.setRange(1, 0);\n this.env.setExp(true);\n\n //set params\n this.setADSR(0.02, 0.25, 0.05, 0.35);\n\n // oscillator --> env --> this.output (gain) --> p5.soundOut\n this.oscillator.disconnect();\n this.oscillator.connect(this.output);\n\n this.env.disconnect();\n this.env.setInput(this.output.gain);\n\n // reset oscillator gain to 1.0\n this.oscillator.output.gain.value = 1.0;\n\n this.oscillator.start();\n this.connect();\n\n p5sound.soundArray.push(this);\n };\n\n p5.MonoSynth.prototype = Object.create(p5.AudioVoice.prototype);\n\n /**\n * Play tells the MonoSynth to start playing a note. This method schedules\n * the calling of .triggerAttack and .triggerRelease.\n *\n * @method play\n * @for p5.MonoSynth\n * @param {String | Number} note the note you want to play, specified as a\n * frequency in Hertz (Number) or as a midi\n * value in Note/Octave format (\"C4\", \"Eb3\"...etc\")\n * See \n * Tone. Defaults to 440 hz.\n * @param {Number} [velocity] velocity of the note to play (ranging from 0 to 1)\n * @param {Number} [secondsFromNow] time from now (in seconds) at which to play\n * @param {Number} [sustainTime] time to sustain before releasing the envelope. Defaults to 0.15 seconds.\n * @example\n *
\n * let monoSynth;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playSynth);\n * background(220);\n * textAlign(CENTER);\n * text('tap to play', width/2, height/2);\n *\n * monoSynth = new p5.MonoSynth();\n * }\n *\n * function playSynth() {\n * userStartAudio();\n *\n * let note = random(['Fb4', 'G4']);\n * // note velocity (volume, from 0 to 1)\n * let velocity = random();\n * // time from now (in seconds)\n * let time = 0;\n * // note duration (in seconds)\n * let dur = 1/6;\n *\n * monoSynth.play(note, velocity, time, dur);\n * }\n *
\n *\n */\n p5.MonoSynth.prototype.play = function (note, velocity, secondsFromNow, susTime) {\n this.triggerAttack(note, velocity, ~~secondsFromNow);\n this.triggerRelease(~~secondsFromNow + (susTime || DEFAULT_SUSTAIN));\n };\n\n /**\n * Trigger the Attack, and Decay portion of the Envelope.\n * Similar to holding down a key on a piano, but it will\n * hold the sustain level until you let go.\n *\n * @param {String | Number} note the note you want to play, specified as a\n * frequency in Hertz (Number) or as a midi\n * value in Note/Octave format (\"C4\", \"Eb3\"...etc\")\n * See \n * Tone. Defaults to 440 hz\n * @param {Number} [velocity] velocity of the note to play (ranging from 0 to 1)\n * @param {Number} [secondsFromNow] time from now (in seconds) at which to play\n * @method triggerAttack\n * @for p5.MonoSynth\n * @example\n *
\n * let monoSynth;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(triggerAttack);\n * background(220);\n * text('tap here for attack, let go to release', 5, 20, width - 20);\n * monoSynth = new p5.MonoSynth();\n * }\n *\n * function triggerAttack() {\n * userStartAudio();\n *\n * monoSynth.triggerAttack(\"E3\");\n * }\n *\n * function mouseReleased() {\n * monoSynth.triggerRelease();\n * }\n *
\n */\n p5.MonoSynth.prototype.triggerAttack = function (note, velocity, secondsFromNow) {\n var secondsFromNow = ~~secondsFromNow;\n var freq = noteToFreq(note);\n var vel = velocity || 0.1;\n this.oscillator.freq(freq, 0, secondsFromNow);\n this.env.ramp(this.output.gain, secondsFromNow, vel);\n };\n\n /**\n * Trigger the release of the Envelope. This is similar to releasing\n * the key on a piano and letting the sound fade according to the\n * release level and release time.\n *\n * @param {Number} secondsFromNow time to trigger the release\n * @method triggerRelease\n * @for p5.MonoSynth\n * @example\n *
\n * let monoSynth;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(triggerAttack);\n * background(220);\n * text('tap here for attack, let go to release', 5, 20, width - 20);\n * monoSynth = new p5.MonoSynth();\n * }\n *\n * function triggerAttack() {\n * userStartAudio();\n *\n * monoSynth.triggerAttack(\"E3\");\n * }\n *\n * function mouseReleased() {\n * monoSynth.triggerRelease();\n * }\n *
\n */\n p5.MonoSynth.prototype.triggerRelease = function (secondsFromNow) {\n var secondsFromNow = secondsFromNow || 0;\n this.env.ramp(this.output.gain, secondsFromNow, 0);\n };\n\n /**\n * Set values like a traditional\n * \n * ADSR envelope\n * .\n *\n * @method setADSR\n * @for p5.MonoSynth\n * @param {Number} attackTime Time (in seconds before envelope\n * reaches Attack Level\n * @param {Number} [decayTime] Time (in seconds) before envelope\n * reaches Decay/Sustain Level\n * @param {Number} [susRatio] Ratio between attackLevel and releaseLevel, on a scale from 0 to 1,\n * where 1.0 = attackLevel, 0.0 = releaseLevel.\n * The susRatio determines the decayLevel and the level at which the\n * sustain portion of the envelope will sustain.\n * For example, if attackLevel is 0.4, releaseLevel is 0,\n * and susAmt is 0.5, the decayLevel would be 0.2. If attackLevel is\n * increased to 1.0 (using setRange),\n * then decayLevel would increase proportionally, to become 0.5.\n * @param {Number} [releaseTime] Time in seconds from now (defaults to 0)\n */\n p5.MonoSynth.prototype.setADSR = function (attack,decay,sustain,release) {\n this.env.setADSR(attack, decay, sustain, release);\n };\n\n\n /**\n * Getters and Setters\n * @property {Number} attack\n * @for p5.MonoSynth\n */\n /**\n * @property {Number} decay\n * @for p5.MonoSynth\n */\n /**\n * @property {Number} sustain\n * @for p5.MonoSynth\n */\n /**\n * @property {Number} release\n * @for p5.MonoSynth\n */\n Object.defineProperties(p5.MonoSynth.prototype, {\n 'attack': {\n get : function() {\n return this.env.aTime;\n },\n set : function(attack) {\n this.env.setADSR(attack, this.env.dTime,\n this.env.sPercent, this.env.rTime);\n }\n },\n 'decay': {\n get : function() {\n return this.env.dTime;\n },\n set : function(decay) {\n this.env.setADSR(this.env.aTime, decay,\n this.env.sPercent, this.env.rTime);\n }\n },\n 'sustain': {\n get : function() {\n return this.env.sPercent;\n },\n set : function(sustain) {\n this.env.setADSR(this.env.aTime, this.env.dTime,\n sustain, this.env.rTime);\n }\n },\n 'release': {\n get : function() {\n return this.env.rTime;\n },\n set : function(release) {\n this.env.setADSR(this.env.aTime, this.env.dTime,\n this.env.sPercent, release);\n }\n },\n });\n\n\n /**\n * MonoSynth amp\n * @method amp\n * @for p5.MonoSynth\n * @param {Number} vol desired volume\n * @param {Number} [rampTime] Time to reach new volume\n * @return {Number} new volume value\n */\n p5.MonoSynth.prototype.amp = function(vol, rampTime) {\n var t = rampTime || 0;\n if (typeof vol !== 'undefined') {\n this.oscillator.amp(vol, t);\n }\n return this.oscillator.amp().value;\n };\n\n /**\n * Connect to a p5.sound / Web Audio object.\n *\n * @method connect\n * @for p5.MonoSynth\n * @param {Object} unit A p5.sound or Web Audio object\n */\n\n p5.MonoSynth.prototype.connect = function(unit) {\n var u = unit || p5sound.input;\n this.output.connect(u.input ? u.input : u);\n };\n\n /**\n * Disconnect all outputs\n *\n * @method disconnect\n * @for p5.MonoSynth\n */\n p5.MonoSynth.prototype.disconnect = function() {\n if (this.output) {\n this.output.disconnect();\n }\n };\n\n\n /**\n * Get rid of the MonoSynth and free up its resources / memory.\n *\n * @method dispose\n * @for p5.MonoSynth\n */\n p5.MonoSynth.prototype.dispose = function() {\n AudioVoice.prototype.dispose.apply(this);\n\n if (this.env) {\n this.env.dispose();\n }\n if (this.oscillator) {\n this.oscillator.dispose();\n }\n };\n\n});\n","'use strict';\ndefine(function() {\n var p5sound = require('master');\n\n /**\n * Base class for monophonic synthesizers. Any extensions of this class\n * should follow the API and implement the methods below in order to\n * remain compatible with p5.PolySynth();\n *\n * @class p5.AudioVoice\n * @constructor\n */\n p5.AudioVoice = function () {\n\t this.ac = p5sound.audiocontext;\n\t this.output = this.ac.createGain();\n\t this.connect();\n\t p5sound.soundArray.push(this);\n };\n\n p5.AudioVoice.prototype.play = function (note, velocity, secondsFromNow, sustime) {\n };\n\n p5.AudioVoice.prototype.triggerAttack = function (note, velocity, secondsFromNow) {\n };\n\n p5.AudioVoice.prototype.triggerRelease = function (secondsFromNow) {\n };\n\n p5.AudioVoice.prototype.amp = function(vol, rampTime) {\n };\n\n /**\n * Connect to p5 objects or Web Audio Nodes\n * @method connect\n * @for p5.AudioVoice\n * @param {Object} unit\n */\n p5.AudioVoice.prototype.connect = function(unit) {\n var u = unit || p5sound.input;\n this.output.connect(u.input ? u.input : u);\n };\n\n /**\n * Disconnect from soundOut\n * @method disconnect\n * @for p5.AudioVoice\n */\n p5.AudioVoice.prototype.disconnect = function() {\n this.output.disconnect();\n };\n\n p5.AudioVoice.prototype.dispose = function() {\n if (this.output) {\n this.output.disconnect();\n delete this.output;\n }\n };\n\n return p5.AudioVoice;\n});\n","'use strict';\ndefine(function (require) {\n\n var p5sound = require('master');\n var TimelineSignal = require('Tone/signal/TimelineSignal');\n var noteToFreq = require('helpers').noteToFreq;\n\n /**\n * An AudioVoice is used as a single voice for sound synthesis.\n * The PolySynth class holds an array of AudioVoice, and deals\n * with voices allocations, with setting notes to be played, and\n * parameters to be set.\n *\n * @class p5.PolySynth\n * @constructor\n *\n * @param {Number} [synthVoice] A monophonic synth voice inheriting\n * the AudioVoice class. Defaults to p5.MonoSynth\n * @param {Number} [maxVoices] Number of voices, defaults to 8;\n * @example\n *
\n * let polySynth;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playSynth);\n * background(220);\n * text('click to play', 20, 20);\n *\n * polySynth = new p5.PolySynth();\n * }\n *\n * function playSynth() {\n * userStartAudio();\n *\n * // note duration (in seconds)\n * let dur = 1.5;\n *\n * // time from now (in seconds)\n * let time = 0;\n *\n * // velocity (volume, from 0 to 1)\n * let vel = 0.1;\n *\n * // notes can overlap with each other\n * polySynth.play('G2', vel, 0, dur);\n * polySynth.play('C3', vel, time += 1/3, dur);\n * polySynth.play('G3', vel, time += 1/3, dur);\n * }\n *
\n **/\n p5.PolySynth = function(audioVoice, maxVoices) {\n //audiovoices will contain maxVoices many monophonic synths\n this.audiovoices = [];\n\n /**\n * An object that holds information about which notes have been played and\n * which notes are currently being played. New notes are added as keys\n * on the fly. While a note has been attacked, but not released, the value of the\n * key is the audiovoice which is generating that note. When notes are released,\n * the value of the key becomes undefined.\n * @property notes\n */\n this.notes = {};\n\n //indices of the most recently used, and least recently used audiovoice\n this._newest = 0;\n this._oldest = 0;\n\n /**\n * A PolySynth must have at least 1 voice, defaults to 8\n * @property polyvalue\n */\n this.maxVoices = maxVoices || 8;\n\n /**\n * Monosynth that generates the sound for each note that is triggered. The\n * p5.PolySynth defaults to using the p5.MonoSynth as its voice.\n * @property AudioVoice\n */\n this.AudioVoice = audioVoice === undefined ? p5.MonoSynth : audioVoice;\n\n /**\n * This value must only change as a note is attacked or released. Due to delay\n * and sustain times, Tone.TimelineSignal is required to schedule the change in value.\n\t * @private\n * @property {Tone.TimelineSignal} _voicesInUse\n */\n this._voicesInUse = new TimelineSignal(0);\n\n this.output = p5sound.audiocontext.createGain();\n this.connect();\n\n //Construct the appropriate number of audiovoices\n this._allocateVoices();\n p5sound.soundArray.push(this);\n };\n\n /**\n * Construct the appropriate number of audiovoices\n * @private\n * @for p5.PolySynth\n * @method _allocateVoices\n */\n p5.PolySynth.prototype._allocateVoices = function() {\n for(var i = 0; i< this.maxVoices; i++) {\n this.audiovoices.push(new this.AudioVoice());\n this.audiovoices[i].disconnect();\n this.audiovoices[i].connect(this.output);\n }\n };\n\n /**\n * Play a note by triggering noteAttack and noteRelease with sustain time\n *\n * @method play\n * @for p5.PolySynth\n * @param {Number} [note] midi note to play (ranging from 0 to 127 - 60 being a middle C)\n * @param {Number} [velocity] velocity of the note to play (ranging from 0 to 1)\n * @param {Number} [secondsFromNow] time from now (in seconds) at which to play\n * @param {Number} [sustainTime] time to sustain before releasing the envelope\n * @example\n *
\n * let polySynth;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playSynth);\n * background(220);\n * text('click to play', 20, 20);\n *\n * polySynth = new p5.PolySynth();\n * }\n *\n * function playSynth() {\n * userStartAudio();\n *\n * // note duration (in seconds)\n * let dur = 1.5;\n *\n * // time from now (in seconds)\n * let time = 0;\n *\n * // velocity (volume, from 0 to 1)\n * let vel = 0.1;\n *\n * // notes can overlap with each other\n * polySynth.play('G2', vel, 0, dur);\n * polySynth.play('C3', vel, time += 1/3, dur);\n * polySynth.play('G3', vel, time += 1/3, dur);\n * }\n *
\n */\n p5.PolySynth.prototype.play = function (note,velocity, secondsFromNow, susTime) {\n var susTime = susTime || 1;\n this.noteAttack(note, velocity, secondsFromNow);\n this.noteRelease(note, secondsFromNow + susTime);\n };\n\n\n /**\n * noteADSR sets the envelope for a specific note that has just been triggered.\n * Using this method modifies the envelope of whichever audiovoice is being used\n * to play the desired note. The envelope should be reset before noteRelease is called\n * in order to prevent the modified envelope from being used on other notes.\n *\n * @method noteADSR\n * @for p5.PolySynth\n * @param {Number} [note] Midi note on which ADSR should be set.\n * @param {Number} [attackTime] Time (in seconds before envelope\n * reaches Attack Level\n * @param {Number} [decayTime] Time (in seconds) before envelope\n * reaches Decay/Sustain Level\n * @param {Number} [susRatio] Ratio between attackLevel and releaseLevel, on a scale from 0 to 1,\n * where 1.0 = attackLevel, 0.0 = releaseLevel.\n * The susRatio determines the decayLevel and the level at which the\n * sustain portion of the envelope will sustain.\n * For example, if attackLevel is 0.4, releaseLevel is 0,\n * and susAmt is 0.5, the decayLevel would be 0.2. If attackLevel is\n * increased to 1.0 (using setRange),\n * then decayLevel would increase proportionally, to become 0.5.\n * @param {Number} [releaseTime] Time in seconds from now (defaults to 0)\n **/\n\n p5.PolySynth.prototype.noteADSR = function (note,a,d,s,r,timeFromNow) {\n var now = p5sound.audiocontext.currentTime;\n var timeFromNow = timeFromNow || 0;\n var t = now + timeFromNow\n this.audiovoices[ this.notes[note].getValueAtTime(t) ].setADSR(a,d,s,r);\n };\n\n\n /**\n * Set the PolySynths global envelope. This method modifies the envelopes of each\n * monosynth so that all notes are played with this envelope.\n *\n * @method setADSR\n * @for p5.PolySynth\n * @param {Number} [attackTime] Time (in seconds before envelope\n * reaches Attack Level\n * @param {Number} [decayTime] Time (in seconds) before envelope\n * reaches Decay/Sustain Level\n * @param {Number} [susRatio] Ratio between attackLevel and releaseLevel, on a scale from 0 to 1,\n * where 1.0 = attackLevel, 0.0 = releaseLevel.\n * The susRatio determines the decayLevel and the level at which the\n * sustain portion of the envelope will sustain.\n * For example, if attackLevel is 0.4, releaseLevel is 0,\n * and susAmt is 0.5, the decayLevel would be 0.2. If attackLevel is\n * increased to 1.0 (using setRange),\n * then decayLevel would increase proportionally, to become 0.5.\n * @param {Number} [releaseTime] Time in seconds from now (defaults to 0)\n **/\n p5.PolySynth.prototype.setADSR = function(a,d,s,r) {\n this.audiovoices.forEach(function(voice) {\n voice.setADSR(a,d,s,r);\n });\n };\n\n /**\n * Trigger the Attack, and Decay portion of a MonoSynth.\n * Similar to holding down a key on a piano, but it will\n * hold the sustain level until you let go.\n *\n * @method noteAttack\n * @for p5.PolySynth\n * @param {Number} [note] midi note on which attack should be triggered.\n * @param {Number} [velocity] velocity of the note to play (ranging from 0 to 1)/\n * @param {Number} [secondsFromNow] time from now (in seconds)\n * @example\n *
\n * let polySynth = new p5.PolySynth();\n * let pitches = ['G', 'D', 'G', 'C'];\n * let octaves = [2, 3, 4];\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playChord);\n * background(220);\n * text('tap to play', 20, 20);\n * }\n *\n * function playChord() {\n * userStartAudio();\n *\n * // play a chord: multiple notes at the same time\n * for (let i = 0; i < 4; i++) {\n * let note = random(pitches) + random(octaves);\n * polySynth.noteAttack(note, 0.1);\n * }\n * }\n *\n * function mouseReleased() {\n * // release all voices\n * polySynth.noteRelease();\n * }\n *
\n */\n p5.PolySynth.prototype.noteAttack = function (_note, _velocity, secondsFromNow) {\n //this value goes to the audiovoices which handle their own scheduling\n var secondsFromNow = ~~secondsFromNow;\n\n //this value is used by this._voicesInUse\n var acTime = p5sound.audiocontext.currentTime + secondsFromNow;\n\n //Convert note to frequency if necessary. This is because entries into this.notes\n //should be based on frequency for the sake of consistency.\n var note = noteToFreq(_note);\n var velocity = _velocity || 0.1;\n\n var currentVoice;\n\n //Release the note if it is already playing\n if (this.notes[note] && this.notes[note].getValueAtTime(acTime) !== null) {\n this.noteRelease(note, 0);\n }\n\n //Check to see how many voices are in use at the time the note will start\n if (this._voicesInUse.getValueAtTime(acTime) < this.maxVoices) {\n currentVoice = Math.max(~~this._voicesInUse.getValueAtTime(acTime), 0);\n }\n //If we are exceeding the polyvalue, bump off the oldest notes and replace\n //with a new note\n else {\n currentVoice = this._oldest;\n\n var oldestNote = p5.prototype.freqToMidi(this.audiovoices[this._oldest].oscillator.freq().value);\n this.noteRelease(oldestNote);\n this._oldest = ( this._oldest + 1 ) % (this.maxVoices - 1);\n }\n\n //Overrite the entry in the notes object. A note (frequency value)\n //corresponds to the index of the audiovoice that is playing it\n this.notes[note] = new TimelineSignal();\n this.notes[note].setValueAtTime(currentVoice, acTime);\n\n //Find the scheduled change in this._voicesInUse that will be previous to this new note\n //Add 1 and schedule this value at time 't', when this note will start playing\n var previousVal = this._voicesInUse._searchBefore(acTime) === null ? 0 : this._voicesInUse._searchBefore(acTime).value;\n this._voicesInUse.setValueAtTime(previousVal + 1, acTime);\n\n //Then update all scheduled values that follow to increase by 1\n this._updateAfter(acTime, 1);\n\n this._newest = currentVoice;\n //The audiovoice handles the actual scheduling of the note\n if (typeof velocity === 'number') {\n var maxRange = 1 / this._voicesInUse.getValueAtTime(acTime) * 2;\n velocity = velocity > maxRange ? maxRange : velocity;\n }\n this.audiovoices[currentVoice].triggerAttack(note, velocity, secondsFromNow);\n };\n\n /**\n * Private method to ensure accurate values of this._voicesInUse\n * Any time a new value is scheduled, it is necessary to increment all subsequent\n * scheduledValues after attack, and decrement all subsequent\n * scheduledValues after release\n *\n * @private\n * @for p5.PolySynth\n * @param {[type]} time [description]\n * @param {[type]} value [description]\n * @return {[type]} [description]\n */\n p5.PolySynth.prototype._updateAfter = function(time, value) {\n if(this._voicesInUse._searchAfter(time) === null) {\n return;\n } else{\n this._voicesInUse._searchAfter(time).value += value;\n var nextTime = this._voicesInUse._searchAfter(time).time;\n this._updateAfter(nextTime, value);\n }\n };\n\n\n /**\n * Trigger the Release of an AudioVoice note. This is similar to releasing\n * the key on a piano and letting the sound fade according to the\n * release level and release time.\n *\n * @method noteRelease\n * @for p5.PolySynth\n * @param {Number} [note] midi note on which attack should be triggered.\n * If no value is provided, all notes will be released.\n * @param {Number} [secondsFromNow] time to trigger the release\n * @example\n *
\n * let polySynth = new p5.PolySynth();\n * let pitches = ['G', 'D', 'G', 'C'];\n * let octaves = [2, 3, 4];\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playChord);\n * background(220);\n * text('tap to play', 20, 20);\n * }\n *\n * function playChord() {\n * userStartAudio();\n *\n * // play a chord: multiple notes at the same time\n * for (let i = 0; i < 4; i++) {\n * let note = random(pitches) + random(octaves);\n * polySynth.noteAttack(note, 0.1);\n * }\n * }\n *\n * function mouseReleased() {\n * // release all voices\n * polySynth.noteRelease();\n * }\n *
\n *\n */\n p5.PolySynth.prototype.noteRelease = function (_note,secondsFromNow) {\n var now = p5sound.audiocontext.currentTime;\n var tFromNow = secondsFromNow || 0;\n var t = now + tFromNow;\n\n // if a note value is not provided, release all voices\n if (!_note) {\n this.audiovoices.forEach(function(voice) {\n voice.triggerRelease(tFromNow)\n });\n this._voicesInUse.setValueAtTime(0, t);\n for (var n in this.notes) {\n this.notes[n].dispose();\n delete this.notes[n];\n }\n return;\n }\n\n //Make sure note is in frequency inorder to query the this.notes object\n var note = noteToFreq(_note);\n\n if (!this.notes[note] || this.notes[note].getValueAtTime(t) === null) {\n console.warn('Cannot release a note that is not already playing');\n } else {\n //Find the scheduled change in this._voicesInUse that will be previous to this new note\n //subtract 1 and schedule this value at time 't', when this note will stop playing\n var previousVal = Math.max(~~this._voicesInUse.getValueAtTime(t).value, 1);\n this._voicesInUse.setValueAtTime(previousVal - 1, t);\n //Then update all scheduled values that follow to decrease by 1 but never go below 0\n if (previousVal > 0) {\n this._updateAfter(t, -1);\n }\n\n this.audiovoices[ this.notes[note].getValueAtTime(t) ].triggerRelease(tFromNow);\n this.notes[note].dispose();\n delete this.notes[note];\n\n this._newest = this._newest === 0 ? 0 : (this._newest - 1) % (this.maxVoices - 1);\n }\n\n };\n\n /**\n * Connect to a p5.sound / Web Audio object.\n *\n * @method connect\n * @for p5.PolySynth\n * @param {Object} unit A p5.sound or Web Audio object\n */\n p5.PolySynth.prototype.connect = function (unit) {\n var u = unit || p5sound.input;\n this.output.connect(u.input ? u.input : u);\n };\n\n /**\n * Disconnect all outputs\n *\n * @method disconnect\n * @for p5.PolySynth\n */\n p5.PolySynth.prototype.disconnect = function() {\n if (this.output) {\n this.output.disconnect();\n }\n };\n\n /**\n * Get rid of the MonoSynth and free up its resources / memory.\n *\n * @method dispose\n * @for p5.PolySynth\n */\n p5.PolySynth.prototype.dispose = function() {\n this.audiovoices.forEach(function(voice) {\n voice.dispose();\n });\n\n if (this.output) {\n this.output.disconnect();\n delete this.output;\n }\n };\n\n});\n","'use strict';\n\ndefine(function (require) {\n\n require('audioworklet-polyfill');\n require('shims');\n require('audiocontext');\n var p5SOUND = require('master');\n require('helpers');\n require('errorHandler');\n require('audioWorklet');\n require('panner');\n require('soundfile');\n require('amplitude');\n require('fft');\n require('signal');\n require('oscillator');\n require('envelope');\n require('pulse');\n require('noise');\n require('audioin');\n require('filter');\n require('eq');\n require('panner3d');\n require('listener3d');\n require('delay');\n require('reverb');\n require('metro');\n require('looper');\n require('soundLoop');\n require('compressor');\n require('soundRecorder');\n require('peakDetect');\n require('gain');\n require('monosynth');\n require('polysynth');\n require('distortion');\n require('audioVoice');\n require('monosynth');\n require('polysynth');\n\n return p5SOUND;\n\n});\n","!function(){var e,t=[];function r(e){var r=this,n={},i=-1;this.parameters.forEach(function(e,o){var s=t[++i]||(t[i]=new Float32Array(r.bufferSize));s.fill(e.value),n[o]=s}),this.processor.realm.exec(\"self.sampleRate=sampleRate=\"+this.context.sampleRate+\";self.currentTime=currentTime=\"+this.context.currentTime);var s=o(e.inputBuffer),a=o(e.outputBuffer);this.instance.process([s],[a],n)}function o(e){for(var t=[],r=0;r= this._length) {\\n this._writeIndex = 0;\\n } // For excessive frames, the buffer will be overwritten.\\n\\n\\n this._framesAvailable += sourceLength;\\n\\n if (this._framesAvailable > this._length) {\\n this._framesAvailable = this._length;\\n }\\n }\\n /**\\n * Pull data out of buffer and fill a given sequence of Float32Arrays.\\n *\\n * @param {array} arraySequence An array of Float32Arrays.\\n */\\n\\n }, {\\n key: \\\"pull\\\",\\n value: function pull(arraySequence) {\\n // The channel count of arraySequence and the length of each channel must\\n // match with this buffer obejct.\\n // If the FIFO is completely empty, do nothing.\\n if (this._framesAvailable === 0) {\\n return;\\n }\\n\\n var destinationLength = arraySequence[0].length; // Transfer data from the internal buffer to the |arraySequence| storage.\\n\\n for (var i = 0; i < destinationLength; ++i) {\\n var readIndex = (this._readIndex + i) % this._length;\\n\\n for (var channel = 0; channel < this._channelCount; ++channel) {\\n arraySequence[channel][i] = this._channelData[channel][readIndex];\\n }\\n }\\n\\n this._readIndex += destinationLength;\\n\\n if (this._readIndex >= this._length) {\\n this._readIndex = 0;\\n }\\n\\n this._framesAvailable -= destinationLength;\\n\\n if (this._framesAvailable < 0) {\\n this._framesAvailable = 0;\\n }\\n }\\n }, {\\n key: \\\"framesAvailable\\\",\\n get: function get() {\\n return this._framesAvailable;\\n }\\n }]);\\n\\n return RingBuffer;\\n }()\\n}[\\\"default\\\"];\\n\\nvar RecorderProcessor =\\n/*#__PURE__*/\\nfunction (_AudioWorkletProcesso) {\\n _inherits(RecorderProcessor, _AudioWorkletProcesso);\\n\\n function RecorderProcessor(options) {\\n var _this;\\n\\n _classCallCheck(this, RecorderProcessor);\\n\\n _this = _possibleConstructorReturn(this, _getPrototypeOf(RecorderProcessor).call(this));\\n var processorOptions = options.processorOptions || {};\\n _this.numOutputChannels = options.outputChannelCount || 2;\\n _this.numInputChannels = processorOptions.numInputChannels || 2;\\n _this.bufferSize = processorOptions.bufferSize || 1024;\\n _this.recording = false;\\n\\n _this.clear();\\n\\n _this.port.onmessage = function (event) {\\n var data = event.data;\\n\\n if (data.name === 'start') {\\n _this.record(data.duration);\\n } else if (data.name === 'stop') {\\n _this.stop();\\n }\\n };\\n\\n return _this;\\n }\\n\\n _createClass(RecorderProcessor, [{\\n key: \\\"process\\\",\\n value: function process(inputs) {\\n if (!this.recording) {\\n return true;\\n } else if (this.sampleLimit && this.recordedSamples >= this.sampleLimit) {\\n this.stop();\\n return true;\\n }\\n\\n var input = inputs[0];\\n this.inputRingBuffer.push(input);\\n\\n if (this.inputRingBuffer.framesAvailable >= this.bufferSize) {\\n this.inputRingBuffer.pull(this.inputRingBufferArraySequence);\\n\\n for (var channel = 0; channel < this.numOutputChannels; ++channel) {\\n var inputChannelCopy = this.inputRingBufferArraySequence[channel].slice();\\n\\n if (channel === 0) {\\n this.leftBuffers.push(inputChannelCopy);\\n\\n if (this.numInputChannels === 1) {\\n this.rightBuffers.push(inputChannelCopy);\\n }\\n } else if (channel === 1 && this.numInputChannels > 1) {\\n this.rightBuffers.push(inputChannelCopy);\\n }\\n }\\n\\n this.recordedSamples += this.bufferSize;\\n }\\n\\n return true;\\n }\\n }, {\\n key: \\\"record\\\",\\n value: function record(duration) {\\n if (duration) {\\n this.sampleLimit = Math.round(duration * sampleRate);\\n }\\n\\n this.recording = true;\\n }\\n }, {\\n key: \\\"stop\\\",\\n value: function stop() {\\n this.recording = false;\\n var buffers = this.getBuffers();\\n var leftBuffer = buffers[0].buffer;\\n var rightBuffer = buffers[1].buffer;\\n this.port.postMessage({\\n name: 'buffers',\\n leftBuffer: leftBuffer,\\n rightBuffer: rightBuffer\\n }, [leftBuffer, rightBuffer]);\\n this.clear();\\n }\\n }, {\\n key: \\\"getBuffers\\\",\\n value: function getBuffers() {\\n var buffers = [];\\n buffers.push(this.mergeBuffers(this.leftBuffers));\\n buffers.push(this.mergeBuffers(this.rightBuffers));\\n return buffers;\\n }\\n }, {\\n key: \\\"mergeBuffers\\\",\\n value: function mergeBuffers(channelBuffer) {\\n var result = new Float32Array(this.recordedSamples);\\n var offset = 0;\\n var lng = channelBuffer.length;\\n\\n for (var i = 0; i < lng; i++) {\\n var buffer = channelBuffer[i];\\n result.set(buffer, offset);\\n offset += buffer.length;\\n }\\n\\n return result;\\n }\\n }, {\\n key: \\\"clear\\\",\\n value: function clear() {\\n var _this2 = this;\\n\\n this.leftBuffers = [];\\n this.rightBuffers = [];\\n this.inputRingBuffer = new RingBuffer(this.bufferSize, this.numInputChannels);\\n this.inputRingBufferArraySequence = new Array(this.numInputChannels).fill(null).map(function () {\\n return new Float32Array(_this2.bufferSize);\\n });\\n this.recordedSamples = 0;\\n this.sampleLimit = null;\\n }\\n }]);\\n\\n return RecorderProcessor;\\n}(_wrapNativeSuper(AudioWorkletProcessor));\\n\\nregisterProcessor(processorNames.recorderProcessor, RecorderProcessor);\"","export default \"function _typeof(obj) { if (typeof Symbol === \\\"function\\\" && typeof Symbol.iterator === \\\"symbol\\\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \\\"function\\\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \\\"symbol\\\" : typeof obj; }; } return _typeof(obj); }\\n\\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \\\"object\\\" || typeof call === \\\"function\\\")) { return call; } return _assertThisInitialized(self); }\\n\\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\\\"this hasn't been initialised - super() hasn't been called\\\"); } return self; }\\n\\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \\\"function\\\" && superClass !== null) { throw new TypeError(\\\"Super expression must either be null or a function\\\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }\\n\\nfunction _wrapNativeSuper(Class) { var _cache = typeof Map === \\\"function\\\" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== \\\"function\\\") { throw new TypeError(\\\"Super expression must either be null or a function\\\"); } if (typeof _cache !== \\\"undefined\\\") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }\\n\\nfunction isNativeReflectConstruct() { if (typeof Reflect === \\\"undefined\\\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \\\"function\\\") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\\n\\nfunction _construct(Parent, args, Class) { if (isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }\\n\\nfunction _isNativeFunction(fn) { return Function.toString.call(fn).indexOf(\\\"[native code]\\\") !== -1; }\\n\\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\\n\\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\\n\\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\\\"Cannot call a class as a function\\\"); } }\\n\\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\\\"value\\\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\\n\\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\\n\\n// import dependencies via preval.require so that they're available as values at compile time\\nvar processorNames = {\\n \\\"recorderProcessor\\\": \\\"recorder-processor\\\",\\n \\\"soundFileProcessor\\\": \\\"sound-file-processor\\\",\\n \\\"amplitudeProcessor\\\": \\\"amplitude-processor\\\"\\n};\\nvar RingBuffer = {\\n \\\"default\\\":\\n /*#__PURE__*/\\n function () {\\n /**\\n * @constructor\\n * @param {number} length Buffer length in frames.\\n * @param {number} channelCount Buffer channel count.\\n */\\n function RingBuffer(length, channelCount) {\\n _classCallCheck(this, RingBuffer);\\n\\n this._readIndex = 0;\\n this._writeIndex = 0;\\n this._framesAvailable = 0;\\n this._channelCount = channelCount;\\n this._length = length;\\n this._channelData = [];\\n\\n for (var i = 0; i < this._channelCount; ++i) {\\n this._channelData[i] = new Float32Array(length);\\n }\\n }\\n /**\\n * Getter for Available frames in buffer.\\n *\\n * @return {number} Available frames in buffer.\\n */\\n\\n\\n _createClass(RingBuffer, [{\\n key: \\\"push\\\",\\n\\n /**\\n * Push a sequence of Float32Arrays to buffer.\\n *\\n * @param {array} arraySequence A sequence of Float32Arrays.\\n */\\n value: function push(arraySequence) {\\n // The channel count of arraySequence and the length of each channel must\\n // match with this buffer obejct.\\n // Transfer data from the |arraySequence| storage to the internal buffer.\\n var sourceLength = arraySequence[0].length;\\n\\n for (var i = 0; i < sourceLength; ++i) {\\n var writeIndex = (this._writeIndex + i) % this._length;\\n\\n for (var channel = 0; channel < this._channelCount; ++channel) {\\n this._channelData[channel][writeIndex] = arraySequence[channel][i];\\n }\\n }\\n\\n this._writeIndex += sourceLength;\\n\\n if (this._writeIndex >= this._length) {\\n this._writeIndex = 0;\\n } // For excessive frames, the buffer will be overwritten.\\n\\n\\n this._framesAvailable += sourceLength;\\n\\n if (this._framesAvailable > this._length) {\\n this._framesAvailable = this._length;\\n }\\n }\\n /**\\n * Pull data out of buffer and fill a given sequence of Float32Arrays.\\n *\\n * @param {array} arraySequence An array of Float32Arrays.\\n */\\n\\n }, {\\n key: \\\"pull\\\",\\n value: function pull(arraySequence) {\\n // The channel count of arraySequence and the length of each channel must\\n // match with this buffer obejct.\\n // If the FIFO is completely empty, do nothing.\\n if (this._framesAvailable === 0) {\\n return;\\n }\\n\\n var destinationLength = arraySequence[0].length; // Transfer data from the internal buffer to the |arraySequence| storage.\\n\\n for (var i = 0; i < destinationLength; ++i) {\\n var readIndex = (this._readIndex + i) % this._length;\\n\\n for (var channel = 0; channel < this._channelCount; ++channel) {\\n arraySequence[channel][i] = this._channelData[channel][readIndex];\\n }\\n }\\n\\n this._readIndex += destinationLength;\\n\\n if (this._readIndex >= this._length) {\\n this._readIndex = 0;\\n }\\n\\n this._framesAvailable -= destinationLength;\\n\\n if (this._framesAvailable < 0) {\\n this._framesAvailable = 0;\\n }\\n }\\n }, {\\n key: \\\"framesAvailable\\\",\\n get: function get() {\\n return this._framesAvailable;\\n }\\n }]);\\n\\n return RingBuffer;\\n }()\\n}[\\\"default\\\"];\\n\\nvar SoundFileProcessor =\\n/*#__PURE__*/\\nfunction (_AudioWorkletProcesso) {\\n _inherits(SoundFileProcessor, _AudioWorkletProcesso);\\n\\n function SoundFileProcessor(options) {\\n var _this;\\n\\n _classCallCheck(this, SoundFileProcessor);\\n\\n _this = _possibleConstructorReturn(this, _getPrototypeOf(SoundFileProcessor).call(this));\\n var processorOptions = options.processorOptions || {};\\n _this.bufferSize = processorOptions.bufferSize || 256;\\n _this.inputRingBuffer = new RingBuffer(_this.bufferSize, 1);\\n _this.inputRingBufferArraySequence = [new Float32Array(_this.bufferSize)];\\n return _this;\\n }\\n\\n _createClass(SoundFileProcessor, [{\\n key: \\\"process\\\",\\n value: function process(inputs) {\\n var input = inputs[0]; // we only care about the first input channel, because that contains the position data\\n\\n this.inputRingBuffer.push([input[0]]);\\n\\n if (this.inputRingBuffer.framesAvailable >= this.bufferSize) {\\n this.inputRingBuffer.pull(this.inputRingBufferArraySequence);\\n var inputChannel = this.inputRingBufferArraySequence[0];\\n var position = inputChannel[inputChannel.length - 1] || 0;\\n this.port.postMessage({\\n name: 'position',\\n position: position\\n });\\n }\\n\\n return true;\\n }\\n }]);\\n\\n return SoundFileProcessor;\\n}(_wrapNativeSuper(AudioWorkletProcessor));\\n\\nregisterProcessor(processorNames.soundFileProcessor, SoundFileProcessor);\"","export default \"function _typeof(obj) { if (typeof Symbol === \\\"function\\\" && typeof Symbol.iterator === \\\"symbol\\\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \\\"function\\\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \\\"symbol\\\" : typeof obj; }; } return _typeof(obj); }\\n\\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \\\"object\\\" || typeof call === \\\"function\\\")) { return call; } return _assertThisInitialized(self); }\\n\\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\\\"this hasn't been initialised - super() hasn't been called\\\"); } return self; }\\n\\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \\\"function\\\" && superClass !== null) { throw new TypeError(\\\"Super expression must either be null or a function\\\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }\\n\\nfunction _wrapNativeSuper(Class) { var _cache = typeof Map === \\\"function\\\" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== \\\"function\\\") { throw new TypeError(\\\"Super expression must either be null or a function\\\"); } if (typeof _cache !== \\\"undefined\\\") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }\\n\\nfunction isNativeReflectConstruct() { if (typeof Reflect === \\\"undefined\\\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \\\"function\\\") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\\n\\nfunction _construct(Parent, args, Class) { if (isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }\\n\\nfunction _isNativeFunction(fn) { return Function.toString.call(fn).indexOf(\\\"[native code]\\\") !== -1; }\\n\\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\\n\\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\\n\\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\\\"Cannot call a class as a function\\\"); } }\\n\\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\\\"value\\\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\\n\\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\\n\\n// import dependencies via preval.require so that they're available as values at compile time\\nvar processorNames = {\\n \\\"recorderProcessor\\\": \\\"recorder-processor\\\",\\n \\\"soundFileProcessor\\\": \\\"sound-file-processor\\\",\\n \\\"amplitudeProcessor\\\": \\\"amplitude-processor\\\"\\n};\\nvar RingBuffer = {\\n \\\"default\\\":\\n /*#__PURE__*/\\n function () {\\n /**\\n * @constructor\\n * @param {number} length Buffer length in frames.\\n * @param {number} channelCount Buffer channel count.\\n */\\n function RingBuffer(length, channelCount) {\\n _classCallCheck(this, RingBuffer);\\n\\n this._readIndex = 0;\\n this._writeIndex = 0;\\n this._framesAvailable = 0;\\n this._channelCount = channelCount;\\n this._length = length;\\n this._channelData = [];\\n\\n for (var i = 0; i < this._channelCount; ++i) {\\n this._channelData[i] = new Float32Array(length);\\n }\\n }\\n /**\\n * Getter for Available frames in buffer.\\n *\\n * @return {number} Available frames in buffer.\\n */\\n\\n\\n _createClass(RingBuffer, [{\\n key: \\\"push\\\",\\n\\n /**\\n * Push a sequence of Float32Arrays to buffer.\\n *\\n * @param {array} arraySequence A sequence of Float32Arrays.\\n */\\n value: function push(arraySequence) {\\n // The channel count of arraySequence and the length of each channel must\\n // match with this buffer obejct.\\n // Transfer data from the |arraySequence| storage to the internal buffer.\\n var sourceLength = arraySequence[0].length;\\n\\n for (var i = 0; i < sourceLength; ++i) {\\n var writeIndex = (this._writeIndex + i) % this._length;\\n\\n for (var channel = 0; channel < this._channelCount; ++channel) {\\n this._channelData[channel][writeIndex] = arraySequence[channel][i];\\n }\\n }\\n\\n this._writeIndex += sourceLength;\\n\\n if (this._writeIndex >= this._length) {\\n this._writeIndex = 0;\\n } // For excessive frames, the buffer will be overwritten.\\n\\n\\n this._framesAvailable += sourceLength;\\n\\n if (this._framesAvailable > this._length) {\\n this._framesAvailable = this._length;\\n }\\n }\\n /**\\n * Pull data out of buffer and fill a given sequence of Float32Arrays.\\n *\\n * @param {array} arraySequence An array of Float32Arrays.\\n */\\n\\n }, {\\n key: \\\"pull\\\",\\n value: function pull(arraySequence) {\\n // The channel count of arraySequence and the length of each channel must\\n // match with this buffer obejct.\\n // If the FIFO is completely empty, do nothing.\\n if (this._framesAvailable === 0) {\\n return;\\n }\\n\\n var destinationLength = arraySequence[0].length; // Transfer data from the internal buffer to the |arraySequence| storage.\\n\\n for (var i = 0; i < destinationLength; ++i) {\\n var readIndex = (this._readIndex + i) % this._length;\\n\\n for (var channel = 0; channel < this._channelCount; ++channel) {\\n arraySequence[channel][i] = this._channelData[channel][readIndex];\\n }\\n }\\n\\n this._readIndex += destinationLength;\\n\\n if (this._readIndex >= this._length) {\\n this._readIndex = 0;\\n }\\n\\n this._framesAvailable -= destinationLength;\\n\\n if (this._framesAvailable < 0) {\\n this._framesAvailable = 0;\\n }\\n }\\n }, {\\n key: \\\"framesAvailable\\\",\\n get: function get() {\\n return this._framesAvailable;\\n }\\n }]);\\n\\n return RingBuffer;\\n }()\\n}[\\\"default\\\"];\\n\\nvar AmplitudeProcessor =\\n/*#__PURE__*/\\nfunction (_AudioWorkletProcesso) {\\n _inherits(AmplitudeProcessor, _AudioWorkletProcesso);\\n\\n function AmplitudeProcessor(options) {\\n var _this;\\n\\n _classCallCheck(this, AmplitudeProcessor);\\n\\n _this = _possibleConstructorReturn(this, _getPrototypeOf(AmplitudeProcessor).call(this));\\n var processorOptions = options.processorOptions || {};\\n _this.numOutputChannels = options.outputChannelCount || 1;\\n _this.numInputChannels = processorOptions.numInputChannels || 2;\\n _this.normalize = processorOptions.normalize || false;\\n _this.smoothing = processorOptions.smoothing || 0;\\n _this.bufferSize = processorOptions.bufferSize || 2048;\\n _this.inputRingBuffer = new RingBuffer(_this.bufferSize, _this.numInputChannels);\\n _this.outputRingBuffer = new RingBuffer(_this.bufferSize, _this.numOutputChannels);\\n _this.inputRingBufferArraySequence = new Array(_this.numInputChannels).fill(null).map(function () {\\n return new Float32Array(_this.bufferSize);\\n });\\n _this.stereoVol = [0, 0];\\n _this.stereoVolNorm = [0, 0];\\n _this.volMax = 0.001;\\n\\n _this.port.onmessage = function (event) {\\n var data = event.data;\\n\\n if (data.name === 'toggleNormalize') {\\n _this.normalize = data.normalize;\\n } else if (data.name === 'smoothing') {\\n _this.smoothing = Math.max(0, Math.min(1, data.smoothing));\\n }\\n };\\n\\n return _this;\\n } // TO DO make this stereo / dependent on # of audio channels\\n\\n\\n _createClass(AmplitudeProcessor, [{\\n key: \\\"process\\\",\\n value: function process(inputs, outputs) {\\n var input = inputs[0];\\n var output = outputs[0];\\n var smoothing = this.smoothing;\\n this.inputRingBuffer.push(input);\\n\\n if (this.inputRingBuffer.framesAvailable >= this.bufferSize) {\\n this.inputRingBuffer.pull(this.inputRingBufferArraySequence);\\n\\n for (var channel = 0; channel < this.numInputChannels; ++channel) {\\n var inputBuffer = this.inputRingBufferArraySequence[channel];\\n var bufLength = inputBuffer.length;\\n var sum = 0;\\n\\n for (var i = 0; i < bufLength; i++) {\\n var x = inputBuffer[i];\\n\\n if (this.normalize) {\\n sum += Math.max(Math.min(x / this.volMax, 1), -1) * Math.max(Math.min(x / this.volMax, 1), -1);\\n } else {\\n sum += x * x;\\n }\\n } // ... then take the square root of the sum.\\n\\n\\n var rms = Math.sqrt(sum / bufLength);\\n this.stereoVol[channel] = Math.max(rms, this.stereoVol[channel] * smoothing);\\n this.volMax = Math.max(this.stereoVol[channel], this.volMax);\\n } // calculate stero normalized volume and add volume from all channels together\\n\\n\\n var volSum = 0;\\n\\n for (var index = 0; index < this.stereoVol.length; index++) {\\n this.stereoVolNorm[index] = Math.max(Math.min(this.stereoVol[index] / this.volMax, 1), 0);\\n volSum += this.stereoVol[index];\\n } // volume is average of channels\\n\\n\\n var volume = volSum / this.stereoVol.length; // normalized value\\n\\n var volNorm = Math.max(Math.min(volume / this.volMax, 1), 0);\\n this.port.postMessage({\\n name: 'amplitude',\\n volume: volume,\\n volNorm: volNorm,\\n stereoVol: this.stereoVol,\\n stereoVolNorm: this.stereoVolNorm\\n }); // pass input through to output\\n\\n this.outputRingBuffer.push(this.inputRingBufferArraySequence);\\n } // pull 128 frames out of the ring buffer\\n // if the ring buffer does not have enough frames, the output will be silent\\n\\n\\n this.outputRingBuffer.pull(output);\\n return true;\\n }\\n }]);\\n\\n return AmplitudeProcessor;\\n}(_wrapNativeSuper(AudioWorkletProcessor));\\n\\nregisterProcessor(processorNames.amplitudeProcessor, AmplitudeProcessor);\"","'use strict';\n\ndefine(function (require) {\n\n var p5sound = require('master');\n var ac = p5sound.audiocontext;\n\n // Stereo panner\n // if there is a stereo panner node use it\n if(typeof ac.createStereoPanner !== 'undefined') {\n p5.Panner = function (input, output) {\n this.stereoPanner = this.input = ac.createStereoPanner();\n input.connect(this.stereoPanner);\n this.stereoPanner.connect(output);\n };\n\n p5.Panner.prototype.pan = function(val, tFromNow) {\n var time = tFromNow || 0;\n var t = ac.currentTime + time;\n\n this.stereoPanner.pan.linearRampToValueAtTime(val, t);\n };\n\n //not implemented because stereopanner\n //node does not require this and will automatically\n //convert single channel or multichannel to stereo.\n //tested with single and stereo, not with (>2) multichannel\n p5.Panner.prototype.inputChannels = function() {};\n\n p5.Panner.prototype.connect = function(obj) {\n this.stereoPanner.connect(obj);\n };\n\n p5.Panner.prototype.disconnect = function() {\n if (this.stereoPanner) {\n this.stereoPanner.disconnect();\n }\n };\n\n } else {\n // if there is no createStereoPanner object\n // such as in safari 7.1.7 at the time of writing this\n // use this method to create the effect\n p5.Panner = function(input, output, numInputChannels) {\n this.input = ac.createGain();\n input.connect(this.input);\n\n this.left = ac.createGain();\n this.right = ac.createGain();\n this.left.channelInterpretation = 'discrete';\n this.right.channelInterpretation = 'discrete';\n\n // if input is stereo\n if (numInputChannels > 1) {\n this.splitter = ac.createChannelSplitter(2);\n this.input.connect(this.splitter);\n\n this.splitter.connect(this.left, 1);\n this.splitter.connect(this.right, 0);\n }\n else {\n this.input.connect(this.left);\n this.input.connect(this.right);\n }\n\n this.output = ac.createChannelMerger(2);\n this.left.connect(this.output, 0, 1);\n this.right.connect(this.output, 0, 0);\n this.output.connect(output);\n };\n\n // -1 is left, +1 is right\n p5.Panner.prototype.pan = function(val, tFromNow) {\n var time = tFromNow || 0;\n var t = ac.currentTime + time;\n var v = (val + 1) / 2;\n var rightVal = Math.cos(v*Math.PI/2);\n var leftVal = Math.sin(v * Math.PI/2);\n this.left.gain.linearRampToValueAtTime(leftVal, t);\n this.right.gain.linearRampToValueAtTime(rightVal, t);\n };\n\n p5.Panner.prototype.inputChannels = function(numChannels) {\n if (numChannels === 1) {\n this.input.disconnect();\n this.input.connect(this.left);\n this.input.connect(this.right);\n } else if (numChannels === 2) {\n if (typeof(this.splitter === 'undefined')) {\n this.splitter = ac.createChannelSplitter(2);\n }\n this.input.disconnect();\n this.input.connect(this.splitter);\n this.splitter.connect(this.left, 1);\n this.splitter.connect(this.right, 0);\n }\n };\n\n p5.Panner.prototype.connect = function(obj) {\n this.output.connect(obj);\n };\n\n p5.Panner.prototype.disconnect = function() {\n if (this.output) {\n this.output.disconnect();\n }\n };\n }\n});\n","'use strict';\n\ndefine(function (require) {\n\n const CustomError = require('errorHandler');\n const p5sound = require('master');\n const ac = p5sound.audiocontext;\n const { midiToFreq, convertToWav, safeBufferSize } = require('helpers');\n var processorNames = require('./audioWorklet/processorNames');\n\n /**\n *

SoundFile object with a path to a file.

\n *\n *

The p5.SoundFile may not be available immediately because\n * it loads the file information asynchronously.

\n *\n *

To do something with the sound as soon as it loads\n * pass the name of a function as the second parameter.

\n *\n *

Only one file path is required. However, audio file formats\n * (i.e. mp3, ogg, wav and m4a/aac) are not supported by all\n * web browsers. If you want to ensure compatability, instead of a single\n * file path, you may include an Array of filepaths, and the browser will\n * choose a format that works.

\n *\n * @class p5.SoundFile\n * @constructor\n * @param {String|Array} path path to a sound file (String). Optionally,\n * you may include multiple file formats in\n * an array. Alternately, accepts an object\n * from the HTML5 File API, or a p5.File.\n * @param {Function} [successCallback] Name of a function to call once file loads\n * @param {Function} [errorCallback] Name of a function to call if file fails to\n * load. This function will receive an error or\n * XMLHttpRequest object with information\n * about what went wrong.\n * @param {Function} [whileLoadingCallback] Name of a function to call while file\n * is loading. That function will\n * receive progress of the request to\n * load the sound file\n * (between 0 and 1) as its first\n * parameter. This progress\n * does not account for the additional\n * time needed to decode the audio data.\n *\n * @example\n *
\n * let mySound;\n * function preload() {\n * soundFormats('mp3', 'ogg');\n * mySound = loadSound('assets/doorbell');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * text('tap here to play', 10, 20);\n * }\n *\n * function canvasPressed() {\n * // playing a sound file on a user gesture\n * // is equivalent to `userStartAudio()`\n * mySound.play();\n * }\n *
\n */\n p5.SoundFile = function(paths, onload, onerror, whileLoading) {\n if (typeof paths !== 'undefined') {\n if (typeof paths === 'string' || typeof paths[0] === 'string') {\n var path = p5.prototype._checkFileFormats(paths);\n this.url = path;\n }\n else if(typeof paths === 'object') {\n if (!(window.File && window.FileReader && window.FileList && window.Blob)) {\n // The File API isn't supported in this browser\n throw 'Unable to load file because the File API is not supported';\n }\n }\n\n // if type is a p5.File...get the actual file\n if (paths.file) {\n paths = paths.file;\n }\n\n this.file = paths;\n }\n\n // private _onended callback, set by the method: onended(callback)\n this._onended = function() {};\n\n this._looping = false;\n this._playing = false;\n this._paused = false;\n this._pauseTime = 0;\n\n // cues for scheduling events with addCue() removeCue()\n this._cues = [];\n this._cueIDCounter = 0;\n\n // position of the most recently played sample\n this._lastPos = 0;\n this._counterNode = null;\n this._workletNode = null;\n\n // array of sources so that they can all be stopped!\n this.bufferSourceNodes = [];\n\n // current source\n this.bufferSourceNode = null;\n\n this.buffer = null;\n this.playbackRate = 1;\n\n this.input = p5sound.audiocontext.createGain();\n this.output = p5sound.audiocontext.createGain();\n\n this.reversed = false;\n\n // start and end of playback / loop\n this.startTime = 0;\n this.endTime = null;\n this.pauseTime = 0;\n\n // \"restart\" would stop playback before retriggering\n this.mode = 'sustain';\n\n // time that playback was started, in millis\n this.startMillis = null;\n\n // stereo panning\n this.panPosition = 0.0;\n this.panner = new p5.Panner(this.output, p5sound.input, 2);\n\n // it is possible to instantiate a soundfile with no path\n if (this.url || this.file) {\n this.load(onload, onerror);\n }\n\n // add this p5.SoundFile to the soundArray\n p5sound.soundArray.push(this);\n\n if (typeof whileLoading === 'function') {\n this._whileLoading = whileLoading;\n } else {\n this._whileLoading = function() {};\n }\n\n this._clearOnEnd = _clearOnEnd.bind(this);\n };\n\n // register preload handling of loadSound\n p5.prototype.registerPreloadMethod('loadSound', p5.prototype);\n\n /**\n * loadSound() returns a new p5.SoundFile from a specified\n * path. If called during preload(), the p5.SoundFile will be ready\n * to play in time for setup() and draw(). If called outside of\n * preload, the p5.SoundFile will not be ready immediately, so\n * loadSound accepts a callback as the second parameter. Using a\n * \n * local server is recommended when loading external files.\n *\n * @method loadSound\n * @for p5\n * @param {String|Array} path Path to the sound file, or an array with\n * paths to soundfiles in multiple formats\n * i.e. ['sound.ogg', 'sound.mp3'].\n * Alternately, accepts an object: either\n * from the HTML5 File API, or a p5.File.\n * @param {Function} [successCallback] Name of a function to call once file loads\n * @param {Function} [errorCallback] Name of a function to call if there is\n * an error loading the file.\n * @param {Function} [whileLoading] Name of a function to call while file is loading.\n * This function will receive the percentage loaded\n * so far, from 0.0 to 1.0.\n * @return {SoundFile} Returns a p5.SoundFile\n * @example\n *
\n * let mySound;\n * function preload() {\n * soundFormats('mp3', 'ogg');\n * mySound = loadSound('assets/doorbell');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * text('tap here to play', 10, 20);\n * }\n *\n * function canvasPressed() {\n * // playing a sound file on a user gesture\n * // is equivalent to `userStartAudio()`\n * mySound.play();\n * }\n *
\n */\n p5.prototype.loadSound = function(path, callback, onerror, whileLoading) {\n // if loading locally without a server\n if (window.location.origin.indexOf('file://') > -1 && window.cordova === 'undefined' ) {\n window.alert('This sketch may require a server to load external files. Please see http://bit.ly/1qcInwS');\n }\n\n var self = this;\n var s = new p5.SoundFile(path, function() {\n if(typeof callback === 'function') {\n callback.apply(self, arguments);\n }\n\n if (typeof self._decrementPreload === 'function') {\n self._decrementPreload();\n }\n }, onerror, whileLoading);\n\n return s;\n };\n\n /**\n * This is a helper function that the p5.SoundFile calls to load\n * itself. Accepts a callback (the name of another function)\n * as an optional parameter.\n *\n * @private\n * @for p5.SoundFile\n * @param {Function} [successCallback] Name of a function to call once file loads\n * @param {Function} [errorCallback] Name of a function to call if there is an error\n */\n p5.SoundFile.prototype.load = function(callback, errorCallback) {\n var self = this;\n var errorTrace = new Error().stack;\n\n if (this.url !== undefined && this.url !== '') {\n var request = new XMLHttpRequest();\n request.addEventListener('progress', function(evt) {\n self._updateProgress(evt);\n }, false);\n request.open('GET', this.url, true);\n request.responseType = 'arraybuffer';\n\n request.onload = function() {\n if (request.status === 200) {\n // on sucess loading file:\n if (!self.panner) return;\n ac.decodeAudioData(request.response,\n // success decoding buffer:\n function(buff) {\n if (!self.panner) return;\n self.buffer = buff;\n self.panner.inputChannels(buff.numberOfChannels);\n if (callback) {\n callback(self);\n }\n },\n // error decoding buffer. \"e\" is undefined in Chrome 11/22/2015\n function() {\n if (!self.panner) return;\n var err = new CustomError('decodeAudioData', errorTrace, self.url);\n var msg = 'AudioContext error at decodeAudioData for ' + self.url;\n if (errorCallback) {\n err.msg = msg;\n errorCallback(err);\n } else {\n console.error(msg +'\\n The error stack trace includes: \\n' + err.stack);\n }\n }\n );\n }\n // if request status != 200, it failed\n else {\n if (!self.panner) return;\n var err = new CustomError('loadSound', errorTrace, self.url);\n var msg = 'Unable to load ' + self.url + '. The request status was: ' +\n request.status + ' (' + request.statusText + ')';\n\n if (errorCallback) {\n err.message = msg;\n errorCallback(err);\n } else {\n console.error(msg +'\\n The error stack trace includes: \\n' + err.stack);\n }\n }\n };\n\n // if there is another error, aside from 404...\n request.onerror = function() {\n var err = new CustomError('loadSound', errorTrace, self.url);\n var msg = 'There was no response from the server at ' + self.url + '. Check the url and internet connectivity.';\n\n if (errorCallback) {\n err.message = msg;\n errorCallback(err);\n } else {\n console.error(msg +'\\n The error stack trace includes: \\n' + err.stack);\n }\n };\n\n request.send();\n }\n else if (this.file !== undefined) {\n var reader = new FileReader();\n reader.onload = function() {\n if (!self.panner) return;\n ac.decodeAudioData(reader.result, function(buff) {\n if (!self.panner) return;\n self.buffer = buff;\n self.panner.inputChannels(buff.numberOfChannels);\n if (callback) {\n callback(self);\n }\n });\n };\n reader.onerror = function(e) {\n if (!self.panner) return;\n if (onerror) {\n onerror(e);\n }\n };\n reader.readAsArrayBuffer(this.file);\n }\n };\n\n // TO DO: use this method to create a loading bar that shows progress during file upload/decode.\n p5.SoundFile.prototype._updateProgress = function(evt) {\n if (evt.lengthComputable) {\n var percentComplete = evt.loaded / evt.total * 0.99;\n this._whileLoading(percentComplete, evt);\n // ...\n } else {\n // Unable to compute progress information since the total size is unknown\n this._whileLoading('size unknown');\n }\n };\n\n /**\n * Returns true if the sound file finished loading successfully.\n *\n * @method isLoaded\n * @for p5.SoundFile\n * @return {Boolean}\n */\n p5.SoundFile.prototype.isLoaded = function() {\n if (this.buffer) {\n return true;\n } else {\n return false;\n }\n };\n\n /**\n * Play the p5.SoundFile\n *\n * @method play\n * @for p5.SoundFile\n * @param {Number} [startTime] (optional) schedule playback to start (in seconds from now).\n * @param {Number} [rate] (optional) playback rate\n * @param {Number} [amp] (optional) amplitude (volume)\n * of playback\n * @param {Number} [cueStart] (optional) cue start time in seconds\n * @param {Number} [duration] (optional) duration of playback in seconds\n */\n p5.SoundFile.prototype.play = function(startTime, rate, amp, _cueStart, duration) {\n if (!this.output) {\n console.warn('SoundFile.play() called after dispose');\n return;\n }\n\n var now = p5sound.audiocontext.currentTime;\n var cueStart, cueEnd;\n var time = startTime || 0;\n if (time < 0) {\n time = 0;\n }\n\n time = time + now;\n\n if (typeof rate !== 'undefined') {\n this.rate(rate);\n }\n\n if (typeof amp !== 'undefined') {\n this.setVolume(amp);\n }\n\n // TO DO: if already playing, create array of buffers for easy stop()\n if (this.buffer) {\n // reset the pause time (if it was paused)\n this._pauseTime = 0;\n\n // handle restart playmode\n if (this.mode === 'restart' && this.buffer && this.bufferSourceNode) {\n this.bufferSourceNode.stop(time);\n this._counterNode.stop(time);\n }\n\n //dont create another instance if already playing\n if (this.mode === 'untildone' && this.isPlaying()) {\n return;\n }\n // make a new source and counter. They are automatically assigned playbackRate and buffer\n this.bufferSourceNode = this._initSourceNode();\n\n // garbage collect counterNode and create a new one\n delete this._counterNode;\n this._counterNode = this._initCounterNode();\n\n if (_cueStart) {\n if (_cueStart >=0 && _cueStart < this.buffer.duration) {\n // this.startTime = cueStart;\n cueStart = _cueStart;\n } else { throw 'start time out of range'; }\n } else {\n cueStart = 0;\n }\n\n if (duration) {\n // if duration is greater than buffer.duration, just play entire file anyway rather than throw an error\n duration = duration <= this.buffer.duration - cueStart ? duration : this.buffer.duration;\n }\n\n // if it was paused, play at the pause position\n if (this._paused) {\n this.bufferSourceNode.start(time, this.pauseTime, duration);\n this._counterNode.start(time, this.pauseTime, duration);\n } else {\n this.bufferSourceNode.start(time, cueStart, duration);\n this._counterNode.start(time, cueStart, duration);\n }\n\n this._playing = true;\n this._paused = false;\n\n // add source to sources array, which is used in stopAll()\n this.bufferSourceNodes.push(this.bufferSourceNode);\n this.bufferSourceNode._arrayIndex = this.bufferSourceNodes.length - 1;\n\n this.bufferSourceNode.addEventListener('ended', this._clearOnEnd);\n }\n // If soundFile hasn't loaded the buffer yet, throw an error\n else {\n throw 'not ready to play file, buffer has yet to load. Try preload()';\n }\n\n // if looping, will restart at original time\n this.bufferSourceNode.loop = this._looping;\n this._counterNode.loop = this._looping;\n\n if (this._looping === true) {\n cueEnd = duration ? duration : cueStart - 0.000000000000001;\n this.bufferSourceNode.loopStart = cueStart;\n this.bufferSourceNode.loopEnd = cueEnd;\n this._counterNode.loopStart = cueStart;\n this._counterNode.loopEnd = cueEnd;\n }\n\n };\n\n\n /**\n * p5.SoundFile has two play modes: restart and\n * sustain. Play Mode determines what happens to a\n * p5.SoundFile if it is triggered while in the middle of playback.\n * In sustain mode, playback will continue simultaneous to the\n * new playback. In restart mode, play() will stop playback\n * and start over. With untilDone, a sound will play only if it's\n * not already playing. Sustain is the default mode.\n *\n * @method playMode\n * @for p5.SoundFile\n * @param {String} str 'restart' or 'sustain' or 'untilDone'\n * @example\n *
\n * let mySound;\n * function preload(){\n * mySound = loadSound('assets/Damscray_DancingTiger.mp3');\n * }\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * noFill();\n * rect(0, height/2, width - 1, height/2 - 1);\n * rect(0, 0, width - 1, height/2);\n * textAlign(CENTER, CENTER);\n * fill(20);\n * text('restart', width/2, 1 * height/4);\n * text('sustain', width/2, 3 * height/4);\n * }\n * function canvasPressed() {\n * if (mouseX < height/2) {\n * mySound.playMode('restart');\n * } else {\n * mySound.playMode('sustain');\n * }\n * mySound.play();\n * }\n *\n *
\n */\n p5.SoundFile.prototype.playMode = function(str) {\n var s = str.toLowerCase();\n\n // if restart, stop all other sounds from playing\n if (s === 'restart' && this.buffer && this.bufferSourceNode) {\n for (var i = 0; i < this.bufferSourceNodes.length - 1; i++) {\n var now = p5sound.audiocontext.currentTime;\n this.bufferSourceNodes[i].stop(now);\n }\n }\n\n // set play mode to effect future playback\n if (s === 'restart' || s === 'sustain' || s === 'untildone') {\n this.mode = s;\n } else {\n throw 'Invalid play mode. Must be either \"restart\" or \"sustain\"';\n }\n };\n\n /**\n * Pauses a file that is currently playing. If the file is not\n * playing, then nothing will happen.\n *\n * After pausing, .play() will resume from the paused\n * position.\n * If p5.SoundFile had been set to loop before it was paused,\n * it will continue to loop after it is unpaused with .play().\n *\n * @method pause\n * @for p5.SoundFile\n * @param {Number} [startTime] (optional) schedule event to occur\n * seconds from now\n * @example\n *
\n * let soundFile;\n * function preload() {\n * soundFormats('ogg', 'mp3');\n * soundFile = loadSound('assets/Damscray_-_Dancing_Tiger_02.mp3');\n * }\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * text('tap to play, release to pause', 10, 20, width - 20);\n * }\n * function canvasPressed() {\n * soundFile.loop();\n * background(0, 200, 50);\n * }\n * function mouseReleased() {\n * soundFile.pause();\n * background(220);\n * }\n * \n *
\n */\n p5.SoundFile.prototype.pause = function(startTime) {\n var now = p5sound.audiocontext.currentTime;\n var time = startTime || 0;\n var pTime = time + now;\n\n if (this.isPlaying() && this.buffer && this.bufferSourceNode) {\n this._paused = true;\n this._playing = false;\n\n this.pauseTime = this.currentTime();\n this.bufferSourceNode.stop(pTime);\n this._counterNode.stop(pTime);\n\n this._pauseTime = this.currentTime();\n // TO DO: make sure play() still starts from orig start position\n } else {\n this._pauseTime = 0;\n }\n };\n\n /**\n * Loop the p5.SoundFile. Accepts optional parameters to set the\n * playback rate, playback volume, loopStart, loopEnd.\n *\n * @method loop\n * @for p5.SoundFile\n * @param {Number} [startTime] (optional) schedule event to occur\n * seconds from now\n * @param {Number} [rate] (optional) playback rate\n * @param {Number} [amp] (optional) playback volume\n * @param {Number} [cueLoopStart] (optional) startTime in seconds\n * @param {Number} [duration] (optional) loop duration in seconds\n * @example\n *
\n * let soundFile;\n * let loopStart = 0.5;\n * let loopDuration = 0.2;\n * function preload() {\n * soundFormats('ogg', 'mp3');\n * soundFile = loadSound('assets/Damscray_-_Dancing_Tiger_02.mp3');\n * }\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * text('tap to play, release to pause', 10, 20, width - 20);\n * }\n * function canvasPressed() {\n * soundFile.loop();\n * background(0, 200, 50);\n * }\n * function mouseReleased() {\n * soundFile.pause();\n * background(220);\n * }\n * \n *
\n */\n p5.SoundFile.prototype.loop = function(startTime, rate, amp, loopStart, duration) {\n this._looping = true;\n this.play(startTime, rate, amp, loopStart, duration);\n };\n\n /**\n * Set a p5.SoundFile's looping flag to true or false. If the sound\n * is currently playing, this change will take effect when it\n * reaches the end of the current playback.\n *\n * @method setLoop\n * @for p5.SoundFile\n * @param {Boolean} Boolean set looping to true or false\n */\n p5.SoundFile.prototype.setLoop = function(bool) {\n if (bool === true) {\n this._looping = true;\n }\n else if (bool === false) {\n this._looping = false;\n }\n else {\n throw 'Error: setLoop accepts either true or false';\n }\n if (this.bufferSourceNode) {\n this.bufferSourceNode.loop = this._looping;\n this._counterNode.loop = this._looping;\n }\n };\n\n /**\n * Returns 'true' if a p5.SoundFile is currently looping and playing, 'false' if not.\n *\n * @method isLooping\n * @for p5.SoundFile\n * @return {Boolean}\n */\n p5.SoundFile.prototype.isLooping = function() {\n if (!this.bufferSourceNode) {\n return false;\n }\n if (this._looping === true && this.isPlaying() === true) {\n return true;\n }\n return false;\n };\n\n /**\n * Returns true if a p5.SoundFile is playing, false if not (i.e.\n * paused or stopped).\n *\n * @method isPlaying\n * @for p5.SoundFile\n * @return {Boolean}\n */\n p5.SoundFile.prototype.isPlaying = function() {\n return this._playing;\n };\n\n /**\n * Returns true if a p5.SoundFile is paused, false if not (i.e.\n * playing or stopped).\n *\n * @method isPaused\n * @for p5.SoundFile\n * @return {Boolean}\n */\n p5.SoundFile.prototype.isPaused = function() {\n return this._paused;\n };\n\n /**\n * Stop soundfile playback.\n *\n * @method stop\n * @for p5.SoundFile\n * @param {Number} [startTime] (optional) schedule event to occur\n * in seconds from now\n */\n p5.SoundFile.prototype.stop = function(timeFromNow) {\n var time = timeFromNow || 0;\n\n if (this.mode === 'sustain' || this.mode === 'untildone') {\n this.stopAll(time);\n this._playing = false;\n this.pauseTime = 0;\n this._paused = false;\n }\n else if (this.buffer && this.bufferSourceNode) {\n var now = p5sound.audiocontext.currentTime;\n var t = time || 0;\n this.pauseTime = 0;\n this.bufferSourceNode.stop(now + t);\n this._counterNode.stop(now + t);\n this._playing = false;\n this._paused = false;\n }\n };\n\n /**\n * Stop playback on all of this soundfile's sources.\n * @private\n */\n p5.SoundFile.prototype.stopAll = function(_time) {\n var now = p5sound.audiocontext.currentTime;\n var time = _time || 0;\n if (this.buffer && this.bufferSourceNode) {\n for (var i in this.bufferSourceNodes) {\n const bufferSourceNode = this.bufferSourceNodes[i];\n if (!!bufferSourceNode) {\n try {\n bufferSourceNode.stop(now + time);\n } catch(e) {\n // this was throwing errors only on Safari\n }\n }\n }\n this._counterNode.stop(now + time);\n this._onended(this);\n }\n };\n\n /**\n * Multiply the output volume (amplitude) of a sound file\n * between 0.0 (silence) and 1.0 (full volume).\n * 1.0 is the maximum amplitude of a digital sound, so multiplying\n * by greater than 1.0 may cause digital distortion. To\n * fade, provide a rampTime parameter. For more\n * complex fades, see the Envelope class.\n *\n * Alternately, you can pass in a signal source such as an\n * oscillator to modulate the amplitude with an audio signal.\n *\n * @method setVolume\n * @for p5.SoundFile\n * @param {Number|Object} volume Volume (amplitude) between 0.0\n * and 1.0 or modulating signal/oscillator\n * @param {Number} [rampTime] Fade for t seconds\n * @param {Number} [timeFromNow] Schedule this event to happen at\n * t seconds in the future\n */\n p5.SoundFile.prototype.setVolume = function(vol, _rampTime, _tFromNow) {\n if (typeof vol === 'number') {\n var rampTime = _rampTime || 0;\n var tFromNow = _tFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n var currentVol = this.output.gain.value;\n this.output.gain.cancelScheduledValues(now + tFromNow);\n this.output.gain.linearRampToValueAtTime(currentVol, now + tFromNow);\n this.output.gain.linearRampToValueAtTime(vol, now + tFromNow + rampTime);\n }\n else if (vol) {\n vol.connect(this.output.gain);\n } else {\n // return the Gain Node\n return this.output.gain;\n }\n };\n\n // same as setVolume, to match Processing Sound\n p5.SoundFile.prototype.amp = p5.SoundFile.prototype.setVolume;\n\n // these are the same thing\n p5.SoundFile.prototype.fade = p5.SoundFile.prototype.setVolume;\n\n p5.SoundFile.prototype.getVolume = function() {\n return this.output.gain.value;\n };\n\n /**\n * Set the stereo panning of a p5.sound object to\n * a floating point number between -1.0 (left) and 1.0 (right).\n * Default is 0.0 (center).\n *\n * @method pan\n * @for p5.SoundFile\n * @param {Number} [panValue] Set the stereo panner\n * @param {Number} [timeFromNow] schedule this event to happen\n * seconds from now\n * @example\n *
\n * let ballX = 0;\n * let soundFile;\n *\n * function preload() {\n * soundFormats('ogg', 'mp3');\n * soundFile = loadSound('assets/beatbox.mp3');\n * }\n *\n * function draw() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * ballX = constrain(mouseX, 0, width);\n * ellipse(ballX, height/2, 20, 20);\n * }\n *\n * function canvasPressed(){\n * // map the ball's x location to a panning degree\n * // between -1.0 (left) and 1.0 (right)\n * let panning = map(ballX, 0., width,-1.0, 1.0);\n * soundFile.pan(panning);\n * soundFile.play();\n * }\n *
\n */\n p5.SoundFile.prototype.pan = function(pval, tFromNow) {\n this.panPosition = pval;\n this.panner.pan(pval, tFromNow);\n };\n\n /**\n * Returns the current stereo pan position (-1.0 to 1.0)\n *\n * @method getPan\n * @for p5.SoundFile\n * @return {Number} Returns the stereo pan setting of the Oscillator\n * as a number between -1.0 (left) and 1.0 (right).\n * 0.0 is center and default.\n */\n p5.SoundFile.prototype.getPan = function() {\n return this.panPosition;\n };\n\n /**\n * Set the playback rate of a sound file. Will change the speed and the pitch.\n * Values less than zero will reverse the audio buffer.\n *\n * @method rate\n * @for p5.SoundFile\n * @param {Number} [playbackRate] Set the playback rate. 1.0 is normal,\n * .5 is half-speed, 2.0 is twice as fast.\n * Values less than zero play backwards.\n * @example\n *
\n * let mySound;\n *\n * function preload() {\n * mySound = loadSound('assets/Damscray_DancingTiger.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * }\n * function canvasPressed() {\n * mySound.loop();\n * }\n * function mouseReleased() {\n * mySound.pause();\n * }\n * function draw() {\n * background(220);\n *\n * // Set the rate to a range between 0.1 and 4\n * // Changing the rate also alters the pitch\n * let playbackRate = map(mouseY, 0.1, height, 2, 0);\n * playbackRate = constrain(playbackRate, 0.01, 4);\n * mySound.rate(playbackRate);\n *\n * line(0, mouseY, width, mouseY);\n * text('rate: ' + round(playbackRate * 100) + '%', 10, 20);\n * }\n *\n * \n *
\n *\n */\n p5.SoundFile.prototype.rate = function(playbackRate) {\n var reverse = false;\n if (typeof playbackRate === 'undefined') {\n return this.playbackRate;\n }\n\n this.playbackRate = playbackRate;\n\n if (playbackRate === 0) {\n playbackRate = 0.0000000000001;\n }\n\n else if (playbackRate < 0 && !this.reversed) {\n playbackRate = Math.abs(playbackRate);\n reverse = true;\n }\n\n else if (playbackRate > 0 && this.reversed) {\n reverse = true;\n }\n\n if (this.bufferSourceNode) {\n var now = p5sound.audiocontext.currentTime;\n this.bufferSourceNode.playbackRate.cancelScheduledValues(now);\n this.bufferSourceNode.playbackRate.linearRampToValueAtTime(Math.abs(playbackRate), now);\n this._counterNode.playbackRate.cancelScheduledValues(now);\n this._counterNode.playbackRate.linearRampToValueAtTime(Math.abs(playbackRate), now);\n }\n\n if (reverse) {\n this.reverseBuffer();\n }\n return this.playbackRate;\n };\n\n // TO DO: document this\n p5.SoundFile.prototype.setPitch = function(num) {\n var newPlaybackRate = midiToFreq(num) / midiToFreq(60);\n this.rate(newPlaybackRate);\n };\n\n p5.SoundFile.prototype.getPlaybackRate = function() {\n return this.playbackRate;\n };\n\n /**\n * Returns the duration of a sound file in seconds.\n *\n * @method duration\n * @for p5.SoundFile\n * @return {Number} The duration of the soundFile in seconds.\n */\n p5.SoundFile.prototype.duration = function() {\n // Return Duration\n if (this.buffer) {\n return this.buffer.duration;\n } else {\n return 0;\n }\n };\n\n /**\n * Return the current position of the p5.SoundFile playhead, in seconds.\n * Time is relative to the normal buffer direction, so if `reverseBuffer`\n * has been called, currentTime will count backwards.\n *\n * @method currentTime\n * @for p5.SoundFile\n * @return {Number} currentTime of the soundFile in seconds.\n */\n p5.SoundFile.prototype.currentTime = function() {\n return this.reversed\n ? Math.abs(this._lastPos - this.buffer.length) / ac.sampleRate\n : this._lastPos / ac.sampleRate;\n };\n\n /**\n * Move the playhead of a soundfile that is currently playing to a\n * new position and a new duration, in seconds.\n * If none are given, will reset the file to play entire duration\n * from start to finish. To set the position of a soundfile that is\n * not currently playing, use the `play` or `loop` methods.\n *\n * @method jump\n * @for p5.SoundFile\n * @param {Number} cueTime cueTime of the soundFile in seconds.\n * @param {Number} duration duration in seconds.\n */\n p5.SoundFile.prototype.jump = function(cueTime, duration) {\n if (cueTime < 0 || cueTime > this.buffer.duration) {\n throw 'jump time out of range';\n }\n if (duration > this.buffer.duration - cueTime) {\n throw 'end time out of range';\n }\n\n var cTime = cueTime || 0;\n var dur = duration || undefined;\n if (this.isPlaying()) {\n this.stop(0);\n this.play(0, this.playbackRate, this.output.gain.value, cTime, dur);\n }\n };\n\n /**\n * Return the number of channels in a sound file.\n * For example, Mono = 1, Stereo = 2.\n *\n * @method channels\n * @for p5.SoundFile\n * @return {Number} [channels]\n */\n p5.SoundFile.prototype.channels = function() {\n return this.buffer.numberOfChannels;\n };\n\n /**\n * Return the sample rate of the sound file.\n *\n * @method sampleRate\n * @for p5.SoundFile\n * @return {Number} [sampleRate]\n */\n p5.SoundFile.prototype.sampleRate = function() {\n return this.buffer.sampleRate;\n };\n\n /**\n * Return the number of samples in a sound file.\n * Equal to sampleRate * duration.\n *\n * @method frames\n * @for p5.SoundFile\n * @return {Number} [sampleCount]\n */\n p5.SoundFile.prototype.frames = function() {\n return this.buffer.length;\n };\n\n /**\n * Returns an array of amplitude peaks in a p5.SoundFile that can be\n * used to draw a static waveform. Scans through the p5.SoundFile's\n * audio buffer to find the greatest amplitudes. Accepts one\n * parameter, 'length', which determines size of the array.\n * Larger arrays result in more precise waveform visualizations.\n *\n * Inspired by Wavesurfer.js.\n *\n * @method getPeaks\n * @for p5.SoundFile\n * @params {Number} [length] length is the size of the returned array.\n * Larger length results in more precision.\n * Defaults to 5*width of the browser window.\n * @returns {Float32Array} Array of peaks.\n */\n p5.SoundFile.prototype.getPeaks = function(length) {\n\n if (this.buffer) {\n // set length to window's width if no length is provided\n if (!length) {\n length = window.width*5;\n }\n if (this.buffer) {\n var buffer = this.buffer;\n var sampleSize = buffer.length / length;\n var sampleStep = ~~(sampleSize / 10) || 1;\n var channels = buffer.numberOfChannels;\n var peaks = new Float32Array(Math.round(length));\n\n for (var c = 0; c < channels; c++) {\n var chan = buffer.getChannelData(c);\n for (var i = 0; i < length; i++) {\n var start = ~~(i*sampleSize);\n var end = ~~(start + sampleSize);\n var max = 0;\n for (var j = start; j < end; j+= sampleStep) {\n var value = chan[j];\n if (value > max) {\n max = value;\n // faster than Math.abs\n } else if (-value > max) {\n max = value;\n }\n }\n if (c === 0 || Math.abs(max) > peaks[i]) {\n peaks[i] = max;\n }\n }\n }\n\n return peaks;\n }\n }\n\n else {\n throw 'Cannot load peaks yet, buffer is not loaded';\n }\n };\n\n /**\n * Reverses the p5.SoundFile's buffer source.\n * Playback must be handled separately (see example).\n *\n * @method reverseBuffer\n * @for p5.SoundFile\n * @example\n *
\n * let drum;\n * function preload() {\n * drum = loadSound('assets/drum.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * text('tap to play', 20, 20);\n * }\n *\n * function canvasPressed() {\n * drum.stop();\n * drum.reverseBuffer();\n * drum.play();\n * }\n * \n *
\n */\n p5.SoundFile.prototype.reverseBuffer = function() {\n if (this.buffer) {\n var currentPos = this._lastPos / ac.sampleRate;\n var curVol = this.getVolume();\n this.setVolume(0, 0.001);\n\n const numChannels = this.buffer.numberOfChannels;\n for (var i = 0; i < numChannels; i++) {\n this.buffer.getChannelData(i).reverse();\n }\n // set reversed flag\n this.reversed = !this.reversed;\n\n if (this.isPlaying() && currentPos) {\n this.jump(this.duration() - currentPos);\n }\n this.setVolume(curVol, 0.001);\n } else {\n throw 'SoundFile is not done loading';\n }\n };\n\n /**\n * Schedule an event to be called when the soundfile\n * reaches the end of a buffer. If the soundfile is\n * playing through once, this will be called when it\n * ends. If it is looping, it will be called when\n * stop is called.\n *\n * @method onended\n * @for p5.SoundFile\n * @param {Function} callback function to call when the\n * soundfile has ended.\n */\n p5.SoundFile.prototype.onended = function(callback) {\n this._onended = callback;\n return this;\n };\n\n p5.SoundFile.prototype.add = function() {\n // TO DO\n };\n\n p5.SoundFile.prototype.dispose = function() {\n var now = p5sound.audiocontext.currentTime;\n\n // remove reference to soundfile\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n\n this.stop(now);\n if (this.buffer && this.bufferSourceNode) {\n for (var i = 0; i < this.bufferSourceNodes.length - 1; i++) {\n if (this.bufferSourceNodes[i] !== null) {\n this.bufferSourceNodes[i].disconnect();\n try {\n this.bufferSourceNodes[i].stop(now);\n } catch(e) {\n console.warn('no buffer source node to dispose');\n }\n this.bufferSourceNodes[i] = null;\n }\n }\n if ( this.isPlaying() ) {\n try {\n this._counterNode.stop(now);\n } catch(e) {\n console.log(e);\n }\n this._counterNode = null;\n }\n }\n if (this.output) {\n this.output.disconnect();\n this.output = null;\n }\n if (this.panner) {\n this.panner.disconnect();\n this.panner = null;\n }\n };\n\n /**\n * Connects the output of a p5sound object to input of another\n * p5.sound object. For example, you may connect a p5.SoundFile to an\n * FFT or an Effect. If no parameter is given, it will connect to\n * the master output. Most p5sound objects connect to the master\n * output when they are created.\n *\n * @method connect\n * @for p5.SoundFile\n * @param {Object} [object] Audio object that accepts an input\n */\n p5.SoundFile.prototype.connect = function(unit) {\n if (!unit) {\n this.panner.connect(p5sound.input);\n }\n else {\n if (unit.hasOwnProperty('input')) {\n this.panner.connect(unit.input);\n } else {\n this.panner.connect(unit);\n }\n }\n };\n\n /**\n * Disconnects the output of this p5sound object.\n *\n * @method disconnect\n * @for p5.SoundFile\n */\n p5.SoundFile.prototype.disconnect = function() {\n if (this.panner) {\n this.panner.disconnect();\n }\n };\n\n /**\n */\n p5.SoundFile.prototype.getLevel = function() {\n console.warn('p5.SoundFile.getLevel has been removed from the library. Use p5.Amplitude instead');\n };\n\n /**\n * Reset the source for this SoundFile to a\n * new path (URL).\n *\n * @method setPath\n * @for p5.SoundFile\n * @param {String} path path to audio file\n * @param {Function} callback Callback\n */\n p5.SoundFile.prototype.setPath = function(p, callback) {\n var path = p5.prototype._checkFileFormats(p);\n this.url = path;\n this.load(callback);\n };\n\n /**\n * Replace the current Audio Buffer with a new Buffer.\n *\n * @method setBuffer\n * @for p5.SoundFile\n * @param {Array} buf Array of Float32 Array(s). 2 Float32 Arrays\n * will create a stereo source. 1 will create\n * a mono source.\n */\n p5.SoundFile.prototype.setBuffer = function(buf) {\n var numChannels = buf.length;\n var size = buf[0].length;\n var newBuffer = ac.createBuffer(numChannels, size, ac.sampleRate);\n\n if (!(buf[0] instanceof Float32Array)) {\n buf[0] = new Float32Array(buf[0]);\n }\n\n for (var channelNum = 0; channelNum < numChannels; channelNum++) {\n var channel = newBuffer.getChannelData( channelNum );\n channel.set(buf[channelNum]);\n }\n\n this.buffer = newBuffer;\n\n // set numbers of channels on input to the panner\n this.panner.inputChannels(numChannels);\n };\n\n //////////////////////////////////////////////////\n // script processor node with an empty buffer to help\n // keep a sample-accurate position in playback buffer.\n // Inspired by Chinmay Pendharkar's technique for Sonoport --> http://bit.ly/1HwdCsV\n // Copyright [2015] [Sonoport (Asia) Pte. Ltd.],\n // Licensed under the Apache License http://apache.org/licenses/LICENSE-2.0\n ////////////////////////////////////////////////////////////////////////////////////\n\n var _createCounterBuffer = function(buffer) {\n const len = buffer.length;\n const audioBuf = ac.createBuffer( 1, buffer.length, ac.sampleRate );\n const arrayBuffer = audioBuf.getChannelData(0);\n for (var index = 0; index < len; index++) {\n arrayBuffer[index] = index;\n }\n return audioBuf;\n };\n\n // initialize counterNode, set its initial buffer and playbackRate\n p5.SoundFile.prototype._initCounterNode = function() {\n var self = this;\n var now = ac.currentTime;\n var cNode = ac.createBufferSource();\n\n const workletBufferSize = safeBufferSize(256);\n\n // dispose of worklet node if it already exists\n if (self._workletNode) {\n self._workletNode.disconnect();\n delete self._workletNode;\n }\n self._workletNode = new AudioWorkletNode(ac, processorNames.soundFileProcessor, {\n processorOptions: { bufferSize: workletBufferSize }\n });\n self._workletNode.port.onmessage = event => {\n if (event.data.name === 'position') {\n // event.data.position should only be 0 when paused\n if (event.data.position === 0) {\n return;\n }\n this._lastPos = event.data.position;\n\n // do any callbacks that have been scheduled\n this._onTimeUpdate(self._lastPos);\n }\n };\n\n // create counter buffer of the same length as self.buffer\n cNode.buffer = _createCounterBuffer( self.buffer );\n\n cNode.playbackRate.setValueAtTime(self.playbackRate, now);\n\n cNode.connect(self._workletNode);\n self._workletNode.connect(p5.soundOut._silentNode);\n\n return cNode;\n };\n\n // initialize sourceNode, set its initial buffer and playbackRate\n p5.SoundFile.prototype._initSourceNode = function() {\n var bufferSourceNode = ac.createBufferSource();\n bufferSourceNode.buffer = this.buffer;\n bufferSourceNode.playbackRate.value = this.playbackRate;\n bufferSourceNode.connect(this.output);\n return bufferSourceNode;\n };\n\n /**\n * processPeaks returns an array of timestamps where it thinks there is a beat.\n *\n * This is an asynchronous function that processes the soundfile in an offline audio context,\n * and sends the results to your callback function.\n *\n * The process involves running the soundfile through a lowpass filter, and finding all of the\n * peaks above the initial threshold. If the total number of peaks are below the minimum number of peaks,\n * it decreases the threshold and re-runs the analysis until either minPeaks or minThreshold are reached.\n *\n * @method processPeaks\n * @for p5.SoundFile\n * @param {Function} callback a function to call once this data is returned\n * @param {Number} [initThreshold] initial threshold defaults to 0.9\n * @param {Number} [minThreshold] minimum threshold defaults to 0.22\n * @param {Number} [minPeaks] minimum number of peaks defaults to 200\n * @return {Array} Array of timestamped peaks\n */\n p5.SoundFile.prototype.processPeaks = function(callback, _initThreshold, _minThreshold, _minPeaks) {\n var bufLen = this.buffer.length;\n var sampleRate = this.buffer.sampleRate;\n var buffer = this.buffer;\n var allPeaks = [];\n\n var initialThreshold = _initThreshold || 0.9,\n threshold = initialThreshold,\n minThreshold = _minThreshold || 0.22,\n minPeaks = _minPeaks || 200;\n\n // Create offline context\n var offlineContext = new window.OfflineAudioContext(1, bufLen, sampleRate);\n\n // create buffer source\n var source = offlineContext.createBufferSource();\n source.buffer = buffer;\n\n // Create filter. TO DO: allow custom setting of filter\n var filter = offlineContext.createBiquadFilter();\n filter.type = 'lowpass';\n source.connect(filter);\n filter.connect(offlineContext.destination);\n\n // start playing at time:0\n source.start(0);\n offlineContext.startRendering(); // Render the song\n\n // act on the result\n offlineContext.oncomplete = function(e) {\n if (!self.panner) return;\n var filteredBuffer = e.renderedBuffer;\n var bufferData = filteredBuffer.getChannelData(0);\n\n\n // step 1:\n // create Peak instances, add them to array, with strength and sampleIndex\n do {\n allPeaks = getPeaksAtThreshold(bufferData, threshold);\n threshold -= 0.005;\n } while (Object.keys(allPeaks).length < minPeaks && threshold >= minThreshold);\n\n\n // step 2:\n // find intervals for each peak in the sampleIndex, add tempos array\n var intervalCounts = countIntervalsBetweenNearbyPeaks(allPeaks);\n\n // step 3: find top tempos\n var groups = groupNeighborsByTempo(intervalCounts, filteredBuffer.sampleRate);\n\n // sort top intervals\n var topTempos = groups.sort(function(intA, intB) {\n return intB.count - intA.count;\n\n }).splice(0,5);\n\n // set this SoundFile's tempo to the top tempo ??\n this.tempo = topTempos[0].tempo;\n\n // step 4:\n // new array of peaks at top tempo within a bpmVariance\n var bpmVariance = 5;\n var tempoPeaks = getPeaksAtTopTempo(allPeaks, topTempos[0].tempo, filteredBuffer.sampleRate, bpmVariance);\n\n callback(tempoPeaks);\n };\n };\n\n // process peaks\n var Peak = function(amp, i) {\n this.sampleIndex = i;\n this.amplitude = amp;\n this.tempos = [];\n this.intervals = [];\n };\n\n // 1. for processPeaks() Function to identify peaks above a threshold\n // returns an array of peak indexes as frames (samples) of the original soundfile\n function getPeaksAtThreshold(data, threshold) {\n var peaksObj = {};\n var length = data.length;\n\n for (var i = 0; i < length; i++) {\n if (data[i] > threshold) {\n var amp = data[i];\n var peak = new Peak(amp, i);\n peaksObj[i] = peak;\n // Skip forward ~ 1/8s to get past this peak.\n i += 6000;\n }\n i++;\n }\n return peaksObj;\n }\n\n // 2. for processPeaks()\n function countIntervalsBetweenNearbyPeaks(peaksObj) {\n var intervalCounts = [];\n var peaksArray = Object.keys(peaksObj).sort();\n\n for (var index = 0; index < peaksArray.length; index++) {\n\n // find intervals in comparison to nearby peaks\n for (var i = 0; i < 10; i++) {\n var startPeak = peaksObj[peaksArray[index]];\n var endPeak = peaksObj[peaksArray[index + i]];\n\n if (startPeak && endPeak) {\n var startPos = startPeak.sampleIndex;\n var endPos = endPeak.sampleIndex;\n var interval = endPos - startPos;\n\n // add a sample interval to the startPeak in the allPeaks array\n if (interval > 0) {\n startPeak.intervals.push(interval);\n }\n\n // tally the intervals and return interval counts\n var foundInterval = intervalCounts.some(function(intervalCount) {\n if (intervalCount.interval === interval) {\n intervalCount.count++;\n return intervalCount;\n }\n });\n\n // store with JSON like formatting\n if (!foundInterval) {\n intervalCounts.push({\n interval: interval,\n count: 1,\n });\n }\n }\n }\n }\n\n return intervalCounts;\n }\n\n\n // 3. for processPeaks --> find tempo\n function groupNeighborsByTempo(intervalCounts, sampleRate) {\n var tempoCounts = [];\n\n intervalCounts.forEach(function(intervalCount) {\n\n try {\n // Convert an interval to tempo\n var theoreticalTempo = Math.abs( 60 / (intervalCount.interval / sampleRate ) );\n\n theoreticalTempo = mapTempo(theoreticalTempo);\n\n var foundTempo = tempoCounts.some(function(tempoCount) {\n if (tempoCount.tempo === theoreticalTempo)\n return tempoCount.count += intervalCount.count;\n });\n if (!foundTempo) {\n if (isNaN(theoreticalTempo)) {\n return;\n }\n tempoCounts.push({\n tempo: Math.round(theoreticalTempo),\n count: intervalCount.count\n });\n }\n } catch(e) {\n throw e;\n }\n\n });\n\n return tempoCounts;\n }\n\n // 4. for processPeaks - get peaks at top tempo\n function getPeaksAtTopTempo(peaksObj, tempo, sampleRate, bpmVariance) {\n var peaksAtTopTempo = [];\n var peaksArray = Object.keys(peaksObj).sort();\n\n // TO DO: filter out peaks that have the tempo and return\n for (var i = 0; i < peaksArray.length; i++) {\n var key = peaksArray[i];\n var peak = peaksObj[key];\n\n for (var j = 0; j < peak.intervals.length; j++) {\n var intervalBPM = Math.round(Math.abs( 60 / (peak.intervals[j] / sampleRate) ) );\n\n intervalBPM = mapTempo(intervalBPM);\n\n if ( Math.abs(intervalBPM - tempo) < bpmVariance ) {\n // convert sampleIndex to seconds\n peaksAtTopTempo.push(peak.sampleIndex/sampleRate);\n }\n }\n }\n\n // filter out peaks that are very close to each other\n peaksAtTopTempo = peaksAtTopTempo.filter(function(peakTime, index, arr) {\n var dif = arr[index + 1] - peakTime;\n if (dif > 0.01) {\n return true;\n }\n });\n\n return peaksAtTopTempo;\n }\n\n // helper function for processPeaks\n function mapTempo(theoreticalTempo) {\n // these scenarios create infinite while loop\n if (!isFinite(theoreticalTempo) || theoreticalTempo === 0 ) {\n return;\n }\n\n // Adjust the tempo to fit within the 90-180 BPM range\n while (theoreticalTempo < 90) theoreticalTempo *= 2;\n while (theoreticalTempo > 180 && theoreticalTempo > 90) theoreticalTempo /= 2;\n\n return theoreticalTempo;\n }\n\n\n /*** SCHEDULE EVENTS ***/\n\n // Cue inspired by JavaScript setTimeout, and the\n // Tone.js Transport Timeline Event, MIT License Yotam Mann 2015 tonejs.org\n var Cue = function(callback, time, id, val) {\n this.callback = callback;\n this.time = time;\n this.id = id;\n this.val = val;\n };\n\n /**\n * Schedule events to trigger every time a MediaElement\n * (audio/video) reaches a playback cue point.\n *\n * Accepts a callback function, a time (in seconds) at which to trigger\n * the callback, and an optional parameter for the callback.\n *\n * Time will be passed as the first parameter to the callback function,\n * and param will be the second parameter.\n *\n *\n * @method addCue\n * @for p5.SoundFile\n * @param {Number} time Time in seconds, relative to this media\n * element's playback. For example, to trigger\n * an event every time playback reaches two\n * seconds, pass in the number 2. This will be\n * passed as the first parameter to\n * the callback function.\n * @param {Function} callback Name of a function that will be\n * called at the given time. The callback will\n * receive time and (optionally) param as its\n * two parameters.\n * @param {Object} [value] An object to be passed as the\n * second parameter to the\n * callback function.\n * @return {Number} id ID of this cue,\n * useful for removeCue(id)\n * @example\n *
\n * let mySound;\n * function preload() {\n * mySound = loadSound('assets/Damscray_DancingTiger.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * text('tap to play', 10, 20);\n *\n * // schedule calls to changeText\n * mySound.addCue(0, changeText, \"hello\" );\n * mySound.addCue(0.5, changeText, \"hello,\" );\n * mySound.addCue(1, changeText, \"hello, p5!\");\n * mySound.addCue(1.5, changeText, \"hello, p5!!\");\n * mySound.addCue(2, changeText, \"hello, p5!!!!!\");\n * }\n *\n * function changeText(val) {\n * background(220);\n * text(val, 10, 20);\n * }\n *\n * function canvasPressed() {\n * mySound.play();\n * }\n *
\n */\n p5.SoundFile.prototype.addCue = function(time, callback, val) {\n var id = this._cueIDCounter++;\n\n var cue = new Cue(callback, time, id, val);\n this._cues.push(cue);\n\n // if (!this.elt.ontimeupdate) {\n // this.elt.ontimeupdate = this._onTimeUpdate.bind(this);\n // }\n\n return id;\n };\n\n /**\n * Remove a callback based on its ID. The ID is returned by the\n * addCue method.\n *\n * @method removeCue\n * @for p5.SoundFile\n * @param {Number} id ID of the cue, as returned by addCue\n */\n p5.SoundFile.prototype.removeCue = function(id) {\n var cueLength = this._cues.length;\n for (var i = 0; i < cueLength; i++) {\n var cue = this._cues[i];\n if (cue.id === id) {\n this._cues.splice(i, 1);\n break;\n }\n }\n\n if (this._cues.length === 0) {\n // TO DO: remove callback\n // this.elt.ontimeupdate = null\n }\n };\n\n /**\n * Remove all of the callbacks that had originally been scheduled\n * via the addCue method.\n *\n * @method clearCues\n */\n p5.SoundFile.prototype.clearCues = function() {\n this._cues = [];\n // this.elt.ontimeupdate = null;\n };\n\n // private method that checks for cues to be fired if events\n // have been scheduled using addCue(callback, time).\n p5.SoundFile.prototype._onTimeUpdate = function(position) {\n var playbackTime = position/this.buffer.sampleRate;\n var cueLength = this._cues.length;\n\n for (var i = 0 ; i < cueLength; i++) {\n var cue = this._cues[i];\n var callbackTime = cue.time;\n var val = cue.val;\n\n if (~~this._prevUpdateTime <= callbackTime && callbackTime <= playbackTime) {\n\n // pass the scheduled callbackTime as parameter to the callback\n cue.callback(val);\n }\n\n }\n\n this._prevUpdateTime = playbackTime;\n };\n\n /**\n * Save a p5.SoundFile as a .wav file. The browser will prompt the user\n * to download the file to their device. To upload a file to a server, see\n * getBlob\n *\n * @method save\n * @for p5.SoundFile\n * @param {String} [fileName] name of the resulting .wav file.\n * @example\n *
\n * let mySound;\n * function preload() {\n * mySound = loadSound('assets/doorbell.mp3');\n * }\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * text('tap to download', 10, 20);\n * }\n *\n * function canvasPressed() {\n * mySound.save('my cool filename');\n * }\n *
\n */\n p5.SoundFile.prototype.save = function(fileName) {\n p5.prototype.saveSound(this, fileName, 'wav');\n };\n\n /**\n * This method is useful for sending a SoundFile to a server. It returns the\n * .wav-encoded audio data as a \"Blob\".\n * A Blob is a file-like data object that can be uploaded to a server\n * with an http request. We'll\n * use the `httpDo` options object to send a POST request with some\n * specific options: we encode the request as `multipart/form-data`,\n * and attach the blob as one of the form values using `FormData`.\n *\n *\n * @method getBlob\n * @for p5.SoundFile\n * @returns {Blob} A file-like data object\n * @example\n *
\n * function preload() {\n * mySound = loadSound('assets/doorbell.mp3');\n * }\n *\n * function setup() {\n * noCanvas();\n * let soundBlob = mySound.getBlob();\n *\n * // Now we can send the blob to a server...\n * let serverUrl = 'https://jsonplaceholder.typicode.com/posts';\n * let httpRequestOptions = {\n * method: 'POST',\n * body: new FormData().append('soundBlob', soundBlob),\n * headers: new Headers({\n * 'Content-Type': 'multipart/form-data'\n * })\n * };\n * httpDo(serverUrl, httpRequestOptions);\n *\n * // We can also create an `ObjectURL` pointing to the Blob\n * let blobUrl = URL.createObjectURL(soundBlob);\n *\n * // The `
\n */\n p5.SoundFile.prototype.getBlob = function() {\n const dataView = convertToWav(this.buffer);\n return new Blob([dataView], { type: 'audio/wav' });\n };\n\n // event handler to remove references to the bufferSourceNode when it is done playing\n function _clearOnEnd(e) {\n const thisBufferSourceNode = e.target;\n const soundFile = this;\n\n // delete this.bufferSourceNode from the sources array when it is done playing:\n thisBufferSourceNode._playing = false;\n thisBufferSourceNode.removeEventListener('ended', soundFile._clearOnEnd);\n\n // call the onended callback\n soundFile._onended(soundFile);\n\n // delete bufferSourceNode(s) in soundFile.bufferSourceNodes\n // iterate in reverse order because the index changes by splice\n soundFile.bufferSourceNodes.map((_, i) => i).reverse().forEach(function (i) {\n const n = soundFile.bufferSourceNodes[i];\n\n if (n._playing === false) {\n soundFile.bufferSourceNodes.splice(i, 1);\n }\n });\n\n if (soundFile.bufferSourceNodes.length === 0) {\n soundFile._playing = false;\n }\n }\n});\n","'use strict';\n\ndefine(function (require) {\n const p5sound = require('master');\n const { safeBufferSize } = require('helpers');\n const processorNames = require('./audioWorklet/processorNames');\n\n /**\n * Amplitude measures volume between 0.0 and 1.0.\n * Listens to all p5sound by default, or use setInput()\n * to listen to a specific sound source. Accepts an optional\n * smoothing value, which defaults to 0.\n *\n * @class p5.Amplitude\n * @constructor\n * @param {Number} [smoothing] between 0.0 and .999 to smooth\n * amplitude readings (defaults to 0)\n * @example\n *
\n * let sound, amplitude;\n *\n * function preload(){\n * sound = loadSound('assets/beat.mp3');\n * }\n * function setup() {\n * let cnv = createCanvas(100,100);\n * cnv.mouseClicked(toggleSound);\n * amplitude = new p5.Amplitude();\n * }\n *\n * function draw() {\n * background(220);\n * text('tap to play', 20, 20);\n *\n * let level = amplitude.getLevel();\n * let size = map(level, 0, 1, 0, 200);\n * ellipse(width/2, height/2, size, size);\n * }\n *\n * function toggleSound() {\n * if (sound.isPlaying() ){\n * sound.stop();\n * } else {\n * sound.play();\n * }\n * }\n *\n *
\n */\n p5.Amplitude = function(smoothing) {\n\n // Set to 2048 for now. In future iterations, this should be inherited or parsed from p5sound's default\n this.bufferSize = safeBufferSize(2048);\n\n // set audio context\n this.audiocontext = p5sound.audiocontext;\n this._workletNode = new AudioWorkletNode(this.audiocontext, processorNames.amplitudeProcessor, {\n outputChannelCount: [1],\n\n parameterData: { smoothing: smoothing || 0 },\n processorOptions: {\n normalize: false,\n smoothing: smoothing || 0,\n numInputChannels: 2,\n bufferSize: this.bufferSize\n }\n });\n\n this._workletNode.port.onmessage = function(event) {\n if (event.data.name === 'amplitude') {\n this.volume = event.data.volume;\n this.volNorm = event.data.volNorm;\n this.stereoVol = event.data.stereoVol;\n this.stereoVolNorm = event.data.stereoVolNorm;\n }\n }.bind(this);\n\n // for connections\n this.input = this._workletNode;\n\n this.output = this.audiocontext.createGain();\n\n // the variables to return\n this.volume = 0;\n this.volNorm = 0;\n this.stereoVol = [0, 0];\n this.stereoVolNorm = [0, 0];\n\n this.normalize = false;\n\n this._workletNode.connect(this.output);\n this.output.gain.value = 0;\n\n // this may only be necessary because of a Chrome bug\n this.output.connect(this.audiocontext.destination);\n\n // connect to p5sound master output by default, unless set by input()\n p5sound.meter.connect(this._workletNode);\n\n // add this p5.SoundFile to the soundArray\n p5sound.soundArray.push(this);\n };\n\n /**\n * Connects to the p5sound instance (master output) by default.\n * Optionally, you can pass in a specific source (i.e. a soundfile).\n *\n * @method setInput\n * @for p5.Amplitude\n * @param {soundObject|undefined} [snd] set the sound source\n * (optional, defaults to\n * master output)\n * @param {Number|undefined} [smoothing] a range between 0.0 and 1.0\n * to smooth amplitude readings\n * @example\n *
\n * function preload(){\n * sound1 = loadSound('assets/beat.mp3');\n * sound2 = loadSound('assets/drum.mp3');\n * }\n * function setup(){\n * cnv = createCanvas(100, 100);\n * cnv.mouseClicked(toggleSound);\n *\n * amplitude = new p5.Amplitude();\n * amplitude.setInput(sound2);\n * }\n *\n * function draw() {\n * background(220);\n * text('tap to play', 20, 20);\n *\n * let level = amplitude.getLevel();\n * let size = map(level, 0, 1, 0, 200);\n * ellipse(width/2, height/2, size, size);\n * }\n *\n * function toggleSound(){\n * if (sound1.isPlaying() && sound2.isPlaying()) {\n * sound1.stop();\n * sound2.stop();\n * } else {\n * sound1.play();\n * sound2.play();\n * }\n * }\n *
\n */\n p5.Amplitude.prototype.setInput = function(source, smoothing) {\n\n p5sound.meter.disconnect();\n\n if (smoothing) {\n this._workletNode.parameters.get('smoothing').value = smoothing;\n }\n\n // connect to the master out of p5s instance if no snd is provided\n if (source == null) {\n console.log('Amplitude input source is not ready! Connecting to master output instead');\n p5sound.meter.connect(this._workletNode);\n }\n\n // if it is a p5.Signal\n else if (source instanceof p5.Signal) {\n source.output.connect(this._workletNode);\n }\n // connect to the sound if it is available\n else if (source) {\n source.connect(this._workletNode);\n this._workletNode.disconnect();\n this._workletNode.connect(this.output);\n }\n\n // otherwise, connect to the master out of p5s instance (default)\n else {\n p5sound.meter.connect(this._workletNode);\n }\n };\n\n p5.Amplitude.prototype.connect = function(unit) {\n if (unit) {\n if (unit.hasOwnProperty('input')) {\n this.output.connect(unit.input);\n } else {\n this.output.connect(unit);\n }\n } else {\n this.output.connect(this.panner.connect(p5sound.input));\n }\n };\n\n p5.Amplitude.prototype.disconnect = function() {\n if (this.output) {\n this.output.disconnect();\n }\n };\n\n /**\n * Returns a single Amplitude reading at the moment it is called.\n * For continuous readings, run in the draw loop.\n *\n * @method getLevel\n * @for p5.Amplitude\n * @param {Number} [channel] Optionally return only channel 0 (left) or 1 (right)\n * @return {Number} Amplitude as a number between 0.0 and 1.0\n * @example\n *
\n * function preload(){\n * sound = loadSound('assets/beat.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mouseClicked(toggleSound);\n * amplitude = new p5.Amplitude();\n * }\n *\n * function draw() {\n * background(220, 150);\n * textAlign(CENTER);\n * text('tap to play', width/2, 20);\n *\n * let level = amplitude.getLevel();\n * let size = map(level, 0, 1, 0, 200);\n * ellipse(width/2, height/2, size, size);\n * }\n *\n * function toggleSound(){\n * if (sound.isPlaying()) {\n * sound.stop();\n * } else {\n * sound.play();\n * }\n * }\n *
\n */\n p5.Amplitude.prototype.getLevel = function(channel) {\n if (typeof channel !== 'undefined') {\n if (this.normalize) {\n return this.stereoVolNorm[channel];\n } else {\n return this.stereoVol[channel];\n }\n }\n else if (this.normalize) {\n return this.volNorm;\n }\n else {\n return this.volume;\n }\n };\n\n /**\n * Determines whether the results of Amplitude.process() will be\n * Normalized. To normalize, Amplitude finds the difference the\n * loudest reading it has processed and the maximum amplitude of\n * 1.0. Amplitude adds this difference to all values to produce\n * results that will reliably map between 0.0 and 1.0. However,\n * if a louder moment occurs, the amount that Normalize adds to\n * all the values will change. Accepts an optional boolean parameter\n * (true or false). Normalizing is off by default.\n *\n * @method toggleNormalize\n * @for p5.Amplitude\n * @param {boolean} [boolean] set normalize to true (1) or false (0)\n */\n p5.Amplitude.prototype.toggleNormalize = function(bool) {\n if (typeof bool === 'boolean') {\n this.normalize = bool;\n }\n else {\n this.normalize = !this.normalize;\n }\n this._workletNode.port.postMessage({ name: 'toggleNormalize', normalize: this.normalize });\n };\n\n /**\n * Smooth Amplitude analysis by averaging with the last analysis\n * frame. Off by default.\n *\n * @method smooth\n * @for p5.Amplitude\n * @param {Number} set smoothing from 0.0 <= 1\n */\n p5.Amplitude.prototype.smooth = function(s) {\n if (s >= 0 && s < 1) {\n this._workletNode.port.postMessage({ name: 'smoothing', smoothing: s });\n } else {\n console.log('Error: smoothing must be between 0 and 1');\n }\n };\n\n p5.Amplitude.prototype.dispose = function() {\n // remove reference from soundArray\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n\n if (this.input) {\n this.input.disconnect();\n delete this.input;\n }\n if (this.output) {\n this.output.disconnect();\n delete this.output;\n }\n\n this._workletNode.disconnect();\n delete this._workletNode;\n };\n\n});\n","'use strict';\n\ndefine(function(require) {\n var p5sound = require('master');\n const {safeBins} = require('helpers');\n\n /**\n *

FFT (Fast Fourier Transform) is an analysis algorithm that\n * isolates individual\n * \n * audio frequencies within a waveform.

\n *\n *

Once instantiated, a p5.FFT object can return an array based on\n * two types of analyses:
• FFT.waveform() computes\n * amplitude values along the time domain. The array indices correspond\n * to samples across a brief moment in time. Each value represents\n * amplitude of the waveform at that sample of time.
\n * • FFT.analyze() computes amplitude values along the\n * frequency domain. The array indices correspond to frequencies (i.e.\n * pitches), from the lowest to the highest that humans can hear. Each\n * value represents amplitude at that slice of the frequency spectrum.\n * Use with getEnergy() to measure amplitude at specific\n * frequencies, or within a range of frequencies.

\n *\n *

FFT analyzes a very short snapshot of sound called a sample\n * buffer. It returns an array of amplitude measurements, referred\n * to as bins. The array is 1024 bins long by default.\n * You can change the bin array length, but it must be a power of 2\n * between 16 and 1024 in order for the FFT algorithm to function\n * correctly. The actual size of the FFT buffer is twice the\n * number of bins, so given a standard sample rate, the buffer is\n * 2048/44100 seconds long.

\n *\n *\n * @class p5.FFT\n * @constructor\n * @param {Number} [smoothing] Smooth results of Freq Spectrum.\n * 0.0 < smoothing < 1.0.\n * Defaults to 0.8.\n * @param {Number} [bins] Length of resulting array.\n * Must be a power of two between\n * 16 and 1024. Defaults to 1024.\n * @example\n *
\n * function preload(){\n * sound = loadSound('assets/Damscray_DancingTiger.mp3');\n * }\n *\n * function setup(){\n * let cnv = createCanvas(100,100);\n * cnv.mouseClicked(togglePlay);\n * fft = new p5.FFT();\n * sound.amp(0.2);\n * }\n *\n * function draw(){\n * background(220);\n *\n * let spectrum = fft.analyze();\n * noStroke();\n * fill(255, 0, 255);\n * for (let i = 0; i< spectrum.length; i++){\n * let x = map(i, 0, spectrum.length, 0, width);\n * let h = -height + map(spectrum[i], 0, 255, height, 0);\n * rect(x, height, width / spectrum.length, h )\n * }\n *\n * let waveform = fft.waveform();\n * noFill();\n * beginShape();\n * stroke(20);\n * for (let i = 0; i < waveform.length; i++){\n * let x = map(i, 0, waveform.length, 0, width);\n * let y = map( waveform[i], -1, 1, 0, height);\n * vertex(x,y);\n * }\n * endShape();\n *\n * text('tap to play', 20, 20);\n * }\n *\n * function togglePlay() {\n * if (sound.isPlaying()) {\n * sound.pause();\n * } else {\n * sound.loop();\n * }\n * }\n *
\n */\n p5.FFT = function(smoothing, bins) {\n this.input = this.analyser = p5sound.audiocontext.createAnalyser();\n\n Object.defineProperties(this, {\n bins: {\n get: function() {\n return this.analyser.fftSize / 2;\n },\n set: function(b) {\n this.analyser.fftSize = b * 2;\n },\n configurable: true,\n enumerable: true\n },\n smoothing: {\n get: function() {\n return this.analyser.smoothingTimeConstant;\n },\n set: function(s) {\n this.analyser.smoothingTimeConstant = s;\n },\n configurable: true,\n enumerable: true\n }\n });\n\n // set default smoothing and bins\n this.smooth(smoothing);\n this.bins = safeBins(bins) || 1024;\n\n // default connections to p5sound fftMeter\n p5sound.fftMeter.connect(this.analyser);\n\n this.freqDomain = new Uint8Array(this.analyser.frequencyBinCount);\n this.timeDomain = new Uint8Array(this.analyser.frequencyBinCount);\n\n // predefined frequency ranges, these will be tweakable\n this.bass = [20, 140];\n this.lowMid = [140, 400];\n this.mid = [400, 2600];\n this.highMid = [2600, 5200];\n this.treble = [5200, 14000];\n\n // add this p5.SoundFile to the soundArray\n p5sound.soundArray.push(this);\n };\n\n /**\n * Set the input source for the FFT analysis. If no source is\n * provided, FFT will analyze all sound in the sketch.\n *\n * @method setInput\n * @for p5.FFT\n * @param {Object} [source] p5.sound object (or web audio API source node)\n */\n p5.FFT.prototype.setInput = function(source) {\n if (!source) {\n p5sound.fftMeter.connect(this.analyser);\n } else {\n if (source.output) {\n source.output.connect(this.analyser);\n } else if (source.connect) {\n source.connect(this.analyser);\n }\n p5sound.fftMeter.disconnect();\n }\n };\n\n /**\n * Returns an array of amplitude values (between -1.0 and +1.0) that represent\n * a snapshot of amplitude readings in a single buffer. Length will be\n * equal to bins (defaults to 1024). Can be used to draw the waveform\n * of a sound.\n *\n * @method waveform\n * @for p5.FFT\n * @param {Number} [bins] Must be a power of two between\n * 16 and 1024. Defaults to 1024.\n * @param {String} [precision] If any value is provided, will return results\n * in a Float32 Array which is more precise\n * than a regular array.\n * @return {Array} Array Array of amplitude values (-1 to 1)\n * over time. Array length = bins.\n *\n */\n p5.FFT.prototype.waveform = function() {\n var bins, mode, normalArray;\n\n for (var i = 0; i < arguments.length; i++) {\n if (typeof arguments[i] === 'number') {\n bins = arguments[i];\n this.analyser.fftSize = bins * 2;\n }\n if (typeof arguments[i] === 'string') {\n mode = arguments[i];\n }\n }\n\n // getFloatFrequencyData doesnt work in Safari as of 5/2015\n if (mode && !p5.prototype._isSafari()) {\n timeToFloat(this, this.timeDomain);\n this.analyser.getFloatTimeDomainData(this.timeDomain);\n return this.timeDomain;\n } else {\n timeToInt(this, this.timeDomain);\n this.analyser.getByteTimeDomainData(this.timeDomain);\n var normalArray = new Array();\n for (var j = 0; j < this.timeDomain.length; j++) {\n var scaled = p5.prototype.map(this.timeDomain[j], 0, 255, -1, 1);\n normalArray.push(scaled);\n }\n return normalArray;\n }\n };\n\n /**\n * Returns an array of amplitude values (between 0 and 255)\n * across the frequency spectrum. Length is equal to FFT bins\n * (1024 by default). The array indices correspond to frequencies\n * (i.e. pitches), from the lowest to the highest that humans can\n * hear. Each value represents amplitude at that slice of the\n * frequency spectrum. Must be called prior to using\n * getEnergy().\n *\n * @method analyze\n * @for p5.FFT\n * @param {Number} [bins] Must be a power of two between\n * 16 and 1024. Defaults to 1024.\n * @param {Number} [scale] If \"dB,\" returns decibel\n * float measurements between\n * -140 and 0 (max).\n * Otherwise returns integers from 0-255.\n * @return {Array} spectrum Array of energy (amplitude/volume)\n * values across the frequency spectrum.\n * Lowest energy (silence) = 0, highest\n * possible is 255.\n * @example\n *
\n * let osc, fft;\n *\n * function setup(){\n * let cnv = createCanvas(100,100);\n * cnv.mousePressed(startSound);\n * osc = new p5.Oscillator();\n * osc.amp(0);\n * fft = new p5.FFT();\n * }\n *\n * function draw(){\n * background(220);\n *\n * let freq = map(mouseX, 0, windowWidth, 20, 10000);\n * freq = constrain(freq, 1, 20000);\n * osc.freq(freq);\n *\n * let spectrum = fft.analyze();\n * noStroke();\n * fill(255, 0, 255);\n * for (let i = 0; i< spectrum.length; i++){\n * let x = map(i, 0, spectrum.length, 0, width);\n * let h = -height + map(spectrum[i], 0, 255, height, 0);\n * rect(x, height, width / spectrum.length, h );\n * }\n *\n * stroke(255);\n * if (!osc.started) {\n * text('tap here and drag to change frequency', 10, 20, width - 20);\n * } else {\n * text(round(freq)+'Hz', 10, 20);\n * }\n * }\n *\n * function startSound() {\n * osc.start();\n * osc.amp(0.5, 0.2);\n * }\n *\n * function mouseReleased() {\n * osc.amp(0, 0.2);\n * }\n *
\n *\n *\n */\n p5.FFT.prototype.analyze = function() {\n var mode;\n\n for (var i = 0; i < arguments.length; i++) {\n if (typeof arguments[i] === 'number') {\n this.bins = arguments[i];\n this.analyser.fftSize = this.bins * 2;\n }\n if (typeof arguments[i] === 'string') {\n mode = arguments[i];\n }\n }\n\n if (mode && mode.toLowerCase() === 'db') {\n freqToFloat(this);\n this.analyser.getFloatFrequencyData(this.freqDomain);\n return this.freqDomain;\n } else {\n freqToInt(this, this.freqDomain);\n this.analyser.getByteFrequencyData(this.freqDomain);\n var normalArray = Array.apply([], this.freqDomain);\n\n return normalArray;\n }\n };\n\n /**\n * Returns the amount of energy (volume) at a specific\n * \n * frequency, or the average amount of energy between two\n * frequencies. Accepts Number(s) corresponding\n * to frequency (in Hz), or a String corresponding to predefined\n * frequency ranges (\"bass\", \"lowMid\", \"mid\", \"highMid\", \"treble\").\n * Returns a range between 0 (no energy/volume at that frequency) and\n * 255 (maximum energy).\n * NOTE: analyze() must be called prior to getEnergy(). Analyze()\n * tells the FFT to analyze frequency data, and getEnergy() uses\n * the results determine the value at a specific frequency or\n * range of frequencies.

\n *\n * @method getEnergy\n * @for p5.FFT\n * @param {Number|String} frequency1 Will return a value representing\n * energy at this frequency. Alternately,\n * the strings \"bass\", \"lowMid\" \"mid\",\n * \"highMid\", and \"treble\" will return\n * predefined frequency ranges.\n * @param {Number} [frequency2] If a second frequency is given,\n * will return average amount of\n * energy that exists between the\n * two frequencies.\n * @return {Number} Energy Energy (volume/amplitude) from\n * 0 and 255.\n *\n */\n p5.FFT.prototype.getEnergy = function(frequency1, frequency2) {\n var nyquist = p5sound.audiocontext.sampleRate / 2;\n\n if (frequency1 === 'bass') {\n frequency1 = this.bass[0];\n frequency2 = this.bass[1];\n } else if (frequency1 === 'lowMid') {\n frequency1 = this.lowMid[0];\n frequency2 = this.lowMid[1];\n } else if (frequency1 === 'mid') {\n frequency1 = this.mid[0];\n frequency2 = this.mid[1];\n } else if (frequency1 === 'highMid') {\n frequency1 = this.highMid[0];\n frequency2 = this.highMid[1];\n } else if (frequency1 === 'treble') {\n frequency1 = this.treble[0];\n frequency2 = this.treble[1];\n }\n\n if (typeof frequency1 !== 'number') {\n throw 'invalid input for getEnergy()';\n } else if (!frequency2) {\n // if only one parameter:\n var index = Math.round(frequency1 / nyquist * this.freqDomain.length);\n return this.freqDomain[index];\n } else if (frequency1 && frequency2) {\n // if two parameters:\n // if second is higher than first\n if (frequency1 > frequency2) {\n var swap = frequency2;\n frequency2 = frequency1;\n frequency1 = swap;\n }\n var lowIndex = Math.round(frequency1 / nyquist * this.freqDomain.length);\n var highIndex = Math.round(frequency2 / nyquist * this.freqDomain.length);\n\n var total = 0;\n var numFrequencies = 0;\n // add up all of the values for the frequencies\n for (var i = lowIndex; i <= highIndex; i++) {\n total += this.freqDomain[i];\n numFrequencies += 1;\n }\n // divide by total number of frequencies\n var toReturn = total / numFrequencies;\n return toReturn;\n } else {\n throw 'invalid input for getEnergy()';\n }\n };\n\n // compatability with v.012, changed to getEnergy in v.0121. Will be deprecated...\n p5.FFT.prototype.getFreq = function(freq1, freq2) {\n console.log('getFreq() is deprecated. Please use getEnergy() instead.');\n var x = this.getEnergy(freq1, freq2);\n return x;\n };\n\n /**\n * Returns the\n * \n * spectral centroid of the input signal.\n * NOTE: analyze() must be called prior to getCentroid(). Analyze()\n * tells the FFT to analyze frequency data, and getCentroid() uses\n * the results determine the spectral centroid.

\n *\n * @method getCentroid\n * @for p5.FFT\n * @return {Number} Spectral Centroid Frequency of the spectral centroid in Hz.\n *\n *\n * @example\n *
\n * function setup(){\n * cnv = createCanvas(100,100);\n * cnv.mousePressed(userStartAudio);\n * sound = new p5.AudioIn();\n * sound.start();\n * fft = new p5.FFT();\n * sound.connect(fft);\n *}\n *\n *function draw() {\n * if (getAudioContext().state !== 'running') {\n * background(220);\n * text('tap here and enable mic to begin', 10, 20, width - 20);\n * return;\n * }\n * let centroidplot = 0.0;\n * let spectralCentroid = 0;\n *\n * background(0);\n * stroke(0,255,0);\n * let spectrum = fft.analyze();\n * fill(0,255,0); // spectrum is green\n *\n * //draw the spectrum\n * for (let i = 0; i < spectrum.length; i++){\n * let x = map(log(i), 0, log(spectrum.length), 0, width);\n * let h = map(spectrum[i], 0, 255, 0, height);\n * let rectangle_width = (log(i+1)-log(i))*(width/log(spectrum.length));\n * rect(x, height, rectangle_width, -h )\n * }\n * let nyquist = 22050;\n *\n * // get the centroid\n * spectralCentroid = fft.getCentroid();\n *\n * // the mean_freq_index calculation is for the display.\n * let mean_freq_index = spectralCentroid/(nyquist/spectrum.length);\n *\n * centroidplot = map(log(mean_freq_index), 0, log(spectrum.length), 0, width);\n *\n * stroke(255,0,0); // the line showing where the centroid is will be red\n *\n * rect(centroidplot, 0, width / spectrum.length, height)\n * noStroke();\n * fill(255,255,255); // text is white\n * text('centroid: ', 10, 20);\n * text(round(spectralCentroid)+' Hz', 10, 40);\n *}\n *
\n */\n p5.FFT.prototype.getCentroid = function() {\n var nyquist = p5sound.audiocontext.sampleRate / 2;\n var cumulative_sum = 0;\n var centroid_normalization = 0;\n\n for (var i = 0; i < this.freqDomain.length; i++) {\n cumulative_sum += i * this.freqDomain[i];\n centroid_normalization += this.freqDomain[i];\n }\n\n var mean_freq_index = 0;\n\n if (centroid_normalization !== 0) {\n mean_freq_index = cumulative_sum / centroid_normalization;\n }\n\n var spec_centroid_freq =\n mean_freq_index * (nyquist / this.freqDomain.length);\n return spec_centroid_freq;\n };\n\n /**\n * Smooth FFT analysis by averaging with the last analysis frame.\n *\n * @method smooth\n * @param {Number} smoothing 0.0 < smoothing < 1.0.\n * Defaults to 0.8.\n */\n p5.FFT.prototype.smooth = function(s) {\n if (typeof s !== 'undefined') {\n this.smoothing = s;\n }\n return this.smoothing;\n };\n\n p5.FFT.prototype.dispose = function() {\n // remove reference from soundArray\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n\n if (this.analyser) {\n this.analyser.disconnect();\n delete this.analyser;\n }\n };\n\n /**\n * Returns an array of average amplitude values for a given number\n * of frequency bands split equally. N defaults to 16.\n * NOTE: analyze() must be called prior to linAverages(). Analyze()\n * tells the FFT to analyze frequency data, and linAverages() uses\n * the results to group them into a smaller set of averages.

\n *\n * @method linAverages\n * @for p5.FFT\n * @param {Number} N Number of returned frequency groups\n * @return {Array} linearAverages Array of average amplitude values for each group\n */\n p5.FFT.prototype.linAverages = function(N) {\n var N = N || 16; // This prevents undefined, null or 0 values of N\n\n var spectrum = this.freqDomain;\n var spectrumLength = spectrum.length;\n var spectrumStep = Math.floor(spectrumLength / N);\n\n var linearAverages = new Array(N);\n // Keep a second index for the current average group and place the values accordingly\n // with only one loop in the spectrum data\n var groupIndex = 0;\n\n for (var specIndex = 0; specIndex < spectrumLength; specIndex++) {\n linearAverages[groupIndex] =\n linearAverages[groupIndex] !== undefined\n ? (linearAverages[groupIndex] + spectrum[specIndex]) / 2\n : spectrum[specIndex];\n\n // Increase the group index when the last element of the group is processed\n if (specIndex % spectrumStep === spectrumStep - 1) {\n groupIndex++;\n }\n }\n\n return linearAverages;\n };\n\n /**\n * Returns an array of average amplitude values of the spectrum, for a given\n * set of \n * Octave Bands\n * NOTE: analyze() must be called prior to logAverages(). Analyze()\n * tells the FFT to analyze frequency data, and logAverages() uses\n * the results to group them into a smaller set of averages.

\n *\n * @method logAverages\n * @for p5.FFT\n * @param {Array} octaveBands Array of Octave Bands objects for grouping\n * @return {Array} logAverages Array of average amplitude values for each group\n */\n p5.FFT.prototype.logAverages = function(octaveBands) {\n var nyquist = p5sound.audiocontext.sampleRate / 2;\n var spectrum = this.freqDomain;\n var spectrumLength = spectrum.length;\n\n var logAverages = new Array(octaveBands.length);\n // Keep a second index for the current average group and place the values accordingly\n // With only one loop in the spectrum data\n var octaveIndex = 0;\n\n for (var specIndex = 0; specIndex < spectrumLength; specIndex++) {\n var specIndexFrequency = Math.round(\n specIndex * nyquist / this.freqDomain.length\n );\n\n // Increase the group index if the current frequency exceeds the limits of the band\n if (specIndexFrequency > octaveBands[octaveIndex].hi) {\n octaveIndex++;\n }\n\n logAverages[octaveIndex] =\n logAverages[octaveIndex] !== undefined\n ? (logAverages[octaveIndex] + spectrum[specIndex]) / 2\n : spectrum[specIndex];\n }\n\n return logAverages;\n };\n\n /**\n * Calculates and Returns the 1/N\n * Octave Bands\n * N defaults to 3 and minimum central frequency to 15.625Hz.\n * (1/3 Octave Bands ~= 31 Frequency Bands)\n * Setting fCtr0 to a central value of a higher octave will ignore the lower bands\n * and produce less frequency groups.\n *\n * @method getOctaveBands\n * @for p5.FFT\n * @param {Number} N Specifies the 1/N type of generated octave bands\n * @param {Number} fCtr0 Minimum central frequency for the lowest band\n * @return {Array} octaveBands Array of octave band objects with their bounds\n */\n p5.FFT.prototype.getOctaveBands = function(N, fCtr0) {\n var N = N || 3; // Default to 1/3 Octave Bands\n var fCtr0 = fCtr0 || 15.625; // Minimum central frequency, defaults to 15.625Hz\n\n var octaveBands = [];\n var lastFrequencyBand = {\n lo: fCtr0 / Math.pow(2, 1 / (2 * N)),\n ctr: fCtr0,\n hi: fCtr0 * Math.pow(2, 1 / (2 * N))\n };\n octaveBands.push(lastFrequencyBand);\n\n var nyquist = p5sound.audiocontext.sampleRate / 2;\n while (lastFrequencyBand.hi < nyquist) {\n var newFrequencyBand = {};\n newFrequencyBand.lo = lastFrequencyBand.hi;\n newFrequencyBand.ctr = lastFrequencyBand.ctr * Math.pow(2, 1 / N);\n newFrequencyBand.hi = newFrequencyBand.ctr * Math.pow(2, 1 / (2 * N));\n\n octaveBands.push(newFrequencyBand);\n lastFrequencyBand = newFrequencyBand;\n }\n\n return octaveBands;\n };\n\n // helper methods to convert type from float (dB) to int (0-255)\n var freqToFloat = function(fft) {\n if (fft.freqDomain instanceof Float32Array === false) {\n fft.freqDomain = new Float32Array(fft.analyser.frequencyBinCount);\n }\n };\n var freqToInt = function(fft) {\n if (fft.freqDomain instanceof Uint8Array === false) {\n fft.freqDomain = new Uint8Array(fft.analyser.frequencyBinCount);\n }\n };\n var timeToFloat = function(fft) {\n if (fft.timeDomain instanceof Float32Array === false) {\n fft.timeDomain = new Float32Array(fft.analyser.frequencyBinCount);\n }\n };\n var timeToInt = function(fft) {\n if (fft.timeDomain instanceof Uint8Array === false) {\n fft.timeDomain = new Uint8Array(fft.analyser.frequencyBinCount);\n }\n };\n});\n","'use strict';\n\ndefine(function (require) {\n\n // Signal is built with the Tone.js signal by Yotam Mann\n // https://github.com/TONEnoTONE/Tone.js/\n var Signal = require('Tone/signal/Signal');\n var Add = require('Tone/signal/Add');\n var Mult = require('Tone/signal/Multiply');\n var Scale = require('Tone/signal/Scale');\n\n /**\n *

p5.Signal is a constant audio-rate signal used by p5.Oscillator\n * and p5.Envelope for modulation math.

\n *\n *

This is necessary because Web Audio is processed on a seprate clock.\n * For example, the p5 draw loop runs about 60 times per second. But\n * the audio clock must process samples 44100 times per second. If we\n * want to add a value to each of those samples, we can't do it in the\n * draw loop, but we can do it by adding a constant-rate audio signal.This class mostly functions behind the scenes in p5.sound, and returns\n * a Tone.Signal from the Tone.js library by Yotam Mann.\n * If you want to work directly with audio signals for modular\n * synthesis, check out\n * tone.js.

\n *\n * @class p5.Signal\n * @constructor\n * @return {Tone.Signal} A Signal object from the Tone.js library\n * @example\n *
\n * let carrier, modulator;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * text('tap to play', 20, 20);\n *\n * carrier = new p5.Oscillator('sine');\n * carrier.start();\n * carrier.amp(1); // set amplitude\n * carrier.freq(220); // set frequency\n *\n * modulator = new p5.Oscillator('sawtooth');\n * modulator.disconnect();\n * modulator.start();\n * modulator.amp(1);\n * modulator.freq(4);\n *\n * // Modulator's default amplitude range is -1 to 1.\n * // Multiply it by -200, so the range is -200 to 200\n * // then add 220 so the range is 20 to 420\n * carrier.freq( modulator.mult(-400).add(220) );\n * }\n *\n * function canvasPressed() {\n * userStartAudio();\n * carrier.amp(1.0);\n * }\n *\n * function mouseReleased() {\n * carrier.amp(0);\n * }\n *
\n */\n p5.Signal = function(value) {\n var s = new Signal(value);\n // p5sound.soundArray.push(s);\n return s; // TODO: is this really a constructor?\n };\n\n /**\n * Fade to value, for smooth transitions\n *\n * @method fade\n * @for p5.Signal\n * @param {Number} value Value to set this signal\n * @param {Number} [secondsFromNow] Length of fade, in seconds from now\n */\n Signal.prototype.fade = Signal.prototype.linearRampToValueAtTime;\n Mult.prototype.fade = Signal.prototype.fade;\n Add.prototype.fade = Signal.prototype.fade;\n Scale.prototype.fade = Signal.prototype.fade;\n\n\n /**\n * Connect a p5.sound object or Web Audio node to this\n * p5.Signal so that its amplitude values can be scaled.\n *\n * @method setInput\n * @for p5.Signal\n * @param {Object} input\n */\n Signal.prototype.setInput = function(_input) {\n _input.connect(this);\n };\n Mult.prototype.setInput = Signal.prototype.setInput;\n Add.prototype.setInput = Signal.prototype.setInput;\n Scale.prototype.setInput = Signal.prototype.setInput;\n\n\n // signals can add / mult / scale themselves\n\n /**\n * Add a constant value to this audio signal,\n * and return the resulting audio signal. Does\n * not change the value of the original signal,\n * instead it returns a new p5.SignalAdd.\n *\n * @method add\n * @for p5.Signal\n * @param {Number} number\n * @return {p5.Signal} object\n */\n Signal.prototype.add = function(num) {\n var add = new Add(num);\n // add.setInput(this);\n this.connect(add);\n return add;\n };\n Mult.prototype.add = Signal.prototype.add;\n Add.prototype.add = Signal.prototype.add;\n Scale.prototype.add = Signal.prototype.add;\n\n /**\n * Multiply this signal by a constant value,\n * and return the resulting audio signal. Does\n * not change the value of the original signal,\n * instead it returns a new p5.SignalMult.\n *\n * @method mult\n * @for p5.Signal\n * @param {Number} number to multiply\n * @return {p5.Signal} object\n */\n Signal.prototype.mult = function(num) {\n var mult = new Mult(num);\n // mult.setInput(this);\n this.connect(mult);\n return mult;\n };\n Mult.prototype.mult = Signal.prototype.mult;\n Add.prototype.mult = Signal.prototype.mult;\n Scale.prototype.mult = Signal.prototype.mult;\n\n /**\n * Scale this signal value to a given range,\n * and return the result as an audio signal. Does\n * not change the value of the original signal,\n * instead it returns a new p5.SignalScale.\n *\n * @method scale\n * @for p5.Signal\n * @param {Number} number to multiply\n * @param {Number} inMin input range minumum\n * @param {Number} inMax input range maximum\n * @param {Number} outMin input range minumum\n * @param {Number} outMax input range maximum\n * @return {p5.Signal} object\n */\n Signal.prototype.scale = function(inMin, inMax, outMin, outMax) {\n var mapOutMin, mapOutMax;\n if (arguments.length === 4) {\n mapOutMin = p5.prototype.map(outMin, inMin, inMax, 0, 1) - 0.5;\n mapOutMax = p5.prototype.map(outMax, inMin, inMax, 0, 1) - 0.5;\n }\n else {\n mapOutMin = arguments[0];\n mapOutMax = arguments[1];\n }\n var scale = new Scale(mapOutMin, mapOutMax);\n this.connect(scale);\n return scale;\n };\n Mult.prototype.scale = Signal.prototype.scale;\n Add.prototype.scale = Signal.prototype.scale;\n Scale.prototype.scale = Signal.prototype.scale;\n\n});\n\n\n","define([\"Tone/core/Tone\", \"Tone/type/TimeBase\"], function (Tone) {\n\n\t/**\n\t * @class Tone.Frequency is a primitive type for encoding Frequency values. \n\t * Eventually all time values are evaluated to hertz\n\t * using the `eval` method. \n\t * @constructor\n\t * @extends {Tone.TimeBase}\n\t * @param {String|Number} val The time value.\n\t * @param {String=} units The units of the value.\n\t * @example\n\t * Tone.Frequency(\"C3\") // 261\n\t * Tone.Frequency(38, \"midi\") //\n\t * Tone.Frequency(\"C3\").transpose(4);\n\t */\n\tTone.Frequency = function(val, units){\n\t\tif (this instanceof Tone.Frequency){\n\t\t\t\n\t\t\tTone.TimeBase.call(this, val, units);\n\n\t\t} else {\n\t\t\treturn new Tone.Frequency(val, units);\n\t\t}\n\t};\n\n\tTone.extend(Tone.Frequency, Tone.TimeBase);\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tAUGMENT BASE EXPRESSIONS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t//clone the expressions so that \n\t//we can add more without modifying the original\n\tTone.Frequency.prototype._primaryExpressions = Object.create(Tone.TimeBase.prototype._primaryExpressions);\n\n\t/*\n\t * midi type primary expression\n\t * @type {Object}\n\t * @private\n\t */\n\tTone.Frequency.prototype._primaryExpressions.midi = {\n\t\tregexp : /^(\\d+(?:\\.\\d+)?midi)/,\n\t\tmethod : function(value){\n\t\t\treturn this.midiToFrequency(value);\n\t\t}\t\n\t};\n\n\t/*\n\t * note type primary expression\n\t * @type {Object}\n\t * @private\n\t */\n\tTone.Frequency.prototype._primaryExpressions.note = {\n\t\tregexp : /^([a-g]{1}(?:b|#|x|bb)?)(-?[0-9]+)/i,\n\t\tmethod : function(pitch, octave){\n\t\t\tvar index = noteToScaleIndex[pitch.toLowerCase()];\n\t\t\tvar noteNumber = index + (parseInt(octave) + 1) * 12;\n\t\t\treturn this.midiToFrequency(noteNumber);\n\t\t}\t\n\t};\n\n\t/*\n\t * BeatsBarsSixteenths type primary expression\n\t * @type {Object}\n\t * @private\n\t */\n\tTone.Frequency.prototype._primaryExpressions.tr = {\n\t\t\tregexp : /^(\\d+(?:\\.\\d+)?):(\\d+(?:\\.\\d+)?):?(\\d+(?:\\.\\d+)?)?/,\n\t\t\tmethod : function(m, q, s){\n\t\t\tvar total = 1;\n\t\t\tif (m && m !== \"0\"){\n\t\t\t\ttotal *= this._beatsToUnits(this._timeSignature() * parseFloat(m));\n\t\t\t}\n\t\t\tif (q && q !== \"0\"){\n\t\t\t\ttotal *= this._beatsToUnits(parseFloat(q));\n\t\t\t}\n\t\t\tif (s && s !== \"0\"){\n\t\t\t\ttotal *= this._beatsToUnits(parseFloat(s) / 4);\n\t\t\t}\n\t\t\treturn total;\n\t\t}\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tEXPRESSIONS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Transposes the frequency by the given number of semitones.\n\t * @param {Interval} interval\n\t * @return {Tone.Frequency} this\n\t * @example\n\t * Tone.Frequency(\"A4\").transpose(3); //\"C5\"\n\t */\n\tTone.Frequency.prototype.transpose = function(interval){\n\t\tthis._expr = function(expr, interval){\n\t\t\tvar val = expr();\n\t\t\treturn val * this.intervalToFrequencyRatio(interval);\n\t\t}.bind(this, this._expr, interval);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Takes an array of semitone intervals and returns\n\t * an array of frequencies transposed by those intervals.\n\t * @param {Array} intervals\n\t * @return {Tone.Frequency} this\n\t * @example\n\t * Tone.Frequency(\"A4\").harmonize([0, 3, 7]); //[\"A4\", \"C5\", \"E5\"]\n\t */\n\tTone.Frequency.prototype.harmonize = function(intervals){\n\t\tthis._expr = function(expr, intervals){\n\t\t\tvar val = expr();\n\t\t\tvar ret = [];\n\t\t\tfor (var i = 0; i < intervals.length; i++){\n\t\t\t\tret[i] = val * this.intervalToFrequencyRatio(intervals[i]);\n\t\t\t}\n\t\t\treturn ret;\n\t\t}.bind(this, this._expr, intervals);\n\t\treturn this;\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tUNIT CONVERSIONS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Return the value of the frequency as a MIDI note\n\t * @return {MIDI}\n\t * @example\n\t * Tone.Frequency(\"C4\").toMidi(); //60\n\t */\n\tTone.Frequency.prototype.toMidi = function(){\n\t\treturn this.frequencyToMidi(this.valueOf());\n\t};\n\n\t/**\n\t * Return the value of the frequency in Scientific Pitch Notation\n\t * @return {Note}\n\t * @example\n\t * Tone.Frequency(69, \"midi\").toNote(); //\"A4\"\n\t */\n\tTone.Frequency.prototype.toNote = function(){\n\t\tvar freq = this.valueOf();\n\t\tvar log = Math.log(freq / Tone.Frequency.A4) / Math.LN2;\n\t\tvar noteNumber = Math.round(12 * log) + 57;\n\t\tvar octave = Math.floor(noteNumber/12);\n\t\tif(octave < 0){\n\t\t\tnoteNumber += -12 * octave;\n\t\t}\n\t\tvar noteName = scaleIndexToNote[noteNumber % 12];\n\t\treturn noteName + octave.toString();\n\t};\n\n\t/**\n\t * Return the duration of one cycle in seconds.\n\t * @return {Seconds}\n\t */\n\tTone.Frequency.prototype.toSeconds = function(){\n\t\treturn 1 / this.valueOf();\n\t};\n\n\t/**\n\t * Return the value in Hertz\n\t * @return {Frequency}\n\t */\n\tTone.Frequency.prototype.toFrequency = function(){\n\t\treturn this.valueOf();\n\t};\n\n\t/**\n\t * Return the duration of one cycle in ticks\n\t * @return {Ticks}\n\t */\n\tTone.Frequency.prototype.toTicks = function(){\n\t\tvar quarterTime = this._beatsToUnits(1);\n\t\tvar quarters = this.valueOf() / quarterTime;\n\t\treturn Math.floor(quarters * Tone.Transport.PPQ);\n\t};\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tUNIT CONVERSIONS HELPERS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Returns the value of a frequency in the current units\n\t * @param {Frequency} freq\n\t * @return {Number}\n\t * @private\n\t */\n\tTone.Frequency.prototype._frequencyToUnits = function(freq){\n\t\treturn freq;\n\t};\n\n\t/**\n\t * Returns the value of a tick in the current time units\n\t * @param {Ticks} ticks\n\t * @return {Number}\n\t * @private\n\t */\n\tTone.Frequency.prototype._ticksToUnits = function(ticks){\n\t\treturn 1 / ((ticks * 60) / (Tone.Transport.bpm.value * Tone.Transport.PPQ));\n\t};\n\n\t/**\n\t * Return the value of the beats in the current units\n\t * @param {Number} beats\n\t * @return {Number}\n\t * @private\n\t */\n\tTone.Frequency.prototype._beatsToUnits = function(beats){\n\t\treturn 1 / Tone.TimeBase.prototype._beatsToUnits.call(this, beats);\n\t};\n\n\t/**\n\t * Returns the value of a second in the current units\n\t * @param {Seconds} seconds\n\t * @return {Number}\n\t * @private\n\t */\n\tTone.Frequency.prototype._secondsToUnits = function(seconds){\n\t\treturn 1 / seconds;\n\t};\n\n\t/**\n\t * The default units if none are given.\n\t * @private\n\t */\n\tTone.Frequency.prototype._defaultUnits = \"hz\";\n\n\t///////////////////////////////////////////////////////////////////////////\n\t//\tFREQUENCY CONVERSIONS\n\t///////////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * Note to scale index\n\t * @type {Object}\n\t */\n\tvar noteToScaleIndex = {\n\t\t\"cbb\" : -2, \"cb\" : -1, \"c\" : 0, \"c#\" : 1, \"cx\" : 2, \n\t\t\"dbb\" : 0, \"db\" : 1, \"d\" : 2, \"d#\" : 3, \"dx\" : 4,\n\t\t\"ebb\" : 2, \"eb\" : 3, \"e\" : 4, \"e#\" : 5, \"ex\" : 6, \n\t\t\"fbb\" : 3, \"fb\" : 4, \"f\" : 5, \"f#\" : 6, \"fx\" : 7,\n\t\t\"gbb\" : 5, \"gb\" : 6, \"g\" : 7, \"g#\" : 8, \"gx\" : 9,\n\t\t\"abb\" : 7, \"ab\" : 8, \"a\" : 9, \"a#\" : 10, \"ax\" : 11,\n\t\t\"bbb\" : 9, \"bb\" : 10, \"b\" : 11, \"b#\" : 12, \"bx\" : 13,\n\t};\n\n\t/**\n\t * scale index to note (sharps)\n\t * @type {Array}\n\t */\n\tvar scaleIndexToNote = [\"C\", \"C#\", \"D\", \"D#\", \"E\", \"F\", \"F#\", \"G\", \"G#\", \"A\", \"A#\", \"B\"];\n\n\t/**\n\t * The [concert pitch](https://en.wikipedia.org/wiki/Concert_pitch)\n\t * A4's values in Hertz. \n\t * @type {Frequency}\n\t * @static\n\t */\n\tTone.Frequency.A4 = 440;\n\n\t/**\n\t * Convert a MIDI note to frequency value. \n\t * @param {MIDI} midi The midi number to convert.\n\t * @return {Frequency} the corresponding frequency value\n\t * @example\n\t * tone.midiToFrequency(69); // returns 440\n\t */\n\tTone.Frequency.prototype.midiToFrequency = function(midi){\n\t\treturn Tone.Frequency.A4 * Math.pow(2, (midi - 69) / 12);\n\t};\n\n\t/**\n\t * Convert a frequency value to a MIDI note.\n\t * @param {Frequency} frequency The value to frequency value to convert.\n\t * @returns {MIDI}\n\t * @example\n\t * tone.midiToFrequency(440); // returns 69\n\t */\n\tTone.Frequency.prototype.frequencyToMidi = function(frequency){\n\t\treturn 69 + 12 * Math.log(frequency / Tone.Frequency.A4) / Math.LN2;\n\t};\n\n\treturn Tone.Frequency;\n});","define([\"Tone/core/Tone\", \"Tone/type/Time\"], function (Tone) {\n\n\t/**\n\t * @class Tone.TransportTime is a the time along the Transport's\n\t * timeline. It is similar to Tone.Time, but instead of evaluating\n\t * against the AudioContext's clock, it is evaluated against\n\t * the Transport's position. See [TransportTime wiki](https://github.com/Tonejs/Tone.js/wiki/TransportTime).\n\t * @constructor\n\t * @param {Time} val The time value as a number or string\n\t * @param {String=} units Unit values\n\t * @extends {Tone.Time}\n\t */\n\tTone.TransportTime = function(val, units){\n\t\tif (this instanceof Tone.TransportTime){\n\t\t\t\n\t\t\tTone.Time.call(this, val, units);\n\n\t\t} else {\n\t\t\treturn new Tone.TransportTime(val, units);\n\t\t}\n\t};\n\n\tTone.extend(Tone.TransportTime, Tone.Time);\n\n\t//clone the expressions so that \n\t//we can add more without modifying the original\n\tTone.TransportTime.prototype._unaryExpressions = Object.create(Tone.Time.prototype._unaryExpressions);\n\n\t/**\n\t * Adds an additional unary expression\n\t * which quantizes values to the next subdivision\n\t * @type {Object}\n\t * @private\n\t */\n\tTone.TransportTime.prototype._unaryExpressions.quantize = {\n\t\tregexp : /^@/,\n\t\tmethod : function(rh){\n\t\t\tvar subdivision = this._secondsToTicks(rh());\n\t\t\tvar multiple = Math.ceil(Tone.Transport.ticks / subdivision);\n\t\t\treturn this._ticksToUnits(multiple * subdivision);\n\t\t}\n\t};\n\n\t/**\n\t * Convert seconds into ticks\n\t * @param {Seconds} seconds\n\t * @return {Ticks}\n\t * @private\n\t */\n\tTone.TransportTime.prototype._secondsToTicks = function(seconds){\n\t\tvar quarterTime = this._beatsToUnits(1);\n\t\tvar quarters = seconds / quarterTime;\n\t\treturn Math.round(quarters * Tone.Transport.PPQ);\n\t};\n\n\t/**\n\t * Evaluate the time expression. Returns values in ticks\n\t * @return {Ticks}\n\t */\n\tTone.TransportTime.prototype.valueOf = function(){\n\t\tvar val = this._secondsToTicks(this._expr());\n\t\treturn val + (this._plusNow ? Tone.Transport.ticks : 0);\n\t};\n\n\t/**\n\t * Return the time in ticks.\n\t * @return {Ticks}\n\t */\n\tTone.TransportTime.prototype.toTicks = function(){\n\t\treturn this.valueOf();\n\t};\n\n\t/**\n\t * Return the time in seconds.\n\t * @return {Seconds}\n\t */\n\tTone.TransportTime.prototype.toSeconds = function(){\n\t\tvar val = this._expr();\n\t\treturn val + (this._plusNow ? Tone.Transport.seconds : 0);\n\t};\n\n\t/**\n\t * Return the time as a frequency value\n\t * @return {Frequency} \n\t */\n\tTone.TransportTime.prototype.toFrequency = function(){\n\t\treturn 1/this.toSeconds();\n\t};\n\n\treturn Tone.TransportTime;\n});","'use strict';\n\ndefine(function (require) {\n\n var p5sound = require('master');\n var Add = require('Tone/signal/Add');\n var Mult = require('Tone/signal/Multiply');\n var Scale = require('Tone/signal/Scale');\n var TimelineSignal = require('Tone/signal/TimelineSignal');\n\n /**\n *

Envelopes are pre-defined amplitude distribution over time.\n * Typically, envelopes are used to control the output volume\n * of an object, a series of fades referred to as Attack, Decay,\n * Sustain and Release (\n * ADSR\n * ). Envelopes can also control other Web Audio Parameters—for example, a p5.Envelope can\n * control an Oscillator's frequency like this: osc.freq(env).

\n *

Use setRange to change the attack/release level.\n * Use setADSR to change attackTime, decayTime, sustainPercent and releaseTime.

\n *

Use the play method to play the entire envelope,\n * the ramp method for a pingable trigger,\n * or triggerAttack/\n * triggerRelease to trigger noteOn/noteOff.

\n *\n * @class p5.Envelope\n * @constructor\n * @example\n *
\n * let t1 = 0.1; // attack time in seconds\n * let l1 = 0.7; // attack level 0.0 to 1.0\n * let t2 = 0.3; // decay time in seconds\n * let l2 = 0.1; // decay level 0.0 to 1.0\n *\n * let env;\n * let triOsc;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * background(220);\n * text('tap to play', 20, 20);\n * cnv.mousePressed(playSound);\n *\n * env = new p5.Envelope(t1, l1, t2, l2);\n * triOsc = new p5.Oscillator('triangle');\n * }\n *\n * function playSound() {\n * // starting the oscillator ensures that audio is enabled.\n * triOsc.start();\n * env.play(triOsc);\n * }\n *
\n */\n p5.Envelope = function(t1, l1, t2, l2, t3, l3) {\n /**\n * Time until envelope reaches attackLevel\n * @property attackTime\n */\n this.aTime = t1 || 0.1;\n /**\n * Level once attack is complete.\n * @property attackLevel\n */\n this.aLevel = l1 || 1;\n /**\n * Time until envelope reaches decayLevel.\n * @property decayTime\n */\n this.dTime = t2 || 0.5;\n /**\n * Level after decay. The envelope will sustain here until it is released.\n * @property decayLevel\n */\n this.dLevel = l2 || 0;\n /**\n * Duration of the release portion of the envelope.\n * @property releaseTime\n */\n this.rTime = t3 || 0;\n /**\n * Level at the end of the release.\n * @property releaseLevel\n */\n this.rLevel = l3 || 0;\n\n this._rampHighPercentage = 0.98;\n\n this._rampLowPercentage = 0.02;\n\n\n this.output = p5sound.audiocontext.createGain();\n\n this.control = new TimelineSignal();\n\n this._init(); // this makes sure the envelope starts at zero\n\n this.control.connect(this.output); // connect to the output\n\n this.connection = null; // store connection\n\n //array of math operation signal chaining\n this.mathOps = [this.control];\n\n //whether envelope should be linear or exponential curve\n this.isExponential = false;\n\n // oscillator or buffer source to clear on env complete\n // to save resources if/when it is retriggered\n this.sourceToClear = null;\n\n // set to true if attack is set, then false on release\n this.wasTriggered = false;\n\n\n // add to the soundArray so we can dispose of the env later\n p5sound.soundArray.push(this);\n };\n\n // this init function just smooths the starting value to zero and gives a start point for the timeline\n // - it was necessary to remove glitches at the beginning.\n p5.Envelope.prototype._init = function () {\n var now = p5sound.audiocontext.currentTime;\n var t = now;\n this.control.setTargetAtTime(0.00001, t, .001);\n //also, compute the correct time constants\n this._setRampAD(this.aTime, this.dTime);\n };\n\n /**\n * Reset the envelope with a series of time/value pairs.\n *\n * @method set\n * @for p5.Envelope\n * @param {Number} attackTime Time (in seconds) before level\n * reaches attackLevel\n * @param {Number} attackLevel Typically an amplitude between\n * 0.0 and 1.0\n * @param {Number} decayTime Time\n * @param {Number} decayLevel Amplitude (In a standard ADSR envelope,\n * decayLevel = sustainLevel)\n * @param {Number} releaseTime Release Time (in seconds)\n * @param {Number} releaseLevel Amplitude\n * @example\n *
\n * let attackTime;\n * let l1 = 0.7; // attack level 0.0 to 1.0\n * let t2 = 0.3; // decay time in seconds\n * let l2 = 0.1; // decay level 0.0 to 1.0\n * let l3 = 0.2; // release time in seconds\n *\n * let env, triOsc;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playSound);\n *\n * env = new p5.Envelope();\n * triOsc = new p5.Oscillator('triangle');\n * }\n *\n * function draw() {\n * background(220);\n * text('tap here to play', 5, 20);\n *\n * attackTime = map(mouseX, 0, width, 0.0, 1.0);\n * text('attack time: ' + attackTime, 5, height - 20);\n * }\n *\n * // mouseClick triggers envelope if over canvas\n * function playSound() {\n * env.set(attackTime, l1, t2, l2, l3);\n *\n * triOsc.start();\n * env.play(triOsc);\n * }\n *
\n *\n */\n p5.Envelope.prototype.set = function(t1, l1, t2, l2, t3, l3) {\n this.aTime = t1;\n this.aLevel = l1;\n this.dTime = t2 || 0;\n this.dLevel = l2 || 0;\n this.rTime = t3 || 0;\n this.rLevel = l3 || 0;\n\n // set time constants for ramp\n this._setRampAD(t1, t2);\n };\n\n /**\n * Set values like a traditional\n * \n * ADSR envelope\n * .\n *\n * @method setADSR\n * @for p5.Envelope\n * @param {Number} attackTime Time (in seconds before envelope\n * reaches Attack Level\n * @param {Number} [decayTime] Time (in seconds) before envelope\n * reaches Decay/Sustain Level\n * @param {Number} [susRatio] Ratio between attackLevel and releaseLevel, on a scale from 0 to 1,\n * where 1.0 = attackLevel, 0.0 = releaseLevel.\n * The susRatio determines the decayLevel and the level at which the\n * sustain portion of the envelope will sustain.\n * For example, if attackLevel is 0.4, releaseLevel is 0,\n * and susAmt is 0.5, the decayLevel would be 0.2. If attackLevel is\n * increased to 1.0 (using setRange),\n * then decayLevel would increase proportionally, to become 0.5.\n * @param {Number} [releaseTime] Time in seconds from now (defaults to 0)\n * @example\n *
\n * let attackLevel = 1.0;\n * let releaseLevel = 0;\n *\n * let attackTime = 0.001;\n * let decayTime = 0.2;\n * let susPercent = 0.2;\n * let releaseTime = 0.5;\n *\n * let env, triOsc;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playEnv);\n *\n * env = new p5.Envelope();\n * triOsc = new p5.Oscillator('triangle');\n * triOsc.amp(env);\n * triOsc.freq(220);\n * }\n *\n * function draw() {\n * background(220);\n * text('tap here to play', 5, 20);\n * attackTime = map(mouseX, 0, width, 0, 1.0);\n * text('attack time: ' + attackTime, 5, height - 40);\n * }\n *\n * function playEnv() {\n * triOsc.start();\n * env.setADSR(attackTime, decayTime, susPercent, releaseTime);\n * env.play();\n * }\n *
\n */\n p5.Envelope.prototype.setADSR = function(aTime, dTime, sPercent, rTime) {\n this.aTime = aTime;\n this.dTime = dTime || 0;\n\n // lerp\n this.sPercent = sPercent || 0;\n this.dLevel = typeof sPercent !== 'undefined' ? sPercent * (this.aLevel - this.rLevel) + this.rLevel : 0;\n\n this.rTime = rTime || 0;\n\n // also set time constants for ramp\n this._setRampAD(aTime, dTime);\n };\n\n /**\n * Set max (attackLevel) and min (releaseLevel) of envelope.\n *\n * @method setRange\n * @for p5.Envelope\n * @param {Number} aLevel attack level (defaults to 1)\n * @param {Number} rLevel release level (defaults to 0)\n * @example\n *
\n * let attackLevel = 1.0;\n * let releaseLevel = 0;\n *\n * let attackTime = 0.001;\n * let decayTime = 0.2;\n * let susPercent = 0.2;\n * let releaseTime = 0.5;\n *\n * let env, triOsc;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playEnv);\n *\n * env = new p5.Envelope();\n * triOsc = new p5.Oscillator('triangle');\n * triOsc.amp(env);\n * triOsc.freq(220);\n * }\n *\n * function draw() {\n * background(220);\n * text('tap here to play', 5, 20);\n * attackLevel = map(mouseY, height, 0, 0, 1.0);\n * text('attack level: ' + attackLevel, 5, height - 20);\n * }\n *\n * function playEnv() {\n * triOsc.start();\n * env.setRange(attackLevel, releaseLevel);\n * env.play();\n * }\n *
\n */\n p5.Envelope.prototype.setRange = function(aLevel, rLevel) {\n this.aLevel = aLevel || 1;\n this.rLevel = rLevel || 0;\n\n // not sure if this belongs here:\n\n // {Number} [dLevel] decay/sustain level (optional)\n // if (typeof(dLevel) !== 'undefined') {\n // this.dLevel = dLevel\n // } else if (this.sPercent) {\n // this.dLevel = this.sPercent ? this.sPercent * (this.aLevel - this.rLevel) + this.rLevel : 0;\n // }\n };\n\n // private (undocumented) method called when ADSR is set to set time constants for ramp\n //\n // Set the \n // time constants for simple exponential ramps.\n // The larger the time constant value, the slower the\n // transition will be.\n //\n // method _setRampAD\n // param {Number} attackTimeConstant attack time constant\n // param {Number} decayTimeConstant decay time constant\n //\n p5.Envelope.prototype._setRampAD = function(t1, t2) {\n this._rampAttackTime = this.checkExpInput(t1);\n this._rampDecayTime = this.checkExpInput(t2);\n\n var TCDenominator = 1.0;\n /// Aatish Bhatia's calculation for time constant for rise(to adjust 1/1-e calculation to any percentage)\n TCDenominator = Math.log(1.0 / this.checkExpInput(1.0 - this._rampHighPercentage));\n this._rampAttackTC = t1 / this.checkExpInput(TCDenominator);\n TCDenominator = Math.log(1.0 / this._rampLowPercentage);\n this._rampDecayTC = t2 / this.checkExpInput(TCDenominator);\n };\n\n // private method\n p5.Envelope.prototype.setRampPercentages = function(p1, p2) {\n //set the percentages that the simple exponential ramps go to\n this._rampHighPercentage = this.checkExpInput(p1);\n this._rampLowPercentage = this.checkExpInput(p2);\n var TCDenominator = 1.0;\n //now re-compute the time constants based on those percentages\n /// Aatish Bhatia's calculation for time constant for rise(to adjust 1/1-e calculation to any percentage)\n TCDenominator = Math.log(1.0 / this.checkExpInput(1.0 - this._rampHighPercentage));\n this._rampAttackTC = this._rampAttackTime / this.checkExpInput(TCDenominator);\n TCDenominator = Math.log(1.0 / this._rampLowPercentage);\n this._rampDecayTC = this._rampDecayTime / this.checkExpInput(TCDenominator);\n };\n\n\n /**\n * Assign a parameter to be controlled by this envelope.\n * If a p5.Sound object is given, then the p5.Envelope will control its\n * output gain. If multiple inputs are provided, the env will\n * control all of them.\n *\n * @method setInput\n * @for p5.Envelope\n * @param {Object} [...inputs] A p5.sound object or\n * Web Audio Param.\n */\n p5.Envelope.prototype.setInput = function() {\n for (var i = 0; iPlay tells the envelope to start acting on a given input.\n * If the input is a p5.sound object (i.e. AudioIn, Oscillator,\n * SoundFile), then Envelope will control its output volume.\n * Envelopes can also be used to control any \n * Web Audio Audio Param.

\n *\n * @method play\n * @for p5.Envelope\n * @param {Object} unit A p5.sound object or\n * Web Audio Param.\n * @param {Number} [startTime] time from now (in seconds) at which to play\n * @param {Number} [sustainTime] time to sustain before releasing the envelope\n * @example\n *
\n * let attackLevel = 1.0;\n * let releaseLevel = 0;\n *\n * let attackTime = 0.001;\n * let decayTime = 0.2;\n * let susPercent = 0.2;\n * let releaseTime = 0.5;\n *\n * let env, triOsc;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playEnv);\n *\n * env = new p5.Envelope();\n * triOsc = new p5.Oscillator('triangle');\n * triOsc.amp(env);\n * triOsc.freq(220);\n * triOsc.start();\n * }\n *\n * function draw() {\n * background(220);\n * text('tap here to play', 5, 20);\n * attackTime = map(mouseX, 0, width, 0, 1.0);\n * attackLevel = map(mouseY, height, 0, 0, 1.0);\n * text('attack time: ' + attackTime, 5, height - 40);\n * text('attack level: ' + attackLevel, 5, height - 20);\n * }\n *\n * function playEnv() {\n * // ensure that audio is enabled\n * userStartAudio();\n *\n * env.setADSR(attackTime, decayTime, susPercent, releaseTime);\n * env.setRange(attackLevel, releaseLevel);\n * env.play();\n * }\n *
\n */\n p5.Envelope.prototype.play = function(unit, secondsFromNow, susTime) {\n var tFromNow = secondsFromNow || 0;\n var susTime = susTime || 0;\n\n if (unit) {\n if (this.connection !== unit) {\n this.connect(unit);\n }\n }\n\n this.triggerAttack(unit, tFromNow);\n\n this.triggerRelease(unit, tFromNow + this.aTime + this.dTime + susTime);\n\n };\n\n /**\n * Trigger the Attack, and Decay portion of the Envelope.\n * Similar to holding down a key on a piano, but it will\n * hold the sustain level until you let go. Input can be\n * any p5.sound object, or a \n * Web Audio Param.\n *\n * @method triggerAttack\n * @for p5.Envelope\n * @param {Object} unit p5.sound Object or Web Audio Param\n * @param {Number} secondsFromNow time from now (in seconds)\n * @example\n *
\n * let attackTime = 0.001;\n * let decayTime = 0.2;\n * let susPercent = 0.3;\n * let releaseTime = 0.4;\n * let env, triOsc;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * background(220);\n * textAlign(CENTER);\n * textSize(10);\n * text('tap to triggerAttack', width/2, height/2);\n *\n * env = new p5.Envelope();\n * env.setADSR(attackTime, decayTime, susPercent, releaseTime);\n * env.setRange(1.0, 0.0);\n * triOsc = new p5.Oscillator('triangle');\n * triOsc.freq(220);\n *\n * cnv.mousePressed(envAttack);\n * }\n *\n * function envAttack() {\n * background(0, 255, 255);\n * text('release to release', width/2, height/2);\n *\n * // ensures audio is enabled. See also: `userStartAudio`\n * triOsc.start();\n *\n * env.triggerAttack(triOsc);\n * }\n *\n * function mouseReleased() {\n * background(220);\n * text('tap to triggerAttack', width/2, height/2);\n *\n * env.triggerRelease(triOsc);\n * }\n *
\n */\n p5.Envelope.prototype.triggerAttack = function(unit, secondsFromNow) {\n var now = p5sound.audiocontext.currentTime;\n var tFromNow = secondsFromNow || 0;\n var t = now + tFromNow;\n this.lastAttack = t;\n this.wasTriggered = true;\n\n if (unit) {\n if (this.connection !== unit) {\n this.connect(unit);\n }\n }\n\n // get and set value (with linear ramp) to anchor automation\n var valToSet = this.control.getValueAtTime(t);\n\n if (this.isExponential === true)\n {\n this.control.exponentialRampToValueAtTime(this.checkExpInput(valToSet), t);\n }\n else\n {\n this.control.linearRampToValueAtTime(valToSet, t);\n }\n\n // after each ramp completes, cancel scheduled values\n // (so they can be overridden in case env has been re-triggered)\n // then, set current value (with linearRamp to avoid click)\n // then, schedule the next automation...\n\n // attack\n t += this.aTime;\n if (this.isExponential === true)\n {\n this.control.exponentialRampToValueAtTime(this.checkExpInput(this.aLevel), t);\n valToSet = this.checkExpInput(this.control.getValueAtTime(t));\n this.control.cancelScheduledValues(t);\n this.control.exponentialRampToValueAtTime(valToSet, t);\n }\n else\n {\n this.control.linearRampToValueAtTime(this.aLevel, t);\n valToSet = this.control.getValueAtTime(t);\n this.control.cancelScheduledValues(t);\n this.control.linearRampToValueAtTime(valToSet, t);\n\n }\n\n // decay to decay level (if using ADSR, then decay level == sustain level)\n t += this.dTime;\n if (this.isExponential === true)\n {\n this.control.exponentialRampToValueAtTime(this.checkExpInput(this.dLevel), t);\n valToSet = this.checkExpInput(this.control.getValueAtTime(t));\n this.control.cancelScheduledValues(t);\n this.control.exponentialRampToValueAtTime(valToSet, t);\n }\n else\n {\n this.control.linearRampToValueAtTime(this.dLevel, t);\n valToSet = this.control.getValueAtTime(t);\n this.control.cancelScheduledValues(t);\n this.control.linearRampToValueAtTime(valToSet, t);\n }\n };\n\n /**\n * Trigger the Release of the Envelope. This is similar to releasing\n * the key on a piano and letting the sound fade according to the\n * release level and release time.\n *\n * @method triggerRelease\n * @for p5.Envelope\n * @param {Object} unit p5.sound Object or Web Audio Param\n * @param {Number} secondsFromNow time to trigger the release\n * @example\n *
\n * let attackTime = 0.001;\n * let decayTime = 0.2;\n * let susPercent = 0.3;\n * let releaseTime = 0.4;\n * let env, triOsc;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * background(220);\n * textAlign(CENTER);\n * textSize(10);\n * text('tap to triggerAttack', width/2, height/2);\n *\n * env = new p5.Envelope();\n * env.setADSR(attackTime, decayTime, susPercent, releaseTime);\n * env.setRange(1.0, 0.0);\n * triOsc = new p5.Oscillator('triangle');\n * triOsc.freq(220);\n *\n * cnv.mousePressed(envAttack);\n * }\n *\n * function envAttack() {\n * background(0, 255, 255);\n * text('release to release', width/2, height/2);\n *\n * // ensures audio is enabled. See also: `userStartAudio`\n * triOsc.start();\n *\n * env.triggerAttack(triOsc);\n * }\n *\n * function mouseReleased() {\n * background(220);\n * text('tap to triggerAttack', width/2, height/2);\n *\n * env.triggerRelease(triOsc);\n * }\n *
\n */\n p5.Envelope.prototype.triggerRelease = function(unit, secondsFromNow) {\n\n // only trigger a release if an attack was triggered\n if (!this.wasTriggered) {\n // this currently causes a bit of trouble:\n // if a later release has been scheduled (via the play function)\n // a new earlier release won't interrupt it, because\n // this.wasTriggered has already been set to false.\n // If we want new earlier releases to override, then we need to\n // keep track of the last release time, and if the new release time is\n // earlier, then use it.\n return;\n }\n\n var now = p5sound.audiocontext.currentTime;\n var tFromNow = secondsFromNow || 0;\n var t = now + tFromNow;\n\n if (unit) {\n if (this.connection !== unit) {\n this.connect(unit);\n }\n }\n\n // get and set value (with linear or exponential ramp) to anchor automation\n var valToSet = this.control.getValueAtTime(t);\n\n if (this.isExponential === true)\n {\n this.control.exponentialRampToValueAtTime(this.checkExpInput(valToSet), t);\n }\n else\n {\n this.control.linearRampToValueAtTime(valToSet, t);\n }\n\n // release\n t += this.rTime;\n\n if (this.isExponential === true)\n {\n this.control.exponentialRampToValueAtTime(this.checkExpInput(this.rLevel), t);\n valToSet = this.checkExpInput(this.control.getValueAtTime(t));\n this.control.cancelScheduledValues(t);\n this.control.exponentialRampToValueAtTime(valToSet, t);\n }\n else\n {\n this.control.linearRampToValueAtTime(this.rLevel, t);\n valToSet = this.control.getValueAtTime(t);\n this.control.cancelScheduledValues(t);\n this.control.linearRampToValueAtTime(valToSet, t);\n }\n\n this.wasTriggered = false;\n };\n\n /**\n * Exponentially ramp to a value using the first two\n * values from setADSR(attackTime, decayTime)\n * as \n * time constants for simple exponential ramps.\n * If the value is higher than current value, it uses attackTime,\n * while a decrease uses decayTime.\n *\n * @method ramp\n * @for p5.Envelope\n * @param {Object} unit p5.sound Object or Web Audio Param\n * @param {Number} secondsFromNow When to trigger the ramp\n * @param {Number} v Target value\n * @param {Number} [v2] Second target value (optional)\n * @example\n *
\n * let env, osc, amp;\n *\n * let attackTime = 0.001;\n * let decayTime = 0.2;\n * let attackLevel = 1;\n * let decayLevel = 0;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * fill(0,255,0);\n * noStroke();\n *\n * env = new p5.Envelope();\n * env.setADSR(attackTime, decayTime);\n * osc = new p5.Oscillator();\n * osc.amp(env);\n * amp = new p5.Amplitude();\n *\n * cnv.mousePressed(triggerRamp);\n * }\n *\n * function triggerRamp() {\n * // ensures audio is enabled. See also: `userStartAudio`\n * osc.start();\n *\n * env.ramp(osc, 0, attackLevel, decayLevel);\n * }\n *\n * function draw() {\n * background(20);\n * text('tap to play', 10, 20);\n * let h = map(amp.getLevel(), 0, 0.4, 0, height);;\n * rect(0, height, width, -h);\n * }\n *
\n */\n p5.Envelope.prototype.ramp = function(unit, secondsFromNow, v1, v2) {\n\n var now = p5sound.audiocontext.currentTime;\n var tFromNow = secondsFromNow || 0;\n var t = now + tFromNow;\n var destination1 = this.checkExpInput(v1);\n var destination2 = typeof v2 !== 'undefined' ? this.checkExpInput(v2) : undefined;\n\n // connect env to unit if not already connected\n if (unit) {\n if (this.connection !== unit) {\n this.connect(unit);\n }\n }\n\n //get current value\n var currentVal = this.checkExpInput(this.control.getValueAtTime(t));\n // this.control.cancelScheduledValues(t);\n\n //if it's going up\n if (destination1 > currentVal) {\n this.control.setTargetAtTime(destination1, t, this._rampAttackTC);\n t += this._rampAttackTime;\n }\n\n //if it's going down\n else if (destination1 < currentVal) {\n this.control.setTargetAtTime(destination1, t, this._rampDecayTC);\n t += this._rampDecayTime;\n }\n\n // Now the second part of envelope begins\n if (destination2 === undefined) return;\n\n //if it's going up\n if (destination2 > destination1) {\n this.control.setTargetAtTime(destination2, t, this._rampAttackTC);\n }\n\n //if it's going down\n else if (destination2 < destination1) {\n this.control.setTargetAtTime(destination2, t, this._rampDecayTC);\n }\n };\n\n\n p5.Envelope.prototype.connect = function(unit) {\n this.connection = unit;\n\n // assume we're talking about output gain\n // unless given a different audio param\n if (unit instanceof p5.Oscillator ||\n unit instanceof p5.SoundFile ||\n unit instanceof p5.AudioIn ||\n unit instanceof p5.Reverb ||\n unit instanceof p5.Noise ||\n unit instanceof p5.Filter ||\n unit instanceof p5.Delay\n ) {\n unit = unit.output.gain;\n }\n if (unit instanceof AudioParam) {\n //set the initial value\n unit.setValueAtTime(0, p5sound.audiocontext.currentTime);\n }\n if (unit instanceof p5.Signal) {\n unit.setValue(0);\n }\n this.output.connect(unit);\n };\n\n p5.Envelope.prototype.disconnect = function() {\n if (this.output) {\n this.output.disconnect();\n }\n };\n\n\n // Signal Math\n\n /**\n * Add a value to the p5.Oscillator's output amplitude,\n * and return the oscillator. Calling this method\n * again will override the initial add() with new values.\n *\n * @method add\n * @for p5.Envelope\n * @param {Number} number Constant number to add\n * @return {p5.Envelope} Envelope Returns this envelope\n * with scaled output\n */\n p5.Envelope.prototype.add = function(num) {\n var add = new Add(num);\n var thisChain = this.mathOps.length;\n var nextChain = this.output;\n return p5.prototype._mathChain(this, add, thisChain, nextChain, Add);\n };\n\n /**\n * Multiply the p5.Envelope's output amplitude\n * by a fixed value. Calling this method\n * again will override the initial mult() with new values.\n *\n * @method mult\n * @for p5.Envelope\n * @param {Number} number Constant number to multiply\n * @return {p5.Envelope} Envelope Returns this envelope\n * with scaled output\n */\n p5.Envelope.prototype.mult = function(num) {\n var mult = new Mult(num);\n var thisChain = this.mathOps.length;\n var nextChain = this.output;\n return p5.prototype._mathChain(this, mult, thisChain, nextChain, Mult);\n };\n\n /**\n * Scale this envelope's amplitude values to a given\n * range, and return the envelope. Calling this method\n * again will override the initial scale() with new values.\n *\n * @method scale\n * @for p5.Envelope\n * @param {Number} inMin input range minumum\n * @param {Number} inMax input range maximum\n * @param {Number} outMin input range minumum\n * @param {Number} outMax input range maximum\n * @return {p5.Envelope} Envelope Returns this envelope\n * with scaled output\n */\n p5.Envelope.prototype.scale = function(inMin, inMax, outMin, outMax) {\n var scale = new Scale(inMin, inMax, outMin, outMax);\n var thisChain = this.mathOps.length;\n var nextChain = this.output;\n return p5.prototype._mathChain(this, scale, thisChain, nextChain, Scale);\n };\n\n\n // get rid of the oscillator\n p5.Envelope.prototype.dispose = function() {\n // remove reference from soundArray\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n\n this.disconnect();\n if (this.control) {\n this.control.dispose();\n this.control = null;\n }\n for (var i = 1; i < this.mathOps.length; i++) {\n this.mathOps[i].dispose();\n }\n };\n\n // Different name for backwards compatibility, replicates p5.Envelope class\n p5.Env = function(t1, l1, t2, l2, t3, l3) {\n console.warn('WARNING: p5.Env is now deprecated and may be removed in future versions. ' +\n 'Please use the new p5.Envelope instead.');\n p5.Envelope.call(this, t1, l1, t2, l2, t3, l3);\n };\n p5.Env.prototype = Object.create(p5.Envelope.prototype);\n\n});\n","'use strict';\n\ndefine(function (require) {\n\n var p5sound = require('master');\n require('oscillator');\n\n /**\n * Creates a Pulse object, an oscillator that implements\n * Pulse Width Modulation.\n * The pulse is created with two oscillators.\n * Accepts a parameter for frequency, and to set the\n * width between the pulses. See \n * p5.Oscillator for a full list of methods.\n *\n * @class p5.Pulse\n * @extends p5.Oscillator\n * @constructor\n * @param {Number} [freq] Frequency in oscillations per second (Hz)\n * @param {Number} [w] Width between the pulses (0 to 1.0,\n * defaults to 0)\n * @example\n *
\n * let pulse;\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(startPulse);\n * background(220);\n *\n * pulse = new p5.Pulse();\n * pulse.amp(0.5);\n * pulse.freq(220);\n * }\n * function startPulse() {\n * pulse.start();\n * pulse.amp(0.5, 0.02);\n * }\n * function mouseReleased() {\n * pulse.amp(0, 0.2);\n * }\n * function draw() {\n * background(220);\n * text('tap to play', 5, 20, width - 20);\n * let w = map(mouseX, 0, width, 0, 1);\n * w = constrain(w, 0, 1);\n * pulse.width(w);\n * text('pulse width: ' + w, 5, height - 20);\n * }\n *
\n */\n p5.Pulse = function(freq, w) {\n p5.Oscillator.call(this, freq, 'sawtooth');\n\n // width of PWM, should be betw 0 to 1.0\n this.w = w || 0;\n\n // create a second oscillator with inverse frequency\n this.osc2 = new p5.SawOsc(freq);\n\n // create a delay node\n this.dNode = p5sound.audiocontext.createDelay();\n\n // dc offset\n this.dcOffset = createDCOffset();\n this.dcGain = p5sound.audiocontext.createGain();\n this.dcOffset.connect(this.dcGain);\n this.dcGain.connect(this.output);\n // set delay time based on PWM width\n this.f = freq || 440;\n var mW = this.w / this.oscillator.frequency.value;\n this.dNode.delayTime.value = mW;\n this.dcGain.gain.value = 1.7*(0.5-this.w);\n\n // disconnect osc2 and connect it to delay, which is connected to output\n this.osc2.disconnect();\n this.osc2.panner.disconnect();\n this.osc2.amp(-1); // inverted amplitude\n this.osc2.output.connect(this.dNode);\n this.dNode.connect(this.output);\n\n this.output.gain.value = 1;\n this.output.connect(this.panner);\n };\n\n p5.Pulse.prototype = Object.create(p5.Oscillator.prototype);\n\n /**\n * Set the width of a Pulse object (an oscillator that implements\n * Pulse Width Modulation).\n *\n * @method width\n * @param {Number} [width] Width between the pulses (0 to 1.0,\n * defaults to 0)\n */\n p5.Pulse.prototype.width = function(w) {\n if (typeof w === 'number') {\n if (w <= 1.0 && w >= 0.0) {\n this.w = w;\n // set delay time based on PWM width\n\n // var mW = map(this.w, 0, 1.0, 0, 1/this.f);\n var mW = this.w / this.oscillator.frequency.value;\n this.dNode.delayTime.value = mW;\n }\n\n this.dcGain.gain.value = 1.7*(0.5-this.w);\n } else {\n w.connect(this.dNode.delayTime);\n var sig = new p5.SignalAdd(-0.5);\n sig.setInput(w);\n sig = sig.mult(-1);\n sig = sig.mult(1.7);\n sig.connect(this.dcGain.gain);\n }\n };\n\n p5.Pulse.prototype.start = function(f, time) {\n var now = p5sound.audiocontext.currentTime;\n var t = time || 0;\n if (!this.started) {\n var freq = f || this.f;\n var type = this.oscillator.type;\n this.oscillator = p5sound.audiocontext.createOscillator();\n this.oscillator.frequency.setValueAtTime(freq, now);\n this.oscillator.type = type;\n this.oscillator.connect(this.output);\n this.oscillator.start(t + now);\n\n // set up osc2\n this.osc2.oscillator = p5sound.audiocontext.createOscillator();\n this.osc2.oscillator.frequency.setValueAtTime(freq, t + now);\n this.osc2.oscillator.type = type;\n this.osc2.oscillator.connect(this.osc2.output);\n this.osc2.start(t + now);\n this.freqNode = [this.oscillator.frequency, this.osc2.oscillator.frequency];\n\n // start dcOffset, too\n this.dcOffset = createDCOffset();\n this.dcOffset.connect(this.dcGain);\n this.dcOffset.start(t + now);\n\n // if LFO connections depend on these oscillators\n if (this.mods !== undefined && this.mods.frequency !== undefined) {\n this.mods.frequency.connect(this.freqNode[0]);\n this.mods.frequency.connect(this.freqNode[1]);\n }\n this.started = true;\n this.osc2.started = true;\n }\n };\n\n p5.Pulse.prototype.stop = function(time) {\n if (this.started) {\n var t = time || 0;\n var now = p5sound.audiocontext.currentTime;\n this.oscillator.stop(t + now);\n if (this.osc2.oscillator) {\n this.osc2.oscillator.stop(t + now);\n }\n this.dcOffset.stop(t + now);\n this.started = false;\n this.osc2.started = false;\n }\n };\n\n p5.Pulse.prototype.freq = function(val, rampTime, tFromNow) {\n if (typeof val === 'number') {\n this.f = val;\n var now = p5sound.audiocontext.currentTime;\n var rampTime = rampTime || 0;\n var tFromNow = tFromNow || 0;\n var currentFreq = this.oscillator.frequency.value;\n this.oscillator.frequency.cancelScheduledValues(now);\n this.oscillator.frequency.setValueAtTime(currentFreq, now + tFromNow);\n this.oscillator.frequency.exponentialRampToValueAtTime(val, tFromNow + rampTime + now);\n this.osc2.oscillator.frequency.cancelScheduledValues(now);\n this.osc2.oscillator.frequency.setValueAtTime(currentFreq, now + tFromNow);\n this.osc2.oscillator.frequency.exponentialRampToValueAtTime(val, tFromNow + rampTime + now);\n\n if (this.freqMod) {\n this.freqMod.output.disconnect();\n this.freqMod = null;\n }\n\n } else if (val.output) {\n val.output.disconnect();\n val.output.connect(this.oscillator.frequency);\n val.output.connect(this.osc2.oscillator.frequency);\n this.freqMod = val;\n }\n };\n\n // inspiration: http://webaudiodemos.appspot.com/oscilloscope/\n function createDCOffset() {\n var ac = p5sound.audiocontext;\n var buffer=ac.createBuffer(1,2048,ac.sampleRate);\n var data = buffer.getChannelData(0);\n for (var i=0; i<2048; i++)\n data[i]=1.0;\n var bufferSource=ac.createBufferSource();\n bufferSource.buffer=buffer;\n bufferSource.loop=true;\n return bufferSource;\n }\n\n});\n","'use strict';\n\ndefine(function (require) {\n var p5sound = require('master');\n\n /**\n * Noise is a type of oscillator that generates a buffer with random values.\n *\n * @class p5.Noise\n * @extends p5.Oscillator\n * @constructor\n * @param {String} type Type of noise can be 'white' (default),\n * 'brown' or 'pink'.\n */\n p5.Noise = function(type) {\n var assignType;\n p5.Oscillator.call(this);\n delete this.f;\n delete this.freq;\n delete this.oscillator;\n\n if (type === 'brown') {\n assignType = _brownNoise;\n } else if (type === 'pink') {\n assignType = _pinkNoise;\n } else {\n assignType = _whiteNoise;\n }\n this.buffer = assignType;\n };\n\n p5.Noise.prototype = Object.create(p5.Oscillator.prototype);\n\n // generate noise buffers\n var _whiteNoise = (function() {\n var bufferSize = 2 * p5sound.audiocontext.sampleRate;\n var whiteBuffer = p5sound.audiocontext.createBuffer(1, bufferSize, p5sound.audiocontext.sampleRate);\n var noiseData = whiteBuffer.getChannelData(0);\n for (var i = 0; i < bufferSize; i++) {\n noiseData[i] = Math.random() * 2 - 1;\n }\n whiteBuffer.type = 'white';\n return whiteBuffer;\n })();\n\n var _pinkNoise = (function() {\n var bufferSize = 2 * p5sound.audiocontext.sampleRate;\n var pinkBuffer = p5sound.audiocontext.createBuffer(1, bufferSize, p5sound.audiocontext.sampleRate);\n var noiseData = pinkBuffer.getChannelData(0);\n var b0, b1, b2, b3, b4, b5, b6;\n b0 = b1 = b2 = b3 = b4 = b5 = b6 = 0.0;\n for (var i = 0; i < bufferSize; i++) {\n var white = Math.random() * 2 - 1;\n b0 = 0.99886 * b0 + white * 0.0555179;\n b1 = 0.99332 * b1 + white * 0.0750759;\n b2 = 0.96900 * b2 + white * 0.1538520;\n b3 = 0.86650 * b3 + white * 0.3104856;\n b4 = 0.55000 * b4 + white * 0.5329522;\n b5 = -0.7616 * b5 - white * 0.0168980;\n noiseData[i] = b0 + b1 + b2 + b3 + b4 + b5 + b6 + white * 0.5362;\n noiseData[i] *= 0.11; // (roughly) compensate for gain\n b6 = white * 0.115926;\n }\n pinkBuffer.type = 'pink';\n return pinkBuffer;\n })();\n\n var _brownNoise = (function() {\n var bufferSize = 2 * p5sound.audiocontext.sampleRate;\n var brownBuffer = p5sound.audiocontext.createBuffer(1, bufferSize, p5sound.audiocontext.sampleRate);\n var noiseData = brownBuffer.getChannelData(0);\n var lastOut = 0.0;\n for (var i = 0; i< bufferSize; i++) {\n var white = Math.random() * 2 - 1;\n noiseData[i] = (lastOut + 0.02*white) / 1.02;\n lastOut = noiseData[i];\n noiseData[i] *= 3.5;\n }\n brownBuffer.type = 'brown';\n return brownBuffer;\n })();\n\n /**\n * Set type of noise to 'white', 'pink' or 'brown'.\n * White is the default.\n *\n * @method setType\n * @param {String} [type] 'white', 'pink' or 'brown'\n */\n p5.Noise.prototype.setType = function(type) {\n switch(type) {\n case 'white':\n this.buffer = _whiteNoise;\n break;\n case 'pink':\n this.buffer = _pinkNoise;\n break;\n case 'brown':\n this.buffer = _brownNoise;\n break;\n default:\n this.buffer = _whiteNoise;\n }\n if (this.started) {\n var now = p5sound.audiocontext.currentTime;\n this.stop(now);\n this.start(now+.01);\n }\n };\n\n p5.Noise.prototype.getType = function() {\n return this.buffer.type;\n };\n\n p5.Noise.prototype.start = function() {\n if (this.started) {\n this.stop();\n }\n this.noise = p5sound.audiocontext.createBufferSource();\n this.noise.buffer = this.buffer;\n this.noise.loop = true;\n this.noise.connect(this.output);\n var now = p5sound.audiocontext.currentTime;\n this.noise.start(now);\n this.started = true;\n };\n\n p5.Noise.prototype.stop = function() {\n var now = p5sound.audiocontext.currentTime;\n if (this.noise) {\n this.noise.stop(now);\n this.started = false;\n }\n };\n\n p5.Noise.prototype.dispose = function() {\n var now = p5sound.audiocontext.currentTime;\n\n // remove reference from soundArray\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n\n if (this.noise) {\n this.noise.disconnect();\n this.stop(now);\n }\n if (this.output) {\n this.output.disconnect();\n }\n if (this.panner) {\n this.panner.disconnect();\n }\n this.output = null;\n this.panner = null;\n this.buffer = null;\n this.noise = null;\n };\n\n});\n","'use strict';\n\ndefine(function (require) {\n var p5sound = require('master');\n\n // an array of input sources\n p5sound.inputSources = [];\n\n /**\n *

Get audio from an input, i.e. your computer's microphone.

\n *\n *

Turn the mic on/off with the start() and stop() methods. When the mic\n * is on, its volume can be measured with getLevel or by connecting an\n * FFT object.

\n *\n *

If you want to hear the AudioIn, use the .connect() method.\n * AudioIn does not connect to p5.sound output by default to prevent\n * feedback.

\n *\n *

Note: This uses the getUserMedia/\n * Stream API, which is not supported by certain browsers. Access in Chrome browser\n * is limited to localhost and https, but access over http may be limited.

\n *\n * @class p5.AudioIn\n * @constructor\n * @param {Function} [errorCallback] A function to call if there is an error\n * accessing the AudioIn. For example,\n * Safari and iOS devices do not\n * currently allow microphone access.\n * @example\n *
\n * let mic;\n *\n * function setup(){\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(userStartAudio);\n * textAlign(CENTER);\n * mic = new p5.AudioIn();\n * mic.start();\n * }\n *\n * function draw(){\n * background(0);\n * fill(255);\n * text('tap to start', width/2, 20);\n *\n * micLevel = mic.getLevel();\n * let y = height - micLevel * height;\n * ellipse(width/2, y, 10, 10);\n * }\n *
\n */\n p5.AudioIn = function(errorCallback) {\n // set up audio input\n /**\n * @property {GainNode} input\n */\n this.input = p5sound.audiocontext.createGain();\n /**\n * @property {GainNode} output\n */\n this.output = p5sound.audiocontext.createGain();\n\n /**\n * @property {MediaStream|null} stream\n */\n this.stream = null;\n /**\n * @property {MediaStreamAudioSourceNode|null} mediaStream\n */\n this.mediaStream = null;\n /**\n * @property {Number|null} currentSource\n */\n this.currentSource = null;\n\n /**\n * Client must allow browser to access their microphone / audioin source.\n * Default: false. Will become true when the client enables access.\n *\n * @property {Boolean} enabled\n */\n this.enabled = false;\n\n /**\n * Input amplitude, connect to it by default but not to master out\n *\n * @property {p5.Amplitude} amplitude\n */\n this.amplitude = new p5.Amplitude();\n this.output.connect(this.amplitude.input);\n\n if (!window.MediaStreamTrack || !window.navigator.mediaDevices || !window.navigator.mediaDevices.getUserMedia) {\n errorCallback ? errorCallback() : window.alert('This browser does not support MediaStreamTrack and mediaDevices');\n }\n\n // add to soundArray so we can dispose on close\n p5sound.soundArray.push(this);\n };\n\n /**\n * Start processing audio input. This enables the use of other\n * AudioIn methods like getLevel(). Note that by default, AudioIn\n * is not connected to p5.sound's output. So you won't hear\n * anything unless you use the connect() method.
\n *\n * Certain browsers limit access to the user's microphone. For example,\n * Chrome only allows access from localhost and over https. For this reason,\n * you may want to include an errorCallback—a function that is called in case\n * the browser won't provide mic access.\n *\n * @method start\n * @for p5.AudioIn\n * @param {Function} [successCallback] Name of a function to call on\n * success.\n * @param {Function} [errorCallback] Name of a function to call if\n * there was an error. For example,\n * some browsers do not support\n * getUserMedia.\n */\n p5.AudioIn.prototype.start = function(successCallback, errorCallback) {\n var self = this;\n\n if (this.stream) {\n this.stop();\n }\n\n // set the audio source\n var audioSource = p5sound.inputSources[self.currentSource];\n var constraints = {\n audio: {\n sampleRate: p5sound.audiocontext.sampleRate,\n echoCancellation: false\n }\n };\n\n // if developers determine which source to use\n if (p5sound.inputSources[this.currentSource]) {\n constraints.audio.deviceId = audioSource.deviceId;\n }\n\n window.navigator.mediaDevices.getUserMedia( constraints )\n .then( function(stream) {\n self.stream = stream;\n self.enabled = true;\n // Wrap a MediaStreamSourceNode around the live input\n self.mediaStream = p5sound.audiocontext.createMediaStreamSource(stream);\n self.mediaStream.connect(self.output);\n // only send to the Amplitude reader, so we can see it but not hear it.\n self.amplitude.setInput(self.output);\n if (successCallback) successCallback();\n })\n .catch( function(err) {\n if (errorCallback) errorCallback(err);\n else console.error(err);\n });\n };\n\n /**\n * Turn the AudioIn off. If the AudioIn is stopped, it cannot getLevel().\n * If re-starting, the user may be prompted for permission access.\n *\n * @method stop\n * @for p5.AudioIn\n */\n p5.AudioIn.prototype.stop = function() {\n if (this.stream) {\n this.stream.getTracks().forEach(function(track) {\n track.stop();\n });\n\n this.mediaStream.disconnect();\n\n delete this.mediaStream;\n delete this.stream;\n }\n };\n\n /**\n * Connect to an audio unit. If no parameter is provided, will\n * connect to the master output (i.e. your speakers).
\n *\n * @method connect\n * @for p5.AudioIn\n * @param {Object} [unit] An object that accepts audio input,\n * such as an FFT\n */\n p5.AudioIn.prototype.connect = function(unit) {\n if (unit) {\n if (unit.hasOwnProperty('input')) {\n this.output.connect(unit.input);\n }\n else if (unit.hasOwnProperty('analyser')) {\n this.output.connect(unit.analyser);\n }\n else {\n this.output.connect(unit);\n }\n }\n else {\n this.output.connect(p5sound.input);\n }\n };\n\n /**\n * Disconnect the AudioIn from all audio units. For example, if\n * connect() had been called, disconnect() will stop sending\n * signal to your speakers.
\n *\n * @method disconnect\n * @for p5.AudioIn\n */\n p5.AudioIn.prototype.disconnect = function() {\n if (this.output) {\n this.output.disconnect();\n // stay connected to amplitude even if not outputting to p5\n this.output.connect(this.amplitude.input);\n }\n };\n\n /**\n * Read the Amplitude (volume level) of an AudioIn. The AudioIn\n * class contains its own instance of the Amplitude class to help\n * make it easy to get a microphone's volume level. Accepts an\n * optional smoothing value (0.0 < 1.0). NOTE: AudioIn must\n * .start() before using .getLevel().
\n *\n * @method getLevel\n * @for p5.AudioIn\n * @param {Number} [smoothing] Smoothing is 0.0 by default.\n * Smooths values based on previous values.\n * @return {Number} Volume level (between 0.0 and 1.0)\n */\n p5.AudioIn.prototype.getLevel = function(smoothing) {\n if (smoothing) {\n this.amplitude.smoothing = smoothing;\n }\n return this.amplitude.getLevel();\n };\n\n /**\n * Set amplitude (volume) of a mic input between 0 and 1.0.
\n *\n * @method amp\n * @for p5.AudioIn\n * @param {Number} vol between 0 and 1.0\n * @param {Number} [time] ramp time (optional)\n */\n p5.AudioIn.prototype.amp = function(vol, t) {\n if (t) {\n var rampTime = t || 0;\n var currentVol = this.output.gain.value;\n this.output.gain.cancelScheduledValues(p5sound.audiocontext.currentTime);\n this.output.gain.setValueAtTime(currentVol, p5sound.audiocontext.currentTime);\n this.output.gain.linearRampToValueAtTime(vol, rampTime + p5sound.audiocontext.currentTime);\n } else {\n this.output.gain.cancelScheduledValues(p5sound.audiocontext.currentTime);\n this.output.gain.setValueAtTime(vol, p5sound.audiocontext.currentTime);\n }\n };\n\n /**\n * Returns a list of available input sources. This is a wrapper\n * for and it returns a Promise.\n *\n * @method getSources\n * @for p5.AudioIn\n * @param {Function} [successCallback] This callback function handles the sources when they\n * have been enumerated. The callback function\n * receives the deviceList array as its only argument\n * @param {Function} [errorCallback] This optional callback receives the error\n * message as its argument.\n * @returns {Promise} Returns a Promise that can be used in place of the callbacks, similar\n * to the enumerateDevices() method\n * @example\n *
\n * let audioIn;\n *\n * function setup(){\n * text('getting sources...', 0, 20);\n * audioIn = new p5.AudioIn();\n * audioIn.getSources(gotSources);\n * }\n *\n * function gotSources(deviceList) {\n * if (deviceList.length > 0) {\n * //set the source to the first item in the deviceList array\n * audioIn.setSource(0);\n * let currentSource = deviceList[audioIn.currentSource];\n * text('set source to: ' + currentSource.deviceId, 5, 20, width);\n * }\n * }\n *
\n */\n p5.AudioIn.prototype.getSources = function (onSuccess, onError) {\n return new Promise( function(resolve, reject) {\n window.navigator.mediaDevices.enumerateDevices()\n .then( function(devices) {\n p5sound.inputSources = devices.filter(function(device) {\n return device.kind === 'audioinput';\n });\n resolve(p5sound.inputSources);\n if (onSuccess) {\n onSuccess(p5sound.inputSources);\n }\n })\n .catch( function(error) {\n reject(error);\n if (onError) {\n onError(error);\n } else {\n console.error('This browser does not support MediaStreamTrack.getSources()');\n }\n });\n });\n };\n\n /**\n * Set the input source. Accepts a number representing a\n * position in the array returned by getSources().\n * This is only available in browsers that support\n * navigator.mediaDevices.enumerateDevices().
\n *\n * @method setSource\n * @for p5.AudioIn\n * @param {number} num position of input source in the array\n * @example\n *
\n * let audioIn;\n *\n * function setup(){\n * text('getting sources...', 0, 20);\n * audioIn = new p5.AudioIn();\n * audioIn.getSources(gotSources);\n * }\n *\n * function gotSources(deviceList) {\n * if (deviceList.length > 0) {\n * //set the source to the first item in the deviceList array\n * audioIn.setSource(0);\n * let currentSource = deviceList[audioIn.currentSource];\n * text('set source to: ' + currentSource.deviceId, 5, 20, width);\n * }\n * }\n *
\n */\n p5.AudioIn.prototype.setSource = function(num) {\n if (p5sound.inputSources.length > 0 && num < p5sound.inputSources.length) {\n // set the current source\n this.currentSource = num;\n console.log('set source to ', p5sound.inputSources[this.currentSource]);\n } else {\n console.log('unable to set input source');\n }\n\n // restart stream if currently active\n if (this.stream && this.stream.active) {\n this.start();\n }\n };\n\n // private method\n p5.AudioIn.prototype.dispose = function() {\n // remove reference from soundArray\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n\n this.stop();\n\n if (this.output) {\n this.output.disconnect();\n }\n if (this.amplitude) {\n this.amplitude.disconnect();\n }\n delete this.amplitude;\n delete this.output;\n };\n\n});\n","define([\"Tone/core/Tone\", \"Tone/signal/Signal\", \"Tone/signal/Expr\", \n\t\"Tone/signal/EqualPowerGain\", \"Tone/core/Gain\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Tone.Crossfade provides equal power fading between two inputs. \n\t * More on crossfading technique [here](https://en.wikipedia.org/wiki/Fade_(audio_engineering)#Crossfading).\n\t *\n\t * @constructor\n\t * @extends {Tone}\n\t * @param {NormalRange} [initialFade=0.5]\n\t * @example\n\t * var crossFade = new Tone.CrossFade(0.5);\n\t * //connect effect A to crossfade from\n\t * //effect output 0 to crossfade input 0\n\t * effectA.connect(crossFade, 0, 0);\n\t * //connect effect B to crossfade from\n\t * //effect output 0 to crossfade input 1\n\t * effectB.connect(crossFade, 0, 1);\n\t * crossFade.fade.value = 0;\n\t * // ^ only effectA is output\n\t * crossFade.fade.value = 1;\n\t * // ^ only effectB is output\n\t * crossFade.fade.value = 0.5;\n\t * // ^ the two signals are mixed equally. \n\t */\t\t\n\tTone.CrossFade = function(initialFade){\n\n\t\tthis.createInsOuts(2, 1);\n\n\t\t/**\n\t\t * Alias for input[0]. \n\t\t * @type {Tone.Gain}\n\t\t */\n\t\tthis.a = this.input[0] = new Tone.Gain();\n\n\t\t/**\n\t\t * Alias for input[1]. \n\t\t * @type {Tone.Gain}\n\t\t */\n\t\tthis.b = this.input[1] = new Tone.Gain();\n\n\t\t/**\n\t\t * \tThe mix between the two inputs. A fade value of 0\n\t\t * \twill output 100% input[0] and \n\t\t * \ta value of 1 will output 100% input[1]. \n\t\t * @type {NormalRange}\n\t\t * @signal\n\t\t */\n\t\tthis.fade = new Tone.Signal(this.defaultArg(initialFade, 0.5), Tone.Type.NormalRange);\n\n\t\t/**\n\t\t * equal power gain cross fade\n\t\t * @private\n\t\t * @type {Tone.EqualPowerGain}\n\t\t */\n\t\tthis._equalPowerA = new Tone.EqualPowerGain();\n\n\t\t/**\n\t\t * equal power gain cross fade\n\t\t * @private\n\t\t * @type {Tone.EqualPowerGain}\n\t\t */\n\t\tthis._equalPowerB = new Tone.EqualPowerGain();\n\t\t\n\t\t/**\n\t\t * invert the incoming signal\n\t\t * @private\n\t\t * @type {Tone}\n\t\t */\n\t\tthis._invert = new Tone.Expr(\"1 - $0\");\n\n\t\t//connections\n\t\tthis.a.connect(this.output);\n\t\tthis.b.connect(this.output);\n\t\tthis.fade.chain(this._equalPowerB, this.b.gain);\n\t\tthis.fade.chain(this._invert, this._equalPowerA, this.a.gain);\n\t\tthis._readOnly(\"fade\");\n\t};\n\n\tTone.extend(Tone.CrossFade);\n\n\t/**\n\t * clean up\n\t * @returns {Tone.CrossFade} this\n\t */\n\tTone.CrossFade.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._writable(\"fade\");\n\t\tthis._equalPowerA.dispose();\n\t\tthis._equalPowerA = null;\n\t\tthis._equalPowerB.dispose();\n\t\tthis._equalPowerB = null;\n\t\tthis.fade.dispose();\n\t\tthis.fade = null;\n\t\tthis._invert.dispose();\n\t\tthis._invert = null;\n\t\tthis.a.dispose();\n\t\tthis.a = null;\n\t\tthis.b.dispose();\n\t\tthis.b = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.CrossFade;\n});\n","define([\"Tone/core/Tone\", \"Tone/signal/Add\", \"Tone/signal/Subtract\", \"Tone/signal/Multiply\", \n\t\"Tone/signal/GreaterThan\", \"Tone/signal/GreaterThanZero\", \"Tone/signal/Abs\", \"Tone/signal/Negate\", \n\t\"Tone/signal/Modulo\", \"Tone/signal/Pow\", \"Tone/signal/AudioToGain\"], \n\tfunction(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Evaluate an expression at audio rate.

\n\t * Parsing code modified from https://code.google.com/p/tapdigit/\n\t * Copyright 2011 2012 Ariya Hidayat, New BSD License\n\t *\n\t * @extends {Tone.SignalBase}\n\t * @constructor\n\t * @param {string} expr the expression to generate\n\t * @example\n\t * //adds the signals from input[0] and input[1].\n\t * var expr = new Tone.Expr(\"$0 + $1\");\n\t */\n\tTone.Expr = function(){\n\n\t\tvar expr = this._replacements(Array.prototype.slice.call(arguments));\n\t\tvar inputCount = this._parseInputs(expr);\n\n\t\t/**\n\t\t * hold onto all of the nodes for disposal\n\t\t * @type {Array}\n\t\t * @private\n\t\t */\n\t\tthis._nodes = [];\n\n\t\t/**\n\t\t * The inputs. The length is determined by the expression. \n\t\t * @type {Array}\n\t\t */\n\t\tthis.input = new Array(inputCount);\n\n\t\t//create a gain for each input\n\t\tfor (var i = 0; i < inputCount; i++){\n\t\t\tthis.input[i] = this.context.createGain();\n\t\t}\n\n\t\t//parse the syntax tree\n\t\tvar tree = this._parseTree(expr);\n\t\t//evaluate the results\n\t\tvar result;\n\t\ttry {\n\t\t\tresult = this._eval(tree);\n\t\t} catch (e){\n\t\t\tthis._disposeNodes();\n\t\t\tthrow new Error(\"Tone.Expr: Could evaluate expression: \"+expr);\n\t\t}\n\n\t\t/**\n\t\t * The output node is the result of the expression\n\t\t * @type {Tone}\n\t\t */\n\t\tthis.output = result;\n\t};\n\n\tTone.extend(Tone.Expr, Tone.SignalBase);\n\n\t//some helpers to cut down the amount of code\n\tfunction applyBinary(Constructor, args, self){\n\t\tvar op = new Constructor();\n\t\tself._eval(args[0]).connect(op, 0, 0);\n\t\tself._eval(args[1]).connect(op, 0, 1);\n\t\treturn op;\n\t}\n\tfunction applyUnary(Constructor, args, self){\n\t\tvar op = new Constructor();\n\t\tself._eval(args[0]).connect(op, 0, 0);\n\t\treturn op;\n\t}\n\tfunction getNumber(arg){\n\t\treturn arg ? parseFloat(arg) : undefined;\n\t}\n\tfunction literalNumber(arg){\n\t\treturn arg && arg.args ? parseFloat(arg.args) : undefined;\n\t}\n\n\t/*\n\t * the Expressions that Tone.Expr can parse.\n\t *\n\t * each expression belongs to a group and contains a regexp \n\t * for selecting the operator as well as that operators method\n\t * \n\t * @type {Object}\n\t * @private\n\t */\n\tTone.Expr._Expressions = {\n\t\t//values\n\t\t\"value\" : {\n\t\t\t\"signal\" : {\n\t\t\t\tregexp : /^\\d+\\.\\d+|^\\d+/,\n\t\t\t\tmethod : function(arg){\n\t\t\t\t\tvar sig = new Tone.Signal(getNumber(arg));\n\t\t\t\t\treturn sig;\n\t\t\t\t}\n\t\t\t},\n\t\t\t\"input\" : {\n\t\t\t\tregexp : /^\\$\\d/,\n\t\t\t\tmethod : function(arg, self){\n\t\t\t\t\treturn self.input[getNumber(arg.substr(1))];\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\t//syntactic glue\n\t\t\"glue\" : {\n\t\t\t\"(\" : {\n\t\t\t\tregexp : /^\\(/,\n\t\t\t},\n\t\t\t\")\" : {\n\t\t\t\tregexp : /^\\)/,\n\t\t\t},\n\t\t\t\",\" : {\n\t\t\t\tregexp : /^,/,\n\t\t\t}\n\t\t},\n\t\t//functions\n\t\t\"func\" : {\n\t\t\t\"abs\" : {\n\t\t\t\tregexp : /^abs/,\n\t\t\t\tmethod : applyUnary.bind(this, Tone.Abs)\n\t\t\t},\n\t\t\t\"mod\" : {\n\t\t\t\tregexp : /^mod/,\n\t\t\t\tmethod : function(args, self){\n\t\t\t\t\tvar modulus = literalNumber(args[1]);\n\t\t\t\t\tvar op = new Tone.Modulo(modulus);\n\t\t\t\t\tself._eval(args[0]).connect(op);\n\t\t\t\t\treturn op;\n\t\t\t\t}\n\t\t\t},\n\t\t\t\"pow\" : {\n\t\t\t\tregexp : /^pow/,\n\t\t\t\tmethod : function(args, self){\n\t\t\t\t\tvar exp = literalNumber(args[1]);\n\t\t\t\t\tvar op = new Tone.Pow(exp);\n\t\t\t\t\tself._eval(args[0]).connect(op);\n\t\t\t\t\treturn op;\n\t\t\t\t}\n\t\t\t},\n\t\t\t\"a2g\" : {\n\t\t\t\tregexp : /^a2g/,\n\t\t\t\tmethod : function(args, self){\n\t\t\t\t\tvar op = new Tone.AudioToGain();\n\t\t\t\t\tself._eval(args[0]).connect(op);\n\t\t\t\t\treturn op;\n\t\t\t\t}\n\t\t\t},\n\t\t},\n\t\t//binary expressions\n\t\t\"binary\" : {\n\t\t\t\"+\" : {\n\t\t\t\tregexp : /^\\+/,\n\t\t\t\tprecedence : 1,\n\t\t\t\tmethod : applyBinary.bind(this, Tone.Add)\n\t\t\t},\n\t\t\t\"-\" : {\n\t\t\t\tregexp : /^\\-/,\n\t\t\t\tprecedence : 1,\n\t\t\t\tmethod : function(args, self){\n\t\t\t\t\t//both unary and binary op\n\t\t\t\t\tif (args.length === 1){\n\t\t\t\t\t\treturn applyUnary(Tone.Negate, args, self);\n\t\t\t\t\t} else {\n\t\t\t\t\t\treturn applyBinary(Tone.Subtract, args, self);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t},\n\t\t\t\"*\" : {\n\t\t\t\tregexp : /^\\*/,\n\t\t\t\tprecedence : 0,\n\t\t\t\tmethod : applyBinary.bind(this, Tone.Multiply)\n\t\t\t}\n\t\t},\n\t\t//unary expressions\n\t\t\"unary\" : {\n\t\t\t\"-\" : {\n\t\t\t\tregexp : /^\\-/,\n\t\t\t\tmethod : applyUnary.bind(this, Tone.Negate)\n\t\t\t},\n\t\t\t\"!\" : {\n\t\t\t\tregexp : /^\\!/,\n\t\t\t\tmethod : applyUnary.bind(this, Tone.NOT)\n\t\t\t},\n\t\t},\n\t};\n\t\t\n\t/**\n\t * @param {string} expr the expression string\n\t * @return {number} the input count\n\t * @private\n\t */\n\tTone.Expr.prototype._parseInputs = function(expr){\n\t\tvar inputArray = expr.match(/\\$\\d/g);\n\t\tvar inputMax = 0;\n\t\tif (inputArray !== null){\n\t\t\tfor (var i = 0; i < inputArray.length; i++){\n\t\t\t\tvar inputNum = parseInt(inputArray[i].substr(1)) + 1;\n\t\t\t\tinputMax = Math.max(inputMax, inputNum);\n\t\t\t}\n\t\t}\n\t\treturn inputMax;\n\t};\n\n\t/**\n\t * @param {Array} args \tan array of arguments\n\t * @return {string} the results of the replacements being replaced\n\t * @private\n\t */\n\tTone.Expr.prototype._replacements = function(args){\n\t\tvar expr = args.shift();\n\t\tfor (var i = 0; i < args.length; i++){\n\t\t\texpr = expr.replace(/\\%/i, args[i]);\n\t\t}\n\t\treturn expr;\n\t};\n\n\t/**\n\t * tokenize the expression based on the Expressions object\n\t * @param {string} expr \n\t * @return {Object} returns two methods on the tokenized list, next and peek\n\t * @private\n\t */\n\tTone.Expr.prototype._tokenize = function(expr){\n\t\tvar position = -1;\n\t\tvar tokens = [];\n\n\t\twhile(expr.length > 0){\n\t\t\texpr = expr.trim();\n\t\t\tvar token = getNextToken(expr);\n\t\t\ttokens.push(token);\n\t\t\texpr = expr.substr(token.value.length);\n\t\t}\n\n\t\tfunction getNextToken(expr){\n\t\t\tfor (var type in Tone.Expr._Expressions){\n\t\t\t\tvar group = Tone.Expr._Expressions[type];\n\t\t\t\tfor (var opName in group){\n\t\t\t\t\tvar op = group[opName];\n\t\t\t\t\tvar reg = op.regexp;\n\t\t\t\t\tvar match = expr.match(reg);\n\t\t\t\t\tif (match !== null){\n\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\ttype : type,\n\t\t\t\t\t\t\tvalue : match[0],\n\t\t\t\t\t\t\tmethod : op.method\n\t\t\t\t\t\t};\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tthrow new SyntaxError(\"Tone.Expr: Unexpected token \"+expr);\n\t\t}\n\n\t\treturn {\n\t\t\tnext : function(){\n\t\t\t\treturn tokens[++position];\n\t\t\t},\n\t\t\tpeek : function(){\n\t\t\t\treturn tokens[position + 1];\n\t\t\t}\n\t\t};\n\t};\n\n\t/**\n\t * recursively parse the string expression into a syntax tree\n\t * \n\t * @param {string} expr \n\t * @return {Object}\n\t * @private\n\t */\n\tTone.Expr.prototype._parseTree = function(expr){\n\t\tvar lexer = this._tokenize(expr);\n\t\tvar isUndef = this.isUndef.bind(this);\n\n\t\tfunction matchSyntax(token, syn) {\n\t\t\treturn !isUndef(token) && \n\t\t\t\ttoken.type === \"glue\" &&\n\t\t\t\ttoken.value === syn;\n\t\t}\n\n\t\tfunction matchGroup(token, groupName, prec) {\n\t\t\tvar ret = false;\n\t\t\tvar group = Tone.Expr._Expressions[groupName];\n\t\t\tif (!isUndef(token)){\n\t\t\t\tfor (var opName in group){\n\t\t\t\t\tvar op = group[opName];\n\t\t\t\t\tif (op.regexp.test(token.value)){\n\t\t\t\t\t\tif (!isUndef(prec)){\n\t\t\t\t\t\t\tif(op.precedence === prec){\t\n\t\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn ret;\n\t\t}\n\n\t\tfunction parseExpression(precedence) {\n\t\t\tif (isUndef(precedence)){\n\t\t\t\tprecedence = 5;\n\t\t\t}\n\t\t\tvar expr;\n\t\t\tif (precedence < 0){\n\t\t\t\texpr = parseUnary();\n\t\t\t} else {\n\t\t\t\texpr = parseExpression(precedence-1);\n\t\t\t}\n\t\t\tvar token = lexer.peek();\n\t\t\twhile (matchGroup(token, \"binary\", precedence)) {\n\t\t\t\ttoken = lexer.next();\n\t\t\t\texpr = {\n\t\t\t\t\toperator: token.value,\n\t\t\t\t\tmethod : token.method,\n\t\t\t\t\targs : [\n\t\t\t\t\t\texpr,\n\t\t\t\t\t\tparseExpression(precedence-1)\n\t\t\t\t\t]\n\t\t\t\t};\n\t\t\t\ttoken = lexer.peek();\n\t\t\t}\n\t\t\treturn expr;\n\t\t}\n\n\t\tfunction parseUnary() {\n\t\t\tvar token, expr;\n\t\t\ttoken = lexer.peek();\n\t\t\tif (matchGroup(token, \"unary\")) {\n\t\t\t\ttoken = lexer.next();\n\t\t\t\texpr = parseUnary();\n\t\t\t\treturn {\n\t\t\t\t\toperator: token.value,\n\t\t\t\t\tmethod : token.method,\n\t\t\t\t\targs : [expr]\n\t\t\t\t};\n\t\t\t}\n\t\t\treturn parsePrimary();\n\t\t}\n\n\t\tfunction parsePrimary() {\n\t\t\tvar token, expr;\n\t\t\ttoken = lexer.peek();\n\t\t\tif (isUndef(token)) {\n\t\t\t\tthrow new SyntaxError(\"Tone.Expr: Unexpected termination of expression\");\n\t\t\t}\n\t\t\tif (token.type === \"func\") {\n\t\t\t\ttoken = lexer.next();\n\t\t\t\treturn parseFunctionCall(token);\n\t\t\t}\n\t\t\tif (token.type === \"value\") {\n\t\t\t\ttoken = lexer.next();\n\t\t\t\treturn {\n\t\t\t\t\tmethod : token.method,\n\t\t\t\t\targs : token.value\n\t\t\t\t};\n\t\t\t}\n\t\t\tif (matchSyntax(token, \"(\")) {\n\t\t\t\tlexer.next();\n\t\t\t\texpr = parseExpression();\n\t\t\t\ttoken = lexer.next();\n\t\t\t\tif (!matchSyntax(token, \")\")) {\n\t\t\t\t\tthrow new SyntaxError(\"Expected )\");\n\t\t\t\t}\n\t\t\t\treturn expr;\n\t\t\t}\n\t\t\tthrow new SyntaxError(\"Tone.Expr: Parse error, cannot process token \" + token.value);\n\t\t}\n\n\t\tfunction parseFunctionCall(func) {\n\t\t\tvar token, args = [];\n\t\t\ttoken = lexer.next();\n\t\t\tif (!matchSyntax(token, \"(\")) {\n\t\t\t\tthrow new SyntaxError(\"Tone.Expr: Expected ( in a function call \\\"\" + func.value + \"\\\"\");\n\t\t\t}\n\t\t\ttoken = lexer.peek();\n\t\t\tif (!matchSyntax(token, \")\")) {\n\t\t\t\targs = parseArgumentList();\n\t\t\t}\n\t\t\ttoken = lexer.next();\n\t\t\tif (!matchSyntax(token, \")\")) {\n\t\t\t\tthrow new SyntaxError(\"Tone.Expr: Expected ) in a function call \\\"\" + func.value + \"\\\"\");\n\t\t\t}\n\t\t\treturn {\n\t\t\t\tmethod : func.method,\n\t\t\t\targs : args,\n\t\t\t\tname : name\n\t\t\t};\n\t\t}\n\n\t\tfunction parseArgumentList() {\n\t\t\tvar token, expr, args = [];\n\t\t\twhile (true) {\n\t\t\t\texpr = parseExpression();\n\t\t\t\tif (isUndef(expr)) {\n\t\t\t\t\t// TODO maybe throw exception?\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\targs.push(expr);\n\t\t\t\ttoken = lexer.peek();\n\t\t\t\tif (!matchSyntax(token, \",\")) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\tlexer.next();\n\t\t\t}\n\t\t\treturn args;\n\t\t}\n\n\t\treturn parseExpression();\n\t};\n\n\t/**\n\t * recursively evaluate the expression tree\n\t * @param {Object} tree \n\t * @return {AudioNode} the resulting audio node from the expression\n\t * @private\n\t */\n\tTone.Expr.prototype._eval = function(tree){\n\t\tif (!this.isUndef(tree)){\n\t\t\tvar node = tree.method(tree.args, this);\n\t\t\tthis._nodes.push(node);\n\t\t\treturn node;\n\t\t} \n\t};\n\n\t/**\n\t * dispose all the nodes\n\t * @private\n\t */\n\tTone.Expr.prototype._disposeNodes = function(){\n\t\tfor (var i = 0; i < this._nodes.length; i++){\n\t\t\tvar node = this._nodes[i];\n\t\t\tif (this.isFunction(node.dispose)) {\n\t\t\t\tnode.dispose();\n\t\t\t} else if (this.isFunction(node.disconnect)) {\n\t\t\t\tnode.disconnect();\n\t\t\t}\n\t\t\tnode = null;\n\t\t\tthis._nodes[i] = null;\n\t\t}\n\t\tthis._nodes = null;\n\t};\n\n\t/**\n\t * clean up\n\t */\n\tTone.Expr.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._disposeNodes();\n\t};\n\n\treturn Tone.Expr;\n});","define([\"Tone/core/Tone\", \"Tone/signal/GreaterThanZero\", \"Tone/signal/Subtract\", \"Tone/signal/Signal\"], \n\tfunction(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Output 1 if the signal is greater than the value, otherwise outputs 0.\n\t * can compare two signals or a signal and a number. \n\t * \n\t * @constructor\n\t * @extends {Tone.Signal}\n\t * @param {number} [value=0] the value to compare to the incoming signal\n\t * @example\n\t * var gt = new Tone.GreaterThan(2);\n\t * var sig = new Tone.Signal(4).connect(gt);\n\t * //output of gt is equal 1. \n\t */\n\tTone.GreaterThan = function(value){\n\n\t\tthis.createInsOuts(2, 0);\n\t\t\n\t\t/**\n\t\t * subtract the amount from the incoming signal\n\t\t * @type {Tone.Subtract}\n\t\t * @private\n\t\t */\n\t\tthis._param = this.input[0] = new Tone.Subtract(value);\n\t\tthis.input[1] = this._param.input[1];\n\n\t\t/**\n\t\t * compare that amount to zero\n\t\t * @type {Tone.GreaterThanZero}\n\t\t * @private\n\t\t */\n\t\tthis._gtz = this.output = new Tone.GreaterThanZero();\n\n\t\t//connect\n\t\tthis._param.connect(this._gtz);\n\t};\n\n\tTone.extend(Tone.GreaterThan, Tone.Signal);\n\n\t/**\n\t * dispose method\n\t * @returns {Tone.GreaterThan} this\n\t */\n\tTone.GreaterThan.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._param.dispose();\n\t\tthis._param = null;\n\t\tthis._gtz.dispose();\n\t\tthis._gtz = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.GreaterThan;\n});","define([\"Tone/core/Tone\", \"Tone/signal/WaveShaper\", \"Tone/signal/SignalBase\"], \nfunction(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Return the absolute value of an incoming signal. \n\t * \n\t * @constructor\n\t * @extends {Tone.SignalBase}\n\t * @example\n\t * var signal = new Tone.Signal(-1);\n\t * var abs = new Tone.Abs();\n\t * signal.connect(abs);\n\t * //the output of abs is 1. \n\t */\n\tTone.Abs = function(){\n\t\t/**\n\t\t * @type {Tone.LessThan}\n\t\t * @private\n\t\t */\n\t\tthis._abs = this.input = this.output = new Tone.WaveShaper(function(val){\n\t\t\tif (val === 0){\n\t\t\t\treturn 0;\n\t\t\t} else {\n\t\t\t\treturn Math.abs(val);\n\t\t\t}\n\t\t}, 127);\n\t};\n\n\tTone.extend(Tone.Abs, Tone.SignalBase);\n\n\t/**\n\t * dispose method\n\t * @returns {Tone.Abs} this\n\t */\n\tTone.Abs.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._abs.dispose();\n\t\tthis._abs = null;\n\t\treturn this;\n\t}; \n\n\treturn Tone.Abs;\n});","define([\"Tone/core/Tone\", \"Tone/signal/WaveShaper\", \"Tone/signal/Multiply\", \"Tone/signal/Subtract\"], \nfunction(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Signal-rate modulo operator. Only works in AudioRange [-1, 1] and for modulus\n\t * values in the NormalRange. \n\t *\n\t * @constructor\n\t * @extends {Tone.SignalBase}\n\t * @param {NormalRange} modulus The modulus to apply.\n\t * @example\n\t * var mod = new Tone.Modulo(0.2)\n\t * var sig = new Tone.Signal(0.5).connect(mod);\n\t * //mod outputs 0.1\n\t */\n\tTone.Modulo = function(modulus){\n\n\t\tthis.createInsOuts(1, 0);\n\n\t\t/**\n\t\t * A waveshaper gets the integer multiple of \n\t\t * the input signal and the modulus.\n\t\t * @private\n\t\t * @type {Tone.WaveShaper}\n\t\t */\n\t\tthis._shaper = new Tone.WaveShaper(Math.pow(2, 16));\n\n\t\t/**\n\t\t * the integer multiple is multiplied by the modulus\n\t\t * @type {Tone.Multiply}\n\t\t * @private\n\t\t */\n\t\tthis._multiply = new Tone.Multiply();\n\n\t\t/**\n\t\t * and subtracted from the input signal\n\t\t * @type {Tone.Subtract}\n\t\t * @private\n\t\t */\n\t\tthis._subtract = this.output = new Tone.Subtract();\n\n\t\t/**\n\t\t * the modulus signal\n\t\t * @type {Tone.Signal}\n\t\t * @private\n\t\t */\n\t\tthis._modSignal = new Tone.Signal(modulus);\n\n\t\t//connections\n\t\tthis.input.fan(this._shaper, this._subtract);\n\t\tthis._modSignal.connect(this._multiply, 0, 0);\n\t\tthis._shaper.connect(this._multiply, 0, 1);\n\t\tthis._multiply.connect(this._subtract, 0, 1);\n\t\tthis._setWaveShaper(modulus);\n\t};\n\n\tTone.extend(Tone.Modulo, Tone.SignalBase);\n\n\t/**\n\t * @param {number} mod the modulus to apply\n\t * @private\n\t */\n\tTone.Modulo.prototype._setWaveShaper = function(mod){\n\t\tthis._shaper.setMap(function(val){\n\t\t\tvar multiple = Math.floor((val + 0.0001) / mod);\n\t\t\treturn multiple;\n\t\t});\n\t};\n\n\t/**\n\t * The modulus value.\n\t * @memberOf Tone.Modulo#\n\t * @type {NormalRange}\n\t * @name value\n\t */\n\tObject.defineProperty(Tone.Modulo.prototype, \"value\", {\n\t\tget : function(){\n\t\t\treturn this._modSignal.value;\n\t\t},\n\t\tset : function(mod){\n\t\t\tthis._modSignal.value = mod;\n\t\t\tthis._setWaveShaper(mod);\n\t\t}\n\t});\n\n\t/**\n\t * clean up\n\t * @returns {Tone.Modulo} this\n\t */\n\tTone.Modulo.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._shaper.dispose();\n\t\tthis._shaper = null;\n\t\tthis._multiply.dispose();\n\t\tthis._multiply = null;\n\t\tthis._subtract.dispose();\n\t\tthis._subtract = null;\n\t\tthis._modSignal.dispose();\n\t\tthis._modSignal = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.Modulo;\n});","define([\"Tone/core/Tone\", \"Tone/signal/WaveShaper\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Pow applies an exponent to the incoming signal. The incoming signal\n\t * must be AudioRange.\n\t *\n\t * @extends {Tone.SignalBase}\n\t * @constructor\n\t * @param {Positive} exp The exponent to apply to the incoming signal, must be at least 2. \n\t * @example\n\t * var pow = new Tone.Pow(2);\n\t * var sig = new Tone.Signal(0.5).connect(pow);\n\t * //output of pow is 0.25. \n\t */\n\tTone.Pow = function(exp){\n\n\t\t/**\n\t\t * the exponent\n\t\t * @private\n\t\t * @type {number}\n\t\t */\n\t\tthis._exp = this.defaultArg(exp, 1);\n\n\t\t/**\n\t\t * @type {WaveShaperNode}\n\t\t * @private\n\t\t */\n\t\tthis._expScaler = this.input = this.output = new Tone.WaveShaper(this._expFunc(this._exp), 8192);\n\t};\n\n\tTone.extend(Tone.Pow, Tone.SignalBase);\n\n\t/**\n\t * The value of the exponent.\n\t * @memberOf Tone.Pow#\n\t * @type {number}\n\t * @name value\n\t */\n\tObject.defineProperty(Tone.Pow.prototype, \"value\", {\n\t\tget : function(){\n\t\t\treturn this._exp;\n\t\t},\n\t\tset : function(exp){\n\t\t\tthis._exp = exp;\n\t\t\tthis._expScaler.setMap(this._expFunc(this._exp));\n\t\t}\n\t});\n\n\n\t/**\n\t * the function which maps the waveshaper\n\t * @param {number} exp\n\t * @return {function}\n\t * @private\n\t */\n\tTone.Pow.prototype._expFunc = function(exp){\n\t\treturn function(val){\n\t\t\treturn Math.pow(Math.abs(val), exp);\n\t\t};\n\t};\n\n\t/**\n\t * Clean up.\n\t * @returns {Tone.Pow} this\n\t */\n\tTone.Pow.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._expScaler.dispose();\n\t\tthis._expScaler = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.Pow;\n});","define([\"Tone/core/Tone\", \"Tone/signal/WaveShaper\", \"Tone/signal/Signal\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class AudioToGain converts an input in AudioRange [-1,1] to NormalRange [0,1]. \n\t * See Tone.GainToAudio.\n\t *\n\t * @extends {Tone.SignalBase}\n\t * @constructor\n\t * @example\n\t * var a2g = new Tone.AudioToGain();\n\t */\n\tTone.AudioToGain = function(){\n\n\t\t/**\n\t\t * @type {WaveShaperNode}\n\t\t * @private\n\t\t */\n\t\tthis._norm = this.input = this.output = new Tone.WaveShaper(function(x){\n\t\t\treturn (x + 1) / 2;\n\t\t});\n\t};\n\n\tTone.extend(Tone.AudioToGain, Tone.SignalBase);\n\n\t/**\n\t * clean up\n\t * @returns {Tone.AudioToGain} this\n\t */\n\tTone.AudioToGain.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._norm.dispose();\n\t\tthis._norm = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.AudioToGain;\n});","define([\"Tone/core/Tone\", \"Tone/signal/WaveShaper\"], function(Tone){\n\n\t\"use strict\";\n\n\t/**\n\t * @class Convert an incoming signal between 0, 1 to an equal power gain scale.\n\t *\n\t * @extends {Tone.SignalBase}\n\t * @constructor\n\t * @example\n\t * var eqPowGain = new Tone.EqualPowerGain();\n\t */\n\tTone.EqualPowerGain = function(){\n\n\t\t/**\n\t\t * @type {Tone.WaveShaper}\n\t\t * @private\n\t\t */\n\t\tthis._eqPower = this.input = this.output = new Tone.WaveShaper(function(val){\n\t\t\tif (Math.abs(val) < 0.001){\n\t\t\t\t//should output 0 when input is 0\n\t\t\t\treturn 0;\n\t\t\t} else {\n\t\t\t\treturn this.equalPowerScale(val);\n\t\t\t}\n\t\t}.bind(this), 4096);\n\t};\n\n\tTone.extend(Tone.EqualPowerGain, Tone.SignalBase);\n\n\t/**\n\t * clean up\n\t * @returns {Tone.EqualPowerGain} this\n\t */\n\tTone.EqualPowerGain.prototype.dispose = function(){\n\t\tTone.prototype.dispose.call(this);\n\t\tthis._eqPower.dispose();\n\t\tthis._eqPower = null;\n\t\treturn this;\n\t};\n\n\treturn Tone.EqualPowerGain;\n});","'use strict';\n\ndefine(function (require) {\n\n var Effect = require('effect');\n var EQFilter = require('eqFilter');\n\n /**\n * p5.EQ is an audio effect that performs the function of a multiband\n * audio equalizer. Equalization is used to adjust the balance of\n * frequency compoenents of an audio signal. This process is commonly used\n * in sound production and recording to change the waveform before it reaches\n * a sound output device. EQ can also be used as an audio effect to create\n * interesting distortions by filtering out parts of the spectrum. p5.EQ is\n * built using a chain of Web Audio Biquad Filter Nodes and can be\n * instantiated with 3 or 8 bands. Bands can be added or removed from\n * the EQ by directly modifying p5.EQ.bands (the array that stores filters).\n *\n * This class extends p5.Effect.\n * Methods amp(), chain(),\n * drywet(), connect(), and\n * disconnect() are available.\n *\n * @class p5.EQ\n * @constructor\n * @extends p5.Effect\n * @param {Number} [_eqsize] Constructor will accept 3 or 8, defaults to 3\n * @return {Object} p5.EQ object\n *\n * @example\n *
\n * let eq, soundFile\n * let eqBandIndex = 0;\n * let eqBandNames = ['lows', 'mids', 'highs'];\n *\n * function preload() {\n * soundFormats('mp3', 'ogg');\n * soundFile = loadSound('assets/beat');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(toggleSound);\n *\n * eq = new p5.EQ(eqBandNames.length);\n * soundFile.disconnect();\n * eq.process(soundFile);\n * }\n *\n * function draw() {\n * background(30);\n * noStroke();\n * fill(255);\n * textAlign(CENTER);\n * text('filtering ', 50, 25);\n *\n * fill(255, 40, 255);\n * textSize(26);\n * text(eqBandNames[eqBandIndex], 50, 55);\n *\n * fill(255);\n * textSize(9);\n *\n * if (!soundFile.isPlaying()) {\n * text('tap to play', 50, 80);\n * } else {\n * text('tap to filter next band', 50, 80)\n * }\n * }\n *\n * function toggleSound() {\n * if (!soundFile.isPlaying()) {\n * soundFile.play();\n * } else {\n * eqBandIndex = (eqBandIndex + 1) % eq.bands.length;\n * }\n *\n * for (let i = 0; i < eq.bands.length; i++) {\n * eq.bands[i].gain(0);\n * }\n * // filter the band we want to filter\n * eq.bands[eqBandIndex].gain(-40);\n * }\n *
\n */\n p5.EQ = function(_eqsize) {\n Effect.call(this);\n\n //p5.EQ can be of size (3) or (8), defaults to 3\n _eqsize = _eqsize === 3 || _eqsize === 8 ? _eqsize : 3;\n\n var factor;\n _eqsize === 3 ? factor = Math.pow(2,3) : factor = 2;\n\n /**\n * The p5.EQ is built with abstracted p5.Filter objects.\n * To modify any bands, use methods of the \n * p5.Filter API, especially `gain` and `freq`.\n * Bands are stored in an array, with indices 0 - 3, or 0 - 7\n * @property {Array} bands\n *\n */\n this.bands = [];\n\n\n var freq, res;\n for (var i = 0; i < _eqsize; i++) {\n if (i === _eqsize - 1) {\n freq = 21000;\n res = .01;\n } else if (i === 0) {\n freq = 100;\n res = .1;\n }\n else if (i===1) {\n freq = _eqsize === 3 ? 360 * factor : 360;\n res = 1;\n }else {\n freq = this.bands[i-1].freq() * factor;\n res = 1;\n }\n this.bands[i] = this._newBand(freq, res);\n\n if (i>0) {\n this.bands[i-1].connect(this.bands[i].biquad);\n } else {\n this.input.connect(this.bands[i].biquad);\n }\n }\n this.bands[_eqsize-1].connect(this.output);\n };\n p5.EQ.prototype = Object.create(Effect.prototype);\n\n /**\n * Process an input by connecting it to the EQ\n * @method process\n * @param {Object} src Audio source\n */\n p5.EQ.prototype.process = function (src) {\n src.connect(this.input);\n };\n\n // /**\n // * Set the frequency and gain of each band in the EQ. This method should be\n // * called with 3 or 8 frequency and gain pairs, depending on the size of the EQ.\n // * ex. eq.set(freq0, gain0, freq1, gain1, freq2, gain2);\n // *\n // * @method set\n // * @for p5.EQ\n // * @param {Number} [freq0] Frequency value for band with index 0\n // * @param {Number} [gain0] Gain value for band with index 0\n // * @param {Number} [freq1] Frequency value for band with index 1\n // * @param {Number} [gain1] Gain value for band with index 1\n // * @param {Number} [freq2] Frequency value for band with index 2\n // * @param {Number} [gain2] Gain value for band with index 2\n // * @param {Number} [freq3] Frequency value for band with index 3\n // * @param {Number} [gain3] Gain value for band with index 3\n // * @param {Number} [freq4] Frequency value for band with index 4\n // * @param {Number} [gain4] Gain value for band with index 4\n // * @param {Number} [freq5] Frequency value for band with index 5\n // * @param {Number} [gain5] Gain value for band with index 5\n // * @param {Number} [freq6] Frequency value for band with index 6\n // * @param {Number} [gain6] Gain value for band with index 6\n // * @param {Number} [freq7] Frequency value for band with index 7\n // * @param {Number} [gain7] Gain value for band with index 7\n // */\n p5.EQ.prototype.set = function() {\n if (arguments.length === this.bands.length * 2) {\n for (var i = 0; i < arguments.length; i+=2) {\n this.bands[i/2].freq(arguments[i]);\n this.bands[i/2].gain(arguments[i+1]);\n }\n }\n else {\n console.error('Argument mismatch. .set() should be called with ' + this.bands.length*2 +\n ' arguments. (one frequency and gain value pair for each band of the eq)');\n }\n };\n\n /**\n * Add a new band. Creates a p5.Filter and strips away everything but\n * the raw biquad filter. This method returns an abstracted p5.Filter,\n * which can be added to p5.EQ.bands, in order to create new EQ bands.\n * @private\n * @for p5.EQ\n * @method _newBand\n * @param {Number} freq\n * @param {Number} res\n * @return {Object} Abstracted Filter\n */\n p5.EQ.prototype._newBand = function(freq, res) {\n return new EQFilter(freq, res);\n };\n\n p5.EQ.prototype.dispose = function () {\n Effect.prototype.dispose.apply(this);\n\n if (this.bands) {\n while (this.bands.length > 0) {\n delete this.bands.pop().dispose();\n }\n delete this.bands;\n }\n };\n\n return p5.EQ;\n});\n","'use strict';\n\ndefine(function (require) {\n var Filter = require('filter');\n var p5sound = require('master');\n\n /**\n * EQFilter extends p5.Filter with constraints\n * necessary for the p5.EQ\n *\n * @private\n */\n var EQFilter = function(freq, res) {\n Filter.call(this, 'peaking');\n this.disconnect();\n this.set(freq, res);\n this.biquad.gain.value = 0;\n delete this.input;\n delete this.output;\n delete this._drywet;\n delete this.wet;\n\n };\n EQFilter.prototype = Object.create(Filter.prototype);\n\n EQFilter.prototype.amp = function() {\n console.warn('`amp()` is not available for p5.EQ bands. Use `.gain()`');\n };\n EQFilter.prototype.drywet = function() {\n console.warn('`drywet()` is not available for p5.EQ bands.');\n };\n EQFilter.prototype.connect = function(unit) {\n var u = unit || p5.soundOut.input;\n if (this.biquad) {\n this.biquad.connect(u.input ? u.input : u);\n } else {\n this.output.connect(u.input ? u.input : u);\n }\n };\n\n EQFilter.prototype.disconnect = function() {\n if (this.biquad) {\n this.biquad.disconnect();\n }\n };\n EQFilter.prototype.dispose = function() {\n // remove reference form soundArray\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n this.disconnect();\n delete this.biquad;\n };\n\n return EQFilter;\n});\n","'use strict'\n\ndefine(function (require) {\n var p5sound = require('master');\n var Effect = require('effect');\n\n /**\n * Panner3D is based on the \n * Web Audio Spatial Panner Node.\n * This panner is a spatial processing node that allows audio to be positioned\n * and oriented in 3D space.\n *\n * The position is relative to an \n * Audio Context Listener, which can be accessed\n * by p5.soundOut.audiocontext.listener\n *\n *\n * @class p5.Panner3D\n * @constructor\n */\n\tp5.Panner3D = function() {\n Effect.call(this);\n\n /**\n * \n * Web Audio Spatial Panner Node\n *\n * Properties include\n * - panningModel: \"equal power\" or \"HRTF\"\n * - distanceModel: \"linear\", \"inverse\", or \"exponential\"\n *\n * @property {AudioNode} panner\n *\n */\n this.panner = this.ac.createPanner();\n this.panner.panningModel = 'HRTF';\n this.panner.distanceModel = 'linear';\n this.panner.connect(this.output);\n this.input.connect(this.panner);\n\t};\n\n p5.Panner3D.prototype = Object.create(Effect.prototype);\n\n\n /**\n * Connect an audio sorce\n *\n * @method process\n * @for p5.Panner3D\n * @param {Object} src Input source\n */\n p5.Panner3D.prototype.process = function(src) {\n src.connect(this.input);\n }\n /**\n * Set the X,Y,Z position of the Panner\n * @method set\n * @for p5.Panner3D\n * @param {Number} xVal\n * @param {Number} yVal\n * @param {Number} zVal\n * @param {Number} time\n * @return {Array} Updated x, y, z values as an array\n */\n p5.Panner3D.prototype.set = function(xVal, yVal, zVal, time) {\n this.positionX(xVal,time);\n this.positionY(yVal,time);\n this.positionZ(zVal,time);\n return [this.panner.positionX.value,\n this.panner.positionY.value,\n this.panner.positionZ.value];\n };\n\n /**\n * Getter and setter methods for position coordinates\n * @method positionX\n * @for p5.Panner3D\n * @return {Number} updated coordinate value\n */\n /**\n * Getter and setter methods for position coordinates\n * @method positionY\n * @for p5.Panner3D\n * @return {Number} updated coordinate value\n */\n /**\n * Getter and setter methods for position coordinates\n * @method positionZ\n * @for p5.Panner3D\n * @return {Number} updated coordinate value\n */\n p5.Panner3D.prototype.positionX = function(xVal, time) {\n var t = time || 0;\n if (typeof xVal === 'number') {\n this.panner.positionX.value = xVal;\n this.panner.positionX.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.panner.positionX.linearRampToValueAtTime(xVal, this.ac.currentTime + 0.02 + t);\n } else if (xVal) {\n xVal.connect(this.panner.positionX);\n }\n return this.panner.positionX.value;\n };\n p5.Panner3D.prototype.positionY = function(yVal, time) {\n var t = time || 0;\n if (typeof yVal === 'number') {\n this.panner.positionY.value = yVal;\n this.panner.positionY.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.panner.positionY.linearRampToValueAtTime(yVal, this.ac.currentTime + 0.02 + t);\n } else if (yVal) {\n yVal.connect(this.panner.positionY);\n }\n return this.panner.positionY.value;\n };\n p5.Panner3D.prototype.positionZ = function(zVal, time) {\n var t = time || 0;\n if (typeof zVal === 'number') {\n this.panner.positionZ.value = zVal;\n this.panner.positionZ.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.panner.positionZ.linearRampToValueAtTime(zVal, this.ac.currentTime + 0.02 + t);\n } else if (zVal) {\n zVal.connect(this.panner.positionZ);\n }\n return this.panner.positionZ.value;\n };\n\n /**\n * Set the X,Y,Z position of the Panner\n * @method orient\n * @for p5.Panner3D\n * @param {Number} xVal\n * @param {Number} yVal\n * @param {Number} zVal\n * @param {Number} time\n * @return {Array} Updated x, y, z values as an array\n */\n p5.Panner3D.prototype.orient = function(xVal, yVal, zVal, time) {\n this.orientX(xVal,time);\n this.orientY(yVal,time);\n this.orientZ(zVal,time);\n return [this.panner.orientationX.value,\n this.panner.orientationY.value,\n this.panner.orientationZ.value];\n };\n\n /**\n * Getter and setter methods for orient coordinates\n * @method orientX\n * @for p5.Panner3D\n * @return {Number} updated coordinate value\n */\n /**\n * Getter and setter methods for orient coordinates\n * @method orientY\n * @for p5.Panner3D\n * @return {Number} updated coordinate value\n */\n /**\n * Getter and setter methods for orient coordinates\n * @method orientZ\n * @for p5.Panner3D\n * @return {Number} updated coordinate value\n */\n p5.Panner3D.prototype.orientX = function(xVal, time) {\n var t = time || 0;\n if (typeof xVal === 'number') {\n this.panner.orientationX.value = xVal;\n this.panner.orientationX.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.panner.orientationX.linearRampToValueAtTime(xVal, this.ac.currentTime + 0.02 + t);\n } else if (xVal) {\n xVal.connect(this.panner.orientationX);\n }\n return this.panner.orientationX.value;\n };\n p5.Panner3D.prototype.orientY = function(yVal, time) {\n var t = time || 0;\n if (typeof yVal === 'number') {\n this.panner.orientationY.value = yVal;\n this.panner.orientationY.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.panner.orientationY.linearRampToValueAtTime(yVal, this.ac.currentTime + 0.02 + t);\n } else if (yVal) {\n yVal.connect(this.panner.orientationY);\n }\n return this.panner.orientationY.value;\n };\n p5.Panner3D.prototype.orientZ = function(zVal, time) {\n var t = time || 0;\n if (typeof zVal === 'number') {\n this.panner.orientationZ.value = zVal;\n this.panner.orientationZ.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.panner.orientationZ.linearRampToValueAtTime(zVal, this.ac.currentTime + 0.02 + t);\n } else if (zVal) {\n zVal.connect(this.panner.orientationZ);\n }\n return this.panner.orientationZ.value;\n };\n\n /**\n * Set the rolloff factor and max distance\n * @method setFalloff\n * @for p5.Panner3D\n * @param {Number} [maxDistance]\n * @param {Number} [rolloffFactor]\n */\n p5.Panner3D.prototype.setFalloff = function(maxDistance, rolloffFactor) {\n this.maxDist(maxDistance);\n this.rolloff(rolloffFactor);\n };\n /**\n * Maxium distance between the source and the listener\n * @method maxDist\n * @for p5.Panner3D\n * @param {Number} maxDistance\n * @return {Number} updated value\n */\n p5.Panner3D.prototype.maxDist = function(maxDistance){\n if (typeof maxDistance === 'number') {\n this.panner.maxDistance = maxDistance;\n }\n return this.panner.maxDistance;\n };\n\n /**\n * How quickly the volume is reduced as the source moves away from the listener\n * @method rollof\n * @for p5.Panner3D\n * @param {Number} rolloffFactor\n * @return {Number} updated value\n */\n p5.Panner3D.prototype.rolloff = function(rolloffFactor){\n if (typeof rolloffFactor === 'number') {\n this.panner.rolloffFactor = rolloffFactor;\n }\n return this.panner.rolloffFactor;\n };\n\n p5.Panner3D.dispose = function() {\n Effect.prototype.dispose.apply(this);\n if (this.panner) {\n this.panner.disconnect();\n delete this.panner;\n }\n };\n\n return p5.Panner3D;\n\n});\n","'use strict'\n\ndefine(function (require) {\n var p5sound = require('master');\n var Effect = require('effect');\n\n// /**\n// * listener is a class that can construct both a Spatial Panner\n// * and a Spatial Listener. The panner is based on the \n// * Web Audio Spatial Panner Node\n// * https://www.w3.org/TR/webaudio/#the-listenernode-interface\n// * This panner is a spatial processing node that allows audio to be positioned\n// * and oriented in 3D space. \n// *\n// * The Listener modifies the properties of the Audio Context Listener. \n// * Both objects types use the same methods. The default is a spatial panner.\n// *\n// * p5.Panner3D - Constructs a Spatial Panner
\n// * p5.Listener3D - Constructs a Spatial Listener
\n// *\n// * @class listener\n// * @constructor\n// * @return {Object} p5.Listener3D Object\n// *\n// * @param {Web Audio Node} listener Web Audio Spatial Panning Node\n// * @param {AudioParam} listener.panningModel \"equal power\" or \"HRTF\"\n// * @param {AudioParam} listener.distanceModel \"linear\", \"inverse\", or \"exponential\"\n// * @param {String} [type] [Specify construction of a spatial panner or listener]\n// */\n \n\tp5.Listener3D = function(type) {\n this.ac = p5sound.audiocontext;\n this.listener = this.ac.listener;\n\t}; \n\n// /**\n// * Connect an audio sorce\n// * @param {Object} src Input source\n// */\n p5.Listener3D.prototype.process = function(src) {\n src.connect(this.input);\n }\n// /**\n// * Set the X,Y,Z position of the Panner\n// * @param {[Number]} xVal\n// * @param {[Number]} yVal\n// * @param {[Number]} zVal\n// * @param {[Number]} time\n// * @return {[Array]} [Updated x, y, z values as an array]\n// */\n p5.Listener3D.prototype.position = function(xVal, yVal, zVal, time) {\n this.positionX(xVal,time);\n this.positionY(yVal,time);\n this.positionZ(zVal,time);\n return [this.listener.positionX.value, \n this.listener.positionY.value,\n this.listener.positionZ.value];\n };\n\n// /**\n// * Getter and setter methods for position coordinates\n// * @return {Number} [updated coordinate value]\n// */\n p5.Listener3D.prototype.positionX = function(xVal, time) {\n var t = time || 0;\n if (typeof xVal === 'number') {\n this.listener.positionX.value = xVal;\n this.listener.positionX.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.listener.positionX.linearRampToValueAtTime(xVal, this.ac.currentTime + 0.02 + t);\n } else if (xVal) {\n xVal.connect(this.listener.positionX);\n }\n return this.listener.positionX.value;\n };\n p5.Listener3D.prototype.positionY = function(yVal, time) {\n var t = time || 0;\n if (typeof yVal === 'number') {\n this.listener.positionY.value = yVal;\n this.listener.positionY.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.listener.positionY.linearRampToValueAtTime(yVal, this.ac.currentTime + 0.02 + t);\n } else if (yVal) {\n yVal.connect(this.listener.positionY);\n }\n return this.listener.positionY.value;\n };\n p5.Listener3D.prototype.positionZ = function(zVal, time) {\n var t = time || 0;\n if (typeof zVal === 'number') {\n this.listener.positionZ.value = zVal;\n this.listener.positionZ.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.listener.positionZ.linearRampToValueAtTime(zVal, this.ac.currentTime + 0.02 + t);\n } else if (zVal) {\n zVal.connect(this.listener.positionZ);\n }\n return this.listener.positionZ.value;\n };\n\n// cannot define method when class definition is commented\n// /**\n// * Overrides the listener orient() method because Listener has slightly\n// * different params. In human terms, Forward vectors are the direction the \n// * nose is pointing. Up vectors are the direction of the top of the head.\n// *\n// * @method orient\n// * @param {Number} xValF Forward vector X direction\n// * @param {Number} yValF Forward vector Y direction\n// * @param {Number} zValF Forward vector Z direction\n// * @param {Number} xValU Up vector X direction\n// * @param {Number} yValU Up vector Y direction\n// * @param {Number} zValU Up vector Z direction\n// * @param {Number} time \n// * @return {Array} All orienation params\n// */\n p5.Listener3D.prototype.orient = function(xValF, yValF, zValF, \n xValU, yValU, zValU, time) {\n\n if (arguments.length === 3 || arguments.length === 4) {\n time = arguments[3];\n this.orientForward(xValF, yValF, zValF, time);\n } else if (arguments.length === 6 || arguments === 7) {\n this.orientForward(xValF, yValF, zValF);\n this.orientUp(xValU, yValU, zValU, time);\n }\n \n return [this.listener.forwardX.value, \n this.listener.forwardY.value,\n this.listener.forwardZ.value,\n this.listener.upX.value,\n this.listener.upY.value,\n this.listener.upZ.value];\n };\n\n\n p5.Listener3D.prototype.orientForward = function(xValF, yValF, zValF, time) {\n this.forwardX(xValF,time);\n this.forwardY(yValF,time);\n this.forwardZ(zValF,time);\n\n return [this.listener.forwardX, \n this.listener.forwardY,\n this.listener.forwardZ];\n };\n\n p5.Listener3D.prototype.orientUp = function(xValU, yValU, zValU, time) {\n this.upX(xValU,time);\n this.upY(yValU,time);\n this.upZ(zValU,time);\n\n return [this.listener.upX, \n this.listener.upY,\n this.listener.upZ];\n };\n// /**\n// * Getter and setter methods for orient coordinates\n// * @return {Number} [updated coordinate value]\n// */\n p5.Listener3D.prototype.forwardX = function(xVal, time) {\n var t = time || 0;\n if (typeof xVal === 'number') {\n this.listener.forwardX.value = xVal;\n this.listener.forwardX.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.listener.forwardX.linearRampToValueAtTime(xVal, this.ac.currentTime + 0.02 + t);\n } else if (xVal) {\n xVal.connect(this.listener.forwardX);\n }\n return this.listener.forwardX.value;\n };\n p5.Listener3D.prototype.forwardY = function(yVal, time) {\n var t = time || 0;\n if (typeof yVal === 'number') {\n this.listener.forwardY.value = yVal;\n this.listener.forwardY.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.listener.forwardY.linearRampToValueAtTime(yVal, this.ac.currentTime + 0.02 + t);\n } else if (yVal) {\n yVal.connect(this.listener.forwardY);\n }\n return this.listener.forwardY.value;\n };\n p5.Listener3D.prototype.forwardZ = function(zVal, time) {\n var t = time || 0;\n if (typeof zVal === 'number') {\n this.listener.forwardZ.value = zVal;\n this.listener.forwardZ.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.listener.forwardZ.linearRampToValueAtTime(zVal, this.ac.currentTime + 0.02 + t);\n } else if (zVal) {\n zVal.connect(this.listener.forwardZ);\n }\n return this.listener.forwardZ.value;\n };\n p5.Listener3D.prototype.upX = function(xVal, time) {\n var t = time || 0;\n if (typeof xVal === 'number') {\n this.listener.upX.value = xVal;\n this.listener.upX.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.listener.upX.linearRampToValueAtTime(xVal, this.ac.currentTime + 0.02 + t);\n } else if (xVal) {\n xVal.connect(this.listener.upX);\n }\n return this.listener.upX.value;\n };\n p5.Listener3D.prototype.upY = function(yVal, time) {\n var t = time || 0;\n if (typeof yVal === 'number') {\n this.listener.upY.value = yVal;\n this.listener.upY.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.listener.upY.linearRampToValueAtTime(yVal, this.ac.currentTime + 0.02 + t);\n } else if (yVal) {\n yVal.connect(this.listener.upY);\n }\n return this.listener.upY.value;\n };\n p5.Listener3D.prototype.upZ = function(zVal, time) {\n var t = time || 0;\n if (typeof zVal === 'number') {\n this.listener.upZ.value = zVal;\n this.listener.upZ.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.listener.upZ.linearRampToValueAtTime(zVal, this.ac.currentTime + 0.02 + t);\n } else if (zVal) {\n zVal.connect(this.listener.upZ);\n }\n return this.listener.upZ.value;\n };\n \n return p5.Listener3D;\n\n});","'use strict';\n\ndefine(function (require) {\n var Filter = require('filter');\n var Effect = require('effect');\n\n /**\n * Delay is an echo effect. It processes an existing sound source,\n * and outputs a delayed version of that sound. The p5.Delay can\n * produce different effects depending on the delayTime, feedback,\n * filter, and type. In the example below, a feedback of 0.5 (the\n * default value) will produce a looping delay that decreases in\n * volume by 50% each repeat. A filter will cut out the high\n * frequencies so that the delay does not sound as piercing as the\n * original source.\n *\n *\n * This class extends p5.Effect.\n * Methods amp(), chain(),\n * drywet(), connect(), and\n * disconnect() are available.\n * @class p5.Delay\n * @extends p5.Effect\n * @constructor\n * @example\n *
\n * let osc;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * background(220);\n * textAlign(CENTER);\n * text('tap to play', width/2, height/2);\n *\n * osc = new p5.Oscillator('square');\n * osc.amp(0.5);\n * delay = new p5.Delay();\n *\n * // delay.process() accepts 4 parameters:\n * // source, delayTime (in seconds), feedback, filter frequency\n * delay.process(osc, 0.12, .7, 2300);\n *\n * cnv.mousePressed(oscStart);\n * }\n *\n * function oscStart() {\n * osc.start();\n * }\n *\n * function mouseReleased() {\n * osc.stop();\n * }\n *
\n */\n p5.Delay = function() {\n \tEffect.call(this);\n\n this._split = this.ac.createChannelSplitter(2);\n this._merge = this.ac.createChannelMerger(2);\n\n this._leftGain = this.ac.createGain();\n this._rightGain = this.ac.createGain();\n\n /**\n * The p5.Delay is built with two\n * \n * Web Audio Delay Nodes, one for each stereo channel.\n *\n * @for p5.Delay\n * @property {DelayNode} leftDelay\n */\n this.leftDelay = this.ac.createDelay();\n /**\n * The p5.Delay is built with two\n * \n * Web Audio Delay Nodes, one for each stereo channel.\n * @for p5.Delay\n * @property {DelayNode} rightDelay\n */\n this.rightDelay = this.ac.createDelay();\n\n this._leftFilter = new Filter();\n this._rightFilter = new Filter();\n this._leftFilter.disconnect();\n this._rightFilter.disconnect();\n\n this._leftFilter.biquad.frequency.setValueAtTime(1200, this.ac.currentTime);\n this._rightFilter.biquad.frequency.setValueAtTime(1200, this.ac.currentTime);\n this._leftFilter.biquad.Q.setValueAtTime(0.3, this.ac.currentTime);\n this._rightFilter.biquad.Q.setValueAtTime(0.3, this.ac.currentTime);\n\n // graph routing\n this.input.connect(this._split);\n this.leftDelay.connect(this._leftGain);\n this.rightDelay.connect(this._rightGain);\n this._leftGain.connect(this._leftFilter.input);\n this._rightGain.connect(this._rightFilter.input);\n this._merge.connect(this.wet);\n\n\n this._leftFilter.biquad.gain.setValueAtTime(1, this.ac.currentTime);\n this._rightFilter.biquad.gain.setValueAtTime(1, this.ac.currentTime);\n\n // default routing\n this.setType(0);\n\n this._maxDelay = this.leftDelay.delayTime.maxValue;\n\n // set initial feedback to 0.5\n this.feedback(0.5);\n\n\n };\n\n p5.Delay.prototype = Object.create(Effect.prototype);\n /**\n * Add delay to an audio signal according to a set\n * of delay parameters.\n *\n * @method process\n * @for p5.Delay\n * @param {Object} Signal An object that outputs audio\n * @param {Number} [delayTime] Time (in seconds) of the delay/echo.\n * Some browsers limit delayTime to\n * 1 second.\n * @param {Number} [feedback] sends the delay back through itself\n * in a loop that decreases in volume\n * each time.\n * @param {Number} [lowPass] Cutoff frequency. Only frequencies\n * below the lowPass will be part of the\n * delay.\n */\n p5.Delay.prototype.process = function(src, _delayTime, _feedback, _filter) {\n var feedback = _feedback || 0;\n var delayTime = _delayTime || 0;\n if (feedback >= 1.0) {\n throw new Error('Feedback value will force a positive feedback loop.');\n }\n if (delayTime >= this._maxDelay) {\n throw new Error('Delay Time exceeds maximum delay time of ' + this._maxDelay + ' second.');\n }\n\n src.connect(this.input);\n this.leftDelay.delayTime.setValueAtTime(delayTime, this.ac.currentTime);\n this.rightDelay.delayTime.setValueAtTime(delayTime, this.ac.currentTime);\n this._leftGain.gain.value = feedback;\n this._rightGain.gain.value = feedback;\n\n if (_filter) {\n this._leftFilter.freq(_filter);\n this._rightFilter.freq(_filter);\n }\n };\n\n /**\n * Set the delay (echo) time, in seconds. Usually this value will be\n * a floating point number between 0.0 and 1.0.\n *\n * @method delayTime\n * @for p5.Delay\n * @param {Number} delayTime Time (in seconds) of the delay\n */\n p5.Delay.prototype.delayTime = function(t) {\n // if t is an audio node...\n if (typeof t !== 'number') {\n t.connect(this.leftDelay.delayTime);\n t.connect(this.rightDelay.delayTime);\n }\n\n else {\n this.leftDelay.delayTime.cancelScheduledValues(this.ac.currentTime);\n this.rightDelay.delayTime.cancelScheduledValues(this.ac.currentTime);\n this.leftDelay.delayTime.linearRampToValueAtTime(t, this.ac.currentTime);\n this.rightDelay.delayTime.linearRampToValueAtTime(t, this.ac.currentTime);\n }\n };\n\n /**\n * Feedback occurs when Delay sends its signal back through its input\n * in a loop. The feedback amount determines how much signal to send each\n * time through the loop. A feedback greater than 1.0 is not desirable because\n * it will increase the overall output each time through the loop,\n * creating an infinite feedback loop. The default value is 0.5\n *\n * @method feedback\n * @for p5.Delay\n * @param {Number|Object} feedback 0.0 to 1.0, or an object such as an\n * Oscillator that can be used to\n * modulate this param\n * @returns {Number} Feedback value\n *\n */\n p5.Delay.prototype.feedback = function(f) {\n // if f is an audio node...\n if (f && typeof f !== 'number') {\n f.connect(this._leftGain.gain);\n f.connect(this._rightGain.gain);\n }\n else if (f >= 1.0) {\n throw new Error('Feedback value will force a positive feedback loop.');\n }\n else if (typeof f === 'number') {\n this._leftGain.gain.value = f;\n this._rightGain.gain.value = f;\n }\n\n // return value of feedback\n return this._leftGain.gain.value;\n };\n\n /**\n * Set a lowpass filter frequency for the delay. A lowpass filter\n * will cut off any frequencies higher than the filter frequency.\n *\n * @method filter\n * @for p5.Delay\n * @param {Number|Object} cutoffFreq A lowpass filter will cut off any\n * frequencies higher than the filter frequency.\n * @param {Number|Object} res Resonance of the filter frequency\n * cutoff, or an object (i.e. a p5.Oscillator)\n * that can be used to modulate this parameter.\n * High numbers (i.e. 15) will produce a resonance,\n * low numbers (i.e. .2) will produce a slope.\n */\n p5.Delay.prototype.filter = function(freq, q) {\n this._leftFilter.set(freq, q);\n this._rightFilter.set(freq, q);\n };\n\n\n /**\n * Choose a preset type of delay. 'pingPong' bounces the signal\n * from the left to the right channel to produce a stereo effect.\n * Any other parameter will revert to the default delay setting.\n *\n * @method setType\n * @for p5.Delay\n * @param {String|Number} type 'pingPong' (1) or 'default' (0)\n */\n p5.Delay.prototype.setType = function(t) {\n if (t === 1) {\n t = 'pingPong';\n }\n this._split.disconnect();\n this._leftFilter.disconnect();\n this._rightFilter.disconnect();\n this._split.connect(this.leftDelay, 0);\n this._split.connect(this.rightDelay, 1);\n switch(t) {\n case 'pingPong':\n this._rightFilter.setType( this._leftFilter.biquad.type );\n this._leftFilter.output.connect(this._merge, 0, 0);\n this._rightFilter.output.connect(this._merge, 0, 1);\n this._leftFilter.output.connect(this.rightDelay);\n this._rightFilter.output.connect(this.leftDelay);\n break;\n default:\n this._leftFilter.output.connect(this._merge, 0, 0);\n this._rightFilter.output.connect(this._merge, 0, 1);\n this._leftFilter.output.connect(this.leftDelay);\n this._rightFilter.output.connect(this.rightDelay);\n }\n };\n\n // DocBlocks for methods inherited from p5.Effect\n /**\n * Set the output level of the delay effect.\n *\n * @method amp\n * @for p5.Delay\n * @param {Number} volume amplitude between 0 and 1.0\n * @param {Number} [rampTime] create a fade that lasts rampTime\n * @param {Number} [timeFromNow] schedule this event to happen\n * seconds from now\n */\n /**\n * Send output to a p5.sound or web audio object\n *\n * @method connect\n * @for p5.Delay\n * @param {Object} unit\n */\n /**\n * Disconnect all output.\n *\n * @method disconnect\n * @for p5.Delay\n */\n\n p5.Delay.prototype.dispose = function() {\n\n Effect.prototype.dispose.apply(this);\n\n this._split.disconnect();\n this._leftFilter.dispose();\n this._rightFilter.dispose();\n this._merge.disconnect();\n this._leftGain.disconnect();\n this._rightGain.disconnect();\n this.leftDelay.disconnect();\n this.rightDelay.disconnect();\n\n this._split = undefined;\n this._leftFilter = undefined;\n this._rightFilter = undefined;\n this._merge = undefined;\n this._leftGain = undefined;\n this._rightGain = undefined;\n this.leftDelay = undefined;\n this.rightDelay = undefined;\n };\n\n});\n","'use strict';\n\ndefine(function (require) {\n var CustomError = require('errorHandler');\n var Effect = require('effect');\n\n /**\n * Reverb adds depth to a sound through a large number of decaying\n * echoes. It creates the perception that sound is occurring in a\n * physical space. The p5.Reverb has paramters for Time (how long does the\n * reverb last) and decayRate (how much the sound decays with each echo)\n * that can be set with the .set() or .process() methods. The p5.Convolver\n * extends p5.Reverb allowing you to recreate the sound of actual physical\n * spaces through convolution.\n *\n * This class extends p5.Effect.\n * Methods amp(), chain(),\n * drywet(), connect(), and\n * disconnect() are available.\n *\n * @class p5.Reverb\n * @extends p5.Effect\n * @constructor\n * @example\n *
\n * let soundFile, reverb;\n * function preload() {\n * soundFile = loadSound('assets/Damscray_DancingTiger.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playSound);\n *\n * reverb = new p5.Reverb();\n * soundFile.disconnect(); // so we'll only hear reverb...\n *\n * // connect soundFile to reverb, process w/\n * // 3 second reverbTime, decayRate of 2%\n * reverb.process(soundFile, 3, 2);\n * }\n *\n * function draw() {\n * let dryWet = constrain(map(mouseX, 0, width, 0, 1), 0, 1);\n * // 1 = all reverb, 0 = no reverb\n * reverb.drywet(dryWet);\n *\n * background(220);\n * text('tap to play', 10, 20);\n * text('dry/wet: ' + round(dryWet * 100) + '%', 10, height - 20);\n * }\n *\n * function playSound() {\n * soundFile.play();\n * }\n *
\n */\n\n\n p5.Reverb = function() {\n Effect.call(this);\n\n this._initConvolverNode();\n\n // otherwise, Safari distorts\n this.input.gain.value = 0.5;\n\n // default params\n this._seconds = 3;\n this._decay = 2;\n this._reverse = false;\n\n this._buildImpulse();\n\n };\n\n p5.Reverb.prototype = Object.create(Effect.prototype);\n\n p5.Reverb.prototype._initConvolverNode = function() {\n this.convolverNode = this.ac.createConvolver();\n this.input.connect(this.convolverNode);\n this.convolverNode.connect(this.wet);\n };\n\n p5.Reverb.prototype._teardownConvolverNode = function() {\n if (this.convolverNode) {\n this.convolverNode.disconnect();\n delete this.convolverNode;\n }\n };\n\n p5.Reverb.prototype._setBuffer = function(audioBuffer) {\n this._teardownConvolverNode();\n this._initConvolverNode();\n this.convolverNode.buffer = audioBuffer;\n };\n /**\n * Connect a source to the reverb, and assign reverb parameters.\n *\n * @method process\n * @for p5.Reverb\n * @param {Object} src p5.sound / Web Audio object with a sound\n * output.\n * @param {Number} [seconds] Duration of the reverb, in seconds.\n * Min: 0, Max: 10. Defaults to 3.\n * @param {Number} [decayRate] Percentage of decay with each echo.\n * Min: 0, Max: 100. Defaults to 2.\n * @param {Boolean} [reverse] Play the reverb backwards or forwards.\n */\n p5.Reverb.prototype.process = function(src, seconds, decayRate, reverse) {\n src.connect(this.input);\n var rebuild = false;\n if (seconds) {\n this._seconds = seconds;\n rebuild = true;\n }\n if (decayRate) {\n this._decay = decayRate;\n }\n if (reverse) {\n this._reverse = reverse;\n }\n if (rebuild) {\n this._buildImpulse();\n }\n };\n\n /**\n * Set the reverb settings. Similar to .process(), but without\n * assigning a new input.\n *\n * @method set\n * @for p5.Reverb\n * @param {Number} [seconds] Duration of the reverb, in seconds.\n * Min: 0, Max: 10. Defaults to 3.\n * @param {Number} [decayRate] Percentage of decay with each echo.\n * Min: 0, Max: 100. Defaults to 2.\n * @param {Boolean} [reverse] Play the reverb backwards or forwards.\n */\n p5.Reverb.prototype.set = function(seconds, decayRate, reverse) {\n var rebuild = false;\n if (seconds) {\n this._seconds = seconds;\n rebuild = true;\n }\n if (decayRate) {\n this._decay = decayRate;\n }\n if (reverse) {\n this._reverse = reverse;\n }\n if (rebuild) {\n this._buildImpulse();\n }\n };\n\n // DocBlocks for methods inherited from p5.Effect\n /**\n * Set the output level of the reverb effect.\n *\n * @method amp\n * @for p5.Reverb\n * @param {Number} volume amplitude between 0 and 1.0\n * @param {Number} [rampTime] create a fade that lasts rampTime\n * @param {Number} [timeFromNow] schedule this event to happen\n * seconds from now\n */\n /**\n * Send output to a p5.sound or web audio object\n *\n * @method connect\n * @for p5.Reverb\n * @param {Object} unit\n */\n /**\n * Disconnect all output.\n *\n * @method disconnect\n * @for p5.Reverb\n */\n\n /**\n * Inspired by Simple Reverb by Jordan Santell\n * https://github.com/web-audio-components/simple-reverb/blob/master/index.js\n *\n * Utility function for building an impulse response\n * based on the module parameters.\n *\n * @private\n */\n p5.Reverb.prototype._buildImpulse = function() {\n var rate = this.ac.sampleRate;\n var length = rate*this._seconds;\n var decay = this._decay;\n var impulse = this.ac.createBuffer(2, length, rate);\n var impulseL = impulse.getChannelData(0);\n var impulseR = impulse.getChannelData(1);\n var n, i;\n for (i = 0; i < length; i++) {\n n = this._reverse ? length - i : i;\n impulseL[i] = (Math.random() * 2 - 1) * Math.pow(1 - n / length, decay);\n impulseR[i] = (Math.random() * 2 - 1) * Math.pow(1 - n / length, decay);\n }\n this._setBuffer(impulse);\n };\n\n p5.Reverb.prototype.dispose = function() {\n Effect.prototype.dispose.apply(this);\n this._teardownConvolverNode();\n };\n\n // =======================================================================\n // *** p5.Convolver ***\n // =======================================================================\n\n /**\n *

p5.Convolver extends p5.Reverb. It can emulate the sound of real\n * physical spaces through a process called \n * convolution.

\n *\n *

Convolution multiplies any audio input by an \"impulse response\"\n * to simulate the dispersion of sound over time. The impulse response is\n * generated from an audio file that you provide. One way to\n * generate an impulse response is to pop a balloon in a reverberant space\n * and record the echo. Convolution can also be used to experiment with\n * sound.

\n *\n *

Use the method createConvolution(path) to instantiate a\n * p5.Convolver with a path to your impulse response audio file.

\n *\n * @class p5.Convolver\n * @extends p5.Effect\n * @constructor\n * @param {String} path path to a sound file\n * @param {Function} [callback] function to call when loading succeeds\n * @param {Function} [errorCallback] function to call if loading fails.\n * This function will receive an error or\n * XMLHttpRequest object with information\n * about what went wrong.\n * @example\n *
\n * let cVerb, sound;\n * function preload() {\n * // We have both MP3 and OGG versions of all sound assets\n * soundFormats('ogg', 'mp3');\n *\n * // Try replacing 'bx-spring' with other soundfiles like\n * // 'concrete-tunnel' 'small-plate' 'drum' 'beatbox'\n * cVerb = createConvolver('assets/bx-spring.mp3');\n *\n * // Try replacing 'Damscray_DancingTiger' with\n * // 'beat', 'doorbell', lucky_dragons_-_power_melody'\n * sound = loadSound('assets/Damscray_DancingTiger.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playSound);\n * background(220);\n * text('tap to play', 20, 20);\n *\n * // disconnect from master output...\n * sound.disconnect();\n *\n * // ...and process with cVerb\n * // so that we only hear the convolution\n * cVerb.process(sound);\n * }\n *\n * function playSound() {\n * sound.play();\n * }\n *
\n */\n p5.Convolver = function(path, callback, errorCallback) {\n \t p5.Reverb.call(this);\n\n /**\n * Internally, the p5.Convolver uses the a\n * \n * Web Audio Convolver Node.\n *\n * @property {ConvolverNode} convolverNode\n */\n this._initConvolverNode();\n\n // otherwise, Safari distorts\n this.input.gain.value = 0.5;\n\n if (path) {\n this.impulses = [];\n this._loadBuffer(path, callback, errorCallback);\n }\n else {\n // parameters\n this._seconds = 3;\n this._decay = 2;\n this._reverse = false;\n\n this._buildImpulse();\n }\n\n };\n\n p5.Convolver.prototype = Object.create(p5.Reverb.prototype);\n\n p5.prototype.registerPreloadMethod('createConvolver', p5.prototype);\n\n /**\n * Create a p5.Convolver. Accepts a path to a soundfile\n * that will be used to generate an impulse response.\n *\n * @method createConvolver\n * @for p5\n * @param {String} path path to a sound file\n * @param {Function} [callback] function to call if loading is successful.\n * The object will be passed in as the argument\n * to the callback function.\n * @param {Function} [errorCallback] function to call if loading is not successful.\n * A custom error will be passed in as the argument\n * to the callback function.\n * @return {p5.Convolver}\n * @example\n *
\n * let cVerb, sound;\n * function preload() {\n * // We have both MP3 and OGG versions of all sound assets\n * soundFormats('ogg', 'mp3');\n *\n * // Try replacing 'bx-spring' with other soundfiles like\n * // 'concrete-tunnel' 'small-plate' 'drum' 'beatbox'\n * cVerb = createConvolver('assets/bx-spring.mp3');\n *\n * // Try replacing 'Damscray_DancingTiger' with\n * // 'beat', 'doorbell', lucky_dragons_-_power_melody'\n * sound = loadSound('assets/Damscray_DancingTiger.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playSound);\n * background(220);\n * text('tap to play', 20, 20);\n *\n * // disconnect from master output...\n * sound.disconnect();\n *\n * // ...and process with cVerb\n * // so that we only hear the convolution\n * cVerb.process(sound);\n * }\n *\n * function playSound() {\n * sound.play();\n * }\n *
\n */\n p5.prototype.createConvolver = function(path, callback, errorCallback) {\n // if loading locally without a server\n if (window.location.origin.indexOf('file://') > -1 && window.cordova === 'undefined') {\n alert('This sketch may require a server to load external files. Please see http://bit.ly/1qcInwS');\n }\n var self = this;\n var cReverb = new p5.Convolver(path, function(buffer) {\n if (typeof callback === 'function') {\n callback(buffer);\n }\n\n if (typeof self._decrementPreload === 'function') {\n self._decrementPreload();\n }\n }, errorCallback);\n cReverb.impulses = [];\n return cReverb;\n };\n\n /**\n * Private method to load a buffer as an Impulse Response,\n * assign it to the convolverNode, and add to the Array of .impulses.\n *\n * @param {String} path\n * @param {Function} callback\n * @param {Function} errorCallback\n * @private\n */\n p5.Convolver.prototype._loadBuffer = function(path, callback, errorCallback) {\n var path = p5.prototype._checkFileFormats(path);\n var self = this;\n var errorTrace = new Error().stack;\n var ac = p5.prototype.getAudioContext();\n\n var request = new XMLHttpRequest();\n request.open('GET', path, true);\n request.responseType = 'arraybuffer';\n\n request.onload = function() {\n if (request.status === 200) {\n // on success loading file:\n ac.decodeAudioData(request.response,\n function(buff) {\n var buffer = {};\n var chunks = path.split('/');\n buffer.name = chunks[chunks.length - 1];\n buffer.audioBuffer = buff;\n self.impulses.push(buffer);\n self._setBuffer(buffer.audioBuffer);\n if (callback) {\n callback(buffer);\n }\n },\n // error decoding buffer. \"e\" is undefined in Chrome 11/22/2015\n function() {\n var err = new CustomError('decodeAudioData', errorTrace, self.url);\n var msg = 'AudioContext error at decodeAudioData for ' + self.url;\n if (errorCallback) {\n err.msg = msg;\n errorCallback(err);\n } else {\n console.error(msg +'\\n The error stack trace includes: \\n' + err.stack);\n }\n }\n );\n }\n // if request status != 200, it failed\n else {\n var err = new CustomError('loadConvolver', errorTrace, self.url);\n var msg = 'Unable to load ' + self.url +\n '. The request status was: ' + request.status + ' (' + request.statusText + ')';\n\n if (errorCallback) {\n err.message = msg;\n errorCallback(err);\n } else {\n console.error(msg +'\\n The error stack trace includes: \\n' + err.stack);\n }\n }\n };\n\n // if there is another error, aside from 404...\n request.onerror = function() {\n var err = new CustomError('loadConvolver', errorTrace, self.url);\n var msg = 'There was no response from the server at ' + self.url + '. Check the url and internet connectivity.';\n\n if (errorCallback) {\n err.message = msg;\n errorCallback(err);\n } else {\n console.error(msg +'\\n The error stack trace includes: \\n' + err.stack);\n }\n };\n request.send();\n };\n\n p5.Convolver.prototype.set = null;\n\n /**\n * Connect a source to the convolver.\n *\n * @method process\n * @for p5.Convolver\n * @param {Object} src p5.sound / Web Audio object with a sound\n * output.\n * @example\n *
\n * let cVerb, sound;\n * function preload() {\n * // We have both MP3 and OGG versions of all sound assets\n * soundFormats('ogg', 'mp3');\n *\n * // Try replacing 'bx-spring' with other soundfiles like\n * // 'concrete-tunnel' 'small-plate' 'drum' 'beatbox'\n * cVerb = createConvolver('assets/bx-spring.mp3');\n *\n * // Try replacing 'Damscray_DancingTiger' with\n * // 'beat', 'doorbell', lucky_dragons_-_power_melody'\n * sound = loadSound('assets/Damscray_DancingTiger.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playSound);\n * background(220);\n * text('tap to play', 20, 20);\n *\n * // disconnect from master output...\n * sound.disconnect();\n *\n * // ...and process with cVerb\n * // so that we only hear the convolution\n * cVerb.process(sound);\n * }\n *\n * function playSound() {\n * sound.play();\n * }\n *\n *
\n */\n p5.Convolver.prototype.process = function(src) {\n src.connect(this.input);\n };\n\n /**\n * If you load multiple impulse files using the .addImpulse method,\n * they will be stored as Objects in this Array. Toggle between them\n * with the toggleImpulse(id) method.\n *\n * @property {Array} impulses\n * @for p5.Convolver\n */\n p5.Convolver.prototype.impulses = [];\n\n /**\n * Load and assign a new Impulse Response to the p5.Convolver.\n * The impulse is added to the .impulses array. Previous\n * impulses can be accessed with the .toggleImpulse(id)\n * method.\n *\n * @method addImpulse\n * @for p5.Convolver\n * @param {String} path path to a sound file\n * @param {Function} callback function (optional)\n * @param {Function} errorCallback function (optional)\n */\n p5.Convolver.prototype.addImpulse = function(path, callback, errorCallback) {\n // if loading locally without a server\n if (window.location.origin.indexOf('file://') > -1 && window.cordova === 'undefined') {\n alert('This sketch may require a server to load external files. Please see http://bit.ly/1qcInwS');\n }\n this._loadBuffer(path, callback, errorCallback);\n };\n\n /**\n * Similar to .addImpulse, except that the .impulses\n * Array is reset to save memory. A new .impulses\n * array is created with this impulse as the only item.\n *\n * @method resetImpulse\n * @for p5.Convolver\n * @param {String} path path to a sound file\n * @param {Function} callback function (optional)\n * @param {Function} errorCallback function (optional)\n */\n p5.Convolver.prototype.resetImpulse = function(path, callback, errorCallback) {\n // if loading locally without a server\n if (window.location.origin.indexOf('file://') > -1 && window.cordova === 'undefined') {\n alert('This sketch may require a server to load external files. Please see http://bit.ly/1qcInwS');\n }\n this.impulses = [];\n this._loadBuffer(path, callback, errorCallback);\n };\n\n /**\n * If you have used .addImpulse() to add multiple impulses\n * to a p5.Convolver, then you can use this method to toggle between\n * the items in the .impulses Array. Accepts a parameter\n * to identify which impulse you wish to use, identified either by its\n * original filename (String) or by its position in the .impulses\n * Array (Number).
\n * You can access the objects in the .impulses Array directly. Each\n * Object has two attributes: an .audioBuffer (type:\n * Web Audio \n * AudioBuffer) and a .name, a String that corresponds\n * with the original filename.\n *\n * @method toggleImpulse\n * @for p5.Convolver\n * @param {String|Number} id Identify the impulse by its original filename\n * (String), or by its position in the\n * .impulses Array (Number).\n */\n p5.Convolver.prototype.toggleImpulse = function(id) {\n if (typeof id === 'number' && id < this.impulses.length) {\n this._setBuffer(this.impulses[id].audioBuffer);\n }\n if (typeof id === 'string') {\n for (var i = 0; i < this.impulses.length; i++) {\n if (this.impulses[i].name === id) {\n this._setBuffer(this.impulses[i].audioBuffer);\n break;\n }\n }\n }\n };\n\n p5.Convolver.prototype.dispose = function() {\n p5.Reverb.prototype.dispose.apply(this);\n\n // remove all the Impulse Response buffers\n for (var i in this.impulses) {\n if (this.impulses[i]) {\n this.impulses[i] = null;\n }\n }\n };\n\n});\n","'use strict';\n\ndefine(function (require) {\n var p5sound = require('master');\n\n // requires the Tone.js library's Clock (MIT license, Yotam Mann)\n // https://github.com/TONEnoTONE/Tone.js/\n var Clock = require('Tone/core/Clock');\n\n p5.Metro = function() {\n this.clock = new Clock({\n 'callback': this.ontick.bind(this)\n });\n this.syncedParts = [];\n this.bpm = 120; // gets overridden by p5.Part\n this._init();\n\n this.prevTick = 0;\n this.tatumTime = 0;\n\n this.tickCallback = function() {};\n };\n\n p5.Metro.prototype.ontick = function(tickTime) {\n var elapsedTime = tickTime - this.prevTick;\n var secondsFromNow = tickTime - p5sound.audiocontext.currentTime;\n if (elapsedTime - this.tatumTime <= -0.02) {\n return;\n } else {\n // console.log('ok', this.syncedParts[0].phrases[0].name);\n this.prevTick = tickTime;\n\n // for all of the active things on the metro:\n var self = this;\n this.syncedParts.forEach(function(thisPart) {\n if (!thisPart.isPlaying) return;\n thisPart.incrementStep(secondsFromNow);\n // each synced source keeps track of its own beat number\n thisPart.phrases.forEach(function(thisPhrase) {\n var phraseArray = thisPhrase.sequence;\n var bNum = self.metroTicks % phraseArray.length;\n if (phraseArray[bNum] !== 0 && (self.metroTicks < phraseArray.length || !thisPhrase.looping) ) {\n thisPhrase.callback(secondsFromNow, phraseArray[bNum]);\n }\n });\n });\n this.metroTicks += 1;\n this.tickCallback(secondsFromNow);\n }\n };\n\n p5.Metro.prototype.setBPM = function(bpm, rampTime) {\n var beatTime = 60 / (bpm*this.tatums);\n var now = p5sound.audiocontext.currentTime;\n this.tatumTime = beatTime;\n\n var rampTime = rampTime || 0;\n this.clock.frequency.setValueAtTime(this.clock.frequency.value, now);\n this.clock.frequency.linearRampToValueAtTime(bpm, now + rampTime);\n this.bpm = bpm;\n };\n\n p5.Metro.prototype.getBPM = function() {\n return this.clock.getRate() / this.tatums * 60;\n };\n\n p5.Metro.prototype._init = function() {\n this.metroTicks = 0;\n // this.setBPM(120);\n };\n\n // clear existing synced parts, add only this one\n p5.Metro.prototype.resetSync = function(part) {\n this.syncedParts = [part];\n };\n\n // push a new synced part to the array\n p5.Metro.prototype.pushSync = function(part) {\n this.syncedParts.push(part);\n };\n\n p5.Metro.prototype.start = function(timeFromNow) {\n var t = timeFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n this.clock.start(now + t);\n this.setBPM(this.bpm);\n };\n\n p5.Metro.prototype.stop = function(timeFromNow) {\n var t = timeFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n this.clock.stop(now + t);\n };\n\n p5.Metro.prototype.beatLength = function(tatums) {\n this.tatums = 1/tatums / 4; // lowest possible division of a beat\n };\n\n});\n","define([\"Tone/core/Tone\", \"Tone/core/Timeline\", \"Tone/type/Type\"], function (Tone) {\n\n\t\"use strict\";\n\n\t/**\n\t * @class A Timeline State. Provides the methods: setStateAtTime(\"state\", time)\n\t * and getValueAtTime(time).\n\t *\n\t * @extends {Tone.Timeline}\n\t * @param {String} initial The initial state of the TimelineState. \n\t * Defaults to undefined\n\t */\n\tTone.TimelineState = function(initial){\n\n\t\tTone.Timeline.call(this);\n\n\t\t/**\n\t\t * The initial state\n\t\t * @private\n\t\t * @type {String}\n\t\t */\n\t\tthis._initial = initial;\n\t};\n\n\tTone.extend(Tone.TimelineState, Tone.Timeline);\n\n\t/**\n\t * Returns the scheduled state scheduled before or at\n\t * the given time.\n\t * @param {Number} time The time to query.\n\t * @return {String} The name of the state input in setStateAtTime.\n\t */\n\tTone.TimelineState.prototype.getValueAtTime = function(time){\n\t\tvar event = this.get(time);\n\t\tif (event !== null){\n\t\t\treturn event.state;\n\t\t} else {\n\t\t\treturn this._initial;\n\t\t}\n\t};\n\n\t/**\n\t * Returns the scheduled state scheduled before or at\n\t * the given time.\n\t * @param {String} state The name of the state to set.\n\t * @param {Number} time The time to query.\n\t */\n\tTone.TimelineState.prototype.setStateAtTime = function(state, time){\n\t\tthis.add({\n\t\t\t\"state\" : state,\n\t\t\t\"time\" : time\n\t\t});\n\t};\n\n\treturn Tone.TimelineState;\n});","'use strict';\n\ndefine(function(require) {\n var p5sound = require('master');\n\n var BPM = 120;\n\n /**\n * Set the global tempo, in beats per minute, for all\n * p5.Parts. This method will impact all active p5.Parts.\n *\n * @method setBPM\n * @for p5\n * @param {Number} BPM Beats Per Minute\n * @param {Number} rampTime Seconds from now\n */\n p5.prototype.setBPM = function(bpm, rampTime) {\n BPM = bpm;\n for (var i in p5sound.parts) {\n if (p5sound.parts[i]) {\n p5sound.parts[i].setBPM(bpm, rampTime);\n }\n }\n };\n\n /**\n *

A phrase is a pattern of musical events over time, i.e.\n * a series of notes and rests.

\n *\n *

Phrases must be added to a p5.Part for playback, and\n * each part can play multiple phrases at the same time.\n * For example, one Phrase might be a kick drum, another\n * could be a snare, and another could be the bassline.

\n *\n *

The first parameter is a name so that the phrase can be\n * modified or deleted later. The callback is a a function that\n * this phrase will call at every step—for example it might be\n * called playNote(value){}. The array determines\n * which value is passed into the callback at each step of the\n * phrase. It can be numbers, an object with multiple numbers,\n * or a zero (0) indicates a rest so the callback won't be called).

\n *\n * @class p5.Phrase\n * @constructor\n * @param {String} name Name so that you can access the Phrase.\n * @param {Function} callback The name of a function that this phrase\n * will call. Typically it will play a sound,\n * and accept two parameters: a time at which\n * to play the sound (in seconds from now),\n * and a value from the sequence array. The\n * time should be passed into the play() or\n * start() method to ensure precision.\n * @param {Array} sequence Array of values to pass into the callback\n * at each step of the phrase.\n * @example\n *
\n * let mySound, myPhrase, myPart;\n * let pattern = [1,0,0,2,0,2,0,0];\n *\n * function preload() {\n * mySound = loadSound('assets/beatbox.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playMyPart);\n * background(220);\n * text('tap to play', width/2, height/2);\n * textAlign(CENTER, CENTER);\n *\n * myPhrase = new p5.Phrase('bbox', onEachStep, pattern);\n * myPart = new p5.Part();\n * myPart.addPhrase(myPhrase);\n * myPart.setBPM(60);\n * }\n *\n * function onEachStep(time, playbackRate) {\n * mySound.rate(playbackRate);\n * mySound.play(time);\n * }\n *\n * function playMyPart() {\n * userStartAudio();\n * myPart.start();\n * }\n *
\n */\n p5.Phrase = function(name, callback, sequence) {\n this.phraseStep = 0;\n this.name = name;\n this.callback = callback;\n /**\n * Array of values to pass into the callback\n * at each step of the phrase. Depending on the callback\n * function's requirements, these values may be numbers,\n * strings, or an object with multiple parameters.\n * Zero (0) indicates a rest.\n *\n * @property {Array} sequence\n */\n this.sequence = sequence;\n };\n\n /**\n *

A p5.Part plays back one or more p5.Phrases. Instantiate a part\n * with steps and tatums. By default, each step represents a 1/16th note.

\n *\n *

See p5.Phrase for more about musical timing.

\n *\n * @class p5.Part\n * @constructor\n * @param {Number} [steps] Steps in the part\n * @param {Number} [tatums] Divisions of a beat, e.g. use 1/4, or 0.25 for a quater note (default is 1/16, a sixteenth note)\n * @example\n *
\n * let box, drum, myPart;\n * let boxPat = [1,0,0,2,0,2,0,0];\n * let drumPat = [0,1,1,0,2,0,1,0];\n *\n * function preload() {\n * box = loadSound('assets/beatbox.mp3');\n * drum = loadSound('assets/drum.mp3');\n * }\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(playMyPart);\n * background(220);\n * textAlign(CENTER, CENTER);\n * text('tap to play', width/2, height/2);\n *\n * let boxPhrase = new p5.Phrase('box', playBox, boxPat);\n * let drumPhrase = new p5.Phrase('drum', playDrum, drumPat);\n * myPart = new p5.Part();\n * myPart.addPhrase(boxPhrase);\n * myPart.addPhrase(drumPhrase);\n * myPart.setBPM(60);\n * }\n *\n * function playBox(time, playbackRate) {\n * box.rate(playbackRate);\n * box.play(time);\n * }\n *\n * function playDrum(time, playbackRate) {\n * drum.rate(playbackRate);\n * drum.play(time);\n * }\n *\n * function playMyPart() {\n * userStartAudio();\n *\n * myPart.start();\n * }\n *
\n */\n p5.Part = function(steps, bLength) {\n this.length = steps || 0; // how many beats\n this.partStep = 0;\n this.phrases = [];\n this.isPlaying = false;\n this.noLoop();\n this.tatums = bLength || 0.0625; // defaults to quarter note\n\n this.metro = new p5.Metro();\n this.metro._init();\n this.metro.beatLength(this.tatums);\n this.metro.setBPM(BPM);\n p5sound.parts.push(this);\n this.callback = function() {};\n };\n\n /**\n * Set the tempo of this part, in Beats Per Minute.\n *\n * @method setBPM\n * @for p5.Part\n * @param {Number} BPM Beats Per Minute\n * @param {Number} [rampTime] Seconds from now\n */\n p5.Part.prototype.setBPM = function(tempo, rampTime) {\n this.metro.setBPM(tempo, rampTime);\n };\n\n /**\n * Returns the tempo, in Beats Per Minute, of this part.\n *\n * @method getBPM\n * @for p5.Part\n * @return {Number}\n */\n p5.Part.prototype.getBPM = function() {\n return this.metro.getBPM();\n };\n\n /**\n * Start playback of this part. It will play\n * through all of its phrases at a speed\n * determined by setBPM.\n *\n * @method start\n * @for p5.Part\n * @param {Number} [time] seconds from now\n */\n p5.Part.prototype.start = function(time) {\n if (!this.isPlaying) {\n this.isPlaying = true;\n this.metro.resetSync(this);\n var t = time || 0;\n this.metro.start(t);\n }\n };\n\n /**\n * Loop playback of this part. It will begin\n * looping through all of its phrases at a speed\n * determined by setBPM.\n *\n * @method loop\n * @for p5.Part\n * @param {Number} [time] seconds from now\n */\n p5.Part.prototype.loop = function(time) {\n this.looping = true;\n // rest onended function\n this.onended = function() {\n this.partStep = 0;\n };\n var t = time || 0;\n this.start(t);\n };\n\n /**\n * Tell the part to stop looping.\n *\n * @method noLoop\n * @for p5.Part\n */\n p5.Part.prototype.noLoop = function() {\n this.looping = false;\n // rest onended function\n this.onended = function() {\n this.stop();\n };\n };\n\n /**\n * Stop the part and cue it to step 0. Playback will resume from the begining of the Part when it is played again.\n *\n * @method stop\n * @for p5.Part\n * @param {Number} [time] seconds from now\n */\n p5.Part.prototype.stop = function(time) {\n this.partStep = 0;\n this.pause(time);\n };\n\n /**\n * Pause the part. Playback will resume\n * from the current step.\n *\n * @method pause\n * @for p5.Part\n * @param {Number} time seconds from now\n */\n p5.Part.prototype.pause = function(time) {\n this.isPlaying = false;\n var t = time || 0;\n this.metro.stop(t);\n };\n\n /**\n * Add a p5.Phrase to this Part.\n *\n * @method addPhrase\n * @for p5.Part\n * @param {p5.Phrase} phrase reference to a p5.Phrase\n */\n p5.Part.prototype.addPhrase = function(name, callback, array) {\n var p;\n if (arguments.length === 3) {\n p = new p5.Phrase(name, callback, array);\n } else if (arguments[0] instanceof p5.Phrase) {\n p = arguments[0];\n } else {\n throw 'invalid input. addPhrase accepts name, callback, array or a p5.Phrase';\n }\n this.phrases.push(p);\n // reset the length if phrase is longer than part's existing length\n if (p.sequence.length > this.length) {\n this.length = p.sequence.length;\n }\n };\n\n /**\n * Remove a phrase from this part, based on the name it was\n * given when it was created.\n *\n * @method removePhrase\n * @for p5.Part\n * @param {String} phraseName\n */\n p5.Part.prototype.removePhrase = function(name) {\n for (var i in this.phrases) {\n if (this.phrases[i].name === name) {\n this.phrases.splice(i, 1);\n }\n }\n };\n\n /**\n * Get a phrase from this part, based on the name it was\n * given when it was created. Now you can modify its array.\n *\n * @method getPhrase\n * @for p5.Part\n * @param {String} phraseName\n */\n p5.Part.prototype.getPhrase = function(name) {\n for (var i in this.phrases) {\n if (this.phrases[i].name === name) {\n return this.phrases[i];\n }\n }\n };\n\n /**\n * Find all sequences with the specified name, and replace their patterns with the specified array.\n *\n * @method replaceSequence\n * @for p5.Part\n * @param {String} phraseName\n * @param {Array} sequence Array of values to pass into the callback\n * at each step of the phrase.\n */\n p5.Part.prototype.replaceSequence = function(name, array) {\n for (var i in this.phrases) {\n if (this.phrases[i].name === name) {\n this.phrases[i].sequence = array;\n }\n }\n };\n\n p5.Part.prototype.incrementStep = function(time) {\n if (this.partStep < this.length - 1) {\n this.callback(time);\n this.partStep += 1;\n } else {\n if (!this.looping && this.partStep === this.length - 1) {\n // this.callback(time);\n this.onended();\n }\n }\n };\n\n /**\n * Set the function that will be called at every step. This will clear the previous function.\n *\n * @method onStep\n * @for p5.Part\n * @param {Function} callback The name of the callback\n * you want to fire\n * on every beat/tatum.\n */\n p5.Part.prototype.onStep = function(callback) {\n this.callback = callback;\n };\n\n\n // ===============\n // p5.Score\n // ===============\n\n /**\n * A Score consists of a series of Parts. The parts will\n * be played back in order. For example, you could have an\n * A part, a B part, and a C part, and play them back in this order\n * new p5.Score(a, a, b, a, c)\n *\n * @class p5.Score\n * @constructor\n * @param {p5.Part} [...parts] One or multiple parts, to be played in sequence.\n */\n p5.Score = function() {\n // for all of the arguments\n this.parts = [];\n this.currentPart = 0;\n\n var thisScore = this;\n for (var i in arguments) {\n if (arguments[i] && this.parts[i]) {\n this.parts[i] = arguments[i];\n this.parts[i].nextPart = this.parts[i + 1];\n this.parts[i].onended = function() {\n thisScore.resetPart(i);\n playNextPart(thisScore);\n };\n }\n }\n this.looping = false;\n };\n\n p5.Score.prototype.onended = function() {\n if (this.looping) {\n // this.resetParts();\n this.parts[0].start();\n } else {\n this.parts[this.parts.length - 1].onended = function() {\n this.stop();\n this.resetParts();\n };\n }\n this.currentPart = 0;\n };\n\n /**\n * Start playback of the score.\n *\n * @method start\n * @for p5.Score\n */\n p5.Score.prototype.start = function() {\n this.parts[this.currentPart].start();\n this.scoreStep = 0;\n };\n\n /**\n * Stop playback of the score.\n *\n * @method stop\n * @for p5.Score\n */\n p5.Score.prototype.stop = function() {\n this.parts[this.currentPart].stop();\n this.currentPart = 0;\n this.scoreStep = 0;\n };\n\n /**\n * Pause playback of the score.\n *\n * @method pause\n * @for p5.Score\n */\n p5.Score.prototype.pause = function() {\n this.parts[this.currentPart].stop();\n };\n\n /**\n * Loop playback of the score.\n *\n * @method loop\n * @for p5.Score\n */\n p5.Score.prototype.loop = function() {\n this.looping = true;\n this.start();\n };\n\n /**\n * Stop looping playback of the score. If it\n * is currently playing, this will go into effect\n * after the current round of playback completes.\n *\n * @method noLoop\n * @for p5.Score\n */\n p5.Score.prototype.noLoop = function() {\n this.looping = false;\n };\n\n p5.Score.prototype.resetParts = function() {\n var self = this;\n this.parts.forEach(function(part) {\n self.resetParts[part];\n });\n };\n\n p5.Score.prototype.resetPart = function(i) {\n this.parts[i].stop();\n this.parts[i].partStep = 0;\n for (var p in this.parts[i].phrases) {\n if (this.parts[i]) {\n this.parts[i].phrases[p].phraseStep = 0;\n }\n }\n };\n\n /**\n * Set the tempo for all parts in the score\n *\n * @method setBPM\n * @for p5.Score\n * @param {Number} BPM Beats Per Minute\n * @param {Number} rampTime Seconds from now\n */\n p5.Score.prototype.setBPM = function(bpm, rampTime) {\n for (var i in this.parts) {\n if (this.parts[i]) {\n this.parts[i].setBPM(bpm, rampTime);\n }\n }\n };\n\n function playNextPart(aScore) {\n aScore.currentPart++;\n if (aScore.currentPart >= aScore.parts.length) {\n aScore.scoreStep = 0;\n aScore.onended();\n } else {\n aScore.scoreStep = 0;\n aScore.parts[aScore.currentPart - 1].stop();\n aScore.parts[aScore.currentPart].start();\n }\n }\n\n});\n","'use strict';\n\ndefine(function (require) {\n var p5sound = require('master');\n var Clock = require('Tone/core/Clock');\n\n /**\n * SoundLoop\n *\n * @class p5.SoundLoop\n * @constructor\n *\n * @param {Function} callback this function will be called on each iteration of theloop\n * @param {Number|String} [interval] amount of time (if a number) or beats (if a string, following Tone.Time convention) for each iteration of the loop. Defaults to 1 second.\n *\n * @example\n *
\n * let synth, soundLoop;\n * let notePattern = [60, 62, 64, 67, 69, 72];\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * colorMode(HSB);\n * background(0, 0, 86);\n * text('tap to start/stop', 10, 20);\n *\n * //the looper's callback is passed the timeFromNow\n * //this value should be used as a reference point from\n * //which to schedule sounds\n * let intervalInSeconds = 0.2;\n * soundLoop = new p5.SoundLoop(onSoundLoop, intervalInSeconds);\n *\n * synth = new p5.MonoSynth();\n * }\n *\n * function canvasPressed() {\n * // ensure audio is enabled\n * userStartAudio();\n *\n * if (soundLoop.isPlaying) {\n * soundLoop.stop();\n * } else {\n * // start the loop\n * soundLoop.start();\n * }\n * }\n *\n * function onSoundLoop(timeFromNow) {\n * let noteIndex = (soundLoop.iterations - 1) % notePattern.length;\n * let note = midiToFreq(notePattern[noteIndex]);\n * synth.play(note, 0.5, timeFromNow);\n * background(noteIndex * 360 / notePattern.length, 50, 100);\n * }\n *
\n */\n p5.SoundLoop = function(callback, interval) {\n this.callback = callback;\n /**\n * musicalTimeMode uses Tone.Time convention\n * true if string, false if number\n * @property {Boolean} musicalTimeMode\n */\n this.musicalTimeMode = typeof this._interval === 'number' ? false : true;\n\n this._interval = interval || 1;\n\n /**\n * musicalTimeMode variables\n * modify these only when the interval is specified in musicalTime format as a string\n */\n this._timeSignature = 4;\n this._bpm = 60;\n\n this.isPlaying = false;\n\n /**\n * Set a limit to the number of loops to play. defaults to Infinity\n * @property {Number} maxIterations\n */\n this.maxIterations = Infinity;\n var self = this;\n\n this.clock = new Clock({\n 'callback' : function(time) {\n var timeFromNow = time - p5sound.audiocontext.currentTime;\n /**\n * Do not initiate the callback if timeFromNow is < 0\n * This ususually occurs for a few milliseconds when the page\n * is not fully loaded\n *\n * The callback should only be called until maxIterations is reached\n */\n if (timeFromNow > 0 && self.iterations <= self.maxIterations) {\n self.callback(timeFromNow);}\n },\n 'frequency' : this._calcFreq()\n });\n };\n\n /**\n * Start the loop\n * @method start\n * @for p5.SoundLoop\n * @param {Number} [timeFromNow] schedule a starting time\n */\n p5.SoundLoop.prototype.start = function(timeFromNow) {\n var t = timeFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n if (!this.isPlaying) {\n this.clock.start(now + t);\n this.isPlaying = true;\n }\n };\n\n /**\n * Stop the loop\n * @method stop\n * @for p5.SoundLoop\n * @param {Number} [timeFromNow] schedule a stopping time\n */\n p5.SoundLoop.prototype.stop = function(timeFromNow) {\n var t = timeFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n if (this.isPlaying) {\n this.clock.stop(now + t);\n this.isPlaying = false;\n }\n };\n /**\n * Pause the loop\n * @method pause\n * @for p5.SoundLoop\n * @param {Number} [timeFromNow] schedule a pausing time\n */\n p5.SoundLoop.prototype.pause = function(timeFromNow) {\n var t = timeFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n if (this.isPlaying) {\n this.clock.pause(now + t);\n this.isPlaying = false;\n }\n };\n\n\n /**\n * Synchronize loops. Use this method to start two or more loops in synchronization\n * or to start a loop in synchronization with a loop that is already playing\n * This method will schedule the implicit loop in sync with the explicit master loop\n * i.e. loopToStart.syncedStart(loopToSyncWith)\n *\n * @method syncedStart\n * @for p5.SoundLoop\n * @param {Object} otherLoop a p5.SoundLoop to sync with\n * @param {Number} [timeFromNow] Start the loops in sync after timeFromNow seconds\n */\n p5.SoundLoop.prototype.syncedStart = function(otherLoop, timeFromNow) {\n var t = timeFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n\n if (!otherLoop.isPlaying) {\n otherLoop.clock.start(now + t);\n otherLoop.isPlaying = true;\n this.clock.start(now + t);\n this.isPlaying = true;\n } else if (otherLoop.isPlaying) {\n var time = otherLoop.clock._nextTick - p5sound.audiocontext.currentTime;\n this.clock.start(now + time);\n this.isPlaying = true;\n }\n };\n\n\n /**\n * Updates frequency value, reflected in next callback\n * @private\n * @for p5.SoundLoop\n * @method _update\n */\n p5.SoundLoop.prototype._update = function() {\n this.clock.frequency.value = this._calcFreq();\n };\n\n /**\n * Calculate the frequency of the clock's callback based on bpm, interval, and timesignature\n * @private\n * @for p5.SoundLoop\n * @method _calcFreq\n * @return {Number} new clock frequency value\n */\n p5.SoundLoop.prototype._calcFreq = function() {\n //Seconds mode, bpm / timesignature has no effect\n if (typeof this._interval === 'number') {\n this.musicalTimeMode = false;\n return 1 / this._interval;\n }\n //Musical timing mode, calculate interval based bpm, interval,and time signature\n else if (typeof this._interval === 'string') {\n this.musicalTimeMode = true;\n return this._bpm / 60 / this._convertNotation(this._interval) * (this._timeSignature / 4);\n }\n };\n\n /**\n * Convert notation from musical time format to seconds\n * Uses Tone.Time convention\n * @private\n * @for p5.SoundLoop\n * @method _convertNotation\n * @param {String} value value to be converted\n * @return {Number} converted value in seconds\n */\n p5.SoundLoop.prototype._convertNotation = function(value) {\n var type = value.slice(-1);\n value = Number(value.slice(0,-1));\n switch (type) {\n case 'm':\n return this._measure(value);\n case 'n':\n return this._note(value);\n default:\n console.warn('Specified interval is not formatted correctly. See Tone.js '+\n 'timing reference for more info: https://github.com/Tonejs/Tone.js/wiki/Time');\n }\n };\n\n /**\n * Helper conversion methods of measure and note\n * @private\n * @for p5.SoundLoop\n * @method _measure\n */\n p5.SoundLoop.prototype._measure = function(value) {\n return value * this._timeSignature;\n };\n\n /**\n * @private\n * @method _note\n * @for p5.SoundLoop\n */\n p5.SoundLoop.prototype._note = function(value) {\n return this._timeSignature / value ;\n };\n\n\n /**\n * Getters and Setters, setting any paramter will result in a change in the clock's\n * frequency, that will be reflected after the next callback\n * beats per minute (defaults to 60)\n * @property {Number} bpm\n * @for p5.SoundLoop\n */\n Object.defineProperty(p5.SoundLoop.prototype, 'bpm', {\n get : function() {\n return this._bpm;\n },\n set : function(bpm) {\n if (!this.musicalTimeMode) {\n console.warn('Changing the BPM in \"seconds\" mode has no effect. '+\n 'BPM is only relevant in musicalTimeMode '+\n 'when the interval is specified as a string '+\n '(\"2n\", \"4n\", \"1m\"...etc)');\n }\n this._bpm = bpm;\n this._update();\n }\n });\n\n /**\n * number of quarter notes in a measure (defaults to 4)\n * @property {Number} timeSignature\n * @for p5.SoundLoop\n */\n Object.defineProperty(p5.SoundLoop.prototype, 'timeSignature', {\n get : function() {\n return this._timeSignature;\n },\n set : function(timeSig) {\n if (!this.musicalTimeMode) {\n console.warn('Changing the timeSignature in \"seconds\" mode has no effect. '+\n 'BPM is only relevant in musicalTimeMode '+\n 'when the interval is specified as a string '+\n '(\"2n\", \"4n\", \"1m\"...etc)');\n }\n this._timeSignature = timeSig;\n this._update();\n }\n });\n\n /**\n * length of the loops interval\n * @property {Number|String} interval\n * @for p5.SoundLoop\n */\n Object.defineProperty(p5.SoundLoop.prototype, 'interval', {\n get : function() {\n return this._interval;\n },\n set : function(interval) {\n this.musicalTimeMode = typeof interval === 'Number'? false : true;\n this._interval = interval;\n this._update();\n }\n });\n\n /**\n * how many times the callback has been called so far\n * @property {Number} iterations\n * @for p5.SoundLoop\n * @readonly\n */\n Object.defineProperty(p5.SoundLoop.prototype, 'iterations', {\n get : function() {\n return this.clock.ticks;\n }\n });\n\n return p5.SoundLoop;\n});\n","define(function (require) {\n\t'use strict';\n\n\tvar p5sound = require('master');\n\tvar Effect = require('effect');\n var CustomError = require('errorHandler');\n\n /**\n * Compressor is an audio effect class that performs dynamics compression\n * on an audio input source. This is a very commonly used technique in music\n * and sound production. Compression creates an overall louder, richer,\n * and fuller sound by lowering the volume of louds and raising that of softs.\n * Compression can be used to avoid clipping (sound distortion due to\n * peaks in volume) and is especially useful when many sounds are played\n * at once. Compression can be used on indivudal sound sources in addition\n * to the master output.\n *\n * This class extends p5.Effect.\n * Methods amp(), chain(),\n * drywet(), connect(), and\n * disconnect() are available.\n *\n * @class p5.Compressor\n * @constructor\n * @extends p5.Effect\n *\n *\n */\n\tp5.Compressor = function() {\n\t\tEffect.call(this);\n\n /**\n * The p5.Compressor is built with a Web Audio Dynamics Compressor Node\n * \n * @property {AudioNode} compressor\n */\n\n\n\t\tthis.compressor = this.ac.createDynamicsCompressor();\n\n this.input.connect(this.compressor);\n this.compressor.connect(this.wet);\n\t};\n\n\tp5.Compressor.prototype = Object.create(Effect.prototype);\n\n /**\n * Performs the same function as .connect, but also accepts\n * optional parameters to set compressor's audioParams\n * @method process\n * @for p5.Compressor\n *\n * @param {Object} src Sound source to be connected\n *\n * @param {Number} [attack] The amount of time (in seconds) to reduce the gain by 10dB,\n * default = .003, range 0 - 1\n * @param {Number} [knee] A decibel value representing the range above the\n * threshold where the curve smoothly transitions to the \"ratio\" portion.\n * default = 30, range 0 - 40\n * @param {Number} [ratio] The amount of dB change in input for a 1 dB change in output\n * default = 12, range 1 - 20\n * @param {Number} [threshold] The decibel value above which the compression will start taking effect\n * default = -24, range -100 - 0\n * @param {Number} [release] The amount of time (in seconds) to increase the gain by 10dB\n * default = .25, range 0 - 1\n */\n\tp5.Compressor.prototype.process = function(src, attack, knee,\n ratio, threshold, release) {\n\t\tsrc.connect(this.input);\n\t\tthis.set(attack, knee, ratio, threshold, release);\n\t};\n\n /**\n * Set the paramters of a compressor.\n * @method set\n * @for p5.Compressor\n * @param {Number} attack The amount of time (in seconds) to reduce the gain by 10dB,\n * default = .003, range 0 - 1\n * @param {Number} knee A decibel value representing the range above the\n * threshold where the curve smoothly transitions to the \"ratio\" portion.\n * default = 30, range 0 - 40\n * @param {Number} ratio The amount of dB change in input for a 1 dB change in output\n * default = 12, range 1 - 20\n * @param {Number} threshold The decibel value above which the compression will start taking effect\n * default = -24, range -100 - 0\n * @param {Number} release The amount of time (in seconds) to increase the gain by 10dB\n * default = .25, range 0 - 1\n */\n p5.Compressor.prototype.set = function (attack, knee,\n ratio, threshold, release) {\n\n if (typeof attack !== 'undefined') {this.attack(attack);}\n if (typeof knee !== 'undefined') {this.knee(knee);}\n if (typeof ratio !== 'undefined') {this.ratio(ratio);}\n if (typeof threshold !== 'undefined') {this.threshold(threshold);}\n if (typeof release !== 'undefined') {this.release(release);}\n };\n\n\n /**\n * Get current attack or set value w/ time ramp\n *\n *\n * @method attack\n * @for p5.Compressor\n * @param {Number} [attack] Attack is the amount of time (in seconds) to reduce the gain by 10dB,\n * default = .003, range 0 - 1\n * @param {Number} [time] Assign time value to schedule the change in value\n */\n p5.Compressor.prototype.attack = function (attack, time){\n var t = time || 0;\n if (typeof attack == 'number'){\n this.compressor.attack.value = attack;\n this.compressor.attack.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.compressor.attack.linearRampToValueAtTime(attack, this.ac.currentTime + 0.02 + t);\n } else if (typeof attack !== 'undefined') {\n attack.connect(this.compressor.attack);\n }\n return this.compressor.attack.value;\n };\n\n\n /**\n * Get current knee or set value w/ time ramp\n *\n * @method knee\n * @for p5.Compressor\n * @param {Number} [knee] A decibel value representing the range above the\n * threshold where the curve smoothly transitions to the \"ratio\" portion.\n * default = 30, range 0 - 40\n * @param {Number} [time] Assign time value to schedule the change in value\n */\n p5.Compressor.prototype.knee = function (knee, time){\n var t = time || 0;\n if (typeof knee == 'number'){\n this.compressor.knee.value = knee;\n this.compressor.knee.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.compressor.knee.linearRampToValueAtTime(knee, this.ac.currentTime + 0.02 + t);\n } else if (typeof knee !== 'undefined') {\n knee.connect(this.compressor.knee);\n }\n return this.compressor.knee.value;\n };\n\n\n /**\n * Get current ratio or set value w/ time ramp\n * @method ratio\n * @for p5.Compressor\n * @param {Number} [ratio] The amount of dB change in input for a 1 dB change in output\n * default = 12, range 1 - 20\n * @param {Number} [time] Assign time value to schedule the change in value\n */\n p5.Compressor.prototype.ratio = function (ratio, time){\n var t = time || 0;\n if (typeof ratio == 'number'){\n this.compressor.ratio.value = ratio;\n this.compressor.ratio.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.compressor.ratio.linearRampToValueAtTime(ratio, this.ac.currentTime + 0.02 + t);\n } else if (typeof ratio !== 'undefined') {\n ratio.connect(this.compressor.ratio);\n }\n return this.compressor.ratio.value;\n };\n\n\n /**\n * Get current threshold or set value w/ time ramp\n * @method threshold\n * @for p5.Compressor\n * @param {Number} threshold The decibel value above which the compression will start taking effect\n * default = -24, range -100 - 0\n * @param {Number} [time] Assign time value to schedule the change in value\n */\n p5.Compressor.prototype.threshold = function (threshold, time){\n var t = time || 0;\n if (typeof threshold == 'number'){\n this.compressor.threshold.value = threshold;\n this.compressor.threshold.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.compressor.threshold.linearRampToValueAtTime(threshold, this.ac.currentTime + 0.02 + t);\n } else if (typeof threshold !== 'undefined') {\n threshold.connect(this.compressor.threshold);\n }\n return this.compressor.threshold.value;\n };\n\n\n /**\n * Get current release or set value w/ time ramp\n * @method release\n * @for p5.Compressor\n * @param {Number} release The amount of time (in seconds) to increase the gain by 10dB\n * default = .25, range 0 - 1\n *\n * @param {Number} [time] Assign time value to schedule the change in value\n */\n p5.Compressor.prototype.release = function (release, time){\n var t = time || 0;\n if (typeof release == 'number'){\n this.compressor.release.value = release;\n this.compressor.release.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\n this.compressor.release.linearRampToValueAtTime(release, this.ac.currentTime + 0.02 + t);\n } else if (typeof number !== 'undefined') {\n release.connect(this.compressor.release);\n }\n return this.compressor.release.value;\n };\n\n /**\n * Return the current reduction value\n *\n * @method reduction\n * @for p5.Compressor\n * @return {Number} Value of the amount of gain reduction that is applied to the signal\n */\n p5.Compressor.prototype.reduction =function() {\n return this.compressor.reduction.value;\n };\n\n\n\tp5.Compressor.prototype.dispose = function() {\n Effect.prototype.dispose.apply(this);\n if (this.compressor) {\n this.compressor.disconnect();\n delete this.compressor;\n }\n\t};\n\n return p5.Compressor;\n});\n","'use strict';\n\ndefine(function (require) {\n\n // inspiration: recorder.js, Tone.js & typedarray.org\n\n const p5sound = require('master');\n const { convertToWav, safeBufferSize } = require('helpers');\n const processorNames = require('./audioWorklet/processorNames');\n const ac = p5sound.audiocontext;\n\n /**\n *

Record sounds for playback and/or to save as a .wav file.\n * The p5.SoundRecorder records all sound output from your sketch,\n * or can be assigned a specific source with setInput().

\n *

The record() method accepts a p5.SoundFile as a parameter.\n * When playback is stopped (either after the given amount of time,\n * or with the stop() method), the p5.SoundRecorder will send its\n * recording to that p5.SoundFile for playback.

\n *\n * @class p5.SoundRecorder\n * @constructor\n * @example\n *
\n * let mic, recorder, soundFile;\n * let state = 0;\n *\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(canvasPressed);\n * background(220);\n * textAlign(CENTER, CENTER);\n *\n * // create an audio in\n * mic = new p5.AudioIn();\n *\n * // prompts user to enable their browser mic\n * mic.start();\n *\n * // create a sound recorder\n * recorder = new p5.SoundRecorder();\n *\n * // connect the mic to the recorder\n * recorder.setInput(mic);\n *\n * // this sound file will be used to\n * // playback & save the recording\n * soundFile = new p5.SoundFile();\n *\n * text('tap to record', width/2, height/2);\n * }\n *\n * function canvasPressed() {\n * // ensure audio is enabled\n * userStartAudio();\n *\n * // make sure user enabled the mic\n * if (state === 0 && mic.enabled) {\n *\n * // record to our p5.SoundFile\n * recorder.record(soundFile);\n *\n * background(255,0,0);\n * text('Recording!', width/2, height/2);\n * state++;\n * }\n * else if (state === 1) {\n * background(0,255,0);\n *\n * // stop recorder and\n * // send result to soundFile\n * recorder.stop();\n *\n * text('Done! Tap to play and download', width/2, height/2, width - 20);\n * state++;\n * }\n *\n * else if (state === 2) {\n * soundFile.play(); // play the result!\n * save(soundFile, 'mySound.wav');\n * state++;\n * }\n * }\n *
\n */\n p5.SoundRecorder = function() {\n this.input = ac.createGain();\n this.output = ac.createGain();\n\n this._inputChannels = 2;\n this._outputChannels = 2; // stereo output, even if input is mono\n\n const workletBufferSize = safeBufferSize(1024);\n\n this._workletNode = new AudioWorkletNode(ac, processorNames.recorderProcessor, {\n outputChannelCount: [this._outputChannels],\n processorOptions: {\n numInputChannels: this._inputChannels,\n bufferSize: workletBufferSize\n }\n });\n\n this._workletNode.port.onmessage = function(event) {\n if (event.data.name === 'buffers') {\n const buffers = [\n new Float32Array(event.data.leftBuffer),\n new Float32Array(event.data.rightBuffer)\n ];\n this._callback(buffers);\n }\n }.bind(this);\n\n /**\n * callback invoked when the recording is over\n * @private\n * @type Function(Float32Array)\n */\n this._callback = function() {};\n\n // connections\n this._workletNode.connect(p5.soundOut._silentNode);\n this.setInput();\n\n // add this p5.SoundFile to the soundArray\n p5sound.soundArray.push(this);\n };\n\n /**\n * Connect a specific device to the p5.SoundRecorder.\n * If no parameter is given, p5.SoundRecorer will record\n * all audible p5.sound from your sketch.\n *\n * @method setInput\n * @for p5.SoundRecorder\n * @param {Object} [unit] p5.sound object or a web audio unit\n * that outputs sound\n */\n p5.SoundRecorder.prototype.setInput = function(unit) {\n this.input.disconnect();\n this.input = null;\n this.input = ac.createGain();\n this.input.connect(this._workletNode);\n this.input.connect(this.output);\n if (unit) {\n unit.connect(this.input);\n } else {\n p5.soundOut.output.connect(this.input);\n }\n };\n\n /**\n * Start recording. To access the recording, provide\n * a p5.SoundFile as the first parameter. The p5.SoundRecorder\n * will send its recording to that p5.SoundFile for playback once\n * recording is complete. Optional parameters include duration\n * (in seconds) of the recording, and a callback function that\n * will be called once the complete recording has been\n * transfered to the p5.SoundFile.\n *\n * @method record\n * @for p5.SoundRecorder\n * @param {p5.SoundFile} soundFile p5.SoundFile\n * @param {Number} [duration] Time (in seconds)\n * @param {Function} [callback] The name of a function that will be\n * called once the recording completes\n */\n p5.SoundRecorder.prototype.record = function(sFile, duration, callback) {\n this._workletNode.port.postMessage({ name: 'start', duration: duration });\n\n if (sFile && callback) {\n this._callback = function(buffer) {\n sFile.setBuffer(buffer);\n callback();\n };\n }\n else if (sFile) {\n this._callback = function(buffer) {\n sFile.setBuffer(buffer);\n };\n }\n };\n\n /**\n * Stop the recording. Once the recording is stopped,\n * the results will be sent to the p5.SoundFile that\n * was given on .record(), and if a callback function\n * was provided on record, that function will be called.\n *\n * @method stop\n * @for p5.SoundRecorder\n */\n p5.SoundRecorder.prototype.stop = function() {\n this._workletNode.port.postMessage({ name: 'stop' });\n };\n\n p5.SoundRecorder.prototype.dispose = function() {\n // remove reference from soundArray\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n\n this._callback = function() {};\n if (this.input) {\n this.input.disconnect();\n }\n this.input = null;\n this._workletNode = null;\n };\n\n\n /**\n * Save a p5.SoundFile as a .wav file. The browser will prompt the user\n * to download the file to their device.\n * For uploading audio to a server, use\n * `p5.SoundFile.saveBlob`.\n *\n * @for p5\n * @method saveSound\n * @param {p5.SoundFile} soundFile p5.SoundFile that you wish to save\n * @param {String} fileName name of the resulting .wav file.\n */\n // add to p5.prototype as this is used by the p5 `save()` method.\n p5.prototype.saveSound = function (soundFile, fileName) {\n const dataView = convertToWav(soundFile.buffer);\n p5.prototype.writeFile([dataView], fileName, 'wav');\n };\n});\n","'use strict';\n\ndefine(function () {\n /**\n *

PeakDetect works in conjunction with p5.FFT to\n * look for onsets in some or all of the frequency spectrum.\n *

\n *

\n * To use p5.PeakDetect, call update in the draw loop\n * and pass in a p5.FFT object.\n *

\n *

\n * You can listen for a specific part of the frequency spectrum by\n * setting the range between freq1 and freq2.\n *

\n *\n *

threshold is the threshold for detecting a peak,\n * scaled between 0 and 1. It is logarithmic, so 0.1 is half as loud\n * as 1.0.

\n *\n *

\n * The update method is meant to be run in the draw loop, and\n * frames determines how many loops must pass before\n * another peak can be detected.\n * For example, if the frameRate() = 60, you could detect the beat of a\n * 120 beat-per-minute song with this equation:\n * framesPerPeak = 60 / (estimatedBPM / 60 );\n *

\n *\n *

\n * Based on example contribtued by @b2renger, and a simple beat detection\n * explanation by Felix Turner.\n *

\n *\n * @class p5.PeakDetect\n * @constructor\n * @param {Number} [freq1] lowFrequency - defaults to 20Hz\n * @param {Number} [freq2] highFrequency - defaults to 20000 Hz\n * @param {Number} [threshold] Threshold for detecting a beat between 0 and 1\n * scaled logarithmically where 0.1 is 1/2 the loudness\n * of 1.0. Defaults to 0.35.\n * @param {Number} [framesPerPeak] Defaults to 20.\n * @example\n *
\n *\n * var cnv, soundFile, fft, peakDetect;\n * var ellipseWidth = 10;\n *\n * function preload() {\n * soundFile = loadSound('assets/beat.mp3');\n * }\n *\n * function setup() {\n * background(0);\n * noStroke();\n * fill(255);\n * textAlign(CENTER);\n *\n * // p5.PeakDetect requires a p5.FFT\n * fft = new p5.FFT();\n * peakDetect = new p5.PeakDetect();\n * }\n *\n * function draw() {\n * background(0);\n * text('click to play/pause', width/2, height/2);\n *\n * // peakDetect accepts an fft post-analysis\n * fft.analyze();\n * peakDetect.update(fft);\n *\n * if ( peakDetect.isDetected ) {\n * ellipseWidth = 50;\n * } else {\n * ellipseWidth *= 0.95;\n * }\n *\n * ellipse(width/2, height/2, ellipseWidth, ellipseWidth);\n * }\n *\n * // toggle play/stop when canvas is clicked\n * function mouseClicked() {\n * if (mouseX > 0 && mouseX < width && mouseY > 0 && mouseY < height) {\n * if (soundFile.isPlaying() ) {\n * soundFile.stop();\n * } else {\n * soundFile.play();\n * }\n * }\n * }\n *
\n */\n p5.PeakDetect = function(freq1, freq2, threshold, _framesPerPeak) {\n // framesPerPeak determines how often to look for a beat.\n // If a beat is provided, try to look for a beat based on bpm\n this.framesPerPeak = _framesPerPeak || 20;\n this.framesSinceLastPeak = 0;\n this.decayRate = 0.95;\n\n this.threshold = threshold || 0.35;\n this.cutoff = 0;\n\n // how much to increase the cutoff\n // TO DO: document this / figure out how to make it accessible\n this.cutoffMult = 1.5;\n\n this.energy = 0;\n this.penergy = 0;\n\n // TO DO: document this property / figure out how to make it accessible\n this.currentValue = 0;\n\n /**\n * isDetected is set to true when a peak is detected.\n *\n * @attribute isDetected {Boolean}\n * @default false\n */\n this.isDetected = false;\n\n this.f1 = freq1 || 40;\n this.f2 = freq2 || 20000;\n\n // function to call when a peak is detected\n this._onPeak = function() {};\n };\n\n\n /**\n * The update method is run in the draw loop.\n *\n * Accepts an FFT object. You must call .analyze()\n * on the FFT object prior to updating the peakDetect\n * because it relies on a completed FFT analysis.\n *\n * @method update\n * @param {p5.FFT} fftObject A p5.FFT object\n */\n p5.PeakDetect.prototype.update = function(fftObject) {\n var nrg = this.energy = fftObject.getEnergy(this.f1,this.f2)/255;\n if (nrg > this.cutoff && nrg > this.threshold && nrg-this.penergy > 0) {\n\n // trigger callback\n this._onPeak();\n this.isDetected = true;\n\n // debounce\n this.cutoff = nrg * this.cutoffMult;\n this.framesSinceLastPeak = 0;\n } else {\n this.isDetected = false;\n if (this.framesSinceLastPeak <= this.framesPerPeak) {\n this.framesSinceLastPeak++;\n } else {\n this.cutoff *= this.decayRate;\n this.cutoff = Math.max(this.cutoff, this.threshold);\n }\n }\n\n this.currentValue = nrg;\n this.penergy = nrg;\n };\n\n /**\n * onPeak accepts two arguments: a function to call when\n * a peak is detected. The value of the peak,\n * between 0.0 and 1.0, is passed to the callback.\n *\n * @method onPeak\n * @param {Function} callback Name of a function that will\n * be called when a peak is\n * detected.\n * @param {Object} [val] Optional value to pass\n * into the function when\n * a peak is detected.\n * @example\n *
\n * var cnv, soundFile, fft, peakDetect;\n * var ellipseWidth = 0;\n *\n * function preload() {\n * soundFile = loadSound('assets/beat.mp3');\n * }\n *\n * function setup() {\n * cnv = createCanvas(100,100);\n * textAlign(CENTER);\n *\n * fft = new p5.FFT();\n * peakDetect = new p5.PeakDetect();\n *\n * setupSound();\n *\n * // when a beat is detected, call triggerBeat()\n * peakDetect.onPeak(triggerBeat);\n * }\n *\n * function draw() {\n * background(0);\n * fill(255);\n * text('click to play', width/2, height/2);\n *\n * fft.analyze();\n * peakDetect.update(fft);\n *\n * ellipseWidth *= 0.95;\n * ellipse(width/2, height/2, ellipseWidth, ellipseWidth);\n * }\n *\n * // this function is called by peakDetect.onPeak\n * function triggerBeat() {\n * ellipseWidth = 50;\n * }\n *\n * // mouseclick starts/stops sound\n * function setupSound() {\n * cnv.mouseClicked( function() {\n * if (soundFile.isPlaying() ) {\n * soundFile.stop();\n * } else {\n * soundFile.play();\n * }\n * });\n * }\n *
\n */\n p5.PeakDetect.prototype.onPeak = function(callback, val) {\n var self = this;\n\n self._onPeak = function() {\n callback(self.energy, val);\n };\n };\n\n});\n","'use strict';\n\ndefine(function (require) {\n var p5sound = require('master');\n\n /**\n * A gain node is usefull to set the relative volume of sound.\n * It's typically used to build mixers.\n *\n * @class p5.Gain\n * @constructor\n * @example\n *
\n *\n * // load two soundfile and crossfade beetween them\n * let sound1,sound2;\n * let sound1Gain, sound2Gain, masterGain;\n * function preload(){\n * soundFormats('ogg', 'mp3');\n * sound1 = loadSound('assets/Damscray_-_Dancing_Tiger_01');\n * sound2 = loadSound('assets/beat');\n * }\n * function setup() {\n * let cnv = createCanvas(100, 100);\n * cnv.mousePressed(startSound);\n * // create a 'master' gain to which we will connect both soundfiles\n * masterGain = new p5.Gain();\n * masterGain.connect();\n * sound1.disconnect(); // diconnect from p5 output\n * sound1Gain = new p5.Gain(); // setup a gain node\n * sound1Gain.setInput(sound1); // connect the first sound to its input\n * sound1Gain.connect(masterGain); // connect its output to the 'master'\n * sound2.disconnect();\n * sound2Gain = new p5.Gain();\n * sound2Gain.setInput(sound2);\n * sound2Gain.connect(masterGain);\n * }\n * function startSound() {\n * sound1.loop();\n * sound2.loop();\n * loop();\n * }\n * function mouseReleased() {\n * sound1.stop();\n * sound2.stop();\n * }\n * function draw(){\n * background(220);\n * textAlign(CENTER);\n * textSize(11);\n * fill(0);\n * if (!sound1.isPlaying()) {\n * text('tap and drag to play', width/2, height/2);\n * return;\n * }\n * // map the horizontal position of the mouse to values useable for volume * control of sound1\n * var sound1Volume = constrain(map(mouseX,width,0,0,1), 0, 1);\n * var sound2Volume = 1-sound1Volume;\n * sound1Gain.amp(sound1Volume);\n * sound2Gain.amp(sound2Volume);\n * // map the vertical position of the mouse to values useable for 'master * volume control'\n * var masterVolume = constrain(map(mouseY,height,0,0,1), 0, 1);\n * masterGain.amp(masterVolume);\n * text('master', width/2, height - masterVolume * height * 0.9)\n * fill(255, 0, 255);\n * textAlign(LEFT);\n * text('sound1', 5, height - sound1Volume * height * 0.9);\n * textAlign(RIGHT);\n * text('sound2', width - 5, height - sound2Volume * height * 0.9);\n * }\n *
\n */\n\n p5.Gain = function() {\n this.ac = p5sound.audiocontext;\n\n this.input = this.ac.createGain();\n this.output = this.ac.createGain();\n\n // otherwise, Safari distorts\n this.input.gain.value = 0.5;\n this.input.connect(this.output);\n\n // add to the soundArray\n p5sound.soundArray.push(this);\n };\n\n /**\n * Connect a source to the gain node.\n *\n * @method setInput\n * @for p5.Gain\n * @param {Object} src p5.sound / Web Audio object with a sound\n * output.\n */\n\n\n p5.Gain.prototype.setInput = function(src) {\n src.connect(this.input);\n };\n\n /**\n * Send output to a p5.sound or web audio object\n *\n * @method connect\n * @for p5.Gain\n * @param {Object} unit\n */\n p5.Gain.prototype.connect = function(unit) {\n var u = unit || p5.soundOut.input;\n this.output.connect(u.input ? u.input : u);\n };\n\n /**\n * Disconnect all output.\n *\n * @method disconnect\n * @for p5.Gain\n */\n p5.Gain.prototype.disconnect = function() {\n if (this.output) {\n this.output.disconnect();\n }\n };\n\n /**\n * Set the output level of the gain node.\n *\n * @method amp\n * @for p5.Gain\n * @param {Number} volume amplitude between 0 and 1.0\n * @param {Number} [rampTime] create a fade that lasts rampTime\n * @param {Number} [timeFromNow] schedule this event to happen\n * seconds from now\n */\n p5.Gain.prototype.amp = function(vol, rampTime, tFromNow) {\n var rampTime = rampTime || 0;\n var tFromNow = tFromNow || 0;\n var now = p5sound.audiocontext.currentTime;\n var currentVol = this.output.gain.value;\n this.output.gain.cancelScheduledValues(now);\n this.output.gain.linearRampToValueAtTime(currentVol, now + tFromNow);\n this.output.gain.linearRampToValueAtTime(vol, now + tFromNow + rampTime);\n };\n\n p5.Gain.prototype.dispose = function() {\n // remove reference from soundArray\n var index = p5sound.soundArray.indexOf(this);\n p5sound.soundArray.splice(index, 1);\n if (this.output) {\n this.output.disconnect();\n delete this.output;\n }\n if (this.input) {\n this.input.disconnect();\n delete this.input;\n }\n };\n\n});\n","'use strict';\n\ndefine(function (require) {\n\n var Effect = require('effect');\n\n /*\n * Adapted from [Kevin Ennis on StackOverflow](http://stackoverflow.com/questions/22312841/waveshaper-node-in-webaudio-how-to-emulate-distortion)\n */\n function makeDistortionCurve(amount) {\n var k = typeof amount === 'number' ? amount : 50;\n var numSamples = 44100;\n var curve = new Float32Array(numSamples);\n var deg = Math.PI / 180;\n var i = 0;\n var x;\n for ( ; i < numSamples; ++i ) {\n x = i * 2 / numSamples - 1;\n curve[i] = ( 3 + k ) * x * 20 * deg / ( Math.PI + k * Math.abs(x) );\n }\n return curve;\n }\n\n /**\n * A Distortion effect created with a Waveshaper Node,\n * with an approach adapted from\n * [Kevin Ennis](http://stackoverflow.com/questions/22312841/waveshaper-node-in-webaudio-how-to-emulate-distortion)\n *\n * This class extends p5.Effect.\n * Methods amp(), chain(),\n * drywet(), connect(), and\n * disconnect() are available.\n *\n * @class p5.Distortion\n * @extends p5.Effect\n * @constructor\n * @param {Number} [amount=0.25] Unbounded distortion amount.\n * Normal values range from 0-1.\n * @param {String} [oversample='none'] 'none', '2x', or '4x'.\n *\n */\n p5.Distortion = function(amount, oversample) {\n Effect.call(this);\n\n if (typeof amount === 'undefined') {\n amount = 0.25;\n } if (typeof amount !== 'number') {\n throw new Error('amount must be a number');\n } if (typeof oversample === 'undefined') {\n oversample = '2x';\n } if (typeof oversample !== 'string') {\n throw new Error('oversample must be a String');\n }\n\n var curveAmount = p5.prototype.map(amount, 0.0, 1.0, 0, 2000);\n\n /**\n * The p5.Distortion is built with a\n * \n * Web Audio WaveShaper Node.\n *\n * @property {AudioNode} WaveShaperNode\n */\n this.waveShaperNode = this.ac.createWaveShaper();\n\n this.amount = curveAmount;\n this.waveShaperNode.curve = makeDistortionCurve(curveAmount);\n this.waveShaperNode.oversample = oversample;\n\n this.input.connect(this.waveShaperNode);\n\n this.waveShaperNode.connect(this.wet);\n };\n\n p5.Distortion.prototype = Object.create(Effect.prototype);\n\n\n /**\n * Process a sound source, optionally specify amount and oversample values.\n *\n * @method process\n * @for p5.Distortion\n * @param {Number} [amount=0.25] Unbounded distortion amount.\n * Normal values range from 0-1.\n * @param {String} [oversample='none'] 'none', '2x', or '4x'.\n */\n p5.Distortion.prototype.process = function(src, amount, oversample) {\n src.connect(this.input);\n this.set(amount, oversample);\n };\n\n /**\n * Set the amount and oversample of the waveshaper distortion.\n *\n * @method set\n * @for p5.Distortion\n * @param {Number} [amount=0.25] Unbounded distortion amount.\n * Normal values range from 0-1.\n * @param {String} [oversample='none'] 'none', '2x', or '4x'.\n */\n p5.Distortion.prototype.set = function(amount, oversample) {\n if (amount) {\n var curveAmount = p5.prototype.map(amount, 0.0, 1.0, 0, 2000);\n this.amount = curveAmount;\n this.waveShaperNode.curve = makeDistortionCurve(curveAmount);\n }\n if (oversample) {\n this.waveShaperNode.oversample = oversample;\n }\n };\n\n /**\n * Return the distortion amount, typically between 0-1.\n *\n * @method getAmount\n * @for p5.Distortion\n * @return {Number} Unbounded distortion amount.\n * Normal values range from 0-1.\n */\n p5.Distortion.prototype.getAmount = function() {\n return this.amount;\n };\n\n /**\n * Return the oversampling.\n *\n * @method getOversample\n * @for p5.Distortion\n * @return {String} Oversample can either be 'none', '2x', or '4x'.\n */\n p5.Distortion.prototype.getOversample = function() {\n return this.waveShaperNode.oversample;\n };\n\n\n p5.Distortion.prototype.dispose = function() {\n Effect.prototype.dispose.apply(this);\n if (this.waveShaperNode) {\n this.waveShaperNode.disconnect();\n this.waveShaperNode = null;\n }\n };\n});\n"],"sourceRoot":""} \ No newline at end of file diff --git a/src/fft.js b/src/fft.js index 77c73796..5a30ebec 100644 --- a/src/fft.js +++ b/src/fft.js @@ -2,6 +2,7 @@ define(function(require) { var p5sound = require('master'); + const {safeBins} = require('helpers'); /** *

FFT (Fast Fourier Transform) is an analysis algorithm that @@ -115,7 +116,7 @@ define(function(require) { // set default smoothing and bins this.smooth(smoothing); - this.bins = bins || 1024; + this.bins = safeBins(bins) || 1024; // default connections to p5sound fftMeter p5sound.fftMeter.connect(this.analyser); diff --git a/src/helpers.js b/src/helpers.js index f829e9db..a6f2fe03 100644 --- a/src/helpers.js +++ b/src/helpers.js @@ -322,7 +322,7 @@ define(function (require) { } function safeBufferSize(idealBufferSize) { - let bufferSize = idealBufferSize; + let bufferSize = idealBufferSize; // if the AudioWorkletNode is actually a ScriptProcessorNode created via polyfill, // make sure that our chosen buffer size isn't smaller than the buffer size automatically @@ -337,12 +337,27 @@ define(function (require) { return bufferSize; } + var safeBins = p5.prototype.safeBins = function(bins) { + let safeBins = 1024; + if(typeof(bins)==="string"){ + console.warn("the value of bins must be power of two and between 16 and 1024"); + return safeBins + } + if(bins && bins>=16 && bins<=1024 && Math.log2(bins)%1===0 ) + return bins; + else { + console.warn("the value of bins must be power of two and between 16 and 1024"); + return safeBins + } + + } return { convertToWav: convertToWav, midiToFreq: midiToFreq, noteToFreq: noteToFreq, - safeBufferSize: safeBufferSize + safeBufferSize: safeBufferSize, + safeBins:safeBins }; }); diff --git a/test/test.js b/test/test.js index 9a5fd4c5..6141c841 100644 --- a/test/test.js +++ b/test/test.js @@ -8,6 +8,7 @@ require.config({ }); var allTests = [ + 'tests/utils/test.helpers', 'tests/p5.SoundFile', 'tests/p5.Amplitude', 'tests/p5.Oscillator', diff --git a/test/tests/utils/test.helpers.js b/test/tests/utils/test.helpers.js new file mode 100644 index 00000000..b8c666db --- /dev/null +++ b/test/tests/utils/test.helpers.js @@ -0,0 +1,42 @@ +'use strict'; + +define(['chai'],(chai)=>{ + const safeBins = p5.prototype.safeBins; + let expect = chai.expect; + + describe('safeBins', ()=>{ + + it('works fine for values in Range',()=>{ + let test = 256; + expect(safeBins(test)).to.equal(256); + let test2 = 512; + expect(safeBins(test2)).to.equal(512); + }); + it('can handle negative input ',()=>{ + let test =-Math.random()*2; + expect(safeBins(test)).to.equal(1024); + }); + it('can handle value less than 16 ',()=>{ + let test = 10; + expect(safeBins(test)).to.equal(1024); + }); + it('can handle value greater than 1024',()=>{ + let test = 1500; + expect(safeBins(test)).to.equal(1024); + }); + it('can handle value other than power 2',()=>{ + let test = 1500; + expect(safeBins(test)).to.equal(1024); + }); + it('can handle value equal to 0',()=>{ + let test = 0; + expect(safeBins(test)).to.equal(1024); + }); + it('can handle strings',()=>{ + let test = 'testString'; + expect(safeBins(test)).to.equal(1024); + }); + + }); + +}); \ No newline at end of file