/*/////////////////////////////////////////////////////////////////////////////
//
//                  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 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 ipplic.htm 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: GSMAMR speech codec: encoder API.
//
*/

#include "owngsmamr.h"

/* filter coefficients (fc = 140 Hz, coeff. b[] is divided by 2) */
static __ALIGN32 CONST short pTblCoeff_b140[3] = {1899, -3798, 1899};      /* 1/2 in Q12 */
static __ALIGN32 CONST short pTblCoeff_a140[3] = {4096, 7807, -3733};      /* Q12 */

/* Spectral expansion factors */

static __ALIGN32 CONST short pTableGamma1[4*LP_ORDER_SIZE+4] =
{
   32767, 30802, 28954, 27217, 25584, 24049, 22606, 21250, 19975, 18777, 17650,
   32767, 30802, 28954, 27217, 25584, 24049, 22606, 21250, 19975, 18777, 17650,
   32767, 30802, 28954, 27217, 25584, 24049, 22606, 21250, 19975, 18777, 17650,
   32767, 30802, 28954, 27217, 25584, 24049, 22606, 21250, 19975, 18777, 17650
};

/* pTableGamma1 differs for the 12k2 coder */
static __ALIGN32 CONST short pTableGamma1_M122[4*LP_ORDER_SIZE+4] =
{
    32767, 29491, 26542, 23888, 21499, 19349, 17414, 15672, 14105, 12694, 11425,
    32767, 29491, 26542, 23888, 21499, 19349, 17414, 15672, 14105, 12694, 11425,
    32767, 29491, 26542, 23888, 21499, 19349, 17414, 15672, 14105, 12694, 11425,
    32767, 29491, 26542, 23888, 21499, 19349, 17414, 15672, 14105, 12694, 11425
};

static __ALIGN32 CONST short pTableGamma2[4*LP_ORDER_SIZE+4] =
{
   32767, 19661, 11797, 7078, 4247, 2548, 1529, 917, 550, 330, 198,
   32767, 19661, 11797, 7078, 4247, 2548, 1529, 917, 550, 330, 198,
   32767, 19661, 11797, 7078, 4247, 2548, 1529, 917, 550, 330, 198,
   32767, 19661, 11797, 7078, 4247, 2548, 1529, 917, 550, 330, 198
};

GSMAMR_CODECFUN( APIGSMAMR_Status, apiGSMAMREncoder_GetSize,
         (GSMAMREncoder_Obj* encoderObj, unsigned int *pCodecSize))
{
   if(NULL == encoderObj)
      return APIGSMAMR_StsBadArgErr;
   if(NULL == pCodecSize)
      return APIGSMAMR_StsBadArgErr;
   if(encoderObj->objPrm.key != DEC_KEY)
      return APIGSMAMR_StsNotInitialized;

   *pCodecSize = encoderObj->objPrm.objSize;
   return APIGSMAMR_StsNoErr;
}


/*************************************************************************
*  Function:   apiGSMAMREncoder_Alloc
*     Enquire a size of the coder state memory
**************************************************************************/
GSMAMR_CODECFUN( APIGSMAMR_Status, apiGSMAMREncoder_Alloc,
         (const GSMAMREnc_Params *gsm_Params, unsigned int *pSizeTab))
{
   int fltSize;
   int allocSize=sizeof(GSMAMREncoder_Obj);
   ippsHighPassFilterSize_G729(&fltSize);
   allocSize += fltSize;
   if(GSMAMR_CODEC != gsm_Params->codecType)
      return APIGSMAMR_StsBadCodecType;
   ownEncDetectSize_GSMAMR(gsm_Params->mode,&allocSize);
   pSizeTab[0] =  allocSize;
   return APIGSMAMR_StsNoErr;
}

