@pexip/media-processor 16.7.1 → 17.0.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 17.0.0
+
+### Major Changes
+
+- 1f5d1df: Restructure to allow targeting to differernt environments
+
+### Minor Changes
+
+- af71598: Avoid using desynconized 2D cavas because MS Edge 113 on Windows
+  produces green screen
+- 32c24c8d06: Remove bg-blur dependency
+
+### Patch Changes
+
+- @pexip/utils@16.6.0
+
 ## 16.7.1
 
 ### Patch Changes

package/README.md

@@ -105,19 +105,13 @@ await audioGraph.release();
 ### Use background blur
 
 ```typescript
-import {urls} from '@pexip/bg-blur';
-
 const PROCESSING_WIDTH = 768;
 const PROCESSING_HEIGHT = 432;
 
 const stream = await navigator.mediaDevices.getUserMedia({video: true});
 
-// Create symbolic link to link bg-blur/selfie_segmentation to a public folder
 // Thus we can create a URL object to get the link to be used for the `gluePath`
-const selfieJs = new URL(
-  `./selfie_segmentation/selfie_segmentation.js`,
-  document.baseURI,
-);
+const selfieJs = new URL('@mediapipe/selfie_segmentation', import.meta);
 const segmenter = createMediapipeSegmenter('selfie_segmentation', {
   modelType: selfieModel,
   processingWidth: PROCESSING_WIDTH,

package/dist/main/audio.d.ts

@@ -0,0 +1,123 @@
+import type { Analyzer, AnalyzerSubscribableOptions, AudioGraph, AudioGraphOptions, AudioNodeInit, AudioNodeInitConnections, Gain, Unsubscribe, WorkletMessagePortOptions } from './types';
+/**
+ * A function to create `AudioContext` using constructor or factory function
+ * depends on the browser supports
+ *
+ * @param options - @see {@link AudioContextOptions}
+ *
+ * @internal
+ */
+export declare const createAudioContext: (options?: AudioContextOptions) => AudioContext;
+/**
+ * Resume the stream whenever interrupted
+ *
+ * @param audioContext - AudioContext
+ *
+ * @alpha
+ */
+export declare function resumeAudioOnInterruption(audioContext: AudioContext): () => void;
+/**
+ * Resume the AudioContext whenever the source track is unmuted
+ *
+ * @param audioContext - The `AudioContext` to resume
+ *
+ * @alpha
+ */
+export declare const resumeAudioOnUnmute: (context: AudioContext) => (track: MediaStreamTrack) => Unsubscribe;
+/**
+ * Subscribe MessagePort message from an AudioWorkletNode
+ *
+ * @param workletNode - the node to subscribe
+ * @param options - can pass a message handler here to handle the message
+ */
+export declare const subscribeWorkletNode: <T>(workletNode: AudioWorkletNode, { messageHandler, errorHandler }?: Partial<WorkletMessagePortOptions<T>>) => () => void;
+/**
+ * Subscribe to a timeout loop to get the data from Analyzer
+ *
+ * @param analyzer - the analyzer to subscribe
+ * @param options - message handler, etc.
+ */
+export declare const subscribeTimeoutAnalyzerNode: (analyzer: Analyzer, { messageHandler, updateFrequency }: AnalyzerSubscribableOptions) => () => void;
+/**
+ * Create a MediaStreamAudioSourceNodeInit
+ *
+ * @param mediaStream - Source MediaStream
+ * @param shouldResetEnabled - Whether or not to enable the cloned track
+ */
+export declare const createStreamSourceGraphNode: (mediaStream: MediaStream, shouldResetEnabled?: boolean) => AudioNodeInit<MediaStreamAudioSourceNode, MediaStreamAudioSourceNode>;
+/**
+ * Create a MediaStreamAudioSourceNodeInit
+ *
+ * @param mediaStream - Source MediaStream
+ */
+export declare const createMediaElementSourceGraphNode: (mediaElement: HTMLMediaElement) => AudioNodeInit<MediaElementAudioSourceNode, MediaElementAudioSourceNode>;
+/**
+ * Create an analyzer node with push-based subscription
+ */
+export declare const createAnalyzerSubscribableGraphNode: ({ messageHandler, updateFrequency, ...analyserOptions }: AnalyzerSubscribableOptions & AnalyserOptions) => AudioNodeInit<AnalyserNode, Analyzer>;
+/**
+ * Create a noise suppression node
+ *
+ * @param data - WebAssembly source
+ */
+export declare const createDenoiseWorkletGraphNode: (data: BufferSource, messageHandler?: ((vads: number[]) => void) | undefined) => AudioNodeInit<AudioWorkletNode, AudioWorkletNode>;
+/**
+ * Create a GainNodeInit
+ *
+ * @param mute - initial mute state
+ */
+export declare const createGainGraphNode: (mute: boolean) => AudioNodeInit<GainNode, Gain>;
+/**
+ * Create an AnalyzerNodeInit
+ *
+ * @param options - @see {@link AnalyserOptions}
+ */
+export declare const createAnalyzerGraphNode: (options?: AnalyserOptions) => AudioNodeInit<AnalyserNode, Analyzer>;
+/**
+ * Create a MediaStreamAudioDestinationNodeInit
+ */
+export declare const createStreamDestinationGraphNode: (options?: AudioNodeOptions) => AudioNodeInit<MediaStreamAudioDestinationNode, MediaStreamAudioDestinationNode>;
+/**
+ * Create an `AudioDestinationNode`
+ */
+export declare const createAudioDestinationGraphNode: () => AudioNodeInit<AudioDestinationNode, AudioDestinationNode>;
+/**
+ * Create a `DelayNode`
+ *
+ * @param options - @see DelayOptions
+ */
+export declare const createDelayGraphNode: (options?: DelayOptions) => AudioNodeInit<DelayNode, DelayNode>;
+/**
+ * Create a ChannelSplitterNode
+ *
+ * @param options - @see ChannelSplitterOptions
+ */
+export declare const createChannelSplitterGraphNode: (options?: ChannelSplitterOptions) => AudioNodeInit<ChannelSplitterNode, ChannelSplitterNode>;
+/**
+ * Create a ChannelMergerNode
+ *
+ * @param options - @see ChannelMergerOptions
+ */
+export declare const createChannelMergerGraphNode: (options?: ChannelMergerOptions) => AudioNodeInit<ChannelMergerNode, ChannelMergerNode>;
+/**
+ * Accepts AudioNodeInitConnections to build the audio graph within a signal audio context
+ *
+ * @param initialConnections - A list of AudioNodeInit to build the graph in a linear fashion
+ * @param options - @see {@link AudioGraphOptions}
+ *
+ * @example
+ *
+ * ```typescript
+ * const source = createStreamSourceGraphNode(stream);
+ * const analyzer = createAnalyzerGraphNode({fftSize});
+ * const audioGraph = createAudioGraph([[source, analyzer]]);
+ * ```
+ */
+export declare const createAudioGraph: (initialConnections: AudioNodeInitConnections, options?: AudioGraphOptions) => AudioGraph;
+type AudioGraphProxyHandler = (target: AudioGraph, args: Parameters<AudioGraph['connect']>) => void;
+interface AudioGraphProxyHandlers {
+    connect?: AudioGraphProxyHandler;
+    disconnect?: AudioGraphProxyHandler;
+}
+export declare const createAudioGraphProxy: (audioGraph: AudioGraph, handlers: AudioGraphProxyHandlers) => AudioGraph;
+export {};