encamrwb.c

audio-video-codecs.rar语音编解码器

/*/////////////////////////////////////////////////////////////////////////////
//
//                  INTEL CORPORATION PROPRIETARY INFORMATION
//     This software is supplied under the terms of a license agreement or
//     nondisclosure agreement with Intel Corporation and may not be copied
//     or disclosed except in accordance with the terms of that agreement.
//          Copyright(c) 2005-2007 Intel Corporation. All Rights Reserved.
//
//     Intel(R) Integrated Performance Primitives
//     USC - Unified Speech Codec interface library
//
// By downloading and installing USC codec, you hereby agree that the
// accompanying Materials are being provided to you under the terms and
// conditions of the End User License Agreement for the Intel(R) Integrated
// Performance Primitives product previously accepted by you. Please refer
// to the file ippEULA.rtf or ippEULA.txt located in the root directory of your Intel(R) IPP
// product installation for more information.
//
// A speech coding standards promoted by ITU, ETSI, 3GPP and other
// organizations. Implementations of these standards, or the standard enabled
// platforms may require licenses from various entities, including
// Intel Corporation.
//
//
// Purpose: AMRWB speech codec encoder API functions.
//
*/

#include "ownamrwb.h"

static Ipp16s ownSynthesis(Ipp16s *pLPCQuantvec, Ipp16s *pExc, Ipp16s valQNew,
                          const Ipp16u *pSynthSignal, AMRWBEncoder_Obj *st);
static void ownPrms2Bits(const Ipp16s* pPrms, Ipp8u *pBitstream, AMRWB_Rate_t rate);

AMRWB_CODECFUN( APIAMRWB_Status, apiAMRWBEncoder_GetSize,
         (AMRWBEncoder_Obj* encoderObj, Ipp32u *pCodecSize))
{
   if(NULL == encoderObj)
      return APIAMRWB_StsBadArgErr;
   if(NULL == pCodecSize)
      return APIAMRWB_StsBadArgErr;
   if(encoderObj->objPrm.iKey != DEC_KEY)
      return APIAMRWB_StsNotInitialized;

   *pCodecSize = encoderObj->objPrm.iObjSize;
   return APIAMRWB_StsNoErr;
}

AMRWB_CODECFUN( APIAMRWB_Status, apiAMRWBEncoder_Alloc,
         (const AMRWBEnc_Params *amrwb_Params, Ipp32u *pCodecSize))
{
   Ipp32s hpfltsize;
   if(NULL == amrwb_Params)
      return APIAMRWB_StsBadArgErr;
   HighPassFIRGetSize_AMRWB_16s_ISfs(&hpfltsize); // aligned by 8
   *pCodecSize = sizeof(AMRWBEncoder_Obj); // aligned by 8
   *pCodecSize += (2*hpfltsize);
   ippsHighPassFilterGetSize_AMRWB_16s(2, &hpfltsize); // aligned by 8
   *pCodecSize += (3*hpfltsize);
   ippsHighPassFilterGetSize_AMRWB_16s(3, &hpfltsize); // aligned by 8
   *pCodecSize += hpfltsize;
   ippsVADGetSize_AMRWB_16s(&hpfltsize); // not aligned by 8
   *pCodecSize += (hpfltsize+7)&(~7);

   return APIAMRWB_StsNoErr;
}

static void InitEncoder(AMRWBEncoder_Obj* encoderObj)
{
   ippsZero_16s(encoderObj->asiExcOld, PITCH_LAG_MAX + INTERPOL_LEN);
   ippsZero_16s(encoderObj->asiSynthesis, LP_ORDER);
   ippsZero_16s(encoderObj->asiIsfQuantPast, LP_ORDER);

   encoderObj->siSpeechWgt = 0;
   encoderObj->siTiltCode = 0;
   encoderObj->siFrameFirst = 1;

   encoderObj->asiGainPitchClip[0] = MAX_DISTANCE_ISF;
   encoderObj->asiGainPitchClip[1] = MIN_GAIN_PITCH;

   encoderObj->iNoiseEnhancerThres = 0;
}

