sbr_enc_frame_gen.c

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

    }

    n = len_bs_rel_bord;

    for (env = 0; env < iSplit; env++) {
      bs_freq_res[env] = freqRes[iSplit - 1 - env];
    }

    bs_freq_res[iSplit] = 1;

    /* pointer: */
    if (iSplit >= iTran && iTran != EMPTY_MAPPING) {
      bs_pointer = iSplit - iTran + 1;
    }

    pGridState->bs_abs_bord = absBord;
    pGridState->n = n;

    break;
//-----------------------
  case VARFIX:

    absBord = borders[0];

    for (i = 1; i < lenBord; i++) {
      rel_bord = borders[i] - borders[i - 1];
      sbrencAddRE2Buf(bs_rel_bord, &len_bs_rel_bord, rel_bord);
    }

    n = len_bs_rel_bord;

    for( env = 0; env < lenFreqRes; env++){
      bs_freq_res[env] = freqRes[env];
    }

    if (iTran >= 0 && iTran != EMPTY_MAPPING) {
      bs_pointer = iTran + 1;
    }

    pGridState->bs_abs_bord = absBord;
    pGridState->n = n;

    break;
//-----------------------
  case VARVAR:

    {
      lenBord = iSplit + 1;
      lenFreqRes = iSplit + 1;

      absBordLead = borders[0];
      absBordTrail = borders[lenBord - 1];

      nRightBord = lenBord - nLeftBord - 2;

      for (i = 1; i <= nLeftBord; i++) {
        rel_bord = borders[i] - borders[i - 1];
        sbrencAddRE2Buf(bs_rel_bord_0, &len_bs_rel_bord_0, rel_bord);
      }

      i = lenBord - 1;

      while (i >= lenBord - nRightBord) {
        rel_bord = borders[i] - borders[i - 1];
        sbrencAddRE2Buf(bs_rel_bord_1, &len_bs_rel_bord_1, rel_bord);
        i--;
      }

      if (iSplit >= iTran && iTran != EMPTY_MAPPING) {
        bs_pointer = iSplit - iTran + 1;
      }

      for (env = 0; env < lenBord - 1; env++) {
        bs_freq_res_LR[env] = freqRes[env];
      }
    }

    pGridState->bs_abs_bord_0 = absBordLead;
    pGridState->bs_abs_bord_1 = absBordTrail;
    pGridState->bs_num_rel_0  = nLeftBord;
    pGridState->bs_num_rel_1  = nRightBord;

    break;
//-----------------------
  default:
    /* do nothing */
    break;
//-----------------------
  } //END switch (frameClass) {

  pGridState->frameClass = frameClass;
  pGridState->bs_pointer = bs_pointer;

  return;
}

/***************************************************************************/

static Ipp32s sbrencGetStatic_FIXFIX_Tabs(sSBRFrameInfoState* pFIState, Ipp32s nEnv )
{
  Ipp32s indx = 0;
  const Ipp32s mapTab[] = { 0, 0, 1, 1, 2 };
  Ipp8u* pTab = NULL;

  if ( nEnv < 1 || nEnv > 4 )
    return -1; // error

  indx = mapTab[ nEnv ];

  pTab = (Ipp8u*)sbr_FIXFIX_FrameInfoTabs[ indx ];

  ippsCopy_8u(pTab, (Ipp8u*)pFIState, sizeof (sSBRFrameInfoState));

  return 0;//OK
}

/********************************************************************/

