ilbc_encode.c

视频监控vc源代码.对于做视频系统的朋友们很有帮助

    
    if ( Nfor > 0 ) {
        
        /* setup memory */

        memset(mem, 0, (CB_MEML-STATE_LEN)*sizeof(float));
        memcpy(mem+CB_MEML-STATE_LEN, decresidual+(start-1)*SUBL, 
            STATE_LEN*sizeof(float));
        memset(weightState, 0, LPC_FILTERORDER*sizeof(float));



        /* loop over sub-frames to encode */

        for (subframe=0; subframe<Nfor; subframe++) {

            /* encode sub-frame */

            iCBSearch(iLBCenc_inst, cb_index+subcount*CB_NSTAGES, 
                gain_index+subcount*CB_NSTAGES, 
                &residual[(start+1+subframe)*SUBL], 
                mem+CB_MEML-memLfTbl[subcount], 
                memLfTbl[subcount], SUBL, CB_NSTAGES, 
                &weightdenum[(start+1+subframe)*
                            (LPC_FILTERORDER+1)],
                weightState, subcount+1);

            /* construct decoded vector */

            iCBConstruct(&decresidual[(start+1+subframe)*SUBL], 
                cb_index+subcount*CB_NSTAGES, 
                gain_index+subcount*CB_NSTAGES, 
                mem+CB_MEML-memLfTbl[subcount], 
                memLfTbl[subcount], SUBL, CB_NSTAGES);

            /* update memory */

            memcpy(mem, mem+SUBL, (CB_MEML-SUBL)*sizeof(float));
            memcpy(mem+CB_MEML-SUBL, 
                &decresidual[(start+1+subframe)*SUBL], 
                SUBL*sizeof(float));
            memset(weightState, 0, LPC_FILTERORDER*sizeof(float));

            subcount++;
        }
    }
    

    /* backward prediction of sub-frames */

    Nback = start-1;

    
    if ( Nback > 0 ) {
               
        /* create reverse order vectors */

        for (n=0; n<Nback; n++) {
            for (k=0; k<SUBL; k++) {
                reverseResidual[n*SUBL+k] = 
                    residual[(start-1)*SUBL-1-n*SUBL-k];
                reverseDecresidual[n*SUBL+k] = 
                    decresidual[(start-1)*SUBL-1-n*SUBL-k];
            }
        }



        /* setup memory */

        meml_gotten = SUBL*(iLBCenc_inst->nsub+1-start);

        
        if ( meml_gotten > CB_MEML ) { 
            meml_gotten=CB_MEML;
        }
        for (k=0; k<meml_gotten; k++) { 
            mem[CB_MEML-1-k] = decresidual[(start-1)*SUBL + k];
        } 
        memset(mem, 0, (CB_MEML-k)*sizeof(float));
        memset(weightState, 0, LPC_FILTERORDER*sizeof(float));

        /* loop over sub-frames to encode */

        for (subframe=0; subframe<Nback; subframe++) {
            
            /* encode sub-frame */

            iCBSearch(iLBCenc_inst, cb_index+subcount*CB_NSTAGES, 
                gain_index+subcount*CB_NSTAGES, 
                &reverseResidual[subframe*SUBL], 
                mem+CB_MEML-memLfTbl[subcount], 
                memLfTbl[subcount], SUBL, CB_NSTAGES, 
                &weightdenum[(start-2-subframe)*
                            (LPC_FILTERORDER+1)], 
                weightState, subcount+1);

            /* construct decoded vector */

            iCBConstruct(&reverseDecresidual[subframe*SUBL], 
                cb_index+subcount*CB_NSTAGES, 
                gain_index+subcount*CB_NSTAGES, 
                mem+CB_MEML-memLfTbl[subcount], 
                memLfTbl[subcount], SUBL, CB_NSTAGES);

            /* update memory */

            memcpy(mem, mem+SUBL, (CB_MEML-SUBL)*sizeof(float));
            memcpy(mem+CB_MEML-SUBL, 
                &reverseDecresidual[subframe*SUBL],
                SUBL*sizeof(float));
            memset(weightState, 0, LPC_FILTERORDER*sizeof(float));

            subcount++;

        }

        /* get decoded residual from reversed vector */

        for (i=0; i<SUBL*Nback; i++) {
            decresidual[SUBL*Nback - i - 1] = 


                reverseDecresidual[i];
        }
    }
    /* end encoding part */

    /* adjust index */
    index_conv_enc(cb_index);

    /* pack bytes */

    pbytes=bytes;
    pos=0;

    /* loop over the 3 ULP classes */

    for (ulp=0; ulp<3; ulp++) {
    
        /* LSF */
        for (k=0; k<LSF_NSPLIT*iLBCenc_inst->lpc_n; k++) {
            packsplit(&lsf_i[k], &firstpart, &lsf_i[k], 
                iLBCenc_inst->ULP_inst->lsf_bits[k][ulp], 
                iLBCenc_inst->ULP_inst->lsf_bits[k][ulp]+
                iLBCenc_inst->ULP_inst->lsf_bits[k][ulp+1]+
                iLBCenc_inst->ULP_inst->lsf_bits[k][ulp+2]);
            dopack( &pbytes, firstpart, 
                iLBCenc_inst->ULP_inst->lsf_bits[k][ulp], &pos);
        }

        /* Start block info */

        packsplit(&start, &firstpart, &start, 
            iLBCenc_inst->ULP_inst->start_bits[ulp], 
            iLBCenc_inst->ULP_inst->start_bits[ulp]+
            iLBCenc_inst->ULP_inst->start_bits[ulp+1]+
            iLBCenc_inst->ULP_inst->start_bits[ulp+2]);
        dopack( &pbytes, firstpart, 
            iLBCenc_inst->ULP_inst->start_bits[ulp], &pos);

        packsplit(&state_first, &firstpart, &state_first, 
            iLBCenc_inst->ULP_inst->startfirst_bits[ulp], 
            iLBCenc_inst->ULP_inst->startfirst_bits[ulp]+
            iLBCenc_inst->ULP_inst->startfirst_bits[ulp+1]+
            iLBCenc_inst->ULP_inst->startfirst_bits[ulp+2]);
        dopack( &pbytes, firstpart, 
            iLBCenc_inst->ULP_inst->startfirst_bits[ulp], &pos);

        packsplit(&idxForMax, &firstpart, &idxForMax, 
            iLBCenc_inst->ULP_inst->scale_bits[ulp], 
            iLBCenc_inst->ULP_inst->scale_bits[ulp]+
            iLBCenc_inst->ULP_inst->scale_bits[ulp+1]+
            iLBCenc_inst->ULP_inst->scale_bits[ulp+2]);
        dopack( &pbytes, firstpart, 
            iLBCenc_inst->ULP_inst->scale_bits[ulp], &pos);



        for (k=0; k<iLBCenc_inst->state_short_len; k++) {
            packsplit(idxVec+k, &firstpart, idxVec+k, 
                iLBCenc_inst->ULP_inst->state_bits[ulp], 
                iLBCenc_inst->ULP_inst->state_bits[ulp]+
                iLBCenc_inst->ULP_inst->state_bits[ulp+1]+
                iLBCenc_inst->ULP_inst->state_bits[ulp+2]);
            dopack( &pbytes, firstpart, 
                iLBCenc_inst->ULP_inst->state_bits[ulp], &pos);
        }

        /* 23/22 (20ms/30ms) sample block */

        for (k=0;k<CB_NSTAGES;k++) {
            packsplit(extra_cb_index+k, &firstpart, 
                extra_cb_index+k, 
                iLBCenc_inst->ULP_inst->extra_cb_index[k][ulp], 
                iLBCenc_inst->ULP_inst->extra_cb_index[k][ulp]+
                iLBCenc_inst->ULP_inst->extra_cb_index[k][ulp+1]+
                iLBCenc_inst->ULP_inst->extra_cb_index[k][ulp+2]);
            dopack( &pbytes, firstpart, 
                iLBCenc_inst->ULP_inst->extra_cb_index[k][ulp], 
                &pos);
        }

        for (k=0;k<CB_NSTAGES;k++) {
            packsplit(extra_gain_index+k, &firstpart, 
                extra_gain_index+k, 
                iLBCenc_inst->ULP_inst->extra_cb_gain[k][ulp], 
                iLBCenc_inst->ULP_inst->extra_cb_gain[k][ulp]+
                iLBCenc_inst->ULP_inst->extra_cb_gain[k][ulp+1]+
                iLBCenc_inst->ULP_inst->extra_cb_gain[k][ulp+2]);
            dopack( &pbytes, firstpart, 
                iLBCenc_inst->ULP_inst->extra_cb_gain[k][ulp], 
                &pos);
        }
            
        /* The two/four (20ms/30ms) 40 sample sub-blocks */

        for (i=0; i<iLBCenc_inst->nasub; i++) {
            for (k=0; k<CB_NSTAGES; k++) {
                packsplit(cb_index+i*CB_NSTAGES+k, &firstpart, 
                    cb_index+i*CB_NSTAGES+k, 
                    iLBCenc_inst->ULP_inst->cb_index[i][k][ulp], 
                    iLBCenc_inst->ULP_inst->cb_index[i][k][ulp]+
                    iLBCenc_inst->ULP_inst->cb_index[i][k][ulp+1]+
                    iLBCenc_inst->ULP_inst->cb_index[i][k][ulp+2]);
                dopack( &pbytes, firstpart, 
                    iLBCenc_inst->ULP_inst->cb_index[i][k][ulp], 
                    &pos);
            }
        }
        
        for (i=0; i<iLBCenc_inst->nasub; i++) {
            for (k=0; k<CB_NSTAGES; k++) {


                packsplit(gain_index+i*CB_NSTAGES+k, &firstpart, 
                    gain_index+i*CB_NSTAGES+k, 
                    iLBCenc_inst->ULP_inst->cb_gain[i][k][ulp], 
                    iLBCenc_inst->ULP_inst->cb_gain[i][k][ulp]+
                    iLBCenc_inst->ULP_inst->cb_gain[i][k][ulp+1]+
                    iLBCenc_inst->ULP_inst->cb_gain[i][k][ulp+2]);
                dopack( &pbytes, firstpart, 
                    iLBCenc_inst->ULP_inst->cb_gain[i][k][ulp], 
                    &pos);
            }
        }
    }

    /* set the last bit to zero (otherwise the decoder 
       will treat it as a lost frame) */
    dopack( &pbytes, 0, 1, &pos);
}