@remotion/video-matting 4.0.523

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export { canUseVideoMatting, VideoMattingUnsupportedReason, } from './can-use-video-matting';
+export type { CanUseVideoMattingOptions, CanUseVideoMattingResult, } from './can-use-video-matting';
+export { disposeVideoMattingModel, loadVideoMattingModel, } from './load-video-matting-model';
+export type { DisposeVideoMattingModelOptions, LoadVideoMattingModelOptions, LoadVideoMattingModelResult, OnVideoMattingModelLoadProgress, VideoMattingModelLoadProgress, } from './load-video-matting-model';
+export { isVideoMattingModelCached } from './is-video-matting-model-cached';
+export type { IsVideoMattingModelCachedOptions } from './is-video-matting-model-cached';
+export { removeVideoMattingModel } from './remove-video-matting-model';
+export type { RemoveVideoMattingModelOptions } from './remove-video-matting-model';
+export { getAvailableModels } from './models';
+export type { VideoMattingModel, VideoMattingModelInfo } from './models';
+export type { VideoLayerOutput, VideoLayerOutputOptions, VideoLayerOutputTarget, } from './output-target';
+export { separateVideoLayers } from './separate-video-layers';
+export type { SeparateVideoLayersOptions, SeparateVideoLayersProgress, SeparateVideoLayersResult, VideoLayerAudio, } from './separate-video-layers';
+export type { VideoMattingBitrate, VideoMattingQuality, } from './video-matting-quality';

package/dist/is-video-matting-model-cached.d.ts

@@ -0,0 +1,5 @@
+import { type VideoMattingModel } from './models';
+export type IsVideoMattingModelCachedOptions = {
+    model: VideoMattingModel;
+};
+export declare const isVideoMattingModelCached: ({ model, }: IsVideoMattingModelCachedOptions) => Promise<boolean>;

package/dist/load-video-matting-model.d.ts

@@ -0,0 +1,35 @@
+import { type VideoMattingModel } from './models';
+export type VideoMattingModelLoadProgress = {
+    status: string;
+    file: string | null;
+    progress: number | null;
+    loadedBytes: number | null;
+    totalBytes: number | null;
+};
+export type OnVideoMattingModelLoadProgress = (progress: VideoMattingModelLoadProgress) => void;
+export type VideoMattingImageSource = HTMLCanvasElement | OffscreenCanvas;
+export type VideoMattingPipelineResult = {
+    data: Uint8ClampedArray<ArrayBuffer>;
+    width: number;
+    height: number;
+    channels: 4;
+};
+export type LoadedVideoMattingPipeline = (image: VideoMattingImageSource) => Promise<VideoMattingPipelineResult>;
+export type LoadVideoMattingModelOptions = {
+    model: VideoMattingModel;
+    onProgress?: OnVideoMattingModelLoadProgress;
+};
+export type LoadVideoMattingModelResult = {
+    alreadyLoaded: boolean;
+};
+export declare const loadVideoMattingModel: ({ model, onProgress, }: LoadVideoMattingModelOptions) => Promise<LoadVideoMattingModelResult>;
+export declare const withLoadedVideoMattingPipeline: <ReturnValue>({ model, onProgress, signal, run, }: {
+    model: "ben2-base" | "modnet";
+    onProgress?: OnVideoMattingModelLoadProgress | undefined;
+    signal: AbortSignal | null;
+    run: (pipeline: LoadedVideoMattingPipeline) => Promise<ReturnValue>;
+}) => Promise<ReturnValue>;
+export type DisposeVideoMattingModelOptions = {
+    model?: VideoMattingModel;
+};
+export declare const disposeVideoMattingModel: ({ model, }?: DisposeVideoMattingModelOptions) => Promise<void>;

package/dist/models.d.ts

@@ -0,0 +1,17 @@
+declare const VIDEO_MATTING_MODELS: readonly ["modnet", "ben2-base"];
+export type VideoMattingModel = (typeof VIDEO_MATTING_MODELS)[number];
+export type VideoMattingModelInfo = {
+    name: VideoMattingModel;
+    modelId: string;
+    purpose: 'person' | 'general';
+    webGpuDownloadSize: number;
+};
+type InternalVideoMattingModelInfo = VideoMattingModelInfo & {
+    revision: string;
+    dtype: 'fp32' | 'fp16';
+    requiresShaderF16: boolean;
+};
+export declare const getAvailableModels: () => VideoMattingModelInfo[];
+export declare const getVideoMattingModelInfo: (model: "ben2-base" | "modnet") => InternalVideoMattingModelInfo;
+export declare const getHostedVideoMattingModelId: (model: "ben2-base" | "modnet") => string;
+export {};

package/dist/output-target.d.ts

