mp3enc_layer3_int.cpp

这是在PCA下的基于IPP库示例代码例子,在网上下了IPP的库之后,设置相关参数就可以编译该代码.

  pDst[17] = -y[9];

  return;
} /* ownsMDCT_36_32s() */

static void ownsMDCT_12x3_32s(
  Ipp32s* pSrc,
  Ipp32s* pDst)
{

    {
    int w;
    Ipp32s data[12], data2[12], y[6], x[6], a1, a2, m1, m2;

    for( w = 0; w < 3; w ++ ) {
        /* phase 1 */
        data[ 0] = _IPPS_MUL32_MP3_32S( pSrc[6+w*6+ 0]*3, pIMWin[2][ 0] );
        data[ 1] = _IPPS_MUL32_MP3_32S( pSrc[6+w*6+ 1]*3, pIMWin[2][ 1] );
        data[ 2] = _IPPS_MUL32_MP3_32S( pSrc[6+w*6+ 2]*3, pIMWin[2][ 2] );
        data[ 3] = _IPPS_MUL32_MP3_32S( pSrc[6+w*6+ 3]*3, pIMWin[2][ 3] );
        data[ 4] = _IPPS_MUL32_MP3_32S( pSrc[6+w*6+ 4]*3, pIMWin[2][ 4] );
        data[ 5] = _IPPS_MUL32_MP3_32S( pSrc[6+w*6+ 5]*3, pIMWin[2][ 5] );
        data[ 6] = _IPPS_MUL32_MP3_32S( pSrc[6+w*6+ 6]*3, pIMWin[2][ 6] );
        data[ 7] = _IPPS_MUL32_MP3_32S( pSrc[6+w*6+ 7]*3, pIMWin[2][ 7] );
        data[ 8] = _IPPS_MUL32_MP3_32S( pSrc[6+w*6+ 8]*3, pIMWin[2][ 8] );
        data[ 9] = _IPPS_MUL32_MP3_32S( pSrc[6+w*6+ 9]*3, pIMWin[2][ 9] );
        data[10] = _IPPS_MUL32_MP3_32S( pSrc[6+w*6+10]*3, pIMWin[2][10] );
        data[11] = _IPPS_MUL32_MP3_32S( pSrc[6+w*6+11]*3, pIMWin[2][11] );

        data2[ 0] = data[0]+data[11];
        data2[ 1] = data[1]+data[10];
        data2[ 2] = data[2]+data[ 9];
        data2[ 3] = data[3]+data[ 8];
        data2[ 4] = data[4]+data[ 7];
        data2[ 5] = data[5]+data[ 6];
        data2[ 6] = data[5]-data[ 6];
        data2[ 7] = data[4]-data[ 7];
        data2[ 8] = data[3]-data[ 8];
        data2[ 9] = data[2]-data[ 9];
        data2[10] = data[1]-data[10];
        data2[11] = data[0]-data[11];

        /* phase 2 */
        y[0] = data2[ 9] - data2[3];
        y[1] = data2[10] - data2[4];
        y[2] = data2[11] - data2[5];
        y[3] = data2[ 0] - data2[6];
        y[4] = data2[ 1] - data2[7];
        y[5] = data2[ 2] - data2[8];

        /* phase 3 */
        x[0] = (Ipp32s)(((Ipp64s)y[0] * _dcoef12[2] - (Ipp64s)y[5] * _dcoef12[5])>>31);
        x[1] = (Ipp32s)(((Ipp64s)y[1] * _dcoef12[1] - (Ipp64s)y[4] * _dcoef12[4])>>31);
        x[2] = (Ipp32s)(((Ipp64s)y[2] * _dcoef12[0] - (Ipp64s)y[3] * _dcoef12[3])>>31);
        x[3] = (Ipp32s)(((Ipp64s)y[3] * _dcoef12[0] + (Ipp64s)y[2] * _dcoef12[3])>>31);
        x[4] = (Ipp32s)(((Ipp64s)y[4] * _dcoef12[1] + (Ipp64s)y[1] * _dcoef12[4])>>31);
        x[5] = (Ipp32s)(((Ipp64s)y[5] * _dcoef12[2] + (Ipp64s)y[0] * _dcoef12[5])>>31);

        /* phase 4: 3 points DCT II & DST II */
        /* Reverse Input Order & DCT II */
        a1 = x[2]+x[0];
        a2 = x[2]-x[0];
        m1 = (Ipp32s)(((Ipp64s)_dt[0] * a2)>>31);
        m2 = (Ipp32s)(((Ipp64s)_dt[1] * a1)>>31);
        y[0] = (x[1]+a1);
        y[1] = m1;
        y[2] = m2-x[1];

        /* DST II */
        a1 = x[3] + x[5];
        a2 = x[3] - x[5];
        m1 = (Ipp32s)(((Ipp64s)_dt[0]*a2)>>31);
        m2 = (Ipp32s)(((Ipp64s)_dt[1]*a1)>>31);
        /* Reverse Output Order of DST */
        y[5] = m2 + x[4];
        y[4] = m1;
        y[3] = (a1 - x[4]);

        /* phase 5 */
        /* pDst[k+w*6] = tmp * (4.0/N); */
        x[0] = y[0];
        x[1] = -y[1]+y[5];
        x[2] = y[2]-y[4];
        x[3] = y[3];
        x[4] = -y[4]-y[2];
        x[5] = y[5]+y[1];

        pDst[w*6+0] = x[0];
        pDst[w*6+1] = - x[5];
        pDst[w*6+2] = x[1];
        pDst[w*6+3] = - x[4];
        pDst[w*6+4] = x[2];
        pDst[w*6+5] = - x[3];
    }
    }

  return;
} /* ownsMDCT_12x3_32s() */

