pwn 0.5.627 → 0.5.628

data/lib/pwn/sdr/decoder/dsp.rb

@@ -466,6 +466,13 @@ module PWN
         public_class_method def self.mag_sq(opts = {})
           iq = opts[:iq]
           n  = iq.length / 2
+          if native && n >= 64 && PWN::FFI.available?(mod: :Volk)
+            begin
+              return PWN::FFI::Volk.magnitude_squared(iq: iq)
+            rescue StandardError
+              # fall through
+            end
+          end
           out = Array.new(n)
           i = 0
           while i < n
@@ -567,6 +574,428 @@ module PWN
           { lag: best_lag, score: best_sc }
         end
 
+        CA_G2_TAPS = {
+          1 => [2, 6], 2 => [3, 7], 3 => [4, 8], 4 => [5, 9], 5 => [1, 9],
+          6 => [2, 10], 7 => [1, 8], 8 => [2, 9], 9 => [3, 10], 10 => [2, 3],
+          11 => [3, 4], 12 => [5, 6], 13 => [6, 7], 14 => [7, 8], 15 => [8, 9],
+          16 => [9, 10], 17 => [1, 4], 18 => [2, 5], 19 => [3, 6], 20 => [4, 7],
+          21 => [5, 8], 22 => [6, 9], 23 => [1, 3], 24 => [4, 6], 25 => [5, 7],
+          26 => [6, 8], 27 => [7, 9], 28 => [8, 10], 29 => [1, 6], 30 => [2, 7],
+          31 => [3, 8], 32 => [4, 9]
+        }.freeze
+
+        # ── True-air I/Q chain (all Decoder::* modules) ──────────────────
+
+        # Supported Method Parameters::
+        # out = PWN::SDR::Decoder::DSP.resample_iq(
+        #   iq: 'required - interleaved [I0,Q0,…] Array<Float>',
+        #   src_rate: 'required - Hz', dst_rate: 'required - Hz'
+        # )
+
+        public_class_method def self.resample_iq(opts = {})
+          iq  = opts[:iq]
+          src = opts[:src_rate].to_f
+          dst = opts[:dst_rate].to_f
+          return iq.dup if (src - dst).abs < 1.0 || iq.empty?
+
+          if native && PWN::FFI.available?(mod: :Liquid)
+            begin
+              return PWN::FFI::Liquid.resample_iq(iq: iq, rate: dst / src)
+            rescue StandardError
+              # fall through
+            end
+          end
+          n_in  = iq.length / 2
+          ratio = src / dst
+          n_out = (n_in / ratio).floor
+          out = Array.new(n_out * 2)
+          i = 0
+          while i < n_out
+            pos  = i * ratio
+            idx  = pos.floor
+            frac = pos - idx
+            2.times do |c|
+              a = iq[(idx * 2) + c] || 0.0
+              b = iq[((idx + 1) * 2) + c] || a
+              out[(i * 2) + c] = a + ((b - a) * frac)
+            end
+            i += 1
+          end
+          out
+        end
+
+        # Supported Method Parameters::
+        # out = PWN::SDR::Decoder::DSP.mix_iq(
+        #   iq: 'required - interleaved I/Q', rate: 'required - Hz',
+        #   freq: 'required - offset Hz to shift DOWN by'
+        # )
+
+        public_class_method def self.mix_iq(opts = {})
+          iq   = opts[:iq]
+          rate = opts[:rate].to_f
+          freq = opts[:freq].to_f
+          return iq.dup if freq.abs < 1e-3 || iq.empty?
+
+          if native && PWN::FFI.available?(mod: :Liquid)
+            begin
+              return PWN::FFI::Liquid.mix_down(iq: iq, freq: TWO_PI * freq / rate)
+            rescue StandardError
+              # fall through
+            end
+          end
+          n = iq.length / 2
+          w = TWO_PI * freq / rate
+          out = Array.new(n * 2)
+          i = 0
+          while i < n
+            ph = w * i
+            c = Math.cos(ph)
+            s = Math.sin(ph)
+            re = iq[i * 2].to_f
+            im = iq[(i * 2) + 1].to_f
+            out[i * 2] = (re * c) + (im * s)
+            out[(i * 2) + 1] = (im * c) - (re * s)
+            i += 1
+          end
+          out
+        end
+
+        # Supported Method Parameters::
+        # bits = PWN::SDR::Decoder::DSP.gfsk_slice(
+        #   iq: 'required - interleaved I/Q', rate:, baud:,
+        #   bt: 'optional - Gaussian BT (default 0.35)', invert: false
+        # )
+        # GFSK/GMSK/2-FSK: prefer liquid gmskdem at integer sps, else
+        # fm_demod_iq → nrz_slice.
+
+        public_class_method def self.gfsk_slice(opts = {})
+          iq   = opts[:iq]
+          rate = opts[:rate].to_f
+          baud = opts[:baud].to_f
+          bt   = (opts[:bt] || 0.35).to_f
+          inv  = opts[:invert]
+          return [] if iq.empty? || baud <= 0
+
+          sps = rate / baud
+          if native && PWN::FFI.available?(mod: :Liquid) && sps >= 2.0
+            begin
+              k = sps.round
+              riq = (sps - k).abs < 0.02 ? iq : resample_iq(iq: iq, src_rate: rate, dst_rate: baud * k)
+              bits = PWN::FFI::Liquid.gmsk_demod(iq: riq, sps: k, bt: bt)
+              return inv ? bits.map { |b| b ^ 1 } : bits
+            rescue StandardError
+              # fall through
+            end
+          end
+          audio = fm_demod_iq(iq: iq)
+          nrz_slice(samples: audio, rate: rate, baud: baud, invert: inv)
+        end
+
+        # Supported Method Parameters::
+        # dibits = PWN::SDR::Decoder::DSP.slice_4fsk(
+        #   samples: 'required - real FM-discriminator baseband',
+        #   rate:, baud:
+        # )
+        # → Array<0..3> per symbol (4-level decision, adaptive thresholds).
+        # C4FM/4-GFSK maps +3 → 01, +1 → 00, −1 → 10, −3 → 11 in P25/DMR.
+
+        public_class_method def self.slice_4fsk(opts = {})
+          samples = opts[:samples]
+          rate    = opts[:rate].to_f
+          baud    = opts[:baud].to_f
+          spb     = rate / baud
+          return [] if spb < 2.0 || samples.empty?
+
+          lp   = envelope_signed(samples: dc_block(samples: samples), window: [(spb / 4.0).round, 1].max)
+          nsym = (lp.length / spb).floor
+          # sample mid-symbol values, then quantise into 4 levels
+          vals = Array.new(nsym) { |i| lp[((i + 0.5) * spb).floor] || 0.0 }
+          return [] if vals.empty?
+
+          sorted = vals.sort
+          lo = sorted[(nsym * 0.1).floor] || vals.min
+          hi = sorted[(nsym * 0.9).floor] || vals.max
+          step = (hi - lo) / 3.0
+          step = 1e-9 if step.abs < 1e-9
+          t_lo = lo + step
+          t_hi = hi - step
+          vals.map do |v|
+            if v >= t_hi then 1        # +3
+            elsif v >= 0 then 0        # +1
+            elsif v >= t_lo then 2     # −1
+            else 3                     # −3
+            end
+          end
+        end
+
+        # Supported Method Parameters::
+        # bits = PWN::SDR::Decoder::DSP.manchester_decode(
+        #   bits: 'required - Array<0|1> at 2×data rate',
+        #   ieee: 'optional - true = 01→1 10→0 (IEEE 802.3), else 10→1 01→0'
+        # )
+
+        public_class_method def self.manchester_decode(opts = {})
+          bits = opts[:bits]
+          ieee = opts[:ieee]
+          out  = []
+          i = 0
+          while i < bits.length - 1
+            a = bits[i]
+            b = bits[i + 1]
+            if a == b
+              i += 1 # phase slip — resync on next transition
+              next
+            end
+            out << (ieee ? b : a)
+            i += 2
+          end
+          out
+        end
+
+        # Supported Method Parameters::
+        # bits = PWN::SDR::Decoder::DSP.diff_decode(bits: Array<0|1>)
+        # NRZ-I / DBPSK: output 1 on transition, 0 on hold.
+
+        public_class_method def self.diff_decode(opts = {})
+          bits = opts[:bits]
+          prev = bits.first || 0
+          out  = Array.new(bits.length - 1)
+          i = 1
+          while i < bits.length
+            out[i - 1] = bits[i] == prev ? 0 : 1
+            prev = bits[i]
+            i += 1
+          end
+          out
+        end
+
+        # Supported Method Parameters::
+        # bytes = PWN::SDR::Decoder::DSP.bytes_from_bits(
+        #   bits: Array<0|1>, lsb_first: false
+        # )
+
+        public_class_method def self.bytes_from_bits(opts = {})
+          bits = opts[:bits]
+          lsb  = opts[:lsb_first]
+          out  = []
+          bits.each_slice(8) do |oct|
+            next if oct.length < 8
+
+            v = 0
+            if lsb
+              oct.each_with_index { |b, i| v |= (b & 1) << i }
+            else
+              oct.each { |b| v = (v << 1) | (b & 1) }
+            end
+            out << v
+          end
+          out
+        end
+
+        # Supported Method Parameters::
+        # crc = PWN::SDR::Decoder::DSP.crc16(
+        #   bytes: Array<Integer>, poly: 0x1021, init: 0xFFFF,
+        #   refin: false, refout: false, xorout: 0x0000
+        # )
+
+        public_class_method def self.crc16(opts = {})
+          bytes  = opts[:bytes]
+          poly   = (opts[:poly]   || 0x1021).to_i
+          crc    = (opts[:init]   || 0xFFFF).to_i
+          refin  = opts[:refin]
+          refout = opts[:refout]
+          xorout = (opts[:xorout] || 0).to_i
+          bytes.each do |b|
+            b = Integer(format('%08b', b & 0xFF).reverse, 2) if refin
+            crc ^= (b & 0xFF) << 8
+            8.times do
+              crc = crc.anybits?(0x8000) ? ((crc << 1) ^ poly) : (crc << 1)
+              crc &= 0xFFFF
+            end
+          end
+          crc = Integer(format('%016b', crc).reverse, 2) if refout
+          crc ^ xorout
+        end
+
+        # Supported Method Parameters::
+        # out = PWN::SDR::Decoder::DSP.whiten_lfsr(
+        #   bytes: Array<Integer>, poly: Integer, init: Integer, width: 7
+        # )
+        # Galois LFSR (MSB-first). BLE: poly 0x11 (x^7+x^4+1), init (ch|0x40).
+
+        public_class_method def self.whiten_lfsr(opts = {})
+          bytes = opts[:bytes]
+          poly  = opts[:poly].to_i
+          reg   = opts[:init].to_i
+          w     = (opts[:width] || 7).to_i
+          top   = 1 << (w - 1)
+          out   = Array.new(bytes.length)
+          bytes.each_with_index do |byte, bi|
+            v = byte & 0xFF
+            8.times do |i|
+              msb = reg.anybits?(top) ? 1 : 0
+              reg = ((reg << 1) & ((1 << w) - 1))
+              reg ^= poly if msb == 1
+              v ^= (msb << i)
+            end
+            out[bi] = v
+          end
+          out
+        end
+
+        # Supported Method Parameters::
+        # pulses = PWN::SDR::Decoder::DSP.ook_pulses(
+        #   iq: 'required - interleaved I/Q', rate:,
+        #   min_us: 'optional - drop shorter pulses (default 20)'
+        # )
+        # → Array of { level: 0|1, us: Float, samples: Int } run-length list.
+
+        public_class_method def self.ook_pulses(opts = {})
+          iq     = opts[:iq]
+          rate   = opts[:rate].to_f
+          min_us = (opts[:min_us] || 20).to_f
+          m2     = mag_sq(iq: iq)
+          return [] if m2.length < 32
+
+          # Adaptive threshold: 0.5·(floor + peak) on power domain
+          sorted = m2.sort
+          floor  = sorted[m2.length / 10] || m2.min
+          peak   = sorted[(m2.length * 9) / 10] || m2.max
+          thr    = floor + ((peak - floor) * 0.5)
+          us_per = 1_000_000.0 / rate
+          runs = []
+          state = m2.first >= thr ? 1 : 0
+          cnt = 0
+          m2.each do |v|
+            s = v >= thr ? 1 : 0
+            if s == state
+              cnt += 1
+            else
+              runs << { level: state, us: cnt * us_per, samples: cnt } if (cnt * us_per) >= min_us
+              state = s
+              cnt = 1
+            end
+          end
+          runs << { level: state, us: cnt * us_per, samples: cnt } if (cnt * us_per) >= min_us
+          runs
+        end
+
+        # Supported Method Parameters::
+        # mag = PWN::SDR::Decoder::DSP.cfft_mag(
+        #   iq: 'required - interleaved I/Q', n: 'optional - FFT size',
+        #   shift: 'optional - fftshift so DC is centred (default true)'
+        # )
+
+        public_class_method def self.cfft_mag(opts = {})
+          iq = opts[:iq]
+          n  = (opts[:n] || (iq.length / 2)).to_i
+          sh = opts.fetch(:shift, true)
+          bins =
+            if native && PWN::FFI.available?(mod: :FFTW)
+              begin
+                PWN::FFI::FFTW.cfft(iq: iq, n: n)
+              rescue StandardError
+                dft_naive(iq: iq, n: n)
+              end
+            else
+              dft_naive(iq: iq, n: n)
+            end
+          mag = bins.map { |re, im| Math.sqrt((re * re) + (im * im)) }
+          sh ? mag.rotate(n / 2) : mag
+        end
+
+        # Naive O(n²) complex DFT — pure-Ruby fallback for small n.
+        # Supported Method Parameters::
+        # bins = PWN::SDR::Decoder::DSP.dft_naive(iq:, n:)
+
+        public_class_method def self.dft_naive(opts = {})
+          iq = opts[:iq]
+          n  = (opts[:n] || (iq.length / 2)).to_i
+          n  = [n, 512].min
+          Array.new(n) do |k|
+            re = 0.0
+            im = 0.0
+            j = 0
+            while j < n
+              ph = -TWO_PI * k * j / n
+              c = Math.cos(ph)
+              s = Math.sin(ph)
+              xr = iq[j * 2].to_f
+              xi = iq[(j * 2) + 1].to_f
+              re += (xr * c) - (xi * s)
+              im += (xr * s) + (xi * c)
+              j += 1
+            end
+            [re, im]
+          end
+        end
+
+        # Supported Method Parameters::
+        # zc = PWN::SDR::Decoder::DSP.zadoff_chu(root:, n: 63)
+        # Returns interleaved [I0,Q0,…] Array<Float>. LTE PSS uses roots 25/29/34.
+
+        public_class_method def self.zadoff_chu(opts = {})
+          u = opts[:root].to_i
+          n = (opts[:n] || 63).to_i
+          out = Array.new(n * 2)
+          n.times do |k|
+            ph = -Math::PI * u * k * (k + 1) / n
+            out[k * 2]       = Math.cos(ph)
+            out[(k * 2) + 1] = Math.sin(ph)
+          end
+          out
+        end
+
+        # Supported Method Parameters::
+        # chips = PWN::SDR::Decoder::DSP.ca_code(prn: 1..32)
+        # Returns Array<Float> of ±1.0 length 1023 (GPS L1 C/A Gold code).
+
+        public_class_method def self.ca_code(opts = {})
+          prn  = opts[:prn].to_i
+          taps = CA_G2_TAPS[prn]
+          raise "ERROR: PRN #{prn} unsupported" unless taps
+
+          g1 = Array.new(10, 1)
+          g2 = Array.new(10, 1)
+          out = Array.new(1023)
+          1023.times do |i|
+            g2i = g2[taps[0] - 1] ^ g2[taps[1] - 1]
+            out[i] = (g1[9] ^ g2i) == 1 ? -1.0 : 1.0
+            fb1 = g1[2] ^ g1[9]
+            fb2 = g2[1] ^ g2[2] ^ g2[5] ^ g2[7] ^ g2[8] ^ g2[9]
+            g1.unshift(fb1)
+            g1.pop
+            g2.unshift(fb2)
+            g2.pop
+          end
+          out
+        end
+
+        # Supported Method Parameters::
+        # out = PWN::SDR::Decoder::DSP.cmul(a: [I,Q,…], b: [I,Q,…], conj_b: false)
+        # Element-wise complex multiply (interleaved). Used for
+        # correlation / dechirp: X = A · conj(B).
+
+        public_class_method def self.cmul(opts = {})
+          a = opts[:a]
+          b = opts[:b]
+          cj = opts[:conj_b]
+          n  = [a.length, b.length].min / 2
+          out = Array.new(n * 2)
+          i = 0
+          while i < n
+            ar = a[i * 2].to_f
+            ai = a[(i * 2) + 1].to_f
+            br = b[i * 2].to_f
+            bi = b[(i * 2) + 1].to_f
+            bi = -bi if cj
+            out[i * 2]       = (ar * br) - (ai * bi)
+            out[(i * 2) + 1] = (ar * bi) + (ai * br)
+            i += 1
+          end
+          out
+        end
+
         # Author(s):: 0day Inc. <support@0dayinc.com>
 
         public_class_method def self.authors
