Struct AtomicLoudnessState 

pub struct AtomicLoudnessState {
    pub target_gain_db: AtomicF64,
    pub current_gain_db: AtomicF64,
    pub smoothing_coeff: AtomicF64,
    pub album_gain_db: AtomicF64,
    pub preamp_gain_db: AtomicF64,
    pub enabled: AtomicBool,
    pub mode: AtomicU8,
}

Atomic loudness state for lock-free audio thread access. Uses AtomicF64 with Relaxed ordering (gains don’t need strict synchronization).

Fields

target_gain_db: AtomicF64

Target gain in dB (set by main thread, read by audio thread)

current_gain_db: AtomicF64

Current smoothed gain in dB (updated by audio thread)

smoothing_coeff: AtomicF64

Smoothing coefficient per sample (< 1.0, for multiplication)

album_gain_db: AtomicF64

Album gain for Album mode (same for all tracks in album)

preamp_gain_db: AtomicF64

Preamp gain for headroom adjustment (default -3 dB)

enabled: AtomicBool

Enable/disable normalization

mode: AtomicU8

Normalization mode: 0=Track, 1=Album, 2=Streaming

Implementations

impl AtomicLoudnessState

pub fn new(smoothing_time_ms: f64, sample_rate: u32) -> Self

pub fn set_target_gain(&self, gain_db: f64)

Set target gain.

H-2 fix: Guards against NaN/Infinity values that could propagate through the audio path and produce corrupted output by coercing them to 0 dB (no gain). This is reachable from the audio thread in streaming mode (LoudnessNormalizer::process), so the non-finite branch must stay allocation- and log-free; non-realtime callers that want to report invalid loudness (e.g. analyze_track) log it on their own path.

pub fn set_album_gain(&self, gain_db: f64)

Set album gain (call from main thread)

pub fn set_preamp_gain(&self, gain_db: f64)

Set preamp gain in dB (call from main thread)

pub fn set_enabled(&self, enabled: bool)

Set enabled state

pub fn set_mode(&self, mode: u8)

Set mode: 0=Track, 1=Album, 2=Streaming, 3=ReplayGainTrack, 4=ReplayGainAlbum

pub fn get_mode(&self) -> NormalizationMode

Get normalization mode as enum

pub fn set_smoothing(&self, smoothing_time_ms: f64, sample_rate: u32)

Update smoothing coefficient

pub fn process_gain(&self, frames: usize) -> f64

Process gain for a chunk (call from audio thread - lock-free) Returns the linear gain to apply (includes preamp)

All fields are read with Relaxed ordering. They are independent atomics, so this is deliberately not a consistent snapshot: a concurrent main-thread update can leave the mode and the gains momentarily mismatched for one block. That is acceptable because the resulting gain is exponentially smoothed (see remaining_factor below), so a single slightly-wrong target is inaudible and self-corrects on the next call.

pub fn get_info(&self) -> LoudnessInfo

Get current loudness info (for API responses)

Trait Implementations

impl Default for AtomicLoudnessState

fn default() -> Self

Returns the “default value” for a type.