xref: /frameworks/av/media/libstagefright/codecs/aacenc/src/quantize.c

/*
 ** Copyright 2003-2010, VisualOn, Inc.
 **
 ** Licensed under the Apache License, Version 2.0 (the "License");
 ** you may not use this file except in compliance with the License.
 ** You may obtain a copy of the License at
 **
 **     http://www.apache.org/licenses/LICENSE-2.0
 **
 ** Unless required by applicable law or agreed to in writing, software
 ** distributed under the License is distributed on an "AS IS" BASIS,
 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 ** See the License for the specific language governing permissions and
 ** limitations under the License.
 */
/*******************************************************************************
	File:		quantize.c

	Content:	quantization functions

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

#include "typedef.h"
#include "basic_op.h"
#include "oper_32b.h"
#include "quantize.h"
#include "aac_rom.h"

#define MANT_DIGITS 9
#define MANT_SIZE   (1<<MANT_DIGITS)

static const Word32 XROUND = 0x33e425af; /* final rounding constant (-0.0946f+ 0.5f) */


/*****************************************************************************
*
* function name:pow34
* description: calculate $x^{\frac{3}{4}}, for 0.5 < x < 1.0$.
*
*****************************************************************************/
__inline Word32 pow34(Word32 x)
{
  /* index table using MANT_DIGITS bits, but mask out the sign bit and the MSB
     which is always one */
  return mTab_3_4[(x >> (INT_BITS-2-MANT_DIGITS)) & (MANT_SIZE-1)];
}


/*****************************************************************************
*
* function name:quantizeSingleLine
* description: quantizes spectrum
*              quaSpectrum = mdctSpectrum^3/4*2^(-(3/16)*gain)
*
*****************************************************************************/
static Word16 quantizeSingleLine(const Word16 gain, const Word32 absSpectrum)
{
  Word32 e, minusFinalExp, finalShift;
  Word32 x;
  Word16 qua = 0;


  if (absSpectrum) {
    e = norm_l(absSpectrum);
    x = pow34(absSpectrum << e);

    /* calculate the final fractional exponent times 16 (was 3*(4*e + gain) + (INT_BITS-1)*16) */
    minusFinalExp = (e << 2) + gain;
    minusFinalExp = (minusFinalExp << 1) + minusFinalExp;
    minusFinalExp = minusFinalExp + ((INT_BITS-1) << 4);

    /* separate the exponent into a shift, and a multiply */
    finalShift = minusFinalExp >> 4;

    if (finalShift < INT_BITS) {
      x = L_mpy_wx(x, pow2tominusNover16[minusFinalExp & 15]);

      x += XROUND >> (INT_BITS - finalShift);

      /* shift and quantize */
	  finalShift--;

	  if(finalShift >= 0)
		  x >>= finalShift;
	  else
		  x <<= (-finalShift);

	  qua = saturate(x);
    }
  }

  return qua;
}

