enh1632.c

Reference Implementation of G.711 standard and other voice codecs

 *  Function Name : shl_r
 *
 *  Purpose :
 *
 *    Identical to shl( var1, var2) but with rounding. Saturates the result
 *    in case of underflows or overflows.
 *
 *  Complexity weight : 3
 *
 *  Inputs :
 *
 *    var1        16 bit short signed integer (Word16) whose value falls in 
 *                the range : 0xffff 8000 <= var1 <= 0x0000 7fff.
 *
 *    var2        16 bit short signed integer (Word16) whose value falls in 
 *                the range : 0xffff 8000 <= var2 <= 0x0000 7fff.
 *
 *  Outputs :
 *
 *    none
 *
 *  Return Value :
 *
 *    var_out     16 bit short signed integer (Word16) whose value falls in 
 *                the range : 0xffff 8000 <= var_out <= 0x0000 7fff.
 *
 *****************************************************************************/
Word16 shl_r( Word16 var1, Word16 var2){
   Word16 var_out;

   if( var2 >= 0) {
      var_out = shl( var1, var2);

      #if (WMOPS)
      multiCounter[currCounter].shl--;
      #endif /* ifdef WMOPS */

   } else {
      var2 = -var2;
      var_out = shr_r( var1, var2);

      #if (WMOPS)
      multiCounter[currCounter].shr_r--;
      #endif /* ifdef WMOPS */
   }

   #if (WMOPS)
   multiCounter[currCounter].shl_r++;
   #endif /* ifdef WMOPS */

   return( var_out);
}


/*****************************************************************************
 *
 *  Function Name : L_shl_r
 *
 *  Purpose :
 *
 *   Same as L_shl( var1, var2) but with rounding. Saturates the result in
 *   case of underflows or overflows.
 *
 *  Complexity weight : 3
 *
 *  Inputs :
 *
 *    L_var1      32 bit long signed integer (Word32) whose value falls in 
 *                the range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.
 *
 *    var2        16 bit short signed integer (Word16) whose value falls in 
 *                the range : 0xffff 8000 <= var2 <= 0x0000 7fff.
 *
 *  Outputs :
 *
 *    none
 *
 *  Return Value :
 *
 *    L_var_out   32 bit long signed integer (Word32) whose value falls in 
 *                the range : 0x8000 0000 <= var_out <= 0x7fff ffff.
 *
 *****************************************************************************/
Word32 L_shl_r( Word32 L_var1, Word16 var2) {
   Word32 var_out;

   if( var2 >= 0) {
      var_out = L_shl( L_var1, var2);

      #if (WMOPS)
      multiCounter[currCounter].L_shl--;
      #endif /* ifdef WMOPS */

   } else {
      var2 = -var2;
      var_out = L_shr_r( L_var1, var2);

      #if (WMOPS)
      multiCounter[currCounter].L_shr_r--;
      #endif /* ifdef WMOPS */
   }

   #if (WMOPS)
   multiCounter[currCounter].L_shl_r++;
   #endif /* ifdef WMOPS */

   return( var_out);
}


/*****************************************************************************
 *
 *  Function Name : rotr
 *
 *  Purpose :
 *
 *    Performs a 16-bit logical rotation of var1 by 1 bit to the LSBits. The
 *    MSBit is set to var2 bit 0. The LSBit of var1 is kept in *var3 bit 0.
 *
 *  Complexity weight : 3
 *
 *  Inputs :
 *
 *    var1        16 bit short signed integer (Word16) whose value falls in
 *                the range : 0xffff 8000 <= var1 <= 0x0000 7fff.
 *
 *    var2        16 bit short signed integer (Word16) whose value must be 0
 *                or 1.
 *
 *  Outputs :
 *
 *    *var3       Points on a 16 bit short signed integer (Word16) whose 
 *                value will be 0 or 1.
 *
 *  Return Value :
 *
 *    var_out     16 bit short signed integer (Word16) whose value falls in
 *                the range : 0xffff 8000 <= var_out <= 0x0000 7fff.
 *
 *****************************************************************************/
Word16 rotr( Word16 var1, Word16 var2, Word16 *var3) {
   Word16 var_out;

   *var3 = s_and( var1, 0x1);
   var_out = s_or( lshr( var1, 1),
                   lshl( var2, 15));

   #if (WMOPS)
   multiCounter[currCounter].s_and--;
   multiCounter[currCounter].lshl--;
   multiCounter[currCounter].lshr--;
   multiCounter[currCounter].s_or--;
   multiCounter[currCounter].rotr++;
   #endif /* ifdef WMOPS */

  return( var_out);
}


