/* General purpose Reed-Solomon codec for 8-bit symbols or less
 * Copyright 2003 Phil Karn, KA9Q
 * May be used under the terms of the GNU Lesser General Public License (LGPL)
 *
 * This version tweaked by Philip Heron <phil@sanslogic.co.uk>
*/

#include <string.h>
#include "rs8.h"

static const uint8_t ALPHA_TO[] = {
0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80,0x87,0x89,0x95,0xAD,0xDD,0x3D,0x7A,0xF4,
0x6F,0xDE,0x3B,0x76,0xEC,0x5F,0xBE,0xFB,0x71,0xE2,0x43,0x86,0x8B,0x91,0xA5,0xCD,
0x1D,0x3A,0x74,0xE8,0x57,0xAE,0xDB,0x31,0x62,0xC4,0x0F,0x1E,0x3C,0x78,0xF0,0x67,
0xCE,0x1B,0x36,0x6C,0xD8,0x37,0x6E,0xDC,0x3F,0x7E,0xFC,0x7F,0xFE,0x7B,0xF6,0x6B,
0xD6,0x2B,0x56,0xAC,0xDF,0x39,0x72,0xE4,0x4F,0x9E,0xBB,0xF1,0x65,0xCA,0x13,0x26,
0x4C,0x98,0xB7,0xE9,0x55,0xAA,0xD3,0x21,0x42,0x84,0x8F,0x99,0xB5,0xED,0x5D,0xBA,
0xF3,0x61,0xC2,0x03,0x06,0x0C,0x18,0x30,0x60,0xC0,0x07,0x0E,0x1C,0x38,0x70,0xE0,
0x47,0x8E,0x9B,0xB1,0xE5,0x4D,0x9A,0xB3,0xE1,0x45,0x8A,0x93,0xA1,0xC5,0x0D,0x1A,
0x34,0x68,0xD0,0x27,0x4E,0x9C,0xBF,0xF9,0x75,0xEA,0x53,0xA6,0xCB,0x11,0x22,0x44,
0x88,0x97,0xA9,0xD5,0x2D,0x5A,0xB4,0xEF,0x59,0xB2,0xE3,0x41,0x82,0x83,0x81,0x85,
0x8D,0x9D,0xBD,0xFD,0x7D,0xFA,0x73,0xE6,0x4B,0x96,0xAB,0xD1,0x25,0x4A,0x94,0xAF,
0xD9,0x35,0x6A,0xD4,0x2F,0x5E,0xBC,0xFF,0x79,0xF2,0x63,0xC6,0x0B,0x16,0x2C,0x58,
0xB0,0xE7,0x49,0x92,0xA3,0xC1,0x05,0x0A,0x14,0x28,0x50,0xA0,0xC7,0x09,0x12,0x24,
0x48,0x90,0xA7,0xC9,0x15,0x2A,0x54,0xA8,0xD7,0x29,0x52,0xA4,0xCF,0x19,0x32,0x64,
0xC8,0x17,0x2E,0x5C,0xB8,0xF7,0x69,0xD2,0x23,0x46,0x8C,0x9F,0xB9,0xF5,0x6D,0xDA,
0x33,0x66,0xCC,0x1F,0x3E,0x7C,0xF8,0x77,0xEE,0x5B,0xB6,0xEB,0x51,0xA2,0xC3,0x00,
};

