@stream-io/video-client 0.7.7 → 0.7.8

package/dist/src/Call.d.ts

@@ -225,6 +225,18 @@ export declare class Call {
      * @param stopTrack if `true` the track will be stopped, else it will be just disabled
      */
     stopPublish: (trackType: TrackType, stopTrack?: boolean) => Promise<void>;
+    /**
+     * Notifies the SFU that a noise cancellation process has started.
+     *
+     * @internal
+     */
+    notifyNoiseCancellationStarting: () => Promise<void | import("@protobuf-ts/runtime-rpc").FinishedUnaryCall<import("./gen/video/sfu/signal_rpc/signal").StartNoiseCancellationRequest, import("./gen/video/sfu/signal_rpc/signal").StartNoiseCancellationResponse> | undefined>;
+    /**
+     * Notifies the SFU that a noise cancellation process has stopped.
+     *
+     * @internal
+     */
+    notifyNoiseCancellationStopped: () => Promise<void | import("@protobuf-ts/runtime-rpc").FinishedUnaryCall<import("./gen/video/sfu/signal_rpc/signal").StopNoiseCancellationRequest, import("./gen/video/sfu/signal_rpc/signal").StopNoiseCancellationResponse> | undefined>;
     /**
      * Update track subscription configuration for one or more participants.
      * You have to create a subscription for each participant for all the different kinds of tracks you want to receive.

package/dist/src/StreamSfuClient.d.ts

@@ -109,6 +109,8 @@ export declare class StreamSfuClient {
     updateMuteState: (trackType: TrackType, muted: boolean) => Promise<FinishedUnaryCall<UpdateMuteStatesRequest, import("./gen/video/sfu/signal_rpc/signal").UpdateMuteStatesResponse>>;
     updateMuteStates: (data: Omit<UpdateMuteStatesRequest, 'sessionId'>) => Promise<FinishedUnaryCall<UpdateMuteStatesRequest, import("./gen/video/sfu/signal_rpc/signal").UpdateMuteStatesResponse>>;
     sendStats: (stats: Omit<SendStatsRequest, 'sessionId'>) => Promise<FinishedUnaryCall<SendStatsRequest, import("./gen/video/sfu/signal_rpc/signal").SendStatsResponse>>;
+    startNoiseCancellation: () => Promise<FinishedUnaryCall<import("./gen/video/sfu/signal_rpc/signal").StartNoiseCancellationRequest, import("./gen/video/sfu/signal_rpc/signal").StartNoiseCancellationResponse>>;
+    stopNoiseCancellation: () => Promise<FinishedUnaryCall<import("./gen/video/sfu/signal_rpc/signal").StopNoiseCancellationRequest, import("./gen/video/sfu/signal_rpc/signal").StopNoiseCancellationResponse>>;
     join: (data: Omit<JoinRequest, 'sessionId' | 'token'>) => Promise<void>;
     send: (message: SfuRequest) => Promise<void>;
     private keepAlive;

package/dist/src/devices/InputMediaDeviceManager.d.ts

@@ -21,7 +21,7 @@ export declare abstract class InputMediaDeviceManager<T extends InputMediaDevice
      */
     stopOnLeave: boolean;
     logger: Logger;
-    private subscriptions;
+    protected subscriptions: Function[];
     private isTrackStoppedDueToTrackEnd;
     private filters;
     protected constructor(call: Call, state: T, trackType: TrackType);

package/dist/src/devices/MicrophoneManager.d.ts

@@ -1,11 +1,28 @@
 import { Observable } from 'rxjs';
+import type { INoiseCancellation } from '@stream-io/audio-filters-web';
 import { Call } from '../Call';
 import { InputMediaDeviceManager } from './InputMediaDeviceManager';
 import { MicrophoneManagerState } from './MicrophoneManagerState';
 export declare class MicrophoneManager extends InputMediaDeviceManager<MicrophoneManagerState> {
     private soundDetectorCleanup?;
     private rnSpeechDetector;
+    private noiseCancellation;
+    private noiseCancellationChangeUnsubscribe;
+    private noiseCancellationRegistration?;
     constructor(call: Call);
+    /**
+     * Enables noise cancellation for the microphone.
+     *
+     * Note: not supported in React Native.
+     * @param noiseCancellation - a noise cancellation instance to use.
+     */
+    enableNoiseCancellation(noiseCancellation: INoiseCancellation): Promise<void>;
+    /**
+     * Disables noise cancellation for the microphone.
+     *
+     * Note: not supported in React Native.
+     */
+    disableNoiseCancellation(): Promise<void>;
     protected getDevices(): Observable<MediaDeviceInfo[]>;
     protected getStream(constraints: MediaTrackConstraints): Promise<MediaStream>;
     protected publishStream(stream: MediaStream): Promise<void>;

package/dist/src/gen/coordinator/index.d.ts

@@ -86,6 +86,12 @@ export interface AudioSettings {
      * @memberof AudioSettings
      */
     mic_default_on: boolean;
+    /**
+     *
+     * @type {NoiseCancellationSettings}
+     * @memberof AudioSettings
+     */
+    noise_cancellation?: NoiseCancellationSettings;
     /**
      *
      * @type {boolean}
@@ -137,6 +143,12 @@ export interface AudioSettingsRequest {
      * @memberof AudioSettingsRequest
      */
     mic_default_on?: boolean;
+    /**
+     *
+     * @type {NoiseCancellationSettingsRequest}
+     * @memberof AudioSettingsRequest
+     */
+    noise_cancellation?: NoiseCancellationSettingsRequest;
     /**
      *
      * @type {boolean}
@@ -467,7 +479,6 @@ export interface CallEndedEvent {
     user?: UserResponse;
 }
 /**
- *
  * @export
  * @interface CallEvent
  */
@@ -2113,7 +2124,7 @@ export interface ClosedCaptionEvent {
 export interface CollectUserFeedbackRequest {
     /**
      *
-     * @type {object}
+     * @type {{ [key:string]: any }}
      * @memberof CollectUserFeedbackRequest
      */
     custom?: {
@@ -3373,6 +3384,50 @@ export interface MuteUsersResponse {
      */
     duration: string;
 }
+/**
+ *
+ * @export
+ * @interface NoiseCancellationSettings
+ */
+export interface NoiseCancellationSettings {
+    /**
+     *
+     * @type {string}
+     * @memberof NoiseCancellationSettings
+     */
+    mode: NoiseCancellationSettingsModeEnum;
+}
+/**
+ * @export
+ */
+export declare const NoiseCancellationSettingsModeEnum: {
+    readonly AVAILABLE: "available";
+    readonly DISABLED: "disabled";
+    readonly AUTO_ON: "auto-on";
+};
+export type NoiseCancellationSettingsModeEnum = (typeof NoiseCancellationSettingsModeEnum)[keyof typeof NoiseCancellationSettingsModeEnum];
+/**
+ *
+ * @export
+ * @interface NoiseCancellationSettingsRequest
+ */
+export interface NoiseCancellationSettingsRequest {
+    /**
+     *
+     * @type {string}
+     * @memberof NoiseCancellationSettingsRequest
+     */
+    mode?: NoiseCancellationSettingsRequestModeEnum;
+}
+/**
+ * @export
+ */
+export declare const NoiseCancellationSettingsRequestModeEnum: {
+    readonly AVAILABLE: "available";
+    readonly DISABLED: "disabled";
+    readonly AUTO_ON: "auto-on";
+};
+export type NoiseCancellationSettingsRequestModeEnum = (typeof NoiseCancellationSettingsRequestModeEnum)[keyof typeof NoiseCancellationSettingsRequestModeEnum];
 /**
  * All possibility of string to use
  * @export
@@ -3381,6 +3436,7 @@ export declare const OwnCapability: {
     readonly BLOCK_USERS: "block-users";
     readonly CREATE_CALL: "create-call";
     readonly CREATE_REACTION: "create-reaction";
+    readonly ENABLE_NOISE_CANCELLATION: "enable-noise-cancellation";
     readonly END_CALL: "end-call";
     readonly JOIN_BACKSTAGE: "join-backstage";
     readonly JOIN_CALL: "join-call";
@@ -5139,6 +5195,44 @@ export interface UserStats {
      */
     session_stats: Array<UserSessionStats>;
 }
+/**
+ *
+ * @export
+ * @interface VideoQuality
+ */
+export interface VideoQuality {
+    /**
+     *
+     * @type {VideoResolution}
+     * @memberof VideoQuality
+     */
+    resolution?: VideoResolution;
+    /**
+     *
+     * @type {string}
+     * @memberof VideoQuality
+     */
+    usage_type?: string;
+}
+/**
+ *
+ * @export
+ * @interface VideoResolution
+ */
+export interface VideoResolution {
+    /**
+     *
+     * @type {number}
+     * @memberof VideoResolution
+     */
+    height: number;
+    /**
+     *
+     * @type {number}
+     * @memberof VideoResolution
+     */
+    width: number;
+}
 /**
  *
  * @export
@@ -5231,38 +5325,6 @@ export declare const VideoSettingsRequestCameraFacingEnum: {
     readonly EXTERNAL: "external";
 };
 export type VideoSettingsRequestCameraFacingEnum = (typeof VideoSettingsRequestCameraFacingEnum)[keyof typeof VideoSettingsRequestCameraFacingEnum];
-/**
- *
- * @export
- * @interface VideoQuality
- */
-export interface VideoQuality {
-    /**
-     *
-     * @type {VideoResolution}
-     * @memberof VideoQuality
-     */
-    resolution: VideoResolution;
-}
-/**
- *
- * @export
- * @interface VideoResolution
- */
-export interface VideoResolution {
-    /**
-     *
-     * @type {number}
-     * @memberof VideoResolution
-     */
-    height: number;
-    /**
-     *
-     * @type {number}
-     * @memberof VideoResolution
-     */
-    width: number;
-}
 /**
  *
  * @export

package/dist/src/gen/video/sfu/signal_rpc/signal.client.d.ts

@@ -1,5 +1,5 @@
 import type { RpcOptions, RpcTransport, ServiceInfo, UnaryCall } from '@protobuf-ts/runtime-rpc';
-import type { ICERestartRequest, ICERestartResponse, ICETrickleResponse, SendAnswerRequest, SendAnswerResponse, SendStatsRequest, SendStatsResponse, SetPublisherRequest, SetPublisherResponse, UpdateMuteStatesRequest, UpdateMuteStatesResponse, UpdateSubscriptionsRequest, UpdateSubscriptionsResponse } from './signal';
+import type { ICERestartRequest, ICERestartResponse, ICETrickleResponse, SendAnswerRequest, SendAnswerResponse, SendStatsRequest, SendStatsResponse, SetPublisherRequest, SetPublisherResponse, StartNoiseCancellationRequest, StartNoiseCancellationResponse, StopNoiseCancellationRequest, StopNoiseCancellationResponse, UpdateMuteStatesRequest, UpdateMuteStatesResponse, UpdateSubscriptionsRequest, UpdateSubscriptionsResponse } from './signal';
 import type { ICETrickle } from '../models/models';
 /**
  * @generated from protobuf service stream.video.sfu.signal.SignalServer
@@ -42,6 +42,14 @@ export interface ISignalServerClient {
      * @generated from protobuf rpc: SendStats(stream.video.sfu.signal.SendStatsRequest) returns (stream.video.sfu.signal.SendStatsResponse);
      */
     sendStats(input: SendStatsRequest, options?: RpcOptions): UnaryCall<SendStatsRequest, SendStatsResponse>;
+    /**
+     * @generated from protobuf rpc: StartNoiseCancellation(stream.video.sfu.signal.StartNoiseCancellationRequest) returns (stream.video.sfu.signal.StartNoiseCancellationResponse);
+     */
+    startNoiseCancellation(input: StartNoiseCancellationRequest, options?: RpcOptions): UnaryCall<StartNoiseCancellationRequest, StartNoiseCancellationResponse>;
+    /**
+     * @generated from protobuf rpc: StopNoiseCancellation(stream.video.sfu.signal.StopNoiseCancellationRequest) returns (stream.video.sfu.signal.StopNoiseCancellationResponse);
+     */
+    stopNoiseCancellation(input: StopNoiseCancellationRequest, options?: RpcOptions): UnaryCall<StopNoiseCancellationRequest, StopNoiseCancellationResponse>;
 }
 /**
  * @generated from protobuf service stream.video.sfu.signal.SignalServer
@@ -91,4 +99,12 @@ export declare class SignalServerClient implements ISignalServerClient, ServiceI
      * @generated from protobuf rpc: SendStats(stream.video.sfu.signal.SendStatsRequest) returns (stream.video.sfu.signal.SendStatsResponse);
      */
     sendStats(input: SendStatsRequest, options?: RpcOptions): UnaryCall<SendStatsRequest, SendStatsResponse>;
+    /**
+     * @generated from protobuf rpc: StartNoiseCancellation(stream.video.sfu.signal.StartNoiseCancellationRequest) returns (stream.video.sfu.signal.StartNoiseCancellationResponse);
+     */
+    startNoiseCancellation(input: StartNoiseCancellationRequest, options?: RpcOptions): UnaryCall<StartNoiseCancellationRequest, StartNoiseCancellationResponse>;
+    /**
+     * @generated from protobuf rpc: StopNoiseCancellation(stream.video.sfu.signal.StopNoiseCancellationRequest) returns (stream.video.sfu.signal.StopNoiseCancellationResponse);
+     */
+    stopNoiseCancellation(input: StopNoiseCancellationRequest, options?: RpcOptions): UnaryCall<StopNoiseCancellationRequest, StopNoiseCancellationResponse>;
 }

package/dist/src/gen/video/sfu/signal_rpc/signal.d.ts

@@ -2,6 +2,42 @@ import { Error, PeerType, TrackInfo, TrackType, VideoDimension } from '../models
 import { ServiceType } from '@protobuf-ts/runtime-rpc';
 import type { BinaryReadOptions, BinaryWriteOptions, IBinaryReader, IBinaryWriter, PartialMessage } from '@protobuf-ts/runtime';
 import { MessageType } from '@protobuf-ts/runtime';
+/**
+ * @generated from protobuf message stream.video.sfu.signal.StartNoiseCancellationRequest
+ */
+export interface StartNoiseCancellationRequest {
+    /**
+     * @generated from protobuf field: string session_id = 1;
+     */
+    sessionId: string;
+}
+/**
+ * @generated from protobuf message stream.video.sfu.signal.StartNoiseCancellationResponse
+ */
+export interface StartNoiseCancellationResponse {
+    /**
+     * @generated from protobuf field: stream.video.sfu.models.Error error = 1;
+     */
+    error?: Error;
+}
+/**
+ * @generated from protobuf message stream.video.sfu.signal.StopNoiseCancellationRequest
+ */
+export interface StopNoiseCancellationRequest {
+    /**
+     * @generated from protobuf field: string session_id = 1;
+     */
+    sessionId: string;
+}
+/**
+ * @generated from protobuf message stream.video.sfu.signal.StopNoiseCancellationResponse
+ */
+export interface StopNoiseCancellationResponse {
+    /**
+     * @generated from protobuf field: stream.video.sfu.models.Error error = 1;
+     */
+    error?: Error;
+}
 /**
  * @generated from protobuf message stream.video.sfu.signal.SendStatsRequest
  */
@@ -235,6 +271,46 @@ export interface SetPublisherResponse {
      */
     error?: Error;
 }
+declare class StartNoiseCancellationRequest$Type extends MessageType<StartNoiseCancellationRequest> {
+    constructor();
+    create(value?: PartialMessage<StartNoiseCancellationRequest>): StartNoiseCancellationRequest;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: StartNoiseCancellationRequest): StartNoiseCancellationRequest;
+    internalBinaryWrite(message: StartNoiseCancellationRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.signal.StartNoiseCancellationRequest
+ */
+export declare const StartNoiseCancellationRequest: StartNoiseCancellationRequest$Type;
+declare class StartNoiseCancellationResponse$Type extends MessageType<StartNoiseCancellationResponse> {
+    constructor();
+    create(value?: PartialMessage<StartNoiseCancellationResponse>): StartNoiseCancellationResponse;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: StartNoiseCancellationResponse): StartNoiseCancellationResponse;
+    internalBinaryWrite(message: StartNoiseCancellationResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.signal.StartNoiseCancellationResponse
+ */
+export declare const StartNoiseCancellationResponse: StartNoiseCancellationResponse$Type;
+declare class StopNoiseCancellationRequest$Type extends MessageType<StopNoiseCancellationRequest> {
+    constructor();
+    create(value?: PartialMessage<StopNoiseCancellationRequest>): StopNoiseCancellationRequest;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: StopNoiseCancellationRequest): StopNoiseCancellationRequest;
+    internalBinaryWrite(message: StopNoiseCancellationRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.signal.StopNoiseCancellationRequest
+ */
+export declare const StopNoiseCancellationRequest: StopNoiseCancellationRequest$Type;
+declare class StopNoiseCancellationResponse$Type extends MessageType<StopNoiseCancellationResponse> {
+    constructor();
+    create(value?: PartialMessage<StopNoiseCancellationResponse>): StopNoiseCancellationResponse;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: StopNoiseCancellationResponse): StopNoiseCancellationResponse;
+    internalBinaryWrite(message: StopNoiseCancellationResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.signal.StopNoiseCancellationResponse
+ */
+export declare const StopNoiseCancellationResponse: StopNoiseCancellationResponse$Type;
 declare class SendStatsRequest$Type extends MessageType<SendStatsRequest> {
     constructor();
     create(value?: PartialMessage<SendStatsRequest>): SendStatsRequest;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-client",
-  "version": "0.7.7",
+  "version": "0.7.8",
   "packageManager": "yarn@3.2.4",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",
@@ -28,9 +28,9 @@
     "CHANGELOG.md"
   ],
   "dependencies": {
-    "@protobuf-ts/runtime": "^2.9.3",
-    "@protobuf-ts/runtime-rpc": "^2.9.3",
-    "@protobuf-ts/twirp-transport": "^2.9.3",
+    "@protobuf-ts/runtime": "^2.9.4",
+    "@protobuf-ts/runtime-rpc": "^2.9.4",
+    "@protobuf-ts/twirp-transport": "^2.9.4",
     "@types/ws": "^8.5.7",
     "axios": "^1.6.0",
     "base64-js": "^1.5.1",
@@ -42,9 +42,10 @@
     "ws": "^8.14.2"
   },
   "devDependencies": {
-    "@openapitools/openapi-generator-cli": "^2.7.0",
+    "@openapitools/openapi-generator-cli": "^2.13.4",
     "@rollup/plugin-replace": "^5.0.5",
     "@rollup/plugin-typescript": "^11.1.6",
+    "@stream-io/audio-filters-web": "workspace:^",
     "@stream-io/node-sdk": "^0.1.12",
     "@types/sdp-transform": "^2.4.7",
     "@types/ua-parser-js": "^0.7.37",

package/src/Call.ts

@@ -1308,6 +1308,28 @@ export class Call {
     await this.publisher?.unpublishStream(trackType, stopTrack);
   };
 
+  /**
+   * Notifies the SFU that a noise cancellation process has started.
+   *
+   * @internal
+   */
+  notifyNoiseCancellationStarting = async () => {
+    return this.sfuClient?.startNoiseCancellation().catch((err) => {
+      this.logger('warn', 'Failed to notify start of noise cancellation', err);
+    });
+  };
+
+  /**
+   * Notifies the SFU that a noise cancellation process has stopped.
+   *
+   * @internal
+   */
+  notifyNoiseCancellationStopped = async () => {
+    return this.sfuClient?.stopNoiseCancellation().catch((err) => {
+      this.logger('warn', 'Failed to notify stop of noise cancellation', err);
+    });
+  };
+
   /**
    * Update track subscription configuration for one or more participants.
    * You have to create a subscription for each participant for all the different kinds of tracks you want to receive.

package/src/StreamSfuClient.ts

@@ -310,6 +310,26 @@ export class StreamSfuClient {
     );
   };
 
+  startNoiseCancellation = async () => {
+    return retryable(
+      () =>
+        this.rpc.startNoiseCancellation({
+          sessionId: this.sessionId,
+        }),
+      this.logger,
+    );
+  };
+
+  stopNoiseCancellation = async () => {
+    return retryable(
+      () =>
+        this.rpc.stopNoiseCancellation({
+          sessionId: this.sessionId,
+        }),
+      this.logger,
+    );
+  };
+
   join = async (data: Omit<JoinRequest, 'sessionId' | 'token'>) => {
     const joinRequest = JoinRequest.create({
       ...data,

package/src/devices/InputMediaDeviceManager.ts

@@ -28,7 +28,8 @@ export abstract class InputMediaDeviceManager<
    */
   stopOnLeave = true;
   logger: Logger;
-  private subscriptions: Function[] = [];
+
+  protected subscriptions: Function[] = [];
   private isTrackStoppedDueToTrackEnd = false;
   private filters: MediaStreamFilter[] = [];
 

package/src/devices/MicrophoneManager.ts

@@ -1,4 +1,5 @@
 import { combineLatest, Observable } from 'rxjs';
+import type { INoiseCancellation } from '@stream-io/audio-filters-web';
 import { Call } from '../Call';
 import { InputMediaDeviceManager } from './InputMediaDeviceManager';
 import { MicrophoneManagerState } from './MicrophoneManagerState';
@@ -6,13 +7,20 @@ import { getAudioDevices, getAudioStream } from './devices';
 import { TrackType } from '../gen/video/sfu/models/models';
 import { createSoundDetector } from '../helpers/sound-detector';
 import { isReactNative } from '../helpers/platforms';
-import { OwnCapability } from '../gen/coordinator';
+import {
+  NoiseCancellationSettingsModeEnum,
+  OwnCapability,
+} from '../gen/coordinator';
 import { CallingState } from '../store';
+import { createSubscription } from '../store/rxUtils';
 import { RNSpeechDetector } from '../helpers/RNSpeechDetector';
 
 export class MicrophoneManager extends InputMediaDeviceManager<MicrophoneManagerState> {
   private soundDetectorCleanup?: Function;
   private rnSpeechDetector: RNSpeechDetector | undefined;
+  private noiseCancellation: INoiseCancellation | undefined;
+  private noiseCancellationChangeUnsubscribe: (() => void) | undefined;
+  private noiseCancellationRegistration?: Promise<() => Promise<void>>;
 
   constructor(call: Call) {
     super(call, new MicrophoneManagerState(), TrackType.AUDIO);
@@ -39,6 +47,120 @@ export class MicrophoneManager extends InputMediaDeviceManager<MicrophoneManager
         await this.stopSpeakingWhileMutedDetection();
       }
     });
+
+    this.subscriptions.push(
+      createSubscription(this.call.state.callingState$, (callingState) => {
+        // do nothing when noise filtering isn't turned on
+        if (!this.noiseCancellationRegistration || !this.noiseCancellation)
+          return;
+
+        const autoOn =
+          this.call.state.settings?.audio.noise_cancellation?.mode ===
+          NoiseCancellationSettingsModeEnum.AUTO_ON;
+
+        if (autoOn && callingState === CallingState.JOINED) {
+          this.noiseCancellationRegistration
+            .then(() => this.noiseCancellation?.enable())
+            .catch((err) => {
+              this.logger('warn', `Failed to enable noise cancellation`, err);
+              return this.call.notifyNoiseCancellationStopped();
+            });
+        } else if (callingState === CallingState.LEFT) {
+          this.noiseCancellationRegistration
+            .then(() => this.noiseCancellation?.disable())
+            .catch((err) => {
+              this.logger('warn', `Failed to disable noise cancellation`, err);
+            });
+        }
+      }),
+    );
+  }
+
+  /**
+   * Enables noise cancellation for the microphone.
+   *
+   * Note: not supported in React Native.
+   * @param noiseCancellation - a noise cancellation instance to use.
+   */
+  async enableNoiseCancellation(noiseCancellation: INoiseCancellation) {
+    if (isReactNative()) {
+      throw new Error('Noise cancellation is not supported in React Native');
+    }
+
+    const { ownCapabilities, settings } = this.call.state;
+    const hasNoiseCancellationCapability = ownCapabilities.includes(
+      OwnCapability.ENABLE_NOISE_CANCELLATION,
+    );
+    if (!hasNoiseCancellationCapability) {
+      throw new Error('Noise cancellation is not available.');
+    }
+    const noiseCancellationSettings = settings?.audio.noise_cancellation;
+    if (
+      !noiseCancellationSettings ||
+      noiseCancellationSettings.mode ===
+        NoiseCancellationSettingsModeEnum.DISABLED
+    ) {
+      throw new Error('Noise cancellation is disabled for this call type.');
+    }
+    try {
+      this.noiseCancellation = noiseCancellation;
+
+      // listen for change events and notify the SFU
+      this.noiseCancellationChangeUnsubscribe = this.noiseCancellation.on(
+        'change',
+        (enabled: boolean) => {
+          if (enabled) {
+            this.call.notifyNoiseCancellationStarting().catch((err) => {
+              this.logger('warn', `notifyNoiseCancellationStart failed`, err);
+            });
+          } else {
+            this.call.notifyNoiseCancellationStopped().catch((err) => {
+              this.logger('warn', `notifyNoiseCancellationStop failed`, err);
+            });
+          }
+        },
+      );
+
+      this.noiseCancellationRegistration = this.registerFilter(
+        noiseCancellation.toFilter(),
+      );
+      await this.noiseCancellationRegistration;
+
+      // handles an edge case where a noise cancellation is enabled after
+      // the participant as joined the call -> we immediately enable NC
+      if (
+        noiseCancellationSettings.mode ===
+          NoiseCancellationSettingsModeEnum.AUTO_ON &&
+        this.call.state.callingState === CallingState.JOINED
+      ) {
+        noiseCancellation.enable();
+      }
+    } catch (e) {
+      this.logger('warn', 'Failed to enable noise cancellation', e);
+      await this.disableNoiseCancellation().catch((err) => {
+        this.logger('warn', 'Failed to disable noise cancellation', err);
+      });
+    }
+  }
+
+  /**
+   * Disables noise cancellation for the microphone.
+   *
+   * Note: not supported in React Native.
+   */
+  async disableNoiseCancellation() {
+    if (isReactNative()) {
+      throw new Error('Noise cancellation is not supported in React Native');
+    }
+    await this.noiseCancellationRegistration
+      ?.then((unregister) => unregister())
+      .then(() => this.noiseCancellation?.disable())
+      .then(() => this.noiseCancellationChangeUnsubscribe?.())
+      .catch((err) => {
+        this.logger('warn', 'Failed to unregister noise cancellation', err);
+      });
+
+    await this.call.notifyNoiseCancellationStopped();
   }
 
   protected getDevices(): Observable<MediaDeviceInfo[]> {