fxpt.h

手机加密通话软件

 *
 *     L_Out
 *                     32 bit long signed integer (fxpt_32) whose value
 *                     falls in the range
 *                     0x8000 0000 <= L_var1 <= 0x7fff ffff.
 *
 *
 *   IMPLEMENTATION:
 *
 *     Arithmetically shift the 32 bit input left by var2.  This
 *     operation maintains the sign of the input number. If var2 is
 *     negative then an arithmetic shift right (fxpt_shr32) of L_var1 by
 *     -var2 is performed.  See description of fxpt_shr32 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 left,
 *
 *************************************************************************/

INLINE fxpt_32
fxpt_shl32 (fxpt_32 L_var1, int var2)
{
  fxpt_32 L_Out;

  if (var2 < 0) {
    L_Out = L_var1 >> -var2;
  }
  else {
    L_Out = L_var1 << var2;
    if ((L_Out >> var2) != L_var1)
      L_Out = (L_var1 > 0) ? FX32_MAX : FX32_MIN;
  }

  return (L_Out);
}

/*
 *   Same as above except var2 is assumed to be between 0 and 31
 *   inclusive.
 */
INLINE fxpt_32
fxpt_shl32_fast (fxpt_32 L_var1, int var2)
{
  fxpt_32 L_Out;

  L_Out = L_var1 << var2;

  if ((L_Out >> var2) != L_var1)
    L_Out = (L_var1 > 0) ? FX32_MAX : FX32_MIN;

  return (L_Out);
}

/***************************************************************************
 *
 *   FUNCTION NAME: fxpt_shr32
 *
 *   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:
 *
 *     var2
 *                     16 bit short signed integer (fxpt_16) whose value
 *                     falls in the range 0xffff 8000 <= var2 <= 0x0000 7fff.
 *     L_var1
 *                     32 bit long signed integer (fxpt_32) whose value
 *                     falls in the range
 *                     0x8000 0000 <= L_var1 <= 0x7fff ffff.
 *   OUTPUTS:
 *
 *     none
 *
 *   RETURN VALUE:
 *
 *     L_Out
 *                     32 bit long signed integer (fxpt_32) whose value
 *                     falls in the range
 *                     0x8000 0000 <= L_var1 <= 0x7fff ffff.
 *
 *
 *   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 L_var1 by
 *     -var2 is performed.  See description of fxpt_shl32 for details.
 *
 *     The input is a 32 bit number, as is the output.
 *
 *     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,
 *
 *************************************************************************/

INLINE fxpt_32
fxpt_shr32 (fxpt_32 L_var1, int var2)
{
  fxpt_32 L_Out;

  if (var2 < 0) {
    L_Out = L_var1 << -var2;
    if ((L_Out >> -var2) != L_var1)
      L_Out = (L_var1 > 0) ? FX32_MAX : FX32_MIN;
  }
  else {
    L_Out = L_var1 >> var2;
  }

  return (L_Out);
}


/*
 *   Same as above except var2 is assumed to be between 0 and 31
 *   inclusive.
 */

INLINE fxpt_32
fxpt_shr32_fast (fxpt_32 L_var1, int var2)
{
  return L_var1 >> var2;
}


/***************************************************************************
 *
 *   FUNCTION NAME: fxpt_shl16
 *
 *   PURPOSE:
 *
 *     Arithmetically shift the input left by var2.
 *
 *
 *   INPUTS:
 *
 *     var1
 *                     16 bit short signed integer (fxpt_16) whose value
 *                     falls in the range 0xffff 8000 <= var1 <= 0x0000 7fff.
 *     var2
 *                     16 bit short signed integer (fxpt_16) whose value
 *                     falls in the range 0xffff 8000 <= var2 <= 0x0000 7fff.
 *
 *   OUTPUTS:
 *
 *     none
 *
 *   RETURN VALUE:
 *
 *     swOut
 *                     16 bit short signed integer (fxpt_16) whose value
 *                     falls in the range
 *                     0xffff 8000 <= swOut <= 0x0000 7fff.
 *
 *   IMPLEMENTATION:
 *
 *     If Arithmetically shift the input left by var2.  If var2 is
 *     negative then an arithmetic shift right (shr) of var1 by
 *     -var2 is performed.  See description of shr for details.
 *     When an arithmetic shift left is performed the var2 LS bits
 *     are zero filled.
 *
 *     The only exception is if the left shift causes an overflow
 *     or underflow.  In this case the LS bits are not modified.
 *     The number returned is 0x8000 in the case of an underflow or
 *     0x7fff in the case of an overflow.
 *
 *     The shl is equivalent to the Full-Rate GSM "<< n" operation.
 *     Note that ANSI-C does not guarantee operation of the C ">>"
 *     or "<<" operator for negative numbers - it is not specified
 *     whether this shift is an arithmetic or logical shift.
 *
 *   KEYWORDS: asl, arithmetic shift left, shift
 *
 *************************************************************************/

