flan/advanced-camera-card
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix: Hold the 2-way audio backchannel open for the shortest possible time (#2697)

Browse Source 
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
(`&microphone`),
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
2026-08-21 20:13:58 -07:00
committed by GitHub
parent 2d7c86c93c
commit 11cc543406
65 changed files with 2251 additions and 1045 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/camera-manager/camera.test.ts
+1 -2
View File
@@ -160,8 +160,7 @@ describe('Camera', () => {
expect.anything(),
2,
{
endpoint:
'http://go2rtc/api/streams?src=stream&video=all&audio=all&microphone',
endpoint: 'http://go2rtc/api/streams?src=stream&video=all&audio=all',
sign: false,
},
expect.objectContaining({
tests/camera-manager/utils/go2rtc-audio.test.ts
-129
View File
@@ -1,129 +0,0 @@
import { beforeEach, describe, expect, it, vi } from 'vitest';
import { mock } from 'vitest-mock-extended';
import { supports2WayAudio } from '../../../src/camera-manager/utils/go2rtc/audio';
import { homeAssistantSignAndFetch } from '../../../src/ha/fetch';
import type { HomeAssistant } from '../../../src/ha/types';
import { createProxiedEndpointIfNecessary } from '../../../src/ha/web-proxy';
import type { Endpoint } from '../../../src/types';
vi.mock('../../../src/ha/fetch');
vi.mock('../../../src/ha/web-proxy');
describe('supports2WayAudio', () => {
const hass = mock<HomeAssistant>();
const endpoint: Endpoint = { endpoint: 'http://go2rtc', sign: true };
beforeEach(() => {
vi.clearAllMocks();
});
it('should return false if no endpoint provided', async () => {
expect(await supports2WayAudio(hass, 2, null)).toBe(false);
});
it('should return false if fetch fails', async () => {
vi.mocked(createProxiedEndpointIfNecessary).mockResolvedValue(endpoint);
vi.mocked(homeAssistantSignAndFetch).mockRejectedValue(new Error('fetch error'));
const spy = vi.spyOn(console, 'warn');
const result = await supports2WayAudio(hass, 2, endpoint);
expect(result).toBe(false);
expect(spy).toHaveBeenCalledWith('fetch error');
spy.mockRestore();
});
it('should return false if stream info has no producers', async () => {
vi.mocked(createProxiedEndpointIfNecessary).mockResolvedValue(endpoint);
vi.mocked(homeAssistantSignAndFetch).mockResolvedValue({ producers: undefined });
expect(await supports2WayAudio(hass, 2, endpoint)).toBe(false);
});
it('should use default metadata fetch timeout', async () => {
vi.mocked(createProxiedEndpointIfNecessary).mockResolvedValue(endpoint);
vi.mocked(homeAssistantSignAndFetch).mockResolvedValue({ producers: [] });
await supports2WayAudio(hass, 2, endpoint);
expect(homeAssistantSignAndFetch).toHaveBeenCalledWith(
hass,
endpoint,
expect.anything(),
{ timeoutSeconds: 2 },
);
});
it('should use custom metadata fetch timeout when provided', async () => {
vi.mocked(createProxiedEndpointIfNecessary).mockResolvedValue(endpoint);
vi.mocked(homeAssistantSignAndFetch).mockResolvedValue({ producers: [] });
await supports2WayAudio(hass, 15, endpoint);
expect(homeAssistantSignAndFetch).toHaveBeenCalledWith(
hass,
endpoint,
expect.anything(),
{ timeoutSeconds: 15 },
);
});
it('should return false if no producer supports audio', async () => {
vi.mocked(createProxiedEndpointIfNecessary).mockResolvedValue(endpoint);
vi.mocked(homeAssistantSignAndFetch).mockResolvedValue({
producers: [
{
medias: ['video,sendonly,h264'],
},
],
});
expect(await supports2WayAudio(hass, 2, endpoint)).toBe(false);
});
it('should return true if producer supports audio and sendonly', async () => {
vi.mocked(createProxiedEndpointIfNecessary).mockResolvedValue(endpoint);
vi.mocked(homeAssistantSignAndFetch).mockResolvedValue({
producers: [
{
medias: ['audio,sendonly,opus'],
},
],
});
expect(await supports2WayAudio(hass, 2, endpoint)).toBe(true);
});
it('should return true if producer supports audio and sendrecv', async () => {
vi.mocked(createProxiedEndpointIfNecessary).mockResolvedValue(endpoint);
vi.mocked(homeAssistantSignAndFetch).mockResolvedValue({
producers: [
{
medias: ['audio,sendrecv,pcmu'],
},
],
});
expect(await supports2WayAudio(hass, 2, endpoint)).toBe(true);
});
it('should handle missing medias in producer', async () => {
vi.mocked(createProxiedEndpointIfNecessary).mockResolvedValue(endpoint);
vi.mocked(homeAssistantSignAndFetch).mockResolvedValue({
producers: [
{
medias: undefined,
},
],
});
expect(await supports2WayAudio(hass, 2, endpoint)).toBe(false);
});
it('should return false if proxied endpoint is null', async () => {
vi.mocked(createProxiedEndpointIfNecessary).mockResolvedValue(null);
expect(await supports2WayAudio(hass, 2, endpoint)).toBe(false);
});
});
tests/camera-manager/utils/go2rtc-endpoint.test.ts
-84
View File
@@ -1,84 +0,0 @@
import { describe, expect, it } from 'vitest';
import {
getGo2RTCMetadataEndpoint,
getGo2RTCStreamEndpoint,
} from '../../../src/camera-manager/utils/go2rtc/endpoint.js';
import { createCameraConfig } from '../../config/test-utils';
describe('getGo2RTCStreamEndpoint', () => {
it('with local configuration', () => {
expect(
getGo2RTCStreamEndpoint(
createCameraConfig({
go2rtc: {
stream: 'stream',
url: '/local/path',
},
}),
),
).toEqual({
endpoint: '/local/path/api/ws?src=stream',
sign: true,
});
});
it('with remote configuration', () => {
expect(
getGo2RTCStreamEndpoint(
createCameraConfig({
go2rtc: {
stream: 'stream',
url: 'https://my-custom-go2rtc',
},
}),
),
).toEqual({
endpoint: 'https://my-custom-go2rtc/api/ws?src=stream',
sign: false,
});
});
it('without configuration', () => {
expect(getGo2RTCStreamEndpoint(createCameraConfig())).toBeNull();
});
});
describe('getGo2RTCMetadataEndpoint', () => {
it('with local configuration', () => {
expect(
getGo2RTCMetadataEndpoint(
createCameraConfig({
go2rtc: {
stream: 'stream',
url: '/local/path',
},
}),
),
).toEqual({
endpoint: '/local/path/api/streams?src=stream&video=all&audio=all&microphone',
sign: true,
});
});
it('with remote configuration', () => {
expect(
getGo2RTCMetadataEndpoint(
createCameraConfig({
go2rtc: {
stream: 'stream',
url: 'https://my-custom-go2rtc',
},
}),
),
).toEqual({
endpoint:
'https://my-custom-go2rtc/api/streams?src=stream&video=all&audio=all&microphone',
sign: false,
});
});
it('without configuration', () => {
expect(getGo2RTCMetadataEndpoint(createCameraConfig())).toBeNull();
});
});