Function validate_output

crates/firewheel-graph/src/processor/process.rs:702–767

(
    output: &mut [&mut [f32]],
    flags: &FirewheelBitFlags,
    shared_flags: &Arc<SharedFlags>,
    logger: &mut RealtimeLogger,
)

    logger: &mut RealtimeLogger,
) {
    if flags.contains(FirewheelBitFlags::VALIDATE_OUTPUT_IS_FINITE) {
        let mut non_finite_value = 0.0;

        for ch in output.iter_mut() {
            for s in ch.iter_mut() {
                // Try to optimize for auto-vectorization
                let is_finite = s.is_finite();

                non_finite_value = if is_finite { non_finite_value } else { *s };
                *s = if is_finite { *s } else { 0.0 };
            }
        }

        if non_finite_value != 0.0 {
            let _ = logger.try_error_with(|s| {
                #[cfg(feature = "std")]
                {
                    *s = format!(
                        "Non-finite number detected on audio output: {}",
                        non_finite_value
                    );
                }

                #[cfg(not(feature = "std"))]
                {
                    *s = bevy_platform::prelude::String::from(
                        "Non-finite number detected on audio output",
                    );
                }
            });
        }
    }

    if flags.contains(FirewheelBitFlags::DETECT_CLIPPING_ON_OUTPUT) {
        let mut clipping_occurred = false;

        for ch in output.iter() {
            let max_peak = firewheel_core::dsp::algo::max_peak(ch);

            if max_peak > 1.0 {
                clipping_occurred = true;
                break;
            }
        }

        if clipping_occurred {
            shared_flags
                .clipping_occurred
                .store(true, Ordering::Relaxed);
        }
    }

    if flags.contains(FirewheelBitFlags::HARD_CLIP_OUTPUTS) {
        for ch in output.iter_mut() {
            for s in ch.iter_mut() {
                *s = s.clamp(-1.0, 1.0);
            }
        }