codld8cp.c

PA1688网络电话机全部源程序

    int avg_lag;
    
    /*------------------------------------------------------------------------*
    *  - Perform LPC analysis:                                               *
    *       * autocorrelation + lag windowing                                *
    *       * Levinson-durbin algorithm to find a[]                          *
    *       * convert a[] to lsp[]                                           *
    *       * quantize and code the LSPs                                     *
    *       * find the interpolated LSPs and convert to a[] for the 2        *
    *         subframes (both quantized and unquantized)                     *
    *------------------------------------------------------------------------*/
    /* ------------------- */
    /* LP Forward analysis */
    /* ------------------- */
    autocorr(p_window, NP, r_fwd);                     /* Autocorrelations */
    copy(r_fwd, r_nbe, MP1);
    lag_window(NP, r_fwd);                             /* Lag windowing    */
    levinsone(M, r_fwd, &A_t_fwd[MP1], rc_fwd,         /* Levinson Durbin  */
        old_A_fwd, old_rc_fwd );
    az_lsp(&A_t_fwd[MP1], lsp_new, lsp_old);           /* From A(z) to lsp */

    /* For G.729B */
    /* ------ VAD ------- */
    if (dtx_enable == 1) {
        lsp_lsf(lsp_new, lsf_new, M);
        vad(rc_fwd[1], lsf_new, r_fwd, p_window, frame,
            pastVad, ppastVad, &Vad, &Energy_db);

        musdetect( rate, r_fwd[0],rc_fwd, lag_buf , pgain_buf,
                      prev_lp_mode, frame,pastVad, &Vad, Energy_db);

        update_cng(r_nbe, Vad);
    }
    else Vad = 1;

    /* -------------------- */
    /* LP Backward analysis */
    /* -------------------- */
    if ( (rate-(1-Vad))== G729E) {

        /* LPC recursive Window as in G728 */
        autocorr_hyb_window(synth, r_bwd, rexp); /* Autocorrelations */
        lag_window_bwd(r_bwd);  /* Lag windowing    */
        levinsone(M_BWD, r_bwd, &A_t_bwd[M_BWDP1], rc_bwd,
            old_A_bwd, old_rc_bwd );

        /* Tests saturation of A_t_bwd */
        sat_filter = 0;
        for (i=M_BWDP1; i<2*M_BWDP1; i++) if (A_t_bwd[i] >= (F)8.) sat_filter = 1;
        if (sat_filter == 1) copy(A_t_bwd_mem, &A_t_bwd[M_BWDP1], M_BWDP1);
        else copy(&A_t_bwd[M_BWDP1], A_t_bwd_mem, M_BWDP1);

        /* Additional bandwidth expansion on backward filter */
        weight_az(&A_t_bwd[M_BWDP1], GAMMA_BWD, M_BWD, &A_t_bwd[M_BWDP1]);
    }
    /*--------------------------------------------------*
    * Update synthesis signal for next frame.          *
    *--------------------------------------------------*/
    copy(&synth[L_FRAME], &synth[0], MEM_SYN_BWD);

    /*--------------------------------------------------------------------*
    * Find interpolated LPC parameters in all subframes unquantized.      *
    * The interpolated parameters are in array A_t[] of size (M+1)*4      *
    *---------------------------------------------------------------------*/
    if( prev_lp_mode == 0) {
        int_lpc(lsp_old, lsp_new, lsf_int, lsf_new, A_t_fwd);
    }
    else {
        /* no interpolation */
        /* unquantized */
        lsp_az(lsp_new, A_t_fwd);           /* Subframe 1 */
        lsp_lsf(lsp_new, lsf_new, M);  /* transformation from LSP to LSF (freq.domain) */
        copy(lsf_new, lsf_int, M);      /* Subframe 1 */
    }

    if(Vad == 1) {
        /* ---------------- */
        /* LSP quantization */
        /* ---------------- */
        qua_lspe(lsp_new, lsp_new_q, code_lsp, freq_prev, freq_cur);

        /*-------------------------------------------------------------------*
        * Find interpolated LPC parameters in all subframes quantized.       *
        * and the quantized interpolated parameters are in array Aq_t[]      *
        *--------------------------------------------------------------------*/
        if( prev_lp_mode == 0) {
            int_qlpc(lsp_old_q, lsp_new_q, A_t_fwd_q);
        }
        else {
            /* no interpolation */
            lsp_az(lsp_new_q, &A_t_fwd_q[MP1]);              /* Subframe 2 */
            copy(&A_t_fwd_q[MP1], A_t_fwd_q, MP1);      /* Subframe 1 */
        }
        /*---------------------------------------------------------------------*
        * - Decision for the switch Forward / Backward                        *
        *---------------------------------------------------------------------*/
        if(rate == G729E) {
            set_lpc_mode(speech, A_t_fwd_q, A_t_bwd, &lp_mode, 
            lsp_new, lsp_old, &bwd_dominant, prev_lp_mode, prev_filter, &C_int,
                &glob_stat, &stat_bwd, &val_stat_bwd);
        }
        else 
             update_bwd( &lp_mode, &bwd_dominant, &C_int, &glob_stat);
    }
    else 
         update_bwd( &lp_mode, &bwd_dominant, &C_int, &glob_stat);

    /* ---------------------------------- */
    /* update the LSPs for the next frame */
    /* ---------------------------------- */
    copy(lsp_new, lsp_old, M);

    /*----------------------------------------------------------------------*
    * - Find the weighted input speech w_sp[] for the whole speech frame   *
    *----------------------------------------------------------------------*/
    if(lp_mode == 0) {
        m_ap = M;
        if (bwd_dominant == 0) Ap = A_t_fwd;
        else Ap = A_t_fwd_q;
        perc_var(gamma1, gamma2, lsf_int, lsf_new, rc_fwd);
    }
    else {
        if (bwd_dominant == 0) {
            m_ap = M;
            Ap = A_t_fwd;
        }
        else {
            m_ap = M_BWD;
            Ap = A_t_bwd;
        }
        perc_vare(gamma1, gamma2, bwd_dominant);
    }
    pAp = Ap;
    for (i=0; i<2; i++) {
        weight_az(pAp, gamma1[i], m_ap, Ap1);
        weight_az(pAp, gamma2[i], m_ap, Ap2);
        residue(m_ap, Ap1, &speech[i*L_SUBFR], &wsp[i*L_SUBFR], L_SUBFR);
        syn_filte(m_ap,  Ap2, &wsp[i*L_SUBFR], &wsp[i*L_SUBFR], L_SUBFR,
            &mem_w[M_BWD-m_ap], 0);
        for(j=0; j<M_BWD; j++) mem_w[j] = wsp[i*L_SUBFR+L_SUBFR-M_BWD+j];
        pAp += m_ap+1;
    }

    /* ---------------------- */
    /* Case of Inactive frame */
    /* ---------------------- */
    if (Vad == 0){

        for (i=0; i<MA_NP; i++) copy(&freq_prev[i][0], &lsfq_mem[i][0], M);
        cod_cng(exc, pastVad, lsp_old_q, old_A_fwd, old_rc_fwd, A_t_fwd_q,
                        ana, lsfq_mem, &seed);

        for (i=0; i<MA_NP; i++) copy(&lsfq_mem[i][0], &freq_prev[i][0], M);

        ppastVad = pastVad;
        pastVad = Vad;

        /* UPDATE wsp, mem_w, mem_syn, mem_err, and mem_w0 */
        pAp  = A_t_fwd;     /* pointer to interpolated LPC parameters           */
        pAq = A_t_fwd_q;    /* pointer to interpolated quantized LPC parameters */
        i_gamma = 0;
        for(i_subfr=0; i_subfr < L_FRAME; i_subfr += L_SUBFR) {
            weight_az(pAp, gamma1[i_gamma], M, Ap1);
            weight_az(pAp, gamma2[i_gamma], M, Ap2);
            i_gamma++;

            /* update mem_syn */
            syn_filte(M, pAq, &exc[i_subfr], &synth_ptr[i_subfr], L_SUBFR, &mem_syn[M_BWD-M], 0);
            for(j=0; j<M_BWD; j++) mem_syn[j] = synth_ptr[i_subfr+L_SUBFR-M_BWD+j];

            /* update mem_w0 */
            for (i=0; i<L_SUBFR; i++)
                error[i] = speech[i_subfr+i] - synth_ptr[i_subfr+i];
            residue(M, Ap1, error, xn, L_SUBFR);
            syn_filte(M, Ap2, xn, xn, L_SUBFR, &mem_w0[M_BWD-M], 0);
            for(j=0; j<M_BWD; j++) mem_w0[j] = xn[L_SUBFR-M_BWD+j];

            /* update mem_err */
            for (i = L_SUBFR-M_BWD, j = 0; i < L_SUBFR; i++, j++)
                mem_err[j] = error[i];

            for (i= 0; i< 4; i++)
                pgain_buf[i] = pgain_buf[i+1];
            pgain_buf[4] =  (F)0.5;

            pAp += MP1;
            pAq += MP1;
        }
        /* update previous filter for next frame */
        copy(&A_t_fwd_q[MP1], prev_filter, MP1);
        for(i=MP1; i <M_BWDP1; i++) prev_filter[i] = (F)0.;
        prev_lp_mode = lp_mode;

        pit_sharp = SHARPMIN;

        /* Update memories for next frames */
        copy(&old_speech[L_FRAME], &old_speech[0], L_TOTAL-L_FRAME);
        copy(&old_wsp[L_FRAME], &old_wsp[0], PIT_MAX);
        copy(&old_exc[L_FRAME], &old_exc[0], PIT_MAX+L_INTERPOL);
        return;

    }  /* End of inactive frame case */

    /* -------------------- */
    /* Case of Active frame */
    /* -------------------- */
    *ana++ = rate+2; /* bit rate mode */

    if(lp_mode == 0) {
        m_aq = M;
        Aq = A_t_fwd_q;
        /* update previous filter for next frame */
        copy(&Aq[MP1], prev_filter, MP1);
        for(i=MP1; i <M_BWDP1; i++) prev_filter[i] = (F)0.;
        for(j=MP1; j<M_BWDP1; j++) ai_zero[j] = (F)0.;
    }
    else {
        m_aq = M_BWD;
        Aq = A_t_bwd;
        if (bwd_dominant == 0) {
            for(j=MP1; j<M_BWDP1; j++) ai_zero[j] = (F)0.;
        }
        /* update previous filter for next frame */
        copy(&Aq[M_BWDP1], prev_filter, M_BWDP1);
    }


    if(dtx_enable == 1) {
        seed = INIT_SEED;
        ppastVad = pastVad;
        pastVad = Vad;
    }

    if (rate == G729E) *ana++ = lp_mode;

    if( lp_mode == 0) {
        copy(lsp_new_q, lsp_old_q, M);
        lsp_prev_update(freq_cur, freq_prev);
        *ana++ = code_lsp[0];
        *ana++ = code_lsp[1];
    }

    /*--------------------------------------------------------------------*
    * - Find the open-loop pitch delay for the whole speech frame        *
    * - Set the range for searching closed-loop pitch in 1st subframe    *
    *--------------------------------------------------------------------*/

    T_op = pitch_ol(wsp, PIT_MIN, PIT_MAX, L_FRAME);

    for (i= 0; i< 4; i++)
        lag_buf[i] = lag_buf[i+1];