sbrdec_parser.c

这是在PCA下的基于IPP库示例代码例子,在网上下了IPP的库之后,设置相关参数就可以编译该代码.

/*//////////////////////////////////////////////////////////////////////////////
//
//                  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.
//
*/

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

#include<math.h>
#include<stdio.h>
#include "ippac.h"

#include "sbrdec_element.h"
#include "sbrdec_huftabs.h"

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

static Ipp32s sbr_extension(Ipp32s bs_extension_id, Ipp32s num_bits_left)
{
  bs_extension_id++;
  num_bits_left++;

  return 0;
}

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

#ifndef ID_SCE
#define ID_SCE    0x0
#endif

#ifndef ID_CPE
#define ID_CPE    0x1
#endif

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

static Ipp32s sbr_header(sBitsreamBuffer * BS, sSbrDecCommon* pSbrHeader)
{
  Ipp32s     cnt = 0;

  Ipp32s     bs_header_extra_1;
  Ipp32s     bs_header_extra_2;

  Ipp32s     bs_start_freq_new;
  Ipp32s     bs_stop_freq_new;
  Ipp32s     bs_freq_scale_new;
  Ipp32s     bs_alter_scale_new;
  Ipp32s     bs_xover_band_new;
  Ipp32s     bs_noise_bands_new;
  Ipp32s     bs_reserved;

  GET_BITS(BS, pSbrHeader->bs_amp_res, 1);
  GET_BITS(BS, bs_start_freq_new, 4);
  GET_BITS(BS, bs_stop_freq_new, 4);
  GET_BITS(BS, bs_xover_band_new, 3);

  GET_BITS(BS, bs_reserved, 2);

  GET_BITS(BS, bs_header_extra_1, 1);
  GET_BITS(BS, bs_header_extra_2, 1);

  cnt += 16;

  if (bs_header_extra_1) {
    GET_BITS(BS, bs_freq_scale_new, 2);
    GET_BITS(BS, bs_alter_scale_new, 1);
    GET_BITS(BS, bs_noise_bands_new, 2);

    cnt += 5;
  } else {      // default
    bs_freq_scale_new = 2;
    bs_alter_scale_new = 1;
    bs_noise_bands_new = 2;
  }

  if (bs_header_extra_2) {
    GET_BITS(BS, pSbrHeader->bs_limiter_bands, 2);
    GET_BITS(BS, pSbrHeader->bs_limiter_gains, 2);
    GET_BITS(BS, pSbrHeader->bs_interpol_freq, 1);
    GET_BITS(BS, pSbrHeader->bs_smoothing_mode, 1);

    cnt += 6;
  } else {      // default
    pSbrHeader->bs_limiter_bands = 2;
    pSbrHeader->bs_limiter_gains = 2;
    pSbrHeader->bs_interpol_freq = 1;
    pSbrHeader->bs_smoothing_mode = 1;
  }

  if ((pSbrHeader->bs_start_freq != bs_start_freq_new) ||
      (pSbrHeader->bs_stop_freq != bs_stop_freq_new) ||
      (pSbrHeader->bs_freq_scale != bs_freq_scale_new) ||
      (pSbrHeader->bs_alter_scale != bs_alter_scale_new) ||
      (pSbrHeader->bs_xover_band != bs_xover_band_new) ||
      (pSbrHeader->bs_noise_bands != bs_noise_bands_new)) {
    pSbrHeader->Reset = 1;

    pSbrHeader->bs_start_freq = bs_start_freq_new;
    pSbrHeader->bs_stop_freq = bs_stop_freq_new;
    pSbrHeader->bs_freq_scale = bs_freq_scale_new;
    pSbrHeader->bs_alter_scale = bs_alter_scale_new;
    pSbrHeader->bs_xover_band = bs_xover_band_new;
    pSbrHeader->bs_noise_bands = bs_noise_bands_new;
  } else {
    pSbrHeader->Reset = 0;
  }

  return cnt;
}

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

