mat_lib.c

2400bps MELP语音编解码源程序。

 *                     falls in the range
 *                     0x8000 0000 <= L_innerprod <= 0x7fff ffff.
 *
 *   IMPLEMENTATION:
 *
 *     Compute the inner product of the two 16 bit vectors
 *     The output is a 32 bit number.
 *
 *   KEYWORDS: inner product
 *
 *************************************************************************/

Longword L_v_inner(Shortword *vec1,Shortword *vec2,Shortword n,
		   Shortword qvec1,Shortword qvec2,Shortword qout)
{
    Shortword i,shift;
    Longword L_innerprod;
    Longword L_temp;

    L_temp = 0;   data_move();
    for(i = 0; i < n; i++)
        L_temp = L_mac(L_temp,vec1[i],vec2[i]);
    /* ((qout-16)-((qvec1+qvec2+1)-16)) */
    shift = sub(qout,add(add(qvec1,qvec2),1));
    L_innerprod = L_shl(L_temp,shift);
    return(L_innerprod);
}

/***************************************************************************
 *
 *   FUNCTION NAME: v_magsq
 *
 *   PURPOSE:
 *
 *     Compute the sum of square magnitude of a 16 bit input vector
 *     with saturation and truncation.  Output is a 16 bit number.
 *
 *   INPUTS:
 *
 *     vec1            16 bit short signed integer (Shortword) whose value
 *                     falls in the range 0xffff 8000 <= vec1 <= 0x0000 7fff.
 *
 *     n               size of input vectors
 *
 *     qvec1           Q value of vec1
 *
 *     qout            Q value of output
 *
 *   OUTPUTS:
 *
 *     none
 *
 *   RETURN VALUE:
 *
 *     magsq           16 bit short signed integer (Shortword) whose value
 *                     falls in the range
 *                     0xffff 8000 <= magsq <= 0x0000 7fff.
 *
 *   IMPLEMENTATION:
 *
 *     Compute the sum of square magnitude of a 16 bit input vector.
 *     The output is a 16 bit number.
 *
 *   KEYWORDS: square magnitude
 *
 *************************************************************************/

Shortword v_magsq(Shortword *vec1,Shortword n,Shortword qvec1,Shortword qout)
{
    Shortword i,shift;
    Shortword magsq;
    Longword L_temp;

    L_temp = 0;   L_data_move();
    for(i = 0; i < n; i++)
        L_temp = L_mac(L_temp,vec1[i],vec1[i]);
    /* qout-((2*qvec1+1)-16) */
    shift = sub(qout,sub(add(shl(qvec1,1),1),16));
    magsq = extract_h(L_shl(L_temp,shift));
    return(magsq);
} /* v_magsq */

/***************************************************************************
 *
 *   FUNCTION NAME: L_v_magsq
 *
 *   PURPOSE:
 *
 *     Compute the sum of square magnitude of a 16 bit input vector
 *     with saturation and truncation.  Output is a 32 bit number.
 *
 *   INPUTS:
 *
 *     vec1            16 bit short signed integer (Shortword) whose value
 *                     falls in the range 0xffff 8000 <= vec1 <= 0x0000 7fff.
 *
 *     n               size of input vectors
 *
 *     qvec1           Q value of vec1
 *
 *     qout            Q value of output
 *
 *   OUTPUTS:
 *
 *     none
 *
 *   RETURN VALUE:
 *
 *     L_magsq         32 bit long signed integer (Longword) whose value
 *                     falls in the range
 *                     0x8000 0000 <= L_magsq <= 0x7fff ffff.
 *
 *   IMPLEMENTATION:
 *
 *     Compute the sum of square magnitude of a 16 bit input vector.
 *     The output is a 32 bit number.
 *
 *   KEYWORDS: square magnitude
 *
 *************************************************************************/

Longword L_v_magsq(Shortword *vec1,Shortword n,Shortword qvec1,Shortword qout)
{
    Shortword i,shift;
    Longword L_magsq;
    Longword L_temp;

    L_temp = 0;   L_data_move();
    for(i = 0; i < n; i++)
        L_temp = L_mac(L_temp,vec1[i],vec1[i]);
    /* ((qout-16)-((2*qvec1+1)-16)) */
    shift = sub(sub(qout,shl(qvec1,1)),1);
    L_magsq = L_shl(L_temp,shift);   L_data_move();
    return(L_magsq);
} /* L_v_magsq */

/***************************************************************************
 *
 *   FUNCTION NAME: v_scale
 *
 *   PURPOSE:
 *
 *     Perform a multipy of the 16 bit input vector with a 16 bit input
 *     scale with saturation and truncation.
 *
 *   INPUTS:
 *
 *     vec1            16 bit short signed integer (Shortword) vector whose 
 *                     values fall in the range 
 *                     0xffff 8000 <= vec1 <= 0x0000 7fff.
 *     scale
 *                     16 bit short signed integer (Shortword) whose value
 *                     falls in the range 0xffff 8000 <= var1 <= 0x0000 7fff.
 *
 *     n               size of vec1
 *
 *   OUTPUTS:
 *
 *     none
 *
 *   RETURN VALUE:
 *
 *     vec1            16 bit short signed integer (Shortword) vector whose 
 *                     values fall in the range 
 *                     0xffff 8000 <= vec1[] <= 0x0000 7fff.
 *
 *   IMPLEMENTATION:
 *
 *     Perform a multipy of the 16 bit input vector with the 16 bit input
 *     scale.  The output is a 16 bit vector.
 *
 *   KEYWORDS: scale
 *
 *************************************************************************/

