rtlsdr 0.1.12 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b6555286674227e3eecacbaad200294e4392ac041e30db601cf824b634c998e7
-  data.tar.gz: 174fe5589fd1a1804a622287a19a0b40181987fc8cb9cf6c0817df2119196be6
+  metadata.gz: '019e21a841f8f9f9aaf543741487c734d4b1c7b2ff4b2bfd20e37cf56fbfcf00'
+  data.tar.gz: c4c3657ae68d2b5f8f2b931c8256447b9ab8feb0d0bbdfe61e7d035e34ee4053
 SHA512:
-  metadata.gz: 71f8218b6bb7453004071b41cc618f388541e99e98a549c3c6c82382ee89b6a82dc0a8ddbcb5e40639f610dc8990d8d3d0c0399070ddb90f62979d3945f6263e
-  data.tar.gz: 9430d11b48acc14d91e8e43cfe5d1ba4b60807d91ef11dab3fff5c025d1f27aa4cde4cb00d5e8560d1edd4bac5a92c548915026c26da1b2c835d64ceeec535b0
+  metadata.gz: cf8de21d50dbf21fd92dfec27cdeab872ccf83e3bbe1132ebbeab74bba98ae4e84da90f794574fc8c742da761768f2f49b26f5ea3c345b49960646a0e63ea053
+  data.tar.gz: 5d587f36838184747666800ac202e52d33584169926f9cd2bd72db1d39a5f4189be4b7025898c675f274134ba326537f08782f9682d7e6fe58dce0921f21b497

data/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## [Unreleased]
 
+## [0.1.13] - 2025-09-26
+
+### Added
+
+### Changed
+
+### Fixed
+
+
 ## [0.1.12] - 2025-09-26
 
 ### Added

data/README.md

@@ -30,6 +30,20 @@ sudo apt-get install librtlsdr-dev
 brew install librtlsdr
 ```
 
+### Optional: FFTW3 for FFT Support
+
+To enable FFT features (fast spectrum analysis, frequency response, etc.), install FFTW3:
+
+```bash
+# Ubuntu/Debian
+sudo apt-get install libfftw3-dev
+
+# macOS
+brew install fftw
+```
+
+FFT features are optional - the gem works without FFTW3, but FFT-related functions will raise an error if called.
+
 ### From Source
 
 If you need to build librtlsdr from source, the gem will automatically try to build it:
@@ -169,6 +183,128 @@ power_spectrum = RTLSDR::DSP.power_spectrum(samples, 1024)
 peak_bin, peak_power = RTLSDR::DSP.find_peak(power_spectrum)
 ```
 