static Ipp32s sbr_single_channel_element(sBitsreamBuffer * BS, sSbrDecCommon * pSbr)
{
  Ipp32s     ret_cnt = 0;
  Ipp32s     cnt = 0;
  Ipp32s     num_bits_left = 0;
  Ipp32s     tmp = 0;
  Ipp32s     i;
  Ipp32s     bs_data_extra = 0;

  Ipp32s     bs_reserved = 0;
  Ipp32s     bs_esc_count = 0;
  Ipp32s     bs_amp_res;

  GET_BITS(BS, bs_data_extra, 1);
  ret_cnt++;

  if (bs_data_extra) {

  GET_BITS(BS, bs_reserved, 4);
    ret_cnt += 4;
  }
  ret_cnt += sbr_grid(BS, &(pSbr->bs_frame_class[0]), &(pSbr->bs_pointer[0]), pSbr->r[0],
                     pSbr->tE[0], pSbr->tQ[0], &(pSbr->L_E[0]),
                     &(pSbr->L_Q[0]) );
    //(0, BS, pSbr);
  ret_cnt += sbr_dtdf(BS, pSbr->bs_df_env[0], pSbr->bs_df_noise[0], pSbr->L_E[0], pSbr->L_Q[0]);
  ret_cnt += sbr_invf(0, BS, pSbr);
/*
 * patch
 */
  if ((pSbr->bs_frame_class[0] == FIXFIX) && (pSbr->L_E[0] == 1))
    bs_amp_res = 0;
  else
    bs_amp_res = pSbr->bs_amp_res;

  ret_cnt += sbr_envelope(0, 0, bs_amp_res, BS, pSbr);

  ret_cnt += sbr_noise(BS, pSbr->vecNoise[0], pSbr->vSizeNoise[0], pSbr->bs_df_noise[0],
    pSbr->sbrHuffTables, 0, 0, pSbr->L_Q[0], pSbr->N_Q);

  GET_BITS(BS, pSbr->bs_add_harmonic_flag[0], 1);
  ret_cnt++;
  if (pSbr->bs_add_harmonic_flag[0]) {
    ret_cnt += sbr_sinusoidal_coding( BS, pSbr->bs_add_harmonic[0], pSbr->N_high );   //(0, BS, pSbr);
  } else {
    for (i = 0; i < MAX_NUM_ENV_VAL; i++) {
      pSbr->bs_add_harmonic[0][i] = 0;
    }
  }

  GET_BITS(BS, pSbr->bs_extended_data, 1);
  ret_cnt++;

  if (pSbr->bs_extended_data) {
    GET_BITS(BS, cnt, 4);
    pSbr->bs_extension_size = cnt;
    ret_cnt += 4;

    if (cnt == 15) {
      GET_BITS(BS, bs_esc_count, 8);
      cnt += bs_esc_count;
      ret_cnt += 8;
    }

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

      tmp = sbr_extension(pSbr->bs_extension_id, num_bits_left);
      ret_cnt += tmp;
      num_bits_left -= tmp;
    }
  }

  return ret_cnt;
}

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