@@ -597,6 +1026,20 @@ module PWN
             #{self}.bch_31_21_syndrome(word:)
             #{self}.baudot_decode(bits:)
             #{self}.rms_dbfs(samples:)                         # → Volk (≥64)
+#{self}.resample_iq(iq:, src_rate:, dst_rate:)     # → Liquid crcf
+#{self}.mix_iq(iq:, rate:, freq:)                  # → Liquid nco
+#{self}.gfsk_slice(iq:, rate:, baud:, bt: 0.35)    # → Liquid gmskdem
+#{self}.slice_4fsk(samples:, rate:, baud:)         # C4FM/4-GFSK
+#{self}.manchester_decode(bits:, ieee: false)
+#{self}.diff_decode(bits:)
+#{self}.bytes_from_bits(bits:, lsb_first: false)
+#{self}.crc16(bytes:, poly: 0x1021, init: 0xFFFF)
+#{self}.whiten_lfsr(bytes:, poly:, init:, width: 7)
+#{self}.ook_pulses(iq:, rate:, min_us: 20)
+#{self}.cfft_mag(iq:, n:, shift: true)             # → FFTW
+#{self}.cmul(a:, b:, conj_b: false)
+#{self}.zadoff_chu(root:, n: 63)                   # LTE PSS
+#{self}.ca_code(prn: 1..32)                        # GPS L1 C/A
 
             Constants: MORSE_TABLE, BAUDOT_LTRS, BAUDOT_FIGS
             Backends:  PWN::FFI.backends  # { Volk: true, Liquid: true, AdalmPluto: true, … }

