summaryrefslogtreecommitdiffstats
path: root/media/libstagefright/codecs/aacdec/esc_iquant_scaling.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'media/libstagefright/codecs/aacdec/esc_iquant_scaling.cpp')
-rw-r--r--media/libstagefright/codecs/aacdec/esc_iquant_scaling.cpp789
1 files changed, 0 insertions, 789 deletions
diff --git a/media/libstagefright/codecs/aacdec/esc_iquant_scaling.cpp b/media/libstagefright/codecs/aacdec/esc_iquant_scaling.cpp
deleted file mode 100644
index 778c88c..0000000
--- a/media/libstagefright/codecs/aacdec/esc_iquant_scaling.cpp
+++ /dev/null
@@ -1,789 +0,0 @@
-/* ------------------------------------------------------------------
- * Copyright (C) 1998-2009 PacketVideo
- *
- * 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.
- * -------------------------------------------------------------------
- */
-/*
-
- Pathname: ./src/esc_iquant_scaling.c
- Funtions: esc_iquant_scaling
-
-------------------------------------------------------------------------------
- REVISION HISTORY
-
- Description: Modified from esc_iquant_fxp.c code
-
- Description: Eliminated unused variables to avoid warnings, changed header
-
- Who: Date:
- Description:
-
-------------------------------------------------------------------------------
- INPUT AND OUTPUT DEFINITIONS
-
- Inputs:
- quantSpec[] = array of quantized compressed spectral coefficients, of
- data type Int and length sfbWidth.
-
- sfbWidth = number of array elements in quantSpec and the output array
- coef, data type Int.
-
- coef[] = output array of uncompressed coefficients, stored in a
- variable Q format, depending on the maximum value found
- for the group, array of Int32, length sfbWdith to be
- overwritten.
-
- QFormat = the output Q format for the array coef[].
-
-
- scale = scaling factor after separating power of 2 factor out from
- 0.25*(sfb_scale - 100), i.e., 0.25*sfb_scale.
-
- maxInput = maximum absolute value of quantSpec.
-
- Local Stores/Buffers/Pointers Needed: None.
-
- Global Stores/Buffers/Pointers Needed:
- inverseQuantTable = lookup table of const integer values to the one third
- power stored in Q27 format, in file iquant_table.c, const
- array of UInt32, of size 1025.
-
- Outputs: None
-
- Pointers and Buffers Modified:
- coef[] contents are overwritten with the uncompressed values from
- quantSpec[]
-
-
-
-
- Local Stores Modified: None.
-
- Global Stores Modified: None.
-
-------------------------------------------------------------------------------
- FUNCTION DESCRIPTION
-
- This function performs the inverse quantization of the spectral coeficients
- read from huffman decoding. It takes each input array value to the four
- thirds power, then scales it according to the scaling factor input argument
- ,and stores the result in the output array in a variable Q format
- depending upon the maximum input value found.
-
-------------------------------------------------------------------------------
- REQUIREMENTS
-
- This function shall not have static or global variables.
-
-------------------------------------------------------------------------------
- REFERENCES
-
- (1) ISO/IEC 13818-7:1997 Titled "Information technology - Generic coding
- of moving pictures and associated audio information - Part 7: Advanced
- Audio Coding (AAC)", Section 10.3, "Decoding process", page 43.
-
- (2) MPEG-2 NBC Audio Decoder
- "This software module was originally developed by AT&T, Dolby
- Laboratories, Fraunhofer Gesellschaft IIS in the course of development
- of the MPEG-2 NBC/MPEG-4 Audio standard ISO/IEC 13818-7, 14496-1,2 and
- 3. This software module is an implementation of a part of one or more
- MPEG-2 NBC/MPEG-4 Audio tools as specified by the MPEG-2 NBC/MPEG-4
- Audio standard. ISO/IEC gives users of the MPEG-2 NBC/MPEG-4 Audio
- standards free license to this software module or modifications thereof
- for use in hardware or software products claiming conformance to the
- MPEG-2 NBC/MPEG-4 Audio standards. Those intending to use this software
- module in hardware or software products are advised that this use may
- infringe existing patents. The original developer of this software
- module and his/her company, the subsequent editors and their companies,
- and ISO/IEC have no liability for use of this software module or
- modifications thereof in an implementation. Copyright is not released
- for non MPEG-2 NBC/MPEG-4 Audio conforming products.The original
- developer retains full right to use the code for his/her own purpose,
- assign or donate the code to a third party and to inhibit third party
- from using the code for non MPEG-2 NBC/MPEG-4 Audio conforming products.
- This copyright notice must be included in all copies or derivative
- works."
- Copyright(c)1996.
-
-------------------------------------------------------------------------------
- PSEUDO-CODE
-
- maxInput = 0;
-
- FOR (i = sfbWidth - 1; i >= 0; i--)
- x = quantSpec[i];
-
- IF ( x >= 0)
- absX = x;
- ELSE
- absX = -x;
- ENDIF
-
- coef[i] = absX;
-
- IF (absX > maxInput)
- maxInput = absX;
- ENDIF
- ENDFOR
-
- IF (maxInput == 0)
- *pQFormat = QTABLE;
- ELSE
- temp = inverseQuantTable[(maxInput >> ORDER) + 1];
-
- temp += ((1 << (QTABLE))-1);
-
- temp >>= (QTABLE-1);
-
- temp *= maxInput;
-
- binaryDigits = 0;
- WHILE( temp != 0)
- temp >>= 1;
- binaryDigits++;
- WEND
-
- IF (binaryDigits < (SIGNED32BITS - QTABLE))
- binaryDigits = SIGNED32BITS - QTABLE;
- ENDIF
-
- *pQFormat = SIGNED32BITS - binaryDigits;
- shift = QTABLE - *pQFormat;
-
- IF (maxInput < TABLESIZE)
- FOR (i = sfbWidth - 1; i >= 0; i--)
- x = quantSpec[i];
-
- absX = coef[i];
-
- tmp_coef = x * (inverseQuantTable[absX] >> shift);
-
- b_low = (tmp_coef & 0xFFFF);
- b_high = (tmp_coef >> 16);
-
- mult_low = ( (UInt32) b_low * scale );
- mult_high = ( (Int32) b_high * scale );
-
- mult_low >>= 16;
-
- coef[i] = (Int32) (mult_high + mult_low);
-
- ENDFOR
- ELSE
- FOR (i = sfbWidth; i >= 0 ; i--)
- x = quantSpec[i];
- absX = coef[i];
-
- IF (absX < TABLESIZE)
- tmp_coef = x * (inverseQuantTable[absX] >> shift);
- ELSE
- index = absX >> ORDER;
- w1 = inverseQuantTable[index];
-
- approxOneThird = (w1 * FACTOR) >> shift;
-
-
- x1 = index * SPACING;
- w2 = inverseQuantTable[index+1];
-
- deltaOneThird = (w2 - w1) * (absX - x1);
-
- deltaOneThird >>= (shift + ORDER - 1);
-
- tmp_coef = x * (approxOneThird + deltaOneThird);
-
- ENDIF
-
- b_low = (mult_high & 0xFFFF);
- b_high = (mult_high >> 16);
-
- mult_low = ( (UInt32) b_low * scale );
- mult_high = ( (Int32) b_high * scale );
-
- mult_low >>= 16;
-
- coef[i] = (Int32) (mult_high + mult_low);
-
- ENDFOR
- ENDIF
- ENDIF
-
- RETURN
-
-
-------------------------------------------------------------------------------
- RESOURCES USED
- When the code is written for a specific target processor the
- the resources used should be documented below.
-
- STACK USAGE: [stack count for this module] + [variable to represent
- stack usage for each subroutine called]
-
- where: [stack usage variable] = stack usage for [subroutine
- name] (see [filename].ext)
-
- DATA MEMORY USED: x words
-
- PROGRAM MEMORY USED: x words
-
- CLOCK CYCLES: [cycle count equation for this module] + [variable
- used to represent cycle count for each subroutine
- called]
-
- where: [cycle count variable] = cycle count for [subroutine
- name] (see [filename].ext)
-
-------------------------------------------------------------------------------
-*/
-
-/*----------------------------------------------------------------------------
-; INCLUDES
-----------------------------------------------------------------------------*/
-#include "pv_audio_type_defs.h"
-#include "iquant_table.h"
-#include "esc_iquant_scaling.h"
-#include "aac_mem_funcs.h" /* For pv_memset */
-
-#include "fxp_mul32.h"
-
-/*----------------------------------------------------------------------------
-; MACROS
-; Define module specific macros here
-----------------------------------------------------------------------------*/
-
-/*----------------------------------------------------------------------------
-; DEFINES
-; Include all pre-processor statements here. Include conditional
-; compile variables also.
-----------------------------------------------------------------------------*/
-/*
- * Read further on what order is.
- * Note: If ORDER is not a multiple of 3, FACTOR is not an integer.
- * Note: Portions of this function assume ORDER is 3, and so does the table
- * in iquant_table.c
- */
-#define ORDER (3)
-/*
- * For input values > TABLESIZE, multiply by FACTOR to get x ^ (1/3)
- * FACTOR = 2 ^ (ORDER/3)
- */
-#define FACTOR (2)
-
-/*
- * This is one more than the range of expected inputs.
- */
-#define INPUTRANGE (8192)
-
-/*
- * SPACING is 2 ^ ORDER, and is the spacing between points when in the
- * interpolation range.
- */
-#define SPACING (1<<ORDER)
-
-/*
- * The actual table size is one more than TABLESIZE, to allow for
- * interpolation for numbers near 8191
- */
-#define TABLESIZE (INPUTRANGE/SPACING)
-
-/*
- * Format the table is stored in.
- */
-#define QTABLE (27)
-
-/*
- * Number of bits for data in a signed 32 bit integer.
- */
-#define SIGNED32BITS (31)
-
-/*
- * Round up value for intermediate values obtained from the table
- */
-#define ROUND_UP (( ((UInt32) 1) << (QTABLE) )-1)
-
-#define MASK_LOW16 0xffff
-#define UPPER16 16
-
-/*----------------------------------------------------------------------------
-; LOCAL FUNCTION DEFINITIONS
-; Function Prototype declaration
-----------------------------------------------------------------------------*/
-
-/*----------------------------------------------------------------------------
-; LOCAL VARIABLE DEFINITIONS
-; Variable declaration - defined here and used outside this module
-----------------------------------------------------------------------------*/
-
-/*----------------------------------------------------------------------------
-; EXTERNAL FUNCTION REFERENCES
-; Declare functions defined elsewhere and referenced in this module
-----------------------------------------------------------------------------*/
-
-/*----------------------------------------------------------------------------
-; EXTERNAL VARIABLES REFERENCES
-; Declare variables used in this module but defined elsewhere
-----------------------------------------------------------------------------*/
-
-/*
- * Processing in this function is performed in these steps:
- *
- * 1) Find the overall Q format for the entire group of inputs. This consists
- * of:
- * a) Finding the maximum input
- * b) estimate the maximum output
- * c) Using the table, get max ^ (4/3), taking into account the table is
- * in q format.
- * 2) For each array element, see if the value is directly inside the table.
- * a) If yes, just multiply by table value by itself, then shift as
- * appropriate.
- * b) If no, get an approximation (described below) for x ^ (1/3) by linearly
- * interpolating using lower values in the table, then multiply by a
- * correction factor, then multiply by x (see below).
- *
- * It more accurate to interpolate x ^ (1/3) then x ^ (4/3), so that is stored
- * in the lookup table. For values not in the table, interpolation is used:
- *
- * We want y = x ^ (4/3) = x * (x ^ (1/3))
- *
- * Let x = w * (2 ^ m) where m is a constant, = ORDER
- *
- * then x ^ (1/3) = w ^ (1/3) * (2 ^ (m/3))
- *
- * w is most likely not an integer, so an interpolation with floor(w) and
- * ceil(w) can be performed to approximate w ^ (1/3) by getting values out of
- * the table. Then to get x ^ (1/3), multiply by FACTOR. If m = 0, 3, 6,
- * then FACTOR is a simple power of 2, so a shift can do the job.
- *
- * The actual code employs some more tricks to speed things up, and because
- * the table is stored in Q format.
- *
- * Rather than saving the sign of each input, the unsigned value of
- * abs(x) ^ (1/3) is multiplied by the signed input value.
- */
-
-
-
-#if ( defined(_ARM) || defined(_ARM_V4))
-
-/*
- * Absolute value for 16 bit-numbers
- */
-__inline Int32 abs2(Int32 x)
-{
- Int32 z;
- /*
- z = x - (x<0);
- x = z ^ sign(z)
- */
- __asm
- {
- sub z, x, x, lsr #31
- eor x, z, z, asr #31
- }
- return (x);
-}
-
-
-#define pv_abs(x) abs2(x)
-
-
-#elif (defined(PV_ARM_GCC_V5)||defined(PV_ARM_GCC_V4))
-
-/*
- * Absolute value for 16 bit-numbers
- */
-__inline Int32 abs2(Int32 x)
-{
- register Int32 z;
- register Int32 y;
- register Int32 ra = x;
- asm volatile(
- "sub %0, %2, %2, lsr #31\n\t"
- "eor %1, %0, %0, asr #31"
- : "=&r*i"(z),
- "=&r*i"(y)
- : "r"(ra));
-
- return (y);
-}
-
-#define pv_abs(x) abs2(x)
-
-
-#else
-
-#define pv_abs(x) ((x) > 0)? (x) : (-x)
-
-#endif
-
-
-
-
-
-void esc_iquant_scaling(
- const Int16 quantSpec[],
- Int32 coef[],
- const Int sfbWidth,
- Int const QFormat,
- UInt16 scale,
- Int maxInput)
-{
- Int i;
- Int x;
- Int y;
- Int index;
- Int shift;
- UInt absX;
- UInt32 w1, w2;
- UInt32 deltaOneThird;
- UInt32 x1;
- UInt32 approxOneThird;
- Int32 mult_high;
-
-
-#if ( defined(_ARM) || defined(_ARM_V4))
-
- {
- Int32 *temp;
- Int32 R12, R11, R10, R9;
-
- deltaOneThird = sizeof(Int32) * sfbWidth;
- temp = coef;
-
- // from standard library call for __rt_memset
- __asm
- {
- MOV R12, #0x0
- MOV R11, #0x0
- MOV R10, #0x0
- MOV R9, #0x0
- SUBS deltaOneThird, deltaOneThird, #0x20
-loop:
- STMCSIA temp!, {R12, R11, R10, R9}
- STMCSIA temp!, {R12, R11, R10, R9}
- SUBCSS deltaOneThird, deltaOneThird, #0x20
- BCS loop
-
- MOVS deltaOneThird, deltaOneThird, LSL #28
- STMCSIA temp!, {R12, R11, R10, R9}
- STMMIIA temp!, {R12, R11}
- }
- }
-
-#else
- pv_memset(coef, 0, sizeof(Int32) * sfbWidth);
-#endif
-
- if (maxInput > 0)
- {
-
- shift = QTABLE - QFormat;
-
- if (scale != 0)
- {
- if (maxInput < TABLESIZE)
- {
-
- for (i = sfbWidth - 1; i >= 0; i -= 4)
- {
- x = quantSpec[i];
- y = quantSpec[i-1];
- if (x)
- {
- absX = pv_abs(x);
- mult_high = (x * (inverseQuantTable[absX] >> shift));
- coef[i] = fxp_mul32_by_16(mult_high, scale) << 1;
- }
-
- if (y)
- {
- absX = pv_abs(y);
- mult_high = y * (inverseQuantTable[absX] >> shift);
- coef[i-1] = fxp_mul32_by_16(mult_high, scale) << 1;
- }
-
- x = quantSpec[i-2];
- y = quantSpec[i-3];
- if (x)
- {
- absX = pv_abs(x);
- mult_high = x * (inverseQuantTable[absX] >> shift);
- coef[i-2] = fxp_mul32_by_16(mult_high, scale) << 1;
- }
-
- if (y)
- {
- absX = pv_abs(y);
- mult_high = y * (inverseQuantTable[absX] >> shift);
- coef[i-3] = fxp_mul32_by_16(mult_high, scale) << 1;
- }
- } /* end for (i = sfbWidth - 1; i >= 0; i--) */
-
- } /* end if (maxInput < TABLESIZE)*/
-
- else /* maxInput >= TABLESIZE) */
- {
- for (i = sfbWidth - 1; i >= 0; i -= 4)
- {
- x = quantSpec[i];
- if (x)
- {
- absX = pv_abs(x);
- if (absX < TABLESIZE)
- {
- mult_high = x * (inverseQuantTable[absX] >> shift);
- coef[i] = fxp_mul32_by_16(mult_high, scale) << 1;
-
- }
- else
- {
- index = absX >> ORDER;
- w1 = inverseQuantTable[index];
- w2 = inverseQuantTable[index+1];
- approxOneThird = (w1 * FACTOR) >> shift;
- x1 = index << ORDER;
- deltaOneThird = (w2 - w1) * (absX - x1);
- deltaOneThird >>= (shift + 2);
- mult_high = x * (approxOneThird + deltaOneThird);
- coef[i] = fxp_mul32_by_16(mult_high, scale) << 1;
-
- }
- } /* if(x) */
-
-
- x = quantSpec[i-1];
- if (x)
- {
- absX = pv_abs(x);
- if (absX < TABLESIZE)
- {
- mult_high = (x * (inverseQuantTable[absX] >> shift));
- coef[i-1] = fxp_mul32_by_16(mult_high, scale) << 1;
-
- }
- else
- {
- index = absX >> ORDER;
- w1 = inverseQuantTable[index];
- w2 = inverseQuantTable[index+1];
- approxOneThird = (w1 * FACTOR) >> shift;
- x1 = index << ORDER;
- deltaOneThird = (w2 - w1) * (absX - x1);
- deltaOneThird >>= (shift + 2);
- mult_high = x * (approxOneThird + deltaOneThird);
- coef[i-1] = fxp_mul32_by_16(mult_high, scale) << 1;
- }
- } /* if(x) */
-
- x = quantSpec[i-2];
- if (x)
- {
- absX = pv_abs(x);
- if (absX < TABLESIZE)
- {
- mult_high = x * (inverseQuantTable[absX] >> shift);
- coef[i-2] = fxp_mul32_by_16(mult_high, scale) << 1;
- }
- else
- {
- index = absX >> ORDER;
- w1 = inverseQuantTable[index];
- w2 = inverseQuantTable[index+1];
- approxOneThird = (w1 * FACTOR) >> shift;
- x1 = index << ORDER;
- deltaOneThird = (w2 - w1) * (absX - x1);
- deltaOneThird >>= (shift + 2);
- mult_high = x * (approxOneThird + deltaOneThird);
- coef[i-2] = fxp_mul32_by_16(mult_high, scale) << 1;
- }
- } /* if(x) */
-
- x = quantSpec[i-3];
- if (x)
- {
- absX = pv_abs(x);
- if (absX < TABLESIZE)
- {
- mult_high = x * (inverseQuantTable[absX] >> shift);
- coef[i-3] = fxp_mul32_by_16(mult_high, scale) << 1;
-
- }
- else
- {
- index = absX >> ORDER;
- w1 = inverseQuantTable[index];
- w2 = inverseQuantTable[index+1];
- approxOneThird = (w1 * FACTOR) >> shift;
- x1 = index << ORDER;
- deltaOneThird = (w2 - w1) * (absX - x1);
- deltaOneThird >>= (shift + 2);
- mult_high = x * (approxOneThird + deltaOneThird);
- coef[i-3] = fxp_mul32_by_16(mult_high, scale) << 1;
-
- }
- } /* if(x) */
-
- } /* end for (i = sfbWidth - 1; i >= 0; i--) */
- } /* end else for if (maxInput < TABLESIZE)*/
- }
- else /* scale == 0 */
- {
- if (maxInput < TABLESIZE)
- {
- for (i = sfbWidth - 1; i >= 0; i -= 4)
- {
- x = quantSpec[i];
- y = quantSpec[i-1];
- if (x)
- {
- absX = pv_abs(x);
- mult_high = x * (inverseQuantTable[absX] >> shift);
- coef[i] = mult_high >> 1;
- }
-
- if (y)
- {
- absX = pv_abs(y);
- mult_high = y * (inverseQuantTable[absX] >> shift);
- coef[i-1] = mult_high >> 1;
- }
-
- x = quantSpec[i-2];
- y = quantSpec[i-3];
- if (x)
- {
- absX = pv_abs(x);
- mult_high = x * (inverseQuantTable[absX] >> shift);
- coef[i-2] = mult_high >> 1;
- }
-
- if (y)
- {
- absX = pv_abs(y);
- mult_high = y * (inverseQuantTable[absX] >> shift);
- coef[i-3] = mult_high >> 1;
- }
- }
-
- } /* end if (maxInput < TABLESIZE)*/
-
- else /* maxInput >= TABLESIZE) */
- {
- for (i = sfbWidth - 1; i >= 0; i -= 4)
- {
- x = quantSpec[i];
- if (x)
- {
- absX = pv_abs(x);
- if (absX < TABLESIZE)
- {
- mult_high = x * (inverseQuantTable[absX] >> shift);
- coef[i] = (mult_high >> 1);
- } /* end if (absX < TABLESIZE) */
- else
- {
- index = absX >> ORDER;
- w1 = inverseQuantTable[index];
- w2 = inverseQuantTable[index+1];
- approxOneThird = (w1 * FACTOR) >> shift;
- x1 = index << ORDER;
- deltaOneThird = (w2 - w1) * (absX - x1);
- deltaOneThird >>= (shift + 2);
- mult_high = x * (approxOneThird + deltaOneThird);
- coef[i] = (mult_high >> 1);
- }
- } /* if(x) */
-
- x = quantSpec[i-1];
- if (x)
- {
- absX = pv_abs(x);
- if (absX < TABLESIZE)
- {
- mult_high = x * (inverseQuantTable[absX] >> shift);
- coef[i-1] = (mult_high >> 1);
- } /* end if (absX < TABLESIZE) */
- else
- {
- index = absX >> ORDER;
- w1 = inverseQuantTable[index];
- w2 = inverseQuantTable[index+1];
- approxOneThird = (w1 * FACTOR) >> shift;
- x1 = index << ORDER;
- deltaOneThird = (w2 - w1) * (absX - x1);
- deltaOneThird >>= (shift + 2);
- mult_high = x * (approxOneThird + deltaOneThird);
- coef[i-1] = (mult_high >> 1);
- }
- } /* if(x) */
-
- x = quantSpec[i-2];
- if (x)
- {
- absX = pv_abs(x);
- if (absX < TABLESIZE)
- {
- mult_high = x * (inverseQuantTable[absX] >> shift);
- coef[i-2] = (mult_high >> 1);
- } /* end if (absX < TABLESIZE) */
- else
- {
- index = absX >> ORDER;
- w1 = inverseQuantTable[index];
- w2 = inverseQuantTable[index+1];
- approxOneThird = (w1 * FACTOR) >> shift;
- x1 = index << ORDER;
- deltaOneThird = (w2 - w1) * (absX - x1);
- deltaOneThird >>= (shift + 2);
- mult_high = x * (approxOneThird + deltaOneThird);
- coef[i-2] = (mult_high >> 1);
- }
- } /* if(x) */
-
- x = quantSpec[i-3];
- if (x)
- {
- absX = pv_abs(x);
- if (absX < TABLESIZE)
- {
- mult_high = x * (inverseQuantTable[absX] >> shift);
- coef[i-3] = (mult_high >> 1);
- } /* end if (absX < TABLESIZE) */
- else
- {
- index = absX >> ORDER;
- w1 = inverseQuantTable[index];
- w2 = inverseQuantTable[index+1];
- approxOneThird = (w1 * FACTOR) >> shift;
- x1 = index << ORDER;
- deltaOneThird = (w2 - w1) * (absX - x1);
- deltaOneThird >>= (shift + 2);
- mult_high = x * (approxOneThird + deltaOneThird);
- coef[i-3] = (mult_high >> 1);
- }
-
- } /* if(x) */
-
- } /* end for (i = sfbWidth - 1; i >= 0; i--) */
-
- } /* end else for if (maxInput < TABLESIZE)*/
-
- } /* end else for if(scale!=0) */
-
- } /* end else for if(maxInput == 0) */
-
-} /* end esc_iquant_fxp */
-
-
generated by cgit v1.1 at 2024-06-11 04:09:30 +0000