tetra_op.c

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

*
************************************************************************/

Word32 L_mac(Word32 L_var3, Word16 var1, Word16 var2)
  {
   Word32 L_var_out;
   Word32 L_produit;

   /*L_produit = L_mult(var1,var2);
   L_var_out = L_add(L_var3,L_produit);*/
   asm("smulbb %0,%1,%2":"=r"(L_produit):"r"(var1),"r"(var2):"cc");
   asm("qdadd %0,%1,%2":"=r"(L_var_out):"r"(L_var3),"r"(L_produit):"cc");
   return(L_var_out);
  }

/************************************************************************
*
*	Function Name : L_mac0
*
*	Purpose :
*
*		Multiply var1 by var2. Add the 32 bit result to L_var3.
*		Control saturation and set overflow_flag.
*		Same as L_mac without left shift.
*
*	Complexity Weight : 1
*
*	Inputs :
*
*		L_var3
*			32 bit long signed integer (Word32) whose value falls in the
*			range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.
*
*		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 :
*
*		L_var_out
*			32 bit long signed integer (Word32) whose value falls in the
*			range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.
*
************************************************************************/

Word32 L_mac0(Word32 L_var3, Word16 var1, Word16 var2)
  {
   Word32 L_var_out;
   Word32 L_produit;

   //L_produit = L_mult0(var1,var2);
   //L_var_out = L_add(L_var3,L_produit);
   asm("smulbb %0,%1,%2":"=r"(L_produit):"r"(var1),"r"(var2):"cc");
   asm("qadd %0,%1,%2":"=r"( L_var_out):"r"(L_produit),"r"(L_var3):"cc");
   return(L_var_out);
  }

/************************************************************************
*
*	Function Name : L_msu
*
*	Purpose :
*
*		Multiply var1 by var2 and shift the result left by 1. Subtract the 32
*		bit result to L_var3 with saturation, return a 32 bit result:
*			L_msu(L_var3,var1,var2) = L_sub(L_var3,(L_mult(var1,var2)).
*
*	Complexity Weight : 1
*
*	Inputs :
*
*		L_var3
*			32 bit long signed integer (Word32) whose value falls in the
*			range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.
*
*		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 :
*
*		L_var_out
*			32 bit long signed integer (Word32) whose value falls in the
*			range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.
*
************************************************************************/

Word32 L_msu(Word32 L_var3, Word16 var1, Word16 var2)
  {
   Word32 L_var_out;
   Word32 L_produit;

  /* L_produit = L_mult(var1,var2);
   L_var_out = L_sub(L_var3,L_produit);*/
   asm("smulbb %0,%1,%2":"=r"(L_produit):"r"(var1),"r"(var2):"cc");
   asm("qdsub %0,%1,%2":"=r"(L_var_out):"r"(L_var3),"r"(L_produit):"cc");
   return(L_var_out);
  }

/************************************************************************
*
*	Function Name : L_msu0
*
*	Purpose :
*
*		Multiply var1 by var2. Subtract the 32 bit result to L_var3.
*		Control saturation and set overflow_flag.
*		Same as L_msu without left shift.
*
*	Complexity Weight : 1
*
*	Inputs :
*
*		L_var3
*			32 bit long signed integer (Word32) whose value falls in the
*			range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.
*
*		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 :
*
*		L_var_out
*			32 bit long signed integer (Word32) whose value falls in the
*			range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.
*
************************************************************************/

Word32 L_msu0(Word32 L_var3, Word16 var1, Word16 var2)
  {
   Word32 L_var_out;
   Word32 L_produit;

   //L_produit = L_mult0(var1,var2);
   //L_var_out = L_sub(L_var3,L_produit);
   asm("smulbb %0,%1,%2":"=r"(L_produit):"r"(var1),"r"(var2):"cc");
   asm("qsub %0,%1,%2":"=r"(L_var_out):"r"(L_var3),"r"(L_produit):"cc");
   return(L_var_out);
  }


/************************************************************************
*
*	Function Name : L_mult
*
*	Purpose :
*
*		L_mult is the 32 bit result of the multiplication of var1 times var2
*		with one shift left i.e.:
*			L_mult(var1,var2) = shl((var1 times var2),1) and
*			L_mult(-32768,-32768) = 2147483647.
*
*	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 :
*
*		L_var_out
*			32 bit long signed integer (Word32) whose value falls in the
*			range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.
*
************************************************************************/

Word32 L_mult(Word16 var1,Word16 var2)
  {
   Word32 L_var_out,prod;

   /*L_var_out = (Word32)var1 * (Word32)var2;
   if (L_var_out != (Word32)0x40000000)
     {
      L_var_out *= 2;
     }
   else
     {
      Overflow = 1;
      L_var_out = MAX_32;
     }*/
     asm("smulbb %0,%1,%2":"=r"(prod):"r"(var1),"r"(var2):"cc");
     asm("qadd %0,%1,%2":"=r"(L_var_out):"r"(prod),"r"(prod):"cc");

   return(L_var_out);
  }

/************************************************************************
*
*	Function Name : L_mult0
*
*	Purpose :
*
*		L_mult is the 32 bit result of the multiplication of var1 times var2.
*		Same as L_mult without left shift.
*
*	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 :
*
*		L_var_out
*			32 bit long signed integer (Word32) whose value falls in the
*			range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.
*
************************************************************************/