+### FFT Analysis (requires FFTW3)
+
+```ruby
+# Check if FFT is available
+if RTLSDR::DSP.fft_available?
+  # Forward FFT
+  spectrum = RTLSDR::DSP.fft(samples)
+
+  # Power spectrum in dB with windowing
+  power_db = RTLSDR::DSP.fft_power_db(samples, window: :hanning)
+
+  # Shift DC to center (like numpy.fft.fftshift)
+  centered = RTLSDR::DSP.fft_shift(spectrum)
+
+  # Inverse FFT
+  reconstructed = RTLSDR::DSP.ifft(spectrum)
+end
+
+# Available window functions: :hanning, :hamming, :blackman, :none
+windowed = RTLSDR::DSP.apply_window(samples, :blackman)
+```
+
+### Digital Filters
+
+```ruby
+# Create lowpass filter (100 kHz cutoff at 2.048 MHz sample rate)
+lpf = RTLSDR::DSP::Filter.lowpass(
+  cutoff: 100_000,
+  sample_rate: 2_048_000,
+  taps: 63,
+  window: :hamming
+)
+
+# Create highpass filter
+hpf = RTLSDR::DSP::Filter.highpass(cutoff: 1000, sample_rate: 48_000)
+
+# Create bandpass filter (voice: 300-3000 Hz)
+bpf = RTLSDR::DSP::Filter.bandpass(low: 300, high: 3000, sample_rate: 48_000)
+
+# Create bandstop (notch) filter
+notch = RTLSDR::DSP::Filter.bandstop(low: 50, high: 60, sample_rate: 48_000)
+
+# Apply filter
+filtered = lpf.apply(samples)
+
+# Zero-phase filtering (no phase distortion)
+filtered = lpf.apply_zero_phase(samples)
+
+# Get filter properties
+puts lpf.group_delay  # Delay in samples
+puts lpf.taps         # Number of filter taps
+
+# Get frequency response (requires FFTW3)
+response = lpf.frequency_response(256)
+```
+
+### Decimation and Resampling
+
+```ruby
+# Decimate by factor of 4 (with anti-aliasing filter)
+decimated = RTLSDR::DSP.decimate(samples, 4)
+
+# Interpolate by factor of 2
+interpolated = RTLSDR::DSP.interpolate(samples, 2)
+
+# Resample from 2.4 MHz to 48 kHz
+audio = RTLSDR::DSP.resample(samples, from_rate: 2_400_000, to_rate: 48_000)
+```
+
+## Demodulation
+
+The gem includes demodulators for common radio signals:
+
+### FM Demodulation
+
+```ruby
+# Wideband FM (broadcast radio 88-108 MHz)
+audio = RTLSDR::Demod.fm(samples, sample_rate: 2_048_000, audio_rate: 48_000)
+
+# With European de-emphasis (50µs instead of US 75µs)
+audio = RTLSDR::Demod.fm(samples, sample_rate: 2_048_000, tau: 50e-6)
+
+# Narrowband FM (voice radio, ham, FRS)
+audio = RTLSDR::Demod.nfm(samples, sample_rate: 2_048_000)
+```
+
+### AM Demodulation
+
+```ruby
+# Envelope detection (simple AM)
+audio = RTLSDR::Demod.am(samples, sample_rate: 2_048_000)
+
+# Synchronous AM (better quality)
+audio = RTLSDR::Demod.am_sync(samples, sample_rate: 2_048_000)
+```
+
+### SSB Demodulation
+
+```ruby
+# Upper Sideband (ham radio above 10 MHz)
+audio = RTLSDR::Demod.usb(samples, sample_rate: 2_048_000, bfo_offset: 1500)
+
+# Lower Sideband (ham radio below 10 MHz)
+audio = RTLSDR::Demod.lsb(samples, sample_rate: 2_048_000, bfo_offset: 1500)
+```
+
+### Helper Functions
+
+```ruby
+# Generate complex oscillator for mixing
+osc = RTLSDR::Demod.complex_oscillator(1024, 1000, 48_000)
+
+# Frequency shift a signal
+shifted = RTLSDR::Demod.mix(samples, -10_000, 2_048_000)
+
+# FM discriminator (phase difference)
+baseband = RTLSDR::Demod.phase_diff(samples)
+
+# De-emphasis filter for FM audio
+filtered = RTLSDR::Demod.deemphasis(audio, 75e-6, 48_000)
+```
+
 ## Frequency Scanning
 
 Scan frequency ranges to find active signals:
@@ -349,6 +485,8 @@ ruby examples/spectrum_analyzer.rb
 
 ### DSP Functions
 
+#### Basic Functions
+
 - `RTLSDR::DSP.iq_to_complex(data)` - Convert IQ bytes to complex samples
 - `RTLSDR::DSP.average_power(samples)` - Calculate average power
 - `RTLSDR::DSP.power_spectrum(samples, window_size)` - Power spectrum
@@ -358,6 +496,59 @@ ruby examples/spectrum_analyzer.rb
 - `RTLSDR::DSP.phase(samples)` - Extract phase information
 - `RTLSDR::DSP.estimate_frequency(samples, sample_rate)` - Frequency estimation
 
