@webex/plugin-meetings 3.0.0-beta.16 → 3.0.0-beta.161

package/dist/types/multistream/mediaRequestManager.d.ts

@@ -0,0 +1,118 @@
+import { StreamRequest } from '@webex/internal-media-core';
+import { ReceiveSlot } from './receiveSlot';
+export interface ActiveSpeakerPolicyInfo {
+    policy: 'active-speaker';
+    priority: number;
+    crossPriorityDuplication: boolean;
+    crossPolicyDuplication: boolean;
+    preferLiveVideo: boolean;
+}
+export interface ReceiverSelectedPolicyInfo {
+    policy: 'receiver-selected';
+    csi: number;
+}
+export type PolicyInfo = ActiveSpeakerPolicyInfo | ReceiverSelectedPolicyInfo;
+export interface H264CodecInfo {
+    codec: 'h264';
+    maxFs?: number;
+    maxFps?: number;
+    maxMbps?: number;
+    maxWidth?: number;
+    maxHeight?: number;
+}
+export type CodecInfo = H264CodecInfo;
+export interface MediaRequest {
+    policyInfo: PolicyInfo;
+    receiveSlots: Array<ReceiveSlot>;
+    codecInfo?: CodecInfo;
+    preferredMaxFs?: number;
+    handleMaxFs?: ({ maxFs }: {
+        maxFs: number;
+    }) => void;
+}
+export type MediaRequestId = string;
+type DegradationPreferences = {
+    maxMacroblocksLimit: number;
+};
+type SendMediaRequestsCallback = (streamRequests: StreamRequest[]) => void;
+type Kind = 'audio' | 'video';
+type Options = {
+    degradationPreferences: DegradationPreferences;
+    kind: Kind;
+    trimRequestsToNumOfSources: boolean;
+};
+export declare class MediaRequestManager {
+    private sendMediaRequestsCallback;
+    private kind;
+    private counter;
+    private clientRequests;
+    private degradationPreferences;
+    private sourceUpdateListener;
+    private debouncedSourceUpdateListener;
+    private previousStreamRequests;
+    private trimRequestsToNumOfSources;
+    private numTotalSources;
+    private numLiveSources;
+    constructor(sendMediaRequestsCallback: SendMediaRequestsCallback, options: Options);
+    setDegradationPreferences(degradationPreferences: DegradationPreferences): void;
+    private getDegradedClientRequests;
+    /**
+     * Returns true if two stream requests are the same, false otherwise.
+     *
+     * @param {StreamRequest} streamRequestA - Stream request A for comparison.
+     * @param {StreamRequest} streamRequestB - Stream request B for comparison.
+     * @returns {boolean} - Whether they are equal.
+     */
+    isEqual(streamRequestA: StreamRequest, streamRequestB: StreamRequest): boolean;
+    /**
+     * Compares new stream requests to previous ones and determines
+     * if they are the same.
+     *
+     * @param {StreamRequest[]} newRequests - Array with new requests.
+     * @returns {boolean} - True if they are equal, false otherwise.
+     */
+    private checkIsNewRequestsEqualToPrev;
+    /**
+     * Returns the maxPayloadBitsPerSecond per Stream
+     *
+     * If MediaRequestManager kind is "audio", a constant bitrate will be returned.
+     * If MediaRequestManager kind is "video", the bitrate will be calculated based
+     * on maxFs (default h264 maxFs as fallback if maxFs is not defined)
+     *
+     * @param {MediaRequest} mediaRequest  - mediaRequest to take data from
+     * @returns {number} maxPayloadBitsPerSecond
+     */
+    private getMaxPayloadBitsPerSecond;
+    /**
+     * Returns the max Macro Blocks per second (maxMbps) per H264 Stream
+     *
+     * The maxMbps will be calculated based on maxFs and maxFps
+     * (default h264 maxFps as fallback if maxFps is not defined)
+     *
+     * @param {MediaRequest} mediaRequest  - mediaRequest to take data from
+     * @returns {number} maxMbps
+     */
+    private getH264MaxMbps;
+    /**
+     * Clears the previous stream requests.
+     *
+     * @returns {void}
+     */
+    clearPreviousRequests(): void;
+    /** Modifies the passed in clientRequests and makes sure that in total they don't ask
+     *  for more streams than there are available.
+     *
+     * @param {Object} clientRequests
+     * @returns {void}
+     */
+    private trimRequests;
+    private getPreferLiveVideo;
+    private cloneClientRequests;
+    private sendRequests;
+    addRequest(mediaRequest: MediaRequest, commit?: boolean): MediaRequestId;
+    cancelRequest(requestId: MediaRequestId, commit?: boolean): void;
+    commit(): void;
+    reset(): void;
+    setNumCurrentSources(numTotalSources: number, numLiveSources: number): void;
+}
+export {};

