sbr_dec_parser.c

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

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

    for (rel = 0; rel < (*nEnv) - 1; rel++) {
      GET_BITS(BS, tmp, 2, Ipp32s);
      ret_cnt += 2;
      bs_rel_bord_1[rel] = 2 * tmp + 2;
    }

    ptr_bits = TABLE_PTR_BITS[ *nEnv ];
    GET_BITS(BS, *bs_pointer, ptr_bits, Ipp32s);
    ret_cnt += ptr_bits;
    for (env = 0; env < (*nEnv); env++) {
      GET_BITS(BS, freqRes[ *nEnv - 1 - env], 1, Ipp32s);
      ret_cnt++;
    }

// TimeFrequency Grid
    absBordLead = 0;
    absBordTrail = bs_var_bord_1 + NUM_TIME_SLOTS;
    n_RelLead = 0;
    n_RelTrail = bs_num_rel_1;
// relBordLead[l] - N/A
    for (l = 0; l < n_RelTrail; l++) {
      relBordTrail[l] = bs_rel_bord_1[l];
    }

    break;

  case VARFIX:
    GET_BITS(BS, bs_var_bord_0, 2, Ipp32s);
    ret_cnt += 2;
    GET_BITS(BS, bs_num_rel_0, 2, Ipp32s);
    ret_cnt += 2;
    *nEnv = bs_num_rel_0 + 1;

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

    for (rel = 0; rel < (*nEnv) - 1; rel++) {
      GET_BITS(BS, tmp, 2, Ipp32s);
      ret_cnt += 2;
      bs_rel_bord_0[rel] = 2 * tmp + 2;
    }
    ptr_bits = TABLE_PTR_BITS[ *nEnv ];
    GET_BITS(BS, *bs_pointer, ptr_bits, Ipp32s);
    ret_cnt += ptr_bits;
    for (env = 0; env < (*nEnv); env++) {
      GET_BITS(BS, freqRes[env], 1, Ipp32s);
      ret_cnt++;
    }

// TimeFrequency Grid
    absBordLead = bs_var_bord_0;
    absBordTrail = NUM_TIME_SLOTS;
    n_RelLead = bs_num_rel_0;
    n_RelTrail = 0;
    for (l = 0; l < n_RelLead; l++) {
      relBordLead[l] = bs_rel_bord_0[l];
    }
// relBordTrail - N/A

    break;

  case VARVAR:
    GET_BITS(BS, bs_var_bord_0, 2, Ipp32s);
    ret_cnt += 2;
    GET_BITS(BS, bs_var_bord_1, 2, Ipp32s);
    ret_cnt += 2;
    GET_BITS(BS, bs_num_rel_0, 2, Ipp32s);
    ret_cnt += 2;
    GET_BITS(BS, bs_num_rel_1, 2, Ipp32s);
    ret_cnt += 2;

    *nEnv = bs_num_rel_0 + bs_num_rel_1 + 1;

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

    for (rel = 0; rel < bs_num_rel_0; rel++) {
      GET_BITS(BS, tmp, 2, Ipp32s);
      ret_cnt += 2;
      bs_rel_bord_0[rel] = 2 * tmp + 2;
    }
    for (rel = 0; rel < bs_num_rel_1; rel++) {
      GET_BITS(BS, tmp, 2, Ipp32s);
      ret_cnt += 2;
      bs_rel_bord_1[rel] = 2 * tmp + 2;
    }
// ptr_bits = (Ipp32s)ceil( log(pSBRItem->nEnv[ch]+1.f)/log(2.) );
    ptr_bits = TABLE_PTR_BITS[ *nEnv ];
    GET_BITS(BS, *bs_pointer, ptr_bits, Ipp32s);
    ret_cnt += ptr_bits;
    for (env = 0; env < (*nEnv); env++) {
      GET_BITS(BS, freqRes[env], 1, Ipp32s);
      ret_cnt++;
    }

