Commit 1bd06233 authored by vaclav's avatar vaclav
Browse files

remove "__zaloha" directory

parent 0a50aa96

lib_com/__zaloha/basop32.c

deleted100644 → 0
+0 −2542

File deleted.

Preview size limit exceeded, changes collapsed.

lib_com/__zaloha/basop32.h

deleted100644 → 0
+0 −139
Original line number Diff line number Diff line 
/*

  ===========================================================================

   File: BASOP32.H                                       v.2.3 - 30.Nov.2009

  ===========================================================================



            ITU-T STL  BASIC OPERATORS



            GLOBAL FUNCTION PROTOTYPES



   History:

   26.Jan.00   v1.0     Incorporated to the STL from updated G.723.1/G.729

                        basic operator library (based on basic_op.h) and

                        G.723.1's basop.h.

   05.Jul.00   v1.1     Added 32-bit shiftless mult/mac/msub operators



   03 Nov 04   v2.0     Incorporation of new 32-bit / 40-bit / control

                        operators for the ITU-T Standard Tool Library as

                        described in Geneva, 20-30 January 2004 WP 3/16 Q10/16

                        TD 11 document and subsequent discussions on the

                        wp3audio@yahoogroups.com email reflector.

                        norm_s()      weight reduced from 15 to 1.

                        norm_l()      weight reduced from 30 to 1.

                        L_abs()       weight reduced from  2 to 1.

                        L_add()       weight reduced from  2 to 1.

                        L_negate()    weight reduced from  2 to 1.

                        L_shl()       weight reduced from  2 to 1.

                        L_shr()       weight reduced from  2 to 1.

                        L_sub()       weight reduced from  2 to 1.

                        mac_r()       weight reduced from  2 to 1.

                        msu_r()       weight reduced from  2 to 1.

                        mult_r()      weight reduced from  2 to 1.

                        L_deposit_h() weight reduced from  2 to 1.

                        L_deposit_l() weight reduced from  2 to 1.

                        L_mls() weight of 5.

                        div_l() weight of 32.

                        i_mult() weight of 3.



   30 Nov 09   v2.3     round() function is now round_fx().

                        saturate() is not referencable from outside application



   13 Mar 12            Add Overflow2 flag for additional overflow checking.

  ============================================================================

*/





#ifndef _BASIC_OP_H

#define _BASIC_OP_H



/* #define BASOP_OVERFLOW2 */



/*___________________________________________________________________________

 |                                                                           |

 |   Constants and Globals                                                   |

 |___________________________________________________________________________|

*/

extern Flag Overflow, Overflow2;

extern Flag Carry;



#define BASOP_SATURATE_WARNING_ON

#define BASOP_SATURATE_WARNING_OFF

#define BASOP_SATURATE_ERROR_ON

#define BASOP_SATURATE_ERROR_OFF

#define BASOP_CHECK()





#define MAX_32 (Word32)0x7fffffffL

#define MIN_32 (Word32)0x80000000L



#define MAX_16 (Word16)0x7fff

#define MIN_16 (Word16)0x8000



/*___________________________________________________________________________

 |                                                                           |

 |   Prototypes for basic arithmetic operators                               |

 |___________________________________________________________________________|

*/



Word16 add (Word16 var1, Word16 var2);    /* Short add,           1   */

Word16 sub (Word16 var1, Word16 var2);    /* Short sub,           1   */

Word16 abs_s (Word16 var1);               /* Short abs,           1   */

Word16 shl (Word16 var1, Word16 var2);    /* Short shift left,    1   */

Word16 shr (Word16 var1, Word16 var2);    /* Short shift right,   1   */

Word16 mult (Word16 var1, Word16 var2);   /* Short mult,          1   */

Word32 L_mult (Word16 var1, Word16 var2); /* Long mult,           1   */

Word16 negate (Word16 var1);              /* Short negate,        1   */

Word16 extract_h (Word32 L_var1);         /* Extract high,        1   */

Word16 extract_l (Word32 L_var1);         /* Extract low,         1   */

Word16 round_fx (Word32 L_var1);          /* Round,               1   */

Word32 L_mac (Word32 L_var3, Word16 var1, Word16 var2);   /* Mac,  1  */

Word32 L_msu (Word32 L_var3, Word16 var1, Word16 var2);   /* Msu,  1  */

