sbr_dec_parser.c

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

      ret_cnt += 2;
      num_bits_left -= 2;

      /* PS PARSER */
      GET_BITS_COUNT(BS, decodeBitsStart);
      /* patch. you can turn off support of PS decoder */
      if( NULL == pSBRItem->psState && EXTENSION_ID_PS == bs_extension_id){
        bs_extension_id = !EXTENSION_ID_PS;
      }
      error = sbr_extension(BS, pSBRItem->psState, bs_extension_id);

      if (error) return SBR_ERR_PARSER;

      GET_BITS_COUNT(BS, decodeBitsStop);

      ret_cnt       += ( decodeBitsStop - decodeBitsStart );
      num_bits_left -= ( decodeBitsStop - decodeBitsStart );
    }
  }

  return ret_cnt;
}

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

static Ipp32s sbr_channel_pair_base_element(sBitsreamBuffer * BS, sSBRDecComState * pSBRItem)
{
  Ipp32s ret_cnt = 0;
  Ipp32s cnt = 0;
  Ipp32s num_bits_left = 0;

  Ipp32s bs_data_extra;
  Ipp32s bs_reserved;
  Ipp32s bs_esc_count;

  Ipp32s bs_extended_data  = 0;
  Ipp32s bs_extension_size = 0;
  Ipp32s bs_extension_id   = 0;

  sSBRFrameInfoState* pFIState0 = &(pSBRItem->sbrFIState[0]);

  sSBREnvDataState*   pEDState0 = &(pSBRItem->sbrEDState[0]);

  Ipp32s decodeBitsStart = 0, decodeBitsStop = 0, error = 0;


  GET_BITS(BS, bs_data_extra, 1, Ipp32s);
  ret_cnt++;
  if (bs_data_extra) {
    GET_BITS(BS, bs_reserved, 8, Ipp32s);
    ret_cnt += 8;
  }

  GET_BITS(BS, pSBRItem->bs_coupling, 1, Ipp32s);
  ret_cnt++;

  ret_cnt += sbr_grid(BS, &(pSBRItem->bs_frame_class[0]), &(pSBRItem->bs_pointer[0]),
                      pFIState0->freqRes, pFIState0->bordersEnv,
                      pFIState0->bordersNoise, &(pFIState0->nEnv),
                      &(pFIState0->nNoiseEnv), &error );

  if(error)
    return error;

  ret_cnt += sbr_dtdf(BS, pEDState0->bs_df_env, pEDState0->bs_df_noise,
                          pFIState0->nEnv, pFIState0->nNoiseEnv);
  ret_cnt += sbr_invf(0, BS, pSBRItem);

  ret_cnt += sbr_envelope(0, 1, pSBRItem->sbrHeader.bs_amp_res, BS, pSBRItem);

  ret_cnt += sbr_noise(BS, pEDState0->bufNoiseQuant, pEDState0->vSizeNoise,
                       pEDState0->bs_df_noise, pSBRItem->sbrHuffTables, 0, 1,
                       pFIState0->nNoiseEnv, pSBRItem->sbrFreqTabsState.nNoiseBand);

  GET_BITS(BS, pEDState0->bs_add_harmonic_flag, 1, Ipp32s);
  ret_cnt++;
  if (pEDState0->bs_add_harmonic_flag) {
    ret_cnt += sbr_sinusoidal_coding(BS, pEDState0->bs_add_harmonic, pSBRItem->sbrFreqTabsState.nHiBand);
  } else {
    Ipp32s     i;

    for (i = 0; i < MAX_NUM_ENV_VAL; i++) {
      pEDState0->bs_add_harmonic[i] = 0;
    }
  }

  GET_BITS(BS, bs_extended_data, 1, Ipp32s);
  ret_cnt++;
  if (bs_extended_data) {
    GET_BITS(BS, cnt, 4, Ipp32s);
    bs_extension_size = cnt;
    ret_cnt += 4;
    if (cnt == 15) {

   GET_BITS(BS, bs_esc_count, 8, Ipp32s);
      ret_cnt += 8;
    }

    num_bits_left = 8 * cnt;
    while (num_bits_left > 7) {
      GET_BITS(BS, bs_extension_id, 2, Ipp32s);
      ret_cnt += 2;
      num_bits_left -= 2;

      /* PS PARSER */
      GET_BITS_COUNT(BS, decodeBitsStart);
      /* patch. you can turn off support of PS decoder */
      if( NULL == pSBRItem->psState && EXTENSION_ID_PS == bs_extension_id){
        bs_extension_id = !EXTENSION_ID_PS;
      }
      error = sbr_extension(BS, pSBRItem->psState, bs_extension_id);

      if (error) return SBR_ERR_PARSER;

      GET_BITS_COUNT(BS, decodeBitsStop);

      ret_cnt       += ( decodeBitsStop - decodeBitsStart );
      num_bits_left -= ( decodeBitsStop - decodeBitsStart );
    }
  }

  return ret_cnt;
}

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