// TimeFrequency Grid
    absBordLead = bs_var_bord_0;
    absBordTrail = bs_var_bord_1 + NUM_TIME_SLOTS;
    n_RelLead = bs_num_rel_0;
    n_RelTrail = bs_num_rel_1;
    for (l = 0; l < n_RelLead; l++) {
      relBordLead[l] = bs_rel_bord_0[l];
    }
    for (l = 0; l < n_RelTrail; l++) {
      relBordTrail[l] = bs_rel_bord_1[l];
    }

    break;
  }     // end of switch

  *nNoiseEnv = ((*nEnv) > 1) ? 2 : 1;

  /* diagnostic */
  {
    Ipp32s tmp_max = 0;
    ippsZero_32s(bordersEnv, MAX_NUM_ENV+1);
    ippsMax_32s(bordersEnv, MAX_NUM_ENV+1, &tmp_max);
  }
// TimeFrequency Grid
  bordersEnv[0] = absBordLead;
  bordersEnv[ *nEnv ] = absBordTrail;

  for (l = 1; l <= n_RelLead; l++) {
    tmp_32s = 0;
    for (i = 0; i < l; i++) {
      tmp_32s += relBordLead[i];
    }
    bordersEnv[l] = absBordLead + tmp_32s;
  }
  for (l = n_RelLead + 1; l < (*nEnv); l++) {
    tmp_32s = 0;
    for (i = 0; i < (*nEnv) - l; i++) {
      tmp_32s += relBordTrail[i];
    }
    bordersEnv[l] = absBordTrail - tmp_32s;
  }

  /* diagnostic */
  {
    Ipp32s tmp_max = 0;
    ippsMax_32s(bordersEnv, MAX_NUM_ENV+1, &tmp_max);

    if ( tmp_max * RATE >= (NUM_TIME_SLOTS * RATE + SBR_TIME_HFGEN) ) {
      *status = SBR_ERR_REQUIREMENTS;
      return SBR_ERR_REQUIREMENTS;
    }
  }

  if ( (*nEnv) == 1) {
    bordersNoise[0] = bordersEnv[0];
    bordersNoise[1] = bordersEnv[1];
  } else {
    bordersNoise[0] = bordersEnv[0];
    tmp_32s =
      middleBorder( *bs_frame_class, *bs_pointer, *nEnv);
    bordersNoise[1] = bordersEnv[tmp_32s];
    bordersNoise[2] = bordersEnv[ *nEnv ];
  }

  return ret_cnt;
}

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

void sbr_grid_coupling(sSBRDecComState * pSBRItem)
{
  Ipp32s env, l;

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

  pSBRItem->bs_frame_class[1] = pSBRItem->bs_frame_class[0];

  switch (pSBRItem->bs_frame_class[1]) {
  case FIXFIX:
    pFIState1->nEnv = pFIState0->nEnv;
    pFIState1->freqRes[0] = pFIState0->freqRes[0];
    for (env = 0; env < pFIState1->nEnv; env++) {
      pFIState1->freqRes[env] = pFIState1->freqRes[0];
    }

    break;

  case FIXVAR:
    pFIState1->nEnv = pFIState0->nEnv;

    pSBRItem->bs_pointer[1] = pSBRItem->bs_pointer[0];
    for (env = 0; env < pFIState1->nEnv; env++)
      pFIState1->freqRes[pFIState1->nEnv - 1 - env] = pFIState0->freqRes[pFIState1->nEnv - 1 - env];

    break;

  case VARFIX:
    pFIState1->nEnv = pFIState0->nEnv;

    pSBRItem->bs_pointer[1] = pSBRItem->bs_pointer[0];
    for (env = 0; env < pFIState1->nEnv; env++)
      pFIState1->freqRes[env] = pFIState0->freqRes[env];

    break;

  case VARVAR:
    pFIState1->nEnv = pFIState0->nEnv;
    pSBRItem->bs_pointer[1] = pSBRItem->bs_pointer[0];
    for (env = 0; env < pFIState1->nEnv; env++)
      pFIState1->freqRes[env] = pFIState0->freqRes[env];

    break;
  }

  pFIState1->nNoiseEnv = pFIState0->nNoiseEnv;

  for (l = 0; l <= pFIState1->nEnv; l++) {
    pFIState1->bordersEnv[l] = pFIState0->bordersEnv[l];
  }

  for (l = 0; l <= pFIState1->nNoiseEnv; l++) {
    pFIState1->bordersNoise[l] = pFIState0->bordersNoise[l];
  }
}

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

