Initial commit

.gitignore

@@ -0,0 +1,12 @@
+Debug
+Release
+x64
+*.bak
+*.obj
+*~
+*.sdf
+*.log
+*.zip
+*.exe
+*.user
+.vs

BPTC19696.cpp

@@ -0,0 +1,346 @@
+/*
+ *	 Copyright (C) 2012 by Ian Wraith
+ *   Copyright (C) 2015 by Jonathan Naylor G4KLX
+ *
+ *   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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "BPTC19696.h"
+
+#include "Hamming.h"
+#include "Utils.h"
+
+#include <cstdio>
+#include <cassert>
+#include <cstring>
+
+CBPTC19696::CBPTC19696() :
+m_rawData(NULL),
+m_deInterData(NULL)
+{
+	m_rawData     = new bool[196];
+	m_deInterData = new bool[196];
+}
+
+CBPTC19696::~CBPTC19696()
+{
+	delete[] m_rawData;
+	delete[] m_deInterData;
+}
+
+// The main decode function
+void CBPTC19696::decode(const unsigned char* in, unsigned char* out)
+{
+	assert(in != NULL);
+	assert(out != NULL);
+
+	//  Get the raw binary
+	decodeExtractBinary(in);
+
+	// Deinterleave
+	decodeDeInterleave();
+
+	// Error check
+	decodeErrorCheck();
+
+	// Extract Data
+	decodeExtractData(out);
+}
+
+// The main encode function
+void CBPTC19696::encode(const unsigned char* in, unsigned char* out)
+{
+	assert(in != NULL);
+	assert(out != NULL);
+
+	// Extract Data
+	encodeExtractData(in);
+
+	// Error check
+	encodeErrorCheck();
+
+	// Deinterleave
+	encodeInterleave();
+
+	//  Get the raw binary
+	encodeExtractBinary(out);
+}
+
+void CBPTC19696::decodeExtractBinary(const unsigned char* in)
+{
+	// First block
+	CUtils::byteToBitsBE(in[0U],  m_rawData + 0U);
+	CUtils::byteToBitsBE(in[1U],  m_rawData + 8U);
+	CUtils::byteToBitsBE(in[2U],  m_rawData + 16U);
+	CUtils::byteToBitsBE(in[3U],  m_rawData + 24U);
+	CUtils::byteToBitsBE(in[4U],  m_rawData + 32U);
+	CUtils::byteToBitsBE(in[5U],  m_rawData + 40U);
+	CUtils::byteToBitsBE(in[6U],  m_rawData + 48U);
+	CUtils::byteToBitsBE(in[7U],  m_rawData + 56U);
+	CUtils::byteToBitsBE(in[8U],  m_rawData + 64U);
+	CUtils::byteToBitsBE(in[9U],  m_rawData + 72U);
+	CUtils::byteToBitsBE(in[10U], m_rawData + 80U);
+	CUtils::byteToBitsBE(in[11U], m_rawData + 88U);
+	CUtils::byteToBitsBE(in[12U], m_rawData + 96U);
+
+	// Handle the two bits
+	bool bits[8U];
+	CUtils::byteToBitsBE(in[20U], bits);
+	m_rawData[98U] = bits[6U];
+	m_rawData[99U] = bits[7U];
+
+	// Second block
+	CUtils::byteToBitsBE(in[21U], m_rawData + 100U);
+	CUtils::byteToBitsBE(in[22U], m_rawData + 108U);
+	CUtils::byteToBitsBE(in[23U], m_rawData + 116U);
+	CUtils::byteToBitsBE(in[24U], m_rawData + 124U);
+	CUtils::byteToBitsBE(in[25U], m_rawData + 132U);
+	CUtils::byteToBitsBE(in[26U], m_rawData + 140U);
+	CUtils::byteToBitsBE(in[27U], m_rawData + 148U);
+	CUtils::byteToBitsBE(in[28U], m_rawData + 156U);
+	CUtils::byteToBitsBE(in[29U], m_rawData + 164U);
+	CUtils::byteToBitsBE(in[30U], m_rawData + 172U);
+	CUtils::byteToBitsBE(in[31U], m_rawData + 180U);
+	CUtils::byteToBitsBE(in[32U], m_rawData + 188U);
+}
+
+// Deinterleave the raw data
+void CBPTC19696::decodeDeInterleave()
+{
+	for (unsigned int i = 0U; i < 196U; i++)
+		m_deInterData[i] = false;
+
+	// The first bit is R(3) which is not used so can be ignored
+	for (unsigned int a = 0U; a < 196U; a++)	{
+		// Calculate the interleave sequence
+		unsigned int interleaveSequence = (a * 181U) % 196U;
+		// Shuffle the data
+		m_deInterData[a] = m_rawData[interleaveSequence];
+	}
+}
+
+// Check each row with a Hamming (15,11,3) code and each column with a Hamming (13,9,3) code
+void CBPTC19696::decodeErrorCheck()
+{
+	bool fixing;
+	unsigned int count = 0U;
+	do {
+		fixing = false;
+
+		// Run through each of the 15 columns
+		bool col[13U];
+		for (unsigned int c = 0U; c < 15U; c++) {
+			unsigned int pos = c + 1U;
+			for (unsigned int a = 0U; a < 13U; a++) {
+				col[a] = m_deInterData[pos];
+				pos = pos + 15U;
+			}
+
+			if (CHamming::decode1393(col)) {
+				unsigned int pos = c + 1U;
+				for (unsigned int a = 0U; a < 13U; a++) {
+					m_deInterData[pos] = col[a];
+					pos = pos + 15U;
+				}
+
+				fixing = true;
+			}
+		}
+
+		// Run through each of the 9 rows containing data
+		for (unsigned int r = 0U; r < 9U; r++) {
+			unsigned int pos = (r * 15U) + 1U;
+			if (CHamming::decode15113(m_deInterData + pos))
+				fixing = true;
+		}
+
+		count++;
+	} while (fixing && count < 5U);
+}
+
+// Extract the 96 bits of payload
+void CBPTC19696::decodeExtractData(unsigned char* data) const
+{
+	bool bData[96U];
+	unsigned int pos = 0U;
+	for (unsigned int a = 4U; a <= 11U; a++, pos++)
+		bData[pos] = m_deInterData[a];
+
+	for (unsigned int a = 16U; a <= 26U; a++, pos++)
+		bData[pos] = m_deInterData[a];
+
+	for (unsigned int a = 31U; a <= 41U; a++, pos++)
+		bData[pos] = m_deInterData[a];
+
+	for (unsigned int a = 46U; a <= 56U; a++, pos++)
+		bData[pos] = m_deInterData[a];
+
+	for (unsigned int a = 61U; a <= 71U; a++, pos++)
+		bData[pos] = m_deInterData[a];
+
+	for (unsigned int a = 76U; a <= 86U; a++, pos++)
+		bData[pos] = m_deInterData[a];
+
+	for (unsigned int a = 91U; a <= 101U; a++, pos++)
+		bData[pos] = m_deInterData[a];
+
+	for (unsigned int a = 106U; a <= 116U; a++, pos++)
+		bData[pos] = m_deInterData[a];
+
+	for (unsigned int a = 121U; a <= 131U; a++, pos++)
+		bData[pos] = m_deInterData[a];
+
+	CUtils::bitsToByteBE(bData + 0U,  data[0U]);
+	CUtils::bitsToByteBE(bData + 8U,  data[1U]);
+	CUtils::bitsToByteBE(bData + 16U, data[2U]);
+	CUtils::bitsToByteBE(bData + 24U, data[3U]);
+	CUtils::bitsToByteBE(bData + 32U, data[4U]);
+	CUtils::bitsToByteBE(bData + 40U, data[5U]);
+	CUtils::bitsToByteBE(bData + 48U, data[6U]);
+	CUtils::bitsToByteBE(bData + 56U, data[7U]);
+	CUtils::bitsToByteBE(bData + 64U, data[8U]);
+	CUtils::bitsToByteBE(bData + 72U, data[9U]);
+	CUtils::bitsToByteBE(bData + 80U, data[10U]);
+	CUtils::bitsToByteBE(bData + 88U, data[11U]);
+}
+
+// Extract the 96 bits of payload
+void CBPTC19696::encodeExtractData(const unsigned char* in) const
+{
+	bool bData[96U];
+	CUtils::byteToBitsBE(in[0U],  bData + 0U);
+	CUtils::byteToBitsBE(in[1U],  bData + 8U);
+	CUtils::byteToBitsBE(in[2U],  bData + 16U);
+	CUtils::byteToBitsBE(in[3U],  bData + 24U);
+	CUtils::byteToBitsBE(in[4U],  bData + 32U);
+	CUtils::byteToBitsBE(in[5U],  bData + 40U);
+	CUtils::byteToBitsBE(in[6U],  bData + 48U);
+	CUtils::byteToBitsBE(in[7U],  bData + 56U);
+	CUtils::byteToBitsBE(in[8U],  bData + 64U);
+	CUtils::byteToBitsBE(in[9U],  bData + 72U);
+	CUtils::byteToBitsBE(in[10U], bData + 80U);
+	CUtils::byteToBitsBE(in[11U], bData + 88U);
+
+	for (unsigned int i = 0U; i < 196U; i++)
+		m_deInterData[i] = false;
+
+	unsigned int pos = 0U;
+	for (unsigned int a = 4U; a <= 11U; a++, pos++)
+		m_deInterData[a] = bData[pos];
+
+	for (unsigned int a = 16U; a <= 26U; a++, pos++)
+		m_deInterData[a] = bData[pos];
+
+	for (unsigned int a = 31U; a <= 41U; a++, pos++)
+		m_deInterData[a] = bData[pos];
+
+	for (unsigned int a = 46U; a <= 56U; a++, pos++)
+		m_deInterData[a] = bData[pos];
+
+	for (unsigned int a = 61U; a <= 71U; a++, pos++)
+		m_deInterData[a] = bData[pos];
+
+	for (unsigned int a = 76U; a <= 86U; a++, pos++)
+		m_deInterData[a] = bData[pos];
+
+	for (unsigned int a = 91U; a <= 101U; a++, pos++)
+		m_deInterData[a] = bData[pos];
+
+	for (unsigned int a = 106U; a <= 116U; a++, pos++)
+		m_deInterData[a] = bData[pos];
+
+	for (unsigned int a = 121U; a <= 131U; a++, pos++)
+		m_deInterData[a] = bData[pos];
+}
+
+// Check each row with a Hamming (15,11,3) code and each column with a Hamming (13,9,3) code
+void CBPTC19696::encodeErrorCheck()
+{
+	// Run through each of the 15 columns
+	bool col[13U];
+	for (unsigned int c = 0U; c < 15U; c++) {
+		unsigned int pos = c + 1U;
+		for (unsigned int a = 0U; a < 13U; a++) {
+			col[a] = m_deInterData[pos];
+			pos = pos + 15U;
+		}
+
+		CHamming::encode1393(col);
+
+		pos = c + 1U;
+		for (unsigned int a = 0U; a < 13U; a++) {
+			m_deInterData[pos] = col[a];
+			pos = pos + 15U;
+		}
+	}
+
+	// Run through each of the 9 rows containing data
+	for (unsigned int r = 0U; r < 9U; r++) {
+		unsigned int pos = (r * 15U) + 1U;
+		CHamming::encode15113(m_deInterData + pos);
+	}
+}
+
+// Interleave the raw data
+void CBPTC19696::encodeInterleave()
+{
+	for (unsigned int i = 0U; i < 196U; i++)
+		m_rawData[i] = false;
+
+	// The first bit is R(3) which is not used so can be ignored
+	for (unsigned int a = 0U; a < 196U; a++)	{
+		// Calculate the interleave sequence
+		unsigned int interleaveSequence = (a * 181U) % 196U;
+		// Unshuffle the data
+		m_rawData[interleaveSequence] = m_deInterData[a];
+	}
+}
+
+void CBPTC19696::encodeExtractBinary(unsigned char* data)
+{
+	// First block
+	CUtils::bitsToByteBE(m_rawData + 0U,  data[0U]);
+	CUtils::bitsToByteBE(m_rawData + 8U,  data[1U]);
+	CUtils::bitsToByteBE(m_rawData + 16U, data[2U]);
+	CUtils::bitsToByteBE(m_rawData + 24U, data[3U]);
+	CUtils::bitsToByteBE(m_rawData + 32U, data[4U]);
+	CUtils::bitsToByteBE(m_rawData + 40U, data[5U]);
+	CUtils::bitsToByteBE(m_rawData + 48U, data[6U]);
+	CUtils::bitsToByteBE(m_rawData + 56U, data[7U]);
+	CUtils::bitsToByteBE(m_rawData + 64U, data[8U]);
+	CUtils::bitsToByteBE(m_rawData + 72U, data[9U]);
+	CUtils::bitsToByteBE(m_rawData + 80U, data[10U]);
+	CUtils::bitsToByteBE(m_rawData + 88U, data[11U]);
+
+	// Handle the two bits
+	unsigned char byte;
+	CUtils::bitsToByteBE(m_rawData + 96U, byte);
+	data[12U] = (data[12U] & 0x3FU) | ((byte >> 0) & 0xC0U);
+	data[13U] = (data[13U] & 0xFCU) | ((byte >> 4) & 0x03U);
+
+// Second block
+	CUtils::bitsToByteBE(m_rawData + 100U,  data[21U]);
+	CUtils::bitsToByteBE(m_rawData + 108U,  data[22U]);
+	CUtils::bitsToByteBE(m_rawData + 116U,  data[23U]);
+	CUtils::bitsToByteBE(m_rawData + 124U,  data[24U]);
+	CUtils::bitsToByteBE(m_rawData + 132U,  data[25U]);
+	CUtils::bitsToByteBE(m_rawData + 140U,  data[26U]);
+	CUtils::bitsToByteBE(m_rawData + 148U,  data[27U]);
+	CUtils::bitsToByteBE(m_rawData + 156U,  data[28U]);
+	CUtils::bitsToByteBE(m_rawData + 164U,  data[29U]);
+	CUtils::bitsToByteBE(m_rawData + 172U,  data[30U]);
+	CUtils::bitsToByteBE(m_rawData + 180U,  data[31U]);
+	CUtils::bitsToByteBE(m_rawData + 188U,  data[32U]);
+}