AMRWB_CODECFUN( APIAMRWB_Status, apiAMRWBEncoder_Init,
         (AMRWBEncoder_Obj* encoderObj, Ipp32s mode))
{
   Ipp32s hpfltsize;

   InitEncoder(encoderObj);

   encoderObj->pSHPFIRState = (HighPassFIRState_AMRWB_16s_ISfs *)((Ipp8s*)encoderObj + sizeof(AMRWBEncoder_Obj));
   HighPassFIRGetSize_AMRWB_16s_ISfs(&hpfltsize);
   encoderObj->pSHPFIRState2 = (HighPassFIRState_AMRWB_16s_ISfs *)((Ipp8s*)encoderObj->pSHPFIRState + hpfltsize);
   encoderObj->pSHPFiltStateSgnlIn = (IppsHighPassFilterState_AMRWB_16s *)((Ipp8s*)encoderObj->pSHPFIRState2 + hpfltsize);
   ippsHighPassFilterGetSize_AMRWB_16s(2, &hpfltsize);
   encoderObj->pSHPFiltStateSgnlOut = (IppsHighPassFilterState_AMRWB_16s *)((Ipp8s*)encoderObj->pSHPFiltStateSgnlIn + hpfltsize);
   encoderObj->pSHPFiltStateSgnl400 = (IppsHighPassFilterState_AMRWB_16s *)((Ipp8s*)encoderObj->pSHPFiltStateSgnlOut + hpfltsize);
   encoderObj->pSHPFiltStateWsp = (IppsHighPassFilterState_AMRWB_16s *)((Ipp8s*)encoderObj->pSHPFiltStateSgnl400 + hpfltsize);
   ippsHighPassFilterGetSize_AMRWB_16s(3, &hpfltsize);
   encoderObj->pSVadState = (IppsVADState_AMRWB_16s *)((Ipp8s*)encoderObj->pSHPFiltStateWsp + hpfltsize);

   /* Static vectors to zero */

   ippsZero_16s(encoderObj->asiSpeechOld, SPEECH_SIZE - FRAME_SIZE + WBP_OFFSET);
   ippsZero_16s(encoderObj->asiWspOld, (PITCH_LAG_MAX / OPL_DECIM));
   ippsZero_16s(encoderObj->asiWspDecimate, 3);

   /* routines initialization */

   ippsZero_16s(encoderObj->asiSpeechDecimate, 2 * NB_COEF_DOWN);
   ippsHighPassFilterInit_AMRWB_16s((Ipp16s*)ACoeffHP50Tbl, (Ipp16s*)BCoeffHP50Tbl, 2, encoderObj->pSHPFiltStateSgnlIn);
   ippsZero_16s(encoderObj->asiLevinsonMem, 32);
   ippsSet_16s(-14336, encoderObj->asiGainQuant, PRED_ORDER);
   ippsHighPassFilterInit_AMRWB_16s((Ipp16s*)ACoeffTbl, (Ipp16s*)BCoeffTbl, 3, encoderObj->pSHPFiltStateWsp);

   /* isp initialization */

   ippsCopy_16s(IspInitTbl, encoderObj->asiIspOld, LP_ORDER);
   ippsCopy_16s(IspInitTbl, encoderObj->asiIspQuantOld, LP_ORDER);

   /* variable initialization */

   encoderObj->siPreemph = 0;
   encoderObj->siWsp = 0;
   encoderObj->siScaleFactorOld = 15;
   encoderObj->asiScaleFactorMax[0] = 15;
   encoderObj->asiScaleFactorMax[1] = 15;
   encoderObj->siWspOldMax = 0;
   encoderObj->siWspOldShift = 0;

   /* pitch ol initialization */

   encoderObj->siMedianOld = 40;
   encoderObj->siOpenLoopGain = 0;
   encoderObj->siAdaptiveParam = 0;
   encoderObj->siWeightFlag = 0;
   ippsSet_16s(40, encoderObj->asiPitchLagOld, 5);
   ippsZero_16s(encoderObj->asiHypassFiltWspOld, (FRAME_SIZE / 2) / OPL_DECIM + (PITCH_LAG_MAX / OPL_DECIM));

   ippsZero_16s(encoderObj->asiSynthHighFilt, LP_ORDER);
   ippsZero_16s((Ipp16s*)encoderObj->aiSynthMem, LP_ORDER * 2);

   ippsHighPassFilterInit_AMRWB_16s((Ipp16s*)ACoeffHP50Tbl, (Ipp16s*)BCoeffHP50Tbl, 2, encoderObj->pSHPFiltStateSgnlOut);
   HighPassFIRInit_AMRWB_16s_ISfs((Ipp16s*)Fir6k_7kTbl, 2, encoderObj->pSHPFIRState);
   ippsHighPassFilterInit_AMRWB_16s((Ipp16s*)ACoeffHP400Tbl, (Ipp16s*)BCoeffHP400Tbl, 2, encoderObj->pSHPFiltStateSgnl400);

   ippsCopy_16s(IsfInitTbl, encoderObj->asiIsfOld, LP_ORDER);

   encoderObj->siDeemph = 0;

   encoderObj->siHFSeed = RND_INIT;

   HighPassFIRInit_AMRWB_16s_ISfs((Ipp16s*)Fir6k_7kTbl, 2, encoderObj->pSHPFIRState2);
   encoderObj->siAlphaGain = IPP_MAX_16S;

   encoderObj->siVadHist = 0;
   encoderObj->iDtx = mode;

   ippsVADInit_AMRWB_16s(encoderObj->pSVadState);
   encoderObj->siToneFlag = 0;
   ownDTXEncReset(&encoderObj->dtxEncState, (Ipp16s*)IsfInitTbl);
   encoderObj->siScaleExp = 0;

   return APIAMRWB_StsNoErr;
}

