@fishjam-cloud/webrtc-client 0.14.0

package/dist/webrtc-client/src/tracks/Remote.js

@@ -0,0 +1,165 @@
+import { MediaEvent_SetTargetTrackVariant } from '@fishjam-cloud/protobufs/peer';
+import { MediaEvent_VadNotification_Status } from '@fishjam-cloud/protobufs/server';
+import { TrackContextImpl } from '../internal';
+import { RemoteTrack } from './RemoteTrack';
+export class Remote {
+    remoteTracks = {};
+    remoteEndpoints = {};
+    emit;
+    sendMediaEvent;
+    constructor(emit, sendMediaEvent) {
+        this.emit = emit;
+        this.sendMediaEvent = sendMediaEvent;
+    }
+    getTrackByMid = (mid) => {
+        const remoteTrack = Object.values(this.remoteTracks).find((remote) => remote.mLineId === mid);
+        if (!remoteTrack)
+            throw new Error(`Remote track with ${mid} not found`);
+        return remoteTrack;
+    };
+    addTracks = (endpointId, tracks) => {
+        const endpoint = this.remoteEndpoints[endpointId];
+        if (!endpoint)
+            throw new Error(`Endpoint ${endpointId} not found`);
+        Object.entries(tracks)
+            .map(([trackId, { metadataJson, simulcastConfig }]) => {
+            const parsedMetadata = metadataJson ? JSON.parse(metadataJson) : undefined;
+            const trackContext = new TrackContextImpl(endpoint, trackId, parsedMetadata, simulcastConfig);
+            return new RemoteTrack(trackId, trackContext);
+        })
+            .forEach((remoteTrack) => {
+            this.remoteTracks[remoteTrack.id] = remoteTrack;
+            endpoint.tracks.set(remoteTrack.id, remoteTrack.trackContext);
+            this.emit('trackAdded', remoteTrack.trackContext);
+        });
+    };
+    removeTracks = (trackIds) => {
+        trackIds.forEach((trackId) => {
+            this.removeRemoteTrack(trackId);
+        });
+    };
+    removeRemoteTrack = (trackId) => {
+        const remoteTrack = this.remoteTracks[trackId];
+        if (!remoteTrack)
+            throw new Error(`Track ${trackId} not found`);
+        const remoteEndpoint = this.remoteEndpoints[remoteTrack.trackContext.endpoint.id];
+        if (!remoteEndpoint)
+            throw new Error(`Endpoint ${remoteTrack.trackContext.endpoint.id} not found`);
+        remoteEndpoint.tracks.delete(trackId);
+        delete this.remoteTracks[trackId];
+        this.emit('trackRemoved', remoteTrack.trackContext);
+    };
+    addRemoteEndpoint = (endpointId, metadataJson, tracks, sendNotification = true) => {
+        const endpoint = {
+            id: endpointId,
+            type: 'exwebrtc',
+            metadata: metadataJson ? JSON.parse(metadataJson) : undefined,
+            tracks: new Map(),
+        };
+        this.addEndpoint(endpoint);
+        this.addTracks(endpoint.id, tracks ?? {});
+        if (sendNotification) {
+            this.emit('endpointAdded', endpoint);
+        }
+    };
+    addEndpoint = (endpoint) => {
+        this.remoteEndpoints[endpoint.id] = endpoint;
+    };
+    updateRemoteEndpoint = (endpointId, metadataJson) => {
+        const endpoint = this.remoteEndpoints[endpointId];
+        if (!endpoint)
+            throw new Error(`Endpoint ${endpointId} not found`);
+        endpoint.metadata = metadataJson ? JSON.parse(metadataJson) : undefined;
+        this.emit('endpointUpdated', endpoint);
+    };
+    removeRemoteEndpoint = (endpointId) => {
+        const endpoint = this.remoteEndpoints[endpointId];
+        if (!endpoint)
+            throw new Error(`Endpoint ${endpointId} not found`);
+        const trackIds = [...endpoint.tracks.values()].map(({ trackId }) => trackId);
+        this.removeTracks(trackIds);
+        delete this.remoteEndpoints[endpointId];
+        this.emit('endpointRemoved', endpoint);
+    };
+    updateRemoteTrack = (endpointId, trackId, metadataJson) => {
+        if (!this.remoteEndpoints[endpointId])
+            throw new Error(`Endpoint ${endpointId} not found`);
+        const remoteTrack = this.remoteTracks[trackId];
+        if (!remoteTrack)
+            throw new Error(`Track ${trackId} not found`);
+        remoteTrack.trackContext.metadata = metadataJson ? JSON.parse(metadataJson) : undefined;
+        this.emit('trackUpdated', remoteTrack.trackContext);
+    };
+    disableRemoteTrackEncoding = (trackId, encoding) => {
+        const remoteTrack = this.remoteTracks[trackId];
+        if (!remoteTrack)
+            throw new Error(`Track ${trackId} not found`);
+        remoteTrack.disableTrackEncoding(encoding);
+        this.emit('trackEncodingDisabled', remoteTrack.trackContext, encoding);
+    };
+    enableRemoteTrackEncoding = (trackId, encoding) => {
+        const remoteTrack = this.remoteTracks[trackId];
+        if (!remoteTrack)
+            throw new Error(`Track ${trackId} not found`);
+        remoteTrack.enableTrackEncoding(encoding);
+        this.emit('trackEncodingEnabled', remoteTrack.trackContext, encoding);
+    };
+    setRemoteTrackEncoding = (trackId, encoding, reason) => {
+        const remoteTrack = this.remoteTracks[trackId];
+        if (!remoteTrack)
+            throw new Error(`Track ${trackId} not found`);
+        remoteTrack.trackContext.encoding = encoding;
+        remoteTrack.trackContext.encodingReason = reason;
+        remoteTrack.trackContext.emit('encodingChanged', remoteTrack.trackContext);
+    };
+    setRemoteTrackVadStatus = (trackId, vadStatus) => {
+        const remoteTrack = this.remoteTracks[trackId];
+        if (!remoteTrack)
+            throw new Error(`Track ${trackId} not found`);
+        let nextStatus = null;
+        if (vadStatus === MediaEvent_VadNotification_Status.STATUS_SILENCE) {
+            nextStatus = 'silence';
+        }
+        else if (vadStatus === MediaEvent_VadNotification_Status.STATUS_SPEECH) {
+            nextStatus = 'speech';
+        }
+        if (nextStatus) {
+            remoteTrack.trackContext.vadStatus = nextStatus;
+            remoteTrack.trackContext.emit('voiceActivityChanged', remoteTrack.trackContext);
+        }
+        else {
+            console.warn('Received unknown vad status: ', vadStatus);
+        }
+    };
+    getRemoteTrackContexts = () => {
+        return Object.values(this.remoteTracks).reduce((acc, current) => ({
+            ...acc,
+            [current.trackContext.trackId]: current.trackContext,
+        }), {});
+    };
+    getRemoteEndpoints = () => {
+        return Object.values(this.remoteEndpoints).reduce((acc, current) => ({ ...acc, [current.id]: current }), {});
+    };
+    setTargetRemoteTrackEncoding = (trackId, variant) => {
+        const remoteTrack = this.remoteTracks[trackId];
+        if (!remoteTrack)
+            throw new Error(`Track ${trackId} not found`);
+        try {
+            remoteTrack.setTargetTrackEncoding(variant);
+            const setTargetTrackVariant = MediaEvent_SetTargetTrackVariant.create({ variant, trackId });
+            this.sendMediaEvent({ setTargetTrackVariant });
+            this.emit('targetTrackEncodingRequested', {
+                trackId,
+                variant,
+            });
+        }
+        catch (e) {
+            console.warn(e);
+        }
+    };
+    updateMLineIds = (midToTrackIds) => {
+        Object.entries(midToTrackIds).forEach(([mid, trackId]) => {
+            this.remoteTracks[trackId]?.setMLineId(mid);
+        });
+    };
+}

