sl1_basic_op.h

定点除法器程序

/*! \file sl1_basic_op.h
 *  \brief This document describes a set of interfaces provided by SimpLight that will help users take full advantage of the underlying DSP extensions provided by the SL1 ISA.
*/
#ifndef sl1_basic_op_INCLUDED
#define sl1_basic_op_INCLUDED
#include "regdefs.h"
#include "sl1defs.h"
#ifdef __cplusplus
extern "C" {
#endif

#ifndef _INLINE
/*
 *  return the high 16 bit of L_var1
 */
extern INT16  _sl1_extract_hi (INT32  L_var1);


/*
 *  return the low 16 bit of L_var1
 */
extern INT16  _sl1_extract_lo (INT32  L_var1);


/*
 *  add two 16 bit integer(var1+var2), producing a saturated 16 bit result
 */
extern INT16  _sl1_sadd (INT16  var1,INT16  var2); 


/*
 *  subtract var2 from var1(var1-var2), producing a saturated 16 bit result
 */
extern INT16  _sl1_ssub (INT16  var1,INT16  var2);


/* 
 *  create a saturated 16 bit absolute value
 */
extern INT16  _sl1_sabs (INT16  var1);


/*
 *  negate the 16 bit variable (-var1) with saturation
 */
extern INT16  _sl1_snegate (INT16  var1);


/*
 *  shift var1 left by var2 positions, producing a saturated 16 bit result
 */
extern INT16  _sl1_sshl(INT16  var1,INT16  var2);



/*
 *  shift var1 right by var2 with sign extension, producing a saturated 16 bit result
 */
extern INT16  _sl1_sshr(INT16  var1,INT16  var2);


/*
 * multiply var1 and var2 with saturation, return high 16 bit of multiply
 */
extern INT16  _sl1_smult_hi (INT16  var1, INT16  var2);


/*
 *  multiply var1 and var2, and shifts the result left by 1 with saturation
 *  return the high 16 bit of result
 */
extern INT16  _sl1_smult_shl1_hi (INT16  var1, INT16  var2); 


/*
 *  return the number of left shift needed to normalize the 16 bit variable var1
 */
extern INT16  _sl1_norm (INT16  var1);


/*
 *  round lower 16 bits of the 32 bit input number into its MS 16 bits 
 *  return high 16 bit of the result
 */
extern INT16  _sl1_round16 (INT32  L_var1); 


/* 
 *  deposit the 16 bit var1 into the 16 MS bits of the 32 bit output.
 */
extern INT32  _sl1_l_deposit_hi (INT16  var1); 


/*
 *  deposit the 16 bit var1 into the 16 LS bits of the 32 bit output
 */
extern INT32  _sl1_l_deposit_lo (INT16  var1);


/*
 *  add two 32 bit integer(L_var1+L_var2), producing a saturated 32 bit result ; 
 */
extern INT32  _sl1_l_sadd (INT32  L_var1, INT32  L_var2); 


/*
 *  subtract two 32 bit integer(L_var1-L_var2), producing a saturated 32 bit result; 
 */
extern INT32  _sl1_l_ssub (INT32  L_var1, INT32  L_var2); 


/*
 *  return the number of left shift needed to normalize the 32 bit variable L_var1
 */
extern INT16  _sl1_norm_l (INT32  L_var1); 


/*
 *  create a saturated 32 bit absolute value
 */
extern INT32  _sl1_l_sabs (INT32  L_var1); 


/*
 *  negate the 32 bit variable (-L_var1) with saturation ; 
 */
extern INT32  _sl1_l_snegate(INT32  L_var1); 


/* 
 *  shift L_var1 left by var2 positions, producing a saturated 32 bit result
 *  Note: var2 must be less than 8
 */
extern INT32  _sl1_l_sshl_lt8 (INT32  L_var1, INT16  var2); 


/* 
 *  shift L_var1 left by var2 positions, producing a saturated 32 bit result
 */
extern INT32  _sl1_l_sshl (INT32  L_var1, INT16  var2);


/*
 *  shift L_var1 right by var2 with sign extension, producing a saturated 32 bit result
 */
extern INT32  _sl1_l_sshr (INT32  L_var1, INT16  var2); 


/*
 *  multiply 32 bit L_var1 and L_var2 , and returns the high 32 bit of result
 */
extern INT32  _sl1_l_muld_hi (INT32  L_var1, INT32  L_var2 ); 


/*
 *  compose from two 16 bit DPF a 32 bit integer with saturation                            
 *  L_var_out = hi<<16 + lo<<1                            
 */
extern INT32  _sl1_l_scomp(INT16  hi, INT16  lo);


/*
 * multiply var1 and var2 with saturation
 */
extern INT32  _sl1_l_smult (INT16  var1,INT16  var2);


/* 
 *  multiply 16 bit var1 and var2, and shifts the result left by 1 with saturation
  */
extern INT32  _sl1_l_smult_shl1 (INT16  var1,INT16  var2) ;


/* 
 *  multiply 16 bit var1 and var2, and shift the result left by 1 with saturation and round
 */
extern INT32  _sl1_l_smult_shl1_r (INT16  var1,INT16  var2);


/*
 *  multiply var1 by var2, add the 32 bit  result to L_sum with saturation
 */
extern INT32  _sl1_l_smac (INT32  L_sum, INT16  var1, INT16  var2) ;


/*
 *  multiply var1 by var2, and shifts the result left by 1. Add the 32 bit  result to L_sum with saturation
 */
extern INT32  _sl1_l_smac_shl1 (INT32  L_sum, INT16  var1, INT16  var2);


/*
 *  multiply var1 by var2, substract the result from  L_sub with saturation
 */
extern INT32  _sl1_l_smsu (INT32  L_sub, INT16  var1, INT16  var2);


/*
 *  multiply var1 by var2, and shifts the result left by 1. 
 *  subtract the result from  L_sub with saturation
 */
extern INT32  _sl1_l_smsu_shl1 (INT32  L_sub, INT16  var1, INT16  var2);


/*
 *  perform 16 bit add with saturation in a do-loop
 *  =======================================
 *  |  for (j = bgn_v; j < end_v; j++ )   |
 *  |    out[j] =  _sadd(p0[j], p1[j]);    |
 *  =======================================
 */
extern void _sl1_sadd_loop (INT16  *out,  INT16 * p0, INT16 * p1, INT32  bgn_v, INT32  end_v, INT32  inc);


/*
 *  perform 16 bit variable subtracts with saturation in a do-loop 
 *  =======================================
 *  |  for (j = bgn_v; j < end_v; j++ )   |
 *  |    out[j] =  _ssub(p0[j], p1[j]);    |
 *  =======================================
 */
extern void _sl1_ssub_loop (INT16  *out,  INT16 * p0, INT16 * p1, INT32  bgn_v, INT32  end_v, INT32  inc);



/*
 * use mac to perform 16 bit variable multiply and add to L_sum with saturation in a do-loop
 *  ==================================================
 *  |  for (j = bgn_v; j < end_v; j++ )              |
 *  |    L_sum += p0[j] * p1[j]); |
 *  ==================================================
 */
extern INT32  _sl1_mac_loop(INT32  L_sum, INT16 * p0, INT16 * p1, INT32  bgn_i, INT32  end_i, INT32  inc);


/*
 * use mac to perform 16 bit variable multiply and add to L_sum with saturation in a do-loop
 *  ==================================================
 *  |  for (j = bgn_v; j < end_v; j++ )              |
 *  |    L_sum= _l_smac(L_sum, p0[j], p1[j]); |
 *  ==================================================
 */
extern INT32  _sl1_smac_loop(INT32  L_sum, INT16 * p0, INT16 * p1, INT32  bgn_i, INT32  end_i, INT32  inc);


/*
 * use mac to perform 16 bit variable multiply and add to L_sum with saturation in a do-loop
 *  ==================================================
 *  |  for (j = bgn_v; j < end_v; j++ )              |
 *  |    L_sum +=  var1 * p1[j]; |
 *  ==================================================
 */
extern INT32  _sl1_mac_v_p_loop(INT32  L_sum, INT16  var1, INT16 * p1, INT32  bgn_i, INT32  end_i, INT32  inc);


/*
 *  multiply two 16 bit variable, and shifts left by 1 and add to L_sum with saturation in a do-loop
 *  =================================================
 *  |  for (j = bgn_v; j < end_v; j++ )             |
 *  |    L_sum = _l_smac_shl1(L_sum, p0[j], p1[j]); |
 *  =================================================
 */
extern INT32  _sl1_smac_shl1_loop(INT32  L_sum, INT16 * p0, INT16 * p1, INT32  bgn_i, INT32  end_i, INT32  inc);


/*
 * use msu to perform 16 bit variable multiply and subtract  by L_out with saturation in a do-loop
 *  ==================================================
 *  |  for (j = bgn_v; j < end_v; j++ )              |
 *  |    L_out = _l_smsu(L_out, p0[j], p1[j]);       |
 *  ==================================================
 */
extern INT32  _sl1_smsu_loop(INT32  L_out, INT16 * p0, INT16 * p1, INT32  bgn_i, INT32  end_i, INT32  inc);


/*
 * use msu to perform 16 bit variable multiply and shift left by 1,  subtract  by L_out with saturation in a do-loop
 *  ==================================================
 *  |  for (j = bgn_v; j < end_v; j++ )              |
 *  |    L_out = _l_smsu_shl1(L_out, p0[j], p1[j]);  |
 *  ==================================================
 */
extern INT32  _sl1_smsu_shl1_loop(INT32  L_out, INT16 * p0, INT16 * p1, INT32  bgn_i, INT32  end_i, INT32  inc);


/*
 * use dmac to perform 16 bit variable multiply add to L_sum in a do-loop
 *  =====================================================
 *  |  for (j = bgn_v; j < end_v; j++ )                 |
 *  |    L_sum += p0[j] * p1[j];                        |
 *  =====================================================
 */
extern INT32  _sl1_dmac_loop(INT32  L_sum, INT16* p0, INT16* p1, INT32  bgn_i, INT32  end_i, INT32  inc);


/*
 * use dmac to perform 16 bit variable multiply and shift left by 1 and add toL_sum with saturation in a do-loop
 *  =================================================
 *  |  for (j = bgn_v; j < end_v; j++ )             |
 *  |    L_sum = _l_smac_shl1(L_sum, p0[j], p1[j]); |
 *  =================================================
 */
extern INT32  _sl1_sdmac_shl1_loop(INT32  L_sum, INT16* p0, INT16* p1, INT32  bgn_i, INT32  end_i, INT32  inc);


/*
 * add high part and low part of L_var1 and L_var2 seperately with saturation
 */
extern INT32  _sl1_dual_sadd(INT32  L_var1, INT32  L_var2);


/*
 * substract high part and low part of L_var1 by L_var2 seperately with saturation
 */
extern INT32  _sl1_dual_ssub(INT32  L_var1, INT32  L_var2);
#endif // ndef _INLINE


/*! \def _sl1_saturate(var1, var2)
 * \brief a macro that saturates 16 bit var1 in range of (-2^var2, 2^var2 - 1)
 * \param var1 variable to be saturated(INT16)
 * \param var2 unsigned immediate integer, should be in range of (0, 15)
 * \return a saturated value of var1(INT16)
 * \note  c3.saaddsh rd, var1, 0, (15-var2) <br>
          shra16.i rd, (15-var2)   <br>
 * \see _sl1_saturate_u
 */
#define _sl1_saturate(var1, var2) \
  (SL1_sadd_shl(var1, 0, (15-var2)) >> (15-var2))

/*! \def  _sl1_saturate_u(var1,var2)
 *  \brief a macro that saturates 16 bit var1 in range of (0, 2^var2 - 1)
 *  \param var1 variable to be saturated(INT16)
 *  \param var2 unsigned immediate integer, should be in range of (0, 15)
 *  \return a saturated value of var1(UINT16)
 *  \see _sl1_saturate 
 */
#define _sl1_saturate_u(var1,var2) \
  ((var1 < 0) ? 0 : (_sl1_sadd_shl(var1, 0, (15-var2)) >> (15-var2)))	


/*! \def _sl1_sadd_shl(var1, var2, shl)
 *  \brief a macro that adds two 16 bit integer(var1+var2) and shift left by shl
 *  \param var1 INT16
 *  \param var2 INT16
 *  \param shl unsigned immediate integer, should be in range of (0, 31)
 *  \return a saturated value(INT16)
 *  \note c3.saaddsh rd, var1, var2, shl
 */
#define _sl1_sadd_shl(var1, var2, shl) \
  SL1_sadd_shl(var1, var2, shl)