mp3enc_quantization.cpp

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

                      regmax++;

                  for (reg0 = 0; reg0 <= 15; reg0++) {
                      index0 = (si_reg0Cnt[gr][ch] = reg0) + 1;

                      if (index0 >= regmax)
                          continue;

                      bits0 = chooseTableLong(gr, ch, quant_ix[gr][ch], sfb_long[index0], 0);

                      for (reg1 = 0; reg1 <= 7; reg1++) {
                          index1 = (si_reg1Cnt[gr][ch] = reg1) + 1;

                          index2 = regmax - index0 - index1;

                          if (index2 < 0)
                              continue;

                          reg1_end = sfb_long[index0 + index1];
                          if (reg1_end > bigv_region)
                              reg1_end = bigv_region;

                          VM_ASSERT(reg1_end > sfb_long[index0]);

                          bits1 = chooseTableLong(gr, ch, quant_ix[gr][ch] + sfb_long[index0],
                            reg1_end - sfb_long[index0], 1);

                          bits2 = last_reg_bits[index2];
                          if (bits2 == 0 && index2) {
                              bits2 = chooseTableLong(gr, ch, quant_ix[gr][ch] + reg1_end,
                                bigv_region - reg1_end, 2);
                              last_reg_bits[index2] = bits2;
                          }

                          cur_bits = bits0 + bits1 + bits2;
                          if (cur_bits < min_bits) {
                              min_bits = cur_bits;
                              st_reg0 = reg0;
                              st_reg1 = reg1;
                          }
                      }
                  }
                  index0 = (si_reg0Cnt[gr][ch] = st_reg0) + 1;
                  index1 = (si_reg1Cnt[gr][ch] = st_reg1) + 1;

                  si_address[gr][ch][0] = sfb_long[index0];
                  si_address[gr][ch][1] = sfb_long[index0 + index1];
                  if (si_address[gr][ch][0] > bigv_region)
                      si_address[gr][ch][0] = bigv_region;
                  if (si_address[gr][ch][1] > bigv_region)
                      si_address[gr][ch][1] = bigv_region;
                  si_address[gr][ch][2] = bigv_region;
              } else {
                  int     index0, index1;

                  i = 0;
                  while (sfb_long[i] < bigv_region)
                      i++;

                  index0 = (si_reg0Cnt[gr][ch] = mp3enc_region01_table[i][0]) + 1;
                  index1 = (si_reg1Cnt[gr][ch] = mp3enc_region01_table[i][1]) + 1;

                  si_address[gr][ch][0] = sfb_long[index0];
                  si_address[gr][ch][1] = sfb_long[index0 + index1];
                  si_address[gr][ch][2] = bigv_region;
             }

          } else {
              if (si_mixedBlock[gr][ch] || (si_blockType[gr][ch] != 2)) {
                  si_reg0Cnt[gr][ch] = 7;
                  si_reg1Cnt[gr][ch] = 13;
                  si_address[gr][ch][0] = sfb_long[si_reg0Cnt[gr][ch] + 1];
              } else {
                  si_reg0Cnt[gr][ch] = 8;
                  si_reg1Cnt[gr][ch] = 36;
                  si_address[gr][ch][0] = 36;
              }

              si_address[gr][ch][1] = bigv_region;
              si_address[gr][ch][2] = 0;
          }
      } else {
          si_address[gr][ch][0] = si_address[gr][ch][1] = si_address[gr][ch][2] = 0;
          si_reg0Cnt[gr][ch] = 0;
          si_reg1Cnt[gr][ch] = 0;
      }

      si_pTableSelect[gr][ch][0] = 0;
      si_pTableSelect[gr][ch][1] = 0;
      si_pTableSelect[gr][ch][2] = 0;

      if (si_address[gr][ch][0] > bigv_region)
          si_address[gr][ch][0] = bigv_region;
      if (si_address[gr][ch][1] < si_address[gr][ch][0])
        si_address[gr][ch][1] = si_address[gr][ch][0];
      if (si_address[gr][ch][2] < si_address[gr][ch][1])
        si_address[gr][ch][2] = si_address[gr][ch][1];

      if (si_blockType[gr][ch] != 2) {
          bits += calcBitsLong(quant_ix[gr][ch], gr, ch);
      } else {
          int     sfb, window, line, start, end;

          IXS    *ix_s = (IXS *) quant_ix[gr][ch];
          short  *pInput = ipptmp0_576;

          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) {
                      pInput[i++] = (*ix_s)[line][window];
                      pInput[i++] = (*ix_s)[line + 1][window];
                  }
              }
          }

          bits += calcBitsLong(pInput, gr, ch);
      }
      return bits;
  }

