1 files changed, 139 insertions, 0 deletions
diff --git a/src/BlockPartitioner.cpp b/src/BlockPartitioner.cpp
new file mode 100644
index 0000000..bb16ae2
--- /dev/null
+++ b/src/BlockPartitioner.cpp
@@ -0,0 +1,139 @@
+/*
+   Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011 Her Majesty
+   the Queen in Right of Canada (Communications Research Center Canada)
+ */
+/*
+   This file is part of CRC-DADMOD.
+
+   CRC-DADMOD 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 3 of the
+   License, or (at your option) any later version.
+
+   CRC-DADMOD 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 CRC-DADMOD.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "BlockPartitioner.h"
+#include "PcDebug.h"
+
+#include <stdio.h>
+#include <stdexcept>
+#include <string.h>
+#include <stdint.h>
+#include <assert.h>
+
+
+BlockPartitioner::BlockPartitioner(unsigned mode, unsigned fct) :
+    ModMux(ModFormat(0), ModFormat(0)),
+    d_mode(mode)
+{
+    PDEBUG("BlockPartitioner::BlockPartitioner(%i)\n", mode);
+
+    switch (mode) {
+    case 1:
+        d_ficSize = 2304 / 8;
+        d_cifCount = 4;
+        d_outputFramesize = 3072 / 8;
+        d_outputFramecount = 72;
+        break;
+    case 2:
+        d_ficSize = 2304 / 8;
+        d_cifCount = 1;
+        d_outputFramesize = 768 / 8;
+        d_outputFramecount = 72;
+        break;
+    case 3:
+        d_ficSize = 3072 / 8;
+        d_cifCount = 1;
+        d_outputFramesize = 384 / 8;
+        d_outputFramecount = 144;
+        break;
+    case 4:
+        d_ficSize = 2304 / 8;
+        d_cifCount = 2;
+        d_outputFramesize = 1536 / 8;
+        d_outputFramecount = 72;
+        break;
+    default:
+        throw std::runtime_error(
+                "BlockPartitioner::BlockPartitioner invalid mode");
+        break;
+    }
+    d_cifNb = 0;
+    // For Synchronisation purpose, count nb of CIF to drop
+    d_cifInit = fct % d_cifCount;
+    d_cifSize = 864 * 8;
+
+    myInputFormat.size(d_cifSize);
+    myOutputFormat.size(d_cifSize * d_cifCount);
+}
+
+
+BlockPartitioner::~BlockPartitioner()
+{
+    PDEBUG("BlockPartitioner::~BlockPartitioner()\n");
+
+}
+
+
+// dataIn[0] -> FIC
+// dataIn[1] -> CIF
+int BlockPartitioner::process(std::vector<Buffer*> dataIn, Buffer* dataOut)
+{
+    assert(dataIn.size() == 2);
+    dataOut->setLength(d_cifCount * (d_ficSize + d_cifSize));
+
+#ifdef DEBUG
+    fprintf(stderr, "BlockPartitioner::process(dataIn:");
+    for (unsigned i = 0; i < dataIn.size(); ++i) {
+        fprintf(stderr, " %p", dataIn[i]);
+    }
+    fprintf(stderr, ", sizeIn:");
+    for (unsigned i = 0; i < dataIn.size(); ++i) {
+        fprintf(stderr, " %zu", dataIn[i]->getLength());
+    }
+    fprintf(stderr, ", dataOut: %p, sizeOut: %zu)\n", dataOut, dataOut->getLength());
+#endif
+
+    if (dataIn[0]->getLength() != d_ficSize) {
+        throw std::runtime_error(
+                "BlockPartitioner::process input size not valid!");
+    }
+    if (dataIn[1]->getLength() != d_cifSize) {
+        throw std::runtime_error(
+                "BlockPartitioner::process input size not valid!");
+    }
+
+    // Synchronize first CIF
+    if (d_cifInit != 0) {
+        if (++d_cifInit == d_cifCount) {
+            d_cifInit = 0;
+        }
+        // Drop CIF
+        return 0;
+    }
+
+    uint8_t* fic = reinterpret_cast<uint8_t*>(dataIn[0]->getData());
+    uint8_t* cif = reinterpret_cast<uint8_t*>(dataIn[1]->getData());
+    uint8_t* out = reinterpret_cast<uint8_t*>(dataOut->getData());
+
+    // Copy FIC data
+    PDEBUG("Writting FIC %zu bytes to %zu\n", d_ficSize, d_cifNb * d_ficSize);
+    memcpy(out + (d_cifNb * d_ficSize), fic, d_ficSize);
+    // Copy CIF data
+    PDEBUG("Writting CIF %u bytes to %zu\n", 864 * 8,
+            (d_cifCount * d_ficSize) + (d_cifNb * 864 * 8));
+    memcpy(out + (d_cifCount * d_ficSize) + (d_cifNb * 864 * 8), cif, 864 * 8);
+
+    if (++d_cifNb == d_cifCount) {
+        d_cifNb = 0;
+    }
+
+    return d_cifNb == 0;
+}