/******************************************************************************
 *
 *  Copyright 2014 The Android Open Source Project
 *  Copyright 2003 - 2004 Open Interface North America, Inc. All rights
 *                        reserved.
 *
 *  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.
 *
 ******************************************************************************/

/*******************************************************************************
  $Revision: #1 $
 ******************************************************************************/

/**
 @file

 Dequantizer for SBC decoder; reconstructs quantized representation of subband
 samples.

 @ingroup codec_internal
 */

/**
@addtogroup codec_internal
@{
*/

/**
 This function is a fixed-point approximation of a modification of the following
 dequantization operation defined in the spec, as inferred from section 12.6.4:

 @code
 dequant = 2^(scale_factor+1) * ((raw * 2.0 + 1.0) / ((2^bits) - 1) - 1)

 2 <= bits <= 16
 0 <= raw < (2^bits)-1   (the -1 is because quantized values with all 1's are
 forbidden)

 -65535 < dequant < 65535
 @endcode

 The code below computes the dequantized value divided by a scaling constant
 equal to about 1.38. This constant is chosen to ensure that the entry in the
 dequant_long_scaled table for 16 bits is as accurate as possible, since it has
 the least relative precision available to it due to its small magnitude.

 This routine outputs in Q16.15 format.

 The helper array dequant_long is defined as follows:

 @code
 dequant_long_long[bits] = round(2^31 * 1/((2^bits - 1) / 1.38...)  for 2 <=
 bits <= 16
 @endcode


 Additionally, the table entries have the following property:

 @code
 dequant_long_scaled[bits] <= 2^31 / ((2^bits - 1))  for 2 <= bits <= 16
 @endcode

 Therefore

 @code
 d = 2 * raw + 1              1 <= d <= 2^bits - 2

 d' = d * dequant_long[bits]

                  d * dequant_long_scaled[bits] <= (2^bits - 2) * (2^31 /
 (2^bits - 1))
                  d * dequant_long_scaled[bits] <= 2^31 * (2^bits - 2)/(2^bits -
 1) < 2^31
 @endcode

 Therefore, d' doesn't overflow a signed 32-bit value.

 @code

 d' =~ 2^31 * (raw * 2.0 + 1.0) / (2^bits - 1) / 1.38...

 result = d' - 2^31/1.38... =~ 2^31 * ((raw * 2.0 + 1.0) / (2^bits - 1) - 1) /
 1.38...

 result is therefore a scaled approximation to dequant. It remains only to
 turn 2^31 into 2^(scale_factor+1). Since we're aiming for Q16.15 format,
 this is achieved by shifting right by (15-scale_factor):

  (2^31 * x) >> (15-scale_factor) =~ 2^(31-15+scale_factor) * x = 2^15 *
 2^(1+scale_factor) * x
 @endcode

 */

#include <oi_codec_sbc_private.h>

#ifndef SBC_DEQUANT_LONG_SCALED_OFFSET
#define SBC_DEQUANT_LONG_SCALED_OFFSET 1555931970
#endif

#ifndef SBC_DEQUANT_LONG_UNSCALED_OFFSET
#define SBC_DEQUANT_LONG_UNSCALED_OFFSET 2147483648
#endif

#ifndef SBC_DEQUANT_SCALING_FACTOR
#define SBC_DEQUANT_SCALING_FACTOR 1.38019122262781f
#endif

const uint32_t dequant_long_scaled[17];
const uint32_t dequant_long_unscaled[17];

/** Scales x by y bits to the right, adding a rounding factor.
 */
#ifndef SCALE
#define SCALE(x, y) (((x) + (1 << ((y)-1))) >> (y))
#endif

#ifdef DEBUG_DEQUANTIZATION

#include <math.h>

INLINE float dequant_float(uint32_t raw, OI_UINT scale_factor, OI_UINT bits) {
  float result = (1 << (scale_factor + 1)) *
                 ((raw * 2.0f + 1.0f) / ((1 << bits) - 1.0f) - 1.0f);

  result /= SBC_DEQUANT_SCALING_FACTOR;

  /* Unless the encoder screwed up, all correct dequantized values should
   * satisfy this inequality. Non-compliant encoders which generate quantized
   * values with all 1-bits set can, theoretically, trigger this assert. This
   * is unlikely, however, and only an issue in debug mode.
   */
  OI_ASSERT(fabs(result) < 32768 * 1.6);

  return result;
}

#endif

INLINE int32_t OI_SBC_Dequant(uint32_t raw, OI_UINT scale_factor,
                              OI_UINT bits) {
  uint32_t d;
  int32_t result;

  OI_ASSERT(scale_factor <= 15);
  OI_ASSERT(bits <= 16);

  if (bits <= 1) {
    return 0;
  }

  d = (raw * 2) + 1;
  d *= dequant_long_scaled[bits];
  result = d - SBC_DEQUANT_LONG_SCALED_OFFSET;

#ifdef DEBUG_DEQUANTIZATION
  {
    int32_t integerized_float_result;
    float float_result;

    float_result = dequant_float(raw, scale_factor, bits);
    integerized_float_result = (int32_t)floor(0.5f + float_result * (1 << 15));

    /* This detects overflow */
    OI_ASSERT(((result >= 0) && (integerized_float_result >= 0)) ||
              ((result <= 0) && (integerized_float_result <= 0)));
  }
#endif
  return result >> (15 - scale_factor);
}

/* This version of Dequant does not incorporate the scaling factor of 1.38. It
 * is intended for use with implementations of the filterbank which are
 * hard-coded into a DSP. Output is Q16.4 format, so that after joint stereo
 * processing (which leaves the most significant bit equal to the sign bit if
 * the encoder is conformant) the result will fit a 24 bit fixed point signed
 * value.*/

INLINE int32_t OI_SBC_Dequant_Unscaled(uint32_t raw, OI_UINT scale_factor,
                                       OI_UINT bits) {
  uint32_t d;
  int32_t result;

  OI_ASSERT(scale_factor <= 15);
  OI_ASSERT(bits <= 16);

  if (bits <= 1) {
    return 0;
  }
  if (bits == 16) {
    result = (raw << 16) + raw - 0x7fff7fff;
    return SCALE(result, 24 - scale_factor);
  }

  d = (raw * 2) + 1;
  d *= dequant_long_unscaled[bits];
  result = d - 0x80000000;

  return SCALE(result, 24 - scale_factor);
}

/**
@}
*/