playlist-data-engine 1.1.0

package/dist/core/analysis/beat/TempoDetector.d.ts

@@ -0,0 +1,220 @@
+/**
+ * Tempo Detector
+ *
+ * Implements global tempo estimation using autocorrelation with perceptual weighting
+ * as described in Ellis, D.P.W. (2007) "Beat Tracking by Dynamic Programming"
+ *
+ * Reference: https://www.ee.columbia.edu/~dpwe/pubs/Ellis07-beattrack.pdf
+ * Section 3.2: Tempo Estimation
+ *
+ * ## Meter Resolution Options
+ *
+ * ### Octave Resolution (TPS2) - Duple Meter
+ * The perceptual weighting cannot distinguish between half/double tempo (e.g., 73 BPM vs 146 BPM).
+ * When `useOctaveResolution` is enabled, TPS2 (Tempo Period Strength for duple meter) is used
+ * to prefer tempos with strong half-period evidence. This improved accuracy from 77% to 84%
+ * in the original Ellis paper.
+ *
+ * ### Triple Meter Resolution (TPS3)
+ * When `useTripleMeter` is enabled, TPS3 is used to detect triple meter music (3/4, 6/8).
+ * The TPS3 formula combines the main tempo with its third-harmonic:
+ * `TPS3(τ) = TPS(τ) + 0.33×TPS(3τ) + 0.33×TPS(3τ-1) + 0.33×TPS(3τ+1)`
+ *
+ * Both options can be enabled simultaneously as they work independently.
+ */
+import type { TempoDetectorConfig, TempoEstimate } from '../../types/BeatMap.js';
+/**
+ * Tempo Detector
+ *
+ * Estimates the global tempo of an audio track using autocorrelation
+ * of the onset strength envelope with perceptual weighting.
+ *
+ * The algorithm follows Ellis 2007 Section 3.2:
+ * 1. Compute autocorrelation of the onset strength envelope
+ * 2. Apply perceptual weighting that biases toward 120 BPM
+ * 3. Find the peak that maximizes the weighted autocorrelation
+ * 4. (Optional) Use TPS2 for octave resolution to prevent half-tempo detection
+ * 5. (Optional) Use TPS3 for triple meter resolution to detect 3/4, 6/8 time signatures
+ *
+ * ## Octave Resolution (TPS2) - Duple Meter
+ * The perceptual weighting cannot distinguish between half/double tempo (e.g., 73 BPM vs 146 BPM).
+ * When `useOctaveResolution` is enabled, TPS2 (Tempo Period Strength for duple meter) is used
+ * to prefer tempos with strong half-period evidence. This improved accuracy from 77% to 84%
+ * in the original Ellis paper.
+ *
+ * ## Triple Meter Resolution (TPS3)
+ * When `useTripleMeter` is enabled, TPS3 is used to detect triple meter music (3/4, 6/8).
+ * The TPS3 formula combines the main tempo with its third-harmonic:
+ * `TPS3(τ) = TPS(τ) + 0.33×TPS(3τ) + 0.33×TPS(3τ-1) + 0.33×TPS(3τ+1)`
+ *
+ * Both TPS2 and TPS3 can be enabled simultaneously as they work independently.
+ *
+ * @see {@link https://www.ee.columbia.edu/~dpwe/pubs/Ellis07-beattrack.pdf|Ellis 2007 Paper}
+ *
+ * @example
+ * ```typescript
+ * const detector = new TempoDetector({
+ *   tempoCenter: 0.5,  // 120 BPM
+ *   tempoWidth: 1.4,   // octaves
+ *   useOctaveResolution: true,  // Enable TPS2 octave resolution
+ *   useTripleMeter: true,       // Enable TPS3 triple meter resolution
+ * });
+ *
+ * const estimate = detector.estimateTempo(onsetEnvelope, hopSize);
+ * console.log(`Estimated BPM: ${estimate.primaryBpm}`);
+ * ```
+ */
+export declare class TempoDetector {
+    private config;
+    /**
+     * Create a new Tempo Detector
+     *
+     * @param config - Configuration options (all optional, defaults provided)
+     */
+    constructor(config?: TempoDetectorConfig);
+    /**
+     * Estimate the tempo from an onset strength envelope
+     *
+     * Implements Ellis Section 3.2:
+     * - Autocorrelation with perceptual weighting
+     * - TPS2 for duple meter (octave resolution)
+     * - TPS3 for triple meter (3/4, 6/8 detection)
+     *
+     * ## Octave Resolution (TPS2) - Duple Meter
+     * When `useOctaveResolution` is enabled, this method uses TPS2
+     * (Tempo Period Strength for duple meter) to resolve tempo octave ambiguity.
+     *
+     * The problem: the perceptual weighting gives equal preference to tempos at
+     * half/double the true tempo (e.g., 73 BPM vs 146 BPM). This causes the
+     * algorithm to sometimes lock onto the wrong octave.
+     *
+     * The solution: TPS2 combines the main tempo with its half-period energy:
+     * `TPS2(τ) = TPS(τ) + 0.5×TPS(2τ) + 0.25×TPS(2τ-1) + 0.25×TPS(2τ+1)`
+     *
+     * Tempos with strong half-period evidence (indicating the correct octave)
+     * will have higher TPS2 scores, allowing us to prefer the true tempo.
+     *
+     * ## Triple Meter Resolution (TPS3)
+     * When `useTripleMeter` is enabled, this method uses TPS3 to detect triple
+     * meter music (3/4, 6/8 time signatures).
+     *
+     * The problem: for waltzes and triple meter music, the algorithm may lock onto
+     * a slower tempo (1 beat per 3 sub-beats) instead of the actual beat.
+     *
+     * The solution: TPS3 combines the main tempo with its third-period energy:
+     * `TPS3(τ) = TPS(τ) + 0.33×TPS(3τ) + 0.33×TPS(3τ-1) + 0.33×TPS(3τ+1)`
+     *
+     * Tempos with strong third-period evidence (indicating triple meter)
+     * will have higher TPS3 scores, allowing proper beat detection.
+     *
+     * ## Combining TPS2 and TPS3
+     * Both options can be enabled simultaneously. They run independently:
+     * - TPS2 runs first, resolving duple meter ambiguity
+     * - TPS3 runs second, resolving triple meter ambiguity
+     *
+     * @param onsetEnvelope - Onset strength envelope from OSE calculation
+     * @param hopSizeSeconds - Hop size in seconds (time between envelope frames)
+     * @returns Tempo estimate with primary/secondary BPM and meter info
+     */
+    estimateTempo(onsetEnvelope: Float32Array, hopSizeSeconds: number): TempoEstimate;
+    /**
+     * Get the current configuration
+     *
+     * @returns The current configuration
+     */
+    getConfig(): Required<TempoDetectorConfig>;
+    /**
+     * Compute autocorrelation of the onset strength envelope
+     *
+     * TPS(τ) = Σ O(t) × O(t-τ)
+     *
+     * @param envelope - Onset strength envelope
+     * @param minLag - Minimum lag to compute
+     * @param maxLag - Maximum lag to compute
+     * @returns Autocorrelation values and lag range
+     */
+    private computeAutocorrelation;
+    /**
+     * Apply perceptual weighting to autocorrelation values
+     *
+     * W(τ) = exp(-0.5 × (log₂(τ/τ₀) / στ)²)
+     *
+     * Where:
+     * - τ₀ = tempoCenter (default 0.5s = 120 BPM)
+     * - στ = tempoWidth (default 1.4 octaves)
+     *
+     * This biases toward human tempo perception centered at 120 BPM.
+     *
+     * @param autocorr - Autocorrelation values
+     * @param minLag - Minimum lag in the array
+     * @param hopSizeSeconds - Hop size in seconds
+     * @returns Weighted autocorrelation values
+     */
+    private applyPerceptualWeighting;
+    /**
+     * Find the index of the maximum value in an array
+     *
+     * @param array - Input array
+     * @param start - Start index (inclusive)
+     * @param end - End index (exclusive)
+     * @returns Index of maximum value
+     */
+    private findPeak;
+    /**
+     * Convert lag in frames to BPM
+     *
+     * BPM = 60 / (lag × hopSize)
+     *
+     * @param lag - Lag in frames
+     * @param hopSizeSeconds - Hop size in seconds
+     * @returns BPM
+     */
+    private lagToBpm;
+    /**
+     * Calculate TPS2 - Tempo Period Strength for duple meter
+     *
+     * TPS2(τ) = TPS(τ) + 0.5×TPS(2τ) + 0.25×TPS(2τ-1) + 0.25×TPS(2τ+1)
+     *
+     * This combines the main tempo with its half-time equivalent,
+     * improving accuracy from 77% to 84% per Ellis paper.
+     *
+     * @param autocorr - Autocorrelation values (indexed from minLag)
+     * @param primaryIdx - Index of primary tempo in autocorr array
+     * @returns TPS2 value
+     */
+    private calculateTPS2;
+    /**
+     * Calculate TPS3 - Tempo Period Strength for triple meter
+     *
+     * TPS3(τ) = TPS(τ) + 0.33×TPS(3τ) + 0.33×TPS(3τ-1) + 0.33×TPS(3τ+1)
+     *
+     * This combines the main tempo with its third-time equivalent,
+     * useful for detecting triple meter (3/4, 6/8).
+     *
+     * @param autocorr - Autocorrelation values
+     * @param primaryIdx - Index of primary tempo in autocorr array
+     * @returns TPS3 value
+     */
+    private calculateTPS3;
+    /**
+     * Get a default tempo estimate for edge cases
+     *
+     * @returns Default tempo estimate (120 BPM)
+     */
+    private getDefaultEstimate;
+    /**
+     * Get tempo candidates (for debugging/visualization)
+     *
+     * Returns the top N tempo candidates with their strengths.
+     *
+     * @param onsetEnvelope - Onset strength envelope
+     * @param hopSizeSeconds - Hop size in seconds
+     * @param count - Number of candidates to return
+     * @returns Array of BPM candidates with strengths
+     */
+    getTempoCandidates(onsetEnvelope: Float32Array, hopSizeSeconds: number, count?: number): Array<{
+        bpm: number;
+        strength: number;
+    }>;
+}
+//# sourceMappingURL=TempoDetector.d.ts.map

