/* ==============================================================================
   Property of Freescale
   Freescale Confidential Proprietary
   Freescale Copyright (C) 2007 All rights reserved
   ------------------------------------------------------------------------------
   $RCSfile: SBL1_TRDLSPK_TurboEncoder.c.rca $
   $Revision: 1.4 $
   $Date: Thu Feb 28 19:22:22 2008 $
   ============================================================================== */

/*--------------------------------------------------------------------------------*/
/**
 @file
 @brief   TurboEncoder kernel
*/
/*--------------------------------------------------------------------------------*/
#include "SBL_CM_Types.h"
#include "SBL1_SP_ErrorCodes.h"
#include "SBL1_SP_Defines.h"
#include "SBL1_TRDLSPK_TurboEncoder.h"
/*--------------------------------------------------------------------------------*/
/*!
 @fn INT32 SBL1_TRDLSPK_TurboEncoder(UINT8 	*input_ptr,
                                	UINT8  *output_ptr,
                             		UINT8  *output_ptr_p1,
                             		UINT8  *output_ptr_p2,
                             		UINT16  block_length,
                             		UINT16 *interleaver_table )
 
 @brief   TurboEncoder API
 
 @param   input_ptr   			Pointer to the beginning of  input data array.
 @param   output_ptr    		Pointer to the beginning of  systematic	bit data array.
 @param   output_ptr_p1  		Pointer to the beginning of  parity-1 bit data array.
 @param   output_ptr_p2  		Pointer to the beginning of  parity-2 bit data array.
 @param   block_length  		Gives the number of bits in the  input data array.
 @param   interleaver_table     Gives the indices of interleaved data for
								the second recursive encoder of the 3gpp
								turbo encoder.
  
 @return  SUCCESS
*/
/*--------------------------------------------------------------------------------*/


