*	 RETURN VALUE:
 *
 *	   swOut
 *					   16 bit short signed integer (Shortword) whose value
 *					   falls in the range
 *					   0xffff 8001 <= swOut <= 0x0000 7fff.
 *
 *	 KEYWORDS: negate, negative, invert
 *
 *************************************************************************/

Shortword negate(Shortword var1)
{
	Shortword	swOut;


	if (var1 == SW_MIN){
		inc_saturation();
		swOut = SW_MAX;
	} else
		swOut = (Shortword) (-var1);
	return(swOut);
}


/***************************************************************************
 *
 *	 FUNCTION NAME: L_negate
 *
 *	 PURPOSE:
 *
 *	   Negate the 32 bit input. 0x8000 0000's negated value is
 *	   0x7fff ffff.
 *
 *	 INPUTS:
 *
 *	   L_var1
 *					   32 bit long signed integer (Longword) whose value
 *					   falls in the range
 *					   0x8000 0000 <= L_var1 <= 0x7fff ffff.
 *
 *	 OUTPUTS:
 *
 *	   none
 *
 *	 RETURN VALUE:
 *
 *	   L_Out
 *					   32 bit long signed integer (Longword) whose value
 *					   falls in the range
 *					   0x8000 0001 <= L_var1 <= 0x7fff ffff.
 *
 *	 KEYWORDS: negate, negative
 *
 *************************************************************************/

Longword L_negate(Longword L_var1)
{
	Longword	L_Out;

	if (L_var1 == LW_MIN){
		inc_saturation();
		L_Out = LW_MAX;
	} else
		L_Out = -L_var1;
	return(L_Out);
}


/***************************************************************************
 *
 *	 FUNCTION NAME: add
 *
 *	 PURPOSE:
 *
 *	   Perform the addition of the two 16 bit input variable with
 *	   saturation.
 *
 *	 INPUTS:
 *
 *	   var1
 *					   16 bit short signed integer (Shortword) whose value
 *					   falls in the range 0xffff 8000 <= var1 <= 0x0000 7fff.
 *	   var2
 *					   16 bit short signed integer (Shortword) whose value
 *					   falls in the range 0xffff 8000 <= var2 <= 0x0000 7fff.
 *
 *	 OUTPUTS:
 *
 *	   none
 *
 *	 RETURN VALUE:
 *
 *	   swOut
 *					   16 bit short signed integer (Shortword) whose value
 *					   falls in the range
 *					   0xffff 8000 <= swOut <= 0x0000 7fff.
 *
 *	 IMPLEMENTATION:
 *
 *	   Perform the addition of the two 16 bit input variable with
 *	   saturation.
 *
 *	   swOut = var1 + var2
 *
 *	   swOut is set to 0x7fff if the operation results in an
 *	   overflow.  swOut is set to 0x8000 if the operation results
 *	   in an underflow.
 *
 *	 KEYWORDS: add, addition
 *
 *************************************************************************/

Shortword add(Shortword var1, Shortword var2)
{
	Longword	L_sum;
	Shortword	swOut;

	L_sum = (Longword) var1 + var2;
	swOut = saturate(L_sum);
	return(swOut);
}


/***************************************************************************
 *
 *	 FUNCTION NAME: L_add
 *
 *	 PURPOSE:
 *
 *	   Perform the addition of the two 32 bit input variables with
 *	   saturation.
 *
 *	 INPUTS:
 *
 *	   L_var1
 *					   32 bit long signed integer (Longword) whose value
 *					   falls in the range
 *					   0x8000 0000 <= L_var1 <= 0x7fff ffff.
 *	   L_var2
 *					   32 bit long signed integer (Longword) whose value
 *					   falls in the range
 *					   0x8000 0000 <= L_var2 <= 0x7fff ffff.
 *
 *	 OUTPUTS:
 *
 *	   none
 *
 *	 RETURN VALUE:
 *
 *	   L_Out
 *					   32 bit long signed integer (Longword) whose value
 *					   falls in the range
 *					   0x8000 0000 <= L_var1 <= 0x7fff ffff.
 *
 *	 IMPLEMENTATION:
 *
 *	   Perform the addition of the two 32 bit input variables with
 *	   saturation.
 *
 *	   L_Out = L_var1 + L_var2
 *
 *	   L_Out is set to 0x7fff ffff if the operation results in an
 *	   overflow.  L_Out is set to 0x8000 0000 if the operation
 *	   results in an underflow.
 *
 *	 KEYWORDS: add, addition
 *
 *************************************************************************/
