sbr_dec_parser.c

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

/*//////////////////////////////////////////////////////////////////////////////
//
//                  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-2007 Intel Corporation. All Rights Reserved.
//
*/

#include <math.h>
#include <stdio.h>
#include "ippac.h"
/* sbr decoder */
#include "sbr_struct.h"
#include "sbr_freq_tabs.h"
#include "sbr_dec_parser.h"
#include "sbr_huff_tabs.h"
/* parametric stereo */
#include "ps_dec_settings.h"
#include "ps_dec_struct.h"
#include "ps_dec_parser.h"

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

#define SBR_ENV_PROTECT( data ) data
//IPP_MAX( IPP_MIN(data, 128), 0 )

#define SBR_NOISE_PROTECT( data ) data
//IPP_MAX( IPP_MIN(data, 30), 0 )

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

static
Ipp32s sbr_extension(sBitsreamBuffer * BS,
                     sPSDecComState* pPSItem,
                     Ipp32s bs_extension_id)
{
  Ipp32s error = 0;//no error

  switch( bs_extension_id ){
    case EXTENSION_ID_PS:

      error = ps_dec_parser( BS, pPSItem );

      if( error ) {

        return SBR_ERR_PARSER;
      }


      break;

    default:

      break;

  }

  return SBR_NO_ERR;
}

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

#ifndef ID_SCE
#define ID_SCE    0x0
#endif

#ifndef ID_CPE
#define ID_CPE    0x1
#endif

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

static Ipp32s sbr_header_default_fill(sSBRHeader* pSbrHeader)
{

  pSbrHeader->bs_amp_res = 1; //default

  pSbrHeader->bs_start_freq = 0; //default

  pSbrHeader->bs_stop_freq = 0; //default

  pSbrHeader->bs_xover_band = 0; //default

  pSbrHeader->bs_freq_scale = BS_FREQ_SCALE_DEFAULT;

  pSbrHeader->bs_alter_scale = BS_ALTER_SCALE_DEFAULT;

  pSbrHeader->bs_noise_bands = BS_NOISE_BANDS_DEFAULT;

  pSbrHeader->bs_limiter_bands = BS_LIMITER_BANDS_DEFAULT;

  pSbrHeader->bs_limiter_gains = BS_LIMITER_GAINS_DEFAULT;

  pSbrHeader->bs_interpol_freq = BS_INTERPOL_FREQ_DEFAULT;

  pSbrHeader->bs_smoothing_mode = BS_SMOOTHING_MODE_DEFAULT;

  return 0;//OK
}

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

static Ipp32s is_sbr_header_valid(sSBRHeader* pSbrHeader)
{
  Ipp32s res = SBR_OK;

  if(pSbrHeader->bs_amp_res < 0 || pSbrHeader->bs_amp_res > 1)
    return SBR_ERR_REQUIREMENTS;

  if(pSbrHeader->bs_start_freq < 0)
    return SBR_ERR_REQUIREMENTS;

  if(pSbrHeader->bs_stop_freq < 0)
    return SBR_ERR_REQUIREMENTS;

  if(pSbrHeader->bs_freq_scale < 0 || pSbrHeader->bs_freq_scale > 3)
    return SBR_ERR_REQUIREMENTS;

  if(pSbrHeader->bs_alter_scale < 0 || pSbrHeader->bs_alter_scale > 1)
    return SBR_ERR_REQUIREMENTS;

  if(pSbrHeader->bs_noise_bands < 0 || pSbrHeader->bs_noise_bands > 3)
    return SBR_ERR_REQUIREMENTS;

  if(pSbrHeader->bs_limiter_bands < 0 || pSbrHeader->bs_limiter_bands > 3)
    return SBR_ERR_REQUIREMENTS;

  if(pSbrHeader->bs_limiter_gains < 0 || pSbrHeader->bs_limiter_gains > 3)
    return SBR_ERR_REQUIREMENTS;

  if(pSbrHeader->bs_interpol_freq < 0 || pSbrHeader->bs_interpol_freq > 1)
    return SBR_ERR_REQUIREMENTS;

  if(pSbrHeader->bs_smoothing_mode < 0 || pSbrHeader->bs_smoothing_mode > 1)
    return SBR_ERR_REQUIREMENTS;

  return res;

}

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