static const uint8_t INDEX_OF[] = {
0xFF,0x00,0x01,0x63,0x02,0xC6,0x64,0x6A,0x03,0xCD,0xC7,0xBC,0x65,0x7E,0x6B,0x2A,
0x04,0x8D,0xCE,0x4E,0xC8,0xD4,0xBD,0xE1,0x66,0xDD,0x7F,0x31,0x6C,0x20,0x2B,0xF3,
0x05,0x57,0x8E,0xE8,0xCF,0xAC,0x4F,0x83,0xC9,0xD9,0xD5,0x41,0xBE,0x94,0xE2,0xB4,
0x67,0x27,0xDE,0xF0,0x80,0xB1,0x32,0x35,0x6D,0x45,0x21,0x12,0x2C,0x0D,0xF4,0x38,
0x06,0x9B,0x58,0x1A,0x8F,0x79,0xE9,0x70,0xD0,0xC2,0xAD,0xA8,0x50,0x75,0x84,0x48,
0xCA,0xFC,0xDA,0x8A,0xD6,0x54,0x42,0x24,0xBF,0x98,0x95,0xF9,0xE3,0x5E,0xB5,0x15,
0x68,0x61,0x28,0xBA,0xDF,0x4C,0xF1,0x2F,0x81,0xE6,0xB2,0x3F,0x33,0xEE,0x36,0x10,
0x6E,0x18,0x46,0xA6,0x22,0x88,0x13,0xF7,0x2D,0xB8,0x0E,0x3D,0xF5,0xA4,0x39,0x3B,
0x07,0x9E,0x9C,0x9D,0x59,0x9F,0x1B,0x08,0x90,0x09,0x7A,0x1C,0xEA,0xA0,0x71,0x5A,
0xD1,0x1D,0xC3,0x7B,0xAE,0x0A,0xA9,0x91,0x51,0x5B,0x76,0x72,0x85,0xA1,0x49,0xEB,
0xCB,0x7C,0xFD,0xC4,0xDB,0x1E,0x8B,0xD2,0xD7,0x92,0x55,0xAA,0x43,0x0B,0x25,0xAF,
0xC0,0x73,0x99,0x77,0x96,0x5C,0xFA,0x52,0xE4,0xEC,0x5F,0x4A,0xB6,0xA2,0x16,0x86,
0x69,0xC5,0x62,0xFE,0x29,0x7D,0xBB,0xCC,0xE0,0xD3,0x4D,0x8C,0xF2,0x1F,0x30,0xDC,
0x82,0xAB,0xE7,0x56,0xB3,0x93,0x40,0xD8,0x34,0xB0,0xEF,0x26,0x37,0x0C,0x11,0x44,
0x6F,0x78,0x19,0x9A,0x47,0x74,0xA7,0xC1,0x23,0x53,0x89,0xFB,0x14,0x5D,0xF8,0x97,
0x2E,0x4B,0xB9,0x60,0x0F,0xED,0x3E,0xE5,0xF6,0x87,0xA5,0x17,0x3A,0xA3,0x3C,0xB7,
};

static const uint8_t GENPOLY[] = {
0x00,0xF9,0x3B,0x42,0x04,0x2B,0x7E,0xFB,0x61,0x1E,0x03,0xD5,0x32,0x42,0xAA,0x05,
0x18,0x05,0xAA,0x42,0x32,0xD5,0x03,0x1E,0x61,0xFB,0x7E,0x2B,0x04,0x42,0x3B,0xF9,
0x00,
};

static inline int mod255(int x)
{
	while(x >= 255)
	{
		x -= 255;
		x = (x >> 8) + (x & 255);
	}
	return(x);
}
#define MODNN(x) mod255(x)

#define MM     (8)
#define NN     (255)
#define NROOTS (32)
#define FCR    (112)
#define PRIM   (11)
#define IPRIM  (116)

#define MIN(a,b) ((a) < (b) ? (a) : (b))
#define A0       (NN) /* Special reserved value encoding zero in index form */

/* Portable C version */
void encode_rs_8(uint8_t *data, uint8_t *parity, int pad)
{
	int i, j;
	uint8_t feedback;
	
	memset(parity, 0, NROOTS * sizeof(uint8_t));
	
	for(i = 0; i < NN - NROOTS - pad; i++)
	{
		feedback = INDEX_OF[data[i] ^ parity[0]];
		if(feedback != A0) /* feedback term is non-zero */
		{
			for(j = 1; j < NROOTS; j++)
				parity[j] ^= ALPHA_TO[mod255(feedback + GENPOLY[NROOTS - j])];
		}
		
		/* Shift */
		memmove(&parity[0], &parity[1], sizeof(uint8_t) * (NROOTS - 1));
		if(feedback != A0)
			parity[NROOTS - 1] = ALPHA_TO[mod255(feedback + GENPOLY[0])];
		else
			parity[NROOTS - 1] = 0;
	}
}