AMRWB_CODECFUN( APIAMRWB_Status, apiAMRWBEncoder_Mode,
               (AMRWBEncoder_Obj* encoderObj, Ipp32s mode)) {
    if(encoderObj->iDtx != mode) encoderObj->iDtx = mode;
    return APIAMRWB_StsNoErr;
}

AMRWB_CODECFUN( APIAMRWB_Status, apiAMRWBEncoderProceedFirst,
         (AMRWBEncoder_Obj* pEncObj, const Ipp16s* pSrc))
{
   Ipp16s error[LP_ORDER + SUBFRAME_SIZE]; /* error of quantization                  */
   Ipp16s code[SUBFRAME_SIZE];             /* Fixed codebook excitation              */
   Ipp16s tmp;
   Ipp32s dwTmp;
   Ipp16s *new_speech;                     /* Speech vector                          */

   new_speech = pEncObj->asiSpeechOld + SPEECH_SIZE - 2*FRAME_SIZE - UP_SAMPL_FILT_DELAY + WBP_OFFSET;
   ippsZero_16s(pEncObj->asiSpeechDecimate, 2*DOWN_SAMPL_FILT_DELAY);
   /* Down sampling signal from 16kHz to 12.8kHz */
   ownDecimation_AMRWB_16s((Ipp16s*)pSrc, DOWN_SAMPL_FILT_DELAY, new_speech, pEncObj->asiSpeechDecimate);
   /* decimate with zero-padding to avoid delay of filter */
   ippsCopy_16s(pEncObj->asiSpeechDecimate, code, 2 * DOWN_SAMPL_FILT_DELAY);
   ippsZero_16s(error, DOWN_SAMPL_FILT_DELAY);
   ownDecimation_AMRWB_16s(error, DOWN_SAMPL_FILT_DELAY, new_speech + FRAME_SIZE, code);
   /*
    * Perform 50Hz HP filtering of input signal.
    * Perform fixed preemphasis through 1 - g z^-1
    */
   ippsHighPassFilter_AMRWB_16s_ISfs(new_speech, FRAME_SIZE, pEncObj->pSHPFiltStateSgnlIn, 14);
   ippsHighPassFilterGetSize_AMRWB_16s(2, &dwTmp);
   ippsCopy_8u((const Ipp8u*)pEncObj->pSHPFiltStateSgnlIn, (Ipp8u*)code, dwTmp);
   ippsHighPassFilter_AMRWB_16s_ISfs(new_speech+FRAME_SIZE, DOWN_SAMPL_FILT_DELAY,
      (IppsHighPassFilterState_AMRWB_16s *)code, 14);
   ippsPreemphasize_AMRWB_16s_ISfs(PREEMPH_FACTOR, new_speech, FRAME_SIZE, 14, &(pEncObj->siPreemph));
   /* last L_FILT samples for autocorrelation window */
   tmp = pEncObj->siPreemph;
   ippsPreemphasize_AMRWB_16s_ISfs(PREEMPH_FACTOR, (new_speech+FRAME_SIZE), DOWN_SAMPL_FILT_DELAY, 14, &tmp);
   return APIAMRWB_StsNoErr;
}

