matrix-react-sdk
Version:
SDK for matrix.org using React
137 lines (132 loc) • 18.1 kB
JavaScript
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.PlaybackClock = void 0;
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
var _matrixWidgetApi = require("matrix-widget-api");
/*
Copyright 2024 New Vector Ltd.
Copyright 2021 The Matrix.org Foundation C.I.C.
SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only
Please see LICENSE files in the repository root for full details.
*/
/**
* Tracks accurate human-perceptible time for an audio clip, as informed
* by managed playback. This clock is tightly coupled with the operation
* of the Playback class, making assumptions about how the provided
* AudioContext will be used (suspended/resumed to preserve time, etc).
*
* But why do we need a clock? The AudioContext exposes time information,
* and so does the audio buffer, but not in a way that is useful for humans
* to perceive. The audio buffer time is often lagged behind the context
* time due to internal processing delays of the audio API. Additionally,
* the context's time is tracked from when it was first initialized/started,
* not related to positioning within the clip. However, the context time
* is the most accurate time we can use to determine position within the
* clip if we're fast enough to track the pauses and stops.
*
* As a result, we track every play, pause, stop, and seek event from the
* Playback class (kinda: it calls us, which is close enough to the same
* thing). These events are then tracked on the AudioContext time scale,
* with assumptions that code execution will result in negligible desync
* of the clock, or at least no perceptible difference in time. It's
* extremely important that the calling code, and the clock's own code,
* is extremely fast between the event happening and the clock time being
* tracked - anything more than a dozen milliseconds is likely to stack up
* poorly, leading to clock desync.
*
* Clock desync can be dangerous for the stability of the playback controls:
* if the clock thinks the user is somewhere else in the clip, it could
* inform the playback of the wrong place in time, leading to dead air in
* the output or, if severe enough, a clock that won't stop running while
* the audio is paused/stopped. Other examples include the clip stopping at
* 90% time due to playback ending, the clip playing from the wrong spot
* relative to the time, and negative clock time.
*
* Note that the clip duration is fed to the clock: this is to ensure that
* we have the most accurate time possible to present.
*/
class PlaybackClock {
constructor(context) {
(0, _defineProperty2.default)(this, "clipStart", 0);
(0, _defineProperty2.default)(this, "stopped", true);
(0, _defineProperty2.default)(this, "lastCheck", 0);
(0, _defineProperty2.default)(this, "observable", new _matrixWidgetApi.SimpleObservable());
(0, _defineProperty2.default)(this, "timerId", void 0);
(0, _defineProperty2.default)(this, "clipDuration", 0);
(0, _defineProperty2.default)(this, "placeholderDuration", 0);
(0, _defineProperty2.default)(this, "checkTime", (force = false) => {
const now = this.timeSeconds; // calculated dynamically
if (this.lastCheck !== now || force) {
this.observable.update([now, this.durationSeconds]);
this.lastCheck = now;
}
});
this.context = context;
}
get durationSeconds() {
return this.clipDuration || this.placeholderDuration;
}
set durationSeconds(val) {
this.clipDuration = val;
this.observable.update([this.timeSeconds, this.clipDuration]);
}
get timeSeconds() {
// The modulo is to ensure that we're only looking at the most recent clip
// time, as the context is long-running and multiple plays might not be
// informed to us (if the control is looping, for example). By taking the
// remainder of the division operation, we're assuming that playback is
// incomplete or stopped, thus giving an accurate position within the active
// clip segment.
return (this.context.currentTime - this.clipStart) % this.clipDuration;
}
get liveData() {
return this.observable;
}
/**
* Populates default information about the audio clip from the event body.
* The placeholders will be overridden once known.
* @param {MatrixEvent} event The event to use for placeholders.
*/
populatePlaceholdersFrom(event) {
const durationMs = Number(event.getContent()["info"]?.["duration"]);
if (Number.isFinite(durationMs)) this.placeholderDuration = durationMs / 1000;
}
/**
* Mark the time in the audio context where the clip starts/has been loaded.
* This is to ensure the clock isn't skewed into thinking it is ~0.5s into
* a clip when the duration is set.
*/
flagLoadTime() {
this.clipStart = this.context.currentTime;
}
flagStart() {
if (this.stopped) {
this.clipStart = this.context.currentTime;
this.stopped = false;
}
if (!this.timerId) {
// 100ms interval to make sure the time is as accurate as possible without being overly insane
this.timerId = window.setInterval(this.checkTime, 100);
}
}
flagStop() {
this.stopped = true;
// Reset the clock time now so that the update going out will trigger components
// to check their seek/position information (alongside the clock).
this.clipStart = this.context.currentTime;
}
syncTo(contextTime, clipTime) {
this.clipStart = contextTime - clipTime;
this.stopped = false; // count as a mid-stream pause (if we were stopped)
this.checkTime(true);
}
destroy() {
this.observable.close();
if (this.timerId) clearInterval(this.timerId);
}
}
exports.PlaybackClock = PlaybackClock;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_matrixWidgetApi","require","PlaybackClock","constructor","context","_defineProperty2","default","SimpleObservable","force","now","timeSeconds","lastCheck","observable","update","durationSeconds","clipDuration","placeholderDuration","val","currentTime","clipStart","liveData","populatePlaceholdersFrom","event","durationMs","Number","getContent","isFinite","flagLoadTime","flagStart","stopped","timerId","window","setInterval","checkTime","flagStop","syncTo","contextTime","clipTime","destroy","close","clearInterval","exports"],"sources":["../../src/audio/PlaybackClock.ts"],"sourcesContent":["/*\nCopyright 2024 New Vector Ltd.\nCopyright 2021 The Matrix.org Foundation C.I.C.\n\nSPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only\nPlease see LICENSE files in the repository root for full details.\n*/\n\nimport { SimpleObservable } from \"matrix-widget-api\";\nimport { MatrixEvent } from \"matrix-js-sdk/src/matrix\";\n\nimport { IDestroyable } from \"../utils/IDestroyable\";\n\n/**\n * Tracks accurate human-perceptible time for an audio clip, as informed\n * by managed playback. This clock is tightly coupled with the operation\n * of the Playback class, making assumptions about how the provided\n * AudioContext will be used (suspended/resumed to preserve time, etc).\n *\n * But why do we need a clock? The AudioContext exposes time information,\n * and so does the audio buffer, but not in a way that is useful for humans\n * to perceive. The audio buffer time is often lagged behind the context\n * time due to internal processing delays of the audio API. Additionally,\n * the context's time is tracked from when it was first initialized/started,\n * not related to positioning within the clip. However, the context time\n * is the most accurate time we can use to determine position within the\n * clip if we're fast enough to track the pauses and stops.\n *\n * As a result, we track every play, pause, stop, and seek event from the\n * Playback class (kinda: it calls us, which is close enough to the same\n * thing). These events are then tracked on the AudioContext time scale,\n * with assumptions that code execution will result in negligible desync\n * of the clock, or at least no perceptible difference in time. It's\n * extremely important that the calling code, and the clock's own code,\n * is extremely fast between the event happening and the clock time being\n * tracked - anything more than a dozen milliseconds is likely to stack up\n * poorly, leading to clock desync.\n *\n * Clock desync can be dangerous for the stability of the playback controls:\n * if the clock thinks the user is somewhere else in the clip, it could\n * inform the playback of the wrong place in time, leading to dead air in\n * the output or, if severe enough, a clock that won't stop running while\n * the audio is paused/stopped. Other examples include the clip stopping at\n * 90% time due to playback ending, the clip playing from the wrong spot\n * relative to the time, and negative clock time.\n *\n * Note that the clip duration is fed to the clock: this is to ensure that\n * we have the most accurate time possible to present.\n */\nexport class PlaybackClock implements IDestroyable {\n    private clipStart = 0;\n    private stopped = true;\n    private lastCheck = 0;\n    private observable = new SimpleObservable<number[]>();\n    private timerId?: number;\n    private clipDuration = 0;\n    private placeholderDuration = 0;\n\n    public constructor(private context: AudioContext) {}\n\n    public get durationSeconds(): number {\n        return this.clipDuration || this.placeholderDuration;\n    }\n\n    public set durationSeconds(val: number) {\n        this.clipDuration = val;\n        this.observable.update([this.timeSeconds, this.clipDuration]);\n    }\n\n    public get timeSeconds(): number {\n        // The modulo is to ensure that we're only looking at the most recent clip\n        // time, as the context is long-running and multiple plays might not be\n        // informed to us (if the control is looping, for example). By taking the\n        // remainder of the division operation, we're assuming that playback is\n        // incomplete or stopped, thus giving an accurate position within the active\n        // clip segment.\n        return (this.context.currentTime - this.clipStart) % this.clipDuration;\n    }\n\n    public get liveData(): SimpleObservable<number[]> {\n        return this.observable;\n    }\n\n    private checkTime = (force = false): void => {\n        const now = this.timeSeconds; // calculated dynamically\n        if (this.lastCheck !== now || force) {\n            this.observable.update([now, this.durationSeconds]);\n            this.lastCheck = now;\n        }\n    };\n\n    /**\n     * Populates default information about the audio clip from the event body.\n     * The placeholders will be overridden once known.\n     * @param {MatrixEvent} event The event to use for placeholders.\n     */\n    public populatePlaceholdersFrom(event: MatrixEvent): void {\n        const durationMs = Number(event.getContent()[\"info\"]?.[\"duration\"]);\n        if (Number.isFinite(durationMs)) this.placeholderDuration = durationMs / 1000;\n    }\n\n    /**\n     * Mark the time in the audio context where the clip starts/has been loaded.\n     * This is to ensure the clock isn't skewed into thinking it is ~0.5s into\n     * a clip when the duration is set.\n     */\n    public flagLoadTime(): void {\n        this.clipStart = this.context.currentTime;\n    }\n\n    public flagStart(): void {\n        if (this.stopped) {\n            this.clipStart = this.context.currentTime;\n            this.stopped = false;\n        }\n\n        if (!this.timerId) {\n            // 100ms interval to make sure the time is as accurate as possible without being overly insane\n            this.timerId = window.setInterval(this.checkTime, 100);\n        }\n    }\n\n    public flagStop(): void {\n        this.stopped = true;\n\n        // Reset the clock time now so that the update going out will trigger components\n        // to check their seek/position information (alongside the clock).\n        this.clipStart = this.context.currentTime;\n    }\n\n    public syncTo(contextTime: number, clipTime: number): void {\n        this.clipStart = contextTime - clipTime;\n        this.stopped = false; // count as a mid-stream pause (if we were stopped)\n        this.checkTime(true);\n    }\n\n    public destroy(): void {\n        this.observable.close();\n        if (this.timerId) clearInterval(this.timerId);\n    }\n}\n"],"mappings":"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","ignoreList":[]}