pvamrwbdecoder_basic_op_cequivalent.h

实现3GPP的GSM中AMR语音的CODECS。

            if ((L_var_out ^ L_var1) & MIN_32)  /* difference matches sign ? */
            {
                L_var_out = (L_var1 >> 31) ^ MAX_32;
            }
        }
        return (L_var_out);
    }



    /*----------------------------------------------------------------------------

         Function Name : mac_16by16_to_int32

         Multiply var1 by var2 and shift the result left by 1. Add the 32 bit
         result to L_var3 with saturation, return a 32 bit result:
              L_mac(L_var3,var1,var2) = L_add(L_var3,L_mult(var1,var2)).

         Inputs :

          L_var3   32 bit long signed integer (int32) whose value falls in the
                   range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.

          var1
                   16 bit short signed integer (int16) whose value falls in the
                   range : 0xffff 8000 <= var1 <= 0x0000 7fff.

          var2
                   16 bit short signed integer (int16) whose value falls in the
                   range : 0xffff 8000 <= var1 <= 0x0000 7fff.


         Return Value :
                   32 bit long signed integer (int32) whose value falls in the
                   range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.

     ----------------------------------------------------------------------------*/


    __inline  int32 mac_16by16_to_int32(int32 L_var3, int16 var1, int16 var2)
    {
        int32 L_var_out;
        int32 L_mul;

        L_mul  = ((int32) var1 * (int32) var2);

        if (L_mul != 0x40000000)
        {
            L_mul <<= 1;
        }
        else
        {
            L_mul = MAX_32;		/* saturation */
        }

        L_var_out = L_var3 + L_mul;

        if (((L_mul ^ L_var3) & MIN_32) == 0)  /* same sign ? */
        {
            if ((L_var_out ^ L_var3) & MIN_32)  /* addition matches sign ? */
            {
                L_var_out = (L_var3 >> 31) ^ MAX_32;
            }
        }

        return (L_var_out);
    }



    /*----------------------------------------------------------------------------

         Function Name : msu_16by16_from_int32

         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)).

         Inputs :

          L_var3   32 bit long signed integer (int32) whose value falls in the
                   range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.

          var1
                   16 bit short signed integer (int16) whose value falls in the
                   range : 0xffff 8000 <= var1 <= 0x0000 7fff.

          var2
                   16 bit short signed integer (int16) whose value falls in the
                   range : 0xffff 8000 <= var1 <= 0x0000 7fff.


         Return Value :
                   32 bit long signed integer (int32) whose value falls in the
                   range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.

     ----------------------------------------------------------------------------*/

    __inline  int32 msu_16by16_from_int32(int32 L_var3, int16 var1, int16 var2)
    {
        int32 L_var_out;
        int32 L_mul;

        L_mul  = ((int32) var1 * (int32) var2);

        if (L_mul != 0x40000000)
        {
            L_mul <<= 1;
        }
        else
        {
            L_mul = MAX_32;		/* saturation */
        }

        L_var_out = L_var3 - L_mul;

        if (((L_mul ^ L_var3) & MIN_32) != 0)  /* different sign ? */
        {
            if ((L_var_out ^ L_var3) & MIN_32)  /* difference matches sign ? */
            {
                L_var_out = (L_var3 >> 31) ^ MAX_32;
            }
        }

        return (L_var_out);
    }


    /*----------------------------------------------------------------------------

         Function Name : mul_16by16_to_int32

         mul_16by16_to_int32 is the 32 bit result of the multiplication of var1
         times var2 with one shift left i.e.:
              L_mult(var1,var2) = L_shl((var1 times var2),1) and
              L_mult(-32768,-32768) = 2147483647.

         Inputs :
          var1
                   16 bit short signed integer (int16) whose value falls in the
                   range : 0xffff 8000 <= var1 <= 0x0000 7fff.

          var2
                   16 bit short signed integer (int16) whose value falls in the
                   range : 0xffff 8000 <= var1 <= 0x0000 7fff.

         Return Value :
                   32 bit long signed integer (int32) whose value falls in the
                   range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.

     ----------------------------------------------------------------------------*/


    __inline  int32 mul_16by16_to_int32(int16 var1, int16 var2)
    {
        int32 L_mul;

        L_mul  = ((int32) var1 * (int32) var2);

        if (L_mul != 0x40000000)
        {
            L_mul <<= 1;
        }
        else
        {
            L_mul = MAX_32;		/* saturation */
        }

        return (L_mul);

    }

    /*----------------------------------------------------------------------------

         Function Name : amr_wb_round

         Round the lower 16 bits of the 32 bit input number into the 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))

         Inputs :
          L_var1
                   32 bit long signed integer (int32 ) whose value falls in the
                   range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.

         Return Value :
                   16 bit short signed integer (int16) whose value falls in the
                   range : 0xffff 8000 <= var_out <= 0x0000 7fff.

     ----------------------------------------------------------------------------*/
    __inline int16 amr_wb_round(int32 L_var1)
    {
        if (L_var1 != MAX_32)
        {
            L_var1 +=  0x00008000L;
        }
        return ((int16)(L_var1 >> 16));
    }

    /*----------------------------------------------------------------------------
         Function Name : mul_32by16

         Multiply a 16 bit integer by a 32 bit (DPF). The result is divided
         by 2^15

                L_32 = (hi1*lo2)<<1 + ((lo1*lo2)>>15)<<1

         Inputs :

         hi          hi part of 32 bit number.
         lo          lo part of 32 bit number.
         n           16 bit number.

     ----------------------------------------------------------------------------*/


    __inline int32 mul_32by16(int16 hi, int16 lo, int16 n)
    {
        return (((((int32)hi*n)) + ((((int32)lo*n) >> 15))) << 1);
    }

    __inline  int32 fxp_mac_16by16(int16 var1,  int16 var2, int32 L_add)
    {

        L_add += (int32)var1 * var2;

        return L_add;
    }

    __inline  int32 fxp_mul_16by16(int16 var1, const int16 var2)
    {
        int32 L_mul = (int32)var1 * var2;

        return L_mul;
    }

    __inline  int32 fxp_mul32_by_16b(int32 L_var1, const int32 L_var2)
    {

        int32 L_mul = (int32)(((int64)L_var1 * (L_var2 << 16)) >> 32);

        return L_mul;
    }


#ifdef __cplusplus
}
#endif

#endif

#endif   /*  PVAMRWBDECODER_BASIC_OP_CEQUIVALENT_H  */