Ipp32s sbr_dtdf(sBitsreamBuffer * BS, Ipp32s* bs_df_env, Ipp32s* bs_df_noise, Ipp32s nEnv, Ipp32s nNoiseEnv)
{
  Ipp32s ret_cnt = 0;
  Ipp32s env;
  Ipp32s noise;

  for (env = 0; env < nEnv; env++) {
    GET_BITS(BS, bs_df_env[env], 1, Ipp32s);
    ret_cnt++;
  }
  for (noise = 0; noise < nNoiseEnv; noise++) {
    GET_BITS(BS, bs_df_noise[noise], 1, Ipp32s);
    ret_cnt++;
  }

  return ret_cnt;
}

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

Ipp32s sbr_invf(Ipp32s ch, sBitsreamBuffer * BS, sSBRDecComState * pSBRItem)
{
  Ipp32s ret_cnt = 0;
  Ipp32s n;
  Ipp32s num_noise_bands = pSBRItem->sbrFreqTabsState.nNoiseBand;

  if (pSBRItem->bs_coupling == 1) {
    for (n = 0; n < num_noise_bands; n++) {
      GET_BITS(BS, pSBRItem->bs_invf_mode[ch][n], 2, Ipp32s);
      pSBRItem->bs_invf_mode[1][n] = pSBRItem->bs_invf_mode[ch][n];
      ret_cnt += 2;
    }
  } else {
    for (n = 0; n < num_noise_bands; n++) {
      GET_BITS(BS, pSBRItem->bs_invf_mode[ch][n], 2, Ipp32s);
      ret_cnt += 2;
    }
  }

  return ret_cnt;
}

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

static Ipp16s sbr_huff_dec(void *t_huff, sBitsreamBuffer * pBS, Ipp32s *cnt, Ipp16s LAV)
{
  Ipp16s index = 0;
  Ipp32s tmp = pBS->nBit_offset;
  Ipp32s num_bit_read = 0;
  Ipp8u  *pSrc;
  Ipp32s bitoffset;

  pSrc = (Ipp8u *)pBS->pCurrent_dword + ((32 - pBS->nBit_offset) >> 3);
  bitoffset = (32 - pBS->nBit_offset) & 0x7;

  ippsVLCDecodeOne_1u16s(&pSrc, &bitoffset, &index,
                         (IppsVLCDecodeSpec_32s *) t_huff);

  pBS->pCurrent_dword = (Ipp32u *)(pSrc - ((Ipp32s)(pSrc) & 3));
  pBS->dword = BSWAP(pBS->pCurrent_dword[0]);
  pBS->nBit_offset =
    32 - ((pSrc - (Ipp8u *)pBS->pCurrent_dword) << 3) - bitoffset;
/*
 * patch
 */
  if (pBS->nBit_offset < tmp)
    num_bit_read = tmp - pBS->nBit_offset;
  else
    num_bit_read = tmp + (32 - pBS->nBit_offset);

  *cnt = (*cnt) + num_bit_read;

  return index - LAV;
}

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

