/* -----------------------------------------------------------------------------
|
Software License for The Fraunhofer FDK AAC Codec Library for Android
|
|
© Copyright 1995 - 2018 Fraunhofer-Gesellschaft zur Förderung der angewandten
|
Forschung e.V. All rights reserved.
|
|
1. INTRODUCTION
|
The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software
|
that implements the MPEG Advanced Audio Coding ("AAC") encoding and decoding
|
scheme for digital audio. This FDK AAC Codec software is intended to be used on
|
a wide variety of Android devices.
|
|
AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient
|
general perceptual audio codecs. AAC-ELD is considered the best-performing
|
full-bandwidth communications codec by independent studies and is widely
|
deployed. AAC has been standardized by ISO and IEC as part of the MPEG
|
specifications.
|
|
Patent licenses for necessary patent claims for the FDK AAC Codec (including
|
those of Fraunhofer) may be obtained through Via Licensing
|
(www.vialicensing.com) or through the respective patent owners individually for
|
the purpose of encoding or decoding bit streams in products that are compliant
|
with the ISO/IEC MPEG audio standards. Please note that most manufacturers of
|
Android devices already license these patent claims through Via Licensing or
|
directly from the patent owners, and therefore FDK AAC Codec software may
|
already be covered under those patent licenses when it is used for those
|
licensed purposes only.
|
|
Commercially-licensed AAC software libraries, including floating-point versions
|
with enhanced sound quality, are also available from Fraunhofer. Users are
|
encouraged to check the Fraunhofer website for additional applications
|
information and documentation.
|
|
2. COPYRIGHT LICENSE
|
|
Redistribution and use in source and binary forms, with or without modification,
|
are permitted without payment of copyright license fees provided that you
|
satisfy the following conditions:
|
|
You must retain the complete text of this software license in redistributions of
|
the FDK AAC Codec or your modifications thereto in source code form.
|
|
You must retain the complete text of this software license in the documentation
|
and/or other materials provided with redistributions of the FDK AAC Codec or
|
your modifications thereto in binary form. You must make available free of
|
charge copies of the complete source code of the FDK AAC Codec and your
|
modifications thereto to recipients of copies in binary form.
|
|
The name of Fraunhofer may not be used to endorse or promote products derived
|
from this library without prior written permission.
|
|
You may not charge copyright license fees for anyone to use, copy or distribute
|
the FDK AAC Codec software or your modifications thereto.
|
|
Your modified versions of the FDK AAC Codec must carry prominent notices stating
|
that you changed the software and the date of any change. For modified versions
|
of the FDK AAC Codec, the term "Fraunhofer FDK AAC Codec Library for Android"
|
must be replaced by the term "Third-Party Modified Version of the Fraunhofer FDK
|
AAC Codec Library for Android."
|
|
3. NO PATENT LICENSE
|
|
NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without
|
limitation the patents of Fraunhofer, ARE GRANTED BY THIS SOFTWARE LICENSE.
|
Fraunhofer provides no warranty of patent non-infringement with respect to this
|
software.
|
|
You may use this FDK AAC Codec software or modifications thereto only for
|
purposes that are authorized by appropriate patent licenses.
|
|
4. DISCLAIMER
|
|
This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright
|
holders and contributors "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES,
|
including but not limited to the implied warranties of merchantability and
|
fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary,
|
or consequential damages, including but not limited to procurement of substitute
|
goods or services; loss of use, data, or profits, or business interruption,
|
however caused and on any theory of liability, whether in contract, strict
|
liability, or tort (including negligence), arising in any way out of the use of
|
this software, even if advised of the possibility of such damage.
|
|
5. CONTACT INFORMATION
|
|
Fraunhofer Institute for Integrated Circuits IIS
|
Attention: Audio and Multimedia Departments - FDK AAC LL
|
Am Wolfsmantel 33
|
91058 Erlangen, Germany
|
|
www.iis.fraunhofer.de/amm
|
amm-info@iis.fraunhofer.de
|
----------------------------------------------------------------------------- */
|
|
/**************************** SBR decoder library ******************************
|
|
Author(s):
|
|
Description:
|
|
*******************************************************************************/
|
|
/*!
|
\file
|
\brief Fast FFT routines prototypes
|
\author Fabian Haussel
|
*/
|
|
#include "hbe.h"
|
#include "qmf.h"
|
#include "env_extr.h"
|
|
#define HBE_MAX_QMF_BANDS (40)
|
|
#define HBE_MAX_OUT_SLOTS (11)
|
|
#define QMF_WIN_LEN \
|
(12 + 6 - 4 - 1) /* 6 subband slots extra delay to align with HQ - 4 slots \
|
to compensate for critical sampling delay - 1 slot to \
|
align critical sampling exactly (w additional time \
|
domain delay)*/
|
|
#ifndef PI
|
#define PI 3.14159265358979323846
|
#endif
|
|
static const int xProducts[MAX_STRETCH_HBE - 1] = {
|
1, 1, 1}; /* Cross products on(1)/off(0) for T=2,3,4. */
|
static const int startSubband2kL[33] = {
|
0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 4, 4, 4, 4, 4, 6, 6,
|
6, 8, 8, 8, 8, 8, 10, 10, 10, 12, 12, 12, 12, 12, 12, 12};
|
|
static const int pmin = 12;
|
|
static const FIXP_DBL hintReal_F[4][3] = {
|
{FL2FXCONST_DBL(0.39840335f), FL2FXCONST_DBL(0.39840335f),
|
FL2FXCONST_DBL(-0.39840335f)},
|
{FL2FXCONST_DBL(0.39840335f), FL2FXCONST_DBL(-0.39840335f),
|
FL2FXCONST_DBL(-0.39840335f)},
|
{FL2FXCONST_DBL(-0.39840335f), FL2FXCONST_DBL(-0.39840335f),
|
FL2FXCONST_DBL(0.39840335f)},
|
{FL2FXCONST_DBL(-0.39840335f), FL2FXCONST_DBL(0.39840335f),
|
FL2FXCONST_DBL(0.39840335f)}};
|
|
static const FIXP_DBL factors[4] = {
|
FL2FXCONST_DBL(0.39840335f), FL2FXCONST_DBL(-0.39840335f),
|
FL2FXCONST_DBL(-0.39840335f), FL2FXCONST_DBL(0.39840335f)};
|
|
#define PSCALE 32
|
|
static const FIXP_DBL p_F[128] = {FL2FXCONST_DBL(0.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(1.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(2.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(3.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(4.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(5.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(6.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(7.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(8.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(9.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(10.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(11.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(12.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(13.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(14.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(15.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(16.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(17.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(18.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(19.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(20.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(21.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(22.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(23.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(24.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(25.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(26.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(27.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(28.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(29.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(30.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(31.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(32.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(33.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(34.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(35.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(36.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(37.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(38.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(39.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(40.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(41.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(42.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(43.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(44.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(45.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(46.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(47.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(48.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(49.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(50.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(51.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(52.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(53.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(54.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(55.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(56.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(57.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(58.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(59.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(60.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(61.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(62.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(63.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(64.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(65.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(66.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(67.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(68.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(69.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(70.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(71.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(72.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(73.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(74.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(75.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(76.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(77.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(78.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(79.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(80.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(81.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(82.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(83.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(84.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(85.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(86.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(87.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(88.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(89.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(90.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(91.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(92.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(93.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(94.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(95.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(96.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(97.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(98.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(99.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(100.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(101.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(102.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(103.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(104.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(105.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(106.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(107.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(108.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(109.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(110.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(111.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(112.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(113.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(114.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(115.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(116.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(117.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(118.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(119.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(120.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(121.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(122.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(123.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(124.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(125.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(126.f / (PSCALE * 12.f)),
|
FL2FXCONST_DBL(127.f / (PSCALE * 12.f))};
|
|
static const FIXP_DBL band_F[64] = {
|
FL2FXCONST_DBL((0.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((1.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((2.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((3.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((4.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((5.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((6.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((7.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((8.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((9.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((10.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((11.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((12.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((13.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((14.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((15.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((16.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((17.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((18.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((19.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((20.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((21.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((22.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((23.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((24.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((25.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((26.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((27.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((28.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((29.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((30.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((31.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((32.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((33.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((34.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((35.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((36.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((37.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((38.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((39.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((40.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((41.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((42.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((43.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((44.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((45.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((46.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((47.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((48.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((49.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((50.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((51.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((52.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((53.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((54.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((55.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((56.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((57.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((58.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((59.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((60.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((61.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((62.f * 2.f + 1) / (PSCALE << 2)),
|
FL2FXCONST_DBL((63.f * 2.f + 1) / (PSCALE << 2))};
|
|
static const FIXP_DBL tr_str[3] = {FL2FXCONST_DBL(1.f / 4.f),
|
FL2FXCONST_DBL(2.f / 4.f),
|
FL2FXCONST_DBL(3.f / 4.f)};
|
|
static const FIXP_DBL stretchfac[3] = {FL2FXCONST_DBL(1.f / 2.f),
|
FL2FXCONST_DBL(1.f / 3.f),
|
FL2FXCONST_DBL(1.f / 4.f)};
|
|
static const FIXP_DBL cos_F[64] = {
|
26353028, -79043208, 131685776, -184244944, 236697216, -289006912,
|
341142496, -393072608, 444773984, -496191392, 547325824, -598114752,
|
648559104, -698597248, 748230016, -797411904, 846083200, -894275136,
|
941928192, -989013760, 1035474624, -1081340672, 1126555136, -1171063296,
|
1214893696, -1257992192, 1300332544, -1341889408, 1382612736, -1422503808,
|
1461586944, -1499741440, 1537039104, -1573364864, 1608743808, -1643196672,
|
1676617344, -1709028992, 1740450560, -1770784896, 1800089472, -1828273536,
|
1855357440, -1881356288, 1906190080, -1929876608, 1952428928, -1973777664,
|
1993962880, -2012922240, 2030670208, -2047216000, 2062508288, -2076559488,
|
2089376128, -2100932224, 2111196800, -2120214784, 2127953792, -2134394368,
|
2139565056, -2143444864, 2146026624, -2147321856};
|
|
static const FIXP_DBL twiddle[121] = {1073741824,
|
1071442860,
|
1064555814,
|
1053110176,
|
1037154959,
|
1016758484,
|
992008094,
|
963009773,
|
929887697,
|
892783698,
|
851856663,
|
807281846,
|
759250125,
|
707967178,
|
653652607,
|
596538995,
|
536870912,
|
474903865,
|
410903207,
|
345142998,
|
277904834,
|
209476638,
|
140151432,
|
70226075,
|
0,
|
-70226075,
|
-140151432,
|
-209476638,
|
-277904834,
|
-345142998,
|
-410903207,
|
-474903865,
|
-536870912,
|
-596538995,
|
-653652607,
|
-707967178,
|
-759250125,
|
-807281846,
|
-851856663,
|
-892783698,
|
-929887697,
|
-963009773,
|
-992008094,
|
-1016758484,
|
-1037154959,
|
-1053110176,
|
-1064555814,
|
-1071442860,
|
-1073741824,
|
-1071442860,
|
-1064555814,
|
-1053110176,
|
-1037154959,
|
-1016758484,
|
-992008094,
|
-963009773,
|
-929887697,
|
-892783698,
|
-851856663,
|
-807281846,
|
-759250125,
|
-707967178,
|
-653652607,
|
-596538995,
|
-536870912,
|
-474903865,
|
-410903207,
|
-345142998,
|
-277904834,
|
-209476638,
|
-140151432,
|
-70226075,
|
0,
|
70226075,
|
140151432,
|
209476638,
|
277904834,
|
345142998,
|
410903207,
|
474903865,
|
536870912,
|
596538995,
|
653652607,
|
707967178,
|
759250125,
|
807281846,
|
851856663,
|
892783698,
|
929887697,
|
963009773,
|
992008094,
|
1016758484,
|
1037154959,
|
1053110176,
|
1064555814,
|
1071442860,
|
1073741824,
|
1071442860,
|
1064555814,
|
1053110176,
|
1037154959,
|
1016758484,
|
992008094,
|
963009773,
|
929887697,
|
892783698,
|
851856663,
|
807281846,
|
759250125,
|
707967178,
|
653652607,
|
596538995,
|
536870912,
|
474903865,
|
410903207,
|
345142998,
|
277904834,
|
209476638,
|
140151432,
|
70226075,
|
0};
|
|
#if FIXP_QTW == FIXP_SGL
|
#define HTW(x) (x)
|
#else
|
#define HTW(x) FX_DBL2FX_QTW(FX_SGL2FX_DBL((const FIXP_SGL)x))
|
#endif
|
|
static const FIXP_QTW post_twiddle_cos_8[8] = {
|
HTW(-1606), HTW(4756), HTW(-7723), HTW(10394),
|
HTW(-12665), HTW(14449), HTW(-15679), HTW(16305)};
|
|
static const FIXP_QTW post_twiddle_cos_16[16] = {
|
HTW(-804), HTW(2404), HTW(-3981), HTW(5520), HTW(-7005), HTW(8423),
|
HTW(-9760), HTW(11003), HTW(-12140), HTW(13160), HTW(-14053), HTW(14811),
|
HTW(-15426), HTW(15893), HTW(-16207), HTW(16364)};
|
|
static const FIXP_QTW post_twiddle_cos_24[24] = {
|
HTW(-536), HTW(1606), HTW(-2669), HTW(3720), HTW(-4756), HTW(5771),
|
HTW(-6762), HTW(7723), HTW(-8652), HTW(9543), HTW(-10394), HTW(11200),
|
HTW(-11958), HTW(12665), HTW(-13318), HTW(13913), HTW(-14449), HTW(14924),
|
HTW(-15334), HTW(15679), HTW(-15956), HTW(16165), HTW(-16305), HTW(16375)};
|
|
static const FIXP_QTW post_twiddle_cos_32[32] = {
|
HTW(-402), HTW(1205), HTW(-2006), HTW(2801), HTW(-3590), HTW(4370),
|
HTW(-5139), HTW(5897), HTW(-6639), HTW(7366), HTW(-8076), HTW(8765),
|
HTW(-9434), HTW(10080), HTW(-10702), HTW(11297), HTW(-11866), HTW(12406),
|
HTW(-12916), HTW(13395), HTW(-13842), HTW(14256), HTW(-14635), HTW(14978),
|
HTW(-15286), HTW(15557), HTW(-15791), HTW(15986), HTW(-16143), HTW(16261),
|
HTW(-16340), HTW(16379)};
|
|
static const FIXP_QTW post_twiddle_cos_40[40] = {
|
HTW(-322), HTW(965), HTW(-1606), HTW(2245), HTW(-2880), HTW(3511),
|
HTW(-4137), HTW(4756), HTW(-5368), HTW(5971), HTW(-6566), HTW(7150),
|
HTW(-7723), HTW(8285), HTW(-8833), HTW(9368), HTW(-9889), HTW(10394),
|
HTW(-10883), HTW(11356), HTW(-11810), HTW(12247), HTW(-12665), HTW(13063),
|
HTW(-13441), HTW(13799), HTW(-14135), HTW(14449), HTW(-14741), HTW(15011),
|
HTW(-15257), HTW(15480), HTW(-15679), HTW(15853), HTW(-16003), HTW(16129),
|
HTW(-16229), HTW(16305), HTW(-16356), HTW(16381)};
|
|
static const FIXP_QTW post_twiddle_sin_8[8] = {
|
HTW(16305), HTW(-15679), HTW(14449), HTW(-12665),
|
HTW(10394), HTW(-7723), HTW(4756), HTW(-1606)};
|
|
static const FIXP_QTW post_twiddle_sin_16[16] = {
|
HTW(16364), HTW(-16207), HTW(15893), HTW(-15426), HTW(14811), HTW(-14053),
|
HTW(13160), HTW(-12140), HTW(11003), HTW(-9760), HTW(8423), HTW(-7005),
|
HTW(5520), HTW(-3981), HTW(2404), HTW(-804)};
|
|
static const FIXP_QTW post_twiddle_sin_24[24] = {
|
HTW(16375), HTW(-16305), HTW(16165), HTW(-15956), HTW(15679), HTW(-15334),
|
HTW(14924), HTW(-14449), HTW(13913), HTW(-13318), HTW(12665), HTW(-11958),
|
HTW(11200), HTW(-10394), HTW(9543), HTW(-8652), HTW(7723), HTW(-6762),
|
HTW(5771), HTW(-4756), HTW(3720), HTW(-2669), HTW(1606), HTW(-536)};
|
|
static const FIXP_QTW post_twiddle_sin_32[32] = {
|
HTW(16379), HTW(-16340), HTW(16261), HTW(-16143), HTW(15986), HTW(-15791),
|
HTW(15557), HTW(-15286), HTW(14978), HTW(-14635), HTW(14256), HTW(-13842),
|
HTW(13395), HTW(-12916), HTW(12406), HTW(-11866), HTW(11297), HTW(-10702),
|
HTW(10080), HTW(-9434), HTW(8765), HTW(-8076), HTW(7366), HTW(-6639),
|
HTW(5897), HTW(-5139), HTW(4370), HTW(-3590), HTW(2801), HTW(-2006),
|
HTW(1205), HTW(-402)};
|
|
static const FIXP_QTW post_twiddle_sin_40[40] = {
|
HTW(16381), HTW(-16356), HTW(16305), HTW(-16229), HTW(16129), HTW(-16003),
|
HTW(15853), HTW(-15679), HTW(15480), HTW(-15257), HTW(15011), HTW(-14741),
|
HTW(14449), HTW(-14135), HTW(13799), HTW(-13441), HTW(13063), HTW(-12665),
|
HTW(12247), HTW(-11810), HTW(11356), HTW(-10883), HTW(10394), HTW(-9889),
|
HTW(9368), HTW(-8833), HTW(8285), HTW(-7723), HTW(7150), HTW(-6566),
|
HTW(5971), HTW(-5368), HTW(4756), HTW(-4137), HTW(3511), HTW(-2880),
|
HTW(2245), HTW(-1606), HTW(965), HTW(-322)};
|
|
static const FIXP_DBL preModCos[32] = {
|
-749875776, 786681536, 711263552, -821592064, -670937792, 854523392,
|
628995648, -885396032, -585538240, 914135680, 540670208, -940673088,
|
-494499680, 964944384, 447137824, -986891008, -398698816, 1006460096,
|
349299264, -1023604544, -299058240, 1038283072, 248096752, -1050460288,
|
-196537584, 1060106816, 144504928, -1067199488, -92124160, 1071721152,
|
39521456, -1073660992};
|
|
static const FIXP_DBL preModSin[32] = {
|
768510144, 730789760, -804379072, -691308864, 838310208, 650162560,
|
-870221760, -607449920, 900036928, 563273856, -927683776, -517740896,
|
953095808, 470960608, -976211712, -423045728, 996975808, 374111712,
|
-1015338112, -324276416, 1031254400, 273659904, -1044686336, -222384144,
|
1055601472, 170572640, -1063973632, -118350192, 1069782528, 65842640,
|
-1073014208, -13176464};
|
|
/* The cube root function */
|
/*****************************************************************************
|
|
functionname: invCubeRootNorm2
|
description: delivers 1/cuberoot(op) in Q1.31 format and modified exponent
|
|
*****************************************************************************/
|
#define CUBE_ROOT_BITS 7
|
#define CUBE_ROOT_VALUES (128 + 2)
|
#define CUBE_ROOT_BITS_MASK 0x7f
|
#define CUBE_ROOT_FRACT_BITS_MASK 0x007FFFFF
|
/* Inverse cube root table for operands running from 0.5 to 1.0 */
|
/* (INT) (1.0/cuberoot((op))); */
|
/* Implicit exponent is 1. */
|
|
LNK_SECTION_CONSTDATA
|
static const FIXP_DBL invCubeRootTab[CUBE_ROOT_VALUES] = {
|
(0x50a28be6), (0x506d1172), (0x503823c4), (0x5003c05a), (0x4fcfe4c0),
|
(0x4f9c8e92), (0x4f69bb7d), (0x4f37693b), (0x4f059594), (0x4ed43e5f),
|
(0x4ea36181), (0x4e72fcea), (0x4e430e98), (0x4e139495), (0x4de48cf5),
|
(0x4db5f5db), (0x4d87cd73), (0x4d5a11f2), (0x4d2cc19c), (0x4cffdabb),
|
(0x4cd35ba4), (0x4ca742b7), (0x4c7b8e5c), (0x4c503d05), (0x4c254d2a),
|
(0x4bfabd50), (0x4bd08c00), (0x4ba6b7cd), (0x4b7d3f53), (0x4b542134),
|
(0x4b2b5c18), (0x4b02eeb1), (0x4adad7b8), (0x4ab315ea), (0x4a8ba80d),
|
(0x4a648cec), (0x4a3dc35b), (0x4a174a30), (0x49f1204a), (0x49cb448d),
|
(0x49a5b5e2), (0x49807339), (0x495b7b86), (0x4936cdc2), (0x491268ec),
|
(0x48ee4c08), (0x48ca761f), (0x48a6e63e), (0x48839b76), (0x486094de),
|
(0x483dd190), (0x481b50ad), (0x47f91156), (0x47d712b3), (0x47b553f0),
|
(0x4793d43c), (0x477292c9), (0x47518ece), (0x4730c785), (0x47103c2d),
|
(0x46efec06), (0x46cfd655), (0x46affa61), (0x46905777), (0x4670ece4),
|
(0x4651b9f9), (0x4632be0b), (0x4613f871), (0x45f56885), (0x45d70da5),
|
(0x45b8e72f), (0x459af487), (0x457d3511), (0x455fa835), (0x45424d5d),
|
(0x452523f6), (0x45082b6e), (0x44eb6337), (0x44cecac5), (0x44b2618d),
|
(0x44962708), (0x447a1ab1), (0x445e3c02), (0x44428a7c), (0x4427059e),
|
(0x440bacec), (0x43f07fe9), (0x43d57e1c), (0x43baa70e), (0x439ffa48),
|
(0x43857757), (0x436b1dc8), (0x4350ed2b), (0x4336e511), (0x431d050c),
|
(0x43034cb2), (0x42e9bb98), (0x42d05156), (0x42b70d85), (0x429defc0),
|
(0x4284f7a2), (0x426c24cb), (0x425376d8), (0x423aed6a), (0x42228823),
|
(0x420a46a6), (0x41f22898), (0x41da2d9f), (0x41c25561), (0x41aa9f86),
|
(0x41930bba), (0x417b99a5), (0x416448f5), (0x414d1956), (0x41360a76),
|
(0x411f1c06), (0x41084db5), (0x40f19f35), (0x40db1039), (0x40c4a074),
|
(0x40ae4f9b), (0x40981d64), (0x40820985), (0x406c13b6), (0x40563bb1),
|
(0x4040812e), (0x402ae3e7), (0x40156399), (0x40000000), (0x3FEAB8D9)};
|
/* n.a. */
|
static const FIXP_DBL invCubeRootCorrection[3] = {0x40000000, 0x50A28BE6,
|
0x6597FA95};
|
|
/*****************************************************************************
|
* \brief calculate 1.0/cube_root(op), op contains mantissa and exponent
|
* \param op_m: (i) mantissa of operand, must not be zero (0x0000.0000) or
|
* negative
|
* \param op_e: (i) pointer to the exponent of the operand (must be initialized)
|
* and .. (o) pointer to the exponent of the result
|
* \return: (o) mantissa of the result
|
* \description:
|
* This routine calculates the cube root of the input operand, that is
|
* given with its mantissa in Q31 format (FIXP_DBL) and its exponent (INT).
|
* The resulting mantissa is returned in format Q31. The exponent (*op_e)
|
* is modified accordingly. It is not assured, that the result is fully
|
* left-aligned but assumed to have not more than 2 bits headroom. There is one
|
* macro to activate the use of this algorithm: FUNCTION_invCubeRootNorm2 By
|
* means of activating the macro INVCUBEROOTNORM2_LINEAR_INTERPOLATE_HQ, a
|
* slightly higher precision is reachable (by default, not active). For DEBUG
|
* purpose only: a FDK_ASSERT macro validates, if the input mantissa is greater
|
* zero.
|
*
|
*/
|
static
|
#ifdef __arm__
|
FIXP_DBL __attribute__((always_inline))
|
invCubeRootNorm2(FIXP_DBL op_m, INT* op_e)
|
#else
|
FIXP_DBL
|
invCubeRootNorm2(FIXP_DBL op_m, INT* op_e)
|
#endif
|
{
|
FDK_ASSERT(op_m > FIXP_DBL(0));
|
|
/* normalize input, calculate shift value */
|
INT exponent = (INT)fNormz(op_m) - 1;
|
op_m <<= exponent;
|
|
INT index = (INT)(op_m >> (DFRACT_BITS - 1 - (CUBE_ROOT_BITS + 1))) &
|
CUBE_ROOT_BITS_MASK;
|
FIXP_DBL fract = (FIXP_DBL)(((INT)op_m & CUBE_ROOT_FRACT_BITS_MASK)
|
<< (CUBE_ROOT_BITS + 1));
|
FIXP_DBL diff = invCubeRootTab[index + 1] - invCubeRootTab[index];
|
op_m = fMultAddDiv2(invCubeRootTab[index], diff << 1, fract);
|
#if defined(INVCUBEROOTNORM2_LINEAR_INTERPOLATE_HQ)
|
/* reg1 = t[i] + (t[i+1]-t[i])*fract ... already computed ... +
|
* (1-fract)fract*(t[i+2]-t[i+1])/2 */
|
if (fract != (FIXP_DBL)0) {
|
/* fract = fract * (1 - fract) */
|
fract = fMultDiv2(fract, (FIXP_DBL)((LONG)0x80000000 - (LONG)fract)) << 1;
|
diff = diff - (invCubeRootTab[index + 2] - invCubeRootTab[index + 1]);
|
op_m = fMultAddDiv2(op_m, fract, diff);
|
}
|
#endif /* INVCUBEROOTNORM2_LINEAR_INTERPOLATE_HQ */
|
|
/* calculate the output exponent = input * exp/3 = cubicroot(m)*2^(exp/3)
|
* where 2^(exp/3) = 2^k'*2 or 2^k'*2^(1/3) or 2^k'*2^(2/3) */
|
exponent = exponent - *op_e + 3;
|
INT shift_tmp =
|
((INT)fMultDiv2((FIXP_SGL)fAbs(exponent), (FIXP_SGL)0x5556)) >> 16;
|
if (exponent < 0) {
|
shift_tmp = -shift_tmp;
|
}
|
INT rem = exponent - 3 * shift_tmp;
|
if (rem < 0) {
|
rem += 3;
|
shift_tmp--;
|
}
|
|
*op_e = shift_tmp;
|
op_m = fMultDiv2(op_m, invCubeRootCorrection[rem]) << 2;
|
|
return (op_m);
|
}
|
|
/*****************************************************************************
|
|
functionname: invFourthRootNorm2
|
description: delivers 1/FourthRoot(op) in Q1.31 format and modified
|
exponent
|
|
*****************************************************************************/
|
|
#define FOURTHROOT_BITS 7
|
#define FOURTHROOT_VALUES (128 + 2)
|
#define FOURTHROOT_BITS_MASK 0x7f
|
#define FOURTHROOT_FRACT_BITS_MASK 0x007FFFFF
|
|
LNK_SECTION_CONSTDATA
|
static const FIXP_DBL invFourthRootTab[FOURTHROOT_VALUES] = {
|
(0x4c1bf829), (0x4bf61977), (0x4bd09843), (0x4bab72ef), (0x4b86a7eb),
|
(0x4b6235ac), (0x4b3e1ab6), (0x4b1a5592), (0x4af6e4d4), (0x4ad3c718),
|
(0x4ab0fb03), (0x4a8e7f42), (0x4a6c5288), (0x4a4a7393), (0x4a28e126),
|
(0x4a079a0c), (0x49e69d16), (0x49c5e91f), (0x49a57d04), (0x498557ac),
|
(0x49657802), (0x4945dcf9), (0x49268588), (0x490770ac), (0x48e89d6a),
|
(0x48ca0ac9), (0x48abb7d6), (0x488da3a6), (0x486fcd4f), (0x485233ed),
|
(0x4834d6a3), (0x4817b496), (0x47faccf0), (0x47de1ee0), (0x47c1a999),
|
(0x47a56c51), (0x47896643), (0x476d96af), (0x4751fcd6), (0x473697ff),
|
(0x471b6773), (0x47006a81), (0x46e5a079), (0x46cb08ae), (0x46b0a279),
|
(0x46966d34), (0x467c683d), (0x466292f4), (0x4648ecbc), (0x462f74fe),
|
(0x46162b20), (0x45fd0e91), (0x45e41ebe), (0x45cb5b19), (0x45b2c315),
|
(0x459a562a), (0x458213cf), (0x4569fb81), (0x45520cbc), (0x453a4701),
|
(0x4522a9d1), (0x450b34b0), (0x44f3e726), (0x44dcc0ba), (0x44c5c0f7),
|
(0x44aee768), (0x4498339e), (0x4481a527), (0x446b3b96), (0x4454f67e),
|
(0x443ed576), (0x4428d815), (0x4412fdf3), (0x43fd46ad), (0x43e7b1de),
|
(0x43d23f23), (0x43bcee1e), (0x43a7be6f), (0x4392afb8), (0x437dc19d),
|
(0x4368f3c5), (0x435445d6), (0x433fb779), (0x432b4856), (0x4316f81a),
|
(0x4302c66f), (0x42eeb305), (0x42dabd8a), (0x42c6e5ad), (0x42b32b21),
|
(0x429f8d96), (0x428c0cc2), (0x4278a859), (0x42656010), (0x4252339e),
|
(0x423f22bc), (0x422c2d23), (0x4219528b), (0x420692b2), (0x41f3ed51),
|
(0x41e16228), (0x41cef0f2), (0x41bc9971), (0x41aa5b62), (0x41983687),
|
(0x41862aa2), (0x41743775), (0x41625cc3), (0x41509a50), (0x413eefe2),
|
(0x412d5d3e), (0x411be22b), (0x410a7e70), (0x40f931d5), (0x40e7fc23),
|
(0x40d6dd24), (0x40c5d4a2), (0x40b4e268), (0x40a40642), (0x40933ffc),
|
(0x40828f64), (0x4071f447), (0x40616e73), (0x4050fdb9), (0x4040a1e6),
|
(0x40305acc), (0x4020283c), (0x40100a08), (0x40000000), (0x3ff009f9),
|
};
|
|
static const FIXP_DBL invFourthRootCorrection[4] = {0x40000000, 0x4C1BF829,
|
0x5A82799A, 0x6BA27E65};
|
|
/* The fourth root function */
|
/*****************************************************************************
|
* \brief calculate 1.0/fourth_root(op), op contains mantissa and exponent
|
* \param op_m: (i) mantissa of operand, must not be zero (0x0000.0000) or
|
* negative
|
* \param op_e: (i) pointer to the exponent of the operand (must be initialized)
|
* and .. (o) pointer to the exponent of the result
|
* \return: (o) mantissa of the result
|
* \description:
|
* This routine calculates the cube root of the input operand, that is
|
* given with its mantissa in Q31 format (FIXP_DBL) and its exponent (INT).
|
* The resulting mantissa is returned in format Q31. The exponent (*op_e)
|
* is modified accordingly. It is not assured, that the result is fully
|
* left-aligned but assumed to have not more than 2 bits headroom. There is one
|
* macro to activate the use of this algorithm: FUNCTION_invFourthRootNorm2 By
|
* means of activating the macro INVFOURTHROOTNORM2_LINEAR_INTERPOLATE_HQ, a
|
* slightly higher precision is reachable (by default, not active). For DEBUG
|
* purpose only: a FDK_ASSERT macro validates, if the input mantissa is greater
|
* zero.
|
*
|
*/
|
|
/* #define INVFOURTHROOTNORM2_LINEAR_INTERPOLATE_HQ */
|
|
static
|
#ifdef __arm__
|
FIXP_DBL __attribute__((always_inline))
|
invFourthRootNorm2(FIXP_DBL op_m, INT* op_e)
|
#else
|
FIXP_DBL
|
invFourthRootNorm2(FIXP_DBL op_m, INT* op_e)
|
#endif
|
{
|
FDK_ASSERT(op_m > FL2FXCONST_DBL(0.0));
|
|
/* normalize input, calculate shift value */
|
INT exponent = (INT)fNormz(op_m) - 1;
|
op_m <<= exponent;
|
|
INT index = (INT)(op_m >> (DFRACT_BITS - 1 - (FOURTHROOT_BITS + 1))) &
|
FOURTHROOT_BITS_MASK;
|
FIXP_DBL fract = (FIXP_DBL)(((INT)op_m & FOURTHROOT_FRACT_BITS_MASK)
|
<< (FOURTHROOT_BITS + 1));
|
FIXP_DBL diff = invFourthRootTab[index + 1] - invFourthRootTab[index];
|
op_m = invFourthRootTab[index] + (fMultDiv2(diff, fract) << 1);
|
|
#if defined(INVFOURTHROOTNORM2_LINEAR_INTERPOLATE_HQ)
|
/* reg1 = t[i] + (t[i+1]-t[i])*fract ... already computed ... +
|
* (1-fract)fract*(t[i+2]-t[i+1])/2 */
|
if (fract != (FIXP_DBL)0) {
|
/* fract = fract * (1 - fract) */
|
fract = fMultDiv2(fract, (FIXP_DBL)((LONG)0x80000000 - (LONG)fract)) << 1;
|
diff = diff - (invFourthRootTab[index + 2] - invFourthRootTab[index + 1]);
|
op_m = fMultAddDiv2(op_m, fract, diff);
|
}
|
#endif /* INVFOURTHROOTNORM2_LINEAR_INTERPOLATE_HQ */
|
|
exponent = exponent - *op_e + 4;
|
INT rem = exponent & 0x00000003;
|
INT shift_tmp = (exponent >> 2);
|
|
*op_e = shift_tmp;
|
op_m = fMultDiv2(op_m, invFourthRootCorrection[rem]) << 2;
|
|
return (op_m);
|
}
|
|
/*****************************************************************************
|
|
functionname: inv3EigthRootNorm2
|
description: delivers 1/cubert(op) normalized to .5...1 and the shift value
|
of the OUTPUT
|
|
*****************************************************************************/
|
#define THREEIGTHROOT_BITS 7
|
#define THREEIGTHROOT_VALUES (128 + 2)
|
#define THREEIGTHROOT_BITS_MASK 0x7f
|
#define THREEIGTHROOT_FRACT_BITS_MASK 0x007FFFFF
|
|
LNK_SECTION_CONSTDATA
|
static const FIXP_DBL inv3EigthRootTab[THREEIGTHROOT_VALUES] = {
|
(0x45cae0f2), (0x45b981bf), (0x45a8492a), (0x45973691), (0x45864959),
|
(0x457580e6), (0x4564dca4), (0x45545c00), (0x4543fe6b), (0x4533c35a),
|
(0x4523aa44), (0x4513b2a4), (0x4503dbf7), (0x44f425be), (0x44e48f7b),
|
(0x44d518b6), (0x44c5c0f7), (0x44b687c8), (0x44a76cb8), (0x44986f58),
|
(0x44898f38), (0x447acbef), (0x446c2514), (0x445d9a3f), (0x444f2b0d),
|
(0x4440d71a), (0x44329e07), (0x44247f73), (0x44167b04), (0x4408905e),
|
(0x43fabf28), (0x43ed070b), (0x43df67b0), (0x43d1e0c5), (0x43c471f7),
|
(0x43b71af6), (0x43a9db71), (0x439cb31c), (0x438fa1ab), (0x4382a6d2),
|
(0x4375c248), (0x4368f3c5), (0x435c3b03), (0x434f97bc), (0x434309ac),
|
(0x43369091), (0x432a2c28), (0x431ddc30), (0x4311a06c), (0x4305789c),
|
(0x42f96483), (0x42ed63e5), (0x42e17688), (0x42d59c30), (0x42c9d4a6),
|
(0x42be1fb1), (0x42b27d1a), (0x42a6ecac), (0x429b6e2f), (0x42900172),
|
(0x4284a63f), (0x42795c64), (0x426e23b0), (0x4262fbf2), (0x4257e4f9),
|
(0x424cde96), (0x4241e89a), (0x423702d8), (0x422c2d23), (0x4221674d),
|
(0x4216b12c), (0x420c0a94), (0x4201735b), (0x41f6eb57), (0x41ec725f),
|
(0x41e2084b), (0x41d7acf3), (0x41cd6030), (0x41c321db), (0x41b8f1ce),
|
(0x41aecfe5), (0x41a4bbf8), (0x419ab5e6), (0x4190bd89), (0x4186d2bf),
|
(0x417cf565), (0x41732558), (0x41696277), (0x415faca1), (0x415603b4),
|
(0x414c6792), (0x4142d818), (0x4139552a), (0x412fdea6), (0x41267470),
|
(0x411d1668), (0x4113c472), (0x410a7e70), (0x41014445), (0x40f815d4),
|
(0x40eef302), (0x40e5dbb4), (0x40dccfcd), (0x40d3cf33), (0x40cad9cb),
|
(0x40c1ef7b), (0x40b9102a), (0x40b03bbd), (0x40a7721c), (0x409eb32e),
|
(0x4095feda), (0x408d5508), (0x4084b5a0), (0x407c208b), (0x407395b2),
|
(0x406b14fd), (0x40629e56), (0x405a31a6), (0x4051ced8), (0x404975d5),
|
(0x40412689), (0x4038e0dd), (0x4030a4bd), (0x40287215), (0x402048cf),
|
(0x401828d7), (0x4010121a), (0x40080483), (0x40000000), (0x3ff8047d),
|
};
|
|
/* The last value is rounded in order to avoid any overflow due to the values
|
* range of the root table */
|
static const FIXP_DBL inv3EigthRootCorrection[8] = {
|
0x40000000, 0x45CAE0F2, 0x4C1BF829, 0x52FF6B55,
|
0x5A82799A, 0x62B39509, 0x6BA27E65, 0x75606373};
|
|
/* The 3/8 root function */
|
/*****************************************************************************
|
* \brief calculate 1.0/3Eigth_root(op) = 1.0/(x)^(3/8), op contains mantissa
|
* and exponent
|
* \param op_m: (i) mantissa of operand, must not be zero (0x0000.0000) or
|
* negative
|
* \param op_e: (i) pointer to the exponent of the operand (must be initialized)
|
* and .. (o) pointer to the exponent of the result
|
* \return: (o) mantissa of the result
|
* \description:
|
* This routine calculates the cube root of the input operand, that is
|
* given with its mantissa in Q31 format (FIXP_DBL) and its exponent (INT).
|
* The resulting mantissa is returned in format Q31. The exponent (*op_e)
|
* is modified accordingly. It is not assured, that the result is fully
|
* left-aligned but assumed to have not more than 2 bits headroom. There is one
|
* macro to activate the use of this algorithm: FUNCTION_inv3EigthRootNorm2 By
|
* means of activating the macro INVTHREEIGTHROOTNORM2_LINEAR_INTERPOLATE_HQ, a
|
* slightly higher precision is reachable (by default, not active). For DEBUG
|
* purpose only: a FDK_ASSERT macro validates, if the input mantissa is greater
|
* zero.
|
*
|
*/
|
|
/* #define INVTHREEIGTHROOTNORM2_LINEAR_INTERPOLATE_HQ */
|
|
static
|
#ifdef __arm__
|
FIXP_DBL __attribute__((always_inline))
|
inv3EigthRootNorm2(FIXP_DBL op_m, INT* op_e)
|
#else
|
FIXP_DBL
|
inv3EigthRootNorm2(FIXP_DBL op_m, INT* op_e)
|
#endif
|
{
|
FDK_ASSERT(op_m > FL2FXCONST_DBL(0.0));
|
|
/* normalize input, calculate shift op_mue */
|
INT exponent = (INT)fNormz(op_m) - 1;
|
op_m <<= exponent;
|
|
INT index = (INT)(op_m >> (DFRACT_BITS - 1 - (THREEIGTHROOT_BITS + 1))) &
|
THREEIGTHROOT_BITS_MASK;
|
FIXP_DBL fract = (FIXP_DBL)(((INT)op_m & THREEIGTHROOT_FRACT_BITS_MASK)
|
<< (THREEIGTHROOT_BITS + 1));
|
FIXP_DBL diff = inv3EigthRootTab[index + 1] - inv3EigthRootTab[index];
|
op_m = inv3EigthRootTab[index] + (fMultDiv2(diff, fract) << 1);
|
|
#if defined(INVTHREEIGTHROOTNORM2_LINEAR_INTERPOLATE_HQ)
|
/* op_m = t[i] + (t[i+1]-t[i])*fract ... already computed ... +
|
* (1-fract)fract*(t[i+2]-t[i+1])/2 */
|
if (fract != (FIXP_DBL)0) {
|
/* fract = fract * (1 - fract) */
|
fract = fMultDiv2(fract, (FIXP_DBL)((LONG)0x80000000 - (LONG)fract)) << 1;
|
diff = diff - (inv3EigthRootTab[index + 2] - inv3EigthRootTab[index + 1]);
|
op_m = fMultAddDiv2(op_m, fract, diff);
|
}
|
#endif /* INVTHREEIGTHROOTNORM2_LINEAR_INTERPOLATE_HQ */
|
|
exponent = exponent - *op_e + 8;
|
INT rem = exponent & 0x00000007;
|
INT shift_tmp = (exponent >> 3);
|
|
*op_e = shift_tmp * 3;
|
op_m = fMultDiv2(op_m, inv3EigthRootCorrection[rem]) << 2;
|
|
return (fMult(op_m, fMult(op_m, op_m)));
|
}
|
|
SBR_ERROR
|
QmfTransposerCreate(HANDLE_HBE_TRANSPOSER* hQmfTransposer, const int frameSize,
|
int bDisableCrossProducts, int bSbr41) {
|
HANDLE_HBE_TRANSPOSER hQmfTran = NULL;
|
|
int i;
|
|
if (hQmfTransposer != NULL) {
|
/* Memory allocation */
|
/*--------------------------------------------------------------------------------------------*/
|
hQmfTran =
|
(HANDLE_HBE_TRANSPOSER)FDKcalloc(1, sizeof(struct hbeTransposer));
|
if (hQmfTran == NULL) {
|
return SBRDEC_MEM_ALLOC_FAILED;
|
}
|
|
for (i = 0; i < MAX_STRETCH_HBE - 1; i++) {
|
hQmfTran->bXProducts[i] = (bDisableCrossProducts ? 0 : xProducts[i]);
|
}
|
|
hQmfTran->timeDomainWinLen = frameSize;
|
if (frameSize == 768) {
|
hQmfTran->noCols =
|
(8 * frameSize / 3) / QMF_SYNTH_CHANNELS; /* 32 for 24:64 */
|
} else {
|
hQmfTran->noCols =
|
(bSbr41 + 1) * 2 * frameSize /
|
QMF_SYNTH_CHANNELS; /* 32 for 32:64 and 64 for 16:64 -> identical to
|
sbrdec->no_cols */
|
}
|
|
hQmfTran->noChannels = frameSize / hQmfTran->noCols;
|
|
hQmfTran->qmfInBufSize = QMF_WIN_LEN;
|
hQmfTran->qmfOutBufSize = 2 * (hQmfTran->noCols / 2 + QMF_WIN_LEN - 1);
|
|
hQmfTran->inBuf_F =
|
(INT_PCM*)FDKcalloc(QMF_SYNTH_CHANNELS + 20 + 1, sizeof(INT_PCM));
|
/* buffered time signal needs to be delayed by synthesis_size; max
|
* synthesis_size = 20; */
|
if (hQmfTran->inBuf_F == NULL) {
|
QmfTransposerClose(hQmfTran);
|
return SBRDEC_MEM_ALLOC_FAILED;
|
}
|
|
hQmfTran->qmfInBufReal_F =
|
(FIXP_DBL**)FDKcalloc(hQmfTran->qmfInBufSize, sizeof(FIXP_DBL*));
|
hQmfTran->qmfInBufImag_F =
|
(FIXP_DBL**)FDKcalloc(hQmfTran->qmfInBufSize, sizeof(FIXP_DBL*));
|
|
if (hQmfTran->qmfInBufReal_F == NULL) {
|
QmfTransposerClose(hQmfTran);
|
return SBRDEC_MEM_ALLOC_FAILED;
|
}
|
if (hQmfTran->qmfInBufImag_F == NULL) {
|
QmfTransposerClose(hQmfTran);
|
return SBRDEC_MEM_ALLOC_FAILED;
|
}
|
|
for (i = 0; i < hQmfTran->qmfInBufSize; i++) {
|
hQmfTran->qmfInBufReal_F[i] = (FIXP_DBL*)FDKaalloc(
|
QMF_SYNTH_CHANNELS * sizeof(FIXP_DBL), ALIGNMENT_DEFAULT);
|
hQmfTran->qmfInBufImag_F[i] = (FIXP_DBL*)FDKaalloc(
|
QMF_SYNTH_CHANNELS * sizeof(FIXP_DBL), ALIGNMENT_DEFAULT);
|
if (hQmfTran->qmfInBufReal_F[i] == NULL) {
|
QmfTransposerClose(hQmfTran);
|
return SBRDEC_MEM_ALLOC_FAILED;
|
}
|
if (hQmfTran->qmfInBufImag_F[i] == NULL) {
|
QmfTransposerClose(hQmfTran);
|
return SBRDEC_MEM_ALLOC_FAILED;
|
}
|
}
|
|
hQmfTran->qmfHBEBufReal_F =
|
(FIXP_DBL**)FDKcalloc(HBE_MAX_OUT_SLOTS, sizeof(FIXP_DBL*));
|
hQmfTran->qmfHBEBufImag_F =
|
(FIXP_DBL**)FDKcalloc(HBE_MAX_OUT_SLOTS, sizeof(FIXP_DBL*));
|
|
if (hQmfTran->qmfHBEBufReal_F == NULL) {
|
QmfTransposerClose(hQmfTran);
|
return SBRDEC_MEM_ALLOC_FAILED;
|
}
|
if (hQmfTran->qmfHBEBufImag_F == NULL) {
|
QmfTransposerClose(hQmfTran);
|
return SBRDEC_MEM_ALLOC_FAILED;
|
}
|
|
for (i = 0; i < HBE_MAX_OUT_SLOTS; i++) {
|
hQmfTran->qmfHBEBufReal_F[i] =
|
(FIXP_DBL*)FDKcalloc(QMF_SYNTH_CHANNELS, sizeof(FIXP_DBL));
|
hQmfTran->qmfHBEBufImag_F[i] =
|
(FIXP_DBL*)FDKcalloc(QMF_SYNTH_CHANNELS, sizeof(FIXP_DBL));
|
if (hQmfTran->qmfHBEBufReal_F[i] == NULL) {
|
QmfTransposerClose(hQmfTran);
|
return SBRDEC_MEM_ALLOC_FAILED;
|
}
|
if (hQmfTran->qmfHBEBufImag_F[i] == NULL) {
|
QmfTransposerClose(hQmfTran);
|
return SBRDEC_MEM_ALLOC_FAILED;
|
}
|
}
|
|
hQmfTran->qmfBufferCodecTempSlot_F =
|
(FIXP_DBL*)FDKcalloc(QMF_SYNTH_CHANNELS / 2, sizeof(FIXP_DBL));
|
if (hQmfTran->qmfBufferCodecTempSlot_F == NULL) {
|
QmfTransposerClose(hQmfTran);
|
return SBRDEC_MEM_ALLOC_FAILED;
|
}
|
|
hQmfTran->bSbr41 = bSbr41;
|
|
hQmfTran->highband_exp[0] = 0;
|
hQmfTran->highband_exp[1] = 0;
|
hQmfTran->target_exp[0] = 0;
|
hQmfTran->target_exp[1] = 0;
|
|
*hQmfTransposer = hQmfTran;
|
}
|
|
return SBRDEC_OK;
|
}
|
|
SBR_ERROR QmfTransposerReInit(HANDLE_HBE_TRANSPOSER hQmfTransposer,
|
UCHAR* FreqBandTable[2], UCHAR NSfb[2])
|
/* removed bSbr41 from parameterlist:
|
don't know where to get this value from
|
at call-side */
|
{
|
int L, sfb, patch, stopPatch, qmfErr;
|
|
if (hQmfTransposer != NULL) {
|
const FIXP_QTW* tmp_t_cos;
|
const FIXP_QTW* tmp_t_sin;
|
|
hQmfTransposer->startBand = FreqBandTable[0][0];
|
FDK_ASSERT((!hQmfTransposer->bSbr41 && hQmfTransposer->startBand <= 32) ||
|
(hQmfTransposer->bSbr41 &&
|
hQmfTransposer->startBand <=
|
16)); /* is checked by resetFreqBandTables() */
|
hQmfTransposer->stopBand = FreqBandTable[0][NSfb[0]];
|
|
hQmfTransposer->synthSize =
|
4 * ((hQmfTransposer->startBand + 4) / 8 + 1); /* 8, 12, 16, 20 */
|
hQmfTransposer->kstart = startSubband2kL[hQmfTransposer->startBand];
|
|
/* don't know where to take this information from */
|
/* hQmfTransposer->bSbr41 = bSbr41; */
|
|
if (hQmfTransposer->bSbr41) {
|
if (hQmfTransposer->kstart + hQmfTransposer->synthSize > 16)
|
hQmfTransposer->kstart = 16 - hQmfTransposer->synthSize;
|
} else if (hQmfTransposer->timeDomainWinLen == 768) {
|
if (hQmfTransposer->kstart + hQmfTransposer->synthSize > 24)
|
hQmfTransposer->kstart = 24 - hQmfTransposer->synthSize;
|
}
|
|
hQmfTransposer->synthesisQmfPreModCos_F =
|
&preModCos[hQmfTransposer->kstart];
|
hQmfTransposer->synthesisQmfPreModSin_F =
|
&preModSin[hQmfTransposer->kstart];
|
|
L = 2 * hQmfTransposer->synthSize; /* 8, 16, 24, 32, 40 */
|
/* Change analysis post twiddles */
|
|
switch (L) {
|
case 8:
|
tmp_t_cos = post_twiddle_cos_8;
|
tmp_t_sin = post_twiddle_sin_8;
|
break;
|
case 16:
|
tmp_t_cos = post_twiddle_cos_16;
|
tmp_t_sin = post_twiddle_sin_16;
|
break;
|
case 24:
|
tmp_t_cos = post_twiddle_cos_24;
|
tmp_t_sin = post_twiddle_sin_24;
|
break;
|
case 32:
|
tmp_t_cos = post_twiddle_cos_32;
|
tmp_t_sin = post_twiddle_sin_32;
|
break;
|
case 40:
|
tmp_t_cos = post_twiddle_cos_40;
|
tmp_t_sin = post_twiddle_sin_40;
|
break;
|
default:
|
return SBRDEC_UNSUPPORTED_CONFIG;
|
}
|
|
qmfErr = qmfInitSynthesisFilterBank(
|
&hQmfTransposer->HBESynthesisQMF, hQmfTransposer->synQmfStates,
|
hQmfTransposer->noCols, 0, hQmfTransposer->synthSize,
|
hQmfTransposer->synthSize, 1);
|
if (qmfErr != 0) {
|
return SBRDEC_UNSUPPORTED_CONFIG;
|
}
|
|
qmfErr = qmfInitAnalysisFilterBank(
|
&hQmfTransposer->HBEAnalysiscQMF, hQmfTransposer->anaQmfStates,
|
hQmfTransposer->noCols / 2, 0, 2 * hQmfTransposer->synthSize,
|
2 * hQmfTransposer->synthSize, 0);
|
|
if (qmfErr != 0) {
|
return SBRDEC_UNSUPPORTED_CONFIG;
|
}
|
|
hQmfTransposer->HBEAnalysiscQMF.t_cos = tmp_t_cos;
|
hQmfTransposer->HBEAnalysiscQMF.t_sin = tmp_t_sin;
|
|
FDKmemset(hQmfTransposer->xOverQmf, 0,
|
MAX_NUM_PATCHES * sizeof(int)); /* global */
|
sfb = 0;
|
if (hQmfTransposer->bSbr41) {
|
stopPatch = MAX_NUM_PATCHES;
|
hQmfTransposer->maxStretch = MAX_STRETCH_HBE;
|
} else {
|
stopPatch = MAX_STRETCH_HBE;
|
}
|
|
for (patch = 1; patch <= stopPatch; patch++) {
|
while (sfb <= NSfb[0] &&
|
FreqBandTable[0][sfb] <= patch * hQmfTransposer->startBand)
|
sfb++;
|
if (sfb <= NSfb[0]) {
|
/* If the distance is larger than three QMF bands - try aligning to high
|
* resolution frequency bands instead. */
|
if ((patch * hQmfTransposer->startBand - FreqBandTable[0][sfb - 1]) <=
|
3) {
|
hQmfTransposer->xOverQmf[patch - 1] = FreqBandTable[0][sfb - 1];
|
} else {
|
int sfb_tmp = 0;
|
while (sfb_tmp <= NSfb[1] &&
|
FreqBandTable[1][sfb_tmp] <= patch * hQmfTransposer->startBand)
|
sfb_tmp++;
|
hQmfTransposer->xOverQmf[patch - 1] = FreqBandTable[1][sfb_tmp - 1];
|
}
|
} else {
|
hQmfTransposer->xOverQmf[patch - 1] = hQmfTransposer->stopBand;
|
hQmfTransposer->maxStretch = fMin(patch, MAX_STRETCH_HBE);
|
break;
|
}
|
}
|
|
hQmfTransposer->highband_exp[0] = 0;
|
hQmfTransposer->highband_exp[1] = 0;
|
hQmfTransposer->target_exp[0] = 0;
|
hQmfTransposer->target_exp[1] = 0;
|
}
|
|
return SBRDEC_OK;
|
}
|
|
void QmfTransposerClose(HANDLE_HBE_TRANSPOSER hQmfTransposer) {
|
int i;
|
|
if (hQmfTransposer != NULL) {
|
if (hQmfTransposer->inBuf_F) FDKfree(hQmfTransposer->inBuf_F);
|
|
if (hQmfTransposer->qmfInBufReal_F) {
|
for (i = 0; i < hQmfTransposer->qmfInBufSize; i++) {
|
FDKafree(hQmfTransposer->qmfInBufReal_F[i]);
|
}
|
FDKfree(hQmfTransposer->qmfInBufReal_F);
|
}
|
|
if (hQmfTransposer->qmfInBufImag_F) {
|
for (i = 0; i < hQmfTransposer->qmfInBufSize; i++) {
|
FDKafree(hQmfTransposer->qmfInBufImag_F[i]);
|
}
|
FDKfree(hQmfTransposer->qmfInBufImag_F);
|
}
|
|
if (hQmfTransposer->qmfHBEBufReal_F) {
|
for (i = 0; i < HBE_MAX_OUT_SLOTS; i++) {
|
FDKfree(hQmfTransposer->qmfHBEBufReal_F[i]);
|
}
|
FDKfree(hQmfTransposer->qmfHBEBufReal_F);
|
}
|
|
if (hQmfTransposer->qmfHBEBufImag_F) {
|
for (i = 0; i < HBE_MAX_OUT_SLOTS; i++) {
|
FDKfree(hQmfTransposer->qmfHBEBufImag_F[i]);
|
}
|
FDKfree(hQmfTransposer->qmfHBEBufImag_F);
|
}
|
|
FDKfree(hQmfTransposer->qmfBufferCodecTempSlot_F);
|
|
FDKfree(hQmfTransposer);
|
}
|
}
|
|
inline void scaleUp(FIXP_DBL* real_m, FIXP_DBL* imag_m, INT* _e) {
|
INT reserve;
|
/* shift gc_r and gc_i up if possible */
|
reserve = CntLeadingZeros((INT(*real_m) ^ INT((*real_m >> 31))) |
|
(INT(*imag_m) ^ INT((*imag_m >> 31)))) -
|
1;
|
reserve = fMax(reserve - 1,
|
0); /* Leave one bit headroom such that (real_m^2 + imag_m^2)
|
does not overflow later if both are 0x80000000. */
|
reserve = fMin(reserve, *_e);
|
FDK_ASSERT(reserve >= 0);
|
*real_m <<= reserve;
|
*imag_m <<= reserve;
|
*_e -= reserve;
|
}
|
|
static void calculateCenterFIXP(FIXP_DBL gammaVecReal, FIXP_DBL gammaVecImag,
|
FIXP_DBL* centerReal, FIXP_DBL* centerImag,
|
INT* exponent, int stretch, int mult) {
|
scaleUp(&gammaVecReal, &gammaVecImag, exponent);
|
FIXP_DBL energy = fPow2Div2(gammaVecReal) + fPow2Div2(gammaVecImag);
|
|
if (energy != FL2FXCONST_DBL(0.f)) {
|
FIXP_DBL gc_r_m, gc_i_m, factor_m = (FIXP_DBL)0;
|
INT factor_e, gc_e;
|
factor_e = 2 * (*exponent) + 1;
|
|
switch (stretch) {
|
case 2:
|
factor_m = invFourthRootNorm2(energy, &factor_e);
|
break;
|
case 3:
|
factor_m = invCubeRootNorm2(energy, &factor_e);
|
break;
|
case 4:
|
factor_m = inv3EigthRootNorm2(energy, &factor_e);
|
break;
|
}
|
|
gc_r_m = fMultDiv2(gammaVecReal,
|
factor_m); /* exponent = HBE_SCALE + factor_e + 1 */
|
gc_i_m = fMultDiv2(gammaVecImag,
|
factor_m); /* exponent = HBE_SCALE + factor_e + 1*/
|
gc_e = *exponent + factor_e + 1;
|
|
scaleUp(&gc_r_m, &gc_i_m, &gc_e);
|
|
switch (mult) {
|
case 0:
|
*centerReal = gc_r_m;
|
*centerImag = gc_i_m;
|
break;
|
case 1:
|
*centerReal = fPow2Div2(gc_r_m) - fPow2Div2(gc_i_m);
|
*centerImag = fMult(gc_r_m, gc_i_m);
|
gc_e = 2 * gc_e + 1;
|
break;
|
case 2:
|
FIXP_DBL tmp_r = gc_r_m;
|
FIXP_DBL tmp_i = gc_i_m;
|
gc_r_m = fPow2Div2(gc_r_m) - fPow2Div2(gc_i_m);
|
gc_i_m = fMult(tmp_r, gc_i_m);
|
gc_e = 3 * gc_e + 1 + 1;
|
cplxMultDiv2(¢erReal[0], ¢erImag[0], gc_r_m, gc_i_m, tmp_r,
|
tmp_i);
|
break;
|
}
|
|
scaleUp(centerReal, centerImag, &gc_e);
|
|
FDK_ASSERT(gc_e >= 0);
|
*exponent = gc_e;
|
} else {
|
*centerReal = energy; /* energy = 0 */
|
*centerImag = energy; /* energy = 0 */
|
*exponent = (INT)energy;
|
}
|
}
|
|
static int getHBEScaleFactorFrame(const int bSbr41, const int maxStretch,
|
const int pitchInBins) {
|
if (pitchInBins >= pmin * (1 + bSbr41)) {
|
/* crossproducts enabled */
|
return 26;
|
} else {
|
return (maxStretch == 2) ? 24 : 25;
|
}
|
}
|
|
static void addHighBandPart(FIXP_DBL g_r_m, FIXP_DBL g_i_m, INT g_e,
|
FIXP_DBL mult, FIXP_DBL gammaCenterReal_m,
|
FIXP_DBL gammaCenterImag_m, INT gammaCenter_e,
|
INT stretch, INT scale_factor_hbe,
|
FIXP_DBL* qmfHBEBufReal_F,
|
FIXP_DBL* qmfHBEBufImag_F) {
|
if ((g_r_m | g_i_m) != FL2FXCONST_DBL(0.f)) {
|
FIXP_DBL factor_m = (FIXP_DBL)0;
|
INT factor_e;
|
INT add = (stretch == 4) ? 1 : 0;
|
INT shift = (stretch == 4) ? 1 : 2;
|
|
scaleUp(&g_r_m, &g_i_m, &g_e);
|
FIXP_DBL energy = fPow2AddDiv2(fPow2Div2(g_r_m), g_i_m);
|
factor_e = 2 * g_e + 1;
|
|
switch (stretch) {
|
case 2:
|
factor_m = invFourthRootNorm2(energy, &factor_e);
|
break;
|
case 3:
|
factor_m = invCubeRootNorm2(energy, &factor_e);
|
break;
|
case 4:
|
factor_m = inv3EigthRootNorm2(energy, &factor_e);
|
break;
|
}
|
|
factor_m = fMult(factor_m, mult);
|
|
FIXP_DBL tmp_r, tmp_i;
|
cplxMultDiv2(&tmp_r, &tmp_i, g_r_m, g_i_m, gammaCenterReal_m,
|
gammaCenterImag_m);
|
|
g_r_m = fMultDiv2(tmp_r, factor_m) << shift;
|
g_i_m = fMultDiv2(tmp_i, factor_m) << shift;
|
g_e = scale_factor_hbe - (g_e + factor_e + gammaCenter_e + add);
|
fMax((INT)0, g_e);
|
*qmfHBEBufReal_F += g_r_m >> g_e;
|
*qmfHBEBufImag_F += g_i_m >> g_e;
|
}
|
}
|
|
void QmfTransposerApply(HANDLE_HBE_TRANSPOSER hQmfTransposer,
|
FIXP_DBL** qmfBufferCodecReal,
|
FIXP_DBL** qmfBufferCodecImag, int nColsIn,
|
FIXP_DBL** ppQmfBufferOutReal_F,
|
FIXP_DBL** ppQmfBufferOutImag_F,
|
FIXP_DBL lpcFilterStatesReal[2 + (3 * (4))][(64)],
|
FIXP_DBL lpcFilterStatesImag[2 + (3 * (4))][(64)],
|
int pitchInBins, int scale_lb, int scale_hbe,
|
int* scale_hb, int timeStep, int firstSlotOffsset,
|
int ov_len,
|
KEEP_STATES_SYNCED_MODE keepStatesSyncedMode) {
|
int i, j, stretch, band, sourceband, r, s;
|
int qmfVocoderColsIn = hQmfTransposer->noCols / 2;
|
int bSbr41 = hQmfTransposer->bSbr41;
|
|
const int winLength[3] = {10, 8, 6};
|
const int slotOffset = 6; /* hQmfTransposer->winLen-6; */
|
|
int qmfOffset = 2 * hQmfTransposer->kstart;
|
int scale_border = (nColsIn == 64) ? 32 : nColsIn;
|
|
INT slot_stretch4[9] = {0, 0, 0, 0, 2, 4, 6, 8, 10};
|
INT slot_stretch2[11] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
|
INT slot_stretch3[10] = {0, 0, 0, 1, 3, 4, 6, 7, 9, 10};
|
INT filt_stretch3[10] = {0, 0, 0, 1, 0, 1, 0, 1, 0, 1};
|
INT filt_dummy[11] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
|
INT* pSlotStretch;
|
INT* pFilt;
|
|
int offset = 0; /* where to take QmfTransposer data */
|
|
int signPreMod =
|
(hQmfTransposer->synthesisQmfPreModCos_F[0] < FL2FXCONST_DBL(0.f)) ? 1
|
: -1;
|
|
int scale_factor_hbe =
|
getHBEScaleFactorFrame(bSbr41, hQmfTransposer->maxStretch, pitchInBins);
|
|
if (keepStatesSyncedMode != KEEP_STATES_SYNCED_OFF) {
|
offset = hQmfTransposer->noCols - ov_len - LPC_ORDER;
|
}
|
|
hQmfTransposer->highband_exp[0] = hQmfTransposer->highband_exp[1];
|
hQmfTransposer->target_exp[0] = hQmfTransposer->target_exp[1];
|
|
hQmfTransposer->highband_exp[1] = scale_factor_hbe;
|
hQmfTransposer->target_exp[1] =
|
fixMax(hQmfTransposer->highband_exp[1], hQmfTransposer->highband_exp[0]);
|
|
scale_factor_hbe = hQmfTransposer->target_exp[1];
|
|
int shift_ov = hQmfTransposer->target_exp[0] - hQmfTransposer->target_exp[1];
|
|
if (shift_ov != 0) {
|
for (i = 0; i < HBE_MAX_OUT_SLOTS; i++) {
|
for (band = 0; band < QMF_SYNTH_CHANNELS; band++) {
|
if (shift_ov >= 0) {
|
hQmfTransposer->qmfHBEBufReal_F[i][band] <<= shift_ov;
|
hQmfTransposer->qmfHBEBufImag_F[i][band] <<= shift_ov;
|
} else {
|
hQmfTransposer->qmfHBEBufReal_F[i][band] >>= (-shift_ov);
|
hQmfTransposer->qmfHBEBufImag_F[i][band] >>= (-shift_ov);
|
}
|
}
|
}
|
}
|
|
if ((keepStatesSyncedMode == KEEP_STATES_SYNCED_OFF) && shift_ov != 0) {
|
for (i = timeStep * firstSlotOffsset; i < ov_len; i++) {
|
for (band = hQmfTransposer->startBand; band < hQmfTransposer->stopBand;
|
band++) {
|
if (shift_ov >= 0) {
|
ppQmfBufferOutReal_F[i][band] <<= shift_ov;
|
ppQmfBufferOutImag_F[i][band] <<= shift_ov;
|
} else {
|
ppQmfBufferOutReal_F[i][band] >>= (-shift_ov);
|
ppQmfBufferOutImag_F[i][band] >>= (-shift_ov);
|
}
|
}
|
}
|
|
/* shift lpc filterstates */
|
for (i = 0; i < timeStep * firstSlotOffsset + LPC_ORDER; i++) {
|
for (band = 0; band < (64); band++) {
|
if (shift_ov >= 0) {
|
lpcFilterStatesReal[i][band] <<= shift_ov;
|
lpcFilterStatesImag[i][band] <<= shift_ov;
|
} else {
|
lpcFilterStatesReal[i][band] >>= (-shift_ov);
|
lpcFilterStatesImag[i][band] >>= (-shift_ov);
|
}
|
}
|
}
|
}
|
|
FIXP_DBL twid_m_new[3][2]; /* [stretch][cos/sin] */
|
INT stepsize = 1 + !bSbr41, sine_offset = 24, mod = 96;
|
INT mult[3] = {1, 2, 3};
|
|
for (s = 0; s <= MAX_STRETCH_HBE - 2; s++) {
|
twid_m_new[s][0] = twiddle[(mult[s] * (stepsize * pitchInBins)) % mod];
|
twid_m_new[s][1] =
|
twiddle[((mult[s] * (stepsize * pitchInBins)) + sine_offset) % mod];
|
}
|
|
/* Time-stretch */
|
for (j = 0; j < qmfVocoderColsIn; j++) {
|
int sign = -1, k, z, addrshift, codecTemp_e;
|
/* update inbuf */
|
for (i = 0; i < hQmfTransposer->synthSize; i++) {
|
hQmfTransposer->inBuf_F[i] =
|
hQmfTransposer->inBuf_F[i + 2 * hQmfTransposer->synthSize];
|
}
|
|
/* run synthesis for two sbr slots as transposer uses
|
half slots double bands representation */
|
for (z = 0; z < 2; z++) {
|
int scale_factor = ((nColsIn == 64) && ((2 * j + z) < scale_border))
|
? scale_lb
|
: scale_hbe;
|
codecTemp_e = scale_factor - 1; /* -2 for Div2 and cos/sin scale of 1 */
|
|
for (k = 0; k < hQmfTransposer->synthSize; k++) {
|
int ki = hQmfTransposer->kstart + k;
|
hQmfTransposer->qmfBufferCodecTempSlot_F[k] =
|
fMultDiv2(signPreMod * hQmfTransposer->synthesisQmfPreModCos_F[k],
|
qmfBufferCodecReal[2 * j + z][ki]);
|
hQmfTransposer->qmfBufferCodecTempSlot_F[k] +=
|
fMultDiv2(signPreMod * hQmfTransposer->synthesisQmfPreModSin_F[k],
|
qmfBufferCodecImag[2 * j + z][ki]);
|
}
|
|
C_AALLOC_SCRATCH_START(pWorkBuffer, FIXP_DBL, (HBE_MAX_QMF_BANDS << 1));
|
|
qmfSynthesisFilteringSlot(
|
&hQmfTransposer->HBESynthesisQMF,
|
hQmfTransposer->qmfBufferCodecTempSlot_F, NULL, 0,
|
-7 - hQmfTransposer->HBESynthesisQMF.filterScale - codecTemp_e + 1,
|
hQmfTransposer->inBuf_F + hQmfTransposer->synthSize * (z + 1), 1,
|
pWorkBuffer);
|
|
C_AALLOC_SCRATCH_END(pWorkBuffer, FIXP_DBL, (HBE_MAX_QMF_BANDS << 1));
|
}
|
|
C_AALLOC_SCRATCH_START(pWorkBuffer, FIXP_DBL, (HBE_MAX_QMF_BANDS << 1));
|
|
qmfAnalysisFilteringSlot(&hQmfTransposer->HBEAnalysiscQMF,
|
hQmfTransposer->qmfInBufReal_F[QMF_WIN_LEN - 1],
|
hQmfTransposer->qmfInBufImag_F[QMF_WIN_LEN - 1],
|
hQmfTransposer->inBuf_F + 1, 1, pWorkBuffer);
|
|
C_AALLOC_SCRATCH_END(pWorkBuffer, FIXP_DBL, (HBE_MAX_QMF_BANDS << 1));
|
|
if ((keepStatesSyncedMode == KEEP_STATES_SYNCED_NORMAL) &&
|
j <= qmfVocoderColsIn - ((LPC_ORDER + ov_len + QMF_WIN_LEN - 1) >> 1)) {
|
/* update in buffer */
|
for (i = 0; i < QMF_WIN_LEN - 1; i++) {
|
FDKmemcpy(
|
hQmfTransposer->qmfInBufReal_F[i],
|
hQmfTransposer->qmfInBufReal_F[i + 1],
|
sizeof(FIXP_DBL) * hQmfTransposer->HBEAnalysiscQMF.no_channels);
|
FDKmemcpy(
|
hQmfTransposer->qmfInBufImag_F[i],
|
hQmfTransposer->qmfInBufImag_F[i + 1],
|
sizeof(FIXP_DBL) * hQmfTransposer->HBEAnalysiscQMF.no_channels);
|
}
|
continue;
|
}
|
|
for (stretch = 2; stretch <= hQmfTransposer->maxStretch; stretch++) {
|
int start = slotOffset - winLength[stretch - 2] / 2;
|
int stop = slotOffset + winLength[stretch - 2] / 2;
|
|
FIXP_DBL factor = FL2FXCONST_DBL(1.f / 3.f);
|
|
for (band = hQmfTransposer->xOverQmf[stretch - 2];
|
band < hQmfTransposer->xOverQmf[stretch - 1]; band++) {
|
FIXP_DBL gammaCenterReal_m[2] = {(FIXP_DBL)0, (FIXP_DBL)0},
|
gammaCenterImag_m[2] = {(FIXP_DBL)0, (FIXP_DBL)0};
|
INT gammaCenter_e[2] = {0, 0};
|
|
FIXP_DBL gammaVecReal_m[2] = {(FIXP_DBL)0, (FIXP_DBL)0},
|
gammaVecImag_m[2] = {(FIXP_DBL)0, (FIXP_DBL)0};
|
INT gammaVec_e[2] = {0, 0};
|
|
FIXP_DBL wingain = (FIXP_DBL)0;
|
|
gammaCenter_e[0] =
|
SCALE2EXP(-hQmfTransposer->HBEAnalysiscQMF.outScalefactor);
|
gammaCenter_e[1] =
|
SCALE2EXP(-hQmfTransposer->HBEAnalysiscQMF.outScalefactor);
|
|
/* interpolation filters for 3rd order */
|
sourceband = 2 * band / stretch - qmfOffset;
|
FDK_ASSERT(sourceband >= 0);
|
|
/* maximum gammaCenter_e == 20 */
|
calculateCenterFIXP(
|
hQmfTransposer->qmfInBufReal_F[slotOffset][sourceband],
|
hQmfTransposer->qmfInBufImag_F[slotOffset][sourceband],
|
&gammaCenterReal_m[0], &gammaCenterImag_m[0], &gammaCenter_e[0],
|
stretch, stretch - 2);
|
|
if (stretch == 4) {
|
r = band - 2 * (band / 2);
|
sourceband += (r == 0) ? -1 : 1;
|
pSlotStretch = slot_stretch4;
|
factor = FL2FXCONST_DBL(2.f / 3.f);
|
pFilt = filt_dummy;
|
} else if (stretch == 2) {
|
r = 0;
|
sourceband = 2 * band / stretch - qmfOffset;
|
pSlotStretch = slot_stretch2;
|
factor = FL2FXCONST_DBL(1.f / 3.f);
|
pFilt = filt_dummy;
|
} else {
|
r = 2 * band - 3 * (2 * band / 3);
|
sourceband = 2 * band / stretch - qmfOffset;
|
pSlotStretch = slot_stretch3;
|
factor = FL2FXCONST_DBL(1.4142f / 3.0f);
|
pFilt = filt_stretch3;
|
}
|
|
if (r == 2) {
|
calculateCenterFIXP(
|
hQmfTransposer->qmfInBufReal_F[slotOffset][sourceband + 1],
|
hQmfTransposer->qmfInBufImag_F[slotOffset][sourceband + 1],
|
&gammaCenterReal_m[1], &gammaCenterImag_m[1], &gammaCenter_e[1],
|
stretch, stretch - 2);
|
|
factor = FL2FXCONST_DBL(1.4142f / 6.0f);
|
}
|
|
if (r == 2) {
|
for (k = start; k < stop; k++) {
|
gammaVecReal_m[0] =
|
hQmfTransposer->qmfInBufReal_F[pSlotStretch[k]][sourceband];
|
gammaVecReal_m[1] =
|
hQmfTransposer->qmfInBufReal_F[pSlotStretch[k]][sourceband + 1];
|
gammaVecImag_m[0] =
|
hQmfTransposer->qmfInBufImag_F[pSlotStretch[k]][sourceband];
|
gammaVecImag_m[1] =
|
hQmfTransposer->qmfInBufImag_F[pSlotStretch[k]][sourceband + 1];
|
gammaVec_e[0] = gammaVec_e[1] =
|
SCALE2EXP(-hQmfTransposer->HBEAnalysiscQMF.outScalefactor);
|
|
if (pFilt[k] == 1) {
|
FIXP_DBL tmpRealF = gammaVecReal_m[0], tmpImagF;
|
gammaVecReal_m[0] =
|
(fMult(gammaVecReal_m[0], hintReal_F[sourceband % 4][1]) -
|
fMult(gammaVecImag_m[0],
|
hintReal_F[(sourceband + 3) % 4][1])) >>
|
1; /* sum should be <= 1 because of sin/cos multiplication */
|
gammaVecImag_m[0] =
|
(fMult(tmpRealF, hintReal_F[(sourceband + 3) % 4][1]) +
|
fMult(gammaVecImag_m[0], hintReal_F[sourceband % 4][1])) >>
|
1; /* sum should be <= 1 because of sin/cos multiplication */
|
|
tmpRealF = hQmfTransposer
|
->qmfInBufReal_F[pSlotStretch[k] + 1][sourceband];
|
tmpImagF = hQmfTransposer
|
->qmfInBufImag_F[pSlotStretch[k] + 1][sourceband];
|
|
gammaVecReal_m[0] +=
|
(fMult(tmpRealF, hintReal_F[sourceband % 4][1]) -
|
fMult(tmpImagF, hintReal_F[(sourceband + 1) % 4][1])) >>
|
1; /* sum should be <= 1 because of sin/cos multiplication */
|
gammaVecImag_m[0] +=
|
(fMult(tmpRealF, hintReal_F[(sourceband + 1) % 4][1]) +
|
fMult(tmpImagF, hintReal_F[sourceband % 4][1])) >>
|
1; /* sum should be <= 1 because of sin/cos multiplication */
|
gammaVec_e[0]++;
|
|
tmpRealF = gammaVecReal_m[1];
|
|
gammaVecReal_m[1] =
|
(fMult(gammaVecReal_m[1], hintReal_F[sourceband % 4][2]) -
|
fMult(gammaVecImag_m[1],
|
hintReal_F[(sourceband + 3) % 4][2])) >>
|
1;
|
gammaVecImag_m[1] =
|
(fMult(tmpRealF, hintReal_F[(sourceband + 3) % 4][2]) +
|
fMult(gammaVecImag_m[1], hintReal_F[sourceband % 4][2])) >>
|
1;
|
|
tmpRealF =
|
hQmfTransposer
|
->qmfInBufReal_F[pSlotStretch[k] + 1][sourceband + 1];
|
tmpImagF =
|
hQmfTransposer
|
->qmfInBufImag_F[pSlotStretch[k] + 1][sourceband + 1];
|
|
gammaVecReal_m[1] +=
|
(fMult(tmpRealF, hintReal_F[sourceband % 4][2]) -
|
fMult(tmpImagF, hintReal_F[(sourceband + 1) % 4][2])) >>
|
1;
|
gammaVecImag_m[1] +=
|
(fMult(tmpRealF, hintReal_F[(sourceband + 1) % 4][2]) +
|
fMult(tmpImagF, hintReal_F[sourceband % 4][2])) >>
|
1;
|
gammaVec_e[1]++;
|
}
|
|
addHighBandPart(gammaVecReal_m[1], gammaVecImag_m[1], gammaVec_e[1],
|
factor, gammaCenterReal_m[0], gammaCenterImag_m[0],
|
gammaCenter_e[0], stretch, scale_factor_hbe,
|
&hQmfTransposer->qmfHBEBufReal_F[k][band],
|
&hQmfTransposer->qmfHBEBufImag_F[k][band]);
|
|
addHighBandPart(gammaVecReal_m[0], gammaVecImag_m[0], gammaVec_e[0],
|
factor, gammaCenterReal_m[1], gammaCenterImag_m[1],
|
gammaCenter_e[1], stretch, scale_factor_hbe,
|
&hQmfTransposer->qmfHBEBufReal_F[k][band],
|
&hQmfTransposer->qmfHBEBufImag_F[k][band]);
|
}
|
} else {
|
for (k = start; k < stop; k++) {
|
gammaVecReal_m[0] =
|
hQmfTransposer->qmfInBufReal_F[pSlotStretch[k]][sourceband];
|
gammaVecImag_m[0] =
|
hQmfTransposer->qmfInBufImag_F[pSlotStretch[k]][sourceband];
|
gammaVec_e[0] =
|
SCALE2EXP(-hQmfTransposer->HBEAnalysiscQMF.outScalefactor);
|
|
if (pFilt[k] == 1) {
|
FIXP_DBL tmpRealF = gammaVecReal_m[0], tmpImagF;
|
gammaVecReal_m[0] =
|
(fMult(gammaVecReal_m[0], hintReal_F[sourceband % 4][1]) -
|
fMult(gammaVecImag_m[0],
|
hintReal_F[(sourceband + 3) % 4][1])) >>
|
1; /* sum should be <= 1 because of sin/cos multiplication */
|
gammaVecImag_m[0] =
|
(fMult(tmpRealF, hintReal_F[(sourceband + 3) % 4][1]) +
|
fMult(gammaVecImag_m[0], hintReal_F[sourceband % 4][1])) >>
|
1; /* sum should be <= 1 because of sin/cos multiplication */
|
|
tmpRealF = hQmfTransposer
|
->qmfInBufReal_F[pSlotStretch[k] + 1][sourceband];
|
tmpImagF = hQmfTransposer
|
->qmfInBufImag_F[pSlotStretch[k] + 1][sourceband];
|
|
gammaVecReal_m[0] +=
|
(fMult(tmpRealF, hintReal_F[sourceband % 4][1]) -
|
fMult(tmpImagF, hintReal_F[(sourceband + 1) % 4][1])) >>
|
1; /* sum should be <= 1 because of sin/cos multiplication */
|
gammaVecImag_m[0] +=
|
(fMult(tmpRealF, hintReal_F[(sourceband + 1) % 4][1]) +
|
fMult(tmpImagF, hintReal_F[sourceband % 4][1])) >>
|
1; /* sum should be <= 1 because of sin/cos multiplication */
|
gammaVec_e[0]++;
|
}
|
|
addHighBandPart(gammaVecReal_m[0], gammaVecImag_m[0], gammaVec_e[0],
|
factor, gammaCenterReal_m[0], gammaCenterImag_m[0],
|
gammaCenter_e[0], stretch, scale_factor_hbe,
|
&hQmfTransposer->qmfHBEBufReal_F[k][band],
|
&hQmfTransposer->qmfHBEBufImag_F[k][band]);
|
}
|
}
|
|
/* pitchInBins is given with the resolution of a 768 bins FFT and we
|
* need 64 QMF units so factor 768/64 = 12 */
|
if (pitchInBins >= pmin * (1 + bSbr41)) {
|
int tr, ti1, ti2, mTr = 0, ts1 = 0, ts2 = 0, mVal_e = 0, temp_e = 0;
|
int sqmag0_e =
|
SCALE2EXP(-hQmfTransposer->HBEAnalysiscQMF.outScalefactor);
|
|
FIXP_DBL mVal_F = FL2FXCONST_DBL(0.f), sqmag0_F, sqmag1_F, sqmag2_F,
|
temp_F, f1_F; /* all equal exponent */
|
sign = -1;
|
|
sourceband = 2 * band / stretch - qmfOffset; /* consistent with the
|
already computed for
|
stretch = 3,4. */
|
FDK_ASSERT(sourceband >= 0);
|
|
FIXP_DBL sqmag0R_F =
|
hQmfTransposer->qmfInBufReal_F[slotOffset][sourceband];
|
FIXP_DBL sqmag0I_F =
|
hQmfTransposer->qmfInBufImag_F[slotOffset][sourceband];
|
scaleUp(&sqmag0R_F, &sqmag0I_F, &sqmag0_e);
|
|
sqmag0_F = fPow2Div2(sqmag0R_F);
|
sqmag0_F += fPow2Div2(sqmag0I_F);
|
sqmag0_e = 2 * sqmag0_e + 1;
|
|
for (tr = 1; tr < stretch; tr++) {
|
int sqmag1_e =
|
SCALE2EXP(-hQmfTransposer->HBEAnalysiscQMF.outScalefactor);
|
int sqmag2_e =
|
SCALE2EXP(-hQmfTransposer->HBEAnalysiscQMF.outScalefactor);
|
|
FIXP_DBL tmp_band = band_F[band];
|
FIXP_DBL tr_p =
|
fMult(p_F[pitchInBins] >> bSbr41, tr_str[tr - 1]); /* scale 7 */
|
f1_F =
|
fMult(tmp_band - tr_p, stretchfac[stretch - 2]); /* scale 7 */
|
ti1 = (INT)(f1_F >> (DFRACT_BITS - 1 - 7)) - qmfOffset;
|
ti2 = (INT)(((f1_F) + ((p_F[pitchInBins] >> bSbr41) >> 2)) >>
|
(DFRACT_BITS - 1 - 7)) -
|
qmfOffset;
|
|
if (ti1 >= 0 && ti2 < 2 * hQmfTransposer->synthSize) {
|
FIXP_DBL sqmag1R_F =
|
hQmfTransposer->qmfInBufReal_F[slotOffset][ti1];
|
FIXP_DBL sqmag1I_F =
|
hQmfTransposer->qmfInBufImag_F[slotOffset][ti1];
|
scaleUp(&sqmag1R_F, &sqmag1I_F, &sqmag1_e);
|
sqmag1_F = fPow2Div2(sqmag1R_F);
|
sqmag1_F += fPow2Div2(sqmag1I_F);
|
sqmag1_e = 2 * sqmag1_e + 1;
|
|
FIXP_DBL sqmag2R_F =
|
hQmfTransposer->qmfInBufReal_F[slotOffset][ti2];
|
FIXP_DBL sqmag2I_F =
|
hQmfTransposer->qmfInBufImag_F[slotOffset][ti2];
|
scaleUp(&sqmag2R_F, &sqmag2I_F, &sqmag2_e);
|
sqmag2_F = fPow2Div2(sqmag2R_F);
|
sqmag2_F += fPow2Div2(sqmag2I_F);
|
sqmag2_e = 2 * sqmag2_e + 1;
|
|
int shift1 = fMin(fMax(sqmag1_e, sqmag2_e) - sqmag1_e, 31);
|
int shift2 = fMin(fMax(sqmag1_e, sqmag2_e) - sqmag2_e, 31);
|
|
temp_F = fMin((sqmag1_F >> shift1), (sqmag2_F >> shift2));
|
temp_e = fMax(sqmag1_e, sqmag2_e);
|
|
int shift3 = fMin(fMax(temp_e, mVal_e) - temp_e, 31);
|
int shift4 = fMin(fMax(temp_e, mVal_e) - mVal_e, 31);
|
|
if ((temp_F >> shift3) > (mVal_F >> shift4)) {
|
mVal_F = temp_F;
|
mVal_e = temp_e; /* equals sqmag2_e + shift2 */
|
mTr = tr;
|
ts1 = ti1;
|
ts2 = ti2;
|
}
|
}
|
}
|
|
int shift1 = fMin(fMax(sqmag0_e, mVal_e) - sqmag0_e, 31);
|
int shift2 = fMin(fMax(sqmag0_e, mVal_e) - mVal_e, 31);
|
|
if ((mVal_F >> shift2) > (sqmag0_F >> shift1) && ts1 >= 0 &&
|
ts2 < 2 * hQmfTransposer->synthSize) {
|
INT gammaOut_e[2];
|
FIXP_DBL gammaOutReal_m[2], gammaOutImag_m[2];
|
FIXP_DBL tmpReal_m = (FIXP_DBL)0, tmpImag_m = (FIXP_DBL)0;
|
|
int Tcenter, Tvec;
|
|
Tcenter = stretch - mTr; /* default phase power parameters */
|
Tvec = mTr;
|
switch (stretch) /* 2 tap block creation design depends on stretch
|
order */
|
{
|
case 2:
|
wingain =
|
FL2FXCONST_DBL(5.f / 12.f); /* sum of taps divided by two */
|
|
if (hQmfTransposer->bXProducts[0]) {
|
gammaCenterReal_m[0] =
|
hQmfTransposer->qmfInBufReal_F[slotOffset][ts1];
|
gammaCenterImag_m[0] =
|
hQmfTransposer->qmfInBufImag_F[slotOffset][ts1];
|
|
for (k = 0; k < 2; k++) {
|
gammaVecReal_m[k] =
|
hQmfTransposer->qmfInBufReal_F[slotOffset - 1 + k][ts2];
|
gammaVecImag_m[k] =
|
hQmfTransposer->qmfInBufImag_F[slotOffset - 1 + k][ts2];
|
}
|
|
gammaCenter_e[0] = SCALE2EXP(
|
-hQmfTransposer->HBEAnalysiscQMF.outScalefactor);
|
gammaVec_e[0] = gammaVec_e[1] = SCALE2EXP(
|
-hQmfTransposer->HBEAnalysiscQMF.outScalefactor);
|
}
|
break;
|
|
case 4:
|
wingain =
|
FL2FXCONST_DBL(6.f / 12.f); /* sum of taps divided by two */
|
if (hQmfTransposer->bXProducts[2]) {
|
if (mTr == 1) {
|
gammaCenterReal_m[0] =
|
hQmfTransposer->qmfInBufReal_F[slotOffset][ts1];
|
gammaCenterImag_m[0] =
|
hQmfTransposer->qmfInBufImag_F[slotOffset][ts1];
|
|
for (k = 0; k < 2; k++) {
|
gammaVecReal_m[k] =
|
hQmfTransposer
|
->qmfInBufReal_F[slotOffset + 2 * (k - 1)][ts2];
|
gammaVecImag_m[k] =
|
hQmfTransposer
|
->qmfInBufImag_F[slotOffset + 2 * (k - 1)][ts2];
|
}
|
} else if (mTr == 2) {
|
gammaCenterReal_m[0] =
|
hQmfTransposer->qmfInBufReal_F[slotOffset][ts1];
|
gammaCenterImag_m[0] =
|
hQmfTransposer->qmfInBufImag_F[slotOffset][ts1];
|
|
for (k = 0; k < 2; k++) {
|
gammaVecReal_m[k] =
|
hQmfTransposer
|
->qmfInBufReal_F[slotOffset + (k - 1)][ts2];
|
gammaVecImag_m[k] =
|
hQmfTransposer
|
->qmfInBufImag_F[slotOffset + (k - 1)][ts2];
|
}
|
} else /* (mTr == 3) */
|
{
|
sign = 1;
|
Tcenter = mTr; /* opposite phase power parameters as ts2 is
|
center */
|
Tvec = stretch - mTr;
|
|
gammaCenterReal_m[0] =
|
hQmfTransposer->qmfInBufReal_F[slotOffset][ts2];
|
gammaCenterImag_m[0] =
|
hQmfTransposer->qmfInBufImag_F[slotOffset][ts2];
|
|
for (k = 0; k < 2; k++) {
|
gammaVecReal_m[k] =
|
hQmfTransposer
|
->qmfInBufReal_F[slotOffset + 2 * (k - 1)][ts1];
|
gammaVecImag_m[k] =
|
hQmfTransposer
|
->qmfInBufImag_F[slotOffset + 2 * (k - 1)][ts1];
|
}
|
}
|
|
gammaCenter_e[0] = SCALE2EXP(
|
-hQmfTransposer->HBEAnalysiscQMF.outScalefactor);
|
gammaVec_e[0] = gammaVec_e[1] = SCALE2EXP(
|
-hQmfTransposer->HBEAnalysiscQMF.outScalefactor);
|
}
|
break;
|
|
case 3:
|
wingain = FL2FXCONST_DBL(5.6568f /
|
12.f); /* sum of taps divided by two */
|
|
if (hQmfTransposer->bXProducts[1]) {
|
FIXP_DBL tmpReal_F, tmpImag_F;
|
if (mTr == 1) {
|
gammaCenterReal_m[0] =
|
hQmfTransposer->qmfInBufReal_F[slotOffset][ts1];
|
gammaCenterImag_m[0] =
|
hQmfTransposer->qmfInBufImag_F[slotOffset][ts1];
|
gammaVecReal_m[1] =
|
hQmfTransposer->qmfInBufReal_F[slotOffset][ts2];
|
gammaVecImag_m[1] =
|
hQmfTransposer->qmfInBufImag_F[slotOffset][ts2];
|
|
addrshift = -2;
|
tmpReal_F =
|
hQmfTransposer
|
->qmfInBufReal_F[addrshift + slotOffset][ts2];
|
tmpImag_F =
|
hQmfTransposer
|
->qmfInBufImag_F[addrshift + slotOffset][ts2];
|
|
gammaVecReal_m[0] =
|
(fMult(factors[ts2 % 4], tmpReal_F) -
|
fMult(factors[(ts2 + 3) % 4], tmpImag_F)) >>
|
1;
|
gammaVecImag_m[0] =
|
(fMult(factors[(ts2 + 3) % 4], tmpReal_F) +
|
fMult(factors[ts2 % 4], tmpImag_F)) >>
|
1;
|
|
tmpReal_F =
|
hQmfTransposer
|
->qmfInBufReal_F[addrshift + 1 + slotOffset][ts2];
|
tmpImag_F =
|
hQmfTransposer
|
->qmfInBufImag_F[addrshift + 1 + slotOffset][ts2];
|
|
gammaVecReal_m[0] +=
|
(fMult(factors[ts2 % 4], tmpReal_F) -
|
fMult(factors[(ts2 + 1) % 4], tmpImag_F)) >>
|
1;
|
gammaVecImag_m[0] +=
|
(fMult(factors[(ts2 + 1) % 4], tmpReal_F) +
|
fMult(factors[ts2 % 4], tmpImag_F)) >>
|
1;
|
|
} else /* (mTr == 2) */
|
{
|
sign = 1;
|
Tcenter = mTr; /* opposite phase power parameters as ts2 is
|
center */
|
Tvec = stretch - mTr;
|
|
gammaCenterReal_m[0] =
|
hQmfTransposer->qmfInBufReal_F[slotOffset][ts2];
|
gammaCenterImag_m[0] =
|
hQmfTransposer->qmfInBufImag_F[slotOffset][ts2];
|
gammaVecReal_m[1] =
|
hQmfTransposer->qmfInBufReal_F[slotOffset][ts1];
|
gammaVecImag_m[1] =
|
hQmfTransposer->qmfInBufImag_F[slotOffset][ts1];
|
|
addrshift = -2;
|
tmpReal_F =
|
hQmfTransposer
|
->qmfInBufReal_F[addrshift + slotOffset][ts1];
|
tmpImag_F =
|
hQmfTransposer
|
->qmfInBufImag_F[addrshift + slotOffset][ts1];
|
|
gammaVecReal_m[0] =
|
(fMult(factors[ts1 % 4], tmpReal_F) -
|
fMult(factors[(ts1 + 3) % 4], tmpImag_F)) >>
|
1;
|
gammaVecImag_m[0] =
|
(fMult(factors[(ts1 + 3) % 4], tmpReal_F) +
|
fMult(factors[ts1 % 4], tmpImag_F)) >>
|
1;
|
|
tmpReal_F =
|
hQmfTransposer
|
->qmfInBufReal_F[addrshift + 1 + slotOffset][ts1];
|
tmpImag_F =
|
hQmfTransposer
|
->qmfInBufImag_F[addrshift + 1 + slotOffset][ts1];
|
|
gammaVecReal_m[0] +=
|
(fMult(factors[ts1 % 4], tmpReal_F) -
|
fMult(factors[(ts1 + 1) % 4], tmpImag_F)) >>
|
1;
|
gammaVecImag_m[0] +=
|
(fMult(factors[(ts1 + 1) % 4], tmpReal_F) +
|
fMult(factors[ts1 % 4], tmpImag_F)) >>
|
1;
|
}
|
|
gammaCenter_e[0] = gammaVec_e[1] = SCALE2EXP(
|
-hQmfTransposer->HBEAnalysiscQMF.outScalefactor);
|
gammaVec_e[0] =
|
SCALE2EXP(
|
-hQmfTransposer->HBEAnalysiscQMF.outScalefactor) +
|
1;
|
}
|
break;
|
default:
|
FDK_ASSERT(0);
|
break;
|
} /* stretch cases */
|
|
/* parameter controlled phase modification parts */
|
/* maximum *_e == 20 */
|
calculateCenterFIXP(gammaCenterReal_m[0], gammaCenterImag_m[0],
|
&gammaCenterReal_m[0], &gammaCenterImag_m[0],
|
&gammaCenter_e[0], stretch, Tcenter - 1);
|
calculateCenterFIXP(gammaVecReal_m[0], gammaVecImag_m[0],
|
&gammaVecReal_m[0], &gammaVecImag_m[0],
|
&gammaVec_e[0], stretch, Tvec - 1);
|
calculateCenterFIXP(gammaVecReal_m[1], gammaVecImag_m[1],
|
&gammaVecReal_m[1], &gammaVecImag_m[1],
|
&gammaVec_e[1], stretch, Tvec - 1);
|
|
/* Final multiplication of prepared parts */
|
for (k = 0; k < 2; k++) {
|
gammaOutReal_m[k] =
|
fMultDiv2(gammaVecReal_m[k], gammaCenterReal_m[0]) -
|
fMultDiv2(gammaVecImag_m[k], gammaCenterImag_m[0]);
|
gammaOutImag_m[k] =
|
fMultDiv2(gammaVecReal_m[k], gammaCenterImag_m[0]) +
|
fMultDiv2(gammaVecImag_m[k], gammaCenterReal_m[0]);
|
gammaOut_e[k] = gammaCenter_e[0] + gammaVec_e[k] + 1;
|
}
|
|
scaleUp(&gammaOutReal_m[0], &gammaOutImag_m[0], &gammaOut_e[0]);
|
scaleUp(&gammaOutReal_m[1], &gammaOutImag_m[1], &gammaOut_e[1]);
|
FDK_ASSERT(gammaOut_e[0] >= 0);
|
FDK_ASSERT(gammaOut_e[0] < 32);
|
|
tmpReal_m = gammaOutReal_m[0];
|
tmpImag_m = gammaOutImag_m[0];
|
|
INT modstretch4 = ((stretch == 4) && (mTr == 2));
|
|
FIXP_DBL cos_twid = twid_m_new[stretch - 2 - modstretch4][0];
|
FIXP_DBL sin_twid = sign * twid_m_new[stretch - 2 - modstretch4][1];
|
|
gammaOutReal_m[0] =
|
fMult(tmpReal_m, cos_twid) -
|
fMult(tmpImag_m, sin_twid); /* sum should be <= 1 because of
|
sin/cos multiplication */
|
gammaOutImag_m[0] =
|
fMult(tmpImag_m, cos_twid) +
|
fMult(tmpReal_m, sin_twid); /* sum should be <= 1 because of
|
sin/cos multiplication */
|
|
/* wingain */
|
for (k = 0; k < 2; k++) {
|
gammaOutReal_m[k] = (fMult(gammaOutReal_m[k], wingain) << 1);
|
gammaOutImag_m[k] = (fMult(gammaOutImag_m[k], wingain) << 1);
|
}
|
|
gammaOutReal_m[1] >>= 1;
|
gammaOutImag_m[1] >>= 1;
|
gammaOut_e[0] += 2;
|
gammaOut_e[1] += 2;
|
|
/* OLA including window scaling by wingain/3 */
|
for (k = 0; k < 2; k++) /* need k=1 to correspond to
|
grainModImag[slotOffset] -> out to
|
j*2+(slotOffset-offset) */
|
{
|
hQmfTransposer->qmfHBEBufReal_F[(k + slotOffset - 1)][band] +=
|
gammaOutReal_m[k] >> (scale_factor_hbe - gammaOut_e[k]);
|
hQmfTransposer->qmfHBEBufImag_F[(k + slotOffset - 1)][band] +=
|
gammaOutImag_m[k] >> (scale_factor_hbe - gammaOut_e[k]);
|
}
|
} /* mVal > qThrQMF * qThrQMF * sqmag0 && ts1 > 0 && ts2 < 64 */
|
} /* p >= pmin */
|
} /* for band */
|
} /* for stretch */
|
|
for (i = 0; i < QMF_WIN_LEN - 1; i++) {
|
FDKmemcpy(hQmfTransposer->qmfInBufReal_F[i],
|
hQmfTransposer->qmfInBufReal_F[i + 1],
|
sizeof(FIXP_DBL) * hQmfTransposer->HBEAnalysiscQMF.no_channels);
|
FDKmemcpy(hQmfTransposer->qmfInBufImag_F[i],
|
hQmfTransposer->qmfInBufImag_F[i + 1],
|
sizeof(FIXP_DBL) * hQmfTransposer->HBEAnalysiscQMF.no_channels);
|
}
|
|
if (keepStatesSyncedMode != KEEP_STATES_SYNCED_NOOUT) {
|
if (2 * j >= offset) {
|
/* copy first two slots of internal buffer to output */
|
if (keepStatesSyncedMode == KEEP_STATES_SYNCED_OUTDIFF) {
|
for (i = 0; i < 2; i++) {
|
FDKmemcpy(&ppQmfBufferOutReal_F[2 * j - offset + i]
|
[hQmfTransposer->xOverQmf[0]],
|
&hQmfTransposer
|
->qmfHBEBufReal_F[i][hQmfTransposer->xOverQmf[0]],
|
(QMF_SYNTH_CHANNELS - hQmfTransposer->xOverQmf[0]) *
|
sizeof(FIXP_DBL));
|
FDKmemcpy(&ppQmfBufferOutImag_F[2 * j - offset + i]
|
[hQmfTransposer->xOverQmf[0]],
|
&hQmfTransposer
|
->qmfHBEBufImag_F[i][hQmfTransposer->xOverQmf[0]],
|
(QMF_SYNTH_CHANNELS - hQmfTransposer->xOverQmf[0]) *
|
sizeof(FIXP_DBL));
|
}
|
} else {
|
for (i = 0; i < 2; i++) {
|
FDKmemcpy(&ppQmfBufferOutReal_F[2 * j + i + ov_len]
|
[hQmfTransposer->xOverQmf[0]],
|
&hQmfTransposer
|
->qmfHBEBufReal_F[i][hQmfTransposer->xOverQmf[0]],
|
(QMF_SYNTH_CHANNELS - hQmfTransposer->xOverQmf[0]) *
|
sizeof(FIXP_DBL));
|
FDKmemcpy(&ppQmfBufferOutImag_F[2 * j + i + ov_len]
|
[hQmfTransposer->xOverQmf[0]],
|
&hQmfTransposer
|
->qmfHBEBufImag_F[i][hQmfTransposer->xOverQmf[0]],
|
(QMF_SYNTH_CHANNELS - hQmfTransposer->xOverQmf[0]) *
|
sizeof(FIXP_DBL));
|
}
|
}
|
}
|
}
|
|
/* move slots up */
|
for (i = 0; i < HBE_MAX_OUT_SLOTS - 2; i++) {
|
FDKmemcpy(
|
&hQmfTransposer->qmfHBEBufReal_F[i][hQmfTransposer->xOverQmf[0]],
|
&hQmfTransposer->qmfHBEBufReal_F[i + 2][hQmfTransposer->xOverQmf[0]],
|
(QMF_SYNTH_CHANNELS - hQmfTransposer->xOverQmf[0]) *
|
sizeof(FIXP_DBL));
|
FDKmemcpy(
|
&hQmfTransposer->qmfHBEBufImag_F[i][hQmfTransposer->xOverQmf[0]],
|
&hQmfTransposer->qmfHBEBufImag_F[i + 2][hQmfTransposer->xOverQmf[0]],
|
(QMF_SYNTH_CHANNELS - hQmfTransposer->xOverQmf[0]) *
|
sizeof(FIXP_DBL));
|
}
|
|
/* finally set last two slot to zero */
|
for (i = 0; i < 2; i++) {
|
FDKmemset(&hQmfTransposer->qmfHBEBufReal_F[HBE_MAX_OUT_SLOTS - 1 - i]
|
[hQmfTransposer->xOverQmf[0]],
|
0,
|
(QMF_SYNTH_CHANNELS - hQmfTransposer->xOverQmf[0]) *
|
sizeof(FIXP_DBL));
|
FDKmemset(&hQmfTransposer->qmfHBEBufImag_F[HBE_MAX_OUT_SLOTS - 1 - i]
|
[hQmfTransposer->xOverQmf[0]],
|
0,
|
(QMF_SYNTH_CHANNELS - hQmfTransposer->xOverQmf[0]) *
|
sizeof(FIXP_DBL));
|
}
|
} /* qmfVocoderColsIn */
|
|
if (keepStatesSyncedMode != KEEP_STATES_SYNCED_NOOUT) {
|
if (keepStatesSyncedMode == KEEP_STATES_SYNCED_OUTDIFF) {
|
for (i = 0; i < ov_len + LPC_ORDER; i++) {
|
for (band = hQmfTransposer->startBand; band < hQmfTransposer->stopBand;
|
band++) {
|
FIXP_DBL tmpR = ppQmfBufferOutReal_F[i][band];
|
FIXP_DBL tmpI = ppQmfBufferOutImag_F[i][band];
|
|
ppQmfBufferOutReal_F[i][band] =
|
fMult(tmpR, cos_F[band]) -
|
fMult(tmpI, (-cos_F[64 - band - 1])); /* sum should be <= 1
|
because of sin/cos
|
multiplication */
|
ppQmfBufferOutImag_F[i][band] =
|
fMult(tmpR, (-cos_F[64 - band - 1])) +
|
fMult(tmpI, cos_F[band]); /* sum should by <= 1 because of sin/cos
|
multiplication */
|
}
|
}
|
} else {
|
for (i = offset; i < hQmfTransposer->noCols; i++) {
|
for (band = hQmfTransposer->startBand; band < hQmfTransposer->stopBand;
|
band++) {
|
FIXP_DBL tmpR = ppQmfBufferOutReal_F[i + ov_len][band];
|
FIXP_DBL tmpI = ppQmfBufferOutImag_F[i + ov_len][band];
|
|
ppQmfBufferOutReal_F[i + ov_len][band] =
|
fMult(tmpR, cos_F[band]) -
|
fMult(tmpI, (-cos_F[64 - band - 1])); /* sum should be <= 1
|
because of sin/cos
|
multiplication */
|
ppQmfBufferOutImag_F[i + ov_len][band] =
|
fMult(tmpR, (-cos_F[64 - band - 1])) +
|
fMult(tmpI, cos_F[band]); /* sum should by <= 1 because of sin/cos
|
multiplication */
|
}
|
}
|
}
|
}
|
|
*scale_hb = EXP2SCALE(scale_factor_hbe);
|
}
|
|
int* GetxOverBandQmfTransposer(HANDLE_HBE_TRANSPOSER hQmfTransposer) {
|
if (hQmfTransposer)
|
return hQmfTransposer->xOverQmf;
|
else
|
return NULL;
|
}
|
|
int Get41SbrQmfTransposer(HANDLE_HBE_TRANSPOSER hQmfTransposer) {
|
if (hQmfTransposer != NULL)
|
return hQmfTransposer->bSbr41;
|
else
|
return 0;
|
}
|