/*****************************************************************************
 *
 *  Function Name : rotl
 *
 *  Purpose :
 *
 *    Performs a 16-bit logical rotation of var1 by 1 bit to the MSBits. The
 *    LSBit is set to var2 bit 0. The MSBit of var1 is kept in *var3 bit 0.
 *
 *  Complexity weight : 3
 *
 *  Inputs :
 *
 *    var1        16 bit short signed integer (Word16) whose value falls in
 *                the range : 0xffff 8000 <= var1 <= 0x0000 7fff.
 *
 *    var2        16 bit short signed integer (Word16) whose value must be 0
 *                or 1.
 *
 *  Outputs :
 *
 *    *var3       Points on a 16 bit short signed integer (Word16) whose 
 *                value will be 0 or 1.
 *
 *  Return Value :
 *
 *    var_out     16 bit short signed integer (Word16) whose value falls in
 *                the range : 0xffff 8000 <= var_out <= 0x0000 7fff.
 *
 *****************************************************************************/
Word16 rotl( Word16 var1, Word16 var2, Word16 *var3) {
   Word16 var_out;

   *var3 = lshr( var1, 15);

   var_out = s_or( lshl( var1, 1),
                   s_and( var2, 0x1));

   #if (WMOPS)
   multiCounter[currCounter].lshr--;
   multiCounter[currCounter].s_and--;
   multiCounter[currCounter].lshl--;
   multiCounter[currCounter].s_or--;
   multiCounter[currCounter].rotl++;
   #endif /* ifdef WMOPS */

   return( var_out);
}


/*****************************************************************************
 *
 *  Function Name : L_rotr
 *
 *  Purpose :
 *
 *    Performs a 32-bit logical rotation of L_var1 by 1 bit to the LSBits. The
 *    MSBit is set to var2 bit 0. The LSBit of L_var1 is kept in *var3 bit 0.
 *
 *  Complexity weight : 3
 *
 *  Inputs :
 *
 *    L_var1      32 bit long signed integer (Word32) whose value falls in
 *                the range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.
 *
 *    var2        16 bit short signed integer (Word16) whose value must be 0
 *                or 1.
 *
 *  Outputs :
 *
 *    *var3       Points on a 16 bit short signed integer (Word16) whose 
 *                value will be 0 or 1.
 *
 *  Return Value :
 *
 *    L_var_out   32 bit long signed integer (Word32) whose value falls in
 *                the range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.
 *
 *****************************************************************************/
Word32 L_rotr( Word32 L_var1, Word16 var2, Word16 *var3) {
   Word32 L_var_out;

   *var3 = s_and( extract_l( L_var1), 0x1);

   L_var_out = L_or( L_lshr( L_var1, 1),
                     L_lshl( L_deposit_l( var2), 31));

   #if (WMOPS)
   multiCounter[currCounter].extract_l--;
   multiCounter[currCounter].s_and--;
   multiCounter[currCounter].L_deposit_l--;
   multiCounter[currCounter].L_lshl--;
   multiCounter[currCounter].L_lshr--;
   multiCounter[currCounter].L_or--;
   multiCounter[currCounter].L_rotr++;
   #endif /* ifdef WMOPS */

   return( L_var_out);
}


/*****************************************************************************
 *
 *  Function Name : L_rotl
 *
 *  Purpose :
 *
 *    Performs a 32-bit logical rotation of L_var1 by 1 bit to the MSBits. The
 *    LSBit is set to var2 bit 0. The MSBit of L_var1 is kept in *var3 bit 0.
 *
 *  Complexity weight : 3
 *
 *  Inputs :
 *
 *    L_var1      32 bit long signed integer (Word32) whose value falls in
 *                the range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.
 *
 *    var2        16 bit short signed integer (Word16) whose value must be 0
 *                or 1.
 *
 *  Outputs :
 *
 *    *var3       Points on a 16 bit short signed integer (Word16) whose 
 *                value will be 0 or 1.
 *
 *  Return Value :
 *
 *    L_var_out   32 bit long signed integer (Word32) whose value falls in
 *                the range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.
 *
 *****************************************************************************/
Word32 L_rotl( Word32 L_var1, Word16 var2, Word16 *var3) {
   Word32 L_var_out;

   *var3 = extract_l( L_lshr( L_var1, 31));

   L_var_out = L_or( L_lshl( L_var1, 1),
                     L_deposit_l( s_and( var2, 0x1)));

   #if (WMOPS)
   multiCounter[currCounter].L_lshr--;
   multiCounter[currCounter].extract_l--;
   multiCounter[currCounter].s_and--;
   multiCounter[currCounter].L_deposit_l--;
   multiCounter[currCounter].L_lshl--;
   multiCounter[currCounter].L_or--;
   multiCounter[currCounter].L_rotl++;
   #endif /* ifdef WMOPS */

   return( L_var_out);
}
































/* end of file */