data/lib/pwn/sdr/decoder/gps.rb

@@ -3,66 +3,100 @@
 module PWN
   module SDR
     module Decoder
-      # True-air + detector-fallback decoder for GPS.
-      # Prefers PWN::FFI I/Q (RTL-SDR / ADALM-Pluto / HackRF / capture file)
-      # via Base.run_iq; degrades to Base.run_detector with no hardware.
+      # GPS L1 C/A (1575.42 MHz) true-air acquisition.
+      #
+      # Parallel-code-phase search: 1 ms of I/Q resampled to 2.046 Msps
+      # (2 samp/chip), FFT-correlated (via PWN::FFI::FFTW.cfft) against
+      # each PRN 1..32 Gold code across ±5 kHz Doppler in 500 Hz steps.
+      # Emits {prn:, doppler_hz:, code_phase_chips:, cn0_db_hz:} for every
+      # satellite whose peak/next-peak ratio clears threshold — the same
+      # cold-start acquisition every GNSS receiver runs, no gnss-sdr binary.
       module GPS
-        # Streaming I/Q energy/burst demod for Base.run_iq.
+        CHIP_RATE   = 1_023_000
+        ACQ_RATE    = 2_046_000 # 2 samp/chip → 2046-point FFT
+        DOPP_RANGE  = 5000
+        DOPP_STEP   = 500
+        ACQ_THRESH  = 2.5 # peak / mean ratio
+
+        # Streaming L1 C/A acquisition demod for Base.run_iq.
         class DemodIQ
