Struct FftBin 

#[repr(C)]
pub struct FftBin {
    pub re: f32,
    pub im: f32,
}

One frequency bin: a complex number, single precision.

Laid out as NE10 lays out its own, so a slice of these is handed to the transform as it stands rather than converted. Not num_complex’s Complex32, which this crate would then owe a major version to; the fields are public and the conversions cheap.

Fields

re: f32

The real part.

im: f32

The imaginary part.

Implementations

impl FftBin

pub const ZERO: Self

The origin: both parts zero.

The same value Default gives, in a form a const item and an array initialiser can use.

pub const fn new(re: f32, im: f32) -> Self

A bin from its two parts.

pub fn magnitude(self) -> f32

The magnitude, sqrt(re² + im²).

The same quantity Bela’s Fft::fda reports, not the same bits: that one uses sqrtf_neon, an approximation from libraries/math_neon, and short-circuits to 0 when both parts are zero.

Examples found in repository

examples/fft.rs (line 327)

    fn analyse(&mut self, context: &BlockContext) {
        let Some(analysis) = &mut self.analysis else {
            return;
        };
        if context.audio_in_channels() == 0 {
            return;
        }

        for frame in 0..context.audio_frames() {
            analysis.window[analysis.filled] = context.audio_read(frame, 0);
            analysis.filled += 1;
            if analysis.filled < analysis.window.len() {
                continue;
            }
            analysis.filled = 0;

            let transformed = {
                let _section = analysis.timer.measure();
                analysis
                    .fft
                    .forward(&mut analysis.window, &mut analysis.spectrum)
            };
            if transformed.is_err() {
                // Both buffers came from the plan, so their lengths
                // agree by construction; saying so beats going quiet
                // if a later edit changes one. Once per window rather
                // than once per block, which is why this one prints
                // where the measurement below does not.
                rt_println!("render_post: the analysis buffers no longer fit the plan");
                continue;
            }

            // The loudest bin, skipping DC — which a little offset on
            // the input would otherwise win every time.
            let peak = analysis
                .spectrum
                .iter()
                .enumerate()
                .skip(1)
                .max_by(|(_, a), (_, b)| a.magnitude_squared().total_cmp(&b.magnitude_squared()));
            if let Some((bin, value)) = peak {
                #[allow(
                    clippy::cast_precision_loss,
                    reason = "a bin index is far below f32's exact integer range"
                )]
                let hz = self.sample_rate * bin as f32 / analysis_length_as_float();
                self.published
                    .peak_hz
                    .store(hz.to_bits(), Ordering::Relaxed);
                self.published
                    .peak_magnitude
                    .store(value.magnitude().to_bits(), Ordering::Relaxed);
            }
        }
    }

pub const fn magnitude_squared(self) -> f32

The magnitude squared, re² + im².

What to compare bins with: it orders them the same way magnitude does and has no square root in it.

Examples found in repository

examples/fft.rs (line 315)

    fn analyse(&mut self, context: &BlockContext) {
        let Some(analysis) = &mut self.analysis else {
            return;
        };
        if context.audio_in_channels() == 0 {
            return;
        }

        for frame in 0..context.audio_frames() {
            analysis.window[analysis.filled] = context.audio_read(frame, 0);
            analysis.filled += 1;
            if analysis.filled < analysis.window.len() {
                continue;
            }
            analysis.filled = 0;

            let transformed = {
                let _section = analysis.timer.measure();
                analysis
                    .fft
                    .forward(&mut analysis.window, &mut analysis.spectrum)
            };
            if transformed.is_err() {
                // Both buffers came from the plan, so their lengths
                // agree by construction; saying so beats going quiet
                // if a later edit changes one. Once per window rather
                // than once per block, which is why this one prints
                // where the measurement below does not.
                rt_println!("render_post: the analysis buffers no longer fit the plan");
                continue;
            }

            // The loudest bin, skipping DC — which a little offset on
            // the input would otherwise win every time.
            let peak = analysis
                .spectrum
                .iter()
                .enumerate()
                .skip(1)
                .max_by(|(_, a), (_, b)| a.magnitude_squared().total_cmp(&b.magnitude_squared()));
            if let Some((bin, value)) = peak {
                #[allow(
                    clippy::cast_precision_loss,
                    reason = "a bin index is far below f32's exact integer range"
                )]
                let hz = self.sample_rate * bin as f32 / analysis_length_as_float();
                self.published
                    .peak_hz
                    .store(hz.to_bits(), Ordering::Relaxed);
                self.published
                    .peak_magnitude
                    .store(value.magnitude().to_bits(), Ordering::Relaxed);
            }
        }
    }

pub fn phase(self) -> f32

The phase in radians, from -π to π.

Trait Implementations

impl Clone for FftBin

fn clone(&self) -> FftBin

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for FftBin

impl Debug for FftBin

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for FftBin

fn default() -> FftBin

Returns the “default value” for a type.

impl From<(f32, f32)> for FftBin

fn from((re, im): (f32, f32)) -> Self

Converts to this type from the input type.

impl From<[f32; 2]> for FftBin

fn from([re, im]: [f32; 2]) -> Self

Converts to this type from the input type.

impl PartialEq for FftBin

fn eq(&self, other: &FftBin) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for FftBin