Building a Signal Processing Pipeline: From Raw Spectrum to Decoded Audio with GNU Radio and RTL-SDR

You installed GNU Radio, plugged in the RTL-SDR Blog V3 Receiver, and hit the generate button. The waterfall display lights up with color, but no matter where you click, nothing resembling a clean signal emerges. Just noise. A thick, undifferentiated band of thermal hiss and spectral clutter stretching across the entire bandwidth. You adjust the gain, shift the frequency, try every preset filter you can find. Still noise. This is the moment most newcomers to software-defined radio abandon the hobby, convinced the hardware is defective or the software is broken. It is neither. The problem is that nobody explained the pipeline.

The Invisible Architecture of Radio Reception

Every radio receiver, whether it sits on your nightstand or runs as a Python script on your laptop, performs the same fundamental sequence of operations. An antenna captures electromagnetic energy across a wide swath of spectrum. A tuner selects a narrow slice of that spectrum. A detector extracts the information encoded onto the carrier wave. An output stage converts that information into something perceptible -- sound, data, an image on a screen.

In a traditional analog receiver, these operations happen in physical hardware: inductors, capacitors, diodes, crystal oscillators. The signal path is tangible, traceable with a probe. In a software-defined radio, the same operations happen as mathematical transformations on arrays of numbers. The antenna still captures electromagnetic energy, and the tuner still selects a frequency band -- the R820T2 chip inside the RTL-SDR handles this in silicon. But everything downstream of the analog-to-digital converter exists as code.

This distinction matters more than most tutorials acknowledge. When you stare at that wall of noise in GNU Radio, you are not looking at a broken radio. You are looking at raw, unprocessed digitized RF energy, and you have not yet told the software how to filter, shift, and demodulate it into something meaningful. The pipeline is not automatic. You must build it.

Sampling: Where Physics Becomes Arithmetic

The RTL2832U chip samples the intermediate-frequency signal from the R820T2 tuner at rates up to 3.2 million samples per second. Each sample is an 8-bit number representing the instantaneous voltage at the ADC input. But radio signals are not scalar quantities. An electromagnetic wave has both amplitude and phase, and capturing both requires two measurements per sample point -- the in-phase (I) and quadrature (Q) components.

The RTL2832U outputs I/Q sample pairs, each component quantized to 8 bits, yielding a total of 16 bits per complex sample. At 2.4 MSPS (a common stable rate for the dongle), the USB 2.0 interface must transmit approximately 38.4 megabits per second of raw data. This is near the practical limit of USB 2.0, which is why pushing beyond 2.4 MSPS often produces dropped samples and visible spectral artifacts.

The 8-bit quantization per component limits the evolving range to approximately 48 decibels -- the ratio between the strongest signal the ADC can represent without clipping and the weakest signal distinguishable from quantization noise. For comparison, a 12-bit ADC provides roughly 72 dB of evolving range, and professional receivers with 14-bit or 16-bit converters exceed 84 dB. This 48 dB constraint shapes every downstream decision in the pipeline. You cannot simultaneously capture a strong local FM station and a weak distant signal; the strong station will consume most of the available evolving range, pushing the weak signal below the noise floor.

The Superheterodyne Legacy in Software

The signal processing pipeline you build in GNU Radio mirrors the architecture that Edwin Armstrong patented in 1918: the superheterodyne receiver. Armstrong's insight was that converting the incoming radio frequency to a fixed intermediate frequency simplifies filtering and demodulation, because you only need one set of filters optimized for a single frequency rather than a different filter for every station.

In GNU Radio, this conversion happens in the frequency domain through multiplication by a complex exponential -- a mathematical operation that shifts the entire spectrum by a specified offset. This is the software equivalent of Armstrong's local oscillator and mixer. After the frequency shift, a low-pass filter removes everything outside the bandwidth of interest, just as the IF filter in a hardware receiver strips away adjacent channels.

Consider the airband, which occupies 108 to 137 MHz and uses amplitude modulation. To receive a signal at 122.8 MHz (a common tower frequency), you configure the R820T2 tuner to center at 122.8 MHz. The dongle outputs I/Q data centered at DC (zero hertz), with your target signal now sitting at baseband. A low-pass filter with a cutoff around 10 kHz passes the modulated audio while rejecting adjacent channels. An envelope detector -- implemented as the magnitude of the complex signal -- extracts the AM audio. A final audio sink plays the result through your speakers. Three blocks in GNU Radio, replicating a century of receiver engineering in about sixty seconds of drag-and-drop.

