mp3enc_layer3_int.c

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

        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 mp3ienc_mdctInit(MP3Enc *state)
{
  if (state)
    ippsZero_32s(&state->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
******************************************************************************/

Ipp32s mp3ienc_mdctInSubband(MP3Enc *state,
                             Ipp32s *in,
                             Ipp32s *out,
                             Ipp32s block_type)
{
    Ipp32s i, j;
    Ipp32s *tout = out;

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

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

        for (i = 0; i < state->com.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 < state->com.lowpass_maxline; i++) {

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

    if (state->com.lowpass_maxline < 32) {
        ippsZero_32s(tout + state->com.lowpass_maxline * 18, 18 * (32 - state->com.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 Ipp32s aa_cs[8] = {
    1841452032,
    1893526528,
    2039312000,
    2111651968,
    2137858176,
    2145681024,
    2147267200,
    2147468928,
};

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

Ipp32s mp3ienc_mdctBlock(MP3Enc *state)
{
    VM_ALIGN16_DECL(Ipp32s) in[1152];
    Ipp32s  ch, gr, bnd, k, j;
    Ipp32s  bu, bd;
    Ipp32s  *ptr_fbout;

    for (gr = 1; gr <= 2; gr++) {
        for (ch = 0; ch < state->com.stereo; ch++) {
            ptr_fbout = &((*(state->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 < state->com.stereo; ch++) {
            for (bnd = 0, j = 0; bnd < 32; bnd++) {
                for (k = 0; k < 18; k++) {
                    in[j + k] = (*(state->fbout_int[gr]))[ch][k][bnd];
                    in[j + k + 18] = (*(state->fbout_int[gr + 1]))[ch][k][bnd];
                }
                j += 36;
            }

            mp3ienc_mdctInSubband(state, in, state->mdct_out_int[gr][ch], state->com.si_blockType[gr][ch]);
        }
        for (ch = 0; ch < state->com.stereo; ch++) {
            if (state->com.si_blockType[gr][ch] != 2) {
                Ipp32s  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 = state->mdct_out_int[gr][ch][idx1] << 1;
                        bd = state->mdct_out_int[gr][ch][idx2] << 1;
                        state->mdct_out_int[gr][ch][idx1] =
                            MUL32_MP3_32S(bu, aa_cs[k]) +
                            MUL32_MP3_32S(bd, aa_ca[k]);
                        state->mdct_out_int[gr][ch][idx2] =
                            MUL32_MP3_32S(bd, aa_cs[k]) -
                            MUL32_MP3_32S(bu, aa_ca[k]);
                    }
                    j += 18;
                }
            } else {
              Ipp32s i, sfb, start, end, line, window;
              Ipp32u *sfb_short = mp3enc_sfBandIndex[state->com.header.id][state->com.header.samplingFreq].s;
              Ipp32s *mdct_out = state->mdct_out_int[gr][ch];

              i = 0;
              for (sfb = 0; sfb < 13; sfb++) {
                start = sfb_short[sfb];
                end = sfb_short[sfb + 1];

                for (window = 0; window < 3; window++) {
                  for (line = start; line < end; line += 2) {
                    in[i++] = mdct_out[line*3  +window];
                    in[i++] = mdct_out[line*3+3+window];
                  }
                }
              }
              ippsCopy_32s(in, mdct_out, 576);
            }
        }
        if (state->com.stereo_mode == MPA_MS_STEREO) {
          const Ipp32s mult_i = 1518500249;
          Ipp32s *ptrL = &(state->mdct_out_int[gr][0][0]);
          Ipp32s *ptrR = &(state->mdct_out_int[gr][1][0]);
          Ipp32s li, ri;
          for (k = 0; k < 576; k++) {
            li = MUL32_MP3_32S(mult_i, (ptrL[0] + ptrR[0]) << 1);
            ri = MUL32_MP3_32S(mult_i, (ptrL[0] - ptrR[0]) << 1);
            ptrL[0] = li;
            ptrR[0] = ri;
            ptrL++; ptrR++;
          }
        }
    }

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

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

    return 1;
}