/**
 * AudioRenderer - Web Audio API based audio playback with precise clock synchronization
 * Uses AudioContext as the master clock for A/V sync (60Hz smooth playback)
 */
import type { PCMFrame } from "../decode/SoftwareAudioDecoder";
export declare class AudioRenderer {
    private audioContext;
    private inputNode;
    private gainNode;
    private compressorNode;
    private scheduledTime;
    private isPlaying;
    private volume;
    private _playbackRate;
    private activeSources;
    private _muted;
    private firstBufferScheduledAt;
    private firstBufferMediaTime;
    private hasFirstBuffer;
    private currentMediaTime;
    private maxScheduledMediaTime;
    private lastDecodeTime;
    private scheduledCount;
    private isRebufferingForRateChange;
    private preservePitch;
    private signalsmith;
    private signalsmithLoading;
    private signalsmithSampleRate;
    private _stableAudio;
    private _sinkId;
    private static readonly GAIN_RAMP_TIME;
    private static readonly FADE_OUT_TIME;
    private contextStateHandler;
    private recoveryAttempts;
    private static readonly MAX_RECOVERY_ATTEMPTS;
    private starvationStartTime;
    private isStarved;
    private static readonly STARVATION_THRESHOLD;
    private keepaliveEl;
    private keepaliveUrl;
    constructor();
    /**
     * Lazily create a near-silent looping <audio> element used to keep the
     * OS audio session alive while AudioContext is suspended. Uses a tiny
     * generated WAV blob so resume from pause stays seamless and Bluetooth
     * speakers/headphones don't drop the connection.
     */
    private ensureKeepalive;
    private startKeepalive;
    private stopKeepalive;
    /**
     * Initialize audio context
     */
    init(): Promise<boolean>;
    /**
     * Route audio to a specific output device via AudioContext.setSinkId
     * (Chromium 110+). `deviceId` "" → the system default. Stored so it
     * survives the AudioContext re-creation in init(). Returns false when
     * unsupported or the device can't be selected (e.g. unplugged).
     */
    setSinkId(deviceId: string): Promise<boolean>;
    /** Current output device id ("" = system default). */
    getSinkId(): string;
    /** True when the running engine can route output to a chosen device. */
    static isSinkSelectionSupported(): boolean;
    private applySinkId;
    /**
     * Configure audio format (logs only, format is taken from AudioData)
     */
    configure(sampleRate: number, channels: number): void;
    /**
     * Maximum number of output channels the user's audio device + browser
     * combination supports. 2 (stereo) for typical laptop/phone setups,
     * 6 for a 5.1 receiver, 8 for 7.1. Returns 2 when the AudioContext
     * hasn't been created yet.
     */
    getMaxChannelCount(): number;
    /**
     * Ask the AudioContext destination to accept `n` discrete channels
     * instead of Web Audio's default 2. `channelCountMode: "explicit"` +
     * `channelInterpretation: "discrete"` together suppress the
     * automatic speaker-layout downmix the API would otherwise apply,
     * so a 7.1 AudioBuffer reaches the device with all 8 planes intact.
     * Caller is responsible for ensuring the OS / hardware actually has
     * that many output channels — read getMaxChannelCount() first and
     * clamp accordingly.
     */
    setOutputChannelCount(n: number): void;
    /**
     * Render AudioData with precise timing
     */
    render(audioData: AudioData): void;
    /**
     * Render a raw PCM frame (browser-agnostic path used by the software
     * decoder). Avoids constructing a WebCodecs AudioData, which Firefox on
     * Android does not implement.
     */
    renderPCM(frame: PCMFrame): void;
    /**
     * Schedule a populated AudioBuffer through the stretcher + A/V sync
     * pipeline. Shared by render() and renderPCM().
     */
    private scheduleAudioBuffer;
    /**
     * Render raw PCM samples
     */
    renderSamples(samples: Float32Array[], sampleRate: number): void;
    /**
     * Start playback
     */
    play(): Promise<void>;
    /**
     * Kick off Signalsmith stretcher construction. Single-flight; idempotent.
     * The movi WASM module is shared with FFmpeg, so this is fast once the
     * player has loaded — just an instance allocation.
     */
    private maybeInitSignalsmith;
    /**
     * Pitch-preserving time stretch through Signalsmith. Returns the stretched
     * AudioBuffer, or null if the stretcher isn't ready yet (caller falls back
     * to source.playbackRate scaling, which shifts pitch but keeps audio playing).
     */
    private processStretch;
    /**
     * Warmup AudioContext (Safari fix)
     */
    private warmupContext;
    /**
     * Pause playback
     */
    private intentionalSuspend;
    pause(): void;
    /**
     * Suspend audio output for buffering without stopping data acceptance.
     * Keeps isPlaying=true so render() still accepts AudioData and buffers fill up.
     * Suppresses auto-recovery so the context stays suspended until resumeFromBuffering().
     */
    suspendForBuffering(): void;
    /**
     * Prepare for the first-play / replay audio prime: mark the renderer playing
     * so render() accepts decoded audio and the buffer fills, but hold the
     * AudioContext suspended so nothing drains until resumeFromBuffering().
     *
     * Unlike play() + suspendForBuffering(), this NEVER issues an async resume().
     * That pair raced on replay: after `ended`, pause() leaves the context
     * suspended; the prime's fire-and-forget play() then kicks off an async
     * resume(), and the immediately-following suspendForBuffering() sees the
     * context still "suspended" (resume in flight) so its state===running guard
     * skips the suspend — the late resume then wins and the context stays
     * running for the whole prime, draining the primed audio and underrunning
     * the sub-realtime software decoder into a flood of gap-fills. Priming
     * without ever resuming removes the race entirely.
     */
    primeForBuffering(): void;
    /**
     * Resume audio after buffering. Clears the intentional suspend flag.
     */
    resumeFromBuffering(): void;
    /**
     * Set volume (0-1) with smooth ramping to prevent clicks/pops
     */
    setVolume(volume: number): void;
    /**
     * Get volume
     */
    getVolume(): number;
    /**
     * Set playback rate
     */
    setPlaybackRate(rate: number): void;
    /**
     * Get playback rate
     */
    getPlaybackRate(): number;
    /**
     * Set pitch preservation mode
     */
    setPreservePitch(preserve: boolean): void;
    /**
     * Get pitch preservation mode
     */
    getPreservePitch(): boolean;
    /**
     * Check if audio is rebuffering due to playback rate change
     */
    isRebuffering(): boolean;
    /**
     * Mute with smooth fade to prevent clicks/pops
     */
    mute(): void;
    /**
     * Unmute with smooth fade to prevent clicks/pops
     */
    unmute(): Promise<void>;
    /**
     * Reset timing and stop all scheduled audio with smooth fade-out
     */
    reset(): void;
    /**
     * Get current audio context time
     */
    getCurrentTime(): number;
    /**
     * Get the audio clock - THE MASTER TIME SOURCE FOR A/V SYNC
     * Returns accurate time based on when audio actually started playing
     * Returns -1 if audio hasn't started yet
     * Clamps to maxScheduledMediaTime when audio has ended
     */
    getAudioClock(): number;
    /**
     * True when an AudioContext exists but the browser is keeping it suspended
     * despite us asking to play unmuted — i.e. autoplay-with-sound was blocked
     * because no user gesture has unlocked audio yet. resume() resolves without
     * throwing in this case (Chromium silently leaves the context suspended),
     * so callers can't detect the block from play()'s promise; they poll this
     * instead. Returns false when muted (we intentionally don't resume) or when
     * the context is genuinely running.
     */
    isBlockedSuspended(): boolean;
    /**
     * Check if audio has healthy buffers (not in underrun state)
     * Used by video renderer to decide whether to sync to audio
     */
    hasHealthyBuffer(): boolean;
    /**
     * Check if audio is actively playing
     */
    isAudioPlaying(): boolean;
    /**
     * Get filtered buffered duration (seconds ahead of current time)
     */
    getBufferedDuration(): number;
    /**
     * Get the furthest media time (seconds) already scheduled in Web Audio.
     */
    getMaxScheduledMediaTime(): number;
    /**
     * (Re)connect the audio graph for the current stable-audio state.
     *   stable ON : sources → input → compressor → gain(makeup) → destination
     *   stable OFF: sources → input → gain(volume)  → destination
     *
     * The volume/makeup gainNode is ALWAYS the final node before destination, so
     * a >100% boost is applied *after* the limiter instead of being cancelled by
     * it. Measured: with the old gain-before-limiter order, 100%→200% yielded
     * only ~+0.6dB; with gain after the limiter it's the full ~+6dB. Because the
     * limiter has already tamed peaks to ≈-15dBFS, a 2× makeup still lands well
     * under 0dBFS, so it does not re-introduce clipping.
     */
    private wireGraph;
    /**
     * Enable/disable stable audio mode (dynamic range compression / loudness normalization)
     */
    setStableAudio(enabled: boolean): void;
    /**
     * Get stable audio mode state
     */
    getStableAudio(): boolean;
    /**
     * Smoothly ramp gain to target value to prevent clicks/pops
     */
    /**
     * Convert a linear slider value (0-1) to a perceptual gain value.
     *
     * Human loudness perception is logarithmic, so a linear gain feels like
     * "almost everything happens in the first 10%" and the top 90% feels flat.
     * We map the slider through an exponential (dB-based) curve so that equal
     * slider movement produces a roughly equal perceived loudness change across
     * the whole range. 0 -> silence, 1 -> unity gain.
     */
    private perceptualGain;
    private rampGain;
    /**
     * Monitor AudioContext state changes and auto-recover from interruptions
     * Handles cases like: phone calls, other audio sources, OS-level interruptions
     */
    private setupContextStateMonitoring;
    /**
     * Attempt to recover AudioContext from interrupted/suspended state
     */
    private attemptContextRecovery;
    /**
     * Check if audio is in starvation state (no new data for extended period)
     * Used by Clock/MoviPlayer to decide whether audio clock is reliable
     */
    isAudioStarved(): boolean;
    /**
     * Get duration of current starvation period in ms (0 if not starved)
     */
    getStarvationDuration(): number;
    /**
     * Destroy renderer
     */
    destroy(): Promise<void>;
}
//# sourceMappingURL=AudioRenderer.d.ts.map