@livedigital/client 2.37.0 → 2.37.1

package/dist/node_modules/mediasoup-client/src/RtpParameters.d.ts

@@ -0,0 +1,305 @@
+/**
+ * The RTP capabilities define what mediasoup or an endpoint can receive at
+ * media level.
+ */
+export declare type RtpCapabilities = {
+    /**
+     * Supported media and RTX codecs.
+     */
+    codecs?: RtpCodecCapability[];
+    /**
+     * Supported RTP header extensions.
+     */
+    headerExtensions?: RtpHeaderExtension[];
+};
+/**
+ * Media kind ('audio' or 'video').
+ */
+export declare type MediaKind = 'audio' | 'video';
+/**
+ * Provides information on the capabilities of a codec within the RTP
+ * capabilities. The list of media codecs supported by mediasoup and their
+ * settings is defined in the supportedRtpCapabilities.ts file.
+ *
+ * Exactly one RtpCodecCapability will be present for each supported combination
+ * of parameters that requires a distinct value of preferredPayloadType. For
+ * example:
+ *
+ * - Multiple H264 codecs, each with their own distinct 'packetization-mode' and
+ *   'profile-level-id' values.
+ * - Multiple VP9 codecs, each with their own distinct 'profile-id' value.
+ *
+ * RtpCodecCapability entries in the mediaCodecs array of RouterOptions do not
+ * require preferredPayloadType field (if unset, mediasoup will choose a random
+ * one). If given, make sure it's in the 96-127 range.
+ */
+export declare type RtpCodecCapability = {
+    /**
+     * Media kind.
+     */
+    kind: MediaKind;
+    /**
+     * The codec MIME media type/subtype (e.g. 'audio/opus', 'video/VP8').
+     */
+    mimeType: string;
+    /**
+     * The preferred RTP payload type.
+     */
+    preferredPayloadType?: number;
+    /**
+     * Codec clock rate expressed in Hertz.
+     */
+    clockRate: number;
+    /**
+     * The number of channels supported (e.g. two for stereo). Just for audio.
+     * Default 1.
+     */
+    channels?: number;
+    /**
+     * Codec specific parameters. Some parameters (such as 'packetization-mode'
+     * and 'profile-level-id' in H264 or 'profile-id' in VP9) are critical for
+     * codec matching.
+     */
+    parameters?: any;
+    /**
+     * Transport layer and codec-specific feedback messages for this codec.
+     */
+    rtcpFeedback?: RtcpFeedback[];
+};
+/**
+ * Direction of RTP header extension.
+ */
+export declare type RtpHeaderExtensionDirection = 'sendrecv' | 'sendonly' | 'recvonly' | 'inactive';
+/**
+ * Provides information relating to supported header extensions. The list of
+ * RTP header extensions supported by mediasoup is defined in the
+ * supportedRtpCapabilities.ts file.
+ *
+ * mediasoup does not currently support encrypted RTP header extensions. The
+ * direction field is just present in mediasoup RTP capabilities (retrieved via
+ * router.rtpCapabilities or mediasoup.getSupportedRtpCapabilities()). It's
+ * ignored if present in endpoints' RTP capabilities.
+ */
+export declare type RtpHeaderExtension = {
+    /**
+     * Media kind.
+     */
+    kind: MediaKind;
+    uri: string;
+    /**
+     * The preferred numeric identifier that goes in the RTP packet. Must be
+     * unique.
+     */
+    preferredId: number;
+    /**
+     * If true, it is preferred that the value in the header be encrypted as per
+     * RFC 6904. Default false.
+     */
+    preferredEncrypt?: boolean;
+    /**
+     * If 'sendrecv', mediasoup supports sending and receiving this RTP extension.
+     * 'sendonly' means that mediasoup can send (but not receive) it. 'recvonly'
+     * means that mediasoup can receive (but not send) it.
+     */
+    direction?: RtpHeaderExtensionDirection;
+};
+/**
+ * The RTP send parameters describe a media stream received by mediasoup from
+ * an endpoint through its corresponding mediasoup Producer. These parameters
+ * may include a mid value that the mediasoup transport will use to match
+ * received RTP packets based on their MID RTP extension value.
+ *
+ * mediasoup allows RTP send parameters with a single encoding and with multiple
+ * encodings (simulcast). In the latter case, each entry in the encodings array
+ * must include a ssrc field or a rid field (the RID RTP extension value). Check
+ * the Simulcast and SVC sections for more information.
+ *
+ * The RTP receive parameters describe a media stream as sent by mediasoup to
+ * an endpoint through its corresponding mediasoup Consumer. The mid value is
+ * unset (mediasoup does not include the MID RTP extension into RTP packets
+ * being sent to endpoints).
+ *
+ * There is a single entry in the encodings array (even if the corresponding
+ * producer uses simulcast). The consumer sends a single and continuous RTP
+ * stream to the endpoint and spatial/temporal layer selection is possible via
+ * consumer.setPreferredLayers().
+ *
+ * As an exception, previous bullet is not true when consuming a stream over a
+ * PipeTransport, in which all RTP streams from the associated producer are
+ * forwarded verbatim through the consumer.
+ *
+ * The RTP receive parameters will always have their ssrc values randomly
+ * generated for all of its  encodings (and optional rtx: { ssrc: XXXX } if the
+ * endpoint supports RTX), regardless of the original RTP send parameters in
+ * the associated producer. This applies even if the producer's encodings have
+ * rid set.
+ */
+export declare type RtpParameters = {
+    /**
+     * The MID RTP extension value as defined in the BUNDLE specification.
+     */
+    mid?: string;
+    /**
+     * Media and RTX codecs in use.
+     */
+    codecs: RtpCodecParameters[];
+    /**
+     * RTP header extensions in use.
+     */
+    headerExtensions?: RtpHeaderExtensionParameters[];
+    /**
+     * Transmitted RTP streams and their settings.
+     */
+    encodings?: RtpEncodingParameters[];
+    /**
+     * Parameters used for RTCP.
+     */
+    rtcp?: RtcpParameters;
+};
+/**
+ * Provides information on codec settings within the RTP parameters. The list
+ * of media codecs supported by mediasoup and their settings is defined in the
+ * supportedRtpCapabilities.ts file.
+ */
+export declare type RtpCodecParameters = {
+    /**
+     * The codec MIME media type/subtype (e.g. 'audio/opus', 'video/VP8').
+     */
+    mimeType: string;
+    /**
+     * The value that goes in the RTP Payload Type Field. Must be unique.
+     */
+    payloadType: number;
+    /**
+     * Codec clock rate expressed in Hertz.
+     */
+    clockRate: number;
+    /**
+     * The number of channels supported (e.g. two for stereo). Just for audio.
+     * Default 1.
+     */
+    channels?: number;
+    /**
+     * Codec-specific parameters available for signaling. Some parameters (such
+     * as 'packetization-mode' and 'profile-level-id' in H264 or 'profile-id' in
+     * VP9) are critical for codec matching.
+     */
+    parameters?: any;
+    /**
+     * Transport layer and codec-specific feedback messages for this codec.
+     */
+    rtcpFeedback?: RtcpFeedback[];
+};
+/**
+ * Provides information on RTCP feedback messages for a specific codec. Those
+ * messages can be transport layer feedback messages or codec-specific feedback
+ * messages. The list of RTCP feedbacks supported by mediasoup is defined in the
+ * supportedRtpCapabilities.ts file.
+ */
+export declare type RtcpFeedback = {
+    /**
+     * RTCP feedback type.
+     */
+    type: string;
+    /**
+     * RTCP feedback parameter.
+     */
+    parameter?: string;
+};
+/**
+ * Provides information relating to an encoding, which represents a media RTP
+ * stream and its associated RTX stream (if any).
+ */
+export declare type RtpEncodingParameters = {
+    /**
+     * The media SSRC.
+     */
+    ssrc?: number;
+    /**
+     * The RID RTP extension value. Must be unique.
+     */
+    rid?: string;
+    /**
+     * Codec payload type this encoding affects. If unset, first media codec is
+     * chosen.
+     */
+    codecPayloadType?: number;
+    /**
+     * RTX stream information. It must contain a numeric ssrc field indicating
+     * the RTX SSRC.
+     */
+    rtx?: {
+        ssrc: number;
+    };
+    /**
+     * It indicates whether discontinuous RTP transmission will be used. Useful
+     * for audio (if the codec supports it) and for video screen sharing (when
+     * static content is being transmitted, this option disables the RTP
+     * inactivity checks in mediasoup). Default false.
+     */
+    dtx?: boolean;
+    /**
+     * Number of spatial and temporal layers in the RTP stream (e.g. 'L1T3').
+     * See webrtc-svc.
+     */
+    scalabilityMode?: string;
+    /**
+     * Others.
+     */
+    scaleResolutionDownBy?: number;
+    maxBitrate?: number;
+    maxFramerate?: number;
+    adaptivePtime?: boolean;
+    priority?: 'very-low' | 'low' | 'medium' | 'high';
+    networkPriority?: 'very-low' | 'low' | 'medium' | 'high';
+};
+/**
+ * Defines a RTP header extension within the RTP parameters. The list of RTP
+ * header extensions supported by mediasoup is defined in the
+ * supportedRtpCapabilities.ts file.
+ *
+ * mediasoup does not currently support encrypted RTP header extensions and no
+ * parameters are currently considered.
+ */
+export declare type RtpHeaderExtensionParameters = {
+    /**
+     * The URI of the RTP header extension, as defined in RFC 5285.
+     */
+    uri: string;
+    /**
+     * The numeric identifier that goes in the RTP packet. Must be unique.
+     */
+    id: number;
+    /**
+     * If true, the value in the header is encrypted as per RFC 6904. Default false.
+     */
+    encrypt?: boolean;
+    /**
+     * Configuration parameters for the header extension.
+     */
+    parameters?: any;
+};
+/**
+ * Provides information on RTCP settings within the RTP parameters.
+ *
+ * If no cname is given in a producer's RTP parameters, the mediasoup transport
+ * will choose a random one that will be used into RTCP SDES messages sent to
+ * all its associated consumers.
+ *
+ * mediasoup assumes reducedSize to always be true.
+ */
+export declare type RtcpParameters = {
+    /**
+     * The Canonical Name (CNAME) used by RTCP (e.g. in SDES messages).
+     */
+    cname?: string;
+    /**
+     * Whether reduced size RTCP RFC 5506 is configured (if true) or compound RTCP
+     * as specified in RFC 3550 (if false). Default true.
+     */
+    reducedSize?: boolean;
+    /**
+     * Whether RTCP-mux is used. Default true.
+     */
+    mux?: boolean;
+};