Word32 L_macNs (Word32 L_var3, Word16 var1, Word16 var2); /* Mac without

                                                             sat, 1   */

Word32 L_msuNs (Word32 L_var3, Word16 var1, Word16 var2); /* Msu without

                                                             sat, 1   */

Word32 L_add (Word32 L_var1, Word32 L_var2);    /* Long add,        1 */

Word32 L_sub (Word32 L_var1, Word32 L_var2);    /* Long sub,        1 */

Word32 L_add_c (Word32 L_var1, Word32 L_var2);  /* Long add with c, 2 */

Word32 L_sub_c (Word32 L_var1, Word32 L_var2);  /* Long sub with c, 2 */

Word32 L_negate (Word32 L_var1);                /* Long negate,     1 */

Word16 mult_r (Word16 var1, Word16 var2);       /* Mult with round, 1 */

Word32 L_shl (Word32 L_var1, Word16 var2);      /* Long shift left, 1 */

Word32 L_shr (Word32 L_var1, Word16 var2);      /* Long shift right, 1 */

Word16 shr_r (Word16 var1, Word16 var2);        /* Shift right with

                                                   round, 2           */

Word16 mac_r (Word32 L_var3, Word16 var1, Word16 var2); /* Mac with

                                                           rounding, 1 */

Word16 msu_r (Word32 L_var3, Word16 var1, Word16 var2); /* Msu with

                                                           rounding, 1 */

Word32 L_deposit_h (Word16 var1);        /* 16 bit var1 -> MSB,     1 */

Word32 L_deposit_l (Word16 var1);        /* 16 bit var1 -> LSB,     1 */



Word32 L_shr_r (Word32 L_var1, Word16 var2); /* Long shift right with

                                                round,             3  */

Word32 L_abs (Word32 L_var1);            /* Long abs,              1  */

Word32 L_sat (Word32 L_var1);            /* Long saturation,       4  */

Word16 norm_s (Word16 var1);             /* Short norm,            1  */

Word16 div_s (Word16 var1, Word16 var2); /* Short division,       18  */

Word16 norm_l (Word32 L_var1);           /* Long norm,             1  */





/*

 * Additional G.723.1 operators

*/

Word32 L_mls( Word32, Word16 ) ;    /* Weight FFS; currently assigned 5 */

Word16 div_l( Word32, Word16 ) ;    /* Weight FFS; currently assigned 32 */

Word16 i_mult(Word16 a, Word16 b);  /* Weight FFS; currently assigned 3 */



/*

 *  New shiftless operators, not used in G.729/G.723.1

*/

Word32 L_mult0(Word16 v1, Word16 v2); /* 32-bit Multiply w/o shift         1 */

Word32 L_mac0(Word32 L_v3, Word16 v1, Word16 v2); /* 32-bit Mac w/o shift  1 */

Word32 L_msu0(Word32 L_v3, Word16 v1, Word16 v2); /* 32-bit Msu w/o shift  1 */





#endif /* ifndef _BASIC_OP_H */





/* end of file */

lib_com/__zaloha/basop_com_lpc.c

deleted100644 → 0
+0 −239
Original line number Diff line number Diff line 
/*====================================================================================

    EVS Codec 3GPP TS26.443 Nov 04, 2021. Version 12.14.0 / 13.10.0 / 14.6.0 / 15.4.0 / 16.3.0

  ====================================================================================*/



#include "wmc_auto.h"

#include <math.h>

#include <memory.h>

#include <assert.h>

#include <stdio.h>

#include "typedef.h"

#include "basop_proto_func.h"

#include "cnst.h"



#include "basop_util.h"

#include "stl.h"



#define WMC_TOOL_SKIP



#define UNROLL_CHEBYSHEV_INNER_LOOP

#define NC_MAX 8

#define GUESS_TBL_SZ 256



#define Madd_32_16(accu, x, y) L_add(accu, Mpy_32_16(x, y))

#define Msub_32_16(accu, x, y) L_sub(accu, Mpy_32_16(x, y))





/*

 * weight_a

 *

 * Parameters:

 *    a              I: LP filter coefficients            Q12

 *    ap             O: weighted LP filter coefficients Q12

 *    gamma          I: weighting factor                Q15

 *

 * Function:

 *    Weighting of LP filter coefficients, ap[i] = a[i] * (gamma^i).

 *

 * Returns:

 *    void

 */

