aac_dec_ssr_fp.c

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

  for (i = 0; i < 4; i++) {
    gcOverlapBuffer[i] = m_gcOverlapBuffer + 512 * i;
  }

  if (window_sequence == EIGHT_SHORT_SEQUENCE){
    for (band = 0; band < 4; band++) {
      for (k = 0; k < 8; k++) {
        ssr_gainc_window(len/16,
                         &prevSSRInfo[band],
                         &SSRInfo[band][k], &SSRInfo[band][k],
                         a_gcwind, window_sequence);

        ippsMul_32f_I(a_gcwind, input+band*len/2 + k*len/16,
                      len/32);

        ippsAdd_32f_I(input+band*len/2+k*len/16,
                      &gcOverlapBuffer[band][len*7/64+len/32*k],
                      len/32);

        ippsMul_32f(input+band*len/2+k*len/16+len/32,
                    a_gcwind+len/32,
                    &gcOverlapBuffer[band][len*7/64+(k+1)*len/32],
                    len/32);
        prevSSRInfo[band] = SSRInfo[band][k];
      }

      ippsMove_32f(&gcOverlapBuffer[band][0], &out[band][0],
                   len/4);

      ippsMove_32f(&gcOverlapBuffer[band][len/4],
                   &gcOverlapBuffer[band][0],
                   len/4);
    }
  } else {
    last_cur_block = 0;
    if (window_sequence != ONLY_LONG_SEQUENCE)
      last_cur_block = 1;

    for (band = 0; band < 4; band++) {
      ssr_gainc_window(len/2,
                       &prevSSRInfo[band],
                       &SSRInfo[band][0], &SSRInfo[band][1],
                       a_gcwind, window_sequence);

      ippsMul_32f_I(a_gcwind, input+band*len/2,
                    len/4);
      ippsAdd_32f(&gcOverlapBuffer[band][0], input+band*len/2,
                  &out[band][0], len/4);

      ippsMul_32f(input+band*len/2+len/4,
                  a_gcwind + len/4,
                  &gcOverlapBuffer[band][0], len/4);

      prevSSRInfo[band] = SSRInfo[band][last_cur_block];
    }
  }
}

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

static void ssr_imdct(Ipp32f      *coef,
                      Ipp32s       curr_win_shape,
                      Ipp32s       prev_win_shape,
                      Ipp32s       window_sequence,
                      Ipp32f      *timeSig,
                      sFilterbank *p_data)
{
  Ipp32s i;
  Ipp32f imdct_in[1024];
  Ipp32s band, short_block;

  if (window_sequence == EIGHT_SHORT_SEQUENCE) {
    for (band = 0; band < 4; band += 2){
      for (short_block = 0; short_block < 8; short_block++) {
        for (i = 0; i < 32; i++) {
          imdct_in[256*band + 32*short_block + i] =
            coef[128*short_block + 32*band + i];
        }
        for (i = 0; i < 32; i++) {
          imdct_in[256*band + 256 + 32*short_block + i] =
            coef[128*short_block + 32*band + 63 - i];
        }
      }
    }

    for (band = 0; band < 4; band++) {
      FilterbankDecSSR(p_data,
                       imdct_in + 256 * band,
                       window_sequence,
                       curr_win_shape,
                       prev_win_shape,
                       timeSig + 512 * band);
    }

  } else {
    for (band = 0; band < 4; band += 2){
      FilterbankDecSSR(p_data,
                       coef + 256 * band,
                       window_sequence,
                       curr_win_shape,
                       prev_win_shape,
                       timeSig + 512 * band);
      for (i = 0; i < 256; i++) {
        imdct_in[256*band + i + 256] = coef[256*band + 511 - i];
      }
      FilterbankDecSSR(p_data,
                       imdct_in + 256 * (band + 1),
                       window_sequence,
                       curr_win_shape,
                       prev_win_shape,
                       timeSig + 512 * (band + 1));
    }
  }
}

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

