playlist-data-engine 1.1.0

package/dist/core/analysis/MelodyContourAnalyzer.d.ts

@@ -0,0 +1,283 @@
+/**
+ * Melody Contour Analyzer
+ *
+ * Analyzes pitch data to extract melodic contour information for button mapping.
+ * This is Phase 1.5 of the Pitch Detection & Button Mapping pipeline.
+ *
+ * ## What it does
+ *
+ * 1. **Pitch-to-Pitch Comparison**: Iterates through consecutive beats and compares
+ *    their pitches to determine direction (up/down/stable/none) and interval distance.
+ *
+ * 2. **Interval Categorization**: Groups intervals into categories useful for button mapping:
+ *    - unison: 0 semitones (same note)
+ *    - small: 1-2 semitones (minor/major 2nd)
+ *    - medium: 3-4 semitones (minor/major 3rd)
+ *    - large: 5-7 semitones (4th, tritone, 5th)
+ *    - very_large: 8+ semitones (6th, 7th, octave+)
+ *
+ * 3. **Melody Segment Detection**: Groups consecutive beats with the same direction
+ *    into melody segments (e.g., ascending phrase, descending phrase).
+ *
+ * 4. **Contour Aggregation**: Calculates overall melody direction and range.
+ *
+ * @example
+ * ```typescript
+ * // After running PitchBeatLinker on the composite stream
+ * const linker = new PitchBeatLinker();
+ * const compositePitches = await linker.linkWithComposite(composite, audioBuffer);
+ *
+ * // Analyze melody contour
+ * const contourAnalyzer = new MelodyContourAnalyzer();
+ * const contourResult = contourAnalyzer.analyze(compositePitches);
+ *
+ * // Access direction and interval for each beat
+ * for (const pitchAtBeat of contourResult.pitchByBeat) {
+ *   console.log(`Beat ${pitchAtBeat.beatIndex}: direction=${pitchAtBeat.direction}, interval=${pitchAtBeat.intervalFromPrevious}`);
+ * }
+ *
+ * // Access overall contour
+ * console.log('Overall direction:', contourResult.melodyContour.direction);
+ * console.log('Range:', contourResult.melodyContour.range);
+ * ```
+ */
+import type { PitchAtBeat } from '../generation/PitchBeatLinker.js';
+/**
+ * Direction of a melody segment
+ */
+export type MelodySegmentDirection = 'up' | 'down' | 'stable';
+/**
+ * Overall direction of a melody contour
+ */
+export type MelodyContourDirection = 'ascending' | 'descending' | 'stable' | 'mixed';
+/**
+ * A segment of a melody with consistent direction
+ *
+ * Part of Phase 1.5 (Melody Contour Analysis)
+ */
+export interface MelodySegment {
+    /** Start time in seconds */
+    startTime: number;
+    /** End time in seconds */
+    endTime: number;
+    /** Starting pitch (note name, e.g., "C4") */
+    startPitch: string;
+    /** Ending pitch (note name, e.g., "F#5") */
+    endPitch: string;
+    /** Direction of this segment */
+    direction: MelodySegmentDirection;
+    /** Interval in semitones between start and end */
+    interval: number;
+}
+/**
+ * Melody contour representing the overall melodic shape
+ *
+ * Populated by melody contour analysis (Phase 1.5).
+ * Used by button mapping (Phase 2) to generate patterns that follow the melody.
+ */
+export interface MelodyContour {
+    /** Melody segments grouped by direction */
+    segments: MelodySegment[];
+    /** Overall direction of the melody */
+    direction: MelodyContourDirection;
+    /** Pitch range of the melody */
+    range: {
+        /** Lowest note (e.g., "C4") */
+        minNote: string;
+        /** Highest note (e.g., "F#5") */
+        maxNote: string;
+        /** Total span in semitones */
+        semitones: number;
+    };
+    /** Time-window direction analysis (Phase 1.5.3) */
+    /** Direction over the last 1-2 beats */
+    shortTermDirection: MelodyContourDirection;
+    /** Direction over the last 4-8 beats */
+    mediumTermDirection: MelodyContourDirection;
+    /** Direction over the last 16+ beats */
+    longTermDirection: MelodyContourDirection;
+}
+/**
+ * Interval category for button mapping
+ *
+ * Used to determine button jump distances based on musical intervals.
+ */
+export type IntervalCategory = 'unison' | 'small' | 'medium' | 'large' | 'very_large';
+/**
+ * Direction of pitch change from previous beat
+ */
+export type PitchDirection = 'up' | 'down' | 'stable' | 'none';
+/**
+ * Direction statistics for melody contour metadata
+ */
+export interface DirectionStats {
+    /** Count of ascending pitches */
+    up: number;
+    /** Count of descending pitches */
+    down: number;
+    /** Count of repeated pitches */
+    stable: number;
+    /** Count with no pitch detected or no previous pitch */
+    none: number;
+}
+/**
+ * Interval statistics for melody contour metadata
+ */
+export interface IntervalStats {
+    /** 0 semitones */
+    unison: number;
+    /** 1-2 semitones (minor/major 2nd) */
+    small: number;
+    /** 3-4 semitones (minor/major 3rd) */
+    medium: number;
+    /** 5-7 semitones (4th, tritone, 5th) */
+    large: number;
+    /** 8+ semitones (6th, 7th, octave+) */
+    very_large: number;
+}
+/**
+ * Result of melody contour analysis
+ */
+export interface MelodyContourAnalysisResult {
+    /** Updated pitch-by-beat with direction and interval populated */
+    pitchByBeat: PitchAtBeat[];
+    /** Melody contour from composite pitches */
+    melodyContour: MelodyContour;
+    /** Direction statistics */
+    directionStats: DirectionStats;
+    /** Interval statistics */
+    intervalStats: IntervalStats;
+    /** Analysis metadata */
+    metadata: {
+        /** Total beats analyzed */
+        totalBeats: number;
+        /** Beats with voiced pitch */
+        voicedBeats: number;
+        /** Beats with direction calculated */
+        directionCalculatedBeats: number;
+    };
+}
+/**
+ * Configuration for MelodyContourAnalyzer
+ */
+export interface MelodyContourAnalyzerConfig {
+    /** Maximum time gap (in seconds) between beats to consider them consecutive (default: 0.5) */
+    maxTimeGapForConsecutive?: number;
+}
+/**
+ * Categorize an interval in semitones
+ *
+ * @param semitones - Number of semitones (absolute value)
+ * @returns Interval category
+ */
+export declare function categorizeInterval(semitones: number): IntervalCategory;
+/**
+ * Calculate the number of semitones between two MIDI notes
+ *
+ * @param midi1 - First MIDI note number
+ * @param midi2 - Second MIDI note number
+ * @returns Absolute difference in semitones
+ */
+export declare function calculateIntervalSemitones(midi1: number, midi2: number): number;
+/**
+ * Determine the direction between two MIDI notes
+ *
+ * @param currentMidi - Current MIDI note
+ * @param previousMidi - Previous MIDI note
+ * @returns Direction (up, down, stable, or none if invalid)
+ */
+export declare function determineDirection(currentMidi: number | null, previousMidi: number | null): PitchDirection;
+/**
+ * Determine overall contour direction from segments
+ *
+ * @param segments - Melody segments
+ * @returns Overall contour direction
+ */
+export declare function determineOverallDirection(segments: MelodySegment[]): MelodyContourDirection;
+/**
+ * Convert MIDI note number to note name
+ *
+ * @param midi - MIDI note number
+ * @returns Note name (e.g., "C4", "F#5")
+ */
+export declare function midiToNoteName(midi: number): string;
+/**
+ * Melody Contour Analyzer
+ *
+ * Analyzes pitch data to extract melodic contour information for button mapping.
+ *
+ * This class performs Phase 1.5 of the pitch detection pipeline:
+ * - Pitch-to-pitch comparison to calculate direction and interval
+ * - Segment detection for melody phrases
+ * - Contour aggregation for overall melody shape
+ */
+export declare class MelodyContourAnalyzer {
+    private config;
+    /**
+     * Create a new MelodyContourAnalyzer
+     *
+     * @param config - Configuration options
+     */
+    constructor(config?: MelodyContourAnalyzerConfig);
+    /**
+     * Get the current configuration
+     */
+    getConfig(): Required<MelodyContourAnalyzerConfig>;
+    /**
+     * Analyze composite pitch data to extract melody contour
+     *
+     * This method:
+     * 1. Compares consecutive pitches to calculate direction and interval
+     * 2. Creates melody segments
+     * 3. Calculates overall contour direction and range
+     *
+     * @param compositePitches - Pitch at each composite beat from PitchBeatLinker.linkWithComposite()
+     * @returns Melody contour analysis result with populated direction/interval
+     */
+    analyze(compositePitches: PitchAtBeat[]): MelodyContourAnalysisResult;
+    /**
+     * Analyze pitch-to-pitch comparison for a single band's pitches
+     *
+     * @param pitches - Array of pitch-at-beat for this band
+     * @returns Updated array with direction and interval populated
+     */
+    private analyzeBandPitches;
+    /**
+     * Build melody contour from a band's pitches
+     *
+     * @param pitches - Array of pitch-at-beat with direction populated
+     * @returns Melody contour with segments and overall direction
+     */
+    private buildMelodyContour;
+    /**
+     * Calculate direction over a specific time window
+     *
+     * Analyzes the last N beats to determine the overall direction trend.
+     *
+     * @param pitches - All pitches (sorted by timestamp)
+     * @param windowSize - Number of beats to look back for direction analysis
+     * @returns The overall direction for that window
+     */
+    private calculateTimeWindowDirection;
+    /**
+     * Determine overall direction from direction counts
+     */
+    private determineOverallDirectionFromCounts;
+    /**
+     * Build melody segments from voiced pitches
+     *
+     * Groups consecutive beats with the same direction into segments.
+     *
+     * @param pitches - Voiced pitches with direction populated
+     * @returns Array of melody segments
+     */
+    private buildSegments;
+    /**
+     * Calculate direction and interval statistics
+     *
+     * @param pitches - All pitches with direction and interval populated
+     * @returns Statistics and metadata
+     */
+    private calculateStatistics;
+}
+//# sourceMappingURL=MelodyContourAnalyzer.d.ts.map