static Ipp32s sbr_header(sBitsreamBuffer * BS, sSBRHeader* 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, Ipp32s);
  GET_BITS(BS, bs_start_freq_new, 4, Ipp32s);
  GET_BITS(BS, bs_stop_freq_new, 4, Ipp32s);
  GET_BITS(BS, bs_xover_band_new, 3, Ipp32s);

  GET_BITS(BS, bs_reserved, 2, Ipp32s);

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

  cnt += 16;

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

    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, Ipp32s);
    GET_BITS(BS, pSbrHeader->bs_limiter_gains, 2, Ipp32s);
    GET_BITS(BS, pSbrHeader->bs_interpol_freq, 1, Ipp32s);
    GET_BITS(BS, pSbrHeader->bs_smoothing_mode, 1, Ipp32s);

    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;
  }

  /*********************************************************************
   * NOTE:
   * check SBR header params
   *********************************************************************/
  if( is_sbr_header_valid(pSbrHeader) == SBR_ERR_REQUIREMENTS ){
    sbr_header_default_fill(pSbrHeader);
    return SBR_ERR_REQUIREMENTS;
  }
  //------------------------

  return cnt;
}

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

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

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

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

  Ipp32s decodeBitsStart = 0, decodeBitsStop = 0, error;

  sSBRFrameInfoState* pFIState = &(pSBRItem->sbrFIState[0]);
  sSBREnvDataState*   pEDState = &(pSBRItem->sbrEDState[0]);

  /* CODE */

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

  if (bs_data_extra) {

  GET_BITS(BS, bs_reserved, 4, Ipp32s);
    ret_cnt += 4;
  }
  ret_cnt += sbr_grid(BS,
                      &(pSBRItem->bs_frame_class[0]),
                      &(pSBRItem->bs_pointer[0]),
                      pFIState->freqRes,
                      pFIState->bordersEnv,
                      pFIState->bordersNoise,
                      &(pFIState->nEnv),
                      &(pFIState->nNoiseEnv),
                      &error );

  if(error)
    return SBR_ERR_REQUIREMENTS;

    //(0, BS, pSBRItem);
  ret_cnt += sbr_dtdf(BS, pEDState->bs_df_env, pEDState->bs_df_noise,
                          pFIState->nEnv, pFIState->nNoiseEnv);
  ret_cnt += sbr_invf(0, BS, pSBRItem);
/*
 * patch
 */
  if ((pSBRItem->bs_frame_class[0] == FIXFIX) && (pFIState->nEnv == 1))
    bs_amp_res = 0;
  else
    bs_amp_res = pSBRItem->sbrHeader.bs_amp_res;

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

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

  GET_BITS(BS, pEDState->bs_add_harmonic_flag, 1, Ipp32s);
  ret_cnt++;
  if (pEDState->bs_add_harmonic_flag) {
    ret_cnt += sbr_sinusoidal_coding( BS, pEDState->bs_add_harmonic, pSBRItem->sbrFreqTabsState.nHiBand );   //(0, BS, pSBRItem);
  } else {
    for (i = 0; i < MAX_NUM_ENV_VAL; i++) {
      pEDState->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);
      cnt += bs_esc_count;
      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);

      /* AYA path */
      if( EXTENSION_ID_PS == bs_extension_id ){
        //printf("PS_FILL_BITS = %i\n", ( decodeBitsStop - decodeBitsStart ));
      }

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

  return ret_cnt;
}

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

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

  Ipp32s bs_data_extra = 1;

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

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

  sSBRFeqTabsState*   pFTState = &(pSBRItem->sbrFreqTabsState);

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

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

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

  /* CODE */
  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++;

  if (pSBRItem->bs_coupling) {
    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;

    sbr_grid_coupling(pSBRItem);

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

    if ((pSBRItem->bs_frame_class[0] == FIXFIX) && (pFIState0->nEnv == 1))
      ampRes = 0;
    else
      ampRes = pSBRItem->sbrHeader.bs_amp_res;

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

    ret_cnt += sbr_envelope(1, 1, ampRes, BS, pSBRItem);
    ret_cnt += sbr_noise(BS, pEDState1->bufNoiseQuant, pEDState1->vSizeNoise,
                         pEDState1->bs_df_noise, pSBRItem->sbrHuffTables, 1, 1,
                         pFIState1->nNoiseEnv, pFTState->nNoiseBand);
  } else {
    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_grid(BS, &(pSBRItem->bs_frame_class[1]), &(pSBRItem->bs_pointer[1]),
                          pFIState1->freqRes, pFIState1->bordersEnv,
                          pFIState1->bordersNoise, &(pFIState1->nEnv),
                          &(pFIState1->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_dtdf(BS, pEDState1->bs_df_env, pEDState1->bs_df_noise, pFIState1->nEnv,
                        pFIState1->nNoiseEnv);
    ret_cnt += sbr_invf(0, BS, pSBRItem);
    ret_cnt += sbr_invf(1, BS, pSBRItem);

    if ((pSBRItem->bs_frame_class[0] == FIXFIX) && (pFIState0->nEnv == 1))
      ampRes = 0;
    else
      ampRes = pSBRItem->sbrHeader.bs_amp_res;
    ret_cnt += sbr_envelope(0, 0, ampRes, BS, pSBRItem);
    if ((pSBRItem->bs_frame_class[1] == FIXFIX) && (pFIState1->nEnv == 1))
      ampRes = 0;
    else
      ampRes = pSBRItem->sbrHeader.bs_amp_res;
    ret_cnt += sbr_envelope(1, 0, ampRes, BS, pSBRItem);

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

    ret_cnt += sbr_noise(BS, pEDState1->bufNoiseQuant, pEDState1->vSizeNoise,
                         pEDState1->bs_df_noise, pSBRItem->sbrHuffTables, 1, 0,
                         pFIState1->nNoiseEnv, pFTState->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, pFTState->nHiBand);
  } else {
    Ipp32s     i;

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

    for (i = 0; i < MAX_NUM_ENV_VAL; i++) {
      pEDState1->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;
      cnt += bs_esc_count;
    }

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