package/dist/types/multistream/receiveSlot.d.ts

@@ -0,0 +1,68 @@
+import { MediaType, ReceiveSlot as WcmeReceiveSlot, StreamState } from '@webex/internal-media-core';
+import EventsScope from '../common/events/events-scope';
+export declare const ReceiveSlotEvents: {
+    SourceUpdate: string;
+    MaxFsUpdate: string;
+};
+export type { StreamState } from '@webex/internal-media-core';
+export type CSI = number;
+export type MemberId = string;
+export type ReceiveSlotId = string;
+export type FindMemberIdCallback = (csi: CSI) => MemberId | undefined;
+/**
+ * Class representing a receive slot. A single receive slot is able to receive a single track
+ * for example some participant's main video or audio
+ */
+export declare class ReceiveSlot extends EventsScope {
+    #private;
+    private readonly mcReceiveSlot;
+    private readonly findMemberIdCallback;
+    readonly id: ReceiveSlotId;
+    readonly mediaType: MediaType;
+    /**
+     * constructor - don't use it directly, you should always use meeting.receiveSlotManager.allocateSlot()
+     * to create any receive slots
+     *
+     * @param {MediaType} mediaType
+     * @param {ReceiveSlot} mcReceiveSlot
+     * @param {FindMemberIdCallback} findMemberIdCallback callback for finding memberId for given CSI
+     */
+    constructor(mediaType: MediaType, mcReceiveSlot: WcmeReceiveSlot, findMemberIdCallback: FindMemberIdCallback);
+    /**
+     * Getter for memberId
+     */
+    get memberId(): string;
+    /**
+     * Getter for csi
+     */
+    get csi(): number;
+    /**
+     * Set the max frame size for this slot
+     * @param newFs frame size
+     */
+    setMaxFs(newFs: any): void;
+    /**
+     * Getter for sourceState
+     */
+    get sourceState(): StreamState;
+    /**
+     * registers event handlers with the underlying ReceiveSlot
+     */
+    private setupEventListeners;
+    /** Tries to find the member id for this receive slot if it hasn't got one */
+    findMemberId(): void;
+    /**
+     * @returns {string} a log message used to identify the receive slot
+     */
+    get logString(): string;
+    /**
+     * The MediaStream object associated with this slot.
+     *
+     * @returns {MediaStream} The MediaStreamTrack.
+     */
+    get stream(): MediaStream;
+    /**
+     * The underlying WCME receive slot
+     */
+    get wcmeReceiveSlot(): WcmeReceiveSlot;
+}

package/dist/types/multistream/receiveSlotManager.d.ts

