enh40.h

Reference Implementation of G.711 standard and other voice codecs

 *
 *  Purpose :
 *
 *    Rounds the lower 16 bits of the 40 bit input number. Returns the 40 bit
 *    result with bits 15-0 cleared.
 *    Calls the macro L40_UNDERFLOW_OCCURED() in case of underflow on 40-bit.
 *    Calls the macro L40_OVERFLOW_OCCURED()  in case of overflow  on 40-bit.
 *
 *
 *  Complexity weight : 1
 *
 *  Inputs :
 *
 *    L40_var1    40 bit long signed integer (Word40) whose value falls in the
 *                range : MIN_40 <= L40_var1 <= MAX_40.
 *
 *
 *  Outputs :
 *
 *    none
 *
 *  Return Value :
 *
 *    L40_var_out 40 bit long signed integer (Word40) whose value falls in
 *                the range : MIN_40 <= L40_var_out <= MAX_40.
 *
 *****************************************************************************/
__inline Word40 L40_round( Word40 L40_var1) {
   Word40 L40_var_out;
   Word40 L40_constant = L40_set( 0xffffff0000);

   L40_var_out = L40_add( 0x8000, L40_var1);
   L40_var_out = L40_var_out & L40_constant;

   #if (WMOPS)
   multiCounter[currCounter].L40_set--;
   multiCounter[currCounter].L40_add--;
   multiCounter[currCounter].L40_round++;
   #endif /* ifdef WMOPS */

   return( L40_var_out);
}   


/*****************************************************************************
 *
 *  Function Name : round40
 *
 *  Purpose :
 *
 *    Rounds the lower 16 bits of the 40 bit input number. Saturates the 40
 *    bit result to 32-bit and returns the resulting higher 16-bit.
 *    round40( L40_var1) = extract_h( L_saturate40( L40_round( L40_var1)))
 *    Calls the macro L40_UNDERFLOW_OCCURED() in case of underflow on 40-bit.
 *    Calls the macro L40_OVERFLOW_OCCURED()  in case of overflow  on 40-bit.
 *
 *
 *  Complexity weight : 1
 *
 *  Inputs :
 *
 *    L40_var1    40 bit long signed integer (Word40) whose value falls in the
 *                range : MIN_40 <= L40_var1 <= MAX_40.
 *
 *
 *  Outputs :
 *
 *    none
 *
 *  Return Value :
 *
 *    var_out     16 bit short signed integer (Word16) whose value falls in 
 *                the range 0xffff 8000 <= var_out <= 0x0000 7fff.
 *
 *****************************************************************************/
__inline Word16 round40( Word40 L40_var1) {
   Word16 var_out;

   var_out = extract_h( L_saturate40( L40_round( L40_var1)));

   #if (WMOPS)
   multiCounter[currCounter].L40_round--;
   multiCounter[currCounter].L_saturate40--;
   multiCounter[currCounter].extract_h--;
   multiCounter[currCounter].round40++;
   #endif /* ifdef WMOPS */

   return( var_out);
}   


/*****************************************************************************
 *
 *  Function Name : L40_mult
 *
 *  Purpose :
 *
 *    Multiplies var1 by var2 and shifts the result left by 1. Returns the
 *    full precision result on 40-bit.
 *    L40_mult( var1, var2) = shiftleft(( var1 times var2), 1)
 *
 *  Complexity weight : 1
 *
 *  Inputs :
 *
 *    var1        16 bit short signed integer (Word16) whose value falls in 
 *                the range : MIN_16 <= var1 <= MAX_16.
 *
 *    var2        16 bit short signed integer (Word16) whose value falls in 
 *                the range : MIN_16 <= var2 <= MAX_16.
 *
 *  Outputs :
 *
 *    none
 *
 *  Return Value :
 *
 *    L40_var_out 40 bit long signed integer (Word40) whose value falls in
 *                the range : MIN_40 <= L40_var_out <= MAX_40.
 *
 *****************************************************************************/
