@stream-io/video-client 1.32.0 → 1.33.0

package/dist/src/rtc/BasePeerConnection.d.ts

@@ -1,20 +1,10 @@
 import type { CallEventListener, Logger } from '../coordinator/connection/types';
 import { CallState } from '../store';
-import { PeerType, TrackType, WebsocketReconnectStrategy } from '../gen/video/sfu/models/models';
+import { PeerType, TrackType } from '../gen/video/sfu/models/models';
 import { StreamSfuClient } from '../StreamSfuClient';
 import { AllSfuEvents, Dispatcher } from './Dispatcher';
 import { StatsTracer, Tracer } from '../stats';
-export type OnReconnectionNeeded = (kind: WebsocketReconnectStrategy, reason: string) => void;
-export type BasePeerConnectionOpts = {
-    sfuClient: StreamSfuClient;
-    state: CallState;
-    connectionConfig?: RTCConfiguration;
-    dispatcher: Dispatcher;
-    onReconnectionNeeded?: OnReconnectionNeeded;
-    tag: string;
-    enableTracing: boolean;
-    iceRestartDelay?: number;
-};
+import { BasePeerConnectionOpts } from './types';
 /**
  * A base class for the `Publisher` and `Subscriber` classes.
  * @internal

package/dist/src/rtc/Publisher.d.ts

@@ -1,8 +1,6 @@
-import { BasePeerConnection, BasePeerConnectionOpts } from './BasePeerConnection';
-import { PublishOption, TrackInfo, TrackType } from '../gen/video/sfu/models/models';
-export type PublisherConstructorOpts = BasePeerConnectionOpts & {
-    publishOptions: PublishOption[];
-};
+import { BasePeerConnection } from './BasePeerConnection';
+import { PublisherConstructorOpts, TrackPublishOptions } from './types';
+import { TrackInfo, TrackType } from '../gen/video/sfu/models/models';
 /**
  * The `Publisher` is responsible for publishing/unpublishing media streams to/from the SFU
  *
@@ -28,8 +26,9 @@ export declare class Publisher extends BasePeerConnection {
      *
      * @param track the track to publish.
      * @param trackType the track type to publish.
+     * @param options the publish options to use.
      */
-    publish: (track: MediaStreamTrack, trackType: TrackType) => Promise<void>;
+    publish: (track: MediaStreamTrack, trackType: TrackType, options?: TrackPublishOptions) => Promise<void>;
     /**
      * Adds a new transceiver carrying the given track to the peer connection.
      */