package/dist/webrtc-client/src/tracks/RemoteTrack.d.ts

@@ -0,0 +1,40 @@
+import { Variant } from '@fishjam-cloud/protobufs/shared';
+import type { TrackContextImpl } from '../internal';
+import type { LocalTrackId, MLineId } from '../types';
+import type { TrackCommon, TrackId } from './TrackCommon';
+/**
+ * This is a wrapper over `TrackContext` that adds additional properties such as:
+ * - `MLineId`: required to generate sdpOffer
+ *
+ * # Lifecycle, state transitions
+ *
+ * I identified the following states
+ * - on `trackAdded`
+ *   - trackContext.stream === null
+ *   - trackContext.track === null
+ *   - trackContext.trackKind === null
+ *   - mLineId === null
+ * - on `onSdpAnswer`
+ *   - trackContext.stream === null
+ *   - trackContext.track === null
+ *   - trackContext.trackKind === null
+ *   - mLineId !== null
+ * - on `trackReady`
+ *   - trackContext.stream !== null
+ *   - trackContext.track !== null
+ *   - trackContext.trackKind !== null
+ *   - mLineId !== null
+ */
+export declare class RemoteTrack implements TrackCommon {
+    id: TrackId;
+    mLineId: MLineId | null;
+    readonly trackContext: TrackContextImpl;
+    readonly encodings: Record<Variant, boolean>;
+    private targetEncoding;
+    constructor(id: LocalTrackId, trackContext: TrackContextImpl);
+    setMLineId: (mLineId: MLineId) => void;
+    setReady: (stream: MediaStream, track: MediaStreamTrack) => void;
+    disableTrackEncoding: (encoding: Variant) => void;
+    enableTrackEncoding: (encoding: Variant) => void;
+    setTargetTrackEncoding: (variant: Variant) => void;
+}

