// --------------------------------------------------------------
#include <string.h>
#include <math.h>
#include <stdint.h>
#include "Symbolizer.hpp"


Symbolizer::Symbolizer(ISymbolizer *pSymbolHandler)
	: m_pSymbolHandler(pSymbolHandler)
	, m_symbolBitCount(0)
	, m_lastSymbol(0)
	, m_symbolMask(0)
{
	setNumBitsPerSymbol(8);
}

void Symbolizer::setNumBitsPerSymbol(uint32_t nBitsPerSym)
{
	m_symbolBitCount = 0;
	m_nBitsPerSym = nBitsPerSym;
	m_lastSymbol = 0;
	m_symbolMask = 0;
	for(uint32_t k=0; k < nBitsPerSym; k++)
	{
		m_symbolMask <<= 1;
		m_symbolMask |= 1;
	}
}

void Symbolizer::process(uint8_t src)
{
	uint32_t i;
	static uint32_t dst;

	// Speed up
	if (m_nBitsPerSym == SIZEOF_DATA_BITS)
	{
		m_pSymbolHandler->onSymbol(differentialEncode((uint32_t)src));
		return;
	}

	// Transmission order MSB first
	for (i=0; i < SIZEOF_DATA_BITS; i++)
	{
		dst <<= 1;
		dst |= (uint32_t)((src >> (SIZEOF_DATA_BITS-1) & 1) != 0);
		src <<= 1;
		m_symbolBitCount++;
		if (m_symbolBitCount == m_nBitsPerSym)
		{
			m_pSymbolHandler->onSymbol(differentialEncode(dst));
			m_symbolBitCount = 0;
			dst = 0;
		}
	}
}

void Symbolizer::process(void *pSrc, uint32_t len)
{
	data_t *pData;

	pData = (data_t*)pSrc;
	
	while(len--)
	{
		process(*(pData++));
	}
}

uint32_t Symbolizer::differentialEncode(uint32_t symbol)
{
	// Differential encode
	m_lastSymbol = (uint32_t)(m_symbolMask & (symbol + m_lastSymbol));

	return m_lastSymbol;
}

void Symbolizer::onFrame(void *pFrame, uint32_t size)
{
	data_t *pData = (data_t*)pFrame;

	while(size)
	{
		process(*(pData++));
		size -= sizeof(data_t);
	}
}

// --------------------------------------------------------------