// Copyright (c) 2000-2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of "Eclipse Public License v1.0"

 // which accompanies this distribution, and is available

 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 //

 #include "basicop.h"

 /*

 ** int2 add( int2 var1, int2 var2 )

 **

 ** Function performs the addition (var1+var2) with overflow control

 ** and saturation; the result is set at +32767 when overflow occurs

 ** or at -32768 when underflow occurs

 **

 ** Input:

 **   var1, var2

 **     16-bit variables to be summed

 **

 ** Output:

 **   Sum of var and var2, see description above

 **  

 ** Return value:

 **   See above

 */

 /*

 ** One way to implement saturation control to add and sub is to

 ** use temporary result that has enough bits to make overflow

 ** impossible and the limit the final result

 */

 int2 add( int2 var1, int2 var2 )

 {

   int4 L_temp;

   L_temp = (int4) var1 + var2;

   if ( L_temp < MININT2 )

     return MININT2;

   else if ( L_temp > MAXINT2 )

     return MAXINT2;

   else

     return (int2) L_temp;

 }

 /*

 ** int2 sub( int2 var1, int2 var2 )

 **

 ** Function performs the subtraction (var1-var2) with overflow control

 ** and saturation; the result is set at +32767 when overflow occurs

 ** or at -32768 when underflow occurs

 **

 ** Input:

 **   var1, var2

 **     16-bit variables to be summed

 **

 ** Output:

 **   Sum of var and var2, see description above

 **  

 ** Return value:

 **   See above

 */

 int2 sub( int2 var1, int2 var2 )

 {

   int4 L_temp;

   L_temp = (int4) var1 - var2;

   if ( L_temp < MININT2 )

     return MININT2;

   else if ( L_temp > MAXINT2 )

     return MAXINT2;

   else

     return (int2) L_temp;

 }

 /*

 ** int2 mult( int2 var1, int2 var2 )

 **

 ** Function performs the multiplication of var1 by var2 and gives a

 ** 16-bit result which is scaled ie

 **   mult( var1, var2 ) = (var1 times var2) >> 15

 ** and

 **   mult( -32768, -32768 ) = 32767 

 **

 ** Input:

 **   var1, var2

 **     16-bit variables to be multiplied

 **

 ** Output:

 **   Scaled result of multiplication

 **  

 ** Return value:

 **   See above

 */

 int2 mult( int2 var1, int2 var2 )

 {

   if ( ( var1 == MININT2 ) && ( var1 == var2 ) )

     return MAXINT2;

   else

     /* Note int4 cast of var1 to force 32-bit arithmetic */

    return( (int2) ( ( (int4) var1 * var2 ) >> 15 ) );

 }

 /*

 ** int2 abs_s( int2 var1 )

 **

 ** Function returns absolute value of var1 with possible saturation:

 **   abs( -32768 ) = 32767

 **

 ** Input:

 **   var1

 **     16-bit variable

 **

 ** Output:

 **   absolute value of var1

 **  

 ** Return value:

 **   See above

 */

 int2 abs_s( int2 var1 )

 {

   if ( var1 == MININT2 )

     return MAXINT2;

   else

     return ( var1 > 0 ) ? var1 : int2 (-var1);

 }

 #ifdef L_MULTF

 /* else implemented using macro (basicop.h) */

 /*

 ** int4 L_mult( int2 var1, int2 var2 )

 **

 ** Function performs the multiplication of var1 by var2 and gives a

 ** 32-bit result which is scaled by shifting result one bit left ie

 **   L_mult( var1, var2 ) = (var1 times var2) << 1

 **

 **   L_mult( -32768, -32768 ) does not occur in algorithm

 **

 ** Input:

 **   var1, var2

 **     16-bit variables to be multiplied

 **

 ** Output:

 **   Scaled result of multiplication

 **  

 ** Return value:

 **   See above

 */

 int4 L_mult( int2 var1, int2 var2 )

 {

   /* Note int4 cast of var1 to force 32-bit arithmetic */

   return ( L_shl( (int4) var1 * var2 ), 1 );

 }

 #endif /* L_MULTF */

 /*

 ** int2 shr( int2 var1, int2 var2 )

 **

 ** Function makes arithmetic var2-bit shift right of var1. If var2 is

 ** less than 0, this operation becomes arithmetic left shift of -var2

 **

 ** Input:

 **   var1

 **     16-bit variable to be shifted

 **   var2

 **     amount of bits to be shifted

 **

 ** Output:

 **   16-bit value of shifted var1 is returned 

 **  

 ** Return value:

 **   See above

 */

 int2 shr( int2 var1, int2 var2 )

 {

   return shl( var1, int2 (-var2) );

 }

 /*

 ** int2 negate( int2 var1 )

 **

 ** Function negates 16-bit variable var1. 

 **   negate( -32768 ) = 32767

 **

 ** Input:

 **   var1

 **     16-bit variable to be negated

 **

 ** Output:

 **   negated var1

 **  

 ** Return value:

 **   See above

 */

 int2 negate( int2 var1 )

 {

   if ( var1 == MININT2 )

     return MAXINT2;

   else

     return int2 (-var1);

 }

 /*

 ** int2 extract_h( int4 L_var1 )

 **

 ** Function returns upper word (16 most significat bits) of the 

 ** 32-bit variable L_var1

 **

 ** Input:

 **   L_var1

 **     32-bit variable

 **

 ** Output:

 **   upper word of the L_var1

 **  

 ** Return value:

 **   See above

 */

 int2 extract_h( int4 L_var1 )

 {

   return (int2) ( L_var1 >> 16 );

 }

 /*

 ** int2 extract_l( int4 L_var1 )

 **

 ** Function returns lower word (16 least significat bits) of the

 ** 32-bit variable L_var1

 **

 ** Input:

 **   L_var1

 **     32-bit variable

 **

 ** Output:

 **   lower word of L_var1

 **  

 ** Return value:

 **   See above

 */

 int2 extract_l( int4 L_var1 )

 {

   return (int2) (L_var1 & 0x0000ffff);

 }

 /*

 ** int4 L_mac( int4 L_var3, int2 var1, int2 var2 )

 **

 ** Function multiplies var1 by var2 and shifts result left by one bit.

 ** Shifted result of multiplication is then added to L_var3 and result

 ** is returned. Summation is done with overflow control and saturation;

 ** the result is set at 2147483647 when overflow occurs and at

 ** -2147483648 when underflow occurs

 **

 ** Input:

 **   var1

 **     16-bit multiplicant

 **   var2

 **     16-bit multiplier

 **

 **   L_var3

 **     32-bit number that is summed with (var1*var2)<<1

 **

 ** Output:

 **   See description above

 **  

 ** Return value:

 **   See above

 */

 int4 L_mac( int4 L_var3, int2 var1, int2 var2 )

 {

   int4 L_temp;

   L_temp = ( (int4) var1 * var2 ) << 1;

   return L_add( L_var3, L_temp );

 }

 /*

 ** int4 L_add( int4 L_var1, int4 L_var2 )

 **

 ** Function performs 32-bit addition of two 32-bit variables

 ** (L_var1 + L_var2) with overflow control and saturation; the

 ** result is set at 2147483647 when overflow occurs and at

 ** -2147483648 when underflow occurs

 **

 ** Input:

 **   L_var1, L_var2

 **     32-bit variables to be summed

 **

 ** Output:

 **   32-bit result, see description above

 **  

 ** Return value:

 **   See above

 */

 int4 L_add( int4 L_var1, int4 L_var2 )

 {

   int4 L_temp1;

   int temp2; /* used for storing sign of L_var1 */

   L_temp1 = L_var1 + L_var2;

   /*

    * Overflow

    *   if sign(L_var1)==sign(L_var2) && sign(L_var1)!=sign(L_temp1).

    */

   if ( ( temp2 = (L_var1 < 0) ) == ( L_var2 < 0 ) 

     && ( temp2 != ( L_temp1 < 0 ) ) ) {

       L_temp1 = temp2 ? MININT4 : MAXINT4;

   }

   return L_temp1;

 }

 /*

 ** int4 L_sub( int4 L_var1, int4 L_var2 )

 **

 ** Function performs 32-bit subtraction of two 32-bit variables

 ** (L_var1 - L_var2) with overflow control and saturation; the

 ** result is set at 2147483647 when overflow occurs and at

 ** -2147483648 when underflow occurs

 **

 ** Input:

 **   L_var1, L_var2

 **     32-bit variables to be summed

 **

 ** Output:

 **   32-bit result, see description above

 **  

 ** Return value:

 **   See above

 */

 int4 L_sub( int4 L_var1, int4 L_var2 )

 {

   int4 L_temp1;

   int temp2;

   L_temp1 = L_var1 - L_var2;

   /*

    * Overflow

    *   if sign(L_var1)!=sign(L_var2) && sign(L_var1)!=sign(L_temp).

    */

   if ( ( temp2 = ( L_var1 < 0 ) ) != ( L_var2 < 0 ) 

     && ( temp2 != ( L_temp1 < 0 ) ) ) {

       L_temp1 = temp2 ? MININT4 : MAXINT4;

   }

   return L_temp1;

 }

 /*

 ** int2 mult_r( int2 var1, int2 var2 )

 **

 ** Function performs the multiplication of var1 by var2 and gives a

 ** 16-bit result which is scaled with rounding ie

 **   mult_r(var1, var2) = ((var1 times var2) + 16384) >> 15

 ** and

 **   mult_r( -32768, -32768 ) = 32767 

 **

 ** Input:

 **   var1, var2

 **     16-bit variables to be multiplied

 **

 ** Output:

 **   16-bit scaled result of multiplication

 **  

 ** Return value:

 **   See above

 */

 int2 mult_r( int2 var1, int2 var2 )

 {

   if ( ( var1 == MININT2 ) && ( var1 == var2 ) )

     return MAXINT2;

   else

     /* Note int4 cast of var1 to force 32-bit arithmetic */

     return( (int2) ( ( (int4) var1 * var2 + (int4) 16384 ) >> 15 ) );

 }

 /*

 ** int4 L_shr( int4 L_var1, int2 var2 )

 **

 ** Function makes arithmetic var2-bit shift right of var1. If var2 is

 ** less than 0, this operation becomes arithmetic left shift of -var2

 **

 ** Input:

 **   L_var1

 **     32-bit variable to be shifted

 **   var2

 **     amount of bits to be shifted

 **

 ** Output:

 **   16-bit value of shifted var1

 **  

 ** Return value:

 **   See above

 */

 int4 L_shr( int4 L_var1, int2 var2 )

 {

   return L_shl( L_var1, int2 (-var2) );

 }

 /*

 ** int4 L_deposit_h( int2 var1 )

 **

 ** Function deposits the 16-bit variable var1 into the 16 most

 ** significant bits of the 32-bit word. The 16 least significant

 ** bits of the result are zeroed.

 **

 ** Input:

 **   var1

 **     16-bit variable to be loaded to the upper 16 bits of

 **     of the 32-bit variable

 **

 ** Output:

 **   32-bit number, see description above

 **  

 ** Return value:

 **   See above

 */

 int4 L_deposit_h( int2 var1 )

 {

   return ( (int4) var1 ) << 16;

 }

 /*

 ** int4 L_deposit_l( int2 var1 )

 **

 ** Function deposits the 16-bit variable var1 into the 16 least

 ** significant bits of the 32-bit word. The 16 most significant bits

 ** of the result are sign extended.

 **

 ** Input:

 **   var1

 **     16-bit variable to be converted to 32-bit variable

 **

 ** Output:

 **   32-bit variable that has same magnitude than var1

 **  

 ** Return value:

 **   See above

 */

 int4 L_deposit_l( int2 var1 )

 {

   return (int4) var1;

 }

 /*

 ** int2 norm_s( int2 var1 )

 **

 ** Function produces number of left shifts needed to normalize the

 ** 16-bit variable var1 for positive values on the interval with

 ** minimum of 16384 and maximum of 32767 and for negative

 ** values on the interval with minimum of -32768 and maximum of

 ** -16384; in order to normalize the result, the following

 ** operation must be done:

 **   norm_var1 = var1 << norm_s(var1)

 **

 ** Input:

 **   var1

 **     16-bit variable which normalization factor is solved

 **

 ** Output:

 **   see description above

 **  

 ** Return value:

 **   See above

 */

 int2 norm_s( int2 var1 )

 {

   int2 cntr = 0;

   /* Special case when L_var1 == -32768: shift leads to underflow */

   if ( var1 == MININT2 )

     return 0;

   /* Special case when var1 == 0: shift does not change the value */

   else if ( var1 == 0 )

     return 0;

   else {

     if ( var1 < 0 ) {

       for ( ; var1 >= -16384; var1 *= 2 )

 	cntr++;      

     }

     else {

       for ( ; var1 < 16384; var1 <<= 1 )

 	cntr++;

     }

     return cntr;

   }

 }

 /*

 ** int2 norm_l( int4 L_var1 )

 **

 ** Function produces number of left shifts needed to normalize the

 ** 32-bit variable L_var1 for positive values on the interval with

 ** minimum of 1073741824 and maximum of 2147483647 and for negative

 ** values on the interval with minimum of -2147483648 and maximum of

 ** -1073741824; in order to normalize the result, the following

 ** operation must be done:

 **   L_norm_var1 = L_var1 << norm_l(L_var1)

 **

 ** Input:

 **   L_var1

 **     32-bit variable which normalization factor is solved

 **

 ** Output:

 **   see description above

 **  

 ** Return value:

 **   See above

 */

 int2 norm_l( int4 L_var1 )

 {

   int2 cntr = 0;

   /* Special case when L_var1 == -2147483648: shift leads to underflow */

   if ( L_var1 == MININT4 )

     return 0;

   /* Special case when L_var1 == 0: shift does not change the value */

   else if ( L_var1 == 0 )

     return 0;

   else {

     if ( L_var1 < 0 ) {

       for ( ; L_var1 >= (int4) -1073741824L; L_var1 *= 2 )

 	cntr++;

     }

     else {

       for ( ; L_var1 < (int4) 1073741824L; L_var1 <<= 1 )

 	cntr++;

     }

     return cntr;

   }

 }

 /*

 ** int2 div_s( int2 num, int2 denum )

 **

 ** Function produces a result which is the fractional integer division

 ** of var1 by var2; var1 and var2 must be positive and var2 must be

 ** greater or equal to var1; The result is positive (leading bit equal

 ** to 0) and truncated to 16 bits. If var1 == var2 then

 **   div_s( var1, var2 ) = 32767

 **

 ** Input:

 **   L_var1

 **     32-bit variable which normalization factor is solved

 **

 ** Output:

 **   16-bit result, see description above

 **  

 ** Return value:

 **   See above

 */

 int2 div_s( int2 num, int2 denum )

 {

   if ( num == denum )

     return MAXINT2;

   else

     return (int2) ( ( ( (int4) num ) << 15 ) / denum );

 }

 /*

 ** int2 shl( int2 var1, int2 var2 )

 **

 ** Function makes arithmetic var2-bit shift left of var1. If var2 is

 ** less than 0, this operation becomes arithmetic right shift of -var2

 **

 ** Input:

 **   var1

 **     16-bit variable to be shifted

 **   var2

 **     amount of bits to be shifted

 **

 ** Output:

 **   16-bit value of shifted var1 is retuned 

 **  

 ** Return value:

 **   See above

 **

 ** Notes:

 **   ANSI C does not guarantee that right shift is arithmetical

 **   (that sign extension is done during shifting). That is why in this

 **   routine negative values are complemented before shifting.

 */

 int2 shl( int2 var1, int2 var2 )

 {

   int2 result;

   if ( ( var1 == 0 ) || ( var2 == 0 ) ) {

     result = var1;

   }

   /* var2 > 0: Perform left shift */

   else if ( var2 > 0 ) {

     if ( var2 >= 15 ) {

       result = ( var1 < 0 ) ? int2(MININT2) : int2(MAXINT2);

     }

     else {

       int4 L_temp;

       L_temp = (int4) var1 << var2;

       if ( L_temp < MININT2 ) {

 	result = MININT2;

       }

       else if ( L_temp > MAXINT2 ) {

 	result = MAXINT2;

       }

       else {

 	result = (int2) L_temp;

       }

     }

   }

   /* var2 < 0: Perform right shift */

   else {

     if ( -var2 >= 15 ) {

       result = ( var1 < 0 ) ? int2 (-1) : int2 (0);

     }

     else if ( var1 < 0 ) {

       result = int2 (~( (~var1) >> -var2 )); /* ~ used to ensure arith. shift */

     }

     else {

       result = int2 (var1 >> -var2);

     }

   }

   return result;

 }

 /*

 ** int4 L_shl( int4 L_var1, int2 var2 )

 **

 ** Function makes arithmetic var2-bit shift left of var1. If var2 is

 ** less than 0, this operation becomes arithmetic right shift of -var2

 **

 ** Input:

 **   L_var1

 **     32-bit variable to be shifted

 **   var2

 **     amount of bits to be shifted

 **

 ** Output:

 **   32-bit value of shifted var1 is retuned 

 **  

 ** Return value:

 **   See above

 **

 ** Notes:

 **   ANSI C does not guarantee that right shift is arithmetical

 **   (that sign extension is done during shifting). That is why in this

 **   routine negative values are complemented before shifting.

 */

 int4 L_shl(int4 L_var1, int2 var2 )

 {

   if ( ( L_var1 == 0L ) || ( var2 == 0 ) ) {

     return L_var1;

   }

   /* var2 > 0: Perform left shift */

   else if ( var2 > 0 ) {

     if ( var2 >= 31 ) {

       return ( L_var1 < 0 ) ? MININT4 : MAXINT4;

     }

     else {

       for( ; var2 > 0; var2-- ) {

 	if ( L_var1 > (MAXINT4 >> 1) )

 	  return MAXINT4;

 	else if ( L_var1 < (MININT4 / 2) )

 	  return MININT4;

 	else

 	  L_var1 *= 2;

       }

       return L_var1;

     }

   }

   /* var2 < 0: Perform right shift */

   else {

     if ( -var2 >= 31 ) {

       return ( L_var1 < 0 ) ? -1L : 0L;

     }

     else if ( L_var1 < 0 ) {

       return ~( (~L_var1) >> -var2 ); /* ~ used to ensure arith. shift */

     }

     else {

       return L_var1 >> -var2;

     }

   }

 }