package/dist/webrtc-client/src/tracks/RemoteTrack.js

@@ -0,0 +1,71 @@
+import { Variant } from '@fishjam-cloud/protobufs/shared';
+import { isTrackKind } from '../internal';
+/**
+ * This is a wrapper over `TrackContext` that adds additional properties such as:
+ * - `MLineId`: required to generate sdpOffer
+ *
+ * # Lifecycle, state transitions
+ *
+ * I identified the following states
+ * - on `trackAdded`
+ *   - trackContext.stream === null
+ *   - trackContext.track === null
+ *   - trackContext.trackKind === null
+ *   - mLineId === null
+ * - on `onSdpAnswer`
+ *   - trackContext.stream === null
+ *   - trackContext.track === null
+ *   - trackContext.trackKind === null
+ *   - mLineId !== null
+ * - on `trackReady`
+ *   - trackContext.stream !== null
+ *   - trackContext.track !== null
+ *   - trackContext.trackKind !== null
+ *   - mLineId !== null
+ */
+export class RemoteTrack {
+    id;
+    mLineId = null;
+    trackContext;
+    encodings = {
+        [Variant.UNRECOGNIZED]: false,
+        [Variant.VARIANT_UNSPECIFIED]: false,
+        [Variant.VARIANT_LOW]: false,
+        [Variant.VARIANT_MEDIUM]: false,
+        [Variant.VARIANT_HIGH]: false,
+    };
+    // todo this field is not exposed
+    targetEncoding = null;
+    constructor(id, trackContext) {
+        this.id = id;
+        this.trackContext = trackContext;
+    }
+    setMLineId = (mLineId) => {
+        this.mLineId = mLineId;
+    };
+    setReady = (stream, track) => {
+        if (!isTrackKind(track.kind))
+            throw new Error('Track has no kind');
+        this.trackContext.stream = stream;
+        this.trackContext.track = track;
+        this.trackContext.trackKind = track.kind;
+    };
+    disableTrackEncoding = (encoding) => {
+        this.encodings[encoding] = false;
+    };
+    enableTrackEncoding = (encoding) => {
+        this.encodings[encoding] = true;
+    };
+    setTargetTrackEncoding = (variant) => {
+        // todo implement validation
+        this.targetEncoding = variant;
+        const trackContext = this.trackContext;
+        if (!trackContext.simulcastConfig?.enabled) {
+            throw new Error('The track does not support changing its target variant');
+        }
+        const isValidTargetEncoding = !trackContext.simulcastConfig.enabledVariants.includes(variant);
+        if (isValidTargetEncoding) {
+            throw new Error(`The track does not support variant ${variant}`);
+        }
+    };
+}

package/dist/webrtc-client/src/tracks/TrackCommon.d.ts

@@ -0,0 +1,9 @@
+import type { Variant } from '@fishjam-cloud/protobufs/shared';
+import type { MLineId } from '../types';
+export type TrackId = string;
+export type EndpointId = string;
+export type TrackEncodings = Record<Variant, boolean>;
+export interface TrackCommon {
+    mLineId: MLineId | null;
+    encodings: TrackEncodings;
+}

package/dist/webrtc-client/src/tracks/TrackCommon.js

@@ -0,0 +1 @@
+export {};

package/dist/webrtc-client/src/tracks/bandwidth.d.ts

