Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
514 changes: 514 additions & 0 deletions tests/browser/audio-response-timing-integration.test.js

Large diffs are not rendered by default.

628 changes: 628 additions & 0 deletions tests/browser/audio-response-timing.test.js

Large diffs are not rendered by default.

3 changes: 3 additions & 0 deletions tests/browser/interview-lifecycle.test.js
Original file line number Diff line number Diff line change
Expand Up @@ -248,6 +248,9 @@ test("the actual connection preserves refusal reasons and gates the init deadlin
// As init leaves it before connect: Practice work is guarded from page
// load, and nothing in the start may arm the guard for Strict.
const context = {
releaseAudioTiming: () => {},
audioTiming: null,

protected: !strict,
state: {
endsAt: 0,
Expand Down
94 changes: 93 additions & 1 deletion tests/browser/mic-meter.test.js
Original file line number Diff line number Diff line change
Expand Up @@ -13,7 +13,8 @@ import {
MIC_CONFIRM_FRAMES,
preflightReadiness,
} from "../../web/audio-check.js";
import { createMicMeter } from "../../web/mic-meter.js";
import { createMicMeter, startMediaMeter } from "../../web/mic-meter.js";
import { stubGlobal } from "./source.js";

/// A pool with one audio track, whose readiness a test can change.
function fakePool(audioState = "live") {
Expand Down Expand Up @@ -293,3 +294,94 @@ test("a dead device of either kind reopens the request the pool makes", () => {
);
}
});

test("the real media meter samples its own stream immediately and stops on the next frame", async (t) => {
let tick;
let stopped = false;
let closes = 0;
const stream = { label: "microphone stream" };
const streams = [];
const sampleLengths = [];
const peaks = [];
const errors = [];
const analyser = {
fftSize: 0,
get frequencyBinCount() {
return this.fftSize / 2;
},
getByteTimeDomainData(samples) {
sampleLengths.push(samples.length);
samples.fill(128);
samples[511] = 192;
},
};
stubGlobal(
t,
"AudioContext",
class {
createAnalyser() {
return analyser;
}
createMediaStreamSource(input) {
streams.push(input);
return {
connect(target) {
assert.equal(target, analyser);
},
disconnect() {},
};
}
async close() {
closes++;
}
},
);
stubGlobal(t, "requestAnimationFrame", (callback) => {
tick = callback;
return 1;
});
stubGlobal(t, "cancelAnimationFrame", () => {});
const stop = await startMediaMeter(
stream,
(peak) => peaks.push(peak),
(error) => errors.push(error),
() => stopped,
);
assert.equal(
typeof stop,
"function",
"the shared loop exposes explicit cleanup",
);
assert.deepEqual(streams, [stream]);
assert.equal(analyser.fftSize, 1024);
assert.deepEqual(sampleLengths, [512]);
assert.deepEqual(peaks, [0.5]);
tick();
assert.deepEqual(peaks, [0.5, 0.5]);
stopped = true;
tick();
stop();
assert.equal(closes, 1, "cleanup is idempotent after shouldStop");
assert.deepEqual(peaks, [0.5, 0.5]);
assert.deepEqual(errors, []);
});

test("the real media meter reports setup failures as strings", async (t) => {
stubGlobal(
t,
"AudioContext",
class {
constructor() {
throw new Error("No audio context");
}
},
);
const errors = [];
await startMediaMeter(
{},
() => assert.fail("no sample without a context"),
(error) => errors.push(error),
() => false,
);
assert.deepEqual(errors, ["No audio context"]);
});
14 changes: 14 additions & 0 deletions tests/browser/report-recovery.test.js
Original file line number Diff line number Diff line change
Expand Up @@ -509,6 +509,18 @@ test("terminal room disconnect finalizes recovery before clearing the room", asy
page.scope.console = { warn() {} };
const playbackRooms = [];
page.scope.audioPlayback = { release: (room) => playbackRooms.push(room) };
let audioTimingReleases = 0;
let audioTimingResets = 0;

page.scope.releaseAudioTiming = () => {
audioTimingReleases++;
};

page.scope.audioTiming = {
reset: () => {
audioTimingResets++;
},
};
page.scope.preflight = { userStream: { label: "Preflight stream" } };
page.scope.localRecording.needsMicrophone = false;
const mediaCleanup = [];
Expand All @@ -520,6 +532,8 @@ test("terminal room disconnect finalizes recovery before clearing the room", asy
)(new Proxy(page.scope, { has: (target, key) => key in target }));
disconnect();
await settle();
assert.equal(audioTimingReleases, 1);
assert.equal(audioTimingResets, 1);
assert.deepEqual(playbackRooms, [page.room]);
assert.deepEqual(mediaCleanup, [
[page.scope.preflight, { preserveMicrophone: false }],
Expand Down
173 changes: 173 additions & 0 deletions web/audio-response-timing.js
Original file line number Diff line number Diff line change
@@ -0,0 +1,173 @@
import { startMediaMeter } from "./mic-meter.js";
/// Browser-observed gap between Jim entering "speaking" and the first
/// detectable remote audio activity. This is not end-to-end latency.
export function createAudioResponseTiming({
now = () => performance.now(),
report = () => {},
diagnose = () => {},
} = {}) {
let speaking = false;
let startedAt = null;
let active = false;
let armed = false;

function speakingChanged(nextSpeaking, unavailableReason = null) {
if (nextSpeaking === speaking) return;

speaking = nextSpeaking;

if (speaking) {
if (unavailableReason || active) {
diagnose(unavailableReason || "audio already active");
} else {
startedAt = now();
armed = false;
}
} else {
cancelPending("speaking stopped before audio");
}
}

function audioActivity() {
active = true;
if (!speaking || startedAt === null) return;
if (!armed) {
cancelPending("audio already active before a quiet frame");
return;
}

const elapsedMs = now() - startedAt;
startedAt = null;

report(elapsedMs);
}

function audioQuiet() {
active = false;
// A pre-transition quiet frame cannot rule out audio arriving first.
if (startedAt !== null) armed = true;
}

function cancelPending(reason = "measurement canceled") {
if (startedAt !== null) diagnose(reason);
startedAt = null;
armed = false;
}

function reset(reason = "timing reset") {
speaking = false;
active = false;
cancelPending(reason);
}

return {
speakingChanged,
audioActivity,
audioQuiet,
cancelPending,
reset,
};
}
/// Observe remote audio activity without routing it to another output.
/// The returned function releases the analyser and its AudioContext.
export function startAudioActivityMonitor(
Comment thread
ChenYingHan1121 marked this conversation as resolved.
Resolved
track,
onActivity,
{
threshold = 0.05,
onAvailable = () => {},
onUnavailable = () => {},
onQuiet = () => {},
createContext = () => new AudioContext(),
createStream = (mediaTrack) => new MediaStream([mediaTrack]),
schedule = requestAnimationFrame,
cancel = cancelAnimationFrame,
gestureTarget = globalThis.document,
visibilityTarget = globalThis.document,
} = {},
) {
const stream = createStream(track);
const context = createContext();
let stopped = false;
let unavailable;

function notifyAvailability(reason) {
if (unavailable === reason) return;
unavailable = reason;
if (reason === null) onAvailable();
else onUnavailable(reason);
}

function visibilityChanged() {
if (stopped) return;

if (visibilityTarget?.hidden) {
notifyAvailability("page hidden");
}
}

function resumeOnGesture() {
if (stopped || context.state !== "suspended") return;
void context.resume?.().catch(() => {});
}

const stopMeter = startMediaMeter(
stream,
(peak) => {
if (peak > threshold) onActivity();
else onQuiet();
},
(message) => {
throw new Error(message);
},
() => stopped,
{
createContext: () => context,
schedule,
cancel,
sampleSize: 1024,
deferFirstFrame: true,
shouldSample: () => {
const reason = visibilityTarget?.hidden
? "page hidden"
: context.state !== "running"
? `audio context ${context.state}`
: track.readyState !== "live"
? "track ended"
: track.muted
? "track muted"
: track.enabled === false
? "track disabled"
: null;

notifyAvailability(reason);
return reason === null;
},
},
);
try {
resumeOnGesture();
} catch (error) {
stopMeter();
throw error;
}
visibilityTarget?.addEventListener("visibilitychange", visibilityChanged);
gestureTarget?.addEventListener("pointerdown", resumeOnGesture);
gestureTarget?.addEventListener("keydown", resumeOnGesture);

return () => {
if (stopped) return;

stopped = true;

gestureTarget?.removeEventListener("pointerdown", resumeOnGesture);
gestureTarget?.removeEventListener("keydown", resumeOnGesture);

visibilityTarget?.removeEventListener(
"visibilitychange",
visibilityChanged,
);

stopMeter();
};
}
Loading
Loading