static Ipp32s sbr_channel_pair_enhance_element(sBitsreamBuffer * BS,
                                               sSBRDecComState * pSBRItem)
{
  Ipp32s     ret_cnt = 0;
  sSBRFrameInfoState* pFIState1 = &(pSBRItem->sbrFIState[1]);

//  sSBREnvDataState*   pEDState0 = &(pSBRItem->sbrEDState[0]);
  sSBREnvDataState*   pEDState1 = &(pSBRItem->sbrEDState[1]);

  ret_cnt += sbr_dtdf(BS, pEDState1->bs_df_env, pEDState1->bs_df_noise,
                          pFIState1->nEnv, pFIState1->nNoiseEnv);

  ret_cnt += sbr_envelope(1, 1, pSBRItem->sbrHeader.bs_amp_res, BS, pSBRItem);
  ret_cnt += sbr_noise(BS, pEDState1->bufNoiseQuant, pEDState1->vSizeNoise,
                       pEDState1->bs_df_noise,
                       pSBRItem->sbrHuffTables, 1, 1, pFIState1->nNoiseEnv,
                       pSBRItem->sbrFreqTabsState.nNoiseBand);

  GET_BITS(BS, pEDState1->bs_add_harmonic_flag, 1, Ipp32s);
  ret_cnt += pEDState1->bs_add_harmonic_flag;
  ret_cnt++;
  if (pEDState1->bs_add_harmonic_flag) {
    ret_cnt += sbr_sinusoidal_coding(BS, pEDState1->bs_add_harmonic, pSBRItem->sbrFreqTabsState.nHiBand);
  } else {
    Ipp32s     i;

    for (i = 0; i < MAX_NUM_ENV_VAL; i++) {
      pEDState1->bs_add_harmonic[i] = 0;
    }
  }

  return ret_cnt;
}

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

static
Ipp32s sbr_data(sBitsreamBuffer * BS,
                Ipp32s id_aac,
                sSBRDecComState * pSBRItem)
{
  Ipp32s cnt = 0;
  Ipp32s error = 0;

  switch (pSBRItem->sbr_layer) {
  case SBR_NOT_SCALABLE:
    switch (id_aac) {
    case ID_SCE:

/* parser */
      error = sbr_single_channel_element(BS, pSBRItem);

      if(SBR_ERR_REQUIREMENTS == error)
        return error;
      else
        cnt = error;

/* algorithm decode */
      error = sbrEnvNoiseDec(pSBRItem, 0);
      if (error)
        return error;

      break;

    case ID_CPE:

/* parser */
      error = sbr_channel_pair_element(BS, pSBRItem);

      if(SBR_ERR_REQUIREMENTS == error)
        return error;
      else
        cnt = error;

/* algorithm decode */
      error = sbrEnvNoiseDec(pSBRItem, 0);
      if (error)
        return error;

      error = sbrEnvNoiseDec(pSBRItem, 1);
      if (error)
        return error;

      break;
    }
    break;

  case SBR_MONO_BASE:
    error = sbr_channel_pair_base_element(BS, pSBRItem);

    if(SBR_ERR_REQUIREMENTS == error)
        return error;
      else
        cnt = error;

    break;

  case SBR_STEREO_ENHANCE:
    error = sbr_channel_pair_enhance_element(BS, pSBRItem);

    if(SBR_ERR_REQUIREMENTS == error)
        return error;
      else
        cnt = error;

    break;

  case SBR_STEREO_BASE:
    error = sbr_channel_pair_element(BS, pSBRItem);

    if(SBR_ERR_REQUIREMENTS == error)
        return error;
      else
        cnt = error;

    break;
  }
/*
  if (error) {
    printf("\nthere is error %i\n", error);
  }
 */
  return cnt;
}

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

static Ipp32s GetValSbrLayer(void)
{
  return SBR_NOT_SCALABLE;
}

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