@@ -0,0 +1 @@
+export declare const splitBandwidth: (rtcRtpEncodingParameters: RTCRtpEncodingParameters[], maxBandwidth: number) => RTCRtpEncodingParameters[];

package/dist/webrtc-client/src/tracks/bandwidth.js

@@ -0,0 +1,27 @@
+export const splitBandwidth = (rtcRtpEncodingParameters, maxBandwidth) => {
+    const bandwidth = maxBandwidth * 1024;
+    if (bandwidth === 0) {
+        return rtcRtpEncodingParameters.map((encoding) => ({
+            ...encoding,
+            maxBitrate: undefined,
+        }));
+    }
+    if (rtcRtpEncodingParameters.length === 0) {
+        // This most likely is a race condition. Log an error and prevent catastrophic failure
+        console.error("Attempted to limit bandwidth of the track that doesn't have any encodings");
+        return rtcRtpEncodingParameters.map((encoding) => ({ ...encoding }));
+    }
+    if (!rtcRtpEncodingParameters[0])
+        throw new Error('RTCRtpEncodingParameters is in invalid state');
+    // We are solving the following equation:
+    // x + (k0/k1)^2 * x + (k0/k2)^2 * x + ... + (k0/kn)^2 * x = bandwidth
+    // where x is the bitrate for the first encoding, kn are scaleResolutionDownBy factors
+    // square is dictated by the fact that k0/kn is a scale factor, but we are interested in the total number of pixels in the image
+    const firstScaleDownBy = rtcRtpEncodingParameters[0].scaleResolutionDownBy || 1;
+    const bitrate_parts = rtcRtpEncodingParameters.reduce((acc, value) => acc + (firstScaleDownBy / (value.scaleResolutionDownBy || 1)) ** 2, 0);
+    const x = bandwidth / bitrate_parts;
+    return rtcRtpEncodingParameters.map((encoding) => ({
+        ...encoding,
+        maxBitrate: x * (firstScaleDownBy / (encoding.scaleResolutionDownBy || 1)) ** 2,
+    }));
+};

package/dist/webrtc-client/src/tracks/encodings.d.ts

@@ -0,0 +1,3 @@
+import { Variant } from '@fishjam-cloud/protobufs/shared';
+export declare const getEncodingParameters: (parameters: RTCRtpSendParameters, bandwidth: number) => RTCRtpEncodingParameters[];
+export declare const encodingToVariantMap: Record<string, Variant>;

package/dist/webrtc-client/src/tracks/encodings.js

@@ -0,0 +1,11 @@
+import { Variant } from '@fishjam-cloud/protobufs/shared';
+import { splitBandwidth } from './bandwidth';
+export const getEncodingParameters = (parameters, bandwidth) => {
+    const unlimitedEncodings = [{}];
+    return parameters.encodings.length === 0 ? unlimitedEncodings : splitBandwidth(parameters.encodings, bandwidth);
+};
+export const encodingToVariantMap = {
+    l: Variant.VARIANT_LOW,
+    m: Variant.VARIANT_MEDIUM,
+    h: Variant.VARIANT_HIGH,
+};

package/dist/webrtc-client/src/tracks/muteTrackUtils.d.ts

@@ -0,0 +1,3 @@
+import type { WebRTCEndpoint } from '../webRTCEndpoint';
+export declare function emitMutableEvents(action: 'mute' | 'unmute', webrtc: WebRTCEndpoint, trackId: string): void;
+export declare function getActionType(currentTrack: MediaStreamTrack | null, newTrack: MediaStreamTrack | null): 'mute' | 'unmute' | 'replace';

package/dist/webrtc-client/src/tracks/muteTrackUtils.js

@@ -0,0 +1,18 @@
+export function emitMutableEvents(action, webrtc, trackId) {
+    const localEventType = action === 'mute' ? 'localTrackMuted' : 'localTrackUnmuted';
+    // TODO add the mute/unmute event back if they're needed
+    // const mediaEvent = generateMediaEvent(mediaEventType, { trackId: trackId });
+    // webrtc.sendMediaEvent(mediaEvent);
+    webrtc.emit(localEventType, { trackId });
+}
+export function getActionType(currentTrack, newTrack) {
+    if (currentTrack && !newTrack) {
+        return 'mute';
+    }
+    else if (!currentTrack && newTrack) {
+        return 'unmute';
+    }
+    else {
+        return 'replace';
+    }
+}

