/*
*********************************************************************************
* Copyright (c) National Mobile Communications Research Laboratory. 
* All rights reserved.
* 
* FILE NAME : syndrome_dec.c
* ABSTRUCT:
*	This file is the C file for syndrome decode.
*	
* AUTHOR:	Zhang Tao	2007-02-13
*
*********************************************************************************
*/

/*
*********************************************************************************
*                               INCLUDE FILES
*********************************************************************************
*/

#include<stdio.h>
#include<string.h>

/*
*********************************************************************************
*                              Function Definition
*********************************************************************************
*/
/*
*********************************************************************************
* NAME:		syn_dec1
* PURPOSE:	decode EBCH : (16,11)
*
* Input:	data_in[]:  data input.
*				
* Output:	data_out[]: data output.
*					
* AUTHOR: 	Zhang Tao	2007-02-13	
* 
*********************************************************************************
*/
void syn_dec1(int data_in[],int data_out[])
{
	int index = 0;
	int shift_reg[4] = {0};
	int feedback = 0;
	int syn = 0;
	int err_bit = -1;

	data_out[15] = 0;
	for(index=0;index<15;index++)
	{
		feedback = shift_reg[3];
		shift_reg[3] = shift_reg[2];
		shift_reg[2] = shift_reg[1];
		shift_reg[1] = shift_reg[0] ^ feedback;
		shift_reg[0] = feedback ^ data_in[index];
		data_out[15] ^= data_in[index];
	}
	syn = shift_reg[0] + 2*shift_reg[1] + 4*shift_reg[2] + 8*shift_reg[3];
	switch(syn)
	{
		case 0:	 err_bit = -1;	break;
		case 1:  err_bit = 14;	break;
		case 2:  err_bit = 13;	break;
		case 3:  err_bit = 10;	break;
		case 4:  err_bit = 12;	break;
		case 5:  err_bit =  6;	break;
		case 6:  err_bit =  9;	break;
		case 7:  err_bit =  4;	break;
		case 8:  err_bit = 11;	break;
		case 9:  err_bit =  0;	break;
		case 10: err_bit =  5;	break;
		case 11: err_bit =  7;	break;
		case 12: err_bit =  8;	break;
		case 13: err_bit =  1;	break;
		case 14: err_bit =  3;	break;
		case 15: err_bit =  2;	break;
	}
	
	memcpy(data_out,data_in,15*sizeof(int));

	if(err_bit!=-1)
	{
		data_out[err_bit] = data_out[err_bit] ^ 1;
		data_out[15] ^= 1;
	}	
}
/*
*********************************************************************************
* NAME:		syn_dec2
* PURPOSE:	decode EBCH : (32,26)
*
* Input:	data_in[]:  data input.
*				
* Output:	data_out[]: data output.
*					
* AUTHOR: 	Zhang Tao	2007-02-13	
* 
*********************************************************************************
*/
void syn_dec2(int data_in[],int data_out[])
{
	int index = 0;
	int shift_reg[5] = {0};
	int feedback = 0;
	int syn = 0;
	int err_bit = -1;

	data_out[31] = 0;
	for(index=0;index<31;index++)
	{
		feedback = shift_reg[4];
		shift_reg[4] = shift_reg[3];
		shift_reg[3] = shift_reg[2];
		shift_reg[2] = shift_reg[1] ^ feedback;
		shift_reg[1] = shift_reg[0];
		shift_reg[0] = feedback ^ data_in[index];
		data_out[31] ^= data_in[index];
	}
	syn = shift_reg[0] + 2*shift_reg[1] + 4*shift_reg[2] + 8*shift_reg[3] + 16*shift_reg[4];
	switch(syn)
	{
		case 0:	 err_bit = -1;	break;
		case 1:  err_bit = 30;	break;
		case 2:  err_bit = 29;	break;
		case 3:  err_bit = 12;	break;
		case 4:  err_bit = 28;	break;
		case 5:  err_bit = 25;	break;
		case 6:  err_bit = 11;	break;
		case 7:  err_bit = 19;	break;
		case 8:  err_bit = 27;	break;
		case 9:  err_bit =  1;	break;
		case 10: err_bit = 24;	break;
		case 11: err_bit =  3;	break;
		case 12: err_bit = 10;	break;
		case 13: err_bit = 22;	break;
		case 14: err_bit = 18;	break;
		case 15: err_bit =  7;	break;
		case 16: err_bit = 26;	break;
		case 17: err_bit = 20;	break;
		case 18: err_bit =  0;	break;
		case 19: err_bit = 13;	break;
		case 20: err_bit = 23;	break;
		case 21: err_bit =  8;	break;
		case 22: err_bit =  2;	break;
		case 23: err_bit =  4;	break;
		case 24: err_bit =  9;	break;
		case 25: err_bit =  5;	break;
		case 26: err_bit = 21;	break;
		case 27: err_bit = 14;	break;
		case 28: err_bit = 17;	break;
		case 29: err_bit = 16;	break;
		case 30: err_bit =  6;	break;
		case 31: err_bit = 15;	break;
			
	}
	memcpy(data_out,data_in,31*sizeof(int));

	if(err_bit!=-1)
	{
		data_out[err_bit] = data_out[err_bit] ^ 1;
		data_out[31] ^= 1;
	}
}
/*
*********************************************************************************
* NAME:		syn_dec3
* PURPOSE:	decode EBCH : (64,57)
*
* Input:	data_in[]:  data input.
*				
* Output:	data_out[]: data output.
*					
* AUTHOR: 	Zhang Tao	2007-02-13	
* 
*********************************************************************************
*/
void syn_dec3(int data_in[],int data_out[])
{
	int index = 0;
	int shift_reg[6] = {0};
	int feedback = 0;
	int syn = 0;
	int err_bit = -1;

	data_out[63] = 0;
	for(index=0;index<63;index++)
	{
		feedback = shift_reg[5];
		shift_reg[5] = shift_reg[4];
		shift_reg[4] = shift_reg[3];
		shift_reg[3] = shift_reg[2];
		shift_reg[2] = shift_reg[1];
		shift_reg[1] = shift_reg[0] ^ feedback;
		shift_reg[0] = feedback ^ data_in[index];
		data_out[63] ^= data_in[index];
	}
	syn = shift_reg[0] + 2*shift_reg[1] + 4*shift_reg[2] + 8*shift_reg[3] 
		  + 16*shift_reg[4] + 32*shift_reg[5];
	switch(syn)
	{
		case 0:	 err_bit = -1;	break;
		case 1:  err_bit = 62;	break;
		case 2:  err_bit = 61;	break;
		case 3:  err_bit = 56;	break;
		case 4:  err_bit = 60;	break;
		case 5:  err_bit = 50;	break;
		case 6:  err_bit = 55;	break;
		case 7:  err_bit = 36;	break;
		case 8:  err_bit = 59;	break;
		case 9:  err_bit = 30;	break;
		case 10: err_bit = 49;	break;
		case 11: err_bit = 27;	break;
		case 12: err_bit = 54;	break;
		case 13: err_bit = 14;	break;
		case 14: err_bit = 35;	break;
		case 15: err_bit = 44;	break;
		case 16: err_bit = 58;	break;
		case 17: err_bit = 38;	break;
		case 18: err_bit = 29;	break;
		case 19: err_bit = 46;	break;
		case 20: err_bit = 47;	break;
		case 21: err_bit = 10;	break;
		case 22: err_bit = 26;	break;
		case 23: err_bit =  8;	break;
		case 24: err_bit = 53;	break;
		case 25: err_bit = 17;	break;
		case 26: err_bit = 13;	break;
		case 27: err_bit = 24;	break;
		case 28: err_bit = 34;	break;
		case 29: err_bit = 21;	break;
		case 30: err_bit = 43;	break;
		case 31: err_bit =  6;	break;
		case 32: err_bit = 57;	break;
		case 33: err_bit =  0;	break;
		case 34: err_bit = 37;	break;
		case 35: err_bit = 51;	break;
		case 36: err_bit = 28;	break;
		case 37: err_bit = 31;	break;
		case 38: err_bit = 45;	break;
		case 39: err_bit = 15;	break;
		case 40: err_bit = 47;	break;
		case 41: err_bit = 39;	break;
		case 42: err_bit =  9;	break;
		case 43: err_bit = 11;	break;
		case 44: err_bit = 25;	break;
		case 45: err_bit = 18;	break;
		case 46: err_bit =  7;	break;
		case 47: err_bit = 22;	break;
		case 48: err_bit = 52;	break;
		case 49: err_bit =  1;	break;
		case 50: err_bit = 16;	break;
		case 51: err_bit = 32;	break;
		case 52: err_bit = 12;	break;
		case 53: err_bit = 40;	break;
		case 54: err_bit = 23;	break;
		case 55: err_bit = 19;	break;
		case 56: err_bit = 33;	break;
		case 57: err_bit =  2;	break;
		case 58: err_bit = 20;	break;
		case 59: err_bit = 41;	break;
		case 60: err_bit = 42;	break;
		case 61: err_bit =  3;	break;
		case 62: err_bit =  5;	break;
		case 63: err_bit =  4;	break;
			
	}
	memcpy(data_out,data_in,63*sizeof(int));

	if(err_bit!=-1)
	{
		data_out[err_bit] = data_out[err_bit] ^ 1;
		data_out[63] ^= 1;
	}
}
/*
*********************************************************************************
* NAME:		syndrome_dec
* PURPOSE:	sydrome decode for EBCH.
*
* Input:	data_in[]:  data input.
*			len_in : code length
*				
* Output:	data_out[]: data output.
*					
* AUTHOR: 	Zhang Tao	2007-02-13	
* 
*********************************************************************************
*/
void syndrome_dec(int data_in[],int len_in,int data_out[])
{
	switch(len_in)
	{
	case 16:
		syn_dec1(data_in,data_out); break;
	case 32:
		syn_dec2(data_in,data_out); break;
	case 64:
		syn_dec3(data_in,data_out); break;
	}
}