tetra_op.c

在ARM中对Ｔｅｔｒａ编码进行了thumb优化

  L_var_out = (L_var1 < 0L) ? MIN_32 : MAX_32;
         Overflow = 1;
        }
     }*/
     asm("qsub %0,%1,%2":"=r"(L_var_out):"r"(L_var1),"r"(L_var2):"cc");
   return(L_var_out);
  }

/************************************************************************
*
*	Function Name : mult
*
*	Purpose :
*
*		Performs the multiplication of var1 by var2 and gives a 16 bit result
*		which is scaled i.e.:
*			mult(var1,var2) = shr((var1 times var2),15) and
*			mult(-32768,-32768) = 32767.
*
*	Complexity Weight : 1
*
*	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
*
*	Returned Value :
*
*		var_out
*			16 bit short signed integer (Word16) whose value falls in the
*			range : 0xffff 8000 <= var_out <= 0x0000 7fff.
*
************************************************************************/

Word16 mult(Word16 var1, Word16 var2)
  {
   Word16 var_out;
   Word32 L_produit;

   //L_produit = (Word32)var1 * (Word32)var2;
   asm("smulbb %0,%1,%2":"=r"(L_produit):"r"(var1),"r"(var2):"cc");
   L_produit = (L_produit & (Word32) 0xffff8000) >> 15;

   if (L_produit & (Word32) 0x00010000)
     L_produit = L_produit | (Word32) 0xffff0000;

   var_out = sature(L_produit);
   return(var_out);
  }

/************************************************************************
*
*	Function Name : mult_r
*
*	Purpose :
*
*		Same as mult with rounding, i.e.:
*			mult_r(var1,var2) = shr(((var1*var2) + 16384),15) and
*			mult_r(-32768,-32768) = 32767.
*
*	Complexity Weight : 2
*
*	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
*
*	Returned Value :
*
*		var_out
*			16 bit short signed integer (Word16) whose value falls in the
*			range : 0xffff 8000 <= var_out <= 0x0000 7fff.
*
************************************************************************/

Word16 mult_r(Word16 var1, Word16 var2)
  {
   Word16 var_out;
   Word32 L_produit_arr;

   L_produit_arr = (Word32)var1 * (Word32)var2; /* product */
   L_produit_arr += (Word32) 0x00004000;        /* round */
   L_produit_arr &= (Word32) 0xffff8000;
   L_produit_arr >>= 15;                        /* shift */

   if (L_produit_arr & (Word32) 0x00010000)   /*sign extend when necessary*/
     {
      L_produit_arr |= (Word32) 0xffff0000;
     }

   var_out = sature(L_produit_arr);
   return(var_out);
  }

/************************************************************************
*
*	Function Name : negate
*
*	Purpose :
*
*		Negate var1 with saturation, saturate in the case where input is -32768:
*			negate(var1) = sub(0,var1).
*
*	Complexity Weight : 1
*
*	Inputs :
*
*		var1
*			16 bit short signed integer (Word16) whose value falls in the
*			range : 0xffff 8000 <= var1 <= 0x0000 7fff.
*
*	Outputs :
*
*		none
*
*	Returned Value :
*
*		var_out
*			16 bit short signed integer (Word16) whose value falls in the
*			range : 0xffff 8000 <= var_out <= 0x0000 7fff.
*
************************************************************************/

Word16 negate(Word16 var1)
  {
   Word16 var_out;

   var_out = (var1 == MIN_16) ? MAX_16 : -var1;
   return(var_out);
  }

/************************************************************************
*
*	Function Name : norm_l
*
*	Purpose :
*
*		Produces the number of left shift 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 :
*			norm_L_var1 = L_shl(L_var1,norm_l(L_var1)).
*
*	Complexity Weight : 30
*
*	Inputs :
*
*		L_var1
*			32 bit long signed integer (Word32) whose value falls in the
*			range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.
*
*	Outputs :
*
*		none
*
*	Returned Value :
*
*		var_out
*			16 bit short signed integer (Word16) whose value falls in the
*			range : 0x0000 0000 <= var_out <= 0x0000 001f.
*
************************************************************************/

Word16 norm_l(Word32 L_var1)
  {
   Word16 var_out;

   if (L_var1 == 0)
     {
      var_out = 0;
     }
   else
     {
      if (L_var1 == (Word32)0xffffffff)
 {
  var_out = 31;
 }
      else
 {
  if (L_var1 < 0)
    {
     L_var1 = ~L_var1;
    }

  for(var_out = 0;L_var1 < (Word32)0x40000000;var_out++)
    {
     L_var1 <<= 1;
    }
 }
     }

   return(var_out);
  }

/************************************************************************
*
*	Function Name : norm_s
*
*	Purpose :
*
*		Produces the number of left shift 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 = shl(var1,norm_s(var1)).
*
*	Complexity Weight : 15
*
*	Inputs :
*
*		var1
*			16 bit short signed integer (Word16) whose value falls in the
*			range : 0xffff 8000 <= var1 <= 0x0000 7fff.
*
*	Outputs :
*
*		none
*
*	Returned Value :
*
*		var_out
*			16 bit short signed integer (Word16) whose value falls in the
*			range : 0x0000 0000 <= var_out <= 0x0000 000f.
*
************************************************************************/