int ownDtxEncoderInit_GSMAMR(sDTXEncoderSt* dtxSt)
{
   short i;

   dtxSt->vHistoryPtr = 0;
   dtxSt->vLogEnergyIndex = 0;
   dtxSt->vLSFQntIndex = 0;
   dtxSt->a_LSPIndex[0] = 0;
   dtxSt->a_LSPIndex[1] = 0;
   dtxSt->a_LSPIndex[2] = 0;

   for(i = 0; i < DTX_HIST_SIZE; i++)
     ippsCopy_16s(TableLSPInitData, &dtxSt->a_LSPHistory[i * LP_ORDER_SIZE], LP_ORDER_SIZE);

   ippsZero_16s(dtxSt->a_LogEnergyHistory, DTX_HIST_SIZE);
   dtxSt->vDTXHangoverCt = DTX_HANG_PERIOD;
   dtxSt->vDecExpireCt = 32767;

   return 1;
}

int ownGainQuantInit_GSMAMR(sGainQuantSt *state)
{

   state->vExpPredCBGain = 0;
   state->vFracPredCBGain = 0;
   state->vExpTargetEnergy = 0;
   state->vFracTargetEnergy = 0;

   ippsZero_16s(state->a_ExpEnCoeff, 5);
   ippsZero_16s(state->a_FracEnCoeff, 5);
   state->pGainPtr = NULL;
   ippsSet_16s(MIN_ENERGY, state->a_PastQntEnergy, NUM_PRED_TAPS);
   ippsSet_16s(MIN_ENERGY_M122, state->a_PastQntEnergy_M122, NUM_PRED_TAPS);
   ippsSet_16s(MIN_ENERGY, state->a_PastUnQntEnergy, NUM_PRED_TAPS);
   ippsSet_16s(MIN_ENERGY_M122, state->a_PastUnQntEnergy_M122, NUM_PRED_TAPS);
   state->vOnSetQntGain = 0;
   state->vPrevAdaptOut = 0;
   state->vPrevGainCode = 0;
   ippsZero_16s(state->a_LTPHistoryGain,NUM_MEM_LTPG);

   return 1;
}

int ownVAD1Init_GSMAMR(IppGSMAMRVad1State *state)
{

   state->pitchFlag = 0;
   state->complexHigh = 0;
   state->complexLow = 0;
   state->complexHangTimer = 0;
   state->vadReg = 0;
   state->statCount = 0;
   state->burstCount = 0;
   state->hangCount = 0;
   state->complexHangCount = 0;

   ippsZero_16s( state->pFifthFltState, 6 );
   ippsZero_16s( state->pThirdFltState, 5 );

   ippsSet_16s(INIT_BACKGROUND_NOISE, state->pBkgNoiseEstimate, NUM_SUBBANDS_VAD);
   ippsSet_16s(INIT_BACKGROUND_NOISE, state->pPrevSignalLevel, NUM_SUBBANDS_VAD);
   ippsSet_16s(INIT_BACKGROUND_NOISE, state->pPrevAverageLevel, NUM_SUBBANDS_VAD);
   ippsZero_16s( state->pPrevSignalSublevel, NUM_SUBBANDS_VAD );

   state->corrHp = INIT_LOWPOW_SEGMENT;
   state->complexWarning = 0;

   return 1;
}

int ownVAD2Init_GSMAMR(IppGSMAMRVad2State *state)
{
    ippsZero_16s((Ipp16s *)state, sizeof(IppGSMAMRVad2State)/2);
    return 1;
}

int ownEncDetectSize_GSMAMR(int mode, int* pEncSize)
{
   //if (mode == GSMAMREncode_VAD1_Enabled)
      *pEncSize += sizeof(IppGSMAMRVad1State);
   //if (mode == GSMAMREncode_VAD2_Enabled)
      *pEncSize += sizeof(IppGSMAMRVad2State);

   return 1;
}