@@ -0,0 +1,13 @@
+import type { StreamTargetChunk } from 'mediabunny';
+export type VideoLayerOutputTarget = 'arraybuffer' | 'web-fs';
+export type VideoLayerOutputOptions = {
+    outputTarget?: VideoLayerOutputTarget;
+    outputWritable?: never;
+} | {
+    outputTarget?: never;
+    outputWritable: WritableStream<StreamTargetChunk>;
+};
+export type VideoLayerOutput = {
+    getBlob: () => Promise<Blob>;
+    dispose: () => Promise<void>;
+};

package/dist/prepare-audio.d.ts

@@ -0,0 +1,28 @@
+import { type Input, type Output, Quality, type Target, type WebMOutputFormat } from 'mediabunny';
+export type VideoMattingAudioDestination = 'base' | 'foreground' | 'both' | 'none';
+export type PreparedVideoMattingAudio = {
+    /**
+     * Queues the first audio packet or sample, even when it starts after the
+     * first video frame. Call this after the outputs have started.
+     */
+    prime: () => Promise<void>;
+    /**
+     * Writes audio whose rebased start timestamp is at or before the given
+     * output timestamp. Calls must use monotonically increasing timestamps.
+     */
+    writeAudioUntil: (outputTimestamp: number) => Promise<void>;
+    /** Writes the remaining audio up to the end of the video and closes it. */
+    finishAudio: () => Promise<void>;
+    /** Releases decoded samples that have not been written yet. */
+    cancel: () => Promise<void>;
+};
+export declare const prepareAudio: <BaseTarget extends Target, ForegroundTarget extends Target>({ input, baseOutput, foregroundOutput, destination, videoStartTimestamp, videoEndTimestamp, audioQuality, forceTranscode, }: {
+    input: Input<import("mediabunny").Source>;
+    baseOutput: Output<WebMOutputFormat, BaseTarget>;
+    foregroundOutput: Output<WebMOutputFormat, ForegroundTarget>;
+    destination: VideoMattingAudioDestination;
+    videoStartTimestamp: number;
+    videoEndTimestamp: number;
+    audioQuality: Quality | null;
+    forceTranscode: boolean;
+}) => Promise<PreparedVideoMattingAudio>;

package/dist/remove-video-matting-model.d.ts

@@ -0,0 +1,5 @@
+import { type VideoMattingModel } from './models';
+export type RemoveVideoMattingModelOptions = {
+    model: VideoMattingModel;
+};
+export declare const removeVideoMattingModel: ({ model, }: RemoveVideoMattingModelOptions) => Promise<void>;

package/dist/separate-video-layers.d.ts

@@ -0,0 +1,43 @@
+import { type OnVideoMattingModelLoadProgress } from './load-video-matting-model';
+import { type VideoMattingModel } from './models';
+import type { VideoLayerOutput, VideoLayerOutputOptions } from './output-target';
+import { type VideoMattingBitrate } from './video-matting-quality';
+export type VideoLayerAudio = 'base' | 'foreground' | 'both' | 'none';
+type VideoLayerProgressFields = {
+    processedFrames: number;
+    processedDurationInSeconds: number;
+    durationInSeconds: number;
+};
+export type SeparateVideoLayersProgress = (VideoLayerProgressFields & {
+    stage: 'processing';
+    progress: number;
+}) | (VideoLayerProgressFields & {
+    stage: 'finalizing';
+    progress: null;
+});
+export type SeparateVideoLayersOptions = {
+    src: string | URL | Blob;
+    model?: VideoMattingModel;
+    audio?: VideoLayerAudio;
+    outputs?: {
+        base?: VideoLayerOutputOptions;
+        foreground?: VideoLayerOutputOptions;
+    };
+    videoBitrate?: VideoMattingBitrate;
+    audioBitrate?: VideoMattingBitrate;
+    keyframeIntervalInSeconds?: number;
+    signal?: AbortSignal;
+    onModelLoadProgress?: OnVideoMattingModelLoadProgress;
+    onProgress?: (progress: SeparateVideoLayersProgress) => void;
+};
+export type SeparateVideoLayersResult = {
+    base: VideoLayerOutput;
+    foreground: VideoLayerOutput;
+    model: VideoMattingModel;
+    width: number;
+    height: number;
+    durationInSeconds: number;
+    processedFrames: number;
+};
+export declare const separateVideoLayers: (options: SeparateVideoLayersOptions) => Promise<SeparateVideoLayersResult>;
+export {};

package/dist/video-matting-canvas.d.ts

@@ -0,0 +1,22 @@
+import type { VideoMattingPipelineResult } from './load-video-matting-model';
+export type VideoMattingCanvas = HTMLCanvasElement | OffscreenCanvas;
+type VideoMattingCanvasContext = CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D;
+export declare const createVideoMattingCanvas: ({ width, height, }: {
+    width: number;
+    height: number;
+}) => VideoMattingCanvas;
+export declare const getVideoMattingCanvasContext: (canvas: VideoMattingCanvas) => VideoMattingCanvasContext;
+export declare const drawOpaqueBaseFrame: ({ context, source, width, height, }: {
+    context: VideoMattingCanvasContext;
+    source: VideoMattingCanvas;
+    width: number;
+    height: number;
+}) => void;
+export declare const drawForegroundFrame: ({ context, result, source, targetWidth, targetHeight, }: {
+    context: VideoMattingCanvasContext;
+    result: VideoMattingPipelineResult;
+    source: VideoMattingCanvas;
+    targetWidth: number;
+    targetHeight: number;
+}) => void;
+export {};