/******************************************************************************
//  Name:
//    iter_reset
//
//  Description:
//    resets all side_info variables before itaration process
******************************************************************************/

  void MP3EncoderInt::iterReset(int gr,
                             int ch)
  {
    int     i, sfb, b;

    if (si_winSwitch[gr][ch] && (si_blockType[gr][ch] == 2)) {
      if (si_mixedBlock[gr][ch]) {
        sfb_lmax = 8;
        sfb_smax = 3;
      } else {
        sfb_lmax = 0;
        sfb_smax = 0;
      }
    } else {
      sfb_lmax = 21;
      sfb_smax = 12;
    }
    for (i = 0; i < 4; i++)
      si_scfsi[ch][i] = 0;

    for (sfb = 0; sfb < SBBND_L; sfb++)
      scalefac_l[gr][ch][sfb] = 0;

    for (sfb = 0; sfb < SBBND_S; sfb++)
      for (b = 0; b < 3; b++)
        scalefac_s[gr][ch][sfb][b] = 0;

    si_cnt1TabSel[gr][ch] = 0;
    si_reg0Cnt[gr][ch] = 0;
    si_reg1Cnt[gr][ch] = 0;
    si_part23Len[gr][ch] = 0;
    si_part2Len[gr][ch] = 0;
    si_bigVals[gr][ch] = 0;
    si_preFlag[gr][ch] = 0;
    si_sfCompress[gr][ch] = 0;
    si_sfScale[gr][ch] = 0;
    si_count1[gr][ch] = 0;

    si_pSubBlkGain[gr][ch][0] = 0;
    si_pSubBlkGain[gr][ch][1] = 0;
    si_pSubBlkGain[gr][ch][2] = 0;

    si_pTableSelect[gr][ch][0] = 0;
    si_pTableSelect[gr][ch][1] = 0;
    si_pTableSelect[gr][ch][2] = 0;

  }

/******************************************************************************
//  Name:
//    calc_part2Len
//
//  Description:
//    Calculate the number of main_data bits used for scalefactors.
//
//  Input Arguments:
//    EC - pointer to encoder context
//    gr - number of granule
//    ch - number of channel
//
//  Output Arguments:
//
//
//  Returns:
//    number of main_data bits used for scalefactors
//
******************************************************************************/

  int MP3EncoderInt::calcPart2Len(int gr,
                               int ch)
  {
    int     slen1, slen2, bits;

    bits = 0;

    slen1 = mp3enc_slen1_tab[si_sfCompress[gr][ch]];
    slen2 = mp3enc_slen2_tab[si_sfCompress[gr][ch]];

    if ((si_winSwitch[gr][ch] == 1) && (si_blockType[gr][ch] == 2)) {
      if (si_mixedBlock[gr][ch]) {
        bits += (8 * slen1) + (9 * slen1) + (18 * slen2);
      } else {
        bits += (18 * slen1) + (18 * slen2);
      }
    } else {
      if ((gr == 0) || (si_scfsi[ch][0] == 0))
        bits += (6 * slen1);

      if ((gr == 0) || (si_scfsi[ch][1] == 0))
        bits += (5 * slen1);

      if ((gr == 0) || (si_scfsi[ch][2] == 0))
        bits += (5 * slen2);

      if ((gr == 0) || (si_scfsi[ch][3] == 0))
        bits += (5 * slen2);
    }

    si_part2Len[gr][ch] = bits;

    return bits;
  }

  int MP3EncoderInt::scaleBitCount(int gr,
                                int ch)
  {
    int     i, k, sfb, max_slen1 = 0, max_slen2 = 0;

    static int slen1[16] = { 0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4 };
    static int slen2[16] = { 0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3 };
    static int pow2[5] = { 1, 2, 4, 8, 16 };

    if ((si_winSwitch[gr][ch] == 1) && (si_blockType[gr][ch] == 2)) {
      if (si_mixedBlock[gr][ch] == 0) {
        for (i = 0; i < 3; i++) {
          for (sfb = 0; sfb < 6; sfb++)
            if (scalefac_s[gr][ch][sfb][i] > max_slen1)
              max_slen1 = scalefac_s[gr][ch][sfb][i];
          for (sfb = 6; sfb < 12; sfb++)
            if (scalefac_s[gr][ch][sfb][i] > max_slen2)
              max_slen2 = scalefac_s[gr][ch][sfb][i];
        }
      } else {
        for (sfb = 0; sfb < 8; sfb++)
          if (scalefac_l[gr][ch][sfb] > max_slen1)
            max_slen1 = scalefac_l[gr][ch][sfb];

        for (i = 0; i < 3; i++) {
          for (sfb = 3; sfb < 6; sfb++)
            if (scalefac_s[gr][ch][sfb][i] > max_slen1)
              max_slen1 = scalefac_s[gr][ch][sfb][i];
          for (sfb = 6; sfb < 12; sfb++)
            if (scalefac_s[gr][ch][sfb][i] > max_slen2)
              max_slen2 = scalefac_s[gr][ch][sfb][i];
        }
      }
    } else {    // block_type == 0,1,or 3
      for (sfb = 0; sfb < 11; sfb++)
        if (scalefac_l[gr][ch][sfb] > max_slen1)
          max_slen1 = scalefac_l[gr][ch][sfb];
      for (sfb = 11; sfb < 21; sfb++)
        if (scalefac_l[gr][ch][sfb] > max_slen2)
          max_slen2 = scalefac_l[gr][ch][sfb];
    }

    for (k = 0; k < 16; k++) {
      if ((max_slen1 < pow2[slen1[k]]) && (max_slen2 < pow2[slen2[k]])) {
        si_sfCompress[gr][ch] = k;
        return 0;
      }
    }

    return 1;
  }
};      // namespace UMC