@@ -0,0 +1,56 @@
+import { MediaType, ReceiveSlot as WcmeReceiveSlot } from '@webex/internal-media-core';
+import { FindMemberIdCallback, ReceiveSlot } from './receiveSlot';
+export type CreateSlotCallback = (mediaType: MediaType) => Promise<WcmeReceiveSlot>;
+export type { CSI, FindMemberIdCallback } from './receiveSlot';
+/**
+ * Manages all receive slots used by a meeting. WMCE receive slots cannot be ever deleted,
+ * so this manager has a pool in order to re-use the slots that were released earlier.
+ */
+export declare class ReceiveSlotManager {
+    private allocatedSlots;
+    private freeSlots;
+    private createSlotCallback;
+    private findMemberIdByCsiCallback;
+    /**
+     * Constructor
+     * @param {Meeting} meeting
+     */
+    constructor(createSlotCallback: CreateSlotCallback, findMemberIdByCsiCallback: FindMemberIdCallback);
+    /**
+     * Creates a new receive slot or returns one from the existing pool of free slots
+     *
+     * @param {MediaType} mediaType
+     * @returns {Promise<ReceiveSlot>}
+     */
+    allocateSlot(mediaType: MediaType): Promise<ReceiveSlot>;
+    /**
+     * Releases the slot back to the pool so it can be re-used by others in the future
+     * @param {ReceiveSlot} slot
+     */
+    releaseSlot(slot: ReceiveSlot): void;
+    /**
+     * Resets the slot manager - this method should be called when the media connection is torn down
+     */
+    reset(): void;
+    /**
+     * Returns statistics about the managed slots
+     *
+     * @returns {Object}
+     */
+    getStats(): {
+        numAllocatedSlots: {};
+        numFreeSlots: {};
+    };
+    /**
+     * Tries to find the member id on all allocated receive slots
+     * This function should be called when new members are added to the meeting.
+     */
+    updateMemberIds(): void;
+    /**
+     * Find a receive slot by a ssrc.
+     *
+     * @param ssrc - The ssrc of the receive slot to find.
+     * @returns - The receive slot with this ssrc, undefined if not found.
+     */
+    findReceiveSlotBySsrc(ssrc: number): ReceiveSlot | undefined;
+}

package/dist/types/multistream/remoteMedia.d.ts

@@ -0,0 +1,72 @@
+import { MediaType, StreamState } from '@webex/internal-media-core';
+import EventsScope from '../common/events/events-scope';
+import { MediaRequestManager } from './mediaRequestManager';
+import { ReceiveSlot } from './receiveSlot';
+export declare const RemoteMediaEvents: {
+    SourceUpdate: string;
+    Stopped: string;
+};
+export type RemoteVideoResolution = 'thumbnail' | 'very small' | 'small' | 'medium' | 'large' | 'best';
+/**
+ * Converts pane size into h264 maxFs
+ * @param {PaneSize} paneSize
+ * @returns {number}
+ */
+export declare function getMaxFs(paneSize: RemoteVideoResolution): number;
+type Options = {
+    resolution?: RemoteVideoResolution;
+};
+export type RemoteMediaId = string;
+/**
+ * Class representing a remote audio/video stream.
+ *
+ * Internally it is associated with a specific receive slot
+ * and a media request for it.
+ */
+export declare class RemoteMedia extends EventsScope {
+    private receiveSlot?;
+    private readonly mediaRequestManager;
+    private readonly options;
+    private mediaRequestId?;
+    readonly id: RemoteMediaId;
+    /**
+     * Constructs RemoteMedia instance
+     *
+     * @param receiveSlot
+     * @param mediaRequestManager
+     * @param options
+     */
+    constructor(receiveSlot: ReceiveSlot, mediaRequestManager: MediaRequestManager, options?: Options);
+    /**
+     * Supply the width and height of the video element
+     * to restrict the requested resolution to this size
+     * @param width width of the video element
+     * @param height height of the video element
+     */
+    setSizeHint(width: any, height: any): void;
+    /**
+     * registers event listeners on the receive slot and forwards all the events
+     */
+    private setupEventListeners;
+    /**
+     * Getter for mediaType
+     */
+    get mediaType(): MediaType;
+    /**
+     * Getter for memberId
+     */
+    get memberId(): string;
+    /**
+     * Getter for csi
+     */
+    get csi(): number;
+    /**
+     * Getter for source state
+     */
+    get sourceState(): StreamState;
+    /**
+     * Getter for remote media stream
+     */
+    get stream(): MediaStream;
+}
+export {};

package/dist/types/multistream/remoteMediaGroup.d.ts