package/dist/core/analysis/beat/TempoDetector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TempoDetector.d.ts","sourceRoot":"","sources":["../../../../src/core/analysis/beat/TempoDetector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AA0BjF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,qBAAa,aAAa;IACtB,OAAO,CAAC,MAAM,CAAgC;IAE9C;;;;OAIG;gBACS,MAAM,GAAE,mBAAwB;IAI5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2CG;IACH,aAAa,CAAC,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,GAAG,aAAa;IAgHjF;;;;OAIG;IACH,SAAS,IAAI,QAAQ,CAAC,mBAAmB,CAAC;IAI1C;;;;;;;;;OASG;IACH,OAAO,CAAC,sBAAsB;IAoC9B;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,wBAAwB;IA4BhC;;;;;;;OAOG;IACH,OAAO,CAAC,QAAQ;IAchB;;;;;;;;OAQG;IACH,OAAO,CAAC,QAAQ;IAOhB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,aAAa;IAerB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,aAAa;IAerB;;;;OAIG;IACH,OAAO,CAAC,kBAAkB;IAU1B;;;;;;;;;OASG;IACH,kBAAkB,CACd,aAAa,EAAE,YAAY,EAC3B,cAAc,EAAE,MAAM,EACtB,KAAK,GAAE,MAAU,GAClB,KAAK,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;CAuC9C"}