/*****************************************************************************
*
* function name:quantizeLines
* description: quantizes spectrum lines
*              quaSpectrum = mdctSpectrum^3/4*2^(-(3/16)*gain)
*  input: global gain, number of lines to process, spectral data
*  output: quantized spectrum
*
*****************************************************************************/
static void quantizeLines(const Word16 gain,
                          const Word16 noOfLines,
                          const Word32 *mdctSpectrum,
                          Word16 *quaSpectrum)
{
  Word32 line;
  Word32 m = gain&3;
  Word32 g = (gain >> 2) + 4;
  Word32 mdctSpeL;
  const Word16 *pquat;
    /* gain&3 */

  pquat = quantBorders[m];

  g += 16;

  if(g >= 0)
  {
	for (line=0; line<noOfLines; line++) {
	  Word32 qua;
	  qua = 0;

	  mdctSpeL = mdctSpectrum[line];

	  if (mdctSpeL) {
		Word32 sa;
		Word32 saShft;

        sa = L_abs(mdctSpeL);
        //saShft = L_shr(sa, 16 + g);
	    saShft = sa >> g;

        if (saShft > pquat[0]) {

          if (saShft < pquat[1]) {

            qua = mdctSpeL>0 ? 1 : -1;
		  }
          else {

            if (saShft < pquat[2]) {

              qua = mdctSpeL>0 ? 2 : -2;
			}
            else {

              if (saShft < pquat[3]) {

                qua = mdctSpeL>0 ? 3 : -3;
			  }
              else {
                qua = quantizeSingleLine(gain, sa);
                /* adjust the sign. Since 0 < qua < 1, this cannot overflow. */

                if (mdctSpeL < 0)
                  qua = -qua;
			  }
			}
		  }
		}
	  }
      quaSpectrum[line] = qua ;
	}
  }
  else
  {
	for (line=0; line<noOfLines; line++) {
	  Word32 qua;
	  qua = 0;

	  mdctSpeL = mdctSpectrum[line];

	  if (mdctSpeL) {
		Word32 sa;
		Word32 saShft;

        sa = L_abs(mdctSpeL);
        saShft = sa << g;

        if (saShft > pquat[0]) {

          if (saShft < pquat[1]) {

            qua = mdctSpeL>0 ? 1 : -1;
		  }
          else {

            if (saShft < pquat[2]) {

              qua = mdctSpeL>0 ? 2 : -2;
			}
            else {

              if (saShft < pquat[3]) {

                qua = mdctSpeL>0 ? 3 : -3;
			  }
              else {
                qua = quantizeSingleLine(gain, sa);
                /* adjust the sign. Since 0 < qua < 1, this cannot overflow. */

                if (mdctSpeL < 0)
                  qua = -qua;
			  }
			}
		  }
		}
	  }
      quaSpectrum[line] = qua ;
	}
  }

}


/*****************************************************************************
*
* function name:iquantizeLines
* description: iquantizes spectrum lines without sign
*              mdctSpectrum = iquaSpectrum^4/3 *2^(0.25*gain)
* input: global gain, number of lines to process,quantized spectrum
* output: spectral data
*
*****************************************************************************/
static void iquantizeLines(const Word16 gain,
                           const Word16 noOfLines,
                           const Word16 *quantSpectrum,
                           Word32 *mdctSpectrum)
{
  Word32   iquantizermod;
  Word32   iquantizershift;
  Word32   line;

  iquantizermod = gain & 3;
  iquantizershift = gain >> 2;

  for (line=0; line<noOfLines; line++) {

    if( quantSpectrum[line] != 0 ) {
      Word32 accu;
      Word32 ex;
	  Word32 tabIndex;
      Word32 specExp;
      Word32 s,t;

      accu = quantSpectrum[line];

      ex = norm_l(accu);
      accu = accu << ex;
      specExp = INT_BITS-1 - ex;

      tabIndex = (accu >> (INT_BITS-2-MANT_DIGITS)) & (~MANT_SIZE);

      /* calculate "mantissa" ^4/3 */
      s = mTab_4_3[tabIndex];

      /* get approperiate exponent multiplier for specExp^3/4 combined with scfMod */
      t = specExpMantTableComb_enc[iquantizermod][specExp];

      /* multiply "mantissa" ^4/3 with exponent multiplier */
      accu = MULHIGH(s, t);

      /* get approperiate exponent shifter */
      specExp = specExpTableComb_enc[iquantizermod][specExp];

      specExp += iquantizershift + 1;
	  if(specExp >= 0)
		  mdctSpectrum[line] = accu << specExp;
	  else
		  mdctSpectrum[line] = accu >> (-specExp);
    }
    else {
      mdctSpectrum[line] = 0;
    }
  }
}

/*****************************************************************************
*
* function name: QuantizeSpectrum
* description: quantizes the entire spectrum
* returns:
* input: number of scalefactor bands to be quantized, ...
* output: quantized spectrum
*
*****************************************************************************/
void QuantizeSpectrum(Word16 sfbCnt,
                      Word16 maxSfbPerGroup,
                      Word16 sfbPerGroup,
                      Word16 *sfbOffset,
                      Word32 *mdctSpectrum,
                      Word16 globalGain,
                      Word16 *scalefactors,
                      Word16 *quantizedSpectrum)
{
  Word32 sfbOffs, sfb;

  for(sfbOffs=0;sfbOffs<sfbCnt;sfbOffs+=sfbPerGroup) {
    Word32 sfbNext ;
    for (sfb = 0; sfb < maxSfbPerGroup; sfb = sfbNext) {
      Word16 scalefactor = scalefactors[sfbOffs+sfb];
      /* coalesce sfbs with the same scalefactor */
      for (sfbNext = sfb+1;
           sfbNext < maxSfbPerGroup && scalefactor == scalefactors[sfbOffs+sfbNext];
           sfbNext++) ;

      quantizeLines(globalGain - scalefactor,
                    sfbOffset[sfbOffs+sfbNext] - sfbOffset[sfbOffs+sfb],
                    mdctSpectrum + sfbOffset[sfbOffs+sfb],
                    quantizedSpectrum + sfbOffset[sfbOffs+sfb]);
    }
  }
}


