audio-inspect/dist/features/spectral.d.ts

Lightweight yet powerful audio analysis library

interface AudioData {
    sampleRate: number;
    channelData: Float32Array[];
    duration: number;
    numberOfChannels: number;
    length: number;
}
type ChannelSelector = 'mix' | number | 'all' | readonly number[];
type WindowFunction = 'hann' | 'hamming' | 'blackman' | 'bartlett' | 'kaiser' | 'tukey' | 'rectangular' | 'none';

type FFTProviderType = 'webfft' | 'native' | 'custom';
interface FFTResult {
    complex: Float32Array;
    magnitude: Float32Array;
    phase: Float32Array;
    frequencies: Float32Array;
}
interface IFFTProvider {
    readonly name: string;
    readonly size: number;
    readonly sampleRate: number;
    fft(input: Float32Array): FFTResult | Promise<FFTResult>;
    dispose(): void;
    profile?(): Promise<void>;
}
interface FFTProviderConfig {
    type: FFTProviderType;
    fftSize: number;
    sampleRate: number;
    enableProfiling?: boolean;
    customProvider?: IFFTProvider;
}

interface FFTProviderResolver {
    createProvider(config: FFTProviderConfig): Promise<IFFTProvider>;
}
interface FFTProviderRequest {
    fftSize: number;
    sampleRate: number;
    provider?: FFTProviderType;
    enableProfiling?: boolean;
    fallbackToNative?: boolean;
    resolver?: FFTProviderResolver;
}
interface FFTProviderCache {
    getOrCreate(request: FFTProviderRequest): Promise<IFFTProvider>;
    clear(): void;
}