package/dist/node_modules/mediasoup-client/src/SctpParameters.d.ts

@@ -0,0 +1,67 @@
+export declare type SctpCapabilities = {
+    numStreams: NumSctpStreams;
+};
+export declare type NumSctpStreams = {
+    /**
+     * Initially requested number of outgoing SCTP streams.
+     */
+    OS: number;
+    /**
+     * Maximum number of incoming SCTP streams.
+     */
+    MIS: number;
+};
+export declare type SctpParameters = {
+    /**
+     * Must always equal 5000.
+     */
+    port: number;
+    /**
+     * Initially requested number of outgoing SCTP streams.
+     */
+    OS: number;
+    /**
+     * Maximum number of incoming SCTP streams.
+     */
+    MIS: number;
+    /**
+     * Maximum allowed size for SCTP messages.
+     */
+    maxMessageSize: number;
+};
+/**
+ * SCTP stream parameters describe the reliability of a certain SCTP stream.
+ * If ordered is true then maxPacketLifeTime and maxRetransmits must be
+ * false.
+ * If ordered if false, only one of maxPacketLifeTime or maxRetransmits
+ * can be true.
+ */
+export declare type SctpStreamParameters = {
+    /**
+     * SCTP stream id.
+     */
+    streamId?: number;
+    /**
+     * Whether data messages must be received in order. if true the messages will
+     * be sent reliably. Default true.
+     */
+    ordered?: boolean;
+    /**
+     * When ordered is false indicates the time (in milliseconds) after which a
+     * SCTP packet will stop being retransmitted.
+     */
+    maxPacketLifeTime?: number;
+    /**
+     * When ordered is false indicates the maximum number of times a packet will
+     * be retransmitted.
+     */
+    maxRetransmits?: number;
+    /**
+     * A label which can be used to distinguish this DataChannel from others.
+     */
+    label?: string;
+    /**
+     * Name of the sub-protocol used by this DataChannel.
+     */
+    protocol?: string;
+};