void basop_weight_a(const Word16 *a, Word16 *ap, const Word16 gamma)

{

    Word16 i, fac;

    Word32 Amax;

    Word16 shift;







    fac = gamma;

    Amax = L_mult( 16384, a[0] );

    FOR (i = 1; i < M; i++)

    {

        Amax = L_max( Amax, L_abs( L_mult0( fac, a[i] ) ) );

        fac = mult_r( fac, gamma );

    }

    Amax = L_max( Amax, L_abs( L_mult0( fac, a[M] ) ) );

    shift = norm_l( Amax );

    fac = gamma;

    ap[0] = shl( a[0], sub(shift,1) );

    move16();

    FOR (i = 1; i < M; i++)

    {

        ap[i] = round_fx(L_shl(L_mult0(a[i], fac),shift));

        move16();

        fac = mult_r( fac, gamma );

    }

    ap[M] = round_fx(L_shl(L_mult0(a[M], fac),shift));

    move16();





    return;

}



/*

 * weight_a_inv

 *

 * Parameters:

 *    a              I: LP filter coefficients            Q12

 *    ap             O: weighted LP filter coefficients Q12

 *    inv_gamma      I: inverse weighting factor                Q14

 *

 * Function:

 *    Weighting of LP filter coefficients, ap[i] = a[i] * (inv_gamma^i).

 *

 * Returns:

 *    void

 */

void basop_weight_a_inv(const Word16 *a, Word16 *ap, const Word16 inv_gamma)

{

    Word16 i;

    static const Word16 inv_gamma_tab_12k8[16] = { 17809, 19357, 21041, 22870, 24859, 27020, 29370, 31924,   /* Q14 */

                                                   17350, 18859, 20499, 22281, 24219, 26325, 28614, 31102

                                                 }; /* Q13 */

    static const Word16 inv_gamma_tab_16k[16]  = { 17430, 18542, 19726, 20985, 22324, 23749, 25265, 26878,   /* Q14 */

                                                   14297, 15209, 16180, 17213, 18312, 19480, 20724, 22047

                                                 }; /* Q13 */

    const Word16 *inv_gamma_tab;

    Word32 L_tmp;

    Word32 Amax;

    Word16 shift;





    IF (inv_gamma == 16384)

    {

        FOR (i = 0; i <= M; i++)

        {

            ap[i] = a[i];

            move16();

        }

        return;

    }



    assert( inv_gamma==GAMMA1_INV || inv_gamma==GAMMA16k_INV );



    inv_gamma_tab = inv_gamma_tab_12k8;

    move16();

    if (sub(inv_gamma,GAMMA16k_INV) == 0)

    {

        inv_gamma_tab = inv_gamma_tab_16k;

        move16();

    }



    Amax = L_mult( 16384, a[0] );

    FOR (i = 1; i < 9; i++)

    {

        Amax = L_max( Amax, L_abs( L_mult( a[i], inv_gamma_tab[i-1] ) ) );

    }

    FOR (i = 9; i < 17; i++)

    {

        Amax = L_max( Amax, L_abs( L_shl( L_mult( a[i], inv_gamma_tab[i-1] ), 1 ) ) );

    }

    shift = norm_l( Amax );

    ap[0] = shl( a[0], sub(shift,1) );

    move16();

    FOR (i = 1; i < 9; i++)

    {

        L_tmp = L_mult( a[i], inv_gamma_tab[i-1] );

        ap[i] = round_fx( L_shl( L_tmp, shift ) );

        move16();

    }

    shift = add(shift,1);

    FOR (i = 9; i < 17; i++)

    {

        L_tmp = L_mult( a[i], inv_gamma_tab[i-1] );

        ap[i] = round_fx( L_shl( L_tmp, shift ) );

        move16();

    }





    return;

}



/*

 * basop_E_LPC_a_add_tilt

 *

 * Parameters:

 *    a              I: LP filter coefficients (m+1 coeffs)

 *    ap             O: modified LP filter coefficients (m+2 coeffs)

 *    gamma          I: tilt factor

 *

 * Function:

 *    Modified LP filter by adding 1st order pre-premphasis, Ap(z)=A(z).(1-gamma.z^(-1))

 *

 * Returns:

 *    void

 */

