@livekit/track-processors 0.6.1 → 0.7.2

package/dist/index.mjs

@@ -26,12 +26,68 @@ function createCanvas(width, height) {
   return canvas;
 }
 
+// src/logger.ts
+import { getLogger as clientGetLogger } from "livekit-client";
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["trace"] = 0] = "trace";
+  LogLevel2[LogLevel2["debug"] = 1] = "debug";
+  LogLevel2[LogLevel2["info"] = 2] = "info";
+  LogLevel2[LogLevel2["warn"] = 3] = "warn";
+  LogLevel2[LogLevel2["error"] = 4] = "error";
+  LogLevel2[LogLevel2["silent"] = 5] = "silent";
+  return LogLevel2;
+})(LogLevel || {});
+var LoggerNames = /* @__PURE__ */ ((LoggerNames2) => {
+  LoggerNames2["ProcessorWrapper"] = "livekit-processor-wrapper";
+  LoggerNames2["BackgroundProcessor"] = "livekit-background-processor";
+  LoggerNames2["WebGl"] = "livekit-track-processor-web-gl";
+  return LoggerNames2;
+})(LoggerNames || {});
+var livekitLogger = getLogger("livekit");
+var livekitLoggers = Object.values(LoggerNames).map((name) => getLogger(name));
+livekitLogger.setDefaultLevel(2 /* info */);
+function getLogger(name) {
+  return clientGetLogger(name);
+}
+function setLogLevel(level, loggerName) {
+  if (loggerName) {
+    getLogger(loggerName).setLevel(level);
+  } else {
+    for (const logger of livekitLoggers) {
+      logger.setLevel(level);
+    }
+  }
+}
+function setLogExtension(extension, logger) {
+  const loggers = logger ? [logger] : livekitLoggers;
+  loggers.forEach((logR) => {
+    const originalFactory = logR.methodFactory;
+    logR.methodFactory = (methodName, configLevel, loggerName) => {
+      const rawMethod = originalFactory(methodName, configLevel, loggerName);
+      const logLevel = LogLevel[methodName];
+      const needLog = logLevel >= configLevel && logLevel < 5 /* silent */;
+      return (msg, context) => {
+        if (context)
+          rawMethod(msg, context);
+        else
+          rawMethod(msg);
+        if (needLog) {
+          extension(logLevel, msg, context);
+        }
+      };
+    };
+    logR.setLevel(logR.getLevel());
+  });
+}
+
 // src/ProcessorWrapper.ts
 var ProcessorWrapper = class _ProcessorWrapper {
   constructor(transformer, name, options = {}) {
     // For tracking whether we're using the stream API fallback
     this.useStreamFallback = false;
     this.processingEnabled = false;
+    this.log = getLogger("livekit-processor-wrapper" /* ProcessorWrapper */);
+    this.lifecycleState = "idle";
     var _a;
     this.name = name;
     this.transformer = transformer;
@@ -92,6 +148,8 @@ var ProcessorWrapper = class _ProcessorWrapper {
     }
   }
   async init(opts) {
+    this.log.debug("Init called");
+    this.lifecycleState = "initializing";
     await this.setup(opts);
     if (!this.canvas) {
       throw new TypeError("Expected canvas to be defined after setup");
@@ -105,6 +163,7 @@ var ProcessorWrapper = class _ProcessorWrapper {
     } else {
       this.initStreamProcessorPath();
     }
+    this.lifecycleState = "running";
   }
   initStreamProcessorPath() {
     if (!this.processor || !this.trackGenerator) {
@@ -114,14 +173,15 @@ var ProcessorWrapper = class _ProcessorWrapper {
     }
     const readableStream = this.processor.readable;
     const pipedStream = readableStream.pipeThrough(this.transformer.transformer);
-    const symbol = Symbol("stream");
-    this.symbol = symbol;
-    pipedStream.pipeTo(this.trackGenerator.writable).then(() => this.destroy(symbol)).catch((e) => {
+    pipedStream.pipeTo(this.trackGenerator.writable).then(() => this.handleMediaExhausted()).catch((e) => {
       if (e instanceof DOMException && e.name === "AbortError") {
-        console.log("stream processor path aborted");
+        this.log.log("stream processor path aborted");
+      } else if (e instanceof DOMException && e.name === "InvalidStateError" && e.message === "Stream closed") {
+        this.log.log("stream processor underlying stream closed");
+        this.handleMediaExhausted();
       } else {
-        console.error("error when trying to pipe", e);
-        this.destroy(symbol);
+        this.log.error("error when trying to pipe", e);
+        this.destroy();
       }
     });
     this.processedTrack = this.trackGenerator;
@@ -154,7 +214,7 @@ var ProcessorWrapper = class _ProcessorWrapper {
       try {
         this.transformer.transform(frame, controller);
       } catch (e) {
-        console.error("Error in transform:", e);
+        this.log.error("Error in transform:", e);
         frame.close();
       }
     };
@@ -162,6 +222,7 @@ var ProcessorWrapper = class _ProcessorWrapper {
   }
   startRenderLoop() {
     if (!this.sourceDummy || !(this.sourceDummy instanceof HTMLVideoElement)) {
+      this.handleMediaExhausted();
       return;
     }
     let lastVideoTimestamp = -1;
@@ -175,11 +236,14 @@ var ProcessorWrapper = class _ProcessorWrapper {
     let lastFpsLog = 0;
     const renderLoop = () => {
       if (!this.processingEnabled || !this.sourceDummy || !(this.sourceDummy instanceof HTMLVideoElement)) {
+        this.handleMediaExhausted();
         return;
       }
       if (this.sourceDummy.paused) {
-        console.warn("Video is paused, trying to play");
-        this.sourceDummy.play();
+        this.log.warn("Video is paused, trying to play");
+        this.sourceDummy.play().then(() => {
+          this.animationFrameId = requestAnimationFrame(renderLoop);
+        });
         return;
       }
       const videoTime = videoElement.currentTime;
@@ -198,7 +262,7 @@ var ProcessorWrapper = class _ProcessorWrapper {
             estimatedVideoFps = 1e3 / avgFrameTime;
             const isDevelopment = typeof window !== "undefined" && window.location.hostname === "localhost" || window.location.hostname === "127.0.0.1";
             if (isDevelopment && now - lastFpsLog > 5e3) {
-              console.debug(
+              this.log.debug(
                 `[${this.name}] Estimated video FPS: ${estimatedVideoFps.toFixed(
                   1
                 )}, Processing at: ${(frameCount / 5).toFixed(1)} FPS`
@@ -225,7 +289,7 @@ var ProcessorWrapper = class _ProcessorWrapper {
             }
           }
         } catch (e) {
-          console.error("Error in render loop:", e);
+          this.log.error("Error in render loop:", e);
         }
       }
       this.animationFrameId = requestAnimationFrame(renderLoop);
@@ -233,7 +297,8 @@ var ProcessorWrapper = class _ProcessorWrapper {
     this.animationFrameId = requestAnimationFrame(renderLoop);
   }
   async restart(opts) {
-    await this.destroy();
+    this.log.debug("Restart called");
+    await this.destroy({ willProcessorRestart: true });
     await this.init(opts);
   }
   async restartTransformer(...options) {
@@ -242,11 +307,18 @@ var ProcessorWrapper = class _ProcessorWrapper {
   async updateTransformerOptions(...options) {
     await this.transformer.update(options[0]);
   }
-  async destroy(symbol) {
-    var _a, _b, _c, _d;
-    if (symbol && this.symbol !== symbol) {
+  /** Called if the media pipeline no longer can read frames to process from the source media */
+  async handleMediaExhausted() {
+    this.log.debug("Media was exhausted from source");
+    if (this.lifecycleState !== "running") {
       return;
     }
+    this.lifecycleState = "media-exhausted";
+    await this.cleanup();
+  }
+  /** Tears down the media stack logic initialized in initStreamProcessorPath / initFallbackPath */
+  async cleanup() {
+    var _a, _b, _c, _d;
     if (this.useStreamFallback) {
       this.processingEnabled = false;
       if (this.animationFrameId) {
@@ -261,7 +333,20 @@ var ProcessorWrapper = class _ProcessorWrapper {
       await ((_c = (_b = this.processor) == null ? void 0 : _b.writableControl) == null ? void 0 : _c.close());
       (_d = this.trackGenerator) == null ? void 0 : _d.stop();
     }
-    await this.transformer.destroy();
+  }
+  async destroy(transformerDestroyOptions = { willProcessorRestart: false }) {
+    this.log.debug(`Destroy called - lifecycleState=${this.lifecycleState}, transformerDestroyOptions=${JSON.stringify(transformerDestroyOptions)}`);
+    switch (this.lifecycleState) {
+      case "running":
+      case "media-exhausted":
+        this.lifecycleState = "destroying";
+        await this.cleanup();
+        await this.transformer.destroy(transformerDestroyOptions);
+        this.lifecycleState = "destroyed";
+        break;
+      default:
+        break;
+    }
   }
 };
 
@@ -274,6 +359,7 @@ var dependencies = {
 };
 
 // src/webgl/utils.ts
+var log = getLogger("livekit-track-processor-web-gl" /* WebGl */);
 function initTexture(gl, texIndex) {
   const texRef = gl.TEXTURE0 + texIndex;
   gl.activeTexture(texRef);
@@ -291,7 +377,7 @@ function createShader(gl, type, source) {
   gl.shaderSource(shader, source);
   gl.compileShader(shader);
   if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
-    console.error("Shader compile failed:", gl.getShaderInfoLog(shader));
+    log.error("Shader compile failed:", gl.getShaderInfoLog(shader));
     gl.deleteShader(shader);
     throw new Error("Shader compile failed");
   }
@@ -303,7 +389,7 @@ function createProgram(gl, vs, fs) {
   gl.attachShader(program, fs);
   gl.linkProgram(program);
   if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
-    console.error("Program link failed:", gl.getProgramInfoLog(program));
+    log.error("Program link failed:", gl.getProgramInfoLog(program));
     throw new Error("Program link failed");
   }
   return program;
@@ -507,29 +593,33 @@ var compositeFragmentShader = glsl`#version 300 es
   precision mediump float;
   in vec2 texCoords;
   uniform sampler2D background;
+  uniform bool disableBackground;
   uniform sampler2D frame;
   uniform sampler2D mask;
   out vec4 fragColor;
   
   void main() {
-      
     vec4 frameTex = texture(frame, texCoords);
-    vec4 bgTex = texture(background, texCoords);
 
-    float maskVal = texture(mask, texCoords).r;
+    if (disableBackground) {
+      fragColor = frameTex;
+    } else {
+      vec4 bgTex = texture(background, texCoords);
+
+      float maskVal = texture(mask, texCoords).r;
+
+      // Compute screen-space gradient to detect edge sharpness
+      float grad = length(vec2(dFdx(maskVal), dFdy(maskVal)));
 
-    // Compute screen-space gradient to detect edge sharpness
-    float grad = length(vec2(dFdx(maskVal), dFdy(maskVal)));
+      float edgeSoftness = 2.0; // higher = softer
 
-    float edgeSoftness = 2.0; // higher = softer
-    
-    // Create a smooth edge around binary transition
-    float smoothAlpha = smoothstep(0.5 - grad * edgeSoftness, 0.5 + grad * edgeSoftness, maskVal);
+      // Create a smooth edge around binary transition
+      float smoothAlpha = smoothstep(0.5 - grad * edgeSoftness, 0.5 + grad * edgeSoftness, maskVal);
 
-    // Optional: preserve frame alpha, or override as fully opaque
-    vec4 blended = mix(bgTex, vec4(frameTex.rgb, 1.0), 1.0 - smoothAlpha);
-    
-    fragColor = blended;
+      // Optional: preserve frame alpha, or override as fully opaque
+      vec4 blended = mix(bgTex, vec4(frameTex.rgb, 1.0), 1.0 - smoothAlpha);
+      fragColor = blended;
+    }
   
   }
 `;
@@ -544,6 +634,7 @@ function createCompositeProgram(gl) {
     mask: gl.getUniformLocation(compositeProgram, "mask"),
     frame: gl.getUniformLocation(compositeProgram, "frame"),
     background: gl.getUniformLocation(compositeProgram, "background"),
+    disableBackground: gl.getUniformLocation(compositeProgram, "disableBackground"),
     stepWidth: gl.getUniformLocation(compositeProgram, "u_stepWidth")
   };
   return {
@@ -613,6 +704,7 @@ function applyDownsampling(gl, inputTexture, downSampler, vertexBuffer, width, h
 }
 
 // src/webgl/index.ts
+var log2 = getLogger("livekit-track-processor-web-gl" /* WebGl */);
 var setupWebGL = (canvas) => {
   const gl = canvas.getContext("webgl2", {
     antialias: true,
@@ -622,7 +714,7 @@ var setupWebGL = (canvas) => {
   let maskBlurRadius = 8;
   const downsampleFactor = 4;
   if (!gl) {
-    console.error("Failed to create WebGL context");
+    log2.error("Failed to create WebGL context");
     return void 0;
   }
   gl.enable(gl.BLEND);
@@ -633,7 +725,8 @@ var setupWebGL = (canvas) => {
   const {
     mask: maskTextureLocation,
     frame: frameTextureLocation,
-    background: bgTextureLocation
+    background: bgTextureLocation,
+    disableBackground: disableBackgroundLocation
   } = composite.uniformLocations;
   const blur = createBlurProgram(gl);
   const blurProgram = blur.program;
@@ -672,11 +765,13 @@ var setupWebGL = (canvas) => {
     createFramebuffer(gl, finalMaskTextures[0], canvas.width, canvas.height),
     createFramebuffer(gl, finalMaskTextures[1], canvas.width, canvas.height)
   ];
+  let backgroundImageDisabled = false;
   gl.useProgram(compositeProgram);
+  gl.uniform1i(disableBackgroundLocation, backgroundImageDisabled ? 1 : 0);
   gl.uniform1i(bgTextureLocation, 0);
   gl.uniform1i(frameTextureLocation, 1);
   gl.uniform1i(maskTextureLocation, 2);
-  let customBackgroundImage = getEmptyImageData();
+  let customBackgroundImage = null;
   function renderFrame(frame) {
     if (frame.codedWidth === 0 || finalMaskTextures.length === 0) {
       return;
@@ -708,7 +803,7 @@ var setupWebGL = (canvas) => {
         bgBlurFrameBuffers,
         bgBlurTextures
       );
-    } else {
+    } else if (customBackgroundImage) {
       gl.activeTexture(gl.TEXTURE0);
       gl.bindTexture(gl.TEXTURE_2D, bgTexture);
       gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, customBackgroundImage);
@@ -724,6 +819,7 @@ var setupWebGL = (canvas) => {
     gl.activeTexture(gl.TEXTURE0);
     gl.bindTexture(gl.TEXTURE_2D, backgroundTexture);
     gl.uniform1i(bgTextureLocation, 0);
+    gl.uniform1i(disableBackgroundLocation, backgroundImageDisabled ? 1 : 0);
     gl.activeTexture(gl.TEXTURE1);
     gl.bindTexture(gl.TEXTURE_2D, frameTexture);
     gl.uniform1i(frameTextureLocation, 1);
@@ -733,26 +829,30 @@ var setupWebGL = (canvas) => {
     gl.drawArrays(gl.TRIANGLES, 0, 6);
   }
   async function setBackgroundImage(image) {
-    customBackgroundImage = getEmptyImageData();
+    customBackgroundImage = null;
     if (image) {
+      customBackgroundImage = getEmptyImageData();
       try {
         const croppedImage = await resizeImageToCover(image, canvas.width, canvas.height);
         customBackgroundImage = croppedImage;
       } catch (error) {
-        console.error(
+        log2.error(
           "Error processing background image, falling back to black background:",
           error
         );
       }
+      gl.activeTexture(gl.TEXTURE0);
+      gl.bindTexture(gl.TEXTURE_2D, bgTexture);
+      gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, customBackgroundImage);
     }
-    gl.activeTexture(gl.TEXTURE0);
-    gl.bindTexture(gl.TEXTURE_2D, bgTexture);
-    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, customBackgroundImage);
   }
   function setBlurRadius(radius) {
     blurRadius = radius ? Math.max(1, Math.floor(radius / downsampleFactor)) : null;
     setBackgroundImage(null);
   }
+  function setBackgroundDisabled(disabled) {
+    backgroundImageDisabled = disabled;
+  }
   function updateMask(mask) {
     const tempFramebuffers = [tempMaskFrameBuffer, finalMaskFrameBuffers[writeMaskIndex]];
     const tempTextures = [tempMaskTexture, finalMaskTextures[writeMaskIndex]];
@@ -804,13 +904,13 @@ var setupWebGL = (canvas) => {
       if (customBackgroundImage instanceof ImageBitmap) {
         customBackgroundImage.close();
       }
-      customBackgroundImage = getEmptyImageData();
+      customBackgroundImage = null;
     }
     bgBlurTextures = [];
     bgBlurFrameBuffers = [];
     finalMaskTextures = [];
   }
-  return { renderFrame, updateMask, setBackgroundImage, setBlurRadius, cleanup };
+  return { renderFrame, updateMask, setBackgroundImage, setBlurRadius, setBackgroundDisabled, cleanup };
 };
 
 // src/transformers/VideoTransformer.ts
@@ -863,6 +963,7 @@ var BackgroundProcessor = class extends VideoTransformer {
     this.backgroundImageAndPath = null;
     this.segmentationTimeMs = 0;
     this.isFirstFrame = true;
+    this.log = getLogger("livekit-processor-wrapper" /* ProcessorWrapper */);
     this.options = opts;
     this.update(opts);
   }
@@ -870,7 +971,7 @@ var BackgroundProcessor = class extends VideoTransformer {
     return typeof OffscreenCanvas !== "undefined" && typeof VideoFrame !== "undefined" && typeof createImageBitmap !== "undefined" && !!document.createElement("canvas").getContext("webgl2");
   }
   async init({ outputCanvas, inputElement: inputVideo }) {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
     await super.init({ outputCanvas, inputElement: inputVideo });
     const fileSet = await vision.FilesetResolver.forVisionTasks(
       (_b = (_a = this.options.assetPaths) == null ? void 0 : _a.tasksVisionFileSet) != null ? _b : `https://cdn.jsdelivr.net/npm/@mediapipe/tasks-vision@${dependencies["@mediapipe/tasks-vision"]}/wasm`
@@ -888,19 +989,22 @@ var BackgroundProcessor = class extends VideoTransformer {
     });
     if ((_e = this.options) == null ? void 0 : _e.imagePath) {
       await this.loadAndSetBackground(this.options.imagePath).catch(
-        (err) => console.error("Error while loading processor background image: ", err)
+        (err) => this.log.error("Error while loading processor background image: ", err)
       );
     }
-    if (this.options.blurRadius) {
+    if (typeof this.options.blurRadius === "number") {
       (_f = this.gl) == null ? void 0 : _f.setBlurRadius(this.options.blurRadius);
     }
+    (_h = this.gl) == null ? void 0 : _h.setBackgroundDisabled((_g = this.options.backgroundDisabled) != null ? _g : false);
   }
-  async destroy() {
+  async destroy(options) {
     var _a;
     await super.destroy();
     await ((_a = this.imageSegmenter) == null ? void 0 : _a.close());
     this.backgroundImageAndPath = null;
-    this.isFirstFrame = true;
+    if (!(options == null ? void 0 : options.willProcessorRestart)) {
+      this.isFirstFrame = true;
+    }
   }
   async loadAndSetBackground(path) {
     var _a, _b;
@@ -918,14 +1022,18 @@ var BackgroundProcessor = class extends VideoTransformer {
     (_b = this.gl) == null ? void 0 : _b.setBackgroundImage(this.backgroundImageAndPath.imageData);
   }
   async transform(frame, controller) {
-    var _a, _b;
+    var _a, _b, _c, _d;
     let enqueuedFrame = false;
     try {
       if (!(frame instanceof VideoFrame) || frame.codedWidth === 0 || frame.codedHeight === 0) {
-        console.debug("empty frame detected, ignoring");
+        this.log.debug("empty frame detected, ignoring");
         return;
       }
-      if (this.isDisabled) {
+      let skipProcessingFrame = (_b = (_a = this.isDisabled) != null ? _a : this.options.backgroundDisabled) != null ? _b : false;
+      if (typeof this.options.blurRadius !== "number" && typeof this.options.imagePath !== "string") {
+        skipProcessingFrame = true;
+      }
+      if (skipProcessingFrame) {
         controller.enqueue(frame);
         enqueuedFrame = true;
         return;
@@ -976,13 +1084,13 @@ var BackgroundProcessor = class extends VideoTransformer {
           segmentationTimeMs: this.segmentationTimeMs,
           filterTimeMs
         };
-        (_b = (_a = this.options).onFrameProcessed) == null ? void 0 : _b.call(_a, stats);
+        (_d = (_c = this.options).onFrameProcessed) == null ? void 0 : _d.call(_c, stats);
       } else {
         controller.enqueue(frame);
       }
       await segmentationPromise;
     } catch (e) {
-      console.error("Error while processing frame: ", e);
+      this.log.error("Error while processing frame: ", e);
     } finally {
       if (!enqueuedFrame) {
         frame.close();
@@ -990,7 +1098,7 @@ var BackgroundProcessor = class extends VideoTransformer {
     }
   }
   async update(opts) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d, _e;
     this.options = { ...this.options, ...opts };
     (_b = this.gl) == null ? void 0 : _b.setBlurRadius((_a = opts.blurRadius) != null ? _a : null);
     if (opts.imagePath) {
@@ -998,6 +1106,7 @@ var BackgroundProcessor = class extends VideoTransformer {
     } else {
       (_c = this.gl) == null ? void 0 : _c.setBackgroundImage(null);
     }
+    (_e = this.gl) == null ? void 0 : _e.setBackgroundDisabled((_d = opts.backgroundDisabled) != null ? _d : false);
   }
   async drawFrame(frame) {
     var _a;
@@ -1014,9 +1123,136 @@ var BackgroundProcessor = class extends VideoTransformer {
 };
 
 // src/index.ts
+var DEFAULT_BLUR_RADIUS = 10;
 var supportsBackgroundProcessors = () => BackgroundProcessor.isSupported && ProcessorWrapper.isSupported;
 var supportsModernBackgroundProcessors = () => BackgroundProcessor.isSupported && ProcessorWrapper.hasModernApiSupport;
-var BackgroundBlur = (blurRadius = 10, segmenterOptions, onFrameProcessed, processorOptions) => {
+var BackgroundProcessorWrapper = class extends ProcessorWrapper {
+  get mode() {
+    const options = this.transformer.options;
+    if (options.backgroundDisabled) {
+      return "disabled";
+    }
+    if (typeof options.imagePath === "string" && typeof options.blurRadius === "undefined") {
+      return "virtual-background";
+    }
+    if (typeof options.imagePath === "undefined") {
+      return "background-blur";
+    }
+    return "legacy";
+  }
+  async switchTo(options) {
+    var _a;
+    switch (options.mode) {
+      case "background-blur":
+        await this.updateTransformerOptions({
+          imagePath: void 0,
+          blurRadius: (_a = options.blurRadius) != null ? _a : DEFAULT_BLUR_RADIUS,
+          backgroundDisabled: false
+        });
+        break;
+      case "virtual-background":
+        await this.updateTransformerOptions({
+          imagePath: options.imagePath,
+          blurRadius: void 0,
+          backgroundDisabled: false
+        });
+        break;
+      case "disabled":
+        await this.updateTransformerOptions({ imagePath: void 0, backgroundDisabled: true });
+        break;
+    }
+  }
+};
+var BackgroundProcessor2 = (options, name = "background-processor") => {
+  const isTransformerSupported = BackgroundProcessor.isSupported;
+  const isProcessorSupported = ProcessorWrapper.isSupported;
+  if (!isTransformerSupported) {
+    throw new Error("Background transformer is not supported in this browser");
+  }
+  if (!isProcessorSupported) {
+    throw new Error(
+      "Neither MediaStreamTrackProcessor nor canvas.captureStream() fallback is supported in this browser"
+    );
+  }
+  let transformer, processorOpts;
+  switch (options.mode) {
+    case "background-blur": {
+      const {
+        // eslint-disable-next-line no-unused-vars
+        mode,
+        blurRadius = DEFAULT_BLUR_RADIUS,
+        segmenterOptions,
+        assetPaths,
+        onFrameProcessed,
+        ...rest
+      } = options;
+      processorOpts = rest;
+      transformer = new BackgroundProcessor({
+        blurRadius,
+        segmenterOptions,
+        assetPaths,
+        onFrameProcessed
+      });
+      break;
+    }
+    case "virtual-background": {
+      const {
+        // eslint-disable-next-line no-unused-vars
+        mode,
+        imagePath,
+        segmenterOptions,
+        assetPaths,
+        onFrameProcessed,
+        ...rest
+      } = options;
+      processorOpts = rest;
+      transformer = new BackgroundProcessor({
+        imagePath,
+        segmenterOptions,
+        assetPaths,
+        onFrameProcessed
+      });
+      break;
+    }
+    case "disabled": {
+      const {
+        segmenterOptions,
+        assetPaths,
+        onFrameProcessed,
+        ...rest
+      } = options;
+      processorOpts = rest;
+      transformer = new BackgroundProcessor({
+        segmenterOptions,
+        assetPaths,
+        onFrameProcessed
+      });
+      break;
+    }
+    default: {
+      const {
+        blurRadius,
+        imagePath,
+        segmenterOptions,
+        assetPaths,
+        onFrameProcessed,
+        ...rest
+      } = options;
+      processorOpts = rest;
+      transformer = new BackgroundProcessor({
+        blurRadius,
+        imagePath,
+        segmenterOptions,
+        assetPaths,
+        onFrameProcessed
+      });
+      break;
+    }
+  }
+  const processor = new BackgroundProcessorWrapper(transformer, name, processorOpts);
+  return processor;
+};
+var BackgroundBlur = (blurRadius = DEFAULT_BLUR_RADIUS, segmenterOptions, onFrameProcessed, processorOptions) => {
   return BackgroundProcessor2(
     {
       blurRadius,
@@ -1038,42 +1274,19 @@ var VirtualBackground = (imagePath, segmenterOptions, onFrameProcessed, processo
     "virtual-background"
   );
 };
-var BackgroundProcessor2 = (options, name = "background-processor") => {
-  const isTransformerSupported = BackgroundProcessor.isSupported;
-  const isProcessorSupported = ProcessorWrapper.isSupported;
-  if (!isTransformerSupported) {
-    throw new Error("Background transformer is not supported in this browser");
-  }
-  if (!isProcessorSupported) {
-    throw new Error(
-      "Neither MediaStreamTrackProcessor nor canvas.captureStream() fallback is supported in this browser"
-    );
-  }
-  const {
-    blurRadius,
-    imagePath,
-    segmenterOptions,
-    assetPaths,
-    onFrameProcessed,
-    ...processorOpts
-  } = options;
-  const transformer = new BackgroundProcessor({
-    blurRadius,
-    imagePath,
-    segmenterOptions,
-    assetPaths,
-    onFrameProcessed
-  });
-  const processor = new ProcessorWrapper(transformer, name, processorOpts);
-  return processor;
-};
 export {
   BackgroundBlur,
   BackgroundProcessor2 as BackgroundProcessor,
+  BackgroundProcessorWrapper,
   BackgroundProcessor as BackgroundTransformer,
+  LogLevel,
+  LoggerNames,
   ProcessorWrapper,
   VideoTransformer,
   VirtualBackground,
+  getLogger,
+  setLogExtension,
+  setLogLevel,
   supportsBackgroundProcessors,
   supportsModernBackgroundProcessors
 };