mat_lib.c

It is source code for Melp2.4kps vocoder using dsp tms320vc55x of ti

/*

*2.4 kbps MELP Proposed Federal Standard speech coder
*
*TMS320C5x assembly code
*
*version 1.0
*
*Copyright (c) 1998, Texas Instruments, Inc.  
*
*Texas Instruments has intellectual property rights on the MELP
*algorithm.  The Texas Instruments contact for licensing issues for
*commercial and non-government use is William Gordon, Director,
*Government Contracts, Texas Instruments Incorporated, Semiconductor
*Group (phone [phone]).

*/

/*************************************************************************
*
* The following code was hand optimized for the Texas Instuments
* TMS320C5x DSP by DSPCon, Inc.  For information, please contact DSPCon
* at:
* 
*                       DSPCon, Inc.
*                       380 Foothill Road
*                       Bridgewater, New Jersey 08807
*                       [phone]
*                       [e-mail]
*                       www.dspcon.com
*
*************************************************************************/




/*

  mat_lib.c: Matrix and vector manipulation library

*/

#include "spbstd.h"
#include "mathhalf.h"
#include "mat.h"


/***************************************************************************
 *
 *   FUNCTION NAME: L_v_add
 *
 *   PURPOSE:
 *
 *     Perform the addition of the two 32 bit input vector with
 *     saturation.
 *
 *   INPUTS:
 *
 *     L_vec1          32 bit long signed integer (Longword) vector whose
 *                     values fall in the range
 *                     0x8000 0000 <= L_vec1 <= 0x7fff ffff.
 *
 *     L_vec2          32 bit long signed integer (Longword) vector whose
 *                     values falls in the range
 *                     0x8000 0000 <= L_vec2 <= 0x7fff ffff.
 *
 *     n               size of input vectors.
 *
 *   OUTPUTS:
 *
 *     none
 *
 *   RETURN VALUE:
 *
 *     L_vec1          32 bit long signed integer (Longword) vector whose
 *                     values fall in the range
 *                     0x8000 0000 <= L_vec1[] <= 0x7fff ffff.
 *
 *   IMPLEMENTATION:
 *
 *     Perform the addition of the two 32 bit input vectors with
 *     saturation.
 *
 *     L_vec1 = L_vec1 + L_vec2
 *
 *     L_vec1[] is set to 0x7fff ffff if the operation results in an
 *     overflow.  L_vec1[] is set to 0x8000 0000 if the operation results
 *     in an underflow.
 *
 *   KEYWORDS: add, addition
 *
 *************************************************************************/

Longword *L_v_add(Longword *L_vec1,Longword *L_vec2,Shortword n)
{
    Shortword i;

    for(i=0; i < n; i++) {
      L_vec1[i] = L_add(L_vec1[i],L_vec2[i]);    
    }
    return(L_vec1);
}


/***************************************************************************
 *
 *   FUNCTION NAME: L_v_equ
 *
 *   PURPOSE:
 *
 *     Copy the contents of one 32 bit input vector to another
 *
 *   INPUTS:
 *
 *     L_vec2          32 bit long signed integer (Longword) vector whose
 *                     values falls in the range
 *                     0x8000 0000 <= L_vec2 <= 0x7fff ffff.
 *
 *     n               size of input vector
 *
 *   OUTPUTS:
 *
 *     L_vec1          32 bit long signed integer (Longword) vector whose
 *                     values fall in the range
 *                     0x8000 0000 <= L_vec1 <= 0x7fff ffff.
 *
 *   RETURN VALUE:
 *
 *     L_vec1          32 bit long signed integer (Longword) vector whose
 *                     values fall in the range
 *                     0x8000 0000 <= L_vec1[] <= 0x7fff ffff.
 *
 *   IMPLEMENTATION:
 *
 *     Copy the contents of one 32 bit input vector to another
 *
 *     vec1 = vec2
 *
 *   KEYWORDS: equate, copy
 *
 *************************************************************************/

Longword *L_v_equ(Longword *L_vec1,Longword *L_vec2,Shortword n)
{
    Shortword i;

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

/***************************************************************************
 *
 *   FUNCTION NAME: v_inner
 *
 *   PURPOSE:
 *
 *     Compute the inner product of two 16 bit input vectors
 *     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.
 *
 *     vec2            16 bit short signed integer (Shortword) whose value
 *                     falls in the range 0xffff 8000 <= vec2 <= 0x0000 7fff.
 *
 *     n               size of input vectors
 *
 *     qvec1           Q value of vec1
 *
 *     qvec2           Q value of vec2
 *
 *     qout            Q value of output
 *
 *   OUTPUTS:
 *
 *     none
 *
 *   RETURN VALUE:
 *
 *     innerprod       16 bit short signed integer (Shortword) whose value
 *                     falls in the range
 *                     0xffff 8000 <= innerprod <= 0x0000 7fff.
 *
 *   IMPLEMENTATION:
 *
 *     Compute the inner product of the two 16 bit input vectors.
 *     The output is a 16 bit number.
 *
 *   KEYWORDS: inner product
 *
 *************************************************************************/

Shortword v_inner(Shortword *vec1,Shortword *vec2,Shortword n,
		  Shortword qvec1,Shortword qvec2,Shortword qout)
{
    Shortword i;
    Shortword innerprod;
    Longword L_temp;

    L_temp = 0;   
    for(i = 0; i < n; i++)
	L_temp = L_mac(L_temp,vec1[i],vec2[i]);
    innerprod = extract_h(L_shl(L_temp,(Shortword)(qout-((qvec1+qvec2+1)-16))));
    return(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;   
    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_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;   
    return(L_vec1);
}