sbr_enc_bitstream.c

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

                       &pTimeHuffTab,
                       &pFreqHuffTab,

                       sbrHuffTabs,

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

  for(env = 0; env < nNoiseEnv; env++){
    if ( 0 == bs_df_noise[env] ){

      pCurrHuffTab     = pFreqHuffTab;

      PUT_BITS(pBS, bs_data_noise[pos], bs_start_noise_bit);
      pos++;
      payloadBits += bs_start_noise_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_noise[env]; band < nNoiseBand; band++ ){
      delta = bs_data_noise[pos];
      pos++;

      //bs_codeword = pCurrHuffTabCode[ delta + LAV ];
      bs_cw_bits = ownVLCCountBits_16s32s(delta + LAV, pCurrHuffTab);

      //PUT_BITS(pBS, bs_codeword, bs_cw_bits);
      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_sinusoidal_coding(sSBREnc_SCE_State* pState, sBitsreamBuffer* pBS, Ipp32s nBand)
{
  Ipp32s payloadBits = 0;
  Ipp32s band;
  Ipp32s *bs_add_harmonic = pState->sbrEDState.bs_add_harmonic;

  for(band = 0; band < nBand; band++){
    PUT_BITS(pBS, bs_add_harmonic[band], 1);
    payloadBits += 1;
  }

  return payloadBits;
}

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

static Ipp32s
enc_sbr_single_channel_element(sSBREncState* pState, sBitsreamBuffer* pBS)
{
  Ipp32s indx = pState->indx_FreqOffset_Tab[ pState->indx_CE_Tab[ pState->sbr_offset ] ];

  sSBREnc_SCE_State* pSCE_Element = ( pState->pSCE_Element + pState->sbr_offset );
  sSBRFeqTabsState*  pFreqtabsState = ( pState->sbrFreqTabsState + indx);
//  sSBRHeader*        pHeader = ( pState->sbrHeader + indx);

  Ipp32s payloadBits      = 0;
  Ipp32s bs_data_extra    = 0; /* no extra data */
  Ipp32s bs_extended_data = 0; /* no extended data */
  Ipp32s add_harm_flag    = pSCE_Element->sbrEDState.bs_add_harmonic_flag;
  Ipp32s bs_amp_res       = 0;

  /* no bs_reserved, bs_data_extra = 0 */
  PUT_BITS(pBS, bs_data_extra,  1);
  payloadBits++;

  payloadBits += enc_sbr_grid(pSCE_Element, pBS);

  payloadBits += enc_sbr_dtdf(pSCE_Element, pBS);

  payloadBits += enc_sbr_invf(pSCE_Element, pBS, pFreqtabsState->nNoiseBand);

  bs_amp_res = pSCE_Element->bs_amp_res;
  payloadBits += enc_sbr_envelope(pSCE_Element,
                                  pState->sbrHuffTabs,
                                  pBS,
                                  bs_amp_res, //pHeader->bs_amp_res,
                                  pFreqtabsState->nLoBand,
                                  pFreqtabsState->nHiBand);

  payloadBits += enc_sbr_noise(pSCE_Element,
                               pState->sbrHuffTabs,
                               pBS,
                               pFreqtabsState->nNoiseBand);

  PUT_BITS(pBS, add_harm_flag, 1);
  payloadBits++;

  if(add_harm_flag) {
    payloadBits += enc_sbr_sinusoidal_coding(pSCE_Element,
                                             pBS,
                                             pFreqtabsState->nHiBand);
  }

  PUT_BITS(pBS, bs_extended_data,  1);
  payloadBits++;

  return payloadBits;
}

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

static Ipp32s
sbrencUpDateAmpRes( Ipp32s nEnv, Ipp32s frameClass )
{
  Ipp32s ampRes = 1; // 3.0dB

  if( (FIXFIX == frameClass) && (1 == nEnv) ){
    ampRes = 0;// 1.5dB
  }

  return ampRes;
}

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

#if 1
static Ipp32s
enc_sbr_channel_pair_element(sSBREncState* pState, sBitsreamBuffer* pBS)
{
  Ipp32s payloadBits      = 0;
  Ipp32s bs_data_extra    = 0; /* no extra data */
  Ipp32s bs_extended_data = 0; /* no extended data */
  Ipp32s bs_coupling      = 0; /* no coupling channel */
  Ipp32s bs_amp_res       = 0;

  /* current info */
  Ipp32s indx = pState->indx_FreqOffset_Tab[ pState->indx_CE_Tab[ pState->sbr_offset ] ];

  sSBREnc_SCE_State* pSCE_Element = ( pState->pSCE_Element + pState->sbr_offset );
  sSBRFeqTabsState*  pFreqtabsState = ( pState->sbrFreqTabsState + indx);
//  sSBRHeader*        pHeader = ( pState->sbrHeader + indx);

  Ipp32s add_harm_flag_0  = (pSCE_Element + 0)->sbrEDState.bs_add_harmonic_flag;
  Ipp32s add_harm_flag_1  = (pSCE_Element + 1)->sbrEDState.bs_add_harmonic_flag;

  /* no bs_reserved, bs_data_extra = 0 */
  PUT_BITS(pBS, bs_data_extra,  1);
  payloadBits++;

  /* no bs_coupling, bs_coupling = 0 */
  PUT_BITS(pBS, bs_coupling, 1);
  payloadBits++;

  /* grid */
  payloadBits += enc_sbr_grid(pSCE_Element + 0, pBS); //ch = 0

  payloadBits += enc_sbr_grid(pSCE_Element + 1, pBS); //ch = 1

  /* dtdf */
  payloadBits += enc_sbr_dtdf(pSCE_Element + 0, pBS); //ch = 0

  payloadBits += enc_sbr_dtdf(pSCE_Element + 1, pBS); //ch = 1

  /* invf */
  payloadBits += enc_sbr_invf(pSCE_Element + 0, pBS, pFreqtabsState->nNoiseBand); //ch = 0

  payloadBits += enc_sbr_invf(pSCE_Element + 1, pBS, pFreqtabsState->nNoiseBand); //ch = 1

  /* envelope */
  /* patch, only for CPE */
  bs_amp_res = (pSCE_Element+0)->bs_amp_res; //sbrencUpDateAmpRes( (pSCE_Element + 0)->sbrFIState.nEnv, (pSCE_Element + 0)->sbrGrid.frameClass );

  payloadBits += enc_sbr_envelope(pSCE_Element + 0,
                                  pState->sbrHuffTabs,
                                  pBS,
                                  bs_amp_res, //pHeader->bs_amp_res,
                                  pFreqtabsState->nLoBand,
                                  pFreqtabsState->nHiBand);//ch = 0

  /* patch, only for CPE */
  bs_amp_res = (pSCE_Element+1)->bs_amp_res; //sbrencUpDateAmpRes( (pSCE_Element + 1)->sbrFIState.nEnv, (pSCE_Element + 1)->sbrGrid.frameClass );
  payloadBits += enc_sbr_envelope(pSCE_Element + 1,
                                  pState->sbrHuffTabs,
                                  pBS,
                                  bs_amp_res, //pHeader->bs_amp_res,
                                  pFreqtabsState->nLoBand,
                                  pFreqtabsState->nHiBand);//ch = 1

  /* noise */
  payloadBits += enc_sbr_noise(pSCE_Element + 0,
                               pState->sbrHuffTabs,
                               pBS,
                               pFreqtabsState->nNoiseBand); //ch = 0

  payloadBits += enc_sbr_noise(pSCE_Element + 1,
                              pState->sbrHuffTabs,
                              pBS,
                              pFreqtabsState->nNoiseBand); // ch = 1

  /* harmonic */
  PUT_BITS(pBS, add_harm_flag_0,  1);
  payloadBits++;

  if(add_harm_flag_0) {
    payloadBits += enc_sbr_sinusoidal_coding(pSCE_Element + 0,
                                             pBS,
                                             pFreqtabsState->nHiBand); /* ch = 0 */
  }

  PUT_BITS(pBS, add_harm_flag_1,  1);
  payloadBits++;

  if(add_harm_flag_1) {
    payloadBits += enc_sbr_sinusoidal_coding(pSCE_Element + 1,
                                             pBS,
                                             pFreqtabsState->nHiBand); /* ch = 1 */
  }

  PUT_BITS(pBS, bs_extended_data,  1);
  payloadBits++;

  return payloadBits;
}
#endif

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

static Ipp32s enc_sbr_data(sSBREncState* pState, sBitsreamBuffer* pBS, enum eId element_ID)
{
  Ipp32s payloadBits = 0;

  switch(element_ID) {
    case ID_SCE:
      payloadBits += enc_sbr_single_channel_element(pState, pBS);
      break;

    case ID_CPE:
      payloadBits += enc_sbr_channel_pair_element(pState, pBS);
      break;

    default:
      break;
  }

  return payloadBits;
}

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

static Ipp32s enc_sbr_extension_data(sSBREncState* pState, sBitsreamBuffer* pBS, enum eId element_ID)
{
  Ipp32s payloadBits = 0;
  //Ipp32s bs_header_flag = pState->sbrHeader->flag_SBRHeaderActive;
  Ipp32s indx = pState->indx_FreqOffset_Tab[ pState->indx_CE_Tab[ pState->sbr_offset ] ];
  sSBRHeader* pHeader = (pState->sbrHeader + indx);
  Ipp32s bs_header_flag = pHeader->flag_SBRHeaderActive;

  PUT_BITS(pBS, bs_header_flag, 1);
  payloadBits++;

  if(bs_header_flag){
    payloadBits += enc_sbr_header(pHeader, pBS);
  }

  payloadBits += enc_sbr_data(pState, pBS, element_ID);

  return payloadBits;
}

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

static Ipp32s enc_extension_payload(sSBREncState* pState, sBitsreamBuffer* pBS, Ipp32s extension_type)
{
  Ipp32s payloadBits = 0;
  enum eId element_ID = pState->indx_CE_Tab[ pState->sbr_offset ]; //ID_SCE;
  Ipp32s bs_fill_bits = 0;

  /* extension_type */
  PUT_BITS(pBS, extension_type, 4);
  payloadBits += 4;

  payloadBits += enc_sbr_extension_data(pState, pBS, element_ID);

  /* align fill data */
  bs_fill_bits = 8 - (payloadBits % 8);
  bs_fill_bits %= 8;

  PUT_BITS(pBS, 0, bs_fill_bits);
  payloadBits += bs_fill_bits;

  /* check */
  if (payloadBits / 8 > 270) {
    payloadBits = 0;
#if 0
    printf("\nErr: payloadBits > 270\n");
#endif
  }

  return payloadBits;
}

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

Ipp32s enc_fill_element( sSBREncState* pState, sBitsreamBuffer* pBS)
{
  Ipp32s payloadBits = 0;
  Ipp32s extension_type = EXT_SBR_DATA;

  /* miss COUNT and ESC_COUNT fields */
  //PUT_BITS(pBS, count, 4);
  //PUT_BITS(pBS, esc_count, 8);

  /*  */
  payloadBits = enc_extension_payload(pState, pBS, extension_type);

  return payloadBits;
}

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

Ipp32s enc_fill_element_write( sBitsreamBuffer *pBS, Ipp8u* bufAuxBS, Ipp32s payloadBits )
{
  Ipp32s count = 0;
  Ipp32s esc_count = 1;
  Ipp32s i;

  count = IPP_MIN((payloadBits)/8, 15);

  PUT_BITS(pBS, ID_FIL, 3);
  PUT_BITS(pBS, count,  4);

#ifdef SBR_NEED_LOG
  fprintf(logFile, "\ncnt_byte = %i\n", count);
#endif

  if(15 == count){
    esc_count = IPP_MIN( (payloadBits/8)- 15, 255);
    esc_count++;
    PUT_BITS(pBS, esc_count,  8);
  }

  /* AYA real payload_bit_formatter */
  count += esc_count - 1;

  for(i = 0; i < count; i++ ){
    PUT_BITS(pBS, bufAuxBS[i],  8);
  }

  //------------------
  return 0; //OK
}