Shortword *v_scale(Shortword *vec1,Shortword scale,Shortword n)
{
    Shortword i;

    for(i=0; i < n; i++) {
        vec1[i] = mult(vec1[i],scale);   data_move();
    }
    return(vec1);
}

/***************************************************************************
 *
 *   FUNCTION NAME: v_scale_shl
 *
 *   PURPOSE:
 *
 *     Perform a multipy of the 16 bit input vector with a 16 bit input
 *     scale and shift to left with saturation and truncation.
 *
 *   INPUTS:
 *
 *     vec1            16 bit short signed integer (Shortword) vector whose 
 *                     values fall in the range 
 *                     0xffff 8000 <= vec1 <= 0x0000 7fff.
 *
 *     scale           16 bit short signed integer (Shortword) whose value
 *                     falls in the range 0xffff 8000 <= var1 <= 0x0000 7fff.
 *
 *     n               size of vec1
 *
 *     shift           16 bit short signed integer (Shortword) whose value
 *                     falls in the range 0x0000 0000 <= var1 <= 0x0000 1f.
 *
 *   OUTPUTS:
 *
 *     none
 *
 *   RETURN VALUE:
 *
 *     vec1            16 bit short signed integer (Shortword) vector whose 
 *                     values fall in the range 
 *                     0xffff 8000 <= vec1[] <= 0x0000 7fff.
 *
 *   IMPLEMENTATION:
 *
 *     Perform a multipy of the 16 bit input vector with the 16 bit input
 *     scale.  The output is a 16 bit vector.
 *
 *   KEYWORDS: scale
 *
 *************************************************************************/

Shortword *v_scale_shl(Shortword *vec1,Shortword scale,Shortword n,
		       Shortword shift)
{
    Shortword i;

    for(i=0; i < n; i++)
        vec1[i] = extract_h(L_shl(L_mult(vec1[i],scale),shift));
    return(vec1);
}

/***************************************************************************
 *
 *   FUNCTION NAME: v_sub
 *
 *   PURPOSE:
 *
 *     Perform the subtraction of the two 16 bit input vector with
 *     saturation.
 *
 *   INPUTS:
 *
 *     vec1            16 bit short signed integer (Shortword) vector whose 
 *                     values fall in the range 
 *                     0xffff 8000 <= vec1 <= 0x0000 7fff.
 *
 *     vec2            16 bit short signed integer (Shortword) vector whose 
 *                     values falls in the range 
 *                     0xffff 8000 <= vec2 <= 0x0000 7fff.
 *
 *     n               size of input vectors.
 *
 *   OUTPUTS:
 *
 *     none
 *
 *   RETURN VALUE:
 *
 *     vec1            16 bit short signed integer (Shortword) vector whose 
 *                     values fall in the range
 *                     0xffff 8000 <= vec1[] <= 0x0000 7fff.
 *
 *   IMPLEMENTATION:
 *
 *     Perform the subtraction of the two 16 bit input vectors with
 *     saturation.
 *
 *     vec1 = vec1 - vec2
 *
 *     vec1[] is set to 0x7fff if the operation results in an
 *     overflow.  vec1[] is set to 0x8000 if the operation results
 *     in an underflow.
 *
 *   KEYWORDS: sub, subtraction
 *
 *************************************************************************/

Shortword *v_sub(Shortword *vec1,Shortword *vec2,Shortword n)
{
    Shortword i;

    for(i=0; i < n; i++) {
        vec1[i] = sub(vec1[i],vec2[i]);   data_move();
    }

    return(vec1);
}

/***************************************************************************
 *
 *   FUNCTION NAME: v_zap
 *
 *   PURPOSE:
 *
 *     Set the elements of a 16 bit input vector to zero.
 *
 *   INPUTS:
 *
 *     vec1            16 bit short signed integer (Shortword) vector whose 
 *                     values fall in the range 
 *                     0xffff 8000 <= vec1 <= 0x0000 7fff.
 *
 *     n               size of vec1.
 *
 *   OUTPUTS:
 *
 *     none
 *
 *   RETURN VALUE:
 *
 *     vec1            16 bit short signed integer (Shortword) vector whose 
 *                     values are equal to 0x0000 0000.
 *
 *   IMPLEMENTATION:
 *
 *     Set the elements of 16 bit input vector to zero.
 *
 *     vec1 = 0
 *
 *   KEYWORDS: zap, clear, reset
 *
 *************************************************************************/

Shortword *v_zap(Shortword *vec1,Shortword n)
{
    Shortword i;

    for(i = 0; i < n; i++) {
        vec1[i] = 0;   data_move();
    }

    return(vec1);
}

/***************************************************************************
 *
 *   FUNCTION NAME: L_v_zap
 *
 *   PURPOSE:
 *
 *     Set the elements of a 32 bit input vector to zero.
 *
 *   INPUTS:
 *
 *     L_vec1          32 bit long signed integer (Longword) vector whose 
 *                     values fall in the range 
 *                     0x8000 0000 <= vec1 <= 0x7fff ffff.
 *
 *     n               size of L_vec1.
 *
 *   OUTPUTS:
 *
 *     none
 *
 *   RETURN VALUE:
 *
 *     L_vec1          32 bit long signed integer (Longword) vector whose 
 *                     values are equal to 0x0000 0000.
 *
 *   IMPLEMENTATION:
 *
 *     Set the elements of 32 bit input vector to zero.
 *
 *     L_vec1 = 0
 *
 *   KEYWORDS: zap, clear, reset
 *
 *************************************************************************/

Longword *L_v_zap(Longword *L_vec1,Shortword n)
{
    Shortword i;

    for(i = 0; i < n; i++) {
        L_vec1[i] = 0;   data_move();
    }

    return(L_vec1);
}