static Ipp32s sbr_channel_pair_element(sBitsreamBuffer * BS, sSbrDecCommon * pSbr)
{
  Ipp32s     ret_cnt = 0;
  Ipp32s     cnt = 0;
  Ipp32s     num_bits_left = 0;
  Ipp32s     tmp = 0;
  Ipp32s     bs_data_extra = 1;

  Ipp32s bs_reserved = 0;
  Ipp32s     bs_esc_count = 0;
  Ipp32s     ampRes;

  GET_BITS(BS, bs_data_extra, 1);
  ret_cnt++;

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

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

  if (pSbr->bs_coupling) {
    ret_cnt += sbr_grid(BS, &(pSbr->bs_frame_class[0]), &(pSbr->bs_pointer[0]), pSbr->r[0],
      pSbr->tE[0], pSbr->tQ[0], &(pSbr->L_E[0]), &(pSbr->L_Q[0]) );

    sbr_grid_coupling(pSbr);

    ret_cnt += sbr_dtdf(BS, pSbr->bs_df_env[0], pSbr->bs_df_noise[0], pSbr->L_E[0],
               pSbr->L_Q[0]);
    ret_cnt += sbr_dtdf(BS, pSbr->bs_df_env[1], pSbr->bs_df_noise[1], pSbr->L_E[1],
               pSbr->L_Q[1]);
    ret_cnt += sbr_invf(0, BS, pSbr);

    if ((pSbr->bs_frame_class[0] == FIXFIX) && (pSbr->L_E[0] == 1))
      ampRes = 0;
    else
      ampRes = pSbr->bs_amp_res;

    ret_cnt += sbr_envelope(0, 1, ampRes, BS, pSbr);
    ret_cnt += sbr_noise(BS, pSbr->vecNoise[0], pSbr->vSizeNoise[0], pSbr->bs_df_noise[0],
    pSbr->sbrHuffTables, 0, 1, pSbr->L_Q[0], pSbr->N_Q);

    ret_cnt += sbr_envelope(1, 1, ampRes, BS, pSbr);
    ret_cnt += sbr_noise(BS, pSbr->vecNoise[1], pSbr->vSizeNoise[1], pSbr->bs_df_noise[1],
    pSbr->sbrHuffTables, 1, 1, pSbr->L_Q[1], pSbr->N_Q);
  } else {
    ret_cnt += sbr_grid(BS, &(pSbr->bs_frame_class[0]), &(pSbr->bs_pointer[0]), pSbr->r[0],
               pSbr->tE[0], pSbr->tQ[0], &(pSbr->L_E[0]),
               &(pSbr->L_Q[0]) );

      ret_cnt += sbr_grid(BS, &(pSbr->bs_frame_class[1]), &(pSbr->bs_pointer[1]), pSbr->r[1],
      pSbr->tE[1], pSbr->tQ[1], &(pSbr->L_E[1]), &(pSbr->L_Q[1]) );

    ret_cnt += sbr_dtdf(BS, pSbr->bs_df_env[0], pSbr->bs_df_noise[0], pSbr->L_E[0],
      pSbr->L_Q[0]);
    ret_cnt += sbr_dtdf(BS, pSbr->bs_df_env[1], pSbr->bs_df_noise[1], pSbr->L_E[1],
      pSbr->L_Q[1]);
    ret_cnt += sbr_invf(0, BS, pSbr);
    ret_cnt += sbr_invf(1, BS, pSbr);

    if ((pSbr->bs_frame_class[0] == FIXFIX) && (pSbr->L_E[0] == 1))
      ampRes = 0;
    else
      ampRes = pSbr->bs_amp_res;
    ret_cnt += sbr_envelope(0, 0, ampRes, BS, pSbr);
    if ((pSbr->bs_frame_class[1] == FIXFIX) && (pSbr->L_E[1] == 1))
      ampRes = 0;
    else
      ampRes = pSbr->bs_amp_res;
    ret_cnt += sbr_envelope(1, 0, ampRes, BS, pSbr);

    ret_cnt += sbr_noise(BS, pSbr->vecNoise[0], pSbr->vSizeNoise[0], pSbr->bs_df_noise[0],
    pSbr->sbrHuffTables, 0, 0, pSbr->L_Q[0], pSbr->N_Q);

    ret_cnt += sbr_noise(BS, pSbr->vecNoise[1], pSbr->vSizeNoise[1], pSbr->bs_df_noise[1],
    pSbr->sbrHuffTables, 1, 0, pSbr->L_Q[1], pSbr->N_Q);
  }

  GET_BITS(BS, pSbr->bs_add_harmonic_flag[0], 1);
  ret_cnt++;
  if (pSbr->bs_add_harmonic_flag[0]) {
    ret_cnt += sbr_sinusoidal_coding(BS, pSbr->bs_add_harmonic[0], pSbr->N_high);
  } else {
    Ipp32s     i;

    for (i = 0; i < MAX_NUM_ENV_VAL; i++) {
      pSbr->bs_add_harmonic[0][i] = 0;
    }
  }
  GET_BITS(BS, pSbr->bs_add_harmonic_flag[1], 1);
  ret_cnt++;
  if (pSbr->bs_add_harmonic_flag[1]) {
    ret_cnt += sbr_sinusoidal_coding(BS, pSbr->bs_add_harmonic[1], pSbr->N_high);
  } else {
    Ipp32s     i;

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

  GET_BITS(BS, pSbr->bs_extended_data, 1);
  ret_cnt++;
  if (pSbr->bs_extended_data) {
    GET_BITS(BS, cnt, 4);
    pSbr->bs_extension_size = cnt;
    ret_cnt += 4;
    if (cnt == 15) {
      GET_BITS(BS, bs_esc_count, 8);
      ret_cnt += 8;
      cnt += bs_esc_count;
    }

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

      tmp = sbr_extension(pSbr->bs_extension_id, num_bits_left);
      num_bits_left -= tmp;
      ret_cnt += tmp;
    }
  }

  return ret_cnt;
}

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