Why Filters Are the Hard Part

The conceptual simplicity of the pipeline -- shift, filter, demodulate -- conceals the engineering complexity concentrated in that middle step. Filter design is where most SDR projects succeed or fail, and it is the step that most tutorials gloss over.

A low-pass filter in GNU Radio is typically implemented as a finite impulse response (FIR) filter. The filter is defined by its cutoff frequency, its transition bandwidth (how sharply it rolls off), and its stopband attenuation (how much it suppresses frequencies outside the passband). Sharper rolloff and deeper stopband attenuation require more filter taps -- more coefficients in the FIR kernel -- and each additional tap costs computational time.

For AM voice reception on the airband, a relatively gentle filter with a 5 kHz cutoff and a 2 kHz transition band works adequately. The signal is narrowband, adjacent channels are spaced 25 kHz apart, and the audio bandwidth requirement is modest. But for FM broadcast reception, the signal occupies approximately 200 kHz of bandwidth, and the demodulator requires a different filter shape entirely -- one that preserves the stereo subcarrier at 38 kHz and the RDS data subcarrier at 57 kHz if you want full fidelity.

The RTL-SDR Blog V3 Receiver, with its R820T2 tuner, provides approximately 50 dB of adjacent channel rejection before the signal even reaches the ADC. This analog preselection helps, but it is not sufficient for strong-signal environments. In urban areas with multiple high-power FM transmitters, the 8-bit ADC can saturate on a strong adjacent signal even after the tuner rejects it by 50 dB. This is why experienced SDR operators reduce the gain setting when working in strong-signal environments -- trading sensitivity for linearity.

From Theory to Working Pipeline

Building a working GNU Radio flowgraph for AM reception requires five blocks: an Osmocom source block (which interfaces with the RTL-SDR hardware), a frequency-translating FIR filter (which combines the frequency shift and low-pass filtering into one efficient operation), a complex-to-magnitude block (the AM envelope detector), a rational resampler (to convert the input sample rate to an audio-friendly rate like 48 kHz), and an audio sink. Connect them in sequence, set the center frequency to your target station, adjust the filter cutoff to match the signal bandwidth, and you will hear voice.

The frequency-translating FIR filter deserves special attention. It performs two operations -- frequency shift and low-pass filtering -- in a single step, which is computationally more efficient than performing them separately. The frequency shift is specified as a decimal offset from the center frequency, and the filter taps are computed automatically from the cutoff and transition bandwidth parameters you provide. GNU Radio includes a filter design tool (gr_filter_design) that lets you visualize the frequency response of your filter before committing it to the flowgraph.

For FM broadcast reception, the pipeline differs in the demodulation stage. FM signals encode information in frequency variations rather than amplitude variations, so the demodulator must extract the instantaneous frequency of the signal at each sample point. In GNU Radio, this is accomplished by computing the phase difference between consecutive complex samples -- the derivative of the phase, which is proportional to the instantaneous frequency deviation. This operation, combined with a deemphasis filter that compensates for the preemphasis applied at the transmitter, produces the baseband audio.

The Noise Floor and What Lives Beneath It

One of the most counterintuitive aspects of SDR is that noise is not the enemy -- it is the medium. Every radio signal exists within a background of thermal noise, atmospheric noise, and man-made interference. The noise floor, measured in dBFS (decibels relative to full scale of the ADC), defines the minimum detectable signal. Any signal below the noise floor is mathematically irrecoverable without additional processing techniques like averaging or correlation.

The RTL-SDR Blog V3, drawing approximately 300 milliwatts from its USB port, produces a noise floor that is adequate for receiving signals above approximately -110 dBm in the VHF band. This is sufficient for local FM stations, airband communications within line of sight, and ADS-B signals from aircraft within a 200-nautical-mile radius. It is not sufficient for weak-signal work like moonbounce communication or satellite telemetry from low-earth orbit without external low-noise amplifiers and high-gain antennas.

When users report