Longword L_add(Longword L_var1, Longword L_var2)
{
	Longword	L_Sum, L_SumLow, L_SumHigh;

	L_Sum = L_var1 + L_var2;

	if ((L_var1 > 0 && L_var2 > 0) || (L_var1 < 0 && L_var2 < 0)){

		/* an overflow is possible */
		L_SumLow = (L_var1 & (Longword) 0xffff) + (L_var2 & (Longword) 0xffff);
		L_SumHigh = ((L_var1 >> 16) & (Longword) 0xffff) +
					((L_var2 >> 16) & (Longword) 0xffff);
		if (L_SumLow & (Longword) 0x10000){
			/* carry into high word is set */
			L_SumHigh ++;
		}

		/* Update sum only if there is an overflow or underflow */
		if ( ((Longword) 0x10000 & L_SumHigh) &&
			!((Longword) 0x8000 & L_SumHigh)){
			inc_saturation();
			L_Sum = LW_MIN;                                      /* underflow */
		} else if (!((Longword) 0x10000 & L_SumHigh) &&
				    ((Longword) 0x8000 & L_SumHigh)){
			inc_saturation();
			L_Sum = LW_MAX;                                       /* overflow */
		}
	}

	return (L_Sum);
}


/***************************************************************************
 *
 *	 FUNCTION NAME: sub
 *
 *	 PURPOSE:
 *
 *	   Perform the subtraction of the two 16 bit input variable with
 *	   saturation.
 *
 *	 INPUTS:
 *
 *	   var1
 *					   16 bit short signed integer (Shortword) whose value
 *					   falls in the range 0xffff 8000 <= var1 <= 0x0000 7fff.
 *	   var2
 *					   16 bit short signed integer (Shortword) whose value
 *					   falls in the range 0xffff 8000 <= var2 <= 0x0000 7fff.
 *
 *	 OUTPUTS:
 *
 *	   none
 *
 *	 RETURN VALUE:
 *
 *	   swOut
 *					   16 bit short signed integer (Shortword) whose value
 *					   falls in the range
 *					   0xffff 8000 <= swOut <= 0x0000 7fff.
 *
 *	 IMPLEMENTATION:
 *
 *	   Perform the subtraction of the two 16 bit input variable with
 *	   saturation.
 *
 *	   swOut = var1 - var2
 *
 *	   swOut is set to 0x7fff if the operation results in an
 *	   overflow.  swOut is set to 0x8000 if the operation results
 *	   in an underflow.
 *
 *	 KEYWORDS: sub, subtraction
 *
 *************************************************************************/
Shortword sub(Shortword var1, Shortword var2)
{
	Longword	L_diff;
	Shortword	swOut;

	L_diff = (Longword) var1 - var2;
	swOut = saturate(L_diff);

	return(swOut);
}


/***************************************************************************
 *
 *	 FUNCTION NAME: L_sub
 *
 *	 PURPOSE:
 *
 *	   Perform the subtraction of the two 32 bit input variables with
 *	   saturation.
 *
 *	 INPUTS:
 *
 *	   L_var1
 *					   32 bit long signed integer (Longword) whose value
 *					   falls in the range
 *					   0x8000 0000 <= L_var1 <= 0x7fff ffff.
 *	   L_var2
 *					   32 bit long signed integer (Longword) whose value
 *					   falls in the range
 *					   0x8000 0000 <= L_var2 <= 0x7fff ffff.
 *
 *	 OUTPUTS:
 *
 *	   none
 *
 *	 RETURN VALUE:
 *
 *	   L_Out
 *					   32 bit long signed integer (Longword) whose value
 *					   falls in the range
 *					   0x8000 0000 <= L_var1 <= 0x7fff ffff.
 *
 *	 IMPLEMENTATION:
 *
 *	   Perform the subtraction of the two 32 bit input variables with
 *	   saturation.
 *
 *	   L_Out = L_var1 - L_var2
 *
 *	   L_Out is set to 0x7fff ffff if the operation results in an
 *	   overflow.  L_Out is set to 0x8000 0000 if the operation
 *	   results in an underflow.
 *
 *	 KEYWORDS: sub, subtraction
 *
 *************************************************************************/