Ipp32s sbr_envelope(Ipp32s ch, Ipp32s bs_coupling, Ipp32s bs_amp_res, sBitsreamBuffer * BS,
                    sSBRDecComState * pSBRItem)
{
  Ipp32s env;
  Ipp32s ret_cnt = 0;
  Ipp32s band;
  Ipp32s num_env_bands[2];     // = {pSBRItem->n[0], pSBRItem->n[1]};
  Ipp16s bs_env_start_value_balance;
  Ipp16s bs_env_start_value_level;
  void   *t_huff;
  void   *f_huff;
  Ipp16s LAV;

  sSBREnvDataState* pEDState = &(pSBRItem->sbrEDState[ch]);

  sSBRFrameInfoState* pFIState = &(pSBRItem->sbrFIState[ch]);

  Ipp32s*   sizeEnv = pEDState->vSizeEnv;

  num_env_bands[0] = pSBRItem->sbrFreqTabsState.nLoBand;// n[0];
  num_env_bands[1] = pSBRItem->sbrFreqTabsState.nHiBand;//  n[1];

  /* patch */
  sizeEnv[0] = 0;
  for(env = 1; env <= pFIState->nEnv; env++)
    sizeEnv[env] = sizeEnv[env-1] + num_env_bands[pFIState->freqRes[env-1]];
  // LE - total size

  if (bs_coupling) {
    if (ch) {
      if (bs_amp_res) {
        t_huff = pSBRItem->sbrHuffTables[6];        // t_huffman_env_bal_3_0dB;//
        f_huff = pSBRItem->sbrHuffTables[7];        // f_huffman_env_bal_3_0dB;//
        LAV = 12;
      } else {
        t_huff = pSBRItem->sbrHuffTables[2];        // t_huffman_env_bal_1_5dB;//
        f_huff = pSBRItem->sbrHuffTables[3];        // f_huffman_env_bal_1_5dB;//
        LAV = 24;
      }
    } else {
      if (bs_amp_res) {
        t_huff = pSBRItem->sbrHuffTables[4];        // t_huffman_env_3_0dB;//
        f_huff = pSBRItem->sbrHuffTables[5];        // f_huffman_env_3_0dB;//
        LAV = 31;
      } else {
        t_huff = pSBRItem->sbrHuffTables[0];        // t_huffman_env_1_5dB;//
        f_huff = pSBRItem->sbrHuffTables[1];        // f_huffman_env_1_5dB;//
        LAV = 60;
      }
    }
  } else {
    if (bs_amp_res) {
      t_huff = pSBRItem->sbrHuffTables[4];  // t_huffman_env_3_0dB;//
      f_huff = pSBRItem->sbrHuffTables[5];  // f_huffman_env_3_0dB;//
      LAV = 31;
    } else {
      t_huff = pSBRItem->sbrHuffTables[0];  // t_huffman_env_1_5dB;//
      f_huff = pSBRItem->sbrHuffTables[1];  // f_huffman_env_1_5dB;//
      LAV = 60;
    }

  }

  for (env = 0; env < pFIState->nEnv; env++) {
    if (pEDState->bs_df_env[env] == 0) {
      if (bs_coupling && ch) {
        if (bs_amp_res) {
          GET_BITS(BS, bs_env_start_value_balance, 5, Ipp16s);
          pEDState->bufEnvQuant[sizeEnv[env]+0] = bs_env_start_value_balance;
          ret_cnt += 5;
        } else {
          GET_BITS(BS, bs_env_start_value_balance, 6, Ipp16s);
          pEDState->bufEnvQuant[sizeEnv[env]+0] = bs_env_start_value_balance;
          ret_cnt += 6;
        }
      } else {
        if (bs_amp_res) {
          GET_BITS(BS, bs_env_start_value_level, 6, Ipp16s);
          pEDState->bufEnvQuant[sizeEnv[env]+0] = bs_env_start_value_level;
          ret_cnt += 6;
        } else {
          GET_BITS(BS, bs_env_start_value_level, 7, Ipp16s);
          pEDState->bufEnvQuant[sizeEnv[env]+0] = bs_env_start_value_level;
          ret_cnt += 7;
        }
      }
      for (band = 1; band < num_env_bands[pFIState->freqRes[env]]; band++) {
        pEDState->bufEnvQuant[sizeEnv[env]+band] =
          sbr_huff_dec(f_huff, BS, &ret_cnt, LAV);

        pEDState->bufEnvQuant[sizeEnv[env]+band] = SBR_ENV_PROTECT(pEDState->bufEnvQuant[sizeEnv[env]+band]);
      }
    } else {
      for (band = 0; band < num_env_bands[pFIState->freqRes[env]]; band++) {
        pEDState->bufEnvQuant[sizeEnv[env]+band] =
          sbr_huff_dec(t_huff, BS, &ret_cnt, LAV);

        pEDState->bufEnvQuant[sizeEnv[env]+band] = SBR_ENV_PROTECT(pEDState->bufEnvQuant[sizeEnv[env]+band]);
      }
    }
  }

  return ret_cnt;
}

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