package/dist/video-matting-quality.d.ts

@@ -0,0 +1,5 @@
+import { Quality } from 'mediabunny';
+export declare const VIDEO_MATTING_QUALITIES: readonly ["very-low", "low", "medium", "high", "very-high"];
+export type VideoMattingQuality = (typeof VIDEO_MATTING_QUALITIES)[number];
+export type VideoMattingBitrate = number | VideoMattingQuality;
+export declare const resolveVideoMattingQuality: (value: VideoMattingBitrate) => Quality;

package/dist/video-timing.d.ts

@@ -0,0 +1,22 @@
+export declare const rebaseVideoTimestamp: ({ timestamp, firstVideoTimestamp, }: {
+    timestamp: number;
+    firstVideoTimestamp: number;
+}) => number;
+export declare const getClippedVideoFrameTiming: ({ timestamp, duration, videoStartTimestamp, videoEndTimestamp, }: {
+    timestamp: number;
+    duration: number;
+    videoStartTimestamp: number;
+    videoEndTimestamp: number;
+}) => {
+    timestamp: number;
+    duration: number;
+} | null;
+export declare const getVideoProcessingProgress: ({ timestamp, duration, firstVideoTimestamp, durationInSeconds, }: {
+    timestamp: number;
+    duration: number;
+    firstVideoTimestamp: number;
+    durationInSeconds: number;
+}) => {
+    processedDurationInSeconds: number;
+    progress: number;
+};

package/dist/web-fs-target.d.ts

@@ -0,0 +1,8 @@
+import type { StreamTargetChunk } from 'mediabunny';
+export declare const canUseWebFsWriter: () => Promise<boolean>;
+export type WebFsVideoLayerTarget = {
+    stream: WritableStream<StreamTargetChunk>;
+    getBlob: () => Promise<Blob>;
+    remove: () => Promise<void>;
+};
+export declare const createWebFsVideoLayerTarget: () => Promise<WebFsVideoLayerTarget>;

package/dist/with-remotion-model-host.d.ts

@@ -0,0 +1,10 @@
+import type { AutoModelForImageSegmentation, AutoProcessor, BackgroundRemovalPipeline, env, ModelRegistry } from '@huggingface/transformers';
+type TransformersModule = {
+    readonly AutoModelForImageSegmentation: typeof AutoModelForImageSegmentation;
+    readonly AutoProcessor: typeof AutoProcessor;
+    readonly BackgroundRemovalPipeline: typeof BackgroundRemovalPipeline;
+    readonly env: typeof env;
+    readonly ModelRegistry: typeof ModelRegistry;
+};
+export declare const withRemotionModelHost: <ReturnValue>(operation: (transformers: TransformersModule) => Promise<ReturnValue>) => Promise<ReturnValue>;
+export {};

package/package.json

@@ -0,0 +1,56 @@
+{
+	"name": "@remotion/video-matting",
+	"version": "4.0.523",
+	"description": "Separate a video into a base layer and transparent foreground in the browser",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"module": "dist/esm/index.mjs",
+	"repository": {
+		"url": "https://github.com/remotion-dev/remotion/tree/main/packages/video-matting"
+	},
+	"type": "module",
+	"scripts": {
+		"test": "bun test src/test",
+		"formatting": "oxfmt src --check",
+		"format": "oxfmt src",
+		"lint": "eslint src",
+		"watch": "tsgo -w",
+		"make": "tsgo && bun --env-file=../.env.bundle bundle.ts"
+	},
+	"author": "Jonny Burger <jonny@remotion.dev>",
+	"contributors": [],
+	"license": "MIT",
+	"bugs": {
+		"url": "https://github.com/remotion-dev/remotion/issues"
+	},
+	"dependencies": {
+		"mediabunny": "1.55.5"
+	},
+	"peerDependencies": {
+		"@huggingface/transformers": "4.2.0"
+	},
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"module": "./dist/esm/index.mjs",
+			"import": "./dist/esm/index.mjs"
+		},
+		"./package.json": "./package.json"
+	},
+	"devDependencies": {
+		"@huggingface/transformers": "4.2.0",
+		"@remotion/eslint-config-internal": "4.0.523",
+		"@typescript/native-preview": "7.0.0-dev.20260217.1",
+		"eslint": "9.19.0"
+	},
+	"keywords": [
+		"remotion",
+		"video-matting",
+		"background-removal",
+		"webgpu"
+	],
+	"publishConfig": {
+		"access": "public"
+	},
+	"homepage": "https://www.remotion.dev/docs/video-matting"
+}