Implement fixed-point symbols, FFT and file output

1 files changed, 76 insertions, 59 deletions

diff --git a/src/PhaseReference.cpp b/src/PhaseReference.cpp
index 568e15e..d7b89bf 100644
--- a/src/PhaseReference.cpp
+++ b/src/PhaseReference.cpp
@@ -29,12 +29,10 @@
 
 #include <stdexcept>
 
-using complexf = std::complex<float>;
-
 /* ETSI EN 300 401 Table 43 (Clause 14.3.2)
  * Contains h_{i,k} values
  */
-const uint8_t PhaseReference::d_h[4][32] = {
+static const uint8_t d_h[4][32] = {
     /* h0 */ { 0, 2, 0, 0, 0, 0, 1, 1, 2, 0, 0, 0, 2, 2, 1, 1,
         0, 2, 0, 0, 0, 0, 1, 1, 2, 0, 0, 0, 2, 2, 1, 1 },
     /* h1 */ { 0, 3, 2, 3, 0, 1, 3, 0, 2, 1, 2, 3, 2, 3, 3, 0,
@@ -54,41 +52,80 @@ const uint8_t PhaseReference::d_h[4][32] = {
  * Tables 44 to 47 describe the frequency interleaving done in
  * FrequencyInterleaver.
  */
-PhaseReference::PhaseReference(unsigned int dabmode) :
+PhaseReference::PhaseReference(unsigned int dabmode, bool fixedPoint) :
     ModInput(),
-    d_dabmode(dabmode)
+    d_dabmode(dabmode),
+    d_fixedPoint(fixedPoint)
 {
     PDEBUG("PhaseReference::PhaseReference(%u) @ %p\n", dabmode, this);
 
     switch (d_dabmode) {
         case 1:
             d_carriers = 1536;
-            d_num = 2048;
             break;
         case 2:
             d_carriers = 384;
-            d_num = 512;
             break;
         case 3:
             d_carriers = 192;
-            d_num = 256;
             break;
         case 4:
             d_dabmode = 0;
         case 0:
             d_carriers = 768;
-            d_num = 1024;
             break;
         default:
             throw std::runtime_error(
                     "PhaseReference::PhaseReference DAB mode not valid!");
     }
-    d_dataIn.resize(d_carriers);
-    fillData();
+
+    if (d_fixedPoint) {
+        d_phaseRefFixed.fillData(d_dabmode, d_carriers);
+    }
+    else {
+        d_phaseRefCF32.fillData(d_dabmode, d_carriers);
+    }
 }
 
 
-complexf convert(uint8_t data) {
+static const int table[][48][2] = {
+    { // Mode 0/4
+        // Positive part
+        { 0, 0 }, { 3, 1 }, { 2, 0 }, { 1, 2 }, { 0, 0 }, { 3, 1 },
+        { 2, 2 }, { 1, 2 }, { 0, 2 }, { 3, 1 }, { 2, 3 }, { 1, 0 },
+        // Negative part
+        { 0, 0 }, { 1, 1 }, { 2, 1 }, { 3, 2 }, { 0, 2 }, { 1, 2 },
+        { 2, 0 }, { 3, 3 }, { 0, 3 }, { 1, 1 }, { 2, 3 }, { 3, 2 },
+    },
+    { // Mode 1
+        // Positive part
+        { 0, 3 }, { 3, 1 }, { 2, 1 }, { 1, 1 }, { 0, 2 }, { 3, 2 },
+        { 2, 1 }, { 1, 0 }, { 0, 2 }, { 3, 2 }, { 2, 3 }, { 1, 3 },
+        { 0, 0 }, { 3, 2 }, { 2, 1 }, { 1, 3 }, { 0, 3 }, { 3, 3 },
+        { 2, 3 }, { 1, 0 }, { 0, 3 }, { 3, 0 }, { 2, 1 }, { 1, 1 },
+        // Negative part
+        { 0, 1 }, { 1, 2 }, { 2, 0 }, { 3, 1 }, { 0, 3 }, { 1, 2 },
+        { 2, 2 }, { 3, 3 }, { 0, 2 }, { 1, 1 }, { 2, 2 }, { 3, 3 },
+        { 0, 1 }, { 1, 2 }, { 2, 3 }, { 3, 3 }, { 0, 2 }, { 1, 2 },
+        { 2, 2 }, { 3, 1 }, { 0, 1 }, { 1, 3 }, { 2, 1 }, { 3, 2 },
+    },
+    { // Mode 2
+        // Positive part
+        { 2, 0 }, { 1, 2 }, { 0, 2 }, { 3, 1 }, { 2, 0 }, { 1, 3 },
+        // Negative part
+        { 0, 2 }, { 1, 3 }, { 2, 2 }, { 3, 2 }, { 0, 1 }, { 1, 2 },
+    },
+    { // Mode 3
+        // Positive part
+        { 3, 2 }, { 2, 2 }, { 1, 2 },
+        // Negative part
+        { 0, 2 }, { 1, 3 }, { 2, 0 },
+    },
+};
+
+
+template <>
+complexf PhaseRefGen<complexf>::convert(uint8_t data) {
     const complexf value[] = {
         complexf(1, 0),
         complexf(0, 1),
@@ -98,62 +135,37 @@ complexf convert(uint8_t data) {
     return value[data % 4];
 }
 
+template <>
+complexfix PhaseRefGen<complexfix>::convert(uint8_t data) {
+    constexpr auto one = fpm::fixed_16_16{1};
+    constexpr auto zero = fpm::fixed_16_16{0};
 
-void PhaseReference::fillData()
-{
-    const int table[][48][2] = {
-        { // Mode 0/4
-            // Positive part
-            { 0, 0 }, { 3, 1 }, { 2, 0 }, { 1, 2 }, { 0, 0 }, { 3, 1 },
-            { 2, 2 }, { 1, 2 }, { 0, 2 }, { 3, 1 }, { 2, 3 }, { 1, 0 },
-            // Negative part
-            { 0, 0 }, { 1, 1 }, { 2, 1 }, { 3, 2 }, { 0, 2 }, { 1, 2 },
-            { 2, 0 }, { 3, 3 }, { 0, 3 }, { 1, 1 }, { 2, 3 }, { 3, 2 },
-        },
-        { // Mode 1
-            // Positive part
-            { 0, 3 }, { 3, 1 }, { 2, 1 }, { 1, 1 }, { 0, 2 }, { 3, 2 },
-            { 2, 1 }, { 1, 0 }, { 0, 2 }, { 3, 2 }, { 2, 3 }, { 1, 3 },
-            { 0, 0 }, { 3, 2 }, { 2, 1 }, { 1, 3 }, { 0, 3 }, { 3, 3 },
-            { 2, 3 }, { 1, 0 }, { 0, 3 }, { 3, 0 }, { 2, 1 }, { 1, 1 },
-            // Negative part
-            { 0, 1 }, { 1, 2 }, { 2, 0 }, { 3, 1 }, { 0, 3 }, { 1, 2 },
-            { 2, 2 }, { 3, 3 }, { 0, 2 }, { 1, 1 }, { 2, 2 }, { 3, 3 },
-            { 0, 1 }, { 1, 2 }, { 2, 3 }, { 3, 3 }, { 0, 2 }, { 1, 2 },
-            { 2, 2 }, { 3, 1 }, { 0, 1 }, { 1, 3 }, { 2, 1 }, { 3, 2 },
-        },
-        { // Mode 2
-            // Positive part
-            { 2, 0 }, { 1, 2 }, { 0, 2 }, { 3, 1 }, { 2, 0 }, { 1, 3 },
-            // Negative part
-            { 0, 2 }, { 1, 3 }, { 2, 2 }, { 3, 2 }, { 0, 1 }, { 1, 2 },
-        },
-        { // Mode 3
-            // Positive part
-            { 3, 2 }, { 2, 2 }, { 1, 2 },
-            // Negative part
-            { 0, 2 }, { 1, 3 }, { 2, 0 },
-        },
+    const complexfix value[] = {
+        complexfix(one, zero),
+        complexfix(zero, one),
+        complexfix(-one, zero),
+        complexfix(zero, -one),
     };
+    return value[data % 4];
+}
 
-    if (d_dabmode > 3) {
-        throw std::runtime_error(
-                "PhaseReference::fillData invalid DAB mode!");
-    }
-
-    if (d_dataIn.size() != d_carriers) {
+template <typename T>
+void PhaseRefGen<T>::fillData(unsigned int dabmode, size_t carriers)
+{
+    dataIn.resize(carriers);
+    if (dataIn.size() != carriers) {
         throw std::runtime_error(
-                "PhaseReference::fillData d_dataIn has incorrect size!");
+                "PhaseReference::fillData dataIn has incorrect size!");
     }
 
     for (size_t index = 0,
                 offset = 0;
-                index < d_dataIn.size();
+                index < dataIn.size();
                 ++offset) {
         for (size_t k = 0; k < 32; ++k) {
-            d_dataIn[index++] = convert(
-                    d_h[ table[d_dabmode][offset][0] ][k] +
-                    table[d_dabmode][offset][1] );
+            dataIn[index++] = convert(
+                    d_h[ table[dabmode][offset][0] ][k] +
+                    table[dabmode][offset][1] );
         }
     }
 }
@@ -163,7 +175,12 @@ int PhaseReference::process(Buffer* dataOut)
 {
     PDEBUG("PhaseReference::process(dataOut: %p)\n", dataOut);
 
-    dataOut->setData(&d_dataIn[0], d_carriers * sizeof(complexf));
+    if (d_fixedPoint) {
+        dataOut->setData(&d_phaseRefFixed.dataIn[0], d_carriers * sizeof(complexfix));
+    }
+    else {
+        dataOut->setData(&d_phaseRefCF32.dataIn[0], d_carriers * sizeof(complexf));
+    }
 
     return 1;
 }