package/dist/core/analysis/MelodyContourAnalyzer.d.ts.map

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

package/dist/core/analysis/MultiBandAnalyzer.d.ts

@@ -0,0 +1,214 @@
+/**
+ * Multi-Band Analyzer for Transient Detection
+ *
+ * Splits audio into multiple frequency bands and analyzes each band separately
+ * for transient detection. This enables detecting different types of rhythmic
+ * elements (bass/kick, vocals/snare, hi-hats/cymbals) independently.
+ *
+ * Part of the Procedural Rhythm Generation pipeline.
+ *
+ * @example
+ * ```typescript
+ * // Basic usage - analyze an audio buffer
+ * const analyzer = new MultiBandAnalyzer();
+ * const result = analyzer.analyze(audioBuffer);
+ *
+ * // Access per-band analysis
+ * for (const [bandName, analysis] of result.bands) {
+ *   console.log(`${bandName}: ${analysis.peaks.length} transients detected`);
+ *   console.log(`  Energy: ${analysis.energy.toFixed(3)}`);
+ * }
+ *
+ * // Check which bands have the most activity
+ * console.log('Dominant bands:', result.dominantBands);
+ *
+ * // Custom configuration with adjusted threshold
+ * const customAnalyzer = new MultiBandAnalyzer({
+ *   peakThreshold: 0.4,  // Higher threshold = fewer, stronger peaks
+ *   fftWindowSizeMs: 46, // Larger window = better frequency resolution
+ * });
+ * ```
+ */
+import { type FrequencyBand } from './beat/utils/audioUtils.js';
+/**
+ * Configuration for the Multi-Band Analyzer
+ */
+export interface MultiBandAnalyzerConfig {
+    /** Target sample rate for analysis (default: 22050 - good balance of quality and speed) */
+    targetSampleRate?: number;
+    /** FFT window size in milliseconds (default: 23ms - good for transient detection) */
+    fftWindowSizeMs?: number;
+    /** Hop size in milliseconds (default: 10ms) */
+    hopSizeMs?: number;
+    /** Gaussian smoothing window in milliseconds (default: 10ms) */
+    smoothWindowMs?: number;
+    /** Peak detection threshold (0.0 - 1.0, default: 0.3) */
+    peakThreshold?: number;
+    /** Custom frequency bands (default: FREQUENCY_BANDS from audioUtils) */
+    bands?: FrequencyBand[];
+}
+/**
+ * Analysis result for a single frequency band
+ */
+export interface BandAnalysis {
+    /** Band name identifier ('low', 'mid', 'high') */
+    name: string;
+    /** Frequency range of this band */
+    frequencyRange: {
+        lowHz: number;
+        highHz: number;
+    };
+    /** Onset strength envelope for this band (one value per frame) */
+    envelope: Float32Array;
+    /** Frame indices where peaks (transients) were detected */
+    peaks: number[];
+    /** Times in seconds where peaks were detected */
+    peakTimes: number[];
+    /** Average energy in this band (0.0 - 1.0, normalized) */
+    energy: number;
+    /** Energy over time (one value per frame) */
+    energyOverTime: Float32Array;
+}
+/**
+ * Result of multi-band analysis
+ */
+export interface MultiBandResult {
+    /** Analysis results per band, keyed by band name */
+    bands: Map<string, BandAnalysis>;
+    /** Bands with the most activity, sorted by energy (highest first) */
+    dominantBands: string[];
+    /** Combined energy profile across all bands (one value per frame) */
+    energyProfile: Float32Array;
+    /** Analysis metadata */
+    metadata: {
+        /** Number of frames in the analysis */
+        numFrames: number;
+        /** Duration of the audio in seconds */
+        duration: number;
+        /** Hop size used for analysis in seconds */
+        hopSizeSeconds: number;
+        /** Effective sample rate after resampling */
+        effectiveSampleRate: number;
+        /** Bands that were analyzed */
+        bandsAnalyzed: string[];
+    };
+}
+/**
+ * Multi-Band Analyzer
+ *
+ * Analyzes audio across multiple frequency bands for transient detection.
+ * Each band is processed independently to detect band-specific rhythmic elements.
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * const analyzer = new MultiBandAnalyzer({
+ *   targetSampleRate: 22050,
+ *   peakThreshold: 0.3,
+ * });
+ *
+ * const result = analyzer.analyze(audioBuffer);
+ *
+ * // Access band-specific analysis
+ * const lowBand = result.bands.get('low');
+ * console.log(`Low band has ${lowBand?.peaks.length} transients`);
+ *
+ * // Get dominant bands
+ * console.log(`Dominant bands: ${result.dominantBands.join(', ')}`);
+ * ```
+ *
+ * ## Detection Strategies
+ *
+ * Different frequency bands contain different rhythmic elements:
+ * - **Low (20-500 Hz)**: Bass, kick drums, sub frequencies - use energy-based detection
+ * - **Mid (500-2000 Hz)**: Vocals, snare body, lead instruments - use spectral flux
+ * - **High (2000-20000 Hz)**: Hi-hats, cymbals, harmonics - use HFC or spectral flux
+ *
+ * The analyzer uses spectral flux across all bands, which works well for general
+ * transient detection. The TransientDetector (next step) will apply band-specific
+ * detection strategies.
+ */
+export declare class MultiBandAnalyzer {
+    private config;
+    /**
+     * Create a new Multi-Band Analyzer
+     *
+     * @param config - Configuration options (all optional, defaults provided)
+     */
+    constructor(config?: MultiBandAnalyzerConfig);
+    /**
+     * Get the current configuration
+     *
+     * @returns The current configuration
+     */
+    getConfig(): Required<MultiBandAnalyzerConfig>;
+    /**
+     * Analyze an audio buffer across all frequency bands
+     *
+     * @param audioBuffer - Web Audio API AudioBuffer to analyze
+     * @returns Multi-band analysis result
+     */
+    analyze(audioBuffer: AudioBuffer): MultiBandResult;
+    /**
+     * Analyze a single frequency band
+     */
+    private analyzeBand;
+    /**
+     * Calculate onset strength envelope using spectral flux
+     *
+     * Spectral flux measures the amount of change in the spectrum between
+     * consecutive frames. High values indicate likely onset points.
+     *
+     * ## Algorithm: Spectral Flux for Onset Detection
+     *
+     * Spectral flux is a widely-used onset detection method that measures the
+     * positive change in spectral energy between consecutive STFT frames.
+     *
+     * ### Mathematical Definition:
+     *
+     * For each frequency bin `b` at time `t`:
+     * ```
+     * flux(t, b) = max(0, |X(t, b)| - |X(t-1, b)|)
+     * ```
+     * Where |X(t, b)| is the magnitude at frequency bin b, time frame t.
+     *
+     * The total flux at time t is the sum across all frequency bins:
+     * ```
+     * onset_strength(t) = Σ flux(t, b) for all bins b
+     * ```
+     *
+     * ### Why Positive Differences Only?
+     *
+     * We only count increases in energy (positive differences) because:
+     * 1. Onsets are characterized by a *rise* in energy, not a fall
+     * 2. Including negative differences would cancel out onset peaks
+     * 3. This is called "half-wave rectification" in signal processing
+     *
+     * ### Why This Works for Rhythm Detection:
+     *
+     * - When a new note/drum hits, its frequency content suddenly appears
+     * - This creates a large positive difference in those frequency bins
+     * - The sum of all positive differences creates a peak in the envelope
+     * - Peaks in the envelope correspond to transients/onsets
+     */
+    private calculateOnsetEnvelope;
+    /**
+     * Find peaks in the onset strength envelope
+     *
+     * A peak is a local maximum that exceeds the threshold.
+     */
+    private findPeaks;
+    /**
+     * Combine energy profiles from multiple bands
+     *
+     * Takes the maximum energy at each frame across all bands.
+     */
+    private combineEnergyProfiles;
+    /**
+     * Calculate dominant bands based on average energy
+     *
+     * Returns band names sorted by energy (highest first).
+     */
+    private calculateDominantBands;
+}
+//# sourceMappingURL=MultiBandAnalyzer.d.ts.map