package/dist/core/analysis/beat/TransientDetector.d.ts

@@ -0,0 +1,303 @@
+/**
+ * Transient Detector for Multi-Band Rhythm Detection
+ *
+ * Detects transients (onsets) in audio using band-specific detection strategies.
+ * Each frequency band uses a different algorithm optimized for its typical content:
+ *
+ * Part of the Procedural Rhythm Generation pipeline.
+ *
+ * @example
+ * ```typescript
+ * // Basic usage - detect transients from multi-band analysis
+ * const detector = new TransientDetector();
+ * const transients = detector.detect(multiBandResult);
+ *
+ * // Access all transients across all bands
+ * console.log(`Total transients: ${transients.transients.length}`);
+ *
+ * // Access transients by band
+ * for (const [band, bandTransients] of transients.bandTransients) {
+ *   console.log(`${band}: ${bandTransients.length} transients`);
+ * }
+ *
+ * // Custom configuration with higher threshold
+ * const customDetector = new TransientDetector({
+ *   baseThreshold: 0.5,         // Higher = fewer transients detected
+ *   adaptiveThresholding: true, // Adjust based on local energy
+ *   minTransientInterval: 0.03, // Minimum 30ms between transients
+ * });
+ * ```
+ */
+import type { MultiBandResult } from '../MultiBandAnalyzer.js';
+import type { FrequencyBand } from './utils/audioUtils.js';
+/**
+ * Detection method used for a transient
+ */
+export type TransientDetectionMethod = 'energy' | 'spectral_flux' | 'hfc';
+/**
+ * Band identifier type
+ */
+type BandName = 'low' | 'mid' | 'high';
+/**
+ * Per-band transient detection configuration.
+ * Each frequency band can have different settings optimized for its typical content.
+ */
+export interface BandTransientConfig {
+    /**
+     * Threshold for peak detection (0.0 - 1.0).
+     * Higher values are more selective (fewer transients detected).
+     */
+    threshold: number;
+    /**
+     * Minimum interval between transients in seconds (buffer window).
+     * Within this window, only the strongest transient wins (Non-Maximum Suppression).
+     */
+    minInterval: number;
+    /**
+     * Whether to use adaptive thresholding for this band.
+     * Adjusts threshold based on local energy/density of the signal.
+     */
+    adaptiveThresholding: boolean;
+}
+/**
+ * Per-band transient detection configuration overrides.
+ * Each band can optionally override the global defaults.
+ */
+export interface BandTransientConfigOverrides {
+    /** Low frequency band (20-500 Hz) - kick drums, bass */
+    low?: Partial<BandTransientConfig>;
+    /** Mid frequency band (500-2000 Hz) - vocals, snare body */
+    mid?: Partial<BandTransientConfig>;
+    /** High frequency band (2000-20000 Hz) - hi-hats, cymbals */
+    high?: Partial<BandTransientConfig>;
+}
+/**
+ * Result of a single detected transient
+ */
+export interface TransientResult {
+    /** Timestamp in seconds from the start of the audio */
+    timestamp: number;
+    /** Strength of the detected transient (0.0 - 1.0, normalized) */
+    intensity: number;
+    /** Which frequency band detected this: 'low', 'mid', or 'high' */
+    band: 'low' | 'mid' | 'high';
+    /** Detection method used to find this transient */
+    detectionMethod: TransientDetectionMethod;
+    /** Information about the nearest beat in the beat map (set during quantization) */
+    nearestBeat?: {
+        /** Index into UnifiedBeatMap.beats[] */
+        index: number;
+        /** How far from quarter note grid (in seconds) */
+        distance: number;
+    };
+}
+/**
+ * Configuration for the TransientDetector
+ */
+export interface TransientDetectorConfig {
+    /**
+     * Base threshold for peak detection (0.0 - 1.0).
+     * Lower values detect more transients, higher values are more selective.
+     * This is used as a fallback if per-band threshold is not specified.
+     * Default: 0.3
+     */
+    baseThreshold?: number;
+    /**
+     * Adaptive thresholding enabled.
+     * When true, the detector adjusts thresholds based on the local energy/density of the signal.
+     * This is used as a fallback if per-band setting is not specified.
+     * Default: true
+     */
+    adaptiveThresholding?: boolean;
+    /**
+     * Window size for adaptive thresholding (in frames).
+     * The local energy is calculated over this window to adjust thresholds.
+     * Default: 50 frames (~500ms at 10ms hop size)
+     */
+    adaptiveWindowSize?: number;
+    /**
+     * Minimum distance between transients in seconds (buffer window).
+     * Within this window, only the strongest transient wins (Non-Maximum Suppression).
+     * This is used as a fallback if per-band interval is not specified.
+     * Default: 0.02 (20ms)
+     * @deprecated Use per-band config in `bandConfig` instead
+     */
+    minTransientInterval?: number;
+    /**
+     * Custom frequency bands (default: FREQUENCY_BANDS from audioUtils)
+     */
+    bands?: FrequencyBand[];
+    /**
+     * Per-band configuration overrides.
+     * Each band can have different thresholds and intervals optimized for its content.
+     * Settings here override the global defaults for specific bands.
+     */
+    bandConfig?: BandTransientConfigOverrides;
+}
+/**
+ * Result of transient analysis
+ */
+export interface TransientAnalysis {
+    /** All detected transients across all bands */
+    transients: TransientResult[];
+    /** Transients grouped by frequency band */
+    bandTransients: Map<'low' | 'mid' | 'high', TransientResult[]>;
+    /** Analysis metadata */
+    metadata: {
+        /** Total number of transients detected */
+        totalTransients: number;
+        /** Number of transients per band */
+        transientsPerBand: Map<'low' | 'mid' | 'high', number>;
+        /** Duration of the audio in seconds */
+        duration: number;
+        /** Average transient intensity */
+        averageIntensity: number;
+        /** Detection methods used */
+        detectionMethodsUsed: TransientDetectionMethod[];
+    };
+}
+/**
+ * Multi-Band Transient Detector
+ *
+ * Detects transients (onsets) using band-specific detection strategies.
+ * Each frequency band is analyzed with an algorithm optimized for its typical content:
+ *
+ * - **Low Band (20-500 Hz)**: Energy-based detection
+ *   - Optimized for kick drums, bass, sub frequencies
+ *   - Uses the energy envelope directly to detect sharp amplitude changes
+ *
+ * - **Mid Band (500-2000 Hz)**: Spectral Flux
+ *   - Optimized for vocals, snare body, lead instruments
+ *   - Measures spectral change between frames for onset detection
+ *
+ * - **High Band (2000-20000 Hz)**: High-Frequency Content (HFC)
+ *   - Optimized for hi-hats, cymbals, harmonics, air
+ *   - Weights high-frequency bins more heavily for cymbal/percussive detection
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * const multiBandAnalyzer = new MultiBandAnalyzer();
+ * const multiBandResult = multiBandAnalyzer.analyze(audioBuffer);
+ *
+ * const detector = new TransientDetector();
+ * const transients = detector.detect(multiBandResult);
+ *
+ * // Access per-band transients
+ * const lowBandTransients = transients.bandTransients.get('low');
+ * const midBandTransients = transients.bandTransients.get('mid');
+ * const highBandTransients = transients.bandTransients.get('high');
+ * ```
+ *
+ * ## Adaptive Thresholding
+ *
+ * When adaptive thresholding is enabled, the detector adjusts thresholds based on local energy.
+ * This helps handle songs with varying dynamics (quiet vs loud sections).
+ */
+export declare class TransientDetector {
+    private config;
+    /**
+     * Create a new TransientDetector
+     *
+     * @param config - Configuration options (all optional, defaults provided)
+     */
+    constructor(config?: TransientDetectorConfig);
+    /**
+     * Get the current configuration
+     *
+     * @returns The current configuration
+     */
+    getConfig(): TransientDetectorConfig;
+    /**
+     * Get the per-band configuration
+     *
+     * @returns The per-band configuration
+     */
+    getBandConfig(): Record<BandName, BandTransientConfig>;
+    /**
+     * Detect transients in multi-band audio analysis
+     *
+     * @param multiBandResult - Result from MultiBandAnalyzer
+     * @returns Transient analysis with per-band results
+     */
+    detect(multiBandResult: MultiBandResult): TransientAnalysis;
+    /**
+     * Detect transients in a specific frequency band
+     *
+     * Uses band-specific detection strategies:
+     * - Low band: Energy-based detection
+     * - Mid band: Spectral Flux
+     * - High band: High-Frequency Content (HFC)
+     *
+     * Applies Non-Maximum Suppression (NMS) to ensure only the strongest
+     * transient within a buffer window is kept.
+     *
+     * @param bandName - Name of the frequency band
+     * @param bandAnalysis - Analysis result for this band
+     * @param hopSizeSeconds - Time between frames in seconds
+     * @returns Array of detected transients
+     */
+    private detectBandTransients;
+    /**
+     * Apply Non-Maximum Suppression (NMS) to transients
+     *
+     * Within a buffer window, only the strongest transient wins.
+     * This prevents multiple detections for the same acoustic event.
+     *
+     * ## Algorithm
+     *
+     * 1. Sort candidates by intensity (strongest first)
+     * 2. For each candidate (starting with strongest):
+     *    - If not suppressed by an already-accepted transient, accept it
+     *    - Suppress all weaker candidates within the buffer window
+     * 3. Return accepted transients sorted by timestamp
+     *
+     * @param candidates - All candidate transients (peaks above threshold)
+     * @param bufferWindow - Minimum interval in seconds between transients
+     * @returns Filtered transients with only the strongest in each window
+     */
+    private applyNonMaximumSuppression;
+    /**
+     * Get the detection method for a specific band
+     *
+     * @param bandName - Name of the frequency band
+     * @returns Detection method to use for this band
+     */
+    private getDetectionMethod;
+    /**
+     * Calculate adaptive threshold based on local energy
+     *
+     * Uses a sliding window to calculate local energy and adjust threshold accordingly.
+     * This helps handle songs with varying dynamics.
+     *
+     * ## Algorithm: Adaptive Thresholding via Coefficient of Variation
+     *
+     * The threshold is adjusted based on the signal's dynamic range:
+     *
+     * 1. **Calculate Mean Energy**: Average onset strength across all frames
+     * 2. **Calculate Standard Deviation**: Measure of energy variation
+     * 3. **Compute Coefficient of Variation (CV)**: stdDev / mean
+     *    - CV ≈ 0: Signal is consistent (e.g., electronic dance music)
+     *    - CV > 1: Signal has high dynamic range (e.g., classical with quiet/loud sections)
+     * 4. **Adjust Threshold**: baseThreshold * (1 + CV * 0.5)
+     *    - High CV → Higher threshold (more selective, fewer false positives in dynamic sections)
+     *    - Low CV → Lower threshold (catch more transients in consistent sections)
+     *
+     * @param envelope - The onset strength envelope
+     * @param baseThreshold - The base threshold for this band (default: global baseThreshold)
+     * @returns Calculated threshold
+     */
+    private calculateAdaptiveThreshold;
+    /**
+     * Find peaks in the onset strength envelope
+     *
+     * A peak is a local maximum that exceeds the threshold.
+     *
+     * @param envelope - The onset strength envelope
+     * @param threshold - Minimum peak height
+     * @returns Array of frame indices where peaks occur
+     */
+    private findPeaks;
+}
+export {};
+//# sourceMappingURL=TransientDetector.d.ts.map

package/dist/core/analysis/beat/TransientDetector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransientDetector.d.ts","sourceRoot":"","sources":["../../../../src/core/analysis/beat/TransientDetector.ts"],"names":[],"mappings":"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"}