コード例 #1
0
/*!
  \brief     FDKaacEnc_ScaleUpSpectrum

  Scales up spectrum lines in a given frequency section

  \param scaled spectrum
  \param original spectrum
  \param frequency line to start scaling
  \param frequency line to enc scaling

  \return scale factor

****************************************************************************/
static inline INT FDKaacEnc_ScaleUpSpectrum(
        FIXP_DBL                 *dest,
        const FIXP_DBL           *src,
        const INT                 startLine,
        const INT                 stopLine
        )
{
    INT i, scale;

    FIXP_DBL maxVal = FL2FXCONST_DBL(0.f);

    /* Get highest value in given spectrum */
    for (i=startLine; i<stopLine; i++) {
      maxVal = fixMax(maxVal,fixp_abs(src[i]));
    }
    scale = CountLeadingBits(maxVal);

    /* Scale spectrum according to highest value */
    for (i=startLine; i<stopLine; i++) {
      dest[i] = src[i]<<scale;
    }

    return scale;
}
コード例 #2
0
ファイル: bit_sbr.cpp プロジェクト: ShiftMediaProject/fdk-aac
/*****************************************************************************

    functionname: writeEnvelopeData
    description:  writes bits corresponding to the envelope
    returns:      number of bits written
    input:
    output:

*****************************************************************************/
static INT writeEnvelopeData(HANDLE_SBR_ENV_DATA sbrEnvData,
                             HANDLE_FDK_BITSTREAM hBitStream, INT coupling) {
  INT payloadBits = 0, j, i, delta;

  for (j = 0; j < sbrEnvData->noOfEnvelopes;
       j++) { /* loop over all envelopes */
    if (sbrEnvData->domain_vec[j] == FREQ) {
      if (coupling && sbrEnvData->balance) {
        payloadBits += FDKwriteBits(hBitStream, sbrEnvData->ienvelope[j][0],
                                    sbrEnvData->si_sbr_start_env_bits_balance);
      } else {
        payloadBits += FDKwriteBits(hBitStream, sbrEnvData->ienvelope[j][0],
                                    sbrEnvData->si_sbr_start_env_bits);
      }
    }

    for (i = 1 - sbrEnvData->domain_vec[j]; i < sbrEnvData->noScfBands[j];
         i++) {
      delta = sbrEnvData->ienvelope[j][i];
      if (coupling && sbrEnvData->balance) {
        FDK_ASSERT(fixp_abs(delta) <= sbrEnvData->codeBookScfLavBalance);
      } else {
        FDK_ASSERT(fixp_abs(delta) <= sbrEnvData->codeBookScfLav);
      }
      if (coupling) {
        if (sbrEnvData->balance) {
          if (sbrEnvData->domain_vec[j]) {
            /* coupling && balance && TIME */
            payloadBits += FDKwriteBits(
                hBitStream,
                sbrEnvData
                    ->hufftableBalanceTimeC[delta +
                                            sbrEnvData->codeBookScfLavBalance],
                sbrEnvData
                    ->hufftableBalanceTimeL[delta +
                                            sbrEnvData->codeBookScfLavBalance]);
          } else {
            /* coupling && balance && FREQ */
            payloadBits += FDKwriteBits(
                hBitStream,
                sbrEnvData
                    ->hufftableBalanceFreqC[delta +
                                            sbrEnvData->codeBookScfLavBalance],
                sbrEnvData
                    ->hufftableBalanceFreqL[delta +
                                            sbrEnvData->codeBookScfLavBalance]);
          }
        } else {
          if (sbrEnvData->domain_vec[j]) {
            /* coupling && !balance && TIME */
            payloadBits += FDKwriteBits(
                hBitStream,
                sbrEnvData
                    ->hufftableLevelTimeC[delta + sbrEnvData->codeBookScfLav],
                sbrEnvData
                    ->hufftableLevelTimeL[delta + sbrEnvData->codeBookScfLav]);
          } else {
            /* coupling && !balance && FREQ */
            payloadBits += FDKwriteBits(
                hBitStream,
                sbrEnvData
                    ->hufftableLevelFreqC[delta + sbrEnvData->codeBookScfLav],
                sbrEnvData
                    ->hufftableLevelFreqL[delta + sbrEnvData->codeBookScfLav]);
          }
        }
      } else {
        if (sbrEnvData->domain_vec[j]) {
          /* !coupling && TIME */
          payloadBits += FDKwriteBits(
              hBitStream,
              sbrEnvData->hufftableTimeC[delta + sbrEnvData->codeBookScfLav],
              sbrEnvData->hufftableTimeL[delta + sbrEnvData->codeBookScfLav]);
        } else {
          /* !coupling && FREQ */
          payloadBits += FDKwriteBits(
              hBitStream,
              sbrEnvData->hufftableFreqC[delta + sbrEnvData->codeBookScfLav],
              sbrEnvData->hufftableFreqL[delta + sbrEnvData->codeBookScfLav]);
        }
      }
    }
  }
  return payloadBits;
}
コード例 #3
0
static void CTns_Filter (FIXP_DBL *spec, int size, int inc, FIXP_TCC coeff [], int order)
{
  // - Simple all-pole filter of order "order" defined by
  //   y(n) =  x(n) - a(2)*y(n-1) - ... - a(order+1)*y(n-order)
  //
  // - The state variables of the filter are initialized to zero every time
  //
  // - The output data is written over the input data ("in-place operation")
  //
  // - An input vector of "size" samples is processed and the index increment
  //   to the next data sample is given by "inc"

  int i,j,N;
  FIXP_DBL *pSpec;
  FIXP_DBL maxVal=FL2FXCONST_DBL(0.0);
  INT s;

  FDK_ASSERT(order <= TNS_MAXIMUM_ORDER);
  C_ALLOC_SCRATCH_START(state, FIXP_DBL, TNS_MAXIMUM_ORDER);
  FDKmemclear(state, order*sizeof(FIXP_DBL));

  for (i=0; i<size; i++) {
    maxVal = fixMax(maxVal,fixp_abs(spec[i]));
  }

  if ( maxVal > FL2FXCONST_DBL(0.03125*0.70710678118) )
    s = fixMax(CntLeadingZeros(maxVal)-6,0);
  else
    s = fixMax(CntLeadingZeros(maxVal)-5,0);

  s = fixMin(s,2);
  s = s-1;

  if (inc == -1)
    pSpec = &spec[size - 1];
  else
    pSpec = &spec[0];

  FIXP_TCC *pCoeff;

#define FIRST_PART_FLTR                                              \
    FIXP_DBL x, *pState = state;                                     \
    pCoeff = coeff;                                                  \
                                                                     \
    if (s < 0)                                                       \
      x = (pSpec [0]>>1) + fMultDiv2 (*pCoeff++, pState [0]) ;       \
    else                                                             \
      x = (pSpec [0]<<s) + fMultDiv2 (*pCoeff++, pState [0]) ;

#define INNER_FLTR_INLINE                                            \
      x = fMultAddDiv2 (x, *pCoeff, pState [1]);                     \
      pState [0] = pState [1] - (fMultDiv2 (*pCoeff++, x) <<2) ;     \
      pState++;

#define LAST_PART_FLTR                                               \
      if (s < 0)                                                     \
        *pSpec = x << 1;                                             \
      else                                                           \
        *pSpec = x >> s;                                             \
      *pState =(-x) << 1;                                            \
      pSpec   += inc ;


   if (order>8)
   {
      N = (order-1)&7;

      for (i = size ; i != 0 ; i--)
      {
        FIRST_PART_FLTR

        for (j = N; j > 0 ; j--) { INNER_FLTR_INLINE }

        INNER_FLTR_INLINE INNER_FLTR_INLINE INNER_FLTR_INLINE INNER_FLTR_INLINE
        INNER_FLTR_INLINE INNER_FLTR_INLINE INNER_FLTR_INLINE INNER_FLTR_INLINE

        LAST_PART_FLTR
      }

   } else if (order>4) {