@siteed/expo-audio-stream 1.17.0 → 2.0.1

package/build/workers/InlineFeaturesExtractor.web.js

@@ -1,21 +1,494 @@
+// packages/expo-audio-stream/src/workers/InlineFeaturesExtractor.web.tsx
 export const InlineFeaturesExtractor = `
+// Constants
+const N_FFT = 1024;  // Default FFT size
+const MAX_FFT_SIZE = 8192;  // Maximum FFT size to prevent memory issues
+const N_CHROMA = 12;
+
+// FFT Implementation with normalized Hann window
+function FFT(n) {
+    this.n = n;
+    this.cosTable = new Float32Array(n / 2);
+    this.sinTable = new Float32Array(n / 2);
+    this.hannWindow = new Float32Array(n);
+    
+    // Match Android implementation with precomputed tables
+    const normalizationFactor = Math.sqrt(2.0 / n);
+    for (var i = 0; i < n / 2; i++) {
+        this.cosTable[i] = Math.cos(2.0 * Math.PI * i / n);
+        this.sinTable[i] = Math.sin(2.0 * Math.PI * i / n);
+    }
+    
+    // Precompute normalized Hann window to match Android
+    for (var i = 0; i < n; i++) {
+        this.hannWindow[i] = normalizationFactor * 0.5 * (1 - Math.cos(2.0 * Math.PI * i / (n - 1)));
+    }
+}
+
+FFT.prototype.transform = function(data) {
+    const n = data.length;
+    
+    // Validate input length is power of 2
+    if ((n & (n - 1)) !== 0) {
+        throw new Error('FFT length must be power of 2');
+    }
+
+    // Use iterative bit reversal instead of recursive
+    const bitReversedIndices = new Uint32Array(n);
+    for (let i = 0; i < n; i++) {
+        let reversed = 0;
+        let j = i;
+        let bits = Math.log2(n);
+        while (bits--) {
+            reversed = (reversed << 1) | (j & 1);
+            j >>= 1;
+        }
+        bitReversedIndices[i] = reversed;
+    }
+
+    // Apply bit reversal
+    for (let i = 0; i < n; i++) {
+        const j = bitReversedIndices[i];
+        if (i < j) {
+            const temp = data[i];
+            data[i] = data[j];
+            data[j] = temp;
+        }
+    }
+
+    // Iterative FFT computation with optimized memory usage
+    for (let step = 1; step < n; step <<= 1) {
+        const jump = step << 1;
+        const angleStep = Math.PI / step;
+
+        for (let group = 0; group < n; group += jump) {
+            for (let pair = group; pair < group + step; pair++) {
+                const match = pair + step;
+                const angle = angleStep * (pair - group);
+                
+                const currentCos = Math.cos(angle);
+                const currentSin = Math.sin(angle);
+
+                const real = currentCos * data[match] - currentSin * data[match + 1];
+                const imag = currentCos * data[match + 1] + currentSin * data[match];
+
+                data[match] = data[pair] - real;
+                data[match + 1] = data[pair + 1] - imag;
+                data[pair] += real;
+                data[pair + 1] += imag;
+            }
+        }
+    }
+};
+
+// Add realInverse method
+FFT.prototype.realInverse = function(powerSpectrum, output) {
+    const n = powerSpectrum.length;
+    const complexData = new Float32Array(n * 2);
+    
+    // Copy power spectrum to complex format
+    for (let i = 0; i < n/2 + 1; i++) {
+        complexData[2 * i] = powerSpectrum[i];
+        if (2 * i + 1 < complexData.length) {
+            complexData[2 * i + 1] = 0;
+        }
+    }
+    
+    // Conjugate for inverse FFT
+    for (let i = 0; i < n; i++) {
+        if (2 * i + 1 < complexData.length) {
+            complexData[2 * i + 1] = -complexData[2 * i + 1];
+        }
+    }
+    
+    this.transform(complexData);
+    
+    // Copy real part to output and scale
+    for (let i = 0; i < n; i++) {
+        output[i] = complexData[2 * i] / n;
+    }
+};
+
+// Add helper functions to match Android
+function nextPowerOfTwo(n) {
+    let value = 1;
+    while (value < n) {
+        value *= 2;
+    }
+    return value;
+}
+
+function applyHannWindow(samples) {
+    const output = new Float32Array(samples.length);
+    for (let i = 0; i < samples.length; i++) {
+        const multiplier = 0.5 * (1 - Math.cos(2 * Math.PI * i / (samples.length - 1)));
+        output[i] = samples[i] * multiplier;
+    }
+    return output;
+}
+
+// Update spectral feature computation to match Android
+function computeSpectralFeatures(segment, sampleRate, featureOptions = {}) {
+    try {
+        // Early return if no spectral features are requested
+        if (!featureOptions.spectralCentroid && 
+            !featureOptions.spectralFlatness && 
+            !featureOptions.spectralRollOff && 
+            !featureOptions.spectralBandwidth &&
+            !featureOptions.magnitudeSpectrum) {
+            return {
+                centroid: 0,
+                flatness: 0,
+                rollOff: 0,
+                bandwidth: 0,
+                magnitudeSpectrum: []
+            };
+        }
+
+        // Ensure we have valid data
+        if (!segment || segment.length === 0) {
+            throw new Error('Invalid segment data');
+        }
+
+        // Process in fixed-size chunks
+        const chunkSize = N_FFT;
+        const numChunks = Math.ceil(segment.length / chunkSize);
+        
+        let results = {
+            centroid: 0,
+            flatness: 0,
+            rollOff: 0,
+            bandwidth: 0,
+            magnitudeSpectrum: new Float32Array(N_FFT / 2 + 1).fill(0)
+        };
+        
+        let validChunks = 0;
+        
+        // Iterate through chunks
+        for (let i = 0; i < numChunks; i++) {
+            const start = i * chunkSize;
+            const end = Math.min(start + chunkSize, segment.length);
+            const chunk = segment.slice(start, end);
+            
+            if (chunk.length < N_FFT / 4) continue; // Skip very small chunks
+
+            // Process the chunk
+            const paddedChunk = new Float32Array(N_FFT);
+            paddedChunk.set(applyHannWindow(chunk));
+
+            const fft = new FFT(N_FFT);
+            fft.transform(paddedChunk);
+
+            // Calculate magnitude spectrum
+            const chunkMagnitudeSpectrum = new Float32Array(N_FFT / 2 + 1);
+            let hasSignal = false;
+            
+            for (let j = 0; j < N_FFT / 2; j++) {
+                const re = paddedChunk[2 * j];
+                const im = paddedChunk[2 * j + 1];
+                const magnitude = Math.sqrt(re * re + im * im);
+                chunkMagnitudeSpectrum[j] = magnitude;
+                if (magnitude > Number.EPSILON) hasSignal = true;
+            }
+            
+            if (!hasSignal) continue;
+            validChunks++;
+
+            // Accumulate results
+            if (featureOptions.spectralCentroid) {
+                const centroid = computeSpectralCentroid(chunkMagnitudeSpectrum, sampleRate);
+                if (!isNaN(centroid)) results.centroid += centroid;
+            }
+            
+            if (featureOptions.spectralFlatness) {
+                const flatness = computeSpectralFlatness(chunkMagnitudeSpectrum);
+                if (!isNaN(flatness)) results.flatness += flatness;
+            }
+            
+            if (featureOptions.spectralRollOff) {
+                const rolloff = computeSpectralRollOff(chunkMagnitudeSpectrum, sampleRate);
+                if (!isNaN(rolloff)) results.rollOff += rolloff;
+            }
+            
+            if (featureOptions.spectralBandwidth && !isNaN(results.centroid)) {
+                const bandwidth = computeSpectralBandwidth(chunkMagnitudeSpectrum, sampleRate, results.centroid);
+                if (!isNaN(bandwidth)) results.bandwidth += bandwidth;
+            }
+            
+            if (featureOptions.magnitudeSpectrum) {
+                for (let j = 0; j < results.magnitudeSpectrum.length; j++) {
+                    results.magnitudeSpectrum[j] += chunkMagnitudeSpectrum[j];
+                }
+            }
+        }
+
+        // Average the accumulated results
+        if (validChunks > 0) {
+            results.centroid /= validChunks;
+            results.flatness /= validChunks;
+            results.rollOff /= validChunks;
+            results.bandwidth /= validChunks;
+            
+            if (featureOptions.magnitudeSpectrum) {
+                for (let i = 0; i < results.magnitudeSpectrum.length; i++) {
+                    results.magnitudeSpectrum[i] /= validChunks;
+                }
+            }
+        }
+
+        return results;
+    } catch (error) {
+        console.error('[Worker] Spectral feature computation error:', error);
+        return {
+            centroid: 0,
+            flatness: 0,
+            rollOff: 0,
+            bandwidth: 0,
+            magnitudeSpectrum: []
+        };
+    }
+}
+
+function computeSpectralCentroid(magnitudeSpectrum, sampleRate) {
+    const sum = magnitudeSpectrum.reduce((a, b) => a + (b || 0), 0);
+    if (sum <= Number.EPSILON) return 0;
+    
+    const weightedSum = magnitudeSpectrum.reduce((acc, value, index) => 
+        acc + (index * (sampleRate / N_FFT) * (value || 0)), 0);
+    
+    return weightedSum / sum;
+}
+
+function computeSpectralFlatness(powerSpectrum) {
+    // Add small epsilon to avoid log(0)
+    const epsilon = Number.EPSILON;
+    const validSpectrum = powerSpectrum.map(v => Math.max(v, epsilon));
+    
+    const geometricMean = Math.exp(
+        validSpectrum
+            .map(v => Math.log(v))
+            .reduce((a, b) => a + b) / validSpectrum.length
+    );
+    
+    const arithmeticMean =
+        validSpectrum.reduce((a, b) => a + b) / validSpectrum.length;
+        
+    return geometricMean / arithmeticMean;
+}
+
+function computeSpectralRollOff(magnitudeSpectrum, sampleRate) {
+    const totalEnergy = magnitudeSpectrum.reduce((a, b) => a + b, 0);
+    const rollOffThreshold = totalEnergy * 0.85;
+    let cumulativeEnergy = 0;
+
+    for (let i = 0; i < magnitudeSpectrum.length; i++) {
+        cumulativeEnergy += magnitudeSpectrum[i];
+        if (cumulativeEnergy >= rollOffThreshold) {
+            return (i / magnitudeSpectrum.length) * (sampleRate / 2);
+        }
+    }
+
+    return 0;
+}
+
+function computeSpectralBandwidth(magnitudeSpectrum, sampleRate, centroid) {
+    const sum = magnitudeSpectrum.reduce((a, b) => a + (b || 0), 0);
+    if (sum <= Number.EPSILON) return 0;
+
+    const weightedSum = magnitudeSpectrum.reduce(
+        (acc, value, index) => {
+            const freq = index * sampleRate / (2 * magnitudeSpectrum.length);
+            return acc + (value || 0) * Math.pow(freq - centroid, 2);
+        }, 0
+    );
+
+    return Math.sqrt(weightedSum / sum);
+}
+
+function computeChroma(segmentData, sampleRate) {
+    // Ensure we have valid input data
+    if (!segmentData || segmentData.length === 0) {
+        return new Array(N_CHROMA).fill(0);
+    }
+
+    const fftLength = nextPowerOfTwo(Math.max(segmentData.length, N_FFT));
+    const windowed = applyHannWindow(segmentData);
+    const padded = new Float32Array(fftLength);
+    padded.set(windowed.slice(0, Math.min(windowed.length, fftLength)));
+
+    const fft = new FFT(fftLength);
+    try {
+        fft.transform(padded);
+    } catch (e) {
+        console.error('[Worker] FFT transform failed in chromagram:', e);
+        return new Array(N_CHROMA).fill(0);
+    }
+
+    const chroma = new Float32Array(N_CHROMA).fill(0);
+    const freqsPerBin = sampleRate / fftLength;
+    let totalEnergy = 0;
+
+    // First pass: compute magnitudes and total energy
+    for (let i = 0; i < fftLength / 2; i++) {
+        const freq = i * freqsPerBin;
+        if (freq > 20) { // Only consider frequencies above 20 Hz
+            const re = padded[2 * i];
+            const im = padded[2 * i + 1] || 0;
+            const magnitude = Math.sqrt(re * re + im * im);
+            
+            if (magnitude > Number.EPSILON) {
+                // Use a more stable pitch class calculation
+                const midiNote = 69 + 12 * Math.log2(freq / 440.0);
+                const pitchClass = Math.round(midiNote) % 12;
+                
+                if (pitchClass >= 0 && pitchClass < 12) {
+                    chroma[pitchClass] += magnitude;
+                    totalEnergy += magnitude;
+                }
+            }
+        }
+    }
+
+    // Normalize chroma values only if we have energy
+    if (totalEnergy > Number.EPSILON) {
+        for (let i = 0; i < N_CHROMA; i++) {
+            chroma[i] = chroma[i] / totalEnergy;
+        }
+    }
+
+    // Convert to regular array and ensure no NaN values
+    return Array.from(chroma, v => isNaN(v) ? 0 : v);
+}
+
+function extractHNR(segmentData) {
+    const frameSize = segmentData.length;
+    const autocorrelation = new Float32Array(frameSize);
+
+    // Compute the autocorrelation iteratively
+    for (let i = 0; i < frameSize; i++) {
+        let sum = 0;
+        for (let j = 0; j < frameSize - i; j++) {
+            sum += segmentData[j] * segmentData[j + i];
+        }
+        autocorrelation[i] = sum;
+    }
+
+    // Find the maximum autocorrelation value iteratively
+    let maxAutocorrelation = -Infinity;
+    for (let i = 1; i < autocorrelation.length; i++) {
+        if (autocorrelation[i] > maxAutocorrelation) {
+            maxAutocorrelation = autocorrelation[i];
+        }
+    }
+
+    // Compute the HNR
+    return autocorrelation[0] !== 0
+        ? 10 * Math.log10(maxAutocorrelation / (autocorrelation[0] - maxAutocorrelation))
+        : 0;
+}
+
+function estimatePitch(segment, sampleRate) {
+    // Early validation
+    if (!segment || segment.length < 2 || !sampleRate) return 0;
+
+    try {
+        // Apply Hann window
+        const windowed = applyHannWindow(segment);
+
+        // Pad for FFT
+        const fftLength = nextPowerOfTwo(segment.length * 2);
+        const padded = new Float32Array(fftLength);
+        padded.set(windowed);
+
+        // Perform FFT
+        const fft = new FFT(fftLength);
+        fft.transform(padded);
+
+        // Compute power spectrum
+        const powerSpectrum = new Float32Array(fftLength / 2 + 1);
+        for (let i = 0; i <= fftLength / 2; i++) {
+            const re = padded[2 * i];
+            const im = padded[2 * i + 1] || 0;
+            powerSpectrum[i] = re * re + im * im;
+        }
+
+        // Find peak frequency
+        let maxPower = 0;
+        let peakIndex = 0;
+        const minFreq = 50;  // Minimum frequency to consider (Hz)
+        const maxFreq = 1000; // Maximum frequency to consider (Hz)
+        const minBin = Math.floor(minFreq * fftLength / sampleRate);
+        const maxBin = Math.ceil(maxFreq * fftLength / sampleRate);
+
+        for (let i = minBin; i <= maxBin; i++) {
+            if (powerSpectrum[i] > maxPower) {
+                maxPower = powerSpectrum[i];
+                peakIndex = i;
+            }
+        }
+
+        // Convert peak index to frequency
+        const fundamentalFreq = peakIndex * sampleRate / fftLength;
+
+        // Return 0 if the detected frequency is outside reasonable bounds
+        return (fundamentalFreq >= minFreq && fundamentalFreq <= maxFreq) ? 
+            fundamentalFreq : 0;
+
+    } catch (error) {
+        console.error('[Worker] Pitch estimation error:', error);
+        return 0;
+    }
+}
+
 // Unique ID counter
 let uniqueIdCounter = 0
-let accumulatedDataPoints = [] // Move outside message handler
-let lastEmitTime = Date.now() // Move outside message handler
+let accumulatedDataPoints = []
+let lastEmitTime = Date.now()
 
 self.onmessage = function (event) {
+    // Check if this is a reset command
+    if (event.data.command === 'resetCounter') {
+        uniqueIdCounter = event.data.startCounterFrom || 0;
+        console.log('[Worker] Reset counter to', uniqueIdCounter);
+        return; // Exit early, don't process audio
+    }
+
+    // Regular audio processing
     const {
-        channelData, // this is only the newly recorded data when live recording.
+        channelData,
         sampleRate,
-        pointsPerSecond,
+        segmentDurationMs,
         algorithm,
         bitDepth,
         fullAudioDurationMs,
         numberOfChannels,
         features: _features,
-        intervalAnalysis = 500, // Use intervalAnalysis instead of interval
+        intervalAnalysis = 500,
+        enableLogging,
+        resetCounter,
+        startCounterFrom,
     } = event.data
+
+    // Also handle reset as part of regular message
+    if (resetCounter) {
+        uniqueIdCounter = startCounterFrom || 0;
+    }
+
+    const subChunkStartTime = fullAudioDurationMs / 1000
+
+    
+    // Create a simple logger that only logs when enabled
+    const logger = enableLogging ? {
+        debug: (...args) => console.debug('[Worker]', ...args),
+        log: (...args) => console.log('[Worker]', ...args),
+        error: (...args) => console.error('[Worker]', ...args)
+    } : {
+        debug: () => {},
+        log: () => {},
+        error: () => {}
+    }
+    console.log('[Worker] START Feature Extractor - hasData: ' + (event.data ? true : false) + ', channelData: ' + (event.data.channelData ? event.data.channelData.length : 0) + ', fullAudioDurationMs: ' + (event.data.fullAudioDurationMs || 0) + ', sampleRate: ' + (event.data.sampleRate || 0) + ', segmentDurationMs: ' + (event.data.segmentDurationMs || 0) + ', algorithm: ' + (event.data.algorithm || 'none') + ', bitDepth: ' + (event.data.bitDepth || 0) + ', numberOfChannels: ' + (event.data.numberOfChannels || 0) + ', features: ' + (event.data.features ? Object.keys(event.data.features).length : 0) + ', intervalAnalysis: ' + (event.data.intervalAnalysis || 0) + ', dataKeys: ' + (event.data ? Object.keys(event.data).join(',') : ''));
+    
     const features = _features || {}
 
     const SILENCE_THRESHOLD = 0.01
@@ -89,205 +562,228 @@ self.onmessage = function (event) {
         return [] // TODO implement
     }
 
-    const extractHNR = (segmentData) => {
-        const frameSize = segmentData.length
-        const autocorrelation = new Float32Array(frameSize)
+    /**
+     * Creates a features object based on requested features
+     */
+    function createFeaturesObject(
+        features,
+        maxAmp,
+        rms,
+        sumSquares,
+        zeroCrossings,
+        remainingSamples,
+        spectralFeatures,
+        channelData,
+        startIdx,
+        endIdx,
+        sampleRate
+    ) {
+        // If no features are requested, return undefined
+        if (!Object.values(features).some(function(v) { return v; })) {
+            return undefined;
+        }
 
-        // Compute the autocorrelation of the segment data
-        for (let i = 0; i < frameSize; i++) {
-            let sum = 0
-            for (let j = 0; j < frameSize - i; j++) {
-                sum += segmentData[j] * segmentData[j + i]
-            }
-            autocorrelation[i] = sum
+        const result = {};
+        
+        if (features.energy) {
+            result.energy = sumSquares;
         }
+        if (features.rms) {
+            result.rms = rms;
+        }
+        // Always include min/max amplitude if any features are requested
+        result.minAmplitude = -maxAmp;
+        result.maxAmplitude = maxAmp;
+        
+        if (features.zcr) {
+            result.zcr = zeroCrossings / remainingSamples;
+        }
+        if (features.spectralCentroid) {
+            result.spectralCentroid = spectralFeatures.centroid;
+        }
+        if (features.spectralFlatness) {
+            result.spectralFlatness = spectralFeatures.flatness;
+        }
+        if (features.spectralRolloff) {
+            result.spectralRolloff = spectralFeatures.rollOff;
+        }
+        if (features.spectralBandwidth) {
+            result.spectralBandwidth = spectralFeatures.bandwidth;
+        }
+        if (features.chromagram) {
+            result.chromagram = computeChroma(channelData.slice(startIdx, endIdx), sampleRate);
+        }
+        if (features.hnr) {
+            result.hnr = extractHNR(channelData.slice(startIdx, endIdx));
+        }
+        if (features.pitch) {
+            result.pitch = estimatePitch(channelData.slice(startIdx, endIdx), sampleRate);
+        }
+        
+        return result;
+    }
 
-        // Find the maximum autocorrelation value (excluding the zero lag)
-        const maxAutocorrelation = Math.max(...autocorrelation.subarray(1))
+    function extractWaveform(
+        channelData,
+        sampleRate,
+        segmentDurationMs
+    ) {
+        const logger = enableLogging ? {
+            debug: (...args) => console.debug('[Worker]', ...args),
+            log: (...args) => console.log('[Worker]', ...args),
+            error: (...args) => console.error('[Worker]', ...args)
+        } : {
+            debug: () => {},
+            log: () => {},
+            error: () => {}
+        }
 
-        // Compute the HNR
-        return autocorrelation[0] !== 0
-            ? 10 *
-                  Math.log10(
-                      maxAutocorrelation /
-                          (autocorrelation[0] - maxAutocorrelation)
-                  )
-            : 0
-    }
+        // Calculate amplitude range
+        let min = Infinity
+        let max = -Infinity
+        for (let i = 0; i < channelData.length; i++) {
+            min = Math.min(min, channelData[i])
+            max = Math.max(max, channelData[i])
+        }
 
-    const extractWaveform = (
-        channelData, // Float32Array
-        sampleRate, // number
-        pointsPerSecond, // number
-        algorithm // string
-    ) => {
         const totalSamples = channelData.length
-        const segmentDuration = totalSamples / sampleRate
-        const totalPoints = Math.max(
-            Math.ceil(segmentDuration * pointsPerSecond),
-            1
-        )
-        const pointInterval = Math.ceil(totalSamples / totalPoints)
-        const dataPoints = []
-        let minAmplitude = Infinity
-        let maxAmplitude = -Infinity
-        let silenceStart = null
-        let lastSpeechEnd = -Infinity
-        let isSpeech = false
-
-        const expectedPoints = segmentDuration * pointsPerSecond
-        const samplesPerPoint = Math.ceil(channelData.length / expectedPoints)
+        const durationMs = (totalSamples / sampleRate) * 1000
+        
+        // Calculate fixed segment sizes
+        const samplesPerSegment = Math.floor(sampleRate * (segmentDurationMs / 1000));
+        const numPoints = Math.floor(totalSamples / samplesPerSegment);
+        const remainingSamples = totalSamples % samplesPerSegment;
 
-        for (let i = 0; i < expectedPoints; i++) {
-            const start = i * samplesPerPoint
-            const end = Math.min(start + samplesPerPoint, totalSamples)
+        const dataPoints = []
 
+        // Process full segments
+        for (let i = 0; i < numPoints; i++) {
+            const startIdx = i * samplesPerSegment
+            const endIdx = startIdx + samplesPerSegment
+            
             let sumSquares = 0
+            let maxAmp = 0
             let zeroCrossings = 0
-            let prevValue = channelData[start]
-            let localMinAmplitude = Infinity
-            let localMaxAmplitude = -Infinity
-            let hasNonZeroValue = false
 
-            // compute values for the segment
-            for (let j = start; j < end; j++) {
+            // Calculate segment features
+            for (let j = startIdx; j < endIdx; j++) {
                 const value = channelData[j]
                 sumSquares += value * value
-                if (j > start && value * prevValue < 0) {
+                maxAmp = Math.max(maxAmp, Math.abs(value))
+                if (j > 0 && value * channelData[j - 1] < 0) {
                     zeroCrossings++
                 }
-                prevValue = value
-
-                // We need to keep absolute value otherwise we cannot visualize properly
-                const absValue = Math.abs(value)
-                localMinAmplitude = Math.min(localMinAmplitude, absValue)
-                localMaxAmplitude = Math.max(localMaxAmplitude, absValue)
-
-                if (value !== 0) {
-                    hasNonZeroValue = true
-                }
             }
 
-            // Post-processing checks
-            if (!hasNonZeroValue) {
-                // All values are zero
-                localMinAmplitude = 0
-                localMaxAmplitude = 0
+            const rms = Math.sqrt(sumSquares / samplesPerSegment)
+            const startTime = subChunkStartTime + (startIdx / sampleRate)
+            const endTime = subChunkStartTime + (endIdx / sampleRate)
+
+            var spectralFeatures = computeSpectralFeatures(channelData.slice(startIdx, endIdx), sampleRate, features);
+
+            const dataPoint = {
+                id: uniqueIdCounter++,
+                amplitude: maxAmp,
+                rms,
+                startTime,
+                endTime,
+                dB: 20 * Math.log10(rms + 1e-6),
+                silent: rms < 0.01,
+                startPosition: startIdx * 2,
+                endPosition: endIdx * 2,
+                samples: samplesPerSegment,
             }
 
-            const rms = Math.sqrt(sumSquares / (end - start))
-            minAmplitude = Math.min(minAmplitude, localMinAmplitude)
-            maxAmplitude = Math.max(maxAmplitude, localMaxAmplitude)
+            // Extract features if any are requested
+            const extractedFeatures = createFeaturesObject(
+                features,
+                maxAmp,
+                rms,
+                sumSquares,
+                zeroCrossings,
+                samplesPerSegment,
+                spectralFeatures,
+                channelData,
+                startIdx,
+                endIdx,
+                sampleRate
+            );
+            
+            if (extractedFeatures) {
+                dataPoint.features = extractedFeatures;
+            }
 
-            const energy = sumSquares
-            const zcr = zeroCrossings / (end - start)
+            dataPoints.push(dataPoint)
+        }
 
-            const silent = rms < SILENCE_THRESHOLD
-            const dB = 20 * Math.log10(rms)
+        // Handle remaining samples if they exist and are enough to process
+        if (remainingSamples > samplesPerSegment / 4) { // Only process if we have at least 1/4 of a segment
+            const startIdx = numPoints * samplesPerSegment
+            const endIdx = totalSamples
+            
+            let sumSquares = 0
+            let maxAmp = 0
+            let zeroCrossings = 0
 
-            if (silent) {
-                if (silenceStart === null) {
-                    silenceStart = start
-                } else if (start - silenceStart > MIN_SILENCE_DURATION) {
-                    // Silence detected for longer than the threshold, set amplitude to 0
-                    localMaxAmplitude = 0
-                    localMinAmplitude = 0
-                    isSpeech = false
-                }
-            } else {
-                silenceStart = null
-                if (
-                    !isSpeech &&
-                    start - lastSpeechEnd < SPEECH_INERTIA_DURATION
-                ) {
-                    isSpeech = true
+            for (let j = startIdx; j < endIdx; j++) {
+                const value = channelData[j]
+                sumSquares += value * value
+                maxAmp = Math.max(maxAmp, Math.abs(value))
+                if (j > 0 && value * channelData[j - 1] < 0) {
+                    zeroCrossings++
                 }
-                lastSpeechEnd = end
             }
 
-            const activeSpeech =
-                (rms > RMS_THRESHOLD && zcr > ZCR_THRESHOLD) ||
-                (isSpeech && start - lastSpeechEnd < SPEECH_INERTIA_DURATION)
-
-            if (activeSpeech) {
-                isSpeech = true
-                lastSpeechEnd = end
-            } else {
-                isSpeech = false
+            const rms = Math.sqrt(sumSquares / remainingSamples)
+            const startTime = startIdx / sampleRate;
+            const endTime = endIdx / sampleRate;
+
+            var spectralFeatures = computeSpectralFeatures(channelData.slice(startIdx, endIdx), sampleRate, features);
+
+            const dataPoint = {
+                id: uniqueIdCounter++,
+                amplitude: maxAmp,
+                rms,
+                startTime,
+                endTime,
+                dB: 20 * Math.log10(rms + 1e-6),
+                silent: rms < 0.01,
+                startPosition: startIdx * 2,
+                endPosition: endIdx * 2,
+                samples: remainingSamples,
             }
 
-            const bytesPerSample = bitDepth / 8
-            const startPosition = start * bytesPerSample * numberOfChannels // Calculate start position in bytes
-            const endPosition = end * bytesPerSample * numberOfChannels // Calculate end position in bytes
-
-            // Compute features
-            const segmentData = channelData.slice(start, end)
-            const mfcc = features.mfcc
-                ? extractMFCC(segmentData, sampleRate)
-                : []
-            const spectralCentroid = features.spectralCentroid
-                ? extractSpectralCentroid(segmentData, sampleRate)
-                : 0
-            const spectralFlatness = features.spectralFlatness
-                ? extractSpectralFlatness(segmentData)
-                : 0
-            const spectralRollOff = features.spectralRollOff
-                ? extractSpectralRollOff(segmentData, sampleRate)
-                : 0
-            const spectralBandwidth = features.spectralBandwidth
-                ? extractSpectralBandwidth(segmentData, sampleRate)
-                : 0
-            const chromagram = features.chromagram
-                ? extractChromagram(segmentData, sampleRate)
-                : []
-            const hnr = features.hnr ? extractHNR(segmentData) : 0
-
-            const peakAmp = Math.max(Math.abs(localMaxAmplitude), Math.abs(localMinAmplitude))
-            const newData = {
-                id: uniqueIdCounter++, // Assign unique ID and increment the counter
-                amplitude: algorithm === 'peak' ? peakAmp : rms,
-                activeSpeech,
-                dB,
-                silent,
-                features: {
-                    energy,
-                    rms,
-                    minAmplitude: localMinAmplitude,
-                    maxAmplitude: localMaxAmplitude,
-                    zcr,
-                    mfcc: [], // Placeholder for MFCC features
-                    spectralCentroid, // Computed spectral centroid
-                    spectralFlatness, // Computed spectral flatness
-                    spectralRollOff, // Computed spectral roll-off
-                    spectralBandwidth, // Computed spectral bandwidth
-                    chromagram, // Computed chromagram
-                    hnr, // Computed HNR
-                },
-                startTime: start / sampleRate,
-                endTime: end / sampleRate,
-                startPosition,
-                endPosition,
-                samples: end - start,
-                speaker: 0, // Assuming speaker detection is to be handled later
+            // Extract features if any are requested
+            const extractedFeatures = createFeaturesObject(
+                features,
+                maxAmp,
+                rms,
+                sumSquares,
+                zeroCrossings,
+                remainingSamples,
+                spectralFeatures,
+                channelData,
+                startIdx,
+                endIdx,
+                sampleRate
+            );
+            
+            if (extractedFeatures) {
+                dataPoint.features = extractedFeatures;
             }
 
-            dataPoints.push(newData)
+            dataPoints.push(dataPoint)
         }
 
         return {
-            pointsPerSecond,
-            amplitudeAlgorithm: algorithm,
-            durationMs: fullAudioDurationMs,
-            bitDepth,
-            samples: totalSamples,
-            numberOfChannels,
-            sampleRate,
+            durationMs,
             dataPoints,
-            amplitudeRange: {
-                min: minAmplitude,
-                max: maxAmplitude,
+            amplitudeRange: { min, max },
+            rmsRange: {
+                min: 0,
+                max: Math.max(Math.abs(min), Math.abs(max))
             },
-            speakerChanges: [], // Placeholder for future speaker detection logic
+            extractionTimeMs: Date.now() - lastEmitTime
         }
     }
 
@@ -295,33 +791,37 @@ self.onmessage = function (event) {
         const result = extractWaveform(
             channelData,
             sampleRate,
-            pointsPerSecond,
-            algorithm
+            segmentDurationMs
         )
 
-        // Accumulate data points
-        accumulatedDataPoints = accumulatedDataPoints.concat(result.dataPoints)
-        
-        const currentTime = Date.now()
-        const shouldEmitAccumulated = currentTime - lastEmitTime >= intervalAnalysis
-
-        if (shouldEmitAccumulated) {
-            self.postMessage({
-                command: 'features',
-                result: {
-                    ...result,
-                    dataPoints: accumulatedDataPoints
-                }
-            })
-            accumulatedDataPoints = [] // Reset accumulator
-            lastEmitTime = currentTime
-        }
+        // Send complete result immediately
+        self.postMessage({
+            command: 'features',
+            result: {
+                bitDepth,
+                samples: channelData.length,
+                numberOfChannels,
+                sampleRate,
+                segmentDurationMs,
+                durationMs: result.durationMs,
+                dataPoints: result.dataPoints,
+                amplitudeRange: result.amplitudeRange,
+                rmsRange: result.rmsRange,
+            }
+        })
     } catch (error) {
-        console.error('[AudioFeaturesExtractor] Error in processing', error)
-        self.postMessage({ error: error.message })
-    } finally {
-        // Do not close the worker so it can be re-used for subsequent messages
-        // self.close();
+        console.error('[Worker] Error', {
+            message: error.message,
+            stack: error.stack
+        });
+        
+        self.postMessage({ 
+            error: {
+                message: error.message,
+                stack: error.stack,
+                name: error.name
+            }
+        });
     }
 }
 `;