int ownEncoderInit_GSMAMR(GSMAMREncoder_Obj* pEnc)
{
   sEncoderState_GSMAMR *stEnc = &pEnc->stEncState;
   stEnc->vFlagDTX = pEnc->objPrm.mode;

   stEnc->pSpeechPtrNew = stEnc->a_SpeechVecOld + SPEECH_BUF_SIZE - FRAME_SIZE_GSMAMR;   /* New speech     */
   stEnc->pSpeechPtr = stEnc->pSpeechPtrNew - SUBFR_SIZE_GSMAMR;                  /* Present frame  */
   stEnc->pWindowPtr = stEnc->a_SpeechVecOld + SPEECH_BUF_SIZE - LP_WINDOW_SIZE;    /* For LPC window */
   stEnc->pWindowPtr_M122 = stEnc->pWindowPtr - SUBFR_SIZE_GSMAMR; /* EFR LPC window: no lookahead */

   stEnc->pWeightSpeechVec = stEnc->a_WeightSpeechVecOld + PITCH_MAX_LAG;
   stEnc->pExcVec = stEnc->a_ExcVecOld + PITCH_MAX_LAG + FLT_INTER_SIZE;
   stEnc->pZeroVec = stEnc->a_ZeroVec + LP1_ORDER_SIZE;
   stEnc->pErrorPtr = stEnc->a_MemoryErr + LP_ORDER_SIZE;
   stEnc->pImpResVec = &stEnc->a_ImpResVec[0];

   ippsZero_16s(stEnc->a_SpeechVecOld, SPEECH_BUF_SIZE);
   ippsZero_16s(stEnc->a_ExcVecOld,PITCH_MAX_LAG + FLT_INTER_SIZE);
   ippsZero_16s(stEnc->a_WeightSpeechVecOld,PITCH_MAX_LAG);
   ippsZero_16s(stEnc->a_MemorySyn,LP_ORDER_SIZE);
   //ippsZero_16s(stEnc->a_Memory_W1,LP_ORDER_SIZE);
   ippsZero_16s(stEnc->a_Memory_W0,LP_ORDER_SIZE);
   ippsZero_16s(stEnc->a_MemoryErr,LP_ORDER_SIZE);
   ippsZero_16s(stEnc->pZeroVec,SUBFR_SIZE_GSMAMR);

   ippsSet_16s(40, stEnc->a_LTPStateOld, 5);

   ippsZero_16s(stEnc->a_SubState, (LP_ORDER_SIZE + 1));
   stEnc->a_SubState[0] = 4096;

   ippsCopy_16s(TableLSPInitData, &stEnc->a_LSP_Old[0], LP_ORDER_SIZE);
   ippsCopy_16s(stEnc->a_LSP_Old, stEnc->a_LSPQnt_Old, LP_ORDER_SIZE);
   ippsZero_16s(stEnc->a_PastQntPredErr,LP_ORDER_SIZE);

   stEnc->vTimePrevSubframe = 0;

   ownGainQuantInit_GSMAMR(&stEnc->stGainQntSt);

   stEnc->vTimeMedOld = 40;
   stEnc->vFlagVADState = 0;
   //stEnc->wght_flg = 0;

   stEnc->vCount = 0;
   ippsZero_16s(stEnc->a_GainHistory, PG_NUM_FRAME);    /* Init Gp_Clipping */

  // if (stEnc->vFlagDTX == GSMAMREncode_VAD1_Enabled)
      ownVAD1Init_GSMAMR((IppGSMAMRVad1State*)stEnc->pVAD1St);
  // if (stEnc->vFlagDTX == GSMAMREncode_VAD2_Enabled)
      ownVAD2Init_GSMAMR((IppGSMAMRVad2State*)stEnc->pVAD2St);
   ownDtxEncoderInit_GSMAMR(&stEnc->stDTXEncState);

   stEnc->vFlagSharp = PITCH_SHARP_MIN;
   stEnc->vLagCountOld = 0;
   stEnc->vLagOld = 0;
   stEnc->vFlagTone = 0;
   stEnc->vBestHpCorr = INIT_LOWPOW_SEGMENT;

   return 1;
}
GSMAMR_CODECFUN( APIGSMAMR_Status, apiGSMAMREncoder_Mode,
                (GSMAMREncoder_Obj* encoderObj, unsigned int mode))
{
   encoderObj->objPrm.mode = mode;
   encoderObj->stEncState.vFlagDTX = mode;
   return APIGSMAMR_StsNoErr;
}
/*************************************************************************
*  Function:   apiGSMAMREncoder_Init
*     Initializes coder state memory
**************************************************************************/
GSMAMR_CODECFUN( APIGSMAMR_Status, apiGSMAMREncoder_Init,
                (GSMAMREncoder_Obj* encoderObj, unsigned int mode))
{
   int fltSize;
   IPP_ALIGNED_ARRAY(16, Ipp16s, abEnc, 6);
   int obj_size = sizeof(GSMAMREncoder_Obj);
   ippsZero_16s((short*)encoderObj,sizeof(GSMAMREncoder_Obj)>>1) ;
   encoderObj->objPrm.mode = mode;
   encoderObj->objPrm.key = ENC_KEY;
   encoderObj->preProc = (char*)encoderObj + sizeof(GSMAMREncoder_Obj);
   ippsHighPassFilterSize_G729(&fltSize);
   obj_size += fltSize;
   ownEncDetectSize_GSMAMR(mode,&obj_size);
   encoderObj->stEncState.pVAD1St = (char*)encoderObj->preProc + fltSize;
   fltSize = sizeof(IppGSMAMRVad1State);
   encoderObj->stEncState.pVAD2St = (char*)encoderObj->stEncState.pVAD1St + fltSize;
   obj_size += fltSize;
   encoderObj->objPrm.objSize = obj_size;

   abEnc[0] = pTblCoeff_a140[0];
   abEnc[1] = pTblCoeff_a140[1];
   abEnc[2] = pTblCoeff_a140[2];
   abEnc[3] = pTblCoeff_b140[0];
   abEnc[4] = pTblCoeff_b140[1];
   abEnc[5] = pTblCoeff_b140[2];
   ownEncoderInit_GSMAMR(encoderObj);
   ippsHighPassFilterInit_G729(abEnc, encoderObj->preProc);

   return APIGSMAMR_StsNoErr;
}
/*************************************************************************
*  Function:   apiGSMAMREncode
**************************************************************************/

