I've been building a tool that generates synthetic RF signals with labels, mainly for training signal classifiers and testing DSP code: https://sigtera.com

You specify the signals and parameters, and it outputs IQ or spectrograms along with a JSON file per signal listing the parameters used to make it. It covers the usual modulations (PSK, QAM, FSK, OFDM, DSSS, etc.) and a fair number of real protocols like AIS, ADS-B, LoRa, Wi-Fi, BLE and GSM.

I set up two example configs that load straight into the form:

• A small PSK dataset with 100 BPSK/QPSK/8PSK samples at random SNR, symbol rate and roll-off: https://sigtera.com/scenes/psk_classification
• A recreation of the last few seconds of US Airways 1549 on the Hudson, using the NTSB report. It has the plane's Mode S transmissions and the ferries' AIS as heard from a nearby pier: https://sigtera.com/scenes/miracle_on_the_hudson

You can use it without an account, up to 100 MB per request. It's still early, so I'd appreciate any feedback, especially if something doesn't look right from a signals point of view.

I came across Paper VIII (Dual-Layer Topological Neuromorphic Architecture) and tested one of its ideas: replacing repeated trigonometric calculations with integer phase addition and precomputed lookup tables (LUTs).

1. How does it work? (First animation above)

The first animation shows how phase calculations can be represented using modular integer arithmetic.

For example, with 1,024 phase positions:

• Angles are converted into integers from 0 to 1023.
• Adding 1023 + 1 wraps back to 0.
• The resulting index retrieves a precomputed value from a lookup table.

This allows certain complex wave calculations to be approximated using integer addition and memory lookups instead of repeated trigonometric evaluations.

2. CPU benchmark — How much faster?

I tested 10 million unit-magnitude complex wave calculations on a CPU.

Results:

• Conventional calculation: 330.40 ms
• Optimized angle calculation: 195.61 ms
• Phase-Ring Z1024: 36.95 ms
• Phase-Ring Z2048: 33.26 ms

The fastest LUT approach was approximately 9.9× faster than the conventional baseline and 5.9× faster than the optimized baseline in this test.

However, this comes with trade-offs. Quantizing phases introduces approximation errors, and larger lookup tables require more memory.

These results apply to a specific type of wave computation, not general-purpose multiplication or physical PIM hardware.

Original Paper VIII (Zenodo):
https://doi.org/10.5281/zenodo.22782241

Implementation, benchmarks, and visualizations (GitHub):
https://github.com/heejun1105/phase-ring-plp-benchmark

I’m using a bladeRF 2.0 micro A9 and recently I’ve been facing random FPGA loading issues.Sometimes the FPGA loads perfectly fine, but other times I get these errors:
dev->backend->load_fpga failed: File or device I/O failure
Failed to switch to NULL interface
The strange thing is that I’ve successfully loaded FPGA images multiple times using the same laptop and USB cable before. I’m using Windows 11. Could this be due to insufficient USB power from my laptop, or is there something else I should check?
I’m also considering programming through JTAG to see if that helps. Has anyone faced a similar issue?

Starting a phd soon in an area involving array signal processing, beamforming and multi user detection. I have. I have a background in dsp, but i am pretty much starting from zero when it comes to array processing. Ive been looking into ressources, and it’s meanly antenna arrays and not array processing from a dsp perspective. M not sure what’s the best way to approach it without getting lost in theory.
So i am asking the experts, or anyone who’s done resea in these areas, what resources, books, courses would u recommend?

Ps: any advice you’d known before starting your phd would be really appreciated. Thanks!

Edit: fair callout below — the original text was AI-polished jargon that explained a technique without saying what it's for. Rewritten below; original kept further down since there are replies to it.

GrandOrgue is open-source software that plays real recorded pipe organs through a MIDI keyboard — every pipe of a real historic organ gets individually sampled once, and the software plays those recordings back live as you perform. Pull enough stops on a big instrument and one chord can trigger thousands of individual pipe recordings decoding and mixing at once, all before the next few milliseconds of audio are due at the sound card. Miss that deadline on an overloaded system and you get an audible glitch — same failure mode as any audio buffer underrun.

