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


Symbolizer::Symbolizer()
: Processor::Block(1, 1)
, 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)
	{
		symbol_t symbol_encoded = differentialEncode((uint32_t)src);
		m_buf_out->write(&symbol_encoded, 1);
		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)
		{
			symbol_t symbol_encoded = differentialEncode(dst);
			m_buf_out->write(&symbol_encoded, 1);
			m_symbolBitCount = 0;
			dst = 0;
		}
	}
}

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

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

void Symbolizer::prepare()
{
	// Get buffers
	m_buf_in = buffer_in<uint8_t>();
	m_buf_out = buffer_out<symbol_t>();
}

void Symbolizer::process()
{
	// Process input
	while(m_buf_in->len())
	{
		uint8_t data;
		m_buf_in->read(&data, 1);
		process(data);
	}
}

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

	return m_lastSymbol;
}

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