@@ -38,6 +37,10 @@ export declare class Publisher extends BasePeerConnection {
      * Updates the transceiver with the given track and track type.
      */
     private updateTransceiver;
+    /**
+     * Updates the publish options for the given track type.
+     */
+    private updateAudioPublishOptions;
     /**
      * Synchronizes the current Publisher state with the provided publish options.
      */

package/dist/src/rtc/Subscriber.d.ts

@@ -1,4 +1,5 @@
-import { BasePeerConnection, BasePeerConnectionOpts } from './BasePeerConnection';
+import { BasePeerConnection } from './BasePeerConnection';
+import { BasePeerConnectionOpts } from './types';
 /**
  * A wrapper around the `RTCPeerConnection` that handles the incoming
  * media streams from the SFU.

package/dist/src/rtc/TransceiverCache.d.ts

@@ -1,9 +1,6 @@
 import { PublishOption } from '../gen/video/sfu/models/models';
-import { OptimalVideoLayer } from './videoLayers';
-type TransceiverId = {
-    publishOption: PublishOption;
-    transceiver: RTCRtpTransceiver;
-};
+import type { OptimalVideoLayer } from './layers';
+import type { PublishBundle } from './types';
 export declare class TransceiverCache {
     private readonly cache;
     private readonly layers;
@@ -16,11 +13,15 @@ export declare class TransceiverCache {
     /**
      * Adds a transceiver to the cache.
      */
-    add: (publishOption: PublishOption, transceiver: RTCRtpTransceiver) => void;
+    add: (bundle: PublishBundle) => void;
     /**
      * Gets the transceiver for the given publish option.
      */
-    get: (publishOption: PublishOption) => RTCRtpTransceiver | undefined;
+    get: (publishOption: PublishOption) => PublishBundle | undefined;
+    /**
+     * Updates the cached bundle with the given patch.
+     */
+    update: (publishOption: PublishOption, patch: Partial<PublishBundle>) => void;
     /**
      * Checks if the cache has the given publish option.
      */
@@ -28,11 +29,11 @@ export declare class TransceiverCache {
     /**
      * Finds the first transceiver that satisfies the given predicate.
      */
-    find: (predicate: (item: TransceiverId) => boolean) => TransceiverId | undefined;
+    find: (predicate: (bundle: PublishBundle) => boolean) => PublishBundle | undefined;
     /**
      * Provides all the items in the cache.
      */
-    items: () => TransceiverId[];
+    items: () => PublishBundle[];
     /**
      * Init index of the transceiver in the cache.
      */
@@ -45,7 +46,5 @@ export declare class TransceiverCache {
      * Sets the video layers for the given track.
      */
     setLayers: (publishOption: PublishOption, layers?: OptimalVideoLayer[]) => void;
-    private findTransceiver;
     private findLayer;
 }
-export {};

package/dist/src/rtc/index.d.ts

@@ -4,7 +4,7 @@ export * from './IceTrickleBuffer';
 export * from './Publisher';
 export * from './Subscriber';
 export * from './signal';
-export * from './videoLayers';
 export * from './helpers/sdp';
 export * from './helpers/tracks';
 export * from './helpers/rtcConfiguration';
+export * from './types';

package/dist/src/rtc/{videoLayers.d.ts → layers.d.ts}

@@ -1,9 +1,15 @@
 import { PublishOption, VideoDimension, VideoLayer, VideoQuality } from '../gen/video/sfu/models/models';
+import { TrackPublishOptions } from './types';
 export type OptimalVideoLayer = RTCRtpEncodingParameters & {
     width: number;
     height: number;
     scalabilityMode?: string;
 };
+/**
+ * Prepares the audio layer for the given track.
+ * Based on the provided audio bitrate profile, we apply the appropriate bitrate.
+ */
+export declare const computeAudioLayers: (publishOption: PublishOption, options: TrackPublishOptions) => RTCRtpEncodingParameters[] | undefined;
 /**
  * In SVC, we need to send only one video encoding (layer).
  * this layer will have the additional spatial and temporal layers
@@ -11,7 +17,7 @@ export type OptimalVideoLayer = RTCRtpEncodingParameters & {
  *
  * @param layers the layers to process.
  */
-export declare const toSvcEncodings: (layers: OptimalVideoLayer[] | undefined) => RTCRtpEncodingParameters[] | undefined;
+export declare const toSvcEncodings: (layers: RTCRtpEncodingParameters[] | undefined) => RTCRtpEncodingParameters[] | undefined;
 /**
  * Converts the rid to a video quality.
  */

package/dist/src/rtc/types.d.ts

@@ -0,0 +1,31 @@
+import { AudioBitrateProfile, PublishOption, WebsocketReconnectStrategy } from '../gen/video/sfu/models/models';
+import { StreamSfuClient } from '../StreamSfuClient';
+import { CallState } from '../store';
+import { Dispatcher } from './Dispatcher';
+import type { OptimalVideoLayer } from './layers';
+export type OnReconnectionNeeded = (kind: WebsocketReconnectStrategy, reason: string) => void;
+export type BasePeerConnectionOpts = {
+    sfuClient: StreamSfuClient;
+    state: CallState;
+    connectionConfig?: RTCConfiguration;
+    dispatcher: Dispatcher;
+    onReconnectionNeeded?: OnReconnectionNeeded;
+    tag: string;
+    enableTracing: boolean;
+    iceRestartDelay?: number;
+};
+export type PublisherConstructorOpts = BasePeerConnectionOpts & {
+    publishOptions: PublishOption[];
+};
+export type TrackPublishOptions = {
+    audioBitrateProfile?: AudioBitrateProfile;
+};
+export type PublishBundle = {
+    publishOption: PublishOption;
+    transceiver: RTCRtpTransceiver;
+    options: TrackPublishOptions;
+};
+export type TrackLayersCache = {
+    publishOption: PublishOption;
+    layers: OptimalVideoLayer[];
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-client",
-  "version": "1.32.0",
+  "version": "1.33.0",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",
   "browser": "dist/index.browser.es.js",
@@ -40,8 +40,9 @@
     "@openapitools/openapi-generator-cli": "^2.13.4",
     "@rollup/plugin-replace": "^6.0.2",
     "@rollup/plugin-typescript": "^12.1.2",
-    "@stream-io/audio-filters-web": "^0.4.3",
+    "@stream-io/audio-filters-web": "^0.5.0",
     "@stream-io/node-sdk": "^0.4.24",
+    "@total-typescript/shoehorn": "^0.1.2",
     "@types/sdp-transform": "^2.4.9",
     "@types/ua-parser-js": "^0.7.39",
     "@vitest/coverage-v8": "^3.1.3",

package/src/Call.ts

@@ -8,6 +8,7 @@ import {
   Publisher,
   Subscriber,
   toRtcConfiguration,
+  TrackPublishOptions,
   trackTypeToParticipantStreamKey,
 } from './rtc';
 import {
@@ -1770,9 +1771,14 @@ export class Call {
    *
    * @param mediaStream the media stream to publish.
    * @param trackType the type of the track to announce.
+   * @param options the publish options.
    */
-  publish = async (mediaStream: MediaStream, trackType: TrackType) => {
-    if (!this.sfuClient) throw new Error(`Call not joined yet.`);
+  publish = async (
+    mediaStream: MediaStream,
+    trackType: TrackType,
+    options?: TrackPublishOptions,
+  ) => {
+    if (!this.sfuClient) throw new Error(`Call is not joined yet`);
     // joining is in progress, and we should wait until the client is ready
     await this.sfuClient.joinTask;
 
@@ -1797,15 +1803,16 @@ export class Call {
     }
 
     pushToIfMissing(this.trackPublishOrder, trackType);
-    await this.publisher.publish(track, trackType);
+    await this.publisher.publish(track, trackType, options);
 
     const trackTypes = [trackType];
     if (trackType === TrackType.SCREEN_SHARE) {
       const [audioTrack] = mediaStream.getAudioTracks();
       if (audioTrack) {
-        pushToIfMissing(this.trackPublishOrder, TrackType.SCREEN_SHARE_AUDIO);
-        await this.publisher.publish(audioTrack, TrackType.SCREEN_SHARE_AUDIO);
-        trackTypes.push(TrackType.SCREEN_SHARE_AUDIO);
+        const screenShareAudio = TrackType.SCREEN_SHARE_AUDIO;
+        pushToIfMissing(this.trackPublishOrder, screenShareAudio);
+        await this.publisher.publish(audioTrack, screenShareAudio, options);
+        trackTypes.push(screenShareAudio);
       }
     }
 

package/src/__tests__/Call.publishing.test.ts

@@ -35,7 +35,7 @@ describe('Publishing and Unpublishing tracks', () => {
   describe('Validations', () => {
     it('publishing is not allowed only when call is not joined', async () => {
       const ms = new MediaStream();
-      const err = 'Call not joined yet.';
+      const err = 'Call is not joined yet';
       await expect(call.publish(ms, TrackType.VIDEO)).rejects.toThrowError(err);
       await expect(call.publish(ms, TrackType.AUDIO)).rejects.toThrowError(err);
       await expect(
@@ -140,7 +140,11 @@ describe('Publishing and Unpublishing tracks', () => {
       vi.spyOn(mediaStream, 'getVideoTracks').mockReturnValue([track]);
 
       await call.publish(mediaStream, TrackType.VIDEO);
-      expect(publisher.publish).toHaveBeenCalledWith(track, TrackType.VIDEO);
+      expect(publisher.publish).toHaveBeenCalledWith(
+        track,
+        TrackType.VIDEO,
+        undefined,
+      );
       expect(call['trackPublishOrder']).toEqual([TrackType.VIDEO]);
 
       expect(sfuClient.updateMuteStates).toHaveBeenCalledWith([
@@ -159,7 +163,11 @@ describe('Publishing and Unpublishing tracks', () => {
       vi.spyOn(mediaStream, 'getAudioTracks').mockReturnValue([track]);
 
       await call.publish(mediaStream, TrackType.AUDIO);
-      expect(publisher.publish).toHaveBeenCalledWith(track, TrackType.AUDIO);
+      expect(publisher.publish).toHaveBeenCalledWith(
+        track,
+        TrackType.AUDIO,
+        undefined,
+      );
       expect(call['trackPublishOrder']).toEqual([TrackType.AUDIO]);
 
       expect(sfuClient.updateMuteStates).toHaveBeenCalledWith([
@@ -181,6 +189,7 @@ describe('Publishing and Unpublishing tracks', () => {
       expect(publisher.publish).toHaveBeenCalledWith(
         track,
         TrackType.SCREEN_SHARE,
+        undefined,
       );
       expect(call['trackPublishOrder']).toEqual([TrackType.SCREEN_SHARE]);
 
@@ -205,10 +214,12 @@ describe('Publishing and Unpublishing tracks', () => {
       expect(publisher.publish).toHaveBeenCalledWith(
         videoTrack,
         TrackType.SCREEN_SHARE,
+        undefined,
       );
       expect(publisher.publish).toHaveBeenCalledWith(
         audioTrack,
         TrackType.SCREEN_SHARE_AUDIO,
+        undefined,
       );
       expect(call['trackPublishOrder']).toEqual([
         TrackType.SCREEN_SHARE,

package/src/__tests__/StreamVideoClient.api.test.ts

@@ -25,7 +25,7 @@ const tokenProvider = (userId: string) => {
   };
 };
 
-describe.skip('StreamVideoClient - coordinator API', () => {
+describe('StreamVideoClient - coordinator API', () => {
   let client: StreamVideoClient;
   const user = {
     id: 'sara',

package/src/devices/AudioDeviceManager.ts

@@ -0,0 +1,61 @@
+import { DeviceManager } from './DeviceManager';
+import { AudioDeviceManagerState } from './AudioDeviceManagerState';
+import { AudioBitrateProfile } from '../gen/video/sfu/models/models';
+import { TrackPublishOptions } from '../rtc';
+
+/**
+ * Base class for High Fidelity enabled Device Managers.
+ */
+export abstract class AudioDeviceManager<
+  S extends AudioDeviceManagerState<C>,
+  C = MediaTrackConstraints,
+> extends DeviceManager<S, C> {
+  /**
+   * Sets the audio bitrate profile and stereo mode.
+   */
+  async setAudioBitrateProfile(profile: AudioBitrateProfile) {
+    if (!this.call.state.settings?.audio.hifi_audio_enabled) {
+      throw new Error('High Fidelity audio is not enabled for this call');
+    }
+    this.doSetAudioBitrateProfile(profile);
+    this.state.setAudioBitrateProfile(profile);
+    if (this.enabled) {
+      await this.applySettingsToStream();
+    }
+  }
+
+  /**
+   * Overrides the default `publishStream` method to inject the audio bitrate profile.
+   */
+  protected override publishStream(
+    stream: MediaStream,
+    options?: TrackPublishOptions,
+  ): Promise<void> {
+    return super.publishStream(stream, {
+      audioBitrateProfile: this.state.audioBitrateProfile,
+      ...options,
+    });
+  }
+
+  /**
+   * Applies Device Manager's specific audio profile settings.
+   */
+  protected abstract doSetAudioBitrateProfile(
+    profile: AudioBitrateProfile,
+  ): void;
+}
+
+/**
+ * Prepares a new MediaTrackConstraints set based on the provided arguments.
+ */
+export const createAudioConstraints = (
+  profile: AudioBitrateProfile,
+): MediaTrackConstraints => {
+  const stereo = profile === AudioBitrateProfile.MUSIC_HIGH_QUALITY;
+  return {
+    echoCancellation: !stereo,
+    noiseSuppression: !stereo,
+    autoGainControl: !stereo,
+    channelCount: { ideal: stereo ? 2 : 1 },
+  };
+};

package/src/devices/AudioDeviceManagerState.ts

@@ -0,0 +1,44 @@
+import { BehaviorSubject, distinctUntilChanged, Observable } from 'rxjs';
+import { AudioBitrateProfile } from '../gen/video/sfu/models/models';
+import { DeviceManagerState, TrackDisableMode } from './DeviceManagerState';
+import { RxUtils } from './../store';
+import { BrowserPermission } from './BrowserPermission';
+
+/**
+ * Base state class for High Fidelity enabled device managers.
+ */
+export abstract class AudioDeviceManagerState<C> extends DeviceManagerState<C> {
+  private readonly audioBitrateProfileSubject: BehaviorSubject<AudioBitrateProfile>;
+
+  /** An Observable that emits the current audio bitrate profile. */
+  audioBitrateProfile$: Observable<AudioBitrateProfile>;
+
+  /**
+   * Constructs a new AudioDeviceManagerState instance.
+   */
+  protected constructor(
+    disableMode: TrackDisableMode,
+    permission: BrowserPermission | undefined,
+    profile: AudioBitrateProfile,
+  ) {
+    super(disableMode, permission);
+    this.audioBitrateProfileSubject = new BehaviorSubject(profile);
+    this.audioBitrateProfile$ = this.audioBitrateProfileSubject
+      .asObservable()
+      .pipe(distinctUntilChanged());
+  }
+
+  /**
+   * Returns the current audio bitrate profile.
+   */
+  get audioBitrateProfile() {
+    return RxUtils.getCurrentValue(this.audioBitrateProfile$);
+  }
+
+  /**
+   * Sets the audio bitrate profile and stereo mode.
+   */
+  setAudioBitrateProfile(profile: AudioBitrateProfile) {
+    RxUtils.setCurrentValue(this.audioBitrateProfileSubject, profile);
+  }
+}

package/src/devices/CameraManager.ts

@@ -1,14 +1,14 @@
 import { Observable } from 'rxjs';
 import { Call } from '../Call';
 import { CameraDirection, CameraManagerState } from './CameraManagerState';
-import { InputMediaDeviceManager } from './InputMediaDeviceManager';
+import { DeviceManager } from './DeviceManager';
 import { getVideoDevices, getVideoStream } from './devices';
 import { OwnCapability, VideoSettingsResponse } from '../gen/coordinator';
 import { TrackType } from '../gen/video/sfu/models/models';
 import { isMobile } from '../helpers/compatibility';
 import { isReactNative } from '../helpers/platforms';
 
-export class CameraManager extends InputMediaDeviceManager<CameraManagerState> {
+export class CameraManager extends DeviceManager<CameraManagerState> {
   private targetResolution = {
     width: 1280,
     height: 720,
@@ -152,11 +152,11 @@ export class CameraManager extends InputMediaDeviceManager<CameraManagerState> {
     }
   }
 
-  protected getDevices(): Observable<MediaDeviceInfo[]> {
+  protected override getDevices(): Observable<MediaDeviceInfo[]> {
     return getVideoDevices(this.call.tracer);
   }
 
-  protected getStream(
+  protected override getStream(
     constraints: MediaTrackConstraints,
   ): Promise<MediaStream> {
     constraints.width = this.targetResolution.width;

package/src/devices/CameraManagerState.ts

@@ -1,12 +1,12 @@
-import { BehaviorSubject, distinctUntilChanged, Observable } from 'rxjs';
-import { InputMediaDeviceManagerState } from './InputMediaDeviceManagerState';
+import { BehaviorSubject, distinctUntilChanged } from 'rxjs';
+import { DeviceManagerState } from './DeviceManagerState';
 import { isReactNative } from '../helpers/platforms';
 import { getVideoBrowserPermission } from './devices';
 import { RxUtils } from '../store';
 
 export type CameraDirection = 'front' | 'back' | undefined;
 
-export class CameraManagerState extends InputMediaDeviceManagerState {
+export class CameraManagerState extends DeviceManagerState {
   private directionSubject = new BehaviorSubject<CameraDirection>(undefined);
 
   /**
@@ -14,13 +14,12 @@ export class CameraManagerState extends InputMediaDeviceManagerState {
    * front - means the camera facing the user
    * back - means the camera facing the environment
    */
-  direction$: Observable<CameraDirection>;
+  direction$ = this.directionSubject
+    .asObservable()
+    .pipe(distinctUntilChanged());
 
   constructor() {
     super('stop-tracks', getVideoBrowserPermission());
-    this.direction$ = this.directionSubject
-      .asObservable()
-      .pipe(distinctUntilChanged());
   }
 
   /**
@@ -58,7 +57,9 @@ export class CameraManagerState extends InputMediaDeviceManagerState {
     }
   }
 
-  protected getDeviceIdFromStream(stream: MediaStream): string | undefined {
+  protected override getDeviceIdFromStream(
+    stream: MediaStream,
+  ): string | undefined {
     const [track] = stream.getVideoTracks();
     return track?.getSettings().deviceId;
   }

package/src/devices/{InputMediaDeviceManager.ts → DeviceManager.ts}

@@ -1,8 +1,9 @@
 import { combineLatest, Observable, pairwise } from 'rxjs';
 import { Call } from '../Call';
+import { TrackPublishOptions } from '../rtc';
 import { CallingState } from '../store';
 import { createSubscription } from '../store/rxUtils';
-import { InputMediaDeviceManagerState } from './InputMediaDeviceManagerState';
+import { DeviceManagerState } from './DeviceManagerState';
 import { isMobile } from '../helpers/compatibility';
 import { isReactNative } from '../helpers/platforms';
 import { Logger } from '../coordinator/connection/types';
@@ -20,8 +21,8 @@ import {
   MediaStreamFilterRegistrationResult,
 } from './filters';
 
-export abstract class InputMediaDeviceManager<
-  T extends InputMediaDeviceManagerState<C>,
+export abstract class DeviceManager<
+  S extends DeviceManagerState<C>,
   C = MediaTrackConstraints,
 > {
   /**
@@ -30,7 +31,7 @@ export abstract class InputMediaDeviceManager<
   stopOnLeave = true;
   logger: Logger;
 
-  state: T;
+  state: S;
 
   protected readonly call: Call;
   protected readonly trackType: TrackType;
@@ -43,7 +44,7 @@ export abstract class InputMediaDeviceManager<
     'filterRegistrationConcurrencyTag',
   );
 
-  protected constructor(call: Call, state: T, trackType: TrackType) {
+  protected constructor(call: Call, state: S, trackType: TrackType) {
     this.call = call;
     this.state = state;
     this.trackType = trackType;
@@ -109,7 +110,6 @@ export abstract class InputMediaDeviceManager<
 
   /**
    * Stops or pauses the stream based on state.disableMode
-   * @param {boolean} [forceStop=false] when true, stops the tracks regardless of the state.disableMode
    */
   async disable(options: { forceStop?: boolean }): Promise<void>;
   async disable(forceStop?: boolean): Promise<void>;
@@ -282,8 +282,11 @@ export abstract class InputMediaDeviceManager<
 
   protected abstract getStream(constraints: C): Promise<MediaStream>;
 
-  protected publishStream(stream: MediaStream): Promise<void> {
-    return this.call.publish(stream, this.trackType);
+  protected publishStream(
+    stream: MediaStream,
+    options?: TrackPublishOptions,
+  ): Promise<void> {
+    return this.call.publish(stream, this.trackType, options);
   }
 
   protected stopPublishStream(): Promise<void> {

package/src/devices/{InputMediaDeviceManagerState.ts → DeviceManagerState.ts}

@@ -11,7 +11,7 @@ import { BrowserPermission, BrowserPermissionState } from './BrowserPermission';
 export type InputDeviceStatus = 'enabled' | 'disabled' | undefined;
 export type TrackDisableMode = 'stop-tracks' | 'disable-tracks';
 
-export abstract class InputMediaDeviceManagerState<C = MediaTrackConstraints> {
+export abstract class DeviceManagerState<C = MediaTrackConstraints> {
   protected statusSubject = new BehaviorSubject<InputDeviceStatus>(undefined);
   protected optimisticStatusSubject = new BehaviorSubject<InputDeviceStatus>(
     undefined,
@@ -79,17 +79,20 @@ export abstract class InputMediaDeviceManagerState<C = MediaTrackConstraints> {
    */
   isPromptingPermission$: Observable<boolean>;
 
+  readonly disableMode: TrackDisableMode;
+
   /**
-   * Constructs new InputMediaDeviceManagerState instance.
+   * Constructs a new InputMediaDeviceManagerState instance.
    *
    * @param disableMode the disable mode to use.
    * @param permission the BrowserPermission to use for querying.
    * `undefined` means no permission is required.
    */
   constructor(
-    public readonly disableMode: TrackDisableMode = 'stop-tracks',
-    permission?: BrowserPermission,
+    disableMode: TrackDisableMode,
+    permission: BrowserPermission | undefined,
   ) {
+    this.disableMode = disableMode;
     this.hasBrowserPermission$ = permission
       ? permission.asObservable().pipe(shareReplay(1))
       : of(true);

package/src/devices/MicrophoneManager.ts

@@ -1,11 +1,14 @@
 import { combineLatest, Observable } from 'rxjs';
 import type { INoiseCancellation } from '@stream-io/audio-filters-web';
 import { Call } from '../Call';
-import { InputMediaDeviceManager } from './InputMediaDeviceManager';
+import {
+  AudioDeviceManager,
+  createAudioConstraints,
+} from './AudioDeviceManager';
 import { MicrophoneManagerState } from './MicrophoneManagerState';
-import { TrackDisableMode } from './InputMediaDeviceManagerState';
+import { TrackDisableMode } from './DeviceManagerState';
 import { getAudioDevices, getAudioStream } from './devices';
-import { TrackType } from '../gen/video/sfu/models/models';
+import { AudioBitrateProfile, TrackType } from '../gen/video/sfu/models/models';
 import { createSoundDetector } from '../helpers/sound-detector';
 import { isReactNative } from '../helpers/platforms';
 import {
@@ -21,7 +24,7 @@ import {
 import { RNSpeechDetector } from '../helpers/RNSpeechDetector';
 import { withoutConcurrency } from '../helpers/concurrency';
 
-export class MicrophoneManager extends InputMediaDeviceManager<MicrophoneManagerState> {
+export class MicrophoneManager extends AudioDeviceManager<MicrophoneManagerState> {
   private speakingWhileMutedNotificationEnabled = true;
   private soundDetectorConcurrencyTag = Symbol('soundDetectorConcurrencyTag');
   private soundDetectorCleanup?: Function;
@@ -245,16 +248,33 @@ export class MicrophoneManager extends InputMediaDeviceManager<MicrophoneManager
     }
   }
 
-  protected getDevices(): Observable<MediaDeviceInfo[]> {
+  protected override getDevices(): Observable<MediaDeviceInfo[]> {
     return getAudioDevices(this.call.tracer);
   }
 
-  protected getStream(
+  protected override getStream(
     constraints: MediaTrackConstraints,
   ): Promise<MediaStream> {
     return getAudioStream(constraints, this.call.tracer);
   }
 
+  protected override doSetAudioBitrateProfile(profile: AudioBitrateProfile) {
+    this.setDefaultConstraints({
+      ...this.state.defaultConstraints,
+      ...createAudioConstraints(profile),
+    });
+
+    if (this.noiseCancellation) {
+      const disableAudioProcessing =
+        profile === AudioBitrateProfile.MUSIC_HIGH_QUALITY;
+      if (disableAudioProcessing) {
+        this.noiseCancellation.disable(); // disable for high quality music mode
+      } else {
+        this.noiseCancellation.enable(); // restore it for other modes if available
+      }
+    }
+  }
+
   private async startSpeakingWhileMutedDetection(deviceId?: string) {
     await withoutConcurrency(this.soundDetectorConcurrencyTag, async () => {
       await this.stopSpeakingWhileMutedDetection();