Longword L_sub(Longword L_var1, Longword L_var2)
{
	Longword	L_Sum;

	/* check for overflow */
	if ((L_var1 > 0 && L_var2 < 0) || (L_var1 < 0 && L_var2 > 0)) {
		if (L_var2 == LW_MIN){
			L_Sum = L_add(L_var1, LW_MAX);
			L_Sum = L_add(L_Sum, 1);
		} else
			L_Sum = L_add(L_var1, -L_var2);
	} else                                            /* no overflow possible */
		L_Sum = L_var1 - L_var2;
	return(L_Sum);
}


/***************************************************************************
 *
 *	 FUNCTION NAME: shr
 *
 *	 PURPOSE:
 *
 *	   Arithmetic shift right (or left).
 *	   Arithmetically shift the input right by var2.   If var2 is
 *	   negative then an arithmetic shift left (shl) of var1 by
 *	   -var2 is performed.
 *
 *	 INPUTS:
 *
 *	   var1
 *					   16 bit short signed integer (Shortword) whose value
 *					   falls in the range 0xffff 8000 <= var1 <= 0x0000 7fff.
 *	   var2
 *					   16 bit short signed integer (Shortword) whose value
 *					   falls in the range 0xffff 8000 <= var2 <= 0x0000 7fff.
 *
 *	 OUTPUTS:
 *
 *	   none
 *
 *	 RETURN VALUE:
 *
 *	   swOut
 *					   16 bit short signed integer (Shortword) whose value
 *					   falls in the range
 *					   0xffff 8000 <= swOut <= 0x0000 7fff.
 *
 *	 IMPLEMENTATION:
 *
 *	   Arithmetically shift the input right by var2.  This
 *	   operation maintains the sign of the input number. If var2 is
 *	   negative then an arithmetic shift left (shl) of var1 by
 *	   -var2 is performed.	See description of shl for details.
 *
 *	   Equivalent to the Full-Rate GSM ">> n" operation.  Note that
 *	   ANSI-C does not guarantee operation of the C ">>" or "<<"
 *	   operator for negative numbers.
 *
 *	 KEYWORDS: shift, arithmetic shift right,
 *
 *************************************************************************/

Shortword shr(Shortword var1, Shortword var2)
{
	Shortword	swMask, swOut;

	if (var2 == 0 || var1 == 0)
		swOut = var1;
	else if (var2 < 0){                   /* perform an arithmetic left shift */
		if (var2 <= -15){
			swOut = (Shortword) ((var1 > 0) ? SW_MAX : SW_MIN);
                                                                  /* saturate */
			inc_saturation();
		} else
			swOut = shl(var1, (Shortword) -var2);
	} else {                                          /* positive shift count */
		if (var2 >= 15)
			swOut = (Shortword) ((var1 < 0) ? -1 : 0);
		else {                                 /* take care of sign extension */
			swMask = 0;
			if (var1 < 0)
				swMask = (Shortword) (~swMask << (16 - var2));

			var1 >>= var2;
			swOut = (Shortword) (swMask | var1);
		}
	}
	return (swOut);
}


/***************************************************************************
 *
 *	 FUNCTION NAME: shl
 *
 *	 PURPOSE:
 *
 *	   Arithmetically shift the input left by var2.
 *
 *
 *	 INPUTS:
 *
 *	   var1
 *					   16 bit short signed integer (Shortword) whose value
 *					   falls in the range 0xffff 8000 <= var1 <= 0x0000 7fff.
 *	   var2
 *					   16 bit short signed integer (Shortword) whose value
 *					   falls in the range 0xffff 8000 <= var2 <= 0x0000 7fff.
 *
 *	 OUTPUTS:
 *
 *	   none
 *
 *	 RETURN VALUE:
 *
 *	   swOut
 *					   16 bit short signed integer (Shortword) whose value
 *					   falls in the range
 *					   0xffff 8000 <= swOut <= 0x0000 7fff.
 *
 *	 IMPLEMENTATION:
 *