static void
sbrencSBRGrid2FrameInfo (sSBRGrid* pGridState, sSBRFrameInfoState* pFIState)
{
  Ipp32s nEnv = 0, border = 0;
  Ipp32s i, k;
  Ipp32s bs_pointer;
  sSBRGrid* in = pGridState;
  sSBRFrameInfoState* out = pFIState;

  Ipp32s frameClass = in->frameClass;

//---------------------------------------------------------
  switch (frameClass) {

  case FIXFIX:
    sbrencGetStatic_FIXFIX_Tabs(out, out->nEnv);

    break;

  case FIXVAR:
  case VARFIX:

    nEnv = in->n + 1;

    out->nEnv = nEnv;

    border = in->bs_abs_bord;

    if (nEnv == 1)
      out->nNoiseEnv = 1;
    else
      out->nNoiseEnv = 2;

    break;

  default:
    /* do nothing */
    break;
  }

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

  switch (frameClass) {
  case FIXVAR:

    out->bordersEnv[0] = 0;

    out->bordersEnv[nEnv] = border;

    for (k = 0, i = nEnv - 1; k < nEnv - 1; k++, i--) {
      border -= in->bs_rel_bord[k];

      out->bordersEnv[i] = border;
    }

    bs_pointer = in->bs_pointer;

    if (bs_pointer == 0) {

      out->shortEnv = 0;
    } else {

      out->shortEnv = nEnv + 1 - bs_pointer;
    }

    for (k = 0, i = nEnv - 1; k < nEnv; k++, i--) {
      out->freqRes[i] = in->bs_freq_res[k];
    }

    if (bs_pointer == 0 || bs_pointer == 1) {
      out->bordersNoise[1] = out->bordersEnv[nEnv - 1];
    } else {
      out->bordersNoise[1] = out->bordersEnv[out->shortEnv];
    }

    break;

  case VARFIX:
    out->bordersEnv[0] = border;

    for (k = 0; k < nEnv - 1; k++) {
      border += in->bs_rel_bord[k];
      out->bordersEnv[k + 1] = border;
    }

    out->bordersEnv[nEnv] = 16;

    bs_pointer = in->bs_pointer;

    if (bs_pointer == 0 || bs_pointer == 1) {
      out->shortEnv = 0;
    } else {
      out->shortEnv = bs_pointer - 1;
    }

    for (k = 0; k < nEnv; k++) {
      out->freqRes[k] = in->bs_freq_res[k];
    }

    switch (bs_pointer) {
    case 0:
      out->bordersNoise[1] = out->bordersEnv[1];
      break;
    case 1:
      out->bordersNoise[1] = out->bordersEnv[nEnv - 1];
      break;
    default:
      out->bordersNoise[1] = out->bordersEnv[out->shortEnv];
      break;
    }
    break;

  case VARVAR:
    nEnv = in->bs_num_rel_0 + in->bs_num_rel_1 + 1;

    out->nEnv = nEnv;

    out->bordersEnv[0] = border = in->bs_abs_bord_0;

    for (k = 0, i = 1; k < in->bs_num_rel_0; k++, i++) {
      border += in->bs_rel_bord_0[k];
      out->bordersEnv[i] = border;
    }

    border = in->bs_abs_bord_1;

    out->bordersEnv[nEnv] = border;

    for (k = 0, i = nEnv - 1; k < in->bs_num_rel_1; k++, i--) {
      border -= in->bs_rel_bord_1[k];
      out->bordersEnv[i] = border;
    }

    bs_pointer = in->bs_pointer;

    if (bs_pointer == 0) {
      out->shortEnv = 0;
    } else {
      out->shortEnv = nEnv + 1 - bs_pointer;
    }

    for (k = 0; k < nEnv; k++) {
      out->freqRes[k] = in->bs_freq_res_LR[k];
    }

    if (nEnv == 1) {
      out->nNoiseEnv = 1;
      out->bordersNoise[0] = in->bs_abs_bord_0;
      out->bordersNoise[1] = in->bs_abs_bord_1;
    } else {
      out->nNoiseEnv = 2;
      out->bordersNoise[0] = in->bs_abs_bord_0;

      if (bs_pointer == 0 || bs_pointer == 1) {
        out->bordersNoise[1] = out->bordersEnv[nEnv - 1];
      } else {
        out->bordersNoise[1] = out->bordersEnv[out->shortEnv];
      }

      out->bordersNoise[2] = in->bs_abs_bord_1;
    }
    break;

  default:
    /* do nothing */
    break;
  }

  if (frameClass == VARFIX || frameClass == FIXVAR) {

    out->bordersNoise[0] = out->bordersEnv[0];

    if (nEnv == 1) {
      out->bordersNoise[1] = out->bordersEnv[nEnv];
    } else {
      out->bordersNoise[2] = out->bordersEnv[nEnv];
    }
  }

  return;
}

/********************************************************************/