void basop_E_LPC_a_add_tilt(const Word16 *a, Word16 *ap, Word16 gamma)

{

    Word16 i;

    Word32 Amax, Atmp[M+2];

    Word16 shift;









    Amax = L_mult( 16384, a[0] );

    FOR (i = 1; i <= M; i++)

    {

        Atmp[i] = L_sub( L_mult(16384, a[i]), L_mult0(gamma, a[i-1]) );

        move32();

        Amax = L_max( Amax, L_abs( Atmp[i] ) );

    }

    Atmp[M+1] = L_negate( L_mult0(gamma, a[M]) );

    move32();

    Amax = L_max( Amax, L_abs( Atmp[M+1] ) );

    shift = norm_l( Amax );

    ap[0] = shl( a[0], sub(shift,1) );

    move16();

    FOR (i = 1; i <= M; i++)

    {

        ap[i] = round_fx( L_shl( Atmp[i], shift ) );

        move16();

    }

    ap[M+1] = round_fx( L_shl( Atmp[M+1], shift ) );

    move16();



    return;

}







static Word16 xsf_to_xsp(Word16 xsf)

{

    /* xsp = cos(xsf * 3.1415/6400); */

    return getCosWord16R2(xsf);

}



/*

 * lsf2lsp

 *

 * Parameters:

 *    lsf            I: lsf[m] normalized (range: 0 <= val <= 0.5)    x2.56

 *    lsp            O: lsp[m] (range: -1 <= val < 1)                Q15

 *

 * Function:

 *    Transformation lsf to lsp

 *

 *    LSF are line spectral pair in frequency domain (0 to 6400).

 *    LSP are line spectral pair in cosine domain (-1 to 1).

 *

 * Returns:

 *    void

 */

void basop_lsf2lsp(const Word16 lsf[], Word16 lsp[])

{

    Word16 i;







    /* convert ISFs to the cosine domain */

    FOR (i = 0; i < M; i++)

    {

        *lsp++ = xsf_to_xsp(*lsf++);

        move16();

    }





    return;

}

lib_com/__zaloha/basop_lsf_tools.c

deleted100644 → 0
+0 −265
Original line number Diff line number Diff line 
/*====================================================================================

    EVS Codec 3GPP TS26.443 Nov 04, 2021. Version 12.14.0 / 13.10.0 / 14.6.0 / 15.4.0 / 16.3.0

  ====================================================================================*/





#include "wmc_auto.h"

#include <stdlib.h>

#include <stdio.h>

#include <assert.h>

#include "basop_proto_func.h"

#include "control.h"

#include "basop_util.h"



#define WMC_TOOL_SKIP



#define NC_MAX 8



static Word16 E_LPC_f_lsp_pol_get(const Word16 lsp[], Word32 f[],  const Word16 n, const Word16 past_Ovf, const Word16 isMODE1);





/*

 * E_LPC_f_lsp_a_conversion

 *

 * Parameters:

 *    lsp            I: Line spectral pairs          Q15

 *    a              O: Predictor coefficients (order = m)  Qx (The Q factor of the output to be deduced from a(0))

 *    m              I: order of LP filter

 *

 * Function:

 *    Convert ISPs to predictor coefficients a[]

 *

 * Returns:

 *    void

 */

void basop_E_LPC_f_lsp_a_conversion(const Word16 *lsp, Word16 *a,  const Word16 m)