int decode_rs_8(uint8_t *data, int *eras_pos, int no_eras, int pad)
{
	int deg_lambda, el, deg_omega;
	int i, j, r, k;
	uint8_t u, q, tmp, num1, num2, den, discr_r;
	uint8_t lambda[NROOTS + 1], s[NROOTS]; /* Err+Eras Locator poly
	                                        * and syndrome poly */
	uint8_t b[NROOTS + 1], t[NROOTS + 1], omega[NROOTS + 1];
	uint8_t root[NROOTS], reg[NROOTS + 1], loc[NROOTS];
	int syn_error, count;
	
	if(pad < 0 || pad > 222) return(-1);
	
	/* form the syndromes; i.e., evaluate data(x) at roots of g(x) */
	for(i = 0; i < NROOTS; i++) s[i] = data[0];
	
	for(j = 1; j < NN - pad; j++)
	{
		for(i = 0; i < NROOTS; i++)
		{
			if(s[i] == 0) s[i] = data[j];
			else s[i] = data[j] ^ ALPHA_TO[MODNN(INDEX_OF[s[i]] + (FCR + i) * PRIM)];
		}
	}
	
	/* Convert syndromes to index form, checking for nonzero condition */
	syn_error = 0;
	for(i = 0; i < NROOTS; i++)
	{
		syn_error |= s[i];
		s[i] = INDEX_OF[s[i]];
	}
	
	if(!syn_error)
	{
		/* if syndrome is zero, data[] is a codeword and there are no
		 * errors to correct. So return data[] unmodified
		 */
		count = 0;
		goto finish;
	}
	
	memset(&lambda[1], 0, NROOTS * sizeof(lambda[0]));
	lambda[0] = 1;
	
	if(no_eras > 0)
	{
		/* Init lambda to be the erasure locator polynomial */
		lambda[1] = ALPHA_TO[MODNN(PRIM * (NN - 1 - eras_pos[0]))];
		for(i = 1; i < no_eras; i++)
		{
			u = MODNN(PRIM * (NN - 1 - eras_pos[i]));
			for(j = i + 1; j > 0; j--)
			{
				tmp = INDEX_OF[lambda[j - 1]];
				if(tmp != A0) lambda[j] ^= ALPHA_TO[MODNN(u + tmp)];
			}
		}
		
	}
	
	for(i = 0; i < NROOTS + 1; i++)
		b[i] = INDEX_OF[lambda[i]];
	
	/*
	 * Begin Berlekamp-Massey algorithm to determine error+erasure
	 * locator polynomial
	 */
	r = no_eras;
	el = no_eras;
	while(++r <= NROOTS) /* r is the step number */
	{
		/* Compute discrepancy at the r-th step in poly-form */
		discr_r = 0;
		for(i = 0; i < r; i++)
		{
			if((lambda[i] != 0) && (s[r - i - 1] != A0))
			{
				discr_r ^= ALPHA_TO[MODNN(INDEX_OF[lambda[i]] + s[r - i - 1])];
			}
		}
		discr_r = INDEX_OF[discr_r]; /* Index form */
		if(discr_r == A0)
		{
			/* 2 lines below: B(x) <-- x*B(x) */
			memmove(&b[1], b, NROOTS * sizeof(b[0]));
			b[0] = A0;
		}
		else
		{
			/* 7 lines below: T(x) <-- lambda(x) - discr_r*x*b(x) */
			t[0] = lambda[0];
			for(i = 0; i < NROOTS; i++)
			{
				if(b[i] != A0)
					t[i + 1] = lambda[i + 1] ^ ALPHA_TO[MODNN(discr_r + b[i])];
				else
					t[i + 1] = lambda[i + 1];
			}
			
			if(2 * el <= r + no_eras - 1)
			{
				el = r + no_eras - el;
				/*
				 * 2 lines below: B(x) <-- inv(discr_r) *
				 * lambda(x)
				 */
				for(i = 0; i <= NROOTS; i++)
					b[i] = (lambda[i] == 0) ? A0 : MODNN(INDEX_OF[lambda[i]] - discr_r + NN);
			}
			else
			{
				/* 2 lines below: B(x) <-- x*B(x) */
				memmove(&b[1], b, NROOTS * sizeof(b[0]));
				b[0] = A0;
			}
			
			memcpy(lambda, t, (NROOTS + 1) * sizeof(t[0]));
		}
	}
	
	/* Convert lambda to index form and compute deg(lambda(x)) */
	deg_lambda = 0;
	for(i = 0; i < NROOTS + 1; i++)
	{
		lambda[i] = INDEX_OF[lambda[i]];
		if(lambda[i] != A0) deg_lambda = i;
	}
	
	/* Find roots of the error+erasure locator polynomial by Chien search */
	memcpy(&reg[1], &lambda[1], NROOTS * sizeof(reg[0]));
	count = 0; /* Number of roots of lambda(x) */
	for(i = 1, k = IPRIM - 1; i <= NN; i++, k = MODNN(k + IPRIM))
	{
		q = 1; /* lambda[0] is always 0 */
		for(j = deg_lambda; j > 0; j--)
		{
			if(reg[j] != A0)
			{
				reg[j] = MODNN(reg[j] + j);
				q ^= ALPHA_TO[reg[j]];
			}
		}
		
		if (q != 0) continue; /* Not a root */
		
		/* store root (index-form) and error location number */
		root[count] = i;
		loc[count] = k;
		/* If we've already found max possible roots,
		 * abort the search to save time
		 */
		if(++count == deg_lambda) break;
	}
	
	if(deg_lambda != count)
	{
		/*
		 * deg(lambda) unequal to number of roots => uncorrectable
		 * error detected
		 */
		count = -1;
		goto finish;
	}
	
	/*
	 * Compute err+eras evaluator poly omega(x) = s(x)*lambda(x) (modulo
	 * x**NROOTS). in index form. Also find deg(omega).
	 */
	deg_omega = deg_lambda - 1;
	for(i = 0; i <= deg_omega; i++)
	{
		tmp = 0;
		for(j = i; j >= 0; j--)
		{
			if((s[i - j] != A0) && (lambda[j] != A0))
				tmp ^= ALPHA_TO[MODNN(s[i - j] + lambda[j])];
		}
		omega[i] = INDEX_OF[tmp];
	}
	
	/*
	 * Compute error values in poly-form. num1 = omega(inv(X(l))), num2 =
	 * inv(X(l))**(FCR-1) and den = lambda_pr(inv(X(l))) all in poly-form
	 */
	for(j = count - 1; j >= 0; j--)
	{
		num1 = 0;
		for(i = deg_omega; i >= 0; i--)
		{
			if(omega[i] != A0) num1 ^= ALPHA_TO[MODNN(omega[i] + i * root[j])];
		}
		num2 = ALPHA_TO[MODNN(root[j] * (FCR - 1) + NN)];
		den = 0;
		
		/* lambda[i+1] for i even is the formal derivative lambda_pr of lambda[i] */
		for(i = MIN(deg_lambda, NROOTS - 1) & ~1; i >= 0; i -= 2)
		{
			if(lambda[i + 1] != A0) den ^= ALPHA_TO[MODNN(lambda[i + 1] + i * root[j])];
		}
		
		/* Apply error to data */
		if(num1 != 0 && loc[j] >= pad)
		{
			data[loc[j] - pad] ^= ALPHA_TO[MODNN(INDEX_OF[num1] + INDEX_OF[num2] + NN - INDEX_OF[den])];
		}
	}
	
finish:
	if(eras_pos != NULL)
	{
		for(i = 0; i < count; i++) eras_pos[i] = loc[i];
	}
	
	return(count);
}

