wave-roll/dist/lib/core/audio/managers/wav-player-manager.d.ts

JavaScript Library for Comparative MIDI Piano-Roll Visualization

/**
 * WAV Player Manager
 * Handles external audio file (WAV/MP3) playback using Tone.Player + PitchShift
 * to preserve pitch while changing playback rate.
 */
import * as Tone from "tone";
export interface AudioPlayerEntry {
    player: Tone.Player;
    pitch: Tone.PitchShift;
    gate: Tone.Gain;
    panner: Tone.Panner;
    url: string;
    muted?: boolean;
    /** Whether this player has been started at least once and not subsequently hard-stopped */
    isStarted?: boolean;
    /** Token to invalidate stale async starts (e.g., overlapping loads) */
    startToken?: number;
    /** Pending timeout id for a scheduled start (if any) - legacy setTimeout scheduling */
    scheduledTimer?: number | ReturnType<typeof setTimeout> | null;
    /** Tone.js Transport event ID for synchronized scheduling */
    transportEventId?: number | null;
}
export declare class WavPlayerManager {
    /** Map of audioId -> { player, panner, url } for waveform playback */
    private audioPlayers;
    private transportSyncManager?;
    private bufferLoadPromise?;
    private notifyBufferReady?;
    /** Currently selected active audio id (from window._waveRollAudio) */
    private activeAudioId;
    setTransportSyncManager(transportSyncManager: import('./transport-sync-manager').TransportSyncManager): void;
    /**
     * Set callback to notify when buffer status changes
     */
    setBufferReadyCallback(callback: (id: string) => void): void;
    /**
     * Start monitoring buffer status for UI updates
     */
    startBufferMonitoring(intervalMs?: number): () => void;
    /**
     * Build/refresh Tone.Player instances from global audio registry (window._waveRollAudio)
     * and select the first visible & unmuted item as the active audio source.
     */
    setupAudioPlayersFromRegistry(state: {
        volume?: number;
        playbackRate?: number;
        isPlaying?: boolean;
        currentTime?: number;
    }): void;
    /**
     * Check if any audio player is active
     */
    isAudioActive(): boolean;
    /**
     * Stop all audio players
     */
    stopAllAudioPlayers(): void;
    /**
     * Start all unmuted WAV files at specified offset
     */
    startActiveAudioAt(offsetSeconds: number, startAt?: string | number): void;
    /**
     * Convert a startAt parameter (e.g., "+0.01" or absolute number) to an absolute AudioContext time.
     */
    private resolveStartAt;
    /**
     * Set volume for all WAV players
     */
    setVolume(volume: number): void;
    /**
     * Set pan for all WAV players
     */
    setPan(pan: number): void;
    /**
     * Set playback rate for all WAV players
     */
    setPlaybackRate(rate: number): void;
    /**
     * Set volume for a specific WAV file
     */
    setWavVolume(fileId: string, volume: number, masterVolume: number, opts?: {
        isPlaying?: boolean;
        currentTime?: number;
    }): void;
    /**
     * Get file mute states
     */
    getFileMuteStates(): Map<string, boolean>;
    /**
     * Get file volume states
     */
    getFileVolumeStates(): Map<string, number>;
    /**
     * Set file mute state
     */
    setFileMute(fileId: string, mute: boolean): boolean;
    /**
     * Set file volume
     */
    setFileVolume(fileId: string, volume: number): boolean;
    /**
     * Check if all players have zero volume
     */
    areAllPlayersZeroVolume(): boolean;
    /**
     * Refresh from MIDI manager
     */
    refreshFromMidiManager(midiManager: any): boolean;
    /**
     * Check if all WAV players are muted
     */
    areAllPlayersMuted(): boolean;
    /**
     * If all WAV players are muted and at least one is visible, unmute visible players,
     * raise their volume to masterVolume and start them at the given offset.
     */
    unmuteAndStartVisibleIfAllMuted(offsetSeconds: number, masterVolume: number): void;
    /**
     * Get maximum duration from audio buffers
     */
    getMaxAudioDuration(): number;
    /**
     * Restart at position
     */
    restartAtPosition(position: number, startAt?: string | number): void;
    /**
     * Clean up resources
     */
    destroy(): void;
    /**
     * Refresh audio players and restart if playing
     */
    refreshAudioPlayers(state: {
        isPlaying: boolean;
        currentTime: number;
        volume?: number;
        playbackRate?: number;
    }): void;
    /**
     * Check if there are any visible & unmuted WAV players whose buffers are not yet loaded.
     * Useful to decide whether to delay a synchronized start a bit longer.
     */
    hasActiveUnloadedPlayers(): boolean;
    /**
     * Wait until all active (visible & unmuted) WAV buffers are ready or timeout.
     * Returns true if ready within the timeout, false otherwise.
     */
    waitUntilActiveReady(timeoutMs?: number, pollMs?: number): Promise<boolean>;
    /**
     * Synchronously check if all active audio buffers are ready
     * Returns immediately without waiting
     */
    /**
     * Synchronously check if all active audio buffers are ready
     * Returns immediately without waiting
     */
    areAllBuffersReady(): boolean;
    /**
     * Start all active audio with guaranteed synchronization
     * All buffers must be loaded before calling this method
     */
    startActiveAudioAtSync(offsetSeconds: number, startAt?: string | number): void;
    /**
     * Estimate processing latency introduced by PitchShift (in seconds).
     * Uses windowSize if available; falls back to 0.06s.
     */
    getEstimatedLatencySec(): number;
}
//# sourceMappingURL=wav-player-manager.d.ts.map