mp3enc_quantization_fp.cpp

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

/*//////////////////////////////////////////////////////////////////////////////
//
//                  INTEL CORPORATION PROPRIETARY INFORMATION
//     This software is supplied under the terms of a license agreement or
//     nondisclosure agreement with Intel Corporation and may not be copied
//     or disclosed except in accordance with the terms of that agreement.
//          Copyright(c) 2002-2005 Intel Corporation. All Rights Reserved.
//
*/

#include "umc_mp3_encoder.h"

#define LEN_MDCT_LINE 576
#define SF_OFFSET 210
#define MAX_QUANT     8206
#define MAGIC_NUMBER  (-0.0946 + 0.5)

namespace UMC {
  void    MP3Encoder::calcAvailableBits() {
    int ch, gr;
    int len;
    int bitsPerFrame;
    int mean_bits;
    int bits_in_buf, max_bits_in_buf;
    int bits_from_buffer, com_additional_bits;
    int additional_bits[2][2];
    int up, l;

    up = frameSize * mp3enc_bitrate[header.bitRate] * 1000;
    slot_size = up / (mp3enc_frequency[header.samplingFreq] << 3);
    l = slot_size * mp3enc_frequency[header.samplingFreq] << 3;

    if (up - l < mp3enc_frequency[header.samplingFreq] << 2)
        header.paddingBit = 0;
    else
        header.paddingBit = 1;

    slot_size += header.paddingBit;

    len = 32;   // header

    if (stereo == 1)
      len += 136;
    else
      len += 256;

    if (header.protectionBit)
      len += 16;

    bitsPerFrame = slot_size << 3;

    max_bits_in_buf = 8*511;
    mean_bits = (bitsPerFrame - len);
    bits_in_buf = si_main_data_begin * 8;

    if (mp3enc_bitrate[header.bitRate] != 320) {

    if (bits_in_buf > 0.95 * max_bits_in_buf) {
      bits_from_buffer = (int)(0.95 * max_bits_in_buf);
      mean_bits += (int)(bits_in_buf - 0.95 * max_bits_in_buf);
    } else {
      bits_from_buffer = bits_in_buf;
    }
    mean_bits = (int)(mean_bits * 0.85);

    mean_bits >>= stereo;

    com_additional_bits = 0;

    for (gr = 0; gr < 2; gr++) {
        for (ch = 0; ch < 2; ch++) {

            additional_bits[gr][ch] =
                (int)((pa_curr_frame_PE_st[gr][ch] - 1000)  * 0.6);

            if (additional_bits[gr][ch] < 0) {
                additional_bits[gr][ch] = 0;
            }
            if (si_blockType[gr][ch] != NORM_TYPE) {
                if (additional_bits[gr][ch] < 0.5 * mean_bits)
                    additional_bits[gr][ch] = (int)(0.5 * mean_bits);
                else if (additional_bits[gr][ch] > 1.2 * mean_bits)
                    additional_bits[gr][ch] = (int)(1.2 * mean_bits);
            }
            else if (additional_bits[gr][ch] > 0.2 * mean_bits)
                additional_bits[gr][ch] = (int)(0.2 * mean_bits);

            com_additional_bits += additional_bits[gr][ch];
        }
    }

    for (gr = 0; gr < 2; gr++) {
        for (ch = 0; ch < 2; ch++) {
            if (com_additional_bits > bits_from_buffer) {
                additional_bits[gr][ch] = (int)(additional_bits[gr][ch] *
                    ((float)bits_from_buffer / (float)com_additional_bits));
            }

            max_bits[gr][ch] =
                mean_bits + additional_bits[gr][ch];
        }
    }
    } else {
        mean_bits += bits_in_buf;
        mean_bits >>= stereo;
        for (gr = 0; gr < 2; gr++)
            for (ch = 0; ch < 2; ch++)
            max_bits[gr][ch] = mean_bits;
    }

  }