package/dist/node_modules/mediasoup-client/src/Transport.d.ts

@@ -0,0 +1,212 @@
+import { EnhancedEventEmitter } from './EnhancedEventEmitter';
+import { HandlerFactory, HandlerInterface } from './handlers/HandlerInterface';
+import { Producer, ProducerOptions } from './Producer';
+import { Consumer, ConsumerOptions } from './Consumer';
+import { DataProducer, DataProducerOptions } from './DataProducer';
+import { DataConsumer, DataConsumerOptions } from './DataConsumer';
+import { SctpParameters } from './SctpParameters';
+interface InternalTransportOptions extends TransportOptions {
+    direction: 'send' | 'recv';
+    handlerFactory: HandlerFactory;
+    extendedRtpCapabilities: any;
+    canProduceByKind: CanProduceByKind;
+}
+export declare type TransportOptions = {
+    id: string;
+    iceParameters: IceParameters;
+    iceCandidates: IceCandidate[];
+    dtlsParameters: DtlsParameters;
+    sctpParameters?: SctpParameters;
+    iceServers?: RTCIceServer[];
+    iceTransportPolicy?: RTCIceTransportPolicy;
+    additionalSettings?: any;
+    proprietaryConstraints?: any;
+    appData?: any;
+};
+export declare type CanProduceByKind = {
+    audio: boolean;
+    video: boolean;
+    [key: string]: boolean;
+};
+export declare type IceParameters = {
+    /**
+     * ICE username fragment.
+     * */
+    usernameFragment: string;
+    /**
+     * ICE password.
+     */
+    password: string;
+    /**
+     * ICE Lite.
+     */
+    iceLite?: boolean;
+};
+export declare type IceCandidate = {
+    /**
+     * Unique identifier that allows ICE to correlate candidates that appear on
+     * multiple transports.
+     */
+    foundation: string;
+    /**
+     * The assigned priority of the candidate.
+     */
+    priority: number;
+    /**
+     * The IP address of the candidate.
+     */
+    ip: string;
+    /**
+     * The protocol of the candidate.
+     */
+    protocol: 'udp' | 'tcp';
+    /**
+     * The port for the candidate.
+     */
+    port: number;
+    /**
+     * The type of candidate.
+     */
+    type: 'host' | 'srflx' | 'prflx' | 'relay';
+    /**
+     * The type of TCP candidate.
+     */
+    tcpType: 'active' | 'passive' | 'so';
+};
+export declare type DtlsParameters = {
+    /**
+     * Server DTLS role. Default 'auto'.
+     */
+    role?: DtlsRole;
+    /**
+     * Server DTLS fingerprints.
+     */
+    fingerprints: DtlsFingerprint[];
+};
+/**
+ * The hash function algorithm (as defined in the "Hash function Textual Names"
+ * registry initially specified in RFC 4572 Section 8) and its corresponding
+ * certificate fingerprint value (in lowercase hex string as expressed utilizing
+ * the syntax of "fingerprint" in RFC 4572 Section 5).
+ */
+export declare type DtlsFingerprint = {
+    algorithm: string;
+    value: string;
+};
+export declare type DtlsRole = 'auto' | 'client' | 'server';
+export declare type ConnectionState = 'new' | 'connecting' | 'connected' | 'failed' | 'disconnected' | 'closed';
+export declare type PlainRtpParameters = {
+    ip: string;
+    ipVersion: 4 | 6;
+    port: number;
+};
+export declare class Transport extends EnhancedEventEmitter {
+    private readonly _id;
+    private _closed;
+    private readonly _direction;
+    private readonly _extendedRtpCapabilities;
+    private readonly _canProduceByKind;
+    private readonly _maxSctpMessageSize?;
+    private readonly _handler;
+    private _connectionState;
+    private readonly _appData;
+    private readonly _producers;
+    private readonly _consumers;
+    private readonly _dataProducers;
+    private readonly _dataConsumers;
+    private _probatorConsumerCreated;
+    private readonly _awaitQueue;
+    private _pendingConsumerTasks;
+    private _consumerCreationInProgress;
+    protected readonly _observer: EnhancedEventEmitter;
+    /**
+     * @emits connect - (transportLocalParameters: any, callback: Function, errback: Function)
+     * @emits connectionstatechange - (connectionState: ConnectionState)
+     * @emits produce - (producerLocalParameters: any, callback: Function, errback: Function)
+     * @emits producedata - (dataProducerLocalParameters: any, callback: Function, errback: Function)
+     */
+    constructor({ direction, id, iceParameters, iceCandidates, dtlsParameters, sctpParameters, iceServers, iceTransportPolicy, additionalSettings, proprietaryConstraints, appData, handlerFactory, extendedRtpCapabilities, canProduceByKind }: InternalTransportOptions);
+    /**
+     * Transport id.
+     */
+    get id(): string;
+    /**
+     * Whether the Transport is closed.
+     */
+    get closed(): boolean;
+    /**
+     * Transport direction.
+     */
+    get direction(): 'send' | 'recv';
+    /**
+     * RTC handler instance.
+     */
+    get handler(): HandlerInterface;
+    /**
+     * Connection state.
+     */
+    get connectionState(): ConnectionState;
+    /**
+     * App custom data.
+     */
+    get appData(): any;
+    /**
+     * Invalid setter.
+     */
+    set appData(appData: any);
+    /**
+     * Observer.
+     *
+     * @emits close
+     * @emits newproducer - (producer: Producer)
+     * @emits newconsumer - (producer: Producer)
+     * @emits newdataproducer - (dataProducer: DataProducer)
+     * @emits newdataconsumer - (dataProducer: DataProducer)
+     */
+    get observer(): EnhancedEventEmitter;
+    /**
+     * Close the Transport.
+     */
+    close(): void;
+    /**
+     * Get associated Transport (RTCPeerConnection) stats.
+     *
+     * @returns {RTCStatsReport}
+     */
+    getStats(): Promise<RTCStatsReport>;
+    /**
+     * Restart ICE connection.
+     */
+    restartIce({ iceParameters }: {
+        iceParameters: IceParameters;
+    }): Promise<void>;
+    /**
+     * Update ICE servers.
+     */
+    updateIceServers({ iceServers }?: {
+        iceServers?: RTCIceServer[];
+    }): Promise<void>;
+    /**
+     * Create a Producer.
+     */
+    produce({ track, encodings, codecOptions, codec, stopTracks, disableTrackOnPause, zeroRtpOnPause, appData }?: ProducerOptions): Promise<Producer>;
+    /**
+     * Create a Consumer to consume a remote Producer.
+     */
+    consume({ id, producerId, kind, rtpParameters, appData }: ConsumerOptions): Promise<Consumer>;
+    /**
+     * Create a DataProducer
+     */
+    produceData({ ordered, maxPacketLifeTime, maxRetransmits, label, protocol, appData }?: DataProducerOptions): Promise<DataProducer>;
+    /**
+     * Create a DataConsumer
+     */
+    consumeData({ id, dataProducerId, sctpStreamParameters, label, protocol, appData }: DataConsumerOptions): Promise<DataConsumer>;
+    _createPendingConsumers(): Promise<void>;
+    _handleHandler(): void;
+    _handleProducer(producer: Producer): void;
+    _handleConsumer(consumer: Consumer): void;
+    _handleDataProducer(dataProducer: DataProducer): void;
+    _handleDataConsumer(dataConsumer: DataConsumer): void;
+}
+export {};