{

    Word16 i, j, k;

    Word32 f1[NC_MAX+1], f2[NC_MAX+1];

    Word16 nc;

    Word32 t0;

    Word16 Ovf, Ovf2;





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

     *  Find the polynomials F1(z) and F2(z)               *

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



    nc = shr(m, 1);



    assert(m == 16 || m == 10);



    Ovf = 0;

    move16();

    Ovf = E_LPC_f_lsp_pol_get(&lsp[0], f1, nc, Ovf, 1);

    Ovf2 = E_LPC_f_lsp_pol_get(&lsp[1], f2, nc, Ovf, 1);

    IF(sub(Ovf2,Ovf) !=0)

    {

        /* to ensure similar scaling for f1 and f2 in case

          an overflow would be detected only in f2,

          but this case never happen on my dtb */

        E_LPC_f_lsp_pol_get(&lsp[0], f1, nc, s_max(Ovf2,Ovf), 1);

    }

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

     *  Multiply F1(z) by (1+z^-1) and F2(z) by (1-z^-1)   *

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

    /*modification*/

    k = sub(nc,1);

    FOR (i = 0; i <= k; i++)

    {

        f1[nc-i] = L_add(f1[nc-i],f1[nc-i-1]);

        move32();

        f2[nc-i] = L_sub(f2[nc-i],f2[nc-i-1]);

        move32();

    }



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

     *  A(z) = (F1(z)+F2(z))/2                             *

     *  F1(z) is symmetric and F2(z) is antisymmetric      *

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



    t0 = L_deposit_l(0);

    FOR (i = 1; i <= nc; i++)

    {

        t0 = L_max( t0, L_abs(L_add(f1[i], f2[i])) );

        t0 = L_max( t0, L_abs(L_sub(f1[i], f2[i])) );

    }

    k = s_min( norm_l(t0), 6 );

    a[0] = shl( 256, k );

    move16();

    test();

    IF( Ovf || Ovf2)

    {

        a[0] = shl( 256, sub(k,Ovf) );

        move16();

    }

    j = m;

    FOR (i = 1;  i <= nc; i++)

    {

        /* a[i] = 0.5*(f1[i] + f2[i]) */

        t0 = L_add(f1[i],f2[i]);

        t0 = L_shl(t0, k);

        a[i] = round_fx(t0);             /* from Q23 to Qx and * 0.5 */



        /* a[j] = 0.5*(f1[i] - f2[i]) */

        t0 = L_sub(f1[i],f2[i]);

        t0 = L_shl(t0, k);

        a[j] = round_fx(t0);             /* from Q23 to Qx and * 0.5 */

        j--;

    }



    return;

}





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

* procedure  reorder_lsf()

*

* To make sure that the  lsfs are properly ordered and to keep a certain

* minimum distance between consecutive lsfs.

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

void basop_reorder_lsf(

    Word16 *lsf,      /* i/o: LSFs in the frequency domain (0..0.5)   Q(x2.56)*/

    const Word16 min_dist,  /* i  : minimum required distance               x2.56*/

    const Word16 n,         /* i  : LPC order                               */

    const Word32 fs         /* i  : sampling frequency                      */

)

{

    Word16 i, lsf_min, n_m_1;

    Word16 lsf_max;



    lsf_min = min_dist;

    move16();



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

     * Verify the LSF ordering and minimum GAP

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



    FOR (i = 0; i < n; i++)

    {

        if (sub(lsf[i], lsf_min) < 0)

        {

            lsf[i] = lsf_min;

            move16();

        }

        lsf_min = add(lsf[i], min_dist);

    }



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

     * Reverify the LSF ordering and minimum GAP in the reverse order (security)

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

    lsf_max = round_fx(L_sub(L_shr(L_mult0(extract_l(L_shr(fs,1)), 1311),9-16), L_deposit_h(min_dist))); /* Q0 + Q9 , 1311 is 2.56 in Q9 */

    n_m_1 = sub(n,1);

    IF (sub(lsf[n_m_1], lsf_max) > 0)    /* If danger of unstable filter in case of resonance in HF */

    {

        FOR (i = n_m_1; i >= 0; i--) /* Reverify the minimum LSF gap in the reverse direction */

        {

            if (sub(lsf[i], lsf_max) > 0)

            {

                lsf[i] = lsf_max;

                move16();

            }

            lsf_max = sub(lsf[i], min_dist);

        }

    }

}