+#### FFT Functions (requires FFTW3)
+
+- `RTLSDR::DSP.fft_available?` - Check if FFTW3 is available
+- `RTLSDR::DSP.fft(samples)` - Forward FFT
+- `RTLSDR::DSP.ifft(spectrum)` - Inverse FFT
+- `RTLSDR::DSP.fft_power_db(samples, window:)` - Power spectrum in dB
+- `RTLSDR::DSP.fft_shift(spectrum)` - Shift DC to center
+- `RTLSDR::DSP.ifft_shift(spectrum)` - Reverse fft_shift
+- `RTLSDR::DSP.apply_window(samples, type)` - Apply window function
+
+#### Decimation and Resampling
+
+- `RTLSDR::DSP.decimate(samples, factor)` - Decimate with anti-aliasing
+- `RTLSDR::DSP.interpolate(samples, factor)` - Interpolate samples
+- `RTLSDR::DSP.resample(samples, from_rate:, to_rate:)` - Rational resampling
+
+### Filter Class
+
+- `Filter.lowpass(cutoff:, sample_rate:, taps:, window:)` - Design lowpass filter
+- `Filter.highpass(cutoff:, sample_rate:, taps:, window:)` - Design highpass filter
+- `Filter.bandpass(low:, high:, sample_rate:, taps:, window:)` - Design bandpass filter
+- `Filter.bandstop(low:, high:, sample_rate:, taps:, window:)` - Design bandstop filter
+- `#apply(samples)` - Apply filter to samples
+- `#apply_zero_phase(samples)` - Zero-phase filtering
+- `#frequency_response(points)` - Get filter frequency response
+- `#group_delay` - Get filter group delay
+- `#coefficients` - Get filter coefficients
+- `#taps` - Number of filter taps
+
+### Demod Module
+
+#### FM Demodulation
+
+- `Demod.fm(samples, sample_rate:, audio_rate:, deviation:, tau:)` - Wideband FM
+- `Demod.nfm(samples, sample_rate:, audio_rate:, deviation:)` - Narrowband FM
+
+#### AM Demodulation
+
+- `Demod.am(samples, sample_rate:, audio_rate:, audio_bandwidth:)` - Envelope detection
+- `Demod.am_sync(samples, sample_rate:, audio_rate:, audio_bandwidth:)` - Synchronous AM
+
+#### SSB Demodulation
+
+- `Demod.usb(samples, sample_rate:, audio_rate:, bfo_offset:)` - Upper Sideband
+- `Demod.lsb(samples, sample_rate:, audio_rate:, bfo_offset:)` - Lower Sideband
+
+#### Helper Functions
+
+- `Demod.complex_oscillator(length, frequency, sample_rate)` - Generate carrier
+- `Demod.mix(samples, frequency, sample_rate)` - Frequency shift signal
+- `Demod.phase_diff(samples)` - FM discriminator
+- `Demod.deemphasis(samples, tau, sample_rate)` - De-emphasis filter
+
 ### Scanner Class
 
 - `Scanner.new(device, options)` - Create frequency scanner
@@ -384,9 +575,10 @@ This gem is licensed under the MIT license.
 
 ## Requirements
 
-- Ruby 2.7 or later
+- Ruby 3.3 or later
 - librtlsdr (installed system-wide or built locally)
 - FFI gem
+- libfftw3 (optional, for FFT functions)
 
 ## Supported Platforms
 

data/lib/rtlsdr/demod.rb

