sbr_enc_bitstream.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) 2006 Intel Corporation. All Rights Reserved.
//
//     Intel(R) Integrated Performance Primitives AAC Decode Sample for Windows*
//
*/

#include <stdlib.h>
#include <stdio.h>
#include "sbr_enc_dbg.h"
#include "bstream.h"
/* HEAAC profile */
#include "aaccmn_const.h"
#include "sbr_enc_settings.h"
#include "sbr_enc_api_fp.h"
#include "sbr_enc_own_fp.h"

#ifdef SBR_NEED_LOG
#include "sbr_enc_dbg.h"
#endif

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

static Ipp32s enc_sbr_header(sSBRHeader* pState, sBitsreamBuffer* pBS)
{
  Ipp32s payloadBits = 0;
  Ipp32s bs_reserved = 0;

  //PUT_BITS(pBS, pState->bs_amp_res,    1);
  PUT_BITS(pBS, 1,    1);
  PUT_BITS(pBS, pState->bs_start_freq, 4);
  PUT_BITS(pBS, pState->bs_stop_freq,  4);
  PUT_BITS(pBS, pState->bs_xover_band, 3);
  PUT_BITS(pBS, bs_reserved,           2);
  PUT_BITS(pBS, pState->bs_extra_1,    1);
  PUT_BITS(pBS, pState->bs_extra_2,    1);

  payloadBits += 1 + 4 + 4 + 3 + 2 + 1 + 1;

  if (pState->bs_extra_1) {

    PUT_BITS(pBS, pState->bs_freq_scale,  2);
    PUT_BITS(pBS, pState->bs_alter_scale, 1);
    PUT_BITS(pBS, pState->bs_noise_bands, 2);

    payloadBits += 2 + 1 + 2;
  }

  if (pState->bs_extra_2){

    PUT_BITS(pBS, pState->bs_limiter_bands,  2);
    PUT_BITS(pBS, pState->bs_limiter_gains,  2);
    PUT_BITS(pBS, pState->bs_interpol_freq,  1);
    PUT_BITS(pBS, pState->bs_smoothing_mode, 1);

    payloadBits += 2 + 2 + 1 + 1;
  }


  return payloadBits;
}

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

/* y = log2(x) */

static Ipp32s supLOG2(Ipp32s x)
{
  Ipp32s y = -1;

  while((1<<++y) < x);

  return y;
}

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

static Ipp32s
enc_sbr_grid(sSBREnc_SCE_State* pState, sBitsreamBuffer* pBS)
{
  Ipp32s payloadBits = 0;
  Ipp32s bs_frame_class = pState->sbrGrid.frameClass;
  //Ipp32s bs_num_env = pState->sbrGrid.bs_num_env;
  Ipp32s bs_num_env = pState->sbrFIState.nEnv;
  Ipp32s temp = 0;
  Ipp32s env, rel;

  PUT_BITS(pBS, bs_frame_class,  2);
  payloadBits += 2;


  switch( bs_frame_class ) {
//---------------------------------
    case FIXFIX:
      temp = supLOG2( bs_num_env );

      PUT_BITS(pBS, temp,  2);
      payloadBits += 2;

      PUT_BITS(pBS, pState->sbrFIState.freqRes[0],  1);
      payloadBits += 1;

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

      temp = pState->sbrGrid.bs_abs_bord - 16;
      if ( VARFIX == bs_frame_class){
        temp = pState->sbrGrid.bs_abs_bord;
      }

      PUT_BITS(pBS, temp,  2);
      payloadBits += 2;

      PUT_BITS(pBS, pState->sbrGrid.n,  2);
      payloadBits += 2;

      for(rel = 0; rel < pState->sbrGrid.n; rel++){
        temp = (pState->sbrGrid.bs_rel_bord[rel] - 2) >> 1;

        PUT_BITS(pBS, temp,  2);
        payloadBits += 2;
      }

      temp = supLOG2( pState->sbrGrid.n + 2 );

      PUT_BITS(pBS, pState->sbrGrid.bs_pointer,  temp);
      payloadBits += temp;

      for(env = 0; env < pState->sbrGrid.n + 1; env++){
        PUT_BITS(pBS, pState->sbrGrid.bs_freq_res[env],  1);
        payloadBits += 1;
      }

      break;
//---------------------------------
    case VARVAR:
      temp = pState->sbrGrid.bs_abs_bord_0;

      PUT_BITS(pBS, temp,  2);
      payloadBits += 2;

      temp = pState->sbrGrid.bs_abs_bord_1 - 16;
      PUT_BITS(pBS, temp,  2);
      payloadBits += 2;

      PUT_BITS(pBS, pState->sbrGrid.bs_num_rel_0,  2);
      PUT_BITS(pBS, pState->sbrGrid.bs_num_rel_1,  2);
      payloadBits += 2 + 2;

      /* rel_0 */
      for(rel = 0; rel < pState->sbrGrid.bs_num_rel_0; rel++){
        temp = (pState->sbrGrid.bs_rel_bord_0[rel] - 2) >> 1;

        PUT_BITS(pBS, temp,  2);
        payloadBits += 2;
      }

      /* rel_1 */
      for(rel = 0; rel < pState->sbrGrid.bs_num_rel_1; rel++){
        temp = (pState->sbrGrid.bs_rel_bord_1[rel] - 2) >> 1;

        PUT_BITS(pBS, temp,  2);
        payloadBits += 2;
      }

      temp =  pState->sbrGrid.bs_num_rel_0 + pState->sbrGrid.bs_num_rel_1 + 2;
      temp = supLOG2( temp );

      /* bs_pointer */
      PUT_BITS(pBS, pState->sbrGrid.bs_pointer,  temp);
      payloadBits += temp;

      temp = pState->sbrGrid.bs_num_rel_0 + pState->sbrGrid.bs_num_rel_1 + 1;
      for(env = 0; env < temp; env++){
        PUT_BITS(pBS, pState->sbrGrid.bs_freq_res_LR[env],  1);
        payloadBits += 1;
      }

      break;
//---------------------------------
    default:
      break;
  }


  return payloadBits;
}

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

