sdrangel/wdsp/RXA.cpp

/*  RXA.c

This file is part of a program that implements a Software-Defined Radio.

Copyright (C) 2013, 2014, 2015, 2016, 2023 Warren Pratt, NR0V
Copyright (C) 2024 Edouard Griffiths, F4EXB Adapted to SDRangel

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

The author can be reached by email at

warren@wpratt.com

*/

#include "comm.hpp"

#include "RXA.hpp"
#include "amd.hpp"
#include "meter.hpp"
#include "shift.hpp"
#include "resample.hpp"
#include "bandpass.hpp"
#include "bps.hpp"
#include "nbp.hpp"
#include "snba.hpp"
#include "bpsnba.hpp"
#include "sender.hpp"
#include "amsq.hpp"
#include "fmd.hpp"
#include "fmsq.hpp"
#include "eqp.hpp"
#include "anf.hpp"
#include "anr.hpp"
#include "emnr.hpp"
#include "patchpanel.hpp"
#include "siphon.hpp"
#include "cblock.hpp"
#include "ssql.hpp"
#include "fircore.hpp"
#include "wcpAGC.hpp"
#include "anb.hpp"
#include "nob.hpp"
#include "speak.hpp"
#include "mpeak.hpp"
#include "fir.hpp"

namespace WDSP {

RXA::RXA(
    int _in_rate,                // input samplerate
    int _out_rate,               // output samplerate
    int _dsp_rate,               // sample rate for mainstream dsp processing
    int _dsp_size                // number complex samples processed per buffer in mainstream dsp processing
) : Unit(
    _in_rate,
    _out_rate,
    _dsp_rate,
    _dsp_size
)
{
    mode = RXA::RXA_LSB;
    std::fill(meter.begin(), meter.end(), 0);

    // Noise blanker (ANB or "NB")
    anb = new ANB(
        0, // run
        dsp_insize,                        // input buffer size
        inbuff,                            // pointer to input buffer
        inbuff,                            // pointer to output buffer
        in_rate,                           // samplerate
        0.0001,                                 // tau
        0.0001,                                 // hang time
        0.0001,                                 // advance time
        0.05,                                   // back tau
        30                                      // thershold
    );
    // Noise blanker (NOB or "NB2")
    nob = new NOB(
        0, // run
        dsp_insize,                        // input buffer size
        inbuff,                            // pointer to input buffer
        inbuff,                            // pointer to output buffer
        in_rate,                           // samplerate
        0,                                      // mode (zero)
        0.0001,                                 // advance slew time
        0.0001,                                 // advance time
        0.0001,                                 // hang slew time
        0.0001,                                 // hang time
        0.025,                                  // max_imp_seq_time:
        0.05,                                   // back tau
        30
    );

    // Ftequency shifter - shift to select a slice of spectrum
    shift = new SHIFT(
        0,                                      // run
        dsp_insize,                        // input buffer size
        inbuff,                            // pointer to input buffer
        inbuff,                            // pointer to output buffer
        in_rate,                           // samplerate
        0.0);                                   // amount to shift (Hz)

    // Input resampler - resample to dsp rate for main processing
    rsmpin = new RESAMPLE(
        0,                                      // run - will be turned ON below if needed
        dsp_insize,                        // input buffer size
        inbuff,                            // pointer to input buffer
        midbuff,                           // pointer to output buffer
        in_rate,                           // input samplerate
        dsp_rate,                          // output samplerate
        0.0,                                    // select cutoff automatically
        0,                                      // select ncoef automatically
        1.0);                                   // gain

    // Input meter - ADC
    adcmeter = new METER(
        0,                                      // run
        nullptr,                                      // optional pointer to another 'run'
        dsp_size,                          // size
        midbuff,                           // pointer to buffer
        dsp_rate,                          // samplerate
        0.100,                                  // averaging time constant
        0.100,                                  // peak decay time constant
        meter.data(),                           // result vector
        RXA_ADC_AV,                             // index for average value
        RXA_ADC_PK,                             // index for peak value
        -1,                                     // index for gain value - disabled
        nullptr);                                     // pointer for gain computation

    // Notched bandpass section

    // notch database
    ndb = new NOTCHDB (
        0,                                      // master run for all nbp's
        1024);                                  // max number of notches

    // notched bandpass
    nbp0 = new NBP (
        1,                                      // run, always runs
        0,                                      // run the notches
        0,                                      // position
        dsp_size,                          // buffer size
        std::max(2048, dsp_size),          // number of coefficients
        0,                                      // minimum phase flag
        midbuff,                           // pointer to input buffer
        midbuff,                           // pointer to output buffer
        -4150.0,                                // lower filter frequency
        -150.0,                                 // upper filter frequency
        dsp_rate,                          // sample rate
        0,                                      // wintype
        1.0,                                    // gain
        1,                                      // auto-increase notch width
        1025,                                   // max number of passbands
        ndb);                              // addr of database pointer

    // bandpass for snba
    bpsnba = new BPSNBA (
        0,                                      // bpsnba run flag
        0,                                      // run the notches
        0,                                      // position
        dsp_size,                          // size
        std::max(2048, dsp_size),          // number of filter coefficients
        0,                                      // minimum phase flag
        midbuff,                           // input buffer
        midbuff,                           // output buffer
        dsp_rate,                          // samplerate
        + 250.0,                                // abs value of cutoff nearest zero
        + 5700.0,                               // abs value of cutoff farthest zero
        - 5700.0,                               // current low frequency
        - 250.0,                                // current high frequency
        0,                                      // wintype
        1.0,                                    // gain
        1,                                      // auto-increase notch width
        1025,                                   // max number of passbands
        ndb);                              // addr of database pointer

    // Post filter display send - send spectrum display (after S-meter in the block diagram)
    sender = new SENDER (
        0,                                      // run
        0,                                      // flag
        0,                                      // mode
        dsp_size,                          // size
        midbuff                            // pointer to input buffer
    );

    // End notched bandpass section

    // S-meter
    smeter = new METER(
        1,                                      // run
        nullptr,                                      // optional pointer to another 'run'
        dsp_size,                          // size
        midbuff,                           // pointer to buffer
        dsp_rate,                          // samplerate
        0.100,                                  // averaging time constant
        0.100,                                  // peak decay time constant
        meter.data(),                           // result vector
        RXA_S_AV,                               // index for average value
        RXA_S_PK,                               // index for peak value
        -1,                                     // index for gain value - disabled
        nullptr);                                     // pointer for gain computation

    // AM squelch capture (for other modes than FM)
    amsq = new AMSQ(
        0,                                      // run
        dsp_size,                          // buffer size
        midbuff,                           // pointer to signal input buffer used by xamsq
        midbuff,                           // pointer to signal output buffer used by xamsq
        midbuff,                           // pointer to trigger buffer that xamsqcap will capture
        dsp_rate,                          // sample rate
        0.010,                                  // time constant for averaging signal level
        0.070,                                  // signal up transition time
        0.070,                                  // signal down transition time
        0.009,                                  // signal level to initiate tail
        0.010,                                  // signal level to initiate unmute
        0.000,                                  // minimum tail length
        1.500,                                  // maximum tail length
        0.0);                                   // muted gain

    // AM/SAM demodulator
    amd = new AMD(
        0,                                      // run - OFF by default
        dsp_size,                          // buffer size
        midbuff,                           // pointer to input buffer
        midbuff,                           // pointer to output buffer
        0,                                      // mode:  0->AM, 1->SAM
        1,                                      // levelfade:  0->OFF, 1->ON
        0,                                      // sideband mode:  0->OFF
        dsp_rate,                          // sample rate
        -2000.0,                                // minimum lock frequency
        +2000.0,                                // maximum lock frequency
        1.0,                                    // zeta
        250.0,                                  // omegaN
        0.02,                                   // tauR
        1.4);                                   // tauI

    // FM demodulator
    fmd = new FMD(
        0,                                      // run
        dsp_size,                          // buffer size
        midbuff,                           // pointer to input buffer
        midbuff,                           // pointer to output buffer
        dsp_rate,                          // sample rate
        5000.0,                                 // deviation
        300.0,                                  // f_low
        3000.0,                                 // f_high
        -8000.0,                                // fmin
        +8000.0,                                // fmax
        1.0,                                    // zeta
        20000.0,                                // omegaN
        0.02,                                   // tau - for dc removal
        0.5,                                    // audio gain
        1,                                      // run tone filter
        254.1,                                  // ctcss frequency
        std::max(2048, dsp_size),          // # coefs for de-emphasis filter
        0,                                      // min phase flag for de-emphasis filter
        std::max(2048, dsp_size),          // # coefs for audio cutoff filter
        0);                                     // min phase flag for audio cutoff filter

    // FM squelch apply
    fmsq = new FMSQ(
        0,                                      // run
        dsp_size,                          // buffer size
        midbuff,                           // pointer to input signal buffer
        midbuff,                           // pointer to output signal buffer
        fmd->audio.data(),                 // pointer to trigger buffer
        dsp_rate,                          // sample rate
        5000.0,                                 // cutoff freq for noise filter (Hz)
        &fmd->pllpole,                     // pointer to pole frequency of the fmd pll (Hz)
        0.100,                                  // delay time after channel flush
        0.001,                                  // tau for noise averaging
        0.100,                                  // tau for long noise averaging
        0.050,                                  // signal up transition time
        0.010,                                  // signal down transition time
        0.750,                                  // noise level to initiate tail
        0.562,                                  // noise level to initiate unmute
        0.000,                                  // minimum tail time
        0.100,                                  // maximum tail time
        std::max(2048, dsp_size),          // number of coefficients for noise filter
        0);                                     // minimum phase flag

    // Spectral noise blanker (SNB)
    snba = new SNBA(
        0,                                      // run
        midbuff,                           // input buffer
        midbuff,                           // output buffer
        dsp_rate,                          // input / output sample rate
        12000,                                  // internal processing sample rate
        dsp_size,                          // buffer size
        4,                                      // overlap factor to use
        256,                                    // frame size to use; sized for 12K rate
        64,                                     // asize
        2,                                      // npasses
        8.0,                                    // k1
        20.0,                                   // k2
        10,                                     // b
        2,                                      // pre
        2,                                      // post
        0.5,                                    // pmultmin
        200.0,                                  // output resampler low cutoff
        5400.0);                                // output resampler high cutoff

    // Equalizer
    {
        std::array<float, 11> default_F = {0.0,  32.0,  63.0, 125.0, 250.0, 500.0, 1000.0, 2000.0, 4000.0, 8000.0, 16000.0};
        std::array<float, 11> default_G = {0.0,   0.0,   0.0,   0.0,   0.0,   0.0,    0.0,    0.0,    0.0,    0.0,     0.0};
        eqp = new EQP(
            0,                                  // run - OFF by default
            dsp_size,                      // buffer size
            std::max(2048, dsp_size),      // number of filter coefficients
            0,                                  // minimum phase flag
            midbuff,                       // pointer to input buffer
            midbuff,                       // pointer to output buffer
            10,                                 // number of frequencies
            default_F.data(),                   // frequency vector
            default_G.data(),                   // gain vector
            0,                                  // cutoff mode
            0,                                  // wintype
            dsp_rate);                     // sample rate
    }

    // Auto notch filter
    anf = new ANF(
        0,                                      // run - OFF by default
        0,                                      // position
        dsp_size,                          // buffer size
        midbuff,                           // pointer to input buffer
        midbuff,                           // pointer to output buffer
        ANF::ANF_DLINE_SIZE,                    // dline_size
        64,                                     // taps
        16,                                     // delay
        0.0001,                                 // two_mu
        0.1,                                    // gamma
        1.0,                                    // lidx
        0.0,                                    // lidx_min
        200.0,                                  // lidx_max
        6.25e-12,                               // ngamma
        6.25e-10,                               // den_mult
        1.0,                                    // lincr
        3.0);                                   // ldecr

    // LMS noise reduction (ANR or "NR")
    anr = new ANR(
        0,                                      // run - OFF by default
        0,                                      // position
        dsp_size,                          // buffer size
        midbuff,                           // pointer to input buffer
        midbuff,                           // pointer to output buffer
        ANR::ANR_DLINE_SIZE,                    // dline_size
        64,                                     // taps
        16,                                     // delay
        0.0001,                                 // two_mu
        0.1,                                    // gamma
        120.0,                                  // lidx
        120.0,                                  // lidx_min
        200.0,                                  // lidx_max
        0.001,                                  // ngamma
        6.25e-10,                               // den_mult
        1.0,                                    // lincr
        3.0);                                   // ldecr

    // Spectral noise reduyction (EMNR or "NR2")
    emnr = new EMNR(
        0,                                      // run
        0,                                      // position
        dsp_size,                          // buffer size
        midbuff,                           // input buffer
        midbuff,                           // output buffer
        4096,                                   // FFT size
        4,                                      // overlap
        dsp_rate,                          // samplerate
        0,                                      // window type
        1.0,                                    // gain
        2,                                      // gain method
        0,                                      // npe_method
        1);                                     // ae_run

    // AGC
    agc = new WCPAGC(
        1,                                      // run
        3,                                      // mode
        1,                                      // peakmode = envelope
        midbuff,                           // pointer to input buffer
        midbuff,                           // pointer to output buffer
        dsp_size,                          // buffer size
        dsp_rate,                          // sample rate
        0.001,                                  // tau_attack
        0.250,                                  // tau_decay
        4,                                      // n_tau
        10000.0,                                // max_gain
        1.5,                                    // var_gain
        1000.0,                                 // fixed_gain
        1.0,                                    // max_input
        1.0,                                    // out_target
        0.250,                                  // tau_fast_backaverage
        0.005,                                  // tau_fast_decay
        5.0,                                    // pop_ratio
        1,                                      // hang_enable
        0.500,                                  // tau_hang_backmult
        0.250,                                  // hangtime
        0.250,                                  // hang_thresh
        0.100);                                 // tau_hang_decay

    // AGC meter
    agcmeter = new METER(
        0,                                      // run
        nullptr,                                      // optional pointer to another 'run'
        dsp_size,                          // size
        midbuff,                           // pointer to buffer
        dsp_rate,                          // samplerate
        0.100,                                  // averaging time constant
        0.100,                                  // peak decay time constant
        meter.data(),                             // result vector
        RXA_AGC_AV,                             // index for average value
        RXA_AGC_PK,                             // index for peak value
        RXA_AGC_GAIN,                           // index for gain value
        &agc->gain);                       // pointer for gain computation

    // Bandpass filter - After spectral noise reduction in the block diagram
    bp1 = new BANDPASS (
        1,                                      // run - used only with ( AM || ANF || ANR || EMNR)
        0,                                      // position
        dsp_size,                          // buffer size
        std::max(2048, dsp_size),          // number of coefficients
        0,                                      // flag for minimum phase
        midbuff,                           // pointer to input buffer
        midbuff,                           // pointer to output buffer
        -4150.0,                                // lower filter frequency
        -150.0,                                 // upper filter frequency
        dsp_rate,                          // sample rate
        1,                                      // wintype
        1.0);                                   // gain

    // Scope/phase display send - pull phase & scope display data
    sip1 = new SIPHON(
        0,                                      // run - needed only for phase display
        0,                                      // position
        0,                                      // mode
        0,                                      // disp
        dsp_size,                          // size of input buffer
        midbuff,                           // input buffer
        4096,                                   // number of samples to store
        4096,                                   // fft size for spectrum
        0);                                     // specmode

    // AM carrier block
    cbl = new CBL(
        0,                                      // run - needed only if set to ON
        dsp_size,                          // buffer size
        midbuff,                           // pointer to input buffer
        midbuff,                           // pointer to output buffer
        0,                                      // mode
        dsp_rate,                          // sample rate
        0.02);                                  // tau

    // CW peaking filter
    speak = new SPEAK(
        0,                                      // run
        dsp_size,                          // buffer size,
        midbuff,                           // pointer to input buffer
        midbuff,                           // pointer to output buffer
        dsp_rate,                          // sample rate
        600.0,                                  // center frequency
        100.0,                                  // bandwidth
        2.0,                                    // gain
        4,                                      // number of stages
        1);                                     // design

    // Dolly filter (multiple peak filter) - default is 2 for RTTY
    {
        std::array<int, 2> def_enable  = {   1,      1};
        std::array<double, 2> def_freq = {2125.0, 2295.0};
        std::array<double, 2> def_bw   = {  75.0, 75.0};
        std::array<double, 2> def_gain = {   1.0, 1.0};
        mpeak = new MPEAK(
            0,                                  // run
            dsp_size,                      // size
            midbuff,                       // pointer to input buffer
            midbuff,                       // pointer to output buffer
            dsp_rate,                      // sample rate
            2,                                  // number of peaking filters
            def_enable.data(),                  // enable vector
            def_freq.data(),                    // frequency vector
            def_bw.data(),                      // bandwidth vector
            def_gain.data(),                    // gain vector
            4 );                                // number of stages
    }

    // Syllabic squelch (Voice suelch) - Not in the block diagram
    ssql = new SSQL(
        0,                                      // run
        dsp_size,                          // size
        midbuff,                           // pointer to input buffer
        midbuff,                           // pointer to output buffer
        dsp_rate,                          // sample rate
        0.070,                                  // signal up transition time
        0.070,                                  // signal down transition time
        0.0,                                    // muted gain
        0.1,                                    // mute time-constant
        0.1,                                    // unmute time-constant
        0.08,                                   // window threshold
        0.8197,                                 // trigger threshold
        2400,                                   // ring size for f_to_v converter
        2000.0);                                // max freq for f_to_v converter

    // PatchPanel
    panel = new PANEL(
        1,                                      // run
        dsp_size,                          // size
        midbuff,                           // pointer to input buffer
        midbuff,                           // pointer to output buffer
        4.0,                                    // gain1
        1.0,                                    // gain2I
        1.0,                                    // gain2Q
        3,                                      // 3 for I and Q
        0);                                     // no copy

    // AM squelch apply - absent but in the block diagram

    // Output resampler
    rsmpout = new RESAMPLE(
        0,                                      // run - will be turned ON below if needed
        dsp_size,                          // input buffer size
        midbuff,                           // pointer to input buffer
        outbuff,                           // pointer to output buffer
        dsp_rate,                          // input sample rate
        out_rate,                          // output sample rate
        0.0,                                    // select cutoff automatically
        0,                                      // select ncoef automatically
        1.0);                                   // gain

    // turn OFF / ON resamplers as needed
    resCheck();
}

RXA::~RXA()
{
    delete rsmpout;
    delete panel;
    delete ssql;
    delete mpeak;
    delete speak;
    delete cbl;
    delete sip1;
    delete bp1;
    delete agcmeter;
    delete agc;
    delete emnr;
    delete anr;
    delete anf;
    delete eqp;
    delete snba;
    delete fmsq;
    delete fmd;
    delete amd;
    delete amsq;
    delete smeter;
    delete sender;
    delete bpsnba;
    delete nbp0;
    delete ndb;
    delete adcmeter;
    delete rsmpin;
    delete shift;
    delete nob;
    delete anb;
}

void RXA::flush()
{
    Unit::flushBuffers();
    anb->flush();
    nob->flush();
    shift->flush();
    rsmpin->flush();
    adcmeter->flush();
    nbp0->flush();
    bpsnba->flush();
    sender->flush();
    smeter->flush();
    amsq->flush();
    amd->flush();
    fmd->flush();
    fmsq->flush();
    snba->flush();
    eqp->flush();
    anf->flush();
    anr->flush();
    emnr->flush();
    agc->flush();
    agcmeter->flush();
    bp1->flush();
    sip1->flush();
    cbl->flush();
    speak->flush();
    mpeak->flush();
    ssql->flush();
    panel->flush();
    rsmpout->flush();
}

void RXA::execute()
{
    anb->execute();
    nob->execute();
    shift->execute();
    rsmpin->execute();
    adcmeter->execute();
    bpsnba->exec_in(0);
    nbp0->execute(0);
    smeter->execute();
    sender->execute();
    amsq->xcap();
    bpsnba->exec_out(0);
    amd->execute();
    fmd->execute();
    fmsq->execute();
    bpsnba->exec_in(1);
    bpsnba->exec_out(1);
    snba->execute();
    eqp->execute();
    anf->execute(0);
    anr->ANR::execute(0);
    emnr->execute(0);
    bp1->BANDPASS::execute(0);
    agc->execute();
    anf->execute(1);
    anr->execute(1);
    emnr->execute(1);
    bp1->execute(1);
    agcmeter->execute();
    sip1->execute(0);
    cbl->execute();
    speak->execute();
    mpeak->execute();
    ssql->execute();
    panel->execute();
    amsq->execute();
    rsmpout->execute();
}

void RXA::setInputSamplerate(int _in_rate)
{
    Unit::setBuffersInputSamplerate(_in_rate);
    // anb
    anb->setBuffers(inbuff, inbuff);
    anb->setSize(dsp_insize);
    anb->setSamplerate(in_rate);
    // nob
    nob->setBuffers(inbuff, inbuff);
    nob->setSize(dsp_insize);
    nob->setSamplerate(in_rate);
    // shift
    shift->setBuffers(inbuff, inbuff);
    shift->setSize(dsp_insize);
    shift->setSamplerate(in_rate);
    // input resampler
    rsmpin->setBuffers(inbuff, midbuff);
    rsmpin->setSize(dsp_insize);
    rsmpin->setInRate(in_rate);
    resCheck();
}

void RXA::setOutputSamplerate(int _out_rate)
{
    Unit::setBuffersOutputSamplerate(_out_rate);
    // output resampler
    rsmpout->setBuffers(midbuff, outbuff);
    rsmpout->setOutRate(out_rate);
    resCheck();
}

void RXA::setDSPSamplerate(int _dsp_rate)
{
    Unit::setBuffersDSPSamplerate(_dsp_rate);
    // anb
    anb->setBuffers(inbuff, inbuff);
    anb->setSize(dsp_insize);
    // nob
    nob->setBuffers(inbuff, inbuff);
    nob->setSize(dsp_insize);
    // shift
    shift->setBuffers(inbuff, inbuff);
    shift->setSize(dsp_insize);
    // input resampler
    rsmpin->setBuffers(inbuff, midbuff);
    rsmpin->setSize(dsp_insize);
    rsmpin->setOutRate(dsp_rate);
    // dsp_rate blocks
    adcmeter->setSamplerate(dsp_rate);
    nbp0->setSamplerate(dsp_rate);
    bpsnba->setSamplerate(dsp_rate);
    smeter->setSamplerate(dsp_rate);
    sender->setSamplerate(dsp_rate);
    amsq->setSamplerate(dsp_rate);
    amd->setSamplerate(dsp_rate);
    fmd->setSamplerate(dsp_rate);
    fmsq->setBuffers(midbuff, midbuff, fmd->audio.data());
    fmsq->setSamplerate(dsp_rate);
    // snba->setSamplerate(dsp_rate); SMBA removed
    eqp->setSamplerate(dsp_rate);
    anf->setSamplerate(dsp_rate);
    anr->setSamplerate(dsp_rate);
    emnr->setSamplerate(dsp_rate);
    bp1->setSamplerate(dsp_rate);
    agc->setSamplerate(dsp_rate);
    agcmeter->setSamplerate(dsp_rate);
    sip1->setSamplerate(dsp_rate);
    cbl->setSamplerate(dsp_rate);
    speak->setSamplerate(dsp_rate);
    mpeak->setSamplerate(dsp_rate);
    ssql->setSamplerate(dsp_rate);
    panel->setSamplerate(dsp_rate);
    // output resampler
    rsmpout->setBuffers(midbuff, outbuff);
    rsmpout->setInRate(dsp_rate);
    resCheck();
}

void RXA::setDSPBuffsize(int _dsp_size)
{
    Unit::setBuffersDSPBuffsize(_dsp_size);
    // anb
    anb->setBuffers(inbuff, inbuff);
    anb->setSize(dsp_insize);
    // nob
    nob->setBuffers(inbuff, inbuff);
    nob->setSize(dsp_insize);
    // shift
    shift->setBuffers(inbuff, inbuff);
    shift->setSize(dsp_insize);
    // input resampler
    rsmpin->setBuffers(inbuff, midbuff);
    rsmpin->setSize(dsp_insize);
    // dsp_size blocks
    adcmeter->setBuffers(midbuff);
    adcmeter->setSize(dsp_size);
    nbp0->setBuffers(midbuff, midbuff);
    nbp0->setSize(dsp_size);
    bpsnba->setBuffers(midbuff, midbuff);
    bpsnba->setSize(dsp_size);
    smeter->setBuffers(midbuff);
    smeter->setSize(dsp_size);
    sender->setBuffers(midbuff);
    sender->setSize(dsp_size);
    amsq->setBuffers(midbuff, midbuff, midbuff);
    amsq->setSize(dsp_size);
    amd->setBuffers(midbuff, midbuff);
    amd->setSize(dsp_size);
    fmd->setBuffers(midbuff, midbuff);
    fmd->setSize(dsp_size);
    fmsq->setBuffers(midbuff, midbuff, fmd->audio.data());
    fmsq->setSize(dsp_size);
    snba->setBuffers(midbuff, midbuff);
    snba->setSize(dsp_size);
    eqp->setBuffers(midbuff, midbuff);
    eqp->setSize(dsp_size);
    anf->setBuffers(midbuff, midbuff);
    anf->setSize(dsp_size);
    anr->setBuffers(midbuff, midbuff);
    anr->setSize(dsp_size);
    emnr->setBuffers(midbuff, midbuff);
    emnr->setSize(dsp_size);
    bp1->setBuffers(midbuff, midbuff);
    bp1->setSize(dsp_size);
    agc->setBuffers(midbuff, midbuff);
    agc->setSize(dsp_size);
    agcmeter->setBuffers(midbuff);
    agcmeter->setSize(dsp_size);
    sip1->setBuffers(midbuff);
    sip1->setSize(dsp_size);
    cbl->setBuffers(midbuff, midbuff);
    cbl->setSize(dsp_size);
    speak->setBuffers(midbuff, midbuff);
    speak->setSize(dsp_size);
    mpeak->setBuffers(midbuff, midbuff);
    mpeak->setSize(dsp_size);
    ssql->setBuffers(midbuff, midbuff);
    ssql->setSize(dsp_size);
    panel->setBuffers(midbuff, midbuff);
    panel->setSize(dsp_size);
    // output resampler
    rsmpout->setBuffers(midbuff, outbuff);
    rsmpout->setSize(dsp_size);
}

void RXA::setSpectrumProbe(BufferProbe *spectrumProbe)
{
    sender->SetSpectrum(1, spectrumProbe);
    sender->run = 1;
}

/********************************************************************************************************
*                                                                                                       *
*                                       RXA Mode & Filter Controls                                      *
*                                                                                                       *
********************************************************************************************************/

void RXA::setMode(int _mode)
{
    if (mode != _mode)
    {
        int amd_run = (_mode == RXA_AM) || (_mode == RXA_SAM);
        bpsnbaCheck (_mode, ndb->master_run);
        bp1Check (
            amd_run,
            snba->run,
            emnr->run,
            anf->run,
            anr->run
        );
        mode = _mode;
        amd->run  = 0;
        fmd->run  = 0;

        switch (_mode)
        {
        case RXA_AM:
            amd->run  = 1;
            amd->mode = 0;
            break;
        case RXA_SAM:
            amd->run  = 1;
            amd->mode = 1;
            break;
        case RXA_DSB:
            break;
        case RXA_FM:
            fmd->run  = 1;
            break;
        default:

            break;
        }

        bp1Set();
        bpsnbaSet();                         // update variables
    }
}

void RXA::resCheck()
{
    // turn OFF/ON resamplers depending upon whether they're needed
    RESAMPLE *a = rsmpin;
    if (in_rate  != dsp_rate)
        a->run = 1;
    else
        a->run = 0;
    a = rsmpout;
    if (dsp_rate != out_rate)
        a->run = 1;
    else
        a->run = 0;
}

void RXA::bp1Check (
    int amd_run,
    int snba_run,
    int emnr_run,
    int anf_run,
    int anr_run
)
{
    BANDPASS *a = bp1;
    float gain;
    if (amd_run  ||
        snba_run ||
        emnr_run ||
        anf_run  ||
        anr_run
    )
        gain = 2.0;
    else
        gain = 1.0;
    if (a->gain != gain)
        a->setGain(gain, 0);
}

void RXA::bp1Set ()
{
    BANDPASS *a = bp1;
    int old = a->run;
    if ((amd->run  == 1) ||
        (snba->run == 1) ||
        (emnr->run == 1) ||
        (anf->run  == 1) ||
        (anr->run  == 1)
    )
        a->run = 1;
    else
        a->run = 0;
    if (!old && a->run)
        a->flush();
    a->fircore->setUpdate();
}

void RXA::bpsnbaCheck(int _mode, int _notch_run)
{
    // for BPSNBA: set run, position, freqs, run_notches
    // call this upon change in RXA_mode, snba_run, notch_master_run
    BPSNBA *a = bpsnba;
    double f_low = 0.0;
    double f_high = 0.0;
    int run_notches = 0;
    switch (_mode)
    {
        case RXA_LSB:
        case RXA_CWL:
        case RXA_DIGL:
            f_low  = -a->abs_high_freq;
            f_high = -a->abs_low_freq;
            run_notches = _notch_run;
            break;
        case RXA_USB:
        case RXA_CWU:
        case RXA_DIGU:
            f_low  = +a->abs_low_freq;
            f_high = +a->abs_high_freq;
            run_notches = _notch_run;
            break;
        case RXA_AM:
        case RXA_SAM:
        case RXA_DSB:
        case RXA_FM:
            f_low  = +a->abs_low_freq;
            f_high = +a->abs_high_freq;
            run_notches = 0;
            break;
        case RXA_DRM:
        case RXA_SPEC:
            break;
        default:
            break;
    }
    // 'run' and 'position' are examined at run time; no filter changes required.
    // Recalculate filter if frequencies OR 'run_notches' changed.
    if ((a->f_low       != f_low      ) ||
        (a->f_high      != f_high     ) ||
        (a->run_notches != run_notches))
    {
        a->f_low  = f_low;
        a->f_high = f_high;
        a->run_notches = run_notches;
        // f_low, f_high, run_notches are needed for the filter recalculation
        bpsnba->recalc_bpsnba_filter(0);
    }
}

void RXA::bpsnbaSet()
{
    // for BPSNBA: set run, position, freqs, run_notches
    // call this upon change in RXA_mode, snba_run, notch_master_run
    BPSNBA *a = bpsnba;
    switch (mode)
    {
        case RXA_LSB:
        case RXA_CWL:
        case RXA_DIGL:
        case RXA_USB:
        case RXA_CWU:
        case RXA_DIGU:
            a->run = snba->run;
            a->position = 0;
            break;
        case RXA_DSB:
        case RXA_AM:
        case RXA_FM:
            a->run = snba->run;
            a->position = 1;
            break;
        case RXA_SAM:
        case RXA_DRM:
        case RXA_SPEC:
            a->run = 0;
            break;
        default:
            break;
    }
    a->bpsnba->fircore->setUpdate();
}

void RXA::updateNBPFiltersLightWeight()
{   // called when setting tune freq or shift freq
    nbp0->calc_lightweight();
    bpsnba->bpsnba->calc_lightweight();
}

void RXA::updateNBPFilters()
{
    NBP *a = nbp0;
    BPSNBA *b = bpsnba;
    if (a->fnfrun)
    {
        a->calc_impulse();
        a->fircore->setImpulse(a->impulse, 1);
    }
    if (b->bpsnba->fnfrun)
    {
        b->recalc_bpsnba_filter(1);
    }
}

int RXA::nbpAddNotch(int _notch, double _fcenter, double _fwidth, int _active)
{
    NOTCHDB *b = ndb;
    int rval = b->addNotch(_notch, _fcenter, _fwidth, _active);

    if (rval == 0) {
        updateNBPFilters();
    }

    return rval;
}

int RXA::nbpGetNotch(int _notch, double* _fcenter, double* _fwidth, int* _active) const
{
    NOTCHDB *a = ndb;
    int rval = a->getNotch(_notch, _fcenter, _fwidth, _active);
    return rval;
}

int RXA::nbpDeleteNotch(int _notch)
{
    NOTCHDB *a = ndb;
    int rval = a->deleteNotch(_notch);

    if (rval == 0) {
        updateNBPFilters();
    }

    return rval;
}

int RXA::nbpEditNotch(int _notch, double _fcenter, double _fwidth, int _active)
{
    NOTCHDB *a = ndb;
    int rval = a->editNotch(_notch, _fcenter, _fwidth, _active);

    if (rval == 0) {
        updateNBPFilters();
    }

    return rval;
}

void RXA::nbpGetNumNotches(int* _nnotches) const
{
    const NOTCHDB *a = ndb;
    a->getNumNotches(_nnotches);
}

void RXA::nbpSetTuneFrequency(double _tunefreq)
{
    NOTCHDB *a;
    a = ndb;

    if (_tunefreq != a->tunefreq)
    {
        a->tunefreq = _tunefreq;
        updateNBPFiltersLightWeight();
    }
}

void RXA::nbpSetShiftFrequency(double _shift)
{
    NOTCHDB *a;
    a = ndb;
    if (_shift != a->shift)
    {
        a->shift = _shift;
        updateNBPFiltersLightWeight();
    }
}

void RXA::nbpSetNotchesRun(int _run)
{
    NOTCHDB *a = ndb;
    NBP *b = nbp0;

    if ( _run != a->master_run)
    {
        a->master_run = _run;                            // update variables
        b->fnfrun = a->master_run;
        bpsnbaCheck(mode, _run);
        b->calc_impulse();                           // recalc nbp impulse response
        b->fircore->setImpulse(b->impulse, 0);       // calculate new filter masks
        bpsnbaSet();
        b->fircore->setUpdate();                       // apply new filter masks
    }
}

void RXA::nbpSetWindow(int _wintype)
{
    NBP *a;
    BPSNBA *b;
    a = nbp0;
    b = bpsnba;

    if (a->wintype != _wintype)
    {
        a->wintype = _wintype;
        a->calc_impulse();
        a->fircore->setImpulse(a->impulse, 1);
    }

    if (b->wintype != _wintype)
    {
        b->wintype = _wintype;
        b->recalc_bpsnba_filter(1);
    }
}

void RXA::nbpSetAutoIncrease(int _autoincr)
{
    NBP *a;
    BPSNBA *b;
    a = nbp0;
    b = bpsnba;

    if (a->autoincr != _autoincr)
    {
        a->autoincr = _autoincr;
        a->calc_impulse();
        a->fircore->setImpulse(a->impulse, 1);
    }

    if (b->autoincr != _autoincr)
    {
        b->autoincr = _autoincr;
        b->recalc_bpsnba_filter(1);
    }
}

void RXA::setAMDRun(int _run)
{
    if (amd->run != _run)
    {
        bp1Check (
            _run,
            snba->run,
            emnr->run,
            anf->run,
            anr->run
        );

        amd->run = _run;
        bp1Set();
    }
}

void RXA::setSNBARun(int _run)
{
    SNBA *a = snba;

    if (a->run != _run)
    {
        bpsnbaCheck(mode, ndb->master_run);
        bp1Check(
            amd->run,
            _run,
            emnr->run,
            anf->run,
            anr->run
        );
        a->run = _run;
        bp1Set();
        bpsnbaSet();
    }
}

void RXA::setANFRun(int _run)
{
    ANF *a = anf;

    if (a->run != _run)
    {
        bp1Check (
            amd->run,
            snba->run,
            emnr->run,
            _run,
            anr->run
        );
        a->run = _run;
        bp1Set();
        a->flush();
    }
}

void RXA::setANFPosition(int _position)
{
    anf->position = _position;
    bp1->position = _position;
    anf->flush();
}

void RXA::setANRRun(int _run)
{
    ANR *a = anr;

    if (a->run != _run)
    {
        bp1Check (
            amd->run,
            snba->run,
            emnr->run,
            anf->run,
            _run
        );
        a->run = _run;
        bp1Set();
        a->flush();
    }
}

void RXA::setANRPosition(int _position)
{
    anr->position = _position;
    bp1->position = _position;
    anr->flush();
}

void RXA::setEMNRRun(int _run)
{
    EMNR *a = emnr;

    if (a->run != _run)
    {
        bp1Check (
            amd->run,
            snba->run,
            _run,
            anf->run,
            anr->run
        );
        a->run = _run;
        bp1Set();
    }
}

void RXA::setEMNRPosition(int _position)
{
    emnr->position = _position;
    bp1->position  = _position;
}

void RXA::getAGCThresh(double *_thresh, double _size, double _rate) const
//for line on bandscope.
{
    double noise_offset;
    noise_offset = 10.0 * log10((nbp0->fhigh - nbp0->flow) * _size / _rate);
    *_thresh = 20.0 * log10( agc->min_volts ) - noise_offset;
}

void RXA::setAGCThresh(double _thresh, double _size, double _rate)
//for line on bandscope
{
    double noise_offset;
    noise_offset = 10.0 * log10((nbp0->fhigh - nbp0->flow) * _size / _rate);
    agc->max_gain = agc->out_target / (agc->var_gain * pow (10.0, (_thresh + noise_offset) / 20.0));
    agc->loadWcpAGC();
}

/********************************************************************************************************
*                                                                                                       *
*                                               Collectives                                             *
*                                                                                                       *
********************************************************************************************************/

void RXA::setPassband(float _f_low, float _f_high)
{
    bp1->setBandpassFreqs         (_f_low, _f_high); // After spectral noise reduction ( AM || ANF || ANR || EMNR)
    snba->setOutputBandwidth      (_f_low, _f_high); // Spectral noise blanker (SNB)
    nbp0->SetFreqs                (_f_low, _f_high); // Notched bandpass
}

void RXA::setNC(int _nc)
{
    int oldstate = state;
    nbp0->SetNC              (_nc);
    bpsnba->SetNC            (_nc);
    bp1->SetBandpassNC       (_nc);
    eqp->setNC               (_nc);
    fmsq->setNC              (_nc);
    fmd->setNCde             (_nc);
    fmd->setNCaud            (_nc);
    state = oldstate;
}

void RXA::setMP(int _mp)
{
    nbp0->SetMP              (_mp);
    bpsnba->SetMP            (_mp);
    bp1->SetBandpassMP       (_mp);
    eqp->setMP               (_mp);
    fmsq->setMP              (_mp);
    fmd->setMPde             (_mp);
    fmd->setMPaud            (_mp);
}

} // namespace WDSP