orion-sdr 0.0.74

Composable SDR/DSP block library targeting HF-to-EHF: analog and single-carrier digital modes, FT8/FT4, PSK31, OFDM/COFDM, and DVB-T/NB-DVB-T, with Python bindings.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

// Copyright (c) 2025-2026 G & R Associates LLC
// SPDX-License-Identifier: MIT OR Apache-2.0

// src/multicarrier/fft.rs
use crate::core::{Block, WorkReport};
use num_complex::Complex32 as C32;
use rustfft::{Fft, FftPlanner};
use std::sync::Arc;

/// Forward FFT, unity gain: `C32 → C32`, `n_fft` samples in, `n_fft` bins out.
///
/// One `n_fft`-sized symbol per `process()` call; a partial trailing chunk
/// (fewer than `n_fft` samples) is a no-op (`WorkReport::default()`), with no
/// cross-call buffering.
#[derive(Clone)]
pub struct FftBlock {
    n_fft: usize,
    plan: Arc<dyn Fft<f32>>,
    scratch: Vec<C32>,
}

impl FftBlock {
    pub fn new(n_fft: usize) -> Self {
        let plan = FftPlanner::new().plan_fft_forward(n_fft);
        let scratch = vec![C32::default(); plan.get_inplace_scratch_len()];
        Self {
            n_fft,
            plan,
            scratch,
        }
    }

    pub fn n_fft(&self) -> usize {
        self.n_fft
    }
}

impl Block for FftBlock {
    type In = C32;
    type Out = C32;

    fn process(&mut self, input: &[C32], output: &mut [C32]) -> WorkReport {
        let n = self.n_fft;
        if input.len() < n || output.len() < n {
            return WorkReport::default();
        }
        copy_c32(&input[..n], &mut output[..n]);
        self.plan
            .process_with_scratch(&mut output[..n], &mut self.scratch);
        WorkReport {
            in_read: n,
            out_written: n,
        }
    }
}

/// Inverse FFT with `1/N` scale folded into the output copy: `C32 → C32`,
/// `n_fft` bins in, `n_fft` samples out.
///
/// Same whole-symbol-per-call contract as `FftBlock`: a partial trailing
/// chunk is a no-op.
#[derive(Clone)]
pub struct IfftBlock {
    n_fft: usize,
    scale: f32,
    plan: Arc<dyn Fft<f32>>,
    scratch: Vec<C32>,
    time: Vec<C32>,
}

impl IfftBlock {
    pub fn new(n_fft: usize) -> Self {
        let plan = FftPlanner::new().plan_fft_inverse(n_fft);
        let scratch = vec![C32::default(); plan.get_inplace_scratch_len()];
        Self {
            n_fft,
            scale: 1.0 / n_fft as f32,
            plan,
            scratch,
            time: vec![C32::default(); n_fft],
        }
    }

    pub fn n_fft(&self) -> usize {
        self.n_fft
    }
}

impl Block for IfftBlock {
    type In = C32;
    type Out = C32;

    fn process(&mut self, input: &[C32], output: &mut [C32]) -> WorkReport {
        let n = self.n_fft;
        if input.len() < n || output.len() < n {
            return WorkReport::default();
        }
        copy_c32(&input[..n], &mut self.time[..n]);
        self.plan
            .process_with_scratch(&mut self.time[..n], &mut self.scratch);
        let g = self.scale;
        let mut i = 0;
        let nn = n & !3;
        while i < nn {
            output[i] = self.time[i] * g;
            output[i + 1] = self.time[i + 1] * g;
            output[i + 2] = self.time[i + 2] * g;
            output[i + 3] = self.time[i + 3] * g;
            i += 4;
        }
        while i < n {
            output[i] = self.time[i] * g;
            i += 1;
        }
        WorkReport {
            in_read: n,
            out_written: n,
        }
    }
}

#[inline(always)]
fn copy_c32(input: &[C32], output: &mut [C32]) {
    let n = input.len();
    let mut i = 0;
    let nn = n & !3;
    while i < nn {
        output[i] = input[i];
        output[i + 1] = input[i + 1];
        output[i + 2] = input[i + 2];
        output[i + 3] = input[i + 3];
        i += 4;
    }
    while i < n {
        output[i] = input[i];
        i += 1;
    }
}