-          def initialize(rate:, protocol:, modulation:, extra: {})
-            @rate = rate.to_f
-            @protocol = protocol
-            @modulation = modulation
-            @extra = extra
-            @floor = nil
-            @in_burst = false
-            @burst_t0 = nil
-            @peak = -200.0
-            @burst_n = 0
-            @threshold = (extra[:threshold] || 8.0).to_f
+          def initialize(rate:)
+            @rate  = rate.to_f
+            @buf   = []
+            @seen  = {}
+            @codes = {}
           end
 
-          def feed_iq(samples, rate: nil, &)
+          def feed_iq(samples, rate: nil)
             @rate = rate.to_f if rate
-            m2 = PWN::SDR::Decoder::DSP.mag_sq(iq: samples)
-            hop = [(@rate / 1000.0).round, 1].max
-            i = 0
-            while i < m2.length
-              win = m2[i, hop]
-              break if win.nil? || win.empty?
-
-              ms = win.sum / win.length
-              lvl = ms.positive? ? (10.0 * Math.log10(ms)) : -120.0
-              @floor = @floor.nil? ? lvl : ((@floor * 0.98) + (lvl * 0.02))
-              delta = lvl - @floor
-              if delta >= @threshold
-                unless @in_burst
-                  @in_burst = true
-                  @burst_t0 = Time.now
-                  @peak = lvl
+            @buf.concat(samples)
+            need = (@rate / 1000.0 * 2).ceil * 2 # 1 ms complex + headroom
+            return if @buf.length < need * 2
+
+            ms = PWN::SDR::Decoder::DSP.resample_iq(
+              iq: @buf.shift(need * 2), src_rate: @rate, dst_rate: ACQ_RATE
+            )[0, 2046 * 2]
+            return if ms.nil? || ms.length < 2046 * 2
+
+            hits = acquire(ms)
+            hits.each do |h|
+              key = "PRN#{h[:prn]}"
+              next if @seen[key] && (@seen[key] - h[:cn0_db_hz]).abs < 1.5
+
+              @seen[key] = h[:cn0_db_hz]
+              yield h
+            end
+          end
+
+          private
+
+          def code_fft(prn)
+            @codes[prn] ||= begin
+              chips = PWN::SDR::Decoder::DSP.ca_code(prn: prn)
+              # upsample to 2 samp/chip, complex (Q=0)
+              iq = Array.new(2046 * 2, 0.0)
+              2046.times { |i| iq[i * 2] = chips[i / 2] }
+              PWN::FFI.available?(mod: :FFTW) ? PWN::FFI::FFTW.cfft(iq: iq, n: 2046) : PWN::SDR::Decoder::DSP.dft_naive(iq: iq, n: 2046)
+            end
+          end
+
+          def acquire(ms_iq)
+            out = []
+            (1..32).each do |prn|
+              cf = code_fft(prn)
+              best = { peak: 0.0, dopp: 0, code: 0, floor: 1.0 }
+              (-DOPP_RANGE..DOPP_RANGE).step(DOPP_STEP) do |fd|
+                mixed = PWN::SDR::Decoder::DSP.mix_iq(iq: ms_iq, rate: ACQ_RATE, freq: fd)
+                sig_f = PWN::FFI.available?(mod: :FFTW) ? PWN::FFI::FFTW.cfft(iq: mixed, n: 2046) : PWN::SDR::Decoder::DSP.dft_naive(iq: mixed, n: 2046)
+                # X = FFT(sig) · conj(FFT(code)); corr = |IFFT(X)|
+                x_iq = Array.new(2046 * 2)
+                2046.times do |k|
+                  ar, ai = sig_f[k]
+                  br, bi = cf[k]
+                  x_iq[k * 2]       = (ar * br) + (ai * bi)
+                  x_iq[(k * 2) + 1] = (ai * br) - (ar * bi)
                 end