/*****************************************************************************
*
* function name:calcSfbDist
* description: quantizes and requantizes lines to calculate distortion
* input:  number of lines to be quantized, ...
* output: distortion
*
*****************************************************************************/
Word32 calcSfbDist(const Word32 *spec,
                   Word16  sfbWidth,
                   Word16  gain)
{
  Word32 line;
  Word32 dist;
  Word32 m = gain&3;
  Word32 g = (gain >> 2) + 4;
  Word32 g2 = (g << 1) + 1;
  const Word16 *pquat, *repquat;
    /* gain&3 */

  pquat = quantBorders[m];
  repquat = quantRecon[m];

  dist = 0;
  g += 16;
  if(g2 < 0 && g >= 0)
  {
	  g2 = -g2;
	  for(line=0; line<sfbWidth; line++) {
		  if (spec[line]) {
			  Word32 diff;
			  Word32 distSingle;
			  Word32 sa;
			  Word32 saShft;
			  sa = L_abs(spec[line]);
			  //saShft = round16(L_shr(sa, g));
			  //saShft = L_shr(sa, 16+g);
			  saShft = sa >> g;

			  if (saShft < pquat[0]) {
				  distSingle = (saShft * saShft) >> g2;
			  }
			  else {

				  if (saShft < pquat[1]) {
					  diff = saShft - repquat[0];
					  distSingle = (diff * diff) >> g2;
				  }
				  else {

					  if (saShft < pquat[2]) {
						  diff = saShft - repquat[1];
						  distSingle = (diff * diff) >> g2;
					  }
					  else {

						  if (saShft < pquat[3]) {
							  diff = saShft - repquat[2];
							  distSingle = (diff * diff) >> g2;
						  }
						  else {
							  Word16 qua = quantizeSingleLine(gain, sa);
							  Word32 iqval, diff32;
							  /* now that we have quantized x, re-quantize it. */
							  iquantizeLines(gain, 1, &qua, &iqval);
							  diff32 = sa - iqval;
							  distSingle = fixmul(diff32, diff32);
						  }
					  }
				  }
			  }

			  dist = L_add(dist, distSingle);
		  }
	  }
  }
  else
  {
	  for(line=0; line<sfbWidth; line++) {
		  if (spec[line]) {
			  Word32 diff;
			  Word32 distSingle;
			  Word32 sa;
			  Word32 saShft;
			  sa = L_abs(spec[line]);
			  //saShft = round16(L_shr(sa, g));
			  saShft = L_shr(sa, g);

			  if (saShft < pquat[0]) {
				  distSingle = L_shl((saShft * saShft), g2);
			  }
			  else {

				  if (saShft < pquat[1]) {
					  diff = saShft - repquat[0];
					  distSingle = L_shl((diff * diff), g2);
				  }
				  else {

					  if (saShft < pquat[2]) {
						  diff = saShft - repquat[1];
						  distSingle = L_shl((diff * diff), g2);
					  }
					  else {

						  if (saShft < pquat[3]) {
							  diff = saShft - repquat[2];
							  distSingle = L_shl((diff * diff), g2);
						  }
						  else {
							  Word16 qua = quantizeSingleLine(gain, sa);
							  Word32 iqval, diff32;
							  /* now that we have quantized x, re-quantize it. */
							  iquantizeLines(gain, 1, &qua, &iqval);
							  diff32 = sa - iqval;
							  distSingle = fixmul(diff32, diff32);
						  }
					  }
				  }
			  }
			  dist = L_add(dist, distSingle);
		  }
	  }
  }

  return dist;
}