package/dist/core/analysis/MultiBandAnalyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MultiBandAnalyzer.d.ts","sourceRoot":"","sources":["../../../src/core/analysis/MultiBandAnalyzer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,EAMH,KAAK,aAAa,EACrB,MAAM,4BAA4B,CAAC;AAEpC;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACpC,2FAA2F;IAC3F,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,qFAAqF;IACrF,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,+CAA+C;IAC/C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gEAAgE;IAChE,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,yDAAyD;IACzD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,wEAAwE;IACxE,KAAK,CAAC,EAAE,aAAa,EAAE,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IACzB,kDAAkD;IAClD,IAAI,EAAE,MAAM,CAAC;IACb,mCAAmC;IACnC,cAAc,EAAE;QACZ,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;KAClB,CAAC;IACF,kEAAkE;IAClE,QAAQ,EAAE,YAAY,CAAC;IACvB,2DAA2D;IAC3D,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,iDAAiD;IACjD,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,0DAA0D;IAC1D,MAAM,EAAE,MAAM,CAAC;IACf,6CAA6C;IAC7C,cAAc,EAAE,YAAY,CAAC;CAChC;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC5B,oDAAoD;IACpD,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IACjC,qEAAqE;IACrE,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,qEAAqE;IACrE,aAAa,EAAE,YAAY,CAAC;IAC5B,wBAAwB;IACxB,QAAQ,EAAE;QACN,uCAAuC;QACvC,SAAS,EAAE,MAAM,CAAC;QAClB,uCAAuC;QACvC,QAAQ,EAAE,MAAM,CAAC;QACjB,4CAA4C;QAC5C,cAAc,EAAE,MAAM,CAAC;QACvB,6CAA6C;QAC7C,mBAAmB,EAAE,MAAM,CAAC;QAC5B,+BAA+B;QAC/B,aAAa,EAAE,MAAM,EAAE,CAAC;KAC3B,CAAC;CACL;AAkBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,qBAAa,iBAAiB;IAC1B,OAAO,CAAC,MAAM,CAAoC;IAElD;;;;OAIG;gBACS,MAAM,GAAE,uBAA4B;IAgBhD;;;;OAIG;IACH,SAAS,IAAI,QAAQ,CAAC,uBAAuB,CAAC;IAI9C;;;;;OAKG;IACH,OAAO,CAAC,WAAW,EAAE,WAAW,GAAG,eAAe;IAsDlD;;OAEG;IACH,OAAO,CAAC,WAAW;IAuEnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACH,OAAO,CAAC,sBAAsB;IAiC9B;;;;OAIG;IACH,OAAO,CAAC,SAAS;IAejB;;;;OAIG;IACH,OAAO,CAAC,qBAAqB;IAgB7B;;;;OAIG;IACH,OAAO,CAAC,sBAAsB;CAejC"}