package/dist/node_modules/mediasoup-client/src/errors.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Error indicating not support for something.
+ */
+export declare class UnsupportedError extends Error {
+    constructor(message: string);
+}
+/**
+ * Error produced when calling a method in an invalid state.
+ */
+export declare class InvalidStateError extends Error {
+    constructor(message: string);
+}

package/dist/node_modules/mediasoup-client/src/handlers/HandlerInterface.d.ts

@@ -0,0 +1,84 @@
+import { EnhancedEventEmitter } from '../EnhancedEventEmitter';
+import { ProducerCodecOptions } from '../Producer';
+import { IceParameters, IceCandidate, DtlsParameters } from '../Transport';
+import { RtpCapabilities, RtpCodecCapability, RtpParameters, RtpEncodingParameters } from '../RtpParameters';
+import { SctpCapabilities, SctpParameters, SctpStreamParameters } from '../SctpParameters';
+export declare type HandlerFactory = () => HandlerInterface;
+export declare type HandlerRunOptions = {
+    direction: 'send' | 'recv';
+    iceParameters: IceParameters;
+    iceCandidates: IceCandidate[];
+    dtlsParameters: DtlsParameters;
+    sctpParameters?: SctpParameters;
+    iceServers?: RTCIceServer[];
+    iceTransportPolicy?: RTCIceTransportPolicy;
+    additionalSettings?: any;
+    proprietaryConstraints?: any;
+    extendedRtpCapabilities: any;
+};
+export declare type HandlerSendOptions = {
+    track: MediaStreamTrack;
+    encodings?: RtpEncodingParameters[];
+    codecOptions?: ProducerCodecOptions;
+    codec?: RtpCodecCapability;
+};
+export declare type HandlerSendResult = {
+    localId: string;
+    rtpParameters: RtpParameters;
+    rtpSender?: RTCRtpSender;
+};
+export declare type HandlerReceiveOptions = {
+    trackId: string;
+    kind: 'audio' | 'video';
+    rtpParameters: RtpParameters;
+};
+export declare type HandlerReceiveResult = {
+    localId: string;
+    track: MediaStreamTrack;
+    rtpReceiver?: RTCRtpReceiver;
+};
+export declare type HandlerSendDataChannelOptions = SctpStreamParameters;
+export declare type HandlerSendDataChannelResult = {
+    dataChannel: RTCDataChannel;
+    sctpStreamParameters: SctpStreamParameters;
+};
+export declare type HandlerReceiveDataChannelOptions = {
+    sctpStreamParameters: SctpStreamParameters;
+    label?: string;
+    protocol?: string;
+};
+export declare type HandlerReceiveDataChannelResult = {
+    dataChannel: RTCDataChannel;
+};
+export declare abstract class HandlerInterface extends EnhancedEventEmitter {
+    /**
+     * @emits @connect - (
+     *     { dtlsParameters: DtlsParameters },
+     *     callback: Function,
+     *     errback: Function
+     *   )
+     * @emits @connectionstatechange - (connectionState: ConnectionState)
+     */
+    constructor();
+    abstract get name(): string;
+    abstract close(): void;
+    abstract getNativeRtpCapabilities(): Promise<RtpCapabilities>;
+    abstract getNativeSctpCapabilities(): Promise<SctpCapabilities>;
+    abstract run(options: HandlerRunOptions): void;
+    abstract updateIceServers(iceServers: RTCIceServer[]): Promise<void>;
+    abstract restartIce(iceParameters: IceParameters): Promise<void>;
+    abstract getTransportStats(): Promise<RTCStatsReport>;
+    abstract send(options: HandlerSendOptions): Promise<HandlerSendResult>;
+    abstract stopSending(localId: string): Promise<void>;
+    abstract replaceTrack(localId: string, track: MediaStreamTrack | null): Promise<void>;
+    abstract setMaxSpatialLayer(localId: string, spatialLayer: number): Promise<void>;
+    abstract setRtpEncodingParameters(localId: string, params: any): Promise<void>;
+    abstract getSenderStats(localId: string): Promise<RTCStatsReport>;
+    abstract sendDataChannel(options: HandlerSendDataChannelOptions): Promise<HandlerSendDataChannelResult>;
+    abstract receive(optionsList: HandlerReceiveOptions[]): Promise<HandlerReceiveResult[]>;
+    abstract stopReceiving(localId: string): Promise<void>;
+    abstract pauseReceiving(localId: string): Promise<void>;
+    abstract resumeReceiving(localId: string): Promise<void>;
+    abstract getReceiverStats(localId: string): Promise<RTCStatsReport>;
+    abstract receiveDataChannel(options: HandlerReceiveDataChannelOptions): Promise<HandlerReceiveDataChannelResult>;
+}