@@ -0,0 +1,386 @@
+# frozen_string_literal: true
+
+module RTLSDR
+  # Demodulation algorithms for common radio signals
+  #
+  # The Demod module provides methods for demodulating FM, AM, and SSB signals
+  # from complex IQ samples. All demodulators output real-valued audio samples
+  # that can be played back or written to audio files.
+  #
+  # @example Demodulate FM radio
+  #   samples = device.read_samples(262144)
+  #   audio = RTLSDR::Demod.fm(samples, sample_rate: 2_048_000)
+  #
+  # @example Demodulate AM signal
+  #   audio = RTLSDR::Demod.am(samples, sample_rate: 2_048_000)
+  #
+  # @example Demodulate SSB (upper sideband)
+  #   audio = RTLSDR::Demod.usb(samples, sample_rate: 2_048_000, bfo_offset: 1500)
+  module Demod
+    # =========================================================================
+    # Helper Functions
+    # =========================================================================
+
+    # Generate a complex oscillator (carrier signal)
+    #
+    # Creates an array of complex exponentials: exp(j * 2 * pi * freq * t)
+    # Used for frequency shifting (mixing) signals.
+    #
+    # @param [Integer] length Number of samples to generate
+    # @param [Numeric] frequency Oscillator frequency in Hz
+    # @param [Numeric] sample_rate Sample rate in Hz
+    # @return [Array<Complex>] Complex oscillator samples
+    # @example Generate 1 kHz oscillator at 48 kHz sample rate
+    #   osc = RTLSDR::Demod.complex_oscillator(1024, 1000, 48_000)
+    def self.complex_oscillator(length, frequency, sample_rate)
+      omega = 2.0 * Math::PI * frequency / sample_rate
+      Array.new(length) { |i| Complex(Math.cos(omega * i), Math.sin(omega * i)) }
+    end
+
+    # Mix (frequency shift) a signal
+    #
+    # Multiplies the input signal by a complex oscillator to shift its
+    # frequency. Positive frequency shifts up, negative shifts down.
+    #
+    # @param [Array<Complex>] samples Input complex samples
+    # @param [Numeric] frequency Shift frequency in Hz (negative = shift down)
+    # @param [Numeric] sample_rate Sample rate in Hz
+    # @return [Array<Complex>] Frequency-shifted samples
+    # @example Shift signal down by 10 kHz
+    #   shifted = RTLSDR::Demod.mix(samples, -10_000, 2_048_000)
+    def self.mix(samples, frequency, sample_rate)
+      omega = 2.0 * Math::PI * frequency / sample_rate
+      samples.each_with_index.map do |sample, i|
+        sample * Complex(Math.cos(omega * i), Math.sin(omega * i))
+      end
+    end
+
+    # Compute instantaneous phase difference (FM discriminator core)
+    #
+    # Calculates the phase difference between consecutive samples using
+    # the polar discriminator method. This is the core of FM demodulation.
+    #
+    # @param [Array<Complex>] samples Input complex samples
+    # @return [Array<Float>] Phase differences in radians (-π to π)
+    # @example Get FM baseband signal
+    #   phase_diff = RTLSDR::Demod.phase_diff(samples)
+    def self.phase_diff(samples)
+      return [] if samples.length < 2
+
+      result = Array.new(samples.length - 1)
+      (1...samples.length).each do |i|
+        prev = samples[i - 1]
+        curr = samples[i]
+        # Polar discriminator: arg(curr * conj(prev))
+        # = atan2(curr.imag*prev.real - curr.real*prev.imag,
+        #         curr.real*prev.real + curr.imag*prev.imag)
+        result[i - 1] = Math.atan2(
+          (curr.imag * prev.real) - (curr.real * prev.imag),
+          (curr.real * prev.real) + (curr.imag * prev.imag)
+        )
+      end
+      result
+    end
+
+    # Apply de-emphasis filter for FM audio
+    #
+    # FM broadcast uses pre-emphasis to boost high frequencies before
+    # transmission. This filter reverses that effect. Standard time
+    # constants are 75µs (US/Korea) or 50µs (Europe/Australia).
+    #
+    # @param [Array<Float>] samples Input audio samples
+    # @param [Float] tau Time constant in seconds (75e-6 for US, 50e-6 for EU)
+    # @param [Numeric] sample_rate Sample rate in Hz
+    # @return [Array<Float>] De-emphasized audio samples
+    def self.deemphasis(samples, tau, sample_rate)
+      return samples if samples.empty? || tau <= 0
+
+      # First-order IIR lowpass: y[n] = (1-alpha)*x[n] + alpha*y[n-1]
+      alpha = Math.exp(-1.0 / (tau * sample_rate))
+      one_minus_alpha = 1.0 - alpha
+
+      result = Array.new(samples.length)
+      result[0] = samples[0] * one_minus_alpha
+
+      (1...samples.length).each do |i|
+        result[i] = (samples[i] * one_minus_alpha) + (result[i - 1] * alpha)
+      end
+
+      result
+    end
+
+    # =========================================================================
+    # FM Demodulation
+    # =========================================================================
+
+    # Wideband FM demodulation (broadcast radio)
+    #
+    # Demodulates wideband FM signals such as broadcast FM radio (88-108 MHz).
+    # Applies a polar discriminator followed by de-emphasis filtering and
+    # decimation to the audio sample rate.
+    #
+    # @param [Array<Complex>] samples Input IQ samples
+    # @param [Integer] sample_rate Input sample rate in Hz
+    # @param [Integer] audio_rate Output audio sample rate (default: 48000)
+    # @param [Integer] deviation FM deviation in Hz (default: 75000 for WBFM)
+    # @param [Float, nil] tau De-emphasis time constant (75e-6 US, 50e-6 EU, nil to disable)
+    # @return [Array<Float>] Demodulated audio samples (normalized to -1.0 to 1.0)
+    # @example Demodulate FM broadcast
+    #   audio = RTLSDR::Demod.fm(samples, sample_rate: 2_048_000)
+    # @example European de-emphasis
+    #   audio = RTLSDR::Demod.fm(samples, sample_rate: 2_048_000, tau: 50e-6)
+    def self.fm(samples, sample_rate:, audio_rate: 48_000, deviation: 75_000, tau: 7.5e-5)
+      return [] if samples.empty?
+
+      # Step 1: FM discriminator (phase difference)
+      demodulated = phase_diff(samples)
+
+      # Step 2: Scale by deviation to get normalized audio
+      # The discriminator output is in radians per sample
+      # Scale factor: sample_rate / (2 * pi * deviation)
+      scale = sample_rate.to_f / (2.0 * Math::PI * deviation)
+      demodulated = demodulated.map { |s| s * scale }
+
+      # Step 3: Apply de-emphasis filter (if tau specified)
+      demodulated = deemphasis(demodulated, tau, sample_rate) if tau&.positive?
+
+      # Step 4: Decimate to audio rate
+      if sample_rate != audio_rate
+        # Convert to complex for DSP.resample, then back to real
+        complex_samples = demodulated.map { |s| Complex(s, 0) }
+        resampled = DSP.resample(complex_samples, from_rate: sample_rate, to_rate: audio_rate)
+        demodulated = resampled.map(&:real)
+      end
+
+      # Normalize output
+      normalize_audio(demodulated)
+    end
+
+    # Narrowband FM demodulation (voice radio)
+    #
+    # Demodulates narrowband FM signals such as amateur radio, FRS/GMRS,
+    # and public safety communications. Uses smaller deviation than WBFM.
+    #
+    # @param [Array<Complex>] samples Input IQ samples
+    # @param [Integer] sample_rate Input sample rate in Hz
+    # @param [Integer] audio_rate Output audio sample rate (default: 48000)
+    # @param [Integer] deviation FM deviation in Hz (default: 5000 for NBFM)
+    # @return [Array<Float>] Demodulated audio samples
+    # @example Demodulate NBFM voice
+    #   audio = RTLSDR::Demod.nfm(samples, sample_rate: 2_048_000)
+    def self.nfm(samples, sample_rate:, audio_rate: 48_000, deviation: 5_000)
+      # NBFM doesn't use de-emphasis
+      fm(samples, sample_rate: sample_rate, audio_rate: audio_rate, deviation: deviation, tau: nil)
+    end
+
+    # =========================================================================
+    # AM Demodulation
+    # =========================================================================
+
+    # AM demodulation using envelope detection
+    #
+    # Demodulates AM signals by extracting the magnitude (envelope) of the
+    # complex signal. This is the simplest AM demodulation method.
+    #
+    # @param [Array<Complex>] samples Input IQ samples
+    # @param [Integer] sample_rate Input sample rate in Hz
+    # @param [Integer] audio_rate Output audio sample rate (default: 48000)
+    # @param [Integer] audio_bandwidth Audio lowpass filter cutoff (default: 5000)
+    # @return [Array<Float>] Demodulated audio samples
+    # @example Demodulate AM broadcast
+    #   audio = RTLSDR::Demod.am(samples, sample_rate: 2_048_000)
+    def self.am(samples, sample_rate:, audio_rate: 48_000, audio_bandwidth: 5_000)
+      return [] if samples.empty?
+
+      # Step 1: Envelope detection (magnitude)
+      envelope = DSP.magnitude(samples)
+
+      # Step 2: Remove DC (carrier component)
+      # Use a simple high-pass by subtracting mean
+      mean = envelope.sum / envelope.length.to_f
+      audio = envelope.map { |s| s - mean }
+
+      # Step 3: Lowpass filter to audio bandwidth
+      if audio_bandwidth < sample_rate / 2
+        filter = DSP::Filter.lowpass(
+          cutoff: audio_bandwidth,
+          sample_rate: sample_rate,
+          taps: 63
+        )
+        complex_audio = audio.map { |s| Complex(s, 0) }
+        audio = filter.apply(complex_audio).map(&:real)
+      end
+
+      # Step 4: Decimate to audio rate
+      if sample_rate != audio_rate
+        complex_audio = audio.map { |s| Complex(s, 0) }
+        resampled = DSP.resample(complex_audio, from_rate: sample_rate, to_rate: audio_rate)
+        audio = resampled.map(&:real)
+      end
+
+      normalize_audio(audio)
+    end
+
+    # AM demodulation with synchronous detection
+    #
+    # Demodulates AM using synchronous detection, which provides better
+    # performance than envelope detection, especially for weak signals
+    # or signals with selective fading.
+    #
+    # @param [Array<Complex>] samples Input IQ samples
+    # @param [Integer] sample_rate Input sample rate in Hz
+    # @param [Integer] audio_rate Output audio sample rate (default: 48000)
+    # @param [Integer] audio_bandwidth Audio lowpass filter cutoff (default: 5000)
+    # @return [Array<Float>] Demodulated audio samples
+    def self.am_sync(samples, sample_rate:, audio_rate: 48_000, audio_bandwidth: 5_000)
+      return [] if samples.empty?
+
+      # Synchronous AM detection:
+      # 1. Estimate carrier phase using simple PLL-like approach
+      # 2. Multiply by recovered carrier to get baseband
+      # 3. Take real part
+
+      # Simple carrier recovery: use average phase
+      # For better performance, a proper PLL would be needed
+      phases = DSP.phase(samples)
+      avg_phase = phases.sum / phases.length.to_f
+
+      # Mix to baseband using recovered carrier phase
+      audio = samples.map do |sample|
+        # Multiply by exp(-j*avg_phase) and take real part
+        rotated = sample * Complex(Math.cos(-avg_phase), Math.sin(-avg_phase))
+        rotated.real
+      end
+
+      # Remove DC
+      mean = audio.sum / audio.length.to_f
+      audio = audio.map { |s| s - mean }
+
+      # Lowpass filter
+      if audio_bandwidth < sample_rate / 2
+        filter = DSP::Filter.lowpass(
+          cutoff: audio_bandwidth,
+          sample_rate: sample_rate,
+          taps: 63
+        )
+        complex_audio = audio.map { |s| Complex(s, 0) }
+        audio = filter.apply(complex_audio).map(&:real)
+      end
+
+      # Decimate to audio rate
+      if sample_rate != audio_rate
+        complex_audio = audio.map { |s| Complex(s, 0) }
+        resampled = DSP.resample(complex_audio, from_rate: sample_rate, to_rate: audio_rate)
+        audio = resampled.map(&:real)
+      end
+
+      normalize_audio(audio)
+    end
+
+    # =========================================================================
+    # SSB Demodulation
+    # =========================================================================
+
+    # Upper Sideband (USB) demodulation
+    #
+    # Demodulates USB signals commonly used in amateur radio above 10 MHz.
+    # Uses a Beat Frequency Oscillator (BFO) to convert the sideband to audio.
+    #
+    # @param [Array<Complex>] samples Input IQ samples
+    # @param [Integer] sample_rate Input sample rate in Hz
+    # @param [Integer] audio_rate Output audio sample rate (default: 48000)
+    # @param [Integer] bfo_offset BFO offset frequency in Hz (default: 1500)
+    # @param [Integer] audio_bandwidth Audio lowpass filter cutoff (default: 3000)
+    # @return [Array<Float>] Demodulated audio samples
+    # @example Demodulate USB signal
+    #   audio = RTLSDR::Demod.usb(samples, sample_rate: 2_048_000, bfo_offset: 1500)
+    def self.usb(samples, sample_rate:, audio_rate: 48_000, bfo_offset: 1500, audio_bandwidth: 3_000)
+      return [] if samples.empty?
+
+      # USB: Mix down by BFO offset, take real part
+      # The upper sideband appears above the carrier, so we shift down
+      mixed = mix(samples, -bfo_offset, sample_rate)
+
+      # Lowpass filter to audio bandwidth
+      filter = DSP::Filter.lowpass(
+        cutoff: audio_bandwidth,
+        sample_rate: sample_rate,
+        taps: 127
+      )
+      filtered = filter.apply(mixed)
+
+      # Take real part for audio
+      audio = filtered.map(&:real)
+
+      # Decimate to audio rate
+      if sample_rate != audio_rate
+        complex_audio = audio.map { |s| Complex(s, 0) }
+        resampled = DSP.resample(complex_audio, from_rate: sample_rate, to_rate: audio_rate)
+        audio = resampled.map(&:real)
+      end
+
+      normalize_audio(audio)
+    end
+
+    # Lower Sideband (LSB) demodulation
+    #
+    # Demodulates LSB signals commonly used in amateur radio below 10 MHz.
+    # Uses a Beat Frequency Oscillator (BFO) to convert the sideband to audio.
+    #
+    # @param [Array<Complex>] samples Input IQ samples
+    # @param [Integer] sample_rate Input sample rate in Hz
+    # @param [Integer] audio_rate Output audio sample rate (default: 48000)
+    # @param [Integer] bfo_offset BFO offset frequency in Hz (default: 1500)
+    # @param [Integer] audio_bandwidth Audio lowpass filter cutoff (default: 3000)
+    # @return [Array<Float>] Demodulated audio samples
+    # @example Demodulate LSB signal
+    #   audio = RTLSDR::Demod.lsb(samples, sample_rate: 2_048_000, bfo_offset: 1500)
+    def self.lsb(samples, sample_rate:, audio_rate: 48_000, bfo_offset: 1500, audio_bandwidth: 3_000)
+      return [] if samples.empty?
+
+      # LSB: Mix up by BFO offset, take real part
+      # The lower sideband appears below the carrier, so we shift up
+      mixed = mix(samples, bfo_offset, sample_rate)
+
+      # Lowpass filter to audio bandwidth
+      filter = DSP::Filter.lowpass(
+        cutoff: audio_bandwidth,
+        sample_rate: sample_rate,
+        taps: 127
+      )
+      filtered = filter.apply(mixed)
+
+      # Take real part for audio
+      audio = filtered.map(&:real)
+
+      # Decimate to audio rate
+      if sample_rate != audio_rate
+        complex_audio = audio.map { |s| Complex(s, 0) }
+        resampled = DSP.resample(complex_audio, from_rate: sample_rate, to_rate: audio_rate)
+        audio = resampled.map(&:real)
+      end
+
+      normalize_audio(audio)
+    end
+
+    # =========================================================================
+    # Private Helpers
+    # =========================================================================
+
+    # Normalize audio to -1.0 to 1.0 range
+    #
+    # @param [Array<Float>] samples Audio samples
+    # @return [Array<Float>] Normalized samples
+    def self.normalize_audio(samples)
+      return samples if samples.empty?
+
+      max_val = samples.map(&:abs).max
+      return samples if max_val.zero? || max_val < 1e-10
+
+      scale = 1.0 / max_val
+      samples.map { |s| s * scale * 0.9 } # Leave 10% headroom
+    end
+
+    private_class_method :normalize_audio
+  end
+end