@@ -0,0 +1,47 @@
+import { RemoteMedia, RemoteVideoResolution } from './remoteMedia';
+import { MediaRequestManager } from './mediaRequestManager';
+import { CSI, ReceiveSlot } from './receiveSlot';
+type Options = {
+    resolution?: RemoteVideoResolution;
+    preferLiveVideo?: boolean;
+};
+export declare class RemoteMediaGroup {
+    private mediaRequestManager;
+    private priority;
+    private options;
+    private unpinnedRemoteMedia;
+    private mediaRequestId?;
+    private pinnedRemoteMedia;
+    constructor(mediaRequestManager: MediaRequestManager, receiveSlots: ReceiveSlot[], priority: number, commitMediaRequest: boolean, options?: Options);
+    /**
+     * Gets the array of remote media elements from the group
+     *
+     * @param {string} filter - 'all' (default) returns both pinned and unpinned
+     * @returns {Array<RemoteMedia>}
+     */
+    getRemoteMedia(filter?: 'all' | 'pinned' | 'unpinned'): RemoteMedia[];
+    /**
+     * Pins a specific remote media instance to a specfic CSI, so the media will
+     * no longer come from active speaker, but from that CSI.
+     * If no CSI is given, the current CSI value is used.
+     *
+     */
+    pin(remoteMedia: RemoteMedia, csi?: CSI): void;
+    /**
+     * Unpins a remote media instance, so that it will again provide media from active speakers
+     *
+     */
+    unpin(remoteMedia: RemoteMedia): void;
+    isPinned(remoteMedia: RemoteMedia): boolean;
+    private sendActiveSpeakerMediaRequest;
+    private cancelActiveSpeakerMediaRequest;
+    /**
+     * Checks if a given RemoteMedia instance belongs to this group.
+     *
+     * @param remoteMedia RemoteMedia instance to check
+     * @param filter controls which remote media from the group to check
+     * @returns true if remote media is found
+     */
+    includes(remoteMedia: RemoteMedia, filter?: 'all' | 'pinned' | 'unpinned'): boolean;
+}
+export {};

package/dist/types/multistream/remoteMediaManager.d.ts