static Ipp32s enc_sbr_dtdf(sSBREnc_SCE_State* pState, sBitsreamBuffer* pBS)
{
  Ipp32s payloadBits  = 0;
  Ipp32s nDataEnv  = pState->sbrFIState.nEnv;
  Ipp32s nNoiseEnv = (nDataEnv > 1) ? 2 : 1;
  Ipp32s env;

  /* data env */
  for(env = 0; env < nDataEnv; env++){
    PUT_BITS(pBS, pState->sbrEDState.bs_df_env[env],  1);
    payloadBits += 1;
  }

  /* noise envelope */
  for(env = 0; env < nNoiseEnv; env++){
    PUT_BITS(pBS, pState->sbrEDState.bs_df_noise[env],  1);
    payloadBits += 1;
  }

  return payloadBits;
}

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

static Ipp32s enc_sbr_invf(sSBREnc_SCE_State* pState, sBitsreamBuffer* pBS, Ipp32s nNoiseEnv)
{
  Ipp32s payloadBits  = 0;
  Ipp32s env;

  for(env = 0; env < nNoiseEnv; env++){
    PUT_BITS(pBS, pState->sbrInvfEst.bs_invf_mode[env],  2);
    payloadBits += 2;
  }

  return payloadBits;
}

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

static Ipp32s
 enc_sbr_envelope(sSBREnc_SCE_State* pState, IppsVLCEncodeSpec_32s*  sbrHuffTabs[NUM_SBR_HUFF_TABS],
                  sBitsreamBuffer* pBS, Ipp32s bs_amp_res, Ipp32s nLoBand, Ipp32s nHiBand)
{
  IppsVLCEncodeSpec_32s* pTimeHuffTab;
  IppsVLCEncodeSpec_32s* pFreqHuffTab;
  IppsVLCEncodeSpec_32s *pCurrHuffTab;

  Ipp32s *bs_df_env   = pState->sbrEDState.bs_df_env;
  Ipp32s *bs_freq_res = pState->sbrFIState.freqRes;
  Ipp16s *bs_data_env = pState->sbrEDState.bufEnvQuant;

  Ipp32s payloadBits  = 0;
  Ipp32s env;
  Ipp32s bs_num_env  = pState->sbrFIState.nEnv;
  Ipp32s bs_coupling = 0;
  //Ipp32s bs_amp_res  = pState->sbrHeader.bs_amp_res;
  Ipp32s band;
  Ipp32s nSfBand[2];
  Ipp32s bs_start_env_bit = (bs_amp_res) ? 6 : 7;
  Ipp32s my_bs_start_env_bit;

  Ipp16s  LAV;
  Ipp16s  delta;
  Ipp32s  pos = 0;

  Ipp32s  bs_cw_bits;
  //Ipp32s  bs_codeword;
  Ipp8u  *pDst;
  Ipp32s bitoffset;

  /* init */
  nSfBand[0] = nLoBand; //pState->sbrFreqTabsState.nLoBand;
  nSfBand[1] = nHiBand; //pState->sbrFreqTabsState.nHiBand;

  /* alternativa */
  sbrencSetEnvHuffTabs(bs_amp_res,
                      &LAV,
                      &my_bs_start_env_bit,

                      &pTimeHuffTab,
                      &pFreqHuffTab,
                      sbrHuffTabs,

                      HUFF_ENV_COMPRESS); /* [1] - envelope, [0] - noise */

  for(env = 0; env < bs_num_env; env++){
    if ( 0 == bs_df_env[env] ){

      pCurrHuffTab  = pFreqHuffTab;

      if(bs_coupling){
        // none
      }else{
        PUT_BITS(pBS, bs_data_env[pos], bs_start_env_bit);
        pos++;
        payloadBits += bs_start_env_bit;
      }
    } else {

      pCurrHuffTab  = pTimeHuffTab;
    }

    /* LOG ------------------------------------------- */
    pDst = (Ipp8u*)pBS->pCurrent_dword + ((32 - pBS->nBit_offset) >> 3);
    bitoffset = (32 - pBS->nBit_offset) & 0x7;
    SAVE_BITSTREAM(pBS)
    /* LOG ------------------------------------------- */

    for(band = 1 - bs_df_env[env]; band < nSfBand[ bs_freq_res[env] ]; band++ ){
      delta = bs_data_env[pos];
      pos++;

      /* AYA */
      //printf("\n dirty = %i \n", delta);
      bs_cw_bits = ownVLCCountBits_16s32s(delta + LAV, pCurrHuffTab);

      delta = delta + LAV;
      ippsVLCEncodeBlock_16s1u(&delta, 1, &pDst, &bitoffset, pCurrHuffTab);

      payloadBits += bs_cw_bits;
    } /* for(band=0; */
    /* LOG ------------------------------------------- */
    pBS->pCurrent_dword = (Ipp32u*)(pDst - ((Ipp32s)(pDst) & 3));
    pBS->nBit_offset = 32 - ((pDst - (Ipp8u*)pBS->pCurrent_dword) << 3)- bitoffset;
    LOAD_DWORD(pBS)
    /* LOG ------------------------------------------- */
  }     /* for(env=0; */

  return payloadBits;
}

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

