cpal | Cross-platform audio I/O library in pure Rust

rodio uses cpal as the underlying audio library. This is where the concepts of host and device come from. Use the re-exported cpal module from rodio to get the system host and obtain a list of output devices.

Your code is, in a sense, fine; what you are seeing are basic problems with interpreting the FFT, not with computing it.

First, the FFT is naturally a function from complex samples to complex samples. When you start with a real-valued input signal and convert it to complex by adding a zero imaginary component (or any other simple value, even copying the real input_buffer[i]), the output will always be a mirrored spectrum.

(Complex-valued signals can have arbitrarily asymmetric spectra, distinguishing positive frequencies from negative ones. This is not widely useful in audio, but it is fundamental to software-defined radio (SDR) applications of FFT and other DSP operations.)

In order to not get the mirroring, you must discard one half of the output. (It's slightly more efficient — though not 50%, if I recall correctly — to skip computing that half, but it doesn't look like rustfft offers that option.)

If you discard the upper half of the output (in terms of array indices), then you will find that the remaining “frequency bins” are arranged from 0 Hz up to 22.05 kHz. The library documentation notes this:

Output Order

Elements in the output are ordered by ascending frequency, with the first element corresponding to frequency 0.

Applications that do use the second half of the spectrum often swap the two halves, so that instead of a range of 0 Hz to [sampling frequency]/2, they go from −[sampling frequency]/2 to +[sampling frequency]/2. But since you're starting with a real, not complex, signal, this doesn't apply to you; I just mention it since you might have seen it in other plots that have 0 Hz at the center.

The drop-off which is visible in the center of your image corresponds to the high-pass anti-aliasing filter required in any digital signal processing. It should appear at the right edge once you've discarded the right half.

Finally, your code does not appear to have any windowing applied to the input signal. Windowing is a complex topic, but it is necessary to account for the fact that the FFT presumes a periodic signal which exactly repeats over the length of the input buffer, but we're actually feeding it a signal whose period is not an even division of the input buffer; windowing dampens the effects of this by attenuating the beginning and ending portions of the signal.

You should look up a standard window function and apply it to your input data before the FFT; this should reduce the secondary peak you're observing.

For an equalizer I'd use an FFT algorithm implementation.

There are libraries for Rust, e.g. https://github.com/ejmahler/RustFFT. You can find more on crates.io.

In your code you are sending samples one by one, but the FFT expects a buffer (a sequence of samples during some short period of time). Given a buffer it outputs the frequencies graph in this time frame.

If you give it a sliding time window, then the repeating frequencies will be averaged, and it should show what you expect from a typical EQ. A ring buffer could be useful to collect samples in this sliding window (e.g. this one from dasp)

Function layout does not work in your example because layout cannot be nested and heatmap (invoked by seq_heatmap) already uses layout to generate the Heat Map.

The only solution I see is to retrieve the source code of function heatmap (from stats), rename it say myheatmap, and modify it to add the display of the color legend.

To retrieve the code of heatmap

Below part is problematic in some ways:

This is tricky, because the process borrows an iterator, which in turn borrows a struct. Putting just the iterator into an Arc<>> is not sufficient, because this pointer might still outlive the FileType it borrows. However, we can't put both the FileType and the iterator into a reference-counted struct, since that struct would then be self-referential.

The easiest solution to this that I can think of (short of using scoped threads) is to create an iterator that owns the FileType, and then put it into a Arc<>> (minimal playground example):

hue_order can be used to force all hue values to be present (and set their order).

The family of seqplot functions offers a series of arguments to control the legend as well as the axes. Look at the help page of seqplot (and of plot.stslist.statd for specific seqdplot parameters).

For instance, you can suppress the x-axis with axes=FALSE, and the y-axis with yaxis=FALSE.

To print the legend you can let seqdplot display it automatically using the default with.legend=TRUE option and control it with for examples cex.legend for the font size, ltext for the text. You can also use the ncol argument to set the number of columns in the legend.

The seqplot functions use by default layout to organize the graphic area between the plots and the legend. If you need more fine tuning (e.g. to change the default par(mar=c(5.1,4.1,4.1,2.1)) margins around the plot and the legend), you should create separately the plot(s) and the legend and then organize them yourself using e.g. layout or par(mfrow=...). In that case, the separate graphics should be created by setting with.legend=FALSE, which prevents the display of the legend and disables the automatic use of layout.

The color legend is easiest obtained with seqlegend.

I illustrate with the mvad data that ships with TraMineR. First the default plot with the legend. Note the use of border=NA to suppress the too many vertical black lines.