/*

 * E_LPC_f_lsp_pol_get

 *

 * Parameters:

 *    lsp/isp        I: Line spectral pairs (cosine domaine)      Q15

 *    f              O: the coefficients of F1 or F2        Q23

 *    n              I: no of coefficients (m/2)

 *                      == NC for F1(z); == NC-1 for F2(z)

 *    fact           I: scaling factor

 *

 *-----------------------------------------------------------*

 * procedure E_LPC_f_lsp_pol_get:                            *

 *           ~~~~~~~~~~~                                     *

 *   Find the polynomial F1(z) or F2(z) from the LSPs.       *

 * This is performed by expanding the product polynomials:   *

 *                                                           *

 * F1(z) =   product   ( 1 - 2 LSF_i z^-1 + z^-2 )           *

 *         i=0,2,4,6,8                                       *

 * F2(z) =   product   ( 1 - 2 LSF_i z^-1 + z^-2 )           *

 *         i=1,3,5,7,9                                       *

 *                                                           *

 * where LSP_i are the LSPs in the cosine domain.            *

 *                                                           *

 *-----------------------------------------------------------*

 *   R.A.Salami    October 1990                              *

 *-----------------------------------------------------------*

 */

static

Word16 E_LPC_f_lsp_pol_get(const Word16 lsp[], Word32 f[],  const Word16 n, const Word16 past_Ovf, const Word16 isMODE1)

{

    /* All computation in Q23 */

    const Word16 *plsp;

    Word16 i, j;

    Word16 b;

    Word32 b32;

    Word16 Ovf = 0;

    Word16 Q_out;

    Word16 m2;





    Q_out = 31-23;

    move16();

    Ovf = past_Ovf;

    move16();



    test();

    if(past_Ovf && isMODE1) /* Currently this feature is implemented only in MODE1 */

    {

        /* In some NB cases, overflow where detectected

            in f1 or f2 polynomial computation when it

            happen we reduce the precision of the computing

            to limit the risk of saturation*/

        Q_out = add(Q_out, past_Ovf);

    }

    Overflow = 0;

    move16();

    plsp = lsp;

    f[0] = L_shl(1, sub(31, Q_out));

    move32();

    /*b = -2.0f * *plsp;*/

    b = *plsp;

    move16();

    m2 = shl(-2, sub(15, Q_out));

    f[1] = L_mult(b, m2);

    move32();



    FOR (i = 2; i <= n; i++)

    {

        plsp += 2;

        /*b = 2.0f * *plsp;*/

        move16();

        b = *plsp;

        b32 = L_mult(b, m2);



        /*f[i] = -b*f[i-1] + 2.0f*f[i-2];*/

        move32();

        f[i] = L_shl(L_sub(f[i-2], Mpy_32_16(f[i-1], b)),1);



        FOR (j = i-1; j > 1; j--)

        {

            /*f[j] += b*f[j-1] + f[j-2];*/

            move32();

            f[j] = L_add(f[j], L_sub(f[j-2], L_shl(Mpy_32_16(f[j-1], b),1)));

        }

        move32();

        f[1] = L_add(f[1], b32);

    }





    test();

    IF (Overflow>0 && isMODE1)

    {

        /* If an overflow is detected, redo the computation with 1 bit less */

        Ovf = add(Ovf,1);

        Ovf = E_LPC_f_lsp_pol_get(lsp, f, n ,Ovf, isMODE1);

    }

    return Ovf;

}

lib_com/__zaloha/basop_mpy.c

deleted100644 → 0
+0 −56
Original line number Diff line number Diff line 
/*====================================================================================

    EVS Codec 3GPP TS26.443 Nov 04, 2021. Version 12.14.0 / 13.10.0 / 14.6.0 / 15.4.0 / 16.3.0

  ====================================================================================*/





#include "wmc_auto.h"

#include "basop_mpy.h"

#include "options.h"



#define WMC_TOOL_SKIP



Word32 Mpy_32_16_1(Word32 x, Word16 y)

{

    Word32 mh;

    UWord16 ml;



    Mpy_32_16_ss(x, y, &mh, &ml);



    return (mh);

}



Word32 Mpy_32_16(Word32 x, Word16 y)

{

    Word32 mh;

    UWord16 ml;



    Mpy_32_16_ss(x, y, &mh, &ml);



    return (mh);

}



Word32 Mpy_32_16_r(Word32 x, Word16 y)

{

    Word32 mh;

    UWord16 ml;



    Mpy_32_16_ss(x, y, &mh, &ml);



    if(s_and(ml, -32768 /* 0x8000 */))

    {

        mh = L_add(mh, 1);

    }



    return (mh);

}





Word32 Mpy_32_32(Word32 x, Word32 y)

{

    Word32 mh;

    UWord32 ml;



    Mpy_32_32_ss(x, y, &mh, &ml);



    return (mh);

}