-                @peak = lvl if lvl > @peak
-              elsif @in_burst
-                @in_burst = false
-                @burst_n += 1
-                dur_ms = ((Time.now - @burst_t0) * 1000).round
-                msg = {
-                  protocol: @protocol, event: 'burst', source: 'iq',
-                  burst_no: @burst_n, peak_dbfs: @peak.round(1),
-                  floor_dbfs: @floor.round(1), delta_db: (@peak - @floor).round(1),
-                  duration_ms: dur_ms, modulation: @modulation,
-                  sample_rate: @rate.to_i
-                }.merge(@extra.except(:threshold))
-                # protocol-specific enrichment
-                msg.merge!(self.class.enrich(msg)) if self.class.respond_to?(:enrich)
-                msg[:summary] = format(
-                  '%<p>s IQ-burst #%<n>d peak=%<pk>+.1f dBFS Δ=%<d>.1f dB dur=%<ms>d ms',
-                  p: @protocol, n: @burst_n, pk: @peak, d: @peak - @floor, ms: dur_ms
-                )
-                yield msg if block_given?
+                corr = PWN::FFI.available?(mod: :FFTW) ? PWN::FFI::FFTW.cfft(iq: x_iq, n: 2046, sign: :backward) : PWN::SDR::Decoder::DSP.dft_naive(iq: x_iq, n: 2046)
+                mag = corr.map { |re, im| (re * re) + (im * im) }
+                pk_i = mag.each_with_index.max_by(&:first).last
+                pk   = mag[pk_i]
+                # exclude ±2 chips around peak for floor estimate
+                floor = (mag.sum - mag[[pk_i - 4, 0].max, 9].sum) / (mag.length - 9)
+                best = { peak: pk, floor: floor, dopp: fd, code: pk_i } if pk / floor > best[:peak] / [best[:floor], 1e-12].max
               end