static Ipp32s sbr_channel_pair_base_element(sBitsreamBuffer * BS, sSbrDecCommon * pSbr)
{
  Ipp32s     ret_cnt = 0;
  Ipp32s     cnt = 0;
  Ipp32s     num_bits_left = 0;
  Ipp32s     tmp = 0;
  Ipp32s     bs_data_extra;
  Ipp32s     bs_reserved;
  Ipp32s     bs_esc_count;

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

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

  ret_cnt += sbr_grid(BS, &(pSbr->bs_frame_class[0]), &(pSbr->bs_pointer[0]), pSbr->r[0],
    pSbr->tE[0], pSbr->tQ[0], &(pSbr->L_E[0]), &(pSbr->L_Q[0]) );
  ret_cnt += sbr_dtdf(BS, pSbr->bs_df_env[0], pSbr->bs_df_noise[0], pSbr->L_E[0], pSbr->L_Q[0]);
  ret_cnt += sbr_invf(0, BS, pSbr);

  ret_cnt += sbr_envelope(0, 1, pSbr->bs_amp_res, BS, pSbr);
  ret_cnt += sbr_noise(BS, pSbr->vecNoise[0], pSbr->vSizeNoise[0], pSbr->bs_df_noise[0],
    pSbr->sbrHuffTables, 0, 1, pSbr->L_Q[0], pSbr->N_Q);

  GET_BITS(BS, pSbr->bs_add_harmonic_flag[0], 1);
  ret_cnt++;
  if (pSbr->bs_add_harmonic_flag[0]) {
    ret_cnt += sbr_sinusoidal_coding(BS, pSbr->bs_add_harmonic[0], pSbr->N_high);
  } else {
    Ipp32s     i;

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

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

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

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

  return ret_cnt;
}

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

static Ipp32s sbr_channel_pair_enhance_element(sBitsreamBuffer * BS,
                                            sSbrDecCommon * pSbr)
{
  Ipp32s     ret_cnt = 0;

  ret_cnt += sbr_dtdf(BS, pSbr->bs_df_env[1], pSbr->bs_df_noise[1], pSbr->L_E[1], pSbr->L_Q[1]);

  ret_cnt += sbr_envelope(1, 1, pSbr->bs_amp_res, BS, pSbr);
  ret_cnt += sbr_noise(BS, pSbr->vecNoise[1], pSbr->vSizeNoise[1], pSbr->bs_df_noise[1],
    pSbr->sbrHuffTables, 1, 1, pSbr->L_Q[1], pSbr->N_Q);

  GET_BITS(BS, pSbr->bs_add_harmonic_flag[1], 1);
  ret_cnt += pSbr->bs_add_harmonic_flag[1];
  ret_cnt++;
  if (pSbr->bs_add_harmonic_flag[1]) {
    ret_cnt += sbr_sinusoidal_coding(BS, pSbr->bs_add_harmonic[1], pSbr->N_high);
  } else {
    Ipp32s     i;

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

  return ret_cnt;
}

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

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

  switch (pSbr->SbrLayer) {
  case SBR_NOT_SCALABLE:
    switch (id_aac) {
    case ID_SCE:

/* parser */
       cnt = sbr_single_channel_element(BS, pSbr);

/* algorithm decode */
      sbrEnvNoiseDec(pSbr, 0);

      break;

    case ID_CPE:

/* parser */
      cnt = sbr_channel_pair_element(BS, pSbr);

/* algorithm decode */
      sbrEnvNoiseDec(pSbr, 0);
      sbrEnvNoiseDec(pSbr, 1);

      break;
    }
    break;

  case SBR_MONO_BASE:
    cnt = sbr_channel_pair_base_element(BS, pSbr);
    break;

  case SBR_STEREO_ENHANCE:
    cnt = sbr_channel_pair_enhance_element(BS, pSbr);
    break;

  case SBR_STEREO_BASE:
    cnt = sbr_channel_pair_element(BS, pSbr);
    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, sSbrDecCommon * pSbr,
                       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;

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

  sbr_layer = GetValSbrLayer();
  pSbr->SbrLayer = sbr_layer;

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

    if (bs_header_flag) {
      pSbr->sbrHeaderFlagPresent++;
      num_sbr_bits += sbr_header(BS, pSbr );
    }

    if ((pSbr->sbrHeaderFlagPresent != 0) && (pSbr->Reset == 1)) {

      error = sbrCalcMasterFreqBoundary(pSbr->bs_start_freq, pSbr->bs_stop_freq,
                                        pSbr->FreqSbr, pSbr->sbr_freq_indx,
                                        &(pSbr->k0), &k2 );

      if (error)
        return error;

      error = sbrCalcMasterFreqBandTable(       // in data
                                          pSbr->k0, k2,
                                          pSbr->bs_freq_scale,
                                          pSbr->bs_alter_scale,
                                  // out data
                                          pSbr->f_master, &(pSbr->N_master));

      if (error)
        return error;

      error = sbrCalcDerivedFreqTables( pSbr->bs_xover_band, pSbr->bs_noise_bands,
                                        k2, pSbr);

      if (error)
        return error;

      error = sbrPatchConstruction(pSbr, pSbr->sbr_freq_indx);


      if (error)
        return error;

      error = sbrCalcLimiterFreqBandTable(      // in data
                                   pSbr->bs_limiter_bands, pSbr->f_TableLow,
                                   pSbr->N_low, pSbr->numPatches,
                                   pSbr->patchNumSubbands,
                           // out data
                                   pSbr->f_TableLim, &(pSbr->N_L));
      if (error)
        return error;

    } else {
    }
  }