mirror of
https://github.com/vector-im/element-call.git
synced 2026-11-16 01:22:29 +00:00
- The first effect chosen in a session shows a spinner on its own tile, in place of the tick, until a frame carrying it is drawn. Later changes show nothing, having nothing to prepare. - Ended by the frame, not the promises, which resolve while the segmenter is still being built. The transformer reports the first frame that went through the segmenter; one passed through untouched doesn't count. - The pipeline publishes the wait with its state, and both footer view models take it as an input. - The lobby tests' provider mock gains the observable hook, built once: a fresh observable per render rebuilt the footer on every render. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
140 lines
4.1 KiB
TypeScript
140 lines
4.1 KiB
TypeScript
/*
|
|
Copyright 2026 Element Creations Ltd.
|
|
|
|
SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
|
|
Please see LICENSE in the repository root for full details.
|
|
*/
|
|
|
|
import {
|
|
combineLatest,
|
|
distinctUntilChanged,
|
|
map,
|
|
Observable,
|
|
scan,
|
|
} from "rxjs";
|
|
import {
|
|
type BackgroundProcessorWrapper,
|
|
type SwitchBackgroundProcessorOptions,
|
|
} from "@livekit/track-processors";
|
|
import { logger } from "matrix-js-sdk/lib/logger";
|
|
import { deepCompare } from "matrix-js-sdk/lib/utils";
|
|
import {
|
|
fromLivekitProcessor,
|
|
type VideoProcessor,
|
|
} from "@element-hq/matrixrtc-sdk";
|
|
|
|
import { type Behavior } from "./Behavior";
|
|
import { type ObservableScope } from "./ObservableScope";
|
|
import {
|
|
type BackgroundEffect,
|
|
imagePathFor,
|
|
parseEffect,
|
|
} from "../tracks/backgroundEffectCatalog";
|
|
|
|
const blurRadius = 15;
|
|
|
|
export interface BackgroundEffectsState {
|
|
supported: boolean | undefined;
|
|
processor: undefined | VideoProcessor;
|
|
/** From the first effect chosen until a frame carrying it is drawn. */
|
|
settling?: boolean;
|
|
}
|
|
|
|
export interface BackgroundEffectsOptions {
|
|
/** Whether this browser can run a pipeline at all. */
|
|
supported: boolean;
|
|
/** The effect chosen, as the setting stores it. */
|
|
effect$: Behavior<string>;
|
|
/** The background processor pipeline to be switched between effects. */
|
|
pipeline: BackgroundProcessorWrapper;
|
|
/** Tells, once, that a frame carrying an effect has been drawn. */
|
|
transformer: { onFirstFrame: (() => void) | undefined };
|
|
}
|
|
|
|
/** The background effect pipeline, as the camera tracks and the menus see it. */
|
|
export interface BackgroundEffects {
|
|
readonly state$: Behavior<BackgroundEffectsState>;
|
|
}
|
|
|
|
/** Switches the pipeline as the choice changes, for as long as the scope lasts. */
|
|
export function createBackgroundEffects(
|
|
scope: ObservableScope,
|
|
{ supported, effect$, pipeline, transformer }: BackgroundEffectsOptions,
|
|
): BackgroundEffects {
|
|
// Wrapped once, so the call and the preview see one processor throughout.
|
|
const processor = fromLivekitProcessor(pipeline);
|
|
const choice$ = effect$.pipe(map(parseEffect));
|
|
const wanted$ = choice$.pipe(
|
|
map((effect) => effect.kind !== "none"),
|
|
distinctUntilChanged(),
|
|
);
|
|
|
|
const drewAFrame$ = scope.behavior(
|
|
new Observable<boolean>((subscriber) => {
|
|
subscriber.next(false);
|
|
transformer.onFirstFrame = (): void => subscriber.next(true);
|
|
return (): void => {
|
|
transformer.onFirstFrame = undefined;
|
|
};
|
|
}),
|
|
);
|
|
|
|
const state$ = scope.behavior(
|
|
combineLatest([wanted$, drewAFrame$]).pipe(
|
|
scan<[boolean, boolean], BackgroundEffectsState>(
|
|
(previous, [wanted, drewAFrame]) => {
|
|
// Attached the first time an effect is wanted and never detached
|
|
// after, so someone who never turns one on pays for none of it.
|
|
const enable =
|
|
previous.processor !== undefined || (supported && wanted);
|
|
return {
|
|
supported,
|
|
processor: enable ? processor : undefined,
|
|
settling: enable && !drewAFrame,
|
|
};
|
|
},
|
|
{ supported, processor: undefined },
|
|
),
|
|
),
|
|
);
|
|
|
|
const switchOptions$ = scope.behavior<
|
|
SwitchBackgroundProcessorOptions | undefined
|
|
>(
|
|
combineLatest([state$, choice$]).pipe(
|
|
map(([{ processor }, effect]) =>
|
|
processor === undefined ? undefined : switchOptionsFor(effect),
|
|
),
|
|
distinctUntilChanged(deepCompare),
|
|
),
|
|
);
|
|
// In turn: a picture's switch ends once it loads, so an earlier one could land last.
|
|
scope.reconcile(switchOptions$, async (options) => {
|
|
if (options === undefined) return;
|
|
try {
|
|
await pipeline.switchTo(options);
|
|
} catch (e) {
|
|
logger.warn("Failed to switch background effect", e);
|
|
}
|
|
});
|
|
|
|
return { state$ };
|
|
}
|
|
|
|
function switchOptionsFor(
|
|
effect: BackgroundEffect,
|
|
): SwitchBackgroundProcessorOptions {
|
|
switch (effect.kind) {
|
|
case "blur":
|
|
return { mode: "background-blur", blurRadius };
|
|
case "shipped": {
|
|
const imagePath = imagePathFor(effect.id);
|
|
return imagePath
|
|
? { mode: "virtual-background", imagePath }
|
|
: { mode: "disabled" };
|
|
}
|
|
default:
|
|
return { mode: "disabled" };
|
|
}
|
|
}
|