GSMAMR_CODECFUN(  APIGSMAMR_Status, apiGSMAMREncode,
         (GSMAMREncoder_Obj* encoderObj,const short* src,  GSMAMR_Rate_t rate,
          unsigned char* dst, int *pVad ))
{
   IPP_ALIGNED_ARRAY(16, short, pSynthVec, FRAME_SIZE_GSMAMR);        /* Buffer for synthesis speech           */
   IPP_ALIGNED_ARRAY(16, short, pParamVec, MAX_NUM_PRM);
   short *pParamPtr = pParamVec;
   short *pNewSpeech = encoderObj->stEncState.pSpeechPtrNew;

   if(NULL==encoderObj || NULL==src || NULL ==dst )
      return APIGSMAMR_StsBadArgErr;
   if(0 >= encoderObj->objPrm.objSize)
      return APIGSMAMR_StsNotInitialized;
   if(rate > GSMAMR_RATE_DTX  || rate < 0)
      return APIGSMAMR_StsBadArgErr;
   if(ENC_KEY != encoderObj->objPrm.key)
      return APIGSMAMR_StsBadCodecType;
   encoderObj->rate = rate;

   /* filter + downscaling */
   ippsCopy_16s(src, pNewSpeech, FRAME_SIZE_GSMAMR);
   ippsHighPassFilter_G729_16s_ISfs(pNewSpeech, FRAME_SIZE_GSMAMR, 12, encoderObj->preProc);

   /* Call the speech encoder */
   ownEncode_GSMAMR(&encoderObj->stEncState, encoderObj->rate, pParamPtr, pVad, pSynthVec);

   if(!*pVad) rate = GSMAMR_RATE_DTX;
   ownPrm2Bits_GSMAMR(pParamVec, dst, rate);

   return APIGSMAMR_StsNoErr;
}

/***************************************************************************
 * Function: ownEncode_GSMAMR
 ***************************************************************************/
int ownEncode_GSMAMR(sEncoderState_GSMAMR *encSt,GSMAMR_Rate_t rate, short *pAnaParam,
                     int *pVad, short *pSynthVec)
{
   /* LPC coefficients */
   IPP_ALIGNED_ARRAY(16, short, A_t, (LP1_ORDER_SIZE) * 4);
   IPP_ALIGNED_ARRAY(16, short, Aq_t, (LP1_ORDER_SIZE) * 4);
   short *A, *Aq;
   IPP_ALIGNED_ARRAY(16, short, pNewLSP, 2*LP_ORDER_SIZE);

   IPP_ALIGNED_ARRAY(16, short, pPitchSrch, SUBFR_SIZE_GSMAMR);