/**
 * 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 droppedWhileSuspended;
    private firstBufferScheduledAt;
    private firstBufferMediaTime;
    private hasFirstBuffer;
    private _lastUnderrunAt;
    private _ducked;
    /** Output held silent across the unmute re-read — see silenceForResync. */
    private _resyncSilenced;
    private static readonly DUCK_FADE_OUT;
    private static readonly DUCK_FADE_IN;
    private static readonly DUCK_CLEAR_MS;
    private _suppressDuckUntil;
    private currentMediaTime;
    private maxScheduledMediaTime;
    private lastDecodeTime;
    private scheduledCount;
    private isRebufferingForRateChange;
    private preservePitch;
    private signalsmith;
    private signalsmithLoading;
    private signalsmithSampleRate;
    private _decodedSampleRate;
    private _stableAudio;
    /** The state the GRAPH is actually wired for, so a repeated request for the
     *  state we are already in doesn't tear the chain apart to rebuild it
     *  identically — see setStableAudio. */
    private _wiredStableAudio;
    private _sinkId;
    private static readonly GAIN_RAMP_TIME;
    private static readonly FADE_OUT_TIME;
    private contextStateHandler;
    /**
     * Latches sharedContextActivated the moment the context reaches "running".
     * Separate from contextStateHandler on purpose: that one is stable audio's
     * recovery monitor and is only wired when stable audio is on, while "audio
     * got unlocked this session" is a fact every path needs — see init().
     */
    private contextActivationHandler;
    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)
     */
    /** Decoded source sample rate, from configure(). 0 until the decoder reports. */
    private _sourceSampleRate;
    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().
     */
    /**
     * Decode as far ahead as the pipeline likes; keep the graph narrow anyway.
     *
     * Every scheduled buffer is a live AudioBufferSourceNode, and WebAudio pulls
     * every connected node once per render quantum whether it has started or
     * not. Committing each buffer the moment it was decoded tied the width of
     * the graph to the depth of the buffer: software audio runs a 5s lead, AAC
     * frames are 23ms, so ~215 nodes. A desktop shrugs. A phone's audio thread
     * misses its deadline, and a missed deadline is a click — measured on mobile
     * Chrome as cushion=4199ms sources=181 with the context's own outputLatency
     * wandering between 600 and 770ms, and with no underrun and no late
     * schedule: the data was there, on time, and the graph was simply too wide
     * to render.
     *
     * So the two are separated. Buffers wait here as plain data, costing
     * nothing, and become nodes only once their turn is within LOOKAHEAD. The
     * lead is unchanged — getBufferedDuration counts what is waiting — so the
     * decode headroom the deep buffer was for is still there.
     */
    private scheduleAudioBuffer;
    /**
     * Hand over every buffer whose turn has come.
     *
     * Driven both by arriving audio and by a timer, because the queue has to
     * keep draining when nothing is arriving — which is exactly what happens
     * once the player hits its buffer cap and stops feeding.
     */
    private pumpSchedule;
    private commitAudioBuffer;
    /**
     * 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
     */
    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;
    /**
     * True once the shared AudioContext has run (been unlocked by a gesture) at
     * any point this session — see the module-level sharedContextActivated latch.
     * After that, a gesture-free resume() will succeed on its own, so a suspended
     * state seen right after init() is just the async resume still in flight and
     * WILL recover. Callers use this to wait it out instead of falling back to
     * muted autoplay (which would flash the "tap to unmute" pill on every
     * auto-advanced track).
     */
    wasEverActivated(): 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)
     */
    /**
     * True when audio frames are being thrown away rather than scheduled: muted
     * with a context the browser won't let us start (the autoplay-blocked state,
     * before any gesture). Only then is audio genuinely absent from the pipeline
     * — a muted context that IS running still schedules everything, at gain 0,
     * and still drives the clock.
     *
     * An intentional suspend (a prime / buffering hold) is explicitly NOT this
     * state: we suspended the context ourselves precisely so decoded audio
     * accumulates against a frozen clock, and it resumes on our own call.
     */
    isDroppingAudio(): boolean;
    getBufferedDuration(): number;
    /**
     * True if we patched a hole with silence within `withinMs`. A run of these
     * means the decode pipeline has fallen behind realtime — the audio the user
     * hears is already broken, so the player surfaces its buffering state rather
     * than claiming to play. High packet-rate codecs (TrueHD/MLP/DTS) are what
     * hit this: they read far more often than AAC, so anything that adds latency
     * per read shows up here first — the same file decodes clean from a local
     * file and stutters over HTTP.
     */
    isUnderrunning(withinMs?: number): boolean;
    /**
     * Fade the input out to cover a run of underruns.
     * Rides on inputNode, never gainNode: gainNode carries the user's volume and
     * boost, and stomping it here would fight setVolume() and leave the ducked
     * level behind as the user's own setting.
     */
    /**
     * Suppress ducking for the next `ms` and release any current duck. Called by
     * the player around a background→foreground recovery, whose decoder flush +
     * re-seek briefly starves audio — a transient underrun that must not mute.
     */
    suppressDuckFor(ms: number): void;
    /** Immediately restore the input gain and clear the duck (no fade). */
    private forceUnduck;
    /**
     * Put silence across a gap in the schedule, so the seam is joined rather
     * than torn.
     *
     * WebAudio does not play "nothing" between two buffer sources — it plays
     * whatever the graph last had, then the next buffer starts abruptly. That
     * step is the click. A silent buffer laid over the gap gives the output
     * something continuous to run through, which is what the underrun path has
     * always done; these two callers are the seams that were missing it.
     *
     * Logged, because a click that leaves no trace is a bug nobody can find
     * twice: the reason mobile-only clicking survived several rounds of looking
     * is that neither of these paths said anything at all.
     */
    private fillSeam;
    /** Throttle for the once-a-second output line above. */
    private _lastHealthLogAt;
    /** Decoded audio waiting for its turn to become a node — see
     *  scheduleAudioBuffer. Plain data; costs nothing until committed. */
    private _pending;
    private _pendingDuration;
    private _pumpTimer;
    /** How far ahead of the output a buffer may be turned into a node. Wide
     *  enough that jank cannot starve the graph, narrow enough that the node
     *  count stays in the dozens rather than the hundreds. */
    private static readonly SCHEDULE_LOOKAHEAD;
    /** How often the queue drains itself while no audio is arriving. */
    private static readonly PUMP_INTERVAL_MS;
    private duckForUnderrun;
    /**
     * Fade back in, but only once no underrun has landed for DUCK_CLEAR_MS.
     * Called on every scheduled buffer, so recovery needs no external signal.
     */
    /**
     * Hold the output silent WITHOUT touching the mute flag.
     *
     * Tap-to-unmute has to resume the AudioContext inside the tap — the browser
     * won't allow it a task later — but the audio that resume makes audible is
     * whatever the decoder holds, which is not where the picture is. So the
     * viewer heard a second of the wrong moment, then a seek, then the right one.
     * Resuming stays on the tap; this keeps it inaudible until the re-read lands.
     *
     * Same gain node the underrun duck uses, its own flag, and the duck can't
     * lift it — see unduckIfClean.
     */
    silenceForResync(): void;
    /** Fade back in once the re-read has landed. Safe to call unconditionally. */
    releaseResyncSilence(): void;
    private unduckIfClean;
    /**
     * 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