static void ssr_ipqf_main(Ipp32f *ipqfInBufCh[4],
                          Ipp32s len,
                          Ipp32f *output,
                          ownIppsIPQFState_32f *SSR_IPQFState)
{
  Ipp32s i, k;
  Ipp32f acc;
  Ipp32f tbuf0[280], tbuf1[280], tbuf2[280], tbuf3[280];
  Ipp32f *app_pqfbuf0[2];
  Ipp32f *app_pqfbuf1[2];

  app_pqfbuf0[0] = SSR_IPQFState->app_pqfbuf0;
  app_pqfbuf0[1] = SSR_IPQFState->app_pqfbuf1;
  app_pqfbuf1[0] = SSR_IPQFState->app_pqfbuf2;
  app_pqfbuf1[1] = SSR_IPQFState->app_pqfbuf3;

  for (i = 0; i < len / 4; i+=2) {
    tbuf0[i+23] = pp_q[0][0][0]*ipqfInBufCh[0][i] +
                  pp_q[0][0][1]*ipqfInBufCh[1][i] +
                  pp_q[0][0][2]*ipqfInBufCh[2][i] +
                  pp_q[0][0][3]*ipqfInBufCh[3][i];

    tbuf0[i+24] = pp_q[1][0][0]*ipqfInBufCh[0][i+1] +
                  pp_q[1][0][1]*ipqfInBufCh[1][i+1] +
                  pp_q[1][0][2]*ipqfInBufCh[2][i+1] +
                  pp_q[1][0][3]*ipqfInBufCh[3][i+1];

    tbuf1[i+23] = pp_q[0][1][0]*ipqfInBufCh[0][i] +
                  pp_q[0][1][1]*ipqfInBufCh[1][i] +
                  pp_q[0][1][2]*ipqfInBufCh[2][i] +
                  pp_q[0][1][3]*ipqfInBufCh[3][i];

    tbuf1[i+24] = pp_q[1][1][0]*ipqfInBufCh[0][i+1] +
                  pp_q[1][1][1]*ipqfInBufCh[1][i+1] +
                  pp_q[1][1][2]*ipqfInBufCh[2][i+1] +
                  pp_q[1][1][3]*ipqfInBufCh[3][i+1];

    tbuf2[i+22] = pp_q[1][0][0]*ipqfInBufCh[0][i] +
                  pp_q[1][0][1]*ipqfInBufCh[1][i] +
                  pp_q[1][0][2]*ipqfInBufCh[2][i] +
                  pp_q[1][0][3]*ipqfInBufCh[3][i];

    tbuf2[i+23] = pp_q[0][0][0]*ipqfInBufCh[0][i+1] +
                  pp_q[0][0][1]*ipqfInBufCh[1][i+1] +
                  pp_q[0][0][2]*ipqfInBufCh[2][i+1] +
                  pp_q[0][0][3]*ipqfInBufCh[3][i+1];

    tbuf3[i+22] = pp_q[1][1][0]*ipqfInBufCh[0][i] +
                  pp_q[1][1][1]*ipqfInBufCh[1][i] +
                  pp_q[1][1][2]*ipqfInBufCh[2][i] +
                  pp_q[1][1][3]*ipqfInBufCh[3][i];

    tbuf3[i+23] = pp_q[0][1][0]*ipqfInBufCh[0][i+1] +
                  pp_q[0][1][1]*ipqfInBufCh[1][i+1] +
                  pp_q[0][1][2]*ipqfInBufCh[2][i+1] +
                  pp_q[0][1][3]*ipqfInBufCh[3][i+1];
  }

  for (i = 0; i < 22; i++) {
    tbuf0[i] = app_pqfbuf0[0][i];
    tbuf1[i] = app_pqfbuf0[1][i];
    tbuf2[i] = app_pqfbuf1[0][i];
    tbuf3[i] = app_pqfbuf1[1][i];
  }

  tbuf0[22] = app_pqfbuf0[0][22];
  tbuf1[22] = app_pqfbuf0[1][22];

  for (i = 0; i < len/8; i++) {
    acc = 0.0;
    for (k = 0; k < 24; k++) {
      acc += ipqfCoef[0][k]*tbuf0[23-k+2*i];
    }
    output[i*8] = acc;

    acc = 0.0;
    for (k = 0; k < 24; k++) {
      acc += ipqfCoef[1][k]*tbuf1[23-k+2*i];
    }
    output[i*8+1] = acc;

    acc = 0.0;
    for (k = 0; k < 24; k++) {
      acc += ipqfCoef[2][k]*tbuf1[23-k+2*i];
    }
    output[i*8+2] = acc;

    acc = 0.0;
    for (k = 0; k < 24; k++) {
      acc += ipqfCoef[3][k]*tbuf0[23-k+2*i];
    }
    output[i*8+3] = acc;

    acc = 0.0;
    for (k = 0; k < 24; k++) {
      acc += ipqfCoef[0][k]*tbuf2[23-k+2*i];
    }
    output[i*8+4] = acc;

    acc = 0.0;
    for (k = 0; k < 24; k++) {
      acc += ipqfCoef[1][k]*tbuf3[23-k+2*i];
    }
    output[i*8+5] = acc;

    acc = 0.0;
    for (k = 0; k < 24; k++) {
      acc += ipqfCoef[2][k]*tbuf3[23-k+2*i];
    }
    output[i*8+6] = acc;

    acc = 0.0;
    for (k = 0; k < 24; k++) {
      acc += ipqfCoef[3][k]*tbuf2[23-k+2*i];
    }
    output[i*8+7] = acc;
  }

  for (i = 0; i < 22; i++) {
    app_pqfbuf0[0][i] = tbuf0[i+256];
    app_pqfbuf0[1][i] = tbuf1[i+256];
    app_pqfbuf1[0][i] = tbuf2[i+256];
    app_pqfbuf1[1][i] = tbuf3[i+256];
  }

  app_pqfbuf0[0][22] = tbuf0[22+256];
  app_pqfbuf0[1][22] = tbuf1[22+256];
}

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

void ssr_gain_control(Ipp32f               *spectrum_data,
                      Ipp32s               curr_win_shape,
                      Ipp32s               prev_win_shape,
                      Ipp32s               curr_win_sequence,
                      SSR_GAIN             **SSRInfo,
                      SSR_GAIN             *prevSSRInfo,
                      Ipp32f               *samples,
                      Ipp32f               *m_gcOverlapBuffer,
                      ownIppsIPQFState_32f *SSR_IPQFState,
                      sFilterbank          *p_data,
                      Ipp32s               len)
{
  Ipp32f bandSigChBuf[1024];
  Ipp32f *bandSigCh[4];
  Ipp32f imdctOut[2048];
  Ipp32s i;

  for (i = 0; i < 4; i++) {
    bandSigCh[i] = bandSigChBuf + i * 256;
  }

  ssr_imdct(spectrum_data, curr_win_shape, prev_win_shape,
            curr_win_sequence, imdctOut, p_data);

  ssr_compensate(imdctOut, SSRInfo, prevSSRInfo, len,
                 curr_win_sequence, bandSigCh, m_gcOverlapBuffer);

  ssr_ipqf_main(bandSigCh, len, samples, SSR_IPQFState);
}

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