/******************************************************************************
//  Name:
//    mdct_init
//
//  Description:
//    Initialize coefficients of mdct windows
//
//  Input Arguments:
//     - pointer to encoder context
//
//  Output Arguments:
//
//  Returns:
//    -
//
******************************************************************************/

  void MP3EncoderInt::mdctInit()
  {
    ippsZero_32s(&fbout_data[0][0][0][0],2*3*18*32);
  }

/******************************************************************************
//  Name:
//    mdct
//
//  Description:
//    Perform windowing and appling of mdct.
//
//  Input Arguments:
//             - pointer to encoder context
//    in         - input samples
//   block_type  - type of block
//
//  Output Arguments:
//    out        - samples in frequency domain
//
//  Returns:
//    1 - all ok
******************************************************************************/

  int MP3EncoderInt::mdctInSubband(int *in,
                                int *out,
                                int block_type)
  {
    int     i, j;
    int *tout = out;

    if (block_type == 2) {
      int   tmp_out[36];
      int  *tmp_out2[3];
      int **tmp_out3;

      tmp_out2[0] = tmp_out;
      tmp_out2[1] = tmp_out + 6;
      tmp_out2[2] = tmp_out + 12;

      tmp_out3 = &(tmp_out2[0]);

      for (i = 0; i < lowpass_maxline; i++) {
        ownsMDCT_12x3_32s(in, tmp_out);
        for(j = 0; j < 6; j++) {
            out[3 * j + 0] = tmp_out2[0][j];
            out[3 * j + 1] = tmp_out2[1][j];
            out[3 * j + 2] = tmp_out2[2][j];
        }

        in += 36;
        out += 18;
      }
    } else {
      for (i = 0; i < lowpass_maxline; i++) {

        ownsMDCT_36_32s(in, out, block_type);
        in += 36;
        out += 18;
      }
    }

    if (lowpass_maxline < 32) {
        ippsZero_32s(tout + lowpass_maxline * 18, 18 * (32 - lowpass_maxline));
    }

    return 1;
  }

/******************************************************************************
//  Name:
//    mdctBlock
//
//  Description:
//    The output of the filterbank is the input to the subdivision using the MDCT.
//    18 consecutive output values of one granule and 18 output values of the granule before
//    are assembled to one block of 36 samples for each subbands.
//
//  Input Arguments:
//             - pointer to encoder context
//
//  Output Arguments:
//    -
//
//  Returns:
//    1 - all ok.
******************************************************************************/

/* Q31 */
static int aa_cs[8] = {
    1841452032,
    1893526528,
    2039312000,
    2111651968,
    2137858176,
    2145681024,
    2147267200,
    2147468928,
};

/* Q31 */
static int aa_ca[8] = {
    -1104871168,
    -1013036672,
    -672972928,
    -390655616,
    -203096528,
    -87972920,
    -30491194,
    -7945636,
};

  int MP3EncoderInt::mdctBlock()
  {
    VM_ALIGN16_DECL(int) in[1152];
    int     ch, gr, bnd, k, j;
    int     bu, bd;
    int  *ptr_fbout;

    for (gr = 1; gr <= 2; gr++) {
      for (ch = 0; ch < stereo; ch++) {
        ptr_fbout = &((*(fbout_int[gr]))[ch][0][0]);
        for (k = 33; k < 576; k += 32)
            for (j = 0; j < 32; j += 2, k += 2)
                ptr_fbout[k] = -ptr_fbout[k];
        }
    }

    for (gr = 0; gr < 2; gr++) {
      for (ch = 0; ch < stereo; ch++) {
        for (bnd = 0, j = 0; bnd < 32; bnd++) {
          for (k = 0; k < 18; k++) {
            in[j + k] = (*(fbout_int[gr]))[ch][k][bnd];
            in[j + k + 18] = (*(fbout_int[gr + 1]))[ch][k][bnd];
          }
          j += 36;
        }

        mdctInSubband(in, mdct_out_int[gr][ch], si_blockType[gr][ch]);

        if (si_blockType[gr][ch] != 2) {
          int     idx1, idx2;

          j = 0;
          for (bnd = 0; bnd < 31; bnd++) {
            for (k = 0; k < 8; k++) {
              idx1 = j + 17 - k;
              idx2 = j + 18 + k;


              bu = mdct_out_int[gr][ch][idx1] << 1;
              bd = mdct_out_int[gr][ch][idx2] << 1;
              mdct_out_int[gr][ch][idx1] =
                MUL32_MP3_32S(bu, aa_cs[k]) +
                MUL32_MP3_32S(bd, aa_ca[k]);
              mdct_out_int[gr][ch][idx2] =
                MUL32_MP3_32S(bd, aa_cs[k]) -
                MUL32_MP3_32S(bu, aa_ca[k]);
            }
            j += 18;
          }
        }
      }
    }

    fbout_prev += 2;
    if (fbout_prev > 2)
        fbout_prev -= 3;

    for (j = 0; j < 3; j++) {
        int ind;
        ind = fbout_prev + j;
        if (ind > 2) ind -= 3;
        fbout_int[j] = &fbout_data[ind];
    }

    return 1;
  }

};      // namespace UMC