summaryrefslogtreecommitdiffstats
path: root/devtools/server/actors/utils/automation-timeline.js
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /devtools/server/actors/utils/automation-timeline.js
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'devtools/server/actors/utils/automation-timeline.js')
-rw-r--r--devtools/server/actors/utils/automation-timeline.js373
1 files changed, 373 insertions, 0 deletions
diff --git a/devtools/server/actors/utils/automation-timeline.js b/devtools/server/actors/utils/automation-timeline.js
new file mode 100644
index 000000000..a086d90be
--- /dev/null
+++ b/devtools/server/actors/utils/automation-timeline.js
@@ -0,0 +1,373 @@
+/**
+ * web-audio-automation-timeline - 1.0.3
+ * https://github.com/jsantell/web-audio-automation-timeline
+ * MIT License, copyright (c) 2014 Jordan Santell
+ */
+!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.Timeline=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
+module.exports = require("./lib/timeline").Timeline;
+
+},{"./lib/timeline":4}],2:[function(require,module,exports){
+var F = require("./formulas");
+
+function TimelineEvent (eventName, value, time, timeConstant, duration) {
+ this.type = eventName;
+ this.value = value;
+ this.time = time;
+ this.constant = timeConstant || 0;
+ this.duration = duration || 0;
+}
+exports.TimelineEvent = TimelineEvent;
+
+
+TimelineEvent.prototype.exponentialApproach = function (lastValue, time) {
+ return F.exponentialApproach(this.time, lastValue, this.value, this.constant, time);
+}
+
+TimelineEvent.prototype.extractValueFromCurve = function (time) {
+ return F.extractValueFromCurve(this.time, this.value, this.value.length, this.duration, time);
+}
+
+TimelineEvent.prototype.linearInterpolate = function (next, time) {
+ return F.linearInterpolate(this.time, this.value, next.time, next.value, time);
+}
+
+TimelineEvent.prototype.exponentialInterpolate = function (next, time) {
+ return F.exponentialInterpolate(this.time, this.value, next.time, next.value, time);
+}
+
+},{"./formulas":3}],3:[function(require,module,exports){
+var EPSILON = 0.0000000001;
+
+exports.linearInterpolate = function (t0, v0, t1, v1, t) {
+ return v0 + (v1 - v0) * ((t - t0) / (t1 - t0));
+};
+
+exports.exponentialInterpolate = function (t0, v0, t1, v1, t) {
+ return v0 * Math.pow(v1 / v0, (t - t0) / (t1 - t0));
+};
+
+exports.extractValueFromCurve = function (start, curve, curveLength, duration, t) {
+ var ratio;
+
+ // If time is after duration, return the last curve value,
+ // or if ratio is >= 1
+ if (t >= start + duration || (ratio = Math.max((t - start) / duration, 0)) >= 1) {
+ return curve[curveLength - 1];
+ }
+
+ return curve[~~(curveLength * ratio)];
+};
+
+exports.exponentialApproach = function (t0, v0, v1, timeConstant, t) {
+ return v1 + (v0 - v1) * Math.exp(-(t - t0) / timeConstant);
+};
+
+// Since we are going to accumulate error by adding 0.01 multiple times
+// in a loop, we want to fuzz the equality check in `getValueAtTime`
+exports.fuzzyEqual = function (lhs, rhs) {
+ return Math.abs(lhs - rhs) < EPSILON;
+};
+
+exports.EPSILON = EPSILON;
+
+},{}],4:[function(require,module,exports){
+var TimelineEvent = require("./event").TimelineEvent;
+var F = require("./formulas");
+
+exports.Timeline = Timeline;
+
+function Timeline (defaultValue) {
+ this.events = [];
+
+ this._value = defaultValue || 0;
+}
+
+Timeline.prototype.getEventCount = function () {
+ return this.events.length;
+};
+
+Timeline.prototype.value = function () {
+ return this._value;
+};
+
+Timeline.prototype.setValue = function (value) {
+ if (this.events.length === 0) {
+ this._value = value;
+ }
+};
+
+Timeline.prototype.getValue = function () {
+ if (this.events.length) {
+ throw new Error("Can only call `getValue` when there are 0 events.");
+ }
+
+ return this._value;
+};
+
+Timeline.prototype.getValueAtTime = function (time) {
+ return this._getValueAtTimeHelper(time);
+};
+
+Timeline.prototype._getValueAtTimeHelper = function (time) {
+ var bailOut = false;
+ var previous = null;
+ var next = null;
+ var lastComputedValue = null; // Used for `setTargetAtTime` nodes
+ var events = this.events;
+ var e;
+
+ for (var i = 0; !bailOut && i < events.length; i++) {
+ if (F.fuzzyEqual(time, events[i].time)) {
+ // Find the last event with the same time as `time`
+ do {
+ ++i;
+ } while (i < events.length && F.fuzzyEqual(time, events[i].time));
+
+ e = events[i - 1];
+
+ // `setTargetAtTime` can be handled no matter what their next event is (if they have one)
+ if (e.type === "setTargetAtTime") {
+ lastComputedValue = this._lastComputedValue(e);
+ return e.exponentialApproach(lastComputedValue, time);
+ }
+
+ // `setValueCurveAtTime` events can be handled no matter what their next event node is
+ // (if they have one)
+ if (e.type === "setValueCurveAtTime") {
+ return e.extractValueFromCurve(time);
+ }
+
+ // For other event types
+ return e.value;
+ }
+ previous = next;
+ next = events[i];
+
+ if (time < events[i].time) {
+ bailOut = true;
+ }
+ }
+
+ // Handle the case where the time is past all of the events
+ if (!bailOut) {
+ previous = next;
+ next = null;
+ }
+
+ // Just return the default value if we did not find anything
+ if (!previous && !next) {
+ return this._value;
+ }
+
+ // If the requested time is before all of the existing events
+ if (!previous) {
+ return this._value;
+ }
+
+ // `setTargetAtTime` can be handled no matter what their next event is (if they have one)
+ if (previous.type === "setTargetAtTime") {
+ lastComputedValue = this._lastComputedValue(previous);
+ return previous.exponentialApproach(lastComputedValue, time);
+ }
+
+ // `setValueCurveAtTime` events can be handled no matter what their next event node is
+ // (if they have one)
+ if (previous.type === "setValueCurveAtTime") {
+ return previous.extractValueFromCurve(time);
+ }
+
+ if (!next) {
+ if (~["setValueAtTime", "linearRampToValueAtTime", "exponentialRampToValueAtTime"].indexOf(previous.type)) {
+ return previous.value;
+ }
+ if (previous.type === "setValueCurveAtTime") {
+ return previous.extractValueFromCurve(time);
+ }
+ if (previous.type === "setTargetAtTime") {
+ throw new Error("unreached");
+ }
+ throw new Error("unreached");
+ }
+
+ // Finally handle the case where we have both a previous and a next event
+ // First handle the case where our range ends up in a ramp event
+ if (next.type === "linearRampToValueAtTime") {
+ return previous.linearInterpolate(next, time);
+ } else if (next.type === "exponentialRampToValueAtTime") {
+ return previous.exponentialInterpolate(next, time);
+ }
+
+ // Now handle all other cases
+ if (~["setValueAtTime", "linearRampToValueAtTime", "exponentialRampToValueAtTime"].indexOf(previous.type)) {
+ // If the next event type is neither linear or exponential ramp,
+ // the value is constant.
+ return previous.value;
+ }
+ if (previous.type === "setValueCurveAtTime") {
+ return previous.extractValueFromCurve(time);
+ }
+ if (previous.type === "setTargetAtTime") {
+ throw new Error("unreached");
+ }
+ throw new Error("unreached");
+};
+
+Timeline.prototype._insertEvent = function (ev) {
+ var events = this.events;
+
+ if (ev.type === "setValueCurveAtTime") {
+ if (!ev.value || !ev.value.length) {
+ throw new Error("NS_ERROR_DOM_SYNTAX_ERR");
+ }
+ }
+
+ if (ev.type === "setTargetAtTime") {
+ if (F.fuzzyEqual(ev.constant, 0)) {
+ throw new Error("NS_ERROR_DOM_SYNTAX_ERR");
+ }
+ }
+
+ // Make sure that non-curve events don't fall within the duration of a
+ // curve event.
+ for (var i = 0; i < events.length; i++) {
+ if (events[i].type === "setValueCurveAtTime" &&
+ events[i].time <= ev.time &&
+ (events[i].time + events[i].duration) >= ev.time) {
+ throw new Error("NS_ERROR_DOM_SYNTAX_ERR");
+ }
+ }
+
+ // Make sure that curve events don't fall in a range which includes other
+ // events.
+ if (ev.type === "setValueCurveAtTime") {
+ for (var i = 0; i < events.length; i++) {
+ if (events[i].time > ev.time &&
+ events[i].time < (ev.time + ev.duration)) {
+ throw new Error("NS_ERROR_DOM_SYNTAX_ERR");
+ }
+ }
+ }
+
+ // Make sure that invalid values are not used for exponential curves
+ if (ev.type === "exponentialRampToValueAtTime") {
+ if (ev.value <= 0) throw new Error("NS_ERROR_DOM_SYNTAX_ERR");
+ var prev = this._getPreviousEvent(ev.time);
+ if (prev) {
+ if (prev.value <= 0) {
+ throw new Error("NS_ERROR_DOM_SYNTAX_ERR");
+ }
+ } else {
+ if (this._value <= 0) {
+ throw new Error("NS_ERROR_DOM_SYNTAX_ERR");
+ }
+ }
+ }
+
+ for (var i = 0; i < events.length; i++) {
+ if (ev.time === events[i].time) {
+ if (ev.type === events[i].type) {
+ // If times and types are equal, replace the event;
+ events[i] = ev;
+ } else {
+ // Otherwise, place the element after the last event of another type
+ do { i++; }
+ while (i < events.length && ev.type !== events[i].type && ev.time === events[i].time);
+ events.splice(i, 0, ev);
+ }
+ return;
+ }
+ // Otherwise, place the event right after the latest existing event
+ if (ev.time < events[i].time) {
+ events.splice(i, 0, ev);
+ return;
+ }
+ }
+
+ // If we couldn't find a place for the event, just append it to the list
+ this.events.push(ev);
+};
+
+Timeline.prototype._getPreviousEvent = function (time) {
+ var previous = null, next = null;
+ var bailOut = false;
+ var events = this.events;
+
+ for (var i = 0; !bailOut && i < events.length; i++) {
+ if (time === events[i]) {
+ do { ++i; }
+ while (i < events.length && time === events[i].time);
+ return events[i - 1];
+ }
+ previous = next;
+ next = events[i];
+ if (time < events[i].time) {
+ bailOut = true;
+ }
+ }
+
+ // Handle the case where the time is past all the events
+ if (!bailOut) {
+ previous = next;
+ }
+
+ return previous;
+};
+
+/**
+ * Calculates the previous value of the timeline, used for
+ * `setTargetAtTime` nodes. Takes an event, and returns
+ * the previous computed value for any sample taken during that
+ * exponential approach node.
+ */
+Timeline.prototype._lastComputedValue = function (event) {
+ // If equal times, return the value for the previous event, before
+ // the `setTargetAtTime` node.
+ var lastEvent = this._getPreviousEvent(event.time - F.EPSILON);
+
+ // If no event before the setTargetAtTime event, then return the
+ // intrinsic value.
+ if (!lastEvent) {
+ return this._value;
+ }
+ // Otherwise, return the value for the previous event, which should
+ // always be the last computed value (? I think?)
+ else {
+ return lastEvent.value;
+ }
+};
+
+Timeline.prototype.setValueAtTime = function (value, startTime) {
+ this._insertEvent(new TimelineEvent("setValueAtTime", value, startTime));
+};
+
+Timeline.prototype.linearRampToValueAtTime = function (value, endTime) {
+ this._insertEvent(new TimelineEvent("linearRampToValueAtTime", value, endTime));
+};
+
+Timeline.prototype.exponentialRampToValueAtTime = function (value, endTime) {
+ this._insertEvent(new TimelineEvent("exponentialRampToValueAtTime", value, endTime));
+};
+
+Timeline.prototype.setTargetAtTime = function (value, startTime, timeConstant) {
+ this._insertEvent(new TimelineEvent("setTargetAtTime", value, startTime, timeConstant));
+};
+
+Timeline.prototype.setValueCurveAtTime = function (value, startTime, duration) {
+ this._insertEvent(new TimelineEvent("setValueCurveAtTime", value, startTime, null, duration));
+};
+
+Timeline.prototype.cancelScheduledValues = function (time) {
+ for (var i = 0; i < this.events.length; i++) {
+ if (this.events[i].time >= time) {
+ this.events = this.events.slice(0, i);
+ break;
+ }
+ }
+};
+
+Timeline.prototype.cancelAllEvents = function () {
+ this.events.length = 0;
+};
+
+},{"./event":2,"./formulas":3}]},{},[1])(1)
+}); \ No newline at end of file