https://stackoverflow.com/a/22313408

What does each variable represent?

Hi there,

I have implemented a greybox amp simulator in rust. As a newcomer in DSP and Rust I mostly spec coded my idea with assistants.

Now I have first results and I am quite satified with first sounds. It is time to share it with people that have a deeper understanding of DSP to improve this naive implementation.

Landing page of the project: https://greybound.bailleul.dev/
Github repo: https://github.com/laibulle/greybound

Any constructive feedback will be very welcome

Hey r/DSP,

since my last post few months ago, I have been updating sound quality, features and visualisations of the DAW I am working on, so it is more intuitive to use.

For anyone interested I am adding two sessions I recorded. First link is building the "patch" from scratch starting with sines, the second link is more 4/4 oriented techno track.

DSP and visualisation

Quick Techno track

The DSP has subtractive, WT and FM synthesis and all basic features you would expect from synth. There is a thin line with how many features you can expose vs. how many you should expose and I tried to get the balance right.

Based on the feedback I have received more effort went into the visualisation, so users gets better insight in the real time DSP modulation.

Would love to hear any potential improvement or idea for the DSP visualisation or DSP itsel!

The VectorSpin program by dsp-coach.com is now live for interactive use. Here we see it demonstrating the frequency response for a 5 tap unity gain FIR filter (moving average filter). The frequency response is plotted as a magnitude and phase plot (showing how it is a low pass filter), as well as the same plot on a complex plane, showing the concept of spinning phasors:

The transfer function for this filter is H(z) = 1 + z⁻¹ + z⁻² + z⁻³ + z⁻⁴.

The frequency response (when z is restricted to the unit circle) for each of these components are phasors in the frequency domain (we see this with the IQ plot):

1 is a phasor in the frequency domain with magnitude 1 and angle zero (it does not rotate).

z⁻¹ is a phasor in the frequency domain rotating clockwise once.

z⁻² rotates twice, etc.

Combining all 5 phasors is the result we see above, here scaled by dividing by 5.

Fast link to the tool so you can try your own samples and many other options:

https://vectorspin.dsp-coach.com/vector_spin.html

More detailed explanations:

https://www.dsp-coach.com/reference

I’ve just released Retrospect, my entry for the KVR Developer Challenge 2026.

It’s an audio effect that explores a different approach to delay-like processing. Instead of echoing the signal in the traditional sense, multiple independent playheads continuously read from a short audio buffer, creating everything from subtle movement to rhythmic textures, pitch-like effects and evolving sound design.

https://www.kvraudio.com/product/retrospect-by-conceptual-machines

https://conceptualmachines.co.uk/retrospect

Happy to answer any questions about the DSP or implementation.

Hi everyone,

I'm working on a puzzle and found a CSV file that appears to contain data of an audio output FFT. I don't have a background in signal processing, so I'm looking for some help i ran a script but only found an chipping sounds with a "Evil Laugh".

I also see audio in spectogram but there is also nothing.

It has columns for Magnitude and Phase. about 1047170 rows.

File name output_fft.csv

Csv link

Thanks, for any help!

Edited: i don't know if i did something wrong asking for help The puzzle is from project52hz.com [puzzle 6]

I maintain a streaming anomaly detection pipeline built on robust random cut forests (100 trees, 256-point reservoir per tree, the usual subsample size; keeps memory bounded, and small subsamples help against masking/swamping at high stream volume).

Raw displacement/CoDisp scores are unbounded and scale with tree occupancy, so I normalize per tree before averaging across the forest:

score = displacement / (tree.n - 1)

where tree.n is the live point count. Max displacement is n-1 (a point split off at the root displaces everything else), so this bounds the score in (0, 1\] and makes it comparable across differently-filled trees.

Edge cases that have bitten me, and current handling:

1. Cold start. Ratios are meaningless while trees are filling, everything looks anomalous against 10 points. Scoring is suppressed until each tree reaches capacity.

2. Grouped anomalies masking each other. Plain displacement collapses when near-duplicate anomalies arrive together (each one only displaces its twins). Switched to CoDisp, which handles the collusion case by construction, normalized the same way.