package/dist/webrtc-client/src/tracks/transceivers.d.ts

@@ -0,0 +1,2 @@
+import type { TrackContextImpl } from '../internal';
+export declare const createTransceiverConfig: (trackContext: TrackContextImpl) => RTCRtpTransceiverInit;

package/dist/webrtc-client/src/tracks/transceivers.js

@@ -0,0 +1,93 @@
+import { Variant } from '@fishjam-cloud/protobufs/shared';
+import { splitBandwidth } from './bandwidth';
+import { encodingToVariantMap } from './encodings';
+export const createTransceiverConfig = (trackContext) => {
+    if (!trackContext.track)
+        throw new Error(`Cannot create transceiver config for `);
+    if (trackContext.track.kind === 'audio') {
+        return createAudioTransceiverConfig(trackContext.stream);
+    }
+    return createVideoTransceiverConfig(trackContext, trackContext.maxBandwidth);
+};
+const createAudioTransceiverConfig = (stream) => {
+    return {
+        direction: 'sendonly',
+        streams: stream ? [stream] : [],
+    };
+};
+const createVideoTransceiverConfig = (trackContext, maxBandwidth) => {
+    if (!trackContext.simulcastConfig)
+        throw new Error(`Simulcast config for track ${trackContext.trackId} not found.`);
+    if (trackContext.simulcastConfig.enabled) {
+        let simulcastConfig;
+        if (maxBandwidth === 0) {
+            simulcastConfig = new Map([
+                [Variant.VARIANT_LOW, 0],
+                [Variant.VARIANT_MEDIUM, 0],
+                [Variant.VARIANT_HIGH, 0],
+            ]);
+        }
+        else if (typeof maxBandwidth === 'number') {
+            throw new Error('Invalid bandwidth limit for simulcast track.');
+        }
+        else {
+            simulcastConfig = maxBandwidth;
+        }
+        return createSimulcastTransceiverConfig(trackContext, simulcastConfig);
+    }
+    if (typeof maxBandwidth === 'number') {
+        return createNonSimulcastTransceiverConfig(trackContext, maxBandwidth);
+    }
+    throw new Error('LocalTrack is in invalid state!');
+};
+const createNonSimulcastTransceiverConfig = (trackContext, maxBandwidth) => {
+    return {
+        direction: 'sendonly',
+        sendEncodings: splitBandwidth([{ active: true }], maxBandwidth),
+        streams: trackContext.stream ? [trackContext.stream] : [],
+    };
+};
+const createSimulcastTransceiverConfig = (trackContext, maxBandwidth) => {
+    if (!trackContext.simulcastConfig)
+        throw new Error(`Simulcast config for track ${trackContext.trackId} not found.`);
+    const activeEncodings = trackContext.simulcastConfig.enabledVariants;
+    const encodings = [
+        {
+            rid: 'l',
+            active: activeEncodings.includes(Variant.VARIANT_LOW),
+            // maxBitrate: 4_000_000,
+            scaleResolutionDownBy: 4.0,
+            //   scalabilityMode: "L1T" + TEMPORAL_LAYERS_COUNT,
+        },
+        {
+            rid: 'm',
+            active: activeEncodings.includes(Variant.VARIANT_MEDIUM),
+            scaleResolutionDownBy: 2.0,
+        },
+        {
+            rid: 'h',
+            active: activeEncodings.includes(Variant.VARIANT_HIGH),
+            // maxBitrate: 4_000_000,
+            // scalabilityMode: "L1T" + TEMPORAL_LAYERS_COUNT,
+        },
+    ];
+    return {
+        direction: 'sendonly',
+        // keep this array from low resolution to high resolution
+        // in other case lower resolution encoding can get
+        // higher max_bitrate
+        sendEncodings: calculateSimulcastEncodings(encodings, maxBandwidth),
+    };
+};
+const calculateSimulcastEncodings = (encodings, maxBandwidth) => {
+    return encodings
+        .filter((encoding) => encoding.rid)
+        .map((encoding) => {
+        const variant = (!!encoding.rid && encodingToVariantMap[encoding.rid]) || Variant.VARIANT_UNSPECIFIED;
+        const limit = maxBandwidth.get(variant) || 0;
+        return {
+            ...encoding,
+            maxBitrate: limit > 0 ? limit * 1024 : undefined,
+        };
+    });
+};