AMRWB_CODECFUN( APIAMRWB_Status, apiAMRWBEncode,
         (AMRWBEncoder_Obj* encoderObj, const Ipp16u* src,
          Ipp8u* dst, AMRWB_Rate_t *rate, Ipp32s Vad, Ipp32s offsetWBE ))
{
    /* Coder states */
    AMRWBEncoder_Obj *st;

    /* Speech vector */
    IPP_ALIGNED_ARRAY(16, Ipp16s, pSpeechOldvec, SPEECH_SIZE + WBP_OFFSET);
    Ipp16s *pSpeechNew, *pSpeech, *pWindow;

    /* Weighted speech vector */
    IPP_ALIGNED_ARRAY(16, Ipp16s, pWgtSpchOldvec, FRAME_SIZE + (PITCH_LAG_MAX / OPL_DECIM));
    Ipp16s *pWgtSpch;

    /* Excitation vector */
    IPP_ALIGNED_ARRAY(16, Ipp16s, pExcOldvec, (FRAME_SIZE + 1) + PITCH_LAG_MAX + INTERPOL_LEN);
    Ipp16s *pExc;

    /* LPC coefficients */

    IPP_ALIGNED_ARRAY(16, Ipp32s, pAutoCorrvec, LP_ORDER + 1);
    IPP_ALIGNED_ARRAY(16, Ipp16s, pRCvec, LP_ORDER);
    IPP_ALIGNED_ARRAY(16, Ipp16s, pLPCvec, LP_ORDER + 1);
    IPP_ALIGNED_ARRAY(16, Ipp16s, pIspvec, LP_ORDER);
    IPP_ALIGNED_ARRAY(16, Ipp16s, pIspQuantvec, LP_ORDER);
    IPP_ALIGNED_ARRAY(16, Ipp16s, pIsfvec, LP_ORDER);
    Ipp16s *pLPCUnQuant, *pLPCQuant;
    IPP_ALIGNED_ARRAY(16, Ipp16s, pLPCUnQuantvec, NUMBER_SUBFRAME*(LP_ORDER+1));
    IPP_ALIGNED_ARRAY(16, Ipp16s, pLPCQuantvec, NUMBER_SUBFRAME*(LP_ORDER+1));

    /* Other vectors */

    IPP_ALIGNED_ARRAY(16, Ipp16s, pAdptTgtPitch, SUBFRAME_SIZE);
    IPP_ALIGNED_ARRAY(16, Ipp16s, pAdptTgtCdbk, SUBFRAME_SIZE);
    IPP_ALIGNED_ARRAY(16, Ipp16s, pCorrvec, SUBFRAME_SIZE);
    IPP_ALIGNED_ARRAY(16, Ipp16s, pResidvec, SUBFRAME_SIZE);

    IPP_ALIGNED_ARRAY(16, Ipp16s, pImpRespPitchvec, SUBFRAME_SIZE);
    IPP_ALIGNED_ARRAY(16, Ipp16s, pImpRespCdbkvec, SUBFRAME_SIZE);
    IPP_ALIGNED_ARRAY(16, Ipp16s, pFixCdbkvec, SUBFRAME_SIZE);
    IPP_ALIGNED_ARRAY(16, Ipp16s, pFixCdbkExcvec, SUBFRAME_SIZE);
    IPP_ALIGNED_ARRAY(16, Ipp16s, pFltAdptvec, SUBFRAME_SIZE);
    IPP_ALIGNED_ARRAY(16, Ipp16s, pFltAdpt2vec, SUBFRAME_SIZE);
    IPP_ALIGNED_ARRAY(16, Ipp16s, pErrQuant, LP_ORDER + SUBFRAME_SIZE);
    IPP_ALIGNED_ARRAY(16, Ipp16s, pSynthvec, SUBFRAME_SIZE);
    IPP_ALIGNED_ARRAY(16, Ipp16s, pExc2vec, FRAME_SIZE);
    IPP_ALIGNED_ARRAY(16, Ipp16s, pVadvec, FRAME_SIZE);

    /* Scalars */

    Ipp16s valSubFrame, valSelect, valClipFlag, valVadFlag;
    Ipp16s valPitchLag, valFracPitchLag;
    Ipp16s pOpenLoopLag[2],pPitchLagBounds[2];
    Ipp16s valPitchGain, valScaleCodeGain, pGainCoeff[4], pGainCoeff2[4];
    Ipp16s tmp, valGainCoeff, valAdptGain, valExp, valQNew, valShift, max;
    Ipp16s valVoiceFac;

    Ipp32s i, z, valCodeGain, valMax;

    Ipp16s valStabFac = 0, valFac, valCodeGainLow;
    Ipp16s pSrcCoeff[2];

    Ipp16s valCorrGain;
    Ipp32s valSize, subFrame;
    IppSpchBitRate irate = Mode2RateTbl[*rate];
    IppSpchBitRate valCodecMode = irate;
    Ipp16s *pHPWgtSpch;
    IPP_ALIGNED_ARRAY(16, Ipp16s, pPrmvec, MAX_PARAM_SIZE);
    Ipp16s *pPrm;