Noise & echo cancellation

# NC
noise_cancellation.NC()

# BVC
noise_cancellation.BVC()

# BVCTelephony
noise_cancellation.BVCTelephony()

import {
  // NC
  NoiseCancellation,

  // BVC
  BackgroundVoiceCancellation,

  // BVCTelephony
  TelephonyBackgroundVoiceCancellation,
} from '@livekit/noise-cancellation-node';

uv add "livekit-plugins-noise-cancellation~=0.2"

pnpm add @livekit/noise-cancellation-node

from livekit.agents import room_io
from livekit.plugins import noise_cancellation

# ...
await session.start(
    # ...,
    room_options=room_io.RoomOptions(
        audio_input=room_io.AudioInputOptions(
            noise_cancellation=noise_cancellation.BVC(),
        ),
    ),
)
# ...

import { BackgroundVoiceCancellation } from '@livekit/noise-cancellation-node';

// ...
await session.start({
  // ...,
  inputOptions: {
    noiseCancellation: BackgroundVoiceCancellation(),
  },
});
// ...

from livekit.rtc import AudioStream
from livekit.plugins import noise_cancellation

stream = AudioStream.from_track(
    track=track,
    noise_cancellation=noise_cancellation.BVC(),
)

import { AudioStream } from '@livekit/rtc-node';
import { BackgroundVoiceCancellation } from '@livekit/noise-cancellation-node';

const stream = new AudioStream(track, {
  noiseCancellation: BackgroundVoiceCancellation(),
});

# QUAIL_L
ai_coustics.audio_enhancement(model=EnhancerModel.QUAIL_L)

# QUAIL_VF_L
ai_coustics.audio_enhancement(model=EnhancerModel.QUAIL_VF_L)

import * as aiCoustics from '@livekit/plugins-ai-coustics';

// QUAIL_L
aiCoustics.audioEnhancement({ model: EnhancerModel.QUAIL_L })

// QUAIL_VF_L
aiCoustics.audioEnhancement({ model: EnhancerModel.QUAIL_VF_L })

uv add "livekit-plugins-ai-coustics"

pnpm add @livekit/plugins-ai-coustics

from livekit.agents import room_io
from livekit.plugins import ai_coustics, EnhancerModel

# ...
await session.start(
    # ...,
    room_options=room_io.RoomOptions(
        audio_input=room_io.AudioInputOptions(
            noise_cancellation=ai_coustics.audio_enhancement(model=EnhancerModel.QUAIL_L),
        ),
    ),
)
# ...

import * as aiCoustics from '@livekit/plugins-ai-coustics';

// ...
await session.start({
  // ...,
  inputOptions: {
    noiseCancellation: aiCoustics.audioEnhancement({ model: "quailL" }),
  },
});
// ...

from livekit.plugins.ai_coustics import audio_enhancement, VAD, EnhancerModel

vad=VAD()
noise_cancellation=audio_enhancement(model=EnhancerModel.QUAIL_L)

import * as aic from '@livekit/plugins-ai-coustics';

vad: aic.vad(),
noiseCancellation: aic.audioEnhancement(),

npm install @livekit/krisp-noise-filter

import { useKrispNoiseFilter } from '@livekit/components-react/krisp';

function MyKrispSetting() {
  const krisp = useKrispNoiseFilter();
  return (
    <input
      type="checkbox"
      onChange={(ev) => krisp.setNoiseFilterEnabled(ev.target.checked)}
      checked={krisp.isNoiseFilterEnabled}
      disabled={krisp.isNoiseFilterPending}
    />
  );
}

import { type LocalAudioTrack, Room, RoomEvent, Track } from 'livekit-client';

const room = new Room();

// We recommend a dynamic import to only load the required resources when you enable the plugin
const { KrispNoiseFilter } = await import('@livekit/krisp-noise-filter');

room.on(RoomEvent.LocalTrackPublished, async (trackPublication) => {
  if (
    trackPublication.source === Track.Source.Microphone &&
    trackPublication.track instanceof LocalAudioTrack
  ) {
    if (!isKrispNoiseFilterSupported()) {
      console.warn('Krisp noise filter is currently not supported on this browser');
      return;
    }
    // Once instantiated, the filter will begin initializing and will download additional resources
    const krispProcessor = KrispNoiseFilter();
    console.log('Enabling LiveKit Krisp noise filter');
    await trackPublication.track.setProcessor(krispProcessor);

    // To enable/disable the noise filter, use setEnabled()
    await krispProcessor.setEnabled(true);

    // To check the current status use:
    // krispProcessor.isEnabled()

    // To stop and dispose of the Krisp processor, simply call:
    // await trackPublication.track.stopProcessor()
  }
});

dependencies {
  implementation "io.livekit:krisp-noise-filter:0.0.10"
}

val krisp = KrispAudioProcessor.getInstance(getApplication())

coroutineScope.launch(Dispatchers.IO) {
    // Only needs to be done once.
    // This should be executed on the background thread to avoid UI freezes.
    krisp.init()
}

// Pass the KrispAudioProcessor into the Room creation
room = LiveKit.create(
    getApplication(),
    overrides = LiveKitOverrides(
        audioOptions = AudioOptions(
            audioProcessorOptions = AudioProcessorOptions(
                capturePostProcessor = krisp,
            )
        ),
    ),
)

// Or to set after Room creation
room.audioProcessingController.setCapturePostProcessing(krisp)

https://github.com/livekit/swift-krisp-noise-filter

.package(url: "https://github.com/livekit/swift-krisp-noise-filter.git", from: "0.0.7"),

import LiveKit
import SwiftUI
import LiveKitKrispNoiseFilter

// Keep this as a global variable or somewhere that won't be deallocated
let krispProcessor = LiveKitKrispNoiseFilter()

struct ContentView: View {
    @StateObject private var room = Room()

    var body: some View {
        MyOtherView()
        .environmentObject(room)
        .onAppear {
            // Attach the processor
            AudioManager.shared.capturePostProcessingDelegate = krispProcessor
            // This must be done before calling `room.connect()`
            room.add(delegate: krispProcessor)

            // You are now ready to connect to the room from this view or any child view
        }
    }
}

npm install @livekit/react-native-krisp-noise-filter

import { KrispNoiseFilter } from '@livekit/react-native-krisp-noise-filter';
import { useLocalParticipant } from '@livekit/components-react';
import { useMemo, useEffect } from 'react';

function MyComponent() {
  let { microphoneTrack } = useLocalParticipant();
  const krisp = useMemo(() => KrispNoiseFilter(), []);

  useEffect(() => {
    const localAudioTrack = microphoneTrack?.audioTrack;
    if (!localAudioTrack) {
      return;
    }
    localAudioTrack?.setProcessor(krisp);
  }, [microphoneTrack, krisp]);
}

dependencies:
  livekit_noise_filter: ^0.1.0

import 'package:livekit_client/livekit_client.dart';
import 'package:livekit_noise_filter/livekit_noise_filter.dart';

// Create the noise filter instance
final liveKitNoiseFilter = LiveKitNoiseFilter();

// Configure room with the noise filter
final room = Room(
  roomOptions: RoomOptions(
    defaultAudioCaptureOptions: AudioCaptureOptions(
      processor: liveKitNoiseFilter,
    ),
  ),
);

// Connect to room and enable microphone
await room.connect(url, token);
await room.localParticipant?.setMicrophoneEnabled(true);

// You can also enable/disable the filter at runtime
// liveKitNoiseFilter.setBypass(true);  // Disables noise cancellation
// liveKitNoiseFilter.setBypass(false); // Enables noise cancellation