__inline Word40 L40_mult( Word16 var1, Word16 var2) {
   Word32 L_var_out;
   Word40 L40_var_out;

   L_var_out = ( Word32) var1 * ( Word32) var2;
   L40_var_out = ( Word40) L_var_out;

   /* Below line can not overflow, so we can use << instead of L40_shl. */
   L40_var_out = L40_var_out << 1;

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

   return( L40_var_out);
}












/*****************************************************************************
 *
 *  Function Name : L40_mac
 *
 *  Purpose :
 *
 *    Multiplies var2 by var3. Shifts left the 40-bit result by 1 and adds
 *    the result to L40_var1. Returns a 40 bit result.
 *    L40_mac( L40_var1, var2, var3)
 *    = L40_add( L40_var1, L40_mult( var2, var3))
 *    Calls the macro L40_UNDERFLOW_OCCURED() in case of underflow on 40-bit.
 *    Calls the macro L40_OVERFLOW_OCCURED()  in case of overflow  on 40-bit.
 *
 *  Complexity weight : 1
 *
 *  Inputs :
 *
 *    L40_var1    40 bit long signed integer (Word40) whose value falls in the
 *                range : MIN_40 <= L40_var1 <= MAX_40.
 *
 *    var2        16 bit short signed integer (Word16) whose value falls in 
 *                the range : MIN_16 <= var2 <= MAX_16.
 *
 *    var3        16 bit short signed integer (Word16) whose value falls in 
 *                the range : MIN_16 <= var3 <= MAX_16.
 *
 *  Outputs :
 *
 *    none
 *
 *  Return Value :
 *
 *    L40_var_out 40 bit long signed integer (Word40) whose value falls in
 *                the range : MIN_40 <= L40_var_out <= MAX_40.
 *
 *****************************************************************************/
__inline Word40 L40_mac( Word40 L40_var1, Word16 var2, Word16 var3) {
   Word40 L40_var_out;

   L40_var_out = L40_mult( var2, var3);
   L40_var_out = L40_add( L40_var1, L40_var_out);

   #if (WMOPS)
   multiCounter[currCounter].L40_mult--;
   multiCounter[currCounter].L40_add--;
   multiCounter[currCounter].L40_mac++;
   #endif /* ifdef WMOPS */

   return( L40_var_out);
}   






/*****************************************************************************
 *
 *  Function Name : mac_r40
 *
 *  Purpose :
 *
 *    Multiplies var2 by var3. Shifts left the 40-bit result by 1 and adds
 *    the result to L40_var1. Rounds the lower 16 bits of the 40 bit result.
 *    Saturates the 40 bit result to 32-bit and returns the resulting higher
 *    16-bit.
 *    mac_r40( L40_var1, var2, var3)
 *    = round40( L40_mac( L40_var1, var2, var3))
 *    Calls the macro L40_UNDERFLOW_OCCURED() in case of underflow on 40-bit.
 *    Calls the macro L40_OVERFLOW_OCCURED()  in case of overflow  on 40-bit.
 *
 *  Complexity weight : 2
 *
 *  Inputs :
 *
 *    L40_var1    40 bit long signed integer (Word40) whose value falls in the
 *                range : MIN_40 <= L40_var1 <= MAX_40.
 *
 *    var2        16 bit short signed integer (Word16) whose value falls in 
 *                the range : MIN_16 <= var2 <= MAX_16.
 *
 *    var3        16 bit short signed integer (Word16) whose value falls in 
 *                the range : MIN_16 <= var3 <= MAX_16.
 *
 *  Outputs :
 *
 *    none
 *
 *  Return Value :
 *
 *    var_out     16 bit short signed integer (Word16) whose value falls in
 *                the range : MIN_16 <= var_out <= MAX_16.
 *
 *****************************************************************************/
__inline Word16 mac_r40( Word40 L40_var1, Word16 var2, Word16 var3) {
   Word40 L40_var_out;
   Word16 var_out;

   L40_var_out = L40_mac( L40_var1, var2, var3);
   var_out = round40( L40_var_out);

   #if (WMOPS)
   multiCounter[currCounter].L40_mac--;
   multiCounter[currCounter].round40--;
   multiCounter[currCounter].mac_r40++;
   #endif /* ifdef WMOPS */

   return( var_out);
}   






