fix: delay types

Author: modpotato

src/lib/audioProcessor.ts

@@ -464,8 +464,12 @@ export function findDelayLinearPhase(x: RawAudioData, y: RawAudioData, freq_band
   const x_mono = x.samples;
   const y_mono = y.samples;
 
+  // For codec delay detection, we want to look at the first few seconds
+  // where the codec delays are most apparent
+  const INITIAL_WINDOW = x.sampleRate * 5; // 5 seconds for initial codec delay detection
+  
   // Ensure equal-sized chunks for initial processing
-  const minLen = Math.min(x_mono.length, y_mono.length);
+  const minLen = Math.min(x_mono.length, y_mono.length, INITIAL_WINDOW);
   const x_slice = x_mono.subarray(0, minLen);
   const y_slice = y_mono.subarray(0, minLen);
 
@@ -476,43 +480,24 @@ export function findDelayLinearPhase(x: RawAudioData, y: RawAudioData, freq_band
   const delays: number[] = [];
   const weights: number[] = [];
 
-  // Max length for individual band signals when performing cross-correlation
-  // 2 seconds is usually sufficient for finding codec/metadata delays
-  const MAX_LEN_XCORR_BAND = x.sampleRate * 2; // 2 seconds at signal's sample rate
-
   // Process each frequency band
   for (let i = 0; i < freq_bands; i++) {
-    const xb_full = x_bands[i];
-    const yb_full = y_bands[i];
-    
-    // For cross-correlation, we can use a shorter window to focus on transients
-    // but we'll use the full signal for coherence calculation
-    let xb_for_xcorr = xb_full;
-    let yb_for_xcorr = yb_full;
-
-    if (xb_full.length > MAX_LEN_XCORR_BAND) {
-      xb_for_xcorr = xb_full.subarray(0, MAX_LEN_XCORR_BAND);
-    }
-    if (yb_full.length > MAX_LEN_XCORR_BAND) {
-      yb_for_xcorr = yb_full.subarray(0, MAX_LEN_XCORR_BAND);
-    }
-    
-    // Ensure they are the same length for cross-correlation
-    const commonLenXcorr = Math.min(xb_for_xcorr.length, yb_for_xcorr.length);
-    if (commonLenXcorr === 0) {
-      console.log(`Band ${i+1}/${freq_bands}: Skipped due to zero length for xcorr.`);
-      delays.push(0);
-      weights.push(0);
-      continue;
-    }
+    const xb = x_bands[i];
+    const yb = y_bands[i];
 
     // Calculate cross-correlation using FFT
-    const correlationResult = calculateCrossCorrelation(xb_for_xcorr, yb_for_xcorr);
+    const correlationResult = calculateCrossCorrelation(xb, yb);
 
     // Find the delay that maximizes correlation
     let maxIdx = 0;
     let maxVal = -Infinity;
-    for (let j = 0; j < correlationResult.length; j++) {
+    
+    // Focus on the center portion of the correlation result
+    // This helps avoid false matches at the edges
+    const centerStart = Math.floor(correlationResult.length * 0.25);
+    const centerEnd = Math.floor(correlationResult.length * 0.75);
+    
+    for (let j = centerStart; j < centerEnd; j++) {
       if (correlationResult[j] > maxVal) {
         maxVal = correlationResult[j];
         maxIdx = j;
@@ -523,8 +508,8 @@ export function findDelayLinearPhase(x: RawAudioData, y: RawAudioData, freq_band
     const mid = Math.floor(correlationResult.length / 2);
     const delay = maxIdx - mid;
 
-    // Calculate phase coherence using the full band signals for better accuracy
-    const coherence = getPhaseCoherence(xb_full, yb_full);
+    // Calculate phase coherence for weighting
+    const coherence = getPhaseCoherence(xb, yb);
 
     delays.push(delay);
     weights.push(coherence);
@@ -548,8 +533,12 @@ export function findDelayLinearPhase(x: RawAudioData, y: RawAudioData, freq_band
 
   const finalDelayUncapped = Math.round(weightedSum / weightSum);
 
-  // Cap the final delay to a reasonable maximum (e.g., 2 seconds) for codec/metadata delays
-  const MAX_EXPECTED_DELAY_SAMPLES = x.sampleRate * 2; // 2 seconds
+  // Cap the final delay to a reasonable maximum for codec delays
+  // Different codecs have different typical delays:
+  // - MP3: ~576 samples
+  // - AAC/M4A: ~1024 samples
+  // - Opus: ~120 samples
+  const MAX_EXPECTED_DELAY_SAMPLES = x.sampleRate * 0.1; // 100ms should cover most codec delays
   let finalDelay = finalDelayUncapped;
   if (Math.abs(finalDelayUncapped) > MAX_EXPECTED_DELAY_SAMPLES) {
     console.warn(`Calculated delay (${finalDelayUncapped} samples) exceeds max expected (${MAX_EXPECTED_DELAY_SAMPLES} samples). Capping.`);