Put device frequency shift calculation in static methods accessible globally

sdrbase/CMakeLists.txt

@@ -111,6 +111,7 @@ set(sdrbase_SOURCES
     dsp/devicesamplesource.cpp
     dsp/devicesamplesink.cpp
     dsp/devicesamplemimo.cpp
+    dsp/devicesamplestatic.cpp
 
     device/deviceapi.cpp
     device/deviceenumerator.cpp
@@ -249,6 +250,7 @@ set(sdrbase_HEADERS
     dsp/devicesamplesource.h
     dsp/devicesamplesink.h
     dsp/devicesamplemimo.h
+    dsp/devicesamplestatic.h
 
     device/deviceapi.h
     device/deviceenumerator.h

sdrbase/dsp/devicesamplesink.cpp

@@ -18,6 +18,7 @@
 
 #include <QDebug>
 
+#include "dsp/devicesamplestatic.h"
 #include "dsp/devicesamplesink.h"
 
 DeviceSampleSink::DeviceSampleSink() :
@@ -52,23 +53,14 @@ qint64 DeviceSampleSink::calculateDeviceCenterFrequency(
             quint32 devSampleRate,
             bool transverterMode)
 {
-    qint64 deviceCenterFrequency = centerFrequency;
+    return DeviceSampleStatic::calculateSinkDeviceCenterFrequency(
-    deviceCenterFrequency -= transverterMode ? transverterDeltaFrequency : 0;
+        centerFrequency,
-    deviceCenterFrequency = deviceCenterFrequency < 0 ? 0 : deviceCenterFrequency;
+        transverterDeltaFrequency,
-    qint64 f_img = deviceCenterFrequency;
+        log2Interp,
-
+        (DeviceSampleStatic::fcPos_t) fcPos,
-    deviceCenterFrequency -= calculateFrequencyShift(log2Interp, fcPos, devSampleRate);
+        devSampleRate,
-    f_img -= 2*calculateFrequencyShift(log2Interp, fcPos, devSampleRate);
+        transverterMode
-
+    );
-    qDebug() << "DeviceSampleSink::calculateDeviceCenterFrequency:"
-            << " desired center freq: " << centerFrequency << " Hz"
-            << " device center freq: " << deviceCenterFrequency << " Hz"
-            << " device sample rate: " << devSampleRate << "S/s"
-            << " Actual sample rate: " << devSampleRate/(1<<log2Interp) << "S/s"
-            << " center freq position code: " << fcPos
-            << " image frequency: " << f_img << "Hz";
-
-    return deviceCenterFrequency;
 }
 
 qint64 DeviceSampleSink::calculateCenterFrequency(
@@ -79,19 +71,14 @@ qint64 DeviceSampleSink::calculateCenterFrequency(
             quint32 devSampleRate,
             bool transverterMode)
 {
-    qint64 centerFrequency = deviceCenterFrequency;
+    return DeviceSampleStatic::calculateSinkCenterFrequency(
-    centerFrequency += calculateFrequencyShift(log2Interp, fcPos, devSampleRate);
+        deviceCenterFrequency,
-    centerFrequency += transverterMode ? transverterDeltaFrequency : 0;
+        transverterDeltaFrequency,
-    centerFrequency = centerFrequency < 0 ? 0 : centerFrequency;
+        log2Interp,
-
+        (DeviceSampleStatic::fcPos_t) fcPos,
-    qDebug() << "DeviceSampleSink::calculateCenterFrequency:"
+        devSampleRate,
-            << " desired center freq: " << centerFrequency << " Hz"
+        transverterMode
-            << " device center freq: " << deviceCenterFrequency << " Hz"
+    );
-            << " device sample rate: " << devSampleRate << "S/s"
-            << " Actual sample rate: " << devSampleRate/(1<<log2Interp) << "S/s"
-            << " center freq position code: " << fcPos;
-
-    return centerFrequency;
 }
 
 /**
@@ -116,29 +103,10 @@ qint32 DeviceSampleSink::calculateFrequencyShift(
             fcPos_t fcPos,
             quint32 devSampleRate)
 {
-    if (fcPos == FC_POS_CENTER) {
+    return DeviceSampleStatic::calculateSinkFrequencyShift(
-        return 0;
+        log2Interp,
-    }
+        (DeviceSampleStatic::fcPos_t) fcPos,
-
+        devSampleRate
-    int sign = fcPos == FC_POS_INFRA ? -1 : 1;
+    );
-    int halfSampleRate = devSampleRate / 2; // fractions are relative to sideband thus based on half the sample rate
-
-    if (log2Interp == 0) {
-        return 0;
-    } else if (log2Interp == 1) {
-        return sign * (halfSampleRate / 2);
-    } else if (log2Interp == 2) {
-        return sign * ((halfSampleRate * 3) / 4);
-    } else if (log2Interp == 3) {
-        return sign * ((halfSampleRate * 5) / 8);
-    } else if (log2Interp == 4) {
-        return sign * ((halfSampleRate * 11) / 16);
-    } else if (log2Interp == 5) {
-        return sign * ((halfSampleRate * 21) / 32);
-    } else if (log2Interp == 6) {
-        return sign * ((halfSampleRate * 21) / 64);
-    } else {
-        return 0;
-    }
 }
 

sdrbase/dsp/devicesamplesource.cpp

@@ -17,7 +17,9 @@
 ///////////////////////////////////////////////////////////////////////////////////
 
 #include <QDebug>
-#include <dsp/devicesamplesource.h>
+
+#include "dsp/devicesamplestatic.h"
+#include "dsp/devicesamplesource.h"
 
 DeviceSampleSource::DeviceSampleSource() :
     m_guiMessageQueue(0)
@@ -51,24 +53,15 @@ qint64 DeviceSampleSource::calculateDeviceCenterFrequency(
             FrequencyShiftScheme frequencyShiftScheme,
             bool transverterMode)
 {
-    qint64 deviceCenterFrequency = centerFrequency;
+    return DeviceSampleStatic::calculateSourceDeviceCenterFrequency(
-    deviceCenterFrequency -= transverterMode ? transverterDeltaFrequency : 0;
+        centerFrequency,
-    deviceCenterFrequency = deviceCenterFrequency < 0 ? 0 : deviceCenterFrequency;
+        transverterDeltaFrequency,
-    qint64 f_img = deviceCenterFrequency;
+        log2Decim,
-
+        (DeviceSampleStatic::fcPos_t) fcPos,
-    deviceCenterFrequency -= calculateFrequencyShift(log2Decim, fcPos, devSampleRate, frequencyShiftScheme);
+        devSampleRate,
-    f_img -= 2*calculateFrequencyShift(log2Decim, fcPos, devSampleRate, frequencyShiftScheme);
+        (DeviceSampleStatic::FrequencyShiftScheme) frequencyShiftScheme,
-
+        transverterMode
-    qDebug() << "DeviceSampleSource::calculateDeviceCenterFrequency:"
+    );
-            << " frequencyShiftScheme: " << frequencyShiftScheme
-            << " desired center freq: " << centerFrequency << " Hz"
-            << " device center freq: " << deviceCenterFrequency << " Hz"
-            << " device sample rate: " << devSampleRate << "S/s"
-            << " Actual sample rate: " << devSampleRate/(1<<log2Decim) << "S/s"
-            << " center freq position code: " << fcPos
-            << " image frequency: " << f_img << "Hz";
-
-    return deviceCenterFrequency;
 }
 
 qint64 DeviceSampleSource::calculateCenterFrequency(
@@ -80,20 +73,15 @@ qint64 DeviceSampleSource::calculateCenterFrequency(
             FrequencyShiftScheme frequencyShiftScheme,
             bool transverterMode)
 {
-    qint64 centerFrequency = deviceCenterFrequency;
+    return DeviceSampleStatic::calculateSourceCenterFrequency(
-    centerFrequency += calculateFrequencyShift(log2Decim, fcPos, devSampleRate, frequencyShiftScheme);
+        deviceCenterFrequency,
-    centerFrequency += transverterMode ? transverterDeltaFrequency : 0;
+        transverterDeltaFrequency,
-    centerFrequency = centerFrequency < 0 ? 0 : centerFrequency;
+        log2Decim,
-
+        (DeviceSampleStatic::fcPos_t) fcPos,
-    qDebug() << "DeviceSampleSource::calculateCenterFrequency:"
+        devSampleRate,
-            << " frequencyShiftScheme: " << frequencyShiftScheme
+        (DeviceSampleStatic::FrequencyShiftScheme) frequencyShiftScheme,
-            << " desired center freq: " << centerFrequency << " Hz"
+        transverterMode
-            << " device center freq: " << deviceCenterFrequency << " Hz"
+    );
-            << " device sample rate: " << devSampleRate << "S/s"
-            << " Actual sample rate: " << devSampleRate/(1<<log2Decim) << "S/s"
-            << " center freq position code: " << fcPos;
-
-    return centerFrequency;
 }
 
 /**
@@ -117,53 +105,10 @@ qint32 DeviceSampleSource::calculateFrequencyShift(
             quint32 devSampleRate,
             FrequencyShiftScheme frequencyShiftScheme)
 {
-    if (frequencyShiftScheme == FSHIFT_STD)
+    return DeviceSampleStatic::calculateSourceFrequencyShift(
-    {
+        log2Decim,
-        if (log2Decim == 0) { // no shift at all
+        (DeviceSampleStatic::fcPos_t) fcPos,
-            return 0;
+        devSampleRate,
-        } else if (log2Decim < 3) {
+        (DeviceSampleStatic::FrequencyShiftScheme) frequencyShiftScheme
-            if (fcPos == FC_POS_INFRA) { // shift in the square next to center frequency
+    );
-                return -(devSampleRate / (1<<(log2Decim+1)));
-            } else if (fcPos == FC_POS_SUPRA) {
-                return devSampleRate / (1<<(log2Decim+1));
-            } else {
-                return 0;
-            }
-        } else {
-            if (fcPos == FC_POS_INFRA) { // shift centered in the square next to center frequency
-                return -(devSampleRate / (1<<(log2Decim)));
-            } else if (fcPos == FC_POS_SUPRA) {
-                return devSampleRate / (1<<(log2Decim));
-            } else {
-                return 0;
-            }
-        }
-    }
-    else // frequencyShiftScheme == FSHIFT_TXSYNC
-    {
-        if (fcPos == FC_POS_CENTER) {
-            return 0;
-        }
-
-        int sign = fcPos == FC_POS_INFRA ? -1 : 1;
-        int halfSampleRate = devSampleRate / 2; // fractions are relative to sideband thus based on half the sample rate
-
-        if (log2Decim == 0) {
-            return 0;
-        } else if (log2Decim == 1) {
-            return sign * (halfSampleRate / 2);         // inf or sup: 1/2
-        } else if (log2Decim == 2) {
-            return sign * ((halfSampleRate * 3) / 4);   // inf, inf or sup, sup: 1/2 + 1/4
-        } else if (log2Decim == 3) {
-            return sign * ((halfSampleRate * 5) / 8);   // inf, inf, sup or sup, sup, inf: 1/2 + 1/4 - 1/8 = 5/8
-        } else if (log2Decim == 4) {
-            return sign * ((halfSampleRate * 11) / 16); // inf, inf, sup, inf or sup, sup, inf, sup: 1/2 + 1/4 - 1/8 + 1/16 = 11/16
-        } else if (log2Decim == 5) {
-            return sign * ((halfSampleRate * 21) / 32); // inf, inf, sup, inf, sup or sup, sup, inf, sup, inf: 1/2 + 1/4 - 1/8 + 1/16 - 1/32 = 21/32
-        } else if (log2Decim == 6) {
-            return sign * ((halfSampleRate * 21) / 64); // inf, sup, inf, sup, inf, sup or sup, inf, sup, inf, sup, inf: 1/2 - 1/4 + 1/8 -1/16 + 1/32 - 1/64 = 21/64
-        } else {
-            return 0;
-        }
-    }
 }

sdrbase/dsp/devicesamplestatic.cpp

@@ -0,0 +1,246 @@
+///////////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2019 F4EXB                                                      //
+// written by Edouard Griffiths                                                  //
+//                                                                               //
+// 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 as version 3 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 V3 for more details.                               //
+//                                                                               //
+// You should have received a copy of the GNU General Public License             //
+// along with this program. If not, see <http://www.gnu.org/licenses/>.          //
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <QDebug>
+
+#include "devicesamplestatic.h"
+
+int64_t DeviceSampleStatic::calculateSourceDeviceCenterFrequency(
+            uint64_t centerFrequency,
+            int64_t transverterDeltaFrequency,
+            int log2Decim,
+            fcPos_t fcPos,
+            uint32_t devSampleRate,
+            FrequencyShiftScheme frequencyShiftScheme,
+            bool transverterMode)
+{
+    int64_t deviceCenterFrequency = centerFrequency;
+    deviceCenterFrequency -= transverterMode ? transverterDeltaFrequency : 0;
+    deviceCenterFrequency = deviceCenterFrequency < 0 ? 0 : deviceCenterFrequency;
+    int64_t f_img = deviceCenterFrequency;
+
+    deviceCenterFrequency -= calculateSourceFrequencyShift(log2Decim, fcPos, devSampleRate, frequencyShiftScheme);
+    f_img -= 2*calculateSourceFrequencyShift(log2Decim, fcPos, devSampleRate, frequencyShiftScheme);
+
+    qDebug() << "DeviceSampleStatic::calculateSourceDeviceCenterFrequency:"
+            << " frequencyShiftScheme: " << frequencyShiftScheme
+            << " desired center freq: " << centerFrequency << " Hz"
+            << " device center freq: " << deviceCenterFrequency << " Hz"
+            << " device sample rate: " << devSampleRate << "S/s"
+            << " Actual sample rate: " << devSampleRate/(1<<log2Decim) << "S/s"
+            << " center freq position code: " << fcPos
+            << " image frequency: " << f_img << "Hz";
+
+    return deviceCenterFrequency;
+}
+
+int64_t DeviceSampleStatic::calculateSourceCenterFrequency(
+            uint64_t deviceCenterFrequency,
+            int64_t transverterDeltaFrequency,
+            int log2Decim,
+            fcPos_t fcPos,
+            uint32_t devSampleRate,
+            FrequencyShiftScheme frequencyShiftScheme,
+            bool transverterMode)
+{
+    qint64 centerFrequency = deviceCenterFrequency;
+    centerFrequency += calculateSourceFrequencyShift(log2Decim, fcPos, devSampleRate, frequencyShiftScheme);
+    centerFrequency += transverterMode ? transverterDeltaFrequency : 0;
+    centerFrequency = centerFrequency < 0 ? 0 : centerFrequency;
+
+    qDebug() << "DeviceSampleStatic::calculateSourceCenterFrequency:"
+            << " frequencyShiftScheme: " << frequencyShiftScheme
+            << " desired center freq: " << centerFrequency << " Hz"
+            << " device center freq: " << deviceCenterFrequency << " Hz"
+            << " device sample rate: " << devSampleRate << "S/s"
+            << " Actual sample rate: " << devSampleRate/(1<<log2Decim) << "S/s"
+            << " center freq position code: " << fcPos;
+
+    return centerFrequency;
+}
+
+/**
+ * log2Decim = 0:  no shift
+ *
+ * n = log2Decim <= 2: fc = +/- 1/2^(n-1)
+ *      center
+ *  |     ^     |
+ *  | inf | sup |
+ *     ^     ^
+ *
+ * n = log2Decim > 2: fc = +/- 1/2^n
+ *         center
+ *  |         ^         |
+ *  |  |inf|  |  |sup|  |
+ *       ^         ^
+ */
+int DeviceSampleStatic::calculateSourceFrequencyShift(
+            int log2Decim,
+            fcPos_t fcPos,
+            uint32_t devSampleRate,
+            FrequencyShiftScheme frequencyShiftScheme)
+{
+    if (frequencyShiftScheme == FSHIFT_STD)
+    {
+        if (log2Decim == 0) { // no shift at all
+            return 0;
+        } else if (log2Decim < 3) {
+            if (fcPos == FC_POS_INFRA) { // shift in the square next to center frequency
+                return -(devSampleRate / (1<<(log2Decim+1)));
+            } else if (fcPos == FC_POS_SUPRA) {
+                return devSampleRate / (1<<(log2Decim+1));
+            } else {
+                return 0;
+            }
+        } else {
+            if (fcPos == FC_POS_INFRA) { // shift centered in the square next to center frequency
+                return -(devSampleRate / (1<<(log2Decim)));
+            } else if (fcPos == FC_POS_SUPRA) {
+                return devSampleRate / (1<<(log2Decim));
+            } else {
+                return 0;
+            }
+        }
+    }
+    else // frequencyShiftScheme == FSHIFT_TXSYNC
+    {
+        if (fcPos == FC_POS_CENTER) {
+            return 0;
+        }
+
+        int sign = fcPos == FC_POS_INFRA ? -1 : 1;
+        int halfSampleRate = devSampleRate / 2; // fractions are relative to sideband thus based on half the sample rate
+
+        if (log2Decim == 0) {
+            return 0;
+        } else if (log2Decim == 1) {
+            return sign * (halfSampleRate / 2);         // inf or sup: 1/2
+        } else if (log2Decim == 2) {
+            return sign * ((halfSampleRate * 3) / 4);   // inf, inf or sup, sup: 1/2 + 1/4
+        } else if (log2Decim == 3) {
+            return sign * ((halfSampleRate * 5) / 8);   // inf, inf, sup or sup, sup, inf: 1/2 + 1/4 - 1/8 = 5/8
+        } else if (log2Decim == 4) {
+            return sign * ((halfSampleRate * 11) / 16); // inf, inf, sup, inf or sup, sup, inf, sup: 1/2 + 1/4 - 1/8 + 1/16 = 11/16
+        } else if (log2Decim == 5) {
+            return sign * ((halfSampleRate * 21) / 32); // inf, inf, sup, inf, sup or sup, sup, inf, sup, inf: 1/2 + 1/4 - 1/8 + 1/16 - 1/32 = 21/32
+        } else if (log2Decim == 6) {
+            return sign * ((halfSampleRate * 21) / 64); // inf, sup, inf, sup, inf, sup or sup, inf, sup, inf, sup, inf: 1/2 - 1/4 + 1/8 -1/16 + 1/32 - 1/64 = 21/64
+        } else {
+            return 0;
+        }
+    }
+}
+
+int64_t DeviceSampleStatic::calculateSinkDeviceCenterFrequency(
+            uint64_t centerFrequency,
+            int64_t transverterDeltaFrequency,
+            int log2Interp,
+            fcPos_t fcPos,
+            uint32_t devSampleRate,
+            bool transverterMode)
+{
+    int64_t deviceCenterFrequency = centerFrequency;
+    deviceCenterFrequency -= transverterMode ? transverterDeltaFrequency : 0;
+    deviceCenterFrequency = deviceCenterFrequency < 0 ? 0 : deviceCenterFrequency;
+    int64_t f_img = deviceCenterFrequency;
+
+    deviceCenterFrequency -= calculateSinkFrequencyShift(log2Interp, fcPos, devSampleRate);
+    f_img -= 2*calculateSinkFrequencyShift(log2Interp, fcPos, devSampleRate);
+
+    qDebug() << "DeviceSampleStatic::calculateSinkDeviceCenterFrequency:"
+            << " desired center freq: " << centerFrequency << " Hz"
+            << " device center freq: " << deviceCenterFrequency << " Hz"
+            << " device sample rate: " << devSampleRate << "S/s"
+            << " Actual sample rate: " << devSampleRate/(1<<log2Interp) << "S/s"
+            << " center freq position code: " << fcPos
+            << " image frequency: " << f_img << "Hz";
+
+    return deviceCenterFrequency;
+}
+
+int64_t DeviceSampleStatic::calculateSinkCenterFrequency(
+            uint64_t deviceCenterFrequency,
+            int64_t transverterDeltaFrequency,
+            int log2Interp,
+            fcPos_t fcPos,
+            uint32_t devSampleRate,
+            bool transverterMode)
+{
+    int64_t centerFrequency = deviceCenterFrequency;
+    centerFrequency += calculateSinkFrequencyShift(log2Interp, fcPos, devSampleRate);
+    centerFrequency += transverterMode ? transverterDeltaFrequency : 0;
+    centerFrequency = centerFrequency < 0 ? 0 : centerFrequency;
+
+    qDebug() << "DeviceSampleStatic::calculateSinkCenterFrequency:"
+            << " desired center freq: " << centerFrequency << " Hz"
+            << " device center freq: " << deviceCenterFrequency << " Hz"
+            << " device sample rate: " << devSampleRate << "S/s"
+            << " Actual sample rate: " << devSampleRate/(1<<log2Interp) << "S/s"
+            << " center freq position code: " << fcPos;
+
+    return centerFrequency;
+}
+
+/**
+ * log2Interp = 0:  no shift
+ *
+ * log2Interp = 1:  middle of side band (inf or sup: 1/2)
+ *        ^     |     ^
+ *  | inf | inf | sup | sup |
+ *
+ * log2Interp = 2:  middle of far side half side band (inf, inf or sup, sup: 1/2 + 1/4)
+ *     ^        |        ^
+ *  | inf | inf | sup | sup |
+ *
+ * log2Interp = 3:  inf, inf, sup or sup, sup, inf: 1/2 + 1/4 - 1/8 = 5/8
+ * log2Interp = 4:  inf, inf, sup, inf or sup, sup, inf, sup: 1/2 + 1/4 - 1/8 + 1/16 = 11/16
+ * log2Interp = 5:  inf, inf, sup, inf, sup or sup, sup, inf, sup, inf: 1/2 + 1/4 - 1/8 + 1/16 - 1/32 = 21/32
+ * log2Interp = 6:  inf, sup, inf, sup, inf, sup or sup, inf, sup, inf, sup, inf: 1/2 - 1/4 + 1/8 -1/16 + 1/32 - 1/64 = 21/64
+ *
+ */
+int DeviceSampleStatic::calculateSinkFrequencyShift(
+            int log2Interp,
+            fcPos_t fcPos,
+            uint32_t devSampleRate)
+{
+    if (fcPos == FC_POS_CENTER) {
+        return 0;
+    }
+
+    int sign = fcPos == FC_POS_INFRA ? -1 : 1;
+    int halfSampleRate = devSampleRate / 2; // fractions are relative to sideband thus based on half the sample rate
+
+    if (log2Interp == 0) {
+        return 0;
+    } else if (log2Interp == 1) {
+        return sign * (halfSampleRate / 2);
+    } else if (log2Interp == 2) {
+        return sign * ((halfSampleRate * 3) / 4);
+    } else if (log2Interp == 3) {
+        return sign * ((halfSampleRate * 5) / 8);
+    } else if (log2Interp == 4) {
+        return sign * ((halfSampleRate * 11) / 16);
+    } else if (log2Interp == 5) {
+        return sign * ((halfSampleRate * 21) / 32);
+    } else if (log2Interp == 6) {
+        return sign * ((halfSampleRate * 21) / 64);
+    } else {
+        return 0;
+    }
+}
+

sdrbase/dsp/devicesamplestatic.h

@@ -0,0 +1,82 @@
+///////////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2019 F4EXB                                                      //
+// written by Edouard Griffiths                                                  //
+//                                                                               //
+// 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 as version 3 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 V3 for more details.                               //
+//                                                                               //
+// You should have received a copy of the GNU General Public License             //
+// along with this program. If not, see <http://www.gnu.org/licenses/>.          //
+///////////////////////////////////////////////////////////////////////////////////
+
+#include <stdint.h>
+
+class DeviceSampleStatic
+{
+public:
+    typedef enum {
+        FC_POS_INFRA = 0,
+        FC_POS_SUPRA,
+        FC_POS_CENTER
+    } fcPos_t;
+
+    typedef enum {
+        FSHIFT_STD = 0, // Standard Rx independent
+        FSHIFT_TXSYNC   // Follows same scheme as Tx
+    } FrequencyShiftScheme;
+
+    static int64_t calculateSourceDeviceCenterFrequency(
+            uint64_t centerFrequency,
+            int64_t transverterDeltaFrequency,
+            int log2Decim,
+            fcPos_t fcPos,
+            uint32_t devSampleRate,
+            FrequencyShiftScheme frequencyShiftScheme,
+            bool transverterMode = false
+    );
+
+    static int64_t calculateSourceCenterFrequency(
+            uint64_t deviceCenterFrequency,
+            int64_t transverterDeltaFrequency,
+            int log2Decim,
+            fcPos_t fcPos,
+            uint32_t devSampleRate,
+            FrequencyShiftScheme frequencyShiftScheme,
+            bool transverterMode = false
+    );
+
+    static int calculateSourceFrequencyShift(
+            int log2Decim,
+            fcPos_t fcPos,
+            uint32_t devSampleRate,
+            FrequencyShiftScheme frequencyShiftScheme
+    );
+
+    static int64_t calculateSinkDeviceCenterFrequency(
+            uint64_t centerFrequency,
+            int64_t transverterDeltaFrequency,
+            int log2Interp,
+            fcPos_t fcPos,
+            uint32_t devSampleRate,
+            bool transverterMode = false);
+
+    static int64_t calculateSinkCenterFrequency(
+            uint64_t deviceCenterFrequency,
+            int64_t transverterDeltaFrequency,
+            int log2Interp,
+            fcPos_t fcPos,
+            uint32_t devSampleRate,
+            bool transverterMode = false);
+
+    static int calculateSinkFrequencyShift(
+            int log2Interp,
+            fcPos_t fcPos,
+            uint32_t devSampleRate);
+};