static Ipp32s
enc_sbr_noise(sSBREnc_SCE_State* pState, IppsVLCEncodeSpec_32s*  sbrHuffTabs[NUM_SBR_HUFF_TABS],
              sBitsreamBuffer* pBS, Ipp32s nNoiseBand)
{
  IppsVLCEncodeSpec_32s* pTimeHuffTab;
  IppsVLCEncodeSpec_32s* pFreqHuffTab;
  IppsVLCEncodeSpec_32s *pCurrHuffTab;

  Ipp32s payloadBits = 0;
  Ipp32s nDataEnv  = pState->sbrFIState.nEnv;
  Ipp32s nNoiseEnv = (nDataEnv > 1) ? 2 : 1;

  Ipp32s env;
  Ipp32s band;
  Ipp32s *bs_df_noise   = pState->sbrEDState.bs_df_noise;
  Ipp16s *bs_data_noise = pState->sbrEDState.bufNoiseQuant;
//  Ipp32s ch = 0;

  Ipp16s LAV;
  Ipp16s delta;
  Ipp32s pos = 0;

  Ipp32s bs_cw_bits;
  //Ipp32s  bs_codeword;
  Ipp32s bs_start_noise_bit = 5;
  Ipp32s my_bs_amp_res = 0;
  Ipp32s my_bs_start_noise_bit;

  Ipp8u  *pDst;
  Ipp32s bitoffset;

  sbrencSetEnvHuffTabs(my_bs_amp_res,
                       &LAV,
                       &my_bs_start_noise_bit,