From acdb1b31d056f96a7380829813da0dba50d87edd Mon Sep 17 00:00:00 2001 From: dori Date: Sat, 11 Apr 2020 15:03:24 -0400 Subject: [PATCH 1/3] condition never met --- src/looper.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/looper.js b/src/looper.js index c136fe91..4e0ca755 100644 --- a/src/looper.js +++ b/src/looper.js @@ -389,7 +389,7 @@ define(function(require) { var thisScore = this; for (var i in arguments) { - if (arguments[i] && this.parts[i]) { + if (arguments[i]) { this.parts[i] = arguments[i]; this.parts[i].nextPart = this.parts[i + 1]; this.parts[i].onended = function() { From a0f0637db07680d667d2f1501eb844c1cca0225b Mon Sep 17 00:00:00 2001 From: dori Date: Sat, 11 Apr 2020 15:05:25 -0400 Subject: [PATCH 2/3] playnextpart already control the flow --- lib/p5.sound.js | 13 ++++--------- lib/p5.sound.js.map | 2 +- lib/p5.sound.min.js | 4 ++-- lib/p5.sound.min.js.map | 2 +- package.json | 2 +- src/looper.js | 5 ----- 6 files changed, 9 insertions(+), 19 deletions(-) diff --git a/lib/p5.sound.js b/lib/p5.sound.js index 8580643c..33c4f3ac 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.13 - 2020-04-11 */ /** *

p5.sound extends p5 with Web Audio functionality including audio input, @@ -5889,7 +5889,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 @@ -10303,7 +10303,7 @@ var __WEBPACK_AMD_DEFINE_RESULT__; var thisScore = this; for (var i in arguments) { - if (arguments[i] && this.parts[i]) { + if (arguments[i]) { this.parts[i] = arguments[i]; this.parts[i].nextPart = this.parts[i + 1]; @@ -10320,11 +10320,6 @@ var __WEBPACK_AMD_DEFINE_RESULT__; p5.Score.prototype.onended = function () { if (this.looping) { this.parts[0].start(); - } else { - this.parts[this.parts.length - 1].onended = function () { - this.stop(); - this.resetParts(); - }; } this.currentPart = 0; @@ -10598,7 +10593,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) diff --git a/lib/p5.sound.js.map b/lib/p5.sound.js.map index b495f030..babccacd 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 *
  • 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:///../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","scoreStep","resetParts","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';\r\n\r\n\r\ndefine(['audiocontext'], function (audiocontext) {\r\n // Master contains the master sound output.\r\n var Master = function() {\r\n this.input = audiocontext.createGain();\r\n this.output = audiocontext.createGain();\r\n\r\n //put a hard limiter on the output\r\n this.limiter = audiocontext.createDynamicsCompressor();\r\n this.limiter.threshold.value = -3;\r\n this.limiter.ratio.value = 20;\r\n this.limiter.knee.value = 1;\r\n\r\n this.audiocontext = audiocontext;\r\n\r\n this.output.disconnect();\r\n\r\n // connect input to limiter\r\n this.input.connect(this.limiter);\r\n\r\n // connect limiter to output\r\n this.limiter.connect(this.output);\r\n\r\n // meter is just for global Amplitude / FFT analysis\r\n this.meter = audiocontext.createGain();\r\n this.fftMeter = audiocontext.createGain();\r\n this.output.connect(this.meter);\r\n this.output.connect(this.fftMeter);\r\n\r\n // connect output to destination\r\n this.output.connect(this.audiocontext.destination);\r\n\r\n // an array of all sounds in the sketch\r\n this.soundArray = [];\r\n // an array of all musical parts in the sketch\r\n this.parts = [];\r\n\r\n // file extensions to search for\r\n this.extensions = [];\r\n };\r\n\r\n // create a single instance of the p5Sound / master output for use within this sketch\r\n var p5sound = new Master();\r\n\r\n /**\r\n * Returns a number representing the master amplitude (volume) for sound\r\n * in this sketch.\r\n *\r\n * @method getMasterVolume\r\n * @return {Number} Master amplitude (volume) for sound in this sketch.\r\n * Should be between 0.0 (silence) and 1.0.\r\n */\r\n p5.prototype.getMasterVolume = function() {\r\n return p5sound.output.gain.value;\r\n };\r\n\r\n /**\r\n *

Scale the output of all sound in this sketch

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

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

\r\n *\r\n *

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

\r\n *\r\n * @method masterVolume\r\n * @param {Number|Object} volume Volume (amplitude) between 0.0\r\n * and 1.0 or modulating signal/oscillator\r\n * @param {Number} [rampTime] Fade for t seconds\r\n * @param {Number} [timeFromNow] Schedule this event to happen at\r\n * t seconds in the future\r\n */\r\n p5.prototype.masterVolume = function(vol, rampTime, tFromNow) {\r\n if (typeof vol === 'number') {\r\n var rampTime = rampTime || 0;\r\n var tFromNow = tFromNow || 0;\r\n var now = p5sound.audiocontext.currentTime;\r\n var currentVol = p5sound.output.gain.value;\r\n p5sound.output.gain.cancelScheduledValues(now + tFromNow);\r\n p5sound.output.gain.linearRampToValueAtTime(currentVol, now + tFromNow);\r\n p5sound.output.gain.linearRampToValueAtTime(vol, now + tFromNow + rampTime);\r\n }\r\n else if (vol) {\r\n vol.connect(p5sound.output.gain);\r\n } else {\r\n // return the Gain Node\r\n return p5sound.output.gain;\r\n }\r\n };\r\n\r\n /**\r\n * `p5.soundOut` is the p5.sound master output. It sends output to\r\n * the destination of this window's web audio context. It contains\r\n * Web Audio API nodes including a dyanmicsCompressor (.limiter),\r\n * and Gain Nodes for .input and .output.\r\n *\r\n * @property {Object} soundOut\r\n */\r\n p5.prototype.soundOut = p5.soundOut = p5sound;\r\n\r\n // a silent connection to the DesinationNode\r\n // which will ensure that anything connected to it\r\n // will not be garbage collected\r\n p5.soundOut._silentNode = p5sound.audiocontext.createGain();\r\n p5.soundOut._silentNode.gain.value = 0;\r\n p5.soundOut._silentNode.connect(p5sound.audiocontext.destination);\r\n\r\n\r\n return p5sound;\r\n});\r\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';\r\ndefine(function (require) {\r\n\r\n var p5sound = require('master');\r\n var CrossFade = require('Tone/component/CrossFade');\r\n\r\n /**\r\n * Effect is a base class for audio effects in p5.
\r\n * This module handles the nodes and methods that are\r\n * common and useful for current and future effects.\r\n *\r\n *\r\n * This class is extended by p5.Distortion,\r\n * p5.Compressor,\r\n * p5.Delay,\r\n * p5.Filter,\r\n * p5.Reverb.\r\n *\r\n * @class p5.Effect\r\n * @constructor\r\n *\r\n * @param {Object} [ac] Reference to the audio context of the p5 object\r\n * @param {AudioNode} [input] Gain Node effect wrapper\r\n * @param {AudioNode} [output] Gain Node effect wrapper\r\n * @param {Object} [_drywet] Tone.JS CrossFade node (defaults to value: 1)\r\n * @param {AudioNode} [wet] Effects that extend this class should connect\r\n * to the wet signal to this gain node, so that dry and wet\r\n * signals are mixed properly.\r\n */\r\n p5.Effect = function() {\r\n this.ac = p5sound.audiocontext;\r\n\r\n this.input = this.ac.createGain();\r\n this.output = this.ac.createGain();\r\n\r\n /**\r\n *\tThe p5.Effect class is built\r\n * \tusing Tone.js CrossFade\r\n * \t@private\r\n */\r\n\r\n this._drywet = new CrossFade(1);\r\n\r\n /**\r\n *\tIn classes that extend\r\n *\tp5.Effect, connect effect nodes\r\n *\tto the wet parameter\r\n */\r\n this.wet = this.ac.createGain();\r\n\r\n this.input.connect(this._drywet.a);\r\n this.wet.connect(this._drywet.b);\r\n this._drywet.connect(this.output);\r\n\r\n this.connect();\r\n\r\n //Add to the soundArray\r\n p5sound.soundArray.push(this);\r\n };\r\n\r\n /**\r\n * Set the output volume of the filter.\r\n *\r\n * @method amp\r\n * @for p5.Effect\r\n * @param {Number} [vol] amplitude between 0 and 1.0\r\n * @param {Number} [rampTime] create a fade that lasts until rampTime\r\n * @param {Number} [tFromNow] schedule this event to happen in tFromNow seconds\r\n */\r\n p5.Effect.prototype.amp = function(vol, rampTime, tFromNow){\r\n var rampTime = rampTime || 0;\r\n var tFromNow = tFromNow || 0;\r\n var now = p5sound.audiocontext.currentTime;\r\n var currentVol = this.output.gain.value;\r\n this.output.gain.cancelScheduledValues(now);\r\n this.output.gain.linearRampToValueAtTime(currentVol, now + tFromNow + .001);\r\n this.output.gain.linearRampToValueAtTime(vol, now + tFromNow + rampTime + .001);\r\n };\r\n\r\n /**\r\n * Link effects together in a chain\r\n * Example usage: filter.chain(reverb, delay, panner);\r\n * May be used with an open-ended number of arguments\r\n *\r\n * @method chain\r\n * @for p5.Effect\r\n * @param {Object} [arguments] Chain together multiple sound objects\r\n */\r\n p5.Effect.prototype.chain = function(){\r\n if (arguments.length>0){\r\n this.connect(arguments[0]);\r\n for(var i=1;i\r\n * let midiNotes = [60, 64, 67, 72];\r\n * let noteIndex = 0;\r\n * let midiVal, freq;\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * cnv.mousePressed(startSound);\r\n * osc = new p5.TriOsc();\r\n * env = new p5.Envelope();\r\n * }\r\n *\r\n * function draw() {\r\n * background(220);\r\n * text('tap to play', 10, 20);\r\n * if (midiVal) {\r\n * text('MIDI: ' + midiVal, 10, 40);\r\n * text('Freq: ' + freq, 10, 60);\r\n * }\r\n * }\r\n *\r\n * function startSound() {\r\n * // see also: userStartAudio();\r\n * osc.start();\r\n *\r\n * midiVal = midiNotes[noteIndex % midiNotes.length];\r\n * freq = midiToFreq(midiVal);\r\n * osc.freq(freq);\r\n * env.ramp(osc, 0, 1.0, 0);\r\n *\r\n * noteIndex++;\r\n * }\r\n * \r\n */\r\n var midiToFreq = p5.prototype.midiToFreq = function(m) {\r\n return 440 * Math.pow(2, (m-69)/12.0);\r\n };\r\n\r\n // This method converts ANSI notes specified as a string \"C4\", \"Eb3\" to a frequency\r\n var noteToFreq = function(note) {\r\n if (typeof note !== 'string') {\r\n return note;\r\n }\r\n var wholeNotes = {A:21, B:23, C:24, D:26, E:28, F:29, G:31};\r\n var value = wholeNotes[ note[0].toUpperCase() ];\r\n var octave = ~~note.slice(-1);\r\n value += 12 * (octave -1);\r\n\r\n switch(note[1]) {\r\n case '#':\r\n value += 1;\r\n break;\r\n case 'b':\r\n value -= 1;\r\n break;\r\n default:\r\n break;\r\n }\r\n return midiToFreq(value);\r\n };\r\n\r\n /**\r\n * List the SoundFile formats that you will include. LoadSound\r\n * will search your directory for these extensions, and will pick\r\n * a format that is compatable with the client's web browser.\r\n * Here is a free online file\r\n * converter.\r\n *\r\n * @method soundFormats\r\n * @param {String} [...formats] i.e. 'mp3', 'wav', 'ogg'\r\n * @example\r\n *
\r\n * function preload() {\r\n * // set the global sound formats\r\n * soundFormats('mp3', 'ogg');\r\n *\r\n * // load either beatbox.mp3, or .ogg, depending on browser\r\n * mySound = loadSound('assets/beatbox.mp3');\r\n * }\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * background(220);\r\n * text('sound loaded! tap to play', 10, 20, width - 20);\r\n * cnv.mousePressed(function() {\r\n * mySound.play();\r\n * });\r\n * }\r\n *
\r\n */\r\n p5.prototype.soundFormats = function() {\r\n // reset extensions array\r\n p5sound.extensions = [];\r\n // add extensions\r\n for (var i = 0; i < arguments.length; i++) {\r\n arguments[i] = arguments[i].toLowerCase();\r\n if (['mp3','wav','ogg', 'm4a', 'aac'].indexOf(arguments[i]) > -1) {\r\n p5sound.extensions.push(arguments[i]);\r\n } else {\r\n throw arguments[i] + ' is not a valid sound format!';\r\n }\r\n }\r\n };\r\n\r\n p5.prototype.disposeSound = function() {\r\n for (var i = 0; i < p5sound.soundArray.length; i++) {\r\n p5sound.soundArray[i].dispose();\r\n }\r\n };\r\n\r\n // register removeSound to dispose of p5sound SoundFiles, Convolvers,\r\n // Oscillators etc when sketch ends\r\n p5.prototype.registerMethod('remove', p5.prototype.disposeSound);\r\n\r\n p5.prototype._checkFileFormats = function(paths) {\r\n var path;\r\n // if path is a single string, check to see if extension is provided\r\n if (typeof paths === 'string') {\r\n path = paths;\r\n // see if extension is provided\r\n var extTest = path.split('.').pop();\r\n // if an extension is provided...\r\n if (['mp3','wav','ogg', 'm4a', 'aac'].indexOf(extTest) > -1) {\r\n if (p5.prototype.isFileSupported(extTest)) {\r\n path = path;\r\n }\r\n else {\r\n var pathSplit = path.split('.');\r\n var pathCore = pathSplit[pathSplit.length - 1];\r\n for (var i = 0; i 1) {\r\n rightChannel = audioBuffer.getChannelData(1);\r\n } else {\r\n rightChannel = leftChannel;\r\n }\r\n\r\n var interleaved = interleave(leftChannel, rightChannel);\r\n\r\n // create the buffer and view to create the .WAV file\r\n var buffer = new window.ArrayBuffer(44 + interleaved.length * 2);\r\n var view = new window.DataView(buffer);\r\n\r\n // write the WAV container,\r\n // check spec at: https://web.archive.org/web/20171215131933/http://tiny.systems/software/soundProgrammer/WavFormatDocs.pdf\r\n\r\n // RIFF chunk descriptor\r\n writeUTFBytes(view, 0, 'RIFF');\r\n view.setUint32(4, 36 + interleaved.length * 2, true);\r\n writeUTFBytes(view, 8, 'WAVE');\r\n // FMT sub-chunk\r\n writeUTFBytes(view, 12, 'fmt ');\r\n view.setUint32(16, 16, true);\r\n view.setUint16(20, 1, true);\r\n // stereo (2 channels)\r\n view.setUint16(22, 2, true);\r\n view.setUint32(24, p5sound.audiocontext.sampleRate, true);\r\n view.setUint32(28, p5sound.audiocontext.sampleRate * 4, true);\r\n view.setUint16(32, 4, true);\r\n view.setUint16(34, 16, true);\r\n // data sub-chunk\r\n writeUTFBytes(view, 36, 'data');\r\n view.setUint32(40, interleaved.length * 2, true);\r\n\r\n // write the PCM samples\r\n var lng = interleaved.length;\r\n var index = 44;\r\n var volume = 1;\r\n for (var i = 0; i < lng; i++) {\r\n view.setInt16(index, interleaved[i] * (0x7FFF * volume), true);\r\n index += 2;\r\n }\r\n\r\n return view;\r\n }\r\n\r\n // helper methods to save waves\r\n function interleave(leftChannel, rightChannel) {\r\n var length = leftChannel.length + rightChannel.length;\r\n var result = new Float32Array(length);\r\n\r\n var inputIndex = 0;\r\n\r\n for (var index = 0; index < length;) {\r\n result[index++] = leftChannel[inputIndex];\r\n result[index++] = rightChannel[inputIndex];\r\n inputIndex++;\r\n }\r\n return result;\r\n }\r\n\r\n function writeUTFBytes(view, offset, string) {\r\n var lng = string.length;\r\n for (var i = 0; i < lng; i++) {\r\n view.setUint8(offset + i, string.charCodeAt(i));\r\n }\r\n }\r\n\r\n function safeBufferSize(idealBufferSize) {\r\n let bufferSize = idealBufferSize;\r\n\r\n // if the AudioWorkletNode is actually a ScriptProcessorNode created via polyfill,\r\n // make sure that our chosen buffer size isn't smaller than the buffer size automatically\r\n // selected by the polyfill\r\n // reference: https://github.com/GoogleChromeLabs/audioworklet-polyfill/issues/13#issuecomment-425014930\r\n let tempAudioWorkletNode = new AudioWorkletNode(p5sound.audiocontext, processorNames.soundFileProcessor);\r\n if (tempAudioWorkletNode instanceof ScriptProcessorNode) {\r\n bufferSize = tempAudioWorkletNode.bufferSize;\r\n }\r\n tempAudioWorkletNode.disconnect();\r\n tempAudioWorkletNode = null;\r\n\r\n return bufferSize;\r\n }\r\n\r\n return {\r\n convertToWav: convertToWav,\r\n midiToFreq: midiToFreq,\r\n noteToFreq: noteToFreq,\r\n safeBufferSize: safeBufferSize\r\n };\r\n\r\n});\r\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 = {\r\n recorderProcessor: 'recorder-processor',\r\n soundFileProcessor: 'sound-file-processor',\r\n amplitudeProcessor: 'amplitude-processor'\r\n};\r\n","'use strict';\r\n\r\ndefine(function () {\r\n /*\r\n Helper function to generate an error\r\n with a custom stack trace that points to the sketch\r\n and removes other parts of the stack trace.\r\n\r\n @private\r\n @class customError\r\n @constructor\r\n @param {String} name custom error name\r\n @param {String} errorTrace custom error trace\r\n @param {String} failedPath path to the file that failed to load\r\n @property {String} name custom error name\r\n @property {String} message custom error message\r\n @property {String} stack trace the error back to a line in the user's sketch.\r\n Note: this edits out stack trace within p5.js and p5.sound.\r\n @property {String} originalStack unedited, original stack trace\r\n @property {String} failedPath path to the file that failed to load\r\n @return {Error} returns a custom Error object\r\n */\r\n var CustomError = function(name, errorTrace, failedPath) {\r\n var err = new Error();\r\n var tempStack, splitStack;\r\n\r\n err.name = name;\r\n err.originalStack = err.stack + errorTrace;\r\n tempStack = err.stack + errorTrace;\r\n err.failedPath = failedPath;\r\n\r\n // only print the part of the stack trace that refers to the user code:\r\n var splitStack = tempStack.split('\\n');\r\n splitStack = splitStack.filter(function(ln) {\r\n return !ln.match(/(p5.|native code|globalInit)/g);\r\n });\r\n err.stack = splitStack.join('\\n');\r\n\r\n return err; // TODO: is this really a constructor?\r\n };\r\n\r\n return CustomError;\r\n});\r\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';\r\n\r\ndefine(function (require) {\r\n var Effect = require('effect');\r\n\r\n /**\r\n *

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

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

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

\r\n *\r\n *

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

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

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

\r\n *\r\n *

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

\r\n *\r\n *

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

\r\n * @param {Element|Array} [element(s)] This argument can be an Element,\r\n * Selector String, NodeList, p5.Element,\r\n * jQuery Element, or an Array of any of those.\r\n * @param {Function} [callback] Callback to invoke when the AudioContext\r\n * has started\r\n * @return {Promise} Returns a Promise that resolves when\r\n * the AudioContext state is 'running'\r\n * @method userStartAudio\r\n * @for p5\r\n * @example\r\n *
\r\n * function setup() {\r\n * // mimics the autoplay policy\r\n * getAudioContext().suspend();\r\n *\r\n * let mySynth = new p5.MonoSynth();\r\n *\r\n * // This won't play until the context has resumed\r\n * mySynth.play('A6');\r\n * }\r\n * function draw() {\r\n * background(220);\r\n * textAlign(CENTER, CENTER);\r\n * text(getAudioContext().state, width/2, height/2);\r\n * }\r\n * function mousePressed() {\r\n * userStartAudio();\r\n * }\r\n *
\r\n */\r\n p5.prototype.userStartAudio = function(elements, callback) {\r\n var elt = elements;\r\n if (elements instanceof p5.Element) {\r\n elt = elements.elt;\r\n } else if (elements instanceof Array && elements[0] instanceof p5.Element ) {\r\n elt = elements.map(function(e) { return e.elt});\r\n }\r\n return StartAudioContext(audiocontext, elt, callback);\r\n };\r\n\r\n return audiocontext;\r\n});\r\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';\r\n\r\ndefine(function (require) {\r\n var p5sound = require('master');\r\n\r\n var Add = require('Tone/signal/Add');\r\n var Mult = require('Tone/signal/Multiply');\r\n var Scale = require('Tone/signal/Scale');\r\n\r\n /**\r\n *

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

\r\n *\r\n *

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

\r\n *\r\n * @class p5.Oscillator\r\n * @constructor\r\n * @param {Number} [freq] frequency defaults to 440Hz\r\n * @param {String} [type] type of oscillator. Options:\r\n * 'sine' (default), 'triangle',\r\n * 'sawtooth', 'square'\r\n * @example\r\n *
\r\n * let osc, playing, freq, amp;\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * cnv.mousePressed(playOscillator);\r\n * osc = new p5.Oscillator('sine');\r\n * }\r\n *\r\n * function draw() {\r\n * background(220)\r\n * freq = constrain(map(mouseX, 0, width, 100, 500), 100, 500);\r\n * amp = constrain(map(mouseY, height, 0, 0, 1), 0, 1);\r\n *\r\n * text('tap to play', 20, 20);\r\n * text('freq: ' + freq, 20, 40);\r\n * text('amp: ' + amp, 20, 60);\r\n *\r\n * if (playing) {\r\n * // smooth the transitions by 0.1 seconds\r\n * osc.freq(freq, 0.1);\r\n * osc.amp(amp, 0.1);\r\n * }\r\n * }\r\n *\r\n * function playOscillator() {\r\n * // starting an oscillator on a user gesture will enable audio\r\n * // in browsers that have a strict autoplay policy.\r\n * // See also: userStartAudio();\r\n * osc.start();\r\n * playing = true;\r\n * }\r\n *\r\n * function mouseReleased() {\r\n * // ramp amplitude to 0 over 0.5 seconds\r\n * osc.amp(0, 0.5);\r\n * playing = false;\r\n * }\r\n *
\r\n */\r\n p5.Oscillator = function(freq, type) {\r\n if (typeof freq === 'string') {\r\n var f = type;\r\n type = freq;\r\n freq = f;\r\n } if (typeof type === 'number') {\r\n var f = type;\r\n type = freq;\r\n freq = f;\r\n }\r\n this.started = false;\r\n\r\n // components\r\n this.phaseAmount = undefined;\r\n this.oscillator = p5sound.audiocontext.createOscillator();\r\n this.f = freq || 440.0; // frequency\r\n this.oscillator.type = type || 'sine';\r\n this.oscillator.frequency.setValueAtTime(this.f, p5sound.audiocontext.currentTime);\r\n\r\n // connections\r\n this.output = p5sound.audiocontext.createGain();\r\n\r\n this._freqMods = []; // modulators connected to this oscillator's frequency\r\n\r\n // set default output gain to 0.5\r\n this.output.gain.value = 0.5;\r\n this.output.gain.setValueAtTime(0.5, p5sound.audiocontext.currentTime);\r\n\r\n this.oscillator.connect(this.output);\r\n // stereo panning\r\n this.panPosition = 0.0;\r\n this.connection = p5sound.input; // connect to p5sound by default\r\n this.panner = new p5.Panner(this.output, this.connection, 1);\r\n\r\n //array of math operation signal chaining\r\n this.mathOps = [this.output];\r\n\r\n // add to the soundArray so we can dispose of the osc later\r\n p5sound.soundArray.push(this);\r\n };\r\n\r\n /**\r\n * Start an oscillator.\r\n *\r\n * Starting an oscillator on a user gesture will enable audio in browsers\r\n * that have a strict autoplay policy, including Chrome and most mobile\r\n * devices. See also: `userStartAudio()`.\r\n *\r\n * @method start\r\n * @for p5.Oscillator\r\n * @param {Number} [time] startTime in seconds from now.\r\n * @param {Number} [frequency] frequency in Hz.\r\n */\r\n p5.Oscillator.prototype.start = function(time, f) {\r\n if (this.started) {\r\n var now = p5sound.audiocontext.currentTime;\r\n this.stop(now);\r\n }\r\n if (!this.started) {\r\n var freq = f || this.f;\r\n var type = this.oscillator.type;\r\n\r\n // set old osc free to be garbage collected (memory)\r\n if (this.oscillator) {\r\n this.oscillator.disconnect();\r\n delete this.oscillator;\r\n }\r\n\r\n // var detune = this.oscillator.frequency.value;\r\n this.oscillator = p5sound.audiocontext.createOscillator();\r\n this.oscillator.frequency.value = Math.abs(freq);\r\n this.oscillator.type = type;\r\n // this.oscillator.detune.value = detune;\r\n this.oscillator.connect(this.output);\r\n time = time || 0;\r\n this.oscillator.start(time + p5sound.audiocontext.currentTime);\r\n this.freqNode = this.oscillator.frequency;\r\n\r\n // if other oscillators are already connected to this osc's freq\r\n for (var i in this._freqMods) {\r\n if (typeof this._freqMods[i].connect !== 'undefined') {\r\n this._freqMods[i].connect(this.oscillator.frequency);\r\n }\r\n }\r\n\r\n this.started = true;\r\n }\r\n };\r\n\r\n /**\r\n * Stop an oscillator. Accepts an optional parameter\r\n * to determine how long (in seconds from now) until the\r\n * oscillator stops.\r\n *\r\n * @method stop\r\n * @for p5.Oscillator\r\n * @param {Number} secondsFromNow Time, in seconds from now.\r\n */\r\n p5.Oscillator.prototype.stop = function(time) {\r\n if (this.started) {\r\n var t = time || 0;\r\n var now = p5sound.audiocontext.currentTime;\r\n this.oscillator.stop(t + now);\r\n this.started = false;\r\n }\r\n };\r\n\r\n /**\r\n * Set the amplitude between 0 and 1.0. Or, pass in an object\r\n * such as an oscillator to modulate amplitude with an audio signal.\r\n *\r\n * @method amp\r\n * @for p5.Oscillator\r\n * @param {Number|Object} vol between 0 and 1.0\r\n * or a modulating signal/oscillator\r\n * @param {Number} [rampTime] create a fade that lasts rampTime\r\n * @param {Number} [timeFromNow] schedule this event to happen\r\n * seconds from now\r\n * @return {AudioParam} gain If no value is provided,\r\n * returns the Web Audio API\r\n * AudioParam that controls\r\n * this oscillator's\r\n * gain/amplitude/volume)\r\n */\r\n p5.Oscillator.prototype.amp = function(vol, rampTime, tFromNow) {\r\n var self = this;\r\n if (typeof vol === 'number') {\r\n var rampTime = rampTime || 0;\r\n var tFromNow = tFromNow || 0;\r\n var now = p5sound.audiocontext.currentTime;\r\n this.output.gain.linearRampToValueAtTime(vol, now + tFromNow + rampTime);\r\n }\r\n\r\n else if (vol) {\r\n vol.connect(self.output.gain);\r\n } else {\r\n // return the Gain Node\r\n return this.output.gain;\r\n }\r\n };\r\n\r\n // these are now the same thing\r\n p5.Oscillator.prototype.fade = p5.Oscillator.prototype.amp;\r\n\r\n p5.Oscillator.prototype.getAmp = function() {\r\n return this.output.gain.value;\r\n };\r\n\r\n /**\r\n * Set frequency of an oscillator to a value. Or, pass in an object\r\n * such as an oscillator to modulate the frequency with an audio signal.\r\n *\r\n * @method freq\r\n * @for p5.Oscillator\r\n * @param {Number|Object} Frequency Frequency in Hz\r\n * or modulating signal/oscillator\r\n * @param {Number} [rampTime] Ramp time (in seconds)\r\n * @param {Number} [timeFromNow] Schedule this event to happen\r\n * at x seconds from now\r\n * @return {AudioParam} Frequency If no value is provided,\r\n * returns the Web Audio API\r\n * AudioParam that controls\r\n * this oscillator's frequency\r\n * @example\r\n *
\r\n * let osc;\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * cnv.mousePressed(playOscillator);\r\n * osc = new p5.Oscillator(300);\r\n * background(220);\r\n * text('tap to play', 20, 20);\r\n * }\r\n *\r\n * function playOscillator() {\r\n * osc.start();\r\n * osc.amp(0.5);\r\n * // start at 700Hz\r\n * osc.freq(700);\r\n * // ramp to 60Hz over 0.7 seconds\r\n * osc.freq(60, 0.7);\r\n * osc.amp(0, 0.1, 0.7);\r\n * }\r\n *
\r\n */\r\n p5.Oscillator.prototype.freq = function(val, rampTime, tFromNow) {\r\n if (typeof val === 'number' && !isNaN(val)) {\r\n this.f = val;\r\n var now = p5sound.audiocontext.currentTime;\r\n var rampTime = rampTime || 0;\r\n var tFromNow = tFromNow || 0;\r\n var t = now + tFromNow + rampTime;\r\n // var currentFreq = this.oscillator.frequency.value;\r\n // this.oscillator.frequency.cancelScheduledValues(now);\r\n\r\n if (rampTime === 0) {\r\n this.oscillator.frequency.setValueAtTime(val, tFromNow + now);\r\n } else {\r\n if (val > 0 ) {\r\n this.oscillator.frequency.exponentialRampToValueAtTime(val, tFromNow + rampTime + now);\r\n } else {\r\n this.oscillator.frequency.linearRampToValueAtTime(val, tFromNow + rampTime + now);\r\n }\r\n }\r\n\r\n // reset phase if oscillator has a phase\r\n if (this.phaseAmount) {\r\n this.phase(this.phaseAmount);\r\n }\r\n\r\n } else if (val) {\r\n if (val.output) {\r\n val = val.output;\r\n }\r\n val.connect(this.oscillator.frequency);\r\n\r\n // keep track of what is modulating this param\r\n // so it can be re-connected if\r\n this._freqMods.push( val );\r\n } else {\r\n // return the Frequency Node\r\n return this.oscillator.frequency;\r\n }\r\n };\r\n\r\n p5.Oscillator.prototype.getFreq = function() {\r\n return this.oscillator.frequency.value;\r\n };\r\n\r\n /**\r\n * Set type to 'sine', 'triangle', 'sawtooth' or 'square'.\r\n *\r\n * @method setType\r\n * @for p5.Oscillator\r\n * @param {String} type 'sine', 'triangle', 'sawtooth' or 'square'.\r\n */\r\n p5.Oscillator.prototype.setType = function(type) {\r\n this.oscillator.type = type;\r\n };\r\n\r\n p5.Oscillator.prototype.getType = function() {\r\n return this.oscillator.type;\r\n };\r\n\r\n /**\r\n * Connect to a p5.sound / Web Audio object.\r\n *\r\n * @method connect\r\n * @for p5.Oscillator\r\n * @param {Object} unit A p5.sound or Web Audio object\r\n */\r\n p5.Oscillator.prototype.connect = function(unit) {\r\n if (!unit) {\r\n this.panner.connect(p5sound.input);\r\n }\r\n else if (unit.hasOwnProperty('input')) {\r\n this.panner.connect(unit.input);\r\n this.connection = unit.input;\r\n }\r\n else {\r\n this.panner.connect(unit);\r\n this.connection = unit;\r\n }\r\n };\r\n\r\n /**\r\n * Disconnect all outputs\r\n *\r\n * @method disconnect\r\n * @for p5.Oscillator\r\n */\r\n p5.Oscillator.prototype.disconnect = function() {\r\n if (this.output) {\r\n this.output.disconnect();\r\n }\r\n if (this.panner) {\r\n this.panner.disconnect();\r\n if (this.output) {\r\n this.output.connect(this.panner);\r\n }\r\n }\r\n this.oscMods = [];\r\n };\r\n\r\n /**\r\n * Pan between Left (-1) and Right (1)\r\n *\r\n * @method pan\r\n * @for p5.Oscillator\r\n * @param {Number} panning Number between -1 and 1\r\n * @param {Number} timeFromNow schedule this event to happen\r\n * seconds from now\r\n */\r\n p5.Oscillator.prototype.pan = function(pval, tFromNow) {\r\n this.panPosition = pval;\r\n this.panner.pan(pval, tFromNow);\r\n };\r\n\r\n p5.Oscillator.prototype.getPan = function() {\r\n return this.panPosition;\r\n };\r\n\r\n // get rid of the oscillator\r\n p5.Oscillator.prototype.dispose = function() {\r\n // remove reference from soundArray\r\n var index = p5sound.soundArray.indexOf(this);\r\n p5sound.soundArray.splice(index, 1);\r\n\r\n if (this.oscillator) {\r\n var now = p5sound.audiocontext.currentTime;\r\n this.stop(now);\r\n this.disconnect();\r\n this.panner = null;\r\n this.oscillator = null;\r\n }\r\n // if it is a Pulse\r\n if (this.osc2) {\r\n this.osc2.dispose();\r\n }\r\n };\r\n\r\n /**\r\n * Set the phase of an oscillator between 0.0 and 1.0.\r\n * In this implementation, phase is a delay time\r\n * based on the oscillator's current frequency.\r\n *\r\n * @method phase\r\n * @for p5.Oscillator\r\n * @param {Number} phase float between 0.0 and 1.0\r\n */\r\n p5.Oscillator.prototype.phase = function(p) {\r\n var delayAmt = p5.prototype.map(p, 0, 1.0, 0, 1/this.f);\r\n var now = p5sound.audiocontext.currentTime;\r\n\r\n this.phaseAmount = p;\r\n\r\n if (!this.dNode) {\r\n // create a delay node\r\n this.dNode = p5sound.audiocontext.createDelay();\r\n // put the delay node in between output and panner\r\n this.oscillator.disconnect();\r\n this.oscillator.connect(this.dNode);\r\n this.dNode.connect(this.output);\r\n }\r\n\r\n // set delay time to match phase:\r\n this.dNode.delayTime.setValueAtTime(delayAmt, now);\r\n };\r\n\r\n // ========================== //\r\n // SIGNAL MATH FOR MODULATION //\r\n // ========================== //\r\n\r\n // return sigChain(this, scale, thisChain, nextChain, Scale);\r\n var sigChain = function(o, mathObj, thisChain, nextChain, type) {\r\n var chainSource = o.oscillator;\r\n // if this type of math already exists in the chain, replace it\r\n for (var i in o.mathOps) {\r\n if (o.mathOps[i] instanceof type) {\r\n chainSource.disconnect();\r\n o.mathOps[i].dispose();\r\n thisChain = i;\r\n // assume nextChain is output gain node unless...\r\n if (thisChain < o.mathOps.length - 2) {\r\n nextChain = o.mathOps[i+1];\r\n }\r\n }\r\n }\r\n if (thisChain === o.mathOps.length - 1) {\r\n o.mathOps.push(nextChain);\r\n }\r\n // assume source is the oscillator unless i > 0\r\n if (i > 0) {\r\n chainSource = o.mathOps[i-1];\r\n }\r\n chainSource.disconnect();\r\n chainSource.connect(mathObj);\r\n mathObj.connect(nextChain);\r\n o.mathOps[thisChain] = mathObj;\r\n return o;\r\n };\r\n\r\n /**\r\n * Add a value to the p5.Oscillator's output amplitude,\r\n * and return the oscillator. Calling this method again\r\n * will override the initial add() with a new value.\r\n *\r\n * @method add\r\n * @for p5.Oscillator\r\n * @param {Number} number Constant number to add\r\n * @return {p5.Oscillator} Oscillator Returns this oscillator\r\n * with scaled output\r\n *\r\n */\r\n p5.Oscillator.prototype.add = function(num) {\r\n var add = new Add(num);\r\n var thisChain = this.mathOps.length-1;\r\n var nextChain = this.output;\r\n return sigChain(this, add, thisChain, nextChain, Add);\r\n };\r\n\r\n /**\r\n * Multiply the p5.Oscillator's output amplitude\r\n * by a fixed value (i.e. turn it up!). Calling this method\r\n * again will override the initial mult() with a new value.\r\n *\r\n * @method mult\r\n * @for p5.Oscillator\r\n * @param {Number} number Constant number to multiply\r\n * @return {p5.Oscillator} Oscillator Returns this oscillator\r\n * with multiplied output\r\n */\r\n p5.Oscillator.prototype.mult = function(num) {\r\n var mult = new Mult(num);\r\n var thisChain = this.mathOps.length-1;\r\n var nextChain = this.output;\r\n return sigChain(this, mult, thisChain, nextChain, Mult);\r\n };\r\n\r\n /**\r\n * Scale this oscillator's amplitude values to a given\r\n * range, and return the oscillator. Calling this method\r\n * again will override the initial scale() with new values.\r\n *\r\n * @method scale\r\n * @for p5.Oscillator\r\n * @param {Number} inMin input range minumum\r\n * @param {Number} inMax input range maximum\r\n * @param {Number} outMin input range minumum\r\n * @param {Number} outMax input range maximum\r\n * @return {p5.Oscillator} Oscillator Returns this oscillator\r\n * with scaled output\r\n */\r\n p5.Oscillator.prototype.scale = function(inMin, inMax, outMin, outMax) {\r\n var mapOutMin, mapOutMax;\r\n if (arguments.length === 4) {\r\n mapOutMin = p5.prototype.map(outMin, inMin, inMax, 0, 1) - 0.5;\r\n mapOutMax = p5.prototype.map(outMax, inMin, inMax, 0, 1) - 0.5;\r\n }\r\n else {\r\n mapOutMin = arguments[0];\r\n mapOutMax = arguments[1];\r\n }\r\n var scale = new Scale(mapOutMin, mapOutMax);\r\n var thisChain = this.mathOps.length-1;\r\n var nextChain = this.output;\r\n return sigChain(this, scale, thisChain, nextChain, Scale);\r\n\r\n // this.output.disconnect();\r\n // this.output.connect(scale)\r\n };\r\n\r\n // ============================== //\r\n // SinOsc, TriOsc, SqrOsc, SawOsc //\r\n // ============================== //\r\n\r\n /**\r\n * Constructor: new p5.SinOsc().\r\n * This creates a Sine Wave Oscillator and is\r\n * equivalent to new p5.Oscillator('sine')\r\n * or creating a p5.Oscillator and then calling\r\n * its method setType('sine').\r\n * See p5.Oscillator for methods.\r\n *\r\n * @class p5.SinOsc\r\n * @constructor\r\n * @extends p5.Oscillator\r\n * @param {Number} [freq] Set the frequency\r\n */\r\n p5.SinOsc = function(freq) {\r\n p5.Oscillator.call(this, freq, 'sine');\r\n };\r\n\r\n p5.SinOsc.prototype = Object.create(p5.Oscillator.prototype);\r\n\r\n /**\r\n * Constructor: new p5.TriOsc().\r\n * This creates a Triangle Wave Oscillator and is\r\n * equivalent to new p5.Oscillator('triangle')\r\n * or creating a p5.Oscillator and then calling\r\n * its method setType('triangle').\r\n * See p5.Oscillator for methods.\r\n *\r\n * @class p5.TriOsc\r\n * @constructor\r\n * @extends p5.Oscillator\r\n * @param {Number} [freq] Set the frequency\r\n */\r\n p5.TriOsc = function(freq) {\r\n p5.Oscillator.call(this, freq, 'triangle');\r\n };\r\n\r\n p5.TriOsc.prototype = Object.create(p5.Oscillator.prototype);\r\n\r\n /**\r\n * Constructor: new p5.SawOsc().\r\n * This creates a SawTooth Wave Oscillator and is\r\n * equivalent to new p5.Oscillator('sawtooth')\r\n * or creating a p5.Oscillator and then calling\r\n * its method setType('sawtooth').\r\n * See p5.Oscillator for methods.\r\n *\r\n * @class p5.SawOsc\r\n * @constructor\r\n * @extends p5.Oscillator\r\n * @param {Number} [freq] Set the frequency\r\n */\r\n p5.SawOsc = function(freq) {\r\n p5.Oscillator.call(this, freq, 'sawtooth');\r\n };\r\n\r\n p5.SawOsc.prototype = Object.create(p5.Oscillator.prototype);\r\n\r\n /**\r\n * Constructor: new p5.SqrOsc().\r\n * This creates a Square Wave Oscillator and is\r\n * equivalent to new p5.Oscillator('square')\r\n * or creating a p5.Oscillator and then calling\r\n * its method setType('square').\r\n * See p5.Oscillator for methods.\r\n *\r\n * @class p5.SqrOsc\r\n * @constructor\r\n * @extends p5.Oscillator\r\n * @param {Number} [freq] Set the frequency\r\n */\r\n p5.SqrOsc = function(freq) {\r\n p5.Oscillator.call(this, freq, 'square');\r\n };\r\n\r\n p5.SqrOsc.prototype = Object.create(p5.Oscillator.prototype);\r\n\r\n});\r\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';\r\ndefine(function (require) {\r\n\r\n var p5sound = require('master');\r\n var AudioVoice = require('audioVoice');\r\n var noteToFreq = require('helpers').noteToFreq;\r\n\r\n var DEFAULT_SUSTAIN = 0.15;\r\n\r\n /**\r\n * A MonoSynth is used as a single voice for sound synthesis.\r\n * This is a class to be used in conjunction with the PolySynth\r\n * class. Custom synthetisers should be built inheriting from\r\n * this class.\r\n *\r\n * @class p5.MonoSynth\r\n * @constructor\r\n * @example\r\n *
\r\n * let monoSynth;\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * cnv.mousePressed(playSynth);\r\n * background(220);\r\n * textAlign(CENTER);\r\n * text('tap to play', width/2, height/2);\r\n *\r\n * monoSynth = new p5.MonoSynth();\r\n * }\r\n *\r\n * function playSynth() {\r\n * userStartAudio();\r\n *\r\n * let note = random(['Fb4', 'G4']);\r\n * // note velocity (volume, from 0 to 1)\r\n * let velocity = random();\r\n * // time from now (in seconds)\r\n * let time = 0;\r\n * // note duration (in seconds)\r\n * let dur = 1/6;\r\n *\r\n * monoSynth.play(note, velocity, time, dur);\r\n * }\r\n *
\r\n **/\r\n\r\n p5.MonoSynth = function () {\r\n AudioVoice.call(this);\r\n\r\n this.oscillator = new p5.Oscillator();\r\n\r\n this.env = new p5.Envelope();\r\n this.env.setRange(1, 0);\r\n this.env.setExp(true);\r\n\r\n //set params\r\n this.setADSR(0.02, 0.25, 0.05, 0.35);\r\n\r\n // oscillator --> env --> this.output (gain) --> p5.soundOut\r\n this.oscillator.disconnect();\r\n this.oscillator.connect(this.output);\r\n\r\n this.env.disconnect();\r\n this.env.setInput(this.output.gain);\r\n\r\n // reset oscillator gain to 1.0\r\n this.oscillator.output.gain.value = 1.0;\r\n\r\n this.oscillator.start();\r\n this.connect();\r\n\r\n p5sound.soundArray.push(this);\r\n };\r\n\r\n p5.MonoSynth.prototype = Object.create(p5.AudioVoice.prototype);\r\n\r\n /**\r\n * Play tells the MonoSynth to start playing a note. This method schedules\r\n * the calling of .triggerAttack and .triggerRelease.\r\n *\r\n * @method play\r\n * @for p5.MonoSynth\r\n * @param {String | Number} note the note you want to play, specified as a\r\n * frequency in Hertz (Number) or as a midi\r\n * value in Note/Octave format (\"C4\", \"Eb3\"...etc\")\r\n * See \r\n * Tone. Defaults to 440 hz.\r\n * @param {Number} [velocity] velocity of the note to play (ranging from 0 to 1)\r\n * @param {Number} [secondsFromNow] time from now (in seconds) at which to play\r\n * @param {Number} [sustainTime] time to sustain before releasing the envelope. Defaults to 0.15 seconds.\r\n * @example\r\n *
\r\n * let monoSynth;\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * cnv.mousePressed(playSynth);\r\n * background(220);\r\n * textAlign(CENTER);\r\n * text('tap to play', width/2, height/2);\r\n *\r\n * monoSynth = new p5.MonoSynth();\r\n * }\r\n *\r\n * function playSynth() {\r\n * userStartAudio();\r\n *\r\n * let note = random(['Fb4', 'G4']);\r\n * // note velocity (volume, from 0 to 1)\r\n * let velocity = random();\r\n * // time from now (in seconds)\r\n * let time = 0;\r\n * // note duration (in seconds)\r\n * let dur = 1/6;\r\n *\r\n * monoSynth.play(note, velocity, time, dur);\r\n * }\r\n *
\r\n *\r\n */\r\n p5.MonoSynth.prototype.play = function (note, velocity, secondsFromNow, susTime) {\r\n this.triggerAttack(note, velocity, ~~secondsFromNow);\r\n this.triggerRelease(~~secondsFromNow + (susTime || DEFAULT_SUSTAIN));\r\n };\r\n\r\n /**\r\n * Trigger the Attack, and Decay portion of the Envelope.\r\n * Similar to holding down a key on a piano, but it will\r\n * hold the sustain level until you let go.\r\n *\r\n * @param {String | Number} note the note you want to play, specified as a\r\n * frequency in Hertz (Number) or as a midi\r\n * value in Note/Octave format (\"C4\", \"Eb3\"...etc\")\r\n * See \r\n * Tone. Defaults to 440 hz\r\n * @param {Number} [velocity] velocity of the note to play (ranging from 0 to 1)\r\n * @param {Number} [secondsFromNow] time from now (in seconds) at which to play\r\n * @method triggerAttack\r\n * @for p5.MonoSynth\r\n * @example\r\n *
\r\n * let monoSynth;\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * cnv.mousePressed(triggerAttack);\r\n * background(220);\r\n * text('tap here for attack, let go to release', 5, 20, width - 20);\r\n * monoSynth = new p5.MonoSynth();\r\n * }\r\n *\r\n * function triggerAttack() {\r\n * userStartAudio();\r\n *\r\n * monoSynth.triggerAttack(\"E3\");\r\n * }\r\n *\r\n * function mouseReleased() {\r\n * monoSynth.triggerRelease();\r\n * }\r\n *
\r\n */\r\n p5.MonoSynth.prototype.triggerAttack = function (note, velocity, secondsFromNow) {\r\n var secondsFromNow = ~~secondsFromNow;\r\n var freq = noteToFreq(note);\r\n var vel = velocity || 0.1;\r\n this.oscillator.freq(freq, 0, secondsFromNow);\r\n this.env.ramp(this.output.gain, secondsFromNow, vel);\r\n };\r\n\r\n /**\r\n * Trigger the release of the Envelope. This is similar to releasing\r\n * the key on a piano and letting the sound fade according to the\r\n * release level and release time.\r\n *\r\n * @param {Number} secondsFromNow time to trigger the release\r\n * @method triggerRelease\r\n * @for p5.MonoSynth\r\n * @example\r\n *
\r\n * let monoSynth;\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * cnv.mousePressed(triggerAttack);\r\n * background(220);\r\n * text('tap here for attack, let go to release', 5, 20, width - 20);\r\n * monoSynth = new p5.MonoSynth();\r\n * }\r\n *\r\n * function triggerAttack() {\r\n * userStartAudio();\r\n *\r\n * monoSynth.triggerAttack(\"E3\");\r\n * }\r\n *\r\n * function mouseReleased() {\r\n * monoSynth.triggerRelease();\r\n * }\r\n *
\r\n */\r\n p5.MonoSynth.prototype.triggerRelease = function (secondsFromNow) {\r\n var secondsFromNow = secondsFromNow || 0;\r\n this.env.ramp(this.output.gain, secondsFromNow, 0);\r\n };\r\n\r\n /**\r\n * Set values like a traditional\r\n * \r\n * ADSR envelope\r\n * .\r\n *\r\n * @method setADSR\r\n * @for p5.MonoSynth\r\n * @param {Number} attackTime Time (in seconds before envelope\r\n * reaches Attack Level\r\n * @param {Number} [decayTime] Time (in seconds) before envelope\r\n * reaches Decay/Sustain Level\r\n * @param {Number} [susRatio] Ratio between attackLevel and releaseLevel, on a scale from 0 to 1,\r\n * where 1.0 = attackLevel, 0.0 = releaseLevel.\r\n * The susRatio determines the decayLevel and the level at which the\r\n * sustain portion of the envelope will sustain.\r\n * For example, if attackLevel is 0.4, releaseLevel is 0,\r\n * and susAmt is 0.5, the decayLevel would be 0.2. If attackLevel is\r\n * increased to 1.0 (using setRange),\r\n * then decayLevel would increase proportionally, to become 0.5.\r\n * @param {Number} [releaseTime] Time in seconds from now (defaults to 0)\r\n */\r\n p5.MonoSynth.prototype.setADSR = function (attack,decay,sustain,release) {\r\n this.env.setADSR(attack, decay, sustain, release);\r\n };\r\n\r\n\r\n /**\r\n * Getters and Setters\r\n * @property {Number} attack\r\n * @for p5.MonoSynth\r\n */\r\n /**\r\n * @property {Number} decay\r\n * @for p5.MonoSynth\r\n */\r\n /**\r\n * @property {Number} sustain\r\n * @for p5.MonoSynth\r\n */\r\n /**\r\n * @property {Number} release\r\n * @for p5.MonoSynth\r\n */\r\n Object.defineProperties(p5.MonoSynth.prototype, {\r\n 'attack': {\r\n get : function() {\r\n return this.env.aTime;\r\n },\r\n set : function(attack) {\r\n this.env.setADSR(attack, this.env.dTime,\r\n this.env.sPercent, this.env.rTime);\r\n }\r\n },\r\n 'decay': {\r\n get : function() {\r\n return this.env.dTime;\r\n },\r\n set : function(decay) {\r\n this.env.setADSR(this.env.aTime, decay,\r\n this.env.sPercent, this.env.rTime);\r\n }\r\n },\r\n 'sustain': {\r\n get : function() {\r\n return this.env.sPercent;\r\n },\r\n set : function(sustain) {\r\n this.env.setADSR(this.env.aTime, this.env.dTime,\r\n sustain, this.env.rTime);\r\n }\r\n },\r\n 'release': {\r\n get : function() {\r\n return this.env.rTime;\r\n },\r\n set : function(release) {\r\n this.env.setADSR(this.env.aTime, this.env.dTime,\r\n this.env.sPercent, release);\r\n }\r\n },\r\n });\r\n\r\n\r\n /**\r\n * MonoSynth amp\r\n * @method amp\r\n * @for p5.MonoSynth\r\n * @param {Number} vol desired volume\r\n * @param {Number} [rampTime] Time to reach new volume\r\n * @return {Number} new volume value\r\n */\r\n p5.MonoSynth.prototype.amp = function(vol, rampTime) {\r\n var t = rampTime || 0;\r\n if (typeof vol !== 'undefined') {\r\n this.oscillator.amp(vol, t);\r\n }\r\n return this.oscillator.amp().value;\r\n };\r\n\r\n /**\r\n * Connect to a p5.sound / Web Audio object.\r\n *\r\n * @method connect\r\n * @for p5.MonoSynth\r\n * @param {Object} unit A p5.sound or Web Audio object\r\n */\r\n\r\n p5.MonoSynth.prototype.connect = function(unit) {\r\n var u = unit || p5sound.input;\r\n this.output.connect(u.input ? u.input : u);\r\n };\r\n\r\n /**\r\n * Disconnect all outputs\r\n *\r\n * @method disconnect\r\n * @for p5.MonoSynth\r\n */\r\n p5.MonoSynth.prototype.disconnect = function() {\r\n if (this.output) {\r\n this.output.disconnect();\r\n }\r\n };\r\n\r\n\r\n /**\r\n * Get rid of the MonoSynth and free up its resources / memory.\r\n *\r\n * @method dispose\r\n * @for p5.MonoSynth\r\n */\r\n p5.MonoSynth.prototype.dispose = function() {\r\n AudioVoice.prototype.dispose.apply(this);\r\n\r\n if (this.env) {\r\n this.env.dispose();\r\n }\r\n if (this.oscillator) {\r\n this.oscillator.dispose();\r\n }\r\n };\r\n\r\n});\r\n","'use strict';\r\ndefine(function() {\r\n var p5sound = require('master');\r\n\r\n /**\r\n * Base class for monophonic synthesizers. Any extensions of this class\r\n * should follow the API and implement the methods below in order to\r\n * remain compatible with p5.PolySynth();\r\n *\r\n * @class p5.AudioVoice\r\n * @constructor\r\n */\r\n p5.AudioVoice = function () {\r\n\t this.ac = p5sound.audiocontext;\r\n\t this.output = this.ac.createGain();\r\n\t this.connect();\r\n\t p5sound.soundArray.push(this);\r\n };\r\n\r\n p5.AudioVoice.prototype.play = function (note, velocity, secondsFromNow, sustime) {\r\n };\r\n\r\n p5.AudioVoice.prototype.triggerAttack = function (note, velocity, secondsFromNow) {\r\n };\r\n\r\n p5.AudioVoice.prototype.triggerRelease = function (secondsFromNow) {\r\n };\r\n\r\n p5.AudioVoice.prototype.amp = function(vol, rampTime) {\r\n };\r\n\r\n /**\r\n * Connect to p5 objects or Web Audio Nodes\r\n * @method connect\r\n * @for p5.AudioVoice\r\n * @param {Object} unit\r\n */\r\n p5.AudioVoice.prototype.connect = function(unit) {\r\n var u = unit || p5sound.input;\r\n this.output.connect(u.input ? u.input : u);\r\n };\r\n\r\n /**\r\n * Disconnect from soundOut\r\n * @method disconnect\r\n * @for p5.AudioVoice\r\n */\r\n p5.AudioVoice.prototype.disconnect = function() {\r\n this.output.disconnect();\r\n };\r\n\r\n p5.AudioVoice.prototype.dispose = function() {\r\n if (this.output) {\r\n this.output.disconnect();\r\n delete this.output;\r\n }\r\n };\r\n\r\n return p5.AudioVoice;\r\n});\r\n","'use strict';\r\ndefine(function (require) {\r\n\r\n var p5sound = require('master');\r\n var TimelineSignal = require('Tone/signal/TimelineSignal');\r\n var noteToFreq = require('helpers').noteToFreq;\r\n\r\n /**\r\n * An AudioVoice is used as a single voice for sound synthesis.\r\n * The PolySynth class holds an array of AudioVoice, and deals\r\n * with voices allocations, with setting notes to be played, and\r\n * parameters to be set.\r\n *\r\n * @class p5.PolySynth\r\n * @constructor\r\n *\r\n * @param {Number} [synthVoice] A monophonic synth voice inheriting\r\n * the AudioVoice class. Defaults to p5.MonoSynth\r\n * @param {Number} [maxVoices] Number of voices, defaults to 8;\r\n * @example\r\n *
\r\n * let polySynth;\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * cnv.mousePressed(playSynth);\r\n * background(220);\r\n * text('click to play', 20, 20);\r\n *\r\n * polySynth = new p5.PolySynth();\r\n * }\r\n *\r\n * function playSynth() {\r\n * userStartAudio();\r\n *\r\n * // note duration (in seconds)\r\n * let dur = 1.5;\r\n *\r\n * // time from now (in seconds)\r\n * let time = 0;\r\n *\r\n * // velocity (volume, from 0 to 1)\r\n * let vel = 0.1;\r\n *\r\n * // notes can overlap with each other\r\n * polySynth.play('G2', vel, 0, dur);\r\n * polySynth.play('C3', vel, time += 1/3, dur);\r\n * polySynth.play('G3', vel, time += 1/3, dur);\r\n * }\r\n *
\r\n **/\r\n p5.PolySynth = function(audioVoice, maxVoices) {\r\n //audiovoices will contain maxVoices many monophonic synths\r\n this.audiovoices = [];\r\n\r\n /**\r\n * An object that holds information about which notes have been played and\r\n * which notes are currently being played. New notes are added as keys\r\n * on the fly. While a note has been attacked, but not released, the value of the\r\n * key is the audiovoice which is generating that note. When notes are released,\r\n * the value of the key becomes undefined.\r\n * @property notes\r\n */\r\n this.notes = {};\r\n\r\n //indices of the most recently used, and least recently used audiovoice\r\n this._newest = 0;\r\n this._oldest = 0;\r\n\r\n /**\r\n * A PolySynth must have at least 1 voice, defaults to 8\r\n * @property polyvalue\r\n */\r\n this.maxVoices = maxVoices || 8;\r\n\r\n /**\r\n * Monosynth that generates the sound for each note that is triggered. The\r\n * p5.PolySynth defaults to using the p5.MonoSynth as its voice.\r\n * @property AudioVoice\r\n */\r\n this.AudioVoice = audioVoice === undefined ? p5.MonoSynth : audioVoice;\r\n\r\n /**\r\n * This value must only change as a note is attacked or released. Due to delay\r\n * and sustain times, Tone.TimelineSignal is required to schedule the change in value.\r\n\t * @private\r\n * @property {Tone.TimelineSignal} _voicesInUse\r\n */\r\n this._voicesInUse = new TimelineSignal(0);\r\n\r\n this.output = p5sound.audiocontext.createGain();\r\n this.connect();\r\n\r\n //Construct the appropriate number of audiovoices\r\n this._allocateVoices();\r\n p5sound.soundArray.push(this);\r\n };\r\n\r\n /**\r\n * Construct the appropriate number of audiovoices\r\n * @private\r\n * @for p5.PolySynth\r\n * @method _allocateVoices\r\n */\r\n p5.PolySynth.prototype._allocateVoices = function() {\r\n for(var i = 0; i< this.maxVoices; i++) {\r\n this.audiovoices.push(new this.AudioVoice());\r\n this.audiovoices[i].disconnect();\r\n this.audiovoices[i].connect(this.output);\r\n }\r\n };\r\n\r\n /**\r\n * Play a note by triggering noteAttack and noteRelease with sustain time\r\n *\r\n * @method play\r\n * @for p5.PolySynth\r\n * @param {Number} [note] midi note to play (ranging from 0 to 127 - 60 being a middle C)\r\n * @param {Number} [velocity] velocity of the note to play (ranging from 0 to 1)\r\n * @param {Number} [secondsFromNow] time from now (in seconds) at which to play\r\n * @param {Number} [sustainTime] time to sustain before releasing the envelope\r\n * @example\r\n *
\r\n * let polySynth;\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * cnv.mousePressed(playSynth);\r\n * background(220);\r\n * text('click to play', 20, 20);\r\n *\r\n * polySynth = new p5.PolySynth();\r\n * }\r\n *\r\n * function playSynth() {\r\n * userStartAudio();\r\n *\r\n * // note duration (in seconds)\r\n * let dur = 1.5;\r\n *\r\n * // time from now (in seconds)\r\n * let time = 0;\r\n *\r\n * // velocity (volume, from 0 to 1)\r\n * let vel = 0.1;\r\n *\r\n * // notes can overlap with each other\r\n * polySynth.play('G2', vel, 0, dur);\r\n * polySynth.play('C3', vel, time += 1/3, dur);\r\n * polySynth.play('G3', vel, time += 1/3, dur);\r\n * }\r\n *
\r\n */\r\n p5.PolySynth.prototype.play = function (note,velocity, secondsFromNow, susTime) {\r\n var susTime = susTime || 1;\r\n this.noteAttack(note, velocity, secondsFromNow);\r\n this.noteRelease(note, secondsFromNow + susTime);\r\n };\r\n\r\n\r\n /**\r\n * noteADSR sets the envelope for a specific note that has just been triggered.\r\n * Using this method modifies the envelope of whichever audiovoice is being used\r\n * to play the desired note. The envelope should be reset before noteRelease is called\r\n * in order to prevent the modified envelope from being used on other notes.\r\n *\r\n * @method noteADSR\r\n * @for p5.PolySynth\r\n * @param {Number} [note] Midi note on which ADSR should be set.\r\n * @param {Number} [attackTime] Time (in seconds before envelope\r\n * reaches Attack Level\r\n * @param {Number} [decayTime] Time (in seconds) before envelope\r\n * reaches Decay/Sustain Level\r\n * @param {Number} [susRatio] Ratio between attackLevel and releaseLevel, on a scale from 0 to 1,\r\n * where 1.0 = attackLevel, 0.0 = releaseLevel.\r\n * The susRatio determines the decayLevel and the level at which the\r\n * sustain portion of the envelope will sustain.\r\n * For example, if attackLevel is 0.4, releaseLevel is 0,\r\n * and susAmt is 0.5, the decayLevel would be 0.2. If attackLevel is\r\n * increased to 1.0 (using setRange),\r\n * then decayLevel would increase proportionally, to become 0.5.\r\n * @param {Number} [releaseTime] Time in seconds from now (defaults to 0)\r\n **/\r\n\r\n p5.PolySynth.prototype.noteADSR = function (note,a,d,s,r,timeFromNow) {\r\n var now = p5sound.audiocontext.currentTime;\r\n var timeFromNow = timeFromNow || 0;\r\n var t = now + timeFromNow\r\n this.audiovoices[ this.notes[note].getValueAtTime(t) ].setADSR(a,d,s,r);\r\n };\r\n\r\n\r\n /**\r\n * Set the PolySynths global envelope. This method modifies the envelopes of each\r\n * monosynth so that all notes are played with this envelope.\r\n *\r\n * @method setADSR\r\n * @for p5.PolySynth\r\n * @param {Number} [attackTime] Time (in seconds before envelope\r\n * reaches Attack Level\r\n * @param {Number} [decayTime] Time (in seconds) before envelope\r\n * reaches Decay/Sustain Level\r\n * @param {Number} [susRatio] Ratio between attackLevel and releaseLevel, on a scale from 0 to 1,\r\n * where 1.0 = attackLevel, 0.0 = releaseLevel.\r\n * The susRatio determines the decayLevel and the level at which the\r\n * sustain portion of the envelope will sustain.\r\n * For example, if attackLevel is 0.4, releaseLevel is 0,\r\n * and susAmt is 0.5, the decayLevel would be 0.2. If attackLevel is\r\n * increased to 1.0 (using setRange),\r\n * then decayLevel would increase proportionally, to become 0.5.\r\n * @param {Number} [releaseTime] Time in seconds from now (defaults to 0)\r\n **/\r\n p5.PolySynth.prototype.setADSR = function(a,d,s,r) {\r\n this.audiovoices.forEach(function(voice) {\r\n voice.setADSR(a,d,s,r);\r\n });\r\n };\r\n\r\n /**\r\n * Trigger the Attack, and Decay portion of a MonoSynth.\r\n * Similar to holding down a key on a piano, but it will\r\n * hold the sustain level until you let go.\r\n *\r\n * @method noteAttack\r\n * @for p5.PolySynth\r\n * @param {Number} [note] midi note on which attack should be triggered.\r\n * @param {Number} [velocity] velocity of the note to play (ranging from 0 to 1)/\r\n * @param {Number} [secondsFromNow] time from now (in seconds)\r\n * @example\r\n *
\r\n * let polySynth = new p5.PolySynth();\r\n * let pitches = ['G', 'D', 'G', 'C'];\r\n * let octaves = [2, 3, 4];\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * cnv.mousePressed(playChord);\r\n * background(220);\r\n * text('tap to play', 20, 20);\r\n * }\r\n *\r\n * function playChord() {\r\n * userStartAudio();\r\n *\r\n * // play a chord: multiple notes at the same time\r\n * for (let i = 0; i < 4; i++) {\r\n * let note = random(pitches) + random(octaves);\r\n * polySynth.noteAttack(note, 0.1);\r\n * }\r\n * }\r\n *\r\n * function mouseReleased() {\r\n * // release all voices\r\n * polySynth.noteRelease();\r\n * }\r\n *
\r\n */\r\n p5.PolySynth.prototype.noteAttack = function (_note, _velocity, secondsFromNow) {\r\n //this value goes to the audiovoices which handle their own scheduling\r\n var secondsFromNow = ~~secondsFromNow;\r\n\r\n //this value is used by this._voicesInUse\r\n var acTime = p5sound.audiocontext.currentTime + secondsFromNow;\r\n\r\n //Convert note to frequency if necessary. This is because entries into this.notes\r\n //should be based on frequency for the sake of consistency.\r\n var note = noteToFreq(_note);\r\n var velocity = _velocity || 0.1;\r\n\r\n var currentVoice;\r\n\r\n //Release the note if it is already playing\r\n if (this.notes[note] && this.notes[note].getValueAtTime(acTime) !== null) {\r\n this.noteRelease(note, 0);\r\n }\r\n\r\n //Check to see how many voices are in use at the time the note will start\r\n if (this._voicesInUse.getValueAtTime(acTime) < this.maxVoices) {\r\n currentVoice = Math.max(~~this._voicesInUse.getValueAtTime(acTime), 0);\r\n }\r\n //If we are exceeding the polyvalue, bump off the oldest notes and replace\r\n //with a new note\r\n else {\r\n currentVoice = this._oldest;\r\n\r\n var oldestNote = p5.prototype.freqToMidi(this.audiovoices[this._oldest].oscillator.freq().value);\r\n this.noteRelease(oldestNote);\r\n this._oldest = ( this._oldest + 1 ) % (this.maxVoices - 1);\r\n }\r\n\r\n //Overrite the entry in the notes object. A note (frequency value)\r\n //corresponds to the index of the audiovoice that is playing it\r\n this.notes[note] = new TimelineSignal();\r\n this.notes[note].setValueAtTime(currentVoice, acTime);\r\n\r\n //Find the scheduled change in this._voicesInUse that will be previous to this new note\r\n //Add 1 and schedule this value at time 't', when this note will start playing\r\n var previousVal = this._voicesInUse._searchBefore(acTime) === null ? 0 : this._voicesInUse._searchBefore(acTime).value;\r\n this._voicesInUse.setValueAtTime(previousVal + 1, acTime);\r\n\r\n //Then update all scheduled values that follow to increase by 1\r\n this._updateAfter(acTime, 1);\r\n\r\n this._newest = currentVoice;\r\n //The audiovoice handles the actual scheduling of the note\r\n if (typeof velocity === 'number') {\r\n var maxRange = 1 / this._voicesInUse.getValueAtTime(acTime) * 2;\r\n velocity = velocity > maxRange ? maxRange : velocity;\r\n }\r\n this.audiovoices[currentVoice].triggerAttack(note, velocity, secondsFromNow);\r\n };\r\n\r\n /**\r\n * Private method to ensure accurate values of this._voicesInUse\r\n * Any time a new value is scheduled, it is necessary to increment all subsequent\r\n * scheduledValues after attack, and decrement all subsequent\r\n * scheduledValues after release\r\n *\r\n * @private\r\n * @for p5.PolySynth\r\n * @param {[type]} time [description]\r\n * @param {[type]} value [description]\r\n * @return {[type]} [description]\r\n */\r\n p5.PolySynth.prototype._updateAfter = function(time, value) {\r\n if(this._voicesInUse._searchAfter(time) === null) {\r\n return;\r\n } else{\r\n this._voicesInUse._searchAfter(time).value += value;\r\n var nextTime = this._voicesInUse._searchAfter(time).time;\r\n this._updateAfter(nextTime, value);\r\n }\r\n };\r\n\r\n\r\n /**\r\n * Trigger the Release of an AudioVoice note. This is similar to releasing\r\n * the key on a piano and letting the sound fade according to the\r\n * release level and release time.\r\n *\r\n * @method noteRelease\r\n * @for p5.PolySynth\r\n * @param {Number} [note] midi note on which attack should be triggered.\r\n * If no value is provided, all notes will be released.\r\n * @param {Number} [secondsFromNow] time to trigger the release\r\n * @example\r\n *
\r\n * let polySynth = new p5.PolySynth();\r\n * let pitches = ['G', 'D', 'G', 'C'];\r\n * let octaves = [2, 3, 4];\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * cnv.mousePressed(playChord);\r\n * background(220);\r\n * text('tap to play', 20, 20);\r\n * }\r\n *\r\n * function playChord() {\r\n * userStartAudio();\r\n *\r\n * // play a chord: multiple notes at the same time\r\n * for (let i = 0; i < 4; i++) {\r\n * let note = random(pitches) + random(octaves);\r\n * polySynth.noteAttack(note, 0.1);\r\n * }\r\n * }\r\n *\r\n * function mouseReleased() {\r\n * // release all voices\r\n * polySynth.noteRelease();\r\n * }\r\n *
\r\n *\r\n */\r\n p5.PolySynth.prototype.noteRelease = function (_note,secondsFromNow) {\r\n var now = p5sound.audiocontext.currentTime;\r\n var tFromNow = secondsFromNow || 0;\r\n var t = now + tFromNow;\r\n\r\n // if a note value is not provided, release all voices\r\n if (!_note) {\r\n this.audiovoices.forEach(function(voice) {\r\n voice.triggerRelease(tFromNow)\r\n });\r\n this._voicesInUse.setValueAtTime(0, t);\r\n for (var n in this.notes) {\r\n this.notes[n].dispose();\r\n delete this.notes[n];\r\n }\r\n return;\r\n }\r\n\r\n //Make sure note is in frequency inorder to query the this.notes object\r\n var note = noteToFreq(_note);\r\n\r\n if (!this.notes[note] || this.notes[note].getValueAtTime(t) === null) {\r\n console.warn('Cannot release a note that is not already playing');\r\n } else {\r\n //Find the scheduled change in this._voicesInUse that will be previous to this new note\r\n //subtract 1 and schedule this value at time 't', when this note will stop playing\r\n var previousVal = Math.max(~~this._voicesInUse.getValueAtTime(t).value, 1);\r\n this._voicesInUse.setValueAtTime(previousVal - 1, t);\r\n //Then update all scheduled values that follow to decrease by 1 but never go below 0\r\n if (previousVal > 0) {\r\n this._updateAfter(t, -1);\r\n }\r\n\r\n this.audiovoices[ this.notes[note].getValueAtTime(t) ].triggerRelease(tFromNow);\r\n this.notes[note].dispose();\r\n delete this.notes[note];\r\n\r\n this._newest = this._newest === 0 ? 0 : (this._newest - 1) % (this.maxVoices - 1);\r\n }\r\n\r\n };\r\n\r\n /**\r\n * Connect to a p5.sound / Web Audio object.\r\n *\r\n * @method connect\r\n * @for p5.PolySynth\r\n * @param {Object} unit A p5.sound or Web Audio object\r\n */\r\n p5.PolySynth.prototype.connect = function (unit) {\r\n var u = unit || p5sound.input;\r\n this.output.connect(u.input ? u.input : u);\r\n };\r\n\r\n /**\r\n * Disconnect all outputs\r\n *\r\n * @method disconnect\r\n * @for p5.PolySynth\r\n */\r\n p5.PolySynth.prototype.disconnect = function() {\r\n if (this.output) {\r\n this.output.disconnect();\r\n }\r\n };\r\n\r\n /**\r\n * Get rid of the MonoSynth and free up its resources / memory.\r\n *\r\n * @method dispose\r\n * @for p5.PolySynth\r\n */\r\n p5.PolySynth.prototype.dispose = function() {\r\n this.audiovoices.forEach(function(voice) {\r\n voice.dispose();\r\n });\r\n\r\n if (this.output) {\r\n this.output.disconnect();\r\n delete this.output;\r\n }\r\n };\r\n\r\n});\r\n","'use strict';\r\n\r\ndefine(function (require) {\r\n\r\n require('audioworklet-polyfill');\r\n require('shims');\r\n require('audiocontext');\r\n var p5SOUND = require('master');\r\n require('helpers');\r\n require('errorHandler');\r\n require('audioWorklet');\r\n require('panner');\r\n require('soundfile');\r\n require('amplitude');\r\n require('fft');\r\n require('signal');\r\n require('oscillator');\r\n require('envelope');\r\n require('pulse');\r\n require('noise');\r\n require('audioin');\r\n require('filter');\r\n require('eq');\r\n require('panner3d');\r\n require('listener3d');\r\n require('delay');\r\n require('reverb');\r\n require('metro');\r\n require('looper');\r\n require('soundLoop');\r\n require('compressor');\r\n require('soundRecorder');\r\n require('peakDetect');\r\n require('gain');\r\n require('monosynth');\r\n require('polysynth');\r\n require('distortion');\r\n require('audioVoice');\r\n require('monosynth');\r\n require('polysynth');\r\n\r\n return p5SOUND;\r\n\r\n});\r\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';\r\n\r\ndefine(function (require) {\r\n\r\n var p5sound = require('master');\r\n var ac = p5sound.audiocontext;\r\n\r\n // Stereo panner\r\n // if there is a stereo panner node use it\r\n if(typeof ac.createStereoPanner !== 'undefined') {\r\n p5.Panner = function (input, output) {\r\n this.stereoPanner = this.input = ac.createStereoPanner();\r\n input.connect(this.stereoPanner);\r\n this.stereoPanner.connect(output);\r\n };\r\n\r\n p5.Panner.prototype.pan = function(val, tFromNow) {\r\n var time = tFromNow || 0;\r\n var t = ac.currentTime + time;\r\n\r\n this.stereoPanner.pan.linearRampToValueAtTime(val, t);\r\n };\r\n\r\n //not implemented because stereopanner\r\n //node does not require this and will automatically\r\n //convert single channel or multichannel to stereo.\r\n //tested with single and stereo, not with (>2) multichannel\r\n p5.Panner.prototype.inputChannels = function() {};\r\n\r\n p5.Panner.prototype.connect = function(obj) {\r\n this.stereoPanner.connect(obj);\r\n };\r\n\r\n p5.Panner.prototype.disconnect = function() {\r\n if (this.stereoPanner) {\r\n this.stereoPanner.disconnect();\r\n }\r\n };\r\n\r\n } else {\r\n // if there is no createStereoPanner object\r\n // such as in safari 7.1.7 at the time of writing this\r\n // use this method to create the effect\r\n p5.Panner = function(input, output, numInputChannels) {\r\n this.input = ac.createGain();\r\n input.connect(this.input);\r\n\r\n this.left = ac.createGain();\r\n this.right = ac.createGain();\r\n this.left.channelInterpretation = 'discrete';\r\n this.right.channelInterpretation = 'discrete';\r\n\r\n // if input is stereo\r\n if (numInputChannels > 1) {\r\n this.splitter = ac.createChannelSplitter(2);\r\n this.input.connect(this.splitter);\r\n\r\n this.splitter.connect(this.left, 1);\r\n this.splitter.connect(this.right, 0);\r\n }\r\n else {\r\n this.input.connect(this.left);\r\n this.input.connect(this.right);\r\n }\r\n\r\n this.output = ac.createChannelMerger(2);\r\n this.left.connect(this.output, 0, 1);\r\n this.right.connect(this.output, 0, 0);\r\n this.output.connect(output);\r\n };\r\n\r\n // -1 is left, +1 is right\r\n p5.Panner.prototype.pan = function(val, tFromNow) {\r\n var time = tFromNow || 0;\r\n var t = ac.currentTime + time;\r\n var v = (val + 1) / 2;\r\n var rightVal = Math.cos(v*Math.PI/2);\r\n var leftVal = Math.sin(v * Math.PI/2);\r\n this.left.gain.linearRampToValueAtTime(leftVal, t);\r\n this.right.gain.linearRampToValueAtTime(rightVal, t);\r\n };\r\n\r\n p5.Panner.prototype.inputChannels = function(numChannels) {\r\n if (numChannels === 1) {\r\n this.input.disconnect();\r\n this.input.connect(this.left);\r\n this.input.connect(this.right);\r\n } else if (numChannels === 2) {\r\n if (typeof(this.splitter === 'undefined')) {\r\n this.splitter = ac.createChannelSplitter(2);\r\n }\r\n this.input.disconnect();\r\n this.input.connect(this.splitter);\r\n this.splitter.connect(this.left, 1);\r\n this.splitter.connect(this.right, 0);\r\n }\r\n };\r\n\r\n p5.Panner.prototype.connect = function(obj) {\r\n this.output.connect(obj);\r\n };\r\n\r\n p5.Panner.prototype.disconnect = function() {\r\n if (this.output) {\r\n this.output.disconnect();\r\n }\r\n };\r\n }\r\n});\r\n","'use strict';\r\n\r\ndefine(function (require) {\r\n\r\n const CustomError = require('errorHandler');\r\n const p5sound = require('master');\r\n const ac = p5sound.audiocontext;\r\n const { midiToFreq, convertToWav, safeBufferSize } = require('helpers');\r\n var processorNames = require('./audioWorklet/processorNames');\r\n\r\n /**\r\n *

SoundFile object with a path to a file.

\r\n *\r\n *

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

\r\n *\r\n *

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

\r\n *\r\n *

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

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

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

\r\n *\r\n *

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

\r\n *\r\n *

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

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

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

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

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

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

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

\r\n *\r\n *

This is necessary because Web Audio is processed on a seprate clock.\r\n * For example, the p5 draw loop runs about 60 times per second. But\r\n * the audio clock must process samples 44100 times per second. If we\r\n * want to add a value to each of those samples, we can't do it in the\r\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\r\n * a Tone.Signal from the Tone.js library by Yotam Mann.\r\n * If you want to work directly with audio signals for modular\r\n * synthesis, check out\r\n * tone.js.

\r\n *\r\n * @class p5.Signal\r\n * @constructor\r\n * @return {Tone.Signal} A Signal object from the Tone.js library\r\n * @example\r\n *
\r\n * let carrier, modulator;\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * cnv.mousePressed(canvasPressed);\r\n * background(220);\r\n * text('tap to play', 20, 20);\r\n *\r\n * carrier = new p5.Oscillator('sine');\r\n * carrier.start();\r\n * carrier.amp(1); // set amplitude\r\n * carrier.freq(220); // set frequency\r\n *\r\n * modulator = new p5.Oscillator('sawtooth');\r\n * modulator.disconnect();\r\n * modulator.start();\r\n * modulator.amp(1);\r\n * modulator.freq(4);\r\n *\r\n * // Modulator's default amplitude range is -1 to 1.\r\n * // Multiply it by -200, so the range is -200 to 200\r\n * // then add 220 so the range is 20 to 420\r\n * carrier.freq( modulator.mult(-400).add(220) );\r\n * }\r\n *\r\n * function canvasPressed() {\r\n * userStartAudio();\r\n * carrier.amp(1.0);\r\n * }\r\n *\r\n * function mouseReleased() {\r\n * carrier.amp(0);\r\n * }\r\n *
\r\n */\r\n p5.Signal = function(value) {\r\n var s = new Signal(value);\r\n // p5sound.soundArray.push(s);\r\n return s; // TODO: is this really a constructor?\r\n };\r\n\r\n /**\r\n * Fade to value, for smooth transitions\r\n *\r\n * @method fade\r\n * @for p5.Signal\r\n * @param {Number} value Value to set this signal\r\n * @param {Number} [secondsFromNow] Length of fade, in seconds from now\r\n */\r\n Signal.prototype.fade = Signal.prototype.linearRampToValueAtTime;\r\n Mult.prototype.fade = Signal.prototype.fade;\r\n Add.prototype.fade = Signal.prototype.fade;\r\n Scale.prototype.fade = Signal.prototype.fade;\r\n\r\n\r\n /**\r\n * Connect a p5.sound object or Web Audio node to this\r\n * p5.Signal so that its amplitude values can be scaled.\r\n *\r\n * @method setInput\r\n * @for p5.Signal\r\n * @param {Object} input\r\n */\r\n Signal.prototype.setInput = function(_input) {\r\n _input.connect(this);\r\n };\r\n Mult.prototype.setInput = Signal.prototype.setInput;\r\n Add.prototype.setInput = Signal.prototype.setInput;\r\n Scale.prototype.setInput = Signal.prototype.setInput;\r\n\r\n\r\n // signals can add / mult / scale themselves\r\n\r\n /**\r\n * Add a constant value to this audio signal,\r\n * and return the resulting audio signal. Does\r\n * not change the value of the original signal,\r\n * instead it returns a new p5.SignalAdd.\r\n *\r\n * @method add\r\n * @for p5.Signal\r\n * @param {Number} number\r\n * @return {p5.Signal} object\r\n */\r\n Signal.prototype.add = function(num) {\r\n var add = new Add(num);\r\n // add.setInput(this);\r\n this.connect(add);\r\n return add;\r\n };\r\n Mult.prototype.add = Signal.prototype.add;\r\n Add.prototype.add = Signal.prototype.add;\r\n Scale.prototype.add = Signal.prototype.add;\r\n\r\n /**\r\n * Multiply this signal by a constant value,\r\n * and return the resulting audio signal. Does\r\n * not change the value of the original signal,\r\n * instead it returns a new p5.SignalMult.\r\n *\r\n * @method mult\r\n * @for p5.Signal\r\n * @param {Number} number to multiply\r\n * @return {p5.Signal} object\r\n */\r\n Signal.prototype.mult = function(num) {\r\n var mult = new Mult(num);\r\n // mult.setInput(this);\r\n this.connect(mult);\r\n return mult;\r\n };\r\n Mult.prototype.mult = Signal.prototype.mult;\r\n Add.prototype.mult = Signal.prototype.mult;\r\n Scale.prototype.mult = Signal.prototype.mult;\r\n\r\n /**\r\n * Scale this signal value to a given range,\r\n * and return the result as an audio signal. Does\r\n * not change the value of the original signal,\r\n * instead it returns a new p5.SignalScale.\r\n *\r\n * @method scale\r\n * @for p5.Signal\r\n * @param {Number} number to multiply\r\n * @param {Number} inMin input range minumum\r\n * @param {Number} inMax input range maximum\r\n * @param {Number} outMin input range minumum\r\n * @param {Number} outMax input range maximum\r\n * @return {p5.Signal} object\r\n */\r\n Signal.prototype.scale = function(inMin, inMax, outMin, outMax) {\r\n var mapOutMin, mapOutMax;\r\n if (arguments.length === 4) {\r\n mapOutMin = p5.prototype.map(outMin, inMin, inMax, 0, 1) - 0.5;\r\n mapOutMax = p5.prototype.map(outMax, inMin, inMax, 0, 1) - 0.5;\r\n }\r\n else {\r\n mapOutMin = arguments[0];\r\n mapOutMax = arguments[1];\r\n }\r\n var scale = new Scale(mapOutMin, mapOutMax);\r\n this.connect(scale);\r\n return scale;\r\n };\r\n Mult.prototype.scale = Signal.prototype.scale;\r\n Add.prototype.scale = Signal.prototype.scale;\r\n Scale.prototype.scale = Signal.prototype.scale;\r\n\r\n});\r\n\r\n\r\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';\r\n\r\ndefine(function (require) {\r\n\r\n var p5sound = require('master');\r\n var Add = require('Tone/signal/Add');\r\n var Mult = require('Tone/signal/Multiply');\r\n var Scale = require('Tone/signal/Scale');\r\n var TimelineSignal = require('Tone/signal/TimelineSignal');\r\n\r\n /**\r\n *

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

\r\n *

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

\r\n *

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

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

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

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

\r\n *\r\n *

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

\r\n *\r\n *

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

\r\n *\r\n *

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

\r\n *\r\n * @class p5.AudioIn\r\n * @constructor\r\n * @param {Function} [errorCallback] A function to call if there is an error\r\n * accessing the AudioIn. For example,\r\n * Safari and iOS devices do not\r\n * currently allow microphone access.\r\n * @example\r\n *
\r\n * let mic;\r\n *\r\n * function setup(){\r\n * let cnv = createCanvas(100, 100);\r\n * cnv.mousePressed(userStartAudio);\r\n * textAlign(CENTER);\r\n * mic = new p5.AudioIn();\r\n * mic.start();\r\n * }\r\n *\r\n * function draw(){\r\n * background(0);\r\n * fill(255);\r\n * text('tap to start', width/2, 20);\r\n *\r\n * micLevel = mic.getLevel();\r\n * let y = height - micLevel * height;\r\n * ellipse(width/2, y, 10, 10);\r\n * }\r\n *
\r\n */\r\n p5.AudioIn = function(errorCallback) {\r\n // set up audio input\r\n /**\r\n * @property {GainNode} input\r\n */\r\n this.input = p5sound.audiocontext.createGain();\r\n /**\r\n * @property {GainNode} output\r\n */\r\n this.output = p5sound.audiocontext.createGain();\r\n\r\n /**\r\n * @property {MediaStream|null} stream\r\n */\r\n this.stream = null;\r\n /**\r\n * @property {MediaStreamAudioSourceNode|null} mediaStream\r\n */\r\n this.mediaStream = null;\r\n /**\r\n * @property {Number|null} currentSource\r\n */\r\n this.currentSource = null;\r\n\r\n /**\r\n * Client must allow browser to access their microphone / audioin source.\r\n * Default: false. Will become true when the client enables access.\r\n *\r\n * @property {Boolean} enabled\r\n */\r\n this.enabled = false;\r\n\r\n /**\r\n * Input amplitude, connect to it by default but not to master out\r\n *\r\n * @property {p5.Amplitude} amplitude\r\n */\r\n this.amplitude = new p5.Amplitude();\r\n this.output.connect(this.amplitude.input);\r\n\r\n if (!window.MediaStreamTrack || !window.navigator.mediaDevices || !window.navigator.mediaDevices.getUserMedia) {\r\n errorCallback ? errorCallback() : window.alert('This browser does not support MediaStreamTrack and mediaDevices');\r\n }\r\n\r\n // add to soundArray so we can dispose on close\r\n p5sound.soundArray.push(this);\r\n };\r\n\r\n /**\r\n * Start processing audio input. This enables the use of other\r\n * AudioIn methods like getLevel(). Note that by default, AudioIn\r\n * is not connected to p5.sound's output. So you won't hear\r\n * anything unless you use the connect() method.
\r\n *\r\n * Certain browsers limit access to the user's microphone. For example,\r\n * Chrome only allows access from localhost and over https. For this reason,\r\n * you may want to include an errorCallback—a function that is called in case\r\n * the browser won't provide mic access.\r\n *\r\n * @method start\r\n * @for p5.AudioIn\r\n * @param {Function} [successCallback] Name of a function to call on\r\n * success.\r\n * @param {Function} [errorCallback] Name of a function to call if\r\n * there was an error. For example,\r\n * some browsers do not support\r\n * getUserMedia.\r\n */\r\n p5.AudioIn.prototype.start = function(successCallback, errorCallback) {\r\n var self = this;\r\n\r\n if (this.stream) {\r\n this.stop();\r\n }\r\n\r\n // set the audio source\r\n var audioSource = p5sound.inputSources[self.currentSource];\r\n var constraints = {\r\n audio: {\r\n sampleRate: p5sound.audiocontext.sampleRate,\r\n echoCancellation: false\r\n }\r\n };\r\n\r\n // if developers determine which source to use\r\n if (p5sound.inputSources[this.currentSource]) {\r\n constraints.audio.deviceId = audioSource.deviceId;\r\n }\r\n\r\n window.navigator.mediaDevices.getUserMedia( constraints )\r\n .then( function(stream) {\r\n self.stream = stream;\r\n self.enabled = true;\r\n // Wrap a MediaStreamSourceNode around the live input\r\n self.mediaStream = p5sound.audiocontext.createMediaStreamSource(stream);\r\n self.mediaStream.connect(self.output);\r\n // only send to the Amplitude reader, so we can see it but not hear it.\r\n self.amplitude.setInput(self.output);\r\n if (successCallback) successCallback();\r\n })\r\n .catch( function(err) {\r\n if (errorCallback) errorCallback(err);\r\n else console.error(err);\r\n });\r\n };\r\n\r\n /**\r\n * Turn the AudioIn off. If the AudioIn is stopped, it cannot getLevel().\r\n * If re-starting, the user may be prompted for permission access.\r\n *\r\n * @method stop\r\n * @for p5.AudioIn\r\n */\r\n p5.AudioIn.prototype.stop = function() {\r\n if (this.stream) {\r\n this.stream.getTracks().forEach(function(track) {\r\n track.stop();\r\n });\r\n\r\n this.mediaStream.disconnect();\r\n\r\n delete this.mediaStream;\r\n delete this.stream;\r\n }\r\n };\r\n\r\n /**\r\n * Connect to an audio unit. If no parameter is provided, will\r\n * connect to the master output (i.e. your speakers).
\r\n *\r\n * @method connect\r\n * @for p5.AudioIn\r\n * @param {Object} [unit] An object that accepts audio input,\r\n * such as an FFT\r\n */\r\n p5.AudioIn.prototype.connect = function(unit) {\r\n if (unit) {\r\n if (unit.hasOwnProperty('input')) {\r\n this.output.connect(unit.input);\r\n }\r\n else if (unit.hasOwnProperty('analyser')) {\r\n this.output.connect(unit.analyser);\r\n }\r\n else {\r\n this.output.connect(unit);\r\n }\r\n }\r\n else {\r\n this.output.connect(p5sound.input);\r\n }\r\n };\r\n\r\n /**\r\n * Disconnect the AudioIn from all audio units. For example, if\r\n * connect() had been called, disconnect() will stop sending\r\n * signal to your speakers.
\r\n *\r\n * @method disconnect\r\n * @for p5.AudioIn\r\n */\r\n p5.AudioIn.prototype.disconnect = function() {\r\n if (this.output) {\r\n this.output.disconnect();\r\n // stay connected to amplitude even if not outputting to p5\r\n this.output.connect(this.amplitude.input);\r\n }\r\n };\r\n\r\n /**\r\n * Read the Amplitude (volume level) of an AudioIn. The AudioIn\r\n * class contains its own instance of the Amplitude class to help\r\n * make it easy to get a microphone's volume level. Accepts an\r\n * optional smoothing value (0.0 < 1.0). NOTE: AudioIn must\r\n * .start() before using .getLevel().
\r\n *\r\n * @method getLevel\r\n * @for p5.AudioIn\r\n * @param {Number} [smoothing] Smoothing is 0.0 by default.\r\n * Smooths values based on previous values.\r\n * @return {Number} Volume level (between 0.0 and 1.0)\r\n */\r\n p5.AudioIn.prototype.getLevel = function(smoothing) {\r\n if (smoothing) {\r\n this.amplitude.smoothing = smoothing;\r\n }\r\n return this.amplitude.getLevel();\r\n };\r\n\r\n /**\r\n * Set amplitude (volume) of a mic input between 0 and 1.0.
\r\n *\r\n * @method amp\r\n * @for p5.AudioIn\r\n * @param {Number} vol between 0 and 1.0\r\n * @param {Number} [time] ramp time (optional)\r\n */\r\n p5.AudioIn.prototype.amp = function(vol, t) {\r\n if (t) {\r\n var rampTime = t || 0;\r\n var currentVol = this.output.gain.value;\r\n this.output.gain.cancelScheduledValues(p5sound.audiocontext.currentTime);\r\n this.output.gain.setValueAtTime(currentVol, p5sound.audiocontext.currentTime);\r\n this.output.gain.linearRampToValueAtTime(vol, rampTime + p5sound.audiocontext.currentTime);\r\n } else {\r\n this.output.gain.cancelScheduledValues(p5sound.audiocontext.currentTime);\r\n this.output.gain.setValueAtTime(vol, p5sound.audiocontext.currentTime);\r\n }\r\n };\r\n\r\n /**\r\n * Returns a list of available input sources. This is a wrapper\r\n * for and it returns a Promise.\r\n *\r\n * @method getSources\r\n * @for p5.AudioIn\r\n * @param {Function} [successCallback] This callback function handles the sources when they\r\n * have been enumerated. The callback function\r\n * receives the deviceList array as its only argument\r\n * @param {Function} [errorCallback] This optional callback receives the error\r\n * message as its argument.\r\n * @returns {Promise} Returns a Promise that can be used in place of the callbacks, similar\r\n * to the enumerateDevices() method\r\n * @example\r\n *
\r\n * let audioIn;\r\n *\r\n * function setup(){\r\n * text('getting sources...', 0, 20);\r\n * audioIn = new p5.AudioIn();\r\n * audioIn.getSources(gotSources);\r\n * }\r\n *\r\n * function gotSources(deviceList) {\r\n * if (deviceList.length > 0) {\r\n * //set the source to the first item in the deviceList array\r\n * audioIn.setSource(0);\r\n * let currentSource = deviceList[audioIn.currentSource];\r\n * text('set source to: ' + currentSource.deviceId, 5, 20, width);\r\n * }\r\n * }\r\n *
\r\n */\r\n p5.AudioIn.prototype.getSources = function (onSuccess, onError) {\r\n return new Promise( function(resolve, reject) {\r\n window.navigator.mediaDevices.enumerateDevices()\r\n .then( function(devices) {\r\n p5sound.inputSources = devices.filter(function(device) {\r\n return device.kind === 'audioinput';\r\n });\r\n resolve(p5sound.inputSources);\r\n if (onSuccess) {\r\n onSuccess(p5sound.inputSources);\r\n }\r\n })\r\n .catch( function(error) {\r\n reject(error);\r\n if (onError) {\r\n onError(error);\r\n } else {\r\n console.error('This browser does not support MediaStreamTrack.getSources()');\r\n }\r\n });\r\n });\r\n };\r\n\r\n /**\r\n * Set the input source. Accepts a number representing a\r\n * position in the array returned by getSources().\r\n * This is only available in browsers that support\r\n * navigator.mediaDevices.enumerateDevices().
\r\n *\r\n * @method setSource\r\n * @for p5.AudioIn\r\n * @param {number} num position of input source in the array\r\n * @example\r\n *
\r\n * let audioIn;\r\n *\r\n * function setup(){\r\n * text('getting sources...', 0, 20);\r\n * audioIn = new p5.AudioIn();\r\n * audioIn.getSources(gotSources);\r\n * }\r\n *\r\n * function gotSources(deviceList) {\r\n * if (deviceList.length > 0) {\r\n * //set the source to the first item in the deviceList array\r\n * audioIn.setSource(0);\r\n * let currentSource = deviceList[audioIn.currentSource];\r\n * text('set source to: ' + currentSource.deviceId, 5, 20, width);\r\n * }\r\n * }\r\n *
\r\n */\r\n p5.AudioIn.prototype.setSource = function(num) {\r\n if (p5sound.inputSources.length > 0 && num < p5sound.inputSources.length) {\r\n // set the current source\r\n this.currentSource = num;\r\n console.log('set source to ', p5sound.inputSources[this.currentSource]);\r\n } else {\r\n console.log('unable to set input source');\r\n }\r\n\r\n // restart stream if currently active\r\n if (this.stream && this.stream.active) {\r\n this.start();\r\n }\r\n };\r\n\r\n // private method\r\n p5.AudioIn.prototype.dispose = function() {\r\n // remove reference from soundArray\r\n var index = p5sound.soundArray.indexOf(this);\r\n p5sound.soundArray.splice(index, 1);\r\n\r\n this.stop();\r\n\r\n if (this.output) {\r\n this.output.disconnect();\r\n }\r\n if (this.amplitude) {\r\n this.amplitude.disconnect();\r\n }\r\n delete this.amplitude;\r\n delete this.output;\r\n };\r\n\r\n});\r\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';\r\n\r\ndefine(function (require) {\r\n\r\n var Effect = require('effect');\r\n var EQFilter = require('eqFilter');\r\n\r\n /**\r\n * p5.EQ is an audio effect that performs the function of a multiband\r\n * audio equalizer. Equalization is used to adjust the balance of\r\n * frequency compoenents of an audio signal. This process is commonly used\r\n * in sound production and recording to change the waveform before it reaches\r\n * a sound output device. EQ can also be used as an audio effect to create\r\n * interesting distortions by filtering out parts of the spectrum. p5.EQ is\r\n * built using a chain of Web Audio Biquad Filter Nodes and can be\r\n * instantiated with 3 or 8 bands. Bands can be added or removed from\r\n * the EQ by directly modifying p5.EQ.bands (the array that stores filters).\r\n *\r\n * This class extends p5.Effect.\r\n * Methods amp(), chain(),\r\n * drywet(), connect(), and\r\n * disconnect() are available.\r\n *\r\n * @class p5.EQ\r\n * @constructor\r\n * @extends p5.Effect\r\n * @param {Number} [_eqsize] Constructor will accept 3 or 8, defaults to 3\r\n * @return {Object} p5.EQ object\r\n *\r\n * @example\r\n *
\r\n * let eq, soundFile\r\n * let eqBandIndex = 0;\r\n * let eqBandNames = ['lows', 'mids', 'highs'];\r\n *\r\n * function preload() {\r\n * soundFormats('mp3', 'ogg');\r\n * soundFile = loadSound('assets/beat');\r\n * }\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * cnv.mousePressed(toggleSound);\r\n *\r\n * eq = new p5.EQ(eqBandNames.length);\r\n * soundFile.disconnect();\r\n * eq.process(soundFile);\r\n * }\r\n *\r\n * function draw() {\r\n * background(30);\r\n * noStroke();\r\n * fill(255);\r\n * textAlign(CENTER);\r\n * text('filtering ', 50, 25);\r\n *\r\n * fill(255, 40, 255);\r\n * textSize(26);\r\n * text(eqBandNames[eqBandIndex], 50, 55);\r\n *\r\n * fill(255);\r\n * textSize(9);\r\n *\r\n * if (!soundFile.isPlaying()) {\r\n * text('tap to play', 50, 80);\r\n * } else {\r\n * text('tap to filter next band', 50, 80)\r\n * }\r\n * }\r\n *\r\n * function toggleSound() {\r\n * if (!soundFile.isPlaying()) {\r\n * soundFile.play();\r\n * } else {\r\n * eqBandIndex = (eqBandIndex + 1) % eq.bands.length;\r\n * }\r\n *\r\n * for (let i = 0; i < eq.bands.length; i++) {\r\n * eq.bands[i].gain(0);\r\n * }\r\n * // filter the band we want to filter\r\n * eq.bands[eqBandIndex].gain(-40);\r\n * }\r\n *
\r\n */\r\n p5.EQ = function(_eqsize) {\r\n Effect.call(this);\r\n\r\n //p5.EQ can be of size (3) or (8), defaults to 3\r\n _eqsize = _eqsize === 3 || _eqsize === 8 ? _eqsize : 3;\r\n\r\n var factor;\r\n _eqsize === 3 ? factor = Math.pow(2,3) : factor = 2;\r\n\r\n /**\r\n * The p5.EQ is built with abstracted p5.Filter objects.\r\n * To modify any bands, use methods of the \r\n * p5.Filter API, especially `gain` and `freq`.\r\n * Bands are stored in an array, with indices 0 - 3, or 0 - 7\r\n * @property {Array} bands\r\n *\r\n */\r\n this.bands = [];\r\n\r\n\r\n var freq, res;\r\n for (var i = 0; i < _eqsize; i++) {\r\n if (i === _eqsize - 1) {\r\n freq = 21000;\r\n res = .01;\r\n } else if (i === 0) {\r\n freq = 100;\r\n res = .1;\r\n }\r\n else if (i===1) {\r\n freq = _eqsize === 3 ? 360 * factor : 360;\r\n res = 1;\r\n }else {\r\n freq = this.bands[i-1].freq() * factor;\r\n res = 1;\r\n }\r\n this.bands[i] = this._newBand(freq, res);\r\n\r\n if (i>0) {\r\n this.bands[i-1].connect(this.bands[i].biquad);\r\n } else {\r\n this.input.connect(this.bands[i].biquad);\r\n }\r\n }\r\n this.bands[_eqsize-1].connect(this.output);\r\n };\r\n p5.EQ.prototype = Object.create(Effect.prototype);\r\n\r\n /**\r\n * Process an input by connecting it to the EQ\r\n * @method process\r\n * @param {Object} src Audio source\r\n */\r\n p5.EQ.prototype.process = function (src) {\r\n src.connect(this.input);\r\n };\r\n\r\n // /**\r\n // * Set the frequency and gain of each band in the EQ. This method should be\r\n // * called with 3 or 8 frequency and gain pairs, depending on the size of the EQ.\r\n // * ex. eq.set(freq0, gain0, freq1, gain1, freq2, gain2);\r\n // *\r\n // * @method set\r\n // * @for p5.EQ\r\n // * @param {Number} [freq0] Frequency value for band with index 0\r\n // * @param {Number} [gain0] Gain value for band with index 0\r\n // * @param {Number} [freq1] Frequency value for band with index 1\r\n // * @param {Number} [gain1] Gain value for band with index 1\r\n // * @param {Number} [freq2] Frequency value for band with index 2\r\n // * @param {Number} [gain2] Gain value for band with index 2\r\n // * @param {Number} [freq3] Frequency value for band with index 3\r\n // * @param {Number} [gain3] Gain value for band with index 3\r\n // * @param {Number} [freq4] Frequency value for band with index 4\r\n // * @param {Number} [gain4] Gain value for band with index 4\r\n // * @param {Number} [freq5] Frequency value for band with index 5\r\n // * @param {Number} [gain5] Gain value for band with index 5\r\n // * @param {Number} [freq6] Frequency value for band with index 6\r\n // * @param {Number} [gain6] Gain value for band with index 6\r\n // * @param {Number} [freq7] Frequency value for band with index 7\r\n // * @param {Number} [gain7] Gain value for band with index 7\r\n // */\r\n p5.EQ.prototype.set = function() {\r\n if (arguments.length === this.bands.length * 2) {\r\n for (var i = 0; i < arguments.length; i+=2) {\r\n this.bands[i/2].freq(arguments[i]);\r\n this.bands[i/2].gain(arguments[i+1]);\r\n }\r\n }\r\n else {\r\n console.error('Argument mismatch. .set() should be called with ' + this.bands.length*2 +\r\n ' arguments. (one frequency and gain value pair for each band of the eq)');\r\n }\r\n };\r\n\r\n /**\r\n * Add a new band. Creates a p5.Filter and strips away everything but\r\n * the raw biquad filter. This method returns an abstracted p5.Filter,\r\n * which can be added to p5.EQ.bands, in order to create new EQ bands.\r\n * @private\r\n * @for p5.EQ\r\n * @method _newBand\r\n * @param {Number} freq\r\n * @param {Number} res\r\n * @return {Object} Abstracted Filter\r\n */\r\n p5.EQ.prototype._newBand = function(freq, res) {\r\n return new EQFilter(freq, res);\r\n };\r\n\r\n p5.EQ.prototype.dispose = function () {\r\n Effect.prototype.dispose.apply(this);\r\n\r\n if (this.bands) {\r\n while (this.bands.length > 0) {\r\n delete this.bands.pop().dispose();\r\n }\r\n delete this.bands;\r\n }\r\n };\r\n\r\n return p5.EQ;\r\n});\r\n","'use strict';\r\n\r\ndefine(function (require) {\r\n var Filter = require('filter');\r\n var p5sound = require('master');\r\n\r\n /**\r\n * EQFilter extends p5.Filter with constraints\r\n * necessary for the p5.EQ\r\n *\r\n * @private\r\n */\r\n var EQFilter = function(freq, res) {\r\n Filter.call(this, 'peaking');\r\n this.disconnect();\r\n this.set(freq, res);\r\n this.biquad.gain.value = 0;\r\n delete this.input;\r\n delete this.output;\r\n delete this._drywet;\r\n delete this.wet;\r\n\r\n };\r\n EQFilter.prototype = Object.create(Filter.prototype);\r\n\r\n EQFilter.prototype.amp = function() {\r\n console.warn('`amp()` is not available for p5.EQ bands. Use `.gain()`');\r\n };\r\n EQFilter.prototype.drywet = function() {\r\n console.warn('`drywet()` is not available for p5.EQ bands.');\r\n };\r\n EQFilter.prototype.connect = function(unit) {\r\n var u = unit || p5.soundOut.input;\r\n if (this.biquad) {\r\n this.biquad.connect(u.input ? u.input : u);\r\n } else {\r\n this.output.connect(u.input ? u.input : u);\r\n }\r\n };\r\n\r\n EQFilter.prototype.disconnect = function() {\r\n if (this.biquad) {\r\n this.biquad.disconnect();\r\n }\r\n };\r\n EQFilter.prototype.dispose = function() {\r\n // remove reference form soundArray\r\n var index = p5sound.soundArray.indexOf(this);\r\n p5sound.soundArray.splice(index, 1);\r\n this.disconnect();\r\n delete this.biquad;\r\n };\r\n\r\n return EQFilter;\r\n});\r\n","'use strict'\r\n\r\ndefine(function (require) {\r\n var p5sound = require('master');\r\n var Effect = require('effect');\r\n\r\n /**\r\n * Panner3D is based on the \r\n * Web Audio Spatial Panner Node.\r\n * This panner is a spatial processing node that allows audio to be positioned\r\n * and oriented in 3D space.\r\n *\r\n * The position is relative to an \r\n * Audio Context Listener, which can be accessed\r\n * by p5.soundOut.audiocontext.listener\r\n *\r\n *\r\n * @class p5.Panner3D\r\n * @constructor\r\n */\r\n\tp5.Panner3D = function() {\r\n Effect.call(this);\r\n\r\n /**\r\n * \r\n * Web Audio Spatial Panner Node\r\n *\r\n * Properties include\r\n * - panningModel: \"equal power\" or \"HRTF\"\r\n * - distanceModel: \"linear\", \"inverse\", or \"exponential\"\r\n *\r\n * @property {AudioNode} panner\r\n *\r\n */\r\n this.panner = this.ac.createPanner();\r\n this.panner.panningModel = 'HRTF';\r\n this.panner.distanceModel = 'linear';\r\n this.panner.connect(this.output);\r\n this.input.connect(this.panner);\r\n\t};\r\n\r\n p5.Panner3D.prototype = Object.create(Effect.prototype);\r\n\r\n\r\n /**\r\n * Connect an audio sorce\r\n *\r\n * @method process\r\n * @for p5.Panner3D\r\n * @param {Object} src Input source\r\n */\r\n p5.Panner3D.prototype.process = function(src) {\r\n src.connect(this.input);\r\n }\r\n /**\r\n * Set the X,Y,Z position of the Panner\r\n * @method set\r\n * @for p5.Panner3D\r\n * @param {Number} xVal\r\n * @param {Number} yVal\r\n * @param {Number} zVal\r\n * @param {Number} time\r\n * @return {Array} Updated x, y, z values as an array\r\n */\r\n p5.Panner3D.prototype.set = function(xVal, yVal, zVal, time) {\r\n this.positionX(xVal,time);\r\n this.positionY(yVal,time);\r\n this.positionZ(zVal,time);\r\n return [this.panner.positionX.value,\r\n this.panner.positionY.value,\r\n this.panner.positionZ.value];\r\n };\r\n\r\n /**\r\n * Getter and setter methods for position coordinates\r\n * @method positionX\r\n * @for p5.Panner3D\r\n * @return {Number} updated coordinate value\r\n */\r\n /**\r\n * Getter and setter methods for position coordinates\r\n * @method positionY\r\n * @for p5.Panner3D\r\n * @return {Number} updated coordinate value\r\n */\r\n /**\r\n * Getter and setter methods for position coordinates\r\n * @method positionZ\r\n * @for p5.Panner3D\r\n * @return {Number} updated coordinate value\r\n */\r\n p5.Panner3D.prototype.positionX = function(xVal, time) {\r\n var t = time || 0;\r\n if (typeof xVal === 'number') {\r\n this.panner.positionX.value = xVal;\r\n this.panner.positionX.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.panner.positionX.linearRampToValueAtTime(xVal, this.ac.currentTime + 0.02 + t);\r\n } else if (xVal) {\r\n xVal.connect(this.panner.positionX);\r\n }\r\n return this.panner.positionX.value;\r\n };\r\n p5.Panner3D.prototype.positionY = function(yVal, time) {\r\n var t = time || 0;\r\n if (typeof yVal === 'number') {\r\n this.panner.positionY.value = yVal;\r\n this.panner.positionY.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.panner.positionY.linearRampToValueAtTime(yVal, this.ac.currentTime + 0.02 + t);\r\n } else if (yVal) {\r\n yVal.connect(this.panner.positionY);\r\n }\r\n return this.panner.positionY.value;\r\n };\r\n p5.Panner3D.prototype.positionZ = function(zVal, time) {\r\n var t = time || 0;\r\n if (typeof zVal === 'number') {\r\n this.panner.positionZ.value = zVal;\r\n this.panner.positionZ.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.panner.positionZ.linearRampToValueAtTime(zVal, this.ac.currentTime + 0.02 + t);\r\n } else if (zVal) {\r\n zVal.connect(this.panner.positionZ);\r\n }\r\n return this.panner.positionZ.value;\r\n };\r\n\r\n /**\r\n * Set the X,Y,Z position of the Panner\r\n * @method orient\r\n * @for p5.Panner3D\r\n * @param {Number} xVal\r\n * @param {Number} yVal\r\n * @param {Number} zVal\r\n * @param {Number} time\r\n * @return {Array} Updated x, y, z values as an array\r\n */\r\n p5.Panner3D.prototype.orient = function(xVal, yVal, zVal, time) {\r\n this.orientX(xVal,time);\r\n this.orientY(yVal,time);\r\n this.orientZ(zVal,time);\r\n return [this.panner.orientationX.value,\r\n this.panner.orientationY.value,\r\n this.panner.orientationZ.value];\r\n };\r\n\r\n /**\r\n * Getter and setter methods for orient coordinates\r\n * @method orientX\r\n * @for p5.Panner3D\r\n * @return {Number} updated coordinate value\r\n */\r\n /**\r\n * Getter and setter methods for orient coordinates\r\n * @method orientY\r\n * @for p5.Panner3D\r\n * @return {Number} updated coordinate value\r\n */\r\n /**\r\n * Getter and setter methods for orient coordinates\r\n * @method orientZ\r\n * @for p5.Panner3D\r\n * @return {Number} updated coordinate value\r\n */\r\n p5.Panner3D.prototype.orientX = function(xVal, time) {\r\n var t = time || 0;\r\n if (typeof xVal === 'number') {\r\n this.panner.orientationX.value = xVal;\r\n this.panner.orientationX.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.panner.orientationX.linearRampToValueAtTime(xVal, this.ac.currentTime + 0.02 + t);\r\n } else if (xVal) {\r\n xVal.connect(this.panner.orientationX);\r\n }\r\n return this.panner.orientationX.value;\r\n };\r\n p5.Panner3D.prototype.orientY = function(yVal, time) {\r\n var t = time || 0;\r\n if (typeof yVal === 'number') {\r\n this.panner.orientationY.value = yVal;\r\n this.panner.orientationY.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.panner.orientationY.linearRampToValueAtTime(yVal, this.ac.currentTime + 0.02 + t);\r\n } else if (yVal) {\r\n yVal.connect(this.panner.orientationY);\r\n }\r\n return this.panner.orientationY.value;\r\n };\r\n p5.Panner3D.prototype.orientZ = function(zVal, time) {\r\n var t = time || 0;\r\n if (typeof zVal === 'number') {\r\n this.panner.orientationZ.value = zVal;\r\n this.panner.orientationZ.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.panner.orientationZ.linearRampToValueAtTime(zVal, this.ac.currentTime + 0.02 + t);\r\n } else if (zVal) {\r\n zVal.connect(this.panner.orientationZ);\r\n }\r\n return this.panner.orientationZ.value;\r\n };\r\n\r\n /**\r\n * Set the rolloff factor and max distance\r\n * @method setFalloff\r\n * @for p5.Panner3D\r\n * @param {Number} [maxDistance]\r\n * @param {Number} [rolloffFactor]\r\n */\r\n p5.Panner3D.prototype.setFalloff = function(maxDistance, rolloffFactor) {\r\n this.maxDist(maxDistance);\r\n this.rolloff(rolloffFactor);\r\n };\r\n /**\r\n * Maxium distance between the source and the listener\r\n * @method maxDist\r\n * @for p5.Panner3D\r\n * @param {Number} maxDistance\r\n * @return {Number} updated value\r\n */\r\n p5.Panner3D.prototype.maxDist = function(maxDistance){\r\n if (typeof maxDistance === 'number') {\r\n this.panner.maxDistance = maxDistance;\r\n }\r\n return this.panner.maxDistance;\r\n };\r\n\r\n /**\r\n * How quickly the volume is reduced as the source moves away from the listener\r\n * @method rollof\r\n * @for p5.Panner3D\r\n * @param {Number} rolloffFactor\r\n * @return {Number} updated value\r\n */\r\n p5.Panner3D.prototype.rolloff = function(rolloffFactor){\r\n if (typeof rolloffFactor === 'number') {\r\n this.panner.rolloffFactor = rolloffFactor;\r\n }\r\n return this.panner.rolloffFactor;\r\n };\r\n\r\n p5.Panner3D.dispose = function() {\r\n Effect.prototype.dispose.apply(this);\r\n if (this.panner) {\r\n this.panner.disconnect();\r\n delete this.panner;\r\n }\r\n };\r\n\r\n return p5.Panner3D;\r\n\r\n});\r\n","'use strict'\r\n\r\ndefine(function (require) {\r\n var p5sound = require('master');\r\n var Effect = require('effect');\r\n\r\n// /**\r\n// * listener is a class that can construct both a Spatial Panner\r\n// * and a Spatial Listener. The panner is based on the \r\n// * Web Audio Spatial Panner Node\r\n// * https://www.w3.org/TR/webaudio/#the-listenernode-interface\r\n// * This panner is a spatial processing node that allows audio to be positioned\r\n// * and oriented in 3D space. \r\n// *\r\n// * The Listener modifies the properties of the Audio Context Listener. \r\n// * Both objects types use the same methods. The default is a spatial panner.\r\n// *\r\n// * p5.Panner3D - Constructs a Spatial Panner
\r\n// * p5.Listener3D - Constructs a Spatial Listener
\r\n// *\r\n// * @class listener\r\n// * @constructor\r\n// * @return {Object} p5.Listener3D Object\r\n// *\r\n// * @param {Web Audio Node} listener Web Audio Spatial Panning Node\r\n// * @param {AudioParam} listener.panningModel \"equal power\" or \"HRTF\"\r\n// * @param {AudioParam} listener.distanceModel \"linear\", \"inverse\", or \"exponential\"\r\n// * @param {String} [type] [Specify construction of a spatial panner or listener]\r\n// */\r\n \r\n\tp5.Listener3D = function(type) {\r\n this.ac = p5sound.audiocontext;\r\n this.listener = this.ac.listener;\r\n\t}; \r\n\r\n// /**\r\n// * Connect an audio sorce\r\n// * @param {Object} src Input source\r\n// */\r\n p5.Listener3D.prototype.process = function(src) {\r\n src.connect(this.input);\r\n }\r\n// /**\r\n// * Set the X,Y,Z position of the Panner\r\n// * @param {[Number]} xVal\r\n// * @param {[Number]} yVal\r\n// * @param {[Number]} zVal\r\n// * @param {[Number]} time\r\n// * @return {[Array]} [Updated x, y, z values as an array]\r\n// */\r\n p5.Listener3D.prototype.position = function(xVal, yVal, zVal, time) {\r\n this.positionX(xVal,time);\r\n this.positionY(yVal,time);\r\n this.positionZ(zVal,time);\r\n return [this.listener.positionX.value, \r\n this.listener.positionY.value,\r\n this.listener.positionZ.value];\r\n };\r\n\r\n// /**\r\n// * Getter and setter methods for position coordinates\r\n// * @return {Number} [updated coordinate value]\r\n// */\r\n p5.Listener3D.prototype.positionX = function(xVal, time) {\r\n var t = time || 0;\r\n if (typeof xVal === 'number') {\r\n this.listener.positionX.value = xVal;\r\n this.listener.positionX.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.listener.positionX.linearRampToValueAtTime(xVal, this.ac.currentTime + 0.02 + t);\r\n } else if (xVal) {\r\n xVal.connect(this.listener.positionX);\r\n }\r\n return this.listener.positionX.value;\r\n };\r\n p5.Listener3D.prototype.positionY = function(yVal, time) {\r\n var t = time || 0;\r\n if (typeof yVal === 'number') {\r\n this.listener.positionY.value = yVal;\r\n this.listener.positionY.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.listener.positionY.linearRampToValueAtTime(yVal, this.ac.currentTime + 0.02 + t);\r\n } else if (yVal) {\r\n yVal.connect(this.listener.positionY);\r\n }\r\n return this.listener.positionY.value;\r\n };\r\n p5.Listener3D.prototype.positionZ = function(zVal, time) {\r\n var t = time || 0;\r\n if (typeof zVal === 'number') {\r\n this.listener.positionZ.value = zVal;\r\n this.listener.positionZ.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.listener.positionZ.linearRampToValueAtTime(zVal, this.ac.currentTime + 0.02 + t);\r\n } else if (zVal) {\r\n zVal.connect(this.listener.positionZ);\r\n }\r\n return this.listener.positionZ.value;\r\n };\r\n\r\n// cannot define method when class definition is commented\r\n// /**\r\n// * Overrides the listener orient() method because Listener has slightly\r\n// * different params. In human terms, Forward vectors are the direction the \r\n// * nose is pointing. Up vectors are the direction of the top of the head.\r\n// *\r\n// * @method orient\r\n// * @param {Number} xValF Forward vector X direction\r\n// * @param {Number} yValF Forward vector Y direction\r\n// * @param {Number} zValF Forward vector Z direction\r\n// * @param {Number} xValU Up vector X direction\r\n// * @param {Number} yValU Up vector Y direction\r\n// * @param {Number} zValU Up vector Z direction\r\n// * @param {Number} time \r\n// * @return {Array} All orienation params\r\n// */\r\n p5.Listener3D.prototype.orient = function(xValF, yValF, zValF, \r\n xValU, yValU, zValU, time) {\r\n\r\n if (arguments.length === 3 || arguments.length === 4) {\r\n time = arguments[3];\r\n this.orientForward(xValF, yValF, zValF, time);\r\n } else if (arguments.length === 6 || arguments === 7) {\r\n this.orientForward(xValF, yValF, zValF);\r\n this.orientUp(xValU, yValU, zValU, time);\r\n }\r\n \r\n return [this.listener.forwardX.value, \r\n this.listener.forwardY.value,\r\n this.listener.forwardZ.value,\r\n this.listener.upX.value,\r\n this.listener.upY.value,\r\n this.listener.upZ.value];\r\n };\r\n\r\n\r\n p5.Listener3D.prototype.orientForward = function(xValF, yValF, zValF, time) {\r\n this.forwardX(xValF,time);\r\n this.forwardY(yValF,time);\r\n this.forwardZ(zValF,time);\r\n\r\n return [this.listener.forwardX, \r\n this.listener.forwardY,\r\n this.listener.forwardZ];\r\n };\r\n\r\n p5.Listener3D.prototype.orientUp = function(xValU, yValU, zValU, time) {\r\n this.upX(xValU,time);\r\n this.upY(yValU,time);\r\n this.upZ(zValU,time);\r\n\r\n return [this.listener.upX, \r\n this.listener.upY,\r\n this.listener.upZ];\r\n };\r\n// /**\r\n// * Getter and setter methods for orient coordinates\r\n// * @return {Number} [updated coordinate value]\r\n// */\r\n p5.Listener3D.prototype.forwardX = function(xVal, time) {\r\n var t = time || 0;\r\n if (typeof xVal === 'number') {\r\n this.listener.forwardX.value = xVal;\r\n this.listener.forwardX.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.listener.forwardX.linearRampToValueAtTime(xVal, this.ac.currentTime + 0.02 + t);\r\n } else if (xVal) {\r\n xVal.connect(this.listener.forwardX);\r\n }\r\n return this.listener.forwardX.value;\r\n };\r\n p5.Listener3D.prototype.forwardY = function(yVal, time) {\r\n var t = time || 0;\r\n if (typeof yVal === 'number') {\r\n this.listener.forwardY.value = yVal;\r\n this.listener.forwardY.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.listener.forwardY.linearRampToValueAtTime(yVal, this.ac.currentTime + 0.02 + t);\r\n } else if (yVal) {\r\n yVal.connect(this.listener.forwardY);\r\n }\r\n return this.listener.forwardY.value;\r\n };\r\n p5.Listener3D.prototype.forwardZ = function(zVal, time) {\r\n var t = time || 0;\r\n if (typeof zVal === 'number') {\r\n this.listener.forwardZ.value = zVal;\r\n this.listener.forwardZ.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.listener.forwardZ.linearRampToValueAtTime(zVal, this.ac.currentTime + 0.02 + t);\r\n } else if (zVal) {\r\n zVal.connect(this.listener.forwardZ);\r\n }\r\n return this.listener.forwardZ.value;\r\n };\r\n p5.Listener3D.prototype.upX = function(xVal, time) {\r\n var t = time || 0;\r\n if (typeof xVal === 'number') {\r\n this.listener.upX.value = xVal;\r\n this.listener.upX.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.listener.upX.linearRampToValueAtTime(xVal, this.ac.currentTime + 0.02 + t);\r\n } else if (xVal) {\r\n xVal.connect(this.listener.upX);\r\n }\r\n return this.listener.upX.value;\r\n };\r\n p5.Listener3D.prototype.upY = function(yVal, time) {\r\n var t = time || 0;\r\n if (typeof yVal === 'number') {\r\n this.listener.upY.value = yVal;\r\n this.listener.upY.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.listener.upY.linearRampToValueAtTime(yVal, this.ac.currentTime + 0.02 + t);\r\n } else if (yVal) {\r\n yVal.connect(this.listener.upY);\r\n }\r\n return this.listener.upY.value;\r\n };\r\n p5.Listener3D.prototype.upZ = function(zVal, time) {\r\n var t = time || 0;\r\n if (typeof zVal === 'number') {\r\n this.listener.upZ.value = zVal;\r\n this.listener.upZ.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.listener.upZ.linearRampToValueAtTime(zVal, this.ac.currentTime + 0.02 + t);\r\n } else if (zVal) {\r\n zVal.connect(this.listener.upZ);\r\n }\r\n return this.listener.upZ.value;\r\n };\r\n \r\n return p5.Listener3D;\r\n\r\n});","'use strict';\r\n\r\ndefine(function (require) {\r\n var Filter = require('filter');\r\n var Effect = require('effect');\r\n\r\n /**\r\n * Delay is an echo effect. It processes an existing sound source,\r\n * and outputs a delayed version of that sound. The p5.Delay can\r\n * produce different effects depending on the delayTime, feedback,\r\n * filter, and type. In the example below, a feedback of 0.5 (the\r\n * default value) will produce a looping delay that decreases in\r\n * volume by 50% each repeat. A filter will cut out the high\r\n * frequencies so that the delay does not sound as piercing as the\r\n * original source.\r\n *\r\n *\r\n * This class extends p5.Effect.\r\n * Methods amp(), chain(),\r\n * drywet(), connect(), and\r\n * disconnect() are available.\r\n * @class p5.Delay\r\n * @extends p5.Effect\r\n * @constructor\r\n * @example\r\n *
\r\n * let osc;\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * background(220);\r\n * textAlign(CENTER);\r\n * text('tap to play', width/2, height/2);\r\n *\r\n * osc = new p5.Oscillator('square');\r\n * osc.amp(0.5);\r\n * delay = new p5.Delay();\r\n *\r\n * // delay.process() accepts 4 parameters:\r\n * // source, delayTime (in seconds), feedback, filter frequency\r\n * delay.process(osc, 0.12, .7, 2300);\r\n *\r\n * cnv.mousePressed(oscStart);\r\n * }\r\n *\r\n * function oscStart() {\r\n * osc.start();\r\n * }\r\n *\r\n * function mouseReleased() {\r\n * osc.stop();\r\n * }\r\n *
\r\n */\r\n p5.Delay = function() {\r\n \tEffect.call(this);\r\n\r\n this._split = this.ac.createChannelSplitter(2);\r\n this._merge = this.ac.createChannelMerger(2);\r\n\r\n this._leftGain = this.ac.createGain();\r\n this._rightGain = this.ac.createGain();\r\n\r\n /**\r\n * The p5.Delay is built with two\r\n * \r\n * Web Audio Delay Nodes, one for each stereo channel.\r\n *\r\n * @for p5.Delay\r\n * @property {DelayNode} leftDelay\r\n */\r\n this.leftDelay = this.ac.createDelay();\r\n /**\r\n * The p5.Delay is built with two\r\n * \r\n * Web Audio Delay Nodes, one for each stereo channel.\r\n * @for p5.Delay\r\n * @property {DelayNode} rightDelay\r\n */\r\n this.rightDelay = this.ac.createDelay();\r\n\r\n this._leftFilter = new Filter();\r\n this._rightFilter = new Filter();\r\n this._leftFilter.disconnect();\r\n this._rightFilter.disconnect();\r\n\r\n this._leftFilter.biquad.frequency.setValueAtTime(1200, this.ac.currentTime);\r\n this._rightFilter.biquad.frequency.setValueAtTime(1200, this.ac.currentTime);\r\n this._leftFilter.biquad.Q.setValueAtTime(0.3, this.ac.currentTime);\r\n this._rightFilter.biquad.Q.setValueAtTime(0.3, this.ac.currentTime);\r\n\r\n // graph routing\r\n this.input.connect(this._split);\r\n this.leftDelay.connect(this._leftGain);\r\n this.rightDelay.connect(this._rightGain);\r\n this._leftGain.connect(this._leftFilter.input);\r\n this._rightGain.connect(this._rightFilter.input);\r\n this._merge.connect(this.wet);\r\n\r\n\r\n this._leftFilter.biquad.gain.setValueAtTime(1, this.ac.currentTime);\r\n this._rightFilter.biquad.gain.setValueAtTime(1, this.ac.currentTime);\r\n\r\n // default routing\r\n this.setType(0);\r\n\r\n this._maxDelay = this.leftDelay.delayTime.maxValue;\r\n\r\n // set initial feedback to 0.5\r\n this.feedback(0.5);\r\n\r\n\r\n };\r\n\r\n p5.Delay.prototype = Object.create(Effect.prototype);\r\n /**\r\n * Add delay to an audio signal according to a set\r\n * of delay parameters.\r\n *\r\n * @method process\r\n * @for p5.Delay\r\n * @param {Object} Signal An object that outputs audio\r\n * @param {Number} [delayTime] Time (in seconds) of the delay/echo.\r\n * Some browsers limit delayTime to\r\n * 1 second.\r\n * @param {Number} [feedback] sends the delay back through itself\r\n * in a loop that decreases in volume\r\n * each time.\r\n * @param {Number} [lowPass] Cutoff frequency. Only frequencies\r\n * below the lowPass will be part of the\r\n * delay.\r\n */\r\n p5.Delay.prototype.process = function(src, _delayTime, _feedback, _filter) {\r\n var feedback = _feedback || 0;\r\n var delayTime = _delayTime || 0;\r\n if (feedback >= 1.0) {\r\n throw new Error('Feedback value will force a positive feedback loop.');\r\n }\r\n if (delayTime >= this._maxDelay) {\r\n throw new Error('Delay Time exceeds maximum delay time of ' + this._maxDelay + ' second.');\r\n }\r\n\r\n src.connect(this.input);\r\n this.leftDelay.delayTime.setValueAtTime(delayTime, this.ac.currentTime);\r\n this.rightDelay.delayTime.setValueAtTime(delayTime, this.ac.currentTime);\r\n this._leftGain.gain.value = feedback;\r\n this._rightGain.gain.value = feedback;\r\n\r\n if (_filter) {\r\n this._leftFilter.freq(_filter);\r\n this._rightFilter.freq(_filter);\r\n }\r\n };\r\n\r\n /**\r\n * Set the delay (echo) time, in seconds. Usually this value will be\r\n * a floating point number between 0.0 and 1.0.\r\n *\r\n * @method delayTime\r\n * @for p5.Delay\r\n * @param {Number} delayTime Time (in seconds) of the delay\r\n */\r\n p5.Delay.prototype.delayTime = function(t) {\r\n // if t is an audio node...\r\n if (typeof t !== 'number') {\r\n t.connect(this.leftDelay.delayTime);\r\n t.connect(this.rightDelay.delayTime);\r\n }\r\n\r\n else {\r\n this.leftDelay.delayTime.cancelScheduledValues(this.ac.currentTime);\r\n this.rightDelay.delayTime.cancelScheduledValues(this.ac.currentTime);\r\n this.leftDelay.delayTime.linearRampToValueAtTime(t, this.ac.currentTime);\r\n this.rightDelay.delayTime.linearRampToValueAtTime(t, this.ac.currentTime);\r\n }\r\n };\r\n\r\n /**\r\n * Feedback occurs when Delay sends its signal back through its input\r\n * in a loop. The feedback amount determines how much signal to send each\r\n * time through the loop. A feedback greater than 1.0 is not desirable because\r\n * it will increase the overall output each time through the loop,\r\n * creating an infinite feedback loop. The default value is 0.5\r\n *\r\n * @method feedback\r\n * @for p5.Delay\r\n * @param {Number|Object} feedback 0.0 to 1.0, or an object such as an\r\n * Oscillator that can be used to\r\n * modulate this param\r\n * @returns {Number} Feedback value\r\n *\r\n */\r\n p5.Delay.prototype.feedback = function(f) {\r\n // if f is an audio node...\r\n if (f && typeof f !== 'number') {\r\n f.connect(this._leftGain.gain);\r\n f.connect(this._rightGain.gain);\r\n }\r\n else if (f >= 1.0) {\r\n throw new Error('Feedback value will force a positive feedback loop.');\r\n }\r\n else if (typeof f === 'number') {\r\n this._leftGain.gain.value = f;\r\n this._rightGain.gain.value = f;\r\n }\r\n\r\n // return value of feedback\r\n return this._leftGain.gain.value;\r\n };\r\n\r\n /**\r\n * Set a lowpass filter frequency for the delay. A lowpass filter\r\n * will cut off any frequencies higher than the filter frequency.\r\n *\r\n * @method filter\r\n * @for p5.Delay\r\n * @param {Number|Object} cutoffFreq A lowpass filter will cut off any\r\n * frequencies higher than the filter frequency.\r\n * @param {Number|Object} res Resonance of the filter frequency\r\n * cutoff, or an object (i.e. a p5.Oscillator)\r\n * that can be used to modulate this parameter.\r\n * High numbers (i.e. 15) will produce a resonance,\r\n * low numbers (i.e. .2) will produce a slope.\r\n */\r\n p5.Delay.prototype.filter = function(freq, q) {\r\n this._leftFilter.set(freq, q);\r\n this._rightFilter.set(freq, q);\r\n };\r\n\r\n\r\n /**\r\n * Choose a preset type of delay. 'pingPong' bounces the signal\r\n * from the left to the right channel to produce a stereo effect.\r\n * Any other parameter will revert to the default delay setting.\r\n *\r\n * @method setType\r\n * @for p5.Delay\r\n * @param {String|Number} type 'pingPong' (1) or 'default' (0)\r\n */\r\n p5.Delay.prototype.setType = function(t) {\r\n if (t === 1) {\r\n t = 'pingPong';\r\n }\r\n this._split.disconnect();\r\n this._leftFilter.disconnect();\r\n this._rightFilter.disconnect();\r\n this._split.connect(this.leftDelay, 0);\r\n this._split.connect(this.rightDelay, 1);\r\n switch(t) {\r\n case 'pingPong':\r\n this._rightFilter.setType( this._leftFilter.biquad.type );\r\n this._leftFilter.output.connect(this._merge, 0, 0);\r\n this._rightFilter.output.connect(this._merge, 0, 1);\r\n this._leftFilter.output.connect(this.rightDelay);\r\n this._rightFilter.output.connect(this.leftDelay);\r\n break;\r\n default:\r\n this._leftFilter.output.connect(this._merge, 0, 0);\r\n this._rightFilter.output.connect(this._merge, 0, 1);\r\n this._leftFilter.output.connect(this.leftDelay);\r\n this._rightFilter.output.connect(this.rightDelay);\r\n }\r\n };\r\n\r\n // DocBlocks for methods inherited from p5.Effect\r\n /**\r\n * Set the output level of the delay effect.\r\n *\r\n * @method amp\r\n * @for p5.Delay\r\n * @param {Number} volume amplitude between 0 and 1.0\r\n * @param {Number} [rampTime] create a fade that lasts rampTime\r\n * @param {Number} [timeFromNow] schedule this event to happen\r\n * seconds from now\r\n */\r\n /**\r\n * Send output to a p5.sound or web audio object\r\n *\r\n * @method connect\r\n * @for p5.Delay\r\n * @param {Object} unit\r\n */\r\n /**\r\n * Disconnect all output.\r\n *\r\n * @method disconnect\r\n * @for p5.Delay\r\n */\r\n\r\n p5.Delay.prototype.dispose = function() {\r\n\r\n Effect.prototype.dispose.apply(this);\r\n\r\n this._split.disconnect();\r\n this._leftFilter.dispose();\r\n this._rightFilter.dispose();\r\n this._merge.disconnect();\r\n this._leftGain.disconnect();\r\n this._rightGain.disconnect();\r\n this.leftDelay.disconnect();\r\n this.rightDelay.disconnect();\r\n\r\n this._split = undefined;\r\n this._leftFilter = undefined;\r\n this._rightFilter = undefined;\r\n this._merge = undefined;\r\n this._leftGain = undefined;\r\n this._rightGain = undefined;\r\n this.leftDelay = undefined;\r\n this.rightDelay = undefined;\r\n };\r\n\r\n});\r\n","'use strict';\r\n\r\ndefine(function (require) {\r\n var CustomError = require('errorHandler');\r\n var Effect = require('effect');\r\n\r\n /**\r\n * Reverb adds depth to a sound through a large number of decaying\r\n * echoes. It creates the perception that sound is occurring in a\r\n * physical space. The p5.Reverb has paramters for Time (how long does the\r\n * reverb last) and decayRate (how much the sound decays with each echo)\r\n * that can be set with the .set() or .process() methods. The p5.Convolver\r\n * extends p5.Reverb allowing you to recreate the sound of actual physical\r\n * spaces through convolution.\r\n *\r\n * This class extends p5.Effect.\r\n * Methods amp(), chain(),\r\n * drywet(), connect(), and\r\n * disconnect() are available.\r\n *\r\n * @class p5.Reverb\r\n * @extends p5.Effect\r\n * @constructor\r\n * @example\r\n *
\r\n * let soundFile, reverb;\r\n * function preload() {\r\n * soundFile = loadSound('assets/Damscray_DancingTiger.mp3');\r\n * }\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * cnv.mousePressed(playSound);\r\n *\r\n * reverb = new p5.Reverb();\r\n * soundFile.disconnect(); // so we'll only hear reverb...\r\n *\r\n * // connect soundFile to reverb, process w/\r\n * // 3 second reverbTime, decayRate of 2%\r\n * reverb.process(soundFile, 3, 2);\r\n * }\r\n *\r\n * function draw() {\r\n * let dryWet = constrain(map(mouseX, 0, width, 0, 1), 0, 1);\r\n * // 1 = all reverb, 0 = no reverb\r\n * reverb.drywet(dryWet);\r\n *\r\n * background(220);\r\n * text('tap to play', 10, 20);\r\n * text('dry/wet: ' + round(dryWet * 100) + '%', 10, height - 20);\r\n * }\r\n *\r\n * function playSound() {\r\n * soundFile.play();\r\n * }\r\n *
\r\n */\r\n\r\n\r\n p5.Reverb = function() {\r\n Effect.call(this);\r\n\r\n this._initConvolverNode();\r\n\r\n // otherwise, Safari distorts\r\n this.input.gain.value = 0.5;\r\n\r\n // default params\r\n this._seconds = 3;\r\n this._decay = 2;\r\n this._reverse = false;\r\n\r\n this._buildImpulse();\r\n\r\n };\r\n\r\n p5.Reverb.prototype = Object.create(Effect.prototype);\r\n\r\n p5.Reverb.prototype._initConvolverNode = function() {\r\n this.convolverNode = this.ac.createConvolver();\r\n this.input.connect(this.convolverNode);\r\n this.convolverNode.connect(this.wet);\r\n };\r\n\r\n p5.Reverb.prototype._teardownConvolverNode = function() {\r\n if (this.convolverNode) {\r\n this.convolverNode.disconnect();\r\n delete this.convolverNode;\r\n }\r\n };\r\n\r\n p5.Reverb.prototype._setBuffer = function(audioBuffer) {\r\n this._teardownConvolverNode();\r\n this._initConvolverNode();\r\n this.convolverNode.buffer = audioBuffer;\r\n };\r\n /**\r\n * Connect a source to the reverb, and assign reverb parameters.\r\n *\r\n * @method process\r\n * @for p5.Reverb\r\n * @param {Object} src p5.sound / Web Audio object with a sound\r\n * output.\r\n * @param {Number} [seconds] Duration of the reverb, in seconds.\r\n * Min: 0, Max: 10. Defaults to 3.\r\n * @param {Number} [decayRate] Percentage of decay with each echo.\r\n * Min: 0, Max: 100. Defaults to 2.\r\n * @param {Boolean} [reverse] Play the reverb backwards or forwards.\r\n */\r\n p5.Reverb.prototype.process = function(src, seconds, decayRate, reverse) {\r\n src.connect(this.input);\r\n var rebuild = false;\r\n if (seconds) {\r\n this._seconds = seconds;\r\n rebuild = true;\r\n }\r\n if (decayRate) {\r\n this._decay = decayRate;\r\n }\r\n if (reverse) {\r\n this._reverse = reverse;\r\n }\r\n if (rebuild) {\r\n this._buildImpulse();\r\n }\r\n };\r\n\r\n /**\r\n * Set the reverb settings. Similar to .process(), but without\r\n * assigning a new input.\r\n *\r\n * @method set\r\n * @for p5.Reverb\r\n * @param {Number} [seconds] Duration of the reverb, in seconds.\r\n * Min: 0, Max: 10. Defaults to 3.\r\n * @param {Number} [decayRate] Percentage of decay with each echo.\r\n * Min: 0, Max: 100. Defaults to 2.\r\n * @param {Boolean} [reverse] Play the reverb backwards or forwards.\r\n */\r\n p5.Reverb.prototype.set = function(seconds, decayRate, reverse) {\r\n var rebuild = false;\r\n if (seconds) {\r\n this._seconds = seconds;\r\n rebuild = true;\r\n }\r\n if (decayRate) {\r\n this._decay = decayRate;\r\n }\r\n if (reverse) {\r\n this._reverse = reverse;\r\n }\r\n if (rebuild) {\r\n this._buildImpulse();\r\n }\r\n };\r\n\r\n // DocBlocks for methods inherited from p5.Effect\r\n /**\r\n * Set the output level of the reverb effect.\r\n *\r\n * @method amp\r\n * @for p5.Reverb\r\n * @param {Number} volume amplitude between 0 and 1.0\r\n * @param {Number} [rampTime] create a fade that lasts rampTime\r\n * @param {Number} [timeFromNow] schedule this event to happen\r\n * seconds from now\r\n */\r\n /**\r\n * Send output to a p5.sound or web audio object\r\n *\r\n * @method connect\r\n * @for p5.Reverb\r\n * @param {Object} unit\r\n */\r\n /**\r\n * Disconnect all output.\r\n *\r\n * @method disconnect\r\n * @for p5.Reverb\r\n */\r\n\r\n /**\r\n * Inspired by Simple Reverb by Jordan Santell\r\n * https://github.com/web-audio-components/simple-reverb/blob/master/index.js\r\n *\r\n * Utility function for building an impulse response\r\n * based on the module parameters.\r\n *\r\n * @private\r\n */\r\n p5.Reverb.prototype._buildImpulse = function() {\r\n var rate = this.ac.sampleRate;\r\n var length = rate*this._seconds;\r\n var decay = this._decay;\r\n var impulse = this.ac.createBuffer(2, length, rate);\r\n var impulseL = impulse.getChannelData(0);\r\n var impulseR = impulse.getChannelData(1);\r\n var n, i;\r\n for (i = 0; i < length; i++) {\r\n n = this._reverse ? length - i : i;\r\n impulseL[i] = (Math.random() * 2 - 1) * Math.pow(1 - n / length, decay);\r\n impulseR[i] = (Math.random() * 2 - 1) * Math.pow(1 - n / length, decay);\r\n }\r\n this._setBuffer(impulse);\r\n };\r\n\r\n p5.Reverb.prototype.dispose = function() {\r\n Effect.prototype.dispose.apply(this);\r\n this._teardownConvolverNode();\r\n };\r\n\r\n // =======================================================================\r\n // *** p5.Convolver ***\r\n // =======================================================================\r\n\r\n /**\r\n *

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

\r\n *\r\n *

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

\r\n *\r\n *

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

\r\n *\r\n * @class p5.Convolver\r\n * @extends p5.Effect\r\n * @constructor\r\n * @param {String} path path to a sound file\r\n * @param {Function} [callback] function to call when loading succeeds\r\n * @param {Function} [errorCallback] function to call if loading fails.\r\n * This function will receive an error or\r\n * XMLHttpRequest object with information\r\n * about what went wrong.\r\n * @example\r\n *
\r\n * let cVerb, sound;\r\n * function preload() {\r\n * // We have both MP3 and OGG versions of all sound assets\r\n * soundFormats('ogg', 'mp3');\r\n *\r\n * // Try replacing 'bx-spring' with other soundfiles like\r\n * // 'concrete-tunnel' 'small-plate' 'drum' 'beatbox'\r\n * cVerb = createConvolver('assets/bx-spring.mp3');\r\n *\r\n * // Try replacing 'Damscray_DancingTiger' with\r\n * // 'beat', 'doorbell', lucky_dragons_-_power_melody'\r\n * sound = loadSound('assets/Damscray_DancingTiger.mp3');\r\n * }\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * cnv.mousePressed(playSound);\r\n * background(220);\r\n * text('tap to play', 20, 20);\r\n *\r\n * // disconnect from master output...\r\n * sound.disconnect();\r\n *\r\n * // ...and process with cVerb\r\n * // so that we only hear the convolution\r\n * cVerb.process(sound);\r\n * }\r\n *\r\n * function playSound() {\r\n * sound.play();\r\n * }\r\n *
\r\n */\r\n p5.Convolver = function(path, callback, errorCallback) {\r\n \t p5.Reverb.call(this);\r\n\r\n /**\r\n * Internally, the p5.Convolver uses the a\r\n * \r\n * Web Audio Convolver Node.\r\n *\r\n * @property {ConvolverNode} convolverNode\r\n */\r\n this._initConvolverNode();\r\n\r\n // otherwise, Safari distorts\r\n this.input.gain.value = 0.5;\r\n\r\n if (path) {\r\n this.impulses = [];\r\n this._loadBuffer(path, callback, errorCallback);\r\n }\r\n else {\r\n // parameters\r\n this._seconds = 3;\r\n this._decay = 2;\r\n this._reverse = false;\r\n\r\n this._buildImpulse();\r\n }\r\n\r\n };\r\n\r\n p5.Convolver.prototype = Object.create(p5.Reverb.prototype);\r\n\r\n p5.prototype.registerPreloadMethod('createConvolver', p5.prototype);\r\n\r\n /**\r\n * Create a p5.Convolver. Accepts a path to a soundfile\r\n * that will be used to generate an impulse response.\r\n *\r\n * @method createConvolver\r\n * @for p5\r\n * @param {String} path path to a sound file\r\n * @param {Function} [callback] function to call if loading is successful.\r\n * The object will be passed in as the argument\r\n * to the callback function.\r\n * @param {Function} [errorCallback] function to call if loading is not successful.\r\n * A custom error will be passed in as the argument\r\n * to the callback function.\r\n * @return {p5.Convolver}\r\n * @example\r\n *
\r\n * let cVerb, sound;\r\n * function preload() {\r\n * // We have both MP3 and OGG versions of all sound assets\r\n * soundFormats('ogg', 'mp3');\r\n *\r\n * // Try replacing 'bx-spring' with other soundfiles like\r\n * // 'concrete-tunnel' 'small-plate' 'drum' 'beatbox'\r\n * cVerb = createConvolver('assets/bx-spring.mp3');\r\n *\r\n * // Try replacing 'Damscray_DancingTiger' with\r\n * // 'beat', 'doorbell', lucky_dragons_-_power_melody'\r\n * sound = loadSound('assets/Damscray_DancingTiger.mp3');\r\n * }\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * cnv.mousePressed(playSound);\r\n * background(220);\r\n * text('tap to play', 20, 20);\r\n *\r\n * // disconnect from master output...\r\n * sound.disconnect();\r\n *\r\n * // ...and process with cVerb\r\n * // so that we only hear the convolution\r\n * cVerb.process(sound);\r\n * }\r\n *\r\n * function playSound() {\r\n * sound.play();\r\n * }\r\n *
\r\n */\r\n p5.prototype.createConvolver = function(path, callback, errorCallback) {\r\n // if loading locally without a server\r\n if (window.location.origin.indexOf('file://') > -1 && window.cordova === 'undefined') {\r\n alert('This sketch may require a server to load external files. Please see http://bit.ly/1qcInwS');\r\n }\r\n var self = this;\r\n var cReverb = new p5.Convolver(path, function(buffer) {\r\n if (typeof callback === 'function') {\r\n callback(buffer);\r\n }\r\n\r\n if (typeof self._decrementPreload === 'function') {\r\n self._decrementPreload();\r\n }\r\n }, errorCallback);\r\n cReverb.impulses = [];\r\n return cReverb;\r\n };\r\n\r\n /**\r\n * Private method to load a buffer as an Impulse Response,\r\n * assign it to the convolverNode, and add to the Array of .impulses.\r\n *\r\n * @param {String} path\r\n * @param {Function} callback\r\n * @param {Function} errorCallback\r\n * @private\r\n */\r\n p5.Convolver.prototype._loadBuffer = function(path, callback, errorCallback) {\r\n var path = p5.prototype._checkFileFormats(path);\r\n var self = this;\r\n var errorTrace = new Error().stack;\r\n var ac = p5.prototype.getAudioContext();\r\n\r\n var request = new XMLHttpRequest();\r\n request.open('GET', path, true);\r\n request.responseType = 'arraybuffer';\r\n\r\n request.onload = function() {\r\n if (request.status === 200) {\r\n // on success loading file:\r\n ac.decodeAudioData(request.response,\r\n function(buff) {\r\n var buffer = {};\r\n var chunks = path.split('/');\r\n buffer.name = chunks[chunks.length - 1];\r\n buffer.audioBuffer = buff;\r\n self.impulses.push(buffer);\r\n self._setBuffer(buffer.audioBuffer);\r\n if (callback) {\r\n callback(buffer);\r\n }\r\n },\r\n // error decoding buffer. \"e\" is undefined in Chrome 11/22/2015\r\n function() {\r\n var err = new CustomError('decodeAudioData', errorTrace, self.url);\r\n var msg = 'AudioContext error at decodeAudioData for ' + self.url;\r\n if (errorCallback) {\r\n err.msg = msg;\r\n errorCallback(err);\r\n } else {\r\n console.error(msg +'\\n The error stack trace includes: \\n' + err.stack);\r\n }\r\n }\r\n );\r\n }\r\n // if request status != 200, it failed\r\n else {\r\n var err = new CustomError('loadConvolver', errorTrace, self.url);\r\n var msg = 'Unable to load ' + self.url +\r\n '. The request status was: ' + request.status + ' (' + request.statusText + ')';\r\n\r\n if (errorCallback) {\r\n err.message = msg;\r\n errorCallback(err);\r\n } else {\r\n console.error(msg +'\\n The error stack trace includes: \\n' + err.stack);\r\n }\r\n }\r\n };\r\n\r\n // if there is another error, aside from 404...\r\n request.onerror = function() {\r\n var err = new CustomError('loadConvolver', errorTrace, self.url);\r\n var msg = 'There was no response from the server at ' + self.url + '. Check the url and internet connectivity.';\r\n\r\n if (errorCallback) {\r\n err.message = msg;\r\n errorCallback(err);\r\n } else {\r\n console.error(msg +'\\n The error stack trace includes: \\n' + err.stack);\r\n }\r\n };\r\n request.send();\r\n };\r\n\r\n p5.Convolver.prototype.set = null;\r\n\r\n /**\r\n * Connect a source to the convolver.\r\n *\r\n * @method process\r\n * @for p5.Convolver\r\n * @param {Object} src p5.sound / Web Audio object with a sound\r\n * output.\r\n * @example\r\n *
\r\n * let cVerb, sound;\r\n * function preload() {\r\n * // We have both MP3 and OGG versions of all sound assets\r\n * soundFormats('ogg', 'mp3');\r\n *\r\n * // Try replacing 'bx-spring' with other soundfiles like\r\n * // 'concrete-tunnel' 'small-plate' 'drum' 'beatbox'\r\n * cVerb = createConvolver('assets/bx-spring.mp3');\r\n *\r\n * // Try replacing 'Damscray_DancingTiger' with\r\n * // 'beat', 'doorbell', lucky_dragons_-_power_melody'\r\n * sound = loadSound('assets/Damscray_DancingTiger.mp3');\r\n * }\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * cnv.mousePressed(playSound);\r\n * background(220);\r\n * text('tap to play', 20, 20);\r\n *\r\n * // disconnect from master output...\r\n * sound.disconnect();\r\n *\r\n * // ...and process with cVerb\r\n * // so that we only hear the convolution\r\n * cVerb.process(sound);\r\n * }\r\n *\r\n * function playSound() {\r\n * sound.play();\r\n * }\r\n *\r\n *
\r\n */\r\n p5.Convolver.prototype.process = function(src) {\r\n src.connect(this.input);\r\n };\r\n\r\n /**\r\n * If you load multiple impulse files using the .addImpulse method,\r\n * they will be stored as Objects in this Array. Toggle between them\r\n * with the toggleImpulse(id) method.\r\n *\r\n * @property {Array} impulses\r\n * @for p5.Convolver\r\n */\r\n p5.Convolver.prototype.impulses = [];\r\n\r\n /**\r\n * Load and assign a new Impulse Response to the p5.Convolver.\r\n * The impulse is added to the .impulses array. Previous\r\n * impulses can be accessed with the .toggleImpulse(id)\r\n * method.\r\n *\r\n * @method addImpulse\r\n * @for p5.Convolver\r\n * @param {String} path path to a sound file\r\n * @param {Function} callback function (optional)\r\n * @param {Function} errorCallback function (optional)\r\n */\r\n p5.Convolver.prototype.addImpulse = function(path, callback, errorCallback) {\r\n // if loading locally without a server\r\n if (window.location.origin.indexOf('file://') > -1 && window.cordova === 'undefined') {\r\n alert('This sketch may require a server to load external files. Please see http://bit.ly/1qcInwS');\r\n }\r\n this._loadBuffer(path, callback, errorCallback);\r\n };\r\n\r\n /**\r\n * Similar to .addImpulse, except that the .impulses\r\n * Array is reset to save memory. A new .impulses\r\n * array is created with this impulse as the only item.\r\n *\r\n * @method resetImpulse\r\n * @for p5.Convolver\r\n * @param {String} path path to a sound file\r\n * @param {Function} callback function (optional)\r\n * @param {Function} errorCallback function (optional)\r\n */\r\n p5.Convolver.prototype.resetImpulse = function(path, callback, errorCallback) {\r\n // if loading locally without a server\r\n if (window.location.origin.indexOf('file://') > -1 && window.cordova === 'undefined') {\r\n alert('This sketch may require a server to load external files. Please see http://bit.ly/1qcInwS');\r\n }\r\n this.impulses = [];\r\n this._loadBuffer(path, callback, errorCallback);\r\n };\r\n\r\n /**\r\n * If you have used .addImpulse() to add multiple impulses\r\n * to a p5.Convolver, then you can use this method to toggle between\r\n * the items in the .impulses Array. Accepts a parameter\r\n * to identify which impulse you wish to use, identified either by its\r\n * original filename (String) or by its position in the .impulses\r\n * Array (Number).
\r\n * You can access the objects in the .impulses Array directly. Each\r\n * Object has two attributes: an .audioBuffer (type:\r\n * Web Audio \r\n * AudioBuffer) and a .name, a String that corresponds\r\n * with the original filename.\r\n *\r\n * @method toggleImpulse\r\n * @for p5.Convolver\r\n * @param {String|Number} id Identify the impulse by its original filename\r\n * (String), or by its position in the\r\n * .impulses Array (Number).\r\n */\r\n p5.Convolver.prototype.toggleImpulse = function(id) {\r\n if (typeof id === 'number' && id < this.impulses.length) {\r\n this._setBuffer(this.impulses[id].audioBuffer);\r\n }\r\n if (typeof id === 'string') {\r\n for (var i = 0; i < this.impulses.length; i++) {\r\n if (this.impulses[i].name === id) {\r\n this._setBuffer(this.impulses[i].audioBuffer);\r\n break;\r\n }\r\n }\r\n }\r\n };\r\n\r\n p5.Convolver.prototype.dispose = function() {\r\n p5.Reverb.prototype.dispose.apply(this);\r\n\r\n // remove all the Impulse Response buffers\r\n for (var i in this.impulses) {\r\n if (this.impulses[i]) {\r\n this.impulses[i] = null;\r\n }\r\n }\r\n };\r\n\r\n});\r\n","'use strict';\r\n\r\ndefine(function (require) {\r\n var p5sound = require('master');\r\n\r\n // requires the Tone.js library's Clock (MIT license, Yotam Mann)\r\n // https://github.com/TONEnoTONE/Tone.js/\r\n var Clock = require('Tone/core/Clock');\r\n\r\n p5.Metro = function() {\r\n this.clock = new Clock({\r\n 'callback': this.ontick.bind(this)\r\n });\r\n this.syncedParts = [];\r\n this.bpm = 120; // gets overridden by p5.Part\r\n this._init();\r\n\r\n this.prevTick = 0;\r\n this.tatumTime = 0;\r\n\r\n this.tickCallback = function() {};\r\n };\r\n\r\n p5.Metro.prototype.ontick = function(tickTime) {\r\n var elapsedTime = tickTime - this.prevTick;\r\n var secondsFromNow = tickTime - p5sound.audiocontext.currentTime;\r\n if (elapsedTime - this.tatumTime <= -0.02) {\r\n return;\r\n } else {\r\n // console.log('ok', this.syncedParts[0].phrases[0].name);\r\n this.prevTick = tickTime;\r\n\r\n // for all of the active things on the metro:\r\n var self = this;\r\n this.syncedParts.forEach(function(thisPart) {\r\n if (!thisPart.isPlaying) return;\r\n thisPart.incrementStep(secondsFromNow);\r\n // each synced source keeps track of its own beat number\r\n thisPart.phrases.forEach(function(thisPhrase) {\r\n var phraseArray = thisPhrase.sequence;\r\n var bNum = self.metroTicks % phraseArray.length;\r\n if (phraseArray[bNum] !== 0 && (self.metroTicks < phraseArray.length || !thisPhrase.looping) ) {\r\n thisPhrase.callback(secondsFromNow, phraseArray[bNum]);\r\n }\r\n });\r\n });\r\n this.metroTicks += 1;\r\n this.tickCallback(secondsFromNow);\r\n }\r\n };\r\n\r\n p5.Metro.prototype.setBPM = function(bpm, rampTime) {\r\n var beatTime = 60 / (bpm*this.tatums);\r\n var now = p5sound.audiocontext.currentTime;\r\n this.tatumTime = beatTime;\r\n\r\n var rampTime = rampTime || 0;\r\n this.clock.frequency.setValueAtTime(this.clock.frequency.value, now);\r\n this.clock.frequency.linearRampToValueAtTime(bpm, now + rampTime);\r\n this.bpm = bpm;\r\n };\r\n\r\n p5.Metro.prototype.getBPM = function() {\r\n return this.clock.getRate() / this.tatums * 60;\r\n };\r\n\r\n p5.Metro.prototype._init = function() {\r\n this.metroTicks = 0;\r\n // this.setBPM(120);\r\n };\r\n\r\n // clear existing synced parts, add only this one\r\n p5.Metro.prototype.resetSync = function(part) {\r\n this.syncedParts = [part];\r\n };\r\n\r\n // push a new synced part to the array\r\n p5.Metro.prototype.pushSync = function(part) {\r\n this.syncedParts.push(part);\r\n };\r\n\r\n p5.Metro.prototype.start = function(timeFromNow) {\r\n var t = timeFromNow || 0;\r\n var now = p5sound.audiocontext.currentTime;\r\n this.clock.start(now + t);\r\n this.setBPM(this.bpm);\r\n };\r\n\r\n p5.Metro.prototype.stop = function(timeFromNow) {\r\n var t = timeFromNow || 0;\r\n var now = p5sound.audiocontext.currentTime;\r\n this.clock.stop(now + t);\r\n };\r\n\r\n p5.Metro.prototype.beatLength = function(tatums) {\r\n this.tatums = 1/tatums / 4; // lowest possible division of a beat\r\n };\r\n\r\n});\r\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]) {\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 }\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';\r\n\r\ndefine(function (require) {\r\n var p5sound = require('master');\r\n var Clock = require('Tone/core/Clock');\r\n\r\n /**\r\n * SoundLoop\r\n *\r\n * @class p5.SoundLoop\r\n * @constructor\r\n *\r\n * @param {Function} callback this function will be called on each iteration of theloop\r\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.\r\n *\r\n * @example\r\n *
\r\n * let synth, soundLoop;\r\n * let notePattern = [60, 62, 64, 67, 69, 72];\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * cnv.mousePressed(canvasPressed);\r\n * colorMode(HSB);\r\n * background(0, 0, 86);\r\n * text('tap to start/stop', 10, 20);\r\n *\r\n * //the looper's callback is passed the timeFromNow\r\n * //this value should be used as a reference point from\r\n * //which to schedule sounds\r\n * let intervalInSeconds = 0.2;\r\n * soundLoop = new p5.SoundLoop(onSoundLoop, intervalInSeconds);\r\n *\r\n * synth = new p5.MonoSynth();\r\n * }\r\n *\r\n * function canvasPressed() {\r\n * // ensure audio is enabled\r\n * userStartAudio();\r\n *\r\n * if (soundLoop.isPlaying) {\r\n * soundLoop.stop();\r\n * } else {\r\n * // start the loop\r\n * soundLoop.start();\r\n * }\r\n * }\r\n *\r\n * function onSoundLoop(timeFromNow) {\r\n * let noteIndex = (soundLoop.iterations - 1) % notePattern.length;\r\n * let note = midiToFreq(notePattern[noteIndex]);\r\n * synth.play(note, 0.5, timeFromNow);\r\n * background(noteIndex * 360 / notePattern.length, 50, 100);\r\n * }\r\n *
\r\n */\r\n p5.SoundLoop = function(callback, interval) {\r\n this.callback = callback;\r\n /**\r\n * musicalTimeMode uses Tone.Time convention\r\n * true if string, false if number\r\n * @property {Boolean} musicalTimeMode\r\n */\r\n this.musicalTimeMode = typeof this._interval === 'number' ? false : true;\r\n\r\n this._interval = interval || 1;\r\n\r\n /**\r\n * musicalTimeMode variables\r\n * modify these only when the interval is specified in musicalTime format as a string\r\n */\r\n this._timeSignature = 4;\r\n this._bpm = 60;\r\n\r\n this.isPlaying = false;\r\n\r\n /**\r\n * Set a limit to the number of loops to play. defaults to Infinity\r\n * @property {Number} maxIterations\r\n */\r\n this.maxIterations = Infinity;\r\n var self = this;\r\n\r\n this.clock = new Clock({\r\n 'callback' : function(time) {\r\n var timeFromNow = time - p5sound.audiocontext.currentTime;\r\n /**\r\n * Do not initiate the callback if timeFromNow is < 0\r\n * This ususually occurs for a few milliseconds when the page\r\n * is not fully loaded\r\n *\r\n * The callback should only be called until maxIterations is reached\r\n */\r\n if (timeFromNow > 0 && self.iterations <= self.maxIterations) {\r\n self.callback(timeFromNow);}\r\n },\r\n 'frequency' : this._calcFreq()\r\n });\r\n };\r\n\r\n /**\r\n * Start the loop\r\n * @method start\r\n * @for p5.SoundLoop\r\n * @param {Number} [timeFromNow] schedule a starting time\r\n */\r\n p5.SoundLoop.prototype.start = function(timeFromNow) {\r\n var t = timeFromNow || 0;\r\n var now = p5sound.audiocontext.currentTime;\r\n if (!this.isPlaying) {\r\n this.clock.start(now + t);\r\n this.isPlaying = true;\r\n }\r\n };\r\n\r\n /**\r\n * Stop the loop\r\n * @method stop\r\n * @for p5.SoundLoop\r\n * @param {Number} [timeFromNow] schedule a stopping time\r\n */\r\n p5.SoundLoop.prototype.stop = function(timeFromNow) {\r\n var t = timeFromNow || 0;\r\n var now = p5sound.audiocontext.currentTime;\r\n if (this.isPlaying) {\r\n this.clock.stop(now + t);\r\n this.isPlaying = false;\r\n }\r\n };\r\n /**\r\n * Pause the loop\r\n * @method pause\r\n * @for p5.SoundLoop\r\n * @param {Number} [timeFromNow] schedule a pausing time\r\n */\r\n p5.SoundLoop.prototype.pause = function(timeFromNow) {\r\n var t = timeFromNow || 0;\r\n var now = p5sound.audiocontext.currentTime;\r\n if (this.isPlaying) {\r\n this.clock.pause(now + t);\r\n this.isPlaying = false;\r\n }\r\n };\r\n\r\n\r\n /**\r\n * Synchronize loops. Use this method to start two or more loops in synchronization\r\n * or to start a loop in synchronization with a loop that is already playing\r\n * This method will schedule the implicit loop in sync with the explicit master loop\r\n * i.e. loopToStart.syncedStart(loopToSyncWith)\r\n *\r\n * @method syncedStart\r\n * @for p5.SoundLoop\r\n * @param {Object} otherLoop a p5.SoundLoop to sync with\r\n * @param {Number} [timeFromNow] Start the loops in sync after timeFromNow seconds\r\n */\r\n p5.SoundLoop.prototype.syncedStart = function(otherLoop, timeFromNow) {\r\n var t = timeFromNow || 0;\r\n var now = p5sound.audiocontext.currentTime;\r\n\r\n if (!otherLoop.isPlaying) {\r\n otherLoop.clock.start(now + t);\r\n otherLoop.isPlaying = true;\r\n this.clock.start(now + t);\r\n this.isPlaying = true;\r\n } else if (otherLoop.isPlaying) {\r\n var time = otherLoop.clock._nextTick - p5sound.audiocontext.currentTime;\r\n this.clock.start(now + time);\r\n this.isPlaying = true;\r\n }\r\n };\r\n\r\n\r\n /**\r\n * Updates frequency value, reflected in next callback\r\n * @private\r\n * @for p5.SoundLoop\r\n * @method _update\r\n */\r\n p5.SoundLoop.prototype._update = function() {\r\n this.clock.frequency.value = this._calcFreq();\r\n };\r\n\r\n /**\r\n * Calculate the frequency of the clock's callback based on bpm, interval, and timesignature\r\n * @private\r\n * @for p5.SoundLoop\r\n * @method _calcFreq\r\n * @return {Number} new clock frequency value\r\n */\r\n p5.SoundLoop.prototype._calcFreq = function() {\r\n //Seconds mode, bpm / timesignature has no effect\r\n if (typeof this._interval === 'number') {\r\n this.musicalTimeMode = false;\r\n return 1 / this._interval;\r\n }\r\n //Musical timing mode, calculate interval based bpm, interval,and time signature\r\n else if (typeof this._interval === 'string') {\r\n this.musicalTimeMode = true;\r\n return this._bpm / 60 / this._convertNotation(this._interval) * (this._timeSignature / 4);\r\n }\r\n };\r\n\r\n /**\r\n * Convert notation from musical time format to seconds\r\n * Uses Tone.Time convention\r\n * @private\r\n * @for p5.SoundLoop\r\n * @method _convertNotation\r\n * @param {String} value value to be converted\r\n * @return {Number} converted value in seconds\r\n */\r\n p5.SoundLoop.prototype._convertNotation = function(value) {\r\n var type = value.slice(-1);\r\n value = Number(value.slice(0,-1));\r\n switch (type) {\r\n case 'm':\r\n return this._measure(value);\r\n case 'n':\r\n return this._note(value);\r\n default:\r\n console.warn('Specified interval is not formatted correctly. See Tone.js '+\r\n 'timing reference for more info: https://github.com/Tonejs/Tone.js/wiki/Time');\r\n }\r\n };\r\n\r\n /**\r\n * Helper conversion methods of measure and note\r\n * @private\r\n * @for p5.SoundLoop\r\n * @method _measure\r\n */\r\n p5.SoundLoop.prototype._measure = function(value) {\r\n return value * this._timeSignature;\r\n };\r\n\r\n /**\r\n * @private\r\n * @method _note\r\n * @for p5.SoundLoop\r\n */\r\n p5.SoundLoop.prototype._note = function(value) {\r\n return this._timeSignature / value ;\r\n };\r\n\r\n\r\n /**\r\n * Getters and Setters, setting any paramter will result in a change in the clock's\r\n * frequency, that will be reflected after the next callback\r\n * beats per minute (defaults to 60)\r\n * @property {Number} bpm\r\n * @for p5.SoundLoop\r\n */\r\n Object.defineProperty(p5.SoundLoop.prototype, 'bpm', {\r\n get : function() {\r\n return this._bpm;\r\n },\r\n set : function(bpm) {\r\n if (!this.musicalTimeMode) {\r\n console.warn('Changing the BPM in \"seconds\" mode has no effect. '+\r\n 'BPM is only relevant in musicalTimeMode '+\r\n 'when the interval is specified as a string '+\r\n '(\"2n\", \"4n\", \"1m\"...etc)');\r\n }\r\n this._bpm = bpm;\r\n this._update();\r\n }\r\n });\r\n\r\n /**\r\n * number of quarter notes in a measure (defaults to 4)\r\n * @property {Number} timeSignature\r\n * @for p5.SoundLoop\r\n */\r\n Object.defineProperty(p5.SoundLoop.prototype, 'timeSignature', {\r\n get : function() {\r\n return this._timeSignature;\r\n },\r\n set : function(timeSig) {\r\n if (!this.musicalTimeMode) {\r\n console.warn('Changing the timeSignature in \"seconds\" mode has no effect. '+\r\n 'BPM is only relevant in musicalTimeMode '+\r\n 'when the interval is specified as a string '+\r\n '(\"2n\", \"4n\", \"1m\"...etc)');\r\n }\r\n this._timeSignature = timeSig;\r\n this._update();\r\n }\r\n });\r\n\r\n /**\r\n * length of the loops interval\r\n * @property {Number|String} interval\r\n * @for p5.SoundLoop\r\n */\r\n Object.defineProperty(p5.SoundLoop.prototype, 'interval', {\r\n get : function() {\r\n return this._interval;\r\n },\r\n set : function(interval) {\r\n this.musicalTimeMode = typeof interval === 'Number'? false : true;\r\n this._interval = interval;\r\n this._update();\r\n }\r\n });\r\n\r\n /**\r\n * how many times the callback has been called so far\r\n * @property {Number} iterations\r\n * @for p5.SoundLoop\r\n * @readonly\r\n */\r\n Object.defineProperty(p5.SoundLoop.prototype, 'iterations', {\r\n get : function() {\r\n return this.clock.ticks;\r\n }\r\n });\r\n\r\n return p5.SoundLoop;\r\n});\r\n","define(function (require) {\r\n\t'use strict';\r\n\r\n\tvar p5sound = require('master');\r\n\tvar Effect = require('effect');\r\n var CustomError = require('errorHandler');\r\n\r\n /**\r\n * Compressor is an audio effect class that performs dynamics compression\r\n * on an audio input source. This is a very commonly used technique in music\r\n * and sound production. Compression creates an overall louder, richer,\r\n * and fuller sound by lowering the volume of louds and raising that of softs.\r\n * Compression can be used to avoid clipping (sound distortion due to\r\n * peaks in volume) and is especially useful when many sounds are played\r\n * at once. Compression can be used on indivudal sound sources in addition\r\n * to the master output.\r\n *\r\n * This class extends p5.Effect.\r\n * Methods amp(), chain(),\r\n * drywet(), connect(), and\r\n * disconnect() are available.\r\n *\r\n * @class p5.Compressor\r\n * @constructor\r\n * @extends p5.Effect\r\n *\r\n *\r\n */\r\n\tp5.Compressor = function() {\r\n\t\tEffect.call(this);\r\n\r\n /**\r\n * The p5.Compressor is built with a Web Audio Dynamics Compressor Node\r\n * \r\n * @property {AudioNode} compressor\r\n */\r\n\r\n\r\n\t\tthis.compressor = this.ac.createDynamicsCompressor();\r\n\r\n this.input.connect(this.compressor);\r\n this.compressor.connect(this.wet);\r\n\t};\r\n\r\n\tp5.Compressor.prototype = Object.create(Effect.prototype);\r\n\r\n /**\r\n * Performs the same function as .connect, but also accepts\r\n * optional parameters to set compressor's audioParams\r\n * @method process\r\n * @for p5.Compressor\r\n *\r\n * @param {Object} src Sound source to be connected\r\n *\r\n * @param {Number} [attack] The amount of time (in seconds) to reduce the gain by 10dB,\r\n * default = .003, range 0 - 1\r\n * @param {Number} [knee] A decibel value representing the range above the\r\n * threshold where the curve smoothly transitions to the \"ratio\" portion.\r\n * default = 30, range 0 - 40\r\n * @param {Number} [ratio] The amount of dB change in input for a 1 dB change in output\r\n * default = 12, range 1 - 20\r\n * @param {Number} [threshold] The decibel value above which the compression will start taking effect\r\n * default = -24, range -100 - 0\r\n * @param {Number} [release] The amount of time (in seconds) to increase the gain by 10dB\r\n * default = .25, range 0 - 1\r\n */\r\n\tp5.Compressor.prototype.process = function(src, attack, knee,\r\n ratio, threshold, release) {\r\n\t\tsrc.connect(this.input);\r\n\t\tthis.set(attack, knee, ratio, threshold, release);\r\n\t};\r\n\r\n /**\r\n * Set the paramters of a compressor.\r\n * @method set\r\n * @for p5.Compressor\r\n * @param {Number} attack The amount of time (in seconds) to reduce the gain by 10dB,\r\n * default = .003, range 0 - 1\r\n * @param {Number} knee A decibel value representing the range above the\r\n * threshold where the curve smoothly transitions to the \"ratio\" portion.\r\n * default = 30, range 0 - 40\r\n * @param {Number} ratio The amount of dB change in input for a 1 dB change in output\r\n * default = 12, range 1 - 20\r\n * @param {Number} threshold The decibel value above which the compression will start taking effect\r\n * default = -24, range -100 - 0\r\n * @param {Number} release The amount of time (in seconds) to increase the gain by 10dB\r\n * default = .25, range 0 - 1\r\n */\r\n p5.Compressor.prototype.set = function (attack, knee,\r\n ratio, threshold, release) {\r\n\r\n if (typeof attack !== 'undefined') {this.attack(attack);}\r\n if (typeof knee !== 'undefined') {this.knee(knee);}\r\n if (typeof ratio !== 'undefined') {this.ratio(ratio);}\r\n if (typeof threshold !== 'undefined') {this.threshold(threshold);}\r\n if (typeof release !== 'undefined') {this.release(release);}\r\n };\r\n\r\n\r\n /**\r\n * Get current attack or set value w/ time ramp\r\n *\r\n *\r\n * @method attack\r\n * @for p5.Compressor\r\n * @param {Number} [attack] Attack is the amount of time (in seconds) to reduce the gain by 10dB,\r\n * default = .003, range 0 - 1\r\n * @param {Number} [time] Assign time value to schedule the change in value\r\n */\r\n p5.Compressor.prototype.attack = function (attack, time){\r\n var t = time || 0;\r\n if (typeof attack == 'number'){\r\n this.compressor.attack.value = attack;\r\n this.compressor.attack.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.compressor.attack.linearRampToValueAtTime(attack, this.ac.currentTime + 0.02 + t);\r\n } else if (typeof attack !== 'undefined') {\r\n attack.connect(this.compressor.attack);\r\n }\r\n return this.compressor.attack.value;\r\n };\r\n\r\n\r\n /**\r\n * Get current knee or set value w/ time ramp\r\n *\r\n * @method knee\r\n * @for p5.Compressor\r\n * @param {Number} [knee] A decibel value representing the range above the\r\n * threshold where the curve smoothly transitions to the \"ratio\" portion.\r\n * default = 30, range 0 - 40\r\n * @param {Number} [time] Assign time value to schedule the change in value\r\n */\r\n p5.Compressor.prototype.knee = function (knee, time){\r\n var t = time || 0;\r\n if (typeof knee == 'number'){\r\n this.compressor.knee.value = knee;\r\n this.compressor.knee.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.compressor.knee.linearRampToValueAtTime(knee, this.ac.currentTime + 0.02 + t);\r\n } else if (typeof knee !== 'undefined') {\r\n knee.connect(this.compressor.knee);\r\n }\r\n return this.compressor.knee.value;\r\n };\r\n\r\n\r\n /**\r\n * Get current ratio or set value w/ time ramp\r\n * @method ratio\r\n * @for p5.Compressor\r\n * @param {Number} [ratio] The amount of dB change in input for a 1 dB change in output\r\n * default = 12, range 1 - 20\r\n * @param {Number} [time] Assign time value to schedule the change in value\r\n */\r\n p5.Compressor.prototype.ratio = function (ratio, time){\r\n var t = time || 0;\r\n if (typeof ratio == 'number'){\r\n this.compressor.ratio.value = ratio;\r\n this.compressor.ratio.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.compressor.ratio.linearRampToValueAtTime(ratio, this.ac.currentTime + 0.02 + t);\r\n } else if (typeof ratio !== 'undefined') {\r\n ratio.connect(this.compressor.ratio);\r\n }\r\n return this.compressor.ratio.value;\r\n };\r\n\r\n\r\n /**\r\n * Get current threshold or set value w/ time ramp\r\n * @method threshold\r\n * @for p5.Compressor\r\n * @param {Number} threshold The decibel value above which the compression will start taking effect\r\n * default = -24, range -100 - 0\r\n * @param {Number} [time] Assign time value to schedule the change in value\r\n */\r\n p5.Compressor.prototype.threshold = function (threshold, time){\r\n var t = time || 0;\r\n if (typeof threshold == 'number'){\r\n this.compressor.threshold.value = threshold;\r\n this.compressor.threshold.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.compressor.threshold.linearRampToValueAtTime(threshold, this.ac.currentTime + 0.02 + t);\r\n } else if (typeof threshold !== 'undefined') {\r\n threshold.connect(this.compressor.threshold);\r\n }\r\n return this.compressor.threshold.value;\r\n };\r\n\r\n\r\n /**\r\n * Get current release or set value w/ time ramp\r\n * @method release\r\n * @for p5.Compressor\r\n * @param {Number} release The amount of time (in seconds) to increase the gain by 10dB\r\n * default = .25, range 0 - 1\r\n *\r\n * @param {Number} [time] Assign time value to schedule the change in value\r\n */\r\n p5.Compressor.prototype.release = function (release, time){\r\n var t = time || 0;\r\n if (typeof release == 'number'){\r\n this.compressor.release.value = release;\r\n this.compressor.release.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.compressor.release.linearRampToValueAtTime(release, this.ac.currentTime + 0.02 + t);\r\n } else if (typeof number !== 'undefined') {\r\n release.connect(this.compressor.release);\r\n }\r\n return this.compressor.release.value;\r\n };\r\n\r\n /**\r\n * Return the current reduction value\r\n *\r\n * @method reduction\r\n * @for p5.Compressor\r\n * @return {Number} Value of the amount of gain reduction that is applied to the signal\r\n */\r\n p5.Compressor.prototype.reduction =function() {\r\n return this.compressor.reduction.value;\r\n };\r\n\r\n\r\n\tp5.Compressor.prototype.dispose = function() {\r\n Effect.prototype.dispose.apply(this);\r\n if (this.compressor) {\r\n this.compressor.disconnect();\r\n delete this.compressor;\r\n }\r\n\t};\r\n\r\n return p5.Compressor;\r\n});\r\n","'use strict';\r\n\r\ndefine(function (require) {\r\n\r\n // inspiration: recorder.js, Tone.js & typedarray.org\r\n\r\n const p5sound = require('master');\r\n const { convertToWav, safeBufferSize } = require('helpers');\r\n const processorNames = require('./audioWorklet/processorNames');\r\n const ac = p5sound.audiocontext;\r\n\r\n /**\r\n *

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

\r\n *

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

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

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

\r\n *

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

\r\n *

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

\r\n *\r\n *

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

\r\n *\r\n *

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

\r\n *\r\n *

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

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

Scale the output of all sound in this sketch

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

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

\r\n *\r\n *

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

\r\n *\r\n * @method masterVolume\r\n * @param {Number|Object} volume Volume (amplitude) between 0.0\r\n * and 1.0 or modulating signal/oscillator\r\n * @param {Number} [rampTime] Fade for t seconds\r\n * @param {Number} [timeFromNow] Schedule this event to happen at\r\n * t seconds in the future\r\n */\r\n p5.prototype.masterVolume = function(vol, rampTime, tFromNow) {\r\n if (typeof vol === 'number') {\r\n var rampTime = rampTime || 0;\r\n var tFromNow = tFromNow || 0;\r\n var now = p5sound.audiocontext.currentTime;\r\n var currentVol = p5sound.output.gain.value;\r\n p5sound.output.gain.cancelScheduledValues(now + tFromNow);\r\n p5sound.output.gain.linearRampToValueAtTime(currentVol, now + tFromNow);\r\n p5sound.output.gain.linearRampToValueAtTime(vol, now + tFromNow + rampTime);\r\n }\r\n else if (vol) {\r\n vol.connect(p5sound.output.gain);\r\n } else {\r\n // return the Gain Node\r\n return p5sound.output.gain;\r\n }\r\n };\r\n\r\n /**\r\n * `p5.soundOut` is the p5.sound master output. It sends output to\r\n * the destination of this window's web audio context. It contains\r\n * Web Audio API nodes including a dyanmicsCompressor (.limiter),\r\n * and Gain Nodes for .input and .output.\r\n *\r\n * @property {Object} soundOut\r\n */\r\n p5.prototype.soundOut = p5.soundOut = p5sound;\r\n\r\n // a silent connection to the DesinationNode\r\n // which will ensure that anything connected to it\r\n // will not be garbage collected\r\n p5.soundOut._silentNode = p5sound.audiocontext.createGain();\r\n p5.soundOut._silentNode.gain.value = 0;\r\n p5.soundOut._silentNode.connect(p5sound.audiocontext.destination);\r\n\r\n\r\n return p5sound;\r\n});\r\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';\r\ndefine(function (require) {\r\n\r\n var p5sound = require('master');\r\n var CrossFade = require('Tone/component/CrossFade');\r\n\r\n /**\r\n * Effect is a base class for audio effects in p5.
\r\n * This module handles the nodes and methods that are\r\n * common and useful for current and future effects.\r\n *\r\n *\r\n * This class is extended by p5.Distortion,\r\n * p5.Compressor,\r\n * p5.Delay,\r\n * p5.Filter,\r\n * p5.Reverb.\r\n *\r\n * @class p5.Effect\r\n * @constructor\r\n *\r\n * @param {Object} [ac] Reference to the audio context of the p5 object\r\n * @param {AudioNode} [input] Gain Node effect wrapper\r\n * @param {AudioNode} [output] Gain Node effect wrapper\r\n * @param {Object} [_drywet] Tone.JS CrossFade node (defaults to value: 1)\r\n * @param {AudioNode} [wet] Effects that extend this class should connect\r\n * to the wet signal to this gain node, so that dry and wet\r\n * signals are mixed properly.\r\n */\r\n p5.Effect = function() {\r\n this.ac = p5sound.audiocontext;\r\n\r\n this.input = this.ac.createGain();\r\n this.output = this.ac.createGain();\r\n\r\n /**\r\n *\tThe p5.Effect class is built\r\n * \tusing Tone.js CrossFade\r\n * \t@private\r\n */\r\n\r\n this._drywet = new CrossFade(1);\r\n\r\n /**\r\n *\tIn classes that extend\r\n *\tp5.Effect, connect effect nodes\r\n *\tto the wet parameter\r\n */\r\n this.wet = this.ac.createGain();\r\n\r\n this.input.connect(this._drywet.a);\r\n this.wet.connect(this._drywet.b);\r\n this._drywet.connect(this.output);\r\n\r\n this.connect();\r\n\r\n //Add to the soundArray\r\n p5sound.soundArray.push(this);\r\n };\r\n\r\n /**\r\n * Set the output volume of the filter.\r\n *\r\n * @method amp\r\n * @for p5.Effect\r\n * @param {Number} [vol] amplitude between 0 and 1.0\r\n * @param {Number} [rampTime] create a fade that lasts until rampTime\r\n * @param {Number} [tFromNow] schedule this event to happen in tFromNow seconds\r\n */\r\n p5.Effect.prototype.amp = function(vol, rampTime, tFromNow){\r\n var rampTime = rampTime || 0;\r\n var tFromNow = tFromNow || 0;\r\n var now = p5sound.audiocontext.currentTime;\r\n var currentVol = this.output.gain.value;\r\n this.output.gain.cancelScheduledValues(now);\r\n this.output.gain.linearRampToValueAtTime(currentVol, now + tFromNow + .001);\r\n this.output.gain.linearRampToValueAtTime(vol, now + tFromNow + rampTime + .001);\r\n };\r\n\r\n /**\r\n * Link effects together in a chain\r\n * Example usage: filter.chain(reverb, delay, panner);\r\n * May be used with an open-ended number of arguments\r\n *\r\n * @method chain\r\n * @for p5.Effect\r\n * @param {Object} [arguments] Chain together multiple sound objects\r\n */\r\n p5.Effect.prototype.chain = function(){\r\n if (arguments.length>0){\r\n this.connect(arguments[0]);\r\n for(var i=1;i\r\n * let midiNotes = [60, 64, 67, 72];\r\n * let noteIndex = 0;\r\n * let midiVal, freq;\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * cnv.mousePressed(startSound);\r\n * osc = new p5.TriOsc();\r\n * env = new p5.Envelope();\r\n * }\r\n *\r\n * function draw() {\r\n * background(220);\r\n * text('tap to play', 10, 20);\r\n * if (midiVal) {\r\n * text('MIDI: ' + midiVal, 10, 40);\r\n * text('Freq: ' + freq, 10, 60);\r\n * }\r\n * }\r\n *\r\n * function startSound() {\r\n * // see also: userStartAudio();\r\n * osc.start();\r\n *\r\n * midiVal = midiNotes[noteIndex % midiNotes.length];\r\n * freq = midiToFreq(midiVal);\r\n * osc.freq(freq);\r\n * env.ramp(osc, 0, 1.0, 0);\r\n *\r\n * noteIndex++;\r\n * }\r\n * \r\n */\r\n var midiToFreq = p5.prototype.midiToFreq = function(m) {\r\n return 440 * Math.pow(2, (m-69)/12.0);\r\n };\r\n\r\n // This method converts ANSI notes specified as a string \"C4\", \"Eb3\" to a frequency\r\n var noteToFreq = function(note) {\r\n if (typeof note !== 'string') {\r\n return note;\r\n }\r\n var wholeNotes = {A:21, B:23, C:24, D:26, E:28, F:29, G:31};\r\n var value = wholeNotes[ note[0].toUpperCase() ];\r\n var octave = ~~note.slice(-1);\r\n value += 12 * (octave -1);\r\n\r\n switch(note[1]) {\r\n case '#':\r\n value += 1;\r\n break;\r\n case 'b':\r\n value -= 1;\r\n break;\r\n default:\r\n break;\r\n }\r\n return midiToFreq(value);\r\n };\r\n\r\n /**\r\n * List the SoundFile formats that you will include. LoadSound\r\n * will search your directory for these extensions, and will pick\r\n * a format that is compatable with the client's web browser.\r\n * Here is a free online file\r\n * converter.\r\n *\r\n * @method soundFormats\r\n * @param {String} [...formats] i.e. 'mp3', 'wav', 'ogg'\r\n * @example\r\n *
\r\n * function preload() {\r\n * // set the global sound formats\r\n * soundFormats('mp3', 'ogg');\r\n *\r\n * // load either beatbox.mp3, or .ogg, depending on browser\r\n * mySound = loadSound('assets/beatbox.mp3');\r\n * }\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * background(220);\r\n * text('sound loaded! tap to play', 10, 20, width - 20);\r\n * cnv.mousePressed(function() {\r\n * mySound.play();\r\n * });\r\n * }\r\n *
\r\n */\r\n p5.prototype.soundFormats = function() {\r\n // reset extensions array\r\n p5sound.extensions = [];\r\n // add extensions\r\n for (var i = 0; i < arguments.length; i++) {\r\n arguments[i] = arguments[i].toLowerCase();\r\n if (['mp3','wav','ogg', 'm4a', 'aac'].indexOf(arguments[i]) > -1) {\r\n p5sound.extensions.push(arguments[i]);\r\n } else {\r\n throw arguments[i] + ' is not a valid sound format!';\r\n }\r\n }\r\n };\r\n\r\n p5.prototype.disposeSound = function() {\r\n for (var i = 0; i < p5sound.soundArray.length; i++) {\r\n p5sound.soundArray[i].dispose();\r\n }\r\n };\r\n\r\n // register removeSound to dispose of p5sound SoundFiles, Convolvers,\r\n // Oscillators etc when sketch ends\r\n p5.prototype.registerMethod('remove', p5.prototype.disposeSound);\r\n\r\n p5.prototype._checkFileFormats = function(paths) {\r\n var path;\r\n // if path is a single string, check to see if extension is provided\r\n if (typeof paths === 'string') {\r\n path = paths;\r\n // see if extension is provided\r\n var extTest = path.split('.').pop();\r\n // if an extension is provided...\r\n if (['mp3','wav','ogg', 'm4a', 'aac'].indexOf(extTest) > -1) {\r\n if (p5.prototype.isFileSupported(extTest)) {\r\n path = path;\r\n }\r\n else {\r\n var pathSplit = path.split('.');\r\n var pathCore = pathSplit[pathSplit.length - 1];\r\n for (var i = 0; i 1) {\r\n rightChannel = audioBuffer.getChannelData(1);\r\n } else {\r\n rightChannel = leftChannel;\r\n }\r\n\r\n var interleaved = interleave(leftChannel, rightChannel);\r\n\r\n // create the buffer and view to create the .WAV file\r\n var buffer = new window.ArrayBuffer(44 + interleaved.length * 2);\r\n var view = new window.DataView(buffer);\r\n\r\n // write the WAV container,\r\n // check spec at: https://web.archive.org/web/20171215131933/http://tiny.systems/software/soundProgrammer/WavFormatDocs.pdf\r\n\r\n // RIFF chunk descriptor\r\n writeUTFBytes(view, 0, 'RIFF');\r\n view.setUint32(4, 36 + interleaved.length * 2, true);\r\n writeUTFBytes(view, 8, 'WAVE');\r\n // FMT sub-chunk\r\n writeUTFBytes(view, 12, 'fmt ');\r\n view.setUint32(16, 16, true);\r\n view.setUint16(20, 1, true);\r\n // stereo (2 channels)\r\n view.setUint16(22, 2, true);\r\n view.setUint32(24, p5sound.audiocontext.sampleRate, true);\r\n view.setUint32(28, p5sound.audiocontext.sampleRate * 4, true);\r\n view.setUint16(32, 4, true);\r\n view.setUint16(34, 16, true);\r\n // data sub-chunk\r\n writeUTFBytes(view, 36, 'data');\r\n view.setUint32(40, interleaved.length * 2, true);\r\n\r\n // write the PCM samples\r\n var lng = interleaved.length;\r\n var index = 44;\r\n var volume = 1;\r\n for (var i = 0; i < lng; i++) {\r\n view.setInt16(index, interleaved[i] * (0x7FFF * volume), true);\r\n index += 2;\r\n }\r\n\r\n return view;\r\n }\r\n\r\n // helper methods to save waves\r\n function interleave(leftChannel, rightChannel) {\r\n var length = leftChannel.length + rightChannel.length;\r\n var result = new Float32Array(length);\r\n\r\n var inputIndex = 0;\r\n\r\n for (var index = 0; index < length;) {\r\n result[index++] = leftChannel[inputIndex];\r\n result[index++] = rightChannel[inputIndex];\r\n inputIndex++;\r\n }\r\n return result;\r\n }\r\n\r\n function writeUTFBytes(view, offset, string) {\r\n var lng = string.length;\r\n for (var i = 0; i < lng; i++) {\r\n view.setUint8(offset + i, string.charCodeAt(i));\r\n }\r\n }\r\n\r\n function safeBufferSize(idealBufferSize) {\r\n let bufferSize = idealBufferSize;\r\n\r\n // if the AudioWorkletNode is actually a ScriptProcessorNode created via polyfill,\r\n // make sure that our chosen buffer size isn't smaller than the buffer size automatically\r\n // selected by the polyfill\r\n // reference: https://github.com/GoogleChromeLabs/audioworklet-polyfill/issues/13#issuecomment-425014930\r\n let tempAudioWorkletNode = new AudioWorkletNode(p5sound.audiocontext, processorNames.soundFileProcessor);\r\n if (tempAudioWorkletNode instanceof ScriptProcessorNode) {\r\n bufferSize = tempAudioWorkletNode.bufferSize;\r\n }\r\n tempAudioWorkletNode.disconnect();\r\n tempAudioWorkletNode = null;\r\n\r\n return bufferSize;\r\n }\r\n\r\n return {\r\n convertToWav: convertToWav,\r\n midiToFreq: midiToFreq,\r\n noteToFreq: noteToFreq,\r\n safeBufferSize: safeBufferSize\r\n };\r\n\r\n});\r\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 = {\r\n recorderProcessor: 'recorder-processor',\r\n soundFileProcessor: 'sound-file-processor',\r\n amplitudeProcessor: 'amplitude-processor'\r\n};\r\n","'use strict';\r\n\r\ndefine(function () {\r\n /*\r\n Helper function to generate an error\r\n with a custom stack trace that points to the sketch\r\n and removes other parts of the stack trace.\r\n\r\n @private\r\n @class customError\r\n @constructor\r\n @param {String} name custom error name\r\n @param {String} errorTrace custom error trace\r\n @param {String} failedPath path to the file that failed to load\r\n @property {String} name custom error name\r\n @property {String} message custom error message\r\n @property {String} stack trace the error back to a line in the user's sketch.\r\n Note: this edits out stack trace within p5.js and p5.sound.\r\n @property {String} originalStack unedited, original stack trace\r\n @property {String} failedPath path to the file that failed to load\r\n @return {Error} returns a custom Error object\r\n */\r\n var CustomError = function(name, errorTrace, failedPath) {\r\n var err = new Error();\r\n var tempStack, splitStack;\r\n\r\n err.name = name;\r\n err.originalStack = err.stack + errorTrace;\r\n tempStack = err.stack + errorTrace;\r\n err.failedPath = failedPath;\r\n\r\n // only print the part of the stack trace that refers to the user code:\r\n var splitStack = tempStack.split('\\n');\r\n splitStack = splitStack.filter(function(ln) {\r\n return !ln.match(/(p5.|native code|globalInit)/g);\r\n });\r\n err.stack = splitStack.join('\\n');\r\n\r\n return err; // TODO: is this really a constructor?\r\n };\r\n\r\n return CustomError;\r\n});\r\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';\r\n\r\ndefine(function (require) {\r\n var Effect = require('effect');\r\n\r\n /**\r\n *

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

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

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

\r\n *\r\n *

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

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

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

\r\n *\r\n *

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

\r\n *\r\n *

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

\r\n * @param {Element|Array} [element(s)] This argument can be an Element,\r\n * Selector String, NodeList, p5.Element,\r\n * jQuery Element, or an Array of any of those.\r\n * @param {Function} [callback] Callback to invoke when the AudioContext\r\n * has started\r\n * @return {Promise} Returns a Promise that resolves when\r\n * the AudioContext state is 'running'\r\n * @method userStartAudio\r\n * @for p5\r\n * @example\r\n *
\r\n * function setup() {\r\n * // mimics the autoplay policy\r\n * getAudioContext().suspend();\r\n *\r\n * let mySynth = new p5.MonoSynth();\r\n *\r\n * // This won't play until the context has resumed\r\n * mySynth.play('A6');\r\n * }\r\n * function draw() {\r\n * background(220);\r\n * textAlign(CENTER, CENTER);\r\n * text(getAudioContext().state, width/2, height/2);\r\n * }\r\n * function mousePressed() {\r\n * userStartAudio();\r\n * }\r\n *
\r\n */\r\n p5.prototype.userStartAudio = function(elements, callback) {\r\n var elt = elements;\r\n if (elements instanceof p5.Element) {\r\n elt = elements.elt;\r\n } else if (elements instanceof Array && elements[0] instanceof p5.Element ) {\r\n elt = elements.map(function(e) { return e.elt});\r\n }\r\n return StartAudioContext(audiocontext, elt, callback);\r\n };\r\n\r\n return audiocontext;\r\n});\r\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';\r\n\r\ndefine(function (require) {\r\n var p5sound = require('master');\r\n\r\n var Add = require('Tone/signal/Add');\r\n var Mult = require('Tone/signal/Multiply');\r\n var Scale = require('Tone/signal/Scale');\r\n\r\n /**\r\n *

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

\r\n *\r\n *

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

\r\n *\r\n * @class p5.Oscillator\r\n * @constructor\r\n * @param {Number} [freq] frequency defaults to 440Hz\r\n * @param {String} [type] type of oscillator. Options:\r\n * 'sine' (default), 'triangle',\r\n * 'sawtooth', 'square'\r\n * @example\r\n *
\r\n * let osc, playing, freq, amp;\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * cnv.mousePressed(playOscillator);\r\n * osc = new p5.Oscillator('sine');\r\n * }\r\n *\r\n * function draw() {\r\n * background(220)\r\n * freq = constrain(map(mouseX, 0, width, 100, 500), 100, 500);\r\n * amp = constrain(map(mouseY, height, 0, 0, 1), 0, 1);\r\n *\r\n * text('tap to play', 20, 20);\r\n * text('freq: ' + freq, 20, 40);\r\n * text('amp: ' + amp, 20, 60);\r\n *\r\n * if (playing) {\r\n * // smooth the transitions by 0.1 seconds\r\n * osc.freq(freq, 0.1);\r\n * osc.amp(amp, 0.1);\r\n * }\r\n * }\r\n *\r\n * function playOscillator() {\r\n * // starting an oscillator on a user gesture will enable audio\r\n * // in browsers that have a strict autoplay policy.\r\n * // See also: userStartAudio();\r\n * osc.start();\r\n * playing = true;\r\n * }\r\n *\r\n * function mouseReleased() {\r\n * // ramp amplitude to 0 over 0.5 seconds\r\n * osc.amp(0, 0.5);\r\n * playing = false;\r\n * }\r\n *
\r\n */\r\n p5.Oscillator = function(freq, type) {\r\n if (typeof freq === 'string') {\r\n var f = type;\r\n type = freq;\r\n freq = f;\r\n } if (typeof type === 'number') {\r\n var f = type;\r\n type = freq;\r\n freq = f;\r\n }\r\n this.started = false;\r\n\r\n // components\r\n this.phaseAmount = undefined;\r\n this.oscillator = p5sound.audiocontext.createOscillator();\r\n this.f = freq || 440.0; // frequency\r\n this.oscillator.type = type || 'sine';\r\n this.oscillator.frequency.setValueAtTime(this.f, p5sound.audiocontext.currentTime);\r\n\r\n // connections\r\n this.output = p5sound.audiocontext.createGain();\r\n\r\n this._freqMods = []; // modulators connected to this oscillator's frequency\r\n\r\n // set default output gain to 0.5\r\n this.output.gain.value = 0.5;\r\n this.output.gain.setValueAtTime(0.5, p5sound.audiocontext.currentTime);\r\n\r\n this.oscillator.connect(this.output);\r\n // stereo panning\r\n this.panPosition = 0.0;\r\n this.connection = p5sound.input; // connect to p5sound by default\r\n this.panner = new p5.Panner(this.output, this.connection, 1);\r\n\r\n //array of math operation signal chaining\r\n this.mathOps = [this.output];\r\n\r\n // add to the soundArray so we can dispose of the osc later\r\n p5sound.soundArray.push(this);\r\n };\r\n\r\n /**\r\n * Start an oscillator.\r\n *\r\n * Starting an oscillator on a user gesture will enable audio in browsers\r\n * that have a strict autoplay policy, including Chrome and most mobile\r\n * devices. See also: `userStartAudio()`.\r\n *\r\n * @method start\r\n * @for p5.Oscillator\r\n * @param {Number} [time] startTime in seconds from now.\r\n * @param {Number} [frequency] frequency in Hz.\r\n */\r\n p5.Oscillator.prototype.start = function(time, f) {\r\n if (this.started) {\r\n var now = p5sound.audiocontext.currentTime;\r\n this.stop(now);\r\n }\r\n if (!this.started) {\r\n var freq = f || this.f;\r\n var type = this.oscillator.type;\r\n\r\n // set old osc free to be garbage collected (memory)\r\n if (this.oscillator) {\r\n this.oscillator.disconnect();\r\n delete this.oscillator;\r\n }\r\n\r\n // var detune = this.oscillator.frequency.value;\r\n this.oscillator = p5sound.audiocontext.createOscillator();\r\n this.oscillator.frequency.value = Math.abs(freq);\r\n this.oscillator.type = type;\r\n // this.oscillator.detune.value = detune;\r\n this.oscillator.connect(this.output);\r\n time = time || 0;\r\n this.oscillator.start(time + p5sound.audiocontext.currentTime);\r\n this.freqNode = this.oscillator.frequency;\r\n\r\n // if other oscillators are already connected to this osc's freq\r\n for (var i in this._freqMods) {\r\n if (typeof this._freqMods[i].connect !== 'undefined') {\r\n this._freqMods[i].connect(this.oscillator.frequency);\r\n }\r\n }\r\n\r\n this.started = true;\r\n }\r\n };\r\n\r\n /**\r\n * Stop an oscillator. Accepts an optional parameter\r\n * to determine how long (in seconds from now) until the\r\n * oscillator stops.\r\n *\r\n * @method stop\r\n * @for p5.Oscillator\r\n * @param {Number} secondsFromNow Time, in seconds from now.\r\n */\r\n p5.Oscillator.prototype.stop = function(time) {\r\n if (this.started) {\r\n var t = time || 0;\r\n var now = p5sound.audiocontext.currentTime;\r\n this.oscillator.stop(t + now);\r\n this.started = false;\r\n }\r\n };\r\n\r\n /**\r\n * Set the amplitude between 0 and 1.0. Or, pass in an object\r\n * such as an oscillator to modulate amplitude with an audio signal.\r\n *\r\n * @method amp\r\n * @for p5.Oscillator\r\n * @param {Number|Object} vol between 0 and 1.0\r\n * or a modulating signal/oscillator\r\n * @param {Number} [rampTime] create a fade that lasts rampTime\r\n * @param {Number} [timeFromNow] schedule this event to happen\r\n * seconds from now\r\n * @return {AudioParam} gain If no value is provided,\r\n * returns the Web Audio API\r\n * AudioParam that controls\r\n * this oscillator's\r\n * gain/amplitude/volume)\r\n */\r\n p5.Oscillator.prototype.amp = function(vol, rampTime, tFromNow) {\r\n var self = this;\r\n if (typeof vol === 'number') {\r\n var rampTime = rampTime || 0;\r\n var tFromNow = tFromNow || 0;\r\n var now = p5sound.audiocontext.currentTime;\r\n this.output.gain.linearRampToValueAtTime(vol, now + tFromNow + rampTime);\r\n }\r\n\r\n else if (vol) {\r\n vol.connect(self.output.gain);\r\n } else {\r\n // return the Gain Node\r\n return this.output.gain;\r\n }\r\n };\r\n\r\n // these are now the same thing\r\n p5.Oscillator.prototype.fade = p5.Oscillator.prototype.amp;\r\n\r\n p5.Oscillator.prototype.getAmp = function() {\r\n return this.output.gain.value;\r\n };\r\n\r\n /**\r\n * Set frequency of an oscillator to a value. Or, pass in an object\r\n * such as an oscillator to modulate the frequency with an audio signal.\r\n *\r\n * @method freq\r\n * @for p5.Oscillator\r\n * @param {Number|Object} Frequency Frequency in Hz\r\n * or modulating signal/oscillator\r\n * @param {Number} [rampTime] Ramp time (in seconds)\r\n * @param {Number} [timeFromNow] Schedule this event to happen\r\n * at x seconds from now\r\n * @return {AudioParam} Frequency If no value is provided,\r\n * returns the Web Audio API\r\n * AudioParam that controls\r\n * this oscillator's frequency\r\n * @example\r\n *
\r\n * let osc;\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * cnv.mousePressed(playOscillator);\r\n * osc = new p5.Oscillator(300);\r\n * background(220);\r\n * text('tap to play', 20, 20);\r\n * }\r\n *\r\n * function playOscillator() {\r\n * osc.start();\r\n * osc.amp(0.5);\r\n * // start at 700Hz\r\n * osc.freq(700);\r\n * // ramp to 60Hz over 0.7 seconds\r\n * osc.freq(60, 0.7);\r\n * osc.amp(0, 0.1, 0.7);\r\n * }\r\n *
\r\n */\r\n p5.Oscillator.prototype.freq = function(val, rampTime, tFromNow) {\r\n if (typeof val === 'number' && !isNaN(val)) {\r\n this.f = val;\r\n var now = p5sound.audiocontext.currentTime;\r\n var rampTime = rampTime || 0;\r\n var tFromNow = tFromNow || 0;\r\n var t = now + tFromNow + rampTime;\r\n // var currentFreq = this.oscillator.frequency.value;\r\n // this.oscillator.frequency.cancelScheduledValues(now);\r\n\r\n if (rampTime === 0) {\r\n this.oscillator.frequency.setValueAtTime(val, tFromNow + now);\r\n } else {\r\n if (val > 0 ) {\r\n this.oscillator.frequency.exponentialRampToValueAtTime(val, tFromNow + rampTime + now);\r\n } else {\r\n this.oscillator.frequency.linearRampToValueAtTime(val, tFromNow + rampTime + now);\r\n }\r\n }\r\n\r\n // reset phase if oscillator has a phase\r\n if (this.phaseAmount) {\r\n this.phase(this.phaseAmount);\r\n }\r\n\r\n } else if (val) {\r\n if (val.output) {\r\n val = val.output;\r\n }\r\n val.connect(this.oscillator.frequency);\r\n\r\n // keep track of what is modulating this param\r\n // so it can be re-connected if\r\n this._freqMods.push( val );\r\n } else {\r\n // return the Frequency Node\r\n return this.oscillator.frequency;\r\n }\r\n };\r\n\r\n p5.Oscillator.prototype.getFreq = function() {\r\n return this.oscillator.frequency.value;\r\n };\r\n\r\n /**\r\n * Set type to 'sine', 'triangle', 'sawtooth' or 'square'.\r\n *\r\n * @method setType\r\n * @for p5.Oscillator\r\n * @param {String} type 'sine', 'triangle', 'sawtooth' or 'square'.\r\n */\r\n p5.Oscillator.prototype.setType = function(type) {\r\n this.oscillator.type = type;\r\n };\r\n\r\n p5.Oscillator.prototype.getType = function() {\r\n return this.oscillator.type;\r\n };\r\n\r\n /**\r\n * Connect to a p5.sound / Web Audio object.\r\n *\r\n * @method connect\r\n * @for p5.Oscillator\r\n * @param {Object} unit A p5.sound or Web Audio object\r\n */\r\n p5.Oscillator.prototype.connect = function(unit) {\r\n if (!unit) {\r\n this.panner.connect(p5sound.input);\r\n }\r\n else if (unit.hasOwnProperty('input')) {\r\n this.panner.connect(unit.input);\r\n this.connection = unit.input;\r\n }\r\n else {\r\n this.panner.connect(unit);\r\n this.connection = unit;\r\n }\r\n };\r\n\r\n /**\r\n * Disconnect all outputs\r\n *\r\n * @method disconnect\r\n * @for p5.Oscillator\r\n */\r\n p5.Oscillator.prototype.disconnect = function() {\r\n if (this.output) {\r\n this.output.disconnect();\r\n }\r\n if (this.panner) {\r\n this.panner.disconnect();\r\n if (this.output) {\r\n this.output.connect(this.panner);\r\n }\r\n }\r\n this.oscMods = [];\r\n };\r\n\r\n /**\r\n * Pan between Left (-1) and Right (1)\r\n *\r\n * @method pan\r\n * @for p5.Oscillator\r\n * @param {Number} panning Number between -1 and 1\r\n * @param {Number} timeFromNow schedule this event to happen\r\n * seconds from now\r\n */\r\n p5.Oscillator.prototype.pan = function(pval, tFromNow) {\r\n this.panPosition = pval;\r\n this.panner.pan(pval, tFromNow);\r\n };\r\n\r\n p5.Oscillator.prototype.getPan = function() {\r\n return this.panPosition;\r\n };\r\n\r\n // get rid of the oscillator\r\n p5.Oscillator.prototype.dispose = function() {\r\n // remove reference from soundArray\r\n var index = p5sound.soundArray.indexOf(this);\r\n p5sound.soundArray.splice(index, 1);\r\n\r\n if (this.oscillator) {\r\n var now = p5sound.audiocontext.currentTime;\r\n this.stop(now);\r\n this.disconnect();\r\n this.panner = null;\r\n this.oscillator = null;\r\n }\r\n // if it is a Pulse\r\n if (this.osc2) {\r\n this.osc2.dispose();\r\n }\r\n };\r\n\r\n /**\r\n * Set the phase of an oscillator between 0.0 and 1.0.\r\n * In this implementation, phase is a delay time\r\n * based on the oscillator's current frequency.\r\n *\r\n * @method phase\r\n * @for p5.Oscillator\r\n * @param {Number} phase float between 0.0 and 1.0\r\n */\r\n p5.Oscillator.prototype.phase = function(p) {\r\n var delayAmt = p5.prototype.map(p, 0, 1.0, 0, 1/this.f);\r\n var now = p5sound.audiocontext.currentTime;\r\n\r\n this.phaseAmount = p;\r\n\r\n if (!this.dNode) {\r\n // create a delay node\r\n this.dNode = p5sound.audiocontext.createDelay();\r\n // put the delay node in between output and panner\r\n this.oscillator.disconnect();\r\n this.oscillator.connect(this.dNode);\r\n this.dNode.connect(this.output);\r\n }\r\n\r\n // set delay time to match phase:\r\n this.dNode.delayTime.setValueAtTime(delayAmt, now);\r\n };\r\n\r\n // ========================== //\r\n // SIGNAL MATH FOR MODULATION //\r\n // ========================== //\r\n\r\n // return sigChain(this, scale, thisChain, nextChain, Scale);\r\n var sigChain = function(o, mathObj, thisChain, nextChain, type) {\r\n var chainSource = o.oscillator;\r\n // if this type of math already exists in the chain, replace it\r\n for (var i in o.mathOps) {\r\n if (o.mathOps[i] instanceof type) {\r\n chainSource.disconnect();\r\n o.mathOps[i].dispose();\r\n thisChain = i;\r\n // assume nextChain is output gain node unless...\r\n if (thisChain < o.mathOps.length - 2) {\r\n nextChain = o.mathOps[i+1];\r\n }\r\n }\r\n }\r\n if (thisChain === o.mathOps.length - 1) {\r\n o.mathOps.push(nextChain);\r\n }\r\n // assume source is the oscillator unless i > 0\r\n if (i > 0) {\r\n chainSource = o.mathOps[i-1];\r\n }\r\n chainSource.disconnect();\r\n chainSource.connect(mathObj);\r\n mathObj.connect(nextChain);\r\n o.mathOps[thisChain] = mathObj;\r\n return o;\r\n };\r\n\r\n /**\r\n * Add a value to the p5.Oscillator's output amplitude,\r\n * and return the oscillator. Calling this method again\r\n * will override the initial add() with a new value.\r\n *\r\n * @method add\r\n * @for p5.Oscillator\r\n * @param {Number} number Constant number to add\r\n * @return {p5.Oscillator} Oscillator Returns this oscillator\r\n * with scaled output\r\n *\r\n */\r\n p5.Oscillator.prototype.add = function(num) {\r\n var add = new Add(num);\r\n var thisChain = this.mathOps.length-1;\r\n var nextChain = this.output;\r\n return sigChain(this, add, thisChain, nextChain, Add);\r\n };\r\n\r\n /**\r\n * Multiply the p5.Oscillator's output amplitude\r\n * by a fixed value (i.e. turn it up!). Calling this method\r\n * again will override the initial mult() with a new value.\r\n *\r\n * @method mult\r\n * @for p5.Oscillator\r\n * @param {Number} number Constant number to multiply\r\n * @return {p5.Oscillator} Oscillator Returns this oscillator\r\n * with multiplied output\r\n */\r\n p5.Oscillator.prototype.mult = function(num) {\r\n var mult = new Mult(num);\r\n var thisChain = this.mathOps.length-1;\r\n var nextChain = this.output;\r\n return sigChain(this, mult, thisChain, nextChain, Mult);\r\n };\r\n\r\n /**\r\n * Scale this oscillator's amplitude values to a given\r\n * range, and return the oscillator. Calling this method\r\n * again will override the initial scale() with new values.\r\n *\r\n * @method scale\r\n * @for p5.Oscillator\r\n * @param {Number} inMin input range minumum\r\n * @param {Number} inMax input range maximum\r\n * @param {Number} outMin input range minumum\r\n * @param {Number} outMax input range maximum\r\n * @return {p5.Oscillator} Oscillator Returns this oscillator\r\n * with scaled output\r\n */\r\n p5.Oscillator.prototype.scale = function(inMin, inMax, outMin, outMax) {\r\n var mapOutMin, mapOutMax;\r\n if (arguments.length === 4) {\r\n mapOutMin = p5.prototype.map(outMin, inMin, inMax, 0, 1) - 0.5;\r\n mapOutMax = p5.prototype.map(outMax, inMin, inMax, 0, 1) - 0.5;\r\n }\r\n else {\r\n mapOutMin = arguments[0];\r\n mapOutMax = arguments[1];\r\n }\r\n var scale = new Scale(mapOutMin, mapOutMax);\r\n var thisChain = this.mathOps.length-1;\r\n var nextChain = this.output;\r\n return sigChain(this, scale, thisChain, nextChain, Scale);\r\n\r\n // this.output.disconnect();\r\n // this.output.connect(scale)\r\n };\r\n\r\n // ============================== //\r\n // SinOsc, TriOsc, SqrOsc, SawOsc //\r\n // ============================== //\r\n\r\n /**\r\n * Constructor: new p5.SinOsc().\r\n * This creates a Sine Wave Oscillator and is\r\n * equivalent to new p5.Oscillator('sine')\r\n * or creating a p5.Oscillator and then calling\r\n * its method setType('sine').\r\n * See p5.Oscillator for methods.\r\n *\r\n * @class p5.SinOsc\r\n * @constructor\r\n * @extends p5.Oscillator\r\n * @param {Number} [freq] Set the frequency\r\n */\r\n p5.SinOsc = function(freq) {\r\n p5.Oscillator.call(this, freq, 'sine');\r\n };\r\n\r\n p5.SinOsc.prototype = Object.create(p5.Oscillator.prototype);\r\n\r\n /**\r\n * Constructor: new p5.TriOsc().\r\n * This creates a Triangle Wave Oscillator and is\r\n * equivalent to new p5.Oscillator('triangle')\r\n * or creating a p5.Oscillator and then calling\r\n * its method setType('triangle').\r\n * See p5.Oscillator for methods.\r\n *\r\n * @class p5.TriOsc\r\n * @constructor\r\n * @extends p5.Oscillator\r\n * @param {Number} [freq] Set the frequency\r\n */\r\n p5.TriOsc = function(freq) {\r\n p5.Oscillator.call(this, freq, 'triangle');\r\n };\r\n\r\n p5.TriOsc.prototype = Object.create(p5.Oscillator.prototype);\r\n\r\n /**\r\n * Constructor: new p5.SawOsc().\r\n * This creates a SawTooth Wave Oscillator and is\r\n * equivalent to new p5.Oscillator('sawtooth')\r\n * or creating a p5.Oscillator and then calling\r\n * its method setType('sawtooth').\r\n * See p5.Oscillator for methods.\r\n *\r\n * @class p5.SawOsc\r\n * @constructor\r\n * @extends p5.Oscillator\r\n * @param {Number} [freq] Set the frequency\r\n */\r\n p5.SawOsc = function(freq) {\r\n p5.Oscillator.call(this, freq, 'sawtooth');\r\n };\r\n\r\n p5.SawOsc.prototype = Object.create(p5.Oscillator.prototype);\r\n\r\n /**\r\n * Constructor: new p5.SqrOsc().\r\n * This creates a Square Wave Oscillator and is\r\n * equivalent to new p5.Oscillator('square')\r\n * or creating a p5.Oscillator and then calling\r\n * its method setType('square').\r\n * See p5.Oscillator for methods.\r\n *\r\n * @class p5.SqrOsc\r\n * @constructor\r\n * @extends p5.Oscillator\r\n * @param {Number} [freq] Set the frequency\r\n */\r\n p5.SqrOsc = function(freq) {\r\n p5.Oscillator.call(this, freq, 'square');\r\n };\r\n\r\n p5.SqrOsc.prototype = Object.create(p5.Oscillator.prototype);\r\n\r\n});\r\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';\r\ndefine(function (require) {\r\n\r\n var p5sound = require('master');\r\n var AudioVoice = require('audioVoice');\r\n var noteToFreq = require('helpers').noteToFreq;\r\n\r\n var DEFAULT_SUSTAIN = 0.15;\r\n\r\n /**\r\n * A MonoSynth is used as a single voice for sound synthesis.\r\n * This is a class to be used in conjunction with the PolySynth\r\n * class. Custom synthetisers should be built inheriting from\r\n * this class.\r\n *\r\n * @class p5.MonoSynth\r\n * @constructor\r\n * @example\r\n *
\r\n * let monoSynth;\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * cnv.mousePressed(playSynth);\r\n * background(220);\r\n * textAlign(CENTER);\r\n * text('tap to play', width/2, height/2);\r\n *\r\n * monoSynth = new p5.MonoSynth();\r\n * }\r\n *\r\n * function playSynth() {\r\n * userStartAudio();\r\n *\r\n * let note = random(['Fb4', 'G4']);\r\n * // note velocity (volume, from 0 to 1)\r\n * let velocity = random();\r\n * // time from now (in seconds)\r\n * let time = 0;\r\n * // note duration (in seconds)\r\n * let dur = 1/6;\r\n *\r\n * monoSynth.play(note, velocity, time, dur);\r\n * }\r\n *
\r\n **/\r\n\r\n p5.MonoSynth = function () {\r\n AudioVoice.call(this);\r\n\r\n this.oscillator = new p5.Oscillator();\r\n\r\n this.env = new p5.Envelope();\r\n this.env.setRange(1, 0);\r\n this.env.setExp(true);\r\n\r\n //set params\r\n this.setADSR(0.02, 0.25, 0.05, 0.35);\r\n\r\n // oscillator --> env --> this.output (gain) --> p5.soundOut\r\n this.oscillator.disconnect();\r\n this.oscillator.connect(this.output);\r\n\r\n this.env.disconnect();\r\n this.env.setInput(this.output.gain);\r\n\r\n // reset oscillator gain to 1.0\r\n this.oscillator.output.gain.value = 1.0;\r\n\r\n this.oscillator.start();\r\n this.connect();\r\n\r\n p5sound.soundArray.push(this);\r\n };\r\n\r\n p5.MonoSynth.prototype = Object.create(p5.AudioVoice.prototype);\r\n\r\n /**\r\n * Play tells the MonoSynth to start playing a note. This method schedules\r\n * the calling of .triggerAttack and .triggerRelease.\r\n *\r\n * @method play\r\n * @for p5.MonoSynth\r\n * @param {String | Number} note the note you want to play, specified as a\r\n * frequency in Hertz (Number) or as a midi\r\n * value in Note/Octave format (\"C4\", \"Eb3\"...etc\")\r\n * See \r\n * Tone. Defaults to 440 hz.\r\n * @param {Number} [velocity] velocity of the note to play (ranging from 0 to 1)\r\n * @param {Number} [secondsFromNow] time from now (in seconds) at which to play\r\n * @param {Number} [sustainTime] time to sustain before releasing the envelope. Defaults to 0.15 seconds.\r\n * @example\r\n *
\r\n * let monoSynth;\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * cnv.mousePressed(playSynth);\r\n * background(220);\r\n * textAlign(CENTER);\r\n * text('tap to play', width/2, height/2);\r\n *\r\n * monoSynth = new p5.MonoSynth();\r\n * }\r\n *\r\n * function playSynth() {\r\n * userStartAudio();\r\n *\r\n * let note = random(['Fb4', 'G4']);\r\n * // note velocity (volume, from 0 to 1)\r\n * let velocity = random();\r\n * // time from now (in seconds)\r\n * let time = 0;\r\n * // note duration (in seconds)\r\n * let dur = 1/6;\r\n *\r\n * monoSynth.play(note, velocity, time, dur);\r\n * }\r\n *
\r\n *\r\n */\r\n p5.MonoSynth.prototype.play = function (note, velocity, secondsFromNow, susTime) {\r\n this.triggerAttack(note, velocity, ~~secondsFromNow);\r\n this.triggerRelease(~~secondsFromNow + (susTime || DEFAULT_SUSTAIN));\r\n };\r\n\r\n /**\r\n * Trigger the Attack, and Decay portion of the Envelope.\r\n * Similar to holding down a key on a piano, but it will\r\n * hold the sustain level until you let go.\r\n *\r\n * @param {String | Number} note the note you want to play, specified as a\r\n * frequency in Hertz (Number) or as a midi\r\n * value in Note/Octave format (\"C4\", \"Eb3\"...etc\")\r\n * See \r\n * Tone. Defaults to 440 hz\r\n * @param {Number} [velocity] velocity of the note to play (ranging from 0 to 1)\r\n * @param {Number} [secondsFromNow] time from now (in seconds) at which to play\r\n * @method triggerAttack\r\n * @for p5.MonoSynth\r\n * @example\r\n *
\r\n * let monoSynth;\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * cnv.mousePressed(triggerAttack);\r\n * background(220);\r\n * text('tap here for attack, let go to release', 5, 20, width - 20);\r\n * monoSynth = new p5.MonoSynth();\r\n * }\r\n *\r\n * function triggerAttack() {\r\n * userStartAudio();\r\n *\r\n * monoSynth.triggerAttack(\"E3\");\r\n * }\r\n *\r\n * function mouseReleased() {\r\n * monoSynth.triggerRelease();\r\n * }\r\n *
\r\n */\r\n p5.MonoSynth.prototype.triggerAttack = function (note, velocity, secondsFromNow) {\r\n var secondsFromNow = ~~secondsFromNow;\r\n var freq = noteToFreq(note);\r\n var vel = velocity || 0.1;\r\n this.oscillator.freq(freq, 0, secondsFromNow);\r\n this.env.ramp(this.output.gain, secondsFromNow, vel);\r\n };\r\n\r\n /**\r\n * Trigger the release of the Envelope. This is similar to releasing\r\n * the key on a piano and letting the sound fade according to the\r\n * release level and release time.\r\n *\r\n * @param {Number} secondsFromNow time to trigger the release\r\n * @method triggerRelease\r\n * @for p5.MonoSynth\r\n * @example\r\n *
\r\n * let monoSynth;\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * cnv.mousePressed(triggerAttack);\r\n * background(220);\r\n * text('tap here for attack, let go to release', 5, 20, width - 20);\r\n * monoSynth = new p5.MonoSynth();\r\n * }\r\n *\r\n * function triggerAttack() {\r\n * userStartAudio();\r\n *\r\n * monoSynth.triggerAttack(\"E3\");\r\n * }\r\n *\r\n * function mouseReleased() {\r\n * monoSynth.triggerRelease();\r\n * }\r\n *
\r\n */\r\n p5.MonoSynth.prototype.triggerRelease = function (secondsFromNow) {\r\n var secondsFromNow = secondsFromNow || 0;\r\n this.env.ramp(this.output.gain, secondsFromNow, 0);\r\n };\r\n\r\n /**\r\n * Set values like a traditional\r\n * \r\n * ADSR envelope\r\n * .\r\n *\r\n * @method setADSR\r\n * @for p5.MonoSynth\r\n * @param {Number} attackTime Time (in seconds before envelope\r\n * reaches Attack Level\r\n * @param {Number} [decayTime] Time (in seconds) before envelope\r\n * reaches Decay/Sustain Level\r\n * @param {Number} [susRatio] Ratio between attackLevel and releaseLevel, on a scale from 0 to 1,\r\n * where 1.0 = attackLevel, 0.0 = releaseLevel.\r\n * The susRatio determines the decayLevel and the level at which the\r\n * sustain portion of the envelope will sustain.\r\n * For example, if attackLevel is 0.4, releaseLevel is 0,\r\n * and susAmt is 0.5, the decayLevel would be 0.2. If attackLevel is\r\n * increased to 1.0 (using setRange),\r\n * then decayLevel would increase proportionally, to become 0.5.\r\n * @param {Number} [releaseTime] Time in seconds from now (defaults to 0)\r\n */\r\n p5.MonoSynth.prototype.setADSR = function (attack,decay,sustain,release) {\r\n this.env.setADSR(attack, decay, sustain, release);\r\n };\r\n\r\n\r\n /**\r\n * Getters and Setters\r\n * @property {Number} attack\r\n * @for p5.MonoSynth\r\n */\r\n /**\r\n * @property {Number} decay\r\n * @for p5.MonoSynth\r\n */\r\n /**\r\n * @property {Number} sustain\r\n * @for p5.MonoSynth\r\n */\r\n /**\r\n * @property {Number} release\r\n * @for p5.MonoSynth\r\n */\r\n Object.defineProperties(p5.MonoSynth.prototype, {\r\n 'attack': {\r\n get : function() {\r\n return this.env.aTime;\r\n },\r\n set : function(attack) {\r\n this.env.setADSR(attack, this.env.dTime,\r\n this.env.sPercent, this.env.rTime);\r\n }\r\n },\r\n 'decay': {\r\n get : function() {\r\n return this.env.dTime;\r\n },\r\n set : function(decay) {\r\n this.env.setADSR(this.env.aTime, decay,\r\n this.env.sPercent, this.env.rTime);\r\n }\r\n },\r\n 'sustain': {\r\n get : function() {\r\n return this.env.sPercent;\r\n },\r\n set : function(sustain) {\r\n this.env.setADSR(this.env.aTime, this.env.dTime,\r\n sustain, this.env.rTime);\r\n }\r\n },\r\n 'release': {\r\n get : function() {\r\n return this.env.rTime;\r\n },\r\n set : function(release) {\r\n this.env.setADSR(this.env.aTime, this.env.dTime,\r\n this.env.sPercent, release);\r\n }\r\n },\r\n });\r\n\r\n\r\n /**\r\n * MonoSynth amp\r\n * @method amp\r\n * @for p5.MonoSynth\r\n * @param {Number} vol desired volume\r\n * @param {Number} [rampTime] Time to reach new volume\r\n * @return {Number} new volume value\r\n */\r\n p5.MonoSynth.prototype.amp = function(vol, rampTime) {\r\n var t = rampTime || 0;\r\n if (typeof vol !== 'undefined') {\r\n this.oscillator.amp(vol, t);\r\n }\r\n return this.oscillator.amp().value;\r\n };\r\n\r\n /**\r\n * Connect to a p5.sound / Web Audio object.\r\n *\r\n * @method connect\r\n * @for p5.MonoSynth\r\n * @param {Object} unit A p5.sound or Web Audio object\r\n */\r\n\r\n p5.MonoSynth.prototype.connect = function(unit) {\r\n var u = unit || p5sound.input;\r\n this.output.connect(u.input ? u.input : u);\r\n };\r\n\r\n /**\r\n * Disconnect all outputs\r\n *\r\n * @method disconnect\r\n * @for p5.MonoSynth\r\n */\r\n p5.MonoSynth.prototype.disconnect = function() {\r\n if (this.output) {\r\n this.output.disconnect();\r\n }\r\n };\r\n\r\n\r\n /**\r\n * Get rid of the MonoSynth and free up its resources / memory.\r\n *\r\n * @method dispose\r\n * @for p5.MonoSynth\r\n */\r\n p5.MonoSynth.prototype.dispose = function() {\r\n AudioVoice.prototype.dispose.apply(this);\r\n\r\n if (this.env) {\r\n this.env.dispose();\r\n }\r\n if (this.oscillator) {\r\n this.oscillator.dispose();\r\n }\r\n };\r\n\r\n});\r\n","'use strict';\r\ndefine(function() {\r\n var p5sound = require('master');\r\n\r\n /**\r\n * Base class for monophonic synthesizers. Any extensions of this class\r\n * should follow the API and implement the methods below in order to\r\n * remain compatible with p5.PolySynth();\r\n *\r\n * @class p5.AudioVoice\r\n * @constructor\r\n */\r\n p5.AudioVoice = function () {\r\n\t this.ac = p5sound.audiocontext;\r\n\t this.output = this.ac.createGain();\r\n\t this.connect();\r\n\t p5sound.soundArray.push(this);\r\n };\r\n\r\n p5.AudioVoice.prototype.play = function (note, velocity, secondsFromNow, sustime) {\r\n };\r\n\r\n p5.AudioVoice.prototype.triggerAttack = function (note, velocity, secondsFromNow) {\r\n };\r\n\r\n p5.AudioVoice.prototype.triggerRelease = function (secondsFromNow) {\r\n };\r\n\r\n p5.AudioVoice.prototype.amp = function(vol, rampTime) {\r\n };\r\n\r\n /**\r\n * Connect to p5 objects or Web Audio Nodes\r\n * @method connect\r\n * @for p5.AudioVoice\r\n * @param {Object} unit\r\n */\r\n p5.AudioVoice.prototype.connect = function(unit) {\r\n var u = unit || p5sound.input;\r\n this.output.connect(u.input ? u.input : u);\r\n };\r\n\r\n /**\r\n * Disconnect from soundOut\r\n * @method disconnect\r\n * @for p5.AudioVoice\r\n */\r\n p5.AudioVoice.prototype.disconnect = function() {\r\n this.output.disconnect();\r\n };\r\n\r\n p5.AudioVoice.prototype.dispose = function() {\r\n if (this.output) {\r\n this.output.disconnect();\r\n delete this.output;\r\n }\r\n };\r\n\r\n return p5.AudioVoice;\r\n});\r\n","'use strict';\r\ndefine(function (require) {\r\n\r\n var p5sound = require('master');\r\n var TimelineSignal = require('Tone/signal/TimelineSignal');\r\n var noteToFreq = require('helpers').noteToFreq;\r\n\r\n /**\r\n * An AudioVoice is used as a single voice for sound synthesis.\r\n * The PolySynth class holds an array of AudioVoice, and deals\r\n * with voices allocations, with setting notes to be played, and\r\n * parameters to be set.\r\n *\r\n * @class p5.PolySynth\r\n * @constructor\r\n *\r\n * @param {Number} [synthVoice] A monophonic synth voice inheriting\r\n * the AudioVoice class. Defaults to p5.MonoSynth\r\n * @param {Number} [maxVoices] Number of voices, defaults to 8;\r\n * @example\r\n *
\r\n * let polySynth;\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * cnv.mousePressed(playSynth);\r\n * background(220);\r\n * text('click to play', 20, 20);\r\n *\r\n * polySynth = new p5.PolySynth();\r\n * }\r\n *\r\n * function playSynth() {\r\n * userStartAudio();\r\n *\r\n * // note duration (in seconds)\r\n * let dur = 1.5;\r\n *\r\n * // time from now (in seconds)\r\n * let time = 0;\r\n *\r\n * // velocity (volume, from 0 to 1)\r\n * let vel = 0.1;\r\n *\r\n * // notes can overlap with each other\r\n * polySynth.play('G2', vel, 0, dur);\r\n * polySynth.play('C3', vel, time += 1/3, dur);\r\n * polySynth.play('G3', vel, time += 1/3, dur);\r\n * }\r\n *
\r\n **/\r\n p5.PolySynth = function(audioVoice, maxVoices) {\r\n //audiovoices will contain maxVoices many monophonic synths\r\n this.audiovoices = [];\r\n\r\n /**\r\n * An object that holds information about which notes have been played and\r\n * which notes are currently being played. New notes are added as keys\r\n * on the fly. While a note has been attacked, but not released, the value of the\r\n * key is the audiovoice which is generating that note. When notes are released,\r\n * the value of the key becomes undefined.\r\n * @property notes\r\n */\r\n this.notes = {};\r\n\r\n //indices of the most recently used, and least recently used audiovoice\r\n this._newest = 0;\r\n this._oldest = 0;\r\n\r\n /**\r\n * A PolySynth must have at least 1 voice, defaults to 8\r\n * @property polyvalue\r\n */\r\n this.maxVoices = maxVoices || 8;\r\n\r\n /**\r\n * Monosynth that generates the sound for each note that is triggered. The\r\n * p5.PolySynth defaults to using the p5.MonoSynth as its voice.\r\n * @property AudioVoice\r\n */\r\n this.AudioVoice = audioVoice === undefined ? p5.MonoSynth : audioVoice;\r\n\r\n /**\r\n * This value must only change as a note is attacked or released. Due to delay\r\n * and sustain times, Tone.TimelineSignal is required to schedule the change in value.\r\n\t * @private\r\n * @property {Tone.TimelineSignal} _voicesInUse\r\n */\r\n this._voicesInUse = new TimelineSignal(0);\r\n\r\n this.output = p5sound.audiocontext.createGain();\r\n this.connect();\r\n\r\n //Construct the appropriate number of audiovoices\r\n this._allocateVoices();\r\n p5sound.soundArray.push(this);\r\n };\r\n\r\n /**\r\n * Construct the appropriate number of audiovoices\r\n * @private\r\n * @for p5.PolySynth\r\n * @method _allocateVoices\r\n */\r\n p5.PolySynth.prototype._allocateVoices = function() {\r\n for(var i = 0; i< this.maxVoices; i++) {\r\n this.audiovoices.push(new this.AudioVoice());\r\n this.audiovoices[i].disconnect();\r\n this.audiovoices[i].connect(this.output);\r\n }\r\n };\r\n\r\n /**\r\n * Play a note by triggering noteAttack and noteRelease with sustain time\r\n *\r\n * @method play\r\n * @for p5.PolySynth\r\n * @param {Number} [note] midi note to play (ranging from 0 to 127 - 60 being a middle C)\r\n * @param {Number} [velocity] velocity of the note to play (ranging from 0 to 1)\r\n * @param {Number} [secondsFromNow] time from now (in seconds) at which to play\r\n * @param {Number} [sustainTime] time to sustain before releasing the envelope\r\n * @example\r\n *
\r\n * let polySynth;\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * cnv.mousePressed(playSynth);\r\n * background(220);\r\n * text('click to play', 20, 20);\r\n *\r\n * polySynth = new p5.PolySynth();\r\n * }\r\n *\r\n * function playSynth() {\r\n * userStartAudio();\r\n *\r\n * // note duration (in seconds)\r\n * let dur = 1.5;\r\n *\r\n * // time from now (in seconds)\r\n * let time = 0;\r\n *\r\n * // velocity (volume, from 0 to 1)\r\n * let vel = 0.1;\r\n *\r\n * // notes can overlap with each other\r\n * polySynth.play('G2', vel, 0, dur);\r\n * polySynth.play('C3', vel, time += 1/3, dur);\r\n * polySynth.play('G3', vel, time += 1/3, dur);\r\n * }\r\n *
\r\n */\r\n p5.PolySynth.prototype.play = function (note,velocity, secondsFromNow, susTime) {\r\n var susTime = susTime || 1;\r\n this.noteAttack(note, velocity, secondsFromNow);\r\n this.noteRelease(note, secondsFromNow + susTime);\r\n };\r\n\r\n\r\n /**\r\n * noteADSR sets the envelope for a specific note that has just been triggered.\r\n * Using this method modifies the envelope of whichever audiovoice is being used\r\n * to play the desired note. The envelope should be reset before noteRelease is called\r\n * in order to prevent the modified envelope from being used on other notes.\r\n *\r\n * @method noteADSR\r\n * @for p5.PolySynth\r\n * @param {Number} [note] Midi note on which ADSR should be set.\r\n * @param {Number} [attackTime] Time (in seconds before envelope\r\n * reaches Attack Level\r\n * @param {Number} [decayTime] Time (in seconds) before envelope\r\n * reaches Decay/Sustain Level\r\n * @param {Number} [susRatio] Ratio between attackLevel and releaseLevel, on a scale from 0 to 1,\r\n * where 1.0 = attackLevel, 0.0 = releaseLevel.\r\n * The susRatio determines the decayLevel and the level at which the\r\n * sustain portion of the envelope will sustain.\r\n * For example, if attackLevel is 0.4, releaseLevel is 0,\r\n * and susAmt is 0.5, the decayLevel would be 0.2. If attackLevel is\r\n * increased to 1.0 (using setRange),\r\n * then decayLevel would increase proportionally, to become 0.5.\r\n * @param {Number} [releaseTime] Time in seconds from now (defaults to 0)\r\n **/\r\n\r\n p5.PolySynth.prototype.noteADSR = function (note,a,d,s,r,timeFromNow) {\r\n var now = p5sound.audiocontext.currentTime;\r\n var timeFromNow = timeFromNow || 0;\r\n var t = now + timeFromNow\r\n this.audiovoices[ this.notes[note].getValueAtTime(t) ].setADSR(a,d,s,r);\r\n };\r\n\r\n\r\n /**\r\n * Set the PolySynths global envelope. This method modifies the envelopes of each\r\n * monosynth so that all notes are played with this envelope.\r\n *\r\n * @method setADSR\r\n * @for p5.PolySynth\r\n * @param {Number} [attackTime] Time (in seconds before envelope\r\n * reaches Attack Level\r\n * @param {Number} [decayTime] Time (in seconds) before envelope\r\n * reaches Decay/Sustain Level\r\n * @param {Number} [susRatio] Ratio between attackLevel and releaseLevel, on a scale from 0 to 1,\r\n * where 1.0 = attackLevel, 0.0 = releaseLevel.\r\n * The susRatio determines the decayLevel and the level at which the\r\n * sustain portion of the envelope will sustain.\r\n * For example, if attackLevel is 0.4, releaseLevel is 0,\r\n * and susAmt is 0.5, the decayLevel would be 0.2. If attackLevel is\r\n * increased to 1.0 (using setRange),\r\n * then decayLevel would increase proportionally, to become 0.5.\r\n * @param {Number} [releaseTime] Time in seconds from now (defaults to 0)\r\n **/\r\n p5.PolySynth.prototype.setADSR = function(a,d,s,r) {\r\n this.audiovoices.forEach(function(voice) {\r\n voice.setADSR(a,d,s,r);\r\n });\r\n };\r\n\r\n /**\r\n * Trigger the Attack, and Decay portion of a MonoSynth.\r\n * Similar to holding down a key on a piano, but it will\r\n * hold the sustain level until you let go.\r\n *\r\n * @method noteAttack\r\n * @for p5.PolySynth\r\n * @param {Number} [note] midi note on which attack should be triggered.\r\n * @param {Number} [velocity] velocity of the note to play (ranging from 0 to 1)/\r\n * @param {Number} [secondsFromNow] time from now (in seconds)\r\n * @example\r\n *
\r\n * let polySynth = new p5.PolySynth();\r\n * let pitches = ['G', 'D', 'G', 'C'];\r\n * let octaves = [2, 3, 4];\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * cnv.mousePressed(playChord);\r\n * background(220);\r\n * text('tap to play', 20, 20);\r\n * }\r\n *\r\n * function playChord() {\r\n * userStartAudio();\r\n *\r\n * // play a chord: multiple notes at the same time\r\n * for (let i = 0; i < 4; i++) {\r\n * let note = random(pitches) + random(octaves);\r\n * polySynth.noteAttack(note, 0.1);\r\n * }\r\n * }\r\n *\r\n * function mouseReleased() {\r\n * // release all voices\r\n * polySynth.noteRelease();\r\n * }\r\n *
\r\n */\r\n p5.PolySynth.prototype.noteAttack = function (_note, _velocity, secondsFromNow) {\r\n //this value goes to the audiovoices which handle their own scheduling\r\n var secondsFromNow = ~~secondsFromNow;\r\n\r\n //this value is used by this._voicesInUse\r\n var acTime = p5sound.audiocontext.currentTime + secondsFromNow;\r\n\r\n //Convert note to frequency if necessary. This is because entries into this.notes\r\n //should be based on frequency for the sake of consistency.\r\n var note = noteToFreq(_note);\r\n var velocity = _velocity || 0.1;\r\n\r\n var currentVoice;\r\n\r\n //Release the note if it is already playing\r\n if (this.notes[note] && this.notes[note].getValueAtTime(acTime) !== null) {\r\n this.noteRelease(note, 0);\r\n }\r\n\r\n //Check to see how many voices are in use at the time the note will start\r\n if (this._voicesInUse.getValueAtTime(acTime) < this.maxVoices) {\r\n currentVoice = Math.max(~~this._voicesInUse.getValueAtTime(acTime), 0);\r\n }\r\n //If we are exceeding the polyvalue, bump off the oldest notes and replace\r\n //with a new note\r\n else {\r\n currentVoice = this._oldest;\r\n\r\n var oldestNote = p5.prototype.freqToMidi(this.audiovoices[this._oldest].oscillator.freq().value);\r\n this.noteRelease(oldestNote);\r\n this._oldest = ( this._oldest + 1 ) % (this.maxVoices - 1);\r\n }\r\n\r\n //Overrite the entry in the notes object. A note (frequency value)\r\n //corresponds to the index of the audiovoice that is playing it\r\n this.notes[note] = new TimelineSignal();\r\n this.notes[note].setValueAtTime(currentVoice, acTime);\r\n\r\n //Find the scheduled change in this._voicesInUse that will be previous to this new note\r\n //Add 1 and schedule this value at time 't', when this note will start playing\r\n var previousVal = this._voicesInUse._searchBefore(acTime) === null ? 0 : this._voicesInUse._searchBefore(acTime).value;\r\n this._voicesInUse.setValueAtTime(previousVal + 1, acTime);\r\n\r\n //Then update all scheduled values that follow to increase by 1\r\n this._updateAfter(acTime, 1);\r\n\r\n this._newest = currentVoice;\r\n //The audiovoice handles the actual scheduling of the note\r\n if (typeof velocity === 'number') {\r\n var maxRange = 1 / this._voicesInUse.getValueAtTime(acTime) * 2;\r\n velocity = velocity > maxRange ? maxRange : velocity;\r\n }\r\n this.audiovoices[currentVoice].triggerAttack(note, velocity, secondsFromNow);\r\n };\r\n\r\n /**\r\n * Private method to ensure accurate values of this._voicesInUse\r\n * Any time a new value is scheduled, it is necessary to increment all subsequent\r\n * scheduledValues after attack, and decrement all subsequent\r\n * scheduledValues after release\r\n *\r\n * @private\r\n * @for p5.PolySynth\r\n * @param {[type]} time [description]\r\n * @param {[type]} value [description]\r\n * @return {[type]} [description]\r\n */\r\n p5.PolySynth.prototype._updateAfter = function(time, value) {\r\n if(this._voicesInUse._searchAfter(time) === null) {\r\n return;\r\n } else{\r\n this._voicesInUse._searchAfter(time).value += value;\r\n var nextTime = this._voicesInUse._searchAfter(time).time;\r\n this._updateAfter(nextTime, value);\r\n }\r\n };\r\n\r\n\r\n /**\r\n * Trigger the Release of an AudioVoice note. This is similar to releasing\r\n * the key on a piano and letting the sound fade according to the\r\n * release level and release time.\r\n *\r\n * @method noteRelease\r\n * @for p5.PolySynth\r\n * @param {Number} [note] midi note on which attack should be triggered.\r\n * If no value is provided, all notes will be released.\r\n * @param {Number} [secondsFromNow] time to trigger the release\r\n * @example\r\n *
\r\n * let polySynth = new p5.PolySynth();\r\n * let pitches = ['G', 'D', 'G', 'C'];\r\n * let octaves = [2, 3, 4];\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * cnv.mousePressed(playChord);\r\n * background(220);\r\n * text('tap to play', 20, 20);\r\n * }\r\n *\r\n * function playChord() {\r\n * userStartAudio();\r\n *\r\n * // play a chord: multiple notes at the same time\r\n * for (let i = 0; i < 4; i++) {\r\n * let note = random(pitches) + random(octaves);\r\n * polySynth.noteAttack(note, 0.1);\r\n * }\r\n * }\r\n *\r\n * function mouseReleased() {\r\n * // release all voices\r\n * polySynth.noteRelease();\r\n * }\r\n *
\r\n *\r\n */\r\n p5.PolySynth.prototype.noteRelease = function (_note,secondsFromNow) {\r\n var now = p5sound.audiocontext.currentTime;\r\n var tFromNow = secondsFromNow || 0;\r\n var t = now + tFromNow;\r\n\r\n // if a note value is not provided, release all voices\r\n if (!_note) {\r\n this.audiovoices.forEach(function(voice) {\r\n voice.triggerRelease(tFromNow)\r\n });\r\n this._voicesInUse.setValueAtTime(0, t);\r\n for (var n in this.notes) {\r\n this.notes[n].dispose();\r\n delete this.notes[n];\r\n }\r\n return;\r\n }\r\n\r\n //Make sure note is in frequency inorder to query the this.notes object\r\n var note = noteToFreq(_note);\r\n\r\n if (!this.notes[note] || this.notes[note].getValueAtTime(t) === null) {\r\n console.warn('Cannot release a note that is not already playing');\r\n } else {\r\n //Find the scheduled change in this._voicesInUse that will be previous to this new note\r\n //subtract 1 and schedule this value at time 't', when this note will stop playing\r\n var previousVal = Math.max(~~this._voicesInUse.getValueAtTime(t).value, 1);\r\n this._voicesInUse.setValueAtTime(previousVal - 1, t);\r\n //Then update all scheduled values that follow to decrease by 1 but never go below 0\r\n if (previousVal > 0) {\r\n this._updateAfter(t, -1);\r\n }\r\n\r\n this.audiovoices[ this.notes[note].getValueAtTime(t) ].triggerRelease(tFromNow);\r\n this.notes[note].dispose();\r\n delete this.notes[note];\r\n\r\n this._newest = this._newest === 0 ? 0 : (this._newest - 1) % (this.maxVoices - 1);\r\n }\r\n\r\n };\r\n\r\n /**\r\n * Connect to a p5.sound / Web Audio object.\r\n *\r\n * @method connect\r\n * @for p5.PolySynth\r\n * @param {Object} unit A p5.sound or Web Audio object\r\n */\r\n p5.PolySynth.prototype.connect = function (unit) {\r\n var u = unit || p5sound.input;\r\n this.output.connect(u.input ? u.input : u);\r\n };\r\n\r\n /**\r\n * Disconnect all outputs\r\n *\r\n * @method disconnect\r\n * @for p5.PolySynth\r\n */\r\n p5.PolySynth.prototype.disconnect = function() {\r\n if (this.output) {\r\n this.output.disconnect();\r\n }\r\n };\r\n\r\n /**\r\n * Get rid of the MonoSynth and free up its resources / memory.\r\n *\r\n * @method dispose\r\n * @for p5.PolySynth\r\n */\r\n p5.PolySynth.prototype.dispose = function() {\r\n this.audiovoices.forEach(function(voice) {\r\n voice.dispose();\r\n });\r\n\r\n if (this.output) {\r\n this.output.disconnect();\r\n delete this.output;\r\n }\r\n };\r\n\r\n});\r\n","'use strict';\r\n\r\ndefine(function (require) {\r\n\r\n require('audioworklet-polyfill');\r\n require('shims');\r\n require('audiocontext');\r\n var p5SOUND = require('master');\r\n require('helpers');\r\n require('errorHandler');\r\n require('audioWorklet');\r\n require('panner');\r\n require('soundfile');\r\n require('amplitude');\r\n require('fft');\r\n require('signal');\r\n require('oscillator');\r\n require('envelope');\r\n require('pulse');\r\n require('noise');\r\n require('audioin');\r\n require('filter');\r\n require('eq');\r\n require('panner3d');\r\n require('listener3d');\r\n require('delay');\r\n require('reverb');\r\n require('metro');\r\n require('looper');\r\n require('soundLoop');\r\n require('compressor');\r\n require('soundRecorder');\r\n require('peakDetect');\r\n require('gain');\r\n require('monosynth');\r\n require('polysynth');\r\n require('distortion');\r\n require('audioVoice');\r\n require('monosynth');\r\n require('polysynth');\r\n\r\n return p5SOUND;\r\n\r\n});\r\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';\r\n\r\ndefine(function (require) {\r\n\r\n var p5sound = require('master');\r\n var ac = p5sound.audiocontext;\r\n\r\n // Stereo panner\r\n // if there is a stereo panner node use it\r\n if(typeof ac.createStereoPanner !== 'undefined') {\r\n p5.Panner = function (input, output) {\r\n this.stereoPanner = this.input = ac.createStereoPanner();\r\n input.connect(this.stereoPanner);\r\n this.stereoPanner.connect(output);\r\n };\r\n\r\n p5.Panner.prototype.pan = function(val, tFromNow) {\r\n var time = tFromNow || 0;\r\n var t = ac.currentTime + time;\r\n\r\n this.stereoPanner.pan.linearRampToValueAtTime(val, t);\r\n };\r\n\r\n //not implemented because stereopanner\r\n //node does not require this and will automatically\r\n //convert single channel or multichannel to stereo.\r\n //tested with single and stereo, not with (>2) multichannel\r\n p5.Panner.prototype.inputChannels = function() {};\r\n\r\n p5.Panner.prototype.connect = function(obj) {\r\n this.stereoPanner.connect(obj);\r\n };\r\n\r\n p5.Panner.prototype.disconnect = function() {\r\n if (this.stereoPanner) {\r\n this.stereoPanner.disconnect();\r\n }\r\n };\r\n\r\n } else {\r\n // if there is no createStereoPanner object\r\n // such as in safari 7.1.7 at the time of writing this\r\n // use this method to create the effect\r\n p5.Panner = function(input, output, numInputChannels) {\r\n this.input = ac.createGain();\r\n input.connect(this.input);\r\n\r\n this.left = ac.createGain();\r\n this.right = ac.createGain();\r\n this.left.channelInterpretation = 'discrete';\r\n this.right.channelInterpretation = 'discrete';\r\n\r\n // if input is stereo\r\n if (numInputChannels > 1) {\r\n this.splitter = ac.createChannelSplitter(2);\r\n this.input.connect(this.splitter);\r\n\r\n this.splitter.connect(this.left, 1);\r\n this.splitter.connect(this.right, 0);\r\n }\r\n else {\r\n this.input.connect(this.left);\r\n this.input.connect(this.right);\r\n }\r\n\r\n this.output = ac.createChannelMerger(2);\r\n this.left.connect(this.output, 0, 1);\r\n this.right.connect(this.output, 0, 0);\r\n this.output.connect(output);\r\n };\r\n\r\n // -1 is left, +1 is right\r\n p5.Panner.prototype.pan = function(val, tFromNow) {\r\n var time = tFromNow || 0;\r\n var t = ac.currentTime + time;\r\n var v = (val + 1) / 2;\r\n var rightVal = Math.cos(v*Math.PI/2);\r\n var leftVal = Math.sin(v * Math.PI/2);\r\n this.left.gain.linearRampToValueAtTime(leftVal, t);\r\n this.right.gain.linearRampToValueAtTime(rightVal, t);\r\n };\r\n\r\n p5.Panner.prototype.inputChannels = function(numChannels) {\r\n if (numChannels === 1) {\r\n this.input.disconnect();\r\n this.input.connect(this.left);\r\n this.input.connect(this.right);\r\n } else if (numChannels === 2) {\r\n if (typeof(this.splitter === 'undefined')) {\r\n this.splitter = ac.createChannelSplitter(2);\r\n }\r\n this.input.disconnect();\r\n this.input.connect(this.splitter);\r\n this.splitter.connect(this.left, 1);\r\n this.splitter.connect(this.right, 0);\r\n }\r\n };\r\n\r\n p5.Panner.prototype.connect = function(obj) {\r\n this.output.connect(obj);\r\n };\r\n\r\n p5.Panner.prototype.disconnect = function() {\r\n if (this.output) {\r\n this.output.disconnect();\r\n }\r\n };\r\n }\r\n});\r\n","'use strict';\r\n\r\ndefine(function (require) {\r\n\r\n const CustomError = require('errorHandler');\r\n const p5sound = require('master');\r\n const ac = p5sound.audiocontext;\r\n const { midiToFreq, convertToWav, safeBufferSize } = require('helpers');\r\n var processorNames = require('./audioWorklet/processorNames');\r\n\r\n /**\r\n *

SoundFile object with a path to a file.

\r\n *\r\n *

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

\r\n *\r\n *

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

\r\n *\r\n *

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

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

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

\r\n *\r\n *

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

\r\n *\r\n *

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

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

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

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

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

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

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

\r\n *\r\n *

This is necessary because Web Audio is processed on a seprate clock.\r\n * For example, the p5 draw loop runs about 60 times per second. But\r\n * the audio clock must process samples 44100 times per second. If we\r\n * want to add a value to each of those samples, we can't do it in the\r\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\r\n * a Tone.Signal from the Tone.js library by Yotam Mann.\r\n * If you want to work directly with audio signals for modular\r\n * synthesis, check out\r\n * tone.js.

\r\n *\r\n * @class p5.Signal\r\n * @constructor\r\n * @return {Tone.Signal} A Signal object from the Tone.js library\r\n * @example\r\n *
\r\n * let carrier, modulator;\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * cnv.mousePressed(canvasPressed);\r\n * background(220);\r\n * text('tap to play', 20, 20);\r\n *\r\n * carrier = new p5.Oscillator('sine');\r\n * carrier.start();\r\n * carrier.amp(1); // set amplitude\r\n * carrier.freq(220); // set frequency\r\n *\r\n * modulator = new p5.Oscillator('sawtooth');\r\n * modulator.disconnect();\r\n * modulator.start();\r\n * modulator.amp(1);\r\n * modulator.freq(4);\r\n *\r\n * // Modulator's default amplitude range is -1 to 1.\r\n * // Multiply it by -200, so the range is -200 to 200\r\n * // then add 220 so the range is 20 to 420\r\n * carrier.freq( modulator.mult(-400).add(220) );\r\n * }\r\n *\r\n * function canvasPressed() {\r\n * userStartAudio();\r\n * carrier.amp(1.0);\r\n * }\r\n *\r\n * function mouseReleased() {\r\n * carrier.amp(0);\r\n * }\r\n *
\r\n */\r\n p5.Signal = function(value) {\r\n var s = new Signal(value);\r\n // p5sound.soundArray.push(s);\r\n return s; // TODO: is this really a constructor?\r\n };\r\n\r\n /**\r\n * Fade to value, for smooth transitions\r\n *\r\n * @method fade\r\n * @for p5.Signal\r\n * @param {Number} value Value to set this signal\r\n * @param {Number} [secondsFromNow] Length of fade, in seconds from now\r\n */\r\n Signal.prototype.fade = Signal.prototype.linearRampToValueAtTime;\r\n Mult.prototype.fade = Signal.prototype.fade;\r\n Add.prototype.fade = Signal.prototype.fade;\r\n Scale.prototype.fade = Signal.prototype.fade;\r\n\r\n\r\n /**\r\n * Connect a p5.sound object or Web Audio node to this\r\n * p5.Signal so that its amplitude values can be scaled.\r\n *\r\n * @method setInput\r\n * @for p5.Signal\r\n * @param {Object} input\r\n */\r\n Signal.prototype.setInput = function(_input) {\r\n _input.connect(this);\r\n };\r\n Mult.prototype.setInput = Signal.prototype.setInput;\r\n Add.prototype.setInput = Signal.prototype.setInput;\r\n Scale.prototype.setInput = Signal.prototype.setInput;\r\n\r\n\r\n // signals can add / mult / scale themselves\r\n\r\n /**\r\n * Add a constant value to this audio signal,\r\n * and return the resulting audio signal. Does\r\n * not change the value of the original signal,\r\n * instead it returns a new p5.SignalAdd.\r\n *\r\n * @method add\r\n * @for p5.Signal\r\n * @param {Number} number\r\n * @return {p5.Signal} object\r\n */\r\n Signal.prototype.add = function(num) {\r\n var add = new Add(num);\r\n // add.setInput(this);\r\n this.connect(add);\r\n return add;\r\n };\r\n Mult.prototype.add = Signal.prototype.add;\r\n Add.prototype.add = Signal.prototype.add;\r\n Scale.prototype.add = Signal.prototype.add;\r\n\r\n /**\r\n * Multiply this signal by a constant value,\r\n * and return the resulting audio signal. Does\r\n * not change the value of the original signal,\r\n * instead it returns a new p5.SignalMult.\r\n *\r\n * @method mult\r\n * @for p5.Signal\r\n * @param {Number} number to multiply\r\n * @return {p5.Signal} object\r\n */\r\n Signal.prototype.mult = function(num) {\r\n var mult = new Mult(num);\r\n // mult.setInput(this);\r\n this.connect(mult);\r\n return mult;\r\n };\r\n Mult.prototype.mult = Signal.prototype.mult;\r\n Add.prototype.mult = Signal.prototype.mult;\r\n Scale.prototype.mult = Signal.prototype.mult;\r\n\r\n /**\r\n * Scale this signal value to a given range,\r\n * and return the result as an audio signal. Does\r\n * not change the value of the original signal,\r\n * instead it returns a new p5.SignalScale.\r\n *\r\n * @method scale\r\n * @for p5.Signal\r\n * @param {Number} number to multiply\r\n * @param {Number} inMin input range minumum\r\n * @param {Number} inMax input range maximum\r\n * @param {Number} outMin input range minumum\r\n * @param {Number} outMax input range maximum\r\n * @return {p5.Signal} object\r\n */\r\n Signal.prototype.scale = function(inMin, inMax, outMin, outMax) {\r\n var mapOutMin, mapOutMax;\r\n if (arguments.length === 4) {\r\n mapOutMin = p5.prototype.map(outMin, inMin, inMax, 0, 1) - 0.5;\r\n mapOutMax = p5.prototype.map(outMax, inMin, inMax, 0, 1) - 0.5;\r\n }\r\n else {\r\n mapOutMin = arguments[0];\r\n mapOutMax = arguments[1];\r\n }\r\n var scale = new Scale(mapOutMin, mapOutMax);\r\n this.connect(scale);\r\n return scale;\r\n };\r\n Mult.prototype.scale = Signal.prototype.scale;\r\n Add.prototype.scale = Signal.prototype.scale;\r\n Scale.prototype.scale = Signal.prototype.scale;\r\n\r\n});\r\n\r\n\r\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';\r\n\r\ndefine(function (require) {\r\n\r\n var p5sound = require('master');\r\n var Add = require('Tone/signal/Add');\r\n var Mult = require('Tone/signal/Multiply');\r\n var Scale = require('Tone/signal/Scale');\r\n var TimelineSignal = require('Tone/signal/TimelineSignal');\r\n\r\n /**\r\n *

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

\r\n *

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

\r\n *

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

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

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

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

\r\n *\r\n *

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

\r\n *\r\n *

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

\r\n *\r\n *

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

\r\n *\r\n * @class p5.AudioIn\r\n * @constructor\r\n * @param {Function} [errorCallback] A function to call if there is an error\r\n * accessing the AudioIn. For example,\r\n * Safari and iOS devices do not\r\n * currently allow microphone access.\r\n * @example\r\n *
\r\n * let mic;\r\n *\r\n * function setup(){\r\n * let cnv = createCanvas(100, 100);\r\n * cnv.mousePressed(userStartAudio);\r\n * textAlign(CENTER);\r\n * mic = new p5.AudioIn();\r\n * mic.start();\r\n * }\r\n *\r\n * function draw(){\r\n * background(0);\r\n * fill(255);\r\n * text('tap to start', width/2, 20);\r\n *\r\n * micLevel = mic.getLevel();\r\n * let y = height - micLevel * height;\r\n * ellipse(width/2, y, 10, 10);\r\n * }\r\n *
\r\n */\r\n p5.AudioIn = function(errorCallback) {\r\n // set up audio input\r\n /**\r\n * @property {GainNode} input\r\n */\r\n this.input = p5sound.audiocontext.createGain();\r\n /**\r\n * @property {GainNode} output\r\n */\r\n this.output = p5sound.audiocontext.createGain();\r\n\r\n /**\r\n * @property {MediaStream|null} stream\r\n */\r\n this.stream = null;\r\n /**\r\n * @property {MediaStreamAudioSourceNode|null} mediaStream\r\n */\r\n this.mediaStream = null;\r\n /**\r\n * @property {Number|null} currentSource\r\n */\r\n this.currentSource = null;\r\n\r\n /**\r\n * Client must allow browser to access their microphone / audioin source.\r\n * Default: false. Will become true when the client enables access.\r\n *\r\n * @property {Boolean} enabled\r\n */\r\n this.enabled = false;\r\n\r\n /**\r\n * Input amplitude, connect to it by default but not to master out\r\n *\r\n * @property {p5.Amplitude} amplitude\r\n */\r\n this.amplitude = new p5.Amplitude();\r\n this.output.connect(this.amplitude.input);\r\n\r\n if (!window.MediaStreamTrack || !window.navigator.mediaDevices || !window.navigator.mediaDevices.getUserMedia) {\r\n errorCallback ? errorCallback() : window.alert('This browser does not support MediaStreamTrack and mediaDevices');\r\n }\r\n\r\n // add to soundArray so we can dispose on close\r\n p5sound.soundArray.push(this);\r\n };\r\n\r\n /**\r\n * Start processing audio input. This enables the use of other\r\n * AudioIn methods like getLevel(). Note that by default, AudioIn\r\n * is not connected to p5.sound's output. So you won't hear\r\n * anything unless you use the connect() method.
\r\n *\r\n * Certain browsers limit access to the user's microphone. For example,\r\n * Chrome only allows access from localhost and over https. For this reason,\r\n * you may want to include an errorCallback—a function that is called in case\r\n * the browser won't provide mic access.\r\n *\r\n * @method start\r\n * @for p5.AudioIn\r\n * @param {Function} [successCallback] Name of a function to call on\r\n * success.\r\n * @param {Function} [errorCallback] Name of a function to call if\r\n * there was an error. For example,\r\n * some browsers do not support\r\n * getUserMedia.\r\n */\r\n p5.AudioIn.prototype.start = function(successCallback, errorCallback) {\r\n var self = this;\r\n\r\n if (this.stream) {\r\n this.stop();\r\n }\r\n\r\n // set the audio source\r\n var audioSource = p5sound.inputSources[self.currentSource];\r\n var constraints = {\r\n audio: {\r\n sampleRate: p5sound.audiocontext.sampleRate,\r\n echoCancellation: false\r\n }\r\n };\r\n\r\n // if developers determine which source to use\r\n if (p5sound.inputSources[this.currentSource]) {\r\n constraints.audio.deviceId = audioSource.deviceId;\r\n }\r\n\r\n window.navigator.mediaDevices.getUserMedia( constraints )\r\n .then( function(stream) {\r\n self.stream = stream;\r\n self.enabled = true;\r\n // Wrap a MediaStreamSourceNode around the live input\r\n self.mediaStream = p5sound.audiocontext.createMediaStreamSource(stream);\r\n self.mediaStream.connect(self.output);\r\n // only send to the Amplitude reader, so we can see it but not hear it.\r\n self.amplitude.setInput(self.output);\r\n if (successCallback) successCallback();\r\n })\r\n .catch( function(err) {\r\n if (errorCallback) errorCallback(err);\r\n else console.error(err);\r\n });\r\n };\r\n\r\n /**\r\n * Turn the AudioIn off. If the AudioIn is stopped, it cannot getLevel().\r\n * If re-starting, the user may be prompted for permission access.\r\n *\r\n * @method stop\r\n * @for p5.AudioIn\r\n */\r\n p5.AudioIn.prototype.stop = function() {\r\n if (this.stream) {\r\n this.stream.getTracks().forEach(function(track) {\r\n track.stop();\r\n });\r\n\r\n this.mediaStream.disconnect();\r\n\r\n delete this.mediaStream;\r\n delete this.stream;\r\n }\r\n };\r\n\r\n /**\r\n * Connect to an audio unit. If no parameter is provided, will\r\n * connect to the master output (i.e. your speakers).
\r\n *\r\n * @method connect\r\n * @for p5.AudioIn\r\n * @param {Object} [unit] An object that accepts audio input,\r\n * such as an FFT\r\n */\r\n p5.AudioIn.prototype.connect = function(unit) {\r\n if (unit) {\r\n if (unit.hasOwnProperty('input')) {\r\n this.output.connect(unit.input);\r\n }\r\n else if (unit.hasOwnProperty('analyser')) {\r\n this.output.connect(unit.analyser);\r\n }\r\n else {\r\n this.output.connect(unit);\r\n }\r\n }\r\n else {\r\n this.output.connect(p5sound.input);\r\n }\r\n };\r\n\r\n /**\r\n * Disconnect the AudioIn from all audio units. For example, if\r\n * connect() had been called, disconnect() will stop sending\r\n * signal to your speakers.
\r\n *\r\n * @method disconnect\r\n * @for p5.AudioIn\r\n */\r\n p5.AudioIn.prototype.disconnect = function() {\r\n if (this.output) {\r\n this.output.disconnect();\r\n // stay connected to amplitude even if not outputting to p5\r\n this.output.connect(this.amplitude.input);\r\n }\r\n };\r\n\r\n /**\r\n * Read the Amplitude (volume level) of an AudioIn. The AudioIn\r\n * class contains its own instance of the Amplitude class to help\r\n * make it easy to get a microphone's volume level. Accepts an\r\n * optional smoothing value (0.0 < 1.0). NOTE: AudioIn must\r\n * .start() before using .getLevel().
\r\n *\r\n * @method getLevel\r\n * @for p5.AudioIn\r\n * @param {Number} [smoothing] Smoothing is 0.0 by default.\r\n * Smooths values based on previous values.\r\n * @return {Number} Volume level (between 0.0 and 1.0)\r\n */\r\n p5.AudioIn.prototype.getLevel = function(smoothing) {\r\n if (smoothing) {\r\n this.amplitude.smoothing = smoothing;\r\n }\r\n return this.amplitude.getLevel();\r\n };\r\n\r\n /**\r\n * Set amplitude (volume) of a mic input between 0 and 1.0.
\r\n *\r\n * @method amp\r\n * @for p5.AudioIn\r\n * @param {Number} vol between 0 and 1.0\r\n * @param {Number} [time] ramp time (optional)\r\n */\r\n p5.AudioIn.prototype.amp = function(vol, t) {\r\n if (t) {\r\n var rampTime = t || 0;\r\n var currentVol = this.output.gain.value;\r\n this.output.gain.cancelScheduledValues(p5sound.audiocontext.currentTime);\r\n this.output.gain.setValueAtTime(currentVol, p5sound.audiocontext.currentTime);\r\n this.output.gain.linearRampToValueAtTime(vol, rampTime + p5sound.audiocontext.currentTime);\r\n } else {\r\n this.output.gain.cancelScheduledValues(p5sound.audiocontext.currentTime);\r\n this.output.gain.setValueAtTime(vol, p5sound.audiocontext.currentTime);\r\n }\r\n };\r\n\r\n /**\r\n * Returns a list of available input sources. This is a wrapper\r\n * for and it returns a Promise.\r\n *\r\n * @method getSources\r\n * @for p5.AudioIn\r\n * @param {Function} [successCallback] This callback function handles the sources when they\r\n * have been enumerated. The callback function\r\n * receives the deviceList array as its only argument\r\n * @param {Function} [errorCallback] This optional callback receives the error\r\n * message as its argument.\r\n * @returns {Promise} Returns a Promise that can be used in place of the callbacks, similar\r\n * to the enumerateDevices() method\r\n * @example\r\n *
\r\n * let audioIn;\r\n *\r\n * function setup(){\r\n * text('getting sources...', 0, 20);\r\n * audioIn = new p5.AudioIn();\r\n * audioIn.getSources(gotSources);\r\n * }\r\n *\r\n * function gotSources(deviceList) {\r\n * if (deviceList.length > 0) {\r\n * //set the source to the first item in the deviceList array\r\n * audioIn.setSource(0);\r\n * let currentSource = deviceList[audioIn.currentSource];\r\n * text('set source to: ' + currentSource.deviceId, 5, 20, width);\r\n * }\r\n * }\r\n *
\r\n */\r\n p5.AudioIn.prototype.getSources = function (onSuccess, onError) {\r\n return new Promise( function(resolve, reject) {\r\n window.navigator.mediaDevices.enumerateDevices()\r\n .then( function(devices) {\r\n p5sound.inputSources = devices.filter(function(device) {\r\n return device.kind === 'audioinput';\r\n });\r\n resolve(p5sound.inputSources);\r\n if (onSuccess) {\r\n onSuccess(p5sound.inputSources);\r\n }\r\n })\r\n .catch( function(error) {\r\n reject(error);\r\n if (onError) {\r\n onError(error);\r\n } else {\r\n console.error('This browser does not support MediaStreamTrack.getSources()');\r\n }\r\n });\r\n });\r\n };\r\n\r\n /**\r\n * Set the input source. Accepts a number representing a\r\n * position in the array returned by getSources().\r\n * This is only available in browsers that support\r\n * navigator.mediaDevices.enumerateDevices().
\r\n *\r\n * @method setSource\r\n * @for p5.AudioIn\r\n * @param {number} num position of input source in the array\r\n * @example\r\n *
\r\n * let audioIn;\r\n *\r\n * function setup(){\r\n * text('getting sources...', 0, 20);\r\n * audioIn = new p5.AudioIn();\r\n * audioIn.getSources(gotSources);\r\n * }\r\n *\r\n * function gotSources(deviceList) {\r\n * if (deviceList.length > 0) {\r\n * //set the source to the first item in the deviceList array\r\n * audioIn.setSource(0);\r\n * let currentSource = deviceList[audioIn.currentSource];\r\n * text('set source to: ' + currentSource.deviceId, 5, 20, width);\r\n * }\r\n * }\r\n *
\r\n */\r\n p5.AudioIn.prototype.setSource = function(num) {\r\n if (p5sound.inputSources.length > 0 && num < p5sound.inputSources.length) {\r\n // set the current source\r\n this.currentSource = num;\r\n console.log('set source to ', p5sound.inputSources[this.currentSource]);\r\n } else {\r\n console.log('unable to set input source');\r\n }\r\n\r\n // restart stream if currently active\r\n if (this.stream && this.stream.active) {\r\n this.start();\r\n }\r\n };\r\n\r\n // private method\r\n p5.AudioIn.prototype.dispose = function() {\r\n // remove reference from soundArray\r\n var index = p5sound.soundArray.indexOf(this);\r\n p5sound.soundArray.splice(index, 1);\r\n\r\n this.stop();\r\n\r\n if (this.output) {\r\n this.output.disconnect();\r\n }\r\n if (this.amplitude) {\r\n this.amplitude.disconnect();\r\n }\r\n delete this.amplitude;\r\n delete this.output;\r\n };\r\n\r\n});\r\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';\r\n\r\ndefine(function (require) {\r\n\r\n var Effect = require('effect');\r\n var EQFilter = require('eqFilter');\r\n\r\n /**\r\n * p5.EQ is an audio effect that performs the function of a multiband\r\n * audio equalizer. Equalization is used to adjust the balance of\r\n * frequency compoenents of an audio signal. This process is commonly used\r\n * in sound production and recording to change the waveform before it reaches\r\n * a sound output device. EQ can also be used as an audio effect to create\r\n * interesting distortions by filtering out parts of the spectrum. p5.EQ is\r\n * built using a chain of Web Audio Biquad Filter Nodes and can be\r\n * instantiated with 3 or 8 bands. Bands can be added or removed from\r\n * the EQ by directly modifying p5.EQ.bands (the array that stores filters).\r\n *\r\n * This class extends p5.Effect.\r\n * Methods amp(), chain(),\r\n * drywet(), connect(), and\r\n * disconnect() are available.\r\n *\r\n * @class p5.EQ\r\n * @constructor\r\n * @extends p5.Effect\r\n * @param {Number} [_eqsize] Constructor will accept 3 or 8, defaults to 3\r\n * @return {Object} p5.EQ object\r\n *\r\n * @example\r\n *
\r\n * let eq, soundFile\r\n * let eqBandIndex = 0;\r\n * let eqBandNames = ['lows', 'mids', 'highs'];\r\n *\r\n * function preload() {\r\n * soundFormats('mp3', 'ogg');\r\n * soundFile = loadSound('assets/beat');\r\n * }\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * cnv.mousePressed(toggleSound);\r\n *\r\n * eq = new p5.EQ(eqBandNames.length);\r\n * soundFile.disconnect();\r\n * eq.process(soundFile);\r\n * }\r\n *\r\n * function draw() {\r\n * background(30);\r\n * noStroke();\r\n * fill(255);\r\n * textAlign(CENTER);\r\n * text('filtering ', 50, 25);\r\n *\r\n * fill(255, 40, 255);\r\n * textSize(26);\r\n * text(eqBandNames[eqBandIndex], 50, 55);\r\n *\r\n * fill(255);\r\n * textSize(9);\r\n *\r\n * if (!soundFile.isPlaying()) {\r\n * text('tap to play', 50, 80);\r\n * } else {\r\n * text('tap to filter next band', 50, 80)\r\n * }\r\n * }\r\n *\r\n * function toggleSound() {\r\n * if (!soundFile.isPlaying()) {\r\n * soundFile.play();\r\n * } else {\r\n * eqBandIndex = (eqBandIndex + 1) % eq.bands.length;\r\n * }\r\n *\r\n * for (let i = 0; i < eq.bands.length; i++) {\r\n * eq.bands[i].gain(0);\r\n * }\r\n * // filter the band we want to filter\r\n * eq.bands[eqBandIndex].gain(-40);\r\n * }\r\n *
\r\n */\r\n p5.EQ = function(_eqsize) {\r\n Effect.call(this);\r\n\r\n //p5.EQ can be of size (3) or (8), defaults to 3\r\n _eqsize = _eqsize === 3 || _eqsize === 8 ? _eqsize : 3;\r\n\r\n var factor;\r\n _eqsize === 3 ? factor = Math.pow(2,3) : factor = 2;\r\n\r\n /**\r\n * The p5.EQ is built with abstracted p5.Filter objects.\r\n * To modify any bands, use methods of the \r\n * p5.Filter API, especially `gain` and `freq`.\r\n * Bands are stored in an array, with indices 0 - 3, or 0 - 7\r\n * @property {Array} bands\r\n *\r\n */\r\n this.bands = [];\r\n\r\n\r\n var freq, res;\r\n for (var i = 0; i < _eqsize; i++) {\r\n if (i === _eqsize - 1) {\r\n freq = 21000;\r\n res = .01;\r\n } else if (i === 0) {\r\n freq = 100;\r\n res = .1;\r\n }\r\n else if (i===1) {\r\n freq = _eqsize === 3 ? 360 * factor : 360;\r\n res = 1;\r\n }else {\r\n freq = this.bands[i-1].freq() * factor;\r\n res = 1;\r\n }\r\n this.bands[i] = this._newBand(freq, res);\r\n\r\n if (i>0) {\r\n this.bands[i-1].connect(this.bands[i].biquad);\r\n } else {\r\n this.input.connect(this.bands[i].biquad);\r\n }\r\n }\r\n this.bands[_eqsize-1].connect(this.output);\r\n };\r\n p5.EQ.prototype = Object.create(Effect.prototype);\r\n\r\n /**\r\n * Process an input by connecting it to the EQ\r\n * @method process\r\n * @param {Object} src Audio source\r\n */\r\n p5.EQ.prototype.process = function (src) {\r\n src.connect(this.input);\r\n };\r\n\r\n // /**\r\n // * Set the frequency and gain of each band in the EQ. This method should be\r\n // * called with 3 or 8 frequency and gain pairs, depending on the size of the EQ.\r\n // * ex. eq.set(freq0, gain0, freq1, gain1, freq2, gain2);\r\n // *\r\n // * @method set\r\n // * @for p5.EQ\r\n // * @param {Number} [freq0] Frequency value for band with index 0\r\n // * @param {Number} [gain0] Gain value for band with index 0\r\n // * @param {Number} [freq1] Frequency value for band with index 1\r\n // * @param {Number} [gain1] Gain value for band with index 1\r\n // * @param {Number} [freq2] Frequency value for band with index 2\r\n // * @param {Number} [gain2] Gain value for band with index 2\r\n // * @param {Number} [freq3] Frequency value for band with index 3\r\n // * @param {Number} [gain3] Gain value for band with index 3\r\n // * @param {Number} [freq4] Frequency value for band with index 4\r\n // * @param {Number} [gain4] Gain value for band with index 4\r\n // * @param {Number} [freq5] Frequency value for band with index 5\r\n // * @param {Number} [gain5] Gain value for band with index 5\r\n // * @param {Number} [freq6] Frequency value for band with index 6\r\n // * @param {Number} [gain6] Gain value for band with index 6\r\n // * @param {Number} [freq7] Frequency value for band with index 7\r\n // * @param {Number} [gain7] Gain value for band with index 7\r\n // */\r\n p5.EQ.prototype.set = function() {\r\n if (arguments.length === this.bands.length * 2) {\r\n for (var i = 0; i < arguments.length; i+=2) {\r\n this.bands[i/2].freq(arguments[i]);\r\n this.bands[i/2].gain(arguments[i+1]);\r\n }\r\n }\r\n else {\r\n console.error('Argument mismatch. .set() should be called with ' + this.bands.length*2 +\r\n ' arguments. (one frequency and gain value pair for each band of the eq)');\r\n }\r\n };\r\n\r\n /**\r\n * Add a new band. Creates a p5.Filter and strips away everything but\r\n * the raw biquad filter. This method returns an abstracted p5.Filter,\r\n * which can be added to p5.EQ.bands, in order to create new EQ bands.\r\n * @private\r\n * @for p5.EQ\r\n * @method _newBand\r\n * @param {Number} freq\r\n * @param {Number} res\r\n * @return {Object} Abstracted Filter\r\n */\r\n p5.EQ.prototype._newBand = function(freq, res) {\r\n return new EQFilter(freq, res);\r\n };\r\n\r\n p5.EQ.prototype.dispose = function () {\r\n Effect.prototype.dispose.apply(this);\r\n\r\n if (this.bands) {\r\n while (this.bands.length > 0) {\r\n delete this.bands.pop().dispose();\r\n }\r\n delete this.bands;\r\n }\r\n };\r\n\r\n return p5.EQ;\r\n});\r\n","'use strict';\r\n\r\ndefine(function (require) {\r\n var Filter = require('filter');\r\n var p5sound = require('master');\r\n\r\n /**\r\n * EQFilter extends p5.Filter with constraints\r\n * necessary for the p5.EQ\r\n *\r\n * @private\r\n */\r\n var EQFilter = function(freq, res) {\r\n Filter.call(this, 'peaking');\r\n this.disconnect();\r\n this.set(freq, res);\r\n this.biquad.gain.value = 0;\r\n delete this.input;\r\n delete this.output;\r\n delete this._drywet;\r\n delete this.wet;\r\n\r\n };\r\n EQFilter.prototype = Object.create(Filter.prototype);\r\n\r\n EQFilter.prototype.amp = function() {\r\n console.warn('`amp()` is not available for p5.EQ bands. Use `.gain()`');\r\n };\r\n EQFilter.prototype.drywet = function() {\r\n console.warn('`drywet()` is not available for p5.EQ bands.');\r\n };\r\n EQFilter.prototype.connect = function(unit) {\r\n var u = unit || p5.soundOut.input;\r\n if (this.biquad) {\r\n this.biquad.connect(u.input ? u.input : u);\r\n } else {\r\n this.output.connect(u.input ? u.input : u);\r\n }\r\n };\r\n\r\n EQFilter.prototype.disconnect = function() {\r\n if (this.biquad) {\r\n this.biquad.disconnect();\r\n }\r\n };\r\n EQFilter.prototype.dispose = function() {\r\n // remove reference form soundArray\r\n var index = p5sound.soundArray.indexOf(this);\r\n p5sound.soundArray.splice(index, 1);\r\n this.disconnect();\r\n delete this.biquad;\r\n };\r\n\r\n return EQFilter;\r\n});\r\n","'use strict'\r\n\r\ndefine(function (require) {\r\n var p5sound = require('master');\r\n var Effect = require('effect');\r\n\r\n /**\r\n * Panner3D is based on the \r\n * Web Audio Spatial Panner Node.\r\n * This panner is a spatial processing node that allows audio to be positioned\r\n * and oriented in 3D space.\r\n *\r\n * The position is relative to an \r\n * Audio Context Listener, which can be accessed\r\n * by p5.soundOut.audiocontext.listener\r\n *\r\n *\r\n * @class p5.Panner3D\r\n * @constructor\r\n */\r\n\tp5.Panner3D = function() {\r\n Effect.call(this);\r\n\r\n /**\r\n * \r\n * Web Audio Spatial Panner Node\r\n *\r\n * Properties include\r\n * - panningModel: \"equal power\" or \"HRTF\"\r\n * - distanceModel: \"linear\", \"inverse\", or \"exponential\"\r\n *\r\n * @property {AudioNode} panner\r\n *\r\n */\r\n this.panner = this.ac.createPanner();\r\n this.panner.panningModel = 'HRTF';\r\n this.panner.distanceModel = 'linear';\r\n this.panner.connect(this.output);\r\n this.input.connect(this.panner);\r\n\t};\r\n\r\n p5.Panner3D.prototype = Object.create(Effect.prototype);\r\n\r\n\r\n /**\r\n * Connect an audio sorce\r\n *\r\n * @method process\r\n * @for p5.Panner3D\r\n * @param {Object} src Input source\r\n */\r\n p5.Panner3D.prototype.process = function(src) {\r\n src.connect(this.input);\r\n }\r\n /**\r\n * Set the X,Y,Z position of the Panner\r\n * @method set\r\n * @for p5.Panner3D\r\n * @param {Number} xVal\r\n * @param {Number} yVal\r\n * @param {Number} zVal\r\n * @param {Number} time\r\n * @return {Array} Updated x, y, z values as an array\r\n */\r\n p5.Panner3D.prototype.set = function(xVal, yVal, zVal, time) {\r\n this.positionX(xVal,time);\r\n this.positionY(yVal,time);\r\n this.positionZ(zVal,time);\r\n return [this.panner.positionX.value,\r\n this.panner.positionY.value,\r\n this.panner.positionZ.value];\r\n };\r\n\r\n /**\r\n * Getter and setter methods for position coordinates\r\n * @method positionX\r\n * @for p5.Panner3D\r\n * @return {Number} updated coordinate value\r\n */\r\n /**\r\n * Getter and setter methods for position coordinates\r\n * @method positionY\r\n * @for p5.Panner3D\r\n * @return {Number} updated coordinate value\r\n */\r\n /**\r\n * Getter and setter methods for position coordinates\r\n * @method positionZ\r\n * @for p5.Panner3D\r\n * @return {Number} updated coordinate value\r\n */\r\n p5.Panner3D.prototype.positionX = function(xVal, time) {\r\n var t = time || 0;\r\n if (typeof xVal === 'number') {\r\n this.panner.positionX.value = xVal;\r\n this.panner.positionX.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.panner.positionX.linearRampToValueAtTime(xVal, this.ac.currentTime + 0.02 + t);\r\n } else if (xVal) {\r\n xVal.connect(this.panner.positionX);\r\n }\r\n return this.panner.positionX.value;\r\n };\r\n p5.Panner3D.prototype.positionY = function(yVal, time) {\r\n var t = time || 0;\r\n if (typeof yVal === 'number') {\r\n this.panner.positionY.value = yVal;\r\n this.panner.positionY.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.panner.positionY.linearRampToValueAtTime(yVal, this.ac.currentTime + 0.02 + t);\r\n } else if (yVal) {\r\n yVal.connect(this.panner.positionY);\r\n }\r\n return this.panner.positionY.value;\r\n };\r\n p5.Panner3D.prototype.positionZ = function(zVal, time) {\r\n var t = time || 0;\r\n if (typeof zVal === 'number') {\r\n this.panner.positionZ.value = zVal;\r\n this.panner.positionZ.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.panner.positionZ.linearRampToValueAtTime(zVal, this.ac.currentTime + 0.02 + t);\r\n } else if (zVal) {\r\n zVal.connect(this.panner.positionZ);\r\n }\r\n return this.panner.positionZ.value;\r\n };\r\n\r\n /**\r\n * Set the X,Y,Z position of the Panner\r\n * @method orient\r\n * @for p5.Panner3D\r\n * @param {Number} xVal\r\n * @param {Number} yVal\r\n * @param {Number} zVal\r\n * @param {Number} time\r\n * @return {Array} Updated x, y, z values as an array\r\n */\r\n p5.Panner3D.prototype.orient = function(xVal, yVal, zVal, time) {\r\n this.orientX(xVal,time);\r\n this.orientY(yVal,time);\r\n this.orientZ(zVal,time);\r\n return [this.panner.orientationX.value,\r\n this.panner.orientationY.value,\r\n this.panner.orientationZ.value];\r\n };\r\n\r\n /**\r\n * Getter and setter methods for orient coordinates\r\n * @method orientX\r\n * @for p5.Panner3D\r\n * @return {Number} updated coordinate value\r\n */\r\n /**\r\n * Getter and setter methods for orient coordinates\r\n * @method orientY\r\n * @for p5.Panner3D\r\n * @return {Number} updated coordinate value\r\n */\r\n /**\r\n * Getter and setter methods for orient coordinates\r\n * @method orientZ\r\n * @for p5.Panner3D\r\n * @return {Number} updated coordinate value\r\n */\r\n p5.Panner3D.prototype.orientX = function(xVal, time) {\r\n var t = time || 0;\r\n if (typeof xVal === 'number') {\r\n this.panner.orientationX.value = xVal;\r\n this.panner.orientationX.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.panner.orientationX.linearRampToValueAtTime(xVal, this.ac.currentTime + 0.02 + t);\r\n } else if (xVal) {\r\n xVal.connect(this.panner.orientationX);\r\n }\r\n return this.panner.orientationX.value;\r\n };\r\n p5.Panner3D.prototype.orientY = function(yVal, time) {\r\n var t = time || 0;\r\n if (typeof yVal === 'number') {\r\n this.panner.orientationY.value = yVal;\r\n this.panner.orientationY.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.panner.orientationY.linearRampToValueAtTime(yVal, this.ac.currentTime + 0.02 + t);\r\n } else if (yVal) {\r\n yVal.connect(this.panner.orientationY);\r\n }\r\n return this.panner.orientationY.value;\r\n };\r\n p5.Panner3D.prototype.orientZ = function(zVal, time) {\r\n var t = time || 0;\r\n if (typeof zVal === 'number') {\r\n this.panner.orientationZ.value = zVal;\r\n this.panner.orientationZ.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.panner.orientationZ.linearRampToValueAtTime(zVal, this.ac.currentTime + 0.02 + t);\r\n } else if (zVal) {\r\n zVal.connect(this.panner.orientationZ);\r\n }\r\n return this.panner.orientationZ.value;\r\n };\r\n\r\n /**\r\n * Set the rolloff factor and max distance\r\n * @method setFalloff\r\n * @for p5.Panner3D\r\n * @param {Number} [maxDistance]\r\n * @param {Number} [rolloffFactor]\r\n */\r\n p5.Panner3D.prototype.setFalloff = function(maxDistance, rolloffFactor) {\r\n this.maxDist(maxDistance);\r\n this.rolloff(rolloffFactor);\r\n };\r\n /**\r\n * Maxium distance between the source and the listener\r\n * @method maxDist\r\n * @for p5.Panner3D\r\n * @param {Number} maxDistance\r\n * @return {Number} updated value\r\n */\r\n p5.Panner3D.prototype.maxDist = function(maxDistance){\r\n if (typeof maxDistance === 'number') {\r\n this.panner.maxDistance = maxDistance;\r\n }\r\n return this.panner.maxDistance;\r\n };\r\n\r\n /**\r\n * How quickly the volume is reduced as the source moves away from the listener\r\n * @method rollof\r\n * @for p5.Panner3D\r\n * @param {Number} rolloffFactor\r\n * @return {Number} updated value\r\n */\r\n p5.Panner3D.prototype.rolloff = function(rolloffFactor){\r\n if (typeof rolloffFactor === 'number') {\r\n this.panner.rolloffFactor = rolloffFactor;\r\n }\r\n return this.panner.rolloffFactor;\r\n };\r\n\r\n p5.Panner3D.dispose = function() {\r\n Effect.prototype.dispose.apply(this);\r\n if (this.panner) {\r\n this.panner.disconnect();\r\n delete this.panner;\r\n }\r\n };\r\n\r\n return p5.Panner3D;\r\n\r\n});\r\n","'use strict'\r\n\r\ndefine(function (require) {\r\n var p5sound = require('master');\r\n var Effect = require('effect');\r\n\r\n// /**\r\n// * listener is a class that can construct both a Spatial Panner\r\n// * and a Spatial Listener. The panner is based on the \r\n// * Web Audio Spatial Panner Node\r\n// * https://www.w3.org/TR/webaudio/#the-listenernode-interface\r\n// * This panner is a spatial processing node that allows audio to be positioned\r\n// * and oriented in 3D space. \r\n// *\r\n// * The Listener modifies the properties of the Audio Context Listener. \r\n// * Both objects types use the same methods. The default is a spatial panner.\r\n// *\r\n// * p5.Panner3D - Constructs a Spatial Panner
\r\n// * p5.Listener3D - Constructs a Spatial Listener
\r\n// *\r\n// * @class listener\r\n// * @constructor\r\n// * @return {Object} p5.Listener3D Object\r\n// *\r\n// * @param {Web Audio Node} listener Web Audio Spatial Panning Node\r\n// * @param {AudioParam} listener.panningModel \"equal power\" or \"HRTF\"\r\n// * @param {AudioParam} listener.distanceModel \"linear\", \"inverse\", or \"exponential\"\r\n// * @param {String} [type] [Specify construction of a spatial panner or listener]\r\n// */\r\n \r\n\tp5.Listener3D = function(type) {\r\n this.ac = p5sound.audiocontext;\r\n this.listener = this.ac.listener;\r\n\t}; \r\n\r\n// /**\r\n// * Connect an audio sorce\r\n// * @param {Object} src Input source\r\n// */\r\n p5.Listener3D.prototype.process = function(src) {\r\n src.connect(this.input);\r\n }\r\n// /**\r\n// * Set the X,Y,Z position of the Panner\r\n// * @param {[Number]} xVal\r\n// * @param {[Number]} yVal\r\n// * @param {[Number]} zVal\r\n// * @param {[Number]} time\r\n// * @return {[Array]} [Updated x, y, z values as an array]\r\n// */\r\n p5.Listener3D.prototype.position = function(xVal, yVal, zVal, time) {\r\n this.positionX(xVal,time);\r\n this.positionY(yVal,time);\r\n this.positionZ(zVal,time);\r\n return [this.listener.positionX.value, \r\n this.listener.positionY.value,\r\n this.listener.positionZ.value];\r\n };\r\n\r\n// /**\r\n// * Getter and setter methods for position coordinates\r\n// * @return {Number} [updated coordinate value]\r\n// */\r\n p5.Listener3D.prototype.positionX = function(xVal, time) {\r\n var t = time || 0;\r\n if (typeof xVal === 'number') {\r\n this.listener.positionX.value = xVal;\r\n this.listener.positionX.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.listener.positionX.linearRampToValueAtTime(xVal, this.ac.currentTime + 0.02 + t);\r\n } else if (xVal) {\r\n xVal.connect(this.listener.positionX);\r\n }\r\n return this.listener.positionX.value;\r\n };\r\n p5.Listener3D.prototype.positionY = function(yVal, time) {\r\n var t = time || 0;\r\n if (typeof yVal === 'number') {\r\n this.listener.positionY.value = yVal;\r\n this.listener.positionY.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.listener.positionY.linearRampToValueAtTime(yVal, this.ac.currentTime + 0.02 + t);\r\n } else if (yVal) {\r\n yVal.connect(this.listener.positionY);\r\n }\r\n return this.listener.positionY.value;\r\n };\r\n p5.Listener3D.prototype.positionZ = function(zVal, time) {\r\n var t = time || 0;\r\n if (typeof zVal === 'number') {\r\n this.listener.positionZ.value = zVal;\r\n this.listener.positionZ.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.listener.positionZ.linearRampToValueAtTime(zVal, this.ac.currentTime + 0.02 + t);\r\n } else if (zVal) {\r\n zVal.connect(this.listener.positionZ);\r\n }\r\n return this.listener.positionZ.value;\r\n };\r\n\r\n// cannot define method when class definition is commented\r\n// /**\r\n// * Overrides the listener orient() method because Listener has slightly\r\n// * different params. In human terms, Forward vectors are the direction the \r\n// * nose is pointing. Up vectors are the direction of the top of the head.\r\n// *\r\n// * @method orient\r\n// * @param {Number} xValF Forward vector X direction\r\n// * @param {Number} yValF Forward vector Y direction\r\n// * @param {Number} zValF Forward vector Z direction\r\n// * @param {Number} xValU Up vector X direction\r\n// * @param {Number} yValU Up vector Y direction\r\n// * @param {Number} zValU Up vector Z direction\r\n// * @param {Number} time \r\n// * @return {Array} All orienation params\r\n// */\r\n p5.Listener3D.prototype.orient = function(xValF, yValF, zValF, \r\n xValU, yValU, zValU, time) {\r\n\r\n if (arguments.length === 3 || arguments.length === 4) {\r\n time = arguments[3];\r\n this.orientForward(xValF, yValF, zValF, time);\r\n } else if (arguments.length === 6 || arguments === 7) {\r\n this.orientForward(xValF, yValF, zValF);\r\n this.orientUp(xValU, yValU, zValU, time);\r\n }\r\n \r\n return [this.listener.forwardX.value, \r\n this.listener.forwardY.value,\r\n this.listener.forwardZ.value,\r\n this.listener.upX.value,\r\n this.listener.upY.value,\r\n this.listener.upZ.value];\r\n };\r\n\r\n\r\n p5.Listener3D.prototype.orientForward = function(xValF, yValF, zValF, time) {\r\n this.forwardX(xValF,time);\r\n this.forwardY(yValF,time);\r\n this.forwardZ(zValF,time);\r\n\r\n return [this.listener.forwardX, \r\n this.listener.forwardY,\r\n this.listener.forwardZ];\r\n };\r\n\r\n p5.Listener3D.prototype.orientUp = function(xValU, yValU, zValU, time) {\r\n this.upX(xValU,time);\r\n this.upY(yValU,time);\r\n this.upZ(zValU,time);\r\n\r\n return [this.listener.upX, \r\n this.listener.upY,\r\n this.listener.upZ];\r\n };\r\n// /**\r\n// * Getter and setter methods for orient coordinates\r\n// * @return {Number} [updated coordinate value]\r\n// */\r\n p5.Listener3D.prototype.forwardX = function(xVal, time) {\r\n var t = time || 0;\r\n if (typeof xVal === 'number') {\r\n this.listener.forwardX.value = xVal;\r\n this.listener.forwardX.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.listener.forwardX.linearRampToValueAtTime(xVal, this.ac.currentTime + 0.02 + t);\r\n } else if (xVal) {\r\n xVal.connect(this.listener.forwardX);\r\n }\r\n return this.listener.forwardX.value;\r\n };\r\n p5.Listener3D.prototype.forwardY = function(yVal, time) {\r\n var t = time || 0;\r\n if (typeof yVal === 'number') {\r\n this.listener.forwardY.value = yVal;\r\n this.listener.forwardY.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.listener.forwardY.linearRampToValueAtTime(yVal, this.ac.currentTime + 0.02 + t);\r\n } else if (yVal) {\r\n yVal.connect(this.listener.forwardY);\r\n }\r\n return this.listener.forwardY.value;\r\n };\r\n p5.Listener3D.prototype.forwardZ = function(zVal, time) {\r\n var t = time || 0;\r\n if (typeof zVal === 'number') {\r\n this.listener.forwardZ.value = zVal;\r\n this.listener.forwardZ.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.listener.forwardZ.linearRampToValueAtTime(zVal, this.ac.currentTime + 0.02 + t);\r\n } else if (zVal) {\r\n zVal.connect(this.listener.forwardZ);\r\n }\r\n return this.listener.forwardZ.value;\r\n };\r\n p5.Listener3D.prototype.upX = function(xVal, time) {\r\n var t = time || 0;\r\n if (typeof xVal === 'number') {\r\n this.listener.upX.value = xVal;\r\n this.listener.upX.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.listener.upX.linearRampToValueAtTime(xVal, this.ac.currentTime + 0.02 + t);\r\n } else if (xVal) {\r\n xVal.connect(this.listener.upX);\r\n }\r\n return this.listener.upX.value;\r\n };\r\n p5.Listener3D.prototype.upY = function(yVal, time) {\r\n var t = time || 0;\r\n if (typeof yVal === 'number') {\r\n this.listener.upY.value = yVal;\r\n this.listener.upY.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.listener.upY.linearRampToValueAtTime(yVal, this.ac.currentTime + 0.02 + t);\r\n } else if (yVal) {\r\n yVal.connect(this.listener.upY);\r\n }\r\n return this.listener.upY.value;\r\n };\r\n p5.Listener3D.prototype.upZ = function(zVal, time) {\r\n var t = time || 0;\r\n if (typeof zVal === 'number') {\r\n this.listener.upZ.value = zVal;\r\n this.listener.upZ.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.listener.upZ.linearRampToValueAtTime(zVal, this.ac.currentTime + 0.02 + t);\r\n } else if (zVal) {\r\n zVal.connect(this.listener.upZ);\r\n }\r\n return this.listener.upZ.value;\r\n };\r\n \r\n return p5.Listener3D;\r\n\r\n});","'use strict';\r\n\r\ndefine(function (require) {\r\n var Filter = require('filter');\r\n var Effect = require('effect');\r\n\r\n /**\r\n * Delay is an echo effect. It processes an existing sound source,\r\n * and outputs a delayed version of that sound. The p5.Delay can\r\n * produce different effects depending on the delayTime, feedback,\r\n * filter, and type. In the example below, a feedback of 0.5 (the\r\n * default value) will produce a looping delay that decreases in\r\n * volume by 50% each repeat. A filter will cut out the high\r\n * frequencies so that the delay does not sound as piercing as the\r\n * original source.\r\n *\r\n *\r\n * This class extends p5.Effect.\r\n * Methods amp(), chain(),\r\n * drywet(), connect(), and\r\n * disconnect() are available.\r\n * @class p5.Delay\r\n * @extends p5.Effect\r\n * @constructor\r\n * @example\r\n *
\r\n * let osc;\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * background(220);\r\n * textAlign(CENTER);\r\n * text('tap to play', width/2, height/2);\r\n *\r\n * osc = new p5.Oscillator('square');\r\n * osc.amp(0.5);\r\n * delay = new p5.Delay();\r\n *\r\n * // delay.process() accepts 4 parameters:\r\n * // source, delayTime (in seconds), feedback, filter frequency\r\n * delay.process(osc, 0.12, .7, 2300);\r\n *\r\n * cnv.mousePressed(oscStart);\r\n * }\r\n *\r\n * function oscStart() {\r\n * osc.start();\r\n * }\r\n *\r\n * function mouseReleased() {\r\n * osc.stop();\r\n * }\r\n *
\r\n */\r\n p5.Delay = function() {\r\n \tEffect.call(this);\r\n\r\n this._split = this.ac.createChannelSplitter(2);\r\n this._merge = this.ac.createChannelMerger(2);\r\n\r\n this._leftGain = this.ac.createGain();\r\n this._rightGain = this.ac.createGain();\r\n\r\n /**\r\n * The p5.Delay is built with two\r\n * \r\n * Web Audio Delay Nodes, one for each stereo channel.\r\n *\r\n * @for p5.Delay\r\n * @property {DelayNode} leftDelay\r\n */\r\n this.leftDelay = this.ac.createDelay();\r\n /**\r\n * The p5.Delay is built with two\r\n * \r\n * Web Audio Delay Nodes, one for each stereo channel.\r\n * @for p5.Delay\r\n * @property {DelayNode} rightDelay\r\n */\r\n this.rightDelay = this.ac.createDelay();\r\n\r\n this._leftFilter = new Filter();\r\n this._rightFilter = new Filter();\r\n this._leftFilter.disconnect();\r\n this._rightFilter.disconnect();\r\n\r\n this._leftFilter.biquad.frequency.setValueAtTime(1200, this.ac.currentTime);\r\n this._rightFilter.biquad.frequency.setValueAtTime(1200, this.ac.currentTime);\r\n this._leftFilter.biquad.Q.setValueAtTime(0.3, this.ac.currentTime);\r\n this._rightFilter.biquad.Q.setValueAtTime(0.3, this.ac.currentTime);\r\n\r\n // graph routing\r\n this.input.connect(this._split);\r\n this.leftDelay.connect(this._leftGain);\r\n this.rightDelay.connect(this._rightGain);\r\n this._leftGain.connect(this._leftFilter.input);\r\n this._rightGain.connect(this._rightFilter.input);\r\n this._merge.connect(this.wet);\r\n\r\n\r\n this._leftFilter.biquad.gain.setValueAtTime(1, this.ac.currentTime);\r\n this._rightFilter.biquad.gain.setValueAtTime(1, this.ac.currentTime);\r\n\r\n // default routing\r\n this.setType(0);\r\n\r\n this._maxDelay = this.leftDelay.delayTime.maxValue;\r\n\r\n // set initial feedback to 0.5\r\n this.feedback(0.5);\r\n\r\n\r\n };\r\n\r\n p5.Delay.prototype = Object.create(Effect.prototype);\r\n /**\r\n * Add delay to an audio signal according to a set\r\n * of delay parameters.\r\n *\r\n * @method process\r\n * @for p5.Delay\r\n * @param {Object} Signal An object that outputs audio\r\n * @param {Number} [delayTime] Time (in seconds) of the delay/echo.\r\n * Some browsers limit delayTime to\r\n * 1 second.\r\n * @param {Number} [feedback] sends the delay back through itself\r\n * in a loop that decreases in volume\r\n * each time.\r\n * @param {Number} [lowPass] Cutoff frequency. Only frequencies\r\n * below the lowPass will be part of the\r\n * delay.\r\n */\r\n p5.Delay.prototype.process = function(src, _delayTime, _feedback, _filter) {\r\n var feedback = _feedback || 0;\r\n var delayTime = _delayTime || 0;\r\n if (feedback >= 1.0) {\r\n throw new Error('Feedback value will force a positive feedback loop.');\r\n }\r\n if (delayTime >= this._maxDelay) {\r\n throw new Error('Delay Time exceeds maximum delay time of ' + this._maxDelay + ' second.');\r\n }\r\n\r\n src.connect(this.input);\r\n this.leftDelay.delayTime.setValueAtTime(delayTime, this.ac.currentTime);\r\n this.rightDelay.delayTime.setValueAtTime(delayTime, this.ac.currentTime);\r\n this._leftGain.gain.value = feedback;\r\n this._rightGain.gain.value = feedback;\r\n\r\n if (_filter) {\r\n this._leftFilter.freq(_filter);\r\n this._rightFilter.freq(_filter);\r\n }\r\n };\r\n\r\n /**\r\n * Set the delay (echo) time, in seconds. Usually this value will be\r\n * a floating point number between 0.0 and 1.0.\r\n *\r\n * @method delayTime\r\n * @for p5.Delay\r\n * @param {Number} delayTime Time (in seconds) of the delay\r\n */\r\n p5.Delay.prototype.delayTime = function(t) {\r\n // if t is an audio node...\r\n if (typeof t !== 'number') {\r\n t.connect(this.leftDelay.delayTime);\r\n t.connect(this.rightDelay.delayTime);\r\n }\r\n\r\n else {\r\n this.leftDelay.delayTime.cancelScheduledValues(this.ac.currentTime);\r\n this.rightDelay.delayTime.cancelScheduledValues(this.ac.currentTime);\r\n this.leftDelay.delayTime.linearRampToValueAtTime(t, this.ac.currentTime);\r\n this.rightDelay.delayTime.linearRampToValueAtTime(t, this.ac.currentTime);\r\n }\r\n };\r\n\r\n /**\r\n * Feedback occurs when Delay sends its signal back through its input\r\n * in a loop. The feedback amount determines how much signal to send each\r\n * time through the loop. A feedback greater than 1.0 is not desirable because\r\n * it will increase the overall output each time through the loop,\r\n * creating an infinite feedback loop. The default value is 0.5\r\n *\r\n * @method feedback\r\n * @for p5.Delay\r\n * @param {Number|Object} feedback 0.0 to 1.0, or an object such as an\r\n * Oscillator that can be used to\r\n * modulate this param\r\n * @returns {Number} Feedback value\r\n *\r\n */\r\n p5.Delay.prototype.feedback = function(f) {\r\n // if f is an audio node...\r\n if (f && typeof f !== 'number') {\r\n f.connect(this._leftGain.gain);\r\n f.connect(this._rightGain.gain);\r\n }\r\n else if (f >= 1.0) {\r\n throw new Error('Feedback value will force a positive feedback loop.');\r\n }\r\n else if (typeof f === 'number') {\r\n this._leftGain.gain.value = f;\r\n this._rightGain.gain.value = f;\r\n }\r\n\r\n // return value of feedback\r\n return this._leftGain.gain.value;\r\n };\r\n\r\n /**\r\n * Set a lowpass filter frequency for the delay. A lowpass filter\r\n * will cut off any frequencies higher than the filter frequency.\r\n *\r\n * @method filter\r\n * @for p5.Delay\r\n * @param {Number|Object} cutoffFreq A lowpass filter will cut off any\r\n * frequencies higher than the filter frequency.\r\n * @param {Number|Object} res Resonance of the filter frequency\r\n * cutoff, or an object (i.e. a p5.Oscillator)\r\n * that can be used to modulate this parameter.\r\n * High numbers (i.e. 15) will produce a resonance,\r\n * low numbers (i.e. .2) will produce a slope.\r\n */\r\n p5.Delay.prototype.filter = function(freq, q) {\r\n this._leftFilter.set(freq, q);\r\n this._rightFilter.set(freq, q);\r\n };\r\n\r\n\r\n /**\r\n * Choose a preset type of delay. 'pingPong' bounces the signal\r\n * from the left to the right channel to produce a stereo effect.\r\n * Any other parameter will revert to the default delay setting.\r\n *\r\n * @method setType\r\n * @for p5.Delay\r\n * @param {String|Number} type 'pingPong' (1) or 'default' (0)\r\n */\r\n p5.Delay.prototype.setType = function(t) {\r\n if (t === 1) {\r\n t = 'pingPong';\r\n }\r\n this._split.disconnect();\r\n this._leftFilter.disconnect();\r\n this._rightFilter.disconnect();\r\n this._split.connect(this.leftDelay, 0);\r\n this._split.connect(this.rightDelay, 1);\r\n switch(t) {\r\n case 'pingPong':\r\n this._rightFilter.setType( this._leftFilter.biquad.type );\r\n this._leftFilter.output.connect(this._merge, 0, 0);\r\n this._rightFilter.output.connect(this._merge, 0, 1);\r\n this._leftFilter.output.connect(this.rightDelay);\r\n this._rightFilter.output.connect(this.leftDelay);\r\n break;\r\n default:\r\n this._leftFilter.output.connect(this._merge, 0, 0);\r\n this._rightFilter.output.connect(this._merge, 0, 1);\r\n this._leftFilter.output.connect(this.leftDelay);\r\n this._rightFilter.output.connect(this.rightDelay);\r\n }\r\n };\r\n\r\n // DocBlocks for methods inherited from p5.Effect\r\n /**\r\n * Set the output level of the delay effect.\r\n *\r\n * @method amp\r\n * @for p5.Delay\r\n * @param {Number} volume amplitude between 0 and 1.0\r\n * @param {Number} [rampTime] create a fade that lasts rampTime\r\n * @param {Number} [timeFromNow] schedule this event to happen\r\n * seconds from now\r\n */\r\n /**\r\n * Send output to a p5.sound or web audio object\r\n *\r\n * @method connect\r\n * @for p5.Delay\r\n * @param {Object} unit\r\n */\r\n /**\r\n * Disconnect all output.\r\n *\r\n * @method disconnect\r\n * @for p5.Delay\r\n */\r\n\r\n p5.Delay.prototype.dispose = function() {\r\n\r\n Effect.prototype.dispose.apply(this);\r\n\r\n this._split.disconnect();\r\n this._leftFilter.dispose();\r\n this._rightFilter.dispose();\r\n this._merge.disconnect();\r\n this._leftGain.disconnect();\r\n this._rightGain.disconnect();\r\n this.leftDelay.disconnect();\r\n this.rightDelay.disconnect();\r\n\r\n this._split = undefined;\r\n this._leftFilter = undefined;\r\n this._rightFilter = undefined;\r\n this._merge = undefined;\r\n this._leftGain = undefined;\r\n this._rightGain = undefined;\r\n this.leftDelay = undefined;\r\n this.rightDelay = undefined;\r\n };\r\n\r\n});\r\n","'use strict';\r\n\r\ndefine(function (require) {\r\n var CustomError = require('errorHandler');\r\n var Effect = require('effect');\r\n\r\n /**\r\n * Reverb adds depth to a sound through a large number of decaying\r\n * echoes. It creates the perception that sound is occurring in a\r\n * physical space. The p5.Reverb has paramters for Time (how long does the\r\n * reverb last) and decayRate (how much the sound decays with each echo)\r\n * that can be set with the .set() or .process() methods. The p5.Convolver\r\n * extends p5.Reverb allowing you to recreate the sound of actual physical\r\n * spaces through convolution.\r\n *\r\n * This class extends p5.Effect.\r\n * Methods amp(), chain(),\r\n * drywet(), connect(), and\r\n * disconnect() are available.\r\n *\r\n * @class p5.Reverb\r\n * @extends p5.Effect\r\n * @constructor\r\n * @example\r\n *
\r\n * let soundFile, reverb;\r\n * function preload() {\r\n * soundFile = loadSound('assets/Damscray_DancingTiger.mp3');\r\n * }\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * cnv.mousePressed(playSound);\r\n *\r\n * reverb = new p5.Reverb();\r\n * soundFile.disconnect(); // so we'll only hear reverb...\r\n *\r\n * // connect soundFile to reverb, process w/\r\n * // 3 second reverbTime, decayRate of 2%\r\n * reverb.process(soundFile, 3, 2);\r\n * }\r\n *\r\n * function draw() {\r\n * let dryWet = constrain(map(mouseX, 0, width, 0, 1), 0, 1);\r\n * // 1 = all reverb, 0 = no reverb\r\n * reverb.drywet(dryWet);\r\n *\r\n * background(220);\r\n * text('tap to play', 10, 20);\r\n * text('dry/wet: ' + round(dryWet * 100) + '%', 10, height - 20);\r\n * }\r\n *\r\n * function playSound() {\r\n * soundFile.play();\r\n * }\r\n *
\r\n */\r\n\r\n\r\n p5.Reverb = function() {\r\n Effect.call(this);\r\n\r\n this._initConvolverNode();\r\n\r\n // otherwise, Safari distorts\r\n this.input.gain.value = 0.5;\r\n\r\n // default params\r\n this._seconds = 3;\r\n this._decay = 2;\r\n this._reverse = false;\r\n\r\n this._buildImpulse();\r\n\r\n };\r\n\r\n p5.Reverb.prototype = Object.create(Effect.prototype);\r\n\r\n p5.Reverb.prototype._initConvolverNode = function() {\r\n this.convolverNode = this.ac.createConvolver();\r\n this.input.connect(this.convolverNode);\r\n this.convolverNode.connect(this.wet);\r\n };\r\n\r\n p5.Reverb.prototype._teardownConvolverNode = function() {\r\n if (this.convolverNode) {\r\n this.convolverNode.disconnect();\r\n delete this.convolverNode;\r\n }\r\n };\r\n\r\n p5.Reverb.prototype._setBuffer = function(audioBuffer) {\r\n this._teardownConvolverNode();\r\n this._initConvolverNode();\r\n this.convolverNode.buffer = audioBuffer;\r\n };\r\n /**\r\n * Connect a source to the reverb, and assign reverb parameters.\r\n *\r\n * @method process\r\n * @for p5.Reverb\r\n * @param {Object} src p5.sound / Web Audio object with a sound\r\n * output.\r\n * @param {Number} [seconds] Duration of the reverb, in seconds.\r\n * Min: 0, Max: 10. Defaults to 3.\r\n * @param {Number} [decayRate] Percentage of decay with each echo.\r\n * Min: 0, Max: 100. Defaults to 2.\r\n * @param {Boolean} [reverse] Play the reverb backwards or forwards.\r\n */\r\n p5.Reverb.prototype.process = function(src, seconds, decayRate, reverse) {\r\n src.connect(this.input);\r\n var rebuild = false;\r\n if (seconds) {\r\n this._seconds = seconds;\r\n rebuild = true;\r\n }\r\n if (decayRate) {\r\n this._decay = decayRate;\r\n }\r\n if (reverse) {\r\n this._reverse = reverse;\r\n }\r\n if (rebuild) {\r\n this._buildImpulse();\r\n }\r\n };\r\n\r\n /**\r\n * Set the reverb settings. Similar to .process(), but without\r\n * assigning a new input.\r\n *\r\n * @method set\r\n * @for p5.Reverb\r\n * @param {Number} [seconds] Duration of the reverb, in seconds.\r\n * Min: 0, Max: 10. Defaults to 3.\r\n * @param {Number} [decayRate] Percentage of decay with each echo.\r\n * Min: 0, Max: 100. Defaults to 2.\r\n * @param {Boolean} [reverse] Play the reverb backwards or forwards.\r\n */\r\n p5.Reverb.prototype.set = function(seconds, decayRate, reverse) {\r\n var rebuild = false;\r\n if (seconds) {\r\n this._seconds = seconds;\r\n rebuild = true;\r\n }\r\n if (decayRate) {\r\n this._decay = decayRate;\r\n }\r\n if (reverse) {\r\n this._reverse = reverse;\r\n }\r\n if (rebuild) {\r\n this._buildImpulse();\r\n }\r\n };\r\n\r\n // DocBlocks for methods inherited from p5.Effect\r\n /**\r\n * Set the output level of the reverb effect.\r\n *\r\n * @method amp\r\n * @for p5.Reverb\r\n * @param {Number} volume amplitude between 0 and 1.0\r\n * @param {Number} [rampTime] create a fade that lasts rampTime\r\n * @param {Number} [timeFromNow] schedule this event to happen\r\n * seconds from now\r\n */\r\n /**\r\n * Send output to a p5.sound or web audio object\r\n *\r\n * @method connect\r\n * @for p5.Reverb\r\n * @param {Object} unit\r\n */\r\n /**\r\n * Disconnect all output.\r\n *\r\n * @method disconnect\r\n * @for p5.Reverb\r\n */\r\n\r\n /**\r\n * Inspired by Simple Reverb by Jordan Santell\r\n * https://github.com/web-audio-components/simple-reverb/blob/master/index.js\r\n *\r\n * Utility function for building an impulse response\r\n * based on the module parameters.\r\n *\r\n * @private\r\n */\r\n p5.Reverb.prototype._buildImpulse = function() {\r\n var rate = this.ac.sampleRate;\r\n var length = rate*this._seconds;\r\n var decay = this._decay;\r\n var impulse = this.ac.createBuffer(2, length, rate);\r\n var impulseL = impulse.getChannelData(0);\r\n var impulseR = impulse.getChannelData(1);\r\n var n, i;\r\n for (i = 0; i < length; i++) {\r\n n = this._reverse ? length - i : i;\r\n impulseL[i] = (Math.random() * 2 - 1) * Math.pow(1 - n / length, decay);\r\n impulseR[i] = (Math.random() * 2 - 1) * Math.pow(1 - n / length, decay);\r\n }\r\n this._setBuffer(impulse);\r\n };\r\n\r\n p5.Reverb.prototype.dispose = function() {\r\n Effect.prototype.dispose.apply(this);\r\n this._teardownConvolverNode();\r\n };\r\n\r\n // =======================================================================\r\n // *** p5.Convolver ***\r\n // =======================================================================\r\n\r\n /**\r\n *

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

\r\n *\r\n *

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

\r\n *\r\n *

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

\r\n *\r\n * @class p5.Convolver\r\n * @extends p5.Effect\r\n * @constructor\r\n * @param {String} path path to a sound file\r\n * @param {Function} [callback] function to call when loading succeeds\r\n * @param {Function} [errorCallback] function to call if loading fails.\r\n * This function will receive an error or\r\n * XMLHttpRequest object with information\r\n * about what went wrong.\r\n * @example\r\n *
\r\n * let cVerb, sound;\r\n * function preload() {\r\n * // We have both MP3 and OGG versions of all sound assets\r\n * soundFormats('ogg', 'mp3');\r\n *\r\n * // Try replacing 'bx-spring' with other soundfiles like\r\n * // 'concrete-tunnel' 'small-plate' 'drum' 'beatbox'\r\n * cVerb = createConvolver('assets/bx-spring.mp3');\r\n *\r\n * // Try replacing 'Damscray_DancingTiger' with\r\n * // 'beat', 'doorbell', lucky_dragons_-_power_melody'\r\n * sound = loadSound('assets/Damscray_DancingTiger.mp3');\r\n * }\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * cnv.mousePressed(playSound);\r\n * background(220);\r\n * text('tap to play', 20, 20);\r\n *\r\n * // disconnect from master output...\r\n * sound.disconnect();\r\n *\r\n * // ...and process with cVerb\r\n * // so that we only hear the convolution\r\n * cVerb.process(sound);\r\n * }\r\n *\r\n * function playSound() {\r\n * sound.play();\r\n * }\r\n *
\r\n */\r\n p5.Convolver = function(path, callback, errorCallback) {\r\n \t p5.Reverb.call(this);\r\n\r\n /**\r\n * Internally, the p5.Convolver uses the a\r\n * \r\n * Web Audio Convolver Node.\r\n *\r\n * @property {ConvolverNode} convolverNode\r\n */\r\n this._initConvolverNode();\r\n\r\n // otherwise, Safari distorts\r\n this.input.gain.value = 0.5;\r\n\r\n if (path) {\r\n this.impulses = [];\r\n this._loadBuffer(path, callback, errorCallback);\r\n }\r\n else {\r\n // parameters\r\n this._seconds = 3;\r\n this._decay = 2;\r\n this._reverse = false;\r\n\r\n this._buildImpulse();\r\n }\r\n\r\n };\r\n\r\n p5.Convolver.prototype = Object.create(p5.Reverb.prototype);\r\n\r\n p5.prototype.registerPreloadMethod('createConvolver', p5.prototype);\r\n\r\n /**\r\n * Create a p5.Convolver. Accepts a path to a soundfile\r\n * that will be used to generate an impulse response.\r\n *\r\n * @method createConvolver\r\n * @for p5\r\n * @param {String} path path to a sound file\r\n * @param {Function} [callback] function to call if loading is successful.\r\n * The object will be passed in as the argument\r\n * to the callback function.\r\n * @param {Function} [errorCallback] function to call if loading is not successful.\r\n * A custom error will be passed in as the argument\r\n * to the callback function.\r\n * @return {p5.Convolver}\r\n * @example\r\n *
\r\n * let cVerb, sound;\r\n * function preload() {\r\n * // We have both MP3 and OGG versions of all sound assets\r\n * soundFormats('ogg', 'mp3');\r\n *\r\n * // Try replacing 'bx-spring' with other soundfiles like\r\n * // 'concrete-tunnel' 'small-plate' 'drum' 'beatbox'\r\n * cVerb = createConvolver('assets/bx-spring.mp3');\r\n *\r\n * // Try replacing 'Damscray_DancingTiger' with\r\n * // 'beat', 'doorbell', lucky_dragons_-_power_melody'\r\n * sound = loadSound('assets/Damscray_DancingTiger.mp3');\r\n * }\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * cnv.mousePressed(playSound);\r\n * background(220);\r\n * text('tap to play', 20, 20);\r\n *\r\n * // disconnect from master output...\r\n * sound.disconnect();\r\n *\r\n * // ...and process with cVerb\r\n * // so that we only hear the convolution\r\n * cVerb.process(sound);\r\n * }\r\n *\r\n * function playSound() {\r\n * sound.play();\r\n * }\r\n *
\r\n */\r\n p5.prototype.createConvolver = function(path, callback, errorCallback) {\r\n // if loading locally without a server\r\n if (window.location.origin.indexOf('file://') > -1 && window.cordova === 'undefined') {\r\n alert('This sketch may require a server to load external files. Please see http://bit.ly/1qcInwS');\r\n }\r\n var self = this;\r\n var cReverb = new p5.Convolver(path, function(buffer) {\r\n if (typeof callback === 'function') {\r\n callback(buffer);\r\n }\r\n\r\n if (typeof self._decrementPreload === 'function') {\r\n self._decrementPreload();\r\n }\r\n }, errorCallback);\r\n cReverb.impulses = [];\r\n return cReverb;\r\n };\r\n\r\n /**\r\n * Private method to load a buffer as an Impulse Response,\r\n * assign it to the convolverNode, and add to the Array of .impulses.\r\n *\r\n * @param {String} path\r\n * @param {Function} callback\r\n * @param {Function} errorCallback\r\n * @private\r\n */\r\n p5.Convolver.prototype._loadBuffer = function(path, callback, errorCallback) {\r\n var path = p5.prototype._checkFileFormats(path);\r\n var self = this;\r\n var errorTrace = new Error().stack;\r\n var ac = p5.prototype.getAudioContext();\r\n\r\n var request = new XMLHttpRequest();\r\n request.open('GET', path, true);\r\n request.responseType = 'arraybuffer';\r\n\r\n request.onload = function() {\r\n if (request.status === 200) {\r\n // on success loading file:\r\n ac.decodeAudioData(request.response,\r\n function(buff) {\r\n var buffer = {};\r\n var chunks = path.split('/');\r\n buffer.name = chunks[chunks.length - 1];\r\n buffer.audioBuffer = buff;\r\n self.impulses.push(buffer);\r\n self._setBuffer(buffer.audioBuffer);\r\n if (callback) {\r\n callback(buffer);\r\n }\r\n },\r\n // error decoding buffer. \"e\" is undefined in Chrome 11/22/2015\r\n function() {\r\n var err = new CustomError('decodeAudioData', errorTrace, self.url);\r\n var msg = 'AudioContext error at decodeAudioData for ' + self.url;\r\n if (errorCallback) {\r\n err.msg = msg;\r\n errorCallback(err);\r\n } else {\r\n console.error(msg +'\\n The error stack trace includes: \\n' + err.stack);\r\n }\r\n }\r\n );\r\n }\r\n // if request status != 200, it failed\r\n else {\r\n var err = new CustomError('loadConvolver', errorTrace, self.url);\r\n var msg = 'Unable to load ' + self.url +\r\n '. The request status was: ' + request.status + ' (' + request.statusText + ')';\r\n\r\n if (errorCallback) {\r\n err.message = msg;\r\n errorCallback(err);\r\n } else {\r\n console.error(msg +'\\n The error stack trace includes: \\n' + err.stack);\r\n }\r\n }\r\n };\r\n\r\n // if there is another error, aside from 404...\r\n request.onerror = function() {\r\n var err = new CustomError('loadConvolver', errorTrace, self.url);\r\n var msg = 'There was no response from the server at ' + self.url + '. Check the url and internet connectivity.';\r\n\r\n if (errorCallback) {\r\n err.message = msg;\r\n errorCallback(err);\r\n } else {\r\n console.error(msg +'\\n The error stack trace includes: \\n' + err.stack);\r\n }\r\n };\r\n request.send();\r\n };\r\n\r\n p5.Convolver.prototype.set = null;\r\n\r\n /**\r\n * Connect a source to the convolver.\r\n *\r\n * @method process\r\n * @for p5.Convolver\r\n * @param {Object} src p5.sound / Web Audio object with a sound\r\n * output.\r\n * @example\r\n *
\r\n * let cVerb, sound;\r\n * function preload() {\r\n * // We have both MP3 and OGG versions of all sound assets\r\n * soundFormats('ogg', 'mp3');\r\n *\r\n * // Try replacing 'bx-spring' with other soundfiles like\r\n * // 'concrete-tunnel' 'small-plate' 'drum' 'beatbox'\r\n * cVerb = createConvolver('assets/bx-spring.mp3');\r\n *\r\n * // Try replacing 'Damscray_DancingTiger' with\r\n * // 'beat', 'doorbell', lucky_dragons_-_power_melody'\r\n * sound = loadSound('assets/Damscray_DancingTiger.mp3');\r\n * }\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * cnv.mousePressed(playSound);\r\n * background(220);\r\n * text('tap to play', 20, 20);\r\n *\r\n * // disconnect from master output...\r\n * sound.disconnect();\r\n *\r\n * // ...and process with cVerb\r\n * // so that we only hear the convolution\r\n * cVerb.process(sound);\r\n * }\r\n *\r\n * function playSound() {\r\n * sound.play();\r\n * }\r\n *\r\n *
\r\n */\r\n p5.Convolver.prototype.process = function(src) {\r\n src.connect(this.input);\r\n };\r\n\r\n /**\r\n * If you load multiple impulse files using the .addImpulse method,\r\n * they will be stored as Objects in this Array. Toggle between them\r\n * with the toggleImpulse(id) method.\r\n *\r\n * @property {Array} impulses\r\n * @for p5.Convolver\r\n */\r\n p5.Convolver.prototype.impulses = [];\r\n\r\n /**\r\n * Load and assign a new Impulse Response to the p5.Convolver.\r\n * The impulse is added to the .impulses array. Previous\r\n * impulses can be accessed with the .toggleImpulse(id)\r\n * method.\r\n *\r\n * @method addImpulse\r\n * @for p5.Convolver\r\n * @param {String} path path to a sound file\r\n * @param {Function} callback function (optional)\r\n * @param {Function} errorCallback function (optional)\r\n */\r\n p5.Convolver.prototype.addImpulse = function(path, callback, errorCallback) {\r\n // if loading locally without a server\r\n if (window.location.origin.indexOf('file://') > -1 && window.cordova === 'undefined') {\r\n alert('This sketch may require a server to load external files. Please see http://bit.ly/1qcInwS');\r\n }\r\n this._loadBuffer(path, callback, errorCallback);\r\n };\r\n\r\n /**\r\n * Similar to .addImpulse, except that the .impulses\r\n * Array is reset to save memory. A new .impulses\r\n * array is created with this impulse as the only item.\r\n *\r\n * @method resetImpulse\r\n * @for p5.Convolver\r\n * @param {String} path path to a sound file\r\n * @param {Function} callback function (optional)\r\n * @param {Function} errorCallback function (optional)\r\n */\r\n p5.Convolver.prototype.resetImpulse = function(path, callback, errorCallback) {\r\n // if loading locally without a server\r\n if (window.location.origin.indexOf('file://') > -1 && window.cordova === 'undefined') {\r\n alert('This sketch may require a server to load external files. Please see http://bit.ly/1qcInwS');\r\n }\r\n this.impulses = [];\r\n this._loadBuffer(path, callback, errorCallback);\r\n };\r\n\r\n /**\r\n * If you have used .addImpulse() to add multiple impulses\r\n * to a p5.Convolver, then you can use this method to toggle between\r\n * the items in the .impulses Array. Accepts a parameter\r\n * to identify which impulse you wish to use, identified either by its\r\n * original filename (String) or by its position in the .impulses\r\n * Array (Number).
\r\n * You can access the objects in the .impulses Array directly. Each\r\n * Object has two attributes: an .audioBuffer (type:\r\n * Web Audio \r\n * AudioBuffer) and a .name, a String that corresponds\r\n * with the original filename.\r\n *\r\n * @method toggleImpulse\r\n * @for p5.Convolver\r\n * @param {String|Number} id Identify the impulse by its original filename\r\n * (String), or by its position in the\r\n * .impulses Array (Number).\r\n */\r\n p5.Convolver.prototype.toggleImpulse = function(id) {\r\n if (typeof id === 'number' && id < this.impulses.length) {\r\n this._setBuffer(this.impulses[id].audioBuffer);\r\n }\r\n if (typeof id === 'string') {\r\n for (var i = 0; i < this.impulses.length; i++) {\r\n if (this.impulses[i].name === id) {\r\n this._setBuffer(this.impulses[i].audioBuffer);\r\n break;\r\n }\r\n }\r\n }\r\n };\r\n\r\n p5.Convolver.prototype.dispose = function() {\r\n p5.Reverb.prototype.dispose.apply(this);\r\n\r\n // remove all the Impulse Response buffers\r\n for (var i in this.impulses) {\r\n if (this.impulses[i]) {\r\n this.impulses[i] = null;\r\n }\r\n }\r\n };\r\n\r\n});\r\n","'use strict';\r\n\r\ndefine(function (require) {\r\n var p5sound = require('master');\r\n\r\n // requires the Tone.js library's Clock (MIT license, Yotam Mann)\r\n // https://github.com/TONEnoTONE/Tone.js/\r\n var Clock = require('Tone/core/Clock');\r\n\r\n p5.Metro = function() {\r\n this.clock = new Clock({\r\n 'callback': this.ontick.bind(this)\r\n });\r\n this.syncedParts = [];\r\n this.bpm = 120; // gets overridden by p5.Part\r\n this._init();\r\n\r\n this.prevTick = 0;\r\n this.tatumTime = 0;\r\n\r\n this.tickCallback = function() {};\r\n };\r\n\r\n p5.Metro.prototype.ontick = function(tickTime) {\r\n var elapsedTime = tickTime - this.prevTick;\r\n var secondsFromNow = tickTime - p5sound.audiocontext.currentTime;\r\n if (elapsedTime - this.tatumTime <= -0.02) {\r\n return;\r\n } else {\r\n // console.log('ok', this.syncedParts[0].phrases[0].name);\r\n this.prevTick = tickTime;\r\n\r\n // for all of the active things on the metro:\r\n var self = this;\r\n this.syncedParts.forEach(function(thisPart) {\r\n if (!thisPart.isPlaying) return;\r\n thisPart.incrementStep(secondsFromNow);\r\n // each synced source keeps track of its own beat number\r\n thisPart.phrases.forEach(function(thisPhrase) {\r\n var phraseArray = thisPhrase.sequence;\r\n var bNum = self.metroTicks % phraseArray.length;\r\n if (phraseArray[bNum] !== 0 && (self.metroTicks < phraseArray.length || !thisPhrase.looping) ) {\r\n thisPhrase.callback(secondsFromNow, phraseArray[bNum]);\r\n }\r\n });\r\n });\r\n this.metroTicks += 1;\r\n this.tickCallback(secondsFromNow);\r\n }\r\n };\r\n\r\n p5.Metro.prototype.setBPM = function(bpm, rampTime) {\r\n var beatTime = 60 / (bpm*this.tatums);\r\n var now = p5sound.audiocontext.currentTime;\r\n this.tatumTime = beatTime;\r\n\r\n var rampTime = rampTime || 0;\r\n this.clock.frequency.setValueAtTime(this.clock.frequency.value, now);\r\n this.clock.frequency.linearRampToValueAtTime(bpm, now + rampTime);\r\n this.bpm = bpm;\r\n };\r\n\r\n p5.Metro.prototype.getBPM = function() {\r\n return this.clock.getRate() / this.tatums * 60;\r\n };\r\n\r\n p5.Metro.prototype._init = function() {\r\n this.metroTicks = 0;\r\n // this.setBPM(120);\r\n };\r\n\r\n // clear existing synced parts, add only this one\r\n p5.Metro.prototype.resetSync = function(part) {\r\n this.syncedParts = [part];\r\n };\r\n\r\n // push a new synced part to the array\r\n p5.Metro.prototype.pushSync = function(part) {\r\n this.syncedParts.push(part);\r\n };\r\n\r\n p5.Metro.prototype.start = function(timeFromNow) {\r\n var t = timeFromNow || 0;\r\n var now = p5sound.audiocontext.currentTime;\r\n this.clock.start(now + t);\r\n this.setBPM(this.bpm);\r\n };\r\n\r\n p5.Metro.prototype.stop = function(timeFromNow) {\r\n var t = timeFromNow || 0;\r\n var now = p5sound.audiocontext.currentTime;\r\n this.clock.stop(now + t);\r\n };\r\n\r\n p5.Metro.prototype.beatLength = function(tatums) {\r\n this.tatums = 1/tatums / 4; // lowest possible division of a beat\r\n };\r\n\r\n});\r\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]) {\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 }\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';\r\n\r\ndefine(function (require) {\r\n var p5sound = require('master');\r\n var Clock = require('Tone/core/Clock');\r\n\r\n /**\r\n * SoundLoop\r\n *\r\n * @class p5.SoundLoop\r\n * @constructor\r\n *\r\n * @param {Function} callback this function will be called on each iteration of theloop\r\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.\r\n *\r\n * @example\r\n *
\r\n * let synth, soundLoop;\r\n * let notePattern = [60, 62, 64, 67, 69, 72];\r\n *\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * cnv.mousePressed(canvasPressed);\r\n * colorMode(HSB);\r\n * background(0, 0, 86);\r\n * text('tap to start/stop', 10, 20);\r\n *\r\n * //the looper's callback is passed the timeFromNow\r\n * //this value should be used as a reference point from\r\n * //which to schedule sounds\r\n * let intervalInSeconds = 0.2;\r\n * soundLoop = new p5.SoundLoop(onSoundLoop, intervalInSeconds);\r\n *\r\n * synth = new p5.MonoSynth();\r\n * }\r\n *\r\n * function canvasPressed() {\r\n * // ensure audio is enabled\r\n * userStartAudio();\r\n *\r\n * if (soundLoop.isPlaying) {\r\n * soundLoop.stop();\r\n * } else {\r\n * // start the loop\r\n * soundLoop.start();\r\n * }\r\n * }\r\n *\r\n * function onSoundLoop(timeFromNow) {\r\n * let noteIndex = (soundLoop.iterations - 1) % notePattern.length;\r\n * let note = midiToFreq(notePattern[noteIndex]);\r\n * synth.play(note, 0.5, timeFromNow);\r\n * background(noteIndex * 360 / notePattern.length, 50, 100);\r\n * }\r\n *
\r\n */\r\n p5.SoundLoop = function(callback, interval) {\r\n this.callback = callback;\r\n /**\r\n * musicalTimeMode uses Tone.Time convention\r\n * true if string, false if number\r\n * @property {Boolean} musicalTimeMode\r\n */\r\n this.musicalTimeMode = typeof this._interval === 'number' ? false : true;\r\n\r\n this._interval = interval || 1;\r\n\r\n /**\r\n * musicalTimeMode variables\r\n * modify these only when the interval is specified in musicalTime format as a string\r\n */\r\n this._timeSignature = 4;\r\n this._bpm = 60;\r\n\r\n this.isPlaying = false;\r\n\r\n /**\r\n * Set a limit to the number of loops to play. defaults to Infinity\r\n * @property {Number} maxIterations\r\n */\r\n this.maxIterations = Infinity;\r\n var self = this;\r\n\r\n this.clock = new Clock({\r\n 'callback' : function(time) {\r\n var timeFromNow = time - p5sound.audiocontext.currentTime;\r\n /**\r\n * Do not initiate the callback if timeFromNow is < 0\r\n * This ususually occurs for a few milliseconds when the page\r\n * is not fully loaded\r\n *\r\n * The callback should only be called until maxIterations is reached\r\n */\r\n if (timeFromNow > 0 && self.iterations <= self.maxIterations) {\r\n self.callback(timeFromNow);}\r\n },\r\n 'frequency' : this._calcFreq()\r\n });\r\n };\r\n\r\n /**\r\n * Start the loop\r\n * @method start\r\n * @for p5.SoundLoop\r\n * @param {Number} [timeFromNow] schedule a starting time\r\n */\r\n p5.SoundLoop.prototype.start = function(timeFromNow) {\r\n var t = timeFromNow || 0;\r\n var now = p5sound.audiocontext.currentTime;\r\n if (!this.isPlaying) {\r\n this.clock.start(now + t);\r\n this.isPlaying = true;\r\n }\r\n };\r\n\r\n /**\r\n * Stop the loop\r\n * @method stop\r\n * @for p5.SoundLoop\r\n * @param {Number} [timeFromNow] schedule a stopping time\r\n */\r\n p5.SoundLoop.prototype.stop = function(timeFromNow) {\r\n var t = timeFromNow || 0;\r\n var now = p5sound.audiocontext.currentTime;\r\n if (this.isPlaying) {\r\n this.clock.stop(now + t);\r\n this.isPlaying = false;\r\n }\r\n };\r\n /**\r\n * Pause the loop\r\n * @method pause\r\n * @for p5.SoundLoop\r\n * @param {Number} [timeFromNow] schedule a pausing time\r\n */\r\n p5.SoundLoop.prototype.pause = function(timeFromNow) {\r\n var t = timeFromNow || 0;\r\n var now = p5sound.audiocontext.currentTime;\r\n if (this.isPlaying) {\r\n this.clock.pause(now + t);\r\n this.isPlaying = false;\r\n }\r\n };\r\n\r\n\r\n /**\r\n * Synchronize loops. Use this method to start two or more loops in synchronization\r\n * or to start a loop in synchronization with a loop that is already playing\r\n * This method will schedule the implicit loop in sync with the explicit master loop\r\n * i.e. loopToStart.syncedStart(loopToSyncWith)\r\n *\r\n * @method syncedStart\r\n * @for p5.SoundLoop\r\n * @param {Object} otherLoop a p5.SoundLoop to sync with\r\n * @param {Number} [timeFromNow] Start the loops in sync after timeFromNow seconds\r\n */\r\n p5.SoundLoop.prototype.syncedStart = function(otherLoop, timeFromNow) {\r\n var t = timeFromNow || 0;\r\n var now = p5sound.audiocontext.currentTime;\r\n\r\n if (!otherLoop.isPlaying) {\r\n otherLoop.clock.start(now + t);\r\n otherLoop.isPlaying = true;\r\n this.clock.start(now + t);\r\n this.isPlaying = true;\r\n } else if (otherLoop.isPlaying) {\r\n var time = otherLoop.clock._nextTick - p5sound.audiocontext.currentTime;\r\n this.clock.start(now + time);\r\n this.isPlaying = true;\r\n }\r\n };\r\n\r\n\r\n /**\r\n * Updates frequency value, reflected in next callback\r\n * @private\r\n * @for p5.SoundLoop\r\n * @method _update\r\n */\r\n p5.SoundLoop.prototype._update = function() {\r\n this.clock.frequency.value = this._calcFreq();\r\n };\r\n\r\n /**\r\n * Calculate the frequency of the clock's callback based on bpm, interval, and timesignature\r\n * @private\r\n * @for p5.SoundLoop\r\n * @method _calcFreq\r\n * @return {Number} new clock frequency value\r\n */\r\n p5.SoundLoop.prototype._calcFreq = function() {\r\n //Seconds mode, bpm / timesignature has no effect\r\n if (typeof this._interval === 'number') {\r\n this.musicalTimeMode = false;\r\n return 1 / this._interval;\r\n }\r\n //Musical timing mode, calculate interval based bpm, interval,and time signature\r\n else if (typeof this._interval === 'string') {\r\n this.musicalTimeMode = true;\r\n return this._bpm / 60 / this._convertNotation(this._interval) * (this._timeSignature / 4);\r\n }\r\n };\r\n\r\n /**\r\n * Convert notation from musical time format to seconds\r\n * Uses Tone.Time convention\r\n * @private\r\n * @for p5.SoundLoop\r\n * @method _convertNotation\r\n * @param {String} value value to be converted\r\n * @return {Number} converted value in seconds\r\n */\r\n p5.SoundLoop.prototype._convertNotation = function(value) {\r\n var type = value.slice(-1);\r\n value = Number(value.slice(0,-1));\r\n switch (type) {\r\n case 'm':\r\n return this._measure(value);\r\n case 'n':\r\n return this._note(value);\r\n default:\r\n console.warn('Specified interval is not formatted correctly. See Tone.js '+\r\n 'timing reference for more info: https://github.com/Tonejs/Tone.js/wiki/Time');\r\n }\r\n };\r\n\r\n /**\r\n * Helper conversion methods of measure and note\r\n * @private\r\n * @for p5.SoundLoop\r\n * @method _measure\r\n */\r\n p5.SoundLoop.prototype._measure = function(value) {\r\n return value * this._timeSignature;\r\n };\r\n\r\n /**\r\n * @private\r\n * @method _note\r\n * @for p5.SoundLoop\r\n */\r\n p5.SoundLoop.prototype._note = function(value) {\r\n return this._timeSignature / value ;\r\n };\r\n\r\n\r\n /**\r\n * Getters and Setters, setting any paramter will result in a change in the clock's\r\n * frequency, that will be reflected after the next callback\r\n * beats per minute (defaults to 60)\r\n * @property {Number} bpm\r\n * @for p5.SoundLoop\r\n */\r\n Object.defineProperty(p5.SoundLoop.prototype, 'bpm', {\r\n get : function() {\r\n return this._bpm;\r\n },\r\n set : function(bpm) {\r\n if (!this.musicalTimeMode) {\r\n console.warn('Changing the BPM in \"seconds\" mode has no effect. '+\r\n 'BPM is only relevant in musicalTimeMode '+\r\n 'when the interval is specified as a string '+\r\n '(\"2n\", \"4n\", \"1m\"...etc)');\r\n }\r\n this._bpm = bpm;\r\n this._update();\r\n }\r\n });\r\n\r\n /**\r\n * number of quarter notes in a measure (defaults to 4)\r\n * @property {Number} timeSignature\r\n * @for p5.SoundLoop\r\n */\r\n Object.defineProperty(p5.SoundLoop.prototype, 'timeSignature', {\r\n get : function() {\r\n return this._timeSignature;\r\n },\r\n set : function(timeSig) {\r\n if (!this.musicalTimeMode) {\r\n console.warn('Changing the timeSignature in \"seconds\" mode has no effect. '+\r\n 'BPM is only relevant in musicalTimeMode '+\r\n 'when the interval is specified as a string '+\r\n '(\"2n\", \"4n\", \"1m\"...etc)');\r\n }\r\n this._timeSignature = timeSig;\r\n this._update();\r\n }\r\n });\r\n\r\n /**\r\n * length of the loops interval\r\n * @property {Number|String} interval\r\n * @for p5.SoundLoop\r\n */\r\n Object.defineProperty(p5.SoundLoop.prototype, 'interval', {\r\n get : function() {\r\n return this._interval;\r\n },\r\n set : function(interval) {\r\n this.musicalTimeMode = typeof interval === 'Number'? false : true;\r\n this._interval = interval;\r\n this._update();\r\n }\r\n });\r\n\r\n /**\r\n * how many times the callback has been called so far\r\n * @property {Number} iterations\r\n * @for p5.SoundLoop\r\n * @readonly\r\n */\r\n Object.defineProperty(p5.SoundLoop.prototype, 'iterations', {\r\n get : function() {\r\n return this.clock.ticks;\r\n }\r\n });\r\n\r\n return p5.SoundLoop;\r\n});\r\n","define(function (require) {\r\n\t'use strict';\r\n\r\n\tvar p5sound = require('master');\r\n\tvar Effect = require('effect');\r\n var CustomError = require('errorHandler');\r\n\r\n /**\r\n * Compressor is an audio effect class that performs dynamics compression\r\n * on an audio input source. This is a very commonly used technique in music\r\n * and sound production. Compression creates an overall louder, richer,\r\n * and fuller sound by lowering the volume of louds and raising that of softs.\r\n * Compression can be used to avoid clipping (sound distortion due to\r\n * peaks in volume) and is especially useful when many sounds are played\r\n * at once. Compression can be used on indivudal sound sources in addition\r\n * to the master output.\r\n *\r\n * This class extends p5.Effect.\r\n * Methods amp(), chain(),\r\n * drywet(), connect(), and\r\n * disconnect() are available.\r\n *\r\n * @class p5.Compressor\r\n * @constructor\r\n * @extends p5.Effect\r\n *\r\n *\r\n */\r\n\tp5.Compressor = function() {\r\n\t\tEffect.call(this);\r\n\r\n /**\r\n * The p5.Compressor is built with a Web Audio Dynamics Compressor Node\r\n * \r\n * @property {AudioNode} compressor\r\n */\r\n\r\n\r\n\t\tthis.compressor = this.ac.createDynamicsCompressor();\r\n\r\n this.input.connect(this.compressor);\r\n this.compressor.connect(this.wet);\r\n\t};\r\n\r\n\tp5.Compressor.prototype = Object.create(Effect.prototype);\r\n\r\n /**\r\n * Performs the same function as .connect, but also accepts\r\n * optional parameters to set compressor's audioParams\r\n * @method process\r\n * @for p5.Compressor\r\n *\r\n * @param {Object} src Sound source to be connected\r\n *\r\n * @param {Number} [attack] The amount of time (in seconds) to reduce the gain by 10dB,\r\n * default = .003, range 0 - 1\r\n * @param {Number} [knee] A decibel value representing the range above the\r\n * threshold where the curve smoothly transitions to the \"ratio\" portion.\r\n * default = 30, range 0 - 40\r\n * @param {Number} [ratio] The amount of dB change in input for a 1 dB change in output\r\n * default = 12, range 1 - 20\r\n * @param {Number} [threshold] The decibel value above which the compression will start taking effect\r\n * default = -24, range -100 - 0\r\n * @param {Number} [release] The amount of time (in seconds) to increase the gain by 10dB\r\n * default = .25, range 0 - 1\r\n */\r\n\tp5.Compressor.prototype.process = function(src, attack, knee,\r\n ratio, threshold, release) {\r\n\t\tsrc.connect(this.input);\r\n\t\tthis.set(attack, knee, ratio, threshold, release);\r\n\t};\r\n\r\n /**\r\n * Set the paramters of a compressor.\r\n * @method set\r\n * @for p5.Compressor\r\n * @param {Number} attack The amount of time (in seconds) to reduce the gain by 10dB,\r\n * default = .003, range 0 - 1\r\n * @param {Number} knee A decibel value representing the range above the\r\n * threshold where the curve smoothly transitions to the \"ratio\" portion.\r\n * default = 30, range 0 - 40\r\n * @param {Number} ratio The amount of dB change in input for a 1 dB change in output\r\n * default = 12, range 1 - 20\r\n * @param {Number} threshold The decibel value above which the compression will start taking effect\r\n * default = -24, range -100 - 0\r\n * @param {Number} release The amount of time (in seconds) to increase the gain by 10dB\r\n * default = .25, range 0 - 1\r\n */\r\n p5.Compressor.prototype.set = function (attack, knee,\r\n ratio, threshold, release) {\r\n\r\n if (typeof attack !== 'undefined') {this.attack(attack);}\r\n if (typeof knee !== 'undefined') {this.knee(knee);}\r\n if (typeof ratio !== 'undefined') {this.ratio(ratio);}\r\n if (typeof threshold !== 'undefined') {this.threshold(threshold);}\r\n if (typeof release !== 'undefined') {this.release(release);}\r\n };\r\n\r\n\r\n /**\r\n * Get current attack or set value w/ time ramp\r\n *\r\n *\r\n * @method attack\r\n * @for p5.Compressor\r\n * @param {Number} [attack] Attack is the amount of time (in seconds) to reduce the gain by 10dB,\r\n * default = .003, range 0 - 1\r\n * @param {Number} [time] Assign time value to schedule the change in value\r\n */\r\n p5.Compressor.prototype.attack = function (attack, time){\r\n var t = time || 0;\r\n if (typeof attack == 'number'){\r\n this.compressor.attack.value = attack;\r\n this.compressor.attack.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.compressor.attack.linearRampToValueAtTime(attack, this.ac.currentTime + 0.02 + t);\r\n } else if (typeof attack !== 'undefined') {\r\n attack.connect(this.compressor.attack);\r\n }\r\n return this.compressor.attack.value;\r\n };\r\n\r\n\r\n /**\r\n * Get current knee or set value w/ time ramp\r\n *\r\n * @method knee\r\n * @for p5.Compressor\r\n * @param {Number} [knee] A decibel value representing the range above the\r\n * threshold where the curve smoothly transitions to the \"ratio\" portion.\r\n * default = 30, range 0 - 40\r\n * @param {Number} [time] Assign time value to schedule the change in value\r\n */\r\n p5.Compressor.prototype.knee = function (knee, time){\r\n var t = time || 0;\r\n if (typeof knee == 'number'){\r\n this.compressor.knee.value = knee;\r\n this.compressor.knee.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.compressor.knee.linearRampToValueAtTime(knee, this.ac.currentTime + 0.02 + t);\r\n } else if (typeof knee !== 'undefined') {\r\n knee.connect(this.compressor.knee);\r\n }\r\n return this.compressor.knee.value;\r\n };\r\n\r\n\r\n /**\r\n * Get current ratio or set value w/ time ramp\r\n * @method ratio\r\n * @for p5.Compressor\r\n * @param {Number} [ratio] The amount of dB change in input for a 1 dB change in output\r\n * default = 12, range 1 - 20\r\n * @param {Number} [time] Assign time value to schedule the change in value\r\n */\r\n p5.Compressor.prototype.ratio = function (ratio, time){\r\n var t = time || 0;\r\n if (typeof ratio == 'number'){\r\n this.compressor.ratio.value = ratio;\r\n this.compressor.ratio.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.compressor.ratio.linearRampToValueAtTime(ratio, this.ac.currentTime + 0.02 + t);\r\n } else if (typeof ratio !== 'undefined') {\r\n ratio.connect(this.compressor.ratio);\r\n }\r\n return this.compressor.ratio.value;\r\n };\r\n\r\n\r\n /**\r\n * Get current threshold or set value w/ time ramp\r\n * @method threshold\r\n * @for p5.Compressor\r\n * @param {Number} threshold The decibel value above which the compression will start taking effect\r\n * default = -24, range -100 - 0\r\n * @param {Number} [time] Assign time value to schedule the change in value\r\n */\r\n p5.Compressor.prototype.threshold = function (threshold, time){\r\n var t = time || 0;\r\n if (typeof threshold == 'number'){\r\n this.compressor.threshold.value = threshold;\r\n this.compressor.threshold.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.compressor.threshold.linearRampToValueAtTime(threshold, this.ac.currentTime + 0.02 + t);\r\n } else if (typeof threshold !== 'undefined') {\r\n threshold.connect(this.compressor.threshold);\r\n }\r\n return this.compressor.threshold.value;\r\n };\r\n\r\n\r\n /**\r\n * Get current release or set value w/ time ramp\r\n * @method release\r\n * @for p5.Compressor\r\n * @param {Number} release The amount of time (in seconds) to increase the gain by 10dB\r\n * default = .25, range 0 - 1\r\n *\r\n * @param {Number} [time] Assign time value to schedule the change in value\r\n */\r\n p5.Compressor.prototype.release = function (release, time){\r\n var t = time || 0;\r\n if (typeof release == 'number'){\r\n this.compressor.release.value = release;\r\n this.compressor.release.cancelScheduledValues(this.ac.currentTime + 0.01 + t);\r\n this.compressor.release.linearRampToValueAtTime(release, this.ac.currentTime + 0.02 + t);\r\n } else if (typeof number !== 'undefined') {\r\n release.connect(this.compressor.release);\r\n }\r\n return this.compressor.release.value;\r\n };\r\n\r\n /**\r\n * Return the current reduction value\r\n *\r\n * @method reduction\r\n * @for p5.Compressor\r\n * @return {Number} Value of the amount of gain reduction that is applied to the signal\r\n */\r\n p5.Compressor.prototype.reduction =function() {\r\n return this.compressor.reduction.value;\r\n };\r\n\r\n\r\n\tp5.Compressor.prototype.dispose = function() {\r\n Effect.prototype.dispose.apply(this);\r\n if (this.compressor) {\r\n this.compressor.disconnect();\r\n delete this.compressor;\r\n }\r\n\t};\r\n\r\n return p5.Compressor;\r\n});\r\n","'use strict';\r\n\r\ndefine(function (require) {\r\n\r\n // inspiration: recorder.js, Tone.js & typedarray.org\r\n\r\n const p5sound = require('master');\r\n const { convertToWav, safeBufferSize } = require('helpers');\r\n const processorNames = require('./audioWorklet/processorNames');\r\n const ac = p5sound.audiocontext;\r\n\r\n /**\r\n *

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

\r\n *

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

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

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

\r\n *

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

\r\n *

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

\r\n *\r\n *

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

\r\n *\r\n *

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

\r\n *\r\n *

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

\r\n *\r\n * @class p5.PeakDetect\r\n * @constructor\r\n * @param {Number} [freq1] lowFrequency - defaults to 20Hz\r\n * @param {Number} [freq2] highFrequency - defaults to 20000 Hz\r\n * @param {Number} [threshold] Threshold for detecting a beat between 0 and 1\r\n * scaled logarithmically where 0.1 is 1/2 the loudness\r\n * of 1.0. Defaults to 0.35.\r\n * @param {Number} [framesPerPeak] Defaults to 20.\r\n * @example\r\n *
\r\n *\r\n * var cnv, soundFile, fft, peakDetect;\r\n * var ellipseWidth = 10;\r\n *\r\n * function preload() {\r\n * soundFile = loadSound('assets/beat.mp3');\r\n * }\r\n *\r\n * function setup() {\r\n * background(0);\r\n * noStroke();\r\n * fill(255);\r\n * textAlign(CENTER);\r\n *\r\n * // p5.PeakDetect requires a p5.FFT\r\n * fft = new p5.FFT();\r\n * peakDetect = new p5.PeakDetect();\r\n * }\r\n *\r\n * function draw() {\r\n * background(0);\r\n * text('click to play/pause', width/2, height/2);\r\n *\r\n * // peakDetect accepts an fft post-analysis\r\n * fft.analyze();\r\n * peakDetect.update(fft);\r\n *\r\n * if ( peakDetect.isDetected ) {\r\n * ellipseWidth = 50;\r\n * } else {\r\n * ellipseWidth *= 0.95;\r\n * }\r\n *\r\n * ellipse(width/2, height/2, ellipseWidth, ellipseWidth);\r\n * }\r\n *\r\n * // toggle play/stop when canvas is clicked\r\n * function mouseClicked() {\r\n * if (mouseX > 0 && mouseX < width && mouseY > 0 && mouseY < height) {\r\n * if (soundFile.isPlaying() ) {\r\n * soundFile.stop();\r\n * } else {\r\n * soundFile.play();\r\n * }\r\n * }\r\n * }\r\n *
\r\n */\r\n p5.PeakDetect = function(freq1, freq2, threshold, _framesPerPeak) {\r\n // framesPerPeak determines how often to look for a beat.\r\n // If a beat is provided, try to look for a beat based on bpm\r\n this.framesPerPeak = _framesPerPeak || 20;\r\n this.framesSinceLastPeak = 0;\r\n this.decayRate = 0.95;\r\n\r\n this.threshold = threshold || 0.35;\r\n this.cutoff = 0;\r\n\r\n // how much to increase the cutoff\r\n // TO DO: document this / figure out how to make it accessible\r\n this.cutoffMult = 1.5;\r\n\r\n this.energy = 0;\r\n this.penergy = 0;\r\n\r\n // TO DO: document this property / figure out how to make it accessible\r\n this.currentValue = 0;\r\n\r\n /**\r\n * isDetected is set to true when a peak is detected.\r\n *\r\n * @attribute isDetected {Boolean}\r\n * @default false\r\n */\r\n this.isDetected = false;\r\n\r\n this.f1 = freq1 || 40;\r\n this.f2 = freq2 || 20000;\r\n\r\n // function to call when a peak is detected\r\n this._onPeak = function() {};\r\n };\r\n\r\n\r\n /**\r\n * The update method is run in the draw loop.\r\n *\r\n * Accepts an FFT object. You must call .analyze()\r\n * on the FFT object prior to updating the peakDetect\r\n * because it relies on a completed FFT analysis.\r\n *\r\n * @method update\r\n * @param {p5.FFT} fftObject A p5.FFT object\r\n */\r\n p5.PeakDetect.prototype.update = function(fftObject) {\r\n var nrg = this.energy = fftObject.getEnergy(this.f1,this.f2)/255;\r\n if (nrg > this.cutoff && nrg > this.threshold && nrg-this.penergy > 0) {\r\n\r\n // trigger callback\r\n this._onPeak();\r\n this.isDetected = true;\r\n\r\n // debounce\r\n this.cutoff = nrg * this.cutoffMult;\r\n this.framesSinceLastPeak = 0;\r\n } else {\r\n this.isDetected = false;\r\n if (this.framesSinceLastPeak <= this.framesPerPeak) {\r\n this.framesSinceLastPeak++;\r\n } else {\r\n this.cutoff *= this.decayRate;\r\n this.cutoff = Math.max(this.cutoff, this.threshold);\r\n }\r\n }\r\n\r\n this.currentValue = nrg;\r\n this.penergy = nrg;\r\n };\r\n\r\n /**\r\n * onPeak accepts two arguments: a function to call when\r\n * a peak is detected. The value of the peak,\r\n * between 0.0 and 1.0, is passed to the callback.\r\n *\r\n * @method onPeak\r\n * @param {Function} callback Name of a function that will\r\n * be called when a peak is\r\n * detected.\r\n * @param {Object} [val] Optional value to pass\r\n * into the function when\r\n * a peak is detected.\r\n * @example\r\n *
\r\n * var cnv, soundFile, fft, peakDetect;\r\n * var ellipseWidth = 0;\r\n *\r\n * function preload() {\r\n * soundFile = loadSound('assets/beat.mp3');\r\n * }\r\n *\r\n * function setup() {\r\n * cnv = createCanvas(100,100);\r\n * textAlign(CENTER);\r\n *\r\n * fft = new p5.FFT();\r\n * peakDetect = new p5.PeakDetect();\r\n *\r\n * setupSound();\r\n *\r\n * // when a beat is detected, call triggerBeat()\r\n * peakDetect.onPeak(triggerBeat);\r\n * }\r\n *\r\n * function draw() {\r\n * background(0);\r\n * fill(255);\r\n * text('click to play', width/2, height/2);\r\n *\r\n * fft.analyze();\r\n * peakDetect.update(fft);\r\n *\r\n * ellipseWidth *= 0.95;\r\n * ellipse(width/2, height/2, ellipseWidth, ellipseWidth);\r\n * }\r\n *\r\n * // this function is called by peakDetect.onPeak\r\n * function triggerBeat() {\r\n * ellipseWidth = 50;\r\n * }\r\n *\r\n * // mouseclick starts/stops sound\r\n * function setupSound() {\r\n * cnv.mouseClicked( function() {\r\n * if (soundFile.isPlaying() ) {\r\n * soundFile.stop();\r\n * } else {\r\n * soundFile.play();\r\n * }\r\n * });\r\n * }\r\n *
\r\n */\r\n p5.PeakDetect.prototype.onPeak = function(callback, val) {\r\n var self = this;\r\n\r\n self._onPeak = function() {\r\n callback(self.energy, val);\r\n };\r\n };\r\n\r\n});\r\n","'use strict';\r\n\r\ndefine(function (require) {\r\n var p5sound = require('master');\r\n\r\n /**\r\n * A gain node is usefull to set the relative volume of sound.\r\n * It's typically used to build mixers.\r\n *\r\n * @class p5.Gain\r\n * @constructor\r\n * @example\r\n *
\r\n *\r\n * // load two soundfile and crossfade beetween them\r\n * let sound1,sound2;\r\n * let sound1Gain, sound2Gain, masterGain;\r\n * function preload(){\r\n * soundFormats('ogg', 'mp3');\r\n * sound1 = loadSound('assets/Damscray_-_Dancing_Tiger_01');\r\n * sound2 = loadSound('assets/beat');\r\n * }\r\n * function setup() {\r\n * let cnv = createCanvas(100, 100);\r\n * cnv.mousePressed(startSound);\r\n * // create a 'master' gain to which we will connect both soundfiles\r\n * masterGain = new p5.Gain();\r\n * masterGain.connect();\r\n * sound1.disconnect(); // diconnect from p5 output\r\n * sound1Gain = new p5.Gain(); // setup a gain node\r\n * sound1Gain.setInput(sound1); // connect the first sound to its input\r\n * sound1Gain.connect(masterGain); // connect its output to the 'master'\r\n * sound2.disconnect();\r\n * sound2Gain = new p5.Gain();\r\n * sound2Gain.setInput(sound2);\r\n * sound2Gain.connect(masterGain);\r\n * }\r\n * function startSound() {\r\n * sound1.loop();\r\n * sound2.loop();\r\n * loop();\r\n * }\r\n * function mouseReleased() {\r\n * sound1.stop();\r\n * sound2.stop();\r\n * }\r\n * function draw(){\r\n * background(220);\r\n * textAlign(CENTER);\r\n * textSize(11);\r\n * fill(0);\r\n * if (!sound1.isPlaying()) {\r\n * text('tap and drag to play', width/2, height/2);\r\n * return;\r\n * }\r\n * // map the horizontal position of the mouse to values useable for volume * control of sound1\r\n * var sound1Volume = constrain(map(mouseX,width,0,0,1), 0, 1);\r\n * var sound2Volume = 1-sound1Volume;\r\n * sound1Gain.amp(sound1Volume);\r\n * sound2Gain.amp(sound2Volume);\r\n * // map the vertical position of the mouse to values useable for 'master * volume control'\r\n * var masterVolume = constrain(map(mouseY,height,0,0,1), 0, 1);\r\n * masterGain.amp(masterVolume);\r\n * text('master', width/2, height - masterVolume * height * 0.9)\r\n * fill(255, 0, 255);\r\n * textAlign(LEFT);\r\n * text('sound1', 5, height - sound1Volume * height * 0.9);\r\n * textAlign(RIGHT);\r\n * text('sound2', width - 5, height - sound2Volume * height * 0.9);\r\n * }\r\n *
\r\n */\r\n\r\n p5.Gain = function() {\r\n this.ac = p5sound.audiocontext;\r\n\r\n this.input = this.ac.createGain();\r\n this.output = this.ac.createGain();\r\n\r\n // otherwise, Safari distorts\r\n this.input.gain.value = 0.5;\r\n this.input.connect(this.output);\r\n\r\n // add to the soundArray\r\n p5sound.soundArray.push(this);\r\n };\r\n\r\n /**\r\n * Connect a source to the gain node.\r\n *\r\n * @method setInput\r\n * @for p5.Gain\r\n * @param {Object} src p5.sound / Web Audio object with a sound\r\n * output.\r\n */\r\n\r\n\r\n p5.Gain.prototype.setInput = function(src) {\r\n src.connect(this.input);\r\n };\r\n\r\n /**\r\n * Send output to a p5.sound or web audio object\r\n *\r\n * @method connect\r\n * @for p5.Gain\r\n * @param {Object} unit\r\n */\r\n p5.Gain.prototype.connect = function(unit) {\r\n var u = unit || p5.soundOut.input;\r\n this.output.connect(u.input ? u.input : u);\r\n };\r\n\r\n /**\r\n * Disconnect all output.\r\n *\r\n * @method disconnect\r\n * @for p5.Gain\r\n */\r\n p5.Gain.prototype.disconnect = function() {\r\n if (this.output) {\r\n this.output.disconnect();\r\n }\r\n };\r\n\r\n /**\r\n * Set the output level of the gain node.\r\n *\r\n * @method amp\r\n * @for p5.Gain\r\n * @param {Number} volume amplitude between 0 and 1.0\r\n * @param {Number} [rampTime] create a fade that lasts rampTime\r\n * @param {Number} [timeFromNow] schedule this event to happen\r\n * seconds from now\r\n */\r\n p5.Gain.prototype.amp = function(vol, rampTime, tFromNow) {\r\n var rampTime = rampTime || 0;\r\n var tFromNow = tFromNow || 0;\r\n var now = p5sound.audiocontext.currentTime;\r\n var currentVol = this.output.gain.value;\r\n this.output.gain.cancelScheduledValues(now);\r\n this.output.gain.linearRampToValueAtTime(currentVol, now + tFromNow);\r\n this.output.gain.linearRampToValueAtTime(vol, now + tFromNow + rampTime);\r\n };\r\n\r\n p5.Gain.prototype.dispose = function() {\r\n // remove reference from soundArray\r\n var index = p5sound.soundArray.indexOf(this);\r\n p5sound.soundArray.splice(index, 1);\r\n if (this.output) {\r\n this.output.disconnect();\r\n delete this.output;\r\n }\r\n if (this.input) {\r\n this.input.disconnect();\r\n delete this.input;\r\n }\r\n };\r\n\r\n});\r\n","'use strict';\r\n\r\ndefine(function (require) {\r\n\r\n var Effect = require('effect');\r\n\r\n /*\r\n * Adapted from [Kevin Ennis on StackOverflow](http://stackoverflow.com/questions/22312841/waveshaper-node-in-webaudio-how-to-emulate-distortion)\r\n */\r\n function makeDistortionCurve(amount) {\r\n var k = typeof amount === 'number' ? amount : 50;\r\n var numSamples = 44100;\r\n var curve = new Float32Array(numSamples);\r\n var deg = Math.PI / 180;\r\n var i = 0;\r\n var x;\r\n for ( ; i < numSamples; ++i ) {\r\n x = i * 2 / numSamples - 1;\r\n curve[i] = ( 3 + k ) * x * 20 * deg / ( Math.PI + k * Math.abs(x) );\r\n }\r\n return curve;\r\n }\r\n\r\n /**\r\n * A Distortion effect created with a Waveshaper Node,\r\n * with an approach adapted from\r\n * [Kevin Ennis](http://stackoverflow.com/questions/22312841/waveshaper-node-in-webaudio-how-to-emulate-distortion)\r\n *\r\n * This class extends p5.Effect.\r\n * Methods amp(), chain(),\r\n * drywet(), connect(), and\r\n * disconnect() are available.\r\n *\r\n * @class p5.Distortion\r\n * @extends p5.Effect\r\n * @constructor\r\n * @param {Number} [amount=0.25] Unbounded distortion amount.\r\n * Normal values range from 0-1.\r\n * @param {String} [oversample='none'] 'none', '2x', or '4x'.\r\n *\r\n */\r\n p5.Distortion = function(amount, oversample) {\r\n Effect.call(this);\r\n\r\n if (typeof amount === 'undefined') {\r\n amount = 0.25;\r\n } if (typeof amount !== 'number') {\r\n throw new Error('amount must be a number');\r\n } if (typeof oversample === 'undefined') {\r\n oversample = '2x';\r\n } if (typeof oversample !== 'string') {\r\n throw new Error('oversample must be a String');\r\n }\r\n\r\n var curveAmount = p5.prototype.map(amount, 0.0, 1.0, 0, 2000);\r\n\r\n /**\r\n * The p5.Distortion is built with a\r\n * \r\n * Web Audio WaveShaper Node.\r\n *\r\n * @property {AudioNode} WaveShaperNode\r\n */\r\n this.waveShaperNode = this.ac.createWaveShaper();\r\n\r\n this.amount = curveAmount;\r\n this.waveShaperNode.curve = makeDistortionCurve(curveAmount);\r\n this.waveShaperNode.oversample = oversample;\r\n\r\n this.input.connect(this.waveShaperNode);\r\n\r\n this.waveShaperNode.connect(this.wet);\r\n };\r\n\r\n p5.Distortion.prototype = Object.create(Effect.prototype);\r\n\r\n\r\n /**\r\n * Process a sound source, optionally specify amount and oversample values.\r\n *\r\n * @method process\r\n * @for p5.Distortion\r\n * @param {Number} [amount=0.25] Unbounded distortion amount.\r\n * Normal values range from 0-1.\r\n * @param {String} [oversample='none'] 'none', '2x', or '4x'.\r\n */\r\n p5.Distortion.prototype.process = function(src, amount, oversample) {\r\n src.connect(this.input);\r\n this.set(amount, oversample);\r\n };\r\n\r\n /**\r\n * Set the amount and oversample of the waveshaper distortion.\r\n *\r\n * @method set\r\n * @for p5.Distortion\r\n * @param {Number} [amount=0.25] Unbounded distortion amount.\r\n * Normal values range from 0-1.\r\n * @param {String} [oversample='none'] 'none', '2x', or '4x'.\r\n */\r\n p5.Distortion.prototype.set = function(amount, oversample) {\r\n if (amount) {\r\n var curveAmount = p5.prototype.map(amount, 0.0, 1.0, 0, 2000);\r\n this.amount = curveAmount;\r\n this.waveShaperNode.curve = makeDistortionCurve(curveAmount);\r\n }\r\n if (oversample) {\r\n this.waveShaperNode.oversample = oversample;\r\n }\r\n };\r\n\r\n /**\r\n * Return the distortion amount, typically between 0-1.\r\n *\r\n * @method getAmount\r\n * @for p5.Distortion\r\n * @return {Number} Unbounded distortion amount.\r\n * Normal values range from 0-1.\r\n */\r\n p5.Distortion.prototype.getAmount = function() {\r\n return this.amount;\r\n };\r\n\r\n /**\r\n * Return the oversampling.\r\n *\r\n * @method getOversample\r\n * @for p5.Distortion\r\n * @return {String} Oversample can either be 'none', '2x', or '4x'.\r\n */\r\n p5.Distortion.prototype.getOversample = function() {\r\n return this.waveShaperNode.oversample;\r\n };\r\n\r\n\r\n p5.Distortion.prototype.dispose = function() {\r\n Effect.prototype.dispose.apply(this);\r\n if (this.waveShaperNode) {\r\n this.waveShaperNode.disconnect();\r\n this.waveShaperNode = null;\r\n }\r\n };\r\n});\r\n"],"sourceRoot":""} \ No newline at end of file diff --git a/package.json b/package.json index ed1554ac..fcf15aaa 100644 --- a/package.json +++ b/package.json @@ -4,7 +4,7 @@ "type": "git", "url": "https://github.com/processing/p5.js-sound.git" }, - "version": "0.3.12", + "version": "0.3.13", "license": "MIT", "devDependencies": { "@babel/core": "^7.4.5", diff --git a/src/looper.js b/src/looper.js index 4e0ca755..b3d74e54 100644 --- a/src/looper.js +++ b/src/looper.js @@ -405,11 +405,6 @@ define(function(require) { if (this.looping) { // this.resetParts(); this.parts[0].start(); - } else { - this.parts[this.parts.length - 1].onended = function() { - this.stop(); - this.resetParts(); - }; } this.currentPart = 0; }; From b05331add62ed389cc2504f3c4bc51f8564826b5 Mon Sep 17 00:00:00 2001 From: dori Date: Sat, 11 Apr 2020 15:32:53 -0400 Subject: [PATCH 3/3] score with two args failed on last version --- examples/files/tick.mp3 | Bin 0 -> 11284 bytes examples/playScore/index.html | 10 +++++++ examples/playScore/sketch.js | 51 ++++++++++++++++++++++++++++++++++ index.html | 1 + 4 files changed, 62 insertions(+) create mode 100644 examples/files/tick.mp3 create mode 100644 examples/playScore/index.html create mode 100644 examples/playScore/sketch.js diff --git a/examples/files/tick.mp3 b/examples/files/tick.mp3 new file mode 100644 index 0000000000000000000000000000000000000000..fa11e926f3211b95910e2ce061f65b28960e088e GIT binary patch literal 11284 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 KzuW&s;Qs*q+QnP| literal 0 HcmV?d00001 diff --git a/examples/playScore/index.html b/examples/playScore/index.html new file mode 100644 index 00000000..6ec1957c --- /dev/null +++ b/examples/playScore/index.html @@ -0,0 +1,10 @@ + + + + + + + + + + diff --git a/examples/playScore/sketch.js b/examples/playScore/sketch.js new file mode 100644 index 00000000..4e1edbb6 --- /dev/null +++ b/examples/playScore/sketch.js @@ -0,0 +1,51 @@ +/* eslint-disable strict */ +let mypart, score, cnv, tick; + +function preload() { + tick = loadSound('../files/tick.mp3'); +} + +function setup() { + cnv = createCanvas(400, 400); + textAlign(CENTER); + cnv.mousePressed(playOneTime); + cnv.doubleClicked(playMeTwice); + + mypart = new p5.Part(4, 1/4); + + tick.pattern = [1, 2, 3, 4]; + tick.phrase = new p5.Phrase('metro', playTick, tick.pattern ); + mypart.addPhrase(tick.phrase); +} + +function playMeTwice() { + userStartAudio(); + score = new p5.Score(mypart, mypart); + score.setBPM(55); + score.start(); +} + +function playOneTime() { + userStartAudio(); + score = new p5.Score(mypart); + score.setBPM(55); + score.start(); +} + +function draw() { + background(33); + textSize(32); + fill(255); + text('click to play once', width/2, height/2-25); + text('double-click to play twice', width/2, height/2+25); +} + +function playMyPart() { + userStartAudio(); + score.start(); +} + +function playTick(time) { + tick.play(time); +} + diff --git a/index.html b/index.html index c2ec3ff3..e7c6dc9d 100644 --- a/index.html +++ b/index.html @@ -69,6 +69,7 @@

p5.sound +