@livedigital/client 1.13.0 → 1.13.1

package/dist/types/common.d.ts

@@ -153,3 +153,29 @@ export declare type PayloadOfPublishedMedia = {
     label: TrackLabel;
 };
 export declare type PayloadOfUnpublishedMedia = PayloadOfPublishedMedia;
+export declare type ChangePreferredLayersPayload = PreferredLayersParams & {
+    consumerId: string;
+    spatialLayer: number;
+    temporalLayer: number;
+};
+export declare type CreateVideoTrackParams = {
+    videoTrackOptions: {
+        deviceId?: string;
+        width?: {
+            max?: number;
+            min?: number;
+            ideal?: number;
+        };
+        height?: {
+            max?: number;
+            min?: number;
+            ideal?: number;
+        };
+        frameRate?: {
+            max?: number;
+            min?: number;
+            ideal?: number;
+        };
+    };
+    encoderConfig: VideoEncoderConfig;
+};

package/package.json

@@ -2,7 +2,7 @@
   "name": "@livedigital/client",
   "author": "vlprojects",
   "license": "MIT",
-  "version": "1.13.0",
+  "version": "1.13.1",
   "private": false,
   "bugs": {
     "url": "https://github.com/vlprojects/livedigital-sdk/issues"

package/src/constants/videoConstrains.ts

@@ -1,10 +1,10 @@
 // eslint-disable-next-line import/prefer-default-export
 export const VIDEO_CONSTRAINS = {
-  qvga: { width: { ideal: 320 }, height: { ideal: 240 } },
-  vga: { width: { ideal: 640 }, height: { ideal: 480 } },
+  qvga: { width: 320, height: 240 },
+  vga: { width: 640, height: 480 },
   hd: {
-    width: { ideal: 1280 },
-    height: { ideal: 720 },
+    width: 1280,
+    height: 720,
   },
-  fullhd: { width: { ideal: 1920 }, height: { ideal: 1080 } },
+  fullhd: { width: 1920, height: 1080 },
 };

package/src/engine/Peer.ts

@@ -9,7 +9,9 @@ import {
   ConnectionQuality,
   StartTrackPayload,
   EndTrackPayload,
-  PayloadOfPublishedMedia, PayloadOfUnpublishedMedia,
+  PayloadOfPublishedMedia,
+  PayloadOfUnpublishedMedia,
+  ChangePreferredLayersPayload,
 } from '../types/common';
 import Consumer from './media/Consumer';
 import VideoConsumer from './media/VideoConsumer';
@@ -271,6 +273,13 @@ class Peer {
         spatialLayer,
         temporalLayer,
       });