Word16 norm_s(Word16 var1)
  {
   Word16 var_out;

   if (var1 == 0)
     {
      var_out = 0;
     }
   else
     {
      if (var1 == (Word16) 0xffff)
 {
  var_out = 15;
 }
      else
 {
  if (var1 < 0)
    {
     var1 = ~var1;
    }

  for(var_out = 0; var1 < 0x4000; var_out++)
    {
     var1 <<= 1;
    }
 }
     }

   return(var_out);
  }

/************************************************************************
*
*	Function Name : round
*
*	Purpose :
*
*		Round the lower 16 bits of the 32 bit input number into its MS 16 bits
*		with saturation. Shift the resulting bits right by 16 and return the 16
*		bit number:
*			round(L_var1) = extract_h(L_add(L_var1,32768))
*
*	Complexity Weight : 1
*
*	Inputs :
*
*		L_var1
*			32 bit long signed integer (Word32 ) whose value falls in the
*			range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.
*
*	Outputs :
*
*		none
*
*	Returned Value :
*
*		var_out
*			16 bit short signed integer (Word16) whose value falls in the
*			range : 0xffff 8000 <= var_out <= 0x0000 7fff.
*
************************************************************************/

Word16 round(Word32 L_var1)
  {
   Word16 var_out;
   Word32 L_arrondi;

   L_arrondi = L_add(L_var1, (Word32)0x00008000);
   var_out = (Word16) ((L_arrondi)>>16);
   return(var_out);
  }

/************************************************************************
*
*	Function Name : sature
*
*	Purpose :
*
*		Limit the 32 bit input to the range of a 16 bit word.
*
*	Inputs :
*
*		L_var1
*			32 bit long signed integer (Word32) whose value falls in the
*			range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.
*
*	Outputs :
*
*		none
*
*	Returned Value :
*
*		var_out
*			16 bit short signed integer (Word16) whose value falls in the
*			range : 0xffff 8000 <= var_out <= 0x0000 7fff.
*
************************************************************************/

Word16 sature(Word32 L_var1)
  {
   Word16 var_out;

   if (L_var1 > 0X00007fffL)
     {
      Overflow = 1;
      var_out = MAX_16;
     }
   else if (L_var1 < (Word32)0xffff8000L)
     {
      Overflow = 1;
      var_out = MIN_16;
     }
   else
     {
      Overflow = 0;
      var_out = (Word16)(L_var1);
     }
   return(var_out);
  }


/************************************************************************
*
*	Function Name : shl
*
*	Purpose :
*
*		Arithmetically shift the 16 bit input var1 left var2 positions.Zero fill|
*		the var2 LSB of the result. If var2 is negative, arithmetically shift
*		var1 right by -var2 with sign extension. Saturate the result in case of
*		underflows or overflows.
*
*	Complexity Weight : 1
*
*	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
*
*	Returned Value :
*
*		var_out
*			16 bit short signed integer (Word16) whose value falls in the
*			range : 0xffff 8000 <= var_out <= 0x0000 7fff.
*
************************************************************************/

Word16 shl(Word16 var1,Word16 var2)
  {
   Word16 var_out;
   Word32 resultat;

   if (var2 < 0)
     {
      var_out = shr( var1,(Word16)(-var2) );
     }
   else
     {
      resultat = (Word32) var1 * ((Word32) 1 << var2);
     if ((var2 > 15 && var1 != 0) || (resultat != (Word32)((Word16) resultat)))
        {
         Overflow = 1;
         var_out = (var1 > 0) ? MAX_16 : MIN_16;
        }
      else
        {
         var_out = (Word16)(resultat);
        }
     }

   return(var_out);
  }

/************************************************************************
*
*	Function Name : shr
*
*	Purpose :
*
*		Arithmetically shift the 16 bit input var1 right var2 positions with
*		sign extension. If var2 is negative, arithmetically shift var1 left by
*		-var2 with sign extension. Saturate the result in case of underflows or
*		overflows.
*
*	Complexity Weight : 1
*
*	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
*
*	Returned Value :
*
*		var_out
*			16 bit short signed integer (Word16) whose value falls in the
*			range : 0xffff 8000 <= var_out <= 0x0000 7fff.
*
************************************************************************/

Word16 shr(Word16 var1,Word16 var2)
  {
   Word16 var_out;

   if (var2 < 0)
     {
      var_out = shl( var1,(Word16)(-var2) );
     }
   else
     {
      if (var2 >= 15)
        {
         var_out = (var1 < 0) ? -1 : 0;
        }
      else
        {
         if (var1 < 0)
           {
     var_out = ~(( ~var1) >> var2 );
           }
         else
           {
            var_out = var1 >> var2;
           }
        }
     }

   return(var_out);
  }

/************************************************************************
*
*	Function Name : sub
*
*	Purpose :
*
*			Performs the subtraction (var1+var2) with overflow control and satu-
*			ration; the 16 bit result is set at +32767 when overflow occurs or at
*			-32768 when underflow occurs.
*
*	Complexity Weight : 1
*
*	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
*
*	Returned Value :
*
*		var_out
*			16 bit short signed integer (Word16) whose value falls in the
*			range : 0xffff 8000 <= var_out <= 0x0000 7fff.
*
************************************************************************/

Word16 sub(Word16 var1,Word16 var2)
  {
   Word16 var_out;
   Word32 L_diff;

   L_diff = (Word32) var1 - var2;
   var_out = sature(L_diff);
   return(var_out);
  }