@@ -0,0 +1,277 @@
+import { EventMap } from 'typed-emitter';
+import EventsScope from '../common/events/events-scope';
+import { RemoteMedia, RemoteVideoResolution } from './remoteMedia';
+import { CSI } from './receiveSlot';
+import { ReceiveSlotManager } from './receiveSlotManager';
+import { RemoteMediaGroup } from './remoteMediaGroup';
+import { MediaRequestManager } from './mediaRequestManager';
+export type PaneSize = RemoteVideoResolution;
+export type LayoutId = string;
+export type PaneId = string;
+export type PaneGroupId = string;
+export interface ActiveSpeakerVideoPaneGroup {
+    id: PaneGroupId;
+    numPanes: number;
+    size: PaneSize;
+    priority: number;
+}
+export interface MemberVideoPane {
+    id: PaneId;
+    size: PaneSize;
+    csi?: CSI;
+}
+export interface VideoLayout {
+    screenShareVideo?: {
+        size: PaneSize;
+    };
+    activeSpeakerVideoPaneGroups?: ActiveSpeakerVideoPaneGroup[];
+    memberVideoPanes?: MemberVideoPane[];
+}
+export interface Configuration {
+    audio: {
+        numOfActiveSpeakerStreams: number;
+        numOfScreenShareStreams: number;
+    };
+    video: {
+        preferLiveVideo: boolean;
+        initialLayoutId: LayoutId;
+        layouts: {
+            [key: LayoutId]: VideoLayout;
+        };
+    };
+}
+/**
+ * Default configuration:
+ * - uses 3 audio streams
+ * - prefers active speakers with live video (e.g. are not audio only or video muted) over active speakers without live video
+ * - has a few layouts defined, including 1 that contains remote screen share (ScreenShareView)
+ */
+export declare const DefaultConfiguration: Configuration;
+export declare enum Event {
+    AudioCreated = "AudioCreated",
+    ScreenShareAudioCreated = "ScreenShareAudioCreated",
+    VideoLayoutChanged = "VideoLayoutChanged"
+}
+export interface VideoLayoutChangedEventData {
+    layoutId: LayoutId;
+    activeSpeakerVideoPanes: {
+        [key: PaneGroupId]: RemoteMediaGroup;
+    };
+    memberVideoPanes: {
+        [key: PaneId]: RemoteMedia;
+    };
+    screenShareVideo?: RemoteMedia;
+}
+export interface Events extends EventMap {
+    [Event.AudioCreated]: (audio: RemoteMediaGroup) => void;
+    [Event.ScreenShareAudioCreated]: (screenShareAudio: RemoteMediaGroup) => void;
+    [Event.VideoLayoutChanged]: (data: VideoLayoutChangedEventData) => void;
+}
+/**
+ * A helper class that manages all remote audio/video streams in order to achieve a predefined set of layouts.
+ * It also creates a fixed number of audio streams and these don't change during the meeting.
+ *
+ * Things that RemoteMediaManager does:
+ * - owns the receive slots (creates them when needed, and re-uses them when switching layouts)
+ * - constructs appropriate RemoteMedia and RemoteMediaGroup objects and sends appropriate mediaRequests
+ */
+export declare class RemoteMediaManager extends EventsScope {
+    private config;
+    private started;
+    private receiveSlotManager;
+    private mediaRequestManagers;
+    private currentLayout?;
+    private slots;
+    private media;
+    private receiveSlotAllocations;
+    private currentLayoutId?;
+    /**
+     * Constructor
+     *
+     * @param {ReceiveSlotManager} receiveSlotManager
+     * @param {{audio: MediaRequestManager, video: mediaRequestManagers}} mediaRequestManagers
+     * @param {Configuration} config Configuration describing what video layouts to use during the meeting
+     */
+    constructor(receiveSlotManager: ReceiveSlotManager, mediaRequestManagers: {
+        audio: MediaRequestManager;
+        video: MediaRequestManager;
+        screenShareAudio: MediaRequestManager;
+        screenShareVideo: MediaRequestManager;
+    }, config?: Configuration);
+    /**
+     * Checks if configuration is valid, throws an error if it's not
+     */
+    private checkConfigValidity;
+    /**
+     * Starts the RemoteMediaManager.
+     *
+     * @returns {Promise}
+     */
+    start(): Promise<void>;
+    /**
+     * Releases all the used resources (like allocated receive slots). This function needs
+     * to be called when we leave the meeting, etc.
+     */
+    stop(): void;
+    /**
+     * Returns the total number of main video panes required for a given layout
+     *
+     * @param {VideoLayout} layout
+     * @returns {number}
+     */
+    private getRequiredNumVideoSlotsForLayout;
+    /**
+     * Allocates the maximum number of panes that any of the configured layouts will require.
+     * We do this at the beginning, because it's more efficient (much faster) then allocating receive slots
+     * later, after the SDP exchange was done.
+     */
+    private preallocateVideoReceiveSlots;
+    /**
+     * Changes the layout (triggers Event.VideoLayoutChanged)
+     *
+     * @param {LayoutId} layoutId new layout id
+     * @returns {Promise}
+     */
+    setLayout(layoutId: LayoutId): Promise<void>;
+    /**
+     * Returns the currently selected layout id
+     *
+     * @returns {LayoutId}
+     */
+    getLayoutId(): LayoutId | undefined;
+    /**
+     * sets the preferLiveVideo
+     */
+    setPreferLiveVideo(preferLiveVideo: boolean): void;
+    /**
+     * Sets CSIs for multiple RemoteMedia instances belonging to RemoteMediaGroup.
+     * For each entry in the remoteMediaCsis array:
+     * - if csi is specified, the RemoteMedia instance is pinned to that CSI
+     * - if csi is undefined, the RemoteMedia instance is unpinned
+     */
+    setActiveSpeakerCsis(remoteMediaCsis: {
+        remoteMedia: RemoteMedia;
+        csi?: number;
+    }[]): void;
+    /**
+     * Creates the audio slots
+     */
+    private createAudioMedia;
+    /**
+     * Creates receive slots required for receiving screen share audio and video
+     */
+    private createScreenShareReceiveSlots;
+    /**
+     * Creates RemoteMedia objects for screen share
+     */
+    private createScreenShareAudioMedia;
+    /**
+     * Goes over all receiver-selected slots and keeps only the ones that are required by a given layout,
+     * the rest are all moved to the "unused" list
+     */
+    private trimReceiverSelectedSlots;
+    /**
+     * Releases all the "unused" video slots.
+     */
+    private releaseUnusedVideoSlots;
+    /**
+     * Allocates receive slots to all active speaker video panes
+     * in the current selected layout.
+     *
+     * Allocation tries to keep the same order of the slots between the previous
+     * layout and the new one. Sorting helps making sure that highest priority slots
+     * go in the same order in the new layout.
+     */
+    private allocateSlotsToActiveSpeakerPaneGroups;
+    /**
+     * Allocates receive slots to all receiver selected video panes
+     * in the current selected layout
+     */
+    private allocateSlotsToReceiverSelectedVideoPaneGroups;
+    /**
+     * Ensures that we have enough slots for the current layout.
+     */
+    private refillRequiredSlotsIfNeeded;
+    /**
+     * Move all active speaker slots to "unused"
+     */
+    private trimActiveSpeakerSlots;
+    /**
+     * Logs the state of the receive slots
+     */
+    private logReceieveSlots;
+    /**
+     * Makes sure we have the right number of receive slots created for the current layout
+     * and allocates them to the right video panes / pane groups
+     *
+     * @returns {Promise}
+     */
+    private updateVideoReceiveSlots;
+    /**
+     * Creates new RemoteMedia and RemoteMediaGroup objects for the current layout
+     * and sends the media requests for all of them.
+     */
+    private updateVideoRemoteMediaObjects;
+    /**
+     * Checks if current layout requires a screen share.
+     * If it does, it creates new RemoteMediaGroup object for screen share
+     * and sends the media requests for it.
+     * If it doesn't, it makes sure we clean up any RemoteMediaGroup objects
+     * created earlier for screen share (for previous layout).
+     */
+    private updateScreenShareVideoRemoteMediaObject;
+    /**
+     * Invalidates all remote media objects belonging to currently selected layout
+     */
+    private invalidateCurrentRemoteMedia;
+    /** emits Event.VideoLayoutChanged */
+    private emitVideoLayoutChangedEvent;
+    /**
+     * Sets a new CSI on a given remote media object
+     *
+     * @param {RemoteMedia} remoteMedia remote Media object to modify
+     * @param {CSI} csi new CSI value, can be null if we want to stop receiving media
+     */
+    setRemoteVideoCsi(remoteMedia: RemoteMedia, csi: CSI | null): void;
+    /**
+     * Adds a new member video pane to the currently selected layout.
+     *
+     * Changes to the layout are lost after a layout change.
+     *
+     * @param {MemberVideoPane} newPane
+     * @returns {Promise<RemoteMedia>}
+     */
+    addMemberVideoPane(newPane: MemberVideoPane): Promise<RemoteMedia>;
+    /**
+     * Removes a member video pane from the currently selected layout.
+     *
+     * Changes to the layout are lost after a layout change.
+     *
+     * @param {PaneId} paneId pane id of the pane to remove
+     * @returns {Promise<void>}
+     */
+    removeMemberVideoPane(paneId: PaneId): Promise<void>;
+    /**
+     * Pins an active speaker remote media object to the given CSI value. From that moment
+     * onwards the remote media will only play audio/video from that specific CSI until
+     * unpinActiveSpeakerVideoPane() is called or current layout is changed.
+     *
+     * @param {RemoteMedia} remoteMedia remote media object reference
+     * @param {CSI} csi CSI value to pin to, if undefined, then current CSI value is used
+     */
+    pinActiveSpeakerVideoPane(remoteMedia: RemoteMedia, csi?: CSI): void;
+    /**
+     * Unpins a remote media object from the fixed CSI value it was pinned to.
+     *
+     * @param {RemoteMedia} remoteMedia remote media object reference
+     */
+    unpinActiveSpeakerVideoPane(remoteMedia: RemoteMedia): void;
+    /**
+     * Returns true if a given remote media object belongs to an active speaker group and has been pinned.
+     * Throws an error if the remote media object doesn't belong to any active speaker remote media group.
+     *
+     * @param {RemoteMedia} remoteMedia remote media object
+     * @returns {boolean}
+     */
+    isPinned(remoteMedia: RemoteMedia): boolean;
+}