Ipp32s sbr_noise(sBitsreamBuffer* BS, Ipp16s* vNoise, Ipp32s* vSize, Ipp32s* bs_df_noise,
                 void* sbrHuffTables[10], Ipp32s ch, Ipp32s bs_coupling, Ipp32s nNoiseEnv, Ipp32s NQ)
{
  Ipp32s ret_cnt = 0;
  Ipp32s noise;
  Ipp32s band;
  Ipp16s bs_noise_start_value_balance;
  Ipp16s bs_noise_start_value_level;
  void   *t_huff;
  void   *f_huff;
  Ipp16s LAV;

  vSize[0] = 0;
  vSize[1] = NQ;
  // total size
  vSize[2] = 2*NQ;

  if (bs_coupling) {
    if (ch) {
      t_huff = sbrHuffTables[9];  // t_huffman_noise_bal_3_0dB;//
      f_huff = sbrHuffTables[7];  // f_huffman_env_bal_3_0dB;//
      LAV = 12;
    } else {
      t_huff = sbrHuffTables[8];  // t_huffman_noise_3_0dB;//
      f_huff = sbrHuffTables[5];  // f_huffman_env_3_0dB;//
      LAV = 31;
    }
  } else {
    t_huff = sbrHuffTables[8];    // t_huffman_noise_3_0dB;//
    f_huff = sbrHuffTables[5];    // f_huffman_env_3_0dB;//
    LAV = 31;
  }

  for (noise = 0; noise < nNoiseEnv; noise++) {
    if (bs_df_noise[noise] == 0) {
      if (bs_coupling && ch) {
        GET_BITS(BS, bs_noise_start_value_balance, 5, Ipp16s);
        vNoise[vSize[noise]] = bs_noise_start_value_balance;

      } else {
        GET_BITS(BS, bs_noise_start_value_level, 5, Ipp16s);
        vNoise[vSize[noise]] = bs_noise_start_value_level;
      }
      ret_cnt += 5;

      for (band = 1; band < NQ; band++) {
        vNoise[vSize[noise] + band] =
          sbr_huff_dec(f_huff, BS, &ret_cnt, LAV);

        vNoise[vSize[noise] + band] = SBR_NOISE_PROTECT(vNoise[vSize[noise] + band]);
      }
    } else {
      for (band = 0; band < NQ; band++) {
        vNoise[vSize[noise]+band] =
          sbr_huff_dec(t_huff, BS, &ret_cnt, LAV);

        vNoise[vSize[noise] + band] = SBR_NOISE_PROTECT(vNoise[vSize[noise] + band]);
      }
    }
  }

  return ret_cnt;
}

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

Ipp32s sbr_sinusoidal_coding(sBitsreamBuffer * BS, Ipp32s* pDst, Ipp32s len)
{
  Ipp32s n;
  Ipp32s ret_cnt = 0;

  for (n = 0; n < len; n++) {
    GET_BITS(BS, pDst[n], 1, Ipp32s);
  }

  ret_cnt = len;

  return ret_cnt;
}

/* EOF */