@livedigital/client 3.28.1 → 3.29.0

package/dist/inversify.factories.d.ts

@@ -1,7 +1,8 @@
 import { interfaces } from 'inversify';
-import { AudioTrackFactory, PeerConsumerFactory, PeerFactory, PeerTrackFactory, VideoTrackFactory } from './types/container';
+import { AudioTrackFactory, AudioTrackProcessorFactory, PeerConsumerFactory, PeerFactory, PeerTrackFactory, VideoTrackFactory } from './types/container';
 export declare function peerTrackFactory(context: interfaces.Context): PeerTrackFactory;
 export declare function peerConsumerFactory(context: interfaces.Context): PeerConsumerFactory;
 export declare function peerFactory(context: interfaces.Context): PeerFactory;
 export declare function audioTrackFactory(context: interfaces.Context): AudioTrackFactory;
 export declare function videoTrackFactory(context: interfaces.Context): VideoTrackFactory;
+export declare function audioTrackProcessorFactory(context: interfaces.Context): AudioTrackProcessorFactory;

package/dist/inversify.tokens.d.ts

@@ -26,6 +26,9 @@ export declare enum TOKEN {
     PeerConsumerFactory = "PeerConsumerFactory",
     AudioTrackFactory = "AudioTrackFactory",
     VideoTrackFactory = "VideoTrackFactory",
+    AudioTrackProcessorFactory = "AudioTrackProcessorFactory",
+    IntegrationsService = "IntegrationsService",
+    ProcessorsCache = "ProcessorsCache",
     StatsHandler = "StatsHandler",
     DataChannelsManager = "DataChannelsManager"
 }

package/dist/types/client.d.ts