Word32 L_mult0(Word16 var1, Word16 var2)
{
  Word32 L_var_out;

  //L_var_out = (Word32)var1 * (Word32)var2;
  asm("smulbb %0,%1,%2":"=r"(L_var_out):"r"(var1),"r"(var2):"cc");

  return(L_var_out);
}


/************************************************************************
*
*	Function Name : L_negate
*
*	Purpose :
*
*		Negate the 32 bit variable L_var1 with saturation; saturate in the case
*		where input is -2147483648 (0x8000 0000).
*
*	Complexity Weight : 2
*
*	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 :
*
*		L_var_out
*			32 bit long signed integer (Word32) whose value falls in the
*			range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.
*
************************************************************************/

Word32 L_negate(Word32 L_var1)
  {
   Word32 L_var_out;

   L_var_out = (L_var1 == MIN_32) ? MAX_32 : -L_var1;
   return(L_var_out);
  }

/************************************************************************
*
*	Function Name : L_shl
*
*	Purpose :
*
*		Arithmetically shift the 32 bit input L_var1 left var2 positions. Zero fill the var2 LSB *		of the result. If var2 is negative, L_var1 right by -var2 arithmetically shift with sign 
*		extension. Saturate the result in case of underflows or overflows.
*
*	Complexity Weight : 2
*
*	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
*
*	Returned 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_shl(Word32 L_var1, Word16 var2)
  {
   Word32 L_var_out;
if (var2 <= 0)
     {
      L_var_out = L_shr( L_var1, (Word16)(-var2) );
     }
   else
     {
      for(;var2>0;var2--)
        {
         if (L_var1 > (Word32) 0X3fffffff)
           {
            Overflow = 1;
            L_var_out = MAX_32;
            break;
           }
         else
           {
            if (L_var1 < (Word32) 0xc0000000)
              {
               Overflow = 1;
               L_var_out = MIN_32;
               break;
              }
           }
         L_var1 *= 2;
         L_var_out = L_var1;
        }
        /*asm("mov %0,%1,lsl %2":"=r"(L_var_out):"r"(L_var1),"r"(var2):"cc");
        asm("teq %0,%1,lsl %2"::"r"(L_var1),"r"(L_var_out),"r"(var2):"cc");
        asm("eorne %0,%1,%2,asr #31":"=r"(L_var_out):"r"(0x7fffffff),"r"(L_var1):"cc");*/
     }
   return(L_var_out);
  }

/************************************************************************
*
*	Function Name : L_shr
*
*	Purpose :
*
*		Arithmetically shift the 32 bit input L_var1 right var2 positions with
*		sign extension. If var2 is negative, arithmetically shift L_var1 left
*		by -var2 and zero fill the var2 LSB of the result. Saturate the result
*		in case of underflows or overflows.
*
*	Complexity Weight : 2
*
*	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
*
*	Returned 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_shr(Word32 L_var1, Word16 var2)
  {
   Word32 L_var_out;

   if (var2 < 0)
     {
      L_var_out = L_shl( L_var1,(Word16)(-var2) );
     }
   else
     {
      if (var2 >= 31)
 {
  L_var_out = (L_var1 < 0L) ? -1 : 0;
 }
      else
 {
  if (L_var1<0)
    {
     L_var_out = ~((~L_var1) >> var2);
    }
  else
    {
     L_var_out = L_var1 >> var2;
    }
 }
     }
   return(L_var_out);
  }

/************************************************************************
*
*	Function Name : L_shr_r
*
*	Purpose :
*
*		Same as L_shr(L_var1,var2)but with rounding. Saturate the result in case|
*		of underflows or overflows :
*		If var2 is greater than zero :
*			L_shr_r(var1,var2) = L_shr(L_add(L_var1,2**(var2-1)),var2)
*		If var2 is less than zero :
*			L_shr_r(var1,var2) = L_shr(L_var1,var2).
*
*	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
*
*	Returned 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_shr_r(Word32 L_var1,Word16 var2)
  {
   Word32 L_var_out;

   if (var2 > 31)
     {
      L_var_out = 0;
     }
   else
     {
      L_var_out = L_shr(L_var1,var2);
      if (var2 > 0)
 {
  if ( (L_var1 & ( (Word32)1 << (var2-1) )) != 0)
    {
     L_var_out++;
    }
 }
     }
   return(L_var_out);
  }

/************************************************************************
*
*	Function Name : L_sub
*
*	Purpose :
*
*		32 bits subtraction of the two 32 bits variables (L_var1-L_var2) with
*		overflow control and saturation; the result is set at [phone] when
*		overflow occurs or at -214783648 when underflow occurs.
*
*	Complexity Weight : 2
*
*	Inputs :
*
*		L_var1
*			32 bit long signed integer (Word32) whose value falls in the
*			range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.
*
*		L_var2
*			32 bit long signed integer (Word32) whose value falls in the
*			range : 0x8000 0000 <= L_var2 <= 0x7fff ffff.
*
*	Outputs :
*
*		none
*
*	Returned 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_sub(Word32 L_var1, Word32 L_var2)
  {
   Word32 L_var_out;

   /*L_var_out = L_var1 - L_var2;

   if (((L_var1 ^ L_var2) & MIN_32) != 0)
     {
      if ((L_var_out ^ L_var1) & MIN_32)
        {