Ipp32s sbr_extension_data(Ipp32s id_aac,
                          Ipp32s crc_flag,
                          sSBRDecComState * pSBRItem,
                          sBitsreamBuffer * BS,
                          Ipp32s cnt)
{
  Ipp32s num_sbr_bits = 0;
  Ipp32s num_align_bits;
  Ipp32s sbr_layer = 0;
  Ipp32s ret_val;
  Ipp32s i;
  Ipp32s bs_header_flag;
  Ipp32s error = 0;
  Ipp32s k2 = 0;
  Ipp32s tmp = 0;
  sSBRHeader* pSBRHeader = &(pSBRItem->sbrHeader);
  sSBRFeqTabsState* pFTState = &(pSBRItem->sbrFreqTabsState);

  if (crc_flag) {
    GET_BITS(BS, pSBRItem->bs_sbr_crc_bits, 10, Ipp32s);
    num_sbr_bits += 10;
  }

  sbr_layer = GetValSbrLayer();
  pSBRItem->sbr_layer = sbr_layer;

  if (sbr_layer != SBR_STEREO_ENHANCE) {
    num_sbr_bits += 1;
    GET_BITS(BS, bs_header_flag, 1, Ipp32s);

    if (bs_header_flag) {
      pSBRItem->sbrHeaderFlagPresent++;

      //num_sbr_bits += sbr_header(BS, pSBRHeader );

      tmp = error = sbr_header(BS, pSBRHeader );

      if( error == SBR_ERR_REQUIREMENTS ){
        pSBRItem->sbrFlagError = SBR_ERR_REQUIREMENTS;
        return SBR_ERR_REQUIREMENTS;

      }else{
        num_sbr_bits += tmp;
        error = 0;

        if(pSBRItem->sbrFlagError == SBR_ERR_REQUIREMENTS) {
          pSBRItem->sbrHeader.Reset = 1;
          pSBRItem->sbrFlagError = SBR_NO_ERR;
        }

      }
    }

    if ((pSBRItem->sbrHeaderFlagPresent != 0) && (pSBRItem->sbrHeader.Reset == 1) && (pSBRItem->sbrFlagError == SBR_NO_ERR)) {

      error = sbrCalcMasterFreqBoundary(pSBRHeader->bs_start_freq,
                                        pSBRHeader->bs_stop_freq,
                                        pSBRItem->sbr_freq_indx,
                                        &(pSBRItem->k0), &k2 );

      if (error)
        return error;

      error = sbrCalcMasterFreqBandTab( // in data
                                       pSBRItem->k0, k2,
                                       pSBRHeader->bs_freq_scale,
                                       pSBRHeader->bs_alter_scale,
                                       // out data
                                       pFTState->fMasterBandTab,
                                       &(pFTState->nMasterBand));

      if (error)
        return error;

      error = sbrCalcDerivedFreqTabs(pFTState,
                                     pSBRHeader->bs_xover_band,
                                     pSBRHeader->bs_noise_bands,
                                     k2,
                                     &(pSBRItem->kx),
                                     &(pSBRItem->M) );

      if (error)
        return error;

      error =  sbrCalcPatchConstructTab(pFTState->fMasterBandTab,
                                        pFTState->nMasterBand,
                                        pSBRItem->M,
                                        pSBRItem->kx,
                                        pSBRItem->k0,
                                        pSBRItem->sbr_freq_indx,

                                        pFTState->patchNumSubbandsTab,
                                        pFTState->patchStartSubbandTab,
                                        &(pFTState->numPatches) );


      if (error)
        return error;

      error = sbrCalcLimBandTab(pSBRHeader->bs_limiter_bands,
                                pFTState->fLoBandTab,
                                pFTState->nLoBand,
                                pFTState->numPatches,
                                pFTState->patchNumSubbandsTab,

                                pFTState->fLimBandTab,
                                &(pFTState->nLimBand));
      if (error)
        return error;

    } else {
      /* NOTHING */
    }
  }

  if (pSBRItem->sbrHeaderFlagPresent != 0 && pSBRItem->sbrFlagError == SBR_NO_ERR) {
    //num_sbr_bits += sbr_data(BS, id_aac, pSBRItem);
      error = sbr_data(BS, id_aac, pSBRItem);
      if(SBR_ERR_REQUIREMENTS == error)
        return error;
      else
        num_sbr_bits += error;
  }

  pSBRItem->cnt_bit -= num_sbr_bits;
  num_align_bits = 8 * cnt - 4 - num_sbr_bits;

  for (i = 0; i < (num_align_bits >> 5); i++) {
    GET_BITS(BS, tmp, 32, Ipp32s);
  }

  if ((num_align_bits - (num_align_bits & (~0x1F))) != 0) {
    GET_BITS(BS, tmp, (num_align_bits - (num_align_bits & (~0x1F))), Ipp32s);
  }

  ret_val = (num_sbr_bits + num_align_bits + 4) / 8;

  return ret_val;

}

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