@@ -4,6 +4,12 @@ import { LogLevel, LogMessageHandler } from './common';
 import { IssuesHandler, NetworkScoresUpdatedHandler } from './engine';
 import { InitEffectsSDKParams } from './media';
 export declare type ClientParams = {
+    denoiser?: 'rnnoise' | 'asdk';
+    asdk?: {
+        customerId: string;
+        version: '2.3.5';
+        localDir?: string;
+    };
     clientEventEmitter?: EnhancedEventEmitter;
     internalEventEmitter?: EnhancedEventEmitter;
     network?: {

package/dist/types/container.d.ts

@@ -1,4 +1,5 @@
 import Logger from '../engine/Logger';
+import { AudioTrackProcessor } from '../engine/media/streamEffects/audio/AudioTrackProcessor';
 import DefaultAudioTrack from '../engine/media/tracks/DefaultAudioTrack';
 import DefaultVideoTrack from '../engine/media/tracks/DefaultVideoTrack';
 import PeerTrack from '../engine/media/tracks/PeerTrack';
@@ -6,6 +7,7 @@ import Peer from '../engine/Peer';
 import PeerConsumer, { PeerConsumerConstructorParams } from '../engine/PeerConsumer';
 import { CreatePeerParams } from '../engine/Peers';
 import { CreatePeerTrackParams } from '../engine/RemotePeerTracks';
+import { TrackLabel } from './common';
 import { AudioTrackParams, BaseTrackParams } from './media';
 export declare type PeerTrackFactoryParams = CreatePeerTrackParams & {
     onClose: () => void;
@@ -17,3 +19,8 @@ export declare type PeerConsumerFactory = (params: CreatePeerConsumerParams) =>
 export declare type LoggerFactory = (namespace: string) => Logger;
 export declare type AudioTrackFactory = (params: AudioTrackParams) => DefaultAudioTrack;
 export declare type VideoTrackFactory = (params: BaseTrackParams) => DefaultVideoTrack;
+export declare type CreateAudioTrackProcessorParams = {
+    noiseSuppressor?: WebAssembly.WebAssemblyInstantiatedSource;
+    trackLabel: TrackLabel;
+};
+export declare type AudioTrackProcessorFactory = (params: CreateAudioTrackProcessorParams) => AudioTrackProcessor;

package/dist/types/engine.d.ts

@@ -70,6 +70,7 @@ export declare type ClientObserverEvents = {
     [CLIENT_EVENTS.forcedDisconnect]: [];
     [CLIENT_EVENTS.rejectUnauthorized]: [];
     [CLIENT_EVENTS.channelStateInconsistent]: [ChannelStateInconsistentPayload];
+    [CLIENT_EVENTS.denoiserInitializing]: [boolean];
 };
 export declare type InternalObserverEvents = {
     [INTERNAL_CLIENT_EVENTS.trackProduced]: [Track | BaseTrack];

package/dist/types/media.d.ts

@@ -4,14 +4,15 @@ import { AppData, RtpEncodingParameters } from 'mediasoup-client/lib/types';
 import { ParsedOutboundVideoStreamStats, ParsedOutboundAudioStreamStats } from 'webrtc-issue-detector';
 import Logger from '../engine/Logger';
 import Media from '../engine/media';
-import { MyPeer } from '../engine/MyPeer';
-import Network from '../engine/network';
+import { AudioTrackProcessor } from '../engine/media/streamEffects/audio/AudioTrackProcessor';
 import type { Effects } from '../engine/media/streamEffects/video/esdk/TrackProcessor';
 import MediaStreamTrackManager from '../engine/media/tracks/MediaStreamTrackManager';
+import { MyPeer } from '../engine/MyPeer';
+import Network from '../engine/network';
+import SocketIO from '../engine/network/Socket';
 import EnhancedEventEmitter from '../EnhancedEventEmitter';
 import { BaseTrackInfo, EncoderConfig, TrackLabel, TrackOutboundStats, TrackProduceParams, TrackTransformParams } from './common';
 import { InternalObserverEvents } from './engine';
-import SocketIO from '../engine/network/Socket';
 import StatsHandler from '../engine/WebRTCStats/StatsHandler';
 export interface BaseTrackDependenciesParams {
     internalEventEmitter: EnhancedEventEmitter<InternalObserverEvents>;
@@ -66,6 +67,7 @@ export interface TrackWithEffects extends BaseTrack {
     isEffectsProcessing: boolean;
 }
 export interface AudioTrack extends BaseTrack, TrackWithEncodings, TrackWithEffects {
+    prepareTrackProcessor(trackProcessor?: AudioTrackProcessor): void;
     enableNoiseSuppression(): Promise<void>;
     disableNoiseSuppression(): Promise<void>;
     pause(): Promise<void>;
@@ -89,7 +91,6 @@ export interface VideoTrack extends BaseTrack, TrackWithEncodings, TrackWithEffe
 }
 export declare type Track = AudioTrack | VideoTrack;
 export interface AudioTrackParams extends BaseTrackParams {
-    noiseSuppressor?: WebAssembly.WebAssemblyInstantiatedSource;
 }
 export interface MediaTracksFactory {
     createAudioTrack: (params: Omit<AudioTrackParams, 'logger'>) => BaseTrack;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@livedigital/client",
   "author": "vlprojects",
   "license": "MIT",
-  "version": "3.28.1",
+  "version": "3.29.0",
   "private": false,
   "bugs": {
     "url": "https://github.com/vlprojects/livedigital-sdk/issues"
@@ -50,6 +50,7 @@
     "fflate": "^0.8.2",
     "hash-sum": "^2.0.0",
     "inversify": "^6.0.2",
+    "load-script": "^2.0.0",
     "mediasoup-client": "3.7.18",
     "message-batcher": "^0.0.2",
     "qs": "^6.11.0",

package/src/config/ConfigService.ts

@@ -4,11 +4,15 @@ import { LoadBalancerApiClientParams } from '../engine/network/LoadBalancerClien
 import * as client from '../types/client';
 import { InitEffectsSDKParams } from '../types/media';
 
-type ParamsToOmit = 'clientEventEmitter' | 'internalEventEmitter' | 'network' | 'effectsSDKParams';
-
+type ParamsToOmit = 'clientEventEmitter' | 'internalEventEmitter' | 'network' | 'effectsSDKParams' | 'asdk';
 export type ProcessedParams = Required<Omit<client.ClientParams, ParamsToOmit>> & {
   loadbalancer: LoadBalancerApiClientParams,
   effectsSDKParams?: InitEffectsSDKParams,
+  asdk: {
+    customerId: string
+    version: '2.3.5',
+    localDir?: string,
+  },
 };
 
 const loadbalancerDefaults: LoadBalancerApiClientParams = {
@@ -16,6 +20,11 @@ const loadbalancerDefaults: LoadBalancerApiClientParams = {
   timeout: 5000,
 };
 
+const asdkDefaults: client.ClientParams['asdk'] = {
+  customerId: '',
+  version: '2.3.5',
+};
+
 const noop = () => { };
 
 @injectable()
@@ -24,6 +33,8 @@ export default class ConfigService {
 
   constructor(params: client.ClientParams) {
     this.#params = {
+      denoiser: params.denoiser || 'rnnoise',
+      asdk: Object.assign(asdkDefaults, params.asdk || {}),
       loadbalancer: Object.assign(loadbalancerDefaults, params.network?.loadbalancer || {}),
       logLevel: params.logLevel ?? LogLevels.Error,
       sendAnalytics: params.sendAnalytics ?? false,

package/src/constants/events.ts

@@ -38,6 +38,7 @@ export const CLIENT_EVENTS = {
   connectionRestored: 'connection-restored',
   forcedDisconnect: 'forced-disconnect',
   rejectUnauthorized: 'reject-unauthorized',
+  denoiserInitializing: 'denoiser-initializing',
 } as const;
 
 export const TRACK_EVENTS = {

package/src/engine/IntegrationsService.ts

@@ -0,0 +1,155 @@
+import { inject, injectable } from 'inversify';
+import ConfigService from '../config/ConfigService';
+import { loadScriptWithFallback } from '../helpers/loader';
+import { TOKEN } from '../inversify.tokens';
+import { TrackLabel } from '../types/common';
+import { AudioTrackProcessorFactory, LoggerFactory } from '../types/container';
+import Logger from './Logger';
+import { ASDKTrackProcessor } from './media/streamEffects/audio/asdk/ASDKTrackProcessor';
+import WasmModuleCompiler from './media/streamEffects/audio/noiseSuppression/WasmModuleCompiler';
+import { ProcessorsCache } from './media/streamEffects/ProcessorsCache';
+
+export type Integrations = 'asdk' | 'rnnoise'; // later 'esdk' should be added
+export type IntegrationContext = {
+  integrated: boolean,
+  initPromise: Promise<void>,
+};
+
+export interface Integration {
+  type: Integrations,
+  enabled: boolean; // flag to show that integration is requested/enabled through ClientParams
+  isInitialized: boolean;
+  waitForInitialization: Promise<void>;
+}
+
+@injectable()
+export class IntegrationsService {
+  readonly #integrationsStorage: Map<Integrations, IntegrationContext> = new Map();
+
+  readonly #logger: Logger;
+
+  constructor(
+    @inject(TOKEN.Config) private readonly config: ConfigService,
+    @inject(TOKEN.ProcessorsCache) private readonly processorsCache: ProcessorsCache,
+    @inject(TOKEN.AudioTrackProcessorFactory) private readonly audioTrackProcessorFactory: AudioTrackProcessorFactory,
+    @inject(TOKEN.LoggerFactory) loggerFactory: LoggerFactory,
+  ) {
+    this.#logger = loggerFactory('IntegrationsService');
+  }
+
+  init() { // must not be async
+    const denoiser = this.config.get('denoiser');
+    if (denoiser === 'asdk') {
+      this.#logger.info('Start integration of ASDK', {
+        denoiser,
+      });
+
+      const context: IntegrationContext = {
+        integrated: false,
+        initPromise: this.integrateASDK(),
+      };
+
+      this.#integrationsStorage.set('asdk', context);
+    } else if (denoiser === 'rnnoise') {
+      this.#logger.info('Start integration of RNNoise', {
+        denoiser,
+      });
+
+      const context: IntegrationContext = {
+        integrated: false,
+        initPromise: this.integrateRNNoise(),
+      };
+
+      this.#integrationsStorage.set('rnnoise', context);
+    }
+  }
+
+  private async integrateASDK(): Promise<void> {
+    const asdkParams = this.config.get('asdk');
+
+    if (!window.atsvb) {
+      // https://effectssdk.ai/sdk/audio/dev/2.3.5/atsvb-web.js
+      const remoteUrl = `https://effectssdk.ai/sdk/audio/dev/${asdkParams.version}/atsvb-web.js`;
+      const localUrl = asdkParams.localDir ?? `${asdkParams.localDir}/${asdkParams.version}/atsvb-web.js`;
+
+      await loadScriptWithFallback(remoteUrl, localUrl);
+    }
+
+    if (!window.atsvb) {
+      this.#logger.info('Audio Effects SDK is not loaded, skipping initialization', { case: 'initAudioSDK' });
+
+      throw new Error('windows.atsvb is still missing');
+    }
+
+    const processor = this.audioTrackProcessorFactory({
+      trackLabel: TrackLabel.Microphone,
+    }) as ASDKTrackProcessor;
+
+    await processor.init();
+
+    this.processorsCache.add('asdk', TrackLabel.Microphone, processor);
+
+    const context = this.#integrationsStorage.get('asdk');
+
+    if (!context) {
+      throw Error('IntegrationContext is missing for ASDK');
+    }
+
+    context.integrated = true;
+  }
+
+  get audio(): Integration {
+    const denoiser = this.config.get('denoiser');
+
+    if (denoiser === 'asdk') {
+      return this.getASDKState();
+    }
+
+    return this.getRNNoiseState();
+  }
+
+  private getASDKState(): Integration {
+    const asdk = this.#integrationsStorage.get('asdk');
+
+    return {
+      type: 'asdk',
+      enabled: Boolean(asdk),
+      isInitialized: asdk?.integrated ?? false,
+      waitForInitialization: asdk?.initPromise ?? Promise.resolve(),
+    };
+  }
+
+  private getRNNoiseState(): Integration {
+    const rnnoise = this.#integrationsStorage.get('rnnoise');
+
+    return {
+      type: 'rnnoise',
+      enabled: Boolean(rnnoise),
+      isInitialized: rnnoise?.integrated ?? false,
+      waitForInitialization: rnnoise?.initPromise ?? Promise.resolve(),
+    };
+  }
+
+  private async integrateRNNoise(): Promise<void> {
+    const noiseSuppressor = await WasmModuleCompiler.compileModule(this.config.get('staticFilesPath'));
+
+    const processor = this.audioTrackProcessorFactory({
+      trackLabel: TrackLabel.Microphone,
+      noiseSuppressor,
+    });
+
+    this.processorsCache.add('rnnoise', TrackLabel.Microphone, processor);
+
+    const context = this.#integrationsStorage.get('rnnoise');
+
+    if (!context) {
+      throw Error('IntegrationContext is missing for ASDK');
+    }
+
+    context.integrated = true;
+  }
+
+  reset() {
+    this.#integrationsStorage.clear();
+  }
+}

package/src/engine/index.ts

@@ -4,6 +4,7 @@ import { MediaKind, RtpCapabilities } from 'mediasoup-client/lib/RtpParameters';
 import { serializeError } from 'serialize-error';
 import WebRTCIssueDetector from 'webrtc-issue-detector';
 import clientMetaProvider from '../ClientMetaProvider';
+import ConfigService from '../config/ConfigService';
 import { MAX_JOIN_ATTEMPTS, SOCKET_ERROR_CODE_UNAUTHORIZED } from '../constants/common';
 import {
   CHANNEL_EVENTS, CLIENT_EVENTS, INTERNAL_CLIENT_EVENTS, NETWORK_OBSERVER_EVENTS,
@@ -46,8 +47,10 @@ import ChannelStateSynchronizer from './ChannelStateSynchronizer/ChannelStateSyn
 import EventsQueue from './EventsQueue';
 import ChannelEventHandler from './handlers/ChannelEventHandler';
 import MediaSoupEventHandler from './handlers/MediaSoupEventHandler';
+import { IntegrationsService } from './IntegrationsService';
 import Logger from './Logger';
 import Media from './media';
+import { ProcessorsCache } from './media/streamEffects/ProcessorsCache';
 import VideoTrack from './media/tracks/DefaultVideoTrack';
 import { MyPeer } from './MyPeer';
 import Network from './network';
@@ -74,12 +77,17 @@ class Engine {
 
   #isConnectionLost = false;
 
+  #denoiserInitializing: boolean = false;
+
   #transportStatsProvider?: TransportsStatsProvider;
 
   constructor(
+    @inject(TOKEN.Config) private readonly config: ConfigService,
     @inject(TOKEN.CallState) private readonly state: CallState,
     @inject(TOKEN.MyPeer) private readonly myPeer: MyPeer,
     @inject(TOKEN.LoggerFactory) loggerFactory: (namespace: string) => Logger,
+    @inject(TOKEN.IntegrationsService) private readonly integrationsService: IntegrationsService,
+    @inject(TOKEN.ProcessorsCache) private readonly processorsCache: ProcessorsCache,
     @inject(TOKEN.MediaSoupEventHandler) private readonly mediaSoupEventsHandler: MediaSoupEventHandler,
     @inject(TOKEN.ChannelEventHandler) private readonly channelEventsHandler: ChannelEventHandler,
     @inject(TOKEN.ChannelStateSynchronizer) readonly channelStateSynchronizer: ChannelStateSynchronizer,
@@ -112,7 +120,7 @@ class Engine {
     try {
       const { rtpCapabilities } = await this.socket
         .request('router.getRtpCapabilities') as { rtpCapabilities: RtpCapabilities };
-      await this.media.createNoiseSuppressor();
+      this.integrationsService.init();
       await this.media.loadDevice(rtpCapabilities);
 
       this.#logger.info('Supported capabilities', {
@@ -184,6 +192,9 @@ class Engine {
         await this.media.clearTracks();
       }
 
+      await this.processorsCache.reset();
+      this.integrationsService.reset();
+
       this.eventsQueue.removeListener('message');
       this.dataChannelsManager.closeAllDataChannels();
 
@@ -208,46 +219,6 @@ class Engine {
     }
   }
 
-  private async releaseForRejoin(): Promise<void> {
-    if (this.isReleasing) {
-      return;
-    }
-
-    this.isReleasing = true;
-
-    try {
-      this.state.isJoined = false;
-      this.state.reset();
-      this.myPeer.delete();
-      this.webRtcIssueDetector?.stopWatchingNewPeerConnections();
-
-      this.peers.reset();
-
-      await this.network.closeSendTransport();
-      await this.network.closeReceiveTransport();
-
-      this.eventsQueue.removeListener('message');
-      this.dataChannelsManager.closeAllDataChannels();
-
-      this.channelEventsHandler.reset();
-      this.mediaSoupEventsHandler.reset();
-
-      this.removeClientEventEmitterListeners();
-
-      await this.network.reset();
-      this.socket.disconnect();
-      clientMetaProvider.clear();
-      this.#logger.debug('release()', {
-        socketId: this.myPeerId,
-      });
-    } catch (error: unknown) {
-      this.#logger.error('release()', { error });
-      throw new Error('Error release engine');
-    } finally {
-      this.isReleasing = false;
-    }
-  }
-
   private removeClientEventEmitterListeners(): void {
     Array.from(Object.values(INTERNAL_CLIENT_EVENTS)).forEach((x) => this.internalEventEmitter.removeAllListeners(x));
   }
@@ -283,7 +254,7 @@ class Engine {
         actionName: 'joinWithRetry',
         logger: this.#loggerFactory('RetryJoinNode'),
         onError: async () => {
-          await this.releaseForRejoin();
+          await this.release(true);
         },
       });
     } catch (error) {
@@ -353,24 +324,23 @@ class Engine {
         audio: options?.audio,
       });
 
-      track.setLabel(options?.isPreview ? TrackLabel.MicrophonePreview : TrackLabel.Microphone);
+      const trackLabel = options?.isPreview ? TrackLabel.MicrophonePreview : TrackLabel.Microphone;
+
+      track.setLabel(trackLabel);
       track.setStopTrackOnPause(Boolean(options?.stopTrackOnPause));
       if (options?.encoderConfig) {
         track.setEncoderConfig(options.encoderConfig);
       }
 
-      if (track.kind === 'audio' && options?.noiseSuppression) {
-        try {
-          await (track as AudioTrack).enableNoiseSuppression();
-        } catch (error) {
-          this.#logger.warn('Failed to start noise suppression, featured original track', {
-            label: track.getLabel(),
-          });
-        }
+      if (track.kind === 'audio' && track.getLabel() === TrackLabel.Microphone && !this.#denoiserInitializing) {
+        this.media.initDenoiser(track as AudioTrack, options); // must be non-blocking, don't await
       }
 
       this.media.setTrack(track);
-      this.#logger.debug('createMicrophoneAudioTrack()', { options });
+      this.#logger.debug('createMicrophoneAudioTrack()', {
+        options,
+        trackLabel: track.getLabel(),
+      });
       return track as AudioTrack;
     } catch (error) {
       this.#logger.error('createMicrophoneAudioTrack()', { error, options });
@@ -435,10 +405,6 @@ class Engine {
     return this.media.deleteTrack(tracks);
   }
 
-  public get canUseNoiseSuppression(): boolean {
-    return this.media.isNoiseSuppressorLoaded;
-  }
-
   public getNodeActiveStreamsStat(): NodeActiveStreamsStat {
     const node = this.socket.getServerUrl();
     const inboundActiveStreams = this.peers.hosts()

package/src/engine/media/index.ts

@@ -1,13 +1,17 @@
 import { inject, injectable } from 'inversify';
 import { Device } from 'mediasoup-client';
 import { RtpCapabilities, RtpCodecCapability } from 'mediasoup-client/lib/RtpParameters';
-import ConfigService from '../../config/ConfigService';
+import { serializeError } from 'serialize-error';
+import ConfigService, { ProcessedParams } from '../../config/ConfigService';
 import { SCREEN_SHARING_SIMULCAST_ENCODINGS, WEBCAM_SIMULCAST_ENCODINGS } from '../../constants/encodings';
+import { CLIENT_EVENTS } from '../../constants/events';
 import { VIDEO_CONSTRAINS } from '../../constants/videoConstrains';
+import EnhancedEventEmitter from '../../EnhancedEventEmitter';
 import { detectHandlerName } from '../../helpers/media';
 import { TOKEN } from '../../inversify.tokens';
 import {
   CreateCameraVideoTrackOptions,
+  CreateMicrophoneAudioTrackOptions,
   CreateScreenMediaOptions,
   CreateTracksPayload,
   CreateVideoTrackParams,
@@ -17,12 +21,18 @@ import {
 import type { AudioTrackFactory, VideoTrackFactory } from '../../types/container';
 import {
   AudioTrack,
-  BaseTrack, BaseTrackParams, InitEffectsSDKParams, TrackWithEncodings,
+  BaseTrack,
+  BaseTrackParams,
+  InitEffectsSDKParams,
+  TrackWithEncodings,
   VideoTrack,
 } from '../../types/media';
+import { IntegrationsService } from '../IntegrationsService';
 import Logger from '../Logger';
-import WasmModuleCompiler from './streamEffects/audio/noiseSuppression/WasmModuleCompiler';
+import { ProcessorsCache } from './streamEffects/ProcessorsCache';
 import EffectsSDKTrackProcessor from './streamEffects/video/esdk/TrackProcessor';
+import DefaultAudioTrack from './tracks/DefaultAudioTrack';
+import DefaultVideoTrack from './tracks/DefaultVideoTrack';
 import MediaStreamTrackManager from './tracks/MediaStreamTrackManager';
 
 @injectable()
@@ -37,21 +47,28 @@ class Media {
 
   #effectsSDKParams: InitEffectsSDKParams | null = null;
 
-  #noiseSuppressor?: WebAssembly.WebAssemblyInstantiatedSource;
-
   #effectsSDKInitialized = false;
 
   #effectsProcessors = new Map<string, EffectsSDKTrackProcessor>();
 
+  #denoiserInitializing = false;
+
+  #denoiser: ProcessedParams['denoiser'];
+
   constructor(
     @inject(TOKEN.Config) private readonly config: ConfigService,
     @inject(TOKEN.LoggerFactory) private readonly loggerFactory: (namespace: string) => Logger,
     @inject(TOKEN.AudioTrackFactory) private readonly audioTrackFactory: AudioTrackFactory,
+    @inject(TOKEN.ClientEventEmitter) private readonly clientEventEmitter: EnhancedEventEmitter,
+    @inject(TOKEN.IntegrationsService) private readonly integrationsService: IntegrationsService,
+    @inject(TOKEN.ProcessorsCache) private readonly processorsCache: ProcessorsCache,
     @inject(TOKEN.VideoTrackFactory) private readonly videoTrackFactory: VideoTrackFactory,
     @inject(TOKEN.MediaStreamTrackManager) private readonly mediaStreamTrackManager: MediaStreamTrackManager,
   ) {
     const effectsSDKParams = this.config.get('effectsSDKParams');
 
+    this.#denoiser = this.config.get('denoiser');
+
     this.#logger = this.loggerFactory('Media');
     this.#effectsSDKParams = effectsSDKParams || null;
   }
@@ -64,10 +81,6 @@ class Media {
     return this.device;
   }
 
-  get isNoiseSuppressorLoaded(): boolean {
-    return !!this.#noiseSuppressor;
-  }
-
   get effectsSDKInitialized(): boolean {
     return this.#effectsSDKInitialized;
   }
@@ -87,19 +100,6 @@ class Media {
     }
   }
 
-  async createNoiseSuppressor(): Promise<void> {
-    try {
-      if (this.#noiseSuppressor) {
-        this.#logger.warn('createNoiseSuppressor()', { message: 'Noise suppression module already created' });
-        return;
-      }
-
-      this.#noiseSuppressor = await WasmModuleCompiler.compileModule(this.config.get('staticFilesPath'));
-    } catch (error) {
-      this.#logger.warn('createNoiseSuppressor()', { message: 'Can not load wasm module', error });
-    }
-  }
-
   getTrackCodec(track: TrackWithEncodings): RtpCodecCapability | undefined {
     const { rtpCapabilities, rtpCapabilities: { codecs } } = this.mediasoupDevice;
     if (!codecs) {
@@ -117,11 +117,10 @@ class Media {
         constraints,
       };
 
-      let track;
+      let track: DefaultAudioTrack | DefaultVideoTrack;
       if (mediaStreamTrack.kind === 'audio') {
         track = this.audioTrackFactory({
           ...params,
-          noiseSuppressor: this.#noiseSuppressor,
           loggerNamespace: 'AudioTrack',
         });
       } else {
@@ -210,9 +209,9 @@ class Media {
     this.tracks.set(track.getLabel(), track);
   }
 
-  initEffectsSDK(): Promise<boolean> {
+  async initEffectsSDK(): Promise<boolean> {
     if (this.#effectsSDKInitialized) {
-      return Promise.resolve(true);
+      return true;
     }
 
     if (!this.#effectsSDKParams) {
@@ -240,7 +239,7 @@ class Media {
         this.#logger.info('Effects SDK initialized', { case: 'initEffectsSDK' });
         resolve(true);
       } catch (error) {
-        this.#logger.error('Failed to initilize Effects SDK', { error, case: 'initEffectsSDK' });
+        this.#logger.error('Failed to initialize Effects SDK', { error, case: 'initEffectsSDK' });
         reject(error);
       }
     };
@@ -256,6 +255,59 @@ class Media {
     });
   }
 
+  async initDenoiser(track: AudioTrack, options?: CreateMicrophoneAudioTrackOptions) {
+    if (this.#denoiserInitializing) {
+      return;
+    }
+
+    try {
+      this.#denoiserInitializing = true;
+      this.clientEventEmitter.emit(CLIENT_EVENTS.denoiserInitializing, true);
+      await this.integrationsService.audio.waitForInitialization;
+
+      this.#logger.debug('Denoiser initialized, activating', {
+        case: 'Denoiser',
+        type: this.integrationsService.audio.type,
+        trackLabel: track.getLabel(),
+      });
+
+      const audioTrack = track as AudioTrack;
+      const trackProcessor = this.processorsCache.get(this.#denoiser, TrackLabel.Microphone);
+      if (!trackProcessor) {
+        this.#logger.error('No cached trackProcessor found', {
+          case: 'Denoiser',
+          trackLabel: track.getLabel(),
+          type: this.integrationsService.audio.type,
+        });
+
+        return;
+      }
+
+      audioTrack.prepareTrackProcessor(trackProcessor);
+
+      this.#logger.debug('Denoiser trackProcessor set, check if activation is needed', {
+        case: 'Denoiser',
+        type: this.#denoiser,
+        shouldEnableDenoiser: options?.noiseSuppression,
+        trackLabel: track.getLabel(),
+      });
+
+      if (options?.noiseSuppression) {
+        await (track as AudioTrack).enableNoiseSuppression();
+      }
+    } catch (error) {
+      this.#logger.warn('Failed to start noise suppression, featured original track', {
+        case: 'Denoiser',
+        type: this.#denoiser,
+        error: serializeError(error),
+        label: track.getLabel(),
+      });
+    } finally {
+      this.clientEventEmitter.emit(CLIENT_EVENTS.denoiserInitializing, false);
+      this.#denoiserInitializing = false;
+    }
+  }
+
   async createEffectsSDKTrackProcessor(trackLabel?: TrackLabel) {
     if (trackLabel) {
       const processor = this.#effectsProcessors.get(trackLabel);