+
+      this.logger.debug('changeConsumerPreferredLayers()', {
+        peer: this,
+        consumer,
+        spatialLayer,
+        temporalLayer,
+      });
     } catch (err) {
       this.logger.error('changeConsumerPreferredLayers()', {
         peer: this,
@@ -424,6 +433,14 @@ class Peer {
       this.outgoingConnectionQuality = Peer.getConnectionQualityByScore(score);
       this.emitConnectionQuality();
     });
+
+    this.observer.on(MEDIASOUP_EVENTS.consumerChangePreferredLayers, (payload: ChangePreferredLayersPayload) => {
+      const consumer = this.consumers.get(payload.consumerId);
+      if (consumer instanceof VideoConsumer) {
+        consumer.setCurrentTemporalLayer(payload.temporalLayer);
+        consumer.setCurrentSpatialLayer(payload.spatialLayer);
+      }
+    });
   }
 
   private emitConnectionQuality(): void {

package/src/engine/handlers/MediaSoupEventHandler.ts

@@ -71,7 +71,7 @@ class MediaSoupEventHandler {
     });
 
     connection.on(MEDIASOUP_EVENTS.consumerChangePreferredLayers, ({
-      peerId, spatialLayer, temporalLayer,
+      peerId, spatialLayer, temporalLayer, consumerId,
     }: ChangePreferredLayersParams) => {
       const peer = this.engine.peers.find((item) => item.id === peerId);
       if (!peer || peer.isMe) {
@@ -79,6 +79,7 @@ class MediaSoupEventHandler {
       }
 
       peer.observer.safeEmit(MEDIASOUP_EVENTS.consumerChangePreferredLayers, {
+        consumerId,
         spatialLayer,
         temporalLayer,
       });

package/src/engine/index.ts

@@ -1,5 +1,4 @@
 import { RtpCapabilities } from 'mediasoup-client/lib/RtpParameters';
-import { VIDEO_CONSTRAINS } from '../constants/videoConstrains';
 import {
   PeerResponse,
   JoinChannelParams,
@@ -193,32 +192,26 @@ class Engine {
     }
   }
 
-  async createCameraVideoTrack(options?: CreateCameraVideoTrackOptions): Promise<Track | null> {
+  async createCameraVideoTrack(options?: CreateCameraVideoTrackOptions): Promise<Track> {
+    const trackParams = Media.getCameraVideoTrackParams(options);
     try {
       const track = await this.media.createUserMediaTrack({
         audio: false,
-        video: {
-          deviceId: options?.deviceId,
-          frameRate: options?.frameRate || 15,
-          width: options?.width || VIDEO_CONSTRAINS.hd.width,
-          height: options?.height || VIDEO_CONSTRAINS.hd.height,
-        },
+        video: trackParams.videoTrackOptions,
       });
 
       track.setLabel(TrackLabel.Camera);
-      if (options?.encoderConfig) {
-        track.setEncoderConfig(options.encoderConfig);
-      }
+      track.setEncoderConfig(trackParams.encoderConfig);
 
-      this.logger.debug('createCameraVideoTrack()', { options, track });
+      this.logger.debug('createCameraVideoTrack()', { trackParams, track });
       return track;
     } catch (error) {
-      this.logger.error('createCameraVideoTrack()', { error, options });
-      return null;
+      this.logger.error('createCameraVideoTrack()', { error, trackParams });
+      throw new Error(`Can not create camera track: ${error.message}`);
     }
   }
 
-  async createMicrophoneAudioTrack(options?: CreateMicrophoneAudioTrackOptions): Promise<Track | null> {
+  async createMicrophoneAudioTrack(options?: CreateMicrophoneAudioTrackOptions): Promise<Track> {
     try {
       const track = await this.media.createUserMediaTrack({
         video: false,
@@ -236,19 +229,16 @@ class Engine {
       return track;
     } catch (error) {
       this.logger.error('createMicrophoneAudioTrack()', { error, options });
-      return null;
+      throw new Error(`Can not create microphone track: ${error.message}`);
     }
   }
 
-  async createScreenVideoTrack(options?: CreateScreenVideoTrackOptions): Promise<Track | null> {
+  async createScreenVideoTrack(options?: CreateScreenVideoTrackOptions): Promise<Track> {
+    const trackParams = Media.getScreenVideoTrackParams(options);
     try {
       const track = await this.media.createDisplayMediaTrack({
         audio: false,
-        video: {
-          frameRate: options?.frameRate || 30,
-          width: options?.width || VIDEO_CONSTRAINS.fullhd.width,
-          height: options?.height || VIDEO_CONSTRAINS.fullhd.height,
-        },
+        video: trackParams.videoTrackOptions,
       });
 
       track.mediaStreamTrack.addEventListener('ended', () => {
@@ -256,19 +246,17 @@ class Engine {
       });
 
       track.setLabel(TrackLabel.ScreenVideo);
-      if (options?.encoderConfig) {
-        track.setEncoderConfig(options.encoderConfig);
-      }
+      track.setEncoderConfig(trackParams.encoderConfig);
 
-      this.logger.debug('createScreenVideoTrack()', { options, track });
+      this.logger.debug('createScreenVideoTrack()', { trackParams, track });
       return track;
     } catch (error) {
-      this.logger.error('createScreenVideoTrack()', { error, options });
-      return null;
+      this.logger.error('createScreenVideoTrack()', { error, trackParams });
+      throw new Error(`Can not create screen video track: ${error.message}`);
     }
   }
 
-  async createScreenAudioTrack(options?: CreateScreenAudioTrackOptions): Promise<Track | null> {
+  async createScreenAudioTrack(options?: CreateScreenAudioTrackOptions): Promise<Track> {
     try {
       const track = await this.media.createDisplayMediaTrack({
         video: false,
@@ -288,7 +276,7 @@ class Engine {
       return track;
     } catch (error) {
       this.logger.error('createScreenAudioTrack()', { error, options });
-      return null;
+      throw new Error(`Can not create screen audio track: ${error.message}`);
     }
   }
 
@@ -329,7 +317,7 @@ class Engine {
         label: track.getLabel(),
       } as StartTrackPayload);
 
-      this.logger.debug('publish()', { track });
+      this.logger.debug('publish()', { track, encodings, codecOptions });
     });
 
     try {

package/src/engine/media/VideoConsumer.ts

@@ -1,14 +1,22 @@
 import { Consumer as MediasoupConsumer } from 'mediasoup-client/lib/types';
 import { parseScalabilityMode } from 'mediasoup-client';
 import Consumer from './Consumer';
+import Logger from '../Logger';
 
 class VideoConsumer extends Consumer {
   public spatialLayers = 0;
 
   public temporalLayers = 0;
 
+  public currentSpatialLayer = 0;
+
+  public currentTemporalLayer = 0;
+
+  private readonly logger: Logger;
+
   constructor(consumer: MediasoupConsumer) {
     super(consumer);
+    this.logger = new Logger('VideoConsumer');
     this.parseScalabilityMode();
   }
 
@@ -18,8 +26,23 @@ class VideoConsumer extends Consumer {
       const { spatialLayers, temporalLayers } = parseScalabilityMode(scalabilityMode);
       this.spatialLayers = spatialLayers;
       this.temporalLayers = temporalLayers;
+      this.logger.debug('parseScalabilityMode()', {
+        scalabilityMode,
+        spatialLayers,
+        temporalLayers,
+      });
     }
   }
+
+  setCurrentSpatialLayer(currentSpatialLayer: number): void {
+    this.currentSpatialLayer = currentSpatialLayer;
+    this.logger.debug('setCurrentSpatialLayer()', { currentSpatialLayer });
+  }
+
+  setCurrentTemporalLayer(currentTemporalLayer: number): void {
+    this.currentTemporalLayer = currentTemporalLayer;
+    this.logger.debug('setCurrentTemporalLayer()', { currentTemporalLayer });
+  }
 }
 
 export default VideoConsumer;

package/src/engine/media/index.ts

@@ -2,8 +2,10 @@ import { Device } from 'mediasoup-client';
 import { RtpCapabilities, RtpCodecCapability } from 'mediasoup-client/lib/RtpParameters';
 import VideoTrack from './tracks/VideoTrack';
 import AudioTrack from './tracks/AudioTrack';
-import { Track } from '../../types/common';
+import { CreateScreenVideoTrackOptions, CreateVideoTrackParams, Track } from '../../types/common';
 import Logger from '../Logger';
+import { VIDEO_CONSTRAINS } from '../../constants/videoConstrains';
+import { SCREEN_SHARING_SIMULCAST_ENCODINGS, WEBCAM_SIMULCAST_ENCODINGS } from '../../constants/simulcastEncodings';
 
 class Media {
   public isDeviceLoaded = false;
@@ -78,6 +80,33 @@ class Media {
   getAllTracks(): Track[] {
     return Array.from(this.tracks.values());
   }
+
+  static getScreenVideoTrackParams(options?: CreateScreenVideoTrackOptions): CreateVideoTrackParams {
+    return {
+      videoTrackOptions: {
+        frameRate: { ideal: options?.frameRate || 30 },
+        width: { ideal: options?.width || VIDEO_CONSTRAINS.fullhd.width },
+        height: { ideal: options?.height || VIDEO_CONSTRAINS.fullhd.height },
+      },
+      encoderConfig: options?.encoderConfig || {
+        encodings: SCREEN_SHARING_SIMULCAST_ENCODINGS,
+      },
+    };
+  }
+
+  static getCameraVideoTrackParams(options?: CreateScreenVideoTrackOptions): CreateVideoTrackParams {
+    return {
+      videoTrackOptions: {
+        deviceId: options?.deviceId,
+        frameRate: { ideal: options?.frameRate || 30 },
+        width: { ideal: options?.width || VIDEO_CONSTRAINS.hd.width },
+        height: { ideal: options?.height || VIDEO_CONSTRAINS.hd.height },
+      },
+      encoderConfig: options?.encoderConfig || {
+        encodings: WEBCAM_SIMULCAST_ENCODINGS,
+      },
+    };
+  }
 }
 
 export default Media;

package/src/index.ts

@@ -88,19 +88,19 @@ class Client {
     return this.engine.resume(track);
   }
 
-  createCameraVideoTrack(options?: CreateCameraVideoTrackOptions): Promise<Track | null> {
+  createCameraVideoTrack(options?: CreateCameraVideoTrackOptions): Promise<Track> {
     return this.engine.createCameraVideoTrack(options);
   }
 
-  createMicrophoneAudioTrack(options?: CreateMicrophoneAudioTrackOptions): Promise<Track | null> {
+  createMicrophoneAudioTrack(options?: CreateMicrophoneAudioTrackOptions): Promise<Track> {
     return this.engine.createMicrophoneAudioTrack(options);
   }
 
-  createScreenVideoTrack(options?: CreateScreenVideoTrackOptions): Promise<Track | null> {
+  createScreenVideoTrack(options?: CreateScreenVideoTrackOptions): Promise<Track> {
     return this.engine.createScreenVideoTrack(options);
   }
 
-  createScreenAudioTrack(options?: CreateScreenAudioTrackOptions): Promise<Track | null> {
+  createScreenAudioTrack(options?: CreateScreenAudioTrackOptions): Promise<Track> {
     return this.engine.createScreenAudioTrack(options);
   }
 

package/src/types/common.ts

@@ -186,3 +186,19 @@ export type PayloadOfPublishedMedia = {
 };
 
 export type PayloadOfUnpublishedMedia = PayloadOfPublishedMedia;
+
+export type ChangePreferredLayersPayload = PreferredLayersParams & {
+  consumerId: string,
+  spatialLayer: number,
+  temporalLayer: number,
+};
+
+export type CreateVideoTrackParams = {
+  videoTrackOptions: {
+    deviceId?: string,
+    width?: { max?: number, min?: number, ideal?: number };
+    height?: { max?: number, min?: number, ideal?: number };
+    frameRate?: { max?: number, min?: number, ideal?: number };
+  },
+  encoderConfig: VideoEncoderConfig,
+};