static Ipp32s middleBorder(Ipp32s bs_frame_class, Ipp32s bs_pointer, Ipp32s nEnv)
{
  Ipp32s indx1, indx2, ret_val;
  Ipp32s TableMidBorder[3][3];

  TableMidBorder[2][0] = TableMidBorder[1][0] = TableMidBorder[0][0] = nEnv / 2;
  TableMidBorder[0][1] = 1;
  TableMidBorder[1][1] = TableMidBorder[1][2] = TableMidBorder[0][2] = nEnv - 1;
  TableMidBorder[2][1] = bs_pointer - 1;
  TableMidBorder[2][2] = nEnv + 1 - bs_pointer;

  if ((bs_pointer > 1) || (bs_pointer < 0))
    indx1 = 2;
  else
    indx1 = bs_pointer;

  if (bs_frame_class == FIXFIX)
    indx2 = 0;
  else if (bs_frame_class == VARFIX)
    indx2 = 1;
  else
    indx2 = 2;

  ret_val = TableMidBorder[indx1][indx2];

  return ret_val;
}

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

Ipp32s sbr_grid(sBitsreamBuffer * BS, Ipp32s* bs_frame_class, Ipp32s* bs_pointer, Ipp32s* freqRes, Ipp32s* bordersEnv,
                Ipp32s* bordersNoise, Ipp32s* nEnv, Ipp32s* nNoiseEnv, Ipp32s* status)
{
  Ipp32s ret_cnt = 0;
  Ipp32s env, rel;
  Ipp32s ptr_bits = 0;
  Ipp32s tmp;
  Ipp32s absBordLead = 0;
  Ipp32s absBordTrail = 0;
  Ipp32s bs_var_bord_0 = 0;
  Ipp32s bs_var_bord_1 = 0;
  Ipp32s bs_num_rel_1 = 0;
  Ipp32s bs_num_rel_0 = 0;
  Ipp32s n_RelLead = 0;
  Ipp32s n_RelTrail = 0;
  Ipp32s bs_rel_bord_0[32];
  Ipp32s bs_rel_bord_1[32];
  Ipp32s relBordLead[32];
  Ipp32s relBordTrail[32];
  Ipp32s l, i;
  Ipp32s tmp_32s;
  const Ipp32s TABLE_PTR_BITS[6] = { 0, 1, 2, 2, 3, 3 };

  /* patch */
  *status = 0;

  /* AYA: MAY BE POTENCIAL BUG? */
  GET_BITS(BS, *bs_frame_class, 2, Ipp32s);
  ret_cnt += 2;

  switch ( *bs_frame_class ) {
  case FIXFIX:
    GET_BITS(BS, tmp, 2, Ipp32s);
    ret_cnt += 2;
    *nEnv = 1 << tmp;

    /* patch */
    if( *nEnv > 5 ){
      *status = SBR_ERR_REQUIREMENTS;
      return SBR_ERR_REQUIREMENTS;
    }

    GET_BITS(BS, freqRes[0], 1, Ipp32s);
    ret_cnt++;

    for (env = 1; env < (*nEnv); env++) {
      freqRes[env] = freqRes[0];
    }

// TimeFrequency Grid
    absBordLead = 0;
    absBordTrail = NUM_TIME_SLOTS;
    n_RelLead = *nEnv - 1;
    n_RelTrail = 0;

     tmp_32s = NUM_TIME_SLOTS / (*nEnv);
    for (l = 0; l < n_RelLead; l++) {
      relBordLead[l] = tmp_32s;
    }
// relBordTrail - N/A

    break;

  case FIXVAR:
    GET_BITS(BS, bs_var_bord_1, 2, Ipp32s);
    ret_cnt += 2;
    GET_BITS(BS, bs_num_rel_1, 2, Ipp32s);
    ret_cnt += 2;
    *nEnv = bs_num_rel_1 + 1;