INLINE fxpt_16
fxpt_shl16 (fxpt_16 var1, int var2)
{
  fxpt_16 swOut;
  fxpt_32 L_Out;

  if (var2 < 0) {
    swOut = var1 >> var2;
  }
  else {

    L_Out = ((fxpt_32) var1) << var2;

    swOut = (fxpt_16) L_Out;

    if (swOut != L_Out) {
      if (var1 > 0)
        swOut = FX16_MAX;
      else
        swOut = FX16_MIN;
    }
  }

  return (swOut);
}


/*
 *   Same as above except var2 is assumed to be between 0 and 15
 *   inclusive.
 */
INLINE fxpt_16
fxpt_shl16_fast(fxpt_16 var1, int var2)
{
  fxpt_16 swOut;
  fxpt_32 L_Out;

  L_Out = ((fxpt_32) var1) << var2;

  swOut = (fxpt_16) L_Out;       /* copy low portion to swOut, overflow
                                  * could have happened
                                  */
  if (swOut != L_Out)
  {
    /* overflow  */
    if (var1 > 0)
      swOut = FX16_MAX;              /* saturate */
    else
      swOut = FX16_MIN;              /* saturate */
  }

  return (swOut);
}


/***************************************************************************
 *
 *   FUNCTION NAME: fxpt_shr16
 *
 *   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 (fxpt_16) whose value
 *                     falls in the range 0xffff 8000 <= var1 <= 0x0000 7fff.
 *     var2
 *                     16 bit short signed integer (fxpt_16) whose value
 *                     falls in the range 0xffff 8000 <= var2 <= 0x0000 7fff.
 *
 *   OUTPUTS:
 *
 *     none
 *
 *   RETURN VALUE:
 *
 *     swOut
 *                     16 bit short signed integer (fxpt_16) 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,
 *
 *************************************************************************/

INLINE fxpt_16
fxpt_shr16 (fxpt_16 var1, fxpt_16 var2)
{
  fxpt_32 L_Out;
  fxpt_16 swOut;

  if (var2 < 0) {
    L_Out = ((fxpt_32) var1) << var2;
    swOut = (fxpt_16) L_Out;

    if (swOut != L_Out) {
      if (var1 > 0)
        swOut = FX16_MAX;
      else
        swOut = FX16_MIN;
    }
  }
  else {
    swOut = var1 >> var2;
  }

  return (swOut);
}


/*
 *   Same as above except var2 is assumed to be between 0 and 15
 *   inclusive.
 */
INLINE fxpt_16
fxpt_shr16_fast(fxpt_16 var1, fxpt_16 var2)
{
  return var1 >> var2;
}


/*
 *   Same as fxpt_shr16_fast, except rounding is performed
 */
INLINE fxpt_16
fxpt_shr16_round(fxpt_16 var1, int var2)
{
  int sign;
  fxpt_16 rOut;

  if (var2 == 0) {
    return var1;
  }

  /* Note sign */
  if (var1 < 0) {
    sign = -1;
    rOut = -var1;
  }
  else {
    sign = 0;
    rOut = var1;
  }

  /* Rounding shift */
  rOut >>= (var2 - 1);
  rOut++;
  rOut >>= 1;

  /* Handle sign */
  if (sign)
    return -rOut;
  else
    return rOut;
}


/***************************************************************************
 *
 *   FUNCTION NAME: fxpt_extract_h
 *
 *   PURPOSE:
 *
 *     Extract the 16 MS bits of a 32 bit fxpt_32.  Return the 16 bit
 *     number as a fxpt_16.  This is used as a "truncation" of a fractional
 *     number.
 *
 *   INPUTS:
 *
 *     L_var1
 *                     32 bit long signed integer (fxpt_32) whose value
 *                     falls in the range
 *                     0x8000 0000 <= L_var1 <= 0x7fff ffff.
 *
 *   OUTPUTS:
 *
 *     none
 *
 *   RETURN VALUE:
 *
 *     swOut
 *                     16 bit short signed integer (fxpt_16) whose value
 *                     falls in the range
 *                     0xffff 8000 <= swOut <= 0x0000 7fff.
 *
 *   IMPLEMENTATION:
 *
 *   KEYWORDS: assign, truncate
 *
 *************************************************************************/

INLINE fxpt_16
fxpt_extract_h (fxpt_32 L_var1)
{
  fxpt_16 var2 = (fxpt_16)(L_var1 >> 16);
  return var2;
}


