audio-inspect/dist/features/frequency.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;
}

type FFTNormalization = 'none' | 'amplitude';
type SpectrumScale = 'amplitude' | 'dbfs';
interface FFTOptions {
    fftSize?: number;
    windowFunction?: WindowFunction;
    channel?: ChannelSelector;
    provider?: FFTProviderType;
    enableProfiling?: boolean;
    providerCache?: FFTProviderCache | undefined;
    normalization?: FFTNormalization;
}
interface SpectrumOptions extends FFTOptions {
    minFrequency?: number;
    maxFrequency?: number;
    scale?: SpectrumScale;
}
interface SpectrogramOptions extends SpectrumOptions {
    frameSize?: number;
    hopSize?: number;
    maxFrames?: number;
}
interface FFTAnalysisResult extends FFTResult {
    fftSize: number;
    windowFunction: string;
    providerName: string;
    normalization: FFTNormalization;
}
interface SpectrumAnalysisResult {
    frequencies: Float32Array;
    values: Float32Array;
    scale: SpectrumScale;
}
interface SpectrogramAnalysisResult {
    times: Float32Array;
    frequencies: Float32Array;
    frames: Float32Array[];
    frameCount: number;
    frequencyBins: number;
    scale: SpectrumScale;
    latest: Float32Array;
}
declare function getFFT(audio: AudioData, options?: FFTOptions): Promise<FFTAnalysisResult>;
declare function getSpectrum(audio: AudioData, options?: SpectrumOptions): Promise<SpectrumAnalysisResult>;
declare function getSpectrogram(audio: AudioData, options?: SpectrogramOptions): Promise<SpectrogramAnalysisResult>;

export { type FFTAnalysisResult, type FFTNormalization, type FFTOptions, type SpectrogramAnalysisResult, type SpectrogramOptions, type SpectrumAnalysisResult, type SpectrumOptions, type SpectrumScale, getFFT, getSpectrogram, getSpectrum };