Last active
July 7, 2017 01:58
-
-
Save softpunch/e008b13b9a8a278666dc6b6efc363b20 to your computer and use it in GitHub Desktop.
Ramps/Oscillators
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| // snippets from @mohayonao's pure js implementation of web audio api | |
| // https://github.com/mohayonao/web-audio-engine/ | |
| // https://github.com/mohayonao/web-audio-engine/blob/master/build/web-audio-engine.js | |
| // basic constructors | |
| // audio scheduled source node | |
| },{"../impl":126,"../utils":135}],31:[function(require,module,exports){ | |
| "use strict"; | |
| var _createClass = function () { function 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); | |
| function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } | |
| function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } | |
| function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } | |
| var impl = require("../impl"); | |
| var AudioScheduledSourceNode = require("./AudioScheduledSourceNode"); | |
| var AudioParam = require("./AudioParam"); | |
| var AudioBufferSourceNode = function (_AudioScheduledSource) { | |
| _inherits(AudioBufferSourceNode, _AudioScheduledSource); | |
| function AudioBufferSourceNode(context, opts) { | |
| _classCallCheck(this, AudioBufferSourceNode); | |
| var _this = _possibleConstructorReturn(this, (AudioBufferSourceNode.__proto__ || Object.getPrototypeOf(AudioBufferSourceNode)).call(this, context)); | |
| _this._impl = new impl.AudioBufferSourceNode(context._impl, opts); | |
| _this._impl.$playbackRate = new AudioParam(context, _this._impl.getPlaybackRate()); | |
| _this._impl.$detune = new AudioParam(context, _this._impl.getDetune()); | |
| _this._impl.$buffer = null; | |
| _this._impl.$onended = null; | |
| if (opts && opts.buffer) { | |
| _this.buffer = opts.buffer; | |
| } | |
| return _this; | |
| } | |
| _createClass(AudioBufferSourceNode, [{ | |
| key: "start", | |
| value: function start(when, offset, duration) { | |
| this._impl.start(when, offset, duration); | |
| } | |
| }, { | |
| key: "buffer", | |
| get: function get() { | |
| return this._impl.$buffer; | |
| }, | |
| set: function set(value) { | |
| this._impl.$buffer = value; | |
| this._impl.setBuffer(value); | |
| } | |
| }, { | |
| key: "playbackRate", | |
| get: function get() { | |
| return this._impl.$playbackRate; | |
| } | |
| }, { | |
| key: "detune", | |
| get: function get() { | |
| return this._impl.$detune; | |
| } | |
| }, { | |
| key: "loop", | |
| get: function get() { | |
| return this._impl.getLoop(); | |
| }, | |
| set: function set(value) { | |
| this._impl.setLoop(value); | |
| } | |
| }, { | |
| key: "loopStart", | |
| get: function get() { | |
| return this._impl.getLoopStart(); | |
| }, | |
| set: function set(value) { | |
| this._impl.setLoopStart(value); | |
| } | |
| }, { | |
| key: "loopEnd", | |
| get: function get() { | |
| return this._impl.getLoopEnd(); | |
| }, | |
| set: function set(value) { | |
| this._impl.setLoopEnd(value); | |
| } | |
| }]); | |
| return AudioBufferSourceNode; | |
| }(AudioScheduledSourceNode); | |
| module.exports = AudioBufferSourceNode; | |
| },{"../impl":126,"./AudioParam":35,"./AudioScheduledSourceNode":36}],32:[function(require,module,exports){ | |
| "use strict"; | |
| // | |
| // | |
| // | |
| // | |
| // AudioParam | |
| },{"../utils":135,"./EventTarget":45}],35:[function(require,module,exports){ | |
| "use strict"; | |
| var _createClass = function () { function 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); | |
| function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } | |
| var _require = require("../utils"), | |
| defineProp = _require.defineProp; | |
| var AudioParam = function () { | |
| function AudioParam(context, impl) { | |
| _classCallCheck(this, AudioParam); | |
| defineProp(this, "_context", context); | |
| defineProp(this, "_impl", impl); | |
| } | |
| _createClass(AudioParam, [{ | |
| key: "setValueAtTime", | |
| value: function setValueAtTime(value, startTime) { | |
| this._impl.setValueAtTime(value, startTime); | |
| return this; | |
| } | |
| }, { | |
| key: "linearRampToValueAtTime", | |
| value: function linearRampToValueAtTime(value, endTime) { | |
| this._impl.linearRampToValueAtTime(value, endTime); | |
| return this; | |
| } | |
| }, { | |
| key: "exponentialRampToValueAtTime", | |
| value: function exponentialRampToValueAtTime(value, endTime) { | |
| this._impl.exponentialRampToValueAtTime(value, endTime); | |
| return this; | |
| } | |
| }, { | |
| key: "setTargetAtTime", | |
| value: function setTargetAtTime(target, startTime, timeConstant) { | |
| this._impl.setTargetAtTime(target, startTime, timeConstant); | |
| return this; | |
| } | |
| }, { | |
| key: "setValueCurveAtTime", | |
| value: function setValueCurveAtTime(values, startTime, duration) { | |
| this._impl.setValueCurveAtTime(values, startTime, duration); | |
| return this; | |
| } | |
| }, { | |
| key: "cancelScheduledValues", | |
| value: function cancelScheduledValues(startTime) { | |
| this._impl.cancelScheduledValues(startTime); | |
| return this; | |
| } | |
| }, { | |
| key: "value", | |
| get: function get() { | |
| return this._impl.getValue(); | |
| }, | |
| set: function set(value) { | |
| this._impl.setValue(value); | |
| } | |
| }, { | |
| key: "defaultValue", | |
| get: function get() { | |
| return this._impl.getDefaultValue(); | |
| } | |
| }]); | |
| return AudioParam; | |
| }(); | |
| module.exports = AudioParam; | |
| // | |
| // | |
| // | |
| // | |
| // oscillator | |
| },{"../impl":126,"./AudioNode":34}],48:[function(require,module,exports){ | |
| "use strict"; | |
| var _createClass = function () { function 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); | |
| function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } | |
| function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } | |
| function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } | |
| var impl = require("../impl"); | |
| var AudioScheduledSourceNode = require("./AudioScheduledSourceNode"); | |
| var AudioParam = require("./AudioParam"); | |
| var OscillatorNode = function (_AudioScheduledSource) { | |
| _inherits(OscillatorNode, _AudioScheduledSource); | |
| function OscillatorNode(context, opts) { | |
| _classCallCheck(this, OscillatorNode); | |
| var _this = _possibleConstructorReturn(this, (OscillatorNode.__proto__ || Object.getPrototypeOf(OscillatorNode)).call(this, context)); | |
| _this._impl = new impl.OscillatorNode(context._impl, opts); | |
| _this._impl.$frequency = new AudioParam(context, _this._impl.getFrequency()); | |
| _this._impl.$detune = new AudioParam(context, _this._impl.getDetune()); | |
| _this._impl.$onended = null; | |
| if (opts && opts.periodicWave) { | |
| _this.setPeriodicWave(opts.periodicWave); | |
| } | |
| return _this; | |
| } | |
| _createClass(OscillatorNode, [{ | |
| key: "setPeriodicWave", | |
| value: function setPeriodicWave(periodicWave) { | |
| this._impl.setPeriodicWave(periodicWave); | |
| } | |
| }, { | |
| key: "type", | |
| get: function get() { | |
| return this._impl.getType(); | |
| }, | |
| set: function set(value) { | |
| this._impl.setType(value); | |
| } | |
| }, { | |
| key: "frequency", | |
| get: function get() { | |
| return this._impl.$frequency; | |
| } | |
| }, { | |
| key: "detune", | |
| get: function get() { | |
| return this._impl.$detune; | |
| } | |
| }]); | |
| return OscillatorNode; | |
| }(AudioScheduledSourceNode); | |
| module.exports = OscillatorNode; | |
| // | |
| // | |
| // | |
| // | |
| // basic context parameters | |
| module.exports = { | |
| MIN_SAMPLERATE: 3000, | |
| MAX_SAMPLERATE: 192000, | |
| MIN_NUMBER_OF_CHANNELS: 1, | |
| MAX_NUMBER_OF_CHANNELS: 32, | |
| MIN_BLOCK_SIZE: 8, | |
| MAX_BLOCK_SIZE: 1024 | |
| }; | |
| // | |
| // | |
| // | |
| // | |
| // AudioParam Details | |
| },{"../constants":66,"../constants/ChannelCountMode":62,"../constants/ChannelInterpretation":63,"../utils":135,"./AudioParam":80,"./EventTarget":91,"./core/AudioNodeInput":103,"./core/AudioNodeOutput":104}],80:[function(require,module,exports){ | |
| "use strict"; | |
| var _createClass = function () { function 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); | |
| function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } | |
| var AudioNodeInput = require("./core/AudioNodeInput"); | |
| var AudioBus = require("./core/AudioBus"); | |
| var AudioParamDSP = require("./dsp/AudioParam"); | |
| var _require = require("../utils"), | |
| defaults = _require.defaults; | |
| var _require2 = require("../utils"), | |
| toNumber = _require2.toNumber; | |
| var _require3 = require("../constants/ChannelCountMode"), | |
| EXPLICIT = _require3.EXPLICIT; | |
| var _require4 = require("../constants/AudioParamRate"), | |
| CONTROL_RATE = _require4.CONTROL_RATE; | |
| var _require5 = require("../constants/AudioParamEvent"), | |
| SET_VALUE_AT_TIME = _require5.SET_VALUE_AT_TIME; | |
| var _require6 = require("../constants/AudioParamEvent"), | |
| LINEAR_RAMP_TO_VALUE_AT_TIME = _require6.LINEAR_RAMP_TO_VALUE_AT_TIME; | |
| var _require7 = require("../constants/AudioParamEvent"), | |
| EXPONENTIAL_RAMP_TO_VALUE_AT_TIME = _require7.EXPONENTIAL_RAMP_TO_VALUE_AT_TIME; | |
| var _require8 = require("../constants/AudioParamEvent"), | |
| SET_TARGET_AT_TIME = _require8.SET_TARGET_AT_TIME; | |
| var _require9 = require("../constants/AudioParamEvent"), | |
| SET_VALUE_CURVE_AT_TIME = _require9.SET_VALUE_CURVE_AT_TIME; | |
| /** | |
| * @prop {AudioContext} context | |
| * @prop {number} blockSize | |
| * @prop {number} sampleRate | |
| * @prop {AudioNodeInput[]} inputs | |
| * @prop {AudioBus} outputBus | |
| */ | |
| var AudioParam = function () { | |
| /** | |
| * @param {AudioContext} context | |
| * @param {string} opts.rate - [ AUDIO_RATE, CONTROL_RATE ] | |
| * @param {number} opts.defaultValue | |
| */ | |
| function AudioParam(context) { | |
| var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; | |
| _classCallCheck(this, AudioParam); | |
| var rate = defaults(opts.rate, CONTROL_RATE); | |
| var defaultValue = defaults(opts.defaultValue, 0); | |
| this.context = context; | |
| this.blockSize = context.blockSize; | |
| this.sampleRate = context.sampleRate; | |
| this.inputs = [new AudioNodeInput({ | |
| node: this, | |
| index: 0, | |
| numberOfChannels: 1, | |
| channelCount: 1, | |
| channelCountMode: EXPLICIT | |
| })]; | |
| this.outputBus = new AudioBus(1, this.blockSize, this.sampleRate); | |
| this._rate = rate; | |
| this._defaultValue = toNumber(defaultValue); | |
| this._value = this._defaultValue; | |
| this._userValue = this._value; | |
| this._timeline = []; | |
| this.dspInit(this._rate); | |
| } | |
| /** | |
| * @return {number} | |
| */ | |
| _createClass(AudioParam, [{ | |
| key: "getValue", | |
| value: function getValue() { | |
| return this._value; | |
| } | |
| /** | |
| * @param {number} value | |
| */ | |
| }, { | |
| key: "setValue", | |
| value: function setValue(value) { | |
| this._value = this._userValue = toNumber(value); | |
| } | |
| /** | |
| * @return {number} | |
| */ | |
| }, { | |
| key: "getDefaultValue", | |
| value: function getDefaultValue() { | |
| return this._defaultValue; | |
| } | |
| /** | |
| * @param {number} value | |
| * @param {number} startTime | |
| */ | |
| }, { | |
| key: "setValueAtTime", | |
| value: function setValueAtTime(value, startTime) { | |
| value = toNumber(value); | |
| startTime = Math.max(0, toNumber(startTime)); | |
| var eventItem = { | |
| type: SET_VALUE_AT_TIME, | |
| time: startTime, | |
| args: [value, startTime], | |
| startFrame: Math.round(startTime * this.sampleRate), | |
| endFrame: Infinity, | |
| startValue: value, | |
| endValue: value | |
| }; | |
| var index = this.insertEvent(eventItem); | |
| var prevEventItem = this._timeline[index - 1]; | |
| var nextEventItem = this._timeline[index + 1]; | |
| if (prevEventItem) { | |
| switch (prevEventItem.type) { | |
| case SET_VALUE_AT_TIME: | |
| case SET_TARGET_AT_TIME: | |
| prevEventItem.endFrame = eventItem.startFrame; | |
| break; | |
| } | |
| } | |
| if (nextEventItem) { | |
| switch (nextEventItem.type) { | |
| case LINEAR_RAMP_TO_VALUE_AT_TIME: | |
| case EXPONENTIAL_RAMP_TO_VALUE_AT_TIME: | |
| nextEventItem.startFrame = eventItem.startFrame; | |
| nextEventItem.startValue = eventItem.startValue; | |
| break; | |
| } | |
| eventItem.endFrame = nextEventItem.startFrame; | |
| } | |
| if (index <= this._currentEventIndex) { | |
| this._currentEventIndex = index; | |
| this._remainSamples = 0; | |
| } | |
| } | |
| /** | |
| * @param {number} value | |
| * @param {number} endTime | |
| */ | |
| }, { | |
| key: "linearRampToValueAtTime", | |
| value: function linearRampToValueAtTime(value, endTime) { | |
| value = toNumber(value); | |
| endTime = Math.max(0, toNumber(endTime)); | |
| var eventItem = { | |
| type: LINEAR_RAMP_TO_VALUE_AT_TIME, | |
| time: endTime, | |
| args: [value, endTime], | |
| startFrame: 0, | |
| endFrame: Math.round(endTime * this.sampleRate), | |
| startValue: this._defaultValue, | |
| endValue: value | |
| }; | |
| var index = this.insertEvent(eventItem); | |
| var prevEventItem = this._timeline[index - 1]; | |
| var nextEventItem = this._timeline[index + 1]; | |
| if (prevEventItem) { | |
| switch (prevEventItem.type) { | |
| case SET_VALUE_AT_TIME: | |
| case SET_TARGET_AT_TIME: | |
| eventItem.startFrame = prevEventItem.startFrame; | |
| eventItem.startValue = prevEventItem.startValue; | |
| prevEventItem.endFrame = eventItem.startFrame; | |
| break; | |
| case LINEAR_RAMP_TO_VALUE_AT_TIME: | |
| case EXPONENTIAL_RAMP_TO_VALUE_AT_TIME: | |
| case SET_VALUE_CURVE_AT_TIME: | |
| eventItem.startFrame = prevEventItem.endFrame; | |
| eventItem.startValue = prevEventItem.endValue; | |
| break; | |
| } | |
| } | |
| if (nextEventItem) { | |
| switch (nextEventItem.type) { | |
| case LINEAR_RAMP_TO_VALUE_AT_TIME: | |
| case EXPONENTIAL_RAMP_TO_VALUE_AT_TIME: | |
| nextEventItem.startFrame = eventItem.endFrame; | |
| nextEventItem.startValue = eventItem.endValue; | |
| break; | |
| } | |
| } | |
| if (index <= this._currentEventIndex) { | |
| this._currentEventIndex = index; | |
| this._remainSamples = 0; | |
| } | |
| } | |
| /** | |
| * @param {number} value | |
| * @param {number} endTime | |
| */ | |
| }, { | |
| key: "exponentialRampToValueAtTime", | |
| value: function exponentialRampToValueAtTime(value, endTime) { | |
| value = Math.max(1e-6, toNumber(value)); | |
| endTime = Math.max(0, toNumber(endTime)); | |
| var eventItem = { | |
| type: EXPONENTIAL_RAMP_TO_VALUE_AT_TIME, | |
| time: endTime, | |
| args: [value, endTime], | |
| startFrame: 0, | |
| endFrame: Math.round(endTime * this.sampleRate), | |
| startValue: Math.max(1e-6, this._defaultValue), | |
| endValue: value | |
| }; | |
| var index = this.insertEvent(eventItem); | |
| var prevEventItem = this._timeline[index - 1]; | |
| var nextEventItem = this._timeline[index + 1]; | |
| if (prevEventItem) { | |
| switch (prevEventItem.type) { | |
| case SET_VALUE_AT_TIME: | |
| case SET_TARGET_AT_TIME: | |
| eventItem.startFrame = prevEventItem.startFrame; | |
| eventItem.startValue = prevEventItem.startValue; | |
| prevEventItem.endFrame = eventItem.startFrame; | |
| break; | |
| case LINEAR_RAMP_TO_VALUE_AT_TIME: | |
| case EXPONENTIAL_RAMP_TO_VALUE_AT_TIME: | |
| case SET_VALUE_CURVE_AT_TIME: | |
| eventItem.startFrame = prevEventItem.endFrame; | |
| eventItem.startValue = prevEventItem.endValue; | |
| break; | |
| } | |
| } | |
| if (nextEventItem) { | |
| switch (nextEventItem.type) { | |
| case LINEAR_RAMP_TO_VALUE_AT_TIME: | |
| case EXPONENTIAL_RAMP_TO_VALUE_AT_TIME: | |
| nextEventItem.startFrame = eventItem.endFrame; | |
| nextEventItem.startValue = eventItem.endValue; | |
| break; | |
| } | |
| } | |
| if (index <= this._currentEventIndex) { | |
| this._currentEventIndex = index; | |
| this._remainSamples = 0; | |
| } | |
| } | |
| /** | |
| * @param {number} target | |
| * @param {number} startTime | |
| * @param {number} timeConstant | |
| */ | |
| }, { | |
| key: "setTargetAtTime", | |
| value: function setTargetAtTime(target, startTime, timeConstant) { | |
| target = toNumber(target); | |
| startTime = Math.max(0, toNumber(startTime)); | |
| timeConstant = Math.max(0, toNumber(timeConstant)); | |
| var eventItem = { | |
| type: SET_TARGET_AT_TIME, | |
| time: startTime, | |
| args: [target, startTime, timeConstant], | |
| startFrame: Math.round(startTime * this.sampleRate), | |
| endFrame: Infinity, | |
| startValue: 0, | |
| endValue: target | |
| }; | |
| var index = this.insertEvent(eventItem); | |
| var prevEventItem = this._timeline[index - 1]; | |
| var nextEventItem = this._timeline[index + 1]; | |
| if (prevEventItem) { | |
| switch (prevEventItem.type) { | |
| case SET_VALUE_AT_TIME: | |
| eventItem.startValue = prevEventItem.endValue; | |
| prevEventItem.endFrame = eventItem.startFrame; | |
| break; | |
| case SET_TARGET_AT_TIME: | |
| eventItem.startValue = 0; | |
| prevEventItem.endFrame = eventItem.startFrame; | |
| break; | |
| case LINEAR_RAMP_TO_VALUE_AT_TIME: | |
| case EXPONENTIAL_RAMP_TO_VALUE_AT_TIME: | |
| case SET_VALUE_CURVE_AT_TIME: | |
| eventItem.startValue = prevEventItem.endValue; | |
| break; | |
| } | |
| } | |
| if (nextEventItem) { | |
| switch (nextEventItem.type) { | |
| case LINEAR_RAMP_TO_VALUE_AT_TIME: | |
| case EXPONENTIAL_RAMP_TO_VALUE_AT_TIME: | |
| nextEventItem.startFrame = eventItem.startFrame; | |
| nextEventItem.startValue = eventItem.startValue; | |
| break; | |
| } | |
| eventItem.endFrame = nextEventItem.startFrame; | |
| } | |
| if (index <= this._currentEventIndex) { | |
| this._currentEventIndex = index; | |
| this._remainSamples = 0; | |
| } | |
| } | |
| /** | |
| * @param {Float32Array[]} values | |
| * @param {number} startTime | |
| * @param {number} duration | |
| */ | |
| }, { | |
| key: "setValueCurveAtTime", | |
| value: function setValueCurveAtTime(values, startTime, duration) { | |
| startTime = Math.max(0, toNumber(startTime)); | |
| duration = Math.max(0, toNumber(duration)); | |
| if (values.length === 0 || duration === 0) { | |
| return; | |
| } | |
| var eventItem = { | |
| type: SET_VALUE_CURVE_AT_TIME, | |
| time: startTime, | |
| args: [values, startTime, duration], | |
| startFrame: Math.round(startTime * this.sampleRate), | |
| endFrame: Math.round((startTime + duration) * this.sampleRate), | |
| startValue: values[0], | |
| endValue: values[values.length - 1] | |
| }; | |
| var index = this.insertEvent(eventItem); | |
| var prevEventItem = this._timeline[index - 1]; | |
| var nextEventItem = this._timeline[index + 1]; | |
| if (prevEventItem) { | |
| switch (prevEventItem.type) { | |
| case SET_VALUE_AT_TIME: | |
| case SET_TARGET_AT_TIME: | |
| prevEventItem.endFrame = eventItem.startFrame; | |
| break; | |
| } | |
| } | |
| if (nextEventItem) { | |
| switch (nextEventItem.type) { | |
| case LINEAR_RAMP_TO_VALUE_AT_TIME: | |
| case EXPONENTIAL_RAMP_TO_VALUE_AT_TIME: | |
| nextEventItem.startFrame = eventItem.startFrame; | |
| nextEventItem.startValue = eventItem.endValue; | |
| break; | |
| } | |
| } | |
| if (index <= this._currentEventIndex) { | |
| this._currentEventIndex = index; | |
| this._remainSamples = 0; | |
| } | |
| } | |
| /** | |
| * @param {number} startTime | |
| */ | |
| }, { | |
| key: "cancelScheduledValues", | |
| value: function cancelScheduledValues(startTime) { | |
| startTime = Math.max(0, toNumber(startTime)); | |
| this._timeline = this._timeline.filter(function (eventItem) { | |
| return eventItem.time < startTime; | |
| }); | |
| var index = this._timeline.length - 1; | |
| var lastEventItem = this._timeline[index]; | |
| if (lastEventItem) { | |
| switch (lastEventItem.type) { | |
| case SET_VALUE_AT_TIME: | |
| case SET_TARGET_AT_TIME: | |
| lastEventItem.endFrame = Infinity; | |
| break; | |
| } | |
| } | |
| if (index <= this._currentEventIndex) { | |
| this._currentEventIndex = index; | |
| this._remainSamples = 0; | |
| } | |
| } | |
| /** | |
| * @return {string} | |
| */ | |
| }, { | |
| key: "getRate", | |
| value: function getRate() { | |
| return this._rate; | |
| } | |
| /** | |
| * @return {boolean} | |
| */ | |
| }, { | |
| key: "hasSampleAccurateValues", | |
| value: function hasSampleAccurateValues() { | |
| return this._hasSampleAccurateValues; | |
| } | |
| /** | |
| * @return {Float32Array} | |
| */ | |
| }, { | |
| key: "getSampleAccurateValues", | |
| value: function getSampleAccurateValues() { | |
| return this.outputBus.getChannelData()[0]; | |
| } | |
| /** | |
| * | |
| */ | |
| }, { | |
| key: "enableOutputsIfNecessary", | |
| value: function enableOutputsIfNecessary() {} | |
| /** | |
| * | |
| */ | |
| }, { | |
| key: "disableOutputsIfNecessary", | |
| value: function disableOutputsIfNecessary() {} | |
| /** | |
| * @return {object[]} | |
| */ | |
| }, { | |
| key: "getTimeline", | |
| value: function getTimeline() { | |
| return this._timeline; | |
| } | |
| /** | |
| * @return {object[]} | |
| */ | |
| }, { | |
| key: "getEvents", | |
| value: function getEvents() { | |
| return this._timeline.map(function (event) { | |
| return { type: event.type, time: event.time, args: event.args }; | |
| }); | |
| } | |
| /** | |
| * @param {object} | |
| * @return {number} | |
| */ | |
| }, { | |
| key: "insertEvent", | |
| value: function insertEvent(eventItem) { | |
| var time = eventItem.time; | |
| var timeline = this._timeline; | |
| if (timeline.length === 0 || timeline[timeline.length - 1].time < time) { | |
| timeline.push(eventItem); | |
| return timeline.length - 1; | |
| } | |
| var pos = 0; | |
| var replace = 0; | |
| while (pos < timeline.length) { | |
| if (timeline[pos].time === time && timeline[pos].type === eventItem.type) { | |
| replace = 1; | |
| break; | |
| } | |
| if (time < timeline[pos].time) { | |
| break; | |
| } | |
| pos += 1; | |
| } | |
| timeline.splice(pos, replace, eventItem); | |
| return pos; | |
| } | |
| }]); | |
| return AudioParam; | |
| }(); | |
| Object.assign(AudioParam.prototype, AudioParamDSP); | |
| module.exports = AudioParam; | |
| },{"../constants/AudioParamEvent":59,"../constants/AudioParamRate":60,"../constants/ChannelCountMode":62,"../utils":135,"./core/AudioBus":101,"./core/AudioNodeInput":103,"./dsp/AudioParam":107}],81:[function(require,module,exports){ | |
| "use strict"; | |
| // | |
| // | |
| // | |
| // | |
| // audio sched source node details | |
| var AudioScheduledSourceNode = function (_AudioSourceNode) { | |
| _inherits(AudioScheduledSourceNode, _AudioSourceNode); | |
| /** | |
| * @param {AudioContext} context | |
| */ | |
| function AudioScheduledSourceNode(context, opts) { | |
| _classCallCheck(this, AudioScheduledSourceNode); | |
| var _this = _possibleConstructorReturn(this, (AudioScheduledSourceNode.__proto__ || Object.getPrototypeOf(AudioScheduledSourceNode)).call(this, context, opts)); | |
| _this._startTime = Infinity; | |
| _this._stopTime = Infinity; | |
| _this._startFrame = Infinity; | |
| _this._stopFrame = Infinity; | |
| return _this; | |
| } | |
| /** | |
| * @return {number} | |
| */ | |
| _createClass(AudioScheduledSourceNode, [{ | |
| key: "getStartTime", | |
| value: function getStartTime() { | |
| if (this._startTime !== Infinity) { | |
| return this._startTime; | |
| } | |
| } | |
| /** | |
| * @return {number} | |
| */ | |
| }, { | |
| key: "getStopTime", | |
| value: function getStopTime() { | |
| if (this._stopTime !== Infinity) { | |
| return this._stopTime; | |
| } | |
| } | |
| /** | |
| * @return {string} | |
| */ | |
| }, { | |
| key: "getPlaybackState", | |
| value: function getPlaybackState() { | |
| if (this._startTime === Infinity) { | |
| return UNSCHEDULED; | |
| } | |
| if (this.context.currentTime < this._startTime) { | |
| return SCHEDULED; | |
| } | |
| if (this._stopTime <= this.context.currentTime) { | |
| return FINISHED; | |
| } | |
| return PLAYING; | |
| } | |
| /** | |
| * @param {number} when | |
| */ | |
| }, { | |
| key: "start", | |
| value: function start(when) { | |
| var _this2 = this; | |
| /* istanbul ignore next */ | |
| if (this._startTime !== Infinity) { | |
| return; | |
| } | |
| when = Math.max(this.context.currentTime, toNumber(when)); | |
| this._startTime = when; | |
| this._startFrame = Math.round(when * this.sampleRate); | |
| this.context.sched(when, function () { | |
| _this2.outputs[0].enable(); | |
| }); | |
| } | |
| /** | |
| * @param {number} when | |
| */ | |
| }, { | |
| key: "stop", | |
| value: function stop(when) { | |
| /* istanbul ignore next */ | |
| if (this._stopTime !== Infinity) { | |
| return; | |
| } | |
| when = Math.max(this.context.currentTime, this._startTime, toNumber(when)); | |
| this._stopTime = when; | |
| this._stopFrame = Math.round(when * this.sampleRate); | |
| } | |
| }]); | |
| return AudioScheduledSourceNode; | |
| }(AudioSourceNode); | |
| module.exports = AudioScheduledSourceNode; | |
| },{"../constants/PlaybackState":65,"../utils":135,"./AudioSourceNode":82}],82:[function(require,module,exports){ | |
| "use strict"; | |
| // | |
| // | |
| // | |
| // | |
| // oscillator details | |
| },{"../constants/ChannelCountMode":62,"../utils":135,"./AudioNode":79,"./dsp/IIRFilterNode":118}],94:[function(require,module,exports){ | |
| "use strict"; | |
| var _createClass = function () { function 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); | |
| function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } | |
| function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } | |
| function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } | |
| var AudioScheduledSourceNode = require("./AudioScheduledSourceNode"); | |
| var PeriodicWave = require("./PeriodicWave"); | |
| var OscillatorNodeDSP = require("./dsp/OscillatorNode"); | |
| var _require = require("../utils"), | |
| defaults = _require.defaults; | |
| var _require2 = require("../utils"), | |
| toImpl = _require2.toImpl; | |
| var _require3 = require("../constants/AudioParamRate"), | |
| AUDIO_RATE = _require3.AUDIO_RATE; | |
| var _require4 = require("../constants/OscillatorType"), | |
| SINE = _require4.SINE, | |
| SAWTOOTH = _require4.SAWTOOTH, | |
| TRIANGLE = _require4.TRIANGLE, | |
| SQUARE = _require4.SQUARE, | |
| CUSTOM = _require4.CUSTOM; | |
| var DefaultPeriodicWaves = {}; | |
| var allowedOscillatorTypes = [SINE, SAWTOOTH, TRIANGLE, SQUARE]; | |
| var DEFAULT_TYPE = SINE; | |
| var DEFAULT_FREQUENCY = 440; | |
| var DEFAULT_DETUNE = 0; | |
| var OscillatorNode = function (_AudioScheduledSource) { | |
| _inherits(OscillatorNode, _AudioScheduledSource); | |
| /** | |
| * @param {AudioContext} context | |
| * @param {object} opts | |
| * @param {string} opts.type | |
| * @param {number} opts.frequency | |
| * @param {number} opts.detune | |
| */ | |
| function OscillatorNode(context) { | |
| var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; | |
| _classCallCheck(this, OscillatorNode); | |
| var type = defaults(opts.type, DEFAULT_TYPE); | |
| var frequency = defaults(opts.frequency, DEFAULT_FREQUENCY); | |
| var detune = defaults(opts.detune, DEFAULT_DETUNE); | |
| var _this = _possibleConstructorReturn(this, (OscillatorNode.__proto__ || Object.getPrototypeOf(OscillatorNode)).call(this, context, opts)); | |
| _this._frequency = _this.addParam(AUDIO_RATE, frequency); | |
| _this._detune = _this.addParam(AUDIO_RATE, detune); | |
| _this._type = type; | |
| _this._periodicWave = _this.buildPeriodicWave(_this._type); | |
| _this._waveTable = null; | |
| _this.dspInit(); | |
| return _this; | |
| } | |
| /** | |
| * @return {string} | |
| */ | |
| _createClass(OscillatorNode, [{ | |
| key: "getType", | |
| value: function getType() { | |
| return this._type; | |
| } | |
| /** | |
| * @param {string} value | |
| */ | |
| }, { | |
| key: "setType", | |
| value: function setType(value) { | |
| /* istanbul ignore else */ | |
| if (allowedOscillatorTypes.indexOf(value) !== -1) { | |
| this._type = value; | |
| this._periodicWave = this.buildPeriodicWave(value); | |
| this._waveTable = this._periodicWave.getWaveTable(); | |
| } | |
| } | |
| /** | |
| * @param {AudioParam} | |
| */ | |
| }, { | |
| key: "getFrequency", | |
| value: function getFrequency() { | |
| return this._frequency; | |
| } | |
| /** | |
| * @param {AudioParam} | |
| */ | |
| }, { | |
| key: "getDetune", | |
| value: function getDetune() { | |
| return this._detune; | |
| } | |
| /** | |
| * @param {PeriodicWave} periodicWave | |
| */ | |
| }, { | |
| key: "setPeriodicWave", | |
| value: function setPeriodicWave(periodicWave) { | |
| periodicWave = toImpl(periodicWave); | |
| /* istanbul ignore else */ | |
| if (periodicWave instanceof PeriodicWave) { | |
| this._type = CUSTOM; | |
| this._periodicWave = periodicWave; | |
| this._waveTable = this._periodicWave.getWaveTable(); | |
| } | |
| } | |
| /** | |
| * @return {PeriodicWave} | |
| */ | |
| }, { | |
| key: "getPeriodicWave", | |
| value: function getPeriodicWave() { | |
| return this._periodicWave; | |
| } | |
| /** | |
| * @param {string} type | |
| * @return {PeriodicWave} | |
| */ | |
| }, { | |
| key: "buildPeriodicWave", | |
| value: function buildPeriodicWave(type) { | |
| var sampleRate = this.context.sampleRate; | |
| var key = type + ":" + sampleRate; | |
| /* istanbul ignore else */ | |
| if (!DefaultPeriodicWaves[key]) { | |
| var periodicWave = new PeriodicWave({ sampleRate: sampleRate }, { constraints: false }); | |
| periodicWave.generateBasicWaveform(type); | |
| DefaultPeriodicWaves[key] = periodicWave; | |
| } | |
| return DefaultPeriodicWaves[key]; | |
| } | |
| }]); | |
| return OscillatorNode; | |
| }(AudioScheduledSourceNode); | |
| Object.assign(OscillatorNode.prototype, OscillatorNodeDSP); | |
| module.exports = OscillatorNode; | |
| },{"../constants/AudioParamRate":60,"../constants/OscillatorType":64,"../utils":135,"./AudioScheduledSourceNode":81,"./PeriodicWave":96,"./dsp/OscillatorNode":119}],95:[function(require,module,exports){ | |
| "use strict"; | |
| // | |
| // | |
| // | |
| // | |
| // periodic wave details | |
| "use strict"; | |
| var _createClass = function () { function 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); | |
| function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } | |
| var nmap = require("nmap"); | |
| var PeriodicWaveDSP = require("./dsp/PeriodicWave"); | |
| var _require = require("../constants/OscillatorType"), | |
| SINE = _require.SINE, | |
| SAWTOOTH = _require.SAWTOOTH, | |
| TRIANGLE = _require.TRIANGLE, | |
| SQUARE = _require.SQUARE, | |
| CUSTOM = _require.CUSTOM; | |
| var PeriodicWave = function () { | |
| /** | |
| * @param {AudioContext} context | |
| * @param {object} opts | |
| * @param {Float32Array} opts.real | |
| * @param {Float32Array} opts.imag | |
| * @param {boolean} opts.constraints | |
| */ | |
| function PeriodicWave(context) { | |
| var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; | |
| _classCallCheck(this, PeriodicWave); | |
| var real = opts.real; | |
| var imag = opts.imag; | |
| var constraints = opts.constraints; | |
| this.context = context; | |
| this._real = real; | |
| this._imag = imag; | |
| this._constants = !!constraints; | |
| this._name = CUSTOM; | |
| this.dspInit(); | |
| } | |
| /** | |
| * @return {Float32Array} | |
| */ | |
| _createClass(PeriodicWave, [{ | |
| key: "getReal", | |
| value: function getReal() { | |
| return this._real; | |
| } | |
| /** | |
| * @return {Float32Array} | |
| */ | |
| }, { | |
| key: "getImag", | |
| value: function getImag() { | |
| return this._imag; | |
| } | |
| /** | |
| * @return {booleam} | |
| */ | |
| }, { | |
| key: "getConstraints", | |
| value: function getConstraints() { | |
| return this._constants; | |
| } | |
| /** | |
| * @return {string} | |
| */ | |
| }, { | |
| key: "getName", | |
| value: function getName() { | |
| return this._name; | |
| } | |
| /** | |
| * @return {Float32Array} | |
| */ | |
| }, { | |
| key: "getWaveTable", | |
| value: function getWaveTable() { | |
| if (!this._waveTable) { | |
| this._waveTable = this.dspBuildWaveTable(); | |
| } | |
| return this._waveTable; | |
| } | |
| }, { | |
| key: "generateBasicWaveform", | |
| value: function generateBasicWaveform(type) { | |
| var length = 512; | |
| switch (type) { | |
| case SINE: | |
| this._real = new Float32Array([0, 0]); | |
| this._imag = new Float32Array([0, 1]); | |
| this._name = SINE; | |
| break; | |
| case SAWTOOTH: | |
| this._real = new Float32Array(length); | |
| this._imag = new Float32Array(nmap(length, function (_, n) { | |
| return n === 0 ? 0 : Math.pow(-1, n + 1) * (2 / (n * Math.PI)); | |
| })); | |
| this._name = SAWTOOTH; | |
| this.dspBuildWaveTable(); | |
| break; | |
| case TRIANGLE: | |
| this._real = new Float32Array(length); | |
| this._imag = new Float32Array(nmap(length, function (_, n) { | |
| return n === 0 ? 0 : 8 * Math.sin(n * Math.PI / 2) / Math.pow(n * Math.PI, 2); | |
| })); | |
| this._name = TRIANGLE; | |
| this.dspBuildWaveTable(); | |
| break; | |
| case SQUARE: | |
| this._real = new Float32Array(length); | |
| this._imag = new Float32Array(nmap(length, function (_, n) { | |
| return n === 0 ? 0 : 2 / (n * Math.PI) * (1 - Math.pow(-1, n)); | |
| })); | |
| this._name = SQUARE; | |
| this.dspBuildWaveTable(); | |
| break; | |
| default: | |
| this._real = new Float32Array([0]); | |
| this._imag = new Float32Array([0]); | |
| this._name = CUSTOM; | |
| this.dspBuildWaveTable(); | |
| break; | |
| } | |
| } | |
| }]); | |
| return PeriodicWave; | |
| }(); | |
| Object.assign(PeriodicWave.prototype, PeriodicWaveDSP); | |
| module.exports = PeriodicWave; | |
| },{"../constants/OscillatorType":64,"./dsp/PeriodicWave":121,"nmap":25}],97:[function(require,module,exports){ | |
| "use strict"; | |
| // | |
| // | |
| // | |
| // | |
| // various DSP algorithm details | |
| DSPAlgorithm[0] = function (source, destination, length) { | |
| var numberOfChannels = Math.min(source.length, destination.length); | |
| for (var ch = 0; ch < numberOfChannels; ch++) { | |
| for (var i = 0; i < length; i++) { | |
| destination[ch][i] += source[ch][i]; | |
| } | |
| } | |
| }; | |
| DSPAlgorithm[0].set = function (source, destination) { | |
| var numberOfChannels = Math.min(source.length, destination.length); | |
| for (var ch = 0; ch < numberOfChannels; ch++) { | |
| destination[ch].set(source[ch]); | |
| } | |
| }; | |
| DSPAlgorithm[1001001] = function (source, destination, length) { | |
| var output = destination[0]; | |
| var input = source[0]; | |
| for (var i = 0; i < length; i++) { | |
| output[i] += input[i]; | |
| } | |
| }; | |
| DSPAlgorithm[1001001].set = function (source, destination) { | |
| destination[0].set(source[0]); | |
| }; | |
| DSPAlgorithm[2001001] = DSPAlgorithm[1001001]; | |
| DSPAlgorithm[2001001].set = DSPAlgorithm[1001001].set; | |
| DSPAlgorithm[1001002] = function (source, destination, length) { | |
| var outputL = destination[0]; | |
| var outputR = destination[1]; | |
| var input = source[0]; | |
| for (var i = 0; i < length; i++) { | |
| outputL[i] += input[i]; | |
| outputR[i] += input[i]; | |
| } | |
| }; | |
| DSPAlgorithm[1001002].set = function (source, destination) { | |
| destination[0].set(source[0]); | |
| destination[1].set(source[0]); | |
| }; | |
| DSPAlgorithm[1001004] = DSPAlgorithm[1001002]; | |
| DSPAlgorithm[1001004].set = DSPAlgorithm[1001002].set; | |
| DSPAlgorithm[1001006] = function (source, destination, length) { | |
| var outputC = destination[2]; | |
| var input = source[0]; | |
| for (var i = 0; i < length; i++) { | |
| outputC[i] += input[i]; | |
| } | |
| }; | |
| DSPAlgorithm[1001006].set = function (source, destination) { | |
| destination[2].set(source[0]); | |
| }; | |
| DSPAlgorithm[1002002] = function (source, destination, length) { | |
| var outputL = destination[0]; | |
| var outputR = destination[1]; | |
| var inputL = source[0]; | |
| var inputR = source[1]; | |
| for (var i = 0; i < length; i++) { | |
| outputL[i] += inputL[i]; | |
| outputR[i] += inputR[i]; | |
| } | |
| }; | |
| DSPAlgorithm[1002002].set = function (source, destination) { | |
| destination[0].set(source[0]); | |
| destination[1].set(source[1]); | |
| }; | |
| DSPAlgorithm[2002002] = DSPAlgorithm[1002002]; | |
| DSPAlgorithm[2002002].set = DSPAlgorithm[1002002].set; | |
| DSPAlgorithm[1002004] = DSPAlgorithm[1002002]; | |
| DSPAlgorithm[1002004].set = DSPAlgorithm[1002002].set; | |
| DSPAlgorithm[1002006] = DSPAlgorithm[1002004]; | |
| DSPAlgorithm[1002006].set = DSPAlgorithm[1002004].set; | |
| DSPAlgorithm[1004006] = function (source, destination, length) { | |
| var outputL = destination[0]; | |
| var outputR = destination[1]; | |
| var outputSL = destination[4]; | |
| var outputSR = destination[5]; | |
| var inputL = source[0]; | |
| var inputR = source[1]; | |
| var inputSL = source[2]; | |
| var inputSR = source[3]; | |
| for (var i = 0; i < length; i++) { | |
| outputL[i] += inputL[i]; | |
| outputR[i] += inputR[i]; | |
| outputSL[i] += inputSL[i]; | |
| outputSR[i] += inputSR[i]; | |
| } | |
| }; | |
| DSPAlgorithm[1004006].set = function (source, destination) { | |
| destination[0].set(source[0]); | |
| destination[1].set(source[1]); | |
| destination[4].set(source[2]); | |
| destination[5].set(source[3]); | |
| }; | |
| DSPAlgorithm[1002001] = function (source, destination, length) { | |
| var output = destination[0]; | |
| var inputL = source[0]; | |
| var inputR = source[1]; | |
| for (var i = 0; i < length; i++) { | |
| output[i] += 0.5 * (inputL[i] + inputR[i]); | |
| } | |
| }; | |
| DSPAlgorithm[1004001] = function (source, destination, length) { | |
| var output = destination[0]; | |
| var inputL = source[0]; | |
| var inputR = source[1]; | |
| var inputSL = source[2]; | |
| var inputSR = source[3]; | |
| for (var i = 0; i < length; i++) { | |
| output[i] += 0.25 * (inputL[i] + inputR[i] + inputSL[i] + inputSR[i]); | |
| } | |
| }; | |
| DSPAlgorithm[1006001] = function (source, destination, length) { | |
| var output = destination[0]; | |
| var inputL = source[0]; | |
| var inputR = source[1]; | |
| var inputC = source[2]; | |
| var inputSL = source[4]; | |
| var inputSR = source[5]; | |
| for (var i = 0; i < length; i++) { | |
| output[i] += 0.7071 * (inputL[i] + inputR[i]) + inputC[i] + 0.5 * (inputSL[i] + inputSR[i]); | |
| } | |
| }; | |
| DSPAlgorithm[1004002] = function (source, destination, length) { | |
| var outputL = destination[0]; | |
| var outputR = destination[1]; | |
| var inputL = source[0]; | |
| var inputR = source[1]; | |
| var inputSL = source[2]; | |
| var inputSR = source[3]; | |
| for (var i = 0; i < length; i++) { | |
| outputL[i] += 0.5 * (inputL[i] + inputSL[i]); | |
| outputR[i] += 0.5 * (inputR[i] + inputSR[i]); | |
| } | |
| }; | |
| DSPAlgorithm[1006002] = function (source, destination, length) { | |
| var outputL = destination[0]; | |
| var outputR = destination[1]; | |
| var inputL = source[0]; | |
| var inputR = source[1]; | |
| var inputC = source[2]; | |
| var inputSL = source[4]; | |
| var inputSR = source[5]; | |
| for (var i = 0; i < length; i++) { | |
| outputL[i] += inputL[i] + 0.7071 * (inputC[i] + inputSL[i]); | |
| outputR[i] += inputR[i] + 0.7071 * (inputC[i] + inputSR[i]); | |
| } | |
| }; | |
| DSPAlgorithm[1006004] = function (source, destination, length) { | |
| var outputL = destination[0]; | |
| var outputR = destination[1]; | |
| var outputSL = destination[2]; | |
| var outputSR = destination[3]; | |
| var inputL = source[0]; | |
| var inputR = source[1]; | |
| var inputC = source[2]; | |
| var inputSL = source[4]; | |
| var inputSR = source[5]; | |
| for (var i = 0; i < length; i++) { | |
| outputL[i] += inputL[i] + 0.7071 * inputC[i]; | |
| outputR[i] += inputR[i] + 0.7071 * inputC[i]; | |
| outputSL[i] += inputSL[i]; | |
| outputSR[i] += inputSR[i]; | |
| } | |
| }; | |
| module.exports = AudioBus; | |
| },{"../../constants/ChannelInterpretation":63,"../../utils":135,"./AudioData":102}],102:[function(require,module,exports){ | |
| "use strict"; | |
| // | |
| // | |
| // | |
| // | |
| // audio buffer source node dsp details | |
| "use strict"; | |
| var AudioBufferSourceNodeDSP = { | |
| dspInit: function dspInit() { | |
| this._phase = 0; | |
| }, | |
| dspStart: function dspStart() { | |
| if (this._audioData) { | |
| var bufferSampleRate = this._audioData.sampleRate; | |
| var bufferDuration = this._audioData.length / bufferSampleRate; | |
| this._phase = Math.max(0, Math.min(this._offset, bufferDuration)) * bufferSampleRate; | |
| } | |
| }, | |
| dspProcess: function dspProcess() { | |
| if (this._audioData === null) { | |
| return this.dspEmitEnded(); | |
| } | |
| var blockSize = this.blockSize; | |
| var quantumStartFrame = this.context.currentSampleFrame; | |
| var quantumEndFrame = quantumStartFrame + blockSize; | |
| var sampleOffset = Math.max(0, this._startFrame - quantumStartFrame); | |
| var fillToSample = Math.min(quantumEndFrame, this._stopFrame) - quantumStartFrame; | |
| var outputs = this.outputs[0].bus.getMutableData(); | |
| var writeIndex = 0; | |
| writeIndex = this.dspBufferRendering(outputs, sampleOffset, fillToSample, this.sampleRate); | |
| // timeline | |
| // |----------------|-------*--------|----------------|----------------| | |
| // ^ ^ ^ | |
| // |------>| quantumEndFrame | |
| // | wrote | | |
| // | stopFrame | |
| // quantumStartFrame | |
| if (this._stopFrame <= quantumStartFrame + writeIndex) { | |
| // rest samples fill zero | |
| var numberOfChannels = outputs.length; | |
| while (writeIndex < blockSize) { | |
| for (var ch = 0; ch < numberOfChannels; ch++) { | |
| outputs[ch][writeIndex] = 0; | |
| } | |
| writeIndex += 1; | |
| } | |
| this.dspEmitEnded(); | |
| } | |
| }, | |
| dspBufferRendering: function dspBufferRendering(outputs, writeIndex, inNumSamples, sampleRate) { | |
| var playbackRateValues = this._playbackRate.getSampleAccurateValues(); | |
| var detuneValues = this._detune.getSampleAccurateValues(); | |
| var numberOfChannels = this._audioData.numberOfChannels; | |
| var bufferLength = this._audioData.length; | |
| var bufferSampleRate = this._audioData.sampleRate; | |
| var bufferChannelData = this._audioData.channelData; | |
| var playbackRateToPhaseIncr = bufferSampleRate / sampleRate; | |
| var phase = this._phase; | |
| while (writeIndex < inNumSamples) { | |
| var playbackRateValue = playbackRateValues[writeIndex]; | |
| var detuneValue = detuneValues[writeIndex]; | |
| var computedPlaybackRate = playbackRateValue * Math.pow(2, detuneValue / 1200); | |
| for (var ch = 0; ch < numberOfChannels; ch++) { | |
| var v0 = bufferChannelData[ch][phase | 0] || 0; | |
| var v1 = bufferChannelData[ch][(phase | 0) + 1] || 0; | |
| outputs[ch][writeIndex] = v0 + phase % 1 * (v1 - v0); | |
| } | |
| writeIndex += 1; | |
| phase += playbackRateToPhaseIncr * Math.max(0, computedPlaybackRate); | |
| if (this._loop) { | |
| if (0 <= this._loopStart && this._loopStart < this._loopEnd) { | |
| var loopEndSamples = this._loopEnd * bufferSampleRate; | |
| if (loopEndSamples <= phase) { | |
| phase = this._loopStart * bufferSampleRate; | |
| } | |
| } else { | |
| if (bufferLength <= phase) { | |
| phase = 0; | |
| } | |
| } | |
| } else { | |
| if (bufferLength <= phase) { | |
| this.dspEmitEnded(); | |
| break; | |
| } | |
| } | |
| } | |
| this._phase = phase; | |
| return writeIndex; | |
| }, | |
| dspEmitEnded: function dspEmitEnded() { | |
| var _this = this; | |
| this._done = true; | |
| this.context.addPostProcess(function () { | |
| _this.outputs[0].bus.zeros(); | |
| _this.outputs[0].disable(); | |
| _this.dispatchEvent({ type: "ended" }); | |
| }); | |
| } | |
| }; | |
| module.exports = AudioBufferSourceNodeDSP; | |
| },{}],107:[function(require,module,exports){ | |
| // | |
| // | |
| // | |
| // | |
| // audio param dsp details | |
| "use strict"; | |
| var AudioParamUtils = require("../../utils/AudioParamUtils"); | |
| var _require = require("../../utils"), | |
| fill = _require.fill; | |
| var _require2 = require("../../constants/AudioParamEvent"), | |
| SET_VALUE_AT_TIME = _require2.SET_VALUE_AT_TIME; | |
| var _require3 = require("../../constants/AudioParamEvent"), | |
| LINEAR_RAMP_TO_VALUE_AT_TIME = _require3.LINEAR_RAMP_TO_VALUE_AT_TIME; | |
| var _require4 = require("../../constants/AudioParamEvent"), | |
| EXPONENTIAL_RAMP_TO_VALUE_AT_TIME = _require4.EXPONENTIAL_RAMP_TO_VALUE_AT_TIME; | |
| var _require5 = require("../../constants/AudioParamEvent"), | |
| SET_TARGET_AT_TIME = _require5.SET_TARGET_AT_TIME; | |
| var _require6 = require("../../constants/AudioParamEvent"), | |
| SET_VALUE_CURVE_AT_TIME = _require6.SET_VALUE_CURVE_AT_TIME; | |
| var AudioParamDSP = { | |
| dspInit: function dspInit() { | |
| this._prevValue = NaN; | |
| this._hasSampleAccurateValues = false; | |
| this._currentEventIndex = -1; | |
| this._quantumStartFrame = -1; | |
| this._remainSamples = 0; | |
| this._schedParams = {}; | |
| }, | |
| dspProcess: function dspProcess() { | |
| var input = this.inputs[0]; | |
| var inputBus = input.bus; | |
| input.pull(); | |
| var hasEvents = !!this._timeline.length; | |
| var hasInput = !inputBus.isSilent; | |
| var algorithm = hasEvents * 2 + hasInput; | |
| switch (algorithm) { | |
| case 0: | |
| // events: x / input: x | |
| return this.dspStaticValue(); | |
| case 1: | |
| // events: x / input: o | |
| return this.dspInputAndOffset(inputBus); | |
| case 2: | |
| // events: o / input: x | |
| return this.dspEvents(); | |
| case 3: | |
| // events: o / input: o | |
| return this.dspEventsAndInput(inputBus); | |
| default: | |
| /* istanbul ignore next */ | |
| void 0; | |
| } | |
| }, | |
| dspStaticValue: function dspStaticValue() { | |
| var value = this._value; | |
| if (value !== this._prevValue) { | |
| if (value === 0) { | |
| this.outputBus.zeros(); | |
| } else { | |
| fill(this.outputBus.getMutableData()[0], value); | |
| } | |
| this._prevValue = value; | |
| } | |
| this._hasSampleAccurateValues = false; | |
| }, | |
| dspInputAndOffset: function dspInputAndOffset(inputBus) { | |
| var blockSize = this.blockSize; | |
| var outputBus = this.outputBus; | |
| var output = outputBus.getMutableData()[0]; | |
| var input = inputBus.getChannelData()[0]; | |
| var value = this._value; | |
| output.set(input); | |
| if (value !== 0) { | |
| for (var i = 0; i < blockSize; i++) { | |
| output[i] += value; | |
| } | |
| } | |
| this._prevValue = NaN; | |
| this._hasSampleAccurateValues = true; | |
| }, | |
| dspEvents: function dspEvents() { | |
| var outputBus = this.outputBus; | |
| var output = outputBus.getMutableData()[0]; | |
| this.dspValuesForTimeRange(output); | |
| this._prevValue = NaN; | |
| this._hasSampleAccurateValues = true; | |
| }, | |
| dspEventsAndInput: function dspEventsAndInput(inputBus) { | |
| var blockSize = this.blockSize; | |
| var outputBus = this.outputBus; | |
| var output = outputBus.getMutableData()[0]; | |
| var input = inputBus.getChannelData()[0]; | |
| this.dspValuesForTimeRange(output); | |
| for (var i = 0; i < blockSize; i++) { | |
| output[i] += input[i]; | |
| } | |
| this._prevValue = NaN; | |
| this._hasSampleAccurateValues = true; | |
| }, | |
| dspValuesForTimeRange: function dspValuesForTimeRange(output) { | |
| var blockSize = this.blockSize; | |
| var quantumStartFrame = this.context.currentSampleFrame; | |
| var quantumEndFrame = quantumStartFrame + blockSize; | |
| var sampleRate = this.sampleRate; | |
| var timeline = this._timeline; | |
| var value = this._value; | |
| var writeIndex = 0; | |
| // processing until the first event | |
| if (this._currentEventIndex === -1) { | |
| var firstEventStartFrame = timeline[0].startFrame; | |
| // timeline | |
| // |----------------|----------------|-------*--------|----------------| | |
| // ^ ^ ^ | |
| // | quantumEndFrame firstEventStartFrame | |
| // quantumStartFrame | |
| // <---------------> fill value with in range | |
| if (quantumEndFrame <= firstEventStartFrame) { | |
| for (var i = 0; i < blockSize; i++) { | |
| output[i] = value; | |
| } | |
| this._hasSampleAccurateValues = false; | |
| return; | |
| } | |
| // timeline | |
| // |----------------|----------------|-------*--------|----------------| | |
| // ^ ^ ^ | |
| // | | quantumEndFrame | |
| // | firstEventStartFrame | |
| // quantumStartFrame | |
| // <------> fill value with in range | |
| for (var _i = 0, imax = firstEventStartFrame - quantumStartFrame; _i < imax; _i++) { | |
| output[writeIndex++] = value; | |
| } | |
| this._currentEventIndex = 0; | |
| } | |
| this._hasSampleAccurateValues = true; | |
| var remainSamples = this._quantumStartFrame === quantumStartFrame ? this._remainSamples : 0; | |
| var schedParams = this._schedParams; | |
| // if new event exists, should recalculate remainSamples | |
| if (remainSamples === Infinity && this._currentEventIndex + 1 !== timeline.length) { | |
| remainSamples = timeline[this._currentEventIndex + 1].startFrame - quantumStartFrame; | |
| } | |
| while (writeIndex < blockSize && this._currentEventIndex < timeline.length) { | |
| var eventItem = timeline[this._currentEventIndex]; | |
| var startFrame = eventItem.startFrame; | |
| var endFrame = eventItem.endFrame; | |
| // timeline | |
| // |-------*--------|-------*--------|----------------|----------------| | |
| // ^ ^ ^ ^ | |
| // |<-------------->| | quantumEndFrame | |
| // | | quantumStartFrame | |
| // startFrame endFrame | |
| // skip event if | |
| // (endFrame < quantumStartFrame): past event | |
| // or | |
| // (startFrame === endFrame): setValueAtTime before linearRampToValueAtTime or exponentialRampToValueAtTime. | |
| if (endFrame < quantumStartFrame || startFrame === endFrame) { | |
| remainSamples = 0; | |
| this._currentEventIndex += 1; | |
| continue; | |
| } | |
| if (remainSamples <= 0) { | |
| var processedSamples = Math.max(0, quantumStartFrame - startFrame); | |
| switch (eventItem.type) { | |
| case SET_VALUE_AT_TIME: | |
| { | |
| value = eventItem.startValue; | |
| schedParams = { type: SET_VALUE_AT_TIME }; | |
| } | |
| break; | |
| case LINEAR_RAMP_TO_VALUE_AT_TIME: | |
| { | |
| var valueRange = eventItem.endValue - eventItem.startValue; | |
| var frameRange = eventItem.endFrame - eventItem.startFrame; | |
| var grow = valueRange / frameRange; | |
| if (grow) { | |
| value = eventItem.startValue + processedSamples * grow; | |
| schedParams = { type: LINEAR_RAMP_TO_VALUE_AT_TIME, grow: grow }; | |
| } else { | |
| value = eventItem.startValue; | |
| schedParams = { type: SET_VALUE_AT_TIME }; | |
| } | |
| } | |
| break; | |
| case EXPONENTIAL_RAMP_TO_VALUE_AT_TIME: | |
| { | |
| var valueRatio = eventItem.endValue / eventItem.startValue; | |
| var _frameRange = eventItem.endFrame - eventItem.startFrame; | |
| var _grow = Math.pow(valueRatio, 1 / _frameRange); | |
| if (_grow) { | |
| value = eventItem.startValue * Math.pow(_grow, processedSamples); | |
| schedParams = { type: EXPONENTIAL_RAMP_TO_VALUE_AT_TIME, grow: _grow }; | |
| } else { | |
| value = eventItem.startValue; | |
| schedParams = { type: SET_VALUE_AT_TIME }; | |
| } | |
| } | |
| break; | |
| case SET_TARGET_AT_TIME: | |
| { | |
| var target = Math.fround(eventItem.args[0]); | |
| var timeConstant = eventItem.args[2]; | |
| var discreteTimeConstant = 1 - Math.exp(-1 / (sampleRate * timeConstant)); | |
| var time = (quantumStartFrame + writeIndex) / sampleRate; | |
| value = AudioParamUtils.computeValueAtTime(timeline, time, this._userValue); | |
| if (discreteTimeConstant !== 1) { | |
| schedParams = { type: SET_TARGET_AT_TIME, target: target, discreteTimeConstant: discreteTimeConstant }; | |
| } else { | |
| schedParams = { type: SET_VALUE_AT_TIME }; | |
| } | |
| } | |
| break; | |
| case SET_VALUE_CURVE_AT_TIME: | |
| { | |
| var curve = eventItem.args[0]; | |
| schedParams = { type: SET_VALUE_CURVE_AT_TIME, curve: curve, startFrame: startFrame, endFrame: endFrame }; | |
| } | |
| break; | |
| } | |
| remainSamples = endFrame - startFrame - processedSamples; | |
| } // if (remainSamples === 0) | |
| var fillFrames = Math.min(blockSize - writeIndex, remainSamples); | |
| switch (schedParams.type) { | |
| case SET_VALUE_AT_TIME: | |
| { | |
| for (var _i2 = 0; _i2 < fillFrames; _i2++) { | |
| output[writeIndex++] = value; | |
| } | |
| } | |
| break; | |
| case LINEAR_RAMP_TO_VALUE_AT_TIME: | |
| { | |
| for (var _i3 = 0; _i3 < fillFrames; _i3++) { | |
| output[writeIndex++] = value; | |
| value += schedParams.grow; | |
| } | |
| } | |
| break; | |
| case EXPONENTIAL_RAMP_TO_VALUE_AT_TIME: | |
| { | |
| for (var _i4 = 0; _i4 < fillFrames; _i4++) { | |
| output[writeIndex++] = value; | |
| value *= schedParams.grow; | |
| } | |
| } | |
| break; | |
| case SET_TARGET_AT_TIME: | |
| { | |
| for (var _i5 = 0; _i5 < fillFrames; _i5++) { | |
| output[writeIndex++] = value; | |
| value += (schedParams.target - value) * schedParams.discreteTimeConstant; | |
| } | |
| } | |
| break; | |
| case SET_VALUE_CURVE_AT_TIME: | |
| { | |
| var _curve = schedParams.curve; | |
| var schedRange = schedParams.endFrame - schedParams.startFrame; | |
| var schedStartFrame = schedParams.startFrame; | |
| for (var _i6 = 0; _i6 < fillFrames; _i6++) { | |
| var xx = (quantumStartFrame + writeIndex - schedStartFrame) / schedRange; | |
| var ix = xx * (_curve.length - 1); | |
| var i0 = ix | 0; | |
| var i1 = i0 + 1; | |
| value = _curve[i0] + ix % 1 * (_curve[i1] - _curve[i0]); | |
| output[writeIndex++] = value; | |
| } | |
| if (remainSamples === fillFrames) { | |
| value = _curve[_curve.length - 1]; | |
| } | |
| } | |
| break; | |
| } | |
| remainSamples -= fillFrames; | |
| if (remainSamples === 0) { | |
| this._currentEventIndex += 1; | |
| } | |
| } // while (writeIndex < blockSize) | |
| while (writeIndex < blockSize) { | |
| output[writeIndex++] = value; | |
| } | |
| this._value = value; | |
| this._schedParams = schedParams; | |
| this._remainSamples = remainSamples; | |
| this._quantumStartFrame = quantumEndFrame; | |
| } | |
| }; | |
| module.exports = AudioParamDSP; | |
| },{"../../constants/AudioParamEvent":59,"../../utils":135,"../../utils/AudioParamUtils":128}],108:[function(require,module,exports){ | |
| "use strict"; | |
| // | |
| // | |
| // | |
| // | |
| // oscillator and periodic wave dsp details | |
| "use strict"; | |
| var _require = require("../../constants/OscillatorType"), | |
| SINE = _require.SINE; | |
| var OscillatorNodeDSP = { | |
| dspInit: function dspInit() { | |
| this._phase = 0; | |
| }, | |
| dspProcess: function dspProcess() { | |
| var _this = this; | |
| var blockSize = this.blockSize; | |
| var quantumStartFrame = this.context.currentSampleFrame; | |
| var quantumEndFrame = quantumStartFrame + blockSize; | |
| var sampleOffset = Math.max(0, this._startFrame - quantumStartFrame); | |
| var fillToSample = Math.min(quantumEndFrame, this._stopFrame) - quantumStartFrame; | |
| var output = this.outputs[0].bus.getMutableData()[0]; | |
| var writeIndex = 0; | |
| if (this._type === SINE) { | |
| writeIndex = this.dspSine(output, sampleOffset, fillToSample, this.sampleRate); | |
| } else { | |
| writeIndex = this.dspWave(output, sampleOffset, fillToSample, this.sampleRate); | |
| } | |
| // timeline | |
| // |----------------|-------*--------|----------------|----------------| | |
| // ^ ^ ^ | |
| // |------>| quantumEndFrame | |
| // | wrote | | |
| // | stopFrame | |
| // quantumStartFrame | |
| if (this._stopFrame <= quantumStartFrame + writeIndex) { | |
| // rest samples fill zero | |
| while (writeIndex < blockSize) { | |
| output[writeIndex++] = 0; | |
| } | |
| this.context.addPostProcess(function () { | |
| _this.outputs[0].bus.zeros(); | |
| _this.outputs[0].disable(); | |
| _this.dispatchEvent({ type: "ended" }); | |
| }); | |
| } | |
| }, | |
| dspSine: function dspSine(output, writeIndex, blockSize, sampleRate) { | |
| var frequency = this._frequency; | |
| var detune = this._detune; | |
| var algorithm = frequency.hasSampleAccurateValues() * 2 + detune.hasSampleAccurateValues(); | |
| var frequencyToPhaseIncr = 2 * Math.PI / sampleRate; | |
| var phase = this._phase; | |
| if (algorithm === 0) { | |
| var frequencyValue = frequency.getValue(); | |
| var detuneValue = detune.getValue(); | |
| var computedFrequency = frequencyValue * Math.pow(2, detuneValue / 1200); | |
| var phaseIncr = frequencyToPhaseIncr * computedFrequency; | |
| while (writeIndex < blockSize) { | |
| output[writeIndex++] = Math.sin(phase); | |
| phase += phaseIncr; | |
| } | |
| } else { | |
| var frequencyValues = frequency.getSampleAccurateValues(); | |
| var detuneValues = detune.getSampleAccurateValues(); | |
| while (writeIndex < blockSize) { | |
| var _frequencyValue = frequencyValues[writeIndex]; | |
| var _detuneValue = detuneValues[writeIndex]; | |
| var _computedFrequency = _frequencyValue * Math.pow(2, _detuneValue / 1200); | |
| output[writeIndex++] = Math.sin(phase); | |
| phase += frequencyToPhaseIncr * _computedFrequency; | |
| } | |
| } | |
| this._phase = phase; | |
| return writeIndex; | |
| }, | |
| dspWave: function dspWave(output, writeIndex, blockSize, sampleRate) { | |
| var frequency = this._frequency; | |
| var detune = this._detune; | |
| var algorithm = frequency.hasSampleAccurateValues() * 2 + detune.hasSampleAccurateValues(); | |
| var waveTable = this._waveTable; | |
| var waveTableLength = waveTable.length - 1; | |
| var frequencyToPhaseIncr = 1 / sampleRate; | |
| var phase = this._phase; | |
| if (algorithm === 0) { | |
| var frequencyValue = frequency.getValue(); | |
| var detuneValue = detune.getValue(); | |
| var computedFrequency = frequencyValue * Math.pow(2, detuneValue / 1200); | |
| var phaseIncr = frequencyToPhaseIncr * computedFrequency; | |
| while (writeIndex < blockSize) { | |
| var idx = phase * waveTableLength % waveTableLength; | |
| var v0 = waveTable[idx | 0]; | |
| var v1 = waveTable[(idx | 0) + 1]; | |
| output[writeIndex++] = v0 + idx % 1 * (v1 - v0); | |
| phase += phaseIncr; | |
| } | |
| } else { | |
| var frequencyValues = frequency.getSampleAccurateValues(); | |
| var detuneValues = detune.getSampleAccurateValues(); | |
| while (writeIndex < blockSize) { | |
| var _frequencyValue2 = frequencyValues[writeIndex]; | |
| var _detuneValue2 = detuneValues[writeIndex]; | |
| var _computedFrequency2 = _frequencyValue2 * Math.pow(2, _detuneValue2 / 1200); | |
| var _idx = phase * waveTableLength % waveTableLength; | |
| var _v = waveTable[_idx | 0]; | |
| var _v2 = waveTable[(_idx | 0) + 1]; | |
| output[writeIndex++] = _v + _idx % 1 * (_v2 - _v); | |
| phase += frequencyToPhaseIncr * _computedFrequency2; | |
| } | |
| } | |
| this._phase = phase; | |
| return writeIndex; | |
| } | |
| }; | |
| module.exports = OscillatorNodeDSP; | |
| },{"../../constants/OscillatorType":64}],120:[function(require,module,exports){ | |
| "use strict"; | |
| var PannerNodeDSP = { | |
| dspProcess: function dspProcess() { | |
| var outputBus = this.outputs[0].bus; | |
| outputBus.zeros(); | |
| outputBus.sumFrom(this.inputs[0].bus); | |
| } | |
| }; | |
| module.exports = PannerNodeDSP; | |
| },{}],121:[function(require,module,exports){ | |
| "use strict"; | |
| var WAVE_TABLE_LENGTH = 8192; | |
| var PeriodicWaveDSP = { | |
| dspInit: function dspInit() { | |
| this._waveTable = null; | |
| }, | |
| dspBuildWaveTable: function dspBuildWaveTable() { | |
| if (this._waveTable !== null) { | |
| return this._waveTable; | |
| } | |
| var waveTable = new Float32Array(WAVE_TABLE_LENGTH + 1); | |
| var real = this._real; | |
| var imag = this._imag; | |
| var maxAbsValue = 0; | |
| var periodicWaveLength = Math.min(real.length, 16); | |
| for (var i = 0; i < WAVE_TABLE_LENGTH; i++) { | |
| var x = i / WAVE_TABLE_LENGTH * Math.PI * 2; | |
| for (var n = 1; n < periodicWaveLength; n++) { | |
| waveTable[i] += real[n] * Math.cos(n * x) + imag[n] * Math.sin(n * x); | |
| } | |
| maxAbsValue = Math.max(maxAbsValue, Math.abs(waveTable[i])); | |
| } | |
| if (!this._constants && maxAbsValue !== 1) { | |
| for (var _i = 0; _i < WAVE_TABLE_LENGTH; _i++) { | |
| waveTable[_i] *= maxAbsValue; | |
| } | |
| } | |
| waveTable[WAVE_TABLE_LENGTH] = waveTable[0]; | |
| this._waveTable = waveTable; | |
| return waveTable; | |
| } | |
| }; | |
| module.exports = PeriodicWaveDSP; | |
| },{}],122:[function(require,module,exports){ | |
| "use strict"; | |
| // | |
| // | |
| // | |
| // | |
| // audio param ramp dsp details | |
| "use strict"; | |
| var _require = require("../constants/AudioParamEvent"), | |
| SET_VALUE_AT_TIME = _require.SET_VALUE_AT_TIME; | |
| var _require2 = require("../constants/AudioParamEvent"), | |
| LINEAR_RAMP_TO_VALUE_AT_TIME = _require2.LINEAR_RAMP_TO_VALUE_AT_TIME; | |
| var _require3 = require("../constants/AudioParamEvent"), | |
| EXPONENTIAL_RAMP_TO_VALUE_AT_TIME = _require3.EXPONENTIAL_RAMP_TO_VALUE_AT_TIME; | |
| var _require4 = require("../constants/AudioParamEvent"), | |
| SET_TARGET_AT_TIME = _require4.SET_TARGET_AT_TIME; | |
| var _require5 = require("../constants/AudioParamEvent"), | |
| SET_VALUE_CURVE_AT_TIME = _require5.SET_VALUE_CURVE_AT_TIME; | |
| /** | |
| * @param {object[]} timeline | |
| * @param {number} time | |
| * @param {number} defaultValue | |
| */ | |
| function computeValueAtTime(timeline, time, defaultValue) { | |
| var value = defaultValue; | |
| for (var i = 0, imax = timeline.length; i < imax; i++) { | |
| var e0 = timeline[i]; | |
| var e1 = timeline[i + 1]; | |
| var t0 = Math.min(time, e1 ? e1.time : time); | |
| if (time < e0.time) { | |
| break; | |
| } | |
| switch (e0.type) { | |
| case SET_VALUE_AT_TIME: | |
| case LINEAR_RAMP_TO_VALUE_AT_TIME: | |
| case EXPONENTIAL_RAMP_TO_VALUE_AT_TIME: | |
| value = e0.args[0]; | |
| break; | |
| case SET_TARGET_AT_TIME: | |
| value = getTargetValueAtTime(t0, value, e0.args[0], e0.args[1], e0.args[2]); | |
| break; | |
| case SET_VALUE_CURVE_AT_TIME: | |
| value = getValueCurveAtTime(t0, e0.args[0], e0.args[1], e0.args[2]); | |
| break; | |
| } | |
| if (e1) { | |
| switch (e1.type) { | |
| case LINEAR_RAMP_TO_VALUE_AT_TIME: | |
| value = getLinearRampToValueAtTime(t0, value, e1.args[0], e0.time, e1.args[1]); | |
| break; | |
| case EXPONENTIAL_RAMP_TO_VALUE_AT_TIME: | |
| value = getExponentialRampToValueAtTime(t0, value, e1.args[0], e0.time, e1.args[1]); | |
| break; | |
| } | |
| } | |
| } | |
| return value; | |
| } | |
| function getLinearRampToValueAtTime(t, v0, v1, t0, t1) { | |
| var a; | |
| if (t <= t0) { | |
| return v0; | |
| } | |
| if (t1 <= t) { | |
| return v1; | |
| } | |
| a = (t - t0) / (t1 - t0); | |
| return v0 + a * (v1 - v0); | |
| } | |
| function getExponentialRampToValueAtTime(t, v0, v1, t0, t1) { | |
| var a; | |
| if (t <= t0) { | |
| return v0; | |
| } | |
| if (t1 <= t) { | |
| return v1; | |
| } | |
| a = (t - t0) / (t1 - t0); | |
| return v0 * Math.pow(v1 / v0, a); | |
| } | |
| function getTargetValueAtTime(t, v0, v1, t0, timeConstant) { | |
| if (t <= t0) { | |
| return v0; | |
| } | |
| return v1 + (v0 - v1) * Math.exp((t0 - t) / timeConstant); | |
| } | |
| function getValueCurveAtTime(t, curve, t0, duration) { | |
| var x, ix, i0, i1; | |
| var y0, y1, a; | |
| x = (t - t0) / duration; | |
| ix = x * (curve.length - 1); | |
| i0 = ix | 0; | |
| i1 = i0 + 1; | |
| if (curve.length <= i1) { | |
| return curve[curve.length - 1]; | |
| } | |
| y0 = curve[i0]; | |
| y1 = curve[i1]; | |
| a = ix % 1; | |
| return y0 + a * (y1 - y0); | |
| } | |
| module.exports = { computeValueAtTime: computeValueAtTime, getLinearRampToValueAtTime: getLinearRampToValueAtTime, getExponentialRampToValueAtTime: getExponentialRampToValueAtTime, getTargetValueAtTime: getTargetValueAtTime, getValueCurveAtTime: getValueCurveAtTime }; | |
| },{"../constants/AudioParamEvent":59}],129:[function(require,module,exports){ | |
| "use strict"; | |
| // | |
| // | |
| // | |
| // | |
| // clamp details | |
| "use strict"; | |
| /** | |
| * @param {number} value | |
| * @param {number} minValue | |
| * @param {number} maxValue | |
| */ | |
| function clamp(value, minValue, maxValue) { | |
| return Math.max(minValue, Math.min(value, maxValue)); | |
| } | |
| module.exports = clamp; | |
| },{}],138:[function(require,module,exports){ | |
| // | |
| // | |
| // | |
| // | |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment