@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/esm/lib/peer/const.js

@@ -0,0 +1,50 @@
+import { SignatureAlgorithm } from './imports/dtls.js';
+import { ProtectionProfileAeadAes128Gcm, ProtectionProfileAes128CmHmacSha1_80 } from './imports/rtp.js';
+// data channel export constants
+export const DATA_CHANNEL_ACK = 2;
+export const DATA_CHANNEL_OPEN = 3;
+// 5.1.  DATA_CHANNEL_OPEN Message
+export const DATA_CHANNEL_RELIABLE = 0x00;
+export const DATA_CHANNEL_PARTIAL_RELIABLE_REXMIT = 0x01;
+export const DATA_CHANNEL_PARTIAL_RELIABLE_TIMED = 0x02;
+export const DATA_CHANNEL_RELIABLE_UNORDERED = 0x80;
+export const DATA_CHANNEL_PARTIAL_RELIABLE_REXMIT_UNORDERED = 0x81;
+export const DATA_CHANNEL_PARTIAL_RELIABLE_TIMED_UNORDERED = 0x82;
+export const WEBRTC_DCEP = 50;
+export const WEBRTC_STRING = 51;
+export const WEBRTC_BINARY = 53;
+export const WEBRTC_STRING_EMPTY = 56;
+export const WEBRTC_BINARY_EMPTY = 57;
+export const DISCARD_HOST = '0.0.0.0';
+export const DISCARD_PORT = 9;
+export const MEDIA_KINDS = ['audio', 'video'];
+export const DIRECTIONS = ['inactive', 'sendonly', 'recvonly', 'sendrecv'];
+export const DTLS_ROLE_SETUP = {
+    auto: 'actpass',
+    client: 'active',
+    server: 'passive'
+};
+export const DTLS_SETUP_ROLE = Object.keys(DTLS_ROLE_SETUP).reduce((acc, cur) => {
+    const key = DTLS_ROLE_SETUP[cur];
+    acc[key] = cur;
+    return acc;
+}, {});
+export const FMTP_INT_PARAMETERS = [
+    'apt',
+    'max-fr',
+    'max-fs',
+    'maxplaybackrate',
+    'minptime',
+    'packetization-mode',
+    'level-asymmetry-allowed',
+    'stereo',
+    'useinbandfec'
+];
+export const SSRC_INFO_ATTRS = ['cname', 'msid', 'mslabel', 'label'];
+export const SRTP_PROFILE = {
+    SRTP_AES128_CM_HMAC_SHA1_80: ProtectionProfileAes128CmHmacSha1_80,
+    SRTP_AEAD_AES_128_GCM: ProtectionProfileAeadAes128Gcm
+};
+export const SenderDirections = ['sendonly', 'sendrecv'];
+export const ReceiverDirection = ['sendrecv', 'recvonly'];
+export { SignatureAlgorithm };

package/dist/esm/lib/peer/dataChannel.js

@@ -0,0 +1,127 @@
+import { randomUUID } from 'node:crypto';
+import { Event, debug, runDetached } from './imports/common.js';
+import { EventTarget } from './helper.js';
+const log = debug('webrtc/peer/dataChannel');
+export function getDataChannelMessageSize(data) {
+    return Buffer.isBuffer(data) ? data.length : Buffer.byteLength(data);
+}
+export class RTCDataChannel extends EventTarget {
+    constructor(sctp, parameters, sendOpen = true) {
+        super();
+        this.sctp = sctp;
+        this.parameters = parameters;
+        this.sendOpen = sendOpen;
+        this.statsId = randomUUID().toString();
+        this.stateChange = new Event();
+        this.stateChanged = new Event();
+        this.onMessage = new Event();
+        // todo impl
+        this.error = new Event();
+        this.bufferedAmountLow = new Event();
+        /**the amount buffered changed (a message queued, or sent): read by a worker thread serving the channel */
+        this.bufferedAmountChanged = new Event();
+        this.isCreatedByRemote = false;
+        this.readyState = 'connecting';
+        this.bufferedAmount = 0;
+        this._bufferedAmountLowThreshold = 0;
+        // Statistics
+        this.messagesSent = 0;
+        this.bytesSent = 0;
+        this.messagesReceived = 0;
+        this.bytesReceived = 0;
+        this.id = this.parameters.id;
+        if (parameters.negotiated) {
+            if (this.id == undefined || this.id < 0 || this.id > 65534) {
+                throw new Error('ID must be in range 0-65534 if data channel is negotiated out-of-band');
+            }
+            this.sctp.dataChannelAddNegotiated(this);
+        }
+        else {
+            if (sendOpen) {
+                this.sendOpen = false;
+                this.sctp.dataChannelOpen(this);
+            }
+        }
+    }
+    get ordered() {
+        return this.parameters.ordered;
+    }
+    get maxRetransmits() {
+        return this.parameters.maxRetransmits ?? null;
+    }
+    get maxPacketLifeTime() {
+        return this.parameters.maxPacketLifeTime ?? null;
+    }
+    get label() {
+        return this.parameters.label;
+    }
+    get protocol() {
+        return this.parameters.protocol;
+    }
+    get negotiated() {
+        return this.parameters.negotiated;
+    }
+    get bufferedAmountLowThreshold() {
+        return this._bufferedAmountLowThreshold;
+    }
+    set bufferedAmountLowThreshold(value) {
+        if (value < 0 || value > 4294967295) {
+            throw new Error('bufferedAmountLowThreshold must be in range 0 - 4294967295');
+        }
+        this._bufferedAmountLowThreshold = value;
+    }
+    setId(id) {
+        this.id = id;
+    }
+    setReadyState(state) {
+        if (state !== this.readyState) {
+            this.readyState = state;
+            this.stateChange.execute(state);
+            this.stateChanged.execute(state);
+            switch (state) {
+                case 'open':
+                    if (this.onopen)
+                        runDetached(() => this.onopen(), (error) => log('onopen failed', error));
+                    this.emit('open');
+                    break;
+                case 'closed':
+                    if (this.onclose)
+                        runDetached(() => this.onclose(), (error) => log('onclose failed', error));
+                    this.emit('close');
+                    break;
+                case 'closing':
+                    if (this.onclosing)
+                        runDetached(() => this.onclosing(), (error) => log('onclosing failed', error));
+                    break;
+            }
+            log('change state', state);
+        }
+    }
+    addBufferedAmount(amount) {
+        const crossesThreshold = this.bufferedAmount > this.bufferedAmountLowThreshold &&
+            this.bufferedAmount + amount <= this.bufferedAmountLowThreshold;
+        this.bufferedAmount += amount;
+        this.bufferedAmountChanged.execute();
+        if (crossesThreshold) {
+            this.bufferedAmountLow.execute();
+            this.emit('bufferedamountlow');
+        }
+    }
+    send(data) {
+        const size = this.sctp.datachannelSend(this, data);
+        this.messagesSent++;
+        this.bytesSent += size;
+    }
+    close() {
+        this.sctp.dataChannelClose(this);
+    }
+}
+export class RTCDataChannelParameters {
+    constructor(props = {}) {
+        this.label = '';
+        this.ordered = true;
+        this.protocol = '';
+        this.negotiated = false;
+        Object.assign(this, props);
+    }
+}

package/dist/esm/lib/peer/errors.js

@@ -0,0 +1,17 @@
+export function createWebRtcDomException(name, message = name) {
+    return new DOMException(message, name);
+}
+export function createWebRtcTypeError(message) {
+    return new TypeError(message);
+}
+/**
+ * Media Capture and Streams `OverconstrainedError`.
+ * WPT `overconstrainederror.html` requires a DOMException subclass with `constraint`.
+ */
+export class OverconstrainedError extends DOMException {
+    constructor(constraint, message = '') {
+        super(message, 'OverconstrainedError');
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.constraint = constraint;
+    }
+}

package/dist/esm/lib/peer/helper.js

@@ -0,0 +1,77 @@
+import { EventEmitter } from 'node:events';
+import { debug } from './imports/common.js';
+const log = debug('webrtc/peer/helper');
+export function enumerate(arr) {
+    return arr.map((v, i) => [i, v]);
+}
+export function divide(from, split) {
+    const arr = from.split(split);
+    return [arr[0], arr.slice(1).join(split)];
+}
+export class PromiseQueue {
+    constructor() {
+        this.queue = [];
+        this.running = false;
+        this.push = (promise) => new Promise((r) => {
+            this.queue.push({ promise, done: r });
+            if (!this.running)
+                void this.run();
+        });
+    }
+    async run() {
+        const task = this.queue.shift();
+        if (task) {
+            this.running = true;
+            //A failed task is logged and the queue goes on: its caller is released as for a task done
+            try {
+                await task.promise();
+            }
+            catch (error) {
+                log('task failed', error);
+            }
+            task.done();
+            void this.run();
+        }
+        else {
+            this.running = false;
+        }
+    }
+}
+export class EventTarget extends EventEmitter {
+    constructor() {
+        super(...arguments);
+        this.addEventListener = (type, listener, options) => {
+            if (typeof options === 'object' && options?.once) {
+                this.once(type, listener);
+                return;
+            }
+            this.addListener(type, listener);
+        };
+        this.removeEventListener = (type, listener) => {
+            this.removeListener(type, listener);
+        };
+        this.dispatchEvent = (event) => this.emit(event.type, event);
+    }
+    emit(type, ...args) {
+        if (typeof type !== 'string') {
+            return super.emit(type, ...args);
+        }
+        if (args.length === 0) {
+            return super.emit(type, new Event(type));
+        }
+        const [event, ...rest] = args;
+        if (event && typeof event === 'object' && !('type' in event)) {
+            try {
+                Object.defineProperty(event, 'type', {
+                    configurable: true,
+                    enumerable: true,
+                    value: type
+                });
+            }
+            catch {
+                return super.emit(type, { type, ...event }, ...rest);
+            }
+        }
+        return super.emit(type, event, ...rest);
+    }
+}

package/dist/esm/lib/peer/imports/common.js

@@ -0,0 +1 @@
+export * from '../../common/index.js';

package/dist/esm/lib/peer/imports/dtls.js

@@ -0,0 +1 @@
+export * from '../../dtls/index.js';

package/dist/esm/lib/peer/imports/ice.js

@@ -0,0 +1 @@
+export * from '../../ice/index.js';

package/dist/esm/lib/peer/imports/rtp.js

@@ -0,0 +1 @@
+export * from '../../rtp/index.js';

package/dist/esm/lib/peer/index.js

@@ -0,0 +1,14 @@
+export * from './imports/common.js';
+export * from './imports/dtls.js';
+export * from './imports/ice.js';
+export * from './imports/rtp.js';
+export * from './dataChannel.js';
+export * from './media/index.js';
+export * from './peerConnection.js';
+export * from './sdp.js';
+export * from './transport/dtls.js';
+export * from './transport/ice.js';
+export * from './transport/sctp.js';
+export * from './types/domain.js';
+export * from './utils.js';
+export * from './sdpManager.js';

package/dist/esm/lib/peer/media/codec.js

@@ -0,0 +1,69 @@
+import { useNACK, usePLI, useREMB } from './extension/rtcpFeedback.js';
+import { RTCRtpCodecParameters } from './parameters.js';
+export const useH264 = (props = {}) => new RTCRtpCodecParameters({
+    mimeType: 'video/h264',
+    clockRate: 90000,
+    rtcpFeedback: [useNACK(), usePLI(), useREMB()],
+    parameters: 'profile-level-id=42e01f;packetization-mode=1;level-asymmetry-allowed=1',
+    ...props
+});
+export const useVP8 = (props = {}) => new RTCRtpCodecParameters({
+    mimeType: 'video/VP8',
+    clockRate: 90000,
+    rtcpFeedback: [useNACK(), usePLI(), useREMB()],
+    ...props
+});
+export const useVP9 = (props = {}) => new RTCRtpCodecParameters({
+    mimeType: 'video/VP9',
+    clockRate: 90000,
+    rtcpFeedback: [useNACK(), usePLI(), useREMB()],
+    ...props
+});
+export const useAV1X = (props = {}) => new RTCRtpCodecParameters({
+    mimeType: 'video/AV1X',
+    clockRate: 90000,
+    rtcpFeedback: [useNACK(), usePLI(), useREMB()],
+    ...props
+});
+export const useOPUS = (props = {}) => new RTCRtpCodecParameters({
+    mimeType: 'audio/OPUS',
+    clockRate: 48000,
+    channels: 2,
+    ...props
+});
+export const usePCMU = (props = {}) => new RTCRtpCodecParameters({
+    mimeType: 'audio/PCMU',
+    clockRate: 8000,
+    channels: 1,
+    payloadType: 0,
+    ...props
+});
+export function defaultCodecs() {
+    return {
+        audio: [useOPUS(), usePCMU()],
+        video: [useVP8()]
+    };
+}
+export function cloneCodecParameters(codec) {
+    return new RTCRtpCodecParameters({
+        mimeType: codec.mimeType,
+        clockRate: codec.clockRate,
+        ...(codec.channels != undefined ? { channels: codec.channels } : {}),
+        ...(codec.payloadType != undefined
+            ? { payloadType: codec.payloadType }
+            : {}),
+        rtcpFeedback: codec.rtcpFeedback.map((feedback) => ({ ...feedback })),
+        ...(codec.parameters != undefined ? { parameters: codec.parameters } : {}),
+        direction: codec.direction
+    });
+}
+export const supportedCodecs = [
+    useAV1X(),
+    useVP9(),
+    useVP8(),
+    useH264(),
+    useOPUS(),
+    usePCMU()
+].map((codec) => codec.mimeType);
+export const supportedVideoCodecs = supportedCodecs.filter((codec) => codec.toLowerCase().startsWith('video/'));
+export const supportedAudioCodecs = supportedCodecs.filter((codec) => codec.toLowerCase().startsWith('audio/'));

package/dist/esm/lib/peer/media/codecCompatibility.js

@@ -0,0 +1,128 @@
+import { createWebRtcDomException } from '../errors.js';
+import { codecParametersFromString } from '../sdp.js';
+function codecName(codec) {
+    return codec.name.toLowerCase();
+}
+function optionalEqual(left, right) {
+    return left == undefined || right == undefined || left === right;
+}
+function h264Parameters(codec) {
+    const parameters = codecParametersFromString(codec.parameters ?? '');
+    return {
+        packetizationMode: parameters['packetization-mode'],
+        profileLevelId: parameters['profile-level-id']?.toString().toLowerCase()
+    };
+}
+export function isCodecCompatible(source, configured) {
+    if (source.mimeType.toLowerCase() !== configured.mimeType.toLowerCase()) {
+        return false;
+    }
+    if (source.clockRate !== configured.clockRate)
+        return false;
+    if (!optionalEqual(source.channels, configured.channels))
+        return false;
+    if (codecName(source) !== 'h264')
+        return true;
+    const sourceParameters = h264Parameters(source);
+    const configuredParameters = h264Parameters(configured);
+    if (!optionalEqual(sourceParameters.packetizationMode, configuredParameters.packetizationMode)) {
+        return false;
+    }
+    return optionalEqual(sourceParameters.profileLevelId, configuredParameters.profileLevelId);
+}
+function isAuxiliary(codec) {
+    return ['rtx', 'red'].includes(codecName(codec));
+}
+/**
+ * remote track が実際に配信する codec を返す。
+ * audio の RED は RTCRtpReceiver が primary へ展開してから track へ渡すため、
+ * RED が参照する primary codec (不明なら先頭の primary) を track の codec とする。
+ */
+export function deliveredTrackCodec(kind, codec, negotiated) {
+    if (kind !== 'audio' || codec == undefined || codecName(codec) !== 'red') {
+        return codec;
+    }
+    const [primaryPayloadType] = referencedPayloadTypes(codec);
+    return (negotiated.find((candidate) => !isAuxiliary(candidate) && candidate.payloadType === primaryPayloadType) ??
+        negotiated.find((candidate) => !isAuxiliary(candidate)) ??
+        codec);
+}
+/**
+ * RTX / RED を除く primary codec に MIME 一致が 1 つでもあるか。
+ * remote m-line を local capability で扱えるかの判定 (Issue #705) に使う。
+ */
+export function hasCommonPrimaryMimeType(local, remote) {
+    return local.some((localCodec) => !isAuxiliary(localCodec) &&
+        remote.some((remoteCodec) => remoteCodec.mimeType.toLowerCase() ===
+            localCodec.mimeType.toLowerCase()));
+}
+function referencedPayloadTypes(codec) {
+    const parameters = codec.parameters ?? '';
+    if (codecName(codec) === 'rtx') {
+        const apt = Number(codecParametersFromString(parameters).apt);
+        return Number.isNaN(apt) ? [] : [apt];
+    }
+    if (codecName(codec) === 'red') {
+        return parameters
+            .split('/')
+            .map(Number)
+            .filter((value) => !Number.isNaN(value));
+    }
+    return [];
+}
+function withAuxiliaryCodecs(configured, primary) {
+    const keptPayloadTypes = new Set(primary.map((codec) => codec.payloadType));
+    const auxiliary = configured.filter((codec) => {
+        if (!isAuxiliary(codec))
+            return false;
+        const referenced = referencedPayloadTypes(codec);
+        return (referenced.length > 0 &&
+            referenced.every((payloadType) => keptPayloadTypes.has(payloadType)));
+    });
+    return configured.filter((codec) => primary.includes(codec) || auxiliary.includes(codec));
+}
+export function intersectCodecs(configured, source) {
+    const primary = configured.filter((codec) => !isAuxiliary(codec) &&
+        source.some((sourceCodec) => isCodecCompatible(sourceCodec, codec)));
+    return withAuxiliaryCodecs(configured, primary);
+}
+function matchesPreference(candidate, preference) {
+    return (candidate.mimeType.toLowerCase() === preference.mimeType.toLowerCase() &&
+        optionalEqual(candidate.clockRate, preference.clockRate));
+}
+export function applyCodecPreferences(configured, preferences) {
+    if (preferences == undefined)
+        return configured;
+    const preferred = preferences.flatMap((preference) => {
+        const match = configured.find((codec) => matchesPreference(codec, preference));
+        return match ? [match] : [];
+    });
+    const uniquePreferred = [...new Set(preferred)];
+    const referencedByPreferredAuxiliary = new Set(uniquePreferred.filter(isAuxiliary).flatMap(referencedPayloadTypes));
+    const primary = configured.filter((codec) => !isAuxiliary(codec) &&
+        (uniquePreferred.includes(codec) ||
+            referencedByPreferredAuxiliary.has(codec.payloadType)));
+    const allowed = withAuxiliaryCodecs(configured, primary);
+    return [
+        ...uniquePreferred.filter((codec) => allowed.includes(codec)),
+        ...allowed.filter((codec) => !uniquePreferred.includes(codec))
+    ];
+}
+export function resolveCodecs(configured, source, preferences) {
+    return applyCodecPreferences(source == undefined ? configured : intersectCodecs(configured, source), preferences);
+}
+function list(codecs) {
+    return codecs?.map((codec) => codec.mimeType).join(', ') || '(none)';
+}
+export function assertCodecsSupported(options) {
+    const { kind, configured, source, preferences } = options;
+    const sourceCompatible = source == undefined ? configured : intersectCodecs(configured, source);
+    if (source != undefined && sourceCompatible.length === 0) {
+        throw createWebRtcDomException('NotSupportedError', `Track codec ${list(source)} is not supported by this RTCPeerConnection. Configured ${kind} codecs: ${list(configured)}`);
+    }
+    const effective = applyCodecPreferences(sourceCompatible, preferences);
+    if (effective.length === 0) {
+        throw createWebRtcDomException('NotSupportedError', `No codec remains after applying codec preferences. Source codecs: ${list(source)} Configured codecs: ${list(configured)} Preferred codecs: ${list(preferences)}`);
+    }
+    return effective;
+}

package/dist/esm/lib/peer/media/extension/rtcpFeedback.js

@@ -0,0 +1,5 @@
+export const useFIR = () => ({ type: 'ccm', parameter: 'fir' });
+export const useNACK = () => ({ type: 'nack' });
+export const usePLI = () => ({ type: 'nack', parameter: 'pli' });
+export const useREMB = () => ({ type: 'goog-remb' });
+export const useTWCC = () => ({ type: 'transport-cc' });

package/dist/esm/lib/peer/media/extension/rtpExtension.js

@@ -0,0 +1,42 @@
+import { RTP_EXTENSION_URI } from '../../imports/rtp.js';
+import { RTCRtpHeaderExtensionParameters } from '../parameters.js';
+export function useSdesMid() {
+    return new RTCRtpHeaderExtensionParameters({
+        uri: RTP_EXTENSION_URI.sdesMid
+    });
+}
+export function useSdesRTPStreamId() {
+    return new RTCRtpHeaderExtensionParameters({
+        uri: RTP_EXTENSION_URI.sdesRTPStreamID
+    });
+}
+export function useRepairedRtpStreamId() {
+    return new RTCRtpHeaderExtensionParameters({
+        uri: RTP_EXTENSION_URI.repairedRtpStreamId
+    });
+}
+export function useTransportWideCC() {
+    return new RTCRtpHeaderExtensionParameters({
+        uri: RTP_EXTENSION_URI.transportWideCC
+    });
+}
+export function useAbsSendTime() {
+    return new RTCRtpHeaderExtensionParameters({
+        uri: RTP_EXTENSION_URI.absSendTime
+    });
+}
+export function useDependencyDescriptor() {
+    return new RTCRtpHeaderExtensionParameters({
+        uri: RTP_EXTENSION_URI.dependencyDescriptor
+    });
+}
+export function useAudioLevelIndication() {
+    return new RTCRtpHeaderExtensionParameters({
+        uri: RTP_EXTENSION_URI.audioLevelIndication
+    });
+}
+export function useVideoOrientation() {
+    return new RTCRtpHeaderExtensionParameters({
+        uri: RTP_EXTENSION_URI.videoOrientation
+    });
+}

package/dist/esm/lib/peer/media/index.js

@@ -0,0 +1,12 @@
+export * from './codec.js';
+export * from './codecCompatibility.js';
+export * from './extension/rtcpFeedback.js';
+export * from './extension/rtpExtension.js';
+export * from './parameters.js';
+export * from './router.js';
+export * from './rtpReceiver.js';
+export * from './rtpSender.js';
+export * from './rtpTransceiver.js';
+export * from './stats.js';
+export * from '../transceiverManager.js';
+export * from './track.js';

package/dist/esm/lib/peer/media/parameters.js

@@ -0,0 +1,50 @@
+export class RTCRtpCodecParameters {
+    constructor(props) {
+        this.rtcpFeedback = [];
+        this.direction = 'all';
+        Object.assign(this, props);
+    }
+    get name() {
+        return this.mimeType.split('/')[1];
+    }
+    get contentType() {
+        return this.mimeType.split('/')[0];
+    }
+    get str() {
+        let s = `${this.name}/${this.clockRate}`;
+        if (this.channels === 2)
+            s += '/2';
+        return s;
+    }
+}
+export class RTCRtpHeaderExtensionParameters {
+    constructor(props) {
+        Object.assign(this, props);
+    }
+}
+export class RTCRtcpParameters {
+    constructor(props = {}) {
+        this.mux = false;
+        Object.assign(this, props);
+    }
+}
+export class RTCRtcpFeedback {
+    constructor(props = {}) {
+        Object.assign(this, props);
+    }
+}
+export class RTCRtpRtxParameters {
+    constructor(props = {}) {
+        Object.assign(this, props);
+    }
+}
+export class RTCRtpCodingParameters {
+    constructor(props) {
+        Object.assign(this, props);
+    }
+}
+export class RTCRtpSimulcastParameters {
+    constructor(props) {
+        Object.assign(this, props);
+    }
+}