-              i += hop
+              ratio = best[:peak] / [best[:floor], 1e-12].max
+              next unless ratio >= ACQ_THRESH
+
+              cn0 = 10.0 * Math.log10(ratio * 1000.0) # 1 ms coherent
+              out << {
+                protocol: 'GPS', event: 'acquisition', modulation: 'BPSK/DSSS',
+                prn: prn, doppler_hz: best[:dopp],
+                code_phase_chips: (best[:code] / 2.0).round(1),
+                peak_to_floor: ratio.round(2), cn0_db_hz: cn0.round(1),
+                summary: "GPS PRN#{prn} acquired: Doppler=#{best[:dopp]}Hz code=#{(best[:code] / 2.0).round(1)} C/N0≈#{cn0.round(1)}dB-Hz"
+              }
             end
+            out
           end
         end
 
@@ -73,23 +107,16 @@ module PWN
 
         public_class_method def self.decode(opts = {})
           freq_obj = opts[:freq_obj]
-
-          rate  = (opts[:sample_rate] || freq_obj[:iq_rate] || 2_048_000).to_i
-          proto = 'GPS'
-          demod = DemodIQ.new(
-            rate: rate, protocol: proto, modulation: 'BPSK/DSSS',
-            extra: { threshold: 3.0 }
-          )
+          rate = (opts[:sample_rate] || freq_obj[:iq_rate] || 2_048_000).to_i
           PWN::SDR::Decoder::Base.run_iq(
             freq_obj: freq_obj,
-            protocol: proto,
+            protocol: 'GPS-L1CA',
             sample_rate: rate,
             source: opts[:source],
             file: opts[:file],
-            demod: demod,
-            threshold: 3.0,
-            note: 'BPSK/DSSS 1.023 Mcps — true-air I/Q path reports composite L1 energy; PRN acquisition is layered on FFTW when available.',
-            describe: proc { |_b| { modulation: 'BPSK/DSSS', chip_rate: 1_023_000 } }
+            demod: DemodIQ.new(rate: rate),
+            note: 'BPSK/DSSS 1.023 Mcps — I/Q→FFT parallel-code-phase acquisition (PWN::FFI::FFTW) → PRN/Doppler/C-N0.',
+            describe: proc { |_b| { modulation: 'BPSK/DSSS', chip_rate: CHIP_RATE } }
           )
         end
 