INT32 SBL1_TRDLSPK_TurboEncoder(UINT8 	*input_ptr,
                                UINT8  *output_ptr,
                             	UINT8  *output_ptr_p1,
                             	UINT8  *output_ptr_p2,
                             	UINT16  block_length,
                             	UINT16 *interleaver_table )
{
    UINT16  usiI;                   /* General loop siCOUNTer                  */
    INT16   interleaver_index;      /* Index into the interleaver table      */
    INT8    register_a0;            /* Register farthest to the normal input */
    INT8    register_a1;            /* Register second farthest to the normal inp*/
    INT8    register_a2;            /* Register nearest to the normal input  */
    INT8    temp_register_1;        /* First Temporary Register              */
    INT8    temp_register_2;        /* Second Temporary Register             */
    INT8    temp_register_3;        /* Third Temporary Register          */
    INT8    temp_register_4;        /* Fourth Temporary Register             */
    INT8    register_b0;            /* Register farthest to the interleaved input */
    INT8    register_b1;            /* Register second farthest to the normal inp*/
    INT8    register_b2;            /* Register nearest to the normal input   */
    UINT16  reminder;
    UINT32  error;
	
	if(block_length > MAX_CODE_BLK_SIZE_DLSCH)
    {
    		error = ERROR|SPK_TURBOENCODING|ERROR_INVALID_INPUT_LENGTH;
    		APP_ASSERT(error);
    }
	
    /* Initialization of registers             */
    register_a0 = register_a1 = register_a2 = 0;
    register_b0 = register_b1 = register_b2 = 0;
    reminder = (UINT16)(block_length % 3);
    block_length = (UINT16)(block_length - reminder);

/*******************************************************************************
* In this loop three outputs X(t),Z(t) and X'(t) are computed three times      *
*******************************************************************************/

    for(usiI = 0;usiI < block_length;usiI = (UINT16)(usiI+3)) {

        interleaver_index = (INT16)interleaver_table[usiI];
        temp_register_1 = (INT8)(register_a1^input_ptr[usiI]);
        temp_register_2 = (INT8)(register_b1^input_ptr[interleaver_index]);

        *output_ptr++ =   (UINT8)input_ptr[usiI];                 /*  X(t)  */
        *output_ptr_p1++ = (UINT8)(temp_register_1^register_a2);    /*  Z(t)  */
        *output_ptr_p2++ = (UINT8)(temp_register_2^register_b2);    /*  X'(t) */

        interleaver_index = (INT16)interleaver_table[usiI+1];

        register_a0 = (INT8)(temp_register_1^register_a0);
        register_b0 = (INT8)(temp_register_2^register_b0);

        temp_register_1 = (INT8)(register_a2^input_ptr[usiI+1]);
        temp_register_2 = (INT8)(register_b2^input_ptr[interleaver_index]);

        *output_ptr++ = input_ptr[usiI+1];               /*  X(t)  */
        *output_ptr_p1++ = (UINT8)(temp_register_1^register_a0);    /*  Z(t)  */
        *output_ptr_p2++ = (UINT8)(temp_register_2^register_b0);    /*  X'(t) */

        interleaver_index = (INT16)interleaver_table[usiI+2];

        register_a1 = (INT8)(temp_register_1^register_a1);
        register_b1 = (INT8)(temp_register_2^register_b1);

        temp_register_1 = (INT8)(register_a0^input_ptr[usiI+2]);
        temp_register_2 = (INT8)(register_b0^input_ptr[interleaver_index]);

        *output_ptr++ = input_ptr[usiI+2];               /*  X(t)  */
        *output_ptr_p1++ = (UINT8)(temp_register_1^register_a1);    /*  Z(t)  */
        *output_ptr_p2++ = (UINT8)(temp_register_2^register_b1);    /*  X'(t) */

        register_a2 = (INT8)(temp_register_1^register_a2);
        register_b2 = (INT8)(temp_register_2^register_b2);
    }

    usiI = block_length;
    if (reminder == 2) {
        interleaver_index = (INT16)interleaver_table[usiI];
        /*  X(t)  */
        *output_ptr++ = input_ptr[usiI];
        /*  Z(t)  */
        *output_ptr_p1++ = (UINT8)(register_a2^register_a1^input_ptr[usiI]);
        /*  X'(t) */
        *output_ptr_p2++ = (UINT8)(input_ptr[interleaver_index]^register_b2^register_b1);

        temp_register_1 = register_a2;
        temp_register_2 = register_a1;
        temp_register_3 = register_b2;
        temp_register_4 = register_b1;

        register_a2 = (INT8)(input_ptr[usiI]^register_a1^register_a0);
        register_a1 = temp_register_1;
        register_a0 = temp_register_2;
        register_b2 = (INT8)(input_ptr[interleaver_index]^register_b1^register_b0);
        register_b1 = temp_register_3;
        register_b0 = temp_register_4;

        usiI = (UINT16)(usiI + 1);
        interleaver_index = (INT16)interleaver_table[usiI];

        /*  X(t)  */
        *output_ptr++ = input_ptr[usiI];
        /*  Z(t)  */
        *output_ptr_p1++ = (UINT8)(register_a2^register_a1^input_ptr[usiI]);
        /*  X'(t) */
        *output_ptr_p2++ = (UINT8)(input_ptr[interleaver_index]^register_b2^register_b1);

        temp_register_1 = register_a2;
        temp_register_2 = register_a1;
        temp_register_3 = register_b2;
        temp_register_4 = register_b1;

        register_a2 = (INT8)(input_ptr[usiI]^register_a1^register_a0);
        register_a1 = temp_register_1;
        register_a0 = temp_register_2;
        register_b2 = (INT8)(input_ptr[interleaver_index]^register_b1^register_b0);
        register_b1 = temp_register_3;
        register_b0 = temp_register_4;
    }
    else if (reminder == 1) {
        interleaver_index = (INT16)interleaver_table[usiI];
        /*  X(t)  */
        *output_ptr++ = input_ptr[usiI];
        /*  Z(t)  */
        *output_ptr_p1++ = (UINT8)(register_a2^register_a1^input_ptr[usiI]);
        /*  X'(t) */
        *output_ptr_p2++ = (UINT8)(input_ptr[interleaver_index]^register_b2^register_b1);

        temp_register_1 = register_a2;
        temp_register_2 = register_a1;
        temp_register_3 = register_b2;
        temp_register_4 = register_b1;

        register_a2 = (INT8)(input_ptr[usiI]^register_a1^register_a0);
        register_a1 = temp_register_1;
        register_a0 = temp_register_2;

        register_b2 = (INT8)(input_ptr[interleaver_index]^register_b1^register_b0);
        register_b1 = temp_register_3;
        register_b0 = temp_register_4;
    }

/* Generation of 12 tail bits: Since zero is always inserted into the shift*/
/* registers, tail bits are calculated without actually shifting registers*/
/* acReg1 and acReg2 */

   /* Tail bits generation from first RSC encoder*/

   *output_ptr++   = (UINT8)(register_a1 ^ register_a0);      /* X(t) */
   *output_ptr_p1++ = (UINT8)(register_a2 ^ register_a0);    /* Y(t) */
   *output_ptr_p2++ = (UINT8)(register_a2 ^ register_a1);    /* X(t+1) */

   *output_ptr++ =   (UINT8)(register_a1) ;                   /* Y(t+1) */
   *output_ptr_p1++ = (UINT8)(register_a2) ;                 /* X(t+2) */
   *output_ptr_p2++ = (UINT8)(register_a2) ;                 /* Y(t+2) */

   /* Tail bits generation from second RSC encoder*/

   *output_ptr++ =   (UINT8)(register_b1 ^ register_b0);      /* X'(t) */
   *output_ptr_p1++ = (UINT8)(register_b2 ^ register_b0);    /* Y'(t) */
   *output_ptr_p2++ = (UINT8)(register_b2 ^ register_b1);    /* X'(t+1) */

   *output_ptr++ = (UINT8)(register_b1) ;                   /* Y'(t+1) */
   *output_ptr_p1++ = (UINT8)(register_b2) ;                 /* X'(t+2) */
   *output_ptr_p2++ = (UINT8)(register_b2) ;                 /* Y'(t+2) */

   return (SUCCESS);
}