  int MP3Encoder::quantization()
  {
      int     gr, ch;
      unsigned int    *sfb_long, *sfb_short;

      VM_ALIGN16_DECL(float) ipptmp0_576[576/2];
      Ipp32f mdct_line_abs[LEN_MDCT_LINE];
      Ipp32f mdct_scaled[LEN_MDCT_LINE];

      sfb_long = mp3enc_sfBandIndex[header.samplingFreq].l;
      sfb_short = mp3enc_sfBandIndex[header.samplingFreq].s;

      calcAvailableBits();

      ippsZero_32f(ipptmp0_576, 576/2);

      for (gr = 0; gr < 2; gr++) {
          for (ch = 0; ch < stereo; ch++) {
              float max_mdct_line;
              float tmp_start_common_scalefac;
              float tmp_finish_common_scalefac;

              start_common_scalefac = -SF_OFFSET;
              finish_common_scalefac = -SF_OFFSET;
              max_mdct_line = 0;

              ippsAbs_32f(mdct_out[gr][ch], mdct_line_abs, LEN_MDCT_LINE);
              ippsPow34_32f(mdct_line_abs, mdct_scaled, LEN_MDCT_LINE);
              ippsMax_32f(mdct_scaled, LEN_MDCT_LINE, &max_mdct_line);

              if (max_mdct_line > 0) {
                  tmp_start_common_scalefac = (float)log(max_mdct_line/(MAX_QUANT))/(float)log(2.0);
                  tmp_start_common_scalefac *= (float)16/(float)3;
                  start_common_scalefac = (int)floor((double)tmp_start_common_scalefac);

                  if (start_common_scalefac < tmp_start_common_scalefac)
                      start_common_scalefac++;

                  tmp_finish_common_scalefac = (float)log(max_mdct_line/(1 - MAGIC_NUMBER))/(float)log(2.0);
                  tmp_finish_common_scalefac *= (float)16/(float)3;
                  finish_common_scalefac = (int)floor((double)tmp_finish_common_scalefac);

                  if (finish_common_scalefac < tmp_finish_common_scalefac)
                      finish_common_scalefac++;

                  finish_common_scalefac++;

                  if (start_common_scalefac > 255 - SF_OFFSET) {
                      start_common_scalefac = 255 - SF_OFFSET;
                  } else if (start_common_scalefac < -SF_OFFSET) {
                      start_common_scalefac = -SF_OFFSET;
                  }

                  if (finish_common_scalefac > 255 - SF_OFFSET) {
                      finish_common_scalefac = 255 - SF_OFFSET;
                  } else if (finish_common_scalefac < -SF_OFFSET) {
                      finish_common_scalefac = -SF_OFFSET;
                  }
              }

              iterReset(gr, ch);

              main_loop(gr, ch, mdct_scaled, (short *)ipptmp0_576);
          }
      }
      return 1;
  }

  void MP3Encoder::main_loop(int gr, int ch,
      Ipp32f* mdct_scaled,
      short *ipptmp0_576)
  {
      Ipp32f tmp_x_quant[LEN_MDCT_LINE];
      Ipp32f sf, temp;

      int common_scalefactor;
      int needed_bits;

      common_scalefactor = last_frame_common_scalefactor[ch];
      common_scalefactor_update[ch] = common_scalefactor_update[ch];

      if (common_scalefactor < start_common_scalefac)
          common_scalefactor = start_common_scalefac;

      if (common_scalefactor > finish_common_scalefac)
          common_scalefactor = finish_common_scalefac;

      for(;;) {
          sf = (Ipp32f)pow(2.0, -common_scalefactor * (3./16.));
          //sf = (Ipp32f)scalefac_pow[common_scalefactor + SF_OFFSET];
          temp = (Ipp32f)(MAGIC_NUMBER - 0.5)/sf;
          ippsAddC_32f( mdct_scaled, temp, tmp_x_quant, LEN_MDCT_LINE);
          ippsMulC_Low_32f16s(tmp_x_quant, sf, quant_ix[gr][ch], LEN_MDCT_LINE);
          needed_bits = calcBits(gr, ch, ipptmp0_576);

          if (needed_bits == max_bits[gr][ch])
              break;

          if (needed_bits > max_bits[gr][ch]) {
              if (common_scalefactor == finish_common_scalefac)
                  break;

              if (common_scalefactor_update[ch] < 0) {
                  common_scalefactor_update[ch] = -common_scalefactor_update[ch];
              }
              common_scalefactor_update[ch] = (common_scalefactor_update[ch] + 1) >> 1;
          } else {
              if (common_scalefactor == start_common_scalefac)
                  break;

              if (common_scalefactor_update[ch] == 1)
                  break;

              if (common_scalefactor_update[ch] > 0) {
                  common_scalefactor_update[ch] = -common_scalefactor_update[ch];
              }
              common_scalefactor_update[ch] >>= 1;
          }

          common_scalefactor += common_scalefactor_update[ch];

          if (common_scalefactor < start_common_scalefac)
              common_scalefactor = start_common_scalefac;

          if (common_scalefactor > finish_common_scalefac)
              common_scalefactor = finish_common_scalefac;

      };

      common_scalefactor_update[ch] =
          common_scalefactor - last_frame_common_scalefactor[ch];
      last_frame_common_scalefactor[ch] = common_scalefactor;

      if (common_scalefactor_update[ch] >= 0) {
          if (common_scalefactor_update[ch] <= 2)
              common_scalefactor_update[ch] = 2;
      } else {
          if (common_scalefactor_update[ch] >= -2)
              common_scalefactor_update[ch] = -2;
      }

      si_globGain[gr][ch] = (short)(common_scalefactor + SF_OFFSET);

      si_part23Len[gr][ch] = needed_bits;
  }
};      // namespace UMC