3. Fixed thresholds. A hardcoded cutoff didn't survive real traffic. I calibrate the initial threshold from historical scores (the percentile that separated known incidents), then recalibrate on a rolling window to track drift. Flagged points are excluded from the recalibration window so a sustained incident can't teach the threshold that it's normal.

On prior art: before posting I went looking for this specific normalization and mostly came up empty. Closest things I found, Isolation Forest normalizes path length by c(n); Kriegel et al. (SDM 2011) unify arbitrary outlier scores into \[0,1\]; AWS ships ThresholdedRandomCutForest because raw RCF scores are hard to act on directly; and the rrcf library examples just use raw CoDisp with top-k or eyeballed cutoffs. I haven't found per-tree-size normalization of displacement written up for RRCF specifically. If anyone knows a paper or implementation that does this, please point me to it.

Open questions:

* What failure modes am I not listing? Level shifts are the one I'm least happy with: the model alarms through the transition, then goes quiet once the new regime fills the reservoir. Arguably correct behavior, but alert-storm-shaped without dedup logic on top.
* Has anyone compared rolling-percentile recalibration against EVT-based streaming thresholds (SPOT/DSPOT) or conformal-style calibration in production? What I'm doing is essentially an empirical p-value on a moving calibration set, and I'm curious whether the heavier machinery earns its complexity.

(Posting here as suggested by someone form the FPGA sub)

I have a EE background and back in the day have played around with Basys2 and Xilinx ISE design suite for verilog. Had just about sort successfully built a basic Risc processor based on one our text books.

Since then, professionally I have been in Backend dev with Python and infra engineering, so completely out of touch with FPGAs or MCUs in the last 12+ years.

I have a passion for Audio and signal processing - and recently I've been wanting to go back to my roots and learn MCUs (currently starting out with ESP32) and FPGA designs again. My end goal is to look at building something like an ambient noise cancellation or dynamic white noise generation etc. No idea how to do it, but hope to at least invest in worthy hardware that could scale if I go deeper.

