Home | History | Annotate | Download | only in srce 
      1 /******************************************************************************
      2  *
      3  *  Copyright (C) 2014 The Android Open Source Project
      4  *  Copyright 2003 - 2004 Open Interface North America, Inc. All rights reserved.
      5  *
      6  *  Licensed under the Apache License, Version 2.0 (the "License");
      7  *  you may not use this file except in compliance with the License.
      8  *  You may obtain a copy of the License at:
      9  *
     10  *  http://www.apache.org/licenses/LICENSE-2.0
     11  *
     12  *  Unless required by applicable law or agreed to in writing, software
     13  *  distributed under the License is distributed on an "AS IS" BASIS,
     14  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     15  *  See the License for the specific language governing permissions and
     16  *  limitations under the License.
     17  *
     18  ******************************************************************************/
     19 
     20 /**********************************************************************************
     21   $Revision: #1 $
     22 ***********************************************************************************/
     23 
     24 /**
     25  @file
     26 
     27  Dequantizer for SBC decoder; reconstructs quantized representation of subband samples.
     28 
     29  @ingroup codec_internal
     30  */
     31 
     32 /**
     33 @addtogroup codec_internal
     34 @{
     35 */
     36 
     37 /**
     38  This function is a fixed-point approximation of a modification of the following
     39  dequantization operation defined in the spec, as inferred from section 12.6.4:
     40 
     41  @code
     42  dequant = 2^(scale_factor+1) * ((raw * 2.0 + 1.0) / ((2^bits) - 1) - 1)
     43 
     44  2 <= bits <= 16
     45  0 <= raw < (2^bits)-1   (the -1 is because quantized values with all 1's are forbidden)
     46 
     47  -65535 < dequant < 65535
     48  @endcode
     49 
     50  The code below computes the dequantized value divided by a scaling constant
     51  equal to about 1.38. This constant is chosen to ensure that the entry in the
     52  dequant_long_scaled table for 16 bits is as accurate as possible, since it has
     53  the least relative precision available to it due to its small magnitude.
     54 
     55  This routine outputs in Q16.15 format.
     56 
     57  The helper array dequant_long is defined as follows:
     58 
     59  @code
     60  dequant_long_long[bits] = round(2^31 * 1/((2^bits - 1) / 1.38...)  for 2 <= bits <= 16
     61  @endcode
     62 
     63 
     64  Additionally, the table entries have the following property:
     65 
     66  @code
     67  dequant_long_scaled[bits] <= 2^31 / ((2^bits - 1))  for 2 <= bits <= 16
     68  @endcode
     69 
     70  Therefore
     71 
     72  @code
     73  d = 2 * raw + 1              1 <= d <= 2^bits - 2
     74 
     75  d' = d * dequant_long[bits]
     76 
     77                   d * dequant_long_scaled[bits] <= (2^bits - 2) * (2^31 / (2^bits - 1))
     78                   d * dequant_long_scaled[bits] <= 2^31 * (2^bits - 2)/(2^bits - 1) < 2^31
     79  @endcode
     80 
     81  Therefore, d' doesn't overflow a signed 32-bit value.
     82 
     83  @code
     84 
     85  d' =~ 2^31 * (raw * 2.0 + 1.0) / (2^bits - 1) / 1.38...
     86 
     87  result = d' - 2^31/1.38... =~ 2^31 * ((raw * 2.0 + 1.0) / (2^bits - 1) - 1) / 1.38...
     88 
     89  result is therefore a scaled approximation to dequant. It remains only to
     90  turn 2^31 into 2^(scale_factor+1). Since we're aiming for Q16.15 format,
     91  this is achieved by shifting right by (15-scale_factor):
     92 
     93   (2^31 * x) >> (15-scale_factor) =~ 2^(31-15+scale_factor) * x = 2^15 * 2^(1+scale_factor) * x
     94  @endcode
     95 
     96  */
     97 
     98 #include <oi_codec_sbc_private.h>
     99 
    100 #ifndef SBC_DEQUANT_LONG_SCALED_OFFSET
    101 #define SBC_DEQUANT_LONG_SCALED_OFFSET 1555931970
    102 #endif
    103 
    104 #ifndef SBC_DEQUANT_LONG_UNSCALED_OFFSET
    105 #define SBC_DEQUANT_LONG_UNSCALED_OFFSET 2147483648
    106 #endif
    107 
    108 #ifndef SBC_DEQUANT_SCALING_FACTOR
    109 #define SBC_DEQUANT_SCALING_FACTOR 1.38019122262781f
    110 #endif
    111 
    112 const OI_UINT32 dequant_long_scaled[17];
    113 const OI_UINT32 dequant_long_unscaled[17];
    114 
    115 /** Scales x by y bits to the right, adding a rounding factor.
    116  */
    117 #ifndef SCALE
    118 #define SCALE(x, y) (((x) + (1 <<((y)-1))) >> (y))
    119 #endif
    120 
    121 #ifdef DEBUG_DEQUANTIZATION
    122 
    123 #include <math.h>
    124 
    125 INLINE float dequant_float(OI_UINT32 raw, OI_UINT scale_factor, OI_UINT bits)
    126 {
    127     float result = (1 << (scale_factor+1)) * ((raw * 2.0f + 1.0f) / ((1 << bits) - 1.0f) - 1.0f);
    128 
    129     result /= SBC_DEQUANT_SCALING_FACTOR;
    130 
    131     /* Unless the encoder screwed up, all correct dequantized values should
    132      * satisfy this inequality. Non-compliant encoders which generate quantized
    133      * values with all 1-bits set can, theoretically, trigger this assert. This
    134      * is unlikely, however, and only an issue in debug mode.
    135      */
    136     OI_ASSERT(fabs(result) < 32768 * 1.6);
    137 
    138     return result;
    139 }
    140 
    141 #endif
    142 
    143 
    144 INLINE OI_INT32 OI_SBC_Dequant(OI_UINT32 raw, OI_UINT scale_factor, OI_UINT bits)
    145 {
    146     OI_UINT32 d;
    147     OI_INT32 result;
    148 
    149     OI_ASSERT(scale_factor <= 15);
    150     OI_ASSERT(bits <= 16);
    151 
    152     if (bits <= 1) {
    153         return 0;
    154     }
    155 
    156     d = (raw * 2) + 1;
    157     d *= dequant_long_scaled[bits];
    158     result = d - SBC_DEQUANT_LONG_SCALED_OFFSET;
    159 
    160 #ifdef DEBUG_DEQUANTIZATION
    161     {
    162         OI_INT32 integerized_float_result;
    163         float float_result;
    164 
    165         float_result = dequant_float(raw, scale_factor, bits);
    166         integerized_float_result = (OI_INT32)floor(0.5f+float_result * (1 << 15));
    167 
    168         /* This detects overflow */
    169         OI_ASSERT(((result >= 0) && (integerized_float_result >= 0)) ||
    170                   ((result <= 0) && (integerized_float_result <= 0)));
    171     }
    172 #endif
    173     return result >> (15 - scale_factor);
    174 }
    175 
    176 /* This version of Dequant does not incorporate the scaling factor of 1.38. It
    177  * is intended for use with implementations of the filterbank which are
    178  * hard-coded into a DSP. Output is Q16.4 format, so that after joint stereo
    179  * processing (which leaves the most significant bit equal to the sign bit if
    180  * the encoder is conformant) the result will fit a 24 bit fixed point signed
    181  * value.*/
    182 
    183 INLINE OI_INT32 OI_SBC_Dequant_Unscaled(OI_UINT32 raw, OI_UINT scale_factor, OI_UINT bits)
    184 {
    185     OI_UINT32 d;
    186     OI_INT32 result;
    187 
    188     OI_ASSERT(scale_factor <= 15);
    189     OI_ASSERT(bits <= 16);
    190 
    191 
    192     if (bits <= 1) {
    193         return 0;
    194     }
    195     if (bits == 16) {
    196         result = (raw << 16) + raw - 0x7fff7fff;
    197         return SCALE(result, 24 - scale_factor);
    198     }
    199 
    200 
    201     d = (raw * 2) + 1;
    202     d *= dequant_long_unscaled[bits];
    203     result = d - 0x80000000;
    204 
    205     return SCALE(result, 24 - scale_factor);
    206 }
    207 
    208 /**
    209 @}
    210 */
    211