fix: Hold the 2-way audio backchannel open for the shortest possible time (#2697)
The card claimed a camera's ONVIF audio backchannel in two places that had nothing to do with a call: the capability probe at camera init (`µphone`), and a pre-armed `sendonly` audio transceiver on every live WebRTC offer. Merely looking at a dashboard occupied the camera's speaker line. Outbound audio now travels on its own audio-only WebRTC connection, opened when a call is answered and closed when it ends. - The backchannel is claimed only for the duration of a call. Idle viewing claims nothing. - Two-way audio now works in `mse`, `mp4` and `mjpeg` modes (note: the outbound audio still traverses WebRTC). - No renegotiation and no video blink at call start or end. - A call that cannot carry audio now reports it and ends, instead of showing a live microphone that goes nowhere. - `live.microphone.always_connected` is now purely about the browser microphone permission prompt. - Call setup measured at 66ms (LAN) and ~260ms (cellular) for ICE and DTLS, plus ~300ms for `go2rtc` to open an RTSP backchannel. Verified against a live Frigate + `go2rtc` instance, and by unit tests at 100% coverage. - Closes #2691 - Closes #2039 - Closes #2178 Ref #2299 -- the probe no longer opens a backchannel, but it still runs per camera on every load and reconnect, and still dials the camera on the direct-`go2rtc` path. Caching remains to be done. Ref AlexxIT/go2rtc#1860 -- once a call has opened a backchannel, `go2rtc` keeps that media set up on the camera's RTSP session for the life of the producer. Diagnoses #2678
This commit is contained in:
Dermot Duffy
-29
@@ -1,29 +0,0 @@
|
||||
import { describe, expect, it, vi } from 'vitest';
|
||||
|
||||
import {
|
||||
createBrowserPeerConnection,
|
||||
GO2RTC_PEER_CONNECTION_CONFIG,
|
||||
} from '../../../../../../src/components-lib/live/providers/go2rtc-experimental/adapters/peer-connection';
|
||||
|
||||
describe('peer-connection', () => {
|
||||
it('should configure two STUN servers with max-bundle', () => {
|
||||
expect(GO2RTC_PEER_CONNECTION_CONFIG).toEqual({
|
||||
bundlePolicy: 'max-bundle',
|
||||
iceServers: [
|
||||
{
|
||||
urls: ['stun:stun.l.google.com:19302', 'stun:stun.cloudflare.com:3478'],
|
||||
},
|
||||
],
|
||||
});
|
||||
});
|
||||
|
||||
it('should construct a real peer connection', () => {
|
||||
const RTCPeerConnectionMock = vi.fn();
|
||||
vi.stubGlobal('RTCPeerConnection', RTCPeerConnectionMock);
|
||||
|
||||
createBrowserPeerConnection(GO2RTC_PEER_CONNECTION_CONFIG);
|
||||
|
||||
expect(RTCPeerConnectionMock).toHaveBeenCalledWith(GO2RTC_PEER_CONNECTION_CONFIG);
|
||||
vi.unstubAllGlobals();
|
||||
});
|
||||
});
|
||||
@@ -1,7 +1,7 @@
|
||||
import { describe, expect, it, vi } from 'vitest';
|
||||
|
||||
import { OffscreenVideo } from '../../../../../src/components-lib/live/providers/go2rtc-experimental/offscreen-video';
|
||||
import { FakeMediaStream, FakeMediaStreamTrack } from './test-utils';
|
||||
import { FakeMediaStream, FakeMediaStreamTrack } from '../../../../go2rtc/test-utils';
|
||||
|
||||
// @vitest-environment jsdom
|
||||
describe('OffscreenVideo', () => {
|
||||
|
||||
@@ -26,7 +26,7 @@ import {
|
||||
FakeMediaStreamTrack,
|
||||
FakeRTCPeerConnection,
|
||||
FakeWebSocket,
|
||||
} from './test-utils';
|
||||
} from '../../../../go2rtc/test-utils';
|
||||
|
||||
const H264_PROFILE: StreamProfile = {
|
||||
hasVideo: true,
|
||||
@@ -128,7 +128,6 @@ describe('Go2RTCSessionController', () => {
|
||||
source.getCapabilities.mockReturnValue({
|
||||
supportsPause: true,
|
||||
hasAudio: true,
|
||||
has2WayAudio: false,
|
||||
});
|
||||
source.getTechnology.mockReturnValue([mode]);
|
||||
binarySources.push(source);
|
||||
@@ -154,15 +153,12 @@ describe('Go2RTCSessionController', () => {
|
||||
source.getCapabilities.mockReturnValue({
|
||||
supportsPause: true,
|
||||
hasAudio: true,
|
||||
has2WayAudio: false,
|
||||
});
|
||||
source.getTechnology.mockReturnValue(['webrtc']);
|
||||
source.getMediaStream.mockReturnValue(webRTCStream.asMediaStream());
|
||||
source.getPeerConnection.mockReturnValue(
|
||||
options?.webRTCPeerConnection?.asPeerConnection() ?? null,
|
||||
);
|
||||
source.setMicrophoneStream.mockResolvedValue(undefined);
|
||||
|
||||
webRTCSources.push(source);
|
||||
return source;
|
||||
},
|
||||
@@ -179,7 +175,6 @@ describe('Go2RTCSessionController', () => {
|
||||
const mediaLoadedCallback = vi.fn();
|
||||
const surfaceCommittedCallback = vi.fn();
|
||||
const streamErrorCallback = vi.fn();
|
||||
const microphoneErrorCallback = vi.fn();
|
||||
|
||||
const session = new Go2RTCSessionController(
|
||||
{
|
||||
@@ -188,7 +183,6 @@ describe('Go2RTCSessionController', () => {
|
||||
mediaLoadedCallback,
|
||||
surfaceCommittedCallback,
|
||||
streamErrorCallback,
|
||||
microphoneErrorCallback,
|
||||
},
|
||||
{ createWebSocket, createBinarySource, createWebRTCSource, createVideoElement },
|
||||
);
|
||||
@@ -204,7 +198,6 @@ describe('Go2RTCSessionController', () => {
|
||||
createWebRTCSource,
|
||||
createWebSocket,
|
||||
streamErrorCallback,
|
||||
microphoneErrorCallback,
|
||||
mediaLoadedCallback,
|
||||
offscreenVideos,
|
||||
session,
|
||||
@@ -285,7 +278,6 @@ describe('Go2RTCSessionController', () => {
|
||||
getCardWideConfig: () => null,
|
||||
mediaLoadedCallback: vi.fn(),
|
||||
streamErrorCallback: vi.fn(),
|
||||
microphoneErrorCallback: vi.fn(),
|
||||
});
|
||||
session.connect('ws://localhost:1/api/ws', createSurfaces().surfaces, ['mse']);
|
||||
session.reset();
|
||||
@@ -528,42 +520,6 @@ describe('Go2RTCSessionController', () => {
|
||||
expect(createWebSocket).toHaveBeenCalledTimes(2);
|
||||
});
|
||||
|
||||
it('should pre-arm the WebRTC source with the current microphone stream', () => {
|
||||
const { session, surfaces, websockets, webRTCOptions } = setup();
|
||||
const micStream = new FakeMediaStream([
|
||||
new FakeMediaStreamTrack('audio'),
|
||||
]).asMediaStream();
|
||||
session.setMicrophoneStream(micStream);
|
||||
session.connect('http://host/api/ws?src=camera', surfaces, ['webrtc']);
|
||||
websockets[0].fireOpen();
|
||||
|
||||
expect(webRTCOptions[0]?.microphoneStream).toBe(micStream);
|
||||
});
|
||||
|
||||
it('should report a microphone error without disturbing the stream', () => {
|
||||
const {
|
||||
session,
|
||||
surfaces,
|
||||
websockets,
|
||||
webRTCOptions,
|
||||
webRTCSources,
|
||||
microphoneErrorCallback,
|
||||
streamErrorCallback,
|
||||
} = setup();
|
||||
session.connect('http://host/api/ws?src=camera', surfaces, ['webrtc']);
|
||||
websockets[0].fireOpen();
|
||||
|
||||
webRTCOptions[0]?.microphoneErrorCallback?.('InvalidStateError');
|
||||
|
||||
expect(microphoneErrorCallback).toHaveBeenCalledWith('InvalidStateError');
|
||||
|
||||
// The inbound video is unaffected by an outbound audio failure, so the
|
||||
// source keeps running and the session neither escalates nor reconnects.
|
||||
expect(streamErrorCallback).not.toHaveBeenCalled();
|
||||
expect(webRTCSources[0].stop).not.toHaveBeenCalled();
|
||||
expect(websockets).toHaveLength(1);
|
||||
});
|
||||
|
||||
it('should re-dispatch loaded media on an audio mute transition', () => {
|
||||
const peerConnection = new FakeRTCPeerConnection();
|
||||
const audioTransceiver = peerConnection.addTransceiver('audio', {
|
||||
@@ -858,26 +814,6 @@ describe('Go2RTCSessionController', () => {
|
||||
});
|
||||
});
|
||||
|
||||
describe('microphone', () => {
|
||||
it('should forward a microphone change to the WebRTC source', () => {
|
||||
const { session, surfaces, websockets, webRTCSources } = setup();
|
||||
session.connect('http://host/api/ws?src=camera', surfaces, ['webrtc']);
|
||||
websockets[0].fireOpen();
|
||||
const micStream = new FakeMediaStream([
|
||||
new FakeMediaStreamTrack('audio'),
|
||||
]).asMediaStream();
|
||||
session.setMicrophoneStream(micStream);
|
||||
|
||||
expect(webRTCSources[0].setMicrophoneStream).toHaveBeenCalledWith(micStream);
|
||||
});
|
||||
|
||||
it('should tolerate a microphone change with no WebRTC source', () => {
|
||||
const { session } = setup();
|
||||
|
||||
expect(() => session.setMicrophoneStream(null)).not.toThrow();
|
||||
});
|
||||
});
|
||||
|
||||
describe('lifecycle', () => {
|
||||
it('should stop the source and reconnect on unexpected closure', () => {
|
||||
const { session, surfaces, websockets, binarySources, createWebSocket } = setup();
|
||||
@@ -1078,16 +1014,6 @@ describe('Go2RTCSessionController', () => {
|
||||
expect(mediaLoadedCallback).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should swallow a rejected microphone update', async () => {
|
||||
const { session, surfaces, websockets, webRTCSources } = setup();
|
||||
session.connect('http://host/api/ws?src=camera', surfaces, ['webrtc']);
|
||||
websockets[0].fireOpen();
|
||||
webRTCSources[0].setMicrophoneStream.mockRejectedValue(new Error('replace'));
|
||||
|
||||
expect(() => session.setMicrophoneStream(null)).not.toThrow();
|
||||
await Promise.resolve();
|
||||
});
|
||||
|
||||
it('should ignore callbacks fired while a binary source is constructed', () => {
|
||||
const websockets: FakeWebSocket[] = [];
|
||||
const createWebSocket = vi.fn<(url: string) => WebSocket>(() => {
|
||||
@@ -1112,7 +1038,6 @@ describe('Go2RTCSessionController', () => {
|
||||
getCardWideConfig: () => null,
|
||||
mediaLoadedCallback,
|
||||
streamErrorCallback: vi.fn(),
|
||||
microphoneErrorCallback: vi.fn(),
|
||||
},
|
||||
{ createWebSocket, createBinarySource },
|
||||
);
|
||||
@@ -1147,7 +1072,6 @@ describe('Go2RTCSessionController', () => {
|
||||
getCardWideConfig: () => null,
|
||||
mediaLoadedCallback,
|
||||
streamErrorCallback: vi.fn(),
|
||||
microphoneErrorCallback: vi.fn(),
|
||||
},
|
||||
{ createWebSocket, createWebRTCSource },
|
||||
);
|
||||
@@ -1174,7 +1098,6 @@ describe('Go2RTCSessionController', () => {
|
||||
getCardWideConfig: () => null,
|
||||
mediaLoadedCallback: vi.fn(),
|
||||
streamErrorCallback: vi.fn(),
|
||||
microphoneErrorCallback: vi.fn(),
|
||||
},
|
||||
{ createWebSocket },
|
||||
);
|
||||
@@ -1206,7 +1129,6 @@ describe('Go2RTCSessionController', () => {
|
||||
getCardWideConfig: () => null,
|
||||
mediaLoadedCallback: vi.fn(),
|
||||
streamErrorCallback: vi.fn(),
|
||||
microphoneErrorCallback: vi.fn(),
|
||||
},
|
||||
{ createWebSocket },
|
||||
);
|
||||
@@ -1247,7 +1169,6 @@ describe('Go2RTCSessionController', () => {
|
||||
getCardWideConfig: () => null,
|
||||
mediaLoadedCallback: vi.fn(),
|
||||
streamErrorCallback: vi.fn(),
|
||||
microphoneErrorCallback: vi.fn(),
|
||||
},
|
||||
{ createWebSocket, createBinarySource, createWebRTCSource },
|
||||
);
|
||||
|
||||
@@ -1,254 +0,0 @@
|
||||
import { describe, expect, it, vi } from 'vitest';
|
||||
|
||||
import { SignalingChannel } from '../../../../../src/components-lib/live/providers/go2rtc-experimental/signaling';
|
||||
import { FakeWebSocket } from './test-utils';
|
||||
|
||||
describe('SignalingChannel', () => {
|
||||
const setup = (options?: {
|
||||
openCallback?: () => void;
|
||||
disconnectCallback?: () => void;
|
||||
}) => {
|
||||
const websockets: FakeWebSocket[] = [];
|
||||
const createWebSocket = vi.fn<(url: string) => WebSocket>(() => {
|
||||
const websocket = new FakeWebSocket();
|
||||
websockets.push(websocket);
|
||||
return websocket.asWebSocket();
|
||||
});
|
||||
const channel = new SignalingChannel(
|
||||
'ws://host/api/ws?src=camera',
|
||||
{
|
||||
openCallback: options?.openCallback,
|
||||
disconnectCallback: options?.disconnectCallback,
|
||||
},
|
||||
{ createWebSocket },
|
||||
);
|
||||
return { channel, createWebSocket, websockets };
|
||||
};
|
||||
|
||||
it('should connect with an arraybuffer binary type', () => {
|
||||
const { channel, createWebSocket, websockets } = setup();
|
||||
channel.connect();
|
||||
|
||||
expect(createWebSocket).toHaveBeenCalledWith('ws://host/api/ws?src=camera');
|
||||
expect(websockets[0].binaryType).toBe('arraybuffer');
|
||||
});
|
||||
|
||||
it('should not connect twice', () => {
|
||||
const { channel, createWebSocket } = setup();
|
||||
channel.connect();
|
||||
channel.connect();
|
||||
|
||||
expect(createWebSocket).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it('should report open state and call the open callback', () => {
|
||||
const openCallback = vi.fn();
|
||||
const { channel, websockets } = setup({ openCallback });
|
||||
channel.connect();
|
||||
|
||||
expect(channel.isOpen()).toBe(false);
|
||||
|
||||
websockets[0].fireOpen();
|
||||
|
||||
expect(channel.isOpen()).toBe(true);
|
||||
expect(openCallback).toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should tolerate an absent open callback', () => {
|
||||
const { channel, websockets } = setup();
|
||||
channel.connect();
|
||||
|
||||
expect(() => websockets[0].fireOpen()).not.toThrow();
|
||||
});
|
||||
|
||||
it('should not send before the connection is open', () => {
|
||||
const { channel, websockets } = setup();
|
||||
channel.connect();
|
||||
channel.send({ type: 'mse', value: 'codecs' });
|
||||
|
||||
expect(websockets[0].send).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should send JSON once open', () => {
|
||||
const { channel, websockets } = setup();
|
||||
channel.connect();
|
||||
websockets[0].fireOpen();
|
||||
const message = { type: 'mse', value: 'codecs' };
|
||||
channel.send(message);
|
||||
|
||||
expect(websockets[0].sent).toEqual([JSON.stringify(message)]);
|
||||
});
|
||||
|
||||
it('should dispatch parsed messages to subscribers', () => {
|
||||
const { channel, websockets } = setup();
|
||||
const callback = vi.fn();
|
||||
channel.subscribeToMessages(callback);
|
||||
channel.connect();
|
||||
websockets[0].fireMessage('{"type":"mse","value":"video/mp4"}');
|
||||
|
||||
expect(callback).toHaveBeenCalledWith({ type: 'mse', value: 'video/mp4' });
|
||||
});
|
||||
|
||||
it('should stop dispatching after unsubscribe', () => {
|
||||
const { channel, websockets } = setup();
|
||||
const callback = vi.fn();
|
||||
const unsubscribe = channel.subscribeToMessages(callback);
|
||||
channel.connect();
|
||||
unsubscribe();
|
||||
websockets[0].fireMessage('{"type":"mse"}');
|
||||
|
||||
expect(callback).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should dispatch to remaining subscribers when one unsubscribes during dispatch', () => {
|
||||
const { channel, websockets } = setup();
|
||||
const secondCallback = vi.fn();
|
||||
const unsubscribeDuringDispatch = vi.fn((): void => {
|
||||
unsubscribe();
|
||||
});
|
||||
const unsubscribe = channel.subscribeToMessages(unsubscribeDuringDispatch);
|
||||
channel.subscribeToMessages(secondCallback);
|
||||
channel.connect();
|
||||
websockets[0].fireMessage('{"type":"mse"}');
|
||||
|
||||
expect(unsubscribeDuringDispatch).toHaveBeenCalledTimes(1);
|
||||
expect(secondCallback).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it('should ignore invalid JSON', () => {
|
||||
const { channel, websockets } = setup();
|
||||
const callback = vi.fn();
|
||||
channel.subscribeToMessages(callback);
|
||||
channel.connect();
|
||||
websockets[0].fireMessage('NOT JSON');
|
||||
|
||||
expect(callback).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should ignore malformed messages', () => {
|
||||
const { channel, websockets } = setup();
|
||||
const callback = vi.fn();
|
||||
channel.subscribeToMessages(callback);
|
||||
channel.connect();
|
||||
websockets[0].fireMessage('{"type":6}');
|
||||
|
||||
expect(callback).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should ignore unexpected data types', () => {
|
||||
const { channel, websockets } = setup();
|
||||
const callback = vi.fn();
|
||||
channel.subscribeToMessages(callback);
|
||||
channel.connect();
|
||||
websockets[0].fireMessage(42);
|
||||
|
||||
expect(callback).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should route binary data to the binary callback', () => {
|
||||
const { channel, websockets } = setup();
|
||||
const binaryCallback = vi.fn();
|
||||
channel.setBinaryCallback(binaryCallback);
|
||||
channel.connect();
|
||||
const data = new ArrayBuffer(8);
|
||||
websockets[0].fireMessage(data);
|
||||
|
||||
expect(binaryCallback).toHaveBeenCalledWith(data);
|
||||
});
|
||||
|
||||
it('should drop binary data without a binary callback', () => {
|
||||
const { channel, websockets } = setup();
|
||||
channel.connect();
|
||||
|
||||
expect(() => websockets[0].fireMessage(new ArrayBuffer(8))).not.toThrow();
|
||||
});
|
||||
|
||||
it('should drop binary data after the binary callback is cleared', () => {
|
||||
const { channel, websockets } = setup();
|
||||
const binaryCallback = vi.fn();
|
||||
channel.setBinaryCallback(binaryCallback);
|
||||
channel.setBinaryCallback(null);
|
||||
channel.connect();
|
||||
websockets[0].fireMessage(new ArrayBuffer(8));
|
||||
|
||||
expect(binaryCallback).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should close the underlying websocket without firing the disconnect callback', () => {
|
||||
const disconnectCallback = vi.fn();
|
||||
const { channel, websockets } = setup({ disconnectCallback });
|
||||
channel.connect();
|
||||
websockets[0].fireOpen();
|
||||
channel.close();
|
||||
|
||||
expect(websockets[0].close).toHaveBeenCalled();
|
||||
expect(channel.isOpen()).toBe(false);
|
||||
expect(disconnectCallback).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should tolerate closing when never connected', () => {
|
||||
const { channel } = setup();
|
||||
|
||||
expect(() => channel.close()).not.toThrow();
|
||||
});
|
||||
|
||||
it('should ignore websocket events delivered after close', () => {
|
||||
const openCallback = vi.fn();
|
||||
const disconnectCallback = vi.fn();
|
||||
const messageCallback = vi.fn();
|
||||
const { channel, websockets } = setup({ openCallback, disconnectCallback });
|
||||
channel.subscribeToMessages(messageCallback);
|
||||
channel.connect();
|
||||
channel.close();
|
||||
|
||||
websockets[0].fireOpen();
|
||||
websockets[0].fireMessage('{"type":"mse"}');
|
||||
websockets[0].fireClose();
|
||||
|
||||
expect(openCallback).not.toHaveBeenCalled();
|
||||
expect(messageCallback).not.toHaveBeenCalled();
|
||||
expect(disconnectCallback).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should fire the disconnect callback on unexpected closure', () => {
|
||||
const disconnectCallback = vi.fn();
|
||||
const { channel, websockets } = setup({ disconnectCallback });
|
||||
channel.connect();
|
||||
websockets[0].fireOpen();
|
||||
websockets[0].fireClose();
|
||||
|
||||
expect(disconnectCallback).toHaveBeenCalledTimes(1);
|
||||
expect(channel.isOpen()).toBe(false);
|
||||
});
|
||||
|
||||
it('should tolerate an absent disconnect callback on unexpected closure', () => {
|
||||
const { channel, websockets } = setup();
|
||||
channel.connect();
|
||||
|
||||
expect(() => websockets[0].fireClose()).not.toThrow();
|
||||
});
|
||||
|
||||
it('should allow reconnecting after unexpected closure', () => {
|
||||
const { channel, createWebSocket, websockets } = setup();
|
||||
channel.connect();
|
||||
websockets[0].fireClose();
|
||||
channel.connect();
|
||||
|
||||
expect(createWebSocket).toHaveBeenCalledTimes(2);
|
||||
});
|
||||
|
||||
it('should construct a real websocket by default', () => {
|
||||
// A mock implementation must be callable with `new`, so it cannot be an
|
||||
// arrow function.
|
||||
const webSocketConstructor = vi.fn(function () {
|
||||
return new FakeWebSocket().asWebSocket();
|
||||
});
|
||||
vi.stubGlobal('WebSocket', webSocketConstructor);
|
||||
const channel = new SignalingChannel('ws://host/api/ws', {});
|
||||
channel.connect();
|
||||
channel.close();
|
||||
|
||||
expect(webSocketConstructor).toHaveBeenCalledWith('ws://host/api/ws');
|
||||
vi.unstubAllGlobals();
|
||||
});
|
||||
});
|
||||
@@ -568,7 +568,6 @@ describe('MSEStreamSource', () => {
|
||||
expect(source.getCapabilities()).toEqual({
|
||||
supportsPause: true,
|
||||
hasAudio: false,
|
||||
has2WayAudio: false,
|
||||
});
|
||||
});
|
||||
|
||||
@@ -579,7 +578,6 @@ describe('MSEStreamSource', () => {
|
||||
expect(setupResult.source.getCapabilities()).toEqual({
|
||||
supportsPause: true,
|
||||
hasAudio: true,
|
||||
has2WayAudio: false,
|
||||
});
|
||||
});
|
||||
|
||||
@@ -595,7 +593,6 @@ describe('MSEStreamSource', () => {
|
||||
expect(setupResult.source.getCapabilities()).toEqual({
|
||||
supportsPause: true,
|
||||
hasAudio: false,
|
||||
has2WayAudio: false,
|
||||
});
|
||||
});
|
||||
|
||||
|
||||
@@ -5,17 +5,17 @@ import type {
|
||||
StreamSourceContext,
|
||||
VideoStreamTarget,
|
||||
} from '../../../../../../src/components-lib/live/providers/go2rtc-experimental/types';
|
||||
import { flushPromises } from '../../../../../test-utils';
|
||||
import {
|
||||
FakeMediaStream,
|
||||
FakeMediaStreamTrack,
|
||||
FakeRTCPeerConnection,
|
||||
FakeStreamSourceChannel,
|
||||
} from '../test-utils';
|
||||
type FakeMediaStreamTrack,
|
||||
} from '../../../../../go2rtc/test-utils';
|
||||
import { flushPromises } from '../../../../../test-utils';
|
||||
import { FakeStreamSourceChannel } from '../test-utils';
|
||||
|
||||
// @vitest-environment jsdom
|
||||
describe('WebRTCStreamSource', () => {
|
||||
const setup = (options?: { microphoneStream?: FakeMediaStream | null }) => {
|
||||
const setup = () => {
|
||||
const video = document.createElement('video');
|
||||
const channel = new FakeStreamSourceChannel();
|
||||
const loadedCallback = vi.fn();
|
||||
@@ -29,13 +29,10 @@ describe('WebRTCStreamSource', () => {
|
||||
|
||||
const pc = new FakeRTCPeerConnection();
|
||||
const createPeerConnection = vi.fn(() => pc.asPeerConnection());
|
||||
const microphoneErrorCallback = vi.fn();
|
||||
const source = new WebRTCStreamSource(context, {
|
||||
createPeerConnection,
|
||||
createMediaStream: (tracks) =>
|
||||
new FakeMediaStream(tracks as unknown as FakeMediaStreamTrack[]).asMediaStream(),
|
||||
microphoneStream: options?.microphoneStream?.asMediaStream() ?? null,
|
||||
microphoneErrorCallback,
|
||||
});
|
||||
|
||||
return {
|
||||
@@ -44,7 +41,6 @@ describe('WebRTCStreamSource', () => {
|
||||
createPeerConnection,
|
||||
failedCallback,
|
||||
loadedCallback,
|
||||
microphoneErrorCallback,
|
||||
pc,
|
||||
source,
|
||||
video,
|
||||
@@ -60,27 +56,14 @@ describe('WebRTCStreamSource', () => {
|
||||
});
|
||||
|
||||
describe('transceivers', () => {
|
||||
it('should pre-arm a sendonly audio transceiver and recvonly video and audio', () => {
|
||||
it('should offer inbound video and audio only', () => {
|
||||
const { source, pc } = setup();
|
||||
source.start();
|
||||
|
||||
expect(pc.transceivers).toHaveLength(3);
|
||||
expect(pc.transceivers[0].direction).toBe('sendonly');
|
||||
expect(pc.transceivers[1].direction).toBe('recvonly');
|
||||
expect(pc.transceivers[2].direction).toBe('recvonly');
|
||||
|
||||
// Kind-only pre-arm: no track, so no getUserMedia and no permission prompt.
|
||||
expect(pc.transceivers[0].sender.track).toBeNull();
|
||||
});
|
||||
|
||||
it('should pre-arm with the current microphone track', () => {
|
||||
const micTrack = new FakeMediaStreamTrack('audio');
|
||||
const { source, pc } = setup({
|
||||
microphoneStream: new FakeMediaStream([micTrack]),
|
||||
});
|
||||
source.start();
|
||||
|
||||
expect(pc.transceivers[0].sender.track).toBe(micTrack);
|
||||
expect(pc.transceivers.map((transceiver) => transceiver.direction)).toEqual([
|
||||
'recvonly',
|
||||
'recvonly',
|
||||
]);
|
||||
});
|
||||
});
|
||||
|
||||
@@ -431,6 +414,17 @@ describe('WebRTCStreamSource', () => {
|
||||
expect(source.getPeerConnection()).toBe(pc.asPeerConnection());
|
||||
});
|
||||
|
||||
it('should report its media capabilities', () => {
|
||||
const { source, pc } = setup();
|
||||
source.start();
|
||||
pc.fireConnectionStateChange('connected');
|
||||
|
||||
expect(source.getCapabilities()).toEqual({
|
||||
supportsPause: true,
|
||||
hasAudio: expect.any(Boolean),
|
||||
});
|
||||
});
|
||||
|
||||
it('should report webrtc technology', () => {
|
||||
const { source } = setup();
|
||||
|
||||
@@ -462,139 +456,5 @@ describe('WebRTCStreamSource', () => {
|
||||
hasAACAudio: false,
|
||||
});
|
||||
});
|
||||
|
||||
it('should report 2-way audio capability once a mic track is armed', () => {
|
||||
const micTrack = new FakeMediaStreamTrack('audio');
|
||||
const { source, pc } = setup({
|
||||
microphoneStream: new FakeMediaStream([micTrack]),
|
||||
});
|
||||
source.start();
|
||||
pc.fireConnectionStateChange('connected');
|
||||
|
||||
expect(source.getCapabilities().has2WayAudio).toBe(true);
|
||||
expect(source.getCapabilities().supportsPause).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('setMicrophoneStream', () => {
|
||||
it('should do nothing for an unchanged stream', async () => {
|
||||
const stream = new FakeMediaStream([new FakeMediaStreamTrack('audio')]);
|
||||
const { source, pc } = setup({ microphoneStream: stream });
|
||||
source.start();
|
||||
await source.setMicrophoneStream(stream.asMediaStream());
|
||||
|
||||
expect(pc.getMicrophoneTransceiver().sender.replaceTrack).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should replace the outbound track without renegotiating', async () => {
|
||||
const { source, pc } = setup();
|
||||
source.start();
|
||||
const newTrack = new FakeMediaStreamTrack('audio');
|
||||
await source.setMicrophoneStream(new FakeMediaStream([newTrack]).asMediaStream());
|
||||
|
||||
expect(pc.getMicrophoneTransceiver().sender.replaceTrack).toHaveBeenCalledWith(
|
||||
newTrack,
|
||||
);
|
||||
});
|
||||
|
||||
it('should clear the outbound track for a null stream', async () => {
|
||||
const stream = new FakeMediaStream([new FakeMediaStreamTrack('audio')]);
|
||||
const { source, pc } = setup({ microphoneStream: stream });
|
||||
source.start();
|
||||
await source.setMicrophoneStream(null);
|
||||
|
||||
expect(pc.getMicrophoneTransceiver().sender.replaceTrack).toHaveBeenCalledWith(
|
||||
null,
|
||||
);
|
||||
});
|
||||
|
||||
it('should do nothing before there is a peer connection', async () => {
|
||||
const { source, microphoneErrorCallback } = setup();
|
||||
await source.setMicrophoneStream(
|
||||
new FakeMediaStream([new FakeMediaStreamTrack('audio')]).asMediaStream(),
|
||||
);
|
||||
|
||||
expect(microphoneErrorCallback).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it.each([
|
||||
[
|
||||
'what the browser said when the rejection has a message',
|
||||
new DOMException('The peer connection is closed', 'InvalidStateError'),
|
||||
'The peer connection is closed',
|
||||
],
|
||||
[
|
||||
'the rejection type when there is no message to quote',
|
||||
new DOMException('', 'InvalidStateError'),
|
||||
'InvalidStateError',
|
||||
],
|
||||
['nothing when the rejection is not an object', 'nope', undefined],
|
||||
[
|
||||
'nothing when the rejection describes itself with neither',
|
||||
{ message: 5, name: 7 },
|
||||
undefined,
|
||||
],
|
||||
] as const)(
|
||||
'should report %s when a current replaceTrack rejects',
|
||||
async (_summary, rejection, expected) => {
|
||||
const { source, pc, microphoneErrorCallback } = setup();
|
||||
source.start();
|
||||
pc.getMicrophoneTransceiver().sender.replaceTrack.mockRejectedValue(rejection);
|
||||
await source.setMicrophoneStream(
|
||||
new FakeMediaStream([new FakeMediaStreamTrack('audio')]).asMediaStream(),
|
||||
);
|
||||
|
||||
expect(microphoneErrorCallback).toHaveBeenCalledWith(expected);
|
||||
},
|
||||
);
|
||||
|
||||
it('should not fail the stream source when the microphone cannot attach', async () => {
|
||||
const { source, pc, failedCallback } = setup();
|
||||
source.start();
|
||||
pc.getMicrophoneTransceiver().sender.replaceTrack.mockRejectedValue(
|
||||
new DOMException('replace failed', 'InvalidStateError'),
|
||||
);
|
||||
await source.setMicrophoneStream(
|
||||
new FakeMediaStream([new FakeMediaStreamTrack('audio')]).asMediaStream(),
|
||||
);
|
||||
|
||||
// The inbound video is unaffected by an outbound audio failure, so the
|
||||
// source must keep running rather than failing over to another one.
|
||||
expect(failedCallback).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should not report a rejection when detaching the microphone', async () => {
|
||||
const stream = new FakeMediaStream([new FakeMediaStreamTrack('audio')]);
|
||||
const { source, pc, microphoneErrorCallback } = setup({
|
||||
microphoneStream: stream,
|
||||
});
|
||||
source.start();
|
||||
pc.getMicrophoneTransceiver().sender.replaceTrack.mockRejectedValue(
|
||||
new DOMException('The peer connection is closed', 'InvalidStateError'),
|
||||
);
|
||||
await source.setMicrophoneStream(null);
|
||||
|
||||
// Ignore the error, the user is not trying to be heard anyway.
|
||||
expect(microphoneErrorCallback).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should ignore a stale replaceTrack rejection after stop', async () => {
|
||||
const { source, pc, microphoneErrorCallback } = setup();
|
||||
source.start();
|
||||
let rejectReplace: (reason: Error) => void = () => {};
|
||||
pc.getMicrophoneTransceiver().sender.replaceTrack.mockReturnValue(
|
||||
new Promise((_resolve, reject) => {
|
||||
rejectReplace = reject;
|
||||
}),
|
||||
);
|
||||
const promise = source.setMicrophoneStream(
|
||||
new FakeMediaStream([new FakeMediaStreamTrack('audio')]).asMediaStream(),
|
||||
);
|
||||
source.stop();
|
||||
rejectReplace(new Error('replace failed'));
|
||||
await promise;
|
||||
|
||||
expect(microphoneErrorCallback).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
@@ -1,15 +1,15 @@
|
||||
import { vi, type Mock } from 'vitest';
|
||||
import { vi } from 'vitest';
|
||||
|
||||
import type {
|
||||
MediaSourceFactory,
|
||||
MediaSourceInterface,
|
||||
} from '../../../../../src/components-lib/live/providers/go2rtc-experimental/adapters/media-source';
|
||||
import type { StreamSourceChannel } from '../../../../../src/components-lib/live/providers/go2rtc-experimental/types';
|
||||
import type {
|
||||
BinaryCallback,
|
||||
Go2RTCMessage,
|
||||
MessageCallback,
|
||||
StreamSourceChannel,
|
||||
} from '../../../../../src/components-lib/live/providers/go2rtc-experimental/types';
|
||||
} from '../../../../../src/go2rtc/messages';
|
||||
import type { UnsubscribeCallback } from '../../../../../src/types';
|
||||
|
||||
// ===========================================================================
|
||||
@@ -28,32 +28,6 @@ export const SAFARI_17_USER_AGENT =
|
||||
// Fakes for browser APIs jsdom does not provide.
|
||||
// ===========================================================================
|
||||
|
||||
export class FakeWebSocket extends EventTarget {
|
||||
public binaryType = '';
|
||||
public sent: string[] = [];
|
||||
|
||||
public close = vi.fn();
|
||||
public send = vi.fn((data: string): void => {
|
||||
this.sent.push(data);
|
||||
});
|
||||
|
||||
public asWebSocket(): WebSocket {
|
||||
return this as unknown as WebSocket;
|
||||
}
|
||||
|
||||
public fireOpen(): void {
|
||||
this.dispatchEvent(new Event('open'));
|
||||
}
|
||||
|
||||
public fireClose(): void {
|
||||
this.dispatchEvent(new Event('close'));
|
||||
}
|
||||
|
||||
public fireMessage(data: unknown): void {
|
||||
this.dispatchEvent(new MessageEvent('message', { data }));
|
||||
}
|
||||
}
|
||||
|
||||
export const createTimeRanges = (ranges: [number, number][]): TimeRanges => ({
|
||||
length: ranges.length,
|
||||
start: (index: number) => ranges[index][0],
|
||||
@@ -77,129 +51,6 @@ class FakeSourceBuffer extends EventTarget {
|
||||
}
|
||||
}
|
||||
|
||||
export class FakeMediaStreamTrack extends EventTarget {
|
||||
public muted = false;
|
||||
public kind: string;
|
||||
|
||||
constructor(kind: string) {
|
||||
super();
|
||||
this.kind = kind;
|
||||
}
|
||||
|
||||
public asTrack(): MediaStreamTrack {
|
||||
return this as unknown as MediaStreamTrack;
|
||||
}
|
||||
|
||||
public setMuted(muted: boolean): void {
|
||||
this.muted = muted;
|
||||
this.dispatchEvent(new Event(muted ? 'mute' : 'unmute'));
|
||||
}
|
||||
}
|
||||
|
||||
export class FakeMediaStream {
|
||||
private _tracks: FakeMediaStreamTrack[];
|
||||
|
||||
constructor(tracks: FakeMediaStreamTrack[] = []) {
|
||||
this._tracks = tracks;
|
||||
}
|
||||
|
||||
public getTracks(): FakeMediaStreamTrack[] {
|
||||
return this._tracks;
|
||||
}
|
||||
|
||||
public getVideoTracks(): FakeMediaStreamTrack[] {
|
||||
return this._tracks.filter((track) => track.kind === 'video');
|
||||
}
|
||||
|
||||
public getAudioTracks(): FakeMediaStreamTrack[] {
|
||||
return this._tracks.filter((track) => track.kind === 'audio');
|
||||
}
|
||||
|
||||
public asMediaStream(): MediaStream {
|
||||
return this as unknown as MediaStream;
|
||||
}
|
||||
}
|
||||
|
||||
class FakeRTCTransceiver {
|
||||
public direction: string;
|
||||
public currentDirection: string;
|
||||
public sender: {
|
||||
track: FakeMediaStreamTrack | null;
|
||||
replaceTrack: Mock<(track: MediaStreamTrack | null) => Promise<void>>;
|
||||
};
|
||||
public receiver: { track: FakeMediaStreamTrack };
|
||||
|
||||
constructor(direction: string, kind: string, track: FakeMediaStreamTrack | null) {
|
||||
this.direction = direction;
|
||||
this.currentDirection = direction;
|
||||
this.sender = {
|
||||
track,
|
||||
replaceTrack: vi.fn<(track: MediaStreamTrack | null) => Promise<void>>(() =>
|
||||
Promise.resolve(),
|
||||
),
|
||||
};
|
||||
this.receiver = { track: new FakeMediaStreamTrack(kind) };
|
||||
}
|
||||
}
|
||||
|
||||
export class FakeRTCPeerConnection extends EventTarget {
|
||||
public connectionState: RTCPeerConnectionState = 'new';
|
||||
public remoteDescription: { sdp: string } | null = null;
|
||||
public transceivers: FakeRTCTransceiver[] = [];
|
||||
|
||||
public createOffer = vi.fn(
|
||||
(): Promise<{ type: string; sdp?: string }> =>
|
||||
Promise.resolve({ type: 'offer', sdp: 'v=0\r\noffer' }),
|
||||
);
|
||||
public setLocalDescription = vi.fn(() => Promise.resolve());
|
||||
public setRemoteDescription = vi.fn((description: { sdp: string }) => {
|
||||
this.remoteDescription = description;
|
||||
return Promise.resolve();
|
||||
});
|
||||
public addIceCandidate = vi.fn(() => Promise.resolve());
|
||||
public close = vi.fn();
|
||||
|
||||
public addTransceiver(
|
||||
trackOrKind: FakeMediaStreamTrack | string,
|
||||
init: { direction: string },
|
||||
): FakeRTCTransceiver {
|
||||
const kind = typeof trackOrKind === 'string' ? trackOrKind : trackOrKind.kind;
|
||||
const track = typeof trackOrKind === 'string' ? null : trackOrKind;
|
||||
const transceiver = new FakeRTCTransceiver(init.direction, kind, track);
|
||||
this.transceivers.push(transceiver);
|
||||
return transceiver;
|
||||
}
|
||||
|
||||
public getTransceivers(): FakeRTCTransceiver[] {
|
||||
return this.transceivers;
|
||||
}
|
||||
|
||||
public getReceivers(): { track: FakeMediaStreamTrack }[] {
|
||||
return this.transceivers.map((transceiver) => transceiver.receiver);
|
||||
}
|
||||
|
||||
public asPeerConnection(): RTCPeerConnection {
|
||||
return this as unknown as RTCPeerConnection;
|
||||
}
|
||||
|
||||
public getMicrophoneTransceiver(): FakeRTCTransceiver {
|
||||
return this.transceivers[0];
|
||||
}
|
||||
|
||||
public fireConnectionStateChange(state: RTCPeerConnectionState): void {
|
||||
this.connectionState = state;
|
||||
this.dispatchEvent(new Event('connectionstatechange'));
|
||||
}
|
||||
|
||||
public fireIceCandidate(candidate: string | null): void {
|
||||
const event = new Event('icecandidate');
|
||||
Object.assign(event, {
|
||||
candidate: candidate === null ? null : { candidate },
|
||||
});
|
||||
this.dispatchEvent(event);
|
||||
}
|
||||
}
|
||||
|
||||
// ===========================================================================
|
||||
// Fakes for custom interfaces.
|
||||
// ===========================================================================
|
||||
|
||||
@@ -1,29 +0,0 @@
|
||||
import { describe, expect, it } from 'vitest';
|
||||
|
||||
import { isServerErrorForMode } from '../../../../../../src/components-lib/live/providers/go2rtc-experimental/utils/messages';
|
||||
|
||||
describe('isServerErrorForMode', () => {
|
||||
it('should match an error for the mode', () => {
|
||||
expect(isServerErrorForMode({ type: 'error', value: 'mse: not found' }, 'mse')).toBe(
|
||||
true,
|
||||
);
|
||||
});
|
||||
|
||||
it('should not match an error for another mode', () => {
|
||||
expect(isServerErrorForMode({ type: 'error', value: 'webrtc: failed' }, 'mse')).toBe(
|
||||
false,
|
||||
);
|
||||
});
|
||||
|
||||
it('should not match a non-error message', () => {
|
||||
expect(isServerErrorForMode({ type: 'mse', value: 'codecs' }, 'mse')).toBe(false);
|
||||
});
|
||||
|
||||
it('should not match an error with a non-string value', () => {
|
||||
expect(isServerErrorForMode({ type: 'error', value: 42 }, 'mse')).toBe(false);
|
||||
});
|
||||
|
||||
it('should not match an error with no value', () => {
|
||||
expect(isServerErrorForMode({ type: 'error' }, 'mse')).toBe(false);
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user