Ipp32s sbrencFrameGenerator(sSBREnc_SCE_State* pState, Ipp32s splitFlag)
{
  sSBRFrameInfoState* pFIState = &(pState->sbrFIState);
  sSBRGrid* pGridState = &(pState->sbrGrid);

  //sSBRGridRaw* pGRawNext = &( pState->sbrGridRawNext );
  //sSBRGridRaw* pGRaw     = &( pState->sbrGridRaw );

  /* current info */
  Ipp32s* borders = pState->sbrGridRaw.bufBorders;
  Ipp32s* freqRes = pState->sbrGridRaw.bufFreqRes;

  Ipp32s* lenBord   = &(pState->sbrGridRaw.lenBord);
  Ipp32s* lenFreqRes = &(pState->sbrGridRaw.lenFreqRes);

  /* next info */
  Ipp32s* bordersNext = pState->sbrGridRawNext.bufBorders;
  Ipp32s* freqResNext = pState->sbrGridRawNext.bufFreqRes;

  Ipp32s* lenBordNext   = &(pState->sbrGridRawNext.lenBord);
  Ipp32s* lenFreqResNext = &(pState->sbrGridRawNext.lenFreqRes);

  Ipp32s* iTranNext = &(pState->sbrGridRawNext.iTran);
  Ipp32s* iFillNext = &(pState->sbrGridRawNext.iFill);

  Ipp32s frameClass = FIXFIX;
  Ipp32s minBord = 0, maxBord = 0;
  Ipp32s tranFlag  = pState->sbrTransientState.tranFlag;
  Ipp32s tranPos   = pState->sbrTransientState.tranPos;
  Ipp32s numEnv;

  Ipp32s tran = 0;
  Ipp32s nSegments = 0;

  Ipp32s iSplit = 0;
  Ipp32s iTran  = 0;

  Ipp32s nLeftBord;

  /* CODE */

  frameClass = sbrencCalcFrameClass(pState->sbrGrid.frameClassOld, tranFlag);
  /* update oldFrameClass */
  pState->sbrGrid.frameClassOld = frameClass;

  if (tranFlag) {

    tran = tranPos + 4;

    sbrencLoadTransientBord(borders, lenBord, freqRes, lenFreqRes,
                            &minBord, &maxBord, tranPos);
  }
//---------------------

  switch ( frameClass ) {
//-----------------------
  case FIXFIX:

    /* patch */
    if( 0 == splitFlag )
      numEnv = 1;
    else
      numEnv = 2;

    pFIState->nEnv  = numEnv;
    pGridState->frameClass = frameClass;

    break;
//-----------------------
  case FIXVAR:

    //if( tranPos > 8 ) {
      sbrencLoadBordPreProc(borders, lenBord, freqRes, lenFreqRes, minBord, minBord);
    //}

    //if( tranPos < 10 ) {
      sbrencLoadBordPostProc(tranPos, borders, lenBord, freqRes, lenFreqRes, &nSegments);
    //}

    sbrencSplitGrid(borders, lenBord,
                    freqRes, lenFreqRes,
                    tran,
                    bordersNext, lenBordNext,
                    freqResNext, lenFreqResNext,

                    &iTran, &iSplit,
                    iTranNext, iFillNext,

                    nSegments);

    sbrencCalcSBRGrid(pGridState, frameClass,

                      borders, *lenBord,
                      freqRes, *lenFreqRes,
                      iSplit, iTran, EMPTY_MAPPING);

    break;
//-----------------------
  case VARFIX:

    sbrencCalcSBRGrid(pGridState, frameClass,

                      bordersNext, *lenBordNext,
                      freqResNext, *lenFreqResNext,
                      EMPTY_MAPPING, iTran, EMPTY_MAPPING);

    break;
//-----------------------
  case VARVAR:

    sbrencConflictResolution (borders, lenBord,
                              minBord,
                              freqRes, lenFreqRes,

                              bordersNext, lenBordNext,
                              freqResNext, lenFreqResNext,

                              *iFillNext, 4, 12,

                              &nLeftBord);

    sbrencLoadBordPostProc(tranPos,
                           borders, lenBord,
                           freqRes, lenFreqRes,
                           &nSegments);

    sbrencSplitGrid(borders, lenBord,
                    freqRes, lenFreqRes,
                    tran,
                    bordersNext, lenBordNext,
                    freqResNext, lenFreqResNext,

                    &iTran, &iSplit,
                    iTranNext, iFillNext,

                    nSegments);

    sbrencCalcSBRGrid(pGridState, frameClass,
                      borders, *lenBord,
                      freqRes, *lenFreqRes,
                      iSplit, iTran, nLeftBord);

    break;
//-----------------------
  } /* END of SWITCH */

//  printf("\nlen_bord = %i\n", *lenBord);

  sbrencSBRGrid2FrameInfo (pGridState, pFIState);

    /* AYA */
  //-------------------------------------------------
   /* debug */
#ifdef SBR_NEED_LOG
  {
    Ipp32s i;

    fprintf(logFile, "SbrFrameInfo\n");

    fprintf(logFile, "frameClass = %i\n", frameClass);

    fprintf(logFile, "envelopes = %i\n", pFIState->nEnv);
    fprintf(logFile, "shortEnv = %i\n", pFIState->shortEnv);
    fprintf(logFile, "nNoiseEnvelopes = %i\n", pFIState->nNoiseEnv);

    fprintf(logFile, "borders v\n");
    for(i=0; i<pFIState->nEnv; i++){
      fprintf(logFile, "borders[%i] = %i  ", i, pFIState->bordersEnv[i]);
    }

    fprintf(logFile, "\nfreqRes v\n");
    for(i=0; i<pFIState->nEnv; i++){
      fprintf(logFile, "freqRes[%i] = %i  ", i, pFIState->freqRes[i]);
    }

    fprintf(logFile, "\nbordersNoise v\n");
    for(i=0; i<pFIState->nNoiseEnv; i++){
      fprintf(logFile, "bordersNoise[%i] = %i  ", i, pFIState->bordersNoise[i]);
    }

    fprintf(logFile, "\n");

  }
#endif
  //-------------------------------------------------

  return 0; //OK

}