dsp: default to 48 khz dsp bw to improve p25p2 timing recovery for difficult qpsk lsm systems

Author: arancormonk

apps/dsd-cli/main.c

@@ -279,7 +279,7 @@ bootstrap_interactive(dsd_opts* opts, dsd_state* state) {
             int dev = prompt_int("RTL device index", 0, 0, 255);
             int gain = prompt_int("RTL gain (dB)", 22, 0, 60);
             int ppm = prompt_int("PPM error", 0, -200, 200);
-            int bw = prompt_int("DSP bandwidth (kHz: 4,6,8,12,16,24)", 12, 4, 24);
+            int bw = prompt_int("DSP bandwidth (kHz: 4,6,8,12,16,24,48)", 48, 4, 48);
             int sql = prompt_int("Squelch (0=off; negative dB ok via CLI later)", 0, -1000, 100000);
             int vol = prompt_int("Volume multiplier (1..3)", 1, 1, 3);
             snprintf(opts->audio_in_dev, sizeof opts->audio_in_dev, "rtl:%d:%s:%d:%d:%d:%d:%d", dev, freq, gain, ppm,
@@ -303,7 +303,7 @@ bootstrap_interactive(dsd_opts* opts, dsd_state* state) {
             } else {
                 int gain = prompt_int("RTL gain (dB)", 22, 0, 60);
                 int ppm = prompt_int("PPM error", 0, -200, 200);
-                int bw = prompt_int("DSP bandwidth (kHz: 4,6,8,12,16,24)", 12, 4, 24);
+                int bw = prompt_int("DSP bandwidth (kHz: 4,6,8,12,16,24,48)", 48, 4, 48);
                 int sql = prompt_int("Squelch (0=off)", 0, -1000, 100000);
                 int vol = prompt_int("Volume multiplier (1..3)", 1, 1, 3);
                 snprintf(opts->audio_in_dev, sizeof opts->audio_in_dev, "rtltcp:%s:%d:%s:%d:%d:%d:%d:%d", host, port,
@@ -462,7 +462,7 @@ bootstrap_interactive(dsd_opts* opts, dsd_state* state) {
             opts->frame_ysf = 0;
             opts->frame_m17 = 0;
             state->samplesPerSymbol = 20;
-            state->symbolCenter = 10;
+            state->symbolCenter = 9; /* (sps-1)/2 */
             opts->mod_c4fm = 1;
             opts->mod_qpsk = 0;
             opts->mod_gfsk = 0;
@@ -600,7 +600,7 @@ bootstrap_interactive(dsd_opts* opts, dsd_state* state) {
             opts->frame_ysf = 0;
             opts->frame_m17 = 0;
             state->samplesPerSymbol = 20; // same as NXDN48
-            state->symbolCenter = 10;     // same as NXDN48
+            state->symbolCenter = 9;      // (sps-1)/2, same as NXDN48
             opts->mod_c4fm = 1;
             opts->mod_qpsk = 0;
             opts->mod_gfsk = 0;
@@ -1489,7 +1489,7 @@ initOpts(dsd_opts* opts) {
     opts->input_volume_multiplier = 1;
     opts->rtl_udp_port =
         0; //set UDP port for RTL remote -- 0 by default, will be making this optional for some external/legacy use cases (edacs-fm, etc)
-    opts->rtl_dsp_bw_khz = 24;  // DSP baseband kHz (4,6,8,12,16,24). Not tuner IF BW.
+    opts->rtl_dsp_bw_khz = 48;  // DSP baseband kHz (4,6,8,12,16,24,48). Not tuner IF BW.
     opts->rtlsdr_ppm_error = 0; //initialize ppm with 0 value;
     opts->rtlsdr_center_freq =
         850000000; //set to an initial value (if user is using a channel map, then they won't need to specify anything other than -i rtl if desired)
@@ -2396,7 +2396,7 @@ usage() {
     printf("  freq <num>    RTL-SDR Frequency (851800000 or 851.8M) \n");
     printf("  gain <num>    RTL-SDR Device Gain (0-49)(default = 0; Hardware AGC recommended)\n");
     printf("  ppm  <num>    RTL-SDR PPM Error (default = 0)\n");
-    printf("  bw   <num>    RTL-SDR DSP Bandwidth (kHz) (default 24). Allowed: 4,6,8,12,16,24.\n");
+    printf("  bw   <num>    RTL-SDR DSP Bandwidth (kHz) (default 48). Allowed: 4,6,8,12,16,24,48.\n");
     printf("                   Note: This is the DSP baseband used to derive capture rate;\n");
     printf("                         it is NOT the tuner IF filter.\n");
     printf("  sq   <val>    RTL-SDR Squelch Threshold (Optional)\n");
@@ -3267,10 +3267,10 @@ main(int argc, char** argv) {
         curr = strtok_r(NULL, ":", &saveptr); // bw (kHz)
         if (curr != NULL) {
             int bw = atoi(curr);
-            if (bw == 4 || bw == 6 || bw == 8 || bw == 12 || bw == 16 || bw == 24) {
+            if (bw == 4 || bw == 6 || bw == 8 || bw == 12 || bw == 16 || bw == 24 || bw == 48) {
                 opts.rtl_dsp_bw_khz = bw;
             } else {
-                opts.rtl_dsp_bw_khz = 12;
+                opts.rtl_dsp_bw_khz = 48;
             }
         } else {
             goto RTLTCPEND;
@@ -3382,13 +3382,13 @@ main(int argc, char** argv) {
         if (curr != NULL) {
             int bw = 0;
             bw = atoi(curr);
-            //check for proper values (6,8,12,24)
-            if (bw == 4 || bw == 6 || bw == 8 || bw == 12 || bw == 16
-                || bw == 24) //testing 4 and 16 as well for weak and/or nxdn48 systems
+            //check for proper values (4,6,8,12,16,24,48)
+            if (bw == 4 || bw == 6 || bw == 8 || bw == 12 || bw == 16 || bw == 24
+                || bw == 48) // testing 4 and 16 as well for weak and/or nxdn48 systems
             {
                 opts.rtl_dsp_bw_khz = bw;
             } else {
-                opts.rtl_dsp_bw_khz = 12; // safe default -- provides best performance on most systems
+                opts.rtl_dsp_bw_khz = 48; // default baseband when input omits/invalid
             }
         } else {
             goto RTLEND;

docs/cli.md

@@ -164,7 +164,7 @@ Notes
 - Tune controls: `-E` disable group calls, `-p` disable private calls, `-e` enable data calls, `--enc-lockout` do not tune encrypted P25 calls, `--enc-follow` allow encrypted (default)
 - Hold talkgroup: `-I <dec>`
 - rigctl over TCP: `-U <port>` (SDR++ default 4532)
-- Set rigctl bandwidth (Hz): `-B <hertz>` (e.g., 7000–24000 by mode)
+- Set rigctl bandwidth (Hz): `-B <hertz>` (e.g., 7000–48000 by mode)
 - Hang time after voice/sync loss (seconds): `-t <secs>`
   - Env (advanced): When P25 Phase 1 voice error rate is elevated, extend hangtime to reduce VC↔CC thrash:
     - `DSD_NEO_P25P1_ERR_HOLD_PCT=<percent>` (default 8.0)

include/dsd-neo/core/opts.h

@@ -118,7 +118,7 @@ struct dsd_opts {
     /* Generic input volume multiplier for non-RTL inputs (Pulse/WAV/TCP/UDP). */
     int input_volume_multiplier;
     int rtl_udp_port;
-    /* Base DSP bandwidth for RTL path in kHz (4,6,8,12,16,24). Influences capture rate planning.
+    /* Base DSP bandwidth for RTL path in kHz (4,6,8,12,16,24,48). Influences capture rate planning.
        Not the hardware tuner IF bandwidth. */
     int rtl_dsp_bw_khz;
     int rtl_bias_tee; /* 1 to enable RTL-SDR bias tee (if supported) */
@@ -284,3 +284,63 @@ struct dsd_opts {
     char mbe_out_path[2048]; //1024
     char dsp_out_file[2048];
 };
+
+/**
+ * @brief Compute samples-per-symbol for a given symbol rate and sample rate.
+ *
+ * Dynamically computes SPS based on the actual demodulator output sample rate.
+ * When demod_rate_hz is provided (>0), it takes precedence over rtl_dsp_bw_khz
+ * to correctly handle cases where a resampler changes the effective rate.
+ *
+ * @param opts Decoder options containing rtl_dsp_bw_khz fallback (may be NULL).
+ * @param sym_rate_hz Symbol rate in Hz (e.g., 4800 for P25P1, 6000 for P25P2).
+ * @param demod_rate_hz Actual demodulator output rate in Hz (0 to use rtl_dsp_bw_khz).
+ * @return Computed samples per symbol, clamped to [2, 64].
+ */
+static inline int
+dsd_opts_compute_sps_rate(const dsd_opts* opts, int sym_rate_hz, int demod_rate_hz) {
+    int fs_hz = 48000; /* default fallback */
+    if (demod_rate_hz > 0) {
+        fs_hz = demod_rate_hz;
+    } else if (opts && opts->rtl_dsp_bw_khz > 0) {
+        fs_hz = opts->rtl_dsp_bw_khz * 1000;
+    }
+    int sps = (fs_hz + (sym_rate_hz / 2)) / sym_rate_hz; /* round(fs/sym_rate) */
+    if (sps < 2) {
+        sps = 2;
+    } else if (sps > 64) {
+        sps = 64;
+    }
+    return sps;
+}
+
+/**
+ * @brief Compute samples-per-symbol for a given symbol rate and DSP bandwidth.
+ *
+ * Convenience wrapper that uses rtl_dsp_bw_khz from opts. For cases where the
+ * actual demodulator output rate may differ (e.g., resampler active), prefer
+ * dsd_opts_compute_sps_rate() with the actual rate.
+ *
+ * @param opts Decoder options containing rtl_dsp_bw_khz (may be NULL).
+ * @param sym_rate_hz Symbol rate in Hz (e.g., 4800 for P25P1, 6000 for P25P2).
+ * @return Computed samples per symbol, clamped to [2, 64].
+ */
+static inline int
+dsd_opts_compute_sps(const dsd_opts* opts, int sym_rate_hz) {
+    return dsd_opts_compute_sps_rate(opts, sym_rate_hz, 0);
+}
+
+/**
+ * @brief Compute symbol center index for a given SPS value.
+ *
+ * The symbol center is the optimal sample index within the symbol period
+ * for slicing. Uses (sps - 1) / 2 which correctly handles both even and
+ * odd SPS values (e.g., SPS=5 -> 2, SPS=8 -> 3, SPS=10 -> 4).
+ *
+ * @param sps Samples per symbol.
+ * @return Symbol center index.
+ */
+static inline int
+dsd_opts_symbol_center(int sps) {
+    return (sps - 1) / 2;
+}

include/dsd-neo/dsp/costas.h

@@ -50,8 +50,14 @@ typedef struct {
  *
  * The FLL uses band-edge filters to estimate frequency error before timing recovery.
  * This is critical for initial frequency acquisition on channel retunes.
+ *
+ * Filter size = 2*sps+1. At 48 kHz DSP bandwidth:
+ *   - P25P1: SPS=10 -> 21 taps
+ *   - P25P2: SPS=8  -> 17 taps
+ *   - NXDN:  SPS=20 -> 41 taps
+ * Size 48 supports SPS up to 23 (e.g., future 2400 sym/s modes at higher rates).
  */
-#define FLL_BAND_EDGE_MAX_TAPS 32
+#define FLL_BAND_EDGE_MAX_TAPS 48
 
 typedef struct {
     float phase;    /* NCO phase accumulator (radians) */

include/dsd-neo/dsp/demod_state.h

@@ -145,12 +145,14 @@ struct demod_state {
     float hb_hist_i[10][HB_TAPS_MAX - 1];
     float hb_hist_q[10][HB_TAPS_MAX - 1];
 
-    /* Fixed channel low-pass (post-HB) to bound noise bandwidth at higher Fs */
+    /* Fixed channel low-pass (post-HB) to bound noise bandwidth at higher Fs.
+     * At 48 kHz with 1200 Hz transition, Blackman needs up to 135 taps (hist = 134).
+     * Size 144 provides headroom for higher sample rates. */
     int channel_lpf_enable; /* gate */
     int channel_lpf_hist_len;
-    int channel_lpf_profile;      /* see DSD_CH_LPF_PROFILE_* */
-    float channel_lpf_hist_i[64]; /* sized for up to 63-tap symmetric FIR (tap-1) */
-    float channel_lpf_hist_q[64];
+    int channel_lpf_profile;       /* see DSD_CH_LPF_PROFILE_* */
+    float channel_lpf_hist_i[144]; /* sized for up to 144-tap symmetric FIR (tap-1) */
+    float channel_lpf_hist_q[144];
     float channel_pwr;           /* mean power (RMS^2 proxy) measured after channel LPF */
     float channel_squelch_level; /* squelch threshold (linear power); 0 = disabled */
     int channel_squelched;       /* 1 if squelched this block, 0 otherwise */

include/dsd-neo/dsp/ted.h

@@ -22,7 +22,7 @@ extern "C" {
 typedef struct {
     int enabled;
     int force; /* allow forcing TED even for FM/C4FM paths */
-    int sps;   /* nominal samples per symbol (e.g., 5 for 4800 sym/s at 24k) */
+    int sps;   /* nominal samples per symbol. At 48 kHz: P25P1=10, P25P2=8, NXDN=20 */
     /* OP25-compatible Gardner parameters (from p25_demodulator.py) */
     float gain_mu;    /* mu loop gain, default 0.025 (OP25 default) */
     float gain_omega; /* omega loop gain, default 0.1 * gain_mu^2 */

include/dsd-neo/ui/menu_services.h

@@ -184,7 +184,7 @@ int svc_rtl_set_freq(dsd_opts* opts, uint32_t hz);
 int svc_rtl_set_gain(dsd_opts* opts, int value);
 /** @brief Set RTL PPM correction (clamped to ±200). */
 int svc_rtl_set_ppm(dsd_opts* opts, int ppm);
-/** @brief Set RTL DSP baseband bandwidth (kHz), clamping to allowed set and restarting if needed. */
+/** @brief Set RTL DSP baseband bandwidth (kHz: 4,6,8,12,16,24,48), clamping and restarting if needed. */
 int svc_rtl_set_bandwidth(dsd_opts* opts, int khz);
 /** @brief Set RTL squelch threshold in dB, converting to power units. */
 int svc_rtl_set_sql_db(dsd_opts* opts, double dB);

src/dsp/demod_pipeline.cpp

@@ -80,18 +80,25 @@ assume_aligned_ptr(const T* p, size_t /*align_unused*/) {
 
 /* HB_TAPS and hb_q15_taps provided by dsp/halfband.h */
 
-/* Fixed channel low-pass for high-rate (24 kHz) mode.
+/* Fixed channel low-pass for high-rate mode.
  *
- * Profile 0 (wide/analog): ~8 kHz cutoff @ 24 kHz Fs.
- *   Designed as Blackman-windowed sinc, 63 taps; passband ripple ~0 dB through 6 kHz,
- *   ~-6 dB at 8 kHz, stopband < -65 dB by 9 kHz.
+ * Profile 0 (wide/analog): target ~8 kHz cutoff.
+ * Profile 1 (digital-narrow): target ~5 kHz cutoff.
+ * Profiles 2/3 (OP25) are generated dynamically per sample rate.
  *
- * Profile 1 (digital-narrow): ~5 kHz cutoff @ 24 kHz Fs.
- *   Designed as Blackman-windowed sinc, 63 taps; passband ~0 dB through ~3.6 kHz,
- *   ~-3 dB at 4.8 kHz, stopband < -60 dB by 6 kHz; tailored for 4.8 ksps 4FSK/CQPSK. */
-static const int kChannelLpfTaps = 63;
+ * Legacy 63-tap Blackman prototypes are kept as fallback; preferred taps are
+ * generated per sample rate to preserve the intended spectral shape at any Fs.
+ *
+ * At 48 kHz with 1200 Hz transition width:
+ *   - Hamming: ntaps = (53 * 48000) / (22 * 1200) = 97
+ *   - Blackman: ntaps = (74 * 48000) / (22 * 1200) = 135
+ * Size 144 provides headroom for higher sample rates. */
+static const int kChannelLpfTaps = 144;
 static const int kChannelLpfHistLen = kChannelLpfTaps - 1;
-static const float channel_lpf_wide[kChannelLpfTaps] = {
+/* Legacy fallback filters are 63 taps (designed for 24 kHz). Only used when
+ * dynamic filter generation fails; prefer dynamically generated taps. */
+static const int kChannelLpfFallbackTaps = 63;
+static const float channel_lpf_wide[kChannelLpfFallbackTaps] = {
     0.0f,
     0.0f,
     -1.0f / 32768.0f,
@@ -159,7 +166,7 @@ static const float channel_lpf_wide[kChannelLpfTaps] = {
 
 /* Digital-narrow profile taps (fc≈5 kHz @ 24 kHz, 63 taps). Designed as
    Blackman-windowed sinc and normalized to unity DC gain. */
-static const float channel_lpf_digital[kChannelLpfTaps] = {
+static const float channel_lpf_digital[kChannelLpfFallbackTaps] = {
     0.0f,
     0.0f,
     0.0f,
@@ -353,11 +360,18 @@ audio_polydecim_process(struct demod_state* d, const float* in, int in_len, floa
 
 /* ---------------- Fixed channel LPF (complex, no decimation) ----------------- */
 
+/* Dynamically generated wide/digital taps (per-rate); fall back to legacy static prototypes on error. */
+static float s_channel_wide_taps[kChannelLpfTaps];
+static float s_channel_digital_taps[kChannelLpfTaps];
+static int s_channel_wide_ntaps = 0;
+static int s_channel_digital_ntaps = 0;
+static double s_channel_taps_sample_rate = 0.0;
+
 /* OP25-compatible dynamically generated filter taps (cached).
  * Generated once per sample rate using GNU Radio's firdes.low_pass() algorithm.
- * Max tap count for Hamming window at 24kHz with 1200Hz transition: 49 taps. */
-static float s_op25_tdma_taps[128];
-static float s_op25_fdma_taps[128];
+ * At 48 kHz with 1200 Hz transition, Hamming: ntaps = (53 * 48000) / (22 * 1200) = 97. */
+static float s_op25_tdma_taps[kChannelLpfTaps];
+static float s_op25_fdma_taps[kChannelLpfTaps];
 static int s_op25_tdma_ntaps = 0;
 static int s_op25_fdma_ntaps = 0;
 static double s_op25_taps_sample_rate = 0.0;
@@ -379,14 +393,16 @@ channel_lpf_ensure_op25_taps(double sample_rate) {
     }
 
     /* Generate TDMA filter: firdes.low_pass(1.0, sample_rate, 9600, 1200, WIN_HAMMING) */
-    s_op25_tdma_ntaps = dsd_firdes_low_pass(1.0, sample_rate, 9600.0, 1200.0, DSD_WIN_HAMMING, s_op25_tdma_taps, 128);
+    s_op25_tdma_ntaps =
+        dsd_firdes_low_pass(1.0, sample_rate, 9600.0, 1200.0, DSD_WIN_HAMMING, s_op25_tdma_taps, kChannelLpfTaps);
     if (s_op25_tdma_ntaps < 0) {
         s_op25_tdma_ntaps = 0;
         fprintf(stderr, "[channel_lpf] Failed to generate OP25 TDMA filter for Fs=%.0f\n", sample_rate);
     }
 
     /* Generate FDMA filter: firdes.low_pass(1.0, sample_rate, 7000, 1200, WIN_HAMMING) */
-    s_op25_fdma_ntaps = dsd_firdes_low_pass(1.0, sample_rate, 7000.0, 1200.0, DSD_WIN_HAMMING, s_op25_fdma_taps, 128);
+    s_op25_fdma_ntaps =
+        dsd_firdes_low_pass(1.0, sample_rate, 7000.0, 1200.0, DSD_WIN_HAMMING, s_op25_fdma_taps, kChannelLpfTaps);
     if (s_op25_fdma_ntaps < 0) {
         s_op25_fdma_ntaps = 0;
         fprintf(stderr, "[channel_lpf] Failed to generate OP25 FDMA filter for Fs=%.0f\n", sample_rate);
@@ -403,6 +419,39 @@ channel_lpf_ensure_op25_taps(double sample_rate) {
     }
 }
 
+/**
+ * @brief Ensure base wide/digital channel LPF taps are generated for the given sample rate.
+ *
+ * Matches the legacy 24 kHz designs by keeping the same absolute cutoffs:
+ *   - Wide: cutoff ~8 kHz, transition ~1.2 kHz (Blackman)
+ *   - Digital: cutoff ~5 kHz, transition ~1.2 kHz (Blackman)
+ *
+ * Falls back to the legacy static prototypes if generation fails.
+ */
+static void
+channel_lpf_ensure_base_taps(double sample_rate) {
+    if (sample_rate <= 0.0) {
+        return;
+    }
+    if (sample_rate == s_channel_taps_sample_rate && s_channel_wide_ntaps > 0 && s_channel_digital_ntaps > 0) {
+        return; /* Already generated for this sample rate */
+    }
+
+    s_channel_wide_ntaps =
+        dsd_firdes_low_pass(1.0, sample_rate, 8000.0, 1200.0, DSD_WIN_BLACKMAN, s_channel_wide_taps, kChannelLpfTaps);
+    if (s_channel_wide_ntaps < 0) {
+        s_channel_wide_ntaps = 0;
+    }
+
+    s_channel_digital_ntaps = dsd_firdes_low_pass(1.0, sample_rate, 5000.0, 1200.0, DSD_WIN_BLACKMAN,
+                                                  s_channel_digital_taps, kChannelLpfTaps);
+    if (s_channel_digital_ntaps < 0) {
+        s_channel_digital_ntaps = 0;
+    }
+
+    s_channel_taps_sample_rate = sample_rate;
+}
+
 static void
 channel_lpf_apply(struct demod_state* d) {
     if (!d || !d->channel_lpf_enable || d->lp_len < 2) {
@@ -415,8 +464,14 @@ channel_lpf_apply(struct demod_state* d) {
     /* Select filter taps based on profile */
     switch (d->channel_lpf_profile) {
         case DSD_CH_LPF_PROFILE_DIGITAL:
-            taps = channel_lpf_digital;
-            taps_len = kChannelLpfTaps;
+            channel_lpf_ensure_base_taps((double)d->rate_out);
+            if (s_channel_digital_ntaps > 0) {
+                taps = s_channel_digital_taps;
+                taps_len = s_channel_digital_ntaps;
+            } else {
+                taps = channel_lpf_digital; /* fallback (63 taps, 24 kHz design) */
+                taps_len = kChannelLpfFallbackTaps;
+            }
             break;
         case DSD_CH_LPF_PROFILE_OP25_TDMA:
             /* OP25-compatible TDMA filter: 9600 Hz cutoff, 1200 Hz transition, Hamming */
@@ -425,9 +480,9 @@ channel_lpf_apply(struct demod_state* d) {
                 taps = s_op25_tdma_taps;
                 taps_len = s_op25_tdma_ntaps;
             } else {
-                /* Fallback to wide if generation failed */
+                /* Fallback to wide if generation failed (63 taps, 24 kHz design) */
                 taps = channel_lpf_wide;
-                taps_len = kChannelLpfTaps;
+                taps_len = kChannelLpfFallbackTaps;
             }
             break;
         case DSD_CH_LPF_PROFILE_OP25_FDMA:
@@ -437,15 +492,21 @@ channel_lpf_apply(struct demod_state* d) {
                 taps = s_op25_fdma_taps;
                 taps_len = s_op25_fdma_ntaps;
             } else {
-                /* Fallback to wide if generation failed */
+                /* Fallback to wide if generation failed (63 taps, 24 kHz design) */
                 taps = channel_lpf_wide;
-                taps_len = kChannelLpfTaps;
+                taps_len = kChannelLpfFallbackTaps;
             }
             break;
         case DSD_CH_LPF_PROFILE_WIDE:
         default:
-            taps = channel_lpf_wide;
-            taps_len = kChannelLpfTaps;
+            channel_lpf_ensure_base_taps((double)d->rate_out);
+            if (s_channel_wide_ntaps > 0) {
+                taps = s_channel_wide_taps;
+                taps_len = s_channel_wide_ntaps;
+            } else {
+                taps = channel_lpf_wide; /* fallback (63 taps, 24 kHz design) */
+                taps_len = kChannelLpfFallbackTaps;
+            }
             break;
     }