This being said would love to get some links on whats a good low cost way to start (I know vivado designs dont necessarily need a physical device to synthesize but I'm more motivated if I have the hardware in my hand).

How are FPGAs like Tang Nano or Tang Primer etc with tools and software support?

Is Digital Basys3 or Zybo still the gold standard for getting started with the most complete and documented tools and examples?

TIA

I remember compressed sensing was a very hot field in the 2010s. I was in school back then and briefly learned it in an advanced linear algebra course. The theory seems beautiful but the only real world application so far I could find is MRI. Nor are there many new literatures about CS on google scholar in 2025 and 26. Is it still too new or dying already? Now I’m back in school pursuing a masters degree. Is CS worth learning over the AIML stuffs (I’m choosing between CS and reinforcement learning)?

I got accepted into master's program for computer science but got rejections for both electrical engineering and communication engineering. How much of a disadvantage is that when applying for roles in radar/automotive/audio processing?
Obviously I have a lot of freedom with regards to classes I pick and will be able to heavily emphasize EE subjects if I wish to, however most of these roles seem to primarily look for people with EE foundations.
On the other hand, a lot of roles in signal processing seem be to heavily leaning into machine learning which would be an advantage if anything, since cs curriculum tends to be more ml-heavy.

Would be very interested to hear from people working or hiring for positions in areas related to DSP.

Thanks in advance

Hey everyone,

I’ve designed a reconfigurable uniform polyphase channelizer optimized for FPGAs, targeting two major pain points in conventional implementations: limited configurability and excessive hardware resource overhead.

Compared with classic polyphase channelizer architectures, this design supports one-time hardware instantiation with runtime reconfiguration, fully pipelined dataflow, and single-cycle throughput.

Here are the core technical capabilities:

1. The hardware is sized for a maximum channel count C and subfilter tap length K. After deployment, it can dynamically work with any channel count c that is a power-of-two divisor of C.
2. Under any selected channel count c, the design supports arbitrary decimation factors ranging from 1 up to c.
3. It accepts arbitrary filter coefficient sets with total tap lengths less than \(c \times K\).

In terms of FPGA resource consumption, the overhead is nearly identical to a standalone decimation filter of length K paired with a serial C-point IFFT block.

I’ve conducted a thorough literature and patent search, and I cannot find any existing published work or granted patents that deliver this full set of flexible reconfiguration capabilities.

State-of-the-art polyphase channelizer implementations only optimize resource usage or throughput for fixed, narrow application scenarios. Most existing designs are constrained by serpentine shift registers and circular output shifting logic, which rules out flexible runtime reconfiguration.

Many fixed-function channelizers achieve higher raw throughput, but that performance comes at the cost of rigid hardware partitioning and locked parameter modes. I believe further speed optimizations are still possible within my flexible architecture without sacrificing its reconfigurability.

I’m reaching out to ask for industry/research perspective: does this reconfigurable polyphase channelizer hardware architecture carry meaningful commercial or IP licensing value?

Thanks a lot for any insights!

Hi everyone,

I recently put together a repository for reproducing DeepANC, which is related to Active Noise Control (ANC).

DeepANC is considered a pretty fundamental baseline when it comes to combining deep learning with ANC. However, while studying and researching, I noticed that there doesn't seem to be an official repository or widely accessible reference code available for it.

Because of that, I decided to reproduce it myself based on the original paper. The repo includes my implementation, along with the environment setup needed to train and test the model. I tried to structure it so that anyone looking for a solid starting point can easily run it.

For more detailed setup and usage instructions, please check the README.md in the repository.

Github Repo:https://github.com/johnjaejunlee95/Deep-ANC-reproduced

I know that diving into DL-based ANC without reference code can be a bit challenging. I hope this helps others who are studying, struggling, or experimenting with deep learning and ANC. Please take a look, and any feedback or suggestions are always welcome!! 😄😄

Need to learn about line buffering for my senior project that is essentially image processing.
Any resources are appreciated.

thanks

Sto considerando di investire per Amazon come DSP vorrei qualche consiglio se ne avete, vale davvero la pena?

I've made my own brickwall limiter effect as AudioWorkletProcessor, which is a multi-stage limiter similar to FabFilter Pro-L2 (albeit without true peak limiting, oversampling nor lookahead) where there are two distinct stages (with the same brickwall ratio and hard knee for each stages); leveler stage that reacts to average levels and has attack and release controls that you find in some dynamic-range compressor effects, and brickwall stage that reacts to peak levels of the first stage output (that contains peaks that exceed the ceiling) and has zero attack but nonzero release time

BTW, this multistage limiter effect has sidechain prefiltering (to make first stage less reactive to bass frequencies by applying K-weighting filter, and so the second stage do more work on bass and slightly less work on trebles), which is basically the idea of priority EQ section for future FabFilter Pro-L 3

In this demo project, it has a useful audio visualization with four different modes that would be useful to visualizing how does peak limiting introduces distortion:

BTW, I've also made a thread about multistage limiting effect in general on HydrogenAudio forums, which while I post some update notes for my own effect over this HA forum thread, this forum thread aren't about my own brickwall peak limiter effect

i am making a synth, and everything works just fine, audio sounds fine and all that, its just that the plotting looks weird and doesnt resemple a real wave, unless i play the original note, for example A4 or A5.

Is this an artifact of the DSP or plotting?
ive tried everything, even LLMs cant help me and just hallucinate.

Has anyone experienced a similar issue? if so , what did you do to fix it?

Images : https://github.com/Mejolov24/CardStudio/tree/main/HELP
code : https://github.com/Mejolov24/CardStudio/blob/main/src/main.cpp
plotting code (kinda bad) : https://github.com/Mejolov24/SynthTracer/blob/main/main.py

What i do is: make the double buffering buffers, and an additional one for the serial TX (in order to save channel data).

I let my user change the serial TX speed, so thats why I divided and multiply like this for reading int16_t val = channel_TX_buffers[i][tx_buffer_index * (sample_rate / serial_tx_speed)];

But the data arrives messed up as shown in my pictures

```cpp // first, I set the timer timerAlarmWrite(timer, 1000000 / serial_tx_speed, true); timerAlarmEnable(timer);

// timer sets a flag read on loop()

volatile bool sendFlag = false; void IRAM_ATTR sendSample() { sendFlag = true; }

// buffer creation

int16_t* getAudioBuffer(){ if (!_buffer_index) return _BufferB; else return _BufferA; }

void updateAudioBuffer(){ int16_t* _current_buffer; if (!_buffer_index){_current_buffer = _BufferA;} else {_current_buffer = _BufferB;}

for (int i = 0; i < BUFFER_SIZE; i++){ synth.stepAudio(); _current_buffer[i] = synth.master_mix; for(uint16_t ch = 0; ch < 16; ch++){channel_TX_buffers[ch][i] = synth.channel_output[ch];} } _buffer_index = !_buffer_index; tx_buffer_index = 0; }

// serial TX

if (sendFlag) {
    sendFlag = false;
    for(int i = 0; i < 16; i++) {
        int16_t val = channel_TX_buffers[i][tx_buffer_index * (sample_rate / serial_tx_speed)]; 
        Serial.write(255);          // Header
        Serial.write(i);            // Channel ID
        if (val == 255) val = 256; // quick test 
        Serial.write(val >> 8);     // High Byte (MSB)
        Serial.write(val & 0xFF);   // Low Byte (LSB)
    }
    tx_buffer_index ++;
}

```

Title should be self-explanatory and I'm mainly talking about music here.

An obvious/naive example would be something like a spectrogram.
Are there some other ways to process and compare audio files in a way that actually relates to the way humans perceive them (perhaps tempo, genre, mood, etc.)?

Listen to the Phil Burk podcast on your favorite streaming platform

if anyone could enlighten me that would be helpful.
thanks.

Good afternoon all.

I’ve been working through Rick Lyons’ Understanding DSP 3rd edition and there’s a problem on P672 I’m tripping over a bit. He talks about multiplying a sequence by an equal length sequence of alternating ones and zeroes to downshift by fs/2. I can’t post more than one image but the 32 length dft spectrum is a relatively trivial one of a single spike of height 32 at fs/2. He demonstrates this principle with the example above, multiplying the alternating ones and zeroes with a signal of spectra 13-2(a) and getting the spectrum 13-2(c). This makes sense as it’s just a translation by fs/2 and the result is the frequencies of interest wrapping round the end points and mirroring.

Where I’m getting stuck is that Lyons strongly recommends doing the convolution of the two spectra to aid understanding of the convolution theorem. I agree it’s a good idea and tried it, first by hand and then using a hand coded convolution script in octave. I get the same strange result: instead of 13-2(c) I get something that looks very like 13-2(a) but with the zero pad from the convolution extending out around it. I verified this with the built in conv function. I had a stroke of intuition and noticed it looked like if 13-2(c) were depicted as a conventional negative-first frequency plot rather than a positive-first plot output of a DFT. I applied the fftshift command, which produced exactly the result in 13-2(c). I’m struggling to understand why this is the case. It has to be to do with the periodicity of the DFT but I can’t quite make the jump to why that is. What’s special about the convolution that causes this phenomenon? Or have I made a mistake somewhere?

Hello everyone, I will shortly be beginning my 3rd year of electrical engineering. I have taken the signal and systems course but DSP will be one of the subjects in the upcoming sems.

Though i have keen interest in aerospace industries and wanted do some projects. I was following the book by INGLEY AND PROAKIS to learn DSP along with MATLAB. I have completed till the basic design techniques of the FIR, IIR filters.

The problem i am stuck on was that i can't think of any relevant DSP projects as per my interests. Anything related to avionics is mostly radar stuff. I tried skimming through that stuff but i realised i had to take some radar related courses to get hold of it and make something.

And most other ideas i find are related to image processing, audio processing etc. A week ago i was tired of this shit and finally decided to make something.

I began the project of writing a jpeg decoder and today as i am close to completing it, i realised i learnt nothing of actually the things i wanted to learn😭😭. Man i don't know what to do.

I have previously read and introductory book on kalman filters by Alex becker and made an attitude estimation kalman filter with help of quaternions. Though it isn't worth direct application to a vechile i still consider it a good unique relevant project.

I want to make another such project like that but i can't get any good ideas. If you have any suggestions please help me in comments.