/***************************************************************************
 *
 *   FUNCTION NAME: fxpt_extract_l
 *
 *   PURPOSE:
 *
 *     Extract the 16 LS bits of a 32 bit fxpt_32.  Return the 16 bit
 *     number as a fxpt_16.  The upper portion of the input fxpt_32
 *     has no impact whatsoever on the output.
 *
 *   INPUTS:
 *
 *     L_var1
 *                     32 bit long signed integer (fxpt_32) whose value
 *                     falls in the range
 *                     0x8000 0000 <= L_var1 <= 0x7fff ffff.
 *
 *   OUTPUTS:
 *
 *     none
 *
 *   RETURN VALUE:
 *
 *     swOut
 *                     16 bit short signed integer (fxpt_16) whose value
 *                     falls in the range
 *                     0xffff 8000 <= swOut <= 0x0000 7fff.
 *
 *
 *   KEYWORDS: extract, assign
 *
 *************************************************************************/

INLINE fxpt_16
fxpt_extract_l (fxpt_32 L_var1)
{
  fxpt_16 var2;

  var2 = (fxpt_16) (0x0000ffffL & L_var1);
  return (var2);
}


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

INLINE fxpt_32
fxpt_negate32 (fxpt_32 L_var1)
{
  fxpt_32 L_Out;

  if (L_var1 == FX32_MIN)
    L_Out = FX32_MAX;
  else
    L_Out = -L_var1;
  return (L_Out);
}


/***************************************************************************
 *
 *   FUNCTION NAME: fxpt_negate16
 *
 *   PURPOSE:
 *
 *     Negate the 16 bit input. 0x8000's negated value is 0x7fff.
 *
 *   INPUTS:
 *
 *     var1
 *                     16 bit short signed integer (fxpt_16) whose value
 *                     falls in the range 0xffff 8000 <= var1 <= 0x0000 7fff.
 *
 *   OUTPUTS:
 *
 *     none
 *
 *   RETURN VALUE:
 *
 *     swOut
 *                     16 bit short signed integer (fxpt_16) whose value
 *                     falls in the range
 *                     0xffff 8001 <= swOut <= 0x0000 7fff.
 *
 *   KEYWORDS: negate, negative, invert
 *
 *************************************************************************/

INLINE fxpt_16
fxpt_negate16 (fxpt_16 var1)
{
  fxpt_16 swOut;

  if (var1 == FX16_MIN)
    swOut = FX16_MAX;
  else
    swOut = -var1;
  return (swOut);
}

/***************************************************************************
 *
 *   FUNCTION NAME: fxpt_round16
 *
 *   PURPOSE:
 *
 *     Round the 32 bit fxpt_32 into a 16 bit shortword with saturation.
 *
 *   INPUTS:
 *
 *     L_var1
 *                     32 bit long signed integer (fxpt_32) whose value
 *                     falls in the range
 *                     0x8000 0000 <= L_var1 <= 0x7fff ffff.
 *   OUTPUTS:
 *
 *     none
 *
 *   RETURN VALUE:
 *
 *     swOut
 *                     16 bit short signed integer (fxpt_16) whose value
 *                     falls in the range
 *                     0xffff 8000 <= swOut <= 0x0000 7fff.
 *
 *   IMPLEMENTATION:
 *
 *     Perform a two's complement round on the input fxpt_32 with
 *     saturation.
 *
 *     This is equivalent to adding 0x0000 8000 to the input.  The
 *     result may overflow due to the add.  If so, the result is
 *     saturated.  The 32 bit rounded number is then shifted down
 *     16 bits and returned as a fxpt_16.
 *
 *
 *   KEYWORDS: round
 *
 *************************************************************************/

INLINE fxpt_16
fxpt_round16 (fxpt_32 L_var1)
{
  fxpt_32 L_Prod;

  L_Prod = fxpt_add32 (L_var1, 0x00008000L); /* round MSP */
  return (fxpt_extract_h (L_Prod));
}


/***************************************************************************
 *
 *   FUNCTION NAME: fxpt_saturate16
 *
 *   PURPOSE:
 *
 *     Limit the 32 bit input to the range of a 16 bit word.
 *
 *
 *   INPUTS:
 *
 *     L_var1
 *                     32 bit long signed integer (fxpt_32) whose value
 *                     falls in the range
 *                     0x8000 0000 <= L_var1 <= 0x7fff ffff.
 *
 *   OUTPUTS:
 *
 *     none
 *
 *   RETURN VALUE:
 *
 *     swOut
 *                     16 bit short signed integer (fxpt_16) whose value
 *                     falls in the range
 *                     0xffff 8000 <= swOut <= 0x0000 7fff.
 *
 *   KEYWORDS: saturation, limiting, limit, saturate, 16 bits
 *
 *************************************************************************/
INLINE fxpt_16
fxpt_saturate16 (fxpt_32 L_var1)
{