Instead of outputting a glitch when the deadline's missed, I built something that predicts what the missing moment of sound probably sounded like and splices it in, inaudibly, until real audio catches up — same basic idea as how a phone call hides a dropped packet instead of a gap of silence, just applied to a missed compute deadline instead of a dropped network packet. Built it inside GrandOrgue first, then pulled it into its own small library (xorcist) so the technique stands on its own.

Full derivation and measured results on GitHub for anyone who wants the actual DSP: [link]. Used Claude to help write the docs there — should've said that upfront.

(original post below, kept so the early replies still make sense

The classical phase-vocoder freeze (continue a bin by holding phase increment/amplitude) is exact for one partial per bin. This generalizes it: for bins containing two sinusoidal partials, a fitted two-pole autoregressive model continues both independently instead of producing beat artifacts.

Derived a hard aliasing limit for the two-partial model from root-coincidence (N/4 for the hop size), and use N/8 in practice as a safety margin — conditioning degrades badly approaching N/4 (verified numerically, singular at the limit). Stability: closed-form quadratic test before falling back to explicit root-finding + clamping, only when needed. Splice-in uses one of two seam-repair strategies chosen by spectral similarity per occurrence. There's a positive-feedback failure mode when previously-concealed audio gets re-analyzed by the same running STFT; a frequency-damping term kills it.

Full disclosure with the derivations and measured NMR results on real sustained material at high simulated miss rates: https://github.com/sebion7125/xorcist. Written to be reproducible independent of the host application (it's extracted from a real-time audio pipeline, but the technique isn't specific to it).

Posting for discussion of the technique, not really the application (polyphonic sampler). The constraint: decode many independently-positioned, differently-timed compressed streams concurrently, on SIMD hardware. Conventional variable-length entropy coding decodes with a per-sample data-dependent branch — kills vectorization outright.

Approach: divide each channel into fixed-length blocks, predict with one of four fixed-order integer linear predictors (coefficients are the standard Shorten/FLAC fixed-predictor set, RFC 9639 §10.2.5 — no claim of novelty there), store residuals at a single fixed byte width per block chosen from that block's own peak residual. Fixed-stride + branch-free lets up to 8 streams decode together in one AVX2 pass via a two-stage per-lane-extraction-then-transpose kernel, even mutually unaligned.

Measured on 4000+ real files: 4.75x decode throughput vs. a representative fixed-escape-width reference codec at a better compression ratio (1.53x vs 1.43x) under lab conditions — real production numbers are lower (~1.85x), documented honestly in the writeup rather than restating the lab figure as achieved. Full disclosure including the aliasing/entropy-ceiling analysis of why this is near the frontier for this constraint class: https://github.com/sebion7125/v3codec

Genuinely curious whether anyone's pushed further in this exact niche (fixed-stride + SIMD-batch, not general-purpose compression ratio).

# Signal Extraction and Eight-Register Assembly Processing

I was able to extract a signal and take that signal transform and turn it into assembly language processing that tracks 8 registers and produces end results.

The signal was processed through forward and reverse transformations.

Ambiguities were marked with a stigma at the state where they occurred. The transform was then reversed to locate the corresponding earlier state.

Once that state was identified, the stigma was recovered and the transformation was carried forward, adjusting for the change.

The processing retained the relationships between the original state, the ambiguity, the reverse transformation, and the reconciled state.

The resulting transform was implemented in assembly language with 8 registers tracking the processing state.

The implementation produced end results through the register-based processing sequence.

I am still unsure what all of this means, but I wanted to share the process and get some feedback.

https://github.com/chadcoulter/REDE-3iAtlas-Signal-Processing

Salut à tous les passionnés du son !

J'ai un petit défi ludique à vous proposer pour tester vos outils et vos oreilles. J'ai récupéré l'enregistrement audio des tonalités DTMF d'un appel passé depuis un téléphone fixe a monttreal (indicatif 514 ou 430 ou 450).

Avis aux amateurs de la transformée de Fourier, des spectrogrammes ou aux génies qui ont l'oreille absolue : qui sera le premier à deviner le numéro composé ? 🕵️‍♂️

🔗 Voici le lien pour écouter/télécharger l'audio :https://voca.ro/1iOZq1YS12uI

I've been visualizing bird song as a 3D graph instead of a spectrogram:

spectral peaks become nodes, connected by partial continuity, harmonic

ratios, and timbral proximity in a PCA-reduced MFCC space.

Pipeline, all written by hand (no librosa — I wanted every coefficient

auditable):

- STFT with parabolic interpolation for sub-bin peak frequency

- 64-band mel filterbank, Slaney-normalized

- DCT-II orthonormal → 40 MFCCs, c0 discarded, plus deltas

- PCA to 3D via eigendecomposition of the covariance matrix

- Chroma folding + flatness/centroid/spread/flux

The part I thought this sub might find useful: I later ported the whole

thing to C++ for an Android build, and verified the port by compiling the

C++ standalone and comparing it against the Python on identical input.

centroid, spread, flux, tonality, chroma concentration

→ correlation 1.000000, max relative error ~1e-4 (float32)

spectral peaks detected → 3146 in both

PCA explained variance → 22.3% / 18.0% / 12.3%, identical

Two things I'm unsure about and would like opinions on:

1. For the PCA I used cyclic Jacobi on the covariance matrix rather than

   a proper SVD of the centered data. D is only 78 so it's cheap, and the

   eigenvectors of the covariance are the right singular vectors anyway —

   but I'm aware this squares the condition number. For this data it

   matched NumPy exactly, so it didn't bite. Is there a case here where

   it would?

2. Partial tracking is greedy nearest-neighbor in log-frequency with a

   ~1 semitone gate, strongest peaks choosing first. Optimal assignment

   (Hungarian) would be more correct. For trills at 10+ syllables/second,

   is greedy actually losing tracks, or is the gate doing enough work?

Code (Python + the C++ port): https://github.com/gustaavoq94/birdgraph

I'm trying to learn the steps of the FFT. I'm using this document, especially the matrices on page 4: https://hal.usc.edu/chugg/docs/301/fft_intro.pdf
Let's say I have a simple signal: [0, 4, 0, -4]
If I do this hand calculation I get:
[ 1 1 1 1 ] [ 0 ] = [ 0 ]
[ 1 -j -1 j ] [ 4 ] = [ -8j ]
[ 1 -1 1 -1 ] [ 0 ] = [ 0 ]
[ 1 j -1 -j ] [ -4 ] = [ 8j ]
But if I use the matrices on page 4 of the document I get: [0, -8j, 0, 8]
My steps are:
After P0: [0, 0, 4, -4]
After D0: [0, 0, 0, 8]
After P1=P0: [0, 0, 0, 8]
After D1: [0, 0, 8, -8j]
After P2: [0, -8j, 0, 8]
Where am I making a mistake?
I tried various AI agents, but they all gave fundamentally different answers. So I need an actual human being to help me out. Mathematics still needs humans.

I was looking for small TTS model which is steerable but couldn't find any, specially something I can adjust contextually by providing controls from LLM during a conversation. So I built one.

What it is:

• 9.6M-param acoustic model (attention + bidirectional Mamba-3, FastPitch-style) + Vocos vocoder = 23M total
• 12 controls, each a z-score relative to the chosen voice’s own neutral speech: rate, loudness, median pitch, pitch range, final rise/fall, pauses, spectral tilt, breathiness-related measures.
• Also: 51 style tags, free-text prompts (resolved into an inspectable JSON request), inline markup (*emphasis*, [pause 400ms], <slow>…</slow>), sentence-level streaming
• 2,825 built-in (anonymized) voices, plus experimental zero-shot cloning

Speed:

- RTFx ~60–80 on an RTX 5070
- ~4–8 on CPU without the optional flow refiner. First streamed audio in ~0.5 s on CPU.

Quality:

~1.8% average WER on the Open TTS Leaderboard English sets (run locally, not an official submission, have reached out for it).

What doesn’t work well (we tried to be upfront):

• Loudness, pitch, and tilt steer reliably; pause, voicing, and CPPS controls are weak
• Emotion tags behave as style switches; an independent emotion classifier mostly can’t tell them apart
• Cloning similarity is low. Don’t expect a convincing likeness
• Free-text prompts struggle with negation (“not fast” can come out fast). More data needed for prompt to controls module.
• English only, no human evals yet

License: weights CC BY-NC 4.0 (non-commercial), code MIT.

Model + full eval tables: https://huggingface.co/WhissleAI/steer-tts

I built an analogy that connects the magnitude, frequency, and rotation of circles using mechanical gears.

Assume you have a large gear with radius R1 that contains multiple smaller gears inside it. The perimeter of the largest gear is 2\pi R1, and one rotation takes T1 time; this is its fundamental period. The smallest gear has perimeter 2\pi R_N, and its fundamental period is T_N.

Now we record and analyze the frequencies over a given time, T. T should be greater than T1.

The smallest gear has the highest frequency, and the fundamental frequency is the lowest. (Of course, fundamental frequency is not always meant to be the lowest one; this assumption is valid for this example.)

The magnitudes of each harmonic are indeed the radii of each gear. This sets limits of the highest and lowest frequencies that can be measured from the observation time, T.

I love to built physical connections on abstract topics.I'm thrilled to hear your opinions. Any contribution and correction are welcomed.

Happy Day, Redditors!

Hi everyone,
I work in automotive software and want to build a solid understanding of Image Signal Processing (ISP) for ADAS cameras. I’m new to ISP, and I find vendor documentation difficult to follow without understanding the basics first.
I’m looking for a structured learning path covering:
Camera fundamentals: How image sensors work, RAW images, Bayer patterns, exposure, gain, and noise.
ISP pipeline: Demosaicing, white balance, noise reduction, color correction, HDR, and tone mapping.
ISP tuning: How to evaluate image quality and understand the trade-offs between different settings.
ADAS applications: How ISP settings affect object detection and perception, especially in low light or high-contrast scenes.
Which courses, books, YouTube playlists, or practical tutorials would you recommend? Free and paid options are both welcome. Hands-on exercises using RAW images, Python, or OpenCV would be especially helpful.
If you work in automotive imaging, where would you start, and in what order would you learn these topics? Please share links or resource names.
Thanks!

Bit of an odd ball thing to post I know, someone might find it useful so last night I open sourced my TigerSharc 201 tool chain.

Its a DSP chip that is relevant in the music world specifically in signal processing, but has many other applications.

This project contains the 3 core components of any chip's toolchain, the Compiler (C to Assembly) the Assembler (Assembly to Machine Objects) and the Linker (Compiles your objects and provides a binary the DSP can run)

http://www.github.com/rm2kdev/TigerSharc-201-Tool-Chain

I built and used this to compile a firmware for a particular bit of kit, unfortunately that project was shut down by the manufacturer (respectfully and politely I'll add) so I pivoted to building my own vst thing instead www.forgeefx.com (not an ad, just part of the true story) since all the code was pure C i just stopped using this compiler, and ported to a vst.

Its highly optimized and produces binaries that run faster than the real compiler, yes, a good bit of AI assistance (still claiming to be an engineer as I've worked in the industry for 20+ years), no reverse engineering used it was created by reading the DSP/CPU's instruction set in the official published documentation (Processor Programming Reference) and cleanly implementing all of those instructions and then building optimizations for the compilation process. (mostly around math, opcode usage, memory etc)

This on its own, does not produce binaries that run on any hardware (That would need a boot loader, and firmware, and other work), it does however produce binaries that run on this exact DSP/CPU in question.

Happy to answer any questions.

Hello DSP community,

Today, something I haven't figured out hit me differently, and I want to discuss it. I was thinking about the perimeter of the circle, which is quite easy to say straightforwardly:

Perimeter=2(\pi)r, and this is also an arc length. Now, assume you take a compass with a unit radius. You start to draw just one circle. You get 2(\pi), which is a perimeter, and it is no longer in radians. It can be seen as radians because the value is exactly (2\pi), but it is not a angle anymore; it's a length. See the trick.

Then I started asking myself why we need degrees, because degrees mess with the whole logic. If I think in radians, I don't need to memorize equations for perimeter and arc length, and I can see the angle/length transformations clearly; instead, I can see the whole logical path.

I thought this is important and shapes the definition of period, and, what’s more, it's a kind of fundamental for signal analysis. How do you learn such formula? Is there anything wrong with my thinking?

Happy day!

Edit: Typo