/*****************************************************************************
 *
 *  Function Name : L40_msu
 *
 *  Purpose :
 *
 *    Multiplies var2 by var3. Shifts left the 40-bit result by 1 and
 *    subtracts the result from L40_var1. Returns a 40 bit result.
 *    L40_msu( L40_var1, var2, var3)
 *    = L40_sub( L40_var1, L40_mult( var2, var3))
 *    Calls the macro L40_UNDERFLOW_OCCURED() in case of underflow on 40-bit.
 *    Calls the macro L40_OVERFLOW_OCCURED()  in case of overflow  on 40-bit.
 *
 *  Complexity weight : 1
 *
 *  Inputs :
 *
 *    L40_var1    40 bit long signed integer (Word40) whose value falls in the
 *                range : MIN_40 <= L40_var1 <= MAX_40.
 *
 *    var2        16 bit short signed integer (Word16) whose value falls in 
 *                the range : MIN_16 <= var2 <= MAX_16.
 *
 *    var3        16 bit short signed integer (Word16) whose value falls in 
 *                the range : MIN_16 <= var3 <= MAX_16.
 *
 *  Outputs :
 *
 *    none
 *
 *  Return Value :
 *
 *    L40_var_out 40 bit long signed integer (Word40) whose value falls in
 *                the range : MIN_40 <= L40_var_out <= MAX_40.
 *
 *****************************************************************************/
__inline Word40 L40_msu( Word40 L40_var1, Word16 var2, Word16 var3) {
   Word40 L40_var_out;

   L40_var_out = L40_mult( var2, var3);
   L40_var_out = L40_sub( L40_var1, L40_var_out);

   #if (WMOPS)
   multiCounter[currCounter].L40_mult--;
   multiCounter[currCounter].L40_sub--;
   multiCounter[currCounter].L40_msu++;
   #endif /* ifdef WMOPS */

   return( L40_var_out);
}   






/*****************************************************************************
 *
 *  Function Name : msu_r40
 *
 *  Purpose :
 *
 *    Multiplies var2 by var3. Shifts left the 40-bit result by 1 and
 *    subtracts the result from L40_var1. Rounds the lower 16 bits of the
 *    40 bit result. Saturates the 40 bit result to 32-bit and returns the
 *    resulting higher 16-bit.
 *    msu_r40( L40_var1, var2, var3)
 *    = round40( L40_msu( L40_var1, var2, var3))
 *    Calls the macro L40_UNDERFLOW_OCCURED() in case of underflow on 40-bit.
 *    Calls the macro L40_OVERFLOW_OCCURED()  in case of overflow  on 40-bit.
 *
 *  Complexity weight : 2
 *
 *  Inputs :
 *
 *    L40_var1    40 bit long signed integer (Word40) whose value falls in the
 *                range : MIN_40 <= L40_var1 <= MAX_40.
 *
 *    var2        16 bit short signed integer (Word16) whose value falls in 
 *                the range : MIN_16 <= var2 <= MAX_16.
 *
 *    var3        16 bit short signed integer (Word16) whose value falls in 
 *                the range : MIN_16 <= var3 <= MAX_16.
 *
 *  Outputs :
 *
 *    none
 *
 *  Return Value :
 *
 *    var_out     16 bit short signed integer (Word16) whose value falls in
 *                the range : MIN_16 <= var_out <= MAX_16.
 *
 *****************************************************************************/
__inline Word16 msu_r40( Word40 L40_var1, Word16 var2, Word16 var3) {
   Word40 L40_var_out;
   Word16 var_out;

   L40_var_out = L40_msu( L40_var1, var2, var3);
   var_out = round40( L40_var_out);

   #if (WMOPS)
   multiCounter[currCounter].L40_msu--;
   multiCounter[currCounter].round40--;
   multiCounter[currCounter].msu_r40++;
   #endif /* ifdef WMOPS */

   return( var_out);
}   










































#endif //_ENH40_H


/* end of file */