@@ -101,15 +128,8 @@ module PWN
           out[:lat]  = ::Regexp.last_match(1) if line =~ /Lat(?:itude)?\s*=\s*(-?[\d.]+)/i
           out[:lon]  = ::Regexp.last_match(1) if line =~ /Long(?:itude)?\s*=\s*(-?[\d.]+)/i
           out[:alt]  = ::Regexp.last_match(1) if line =~ /Height\s*=\s*(-?[\d.]+)/i
-          out[:utc]  = ::Regexp.last_match(1) if line =~ /UTC\s*=?\s*([\d:.-]+T?[\d:.]*)/
           out[:nmea] = line if line.start_with?('$G')
-          out[:summary] = if out[:lat]
-                            "GPS FIX #{out[:lat]},#{out[:lon]} alt=#{out[:alt]}m"
-                          elsif out[:prn]
-                            "GPS PRN#{out[:prn]} CN0=#{out[:cn0]}"
-                          else
-                            "GPS #{line[0, 100]}"
-                          end
+          out[:summary] = out[:lat] ? "GPS FIX #{out[:lat]},#{out[:lon]}" : "GPS PRN#{out[:prn]} CN0=#{out[:cn0]}"
           out.compact
         end
 
@@ -124,7 +144,7 @@ module PWN
             #{self}.decode(
               freq_obj: 'required - freq_obj returned from PWN::SDR::GQRX.init_freq',
               source:   'optional - :auto|:rtlsdr|:adalm_pluto|:file',
-              file:     'optional - .cu8/.cs16 capture'
+              file:     'optional - .cu8/.cs16 capture (≥2.048 Msps)'
             )
 
             #{self}.authors