interface SpectralRuntimeOptions {
    provider?: FFTProviderType;
    enableProfiling?: boolean;
    providerCache?: FFTProviderCache | undefined;
}
interface SpectralFeaturesOptions extends SpectralRuntimeOptions {
    fftSize?: number;
    windowFunction?: 'hann' | 'hamming' | 'blackman' | 'none';
    channel?: ChannelSelector;
    minFrequency?: number;
    maxFrequency?: number;
    rolloffThreshold?: number;
}
interface SpectralFeaturesResult {
    spectralCentroid: number;
    spectralBandwidth: number;
    spectralRolloff: number;
    spectralFlatness: number;
    spectralFlux?: number;
    zeroCrossingRate: number;
    frequencyRange: {
        min: number;
        max: number;
    };
}
interface TimeVaryingSpectralOptions extends SpectralFeaturesOptions {
    frameSize?: number;
    hopSize?: number;
    numFrames?: number;
}
interface TimeVaryingSpectralResult {
    times: Float32Array;
    spectralCentroid: Float32Array;
    spectralBandwidth: Float32Array;
    spectralRolloff: Float32Array;
    spectralFlatness: Float32Array;
    spectralFlux: Float32Array;
    zeroCrossingRate: Float32Array;
    frameInfo: {
        frameSize: number;
        hopSize: number;
        numFrames: number;
    };
}
interface SpectralEntropyOptions extends SpectralRuntimeOptions {
    fftSize?: number;
    windowFunction?: 'hann' | 'hamming' | 'blackman' | 'none';
    channel?: ChannelSelector;
    minFrequency?: number;
    maxFrequency?: number;
}
interface SpectralEntropyResult {
    entropy: number;
    entropyNorm: number;
    frequencyRange: {
        min: number;
        max: number;
    };
}
interface SpectralCrestOptions extends SpectralRuntimeOptions {
    fftSize?: number;
    windowFunction?: 'hann' | 'hamming' | 'blackman' | 'none';
    channel?: ChannelSelector;
    minFrequency?: number;
    maxFrequency?: number;
    asDB?: boolean;
}
interface SpectralCrestResult {
    crest: number;
    crestDB?: number;
    peak: number;
    average: number;
    frequencyRange: {
        min: number;
        max: number;
    };
}
declare function getSpectralFeatures(audio: AudioData, options?: SpectralFeaturesOptions): Promise<SpectralFeaturesResult>;
declare function getTimeVaryingSpectralFeatures(audio: AudioData, options?: TimeVaryingSpectralOptions): Promise<TimeVaryingSpectralResult>;
declare function getSpectralEntropy(audio: AudioData, options?: SpectralEntropyOptions): Promise<SpectralEntropyResult>;
declare function getSpectralCrest(audio: AudioData, options?: SpectralCrestOptions): Promise<SpectralCrestResult>;
interface FramedTransformOptions extends SpectralRuntimeOptions {
    frameSizeMs?: number;
    hopSizeMs?: number;
    fftSize?: number;
    windowFunction?: WindowFunction;
    channel?: ChannelSelector;
}
interface MelSpectrogramOptions extends FramedTransformOptions {
    numMelFilters?: number;
    minFrequency?: number;
    maxFrequency?: number;
    preEmphasis?: number;
    power?: number;
    logScale?: boolean;
    logEpsilon?: number;
}
interface MelSpectrogramResult {
    melSpectrogram: number[][];
    times: Float32Array;
    melFrequencies: Float32Array;
    frameInfo: {
        frameSizeMs: number;
        hopSizeMs: number;
        numFrames: number;
        numBins: number;
    };
    frequencyRange: {
        min: number;
        max: number;
    };
}
interface CQTOptions extends FramedTransformOptions {
    fMin?: number;
    binsPerOctave?: number;
    numBins?: number;
    preEmphasis?: number;
    power?: number;
    logScale?: boolean;
    logEpsilon?: number;
}
interface CQTResult {
    cqt: number[][];
    times: Float32Array;
    frequencies: Float32Array;
    frameInfo: {
        frameSizeMs: number;
        hopSizeMs: number;
        numFrames: number;
        numBins: number;
        binsPerOctave: number;
    };
    frequencyRange: {
        min: number;
        max: number;
    };
}
interface MFCCOptions extends FramedTransformOptions {
    numMelFilters?: number;
    numMfccCoeffs?: number;
    minFrequency?: number;
    maxFrequency?: number;
    preEmphasis?: number;
    lifterCoeff?: number;
}
interface MFCCResult {
    mfcc: number[][];
    times: Float32Array;
    frameInfo: {
        frameSizeMs: number;
        hopSizeMs: number;
        numFrames: number;
        numCoeffs: number;
    };
    frequencyRange: {
        min: number;
        max: number;
    };
}
declare function getMelSpectrogram(audio: AudioData, options?: MelSpectrogramOptions): Promise<MelSpectrogramResult>;
declare function getCQT(audio: AudioData, options?: CQTOptions): Promise<CQTResult>;
declare function getMFCC(audio: AudioData, options?: MFCCOptions): Promise<MFCCResult>;
declare function computeDeltaCoefficients(coefficients: number[][], windowSize?: number): {
    delta: number[][];
    deltaDelta: number[][];
};
interface MFCCDeltaOptions extends MFCCOptions {
    deltaWindowSize?: number;
    computeDelta?: boolean;
    computeDeltaDelta?: boolean;
}
interface MFCCDeltaResult extends MFCCResult {
    delta?: number[][];
    deltaDelta?: number[][];
}
declare function getMFCCWithDelta(audio: AudioData, options?: MFCCDeltaOptions): Promise<MFCCDeltaResult>;

export { type CQTOptions, type CQTResult, type MFCCDeltaOptions, type MFCCDeltaResult, type MFCCOptions, type MFCCResult, type MelSpectrogramOptions, type MelSpectrogramResult, type SpectralCrestOptions, type SpectralCrestResult, type SpectralEntropyOptions, type SpectralEntropyResult, type SpectralFeaturesOptions, type SpectralFeaturesResult, type TimeVaryingSpectralOptions, type TimeVaryingSpectralResult, computeDeltaCoefficients, getCQT, getMFCC, getMFCCWithDelta, getMelSpectrogram, getSpectralCrest, getSpectralEntropy, getSpectralFeatures, getTimeVaryingSpectralFeatures };