sbr_enc_encoder_fp.c

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

  Ipp32s pHiFreqResTab[10] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };

  Ipp32s nBand[2];
  Ipp32s nNoiseBand[2];

  Ipp32s* pFreqTabs[2];

  Ipp32s bs_invf_mode[MAX_NUM_NOISE_BANDS];

  Ipp32s curr_amp_res = 0;

  Ipp32s i = 0;
  Ipp32s tranPos = 0, tranFlag = 0;
  Ipp32s splitFlag = 0;
  Ipp32s lastBand = 0; //kx + M

  Ipp32s flagTranForInvfEst    = 0;
  Ipp32s flagTranForNoisefEst  = 0;

  Ipp32s flagResetNeed = 0;

  /* ******************************************************************* */
  /*                   update flag_header                                */
  /* this step need for synchronization other device (for ex DRadioM)    */
  /* every 500 mls header is sent                                        */
  /* ******************************************************************* */

  pHeader->flag_SBRHeaderActive = 0;

  if ( 0 == pHeader->cntSentSBRHeader ) {
    pHeader->flag_SBRHeaderActive = 1;
  }

  pHeader->cntSentSBRHeader++;
  pHeader->cntSentSBRHeader %= pHeader->nSendSBRHeader;
  //----------------------------------------------------

  /* ********************************************************************* */
  /*                  START MAIL LOOP                                      */
  /* ********************************************************************* */

  for( ch = 0; ch < pState->indx_CE_Tab[offset] + 1; ch++ ){

    /* init structures */
    sSBREnc_SCE_State* pSCE_Element = pRoot_SCE_Element + ch;
    sSBRFrameInfoState* pFIState = &( pSCE_Element->sbrFIState );
    sSBREnvDataState* pEDState = &( pSCE_Element->sbrEDState );

    Ipp32f* pSrc = pSCE_Element->sbrInputBuffer;


    Ipp16s* bufEnvQuant   = pEDState->bufEnvQuant;
    Ipp16s* bufNoiseQuant = pEDState->bufNoiseQuant;

    Ipp16s* bufEnvQuantPrev = pEDState->bufEnvQuantPrev;
    Ipp32s* nEnv = &( pFIState->nEnv );

    Ipp32s  nNoiseEnv   = *nEnv > 1 ? 2 : 1;
    Ipp16s* bufNoiseQuantPrev = pEDState->bufNoiseQuantPrev;

    /* reset vals */
    i = 0;
    tranPos = 0;
    tranFlag = 0;
    splitFlag = 0;
    lastBand = 0; //kx + M

    flagTranForInvfEst    = 0;
    flagTranForNoisefEst  = 0;

    /* analysis */
    for(i=0; i<32; i++){
      ownAnalysisFilter_SBREnc_RToC_32f32fc(pSrc + 64*i, pSCE_Element->bufX[i], pSpec);
    }

    /* calc energy of signal: history up-date here */
    sbrencCalcNrg(pSCE_Element->bufX, pSCE_Element->bufXFlip, pSCE_Element->bufNrg, pSCE_Element->bufNrgFlip);

    /*  */
    lastBand = pFreqTabsState->fHiBandTab[ pFreqTabsState->nHiBand ];

    /* TNR estimation */
    ippsCopy_32f(pSCE_Element->bufT[2], pSCE_Element->bufT[0], 128);

    pSCE_Element->bufTNrg[0] = pSCE_Element->bufTNrg[1];
    pSCE_Element->bufTNrg[1] = 0.f;

    for(i = 0; i < lastBand; i++){
      Ipp32f meanNrg = 0.f;

      ownEstimateTNR_SBR_32f(pSCE_Element->bufXFlip[i],
                            &(pSCE_Element->bufT[2][i]),
                            &(pSCE_Element->bufT[3][i]), &meanNrg );

      pSCE_Element->bufTNrg[1] += meanNrg;
    }

    /* transient detector */
    sbrencTransientDetector(pSCE_Element->bufNrgFlip,
                            pSCE_Element->sbrTransientState.threshold,
                            pSCE_Element->sbrTransientState.transient,
                            &tranPos, &tranFlag);

    /* frame splitter */
    if ( 0 == tranFlag ){
      splitFlag = sbrencFrameSplitter(pSCE_Element->bufNrg,
                                      pFreqTabsState->fHiBandTab,
                                      pFreqTabsState->nHiBand,
                                      &(pSCE_Element->sbrTransientState.nrgPrevLow),
                                      pState->splitThr);

  #ifdef SBR_NEED_LOG
      fprintf(logFile, "splitFlag = %i\n", splitFlag);
  #endif
    } else {
  #ifdef SBR_NEED_LOG
      fprintf(logFile, "splitFlag = %i\n", tranPos);
  #endif
    }

    /* frame generator */
    pSCE_Element->sbrTransientState.tranPos  = tranPos;
    pSCE_Element->sbrTransientState.tranFlag = tranFlag;
    /* AYA patch */
    if (tranFlag == 0) {
      pSCE_Element->sbrTransientState.tranPos = splitFlag;
    }
    sbrencFrameGenerator(pSCE_Element, splitFlag);

  //-----------------------------------------------------------------------------
    /* duty code: MAY BE POTENCIAL ERROR, WHEN DIFFERENT AMP_RES IS CALCULATED */
    /* correct bs_amp_res */
    curr_amp_res = sbrencUpDateAmpRes( *nEnv, pSCE_Element->sbrGrid.frameClass );

    if( pSCE_Element->bs_amp_res != curr_amp_res ){
    //if ( pHeader->bs_amp_res != curr_amp_res ) {

     // if( ch > 0 ){
     //   vm_string_printf(VM_STRING("sbr err: CONFLICT WITH AMP_RES\n"));
     // }

      pSCE_Element->bs_amp_res = curr_amp_res;
      //pHeader->bs_amp_res = curr_amp_res;

      pEDState->flagEnvUpDate   = 0;
      pEDState->flagNoiseUpDate = 0;

      /* patch */
      flagResetNeed++;
    }
  //-----------------------------------------------------------------------------
    /* set flags */
    flagTranForNoisefEst = 0;
    //pState->flagTransferTran

    if(pSCE_Element->sbrTransientState.flagTransferTran){
      flagTranForNoisefEst = 1;
      pSCE_Element->sbrTransientState.flagTransferTran = 0;

      if(tranFlag){
        if(tranPos + 4 >= pFIState->bordersEnv[pFIState->nEnv]){
          pSCE_Element->sbrTransientState.flagTransferTran = 1;
        }
      }
    } else {
      if(tranFlag){
        if(tranPos + 4 < pFIState->bordersEnv[pFIState->nEnv]){

          flagTranForNoisefEst = 1;
          pSCE_Element->sbrTransientState.flagTransferTran = 0;
        }else{
          pSCE_Element->sbrTransientState.flagTransferTran = 1;
        }
      }
    }

    flagTranForInvfEst = pSCE_Element->sbrTransientState.flagTransferTran;

  //---------------------------------

    /* inv filtering estimation */
    sbrencInvfEstimation (&(pSCE_Element->sbrInvfEst),
                          pSCE_Element->bufT,
                          pSCE_Element->bufTNrg,
                          pSCE_Element->tabPatchMap,
                          flagTranForInvfEst,
                          pFreqTabsState->fNoiseBandTab,
                          pFreqTabsState->nNoiseBand,
                          bs_invf_mode);


    sbrencSinEstimation(pSCE_Element, pFreqTabsState);

    sbrencNoisefEstimation(pSCE_Element,
                           pFreqTabsState->fNoiseBandTab,
                           pFreqTabsState->nNoiseBand,
                           bufNoiseQuant);

    /* up-date */
    for(i = 0; i < pFreqTabsState->nNoiseBand; i++){
      pSCE_Element->sbrInvfEst.bs_invf_mode[i] = bs_invf_mode[i];
    }

    /* data */
    nBand[0] = pFreqTabsState->nLoBand;
    nBand[1] = pFreqTabsState->nHiBand;

    pFreqTabs[0] = pFreqTabsState->fLoBandTab;
    pFreqTabs[1] = pFreqTabsState->fHiBandTab;

    /* AYA log */
    //printf("\namp_res = %i\n", pState->bs_amp_res);

    sbrencEnvEstimation(pSCE_Element->bufNrg,
                        &(pSCE_Element->sbrFIState),
                        bufEnvQuant,
                        nBand,//Ipp32s    nBand[2],
                        pFreqTabs, //Ipp32s*   pFreqTabs[2],
                        curr_amp_res,//pHeader->bs_amp_res, //Ipp32s    amp_res,
                        pEDState->bs_add_harmonic, //Ipp32s*   add_harmonic,
                        pEDState->bs_add_harmonic_flag);

    /* *********** start noise coding **************** */
    /* up-date */
    nNoiseEnv   = *nEnv > 1 ? 2 : 1;

    /* data */
    nNoiseBand[0] = pFreqTabsState->nNoiseBand;
    nNoiseBand[1] = pFreqTabsState->nNoiseBand;

    /* AYAlog: Ipp32s data (env) */
#ifdef SBR_NEED_LOG
    fprintf(logFile, "in data (noise)\n");
    {
      Ipp32s i,j, Band;
      Ipp16s *ptr = bufNoiseQuant;

      for(i=0; i<nNoiseEnv; i++){
        Band = nNoiseBand[ pFIState->freqRes[i] ];
        for(j=0; j<Band; j++){
          fprintf(logFile, "%i\n", *ptr);
          ptr++;
        }
      }
    }
#endif

    sbrencDeltaCoding(bufNoiseQuant,
                      bufNoiseQuantPrev,

                      pHiFreqResTab, //Ipp32s*  freq_res, (only HiFreqRes for noise coding)
                      nNoiseBand,
                      curr_amp_res, // ignored
                      pEDState->bs_df_noise, //directionDeltaCoding,
                      0, //coupling,
                      3, //Ipp32s   offset,
                      nNoiseEnv, //Ipp32s   nEnv,
                      0, //channel,

                      pHeader->flag_SBRHeaderActive,//Ipp32s   headerActive,
                      &(pEDState->flagNoiseUpDate),
                      pEDState->env_dF_edge_incr_fac,
                      0,
                      pState->sbrHuffTabs);

    /* AYAlog: Ipp32s data (env) */
#ifdef SBR_NEED_LOG
    fprintf(logFile, "out data (noise)\n");
    {
      Ipp32s i,j, Band;
      Ipp16s *ptr = bufNoiseQuant;

      for(i=0; i<nNoiseEnv; i++){
        fprintf(logFile, "vec_df = %i\n", pEDState->bs_df_noise[i]);
        Band = nNoiseBand[ pFIState->freqRes[i] ];
        for(j=0; j<Band; j++){
          fprintf(logFile, "%i\n", *ptr);
          ptr++;
        }
      }
    }
#endif
    /* *********** stop noise coding **************** */
  //---------------------------------------------------------
    /* *********** start envelope coding **************** */

    /* AYA: Ipp32s data (env) */
#ifdef SBR_NEED_LOG
    fprintf(logFile, "in data (env)\n");
    {
      Ipp32s i,j, Band;
      Ipp16s *ptr = bufEnvQuant;

      for(i=0; i<*nEnv; i++){
        Band = nBand[ pFIState->freqRes[i] ];
        for(j=0; j<Band; j++){
          fprintf(logFile, "%i\n", *ptr);
          ptr++;
        }
      }
    }
#endif

    sbrencDeltaCoding(bufEnvQuant,
                      bufEnvQuantPrev,

                      pFIState->freqRes, //Ipp32s*  freq_res,
                      nBand,
                      curr_amp_res,
                      pEDState->bs_df_env, //directionDeltaCoding,
                      0, //coupling,
                      0, //Ipp32s   offset,
                      *nEnv, //Ipp32s   nEnv,
                      0, //channel,

                      pHeader->flag_SBRHeaderActive,//Ipp32s   headerActive,
                      &(pEDState->flagEnvUpDate),
                      pEDState->env_dF_edge_incr_fac,
                      1,
                      pState->sbrHuffTabs);

    /* start patch */
    if (pEDState->bs_df_env[0] == TIME_DOMAIN) {
      pEDState->env_dF_edge_incr_fac++;
    }else {
      pEDState->env_dF_edge_incr_fac = 0;
    }
    /* end patch */

    /* AYA: Ipp32s data (env) */
#ifdef SBR_NEED_LOG
    fprintf(logFile, "out data (env)\n");
    {
      Ipp32s i,j, Band;
      Ipp16s *ptr = bufEnvQuant;

      for(i=0; i<*nEnv; i++){
        fprintf(logFile, "vec_df = %i\n", pEDState->bs_df_env[i]);

        Band = nBand[ pFIState->freqRes[i] ];
        for(j=0; j<Band; j++){
          fprintf(logFile, "%i\n", *ptr);
          ptr++;
        }
      }
    }
#endif
    /* *********** end envelope coding **************** */
  }
  /* ********************************************************************* */
  /*                   ENF of MAIN LOOP                                    */
  /* ********************************************************************* */

#if 0
  /* patch */
  //this step is need if header isn't active but change is needed
  if (flagResetNeed && !pHeader->flag_SBRHeaderActive ) {
    pHeader->flag_SBRHeaderActive = 1;
  }

  /* if bs_amp_res = 0, then UMC HE-AAC Dec will auto understand it */
  if ( ID_SCE == pState->indx_CE_Tab[offset] ) {
    pHeader->bs_amp_res = pRoot_SCE_Element->bs_amp_res;
  } else {
    pHeader->bs_amp_res = IPP_MAX(pRoot_SCE_Element->bs_amp_res, (pRoot_SCE_Element+1)->bs_amp_res);
  }
#endif

  return status;
}