@newgameplusinc/odyssey-audio-video-sdk-dev 1.0.57 → 1.0.58

package/dist/UltimateMLNoiseSuppressor.js

@@ -1,309 +0,0 @@
-"use strict";
-/**
- * ULTIMATE ML Noise Suppressor - Enhanced for Apple/Google Meet Quality
- * Features:
- * 1. Temporal smoothing (exponential moving average)
- * 2. Voice frequency preservation (80-500 Hz)
- * 3. Sub-bass filtering (remove < 80 Hz)
- * 4. Adaptive processing
- * 5. WebAssembly acceleration
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UltimateMLNoiseSuppressor = void 0;
-const tf = __importStar(require("@tensorflow/tfjs"));
-class UltimateMLNoiseSuppressor {
-    constructor() {
-        this.model = null;
-        this.config = null;
-        this.normStats = null;
-        this.audioContext = null;
-        this.isInitialized = false;
-        // CRITICAL: Temporal smoothing state
-        this.prevMask = null;
-        this.SMOOTHING_ALPHA = 0.85; // 85% current, 15% previous
-        // Voice frequency preservation
-        this.highPassFilter = null;
-        this.voiceBandFilter = null;
-        // Processing optimization
-        this.processingQueue = [];
-        this.isProcessing = false;
-    }
-    /**
-     * Initialize with enhanced setup
-     */
-    async initialize(modelUrl, audioContext) {
-        console.log("🚀 Initializing ULTIMATE ML Noise Suppressor...");
-        this.audioContext = audioContext;
-        try {
-            // Load model
-            console.log(`📂 Loading model from ${modelUrl}`);
-            this.model = await tf.loadLayersModel(modelUrl);
-            console.log("✅ Model loaded");
-            // Load config
-            const baseUrl = modelUrl.substring(0, modelUrl.lastIndexOf("/"));
-            const configResponse = await fetch(`${baseUrl}/model_config.json`);
-            this.config = await configResponse.json();
-            // Load normalization stats
-            const normResponse = await fetch(`${baseUrl}/normalization_stats.json`);
-            this.normStats = await normResponse.json();
-            // Setup voice frequency filters
-            this.setupVoiceFilters();
-            this.isInitialized = true;
-            console.log("✅ ULTIMATE ML Noise Suppressor initialized!");
-        }
-        catch (error) {
-            console.error("❌ Failed to initialize:", error);
-            throw error;
-        }
-    }
-    /**
-     * Setup filters for voice frequency preservation
-     */
-    setupVoiceFilters() {
-        if (!this.audioContext)
-            return;
-        // High-pass filter: Remove sub-bass rumble (< 80 Hz)
-        this.highPassFilter = this.audioContext.createBiquadFilter();
-        this.highPassFilter.type = "highpass";
-        this.highPassFilter.frequency.value = 80; // 80 Hz cutoff
-        this.highPassFilter.Q.value = 0.7;
-        // Bandpass filter: Enhance voice fundamentals (100-300 Hz)
-        this.voiceBandFilter = this.audioContext.createBiquadFilter();
-        this.voiceBandFilter.type = "bandpass";
-        this.voiceBandFilter.frequency.value = 200; // Center at 200 Hz
-        this.voiceBandFilter.Q.value = 1.4;
-    }
-    /**
-     * Process audio with ULTIMATE quality
-     * NOTE: This runs in the AudioWorklet thread. It must be synchronous and fast.
-     * The heavy ML inference should ideally happen in a Worker, communicating via SharedArrayBuffer.
-     * For this implementation, we use a simplified frame-based approach.
-     */
-    processAudio(inputBuffer) {
-        if (!this.isInitialized || !this.model || !this.config || !this.normStats) {
-            return inputBuffer;
-        }
-        // 1. Pre-processing: Remove sub-bass rumble (High-pass)
-        // Note: In a real AudioWorklet, filters should be applied per-sample or per-block, not on the whole buffer at once if it's a stream.
-        // But assuming inputBuffer is a processing block (e.g. 128 samples):
-        const filtered = this.applyHighPassFilter(inputBuffer);
-        // ⚠️ CRITICAL ARCHITECTURE NOTE ⚠️
-        // We cannot await this.model.predict() here because this function must return immediately for real-time audio.
-        // The correct architecture is:
-        // 1. AudioWorklet writes audio to a RingBuffer (SharedArrayBuffer).
-        // 2. Web Worker reads RingBuffer, runs TFJS inference (async), writes Mask to another RingBuffer.
-        // 3. AudioWorklet reads latest Mask from RingBuffer and applies it.
-        // For now, we will return the filtered audio.
-        // To enable ML, you must implement the Worker architecture described above.
-        // Running TFJS on the main audio thread will cause stuttering.
-        return filtered;
-    }
-    /**
-     * Placeholder for async processing (to be moved to a Web Worker)
-     */
-    async processFrameAsync(inputBuffer) {
-        // This logic belongs in a Web Worker
-        try {
-            const features = await this.extractMelFeatures(inputBuffer);
-            const normalizedFeatures = tf.tidy(() => {
-                const tensor = tf.tensor2d(features);
-                return tensor.sub(this.normStats.mean).div(this.normStats.std);
-            });
-            const featuresArray = await normalizedFeatures.array();
-            const sequences = this.createSequences(featuresArray, this.config.sequence_length);
-            if (sequences.length > 0) {
-                const sequenceTensor = tf.tensor3d([sequences[0]]);
-                const maskTensor = this.model.predict(sequenceTensor);
-                const maskData = await maskTensor.data();
-                const flatMask = Array.from(maskData);
-                // Update the current mask for the AudioWorklet to use
-                this.prevMask = this.applyTemporalSmoothing(flatMask);
-                normalizedFeatures.dispose();
-                sequenceTensor.dispose();
-                maskTensor.dispose();
-            }
-        }
-        catch (e) {
-            console.error(e);
-        }
-    }
-    /**
-     * CRITICAL: Temporal smoothing (biggest quality improvement!)
-     */
-    applyTemporalSmoothing(currentMask) {
-        const smoothed = new Float32Array(currentMask.length);
-        if (!this.prevMask || this.prevMask.length !== currentMask.length) {
-            // First frame - no smoothing
-            this.prevMask = new Float32Array(currentMask);
-            return this.prevMask;
-        }
-        // Exponential moving average
-        for (let i = 0; i < currentMask.length; i++) {
-            smoothed[i] =
-                this.SMOOTHING_ALPHA * currentMask[i] +
-                    (1 - this.SMOOTHING_ALPHA) * this.prevMask[i];
-            // Clamp to valid range [0.02, 1.0]
-            // Never completely mute (min 2%)
-            smoothed[i] = Math.max(0.02, Math.min(1.0, smoothed[i]));
-        }
-        this.prevMask = smoothed;
-        return smoothed;
-    }
-    /**
-     * Apply high-pass filter to remove rumble
-     */
-    applyHighPassFilter(input) {
-        // Simple IIR high-pass filter (80 Hz @ 48kHz)
-        const output = new Float32Array(input.length);
-        const alpha = 0.98; // Filter coefficient
-        output[0] = input[0];
-        for (let i = 1; i < input.length; i++) {
-            output[i] = alpha * (output[i - 1] + input[i] - input[i - 1]);
-        }
-        return output;
-    }
-    /**
-     * Apply mask with voice frequency preservation
-     */
-    applyMaskWithVoicePreservation(audio, mask, numFrames) {
-        const output = new Float32Array(audio.length);
-        // Simple overlap-add (proper implementation would use ISTFT)
-        const hopLength = Math.floor(audio.length / numFrames);
-        for (let i = 0; i < audio.length; i++) {
-            const frameIdx = Math.floor(i / hopLength);
-            const maskIdx = Math.min(frameIdx, numFrames - 1);
-            // Apply mask
-            let gain = 1.0;
-            if (maskIdx < mask.length / this.config.n_mels) {
-                // Average mask across frequency bins for this frame
-                let maskSum = 0;
-                const startBin = maskIdx * this.config.n_mels;
-                for (let j = 0; j < this.config.n_mels; j++) {
-                    maskSum += mask[startBin + j];
-                }
-                gain = maskSum / this.config.n_mels;
-            }
-            // Apply gain with minimum threshold
-            output[i] = audio[i] * Math.max(0.02, gain);
-        }
-        // Apply fade-in/out to prevent clicks
-        const fadeLength = Math.min(256, output.length / 10);
-        for (let i = 0; i < fadeLength; i++) {
-            const fade = i / fadeLength;
-            output[i] *= fade;
-            output[output.length - 1 - i] *= fade;
-        }
-        return output;
-    }
-    /**
-     * Extract mel-spectrogram features
-     */
-    async extractMelFeatures(audio) {
-        if (!this.config)
-            throw new Error("Config not loaded");
-        // Simplified feature extraction
-        // In production, use proper STFT + Mel filterbank
-        const frameLength = this.config.n_fft;
-        const hopLength = this.config.hop_length;
-        const numFrames = Math.floor((audio.length - frameLength) / hopLength) + 1;
-        const features = [];
-        for (let i = 0; i < numFrames; i++) {
-            const start = i * hopLength;
-            const frame = audio.slice(start, start + frameLength);
-            // Compute mel bins (simplified)
-            const frameFeatures = [];
-            for (let j = 0; j < this.config.n_mels; j++) {
-                const melBin = this.computeMelBin(frame, j);
-                frameFeatures.push(melBin);
-            }
-            features.push(frameFeatures);
-        }
-        return features;
-    }
-    /**
-     * Compute mel bin (simplified)
-     */
-    computeMelBin(frame, binIndex) {
-        const start = Math.floor((binIndex / this.config.n_mels) * frame.length);
-        const end = Math.floor(((binIndex + 1) / this.config.n_mels) * frame.length);
-        let sum = 0;
-        for (let i = start; i < end && i < frame.length; i++) {
-            sum += Math.abs(frame[i]);
-        }
-        const avg = sum / (end - start);
-        // Convert to log scale (dB-like)
-        return Math.log10(avg + 1e-8) * 10;
-    }
-    /**
-     * Create sequences for LSTM input
-     */
-    createSequences(features, seqLength) {
-        const sequences = [];
-        for (let i = 0; i <= features.length - seqLength; i++) {
-            sequences.push(features.slice(i, i + seqLength));
-        }
-        // If not enough frames, pad with last frame
-        if (sequences.length === 0 && features.length > 0) {
-            const paddedSeq = [];
-            for (let i = 0; i < seqLength; i++) {
-                paddedSeq.push(features[Math.min(i, features.length - 1)]);
-            }
-            sequences.push(paddedSeq);
-        }
-        return sequences;
-    }
-    /**
-     * Reset processing state (call when switching audio streams)
-     */
-    reset() {
-        this.prevMask = null;
-        this.processingQueue = [];
-    }
-    /**
-     * Get processing latency
-     */
-    getLatency() {
-        if (!this.config)
-            return 0;
-        // Approximate latency in milliseconds
-        const bufferLatency = (this.config.n_fft / this.config.sample_rate) * 1000;
-        const processingLatency = 10; // Model inference ~10ms
-        return bufferLatency + processingLatency;
-    }
-}
-exports.UltimateMLNoiseSuppressor = UltimateMLNoiseSuppressor;
-// Export for use in AudioWorklet
-exports.default = UltimateMLNoiseSuppressor;