开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
sp_dec.c
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：157k
源码类别：

Symbian

开发平台：

Visual C++

sp_dec.c：源码内容
  1. /*
  2.  * ===================================================================
  3.  *  TS 26.104
  4.  *  R99   V3.4.0 2002-02
  5.  *  REL-4 V4.3.0 2002-02
  6.  *  3GPP AMR Floating-point Speech Codec
  7.  * ===================================================================
  8.  *
  9.  */
  11. /*
  12.  * sp_dec.c
  13.  *
  14.  *
  15.  * Project:
  16.  *    AMR Floating-Point Codec
  17.  *
  18.  * Contains:
  19.  *    This module contains all the functions needed decoding AMR
  20.  *    encoder parameters to 16-bit speech samples
  21.  *
  22.  */
  23. /*
  24.  * include files
  25.  */
  26. #include "hlxclib/stdio.h"
  27. #include "hlxclib/stdlib.h"
  28. #include "hlxclib/memory.h"
  29. #include "hlxclib/math.h"
  30. #include "sp_dec.h"
  31. #include "rom_dec.h"
  33. /*
  34.  * Declare structure types
  35.  */
  36. enum DTXStateType
  37. {
  38.    SPEECH = 0, DTX, DTX_MUTE
  39. };
  41. /*
  42.  * Decoder memory structure
  43.  */
  44. typedef struct
  45. {
  46.    /* history vector of past synthesis speech energy */
  47.    Word32 frameEnergyHist[L_ENERGYHIST];
  50.    /* state flags */
  51.    Word16 bgHangover;   /* counter; number of frames after last speech frame */
  54. }Bgn_scdState;
  55. typedef struct
  56. {
  57.    Word32 hangCount;   /* counter; */
  58.    /* history vector of past synthesis speech energy */
  59.    Word32 cbGainHistory[L_CBGAINHIST];
  60.    Word16 hangVar;   /* counter; */
  62. }Cb_gain_averageState;
  63. typedef struct
  64. {
  65.    Word32 lsp_meanSave[M];   /* Averaged LSPs saved for efficiency  */
  68. }lsp_avgState;
  69. typedef struct
  70. {
  71.    Word32 past_r_q[M];   /* Past quantized prediction error, Q15 */
  72.    Word32 past_lsf_q[M];   /* Past dequantized lsfs, Q15 */
  75. }D_plsfState;
  76. typedef struct
  77. {
  78.    Word32 pbuf[5];
  79.    Word32 past_gain_pit;
  80.    Word32 prev_gp;
  83. }ec_gain_pitchState;
  84. typedef struct
  85. {
  86.    Word32 gbuf[5];
  87.    Word32 past_gain_code;
  88.    Word32 prev_gc;
  91. }ec_gain_codeState;
  92. typedef struct
  93. {
  94.    /*
  95.     * normal MA predictor memory, Q10
  96.     * (contains 20*log10(quaErr))
  97.     */
  98.    Word32 past_qua_en[4];
  101.    /*
  102.     * MA predictor memory for MR122 mode, Q10
  103.     * (contains log2(quaErr))
  104.     */
  105.    Word32 past_qua_en_MR122[4];
  108. }gc_predState;
  109. typedef struct
  110. {
  111.    Word32 gainMem[PHDGAINMEMSIZE];
  112.    Word32 prevCbGain;
  113.    Word32 prevState;
  114.    Word16 lockFull;
  115.    Word16 onset;
  118. }ph_dispState;
  119. typedef struct
  120. {
  121.    enum DTXStateType dtxGlobalState;   /* contains previous state */
  123.    Word32 log_en;
  124.    Word32 old_log_en;
  125.    Word32 pn_seed_rx;
  126.    Word32 lsp[M];
  127.    Word32 lsp_old[M];
  128.    Word32 lsf_hist[M * DTX_HIST_SIZE];
  129.    Word32 lsf_hist_mean[M * DTX_HIST_SIZE];
  130.    Word32 log_en_hist[DTX_HIST_SIZE];
  131.    Word32 true_sid_period_inv;
  132.    Word16 since_last_sid;
  133.    Word16 lsf_hist_ptr;
  134.    Word16 log_pg_mean;
  135.    Word16 log_en_hist_ptr;
  136.    Word16 log_en_adjust;
  137.    Word16 dtxHangoverCount;
  138.    Word16 decAnaElapsedCount;
  139.    Word16 sid_frame;
  140.    Word16 valid_data;
  141.    Word16 dtxHangoverAdded;
  144.    /* updated in main decoder */
  145.    Word16 data_updated;   /* marker to know if CNI data is ever renewed */
  148. }dtx_decState;
  149. typedef struct
  150. {
  151.    Word32 past_gain;
  154. }agcState;
  155. typedef struct
  156. {
  157.    /* Excitation vector */
  158.    Word32 old_exc[L_SUBFR + PIT_MAX + L_INTERPOL];
  159.    Word32 *exc;
  160.    Word32 lsp_old[M];
  163.    /* Filter's memory */
  164.    Word32 mem_syn[M];
  167.    /* pitch sharpening */
  168.    Word32 sharp;
  169.    Word32 old_T0;
  172.    /* Variable holding received ltpLag, used in background noise and BFI */
  173.    Word32 T0_lagBuff;
  176.    /* Variables for the source characteristic detector (SCD) */
  177.    Word32 inBackgroundNoise;
  178.    Word32 voicedHangover;
  179.    Word32 ltpGainHistory[9];
  182.    /* Memories for bad frame handling */
  183.    Word32 excEnergyHist[9];
  184.    Word16 prev_bf;
  185.    Word16 prev_pdf;
  186.    Word16 state;
  187.    Word16 nodataSeed;
  190.    Bgn_scdState * background_state;
  191.    Cb_gain_averageState * Cb_gain_averState;
  192.    lsp_avgState * lsp_avg_st;
  193.    D_plsfState * lsfState;
  194.    ec_gain_pitchState * ec_gain_p_st;
  195.    ec_gain_codeState * ec_gain_c_st;
  196.    gc_predState * pred_state;
  197.    ph_dispState * ph_disp_st;
  198.    dtx_decState * dtxDecoderState;
  199. }Decoder_amrState;
  200. typedef struct
  201. {
  202.    Word32 res2[L_SUBFR];
  203.    Word32 mem_syn_pst[M];
  204.    Word32 synth_buf[M + L_FRAME];
  205.    Word32 preemph_state_mem_pre;
  206.    agcState * agc_state;
  207. }Post_FilterState;
  208. typedef struct
  209. {
  210.    Word32 y2_hi;
  211.    Word32 y2_lo;
  212.    Word32 y1_hi;
  213.    Word32 y1_lo;
  214.    Word32 x0;
  215.    Word32 x1;
  218. }Post_ProcessState;
  219. typedef struct
  220. {
  221.    Decoder_amrState * decoder_amrState;
  222.    Post_FilterState * post_state;
  223.    Post_ProcessState * postHP_state;
  224. }Speech_Decode_FrameState;
  227. /*
  228.  * CodAmrReset
  229.  *
  230.  *
  231.  * Parameters:
  232.  *    state             B: state structure
  233.  *    mode              I: AMR mode
  234.  *
  235.  * Function:
  236.  *    Resets state memory
  237.  *
  238.  * Returns:
  239.  *    void
  240.  */
  241. static void Decoder_amr_reset( Decoder_amrState *state, enum Mode mode )
  242. {
  243.    Word32 i;
  245.    /* Cb_gain_average_reset */
  246.    memset(state->Cb_gain_averState->cbGainHistory, 0, L_CBGAINHIST << 2);
  247.    state->Cb_gain_averState->hangVar = 0;
  248.    state->Cb_gain_averState->hangCount= 0;
  250.    /* Initialize static pointer */
  251.    state->exc = state->old_exc + PIT_MAX + L_INTERPOL;
  253.    /* Static vectors to zero */
  254.    memset( state->old_exc, 0, ( PIT_MAX + L_INTERPOL )<<2 );
  256.    if ( mode != MRDTX )
  257.       memset( state->mem_syn, 0, M <<2 );
  259.    /* initialize pitch sharpening */
  260.    state->sharp = SHARPMIN;
  261.    state->old_T0 = 40;
  263.    /* Initialize state->lsp_old [] */
  264.    if ( mode != MRDTX ) {
  265.       state->lsp_old[0] = 30000;
  266.       state->lsp_old[1] = 26000;
  267.       state->lsp_old[2] = 21000;
  268.       state->lsp_old[3] = 15000;
  269.       state->lsp_old[4] = 8000;
  270.       state->lsp_old[5] = 0;
  271.       state->lsp_old[6] = -8000;
  272.       state->lsp_old[7] = -15000;
  273.       state->lsp_old[8] = -21000;
  274.       state->lsp_old[9] = -26000;
  275.    }
  277.    /* Initialize memories of bad frame handling */
  278.    state->prev_bf = 0;
  279.    state->prev_pdf = 0;
  280.    state->state = 0;
  281.    state->T0_lagBuff = 40;
  282.    state->inBackgroundNoise = 0;
  283.    state->voicedHangover = 0;
  285.    if ( mode != MRDTX )
  286.       memset( state->excEnergyHist, 0, 9 <<2 );
  287.    memset( state->ltpGainHistory, 0, 9 <<2 );
  289.    if ( mode != MRDTX ) {
  290.       state->lsp_avg_st->lsp_meanSave[0] = 1384;
  291.       state->lsp_avg_st->lsp_meanSave[1] = 2077;
  292.       state->lsp_avg_st->lsp_meanSave[2] = 3420;
  293.       state->lsp_avg_st->lsp_meanSave[3] = 5108;
  294.       state->lsp_avg_st->lsp_meanSave[4] = 6742;
  295.       state->lsp_avg_st->lsp_meanSave[5] = 8122;
  296.       state->lsp_avg_st->lsp_meanSave[6] = 9863;
  297.       state->lsp_avg_st->lsp_meanSave[7] = 11092;
  298.       state->lsp_avg_st->lsp_meanSave[8] = 12714;
  299.       state->lsp_avg_st->lsp_meanSave[9] = 13701;
  300.    }
  301.    memset( state->lsfState->past_r_q, 0, M <<2 );
  303.    /* Past dequantized lsfs */
  304.    state->lsfState->past_lsf_q[0] = 1384;
  305.    state->lsfState->past_lsf_q[1] = 2077;
  306.    state->lsfState->past_lsf_q[2] = 3420;
  307.    state->lsfState->past_lsf_q[3] = 5108;
  308.    state->lsfState->past_lsf_q[4] = 6742;
  309.    state->lsfState->past_lsf_q[5] = 8122;
  310.    state->lsfState->past_lsf_q[6] = 9863;
  311.    state->lsfState->past_lsf_q[7] = 11092;
  312.    state->lsfState->past_lsf_q[8] = 12714;
  313.    state->lsfState->past_lsf_q[9] = 13701;
  315.    for ( i = 0; i < 5; i++ )
  316.       state->ec_gain_p_st->pbuf[i] = 1640;
  317.    state->ec_gain_p_st->past_gain_pit = 0;
  318.    state->ec_gain_p_st->prev_gp = 16384;
  320.    for ( i = 0; i < 5; i++ )
  321.       state->ec_gain_c_st->gbuf[i] = 1;
  322.    state->ec_gain_c_st->past_gain_code = 0;
  323.    state->ec_gain_c_st->prev_gc = 1;
  325.    if ( mode != MRDTX ) {
  326.       for ( i = 0; i < NPRED; i++ ) {
  327.          state->pred_state->past_qua_en[i] = MIN_ENERGY;
  328.          state->pred_state->past_qua_en_MR122[i] = MIN_ENERGY_MR122;
  329.       }
  330.    }
  331.    state->nodataSeed = 21845;
  333.    /* Static vectors to zero */
  334.    memset( state->background_state->frameEnergyHist, 0, L_ENERGYHIST <<2 );
  336.    /* Initialize hangover handling */
  337.    state->background_state->bgHangover = 0;
  339.    /* phDispReset */
  340.    memset( state->ph_disp_st->gainMem, 0, PHDGAINMEMSIZE <<2 );
  341.    state->ph_disp_st->prevState = 0;
  342.    state->ph_disp_st->prevCbGain = 0;
  343.    state->ph_disp_st->lockFull = 0;
  344.    state->ph_disp_st->onset = 0;   /* assume no onset in start */
  346.    if ( mode != MRDTX ) {
  347.       state->dtxDecoderState->since_last_sid = 0;
  348.       state->dtxDecoderState->true_sid_period_inv = 8192;
  349.       state->dtxDecoderState->log_en = 3500;
  350.       state->dtxDecoderState->old_log_en = 3500;
  352.       /* low level noise for better performance in  DTX handover cases*/
  353.       state->dtxDecoderState->pn_seed_rx = PN_INITIAL_SEED;
  355.       /* Initialize state->lsp [] */
  356.       state->dtxDecoderState->lsp[0] = 30000;
  357.       state->dtxDecoderState->lsp[1] = 26000;
  358.       state->dtxDecoderState->lsp[2] = 21000;
  359.       state->dtxDecoderState->lsp[3] = 15000;
  360.       state->dtxDecoderState->lsp[4] = 8000;
  361.       state->dtxDecoderState->lsp[5] = 0;
  362.       state->dtxDecoderState->lsp[6] = -8000;
  363.       state->dtxDecoderState->lsp[7] = -15000;
  364.       state->dtxDecoderState->lsp[8] = -21000;
  365.       state->dtxDecoderState->lsp[9] = -26000;
  367.       /* Initialize state->lsp_old [] */
  368.       state->dtxDecoderState->lsp_old[0] = 30000;
  369.       state->dtxDecoderState->lsp_old[1] = 26000;
  370.       state->dtxDecoderState->lsp_old[2] = 21000;
  371.       state->dtxDecoderState->lsp_old[3] = 15000;
  372.       state->dtxDecoderState->lsp_old[4] = 8000;
  373.       state->dtxDecoderState->lsp_old[5] = 0;
  374.       state->dtxDecoderState->lsp_old[6] = -8000;
  375.       state->dtxDecoderState->lsp_old[7] = -15000;
  376.       state->dtxDecoderState->lsp_old[8] = -21000;
  377.       state->dtxDecoderState->lsp_old[9] = -26000;
  378.       state->dtxDecoderState->lsf_hist_ptr = 0;
  379.       state->dtxDecoderState->log_pg_mean = 0;
  380.       state->dtxDecoderState->log_en_hist_ptr = 0;
  382.       /* initialize decoder lsf history */
  383.       state->dtxDecoderState->lsf_hist[0] = 1384;
  384.       state->dtxDecoderState->lsf_hist[1] = 2077;
  385.       state->dtxDecoderState->lsf_hist[2] = 3420;
  386.       state->dtxDecoderState->lsf_hist[3] = 5108;
  387.       state->dtxDecoderState->lsf_hist[4] = 6742;
  388.       state->dtxDecoderState->lsf_hist[5] = 8122;
  389.       state->dtxDecoderState->lsf_hist[6] = 9863;
  390.       state->dtxDecoderState->lsf_hist[7] = 11092;
  391.       state->dtxDecoderState->lsf_hist[8] = 12714;
  392.       state->dtxDecoderState->lsf_hist[9] = 13701;
  394.       for ( i = 1; i < DTX_HIST_SIZE; i++ ) {
  395.          memcpy( &state->dtxDecoderState->lsf_hist[M * i], &state->
  396.                dtxDecoderState->lsf_hist[0], M <<2 );
  397.       }
  398.       memset( state->dtxDecoderState->lsf_hist_mean, 0, M * DTX_HIST_SIZE <<2 );
  400.       /* initialize decoder log frame energy */
  401.       for ( i = 0; i < DTX_HIST_SIZE; i++ ) {
  402.          state->dtxDecoderState->log_en_hist[i] = state->dtxDecoderState->log_en
  403.          ;
  404.       }
  405.       state->dtxDecoderState->log_en_adjust = 0;
  406.       state->dtxDecoderState->dtxHangoverCount = DTX_HANG_CONST;
  407.       state->dtxDecoderState->decAnaElapsedCount = 31;
  408.       state->dtxDecoderState->sid_frame = 0;
  409.       state->dtxDecoderState->valid_data = 0;
  410.       state->dtxDecoderState->dtxHangoverAdded = 0;
  411.       state->dtxDecoderState->dtxGlobalState = DTX;
  412.       state->dtxDecoderState->data_updated = 0;
  413.    }
  414.    return;
  415. }
  418. /*
  419.  * rx_dtx_handler
  420.  *
  421.  *
  422.  * Parameters:
  423.  *    st->dtxGlobalState      I: DTX state
  424.  *    st->since_last_sid      B: Frames after last SID frame
  425.  *    st->data_updated        I: SID update flag
  426.  *    st->decAnaElapsedCount  B: state machine that synch with the GSMEFR txDtx machine
  427.  *    st->dtxHangoverAdded    B: DTX hangover
  428.  *    st->sid_frame           O: SID frame indicator
  429.  *    st->valid_data          O: Vaild data indicator
  430.  *    frame_type              O: Frame type
  431.  *
  432.  * Function:
  433.  *    Find the new DTX state
  434.  *
  435.  * Returns:
  436.  *    DTXStateType            DTX, DTX_MUTE or SPEECH
  437.  */
  438. static enum DTXStateType rx_dtx_handler( dtx_decState *st, enum RXFrameType frame_type )
  439. {
  440.    enum DTXStateType newState;
  441.    enum DTXStateType encState;
  443.    /* DTX if SID frame or previously in DTX{_MUTE} and (NO_RX OR BAD_SPEECH) */
  444.    if ( table_SID[frame_type] | ( ( st->dtxGlobalState != SPEECH ) &
  445.          table_speech_bad[frame_type] ) ) {
  446.       newState = DTX;
  448.       /* stay in mute for these input types */
  449.       if ( ( st->dtxGlobalState == DTX_MUTE ) & table_mute[frame_type] ) {
  450.          newState = DTX_MUTE;
  451.       }
  453.       /*
  454.        * evaluate if noise parameters are too old
  455.        * since_last_sid is reset when CN parameters have been updated
  456.        */
  457.       st->since_last_sid += 1;
  459.       /* no update of sid parameters in DTX for a long while */
  460.       if ((frame_type != RX_SID_UPDATE) & ( st->since_last_sid > DTX_MAX_EMPTY_THRESH )) {
  461.          newState = DTX_MUTE;
  462.       }
  463.    }
  464.    else {
  465.       newState = SPEECH;
  466.       st->since_last_sid = 0;
  467.    }
  469.    /*
  470.     * reset the decAnaElapsed Counter when receiving CNI data the first
  471.     * time, to robustify counter missmatch after handover
  472.     * this might delay the bwd CNI analysis in the new decoder slightly.
  473.     */
  474.    if ( ( st->data_updated == 0 ) & ( frame_type == RX_SID_UPDATE ) ) {
  475.       st->decAnaElapsedCount = 0;
  476.    }
  478.    /*
  479.     * update the SPE-SPD DTX hangover synchronization
  480.     * to know when SPE has added dtx hangover
  481.     */
  482.    st->decAnaElapsedCount += 1;
  483.    st->dtxHangoverAdded = 0;
  484.    encState = SPEECH;
  486.    if ( table_DTX[frame_type] ) {
  487.       encState = DTX;
  488.       if( ( frame_type == RX_NO_DATA ) & ( newState == SPEECH ) ) {
  489.          encState = SPEECH;
  490.       }
  491.    }
  493.    if ( encState == SPEECH ) {
  494.       st->dtxHangoverCount = DTX_HANG_CONST;
  495.    }
  496.    else {
  497.       if ( st->decAnaElapsedCount > DTX_ELAPSED_FRAMES_THRESH ) {
  498.          st->dtxHangoverAdded = 1;
  499.          st->decAnaElapsedCount = 0;
  500.          st->dtxHangoverCount = 0;
  501.       }
  502.       else if ( st->dtxHangoverCount == 0 ) {
  503.          st->decAnaElapsedCount = 0;
  504.       }
  505.       else {
  506.          st->dtxHangoverCount -= 1;
  507.       }
  508.    }
  510.    if ( newState != SPEECH ) {
  511.       /*
  512.        * DTX or DTX_MUTE
  513.        * CN data is not in a first SID, first SIDs are marked as SID_BAD
  514.        * but will do backwards analysis if a hangover period has been added
  515.        * according to the state machine above
  516.        */
  517.       st->sid_frame = 0;
  518.       st->valid_data = 0;
  520.       if ( frame_type == RX_SID_FIRST ) {
  521.          st->sid_frame = 1;
  522.       }
  523.       else if ( frame_type == RX_SID_UPDATE ) {
  524.          st->sid_frame = 1;
  525.          st->valid_data = 1;
  526.       }
  527.       else if ( frame_type == RX_SID_BAD ) {
  528.          st->sid_frame = 1;
  530.          /* use old data */
  531.          st->dtxHangoverAdded = 0;
  532.       }
  533.    }
  535.    /* newState is used by both SPEECH AND DTX synthesis routines */
  536.    return newState;
  537. }
  540. /*
  541.  * Lsf_lsp
  542.  *
  543.  *
  544.  * Parameters:
  545.  *    lsf               I: vector of LSFs
  546.  *    lsp               O: vector of LSPs
  547.  *
  548.  * Function:
  549.  *    Transformation lsf to lsp, order M
  550.  *
  551.  * Returns:
  552.  *    void
  553.  */
  554. static void Lsf_lsp( Word32 lsf[], Word32 lsp[] )
  555. {
  556.    Word32 i, ind, offset, tmp;
  559.    for ( i = 0; i < M; i++ ) {
  560.       /* ind = b8-b15 of lsf[i] */
  561.       ind = lsf[i] >> 8;
  563.       /* offset = b0-b7  of lsf[i] */
  564.       offset = lsf[i] & 0x00ff;
  566.       /* lsp[i] = table[ind]+ ((table[ind+1]-table[ind])*offset) / 256 */
  567.       tmp = ( ( cos_table[ind+1]-cos_table[ind] )*offset ) << 1;
  568.       lsp[i] = cos_table[ind] + ( tmp >> 9 );
  569.    }
  570.    return;
  571. }
  574. /*
  575.  * D_plsf_3
  576.  *
  577.  *
  578.  * Parameters:
  579.  *    st->past_lsf_q    I: Past dequantized LFSs
  580.  *    st->past_r_q      B: past quantized residual
  581.  *    mode              I: AMR mode
  582.  *    bfi               B: bad frame indicator
  583.  *    indice            I: quantization indices of 3 submatrices, Q0
  584.  *    lsp1_q            O: quantized 1st LSP vector
  585.  *
  586.  * Function:
  587.  *    Decodes the LSP parameters using the received quantization indices.
  588.  *    1st order MA prediction and split by 3 vector quantization (split-VQ)
  589.  *
  590.  * Returns:
  591.  *    void
  592.  */
  593. static void D_plsf_3( D_plsfState *st, enum Mode mode, Word16 bfi, Word16 *
  594.       indice, Word32 *lsp1_q )
  595. {
  596.    Word32 lsf1_r[M], lsf1_q[M];
  597.    Word32 i, index, temp;
  598.    const Word32 *p_cb1, *p_cb2, *p_cb3, *p_dico;
  601.    /* if bad frame */
  602.    if ( bfi != 0 ) {
  603.       /* use the past LSFs slightly shifted towards their mean */
  604.       for ( i = 0; i < M; i++ ) {
  605.          /* lsfi_q[i] = ALPHA*past_lsf_q[i] + ONE_ALPHA*meanLsf[i]; */
  606.          lsf1_q[i] = ( ( st->past_lsf_q[i] * ALPHA ) >> 15 ) + ( ( mean_lsf_3[i]
  607.                * ONE_ALPHA ) >> 15 );
  608.       }
  610.       /* estimate past quantized residual to be used in next frame */
  611.       if ( mode != MRDTX ) {
  612.          for ( i = 0; i < M; i++ ) {
  613.             /* temp  = meanLsf[i] +  pastR2_q[i] * pred_fac; */
  614.             temp = mean_lsf_3[i] + ( ( st->past_r_q[i] * pred_fac[i] ) >> 15 );
  615.             st->past_r_q[i] = lsf1_q[i] - temp;
  616.          }
  617.       }
  618.       else {
  619.          for ( i = 0; i < M; i++ ) {
  620.             /* temp  = meanLsf[i] +  pastR2_q[i]; */
  621.             temp = mean_lsf_3[i] + st->past_r_q[i];
  622.             st->past_r_q[i] = lsf1_q[i] - temp;
  623.          }
  624.       }
  625.    }
  627.    /* if good LSFs received */
  628.    else {
  629.       if ( ( mode == MR475 ) | ( mode == MR515 ) ) {
  630.          /* MR475, MR515 */
  631.          p_cb1 = dico1_lsf_3;
  632.          p_cb2 = dico2_lsf_3;
  633.          p_cb3 = mr515_3_lsf;
  634.       }
  635.       else if ( mode == MR795 ) {
  636.          /* MR795 */
  637.          p_cb1 = mr795_1_lsf;
  638.          p_cb2 = dico2_lsf_3;
  639.          p_cb3 = dico3_lsf_3;
  640.       }
  641.       else {
  642.          /* MR59, MR67, MR74, MR102, MRDTX */
  643.          p_cb1 = dico1_lsf_3;
  644.          p_cb2 = dico2_lsf_3;
  645.          p_cb3 = dico3_lsf_3;
  646.       }
  648.       /* decode prediction residuals from 3 received indices */
  649.       index = *indice++;
  650.       p_dico = &p_cb1[index + index + index];
  651.       index = *indice++;
  652.       lsf1_r[0] = *p_dico++;
  653.       lsf1_r[1] = *p_dico++;
  654.       lsf1_r[2] = *p_dico++;
  656.       if ( ( mode == MR475 ) | ( mode == MR515 ) ) {
  657.          /* MR475, MR515 only using every second entry */
  658.          index = index << 1;
  659.       }
  660.       p_dico = &p_cb2[index + index + index];
  661.       index = *indice++;
  662.       lsf1_r[3] = *p_dico++;
  663.       lsf1_r[4] = *p_dico++;
  664.       lsf1_r[5] = *p_dico++;
  665.       p_dico = &p_cb3[index << 2];
  666.       lsf1_r[6] = *p_dico++;
  667.       lsf1_r[7] = *p_dico++;
  668.       lsf1_r[8] = *p_dico++;
  669.       lsf1_r[9] = *p_dico++;
  671.       /* Compute quantized LSFs and update the past quantized residual */
  672.       if ( mode != MRDTX ) {
  673.          for ( i = 0; i < M; i++ ) {
  674.             lsf1_q[i] = lsf1_r[i] + ( mean_lsf_3[i] + ( ( st->past_r_q[i] *
  675.                   pred_fac[i] ) >> 15 ) );
  676.          }
  677.          memcpy( st->past_r_q, lsf1_r, M <<2 );
  678.       }
  679.       else {
  680.          for ( i = 0; i < M; i++ ) {
  681.             lsf1_q[i] = lsf1_r[i] + ( mean_lsf_3[i] + st->past_r_q[i] );
  682.          }
  683.          memcpy( st->past_r_q, lsf1_r, M <<2 );
  684.       }
  685.    }
  687.    /* verification that LSFs has minimum distance of LSF_GAP Hz */
  688.    temp = LSF_GAP;
  690.    for ( i = 0; i < M; i++ ) {
  691.       if ( lsf1_q[i] < temp ) {
  692.          lsf1_q[i] = temp;
  693.       }
  694.       temp = lsf1_q[i] + LSF_GAP;
  695.    }
  696.    memcpy( st->past_lsf_q, lsf1_q, M <<2 );
  698.    /*  convert LSFs to the cosine domain */
  699.    Lsf_lsp( lsf1_q, lsp1_q );
  700.    return;
  701. }
  704. /*
  705.  * pseudonoise
  706.  *
  707.  *
  708.  * Parameters:
  709.  *    shift_reg         B: Old CN generator shift register state
  710.  *    no_bits           I: Number of bits
  711.  *
  712.  * Function:
  713.  *    pseudonoise
  714.  *
  715.  * Returns:
  716.  *    noise_bits
  717.  */
  718. static Word32 pseudonoise( Word32 *shift_reg, Word32 no_bits )
  719. {
  720.    Word32 noise_bits, Sn, i;
  721.    Word32 s_reg;
  724.    s_reg = *shift_reg;
  725.    noise_bits = 0;
  727.    for ( i = 0; i < no_bits; i++ ) {
  728.       /* State n == 31 */
  729.       Sn = s_reg & 0x00000001L;
  731.       /* State n == 3 */
  732.       if ( s_reg & 0x10000000L ) {
  733.          Sn = Sn ^ 0x1L;
  734.       }
  735.       else {
  736.          Sn = Sn ^ 0x0L;
  737.       }
  738.       noise_bits = ( noise_bits << 1 ) | ( s_reg & 1 );
  739.       s_reg = s_reg >> 1;
  741.       if ( Sn & 1 ) {
  742.          s_reg = s_reg | 0x40000000L;
  743.       }
  744.    }
  745.    *shift_reg = s_reg;
  746.    return noise_bits;
  747. }
  750. /*
  751.  * Lsp_lsf
  752.  *
  753.  *
  754.  * Parameters:
  755.  *    lsp               I: LSP vector (range: -1<=val<1)
  756.  *    lsf               O: LSF vector Old CN generator shift register state
  757.  *
  758.  * Function:
  759.  *    Transformation lsp to lsf, LPC order M
  760.  *    lsf[i] = arccos(lsp[i])/(2*pi)
  761.  *
  762.  * Returns:
  763.  *    void
  764.  */
  765. static void Lsp_lsf( Word32 lsp[], Word32 lsf[] )
  766. {
  767.    Word32 i, ind = 63;   /* begin at end of table -1 */
  770.    for ( i = M - 1; i >= 0; i-- ) {
  771.       /* find value in table that is just greater than lsp[i] */
  772.       while ( cos_table[ind] < lsp[i] ) {
  773.          ind--;
  774.       }
  775.       lsf[i] = ( ( ( ( lsp[i] - cos_table[ind] ) * acos_slope[ind] ) + 0x800 )
  776.             >> 12 ) + ( ind << 8 );
  777.    }
  778.    return;
  779. }
  782. /*
  783.  * Reorder_lsf
  784.  *
  785.  *
  786.  * Parameters:
  787.  *    lsf            B: vector of LSFs (range: 0<=val<=0.5)
  788.  *    min_dist       I: minimum required distance
  789.  *
  790.  * Function:
  791.  *    Make sure that the LSFs are properly ordered and to keep a certain minimum
  792.  *    distance between adjacent LSFs. LPC order = M.
  793.  *
  794.  * Returns:
  795.  *    void
  796.  */
  797. static void Reorder_lsf( Word32 *lsf, Word32 min_dist )
  798. {
  799.    Word32 lsf_min, i;
  802.    lsf_min = min_dist;
  804.    for ( i = 0; i < M; i++ ) {
  805.       if ( lsf[i] < lsf_min ) {
  806.          lsf[i] = lsf_min;
  807.       }
  808.       lsf_min = lsf[i] + min_dist;
  809.    }
  810. }
  812. /* VC5.0 Global optimization does not work with this function */
  813. #if _MSC_VER == 1100
  814. #pragma optimize( "g", off )
  815. #endif
  816. /*
  817.  * Get_lsp_pol
  818.  *
  819.  *
  820.  * Parameters:
  821.  *    lsp               I: line spectral frequencies
  822.  *    f                 O: polynomial F1(z) or F2(z)
  823.  *
  824.  * Function:
  825.  *    Find the polynomial F1(z) or F2(z) from the LSPs.
  826.  *
  827.  *    F1(z) = product ( 1 - 2 lsp[i] z^-1 + z^-2 )
  828.  *             i=0,2,4,6,8
  829.  *    F2(z) = product   ( 1 - 2 lsp[i] z^-1 + z^-2 )
  830.  *             i=1,3,5,7,9
  831.  *
  832.  *    where lsp[] is the LSP vector in the cosine domain.
  833.  *
  834.  *    The expansion is performed using the following recursion:
  835.  *
  836.  *    f[0] = 1
  837.  *    b = -2.0 * lsp[0]
  838.  *    f[1] = b
  839.  *    for i=2 to 5 do
  840.  *       b = -2.0 * lsp[2*i-2];
  841.  *       f[i] = b*f[i-1] + 2.0*f[i-2];
  842.  *       for j=i-1 down to 2 do
  843.  *          f[j] = f[j] + b*f[j-1] + f[j-2];
  844.  *       f[1] = f[1] + b;
  845.  *
  846.  * Returns:
  847.  *    void
  848.  */
  849. static void Get_lsp_pol( Word32 *lsp, Word32 *f )
  850. {
  851.    volatile Word32 f0, f1, f2, f3, f4, f5;
  852.    Word32 l1, l2, l3, l4;
  855.    /* f[0] = 1.0; */
  856.    f0 = 16777216L;
  858.    /* f1 = *lsp * -1024; */
  859.    f1 = -lsp[0] << 10;
  860.    l1 = lsp[2];
  861.    l2 = lsp[4];
  862.    l3 = lsp[6];
  863.    l4 = lsp[8];
  864.    f2 = f0 << 1;
  865.    f2 -= ( ( ( f1 >> 16 ) * l1 ) + ( ( ( f1 & 0xFFFE ) * l1 ) >> 16 ) ) << 2;
  866.    f1 -= l1 << 10;
  867.    f3 = f1 << 1;
  868.    f3 -= ( ( ( f2 >> 16 ) * l2 ) + ( ( ( f2 & 0xFFFE ) * l2 ) >> 16 ) ) << 2;
  869.    f2 += f0;
  870.    f2 -= ( ( ( f1 >> 16 ) * l2 ) + ( ( ( f1 & 0xFFFE ) * l2 ) >> 16 ) ) << 2;
  871.    f1 -= l2 << 10;
  872.    f4 = f2 << 1;
  873.    f4 -= ( ( ( f3 >> 16 ) * l3 ) + ( ( ( f3 & 0xFFFE ) * l3 ) >> 16 ) ) << 2;
  874.    f3 += f1;
  875.    f3 -= ( ( ( f2 >> 16 ) * l3 ) + ( ( ( f2 & 0xFFFE ) * l3 ) >> 16 ) ) << 2;
  876.    f2 += f0;
  877.    f2 -= ( ( ( f1 >> 16 ) * l3 ) + ( ( ( f1 & 0xFFFE ) * l3 ) >> 16 ) ) << 2;
  878.    f1 -= l3 << 10;
  879.    f5 = f3 << 1;
  880.    f5 -= ( ( ( f4 >> 16 ) * l4 ) + ( ( ( f4 & 0xFFFE ) * l4 ) >> 16 ) ) << 2;
  881.    f4 += f2;
  882.    f4 -= ( ( ( f3 >> 16 ) * l4 ) + ( ( ( f3 & 0xFFFE ) * l4 ) >> 16 ) ) << 2;
  883.    f3 += f1;
  884.    f3 -= ( ( ( f2 >> 16 ) * l4 ) + ( ( ( f2 & 0xFFFE ) * l4 ) >> 16 ) ) << 2;
  885.    f2 += f0;
  886.    f2 -= ( ( ( f1 >> 16 ) * l4 ) + ( ( ( f1 & 0xFFFE ) * l4 ) >> 16 ) ) << 2;
  887.    f1 -= l4 << 10;
  888.    f[0] = f0;
  889.    f[1] = f1;
  890.    f[2] = f2;
  891.    f[3] = f3;
  892.    f[4] = f4;
  893.    f[5] = f5;
  894.    return;
  895. }
  896. #if _MSC_VER == 1100
  897. #pragma optimize( "", on )
  898. #endif
  901. /*
  902.  * Lsp_Az
  903.  *
  904.  *
  905.  * Parameters:
  906.  *    lsp                 I: Line spectral frequencies
  907.  *    a                   O: Predictor coefficients
  908.  *
  909.  * Function:
  910.  *    Converts from the line spectral pairs (LSP) to LP coefficients,
  911.  *    for a 10th order filter.
  912.  *
  913.  *    Find the coefficients of F1(z) and F2(z)
  914.  *    Multiply F1(z) by 1+z^{-1} and F2(z) by 1-z^{-1}
  915.  *    A(z) = ( F1(z) + F2(z) ) / 2
  916.  *
  917.  * Returns:
  918.  *    void
  919.  */
  920. static void Lsp_Az( Word32 lsp[], Word32 a[] )
  921. {
  922.    Word32 f1[6], f2[6];
  923.    Word32 T0, i, j;
  926.    Get_lsp_pol( &lsp[0], f1 );
  927.    Get_lsp_pol( &lsp[1], f2 );
  929.    for ( i = 5; i > 0; i-- ) {
  930.       f1[i] += f1[i - 1];
  931.       f2[i] -= f2[i - 1];
  932.    }
  933.    a[0] = 4096;
  935.    for ( i = 1, j = 10; i <= 5; i++, j-- ) {
  936.       T0 = f1[i] + f2[i];
  937.       a[i] = (Word16)(T0 >> 13);  /* emulate fixed point bug */
  938.       if ( ( T0 & 4096 ) != 0 ) {
  939.          a[i]++;
  940.       }
  941.       T0 = f1[i] - f2[i];
  942.       a[j] = (Word16)(T0 >> 13);   /* emulate fixed point bug */
  944.       if ( ( T0 & 4096 ) != 0 ) {
  945.          a[j]++;
  946.       }
  947.    }
  948.    return;
  949. }
  952. /*
  953.  * A_Refl
  954.  *
  955.  *
  956.  * Parameters:
  957.  *    a                 I: Directform coefficients
  958.  *    refl              O: Reflection coefficients
  959.  *
  960.  * Function:
  961.  *    Converts from the directform coefficients to reflection coefficients
  962.  *
  963.  * Returns:
  964.  *    void
  965.  */
  966. static void A_Refl( Word32 a[], Word32 refl[] )
  967. {
  968.    /* local variables */
  969.    int normShift;
  970.    Word32 aState[M], bState[M];
  971.    Word32 normProd, acc, temp, mult, scale, i, j;
  974.    /* initialize states */
  975.    memcpy( aState, a, M <<2 );
  977.    /* backward Levinson recursion */
  978.    for ( i = M - 1; i >= 0; i-- ) {
  979.       if ( labs( aState[i] ) >= 4096 ) {
  980.          goto ExitRefl;
  981.       }
  982.       refl[i] = aState[i] << 3;
  983.       temp = ( refl[i] * refl[i] ) << 1;
  984.       acc = ( MAX_32 - temp );
  985.       normShift=0;
  986.       if (acc != 0){
  987.          temp = acc;
  988.          while (!(temp & 0x40000000))
  989.          {
  990.             normShift++;
  991.             temp = temp << 1;
  992.          }
  993.       }
  994.       else{
  995.          normShift = 0;
  996.       }
  997.       scale = 15 - normShift;
  998.       acc = ( acc << normShift );
  999.       temp = ( acc + ( Word32 )0x00008000L );
  1001.       if ( temp > 0 ) {
  1002.          normProd = temp >> 16;
  1003.          mult = 0x20000000L / normProd;
  1004.       }
  1005.       else
  1006.          mult = 16384;
  1008.       for ( j = 0; j < i; j++ ) {
  1009.          acc = aState[j] << 16;
  1010.          acc -= ( refl[i] * aState[i - j - 1] ) << 1;
  1011.          temp = ( acc + ( Word32 )0x00008000L ) >> 16;
  1012.          temp = ( mult * temp ) << 1;
  1014.          if ( scale > 0 ) {
  1015.             if ( ( temp & ( ( Word32 )1 << ( scale - 1 ) ) ) != 0 ) {
  1016.                temp = ( temp >> scale ) + 1;
  1017.             }
  1018.             else
  1019.                temp = ( temp >> scale );
  1020.          }
  1021.          else
  1022.             temp = ( temp >> scale );
  1024.          if ( labs( temp ) > 32767 ) {
  1025.             goto ExitRefl;
  1026.          }
  1027.          bState[j] = temp;
  1028.       }
  1029.       memcpy( aState, bState, i <<2 );
  1030.    }
  1031.    return;
  1032. ExitRefl:
  1033.    memset( refl, 0, M <<2 );
  1034. }
  1037. /*
  1038.  * Log2_norm
  1039.  *
  1040.  *
  1041.  * Parameters:
  1042.  *    x                 I: input value
  1043.  *    exp               I: exponent
  1044.  *    exponent          O: Integer part of Log2. (range: 0<=val<=30)
  1045.  *    fraction          O: Fractional part of Log2. (range: 0<=val<1)
  1046.  *
  1047.  * Function:
  1048.  *    Computes log2
  1049.  *
  1050.  *    Computes log2(L_x, exp),  where   L_x is positive and
  1051.  *    normalized, and exp is the normalisation exponent
  1052.  *    If L_x is negative or zero, the result is 0.
  1053.  *
  1054.  *    The function Log2(L_x) is approximated by a table and linear
  1055.  *    interpolation. The following steps are used to compute Log2(L_x)
  1056.  *
  1057.  *    exponent = 30-normExponent
  1058.  *    i = bit25-b31 of L_x;  32<=i<=63  (because of normalization).
  1059.  *    a = bit10-b24
  1060.  *    i -=32
  1061.  *    fraction = table[i]<<16 - (table[i] - table[i+1]) * a * 2
  1062.  *
  1063.  * Returns:
  1064.  *    void
  1065.  */
  1066. static void Log2_norm( Word32 x, Word32 exp, Word32 *exponent, Word32 *
  1067.       fraction )
  1068. {
  1069.    Word32 y, i, a;
  1072.    if ( x <= 0 ) {
  1073.       *exponent = 0;
  1074.       *fraction = 0;
  1075.       return;
  1076.    }
  1078.    /* Extract b25-b31 */
  1079.    i = x >> 25;
  1080.    i = i - 32;
  1082.    /* Extract b10-b24 of fraction */
  1083.    a = x >> 9;
  1084.    a = a & 0xFFFE;   /* 2a */
  1086.    /* fraction */
  1087.    y = ( log2_table[i] << 16 ) - a * ( log2_table[i] - log2_table[i + 1] );
  1088.    *fraction = y >> 16;
  1089.    *exponent = 30 - exp;
  1090.    return;
  1091. }
  1094. /*
  1095.  * Log2
  1096.  *
  1097.  *
  1098.  * Parameters:
  1099.  *    x                 I: input value
  1100.  *    exponent          O: Integer part of Log2. (range: 0<=val<=30)
  1101.  *    fraction          O: Fractional part of Log2. (range: 0<=val<1)
  1102.  *
  1103.  * Function:
  1104.  *    Computes log2(L_x)
  1105.  *    If x is negative or zero, the result is 0.
  1106.  *
  1107.  * Returns:
  1108.  *    void
  1109.  */
  1110. static void Log2( Word32 x, Word32 *exponent, Word32 *fraction )
  1111. {
  1112.    int tmp, exp=0;
  1114.    if (x != 0){
  1115.          tmp = x;
  1116.          while (!((tmp & 0x80000000) ^ ((tmp & 0x40000000) << 1)))
  1117.          {
  1118.             exp++;
  1119.             tmp = tmp << 1;
  1120.          }
  1121.       }
  1122.    Log2_norm( x <<exp, exp, exponent, fraction );
  1123. }
  1126. /*
  1127.  * Pow2
  1128.  *
  1129.  *
  1130.  * Parameters:
  1131.  *    exponent          I: Integer part. (range: 0<=val<=30)
  1132.  *    fraction          O: Fractional part. (range: 0.0<=val<1.0)
  1133.  *
  1134.  * Function:
  1135.  *    pow(2.0, exponent.fraction)
  1136.  *
  1137.  *    The function Pow2(L_x) is approximated by a table and linear interpolation.
  1138.  *
  1139.  *    i = bit10-b15 of fraction, 0 <= i <= 31
  1140.  *    a = biT0-b9   of fraction
  1141.  *    x = table[i]<<16 - (table[i] - table[i+1]) * a * 2
  1142.  *    x = L_x >> (30-exponent) (with rounding)
  1143.  *
  1144.  * Returns:
  1145.  *    result (range: 0<=val<=0x7fffffff)
  1146.  */
  1147. static Word32 Pow2( Word32 exponent, Word32 fraction )
  1148. {
  1149.    Word32 i, a, tmp, x, exp;
  1152.    /* Extract b10-b16 of fraction */
  1153.    i = fraction >> 10;
  1155.    /* Extract b0-b9 of fraction */
  1156.    a = ( fraction << 5 ) & 0x7fff;
  1158.    /* table[i] << 16 */
  1159.    x = pow2_table[i] << 16;
  1161.    /* table[i] - table[i+1] */
  1162.    tmp = pow2_table[i] - pow2_table[i + 1];
  1164.    /* L_x -= tmp*a*2 */
  1165.    x -= ( tmp * a ) << 1;
  1167.    if ( exponent >= -1 ) {
  1168.       exp = ( 30 - exponent );
  1170.       /* Rounding */
  1171.       if ( ( x & ( ( Word32 )1 << ( exp - 1 ) ) ) != 0 ) {
  1172.          x = ( x >> exp ) + 1;
  1173.       }
  1174.       else
  1175.          x = x >> exp;
  1176.    }
  1177.    else
  1178.       x = 0;
  1179.    return( x );
  1180. }
  1183. /*
  1184.  * Build_CN_code
  1185.  *
  1186.  *
  1187.  * Parameters:
  1188.  *    seed              B: Old CN generator shift register state
  1189.  *    cod               O: Generated CN fixed codebook vector
  1190.  *
  1191.  * Function:
  1192.  *    Generate CN fixed codebook vector
  1193.  *
  1194.  * Returns:
  1195.  *    void
  1196.  */
  1197. static void Build_CN_code( Word32 *seed, Word32 cod[] )
  1198. {
  1199.    Word32 i, j, k;
  1202.    memset( cod, 0, L_SUBFR <<2 );
  1204.    for ( k = 0; k < 10; k++ ) {
  1205.       i = pseudonoise( seed, 2 );   /* generate pulse position */
  1206.       i = ( i * 20 ) >> 1;
  1207.       i = ( i + k );
  1208.       j = pseudonoise( seed, 1 );   /* generate sign           */
  1210.       if ( j > 0 ) {
  1211.          cod[i] = 4096;
  1212.       }
  1213.       else {
  1214.          cod[i] = -4096;
  1215.       }
  1216.    }
  1217.    return;
  1218. }
  1221. /*
  1222.  * Build_CN_param
  1223.  *
  1224.  *
  1225.  * Parameters:
  1226.  *    seed              B: Old CN generator shift register state
  1227.  *    nParam            I: number of params
  1228.  *    paramSizeTable    I: size of params
  1229.  *    parm              O: CN Generated params
  1230.  *
  1231.  * Function:
  1232.  *    Generate parameters for comfort noise generation
  1233.  *
  1234.  * Returns:
  1235.  *    void
  1236.  */
  1237. static void Build_CN_param( Word16 *seed, enum Mode mode, Word16 parm[] )
  1238. {
  1239.    Word32 i;
  1240.    const Word32 *p;
  1243.    *seed = ( Word16 )( ( *seed * 31821 ) + 13849L );
  1244.    p = &window_200_40[ * seed & 0x7F];
  1246.    switch ( mode ) {
  1247.       case MR122:
  1248.          for ( i = 0; i < PRMNO_MR122; i++ ) {
  1249.             parm[i] = ( Word16 )( *p++ & ~( 0xFFFF << bitno_MR122[i] ) );
  1250.          }
  1251.          break;
  1253.       case MR102:
  1254.          for ( i = 0; i < PRMNO_MR102; i++ ) {
  1255.             parm[i] = ( Word16 )( *p++ & ~( 0xFFFF << bitno_MR102[i] ) );
  1256.          }
  1257.          break;
  1259.       case MR795:
  1260.          for ( i = 0; i < PRMNO_MR795; i++ ) {
  1261.             parm[i] = ( Word16 )( *p++ & ~( 0xFFFF << bitno_MR795[i] ) );
  1262.          }
  1263.          break;
  1265.       case MR74:
  1266.          for ( i = 0; i < PRMNO_MR74; i++ ) {
  1267.             parm[i] = ( Word16 )( *p++ & ~( 0xFFFF << bitno_MR74[i] ) );
  1268.          }
  1269.          break;
  1271.       case MR67:
  1272.          for ( i = 0; i < PRMNO_MR67; i++ ) {
  1273.             parm[i] = ( Word16 )( *p++ & ~( 0xFFFF << bitno_MR67[i] ) );
  1274.          }
  1275.          break;
  1277.       case MR59:
  1278.          for ( i = 0; i < PRMNO_MR59; i++ ) {
  1279.             parm[i] = ( Word16 )( *p++ & ~( 0xFFFF << bitno_MR59[i] ) );
  1280.          }
  1281.          break;
  1283.       case MR515:
  1284.          for ( i = 0; i < PRMNO_MR515; i++ ) {
  1285.             parm[i] = ( Word16 )( *p++ & ~( 0xFFFF << bitno_MR515[i] ) );
  1286.          }
  1287.          break;
  1289.       case MR475:
  1290.          for ( i = 0; i < PRMNO_MR475; i++ ) {
  1291.             parm[i] = ( Word16 )( *p++ & ~( 0xFFFF << bitno_MR475[i] ) );
  1292.          }
  1293.          break;
  1294.    }
  1295. }
  1298. /*
  1299.  * Syn_filt
  1300.  *
  1301.  *
  1302.  * Parameters:
  1303.  *    a                 I: prediction coefficients [M+1]
  1304.  *    x                 I: input signal
  1305.  *    y                 O: output signal
  1306.  *    lg                I: size of filtering
  1307.  *    mem               B: memory associated with this filtering
  1308.  *    update            I: 0=no update, 1=update of memory.
  1309.  *
  1310.  * Function:
  1311.  *    Perform synthesis filtering through 1/A(z).
  1312.  *
  1313.  * Returns:
  1314.  *    void
  1315.  */
  1316. static Word32 Syn_filt( Word32 a[], Word32 x[], Word32 y[], Word32 lg, Word32 mem[]
  1317.       , Word32 update )
  1318. {
  1319.    Word32 tmp[50];   /* malloc is slow */
  1320.    Word32 s, a0, overflow = 0;
  1321.    Word32 *yy, *yy_limit;
  1324.    /* Copy mem[] to yy[] */
  1325.    memcpy( tmp, mem, 40 );
  1326.    yy = tmp + M;
  1327.    yy_limit = yy + lg;
  1328.    a0 = a[0];
  1330.    /* Do the filtering. */
  1331.    while ( yy < yy_limit ) {
  1333.       s = *x++ * a0;
  1334.       s -= yy[-1] * a[1];
  1335.       s -= yy[-2] * a[2];
  1336.       s -= yy[-3] * a[3];
  1337.       s -= yy[-4] * a[4];
  1338.       s -= yy[-5] * a[5];
  1339.       s -= yy[-6] * a[6];
  1340.       s -= yy[-7] * a[7];
  1341.       s -= yy[-8] * a[8];
  1342.       s -= yy[-9] * a[9];
  1343.       s -= yy[-10] * a[10];
  1344.       if ( labs( s ) < 0x7ffffff )
  1345.          *yy = ( s + 0x800L ) >> 12;
  1346.       else if ( s > 0 ) {
  1347.          *yy = 32767;
  1348.          overflow = 1;
  1349.       }
  1350.       else {
  1351.          *yy = -32768;
  1352.          overflow = 1;
  1353.       }
  1354.       yy++;
  1355.    }
  1356.    memcpy( y, &tmp[M], lg <<2 );
  1358.    /* Update of memory if update==1 */
  1359.    if ( update ) {
  1360.       memcpy( mem, &y[lg - M], 40 );
  1361.    }
  1362.    return overflow;
  1363. }
  1365. /*
  1366.  * Syn_filt_overflow
  1367.  *
  1368.  *
  1369.  * Parameters:
  1370.  *    a                 I: prediction coefficients [M+1]
  1371.  *    x                 I: input signal
  1372.  *    y                 O: output signal
  1373.  *    lg                I: size of filtering
  1374.  *    mem               B: memory associated with this filtering
  1375.  *    update            I: 0=no update, 1=update of memory.
  1376.  *
  1377.  * Function:
  1378.  *    Perform synthesis filtering through 1/A(z).
  1379.  *    Saturate after every multiplication.
  1380.  * Returns:
  1381.  *    void
  1382.  */
  1383. static void Syn_filt_overflow( Word32 a[], Word32 x[], Word32 y[], Word32 lg, Word32 mem[]
  1384.       , Word32 update )
  1385. {
  1386.    Word32 tmp[50];   /* malloc is slow */
  1387.    Word32 i, j, s, a0;
  1388.    Word32 *yy;
  1391.    /* Copy mem[] to yy[] */
  1392.    memcpy( tmp, mem, 40 );
  1393.    yy = tmp + M;
  1394.    a0 = a[0];
  1396.    /* Do the filtering. */
  1397.    for ( i = 0; i < lg; i++ ) {
  1398.       s = x[i] * a0;
  1400.       for ( j = 1; j <= M; j++ ) {
  1401.          s -= a[j] * yy[ - j];
  1402.          if (s > 1073741823){
  1403.             s = 1073741823;
  1404.          }
  1405.          else if ( s < -1073741824) {
  1406.             s = -1073741824;
  1407.          }
  1408.       }
  1410.       if ( labs( s ) < 0x7FFE800 )
  1411.          *yy = ( s + 0x800L ) >> 12;
  1412.       else if ( s > 0 ) {
  1413.          *yy = 32767;
  1414.       }
  1415.       else {
  1416.          *yy = -32768;
  1417.       }
  1418.       yy++;
  1419.    }
  1420.    memcpy( y, &tmp[M], lg <<2 );
  1422.    /* Update of memory if update==1 */
  1423.    if ( update ) {
  1424.       memcpy( mem, &y[lg - M], 40 );
  1425.    }
  1426.    return;
  1427. }
  1429. /*
  1430.  * dtx_dec
  1431.  *
  1432.  *
  1433.  * Parameters:
  1434.  *    st                            B: DTX state struct
  1435.  *    mem_syn                       I: AMR decoder state
  1436.  *    lsfState                      B: LSF state struct
  1437.  *    pred_state->past_qua_en       O: table of past quantized energies
  1438.  *    pred_state->past_qua_en_MR122 O: table of past quantized energies MR122
  1439.  *    averState->hangVar            O:
  1440.  *    averState->hangCount          O: hangover variable
  1441.  *    new_state                     I: new DTX state
  1442.  *    mode                          I: AMR mode
  1443.  *    parm                          I: vector of synthesis parameters
  1444.  *    synth                         O: synthesised speech
  1445.  *    A_t                           O: decoded LP filter in 4 subframes
  1446.  *
  1447.  * Function:
  1448.  *    DTX
  1449.  *
  1450.  * Returns:
  1451.  *    void
  1452.  */
  1453. static void dtx_dec( dtx_decState *st, Word32 *mem_syn, D_plsfState *lsfState,
  1454.       gc_predState *pred_state, Cb_gain_averageState *averState, enum
  1455.       DTXStateType new_state, enum Mode mode, Word16 parm[], Word32 synth[],
  1456.       Word32 A_t[] )
  1457. {
  1458.    Word32 ex[L_SUBFR], acoeff[11], acoeff_variab[M + 1], lsp_int[M];
  1459.    Word32 refl[M], lsf[M], lsf_int[M], lsf_int_variab[M], lsp_int_variab[M];
  1460.    Word32 i, j, int_fac, log_en_int, pred_err, log_pg_e, log_pg_m, log_pg;
  1461.    Word32 negative, lsf_mean, lsf_variab_index, lsf_variab_factor, ptr;
  1462.    Word16 log_en_index, log_en_int_e, log_en_int_m, level, ma_pred_init,
  1463.          tmp_int_length;
  1466.    if ( ( st->dtxHangoverAdded != 0 ) & ( st->sid_frame != 0 ) ) {
  1467.       /*
  1468.        * sidFirst after dtx hangover period
  1469.        * or sidUpd after dtxhangover
  1470.        */
  1471.       /* set log_en_adjust to correct value */
  1472.       st->log_en_adjust = dtx_log_en_adjust[mode];
  1473.       ptr = st->lsf_hist_ptr + M;
  1475.       if ( ptr == 80 ) {
  1476.          ptr = 0;
  1477.       }
  1478.       memcpy( &st->lsf_hist[ptr], &st->lsf_hist[st->lsf_hist_ptr], M <<2 );
  1479.       ptr = st->log_en_hist_ptr + 1;
  1481.       if ( ptr == DTX_HIST_SIZE ) {
  1482.          ptr = 0;
  1483.       }
  1484.       st->log_en_hist[ptr] = st->log_en_hist[st->log_en_hist_ptr];   /* Q11 */
  1486.       /*
  1487.        * compute mean log energy and lsp
  1488.        * from decoded signal (SID_FIRST)
  1489.        */
  1490.       st->log_en = 0;
  1491.       memset( lsf, 0, M <<2 );
  1493.       /* average energy and lsp */
  1494.       for ( i = 0; i < DTX_HIST_SIZE; i++ ) {
  1495.          st->log_en = st->log_en + ( st->log_en_hist[i] >> 3 );
  1497.          for ( j = 0; j < M; j++ ) {
  1498.             lsf[j] += st->lsf_hist[i * M + j];
  1499.          }
  1500.       }
  1502.       for ( j = 0; j < M; j++ ) {
  1503.          lsf[j] = lsf[j] >> 3;   /* divide by 8 */
  1504.       }
  1505.       Lsf_lsp( lsf, st->lsp );
  1507.       /*
  1508.        * make log_en speech coder mode independent
  1509.        * added again later before synthesis
  1510.        */
  1511.       st->log_en = st->log_en - st->log_en_adjust;
  1513.       /* compute lsf variability vector */
  1514.       memcpy( st->lsf_hist_mean, st->lsf_hist, 80 <<2 );
  1516.       for ( i = 0; i < M; i++ ) {
  1517.          lsf_mean = 0;
  1519.          /* compute mean lsf */
  1520.          for ( j = 0; j < 8; j++ ) {
  1521.             lsf_mean += st->lsf_hist_mean[i + j * M];
  1522.          }
  1523.          lsf_mean = lsf_mean >> 3;
  1525.          /*
  1526.           * subtract mean and limit to within reasonable limits
  1527.           * moreover the upper lsf's are attenuated
  1528.           */
  1529.          for ( j = 0; j < 8; j++ ) {
  1530.             /* subtract mean */
  1531.             st->lsf_hist_mean[i + j * M] = st->lsf_hist_mean[i + j * M] -
  1532.                   lsf_mean;
  1534.             /* attenuate deviation from mean, especially for upper lsf's */
  1535.             st->lsf_hist_mean[i + j * M] = ( st->lsf_hist_mean[i + j * M] *
  1536.                   lsf_hist_mean_scale[i] ) >> 15;
  1538.             /* limit the deviation */
  1539.             if ( st->lsf_hist_mean[i + j * M] < 0 ) {
  1540.                negative = 1;
  1541.             }
  1542.             else {
  1543.                negative = 0;
  1544.             }
  1545.             st->lsf_hist_mean[i + j * M] = labs( st->lsf_hist_mean[i + j * M] );
  1547.             /* apply soft limit */
  1548.             if ( st->lsf_hist_mean[i + j * M] > 655 ) {
  1549.                st->lsf_hist_mean[i + j * M] = 655 + ( ( st->lsf_hist_mean[i + j
  1550.                      * M] - 655 ) >> 2 );
  1551.             }
  1553.             /* apply hard limit */
  1554.             if ( st->lsf_hist_mean[i + j * M] > 1310 ) {
  1555.                st->lsf_hist_mean[i + j * M] = 1310;
  1556.             }
  1558.             if ( negative != 0 ) {
  1559.                st->lsf_hist_mean[i + j * M] = -st->lsf_hist_mean[i + j * M];
  1560.             }
  1561.          }
  1562.       }
  1563.    }
  1565.    if ( st->sid_frame != 0 ) {
  1566.       /*
  1567.        * Set old SID parameters, always shift
  1568.        * even if there is no new valid_data
  1569.        */
  1570.       memcpy( st->lsp_old, st->lsp, M <<2 );
  1571.       st->old_log_en = st->log_en;
  1573.       if ( st->valid_data != 0 ) /* new data available (no CRC) */ {
  1574.       /* Compute interpolation factor, since the division only works
  1575.        * for values of since_last_sid < 32 we have to limit the
  1576.        * interpolation to 32 frames
  1577.        */
  1578.          tmp_int_length = st->since_last_sid;
  1579.          st->since_last_sid = 0;
  1581.          if ( tmp_int_length > 32 ) {
  1582.             tmp_int_length = 32;
  1583.          }
  1585.          if ( tmp_int_length >= 2 ) {
  1586.             st->true_sid_period_inv = 0x2000000 / ( tmp_int_length
  1587.                   << 10 );
  1588.          }
  1589.          else {
  1590.             st->true_sid_period_inv = 16384;   /* 0.5 it Q15 */
  1591.          }
  1592.          memcpy( lsfState->past_r_q, &past_rq_init[parm[0] * M], M <<2 );
  1593.          D_plsf_3( lsfState, MRDTX, 0, &parm[1], st->lsp );
  1595.          /* reset for next speech frame */
  1596.          memset( lsfState->past_r_q, 0, M <<2 );
  1597.          log_en_index = parm[4];
  1599.          /* Q11 and divide by 4 */
  1600.          st->log_en = ( Word16 )( log_en_index << 9 );
  1602.          /* Subtract 2.5 in Q11 */
  1603.          st->log_en = ( Word16 )( st->log_en - 5120 );
  1605.          /* Index 0 is reserved for silence */
  1606.          if ( log_en_index == 0 ) {
  1607.             st->log_en = MIN_16;
  1608.          }
  1610.          /*
  1611.           * no interpolation at startup after coder reset
  1612.           * or when SID_UPD has been received right after SPEECH
  1613.           */
  1614.          if ( ( st->data_updated == 0 ) || ( st->dtxGlobalState == SPEECH ) ) {
  1615.             memcpy( st->lsp_old, st->lsp, M <<2 );
  1616.             st->old_log_en = st->log_en;
  1617.          }
  1618.       }   /* endif valid_data */
  1620.       /* initialize gain predictor memory of other modes */
  1621.       ma_pred_init = ( Word16 )( ( st->log_en >> 1 ) - 9000 );
  1623.       if ( ma_pred_init > 0 ) {
  1624.          ma_pred_init = 0;
  1625.       }
  1627.       if ( ma_pred_init < - 14436 ) {
  1628.          ma_pred_init = -14436;
  1629.       }
  1630.       pred_state->past_qua_en[0] = ma_pred_init;
  1631.       pred_state->past_qua_en[1] = ma_pred_init;
  1632.       pred_state->past_qua_en[2] = ma_pred_init;
  1633.       pred_state->past_qua_en[3] = ma_pred_init;
  1635.       /* past_qua_en for other modes than MR122 */
  1636.       ma_pred_init = ( Word16 )( ( 5443*ma_pred_init ) >> 15 );
  1638.       /* scale down by factor 20*log10(2) in Q15 */
  1639.       pred_state->past_qua_en_MR122[0] = ma_pred_init;
  1640.       pred_state->past_qua_en_MR122[1] = ma_pred_init;
  1641.       pred_state->past_qua_en_MR122[2] = ma_pred_init;
  1642.       pred_state->past_qua_en_MR122[3] = ma_pred_init;
  1643.    }   /* endif sid_frame */
  1645.    /*
  1646.     * CN generation
  1647.     * recompute level adjustment factor Q11
  1648.     * st->log_en_adjust = 0.9*st->log_en_adjust +
  1649.     *                     0.1*dtx_log_en_adjust[mode]);
  1650.     */
  1651.    st->log_en_adjust = ( Word16 )( ( ( st->log_en_adjust * 29491 ) >> 15 ) + ( (
  1652.          ( dtx_log_en_adjust[mode] << 5 ) * 3277 ) >> 20 ) );
  1654.    /* Interpolate SID info */
  1655.    /* Q10 */
  1656.    if ( st->since_last_sid > 30 )
  1657.       int_fac = 32767;
  1658.    else
  1659.       int_fac = ( Word16 )( (st->since_last_sid + 1) << 10 );
  1661.    /* Q10 * Q15 -> Q10 */
  1662.    int_fac = ( int_fac * st->true_sid_period_inv ) >> 15;
  1664.    /* Maximize to 1.0 in Q10 */
  1665.    if ( int_fac > 1024 ) {
  1666.       int_fac = 1024;
  1667.    }
  1669.    /* Q10 -> Q14 */
  1670.    int_fac = ( Word16 )( int_fac << 4 );
  1672.    /* Q14 * Q11->Q26 */
  1673.    log_en_int = ( int_fac * st->log_en ) << 1;
  1675.    for ( i = 0; i < M; i++ ) {
  1676.       /* Q14 * Q15 -> Q14 */
  1677.       lsp_int[i] = ( int_fac * st->lsp[i] ) >> 15;
  1678.    }
  1680.    /* 1-k in Q14 */
  1681.    int_fac = 16384 - int_fac;
  1683.    /* (Q14 * Q11 -> Q26) + Q26 -> Q26 */
  1684.    log_en_int += ( int_fac * st->old_log_en ) << 1;
  1686.    for ( i = 0; i < M; i++ ) {
  1687.       /* Q14 + (Q14 * Q15 -> Q14) -> Q14 */
  1688.       lsp_int[i] = lsp_int[i] + ( ( int_fac * st->lsp_old[i] ) >> 15 );
  1690.       /* Q14 -> Q15 */
  1691.       lsp_int[i] = lsp_int[i] << 1;
  1692.    }
  1694.    /* compute the amount of lsf variability */
  1695.    /* -0.6 in Q12 */
  1696.    lsf_variab_factor = st->log_pg_mean - 2457;
  1698.    /* *0.3 Q12*Q15 -> Q12 */
  1699.    lsf_variab_factor = 4096 - ( ( lsf_variab_factor * 9830 ) >> 15 );
  1701.    /* limit to values between 0..1 in Q12 */
  1702.    if ( lsf_variab_factor >= 4096 ) {
  1703.       lsf_variab_factor = 32767;
  1704.    }
  1705.    else if ( lsf_variab_factor < 0 ) {
  1706.       lsf_variab_factor = 0;
  1707.    }
  1708.    else
  1709.       lsf_variab_factor = lsf_variab_factor << 3;   /* -> Q15 */
  1711.    /* get index of vector to do variability with */
  1712.    lsf_variab_index = pseudonoise( &st->pn_seed_rx, 3 );
  1714.    /* convert to lsf */
  1715.    Lsp_lsf( lsp_int, lsf_int );
  1717.    /* apply lsf variability */
  1718.    memcpy( lsf_int_variab, lsf_int, M <<2 );
  1720.    for ( i = 0; i < M; i++ ) {
  1721.       lsf_int_variab[i] = lsf_int_variab[i] + ( ( lsf_variab_factor * st->
  1722.             lsf_hist_mean[i + lsf_variab_index * M] ) >> 15 );
  1723.    }
  1725.    /* make sure that LSP's are ordered */
  1726.    Reorder_lsf( lsf_int, LSF_GAP );
  1727.    Reorder_lsf( lsf_int_variab, LSF_GAP );
  1729.    /* copy lsf to speech decoders lsf state */
  1730.    memcpy( lsfState->past_lsf_q, lsf_int, M <<2 );
  1732.    /* convert to lsp */
  1733.    Lsf_lsp( lsf_int, lsp_int );
  1734.    Lsf_lsp( lsf_int_variab, lsp_int_variab );
  1736.      /* Compute acoeffs Q12 acoeff is used for level
  1737.       * normalization and Post_Filter, acoeff_variab is
  1738.       * used for synthesis filter
  1739.       * by doing this we make sure that the level
  1740.       * in high frequenncies does not jump up and down
  1741.       */
  1742.    Lsp_Az( lsp_int, acoeff );
  1743.    Lsp_Az( lsp_int_variab, acoeff_variab );
  1745.    /* For use in Post_Filter */
  1746.    memcpy( &A_t[0], acoeff, MP1 <<2 );
  1747.    memcpy( &A_t[MP1], acoeff, MP1 <<2 );
  1748.    memcpy( &A_t[MP1 <<1], acoeff, MP1 <<2 );
  1749.    memcpy( &A_t[MP1 + MP1 + MP1], acoeff, MP1 <<2 );
  1751.    /* Compute reflection coefficients Q15 */
  1752.    A_Refl( &acoeff[1], refl );
  1754.    /* Compute prediction error in Q15 */
  1755.    /* 0.99997 in Q15 */
  1756.    pred_err = MAX_16;
  1758.    for ( i = 0; i < M; i++ ) {
  1759.       pred_err = ( pred_err * ( MAX_16 - ( ( refl[i] * refl[i] ) >> 15 ) ) ) >>
  1760.             15;
  1761.    }
  1763.    /* compute logarithm of prediction gain */
  1764.    Log2( pred_err, &log_pg_e, &log_pg_m );
  1766.    /* convert exponent and mantissa to Word16 Q12 */
  1767.    /* Q12 */
  1768.    log_pg = ( log_pg_e - 15 ) << 12;
  1769.    /* saturate */
  1770.    if (log_pg < -32768) {
  1771.       log_pg = -32768;
  1772.    }
  1773.    log_pg = ( -( log_pg + ( log_pg_m >> 3 ) ) ) >> 1;
  1774.    st->log_pg_mean = ( Word16 )( ( ( 29491*st->log_pg_mean ) >> 15 ) + ( ( 3277
  1775.          * log_pg ) >> 15 ) );
  1777.    /* Compute interpolated log energy */
  1778.    /* Q26 -> Q16 */
  1779.    log_en_int = log_en_int >> 10;
  1781.    /* Add 4 in Q16 */
  1782.    log_en_int += 262144L;
  1784.    /* subtract prediction gain */
  1785.    log_en_int = log_en_int - ( log_pg << 4 );
  1787.    /* adjust level to speech coder mode */
  1788.    log_en_int += st->log_en_adjust << 5;
  1789.    log_en_int_e = ( Word16 )( log_en_int >> 16 );
  1790.    log_en_int_m = ( Word16 )( ( log_en_int - ( log_en_int_e << 16 ) ) >> 1 );
  1792.    /* Q4 */
  1793.    level = ( Word16 )( Pow2( log_en_int_e, log_en_int_m ) );
  1795.    for ( i = 0; i < 4; i++ ) {
  1796.       /* Compute innovation vector */
  1797.       Build_CN_code( &st->pn_seed_rx, ex );
  1799.       for ( j = 0; j < L_SUBFR; j++ ) {
  1800.          ex[j] = ( level * ex[j] ) >> 15;
  1801.       }
  1803.       /* Synthesize */
  1804.       Syn_filt( acoeff_variab, ex, &synth[i * L_SUBFR], L_SUBFR, mem_syn, 1 );
  1805.    }   /* next i */
  1807.    /* reset codebook averaging variables */
  1808.    averState->hangVar = 20;
  1809.    averState->hangCount = 0;
  1811.    if ( new_state == DTX_MUTE ) {
  1812.         /*
  1813.          * mute comfort noise as it has been quite a long time since
  1814.          * last SID update  was performed
  1815.          */
  1816.       Word32 num, denom;
  1819.       tmp_int_length = st->since_last_sid;
  1821.       if ( tmp_int_length > 32 ) {
  1822.          tmp_int_length = 32;
  1823.       }
  1825.       if ( tmp_int_length == 1 ) {
  1826.          st->true_sid_period_inv = MAX_16;
  1827.       }
  1828.       else {
  1829.          num = 1024;
  1830.          denom = ( tmp_int_length << 10 );
  1831.          st->true_sid_period_inv = 0;
  1833.          for ( i = 0; i < 15; i++ ) {
  1834.             st->true_sid_period_inv <<= 1;
  1835.             num <<= 1;
  1837.             if ( num >= denom ) {
  1838.                num = num - denom;
  1839.                st->true_sid_period_inv += 1;
  1840.             }
  1841.          }
  1842.       }
  1843.       st->since_last_sid = 0;
  1844.       memcpy( st->lsp_old, st->lsp, M << 2 );
  1845.       st->old_log_en = st->log_en;
  1847.       /* subtract 1/8 in Q11 i.e -6/8 dB */
  1848.       st->log_en = st->log_en - 256;
  1849.       if (st->log_en < -32768) st->log_en = -32768;
  1850.    }
  1852.      /*
  1853.       * reset interpolation length timer
  1854.       * if data has been updated.
  1855.       */
  1856.    if ( ( st->sid_frame != 0 ) & ( ( st->valid_data != 0 ) || ( ( st->valid_data
  1857.          == 0 ) & ( st->dtxHangoverAdded != 0 ) ) ) ) {
  1858.       st->since_last_sid = 0;
  1859.       st->data_updated = 1;
  1860.    }
  1861.    return;
  1862. }
  1865. /*
  1866.  * lsp_avg
  1867.  *
  1868.  *
  1869.  * Parameters:
  1870.  *    st->lsp_meanSave  B: LSP averages
  1871.  *    lsp               I: LSPs
  1872.  *
  1873.  * Function:
  1874.  *    Calculate the LSP averages
  1875.  *
  1876.  * Returns:
  1877.  *    void
  1878.  */
  1879. static void lsp_avg( lsp_avgState *st, Word32 *lsp )
  1880. {
  1881.    Word32 i, tmp;
  1884.    for ( i = 0; i < M; i++ ) {
  1885.       /* mean = 0.84*mean */
  1886.       tmp = ( st->lsp_meanSave[i] << 16 );
  1887.       tmp -= ( EXPCONST * st->lsp_meanSave[i] ) << 1;
  1889.       /* Add 0.16 of newest LSPs to mean */
  1890.       tmp += ( EXPCONST * lsp[i] ) << 1;
  1892.       /* Save means */
  1893.       tmp += 0x00008000L;
  1894.       st->lsp_meanSave[i] = tmp >> 16;
  1895.    }
  1896.    return;
  1897. }
  1900. /*
  1901.  * Int_lpc_1and3
  1902.  *
  1903.  *
  1904.  * Parameters:
  1905.  *    lsp_old        I: LSP vector at the 4th subfr. of past frame      [M]
  1906.  *    lsp_mid        I: LSP vector at the 2nd subframe of present frame [M]
  1907.  *    lsp_new        I: LSP vector at the 4th subframe of present frame [M]
  1908.  *    Az             O: interpolated LP parameters in subframes 1 and 3
  1909.  *                                                                   [AZ_SIZE]
  1910.  *
  1911.  * Function:
  1912.  *    Interpolates the LSPs and converts to LPC parameters
  1913.  *    to get a different LP filter in each subframe.
  1914.  *
  1915.  *    The 20 ms speech frame is divided into 4 subframes.
  1916.  *    The LSPs are quantized and transmitted at the 2nd and
  1917.  *    4th subframes (twice per frame) and interpolated at the
  1918.  *    1st and 3rd subframe.
  1919.  *
  1920.  * Returns:
  1921.  *    void
  1922.  */
  1923. static void Int_lpc_1and3( Word32 lsp_old[], Word32 lsp_mid[], Word32 lsp_new[],
  1924.       Word32 Az[] )
  1925. {
  1926.    Word32 lsp[M];
  1927.    Word32 i;
  1930.    /* lsp[i] = lsp_mid[i] * 0.5 + lsp_old[i] * 0.5 */
  1931.    for ( i = 0; i < 10; i++ ) {
  1932.       lsp[i] = ( lsp_mid[i] >> 1 ) + ( lsp_old[i] >> 1 );
  1933.    }
  1935.    /* Subframe 1 */
  1936.    Lsp_Az( lsp, Az );
  1937.    Az += MP1;
  1939.    /* Subframe 2 */
  1940.    Lsp_Az( lsp_mid, Az );
  1941.    Az += MP1;
  1943.    for ( i = 0; i < 10; i++ ) {
  1944.       lsp[i] = ( lsp_mid[i] >> 1 ) + ( lsp_new[i] >> 1 );
  1945.    }
  1947.    /* Subframe 3 */
  1948.    Lsp_Az( lsp, Az );
  1949.    Az += MP1;
  1951.    /* Subframe 4 */
  1952.    Lsp_Az( lsp_new, Az );
  1953.    return;
  1954. }
  1957. /*
  1958.  * Int_lpc_1to3
  1959.  *
  1960.  *
  1961.  * Parameters:
  1962.  *    lsp_old           I: LSP vector at the 4th subframe of past frame    [M]
  1963.  *    lsp_new           I: LSP vector at the 4th subframe of present frame [M]
  1964.  *    Az                O: interpolated LP parameters in all subframes
  1965.  *                                                                   [AZ_SIZE]
  1966.  *
  1967.  * Function:
  1968.  *    Interpolates the LSPs and converts to LPC parameters to get a different
  1969.  *    LP filter in each subframe.
  1970.  *
  1971.  *    The 20 ms speech frame is divided into 4 subframes.
  1972.  *    The LSPs are quantized and transmitted at the 4th
  1973.  *    subframes (once per frame) and interpolated at the
  1974.  *    1st, 2nd and 3rd subframe.
  1975.  *
  1976.  * Returns:
  1977.  *    void
  1978.  */
  1979. static void Int_lpc_1to3( Word32 lsp_old[], Word32 lsp_new[], Word32 Az[] )
  1980. {
  1981.    Word32 lsp[M];
  1982.    Word32 i;
  1985.    for ( i = 0; i < 10; i++ ) {
  1986.       lsp[i] = ( lsp_new[i] >> 2 ) + ( lsp_old[i] - ( lsp_old[i] >> 2 ) );
  1987.    }
  1989.    /* Subframe 1 */
  1990.    Lsp_Az( lsp, Az );
  1991.    Az += MP1;
  1993.    for ( i = 0; i < 10; i++ ) {
  1994.       lsp[i] = ( lsp_old[i] >> 1 ) + ( lsp_new[i] >> 1 );
  1995.    }
  1997.    /* Subframe 2 */
  1998.    Lsp_Az( lsp, Az );
  1999.    Az += MP1;
  2001.    for ( i = 0; i < 10; i++ ) {
  2002.       lsp[i] = ( lsp_old[i] >> 2 ) + ( lsp_new[i] - ( lsp_new[i] >> 2 ) );
  2003.    }
  2005.    /* Subframe 3 */
  2006.    Lsp_Az( lsp, Az );
  2007.    Az += MP1;
  2009.    /* Subframe 4 */
  2010.    Lsp_Az( lsp_new, Az );
  2011.    return;
  2012. }
  2015. /*
  2016.  * D_plsf_5
  2017.  *
  2018.  *
  2019.  * Parameters:
  2020.  *    st->past_lsf_q I: Past dequantized LFSs
  2021.  *    st->past_r_q      B: past quantized residual
  2022.  *    bfi               B: bad frame indicator
  2023.  *    indice            I: quantization indices of 3 submatrices, Q0
  2024.  *    lsp1_q            O: quantized 1st LSP vector
  2025.  *    lsp2_q            O: quantized 2nd LSP vector
  2026.  *
  2027.  * Function:
  2028.  *    Decodes the 2 sets of LSP parameters in a frame
  2029.  *    using the received quantization indices.
  2030.  *
  2031.  * Returns:
  2032.  *    void
  2033.  */
  2034. static void D_plsf_5( D_plsfState *st, Word16 bfi, Word16 *indice, Word32 *lsp1_q
  2035.       , Word32 *lsp2_q )
  2036. {
  2037.    Word32 lsf1_r[M], lsf2_r[M], lsf1_q[M], lsf2_q[M];
  2038.    Word32 i, temp1, temp2, sign;
  2039.    const Word32 *p_dico;
  2042.    /* if bad frame */
  2043.    if ( bfi != 0 ) {
  2044.       /* use the past LSFs slightly shifted towards their mean */
  2045.       for ( i = 0; i < M; i += 2 ) {
  2046.          /* lsfi_q[i] = ALPHA*st->past_lsf_q[i] + ONE_ALPHA*meanLsf[i]; */
  2047.          lsf1_q[i] = ( ( st->past_lsf_q[i] * ALPHA_122 ) >> 15 ) + ( ( mean_lsf_5[i]
  2048.                * ONE_ALPHA_122 ) >> 15 );
  2049.          lsf1_q[i + 1] = ( ( st->past_lsf_q[i + 1] * ALPHA_122 ) >> 15 ) + ( (
  2050.                mean_lsf_5[i + 1] * ONE_ALPHA_122 ) >> 15 );
  2051.       }
  2052.       memcpy( lsf2_q, lsf1_q, M <<2 );
  2054.       /* estimate past quantized residual to be used in next frame */
  2055.       for ( i = 0; i < M; i += 2 ) {
  2056.          /* temp  = meanLsf[i] +  st->past_r_q[i] * LSPPpred_facMR122; */
  2057.          temp1 = mean_lsf_5[i] + ( ( st->past_r_q[i] * LSP_PRED_FAC_MR122 ) >>
  2058.                15 );
  2059.          temp2 = mean_lsf_5[i + 1] +( ( st->past_r_q[i + 1] *LSP_PRED_FAC_MR122
  2060.                ) >> 15 );
  2061.          st->past_r_q[i] = lsf2_q[i] - temp1;
  2062.          st->past_r_q[i + 1] = lsf2_q[i + 1] -temp2;
  2063.       }
  2064.    }
  2066.    /* if good LSFs received */
  2067.    else {
  2068.       /* decode prediction residuals from 5 received indices */
  2069.       p_dico = &dico1_lsf_5[indice[0] << 2];
  2070.       lsf1_r[0] = *p_dico++;
  2071.       lsf1_r[1] = *p_dico++;
  2072.       lsf2_r[0] = *p_dico++;
  2073.       lsf2_r[1] = *p_dico++;
  2074.       p_dico = &dico2_lsf_5[indice[1] << 2];
  2075.       lsf1_r[2] = *p_dico++;
  2076.       lsf1_r[3] = *p_dico++;
  2077.       lsf2_r[2] = *p_dico++;
  2078.       lsf2_r[3] = *p_dico++;
  2079.       sign = ( Word16 )( indice[2] & 1 );
  2080.       i = indice[2] >> 1;
  2081.       p_dico = &dico3_lsf_5[i << 2];
  2083.       if ( sign == 0 ) {
  2084.          lsf1_r[4] = *p_dico++;
  2085.          lsf1_r[5] = *p_dico++;
  2086.          lsf2_r[4] = *p_dico++;
  2087.          lsf2_r[5] = *p_dico++;
  2088.       }
  2089.       else {
  2090.          lsf1_r[4] = ( Word16 )( -( *p_dico++ ) );
  2091.          lsf1_r[5] = ( Word16 )( -( *p_dico++ ) );
  2092.          lsf2_r[4] = ( Word16 )( -( *p_dico++ ) );
  2093.          lsf2_r[5] = ( Word16 )( -( *p_dico++ ) );
  2094.       }
  2095.       p_dico = &dico4_lsf_5[( indice[3]<<2 )];
  2096.       lsf1_r[6] = *p_dico++;
  2097.       lsf1_r[7] = *p_dico++;
  2098.       lsf2_r[6] = *p_dico++;
  2099.       lsf2_r[7] = *p_dico++;
  2100.       p_dico = &dico5_lsf_5[( indice[4]<<2 )];
  2101.       lsf1_r[8] = *p_dico++;
  2102.       lsf1_r[9] = *p_dico++;
  2103.       lsf2_r[8] = *p_dico++;
  2104.       lsf2_r[9] = *p_dico++;
  2106.       /* Compute quantized LSFs and update the past quantized residual */
  2107.       for ( i = 0; i < M; i++ ) {
  2108.          temp1 = mean_lsf_5[i] + ( ( st->past_r_q[i] * LSP_PRED_FAC_MR122 ) >>
  2109.                15 );
  2110.          lsf1_q[i] = lsf1_r[i] + temp1;
  2111.          lsf2_q[i] = lsf2_r[i] + temp1;
  2112.          st->past_r_q[i] = lsf2_r[i];
  2113.       }
  2114.    }
  2116.    /* verification that LSFs have minimum distance of LSF_GAP Hz */
  2117.    Reorder_lsf( lsf1_q, LSF_GAP );
  2118.    Reorder_lsf( lsf2_q, LSF_GAP );
  2119.    memcpy( st->past_lsf_q, lsf2_q, M <<2 );
  2121.    /*  convert LSFs to the cosine domain */
  2122.    Lsf_lsp( lsf1_q, lsp1_q );
  2123.    Lsf_lsp( lsf2_q, lsp2_q );
  2124.    return;
  2125. }
  2128. /*
  2129.  * Dec_lag3
  2130.  *
  2131.  *
  2132.  * Parameters:
  2133.  *    index             I: received pitch index
  2134.  *    t0_min            I: minimum of search range
  2135.  *    t0_max            I: maximum of search range
  2136.  *    i_subfr           I: subframe flag
  2137.  *    T0_prev           I: integer pitch delay of last subframe used
  2138.  *                         in 2nd and 4th subframes
  2139.  *    T0                O: integer part of pitch lag
  2140.  *    T0_frac           O : fractional part of pitch lag
  2141.  *    flag4             I : flag for encoding with 4 bits
  2142.  * Function:
  2143.  *    Decoding of fractional pitch lag with 1/3 resolution.
  2144.  *    Extract the integer and fraction parts of the pitch lag from
  2145.  *    the received adaptive codebook index.
  2146.  *
  2147.  *    The fractional lag in 1st and 3rd subframes is encoded with 8 bits
  2148.  *    while that in 2nd and 4th subframes is relatively encoded with 4, 5
  2149.  *    and 6 bits depending on the mode.
  2150.  *
  2151.  * Returns:
  2152.  *    void
  2153.  */
  2154. static void Dec_lag3( Word32 index, Word32 t0_min, Word32 t0_max, Word32 i_subfr
  2155.       , Word32 T0_prev, Word32 *T0, Word32 *T0_frac, Word32 flag4 )
  2156. {
  2157.    Word32 i, tmp_lag;
  2160.    /* if 1st or 3rd subframe */
  2161.    if ( i_subfr == 0 ) {
  2162.       if ( index < 197 ) {
  2163.          *T0 = ( ( ( index + 2 ) * 10923 ) >> 15 ) + 19;
  2164.          i = *T0 + *T0 + *T0;
  2165.          *T0_frac = ( index - i ) + 58;
  2166.       }
  2167.       else {
  2168.          *T0 = index - 112;
  2169.          *T0_frac = 0;
  2170.       }
  2171.    }
  2173.    /* 2nd or 4th subframe */
  2174.    else {
  2175.       if ( flag4 == 0 ) {
  2176.          /* 'normal' decoding: either with 5 or 6 bit resolution */
  2177.          i = ( ( ( index + 2 ) * 10923 ) >> 15 ) - 1;
  2178.          *T0 = i + t0_min;
  2179.          i = i + i + i;
  2180.          *T0_frac = ( index - 2 ) - i;
  2181.       }
  2182.       else {
  2183.          /* decoding with 4 bit resolution */
  2184.          tmp_lag = T0_prev;
  2186.          if ( ( tmp_lag - t0_min ) > 5 )
  2187.             tmp_lag = t0_min + 5;
  2189.          if ( ( t0_max - tmp_lag ) > 4 )
  2190.             tmp_lag = t0_max - 4;
  2192.          if ( index < 4 ) {
  2193.             i = ( tmp_lag - 5 );
  2194.             *T0 = i + index;
  2195.             *T0_frac = 0;
  2196.          }
  2197.          else {
  2198.             if ( index < 12 ) {
  2199.                i = ( ( ( index - 5 ) * 10923 ) >> 15 ) - 1;
  2200.                *T0 = i + tmp_lag;
  2201.                i = i + i + i;
  2202.                *T0_frac = ( index - 9 ) - i;
  2203.             }
  2204.             else {
  2205.                i = ( index - 12 ) + tmp_lag;
  2206.                *T0 = i + 1;
  2207.                *T0_frac = 0;
  2208.             }
  2209.          }
  2210.       }   /* end if (decoding with 4 bit resolution) */
  2211.    }
  2212.    return;
  2213. }
  2216. /*
  2217.  * Pred_lt_3or6_40
  2218.  *
  2219.  *
  2220.  * Parameters:
  2221.  *    exc               B: excitation buffer
  2222.  *    T0                I: integer pitch lag
  2223.  *    frac              I: fraction of lag
  2224.  *    flag3             I: if set, upsampling rate = 3 (6 otherwise)
  2225.  *
  2226.  * Function:
  2227.  *    Compute the result of long term prediction with fractional
  2228.  *    interpolation of resolution 1/3 or 1/6. (Interpolated past excitation).
  2229.  *
  2230.  *    Once the fractional pitch lag is determined,
  2231.  *    the adaptive codebook vector v(n) is computed by interpolating
  2232.  *    the past excitation signal u(n) at the given integer delay k
  2233.  *    and phase (fraction)  :
  2234.  *
  2235.  *          9                       9
  2236.  *    v(n) = SUM[ u(n-k-i) * b60(t+i*6) ] + SUM[ u(n-k+1+i) * b60(6-t+i*6) ],
  2237.  *          i=0                       i=0
  2238.  *    n = 0, ...,39, t = 0, ...,5.
  2239.  *
  2240.  *    The interpolation filter b60 is based on a Hamming windowed sin(x)/x
  2241.  *    function truncated at