summaryrefslogtreecommitdiffstats
path: root/libAACenc/src
diff options
context:
space:
mode:
authorMatthias P. Braendli <matthias.braendli@mpb.li>2016-09-10 20:15:44 +0200
committerMatthias P. Braendli <matthias.braendli@mpb.li>2016-09-10 20:15:44 +0200
commit14c7b800eaa23e9da7c92c7c4df397d0c191f097 (patch)
treed840b6ec41ff74d1184ca1dcd7731d08f1e9ebbb /libAACenc/src
parent78a801e4d716c6f2403cc56cf6c5b6f138f24b2f (diff)
downloadODR-AudioEnc-14c7b800eaa23e9da7c92c7c4df397d0c191f097.tar.gz
ODR-AudioEnc-14c7b800eaa23e9da7c92c7c4df397d0c191f097.tar.bz2
ODR-AudioEnc-14c7b800eaa23e9da7c92c7c4df397d0c191f097.zip
Remove FDK-AAC
Diffstat (limited to 'libAACenc/src')
-rw-r--r--libAACenc/src/aacEnc_ram.cpp194
-rw-r--r--libAACenc/src/aacEnc_ram.h226
-rw-r--r--libAACenc/src/aacEnc_rom.cpp1232
-rw-r--r--libAACenc/src/aacEnc_rom.h203
-rw-r--r--libAACenc/src/aacenc.cpp1081
-rw-r--r--libAACenc/src/aacenc.h323
-rw-r--r--libAACenc/src/aacenc_hcr.cpp93
-rw-r--r--libAACenc/src/aacenc_hcr.h96
-rw-r--r--libAACenc/src/aacenc_lib.cpp2186
-rw-r--r--libAACenc/src/aacenc_pns.cpp591
-rw-r--r--libAACenc/src/aacenc_pns.h113
-rw-r--r--libAACenc/src/aacenc_tns.cpp1370
-rw-r--r--libAACenc/src/aacenc_tns.h198
-rw-r--r--libAACenc/src/adj_thr.cpp2631
-rw-r--r--libAACenc/src/adj_thr.h147
-rw-r--r--libAACenc/src/adj_thr_data.h150
-rw-r--r--libAACenc/src/band_nrg.cpp359
-rw-r--r--libAACenc/src/band_nrg.h149
-rw-r--r--libAACenc/src/bandwidth.cpp381
-rw-r--r--libAACenc/src/bandwidth.h106
-rw-r--r--libAACenc/src/bit_cnt.cpp1122
-rw-r--r--libAACenc/src/bit_cnt.h187
-rw-r--r--libAACenc/src/bitenc.cpp1508
-rw-r--r--libAACenc/src/bitenc.h183
-rw-r--r--libAACenc/src/block_switch.cpp545
-rw-r--r--libAACenc/src/block_switch.h146
-rw-r--r--libAACenc/src/channel_map.cpp566
-rw-r--r--libAACenc/src/channel_map.h132
-rw-r--r--libAACenc/src/chaosmeasure.cpp161
-rw-r--r--libAACenc/src/chaosmeasure.h103
-rw-r--r--libAACenc/src/dyn_bits.cpp807
-rw-r--r--libAACenc/src/dyn_bits.h167
-rw-r--r--libAACenc/src/grp_data.cpp272
-rw-r--r--libAACenc/src/grp_data.h115
-rw-r--r--libAACenc/src/intensity.cpp761
-rw-r--r--libAACenc/src/intensity.h122
-rw-r--r--libAACenc/src/interface.h169
-rw-r--r--libAACenc/src/line_pe.cpp209
-rw-r--r--libAACenc/src/line_pe.h139
-rw-r--r--libAACenc/src/metadata_compressor.cpp1038
-rw-r--r--libAACenc/src/metadata_compressor.h252
-rw-r--r--libAACenc/src/metadata_main.cpp871
-rw-r--r--libAACenc/src/metadata_main.h224
-rw-r--r--libAACenc/src/ms_stereo.cpp251
-rw-r--r--libAACenc/src/ms_stereo.h107
-rw-r--r--libAACenc/src/noisedet.cpp228
-rw-r--r--libAACenc/src/noisedet.h108
-rw-r--r--libAACenc/src/pns_func.h150
-rw-r--r--libAACenc/src/pnsparam.cpp308
-rw-r--r--libAACenc/src/pnsparam.h141
-rw-r--r--libAACenc/src/pre_echo_control.cpp170
-rw-r--r--libAACenc/src/pre_echo_control.h114
-rw-r--r--libAACenc/src/psy_configuration.cpp828
-rw-r--r--libAACenc/src/psy_configuration.h165
-rw-r--r--libAACenc/src/psy_const.h161
-rw-r--r--libAACenc/src/psy_data.h152
-rw-r--r--libAACenc/src/psy_main.cpp1380
-rw-r--r--libAACenc/src/psy_main.h174
-rw-r--r--libAACenc/src/qc_data.h278
-rw-r--r--libAACenc/src/qc_main.cpp1644
-rw-r--r--libAACenc/src/qc_main.h170
-rw-r--r--libAACenc/src/quantize.cpp395
-rw-r--r--libAACenc/src/quantize.h119
-rw-r--r--libAACenc/src/sf_estim.cpp1301
-rw-r--r--libAACenc/src/sf_estim.h117
-rw-r--r--libAACenc/src/spreading.cpp114
-rw-r--r--libAACenc/src/spreading.h102
-rw-r--r--libAACenc/src/tns_func.h144
-rw-r--r--libAACenc/src/tonality.cpp204
-rw-r--r--libAACenc/src/tonality.h108
-rw-r--r--libAACenc/src/transform.cpp264
-rw-r--r--libAACenc/src/transform.h123
72 files changed, 0 insertions, 31148 deletions
diff --git a/libAACenc/src/aacEnc_ram.cpp b/libAACenc/src/aacEnc_ram.cpp
deleted file mode 100644
index be3eea2..0000000
--- a/libAACenc/src/aacEnc_ram.cpp
+++ /dev/null
@@ -1,194 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************************************************************
-
- Initial authors: M. Lohwasser, M. Gayer
- Contents/description:
-
-******************************************************************************/
-/*!
- \file
- \brief Memory layout
- \author Markus Lohwasser
-*/
-
-#include "aacEnc_ram.h"
-
- C_AALLOC_MEM (AACdynamic_RAM, FIXP_DBL, AAC_ENC_DYN_RAM_SIZE/sizeof(FIXP_DBL))
-
-/*
- Static memory areas, must not be overwritten in other sections of the decoder !
-*/
-
-/*
- The structure AacEncoder contains all Encoder structures.
-*/
-
-C_ALLOC_MEM (Ram_aacEnc_AacEncoder, AAC_ENC, 1)
-
-
-/*
- The structure PSY_INTERNAl contains all psych configuration and data pointer.
- * PsyStatic holds last and current Psych data.
- * PsyInputBuffer contains time input. Signal is needed at the beginning of Psych.
- Memory can be reused after signal is in time domain.
- * PsyData contains spectral, nrg and threshold information. Necessary data are
- copied into PsyOut, so memory is available after leaving psych.
- * TnsData, ChaosMeasure, PnsData are temporarily necessary, e.g. use memory from
- PsyInputBuffer.
-*/
-
-C_ALLOC_MEM2 (Ram_aacEnc_PsyElement, PSY_ELEMENT, 1, (8))
-
-C_ALLOC_MEM (Ram_aacEnc_PsyInternal, PSY_INTERNAL, 1)
-C_ALLOC_MEM2 (Ram_aacEnc_PsyStatic, PSY_STATIC, 1, (8))
-
-C_ALLOC_MEM2 (Ram_aacEnc_PsyInputBuffer, INT_PCM, MAX_INPUT_BUFFER_SIZE, (8))
-
- PSY_DYNAMIC *GetRam_aacEnc_PsyDynamic (int n, UCHAR* dynamic_RAM) {
- FDK_ASSERT(dynamic_RAM!=0);
- return ((PSY_DYNAMIC*) (dynamic_RAM + P_BUF_1 + n*sizeof(PSY_DYNAMIC)));
- }
-
- C_ALLOC_MEM (Ram_bsOutbuffer, UCHAR, OUTPUTBUFFER_SIZE)
-
-/*
- The structure PSY_OUT holds all psychoaccoustic data needed
- in quantization module
-*/
-C_ALLOC_MEM2 (Ram_aacEnc_PsyOut, PSY_OUT, 1, (1))
-
-C_ALLOC_MEM2 (Ram_aacEnc_PsyOutElements, PSY_OUT_ELEMENT, 1, (1)*(8))
-C_ALLOC_MEM2 (Ram_aacEnc_PsyOutChannel, PSY_OUT_CHANNEL, 1, (1)*(8))
-
-
-/*
- The structure QC_STATE contains preinitialized settings and quantizer structures.
- * AdjustThreshold structure contains element-wise settings.
- * ElementBits contains elemnt-wise bit consumption settings.
- * When CRC is active, lookup table is necessary for fast crc calculation.
- * Bitcounter contains buffer to find optimal codebooks and minimal bit consumption.
- Values are temporarily, so dynamic memory can be used.
-*/
-
-C_ALLOC_MEM (Ram_aacEnc_QCstate, QC_STATE, 1)
-C_ALLOC_MEM (Ram_aacEnc_AdjustThreshold, ADJ_THR_STATE, 1)
-
-C_ALLOC_MEM2 (Ram_aacEnc_AdjThrStateElement, ATS_ELEMENT, 1, (8))
-C_ALLOC_MEM2 (Ram_aacEnc_ElementBits, ELEMENT_BITS, 1, (8))
-C_ALLOC_MEM (Ram_aacEnc_BitCntrState, BITCNTR_STATE, 1)
-
- INT *GetRam_aacEnc_BitLookUp(int n, UCHAR* dynamic_RAM) {
- FDK_ASSERT(dynamic_RAM!=0);
- return ((INT*) (dynamic_RAM + P_BUF_1));
- }
- INT *GetRam_aacEnc_MergeGainLookUp(int n, UCHAR* dynamic_RAM) {
- FDK_ASSERT(dynamic_RAM!=0);
- return ((INT*) (dynamic_RAM + P_BUF_1 + sizeof(INT)*(MAX_SFB_LONG*(CODE_BOOK_ESC_NDX+1))));
- }
-
-
-/*
- The structure QC_OUT contains settings and structures holding all necessary information
- needed in bitstreamwriter.
-*/
-
-C_ALLOC_MEM2 (Ram_aacEnc_QCout, QC_OUT, 1, (1))
-C_ALLOC_MEM2 (Ram_aacEnc_QCelement, QC_OUT_ELEMENT, (1), (8))
- QC_OUT_CHANNEL *GetRam_aacEnc_QCchannel (int n, UCHAR* dynamic_RAM) {
- FDK_ASSERT(dynamic_RAM!=0);
- return ((QC_OUT_CHANNEL*) (dynamic_RAM + P_BUF_0 + n*sizeof(QC_OUT_CHANNEL)));
- }
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/libAACenc/src/aacEnc_ram.h b/libAACenc/src/aacEnc_ram.h
deleted file mode 100644
index cf7da7c..0000000
--- a/libAACenc/src/aacEnc_ram.h
+++ /dev/null
@@ -1,226 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************************************************************
-
- Initial authors: M. Lohwasser, M. Gayer
- Contents/description:
-
-******************************************************************************/
-
-/*!
- \file
- \brief Memory layout
- \author Markus Lohwasser
-*/
-
-#ifndef AAC_ENC_RAM_H
-#define AAC_ENC_RAM_H
-
-#include "common_fix.h"
-
-#include "aacenc.h"
-#include "psy_data.h"
-#include "interface.h"
-#include "psy_main.h"
-#include "bitenc.h"
-#include "bit_cnt.h"
-#include "psy_const.h"
-
- #define OUTPUTBUFFER_SIZE (8192) /*!< Output buffer size has to be at least 6144 bits per channel (768 bytes). FDK bitbuffer implementation expects buffer of size 2^n. */
-
-
-/*
- Moved AAC_ENC struct definition from aac_enc.cpp into aacEnc_ram.h to get size and respective
- static memory in aacEnc_ram.cpp.
- aac_enc.h is the outward visible header file and putting the struct into would cause necessity
- of additional visible header files outside library.
-*/
-
-/* define hBitstream size: max AAC framelength is 6144 bits/channel */
-/*#define BUFFER_BITSTR_SIZE ((6400*(8)/bbWordSize) +((bbWordSize - 1) / bbWordSize))*/
-
-struct AAC_ENC {
-
- AACENC_CONFIG *config;
-
- INT ancillaryBitsPerFrame; /* ancillary bits per frame calculated from ancillary rate */
-
- CHANNEL_MAPPING channelMapping;
-
- QC_STATE *qcKernel;
- QC_OUT *qcOut[(1)];
-
- PSY_OUT *psyOut[(1)];
- PSY_INTERNAL *psyKernel;
-
- /* lifetime vars */
-
- CHANNEL_MODE encoderMode;
- INT bandwidth90dB;
- AACENC_BITRATE_MODE bitrateMode;
-
- INT dontWriteAdif; /* use: write ADIF header only before 1st frame */
-
- FIXP_DBL *dynamic_RAM;
-
-
- INT maxChannels; /* used while allocation */
- INT maxElements;
- INT maxFrames;
-
- AUDIO_OBJECT_TYPE aot; /* AOT to be used while encoding. */
-
-} ;
-
-#define maxSize(a,b) ( ((a)>(b)) ? (a) : (b) )
-
-#define BIT_LOOK_UP_SIZE ( sizeof(INT)*(MAX_SFB_LONG*(CODE_BOOK_ESC_NDX+1)) )
-#define MERGE_GAIN_LOOK_UP_SIZE ( sizeof(INT)*MAX_SFB_LONG )
-
-
-
-/* Dynamic RAM - Allocation */
-/*
- ++++++++++++++++++++++++++++++++++++++++++++
- | P_BUF_0 | P_BUF_1 |
- ++++++++++++++++++++++++++++++++++++++++++++
- | QC_OUT_CH | PSY_DYN |
- ++++++++++++++++++++++++++++++++++++++++++++
- | | BitLookUp+MergeGainLookUp |
- ++++++++++++++++++++++++++++++++++++++++++++
- | | Bitstream output buffer |
- ++++++++++++++++++++++++++++++++++++++++++++
-*/
-
-#define BUF_SIZE_0 ( ALIGN_SIZE(sizeof(QC_OUT_CHANNEL)*(8)) )
-#define BUF_SIZE_1 ( ALIGN_SIZE(maxSize(sizeof(PSY_DYNAMIC), \
- (BIT_LOOK_UP_SIZE+MERGE_GAIN_LOOK_UP_SIZE))) )
-
-#define P_BUF_0 ( 0 )
-#define P_BUF_1 ( P_BUF_0 + BUF_SIZE_0 )
-
-#define AAC_ENC_DYN_RAM_SIZE ( BUF_SIZE_0 + BUF_SIZE_1 )
-
-
- H_ALLOC_MEM (AACdynamic_RAM, FIXP_DBL)
-/*
- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-END - Dynamic RAM - Allocation */
-
-/*
- See further Memory Allocation details in aacEnc_ram.cpp
-*/
- H_ALLOC_MEM (Ram_aacEnc_AacEncoder, AAC_ENC)
-
- H_ALLOC_MEM (Ram_aacEnc_PsyElement, PSY_ELEMENT)
-
- H_ALLOC_MEM (Ram_aacEnc_PsyInternal, PSY_INTERNAL)
- H_ALLOC_MEM (Ram_aacEnc_PsyStatic, PSY_STATIC)
- H_ALLOC_MEM (Ram_aacEnc_PsyInputBuffer, INT_PCM)
-
- PSY_DYNAMIC *GetRam_aacEnc_PsyDynamic (int n, UCHAR* dynamic_RAM);
- H_ALLOC_MEM (Ram_bsOutbuffer, UCHAR)
-
- H_ALLOC_MEM (Ram_aacEnc_PsyOutChannel, PSY_OUT_CHANNEL)
-
- H_ALLOC_MEM (Ram_aacEnc_PsyOut, PSY_OUT)
- H_ALLOC_MEM (Ram_aacEnc_PsyOutElements, PSY_OUT_ELEMENT)
-
- H_ALLOC_MEM (Ram_aacEnc_QCstate, QC_STATE)
- H_ALLOC_MEM (Ram_aacEnc_AdjustThreshold, ADJ_THR_STATE)
-
- H_ALLOC_MEM (Ram_aacEnc_AdjThrStateElement, ATS_ELEMENT)
- H_ALLOC_MEM (Ram_aacEnc_ElementBits, ELEMENT_BITS)
- H_ALLOC_MEM (Ram_aacEnc_BitCntrState, BITCNTR_STATE)
-
- INT *GetRam_aacEnc_BitLookUp(int n, UCHAR* dynamic_RAM);
- INT *GetRam_aacEnc_MergeGainLookUp(int n, UCHAR* dynamic_RAM);
- QC_OUT_CHANNEL *GetRam_aacEnc_QCchannel (int n, UCHAR* dynamic_RAM);
-
- H_ALLOC_MEM (Ram_aacEnc_QCout, QC_OUT)
- H_ALLOC_MEM (Ram_aacEnc_QCelement, QC_OUT_ELEMENT)
-
-
-#endif /* #ifndef AAC_ENC_RAM_H */
-
diff --git a/libAACenc/src/aacEnc_rom.cpp b/libAACenc/src/aacEnc_rom.cpp
deleted file mode 100644
index 0cdf5fe..0000000
--- a/libAACenc/src/aacEnc_rom.cpp
+++ /dev/null
@@ -1,1232 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************************************************************
-
- Initial authors: M. Lohwasser, M. Gayer
- Contents/description:
-
-******************************************************************************/
-
-#include "aacEnc_rom.h"
-
-/*
- Huffman Tables
-*/
-const INT FDKaacEnc_huff_ltab1_2[3][3][3][3]=
-{
- {
- { {0x000b0009,0x00090007,0x000b0009}, {0x000a0008,0x00070006,0x000a0008}, {0x000b0009,0x00090008,0x000b0009} },
- { {0x000a0008,0x00070006,0x000a0007}, {0x00070006,0x00050005,0x00070006}, {0x00090007,0x00070006,0x000a0008} },
- { {0x000b0009,0x00090007,0x000b0008}, {0x00090008,0x00070006,0x00090008}, {0x000b0009,0x00090007,0x000b0009} }
- },
- {
- { {0x00090008,0x00070006,0x00090007}, {0x00070006,0x00050005,0x00070006}, {0x00090007,0x00070006,0x00090008} },
- { {0x00070006,0x00050005,0x00070006}, {0x00050005,0x00010003,0x00050005}, {0x00070006,0x00050005,0x00070006} },
- { {0x00090008,0x00070006,0x00090007}, {0x00070006,0x00050005,0x00070006}, {0x00090008,0x00070006,0x00090008} }
- },
- {
- { {0x000b0009,0x00090007,0x000b0009}, {0x00090008,0x00070006,0x00090008}, {0x000b0008,0x00090007,0x000b0009} },
- { {0x000a0008,0x00070006,0x00090007}, {0x00070006,0x00050004,0x00070006}, {0x00090008,0x00070006,0x000a0007} },
- { {0x000b0009,0x00090007,0x000b0009}, {0x000a0007,0x00070006,0x00090008}, {0x000b0009,0x00090007,0x000b0009} }
- }
-};
-
-
-const INT FDKaacEnc_huff_ltab3_4[3][3][3][3]=
-{
- {
- { {0x00010004,0x00040005,0x00080008}, {0x00040005,0x00050004,0x00080008}, {0x00090009,0x00090008,0x000a000b} },
- { {0x00040005,0x00060005,0x00090008}, {0x00060005,0x00060004,0x00090008}, {0x00090008,0x00090007,0x000a000a} },
- { {0x00090009,0x000a0008,0x000d000b}, {0x00090008,0x00090008,0x000b000a}, {0x000b000b,0x000a000a,0x000c000b} }
- },
- {
- { {0x00040004,0x00060005,0x000a0008}, {0x00060004,0x00070004,0x000a0008}, {0x000a0008,0x000a0008,0x000c000a} },
- { {0x00050004,0x00070004,0x000b0008}, {0x00060004,0x00070004,0x000a0007}, {0x00090008,0x00090007,0x000b0009} },
- { {0x00090008,0x000a0008,0x000d000a}, {0x00080007,0x00090007,0x000c0009}, {0x000a000a,0x000b0009,0x000c000a} }
- },
- {
- { {0x00080008,0x000a0008,0x000f000b}, {0x00090008,0x000b0007,0x000f000a}, {0x000d000b,0x000e000a,0x0010000c} },
- { {0x00080008,0x000a0007,0x000e000a}, {0x00090007,0x000a0007,0x000e0009}, {0x000c000a,0x000c0009,0x000f000b} },
- { {0x000b000b,0x000c000a,0x0010000c}, {0x000a000a,0x000b0009,0x000f000b}, {0x000c000b,0x000c000a,0x000f000b} }
- }
-};
-
-const INT FDKaacEnc_huff_ltab5_6[9][9]=
-{
- {0x000d000b, 0x000c000a, 0x000b0009, 0x000b0009, 0x000a0009, 0x000b0009, 0x000b0009, 0x000c000a, 0x000d000b},
- {0x000c000a, 0x000b0009, 0x000a0008, 0x00090007, 0x00080007, 0x00090007, 0x000a0008, 0x000b0009, 0x000c000a},
- {0x000c0009, 0x000a0008, 0x00090006, 0x00080006, 0x00070006, 0x00080006, 0x00090006, 0x000a0008, 0x000b0009},
- {0x000b0009, 0x00090007, 0x00080006, 0x00050004, 0x00040004, 0x00050004, 0x00080006, 0x00090007, 0x000b0009},
- {0x000a0009, 0x00080007, 0x00070006, 0x00040004, 0x00010004, 0x00040004, 0x00070006, 0x00080007, 0x000b0009},
- {0x000b0009, 0x00090007, 0x00080006, 0x00050004, 0x00040004, 0x00050004, 0x00080006, 0x00090007, 0x000b0009},
- {0x000b0009, 0x000a0008, 0x00090006, 0x00080006, 0x00070006, 0x00080006, 0x00090006, 0x000a0008, 0x000b0009},
- {0x000c000a, 0x000b0009, 0x000a0008, 0x00090007, 0x00080007, 0x00090007, 0x000a0007, 0x000b0008, 0x000c000a},
- {0x000d000b, 0x000c000a, 0x000c0009, 0x000b0009, 0x000a0009, 0x000a0009, 0x000b0009, 0x000c000a, 0x000d000b}
-};
-
-const INT FDKaacEnc_huff_ltab7_8[8][8]=
-{
- {0x00010005, 0x00030004, 0x00060005, 0x00070006, 0x00080007, 0x00090008, 0x000a0009, 0x000b000a},
- {0x00030004, 0x00040003, 0x00060004, 0x00070005, 0x00080006, 0x00080007, 0x00090007, 0x00090008},
- {0x00060005, 0x00060004, 0x00070004, 0x00080005, 0x00080006, 0x00090007, 0x00090007, 0x000a0008},
- {0x00070006, 0x00070005, 0x00080005, 0x00080006, 0x00090006, 0x00090007, 0x000a0008, 0x000a0008},
- {0x00080007, 0x00080006, 0x00090006, 0x00090006, 0x000a0007, 0x000a0007, 0x000a0008, 0x000b0009},
- {0x00090008, 0x00080007, 0x00090006, 0x00090007, 0x000a0007, 0x000a0008, 0x000b0008, 0x000b000a},
- {0x000a0009, 0x00090007, 0x00090007, 0x000a0008, 0x000a0008, 0x000b0008, 0x000c0009, 0x000c0009},
- {0x000b000a, 0x000a0008, 0x000a0008, 0x000a0008, 0x000b0009, 0x000b0009, 0x000c0009, 0x000c000a}
-};
-
-const INT FDKaacEnc_huff_ltab9_10[13][13]=
-{
- {0x00010006, 0x00030005, 0x00060006, 0x00080006, 0x00090007, 0x000a0008, 0x000a0009, 0x000b000a, 0x000b000a, 0x000c000a, 0x000c000b, 0x000d000b, 0x000d000c},
- {0x00030005, 0x00040004, 0x00060004, 0x00070005, 0x00080006, 0x00080007, 0x00090007, 0x000a0008, 0x000a0008, 0x000a0009, 0x000b000a, 0x000c000a, 0x000c000b},
- {0x00060006, 0x00060004, 0x00070005, 0x00080005, 0x00080006, 0x00090006, 0x000a0007, 0x000a0008, 0x000a0008, 0x000b0009, 0x000c0009, 0x000c000a, 0x000c000a},
- {0x00080006, 0x00070005, 0x00080005, 0x00090005, 0x00090006, 0x000a0007, 0x000a0007, 0x000b0008, 0x000b0008, 0x000b0009, 0x000c0009, 0x000c000a, 0x000d000a},
- {0x00090007, 0x00080006, 0x00090006, 0x00090006, 0x000a0006, 0x000a0007, 0x000b0007, 0x000b0008, 0x000b0008, 0x000c0009, 0x000c0009, 0x000c000a, 0x000d000a},
- {0x000a0008, 0x00090007, 0x00090006, 0x000a0007, 0x000b0007, 0x000b0007, 0x000b0008, 0x000c0008, 0x000b0008, 0x000c0009, 0x000c000a, 0x000d000a, 0x000d000b},
- {0x000b0009, 0x00090007, 0x000a0007, 0x000b0007, 0x000b0007, 0x000b0008, 0x000c0008, 0x000c0009, 0x000c0009, 0x000c0009, 0x000d000a, 0x000d000a, 0x000d000b},
- {0x000b0009, 0x000a0008, 0x000a0008, 0x000b0008, 0x000b0008, 0x000c0008, 0x000c0009, 0x000d0009, 0x000d0009, 0x000d000a, 0x000d000a, 0x000d000b, 0x000d000b},
- {0x000b0009, 0x000a0008, 0x000a0008, 0x000b0008, 0x000b0008, 0x000b0008, 0x000c0009, 0x000c0009, 0x000d000a, 0x000d000a, 0x000e000a, 0x000d000b, 0x000e000b},
- {0x000b000a, 0x000a0009, 0x000b0009, 0x000b0009, 0x000c0009, 0x000c0009, 0x000c0009, 0x000c000a, 0x000d000a, 0x000d000a, 0x000e000b, 0x000e000b, 0x000e000c},
- {0x000c000a, 0x000b0009, 0x000b0009, 0x000c0009, 0x000c0009, 0x000c000a, 0x000d000a, 0x000d000a, 0x000d000a, 0x000e000b, 0x000e000b, 0x000e000b, 0x000f000c},
- {0x000c000b, 0x000b000a, 0x000c0009, 0x000c000a, 0x000c000a, 0x000d000a, 0x000d000a, 0x000d000a, 0x000d000b, 0x000e000b, 0x000e000b, 0x000f000b, 0x000f000c},
- {0x000d000b, 0x000c000a, 0x000c000a, 0x000c000a, 0x000d000a, 0x000d000a, 0x000d000a, 0x000d000b, 0x000e000b, 0x000e000c, 0x000e000c, 0x000e000c, 0x000f000c}
-};
-
-const UCHAR FDKaacEnc_huff_ltab11[17][17]=
-{
- {0x04, 0x05, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0a, 0x0a, 0x0b, 0x0b, 0x0c, 0x0b, 0x0c, 0x0c, 0x0a},
- {0x05, 0x04, 0x05, 0x06, 0x07, 0x07, 0x08, 0x08, 0x09, 0x09, 0x09, 0x0a, 0x0a, 0x0a, 0x0a, 0x0b, 0x08},
- {0x06, 0x05, 0x05, 0x06, 0x07, 0x07, 0x08, 0x08, 0x08, 0x09, 0x09, 0x09, 0x0a, 0x0a, 0x0a, 0x0a, 0x08},
- {0x07, 0x06, 0x06, 0x06, 0x07, 0x07, 0x08, 0x08, 0x08, 0x09, 0x09, 0x09, 0x0a, 0x0a, 0x0a, 0x0a, 0x08},
- {0x08, 0x07, 0x07, 0x07, 0x07, 0x08, 0x08, 0x08, 0x08, 0x09, 0x09, 0x09, 0x0a, 0x0a, 0x0a, 0x0a, 0x08},
- {0x08, 0x07, 0x07, 0x07, 0x07, 0x08, 0x08, 0x08, 0x09, 0x09, 0x09, 0x09, 0x0a, 0x0a, 0x0a, 0x0a, 0x08},
- {0x09, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x09, 0x09, 0x09, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x08},
- {0x09, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x09, 0x09, 0x09, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x08},
- {0x0a, 0x09, 0x08, 0x08, 0x09, 0x09, 0x09, 0x09, 0x09, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0b, 0x08},
- {0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0b, 0x0b, 0x08},
- {0x0b, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0b, 0x0a, 0x0b, 0x0b, 0x08},
- {0x0b, 0x0a, 0x09, 0x09, 0x0a, 0x09, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x08},
- {0x0b, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x09},
- {0x0b, 0x0a, 0x09, 0x09, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x09},
- {0x0b, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x09},
- {0x0c, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0c, 0x0c, 0x09},
- {0x09, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x09, 0x05}
-};
-
-const UCHAR FDKaacEnc_huff_ltabscf[121]=
-{
- 0x12, 0x12, 0x12, 0x12, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
- 0x13, 0x13, 0x13, 0x12, 0x13, 0x12, 0x11, 0x11, 0x10, 0x11, 0x10, 0x10, 0x10, 0x10, 0x0f, 0x0f,
- 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0d, 0x0d, 0x0c, 0x0c, 0x0c, 0x0b, 0x0c, 0x0b, 0x0a, 0x0a,
- 0x0a, 0x09, 0x09, 0x08, 0x08, 0x08, 0x07, 0x06, 0x06, 0x05, 0x04, 0x03, 0x01, 0x04, 0x04, 0x05,
- 0x06, 0x06, 0x07, 0x07, 0x08, 0x08, 0x09, 0x09, 0x0a, 0x0a, 0x0a, 0x0b, 0x0b, 0x0b, 0x0b, 0x0c,
- 0x0c, 0x0d, 0x0d, 0x0d, 0x0e, 0x0e, 0x10, 0x0f, 0x10, 0x0f, 0x12, 0x13, 0x13, 0x13, 0x13, 0x13,
- 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
- 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13
-};
-
-
-const USHORT FDKaacEnc_huff_ctab1[3][3][3][3]=
-{
- {
- { {0x07f8,0x01f1,0x07fd}, {0x03f5,0x0068,0x03f0}, {0x07f7,0x01ec,0x07f5} },
- { {0x03f1,0x0072,0x03f4}, {0x0074,0x0011,0x0076}, {0x01eb,0x006c,0x03f6} },
- { {0x07fc,0x01e1,0x07f1}, {0x01f0,0x0061,0x01f6}, {0x07f2,0x01ea,0x07fb} }
- },
- {
- { {0x01f2,0x0069,0x01ed}, {0x0077,0x0017,0x006f}, {0x01e6,0x0064,0x01e5} },
- { {0x0067,0x0015,0x0062}, {0x0012,0x0000,0x0014}, {0x0065,0x0016,0x006d} },
- { {0x01e9,0x0063,0x01e4}, {0x006b,0x0013,0x0071}, {0x01e3,0x0070,0x01f3} }
- },
- {
- { {0x07fe,0x01e7,0x07f3}, {0x01ef,0x0060,0x01ee}, {0x07f0,0x01e2,0x07fa} },
- { {0x03f3,0x006a,0x01e8}, {0x0075,0x0010,0x0073}, {0x01f4,0x006e,0x03f7} },
- { {0x07f6,0x01e0,0x07f9}, {0x03f2,0x0066,0x01f5}, {0x07ff,0x01f7,0x07f4} }
- }
-};
-
-const USHORT FDKaacEnc_huff_ctab2[3][3][3][3]=
-{
- {
- { {0x01f3,0x006f,0x01fd}, {0x00eb,0x0023,0x00ea}, {0x01f7,0x00e8,0x01fa} },
- { {0x00f2,0x002d,0x0070}, {0x0020,0x0006,0x002b}, {0x006e,0x0028,0x00e9} },
- { {0x01f9,0x0066,0x00f8}, {0x00e7,0x001b,0x00f1}, {0x01f4,0x006b,0x01f5} }
- },
- {
- { {0x00ec,0x002a,0x006c}, {0x002c,0x000a,0x0027}, {0x0067,0x001a,0x00f5} },
- { {0x0024,0x0008,0x001f}, {0x0009,0x0000,0x0007}, {0x001d,0x000b,0x0030} },
- { {0x00ef,0x001c,0x0064}, {0x001e,0x000c,0x0029}, {0x00f3,0x002f,0x00f0} }
- },
- {
- { {0x01fc,0x0071,0x01f2}, {0x00f4,0x0021,0x00e6}, {0x00f7,0x0068,0x01f8} },
- { {0x00ee,0x0022,0x0065}, {0x0031,0x0002,0x0026}, {0x00ed,0x0025,0x006a} },
- { {0x01fb,0x0072,0x01fe}, {0x0069,0x002e,0x00f6}, {0x01ff,0x006d,0x01f6} }
- }
-};
-
-const USHORT FDKaacEnc_huff_ctab3[3][3][3][3]=
-{
- {
- { {0x0000,0x0009,0x00ef}, {0x000b,0x0019,0x00f0}, {0x01eb,0x01e6,0x03f2} },
- { {0x000a,0x0035,0x01ef}, {0x0034,0x0037,0x01e9}, {0x01ed,0x01e7,0x03f3} },
- { {0x01ee,0x03ed,0x1ffa}, {0x01ec,0x01f2,0x07f9}, {0x07f8,0x03f8,0x0ff8} }
- },
- {
- { {0x0008,0x0038,0x03f6}, {0x0036,0x0075,0x03f1}, {0x03eb,0x03ec,0x0ff4} },
- { {0x0018,0x0076,0x07f4}, {0x0039,0x0074,0x03ef}, {0x01f3,0x01f4,0x07f6} },
- { {0x01e8,0x03ea,0x1ffc}, {0x00f2,0x01f1,0x0ffb}, {0x03f5,0x07f3,0x0ffc} }
- },
- {
- { {0x00ee,0x03f7,0x7ffe}, {0x01f0,0x07f5,0x7ffd}, {0x1ffb,0x3ffa,0xffff} },
- { {0x00f1,0x03f0,0x3ffc}, {0x01ea,0x03ee,0x3ffb}, {0x0ff6,0x0ffa,0x7ffc} },
- { {0x07f2,0x0ff5,0xfffe}, {0x03f4,0x07f7,0x7ffb}, {0x0ff7,0x0ff9,0x7ffa} }
- }
-};
-
-const USHORT FDKaacEnc_huff_ctab4[3][3][3][3]=
-{
- {
- { {0x0007,0x0016,0x00f6}, {0x0018,0x0008,0x00ef}, {0x01ef,0x00f3,0x07f8} },
- { {0x0019,0x0017,0x00ed}, {0x0015,0x0001,0x00e2}, {0x00f0,0x0070,0x03f0} },
- { {0x01ee,0x00f1,0x07fa}, {0x00ee,0x00e4,0x03f2}, {0x07f6,0x03ef,0x07fd} }
- },
- {
- { {0x0005,0x0014,0x00f2}, {0x0009,0x0004,0x00e5}, {0x00f4,0x00e8,0x03f4} },
- { {0x0006,0x0002,0x00e7}, {0x0003,0x0000,0x006b}, {0x00e3,0x0069,0x01f3} },
- { {0x00eb,0x00e6,0x03f6}, {0x006e,0x006a,0x01f4}, {0x03ec,0x01f0,0x03f9} }
- },
- {
- { {0x00f5,0x00ec,0x07fb}, {0x00ea,0x006f,0x03f7}, {0x07f9,0x03f3,0x0fff} },
- { {0x00e9,0x006d,0x03f8}, {0x006c,0x0068,0x01f5}, {0x03ee,0x01f2,0x07f4} },
- { {0x07f7,0x03f1,0x0ffe}, {0x03ed,0x01f1,0x07f5}, {0x07fe,0x03f5,0x07fc} }
- }
-};
-const USHORT FDKaacEnc_huff_ctab5[9][9]=
-{
- {0x1fff, 0x0ff7, 0x07f4, 0x07e8, 0x03f1, 0x07ee, 0x07f9, 0x0ff8, 0x1ffd},
- {0x0ffd, 0x07f1, 0x03e8, 0x01e8, 0x00f0, 0x01ec, 0x03ee, 0x07f2, 0x0ffa},
- {0x0ff4, 0x03ef, 0x01f2, 0x00e8, 0x0070, 0x00ec, 0x01f0, 0x03ea, 0x07f3},
- {0x07eb, 0x01eb, 0x00ea, 0x001a, 0x0008, 0x0019, 0x00ee, 0x01ef, 0x07ed},
- {0x03f0, 0x00f2, 0x0073, 0x000b, 0x0000, 0x000a, 0x0071, 0x00f3, 0x07e9},
- {0x07ef, 0x01ee, 0x00ef, 0x0018, 0x0009, 0x001b, 0x00eb, 0x01e9, 0x07ec},
- {0x07f6, 0x03eb, 0x01f3, 0x00ed, 0x0072, 0x00e9, 0x01f1, 0x03ed, 0x07f7},
- {0x0ff6, 0x07f0, 0x03e9, 0x01ed, 0x00f1, 0x01ea, 0x03ec, 0x07f8, 0x0ff9},
- {0x1ffc, 0x0ffc, 0x0ff5, 0x07ea, 0x03f3, 0x03f2, 0x07f5, 0x0ffb, 0x1ffe}
-};
-
-const USHORT FDKaacEnc_huff_ctab6[9][9]=
-{
- {0x07fe, 0x03fd, 0x01f1, 0x01eb, 0x01f4, 0x01ea, 0x01f0, 0x03fc, 0x07fd},
- {0x03f6, 0x01e5, 0x00ea, 0x006c, 0x0071, 0x0068, 0x00f0, 0x01e6, 0x03f7},
- {0x01f3, 0x00ef, 0x0032, 0x0027, 0x0028, 0x0026, 0x0031, 0x00eb, 0x01f7},
- {0x01e8, 0x006f, 0x002e, 0x0008, 0x0004, 0x0006, 0x0029, 0x006b, 0x01ee},
- {0x01ef, 0x0072, 0x002d, 0x0002, 0x0000, 0x0003, 0x002f, 0x0073, 0x01fa},
- {0x01e7, 0x006e, 0x002b, 0x0007, 0x0001, 0x0005, 0x002c, 0x006d, 0x01ec},
- {0x01f9, 0x00ee, 0x0030, 0x0024, 0x002a, 0x0025, 0x0033, 0x00ec, 0x01f2},
- {0x03f8, 0x01e4, 0x00ed, 0x006a, 0x0070, 0x0069, 0x0074, 0x00f1, 0x03fa},
- {0x07ff, 0x03f9, 0x01f6, 0x01ed, 0x01f8, 0x01e9, 0x01f5, 0x03fb, 0x07fc}
-};
-
-const USHORT FDKaacEnc_huff_ctab7[8][8]=
-{
- {0x0000, 0x0005, 0x0037, 0x0074, 0x00f2, 0x01eb, 0x03ed, 0x07f7},
- {0x0004, 0x000c, 0x0035, 0x0071, 0x00ec, 0x00ee, 0x01ee, 0x01f5},
- {0x0036, 0x0034, 0x0072, 0x00ea, 0x00f1, 0x01e9, 0x01f3, 0x03f5},
- {0x0073, 0x0070, 0x00eb, 0x00f0, 0x01f1, 0x01f0, 0x03ec, 0x03fa},
- {0x00f3, 0x00ed, 0x01e8, 0x01ef, 0x03ef, 0x03f1, 0x03f9, 0x07fb},
- {0x01ed, 0x00ef, 0x01ea, 0x01f2, 0x03f3, 0x03f8, 0x07f9, 0x07fc},
- {0x03ee, 0x01ec, 0x01f4, 0x03f4, 0x03f7, 0x07f8, 0x0ffd, 0x0ffe},
- {0x07f6, 0x03f0, 0x03f2, 0x03f6, 0x07fa, 0x07fd, 0x0ffc, 0x0fff}
-};
-
-const USHORT FDKaacEnc_huff_ctab8[8][8]=
-{
- {0x000e, 0x0005, 0x0010, 0x0030, 0x006f, 0x00f1, 0x01fa, 0x03fe},
- {0x0003, 0x0000, 0x0004, 0x0012, 0x002c, 0x006a, 0x0075, 0x00f8},
- {0x000f, 0x0002, 0x0006, 0x0014, 0x002e, 0x0069, 0x0072, 0x00f5},
- {0x002f, 0x0011, 0x0013, 0x002a, 0x0032, 0x006c, 0x00ec, 0x00fa},
- {0x0071, 0x002b, 0x002d, 0x0031, 0x006d, 0x0070, 0x00f2, 0x01f9},
- {0x00ef, 0x0068, 0x0033, 0x006b, 0x006e, 0x00ee, 0x00f9, 0x03fc},
- {0x01f8, 0x0074, 0x0073, 0x00ed, 0x00f0, 0x00f6, 0x01f6, 0x01fd},
- {0x03fd, 0x00f3, 0x00f4, 0x00f7, 0x01f7, 0x01fb, 0x01fc, 0x03ff}
-};
-
-const USHORT FDKaacEnc_huff_ctab9[13][13]=
-{
- {0x0000, 0x0005, 0x0037, 0x00e7, 0x01de, 0x03ce, 0x03d9, 0x07c8, 0x07cd, 0x0fc8, 0x0fdd, 0x1fe4, 0x1fec},
- {0x0004, 0x000c, 0x0035, 0x0072, 0x00ea, 0x00ed, 0x01e2, 0x03d1, 0x03d3, 0x03e0, 0x07d8, 0x0fcf, 0x0fd5},
- {0x0036, 0x0034, 0x0071, 0x00e8, 0x00ec, 0x01e1, 0x03cf, 0x03dd, 0x03db, 0x07d0, 0x0fc7, 0x0fd4, 0x0fe4},
- {0x00e6, 0x0070, 0x00e9, 0x01dd, 0x01e3, 0x03d2, 0x03dc, 0x07cc, 0x07ca, 0x07de, 0x0fd8, 0x0fea, 0x1fdb},
- {0x01df, 0x00eb, 0x01dc, 0x01e6, 0x03d5, 0x03de, 0x07cb, 0x07dd, 0x07dc, 0x0fcd, 0x0fe2, 0x0fe7, 0x1fe1},
- {0x03d0, 0x01e0, 0x01e4, 0x03d6, 0x07c5, 0x07d1, 0x07db, 0x0fd2, 0x07e0, 0x0fd9, 0x0feb, 0x1fe3, 0x1fe9},
- {0x07c4, 0x01e5, 0x03d7, 0x07c6, 0x07cf, 0x07da, 0x0fcb, 0x0fda, 0x0fe3, 0x0fe9, 0x1fe6, 0x1ff3, 0x1ff7},
- {0x07d3, 0x03d8, 0x03e1, 0x07d4, 0x07d9, 0x0fd3, 0x0fde, 0x1fdd, 0x1fd9, 0x1fe2, 0x1fea, 0x1ff1, 0x1ff6},
- {0x07d2, 0x03d4, 0x03da, 0x07c7, 0x07d7, 0x07e2, 0x0fce, 0x0fdb, 0x1fd8, 0x1fee, 0x3ff0, 0x1ff4, 0x3ff2},
- {0x07e1, 0x03df, 0x07c9, 0x07d6, 0x0fca, 0x0fd0, 0x0fe5, 0x0fe6, 0x1feb, 0x1fef, 0x3ff3, 0x3ff4, 0x3ff5},
- {0x0fe0, 0x07ce, 0x07d5, 0x0fc6, 0x0fd1, 0x0fe1, 0x1fe0, 0x1fe8, 0x1ff0, 0x3ff1, 0x3ff8, 0x3ff6, 0x7ffc},
- {0x0fe8, 0x07df, 0x0fc9, 0x0fd7, 0x0fdc, 0x1fdc, 0x1fdf, 0x1fed, 0x1ff5, 0x3ff9, 0x3ffb, 0x7ffd, 0x7ffe},
- {0x1fe7, 0x0fcc, 0x0fd6, 0x0fdf, 0x1fde, 0x1fda, 0x1fe5, 0x1ff2, 0x3ffa, 0x3ff7, 0x3ffc, 0x3ffd, 0x7fff}
-};
-
-const USHORT FDKaacEnc_huff_ctab10[13][13]=
-{
- {0x0022, 0x0008, 0x001d, 0x0026, 0x005f, 0x00d3, 0x01cf, 0x03d0, 0x03d7, 0x03ed, 0x07f0, 0x07f6, 0x0ffd},
- {0x0007, 0x0000, 0x0001, 0x0009, 0x0020, 0x0054, 0x0060, 0x00d5, 0x00dc, 0x01d4, 0x03cd, 0x03de, 0x07e7},
- {0x001c, 0x0002, 0x0006, 0x000c, 0x001e, 0x0028, 0x005b, 0x00cd, 0x00d9, 0x01ce, 0x01dc, 0x03d9, 0x03f1},
- {0x0025, 0x000b, 0x000a, 0x000d, 0x0024, 0x0057, 0x0061, 0x00cc, 0x00dd, 0x01cc, 0x01de, 0x03d3, 0x03e7},
- {0x005d, 0x0021, 0x001f, 0x0023, 0x0027, 0x0059, 0x0064, 0x00d8, 0x00df, 0x01d2, 0x01e2, 0x03dd, 0x03ee},
- {0x00d1, 0x0055, 0x0029, 0x0056, 0x0058, 0x0062, 0x00ce, 0x00e0, 0x00e2, 0x01da, 0x03d4, 0x03e3, 0x07eb},
- {0x01c9, 0x005e, 0x005a, 0x005c, 0x0063, 0x00ca, 0x00da, 0x01c7, 0x01ca, 0x01e0, 0x03db, 0x03e8, 0x07ec},
- {0x01e3, 0x00d2, 0x00cb, 0x00d0, 0x00d7, 0x00db, 0x01c6, 0x01d5, 0x01d8, 0x03ca, 0x03da, 0x07ea, 0x07f1},
- {0x01e1, 0x00d4, 0x00cf, 0x00d6, 0x00de, 0x00e1, 0x01d0, 0x01d6, 0x03d1, 0x03d5, 0x03f2, 0x07ee, 0x07fb},
- {0x03e9, 0x01cd, 0x01c8, 0x01cb, 0x01d1, 0x01d7, 0x01df, 0x03cf, 0x03e0, 0x03ef, 0x07e6, 0x07f8, 0x0ffa},
- {0x03eb, 0x01dd, 0x01d3, 0x01d9, 0x01db, 0x03d2, 0x03cc, 0x03dc, 0x03ea, 0x07ed, 0x07f3, 0x07f9, 0x0ff9},
- {0x07f2, 0x03ce, 0x01e4, 0x03cb, 0x03d8, 0x03d6, 0x03e2, 0x03e5, 0x07e8, 0x07f4, 0x07f5, 0x07f7, 0x0ffb},
- {0x07fa, 0x03ec, 0x03df, 0x03e1, 0x03e4, 0x03e6, 0x03f0, 0x07e9, 0x07ef, 0x0ff8, 0x0ffe, 0x0ffc, 0x0fff}
-};
-
-const USHORT FDKaacEnc_huff_ctab11[21][17]=
-{
- {0x0000, 0x0006, 0x0019, 0x003d, 0x009c, 0x00c6, 0x01a7, 0x0390, 0x03c2, 0x03df, 0x07e6, 0x07f3, 0x0ffb, 0x07ec, 0x0ffa, 0x0ffe, 0x038e},
- {0x0005, 0x0001, 0x0008, 0x0014, 0x0037, 0x0042, 0x0092, 0x00af, 0x0191, 0x01a5, 0x01b5, 0x039e, 0x03c0, 0x03a2, 0x03cd, 0x07d6, 0x00ae},
- {0x0017, 0x0007, 0x0009, 0x0018, 0x0039, 0x0040, 0x008e, 0x00a3, 0x00b8, 0x0199, 0x01ac, 0x01c1, 0x03b1, 0x0396, 0x03be, 0x03ca, 0x009d},
- {0x003c, 0x0015, 0x0016, 0x001a, 0x003b, 0x0044, 0x0091, 0x00a5, 0x00be, 0x0196, 0x01ae, 0x01b9, 0x03a1, 0x0391, 0x03a5, 0x03d5, 0x0094},
- {0x009a, 0x0036, 0x0038, 0x003a, 0x0041, 0x008c, 0x009b, 0x00b0, 0x00c3, 0x019e, 0x01ab, 0x01bc, 0x039f, 0x038f, 0x03a9, 0x03cf, 0x0093},
- {0x00bf, 0x003e, 0x003f, 0x0043, 0x0045, 0x009e, 0x00a7, 0x00b9, 0x0194, 0x01a2, 0x01ba, 0x01c3, 0x03a6, 0x03a7, 0x03bb, 0x03d4, 0x009f},
- {0x01a0, 0x008f, 0x008d, 0x0090, 0x0098, 0x00a6, 0x00b6, 0x00c4, 0x019f, 0x01af, 0x01bf, 0x0399, 0x03bf, 0x03b4, 0x03c9, 0x03e7, 0x00a8},
- {0x01b6, 0x00ab, 0x00a4, 0x00aa, 0x00b2, 0x00c2, 0x00c5, 0x0198, 0x01a4, 0x01b8, 0x038c, 0x03a4, 0x03c4, 0x03c6, 0x03dd, 0x03e8, 0x00ad},
- {0x03af, 0x0192, 0x00bd, 0x00bc, 0x018e, 0x0197, 0x019a, 0x01a3, 0x01b1, 0x038d, 0x0398, 0x03b7, 0x03d3, 0x03d1, 0x03db, 0x07dd, 0x00b4},
- {0x03de, 0x01a9, 0x019b, 0x019c, 0x01a1, 0x01aa, 0x01ad, 0x01b3, 0x038b, 0x03b2, 0x03b8, 0x03ce, 0x03e1, 0x03e0, 0x07d2, 0x07e5, 0x00b7},
- {0x07e3, 0x01bb, 0x01a8, 0x01a6, 0x01b0, 0x01b2, 0x01b7, 0x039b, 0x039a, 0x03ba, 0x03b5, 0x03d6, 0x07d7, 0x03e4, 0x07d8, 0x07ea, 0x00ba},
- {0x07e8, 0x03a0, 0x01bd, 0x01b4, 0x038a, 0x01c4, 0x0392, 0x03aa, 0x03b0, 0x03bc, 0x03d7, 0x07d4, 0x07dc, 0x07db, 0x07d5, 0x07f0, 0x00c1},
- {0x07fb, 0x03c8, 0x03a3, 0x0395, 0x039d, 0x03ac, 0x03ae, 0x03c5, 0x03d8, 0x03e2, 0x03e6, 0x07e4, 0x07e7, 0x07e0, 0x07e9, 0x07f7, 0x0190},
- {0x07f2, 0x0393, 0x01be, 0x01c0, 0x0394, 0x0397, 0x03ad, 0x03c3, 0x03c1, 0x03d2, 0x07da, 0x07d9, 0x07df, 0x07eb, 0x07f4, 0x07fa, 0x0195},
- {0x07f8, 0x03bd, 0x039c, 0x03ab, 0x03a8, 0x03b3, 0x03b9, 0x03d0, 0x03e3, 0x03e5, 0x07e2, 0x07de, 0x07ed, 0x07f1, 0x07f9, 0x07fc, 0x0193},
- {0x0ffd, 0x03dc, 0x03b6, 0x03c7, 0x03cc, 0x03cb, 0x03d9, 0x03da, 0x07d3, 0x07e1, 0x07ee, 0x07ef, 0x07f5, 0x07f6, 0x0ffc, 0x0fff, 0x019d},
- {0x01c2, 0x00b5, 0x00a1, 0x0096, 0x0097, 0x0095, 0x0099, 0x00a0, 0x00a2, 0x00ac, 0x00a9, 0x00b1, 0x00b3, 0x00bb, 0x00c0, 0x018f, 0x0004},
- {0x0018, 0x002e, 0x0000, 0x005a, 0x00a5, 0x00f8, 0x00b7, 0x0094, 0x00f9, 0x004d, 0x0021, 0x002b, 0x004f, 0x007b, 0x00bc, 0x0046, 0x0015},
- {0x0042, 0x0037, 0x0078, 0x000d, 0x0068, 0x005f, 0x000d, 0x005e, 0x005a, 0x00be, 0x0063, 0x007e, 0x001f, 0x0092, 0x001a, 0x00ab, 0x0032},
- {0x00e6, 0x0037, 0x0000, 0x0058, 0x000b, 0x005a, 0x00e1, 0x005d, 0x0029, 0x0017, 0x007e, 0x0069, 0x00aa, 0x0054, 0x0029, 0x0032, 0x0041},
- {0x0046, 0x00ea, 0x0034, 0x00ea, 0x0011, 0x001b, 0x00a9, 0x0094, 0x00e2, 0x0031, 0x00d0, 0x00e5, 0x0007, 0x0070, 0x0069, 0x003e, 0x0021}
-};
-
-const INT FDKaacEnc_huff_ctabscf[121]=
-{
- 0x0003ffe8, 0x0003ffe6, 0x0003ffe7, 0x0003ffe5, 0x0007fff5, 0x0007fff1, 0x0007ffed, 0x0007fff6,
- 0x0007ffee, 0x0007ffef, 0x0007fff0, 0x0007fffc, 0x0007fffd, 0x0007ffff, 0x0007fffe, 0x0007fff7,
- 0x0007fff8, 0x0007fffb, 0x0007fff9, 0x0003ffe4, 0x0007fffa, 0x0003ffe3, 0x0001ffef, 0x0001fff0,
- 0x0000fff5, 0x0001ffee, 0x0000fff2, 0x0000fff3, 0x0000fff4, 0x0000fff1, 0x00007ff6, 0x00007ff7,
- 0x00003ff9, 0x00003ff5, 0x00003ff7, 0x00003ff3, 0x00003ff6, 0x00003ff2, 0x00001ff7, 0x00001ff5,
- 0x00000ff9, 0x00000ff7, 0x00000ff6, 0x000007f9, 0x00000ff4, 0x000007f8, 0x000003f9, 0x000003f7,
- 0x000003f5, 0x000001f8, 0x000001f7, 0x000000fa, 0x000000f8, 0x000000f6, 0x00000079, 0x0000003a,
- 0x00000038, 0x0000001a, 0x0000000b, 0x00000004, 0x00000000, 0x0000000a, 0x0000000c, 0x0000001b,
- 0x00000039, 0x0000003b, 0x00000078, 0x0000007a, 0x000000f7, 0x000000f9, 0x000001f6, 0x000001f9,
- 0x000003f4, 0x000003f6, 0x000003f8, 0x000007f5, 0x000007f4, 0x000007f6, 0x000007f7, 0x00000ff5,
- 0x00000ff8, 0x00001ff4, 0x00001ff6, 0x00001ff8, 0x00003ff8, 0x00003ff4, 0x0000fff0, 0x00007ff4,
- 0x0000fff6, 0x00007ff5, 0x0003ffe2, 0x0007ffd9, 0x0007ffda, 0x0007ffdb, 0x0007ffdc, 0x0007ffdd,
- 0x0007ffde, 0x0007ffd8, 0x0007ffd2, 0x0007ffd3, 0x0007ffd4, 0x0007ffd5, 0x0007ffd6, 0x0007fff2,
- 0x0007ffdf, 0x0007ffe7, 0x0007ffe8, 0x0007ffe9, 0x0007ffea, 0x0007ffeb, 0x0007ffe6, 0x0007ffe0,
- 0x0007ffe1, 0x0007ffe2, 0x0007ffe3, 0x0007ffe4, 0x0007ffe5, 0x0007ffd7, 0x0007ffec, 0x0007fff4,
- 0x0007fff3
-};
-
-/*
- table of (0.50000...1.00000) ^0.75
-*/
-const FIXP_QTD FDKaacEnc_mTab_3_4[MANT_SIZE] =
-{
- QTC(0x4c1bf829), QTC(0x4c3880de), QTC(0x4c550603), QTC(0x4c71879c), QTC(0x4c8e05aa), QTC(0x4caa8030), QTC(0x4cc6f72f), QTC(0x4ce36aab),
- QTC(0x4cffdaa4), QTC(0x4d1c471d), QTC(0x4d38b019), QTC(0x4d55159a), QTC(0x4d7177a1), QTC(0x4d8dd631), QTC(0x4daa314b), QTC(0x4dc688f3),
- QTC(0x4de2dd2a), QTC(0x4dff2df2), QTC(0x4e1b7b4d), QTC(0x4e37c53d), QTC(0x4e540bc5), QTC(0x4e704ee6), QTC(0x4e8c8ea3), QTC(0x4ea8cafd),
- QTC(0x4ec503f7), QTC(0x4ee13992), QTC(0x4efd6bd0), QTC(0x4f199ab4), QTC(0x4f35c640), QTC(0x4f51ee75), QTC(0x4f6e1356), QTC(0x4f8a34e4),
- QTC(0x4fa65321), QTC(0x4fc26e10), QTC(0x4fde85b2), QTC(0x4ffa9a0a), QTC(0x5016ab18), QTC(0x5032b8e0), QTC(0x504ec362), QTC(0x506acaa1),
- QTC(0x5086cea0), QTC(0x50a2cf5e), QTC(0x50becce0), QTC(0x50dac725), QTC(0x50f6be31), QTC(0x5112b205), QTC(0x512ea2a3), QTC(0x514a900d),
- QTC(0x51667a45), QTC(0x5182614c), QTC(0x519e4524), QTC(0x51ba25cf), QTC(0x51d60350), QTC(0x51f1dda7), QTC(0x520db4d6), QTC(0x522988e0),
- QTC(0x524559c6), QTC(0x52612789), QTC(0x527cf22d), QTC(0x5298b9b1), QTC(0x52b47e19), QTC(0x52d03f65), QTC(0x52ebfd98), QTC(0x5307b8b4),
- QTC(0x532370b9), QTC(0x533f25aa), QTC(0x535ad789), QTC(0x53768656), QTC(0x53923215), QTC(0x53addac6), QTC(0x53c9806b), QTC(0x53e52306),
- QTC(0x5400c298), QTC(0x541c5f24), QTC(0x5437f8ab), QTC(0x54538f2e), QTC(0x546f22af), QTC(0x548ab330), QTC(0x54a640b3), QTC(0x54c1cb38),
- QTC(0x54dd52c2), QTC(0x54f8d753), QTC(0x551458eb), QTC(0x552fd78d), QTC(0x554b5339), QTC(0x5566cbf3), QTC(0x558241bb), QTC(0x559db492),
- QTC(0x55b9247b), QTC(0x55d49177), QTC(0x55effb87), QTC(0x560b62ad), QTC(0x5626c6eb), QTC(0x56422842), QTC(0x565d86b4), QTC(0x5678e242),
- QTC(0x56943aee), QTC(0x56af90b9), QTC(0x56cae3a4), QTC(0x56e633b2), QTC(0x570180e4), QTC(0x571ccb3b), QTC(0x573812b8), QTC(0x5753575e),
- QTC(0x576e992e), QTC(0x5789d829), QTC(0x57a51450), QTC(0x57c04da6), QTC(0x57db842b), QTC(0x57f6b7e1), QTC(0x5811e8c9), QTC(0x582d16e6),
- QTC(0x58484238), QTC(0x58636ac0), QTC(0x587e9081), QTC(0x5899b37c), QTC(0x58b4d3b1), QTC(0x58cff123), QTC(0x58eb0bd3), QTC(0x590623c2),
- QTC(0x592138f2), QTC(0x593c4b63), QTC(0x59575b19), QTC(0x59726812), QTC(0x598d7253), QTC(0x59a879da), QTC(0x59c37eab), QTC(0x59de80c6),
- QTC(0x59f9802d), QTC(0x5a147ce0), QTC(0x5a2f76e2), QTC(0x5a4a6e34), QTC(0x5a6562d6), QTC(0x5a8054cb), QTC(0x5a9b4414), QTC(0x5ab630b2),
- QTC(0x5ad11aa6), QTC(0x5aec01f1), QTC(0x5b06e696), QTC(0x5b21c895), QTC(0x5b3ca7ef), QTC(0x5b5784a6), QTC(0x5b725ebc), QTC(0x5b8d3631),
- QTC(0x5ba80b06), QTC(0x5bc2dd3e), QTC(0x5bddacd9), QTC(0x5bf879d8), QTC(0x5c13443d), QTC(0x5c2e0c09), QTC(0x5c48d13e), QTC(0x5c6393dc),
- QTC(0x5c7e53e5), QTC(0x5c99115a), QTC(0x5cb3cc3c), QTC(0x5cce848d), QTC(0x5ce93a4e), QTC(0x5d03ed80), QTC(0x5d1e9e24), QTC(0x5d394c3b),
- QTC(0x5d53f7c7), QTC(0x5d6ea0c9), QTC(0x5d894742), QTC(0x5da3eb33), QTC(0x5dbe8c9e), QTC(0x5dd92b84), QTC(0x5df3c7e5), QTC(0x5e0e61c3),
- QTC(0x5e28f920), QTC(0x5e438dfc), QTC(0x5e5e2059), QTC(0x5e78b037), QTC(0x5e933d99), QTC(0x5eadc87e), QTC(0x5ec850e9), QTC(0x5ee2d6da),
- QTC(0x5efd5a53), QTC(0x5f17db54), QTC(0x5f3259e0), QTC(0x5f4cd5f6), QTC(0x5f674f99), QTC(0x5f81c6c8), QTC(0x5f9c3b87), QTC(0x5fb6add4),
- QTC(0x5fd11db3), QTC(0x5feb8b23), QTC(0x6005f626), QTC(0x60205ebd), QTC(0x603ac4e9), QTC(0x605528ac), QTC(0x606f8a05), QTC(0x6089e8f7),
- QTC(0x60a44583), QTC(0x60be9fa9), QTC(0x60d8f76b), QTC(0x60f34cca), QTC(0x610d9fc7), QTC(0x6127f062), QTC(0x61423e9e), QTC(0x615c8a7a),
- QTC(0x6176d3f9), QTC(0x61911b1b), QTC(0x61ab5fe1), QTC(0x61c5a24d), QTC(0x61dfe25f), QTC(0x61fa2018), QTC(0x62145b7a), QTC(0x622e9485),
- QTC(0x6248cb3b), QTC(0x6262ff9d), QTC(0x627d31ab), QTC(0x62976167), QTC(0x62b18ed1), QTC(0x62cbb9eb), QTC(0x62e5e2b6), QTC(0x63000933),
- QTC(0x631a2d62), QTC(0x63344f45), QTC(0x634e6edd), QTC(0x63688c2b), QTC(0x6382a730), QTC(0x639cbfec), QTC(0x63b6d661), QTC(0x63d0ea90),
- QTC(0x63eafc7a), QTC(0x64050c1f), QTC(0x641f1982), QTC(0x643924a2), QTC(0x64532d80), QTC(0x646d341f), QTC(0x6487387e), QTC(0x64a13a9e),
- QTC(0x64bb3a81), QTC(0x64d53828), QTC(0x64ef3393), QTC(0x65092cc4), QTC(0x652323bb), QTC(0x653d1879), QTC(0x65570b00), QTC(0x6570fb50),
- QTC(0x658ae96b), QTC(0x65a4d550), QTC(0x65bebf01), QTC(0x65d8a680), QTC(0x65f28bcc), QTC(0x660c6ee8), QTC(0x66264fd3), QTC(0x66402e8f),
- QTC(0x665a0b1c), QTC(0x6673e57d), QTC(0x668dbdb0), QTC(0x66a793b8), QTC(0x66c16795), QTC(0x66db3949), QTC(0x66f508d4), QTC(0x670ed636),
- QTC(0x6728a172), QTC(0x67426a87), QTC(0x675c3177), QTC(0x6775f643), QTC(0x678fb8eb), QTC(0x67a97971), QTC(0x67c337d5), QTC(0x67dcf418),
- QTC(0x67f6ae3b), QTC(0x6810663f), QTC(0x682a1c25), QTC(0x6843cfed), QTC(0x685d8199), QTC(0x68773129), QTC(0x6890de9f), QTC(0x68aa89fa),
- QTC(0x68c4333d), QTC(0x68ddda67), QTC(0x68f77f7a), QTC(0x69112277), QTC(0x692ac35e), QTC(0x69446230), QTC(0x695dfeee), QTC(0x6977999a),
- QTC(0x69913232), QTC(0x69aac8ba), QTC(0x69c45d31), QTC(0x69ddef98), QTC(0x69f77ff0), QTC(0x6a110e3a), QTC(0x6a2a9a77), QTC(0x6a4424a8),
- QTC(0x6a5daccc), QTC(0x6a7732e6), QTC(0x6a90b6f6), QTC(0x6aaa38fd), QTC(0x6ac3b8fb), QTC(0x6add36f2), QTC(0x6af6b2e2), QTC(0x6b102ccd),
- QTC(0x6b29a4b2), QTC(0x6b431a92), QTC(0x6b5c8e6f), QTC(0x6b76004a), QTC(0x6b8f7022), QTC(0x6ba8ddf9), QTC(0x6bc249d0), QTC(0x6bdbb3a7),
- QTC(0x6bf51b80), QTC(0x6c0e815a), QTC(0x6c27e537), QTC(0x6c414718), QTC(0x6c5aa6fd), QTC(0x6c7404e7), QTC(0x6c8d60d7), QTC(0x6ca6bace),
- QTC(0x6cc012cc), QTC(0x6cd968d2), QTC(0x6cf2bce1), QTC(0x6d0c0ef9), QTC(0x6d255f1d), QTC(0x6d3ead4b), QTC(0x6d57f985), QTC(0x6d7143cc),
- QTC(0x6d8a8c21), QTC(0x6da3d283), QTC(0x6dbd16f5), QTC(0x6dd65976), QTC(0x6def9a08), QTC(0x6e08d8ab), QTC(0x6e221560), QTC(0x6e3b5027),
- QTC(0x6e548902), QTC(0x6e6dbff1), QTC(0x6e86f4f5), QTC(0x6ea0280e), QTC(0x6eb9593e), QTC(0x6ed28885), QTC(0x6eebb5e3), QTC(0x6f04e15a),
- QTC(0x6f1e0aea), QTC(0x6f373294), QTC(0x6f505859), QTC(0x6f697c39), QTC(0x6f829e35), QTC(0x6f9bbe4e), QTC(0x6fb4dc85), QTC(0x6fcdf8d9),
- QTC(0x6fe7134d), QTC(0x70002be0), QTC(0x70194293), QTC(0x70325767), QTC(0x704b6a5d), QTC(0x70647b76), QTC(0x707d8ab1), QTC(0x70969811),
- QTC(0x70afa394), QTC(0x70c8ad3d), QTC(0x70e1b50c), QTC(0x70fabb01), QTC(0x7113bf1d), QTC(0x712cc161), QTC(0x7145c1ce), QTC(0x715ec064),
- QTC(0x7177bd24), QTC(0x7190b80f), QTC(0x71a9b124), QTC(0x71c2a866), QTC(0x71db9dd4), QTC(0x71f49170), QTC(0x720d8339), QTC(0x72267331),
- QTC(0x723f6159), QTC(0x72584db0), QTC(0x72713838), QTC(0x728a20f1), QTC(0x72a307db), QTC(0x72bbecf9), QTC(0x72d4d049), QTC(0x72edb1ce),
- QTC(0x73069187), QTC(0x731f6f75), QTC(0x73384b98), QTC(0x735125f3), QTC(0x7369fe84), QTC(0x7382d54d), QTC(0x739baa4e), QTC(0x73b47d89),
- QTC(0x73cd4efd), QTC(0x73e61eab), QTC(0x73feec94), QTC(0x7417b8b8), QTC(0x74308319), QTC(0x74494bb6), QTC(0x74621291), QTC(0x747ad7aa),
- QTC(0x74939b02), QTC(0x74ac5c98), QTC(0x74c51c6f), QTC(0x74ddda86), QTC(0x74f696de), QTC(0x750f5178), QTC(0x75280a54), QTC(0x7540c174),
- QTC(0x755976d7), QTC(0x75722a7e), QTC(0x758adc69), QTC(0x75a38c9b), QTC(0x75bc3b12), QTC(0x75d4e7cf), QTC(0x75ed92d4), QTC(0x76063c21),
- QTC(0x761ee3b6), QTC(0x76378994), QTC(0x76502dbc), QTC(0x7668d02e), QTC(0x768170eb), QTC(0x769a0ff3), QTC(0x76b2ad47), QTC(0x76cb48e7),
- QTC(0x76e3e2d5), QTC(0x76fc7b10), QTC(0x7715119a), QTC(0x772da673), QTC(0x7746399b), QTC(0x775ecb13), QTC(0x77775adc), QTC(0x778fe8f6),
- QTC(0x77a87561), QTC(0x77c1001f), QTC(0x77d98930), QTC(0x77f21095), QTC(0x780a964d), QTC(0x78231a5b), QTC(0x783b9cbd), QTC(0x78541d75),
- QTC(0x786c9c84), QTC(0x788519e9), QTC(0x789d95a6), QTC(0x78b60fbb), QTC(0x78ce8828), QTC(0x78e6feef), QTC(0x78ff740f), QTC(0x7917e78a),
- QTC(0x7930595f), QTC(0x7948c990), QTC(0x7961381d), QTC(0x7979a506), QTC(0x7992104c), QTC(0x79aa79f0), QTC(0x79c2e1f1), QTC(0x79db4852),
- QTC(0x79f3ad11), QTC(0x7a0c1031), QTC(0x7a2471b0), QTC(0x7a3cd191), QTC(0x7a552fd3), QTC(0x7a6d8c76), QTC(0x7a85e77d), QTC(0x7a9e40e6),
- QTC(0x7ab698b2), QTC(0x7aceeee3), QTC(0x7ae74378), QTC(0x7aff9673), QTC(0x7b17e7d2), QTC(0x7b303799), QTC(0x7b4885c5), QTC(0x7b60d259),
- QTC(0x7b791d55), QTC(0x7b9166b9), QTC(0x7ba9ae86), QTC(0x7bc1f4bc), QTC(0x7bda395c), QTC(0x7bf27c66), QTC(0x7c0abddb), QTC(0x7c22fdbb),
- QTC(0x7c3b3c07), QTC(0x7c5378c0), QTC(0x7c6bb3e5), QTC(0x7c83ed78), QTC(0x7c9c2579), QTC(0x7cb45be9), QTC(0x7ccc90c7), QTC(0x7ce4c414),
- QTC(0x7cfcf5d2), QTC(0x7d152600), QTC(0x7d2d549f), QTC(0x7d4581b0), QTC(0x7d5dad32), QTC(0x7d75d727), QTC(0x7d8dff8f), QTC(0x7da6266a),
- QTC(0x7dbe4bba), QTC(0x7dd66f7d), QTC(0x7dee91b6), QTC(0x7e06b264), QTC(0x7e1ed188), QTC(0x7e36ef22), QTC(0x7e4f0b34), QTC(0x7e6725bd),
- QTC(0x7e7f3ebd), QTC(0x7e975636), QTC(0x7eaf6c28), QTC(0x7ec78093), QTC(0x7edf9378), QTC(0x7ef7a4d7), QTC(0x7f0fb4b1), QTC(0x7f27c307),
- QTC(0x7f3fcfd8), QTC(0x7f57db25), QTC(0x7f6fe4ef), QTC(0x7f87ed36), QTC(0x7f9ff3fb), QTC(0x7fb7f93e), QTC(0x7fcffcff), QTC(0x7fe7ff40)
-};
-
-/*
- table of pow(2.0,0.25*q)/2.0, q[0..4)
-*/
-const FIXP_QTD FDKaacEnc_quantTableQ[4] = { QTC(0x40000000), QTC(0x4c1bf7ff), QTC(0x5a82797f), QTC(0x6ba27e7f) };
-
-/*
- table of pow(2.0,0.75*e)/8.0, e[0..4)
-*/
-const FIXP_QTD FDKaacEnc_quantTableE[4] = { QTC(0x10000000), QTC(0x1ae89f99), QTC(0x2d413ccd), QTC(0x4c1bf828) };
-
-
-/*
- table to count used number of bits
-*/
-const SHORT FDKaacEnc_sideInfoTabLong[MAX_SFB_LONG + 1] =
-{
- 0x0009, 0x0009, 0x0009, 0x0009, 0x0009, 0x0009, 0x0009, 0x0009,
- 0x0009, 0x0009, 0x0009, 0x0009, 0x0009, 0x0009, 0x0009, 0x0009,
- 0x0009, 0x0009, 0x0009, 0x0009, 0x0009, 0x0009, 0x0009, 0x0009,
- 0x0009, 0x0009, 0x0009, 0x0009, 0x0009, 0x0009, 0x0009, 0x000e,
- 0x000e, 0x000e, 0x000e, 0x000e, 0x000e, 0x000e, 0x000e, 0x000e,
- 0x000e, 0x000e, 0x000e, 0x000e, 0x000e, 0x000e, 0x000e, 0x000e,
- 0x000e, 0x000e, 0x000e, 0x000e
-};
-
-
-const SHORT FDKaacEnc_sideInfoTabShort[MAX_SFB_SHORT + 1] =
-{
- 0x0007, 0x0007, 0x0007, 0x0007, 0x0007, 0x0007, 0x0007, 0x000a,
- 0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x000d, 0x000d
-};
-
-
-
-
-
-
-/*
- Psy Configuration constants
-*/
-
-const SFB_PARAM_LONG p_FDKaacEnc_8000_long_1024 = {
- 40,
- { 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 16, 16, 16, 16, 16, 16, 16,
- 20, 20, 20, 20, 24, 24, 24, 28, 28, 32, 36, 36, 40, 44, 48, 52, 56, 60, 64, 80 }
-};
-const SFB_PARAM_SHORT p_FDKaacEnc_8000_short_128 = {
- 15,
- { 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 12, 16, 20, 20 }
-};
-
-const SFB_PARAM_LONG p_FDKaacEnc_11025_long_1024 = {
- 43,
- { 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 12, 12, 12, 12, 12, 12, 12, 12, 12,
- 16, 16, 16, 16, 20, 20, 20, 24, 24, 28, 28, 32, 36, 40, 40, 44, 48, 52, 56, 60,
- 64, 64, 64 }
-};
-const SFB_PARAM_SHORT p_FDKaacEnc_11025_short_128 = {
- 15,
- { 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 12, 12, 16, 20, 20 }
-};
-
-const SFB_PARAM_LONG p_FDKaacEnc_12000_long_1024 = {
- 43,
- { 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 12, 12, 12, 12, 12, 12, 12, 12, 12,
- 16, 16, 16, 16, 20, 20, 20, 24, 24, 28, 28, 32, 36, 40, 40, 44, 48, 52, 56, 60,
- 64, 64, 64 }
-};
-const SFB_PARAM_SHORT p_FDKaacEnc_12000_short_128 = {
- 15,
- { 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 12, 12, 16, 20, 20 }
-};
-
-const SFB_PARAM_LONG p_FDKaacEnc_16000_long_1024 = {
- 43,
- { 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 12, 12, 12, 12, 12, 12, 12, 12, 12,
- 16, 16, 16, 16, 20, 20, 20, 24, 24, 28, 28, 32, 36, 40, 40, 44, 48, 52, 56, 60,
- 64, 64, 64 }
-};
-const SFB_PARAM_SHORT p_FDKaacEnc_16000_short_128 = {
- 15,
- { 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 12, 12, 16, 20, 20 }
-};
-const SFB_PARAM_LONG p_FDKaacEnc_22050_long_1024 = {
- 47,
- { 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8, 8, 8, 8, 8,
- 8, 12, 12, 12, 12, 16, 16, 16, 20, 20, 24, 24, 28, 28, 32, 36, 36, 40, 44, 48,
- 52, 52, 64, 64, 64, 64, 64 }
-};
-const SFB_PARAM_SHORT p_FDKaacEnc_22050_short_128 = {
- 15,
- { 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 12, 12, 16, 16, 20 }
-};
-const SFB_PARAM_LONG p_FDKaacEnc_24000_long_1024 = {
- 47,
- { 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8, 8, 8, 8, 8,
- 8, 12, 12, 12, 12, 16, 16, 16, 20, 20, 24, 24, 28, 28, 32, 36, 36, 40, 44, 48,
- 52, 52, 64, 64, 64, 64, 64 }
-};
-const SFB_PARAM_SHORT p_FDKaacEnc_24000_short_128 = {
- 15,
- { 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 12, 12, 16, 16, 20 }
-};
-const SFB_PARAM_LONG p_FDKaacEnc_32000_long_1024 = {
- 51,
- { 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8, 8, 8, 12, 12, 12,
- 12, 16, 16, 20, 20, 24, 24, 28, 28, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
- 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32 }
-};
-const SFB_PARAM_SHORT p_FDKaacEnc_32000_short_128 = {
- 14,
- { 4, 4, 4, 4, 4, 8, 8, 8, 12, 12, 12, 16, 16, 16 }
-};
-const SFB_PARAM_LONG p_FDKaacEnc_44100_long_1024 = {
- 49,
- { 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8, 8, 8, 12, 12, 12,
- 12, 16, 16, 20, 20, 24, 24, 28, 28, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
- 32, 32, 32, 32, 32, 32, 32, 32, 96 }
-};
-const SFB_PARAM_SHORT p_FDKaacEnc_44100_short_128 = {
- 14,
- { 4, 4, 4, 4, 4, 8, 8, 8, 12, 12, 12, 16, 16, 16 }
-};
-const SFB_PARAM_LONG p_FDKaacEnc_48000_long_1024 = {
- 49,
- { 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8, 8, 8, 12, 12, 12,
- 12, 16, 16, 20, 20, 24, 24, 28, 28, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
- 32, 32, 32, 32, 32, 32, 32, 32, 96 }
-};
-const SFB_PARAM_SHORT p_FDKaacEnc_48000_short_128 = {
- 14,
- { 4, 4, 4, 4, 4, 8, 8, 8, 12, 12, 12, 16, 16, 16 }
-};
-const SFB_PARAM_LONG p_FDKaacEnc_64000_long_1024 = {
- 47,
- { 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 12, 12,
- 12, 16, 16, 16, 20, 24, 24, 28, 36, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
- 40, 40, 40, 40, 40, 40, 40 }
-};
-const SFB_PARAM_SHORT p_FDKaacEnc_64000_short_128 = {
- 12,
- { 4, 4, 4, 4, 4, 4, 8, 8, 8, 16, 28, 36 }
-};
-const SFB_PARAM_LONG p_FDKaacEnc_88200_long_1024 = {
- 41,
- { 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8, 12,
- 12, 12, 12, 12, 16, 16, 24, 28, 36, 44, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
- 64 }
-};
-const SFB_PARAM_SHORT p_FDKaacEnc_88200_short_128 = {
- 12,
- { 4, 4, 4, 4, 4, 4, 8, 8, 8, 16, 28, 36 }
-};
-const SFB_PARAM_LONG p_FDKaacEnc_96000_long_1024 = {
- 41,
- { 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8, 12,
- 12, 12, 12, 12, 16, 16, 24, 28, 36, 44, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
- 64 }
-};
-const SFB_PARAM_SHORT p_FDKaacEnc_96000_short_128 = {
- 12,
- { 4, 4, 4, 4, 4, 4, 8, 8, 8, 16, 28, 36 }
-};
-
-
-/*
- TNS filter coefficients
-*/
-
-/*
- 3 bit resolution
-*/
-const FIXP_DBL FDKaacEnc_tnsEncCoeff3[8]=
-{
- 0x81f1d201, 0x91261481, 0xadb92301, 0xd438af00, 0x00000000, 0x37898080, 0x64130dff, 0x7cca6fff
-};
-const FIXP_DBL FDKaacEnc_tnsCoeff3Borders[8]={
- 0x80000001 /*-4*/, 0x87b826df /*-3*/, 0x9df24154 /*-2*/, 0xbfffffe5 /*-1*/,
- 0xe9c5e578 /* 0*/, 0x1c7b90f0 /* 1*/, 0x4fce83a9 /* 2*/, 0x7352f2c3 /* 3*/
-};
-
-/*
- 4 bit resolution
-*/
-const FIXP_DBL FDKaacEnc_tnsEncCoeff4[16]=
-{
- 0x808bc881, 0x84e2e581, 0x8d6b4a01, 0x99da9201, 0xa9c45701, 0xbc9dde81, 0xd1c2d500, 0xe87ae540,
- 0x00000000, 0x1a9cd9c0, 0x340ff240, 0x4b3c8bff, 0x5f1f5e7f, 0x6ed9eb7f, 0x79bc387f, 0x7f4c7e7f
-};
-const FIXP_DBL FDKaacEnc_tnsCoeff4Borders[16]=
-{
- 0x80000001 /*-8*/, 0x822deff0 /*-7*/, 0x88a4bfe6 /*-6*/, 0x932c159d /*-5*/,
- 0xa16827c2 /*-4*/, 0xb2dcde27 /*-3*/, 0xc6f20b91 /*-2*/, 0xdcf89c64 /*-1*/,
- 0xf4308ce1 /* 0*/, 0x0d613054 /* 1*/, 0x278dde80 /* 2*/, 0x4000001b /* 3*/,
- 0x55a6127b /* 4*/, 0x678dde8f /* 5*/, 0x74ef0ed7 /* 6*/, 0x7d33f0da /* 7*/
-};
-const FIXP_DBL FDKaacEnc_mTab_4_3Elc[512]={
- FL2FXCONST_DBL(0.3968502629920499),FL2FXCONST_DBL(0.3978840634868335),FL2FXCONST_DBL(0.3989185359354711),FL2FXCONST_DBL(0.3999536794661432),
- FL2FXCONST_DBL(0.4009894932098531),FL2FXCONST_DBL(0.4020259763004115),FL2FXCONST_DBL(0.4030631278744227),FL2FXCONST_DBL(0.4041009470712695),
- FL2FXCONST_DBL(0.4051394330330996),FL2FXCONST_DBL(0.4061785849048110),FL2FXCONST_DBL(0.4072184018340380),FL2FXCONST_DBL(0.4082588829711372),
- FL2FXCONST_DBL(0.4093000274691739),FL2FXCONST_DBL(0.4103418344839078),FL2FXCONST_DBL(0.4113843031737798),FL2FXCONST_DBL(0.4124274326998980),
- FL2FXCONST_DBL(0.4134712222260245),FL2FXCONST_DBL(0.4145156709185620),FL2FXCONST_DBL(0.4155607779465400),FL2FXCONST_DBL(0.4166065424816022),
- FL2FXCONST_DBL(0.4176529636979932),FL2FXCONST_DBL(0.4187000407725452),FL2FXCONST_DBL(0.4197477728846652),FL2FXCONST_DBL(0.4207961592163222),
- FL2FXCONST_DBL(0.4218451989520345),FL2FXCONST_DBL(0.4228948912788567),FL2FXCONST_DBL(0.4239452353863673),FL2FXCONST_DBL(0.4249962304666564),
- FL2FXCONST_DBL(0.4260478757143130),FL2FXCONST_DBL(0.4271001703264124),FL2FXCONST_DBL(0.4281531135025046),FL2FXCONST_DBL(0.4292067044446017),
- FL2FXCONST_DBL(0.4302609423571658),FL2FXCONST_DBL(0.4313158264470970),FL2FXCONST_DBL(0.4323713559237216),FL2FXCONST_DBL(0.4334275299987803),
- FL2FXCONST_DBL(0.4344843478864161),FL2FXCONST_DBL(0.4355418088031630),FL2FXCONST_DBL(0.4365999119679339),FL2FXCONST_DBL(0.4376586566020096),
- FL2FXCONST_DBL(0.4387180419290272),FL2FXCONST_DBL(0.4397780671749683),FL2FXCONST_DBL(0.4408387315681480),FL2FXCONST_DBL(0.4419000343392039),
- FL2FXCONST_DBL(0.4429619747210847),FL2FXCONST_DBL(0.4440245519490388),FL2FXCONST_DBL(0.4450877652606038),FL2FXCONST_DBL(0.4461516138955953),
- FL2FXCONST_DBL(0.4472160970960963),FL2FXCONST_DBL(0.4482812141064458),FL2FXCONST_DBL(0.4493469641732286),FL2FXCONST_DBL(0.4504133465452648),
- FL2FXCONST_DBL(0.4514803604735984),FL2FXCONST_DBL(0.4525480052114875),FL2FXCONST_DBL(0.4536162800143939),FL2FXCONST_DBL(0.4546851841399719),
- FL2FXCONST_DBL(0.4557547168480591),FL2FXCONST_DBL(0.4568248774006652),FL2FXCONST_DBL(0.4578956650619623),FL2FXCONST_DBL(0.4589670790982746),
- FL2FXCONST_DBL(0.4600391187780688),FL2FXCONST_DBL(0.4611117833719430),FL2FXCONST_DBL(0.4621850721526184),FL2FXCONST_DBL(0.4632589843949278),
- FL2FXCONST_DBL(0.4643335193758069),FL2FXCONST_DBL(0.4654086763742842),FL2FXCONST_DBL(0.4664844546714713),FL2FXCONST_DBL(0.4675608535505532),
- FL2FXCONST_DBL(0.4686378722967790),FL2FXCONST_DBL(0.4697155101974522),FL2FXCONST_DBL(0.4707937665419216),FL2FXCONST_DBL(0.4718726406215713),
- FL2FXCONST_DBL(0.4729521317298118),FL2FXCONST_DBL(0.4740322391620711),FL2FXCONST_DBL(0.4751129622157845),FL2FXCONST_DBL(0.4761943001903867),
- FL2FXCONST_DBL(0.4772762523873015),FL2FXCONST_DBL(0.4783588181099338),FL2FXCONST_DBL(0.4794419966636599),FL2FXCONST_DBL(0.4805257873558190),
- FL2FXCONST_DBL(0.4816101894957042),FL2FXCONST_DBL(0.4826952023945537),FL2FXCONST_DBL(0.4837808253655421),FL2FXCONST_DBL(0.4848670577237714),
- FL2FXCONST_DBL(0.4859538987862632),FL2FXCONST_DBL(0.4870413478719488),FL2FXCONST_DBL(0.4881294043016621),FL2FXCONST_DBL(0.4892180673981298),
- FL2FXCONST_DBL(0.4903073364859640),FL2FXCONST_DBL(0.4913972108916533),FL2FXCONST_DBL(0.4924876899435545),FL2FXCONST_DBL(0.4935787729718844),
- FL2FXCONST_DBL(0.4946704593087116),FL2FXCONST_DBL(0.4957627482879484),FL2FXCONST_DBL(0.4968556392453423),FL2FXCONST_DBL(0.4979491315184684),
- FL2FXCONST_DBL(0.4990432244467211),FL2FXCONST_DBL(0.5001379173713062),FL2FXCONST_DBL(0.5012332096352328),FL2FXCONST_DBL(0.5023291005833056),
- FL2FXCONST_DBL(0.5034255895621171),FL2FXCONST_DBL(0.5045226759200399),FL2FXCONST_DBL(0.5056203590072181),FL2FXCONST_DBL(0.5067186381755611),
- FL2FXCONST_DBL(0.5078175127787346),FL2FXCONST_DBL(0.5089169821721536),FL2FXCONST_DBL(0.5100170457129749),FL2FXCONST_DBL(0.5111177027600893),
- FL2FXCONST_DBL(0.5122189526741143),FL2FXCONST_DBL(0.5133207948173868),FL2FXCONST_DBL(0.5144232285539552),FL2FXCONST_DBL(0.5155262532495726),
- FL2FXCONST_DBL(0.5166298682716894),FL2FXCONST_DBL(0.5177340729894460),FL2FXCONST_DBL(0.5188388667736652),FL2FXCONST_DBL(0.5199442489968457),
- FL2FXCONST_DBL(0.5210502190331544),FL2FXCONST_DBL(0.5221567762584198),FL2FXCONST_DBL(0.5232639200501247),FL2FXCONST_DBL(0.5243716497873989),
- FL2FXCONST_DBL(0.5254799648510130),FL2FXCONST_DBL(0.5265888646233705),FL2FXCONST_DBL(0.5276983484885021),FL2FXCONST_DBL(0.5288084158320574),
- FL2FXCONST_DBL(0.5299190660412995),FL2FXCONST_DBL(0.5310302985050975),FL2FXCONST_DBL(0.5321421126139198),FL2FXCONST_DBL(0.5332545077598274),
- FL2FXCONST_DBL(0.5343674833364678),FL2FXCONST_DBL(0.5354810387390675),FL2FXCONST_DBL(0.5365951733644262),FL2FXCONST_DBL(0.5377098866109097),
- FL2FXCONST_DBL(0.5388251778784438),FL2FXCONST_DBL(0.5399410465685075),FL2FXCONST_DBL(0.5410574920841272),FL2FXCONST_DBL(0.5421745138298695),
- FL2FXCONST_DBL(0.5432921112118353),FL2FXCONST_DBL(0.5444102836376534),FL2FXCONST_DBL(0.5455290305164744),FL2FXCONST_DBL(0.5466483512589642),
- FL2FXCONST_DBL(0.5477682452772976),FL2FXCONST_DBL(0.5488887119851529),FL2FXCONST_DBL(0.5500097507977050),FL2FXCONST_DBL(0.5511313611316194),
- FL2FXCONST_DBL(0.5522535424050467),FL2FXCONST_DBL(0.5533762940376158),FL2FXCONST_DBL(0.5544996154504284),FL2FXCONST_DBL(0.5556235060660528),
- FL2FXCONST_DBL(0.5567479653085183),FL2FXCONST_DBL(0.5578729926033087),FL2FXCONST_DBL(0.5589985873773569),FL2FXCONST_DBL(0.5601247490590389),
- FL2FXCONST_DBL(0.5612514770781683),FL2FXCONST_DBL(0.5623787708659898),FL2FXCONST_DBL(0.5635066298551742),FL2FXCONST_DBL(0.5646350534798125),
- FL2FXCONST_DBL(0.5657640411754097),FL2FXCONST_DBL(0.5668935923788799),FL2FXCONST_DBL(0.5680237065285404),FL2FXCONST_DBL(0.5691543830641059),
- FL2FXCONST_DBL(0.5702856214266832),FL2FXCONST_DBL(0.5714174210587655),FL2FXCONST_DBL(0.5725497814042271),FL2FXCONST_DBL(0.5736827019083177),
- FL2FXCONST_DBL(0.5748161820176573),FL2FXCONST_DBL(0.5759502211802304),FL2FXCONST_DBL(0.5770848188453810),FL2FXCONST_DBL(0.5782199744638067),
- FL2FXCONST_DBL(0.5793556874875542),FL2FXCONST_DBL(0.5804919573700131),FL2FXCONST_DBL(0.5816287835659116),FL2FXCONST_DBL(0.5827661655313104),
- FL2FXCONST_DBL(0.5839041027235979),FL2FXCONST_DBL(0.5850425946014850),FL2FXCONST_DBL(0.5861816406250000),FL2FXCONST_DBL(0.5873212402554834),
- FL2FXCONST_DBL(0.5884613929555826),FL2FXCONST_DBL(0.5896020981892474),FL2FXCONST_DBL(0.5907433554217242),FL2FXCONST_DBL(0.5918851641195517),
- FL2FXCONST_DBL(0.5930275237505556),FL2FXCONST_DBL(0.5941704337838434),FL2FXCONST_DBL(0.5953138936897999),FL2FXCONST_DBL(0.5964579029400819),
- FL2FXCONST_DBL(0.5976024610076139),FL2FXCONST_DBL(0.5987475673665825),FL2FXCONST_DBL(0.5998932214924321),FL2FXCONST_DBL(0.6010394228618597),
- FL2FXCONST_DBL(0.6021861709528106),FL2FXCONST_DBL(0.6033334652444733),FL2FXCONST_DBL(0.6044813052172748),FL2FXCONST_DBL(0.6056296903528761),
- FL2FXCONST_DBL(0.6067786201341671),FL2FXCONST_DBL(0.6079280940452625),FL2FXCONST_DBL(0.6090781115714966),FL2FXCONST_DBL(0.6102286721994192),
- FL2FXCONST_DBL(0.6113797754167908),FL2FXCONST_DBL(0.6125314207125777),FL2FXCONST_DBL(0.6136836075769482),FL2FXCONST_DBL(0.6148363355012674),
- FL2FXCONST_DBL(0.6159896039780929),FL2FXCONST_DBL(0.6171434125011708),FL2FXCONST_DBL(0.6182977605654305),FL2FXCONST_DBL(0.6194526476669808),
- FL2FXCONST_DBL(0.6206080733031054),FL2FXCONST_DBL(0.6217640369722584),FL2FXCONST_DBL(0.6229205381740598),FL2FXCONST_DBL(0.6240775764092919),
- FL2FXCONST_DBL(0.6252351511798939),FL2FXCONST_DBL(0.6263932619889586),FL2FXCONST_DBL(0.6275519083407275),FL2FXCONST_DBL(0.6287110897405869),
- FL2FXCONST_DBL(0.6298708056950635),FL2FXCONST_DBL(0.6310310557118203),FL2FXCONST_DBL(0.6321918392996523),FL2FXCONST_DBL(0.6333531559684823),
- FL2FXCONST_DBL(0.6345150052293571),FL2FXCONST_DBL(0.6356773865944432),FL2FXCONST_DBL(0.6368402995770224),FL2FXCONST_DBL(0.6380037436914881),
- FL2FXCONST_DBL(0.6391677184533411),FL2FXCONST_DBL(0.6403322233791856),FL2FXCONST_DBL(0.6414972579867254),FL2FXCONST_DBL(0.6426628217947594),
- FL2FXCONST_DBL(0.6438289143231779),FL2FXCONST_DBL(0.6449955350929588),FL2FXCONST_DBL(0.6461626836261636),FL2FXCONST_DBL(0.6473303594459330),
- FL2FXCONST_DBL(0.6484985620764839),FL2FXCONST_DBL(0.6496672910431047),FL2FXCONST_DBL(0.6508365458721518),FL2FXCONST_DBL(0.6520063260910459),
- FL2FXCONST_DBL(0.6531766312282679),FL2FXCONST_DBL(0.6543474608133552),FL2FXCONST_DBL(0.6555188143768979),FL2FXCONST_DBL(0.6566906914505349),
- FL2FXCONST_DBL(0.6578630915669509),FL2FXCONST_DBL(0.6590360142598715),FL2FXCONST_DBL(0.6602094590640603),FL2FXCONST_DBL(0.6613834255153149),
- FL2FXCONST_DBL(0.6625579131504635),FL2FXCONST_DBL(0.6637329215073610),FL2FXCONST_DBL(0.6649084501248851),FL2FXCONST_DBL(0.6660844985429335),
- FL2FXCONST_DBL(0.6672610663024197),FL2FXCONST_DBL(0.6684381529452691),FL2FXCONST_DBL(0.6696157580144163),FL2FXCONST_DBL(0.6707938810538011),
- FL2FXCONST_DBL(0.6719725216083646),FL2FXCONST_DBL(0.6731516792240465),FL2FXCONST_DBL(0.6743313534477807),FL2FXCONST_DBL(0.6755115438274927),
- FL2FXCONST_DBL(0.6766922499120955),FL2FXCONST_DBL(0.6778734712514865),FL2FXCONST_DBL(0.6790552073965435),FL2FXCONST_DBL(0.6802374578991223),
- FL2FXCONST_DBL(0.6814202223120524),FL2FXCONST_DBL(0.6826035001891340),FL2FXCONST_DBL(0.6837872910851345),FL2FXCONST_DBL(0.6849715945557853),
- FL2FXCONST_DBL(0.6861564101577784),FL2FXCONST_DBL(0.6873417374487629),FL2FXCONST_DBL(0.6885275759873420),FL2FXCONST_DBL(0.6897139253330697),
- FL2FXCONST_DBL(0.6909007850464473),FL2FXCONST_DBL(0.6920881546889198),FL2FXCONST_DBL(0.6932760338228737),FL2FXCONST_DBL(0.6944644220116332),
- FL2FXCONST_DBL(0.6956533188194565),FL2FXCONST_DBL(0.6968427238115332),FL2FXCONST_DBL(0.6980326365539813),FL2FXCONST_DBL(0.6992230566138435),
- FL2FXCONST_DBL(0.7004139835590845),FL2FXCONST_DBL(0.7016054169585869),FL2FXCONST_DBL(0.7027973563821499),FL2FXCONST_DBL(0.7039898014004843),
- FL2FXCONST_DBL(0.7051827515852106),FL2FXCONST_DBL(0.7063762065088554),FL2FXCONST_DBL(0.7075701657448483),FL2FXCONST_DBL(0.7087646288675196),
- FL2FXCONST_DBL(0.7099595954520960),FL2FXCONST_DBL(0.7111550650746988),FL2FXCONST_DBL(0.7123510373123402),FL2FXCONST_DBL(0.7135475117429202),
- FL2FXCONST_DBL(0.7147444879452244),FL2FXCONST_DBL(0.7159419654989200),FL2FXCONST_DBL(0.7171399439845538),FL2FXCONST_DBL(0.7183384229835486),
- FL2FXCONST_DBL(0.7195374020782005),FL2FXCONST_DBL(0.7207368808516762),FL2FXCONST_DBL(0.7219368588880097),FL2FXCONST_DBL(0.7231373357720997),
- FL2FXCONST_DBL(0.7243383110897066),FL2FXCONST_DBL(0.7255397844274496),FL2FXCONST_DBL(0.7267417553728043),FL2FXCONST_DBL(0.7279442235140992),
- FL2FXCONST_DBL(0.7291471884405130),FL2FXCONST_DBL(0.7303506497420724),FL2FXCONST_DBL(0.7315546070096487),FL2FXCONST_DBL(0.7327590598349553),
- FL2FXCONST_DBL(0.7339640078105445),FL2FXCONST_DBL(0.7351694505298055),FL2FXCONST_DBL(0.7363753875869610),FL2FXCONST_DBL(0.7375818185770647),
- FL2FXCONST_DBL(0.7387887430959987),FL2FXCONST_DBL(0.7399961607404706),FL2FXCONST_DBL(0.7412040711080108),FL2FXCONST_DBL(0.7424124737969701),
- FL2FXCONST_DBL(0.7436213684065166),FL2FXCONST_DBL(0.7448307545366334),FL2FXCONST_DBL(0.7460406317881158),FL2FXCONST_DBL(0.7472509997625686),
- FL2FXCONST_DBL(0.7484618580624036),FL2FXCONST_DBL(0.7496732062908372),FL2FXCONST_DBL(0.7508850440518872),FL2FXCONST_DBL(0.7520973709503704),
- FL2FXCONST_DBL(0.7533101865919009),FL2FXCONST_DBL(0.7545234905828862),FL2FXCONST_DBL(0.7557372825305252),FL2FXCONST_DBL(0.7569515620428062),
- FL2FXCONST_DBL(0.7581663287285035),FL2FXCONST_DBL(0.7593815821971756),FL2FXCONST_DBL(0.7605973220591619),FL2FXCONST_DBL(0.7618135479255810),
- FL2FXCONST_DBL(0.7630302594083277),FL2FXCONST_DBL(0.7642474561200708),FL2FXCONST_DBL(0.7654651376742505),FL2FXCONST_DBL(0.7666833036850760),
- FL2FXCONST_DBL(0.7679019537675227),FL2FXCONST_DBL(0.7691210875373307),FL2FXCONST_DBL(0.7703407046110011),FL2FXCONST_DBL(0.7715608046057948),
- FL2FXCONST_DBL(0.7727813871397293),FL2FXCONST_DBL(0.7740024518315765),FL2FXCONST_DBL(0.7752239983008605),FL2FXCONST_DBL(0.7764460261678551),
- FL2FXCONST_DBL(0.7776685350535814),FL2FXCONST_DBL(0.7788915245798054),FL2FXCONST_DBL(0.7801149943690360),FL2FXCONST_DBL(0.7813389440445223),
- FL2FXCONST_DBL(0.7825633732302513),FL2FXCONST_DBL(0.7837882815509458),FL2FXCONST_DBL(0.7850136686320621),FL2FXCONST_DBL(0.7862395340997874),
- FL2FXCONST_DBL(0.7874658775810378),FL2FXCONST_DBL(0.7886926987034559),FL2FXCONST_DBL(0.7899199970954088),FL2FXCONST_DBL(0.7911477723859853),
- FL2FXCONST_DBL(0.7923760242049944),FL2FXCONST_DBL(0.7936047521829623),FL2FXCONST_DBL(0.7948339559511308),FL2FXCONST_DBL(0.7960636351414546),
- FL2FXCONST_DBL(0.7972937893865995),FL2FXCONST_DBL(0.7985244183199399),FL2FXCONST_DBL(0.7997555215755570),FL2FXCONST_DBL(0.8009870987882359),
- FL2FXCONST_DBL(0.8022191495934644),FL2FXCONST_DBL(0.8034516736274301),FL2FXCONST_DBL(0.8046846705270185),FL2FXCONST_DBL(0.8059181399298110),
- FL2FXCONST_DBL(0.8071520814740822),FL2FXCONST_DBL(0.8083864947987989),FL2FXCONST_DBL(0.8096213795436166),FL2FXCONST_DBL(0.8108567353488784),
- FL2FXCONST_DBL(0.8120925618556127),FL2FXCONST_DBL(0.8133288587055308),FL2FXCONST_DBL(0.8145656255410253),FL2FXCONST_DBL(0.8158028620051674),
- FL2FXCONST_DBL(0.8170405677417053),FL2FXCONST_DBL(0.8182787423950622),FL2FXCONST_DBL(0.8195173856103341),FL2FXCONST_DBL(0.8207564970332875),
- FL2FXCONST_DBL(0.8219960763103580),FL2FXCONST_DBL(0.8232361230886477),FL2FXCONST_DBL(0.8244766370159234),FL2FXCONST_DBL(0.8257176177406150),
- FL2FXCONST_DBL(0.8269590649118125),FL2FXCONST_DBL(0.8282009781792650),FL2FXCONST_DBL(0.8294433571933784),FL2FXCONST_DBL(0.8306862016052132),
- FL2FXCONST_DBL(0.8319295110664831),FL2FXCONST_DBL(0.8331732852295520),FL2FXCONST_DBL(0.8344175237474336),FL2FXCONST_DBL(0.8356622262737878),
- FL2FXCONST_DBL(0.8369073924629202),FL2FXCONST_DBL(0.8381530219697793),FL2FXCONST_DBL(0.8393991144499545),FL2FXCONST_DBL(0.8406456695596752),
- FL2FXCONST_DBL(0.8418926869558079),FL2FXCONST_DBL(0.8431401662958544),FL2FXCONST_DBL(0.8443881072379507),FL2FXCONST_DBL(0.8456365094408642),
- FL2FXCONST_DBL(0.8468853725639923),FL2FXCONST_DBL(0.8481346962673606),FL2FXCONST_DBL(0.8493844802116208),FL2FXCONST_DBL(0.8506347240580492),
- FL2FXCONST_DBL(0.8518854274685442),FL2FXCONST_DBL(0.8531365901056253),FL2FXCONST_DBL(0.8543882116324307),FL2FXCONST_DBL(0.8556402917127157),
- FL2FXCONST_DBL(0.8568928300108512),FL2FXCONST_DBL(0.8581458261918209),FL2FXCONST_DBL(0.8593992799212207),FL2FXCONST_DBL(0.8606531908652563),
- FL2FXCONST_DBL(0.8619075586907414),FL2FXCONST_DBL(0.8631623830650962),FL2FXCONST_DBL(0.8644176636563452),FL2FXCONST_DBL(0.8656734001331161),
- FL2FXCONST_DBL(0.8669295921646375),FL2FXCONST_DBL(0.8681862394207371),FL2FXCONST_DBL(0.8694433415718407),FL2FXCONST_DBL(0.8707008982889695),
- FL2FXCONST_DBL(0.8719589092437391),FL2FXCONST_DBL(0.8732173741083574),FL2FXCONST_DBL(0.8744762925556232),FL2FXCONST_DBL(0.8757356642589241),
- FL2FXCONST_DBL(0.8769954888922352),FL2FXCONST_DBL(0.8782557661301171),FL2FXCONST_DBL(0.8795164956477146),FL2FXCONST_DBL(0.8807776771207545),
- FL2FXCONST_DBL(0.8820393102255443),FL2FXCONST_DBL(0.8833013946389704),FL2FXCONST_DBL(0.8845639300384969),FL2FXCONST_DBL(0.8858269161021629),
- FL2FXCONST_DBL(0.8870903525085819),FL2FXCONST_DBL(0.8883542389369399),FL2FXCONST_DBL(0.8896185750669933),FL2FXCONST_DBL(0.8908833605790678),
- FL2FXCONST_DBL(0.8921485951540565),FL2FXCONST_DBL(0.8934142784734187),FL2FXCONST_DBL(0.8946804102191776),FL2FXCONST_DBL(0.8959469900739191),
- FL2FXCONST_DBL(0.8972140177207906),FL2FXCONST_DBL(0.8984814928434985),FL2FXCONST_DBL(0.8997494151263077),FL2FXCONST_DBL(0.9010177842540390),
- FL2FXCONST_DBL(0.9022865999120682),FL2FXCONST_DBL(0.9035558617863242),FL2FXCONST_DBL(0.9048255695632878),FL2FXCONST_DBL(0.9060957229299895),
- FL2FXCONST_DBL(0.9073663215740092),FL2FXCONST_DBL(0.9086373651834729),FL2FXCONST_DBL(0.9099088534470528),FL2FXCONST_DBL(0.9111807860539647),
- FL2FXCONST_DBL(0.9124531626939672),FL2FXCONST_DBL(0.9137259830573594),FL2FXCONST_DBL(0.9149992468349805),FL2FXCONST_DBL(0.9162729537182071),
- FL2FXCONST_DBL(0.9175471033989524),FL2FXCONST_DBL(0.9188216955696648),FL2FXCONST_DBL(0.9200967299233258),FL2FXCONST_DBL(0.9213722061534494),
- FL2FXCONST_DBL(0.9226481239540795),FL2FXCONST_DBL(0.9239244830197896),FL2FXCONST_DBL(0.9252012830456805),FL2FXCONST_DBL(0.9264785237273793),
- FL2FXCONST_DBL(0.9277562047610376),FL2FXCONST_DBL(0.9290343258433305),FL2FXCONST_DBL(0.9303128866714547),FL2FXCONST_DBL(0.9315918869431275),
- FL2FXCONST_DBL(0.9328713263565848),FL2FXCONST_DBL(0.9341512046105802),FL2FXCONST_DBL(0.9354315214043836),FL2FXCONST_DBL(0.9367122764377792),
- FL2FXCONST_DBL(0.9379934694110648),FL2FXCONST_DBL(0.9392751000250497),FL2FXCONST_DBL(0.9405571679810542),FL2FXCONST_DBL(0.9418396729809072),
- FL2FXCONST_DBL(0.9431226147269456),FL2FXCONST_DBL(0.9444059929220124),FL2FXCONST_DBL(0.9456898072694558),FL2FXCONST_DBL(0.9469740574731275),
- FL2FXCONST_DBL(0.9482587432373810),FL2FXCONST_DBL(0.9495438642670713),FL2FXCONST_DBL(0.9508294202675522),FL2FXCONST_DBL(0.9521154109446763),
- FL2FXCONST_DBL(0.9534018360047926),FL2FXCONST_DBL(0.9546886951547455),FL2FXCONST_DBL(0.9559759881018738),FL2FXCONST_DBL(0.9572637145540087),
- FL2FXCONST_DBL(0.9585518742194732),FL2FXCONST_DBL(0.9598404668070802),FL2FXCONST_DBL(0.9611294920261317),FL2FXCONST_DBL(0.9624189495864168),
- FL2FXCONST_DBL(0.9637088391982110),FL2FXCONST_DBL(0.9649991605722750),FL2FXCONST_DBL(0.9662899134198524),FL2FXCONST_DBL(0.9675810974526697),
- FL2FXCONST_DBL(0.9688727123829343),FL2FXCONST_DBL(0.9701647579233330),FL2FXCONST_DBL(0.9714572337870316),FL2FXCONST_DBL(0.9727501396876727),
- FL2FXCONST_DBL(0.9740434753393749),FL2FXCONST_DBL(0.9753372404567313),FL2FXCONST_DBL(0.9766314347548087),FL2FXCONST_DBL(0.9779260579491460),
- FL2FXCONST_DBL(0.9792211097557527),FL2FXCONST_DBL(0.9805165898911081),FL2FXCONST_DBL(0.9818124980721600),FL2FXCONST_DBL(0.9831088340163232),
- FL2FXCONST_DBL(0.9844055974414786),FL2FXCONST_DBL(0.9857027880659716),FL2FXCONST_DBL(0.9870004056086111),FL2FXCONST_DBL(0.9882984497886684),
- FL2FXCONST_DBL(0.9895969203258759),FL2FXCONST_DBL(0.9908958169404255),FL2FXCONST_DBL(0.9921951393529680),FL2FXCONST_DBL(0.9934948872846116),
- FL2FXCONST_DBL(0.9947950604569206),FL2FXCONST_DBL(0.9960956585919144),FL2FXCONST_DBL(0.9973966814120665),FL2FXCONST_DBL(0.9986981286403025)
-};
-
-const FIXP_DBL FDKaacEnc_specExpMantTableCombElc[4][14] =
-{
- {FL2FXCONST_DBL(0.5000000000000000), FL2FXCONST_DBL(0.6299605249474366), FL2FXCONST_DBL(0.7937005259840998), FL2FXCONST_DBL(0.5000000000000000),
- FL2FXCONST_DBL(0.6299605249474366), FL2FXCONST_DBL(0.7937005259840998), FL2FXCONST_DBL(0.5000000000000000), FL2FXCONST_DBL(0.6299605249474366),
- FL2FXCONST_DBL(0.7937005259840998), FL2FXCONST_DBL(0.5000000000000000), FL2FXCONST_DBL(0.6299605249474366), FL2FXCONST_DBL(0.7937005259840998),
- FL2FXCONST_DBL(0.5000000000000000), FL2FXCONST_DBL(0.6299605249474366)},
-
- {FL2FXCONST_DBL(0.5946035575013605), FL2FXCONST_DBL(0.7491535384383408), FL2FXCONST_DBL(0.9438743126816935), FL2FXCONST_DBL(0.5946035575013605),
- FL2FXCONST_DBL(0.7491535384383408), FL2FXCONST_DBL(0.9438743126816935), FL2FXCONST_DBL(0.5946035575013605), FL2FXCONST_DBL(0.7491535384383408),
- FL2FXCONST_DBL(0.9438743126816935), FL2FXCONST_DBL(0.5946035575013605), FL2FXCONST_DBL(0.7491535384383408), FL2FXCONST_DBL(0.9438743126816935),
- FL2FXCONST_DBL(0.5946035575013605), FL2FXCONST_DBL(0.7491535384383408)},
-
- {FL2FXCONST_DBL(0.7071067811865476), FL2FXCONST_DBL(0.8908987181403393), FL2FXCONST_DBL(0.5612310241546865), FL2FXCONST_DBL(0.7071067811865476),
- FL2FXCONST_DBL(0.8908987181403393), FL2FXCONST_DBL(0.5612310241546865), FL2FXCONST_DBL(0.7071067811865476), FL2FXCONST_DBL(0.8908987181403393),
- FL2FXCONST_DBL(0.5612310241546865), FL2FXCONST_DBL(0.7071067811865476), FL2FXCONST_DBL(0.8908987181403393), FL2FXCONST_DBL(0.5612310241546865),
- FL2FXCONST_DBL(0.7071067811865476), FL2FXCONST_DBL(0.8908987181403393)},
-
- {FL2FXCONST_DBL(0.8408964152537145), FL2FXCONST_DBL(0.5297315471796477), FL2FXCONST_DBL(0.6674199270850172), FL2FXCONST_DBL(0.8408964152537145),
- FL2FXCONST_DBL(0.5297315471796477), FL2FXCONST_DBL(0.6674199270850172), FL2FXCONST_DBL(0.8408964152537145), FL2FXCONST_DBL(0.5297315471796477),
- FL2FXCONST_DBL(0.6674199270850172), FL2FXCONST_DBL(0.8408964152537145), FL2FXCONST_DBL(0.5297315471796477), FL2FXCONST_DBL(0.6674199270850172),
- FL2FXCONST_DBL(0.8408964152537145), FL2FXCONST_DBL(0.5297315471796477)}
-};
-
-const UCHAR FDKaacEnc_specExpTableComb[4][14] =
-{
- {1, 2, 3, 5, 6, 7, 9, 10, 11, 13, 14, 15, 17, 18},
- {1, 2, 3, 5, 6, 7, 9, 10, 11, 13, 14, 15, 17, 18},
- {1, 2, 4, 5, 6, 8, 9, 10, 12, 13, 14, 16, 17, 18},
- {1, 3, 4, 5, 7, 8, 9, 11, 12, 13, 15, 16, 17, 19}
-};
-
-
-#define WTS0 1
-#define WTS1 0
-#define WTS2 -2
-
-const FIXP_WTB ELDAnalysis512[1536] = {
- /* part 0 */
- WTC0(0xfac5a770), WTC0(0xfaafbab8), WTC0(0xfa996a40), WTC0(0xfa82bbd0), WTC0(0xfa6bb538), WTC0(0xfa545c38), WTC0(0xfa3cb698), WTC0(0xfa24ca28),
- WTC0(0xfa0c9ca8), WTC0(0xf9f433e8), WTC0(0xf9db9580), WTC0(0xf9c2c298), WTC0(0xf9a9b800), WTC0(0xf9907250), WTC0(0xf976ee38), WTC0(0xf95d2b88),
- WTC0(0xf9432d10), WTC0(0xf928f5c0), WTC0(0xf90e8868), WTC0(0xf8f3e400), WTC0(0xf8d903a0), WTC0(0xf8bde238), WTC0(0xf8a27af0), WTC0(0xf886cde8),
- WTC0(0xf86ae020), WTC0(0xf84eb6c0), WTC0(0xf83256f8), WTC0(0xf815c4b8), WTC0(0xf7f902c0), WTC0(0xf7dc13b0), WTC0(0xf7befa60), WTC0(0xf7a1ba40),
- WTC0(0xf78457c0), WTC0(0xf766d780), WTC0(0xf7493d90), WTC0(0xf72b8990), WTC0(0xf70db5f0), WTC0(0xf6efbd30), WTC0(0xf6d19a20), WTC0(0xf6b352e0),
- WTC0(0xf694f8c0), WTC0(0xf6769da0), WTC0(0xf6585310), WTC0(0xf63a28d0), WTC0(0xf61c2c60), WTC0(0xf5fe6b10), WTC0(0xf5e0f250), WTC0(0xf5c3ceb0),
- WTC0(0xf5a70be0), WTC0(0xf58ab5a0), WTC0(0xf56ed7b0), WTC0(0xf5537e40), WTC0(0xf538b610), WTC0(0xf51e8bf0), WTC0(0xf5050c90), WTC0(0xf4ec4330),
- WTC0(0xf4d439b0), WTC0(0xf4bcf9b0), WTC0(0xf4a68ce0), WTC0(0xf490fa80), WTC0(0xf47c4760), WTC0(0xf4687830), WTC0(0xf4558f00), WTC0(0xf4434fc0),
- WTC0(0xf4314070), WTC0(0xf41ee450), WTC0(0xf40bc130), WTC0(0xf3f799c0), WTC0(0xf3e26d30), WTC0(0xf3cc3d70), WTC0(0xf3b50c80), WTC0(0xf39cdd60),
- WTC0(0xf383b440), WTC0(0xf3699550), WTC0(0xf34e84c0), WTC0(0xf33286b0), WTC0(0xf3159f10), WTC0(0xf2f7d1b0), WTC0(0xf2d92290), WTC0(0xf2b994d0),
- WTC0(0xf2992ad0), WTC0(0xf277e6d0), WTC0(0xf255cb60), WTC0(0xf232dd00), WTC0(0xf20f2240), WTC0(0xf1eaa1d0), WTC0(0xf1c56240), WTC0(0xf19f63d0),
- WTC0(0xf178a0f0), WTC0(0xf15113a0), WTC0(0xf128b5c0), WTC0(0xf0ff7fd0), WTC0(0xf0d56860), WTC0(0xf0aa6610), WTC0(0xf07e6fd0), WTC0(0xf0518190),
- WTC0(0xf0239cd0), WTC0(0xeff4c320), WTC0(0xefc4f720), WTC0(0xef945080), WTC0(0xef62fce0), WTC0(0xef312a40), WTC0(0xeeff05c0), WTC0(0xeecca2c0),
- WTC0(0xee99faa0), WTC0(0xee6705a0), WTC0(0xee33bb60), WTC0(0xee000060), WTC0(0xedcba660), WTC0(0xed967e80), WTC0(0xed605b80), WTC0(0xed293b40),
- WTC0(0xecf146a0), WTC0(0xecb8a8a0), WTC0(0xec7f8bc0), WTC0(0xec461260), WTC0(0xec0c5720), WTC0(0xebd27440), WTC0(0xeb988220), WTC0(0xeb5e7040),
- WTC0(0xeb2404c0), WTC0(0xeae90440), WTC0(0xeaad33c0), WTC0(0xea7066c0), WTC0(0xea327f60), WTC0(0xe9f36000), WTC0(0xe9b2ed60), WTC0(0xe9713920),
- WTC0(0xe92e81e0), WTC0(0xe8eb08c0), WTC0(0xe8a70e60), WTC0(0xe862d8e0), WTC0(0xe81eb340), WTC0(0xe7dae8a0), WTC0(0xe797c1a0), WTC0(0xe7554ca0),
- WTC0(0xe7135dc0), WTC0(0xe6d1c6a0), WTC0(0xe6905720), WTC0(0xe64eb9c0), WTC0(0xe60c7300), WTC0(0xe5c90600), WTC0(0xe583f920), WTC0(0xe53d1ce0),
- WTC0(0xe4f48c80), WTC0(0xe4aa6640), WTC0(0xe45ecaa0), WTC0(0xe4120be0), WTC0(0xe3c4ae60), WTC0(0xe3773860), WTC0(0xe32a2ea0), WTC0(0xe2ddeea0),
- WTC0(0xe292af00), WTC0(0xe248a4a0), WTC0(0xe2000140), WTC0(0xe1b8b640), WTC0(0xe1727440), WTC0(0xe12ce900), WTC0(0xe0e7c280), WTC0(0xe0a2b420),
- WTC0(0xe05d76c0), WTC0(0xe017c360), WTC0(0xdfd15440), WTC0(0xdf8a0540), WTC0(0xdf41d300), WTC0(0xdef8bb40), WTC0(0xdeaebd40), WTC0(0xde63e7c0),
- WTC0(0xde185940), WTC0(0xddcc3180), WTC0(0xdd7f9000), WTC0(0xdd329e80), WTC0(0xdce58e80), WTC0(0xdc989300), WTC0(0xdc4bde40), WTC0(0xdbff96c0),
- WTC0(0xdbb3d780), WTC0(0xdb68bb80), WTC0(0xdb1e5c80), WTC0(0xdad4c380), WTC0(0xda8be840), WTC0(0xda43c1c0), WTC0(0xd9fc4740), WTC0(0xd9b56640),
- WTC0(0xd96f0440), WTC0(0xd9290600), WTC0(0xd8e35080), WTC0(0xd89dcd40), WTC0(0xd8586b40), WTC0(0xd8131940), WTC0(0xd7cdc640), WTC0(0xd7886180),
- WTC0(0xd742dc80), WTC0(0xd6fd2780), WTC0(0xd6b73400), WTC0(0xd670fd80), WTC0(0xd62a8a40), WTC0(0xd5e3e080), WTC0(0xd59d0840), WTC0(0xd5562b80),
- WTC0(0xd50f9540), WTC0(0xd4c992c0), WTC0(0xd4846f80), WTC0(0xd4405a80), WTC0(0xd3fd6580), WTC0(0xd3bba140), WTC0(0xd37b1c80), WTC0(0xd33bb780),
- WTC0(0xd2fd2400), WTC0(0xd2bf1240), WTC0(0xd2813300), WTC0(0xd2435ac0), WTC0(0xd2057fc0), WTC0(0xd1c79a00), WTC0(0xd189a240), WTC0(0xd14b9dc0),
- WTC0(0xd10d9e00), WTC0(0xd0cfb580), WTC0(0xd091f6c0), WTC0(0xd0548100), WTC0(0xd0177f40), WTC0(0xcfdb1cc0), WTC0(0xcf9f84c0), WTC0(0xcf64d780),
- WTC0(0xcf2b2b00), WTC0(0xcef29440), WTC0(0xcebb2640), WTC0(0xce84c000), WTC0(0xce4f0bc0), WTC0(0xce19b200), WTC0(0xcde45d40), WTC0(0xcdaeedc0),
- WTC0(0xcd7979c0), WTC0(0xcd4419c0), WTC0(0xcd0ee6c0), WTC0(0xccda0540), WTC0(0xcca5a500), WTC0(0xcc71f640), WTC0(0xcc3f2800), WTC0(0xcc0d4300),
- WTC0(0xcbdc2a00), WTC0(0xcbabbe80), WTC0(0xcb7be200), WTC0(0xcb4c8200), WTC0(0xcb1d9800), WTC0(0xcaef1d40), WTC0(0xcac10bc0), WTC0(0xca936440),
- WTC0(0xca662d00), WTC0(0xca396d40), WTC0(0xca0d2b80), WTC0(0xc9e16f80), WTC0(0xc9b63f80), WTC0(0xc98ba2c0), WTC0(0xc961a000), WTC0(0xc9383ec0),
- WTC0(0xc90a0440), WTC0(0xc8e0d280), WTC0(0xc8b73b80), WTC0(0xc88d4900), WTC0(0xc86304c0), WTC0(0xc83878c0), WTC0(0xc80dae80), WTC0(0xc7e2afc0),
- WTC0(0xc7b78640), WTC0(0xc78c3c40), WTC0(0xc760da80), WTC0(0xc7356640), WTC0(0xc709de40), WTC0(0xc6de41c0), WTC0(0xc6b28fc0), WTC0(0xc686bd40),
- WTC0(0xc65ab600), WTC0(0xc62e6580), WTC0(0xc601b880), WTC0(0xc5d4bac0), WTC0(0xc5a79640), WTC0(0xc57a76c0), WTC0(0xc54d8780), WTC0(0xc520e840),
- WTC0(0xc4f4acc0), WTC0(0xc4c8e880), WTC0(0xc49dad80), WTC0(0xc472e640), WTC0(0xc44856c0), WTC0(0xc41dc140), WTC0(0xc3f2e940), WTC0(0xc3c7bc00),
- WTC0(0xc39c4f00), WTC0(0xc370b9c0), WTC0(0xc34513c0), WTC0(0xc3197940), WTC0(0xc2ee0a00), WTC0(0xc2c2e640), WTC0(0xc2982d80), WTC0(0xc26df5c0),
- WTC0(0xc2444b00), WTC0(0xc21b3940), WTC0(0xc1f2cbc0), WTC0(0xc1cb05c0), WTC0(0xc1a3e340), WTC0(0xc17d5f00), WTC0(0xc15773c0), WTC0(0xc1320940),
- WTC0(0xc10cf480), WTC0(0xc0e80a00), WTC0(0xc0c31f00), WTC0(0xc09e2640), WTC0(0xc0792ec0), WTC0(0xc0544940), WTC0(0xc02f86c0), WTC0(0xc00b04c0),
- WTC0(0xbfe6ed01), WTC0(0xbfc36a01), WTC0(0xbfa0a581), WTC0(0xbf7eb581), WTC0(0xbf5d9a81), WTC0(0xbf3d5501), WTC0(0xbf1de601), WTC0(0xbeff4801),
- WTC0(0xbee17201), WTC0(0xbec45881), WTC0(0xbea7f301), WTC0(0xbe8c3781), WTC0(0xbe712001), WTC0(0xbe56a381), WTC0(0xbe3cbc01), WTC0(0xbe236001),
- WTC0(0xbe0a8581), WTC0(0xbdf22181), WTC0(0xbdda2a01), WTC0(0xbdc29a81), WTC0(0xbdab7181), WTC0(0xbd94b001), WTC0(0xbd7e5581), WTC0(0xbd686681),
- WTC0(0xbd52eb01), WTC0(0xbd3deb81), WTC0(0xbd297181), WTC0(0xbd158801), WTC0(0xbd023f01), WTC0(0xbcefa601), WTC0(0xbcddcc81), WTC0(0xbcccbd01),
- WTC0(0xbcbc7e01), WTC0(0xbcad1501), WTC0(0xbc9e8801), WTC0(0xbc90d481), WTC0(0xbc83f201), WTC0(0xbc77d601), WTC0(0xbc6c7781), WTC0(0xbc61c401),
- WTC0(0xbc57a301), WTC0(0xbc4dfb81), WTC0(0xbc44b481), WTC0(0xbc3bbc01), WTC0(0xbc330781), WTC0(0xbc2a8c81), WTC0(0xbc224181), WTC0(0xbc1a2401),
- WTC0(0xbc123b81), WTC0(0xbc0a8f01), WTC0(0xbc032601), WTC0(0xbbfc0f81), WTC0(0xbbf56181), WTC0(0xbbef3301), WTC0(0xbbe99981), WTC0(0xbbe49d01),
- WTC0(0xbbe03801), WTC0(0xbbdc6481), WTC0(0xbbd91b81), WTC0(0xbbd64d01), WTC0(0xbbd3e101), WTC0(0xbbd1bd81), WTC0(0xbbcfca81), WTC0(0xbbce0601),
- WTC0(0xbbcc8201), WTC0(0xbbcb5301), WTC0(0xbbca8d01), WTC0(0xbbca5081), WTC0(0xbbcaca01), WTC0(0xbbcc2681), WTC0(0xbbce9181), WTC0(0xbbd21281),
- WTC0(0xbbd68c81), WTC0(0xbbdbe201), WTC0(0xbbe1f401), WTC0(0xbbe89901), WTC0(0xbbef9b81), WTC0(0xbbf6c601), WTC0(0xbbfde481), WTC0(0xbc04e381),
- WTC0(0xbc0bcf81), WTC0(0xbc12b801), WTC0(0xbc19ab01), WTC0(0xbc20ae01), WTC0(0xbc27bd81), WTC0(0xbc2ed681), WTC0(0xbc35f501), WTC0(0xbc3d1801),
- WTC0(0xbc444081), WTC0(0xbc4b6e81), WTC0(0xbc52a381), WTC0(0xbc59df81), WTC0(0xbc612301), WTC0(0xbc686e01), WTC0(0xbc6fc101), WTC0(0xbc771c01),
- WTC0(0xbc7e7e01), WTC0(0xbc85e801), WTC0(0xbc8d5901), WTC0(0xbc94d201), WTC0(0xbc9c5281), WTC0(0xbca3db01), WTC0(0xbcab6c01), WTC0(0xbcb30601),
- WTC0(0xbcbaa801), WTC0(0xbcc25181), WTC0(0xbcca0301), WTC0(0xbcd1bb81), WTC0(0xbcd97c81), WTC0(0xbce14601), WTC0(0xbce91801), WTC0(0xbcf0f381),
- WTC0(0xbcf8d781), WTC0(0xbd00c381), WTC0(0xbd08b781), WTC0(0xbd10b381), WTC0(0xbd18b781), WTC0(0xbd20c401), WTC0(0xbd28d981), WTC0(0xbd30f881),
- WTC0(0xbd391f81), WTC0(0xbd414f01), WTC0(0xbd498601), WTC0(0xbd51c481), WTC0(0xbd5a0b01), WTC0(0xbd625981), WTC0(0xbd6ab101), WTC0(0xbd731081),
- WTC0(0xbd7b7781), WTC0(0xbd83e681), WTC0(0xbd8c5c01), WTC0(0xbd94d801), WTC0(0xbd9d5b81), WTC0(0xbda5e601), WTC0(0xbdae7881), WTC0(0xbdb71201),
- WTC0(0xbdbfb281), WTC0(0xbdc85981), WTC0(0xbdd10681), WTC0(0xbdd9b981), WTC0(0xbde27201), WTC0(0xbdeb3101), WTC0(0xbdf3f701), WTC0(0xbdfcc301),
- WTC0(0xbe059481), WTC0(0xbe0e6c01), WTC0(0xbe174781), WTC0(0xbe202801), WTC0(0xbe290d01), WTC0(0xbe31f701), WTC0(0xbe3ae601), WTC0(0xbe43da81),
- WTC0(0xbe4cd381), WTC0(0xbe55d001), WTC0(0xbe5ed081), WTC0(0xbe67d381), WTC0(0xbe70da01), WTC0(0xbe79e481), WTC0(0xbe82f301), WTC0(0xbe8c0501),
- WTC0(0xbe951a81), WTC0(0xbe9e3281), WTC0(0xbea74c81), WTC0(0xbeb06881), WTC0(0xbeb98681), WTC0(0xbec2a781), WTC0(0xbecbca81), WTC0(0xbed4f081),
- WTC0(0xbede1901), WTC0(0xbee74281), WTC0(0xbef06d01), WTC0(0xbef99901), WTC0(0xbf02c581), WTC0(0xbf0bf381), WTC0(0xbf152381), WTC0(0xbf1e5501),
- WTC0(0xbf278801), WTC0(0xbf30bb01), WTC0(0xbf39ee81), WTC0(0xbf432281), WTC0(0xbf4c5681), WTC0(0xbf558b01), WTC0(0xbf5ec101), WTC0(0xbf67f801),
- WTC0(0xbf712f01), WTC0(0xbf7a6681), WTC0(0xbf839d81), WTC0(0xbf8cd481), WTC0(0xbf960b01), WTC0(0xbf9f4181), WTC0(0xbfa87901), WTC0(0xbfb1b101),
- WTC0(0xbfbae981), WTC0(0xbfc42201), WTC0(0xbfcd5a01), WTC0(0xbfd69101), WTC0(0xbfdfc781), WTC0(0xbfe8fc01), WTC0(0xbff22f81), WTC0(0xbffb6081),
- /* part 1 */
- WTC1(0x80093e01), WTC1(0x801b9b01), WTC1(0x802df701), WTC1(0x80405101), WTC1(0x8052a881), WTC1(0x8064fc81), WTC1(0x80774c81), WTC1(0x80899881),
- WTC1(0x809bdf01), WTC1(0x80ae1f81), WTC1(0x80c05a01), WTC1(0x80d28d81), WTC1(0x80e4bb81), WTC1(0x80f6e481), WTC1(0x81090981), WTC1(0x811b2981),
- WTC1(0x812d4481), WTC1(0x813f5981), WTC1(0x81516701), WTC1(0x81636d81), WTC1(0x81756d81), WTC1(0x81876781), WTC1(0x81995c01), WTC1(0x81ab4b01),
- WTC1(0x81bd3401), WTC1(0x81cf1581), WTC1(0x81e0ee81), WTC1(0x81f2bf81), WTC1(0x82048881), WTC1(0x82164a81), WTC1(0x82280581), WTC1(0x8239b981),
- WTC1(0x824b6601), WTC1(0x825d0901), WTC1(0x826ea201), WTC1(0x82803101), WTC1(0x8291b601), WTC1(0x82a33281), WTC1(0x82b4a601), WTC1(0x82c61101),
- WTC1(0x82d77201), WTC1(0x82e8c801), WTC1(0x82fa1181), WTC1(0x830b4f81), WTC1(0x831c8101), WTC1(0x832da781), WTC1(0x833ec381), WTC1(0x834fd481),
- WTC1(0x8360d901), WTC1(0x8371d081), WTC1(0x8382ba01), WTC1(0x83939501), WTC1(0x83a46181), WTC1(0x83b52101), WTC1(0x83c5d381), WTC1(0x83d67881),
- WTC1(0x83e70f01), WTC1(0x83f79681), WTC1(0x84080d81), WTC1(0x84187401), WTC1(0x8428ca01), WTC1(0x84391081), WTC1(0x84494881), WTC1(0x84597081),
- WTC1(0x84698881), WTC1(0x84798f81), WTC1(0x84898481), WTC1(0x84996701), WTC1(0x84a93801), WTC1(0x84b8f801), WTC1(0x84c8a701), WTC1(0x84d84601),
- WTC1(0x84e7d381), WTC1(0x84f74e01), WTC1(0x8506b581), WTC1(0x85160981), WTC1(0x85254a81), WTC1(0x85347901), WTC1(0x85439601), WTC1(0x8552a181),
- WTC1(0x85619a01), WTC1(0x85707f81), WTC1(0x857f5101), WTC1(0x858e0e01), WTC1(0x859cb781), WTC1(0x85ab4f01), WTC1(0x85b9d481), WTC1(0x85c84801),
- WTC1(0x85d6a981), WTC1(0x85e4f801), WTC1(0x85f33281), WTC1(0x86015981), WTC1(0x860f6e01), WTC1(0x861d7081), WTC1(0x862b6201), WTC1(0x86394301),
- WTC1(0x86471281), WTC1(0x8654d001), WTC1(0x86627b01), WTC1(0x86701381), WTC1(0x867d9a81), WTC1(0x868b1001), WTC1(0x86987581), WTC1(0x86a5ca81),
- WTC1(0x86b30f01), WTC1(0x86c04381), WTC1(0x86cd6681), WTC1(0x86da7901), WTC1(0x86e77b81), WTC1(0x86f46d81), WTC1(0x87014f81), WTC1(0x870e2301),
- WTC1(0x871ae981), WTC1(0x8727a381), WTC1(0x87345381), WTC1(0x8740f681), WTC1(0x874d8681), WTC1(0x8759fd01), WTC1(0x87665481), WTC1(0x87729701),
- WTC1(0x877ede01), WTC1(0x878b4301), WTC1(0x8797dd81), WTC1(0x87a48b01), WTC1(0x87b0ef01), WTC1(0x87bcab81), WTC1(0x87c76201), WTC1(0x87d0ca81),
- WTC1(0x87fdd781), WTC1(0x881dd301), WTC1(0x88423301), WTC1(0x886a8a81), WTC1(0x88962981), WTC1(0x88c45e81), WTC1(0x88f47901), WTC1(0x8925f101),
- WTC1(0x89586901), WTC1(0x898b8301), WTC1(0x89bee581), WTC1(0x89f26101), WTC1(0x8a25f301), WTC1(0x8a599a81), WTC1(0x8a8d5801), WTC1(0x8ac13381),
- WTC1(0x8af53e81), WTC1(0x8b298b81), WTC1(0x8b5e2c81), WTC1(0x8b933001), WTC1(0x8bc8a401), WTC1(0x8bfe9401), WTC1(0x8c350d01), WTC1(0x8c6c1b01),
- WTC1(0x8ca3cb01), WTC1(0x8cdc2901), WTC1(0x8d154081), WTC1(0x8d4f1b01), WTC1(0x8d89be81), WTC1(0x8dc53001), WTC1(0x8e017581), WTC1(0x8e3e9481),
- WTC1(0x8e7c9301), WTC1(0x8ebb7581), WTC1(0x8efb4181), WTC1(0x8f3bfb01), WTC1(0x8f7da401), WTC1(0x8fc03f01), WTC1(0x9003ce81), WTC1(0x90485401),
- WTC1(0x908dd101), WTC1(0x90d44781), WTC1(0x911bb981), WTC1(0x91642781), WTC1(0x91ad9281), WTC1(0x91f7f981), WTC1(0x92435d01), WTC1(0x928fbe01),
- WTC1(0x92dd1b01), WTC1(0x932b7501), WTC1(0x937acb01), WTC1(0x93cb1c81), WTC1(0x941c6901), WTC1(0x946eaf81), WTC1(0x94c1ee01), WTC1(0x95162381),
- WTC1(0x956b4f81), WTC1(0x95c17081), WTC1(0x96188501), WTC1(0x96708b81), WTC1(0x96c98381), WTC1(0x97236b01), WTC1(0x977e4181), WTC1(0x97da0481),
- WTC1(0x9836b201), WTC1(0x98944901), WTC1(0x98f2c601), WTC1(0x99522801), WTC1(0x99b26c81), WTC1(0x9a139101), WTC1(0x9a759301), WTC1(0x9ad87081),
- WTC1(0x9b3c2801), WTC1(0x9ba0b701), WTC1(0x9c061b81), WTC1(0x9c6c5481), WTC1(0x9cd35f81), WTC1(0x9d3b3b81), WTC1(0x9da3e601), WTC1(0x9e0d5e01),
- WTC1(0x9e779f81), WTC1(0x9ee2a901), WTC1(0x9f4e7801), WTC1(0x9fbb0981), WTC1(0xa0285d81), WTC1(0xa0967201), WTC1(0xa1054701), WTC1(0xa174da81),
- WTC1(0xa1e52a81), WTC1(0xa2563501), WTC1(0xa2c7f801), WTC1(0xa33a7201), WTC1(0xa3ada281), WTC1(0xa4218801), WTC1(0xa4962181), WTC1(0xa50b6e81),
- WTC1(0xa5816e81), WTC1(0xa5f81f81), WTC1(0xa66f8201), WTC1(0xa6e79401), WTC1(0xa7605601), WTC1(0xa7d9c681), WTC1(0xa853e501), WTC1(0xa8ceb201),
- WTC1(0xa94a2c01), WTC1(0xa9c65401), WTC1(0xaa432981), WTC1(0xaac0ad01), WTC1(0xab3edf01), WTC1(0xabbdc001), WTC1(0xac3d5001), WTC1(0xacbd9081),
- WTC1(0xad3e8101), WTC1(0xadc02281), WTC1(0xae427481), WTC1(0xaec57801), WTC1(0xaf492f01), WTC1(0xafcd9a81), WTC1(0xb052bc01), WTC1(0xb0d89401),
- WTC1(0xb15f2381), WTC1(0xb1e66a01), WTC1(0xb26e6881), WTC1(0xb2f71f01), WTC1(0xb3808d81), WTC1(0xb40ab501), WTC1(0xb4959501), WTC1(0xb5212e81),
- WTC1(0x4a6cf67f), WTC1(0x49dffeff), WTC1(0x495265ff), WTC1(0x48c4277f), WTC1(0x4835407f), WTC1(0x47a5aeff), WTC1(0x471570ff), WTC1(0x468484ff),
- WTC1(0x45f2eaff), WTC1(0x4560a2ff), WTC1(0x44cdad7f), WTC1(0x443a0c7f), WTC1(0x43a5c07f), WTC1(0x4310caff), WTC1(0x427b2bff), WTC1(0x41e4e3ff),
- WTC1(0x414df2ff), WTC1(0x40b6557f), WTC1(0x401e06ff), WTC1(0x3f8503c0), WTC1(0x3eeb4e00), WTC1(0x3e50ebc0), WTC1(0x3db5e680), WTC1(0x3d1a4680),
- WTC1(0x3c7e10c0), WTC1(0x3be14cc0), WTC1(0x3b4402c0), WTC1(0x3aa63800), WTC1(0x3a07e840), WTC1(0x39690880), WTC1(0x38c98700), WTC1(0x38295b40),
- WTC1(0x37888a80), WTC1(0x36e71d40), WTC1(0x36451d80), WTC1(0x35a29400), WTC1(0x34ff8800), WTC1(0x345c04c0), WTC1(0x33b81940), WTC1(0x3313d200),
- WTC1(0x326f3800), WTC1(0x31ca5600), WTC1(0x31253840), WTC1(0x307fe8c0), WTC1(0x2fda6e40), WTC1(0x2f34ce40), WTC1(0x2e8f0e40), WTC1(0x2de92ec0),
- WTC1(0x2d432780), WTC1(0x2c9cea40), WTC1(0x2bf66300), WTC1(0x2b4f88c0), WTC1(0x2aa864c0), WTC1(0x2a010240), WTC1(0x29596e40), WTC1(0x28b1ba80),
- WTC1(0x2809ff40), WTC1(0x27625b80), WTC1(0x26baf580), WTC1(0x2613e7c0), WTC1(0x256d3dc0), WTC1(0x24c70300), WTC1(0x24214380), WTC1(0x237c0800),
- WTC1(0x22d75400), WTC1(0x22332a80), WTC1(0x218f8cc0), WTC1(0x20ec7e40), WTC1(0x204a04c0), WTC1(0x1fa82540), WTC1(0x1f06e300), WTC1(0x1e664000),
- WTC1(0x1dc63bc0), WTC1(0x1d26d3c0), WTC1(0x1c8803a0), WTC1(0x1be9cc40), WTC1(0x1b4c34c0), WTC1(0x1aaf4480), WTC1(0x1a130260), WTC1(0x197774a0),
- WTC1(0x18dca260), WTC1(0x184294e0), WTC1(0x17a95840), WTC1(0x1710fd80), WTC1(0x16799ce0), WTC1(0x15e35340), WTC1(0x154e41a0), WTC1(0x14ba8360),
- WTC1(0x14282be0), WTC1(0x13975100), WTC1(0x13080aa0), WTC1(0x127a6240), WTC1(0x11ee50a0), WTC1(0x1163cc80), WTC1(0x10dacb20), WTC1(0x105333a0),
- WTC1(0x0fccdb30), WTC1(0x0f478f40), WTC1(0x0ec31700), WTC1(0x0e3f4e80), WTC1(0x0dbc27f0), WTC1(0x0d399000), WTC1(0x0cb76d00), WTC1(0x0c359d50),
- WTC1(0x0bb3fd50), WTC1(0x0b326bd0), WTC1(0x0ab0ca80), WTC1(0x0a2f0dc0), WTC1(0x09ad40c0), WTC1(0x092b7a90), WTC1(0x08a9db80), WTC1(0x08285c80),
- WTC1(0x07a6c7b8), WTC1(0x0724e4e0), WTC1(0x06a27b80), WTC1(0x061f52f8), WTC1(0x059b2ad0), WTC1(0x0515b568), WTC1(0x048ea058), WTC1(0x04066408),
- WTC1(0x037e52d8), WTC1(0x02f7d3c8), WTC1(0x0274614c), WTC1(0x01f63008), WTC1(0x0180403a), WTC1(0x0115c442), WTC1(0x00ba09e2), WTC1(0x006f077c),
- WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000),
- WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000),
- WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000),
- WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000),
- WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000),
- WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000),
- WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000),
- WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000),
- WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000),
- WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000),
- WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000),
- WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000),
- WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000),
- WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000),
- WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000),
- WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000),
- /* part 2 */
- WTC2(0xfff36be1), WTC2(0xffdafbc1), WTC2(0xffc28035), WTC2(0xffa9fe8a), WTC2(0xff917c08), WTC2(0xff78fdfc), WTC2(0xff6089af), WTC2(0xff48246c),
- WTC2(0xff2fd37f), WTC2(0xff179c31), WTC2(0xfeff83b6), WTC2(0xfee78d18), WTC2(0xfecfb93e), WTC2(0xfeb808f2), WTC2(0xfea07d06), WTC2(0xfe8916b4),
- WTC2(0xfe71d7a0), WTC2(0xfe5ac174), WTC2(0xfe43d5d6), WTC2(0xfe2d167e), WTC2(0xfe16852e), WTC2(0xfe0023a6), WTC2(0xfde9f3f8), WTC2(0xfdd3ff7c),
- WTC2(0xfdbe56c0), WTC2(0xfda90aa8), WTC2(0xfd942b78), WTC2(0xfd7fbb20), WTC2(0xfd6bad50), WTC2(0xfd57f510), WTC2(0xfd44857c), WTC2(0xfd3153fc),
- WTC2(0xfd1e5840), WTC2(0xfd0b8a0c), WTC2(0xfcf8e180), WTC2(0xfce65eec), WTC2(0xfcd40ad0), WTC2(0xfcc1ee0c), WTC2(0xfcb011e8), WTC2(0xfc9e896c),
- WTC2(0xfc8d716c), WTC2(0xfc7ce720), WTC2(0xfc6d072c), WTC2(0xfc5de09c), WTC2(0xfc4f74e8), WTC2(0xfc41c4e8), WTC2(0xfc34d0dc), WTC2(0xfc288a68),
- WTC2(0xfc1cd49c), WTC2(0xfc1191e0), WTC2(0xfc06a4d0), WTC2(0xfbfbf3e8), WTC2(0xfbf16990), WTC2(0xfbe6f068), WTC2(0xfbdc7428), WTC2(0xfbd1fc68),
- WTC2(0xfbc7ac50), WTC2(0xfbbda868), WTC2(0xfbb41500), WTC2(0xfbab1438), WTC2(0xfba2c5f8), WTC2(0xfb9b4a00), WTC2(0xfb94bfa8), WTC2(0xfb8f3b48),
- WTC2(0xfb8ac638), WTC2(0xfb876970), WTC2(0xfb852d20), WTC2(0xfb840ae0), WTC2(0xfb83ed60), WTC2(0xfb84bec0), WTC2(0xfb866918), WTC2(0xfb88d4a8),
- WTC2(0xfb8be810), WTC2(0xfb8f89d0), WTC2(0xfb93a080), WTC2(0xfb981418), WTC2(0xfb9ccdf0), WTC2(0xfba1b770), WTC2(0xfba6bae0), WTC2(0xfbabd5c0),
- WTC2(0xfbb118d8), WTC2(0xfbb695c0), WTC2(0xfbbc5e90), WTC2(0xfbc29030), WTC2(0xfbc95268), WTC2(0xfbd0cd78), WTC2(0xfbd929c8), WTC2(0xfbe294d0),
- WTC2(0xfbed4108), WTC2(0xfbf96118), WTC2(0xfc0726c8), WTC2(0xfc16b064), WTC2(0xfc280890), WTC2(0xfc3b3920), WTC2(0xfc504a98), WTC2(0xfc67271c),
- WTC2(0xfc7f9a74), WTC2(0xfc996f18), WTC2(0xfcb46eb8), WTC2(0xfcd050b0), WTC2(0xfcecba24), WTC2(0xfd094f64), WTC2(0xfd25b720), WTC2(0xfd41ce40),
- WTC2(0xfd5da7f8), WTC2(0xfd7959d8), WTC2(0xfd94fb74), WTC2(0xfdb0d3fc), WTC2(0xfdcd5a34), WTC2(0xfdeb06e4), WTC2(0xfe0a5184), WTC2(0xfe2b92c4),
- WTC2(0xfe4f0486), WTC2(0xfe74df54), WTC2(0xfe9d5886), WTC2(0xfec85b92), WTC2(0xfef58a16), WTC2(0xff248275), WTC2(0xff54e401), WTC2(0xff866330),
- WTC2(0xffb8c99b), WTC2(0xffebe1c9), WTC2(0x001f786a), WTC2(0x00538bf9), WTC2(0x00884cbc), WTC2(0x00bded23), WTC2(0x00f49f54), WTC2(0x012c8ee4),
- WTC2(0x0165e0d2), WTC2(0x01a0b9d6), WTC2(0x01dd3d80), WTC2(0x021b74d4), WTC2(0x025b4e48), WTC2(0x029cb730), WTC2(0x02df9d0c), WTC2(0x0323f1a4),
- WTC2(0x0369ab00), WTC2(0x03b0bf5c), WTC2(0x03f925a0), WTC2(0x0442e3d8), WTC2(0x048e0f40), WTC2(0x04dabdb0), WTC2(0x05290430), WTC2(0x0578e428),
- WTC2(0x05ca4b60), WTC2(0x061d26c0), WTC2(0x067163d8), WTC2(0x06c6ff10), WTC2(0x071e03b0), WTC2(0x07767da0), WTC2(0x07d07918), WTC2(0x082c08e0),
- WTC2(0x08894660), WTC2(0x08e84b70), WTC2(0x094930b0), WTC2(0x09abf8d0), WTC2(0x0a109020), WTC2(0x0a76e210), WTC2(0x0adeda50), WTC2(0x0b486b80),
- WTC2(0x0bb38f00), WTC2(0x0c203e80), WTC2(0x0c8e73e0), WTC2(0x0cfe2c30), WTC2(0x0d6f6820), WTC2(0x0de22850), WTC2(0x0e566d90), WTC2(0x0ecc3dd0),
- WTC2(0x0f43a3a0), WTC2(0x0fbca9f0), WTC2(0x10375b80), WTC2(0x10b3be20), WTC2(0x1131d280), WTC2(0x11b19960), WTC2(0x123313a0), WTC2(0x12b64380),
- WTC2(0x133b2d00), WTC2(0x13c1d440), WTC2(0x144a3d60), WTC2(0x14d46900), WTC2(0x15605480), WTC2(0x15edfd20), WTC2(0x167d6040), WTC2(0x170e7e80),
- WTC2(0x17a15b80), WTC2(0x1835fb00), WTC2(0x18cc60a0), WTC2(0x19648dc0), WTC2(0x19fe80e0), WTC2(0x1a9a38a0), WTC2(0x1b37b3e0), WTC2(0x1bd6f400),
- WTC2(0x1c77fd20), WTC2(0x1d1ad400), WTC2(0x1dbf7c80), WTC2(0x1e65f820), WTC2(0x1f0e4540), WTC2(0x1fb861e0), WTC2(0x20644cc0), WTC2(0x21120640),
- WTC2(0x21c19240), WTC2(0x2272f480), WTC2(0x23263000), WTC2(0x23db4580), WTC2(0x24923340), WTC2(0x254af700), WTC2(0x26058e80), WTC2(0x26c1fa00),
- WTC2(0x27803d00), WTC2(0x28405a40), WTC2(0x29025500), WTC2(0x29c62d40), WTC2(0x2a8be0c0), WTC2(0x2b536cc0), WTC2(0x2c1ccf80), WTC2(0x2ce80840),
- WTC2(0x2db519c0), WTC2(0x2e840600), WTC2(0x2f54cf80), WTC2(0x302775c0), WTC2(0x30fbf640), WTC2(0x31d24e00), WTC2(0x32aa7a00), WTC2(0x338479c0),
- WTC2(0x34604e40), WTC2(0x353df900), WTC2(0x361d7ac0), WTC2(0x36fed200), WTC2(0x37e1fb40), WTC2(0x38c6f240), WTC2(0x39adb2c0), WTC2(0x3a963a00),
- WTC2(0x3b808740), WTC2(0x3c6c9880), WTC2(0x3d5a6cc0), WTC2(0x3e4a0040), WTC2(0x3f3b4bc0), WTC2(0x402e48ff), WTC2(0x4122f17f), WTC2(0x42193f7f),
- WTC2(0x43112eff), WTC2(0x440abbff), WTC2(0x4505e2ff), WTC2(0x46029e7f), WTC2(0x4700e9ff), WTC2(0x4800bfff), WTC2(0x49021bff), WTC2(0x4a050eff),
- WTC2(0x4b09bc7f), WTC2(0x4c104aff), WTC2(0x4d18df7f), WTC2(0x4e23a07f), WTC2(0x4f30b2ff), WTC2(0x50403c7f), WTC2(0x515262ff), WTC2(0x52674b7f),
- WTC2(0x001678b2), WTC2(0x00061a3b), WTC2(0xfffb4622), WTC2(0xfff5ea94), WTC2(0xfff5f5b9), WTC2(0xfffb55bd), WTC2(0x0005f8cb), WTC2(0x0015cd0c),
- WTC2(0x002ac0ac), WTC2(0x0044c1d5), WTC2(0x0063beb2), WTC2(0x0087a56d), WTC2(0x00b06431), WTC2(0x00dde929), WTC2(0x01102280), WTC2(0x0146fe5e),
- WTC2(0x01826af2), WTC2(0x01c25662), WTC2(0x0206aedc), WTC2(0x024f6288), WTC2(0x029c5f94), WTC2(0x02ed9424), WTC2(0x0342ee6c), WTC2(0x039c5c90),
- WTC2(0x03f9ccbc), WTC2(0x045b2d18), WTC2(0x04c06bd8), WTC2(0x05297718), WTC2(0x05963d10), WTC2(0x0606abe8), WTC2(0x067ab1c0), WTC2(0x06f23cd0),
- WTC2(0x076d3b40), WTC2(0x07eb9b38), WTC2(0x086d4ae0), WTC2(0x08f23860), WTC2(0x097a51f0), WTC2(0x0a0585b0), WTC2(0x0a93c1d0), WTC2(0x0b24f470),
- WTC2(0x0bb90bc0), WTC2(0x0c4ff5f0), WTC2(0x0ce9a130), WTC2(0x0d85fb90), WTC2(0x0e24f360), WTC2(0x0ec676b0), WTC2(0x0f6a73b0), WTC2(0x1010d880),
- WTC2(0x10b99360), WTC2(0x11649280), WTC2(0x1211c400), WTC2(0x12c115e0), WTC2(0x137276a0), WTC2(0x1425d420), WTC2(0x14db1ca0), WTC2(0x15923e60),
- WTC2(0x164b2780), WTC2(0x1705c620), WTC2(0x17c20860), WTC2(0x187fdca0), WTC2(0x193f30e0), WTC2(0x19fff340), WTC2(0x1ac21200), WTC2(0x1b857b40),
- WTC2(0x1c4a1d40), WTC2(0x1d0fe600), WTC2(0x1dd6c3e0), WTC2(0x1e9ea4e0), WTC2(0x1f677740), WTC2(0x20312940), WTC2(0x20fba8c0), WTC2(0x21c6e440),
- WTC2(0x2292c9c0), WTC2(0x235f4780), WTC2(0x242c4b80), WTC2(0x24f9c400), WTC2(0x25c79f40), WTC2(0x2695cb40), WTC2(0x27643680), WTC2(0x2832cec0),
- WTC2(0x29018240), WTC2(0x29d03f80), WTC2(0x2a9ef480), WTC2(0x2b6d8f00), WTC2(0x2c3bfdc0), WTC2(0x2d0a2ec0), WTC2(0x2dd81000), WTC2(0x2ea58fc0),
- WTC2(0x2f729c40), WTC2(0x303f2380), WTC2(0x310b1400), WTC2(0x31d65b80), WTC2(0x32a0e840), WTC2(0x336aa8c0), WTC2(0x34338ac0), WTC2(0x34fb7cc0),
- WTC2(0x35c26cc0), WTC2(0x36884900), WTC2(0x374cff80), WTC2(0x38107e80), WTC2(0x38d2b440), WTC2(0x39938ec0), WTC2(0x3a52fc40), WTC2(0x3b10eb00),
- WTC2(0x3bcd4900), WTC2(0x3c880480), WTC2(0x3d410bc0), WTC2(0x3df84d00), WTC2(0x3eadb600), WTC2(0x3f613540), WTC2(0x4012b8ff), WTC2(0x40c22eff),
- WTC2(0x416f85ff), WTC2(0x421aab7f), WTC2(0x42c38e7f), WTC2(0x436a1c7f), WTC2(0x440e437f), WTC2(0x44aff27f), WTC2(0x454f167f), WTC2(0x45eb9eff),
- WTC2(0x468578ff), WTC2(0x471c937f), WTC2(0x47b0dc7f), WTC2(0x484241ff), WTC2(0x48d0b1ff), WTC2(0x495c1a7f), WTC2(0x49e46a7f), WTC2(0x4a698f7f),
- WTC2(0x4aeb77ff), WTC2(0x4b6a11ff), WTC2(0x4be54b7f), WTC2(0x4c5d12ff), WTC2(0x4cd155ff), WTC2(0x4d4203ff), WTC2(0x4daf09ff), WTC2(0x4e18567f),
- WTC2(0x4e7dd77f), WTC2(0x4edf7b7f), WTC2(0x4f3d307f), WTC2(0x4f96e47f), WTC2(0x4fec85ff), WTC2(0x503e02ff), WTC2(0x508b497f), WTC2(0x50d447ff),
- WTC2(0x5118ec7f), WTC2(0x515924ff), WTC2(0x5194dfff), WTC2(0x51cc0b7f), WTC2(0x51fe95ff), WTC2(0x522c6cff), WTC2(0x52557eff), WTC2(0x5279b9ff),
- WTC2(0x52990c7f), WTC2(0x52b364ff), WTC2(0x52c8b07f), WTC2(0x52d8ddff), WTC2(0x52e3db7f), WTC2(0x52e996ff), WTC2(0x52e9ff7f), WTC2(0x52e501ff),
- WTC2(0x52da8cff), WTC2(0x52ca8f7f), WTC2(0x52b4f67f), WTC2(0x5299b07f), WTC2(0x5278ac7f), WTC2(0x5251d77f), WTC2(0x52251fff), WTC2(0x51f274ff),
- WTC2(0x51b9c37f), WTC2(0x517af9ff), WTC2(0x5136077f), WTC2(0x50ead8ff), WTC2(0x50995cff), WTC2(0x504181ff), WTC2(0x4fe335ff), WTC2(0x4f7e677f),
- WTC2(0x4f1303ff), WTC2(0x4ea0f9ff), WTC2(0x4e2837ff), WTC2(0x4da8ab7f), WTC2(0x4d2242ff), WTC2(0x4c94ecff), WTC2(0x4c0096ff), WTC2(0x4b652f7f),
- WTC2(0x4ac2a4ff), WTC2(0x4a18e4ff), WTC2(0x4967ddff), WTC2(0x48af7e7f), WTC2(0x47efb3ff), WTC2(0x47286cff), WTC2(0x4659ad7f), WTC2(0x45856f7f),
- WTC2(0x44afa3ff), WTC2(0x43dc507f), WTC2(0x430f657f), WTC2(0x424ad47f), WTC2(0x418e927f), WTC2(0x40da7bff), WTC2(0x402e6f7f), WTC2(0x3f8a3100),
- WTC2(0x3eed6f40), WTC2(0x3e57d700), WTC2(0x3dc914c0), WTC2(0x3d40cc40), WTC2(0x3cbe98c0), WTC2(0x3c421540), WTC2(0x3bcadbc0), WTC2(0x3b588880),
- WTC2(0x3aeab780), WTC2(0x3a810540), WTC2(0x3a1b0e00), WTC2(0x39b86d00), WTC2(0x3958bcc0), WTC2(0x38fb9700), WTC2(0x38a095c0), WTC2(0x38473d80),
- WTC2(0x37eeff40), WTC2(0x37974b40), WTC2(0x373f9500), WTC2(0x36e7ae00), WTC2(0x368fc4c0), WTC2(0x36380b80), WTC2(0x35e0b300), WTC2(0x3589c140),
- WTC2(0x35331180), WTC2(0x34dc7c80), WTC2(0x3485dc80), WTC2(0x342f1600), WTC2(0x33d81780), WTC2(0x3380d0c0), WTC2(0x33293100), WTC2(0x32d11800),
- WTC2(0x32785780), WTC2(0x321ec0c0), WTC2(0x31c42680), WTC2(0x316885c0), WTC2(0x310c0580), WTC2(0x30aecec0), WTC2(0x30510940), WTC2(0x2ff2b8c0),
- WTC2(0x2f93bf40), WTC2(0x2f33fc00), WTC2(0x2ed350c0), WTC2(0x2e71ba80), WTC2(0x2e0f5340), WTC2(0x2dac35c0), WTC2(0x2d487c80), WTC2(0x2ce431c0),
- WTC2(0x2c7f4fc0), WTC2(0x2c19d080), WTC2(0x2bb3ad80), WTC2(0x2b4ce080), WTC2(0x2ae56340), WTC2(0x2a7d2f80), WTC2(0x2a143f00), WTC2(0x29aa8b40)
-};
-
-const FIXP_WTB ELDAnalysis480[1440] = {
- WTC0(0xfacfbef0), WTC0(0xfab88c18), WTC0(0xfaa0e520), WTC0(0xfa88d110), WTC0(0xfa7056e8), WTC0(0xfa577db0), WTC0(0xfa3e4c70), WTC0(0xfa24ca28),
- WTC0(0xfa0afde0), WTC0(0xf9f0eea0), WTC0(0xf9d6a2c8), WTC0(0xf9bc1ab8), WTC0(0xf9a15230), WTC0(0xf9864510), WTC0(0xf96af058), WTC0(0xf94f55c0),
- WTC0(0xf93378e0), WTC0(0xf9175d80), WTC0(0xf8fb0468), WTC0(0xf8de68b8), WTC0(0xf8c18438), WTC0(0xf8a450d8), WTC0(0xf886cde8), WTC0(0xf8690148),
- WTC0(0xf84af148), WTC0(0xf82ca410), WTC0(0xf80e1e18), WTC0(0xf7ef62a0), WTC0(0xf7d074e0), WTC0(0xf7b15870), WTC0(0xf7921240), WTC0(0xf772a7a0),
- WTC0(0xf7531e50), WTC0(0xf7337820), WTC0(0xf713afd0), WTC0(0xf6f3bea0), WTC0(0xf6d39dc0), WTC0(0xf6b352e0), WTC0(0xf692f280), WTC0(0xf6729250),
- WTC0(0xf65247a0), WTC0(0xf63224c0), WTC0(0xf6123a00), WTC0(0xf5f297c0), WTC0(0xf5d34dd0), WTC0(0xf5b46b10), WTC0(0xf595fd90), WTC0(0xf5781390),
- WTC0(0xf55abba0), WTC0(0xf53e0510), WTC0(0xf521ff70), WTC0(0xf506ba30), WTC0(0xf4ec4330), WTC0(0xf4d2a680), WTC0(0xf4b9efe0), WTC0(0xf4a22ac0),
- WTC0(0xf48b5f70), WTC0(0xf4759310), WTC0(0xf460cde0), WTC0(0xf44cfcc0), WTC0(0xf439aff0), WTC0(0xf4264e00), WTC0(0xf4123d90), WTC0(0xf3fd1370),
- WTC0(0xf3e6be00), WTC0(0xf3cf41a0), WTC0(0xf3b6a030), WTC0(0xf39cdd60), WTC0(0xf381fe00), WTC0(0xf3660760), WTC0(0xf348fe70), WTC0(0xf32ae820),
- WTC0(0xf30bc940), WTC0(0xf2eba690), WTC0(0xf2ca8480), WTC0(0xf2a86670), WTC0(0xf2854f40), WTC0(0xf2614190), WTC0(0xf23c41e0), WTC0(0xf21657a0),
- WTC0(0xf1ef8ae0), WTC0(0xf1c7e3e0), WTC0(0xf19f63d0), WTC0(0xf1760450), WTC0(0xf14bbdf0), WTC0(0xf1208960), WTC0(0xf0f45cd0), WTC0(0xf0c72ce0),
- WTC0(0xf098ee00), WTC0(0xf06996f0), WTC0(0xf0392620), WTC0(0xf0079e10), WTC0(0xefd4ffc0), WTC0(0xefa15ca0), WTC0(0xef6ce600), WTC0(0xef37d460),
- WTC0(0xef025f80), WTC0(0xeecca2c0), WTC0(0xee969760), WTC0(0xee603440), WTC0(0xee296d20), WTC0(0xedf21c00), WTC0(0xedba07e0), WTC0(0xed80f640),
- WTC0(0xed46bf40), WTC0(0xed0b7b00), WTC0(0xeccf5fc0), WTC0(0xec92a120), WTC0(0xec556d60), WTC0(0xec17e700), WTC0(0xebda2d40), WTC0(0xeb9c5fa0),
- WTC0(0xeb5e7040), WTC0(0xeb201b20), WTC0(0xeae117c0), WTC0(0xeaa12000), WTC0(0xea600180), WTC0(0xea1d9940), WTC0(0xe9d9c160), WTC0(0xe99468a0),
- WTC0(0xe94dc040), WTC0(0xe9061940), WTC0(0xe8bdc140), WTC0(0xe8750ae0), WTC0(0xe82c4fa0), WTC0(0xe7e3ea40), WTC0(0xe79c35e0), WTC0(0xe7554ca0),
- WTC0(0xe70efc00), WTC0(0xe6c90c20), WTC0(0xe6833f00), WTC0(0xe63d2300), WTC0(0xe5f620a0), WTC0(0xe5ad9dc0), WTC0(0xe5632080), WTC0(0xe5169da0),
- WTC0(0xe4c83e60), WTC0(0xe4782400), WTC0(0xe4269840), WTC0(0xe3d42dc0), WTC0(0xe38188c0), WTC0(0xe32f4be0), WTC0(0xe2ddeea0), WTC0(0xe28db520),
- WTC0(0xe23ee000), WTC0(0xe1f1a580), WTC0(0xe1a5e3a0), WTC0(0xe15b35a0), WTC0(0xe1113860), WTC0(0xe0c78a00), WTC0(0xe07dd0e0), WTC0(0xe033b7c0),
- WTC0(0xdfe8e680), WTC0(0xdf9d1fc0), WTC0(0xdf5055c0), WTC0(0xdf0287c0), WTC0(0xdeb3b340), WTC0(0xde63e7c0), WTC0(0xde134a00), WTC0(0xddc20000),
- WTC0(0xdd703180), WTC0(0xdd1e1280), WTC0(0xdccbe080), WTC0(0xdc79d980), WTC0(0xdc283600), WTC0(0xdbd71e00), WTC0(0xdb86b140), WTC0(0xdb3710c0),
- WTC0(0xdae850c0), WTC0(0xda9a6bc0), WTC0(0xda4d5640), WTC0(0xda010640), WTC0(0xd9b56640), WTC0(0xd96a5700), WTC0(0xd91fb700), WTC0(0xd8d56600),
- WTC0(0xd88b4a40), WTC0(0xd8414f00), WTC0(0xd7f75f80), WTC0(0xd7ad6740), WTC0(0xd76352c0), WTC0(0xd7191040), WTC0(0xd6ce8c80), WTC0(0xd683bd00),
- WTC0(0xd638a5c0), WTC0(0xd5ed4f80), WTC0(0xd5a1c240), WTC0(0xd5562b80), WTC0(0xd50ae500), WTC0(0xd4c04c80), WTC0(0xd476bb40), WTC0(0xd42e62c0),
- WTC0(0xd3e75680), WTC0(0xd3a1ad00), WTC0(0xd35d6780), WTC0(0xd31a4300), WTC0(0xd2d7dc00), WTC0(0xd295d080), WTC0(0xd253d8c0), WTC0(0xd211df40),
- WTC0(0xd1cfdbc0), WTC0(0xd18dc480), WTC0(0xd14b9dc0), WTC0(0xd1097c80), WTC0(0xd0c77700), WTC0(0xd085a500), WTC0(0xd0442f40), WTC0(0xd0034a80),
- WTC0(0xcfc32c00), WTC0(0xcf840400), WTC0(0xcf45f400), WTC0(0xcf0913c0), WTC0(0xcecd8000), WTC0(0xce932c80), WTC0(0xce59bf40), WTC0(0xce20cd40),
- WTC0(0xcde7ec40), WTC0(0xcdaeedc0), WTC0(0xcd75ea00), WTC0(0xcd3cfec0), WTC0(0xcd044b40), WTC0(0xcccbff00), WTC0(0xcc945480), WTC0(0xcc5d8780),
- WTC0(0xcc27c3c0), WTC0(0xcbf2fc40), WTC0(0xcbbf0a00), WTC0(0xcb8bc7c0), WTC0(0xcb591880), WTC0(0xcb26f0c0), WTC0(0xcaf54980), WTC0(0xcac41ac0),
- WTC0(0xca936440), WTC0(0xca632d80), WTC0(0xca337f00), WTC0(0xca046180), WTC0(0xc9d5dd40), WTC0(0xc9a7fa80), WTC0(0xc97ac200), WTC0(0xc94e3c00),
- WTC0(0xc91d1840), WTC0(0xc8f15980), WTC0(0xc8c52340), WTC0(0xc8988100), WTC0(0xc86b7f00), WTC0(0xc83e28c0), WTC0(0xc8108a80), WTC0(0xc7e2afc0),
- WTC0(0xc7b4a480), WTC0(0xc7867480), WTC0(0xc7582b40), WTC0(0xc729cc80), WTC0(0xc6fb5700), WTC0(0xc6ccca40), WTC0(0xc69e2180), WTC0(0xc66f49c0),
- WTC0(0xc64029c0), WTC0(0xc610a740), WTC0(0xc5e0bfc0), WTC0(0xc5b09e80), WTC0(0xc5807900), WTC0(0xc5508440), WTC0(0xc520e840), WTC0(0xc4f1bdc0),
- WTC0(0xc4c31d00), WTC0(0xc4951780), WTC0(0xc4678a00), WTC0(0xc43a28c0), WTC0(0xc40ca800), WTC0(0xc3deccc0), WTC0(0xc3b09940), WTC0(0xc3822c00),
- WTC0(0xc353a0c0), WTC0(0xc3251740), WTC0(0xc2f6b500), WTC0(0xc2c8a140), WTC0(0xc29b02c0), WTC0(0xc26df5c0), WTC0(0xc2418940), WTC0(0xc215cbc0),
- WTC0(0xc1eaca00), WTC0(0xc1c08680), WTC0(0xc196fb00), WTC0(0xc16e22c0), WTC0(0xc145f040), WTC0(0xc11e3a80), WTC0(0xc0f6cc00), WTC0(0xc0cf6ec0),
- WTC0(0xc0a802c0), WTC0(0xc0809280), WTC0(0xc0593340), WTC0(0xc031f880), WTC0(0xc00b04c0), WTC0(0xbfe48981), WTC0(0xbfbebb81), WTC0(0xbf99cb01),
- WTC0(0xbf75cc81), WTC0(0xbf52c101), WTC0(0xbf30a901), WTC0(0xbf0f8301), WTC0(0xbeef4601), WTC0(0xbecfe601), WTC0(0xbeb15701), WTC0(0xbe938c81),
- WTC0(0xbe767e81), WTC0(0xbe5a2301), WTC0(0xbe3e7201), WTC0(0xbe236001), WTC0(0xbe08e181), WTC0(0xbdeee981), WTC0(0xbdd56b81), WTC0(0xbdbc6381),
- WTC0(0xbda3d081), WTC0(0xbd8bb281), WTC0(0xbd740b81), WTC0(0xbd5ce281), WTC0(0xbd464281), WTC0(0xbd303581), WTC0(0xbd1ac801), WTC0(0xbd060c81),
- WTC0(0xbcf21601), WTC0(0xbcdef701), WTC0(0xbcccbd01), WTC0(0xbcbb7001), WTC0(0xbcab1781), WTC0(0xbc9bb901), WTC0(0xbc8d5101), WTC0(0xbc7fd301),
- WTC0(0xbc733401), WTC0(0xbc676501), WTC0(0xbc5c4c81), WTC0(0xbc51cb01), WTC0(0xbc47c281), WTC0(0xbc3e1981), WTC0(0xbc34c081), WTC0(0xbc2bab01),
- WTC0(0xbc22cd81), WTC0(0xbc1a2401), WTC0(0xbc11b681), WTC0(0xbc098d81), WTC0(0xbc01b381), WTC0(0xbbfa3c01), WTC0(0xbbf34281), WTC0(0xbbece281),
- WTC0(0xbbe73201), WTC0(0xbbe23281), WTC0(0xbbdddb01), WTC0(0xbbda2501), WTC0(0xbbd70201), WTC0(0xbbd45601), WTC0(0xbbd20301), WTC0(0xbbcfea81),
- WTC0(0xbbce0601), WTC0(0xbbcc6b01), WTC0(0xbbcb3201), WTC0(0xbbca7481), WTC0(0xbbca5d01), WTC0(0xbbcb2281), WTC0(0xbbccfc81), WTC0(0xbbd01301),
- WTC0(0xbbd45881), WTC0(0xbbd9a781), WTC0(0xbbdfdb81), WTC0(0xbbe6c801), WTC0(0xbbee2f81), WTC0(0xbbf5d181), WTC0(0xbbfd6c01), WTC0(0xbc04e381),
- WTC0(0xbc0c4581), WTC0(0xbc13a481), WTC0(0xbc1b1081), WTC0(0xbc228f01), WTC0(0xbc2a1a81), WTC0(0xbc31af01), WTC0(0xbc394901), WTC0(0xbc40e881),
- WTC0(0xbc488e81), WTC0(0xbc503b81), WTC0(0xbc57f101), WTC0(0xbc5fae81), WTC0(0xbc677501), WTC0(0xbc6f4401), WTC0(0xbc771c01), WTC0(0xbc7efc81),
- WTC0(0xbc86e581), WTC0(0xbc8ed701), WTC0(0xbc96d101), WTC0(0xbc9ed481), WTC0(0xbca6e101), WTC0(0xbcaef701), WTC0(0xbcb71701), WTC0(0xbcbf4001),
- WTC0(0xbcc77181), WTC0(0xbccfac01), WTC0(0xbcd7ef01), WTC0(0xbce03b81), WTC0(0xbce89281), WTC0(0xbcf0f381), WTC0(0xbcf95e81), WTC0(0xbd01d281),
- WTC0(0xbd0a4f81), WTC0(0xbd12d581), WTC0(0xbd1b6501), WTC0(0xbd23ff01), WTC0(0xbd2ca281), WTC0(0xbd355081), WTC0(0xbd3e0801), WTC0(0xbd46c801),
- WTC0(0xbd4f9101), WTC0(0xbd586281), WTC0(0xbd613d81), WTC0(0xbd6a2201), WTC0(0xbd731081), WTC0(0xbd7c0781), WTC0(0xbd850701), WTC0(0xbd8e0e01),
- WTC0(0xbd971c81), WTC0(0xbda03381), WTC0(0xbda95301), WTC0(0xbdb27b01), WTC0(0xbdbbab01), WTC0(0xbdc4e301), WTC0(0xbdce2181), WTC0(0xbdd76701),
- WTC0(0xbde0b301), WTC0(0xbdea0681), WTC0(0xbdf36101), WTC0(0xbdfcc301), WTC0(0xbe062b81), WTC0(0xbe0f9a01), WTC0(0xbe190d81), WTC0(0xbe228681),
- WTC0(0xbe2c0501), WTC0(0xbe358901), WTC0(0xbe3f1381), WTC0(0xbe48a301), WTC0(0xbe523781), WTC0(0xbe5bd001), WTC0(0xbe656c01), WTC0(0xbe6f0c01),
- WTC0(0xbe78b001), WTC0(0xbe825801), WTC0(0xbe8c0501), WTC0(0xbe95b581), WTC0(0xbe9f6901), WTC0(0xbea91f01), WTC0(0xbeb2d681), WTC0(0xbebc9181),
- WTC0(0xbec64e81), WTC0(0xbed00f81), WTC0(0xbed9d281), WTC0(0xbee39801), WTC0(0xbeed5f01), WTC0(0xbef72681), WTC0(0xbf00ef81), WTC0(0xbf0aba01),
- WTC0(0xbf148681), WTC0(0xbf1e5501), WTC0(0xbf282501), WTC0(0xbf31f501), WTC0(0xbf3bc601), WTC0(0xbf459681), WTC0(0xbf4f6801), WTC0(0xbf593a01),
- WTC0(0xbf630d81), WTC0(0xbf6ce201), WTC0(0xbf76b701), WTC0(0xbf808b81), WTC0(0xbf8a5f81), WTC0(0xbf943301), WTC0(0xbf9e0701), WTC0(0xbfa7dc01),
- WTC0(0xbfb1b101), WTC0(0xbfbb8701), WTC0(0xbfc55c81), WTC0(0xbfcf3181), WTC0(0xbfd90601), WTC0(0xbfe2d901), WTC0(0xbfecaa81), WTC0(0xbff67a01),
- /* part 1 */
- WTC1(0x80130981), WTC1(0x80269f81), WTC1(0x803a3381), WTC1(0x804dc481), WTC1(0x80615281), WTC1(0x8074dc01), WTC1(0x80886081), WTC1(0x809bdf01),
- WTC1(0x80af5701), WTC1(0x80c2c781), WTC1(0x80d63101), WTC1(0x80e99401), WTC1(0x80fcf181), WTC1(0x81104a01), WTC1(0x81239d81), WTC1(0x8136ea01),
- WTC1(0x814a2f81), WTC1(0x815d6c01), WTC1(0x8170a181), WTC1(0x8183cf81), WTC1(0x8196f781), WTC1(0x81aa1981), WTC1(0x81bd3401), WTC1(0x81d04681),
- WTC1(0x81e34f81), WTC1(0x81f64f01), WTC1(0x82094581), WTC1(0x821c3401), WTC1(0x822f1b01), WTC1(0x8241fa01), WTC1(0x8254cf01), WTC1(0x82679901),
- WTC1(0x827a5801), WTC1(0x828d0b01), WTC1(0x829fb401), WTC1(0x82b25301), WTC1(0x82c4e801), WTC1(0x82d77201), WTC1(0x82e9ef01), WTC1(0x82fc5f01),
- WTC1(0x830ec081), WTC1(0x83211501), WTC1(0x83335c81), WTC1(0x83459881), WTC1(0x8357c701), WTC1(0x8369e781), WTC1(0x837bf801), WTC1(0x838df801),
- WTC1(0x839fe801), WTC1(0x83b1c881), WTC1(0x83c39a81), WTC1(0x83d55d01), WTC1(0x83e70f01), WTC1(0x83f8b001), WTC1(0x840a3e81), WTC1(0x841bb981),
- WTC1(0x842d2281), WTC1(0x843e7a81), WTC1(0x844fc081), WTC1(0x8460f581), WTC1(0x84721701), WTC1(0x84832481), WTC1(0x84941d81), WTC1(0x84a50201),
- WTC1(0x84b5d301), WTC1(0x84c69101), WTC1(0x84d73c01), WTC1(0x84e7d381), WTC1(0x84f85581), WTC1(0x8508c181), WTC1(0x85191801), WTC1(0x85295881),
- WTC1(0x85398481), WTC1(0x85499d01), WTC1(0x8559a081), WTC1(0x85698e81), WTC1(0x85796601), WTC1(0x85892681), WTC1(0x8598d081), WTC1(0x85a86581),
- WTC1(0x85b7e601), WTC1(0x85c75201), WTC1(0x85d6a981), WTC1(0x85e5eb81), WTC1(0x85f51681), WTC1(0x86042c01), WTC1(0x86132c01), WTC1(0x86221801),
- WTC1(0x8630f181), WTC1(0x863fb701), WTC1(0x864e6901), WTC1(0x865d0581), WTC1(0x866b8d81), WTC1(0x867a0081), WTC1(0x86886001), WTC1(0x8696ad01),
- WTC1(0x86a4e781), WTC1(0x86b30f01), WTC1(0x86c12401), WTC1(0x86cf2601), WTC1(0x86dd1481), WTC1(0x86eaf081), WTC1(0x86f8ba81), WTC1(0x87067281),
- WTC1(0x87141b01), WTC1(0x8721b481), WTC1(0x872f4201), WTC1(0x873cc201), WTC1(0x874a2f01), WTC1(0x87578181), WTC1(0x8764b101), WTC1(0x8771c601),
- WTC1(0x877ede01), WTC1(0x878c1881), WTC1(0x87998f01), WTC1(0x87a70e81), WTC1(0x87b42481), WTC1(0x87c05e81), WTC1(0x87cb5101), WTC1(0x87d4ac81),
- WTC1(0x87e73d81), WTC1(0x88124281), WTC1(0x88353501), WTC1(0x885f8481), WTC1(0x888d3181), WTC1(0x88be1681), WTC1(0x88f13801), WTC1(0x8925f101),
- WTC1(0x895bcd01), WTC1(0x89925a81), WTC1(0x89c92f81), WTC1(0x8a001f01), WTC1(0x8a372881), WTC1(0x8a6e4a01), WTC1(0x8aa58681), WTC1(0x8adcee01),
- WTC1(0x8b149701), WTC1(0x8b4c9701), WTC1(0x8b850281), WTC1(0x8bbde981), WTC1(0x8bf75b01), WTC1(0x8c316681), WTC1(0x8c6c1b01), WTC1(0x8ca78781),
- WTC1(0x8ce3ba81), WTC1(0x8d20c301), WTC1(0x8d5eaa01), WTC1(0x8d9d7781), WTC1(0x8ddd3201), WTC1(0x8e1de001), WTC1(0x8e5f8881), WTC1(0x8ea23201),
- WTC1(0x8ee5e301), WTC1(0x8f2aa101), WTC1(0x8f706f01), WTC1(0x8fb74f81), WTC1(0x8fff4601), WTC1(0x90485401), WTC1(0x90927b81), WTC1(0x90ddc001),
- WTC1(0x912a2201), WTC1(0x9177a301), WTC1(0x91c64301), WTC1(0x92160301), WTC1(0x9266e281), WTC1(0x92b8e101), WTC1(0x930bff81), WTC1(0x93603d01),
- WTC1(0x93b59901), WTC1(0x940c1281), WTC1(0x9463a881), WTC1(0x94bc5981), WTC1(0x95162381), WTC1(0x95710601), WTC1(0x95ccff01), WTC1(0x962a0c81),
- WTC1(0x96882e01), WTC1(0x96e76101), WTC1(0x9747a481), WTC1(0x97a8f681), WTC1(0x980b5501), WTC1(0x986ebd81), WTC1(0x98d32d81), WTC1(0x9938a281),
- WTC1(0x999f1981), WTC1(0x9a069001), WTC1(0x9a6f0381), WTC1(0x9ad87081), WTC1(0x9b42d581), WTC1(0x9bae2f81), WTC1(0x9c1a7c81), WTC1(0x9c87ba81),
- WTC1(0x9cf5e701), WTC1(0x9d650081), WTC1(0x9dd50481), WTC1(0x9e45f081), WTC1(0x9eb7c101), WTC1(0x9f2a7281), WTC1(0x9f9e0301), WTC1(0xa0127081),
- WTC1(0xa087b981), WTC1(0xa0fddd81), WTC1(0xa174da81), WTC1(0xa1ecae01), WTC1(0xa2655581), WTC1(0xa2dece81), WTC1(0xa3591801), WTC1(0xa3d43001),
- WTC1(0xa4501601), WTC1(0xa4ccc901), WTC1(0xa54a4701), WTC1(0xa5c89001), WTC1(0xa647a301), WTC1(0xa6c77e01), WTC1(0xa7482101), WTC1(0xa7c98b01),
- WTC1(0xa84bbb81), WTC1(0xa8ceb201), WTC1(0xa9526d81), WTC1(0xa9d6ef01), WTC1(0xaa5c3601), WTC1(0xaae24301), WTC1(0xab691681), WTC1(0xabf0b181),
- WTC1(0xac791401), WTC1(0xad023f01), WTC1(0xad8c3301), WTC1(0xae16f001), WTC1(0xaea27681), WTC1(0xaf2ec901), WTC1(0xafbbe801), WTC1(0xb049d601),
- WTC1(0xb0d89401), WTC1(0xb1682281), WTC1(0xb1f88181), WTC1(0xb289b181), WTC1(0xb31bb301), WTC1(0xb3ae8601), WTC1(0xb4422b81), WTC1(0xb4d6a381),
- WTC1(0x4a5a327f), WTC1(0x49c4adff), WTC1(0x492e637f), WTC1(0x48974f7f), WTC1(0x47ff6d7f), WTC1(0x4766baff), WTC1(0x46cd35ff), WTC1(0x4632dd7f),
- WTC1(0x4597b0ff), WTC1(0x44fbb1ff), WTC1(0x445eeaff), WTC1(0x43c165ff), WTC1(0x4323227f), WTC1(0x4284277f), WTC1(0x41e48aff), WTC1(0x4144557f),
- WTC1(0x40a3867f), WTC1(0x4001f5ff), WTC1(0x3f5f5d80), WTC1(0x3ebbad00), WTC1(0x3e16ee40), WTC1(0x3d713d00), WTC1(0x3ccab700), WTC1(0x3c236500),
- WTC1(0x3b7b5800), WTC1(0x3ad2ecc0), WTC1(0x3a2a6540), WTC1(0x3981b7c0), WTC1(0x38d8ba00), WTC1(0x382f01c0), WTC1(0x37846240), WTC1(0x36d8eb00),
- WTC1(0x362c9ec0), WTC1(0x357f7a00), WTC1(0x34d18340), WTC1(0x3422c900), WTC1(0x33736c40), WTC1(0x32c39040), WTC1(0x32134280), WTC1(0x31629280),
- WTC1(0x30b1a000), WTC1(0x30008380), WTC1(0x2f4f4240), WTC1(0x2e9df180), WTC1(0x2decc780), WTC1(0x2d3bd640), WTC1(0x2c8b0cc0), WTC1(0x2bda3080),
- WTC1(0x2b28ec80), WTC1(0x2a773500), WTC1(0x29c51b40), WTC1(0x291293c0), WTC1(0x285f9280), WTC1(0x27ac35c0), WTC1(0x26f8ab40), WTC1(0x26454c00),
- WTC1(0x25925600), WTC1(0x24dfd580), WTC1(0x242ddd40), WTC1(0x237c87c0), WTC1(0x22cbe240), WTC1(0x221bef40), WTC1(0x216cb040), WTC1(0x20be2800),
- WTC1(0x20105c80), WTC1(0x1f6352a0), WTC1(0x1eb71240), WTC1(0x1e0ba140), WTC1(0x1d60fe40), WTC1(0x1cb723e0), WTC1(0x1c0e0300), WTC1(0x1b6596c0),
- WTC1(0x1abde8a0), WTC1(0x1a16fbe0), WTC1(0x1970c680), WTC1(0x18cb4840), WTC1(0x18268e20), WTC1(0x1782a0c0), WTC1(0x16df8960), WTC1(0x163d6300),
- WTC1(0x159c52c0), WTC1(0x14fc87e0), WTC1(0x145e2c80), WTC1(0x13c15b60), WTC1(0x13263240), WTC1(0x128cd9a0), WTC1(0x11f562a0), WTC1(0x115fc1c0),
- WTC1(0x10cbf160), WTC1(0x1039f200), WTC1(0x0fa9a080), WTC1(0x0f1abd90), WTC1(0x0e8d01d0), WTC1(0x0e003330), WTC1(0x0d743590), WTC1(0x0ce8ef40),
- WTC1(0x0c5e1900), WTC1(0x0bd35d70), WTC1(0x0b488eb0), WTC1(0x0abd8410), WTC1(0x0a320a00), WTC1(0x09a60e70), WTC1(0x0919ab00), WTC1(0x088d0de0),
- WTC1(0x080065e0), WTC1(0x07739710), WTC1(0x06e65808), WTC1(0x06588348), WTC1(0x05ca0ae0), WTC1(0x053aaaf8), WTC1(0x04a9faf0), WTC1(0x0417f698),
- WTC1(0x03859ff4), WTC1(0x02f49be4), WTC1(0x0266b668), WTC1(0x01de554e), WTC1(0x015f50ca), WTC1(0x00eb7e5d), WTC1(0x00904f24), WTC1(0x00212889),
- WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000),
- WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000),
- WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000),
- WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000),
- WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000),
- WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000),
- WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000),
- WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000),
- WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000),
- WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000),
- WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000),
- WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000),
- WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000),
- WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000),
- WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000), WTC1(0x00000000),
- /* part 2 */
- WTC2(0xfffece02), WTC2(0xffe4c3df), WTC2(0xffcaaa55), WTC2(0xffb087d1), WTC2(0xff9662bf), WTC2(0xff7c418b), WTC2(0xff622aa0), WTC2(0xff48246c),
- WTC2(0xff2e355a), WTC2(0xff1463db), WTC2(0xfefab608), WTC2(0xfee12f0a), WTC2(0xfec7cfd2), WTC2(0xfeae995a), WTC2(0xfe958cc4), WTC2(0xfe7cabce),
- WTC2(0xfe63f882), WTC2(0xfe4b74e0), WTC2(0xfe3322f6), WTC2(0xfe1b04dc), WTC2(0xfe031ccc), WTC2(0xfdeb6cf0), WTC2(0xfdd3ff7c), WTC2(0xfdbce834),
- WTC2(0xfda63bb8), WTC2(0xfd900c68), WTC2(0xfd7a590c), WTC2(0xfd6511b4), WTC2(0xfd5026c0), WTC2(0xfd3b8954), WTC2(0xfd272df0), WTC2(0xfd130adc),
- WTC2(0xfcff15ac), WTC2(0xfceb4a68), WTC2(0xfcd7b110), WTC2(0xfcc454d0), WTC2(0xfcb14064), WTC2(0xfc9e896c), WTC2(0xfc8c5264), WTC2(0xfc7abef0),
- WTC2(0xfc69f078), WTC2(0xfc59f5e8), WTC2(0xfc4acfec), WTC2(0xfc3c8060), WTC2(0xfc2f0264), WTC2(0xfc223b7c), WTC2(0xfc160714), WTC2(0xfc0a4150),
- WTC2(0xfbfec920), WTC2(0xfbf38320), WTC2(0xfbe855d0), WTC2(0xfbdd2740), WTC2(0xfbd1fc68), WTC2(0xfbc6fea0), WTC2(0xfbbc5a48), WTC2(0xfbb23b48),
- WTC2(0xfba8ca78), WTC2(0xfba02e50), WTC2(0xfb988de0), WTC2(0xfb920b40), WTC2(0xfb8cb870), WTC2(0xfb889f68), WTC2(0xfb85cbe8), WTC2(0xfb843dd0),
- WTC2(0xfb83df78), WTC2(0xfb8495d0), WTC2(0xfb864660), WTC2(0xfb88d4a8), WTC2(0xfb8c21e8), WTC2(0xfb900f28), WTC2(0xfb947dc0), WTC2(0xfb9950c0),
- WTC2(0xfb9e6d08), WTC2(0xfba3b658), WTC2(0xfba91908), WTC2(0xfbae9e08), WTC2(0xfbb45bd0), WTC2(0xfbba66f8), WTC2(0xfbc0dcf0), WTC2(0xfbc7ead8),
- WTC2(0xfbcfc200), WTC2(0xfbd89330), WTC2(0xfbe294d0), WTC2(0xfbee03d0), WTC2(0xfbfb1de8), WTC2(0xfc0a1da4), WTC2(0xfc1b22e0), WTC2(0xfc2e38f0),
- WTC2(0xfc436d48), WTC2(0xfc5abf7c), WTC2(0xfc74024c), WTC2(0xfc8ef2e8), WTC2(0xfcab51ac), WTC2(0xfcc8d024), WTC2(0xfce704f0), WTC2(0xfd0580cc),
- WTC2(0xfd23d4d0), WTC2(0xfd41ce40), WTC2(0xfd5f81b0), WTC2(0xfd7d08f0), WTC2(0xfd9a8560), WTC2(0xfdb85938), WTC2(0xfdd71798), WTC2(0xfdf753b8),
- WTC2(0xfe1993ee), WTC2(0xfe3e30f8), WTC2(0xfe656cba), WTC2(0xfe8f8fdc), WTC2(0xfebca8a4), WTC2(0xfeec590e), WTC2(0xff1e285c), WTC2(0xff51a0b7),
- WTC2(0xff866330), WTC2(0xffbc2cbb), WTC2(0xfff2bbff), WTC2(0x0029d79d), WTC2(0x00618a22), WTC2(0x009a1185), WTC2(0x00d3aa8c), WTC2(0x010e8ff6),
- WTC2(0x014af29e), WTC2(0x0188fe56), WTC2(0x01c8e108), WTC2(0x020ab3c4), WTC2(0x024e68a8), WTC2(0x0293e824), WTC2(0x02db1bc8), WTC2(0x0323f1a4),
- WTC2(0x036e5d6c), WTC2(0x03ba5320), WTC2(0x0407c938), WTC2(0x0456cad0), WTC2(0x04a77288), WTC2(0x04f9db88), WTC2(0x054e1888), WTC2(0x05a41ef0),
- WTC2(0x05fbd6e0), WTC2(0x065528c0), WTC2(0x06b00838), WTC2(0x070c7ee0), WTC2(0x076a9bb0), WTC2(0x07ca6d10), WTC2(0x082c08e0), WTC2(0x088f8da0),
- WTC2(0x08f51ac0), WTC2(0x095ccc20), WTC2(0x09c69f70), WTC2(0x0a327b40), WTC2(0x0aa046d0), WTC2(0x0b0febb0), WTC2(0x0b815dd0), WTC2(0x0bf49600),
- WTC2(0x0c698c50), WTC2(0x0ce03ba0), WTC2(0x0d58a380), WTC2(0x0dd2c510), WTC2(0x0e4ea110), WTC2(0x0ecc3dd0), WTC2(0x0f4ba800), WTC2(0x0fcced10),
- WTC2(0x10501960), WTC2(0x10d532a0), WTC2(0x115c39c0), WTC2(0x11e52fa0), WTC2(0x12701560), WTC2(0x12fcef20), WTC2(0x138bc200), WTC2(0x141c9300),
- WTC2(0x14af64a0), WTC2(0x154434e0), WTC2(0x15db0020), WTC2(0x1673c360), WTC2(0x170e7e80), WTC2(0x17ab35e0), WTC2(0x1849ee40), WTC2(0x18eaaba0),
- WTC2(0x198d6f00), WTC2(0x1a3236a0), WTC2(0x1ad90080), WTC2(0x1b81cc60), WTC2(0x1c2c9da0), WTC2(0x1cd97980), WTC2(0x1d8865c0), WTC2(0x1e396540),
- WTC2(0x1eec7700), WTC2(0x1fa198c0), WTC2(0x2058c840), WTC2(0x21120640), WTC2(0x21cd5700), WTC2(0x228abec0), WTC2(0x234a4180), WTC2(0x240bdf80),
- WTC2(0x24cf95c0), WTC2(0x259561c0), WTC2(0x265d4200), WTC2(0x27273840), WTC2(0x27f348c0), WTC2(0x28c17700), WTC2(0x2991c500), WTC2(0x2a643080),
- WTC2(0x2b38b680), WTC2(0x2c0f53c0), WTC2(0x2ce80840), WTC2(0x2dc2d680), WTC2(0x2e9fc100), WTC2(0x2f7ecac0), WTC2(0x305ff280), WTC2(0x314334c0),
- WTC2(0x32288e00), WTC2(0x330ffb80), WTC2(0x33f97d80), WTC2(0x34e515c0), WTC2(0x35d2c5c0), WTC2(0x36c28d00), WTC2(0x37b467c0), WTC2(0x38a85080),
- WTC2(0x399e4240), WTC2(0x3a963a00), WTC2(0x3b903600), WTC2(0x3c8c3480), WTC2(0x3d8a3380), WTC2(0x3e8a2dc0), WTC2(0x3f8c1b40), WTC2(0x408ff2ff),
- WTC2(0x4195ae7f), WTC2(0x429d477f), WTC2(0x43a6b87f), WTC2(0x44b1fdff), WTC2(0x45bf11ff), WTC2(0x46cdee7f), WTC2(0x47de8cff), WTC2(0x48f0e77f),
- WTC2(0x4a050eff), WTC2(0x4b1b2dff), WTC2(0x4c3372ff), WTC2(0x4d4e0bff), WTC2(0x4e6b257f), WTC2(0x4f8aedff), WTC2(0x50ad92ff), WTC2(0x51d341ff),
- WTC2(0x002006a9), WTC2(0x000bfb36), WTC2(0xfffe45ac), WTC2(0xfff6d064), WTC2(0xfff585bc), WTC2(0xfffa500d), WTC2(0x000519b4), WTC2(0x0015cd0c),
- WTC2(0x002c5470), WTC2(0x00489a3b), WTC2(0x006a88c8), WTC2(0x00920a74), WTC2(0x00bf0999), WTC2(0x00f17092), WTC2(0x012929bc), WTC2(0x01661f70),
- WTC2(0x01a83c0c), WTC2(0x01ef69e8), WTC2(0x023b9364), WTC2(0x028ca2d4), WTC2(0x02e2829c), WTC2(0x033d1d10), WTC2(0x039c5c90), WTC2(0x04002b78),
- WTC2(0x04687418), WTC2(0x04d520e0), WTC2(0x05461c18), WTC2(0x05bb5020), WTC2(0x0634a758), WTC2(0x06b20c20), WTC2(0x073368c8), WTC2(0x07b8a7b0),
- WTC2(0x0841b340), WTC2(0x08ce75b0), WTC2(0x095ed980), WTC2(0x09f2c900), WTC2(0x0a8a2e80), WTC2(0x0b24f470), WTC2(0x0bc30510), WTC2(0x0c644ad0),
- WTC2(0x0d08b010), WTC2(0x0db01f10), WTC2(0x0e5a8250), WTC2(0x0f07c400), WTC2(0x0fb7cea0), WTC2(0x106a8c80), WTC2(0x111fe800), WTC2(0x11d7cb60),
- WTC2(0x12922120), WTC2(0x134ed3a0), WTC2(0x140dcd00), WTC2(0x14cef7e0), WTC2(0x15923e60), WTC2(0x16578b00), WTC2(0x171ec820), WTC2(0x17e7e020),
- WTC2(0x18b2bd20), WTC2(0x197f49c0), WTC2(0x1a4d7040), WTC2(0x1b1d1b00), WTC2(0x1bee3460), WTC2(0x1cc0a6a0), WTC2(0x1d945c40), WTC2(0x1e693f80),
- WTC2(0x1f3f3ac0), WTC2(0x20163880), WTC2(0x20ee22c0), WTC2(0x21c6e440), WTC2(0x22a06740), WTC2(0x237a9600), WTC2(0x24555ac0), WTC2(0x2530a040),
- WTC2(0x260c5080), WTC2(0x26e85600), WTC2(0x27c49b00), WTC2(0x28a10a00), WTC2(0x297d8d80), WTC2(0x2a5a0f80), WTC2(0x2b367a80), WTC2(0x2c12b8c0),
- WTC2(0x2ceeb500), WTC2(0x2dca5940), WTC2(0x2ea58fc0), WTC2(0x2f804340), WTC2(0x305a5dc0), WTC2(0x3133ca00), WTC2(0x320c7200), WTC2(0x32e44000),
- WTC2(0x33bb1ec0), WTC2(0x3490f880), WTC2(0x3565b7c0), WTC2(0x36394640), WTC2(0x370b8f00), WTC2(0x37dc7c00), WTC2(0x38abf7c0), WTC2(0x3979ecc0),
- WTC2(0x3a464500), WTC2(0x3b10eb00), WTC2(0x3bd9c940), WTC2(0x3ca0c9c0), WTC2(0x3d65d740), WTC2(0x3e28dc00), WTC2(0x3ee9c240), WTC2(0x3fa87480),
- WTC2(0x4064dcff), WTC2(0x411ee67f), WTC2(0x41d67a7f), WTC2(0x428b847f), WTC2(0x433ded7f), WTC2(0x43eda0ff), WTC2(0x449a887f), WTC2(0x45448f7f),
- WTC2(0x45eb9eff), WTC2(0x468fa1ff), WTC2(0x473082ff), WTC2(0x47ce2c7f), WTC2(0x4868887f), WTC2(0x48ff80ff), WTC2(0x499300ff), WTC2(0x4a22f2ff),
- WTC2(0x4aaf407f), WTC2(0x4b37d47f), WTC2(0x4bbc997f), WTC2(0x4c3d78ff), WTC2(0x4cba5e7f), WTC2(0x4d33337f), WTC2(0x4da7e27f), WTC2(0x4e18567f),
- WTC2(0x4e8478ff), WTC2(0x4eec347f), WTC2(0x4f4f737f), WTC2(0x4fae20ff), WTC2(0x500825ff), WTC2(0x505d6dff), WTC2(0x50ade37f), WTC2(0x50f96f7f),
- WTC2(0x513ffdff), WTC2(0x518177ff), WTC2(0x51bdc87f), WTC2(0x51f4d9ff), WTC2(0x5226967f), WTC2(0x5252e87f), WTC2(0x5279b9ff), WTC2(0x529af5ff),
- WTC2(0x52b6867f), WTC2(0x52cc55ff), WTC2(0x52dc4eff), WTC2(0x52e65aff), WTC2(0x52ea657f), WTC2(0x52e857ff), WTC2(0x52e01d7f), WTC2(0x52d19fff),
- WTC2(0x52bcc9ff), WTC2(0x52a1857f), WTC2(0x527fbd7f), WTC2(0x52575b7f), WTC2(0x52284a7f), WTC2(0x51f274ff), WTC2(0x51b5c47f), WTC2(0x5172247f),
- WTC2(0x51277dff), WTC2(0x50d5bc7f), WTC2(0x507cc9ff), WTC2(0x501c90ff), WTC2(0x4fb4fb7f), WTC2(0x4f45f3ff), WTC2(0x4ecf64ff), WTC2(0x4e5138ff),
- WTC2(0x4dcb597f), WTC2(0x4d3db1ff), WTC2(0x4ca82bff), WTC2(0x4c0ab27f), WTC2(0x4b652f7f), WTC2(0x4ab78d7f), WTC2(0x4a01b67f), WTC2(0x4943957f),
- WTC2(0x487d12ff), WTC2(0x47ae1f7f), WTC2(0x46d68f7f), WTC2(0x45f7187f), WTC2(0x4513597f), WTC2(0x4430467f), WTC2(0x4352d2ff), WTC2(0x427e6bff),
- WTC2(0x41b390ff), WTC2(0x40f2077f), WTC2(0x4039a87f), WTC2(0x3f8a3100), WTC2(0x3ee33e00), WTC2(0x3e446ac0), WTC2(0x3dad5180), WTC2(0x3d1d7fc0),
- WTC2(0x3c947b00), WTC2(0x3c11c7c0), WTC2(0x3b94ebc0), WTC2(0x3b1d6dc0), WTC2(0x3aaad480), WTC2(0x3a3ca740), WTC2(0x39d26c40), WTC2(0x396ba8c0),
- WTC2(0x3907e080), WTC2(0x38a69800), WTC2(0x38473d80), WTC2(0x37e923c0), WTC2(0x378b9b80), WTC2(0x372e0380), WTC2(0x36d03a80), WTC2(0x36727f00),
- WTC2(0x36150e40), WTC2(0x35b81540), WTC2(0x355b8000), WTC2(0x34ff1dc0), WTC2(0x34a2bfc0), WTC2(0x34463e80), WTC2(0x33e982c0), WTC2(0x338c7880),
- WTC2(0x332f0bc0), WTC2(0x32d11800), WTC2(0x327265c0), WTC2(0x3212bbc0), WTC2(0x31b1e740), WTC2(0x314fef00), WTC2(0x30ed0540), WTC2(0x30895c80),
- WTC2(0x30251880), WTC2(0x2fc02880), WTC2(0x2f5a6480), WTC2(0x2ef3a480), WTC2(0x2e8bd640), WTC2(0x2e231100), WTC2(0x2db97680), WTC2(0x2d4f2700),
- WTC2(0x2ce431c0), WTC2(0x2c789080), WTC2(0x2c0c3bc0), WTC2(0x2b9f2bc0), WTC2(0x2b315940), WTC2(0x2ac2bc00), WTC2(0x2a534cc0), WTC2(0x29e303c0)
-};
-
-
diff --git a/libAACenc/src/aacEnc_rom.h b/libAACenc/src/aacEnc_rom.h
deleted file mode 100644
index 37e5012..0000000
--- a/libAACenc/src/aacEnc_rom.h
+++ /dev/null
@@ -1,203 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************************************************************
-
- Initial authors: M. Lohwasser, M. Gayer
- Contents/description:
-
-******************************************************************************/
-/*!
- \file
- \brief Memory layout
- \author Markus Lohwasser
-*/
-
-#ifndef AAC_ENC_ROM_H
-#define AAC_ENC_ROM_H
-
-#include "common_fix.h"
-
-#include "psy_const.h"
-#include "psy_configuration.h"
-#include "FDK_tools_rom.h"
-
-/*
- Huffman Tables
-*/
-extern const INT FDKaacEnc_huff_ltab1_2[3][3][3][3];
-extern const INT FDKaacEnc_huff_ltab3_4[3][3][3][3];
-extern const INT FDKaacEnc_huff_ltab5_6[9][9];
-extern const INT FDKaacEnc_huff_ltab7_8[8][8];
-extern const INT FDKaacEnc_huff_ltab9_10[13][13];
-extern const UCHAR FDKaacEnc_huff_ltab11[17][17];
-extern const UCHAR FDKaacEnc_huff_ltabscf[121];
-extern const USHORT FDKaacEnc_huff_ctab1[3][3][3][3];
-extern const USHORT FDKaacEnc_huff_ctab2[3][3][3][3];
-extern const USHORT FDKaacEnc_huff_ctab3[3][3][3][3];
-extern const USHORT FDKaacEnc_huff_ctab4[3][3][3][3];
-extern const USHORT FDKaacEnc_huff_ctab5[9][9];
-extern const USHORT FDKaacEnc_huff_ctab6[9][9];
-extern const USHORT FDKaacEnc_huff_ctab7[8][8];
-extern const USHORT FDKaacEnc_huff_ctab8[8][8];
-extern const USHORT FDKaacEnc_huff_ctab9[13][13];
-extern const USHORT FDKaacEnc_huff_ctab10[13][13];
-extern const USHORT FDKaacEnc_huff_ctab11[21][17];
-extern const INT FDKaacEnc_huff_ctabscf[121];
-
-/*
- quantizer
-*/
-#define MANT_DIGITS 9
-#define MANT_SIZE (1<<MANT_DIGITS)
-
-#if defined(ARCH_PREFER_MULT_32x16)
-#define FIXP_QTD FIXP_SGL
-#define QTC FX_DBL2FXCONST_SGL
-#else
-#define FIXP_QTD FIXP_DBL
-#define QTC
-#endif
-
-extern const FIXP_QTD FDKaacEnc_mTab_3_4[MANT_SIZE];
-extern const FIXP_QTD FDKaacEnc_quantTableQ[4];
-extern const FIXP_QTD FDKaacEnc_quantTableE[4];
-
-extern const FIXP_DBL FDKaacEnc_mTab_4_3Elc[512];
-extern const FIXP_DBL FDKaacEnc_specExpMantTableCombElc[4][14];
-extern const UCHAR FDKaacEnc_specExpTableComb[4][14];
-
-
-/*
- table to count used number of bits
-*/
-extern const SHORT FDKaacEnc_sideInfoTabLong[MAX_SFB_LONG + 1];
-extern const SHORT FDKaacEnc_sideInfoTabShort[MAX_SFB_SHORT + 1];
-
-
-/*
- Psy Configuration constants
-*/
-extern const SFB_PARAM_LONG p_FDKaacEnc_8000_long_1024;
-extern const SFB_PARAM_SHORT p_FDKaacEnc_8000_short_128;
-extern const SFB_PARAM_LONG p_FDKaacEnc_11025_long_1024;
-extern const SFB_PARAM_SHORT p_FDKaacEnc_11025_short_128;
-extern const SFB_PARAM_LONG p_FDKaacEnc_12000_long_1024;
-extern const SFB_PARAM_SHORT p_FDKaacEnc_12000_short_128;
-extern const SFB_PARAM_LONG p_FDKaacEnc_16000_long_1024;
-extern const SFB_PARAM_SHORT p_FDKaacEnc_16000_short_128;
-extern const SFB_PARAM_LONG p_FDKaacEnc_22050_long_1024;
-extern const SFB_PARAM_SHORT p_FDKaacEnc_22050_short_128;
-extern const SFB_PARAM_LONG p_FDKaacEnc_24000_long_1024;
-extern const SFB_PARAM_SHORT p_FDKaacEnc_24000_short_128;
-extern const SFB_PARAM_LONG p_FDKaacEnc_32000_long_1024;
-extern const SFB_PARAM_SHORT p_FDKaacEnc_32000_short_128;
-extern const SFB_PARAM_LONG p_FDKaacEnc_44100_long_1024;
-extern const SFB_PARAM_SHORT p_FDKaacEnc_44100_short_128;
-extern const SFB_PARAM_LONG p_FDKaacEnc_48000_long_1024;
-extern const SFB_PARAM_SHORT p_FDKaacEnc_48000_short_128;
-extern const SFB_PARAM_LONG p_FDKaacEnc_64000_long_1024;
-extern const SFB_PARAM_SHORT p_FDKaacEnc_64000_short_128;
-extern const SFB_PARAM_LONG p_FDKaacEnc_88200_long_1024;
-extern const SFB_PARAM_SHORT p_FDKaacEnc_88200_short_128;
-extern const SFB_PARAM_LONG p_FDKaacEnc_96000_long_1024;
-extern const SFB_PARAM_SHORT p_FDKaacEnc_96000_short_128;
-
-
-/*
- TNS filter coefficients
-*/
-extern const FIXP_DBL FDKaacEnc_tnsEncCoeff3[8];
-extern const FIXP_DBL FDKaacEnc_tnsCoeff3Borders[8];
-extern const FIXP_DBL FDKaacEnc_tnsEncCoeff4[16];
-extern const FIXP_DBL FDKaacEnc_tnsCoeff4Borders[16];
-
-#define WTC0 WTC
-#define WTC1 WTC
-#define WTC2 WTC
-
-extern const FIXP_WTB ELDAnalysis512[1536];
-extern const FIXP_WTB ELDAnalysis480[1440];
-
-
-#endif /* #ifndef AAC_ENC_ROM_H */
diff --git a/libAACenc/src/aacenc.cpp b/libAACenc/src/aacenc.cpp
deleted file mode 100644
index 96668cc..0000000
--- a/libAACenc/src/aacenc.cpp
+++ /dev/null
@@ -1,1081 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/*************************** Fast MPEG AAC Audio Encoder **********************
-
- Initial author: M. Schug / A. Groeschel
- contents/description: fast aac coder functions
-
-******************************************************************************/
-#include <stdio.h>
-#include "aacenc.h"
-
-#include "bitenc.h"
-#include "interface.h"
-#include "psy_configuration.h"
-#include "psy_main.h"
-#include "qc_main.h"
-#include "bandwidth.h"
-#include "channel_map.h"
-#include "tns_func.h"
-#include "aacEnc_ram.h"
-
-#include "genericStds.h"
-
-
-
-
-#define MIN_BUFSIZE_PER_EFF_CHAN 6144
-
-static AAC_ENCODER_ERROR FDKaacEnc_InitCheckAncillary(INT bitRate,
- INT framelength,
- INT ancillaryRate,
- INT *ancillaryBitsPerFrame,
- INT sampleRate);
-
-INT FDKaacEnc_LimitBitrate(
- HANDLE_TRANSPORTENC hTpEnc,
- INT coreSamplingRate,
- INT frameLength,
- INT nChannels,
- INT nChannelsEff,
- INT bitRate,
- INT averageBits,
- INT *pAverageBitsPerFrame,
- INT bitrateMode,
- INT nSubFrames
- )
-{
- INT transportBits, prevBitRate, averageBitsPerFrame, shift = 0, iter=0;
-
- while ( (frameLength & ~((1<<(shift+1))-1)) == frameLength
- && (coreSamplingRate & ~((1<<(shift+1))-1)) == coreSamplingRate )
- {
- shift ++;
- }
-
- do {
- prevBitRate = bitRate;
- averageBitsPerFrame = (bitRate*(frameLength>>shift)) / (coreSamplingRate>>shift) / nSubFrames;
- //fprintf(stderr, "FDKaacEnc_LimitBitrate(): averageBitsPerFrame=%d, prevBitRate=%d, nSubFrames=%d\n", averageBitsPerFrame, prevBitRate, bitRate);
-
- if (pAverageBitsPerFrame != NULL) {
- *pAverageBitsPerFrame = averageBitsPerFrame;
- }
-
- if (hTpEnc != NULL) {
- transportBits = transportEnc_GetStaticBits(hTpEnc, averageBitsPerFrame);
- } else {
- /* Assume some worst case */
- transportBits = 208;
- }
-
- //fprintf(stderr, "FDKaacEnc_LimitBitrate(): transportBits=%d, FDKmax(%d, %d)\n", transportBits, bitRate,
- // ((((40 * nChannels) + transportBits) * (coreSamplingRate)) / frameLength));
- bitRate = FDKmax(bitRate, ((((40 * nChannels) + transportBits) * (coreSamplingRate)) / frameLength) );
- FDK_ASSERT(bitRate >= 0);
-
- //fprintf(stderr, "FDKaacEnc_LimitBitrate(): FDKmin(%d, %d)\n", bitRate, ((nChannelsEff * MIN_BUFSIZE_PER_EFF_CHAN)*(coreSamplingRate>>shift)) / (frameLength>>shift));
- bitRate = FDKmin(bitRate, ((nChannelsEff * MIN_BUFSIZE_PER_EFF_CHAN)*(coreSamplingRate>>shift)) / (frameLength>>shift)) ;
- FDK_ASSERT(bitRate >= 0);
-
- } while (prevBitRate != bitRate && iter++ < 3) ;
-
- //fprintf(stderr, "FDKaacEnc_LimitBitrate(): bitRate=%d\n", bitRate);
- return bitRate;
-}
-
-
-typedef struct
-{
- AACENC_BITRATE_MODE bitrateMode;
- int chanBitrate[2]; /* mono/stereo settings */
-} CONFIG_TAB_ENTRY_VBR;
-
-static const CONFIG_TAB_ENTRY_VBR configTabVBR[] = {
- {AACENC_BR_MODE_CBR, { 0, 0}} ,
- {AACENC_BR_MODE_VBR_1, { 32000, 20000}} ,
- {AACENC_BR_MODE_VBR_2, { 40000, 32000}} ,
- {AACENC_BR_MODE_VBR_3, { 56000, 48000}} ,
- {AACENC_BR_MODE_VBR_4, { 72000, 64000}} ,
- {AACENC_BR_MODE_VBR_5, {112000, 96000}}
-};
-
-/*-----------------------------------------------------------------------------
-
- functionname: FDKaacEnc_GetVBRBitrate
- description: Get VBR bitrate from vbr quality
- input params: int vbrQuality (VBR0, VBR1, VBR2)
- channelMode
- returns: vbr bitrate
-
- ------------------------------------------------------------------------------*/
-INT FDKaacEnc_GetVBRBitrate(INT bitrateMode, CHANNEL_MODE channelMode)
-{
- INT bitrate = 0;
- INT monoStereoMode = 0; /* default mono */
-
- if (FDKaacEnc_GetMonoStereoMode(channelMode)==EL_MODE_STEREO) {
- monoStereoMode = 1;
- }
-
- switch((AACENC_BITRATE_MODE)bitrateMode){
- case AACENC_BR_MODE_VBR_1:
- case AACENC_BR_MODE_VBR_2:
- case AACENC_BR_MODE_VBR_3:
- case AACENC_BR_MODE_VBR_4:
- case AACENC_BR_MODE_VBR_5:
- bitrate = configTabVBR[bitrateMode].chanBitrate[monoStereoMode];
- break;
- case AACENC_BR_MODE_INVALID:
- case AACENC_BR_MODE_CBR:
- case AACENC_BR_MODE_SFR:
- case AACENC_BR_MODE_FF:
- default:
- bitrate = 0;
- break;
- }
-
- /* convert channel bitrate to overall bitrate*/
- bitrate *= FDKaacEnc_GetChannelModeConfiguration(channelMode)->nChannelsEff;
-
- return bitrate;
-}
-
-/**
- * \brief Convert encoder bitreservoir value for transport library.
- *
- * \param bitrateMode Bitratemode used in current encoder instance. Se ::AACENC_BITRATE_MODE
- * \param bitresTotal Encoder bitreservoir level in bits.
- *
- * \return Corrected bitreservoir level used in transport library.
- */
-static INT FDKaacEnc_EncBitresToTpBitres(
- const AACENC_BITRATE_MODE bitrateMode,
- const INT bitresTotal
- )
-{
- INT transporBitreservoir = 0;
-
- switch (bitrateMode) {
- case AACENC_BR_MODE_CBR:
- transporBitreservoir = bitresTotal; /* encoder bitreservoir level */
- break;
- case AACENC_BR_MODE_VBR_1:
- case AACENC_BR_MODE_VBR_2:
- case AACENC_BR_MODE_VBR_3:
- case AACENC_BR_MODE_VBR_4:
- case AACENC_BR_MODE_VBR_5:
- transporBitreservoir = FDK_INT_MAX; /* signal variable bitrate */
- break;
- case AACENC_BR_MODE_FF:
- case AACENC_BR_MODE_SFR:
- transporBitreservoir = 0; /* super framing and fixed framing */
- break; /* without bitreservoir signaling */
- default:
- case AACENC_BR_MODE_INVALID:
- transporBitreservoir = 0; /* invalid configuration*/
- FDK_ASSERT(0);
- }
-
- return transporBitreservoir;
-}
-
-/*-----------------------------------------------------------------------------
-
- functionname: FDKaacEnc_AacInitDefaultConfig
- description: gives reasonable default configuration
- returns: ---
-
- ------------------------------------------------------------------------------*/
-void FDKaacEnc_AacInitDefaultConfig(AACENC_CONFIG *config)
-{
- /* make thepre initialization of the structs flexible */
- FDKmemclear(config, sizeof(AACENC_CONFIG));
-
- /* default ancillary */
- config->anc_Rate = 0; /* no ancillary data */
- config->ancDataBitRate = 0; /* no additional consumed bitrate */
-
- /* default configurations */
- config->bitRate = -1; /* bitrate must be set*/
- config->averageBits = -1; /* instead of bitrate/s we can configure bits/superframe */
- config->bitrateMode = 0;
- config->bandWidth = 0; /* get bandwidth from table */
- config->useTns = TNS_ENABLE_MASK; /* tns enabled completly */
- config->usePns = 1; /* depending on channelBitrate this might be set to 0 later */
- config->useIS = 1; /* Intensity Stereo Configuration */
- config->framelength = -1; /* Framesize not configured */
- config->syntaxFlags = 0; /* default syntax with no specialities */
- config->epConfig = -1; /* no ER syntax -> no additional error protection */
- config->nSubFrames = 1; /* default, no sub frames */
- config->channelOrder = CH_ORDER_MPEG; /* Use MPEG channel ordering. */
- config->channelMode = MODE_UNKNOWN;
- config->minBitsPerFrame = -1; /* minum number of bits in each AU */
- config->maxBitsPerFrame = -1; /* minum number of bits in each AU */
- config->bitreservoir = -1; /* default, uninitialized value */
-
- /* init tabs in fixpoint_math */
- InitLdInt();
- InitInvSqrtTab();
-}
-
-
-/*---------------------------------------------------------------------------
-
- functionname: FDKaacEnc_Open
- description: allocate and initialize a new encoder instance
- returns: error code
-
- ---------------------------------------------------------------------------*/
-AAC_ENCODER_ERROR FDKaacEnc_Open(HANDLE_AAC_ENC *phAacEnc,
- const INT nElements,
- const INT nChannels,
- const INT nSubFrames)
-{
- AAC_ENCODER_ERROR ErrorStatus;
- AAC_ENC *hAacEnc = NULL;
- UCHAR *dynamicRAM = NULL;
-
- if (phAacEnc==NULL) {
- return AAC_ENC_INVALID_HANDLE;
- }
-
- /* allocate encoder structure */
- hAacEnc = GetRam_aacEnc_AacEncoder();
- if (hAacEnc == NULL) {
- ErrorStatus = AAC_ENC_NO_MEMORY;
- goto bail;
- }
- FDKmemclear(hAacEnc, sizeof(AAC_ENC));
-
- hAacEnc->dynamic_RAM = GetAACdynamic_RAM();
- dynamicRAM = (UCHAR*)hAacEnc->dynamic_RAM;
-
- /* allocate the Psy aud Psy Out structure */
- ErrorStatus = FDKaacEnc_PsyNew(&hAacEnc->psyKernel,
- nElements,
- nChannels
- ,dynamicRAM
- );
- if (ErrorStatus != AAC_ENC_OK)
- goto bail;
-
- ErrorStatus = FDKaacEnc_PsyOutNew(hAacEnc->psyOut,
- nElements,
- nChannels,
- nSubFrames
- ,dynamicRAM
- );
- if (ErrorStatus != AAC_ENC_OK)
- goto bail;
-
- /* allocate the Q&C Out structure */
- ErrorStatus = FDKaacEnc_QCOutNew(hAacEnc->qcOut,
- nElements,
- nChannels,
- nSubFrames
- ,dynamicRAM
- );
- if (ErrorStatus != AAC_ENC_OK)
- goto bail;
-
- /* allocate the Q&C kernel */
- ErrorStatus = FDKaacEnc_QCNew(&hAacEnc->qcKernel,
- nElements
- ,dynamicRAM
- );
- if (ErrorStatus != AAC_ENC_OK)
- goto bail;
-
- hAacEnc->maxChannels = nChannels;
- hAacEnc->maxElements = nElements;
- hAacEnc->maxFrames = nSubFrames;
-
-bail:
- *phAacEnc = hAacEnc;
- return ErrorStatus;
-}
-
-
-AAC_ENCODER_ERROR FDKaacEnc_Initialize(HANDLE_AAC_ENC hAacEnc,
- AACENC_CONFIG *config, /* pre-initialized config struct */
- HANDLE_TRANSPORTENC hTpEnc,
- ULONG initFlags)
-{
- AAC_ENCODER_ERROR ErrorStatus;
- INT psyBitrate, tnsMask; //INT profile = 1;
- CHANNEL_MAPPING *cm = NULL;
-
- INT qmbfac, qbw;
- FIXP_DBL mbfac, bw_ratio;
- QC_INIT qcInit;
- INT averageBitsPerFrame = 0;
-
- if (config==NULL)
- return AAC_ENC_INVALID_HANDLE;
-
- /******************* sanity checks *******************/
-
- /* check config structure */
- if (config->nChannels < 1 || config->nChannels > (8)) {
- return AAC_ENC_UNSUPPORTED_CHANNELCONFIG;
- }
-
- /* check sample rate */
- switch (config->sampleRate)
- {
- case 8000:
- case 11025:
- case 12000:
- case 16000:
- case 22050:
- case 24000:
- case 32000:
- case 44100:
- case 48000:
- case 64000:
- case 88200:
- case 96000:
- break;
- default:
- return AAC_ENC_UNSUPPORTED_SAMPLINGRATE;
- }
-
- /* bitrate has to be set */
- if (config->bitRate==-1) {
- return AAC_ENC_UNSUPPORTED_BITRATE;
- }
-
- INT superframe_size = 110*8*(config->bitRate/8000);
- INT frames_per_superframe = 6;
- INT staticBits = 0;
- if((config->syntaxFlags & AC_DAB) && hTpEnc) {
- staticBits = transportEnc_GetStaticBits(hTpEnc, 0);
- switch(config->sampleRate) {
- case 48000:
- frames_per_superframe=6;
- break;
- case 32000:
- frames_per_superframe=4;
- break;
- case 24000:
- frames_per_superframe=3;
- break;
- case 16000:
- frames_per_superframe=2;
- break;
- }
-
- //config->nSubFrames = frames_per_superframe;
- //fprintf(stderr, "DAB+ superframe size=%d\n", superframe_size);
- config->bitRate = (superframe_size - 16*(frames_per_superframe-1) - staticBits) * 1000/120;
- //fprintf(stderr, "DAB+ tuned bitrate=%d\n", config->bitRate);
- config->maxBitsPerFrame = (superframe_size - 16*(frames_per_superframe-1) - staticBits) / frames_per_superframe;
- config->maxBitsPerFrame += 7; /*padding*/
- //config->bitreservoir=(superframe_size - 16*(frames_per_superframe-1) - staticBits - 2*8)/frames_per_superframe;
- //fprintf(stderr, "DAB+ tuned maxBitsPerFrame=%d\n", (superframe_size - 16*(frames_per_superframe-1) - staticBits)/frames_per_superframe);
- }
-
- /* check bit rate */
-
- if (FDKaacEnc_LimitBitrate(
- hTpEnc,
- config->sampleRate,
- config->framelength,
- config->nChannels,
- FDKaacEnc_GetChannelModeConfiguration(config->channelMode)->nChannelsEff,
- config->bitRate,
- config->averageBits,
- &averageBitsPerFrame,
- config->bitrateMode,
- config->nSubFrames
- ) != config->bitRate )
- {
- return AAC_ENC_UNSUPPORTED_BITRATE;
- }
-
- if (config->syntaxFlags & AC_ER_VCB11) {
- return AAC_ENC_UNSUPPORTED_ER_FORMAT;
- }
- if (config->syntaxFlags & AC_ER_HCR) {
- return AAC_ENC_UNSUPPORTED_ER_FORMAT;
- }
-
- /* check frame length */
- switch (config->framelength)
- {
- case 1024:
- case 960: //TODO: DRM
- if ( config->audioObjectType == AOT_ER_AAC_LD
- || config->audioObjectType == AOT_ER_AAC_ELD )
- {
- return AAC_ENC_INVALID_FRAME_LENGTH;
- }
- break;
- case 512:
- case 480:
- if ( config->audioObjectType != AOT_ER_AAC_LD
- && config->audioObjectType != AOT_ER_AAC_ELD )
- {
- return AAC_ENC_INVALID_FRAME_LENGTH;
- }
- break;
- default:
- return AAC_ENC_INVALID_FRAME_LENGTH;
- }
-
- if (config->anc_Rate != 0) {
-
- ErrorStatus = FDKaacEnc_InitCheckAncillary(config->bitRate,
- config->framelength,
- config->anc_Rate,
- &hAacEnc->ancillaryBitsPerFrame,
- config->sampleRate);
- if (ErrorStatus != AAC_ENC_OK)
- goto bail;
-
-
- /* update estimated consumed bitrate */
- config->ancDataBitRate += ( (hAacEnc->ancillaryBitsPerFrame * config->sampleRate) / config->framelength );
-
- }
-
- /* maximal allowed DSE bytes in frame */
- {
- /* fixpoint calculation*/
- INT q_res, encBitrate, sc;
- FIXP_DBL tmp = fDivNorm(config->framelength, config->sampleRate, &q_res);
- encBitrate = (config->bitRate/*-config->ancDataBitRate*/)- (INT)(config->nChannels*8000);
- sc = CountLeadingBits(encBitrate);
- config->maxAncBytesPerAU = FDKmin( (256), FDKmax(0,(INT)(fMultDiv2(tmp, (FIXP_DBL)(encBitrate<<sc))>>(-q_res+sc-1+3))) );
- }
-
- /* bind config to hAacEnc->config */
- hAacEnc->config = config;
-
- /* set hAacEnc->bitrateMode */
- hAacEnc->bitrateMode = (AACENC_BITRATE_MODE)config->bitrateMode;
-
- hAacEnc->encoderMode = config->channelMode;
-
- ErrorStatus = FDKaacEnc_InitChannelMapping(hAacEnc->encoderMode, config->channelOrder, &hAacEnc->channelMapping);
- if (ErrorStatus != AAC_ENC_OK)
- goto bail;
-
- cm = &hAacEnc->channelMapping;
-
- ErrorStatus = FDKaacEnc_DetermineBandWidth(&hAacEnc->config->bandWidth,
- config->bandWidth,
- config->bitRate - config->ancDataBitRate,
- hAacEnc->bitrateMode,
- config->sampleRate,
- config->framelength,
- cm,
- hAacEnc->encoderMode);
- if (ErrorStatus != AAC_ENC_OK)
- goto bail;
-
- hAacEnc->bandwidth90dB = (INT)hAacEnc->config->bandWidth;
-
- tnsMask = config->useTns ? TNS_ENABLE_MASK : 0x0;
- psyBitrate = config->bitRate - config->ancDataBitRate;
-
- ErrorStatus = FDKaacEnc_psyInit(hAacEnc->psyKernel,
- hAacEnc->psyOut,
- hAacEnc->maxFrames,
- hAacEnc->maxChannels,
- config->audioObjectType,
- cm);
- if (ErrorStatus != AAC_ENC_OK)
- goto bail;
-
- ErrorStatus = FDKaacEnc_psyMainInit(hAacEnc->psyKernel,
- config->audioObjectType,
- cm,
- config->sampleRate,
- config->framelength,
- psyBitrate,
- tnsMask,
- hAacEnc->bandwidth90dB,
- config->usePns,
- config->useIS,
- config->syntaxFlags,
- initFlags);
- if (ErrorStatus != AAC_ENC_OK)
- goto bail;
-
- ErrorStatus = FDKaacEnc_QCOutInit(hAacEnc->qcOut, hAacEnc->maxFrames, cm);
- if (ErrorStatus != AAC_ENC_OK)
- goto bail;
-
-
-
- qcInit.channelMapping = &hAacEnc->channelMapping;
- qcInit.sceCpe = 0;
-
- if ((config->bitrateMode>=1) && (config->bitrateMode<=5)) {
- qcInit.averageBits = (averageBitsPerFrame+7)&~7;
- qcInit.bitRes = MIN_BUFSIZE_PER_EFF_CHAN*cm->nChannelsEff;
- qcInit.maxBits = MIN_BUFSIZE_PER_EFF_CHAN*cm->nChannelsEff;
- qcInit.minBits = 0;
- }
- else
- {
- int maxBitres;
- qcInit.averageBits = (averageBitsPerFrame+7)&~7;
- maxBitres = (MIN_BUFSIZE_PER_EFF_CHAN*cm->nChannelsEff) - qcInit.averageBits;
- qcInit.bitRes = (config->bitreservoir!=-1) ? FDKmin(config->bitreservoir, maxBitres) : maxBitres;
- //fprintf(stderr, "qcInit.bitRes=%d\n", qcInit.bitRes);
-
- qcInit.maxBits = fixMin(MIN_BUFSIZE_PER_EFF_CHAN*cm->nChannelsEff, ((averageBitsPerFrame+7)&~7)+qcInit.bitRes);
- qcInit.maxBits = (config->maxBitsPerFrame!=-1) ? fixMin(qcInit.maxBits, config->maxBitsPerFrame) : qcInit.maxBits;
- //fprintf(stderr, "qcInit.maxBits=%d\n", qcInit.maxBits);
-
- qcInit.minBits = fixMax(0, ((averageBitsPerFrame-1)&~7)-qcInit.bitRes-transportEnc_GetStaticBits(hTpEnc, ((averageBitsPerFrame+7)&~7)+qcInit.bitRes));
- qcInit.minBits = (config->minBitsPerFrame!=-1) ? fixMax(qcInit.minBits, config->minBitsPerFrame) : qcInit.minBits;
- //fprintf(stderr, "qcInit.minBits=%d\n", qcInit.minBits);
- }
-
- qcInit.sampleRate = config->sampleRate;
- qcInit.advancedBitsToPe = isLowDelay(config->audioObjectType) ? 1 : 0 ;
- qcInit.nSubFrames = config->nSubFrames;
- qcInit.padding.paddingRest = config->sampleRate;
-
- /* Calc meanPe */
- bw_ratio = fDivNorm((FIXP_DBL)hAacEnc->bandwidth90dB, (FIXP_DBL)(config->sampleRate>>1), &qbw);
- qbw = DFRACT_BITS-1-qbw;
- /* qcInit.meanPe = 10.0f * FRAME_LEN_LONG * hAacEnc->bandwidth90dB/(config->sampleRate/2.0f); */
- qcInit.meanPe = fMult(bw_ratio, (FIXP_DBL)((10*config->framelength)<<16)) >> (qbw-15);
-
- /* Calc maxBitFac */
- mbfac = fDivNorm((MIN_BUFSIZE_PER_EFF_CHAN-744)*cm->nChannelsEff, qcInit.averageBits/qcInit.nSubFrames, &qmbfac);
- qmbfac = DFRACT_BITS-1-qmbfac;
- qcInit.maxBitFac = (qmbfac > 24) ? (mbfac >> (qmbfac - 24)):(mbfac << (24 - qmbfac));
-
- switch(config->bitrateMode){
- case AACENC_BR_MODE_CBR:
- qcInit.bitrateMode = QCDATA_BR_MODE_CBR;
- break;
- case AACENC_BR_MODE_VBR_1:
- qcInit.bitrateMode = QCDATA_BR_MODE_VBR_1;
- break;
- case AACENC_BR_MODE_VBR_2:
- qcInit.bitrateMode = QCDATA_BR_MODE_VBR_2;
- break;
- case AACENC_BR_MODE_VBR_3:
- qcInit.bitrateMode = QCDATA_BR_MODE_VBR_3;
- break;
- case AACENC_BR_MODE_VBR_4:
- qcInit.bitrateMode = QCDATA_BR_MODE_VBR_4;
- break;
- case AACENC_BR_MODE_VBR_5:
- qcInit.bitrateMode = QCDATA_BR_MODE_VBR_5;
- break;
- case AACENC_BR_MODE_SFR:
- qcInit.bitrateMode = QCDATA_BR_MODE_SFR;
- break;
- case AACENC_BR_MODE_FF:
- qcInit.bitrateMode = QCDATA_BR_MODE_FF;
- break;
- default:
- ErrorStatus = AAC_ENC_UNSUPPORTED_BITRATE_MODE;
- goto bail;
- }
-
- qcInit.invQuant = (config->useRequant)?2:0;
-
- /* maxIterations should be set to the maximum number of requantization iterations that are
- * allowed before the crash recovery functionality is activated. This setting should be adjusted
- * to the processing power available, i.e. to the processing power headroom in one frame that is
- * still left after normal encoding without requantization. Please note that if activated this
- * functionality is used most likely only in cases where the encoder is operating beyond
- * recommended settings, i.e. the audio quality is suboptimal anyway. Activating the crash
- * recovery does not further reduce audio quality significantly in these cases. */
- if ( (config->audioObjectType == AOT_ER_AAC_LD) || (config->audioObjectType == AOT_ER_AAC_ELD) ) {
- qcInit.maxIterations = 2;
- }
- else
- {
- qcInit.maxIterations = 5;
- }
-
- qcInit.bitrate = config->bitRate - config->ancDataBitRate;
-
- qcInit.staticBits = transportEnc_GetStaticBits(hTpEnc, qcInit.averageBits/qcInit.nSubFrames);
-
- ErrorStatus = FDKaacEnc_QCInit(hAacEnc->qcKernel, &qcInit);
- if (ErrorStatus != AAC_ENC_OK)
- goto bail;
-
- /* Map virtual aot's to intern aot used in bitstream writer. */
- switch (hAacEnc->config->audioObjectType) {
- case AOT_MP2_AAC_LC:
- case AOT_DABPLUS_AAC_LC:
- hAacEnc->aot = AOT_AAC_LC;
- break;
- case AOT_MP2_SBR:
- case AOT_DABPLUS_SBR:
- hAacEnc->aot = AOT_SBR;
- break;
- case AOT_MP2_PS:
- case AOT_DABPLUS_PS:
- hAacEnc->aot = AOT_PS;
- break;
- default:
- hAacEnc->aot = hAacEnc->config->audioObjectType;
- }
-
- /* common things */
-
- return AAC_ENC_OK;
-
-bail:
-
- return ErrorStatus;
-}
-
-
-/*---------------------------------------------------------------------------
-
- functionname: FDKaacEnc_EncodeFrame
- description: encodes one frame
- returns: error code
-
- ---------------------------------------------------------------------------*/
-AAC_ENCODER_ERROR FDKaacEnc_EncodeFrame( HANDLE_AAC_ENC hAacEnc, /* encoder handle */
- HANDLE_TRANSPORTENC hTpEnc,
- INT_PCM* RESTRICT inputBuffer,
- INT* nOutBytes,
- AACENC_EXT_PAYLOAD extPayload[MAX_TOTAL_EXT_PAYLOADS]
- )
-{
- AAC_ENCODER_ERROR ErrorStatus;
- int el, n, c=0;
- UCHAR extPayloadUsed[MAX_TOTAL_EXT_PAYLOADS];
-
- CHANNEL_MAPPING *cm = &hAacEnc->channelMapping;
-
-
-
- PSY_OUT *psyOut = hAacEnc->psyOut[c];
- QC_OUT *qcOut = hAacEnc->qcOut[c];
-
- FDKmemclear(extPayloadUsed, MAX_TOTAL_EXT_PAYLOADS * sizeof(UCHAR));
-
- qcOut->elementExtBits = 0; /* sum up all extended bit of each element */
- qcOut->staticBits = 0; /* sum up side info bits of each element */
- qcOut->totalNoRedPe = 0; /* sum up PE */
-
- /* advance psychoacoustics */
- for (el=0; el<cm->nElements; el++) {
- ELEMENT_INFO elInfo = cm->elInfo[el];
- //fprintf(stderr, "elInfo.elType=%d\n", elInfo.elType);
-
- if ( (elInfo.elType == ID_SCE)
- || (elInfo.elType == ID_CPE)
- || (elInfo.elType == ID_LFE) )
- {
- int ch;
-
- /* update pointer!*/
- for(ch=0;ch<elInfo.nChannelsInEl;ch++) {
- PSY_OUT_CHANNEL *psyOutChan = psyOut->psyOutElement[el]->psyOutChannel[ch];
- QC_OUT_CHANNEL *qcOutChan = qcOut->qcElement[el]->qcOutChannel[ch];
-
- psyOutChan->mdctSpectrum = qcOutChan->mdctSpectrum;
- psyOutChan->sfbSpreadEnergy = qcOutChan->sfbSpreadEnergy;
- psyOutChan->sfbEnergy = qcOutChan->sfbEnergy;
- psyOutChan->sfbEnergyLdData = qcOutChan->sfbEnergyLdData;
- psyOutChan->sfbMinSnrLdData = qcOutChan->sfbMinSnrLdData;
- psyOutChan->sfbThresholdLdData = qcOutChan->sfbThresholdLdData;
-
- }
-
- FDKaacEnc_psyMain(elInfo.nChannelsInEl,
- hAacEnc->psyKernel->psyElement[el],
- hAacEnc->psyKernel->psyDynamic,
- hAacEnc->psyKernel->psyConf,
- psyOut->psyOutElement[el],
- inputBuffer,
- cm->elInfo[el].ChannelIndex,
- cm->nChannels
-
- );
-
- /* FormFactor, Pe and staticBitDemand calculation */
- ErrorStatus = FDKaacEnc_QCMainPrepare(&elInfo,
- hAacEnc->qcKernel->hAdjThr->adjThrStateElem[el],
- psyOut->psyOutElement[el],
- qcOut->qcElement[el],
- hAacEnc->aot,
- hAacEnc->config->syntaxFlags,
- hAacEnc->config->epConfig);
-
- if (ErrorStatus != AAC_ENC_OK)
- return ErrorStatus;
-
- /*-------------------------------------------- */
-
- qcOut->qcElement[el]->extBitsUsed = 0;
- qcOut->qcElement[el]->nExtensions = 0;
- /* reset extension payload */
- FDKmemclear(&qcOut->qcElement[el]->extension, (1)*sizeof(QC_OUT_EXTENSION));
-
- for ( n = 0; n < MAX_TOTAL_EXT_PAYLOADS; n++ ) {
- if ( !extPayloadUsed[n]
- && (extPayload[n].associatedChElement == el)
- && (extPayload[n].dataSize > 0)
- && (extPayload[n].pData != NULL) )
- {
- int idx = qcOut->qcElement[el]->nExtensions++;
-
- qcOut->qcElement[el]->extension[idx].type = extPayload[n].dataType; /* Perform a sanity check on the type? */
- qcOut->qcElement[el]->extension[idx].nPayloadBits = extPayload[n].dataSize;
- qcOut->qcElement[el]->extension[idx].pPayload = extPayload[n].pData;
- /* Now ask the bitstream encoder how many bits we need to encode the data with the current bitstream syntax: */
- qcOut->qcElement[el]->extBitsUsed +=
- FDKaacEnc_writeExtensionData( NULL,
- &qcOut->qcElement[el]->extension[idx],
- 0, 0,
- hAacEnc->config->syntaxFlags,
- hAacEnc->aot,
- hAacEnc->config->epConfig );
- extPayloadUsed[n] = 1;
- }
- }
-
- /* sum up extension and static bits for all channel elements */
- qcOut->elementExtBits += qcOut->qcElement[el]->extBitsUsed;
- qcOut->staticBits += qcOut->qcElement[el]->staticBitsUsed;
-
- /* sum up pe */
- qcOut->totalNoRedPe += qcOut->qcElement[el]->peData.pe;
- }
- }
-
- qcOut->nExtensions = 0;
- qcOut->globalExtBits = 0;
-
- /* reset extension payload */
- FDKmemclear(&qcOut->extension, (2+2)*sizeof(QC_OUT_EXTENSION));
-
- /* Add extension payload not assigned to an channel element
- (Ancillary data is the only supported type up to now) */
- for ( n = 0; n < MAX_TOTAL_EXT_PAYLOADS; n++ ) {
- if ( !extPayloadUsed[n]
- && (extPayload[n].associatedChElement == -1)
- && (extPayload[n].pData != NULL) )
- {
- UINT payloadBits = 0;
-
- if (extPayload[n].dataType == EXT_DATA_ELEMENT) {
- if (hAacEnc->ancillaryBitsPerFrame) {
- /* granted frame dse bitrate */
- payloadBits = hAacEnc->ancillaryBitsPerFrame;
- }
- else {
- /* write anc data if bitrate constraint fulfilled */
- if ((extPayload[n].dataSize>>3) <= hAacEnc->config->maxAncBytesPerAU) {
- payloadBits = extPayload[n].dataSize;
- }
- }
- payloadBits = fixMin( extPayload[n].dataSize, payloadBits );
- } else {
- payloadBits = extPayload[n].dataSize;
- }
-
- if (payloadBits > 0)
- {
- int idx = qcOut->nExtensions++;
-
- qcOut->extension[idx].type = extPayload[n].dataType; /* Perform a sanity check on the type? */
- qcOut->extension[idx].nPayloadBits = payloadBits;
- qcOut->extension[idx].pPayload = extPayload[n].pData;
- /* Now ask the bitstream encoder how many bits we need to encode the data with the current bitstream syntax: */
- qcOut->globalExtBits += FDKaacEnc_writeExtensionData( NULL,
- &qcOut->extension[idx],
- 0, 0,
- hAacEnc->config->syntaxFlags,
- hAacEnc->aot,
- hAacEnc->config->epConfig );
- if (extPayload[n].dataType == EXT_DATA_ELEMENT) {
- /* substract the processed bits */
- extPayload[n].dataSize -= payloadBits;
- }
- extPayloadUsed[n] = 1;
- }
- }
- }
-
- if (!(hAacEnc->config->syntaxFlags & (AC_SCALABLE|AC_ER))) {
- qcOut->globalExtBits += EL_ID_BITS; /* add bits for ID_END */
- }
-
- /* build bitstream all nSubFrames */
- {
- INT totalBits = 0; /* Total AU bits */;
- INT avgTotalBits = 0;
-
- /*-------------------------------------------- */
- /* Get average total bits */
- /*-------------------------------------------- */
- {
- /* frame wise bitrate adaption */
- FDKaacEnc_AdjustBitrate(hAacEnc->qcKernel,
- cm,
- &avgTotalBits,
- hAacEnc->config->bitRate,
- hAacEnc->config->sampleRate,
- hAacEnc->config->framelength);
-
- /* adjust super frame bitrate */
- avgTotalBits *= hAacEnc->config->nSubFrames;
- //fprintf(stderr, "avgTotalBits=%d x %d\n", avgTotalBits, hAacEnc->config->nSubFrames);
- }
-
- /* Make first estimate of transport header overhead.
- Take maximum possible frame size into account to prevent bitreservoir underrun. */
-
- //fprintf(stderr, "avgTotalBits=%d, bitResTot=%d\n", avgTotalBits, hAacEnc->qcKernel->bitResTot);
- hAacEnc->qcKernel->globHdrBits = transportEnc_GetStaticBits(hTpEnc, avgTotalBits + hAacEnc->qcKernel->bitResTot);
-
-
- /*-------------------------------------------- */
- /*-------------------------------------------- */
- /*-------------------------------------------- */
-
- ErrorStatus = FDKaacEnc_QCMain(hAacEnc->qcKernel,
- hAacEnc->psyOut,
- hAacEnc->qcOut,
- avgTotalBits,
- cm
- ,hAacEnc->aot,
- hAacEnc->config->syntaxFlags,
- hAacEnc->config->epConfig);
-
- if (ErrorStatus != AAC_ENC_OK)
- return ErrorStatus;
- /*-------------------------------------------- */
-
- /*-------------------------------------------- */
- ErrorStatus = FDKaacEnc_updateFillBits(cm,
- hAacEnc->qcKernel,
- hAacEnc->qcKernel->elementBits,
- hAacEnc->qcOut);
- if (ErrorStatus != AAC_ENC_OK)
- return ErrorStatus;
-
- /*-------------------------------------------- */
- ErrorStatus = FDKaacEnc_FinalizeBitConsumption(cm,
- hAacEnc->qcKernel,
- qcOut,
- qcOut->qcElement,
- hTpEnc,
- hAacEnc->aot,
- hAacEnc->config->syntaxFlags,
- hAacEnc->config->epConfig);
- if (ErrorStatus != AAC_ENC_OK)
- return ErrorStatus;
- /*-------------------------------------------- */
- totalBits += qcOut->totalBits;
-
-
- /*-------------------------------------------- */
- FDKaacEnc_updateBitres(cm,
- hAacEnc->qcKernel,
- hAacEnc->qcOut);
-
- /*-------------------------------------------- */
-
- /* for ( all sub frames ) ... */
- //fprintf(stderr, "totalBits=%d, qcOut->totalBits=%d, qcOut->totFillBits=%d\n", totalBits, qcOut->totalBits, qcOut->totFillBits);
- /* write bitstream header */
- transportEnc_WriteAccessUnit(
- hTpEnc,
- totalBits,
- FDKaacEnc_EncBitresToTpBitres(hAacEnc->bitrateMode, hAacEnc->qcKernel->bitResTot),
- cm->nChannelsEff);
-
- /* write bitstream */
- ErrorStatus = FDKaacEnc_WriteBitstream(
- hTpEnc,
- cm,
- qcOut,
- psyOut,
- hAacEnc->qcKernel,
- hAacEnc->aot,
- hAacEnc->config->syntaxFlags,
- hAacEnc->config->epConfig);
-
- if (ErrorStatus != AAC_ENC_OK)
- return ErrorStatus;
-
- /* transportEnc_EndAccessUnit() is being called inside FDKaacEnc_WriteBitstream() */
- transportEnc_GetFrame(hTpEnc, nOutBytes);
-
- } /* -end- if (curFrame==hAacEnc->qcKernel->nSubFrames) */
-
-
- /*-------------------------------------------- */
- return AAC_ENC_OK;
-}
-
-/*---------------------------------------------------------------------------
-
- functionname:FDKaacEnc_Close
- description: delete encoder instance
- returns:
-
- ---------------------------------------------------------------------------*/
-
-void FDKaacEnc_Close( HANDLE_AAC_ENC* phAacEnc) /* encoder handle */
-{
- if (*phAacEnc == NULL) {
- return;
- }
- AAC_ENC *hAacEnc = (AAC_ENC*)*phAacEnc;
-
- if (hAacEnc->dynamic_RAM != NULL)
- FreeAACdynamic_RAM(&hAacEnc->dynamic_RAM);
-
- FDKaacEnc_PsyClose(&hAacEnc->psyKernel,hAacEnc->psyOut);
-
- FDKaacEnc_QCClose(&hAacEnc->qcKernel, hAacEnc->qcOut);
-
- FreeRam_aacEnc_AacEncoder(phAacEnc);
-}
-
-
-/* The following functions are in this source file only for convenience and */
-/* need not be visible outside of a possible encoder library. */
-
-/* basic defines for ancillary data */
-#define MAX_ANCRATE 19200 /* ancillary rate >= 19200 isn't valid */
-
-/*---------------------------------------------------------------------------
-
- functionname: FDKaacEnc_InitCheckAncillary
- description: initialize and check ancillary data struct
- return: if success or NULL if error
-
- ---------------------------------------------------------------------------*/
-static AAC_ENCODER_ERROR FDKaacEnc_InitCheckAncillary(INT bitRate,
- INT framelength,
- INT ancillaryRate,
- INT *ancillaryBitsPerFrame,
- INT sampleRate)
-{
- INT diffToByteAlign;
-
- /* don't use negative ancillary rates */
- if ( ancillaryRate < -1 )
- return AAC_ENC_UNSUPPORTED_ANC_BITRATE;
-
- /* check if ancillary rate is ok */
- if ( (ancillaryRate != (-1)) && (ancillaryRate != 0) ) {
- /* ancRate <= 15% of bitrate && ancRate < 19200 */
- if ( ( ancillaryRate >= MAX_ANCRATE ) ||
- ( (ancillaryRate * 20) > (bitRate * 3) ) ) {
- return AAC_ENC_UNSUPPORTED_ANC_BITRATE;
- }
- }
- else if (ancillaryRate == -1) {
- /* if no special ancRate is requested but a ancillary file is
- stated, then generate a ancillary rate matching to the bitrate */
- if (bitRate >= (MAX_ANCRATE * 10)) {
- /* ancillary rate is 19199 */
- ancillaryRate = (MAX_ANCRATE - 1);
- }
- else { /* 10% of bitrate */
- ancillaryRate = bitRate / 10;
- }
- }
-
- /* make ancillaryBitsPerFrame byte align */
- *ancillaryBitsPerFrame = (ancillaryRate * framelength ) / sampleRate;
- diffToByteAlign = *ancillaryBitsPerFrame % 8;
- *ancillaryBitsPerFrame = *ancillaryBitsPerFrame - diffToByteAlign;
-
- return AAC_ENC_OK;
-}
diff --git a/libAACenc/src/aacenc.h b/libAACenc/src/aacenc.h
deleted file mode 100644
index ed167c2..0000000
--- a/libAACenc/src/aacenc.h
+++ /dev/null
@@ -1,323 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/************************* Fast MPEG AAC Audio Encoder **********************
-
- Initial author: M. Schug / A. Groeschel
- contents/description: fast aac coder interface library functions
-
-******************************************************************************/
-
-#ifndef _aacenc_h_
-#define _aacenc_h_
-
-#include "common_fix.h"
-#include "FDK_audio.h"
-
-#include "tpenc_lib.h"
-
-#include "sbr_encoder.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*
- * AAC-LC error codes.
- */
-typedef enum {
- AAC_ENC_OK = 0x0000, /*!< All fine. */
-
- AAC_ENC_UNKNOWN = 0x0002, /*!< Error condition is of unknown reason, or from another module. */
-
- /* initialization errors */
- aac_enc_init_error_start = 0x2000,
- AAC_ENC_INVALID_HANDLE = 0x2020, /*!< The handle passed to the function call was invalid (probably NULL). */
- AAC_ENC_INVALID_FRAME_LENGTH = 0x2080, /*!< Invalid frame length. */
- AAC_ENC_INVALID_N_CHANNELS = 0x20e0, /*!< Invalid amount of audio input channels. */
- AAC_ENC_INVALID_SFB_TABLE = 0x2140, /*!< Internal encoder error. */
-
- AAC_ENC_UNSUPPORTED_AOT = 0x3000, /*!< The Audio Object Type (AOT) is not supported. */
- AAC_ENC_UNSUPPORTED_BITRATE = 0x3020, /*!< The chosen bitrate is not supported. */
- AAC_ENC_UNSUPPORTED_BITRATE_MODE = 0x3028, /*!< Unsupported bit rate mode (CBR or VBR). */
- AAC_ENC_UNSUPPORTED_ANC_BITRATE = 0x3040, /*!< Unsupported ancillay bitrate. */
- AAC_ENC_UNSUPPORTED_ANC_MODE = 0x3060,
- AAC_ENC_UNSUPPORTED_TRANSPORT_TYPE = 0x3080, /*!< The bitstream format is not supported. */
- AAC_ENC_UNSUPPORTED_ER_FORMAT = 0x30a0, /*!< The error resilience tool format is not supported. */
- AAC_ENC_UNSUPPORTED_EPCONFIG = 0x30c0, /*!< The error protection format is not supported. */
- AAC_ENC_UNSUPPORTED_CHANNELCONFIG = 0x30e0, /*!< The channel configuration (either number or arrangement) is not supported. */
- AAC_ENC_UNSUPPORTED_SAMPLINGRATE = 0x3100, /*!< Sample rate of audio input is not supported. */
- AAC_ENC_NO_MEMORY = 0x3120, /*!< Could not allocate memory. */
- AAC_ENC_PE_INIT_TABLE_NOT_FOUND = 0x3140, /*!< Internal encoder error. */
-
- aac_enc_init_error_end,
-
- /* encode errors */
- aac_enc_error_start = 0x4000,
- AAC_ENC_QUANT_ERROR = 0x4020, /*!< Too many bits used in quantization. */
- AAC_ENC_WRITTEN_BITS_ERROR = 0x4040, /*!< Unexpected number of written bits, differs to
- calculated number of bits. */
- AAC_ENC_PNS_TABLE_ERROR = 0x4060, /*!< PNS level out of range. */
- AAC_ENC_GLOBAL_GAIN_TOO_HIGH = 0x4080, /*!< Internal quantizer error. */
- AAC_ENC_BITRES_TOO_LOW = 0x40a0, /*!< Too few bits in bit reservoir. */
- AAC_ENC_BITRES_TOO_HIGH = 0x40a1, /*!< Too many bits in bit reservoir. */
- AAC_ENC_INVALID_CHANNEL_BITRATE = 0x4100,
- AAC_ENC_INVALID_ELEMENTINFO_TYPE = 0x4120, /*!< Internal encoder error. */
-
- AAC_ENC_WRITE_SCAL_ERROR = 0x41e0, /*!< Error writing scalefacData. */
- AAC_ENC_WRITE_SEC_ERROR = 0x4200, /*!< Error writing sectionData. */
- AAC_ENC_WRITE_SPEC_ERROR = 0x4220, /*!< Error writing spectralData. */
- aac_enc_error_end
-
-} AAC_ENCODER_ERROR;
-/*-------------------------- defines --------------------------------------*/
-
-#define ANC_DATA_BUFFERSIZE 1024 /* ancBuffer size */
-
-#define MAX_TOTAL_EXT_PAYLOADS (((8) * (1)) + (2+2))
-
-
-typedef enum {
- AACENC_BR_MODE_INVALID = -1, /*!< Invalid bitrate mode. */
- AACENC_BR_MODE_CBR = 0, /*!< Constant bitrate mode. */
- AACENC_BR_MODE_VBR_1 = 1, /*!< Variable bitrate mode, about 32 kbps/channel. */
- AACENC_BR_MODE_VBR_2 = 2, /*!< Variable bitrate mode, about 40 kbps/channel. */
- AACENC_BR_MODE_VBR_3 = 3, /*!< Variable bitrate mode, about 48-56 kbps/channel. */
- AACENC_BR_MODE_VBR_4 = 4, /*!< Variable bitrate mode, about 64 kbps/channel. */
- AACENC_BR_MODE_VBR_5 = 5, /*!< Variable bitrate mode, about 80-96 kbps/channel. */
- AACENC_BR_MODE_FF = 6, /*!< Fixed frame mode. */
- AACENC_BR_MODE_SFR = 7 /*!< Superframe mode. */
-
-} AACENC_BITRATE_MODE;
-
-typedef enum {
-
- CH_ORDER_MPEG = 0, /*!< MPEG channel ordering (e. g. 5.1: C, L, R, SL, SR, LFE) */
- CH_ORDER_WAV, /*!< WAV fileformat channel ordering (e. g. 5.1: L, R, C, LFE, SL, SR) */
- CH_ORDER_WG4 /*!< WG4 fileformat channel ordering (e. g. 5.1: L, R, SL, SR, C, LFE) */
-
-} CHANNEL_ORDER;
-
-/*-------------------- structure definitions ------------------------------*/
-
-struct AACENC_CONFIG {
- INT sampleRate; /* encoder sample rate */
- INT bitRate; /* encoder bit rate in bits/sec */
- INT ancDataBitRate; /* additional bits consumed by anc data or sbr have to be consiedered while configuration */
-
- INT nSubFrames; /* number of frames in super frame (not ADTS/LATM subframes !) */
- AUDIO_OBJECT_TYPE audioObjectType; /* Audio Object Type */
-
- INT averageBits; /* encoder bit rate in bits/superframe */
- INT bitrateMode; /* encoder bitrate mode (CBR/VBR) */
- INT nChannels; /* number of channels to process */
- CHANNEL_ORDER channelOrder; /* Input Channel ordering scheme. */
- INT bandWidth; /* targeted audio bandwidth in Hz */
- CHANNEL_MODE channelMode; /* encoder channel mode configuration */
- INT framelength; /* used frame size */
-
- UINT syntaxFlags; /* bitstreams syntax configuration */
- SCHAR epConfig; /* error protection configuration */
-
- INT anc_Rate; /* ancillary rate, 0 (disabled), -1 (default) else desired rate */
- UINT maxAncBytesPerAU;
- INT minBitsPerFrame; /* minimum number of bits in AU */
- INT maxBitsPerFrame; /* maximum number of bits in AU */
- INT bitreservoir; /* size of bitreservoir */
-
- UINT sbrRatio; /* sbr sampling rate ratio: dual- or single-rate */
-
- UCHAR useTns; /* flag: use temporal noise shaping */
- UCHAR usePns; /* flag: use perceptual noise substitution */
- UCHAR useIS; /* flag: use intensity coding */
-
- UCHAR useRequant; /* flag: use afterburner */
-};
-
-typedef struct {
- UCHAR *pData; /* pointer to extension payload data */
- UINT dataSize; /* extension payload data size in bits */
- EXT_PAYLOAD_TYPE dataType; /* extension payload data type */
- INT associatedChElement; /* number of the channel element the data is assigned to */
-} AACENC_EXT_PAYLOAD;
-
-typedef struct AAC_ENC *HANDLE_AAC_ENC;
-
-/**
- * \brief Limit given bit rate to a valid value
- * \param hTpEnc transport encoder handle
- * \param coreSamplingRate the sample rate to be used for the AAC encoder
- * \param frameLength the frameLength to be used for the AAC encoder
- * \param nChannels number of total channels
- * \param nChannelsEff number of effective channels
- * \param bitRate the initial bit rate value for which the closest valid bit rate value is searched for
- * \param averageBits average bits per frame for fixed framing. Set to -1 if not available.
- * \param optional pointer where the current bits per frame are stored into.
- * \param bitrateMode the current bit rate mode
- * \param nSubFrames number of sub frames for super framing (not transport frames).
- * \return a valid bit rate value as close as possible or identical to bitRate
- */
-INT FDKaacEnc_LimitBitrate(
- HANDLE_TRANSPORTENC hTpEnc,
- INT coreSamplingRate,
- INT frameLength,
- INT nChannels,
- INT nChannelsEff,
- INT bitRate,
- INT averageBits,
- INT *pAverageBitsPerFrame,
- INT bitrateMode,
- INT nSubFrames
- );
-
- /*-----------------------------------------------------------------------------
-
- functionname: FDKaacEnc_GetVBRBitrate
- description: Get VBR bitrate from vbr quality
- input params: int vbrQuality (VBR0, VBR1, VBR2)
- channelMode
- returns: vbr bitrate
-
- ------------------------------------------------------------------------------*/
- INT FDKaacEnc_GetVBRBitrate(INT bitrateMode, CHANNEL_MODE channelMode);
-
-
-/*-----------------------------------------------------------------------------
-
- functionname: FDKaacEnc_AacInitDefaultConfig
- description: gives reasonable default configuration
- returns: ---
-
- ------------------------------------------------------------------------------*/
-void FDKaacEnc_AacInitDefaultConfig(AACENC_CONFIG *config);
-
-/*---------------------------------------------------------------------------
-
- functionname:FDKaacEnc_Open
- description: allocate and initialize a new encoder instance
- returns: 0 if success
-
- ---------------------------------------------------------------------------*/
-AAC_ENCODER_ERROR FDKaacEnc_Open(HANDLE_AAC_ENC *phAacEnc, /* pointer to an encoder handle, initialized on return */
- const INT nElements, /* number of maximal elements in instance to support */
- const INT nChannels, /* number of maximal channels in instance to support */
- const INT nSubFrames); /* support superframing in instance */
-
-
-AAC_ENCODER_ERROR FDKaacEnc_Initialize(HANDLE_AAC_ENC hAacEncoder, /* pointer to an encoder handle, initialized on return */
- AACENC_CONFIG *config, /* pre-initialized config struct */
- HANDLE_TRANSPORTENC hTpEnc,
- ULONG initFlags);
-
-
-/*---------------------------------------------------------------------------
-
- functionname: FDKaacEnc_EncodeFrame
- description: encode one frame
- returns: 0 if success
-
- ---------------------------------------------------------------------------*/
-
-AAC_ENCODER_ERROR FDKaacEnc_EncodeFrame( HANDLE_AAC_ENC hAacEnc, /* encoder handle */
- HANDLE_TRANSPORTENC hTpEnc,
- INT_PCM* inputBuffer,
- INT* numOutBytes,
- AACENC_EXT_PAYLOAD extPayload[MAX_TOTAL_EXT_PAYLOADS]
- );
-
-/*---------------------------------------------------------------------------
-
- functionname:FDKaacEnc_Close
- description: delete encoder instance
- returns:
-
- ---------------------------------------------------------------------------*/
-
-void FDKaacEnc_Close( HANDLE_AAC_ENC* phAacEnc); /* encoder handle */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _aacenc_h_ */
-
diff --git a/libAACenc/src/aacenc_hcr.cpp b/libAACenc/src/aacenc_hcr.cpp
deleted file mode 100644
index 316623a..0000000
--- a/libAACenc/src/aacenc_hcr.cpp
+++ /dev/null
@@ -1,93 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/*************************** MPEG AAC Audio Encoder *************************
-
- Initial author: R. Boehm
- contents/description: huffman codeword reordering
- based on source from aacErrRobTrans
-
-******************************************************************************/
-
-#include "aacenc_hcr.h"
-
diff --git a/libAACenc/src/aacenc_hcr.h b/libAACenc/src/aacenc_hcr.h
deleted file mode 100644
index 934247a..0000000
--- a/libAACenc/src/aacenc_hcr.h
+++ /dev/null
@@ -1,96 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/*************************** MPEG AAC Audio Encoder *************************
-
- Initial author: R. Boehm
- contents/description: huffman codeword reordering
- based on source from aacErrRobTrans
-
-******************************************************************************/
-
-#ifndef _AACENC_HCR
-#define _AACENC_HCR_H
-
-
-#endif /* ifndef _AACENC_HCR */
diff --git a/libAACenc/src/aacenc_lib.cpp b/libAACenc/src/aacenc_lib.cpp
deleted file mode 100644
index 6b77155..0000000
--- a/libAACenc/src/aacenc_lib.cpp
+++ /dev/null
@@ -1,2186 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/**************************** MPEG-4 HE-AAC Encoder *************************
-
- Initial author: M. Lohwasser
- contents/description: FDK HE-AAC Encoder interface library functions
-
-****************************************************************************/
-#include <stdio.h>
-#include "aacenc_lib.h"
-#include "FDK_audio.h"
-#include "aacenc.h"
-
-#include "aacEnc_ram.h"
-#include "FDK_core.h" /* FDK_tools versioning info */
-
-/* Encoder library info */
-#define AACENCODER_LIB_VL0 3
-#define AACENCODER_LIB_VL1 4
-#define AACENCODER_LIB_VL2 12
-#define AACENCODER_LIB_TITLE "AAC Encoder"
-#define AACENCODER_LIB_BUILD_DATE __DATE__
-#define AACENCODER_LIB_BUILD_TIME __TIME__
-
-
-#include "sbr_encoder.h"
-#include "../src/sbr_ram.h"
-#include "channel_map.h"
-
-#include "psy_const.h"
-#include "bitenc.h"
-
-#include "tpenc_lib.h"
-
-#include "metadata_main.h"
-
-#define SBL(fl) (fl/8) /*!< Short block length (hardcoded to 8 short blocks per long block) */
-#define BSLA(fl) (4*SBL(fl)+SBL(fl)/2) /*!< AAC block switching look-ahead */
-#define DELAY_AAC(fl) (fl+BSLA(fl)) /*!< MDCT + blockswitching */
-#define DELAY_AACELD(fl) ((fl)/2) /*!< ELD FB delay (no framing delay included) */
-
-#define INPUTBUFFER_SIZE (1537+100+2048)
-
-#define DEFAULT_HEADER_PERIOD_REPETITION_RATE 10 /*!< Default header repetition rate used in transport library and for SBR header. */
-
-////////////////////////////////////////////////////////////////////////////////////
-/**
- * Flags to characterize encoder modules to be supported in present instance.
- */
-enum {
- ENC_MODE_FLAG_AAC = 0x0001,
- ENC_MODE_FLAG_SBR = 0x0002,
- ENC_MODE_FLAG_PS = 0x0004,
- ENC_MODE_FLAG_SAC = 0x0008,
- ENC_MODE_FLAG_META = 0x0010
-};
-
-////////////////////////////////////////////////////////////////////////////////////
-typedef struct {
- AUDIO_OBJECT_TYPE userAOT; /*!< Audio Object Type. */
- UINT userSamplerate; /*!< Sampling frequency. */
- UINT nChannels; /*!< will be set via channelMode. */
- CHANNEL_MODE userChannelMode;
- UINT userBitrate;
- UINT userBitrateMode;
- UINT userBandwidth;
- UINT userAfterburner;
- UINT userFramelength;
- UINT userAncDataRate;
-
- UCHAR userTns; /*!< Use TNS coding. */
- UCHAR userPns; /*!< Use PNS coding. */
- UCHAR userIntensity; /*!< Use Intensity coding. */
-
- TRANSPORT_TYPE userTpType; /*!< Transport type */
- UCHAR userTpSignaling; /*!< Extension AOT signaling mode. */
- UCHAR userTpNsubFrames; /*!< Number of sub frames in a transport frame for LOAS/LATM or ADTS (default 1). */
- UCHAR userTpAmxv; /*!< AudioMuxVersion to be used for LATM (default 0). */
- UCHAR userTpProtection;
- UCHAR userTpHeaderPeriod; /*!< Parameter used to configure LATM/LOAS SMC rate. Moreover this parameters is
- used to configure repetition rate of PCE in raw_data_block. */
-
- UCHAR userErTools; /*!< Use VCB11, HCR and/or RVLC ER tool. */
- UINT userPceAdditions; /*!< Configure additional bits in PCE. */
-
- UCHAR userMetaDataMode; /*!< Meta data library configuration. */
-
- UCHAR userSbrEnabled; /*!< Enable SBR for ELD. */
- UINT userSbrRatio; /*!< SBR sampling rate ratio. Dual- or single-rate. */
-
-} USER_PARAM;
-
-////////////////////////////////////////////////////////////////////////////////////
-
-/****************************************************************************
- Structure Definitions
-****************************************************************************/
-
-typedef struct AACENC_CONFIG *HANDLE_AACENC_CONFIG;
-
-
-struct AACENCODER
-{
- USER_PARAM extParam;
- CODER_CONFIG coderConfig;
-
- /* AAC */
- AACENC_CONFIG aacConfig;
- HANDLE_AAC_ENC hAacEnc;
-
- /* SBR */
- HANDLE_SBR_ENCODER hEnvEnc;
-
- /* Meta Data */
- HANDLE_FDK_METADATA_ENCODER hMetadataEnc;
- INT metaDataAllowed; /* Signal whether chosen configuration allows metadata. Necessary for delay
- compensation. Metadata mode is a separate parameter. */
-
- /* Transport */
- HANDLE_TRANSPORTENC hTpEnc;
-
- /* Output */
- UCHAR *outBuffer; /* Internal bitstream buffer */
- INT outBufferInBytes; /* Size of internal bitstream buffer*/
-
- /* Input */
- INT_PCM *inputBuffer; /* Internal input buffer. Input source for AAC encoder */
- INT inputBufferOffset; /* Where to write new input samples. */
-
- INT nSamplesToRead; /* number of input samples neeeded for encoding one frame */
- INT nSamplesRead; /* number of input samples already in input buffer */
- INT nZerosAppended; /* appended zeros at end of file*/
- INT nDelay; /* encoder delay */
-
- AACENC_EXT_PAYLOAD extPayload [MAX_TOTAL_EXT_PAYLOADS];
- /* Extension payload */
- UCHAR extPayloadData [(1)][(8)][MAX_PAYLOAD_SIZE];
- UINT extPayloadSize [(1)][(8)]; /* payload sizes in bits */
-
- ULONG InitFlags; /* internal status to treggier re-initialization */
-
-
- /* Memory allocation info. */
- INT nMaxAacElements;
- INT nMaxAacChannels;
- INT nMaxSbrElements;
- INT nMaxSbrChannels;
- UINT nMaxSubFrames;
-
- UINT encoder_modis;
-
- /* Capability flags */
- UINT CAPF_tpEnc;
-
-} ;
-
-typedef struct
-{
- ULONG samplingRate; /*!< Encoder output sampling rate. */
- ULONG bitrateRange; /*!< Lower bitrate range for config entry. */
-
- UCHAR lowDelaySbr; /*!< 0: ELD sbr off,
- 1: ELD sbr on */
-
- UCHAR downsampledSbr; /*!< 0: ELD with dualrate sbr,
- 1: ELD with downsampled sbr */
-
-} ELD_SBR_CONFIGURATOR;
-
-/**
- * \brief This table defines ELD/SBR default configurations.
- */
-static const ELD_SBR_CONFIGURATOR eldSbrAutoConfigTab[] =
-{
- { 48000, 0, 1, 0 },
- { 48000, 64001, 0, 0 },
-
- { 44100, 0, 1, 0 },
- { 44100, 64001, 0, 0 },
-
- { 32000, 0, 1, 0 },
- { 32000, 28000, 1, 1 },
- { 32000, 56000, 0, 0 },
-
- { 24000, 0, 1, 1 },
- { 24000, 40000, 0, 0 },
-
- { 16000, 0, 1, 1 },
- { 16000, 28000, 0, 0 }
-
-};
-
-/*
- * \brief Configure SBR for ELD configuration.
- *
- * This function finds default SBR configuration for ELD based on sampling rate and channel bitrate.
- * Outputparameters are SBR on/off, and SBR ratio.
- *
- * \param samplingRate Audio signal sampling rate.
- * \param channelMode Channel configuration to be used.
- * \param totalBitrate Overall bitrate.
- * \param eldSbr Pointer to eldSbr parameter, filled on return.
- * \param eldSbrRatio Pointer to eldSbrRatio parameter, filled on return.
- *
- * \return - AACENC_OK, all fine.
- * - AACENC_INVALID_CONFIG, on failure.
- */
-static AACENC_ERROR eldSbrConfigurator(
- const ULONG samplingRate,
- const CHANNEL_MODE channelMode,
- const ULONG totalBitrate,
- UINT * const eldSbr,
- UINT * const eldSbrRatio
- )
-{
- AACENC_ERROR err = AACENC_OK;
- int i, cfgIdx = -1;
- const ULONG channelBitrate = totalBitrate / FDKaacEnc_GetChannelModeConfiguration(channelMode)->nChannelsEff;
-
- for (i=0; i<(sizeof(eldSbrAutoConfigTab)/sizeof(ELD_SBR_CONFIGURATOR)); i++) {
- if ( (samplingRate <= eldSbrAutoConfigTab[i].samplingRate)
- && (channelBitrate >= eldSbrAutoConfigTab[i].bitrateRange) )
- {
- cfgIdx = i;
- }
- }
-
- if (cfgIdx != -1) {
- *eldSbr = (eldSbrAutoConfigTab[cfgIdx].lowDelaySbr==0) ? 0 : 1;
- *eldSbrRatio = (eldSbrAutoConfigTab[cfgIdx].downsampledSbr==0) ? 2 : 1;
- }
- else {
- err = AACENC_INVALID_CONFIG; /* no default configuration for eld-sbr available. */
- }
-
- return err;
-}
-
-static inline INT isSbrActive(const HANDLE_AACENC_CONFIG hAacConfig)
-{
- INT sbrUsed = 0;
-
- if ( (hAacConfig->audioObjectType==AOT_SBR) || (hAacConfig->audioObjectType==AOT_PS)
- || (hAacConfig->audioObjectType==AOT_MP2_SBR) || (hAacConfig->audioObjectType==AOT_MP2_PS)
- || (hAacConfig->audioObjectType==AOT_DABPLUS_SBR) || (hAacConfig->audioObjectType==AOT_DABPLUS_PS)
- || (hAacConfig->audioObjectType==AOT_DRM_SBR) || (hAacConfig->audioObjectType==AOT_DRM_MPEG_PS) )
- {
- sbrUsed = 1;
- }
- if (hAacConfig->audioObjectType == AOT_ER_AAC_ELD && (hAacConfig->syntaxFlags & AC_SBR_PRESENT))
- {
- sbrUsed = 1;
- }
-
- return ( sbrUsed );
-}
-
-static inline INT isPsActive(const AUDIO_OBJECT_TYPE audioObjectType)
-{
- INT psUsed = 0;
-
- if ( (audioObjectType==AOT_PS)
- || (audioObjectType==AOT_MP2_PS)
- || (audioObjectType==AOT_DABPLUS_PS)
- || (audioObjectType==AOT_DRM_MPEG_PS) )
- {
- psUsed = 1;
- }
-
- return ( psUsed );
-}
-
-static SBR_PS_SIGNALING getSbrSignalingMode(
- const AUDIO_OBJECT_TYPE audioObjectType,
- const TRANSPORT_TYPE transportType,
- const UCHAR transportSignaling,
- const UINT sbrRatio
- )
-
-{
- SBR_PS_SIGNALING sbrSignaling;
-
- if (transportType==TT_UNKNOWN || sbrRatio==0) {
- sbrSignaling = SIG_UNKNOWN; /* Needed parameters have not been set */
- return sbrSignaling;
- } else {
- sbrSignaling = SIG_IMPLICIT; /* default: implicit signaling */
- }
-
- if ((audioObjectType==AOT_AAC_LC) || (audioObjectType==AOT_SBR) || (audioObjectType==AOT_PS) ||
- (audioObjectType==AOT_MP2_AAC_LC) || (audioObjectType==AOT_MP2_SBR) || (audioObjectType==AOT_MP2_PS) ||
- (audioObjectType==AOT_DABPLUS_SBR) || (audioObjectType==AOT_DABPLUS_PS) ) {
- switch (transportType) {
- case TT_MP4_ADIF:
- case TT_MP4_ADTS:
- sbrSignaling = SIG_IMPLICIT; /* For MPEG-2 transport types, only implicit signaling is possible */
- break;
-
- case TT_MP4_RAW:
- case TT_MP4_LATM_MCP1:
- case TT_MP4_LATM_MCP0:
- case TT_MP4_LOAS:
- default:
- if ( transportSignaling==0xFF ) {
- /* Defaults */
- if ( sbrRatio==1 ) {
- sbrSignaling = SIG_EXPLICIT_HIERARCHICAL; /* For downsampled SBR, explicit signaling is mandatory */
- } else {
- sbrSignaling = SIG_IMPLICIT; /* For dual-rate SBR, implicit signaling is default */
- }
- } else {
- /* User set parameters */
- /* Attention: Backward compatible explicit signaling does only work with AMV1 for LATM/LOAS */
- sbrSignaling = (SBR_PS_SIGNALING)transportSignaling;
- }
- break;
- }
- }
-
- return sbrSignaling;
-}
-
-/****************************************************************************
- Allocate Encoder
-****************************************************************************/
-
-H_ALLOC_MEM (_AacEncoder, AACENCODER)
-C_ALLOC_MEM (_AacEncoder, AACENCODER, 1)
-
-
-
-
-/*
- * Map Encoder specific config structures to CODER_CONFIG.
- */
-static void FDKaacEnc_MapConfig(
- CODER_CONFIG *const cc,
- const USER_PARAM *const extCfg,
- const SBR_PS_SIGNALING sbrSignaling,
- const HANDLE_AACENC_CONFIG hAacConfig
- )
-{
- AUDIO_OBJECT_TYPE transport_AOT = AOT_NULL_OBJECT;
- FDKmemclear(cc, sizeof(CODER_CONFIG));
-
- cc->flags = 0;
-
- /* Map virtual aot to transport aot. */
- switch (hAacConfig->audioObjectType) {
- case AOT_DABPLUS_AAC_LC:
- case AOT_MP2_AAC_LC:
- transport_AOT = AOT_AAC_LC;
- break;
- case AOT_DABPLUS_SBR:
- case AOT_MP2_SBR:
- transport_AOT = AOT_SBR;
- cc->flags |= CC_SBR;
- break;
- case AOT_DABPLUS_PS:
- case AOT_MP2_PS:
- transport_AOT = AOT_PS;
- cc->flags |= CC_SBR;
- break;
- default:
- transport_AOT = hAacConfig->audioObjectType;
- }
-
- if (hAacConfig->audioObjectType == AOT_ER_AAC_ELD) {
- cc->flags |= (hAacConfig->syntaxFlags & AC_SBR_PRESENT) ? CC_SBR : 0;
- }
-
- /* transport type is usually AAC-LC. */
- if ( (transport_AOT == AOT_SBR) || (transport_AOT == AOT_PS) ) {
- cc->aot = AOT_AAC_LC;
- }
- else {
- cc->aot = transport_AOT;
- }
-
- /* Configure extension aot. */
- if (sbrSignaling==SIG_IMPLICIT) {
- cc->extAOT = AOT_NULL_OBJECT; /* implicit */
- }
- else {
- if ( (sbrSignaling==SIG_EXPLICIT_BW_COMPATIBLE) && ( (transport_AOT==AOT_SBR) || (transport_AOT==AOT_PS) ) ) {
- cc->extAOT = AOT_SBR; /* explicit backward compatible */
- }
- else {
- cc->extAOT = transport_AOT; /* explicit hierarchical */
- }
- }
-
- if ( (transport_AOT==AOT_SBR) || (transport_AOT==AOT_PS) ) {
- cc->sbrPresent=1;
- if (transport_AOT==AOT_PS) {
- cc->psPresent=1;
- }
- }
- cc->sbrSignaling = sbrSignaling;
-
- cc->extSamplingRate = extCfg->userSamplerate;
- cc->bitRate = hAacConfig->bitRate;
- cc->noChannels = hAacConfig->nChannels;
- cc->flags |= CC_IS_BASELAYER;
- cc->channelMode = hAacConfig->channelMode;
-
- if(extCfg->userTpType == TT_DABPLUS && hAacConfig->nSubFrames==1) {
- switch(hAacConfig->sampleRate) {
- case 48000:
- cc->nSubFrames=6;
- break;
- case 32000:
- cc->nSubFrames=4;
- break;
- case 24000:
- cc->nSubFrames=3;
- break;
- case 16000:
- cc->nSubFrames=2;
- break;
- }
- //fprintf(stderr, "hAacConfig->nSubFrames=%d hAacConfig->sampleRate=%d\n", hAacConfig->nSubFrames, hAacConfig->sampleRate);
- } else {
- cc->nSubFrames = (hAacConfig->nSubFrames > 1 && extCfg->userTpNsubFrames == 1)
- ? hAacConfig->nSubFrames
- : extCfg->userTpNsubFrames;
- }
-
- cc->flags |= (extCfg->userTpProtection) ? CC_PROTECTION : 0;
-
- if (extCfg->userTpHeaderPeriod!=0xFF) {
- cc->headerPeriod = extCfg->userTpHeaderPeriod;
- }
- else { /* auto-mode */
- switch (extCfg->userTpType) {
- case TT_MP4_ADTS:
- case TT_MP4_LOAS:
- case TT_MP4_LATM_MCP1:
- cc->headerPeriod = DEFAULT_HEADER_PERIOD_REPETITION_RATE;
- break;
- default:
- cc->headerPeriod = 0;
- }
- }
-
- cc->samplesPerFrame = hAacConfig->framelength;
- cc->samplingRate = hAacConfig->sampleRate;
-
- /* Mpeg-4 signaling for transport library. */
- switch ( hAacConfig->audioObjectType ) {
- case AOT_MP2_AAC_LC:
- case AOT_MP2_SBR:
- case AOT_MP2_PS:
- cc->flags &= ~CC_MPEG_ID; /* Required for ADTS. */
- cc->extAOT = AOT_NULL_OBJECT;
- break;
- default:
- cc->flags |= CC_MPEG_ID;
- }
-
- /* ER-tools signaling. */
- cc->flags |= (hAacConfig->syntaxFlags & AC_ER_VCB11) ? CC_VCB11 : 0;
- cc->flags |= (hAacConfig->syntaxFlags & AC_ER_HCR) ? CC_HCR : 0;
- cc->flags |= (hAacConfig->syntaxFlags & AC_ER_RVLC) ? CC_RVLC : 0;
-
- /* Matrix mixdown coefficient configuration. */
- if ( (extCfg->userPceAdditions&0x1) && (hAacConfig->epConfig==-1)
- && ((cc->channelMode==MODE_1_2_2)||(cc->channelMode==MODE_1_2_2_1)) )
- {
- cc->matrixMixdownA = ((extCfg->userPceAdditions>>1)&0x3)+1;
- cc->flags |= (extCfg->userPceAdditions>>3)&0x1 ? CC_PSEUDO_SURROUND : 0;
- }
- else {
- cc->matrixMixdownA = 0;
- }
-}
-
-/*
- * Examine buffer descriptor regarding choosen identifier.
- *
- * \param pBufDesc Pointer to buffer descriptor
- * \param identifier Buffer identifier to look for.
-
- * \return - Buffer descriptor index.
- * -1, if there is no entry available.
- */
-static INT getBufDescIdx(
- const AACENC_BufDesc *pBufDesc,
- const AACENC_BufferIdentifier identifier
-)
-{
- INT i, idx = -1;
-
- for (i=0; i<pBufDesc->numBufs; i++) {
- if ( (AACENC_BufferIdentifier)pBufDesc->bufferIdentifiers[i] == identifier ) {
- idx = i;
- break;
- }
- }
- return idx;
-}
-
-
-/****************************************************************************
- Function Declarations
-****************************************************************************/
-
-AAC_ENCODER_ERROR aacEncDefaultConfig(HANDLE_AACENC_CONFIG hAacConfig,
- USER_PARAM *config)
-{
- /* make reasonable default settings */
- FDKaacEnc_AacInitDefaultConfig (hAacConfig);
-
- /* clear configuration structure and copy default settings */
- FDKmemclear(config, sizeof(USER_PARAM));
-
- /* copy encoder configuration settings */
- config->nChannels = hAacConfig->nChannels;
- config->userAOT = hAacConfig->audioObjectType = AOT_AAC_LC;
- config->userSamplerate = hAacConfig->sampleRate;
- config->userChannelMode = hAacConfig->channelMode;
- config->userBitrate = hAacConfig->bitRate;
- config->userBitrateMode = hAacConfig->bitrateMode;
- config->userBandwidth = hAacConfig->bandWidth;
- config->userTns = hAacConfig->useTns;
- config->userPns = hAacConfig->usePns;
- config->userIntensity = hAacConfig->useIS;
- config->userAfterburner = hAacConfig->useRequant;
- config->userFramelength = (UINT)-1;
-
- if (hAacConfig->syntaxFlags & AC_ER_VCB11) {
- config->userErTools |= 0x01;
- }
- if (hAacConfig->syntaxFlags & AC_ER_HCR) {
- config->userErTools |= 0x02;
- }
-
- /* initialize transport parameters */
- config->userTpType = TT_UNKNOWN;
- config->userTpAmxv = 0;
- config->userTpSignaling = 0xFF; /* choose signaling automatically */
- config->userTpNsubFrames = 1;
- config->userTpProtection = 0; /* not crc protected*/
- config->userTpHeaderPeriod = 0xFF; /* header period in auto mode */
- config->userPceAdditions = 0; /* no matrix mixdown coefficient */
- config->userMetaDataMode = 0; /* do not embed any meta data info */
-
- config->userAncDataRate = 0;
-
- /* SBR rate is set to 0 here, which means it should be set automatically
- in FDKaacEnc_AdjustEncSettings() if the user did not set a rate
- expilicitely. */
- config->userSbrRatio = 0;
-
- /* SBR enable set to -1 means to inquire ELD audio configurator for reasonable configuration. */
- config->userSbrEnabled = -1;
-
- return AAC_ENC_OK;
-}
-
-static
-void aacEncDistributeSbrBits(CHANNEL_MAPPING *channelMapping, SBR_ELEMENT_INFO *sbrElInfo, INT bitRate)
-{
- INT codebits = bitRate;
- int el;
-
- /* Copy Element info */
- for (el=0; el<channelMapping->nElements; el++) {
- sbrElInfo[el].ChannelIndex[0] = channelMapping->elInfo[el].ChannelIndex[0];
- sbrElInfo[el].ChannelIndex[1] = channelMapping->elInfo[el].ChannelIndex[1];
- sbrElInfo[el].elType = channelMapping->elInfo[el].elType;
- sbrElInfo[el].bitRate = (INT)(fMultNorm(channelMapping->elInfo[el].relativeBits, (FIXP_DBL)bitRate));
- sbrElInfo[el].instanceTag = channelMapping->elInfo[el].instanceTag;
- sbrElInfo[el].nChannelsInEl = channelMapping->elInfo[el].nChannelsInEl;
-
- codebits -= sbrElInfo[el].bitRate;
- }
- sbrElInfo[0].bitRate += codebits;
-}
-
-
-static
-INT aacEncoder_LimitBitrate(
- const HANDLE_TRANSPORTENC hTpEnc,
- const INT samplingRate,
- const INT frameLength,
- const INT nChannels,
- const CHANNEL_MODE channelMode,
- INT bitRate,
- const INT nSubFrames,
- const INT sbrActive,
- const INT sbrDownSampleRate,
- const AUDIO_OBJECT_TYPE aot
- )
-{
- INT coreSamplingRate;
- CHANNEL_MAPPING cm;
-
- FDKaacEnc_InitChannelMapping(channelMode, CH_ORDER_MPEG, &cm);
-
- if (sbrActive) {
- coreSamplingRate = samplingRate >> (sbrEncoder_IsSingleRatePossible(aot) ? (sbrDownSampleRate-1):1);
- } else {
- coreSamplingRate = samplingRate;
- }
-
- /* Consider bandwidth channel bit rate limit (see bandwidth.cpp: GetBandwidthEntry()) */
- if (aot == AOT_ER_AAC_LD || aot == AOT_ER_AAC_ELD) {
- bitRate = FDKmin(360000*nChannels, bitRate);
- bitRate = FDKmax(8000*nChannels, bitRate);
- }
-
- if (aot == AOT_AAC_LC || aot == AOT_SBR || aot == AOT_PS) {
- bitRate = FDKmin(576000*nChannels, bitRate);
- /*bitRate = FDKmax(0*nChannels, bitRate);*/
- }
-
-
- /* Limit bit rate in respect to the core coder */
- bitRate = FDKaacEnc_LimitBitrate(
- hTpEnc,
- coreSamplingRate,
- frameLength,
- nChannels,
- cm.nChannelsEff,
- bitRate,
- -1,
- NULL,
- -1,
- nSubFrames
- );
-
- /* Limit bit rate in respect to available SBR modes if active */
- if (sbrActive)
- {
- int numIterations = 0;
- INT initialBitrate, adjustedBitrate;
- initialBitrate = adjustedBitrate = bitRate;
-
- /* Find total bitrate which provides valid configuration for each SBR element. */
- do {
- int e;
- SBR_ELEMENT_INFO sbrElInfo[(8)];
- FDK_ASSERT(cm.nElements <= (8));
-
- initialBitrate = adjustedBitrate;
-
- /* Get bit rate for each SBR element */
- aacEncDistributeSbrBits(&cm, sbrElInfo, initialBitrate);
-
- for (e=0; e<cm.nElements; e++)
- {
- INT sbrElementBitRateIn, sbrBitRateOut;
-
- if (cm.elInfo[e].elType != ID_SCE && cm.elInfo[e].elType != ID_CPE) {
- continue;
- }
- sbrElementBitRateIn = sbrElInfo[e].bitRate;
- sbrBitRateOut = sbrEncoder_LimitBitRate(sbrElementBitRateIn , cm.elInfo[e].nChannelsInEl, coreSamplingRate, aot);
- if (sbrBitRateOut == 0) {
- return 0;
- }
-
- /* If bitrates don't match, distribution and limiting needs to be determined again.
- Abort element loop and restart with adapted bitrate. */
- if (sbrElementBitRateIn != sbrBitRateOut) {
-
- if (sbrElementBitRateIn < sbrBitRateOut) {
- adjustedBitrate = fMax(initialBitrate, (INT)fDivNorm((FIXP_DBL)(sbrBitRateOut+8), cm.elInfo[e].relativeBits));
- break;
- }
-
- if (sbrElementBitRateIn > sbrBitRateOut) {
- adjustedBitrate = fMin(initialBitrate, (INT)fDivNorm((FIXP_DBL)(sbrBitRateOut-8), cm.elInfo[e].relativeBits));
- break;
- }
-
- } /* sbrElementBitRateIn != sbrBitRateOut */
-
- } /* elements */
-
- numIterations++; /* restrict iteration to worst case of num elements */
-
- } while ( (initialBitrate!=adjustedBitrate) && (numIterations<=cm.nElements) );
-
- /* Unequal bitrates mean that no reasonable bitrate configuration found. */
- bitRate = (initialBitrate==adjustedBitrate) ? adjustedBitrate : 0;
- }
-
- FDK_ASSERT(bitRate > 0);
-
- //fprintf(stderr, "aacEncoder_LimitBitrate(): bitRate=%d\n", bitRate);
- return bitRate;
-}
-
-/*
- * \brief Consistency check of given USER_PARAM struct and
- * copy back configuration from public struct into internal
- * encoder configuration struct.
- *
- * \hAacEncoder Internal encoder config which is to be updated
- * \param config User provided config (public struct)
- * \return �returns always AAC_ENC_OK
- */
-static
-AACENC_ERROR FDKaacEnc_AdjustEncSettings(HANDLE_AACENCODER hAacEncoder,
- USER_PARAM *config)
-{
- AACENC_ERROR err = AACENC_OK;
-
- /* Get struct pointers. */
- HANDLE_AACENC_CONFIG hAacConfig = &hAacEncoder->aacConfig;
-
- hAacConfig->nChannels = config->nChannels;
-
- /* Encoder settings update. */
- hAacConfig->sampleRate = config->userSamplerate;
- hAacConfig->useTns = config->userTns;
- hAacConfig->usePns = config->userPns;
- hAacConfig->useIS = config->userIntensity;
- hAacConfig->bitRate = config->userBitrate;
- hAacConfig->channelMode = config->userChannelMode;
- hAacConfig->bitrateMode = config->userBitrateMode;
- hAacConfig->bandWidth = config->userBandwidth;
- hAacConfig->useRequant = config->userAfterburner;
-
- hAacConfig->audioObjectType = config->userAOT;
- hAacConfig->anc_Rate = config->userAncDataRate;
- hAacConfig->syntaxFlags = 0;
- hAacConfig->epConfig = -1;
-
- /* Adapt internal AOT when necessary. */
- switch ( hAacConfig->audioObjectType ) {
- case AOT_MP2_AAC_LC:
- case AOT_MP2_SBR:
- case AOT_MP2_PS:
- hAacConfig->usePns = 0;
- case AOT_AAC_LC:
- case AOT_SBR:
- case AOT_PS:
- config->userTpType = (config->userTpType!=TT_UNKNOWN) ? config->userTpType : TT_MP4_ADTS;
- hAacConfig->framelength = (config->userFramelength!=(UINT)-1) ? config->userFramelength : 1024;
- if (hAacConfig->framelength != 1024 && hAacConfig->framelength != 960) {
- return AACENC_INVALID_CONFIG;
- }
- break;
- case AOT_DABPLUS_SBR:
- case AOT_DABPLUS_PS:
- hAacConfig->syntaxFlags |= ((config->userSbrEnabled) ? AC_SBR_PRESENT : 0);
- case AOT_DABPLUS_AAC_LC:
- config->userTpType = (config->userTpType!=TT_UNKNOWN) ? config->userTpType : TT_DABPLUS;
- hAacConfig->framelength = (config->userFramelength!=(UINT)-1) ? config->userFramelength : 960;
- if (hAacConfig->framelength != 960) {
- return AACENC_INVALID_CONFIG;
- }
- config->userTpSignaling=2;
- if(config->userTpType == TT_DABPLUS)
- hAacConfig->syntaxFlags |= AC_DAB;
- break;
-#if 0
- case AOT_ER_AAC_LC:
- hAacConfig->epConfig = 0;
- hAacConfig->syntaxFlags |= AC_ER;
- hAacConfig->syntaxFlags |= ((config->userErTools & 0x1) ? AC_ER_VCB11 : 0);
- hAacConfig->syntaxFlags |= ((config->userErTools & 0x2) ? AC_ER_HCR : 0);
- config->userTpType = (config->userTpType!=TT_UNKNOWN) ? config->userTpType : TT_MP4_LOAS;
- hAacConfig->framelength = (config->userFramelength!=(UINT)-1) ? config->userFramelength : 1024;
- if (hAacConfig->framelength != 1024 && hAacConfig->framelength != 960) {
- return AACENC_INVALID_CONFIG;
- }
- break;
-#endif
- case AOT_ER_AAC_LD:
- hAacConfig->epConfig = 0;
- hAacConfig->syntaxFlags |= AC_ER|AC_LD;
- hAacConfig->syntaxFlags |= ((config->userErTools & 0x1) ? AC_ER_VCB11 : 0);
- hAacConfig->syntaxFlags |= ((config->userErTools & 0x2) ? AC_ER_HCR : 0);
- hAacConfig->syntaxFlags |= ((config->userErTools & 0x4) ? AC_ER_RVLC : 0);
- config->userTpType = (config->userTpType!=TT_UNKNOWN) ? config->userTpType : TT_MP4_LOAS;
- hAacConfig->framelength = (config->userFramelength!=(UINT)-1) ? config->userFramelength : 512;
- if (hAacConfig->framelength != 512 && hAacConfig->framelength != 480) {
- return AACENC_INVALID_CONFIG;
- }
- break;
- case AOT_ER_AAC_ELD:
- hAacConfig->epConfig = 0;
- hAacConfig->syntaxFlags |= AC_ER|AC_ELD;
- hAacConfig->syntaxFlags |= ((config->userErTools & 0x1) ? AC_ER_VCB11 : 0);
- hAacConfig->syntaxFlags |= ((config->userErTools & 0x2) ? AC_ER_HCR : 0);
- hAacConfig->syntaxFlags |= ((config->userErTools & 0x4) ? AC_ER_RVLC : 0);
- hAacConfig->syntaxFlags |= ((config->userSbrEnabled==1) ? AC_SBR_PRESENT : 0);
- config->userTpType = (config->userTpType!=TT_UNKNOWN) ? config->userTpType : TT_MP4_LOAS;
- hAacConfig->framelength = (config->userFramelength!=(UINT)-1) ? config->userFramelength : 512;
- if (hAacConfig->framelength != 512 && hAacConfig->framelength != 480) {
- return AACENC_INVALID_CONFIG;
- }
- break;
- default:
- break;
- }
-
-
- switch ( hAacConfig->audioObjectType ) {
- case AOT_ER_AAC_LD:
- case AOT_ER_AAC_ELD:
- if (config->userBitrateMode==8) {
- hAacConfig->bitrateMode = 0;
- }
- if (config->userBitrateMode==0) {
- hAacConfig->bitreservoir = 100*config->nChannels; /* default, reduced bitreservoir */
- }
- if (hAacConfig->bitrateMode!=0) {
- return AACENC_INVALID_CONFIG;
- }
- break;
- default:
- break;
- }
-
- hAacConfig->bitRate = config->userBitrate;
-
- /* get bitrate in VBR configuration */
- if ( (hAacConfig->bitrateMode>=1) && (hAacConfig->bitrateMode<=5) ) {
- /* In VBR mode; SBR-modul depends on bitrate, core encoder on bitrateMode. */
- hAacConfig->bitRate = FDKaacEnc_GetVBRBitrate(hAacConfig->bitrateMode, hAacConfig->channelMode);
- }
-
-
-
- /* Set default bitrate if no external bitrate declared. */
- if ( (hAacConfig->bitrateMode==0) && (config->userBitrate==(UINT)-1) ) {
- INT bitrate = FDKaacEnc_GetChannelModeConfiguration(hAacConfig->channelMode)->nChannelsEff * hAacConfig->sampleRate;
-
- if ( isPsActive(hAacConfig->audioObjectType) ) {
- hAacConfig->bitRate = (bitrate>>1); /* 0.5 bit per sample */
- }
- else if ( isSbrActive(hAacConfig) )
- {
- if ( (config->userSbrRatio==2) || ((config->userSbrRatio==0)&&(hAacConfig->audioObjectType!=AOT_ER_AAC_ELD)) ) {
- hAacConfig->bitRate = (bitrate + (bitrate>>2))>>1; /* 0.625 bits per sample */
- }
- if ( (config->userSbrRatio==1) || ((config->userSbrRatio==0)&&(hAacConfig->audioObjectType==AOT_ER_AAC_ELD)) ) {
- hAacConfig->bitRate = (bitrate + (bitrate>>3)); /* 1.125 bits per sample */
- }
- } else
- {
- hAacConfig->bitRate = bitrate + (bitrate>>1); /* 1.5 bits per sample */
- }
- }
-
- /* Initialize SBR parameters */
- if ( (hAacConfig->audioObjectType==AOT_ER_AAC_ELD)
- && (config->userSbrEnabled == (UCHAR)-1) && (config->userSbrRatio==0) )
- {
- UINT eldSbr = 0;
- UINT eldSbrRatio = 0;
-
- if ( AACENC_OK!=(err=eldSbrConfigurator(
- hAacConfig->sampleRate,
- hAacConfig->channelMode,
- hAacConfig->bitRate,
- &eldSbr,
- &eldSbrRatio)) )
- {
- return err;
- }
-
- hAacConfig->syntaxFlags |= ((eldSbr) ? AC_SBR_PRESENT : 0);
- hAacConfig->sbrRatio = eldSbrRatio;
- }
- else
- if ( (config->userSbrRatio==0) && (isSbrActive(hAacConfig)) ) {
- /* Automatic SBR ratio configuration
- * - downsampled SBR for ELD
- * - otherwise always dualrate SBR
- */
- hAacConfig->sbrRatio = (hAacConfig->audioObjectType==AOT_ER_AAC_ELD) ? 1 : 2;
- }
- else {
- /* SBR ratio has been set by the user, so use it. */
- hAacConfig->sbrRatio = config->userSbrRatio;
- }
-
- {
- UCHAR tpSignaling=getSbrSignalingMode(hAacConfig->audioObjectType, config->userTpType, config->userTpSignaling, hAacConfig->sbrRatio);
-
- if ( (hAacConfig->audioObjectType==AOT_AAC_LC || hAacConfig->audioObjectType==AOT_SBR || hAacConfig->audioObjectType==AOT_PS) &&
- (config->userTpType==TT_MP4_LATM_MCP1 || config->userTpType==TT_MP4_LATM_MCP0 || config->userTpType==TT_MP4_LOAS) &&
- (tpSignaling==1) && (config->userTpAmxv==0) ) {
- /* For backward compatible explicit signaling, AMV1 has to be active */
- return AACENC_INVALID_CONFIG;
- }
-
- if ( (hAacConfig->audioObjectType==AOT_AAC_LC || hAacConfig->audioObjectType==AOT_SBR || hAacConfig->audioObjectType==AOT_PS) &&
- (tpSignaling==0) && (hAacConfig->sbrRatio==1)) {
- /* Downsampled SBR has to be signaled explicitely (for transmission of SBR sampling fequency) */
- return AACENC_INVALID_CONFIG;
- }
- }
-
-
-
- //fprintf(stderr, "config->userBitrate=%d\n", config->userBitrate);
- /* We need the frame length to call aacEncoder_LimitBitrate() */
- hAacConfig->bitRate = aacEncoder_LimitBitrate(
- NULL,
- hAacConfig->sampleRate,
- hAacConfig->framelength,
- hAacConfig->nChannels,
- hAacConfig->channelMode,
- hAacConfig->bitRate,
- hAacConfig->nSubFrames,
- isSbrActive(hAacConfig),
- hAacConfig->sbrRatio,
- hAacConfig->audioObjectType
- );
- //fprintf(stderr, "hAacConfig->bitRate=%d\n", hAacConfig->bitRate);
-
- /* Configure PNS */
- if ( ((hAacConfig->bitrateMode>=1) && (hAacConfig->bitrateMode<=5)) /* VBR without PNS. */
- || (hAacConfig->useTns == 0) ) /* TNS required. */
- {
- hAacConfig->usePns = 0;
- }
-
- if (hAacConfig->epConfig >= 0) {
- hAacConfig->syntaxFlags |= AC_ER;
- if (((INT)hAacConfig->channelMode < 1) || ((INT)hAacConfig->channelMode > 7)) {
- return AACENC_INVALID_CONFIG; /* Cannel config 0 not supported. */
- }
- }
-
- if ( FDKaacEnc_DetermineEncoderMode(&hAacConfig->channelMode, hAacConfig->nChannels) != AAC_ENC_OK) {
- return AACENC_INVALID_CONFIG; /* nChannels doesn't match chMode, this is just a check-up */
- }
-
- if ( (hAacConfig->nChannels > hAacEncoder->nMaxAacChannels)
- || ( (FDKaacEnc_GetChannelModeConfiguration(hAacConfig->channelMode)->nChannelsEff > hAacEncoder->nMaxSbrChannels) &&
- isSbrActive(hAacConfig) )
- )
- {
- return AACENC_INVALID_CONFIG; /* not enough channels allocated */
- }
-
- /* Meta data restriction. */
- switch (hAacConfig->audioObjectType)
- {
- /* Allow metadata support */
- case AOT_AAC_LC:
- case AOT_SBR:
- case AOT_PS:
- hAacEncoder->metaDataAllowed = 1;
- if (((INT)hAacConfig->channelMode < 1) || ((INT)hAacConfig->channelMode > 7)) {
- config->userMetaDataMode = 0;
- }
- break;
- /* Prohibit metadata support */
- default:
- hAacEncoder->metaDataAllowed = 0;
- }
-
- //fprintf(stderr, "hAacEncoder->metaDataAllowed=%d\n", hAacEncoder->metaDataAllowed);
- return err;
-}
-
-static
-INT aacenc_SbrCallback(
- void * self,
- HANDLE_FDK_BITSTREAM hBs,
- const INT sampleRateIn,
- const INT sampleRateOut,
- const INT samplesPerFrame,
- const AUDIO_OBJECT_TYPE coreCodec,
- const MP4_ELEMENT_ID elementID,
- const INT elementIndex
- )
-{
- HANDLE_AACENCODER hAacEncoder = (HANDLE_AACENCODER)self;
-
- sbrEncoder_GetHeader(hAacEncoder->hEnvEnc, hBs, elementIndex, 0);
-
- return 0;
-}
-
-static AACENC_ERROR aacEncInit(HANDLE_AACENCODER hAacEncoder,
- ULONG InitFlags,
- USER_PARAM *config)
-{
- AACENC_ERROR err = AACENC_OK;
-
- INT aacBufferOffset = 0;
- HANDLE_SBR_ENCODER *hSbrEncoder = &hAacEncoder->hEnvEnc;
- HANDLE_AACENC_CONFIG hAacConfig = &hAacEncoder->aacConfig;
-
- hAacEncoder->nZerosAppended = 0; /* count appended zeros */
-
- INT frameLength = hAacConfig->framelength;
-
- if ( (InitFlags & AACENC_INIT_CONFIG) )
- {
- CHANNEL_MODE prevChMode = hAacConfig->channelMode;
-
- /* Verify settings and update: config -> heAacEncoder */
- if ( (err=FDKaacEnc_AdjustEncSettings(hAacEncoder, config)) != AACENC_OK ) {
- return err;
- }
- frameLength = hAacConfig->framelength; /* adapt temporal framelength */
-
- /* Seamless channel reconfiguration in sbr not fully implemented */
- if ( (prevChMode!=hAacConfig->channelMode) && isSbrActive(hAacConfig) ) {
- InitFlags |= AACENC_INIT_STATES;
- }
- }
-
- /* Clear input buffer */
- if ( (InitFlags == AACENC_INIT_ALL) ) {
- FDKmemclear(hAacEncoder->inputBuffer, sizeof(INT_PCM)*hAacEncoder->nMaxAacChannels*INPUTBUFFER_SIZE);
- }
-
- if ( (InitFlags & AACENC_INIT_CONFIG) )
- {
- aacBufferOffset = 0;
- if (hAacConfig->audioObjectType == AOT_ER_AAC_ELD) {
- hAacEncoder->nDelay = DELAY_AACELD(hAacConfig->framelength);
- } else
- {
- hAacEncoder->nDelay = DELAY_AAC(hAacConfig->framelength); /* AAC encoder delay */
- }
- hAacConfig->ancDataBitRate = 0;
- }
-
- if ( isSbrActive(hAacConfig) &&
- ((InitFlags & AACENC_INIT_CONFIG) || (InitFlags & AACENC_INIT_STATES)) )
- {
- INT sbrError;
- SBR_ELEMENT_INFO sbrElInfo[(8)];
- CHANNEL_MAPPING channelMapping;
-
- if ( FDKaacEnc_InitChannelMapping(hAacConfig->channelMode,
- hAacConfig->channelOrder,
- &channelMapping) != AAC_ENC_OK )
- {
- return AACENC_INIT_ERROR;
- }
-
- /* Check return value and if the SBR encoder can handle enough elements */
- if (channelMapping.nElements > (8)) {
- return AACENC_INIT_ERROR;
- }
-
- aacEncDistributeSbrBits(&channelMapping, sbrElInfo, hAacConfig->bitRate);
-
- UINT initFlag = 0;
- initFlag += (InitFlags & AACENC_INIT_STATES) ? 1 : 0;
-
- /* Let the SBR encoder take a look at the configuration and change if required. */
- sbrError = sbrEncoder_Init(
- *hSbrEncoder,
- sbrElInfo,
- channelMapping.nElements,
- hAacEncoder->inputBuffer,
- &hAacConfig->bandWidth,
- &aacBufferOffset,
- &hAacConfig->nChannels,
- &hAacConfig->sampleRate,
- &hAacConfig->sbrRatio,
- &frameLength,
- hAacConfig->audioObjectType,
- &hAacEncoder->nDelay,
- (hAacConfig->audioObjectType == AOT_ER_AAC_ELD) ? 1 : TRANS_FAC,
- (config->userTpHeaderPeriod!=0xFF) ? config->userTpHeaderPeriod : DEFAULT_HEADER_PERIOD_REPETITION_RATE,
- initFlag
- );
-
- /* Suppress AOT reconfiguration and check error status. */
- if (sbrError) {
- return AACENC_INIT_SBR_ERROR;
- }
-
- if (hAacConfig->nChannels == 1) {
- hAacConfig->channelMode = MODE_1;
- }
-
- /* Never use PNS if SBR is active */
- if ( hAacConfig->usePns ) {
- hAacConfig->usePns = 0;
- }
-
- /* estimated bitrate consumed by SBR or PS */
- hAacConfig->ancDataBitRate = sbrEncoder_GetEstimateBitrate(*hSbrEncoder) ;
-
- } /* sbr initialization */
-
-
- /*
- * Initialize Transport - Module.
- */
- if ( (InitFlags & AACENC_INIT_TRANSPORT) )
- {
- UINT flags = 0;
-
- FDKaacEnc_MapConfig(
- &hAacEncoder->coderConfig,
- config,
- getSbrSignalingMode(hAacConfig->audioObjectType, config->userTpType, config->userTpSignaling, hAacConfig->sbrRatio),
- hAacConfig);
-
- /* create flags for transport encoder */
- if (config->userTpAmxv == 1) {
- flags |= TP_FLAG_LATM_AMV;
- }
- /* Clear output buffer */
- FDKmemclear(hAacEncoder->outBuffer, hAacEncoder->outBufferInBytes*sizeof(UCHAR));
-
- /* Initialize Bitstream encoder */
- if ( transportEnc_Init(hAacEncoder->hTpEnc, hAacEncoder->outBuffer, hAacEncoder->outBufferInBytes, config->userTpType, &hAacEncoder->coderConfig, flags) != 0) {
- return AACENC_INIT_TP_ERROR;
- }
-
- } /* transport initialization */
-
- /*
- * Initialize AAC - Core.
- */
- if ( (InitFlags & AACENC_INIT_CONFIG) ||
- (InitFlags & AACENC_INIT_STATES) )
- {
- AAC_ENCODER_ERROR err;
- err = FDKaacEnc_Initialize(hAacEncoder->hAacEnc,
- hAacConfig,
- hAacEncoder->hTpEnc,
- (InitFlags & AACENC_INIT_STATES) ? 1 : 0);
-
- if (err != AAC_ENC_OK) {
- return AACENC_INIT_AAC_ERROR;
- }
-
- } /* aac initialization */
-
- /*
- * Initialize Meta Data - Encoder.
- */
- if ( hAacEncoder->hMetadataEnc && (hAacEncoder->metaDataAllowed!=0) &&
- ((InitFlags & AACENC_INIT_CONFIG) ||(InitFlags & AACENC_INIT_STATES)) )
- {
- INT inputDataDelay = DELAY_AAC(hAacConfig->framelength);
-
- if ( isSbrActive(hAacConfig) && hSbrEncoder!=NULL) {
- inputDataDelay = hAacConfig->sbrRatio*inputDataDelay + sbrEncoder_GetInputDataDelay(*hSbrEncoder);
- }
-
- if ( FDK_MetadataEnc_Init(hAacEncoder->hMetadataEnc,
- ((InitFlags&AACENC_INIT_STATES) ? 1 : 0),
- config->userMetaDataMode,
- inputDataDelay,
- frameLength,
- config->userSamplerate,
- config->nChannels,
- config->userChannelMode,
- hAacConfig->channelOrder) != 0)
- {
- return AACENC_INIT_META_ERROR;
- }
-
- hAacEncoder->nDelay += FDK_MetadataEnc_GetDelay(hAacEncoder->hMetadataEnc);
- }
-
- /*
- * Update pointer to working buffer.
- */
- if ( (InitFlags & AACENC_INIT_CONFIG) )
- {
- hAacEncoder->inputBufferOffset = aacBufferOffset;
-
- hAacEncoder->nSamplesToRead = frameLength * config->nChannels;
-
- /* Make nDelay comparison compatible with config->nSamplesRead */
- hAacEncoder->nDelay *= config->nChannels;
-
- } /* parameter changed */
-
- return AACENC_OK;
-}
-
-
-AACENC_ERROR aacEncOpen(
- HANDLE_AACENCODER *phAacEncoder,
- const UINT encModules,
- const UINT maxChannels
- )
-{
- AACENC_ERROR err = AACENC_OK;
- HANDLE_AACENCODER hAacEncoder = NULL;
-
- if (phAacEncoder == NULL) {
- err = AACENC_INVALID_HANDLE;
- goto bail;
- }
-
- /* allocate memory */
- hAacEncoder = Get_AacEncoder();
-
- if (hAacEncoder == NULL) {
- err = AACENC_MEMORY_ERROR;
- goto bail;
- }
-
- FDKmemclear(hAacEncoder, sizeof(AACENCODER));
-
- /* Specify encoder modules to be allocated. */
- if (encModules==0) {
- hAacEncoder->encoder_modis = ENC_MODE_FLAG_AAC;
- hAacEncoder->encoder_modis |= ENC_MODE_FLAG_SBR;
- hAacEncoder->encoder_modis |= ENC_MODE_FLAG_PS;
- hAacEncoder->encoder_modis |= ENC_MODE_FLAG_META;
- }
- else {
- /* consider SAC and PS module */
- hAacEncoder->encoder_modis = encModules;
- }
-
- /* Determine max channel configuration. */
- if (maxChannels==0) {
- hAacEncoder->nMaxAacChannels = (8);
- hAacEncoder->nMaxSbrChannels = (8);
- }
- else {
- hAacEncoder->nMaxAacChannels = (maxChannels&0x00FF);
- if ( (hAacEncoder->encoder_modis&ENC_MODE_FLAG_SBR) ) {
- hAacEncoder->nMaxSbrChannels = (maxChannels&0xFF00) ? (maxChannels>>8) : hAacEncoder->nMaxAacChannels;
- }
-
- if ( (hAacEncoder->nMaxAacChannels>(8)) || (hAacEncoder->nMaxSbrChannels>(8)) ) {
- err = AACENC_INVALID_CONFIG;
- goto bail;
- }
- } /* maxChannels==0 */
-
- /* Max number of elements could be tuned any more. */
- hAacEncoder->nMaxAacElements = fixMin((8), hAacEncoder->nMaxAacChannels);
- hAacEncoder->nMaxSbrElements = fixMin((8), hAacEncoder->nMaxSbrChannels);
- hAacEncoder->nMaxSubFrames = (1);
-
-
- /* In case of memory overlay, allocate memory out of libraries */
-
- hAacEncoder->inputBuffer = (INT_PCM*)FDKcalloc(hAacEncoder->nMaxAacChannels*INPUTBUFFER_SIZE, sizeof(INT_PCM));
-
- /* Open SBR Encoder */
- if (hAacEncoder->encoder_modis&ENC_MODE_FLAG_SBR) {
- if ( sbrEncoder_Open(&hAacEncoder->hEnvEnc,
- hAacEncoder->nMaxSbrElements,
- hAacEncoder->nMaxSbrChannels,
- (hAacEncoder->encoder_modis&ENC_MODE_FLAG_PS) ? 1 : 0 ) )
- {
- err = AACENC_MEMORY_ERROR;
- goto bail;
- }
- } /* (encoder_modis&ENC_MODE_FLAG_SBR) */
-
-
- /* Open Aac Encoder */
- if ( FDKaacEnc_Open(&hAacEncoder->hAacEnc,
- hAacEncoder->nMaxAacElements,
- hAacEncoder->nMaxAacChannels,
- (1)) != AAC_ENC_OK )
- {
- err = AACENC_MEMORY_ERROR;
- goto bail;
- }
-
- { /* Get bitstream outputbuffer size */
- UINT ld_M;
- for (ld_M=1; (UINT)(1<<ld_M) < (hAacEncoder->nMaxSubFrames*hAacEncoder->nMaxAacChannels*6144)>>3; ld_M++) ;
- hAacEncoder->outBufferInBytes = (1<<ld_M); /* buffer has to be 2^n */
- }
- hAacEncoder->outBuffer = GetRam_bsOutbuffer();
- if (OUTPUTBUFFER_SIZE < hAacEncoder->outBufferInBytes ) {
- err = AACENC_MEMORY_ERROR;
- goto bail;
- }
-
- /* Open Meta Data Encoder */
- if (hAacEncoder->encoder_modis&ENC_MODE_FLAG_META) {
- if ( FDK_MetadataEnc_Open(&hAacEncoder->hMetadataEnc) )
- {
- err = AACENC_MEMORY_ERROR;
- goto bail;
- }
- } /* (encoder_modis&ENC_MODE_FLAG_META) */
-
- /* Open Transport Encoder */
- if ( transportEnc_Open(&hAacEncoder->hTpEnc) != 0 )
- {
- err = AACENC_MEMORY_ERROR;
- goto bail;
- }
- else {
- C_ALLOC_SCRATCH_START(pLibInfo, LIB_INFO, FDK_MODULE_LAST);
-
- FDKinitLibInfo( pLibInfo);
- transportEnc_GetLibInfo( pLibInfo );
-
- /* Get capabilty flag for transport encoder. */
- hAacEncoder->CAPF_tpEnc = FDKlibInfo_getCapabilities( pLibInfo, FDK_TPENC);
-
- C_ALLOC_SCRATCH_END(pLibInfo, LIB_INFO, FDK_MODULE_LAST);
- }
- if ( transportEnc_RegisterSbrCallback(hAacEncoder->hTpEnc, aacenc_SbrCallback, hAacEncoder) != 0 ) {
- err = AACENC_INIT_TP_ERROR;
- goto bail;
- }
-
- /* Initialize encoder instance with default parameters. */
- aacEncDefaultConfig(&hAacEncoder->aacConfig, &hAacEncoder->extParam);
-
- /* Initialize headerPeriod in coderConfig for aacEncoder_GetParam(). */
- hAacEncoder->coderConfig.headerPeriod = hAacEncoder->extParam.userTpHeaderPeriod;
-
- /* All encoder modules have to be initialized */
- hAacEncoder->InitFlags = AACENC_INIT_ALL;
-
- /* Return encoder instance */
- *phAacEncoder = hAacEncoder;
-
- return err;
-
-bail:
- aacEncClose(&hAacEncoder);
-
- return err;
-}
-
-
-
-AACENC_ERROR aacEncClose(HANDLE_AACENCODER *phAacEncoder)
-{
- AACENC_ERROR err = AACENC_OK;
-
- if (phAacEncoder == NULL) {
- err = AACENC_INVALID_HANDLE;
- goto bail;
- }
-
- if (*phAacEncoder != NULL) {
- HANDLE_AACENCODER hAacEncoder = *phAacEncoder;
-
-
- if (hAacEncoder->inputBuffer!=NULL) {
- FDKfree(hAacEncoder->inputBuffer);
- hAacEncoder->inputBuffer = NULL;
- }
-
- if (hAacEncoder->outBuffer) {
- FreeRam_bsOutbuffer(&hAacEncoder->outBuffer);
- }
-
- if (hAacEncoder->hEnvEnc) {
- sbrEncoder_Close (&hAacEncoder->hEnvEnc);
- }
- if (hAacEncoder->hAacEnc) {
- FDKaacEnc_Close (&hAacEncoder->hAacEnc);
- }
-
- transportEnc_Close(&hAacEncoder->hTpEnc);
-
- if (hAacEncoder->hMetadataEnc) {
- FDK_MetadataEnc_Close (&hAacEncoder->hMetadataEnc);
- }
-
- Free_AacEncoder(phAacEncoder);
- }
-
-bail:
- return err;
-}
-
-AACENC_ERROR aacEncEncode(
- const HANDLE_AACENCODER hAacEncoder,
- const AACENC_BufDesc *inBufDesc,
- const AACENC_BufDesc *outBufDesc,
- const AACENC_InArgs *inargs,
- AACENC_OutArgs *outargs
- )
-{
- AACENC_ERROR err = AACENC_OK;
- INT i, nBsBytes = 0;
- INT outBytes[(1)];
- int nExtensions = 0;
- int ancDataExtIdx = -1;
-
- /* deal with valid encoder handle */
- if (hAacEncoder==NULL) {
- err = AACENC_INVALID_HANDLE;
- goto bail;
- }
-
-
- /*
- * Adjust user settings and trigger reinitialization.
- */
- if (hAacEncoder->InitFlags!=0) {
-
- err = aacEncInit(hAacEncoder,
- hAacEncoder->InitFlags,
- &hAacEncoder->extParam);
-
- if (err!=AACENC_OK) {
- /* keep init flags alive! */
- goto bail;
- }
- hAacEncoder->InitFlags = AACENC_INIT_NONE;
- }
-
- if (outargs!=NULL) {
- FDKmemclear(outargs, sizeof(AACENC_OutArgs));
- }
-
- if (outBufDesc!=NULL) {
- for (i=0; i<outBufDesc->numBufs; i++) {
- if (outBufDesc->bufs[i]!=NULL) {
- FDKmemclear(outBufDesc->bufs[i], outBufDesc->bufSizes[i]);
- }
- }
- }
-
- /*
- * If only encoder handle given, independent (re)initialization can be triggered.
- */
- if ( (hAacEncoder!=NULL) & (inBufDesc==NULL) && (outBufDesc==NULL) && (inargs==NULL) && (outargs==NULL) ) {
- goto bail;
- }
-
- /* reset buffer wich signals number of valid bytes in output bitstream buffer */
- FDKmemclear(outBytes, hAacEncoder->aacConfig.nSubFrames*sizeof(INT));
-
- /*
- * Manage incoming audio samples.
- */
- if ( (inargs->numInSamples > 0) && (getBufDescIdx(inBufDesc,IN_AUDIO_DATA) != -1) )
- {
- /* Fetch data until nSamplesToRead reached */
- INT idx = getBufDescIdx(inBufDesc,IN_AUDIO_DATA);
- INT newSamples = fixMax(0,fixMin(inargs->numInSamples, hAacEncoder->nSamplesToRead-hAacEncoder->nSamplesRead));
- INT_PCM *pIn = hAacEncoder->inputBuffer+hAacEncoder->inputBufferOffset+hAacEncoder->nSamplesRead;
-
- /* Copy new input samples to internal buffer */
- if (inBufDesc->bufElSizes[idx]==(INT)sizeof(INT_PCM)) {
- FDKmemcpy(pIn, (INT_PCM*)inBufDesc->bufs[idx], newSamples*sizeof(INT_PCM)); /* Fast copy. */
- }
- else if (inBufDesc->bufElSizes[idx]>(INT)sizeof(INT_PCM)) {
- for (i=0; i<newSamples; i++) {
- pIn[i] = (INT_PCM)(((LONG*)inBufDesc->bufs[idx])[i]>>16); /* Convert 32 to 16 bit. */
- }
- }
- else {
- for (i=0; i<newSamples; i++) {
- pIn[i] = ((INT_PCM)(((SHORT*)inBufDesc->bufs[idx])[i]))<<16; /* Convert 16 to 32 bit. */
- }
- }
- hAacEncoder->nSamplesRead += newSamples;
-
- /* Number of fetched input buffer samples. */
- outargs->numInSamples = newSamples;
- }
-
- /* input buffer completely filled ? */
- if (hAacEncoder->nSamplesRead < hAacEncoder->nSamplesToRead)
- {
- /* - eof reached and flushing enabled, or
- - return to main and wait for further incoming audio samples */
- if (inargs->numInSamples==-1)
- {
- if ( (hAacEncoder->nZerosAppended < hAacEncoder->nDelay)
- )
- {
- int nZeros = hAacEncoder->nSamplesToRead - hAacEncoder->nSamplesRead;
-
- FDK_ASSERT(nZeros >= 0);
-
- /* clear out until end-of-buffer */
- if (nZeros) {
- FDKmemclear(hAacEncoder->inputBuffer+hAacEncoder->inputBufferOffset+hAacEncoder->nSamplesRead, sizeof(INT_PCM)*nZeros );
- hAacEncoder->nZerosAppended += nZeros;
- hAacEncoder->nSamplesRead = hAacEncoder->nSamplesToRead;
- }
- }
- else { /* flushing completed */
- err = AACENC_ENCODE_EOF; /* eof reached */
- goto bail;
- }
- }
- else { /* inargs->numInSamples!= -1 */
- goto bail; /* not enough samples in input buffer and no flushing enabled */
- }
- }
-
- /* init payload */
- FDKmemclear(hAacEncoder->extPayload, sizeof(AACENC_EXT_PAYLOAD) * MAX_TOTAL_EXT_PAYLOADS);
- for (i = 0; i < MAX_TOTAL_EXT_PAYLOADS; i++) {
- hAacEncoder->extPayload[i].associatedChElement = -1;
- }
- FDKmemclear(hAacEncoder->extPayloadData, sizeof(hAacEncoder->extPayloadData));
- FDKmemclear(hAacEncoder->extPayloadSize, sizeof(hAacEncoder->extPayloadSize));
-
-
- /*
- * Calculate Meta Data info.
- */
- if ( (hAacEncoder->hMetadataEnc!=NULL) && (hAacEncoder->metaDataAllowed!=0) ) {
-
- const AACENC_MetaData *pMetaData = NULL;
- AACENC_EXT_PAYLOAD *pMetaDataExtPayload = NULL;
- UINT nMetaDataExtensions = 0;
- INT matrix_mixdown_idx = 0;
-
- /* New meta data info available ? */
- if ( getBufDescIdx(inBufDesc,IN_METADATA_SETUP) != -1 ) {
- pMetaData = (AACENC_MetaData*)inBufDesc->bufs[getBufDescIdx(inBufDesc,IN_METADATA_SETUP)];
- }
-
- FDK_MetadataEnc_Process(hAacEncoder->hMetadataEnc,
- hAacEncoder->inputBuffer+hAacEncoder->inputBufferOffset,
- hAacEncoder->nSamplesRead,
- pMetaData,
- &pMetaDataExtPayload,
- &nMetaDataExtensions,
- &matrix_mixdown_idx
- );
-
- for (i=0; i<(INT)nMetaDataExtensions; i++) { /* Get meta data extension payload. */
- hAacEncoder->extPayload[nExtensions++] = pMetaDataExtPayload[i];
- }
-
- if ( (matrix_mixdown_idx!=-1)
- && ((hAacEncoder->extParam.userChannelMode==MODE_1_2_2)||(hAacEncoder->extParam.userChannelMode==MODE_1_2_2_1)) )
- {
- /* Set matrix mixdown coefficient. */
- UINT pceValue = (UINT)( (1<<3) | ((matrix_mixdown_idx&0x3)<<1) | 1 );
- if (hAacEncoder->extParam.userPceAdditions != pceValue) {
- hAacEncoder->extParam.userPceAdditions = pceValue;
- hAacEncoder->InitFlags |= AACENC_INIT_TRANSPORT;
- }
- }
- }
-
-
- if ( isSbrActive(&hAacEncoder->aacConfig) ) {
-
- INT nPayload = 0;
-
- /*
- * Encode SBR data.
- */
- if (sbrEncoder_EncodeFrame(hAacEncoder->hEnvEnc,
- hAacEncoder->inputBuffer,
- hAacEncoder->extParam.nChannels,
- hAacEncoder->extPayloadSize[nPayload],
- hAacEncoder->extPayloadData[nPayload]
-#if defined(EVAL_PACKAGE_SILENCE) || defined(EVAL_PACKAGE_SBR_SILENCE)
- ,hAacEncoder->hAacEnc->clearOutput
-#endif
- ))
- {
- err = AACENC_ENCODE_ERROR;
- goto bail;
- }
- else {
- /* Add SBR extension payload */
- for (i = 0; i < (8); i++) {
- if (hAacEncoder->extPayloadSize[nPayload][i] > 0) {
- hAacEncoder->extPayload[nExtensions].pData = hAacEncoder->extPayloadData[nPayload][i];
- {
- hAacEncoder->extPayload[nExtensions].dataSize = hAacEncoder->extPayloadSize[nPayload][i];
- hAacEncoder->extPayload[nExtensions].associatedChElement = i;
- }
- hAacEncoder->extPayload[nExtensions].dataType = EXT_SBR_DATA; /* Once SBR Encoder supports SBR CRC set EXT_SBR_DATA_CRC */
- nExtensions++; /* or EXT_SBR_DATA according to configuration. */
- FDK_ASSERT(nExtensions<=MAX_TOTAL_EXT_PAYLOADS);
- }
- }
- nPayload++;
- }
- } /* sbrEnabled */
-
- if ( (inargs->numAncBytes > 0) && ( getBufDescIdx(inBufDesc,IN_ANCILLRY_DATA)!=-1 ) ) {
- INT idx = getBufDescIdx(inBufDesc,IN_ANCILLRY_DATA);
- hAacEncoder->extPayload[nExtensions].dataSize = inargs->numAncBytes * 8;
- hAacEncoder->extPayload[nExtensions].pData = (UCHAR*)inBufDesc->bufs[idx];
- hAacEncoder->extPayload[nExtensions].dataType = EXT_DATA_ELEMENT;
- hAacEncoder->extPayload[nExtensions].associatedChElement = -1;
- ancDataExtIdx = nExtensions; /* store index */
- nExtensions++;
- }
-
- /*
- * Encode AAC - Core.
- */
- if ( FDKaacEnc_EncodeFrame( hAacEncoder->hAacEnc,
- hAacEncoder->hTpEnc,
- hAacEncoder->inputBuffer,
- outBytes,
- hAacEncoder->extPayload
- ) != AAC_ENC_OK )
- {
- err = AACENC_ENCODE_ERROR;
- goto bail;
- }
-
- if (ancDataExtIdx >= 0) {
- outargs->numAncBytes = inargs->numAncBytes - (hAacEncoder->extPayload[ancDataExtIdx].dataSize>>3);
- }
-
- /* samples exhausted */
- hAacEncoder->nSamplesRead -= hAacEncoder->nSamplesToRead;
-
- /*
- * Delay balancing buffer handling
- */
- if (isSbrActive(&hAacEncoder->aacConfig)) {
- sbrEncoder_UpdateBuffers(hAacEncoder->hEnvEnc, hAacEncoder->inputBuffer);
- }
-
- /*
- * Make bitstream public
- */
- if (outBufDesc->numBufs>=1) {
-
- INT bsIdx = getBufDescIdx(outBufDesc,OUT_BITSTREAM_DATA);
- INT auIdx = getBufDescIdx(outBufDesc,OUT_AU_SIZES);
-
- for (i=0,nBsBytes=0; i<hAacEncoder->aacConfig.nSubFrames; i++) {
- nBsBytes += outBytes[i];
-
- if (auIdx!=-1) {
- ((INT*)outBufDesc->bufs[auIdx])[i] = outBytes[i];
- }
- }
-
- if ( (bsIdx!=-1) && (outBufDesc->bufSizes[bsIdx]>=nBsBytes) ) {
- FDKmemcpy(outBufDesc->bufs[bsIdx], hAacEncoder->outBuffer, sizeof(UCHAR)*nBsBytes);
- outargs->numOutBytes = nBsBytes;
- }
- else {
- /* output buffer too small, can't write valid bitstream */
- err = AACENC_ENCODE_ERROR;
- goto bail;
- }
- }
-
-bail:
- if (err == AACENC_ENCODE_ERROR) {
- /* All encoder modules have to be initialized */
- hAacEncoder->InitFlags = AACENC_INIT_ALL;
- }
-
- return err;
-}
-
-static
-AAC_ENCODER_ERROR aacEncGetConf(HANDLE_AACENCODER hAacEncoder,
- UINT *size,
- UCHAR *confBuffer)
-{
- FDK_BITSTREAM tmpConf;
- UINT confType;
- UCHAR buf[64];
- int err;
-
- /* Init bit buffer */
- FDKinitBitStream(&tmpConf, buf, 64, 0, BS_WRITER);
-
- /* write conf in tmp buffer */
- err = transportEnc_GetConf(hAacEncoder->hTpEnc, &hAacEncoder->coderConfig, &tmpConf, &confType);
-
- /* copy data to outbuffer: length in bytes */
- FDKbyteAlign(&tmpConf, 0);
-
- /* Check buffer size */
- if (FDKgetValidBits(&tmpConf) > ((*size)<<3))
- return AAC_ENC_UNKNOWN;
-
- FDKfetchBuffer(&tmpConf, confBuffer, size);
-
- if (err != 0)
- return AAC_ENC_UNKNOWN;
- else
- return AAC_ENC_OK;
-}
-
-
-AACENC_ERROR aacEncGetLibInfo(LIB_INFO *info)
-{
- int i = 0;
-
- if (info == NULL) {
- return AACENC_INVALID_HANDLE;
- }
-
- FDK_toolsGetLibInfo( info );
- transportEnc_GetLibInfo( info );
-
- sbrEncoder_GetLibInfo( info );
-
- /* search for next free tab */
- for (i = 0; i < FDK_MODULE_LAST; i++) {
- if (info[i].module_id == FDK_NONE) break;
- }
- if (i == FDK_MODULE_LAST) {
- return AACENC_INIT_ERROR;
- }
-
- info[i].module_id = FDK_AACENC;
- info[i].build_date = (char*)AACENCODER_LIB_BUILD_DATE;
- info[i].build_time = (char*)AACENCODER_LIB_BUILD_TIME;
- info[i].title = (char*)AACENCODER_LIB_TITLE;
- info[i].version = LIB_VERSION(AACENCODER_LIB_VL0, AACENCODER_LIB_VL1, AACENCODER_LIB_VL2);;
- LIB_VERSION_STRING(&info[i]);
-
- /* Capability flags */
- info[i].flags = 0
- | CAPF_AAC_1024 | CAPF_AAC_LC
- | CAPF_AAC_960
- | CAPF_AAC_512
- | CAPF_AAC_480
- | CAPF_AAC_DRC
- ;
- /* End of flags */
-
- return AACENC_OK;
-}
-
-AACENC_ERROR aacEncoder_SetParam(
- const HANDLE_AACENCODER hAacEncoder,
- const AACENC_PARAM param,
- const UINT value
- )
-{
- AACENC_ERROR err = AACENC_OK;
- USER_PARAM *settings = &hAacEncoder->extParam;
-
- /* check encoder handle */
- if (hAacEncoder == NULL) {
- err = AACENC_INVALID_HANDLE;
- goto bail;
- }
-
- /* apply param value */
- switch (param)
- {
- case AACENC_AOT:
- if (settings->userAOT != (AUDIO_OBJECT_TYPE)value) {
- /* check if AOT matches the allocated modules */
- switch ( value ) {
- case AOT_PS:
- case AOT_DRM_SBR: // Added mfeilen
- case AOT_DABPLUS_PS:
- case AOT_MP2_PS:
- if (!(hAacEncoder->encoder_modis & (ENC_MODE_FLAG_PS))) {
- err = AACENC_INVALID_CONFIG;
- goto bail;
- }
- case AOT_SBR:
- case AOT_DABPLUS_SBR:
- case AOT_MP2_SBR:
- if (!(hAacEncoder->encoder_modis & (ENC_MODE_FLAG_SBR))) {
- err = AACENC_INVALID_CONFIG;
- goto bail;
- }
- case AOT_AAC_LC:
- case AOT_DABPLUS_AAC_LC:
- case AOT_MP2_AAC_LC:
- case AOT_ER_AAC_LD:
- case AOT_ER_AAC_ELD:
- if (!(hAacEncoder->encoder_modis & (ENC_MODE_FLAG_AAC))) {
- err = AACENC_INVALID_CONFIG;
- goto bail;
- }
- break;
- default:
- err = AACENC_INVALID_CONFIG;
- goto bail;
- }/* switch value */
- settings->userAOT = (AUDIO_OBJECT_TYPE)value;
- hAacEncoder->InitFlags |= AACENC_INIT_CONFIG | AACENC_INIT_STATES | AACENC_INIT_TRANSPORT;
- }
- break;
- case AACENC_BITRATE:
- if (settings->userBitrate != value) {
- settings->userBitrate = value;
- hAacEncoder->InitFlags |= AACENC_INIT_CONFIG | AACENC_INIT_TRANSPORT;
- }
- break;
- case AACENC_BITRATEMODE:
- if (settings->userBitrateMode != value) {
- switch ( value ) {
- case 0:
- case 1:
- case 2:
- case 3:
- case 4:
- case 5:
- case 7:
- case 8:
- settings->userBitrateMode = value;
- hAacEncoder->InitFlags |= AACENC_INIT_CONFIG | AACENC_INIT_TRANSPORT;
- break;
- default:
- err = AACENC_INVALID_CONFIG;
- break;
- } /* switch value */
- }
- break;
- case AACENC_SAMPLERATE:
- if (settings->userSamplerate != value) {
- if ( !( (value==8000) || (value==11025) || (value==12000) || (value==16000) || (value==22050) || (value==24000) ||
- (value==32000) || (value==44100) || (value==48000) || (value==64000) || (value==88200) || (value==96000) ) )
- {
- err = AACENC_INVALID_CONFIG;
- break;
- }
- settings->userSamplerate = value;
- hAacEncoder->nSamplesRead = 0; /* reset internal inputbuffer */
- hAacEncoder->InitFlags |= AACENC_INIT_CONFIG | AACENC_INIT_STATES | AACENC_INIT_TRANSPORT;
- }
- break;
- case AACENC_CHANNELMODE:
- if (settings->userChannelMode != (CHANNEL_MODE)value) {
- const CHANNEL_MODE_CONFIG_TAB* pConfig = FDKaacEnc_GetChannelModeConfiguration((CHANNEL_MODE)value);
- if (pConfig==NULL) {
- err = AACENC_INVALID_CONFIG;
- break;
- }
- if ( (pConfig->nElements > hAacEncoder->nMaxAacElements)
- || (pConfig->nChannelsEff > hAacEncoder->nMaxAacChannels)
- || !(((value>=1) && (value<=7))||((value>=33) && (value<=34)))
- )
- {
- err = AACENC_INVALID_CONFIG;
- break;
- }
-
- settings->userChannelMode = (CHANNEL_MODE)value;
- settings->nChannels = pConfig->nChannels;
- hAacEncoder->nSamplesRead = 0; /* reset internal inputbuffer */
- hAacEncoder->InitFlags |= AACENC_INIT_CONFIG | AACENC_INIT_TRANSPORT;
- }
- break;
- case AACENC_BANDWIDTH:
- if (settings->userBandwidth != value) {
- settings->userBandwidth = value;
- hAacEncoder->InitFlags |= AACENC_INIT_CONFIG;
- }
- break;
- case AACENC_CHANNELORDER:
- if (hAacEncoder->aacConfig.channelOrder != (CHANNEL_ORDER)value) {
- if (! ((value==0) || (value==1) || (value==2)) ) {
- err = AACENC_INVALID_CONFIG;
- break;
- }
- hAacEncoder->aacConfig.channelOrder = (CHANNEL_ORDER)value;
- hAacEncoder->nSamplesRead = 0; /* reset internal inputbuffer */
- hAacEncoder->InitFlags |= AACENC_INIT_CONFIG | AACENC_INIT_STATES | AACENC_INIT_TRANSPORT;
- }
- break;
- case AACENC_AFTERBURNER:
- if (settings->userAfterburner != value) {
- if (! ((value==0) || (value==1)) ) {
- err = AACENC_INVALID_CONFIG;
- break;
- }
- settings->userAfterburner = value;
- hAacEncoder->InitFlags |= AACENC_INIT_CONFIG;
- }
- break;
- case AACENC_GRANULE_LENGTH:
- if (settings->userFramelength != value) {
- switch (value) {
- case 1024:
- case 960:
- case 512:
- case 480:
- settings->userFramelength = value;
- hAacEncoder->InitFlags |= AACENC_INIT_CONFIG | AACENC_INIT_TRANSPORT;
- break;
- default:
- err = AACENC_INVALID_CONFIG;
- break;
- }
- }
- break;
- case AACENC_SBR_RATIO:
- if (settings->userSbrRatio != value) {
- if (! ((value==0) || (value==1) || (value==2)) ) {
- err = AACENC_INVALID_CONFIG;
- break;
- }
- settings->userSbrRatio = value;
- hAacEncoder->InitFlags |= AACENC_INIT_CONFIG | AACENC_INIT_STATES | AACENC_INIT_TRANSPORT;
- }
- break;
- case AACENC_SBR_MODE:
- if (settings->userSbrEnabled != value) {
- settings->userSbrEnabled = value;
- hAacEncoder->InitFlags |= AACENC_INIT_CONFIG | AACENC_INIT_STATES | AACENC_INIT_TRANSPORT;
- }
- break;
- case AACENC_TRANSMUX:
- if (settings->userTpType != (TRANSPORT_TYPE)value) {
-
- TRANSPORT_TYPE type = (TRANSPORT_TYPE)value;
- UINT flags = hAacEncoder->CAPF_tpEnc;
-
- if ( !( ((type==TT_MP4_ADIF) && (flags&CAPF_ADIF))
- || ((type==TT_MP4_ADTS) && (flags&CAPF_ADTS))
- || ((type==TT_MP4_LATM_MCP0) && ((flags&CAPF_LATM) && (flags&CAPF_RAWPACKETS)))
- || ((type==TT_MP4_LATM_MCP1) && ((flags&CAPF_LATM) && (flags&CAPF_RAWPACKETS)))
- || ((type==TT_MP4_LOAS) && (flags&CAPF_LOAS))
- || ((type==TT_MP4_RAW) && (flags&CAPF_RAWPACKETS))
- || ((type==TT_DABPLUS) && ((flags&CAPF_DAB_AAC) && (flags&CAPF_RAWPACKETS)))
- ) )
- {
- err = AACENC_INVALID_CONFIG;
- break;
- }
- settings->userTpType = (TRANSPORT_TYPE)value;
- hAacEncoder->InitFlags |= AACENC_INIT_TRANSPORT;
- }
- break;
- case AACENC_SIGNALING_MODE:
- if (settings->userTpSignaling != value) {
- if ( !((value==0) || (value==1) || (value==2)) ) {
- err = AACENC_INVALID_CONFIG;
- break;
- }
- settings->userTpSignaling = value;
- hAacEncoder->InitFlags |= AACENC_INIT_TRANSPORT;
- }
- break;
- case AACENC_PROTECTION:
- if (settings->userTpProtection != value) {
- if ( !((value==0) || (value==1)) ) {
- err = AACENC_INVALID_CONFIG;
- break;
- }
- settings->userTpProtection = value;
- hAacEncoder->InitFlags |= AACENC_INIT_TRANSPORT;
- }
- break;
- case AACENC_HEADER_PERIOD:
- if (settings->userTpHeaderPeriod != value) {
- settings->userTpHeaderPeriod = value;
- hAacEncoder->InitFlags |= AACENC_INIT_TRANSPORT;
- }
- break;
- case AACENC_TPSUBFRAMES:
- if (settings->userTpNsubFrames != value) {
- if (! ( (value>=1) && (value<=6) ) ) {
- err = AACENC_INVALID_CONFIG;
- break;
- }
- settings->userTpNsubFrames = value;
- hAacEncoder->InitFlags |= AACENC_INIT_TRANSPORT;
- }
- break;
- case AACENC_ANCILLARY_BITRATE:
- if (settings->userAncDataRate != value) {
- settings->userAncDataRate = value;
- }
- break;
- case AACENC_CONTROL_STATE:
- if (hAacEncoder->InitFlags != value) {
- if (value&AACENC_RESET_INBUFFER) {
- hAacEncoder->nSamplesRead = 0;
- }
- hAacEncoder->InitFlags = value;
- }
- break;
- case AACENC_METADATA_MODE:
- if ((UINT)settings->userMetaDataMode != value) {
- if ( !((value>=0) && (value<=2)) ) {
- err = AACENC_INVALID_CONFIG;
- break;
- }
- settings->userMetaDataMode = value;
- hAacEncoder->InitFlags |= AACENC_INIT_CONFIG;
- }
- break;
- default:
- err = AACENC_UNSUPPORTED_PARAMETER;
- break;
- } /* switch(param) */
-
-bail:
- return err;
-}
-
-UINT aacEncoder_GetParam(
- const HANDLE_AACENCODER hAacEncoder,
- const AACENC_PARAM param
- )
-{
- UINT value = 0;
- USER_PARAM *settings = &hAacEncoder->extParam;
-
- /* check encoder handle */
- if (hAacEncoder == NULL) {
- goto bail;
- }
-
- /* apply param value */
- switch (param)
- {
- case AACENC_AOT:
- value = (UINT)hAacEncoder->aacConfig.audioObjectType;
- break;
- case AACENC_BITRATE:
- value = (UINT)((hAacEncoder->aacConfig.bitrateMode==AACENC_BR_MODE_CBR) ? hAacEncoder->aacConfig.bitRate : -1);
- break;
- case AACENC_BITRATEMODE:
- value = (UINT)hAacEncoder->aacConfig.bitrateMode;
- break;
- case AACENC_SAMPLERATE:
- value = (UINT)hAacEncoder->coderConfig.extSamplingRate;
- break;
- case AACENC_CHANNELMODE:
- value = (UINT)hAacEncoder->aacConfig.channelMode;
- break;
- case AACENC_BANDWIDTH:
- value = (UINT)hAacEncoder->aacConfig.bandWidth;
- break;
- case AACENC_CHANNELORDER:
- value = (UINT)hAacEncoder->aacConfig.channelOrder;
- break;
- case AACENC_AFTERBURNER:
- value = (UINT)hAacEncoder->aacConfig.useRequant;
- break;
- case AACENC_GRANULE_LENGTH:
- value = (UINT)hAacEncoder->aacConfig.framelength;
- break;
- case AACENC_SBR_RATIO:
- value = isSbrActive(&hAacEncoder->aacConfig) ? hAacEncoder->aacConfig.sbrRatio : 0;
- break;
- case AACENC_SBR_MODE:
- value = (UINT) (hAacEncoder->aacConfig.syntaxFlags & AC_SBR_PRESENT) ? 1 : 0;
- break;
- case AACENC_TRANSMUX:
- value = (UINT)settings->userTpType;
- break;
- case AACENC_SIGNALING_MODE:
- value = (UINT)getSbrSignalingMode(hAacEncoder->aacConfig.audioObjectType, settings->userTpType, settings->userTpSignaling, hAacEncoder->aacConfig.sbrRatio);
- break;
- case AACENC_PROTECTION:
- value = (UINT)settings->userTpProtection;
- break;
- case AACENC_HEADER_PERIOD:
- value = (UINT)hAacEncoder->coderConfig.headerPeriod;
- break;
- case AACENC_TPSUBFRAMES:
- value = (UINT)settings->userTpNsubFrames;
- break;
- case AACENC_ANCILLARY_BITRATE:
- value = (UINT)hAacEncoder->aacConfig.anc_Rate;
- break;
- case AACENC_CONTROL_STATE:
- value = (UINT)hAacEncoder->InitFlags;
- break;
- case AACENC_METADATA_MODE:
- value = (hAacEncoder->metaDataAllowed==0) ? 0 : (UINT)settings->userMetaDataMode;
- break;
- default:
- //err = MPS_INVALID_PARAMETER;
- break;
- } /* switch(param) */
-
-bail:
- return value;
-}
-
-AACENC_ERROR aacEncInfo(
- const HANDLE_AACENCODER hAacEncoder,
- AACENC_InfoStruct *pInfo
- )
-{
- AACENC_ERROR err = AACENC_OK;
-
- FDKmemclear(pInfo, sizeof(AACENC_InfoStruct));
- pInfo->confSize = 64; /* pre-initialize */
-
- pInfo->maxOutBufBytes = ((hAacEncoder->nMaxAacChannels*6144)+7)>>3;
- pInfo->maxAncBytes = hAacEncoder->aacConfig.maxAncBytesPerAU;
- pInfo->inBufFillLevel = hAacEncoder->nSamplesRead/hAacEncoder->extParam.nChannels;
- pInfo->inputChannels = hAacEncoder->extParam.nChannels;
- pInfo->frameLength = hAacEncoder->nSamplesToRead/hAacEncoder->extParam.nChannels;
- pInfo->encoderDelay = hAacEncoder->nDelay/hAacEncoder->extParam.nChannels;
-
- /* Get encoder configuration */
- if ( aacEncGetConf(hAacEncoder, &pInfo->confSize, &pInfo->confBuf[0]) != AAC_ENC_OK) {
- err = AACENC_INIT_ERROR;
- goto bail;
- }
-bail:
- return err;
-}
-
diff --git a/libAACenc/src/aacenc_pns.cpp b/libAACenc/src/aacenc_pns.cpp
deleted file mode 100644
index b9640d9..0000000
--- a/libAACenc/src/aacenc_pns.cpp
+++ /dev/null
@@ -1,591 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M. Lohwasser
- contents/description: pns.c
-
-******************************************************************************/
-
-#include "aacenc_pns.h"
-#include "psy_data.h"
-#include "pnsparam.h"
-#include "noisedet.h"
-#include "bit_cnt.h"
-#include "interface.h"
-
-
-/* minCorrelationEnergy = (1.0e-10f)^2 ~ 2^-67 = 2^-47 * 2^-20 */
-static const FIXP_DBL minCorrelationEnergy = FL2FXCONST_DBL(0.0); /* FL2FXCONST_DBL((float)FDKpow(2.0,-47)); */
-/* noiseCorrelationThresh = 0.6^2 */
-static const FIXP_DBL noiseCorrelationThresh = FL2FXCONST_DBL(0.36);
-
-static void FDKaacEnc_FDKaacEnc_noiseDetection( PNS_CONFIG *pnsConf,
- PNS_DATA *pnsData,
- const INT sfbActive,
- const INT *sfbOffset,
- INT tnsOrder,
- INT tnsPredictionGain,
- INT tnsActive,
- FIXP_DBL *mdctSpectrum,
- INT *sfbMaxScaleSpec,
- FIXP_SGL *sfbtonality );
-
-static void FDKaacEnc_CalcNoiseNrgs( const INT sfbActive,
- INT *pnsFlag,
- FIXP_DBL *sfbEnergyLdData,
- INT *noiseNrg );
-
-/*****************************************************************************
-
- functionname: initPnsConfiguration
- description: fill pnsConf with pns parameters
- returns: error status
- input: PNS Config struct (modified)
- bitrate, samplerate, usePns,
- number of sfb's, pointer to sfb offset
- output: error code
-
-*****************************************************************************/
-
-AAC_ENCODER_ERROR FDKaacEnc_InitPnsConfiguration(PNS_CONFIG *pnsConf,
- INT bitRate,
- INT sampleRate,
- INT usePns,
- INT sfbCnt,
- const INT *sfbOffset,
- const INT numChan,
- const INT isLC)
-{
- AAC_ENCODER_ERROR ErrorStatus;
-
- /* init noise detection */
- ErrorStatus = FDKaacEnc_GetPnsParam(&pnsConf->np,
- bitRate,
- sampleRate,
- sfbCnt,
- sfbOffset,
- &usePns,
- numChan,
- isLC);
- if (ErrorStatus != AAC_ENC_OK)
- return ErrorStatus;
-
- pnsConf->minCorrelationEnergy = minCorrelationEnergy;
- pnsConf->noiseCorrelationThresh = noiseCorrelationThresh;
-
- pnsConf->usePns = usePns;
-
- return AAC_ENC_OK;
-}
-
-
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_PnsDetect
- description: do decision, if PNS shall used or not
- returns:
- input: pns config structure
- pns data structure (modified),
- lastWindowSequence (long or short blocks)
- sfbActive
- pointer to Sfb Energy, Threshold, Offset
- pointer to mdct Spectrum
- length of each group
- pointer to tonality calculated in chaosmeasure
- tns order and prediction gain
- calculated noiseNrg at active PNS
- output: pnsFlag in pns data structure
-
-*****************************************************************************/
-void FDKaacEnc_PnsDetect(PNS_CONFIG *pnsConf,
- PNS_DATA *pnsData,
- const INT lastWindowSequence,
- const INT sfbActive,
- const INT maxSfbPerGroup,
- FIXP_DBL *sfbThresholdLdData,
- const INT *sfbOffset,
- FIXP_DBL *mdctSpectrum,
- INT *sfbMaxScaleSpec,
- FIXP_SGL *sfbtonality,
- INT tnsOrder,
- INT tnsPredictionGain,
- INT tnsActive,
- FIXP_DBL *sfbEnergyLdData,
- INT *noiseNrg )
-
-{
- int sfb;
- int startNoiseSfb;
-
- if (pnsConf->np.detectionAlgorithmFlags & IS_LOW_COMLEXITY) {
- if ( (!pnsConf->usePns) || /* pns enabled? */
- (lastWindowSequence == SHORT_WINDOW) ) /* currently only long blocks */
- {
- FDKmemclear(pnsData->pnsFlag, MAX_GROUPED_SFB*sizeof(INT)); /* clear all pnsFlags */
- for (sfb=0; sfb<MAX_GROUPED_SFB; sfb++) {
- noiseNrg[sfb] = NO_NOISE_PNS; /* clear nrg's of previous frame */
- }
- return;
- }
- }
- else {
- if(!pnsConf->usePns)
- return;
-
- /* PNS only for long Windows */
- if (pnsConf->np.detectionAlgorithmFlags & JUST_LONG_WINDOW) {
- if(lastWindowSequence != LONG_WINDOW) {
- for (sfb = 0; sfb < sfbActive; sfb++) {
- pnsData->pnsFlag[sfb] = 0; /* clear all pnsFlags */
- }
- return;
- }
- }
- }
- /*
- call noise detection
- */
- FDKaacEnc_FDKaacEnc_noiseDetection( pnsConf,
- pnsData,
- sfbActive,
- sfbOffset,
- tnsOrder,
- tnsPredictionGain,
- tnsActive,
- mdctSpectrum,
- sfbMaxScaleSpec,
- sfbtonality );
-
- /* set startNoiseSfb (long) */
- startNoiseSfb = pnsConf->np.startSfb;
-
- /* Set noise substitution status */
- for(sfb = 0; sfb < sfbActive; sfb++) {
-
- /* No PNS below startNoiseSfb */
- if(sfb < startNoiseSfb){
- pnsData->pnsFlag[sfb] = 0;
- continue;
- }
-
- /*
- do noise substitution if
- fuzzy measure is high enough
- sfb freq > minimum sfb freq
- signal in coder band is not masked
- */
-
- if((pnsData->noiseFuzzyMeasure[sfb] > FL2FXCONST_SGL(0.5)) &&
- ( (sfbThresholdLdData[sfb] + FL2FXCONST_DBL(0.5849625f/64.0f)) /* thr * 1.5 = thrLd +ld(1.5)/64 */
- < sfbEnergyLdData[sfb] ) )
- {
- /*
- mark in psyout flag array that we will code
- this band with PNS
- */
- pnsData->pnsFlag[sfb] = 1; /* PNS_ON */
- }
- else{
- pnsData->pnsFlag[sfb] = 0; /* PNS_OFF */
- }
-
- /* no PNS if LTP is active */
- }
-
- /* avoid PNS holes */
- if((pnsData->noiseFuzzyMeasure[0]>FL2FXCONST_SGL(0.5f)) && (pnsData->pnsFlag[1])) {
- pnsData->pnsFlag[0] = 1;
- }
-
- for(sfb=1; sfb<maxSfbPerGroup-1; sfb++) {
- if((pnsData->noiseFuzzyMeasure[sfb]>pnsConf->np.gapFillThr) &&
- (pnsData->pnsFlag[sfb-1]) && (pnsData->pnsFlag[sfb+1])) {
- pnsData->pnsFlag[sfb] = 1;
- }
- }
-
- if(maxSfbPerGroup>0) {
- /* avoid PNS hole */
- if((pnsData->noiseFuzzyMeasure[maxSfbPerGroup-1]>pnsConf->np.gapFillThr) && (pnsData->pnsFlag[maxSfbPerGroup-2])) {
- pnsData->pnsFlag[maxSfbPerGroup-1] = 1;
- }
- /* avoid single PNS band */
- if(pnsData->pnsFlag[maxSfbPerGroup-2]==0) {
- pnsData->pnsFlag[maxSfbPerGroup-1] = 0;
- }
- }
-
- /* avoid single PNS bands */
- if(pnsData->pnsFlag[1]==0) {
- pnsData->pnsFlag[0] = 0;
- }
-
- for(sfb=1; sfb<maxSfbPerGroup-1; sfb++) {
- if((pnsData->pnsFlag[sfb-1]==0)&&(pnsData->pnsFlag[sfb+1]==0)) {
- pnsData->pnsFlag[sfb] = 0;
- }
- }
-
-
- /*
- calculate noiseNrg's
- */
- FDKaacEnc_CalcNoiseNrgs( sfbActive,
- pnsData->pnsFlag,
- sfbEnergyLdData,
- noiseNrg );
-}
-
-
-/*****************************************************************************
-
- functionname:FDKaacEnc_FDKaacEnc_noiseDetection
- description: wrapper for noisedet.c
- returns:
- input: pns config structure
- pns data structure (modified),
- sfbActive
- tns order and prediction gain
- pointer to mdct Spectrumand Sfb Energy
- pointer to Sfb tonality
- output: noiseFuzzyMeasure in structure pnsData
- flags tonal / nontonal
-
-*****************************************************************************/
-static void FDKaacEnc_FDKaacEnc_noiseDetection( PNS_CONFIG *pnsConf,
- PNS_DATA *pnsData,
- const INT sfbActive,
- const INT *sfbOffset,
- int tnsOrder,
- INT tnsPredictionGain,
- INT tnsActive,
- FIXP_DBL *mdctSpectrum,
- INT *sfbMaxScaleSpec,
- FIXP_SGL *sfbtonality )
-{
- INT condition = TRUE;
- if ( !(pnsConf->np.detectionAlgorithmFlags & IS_LOW_COMLEXITY) ) {
- condition = (tnsOrder > 3);
- }
- /*
- no PNS if heavy TNS activity
- clear pnsData->noiseFuzzyMeasure
- */
- if((pnsConf->np.detectionAlgorithmFlags & USE_TNS_GAIN_THR) &&
- (tnsPredictionGain >= pnsConf->np.tnsGainThreshold) && condition &&
- !((pnsConf->np.detectionAlgorithmFlags & USE_TNS_PNS) && (tnsPredictionGain >= pnsConf->np.tnsPNSGainThreshold) && (tnsActive)) )
- {
- /* clear all noiseFuzzyMeasure */
- FDKmemclear(pnsData->noiseFuzzyMeasure, sfbActive*sizeof(FIXP_SGL));
- }
- else
- {
- /*
- call noise detection, output in pnsData->noiseFuzzyMeasure,
- use real mdct spectral data
- */
- FDKaacEnc_noiseDetect( mdctSpectrum,
- sfbMaxScaleSpec,
- sfbActive,
- sfbOffset,
- pnsData->noiseFuzzyMeasure,
- &pnsConf->np,
- sfbtonality);
- }
-}
-
-
-/*****************************************************************************
-
- functionname:FDKaacEnc_CalcNoiseNrgs
- description: Calculate the NoiseNrg's
- returns:
- input: sfbActive
- if pnsFlag calculate NoiseNrg
- pointer to sfbEnergy and groupLen
- pointer to noiseNrg (modified)
- output: noiseNrg's in pnsFlaged sfb's
-
-*****************************************************************************/
-
-static void FDKaacEnc_CalcNoiseNrgs( const INT sfbActive,
- INT *RESTRICT pnsFlag,
- FIXP_DBL *RESTRICT sfbEnergyLdData,
- INT *RESTRICT noiseNrg )
-{
- int sfb;
- INT tmp = (-LOG_NORM_PCM)<<2;
-
- for(sfb = 0; sfb < sfbActive; sfb++) {
- if(pnsFlag[sfb]) {
- INT nrg = (-sfbEnergyLdData[sfb]+FL2FXCONST_DBL(0.5f/64.0f))>>(DFRACT_BITS-1-7);
- noiseNrg[sfb] = tmp - nrg;
- }
- }
-}
-
-
-/*****************************************************************************
-
- functionname:FDKaacEnc_CodePnsChannel
- description: Execute pns decission
- returns:
- input: sfbActive
- pns config structure
- use PNS if pnsFlag
- pointer to Sfb Energy, noiseNrg, Threshold
- output: set sfbThreshold high to code pe with 0,
- noiseNrg marks flag for pns coding
-
-*****************************************************************************/
-
-void FDKaacEnc_CodePnsChannel(const INT sfbActive,
- PNS_CONFIG *pnsConf,
- INT *RESTRICT pnsFlag,
- FIXP_DBL *RESTRICT sfbEnergyLdData,
- INT *RESTRICT noiseNrg,
- FIXP_DBL *RESTRICT sfbThresholdLdData)
-{
- INT sfb;
- INT lastiNoiseEnergy = 0;
- INT firstPNSband = 1; /* TRUE for first PNS-coded band */
-
- /* no PNS */
- if(!pnsConf->usePns) {
- for(sfb = 0; sfb < sfbActive; sfb++) {
- /* no PNS coding */
- noiseNrg[sfb] = NO_NOISE_PNS;
- }
- return;
- }
-
- /* code PNS */
- for(sfb = 0; sfb < sfbActive; sfb++) {
- if(pnsFlag[sfb]) {
- /* high sfbThreshold causes pe = 0 */
- if(noiseNrg[sfb] != NO_NOISE_PNS)
- sfbThresholdLdData[sfb] = sfbEnergyLdData[sfb] + FL2FXCONST_DBL(1.0f/LD_DATA_SCALING);
-
- /* set noiseNrg in valid region */
- if(!firstPNSband) {
- INT deltaiNoiseEnergy = noiseNrg[sfb] - lastiNoiseEnergy;
-
- if(deltaiNoiseEnergy > CODE_BOOK_PNS_LAV)
- noiseNrg[sfb] -= deltaiNoiseEnergy - CODE_BOOK_PNS_LAV;
- else if(deltaiNoiseEnergy < -CODE_BOOK_PNS_LAV)
- noiseNrg[sfb] -= deltaiNoiseEnergy + CODE_BOOK_PNS_LAV;
- }
- else {
- firstPNSband = 0;
- }
- lastiNoiseEnergy = noiseNrg[sfb];
- }
- else {
- /* no PNS coding */
- noiseNrg[sfb] = NO_NOISE_PNS;
- }
- }
-}
-
-
-/*****************************************************************************
-
- functionname:FDKaacEnc_PreProcessPnsChannelPair
- description: Calculate the correlation of noise in a channel pair
-
- returns:
- input: sfbActive
- pointer to sfb energies left, right and mid channel
- pns config structure
- pns data structure left and right (modified)
-
- output: noiseEnergyCorrelation in pns data structure
-
-*****************************************************************************/
-
-void FDKaacEnc_PreProcessPnsChannelPair(const INT sfbActive,
- FIXP_DBL *RESTRICT sfbEnergyLeft,
- FIXP_DBL *RESTRICT sfbEnergyRight,
- FIXP_DBL *RESTRICT sfbEnergyLeftLD,
- FIXP_DBL *RESTRICT sfbEnergyRightLD,
- FIXP_DBL *RESTRICT sfbEnergyMid,
- PNS_CONFIG *RESTRICT pnsConf,
- PNS_DATA *pnsDataLeft,
- PNS_DATA *pnsDataRight)
-{
- INT sfb;
- FIXP_DBL ccf;
-
- if(!pnsConf->usePns)
- return;
-
- FIXP_DBL *RESTRICT pNoiseEnergyCorrelationL = pnsDataLeft->noiseEnergyCorrelation;
- FIXP_DBL *RESTRICT pNoiseEnergyCorrelationR = pnsDataRight->noiseEnergyCorrelation;
-
- for(sfb=0;sfb< sfbActive;sfb++) {
- FIXP_DBL quot = (sfbEnergyLeftLD[sfb]>>1) + (sfbEnergyRightLD[sfb]>>1);
-
- if(quot < FL2FXCONST_DBL(-32.0f/(float)LD_DATA_SCALING))
- ccf = FL2FXCONST_DBL(0.0f);
- else {
- FIXP_DBL accu = sfbEnergyMid[sfb]- (((sfbEnergyLeft[sfb]>>1)+(sfbEnergyRight[sfb]>>1))>>1);
- INT sign = (accu < FL2FXCONST_DBL(0.0f)) ? 1 : 0 ;
- accu = fixp_abs(accu);
-
- ccf = CalcLdData(accu) + FL2FXCONST_DBL((float)1.0f/(float)LD_DATA_SCALING) - quot; /* ld(accu*2) = ld(accu) + 1 */
- ccf = (ccf>=FL2FXCONST_DBL(0.0)) ? ((FIXP_DBL)MAXVAL_DBL) : (sign) ? -CalcInvLdData(ccf) : CalcInvLdData(ccf);
- }
-
- pNoiseEnergyCorrelationL[sfb] = ccf;
- pNoiseEnergyCorrelationR[sfb] = ccf;
- }
-}
-
-
-
-/*****************************************************************************
-
- functionname:FDKaacEnc_PostProcessPnsChannelPair
- description: if PNS used at left and right channel,
- use msMask to flag correlation
- returns:
- input: sfbActive
- pns config structure
- pns data structure left and right (modified)
- pointer to msMask, flags correlation by pns coding (modified)
- Digest of MS coding
- output: pnsFlag in pns data structure,
- msFlag in msMask (flags correlation)
-
-*****************************************************************************/
-
-void FDKaacEnc_PostProcessPnsChannelPair(const INT sfbActive,
- PNS_CONFIG *pnsConf,
- PNS_DATA *pnsDataLeft,
- PNS_DATA *pnsDataRight,
- INT *RESTRICT msMask,
- INT *msDigest )
-{
- INT sfb;
-
- if(!pnsConf->usePns)
- return;
-
- for(sfb=0;sfb<sfbActive;sfb++) {
- /*
- MS post processing
- */
- if( msMask[sfb] ) {
- if( (pnsDataLeft->pnsFlag[sfb]) &&
- (pnsDataRight->pnsFlag[sfb]) ) {
- /* AAC only: Standard */
- /* do this to avoid ms flags in layers that should not have it */
- if(pnsDataLeft->noiseEnergyCorrelation[sfb] <= pnsConf->noiseCorrelationThresh){
- msMask[sfb] = 0;
- *msDigest = MS_SOME;
- }
- }
- else {
- /*
- No PNS coding
- */
- pnsDataLeft->pnsFlag[sfb] = 0;
- pnsDataRight->pnsFlag[sfb] = 0;
- }
- }
-
- /*
- Use MS flag to signal noise correlation if
- pns is active in both channels
- */
- if( (pnsDataLeft->pnsFlag[sfb]) && (pnsDataRight->pnsFlag[sfb]) ) {
- if(pnsDataLeft->noiseEnergyCorrelation[sfb] > pnsConf->noiseCorrelationThresh) {
- msMask[sfb] = 1;
- *msDigest = MS_SOME;
- }
- }
- }
-}
diff --git a/libAACenc/src/aacenc_pns.h b/libAACenc/src/aacenc_pns.h
deleted file mode 100644
index 3bda9de..0000000
--- a/libAACenc/src/aacenc_pns.h
+++ /dev/null
@@ -1,113 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M. Lohwasser
- contents/description: pns.h
-
-******************************************************************************/
-
-#ifndef __PNS_H
-#define __PNS_H
-
-#include "common_fix.h"
-
-#include "pnsparam.h"
-
-#define NO_NOISE_PNS FDK_INT_MIN
-
-typedef struct{
- NOISEPARAMS np;
- FIXP_DBL minCorrelationEnergy;
- FIXP_DBL noiseCorrelationThresh;
- INT usePns;
-} PNS_CONFIG;
-
-typedef struct{
- FIXP_SGL noiseFuzzyMeasure[MAX_GROUPED_SFB];
- FIXP_DBL noiseEnergyCorrelation[MAX_GROUPED_SFB];
- INT pnsFlag[MAX_GROUPED_SFB];
-} PNS_DATA;
-
-#endif
diff --git a/libAACenc/src/aacenc_tns.cpp b/libAACenc/src/aacenc_tns.cpp
deleted file mode 100644
index e0f59bd..0000000
--- a/libAACenc/src/aacenc_tns.cpp
+++ /dev/null
@@ -1,1370 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: Alex Groeschel, Tobias Chalupka
- contents/description: Temporal noise shaping
-
-******************************************************************************/
-
-#include "aacenc_tns.h"
-#include "psy_const.h"
-#include "psy_configuration.h"
-#include "tns_func.h"
-#include "aacEnc_rom.h"
-#include "aacenc_tns.h"
-
-enum {
- HIFILT = 0, /* index of higher filter */
- LOFILT = 1 /* index of lower filter */
-};
-
-
-#define FILTER_DIRECTION 0
-
-static const FIXP_DBL acfWindowLong[12+3+1] = {
- 0x7fffffff,0x7fb80000,0x7ee00000,0x7d780000,0x7b800000,0x78f80000,0x75e00000,0x72380000,
- 0x6e000000,0x69380000,0x63e00000,0x5df80000,0x57800000,0x50780000,0x48e00000,0x40b80000
-};
-
-static const FIXP_DBL acfWindowShort[4+3+1] = {
- 0x7fffffff,0x7e000000,0x78000000,0x6e000000,0x60000000,0x4e000000,0x38000000,0x1e000000
-};
-
-
-typedef struct {
- INT filterEnabled[MAX_NUM_OF_FILTERS];
- INT threshOn[MAX_NUM_OF_FILTERS]; /* min. prediction gain for using tns TABUL*/
- INT filterStartFreq[MAX_NUM_OF_FILTERS]; /* lowest freq for lpc TABUL*/
- INT tnsLimitOrder[MAX_NUM_OF_FILTERS]; /* Limit for TNS order TABUL*/
- INT tnsFilterDirection[MAX_NUM_OF_FILTERS]; /* Filtering direction, 0=up, 1=down TABUL */
- INT acfSplit[MAX_NUM_OF_FILTERS];
- FIXP_DBL tnsTimeResolution[MAX_NUM_OF_FILTERS]; /* TNS max. time resolution TABUL. Should be fract but MSVC won't compile then */
- INT seperateFiltersAllowed;
-
-} TNS_PARAMETER_TABULATED;
-
-
-typedef struct{
- INT bitRateFrom[2]; /* noneSbr=0, useSbr=1 */
- INT bitRateTo[2]; /* noneSbr=0, useSbr=1 */
- TNS_PARAMETER_TABULATED paramTab[2]; /* mono=0, stereo=1 */
-
-} TNS_INFO_TAB;
-
-#define TNS_TIMERES_SCALE (1)
-#define FL2_TIMERES_FIX(a) ( FL2FXCONST_DBL(a/(float)(1<<TNS_TIMERES_SCALE)) )
-
-static const TNS_INFO_TAB tnsInfoTab[] =
-{
- {
- { 16000, 13500},
- { 32000, 28000},
- {
- { {1, 1}, {1437, 1500}, {1400, 600}, {12, 12}, {FILTER_DIRECTION, FILTER_DIRECTION}, {3, 1}, {FL2_TIMERES_FIX(0.4f), FL2_TIMERES_FIX(1.2f)}, 1 },
- { {1, 1}, {1437, 1500}, {1400, 600}, {12, 12}, {FILTER_DIRECTION, FILTER_DIRECTION}, {3, 1}, {FL2_TIMERES_FIX(0.4f), FL2_TIMERES_FIX(1.2f)}, 1 }
- }
- },
- {
- { 32001, 28001},
- { 60000, 52000},
- {
- { {1, 1}, {1437, 1500}, {1400, 600}, {12, 10}, {FILTER_DIRECTION, FILTER_DIRECTION}, {3, 1}, {FL2_TIMERES_FIX(0.4f), FL2_TIMERES_FIX(1.0f)}, 1 },
- { {1, 1}, {1437, 1500}, {1400, 600}, {12, 10}, {FILTER_DIRECTION, FILTER_DIRECTION}, {3, 1}, {FL2_TIMERES_FIX(0.4f), FL2_TIMERES_FIX(1.0f)}, 1 }
- }
- },
- {
- { 60001, 52001},
- { 384000, 384000},
- {
- { {1, 1}, {1437, 1500}, {1400, 600}, {12, 8}, {FILTER_DIRECTION, FILTER_DIRECTION}, {3, 1}, {FL2_TIMERES_FIX(0.4f), FL2_TIMERES_FIX(1.0f)}, 1 },
- { {1, 1}, {1437, 1500}, {1400, 600}, {12, 8}, {FILTER_DIRECTION, FILTER_DIRECTION}, {3, 1}, {FL2_TIMERES_FIX(0.4f), FL2_TIMERES_FIX(1.0f)}, 1 }
- }
- }
-};
-
-typedef struct {
- INT samplingRate;
- SCHAR maxBands[2]; /* long=0; short=1 */
-
-} TNS_MAX_TAB_ENTRY;
-
-static const TNS_MAX_TAB_ENTRY tnsMaxBandsTab1024[] =
-{
- { 96000, { 31, 9}},
- { 88200, { 31, 9}},
- { 64000, { 34, 10}},
- { 48000, { 40, 14}},
- { 44100, { 42, 14}},
- { 32000, { 51, 14}},
- { 24000, { 46, 14}},
- { 22050, { 46, 14}},
- { 16000, { 42, 14}},
- { 12000, { 42, 14}},
- { 11025, { 42, 14}},
- { 8000, { 39, 14}}
-};
-
-static const TNS_MAX_TAB_ENTRY tnsMaxBandsTab960[] =
-{
- { 96000, { 31, 9}},
- { 88200, { 31, 9}},
- { 64000, { 34, 10}},
- { 48000, { 49, 14}},
- { 44100, { 49, 14}},
- { 32000, { 49, 14}},
- { 24000, { 46, 15}},
- { 22050, { 46, 14}},
- { 16000, { 46, 15}},
- { 12000, { 42, 15}},
- { 11025, { 42, 15}},
- { 8000, { 40, 15}}
-};
-
-static const TNS_MAX_TAB_ENTRY tnsMaxBandsTab480[] =
-{
- { 48000, { 31, -1}},
- { 44100, { 32, -1}},
- { 32000, { 37, -1}},
- { 24000, { 30, -1}},
- { 22050, { 30, -1}}
-};
-
-static const TNS_MAX_TAB_ENTRY tnsMaxBandsTab512[] =
-{
- { 48000, { 31, -1}},
- { 44100, { 32, -1}},
- { 32000, { 37, -1}},
- { 24000, { 31, -1}},
- { 22050, { 31, -1}}
-};
-
-static INT FDKaacEnc_AutoToParcor(
- FIXP_DBL *RESTRICT input,
- FIXP_DBL *RESTRICT reflCoeff,
- const INT numOfCoeff
- );
-
-static void FDKaacEnc_Parcor2Index(
- const FIXP_DBL *parcor,
- INT *RESTRICT index,
- const INT order,
- const INT bitsPerCoeff
- );
-
-static void FDKaacEnc_Index2Parcor(
- const INT *index,
- FIXP_DBL *RESTRICT parcor,
- const INT order,
- const INT bitsPerCoeff
- );
-
-static INT FDKaacEnc_ParcorToLpc(
- const FIXP_DBL *reflCoeff,
- FIXP_DBL *RESTRICT LpcCoeff,
- const INT numOfCoeff,
- FIXP_DBL *RESTRICT workBuffer
- );
-
-static void FDKaacEnc_AnalysisFilter(
- FIXP_DBL *RESTRICT signal,
- const INT numOfLines,
- const FIXP_DBL *predictorCoeff,
- const INT order,
- const INT lpcGainFactor
- );
-
-static void FDKaacEnc_CalcGaussWindow(
- FIXP_DBL *win,
- const int winSize,
- const INT samplingRate,
- const INT transformResolution,
- const FIXP_DBL timeResolution,
- const INT timeResolution_e
- );
-
-static const TNS_PARAMETER_TABULATED* FDKaacEnc_GetTnsParam(
- const INT bitRate,
- const INT channels,
- const INT sbrLd
- )
-{
- int i;
- const TNS_PARAMETER_TABULATED *tnsConfigTab = NULL;
-
- for (i = 0; i < (int) (sizeof(tnsInfoTab)/sizeof(TNS_INFO_TAB)); i++) {
- if ((bitRate >= tnsInfoTab[i].bitRateFrom[sbrLd?1:0]) &&
- bitRate <= tnsInfoTab[i].bitRateTo[sbrLd?1:0])
- {
- tnsConfigTab = &tnsInfoTab[i].paramTab[(channels==1)?0:1];
- }
- }
-
- return tnsConfigTab;
-}
-
-
-static INT getTnsMaxBands(
- const INT sampleRate,
- const INT granuleLength,
- const INT isShortBlock
- )
-{
- int i;
- INT numBands = -1;
- const TNS_MAX_TAB_ENTRY *pMaxBandsTab = NULL;
- int maxBandsTabSize = 0;
-
- switch (granuleLength) {
- case 960:
- pMaxBandsTab = tnsMaxBandsTab960;
- maxBandsTabSize = sizeof(tnsMaxBandsTab960)/sizeof(TNS_MAX_TAB_ENTRY);
- break;
- case 1024:
- pMaxBandsTab = tnsMaxBandsTab1024;
- maxBandsTabSize = sizeof(tnsMaxBandsTab1024)/sizeof(TNS_MAX_TAB_ENTRY);
- break;
- case 480:
- pMaxBandsTab = tnsMaxBandsTab480;
- maxBandsTabSize = sizeof(tnsMaxBandsTab480)/sizeof(TNS_MAX_TAB_ENTRY);
- break;
- case 512:
- pMaxBandsTab = tnsMaxBandsTab512;
- maxBandsTabSize = sizeof(tnsMaxBandsTab512)/sizeof(TNS_MAX_TAB_ENTRY);
- break;
- default:
- numBands = -1;
- }
-
- if (pMaxBandsTab!=NULL) {
- for (i=0; i<maxBandsTabSize; i++) {
- numBands = pMaxBandsTab[i].maxBands[(!isShortBlock)?0:1];
- if (sampleRate >= pMaxBandsTab[i].samplingRate) {
- break;
- }
- }
- }
-
- return numBands;
-}
-
-/***************************************************************************/
-/*!
- \brief FDKaacEnc_FreqToBandWithRounding
-
- Returns index of nearest band border
-
- \param frequency
- \param sampling frequency
- \param total number of bands
- \param pointer to table of band borders
-
- \return band border
-****************************************************************************/
-
-INT FDKaacEnc_FreqToBandWithRounding(
- const INT freq,
- const INT fs,
- const INT numOfBands,
- const INT *bandStartOffset
- )
-{
- INT lineNumber, band;
-
- /* assert(freq >= 0); */
- lineNumber = (freq*bandStartOffset[numOfBands]*4/fs+1)/2;
-
- /* freq > fs/2 */
- if (lineNumber >= bandStartOffset[numOfBands])
- return numOfBands;
-
- /* find band the line number lies in */
- for (band=0; band<numOfBands; band++) {
- if (bandStartOffset[band+1]>lineNumber) break;
- }
-
- /* round to nearest band border */
- if (lineNumber - bandStartOffset[band] >
- bandStartOffset[band+1] - lineNumber )
- {
- band++;
- }
-
- return(band);
-}
-
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_InitTnsConfiguration
- description: fill TNS_CONFIG structure with sensible content
- returns:
- input: bitrate, samplerate, number of channels,
- blocktype (long or short),
- TNS Config struct (modified),
- psy config struct,
- tns active flag
- output:
-
-*****************************************************************************/
-AAC_ENCODER_ERROR FDKaacEnc_InitTnsConfiguration(INT bitRate,
- INT sampleRate,
- INT channels,
- INT blockType,
- INT granuleLength,
- INT ldSbrPresent,
- TNS_CONFIG *tC,
- PSY_CONFIGURATION *pC,
- INT active,
- INT useTnsPeak)
-{
- int i;
- //float acfTimeRes = (blockType == SHORT_WINDOW) ? 0.125f : 0.046875f;
-
- if (channels <= 0)
- return (AAC_ENCODER_ERROR)1;
-
- /* initialize TNS filter flag, order, and coefficient resolution (in bits per coeff) */
- tC->tnsActive = (active) ? TRUE : FALSE;
- tC->maxOrder = (blockType == SHORT_WINDOW) ? 5 : 12; /* maximum: 7, 20 */
- if (bitRate < 16000)
- tC->maxOrder -= 2;
- tC->coefRes = (blockType == SHORT_WINDOW) ? 3 : 4;
-
- /* LPC stop line: highest MDCT line to be coded, but do not go beyond TNS_MAX_BANDS! */
- tC->lpcStopBand = getTnsMaxBands(sampleRate, granuleLength, (blockType == SHORT_WINDOW) ? 1 : 0);
-
- if (tC->lpcStopBand < 0) {
- return (AAC_ENCODER_ERROR)1;
- }
-
- tC->lpcStopBand = FDKmin(tC->lpcStopBand, pC->sfbActive);
- tC->lpcStopLine = pC->sfbOffset[tC->lpcStopBand];
-
- switch (granuleLength) {
- case 960:
- case 1024:
- /* TNS start line: skip lower MDCT lines to prevent artifacts due to filter mismatch */
- tC->lpcStartBand[LOFILT] = (blockType == SHORT_WINDOW) ? 0 : ((sampleRate < 18783) ? 4 : 8);
- tC->lpcStartLine[LOFILT] = pC->sfbOffset[tC->lpcStartBand[LOFILT]];
-
- i = tC->lpcStopBand;
- while (pC->sfbOffset[i] > (tC->lpcStartLine[LOFILT] + (tC->lpcStopLine - tC->lpcStartLine[LOFILT]) / 4)) i--;
- tC->lpcStartBand[HIFILT] = i;
- tC->lpcStartLine[HIFILT] = pC->sfbOffset[i];
-
- tC->confTab.threshOn[HIFILT] = 1437;
- tC->confTab.threshOn[LOFILT] = 1500;
-
- tC->confTab.tnsLimitOrder[HIFILT] = tC->maxOrder;
- tC->confTab.tnsLimitOrder[LOFILT] = tC->maxOrder - 7;
-
- tC->confTab.tnsFilterDirection[HIFILT] = FILTER_DIRECTION;
- tC->confTab.tnsFilterDirection[LOFILT] = FILTER_DIRECTION;
-
- tC->confTab.acfSplit[HIFILT] = -1; /* signal Merged4to2QuartersAutoCorrelation in FDKaacEnc_MergedAutoCorrelation*/
- tC->confTab.acfSplit[LOFILT] = -1; /* signal Merged4to2QuartersAutoCorrelation in FDKaacEnc_MergedAutoCorrelation */
-
- tC->confTab.filterEnabled[HIFILT] = 1;
- tC->confTab.filterEnabled[LOFILT] = 1;
- tC->confTab.seperateFiltersAllowed = 1;
-
- /* compute autocorrelation window based on maximum filter order for given block type */
- /* for (i = 0; i <= tC->maxOrder + 3; i++) {
- float acfWinTemp = acfTimeRes * i;
- acfWindow[i] = FL2FXCONST_DBL(1.0f - acfWinTemp * acfWinTemp);
- }
- */
- if (blockType == SHORT_WINDOW) {
- FDKmemcpy(tC->acfWindow[HIFILT], acfWindowShort, FDKmin(sizeof(acfWindowShort), sizeof(tC->acfWindow[HIFILT])));
- FDKmemcpy(tC->acfWindow[LOFILT], acfWindowShort, FDKmin(sizeof(acfWindowShort), sizeof(tC->acfWindow[HIFILT])));
- }
- else {
- FDKmemcpy(tC->acfWindow[HIFILT], acfWindowLong, FDKmin(sizeof(acfWindowLong), sizeof(tC->acfWindow[HIFILT])));
- FDKmemcpy(tC->acfWindow[LOFILT], acfWindowLong, FDKmin(sizeof(acfWindowLong), sizeof(tC->acfWindow[HIFILT])));
- }
- break;
- case 480:
- case 512:
- {
- const TNS_PARAMETER_TABULATED* pCfg = FDKaacEnc_GetTnsParam(bitRate, channels, ldSbrPresent);
-
- if ( pCfg != NULL ) {
- tC->lpcStartBand[HIFILT] = FDKaacEnc_FreqToBandWithRounding(pCfg->filterStartFreq[HIFILT], sampleRate, pC->sfbCnt, pC->sfbOffset);
- tC->lpcStartLine[HIFILT] = pC->sfbOffset[tC->lpcStartBand[HIFILT]];
- tC->lpcStartBand[LOFILT] = FDKaacEnc_FreqToBandWithRounding(pCfg->filterStartFreq[LOFILT], sampleRate, pC->sfbCnt, pC->sfbOffset);
- tC->lpcStartLine[LOFILT] = pC->sfbOffset[tC->lpcStartBand[LOFILT]];
-
- tC->confTab.threshOn[HIFILT] = pCfg->threshOn[HIFILT];
- tC->confTab.threshOn[LOFILT] = pCfg->threshOn[LOFILT];
-
- tC->confTab.tnsLimitOrder[HIFILT] = pCfg->tnsLimitOrder[HIFILT];
- tC->confTab.tnsLimitOrder[LOFILT] = pCfg->tnsLimitOrder[LOFILT];
-
- tC->confTab.tnsFilterDirection[HIFILT] = pCfg->tnsFilterDirection[HIFILT];
- tC->confTab.tnsFilterDirection[LOFILT] = pCfg->tnsFilterDirection[LOFILT];
-
- tC->confTab.acfSplit[HIFILT] = pCfg->acfSplit[HIFILT];
- tC->confTab.acfSplit[LOFILT] = pCfg->acfSplit[LOFILT];
-
- tC->confTab.filterEnabled[HIFILT] = pCfg->filterEnabled[HIFILT];
- tC->confTab.filterEnabled[LOFILT] = pCfg->filterEnabled[LOFILT];
- tC->confTab.seperateFiltersAllowed = pCfg->seperateFiltersAllowed;
-
- FDKaacEnc_CalcGaussWindow(tC->acfWindow[HIFILT], tC->maxOrder+1, sampleRate, granuleLength, pCfg->tnsTimeResolution[HIFILT], TNS_TIMERES_SCALE);
- FDKaacEnc_CalcGaussWindow(tC->acfWindow[LOFILT], tC->maxOrder+1, sampleRate, granuleLength, pCfg->tnsTimeResolution[LOFILT], TNS_TIMERES_SCALE);
- }
- else {
- tC->tnsActive = FALSE; /* no configuration available, disable tns tool */
- }
- }
- break;
- default:
- tC->tnsActive = FALSE; /* no configuration available, disable tns tool */
- }
-
- return AAC_ENC_OK;
-
-}
-
-/***************************************************************************/
-/*!
- \brief FDKaacEnc_ScaleUpSpectrum
-
- Scales up spectrum lines in a given frequency section
-
- \param scaled spectrum
- \param original spectrum
- \param frequency line to start scaling
- \param frequency line to enc scaling
-
- \return scale factor
-
-****************************************************************************/
-static inline INT FDKaacEnc_ScaleUpSpectrum(
- FIXP_DBL *dest,
- const FIXP_DBL *src,
- const INT startLine,
- const INT stopLine
- )
-{
- INT i, scale;
-
- FIXP_DBL maxVal = FL2FXCONST_DBL(0.f);
-
- /* Get highest value in given spectrum */
- for (i=startLine; i<stopLine; i++) {
- maxVal = fixMax(maxVal,fixp_abs(src[i]));
- }
- scale = CountLeadingBits(maxVal);
-
- /* Scale spectrum according to highest value */
- for (i=startLine; i<stopLine; i++) {
- dest[i] = src[i]<<scale;
- }
-
- return scale;
-}
-
-/***************************************************************************/
-/*!
- \brief FDKaacEnc_CalcAutoCorrValue
-
- Calculate autocorellation value for one lag
-
- \param pointer to spectrum
- \param start line
- \param stop line
- \param lag to be calculated
- \param scaling of the lag
-
-****************************************************************************/
-static inline FIXP_DBL FDKaacEnc_CalcAutoCorrValue(
- const FIXP_DBL *spectrum,
- const INT startLine,
- const INT stopLine,
- const INT lag,
- const INT scale
- )
-{
- int i;
- FIXP_DBL result = FL2FXCONST_DBL(0.f);
-
- if (lag==0) {
- for (i=startLine; i<stopLine; i++) {
- result += (fPow2(spectrum[i])>>scale);
- }
- }
- else {
- for (i=startLine; i<(stopLine-lag); i++) {
- result += (fMult(spectrum[i], spectrum[i+lag])>>scale);
- }
- }
-
- return result;
-}
-
-/***************************************************************************/
-/*!
- \brief FDKaacEnc_AutoCorrNormFac
-
- Autocorrelation function for 1st and 2nd half of the spectrum
-
- \param pointer to spectrum
- \param pointer to autocorrelation window
- \param filter start line
-
-****************************************************************************/
-static inline FIXP_DBL FDKaacEnc_AutoCorrNormFac(
- const FIXP_DBL value,
- const INT scale,
- INT *sc
- )
-{
- #define HLM_MIN_NRG 0.0000000037252902984619140625f /* 2^-28 */
- #define MAX_INV_NRGFAC (1.f/HLM_MIN_NRG)
-
- FIXP_DBL retValue;
- FIXP_DBL A, B;
-
- if (scale>=0) {
- A = value;
- B = FL2FXCONST_DBL(HLM_MIN_NRG)>>fixMin(DFRACT_BITS-1,scale);
- }
- else {
- A = value>>fixMin(DFRACT_BITS-1,(-scale));
- B = FL2FXCONST_DBL(HLM_MIN_NRG);
- }
-
- if (A > B) {
- int shift = 0;
- FIXP_DBL tmp = invSqrtNorm2(value,&shift);
-
- retValue = fMult(tmp,tmp);
- *sc += (2*shift);
- }
- else {
- /* MAX_INV_NRGFAC*FDKpow(2,-28) = 1/2^-28 * 2^-28 = 1.0 */
- retValue = /*FL2FXCONST_DBL(MAX_INV_NRGFAC*FDKpow(2,-28))*/ (FIXP_DBL)MAXVAL_DBL;
- *sc += scale+28;
- }
-
- return retValue;
-}
-
-static void FDKaacEnc_MergedAutoCorrelation(
- const FIXP_DBL *spectrum,
- const FIXP_DBL acfWindow[MAX_NUM_OF_FILTERS][TNS_MAX_ORDER+3+1],
- const INT lpcStartLine[MAX_NUM_OF_FILTERS],
- const INT lpcStopLine,
- const INT maxOrder,
- const INT acfSplit[MAX_NUM_OF_FILTERS],
- FIXP_DBL *_rxx1,
- FIXP_DBL *_rxx2
- )
-{
- int i, idx0, idx1, idx2, idx3, idx4, lag;
- FIXP_DBL rxx1_0, rxx2_0, rxx3_0, rxx4_0;
-
- /* buffer for temporal spectrum */
- C_ALLOC_SCRATCH_START(pSpectrum, FIXP_DBL, (1024));
-
- /* pre-initialization output */
- FDKmemclear(&_rxx1[0], sizeof(FIXP_DBL)*(maxOrder+1));
- FDKmemclear(&_rxx2[0], sizeof(FIXP_DBL)*(maxOrder+1));
-
- /* MDCT line indices separating the 1st, 2nd, 3rd, and 4th analysis quarters */
- if ( (acfSplit[LOFILT]==-1) || (acfSplit[HIFILT]==-1) ) {
- /* autocorrelation function for 1st, 2nd, 3rd, and 4th quarter of the spectrum */
- idx0 = lpcStartLine[LOFILT];
- i = lpcStopLine - lpcStartLine[LOFILT];
- idx1 = idx0 + i / 4;
- idx2 = idx0 + i / 2;
- idx3 = idx0 + i * 3 / 4;
- idx4 = lpcStopLine;
- }
- else {
- FDK_ASSERT(acfSplit[LOFILT]==1);
- FDK_ASSERT(acfSplit[HIFILT]==3);
- i = (lpcStopLine - lpcStartLine[HIFILT]) / 3;
- idx0 = lpcStartLine[LOFILT];
- idx1 = lpcStartLine[HIFILT];
- idx2 = idx1 + i;
- idx3 = idx2 + i;
- idx4 = lpcStopLine;
- }
-
- /* copy spectrum to temporal buffer and scale up as much as possible */
- INT sc1 = FDKaacEnc_ScaleUpSpectrum(pSpectrum, spectrum, idx0, idx1);
- INT sc2 = FDKaacEnc_ScaleUpSpectrum(pSpectrum, spectrum, idx1, idx2);
- INT sc3 = FDKaacEnc_ScaleUpSpectrum(pSpectrum, spectrum, idx2, idx3);
- INT sc4 = FDKaacEnc_ScaleUpSpectrum(pSpectrum, spectrum, idx3, idx4);
-
- /* get scaling values for summation */
- INT nsc1, nsc2, nsc3, nsc4;
- for (nsc1=1; (1<<nsc1)<(idx1-idx0); nsc1++);
- for (nsc2=1; (1<<nsc2)<(idx2-idx1); nsc2++);
- for (nsc3=1; (1<<nsc3)<(idx3-idx2); nsc3++);
- for (nsc4=1; (1<<nsc4)<(idx4-idx3); nsc4++);
-
- /* compute autocorrelation value at lag zero, i. e. energy, for each quarter */
- rxx1_0 = FDKaacEnc_CalcAutoCorrValue(pSpectrum, idx0, idx1, 0, nsc1);
- rxx2_0 = FDKaacEnc_CalcAutoCorrValue(pSpectrum, idx1, idx2, 0, nsc2);
- rxx3_0 = FDKaacEnc_CalcAutoCorrValue(pSpectrum, idx2, idx3, 0, nsc3);
- rxx4_0 = FDKaacEnc_CalcAutoCorrValue(pSpectrum, idx3, idx4, 0, nsc4);
-
- /* compute energy normalization factors, i. e. 1/energy (saves some divisions) */
- if (rxx1_0 != FL2FXCONST_DBL(0.f))
- {
- INT sc_fac1 = -1;
- FIXP_DBL fac1 = FDKaacEnc_AutoCorrNormFac(rxx1_0, ((-2*sc1)+nsc1), &sc_fac1);
- _rxx1[0] = scaleValue(fMult(rxx1_0,fac1),sc_fac1);
-
- for (lag = 1; lag <= maxOrder; lag++) {
- /* compute energy-normalized and windowed autocorrelation values at this lag */
- if ((3 * lag) <= maxOrder + 3) {
- FIXP_DBL x1 = FDKaacEnc_CalcAutoCorrValue(pSpectrum, idx0, idx1, lag, nsc1);
- _rxx1[lag] = fMult(scaleValue(fMult(x1,fac1),sc_fac1), acfWindow[LOFILT][3*lag]);
- }
- }
- }
-
- /* auto corr over upper 3/4 of spectrum */
- if ( !((rxx2_0 == FL2FXCONST_DBL(0.f)) && (rxx3_0 == FL2FXCONST_DBL(0.f)) && (rxx4_0 == FL2FXCONST_DBL(0.f))) )
- {
- FIXP_DBL fac2, fac3, fac4;
- fac2 = fac3 = fac4 = FL2FXCONST_DBL(0.f);
- INT sc_fac2, sc_fac3, sc_fac4;
- sc_fac2 = sc_fac3 = sc_fac4 = 0;
-
- if (rxx2_0!=FL2FXCONST_DBL(0.f)) {
- fac2 = FDKaacEnc_AutoCorrNormFac(rxx2_0, ((-2*sc2)+nsc2), &sc_fac2);
- sc_fac2 -= 2;
- }
- if (rxx3_0!=FL2FXCONST_DBL(0.f)) {
- fac3 = FDKaacEnc_AutoCorrNormFac(rxx3_0, ((-2*sc3)+nsc3), &sc_fac3);
- sc_fac3 -= 2;
- }
- if (rxx4_0!=FL2FXCONST_DBL(0.f)) {
- fac4 = FDKaacEnc_AutoCorrNormFac(rxx4_0, ((-2*sc4)+nsc4), &sc_fac4);
- sc_fac4 -= 2;
- }
-
- _rxx2[0] = scaleValue(fMult(rxx2_0,fac2),sc_fac2) +
- scaleValue(fMult(rxx3_0,fac3),sc_fac3) +
- scaleValue(fMult(rxx4_0,fac4),sc_fac4);
-
- for (lag = 1; lag <= maxOrder; lag++) {
- /* merge quarters 2, 3, 4 into one autocorrelation; quarter 1 stays separate */
- FIXP_DBL x2 = scaleValue(fMult(FDKaacEnc_CalcAutoCorrValue(pSpectrum, idx1, idx2, lag, nsc2), fac2),sc_fac2) +
- scaleValue(fMult(FDKaacEnc_CalcAutoCorrValue(pSpectrum, idx2, idx3, lag, nsc3), fac3),sc_fac3) +
- scaleValue(fMult(FDKaacEnc_CalcAutoCorrValue(pSpectrum, idx3, idx4, lag, nsc4), fac4),sc_fac4);
-
- _rxx2[lag] = fMult(x2, acfWindow[HIFILT][lag]);
- }
- }
-
- C_ALLOC_SCRATCH_END(pSpectrum, FIXP_DBL, (1024));
-}
-
-
-/*****************************************************************************
- functionname: FDKaacEnc_TnsDetect
- description: do decision, if TNS shall be used or not
- returns:
- input: tns data structure (modified),
- tns config structure,
- scalefactor size and table,
- spectrum,
- subblock num, blocktype,
- sfb-wise energy.
-
-*****************************************************************************/
-INT FDKaacEnc_TnsDetect(
- TNS_DATA *tnsData,
- const TNS_CONFIG *tC,
- TNS_INFO* tnsInfo,
- INT sfbCnt,
- FIXP_DBL *spectrum,
- INT subBlockNumber,
- INT blockType
- )
-{
- /* autocorrelation function for 1st, 2nd, 3rd, and 4th quarter of the spectrum. */
- FIXP_DBL rxx1[TNS_MAX_ORDER+1]; /* higher part */
- FIXP_DBL rxx2[TNS_MAX_ORDER+1]; /* lower part */
- FIXP_DBL parcor_tmp[TNS_MAX_ORDER];
-
- int i;
-
- TNS_SUBBLOCK_INFO *tsbi = (blockType == SHORT_WINDOW)
- ? &tnsData->dataRaw.Short.subBlockInfo[subBlockNumber]
- : &tnsData->dataRaw.Long.subBlockInfo;
-
- tnsData->filtersMerged = FALSE;
- tsbi->tnsActive = FALSE;
- tsbi->predictionGain = 1000;
- tnsInfo->numOfFilters[subBlockNumber] = 0;
- tnsInfo->coefRes[subBlockNumber] = tC->coefRes;
- for (i = 0; i < tC->maxOrder; i++) {
- tnsInfo->coef[subBlockNumber][HIFILT][i] = tnsInfo->coef[subBlockNumber][LOFILT][i] = 0;
- }
-
- tnsInfo->length[subBlockNumber][HIFILT] = tnsInfo->length[subBlockNumber][LOFILT] = 0;
- tnsInfo->order [subBlockNumber][HIFILT] = tnsInfo->order [subBlockNumber][LOFILT] = 0;
-
- if ( (tC->tnsActive) && (tC->maxOrder>0) )
- {
- int sumSqrCoef;
-
- FDKaacEnc_MergedAutoCorrelation(
- spectrum,
- tC->acfWindow,
- tC->lpcStartLine,
- tC->lpcStopLine,
- tC->maxOrder,
- tC->confTab.acfSplit,
- rxx1,
- rxx2);
-
- /* compute higher TNS filter in lattice (ParCor) form with LeRoux-Gueguen algorithm */
- tsbi->predictionGain = FDKaacEnc_AutoToParcor(rxx2, parcor_tmp, tC->confTab.tnsLimitOrder[HIFILT]);
-
- /* non-linear quantization of TNS lattice coefficients with given resolution */
- FDKaacEnc_Parcor2Index(
- parcor_tmp,
- tnsInfo->coef[subBlockNumber][HIFILT],
- tC->confTab.tnsLimitOrder[HIFILT],
- tC->coefRes);
-
- /* reduce filter order by truncating trailing zeros, compute sum(abs(coefs)) */
- for (i = tC->confTab.tnsLimitOrder[HIFILT] - 1; i >= 0; i--) {
- if (tnsInfo->coef[subBlockNumber][HIFILT][i] != 0) {
- break;
- }
- }
-
- tnsInfo->order[subBlockNumber][HIFILT] = i + 1;
-
- sumSqrCoef = 0;
- for (; i >= 0; i--) {
- sumSqrCoef += tnsInfo->coef[subBlockNumber][HIFILT][i] * tnsInfo->coef[subBlockNumber][HIFILT][i];
- }
-
- tnsInfo->direction[subBlockNumber][HIFILT] = tC->confTab.tnsFilterDirection[HIFILT];
- tnsInfo->length[subBlockNumber][HIFILT] = sfbCnt - tC->lpcStartBand[HIFILT];
-
- /* disable TNS if predictionGain is less than 3dB or sumSqrCoef is too small */
- if ((tsbi->predictionGain > tC->confTab.threshOn[HIFILT]) || (sumSqrCoef > (tC->confTab.tnsLimitOrder[HIFILT]/2 + 2)))
- {
- tsbi->tnsActive = TRUE;
- tnsInfo->numOfFilters[subBlockNumber]++;
-
- /* compute second filter for lower quarter; only allowed for long windows! */
- if ( (blockType != SHORT_WINDOW) &&
- (tC->confTab.filterEnabled[LOFILT]) && (tC->confTab.seperateFiltersAllowed) )
- {
- /* compute second filter for lower frequencies */
-
- /* compute TNS filter in lattice (ParCor) form with LeRoux-Gueguen algorithm */
- INT predGain = FDKaacEnc_AutoToParcor(rxx1, parcor_tmp, tC->confTab.tnsLimitOrder[LOFILT]);
-
- /* non-linear quantization of TNS lattice coefficients with given resolution */
- FDKaacEnc_Parcor2Index(
- parcor_tmp,
- tnsInfo->coef[subBlockNumber][LOFILT],
- tC->confTab.tnsLimitOrder[LOFILT],
- tC->coefRes);
-
- /* reduce filter order by truncating trailing zeros, compute sum(abs(coefs)) */
- for (i = tC->confTab.tnsLimitOrder[LOFILT] - 1; i >= 0; i--) {
- if (tnsInfo->coef[subBlockNumber][LOFILT][i] != 0) {
- break;
- }
- }
- tnsInfo->order[subBlockNumber][LOFILT] = i + 1;
-
- sumSqrCoef = 0;
- for (; i >= 0; i--) {
- sumSqrCoef += tnsInfo->coef[subBlockNumber][LOFILT][i] * tnsInfo->coef[subBlockNumber][LOFILT][i];
- }
-
- tnsInfo->direction[subBlockNumber][LOFILT] = tC->confTab.tnsFilterDirection[LOFILT];
- tnsInfo->length[subBlockNumber][LOFILT] = tC->lpcStartBand[HIFILT] - tC->lpcStartBand[LOFILT];
-
- /* filter lower quarter if gain is high enough, but not if it's too high */
- if ( ( (predGain > tC->confTab.threshOn[LOFILT]) && (predGain < (16000 * tC->confTab.tnsLimitOrder[LOFILT])) )
- || ( (sumSqrCoef > 9) && (sumSqrCoef < 22 * tC->confTab.tnsLimitOrder[LOFILT]) ) )
- {
- /* compare lower to upper filter; if they are very similar, merge them */
- sumSqrCoef = 0;
- for (i = 0; i < tC->confTab.tnsLimitOrder[LOFILT]; i++) {
- sumSqrCoef += FDKabs(tnsInfo->coef[subBlockNumber][HIFILT][i] - tnsInfo->coef[subBlockNumber][LOFILT][i]);
- }
- if ( (sumSqrCoef < 2) &&
- (tnsInfo->direction[subBlockNumber][LOFILT] == tnsInfo->direction[subBlockNumber][HIFILT]) )
- {
- tnsData->filtersMerged = TRUE;
- tnsInfo->length[subBlockNumber][HIFILT] = sfbCnt - tC->lpcStartBand[LOFILT];
- for (; i < tnsInfo->order[subBlockNumber][HIFILT]; i++) {
- if (FDKabs(tnsInfo->coef[subBlockNumber][HIFILT][i]) > 1) {
- break;
- }
- }
- for (i--; i >= 0; i--) {
- if (tnsInfo->coef[subBlockNumber][HIFILT][i] != 0) {
- break;
- }
- }
- if (i < tnsInfo->order[subBlockNumber][HIFILT]) {
- tnsInfo->order[subBlockNumber][HIFILT] = i + 1;
- }
- }
- else {
- tnsInfo->numOfFilters[subBlockNumber]++;
- }
- } /* filter lower part */
- } /* second filter allowed */
- } /* if predictionGain > 1437 ... */
- } /* maxOrder > 0 && tnsActive */
-
- return 0;
-
-}
-
-
-/***************************************************************************/
-/*!
- \brief FDKaacLdEnc_TnsSync
-
- synchronize TNS parameters when TNS gain difference small (relative)
-
- \param pointer to TNS data structure (destination)
- \param pointer to TNS data structure (source)
- \param pointer to TNS config structure
- \param number of sub-block
- \param block type
-
- \return void
-****************************************************************************/
-void FDKaacEnc_TnsSync(
- TNS_DATA *tnsDataDest,
- const TNS_DATA *tnsDataSrc,
- TNS_INFO *tnsInfoDest,
- TNS_INFO *tnsInfoSrc,
- const INT blockTypeDest,
- const INT blockTypeSrc,
- const TNS_CONFIG *tC
- )
-{
- int i, w, absDiff, nWindows;
- TNS_SUBBLOCK_INFO *sbInfoDest;
- const TNS_SUBBLOCK_INFO *sbInfoSrc;
-
- /* if one channel contains short blocks and the other not, do not synchronize */
- if ( (blockTypeSrc == SHORT_WINDOW && blockTypeDest != SHORT_WINDOW) ||
- (blockTypeDest == SHORT_WINDOW && blockTypeSrc != SHORT_WINDOW) )
- {
- return;
- }
-
- if (blockTypeDest != SHORT_WINDOW) {
- sbInfoDest = &tnsDataDest->dataRaw.Long.subBlockInfo;
- sbInfoSrc = &tnsDataSrc->dataRaw.Long.subBlockInfo;
- nWindows = 1;
- } else {
- sbInfoDest = &tnsDataDest->dataRaw.Short.subBlockInfo[0];
- sbInfoSrc = &tnsDataSrc->dataRaw.Short.subBlockInfo[0];
- nWindows = 8;
- }
-
- for (w=0; w<nWindows; w++) {
- const TNS_SUBBLOCK_INFO *pSbInfoSrcW = sbInfoSrc + w;
- TNS_SUBBLOCK_INFO *pSbInfoDestW = sbInfoDest + w;
- INT doSync = 1, absDiffSum = 0;
-
- /* if TNS is active in at least one channel, check if ParCor coefficients of higher filter are similar */
- if (pSbInfoDestW->tnsActive || pSbInfoSrcW->tnsActive) {
- for (i = 0; i < tC->maxOrder; i++) {
- absDiff = FDKabs(tnsInfoDest->coef[w][HIFILT][i] - tnsInfoSrc->coef[w][HIFILT][i]);
- absDiffSum += absDiff;
- /* if coefficients diverge too much between channels, do not synchronize */
- if ((absDiff > 1) || (absDiffSum > 2)) {
- doSync = 0;
- break;
- }
- }
-
- if (doSync) {
- /* if no significant difference was detected, synchronize coefficient sets */
- if (pSbInfoSrcW->tnsActive) {
- /* no dest filter, or more dest than source filters: use one dest filter */
- if ((!pSbInfoDestW->tnsActive) ||
- ((pSbInfoDestW->tnsActive) && (tnsInfoDest->numOfFilters[w] > tnsInfoSrc->numOfFilters[w])))
- {
- pSbInfoDestW->tnsActive = tnsInfoDest->numOfFilters[w] = 1;
- }
- tnsDataDest->filtersMerged = tnsDataSrc->filtersMerged;
- tnsInfoDest->order [w][HIFILT] = tnsInfoSrc->order [w][HIFILT];
- tnsInfoDest->length [w][HIFILT] = tnsInfoSrc->length [w][HIFILT];
- tnsInfoDest->direction [w][HIFILT] = tnsInfoSrc->direction [w][HIFILT];
- tnsInfoDest->coefCompress[w][HIFILT] = tnsInfoSrc->coefCompress[w][HIFILT];
-
- for (i = 0; i < tC->maxOrder; i++) {
- tnsInfoDest->coef[w][HIFILT][i] = tnsInfoSrc->coef[w][HIFILT][i];
- }
- }
- else
- pSbInfoDestW->tnsActive = tnsInfoDest->numOfFilters[w] = 0;
- }
- }
-
- }
-}
-
-/***************************************************************************/
-/*!
- \brief FDKaacEnc_TnsEncode
-
- perform TNS encoding
-
- \param pointer to TNS info structure
- \param pointer to TNS data structure
- \param number of sfbs
- \param pointer to TNS config structure
- \param low-pass line
- \param pointer to spectrum
- \param number of sub-block
- \param block type
-
- \return ERROR STATUS
-****************************************************************************/
-INT FDKaacEnc_TnsEncode(
- TNS_INFO* tnsInfo,
- TNS_DATA* tnsData,
- const INT numOfSfb,
- const TNS_CONFIG *tC,
- const INT lowPassLine,
- FIXP_DBL* spectrum,
- const INT subBlockNumber,
- const INT blockType
- )
-{
- INT i, startLine, stopLine;
-
- if ( ( (blockType == SHORT_WINDOW) && (!tnsData->dataRaw.Short.subBlockInfo[subBlockNumber].tnsActive) )
- || ( (blockType != SHORT_WINDOW) && (!tnsData->dataRaw.Long.subBlockInfo.tnsActive) ) )
- {
- return 1;
- }
-
- startLine = (tnsData->filtersMerged) ? tC->lpcStartLine[LOFILT] : tC->lpcStartLine[HIFILT];
- stopLine = tC->lpcStopLine;
-
- for (i=0; i<tnsInfo->numOfFilters[subBlockNumber]; i++) {
-
- INT lpcGainFactor;
- FIXP_DBL LpcCoeff[TNS_MAX_ORDER];
- FIXP_DBL workBuffer[TNS_MAX_ORDER];
- FIXP_DBL parcor_tmp[TNS_MAX_ORDER];
-
- FDKaacEnc_Index2Parcor(
- tnsInfo->coef[subBlockNumber][i],
- parcor_tmp,
- tnsInfo->order[subBlockNumber][i],
- tC->coefRes);
-
- lpcGainFactor = FDKaacEnc_ParcorToLpc(
- parcor_tmp,
- LpcCoeff,
- tnsInfo->order[subBlockNumber][i],
- workBuffer);
-
- FDKaacEnc_AnalysisFilter(
- &spectrum[startLine],
- stopLine - startLine,
- LpcCoeff,
- tnsInfo->order[subBlockNumber][i],
- lpcGainFactor);
-
- /* update for second filter */
- startLine = tC->lpcStartLine[LOFILT];
- stopLine = tC->lpcStartLine[HIFILT];
- }
-
- return(0);
-
-}
-
-static void FDKaacEnc_CalcGaussWindow(
- FIXP_DBL *win,
- const int winSize,
- const INT samplingRate,
- const INT transformResolution,
- const FIXP_DBL timeResolution,
- const INT timeResolution_e
- )
-{
- #define PI_E (2)
- #define PI_M FL2FXCONST_DBL(3.1416f/(float)(1<<PI_E))
-
- #define EULER_E (2)
- #define EULER_M FL2FXCONST_DBL(2.7183/(float)(1<<EULER_E))
-
- #define COEFF_LOOP_SCALE (4)
-
- INT i, e1, e2, gaussExp_e;
- FIXP_DBL gaussExp_m;
-
- /* calc. window exponent from time resolution:
- *
- * gaussExp = PI * samplingRate * 0.001f * timeResolution / transformResolution;
- * gaussExp = -0.5f * gaussExp * gaussExp;
- */
- gaussExp_m = fMultNorm(timeResolution, fMult(PI_M, fDivNorm( (FIXP_DBL)(samplingRate), (FIXP_DBL)(LONG)(transformResolution*1000.f), &e1)), &e2);
- gaussExp_m = -fPow2Div2(gaussExp_m);
- gaussExp_e = 2*(e1+e2+timeResolution_e+PI_E);
-
- FDK_ASSERT( winSize < (1<<COEFF_LOOP_SCALE) );
-
- /* calc. window coefficients
- * win[i] = (float)exp( gaussExp * (i+0.5) * (i+0.5) );
- */
- for( i=0; i<winSize; i++) {
-
- win[i] = fPow(
- EULER_M,
- EULER_E,
- fMult(gaussExp_m, fPow2((i*FL2FXCONST_DBL(1.f/(float)(1<<COEFF_LOOP_SCALE)) + FL2FXCONST_DBL(.5f/(float)(1<<COEFF_LOOP_SCALE))))),
- gaussExp_e + 2*COEFF_LOOP_SCALE,
- &e1);
-
- win[i] = scaleValueSaturate(win[i], e1);
- }
-}
-
-
-/***************************************************************************/
-/*!
- \brief FDKaacEnc_AutoToParcor
-
- conversion autocorrelation to reflection coefficients
-
- \param pointer to input (acf)
- \param pointer to output (reflection coefficients)
- \param number of coefficients
-
- \return prediction gain
-****************************************************************************/
-static INT FDKaacEnc_AutoToParcor(
- FIXP_DBL *RESTRICT input,
- FIXP_DBL *RESTRICT reflCoeff,
- const INT numOfCoeff
- )
-{
- INT i, j, scale=0;
- FIXP_DBL tmp, parcorWorkBuffer[TNS_MAX_ORDER];
- INT predictionGain = (INT)(TNS_PREDGAIN_SCALE);
-
- FIXP_DBL *RESTRICT workBuffer = parcorWorkBuffer;
- const FIXP_DBL autoCorr_0 = input[0];
-
- if((FIXP_DBL)input[0] == FL2FXCONST_DBL(0.0)) {
- FDKmemclear(reflCoeff,numOfCoeff*sizeof(FIXP_DBL));
- return(predictionGain);
- }
-
- FDKmemcpy(workBuffer,&input[1],numOfCoeff*sizeof(FIXP_DBL));
- for(i=0; i<numOfCoeff; i++) {
- LONG sign = ((LONG)workBuffer[0] >> (DFRACT_BITS-1));
- tmp = (FIXP_DBL)((LONG)workBuffer[0]^sign);
-
- if(input[0]<tmp)
- break;
-
- tmp = (FIXP_DBL)((LONG)schur_div(tmp, input[0], FRACT_BITS)^(~sign));
- reflCoeff[i] = tmp;
-
- for(j=numOfCoeff-i-1; j>=0; j--) {
- FIXP_DBL accu1 = fMult(tmp, input[j]);
- FIXP_DBL accu2 = fMult(tmp, workBuffer[j]);
- workBuffer[j] += accu1;
- input[j] += accu2;
- }
-
- workBuffer++;
- }
-
- tmp = fMult((FIXP_DBL)((LONG)TNS_PREDGAIN_SCALE<<21), fDivNorm(fAbs(autoCorr_0), fAbs(input[0]), &scale));
- if ( fMultDiv2(autoCorr_0, input[0])<FL2FXCONST_DBL(0.0f) ) {
- tmp = -tmp;
- }
- predictionGain = (LONG)scaleValue(tmp,scale-21);
-
- return (predictionGain);
-}
-
-
-static INT FDKaacEnc_Search3(FIXP_DBL parcor)
-{
- INT i, index=0;
-
- for(i=0;i<8;i++){
- if(parcor > FDKaacEnc_tnsCoeff3Borders[i])
- index=i;
- }
- return(index-4);
-}
-
-static INT FDKaacEnc_Search4(FIXP_DBL parcor)
-{
- INT i, index=0;
-
- for(i=0;i<16;i++){
- if(parcor > FDKaacEnc_tnsCoeff4Borders[i])
- index=i;
- }
- return(index-8);
-}
-
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_Parcor2Index
-
-*****************************************************************************/
-static void FDKaacEnc_Parcor2Index(
- const FIXP_DBL *parcor,
- INT *RESTRICT index,
- const INT order,
- const INT bitsPerCoeff
- )
-{
- INT i;
- for(i=0; i<order; i++) {
- if(bitsPerCoeff == 3)
- index[i] = FDKaacEnc_Search3(parcor[i]);
- else
- index[i] = FDKaacEnc_Search4(parcor[i]);
- }
-}
-
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_Index2Parcor
- description: inverse quantization for reflection coefficients
- returns: -
- input: quantized values, ptr. to reflection coefficients,
- no. of coefficients, resolution
- output: reflection coefficients
-
-*****************************************************************************/
-static void FDKaacEnc_Index2Parcor(
- const INT *index,
- FIXP_DBL *RESTRICT parcor,
- const INT order,
- const INT bitsPerCoeff
- )
-{
- INT i;
- for(i=0; i<order; i++)
- parcor[i] = bitsPerCoeff == 4 ? FDKaacEnc_tnsEncCoeff4[index[i]+8] : FDKaacEnc_tnsEncCoeff3[index[i]+4];
-}
-
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_ParcorToLpc
- description: conversion reflection coefficients to LPC coefficients
- returns: Gain factor
- input: reflection coefficients, no. of reflection coefficients <order>,
- ptr. to work buffer (required size: order)
- output: <order> LPC coefficients
-
-*****************************************************************************/
-static INT FDKaacEnc_ParcorToLpc(
- const FIXP_DBL *reflCoeff,
- FIXP_DBL *RESTRICT LpcCoeff,
- const INT numOfCoeff,
- FIXP_DBL *RESTRICT workBuffer
- )
-{
- INT i, j;
- INT shiftval, par2LpcShiftVal = 6; /* 6 should be enough, bec. max(numOfCoeff) = 20 */
- FIXP_DBL maxVal = FL2FXCONST_DBL(0.0f);
-
- LpcCoeff[0] = reflCoeff[0] >> par2LpcShiftVal;
- for(i=1; i<numOfCoeff; i++) {
- for(j=0; j<i; j++) {
- workBuffer[j] = LpcCoeff[i-1-j];
- }
-
- for(j=0; j<i; j++) {
- LpcCoeff[j] += fMult(reflCoeff[i],workBuffer[j]);
- }
-
- LpcCoeff[i] = reflCoeff[i] >> par2LpcShiftVal;
- }
-
- /* normalize LpcCoeff and calc shiftfactor */
- for(i=0; i<numOfCoeff; i++) {
- maxVal = fixMax(maxVal,(FIXP_DBL)fixp_abs(LpcCoeff[i]));
- }
-
- shiftval = CountLeadingBits(maxVal);
- shiftval = (shiftval>=par2LpcShiftVal) ? par2LpcShiftVal : shiftval;
-
- for(i=0; i<numOfCoeff; i++)
- LpcCoeff[i] = LpcCoeff[i]<<shiftval;
-
- return (par2LpcShiftVal - shiftval);
-}
-
-/***************************************************************************/
-/*!
- \brief FDKaacEnc_AnalysisFilter
-
- TNS analysis filter (all-zero filter)
-
- \param pointer to signal spectrum
- \param number of lines
- \param pointer to lpc coefficients
- \param filter order
- \param lpc gain factor
-
- \return void
-****************************************************************************/
-/* Note: in-place computation possible */
-static void FDKaacEnc_AnalysisFilter(
- FIXP_DBL *RESTRICT signal,
- const INT numOfLines,
- const FIXP_DBL *predictorCoeff,
- const INT order,
- const INT lpcGainFactor
- )
-{
- FIXP_DBL statusVar[TNS_MAX_ORDER];
- INT i, j;
- const INT shift = lpcGainFactor + 1; /* +1, because fMultDiv2 */
- FIXP_DBL tmp;
-
- if (order>0) {
-
- INT idx = 0;
-
- /* keep filter coefficients twice and save memory copy operation in
- modulo state buffer */
-#if defined(ARCH_PREFER_MULT_32x16)
- FIXP_SGL coeff[2*TNS_MAX_ORDER];
- const FIXP_SGL *pCoeff;
- for(i=0;i<order;i++) {
- coeff[i] = FX_DBL2FX_SGL(predictorCoeff[i]);
- }
- FDKmemcpy(&coeff[order], coeff, order*sizeof(FIXP_SGL));
-#else
- FIXP_DBL coeff[2*TNS_MAX_ORDER];
- const FIXP_DBL *pCoeff;
- FDKmemcpy(&coeff[0], predictorCoeff, order*sizeof(FIXP_DBL));
- FDKmemcpy(&coeff[order], predictorCoeff, order*sizeof(FIXP_DBL));
-#endif
- FDKmemclear(statusVar, order*sizeof(FIXP_DBL));
-
- for(j=0; j<numOfLines; j++) {
- pCoeff = &coeff[(order-idx)];
- tmp = FL2FXCONST_DBL(0);
- for(i=0; i<order; i++) {
- tmp = fMultAddDiv2(tmp, pCoeff[i], statusVar[i]) ;
- }
-
- if(--idx<0) { idx = order-1; }
- statusVar[idx] = signal[j];
-
- FDK_ASSERT(lpcGainFactor>=0);
- signal[j] = (tmp<<shift) + signal[j];
- }
- }
-}
-
-
diff --git a/libAACenc/src/aacenc_tns.h b/libAACenc/src/aacenc_tns.h
deleted file mode 100644
index f2b731f..0000000
--- a/libAACenc/src/aacenc_tns.h
+++ /dev/null
@@ -1,198 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: Alex Groeschel
- contents/description: Temporal noise shaping
-
-******************************************************************************/
-
-#ifndef _TNS_H
-#define _TNS_H
-
-#include "common_fix.h"
-
-#include "psy_const.h"
-
-
-#ifndef PI
-#define PI 3.1415926535897931f
-#endif
-
-/**
- * TNS_ENABLE_MASK
- * This bitfield defines which TNS features are enabled
- * The TNS mask is composed of 4 bits.
- * tnsMask |= 0x1; activate TNS short blocks
- * tnsMask |= 0x2; activate TNS for long blocks
- * tnsMask |= 0x4; activate TNS PEAK tool for short blocks
- * tnsMask |= 0x8; activate TNS PEAK tool for long blocks
- */
-#define TNS_ENABLE_MASK 0xf
-
-/* TNS max filter order for Low Complexity MPEG4 profile */
-#define TNS_MAX_ORDER 12
-
-
-#define MAX_NUM_OF_FILTERS 2
-
-
-typedef struct{ /*stuff that is tabulated dependent on bitrate etc. */
- INT filterEnabled[MAX_NUM_OF_FILTERS];
- INT threshOn[MAX_NUM_OF_FILTERS]; /* min. prediction gain for using tns TABUL*/
- INT tnsLimitOrder[MAX_NUM_OF_FILTERS]; /* Limit for TNS order TABUL*/
- INT tnsFilterDirection[MAX_NUM_OF_FILTERS]; /* Filtering direction, 0=up, 1=down TABUL */
- INT acfSplit[MAX_NUM_OF_FILTERS];
- INT seperateFiltersAllowed;
-
-}TNS_CONFIG_TABULATED;
-
-
-
-typedef struct { /*assigned at InitTime*/
- TNS_CONFIG_TABULATED confTab;
- INT tnsActive;
- INT maxOrder; /* max. order of tns filter */
- INT coefRes;
- FIXP_DBL acfWindow[MAX_NUM_OF_FILTERS][TNS_MAX_ORDER+3+1];
- /* now some things that only probably can be done at Init time;
- could be they have to be split up for each individual (short) window or
- even filter. */
- INT lpcStartBand[MAX_NUM_OF_FILTERS];
- INT lpcStartLine[MAX_NUM_OF_FILTERS];
- INT lpcStopBand;
- INT lpcStopLine;
-
-}TNS_CONFIG;
-
-
-typedef struct {
- INT tnsActive;
- INT predictionGain;
-} TNS_SUBBLOCK_INFO;
-
-typedef struct{ /*changed at runTime*/
- TNS_SUBBLOCK_INFO subBlockInfo[TRANS_FAC];
- FIXP_DBL ratioMultTable[TRANS_FAC][MAX_SFB_SHORT];
-} TNS_DATA_SHORT;
-
-typedef struct{ /*changed at runTime*/
- TNS_SUBBLOCK_INFO subBlockInfo;
- FIXP_DBL ratioMultTable[MAX_SFB_LONG];
-} TNS_DATA_LONG;
-
-/* can be implemented as union */
-typedef shouldBeUnion{
- TNS_DATA_LONG Long;
- TNS_DATA_SHORT Short;
-}TNS_DATA_RAW;
-
-typedef struct{
- INT numOfSubblocks;
- TNS_DATA_RAW dataRaw;
- INT tnsMaxScaleSpec;
- INT filtersMerged;
-}TNS_DATA;
-
-typedef struct{
- INT numOfFilters[TRANS_FAC];
- INT coefRes[TRANS_FAC];
- INT length[TRANS_FAC][MAX_NUM_OF_FILTERS];
- INT order[TRANS_FAC][MAX_NUM_OF_FILTERS];
- INT direction[TRANS_FAC][MAX_NUM_OF_FILTERS];
- INT coefCompress[TRANS_FAC][MAX_NUM_OF_FILTERS];
- /* for Long: length TNS_MAX_ORDER (12 for LC) is required -> 12 */
- /* for Short: length TRANS_FAC*TNS_MAX_ORDER (only 5 for short LC) is required -> 8*5=40 */
- /* Currently TRANS_FAC*TNS_MAX_ORDER = 8*12 = 96 (for LC) is used (per channel)! Memory could be saved here! */
- INT coef[TRANS_FAC][MAX_NUM_OF_FILTERS][TNS_MAX_ORDER];
-}TNS_INFO;
-
-INT FDKaacEnc_FreqToBandWithRounding(
- const INT freq,
- const INT fs,
- const INT numOfBands,
- const INT *bandStartOffset
- );
-
-#endif /* _TNS_H */
diff --git a/libAACenc/src/adj_thr.cpp b/libAACenc/src/adj_thr.cpp
deleted file mode 100644
index 6433633..0000000
--- a/libAACenc/src/adj_thr.cpp
+++ /dev/null
@@ -1,2631 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M. Werner
- contents/description: Threshold compensation
-
-******************************************************************************/
-
-#include "common_fix.h"
-
-#include "adj_thr_data.h"
-#include "adj_thr.h"
-#include "qc_data.h"
-#include "sf_estim.h"
-#include "aacEnc_ram.h"
-
-
-
-
-#define INV_INT_TAB_SIZE (8)
-static const FIXP_DBL invInt[INV_INT_TAB_SIZE] =
-{
- 0x7fffffff, 0x7fffffff, 0x40000000, 0x2aaaaaaa, 0x20000000, 0x19999999, 0x15555555, 0x12492492
-};
-
-
-#define INV_SQRT4_TAB_SIZE (8)
-static const FIXP_DBL invSqrt4[INV_SQRT4_TAB_SIZE] =
-{
- 0x7fffffff, 0x7fffffff, 0x6ba27e65, 0x61424bb5, 0x5a827999, 0x55994845, 0x51c8e33c, 0x4eb160d1
-};
-
-
-/*static const INT invRedExp = 4;*/
-static const FIXP_DBL SnrLdMin1 = (FIXP_DBL)0xfcad0ddf; /*FL2FXCONST_DBL(FDKlog(0.316)/FDKlog(2.0)/LD_DATA_SCALING);*/
-static const FIXP_DBL SnrLdMin2 = (FIXP_DBL)0x0351e1a2; /*FL2FXCONST_DBL(FDKlog(3.16) /FDKlog(2.0)/LD_DATA_SCALING);*/
-static const FIXP_DBL SnrLdFac = (FIXP_DBL)0xff5b2c3e; /*FL2FXCONST_DBL(FDKlog(0.8) /FDKlog(2.0)/LD_DATA_SCALING);*/
-
-static const FIXP_DBL SnrLdMin3 = (FIXP_DBL)0xfe000000; /*FL2FXCONST_DBL(FDKlog(0.5) /FDKlog(2.0)/LD_DATA_SCALING);*/
-static const FIXP_DBL SnrLdMin4 = (FIXP_DBL)0x02000000; /*FL2FXCONST_DBL(FDKlog(2.0) /FDKlog(2.0)/LD_DATA_SCALING);*/
-static const FIXP_DBL SnrLdMin5 = (FIXP_DBL)0xfc000000; /*FL2FXCONST_DBL(FDKlog(0.25) /FDKlog(2.0)/LD_DATA_SCALING);*/
-
-
-/*
-The bits2Pe factors are choosen for the case that some times
-the crash recovery strategy will be activated once.
-*/
-
-typedef struct {
- INT bitrate;
- LONG bits2PeFactor_mono;
- LONG bits2PeFactor_mono_slope;
- LONG bits2PeFactor_stereo;
- LONG bits2PeFactor_stereo_slope;
- LONG bits2PeFactor_mono_scfOpt;
- LONG bits2PeFactor_mono_scfOpt_slope;
- LONG bits2PeFactor_stereo_scfOpt;
- LONG bits2PeFactor_stereo_scfOpt_slope;
-
-} BIT_PE_SFAC;
-
-typedef struct {
- const INT sampleRate;
- const BIT_PE_SFAC * pPeTab;
- const INT nEntries;
-
-} BITS2PE_CFG_TAB;
-
-static const BIT_PE_SFAC S_Bits2PeTab16000[] = {
- { 10000, 0x228F5C29, 0x02FEF55D, 0x1D70A3D7, 0x09BC9D6D, 0x228F5C29, 0x02FEF55D, 0x1C28F5C3, 0x0CBB92CA},
- { 24000, 0x23D70A3D, 0x029F16B1, 0x2199999A, 0x07DD4413, 0x23D70A3D, 0x029F16B1, 0x2199999A, 0x07DD4413},
- { 32000, 0x247AE148, 0x11B1D92B, 0x23851EB8, 0x01F75105, 0x247AE148, 0x110A137F, 0x23851EB8, 0x01F75105},
- { 48000, 0x2D1EB852, 0x6833C600, 0x247AE148, 0x014F8B59, 0x2CCCCCCD, 0x68DB8BAC, 0x247AE148, 0x01F75105},
- { 64000, 0x60000000, 0x00000000, 0x251EB852, 0x154C985F, 0x60000000, 0x00000000, 0x2570A3D7, 0x154C985F},
- { 96000, 0x60000000, 0x00000000, 0x39EB851F, 0x088509C0, 0x60000000, 0x00000000, 0x3A3D70A4, 0x088509C0},
- {128000, 0x60000000, 0x00000000, 0x423D70A4, 0x18A43BB4, 0x60000000, 0x00000000, 0x428F5C29, 0x181E03F7},
- {148000, 0x60000000, 0x00000000, 0x5147AE14, 0x00000000, 0x60000000, 0x00000000, 0x5147AE14, 0x00000000}
-};
-
-static const BIT_PE_SFAC S_Bits2PeTab22050[] = {
- { 16000, 0x1a8f5c29, 0x1797cc3a, 0x128f5c29, 0x18e75793, 0x175c28f6, 0x221426fe, 0x00000000, 0x5a708ede},
- { 24000, 0x2051eb85, 0x092ccf6c, 0x18a3d70a, 0x13a92a30, 0x1fae147b, 0xbcbe61d, 0x16147ae1, 0x18e75793},
- { 32000, 0x228f5c29, 0x029f16b1, 0x1d70a3d7, 0x088509c0, 0x228f5c29, 0x29f16b1, 0x1c28f5c3, 0x0b242071},
- { 48000, 0x23d70a3d, 0x014f8b59, 0x2199999a, 0x03eea20a, 0x23d70a3d, 0x14f8b59, 0x2199999a, 0x03eea20a},
- { 64000, 0x247ae148, 0x08d8ec96, 0x23851eb8, 0x00fba882, 0x247ae148, 0x88509c0, 0x23851eb8, 0x00fba882},
- { 96000, 0x2d1eb852, 0x3419e300, 0x247ae148, 0x00a7c5ac, 0x2ccccccd, 0x346dc5d6, 0x247ae148, 0x00fba882},
- {128000, 0x60000000, 0x00000000, 0x251eb852, 0x029f16b1, 0x60000000, 0x00000000, 0x2570a3d7, 0x009f16b1},
- {148000, 0x60000000, 0x00000000, 0x26b851ec, 0x00000000, 0x60000000, 0x00000000, 0x270a3d71, 0x00000000}
-};
-
-static const BIT_PE_SFAC S_Bits2PeTab24000[] = {
- { 16000, 0x19eb851f, 0x13a92a30, 0x1147ae14, 0x164840e1, 0x1999999a, 0x12599ed8, 0x00000000, 0x46c764ae},
- { 24000, 0x1eb851ec, 0x0d1b7176, 0x16b851ec, 0x18e75793, 0x1e147ae1, 0x0fba8827, 0x1147ae14, 0x2c9081c3},
- { 32000, 0x21eb851f, 0x049667b6, 0x1ccccccd, 0x07357e67, 0x21eb851f, 0x03eea20a, 0x1c28f5c3, 0x07357e67},
- { 48000, 0x2428f5c3, 0x014f8b59, 0x2051eb85, 0x053e2d62, 0x23d70a3d, 0x01f75105, 0x1fae147b, 0x07357e67},
- { 64000, 0x24cccccd, 0x05e5f30e, 0x22e147ae, 0x01a36e2f, 0x24cccccd, 0x05e5f30e, 0x23333333, 0x014f8b59},
- { 96000, 0x2a8f5c29, 0x24b33db0, 0x247ae148, 0x00fba882, 0x2a8f5c29, 0x26fe718b, 0x247ae148, 0x00fba882},
- {128000, 0x4e666666, 0x1cd5f99c, 0x2570a3d7, 0x010c6f7a, 0x50a3d70a, 0x192a7371, 0x2570a3d7, 0x010c6f7a},
- {148000, 0x60000000, 0x00000000, 0x26147ae1, 0x00000000, 0x60000000, 0x00000000, 0x26147ae1, 0x00000000}
-};
-
-static const BIT_PE_SFAC S_Bits2PeTab32000[] = {
- { 16000, 0x1199999a, 0x20c49ba6, 0x00000000, 0x4577d955, 0x00000000, 0x60fe4799, 0x00000000, 0x00000000},
- { 24000, 0x1999999a, 0x0fba8827, 0x10f5c28f, 0x1b866e44, 0x17ae147b, 0x0fba8827, 0x00000000, 0x4d551d69},
- { 32000, 0x1d70a3d7, 0x07357e67, 0x17ae147b, 0x09d49518, 0x1b851eb8, 0x0a7c5ac4, 0x12e147ae, 0x110a137f},
- { 48000, 0x20f5c28f, 0x049667b6, 0x1c7ae148, 0x053e2d62, 0x20a3d70a, 0x053e2d62, 0x1b333333, 0x05e5f30e},
- { 64000, 0x23333333, 0x029f16b1, 0x1f0a3d71, 0x02f2f987, 0x23333333, 0x029f16b1, 0x1e147ae1, 0x03eea20a},
- { 96000, 0x25c28f5c, 0x2c3c9eed, 0x21eb851f, 0x01f75105, 0x25c28f5c, 0x0a7c5ac4, 0x21eb851f, 0x01a36e2f},
- {128000, 0x50f5c28f, 0x18a43bb4, 0x23d70a3d, 0x010c6f7a, 0x30000000, 0x168b5cc0, 0x23851eb8, 0x0192a737},
- {148000, 0x60000000, 0x00000000, 0x247ae148, 0x00dfb23b, 0x3dc28f5c, 0x300f4aaf, 0x247ae148, 0x01bf6476},
- {160000, 0x60000000, 0xb15b5740, 0x24cccccd, 0x053e2d62, 0x4f5c28f6, 0xbefd0072, 0x251eb852, 0x04fb1184},
- {200000, 0x00000000, 0x00000000, 0x2b333333, 0x0836be91, 0x00000000, 0x00000000, 0x2b333333, 0x0890390f},
- {320000, 0x00000000, 0x00000000, 0x4947ae14, 0x00000000, 0x00000000, 0x00000000, 0x4a8f5c29, 0x00000000}
-};
-
-static const BIT_PE_SFAC S_Bits2PeTab44100[] = {
- { 16000, 0x10a3d70a, 0x1797cc3a, 0x00000000, 0x00000000, 0x00000000, 0x59210386, 0x00000000, 0x00000000},
- { 24000, 0x16666666, 0x1797cc3a, 0x00000000, 0x639d5e4a, 0x15c28f5c, 0x12599ed8, 0x00000000, 0x5bc01a37},
- { 32000, 0x1c28f5c3, 0x049667b6, 0x1851eb85, 0x049667b6, 0x1a3d70a4, 0x088509c0, 0x16666666, 0x053e2d62},
- { 48000, 0x1e666666, 0x05e5f30e, 0x1a8f5c29, 0x049667b6, 0x1e666666, 0x05e5f30e, 0x18f5c28f, 0x05e5f30e},
- { 64000, 0x2147ae14, 0x0346dc5d, 0x1ccccccd, 0x02f2f987, 0x2147ae14, 0x02f2f987, 0x1bd70a3d, 0x039abf34},
- { 96000, 0x247ae148, 0x068db8bb, 0x1fae147b, 0x029f16b1, 0x2428f5c3, 0x0639d5e5, 0x1f5c28f6, 0x029f16b1},
- {128000, 0x2ae147ae, 0x1b435265, 0x223d70a4, 0x0192a737, 0x2a3d70a4, 0x1040bfe4, 0x21eb851f, 0x0192a737},
- {148000, 0x3b851eb8, 0x2832069c, 0x23333333, 0x00dfb23b, 0x3428f5c3, 0x2054c288, 0x22e147ae, 0x00dfb23b},
- {160000, 0x4a3d70a4, 0xc32ebe5a, 0x23851eb8, 0x01d5c316, 0x40000000, 0xcb923a2b, 0x23333333, 0x01d5c316},
- {200000, 0x00000000, 0x00000000, 0x25c28f5c, 0x0713f078, 0x00000000, 0x00000000, 0x2570a3d7, 0x072a4f17},
- {320000, 0x00000000, 0x00000000, 0x3fae147b, 0x00000000, 0x00000000, 0x00000000, 0x3fae147b, 0x00000000}
-};
-
-static const BIT_PE_SFAC S_Bits2PeTab48000[] = {
- { 16000, 0x0f5c28f6, 0x31ceaf25, 0x00000000, 0x00000000, 0x00000000, 0x74a771c9, 0x00000000, 0x00000000},
- { 24000, 0x1b851eb8, 0x029f16b1, 0x00000000, 0x663c74fb, 0x1c7ae148, 0xe47991bd, 0x00000000, 0x49667b5f},
- { 32000, 0x1c28f5c3, 0x029f16b1, 0x18f5c28f, 0x07357e67, 0x15c28f5c, 0x0f12c27a, 0x11eb851f, 0x13016484},
- { 48000, 0x1d70a3d7, 0x053e2d62, 0x1c7ae148, 0xfe08aefc, 0x1d1eb852, 0x068db8bb, 0x1b333333, 0xfeb074a8},
- { 64000, 0x20000000, 0x03eea20a, 0x1b851eb8, 0x0346dc5d, 0x2051eb85, 0x0346dc5d, 0x1a8f5c29, 0x039abf34},
- { 96000, 0x23d70a3d, 0x053e2d62, 0x1eb851ec, 0x029f16b1, 0x23851eb8, 0x04ea4a8c, 0x1e147ae1, 0x02f2f987},
- {128000, 0x28f5c28f, 0x14727dcc, 0x2147ae14, 0x0218def4, 0x2851eb85, 0x0e27e0f0, 0x20f5c28f, 0x0218def4},
- {148000, 0x3570a3d7, 0x1cd5f99c, 0x228f5c29, 0x01bf6476, 0x30f5c28f, 0x18777e75, 0x223d70a4, 0x01bf6476},
- {160000, 0x40000000, 0xcb923a2b, 0x23333333, 0x0192a737, 0x39eb851f, 0xd08d4bae, 0x22e147ae, 0x0192a737},
- {200000, 0x00000000, 0x00000000, 0x251eb852, 0x06775a1b, 0x00000000, 0x00000000, 0x24cccccd, 0x06a4175a},
- {320000, 0x00000000, 0x00000000, 0x3ccccccd, 0x00000000, 0x00000000, 0x00000000, 0x3d1eb852, 0x00000000}
-};
-
-static const BITS2PE_CFG_TAB bits2PeConfigTab[] = {
- { 16000, S_Bits2PeTab16000, sizeof(S_Bits2PeTab16000)/sizeof(BIT_PE_SFAC) },
- { 22050, S_Bits2PeTab22050, sizeof(S_Bits2PeTab22050)/sizeof(BIT_PE_SFAC) },
- { 24000, S_Bits2PeTab24000, sizeof(S_Bits2PeTab24000)/sizeof(BIT_PE_SFAC) },
- { 32000, S_Bits2PeTab32000, sizeof(S_Bits2PeTab32000)/sizeof(BIT_PE_SFAC) },
- { 44100, S_Bits2PeTab44100, sizeof(S_Bits2PeTab44100)/sizeof(BIT_PE_SFAC) },
- { 48000, S_Bits2PeTab48000, sizeof(S_Bits2PeTab48000)/sizeof(BIT_PE_SFAC) }
-};
-
-
-
-/* values for avoid hole flag */
-enum _avoid_hole_state {
- NO_AH =0,
- AH_INACTIVE =1,
- AH_ACTIVE =2
-};
-
-
-/* Q format definitions */
-#define Q_BITFAC (24) /* Q scaling used in FDKaacEnc_bitresCalcBitFac() calculation */
-#define Q_AVGBITS (17) /* scale bit values */
-
-
-/*****************************************************************************
- functionname: FDKaacEnc_InitBits2PeFactor
- description: retrieve bits2PeFactor from table
-*****************************************************************************/
-static void FDKaacEnc_InitBits2PeFactor(
- FIXP_DBL *bits2PeFactor_m,
- INT *bits2PeFactor_e,
- const INT bitRate,
- const INT nChannels,
- const INT sampleRate,
- const INT advancedBitsToPe,
- const INT invQuant
- )
-{
- /* default bits2pe factor */
- FIXP_DBL bit2PE_m = FL2FXCONST_DBL(1.18f/(1<<(1)));
- INT bit2PE_e = 1;
-
- /* make use of advanced bits to pe factor table */
- if (advancedBitsToPe) {
-
- int i;
- const BIT_PE_SFAC *peTab = NULL;
- INT size = 0;
-
-
- /* Get correct table entry */
- for (i=0; i<(INT)(sizeof(bits2PeConfigTab)/sizeof(BITS2PE_CFG_TAB)); i++) {
- if (sampleRate >= bits2PeConfigTab[i].sampleRate) {
- peTab = bits2PeConfigTab[i].pPeTab;
- size = bits2PeConfigTab[i].nEntries;
- }
- }
-
- if ( (peTab!=NULL) && (size!=0) ) {
-
- INT startB = -1;
- LONG startPF = 0;
- LONG peSlope = 0;
-
- /* stereo or mono mode and invQuant used or not */
- for (i=0; i<size-1; i++)
- {
- if ((peTab[i].bitrate<=bitRate) && ((peTab[i+1].bitrate>bitRate) || ((i==size-2)) ))
- {
- if (nChannels==1)
- {
- startPF = (!invQuant) ? peTab[i].bits2PeFactor_mono : peTab[i].bits2PeFactor_mono_scfOpt;
- peSlope = (!invQuant) ? peTab[i].bits2PeFactor_mono_slope : peTab[i].bits2PeFactor_mono_scfOpt_slope;
- /*endPF = (!invQuant) ? peTab[i+1].bits2PeFactor_mono : peTab[i+1].bits2PeFactor_mono_scfOpt;
- endB=peTab[i+1].bitrate;*/
- startB=peTab[i].bitrate;
- break;
- }
- else
- {
- startPF = (!invQuant) ? peTab[i].bits2PeFactor_stereo : peTab[i].bits2PeFactor_stereo_scfOpt;
- peSlope = (!invQuant) ? peTab[i].bits2PeFactor_stereo_slope : peTab[i].bits2PeFactor_stereo_scfOpt_slope;
- /*endPF = (!invQuant) ? peTab[i+1].bits2PeFactor_stereo : peTab[i+1].bits2PeFactor_stereo_scfOpt;
- endB=peTab[i+1].bitrate;*/
- startB=peTab[i].bitrate;
- break;
- }
- }
- } /* for i */
-
- /* if a configuration is available */
- if (startB!=-1) {
- /* linear interpolate to actual PEfactor */
- FIXP_DBL peFac = fMult((FIXP_DBL)(bitRate-startB)<<14, (FIXP_DBL)peSlope) << 2;
- FIXP_DBL bit2PE = peFac + (FIXP_DBL)startPF; /* startPF_float = startPF << 2 */
-
- /* sanity check if bits2pe value is high enough */
- if ( bit2PE >= (FL2FXCONST_DBL(0.35f) >> 2) ) {
- bit2PE_m = bit2PE;
- bit2PE_e = 2; /* table is fixed scaled */
- }
- } /* br */
- } /* sr */
- } /* advancedBitsToPe */
-
-
- /* return bits2pe factor */
- *bits2PeFactor_m = bit2PE_m;
- *bits2PeFactor_e = bit2PE_e;
-}
-
-
-/*****************************************************************************
-functionname: FDKaacEnc_bits2pe2
-description: convert from bits to pe
-*****************************************************************************/
-static INT FDKaacEnc_bits2pe2(
- const INT bits,
- const FIXP_DBL factor_m,
- const INT factor_e
- )
-{
- return (INT)(fMult(factor_m, (FIXP_DBL)(bits<<Q_AVGBITS)) >> (Q_AVGBITS-factor_e));
-}
-
-/*****************************************************************************
-functionname: FDKaacEnc_calcThreshExp
-description: loudness calculation (threshold to the power of redExp)
-*****************************************************************************/
-static void FDKaacEnc_calcThreshExp(FIXP_DBL thrExp[(2)][MAX_GROUPED_SFB],
- QC_OUT_CHANNEL* qcOutChannel[(2)],
- PSY_OUT_CHANNEL* psyOutChannel[(2)],
- const INT nChannels)
-{
- INT ch, sfb, sfbGrp;
- FIXP_DBL thrExpLdData;
-
- for (ch=0; ch<nChannels; ch++) {
- for(sfbGrp = 0;sfbGrp < psyOutChannel[ch]->sfbCnt;sfbGrp+= psyOutChannel[ch]->sfbPerGroup) {
- for (sfb=0; sfb<psyOutChannel[ch]->maxSfbPerGroup; sfb++) {
- thrExpLdData = psyOutChannel[ch]->sfbThresholdLdData[sfbGrp+sfb]>>2 ;
- thrExp[ch][sfbGrp+sfb] = CalcInvLdData(thrExpLdData);
- }
- }
- }
-}
-
-
-/*****************************************************************************
- functionname: FDKaacEnc_adaptMinSnr
- description: reduce minSnr requirements for bands with relative low energies
-*****************************************************************************/
-static void FDKaacEnc_adaptMinSnr(QC_OUT_CHANNEL *qcOutChannel[(2)],
- PSY_OUT_CHANNEL *psyOutChannel[(2)],
- MINSNR_ADAPT_PARAM *msaParam,
- const INT nChannels)
-{
- INT ch, sfb, sfbGrp, nSfb;
- FIXP_DBL avgEnLD64, dbRatio, minSnrRed;
- FIXP_DBL minSnrLimitLD64 = FL2FXCONST_DBL(-0.00503012648262f); /* ld64(0.8f) */
- FIXP_DBL nSfbLD64;
- FIXP_DBL accu;
-
- for (ch=0; ch<nChannels; ch++) {
- /* calc average energy per scalefactor band */
- nSfb = 0;
- accu = FL2FXCONST_DBL(0.0f);
-
- for (sfbGrp=0; sfbGrp < psyOutChannel[ch]->sfbCnt; sfbGrp+=psyOutChannel[ch]->sfbPerGroup) {
- for (sfb=0; sfb<psyOutChannel[ch]->maxSfbPerGroup; sfb++) {
- accu += psyOutChannel[ch]->sfbEnergy[sfbGrp+sfb]>>6;
- nSfb++;
- }
- }
-
- if ((accu == FL2FXCONST_DBL(0.0f)) || (nSfb == 0)) {
- avgEnLD64 = FL2FXCONST_DBL(-1.0f);
- }
- else {
- nSfbLD64 = CalcLdInt(nSfb);
- avgEnLD64 = CalcLdData(accu);
- avgEnLD64 = avgEnLD64 + FL2FXCONST_DBL(0.09375f) - nSfbLD64; /* 0.09375f: compensate shift with 6 */
- }
-
- /* reduce minSnr requirement by minSnr^minSnrRed dependent on avgEn/sfbEn */
- for (sfbGrp=0; sfbGrp < psyOutChannel[ch]->sfbCnt; sfbGrp+=psyOutChannel[ch]->sfbPerGroup) {
- for (sfb=0; sfb<psyOutChannel[ch]->maxSfbPerGroup; sfb++) {
- if ( (msaParam->startRatio + qcOutChannel[ch]->sfbEnergyLdData[sfbGrp+sfb]) < avgEnLD64 ) {
- dbRatio = fMult((avgEnLD64 - qcOutChannel[ch]->sfbEnergyLdData[sfbGrp+sfb]),FL2FXCONST_DBL(0.3010299956f)); /* scaled by (1.0f/(10.0f*64.0f)) */
- minSnrRed = msaParam->redOffs + fMult(msaParam->redRatioFac,dbRatio); /* scaled by 1.0f/64.0f*/
- minSnrRed = fixMax(minSnrRed, msaParam->maxRed); /* scaled by 1.0f/64.0f*/
- qcOutChannel[ch]->sfbMinSnrLdData[sfbGrp+sfb] = (fMult(qcOutChannel[ch]->sfbMinSnrLdData[sfbGrp+sfb],minSnrRed)) << 6;
- qcOutChannel[ch]->sfbMinSnrLdData[sfbGrp+sfb] = fixMin(minSnrLimitLD64, qcOutChannel[ch]->sfbMinSnrLdData[sfbGrp+sfb]);
- }
- }
- }
- }
-}
-
-
-/*****************************************************************************
-functionname: FDKaacEnc_initAvoidHoleFlag
-description: determine bands where avoid hole is not necessary resp. possible
-*****************************************************************************/
-static void FDKaacEnc_initAvoidHoleFlag(QC_OUT_CHANNEL *qcOutChannel[(2)],
- PSY_OUT_CHANNEL *psyOutChannel[(2)],
- UCHAR ahFlag[(2)][MAX_GROUPED_SFB],
- struct TOOLSINFO *toolsInfo,
- const INT nChannels,
- const PE_DATA *peData,
- AH_PARAM *ahParam)
-{
- INT ch, sfb, sfbGrp;
- FIXP_DBL sfbEn, sfbEnm1;
- FIXP_DBL sfbEnLdData;
- FIXP_DBL avgEnLdData;
-
- /* decrease spread energy by 3dB for long blocks, resp. 2dB for shorts
- (avoid more holes in long blocks) */
- for (ch=0; ch<nChannels; ch++) {
- INT sfbGrp, sfb;
- QC_OUT_CHANNEL* qcOutChan = qcOutChannel[ch];
-
- if (psyOutChannel[ch]->lastWindowSequence != SHORT_WINDOW) {
- for (sfbGrp = 0;sfbGrp < psyOutChannel[ch]->sfbCnt;sfbGrp+= psyOutChannel[ch]->sfbPerGroup)
- for (sfb=0; sfb<psyOutChannel[ch]->maxSfbPerGroup; sfb++)
- qcOutChan->sfbSpreadEnergy[sfbGrp+sfb] >>= 1 ;
- }
- else {
- for (sfbGrp = 0;sfbGrp < psyOutChannel[ch]->sfbCnt;sfbGrp+= psyOutChannel[ch]->sfbPerGroup)
- for (sfb=0; sfb<psyOutChannel[ch]->maxSfbPerGroup; sfb++)
- qcOutChan->sfbSpreadEnergy[sfbGrp+sfb] =
- fMult(FL2FXCONST_DBL(0.63f),
- qcOutChan->sfbSpreadEnergy[sfbGrp+sfb]) ;
- }
- }
-
- /* increase minSnr for local peaks, decrease it for valleys */
- if (ahParam->modifyMinSnr) {
- for(ch=0; ch<nChannels; ch++) {
- QC_OUT_CHANNEL* qcOutChan = qcOutChannel[ch];
- for(sfbGrp = 0;sfbGrp < psyOutChannel[ch]->sfbCnt;sfbGrp+= psyOutChannel[ch]->sfbPerGroup){
- for (sfb=0; sfb<psyOutChannel[ch]->maxSfbPerGroup; sfb++) {
- FIXP_DBL sfbEnp1, avgEn;
- if (sfb > 0)
- sfbEnm1 = qcOutChan->sfbEnergy[sfbGrp+sfb-1];
- else
- sfbEnm1 = qcOutChan->sfbEnergy[sfbGrp+sfb];
-
- if (sfb < psyOutChannel[ch]->maxSfbPerGroup-1)
- sfbEnp1 = qcOutChan->sfbEnergy[sfbGrp+sfb+1];
- else
- sfbEnp1 = qcOutChan->sfbEnergy[sfbGrp+sfb];
-
- avgEn = (sfbEnm1>>1) + (sfbEnp1>>1);
- avgEnLdData = CalcLdData(avgEn);
- sfbEn = qcOutChan->sfbEnergy[sfbGrp+sfb];
- sfbEnLdData = qcOutChan->sfbEnergyLdData[sfbGrp+sfb];
- /* peak ? */
- if (sfbEn > avgEn) {
- FIXP_DBL tmpMinSnrLdData;
- if (psyOutChannel[ch]->lastWindowSequence==LONG_WINDOW)
- tmpMinSnrLdData = fixMax( SnrLdFac + (FIXP_DBL)(avgEnLdData - sfbEnLdData), (FIXP_DBL)SnrLdMin1 ) ;
- else
- tmpMinSnrLdData = fixMax( SnrLdFac + (FIXP_DBL)(avgEnLdData - sfbEnLdData), (FIXP_DBL)SnrLdMin3 ) ;
-
- qcOutChan->sfbMinSnrLdData[sfbGrp+sfb] =
- fixMin(qcOutChan->sfbMinSnrLdData[sfbGrp+sfb], tmpMinSnrLdData);
- }
- /* valley ? */
- if ( ((sfbEnLdData+(FIXP_DBL)SnrLdMin4) < (FIXP_DBL)avgEnLdData) && (sfbEn > FL2FXCONST_DBL(0.0)) ) {
- FIXP_DBL tmpMinSnrLdData = avgEnLdData - sfbEnLdData -(FIXP_DBL)SnrLdMin4 + qcOutChan->sfbMinSnrLdData[sfbGrp+sfb];
- tmpMinSnrLdData = fixMin((FIXP_DBL)SnrLdFac, tmpMinSnrLdData);
- qcOutChan->sfbMinSnrLdData[sfbGrp+sfb] = fixMin(tmpMinSnrLdData,
- (FIXP_DBL)(qcOutChan->sfbMinSnrLdData[sfbGrp+sfb] + SnrLdMin2 ));
- }
- }
- }
- }
- }
-
- /* stereo: adapt the minimum requirements sfbMinSnr of mid and
- side channels to avoid spending unnoticable bits */
- if (nChannels == 2) {
- QC_OUT_CHANNEL* qcOutChanM = qcOutChannel[0];
- QC_OUT_CHANNEL* qcOutChanS = qcOutChannel[1];
- PSY_OUT_CHANNEL* psyOutChanM = psyOutChannel[0];
- for(sfbGrp = 0;sfbGrp < psyOutChanM->sfbCnt;sfbGrp+= psyOutChanM->sfbPerGroup){
- for (sfb=0; sfb<psyOutChanM->maxSfbPerGroup; sfb++) {
- if (toolsInfo->msMask[sfbGrp+sfb]) {
- FIXP_DBL maxSfbEnLd = fixMax(qcOutChanM->sfbEnergyLdData[sfbGrp+sfb],qcOutChanS->sfbEnergyLdData[sfbGrp+sfb]);
- FIXP_DBL maxThrLd, sfbMinSnrTmpLd;
-
- if ( ((SnrLdMin5>>1) + (maxSfbEnLd>>1) + (qcOutChanM->sfbMinSnrLdData[sfbGrp+sfb]>>1)) <= FL2FXCONST_DBL(-0.5f))
- maxThrLd = FL2FXCONST_DBL(-1.0f) ;
- else
- maxThrLd = SnrLdMin5 + maxSfbEnLd + qcOutChanM->sfbMinSnrLdData[sfbGrp+sfb];
-
- if (qcOutChanM->sfbEnergy[sfbGrp+sfb] > FL2FXCONST_DBL(0.0f))
- sfbMinSnrTmpLd = maxThrLd - qcOutChanM->sfbEnergyLdData[sfbGrp+sfb];
- else
- sfbMinSnrTmpLd = FL2FXCONST_DBL(0.0f);
-
- qcOutChanM->sfbMinSnrLdData[sfbGrp+sfb] = fixMax(qcOutChanM->sfbMinSnrLdData[sfbGrp+sfb],sfbMinSnrTmpLd);
-
- if (qcOutChanM->sfbMinSnrLdData[sfbGrp+sfb] <= FL2FXCONST_DBL(0.0f))
- qcOutChanM->sfbMinSnrLdData[sfbGrp+sfb] = fixMin(qcOutChanM->sfbMinSnrLdData[sfbGrp+sfb], (FIXP_DBL)SnrLdFac);
-
- if (qcOutChanS->sfbEnergy[sfbGrp+sfb] > FL2FXCONST_DBL(0.0f))
- sfbMinSnrTmpLd = maxThrLd - qcOutChanS->sfbEnergyLdData[sfbGrp+sfb];
- else
- sfbMinSnrTmpLd = FL2FXCONST_DBL(0.0f);
-
- qcOutChanS->sfbMinSnrLdData[sfbGrp+sfb] = fixMax(qcOutChanS->sfbMinSnrLdData[sfbGrp+sfb],sfbMinSnrTmpLd);
-
- if (qcOutChanS->sfbMinSnrLdData[sfbGrp+sfb] <= FL2FXCONST_DBL(0.0f))
- qcOutChanS->sfbMinSnrLdData[sfbGrp+sfb] = fixMin(qcOutChanS->sfbMinSnrLdData[sfbGrp+sfb],(FIXP_DBL)SnrLdFac);
-
- if (qcOutChanM->sfbEnergy[sfbGrp+sfb]>qcOutChanM->sfbSpreadEnergy[sfbGrp+sfb])
- qcOutChanS->sfbSpreadEnergy[sfbGrp+sfb] =
- fMult(qcOutChanS->sfbEnergy[sfbGrp+sfb], FL2FXCONST_DBL(0.9f));
-
- if (qcOutChanS->sfbEnergy[sfbGrp+sfb]>qcOutChanS->sfbSpreadEnergy[sfbGrp+sfb])
- qcOutChanM->sfbSpreadEnergy[sfbGrp+sfb] =
- fMult(qcOutChanM->sfbEnergy[sfbGrp+sfb], FL2FXCONST_DBL(0.9f));
- }
- }
- }
- }
-
- /* init ahFlag (0: no ah necessary, 1: ah possible, 2: ah active */
- for(ch=0; ch<nChannels; ch++) {
- QC_OUT_CHANNEL *qcOutChan = qcOutChannel[ch];
- PSY_OUT_CHANNEL *psyOutChan = psyOutChannel[ch];
- for(sfbGrp = 0;sfbGrp < psyOutChan->sfbCnt;sfbGrp+= psyOutChan->sfbPerGroup){
- for (sfb=0; sfb<psyOutChan->maxSfbPerGroup; sfb++) {
- if ((qcOutChan->sfbSpreadEnergy[sfbGrp+sfb] > qcOutChan->sfbEnergy[sfbGrp+sfb])
- || (qcOutChan->sfbMinSnrLdData[sfbGrp+sfb] > FL2FXCONST_DBL(0.0f))) {
- ahFlag[ch][sfbGrp+sfb] = NO_AH;
- }
- else {
- ahFlag[ch][sfbGrp+sfb] = AH_INACTIVE;
- }
- }
- }
- }
-}
-
-
-
-/**
- * \brief Calculate constants that do not change during successive pe calculations.
- *
- * \param peData Pointer to structure containing PE data of current element.
- * \param psyOutChannel Pointer to PSY_OUT_CHANNEL struct holding nChannels elements.
- * \param qcOutChannel Pointer to QC_OUT_CHANNEL struct holding nChannels elements.
- * \param nChannels Number of channels in element.
- * \param peOffset Fixed PE offset defined while FDKaacEnc_AdjThrInit() depending on bitrate.
- *
- * \return void
- */
-static
-void FDKaacEnc_preparePe(PE_DATA *peData,
- PSY_OUT_CHANNEL* psyOutChannel[(2)],
- QC_OUT_CHANNEL* qcOutChannel[(2)],
- const INT nChannels,
- const INT peOffset)
-{
- INT ch;
-
- for(ch=0; ch<nChannels; ch++) {
- PSY_OUT_CHANNEL *psyOutChan = psyOutChannel[ch];
- FDKaacEnc_prepareSfbPe(&peData->peChannelData[ch],
- psyOutChan->sfbEnergyLdData,
- psyOutChan->sfbThresholdLdData,
- qcOutChannel[ch]->sfbFormFactorLdData,
- psyOutChan->sfbOffsets,
- psyOutChan->sfbCnt,
- psyOutChan->sfbPerGroup,
- psyOutChan->maxSfbPerGroup);
- }
- peData->offset = peOffset;
-}
-
-/**
- * \brief Calculate weighting factor for threshold adjustment.
- *
- * Calculate weighting factor to be applied at energies and thresholds in ld64 format.
- *
- * \param peData, Pointer to PE data in current element.
- * \param psyOutChannel Pointer to PSY_OUT_CHANNEL struct holding nChannels elements.
- * \param qcOutChannel Pointer to QC_OUT_CHANNEL struct holding nChannels elements.
- * \param toolsInfo Pointer to tools info struct of current element.
- * \param adjThrStateElement Pointer to ATS_ELEMENT holding enFacPatch states.
- * \param nChannels Number of channels in element.
- * \param usePatchTool Apply the weighting tool 0 (no) else (yes).
- *
- * \return void
- */
-static
-void FDKaacEnc_calcWeighting(PE_DATA *peData,
- PSY_OUT_CHANNEL* psyOutChannel[(2)],
- QC_OUT_CHANNEL* qcOutChannel[(2)],
- struct TOOLSINFO *toolsInfo,
- ATS_ELEMENT* adjThrStateElement,
- const INT nChannels,
- const INT usePatchTool)
-{
- int ch, noShortWindowInFrame = TRUE;
- INT exePatchM = 0;
-
- for (ch=0; ch<nChannels; ch++) {
- if (psyOutChannel[ch]->lastWindowSequence == SHORT_WINDOW) {
- noShortWindowInFrame = FALSE;
- }
- FDKmemclear(qcOutChannel[ch]->sfbEnFacLd, MAX_GROUPED_SFB*sizeof(FIXP_DBL));
- }
-
- if (usePatchTool==0) {
- return; /* tool is disabled */
- }
-
- for (ch=0; ch<nChannels; ch++) {
-
- PSY_OUT_CHANNEL *psyOutChan = psyOutChannel[ch];
-
- if (noShortWindowInFrame) { /* retain energy ratio between blocks of different length */
-
- FIXP_DBL nrgSum14, nrgSum12, nrgSum34, nrgTotal;
- FIXP_DBL nrgFacLd_14, nrgFacLd_12, nrgFacLd_34;
- INT usePatch, exePatch;
- int sfb, sfbGrp, nLinesSum = 0;
-
- nrgSum14 = nrgSum12 = nrgSum34 = nrgTotal = FL2FXCONST_DBL(0.f);
-
- /* calculate flatness of audible spectrum, i.e. spectrum above masking threshold. */
- for (sfbGrp = 0;sfbGrp < psyOutChannel[ch]->sfbCnt; sfbGrp+=psyOutChannel[ch]->sfbPerGroup) {
- for (sfb=0; sfb<psyOutChannel[ch]->maxSfbPerGroup; sfb++) {
- FIXP_DBL nrgFac12 = CalcInvLdData(psyOutChan->sfbEnergyLdData[sfbGrp+sfb]>>1); /* nrg^(1/2) */
- FIXP_DBL nrgFac14 = CalcInvLdData(psyOutChan->sfbEnergyLdData[sfbGrp+sfb]>>2); /* nrg^(1/4) */
-
- /* maximal number of bands is 64, results scaling factor 6 */
- nLinesSum += peData->peChannelData[ch].sfbNLines[sfbGrp+sfb]; /* relevant lines */
- nrgTotal += ( psyOutChan->sfbEnergy[sfbGrp+sfb] >> 6 ); /* sum up nrg */
- nrgSum12 += ( nrgFac12 >> 6 ); /* sum up nrg^(2/4) */
- nrgSum14 += ( nrgFac14 >> 6 ); /* sum up nrg^(1/4) */
- nrgSum34 += ( fMult(nrgFac14, nrgFac12) >> 6 ); /* sum up nrg^(3/4) */
- }
- }
-
- nrgTotal = CalcLdData(nrgTotal); /* get ld64 of total nrg */
-
- nrgFacLd_14 = CalcLdData(nrgSum14) - nrgTotal; /* ld64(nrgSum14/nrgTotal) */
- nrgFacLd_12 = CalcLdData(nrgSum12) - nrgTotal; /* ld64(nrgSum12/nrgTotal) */
- nrgFacLd_34 = CalcLdData(nrgSum34) - nrgTotal; /* ld64(nrgSum34/nrgTotal) */
-
- adjThrStateElement->chaosMeasureEnFac[ch] = FDKmax( FL2FXCONST_DBL(0.1875f), fDivNorm(nLinesSum,psyOutChan->sfbOffsets[psyOutChan->sfbCnt]) );
-
- usePatch = (adjThrStateElement->chaosMeasureEnFac[ch] > FL2FXCONST_DBL(0.78125f));
- exePatch = ((usePatch) && (adjThrStateElement->lastEnFacPatch[ch]));
-
- for (sfbGrp = 0;sfbGrp < psyOutChannel[ch]->sfbCnt; sfbGrp+=psyOutChannel[ch]->sfbPerGroup) {
- for (sfb=0; sfb<psyOutChannel[ch]->maxSfbPerGroup; sfb++) {
-
- INT sfbExePatch;
-
- /* for MS coupled SFBs, also execute patch in side channel if done in mid channel */
- if ((ch == 1) && (toolsInfo->msMask[sfbGrp+sfb])) {
- sfbExePatch = exePatchM;
- }
- else {
- sfbExePatch = exePatch;
- }
-
- if ( (sfbExePatch) && (psyOutChan->sfbEnergy[sfbGrp+sfb]>FL2FXCONST_DBL(0.f)) )
- {
- /* execute patch based on spectral flatness calculated above */
- if (adjThrStateElement->chaosMeasureEnFac[ch] > FL2FXCONST_DBL(0.8125f)) {
- qcOutChannel[ch]->sfbEnFacLd[sfbGrp+sfb] = ( (nrgFacLd_14 + (psyOutChan->sfbEnergyLdData[sfbGrp+sfb]+(psyOutChan->sfbEnergyLdData[sfbGrp+sfb]>>1)))>>1 ); /* sfbEnergy^(3/4) */
- }
- else if (adjThrStateElement->chaosMeasureEnFac[ch] > FL2FXCONST_DBL(0.796875f)) {
- qcOutChannel[ch]->sfbEnFacLd[sfbGrp+sfb] = ( (nrgFacLd_12 + psyOutChan->sfbEnergyLdData[sfbGrp+sfb])>>1 ); /* sfbEnergy^(2/4) */
- }
- else {
- qcOutChannel[ch]->sfbEnFacLd[sfbGrp+sfb] = ( (nrgFacLd_34 + (psyOutChan->sfbEnergyLdData[sfbGrp+sfb]>>1))>>1 ); /* sfbEnergy^(1/4) */
- }
- qcOutChannel[ch]->sfbEnFacLd[sfbGrp+sfb] = fixMin(qcOutChannel[ch]->sfbEnFacLd[sfbGrp+sfb],(FIXP_DBL)0);
-
- }
- }
- } /* sfb loop */
-
- adjThrStateElement->lastEnFacPatch[ch] = usePatch;
- exePatchM = exePatch;
- }
- else {
- /* !noShortWindowInFrame */
- adjThrStateElement->chaosMeasureEnFac[ch] = FL2FXCONST_DBL(0.75f);
- adjThrStateElement->lastEnFacPatch[ch] = TRUE; /* allow use of sfbEnFac patch in upcoming frame */
- }
-
- } /* ch loop */
-
-}
-
-
-
-
-/*****************************************************************************
-functionname: FDKaacEnc_calcPe
-description: calculate pe for both channels
-*****************************************************************************/
-static
-void FDKaacEnc_calcPe(PSY_OUT_CHANNEL* psyOutChannel[(2)],
- QC_OUT_CHANNEL* qcOutChannel[(2)],
- PE_DATA *peData,
- const INT nChannels)
-{
- INT ch;
-
- peData->pe = peData->offset;
- peData->constPart = 0;
- peData->nActiveLines = 0;
- for(ch=0; ch<nChannels; ch++) {
- PE_CHANNEL_DATA *peChanData = &peData->peChannelData[ch];
- FDKaacEnc_calcSfbPe(&peData->peChannelData[ch],
- qcOutChannel[ch]->sfbWeightedEnergyLdData,
- qcOutChannel[ch]->sfbThresholdLdData,
- psyOutChannel[ch]->sfbCnt,
- psyOutChannel[ch]->sfbPerGroup,
- psyOutChannel[ch]->maxSfbPerGroup,
- psyOutChannel[ch]->isBook,
- psyOutChannel[ch]->isScale);
-
- peData->pe += peChanData->pe;
- peData->constPart += peChanData->constPart;
- peData->nActiveLines += peChanData->nActiveLines;
- }
-}
-
-void FDKaacEnc_peCalculation(PE_DATA *peData,
- PSY_OUT_CHANNEL* psyOutChannel[(2)],
- QC_OUT_CHANNEL* qcOutChannel[(2)],
- struct TOOLSINFO *toolsInfo,
- ATS_ELEMENT* adjThrStateElement,
- const INT nChannels)
-{
- /* constants that will not change during successive pe calculations */
- FDKaacEnc_preparePe(peData, psyOutChannel, qcOutChannel, nChannels, adjThrStateElement->peOffset);
-
- /* calculate weighting factor for threshold adjustment */
- FDKaacEnc_calcWeighting(peData, psyOutChannel, qcOutChannel, toolsInfo, adjThrStateElement, nChannels, 1);
-{
- /* no weighting of threholds and energies for mlout */
- /* weight energies and thresholds */
- int ch;
- for (ch=0; ch<nChannels; ch++) {
-
- int sfb, sfbGrp;
- QC_OUT_CHANNEL* pQcOutCh = qcOutChannel[ch];
-
- for (sfbGrp = 0;sfbGrp < psyOutChannel[ch]->sfbCnt; sfbGrp+=psyOutChannel[ch]->sfbPerGroup) {
- for (sfb=0; sfb<psyOutChannel[ch]->maxSfbPerGroup; sfb++) {
- pQcOutCh->sfbWeightedEnergyLdData[sfb+sfbGrp] = pQcOutCh->sfbEnergyLdData[sfb+sfbGrp] - pQcOutCh->sfbEnFacLd[sfb+sfbGrp];
- pQcOutCh->sfbThresholdLdData[sfb+sfbGrp] -= pQcOutCh->sfbEnFacLd[sfb+sfbGrp];
- }
- }
- }
-}
-
- /* pe without reduction */
- FDKaacEnc_calcPe(psyOutChannel, qcOutChannel, peData, nChannels);
-}
-
-
-
-/*****************************************************************************
-functionname: FDKaacEnc_FDKaacEnc_calcPeNoAH
-description: sum the pe data only for bands where avoid hole is inactive
-*****************************************************************************/
-static void FDKaacEnc_FDKaacEnc_calcPeNoAH(INT *pe,
- INT *constPart,
- INT *nActiveLines,
- PE_DATA *peData,
- UCHAR ahFlag[(2)][MAX_GROUPED_SFB],
- PSY_OUT_CHANNEL* psyOutChannel[(2)],
- const INT nChannels)
-{
- INT ch, sfb,sfbGrp;
-
- INT pe_tmp = peData->offset;
- INT constPart_tmp = 0;
- INT nActiveLines_tmp = 0;
- for(ch=0; ch<nChannels; ch++) {
- PE_CHANNEL_DATA *peChanData = &peData->peChannelData[ch];
- for(sfbGrp = 0;sfbGrp < psyOutChannel[ch]->sfbCnt;sfbGrp+= psyOutChannel[ch]->sfbPerGroup){
- for (sfb=0; sfb<psyOutChannel[ch]->maxSfbPerGroup; sfb++) {
- if(ahFlag[ch][sfbGrp+sfb] < AH_ACTIVE) {
- pe_tmp += peChanData->sfbPe[sfbGrp+sfb];
- constPart_tmp += peChanData->sfbConstPart[sfbGrp+sfb];
- nActiveLines_tmp += peChanData->sfbNActiveLines[sfbGrp+sfb];
- }
- }
- }
- }
- /* correct scaled pe and constPart values */
- *pe = pe_tmp >> PE_CONSTPART_SHIFT;
- *constPart = constPart_tmp >> PE_CONSTPART_SHIFT;
-
- *nActiveLines = nActiveLines_tmp;
-}
-
-
-/*****************************************************************************
-functionname: FDKaacEnc_reduceThresholdsCBR
-description: apply reduction formula
-*****************************************************************************/
-static const FIXP_DBL limitThrReducedLdData = (FIXP_DBL)0x00008000; /*FL2FXCONST_DBL(FDKpow(2.0,-LD_DATA_SCALING/4.0));*/
-
-static void FDKaacEnc_reduceThresholdsCBR(QC_OUT_CHANNEL* qcOutChannel[(2)],
- PSY_OUT_CHANNEL* psyOutChannel[(2)],
- UCHAR ahFlag[(2)][MAX_GROUPED_SFB],
- FIXP_DBL thrExp[(2)][MAX_GROUPED_SFB],
- const INT nChannels,
- const FIXP_DBL redVal,
- const SCHAR redValScaling)
-{
- INT ch, sfb, sfbGrp;
- FIXP_DBL sfbEnLdData, sfbThrLdData, sfbThrReducedLdData;
- FIXP_DBL sfbThrExp;
-
- for(ch=0; ch<nChannels; ch++) {
- QC_OUT_CHANNEL *qcOutChan = qcOutChannel[ch];
- for(sfbGrp = 0; sfbGrp < psyOutChannel[ch]->sfbCnt; sfbGrp+= psyOutChannel[ch]->sfbPerGroup){
- for (sfb=0; sfb<psyOutChannel[ch]->maxSfbPerGroup; sfb++) {
- sfbEnLdData = qcOutChan->sfbWeightedEnergyLdData[sfbGrp+sfb];
- sfbThrLdData = qcOutChan->sfbThresholdLdData[sfbGrp+sfb];
- sfbThrExp = thrExp[ch][sfbGrp+sfb];
- if ((sfbEnLdData > sfbThrLdData) && (ahFlag[ch][sfbGrp+sfb] != AH_ACTIVE)) {
-
- /* threshold reduction formula:
- float tmp = thrExp[ch][sfb]+redVal;
- tmp *= tmp;
- sfbThrReduced = tmp*tmp;
- */
- int minScale = fixMin(CountLeadingBits(sfbThrExp), CountLeadingBits(redVal) - (DFRACT_BITS-1-redValScaling) )-1;
-
- /* 4*log( sfbThrExp + redVal ) */
- sfbThrReducedLdData = CalcLdData(fAbs(scaleValue(sfbThrExp, minScale) + scaleValue(redVal,(DFRACT_BITS-1-redValScaling)+minScale)))
- - (FIXP_DBL)(minScale<<(DFRACT_BITS-1-LD_DATA_SHIFT));
- sfbThrReducedLdData <<= 2;
-
- /* avoid holes */
- if ( ((sfbThrReducedLdData - sfbEnLdData) > qcOutChan->sfbMinSnrLdData[sfbGrp+sfb] )
- && (ahFlag[ch][sfbGrp+sfb] != NO_AH) )
- {
- if (qcOutChan->sfbMinSnrLdData[sfbGrp+sfb] > (FL2FXCONST_DBL(-1.0f) - sfbEnLdData) ){
- sfbThrReducedLdData = fixMax((qcOutChan->sfbMinSnrLdData[sfbGrp+sfb] + sfbEnLdData), sfbThrLdData);
- }
- else sfbThrReducedLdData = sfbThrLdData;
- ahFlag[ch][sfbGrp+sfb] = AH_ACTIVE;
- }
-
- /* minimum of 29 dB Ratio for Thresholds */
- if ((sfbEnLdData+(FIXP_DBL)MAXVAL_DBL) > FL2FXCONST_DBL(9.6336206/LD_DATA_SCALING)){
- sfbThrReducedLdData = fixMax(sfbThrReducedLdData, (sfbEnLdData - FL2FXCONST_DBL(9.6336206/LD_DATA_SCALING)));
- }
-
- qcOutChan->sfbThresholdLdData[sfbGrp+sfb] = sfbThrReducedLdData;
- }
- }
- }
- }
-}
-
-/* similar to prepareSfbPe1() */
-static FIXP_DBL FDKaacEnc_calcChaosMeasure(PSY_OUT_CHANNEL *psyOutChannel,
- const FIXP_DBL *sfbFormFactorLdData)
-{
- #define SCALE_FORM_FAC (4) /* (SCALE_FORM_FAC+FORM_FAC_SHIFT) >= ld(FRAME_LENGTH)*/
- #define SCALE_NRGS (8)
- #define SCALE_NLINES (16)
- #define SCALE_NRGS_SQRT4 (2) /* 0.25 * SCALE_NRGS */
- #define SCALE_NLINES_P34 (12) /* 0.75 * SCALE_NLINES */
-
- INT sfbGrp, sfb;
- FIXP_DBL chaosMeasure;
- INT frameNLines = 0;
- FIXP_DBL frameFormFactor = FL2FXCONST_DBL(0.f);
- FIXP_DBL frameEnergy = FL2FXCONST_DBL(0.f);
-
- for (sfbGrp=0; sfbGrp<psyOutChannel->sfbCnt; sfbGrp+=psyOutChannel->sfbPerGroup) {
- for (sfb=0; sfb<psyOutChannel->maxSfbPerGroup; sfb++){
- if (psyOutChannel->sfbEnergyLdData[sfbGrp+sfb] > psyOutChannel->sfbThresholdLdData[sfbGrp+sfb]) {
- frameFormFactor += (CalcInvLdData(sfbFormFactorLdData[sfbGrp+sfb])>>SCALE_FORM_FAC);
- frameNLines += (psyOutChannel->sfbOffsets[sfbGrp+sfb+1] - psyOutChannel->sfbOffsets[sfbGrp+sfb]);
- frameEnergy += (psyOutChannel->sfbEnergy[sfbGrp+sfb]>>SCALE_NRGS);
- }
- }
- }
-
- if(frameNLines > 0){
-
- /* frameNActiveLines = frameFormFactor*2^FORM_FAC_SHIFT * ((frameEnergy *2^SCALE_NRGS)/frameNLines)^-0.25
- chaosMeasure = frameNActiveLines / frameNLines */
- chaosMeasure =
- CalcInvLdData( (((CalcLdData(frameFormFactor)>>1) -
- (CalcLdData(frameEnergy)>>(2+1))) -
- (fMultDiv2(FL2FXCONST_DBL(0.75f),CalcLdData((FIXP_DBL)frameNLines<<(DFRACT_BITS-1-SCALE_NLINES))) -
- (((FIXP_DBL)(SCALE_FORM_FAC-SCALE_NRGS_SQRT4+FORM_FAC_SHIFT-(SCALE_NLINES_P34))<<(DFRACT_BITS-1-LD_DATA_SHIFT))>>1))
- )<<1 );
- } else {
-
- /* assuming total chaos, if no sfb is above thresholds */
- chaosMeasure = FL2FXCONST_DBL(1.f);
- }
-
- return chaosMeasure;
-}
-
-/* apply reduction formula for VBR-mode */
-static void FDKaacEnc_reduceThresholdsVBR(QC_OUT_CHANNEL* qcOutChannel[(2)],
- PSY_OUT_CHANNEL* psyOutChannel[(2)],
- UCHAR ahFlag[(2)][MAX_GROUPED_SFB],
- FIXP_DBL thrExp[(2)][MAX_GROUPED_SFB],
- const INT nChannels,
- const FIXP_DBL vbrQualFactor,
- FIXP_DBL* chaosMeasureOld)
-{
- INT ch, sfbGrp, sfb;
- FIXP_DBL chGroupEnergy[TRANS_FAC][2];/*energy for each group and channel*/
- FIXP_DBL chChaosMeasure[2];
- FIXP_DBL frameEnergy = FL2FXCONST_DBL(1e-10f);
- FIXP_DBL chaosMeasure = FL2FXCONST_DBL(0.f);
- FIXP_DBL sfbEnLdData, sfbThrLdData, sfbThrExp;
- FIXP_DBL sfbThrReducedLdData;
- FIXP_DBL chaosMeasureAvg;
- INT groupCnt; /* loop counter */
- FIXP_DBL redVal[TRANS_FAC]; /* reduction values; in short-block case one redVal for each group */
- QC_OUT_CHANNEL *qcOutChan = NULL;
- PSY_OUT_CHANNEL *psyOutChan = NULL;
-
-#define SCALE_GROUP_ENERGY (8)
-
-#define CONST_CHAOS_MEAS_AVG_FAC_0 (FL2FXCONST_DBL(0.25f))
-#define CONST_CHAOS_MEAS_AVG_FAC_1 (FL2FXCONST_DBL(1.f-0.25f))
-
-#define MIN_LDTHRESH (FL2FXCONST_DBL(-0.515625f))
-
-
- for(ch=0; ch<nChannels; ch++){
- qcOutChan = qcOutChannel[ch];
- psyOutChan = psyOutChannel[ch];
-
- /* adding up energy for each channel and each group separately */
- FIXP_DBL chEnergy = FL2FXCONST_DBL(0.f);
- groupCnt=0;
-
- for (sfbGrp=0; sfbGrp<psyOutChan->sfbCnt; sfbGrp+=psyOutChan->sfbPerGroup, groupCnt++) {
- chGroupEnergy[groupCnt][ch] = FL2FXCONST_DBL(0.f);
- for (sfb=0; sfb<psyOutChan->maxSfbPerGroup; sfb++){
- chGroupEnergy[groupCnt][ch] += (psyOutChan->sfbEnergy[sfbGrp+sfb]>>SCALE_GROUP_ENERGY);
- }
- chEnergy += chGroupEnergy[groupCnt][ch];
- }
- frameEnergy += chEnergy;
-
- /* chaosMeasure */
- if (psyOutChannel[0]->lastWindowSequence == SHORT_WINDOW) {
- chChaosMeasure[ch] = FL2FXCONST_DBL(0.5f); /* assume a constant chaos measure of 0.5f for short blocks */
- } else {
- chChaosMeasure[ch] = FDKaacEnc_calcChaosMeasure(psyOutChannel[ch], qcOutChannel[ch]->sfbFormFactorLdData);
- }
- chaosMeasure += fMult(chChaosMeasure[ch], chEnergy);
- }
-
- if(frameEnergy > chaosMeasure) {
- INT scale = CntLeadingZeros(frameEnergy) - 1;
- FIXP_DBL num = chaosMeasure<<scale;
- FIXP_DBL denum = frameEnergy<<scale;
- chaosMeasure = schur_div(num,denum,16);
- }
- else {
- chaosMeasure = FL2FXCONST_DBL(1.f);
- }
-
- chaosMeasureAvg = fMult(CONST_CHAOS_MEAS_AVG_FAC_0, chaosMeasure) +
- fMult(CONST_CHAOS_MEAS_AVG_FAC_1, *chaosMeasureOld); /* averaging chaos measure */
- *chaosMeasureOld = chaosMeasure = (fixMin(chaosMeasure, chaosMeasureAvg)); /* use min-value, safe for next frame */
-
- /* characteristic curve
- chaosMeasure = 0.2f + 0.7f/0.3f * (chaosMeasure - 0.2f);
- chaosMeasure = fixMin(1.0f, fixMax(0.1f, chaosMeasure));
- constants scaled by 4.f
- */
- chaosMeasure = ((FL2FXCONST_DBL(0.2f)>>2) + fMult(FL2FXCONST_DBL(0.7f/(4.f*0.3f)), (chaosMeasure - FL2FXCONST_DBL(0.2f))));
- chaosMeasure = (fixMin((FIXP_DBL)(FL2FXCONST_DBL(1.0f)>>2), fixMax((FIXP_DBL)(FL2FXCONST_DBL(0.1f)>>2), chaosMeasure)))<<2;
-
- /* calculation of reduction value */
- if (psyOutChannel[0]->lastWindowSequence == SHORT_WINDOW){ /* short-blocks */
- FDK_ASSERT(TRANS_FAC==8);
- #define WIN_TYPE_SCALE (3)
-
- INT sfbGrp, groupCnt=0;
- for (sfbGrp=0; sfbGrp<psyOutChan->sfbCnt; sfbGrp+=psyOutChan->sfbPerGroup,groupCnt++) {
-
- FIXP_DBL groupEnergy = FL2FXCONST_DBL(0.f);
-
- for(ch=0;ch<nChannels;ch++){
- groupEnergy += chGroupEnergy[groupCnt][ch]; /* adding up the channels groupEnergy */
- }
-
- FDK_ASSERT(psyOutChannel[0]->groupLen[groupCnt]<=INV_INT_TAB_SIZE);
- groupEnergy = fMult(groupEnergy,invInt[psyOutChannel[0]->groupLen[groupCnt]]); /* correction of group energy */
- groupEnergy = fixMin(groupEnergy, frameEnergy>>WIN_TYPE_SCALE); /* do not allow an higher redVal as calculated framewise */
-
- groupEnergy>>=2; /* 2*WIN_TYPE_SCALE = 6 => 6+2 = 8 ==> 8/4 = int number */
-
- redVal[groupCnt] = fMult(fMult(vbrQualFactor,chaosMeasure),
- CalcInvLdData(CalcLdData(groupEnergy)>>2) )
- << (int)( ( 2 + (2*WIN_TYPE_SCALE) + SCALE_GROUP_ENERGY )>>2 ) ;
-
- }
- } else { /* long-block */
-
- redVal[0] = fMult( fMult(vbrQualFactor,chaosMeasure),
- CalcInvLdData(CalcLdData(frameEnergy)>>2) )
- << (int)( SCALE_GROUP_ENERGY>>2 ) ;
- }
-
- for(ch=0; ch<nChannels; ch++) {
- qcOutChan = qcOutChannel[ch];
- psyOutChan = psyOutChannel[ch];
-
- for (sfbGrp=0; sfbGrp<psyOutChan->sfbCnt; sfbGrp+=psyOutChan->sfbPerGroup) {
- for (sfb=0; sfb<psyOutChan->maxSfbPerGroup; sfb++){
-
- sfbEnLdData = (qcOutChan->sfbWeightedEnergyLdData[sfbGrp+sfb]);
- sfbThrLdData = (qcOutChan->sfbThresholdLdData[sfbGrp+sfb]);
- sfbThrExp = thrExp[ch][sfbGrp+sfb];
-
- if ( (sfbThrLdData>=MIN_LDTHRESH) && (sfbEnLdData > sfbThrLdData) && (ahFlag[ch][sfbGrp+sfb] != AH_ACTIVE)) {
-
- /* Short-Window */
- if (psyOutChannel[ch]->lastWindowSequence == SHORT_WINDOW) {
- const int groupNumber = (int) sfb/psyOutChan->sfbPerGroup;
-
- FDK_ASSERT(INV_SQRT4_TAB_SIZE>psyOutChan->groupLen[groupNumber]);
-
- sfbThrExp = fMult(sfbThrExp, fMult( FL2FXCONST_DBL(2.82f/4.f), invSqrt4[psyOutChan->groupLen[groupNumber]]))<<2 ;
-
- if ( sfbThrExp <= (limitThrReducedLdData-redVal[groupNumber]) ) {
- sfbThrReducedLdData = FL2FXCONST_DBL(-1.0f);
- }
- else {
- if ((FIXP_DBL)redVal[groupNumber] >= FL2FXCONST_DBL(1.0f)-sfbThrExp)
- sfbThrReducedLdData = FL2FXCONST_DBL(0.0f);
- else {
- /* threshold reduction formula */
- sfbThrReducedLdData = CalcLdData(sfbThrExp + redVal[groupNumber]);
- sfbThrReducedLdData <<= 2;
- }
- }
- sfbThrReducedLdData += ( CalcLdInt(psyOutChan->groupLen[groupNumber]) -
- ((FIXP_DBL)6<<(DFRACT_BITS-1-LD_DATA_SHIFT)) );
- }
-
- /* Long-Window */
- else {
- if ((FIXP_DBL)redVal[0] >= FL2FXCONST_DBL(1.0f)-sfbThrExp) {
- sfbThrReducedLdData = FL2FXCONST_DBL(0.0f);
- }
- else {
- /* threshold reduction formula */
- sfbThrReducedLdData = CalcLdData(sfbThrExp + redVal[0]);
- sfbThrReducedLdData <<= 2;
- }
- }
-
- /* avoid holes */
- if ( ((sfbThrReducedLdData - sfbEnLdData) > qcOutChan->sfbMinSnrLdData[sfbGrp+sfb] )
- && (ahFlag[ch][sfbGrp+sfb] != NO_AH) )
- {
- if (qcOutChan->sfbMinSnrLdData[sfbGrp+sfb] > (FL2FXCONST_DBL(-1.0f) - sfbEnLdData) ){
- sfbThrReducedLdData = fixMax((qcOutChan->sfbMinSnrLdData[sfbGrp+sfb] + sfbEnLdData), sfbThrLdData);
- }
- else sfbThrReducedLdData = sfbThrLdData;
- ahFlag[ch][sfbGrp+sfb] = AH_ACTIVE;
- }
-
- if (sfbThrReducedLdData<FL2FXCONST_DBL(-0.5f))
- sfbThrReducedLdData = FL2FXCONST_DBL(-1.f);
-
- /* minimum of 29 dB Ratio for Thresholds */
- if ((sfbEnLdData+FL2FXCONST_DBL(1.0f)) > FL2FXCONST_DBL(9.6336206/LD_DATA_SCALING)){
- sfbThrReducedLdData = fixMax(sfbThrReducedLdData, sfbEnLdData - FL2FXCONST_DBL(9.6336206/LD_DATA_SCALING));
- }
-
- sfbThrReducedLdData = fixMax(MIN_LDTHRESH,sfbThrReducedLdData);
-
- qcOutChan->sfbThresholdLdData[sfbGrp+sfb] = sfbThrReducedLdData;
- }
- }
- }
- }
-}
-
-/*****************************************************************************
-functionname: FDKaacEnc_correctThresh
-description: if pe difference deltaPe between desired pe and real pe is small enough,
-the difference can be distributed among the scale factor bands.
-New thresholds can be derived from this pe-difference
-*****************************************************************************/
-static void FDKaacEnc_correctThresh(CHANNEL_MAPPING* cm,
- QC_OUT_ELEMENT* qcElement[(8)],
- PSY_OUT_ELEMENT* psyOutElement[(8)],
- UCHAR ahFlag[(8)][(2)][MAX_GROUPED_SFB],
- FIXP_DBL thrExp[(8)][(2)][MAX_GROUPED_SFB],
- const FIXP_DBL redVal[(8)],
- const SCHAR redValScaling[(8)],
- const INT deltaPe,
- const INT processElements,
- const INT elementOffset)
-{
- INT ch, sfb, sfbGrp;
- QC_OUT_CHANNEL *qcOutChan;
- PSY_OUT_CHANNEL *psyOutChan;
- PE_CHANNEL_DATA *peChanData;
- FIXP_DBL thrFactorLdData;
- FIXP_DBL sfbEnLdData, sfbThrLdData, sfbThrReducedLdData;
- FIXP_DBL *sfbPeFactorsLdData[(8)][(2)];
- FIXP_DBL sfbNActiveLinesLdData[(8)][(2)][MAX_GROUPED_SFB];
- INT normFactorInt;
- FIXP_DBL normFactorLdData;
-
- INT nElements = elementOffset+processElements;
- INT elementId;
-
- /* scratch is empty; use temporal memory from quantSpec in QC_OUT_CHANNEL */
- for(elementId=elementOffset;elementId<nElements;elementId++) {
- for(ch=0; ch<cm->elInfo[elementId].nChannelsInEl; ch++) {
- SHORT* ptr = qcElement[elementId]->qcOutChannel[ch]->quantSpec;
- sfbPeFactorsLdData[elementId][ch] = (FIXP_DBL*)ptr;
- }
- }
-
- /* for each sfb calc relative factors for pe changes */
- normFactorInt = 0;
-
- for(elementId=elementOffset;elementId<nElements;elementId++) {
- if (cm->elInfo[elementId].elType != ID_DSE) {
-
- for(ch=0; ch<cm->elInfo[elementId].nChannelsInEl; ch++) {
-
- qcOutChan = qcElement[elementId]->qcOutChannel[ch];
- psyOutChan = psyOutElement[elementId]->psyOutChannel[ch];
- peChanData = &qcElement[elementId]->peData.peChannelData[ch];
-
- for(sfbGrp = 0; sfbGrp < psyOutChan->sfbCnt; sfbGrp+= psyOutChan->sfbPerGroup){
- for (sfb=0; sfb<psyOutChan->maxSfbPerGroup; sfb++) {
-
- if ( peChanData->sfbNActiveLines[sfbGrp+sfb] == 0 ) {
- sfbNActiveLinesLdData[elementId][ch][sfbGrp+sfb] = FL2FXCONST_DBL(-1.0f);
- }
- else {
- /* Both CalcLdInt and CalcLdData can be used!
- * No offset has to be subtracted, because sfbNActiveLinesLdData
- * is shorted while thrFactor calculation */
- sfbNActiveLinesLdData[elementId][ch][sfbGrp+sfb] = CalcLdInt(peChanData->sfbNActiveLines[sfbGrp+sfb]);
- }
- if ( ((ahFlag[elementId][ch][sfbGrp+sfb] < AH_ACTIVE) || (deltaPe > 0)) &&
- peChanData->sfbNActiveLines[sfbGrp+sfb] != 0 )
- {
- if (thrExp[elementId][ch][sfbGrp+sfb] > -redVal[elementId]) {
-
- /* sfbPeFactors[ch][sfbGrp+sfb] = peChanData->sfbNActiveLines[sfbGrp+sfb] /
- (thrExp[elementId][ch][sfbGrp+sfb] + redVal[elementId]); */
-
- int minScale = fixMin(CountLeadingBits(thrExp[elementId][ch][sfbGrp+sfb]), CountLeadingBits(redVal[elementId]) - (DFRACT_BITS-1-redValScaling[elementId]) ) - 1;
-
- /* sumld = ld64( sfbThrExp + redVal ) */
- FIXP_DBL sumLd = CalcLdData(scaleValue(thrExp[elementId][ch][sfbGrp+sfb], minScale) + scaleValue(redVal[elementId], (DFRACT_BITS-1-redValScaling[elementId])+minScale))
- - (FIXP_DBL)(minScale<<(DFRACT_BITS-1-LD_DATA_SHIFT));
-
- if (sumLd < FL2FXCONST_DBL(0.f)) {
- sfbPeFactorsLdData[elementId][ch][sfbGrp+sfb] = sfbNActiveLinesLdData[elementId][ch][sfbGrp+sfb] - sumLd;
- }
- else {
- if ( sfbNActiveLinesLdData[elementId][ch][sfbGrp+sfb] > (FL2FXCONST_DBL(-1.f) + sumLd) ) {
- sfbPeFactorsLdData[elementId][ch][sfbGrp+sfb] = sfbNActiveLinesLdData[elementId][ch][sfbGrp+sfb] - sumLd;
- }
- else {
- sfbPeFactorsLdData[elementId][ch][sfbGrp+sfb] = sfbNActiveLinesLdData[elementId][ch][sfbGrp+sfb];
- }
- }
-
- normFactorInt += (INT)CalcInvLdData(sfbPeFactorsLdData[elementId][ch][sfbGrp+sfb]);
- }
- else sfbPeFactorsLdData[elementId][ch][sfbGrp+sfb] = FL2FXCONST_DBL(1.0f);
- }
- else sfbPeFactorsLdData[elementId][ch][sfbGrp+sfb] = FL2FXCONST_DBL(-1.0f);
- }
- }
- }
- }
- }
-
- /* normFactorLdData = ld64(deltaPe/normFactorInt) */
- normFactorLdData = CalcLdData((FIXP_DBL)((deltaPe<0) ? (-deltaPe) : (deltaPe))) - CalcLdData((FIXP_DBL)normFactorInt);
-
- /* distribute the pe difference to the scalefactors
- and calculate the according thresholds */
- for(elementId=elementOffset;elementId<nElements;elementId++) {
- if (cm->elInfo[elementId].elType != ID_DSE) {
-
- for(ch=0; ch<cm->elInfo[elementId].nChannelsInEl; ch++) {
- qcOutChan = qcElement[elementId]->qcOutChannel[ch];
- psyOutChan = psyOutElement[elementId]->psyOutChannel[ch];
- peChanData = &qcElement[elementId]->peData.peChannelData[ch];
-
- for(sfbGrp = 0;sfbGrp < psyOutChan->sfbCnt;sfbGrp+= psyOutChan->sfbPerGroup){
- for (sfb=0; sfb<psyOutChan->maxSfbPerGroup; sfb++) {
-
- if (peChanData->sfbNActiveLines[sfbGrp+sfb] > 0) {
-
- /* pe difference for this sfb */
- if ( (sfbPeFactorsLdData[elementId][ch][sfbGrp+sfb]==FL2FXCONST_DBL(-1.0f)) ||
- (deltaPe==0) )
- {
- thrFactorLdData = FL2FXCONST_DBL(0.f);
- }
- else {
- /* new threshold */
- FIXP_DBL tmp = CalcInvLdData(sfbPeFactorsLdData[elementId][ch][sfbGrp+sfb] + normFactorLdData - sfbNActiveLinesLdData[elementId][ch][sfbGrp+sfb] - FL2FXCONST_DBL((float)LD_DATA_SHIFT/LD_DATA_SCALING));
-
- /* limit thrFactor to 60dB */
- tmp = (deltaPe<0) ? tmp : (-tmp);
- thrFactorLdData = FDKmin(tmp, FL2FXCONST_DBL(20.f/LD_DATA_SCALING));
- }
-
- /* new threshold */
- sfbThrLdData = qcOutChan->sfbThresholdLdData[sfbGrp+sfb];
- sfbEnLdData = qcOutChan->sfbWeightedEnergyLdData[sfbGrp+sfb];
-
- if (thrFactorLdData < FL2FXCONST_DBL(0.f)) {
- if( sfbThrLdData > (FL2FXCONST_DBL(-1.f)-thrFactorLdData) ) {
- sfbThrReducedLdData = sfbThrLdData + thrFactorLdData;
- }
- else {
- sfbThrReducedLdData = FL2FXCONST_DBL(-1.f);
- }
- }
- else{
- sfbThrReducedLdData = sfbThrLdData + thrFactorLdData;
- }
-
- /* avoid hole */
- if ( (sfbThrReducedLdData - sfbEnLdData > qcOutChan->sfbMinSnrLdData[sfbGrp+sfb]) &&
- (ahFlag[elementId][ch][sfbGrp+sfb] == AH_INACTIVE) )
- {
- /* sfbThrReduced = max(psyOutChan[ch]->sfbMinSnr[i] * sfbEn, sfbThr); */
- if ( sfbEnLdData > (sfbThrLdData-qcOutChan->sfbMinSnrLdData[sfbGrp+sfb]) ) {
- sfbThrReducedLdData = qcOutChan->sfbMinSnrLdData[sfbGrp+sfb] + sfbEnLdData;
- }
- else {
- sfbThrReducedLdData = sfbThrLdData;
- }
- ahFlag[elementId][ch][sfbGrp+sfb] = AH_ACTIVE;
- }
-
- qcOutChan->sfbThresholdLdData[sfbGrp+sfb] = sfbThrReducedLdData;
- }
- }
- }
- }
- }
- }
-}
-
-/*****************************************************************************
- functionname: FDKaacEnc_reduceMinSnr
- description: if the desired pe can not be reached, reduce pe by
- reducing minSnr
-*****************************************************************************/
-void FDKaacEnc_reduceMinSnr(CHANNEL_MAPPING* cm,
- QC_OUT_ELEMENT* qcElement[(8)],
- PSY_OUT_ELEMENT* psyOutElement[(8)],
- UCHAR ahFlag[(8)][(2)][MAX_GROUPED_SFB],
- const INT desiredPe,
- INT* redPeGlobal,
- const INT processElements,
- const INT elementOffset)
-
-{
- INT elementId;
- INT nElements = elementOffset+processElements;
-
- INT newGlobalPe = *redPeGlobal;
-
- for(elementId=elementOffset;elementId<nElements;elementId++) {
- if (cm->elInfo[elementId].elType != ID_DSE) {
- INT ch;
- INT maxSfbPerGroup[2];
- INT sfbCnt[2];
- INT sfbPerGroup[2];
-
- for(ch=0; ch<cm->elInfo[elementId].nChannelsInEl; ch++) {
- maxSfbPerGroup[ch] = psyOutElement[elementId]->psyOutChannel[ch]->maxSfbPerGroup-1;
- sfbCnt[ch] = psyOutElement[elementId]->psyOutChannel[ch]->sfbCnt;
- sfbPerGroup[ch] = psyOutElement[elementId]->psyOutChannel[ch]->sfbPerGroup;
- }
-
- PE_DATA *peData = &qcElement[elementId]->peData;
-
- do
- {
- for(ch=0; ch<cm->elInfo[elementId].nChannelsInEl; ch++) {
-
- INT sfb, sfbGrp;
- QC_OUT_CHANNEL *qcOutChan = qcElement[elementId]->qcOutChannel[ch];
- INT noReduction = 1;
-
- if (maxSfbPerGroup[ch]>=0) { /* sfb in next channel */
- INT deltaPe = 0;
- sfb = maxSfbPerGroup[ch]--;
- noReduction = 0;
-
- for (sfbGrp = 0; sfbGrp < sfbCnt[ch]; sfbGrp += sfbPerGroup[ch]) {
-
- if (ahFlag[elementId][ch][sfbGrp+sfb] != NO_AH &&
- qcOutChan->sfbMinSnrLdData[sfbGrp+sfb] < SnrLdFac)
- {
- /* increase threshold to new minSnr of 1dB */
- qcOutChan->sfbMinSnrLdData[sfbGrp+sfb] = SnrLdFac;
-
- /* sfbThrReduced = max(psyOutChan[ch]->sfbMinSnr[i] * sfbEn, sfbThr); */
- if ( qcOutChan->sfbWeightedEnergyLdData[sfbGrp+sfb] >= qcOutChan->sfbThresholdLdData[sfbGrp+sfb] - qcOutChan->sfbMinSnrLdData[sfbGrp+sfb] ) {
-
- qcOutChan->sfbThresholdLdData[sfbGrp+sfb] = qcOutChan->sfbWeightedEnergyLdData[sfbGrp+sfb] + qcOutChan->sfbMinSnrLdData[sfbGrp+sfb];
-
- /* calc new pe */
- /* C2 + C3*ld(1/0.8) = 1.5 */
- deltaPe -= (peData->peChannelData[ch].sfbPe[sfbGrp+sfb]>>PE_CONSTPART_SHIFT);
-
- /* sfbPe = 1.5 * sfbNLines */
- peData->peChannelData[ch].sfbPe[sfbGrp+sfb] = (3*peData->peChannelData[ch].sfbNLines[sfbGrp+sfb]) << (PE_CONSTPART_SHIFT-1);
- deltaPe += (peData->peChannelData[ch].sfbPe[sfbGrp+sfb]>>PE_CONSTPART_SHIFT);
- }
- }
-
- } /* sfbGrp loop */
-
- peData->pe += deltaPe;
- peData->peChannelData[ch].pe += deltaPe;
- newGlobalPe += deltaPe;
-
- /* stop if enough has been saved */
- if (peData->pe <= desiredPe) {
- goto bail;
- }
-
- } /* sfb > 0 */
-
- if ( (ch==(cm->elInfo[elementId].nChannelsInEl-1)) && noReduction ) {
- goto bail;
- }
-
- } /* ch loop */
-
- } while ( peData->pe > desiredPe);
-
- } /* != ID_DSE */
- } /* element loop */
-
-
-bail:
- /* update global PE */
- *redPeGlobal = newGlobalPe;
-}
-
-
-/*****************************************************************************
- functionname: FDKaacEnc_allowMoreHoles
- description: if the desired pe can not be reached, some more scalefactor
- bands have to be quantized to zero
-*****************************************************************************/
-static void FDKaacEnc_allowMoreHoles(CHANNEL_MAPPING* cm,
- QC_OUT_ELEMENT* qcElement[(8)],
- PSY_OUT_ELEMENT* psyOutElement[(8)],
- ATS_ELEMENT* AdjThrStateElement[(8)],
- UCHAR ahFlag[(8)][(2)][MAX_GROUPED_SFB],
- const INT desiredPe,
- const INT currentPe,
- const int processElements,
- const int elementOffset)
-{
- INT elementId;
- INT nElements = elementOffset+processElements;
- INT actPe = currentPe;
-
- if (actPe <= desiredPe) {
- return; /* nothing to do */
- }
-
- for (elementId = elementOffset;elementId<nElements;elementId++) {
- if (cm->elInfo[elementId].elType != ID_DSE) {
-
- INT ch, sfb, sfbGrp;
-
- PE_DATA *peData = &qcElement[elementId]->peData;
- const INT nChannels = cm->elInfo[elementId].nChannelsInEl;
-
- QC_OUT_CHANNEL* qcOutChannel[(2)] = {NULL};
- PSY_OUT_CHANNEL* psyOutChannel[(2)] = {NULL};
-
- for (ch=0; ch<nChannels; ch++) {
-
- /* init pointers */
- qcOutChannel[ch] = qcElement[elementId]->qcOutChannel[ch];
- psyOutChannel[ch] = psyOutElement[elementId]->psyOutChannel[ch];
-
- for(sfbGrp=0; sfbGrp < psyOutChannel[ch]->sfbCnt; sfbGrp+= psyOutChannel[ch]->sfbPerGroup) {
- for (sfb=psyOutChannel[ch]->maxSfbPerGroup; sfb<psyOutChannel[ch]->sfbPerGroup; sfb++) {
- peData->peChannelData[ch].sfbPe[sfbGrp+sfb] = 0;
- }
- }
- }
-
- /* for MS allow hole in the channel with less energy */
- if ( nChannels==2 && psyOutChannel[0]->lastWindowSequence==psyOutChannel[1]->lastWindowSequence ) {
-
- for (sfb=0; sfb<psyOutChannel[0]->maxSfbPerGroup; sfb++) {
- for(sfbGrp=0; sfbGrp < psyOutChannel[0]->sfbCnt; sfbGrp+=psyOutChannel[0]->sfbPerGroup) {
- if (psyOutElement[elementId]->toolsInfo.msMask[sfbGrp+sfb]) {
- FIXP_DBL EnergyLd_L = qcOutChannel[0]->sfbWeightedEnergyLdData[sfbGrp+sfb];
- FIXP_DBL EnergyLd_R = qcOutChannel[1]->sfbWeightedEnergyLdData[sfbGrp+sfb];
-
- /* allow hole in side channel ? */
- if ( (ahFlag[elementId][1][sfbGrp+sfb] != NO_AH) &&
- (((FL2FXCONST_DBL(-0.02065512648f)>>1) + (qcOutChannel[0]->sfbMinSnrLdData[sfbGrp+sfb]>>1))
- > ((EnergyLd_R>>1) - (EnergyLd_L>>1))) )
- {
- ahFlag[elementId][1][sfbGrp+sfb] = NO_AH;
- qcOutChannel[1]->sfbThresholdLdData[sfbGrp+sfb] = FL2FXCONST_DBL(0.015625f) + EnergyLd_R;
- actPe -= peData->peChannelData[1].sfbPe[sfbGrp+sfb]>>PE_CONSTPART_SHIFT;
- }
- /* allow hole in mid channel ? */
- else if ( (ahFlag[elementId][0][sfbGrp+sfb] != NO_AH) &&
- (((FL2FXCONST_DBL(-0.02065512648f)>>1) + (qcOutChannel[1]->sfbMinSnrLdData[sfbGrp+sfb]>>1))
- > ((EnergyLd_L>>1) - (EnergyLd_R>>1))) )
- {
- ahFlag[elementId][0][sfbGrp+sfb] = NO_AH;
- qcOutChannel[0]->sfbThresholdLdData[sfbGrp+sfb] = FL2FXCONST_DBL(0.015625f) + EnergyLd_L;
- actPe -= peData->peChannelData[0].sfbPe[sfbGrp+sfb]>>PE_CONSTPART_SHIFT;
- } /* if (ahFlag) */
- } /* if MS */
- } /* sfbGrp */
- if (actPe <= desiredPe) {
- return; /* stop if enough has been saved */
- }
- } /* sfb */
- } /* MS possible ? */
-
- /* more holes necessary? subsequently erase bands
- starting with low energies */
- INT startSfb[2];
- FIXP_DBL avgEnLD64,minEnLD64;
- INT ahCnt;
- FIXP_DBL ahCntLD64;
- INT enIdx;
- FIXP_DBL enLD64[4];
- FIXP_DBL avgEn;
-
- /* do not go below startSfb */
- for (ch=0; ch<nChannels; ch++) {
- if (psyOutChannel[ch]->lastWindowSequence != SHORT_WINDOW)
- startSfb[ch] = AdjThrStateElement[elementId]->ahParam.startSfbL;
- else
- startSfb[ch] = AdjThrStateElement[elementId]->ahParam.startSfbS;
- }
-
- /* calc avg and min energies of bands that avoid holes */
- avgEn = FL2FXCONST_DBL(0.0f);
- minEnLD64 = FL2FXCONST_DBL(0.0f);
- ahCnt = 0;
-
- for (ch=0; ch<nChannels; ch++) {
-
- sfbGrp=0;
- sfb=startSfb[ch];
-
- do {
- for (; sfb<psyOutChannel[ch]->maxSfbPerGroup; sfb++) {
- if ((ahFlag[elementId][ch][sfbGrp+sfb]!=NO_AH) &&
- (qcOutChannel[ch]->sfbWeightedEnergyLdData[sfbGrp+sfb] > qcOutChannel[ch]->sfbThresholdLdData[sfbGrp+sfb])){
- minEnLD64 = fixMin(minEnLD64,qcOutChannel[ch]->sfbEnergyLdData[sfbGrp+sfb]);
- avgEn += qcOutChannel[ch]->sfbEnergy[sfbGrp+sfb] >> 6;
- ahCnt++;
- }
- }
-
- sfbGrp += psyOutChannel[ch]->sfbPerGroup;
- sfb=0;
-
- } while (sfbGrp < psyOutChannel[ch]->sfbCnt);
- }
-
- if ( (avgEn == FL2FXCONST_DBL(0.0f)) || (ahCnt == 0) ) {
- avgEnLD64 = FL2FXCONST_DBL(0.0f);
- }
- else {
- avgEnLD64 = CalcLdData(avgEn);
- ahCntLD64 = CalcLdInt(ahCnt);
- avgEnLD64 = avgEnLD64 + FL2FXCONST_DBL(0.09375f) - ahCntLD64; /* compensate shift with 6 */
- }
-
- /* calc some energy borders between minEn and avgEn */
- /* for (enIdx=0; enIdx<4; enIdx++) */
- /* en[enIdx] = minEn * (float)FDKpow(avgEn/(minEn+FLT_MIN), (2*enIdx+1)/7.0f); */
- enLD64[0] = minEnLD64 + fMult((avgEnLD64-minEnLD64),FL2FXCONST_DBL(0.14285714285f));
- enLD64[1] = minEnLD64 + fMult((avgEnLD64-minEnLD64),FL2FXCONST_DBL(0.42857142857f));
- enLD64[2] = minEnLD64 + fMult((avgEnLD64-minEnLD64),FL2FXCONST_DBL(0.71428571428f));
- enLD64[3] = minEnLD64 + (avgEnLD64-minEnLD64);
-
- for (enIdx=0; enIdx<4; enIdx++) {
- INT noReduction = 1;
-
- INT maxSfbPerGroup[2];
- INT sfbCnt[2];
- INT sfbPerGroup[2];
-
- for(ch=0; ch<cm->elInfo[elementId].nChannelsInEl; ch++) {
- maxSfbPerGroup[ch] = psyOutElement[elementId]->psyOutChannel[ch]->maxSfbPerGroup-1;
- sfbCnt[ch] = psyOutElement[elementId]->psyOutChannel[ch]->sfbCnt;
- sfbPerGroup[ch] = psyOutElement[elementId]->psyOutChannel[ch]->sfbPerGroup;
- }
-
- do {
-
- noReduction = 1;
-
- for(ch=0; ch<cm->elInfo[elementId].nChannelsInEl; ch++) {
-
- INT sfb, sfbGrp;
-
- /* start with lowest energy border at highest sfb */
- if (maxSfbPerGroup[ch]>=startSfb[ch]) { /* sfb in next channel */
- sfb = maxSfbPerGroup[ch]--;
- noReduction = 0;
-
- for (sfbGrp = 0; sfbGrp < sfbCnt[ch]; sfbGrp += sfbPerGroup[ch]) {
- /* sfb energy below border ? */
- if (ahFlag[elementId][ch][sfbGrp+sfb] != NO_AH && qcOutChannel[ch]->sfbEnergyLdData[sfbGrp+sfb] < enLD64[enIdx]) {
- /* allow hole */
- ahFlag[elementId][ch][sfbGrp+sfb] = NO_AH;
- qcOutChannel[ch]->sfbThresholdLdData[sfbGrp+sfb] = FL2FXCONST_DBL(0.015625f) + qcOutChannel[ch]->sfbWeightedEnergyLdData[sfbGrp+sfb];
- actPe -= peData->peChannelData[ch].sfbPe[sfbGrp+sfb]>>PE_CONSTPART_SHIFT;
- }
- } /* sfbGrp */
-
- if (actPe <= desiredPe) {
- return; /* stop if enough has been saved */
- }
- } /* sfb > 0 */
- } /* ch loop */
-
- } while( (noReduction == 0) && (actPe > desiredPe) );
-
- if (actPe <= desiredPe) {
- return; /* stop if enough has been saved */
- }
-
- } /* enIdx loop */
-
- } /* EOF DSE-suppression */
- } /* EOF for all elements... */
-
-}
-
-/* reset avoid hole flags from AH_ACTIVE to AH_INACTIVE */
-static void FDKaacEnc_resetAHFlags( UCHAR ahFlag[(2)][MAX_GROUPED_SFB],
- const int nChannels,
- PSY_OUT_CHANNEL *psyOutChannel[(2)])
-{
- int ch, sfb, sfbGrp;
-
- for(ch=0; ch<nChannels; ch++) {
- for (sfbGrp=0; sfbGrp < psyOutChannel[ch]->sfbCnt; sfbGrp+=psyOutChannel[ch]->sfbPerGroup) {
- for (sfb=0; sfb<psyOutChannel[ch]->maxSfbPerGroup; sfb++) {
- if ( ahFlag[ch][sfbGrp+sfb] == AH_ACTIVE) {
- ahFlag[ch][sfbGrp+sfb] = AH_INACTIVE;
- }
- }
- }
- }
-}
-
-
-static FIXP_DBL CalcRedValPower(FIXP_DBL num,
- FIXP_DBL denum,
- INT* scaling )
-{
- FIXP_DBL value = FL2FXCONST_DBL(0.f);
-
- if (num>=FL2FXCONST_DBL(0.f)) {
- value = fDivNorm( num, denum, scaling);
- }
- else {
- value = -fDivNorm( -num, denum, scaling);
- }
- value = f2Pow(value, *scaling, scaling);
- *scaling = DFRACT_BITS-1-*scaling;
-
- return value;
-}
-
-
-/*****************************************************************************
-functionname: FDKaacEnc_adaptThresholdsToPe
-description: two guesses for the reduction value and one final correction of the thresholds
-*****************************************************************************/
-static void FDKaacEnc_adaptThresholdsToPe(CHANNEL_MAPPING* cm,
- ATS_ELEMENT* AdjThrStateElement[(8)],
- QC_OUT_ELEMENT* qcElement[(8)],
- PSY_OUT_ELEMENT* psyOutElement[(8)],
- const INT desiredPe,
- const INT processElements,
- const INT elementOffset)
-{
- FIXP_DBL redValue[(8)];
- SCHAR redValScaling[(8)];
- UCHAR pAhFlag[(8)][(2)][MAX_GROUPED_SFB];
- FIXP_DBL pThrExp[(8)][(2)][MAX_GROUPED_SFB];
- int iter;
-
- INT constPartGlobal, noRedPeGlobal, nActiveLinesGlobal, redPeGlobal;
- constPartGlobal = noRedPeGlobal = nActiveLinesGlobal = redPeGlobal = 0;
-
- int elementId;
-
- int nElements = elementOffset+processElements;
- if(nElements > cm->nElements) {
- nElements = cm->nElements;
- }
-
- /* ------------------------------------------------------- */
- /* Part I: Initialize data structures and variables... */
- /* ------------------------------------------------------- */
- for (elementId = elementOffset;elementId<nElements;elementId++) {
- if (cm->elInfo[elementId].elType != ID_DSE) {
-
- INT nChannels = cm->elInfo[elementId].nChannelsInEl;
- PE_DATA *peData = &qcElement[elementId]->peData;
-
- /* thresholds to the power of redExp */
- FDKaacEnc_calcThreshExp(pThrExp[elementId], qcElement[elementId]->qcOutChannel, psyOutElement[elementId]->psyOutChannel, nChannels);
-
- /* lower the minSnr requirements for low energies compared to the average
- energy in this frame */
- FDKaacEnc_adaptMinSnr(qcElement[elementId]->qcOutChannel, psyOutElement[elementId]->psyOutChannel, &AdjThrStateElement[elementId]->minSnrAdaptParam, nChannels);
-
- /* init ahFlag (0: no ah necessary, 1: ah possible, 2: ah active */
- FDKaacEnc_initAvoidHoleFlag(qcElement[elementId]->qcOutChannel, psyOutElement[elementId]->psyOutChannel, pAhFlag[elementId], &psyOutElement[elementId]->toolsInfo, nChannels, peData, &AdjThrStateElement[elementId]->ahParam);
-
- /* sum up */
- constPartGlobal += peData->constPart;
- noRedPeGlobal += peData->pe;
- nActiveLinesGlobal += fixMax((INT)peData->nActiveLines, 1);
-
- } /* EOF DSE-suppression */
- } /* EOF for all elements... */
-
- /* ----------------------------------------------------------------------- */
- /* Part II: Calculate bit consumption of initial bit constraints setup */
- /* ----------------------------------------------------------------------- */
- for (elementId = elementOffset;elementId<nElements;elementId++) {
- if (cm->elInfo[elementId].elType != ID_DSE) {
- /*
- redVal = ( 2 ^ ( (constPartGlobal-desiredPe) / (invRedExp*nActiveLinesGlobal) )
- - 2 ^ ( (constPartGlobal-noRedPeGlobal) / (invRedExp*nActiveLinesGlobal) ) )
- */
-
-
- INT nChannels = cm->elInfo[elementId].nChannelsInEl;
- PE_DATA *peData = &qcElement[elementId]->peData;
-
- /* first guess of reduction value */
- int scale0=0, scale1=0;
- FIXP_DBL tmp0 = CalcRedValPower( constPartGlobal-desiredPe, 4*nActiveLinesGlobal, &scale0 );
- FIXP_DBL tmp1 = CalcRedValPower( constPartGlobal-noRedPeGlobal, 4*nActiveLinesGlobal, &scale1 );
-
- int scalMin = FDKmin(scale0, scale1)-1;
-
- redValue[elementId] = scaleValue(tmp0,(scalMin-scale0)) - scaleValue(tmp1,(scalMin-scale1));
- redValScaling[elementId] = scalMin;
-
- /* reduce thresholds */
- FDKaacEnc_reduceThresholdsCBR(qcElement[elementId]->qcOutChannel, psyOutElement[elementId]->psyOutChannel, pAhFlag[elementId], pThrExp[elementId], nChannels, redValue[elementId], redValScaling[elementId]);
-
- /* pe after first guess */
- FDKaacEnc_calcPe(psyOutElement[elementId]->psyOutChannel, qcElement[elementId]->qcOutChannel, peData, nChannels);
-
- redPeGlobal += peData->pe;
- } /* EOF DSE-suppression */
- } /* EOF for all elements... */
-
- /* -------------------------------------------------- */
- /* Part III: Iterate until bit constraints are met */
- /* -------------------------------------------------- */
- iter = 0;
- while ((fixp_abs(redPeGlobal - desiredPe) > fMultI(FL2FXCONST_DBL(0.05f),desiredPe)) && (iter < 1)) {
-
- INT desiredPeNoAHGlobal;
- INT redPeNoAHGlobal = 0;
- INT constPartNoAHGlobal = 0;
- INT nActiveLinesNoAHGlobal = 0;
-
- for (elementId = elementOffset;elementId<nElements;elementId++) {
- if (cm->elInfo[elementId].elType != ID_DSE) {
-
- INT redPeNoAH, constPartNoAH, nActiveLinesNoAH;
- INT nChannels = cm->elInfo[elementId].nChannelsInEl;
- PE_DATA *peData = &qcElement[elementId]->peData;
-
- /* pe for bands where avoid hole is inactive */
- FDKaacEnc_FDKaacEnc_calcPeNoAH(&redPeNoAH, &constPartNoAH, &nActiveLinesNoAH,
- peData, pAhFlag[elementId], psyOutElement[elementId]->psyOutChannel, nChannels);
-
- redPeNoAHGlobal += redPeNoAH;
- constPartNoAHGlobal += constPartNoAH;
- nActiveLinesNoAHGlobal += nActiveLinesNoAH;
- } /* EOF DSE-suppression */
- } /* EOF for all elements... */
-
- /* Calculate new redVal ... */
- if(desiredPe < redPeGlobal) {
-
- /* new desired pe without bands where avoid hole is active */
- desiredPeNoAHGlobal = desiredPe - (redPeGlobal - redPeNoAHGlobal);
-
- /* limit desiredPeNoAH to positive values, as the PE can not become negative */
- desiredPeNoAHGlobal = FDKmax(0,desiredPeNoAHGlobal);
-
- /* second guess (only if there are bands left where avoid hole is inactive)*/
- if (nActiveLinesNoAHGlobal > 0) {
- for (elementId = elementOffset;elementId<nElements;elementId++) {
- if (cm->elInfo[elementId].elType != ID_DSE) {
- /*
- redVal += ( 2 ^ ( (constPartNoAHGlobal-desiredPeNoAHGlobal) / (invRedExp*nActiveLinesNoAHGlobal) )
- - 2 ^ ( (constPartNoAHGlobal-redPeNoAHGlobal) / (invRedExp*nActiveLinesNoAHGlobal) ) )
- */
- int scale0 = 0;
- int scale1 = 0;
-
- FIXP_DBL tmp0 = CalcRedValPower( constPartNoAHGlobal-desiredPeNoAHGlobal, 4*nActiveLinesNoAHGlobal, &scale0 );
- FIXP_DBL tmp1 = CalcRedValPower( constPartNoAHGlobal-redPeNoAHGlobal, 4*nActiveLinesNoAHGlobal, &scale1 );
-
- int scalMin = FDKmin(scale0, scale1)-1;
-
- tmp0 = scaleValue(tmp0,(scalMin-scale0)) - scaleValue(tmp1,(scalMin-scale1));
- scale0 = scalMin;
-
- /* old reduction value */
- tmp1 = redValue[elementId];
- scale1 = redValScaling[elementId];
-
- scalMin = fixMin(scale0,scale1)-1;
-
- /* sum up old and new reduction value */
- redValue[elementId] = scaleValue(tmp0,(scalMin-scale0)) + scaleValue(tmp1,(scalMin-scale1));
- redValScaling[elementId] = scalMin;
-
- } /* EOF DSE-suppression */
- } /* EOF for all elements... */
- } /* nActiveLinesNoAHGlobal > 0 */
- }
- else {
- /* desiredPe >= redPeGlobal */
- for (elementId = elementOffset;elementId<nElements;elementId++) {
- if (cm->elInfo[elementId].elType != ID_DSE) {
-
- INT redVal_scale = 0;
- FIXP_DBL tmp = fDivNorm((FIXP_DBL)redPeGlobal, (FIXP_DBL)desiredPe, &redVal_scale);
-
- /* redVal *= redPeGlobal/desiredPe; */
- redValue[elementId] = fMult(redValue[elementId], tmp);
- redValScaling[elementId] -= redVal_scale;
-
- FDKaacEnc_resetAHFlags(pAhFlag[elementId], cm->elInfo[elementId].nChannelsInEl, psyOutElement[elementId]->psyOutChannel);
- } /* EOF DSE-suppression */
- } /* EOF for all elements... */
- }
-
- redPeGlobal = 0;
- /* Calculate new redVal's PE... */
- for (elementId = elementOffset;elementId<nElements;elementId++) {
- if (cm->elInfo[elementId].elType != ID_DSE) {
-
- INT nChannels = cm->elInfo[elementId].nChannelsInEl;
- PE_DATA *peData = &qcElement[elementId]->peData;
-
- /* reduce thresholds */
- FDKaacEnc_reduceThresholdsCBR(qcElement[elementId]->qcOutChannel, psyOutElement[elementId]->psyOutChannel, pAhFlag[elementId], pThrExp[elementId], nChannels, redValue[elementId], redValScaling[elementId]);
-
- /* pe after second guess */
- FDKaacEnc_calcPe(psyOutElement[elementId]->psyOutChannel, qcElement[elementId]->qcOutChannel, peData, nChannels);
- redPeGlobal += peData->pe;
-
- } /* EOF DSE-suppression */
- } /* EOF for all elements... */
-
- iter++;
- } /* EOF while */
-
-
- /* ------------------------------------------------------- */
- /* Part IV: if still required, further reduce constraints */
- /* ------------------------------------------------------- */
- /* 1.0* 1.15* 1.20*
- * desiredPe desiredPe desiredPe
- * | | |
- * ...XXXXXXXXXXXXXXXXXXXXXXXXXXX| |
- * | | |XXXXXXXXXXX...
- * | |XXXXXXXXXXX|
- * --- A --- | --- B --- | --- C ---
- *
- * (X): redPeGlobal
- * (A): FDKaacEnc_correctThresh()
- * (B): FDKaacEnc_allowMoreHoles()
- * (C): FDKaacEnc_reduceMinSnr()
- */
-
- /* correct thresholds to get closer to the desired pe */
- if ( redPeGlobal > desiredPe ) {
- FDKaacEnc_correctThresh(cm, qcElement, psyOutElement, pAhFlag, pThrExp, redValue, redValScaling,
- desiredPe - redPeGlobal, processElements, elementOffset);
-
- /* update PE */
- redPeGlobal = 0;
- for(elementId=elementOffset;elementId<nElements;elementId++) {
- if (cm->elInfo[elementId].elType != ID_DSE) {
-
- INT nChannels = cm->elInfo[elementId].nChannelsInEl;
- PE_DATA *peData = &qcElement[elementId]->peData;
-
- /* pe after correctThresh */
- FDKaacEnc_calcPe(psyOutElement[elementId]->psyOutChannel, qcElement[elementId]->qcOutChannel, peData, nChannels);
- redPeGlobal += peData->pe;
-
- } /* EOF DSE-suppression */
- } /* EOF for all elements... */
- }
-
- if ( redPeGlobal > desiredPe ) {
- /* reduce pe by reducing minSnr requirements */
- FDKaacEnc_reduceMinSnr(cm, qcElement, psyOutElement, pAhFlag,
- (fMultI(FL2FXCONST_DBL(0.15f),desiredPe) + desiredPe),
- &redPeGlobal, processElements, elementOffset);
-
- /* reduce pe by allowing additional spectral holes */
- FDKaacEnc_allowMoreHoles(cm, qcElement, psyOutElement, AdjThrStateElement, pAhFlag,
- desiredPe, redPeGlobal, processElements, elementOffset);
- }
-
-}
-
-/* similar to FDKaacEnc_adaptThresholdsToPe(), for VBR-mode */
-void FDKaacEnc_AdaptThresholdsVBR(QC_OUT_CHANNEL* qcOutChannel[(2)],
- PSY_OUT_CHANNEL* psyOutChannel[(2)],
- ATS_ELEMENT* AdjThrStateElement,
- struct TOOLSINFO *toolsInfo,
- PE_DATA *peData,
- const INT nChannels)
-{
- UCHAR (*pAhFlag)[MAX_GROUPED_SFB];
- FIXP_DBL (*pThrExp)[MAX_GROUPED_SFB];
-
- /* allocate scratch memory */
- C_ALLOC_SCRATCH_START(_pAhFlag, UCHAR, (2)*MAX_GROUPED_SFB)
- C_ALLOC_SCRATCH_START(_pThrExp, FIXP_DBL, (2)*MAX_GROUPED_SFB)
- pAhFlag = (UCHAR(*)[MAX_GROUPED_SFB])_pAhFlag;
- pThrExp = (FIXP_DBL(*)[MAX_GROUPED_SFB])_pThrExp;
-
- /* thresholds to the power of redExp */
- FDKaacEnc_calcThreshExp(pThrExp, qcOutChannel, psyOutChannel, nChannels);
-
- /* lower the minSnr requirements for low energies compared to the average
- energy in this frame */
- FDKaacEnc_adaptMinSnr(qcOutChannel, psyOutChannel, &AdjThrStateElement->minSnrAdaptParam, nChannels);
-
- /* init ahFlag (0: no ah necessary, 1: ah possible, 2: ah active */
- FDKaacEnc_initAvoidHoleFlag(qcOutChannel, psyOutChannel, pAhFlag, toolsInfo,
- nChannels, peData, &AdjThrStateElement->ahParam);
-
- /* reduce thresholds */
- FDKaacEnc_reduceThresholdsVBR(qcOutChannel, psyOutChannel, pAhFlag, pThrExp, nChannels,
- AdjThrStateElement->vbrQualFactor,
- &AdjThrStateElement->chaosMeasureOld);
-
- /* free scratch memory */
- C_ALLOC_SCRATCH_END(_pThrExp, FIXP_DBL, (2)*MAX_GROUPED_SFB)
- C_ALLOC_SCRATCH_END(_pAhFlag, UCHAR, (2)*MAX_GROUPED_SFB)
-}
-
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_calcBitSave
- description: Calculates percentage of bit save, see figure below
- returns:
- input: parameters and bitres-fullness
- output: percentage of bit save
-
-*****************************************************************************/
-/*
- bitsave
- maxBitSave(%)| clipLow
- |---\
- | \
- | \
- | \
- | \
- |--------\--------------> bitres
- | \
- minBitSave(%)| \------------
- clipHigh maxBitres
-*/
-static FIXP_DBL FDKaacEnc_calcBitSave(FIXP_DBL fillLevel,
- const FIXP_DBL clipLow,
- const FIXP_DBL clipHigh,
- const FIXP_DBL minBitSave,
- const FIXP_DBL maxBitSave,
- const FIXP_DBL bitsave_slope)
-{
- FIXP_DBL bitsave;
-
- fillLevel = fixMax(fillLevel, clipLow);
- fillLevel = fixMin(fillLevel, clipHigh);
-
- bitsave = maxBitSave - fMult((fillLevel-clipLow), bitsave_slope);
-
- return (bitsave);
-}
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_calcBitSpend
- description: Calculates percentage of bit spend, see figure below
- returns:
- input: parameters and bitres-fullness
- output: percentage of bit spend
-
-*****************************************************************************/
-/*
- bitspend clipHigh
- maxBitSpend(%)| /-----------maxBitres
- | /
- | /
- | /
- | /
- | /
- |----/-----------------> bitres
- | /
- minBitSpend(%)|--/
- clipLow
-*/
-static FIXP_DBL FDKaacEnc_calcBitSpend(FIXP_DBL fillLevel,
- const FIXP_DBL clipLow,
- const FIXP_DBL clipHigh,
- const FIXP_DBL minBitSpend,
- const FIXP_DBL maxBitSpend,
- const FIXP_DBL bitspend_slope)
-{
- FIXP_DBL bitspend;
-
- fillLevel = fixMax(fillLevel, clipLow);
- fillLevel = fixMin(fillLevel, clipHigh);
-
- bitspend = minBitSpend + fMult(fillLevel-clipLow, bitspend_slope);
-
- return (bitspend);
-}
-
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_adjustPeMinMax()
- description: adjusts peMin and peMax parameters over time
- returns:
- input: current pe, peMin, peMax, bitres size
- output: adjusted peMin/peMax
-
-*****************************************************************************/
-static void FDKaacEnc_adjustPeMinMax(const INT currPe,
- INT *peMin,
- INT *peMax)
-{
- FIXP_DBL minFacHi = FL2FXCONST_DBL(0.3f), maxFacHi = (FIXP_DBL)MAXVAL_DBL, minFacLo = FL2FXCONST_DBL(0.14f), maxFacLo = FL2FXCONST_DBL(0.07f);
- INT diff;
-
- INT minDiff_fix = fMultI(FL2FXCONST_DBL(0.1666666667f), currPe);
-
- if (currPe > *peMax)
- {
- diff = (currPe-*peMax) ;
- *peMin += fMultI(minFacHi,diff);
- *peMax += fMultI(maxFacHi,diff);
- }
- else if (currPe < *peMin)
- {
- diff = (*peMin-currPe) ;
- *peMin -= fMultI(minFacLo,diff);
- *peMax -= fMultI(maxFacLo,diff);
- }
- else
- {
- *peMin += fMultI(minFacHi, (currPe - *peMin));
- *peMax -= fMultI(maxFacLo, (*peMax - currPe));
- }
-
- if ((*peMax - *peMin) < minDiff_fix)
- {
- INT peMax_fix = *peMax, peMin_fix = *peMin;
- FIXP_DBL partLo_fix, partHi_fix;
-
- partLo_fix = (FIXP_DBL)fixMax(0, currPe - peMin_fix);
- partHi_fix = (FIXP_DBL)fixMax(0, peMax_fix - currPe);
-
- peMax_fix = (INT)(currPe + fMultI(fDivNorm(partHi_fix, (partLo_fix+partHi_fix)), minDiff_fix));
- peMin_fix = (INT)(currPe - fMultI(fDivNorm(partLo_fix, (partLo_fix+partHi_fix)), minDiff_fix));
- peMin_fix = fixMax(0, peMin_fix);
-
- *peMax = peMax_fix;
- *peMin = peMin_fix;
- }
-}
-
-
-
-/*****************************************************************************
-
- functionname: BitresCalcBitFac
- description: calculates factor of spending bits for one frame
- 1.0 : take all frame dynpart bits
- >1.0 : take all frame dynpart bits + bitres
- <1.0 : put bits in bitreservoir
- returns: BitFac
- input: bitres-fullness, pe, blockType, parameter-settings
- output:
-
-*****************************************************************************/
-/*
- bitfac(%) pemax
- bitspend(%) | /-----------maxBitres
- | /
- | /
- | /
- | /
- | /
- |----/-----------------> pe
- | /
- bitsave(%) |--/
- pemin
-*/
-
-static FIXP_DBL FDKaacEnc_bitresCalcBitFac(const INT bitresBits,
- const INT maxBitresBits,
- const INT pe,
- const INT lastWindowSequence,
- const INT avgBits,
- const FIXP_DBL maxBitFac,
- ADJ_THR_STATE *AdjThr,
- ATS_ELEMENT *adjThrChan)
-{
- BRES_PARAM *bresParam;
- INT pex;
-
- INT qmin, qbr, qbres, qmbr;
- FIXP_DBL bitSave, bitSpend;
-
- FIXP_DBL bitresFac_fix, tmp_cst, tmp_fix;
- FIXP_DBL pe_pers, bits_ratio, maxBrVal;
- FIXP_DBL bitsave_slope, bitspend_slope, maxBitFac_tmp;
- FIXP_DBL fillLevel_fix = (FIXP_DBL)0x7fffffff;
- FIXP_DBL UNITY = (FIXP_DBL)0x7fffffff;
- FIXP_DBL POINT7 = (FIXP_DBL)0x5999999A;
-
- if (maxBitresBits > bitresBits) {
- fillLevel_fix = fDivNorm(bitresBits, maxBitresBits);
- }
-
- if (lastWindowSequence != SHORT_WINDOW)
- {
- bresParam = &(AdjThr->bresParamLong);
- bitsave_slope = (FIXP_DBL)0x3BBBBBBC;
- bitspend_slope = (FIXP_DBL)0x55555555;
- }
- else
- {
- bresParam = &(AdjThr->bresParamShort);
- bitsave_slope = (FIXP_DBL)0x2E8BA2E9;
- bitspend_slope = (FIXP_DBL)0x7fffffff;
- }
-
- pex = fixMax(pe, adjThrChan->peMin);
- pex = fixMin(pex, adjThrChan->peMax);
-
- bitSave = FDKaacEnc_calcBitSave(fillLevel_fix,
- bresParam->clipSaveLow, bresParam->clipSaveHigh,
- bresParam->minBitSave, bresParam->maxBitSave, bitsave_slope);
-
- bitSpend = FDKaacEnc_calcBitSpend(fillLevel_fix,
- bresParam->clipSpendLow, bresParam->clipSpendHigh,
- bresParam->minBitSpend, bresParam->maxBitSpend, bitspend_slope);
-
- pe_pers = fDivNorm(pex - adjThrChan->peMin, adjThrChan->peMax - adjThrChan->peMin);
- tmp_fix = fMult(((FIXP_DBL)bitSpend + (FIXP_DBL)bitSave), pe_pers);
- bitresFac_fix = (UNITY>>1) - ((FIXP_DBL)bitSave>>1) + (tmp_fix>>1); qbres = (DFRACT_BITS-2);
-
- /* (float)bitresBits/(float)avgBits */
- bits_ratio = fDivNorm(bitresBits, avgBits, &qbr);
- qbr = DFRACT_BITS-1-qbr;
-
- /* Add 0.7 in q31 to bits_ratio in qbr */
- /* 0.7f + (float)bitresBits/(float)avgBits */
- qmin = fixMin(qbr, (DFRACT_BITS-1));
- bits_ratio = bits_ratio >> (qbr - qmin);
- tmp_cst = POINT7 >> ((DFRACT_BITS-1) - qmin);
- maxBrVal = (bits_ratio>>1) + (tmp_cst>>1); qmbr = qmin - 1;
-
- /* bitresFac_fix = fixMin(bitresFac_fix, 0.7 + bitresBits/avgBits); */
- bitresFac_fix = bitresFac_fix >> (qbres - qmbr); qbres = qmbr;
- bitresFac_fix = fixMin(bitresFac_fix, maxBrVal);
-
- /* Compare with maxBitFac */
- qmin = fixMin(Q_BITFAC, qbres);
- bitresFac_fix = bitresFac_fix >> (qbres - qmin);
- maxBitFac_tmp = maxBitFac >> (Q_BITFAC - qmin);
- if(maxBitFac_tmp < bitresFac_fix)
- {
- bitresFac_fix = maxBitFac;
- }
- else
- {
- if(qmin < Q_BITFAC)
- {
- bitresFac_fix = bitresFac_fix << (Q_BITFAC-qmin);
- }
- else
- {
- bitresFac_fix = bitresFac_fix >> (qmin-Q_BITFAC);
- }
- }
-
- FDKaacEnc_adjustPeMinMax(pe, &adjThrChan->peMin, &adjThrChan->peMax);
-
- return bitresFac_fix;
-}
-
-
-/*****************************************************************************
-functionname: FDKaacEnc_AdjThrNew
-description: allocate ADJ_THR_STATE
-*****************************************************************************/
-INT FDKaacEnc_AdjThrNew(ADJ_THR_STATE** phAdjThr,
- INT nElements)
-{
- INT err = 0;
- INT i;
- ADJ_THR_STATE* hAdjThr = GetRam_aacEnc_AdjustThreshold();
- if (hAdjThr==NULL) {
- err = 1;
- goto bail;
- }
-
- for (i=0; i<nElements; i++) {
- hAdjThr->adjThrStateElem[i] = GetRam_aacEnc_AdjThrStateElement(i);
- if (hAdjThr->adjThrStateElem[i]==NULL) {
- err = 1;
- goto bail;
- }
- }
-
-bail:
- *phAdjThr = hAdjThr;
- return err;
-}
-
-
-/*****************************************************************************
-functionname: FDKaacEnc_AdjThrInit
-description: initialize ADJ_THR_STATE
-*****************************************************************************/
-void FDKaacEnc_AdjThrInit(
- ADJ_THR_STATE *hAdjThr,
- const INT meanPe,
- ELEMENT_BITS *elBits[(8)],
- INT invQuant,
- INT nElements,
- INT nChannelsEff,
- INT sampleRate,
- INT advancedBitsToPe,
- FIXP_DBL vbrQualFactor
- )
-{
- INT i;
-
- FIXP_DBL POINT8 = FL2FXCONST_DBL(0.8f);
- FIXP_DBL POINT6 = FL2FXCONST_DBL(0.6f);
-
- /* common for all elements: */
- /* parameters for bitres control */
- hAdjThr->bresParamLong.clipSaveLow = (FIXP_DBL)0x1999999a; /* FL2FXCONST_DBL(0.2f); */
- hAdjThr->bresParamLong.clipSaveHigh = (FIXP_DBL)0x7999999a; /* FL2FXCONST_DBL(0.95f); */
- hAdjThr->bresParamLong.minBitSave = (FIXP_DBL)0xf999999a; /* FL2FXCONST_DBL(-0.05f); */
- hAdjThr->bresParamLong.maxBitSave = (FIXP_DBL)0x26666666; /* FL2FXCONST_DBL(0.3f); */
- hAdjThr->bresParamLong.clipSpendLow = (FIXP_DBL)0x1999999a; /* FL2FXCONST_DBL(0.2f); */
- hAdjThr->bresParamLong.clipSpendHigh = (FIXP_DBL)0x7999999a; /* FL2FXCONST_DBL(0.95f); */
- hAdjThr->bresParamLong.minBitSpend = (FIXP_DBL)0xf3333333; /* FL2FXCONST_DBL(-0.10f); */
- hAdjThr->bresParamLong.maxBitSpend = (FIXP_DBL)0x33333333; /* FL2FXCONST_DBL(0.4f); */
-
- hAdjThr->bresParamShort.clipSaveLow = (FIXP_DBL)0x199999a0; /* FL2FXCONST_DBL(0.2f); */
- hAdjThr->bresParamShort.clipSaveHigh = (FIXP_DBL)0x5fffffff; /* FL2FXCONST_DBL(0.75f); */
- hAdjThr->bresParamShort.minBitSave = (FIXP_DBL)0x00000000; /* FL2FXCONST_DBL(0.0f); */
- hAdjThr->bresParamShort.maxBitSave = (FIXP_DBL)0x199999a0; /* FL2FXCONST_DBL(0.2f); */
- hAdjThr->bresParamShort.clipSpendLow = (FIXP_DBL)0x199999a0; /* FL2FXCONST_DBL(0.2f); */
- hAdjThr->bresParamShort.clipSpendHigh = (FIXP_DBL)0x5fffffff; /* FL2FXCONST_DBL(0.75f); */
- hAdjThr->bresParamShort.minBitSpend = (FIXP_DBL)0xf9999998; /* FL2FXCONST_DBL(-0.05f); */
- hAdjThr->bresParamShort.maxBitSpend = (FIXP_DBL)0x40000000; /* FL2FXCONST_DBL(0.5f); */
-
- /* specific for each element: */
- for (i=0; i<nElements; i++) {
- ATS_ELEMENT* atsElem = hAdjThr->adjThrStateElem[i];
- MINSNR_ADAPT_PARAM *msaParam = &atsElem->minSnrAdaptParam;
- INT chBitrate = elBits[i]->chBitrateEl;
-
- /* parameters for bitres control */
- atsElem->peMin = fMultI(POINT8, meanPe) >> 1;
- atsElem->peMax = fMultI(POINT6, meanPe);
-
- /* for use in FDKaacEnc_reduceThresholdsVBR */
- atsElem->chaosMeasureOld = FL2FXCONST_DBL(0.3f);
-
- /* additional pe offset to correct pe2bits for low bitrates */
- atsElem->peOffset = 0;
-
- /* vbr initialisation */
- atsElem->vbrQualFactor = vbrQualFactor;
- if (chBitrate < 32000)
- {
- atsElem->peOffset = fixMax(50, 100-fMultI((FIXP_DBL)0x666667, chBitrate));
- }
-
- /* avoid hole parameters */
- if (chBitrate > 20000) {
- atsElem->ahParam.modifyMinSnr = TRUE;
- atsElem->ahParam.startSfbL = 15;
- atsElem->ahParam.startSfbS = 3;
- }
- else {
- atsElem->ahParam.modifyMinSnr = FALSE;
- atsElem->ahParam.startSfbL = 0;
- atsElem->ahParam.startSfbS = 0;
- }
-
- /* minSnr adaptation */
- msaParam->maxRed = FL2FXCONST_DBL(0.00390625f); /* 0.25f/64.0f */
- /* start adaptation of minSnr for avgEn/sfbEn > startRatio */
- msaParam->startRatio = FL2FXCONST_DBL(0.05190512648f); /* ld64(10.0f) */
- /* maximum minSnr reduction to minSnr^maxRed is reached for
- avgEn/sfbEn >= maxRatio */
- /* msaParam->maxRatio = 1000.0f; */
- /*msaParam->redRatioFac = ((float)1.0f - msaParam->maxRed) / ((float)10.0f*log10(msaParam->startRatio/msaParam->maxRatio)/log10(2.0f)*(float)0.3010299956f);*/
- msaParam->redRatioFac = FL2FXCONST_DBL(-0.375f); /* -0.0375f * 10.0f */
- /*msaParam->redOffs = (float)1.0f - msaParam->redRatioFac * (float)10.0f * log10(msaParam->startRatio)/log10(2.0f) * (float)0.3010299956f;*/
- msaParam->redOffs = FL2FXCONST_DBL(0.021484375); /* 1.375f/64.0f */
-
- /* init pe correction */
- atsElem->peCorrectionFactor_m = FL2FXCONST_DBL(0.5f); /* 1.0 */
- atsElem->peCorrectionFactor_e = 1;
-
- atsElem->dynBitsLast = -1;
- atsElem->peLast = 0;
-
- /* init bits to pe factor */
-
- /* init bits2PeFactor */
- FDKaacEnc_InitBits2PeFactor(
- &atsElem->bits2PeFactor_m,
- &atsElem->bits2PeFactor_e,
- chBitrate, /* bitrate/channel*/
- nChannelsEff, /* number of channels */
- sampleRate,
- advancedBitsToPe,
- invQuant
- );
-
- } /* for nElements */
-
-}
-
-
-/*****************************************************************************
- functionname: FDKaacEnc_FDKaacEnc_calcPeCorrection
- description: calc desired pe
-*****************************************************************************/
-static void FDKaacEnc_FDKaacEnc_calcPeCorrection(
- FIXP_DBL *const correctionFac_m,
- INT *const correctionFac_e,
- const INT peAct,
- const INT peLast,
- const INT bitsLast,
- const FIXP_DBL bits2PeFactor_m,
- const INT bits2PeFactor_e
- )
-{
- if ( (bitsLast > 0) && (peAct < 1.5f*peLast) && (peAct > 0.7f*peLast) &&
- (FDKaacEnc_bits2pe2(bitsLast, fMult(FL2FXCONST_DBL(1.2f/2.f), bits2PeFactor_m), bits2PeFactor_e+1) > peLast) &&
- (FDKaacEnc_bits2pe2(bitsLast, fMult(FL2FXCONST_DBL(0.65f), bits2PeFactor_m), bits2PeFactor_e ) < peLast) )
- {
- FIXP_DBL corrFac = *correctionFac_m;
-
- int scaling = 0;
- FIXP_DBL denum = (FIXP_DBL)FDKaacEnc_bits2pe2(bitsLast, bits2PeFactor_m, bits2PeFactor_e);
- FIXP_DBL newFac = fDivNorm((FIXP_DBL)peLast, denum, &scaling);
-
- /* dead zone, newFac and corrFac are scaled by 0.5 */
- if ((FIXP_DBL)peLast <= denum) { /* ratio <= 1.f */
- newFac = fixMax(scaleValue(fixMin( fMult(FL2FXCONST_DBL(1.1f/2.f), newFac), scaleValue(FL2FXCONST_DBL( 1.f/2.f), -scaling)), scaling), FL2FXCONST_DBL(0.85f/2.f) );
- }
- else { /* ratio < 1.f */
- newFac = fixMax( fixMin( scaleValue(fMult(FL2FXCONST_DBL(0.9f/2.f), newFac), scaling), FL2FXCONST_DBL(1.15f/2.f) ), FL2FXCONST_DBL( 1.f/2.f) );
- }
-
- if ( ((newFac > FL2FXCONST_DBL(1.f/2.f)) && (corrFac < FL2FXCONST_DBL(1.f/2.f)))
- || ((newFac < FL2FXCONST_DBL(1.f/2.f)) && (corrFac > FL2FXCONST_DBL(1.f/2.f))))
- {
- corrFac = FL2FXCONST_DBL(1.f/2.f);
- }
-
- /* faster adaptation towards 1.0, slower in the other direction */
- if ( (corrFac < FL2FXCONST_DBL(1.f/2.f) && newFac < corrFac)
- || (corrFac > FL2FXCONST_DBL(1.f/2.f) && newFac > corrFac) )
- {
- corrFac = fMult(FL2FXCONST_DBL(0.85f), corrFac) + fMult(FL2FXCONST_DBL(0.15f), newFac);
- }
- else {
- corrFac = fMult(FL2FXCONST_DBL(0.7f), corrFac) + fMult(FL2FXCONST_DBL(0.3f), newFac);
- }
-
- corrFac = fixMax( fixMin( corrFac, FL2FXCONST_DBL(1.15f/2.f) ), FL2FXCONST_DBL(0.85/2.f) );
-
- *correctionFac_m = corrFac;
- *correctionFac_e = 1;
- }
- else {
- *correctionFac_m = FL2FXCONST_DBL(1.f/2.f);
- *correctionFac_e = 1;
- }
-}
-
-
-static void FDKaacEnc_calcPeCorrectionLowBitRes(
- FIXP_DBL *const correctionFac_m,
- INT *const correctionFac_e,
- const INT peLast,
- const INT bitsLast,
- const INT bitresLevel,
- const INT nChannels,
- const FIXP_DBL bits2PeFactor_m,
- const INT bits2PeFactor_e
- )
-{
- /* tuning params */
- const FIXP_DBL amp = FL2FXCONST_DBL(0.005);
- const FIXP_DBL maxDiff = FL2FXCONST_DBL(0.25f);
-
- if (bitsLast > 0) {
-
- /* Estimate deviation of granted and used dynamic bits in previous frame, in PE units */
- const int bitsBalLast = peLast - FDKaacEnc_bits2pe2(
- bitsLast,
- bits2PeFactor_m,
- bits2PeFactor_e);
-
- /* reserve n bits per channel */
- int headroom = (bitresLevel>=50*nChannels) ? 0 : (100*nChannels);
-
- /* in PE units */
- headroom = FDKaacEnc_bits2pe2(
- headroom,
- bits2PeFactor_m,
- bits2PeFactor_e);
-
- /*
- * diff = amp * ((bitsBalLast - headroom) / (bitresLevel + headroom)
- * diff = max ( min ( diff, maxDiff, -maxDiff)) / 2
- */
- FIXP_DBL denominator = (FIXP_DBL)FDKaacEnc_bits2pe2(bitresLevel, bits2PeFactor_m, bits2PeFactor_e) + (FIXP_DBL)headroom;
-
- int scaling = 0;
- FIXP_DBL diff = (bitsBalLast>=headroom)
- ? fMult(amp, fDivNorm( (FIXP_DBL)(bitsBalLast - headroom), denominator, &scaling))
- : -fMult(amp, fDivNorm(-(FIXP_DBL)(bitsBalLast - headroom), denominator, &scaling)) ;
-
- scaling -= 1; /* divide by 2 */
-
- diff = (scaling<=0) ? FDKmax( FDKmin (diff>>(-scaling), maxDiff>>1), -maxDiff>>1)
- : FDKmax( FDKmin (diff, maxDiff>>(1+scaling)), -maxDiff>>(1+scaling)) << scaling;
-
- /*
- * corrFac += diff
- * corrFac = max ( min ( corrFac/2.f, 1.f/2.f, 0.75f/2.f ) )
- */
- *correctionFac_m = FDKmax(FDKmin((*correctionFac_m)+diff, FL2FXCONST_DBL(1.0f/2.f)), FL2FXCONST_DBL(0.75f/2.f)) ;
- *correctionFac_e = 1;
- }
- else {
- *correctionFac_m = FL2FXCONST_DBL(0.75/2.f);
- *correctionFac_e = 1;
- }
-}
-
-void FDKaacEnc_DistributeBits(ADJ_THR_STATE *adjThrState,
- ATS_ELEMENT *AdjThrStateElement,
- PSY_OUT_CHANNEL *psyOutChannel[(2)],
- PE_DATA *peData,
- INT *grantedPe,
- INT *grantedPeCorr,
- const INT nChannels,
- const INT commonWindow,
- const INT grantedDynBits,
- const INT bitresBits,
- const INT maxBitresBits,
- const FIXP_DBL maxBitFac,
- const INT bitDistributionMode)
-{
- FIXP_DBL bitFactor;
- INT noRedPe = peData->pe;
-
- /* prefer short windows for calculation of bitFactor */
- INT curWindowSequence = LONG_WINDOW;
- if (nChannels==2) {
- if ((psyOutChannel[0]->lastWindowSequence == SHORT_WINDOW) ||
- (psyOutChannel[1]->lastWindowSequence == SHORT_WINDOW)) {
- curWindowSequence = SHORT_WINDOW;
- }
- }
- else {
- curWindowSequence = psyOutChannel[0]->lastWindowSequence;
- }
-
- if (grantedDynBits >= 1) {
- if (bitDistributionMode!=0) {
- *grantedPe = FDKaacEnc_bits2pe2(grantedDynBits, AdjThrStateElement->bits2PeFactor_m, AdjThrStateElement->bits2PeFactor_e);
- }
- else
- {
- /* factor dependend on current fill level and pe */
- bitFactor = FDKaacEnc_bitresCalcBitFac(bitresBits, maxBitresBits, noRedPe,
- curWindowSequence, grantedDynBits, maxBitFac,
- adjThrState,
- AdjThrStateElement
- );
-
- /* desired pe for actual frame */
- /* Worst case max of grantedDynBits is = 1024 * 5.27 * 2 */
- *grantedPe = FDKaacEnc_bits2pe2(grantedDynBits,
- fMult(bitFactor, AdjThrStateElement->bits2PeFactor_m), AdjThrStateElement->bits2PeFactor_e+(DFRACT_BITS-1-Q_BITFAC)
- );
- }
- }
- else {
- *grantedPe = 0; /* prevent divsion by 0 */
- }
-
- /* correction of pe value */
- switch (bitDistributionMode) {
- case 2:
- case 1:
- FDKaacEnc_calcPeCorrectionLowBitRes(
- &AdjThrStateElement->peCorrectionFactor_m,
- &AdjThrStateElement->peCorrectionFactor_e,
- AdjThrStateElement->peLast,
- AdjThrStateElement->dynBitsLast,
- bitresBits,
- nChannels,
- AdjThrStateElement->bits2PeFactor_m,
- AdjThrStateElement->bits2PeFactor_e
- );
- break;
- case 0:
- default:
- FDKaacEnc_FDKaacEnc_calcPeCorrection(
- &AdjThrStateElement->peCorrectionFactor_m,
- &AdjThrStateElement->peCorrectionFactor_e,
- fixMin(*grantedPe, noRedPe),
- AdjThrStateElement->peLast,
- AdjThrStateElement->dynBitsLast,
- AdjThrStateElement->bits2PeFactor_m,
- AdjThrStateElement->bits2PeFactor_e
- );
- break;
- }
-
- *grantedPeCorr = (INT)(fMult((FIXP_DBL)(*grantedPe<<Q_AVGBITS), AdjThrStateElement->peCorrectionFactor_m) >> (Q_AVGBITS-AdjThrStateElement->peCorrectionFactor_e));
-
- /* update last pe */
- AdjThrStateElement->peLast = *grantedPe;
- AdjThrStateElement->dynBitsLast = -1;
-
-}
-
-/*****************************************************************************
-functionname: FDKaacEnc_AdjustThresholds
-description: adjust thresholds
-*****************************************************************************/
-void FDKaacEnc_AdjustThresholds(ATS_ELEMENT* AdjThrStateElement[(8)],
- QC_OUT_ELEMENT* qcElement[(8)],
- QC_OUT* qcOut,
- PSY_OUT_ELEMENT* psyOutElement[(8)],
- INT CBRbitrateMode,
- CHANNEL_MAPPING* cm)
-{
- int i;
- if (CBRbitrateMode)
- {
- /* In case, no bits must be shifted between different elements, */
- /* an element-wise execution of the pe-dependent threshold- */
- /* adaption becomes necessary... */
- for (i=0; i<cm->nElements; i++)
- {
- ELEMENT_INFO elInfo = cm->elInfo[i];
-
- if ((elInfo.elType == ID_SCE) || (elInfo.elType == ID_CPE) ||
- (elInfo.elType == ID_LFE))
- {
- /* qcElement[i]->grantedPe = 2000; */ /* Use this only for debugging */
- //if (totalGrantedPeCorr < totalNoRedPe) {
- if (qcElement[i]->grantedPe < qcElement[i]->peData.pe)
- {
- /* calc threshold necessary for desired pe */
- FDKaacEnc_adaptThresholdsToPe(cm,
- AdjThrStateElement,
- qcElement,
- psyOutElement,
- qcElement[i]->grantedPeCorr,
- 1, /* Process only 1 element */
- i); /* Process exactly THIS element */
-
- }
-
- } /* -end- if(ID_SCE || ID_CPE || ID_LFE) */
-
- } /* -end- element loop */
- }
- else {
- for (i=0; i<cm->nElements; i++)
- {
- ELEMENT_INFO elInfo = cm->elInfo[i];
-
- if ((elInfo.elType == ID_SCE) || (elInfo.elType == ID_CPE) ||
- (elInfo.elType == ID_LFE))
- {
- /* for VBR-mode */
- FDKaacEnc_AdaptThresholdsVBR(qcElement[i]->qcOutChannel,
- psyOutElement[i]->psyOutChannel,
- AdjThrStateElement[i],
- &psyOutElement[i]->toolsInfo,
- &qcElement[i]->peData,
- cm->elInfo[i].nChannelsInEl);
- } /* -end- if(ID_SCE || ID_CPE || ID_LFE) */
-
- } /* -end- element loop */
-
- }
- for (i=0; i<cm->nElements; i++) {
- int ch,sfb,sfbGrp;
- /* no weighting of threholds and energies for mlout */
- /* weight energies and thresholds */
- for (ch=0; ch<cm->elInfo[i].nChannelsInEl; ch++) {
- QC_OUT_CHANNEL* pQcOutCh = qcElement[i]->qcOutChannel[ch];
- for (sfbGrp = 0;sfbGrp < psyOutElement[i]->psyOutChannel[ch]->sfbCnt; sfbGrp+=psyOutElement[i]->psyOutChannel[ch]->sfbPerGroup) {
- for (sfb=0; sfb<psyOutElement[i]->psyOutChannel[ch]->maxSfbPerGroup; sfb++) {
- pQcOutCh->sfbThresholdLdData[sfb+sfbGrp] += pQcOutCh->sfbEnFacLd[sfb+sfbGrp];
- }
- }
- }
- }
-}
-
-void FDKaacEnc_AdjThrClose(ADJ_THR_STATE** phAdjThr)
-{
- INT i;
- ADJ_THR_STATE* hAdjThr = *phAdjThr;
-
- if (hAdjThr!=NULL) {
- for (i=0; i<(8); i++) {
- if (hAdjThr->adjThrStateElem[i]!=NULL) {
- FreeRam_aacEnc_AdjThrStateElement(&hAdjThr->adjThrStateElem[i]);
- }
- }
- FreeRam_aacEnc_AdjustThreshold(phAdjThr);
- }
-}
-
diff --git a/libAACenc/src/adj_thr.h b/libAACenc/src/adj_thr.h
deleted file mode 100644
index 69b1dcc..0000000
--- a/libAACenc/src/adj_thr.h
+++ /dev/null
@@ -1,147 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M. Werner
- contents/description: Threshold compensation
-
-******************************************************************************/
-
-#ifndef __ADJ_THR_H
-#define __ADJ_THR_H
-
-
-#include "adj_thr_data.h"
-#include "qc_data.h"
-#include "line_pe.h"
-#include "interface.h"
-
-
-void FDKaacEnc_peCalculation(
- PE_DATA *peData,
- PSY_OUT_CHANNEL* psyOutChannel[(2)],
- QC_OUT_CHANNEL* qcOutChannel[(2)],
- struct TOOLSINFO *toolsInfo,
- ATS_ELEMENT* adjThrStateElement,
- const INT nChannels
- );
-
-INT FDKaacEnc_AdjThrNew(ADJ_THR_STATE** phAdjThr,
- INT nElements);
-
-void FDKaacEnc_AdjThrInit(ADJ_THR_STATE *hAdjThr,
- const INT peMean,
- ELEMENT_BITS* elBits[(8)],
- INT invQuant,
- INT nElements,
- INT nChannelsEff,
- INT sampleRate,
- INT advancedBitsToPe,
- FIXP_DBL vbrQualFactor);
-
-
-void FDKaacEnc_DistributeBits(ADJ_THR_STATE *adjThrState,
- ATS_ELEMENT *AdjThrStateElement,
- PSY_OUT_CHANNEL *psyOutChannel[(2)],
- PE_DATA *peData,
- INT *grantedPe,
- INT *grantedPeCorr,
- const INT nChannels,
- const INT commonWindow,
- const INT avgBits,
- const INT bitresBits,
- const INT maxBitresBits,
- const FIXP_DBL maxBitFac,
- const INT bitDistributionMode);
-
-void FDKaacEnc_AdjustThresholds(ATS_ELEMENT* AdjThrStateElement[(8)],
- QC_OUT_ELEMENT* qcElement[(8)],
- QC_OUT* qcOut,
- PSY_OUT_ELEMENT* psyOutElement[(8)],
- INT CBRbitrateMode,
- CHANNEL_MAPPING* cm);
-
-void FDKaacEnc_AdjThrClose(ADJ_THR_STATE** hAdjThr);
-
-#endif
diff --git a/libAACenc/src/adj_thr_data.h b/libAACenc/src/adj_thr_data.h
deleted file mode 100644
index 3eb7678..0000000
--- a/libAACenc/src/adj_thr_data.h
+++ /dev/null
@@ -1,150 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/************************* Fast MPEG AAC Audio Encoder **********************
-
- Initial author: M. Schug / A. Groeschel
- contents/description: threshold calculations
-
-******************************************************************************/
-
-#ifndef __ADJ_THR_DATA_H
-#define __ADJ_THR_DATA_H
-
-
-#include "psy_const.h"
-
-typedef struct {
- FIXP_DBL clipSaveLow, clipSaveHigh;
- FIXP_DBL minBitSave, maxBitSave;
- FIXP_DBL clipSpendLow, clipSpendHigh;
- FIXP_DBL minBitSpend, maxBitSpend;
-} BRES_PARAM;
-
-typedef struct {
- INT modifyMinSnr;
- INT startSfbL, startSfbS;
-} AH_PARAM;
-
-typedef struct {
- FIXP_DBL maxRed;
- FIXP_DBL startRatio;
- FIXP_DBL maxRatio;
- FIXP_DBL redRatioFac;
- FIXP_DBL redOffs;
-} MINSNR_ADAPT_PARAM;
-
-typedef struct {
- /* parameters for bitreservoir control */
- INT peMin, peMax;
- /* constant offset to pe */
- INT peOffset;
- /* constant PeFactor */
- FIXP_DBL bits2PeFactor_m;
- INT bits2PeFactor_e;
- /* avoid hole parameters */
- AH_PARAM ahParam;
- /* values for correction of pe */
- /* paramters for adaptation of minSnr */
- MINSNR_ADAPT_PARAM minSnrAdaptParam;
- INT peLast;
- INT dynBitsLast;
- FIXP_DBL peCorrectionFactor_m;
- INT peCorrectionFactor_e;
-
- /* vbr encoding */
- FIXP_DBL vbrQualFactor;
- FIXP_DBL chaosMeasureOld;
-
- /* threshold weighting */
- FIXP_DBL chaosMeasureEnFac[(2)];
- INT lastEnFacPatch[(2)];
-
-} ATS_ELEMENT;
-
-typedef struct {
- BRES_PARAM bresParamLong, bresParamShort;
- ATS_ELEMENT* adjThrStateElem[(8)];
-} ADJ_THR_STATE;
-
-#endif
diff --git a/libAACenc/src/band_nrg.cpp b/libAACenc/src/band_nrg.cpp
deleted file mode 100644
index 861f7a8..0000000
--- a/libAACenc/src/band_nrg.cpp
+++ /dev/null
@@ -1,359 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/***************************** MPEG-4 AAC Encoder **************************
-
- Initial author: M. Werner
- contents/description: Band/Line energy calculations
-
-******************************************************************************/
-
-#include "band_nrg.h"
-
-
-/*****************************************************************************
- functionname: FDKaacEnc_CalcSfbMaxScaleSpec
- description:
- input:
- output:
-*****************************************************************************/
-void
-FDKaacEnc_CalcSfbMaxScaleSpec(const FIXP_DBL *RESTRICT mdctSpectrum,
- const INT *RESTRICT bandOffset,
- INT *RESTRICT sfbMaxScaleSpec,
- const INT numBands)
-{
- INT i,j;
- FIXP_DBL maxSpc, tmp;
-
- for(i=0; i<numBands; i++) {
- maxSpc = (FIXP_DBL)0;
- for (j=bandOffset[i]; j<bandOffset[i+1]; j++) {
- tmp = fixp_abs(mdctSpectrum[j]);
- maxSpc = fixMax(maxSpc, tmp);
- }
- sfbMaxScaleSpec[i] = (maxSpc==(FIXP_DBL)0) ? (DFRACT_BITS-2) : CntLeadingZeros(maxSpc)-1;
- /* CountLeadingBits() is not necessary here since test value is always > 0 */
- }
-}
-
-/*****************************************************************************
- functionname: FDKaacEnc_CheckBandEnergyOptim
- description:
- input:
- output:
-*****************************************************************************/
-FIXP_DBL
-FDKaacEnc_CheckBandEnergyOptim(const FIXP_DBL *RESTRICT mdctSpectrum,
- INT *RESTRICT sfbMaxScaleSpec,
- const INT *RESTRICT bandOffset,
- const INT numBands,
- FIXP_DBL *RESTRICT bandEnergy,
- FIXP_DBL *RESTRICT bandEnergyLdData,
- INT minSpecShift)
-{
- INT i, j, scale, nr = 0;
- FIXP_DBL maxNrgLd = FL2FXCONST_DBL(-1.0f);
- FIXP_DBL maxNrg = 0;
- FIXP_DBL spec;
-
- for(i=0; i<numBands; i++) {
- scale = fixMax(0, sfbMaxScaleSpec[i]-4);
- FIXP_DBL tmp = 0;
- for (j=bandOffset[i]; j<bandOffset[i+1]; j++){
- spec = mdctSpectrum[j]<<scale;
- tmp = fPow2AddDiv2(tmp, spec);
- }
- bandEnergy[i] = tmp<<1;
-
- /* calculate ld of bandNrg, subtract scaling */
- bandEnergyLdData[i] = CalcLdData(bandEnergy[i]);
- if (bandEnergyLdData[i] != FL2FXCONST_DBL(-1.0f)) {
- bandEnergyLdData[i] -= scale*FL2FXCONST_DBL(2.0/64);
- }
- /* find index of maxNrg */
- if (bandEnergyLdData[i] > maxNrgLd) {
- maxNrgLd = bandEnergyLdData[i];
- nr = i;
- }
- }
-
- /* return unscaled maxNrg*/
- scale = fixMax(0,sfbMaxScaleSpec[nr]-4);
- scale = fixMax(2*(minSpecShift-scale),-(DFRACT_BITS-1));
-
- maxNrg = scaleValue(bandEnergy[nr], scale);
-
- return maxNrg;
-}
-
-/*****************************************************************************
- functionname: FDKaacEnc_CalcBandEnergyOptimLong
- description:
- input:
- output:
-*****************************************************************************/
-INT
-FDKaacEnc_CalcBandEnergyOptimLong(const FIXP_DBL *RESTRICT mdctSpectrum,
- INT *RESTRICT sfbMaxScaleSpec,
- const INT *RESTRICT bandOffset,
- const INT numBands,
- FIXP_DBL *RESTRICT bandEnergy,
- FIXP_DBL *RESTRICT bandEnergyLdData)
-{
- INT i, j, shiftBits = 0;
- FIXP_DBL maxNrgLd = FL2FXCONST_DBL(0.0f);
-
- FIXP_DBL spec;
-
- for(i=0; i<numBands; i++) {
- INT leadingBits = sfbMaxScaleSpec[i]-4; /* max sfbWidth = 96 ; 2^7=128 => 7/2 = 4 (spc*spc) */
- FIXP_DBL tmp = FL2FXCONST_DBL(0.0);
- /* don't use scaleValue() here, it increases workload quite sufficiently... */
- if (leadingBits>=0) {
- for (j=bandOffset[i];j<bandOffset[i+1];j++) {
- spec = mdctSpectrum[j]<<leadingBits;
- tmp = fPow2AddDiv2(tmp, spec);
- }
- } else {
- INT shift = -leadingBits;
- for (j=bandOffset[i];j<bandOffset[i+1];j++){
- spec = mdctSpectrum[j]>>shift;
- tmp = fPow2AddDiv2(tmp, spec);
- }
- }
- bandEnergy[i] = tmp<<1;
- }
-
- /* calculate ld of bandNrg, subtract scaling */
- LdDataVector(bandEnergy, bandEnergyLdData, numBands);
- for(i=numBands; i--!=0; ) {
- FIXP_DBL scaleDiff = (sfbMaxScaleSpec[i]-4)*FL2FXCONST_DBL(2.0/64);
-
- bandEnergyLdData[i] = (bandEnergyLdData[i] >= ((FL2FXCONST_DBL(-1.f)>>1) + (scaleDiff>>1)))
- ? bandEnergyLdData[i]-scaleDiff : FL2FXCONST_DBL(-1.f);
- /* find maxNrgLd */
- maxNrgLd = fixMax(maxNrgLd, bandEnergyLdData[i]);
- }
-
- if (maxNrgLd<=(FIXP_DBL)0)
- {
- for(i=numBands; i--!=0; )
- {
- INT scale = fixMin((sfbMaxScaleSpec[i]-4)<<1,(DFRACT_BITS-1));
- bandEnergy[i] = scaleValue(bandEnergy[i], -scale);
- }
- return 0;
- }
- else
- { /* scale down NRGs */
- while (maxNrgLd>FL2FXCONST_DBL(0.0f))
- {
- maxNrgLd -= FL2FXCONST_DBL(2.0/64);
- shiftBits++;
- }
- for(i=numBands; i--!=0; )
- {
- INT scale = fixMin( ((sfbMaxScaleSpec[i]-4)+shiftBits)<<1, (DFRACT_BITS-1));
- bandEnergyLdData[i] -= shiftBits*FL2FXCONST_DBL(2.0/64);
- bandEnergy[i] = scaleValue(bandEnergy[i], -scale);
- }
- return shiftBits;
- }
-}
-
-
-/*****************************************************************************
- functionname: FDKaacEnc_CalcBandEnergyOptimShort
- description:
- input:
- output:
-*****************************************************************************/
-void
-FDKaacEnc_CalcBandEnergyOptimShort(const FIXP_DBL *RESTRICT mdctSpectrum,
- INT *RESTRICT sfbMaxScaleSpec,
- const INT *RESTRICT bandOffset,
- const INT numBands,
- FIXP_DBL *RESTRICT bandEnergy)
-{
- INT i, j;
-
- for(i=0; i<numBands; i++)
- {
- int leadingBits = sfbMaxScaleSpec[i]-3; /* max sfbWidth = 36 ; 2^6=64 => 6/2 = 3 (spc*spc) */
- FIXP_DBL tmp = FL2FXCONST_DBL(0.0);
- for (j=bandOffset[i];j<bandOffset[i+1];j++)
- {
- FIXP_DBL spec = scaleValue(mdctSpectrum[j],leadingBits);
- tmp = fPow2AddDiv2(tmp, spec);
- }
- bandEnergy[i] = tmp;
- }
-
- for(i=0; i<numBands; i++)
- {
- INT scale = (2*(sfbMaxScaleSpec[i]-3))-1; /* max sfbWidth = 36 ; 2^6=64 => 6/2 = 3 (spc*spc) */
- scale = fixMax(fixMin(scale,(DFRACT_BITS-1)),-(DFRACT_BITS-1));
- bandEnergy[i] = scaleValueSaturate(bandEnergy[i], -scale);
- }
-}
-
-
-/*****************************************************************************
- functionname: FDKaacEnc_CalcBandNrgMSOpt
- description:
- input:
- output:
-*****************************************************************************/
-void FDKaacEnc_CalcBandNrgMSOpt(const FIXP_DBL *RESTRICT mdctSpectrumLeft,
- const FIXP_DBL *RESTRICT mdctSpectrumRight,
- INT *RESTRICT sfbMaxScaleSpecLeft,
- INT *RESTRICT sfbMaxScaleSpecRight,
- const INT *RESTRICT bandOffset,
- const INT numBands,
- FIXP_DBL *RESTRICT bandEnergyMid,
- FIXP_DBL *RESTRICT bandEnergySide,
- INT calcLdData,
- FIXP_DBL *RESTRICT bandEnergyMidLdData,
- FIXP_DBL *RESTRICT bandEnergySideLdData)
-{
- INT i, j, minScale;
- FIXP_DBL NrgMid, NrgSide, specm, specs;
-
- for (i=0; i<numBands; i++) {
-
- NrgMid = NrgSide = FL2FXCONST_DBL(0.0);
- minScale = fixMin(sfbMaxScaleSpecLeft[i], sfbMaxScaleSpecRight[i])-4;
- minScale = fixMax(0, minScale);
-
- if (minScale > 0) {
- for (j=bandOffset[i];j<bandOffset[i+1];j++) {
- FIXP_DBL specL = mdctSpectrumLeft[j]<<(minScale-1);
- FIXP_DBL specR = mdctSpectrumRight[j]<<(minScale-1);
- specm = specL + specR;
- specs = specL - specR;
- NrgMid = fPow2AddDiv2(NrgMid, specm);
- NrgSide = fPow2AddDiv2(NrgSide, specs);
- }
- } else {
- for (j=bandOffset[i];j<bandOffset[i+1];j++) {
- FIXP_DBL specL = mdctSpectrumLeft[j]>>1;
- FIXP_DBL specR = mdctSpectrumRight[j]>>1;
- specm = specL + specR;
- specs = specL - specR;
- NrgMid = fPow2AddDiv2(NrgMid, specm);
- NrgSide = fPow2AddDiv2(NrgSide, specs);
- }
- }
- bandEnergyMid[i] = NrgMid<<1;
- bandEnergySide[i] = NrgSide<<1;
- }
-
- if(calcLdData) {
- LdDataVector(bandEnergyMid, bandEnergyMidLdData, numBands);
- LdDataVector(bandEnergySide, bandEnergySideLdData, numBands);
- }
-
- for (i=0; i<numBands; i++)
- {
- INT minScale = fixMin(sfbMaxScaleSpecLeft[i], sfbMaxScaleSpecRight[i]);
- INT scale = fixMax(0, 2*(minScale-4));
-
- if (calcLdData)
- {
- /* using the minimal scaling of left and right channel can cause very small energies;
- check ldNrg before subtract scaling multiplication: fract*INT we don't need fMult */
-
- int minus = scale*FL2FXCONST_DBL(1.0/64);
-
- if (bandEnergyMidLdData[i] != FL2FXCONST_DBL(-1.0f))
- bandEnergyMidLdData[i] -= minus;
-
- if (bandEnergySideLdData[i] != FL2FXCONST_DBL(-1.0f))
- bandEnergySideLdData[i] -= minus;
- }
- scale = fixMin(scale, (DFRACT_BITS-1));
- bandEnergyMid[i] >>= scale;
- bandEnergySide[i] >>= scale;
- }
-}
diff --git a/libAACenc/src/band_nrg.h b/libAACenc/src/band_nrg.h
deleted file mode 100644
index 540a8ef..0000000
--- a/libAACenc/src/band_nrg.h
+++ /dev/null
@@ -1,149 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Author(s): M. Werner
- Description: Band/Line energy calculation
-
-******************************************************************************/
-
-#ifndef _BAND_NRG_H
-#define _BAND_NRG_H
-
-#include "common_fix.h"
-
-
-void
-FDKaacEnc_CalcSfbMaxScaleSpec(
- const FIXP_DBL *mdctSpectrum,
- const INT *bandOffset,
- INT *sfbMaxScaleSpec,
- const INT numBands
- );
-
-FIXP_DBL
-FDKaacEnc_CheckBandEnergyOptim(
- const FIXP_DBL *mdctSpectrum,
- INT *sfbMaxScaleSpec,
- const INT *bandOffset,
- const INT numBands,
- FIXP_DBL *bandEnergy,
- FIXP_DBL *bandEnergyLdData,
- INT minSpecShift
- );
-
-INT
-FDKaacEnc_CalcBandEnergyOptimLong(
- const FIXP_DBL *mdctSpectrum,
- INT *sfbMaxScaleSpec,
- const INT *bandOffset,
- const INT numBands,
- FIXP_DBL *bandEnergy,
- FIXP_DBL *bandEnergyLdData
- );
-
-void
-FDKaacEnc_CalcBandEnergyOptimShort(
- const FIXP_DBL *mdctSpectrum,
- INT *sfbMaxScaleSpec,
- const INT *bandOffset,
- const INT numBands,
- FIXP_DBL *bandEnergy
- );
-
-
-void FDKaacEnc_CalcBandNrgMSOpt(
- const FIXP_DBL *RESTRICT mdctSpectrumLeft,
- const FIXP_DBL *RESTRICT mdctSpectrumRight,
- INT *RESTRICT sfbMaxScaleSpecLeft,
- INT *RESTRICT sfbMaxScaleSpecRight,
- const INT *RESTRICT bandOffset,
- const INT numBands,
- FIXP_DBL *RESTRICT bandEnergyMid,
- FIXP_DBL *RESTRICT bandEnergySide,
- INT calcLdData,
- FIXP_DBL *RESTRICT bandEnergyMidLdData,
- FIXP_DBL *RESTRICT bandEnergySideLdData);
-
-#endif
diff --git a/libAACenc/src/bandwidth.cpp b/libAACenc/src/bandwidth.cpp
deleted file mode 100644
index 703658b..0000000
--- a/libAACenc/src/bandwidth.cpp
+++ /dev/null
@@ -1,381 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/************************* Fast MPEG AAC Audio Encoder **********************
-
- Initial author: M. Schug / A. Groeschel
- contents/description: bandwidth expert
-
-******************************************************************************/
-
-#include "channel_map.h"
-#include "bandwidth.h"
-#include "aacEnc_ram.h"
-
-typedef struct{
- INT chanBitRate;
- INT bandWidthMono;
- INT bandWidth2AndMoreChan;
-
-} BANDWIDTH_TAB;
-
-static const BANDWIDTH_TAB bandWidthTable[] = {
- {0, 3700, 5000},
- {12000, 5000, 6400},
- {20000, 6900, 9640},
- {28000, 9600, 13050},
- {40000, 12060, 14260},
- {56000, 13950, 15500},
- {72000, 14200, 16120},
- {96000, 17000, 17000},
- {576001,17000, 17000}
-};
-
-
-static const BANDWIDTH_TAB bandWidthTable_LD_22050[] = {
- { 8000, 2000, 2400},
- {12000, 2500, 2700},
- {16000, 3300, 3100},
- {24000, 6250, 7200},
- {32000, 9200, 10500},
- {40000, 16000, 16000},
- {48000, 16000, 16000},
- {360001, 16000, 16000}
-};
-
-static const BANDWIDTH_TAB bandWidthTable_LD_24000[] = {
- { 8000, 2000, 2000},
- {12000, 2000, 2300},
- {16000, 2200, 2500},
- {24000, 5650, 6400},
- {32000, 11600, 12000},
- {40000, 12000, 16000},
- {48000, 16000, 16000},
- {64000, 16000, 16000},
- {360001, 16000, 16000}
-};
-
-static const BANDWIDTH_TAB bandWidthTable_LD_32000[] = {
- { 8000, 2000, 2000},
- {12000, 2000, 2000},
- {24000, 4250, 5200},
- {32000, 8400, 9000},
- {40000, 9400, 11300},
- {48000, 11900, 13700},
- {64000, 14800, 16000},
- {76000, 16000, 16000},
- {360001, 16000, 16000}
-};
-
-static const BANDWIDTH_TAB bandWidthTable_LD_44100[] = {
- { 8000, 2000, 2000},
- {24000, 2000, 2000},
- {32000, 4400, 5700},
- {40000, 7400, 8800},
- {48000, 9000, 10700},
- {56000, 11000, 12900},
- {64000, 14400, 15500},
- {80000, 16000, 16200},
- {96000, 16500, 16000},
- {128000, 16000, 16000},
- {360001, 16000, 16000}
-};
-
-static const BANDWIDTH_TAB bandWidthTable_LD_48000[] = {
- { 8000, 2000, 2000},
- {24000, 2000, 2000},
- {32000, 4400, 5700},
- {40000, 7400, 8800},
- {48000, 9000, 10700},
- {56000, 11000, 12800},
- {64000, 14300, 15400},
- {80000, 16000, 16200},
- {96000, 16500, 16000},
- {128000, 16000, 16000},
- {360001, 16000, 16000}
-};
-
-typedef struct{
- AACENC_BITRATE_MODE bitrateMode;
- int bandWidthMono;
- int bandWidth2AndMoreChan;
-} BANDWIDTH_TAB_VBR;
-
-static const BANDWIDTH_TAB_VBR bandWidthTableVBR[]= {
- {AACENC_BR_MODE_CBR, 0, 0},
- {AACENC_BR_MODE_VBR_1, 13050, 13050},
- {AACENC_BR_MODE_VBR_2, 13050, 13050},
- {AACENC_BR_MODE_VBR_3, 14260, 14260},
- {AACENC_BR_MODE_VBR_4, 15500, 15500},
- {AACENC_BR_MODE_VBR_5, 48000, 48000},
- {AACENC_BR_MODE_SFR, 0, 0},
- {AACENC_BR_MODE_FF, 0, 0}
-
-};
-
-static INT GetBandwidthEntry(
- const INT frameLength,
- const INT sampleRate,
- const INT chanBitRate,
- const INT entryNo)
-{
- INT bandwidth = -1;
- const BANDWIDTH_TAB *pBwTab = NULL;
- INT bwTabSize = 0;
-
- switch (frameLength) {
- case 960:
- case 1024:
- pBwTab = bandWidthTable;
- bwTabSize = sizeof(bandWidthTable)/sizeof(BANDWIDTH_TAB);
- break;
- case 480:
- case 512:
- switch (sampleRate) {
- case 8000:
- case 11025:
- case 12000:
- case 16000:
- case 22050:
- pBwTab = bandWidthTable_LD_22050;
- bwTabSize = sizeof(bandWidthTable_LD_22050)/sizeof(BANDWIDTH_TAB);
- break;
- case 24000:
- pBwTab = bandWidthTable_LD_24000;
- bwTabSize = sizeof(bandWidthTable_LD_24000)/sizeof(BANDWIDTH_TAB);
- break;
- case 32000:
- pBwTab = bandWidthTable_LD_32000;
- bwTabSize = sizeof(bandWidthTable_LD_32000)/sizeof(BANDWIDTH_TAB);
- break;
- case (44100):
- pBwTab = bandWidthTable_LD_44100;
- bwTabSize = sizeof(bandWidthTable_LD_44100)/sizeof(BANDWIDTH_TAB);
- break;
- case 48000:
- case 64000:
- case 88200:
- case 96000:
- pBwTab = bandWidthTable_LD_48000;
- bwTabSize = sizeof(bandWidthTable_LD_48000)/sizeof(BANDWIDTH_TAB);
- break;
- }
- break;
- default:
- pBwTab = NULL;
- bwTabSize = 0;
- }
-
- if (pBwTab!=NULL) {
- int i;
- for (i=0; i<bwTabSize-1; i++) {
- if (chanBitRate >= pBwTab[i].chanBitRate &&
- chanBitRate < pBwTab[i+1].chanBitRate)
- {
- switch (frameLength) {
- case 960:
- case 1024:
- bandwidth = (entryNo==0)
- ? pBwTab[i].bandWidthMono
- : pBwTab[i].bandWidth2AndMoreChan;
- break;
- case 480:
- case 512:
- {
- INT q_res = 0;
- INT startBw = (entryNo==0) ? pBwTab[i ].bandWidthMono : pBwTab[i ].bandWidth2AndMoreChan;
- INT endBw = (entryNo==0) ? pBwTab[i+1].bandWidthMono : pBwTab[i+1].bandWidth2AndMoreChan;
- INT startBr = pBwTab[i].chanBitRate;
- INT endBr = pBwTab[i+1].chanBitRate;
-
- FIXP_DBL bwFac_fix = fDivNorm(chanBitRate-startBr, endBr-startBr, &q_res);
- bandwidth = (INT)scaleValue(fMult(bwFac_fix, (FIXP_DBL)(endBw-startBw)),q_res) + startBw;
- }
- break;
- default:
- bandwidth = -1;
- }
- break;
- } /* within bitrate range */
- }
- } /* pBwTab!=NULL */
-
- return bandwidth;
-}
-
-
-AAC_ENCODER_ERROR FDKaacEnc_DetermineBandWidth(INT* bandWidth,
- INT proposedBandWidth,
- INT bitrate,
- AACENC_BITRATE_MODE bitrateMode,
- INT sampleRate,
- INT frameLength,
- CHANNEL_MAPPING* cm,
- CHANNEL_MODE encoderMode)
-{
- AAC_ENCODER_ERROR ErrorStatus = AAC_ENC_OK;
- INT chanBitRate = bitrate/cm->nChannels;
-
- /* vbr */
- switch(bitrateMode){
- case AACENC_BR_MODE_VBR_1:
- case AACENC_BR_MODE_VBR_2:
- case AACENC_BR_MODE_VBR_3:
- case AACENC_BR_MODE_VBR_4:
- case AACENC_BR_MODE_VBR_5:
- if (proposedBandWidth != 0){
- /* use given bw */
- *bandWidth = proposedBandWidth;
- } else {
- /* take bw from table */
- switch(encoderMode){
- case MODE_1:
- *bandWidth = bandWidthTableVBR[bitrateMode].bandWidthMono;
- break;
- case MODE_2:
- case MODE_1_2:
- case MODE_1_2_1:
- case MODE_1_2_2:
- case MODE_1_2_2_1:
- case MODE_1_2_2_2_1:
- case MODE_7_1_REAR_SURROUND:
- case MODE_7_1_FRONT_CENTER:
- *bandWidth = bandWidthTableVBR[bitrateMode].bandWidth2AndMoreChan;
- break;
- default:
- return AAC_ENC_UNSUPPORTED_CHANNELCONFIG;
- }
- }
- break;
- case AACENC_BR_MODE_CBR:
- case AACENC_BR_MODE_SFR:
- case AACENC_BR_MODE_FF:
-
- /* bandwidth limiting */
- if (proposedBandWidth != 0) {
- *bandWidth = FDKmin(proposedBandWidth, FDKmin(20000, sampleRate>>1));
- }
- else { /* search reasonable bandwidth */
-
- int entryNo = 0;
-
- switch(encoderMode){
- case MODE_1: /* mono */
- entryNo = 0; /* use mono bandwith settings */
- break;
-
- case MODE_2: /* stereo */
- case MODE_1_2: /* sce + cpe */
- case MODE_1_2_1: /* sce + cpe + sce */
- case MODE_1_2_2: /* sce + cpe + cpe */
- case MODE_1_2_2_1: /* (5.1) sce + cpe + cpe + lfe */
- case MODE_1_2_2_2_1: /* (7.1) sce + cpe + cpe + cpe + lfe */
- case MODE_7_1_REAR_SURROUND:
- case MODE_7_1_FRONT_CENTER:
- entryNo = 1; /* use stereo bandwith settings */
- break;
-
- default:
- return AAC_ENC_UNSUPPORTED_CHANNELCONFIG;
- }
-
- *bandWidth = GetBandwidthEntry(
- frameLength,
- sampleRate,
- chanBitRate,
- entryNo);
-
- if (*bandWidth==-1) {
- ErrorStatus = AAC_ENC_INVALID_CHANNEL_BITRATE;
- }
- }
- break;
- default:
- *bandWidth = 0;
- return AAC_ENC_UNSUPPORTED_BITRATE_MODE;
- }
-
- *bandWidth = FDKmin(*bandWidth, sampleRate/2);
-
- return ErrorStatus;;
-}
diff --git a/libAACenc/src/bandwidth.h b/libAACenc/src/bandwidth.h
deleted file mode 100644
index 2e92453..0000000
--- a/libAACenc/src/bandwidth.h
+++ /dev/null
@@ -1,106 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/************************* Fast MPEG AAC Audio Encoder **********************
-
- Initial author: M. Schug / A. Groeschel
- contents/description: bandwidth expert
-
-******************************************************************************/
-
-#ifndef _BANDWIDTH_H
-#define _BANDWIDTH_H
-
-
-#include "qc_data.h"
-
-AAC_ENCODER_ERROR FDKaacEnc_DetermineBandWidth(INT* bandWidth,
- INT proposedBandwidth,
- INT bitrate,
- AACENC_BITRATE_MODE bitrateMode,
- INT sampleRate,
- INT frameLength,
- CHANNEL_MAPPING* cm,
- CHANNEL_MODE encoderMode);
-
-#endif /* BANDWIDTH_H */
diff --git a/libAACenc/src/bit_cnt.cpp b/libAACenc/src/bit_cnt.cpp
deleted file mode 100644
index 926ee49..0000000
--- a/libAACenc/src/bit_cnt.cpp
+++ /dev/null
@@ -1,1122 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M.Werner
- contents/description: Huffman Bitcounter & coder
-
-******************************************************************************/
-
-#include "bit_cnt.h"
-
-#include "aacEnc_ram.h"
-
-#define HI_LTAB(a) (a>>16)
-#define LO_LTAB(a) (a & 0xffff)
-
-/*****************************************************************************
-
-
- functionname: FDKaacEnc_count1_2_3_4_5_6_7_8_9_10_11
- description: counts tables 1-11
- returns:
- input: quantized spectrum
- output: bitCount for tables 1-11
-
-*****************************************************************************/
-
-static void FDKaacEnc_count1_2_3_4_5_6_7_8_9_10_11(const SHORT *RESTRICT values,
- const INT width,
- INT *bitCount)
-{
-
- INT i;
- INT bc1_2,bc3_4,bc5_6,bc7_8,bc9_10,bc11,sc;
- INT t0,t1,t2,t3;
- bc1_2=0;
- bc3_4=0;
- bc5_6=0;
- bc7_8=0;
- bc9_10=0;
- bc11=0;
- sc=0;
-
- for(i=0;i<width;i+=4){
-
- t0= values[i+0];
- t1= values[i+1];
- t2= values[i+2];
- t3= values[i+3];
-
- /* 1,2 */
-
- bc1_2+=FDKaacEnc_huff_ltab1_2[t0+1][t1+1][t2+1][t3+1];
-
- /* 5,6 */
- bc5_6+=FDKaacEnc_huff_ltab5_6[t0+4][t1+4];
- bc5_6+=FDKaacEnc_huff_ltab5_6[t2+4][t3+4];
-
- t0=fixp_abs(t0);
- t1=fixp_abs(t1);
- t2=fixp_abs(t2);
- t3=fixp_abs(t3);
-
-
- bc3_4+= FDKaacEnc_huff_ltab3_4[t0][t1][t2][t3];
-
- bc7_8+=FDKaacEnc_huff_ltab7_8[t0][t1];
- bc7_8+=FDKaacEnc_huff_ltab7_8[t2][t3];
-
- bc9_10+=FDKaacEnc_huff_ltab9_10[t0][t1];
- bc9_10+=FDKaacEnc_huff_ltab9_10[t2][t3];
-
- bc11+= (INT) FDKaacEnc_huff_ltab11[t0][t1];
- bc11+= (INT) FDKaacEnc_huff_ltab11[t2][t3];
-
- sc+=(t0>0)+(t1>0)+(t2>0)+(t3>0);
- }
-
- bitCount[1]=HI_LTAB(bc1_2);
- bitCount[2]=LO_LTAB(bc1_2);
- bitCount[3]=HI_LTAB(bc3_4)+sc;
- bitCount[4]=LO_LTAB(bc3_4)+sc;
- bitCount[5]=HI_LTAB(bc5_6);
- bitCount[6]=LO_LTAB(bc5_6);
- bitCount[7]=HI_LTAB(bc7_8)+sc;
- bitCount[8]=LO_LTAB(bc7_8)+sc;
- bitCount[9]=HI_LTAB(bc9_10)+sc;
- bitCount[10]=LO_LTAB(bc9_10)+sc;
- bitCount[11]=bc11+sc;
-
-}
-
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_count3_4_5_6_7_8_9_10_11
- description: counts tables 3-11
- returns:
- input: quantized spectrum
- output: bitCount for tables 3-11
-
-*****************************************************************************/
-
-static void FDKaacEnc_count3_4_5_6_7_8_9_10_11(const SHORT *RESTRICT values,
- const INT width,
- INT *bitCount)
-{
-
- INT i;
- INT bc3_4,bc5_6,bc7_8,bc9_10,bc11,sc;
- INT t0,t1,t2,t3;
-
- bc3_4=0;
- bc5_6=0;
- bc7_8=0;
- bc9_10=0;
- bc11=0;
- sc=0;
-
- for(i=0;i<width;i+=4){
-
- t0= values[i+0];
- t1= values[i+1];
- t2= values[i+2];
- t3= values[i+3];
-
- bc5_6+=FDKaacEnc_huff_ltab5_6[t0+4][t1+4];
- bc5_6+=FDKaacEnc_huff_ltab5_6[t2+4][t3+4];
-
- t0=fixp_abs(t0);
- t1=fixp_abs(t1);
- t2=fixp_abs(t2);
- t3=fixp_abs(t3);
-
- bc3_4+= FDKaacEnc_huff_ltab3_4[t0][t1][t2][t3];
-
- bc7_8+=FDKaacEnc_huff_ltab7_8[t0][t1];
- bc7_8+=FDKaacEnc_huff_ltab7_8[t2][t3];
-
- bc9_10+=FDKaacEnc_huff_ltab9_10[t0][t1];
- bc9_10+=FDKaacEnc_huff_ltab9_10[t2][t3];
-
- bc11+= (INT) FDKaacEnc_huff_ltab11[t0][t1];
- bc11+= (INT) FDKaacEnc_huff_ltab11[t2][t3];
-
- sc+=(t0>0)+(t1>0)+(t2>0)+(t3>0);
- }
-
- bitCount[1]=INVALID_BITCOUNT;
- bitCount[2]=INVALID_BITCOUNT;
- bitCount[3]=HI_LTAB(bc3_4)+sc;
- bitCount[4]=LO_LTAB(bc3_4)+sc;
- bitCount[5]=HI_LTAB(bc5_6);
- bitCount[6]=LO_LTAB(bc5_6);
- bitCount[7]=HI_LTAB(bc7_8)+sc;
- bitCount[8]=LO_LTAB(bc7_8)+sc;
- bitCount[9]=HI_LTAB(bc9_10)+sc;
- bitCount[10]=LO_LTAB(bc9_10)+sc;
- bitCount[11]=bc11+sc;
-}
-
-
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_count5_6_7_8_9_10_11
- description: counts tables 5-11
- returns:
- input: quantized spectrum
- output: bitCount for tables 5-11
-
-*****************************************************************************/
-
-
-static void FDKaacEnc_count5_6_7_8_9_10_11(const SHORT *RESTRICT values,
- const INT width,
- INT *bitCount)
-{
-
- INT i;
- INT bc5_6,bc7_8,bc9_10,bc11,sc;
- INT t0,t1;
- bc5_6=0;
- bc7_8=0;
- bc9_10=0;
- bc11=0;
- sc=0;
-
- for(i=0;i<width;i+=2){
-
- t0 = values[i+0];
- t1 = values[i+1];
-
- bc5_6+=FDKaacEnc_huff_ltab5_6[t0+4][t1+4];
-
- t0=fixp_abs(t0);
- t1=fixp_abs(t1);
-
- bc7_8+=FDKaacEnc_huff_ltab7_8[t0][t1];
- bc9_10+=FDKaacEnc_huff_ltab9_10[t0][t1];
- bc11+= (INT) FDKaacEnc_huff_ltab11[t0][t1];
-
- sc+=(t0>0)+(t1>0);
- }
- bitCount[1]=INVALID_BITCOUNT;
- bitCount[2]=INVALID_BITCOUNT;
- bitCount[3]=INVALID_BITCOUNT;
- bitCount[4]=INVALID_BITCOUNT;
- bitCount[5]=HI_LTAB(bc5_6);
- bitCount[6]=LO_LTAB(bc5_6);
- bitCount[7]=HI_LTAB(bc7_8)+sc;
- bitCount[8]=LO_LTAB(bc7_8)+sc;
- bitCount[9]=HI_LTAB(bc9_10)+sc;
- bitCount[10]=LO_LTAB(bc9_10)+sc;
- bitCount[11]=bc11+sc;
-
-}
-
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_count7_8_9_10_11
- description: counts tables 7-11
- returns:
- input: quantized spectrum
- output: bitCount for tables 7-11
-
-*****************************************************************************/
-
-static void FDKaacEnc_count7_8_9_10_11(const SHORT *RESTRICT values,
- const INT width,
- INT *bitCount)
-{
-
- INT i;
- INT bc7_8,bc9_10,bc11,sc;
- INT t0,t1;
-
- bc7_8=0;
- bc9_10=0;
- bc11=0;
- sc=0;
-
- for(i=0;i<width;i+=2){
- t0=fixp_abs(values[i+0]);
- t1=fixp_abs(values[i+1]);
-
- bc7_8+=FDKaacEnc_huff_ltab7_8[t0][t1];
- bc9_10+=FDKaacEnc_huff_ltab9_10[t0][t1];
- bc11+= (INT) FDKaacEnc_huff_ltab11[t0][t1];
- sc+=(t0>0)+(t1>0);
- }
-
- bitCount[1]=INVALID_BITCOUNT;
- bitCount[2]=INVALID_BITCOUNT;
- bitCount[3]=INVALID_BITCOUNT;
- bitCount[4]=INVALID_BITCOUNT;
- bitCount[5]=INVALID_BITCOUNT;
- bitCount[6]=INVALID_BITCOUNT;
- bitCount[7]=HI_LTAB(bc7_8)+sc;
- bitCount[8]=LO_LTAB(bc7_8)+sc;
- bitCount[9]=HI_LTAB(bc9_10)+sc;
- bitCount[10]=LO_LTAB(bc9_10)+sc;
- bitCount[11]=bc11+sc;
-
-}
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_count9_10_11
- description: counts tables 9-11
- returns:
- input: quantized spectrum
- output: bitCount for tables 9-11
-
-*****************************************************************************/
-
-
-
-static void FDKaacEnc_count9_10_11(const SHORT *RESTRICT values,
- const INT width,
- INT *bitCount)
-{
-
- INT i;
- INT bc9_10,bc11,sc;
- INT t0,t1;
-
- bc9_10=0;
- bc11=0;
- sc=0;
-
- for(i=0;i<width;i+=2){
- t0=fixp_abs(values[i+0]);
- t1=fixp_abs(values[i+1]);
-
- bc9_10+=FDKaacEnc_huff_ltab9_10[t0][t1];
- bc11+= (INT) FDKaacEnc_huff_ltab11[t0][t1];
-
- sc+=(t0>0)+(t1>0);
- }
-
- bitCount[1]=INVALID_BITCOUNT;
- bitCount[2]=INVALID_BITCOUNT;
- bitCount[3]=INVALID_BITCOUNT;
- bitCount[4]=INVALID_BITCOUNT;
- bitCount[5]=INVALID_BITCOUNT;
- bitCount[6]=INVALID_BITCOUNT;
- bitCount[7]=INVALID_BITCOUNT;
- bitCount[8]=INVALID_BITCOUNT;
- bitCount[9]=HI_LTAB(bc9_10)+sc;
- bitCount[10]=LO_LTAB(bc9_10)+sc;
- bitCount[11]=bc11+sc;
-
-}
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_count11
- description: counts table 11
- returns:
- input: quantized spectrum
- output: bitCount for table 11
-
-*****************************************************************************/
-
-static void FDKaacEnc_count11(const SHORT *RESTRICT values,
- const INT width,
- INT *bitCount)
-{
-
- INT i;
- INT bc11,sc;
- INT t0,t1;
-
- bc11=0;
- sc=0;
- for(i=0;i<width;i+=2){
- t0=fixp_abs(values[i+0]);
- t1=fixp_abs(values[i+1]);
- bc11+= (INT) FDKaacEnc_huff_ltab11[t0][t1];
- sc+=(t0>0)+(t1>0);
- }
-
- bitCount[1]=INVALID_BITCOUNT;
- bitCount[2]=INVALID_BITCOUNT;
- bitCount[3]=INVALID_BITCOUNT;
- bitCount[4]=INVALID_BITCOUNT;
- bitCount[5]=INVALID_BITCOUNT;
- bitCount[6]=INVALID_BITCOUNT;
- bitCount[7]=INVALID_BITCOUNT;
- bitCount[8]=INVALID_BITCOUNT;
- bitCount[9]=INVALID_BITCOUNT;
- bitCount[10]=INVALID_BITCOUNT;
- bitCount[11]=bc11+sc;
-}
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_countEsc
- description: counts table 11 (with Esc)
- returns:
- input: quantized spectrum
- output: bitCount for tables 11 (with Esc)
-
-*****************************************************************************/
-
-static void FDKaacEnc_countEsc(const SHORT *RESTRICT values,
- const INT width,
- INT *RESTRICT bitCount)
-{
-
- INT i;
- INT bc11,ec,sc;
- INT t0,t1,t00,t01;
-
- bc11=0;
- sc=0;
- ec=0;
- for(i=0;i<width;i+=2){
- t0=fixp_abs(values[i+0]);
- t1=fixp_abs(values[i+1]);
-
- sc+=(t0>0)+(t1>0);
-
- t00 = fixMin(t0,16);
- t01 = fixMin(t1,16);
- bc11+= (INT) FDKaacEnc_huff_ltab11[t00][t01];
-
- if(t0>=16){
- ec+=5;
- while((t0>>=1) >= 16)
- ec+=2;
- }
-
- if(t1>=16){
- ec+=5;
- while((t1>>=1) >= 16)
- ec+=2;
- }
- }
-
- for (i=0; i<11; i++)
- bitCount[i]=INVALID_BITCOUNT;
-
- bitCount[11]=bc11+sc+ec;
-}
-
-
-typedef void (*COUNT_FUNCTION)(const SHORT *RESTRICT values,
- const INT width,
- INT *RESTRICT bitCount);
-
-static const COUNT_FUNCTION countFuncTable[CODE_BOOK_ESC_LAV+1] =
-{
-
- FDKaacEnc_count1_2_3_4_5_6_7_8_9_10_11, /* 0 */
- FDKaacEnc_count1_2_3_4_5_6_7_8_9_10_11, /* 1 */
- FDKaacEnc_count3_4_5_6_7_8_9_10_11, /* 2 */
- FDKaacEnc_count5_6_7_8_9_10_11, /* 3 */
- FDKaacEnc_count5_6_7_8_9_10_11, /* 4 */
- FDKaacEnc_count7_8_9_10_11, /* 5 */
- FDKaacEnc_count7_8_9_10_11, /* 6 */
- FDKaacEnc_count7_8_9_10_11, /* 7 */
- FDKaacEnc_count9_10_11, /* 8 */
- FDKaacEnc_count9_10_11, /* 9 */
- FDKaacEnc_count9_10_11, /* 10 */
- FDKaacEnc_count9_10_11, /* 11 */
- FDKaacEnc_count9_10_11, /* 12 */
- FDKaacEnc_count11, /* 13 */
- FDKaacEnc_count11, /* 14 */
- FDKaacEnc_count11, /* 15 */
- FDKaacEnc_countEsc /* 16 */
-};
-
-
-
-INT FDKaacEnc_bitCount(const SHORT *values,
- const INT width,
- INT maxVal,
- INT *bitCount)
-{
-
- /*
- check if we can use codebook 0
- */
-
- if(maxVal == 0)
- bitCount[0] = 0;
- else
- bitCount[0] = INVALID_BITCOUNT;
-
- maxVal = fixMin(maxVal,(INT)CODE_BOOK_ESC_LAV);
- countFuncTable[maxVal](values,width,bitCount);
- return(0);
-}
-
-
-
-
-/*
- count difference between actual and zeroed lines
-*/
-INT FDKaacEnc_countValues(SHORT *RESTRICT values, INT width, INT codeBook)
-{
-
- INT i,t0,t1,t2,t3,t00,t01;
- INT codeLength;
- INT signLength;
- INT bitCnt=0;
-
- switch(codeBook){
- case CODE_BOOK_ZERO_NO:
- break;
-
- case CODE_BOOK_1_NO:
- for(i=0; i<width; i+=4) {
- t0 = values[i+0];
- t1 = values[i+1];
- t2 = values[i+2];
- t3 = values[i+3];
- codeLength = HI_LTAB(FDKaacEnc_huff_ltab1_2[t0+1][t1+1][t2+1][t3+1]);
- bitCnt+= codeLength;
- }
- break;
-
- case CODE_BOOK_2_NO:
- for(i=0; i<width; i+=4) {
- t0 = values[i+0];
- t1 = values[i+1];
- t2 = values[i+2];
- t3 = values[i+3];
- codeLength = LO_LTAB(FDKaacEnc_huff_ltab1_2[t0+1][t1+1][t2+1][t3+1]);
- bitCnt+= codeLength;
- }
- break;
-
- case CODE_BOOK_3_NO:
- for(i=0; i<width; i+=4) {
- signLength=0;
- t0 = values[i+0];
- if(t0 != 0){
- signLength++;
- t0=fixp_abs(t0);
- }
- t1 = values[i+1];
- if(t1 != 0){
- signLength++;
- t1=fixp_abs(t1);
- }
- t2 = values[i+2];
- if(t2 != 0){
- signLength++;
- t2=fixp_abs(t2);
- }
- t3 = values[i+3];
- if(t3 != 0){
- signLength++;
- t3=fixp_abs(t3);
- }
-
- codeLength = HI_LTAB(FDKaacEnc_huff_ltab3_4[t0][t1][t2][t3]);
- bitCnt+=codeLength+signLength;
- }
- break;
-
- case CODE_BOOK_4_NO:
- for(i=0; i<width; i+=4) {
- signLength=0;
- t0 = values[i+0];
- if(t0 != 0){
- signLength++;
- t0=fixp_abs(t0);
- }
- t1 = values[i+1];
- if(t1 != 0){
- signLength++;
- t1=fixp_abs(t1);
- }
- t2 = values[i+2];
- if(t2 != 0){
- signLength++;
- t2=fixp_abs(t2);
- }
- t3 = values[i+3];
- if(t3 != 0){
- signLength++;
- t3=fixp_abs(t3);
- }
- codeLength = LO_LTAB(FDKaacEnc_huff_ltab3_4[t0][t1][t2][t3]);
- bitCnt+=codeLength+signLength;
- }
- break;
-
- case CODE_BOOK_5_NO:
- for(i=0; i<width; i+=2) {
- t0 = values[i+0];
- t1 = values[i+1];
- codeLength = HI_LTAB(FDKaacEnc_huff_ltab5_6[t0+4][t1+4]);
- bitCnt+=codeLength;
- }
- break;
-
- case CODE_BOOK_6_NO:
- for(i=0; i<width; i+=2) {
- t0 = values[i+0];
- t1 = values[i+1];
- codeLength = LO_LTAB(FDKaacEnc_huff_ltab5_6[t0+4][t1+4]);
- bitCnt+=codeLength;
- }
- break;
-
- case CODE_BOOK_7_NO:
- for(i=0; i<width; i+=2){
- signLength=0;
- t0 = values[i+0];
- if(t0 != 0){
- signLength++;
- t0=fixp_abs(t0);
- }
-
- t1 = values[i+1];
- if(t1 != 0){
- signLength++;
- t1=fixp_abs(t1);
- }
- codeLength = HI_LTAB(FDKaacEnc_huff_ltab7_8[t0][t1]);
- bitCnt+=codeLength +signLength;
- }
- break;
-
- case CODE_BOOK_8_NO:
- for(i=0; i<width; i+=2) {
- signLength=0;
- t0 = values[i+0];
- if(t0 != 0){
- signLength++;
- t0=fixp_abs(t0);
- }
-
- t1 = values[i+1];
- if(t1 != 0){
- signLength++;
- t1=fixp_abs(t1);
- }
- codeLength = LO_LTAB(FDKaacEnc_huff_ltab7_8[t0][t1]);
- bitCnt+=codeLength +signLength;
- }
- break;
-
- case CODE_BOOK_9_NO:
- for(i=0; i<width; i+=2) {
- signLength=0;
- t0 = values[i+0];
- if(t0 != 0){
- signLength++;
- t0=fixp_abs(t0);
- }
- t1 = values[i+1];
- if(t1 != 0){
- signLength++;
- t1=fixp_abs(t1);
- }
- codeLength = HI_LTAB(FDKaacEnc_huff_ltab9_10[t0][t1]);
- bitCnt+=codeLength +signLength;
- }
- break;
-
- case CODE_BOOK_10_NO:
- for(i=0; i<width; i+=2) {
- signLength=0;
- t0 = values[i+0];
- if(t0 != 0){
- signLength++;
- t0=fixp_abs(t0);
- }
-
- t1 = values[i+1];
- if(t1 != 0){
- signLength++;
- t1=fixp_abs(t1);
- }
- codeLength = LO_LTAB(FDKaacEnc_huff_ltab9_10[t0][t1]);
- bitCnt+=codeLength +signLength;
- }
- break;
-
- case CODE_BOOK_ESC_NO:
- for(i=0; i<width; i+=2) {
- signLength=0;
- t0 = values[i+0];
- if(t0 != 0){
- signLength++;
- t0=fixp_abs(t0);
- }
- t1 = values[i+1];
- if(t1 != 0){
- signLength++;
- t1=fixp_abs(t1);
- }
- t00 = fixMin(t0,16);
- t01 = fixMin(t1,16);
-
- codeLength = (INT) FDKaacEnc_huff_ltab11[t00][t01];
- bitCnt+=codeLength +signLength;
- if(t0 >=16){
- INT n,p;
- n=0;
- p=t0;
- while((p>>=1) >=16){
- bitCnt++;
- n++;
- }
- bitCnt+=(n+5);
- }
- if(t1 >=16){
- INT n,p;
- n=0;
- p=t1;
- while((p>>=1) >=16){
- bitCnt++;
- n++;
- }
- bitCnt+=(n+5);
- }
- }
- break;
-
- default:
- break;
- }
-
- return(bitCnt);
-}
-
-
-
-INT FDKaacEnc_codeValues(SHORT *RESTRICT values, INT width, INT codeBook, HANDLE_FDK_BITSTREAM hBitstream)
-{
-
- INT i,t0,t1,t2,t3,t00,t01;
- INT codeWord,codeLength;
- INT sign,signLength;
-
- switch(codeBook){
- case CODE_BOOK_ZERO_NO:
- break;
-
- case CODE_BOOK_1_NO:
- for(i=0; i<width; i+=4) {
- t0 = values[i+0]+1;
- t1 = values[i+1]+1;
- t2 = values[i+2]+1;
- t3 = values[i+3]+1;
- codeWord = FDKaacEnc_huff_ctab1[t0][t1][t2][t3];
- codeLength = HI_LTAB(FDKaacEnc_huff_ltab1_2[t0][t1][t2][t3]);
- FDKwriteBits(hBitstream,codeWord,codeLength);
- }
- break;
-
- case CODE_BOOK_2_NO:
- for(i=0; i<width; i+=4) {
- t0 = values[i+0]+1;
- t1 = values[i+1]+1;
- t2 = values[i+2]+1;
- t3 = values[i+3]+1;
- codeWord = FDKaacEnc_huff_ctab2[t0][t1][t2][t3];
- codeLength = LO_LTAB(FDKaacEnc_huff_ltab1_2[t0][t1][t2][t3]);
- FDKwriteBits(hBitstream,codeWord,codeLength);
- }
- break;
-
- case CODE_BOOK_3_NO:
- for(i=0; i<width; i+=4) {
- sign=0;
- signLength=0;
- t0 = values[i+0];
- if(t0 != 0){
- signLength++;
- sign<<=1;
- if(t0 < 0){
- sign|=1;
- t0=fixp_abs(t0);
- }
- }
- t1 = values[i+1];
- if(t1 != 0){
- signLength++;
- sign<<=1;
- if(t1 < 0){
- sign|=1;
- t1=fixp_abs(t1);
- }
- }
- t2 = values[i+2];
- if(t2 != 0){
- signLength++;
- sign<<=1;
- if(t2 < 0){
- sign|=1;
- t2=fixp_abs(t2);
- }
- }
- t3 = values[i+3];
- if(t3 != 0){
- signLength++;
- sign<<=1;
- if(t3 < 0){
- sign|=1;
- t3=fixp_abs(t3);
- }
- }
-
- codeWord = FDKaacEnc_huff_ctab3[t0][t1][t2][t3];
- codeLength = HI_LTAB(FDKaacEnc_huff_ltab3_4[t0][t1][t2][t3]);
- FDKwriteBits(hBitstream,codeWord,codeLength);
- FDKwriteBits(hBitstream,sign,signLength);
- }
- break;
-
- case CODE_BOOK_4_NO:
- for(i=0; i<width; i+=4) {
- sign=0;
- signLength=0;
- t0 = values[i+0];
- if(t0 != 0){
- signLength++;
- sign<<=1;
- if(t0 < 0){
- sign|=1;
- t0=fixp_abs(t0);
- }
- }
- t1 = values[i+1];
- if(t1 != 0){
- signLength++;
- sign<<=1;
- if(t1 < 0){
- sign|=1;
- t1=fixp_abs(t1);
- }
- }
- t2 = values[i+2];
- if(t2 != 0){
- signLength++;
- sign<<=1;
- if(t2 < 0){
- sign|=1;
- t2=fixp_abs(t2);
- }
- }
- t3 = values[i+3];
- if(t3 != 0){
- signLength++;
- sign<<=1;
- if(t3 < 0){
- sign|=1;
- t3=fixp_abs(t3);
- }
- }
- codeWord = FDKaacEnc_huff_ctab4[t0][t1][t2][t3];
- codeLength = LO_LTAB(FDKaacEnc_huff_ltab3_4[t0][t1][t2][t3]);
- FDKwriteBits(hBitstream,codeWord,codeLength);
- FDKwriteBits(hBitstream,sign,signLength);
- }
- break;
-
- case CODE_BOOK_5_NO:
- for(i=0; i<width; i+=2) {
- t0 = values[i+0]+4;
- t1 = values[i+1]+4;
- codeWord = FDKaacEnc_huff_ctab5[t0][t1];
- codeLength = HI_LTAB(FDKaacEnc_huff_ltab5_6[t0][t1]);
- FDKwriteBits(hBitstream,codeWord,codeLength);
- }
- break;
-
- case CODE_BOOK_6_NO:
- for(i=0; i<width; i+=2) {
- t0 = values[i+0]+4;
- t1 = values[i+1]+4;
- codeWord = FDKaacEnc_huff_ctab6[t0][t1];
- codeLength = LO_LTAB(FDKaacEnc_huff_ltab5_6[t0][t1]);
- FDKwriteBits(hBitstream,codeWord,codeLength);
- }
- break;
-
- case CODE_BOOK_7_NO:
- for(i=0; i<width; i+=2){
- sign=0;
- signLength=0;
- t0 = values[i+0];
- if(t0 != 0){
- signLength++;
- sign<<=1;
- if(t0 < 0){
- sign|=1;
- t0=fixp_abs(t0);
- }
- }
-
- t1 = values[i+1];
- if(t1 != 0){
- signLength++;
- sign<<=1;
- if(t1 < 0){
- sign|=1;
- t1=fixp_abs(t1);
- }
- }
- codeWord = FDKaacEnc_huff_ctab7[t0][t1];
- codeLength = HI_LTAB(FDKaacEnc_huff_ltab7_8[t0][t1]);
- FDKwriteBits(hBitstream,codeWord,codeLength);
- FDKwriteBits(hBitstream,sign,signLength);
- }
- break;
-
- case CODE_BOOK_8_NO:
- for(i=0; i<width; i+=2) {
- sign=0;
- signLength=0;
- t0 = values[i+0];
- if(t0 != 0){
- signLength++;
- sign<<=1;
- if(t0 < 0){
- sign|=1;
- t0=fixp_abs(t0);
- }
- }
-
- t1 = values[i+1];
- if(t1 != 0){
- signLength++;
- sign<<=1;
- if(t1 < 0){
- sign|=1;
- t1=fixp_abs(t1);
- }
- }
- codeWord = FDKaacEnc_huff_ctab8[t0][t1];
- codeLength = LO_LTAB(FDKaacEnc_huff_ltab7_8[t0][t1]);
- FDKwriteBits(hBitstream,codeWord,codeLength);
- FDKwriteBits(hBitstream,sign,signLength);
- }
- break;
-
- case CODE_BOOK_9_NO:
- for(i=0; i<width; i+=2) {
- sign=0;
- signLength=0;
- t0 = values[i+0];
- if(t0 != 0){
- signLength++;
- sign<<=1;
- if(t0 < 0){
- sign|=1;
- t0=fixp_abs(t0);
- }
- }
- t1 = values[i+1];
- if(t1 != 0){
- signLength++;
- sign<<=1;
- if(t1 < 0){
- sign|=1;
- t1=fixp_abs(t1);
- }
- }
- codeWord = FDKaacEnc_huff_ctab9[t0][t1];
- codeLength = HI_LTAB(FDKaacEnc_huff_ltab9_10[t0][t1]);
- FDKwriteBits(hBitstream,codeWord,codeLength);
- FDKwriteBits(hBitstream,sign,signLength);
- }
- break;
-
- case CODE_BOOK_10_NO:
- for(i=0; i<width; i+=2) {
- sign=0;
- signLength=0;
- t0 = values[i+0];
- if(t0 != 0){
- signLength++;
- sign<<=1;
- if(t0 < 0){
- sign|=1;
- t0=fixp_abs(t0);
- }
- }
-
- t1 = values[i+1];
- if(t1 != 0){
- signLength++;
- sign<<=1;
- if(t1 < 0){
- sign|=1;
- t1=fixp_abs(t1);
- }
- }
- codeWord = FDKaacEnc_huff_ctab10[t0][t1];
- codeLength = LO_LTAB(FDKaacEnc_huff_ltab9_10[t0][t1]);
- FDKwriteBits(hBitstream,codeWord,codeLength);
- FDKwriteBits(hBitstream,sign,signLength);
- }
- break;
-
- case CODE_BOOK_ESC_NO:
- for(i=0; i<width; i+=2) {
- sign=0;
- signLength=0;
- t0 = values[i+0];
- if(t0 != 0){
- signLength++;
- sign<<=1;
- if(t0 < 0){
- sign|=1;
- t0=fixp_abs(t0);
- }
- }
- t1 = values[i+1];
- if(t1 != 0){
- signLength++;
- sign<<=1;
- if(t1 < 0){
- sign|=1;
- t1=fixp_abs(t1);
- }
- }
- t00 = fixMin(t0,16);
- t01 = fixMin(t1,16);
-
- codeWord = FDKaacEnc_huff_ctab11[t00][t01];
- codeLength = (INT) FDKaacEnc_huff_ltab11[t00][t01];
- FDKwriteBits(hBitstream,codeWord,codeLength);
- FDKwriteBits(hBitstream,sign,signLength);
- if(t0 >=16){
- INT n,p;
- n=0;
- p=t0;
- while((p>>=1) >=16){
- FDKwriteBits(hBitstream,1,1);
- n++;
- }
- FDKwriteBits(hBitstream,0,1);
- FDKwriteBits(hBitstream,t0-(1<<(n+4)),n+4);
- }
- if(t1 >=16){
- INT n,p;
- n=0;
- p=t1;
- while((p>>=1) >=16){
- FDKwriteBits(hBitstream,1,1);
- n++;
- }
- FDKwriteBits(hBitstream,0,1);
- FDKwriteBits(hBitstream,t1-(1<<(n+4)),n+4);
- }
- }
- break;
-
- default:
- break;
- }
- return(0);
-}
-
-INT FDKaacEnc_codeScalefactorDelta(INT delta, HANDLE_FDK_BITSTREAM hBitstream)
-{
- INT codeWord,codeLength;
-
- if(fixp_abs(delta) >CODE_BOOK_SCF_LAV)
- return(1);
-
- codeWord = FDKaacEnc_huff_ctabscf[delta+CODE_BOOK_SCF_LAV];
- codeLength = (INT)FDKaacEnc_huff_ltabscf[delta+CODE_BOOK_SCF_LAV];
- FDKwriteBits(hBitstream,codeWord,codeLength);
- return(0);
-}
-
-
-
diff --git a/libAACenc/src/bit_cnt.h b/libAACenc/src/bit_cnt.h
deleted file mode 100644
index 7c4b59e..0000000
--- a/libAACenc/src/bit_cnt.h
+++ /dev/null
@@ -1,187 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M.Werner
- contents/description: Huffman Bitcounter & coder
-
-******************************************************************************/
-
-#ifndef __BITCOUNT_H
-#define __BITCOUNT_H
-
-
-#include "common_fix.h"
-#include "FDK_bitstream.h"
-#include "aacEnc_rom.h"
-
-#define INVALID_BITCOUNT (FDK_INT_MAX/4)
-
-/*
- code book number table
-*/
-
-enum codeBookNo{
- CODE_BOOK_ZERO_NO= 0,
- CODE_BOOK_1_NO= 1,
- CODE_BOOK_2_NO= 2,
- CODE_BOOK_3_NO= 3,
- CODE_BOOK_4_NO= 4,
- CODE_BOOK_5_NO= 5,
- CODE_BOOK_6_NO= 6,
- CODE_BOOK_7_NO= 7,
- CODE_BOOK_8_NO= 8,
- CODE_BOOK_9_NO= 9,
- CODE_BOOK_10_NO= 10,
- CODE_BOOK_ESC_NO= 11,
- CODE_BOOK_RES_NO= 12,
- CODE_BOOK_PNS_NO= 13,
- CODE_BOOK_IS_OUT_OF_PHASE_NO= 14,
- CODE_BOOK_IS_IN_PHASE_NO= 15
-
-};
-
-/*
- code book index table
-*/
-
-enum codeBookNdx{
- CODE_BOOK_ZERO_NDX,
- CODE_BOOK_1_NDX,
- CODE_BOOK_2_NDX,
- CODE_BOOK_3_NDX,
- CODE_BOOK_4_NDX,
- CODE_BOOK_5_NDX,
- CODE_BOOK_6_NDX,
- CODE_BOOK_7_NDX,
- CODE_BOOK_8_NDX,
- CODE_BOOK_9_NDX,
- CODE_BOOK_10_NDX,
- CODE_BOOK_ESC_NDX,
- CODE_BOOK_RES_NDX,
- CODE_BOOK_PNS_NDX,
- CODE_BOOK_IS_OUT_OF_PHASE_NDX,
- CODE_BOOK_IS_IN_PHASE_NDX,
- NUMBER_OF_CODE_BOOKS
-};
-
-/*
- code book lav table
-*/
-
-enum codeBookLav{
- CODE_BOOK_ZERO_LAV=0,
- CODE_BOOK_1_LAV=1,
- CODE_BOOK_2_LAV=1,
- CODE_BOOK_3_LAV=2,
- CODE_BOOK_4_LAV=2,
- CODE_BOOK_5_LAV=4,
- CODE_BOOK_6_LAV=4,
- CODE_BOOK_7_LAV=7,
- CODE_BOOK_8_LAV=7,
- CODE_BOOK_9_LAV=12,
- CODE_BOOK_10_LAV=12,
- CODE_BOOK_ESC_LAV=16,
- CODE_BOOK_SCF_LAV=60,
- CODE_BOOK_PNS_LAV=60
- };
-
-INT FDKaacEnc_bitCount(const SHORT *aQuantSpectrum,
- const INT noOfSpecLines,
- INT maxVal,
- INT *bitCountLut);
-
-INT FDKaacEnc_countValues(SHORT *values, INT width, INT codeBook);
-
-INT FDKaacEnc_codeValues(SHORT *values, INT width, INT codeBook, HANDLE_FDK_BITSTREAM hBitstream);
-
-INT FDKaacEnc_codeScalefactorDelta(INT scalefactor, HANDLE_FDK_BITSTREAM hBitstream);
-
-inline INT FDKaacEnc_bitCountScalefactorDelta(const INT delta)
-{
- FDK_ASSERT( (0 <= (delta+CODE_BOOK_SCF_LAV)) && ((delta+CODE_BOOK_SCF_LAV)<(int)(sizeof(FDKaacEnc_huff_ltabscf)/sizeof((FDKaacEnc_huff_ltabscf[0])))) );
- return((INT)FDKaacEnc_huff_ltabscf[delta+CODE_BOOK_SCF_LAV]);
-}
-
-#endif
diff --git a/libAACenc/src/bitenc.cpp b/libAACenc/src/bitenc.cpp
deleted file mode 100644
index 4552457..0000000
--- a/libAACenc/src/bitenc.cpp
+++ /dev/null
@@ -1,1508 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
- /******************************** MPEG Audio Encoder **************************
-
- Initial author: M. Werner
- contents/description: Bitstream encoder
-
-******************************************************************************/
-#include <stdio.h>
-#include "bitenc.h"
-#include "bit_cnt.h"
-#include "dyn_bits.h"
-#include "qc_data.h"
-#include "interface.h"
-#include "aacEnc_ram.h"
-
-
-#include "tpenc_lib.h"
-
-#include "FDK_tools_rom.h" /* needed for the bitstream syntax tables */
-
-static const int globalGainOffset = 100;
-static const int icsReservedBit = 0;
-static const int noiseOffset = 90;
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_encodeSpectralData
- description: encode spectral data
- returns: the number of written bits
- input:
- output:
-
-*****************************************************************************/
-static INT FDKaacEnc_encodeSpectralData(INT *sfbOffset,
- SECTION_DATA *sectionData,
- SHORT *quantSpectrum,
- HANDLE_FDK_BITSTREAM hBitStream)
-{
- INT i,sfb;
- INT dbgVal = FDKgetValidBits(hBitStream);
-
- for(i=0;i<sectionData->noOfSections;i++)
- {
- if(sectionData->huffsection[i].codeBook != CODE_BOOK_PNS_NO)
- {
- /* huffencode spectral data for this huffsection */
- INT tmp = sectionData->huffsection[i].sfbStart+sectionData->huffsection[i].sfbCnt;
- for(sfb=sectionData->huffsection[i].sfbStart; sfb<tmp; sfb++)
- {
- FDKaacEnc_codeValues(quantSpectrum+sfbOffset[sfb],
- sfbOffset[sfb+1]-sfbOffset[sfb],
- sectionData->huffsection[i].codeBook,
- hBitStream);
- }
- }
- }
- return(FDKgetValidBits(hBitStream)-dbgVal);
-}
-
-/*****************************************************************************
-
- functionname:FDKaacEnc_encodeGlobalGain
- description: encodes Global Gain (common scale factor)
- returns: the number of static bits
- input:
- output:
-
-*****************************************************************************/
-static INT FDKaacEnc_encodeGlobalGain(INT globalGain,
- INT scalefac,
- HANDLE_FDK_BITSTREAM hBitStream,
- INT mdctScale)
-{
- if (hBitStream != NULL) {
- FDKwriteBits(hBitStream,globalGain - scalefac + globalGainOffset-4*(LOG_NORM_PCM-mdctScale),8);
- }
- return (8);
-}
-
-
-/*****************************************************************************
-
- functionname:FDKaacEnc_encodeIcsInfo
- description: encodes Ics Info
- returns: the number of static bits
- input:
- output:
-
-*****************************************************************************/
-
-static INT FDKaacEnc_encodeIcsInfo(INT blockType,
- INT windowShape,
- INT groupingMask,
- INT maxSfbPerGroup,
- HANDLE_FDK_BITSTREAM hBitStream,
- UINT syntaxFlags)
-{
- INT statBits;
-
- if (blockType == SHORT_WINDOW) {
- statBits = 8 + TRANS_FAC - 1;
- } else {
- if (syntaxFlags & AC_ELD) {
- statBits = 6;
- } else
- {
- statBits = (!(syntaxFlags & AC_SCALABLE)) ? 11 : 10;
- }
- }
-
- if (hBitStream != NULL) {
-
- if (!(syntaxFlags & AC_ELD)){
- FDKwriteBits(hBitStream,icsReservedBit,1);
- FDKwriteBits(hBitStream,blockType,2);
- FDKwriteBits(hBitStream, (windowShape == LOL_WINDOW) ? KBD_WINDOW : windowShape,1);
- }
-
- switch(blockType){
- case LONG_WINDOW:
- case START_WINDOW:
- case STOP_WINDOW:
- FDKwriteBits(hBitStream,maxSfbPerGroup,6);
-
- if (!(syntaxFlags & (AC_SCALABLE|AC_ELD)) ) { /* If not scalable syntax then ... */
- /* No predictor data present */
- FDKwriteBits(hBitStream, 0, 1);
- }
- break;
-
- case SHORT_WINDOW:
- FDKwriteBits(hBitStream,maxSfbPerGroup,4);
-
- /* Write grouping bits */
- FDKwriteBits(hBitStream,groupingMask,TRANS_FAC-1);
- break;
- }
- }
-
- return (statBits);
-}
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_encodeSectionData
- description: encode section data (common Huffman codebooks for adjacent
- SFB's)
- returns: none
- input:
- output:
-
-*****************************************************************************/
-static INT FDKaacEnc_encodeSectionData(SECTION_DATA *sectionData,
- HANDLE_FDK_BITSTREAM hBitStream,
- UINT useVCB11)
-{
- if (hBitStream != NULL) {
- INT sectEscapeVal=0,sectLenBits=0;
- INT sectLen;
- INT i;
- INT dbgVal=FDKgetValidBits(hBitStream);
- INT sectCbBits = 4;
-
- switch(sectionData->blockType)
- {
- case LONG_WINDOW:
- case START_WINDOW:
- case STOP_WINDOW:
- sectEscapeVal = SECT_ESC_VAL_LONG;
- sectLenBits = SECT_BITS_LONG;
- break;
-
- case SHORT_WINDOW:
- sectEscapeVal = SECT_ESC_VAL_SHORT;
- sectLenBits = SECT_BITS_SHORT;
- break;
- }
-
- for(i=0;i<sectionData->noOfSections;i++)
- {
- INT codeBook = sectionData->huffsection[i].codeBook;
-
- FDKwriteBits(hBitStream,codeBook,sectCbBits);
-
- {
- sectLen = sectionData->huffsection[i].sfbCnt;
-
- while(sectLen >= sectEscapeVal)
- {
- FDKwriteBits(hBitStream,sectEscapeVal,sectLenBits);
- sectLen-=sectEscapeVal;
- }
- FDKwriteBits(hBitStream,sectLen,sectLenBits);
- }
- }
- return(FDKgetValidBits(hBitStream)-dbgVal);
- }
- return (0);
-}
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_encodeScaleFactorData
- description: encode DPCM coded scale factors
- returns: none
- input:
- output:
-
-*****************************************************************************/
-static INT FDKaacEnc_encodeScaleFactorData(UINT *maxValueInSfb,
- SECTION_DATA *sectionData,
- INT *scalefac,
- HANDLE_FDK_BITSTREAM hBitStream,
- INT *RESTRICT noiseNrg,
- const INT *isScale,
- INT globalGain)
-{
- if (hBitStream != NULL) {
- INT i,j,lastValScf,deltaScf;
- INT deltaPns;
- INT lastValPns = 0;
- INT noisePCMFlag = TRUE;
- INT lastValIs;
-
- INT dbgVal = FDKgetValidBits(hBitStream);
-
- lastValScf=scalefac[sectionData->firstScf];
- lastValPns = globalGain-scalefac[sectionData->firstScf]+globalGainOffset-4*LOG_NORM_PCM-noiseOffset;
- lastValIs = 0;
-
- for(i=0; i<sectionData->noOfSections; i++){
- if (sectionData->huffsection[i].codeBook != CODE_BOOK_ZERO_NO) {
-
- if ((sectionData->huffsection[i].codeBook == CODE_BOOK_IS_OUT_OF_PHASE_NO) ||
- (sectionData->huffsection[i].codeBook == CODE_BOOK_IS_IN_PHASE_NO))
- {
- INT sfbStart = sectionData->huffsection[i].sfbStart;
- INT tmp = sfbStart + sectionData->huffsection[i].sfbCnt;
- for(j=sfbStart; j<tmp; j++) {
- INT deltaIs = isScale[j]-lastValIs;
- lastValIs = isScale[j];
- if(FDKaacEnc_codeScalefactorDelta(deltaIs,hBitStream)) {
- return(1);
- }
- } /* sfb */
- }
- else if(sectionData->huffsection[i].codeBook == CODE_BOOK_PNS_NO) {
- INT sfbStart = sectionData->huffsection[i].sfbStart;
- INT tmp = sfbStart + sectionData->huffsection[i].sfbCnt;
- for(j=sfbStart; j<tmp; j++) {
- deltaPns = noiseNrg[j]-lastValPns;
- lastValPns = noiseNrg[j];
-
- if(noisePCMFlag){
- FDKwriteBits(hBitStream,deltaPns+(1<<(PNS_PCM_BITS-1)),PNS_PCM_BITS);
- noisePCMFlag = FALSE;
- }
- else {
- if(FDKaacEnc_codeScalefactorDelta(deltaPns,hBitStream)) {
- return(1);
- }
- }
- } /* sfb */
- }
- else {
- INT tmp = sectionData->huffsection[i].sfbStart+sectionData->huffsection[i].sfbCnt;
- for(j=sectionData->huffsection[i].sfbStart; j<tmp; j++){
- /*
- check if we can repeat the last value to save bits
- */
- if(maxValueInSfb[j] == 0)
- deltaScf = 0;
- else{
- deltaScf = -(scalefac[j]-lastValScf);
- lastValScf = scalefac[j];
- }
- if(FDKaacEnc_codeScalefactorDelta(deltaScf,hBitStream)){
- return(1);
- }
- } /* sfb */
- } /* code scalefactor */
- } /* sectionData->huffsection[i].codeBook != CODE_BOOK_ZERO_NO */
- } /* section loop */
-
- return(FDKgetValidBits(hBitStream)-dbgVal);
- } /* if (hBitStream != NULL) */
-
- return (0);
-}
-
-/*****************************************************************************
-
- functionname:encodeMsInfo
- description: encodes MS-Stereo Info
- returns: the number of static bits
- input:
- output:
-
-*****************************************************************************/
-static INT FDKaacEnc_encodeMSInfo(INT sfbCnt,
- INT grpSfb,
- INT maxSfb,
- INT msDigest,
- INT *jsFlags,
- HANDLE_FDK_BITSTREAM hBitStream)
-{
- INT sfb, sfbOff, msBits = 0;
-
- if (hBitStream != NULL)
- {
- switch(msDigest)
- {
- case MS_NONE:
- FDKwriteBits(hBitStream,SI_MS_MASK_NONE,2);
- msBits += 2;
- break;
-
- case MS_ALL:
- FDKwriteBits(hBitStream,SI_MS_MASK_ALL,2);
- msBits += 2;
- break;
-
- case MS_SOME:
- FDKwriteBits(hBitStream,SI_MS_MASK_SOME,2);
- msBits += 2;
- for(sfbOff = 0; sfbOff < sfbCnt; sfbOff+=grpSfb)
- {
- for(sfb=0; sfb<maxSfb; sfb++)
- {
- if(jsFlags[sfbOff+sfb] & MS_ON){
- FDKwriteBits(hBitStream,1,1);
- }
- else{
- FDKwriteBits(hBitStream,0,1);
- }
- msBits += 1;
- }
- }
- break;
- }
- }
- else {
- msBits += 2;
- if (msDigest == MS_SOME) {
- for(sfbOff = 0; sfbOff < sfbCnt; sfbOff+=grpSfb) {
- for(sfb=0; sfb<maxSfb; sfb++) {
- msBits += 1;
- }
- }
- }
- }
- return (msBits);
-}
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_encodeTnsDataPresent
- description: encode TNS data (filter order, coeffs, ..)
- returns: the number of static bits
- input:
- output:
-
-*****************************************************************************/
-static INT FDKaacEnc_encodeTnsDataPresent(TNS_INFO *tnsInfo,
- INT blockType,
- HANDLE_FDK_BITSTREAM hBitStream)
-{
- if ( (hBitStream!=NULL) && (tnsInfo!=NULL) )
- {
- INT i, tnsPresent = 0;
- INT numOfWindows = (blockType==SHORT_WINDOW?TRANS_FAC:1);
-
- for (i=0; i<numOfWindows; i++) {
- if (tnsInfo->numOfFilters[i]!=0) {
- tnsPresent=1;
- break;
- }
- }
-
- if (tnsPresent==0) {
- FDKwriteBits(hBitStream,0,1);
- } else {
- FDKwriteBits(hBitStream,1,1);
- }
- }
- return (1);
-}
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_encodeTnsData
- description: encode TNS data (filter order, coeffs, ..)
- returns: the number of static bits
- input:
- output:
-
-*****************************************************************************/
-static INT FDKaacEnc_encodeTnsData(TNS_INFO *tnsInfo,
- INT blockType,
- HANDLE_FDK_BITSTREAM hBitStream)
-{
- INT tnsBits = 0;
-
- if (tnsInfo!=NULL) {
-
- INT i,j,k;
- INT tnsPresent = 0;
- INT coefBits;
- INT numOfWindows=(blockType==SHORT_WINDOW?TRANS_FAC:1);
-
- for (i=0; i<numOfWindows; i++) {
- if (tnsInfo->numOfFilters[i]!=0) {
- tnsPresent=1;
- }
- }
-
- if (hBitStream != NULL)
- {
- if (tnsPresent==1) { /* there is data to be written*/
- for (i=0; i<numOfWindows; i++) {
- FDKwriteBits(hBitStream,tnsInfo->numOfFilters[i],(blockType==SHORT_WINDOW?1:2));
- tnsBits += (blockType==SHORT_WINDOW?1:2);
- if (tnsInfo->numOfFilters[i]) {
- FDKwriteBits(hBitStream,(tnsInfo->coefRes[i]==4?1:0),1);
- tnsBits += 1;
- }
- for (j=0; j<tnsInfo->numOfFilters[i]; j++) {
- FDKwriteBits(hBitStream,tnsInfo->length[i][j],(blockType==SHORT_WINDOW?4:6));
- tnsBits += (blockType==SHORT_WINDOW?4:6);
- FDK_ASSERT(tnsInfo->order[i][j] <= 12);
- FDKwriteBits(hBitStream,tnsInfo->order[i][j],(blockType==SHORT_WINDOW?3:5));
- tnsBits += (blockType==SHORT_WINDOW?3:5);
- if (tnsInfo->order[i][j]){
- FDKwriteBits(hBitStream,tnsInfo->direction[i][j],1);
- tnsBits +=1; /*direction*/
- if(tnsInfo->coefRes[i] == 4) {
- coefBits = 3;
- for(k=0; k<tnsInfo->order[i][j]; k++) {
- if (tnsInfo->coef[i][j][k]> 3 ||
- tnsInfo->coef[i][j][k]< -4) {
- coefBits = 4;
- break;
- }
- }
- } else {
- coefBits = 2;
- for(k=0; k<tnsInfo->order[i][j]; k++) {
- if ( tnsInfo->coef[i][j][k]> 1
- || tnsInfo->coef[i][j][k]< -2) {
- coefBits = 3;
- break;
- }
- }
- }
- FDKwriteBits(hBitStream,-(coefBits - tnsInfo->coefRes[i]),1); /*coef_compres*/
- tnsBits +=1; /*coef_compression */
- for (k=0; k<tnsInfo->order[i][j]; k++ ) {
- static const INT rmask[] = {0,1,3,7,15};
- FDKwriteBits(hBitStream,tnsInfo->coef[i][j][k] & rmask[coefBits],coefBits);
- tnsBits += coefBits;
- }
- }
- }
- }
- }
- }
- else {
- if (tnsPresent != 0) {
- for (i=0; i<numOfWindows; i++) {
- tnsBits += (blockType==SHORT_WINDOW?1:2);
- if (tnsInfo->numOfFilters[i]) {
- tnsBits += 1;
- for (j=0; j<tnsInfo->numOfFilters[i]; j++) {
- tnsBits += (blockType==SHORT_WINDOW?4:6);
- tnsBits += (blockType==SHORT_WINDOW?3:5);
- if (tnsInfo->order[i][j]) {
- tnsBits +=1; /*direction*/
- tnsBits +=1; /*coef_compression */
- if (tnsInfo->coefRes[i] == 4) {
- coefBits=3;
- for (k=0; k<tnsInfo->order[i][j]; k++) {
- if (tnsInfo->coef[i][j][k]> 3 || tnsInfo->coef[i][j][k]< -4) {
- coefBits = 4;
- break;
- }
- }
- }
- else {
- coefBits = 2;
- for (k=0; k<tnsInfo->order[i][j]; k++) {
- if (tnsInfo->coef[i][j][k]> 1 || tnsInfo->coef[i][j][k]< -2) {
- coefBits = 3;
- break;
- }
- }
- }
- for (k=0; k<tnsInfo->order[i][j]; k++) {
- tnsBits += coefBits;
- }
- }
- }
- }
- }
- }
- }
- } /* (tnsInfo!=NULL) */
-
- return (tnsBits);
-}
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_encodeGainControlData
- description: unsupported
- returns: none
- input:
- output:
-
-*****************************************************************************/
-static INT FDKaacEnc_encodeGainControlData(HANDLE_FDK_BITSTREAM hBitStream)
-{
- if (hBitStream != NULL) {
- FDKwriteBits(hBitStream,0,1);
- }
- return (1);
-}
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_encodePulseData
- description: not supported yet (dummy)
- returns: none
- input:
- output:
-
-*****************************************************************************/
-static INT FDKaacEnc_encodePulseData(HANDLE_FDK_BITSTREAM hBitStream)
-{
- if (hBitStream != NULL) {
- FDKwriteBits(hBitStream,0,1);
- }
- return (1);
-}
-
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_writeExtensionPayload
- description: write extension payload to bitstream
- returns: number of written bits
- input:
- output:
-
-*****************************************************************************/
-static INT FDKaacEnc_writeExtensionPayload( HANDLE_FDK_BITSTREAM hBitStream,
- EXT_PAYLOAD_TYPE extPayloadType,
- const UCHAR *extPayloadData,
- INT extPayloadBits
- )
-{
- #define EXT_TYPE_BITS ( 4 )
- #define DATA_EL_VERSION_BITS ( 4 )
- #define FILL_NIBBLE_BITS ( 4 )
-
- INT extBitsUsed = 0;
- //fprintf(stderr, "FDKaacEnc_writeExtensionPayload() extPayloadType=%d\n", extPayloadType);
- if (extPayloadBits >= EXT_TYPE_BITS)
- {
- UCHAR fillByte = 0x00; /* for EXT_FIL and EXT_FILL_DATA */
-
- if (hBitStream != NULL) {
- FDKwriteBits(hBitStream, extPayloadType, EXT_TYPE_BITS);
- }
- extBitsUsed += EXT_TYPE_BITS;
-
- switch (extPayloadType) {
- case EXT_DYNAMIC_RANGE:
- /* case EXT_SAC_DATA: */
- case EXT_SBR_DATA:
- case EXT_SBR_DATA_CRC:
- if (hBitStream != NULL) {
- int i, writeBits = extPayloadBits;
- for (i=0; writeBits >= 8; i++) {
- FDKwriteBits(hBitStream, extPayloadData[i], 8);
- writeBits -= 8;
- }
- if (writeBits > 0) {
- FDKwriteBits(hBitStream, extPayloadData[i]>>(8-writeBits), writeBits);
- }
- }
- extBitsUsed += extPayloadBits;
- break;
-
- case EXT_DATA_ELEMENT:
- {
- INT dataElementLength = (extPayloadBits+7)>>3;
- INT cnt = dataElementLength;
- int loopCounter = 1;
-
- while (dataElementLength >= 255) {
- loopCounter++;
- dataElementLength -= 255;
- }
-
- if (hBitStream != NULL) {
- int i;
- FDKwriteBits(hBitStream, 0x00, DATA_EL_VERSION_BITS); /* data_element_version = ANC_DATA */
-
- for (i=1; i<loopCounter; i++) {
- FDKwriteBits(hBitStream, 255, 8);
- }
- FDKwriteBits(hBitStream, dataElementLength, 8);
-
- for (i=0; i<cnt; i++) {
- FDKwriteBits(hBitStream, extPayloadData[i], 8);
- }
- }
- extBitsUsed += DATA_EL_VERSION_BITS + (loopCounter*8) + (cnt*8);
- }
- break;
-
- case EXT_FILL_DATA:
- fillByte = 0xA5;
- case EXT_FIL:
- default:
- if (hBitStream != NULL) {
- int writeBits = extPayloadBits;
- FDKwriteBits(hBitStream, 0x00, FILL_NIBBLE_BITS);
- writeBits -= 8; /* acount for the extension type and the fill nibble */
- while (writeBits >= 8) {
- FDKwriteBits(hBitStream, fillByte, 8);
- writeBits -= 8;
- }
- }
- extBitsUsed += FILL_NIBBLE_BITS + (extPayloadBits & ~0x7) - 8;
- break;
- }
- }
-
- return (extBitsUsed);
-}
-
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_writeDataStreamElement
- description: write data stream elements like ancillary data ...
- returns: the amount of used bits
- input:
- output:
-
-******************************************************************************/
-static INT FDKaacEnc_writeDataStreamElement( HANDLE_TRANSPORTENC hTpEnc,
- INT elementInstanceTag,
- INT dataPayloadBytes,
- UCHAR *dataBuffer,
- UINT alignAnchor )
-{
- #define DATA_BYTE_ALIGN_FLAG ( 0 )
-
- #define EL_INSTANCE_TAG_BITS ( 4 )
- #define DATA_BYTE_ALIGN_FLAG_BITS ( 1 )
- #define DATA_LEN_COUNT_BITS ( 8 )
- #define DATA_LEN_ESC_COUNT_BITS ( 8 )
-
- #define MAX_DATA_ALIGN_BITS ( 7 )
- #define MAX_DSE_DATA_BYTES ( 510 )
-
- INT dseBitsUsed = 0;
- //fprintf(stderr, "FDKaacEnc_writeDataStreamElement() dataPayloadBytes=%d\n", dataPayloadBytes);
- while (dataPayloadBytes > 0)
- {
- int esc_count = -1;
- int cnt = 0;
- INT crcReg = -1;
-
- dseBitsUsed += EL_ID_BITS + EL_INSTANCE_TAG_BITS
- + DATA_BYTE_ALIGN_FLAG_BITS + DATA_LEN_COUNT_BITS;
-
- if (DATA_BYTE_ALIGN_FLAG) {
- dseBitsUsed += MAX_DATA_ALIGN_BITS;
- }
-
- cnt = fixMin(MAX_DSE_DATA_BYTES, dataPayloadBytes);
- if ( cnt >= 255 ) {
- esc_count = cnt - 255;
- dseBitsUsed += DATA_LEN_ESC_COUNT_BITS;
- }
-
- dataPayloadBytes -= cnt;
- dseBitsUsed += cnt * 8;
-
- if (hTpEnc != NULL) {
- HANDLE_FDK_BITSTREAM hBitStream = transportEnc_GetBitstream(hTpEnc);
- int i;
-
- FDKwriteBits(hBitStream, ID_DSE, EL_ID_BITS);
-
- crcReg = transportEnc_CrcStartReg(hTpEnc, 0);
-
- FDKwriteBits(hBitStream, elementInstanceTag, EL_INSTANCE_TAG_BITS);
- FDKwriteBits(hBitStream, DATA_BYTE_ALIGN_FLAG, DATA_BYTE_ALIGN_FLAG_BITS);
-
- /* write length field(s) */
- if ( esc_count >= 0 ) {
- FDKwriteBits(hBitStream, 255, DATA_LEN_COUNT_BITS);
- FDKwriteBits(hBitStream, esc_count, DATA_LEN_ESC_COUNT_BITS);
- } else {
- FDKwriteBits(hBitStream, cnt, DATA_LEN_COUNT_BITS);
- }
-
- if (DATA_BYTE_ALIGN_FLAG) {
- INT tmp = (INT)FDKgetValidBits(hBitStream);
- FDKbyteAlign(hBitStream, alignAnchor);
- /* count actual bits */
- dseBitsUsed += (INT)FDKgetValidBits(hBitStream) - tmp - MAX_DATA_ALIGN_BITS;
- }
-
- /* write payload */
- for (i=0; i<cnt; i++) {
- FDKwriteBits(hBitStream, dataBuffer[i], 8);
- }
- transportEnc_CrcEndReg(hTpEnc, crcReg);
- }
- }
-
- return (dseBitsUsed);
-}
-
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_writeExtensionData
- description: write extension payload to bitstream
- returns: number of written bits
- input:
- output:
-
-*****************************************************************************/
-INT FDKaacEnc_writeExtensionData( HANDLE_TRANSPORTENC hTpEnc,
- QC_OUT_EXTENSION *pExtension,
- INT elInstanceTag, /* for DSE only */
- UINT alignAnchor, /* for DSE only */
- UINT syntaxFlags,
- AUDIO_OBJECT_TYPE aot,
- SCHAR epConfig
- )
-{
- #define FILL_EL_COUNT_BITS ( 4 )
- #define FILL_EL_ESC_COUNT_BITS ( 8 )
- #define MAX_FILL_DATA_BYTES ( 269 )
-
- HANDLE_FDK_BITSTREAM hBitStream = NULL;
- INT payloadBits = pExtension->nPayloadBits;
- INT extBitsUsed = 0;
-
- if (hTpEnc != NULL) {
- hBitStream = transportEnc_GetBitstream(hTpEnc);
- }
-
- //fprintf(stderr, "FDKaacEnc_writeExtensionData() pExtension->type=%d\n", pExtension->type);
- if (syntaxFlags & (AC_SCALABLE|AC_ER))
- {
- if ( syntaxFlags & AC_DRM )
- { /* CAUTION: The caller has to assure that fill
- data is written before the SBR payload. */
- UCHAR *extPayloadData = pExtension->pPayload;
-
- switch (pExtension->type)
- {
- case EXT_SBR_DATA:
- case EXT_SBR_DATA_CRC:
- /* SBR payload is written in reverse */
- if (hBitStream != NULL) {
- int i, writeBits = payloadBits;
-
- FDKpushFor(hBitStream, payloadBits-1); /* Does a cache sync internally */
-
- for (i=0; writeBits >= 8; i++) {
- FDKwriteBitsBwd(hBitStream, extPayloadData[i], 8);
- writeBits -= 8;
- }
- if (writeBits > 0) {
- FDKwriteBitsBwd(hBitStream, extPayloadData[i]>>(8-writeBits), writeBits);
- }
-
- FDKsyncCacheBwd (hBitStream);
- FDKpushFor (hBitStream, payloadBits+1);
- }
- extBitsUsed += payloadBits;
- break;
-
- case EXT_FILL_DATA:
- case EXT_FIL:
- default:
- if (hBitStream != NULL) {
- int writeBits = payloadBits;
- while (writeBits >= 8) {
- FDKwriteBits(hBitStream, 0x00, 8);
- writeBits -= 8;
- }
- FDKwriteBits(hBitStream, 0x00, writeBits);
- }
- extBitsUsed += payloadBits;
- break;
- }
- }
- else {
- if ( (syntaxFlags & AC_ELD) && ((pExtension->type==EXT_SBR_DATA) || (pExtension->type==EXT_SBR_DATA_CRC)) ) {
-
- if (hBitStream != NULL) {
- int i, writeBits = payloadBits;
- UCHAR *extPayloadData = pExtension->pPayload;
-
- for (i=0; writeBits >= 8; i++) {
- FDKwriteBits(hBitStream, extPayloadData[i], 8);
- writeBits -= 8;
- }
- if (writeBits > 0) {
- FDKwriteBits(hBitStream, extPayloadData[i]>>(8-writeBits), writeBits);
- }
- }
- extBitsUsed += payloadBits;
- }
- else
- {
- /* ER or scalable syntax -> write extension en bloc */
- extBitsUsed += FDKaacEnc_writeExtensionPayload( hBitStream,
- pExtension->type,
- pExtension->pPayload,
- payloadBits );
- }
- }
- }
- else {
- /* We have normal GA bitstream payload (AOT 2,5,29) so pack
- the data into a fill elements or DSEs */
-
- if ( pExtension->type == EXT_DATA_ELEMENT )
- {
- extBitsUsed += FDKaacEnc_writeDataStreamElement( hTpEnc,
- elInstanceTag,
- pExtension->nPayloadBits>>3,
- pExtension->pPayload,
- alignAnchor );
- }
- else {
- while (payloadBits >= (EL_ID_BITS + FILL_EL_COUNT_BITS)) {
- INT cnt, esc_count=-1, alignBits=7;
-
- if ( (pExtension->type == EXT_FILL_DATA) || (pExtension->type == EXT_FIL) )
- {
- payloadBits -= EL_ID_BITS + FILL_EL_COUNT_BITS;
- if (payloadBits >= 15*8) {
- payloadBits -= FILL_EL_ESC_COUNT_BITS;
- esc_count = 0; /* write esc_count even if cnt becomes smaller 15 */
- }
- alignBits = 0;
- }
-
- cnt = fixMin(MAX_FILL_DATA_BYTES, (payloadBits+alignBits)>>3);
-
- if (cnt >= 15) {
- esc_count = cnt - 15 + 1;
- }
-
- if (hBitStream != NULL) {
- /* write bitstream */
- FDKwriteBits(hBitStream, ID_FIL, EL_ID_BITS);
- if (esc_count >= 0) {
- FDKwriteBits(hBitStream, 15, FILL_EL_COUNT_BITS);
- FDKwriteBits(hBitStream, esc_count, FILL_EL_ESC_COUNT_BITS);
- } else {
- FDKwriteBits(hBitStream, cnt, FILL_EL_COUNT_BITS);
- }
- }
-
- extBitsUsed += EL_ID_BITS + FILL_EL_COUNT_BITS + ((esc_count>=0) ? FILL_EL_ESC_COUNT_BITS : 0);
-
- cnt = fixMin(cnt*8, payloadBits); /* convert back to bits */
- extBitsUsed += FDKaacEnc_writeExtensionPayload( hBitStream,
- pExtension->type,
- pExtension->pPayload,
- cnt );
- payloadBits -= cnt;
- }
- }
- }
-
- return (extBitsUsed);
-}
-
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_ByteAlignment
- description:
- returns:
- input:
- output:
-
-*****************************************************************************/
-static void FDKaacEnc_ByteAlignment(HANDLE_FDK_BITSTREAM hBitStream, int alignBits)
-{
- FDKwriteBits(hBitStream, 0, alignBits);
-}
-
-AAC_ENCODER_ERROR FDKaacEnc_ChannelElementWrite( HANDLE_TRANSPORTENC hTpEnc,
- ELEMENT_INFO *pElInfo,
- QC_OUT_CHANNEL *qcOutChannel[(2)],
- PSY_OUT_ELEMENT *psyOutElement,
- PSY_OUT_CHANNEL *psyOutChannel[(2)],
- UINT syntaxFlags,
- AUDIO_OBJECT_TYPE aot,
- SCHAR epConfig,
- INT *pBitDemand,
- UCHAR minCnt
- )
-{
- AAC_ENCODER_ERROR error = AAC_ENC_OK;
- HANDLE_FDK_BITSTREAM hBitStream = NULL;
- INT bitDemand = 0;
- const element_list_t *list;
- int i, ch, decision_bit;
- INT crcReg1 = -1, crcReg2 = -1;
- UCHAR numberOfChannels;
-
- if (hTpEnc != NULL) {
- /* Get bitstream handle */
- hBitStream = transportEnc_GetBitstream(hTpEnc);
- }
-
- if ( (pElInfo->elType==ID_SCE) || (pElInfo->elType==ID_LFE) ) {
- numberOfChannels = 1;
- } else {
- numberOfChannels = 2;
- }
-
- /* Get channel element sequence table */
- list = getBitstreamElementList(aot, epConfig, numberOfChannels, 0);
- if (list == NULL) {
- error = AAC_ENC_UNSUPPORTED_AOT;
- goto bail;
- }
-
- if (!(syntaxFlags & (AC_SCALABLE|AC_ER))) {
- if (hBitStream != NULL) {
- FDKwriteBits(hBitStream, pElInfo->elType, EL_ID_BITS);
- }
- bitDemand += EL_ID_BITS;
- }
-
- /* Iterate through sequence table */
- i = 0;
- ch = 0;
- decision_bit = 0;
- do {
- /* some tmp values */
- SECTION_DATA *pChSectionData = NULL;
- INT *pChScf = NULL;
- UINT *pChMaxValueInSfb = NULL;
- TNS_INFO *pTnsInfo = NULL;
- INT chGlobalGain = 0;
- INT chBlockType = 0;
- INT chMaxSfbPerGrp = 0;
- INT chSfbPerGrp = 0;
- INT chSfbCnt = 0;
- INT chFirstScf = 0;
-
- if (minCnt==0) {
- if ( qcOutChannel!=NULL ) {
- pChSectionData = &(qcOutChannel[ch]->sectionData);
- pChScf = qcOutChannel[ch]->scf;
- chGlobalGain = qcOutChannel[ch]->globalGain;
- pChMaxValueInSfb = qcOutChannel[ch]->maxValueInSfb;
- chBlockType = pChSectionData->blockType;
- chMaxSfbPerGrp = pChSectionData->maxSfbPerGroup;
- chSfbPerGrp = pChSectionData->sfbPerGroup;
- chSfbCnt = pChSectionData->sfbCnt;
- chFirstScf = pChScf[pChSectionData->firstScf];
- }
- else {
- /* get values from PSY */
- chSfbCnt = psyOutChannel[ch]->sfbCnt;
- chSfbPerGrp = psyOutChannel[ch]->sfbPerGroup;
- chMaxSfbPerGrp = psyOutChannel[ch]->maxSfbPerGroup;
- }
- pTnsInfo = &psyOutChannel[ch]->tnsInfo;
- } /* minCnt==0 */
-
- if ( qcOutChannel==NULL ) {
- chBlockType = psyOutChannel[ch]->lastWindowSequence;
- }
-
- switch (list->id[i])
- {
- case element_instance_tag:
- /* Write element instance tag */
- if (hBitStream != NULL) {
- FDKwriteBits(hBitStream, pElInfo->instanceTag, 4);
- }
- bitDemand += 4;
- break;
-
- case common_window:
- /* Write common window flag */
- decision_bit = psyOutElement->commonWindow;
- if (hBitStream != NULL) {
- FDKwriteBits(hBitStream, psyOutElement->commonWindow, 1);
- }
- bitDemand += 1;
- break;
-
- case ics_info:
- /* Write individual channel info */
- bitDemand += FDKaacEnc_encodeIcsInfo( chBlockType,
- psyOutChannel[ch]->windowShape,
- psyOutChannel[ch]->groupingMask,
- chMaxSfbPerGrp,
- hBitStream,
- syntaxFlags);
- break;
-
- case ltp_data_present:
- /* Write LTP data present flag */
- if (hBitStream != NULL) {
- FDKwriteBits(hBitStream, 0, 1);
- }
- bitDemand += 1;
- break;
-
- case ltp_data:
- /* Predictor data not supported.
- Nothing to do here. */
- break;
-
- case ms:
- /* Write MS info */
- bitDemand += FDKaacEnc_encodeMSInfo( chSfbCnt,
- chSfbPerGrp,
- chMaxSfbPerGrp,
- (minCnt==0) ? psyOutElement->toolsInfo.msDigest : MS_NONE,
- psyOutElement->toolsInfo.msMask,
- hBitStream);
- break;
-
- case global_gain:
- bitDemand += FDKaacEnc_encodeGlobalGain( chGlobalGain,
- chFirstScf,
- hBitStream,
- psyOutChannel[ch]->mdctScale );
- break;
-
- case section_data:
- {
- INT siBits = FDKaacEnc_encodeSectionData(pChSectionData, hBitStream, (syntaxFlags & AC_ER_VCB11)?1:0);
- if (hBitStream != NULL) {
- if (siBits != qcOutChannel[ch]->sectionData.sideInfoBits) {
- error = AAC_ENC_WRITE_SEC_ERROR;
- }
- }
- bitDemand += siBits;
- }
- break;
-
- case scale_factor_data:
- {
- INT sfDataBits = FDKaacEnc_encodeScaleFactorData( pChMaxValueInSfb,
- pChSectionData,
- pChScf,
- hBitStream,
- psyOutChannel[ch]->noiseNrg,
- psyOutChannel[ch]->isScale,
- chGlobalGain );
- if ( (hBitStream != NULL)
- && (sfDataBits != (qcOutChannel[ch]->sectionData.scalefacBits + qcOutChannel[ch]->sectionData.noiseNrgBits)) ) {
- error = AAC_ENC_WRITE_SCAL_ERROR;
- }
- bitDemand += sfDataBits;
- }
- break;
-
- case esc2_rvlc:
- if (syntaxFlags & AC_ER_RVLC) {
- /* write RVLC data into bitstream (error sens. cat. 2) */
- error = AAC_ENC_UNSUPPORTED_AOT;
- }
- break;
-
- case pulse:
- /* Write pulse data */
- bitDemand += FDKaacEnc_encodePulseData(hBitStream);
- break;
-
- case tns_data_present:
- /* Write TNS data present flag */
- bitDemand += FDKaacEnc_encodeTnsDataPresent(pTnsInfo,
- chBlockType,
- hBitStream);
- break;
- case tns_data:
- /* Write TNS data */
- bitDemand += FDKaacEnc_encodeTnsData(pTnsInfo,
- chBlockType,
- hBitStream);
- break;
-
- case gain_control_data:
- /* Nothing to do here */
- break;
-
- case gain_control_data_present:
- bitDemand += FDKaacEnc_encodeGainControlData(hBitStream);
- break;
-
-
- case esc1_hcr:
- //TODO: DRM!
- if (syntaxFlags & AC_ER_HCR)
- {
- error = AAC_ENC_UNKNOWN;
- }
- break;
-
- case spectral_data:
- if (hBitStream != NULL)
- {
- INT spectralBits = 0;
-
- spectralBits = FDKaacEnc_encodeSpectralData( psyOutChannel[ch]->sfbOffsets,
- pChSectionData,
- qcOutChannel[ch]->quantSpec,
- hBitStream );
-
- if (spectralBits != qcOutChannel[ch]->sectionData.huffmanBits) {
- return AAC_ENC_WRITE_SPEC_ERROR;
- }
- bitDemand += spectralBits;
- }
- break;
-
- /* Non data cases */
- case adtscrc_start_reg1:
- if (hTpEnc != NULL) {
- crcReg1 = transportEnc_CrcStartReg(hTpEnc, 192);
- }
- break;
- case adtscrc_start_reg2:
- if (hTpEnc != NULL) {
- crcReg2 = transportEnc_CrcStartReg(hTpEnc, 128);
- }
- break;
- case adtscrc_end_reg1:
- case drmcrc_end_reg:
- if (hTpEnc != NULL) {
- transportEnc_CrcEndReg(hTpEnc, crcReg1);
- }
- break;
- case adtscrc_end_reg2:
- if (hTpEnc != NULL) {
- transportEnc_CrcEndReg(hTpEnc, crcReg2);
- }
- break;
- case drmcrc_start_reg:
- if (hTpEnc != NULL) {
- crcReg1 = transportEnc_CrcStartReg(hTpEnc, 0);
- }
- break;
- case next_channel:
- ch = (ch + 1) % numberOfChannels;
- break;
- case link_sequence:
- list = list->next[decision_bit];
- i=-1;
- break;
-
- default:
- error = AAC_ENC_UNKNOWN;
- break;
- }
-
- if (error != AAC_ENC_OK) {
- return error;
- }
-
- i++;
-
- } while (list->id[i] != end_of_sequence);
-
-bail:
- if (pBitDemand != NULL) {
- *pBitDemand = bitDemand;
- }
-
- return error;
-}
-
-
-//-----------------------------------------------------------------------------------------------
-
-AAC_ENCODER_ERROR FDKaacEnc_WriteBitstream(HANDLE_TRANSPORTENC hTpEnc,
- CHANNEL_MAPPING *channelMapping,
- QC_OUT *qcOut,
- PSY_OUT* psyOut,
- QC_STATE *qcKernel,
- AUDIO_OBJECT_TYPE aot,
- UINT syntaxFlags,
- SCHAR epConfig
- )
-{
- HANDLE_FDK_BITSTREAM hBs = transportEnc_GetBitstream(hTpEnc);
- AAC_ENCODER_ERROR ErrorStatus = AAC_ENC_OK;
- int i, n, doByteAlign = 1;
- INT bitMarkUp;
- INT frameBits;
- /* Get first bit of raw data block.
- In case of ADTS+PCE, AU would start at PCE.
- This is okay because PCE assures alignment. */
- UINT alignAnchor = FDKgetValidBits(hBs);
-
- frameBits = bitMarkUp = alignAnchor;
-
-
- /* Write DSEs first in case of DAB */
- for (n = 0; (n < qcOut->nExtensions) && (n < (2+2)); n++)
- {
- if ( (syntaxFlags & AC_DAB) &&
- (qcOut->extension[n].type == EXT_DATA_ELEMENT) ) {
- FDKaacEnc_writeExtensionData( hTpEnc,
- &qcOut->extension[n],
- 0,
- alignAnchor,
- syntaxFlags,
- aot,
- epConfig );
- }
-
- /* For EXT_FIL or EXT_FILL_DATA we could do an additional sanity check here */
- }
-
- /* Channel element loop */
- for (i=0; i<channelMapping->nElements; i++) {
-
- ELEMENT_INFO elInfo = channelMapping->elInfo[i];
- INT elementUsedBits = 0;
-
- switch (elInfo.elType)
- {
- case ID_SCE: /* single channel */
- case ID_CPE: /* channel pair */
- case ID_LFE: /* low freq effects channel */
- {
- if ( AAC_ENC_OK != (ErrorStatus = FDKaacEnc_ChannelElementWrite( hTpEnc,
- &elInfo,
- qcOut->qcElement[i]->qcOutChannel,
- psyOut->psyOutElement[i],
- psyOut->psyOutElement[i]->psyOutChannel,
- syntaxFlags, /* syntaxFlags (ER tools ...) */
- aot, /* aot: AOT_AAC_LC, AOT_SBR, AOT_PS */
- epConfig, /* epConfig -1, 0, 1 */
- NULL,
- 0 )) )
- {
- return ErrorStatus;
- }
-
- if ( !(syntaxFlags & AC_ER) )
- {
- /* Write associated extension payload */
- for (n = 0; n < qcOut->qcElement[i]->nExtensions; n++) {
- FDKaacEnc_writeExtensionData( hTpEnc,
- &qcOut->qcElement[i]->extension[n],
- 0,
- alignAnchor,
- syntaxFlags,
- aot,
- epConfig );
- }
- }
- }
- break;
-
- /* In FDK, DSE signalling explicit done in elDSE. See channel_map.cpp */
- default:
- return AAC_ENC_INVALID_ELEMENTINFO_TYPE;
-
- } /* switch */
-
- if(elInfo.elType != ID_DSE) {
- elementUsedBits -= bitMarkUp;
- bitMarkUp = FDKgetValidBits(hBs);
- elementUsedBits += bitMarkUp;
- frameBits += elementUsedBits;
- }
-
- } /* for (i=0; i<channelMapping.nElements; i++) */
-
- if ( (syntaxFlags & AC_ER) && !(syntaxFlags & AC_DRM) )
- {
- UCHAR channelElementExtensionWritten[(8)][(1)]; /* 0: extension not touched, 1: extension already written */
-
- FDKmemclear(channelElementExtensionWritten, sizeof(channelElementExtensionWritten));
-
- if ( syntaxFlags & AC_ELD ) {
-
- for (i=0; i<channelMapping->nElements; i++) {
- for (n = 0; n < qcOut->qcElement[i]->nExtensions; n++) {
-
- if ( (qcOut->qcElement[i]->extension[n].type==EXT_SBR_DATA)
- || (qcOut->qcElement[i]->extension[n].type==EXT_SBR_DATA_CRC) )
- {
- /* Write sbr extension payload */
- FDKaacEnc_writeExtensionData( hTpEnc,
- &qcOut->qcElement[i]->extension[n],
- 0,
- alignAnchor,
- syntaxFlags,
- aot,
- epConfig );
-
- channelElementExtensionWritten[i][n] = 1;
- } /* SBR */
- } /* n */
- } /* i */
- } /* AC_ELD */
-
- for (i=0; i<channelMapping->nElements; i++) {
- for (n = 0; n < qcOut->qcElement[i]->nExtensions; n++) {
-
- if (channelElementExtensionWritten[i][n]==0)
- {
- /* Write all remaining extension payloads in element */
- FDKaacEnc_writeExtensionData( hTpEnc,
- &qcOut->qcElement[i]->extension[n],
- 0,
- alignAnchor,
- syntaxFlags,
- aot,
- epConfig );
- }
- } /* n */
- } /* i */
- } /* if AC_ER */
-
- /* Extend global extension payload table with fill bits */
- if ( syntaxFlags & AC_DRM )
- {
- /* Exception for Drm */
- for (n = 0; n < qcOut->nExtensions; n++) {
- if ( (qcOut->extension[n].type == EXT_SBR_DATA)
- || (qcOut->extension[n].type == EXT_SBR_DATA_CRC) ) {
- /* SBR data must be the last extension! */
- FDKmemcpy(&qcOut->extension[qcOut->nExtensions], &qcOut->extension[n], sizeof(QC_OUT_EXTENSION));
- break;
- }
- }
- /* Do byte alignment after AAC (+ MPS) payload.
- Assure that MPS has been written as channel assigned extension payload! */
- if (((FDKgetValidBits(hBs)-alignAnchor+(UINT)qcOut->totFillBits)&0x7)!=(UINT)qcOut->alignBits) {
- return AAC_ENC_WRITTEN_BITS_ERROR;
- }
- FDKaacEnc_ByteAlignment(hBs, qcOut->alignBits);
- doByteAlign = 0;
-
- } /* AC_DRM */
-
- /* Add fill data / stuffing bits */
- n = qcOut->nExtensions;
-
-// if (!(syntaxFlags & AC_DAB)) {
- qcOut->extension[n].type = EXT_FILL_DATA;
- qcOut->extension[n].nPayloadBits = qcOut->totFillBits;
- qcOut->nExtensions++;
-// } else {
-// doByteAlign = 0;
-// }
- if (syntaxFlags & AC_DAB)
- doByteAlign = 0;
-
- /* Write global extension payload and fill data */
- for (n = 0; (n < qcOut->nExtensions) && (n < (2+2)); n++)
- {
- if ( !(syntaxFlags & AC_DAB) ||
- ( (syntaxFlags & AC_DAB) &&
- (qcOut->extension[n].type != EXT_DATA_ELEMENT)
- )
- ) {
- FDKaacEnc_writeExtensionData( hTpEnc,
- &qcOut->extension[n],
- 0,
- alignAnchor,
- syntaxFlags,
- aot,
- epConfig );
- }
-
- /* For EXT_FIL or EXT_FILL_DATA we could do an additional sanity check here */
- }
-
- if (!(syntaxFlags & (AC_SCALABLE|AC_ER|AC_DAB))) {
- FDKwriteBits(hBs, ID_END, EL_ID_BITS);
- }
-
- if (doByteAlign) {
- /* Assure byte alignment*/
- if (((alignAnchor-FDKgetValidBits(hBs))&0x7)!=(UINT)qcOut->alignBits) {
- return AAC_ENC_WRITTEN_BITS_ERROR;
- }
-
- FDKaacEnc_ByteAlignment(hBs, qcOut->alignBits);
- }
-
- frameBits -= bitMarkUp;
- frameBits += FDKgetValidBits(hBs);
-
- transportEnc_EndAccessUnit(hTpEnc, &frameBits);
-
- if (frameBits != qcOut->totalBits + qcKernel->globHdrBits){
- fprintf(stderr, "frameBits != qcOut->totalBits + qcKernel->globHdrBits: %d != %d + %d", frameBits, qcOut->totalBits, qcKernel->globHdrBits);
- return AAC_ENC_WRITTEN_BITS_ERROR;
- }
-
- //fprintf(stderr, "ErrorStatus=%d", ErrorStatus);
- return ErrorStatus;
-}
-
diff --git a/libAACenc/src/bitenc.h b/libAACenc/src/bitenc.h
deleted file mode 100644
index 498be7c..0000000
--- a/libAACenc/src/bitenc.h
+++ /dev/null
@@ -1,183 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M. Werner
- contents/description: Bitstream encoder
-
-******************************************************************************/
-
-#ifndef _BITENC_H
-#define _BITENC_H
-
-
-#include "qc_data.h"
-#include "aacenc_tns.h"
-#include "channel_map.h"
-#include "interface.h" /* obsolete, when PSY_OUT is thrown out of the WritBS-call! */
-#include "FDK_audio.h"
-#include "aacenc.h"
-
-#include "tpenc_lib.h"
-
-typedef enum{
- MAX_ENCODER_CHANNELS = 9,
- MAX_BLOCK_TYPES = 4,
- MAX_AAC_LAYERS = 9,
- MAX_LAYERS = MAX_AAC_LAYERS , /* only one core layer if present */
- FIRST_LAY = 1 /* default layer number for AAC nonscalable */
-} _MAX_CONST;
-
-#define BUFFER_MX_HUFFCB_SIZE (32*sizeof(INT)) /* our FDK_bitbuffer needs size of power 2 */
-
-#define EL_ID_BITS ( 3 )
-
-
-/**
- * \brief Arbitrary order bitstream writer. This function can either assemble a bit stream
- * and write into the bit buffer of hTpEnc or calculate the number of static bits (signal independent)
- * TpEnc handle must be NULL in this case. Or also Calculate the minimum possible number of
- * static bits which by disabling all tools e.g. MS, TNS and sbfCnt=0. The minCnt parameter
- * has to be 1 in this latter case.
- * \param hTpEnc Transport encoder handle. If NULL, the number of static bits will be returned into
- * *pBitDemand.
- * \param pElInfo
- * \param qcOutChannel
- * \param hReorderInfo
- * \param psyOutElement
- * \param psyOutChannel
- * \param syntaxFlags Bit stream syntax flags as defined in FDK_audio.h (Audio Codec flags).
- * \param aot
- * \param epConfig
- * \param pBitDemand Pointer to an int where the amount of bits is returned into. The returned value
- * depends on if hTpEnc is NULL and minCnt.
- * \param minCnt If non-zero the value returned into *pBitDemand is the absolute minimum required amount of
- * static bits in order to write a valid bit stream.
- * \return AAC_ENCODER_ERROR error code
- */
-AAC_ENCODER_ERROR FDKaacEnc_ChannelElementWrite( HANDLE_TRANSPORTENC hTpEnc,
- ELEMENT_INFO *pElInfo,
- QC_OUT_CHANNEL *qcOutChannel[(2)],
- PSY_OUT_ELEMENT *psyOutElement,
- PSY_OUT_CHANNEL *psyOutChannel[(2)],
- UINT syntaxFlags,
- AUDIO_OBJECT_TYPE aot,
- SCHAR epConfig,
- INT *pBitDemand,
- UCHAR minCnt
- );
-/**
- * \brief Write bit stream or account static bits
- * \param hTpEnc transport encoder handle. If NULL, the function will
- * not write any bit stream data but only count the amount
- * of static (signal independent) bits
- * \param channelMapping Channel mapping info
- * \param qcOut
- * \param psyOut
- * \param qcKernel
- * \param hBSE
- * \param aot Audio Object Type being encoded
- * \param syntaxFlags Flags indicating format specific detail
- * \param epConfig Error protection config
- */
-AAC_ENCODER_ERROR FDKaacEnc_WriteBitstream (HANDLE_TRANSPORTENC hTpEnc,
- CHANNEL_MAPPING *channelMapping,
- QC_OUT* qcOut,
- PSY_OUT* psyOut,
- QC_STATE* qcKernel,
- AUDIO_OBJECT_TYPE aot,
- UINT syntaxFlags,
- SCHAR epConfig
- );
-
-INT FDKaacEnc_writeExtensionData( HANDLE_TRANSPORTENC hTpEnc,
- QC_OUT_EXTENSION *pExtension,
- INT elInstanceTag,
- UINT alignAnchor,
- UINT syntaxFlags,
- AUDIO_OBJECT_TYPE aot,
- SCHAR epConfig
- );
-
-#endif /* _BITENC_H */
diff --git a/libAACenc/src/block_switch.cpp b/libAACenc/src/block_switch.cpp
deleted file mode 100644
index 7b3e275..0000000
--- a/libAACenc/src/block_switch.cpp
+++ /dev/null
@@ -1,545 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/***************************** MPEG-4 AAC Encoder **************************
-
- Author(s): M. Werner, Tobias Chalupka
- Description: Block switching
-
-******************************************************************************/
-
-/****************** Includes *****************************/
-
-#include "block_switch.h"
-#include "genericStds.h"
-
-
-#define LOWOV_WINDOW _LOWOV_WINDOW
-
-/**************** internal function prototypes ***********/
-
-static FIXP_DBL FDKaacEnc_GetWindowEnergy(const FIXP_DBL in[], const INT blSwWndIdx);
-
-static void FDKaacEnc_CalcWindowEnergy(
- BLOCK_SWITCHING_CONTROL *RESTRICT blockSwitchingControl,
- INT windowLen,
- const INT_PCM *pTimeSignal
- );
-
-/****************** Constants *****************************/
-/* LONG START SHORT STOP LOWOV */
-static const INT blockType2windowShape[2][5] = { {SINE_WINDOW, KBD_WINDOW, WRONG_WINDOW, SINE_WINDOW, KBD_WINDOW}, /* LD */
- {KBD_WINDOW, SINE_WINDOW, SINE_WINDOW, KBD_WINDOW, WRONG_WINDOW} }; /* LC */
-
-/* IIR high pass coeffs */
-
-#ifndef SINETABLE_16BIT
-
-static const FIXP_DBL hiPassCoeff[BLOCK_SWITCHING_IIR_LEN]=
-{
- FL2FXCONST_DBL(-0.5095),FL2FXCONST_DBL(0.7548)
-};
-
-static const FIXP_DBL accWindowNrgFac = FL2FXCONST_DBL(0.3f); /* factor for accumulating filtered window energies */
-static const FIXP_DBL oneMinusAccWindowNrgFac = FL2FXCONST_DBL(0.7f);
-/* static const float attackRatio = 10.0; */ /* lower ratio limit for attacks */
-static const FIXP_DBL invAttackRatio = FL2FXCONST_DBL(0.1f); /* inverted lower ratio limit for attacks */
-
-/* The next constants are scaled, because they are used for comparison with scaled values*/
-/* minimum energy for attacks */
-static const FIXP_DBL minAttackNrg = (FL2FXCONST_DBL(1e+6f*NORM_PCM_ENERGY)>>BLOCK_SWITCH_ENERGY_SHIFT); /* minimum energy for attacks */
-
-#else
-
-static const FIXP_SGL hiPassCoeff[BLOCK_SWITCHING_IIR_LEN]=
-{
- FL2FXCONST_SGL(-0.5095),FL2FXCONST_SGL(0.7548)
-};
-
-static const FIXP_DBL accWindowNrgFac = FL2FXCONST_DBL(0.3f); /* factor for accumulating filtered window energies */
-static const FIXP_SGL oneMinusAccWindowNrgFac = FL2FXCONST_SGL(0.7f);
-/* static const float attackRatio = 10.0; */ /* lower ratio limit for attacks */
-static const FIXP_SGL invAttackRatio = FL2FXCONST_SGL(0.1f); /* inverted lower ratio limit for attacks */
-/* minimum energy for attacks */
-static const FIXP_DBL minAttackNrg = (FL2FXCONST_DBL(1e+6f*NORM_PCM_ENERGY)>>BLOCK_SWITCH_ENERGY_SHIFT); /* minimum energy for attacks */
-
-#endif
-
-/**************** internal function prototypes ***********/
-
-/****************** Routines ****************************/
-void FDKaacEnc_InitBlockSwitching(BLOCK_SWITCHING_CONTROL *blockSwitchingControl, INT isLowDelay)
-{
- FDKmemclear (blockSwitchingControl, sizeof(BLOCK_SWITCHING_CONTROL));
-
- if (isLowDelay)
- {
- blockSwitchingControl->nBlockSwitchWindows = 4;
- blockSwitchingControl->allowShortFrames = 0;
- blockSwitchingControl->allowLookAhead = 0;
- }
- else
- {
- blockSwitchingControl->nBlockSwitchWindows = 8;
- blockSwitchingControl->allowShortFrames = 1;
- blockSwitchingControl->allowLookAhead = 1;
- }
-
- blockSwitchingControl->noOfGroups = MAX_NO_OF_GROUPS;
-
- /* Initialize startvalue for blocktype */
- blockSwitchingControl->lastWindowSequence = LONG_WINDOW;
- blockSwitchingControl->windowShape = blockType2windowShape[blockSwitchingControl->allowShortFrames][blockSwitchingControl->lastWindowSequence];
-
-}
-
-static const INT suggestedGroupingTable[TRANS_FAC][MAX_NO_OF_GROUPS] =
-{
- /* Attack in Window 0 */ {1, 3, 3, 1},
- /* Attack in Window 1 */ {1, 1, 3, 3},
- /* Attack in Window 2 */ {2, 1, 3, 2},
- /* Attack in Window 3 */ {3, 1, 3, 1},
- /* Attack in Window 4 */ {3, 1, 1, 3},
- /* Attack in Window 5 */ {3, 2, 1, 2},
- /* Attack in Window 6 */ {3, 3, 1, 1},
- /* Attack in Window 7 */ {3, 3, 1, 1}
-};
-
-/* change block type depending on current blocktype and whether there's an attack */
-/* assume no look-ahead */
-static const INT chgWndSq[2][N_BLOCKTYPES] =
-{
- /* LONG WINDOW START_WINDOW SHORT_WINDOW STOP_WINDOW, LOWOV_WINDOW, WRONG_WINDOW */
- /*no attack*/ {LONG_WINDOW, STOP_WINDOW, WRONG_WINDOW, LONG_WINDOW, STOP_WINDOW , WRONG_WINDOW },
- /*attack */ {START_WINDOW, LOWOV_WINDOW, WRONG_WINDOW, START_WINDOW, LOWOV_WINDOW, WRONG_WINDOW }
-};
-
-/* change block type depending on current blocktype and whether there's an attack */
-/* assume look-ahead */
-static const INT chgWndSqLkAhd[2][2][N_BLOCKTYPES] =
-{
- /*attack LONG WINDOW START_WINDOW SHORT_WINDOW STOP_WINDOW LOWOV_WINDOW, WRONG_WINDOW */ /* last attack */
- /*no attack*/ { {LONG_WINDOW, SHORT_WINDOW, STOP_WINDOW, LONG_WINDOW, WRONG_WINDOW, WRONG_WINDOW}, /* no attack */
- /*attack */ {START_WINDOW, SHORT_WINDOW, SHORT_WINDOW, START_WINDOW, WRONG_WINDOW, WRONG_WINDOW} }, /* no attack */
- /*no attack*/ { {LONG_WINDOW, SHORT_WINDOW, SHORT_WINDOW, LONG_WINDOW, WRONG_WINDOW, WRONG_WINDOW}, /* attack */
- /*attack */ {START_WINDOW, SHORT_WINDOW, SHORT_WINDOW, START_WINDOW, WRONG_WINDOW, WRONG_WINDOW} } /* attack */
-};
-
-int FDKaacEnc_BlockSwitching(BLOCK_SWITCHING_CONTROL *blockSwitchingControl, const INT granuleLength, const int isLFE, const INT_PCM *pTimeSignal)
-{
- UINT i;
- FIXP_DBL enM1, enMax;
-
- UINT nBlockSwitchWindows = blockSwitchingControl->nBlockSwitchWindows;
-
- /* for LFE : only LONG window allowed */
- if (isLFE) {
-
- /* case LFE: */
- /* only long blocks, always use sine windows (MPEG2 AAC, MPEG4 AAC) */
- blockSwitchingControl->lastWindowSequence = LONG_WINDOW;
- blockSwitchingControl->windowShape = SINE_WINDOW;
- blockSwitchingControl->noOfGroups = 1;
- blockSwitchingControl->groupLen[0] = 1;
-
- return(0);
- };
-
- /* Save current attack index as last attack index */
- blockSwitchingControl->lastattack = blockSwitchingControl->attack;
- blockSwitchingControl->lastAttackIndex = blockSwitchingControl->attackIndex;
-
- /* Save current window energy as last window energy */
- FDKmemcpy(blockSwitchingControl->windowNrg[0], blockSwitchingControl->windowNrg[1], sizeof(blockSwitchingControl->windowNrg[0]));
- FDKmemcpy(blockSwitchingControl->windowNrgF[0], blockSwitchingControl->windowNrgF[1], sizeof(blockSwitchingControl->windowNrgF[0]));
-
- if (blockSwitchingControl->allowShortFrames)
- {
- /* Calculate suggested grouping info for the last frame */
-
- /* Reset grouping info */
- FDKmemclear (blockSwitchingControl->groupLen, sizeof(blockSwitchingControl->groupLen));
-
- /* Set grouping info */
- blockSwitchingControl->noOfGroups = MAX_NO_OF_GROUPS;
-
- FDKmemcpy(blockSwitchingControl->groupLen, suggestedGroupingTable[blockSwitchingControl->lastAttackIndex], sizeof(blockSwitchingControl->groupLen));
-
- if (blockSwitchingControl->attack == TRUE)
- blockSwitchingControl->maxWindowNrg = FDKaacEnc_GetWindowEnergy(blockSwitchingControl->windowNrg[0], blockSwitchingControl->lastAttackIndex);
- else
- blockSwitchingControl->maxWindowNrg = FL2FXCONST_DBL(0.0);
-
- }
-
-
- /* Calculate unfiltered and filtered energies in subwindows and combine to segments */
- FDKaacEnc_CalcWindowEnergy(blockSwitchingControl, granuleLength>>(nBlockSwitchWindows==4? 2:3 ), pTimeSignal);
-
- /* now calculate if there is an attack */
-
- /* reset attack */
- blockSwitchingControl->attack = FALSE;
-
- /* look for attack */
- enMax = FL2FXCONST_DBL(0.0f);
- enM1 = blockSwitchingControl->windowNrgF[0][nBlockSwitchWindows-1];
-
- for (i=0; i<nBlockSwitchWindows; i++) {
- FIXP_DBL tmp = fMultDiv2(oneMinusAccWindowNrgFac, blockSwitchingControl->accWindowNrg);
- blockSwitchingControl->accWindowNrg = fMultAdd(tmp, accWindowNrgFac, enM1) ;
-
- if (fMult(blockSwitchingControl->windowNrgF[1][i],invAttackRatio) > blockSwitchingControl->accWindowNrg ) {
- blockSwitchingControl->attack = TRUE;
- blockSwitchingControl->attackIndex = i;
- }
- enM1 = blockSwitchingControl->windowNrgF[1][i];
- enMax = fixMax(enMax, enM1);
- }
-
-
- if (enMax < minAttackNrg) blockSwitchingControl->attack = FALSE;
-
- /* Check if attack spreads over frame border */
- if((blockSwitchingControl->attack == FALSE) && (blockSwitchingControl->lastattack == TRUE)) {
- /* if attack is in last window repeat SHORT_WINDOW */
- if ( ((blockSwitchingControl->windowNrgF[0][nBlockSwitchWindows-1]>>4) > fMult((FIXP_DBL)(10<<(DFRACT_BITS-1-4)), blockSwitchingControl->windowNrgF[1][1]))
- && (blockSwitchingControl->lastAttackIndex == (INT)nBlockSwitchWindows-1)
- )
- {
- blockSwitchingControl->attack = TRUE;
- blockSwitchingControl->attackIndex = 0;
- }
- }
-
-
- if(blockSwitchingControl->allowLookAhead)
- {
-
-
- blockSwitchingControl->lastWindowSequence =
- chgWndSqLkAhd[blockSwitchingControl->lastattack][blockSwitchingControl->attack][blockSwitchingControl->lastWindowSequence];
- }
- else
- {
- /* Low Delay */
- blockSwitchingControl->lastWindowSequence =
- chgWndSq[blockSwitchingControl->attack][blockSwitchingControl->lastWindowSequence];
- }
-
-
- /* update window shape */
- blockSwitchingControl->windowShape = blockType2windowShape[blockSwitchingControl->allowShortFrames][blockSwitchingControl->lastWindowSequence];
-
- return(0);
-}
-
-
-
-static FIXP_DBL FDKaacEnc_GetWindowEnergy(const FIXP_DBL in[], const INT blSwWndIdx)
-{
-/* For coherency, change FDKaacEnc_GetWindowEnergy() to calcluate the energy for a block switching analysis windows,
- not for a short block. The same is done FDKaacEnc_CalcWindowEnergy(). The result of FDKaacEnc_GetWindowEnergy()
- is used for a comparision of the max energy of left/right channel. */
-
- return in[blSwWndIdx];
-
-}
-
-static void FDKaacEnc_CalcWindowEnergy(BLOCK_SWITCHING_CONTROL *RESTRICT blockSwitchingControl, INT windowLen, const INT_PCM *pTimeSignal)
-{
- INT i;
- UINT w;
-
- FIXP_SGL hiPassCoeff0 = hiPassCoeff[0];
- FIXP_SGL hiPassCoeff1 = hiPassCoeff[1];
-
- /* sum up scalarproduct of timesignal as windowed Energies */
- for (w=0; w < blockSwitchingControl->nBlockSwitchWindows; w++) {
-
- FIXP_DBL temp_windowNrg = FL2FXCONST_DBL(0.0f);
- FIXP_DBL temp_windowNrgF = FL2FXCONST_DBL(0.0f);
- FIXP_DBL temp_iirState0 = blockSwitchingControl->iirStates[0];
- FIXP_DBL temp_iirState1 = blockSwitchingControl->iirStates[1];
-
- /* windowNrg = sum(timesample^2) */
- for(i=0;i<windowLen;i++)
- {
-
- FIXP_DBL tempUnfiltered, tempFiltred, t1, t2;
- /* tempUnfiltered is scaled with 1 to prevent overflows during calculation of tempFiltred */
-#if SAMPLE_BITS == DFRACT_BITS
- tempUnfiltered = (FIXP_DBL) *pTimeSignal++ >> 1;
-#else
- tempUnfiltered = (FIXP_DBL) *pTimeSignal++ << (DFRACT_BITS-SAMPLE_BITS-1);
-#endif
- t1 = fMultDiv2(hiPassCoeff1, tempUnfiltered-temp_iirState0);
- t2 = fMultDiv2(hiPassCoeff0, temp_iirState1);
- tempFiltred = (t1 - t2) << 1;
-
- temp_iirState0 = tempUnfiltered;
- temp_iirState1 = tempFiltred;
-
- /* subtract 2 from overallscaling (BLOCK_SWITCH_ENERGY_SHIFT)
- * because tempUnfiltered was already scaled with 1 (is 2 after squaring)
- * subtract 1 from overallscaling (BLOCK_SWITCH_ENERGY_SHIFT)
- * because of fMultDiv2 is doing a scaling by one */
- temp_windowNrg += fPow2Div2(tempUnfiltered) >> (BLOCK_SWITCH_ENERGY_SHIFT - 1 - 2);
- temp_windowNrgF += fPow2Div2(tempFiltred) >> (BLOCK_SWITCH_ENERGY_SHIFT - 1 - 2);
- }
- blockSwitchingControl->windowNrg[1][w] = temp_windowNrg;
- blockSwitchingControl->windowNrgF[1][w] = temp_windowNrgF;
- blockSwitchingControl->iirStates[0] = temp_iirState0;
- blockSwitchingControl->iirStates[1] = temp_iirState1;
- }
-}
-
-
-static const UCHAR synchronizedBlockTypeTable[5][5] =
-{
- /* LONG_WINDOW START_WINDOW SHORT_WINDOW STOP_WINDOW LOWOV_WINDOW*/
- /* LONG_WINDOW */ {LONG_WINDOW, START_WINDOW, SHORT_WINDOW, STOP_WINDOW, LOWOV_WINDOW},
- /* START_WINDOW */ {START_WINDOW, START_WINDOW, SHORT_WINDOW, SHORT_WINDOW, LOWOV_WINDOW},
- /* SHORT_WINDOW */ {SHORT_WINDOW, SHORT_WINDOW, SHORT_WINDOW, SHORT_WINDOW, WRONG_WINDOW},
- /* STOP_WINDOW */ {STOP_WINDOW, SHORT_WINDOW, SHORT_WINDOW, STOP_WINDOW, LOWOV_WINDOW},
- /* LOWOV_WINDOW */ {LOWOV_WINDOW, LOWOV_WINDOW, WRONG_WINDOW, LOWOV_WINDOW, LOWOV_WINDOW},
-};
-
-int FDKaacEnc_SyncBlockSwitching (
- BLOCK_SWITCHING_CONTROL *blockSwitchingControlLeft,
- BLOCK_SWITCHING_CONTROL *blockSwitchingControlRight,
- const INT nChannels,
- const INT commonWindow )
-{
- UCHAR patchType = LONG_WINDOW;
-
- if( nChannels == 2 && commonWindow == TRUE)
- {
- /* could be better with a channel loop (need a handle to psy_data) */
- /* get suggested Block Types and synchronize */
- patchType = synchronizedBlockTypeTable[patchType][blockSwitchingControlLeft->lastWindowSequence];
- patchType = synchronizedBlockTypeTable[patchType][blockSwitchingControlRight->lastWindowSequence];
-
- /* sanity check (no change from low overlap window to short winow and vice versa) */
- if (patchType == WRONG_WINDOW)
- return -1; /* mixed up AAC-LC and AAC-LD */
-
- /* Set synchronized Blocktype */
- blockSwitchingControlLeft->lastWindowSequence = patchType;
- blockSwitchingControlRight->lastWindowSequence = patchType;
-
- /* update window shape */
- blockSwitchingControlLeft->windowShape = blockType2windowShape[blockSwitchingControlLeft->allowShortFrames][blockSwitchingControlLeft->lastWindowSequence];
- blockSwitchingControlRight->windowShape = blockType2windowShape[blockSwitchingControlLeft->allowShortFrames][blockSwitchingControlRight->lastWindowSequence];
- }
-
- if (blockSwitchingControlLeft->allowShortFrames)
- {
- int i;
-
- if( nChannels == 2 )
- {
- if (commonWindow == TRUE)
- {
- /* Synchronize grouping info */
- int windowSequenceLeftOld = blockSwitchingControlLeft->lastWindowSequence;
- int windowSequenceRightOld = blockSwitchingControlRight->lastWindowSequence;
-
- /* Long Blocks */
- if(patchType != SHORT_WINDOW) {
- /* Set grouping info */
- blockSwitchingControlLeft->noOfGroups = 1;
- blockSwitchingControlRight->noOfGroups = 1;
- blockSwitchingControlLeft->groupLen[0] = 1;
- blockSwitchingControlRight->groupLen[0] = 1;
-
- for (i = 1; i < MAX_NO_OF_GROUPS; i++)
- {
- blockSwitchingControlLeft->groupLen[i] = 0;
- blockSwitchingControlRight->groupLen[i] = 0;
- }
- }
-
- /* Short Blocks */
- else {
- /* in case all two channels were detected as short-blocks before syncing, use the grouping of channel with higher maxWindowNrg */
- if( (windowSequenceLeftOld == SHORT_WINDOW) &&
- (windowSequenceRightOld == SHORT_WINDOW) )
- {
- if(blockSwitchingControlLeft->maxWindowNrg > blockSwitchingControlRight->maxWindowNrg) {
- /* Left Channel wins */
- blockSwitchingControlRight->noOfGroups = blockSwitchingControlLeft->noOfGroups;
- for (i = 0; i < MAX_NO_OF_GROUPS; i++){
- blockSwitchingControlRight->groupLen[i] = blockSwitchingControlLeft->groupLen[i];
- }
- }
- else {
- /* Right Channel wins */
- blockSwitchingControlLeft->noOfGroups = blockSwitchingControlRight->noOfGroups;
- for (i = 0; i < MAX_NO_OF_GROUPS; i++){
- blockSwitchingControlLeft->groupLen[i] = blockSwitchingControlRight->groupLen[i];
- }
- }
- }
- else if ( (windowSequenceLeftOld == SHORT_WINDOW) &&
- (windowSequenceRightOld != SHORT_WINDOW) )
- {
- /* else use grouping of short-block channel */
- blockSwitchingControlRight->noOfGroups = blockSwitchingControlLeft->noOfGroups;
- for (i = 0; i < MAX_NO_OF_GROUPS; i++){
- blockSwitchingControlRight->groupLen[i] = blockSwitchingControlLeft->groupLen[i];
- }
- }
- else if ( (windowSequenceRightOld == SHORT_WINDOW) &&
- (windowSequenceLeftOld != SHORT_WINDOW) )
- {
- blockSwitchingControlLeft->noOfGroups = blockSwitchingControlRight->noOfGroups;
- for (i = 0; i < MAX_NO_OF_GROUPS; i++){
- blockSwitchingControlLeft->groupLen[i] = blockSwitchingControlRight->groupLen[i];
- }
- } else {
- /* syncing a start and stop window ... */
- blockSwitchingControlLeft->noOfGroups = blockSwitchingControlRight->noOfGroups = 2;
- blockSwitchingControlLeft->groupLen[0] = blockSwitchingControlRight->groupLen[0] = 4;
- blockSwitchingControlLeft->groupLen[1] = blockSwitchingControlRight->groupLen[1] = 4;
- }
- } /* Short Blocks */
- }
- else {
- /* stereo, no common window */
- if (blockSwitchingControlLeft->lastWindowSequence!=SHORT_WINDOW){
- blockSwitchingControlLeft->noOfGroups = 1;
- blockSwitchingControlLeft->groupLen[0] = 1;
- for (i = 1; i < MAX_NO_OF_GROUPS; i++)
- {
- blockSwitchingControlLeft->groupLen[i] = 0;
- }
- }
- if (blockSwitchingControlRight->lastWindowSequence!=SHORT_WINDOW){
- blockSwitchingControlRight->noOfGroups = 1;
- blockSwitchingControlRight->groupLen[0] = 1;
- for (i = 1; i < MAX_NO_OF_GROUPS; i++)
- {
- blockSwitchingControlRight->groupLen[i] = 0;
- }
- }
- } /* common window */
- } else {
- /* Mono */
- if (blockSwitchingControlLeft->lastWindowSequence!=SHORT_WINDOW){
- blockSwitchingControlLeft->noOfGroups = 1;
- blockSwitchingControlLeft->groupLen[0] = 1;
-
- for (i = 1; i < MAX_NO_OF_GROUPS; i++)
- {
- blockSwitchingControlLeft->groupLen[i] = 0;
- }
- }
- }
- } /* allowShortFrames */
-
-
- /* Translate LOWOV_WINDOW block type to a meaningful window shape. */
- if ( ! blockSwitchingControlLeft->allowShortFrames ) {
- if ( blockSwitchingControlLeft->lastWindowSequence != LONG_WINDOW
- && blockSwitchingControlLeft->lastWindowSequence != STOP_WINDOW )
- {
- blockSwitchingControlLeft->lastWindowSequence = LONG_WINDOW;
- blockSwitchingControlLeft->windowShape = LOL_WINDOW;
- }
- }
- if (nChannels == 2) {
- if ( ! blockSwitchingControlRight->allowShortFrames ) {
- if ( blockSwitchingControlRight->lastWindowSequence != LONG_WINDOW
- && blockSwitchingControlRight->lastWindowSequence != STOP_WINDOW )
- {
- blockSwitchingControlRight->lastWindowSequence = LONG_WINDOW;
- blockSwitchingControlRight->windowShape = LOL_WINDOW;
- }
- }
- }
-
- return 0;
-}
-
-
diff --git a/libAACenc/src/block_switch.h b/libAACenc/src/block_switch.h
deleted file mode 100644
index e94b6f5..0000000
--- a/libAACenc/src/block_switch.h
+++ /dev/null
@@ -1,146 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/***************************** MPEG-4 AAC Encoder **************************
-
- Author(s): M. Werner
- Description: Block switching
-
-******************************************************************************/
-
-#ifndef _BLOCK_SWITCH_H
-#define _BLOCK_SWITCH_H
-
-#include "common_fix.h"
-
-#include "psy_const.h"
-
-/****************** Defines ******************************/
- #define BLOCK_SWITCH_WINDOWS 8 /* number of windows for energy calculation */
-
-#define BLOCK_SWITCHING_IIR_LEN 2 /* Length of HighPass-IIR-Filter for Attack-Detection */
-#define BLOCK_SWITCH_ENERGY_SHIFT 7 /* should be logDualis(BLOCK_SWITCH_WINDOW_LEN) to avoid overflow in windowNrgs. */
-
-#define LAST_WINDOW 0
-#define THIS_WINDOW 1
-
-
-/****************** Structures ***************************/
-typedef struct{
- INT lastWindowSequence;
- INT windowShape;
- INT lastWindowShape;
- UINT nBlockSwitchWindows; /* number of windows for energy calculation */
- INT attack;
- INT lastattack;
- INT attackIndex;
- INT lastAttackIndex;
- INT allowShortFrames; /* for Low Delay, don't allow short frames */
- INT allowLookAhead; /* for Low Delay, don't do look-ahead */
- INT noOfGroups;
- INT groupLen[MAX_NO_OF_GROUPS];
- FIXP_DBL maxWindowNrg; /* max energy in subwindows */
-
- FIXP_DBL windowNrg[2][BLOCK_SWITCH_WINDOWS]; /* time signal energy in Subwindows (last and current) */
- FIXP_DBL windowNrgF[2][BLOCK_SWITCH_WINDOWS]; /* filtered time signal energy in segments (last and current) */
- FIXP_DBL accWindowNrg; /* recursively accumulated windowNrgF */
-
- FIXP_DBL iirStates[BLOCK_SWITCHING_IIR_LEN]; /* filter delay-line */
-
-} BLOCK_SWITCHING_CONTROL;
-
-
-
-
-
-void FDKaacEnc_InitBlockSwitching(BLOCK_SWITCHING_CONTROL *blockSwitchingControl, INT isLowDelay);
-
-int FDKaacEnc_BlockSwitching(BLOCK_SWITCHING_CONTROL *blockSwitchingControl, const INT granuleLength, const int isLFE, const INT_PCM *pTimeSignal);
-
-int FDKaacEnc_SyncBlockSwitching(
- BLOCK_SWITCHING_CONTROL *blockSwitchingControlLeft,
- BLOCK_SWITCHING_CONTROL *blockSwitchingControlRight,
- const INT noOfChannels,
- const INT commonWindow);
-
-#endif /* #ifndef _BLOCK_SWITCH_H */
diff --git a/libAACenc/src/channel_map.cpp b/libAACenc/src/channel_map.cpp
deleted file mode 100644
index 99ed2b5..0000000
--- a/libAACenc/src/channel_map.cpp
+++ /dev/null
@@ -1,566 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/************************* Fast MPEG AAC Audio Encoder **********************
-
- Initial author: A. Groeschel
- contents/description: channel mapping functionality
-
-******************************************************************************/
-
-#include "channel_map.h"
-#include "bitenc.h"
-#include "psy_const.h"
-#include "qc_data.h"
-#include "aacEnc_ram.h"
-
-
-/* channel_assignment treats the relationship of Input file channels
- to the encoder channels.
- This is necessary because the usual order in RIFF files (.wav)
- is different from the elements order in the coder given
- by Table 8.1 (implicit speaker mapping) of the AAC standard.
-
- In mono and stereo case, this is trivial.
- In mc case, it looks like this:
-
- Channel Input file coder chan
-5ch:
- front center 2 0 (SCE channel)
- left center 0 1 (1st of 1st CPE)
- right center 1 2 (2nd of 1st CPE)
- left surround 3 3 (1st of 2nd CPE)
- right surround 4 4 (2nd of 2nd CPE)
-
-5.1ch:
- front center 2 0 (SCE channel)
- left center 0 1 (1st of 1st CPE)
- right center 1 2 (2nd of 1st CPE)
- left surround 4 3 (1st of 2nd CPE)
- right surround 5 4 (2nd of 2nd CPE)
- LFE 3 5 (LFE)
-*/
-
-typedef struct {
-
- CHANNEL_MODE encoderMode;
- INT channel_assignment[/*(8)*/12];
-
-} CHANNEL_ASSIGNMENT_INFO_TAB;
-
-
-static const CHANNEL_ASSIGNMENT_INFO_TAB assignmentInfoTabMpeg[] =
-{
- { MODE_INVALID, {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1} }, /* invalid */
- { MODE_1, { 0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1} }, /* mono */
- { MODE_2, { 0, 1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1} }, /* stereo */
- { MODE_1_2, { 0, 1, 2,-1,-1,-1,-1,-1,-1,-1,-1,-1} }, /* 3ch */
- { MODE_1_2_1, { 0, 1, 2, 3,-1,-1,-1,-1,-1,-1,-1,-1} }, /* 4ch */
- { MODE_1_2_2, { 0, 1, 2, 3, 4,-1,-1,-1,-1,-1,-1,-1} }, /* 5ch */
- { MODE_1_2_2_1, { 0, 1, 2, 3, 4, 5,-1,-1,-1,-1,-1,-1} }, /* 5.1ch */
- { MODE_1_2_2_2_1, { 0, 1, 2, 3, 4, 5, 6, 7,-1,-1,-1,-1} }, /* 7.1ch */
- { MODE_7_1_REAR_SURROUND, { 0, 1, 2, 3, 4, 5, 6, 7,-1,-1,-1,-1} }, /* 7.1ch */
- { MODE_7_1_FRONT_CENTER, { 0, 1, 2, 3, 4, 5, 6, 7,-1,-1,-1,-1} } /* 7.1ch */
-};
-
-static const CHANNEL_ASSIGNMENT_INFO_TAB assignmentInfoTabWav[] =
-{
- { MODE_INVALID, {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1} }, /* invalid */
- { MODE_1, { 0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1} }, /* mono */
- { MODE_2, { 0, 1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1} }, /* stereo */
- { MODE_1_2, { 2, 0, 1,-1,-1,-1,-1,-1,-1,-1,-1,-1} }, /* 3ch */
- { MODE_1_2_1, { 2, 0, 1, 3,-1,-1,-1,-1,-1,-1,-1,-1} }, /* 4ch */
- { MODE_1_2_2, { 2, 0, 1, 3, 4,-1,-1,-1,-1,-1,-1,-1} }, /* 5ch */
- { MODE_1_2_2_1, { 2, 0, 1, 4, 5, 3,-1,-1,-1,-1,-1,-1} }, /* 5.1ch */
- { MODE_1_2_2_2_1, { 2, 6, 7, 0, 1, 4, 5, 3,-1,-1,-1,-1} }, /* 7.1ch */
- { MODE_7_1_REAR_SURROUND, { 2, 0, 1, 6, 7, 4, 5, 3,-1,-1,-1,-1} }, /* 7.1ch */
- { MODE_7_1_FRONT_CENTER, { 2, 6, 7, 0, 1, 4, 5, 3,-1,-1,-1,-1} }, /* 7.1ch */
-};
-
-static const CHANNEL_ASSIGNMENT_INFO_TAB assignmentInfoTabWg4[] =
-{
- { MODE_INVALID, {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1} }, /* invalid */
- { MODE_1, { 0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1} }, /* mono */
- { MODE_2, { 0, 1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1} }, /* stereo */
- { MODE_1_2, { 2, 0, 1,-1,-1,-1,-1,-1,-1,-1,-1,-1} }, /* 3ch */
- { MODE_1_2_1, { 3, 0, 1, 2,-1,-1,-1,-1,-1,-1,-1,-1} }, /* 4ch */
- { MODE_1_2_2, { 4, 0, 1, 2, 3,-1,-1,-1,-1,-1,-1,-1} }, /* 5ch */
- { MODE_1_2_2_1, { 4, 0, 1, 2, 3, 5,-1,-1,-1,-1,-1,-1} }, /* 5.1ch */
- { MODE_1_2_2_2_1, { 6, 0, 1, 2, 3, 4, 5, 7,-1,-1,-1,-1} }, /* 7.1ch */
-};
-
-/* Channel mode configuration tab provides,
- corresponding number of channels and elements
-*/
-static const CHANNEL_MODE_CONFIG_TAB channelModeConfig[] =
-{
- { MODE_1, 1, 1, 1 }, /* SCE */
- { MODE_2, 2, 2, 1 }, /* CPE */
- { MODE_1_2, 3, 3, 2 }, /* SCE,CPE */
- { MODE_1_2_1, 4, 4, 3 }, /* SCE,CPE,SCE */
- { MODE_1_2_2, 5, 5, 3 }, /* SCE,CPE,CPE */
- { MODE_1_2_2_1, 6, 5, 4 }, /* SCE,CPE,CPE,LFE */
- { MODE_1_2_2_2_1, 8, 7, 5 }, /* SCE,CPE,CPE,CPE,LFE */
- { MODE_7_1_REAR_SURROUND, 8, 7, 5 },
- { MODE_7_1_FRONT_CENTER, 8, 7, 5 },
-};
-
-#define MAX_MODES (sizeof(assignmentInfoTabWav)/sizeof(CHANNEL_ASSIGNMENT_INFO_TAB))
-
-const INT* FDKaacEnc_getChannelAssignment(CHANNEL_MODE encMode, CHANNEL_ORDER co)
-{
- const CHANNEL_ASSIGNMENT_INFO_TAB *pTab;
- int i;
-
- if (co == CH_ORDER_MPEG)
- pTab = assignmentInfoTabMpeg;
- else if (co == CH_ORDER_WAV)
- pTab = assignmentInfoTabWav;
- else
- pTab = assignmentInfoTabWg4;
-
- for(i=MAX_MODES-1; i>0; i--) {
- if (encMode== pTab[i].encoderMode) {
- break;
- }
- }
- return (pTab[i].channel_assignment);
-}
-
-AAC_ENCODER_ERROR FDKaacEnc_DetermineEncoderMode(CHANNEL_MODE* mode, INT nChannels)
-{
- INT i;
- CHANNEL_MODE encMode = MODE_INVALID;
-
- if (*mode==MODE_UNKNOWN) {
- for (i=0; i<(INT)sizeof(channelModeConfig)/(INT)sizeof(CHANNEL_MODE_CONFIG_TAB); i++) {
- if (channelModeConfig[i].nChannels==nChannels) {
- encMode = channelModeConfig[i].encMode;
- break;
- }
- }
- *mode = encMode;
- }
- else {
- /* check if valid channel configuration */
- if (FDKaacEnc_GetChannelModeConfiguration(*mode)->nChannels==nChannels) {
- encMode = *mode;
- }
- }
-
- if (encMode==MODE_INVALID) {
- return AAC_ENC_UNSUPPORTED_CHANNELCONFIG;
- }
-
- return AAC_ENC_OK;
-}
-
-static INT FDKaacEnc_initElement (ELEMENT_INFO* elInfo, MP4_ELEMENT_ID elType, INT* cnt, CHANNEL_MODE mode, CHANNEL_ORDER co, INT* it_cnt, const FIXP_DBL relBits) {
-
- INT error=0;
- INT counter =*cnt;
-
- const INT *assign = FDKaacEnc_getChannelAssignment(mode, co);
-
- elInfo->elType=elType;
- elInfo->relativeBits = relBits;
-
- switch(elInfo->elType) {
- case ID_SCE: case ID_LFE: case ID_CCE:
- elInfo->nChannelsInEl=1;
- elInfo->ChannelIndex[0]=assign[counter++];
- elInfo->instanceTag=it_cnt[elType]++;
-
- break;
- case ID_CPE:
- elInfo->nChannelsInEl=2;
- elInfo->ChannelIndex[0]=assign[counter++];
- elInfo->ChannelIndex[1]=assign[counter++];
- elInfo->instanceTag=it_cnt[elType]++;
- break;
- case ID_DSE:
- elInfo->nChannelsInEl=0;
- elInfo->ChannelIndex[0]=0;
- elInfo->ChannelIndex[1]=0;
- elInfo->instanceTag=it_cnt[elType]++;
- break;
- default: error=1;
- };
- *cnt = counter;
- return error;
-
-}
-
-AAC_ENCODER_ERROR FDKaacEnc_InitChannelMapping(CHANNEL_MODE mode, CHANNEL_ORDER co, CHANNEL_MAPPING* cm)
-{
- INT count=0; /* count through coder channels */
- INT it_cnt[ID_END+1];
- INT i;
-
- for (i=0; i<ID_END; i++)
- it_cnt[i]=0;
-
- FDKmemclear(cm, sizeof(CHANNEL_MAPPING));
-
- /* init channel mapping*/
- for (i=0; i<(INT)sizeof(channelModeConfig)/(INT)sizeof(CHANNEL_MODE_CONFIG_TAB); i++) {
- if (channelModeConfig[i].encMode==mode)
- {
- cm->encMode = channelModeConfig[i].encMode;
- cm->nChannels = channelModeConfig[i].nChannels;
- cm->nChannelsEff = channelModeConfig[i].nChannelsEff;
- cm->nElements = channelModeConfig[i].nElements;
-
- break;
- }
- }
-
- /* init element info struct */
- switch(mode) {
- case MODE_1:
- /* (mono) sce */
- FDKaacEnc_initElement(&cm->elInfo[0], ID_SCE, &count, mode, co, it_cnt, (FIXP_DBL)MAXVAL_DBL);
- break;
- case MODE_2:
- /* (stereo) cpe */
- FDKaacEnc_initElement(&cm->elInfo[0], ID_CPE, &count, mode, co, it_cnt, (FIXP_DBL)MAXVAL_DBL);
- break;
-
- case MODE_1_2:
- /* sce + cpe */
- FDKaacEnc_initElement(&cm->elInfo[0], ID_SCE, &count, mode, co, it_cnt, FL2FXCONST_DBL(0.4f));
- FDKaacEnc_initElement(&cm->elInfo[1], ID_CPE, &count, mode, co, it_cnt, FL2FXCONST_DBL(0.6f));
- break;
-
- case MODE_1_2_1:
- /* sce + cpe + sce */
- FDKaacEnc_initElement(&cm->elInfo[0], ID_SCE, &count, mode, co, it_cnt, FL2FXCONST_DBL(0.3f));
- FDKaacEnc_initElement(&cm->elInfo[1], ID_CPE, &count, mode, co, it_cnt, FL2FXCONST_DBL(0.4f));
- FDKaacEnc_initElement(&cm->elInfo[2], ID_SCE, &count, mode, co, it_cnt, FL2FXCONST_DBL(0.3f));
- break;
-
- case MODE_1_2_2:
- /* sce + cpe + cpe */
- FDKaacEnc_initElement(&cm->elInfo[0], ID_SCE, &count, mode, co, it_cnt, FL2FXCONST_DBL(0.26f));
- FDKaacEnc_initElement(&cm->elInfo[1], ID_CPE, &count, mode, co, it_cnt, FL2FXCONST_DBL(0.37f));
- FDKaacEnc_initElement(&cm->elInfo[2], ID_CPE, &count, mode, co, it_cnt, FL2FXCONST_DBL(0.37f));
- break;
-
- case MODE_1_2_2_1:
- /* (5.1) sce + cpe + cpe + lfe */
- FDKaacEnc_initElement(&cm->elInfo[0], ID_SCE, &count, mode, co, it_cnt, FL2FXCONST_DBL(0.24f));
- FDKaacEnc_initElement(&cm->elInfo[1], ID_CPE, &count, mode, co, it_cnt, FL2FXCONST_DBL(0.35f));
- FDKaacEnc_initElement(&cm->elInfo[2], ID_CPE, &count, mode, co, it_cnt, FL2FXCONST_DBL(0.35f));
- FDKaacEnc_initElement(&cm->elInfo[3], ID_LFE, &count, mode, co, it_cnt, FL2FXCONST_DBL(0.06f));
- break;
-
- case MODE_1_2_2_2_1:
- case MODE_7_1_REAR_SURROUND:
- case MODE_7_1_FRONT_CENTER:
- /* (7.1) sce + cpe + cpe + cpe + lfe */
- FDKaacEnc_initElement(&cm->elInfo[0], ID_SCE, &count, mode, co, it_cnt, FL2FXCONST_DBL(0.18f));
- FDKaacEnc_initElement(&cm->elInfo[1], ID_CPE, &count, mode, co, it_cnt, FL2FXCONST_DBL(0.26f));
- FDKaacEnc_initElement(&cm->elInfo[2], ID_CPE, &count, mode, co, it_cnt, FL2FXCONST_DBL(0.26f));
- FDKaacEnc_initElement(&cm->elInfo[3], ID_CPE, &count, mode, co, it_cnt, FL2FXCONST_DBL(0.26f));
- FDKaacEnc_initElement(&cm->elInfo[4], ID_LFE, &count, mode, co, it_cnt, FL2FXCONST_DBL(0.04f));
- break;
- default:
- //*chMap=0;
- return AAC_ENC_UNSUPPORTED_CHANNELCONFIG;
- };
-
-
- FDK_ASSERT(cm->nElements<=(8));
-
-
- return AAC_ENC_OK;
-}
-
-AAC_ENCODER_ERROR FDKaacEnc_InitElementBits(QC_STATE *hQC,
- CHANNEL_MAPPING *cm,
- INT bitrateTot,
- INT averageBitsTot,
- INT maxChannelBits)
-{
- int sc_brTot = CountLeadingBits(bitrateTot);
-
- switch(cm->encMode) {
- case MODE_1:
- hQC->elementBits[0]->chBitrateEl = bitrateTot;
-
- hQC->elementBits[0]->maxBitsEl = maxChannelBits;
-
- hQC->elementBits[0]->relativeBitsEl = cm->elInfo[0].relativeBits;
- break;
-
- case MODE_2:
- hQC->elementBits[0]->chBitrateEl = bitrateTot>>1;
-
- hQC->elementBits[0]->maxBitsEl = 2*maxChannelBits;
-
- hQC->elementBits[0]->relativeBitsEl = cm->elInfo[0].relativeBits;
- break;
- case MODE_1_2: {
- hQC->elementBits[0]->relativeBitsEl = cm->elInfo[0].relativeBits;
- hQC->elementBits[1]->relativeBitsEl = cm->elInfo[1].relativeBits;
- FIXP_DBL sceRate = cm->elInfo[0].relativeBits;
- FIXP_DBL cpeRate = cm->elInfo[1].relativeBits;
-
- hQC->elementBits[0]->chBitrateEl = fMult(sceRate, (FIXP_DBL)(bitrateTot<<sc_brTot))>>sc_brTot;
- hQC->elementBits[1]->chBitrateEl = fMult(cpeRate, (FIXP_DBL)(bitrateTot<<sc_brTot))>>(sc_brTot+1);
-
- hQC->elementBits[0]->maxBitsEl = maxChannelBits;
- hQC->elementBits[1]->maxBitsEl = 2*maxChannelBits;
- break;
- }
- case MODE_1_2_1: {
- /* sce + cpe + sce */
- hQC->elementBits[0]->relativeBitsEl = cm->elInfo[0].relativeBits;
- hQC->elementBits[1]->relativeBitsEl = cm->elInfo[1].relativeBits;
- hQC->elementBits[2]->relativeBitsEl = cm->elInfo[2].relativeBits;
- FIXP_DBL sce1Rate = cm->elInfo[0].relativeBits;
- FIXP_DBL cpeRate = cm->elInfo[1].relativeBits;
- FIXP_DBL sce2Rate = cm->elInfo[2].relativeBits;
-
- hQC->elementBits[0]->chBitrateEl = fMult(sce1Rate, (FIXP_DBL)(bitrateTot<<sc_brTot))>>sc_brTot;
- hQC->elementBits[1]->chBitrateEl = fMult(cpeRate, (FIXP_DBL)(bitrateTot<<sc_brTot))>>(sc_brTot+1);
- hQC->elementBits[2]->chBitrateEl = fMult(sce2Rate, (FIXP_DBL)(bitrateTot<<sc_brTot))>>sc_brTot;
-
- hQC->elementBits[0]->maxBitsEl = maxChannelBits;
- hQC->elementBits[1]->maxBitsEl = 2*maxChannelBits;
- hQC->elementBits[2]->maxBitsEl = maxChannelBits;
- break;
- }
- case MODE_1_2_2: {
- /* sce + cpe + cpe */
- hQC->elementBits[0]->relativeBitsEl = cm->elInfo[0].relativeBits;
- hQC->elementBits[1]->relativeBitsEl = cm->elInfo[1].relativeBits;
- hQC->elementBits[2]->relativeBitsEl = cm->elInfo[2].relativeBits;
- FIXP_DBL sceRate = cm->elInfo[0].relativeBits;
- FIXP_DBL cpe1Rate = cm->elInfo[1].relativeBits;
- FIXP_DBL cpe2Rate = cm->elInfo[2].relativeBits;
-
- hQC->elementBits[0]->chBitrateEl = fMult(sceRate, (FIXP_DBL)(bitrateTot<<sc_brTot))>>sc_brTot;
- hQC->elementBits[1]->chBitrateEl = fMult(cpe1Rate, (FIXP_DBL)(bitrateTot<<sc_brTot))>>(sc_brTot+1);
- hQC->elementBits[2]->chBitrateEl = fMult(cpe2Rate, (FIXP_DBL)(bitrateTot<<sc_brTot))>>(sc_brTot+1);
-
- hQC->elementBits[0]->maxBitsEl = maxChannelBits;
- hQC->elementBits[1]->maxBitsEl = 2*maxChannelBits;
- hQC->elementBits[2]->maxBitsEl = 2*maxChannelBits;
- break;
- }
-
- case MODE_1_2_2_1: {
- /* (5.1) sce + cpe + cpe + lfe */
- hQC->elementBits[0]->relativeBitsEl = cm->elInfo[0].relativeBits;
- hQC->elementBits[1]->relativeBitsEl = cm->elInfo[1].relativeBits;
- hQC->elementBits[2]->relativeBitsEl = cm->elInfo[2].relativeBits;
- hQC->elementBits[3]->relativeBitsEl = cm->elInfo[3].relativeBits;
- FIXP_DBL sceRate = cm->elInfo[0].relativeBits;
- FIXP_DBL cpe1Rate = cm->elInfo[1].relativeBits;
- FIXP_DBL cpe2Rate = cm->elInfo[2].relativeBits;
- FIXP_DBL lfeRate = cm->elInfo[3].relativeBits;
-
- int maxBitsTot = maxChannelBits * 5; /* LFE does not add to bit reservoir */
- int sc = CountLeadingBits(fixMax(maxChannelBits,averageBitsTot));
- int maxLfeBits = (int) FDKmax ( (INT)((fMult(lfeRate,(FIXP_DBL)(maxChannelBits<<sc))>>sc)<<1),
- (INT)((fMult(FL2FXCONST_DBL(1.1f/2.f),fMult(lfeRate,(FIXP_DBL)(averageBitsTot<<sc)))<<1)>>sc) );
-
- maxChannelBits = (maxBitsTot - maxLfeBits);
- sc = CountLeadingBits(maxChannelBits);
-
- maxChannelBits = fMult((FIXP_DBL)maxChannelBits<<sc,GetInvInt(5))>>sc;
-
- hQC->elementBits[0]->chBitrateEl = fMult(sceRate, (FIXP_DBL)(bitrateTot<<sc_brTot))>>sc_brTot;
- hQC->elementBits[1]->chBitrateEl = fMult(cpe1Rate, (FIXP_DBL)(bitrateTot<<sc_brTot))>>(sc_brTot+1);
- hQC->elementBits[2]->chBitrateEl = fMult(cpe2Rate, (FIXP_DBL)(bitrateTot<<sc_brTot))>>(sc_brTot+1);
- hQC->elementBits[3]->chBitrateEl = fMult(lfeRate, (FIXP_DBL)(bitrateTot<<sc_brTot))>>sc_brTot;
-
- hQC->elementBits[0]->maxBitsEl = maxChannelBits;
- hQC->elementBits[1]->maxBitsEl = 2*maxChannelBits;
- hQC->elementBits[2]->maxBitsEl = 2*maxChannelBits;
- hQC->elementBits[3]->maxBitsEl = maxLfeBits;
-
- break;
- }
- case MODE_7_1_REAR_SURROUND:
- case MODE_7_1_FRONT_CENTER:
- case MODE_1_2_2_2_1: {
- int cpe3Idx = 3;
- int lfeIdx = 4;
-
- /* (7.1) sce + cpe + cpe + cpe + lfe */
- FIXP_DBL sceRate = hQC->elementBits[0]->relativeBitsEl = cm->elInfo[0].relativeBits;
- FIXP_DBL cpe1Rate = hQC->elementBits[1]->relativeBitsEl = cm->elInfo[1].relativeBits;
- FIXP_DBL cpe2Rate = hQC->elementBits[2]->relativeBitsEl = cm->elInfo[2].relativeBits;
- FIXP_DBL cpe3Rate = hQC->elementBits[cpe3Idx]->relativeBitsEl = cm->elInfo[cpe3Idx].relativeBits;
- FIXP_DBL lfeRate = hQC->elementBits[lfeIdx]->relativeBitsEl = cm->elInfo[lfeIdx].relativeBits;
-
- int maxBitsTot = maxChannelBits * 7; /* LFE does not add to bit reservoir */
- int sc = CountLeadingBits(fixMax(maxChannelBits,averageBitsTot));
- int maxLfeBits = (int) FDKmax ( (INT)((fMult(lfeRate,(FIXP_DBL)(maxChannelBits<<sc))>>sc)<<1),
- (INT)((fMult(FL2FXCONST_DBL(1.1f/2.f),fMult(lfeRate,(FIXP_DBL)(averageBitsTot<<sc)))<<1)>>sc) );
-
- maxChannelBits = (maxBitsTot - maxLfeBits) / 7;
-
- hQC->elementBits[0]->chBitrateEl = fMult(sceRate, (FIXP_DBL)(bitrateTot<<sc_brTot))>>sc_brTot;
- hQC->elementBits[1]->chBitrateEl = fMult(cpe1Rate, (FIXP_DBL)(bitrateTot<<sc_brTot))>>(sc_brTot+1);
- hQC->elementBits[2]->chBitrateEl = fMult(cpe2Rate, (FIXP_DBL)(bitrateTot<<sc_brTot))>>(sc_brTot+1);
- hQC->elementBits[cpe3Idx]->chBitrateEl = fMult(cpe3Rate, (FIXP_DBL)(bitrateTot<<sc_brTot))>>(sc_brTot+1);
- hQC->elementBits[lfeIdx]->chBitrateEl = fMult(lfeRate, (FIXP_DBL)(bitrateTot<<sc_brTot))>>sc_brTot;
-
- hQC->elementBits[0]->maxBitsEl = maxChannelBits;
- hQC->elementBits[1]->maxBitsEl = 2*maxChannelBits;
- hQC->elementBits[2]->maxBitsEl = 2*maxChannelBits;
- hQC->elementBits[cpe3Idx]->maxBitsEl = 2*maxChannelBits;
- hQC->elementBits[lfeIdx]->maxBitsEl = maxLfeBits;
- break;
- }
- default:
- return AAC_ENC_UNSUPPORTED_CHANNELCONFIG;
- }
-
- return AAC_ENC_OK;
-}
-
-/********************************************************************************/
-/* */
-/* function: GetMonoStereoMODE(const CHANNEL_MODE mode) */
-/* */
-/* description: Determines encoder setting from channel mode. */
-/* Multichannel modes are mapped to mono or stereo modes */
-/* returns MODE_MONO in case of mono, */
-/* MODE_STEREO in case of stereo */
-/* MODE_INVALID in case of error */
-/* */
-/* input: CHANNEL_MODE mode: Encoder mode (see qc_data.h). */
-/* output: return: CM_STEREO_MODE monoStereoSetting */
-/* (MODE_INVALID: error, */
-/* MODE_MONO: mono */
-/* MODE_STEREO: stereo). */
-/* */
-/* misc: No memory is allocated. */
-/* */
-/********************************************************************************/
-
-ELEMENT_MODE FDKaacEnc_GetMonoStereoMode(const CHANNEL_MODE mode){
-
- ELEMENT_MODE monoStereoSetting = EL_MODE_INVALID;
-
- switch(mode){
- case MODE_1: /* mono setups */
- monoStereoSetting = EL_MODE_MONO;
- break;
- case MODE_2: /* stereo setups */
- case MODE_1_2:
- case MODE_1_2_1:
- case MODE_1_2_2:
- case MODE_1_2_2_1:
- case MODE_1_2_2_2_1:
- case MODE_7_1_REAR_SURROUND:
- case MODE_7_1_FRONT_CENTER:
- monoStereoSetting = EL_MODE_STEREO;
- break;
- default: /* error */
- monoStereoSetting = EL_MODE_INVALID;
- break;
- }
-
- return monoStereoSetting;
-}
-
-const CHANNEL_MODE_CONFIG_TAB* FDKaacEnc_GetChannelModeConfiguration(const CHANNEL_MODE mode)
-{
- INT i;
- const CHANNEL_MODE_CONFIG_TAB *cm_config = NULL;
-
- /* get channel mode config */
- for (i=0; i<(INT)sizeof(channelModeConfig)/(INT)sizeof(CHANNEL_MODE_CONFIG_TAB); i++) {
- if (channelModeConfig[i].encMode==mode)
- {
- cm_config = &channelModeConfig[i];
- break;
- }
- }
- return cm_config;
-}
diff --git a/libAACenc/src/channel_map.h b/libAACenc/src/channel_map.h
deleted file mode 100644
index 2cfb486..0000000
--- a/libAACenc/src/channel_map.h
+++ /dev/null
@@ -1,132 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/************************* Fast MPEG AAC Audio Encoder **********************
-
- Initial author: A. Groeschel
- contents/description: channel mapping functionality
-
-******************************************************************************/
-
-#ifndef _CHANNEL_MAP_H
-#define _CHANNEL_MAP_H
-
-
-#include "aacenc.h"
-#include "psy_const.h"
-#include "qc_data.h"
-
-typedef struct {
- CHANNEL_MODE encMode;
- INT nChannels;
- INT nChannelsEff;
- INT nElements;
-} CHANNEL_MODE_CONFIG_TAB;
-
-
-/* Element mode */
-typedef enum {
- EL_MODE_INVALID = 0,
- EL_MODE_MONO,
- EL_MODE_STEREO
-} ELEMENT_MODE;
-
-
-AAC_ENCODER_ERROR FDKaacEnc_DetermineEncoderMode(CHANNEL_MODE* mode,
- INT nChannels);
-
-AAC_ENCODER_ERROR FDKaacEnc_InitChannelMapping(CHANNEL_MODE mode,
- CHANNEL_ORDER co,
- CHANNEL_MAPPING* chMap);
-
-AAC_ENCODER_ERROR FDKaacEnc_InitElementBits(QC_STATE *hQC,
- CHANNEL_MAPPING *cm,
- INT bitrateTot,
- INT averageBitsTot,
- INT maxChannelBits);
-
-ELEMENT_MODE FDKaacEnc_GetMonoStereoMode(const CHANNEL_MODE mode);
-
-const CHANNEL_MODE_CONFIG_TAB* FDKaacEnc_GetChannelModeConfiguration(const CHANNEL_MODE mode);
-
-#endif /* CHANNEL_MAP_H */
diff --git a/libAACenc/src/chaosmeasure.cpp b/libAACenc/src/chaosmeasure.cpp
deleted file mode 100644
index 4e56e9e..0000000
--- a/libAACenc/src/chaosmeasure.cpp
+++ /dev/null
@@ -1,161 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M. Werner
- contents/description: Chaos measure calculation
-
-******************************************************************************/
-
-#include "chaosmeasure.h"
-
-/*****************************************************************************
- functionname: FDKaacEnc_FDKaacEnc_CalculateChaosMeasurePeakFast
- description: Eberlein method of chaos measure calculation by high-pass
- filtering amplitude spectrum
- A special case of FDKaacEnc_CalculateChaosMeasureTonalGeneric --
- highly optimized
-*****************************************************************************/
-static void
-FDKaacEnc_FDKaacEnc_CalculateChaosMeasurePeakFast( FIXP_DBL *RESTRICT paMDCTDataNM0,
- INT numberOfLines,
- FIXP_DBL *RESTRICT chaosMeasure )
-{
- INT i, j;
-
- /* calculate chaos measure by "peak filter" */
- for (i=0; i<2; i++) {
- /* make even and odd pass through data */
- FIXP_DBL left,center; /* left, center tap of filter */
-
- left = (FIXP_DBL)((LONG)paMDCTDataNM0[i]^((LONG)paMDCTDataNM0[i]>>(DFRACT_BITS-1)));
- center = (FIXP_DBL)((LONG)paMDCTDataNM0[i+2]^((LONG)paMDCTDataNM0[i+2]>>(DFRACT_BITS-1)));
-
- for (j = i+2; j < numberOfLines - 2; j+=2) {
- FIXP_DBL right = (FIXP_DBL)((LONG)paMDCTDataNM0[j+2]^((LONG)paMDCTDataNM0[j+2]>>(DFRACT_BITS-1)));
- FIXP_DBL tmp = (left>>1)+(right>>1);
-
- if (tmp < center ) {
- INT leadingBits = CntLeadingZeros(center)-1;
- tmp = schur_div(tmp<<leadingBits, center<<leadingBits, 8);
- chaosMeasure[j] = fMult(tmp,tmp);
- }
- else {
- chaosMeasure[j] = (FIXP_DBL)MAXVAL_DBL;
- }
-
- left = center;
- center = right;
- }
- }
-
- /* provide chaos measure for first few lines */
- chaosMeasure[0] = chaosMeasure[2];
- chaosMeasure[1] = chaosMeasure[2];
-
- /* provide chaos measure for last few lines */
- for (i = (numberOfLines-3); i < numberOfLines; i++)
- chaosMeasure[i] = FL2FXCONST_DBL(0.5);
-}
-
-
-/*****************************************************************************
- functionname: FDKaacEnc_CalculateChaosMeasure
- description: calculates a chaosmeasure for every line, different methods
- are available. 0 means tonal, 1 means noiselike
- returns:
- input: MDCT data, number of lines
- output: chaosMeasure
-*****************************************************************************/
-void
-FDKaacEnc_CalculateChaosMeasure( FIXP_DBL *paMDCTDataNM0,
- INT numberOfLines,
- FIXP_DBL *chaosMeasure )
-
-{
- FDKaacEnc_FDKaacEnc_CalculateChaosMeasurePeakFast( paMDCTDataNM0,
- numberOfLines,
- chaosMeasure );
-}
-
diff --git a/libAACenc/src/chaosmeasure.h b/libAACenc/src/chaosmeasure.h
deleted file mode 100644
index 44301c5..0000000
--- a/libAACenc/src/chaosmeasure.h
+++ /dev/null
@@ -1,103 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M. Werner
- contents/description: Chaos measure calculation
-
-******************************************************************************/
-
-#ifndef __CHAOSMEASURE_H
-#define __CHAOSMEASURE_H
-
-#include "common_fix.h"
-
-#include "psy_const.h"
-
-void
-FDKaacEnc_CalculateChaosMeasure( FIXP_DBL *paMDCTDataNM0,
- INT numberOfLines,
- FIXP_DBL *chaosMeasure );
-
-#endif
diff --git a/libAACenc/src/dyn_bits.cpp b/libAACenc/src/dyn_bits.cpp
deleted file mode 100644
index 3105fb4..0000000
--- a/libAACenc/src/dyn_bits.cpp
+++ /dev/null
@@ -1,807 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M.Werner
- contents/description: Noiseless coder module
-
-******************************************************************************/
-
-#include "dyn_bits.h"
-#include "bit_cnt.h"
-#include "psy_const.h"
-#include "aacenc_pns.h"
-#include "aacEnc_ram.h"
-#include "aacEnc_rom.h"
-
-typedef INT (*lookUpTable)[CODE_BOOK_ESC_NDX + 1];
-
-static INT FDKaacEnc_getSideInfoBits(
- const SECTION_INFO* const huffsection,
- const SHORT* const sideInfoTab,
- const INT useHCR
- )
-{
- INT sideInfoBits;
-
- if ( useHCR && ((huffsection->codeBook == 11) || (huffsection->codeBook >= 16)) ) {
- sideInfoBits = 5;
- }
- else {
- sideInfoBits = sideInfoTab[huffsection->sfbCnt];
- }
-
- return (sideInfoBits);
-}
-
-/* count bits using all possible tables */
-static void FDKaacEnc_buildBitLookUp(
- const SHORT* const quantSpectrum,
- const INT maxSfb,
- const INT* const sfbOffset,
- const UINT* const sfbMax,
- INT bitLookUp[MAX_SFB_LONG][CODE_BOOK_ESC_NDX + 1],
- SECTION_INFO* const huffsection
- )
-{
- INT i, sfbWidth;
-
- for (i = 0; i < maxSfb; i++)
- {
- huffsection[i].sfbCnt = 1;
- huffsection[i].sfbStart = i;
- huffsection[i].sectionBits = INVALID_BITCOUNT;
- huffsection[i].codeBook = -1;
- sfbWidth = sfbOffset[i + 1] - sfbOffset[i];
- FDKaacEnc_bitCount(quantSpectrum + sfbOffset[i], sfbWidth, sfbMax[i], bitLookUp[i]);
- }
-}
-
-/* essential helper functions */
-static INT FDKaacEnc_findBestBook(
- const INT* const bc,
- INT* const book,
- const INT useVCB11
- )
-{
- INT minBits = INVALID_BITCOUNT, j;
-
- int end = CODE_BOOK_ESC_NDX;
-
-
- for (j = 0; j <= end; j++)
- {
- if (bc[j] < minBits)
- {
- minBits = bc[j];
- *book = j;
- }
- }
- return (minBits);
-}
-
-static INT FDKaacEnc_findMinMergeBits(
- const INT* const bc1,
- const INT* const bc2,
- const INT useVCB11
- )
-{
- INT minBits = INVALID_BITCOUNT, j;
-
- int end = CODE_BOOK_ESC_NDX;
-
-
- for (j = 0; j <= end; j++)
- {
- if (bc1[j] + bc2[j] < minBits)
- {
- minBits = bc1[j] + bc2[j];
- }
- }
- return (minBits);
-}
-
-static void FDKaacEnc_mergeBitLookUp(
- INT* const bc1,
- const INT* const bc2
- )
-{
- int j;
-
- for (j = 0; j <= CODE_BOOK_ESC_NDX; j++)
- {
- bc1[j] = fixMin(bc1[j] + bc2[j], INVALID_BITCOUNT);
- }
-}
-
-static INT FDKaacEnc_findMaxMerge(
- const INT* const mergeGainLookUp,
- const SECTION_INFO* const huffsection,
- const INT maxSfb,
- INT* const maxNdx
- )
-{
- INT i, maxMergeGain = 0;
-
- for (i = 0; i + huffsection[i].sfbCnt < maxSfb; i += huffsection[i].sfbCnt)
- {
- if (mergeGainLookUp[i] > maxMergeGain)
- {
- maxMergeGain = mergeGainLookUp[i];
- *maxNdx = i;
- }
- }
- return (maxMergeGain);
-}
-
-static INT FDKaacEnc_CalcMergeGain(
- const SECTION_INFO* const huffsection,
- const INT bitLookUp[MAX_SFB_LONG][CODE_BOOK_ESC_NDX + 1],
- const SHORT* const sideInfoTab,
- const INT ndx1,
- const INT ndx2,
- const INT useVCB11
- )
-{
- INT MergeGain, MergeBits, SplitBits;
-
- MergeBits = sideInfoTab[huffsection[ndx1].sfbCnt + huffsection[ndx2].sfbCnt] + FDKaacEnc_findMinMergeBits(bitLookUp[ndx1], bitLookUp[ndx2], useVCB11);
- SplitBits = huffsection[ndx1].sectionBits + huffsection[ndx2].sectionBits; /* Bit amount for splitted huffsections */
- MergeGain = SplitBits - MergeBits;
-
- if ( (huffsection[ndx1].codeBook==CODE_BOOK_PNS_NO)||(huffsection[ndx2].codeBook==CODE_BOOK_PNS_NO)
- || (huffsection[ndx1].codeBook==CODE_BOOK_IS_OUT_OF_PHASE_NO)||(huffsection[ndx2].codeBook==CODE_BOOK_IS_OUT_OF_PHASE_NO)
- || (huffsection[ndx1].codeBook==CODE_BOOK_IS_IN_PHASE_NO)||(huffsection[ndx2].codeBook==CODE_BOOK_IS_IN_PHASE_NO)
- )
- {
- MergeGain = -1;
- }
-
- return (MergeGain);
-}
-
-
-/* sectioning Stage 0:find minimum codbooks */
-static void FDKaacEnc_gmStage0(
- SECTION_INFO* const RESTRICT huffsection,
- const INT bitLookUp[MAX_SFB_LONG][CODE_BOOK_ESC_NDX + 1],
- const INT maxSfb,
- const INT* const noiseNrg,
- const INT* const isBook
- )
-{
- INT i;
-
- for (i = 0; i < maxSfb; i++)
- {
- /* Side-Info bits will be calculated in Stage 1! */
- if (huffsection[i].sectionBits == INVALID_BITCOUNT)
- {
- /* intensity and pns codebooks are already allocated in bitcount.c */
- if(noiseNrg[i] != NO_NOISE_PNS){
- huffsection[i].codeBook=CODE_BOOK_PNS_NO;
- huffsection[i].sectionBits = 0;
- }
- else if( isBook[i] ) {
- huffsection[i].codeBook=isBook[i];
- huffsection[i].sectionBits = 0;
- }
- else {
- huffsection[i].sectionBits = FDKaacEnc_findBestBook(bitLookUp[i], &(huffsection[i].codeBook), 0); /* useVCB11 must be 0!!! */
- }
- }
- }
-}
-
-/*
- sectioning Stage 1:merge all connected regions with the same code book and
- calculate side info
- */
-static void FDKaacEnc_gmStage1(
- SECTION_INFO* const RESTRICT huffsection,
- INT bitLookUp[MAX_SFB_LONG][CODE_BOOK_ESC_NDX + 1],
- const INT maxSfb,
- const SHORT* const sideInfoTab,
- const INT useVCB11
- )
-{
- INT mergeStart = 0, mergeEnd;
-
- do
- {
- for (mergeEnd = mergeStart + 1; mergeEnd < maxSfb; mergeEnd++)
- {
- if (huffsection[mergeStart].codeBook != huffsection[mergeEnd].codeBook)
- break;
-
-
- /* we can merge. update tables, side info bits will be updated outside of this loop */
- huffsection[mergeStart].sfbCnt++;
- huffsection[mergeStart].sectionBits += huffsection[mergeEnd].sectionBits;
-
- /* update bit look up for all code books */
- FDKaacEnc_mergeBitLookUp(bitLookUp[mergeStart], bitLookUp[mergeEnd]);
- }
-
- /* add side info info bits */
- huffsection[mergeStart].sectionBits += FDKaacEnc_getSideInfoBits(&huffsection[mergeStart], sideInfoTab, useVCB11);
- huffsection[mergeEnd - 1].sfbStart = huffsection[mergeStart].sfbStart; /* speed up prev search */
-
- mergeStart = mergeEnd;
-
- } while (mergeStart < maxSfb);
-}
-
-/*
- sectioning Stage 2:greedy merge algorithm, merge connected sections with
- maximum bit gain until no more gain is possible
- */
-static void
-FDKaacEnc_gmStage2(
- SECTION_INFO* const RESTRICT huffsection,
- INT* const RESTRICT mergeGainLookUp,
- INT bitLookUp[MAX_SFB_LONG][CODE_BOOK_ESC_NDX + 1],
- const INT maxSfb,
- const SHORT* const sideInfoTab,
- const INT useVCB11
- )
-{
- INT i;
-
- for (i = 0; i + huffsection[i].sfbCnt < maxSfb; i += huffsection[i].sfbCnt)
- {
- mergeGainLookUp[i] = FDKaacEnc_CalcMergeGain(huffsection,
- bitLookUp,
- sideInfoTab,
- i,
- i + huffsection[i].sfbCnt,
- useVCB11);
- }
-
- while (TRUE)
- {
- INT maxMergeGain, maxNdx = 0, maxNdxNext, maxNdxLast;
-
- maxMergeGain = FDKaacEnc_findMaxMerge(mergeGainLookUp, huffsection, maxSfb, &maxNdx);
-
- /* exit while loop if no more gain is possible */
- if (maxMergeGain <= 0)
- break;
-
- maxNdxNext = maxNdx + huffsection[maxNdx].sfbCnt;
-
- /* merge sections with maximum bit gain */
- huffsection[maxNdx].sfbCnt += huffsection[maxNdxNext].sfbCnt;
- huffsection[maxNdx].sectionBits += huffsection[maxNdxNext].sectionBits - maxMergeGain;
-
- /* update bit look up table for merged huffsection */
- FDKaacEnc_mergeBitLookUp(bitLookUp[maxNdx], bitLookUp[maxNdxNext]);
-
- /* update mergeLookUpTable */
- if (maxNdx != 0)
- {
- maxNdxLast = huffsection[maxNdx - 1].sfbStart;
- mergeGainLookUp[maxNdxLast] = FDKaacEnc_CalcMergeGain(huffsection,
- bitLookUp,
- sideInfoTab,
- maxNdxLast,
- maxNdx,
- useVCB11);
-
- }
- maxNdxNext = maxNdx + huffsection[maxNdx].sfbCnt;
-
- huffsection[maxNdxNext - 1].sfbStart = huffsection[maxNdx].sfbStart;
-
- if (maxNdxNext < maxSfb)
- mergeGainLookUp[maxNdx] = FDKaacEnc_CalcMergeGain(huffsection,
- bitLookUp,
- sideInfoTab,
- maxNdx,
- maxNdxNext,
- useVCB11);
-
- }
-}
-
-/* count bits used by the noiseless coder */
-static void FDKaacEnc_noiselessCounter(
- SECTION_DATA* const RESTRICT sectionData,
- INT mergeGainLookUp[MAX_SFB_LONG],
- INT bitLookUp[MAX_SFB_LONG][CODE_BOOK_ESC_NDX + 1],
- const SHORT* const quantSpectrum,
- const UINT* const maxValueInSfb,
- const INT* const sfbOffset,
- const INT blockType,
- const INT* const noiseNrg,
- const INT* const isBook,
- const INT useVCB11
- )
-{
- INT grpNdx, i;
- const SHORT *sideInfoTab = NULL;
- SECTION_INFO *huffsection;
-
- /* use appropriate side info table */
- switch (blockType)
- {
- case LONG_WINDOW:
- case START_WINDOW:
- case STOP_WINDOW:
- sideInfoTab = FDKaacEnc_sideInfoTabLong;
- break;
- case SHORT_WINDOW:
- sideInfoTab = FDKaacEnc_sideInfoTabShort;
- break;
- }
-
- FDK_ASSERT(sideInfoTab != NULL);
-
- sectionData->noOfSections = 0;
- sectionData->huffmanBits = 0;
- sectionData->sideInfoBits = 0;
-
-
- if (sectionData->maxSfbPerGroup == 0)
- return;
-
- /* loop trough groups */
- for (grpNdx = 0; grpNdx < sectionData->sfbCnt; grpNdx += sectionData->sfbPerGroup)
- {
- huffsection = sectionData->huffsection + sectionData->noOfSections;
-
- /* count bits in this group */
- FDKaacEnc_buildBitLookUp(quantSpectrum,
- sectionData->maxSfbPerGroup,
- sfbOffset + grpNdx,
- maxValueInSfb + grpNdx,
- bitLookUp,
- huffsection);
-
- /* 0.Stage :Find minimum Codebooks */
- FDKaacEnc_gmStage0(huffsection, bitLookUp, sectionData->maxSfbPerGroup, noiseNrg+grpNdx, isBook+grpNdx);
-
- /* 1.Stage :Merge all connected regions with the same code book */
- FDKaacEnc_gmStage1(huffsection, bitLookUp, sectionData->maxSfbPerGroup, sideInfoTab, useVCB11);
-
-
- /*
- 2.Stage
- greedy merge algorithm, merge connected huffsections with maximum bit
- gain until no more gain is possible
- */
-
- FDKaacEnc_gmStage2(huffsection,
- mergeGainLookUp,
- bitLookUp,
- sectionData->maxSfbPerGroup,
- sideInfoTab,
- useVCB11);
-
-
-
- /*
- compress output, calculate total huff and side bits
- since we did not update the actual codebook in stage 2
- to save time, we must set it here for later use in bitenc
- */
-
- for (i = 0; i < sectionData->maxSfbPerGroup; i += huffsection[i].sfbCnt)
- {
- if ((huffsection[i].codeBook==CODE_BOOK_PNS_NO) ||
- (huffsection[i].codeBook==CODE_BOOK_IS_OUT_OF_PHASE_NO) ||
- (huffsection[i].codeBook==CODE_BOOK_IS_IN_PHASE_NO))
- {
- huffsection[i].sectionBits=0;
- } else {
- /* the sections in the sectionData are now marked with the optimal code book */
-
- FDKaacEnc_findBestBook(bitLookUp[i], &(huffsection[i].codeBook), useVCB11);
-
- sectionData->huffmanBits += huffsection[i].sectionBits - FDKaacEnc_getSideInfoBits(&huffsection[i], sideInfoTab, useVCB11);
- }
-
- huffsection[i].sfbStart += grpNdx;
-
- /* sum up side info bits (section data bits) */
- sectionData->sideInfoBits += FDKaacEnc_getSideInfoBits(&huffsection[i], sideInfoTab, useVCB11);
- sectionData->huffsection[sectionData->noOfSections++] = huffsection[i];
- }
- }
-}
-
-
-/*******************************************************************************
-
- functionname: FDKaacEnc_scfCount
- returns : ---
- description : count bits used by scalefactors.
-
- not in all cases if maxValueInSfb[] == 0 we set deltaScf
- to zero. only if the difference of the last and future
- scalefacGain is not greater then CODE_BOOK_SCF_LAV (60).
-
- example:
- ^
- scalefacGain |
- |
- | last 75
- | |
- | |
- | |
- | | current 50
- | | |
- | | |
- | | |
- | | |
- | | | future 5
- | | | |
- --- ... ---------------------------- ... --------->
- sfb
-
-
- if maxValueInSfb[] of current is zero because of a
- notfallstrategie, we do not save bits and transmit a
- deltaScf of 25. otherwise the deltaScf between the last
- scalfacGain (75) and the future scalefacGain (5) is 70.
-
-********************************************************************************/
-static void FDKaacEnc_scfCount(
- const INT* const scalefacGain,
- const UINT* const maxValueInSfb,
- SECTION_DATA* const RESTRICT sectionData,
- const INT* const isScale
- )
-{
- INT i, j, k, m, n;
-
- INT lastValScf = 0;
- INT deltaScf = 0;
- INT found = 0;
- INT scfSkipCounter = 0;
- INT lastValIs = 0;
-
- sectionData->scalefacBits = 0;
-
- if (scalefacGain == NULL)
- return;
-
- sectionData->firstScf = 0;
-
- for (i=0; i<sectionData->noOfSections; i++)
- {
- if (sectionData->huffsection[i].codeBook != CODE_BOOK_ZERO_NO)
- {
- sectionData->firstScf = sectionData->huffsection[i].sfbStart;
- lastValScf = scalefacGain[sectionData->firstScf];
- break;
- }
- }
-
- for (i=0; i<sectionData->noOfSections; i++)
- {
- if ((sectionData->huffsection[i].codeBook == CODE_BOOK_IS_OUT_OF_PHASE_NO) ||
- (sectionData->huffsection[i].codeBook == CODE_BOOK_IS_IN_PHASE_NO))
- {
- for (j = sectionData->huffsection[i].sfbStart;
- j < sectionData->huffsection[i].sfbStart + sectionData->huffsection[i].sfbCnt;
- j++)
- {
- INT deltaIs = isScale[j]-lastValIs;
- lastValIs = isScale[j];
- sectionData->scalefacBits+=FDKaacEnc_bitCountScalefactorDelta(deltaIs);
- }
- } /* Intensity */
- else if ((sectionData->huffsection[i].codeBook != CODE_BOOK_ZERO_NO) &&
- (sectionData->huffsection[i].codeBook != CODE_BOOK_PNS_NO))
- {
- INT tmp = sectionData->huffsection[i].sfbStart + sectionData->huffsection[i].sfbCnt;
- for (j = sectionData->huffsection[i].sfbStart; j<tmp; j++)
- {
- /* check if we can repeat the last value to save bits */
- if (maxValueInSfb[j] == 0)
- {
- found = 0;
- /* are scalefactors skipped? */
- if (scfSkipCounter == 0)
- {
- /* end of section */
- if (j == (tmp - 1) )
- found = 0; /* search in other sections for maxValueInSfb != 0 */
- else
- {
- /* search in this section for the next maxValueInSfb[] != 0 */
- for (k = (j+1); k < tmp; k++)
- {
- if (maxValueInSfb[k] != 0)
- {
- found = 1;
- if ( (fixp_abs(scalefacGain[k] - lastValScf)) <= CODE_BOOK_SCF_LAV)
- deltaScf = 0; /* save bits */
- else
- {
- /* do not save bits */
- deltaScf = lastValScf - scalefacGain[j];
- lastValScf = scalefacGain[j];
- scfSkipCounter = 0;
- }
- break;
- }
- /* count scalefactor skip */
- scfSkipCounter++;
- }
- }
-
- /* search for the next maxValueInSfb[] != 0 in all other sections */
- for (m=(i+1); (m < sectionData->noOfSections) && (found == 0); m++)
- {
- if ((sectionData->huffsection[m].codeBook != CODE_BOOK_ZERO_NO) && (sectionData->huffsection[m].codeBook != CODE_BOOK_PNS_NO))
- {
- INT end = sectionData->huffsection[m].sfbStart + sectionData->huffsection[m].sfbCnt;
- for (n = sectionData->huffsection[m].sfbStart; n<end; n++)
- {
- if (maxValueInSfb[n] != 0)
- {
- found = 1;
- if (fixp_abs(scalefacGain[n] - lastValScf) <= CODE_BOOK_SCF_LAV)
- deltaScf = 0; /* save bits */
- else
- {
- /* do not save bits */
- deltaScf = lastValScf - scalefacGain[j];
- lastValScf = scalefacGain[j];
- scfSkipCounter = 0;
- }
- break;
- }
- /* count scalefactor skip */
- scfSkipCounter++;
- }
- }
- }
- /* no maxValueInSfb[] != 0 found */
- if (found == 0)
- {
- deltaScf = 0;
- scfSkipCounter = 0;
- }
- }
- else {
- /* consider skipped scalefactors */
- deltaScf = 0;
- scfSkipCounter--;
- }
- }
- else {
- deltaScf = lastValScf - scalefacGain[j];
- lastValScf = scalefacGain[j];
- }
- sectionData->scalefacBits += FDKaacEnc_bitCountScalefactorDelta(deltaScf);
- }
- }
- } /* for (i=0; i<sectionData->noOfSections; i++) */
-}
-
-#ifdef PNS_PRECOUNT_ENABLE
-/*
- preCount bits used pns
-*/
-/* estimate bits used by pns for correction of static bits */
-/* no codebook switch estimation, see AAC LD FASTENC */
-INT noisePreCount(const INT *noiseNrg, INT maxSfb)
-{
- INT noisePCMFlag = TRUE;
- INT lastValPns = 0, deltaPns;
- int i, bits=0;
-
- for (i = 0; i < maxSfb; i++) {
- if (noiseNrg[i] != NO_NOISE_PNS) {
-
- if (noisePCMFlag) {
- bits+=PNS_PCM_BITS;
- lastValPns = noiseNrg[i];
- noisePCMFlag = FALSE;
- }else {
- deltaPns = noiseNrg[i]-lastValPns;
- lastValPns = noiseNrg[i];
- bits+=FDKaacEnc_bitCountScalefactorDelta(deltaPns);
- }
- }
- }
- return ( bits );
-}
-#endif /* PNS_PRECOUNT_ENABLE */
-
-/* count bits used by pns */
-static void FDKaacEnc_noiseCount(
- SECTION_DATA* const RESTRICT sectionData,
- const INT* const noiseNrg
- )
-{
- INT noisePCMFlag = TRUE;
- INT lastValPns = 0, deltaPns;
- int i, j;
-
- sectionData->noiseNrgBits = 0;
-
- for (i = 0; i < sectionData->noOfSections; i++) {
- if (sectionData->huffsection[i].codeBook == CODE_BOOK_PNS_NO) {
- int sfbStart = sectionData->huffsection[i].sfbStart;
- int sfbEnd = sfbStart + sectionData->huffsection[i].sfbCnt;
- for (j=sfbStart; j<sfbEnd; j++) {
-
- if (noisePCMFlag) {
- sectionData->noiseNrgBits+=PNS_PCM_BITS;
- lastValPns = noiseNrg[j];
- noisePCMFlag = FALSE;
- } else {
- deltaPns = noiseNrg[j]-lastValPns;
- lastValPns = noiseNrg[j];
- sectionData->noiseNrgBits+=FDKaacEnc_bitCountScalefactorDelta(deltaPns);
- }
- }
- }
- }
-}
-
-INT FDKaacEnc_dynBitCount(
- BITCNTR_STATE* const hBC,
- const SHORT* const quantSpectrum,
- const UINT* const maxValueInSfb,
- const INT* const scalefac,
- const INT blockType,
- const INT sfbCnt,
- const INT maxSfbPerGroup,
- const INT sfbPerGroup,
- const INT* const sfbOffset,
- SECTION_DATA* const RESTRICT sectionData,
- const INT* const noiseNrg,
- const INT* const isBook,
- const INT* const isScale,
- const UINT syntaxFlags
- )
-{
- sectionData->blockType = blockType;
- sectionData->sfbCnt = sfbCnt;
- sectionData->sfbPerGroup = sfbPerGroup;
- sectionData->noOfGroups = sfbCnt / sfbPerGroup;
- sectionData->maxSfbPerGroup = maxSfbPerGroup;
-
- FDKaacEnc_noiselessCounter(
- sectionData,
- hBC->mergeGainLookUp,
- (lookUpTable)hBC->bitLookUp,
- quantSpectrum,
- maxValueInSfb,
- sfbOffset,
- blockType,
- noiseNrg,
- isBook,
- (syntaxFlags & AC_ER_VCB11)?1:0);
-
- FDKaacEnc_scfCount(
- scalefac,
- maxValueInSfb,
- sectionData,
- isScale);
-
- FDKaacEnc_noiseCount(sectionData,
- noiseNrg);
-
- return (sectionData->huffmanBits +
- sectionData->sideInfoBits +
- sectionData->scalefacBits +
- sectionData->noiseNrgBits);
-}
-
-INT FDKaacEnc_BCNew(BITCNTR_STATE **phBC
- ,UCHAR* dynamic_RAM
- )
-{
- BITCNTR_STATE *hBC = GetRam_aacEnc_BitCntrState();
-
- if (hBC)
- {
- *phBC = hBC;
- hBC->bitLookUp = GetRam_aacEnc_BitLookUp(0,dynamic_RAM);
- hBC->mergeGainLookUp = GetRam_aacEnc_MergeGainLookUp(0,dynamic_RAM);
- if (hBC->bitLookUp == 0 ||
- hBC->mergeGainLookUp == 0)
- {
- return 1;
- }
- }
- return (hBC == 0) ? 1 : 0;
-}
-
-void FDKaacEnc_BCClose(BITCNTR_STATE **phBC)
-{
- if (*phBC!=NULL) {
-
- FreeRam_aacEnc_BitCntrState(phBC);
- }
-}
-
-
-
diff --git a/libAACenc/src/dyn_bits.h b/libAACenc/src/dyn_bits.h
deleted file mode 100644
index ae78a4c..0000000
--- a/libAACenc/src/dyn_bits.h
+++ /dev/null
@@ -1,167 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M.Werner
- contents/description: Noiseless coder module
-
-******************************************************************************/
-
-#ifndef __DYN_BITS_H
-#define __DYN_BITS_H
-
-#include "common_fix.h"
-
-#include "psy_const.h"
-#include "aacenc_tns.h"
-
-#define MAX_SECTIONS MAX_GROUPED_SFB
-#define SECT_ESC_VAL_LONG 31
-#define SECT_ESC_VAL_SHORT 7
-#define CODE_BOOK_BITS 4
-#define SECT_BITS_LONG 5
-#define SECT_BITS_SHORT 3
-#define PNS_PCM_BITS 9
-
-typedef struct
-{
- INT codeBook;
- INT sfbStart;
- INT sfbCnt;
- INT sectionBits; /* huff + si ! */
-} SECTION_INFO;
-
-
-typedef struct
-{
- INT blockType;
- INT noOfGroups;
- INT sfbCnt;
- INT maxSfbPerGroup;
- INT sfbPerGroup;
- INT noOfSections;
- SECTION_INFO huffsection[MAX_SECTIONS];
- INT sideInfoBits; /* sectioning bits */
- INT huffmanBits; /* huffman coded bits */
- INT scalefacBits; /* scalefac coded bits */
- INT noiseNrgBits; /* noiseEnergy coded bits */
- INT firstScf; /* first scf to be coded */
-} SECTION_DATA;
-
-
-struct BITCNTR_STATE
-{
- INT *bitLookUp;
- INT *mergeGainLookUp;
-};
-
-
-INT FDKaacEnc_BCNew(BITCNTR_STATE **phBC
- ,UCHAR* dynamic_RAM
- );
-
-void FDKaacEnc_BCClose(BITCNTR_STATE **phBC);
-
-#if defined(PNS_PRECOUNT_ENABLE)
-INT noisePreCount(const INT *noiseNrg, INT maxSfb);
-#endif
-
-INT FDKaacEnc_dynBitCount(
- BITCNTR_STATE* const hBC,
- const SHORT* const quantSpectrum,
- const UINT* const maxValueInSfb,
- const INT* const scalefac,
- const INT blockType,
- const INT sfbCnt,
- const INT maxSfbPerGroup,
- const INT sfbPerGroup,
- const INT* const sfbOffset,
- SECTION_DATA* const RESTRICT sectionData,
- const INT* const noiseNrg,
- const INT* const isBook,
- const INT* const isScale,
- const UINT syntaxFlags
- );
-
-#endif
diff --git a/libAACenc/src/grp_data.cpp b/libAACenc/src/grp_data.cpp
deleted file mode 100644
index 465865f..0000000
--- a/libAACenc/src/grp_data.cpp
+++ /dev/null
@@ -1,272 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M.Werner
- contents/description: Short block grouping
-
-******************************************************************************/
-#include "psy_const.h"
-#include "interface.h"
-
-/*
-* this routine does not work in-place
-*/
-
-static inline FIXP_DBL nrgAddSaturate(const FIXP_DBL a, const FIXP_DBL b) {
- return ( (a>=(FIXP_DBL)MAXVAL_DBL-b) ? (FIXP_DBL)MAXVAL_DBL : (a + b) );
-}
-
-void
-FDKaacEnc_groupShortData(FIXP_DBL *mdctSpectrum, /* in-out */
- SFB_THRESHOLD *sfbThreshold, /* in-out */
- SFB_ENERGY *sfbEnergy, /* in-out */
- SFB_ENERGY *sfbEnergyMS, /* in-out */
- SFB_ENERGY *sfbSpreadEnergy,
- const INT sfbCnt,
- const INT sfbActive,
- const INT *sfbOffset,
- const FIXP_DBL *sfbMinSnrLdData,
- INT *groupedSfbOffset, /* out */
- INT *maxSfbPerGroup, /* out */
- FIXP_DBL *groupedSfbMinSnrLdData,
- const INT noOfGroups,
- const INT *groupLen,
- const INT granuleLength)
-{
- INT i,j;
- INT line; /* counts through lines */
- INT sfb; /* counts through scalefactor bands */
- INT grp; /* counts through groups */
- INT wnd; /* counts through windows in a group */
- INT offset; /* needed in sfbOffset grouping */
- INT highestSfb;
-
- INT granuleLength_short = granuleLength/TRANS_FAC;
-
- /* for short blocks: regroup spectrum and */
- /* group energies and thresholds according to grouping */
- C_ALLOC_SCRATCH_START(tmpSpectrum, FIXP_DBL, (1024));
-
- /* calculate maxSfbPerGroup */
- highestSfb = 0;
- for (wnd = 0; wnd < TRANS_FAC; wnd++)
- {
- for (sfb = sfbActive-1; sfb >= highestSfb; sfb--)
- {
- for (line = sfbOffset[sfb+1]-1; line >= sfbOffset[sfb]; line--)
- {
- if ( mdctSpectrum[wnd*granuleLength_short+line] != FL2FXCONST_SPC(0.0) ) break; /* this band is not completely zero */
- }
- if (line >= sfbOffset[sfb]) break; /* this band was not completely zero */
- }
- highestSfb = fixMax(highestSfb, sfb);
- }
- highestSfb = highestSfb > 0 ? highestSfb : 0;
- *maxSfbPerGroup = highestSfb+1;
-
- /* calculate groupedSfbOffset */
- i = 0;
- offset = 0;
- for (grp = 0; grp < noOfGroups; grp++)
- {
- for (sfb = 0; sfb < sfbActive+1; sfb++)
- {
- groupedSfbOffset[i++] = offset + sfbOffset[sfb] * groupLen[grp];
- }
- i += sfbCnt-sfb;
- offset += groupLen[grp] * granuleLength_short;
- }
- groupedSfbOffset[i++] = granuleLength;
-
- /* calculate groupedSfbMinSnr */
- i = 0;
- for (grp = 0; grp < noOfGroups; grp++)
- {
- for (sfb = 0; sfb < sfbActive; sfb++)
- {
- groupedSfbMinSnrLdData[i++] = sfbMinSnrLdData[sfb];
- }
- i += sfbCnt-sfb;
- }
-
- /* sum up sfbThresholds */
- wnd = 0;
- i = 0;
- for (grp = 0; grp < noOfGroups; grp++)
- {
- for (sfb = 0; sfb < sfbActive; sfb++)
- {
- FIXP_DBL thresh = sfbThreshold->Short[wnd][sfb];
- for (j=1; j<groupLen[grp]; j++)
- {
- thresh = nrgAddSaturate(thresh, sfbThreshold->Short[wnd+j][sfb]);
- }
- sfbThreshold->Long[i++] = thresh;
- }
- i += sfbCnt-sfb;
- wnd += groupLen[grp];
- }
-
- /* sum up sfbEnergies left/right */
- wnd = 0;
- i = 0;
- for (grp = 0; grp < noOfGroups; grp++)
- {
- for (sfb = 0; sfb < sfbActive; sfb++)
- {
- FIXP_DBL energy = sfbEnergy->Short[wnd][sfb];
- for (j=1; j<groupLen[grp]; j++)
- {
- energy = nrgAddSaturate(energy, sfbEnergy->Short[wnd+j][sfb]);
- }
- sfbEnergy->Long[i++] = energy;
- }
- i += sfbCnt-sfb;
- wnd += groupLen[grp];
- }
-
- /* sum up sfbEnergies mid/side */
- wnd = 0;
- i = 0;
- for (grp = 0; grp < noOfGroups; grp++)
- {
- for (sfb = 0; sfb < sfbActive; sfb++)
- {
- FIXP_DBL energy = sfbEnergyMS->Short[wnd][sfb];
- for (j=1; j<groupLen[grp]; j++)
- {
- energy = nrgAddSaturate(energy, sfbEnergyMS->Short[wnd+j][sfb]);
- }
- sfbEnergyMS->Long[i++] = energy;
- }
- i += sfbCnt-sfb;
- wnd += groupLen[grp];
- }
-
- /* sum up sfbSpreadEnergies */
- wnd = 0;
- i = 0;
- for (grp = 0; grp < noOfGroups; grp++)
- {
- for (sfb = 0; sfb < sfbActive; sfb++)
- {
- FIXP_DBL energy = sfbSpreadEnergy->Short[wnd][sfb];
- for (j=1; j<groupLen[grp]; j++)
- {
- energy = nrgAddSaturate(energy, sfbSpreadEnergy->Short[wnd+j][sfb]);
- }
- sfbSpreadEnergy->Long[i++] = energy;
- }
- i += sfbCnt-sfb;
- wnd += groupLen[grp];
- }
-
- /* re-group spectrum */
- wnd = 0;
- i = 0;
- for (grp = 0; grp < noOfGroups; grp++)
- {
- for (sfb = 0; sfb < sfbActive; sfb++)
- {
- int width = sfbOffset[sfb+1]-sfbOffset[sfb];
- FIXP_DBL *pMdctSpectrum = &mdctSpectrum[sfbOffset[sfb]] + wnd*granuleLength_short;
- for (j = 0; j < groupLen[grp]; j++)
- {
- FIXP_DBL *pTmp = pMdctSpectrum;
- for (line = width; line > 0; line--)
- {
- tmpSpectrum[i++] = *pTmp++;
- }
- pMdctSpectrum += granuleLength_short;
- }
- }
- i += (groupLen[grp]*(sfbOffset[sfbCnt]-sfbOffset[sfb]));
- wnd += groupLen[grp];
- }
-
- FDKmemcpy(mdctSpectrum, tmpSpectrum, granuleLength*sizeof(FIXP_DBL));
-
- C_ALLOC_SCRATCH_END(tmpSpectrum, FIXP_DBL, (1024))
-}
diff --git a/libAACenc/src/grp_data.h b/libAACenc/src/grp_data.h
deleted file mode 100644
index f061855..0000000
--- a/libAACenc/src/grp_data.h
+++ /dev/null
@@ -1,115 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M.Werner
- contents/description: Short block grouping
-
-******************************************************************************/
-#ifndef __GRP_DATA_H__
-#define __GRP_DATA_H__
-
-#include "common_fix.h"
-
-#include "psy_data.h"
-
-
-void
-FDKaacEnc_groupShortData(FIXP_DBL *mdctSpectrum, /* in-out */
- SFB_THRESHOLD *sfbThreshold, /* in-out */
- SFB_ENERGY *sfbEnergy, /* in-out */
- SFB_ENERGY *sfbEnergyMS, /* in-out */
- SFB_ENERGY *sfbSpreadEnergy,
- const INT sfbCnt,
- const INT sfbActive,
- const INT *sfbOffset,
- const FIXP_DBL *sfbMinSnrLdData,
- INT *groupedSfbOffset, /* out */
- INT *maxSfbPerGroup,
- FIXP_DBL *groupedSfbMinSnrLdData,
- const INT noOfGroups,
- const INT *groupLen,
- const INT granuleLength);
-
-#endif /* _INTERFACE_H */
diff --git a/libAACenc/src/intensity.cpp b/libAACenc/src/intensity.cpp
deleted file mode 100644
index 6d807f7..0000000
--- a/libAACenc/src/intensity.cpp
+++ /dev/null
@@ -1,761 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: A. Horndasch (code originally from lwr) / Josef Hoepfl (FDK)
- contents/description: intensity stereo processing
-
-******************************************************************************/
-
-#include "intensity.h"
-#include "interface.h"
-#include "psy_configuration.h"
-#include "psy_const.h"
-#include "qc_main.h"
-#include "bit_cnt.h"
-
-/* only set an IS seed it left/right channel correlation is above IS_CORR_THRESH */
-#define IS_CORR_THRESH FL2FXCONST_DBL(0.95f)
-
-/* when expanding the IS region to more SFBs only accept an error that is
- * not more than IS_TOTAL_ERROR_THRESH overall and
- * not more than IS_LOCAL_ERROR_THRESH for the current SFB */
-#define IS_TOTAL_ERROR_THRESH FL2FXCONST_DBL(0.04f)
-#define IS_LOCAL_ERROR_THRESH FL2FXCONST_DBL(0.01f)
-
-/* the maximum allowed change of the intensity direction (unit: IS scale) - scaled with factor 0.25 - */
-#define IS_DIRECTION_DEVIATION_THRESH_SF 2
-#define IS_DIRECTION_DEVIATION_THRESH FL2FXCONST_DBL(2.0f/(1<<IS_DIRECTION_DEVIATION_THRESH_SF))
-
-/* IS regions need to have a minimal percentage of the overall loudness, e.g. 0.06 == 6% */
-#define IS_REGION_MIN_LOUDNESS FL2FXCONST_DBL(0.1f)
-
-/* only perform IS if IS_MIN_SFBS neighboring SFBs can be processed */
-#define IS_MIN_SFBS 6
-
-/* only do IS if
- * if IS_LEFT_RIGHT_RATIO_THRESH < sfbEnergyLeft[sfb]/sfbEnergyRight[sfb] < 1 / IS_LEFT_RIGHT_RATIO_THRESH
- * -> no IS if the panning angle is not far from the middle, MS will do */
-/* this is equivalent to a scale of +/-1.02914634566 */
-#define IS_LEFT_RIGHT_RATIO_THRESH FL2FXCONST_DBL(0.7f)
-
-/* scalefactor of realScale */
-#define REAL_SCALE_SF 1
-
-/* scalefactor overallLoudness */
-#define OVERALL_LOUDNESS_SF 6
-
-/* scalefactor for sum over max samples per goup */
-#define MAX_SFB_PER_GROUP_SF 6
-
-/* scalefactor for sum of mdct spectrum */
-#define MDCT_SPEC_SF 6
-
-
-typedef struct
-{
-
- FIXP_DBL corr_thresh; /*!< Only set an IS seed it left/right channel correlation is above corr_thresh */
-
- FIXP_DBL total_error_thresh; /*!< When expanding the IS region to more SFBs only accept an error that is
- not more than 'total_error_thresh' overall. */
-
- FIXP_DBL local_error_thresh; /*!< When expanding the IS region to more SFBs only accept an error that is
- not more than 'local_error_thresh' for the current SFB. */
-
- FIXP_DBL direction_deviation_thresh; /*!< The maximum allowed change of the intensity direction (unit: IS scale) */
-
- FIXP_DBL is_region_min_loudness; /*!< IS regions need to have a minimal percentage of the overall loudness, e.g. 0.06 == 6% */
-
- INT min_is_sfbs; /*!< Only perform IS if 'min_is_sfbs' neighboring SFBs can be processed */
-
- FIXP_DBL left_right_ratio_threshold; /*!< No IS if the panning angle is not far from the middle, MS will do */
-
-} INTENSITY_PARAMETERS;
-
-
-/*****************************************************************************
-
- functionname: calcSfbMaxScale
-
- description: Calc max value in scalefactor band
-
- input: *mdctSpectrum
- l1
- l2
-
- output: none
-
- returns: scalefactor
-
-*****************************************************************************/
-static INT
-calcSfbMaxScale(const FIXP_DBL *mdctSpectrum,
- const INT l1,
- const INT l2)
-{
- INT i;
- INT sfbMaxScale;
- FIXP_DBL maxSpc;
-
- maxSpc = FL2FXCONST_DBL(0.0);
- for (i=l1; i<l2; i++) {
- FIXP_DBL tmp = fixp_abs((FIXP_DBL)mdctSpectrum[i]);
- maxSpc = fixMax(maxSpc, tmp);
- }
- sfbMaxScale = (maxSpc==FL2FXCONST_DBL(0.0)) ? (DFRACT_BITS-2) : CntLeadingZeros(maxSpc)-1;
-
- return sfbMaxScale;
- }
-
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_initIsParams
-
- description: Initialization of intensity parameters
-
- input: isParams
-
- output: isParams
-
- returns: none
-
-*****************************************************************************/
-static void
-FDKaacEnc_initIsParams(INTENSITY_PARAMETERS *isParams)
-{
- isParams->corr_thresh = IS_CORR_THRESH;
- isParams->total_error_thresh = IS_TOTAL_ERROR_THRESH;
- isParams->local_error_thresh = IS_LOCAL_ERROR_THRESH;
- isParams->direction_deviation_thresh = IS_DIRECTION_DEVIATION_THRESH;
- isParams->is_region_min_loudness = IS_REGION_MIN_LOUDNESS;
- isParams->min_is_sfbs = IS_MIN_SFBS;
- isParams->left_right_ratio_threshold = IS_LEFT_RIGHT_RATIO_THRESH;
-}
-
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_prepareIntensityDecision
-
- description: Prepares intensity decision
-
- input: sfbEnergyLeft
- sfbEnergyRight
- sfbEnergyLdDataLeft
- sfbEnergyLdDataRight
- mdctSpectrumLeft
- sfbEnergyLdDataRight
- isParams
-
- output: hrrErr scale: none
- isMask scale: none
- realScale scale: LD_DATA_SHIFT + REAL_SCALE_SF
- normSfbLoudness scale: none
-
- returns: none
-
-*****************************************************************************/
-static void
-FDKaacEnc_prepareIntensityDecision(const FIXP_DBL *sfbEnergyLeft,
- const FIXP_DBL *sfbEnergyRight,
- const FIXP_DBL *sfbEnergyLdDataLeft,
- const FIXP_DBL *sfbEnergyLdDataRight,
- const FIXP_DBL *mdctSpectrumLeft,
- const FIXP_DBL *mdctSpectrumRight,
- const INTENSITY_PARAMETERS *isParams,
- FIXP_DBL *hrrErr,
- INT *isMask,
- FIXP_DBL *realScale,
- FIXP_DBL *normSfbLoudness,
- const INT sfbCnt,
- const INT sfbPerGroup,
- const INT maxSfbPerGroup,
- const INT *sfbOffset)
-{
- INT j,sfb,sfboffs;
- INT grpCounter;
-
- /* temporary variables to compute loudness */
- FIXP_DBL overallLoudness[MAX_NO_OF_GROUPS];
-
- /* temporary variables to compute correlation */
- FIXP_DBL channelCorr[MAX_GROUPED_SFB];
- FIXP_DBL ml, mr;
- FIXP_DBL prod_lr;
- FIXP_DBL square_l, square_r;
- FIXP_DBL tmp_l, tmp_r;
- FIXP_DBL inv_n;
-
- FDKmemclear(channelCorr, MAX_GROUPED_SFB*sizeof(FIXP_DBL));
- FDKmemclear(normSfbLoudness, MAX_GROUPED_SFB*sizeof(FIXP_DBL));
- FDKmemclear(overallLoudness, MAX_NO_OF_GROUPS*sizeof(FIXP_DBL));
- FDKmemclear(realScale, MAX_GROUPED_SFB*sizeof(FIXP_DBL));
-
- for (grpCounter = 0, sfboffs = 0; sfboffs < sfbCnt; sfboffs += sfbPerGroup, grpCounter++) {
- overallLoudness[grpCounter] = FL2FXCONST_DBL(0.0f);
- for (sfb = 0; sfb < maxSfbPerGroup; sfb++) {
- INT sL,sR,s;
- FIXP_DBL isValue = sfbEnergyLdDataLeft[sfb+sfboffs]-sfbEnergyLdDataRight[sfb+sfboffs];
-
- /* delimitate intensity scale value to representable range */
- realScale[sfb + sfboffs] = fixMin(FL2FXCONST_DBL(60.f/(1<<(REAL_SCALE_SF+LD_DATA_SHIFT))), fixMax(FL2FXCONST_DBL(-60.f/(1<<(REAL_SCALE_SF+LD_DATA_SHIFT))), isValue));
-
- sL = fixMax(0,(CntLeadingZeros(sfbEnergyLeft[sfb + sfboffs])-1));
- sR = fixMax(0,(CntLeadingZeros(sfbEnergyRight[sfb + sfboffs])-1));
- s = (fixMin(sL,sR)>>2)<<2;
- normSfbLoudness[sfb + sfboffs] = sqrtFixp(sqrtFixp(((sfbEnergyLeft[sfb + sfboffs]<<s) >> 1) + ((sfbEnergyRight[sfb + sfboffs]<<s) >> 1))) >> (s>>2);
-
- overallLoudness[grpCounter] += normSfbLoudness[sfb + sfboffs] >> OVERALL_LOUDNESS_SF;
- /* don't do intensity if
- * - panning angle is too close to the middle or
- * - one channel is non-existent or
- * - if it is dual mono */
- if( (sfbEnergyLeft[sfb + sfboffs] >= fMult(isParams->left_right_ratio_threshold,sfbEnergyRight[sfb + sfboffs]))
- && (fMult(isParams->left_right_ratio_threshold,sfbEnergyLeft[sfb + sfboffs]) <= sfbEnergyRight[sfb + sfboffs]) ) {
-
- /* this will prevent post processing from considering this SFB for merging */
- hrrErr[sfb + sfboffs] = FL2FXCONST_DBL(1.0/8.0);
- }
- }
- }
-
- for (grpCounter = 0, sfboffs = 0; sfboffs < sfbCnt; sfboffs += sfbPerGroup, grpCounter++) {
- INT invOverallLoudnessSF;
- FIXP_DBL invOverallLoudness;
-
- if (overallLoudness[grpCounter] == FL2FXCONST_DBL(0.0)) {
- invOverallLoudness = FL2FXCONST_DBL(0.0);
- invOverallLoudnessSF = 0;
- }
- else {
- invOverallLoudness = fDivNorm((FIXP_DBL)MAXVAL_DBL, overallLoudness[grpCounter],&invOverallLoudnessSF);
- invOverallLoudnessSF = invOverallLoudnessSF - OVERALL_LOUDNESS_SF + 1; /* +1: compensate fMultDiv2() in subsequent loop */
- }
- invOverallLoudnessSF = fixMin(fixMax(invOverallLoudnessSF,-(DFRACT_BITS-1)),DFRACT_BITS-1);
-
- for (sfb = 0; sfb < maxSfbPerGroup; sfb++) {
- FIXP_DBL tmp;
-
- tmp = fMultDiv2((normSfbLoudness[sfb + sfboffs]>>OVERALL_LOUDNESS_SF)<<OVERALL_LOUDNESS_SF,invOverallLoudness);
-
- normSfbLoudness[sfb + sfboffs] = scaleValue(tmp, invOverallLoudnessSF);
-
- channelCorr[sfb + sfboffs] = FL2FXCONST_DBL(0.0f);
-
- FDK_ASSERT(50 >= 49);
- /* max width of scalefactorband is 96; width's are always even */
- /* inv_n is scaled with factor 2 to compensate fMultDiv2() in subsequent loops */
- inv_n = GetInvInt((sfbOffset[sfb + sfboffs + 1] - sfbOffset[sfb + sfboffs])>>1);
-
- if (inv_n > FL2FXCONST_DBL(0.0f)) {
- INT s,sL,sR;
-
- /* correlation := Pearson's product-moment coefficient */
- /* compute correlation between channels and check if it is over threshold */
- ml = FL2FXCONST_DBL(0.0f);
- mr = FL2FXCONST_DBL(0.0f);
- prod_lr = FL2FXCONST_DBL(0.0f);
- square_l = FL2FXCONST_DBL(0.0f);
- square_r = FL2FXCONST_DBL(0.0f);
-
- sL = calcSfbMaxScale(mdctSpectrumLeft,sfbOffset[sfb+sfboffs],sfbOffset[sfb+sfboffs+1]);
- sR = calcSfbMaxScale(mdctSpectrumRight,sfbOffset[sfb+sfboffs],sfbOffset[sfb+sfboffs+1]);
- s = fixMin(sL,sR);
-
- for (j = sfbOffset[sfb + sfboffs]; j < sfbOffset[sfb + sfboffs + 1]; j++) {
- ml += fMultDiv2((mdctSpectrumLeft[j] << s),inv_n); // scaled with mdctScale - s + inv_n
- mr += fMultDiv2((mdctSpectrumRight[j] << s),inv_n); // scaled with mdctScale - s + inv_n
- }
- ml = fMultDiv2(ml,inv_n); // scaled with mdctScale - s + inv_n
- mr = fMultDiv2(mr,inv_n); // scaled with mdctScale - s + inv_n
-
- for (j = sfbOffset[sfb + sfboffs]; j < sfbOffset[sfb + sfboffs + 1]; j++) {
- tmp_l = fMultDiv2((mdctSpectrumLeft[j] << s),inv_n) - ml; // scaled with mdctScale - s + inv_n
- tmp_r = fMultDiv2((mdctSpectrumRight[j] << s),inv_n) - mr; // scaled with mdctScale - s + inv_n
-
- prod_lr += fMultDiv2(tmp_l,tmp_r); // scaled with 2*(mdctScale - s + inv_n) + 1
- square_l += fPow2Div2(tmp_l); // scaled with 2*(mdctScale - s + inv_n) + 1
- square_r += fPow2Div2(tmp_r); // scaled with 2*(mdctScale - s + inv_n) + 1
- }
- prod_lr = prod_lr << 1; // scaled with 2*(mdctScale - s + inv_n)
- square_l = square_l << 1; // scaled with 2*(mdctScale - s + inv_n)
- square_r = square_r << 1; // scaled with 2*(mdctScale - s + inv_n)
-
- if (square_l > FL2FXCONST_DBL(0.0f) && square_r > FL2FXCONST_DBL(0.0f)) {
- INT channelCorrSF = 0;
-
- /* local scaling of square_l and square_r is compensated after sqrt calculation */
- sL = fixMax(0,(CntLeadingZeros(square_l)-1));
- sR = fixMax(0,(CntLeadingZeros(square_r)-1));
- s = ((sL + sR)>>1)<<1;
- sL = fixMin(sL,s);
- sR = s-sL;
- tmp = fMult(square_l<<sL,square_r<<sR);
- tmp = sqrtFixp(tmp);
-
- FDK_ASSERT(tmp > FL2FXCONST_DBL(0.0f));
-
- /* numerator and denominator have the same scaling */
- if (prod_lr < FL2FXCONST_DBL(0.0f) ) {
- channelCorr[sfb + sfboffs] = -(fDivNorm(-prod_lr,tmp,&channelCorrSF));
-
- }
- else {
- channelCorr[sfb + sfboffs] = (fDivNorm( prod_lr,tmp,&channelCorrSF));
- }
- channelCorrSF = fixMin(fixMax(( channelCorrSF + ((sL+sR)>>1)),-(DFRACT_BITS-1)),DFRACT_BITS-1);
-
- if (channelCorrSF < 0) {
- channelCorr[sfb + sfboffs] = channelCorr[sfb + sfboffs] >> (-channelCorrSF);
- }
- else {
- /* avoid overflows due to limited computational accuracy */
- if ( fAbs(channelCorr[sfb + sfboffs]) > (((FIXP_DBL)MAXVAL_DBL)>>channelCorrSF) ) {
- if (channelCorr[sfb + sfboffs] < FL2FXCONST_DBL(0.0f))
- channelCorr[sfb + sfboffs] = -(FIXP_DBL) MAXVAL_DBL;
- else
- channelCorr[sfb + sfboffs] = (FIXP_DBL) MAXVAL_DBL;
- }
- else {
- channelCorr[sfb + sfboffs] = channelCorr[sfb + sfboffs] << channelCorrSF;
- }
- }
- }
- }
-
- /* for post processing: hrrErr is the error in terms of (too little) correlation
- * weighted with the loudness of the SFB; SFBs with small hrrErr can be merged */
- if (hrrErr[sfb + sfboffs] == FL2FXCONST_DBL(1.0/8.0)) {
- continue;
- }
-
- hrrErr[sfb + sfboffs] = fMultDiv2((FL2FXCONST_DBL(0.25f)-(channelCorr[sfb + sfboffs]>>2)),normSfbLoudness[sfb + sfboffs]);
-
- /* set IS mask/vector to 1, if correlation is high enough */
- if (fAbs(channelCorr[sfb + sfboffs]) >= isParams->corr_thresh) {
- isMask[sfb + sfboffs] = 1;
- }
- }
- }
-}
-
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_finalizeIntensityDecision
-
- description: Finalizes intensity decision
-
- input: isParams scale: none
- hrrErr scale: none
- realIsScale scale: LD_DATA_SHIFT + REAL_SCALE_SF
- normSfbLoudness scale: none
-
- output: isMask scale: none
-
- returns: none
-
-*****************************************************************************/
-static void
-FDKaacEnc_finalizeIntensityDecision(const FIXP_DBL *hrrErr,
- INT *isMask,
- const FIXP_DBL *realIsScale,
- const FIXP_DBL *normSfbLoudness,
- const INTENSITY_PARAMETERS *isParams,
- const INT sfbCnt,
- const INT sfbPerGroup,
- const INT maxSfbPerGroup)
-{
- INT sfb,sfboffs, j;
- FIXP_DBL isScaleLast = FL2FXCONST_DBL(0.0f);
- INT isStartValueFound = 0;
-
- for (sfboffs = 0; sfboffs < sfbCnt; sfboffs += sfbPerGroup) {
- INT startIsSfb = 0;
- INT inIsBlock = 0;
- INT currentIsSfbCount = 0;
- FIXP_DBL overallHrrError = FL2FXCONST_DBL(0.0f);
- FIXP_DBL isRegionLoudness = FL2FXCONST_DBL(0.0f);
-
- for (sfb = 0; sfb < maxSfbPerGroup; sfb++) {
- if (isMask[sfboffs + sfb] == 1) {
- if (currentIsSfbCount == 0) {
- startIsSfb = sfboffs + sfb;
- }
- if (isStartValueFound==0) {
- isScaleLast = realIsScale[sfboffs + sfb];
- isStartValueFound = 1;
- }
- inIsBlock = 1;
- currentIsSfbCount++;
- overallHrrError += hrrErr[sfboffs + sfb] >> (MAX_SFB_PER_GROUP_SF-3);
- isRegionLoudness += normSfbLoudness[sfboffs + sfb] >> MAX_SFB_PER_GROUP_SF;
- }
- else {
- /* based on correlation, IS should not be used
- * -> use it anyway, if overall error is below threshold
- * and if local error does not exceed threshold
- * otherwise: check if there are enough IS SFBs
- */
- if (inIsBlock) {
- overallHrrError += hrrErr[sfboffs + sfb] >> (MAX_SFB_PER_GROUP_SF-3);
- isRegionLoudness += normSfbLoudness[sfboffs + sfb] >> MAX_SFB_PER_GROUP_SF;
-
- if ( (hrrErr[sfboffs + sfb] < (isParams->local_error_thresh>>3)) && (overallHrrError < (isParams->total_error_thresh>>MAX_SFB_PER_GROUP_SF)) ) {
- currentIsSfbCount++;
- /* overwrite correlation based decision */
- isMask[sfboffs + sfb] = 1;
- } else {
- inIsBlock = 0;
- }
- }
- }
- /* check for large direction deviation */
- if (inIsBlock) {
- if( fAbs(isScaleLast-realIsScale[sfboffs + sfb]) < (isParams->direction_deviation_thresh>>(REAL_SCALE_SF+LD_DATA_SHIFT-IS_DIRECTION_DEVIATION_THRESH_SF)) ) {
- isScaleLast = realIsScale[sfboffs + sfb];
- }
- else{
- isMask[sfboffs + sfb] = 0;
- inIsBlock = 0;
- currentIsSfbCount--;
- }
- }
-
- if (currentIsSfbCount > 0 && (!inIsBlock || sfb == maxSfbPerGroup - 1)) {
- /* not enough SFBs -> do not use IS */
- if (currentIsSfbCount < isParams->min_is_sfbs || (isRegionLoudness < isParams->is_region_min_loudness>>MAX_SFB_PER_GROUP_SF)) {
- for(j = startIsSfb; j <= sfboffs + sfb; j++) {
- isMask[j] = 0;
- }
- isScaleLast = FL2FXCONST_DBL(0.0f);
- isStartValueFound = 0;
- for (j=0; j < startIsSfb; j++) {
- if (isMask[j]!=0) {
- isScaleLast = realIsScale[j];
- isStartValueFound = 1;
- }
- }
- }
- currentIsSfbCount = 0;
- overallHrrError = FL2FXCONST_DBL(0.0f);
- isRegionLoudness = FL2FXCONST_DBL(0.0f);
- }
- }
- }
-}
-
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_IntensityStereoProcessing
-
- description: Intensity stereo processing tool
-
- input: sfbEnergyLeft
- sfbEnergyRight
- mdctSpectrumLeft
- mdctSpectrumRight
- sfbThresholdLeft
- sfbThresholdRight
- sfbSpreadEnLeft
- sfbSpreadEnRight
- sfbEnergyLdDataLeft
- sfbEnergyLdDataRight
-
- output: isBook
- isScale
- pnsData->pnsFlag
- msDigest zeroed from start to sfbCnt
- msMask zeroed from start to sfbCnt
- mdctSpectrumRight zeroed where isBook!=0
- sfbEnergyRight zeroed where isBook!=0
- sfbSpreadEnRight zeroed where isBook!=0
- sfbThresholdRight zeroed where isBook!=0
- sfbEnergyLdDataRight FL2FXCONST_DBL(-1.0) where isBook!=0
- sfbThresholdLdDataRight FL2FXCONST_DBL(-0.515625f) where isBook!=0
-
- returns: none
-
-*****************************************************************************/
-void FDKaacEnc_IntensityStereoProcessing(
- FIXP_DBL *sfbEnergyLeft,
- FIXP_DBL *sfbEnergyRight,
- FIXP_DBL *mdctSpectrumLeft,
- FIXP_DBL *mdctSpectrumRight,
- FIXP_DBL *sfbThresholdLeft,
- FIXP_DBL *sfbThresholdRight,
- FIXP_DBL *sfbThresholdLdDataRight,
- FIXP_DBL *sfbSpreadEnLeft,
- FIXP_DBL *sfbSpreadEnRight,
- FIXP_DBL *sfbEnergyLdDataLeft,
- FIXP_DBL *sfbEnergyLdDataRight,
- INT *msDigest,
- INT *msMask,
- const INT sfbCnt,
- const INT sfbPerGroup,
- const INT maxSfbPerGroup,
- const INT *sfbOffset,
- const INT allowIS,
- INT *isBook,
- INT *isScale,
- PNS_DATA *RESTRICT pnsData[2]
- )
-{
- INT sfb,sfboffs, j;
- FIXP_DBL scale;
- FIXP_DBL lr;
- FIXP_DBL hrrErr[MAX_GROUPED_SFB];
- FIXP_DBL normSfbLoudness[MAX_GROUPED_SFB];
- FIXP_DBL realIsScale[MAX_GROUPED_SFB];
- INTENSITY_PARAMETERS isParams;
- INT isMask[MAX_GROUPED_SFB];
-
- FDKmemclear((void*)isBook,sfbCnt*sizeof(INT));
- FDKmemclear((void*)isMask,sfbCnt*sizeof(INT));
- FDKmemclear((void*)realIsScale,sfbCnt*sizeof(FIXP_DBL));
- FDKmemclear((void*)isScale,sfbCnt*sizeof(INT));
- FDKmemclear((void*)hrrErr,sfbCnt*sizeof(FIXP_DBL));
-
- if (!allowIS)
- return;
-
- FDKaacEnc_initIsParams(&isParams);
-
- /* compute / set the following values per SFB:
- * - left/right ratio between channels
- * - normalized loudness
- * + loudness == average of energy in channels to 0.25
- * + normalization: division by sum of all SFB loudnesses
- * - isMask (is set to 0 if channels are the same or one is 0)
- */
- FDKaacEnc_prepareIntensityDecision(sfbEnergyLeft,
- sfbEnergyRight,
- sfbEnergyLdDataLeft,
- sfbEnergyLdDataRight,
- mdctSpectrumLeft,
- mdctSpectrumRight,
- &isParams,
- hrrErr,
- isMask,
- realIsScale,
- normSfbLoudness,
- sfbCnt,
- sfbPerGroup,
- maxSfbPerGroup,
- sfbOffset);
-
- FDKaacEnc_finalizeIntensityDecision(hrrErr,
- isMask,
- realIsScale,
- normSfbLoudness,
- &isParams,
- sfbCnt,
- sfbPerGroup,
- maxSfbPerGroup);
-
- for (sfb=0; sfb<sfbCnt; sfb+=sfbPerGroup) {
- for (sfboffs=0; sfboffs<maxSfbPerGroup; sfboffs++) {
- INT sL, sR;
- FIXP_DBL inv_n;
-
- msMask[sfb+sfboffs] = 0;
- if (isMask[sfb+sfboffs] == 0) {
- continue;
- }
-
- if ( (sfbEnergyLeft[sfb+sfboffs] < sfbThresholdLeft[sfb+sfboffs])
- &&(fMult(FL2FXCONST_DBL(1.0f/1.5f),sfbEnergyRight[sfb+sfboffs]) > sfbThresholdRight[sfb+sfboffs]) ) {
- continue;
- }
- /* NEW: if there is a big-enough IS region, switch off PNS */
- if (pnsData[0]) {
- if(pnsData[0]->pnsFlag[sfb+sfboffs]) {
- pnsData[0]->pnsFlag[sfb+sfboffs] = 0;
- }
- if(pnsData[1]->pnsFlag[sfb+sfboffs]) {
- pnsData[1]->pnsFlag[sfb+sfboffs] = 0;
- }
- }
-
- inv_n = GetInvInt((sfbOffset[sfb + sfboffs + 1] - sfbOffset[sfb + sfboffs])>>1); // scaled with 2 to compensate fMultDiv2() in subsequent loop
- sL = calcSfbMaxScale(mdctSpectrumLeft,sfbOffset[sfb+sfboffs],sfbOffset[sfb+sfboffs+1]);
- sR = calcSfbMaxScale(mdctSpectrumRight,sfbOffset[sfb+sfboffs],sfbOffset[sfb+sfboffs+1]);
-
- lr = FL2FXCONST_DBL(0.0f);
- for (j=sfbOffset[sfb+sfboffs]; j<sfbOffset[sfb+sfboffs+1]; j++)
- lr += fMultDiv2(fMultDiv2(mdctSpectrumLeft[j]<<sL,mdctSpectrumRight[j]<<sR),inv_n);
- lr = lr<<1;
-
- if (lr < FL2FXCONST_DBL(0.0f)) {
- /* This means OUT OF phase intensity stereo, cf. standard */
- INT s0, s1, s2;
- FIXP_DBL tmp, d, ed = FL2FXCONST_DBL(0.0f);
-
- s0 = fixMin(sL,sR);
- for (j=sfbOffset[sfb+sfboffs]; j<sfbOffset[sfb+sfboffs+1]; j++) {
- d = ((mdctSpectrumLeft[j]<<s0)>>1) - ((mdctSpectrumRight[j]<<s0)>>1);
- ed += fMultDiv2(d,d)>>(MDCT_SPEC_SF-1);
- }
- msMask[sfb+sfboffs] = 1;
- tmp = fDivNorm(sfbEnergyLeft[sfb+sfboffs],ed,&s1);
- s2 = (s1) + (2*s0) - 2 - MDCT_SPEC_SF;
- if (s2 & 1) {
- tmp = tmp>>1;
- s2 = s2+1;
- }
- s2 = (s2>>1) + 1; // +1 compensate fMultDiv2() in subsequent loop
- s2 = fixMin(fixMax(s2,-(DFRACT_BITS-1)),(DFRACT_BITS-1));
- scale = sqrtFixp(tmp);
- if (s2 < 0) {
- s2 = -s2;
- for (j=sfbOffset[sfb+sfboffs]; j<sfbOffset[sfb+sfboffs+1]; j++) {
- mdctSpectrumLeft[j] = (fMultDiv2(mdctSpectrumLeft[j],scale) - fMultDiv2(mdctSpectrumRight[j],scale)) >> s2;
- mdctSpectrumRight[j] = FL2FXCONST_DBL(0.0f);
- }
- }
- else {
- for (j=sfbOffset[sfb+sfboffs]; j<sfbOffset[sfb+sfboffs+1]; j++) {
- mdctSpectrumLeft[j] = (fMultDiv2(mdctSpectrumLeft[j],scale) - fMultDiv2(mdctSpectrumRight[j],scale)) << s2;
- mdctSpectrumRight[j] = FL2FXCONST_DBL(0.0f);
- }
- }
- }
- else {
- /* This means IN phase intensity stereo, cf. standard */
- INT s0,s1,s2;
- FIXP_DBL tmp, s, es = FL2FXCONST_DBL(0.0f);
-
- s0 = fixMin(sL,sR);
- for (j=sfbOffset[sfb+sfboffs]; j<sfbOffset[sfb+sfboffs+1]; j++) {
- s = ((mdctSpectrumLeft[j]<<s0)>>1) + ((mdctSpectrumRight[j]<<s0)>>1);
- es += fMultDiv2(s,s)>>(MDCT_SPEC_SF-1); // scaled 2*(mdctScale - s0 + 1) + MDCT_SPEC_SF
- }
- msMask[sfb+sfboffs] = 0;
- tmp = fDivNorm(sfbEnergyLeft[sfb+sfboffs],es,&s1);
- s2 = (s1) + (2*s0) - 2 - MDCT_SPEC_SF;
- if (s2 & 1) {
- tmp = tmp>>1;
- s2 = s2 + 1;
- }
- s2 = (s2>>1) + 1; // +1 compensate fMultDiv2() in subsequent loop
- s2 = fixMin(fixMax(s2,-(DFRACT_BITS-1)),(DFRACT_BITS-1));
- scale = sqrtFixp(tmp);
- if (s2 < 0) {
- s2 = -s2;
- for (j=sfbOffset[sfb+sfboffs]; j<sfbOffset[sfb+sfboffs+1]; j++) {
- mdctSpectrumLeft[j] = (fMultDiv2(mdctSpectrumLeft[j],scale) + fMultDiv2(mdctSpectrumRight[j],scale)) >> s2;
- mdctSpectrumRight[j] = FL2FXCONST_DBL(0.0f);
- }
- }
- else {
- for (j=sfbOffset[sfb+sfboffs]; j<sfbOffset[sfb+sfboffs+1]; j++) {
- mdctSpectrumLeft[j] = (fMultDiv2(mdctSpectrumLeft[j],scale) + fMultDiv2(mdctSpectrumRight[j],scale)) << s2;
- mdctSpectrumRight[j] = FL2FXCONST_DBL(0.0f);
- }
- }
- }
-
- isBook[sfb+sfboffs] = CODE_BOOK_IS_IN_PHASE_NO;
-
- if ( realIsScale[sfb+sfboffs] < FL2FXCONST_DBL(0.0f) ) {
- isScale[sfb+sfboffs] = (INT)(((realIsScale[sfb+sfboffs]>>1)-FL2FXCONST_DBL(0.5f/(1<<(REAL_SCALE_SF+LD_DATA_SHIFT+1))))>>(DFRACT_BITS-1-REAL_SCALE_SF-LD_DATA_SHIFT-1)) + 1;
- }
- else {
- isScale[sfb+sfboffs] = (INT)(((realIsScale[sfb+sfboffs]>>1)+FL2FXCONST_DBL(0.5f/(1<<(REAL_SCALE_SF+LD_DATA_SHIFT+1))))>>(DFRACT_BITS-1-REAL_SCALE_SF-LD_DATA_SHIFT-1));
- }
-
- sfbEnergyRight[sfb+sfboffs] = FL2FXCONST_DBL(0.0f);
- sfbEnergyLdDataRight[sfb+sfboffs] = FL2FXCONST_DBL(-1.0f);
- sfbThresholdRight[sfb+sfboffs] = FL2FXCONST_DBL(0.0f);
- sfbThresholdLdDataRight[sfb+sfboffs] = FL2FXCONST_DBL(-0.515625f);
- sfbSpreadEnRight[sfb+sfboffs] = FL2FXCONST_DBL(0.0f);
-
- *msDigest = MS_SOME;
- }
- }
-}
-
diff --git a/libAACenc/src/intensity.h b/libAACenc/src/intensity.h
deleted file mode 100644
index 2acc292..0000000
--- a/libAACenc/src/intensity.h
+++ /dev/null
@@ -1,122 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: A. Horndasch (code originally from lwr and rtb) / Josef Höpfl (FDK)
- contents/description: intensity stereo prototype
-
-******************************************************************************/
-
-#ifndef _INTENSITY_H
-#define _INTENSITY_H
-
-#include "aacenc_pns.h"
-
-
-void FDKaacEnc_IntensityStereoProcessing(
- FIXP_DBL *sfbEnergyLeft,
- FIXP_DBL *sfbEnergyRight,
- FIXP_DBL *mdctSpectrumLeft,
- FIXP_DBL *mdctSpectrumRight,
- FIXP_DBL *sfbThresholdLeft,
- FIXP_DBL *sfbThresholdRight,
- FIXP_DBL *sfbThresholdLdDataRight,
- FIXP_DBL *sfbSpreadEnLeft,
- FIXP_DBL *sfbSpreadEnRight,
- FIXP_DBL *sfbEnergyLdDataLeft,
- FIXP_DBL *sfbEnergyLdDataRight,
- INT *msDigest,
- INT *msMask,
- const INT sfbCnt,
- const INT sfbPerGroup,
- const INT maxSfbPerGroup,
- const INT *sfbOffset,
- const INT allowIS,
- INT *isBook,
- INT *isScale,
- PNS_DATA *RESTRICT pnsData[2]
- );
-
-#endif /* _INTENSITY_H */
-
diff --git a/libAACenc/src/interface.h b/libAACenc/src/interface.h
deleted file mode 100644
index 51fb72a..0000000
--- a/libAACenc/src/interface.h
+++ /dev/null
@@ -1,169 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M.Werner
- contents/description: Interface psychoaccoustic/quantizer
-
-******************************************************************************/
-
-#ifndef _INTERFACE_H
-#define _INTERFACE_H
-
-#include "common_fix.h"
-#include "FDK_audio.h"
-
-#include "psy_data.h"
-#include "aacenc_tns.h"
-
-enum
-{
- MS_NONE = 0,
- MS_SOME = 1,
- MS_ALL = 2
-};
-
-enum
-{
- MS_ON = 1
-};
-
-struct TOOLSINFO {
- INT msDigest; /* 0 = no MS; 1 = some MS, 2 = all MS */
- INT msMask[MAX_GROUPED_SFB];
-};
-
-
-typedef struct {
- INT sfbCnt;
- INT sfbPerGroup;
- INT maxSfbPerGroup;
- INT lastWindowSequence;
- INT windowShape;
- INT groupingMask;
- INT sfbOffsets[MAX_GROUPED_SFB+1];
-
- INT mdctScale; /* number of transform shifts */
- INT groupLen[MAX_NO_OF_GROUPS];
-
- TNS_INFO tnsInfo;
- INT noiseNrg[MAX_GROUPED_SFB];
- INT isBook[MAX_GROUPED_SFB];
- INT isScale[MAX_GROUPED_SFB];
-
- /* memory located in QC_OUT_CHANNEL */
- FIXP_DBL *mdctSpectrum;
- FIXP_DBL *sfbEnergy;
- FIXP_DBL *sfbSpreadEnergy;
- FIXP_DBL *sfbThresholdLdData;
- FIXP_DBL *sfbMinSnrLdData;
- FIXP_DBL *sfbEnergyLdData;
-
-
- }PSY_OUT_CHANNEL;
-
-typedef struct {
-
- /* information specific to each channel */
- PSY_OUT_CHANNEL* psyOutChannel[(2)];
-
- /* information shared by both channels */
- INT commonWindow;
- struct TOOLSINFO toolsInfo;
-
-} PSY_OUT_ELEMENT;
-
-typedef struct {
-
- PSY_OUT_ELEMENT* psyOutElement[(8)];
- PSY_OUT_CHANNEL* pPsyOutChannels[(8)];
-
-}PSY_OUT;
-
-inline int isLowDelay( AUDIO_OBJECT_TYPE aot )
-{
- return (aot==AOT_ER_AAC_LD || aot==AOT_ER_AAC_ELD);
-}
-
-#endif /* _INTERFACE_H */
diff --git a/libAACenc/src/line_pe.cpp b/libAACenc/src/line_pe.cpp
deleted file mode 100644
index f3c0dab..0000000
--- a/libAACenc/src/line_pe.cpp
+++ /dev/null
@@ -1,209 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M. Werner
- contents/description: Perceptual entropie module
-
-******************************************************************************/
-
-#include "line_pe.h"
-#include "sf_estim.h"
-#include "bit_cnt.h"
-
-#include "genericStds.h"
-
-static const FIXP_DBL C1LdData = FL2FXCONST_DBL(3.0/LD_DATA_SCALING); /* C1 = 3.0 = log(8.0)/log(2) */
-static const FIXP_DBL C2LdData = FL2FXCONST_DBL(1.3219281/LD_DATA_SCALING); /* C2 = 1.3219281 = log(2.5)/log(2) */
-static const FIXP_DBL C3LdData = FL2FXCONST_DBL(0.5593573); /* 1-C2/C1 */
-
-
-/* constants that do not change during successive pe calculations */
-void FDKaacEnc_prepareSfbPe(PE_CHANNEL_DATA *peChanData,
- const FIXP_DBL *sfbEnergyLdData,
- const FIXP_DBL *sfbThresholdLdData,
- const FIXP_DBL *sfbFormFactorLdData,
- const INT *sfbOffset,
- const INT sfbCnt,
- const INT sfbPerGroup,
- const INT maxSfbPerGroup)
-{
- INT sfbGrp,sfb;
- INT sfbWidth;
- FIXP_DBL avgFormFactorLdData;
- const FIXP_DBL formFacScaling = FL2FXCONST_DBL((float)FORM_FAC_SHIFT/LD_DATA_SCALING);
-
- for (sfbGrp = 0;sfbGrp < sfbCnt;sfbGrp+=sfbPerGroup) {
- for (sfb=0; sfb<maxSfbPerGroup; sfb++) {
- if ((FIXP_DBL)sfbEnergyLdData[sfbGrp+sfb] > (FIXP_DBL)sfbThresholdLdData[sfbGrp+sfb]) {
- sfbWidth = sfbOffset[sfbGrp+sfb+1] - sfbOffset[sfbGrp+sfb];
- /* estimate number of active lines */
- avgFormFactorLdData = ((-sfbEnergyLdData[sfbGrp+sfb]>>1) + (CalcLdInt(sfbWidth)>>1))>>1;
- peChanData->sfbNLines[sfbGrp+sfb] =
- (INT)CalcInvLdData( (sfbFormFactorLdData[sfbGrp+sfb] + formFacScaling) + avgFormFactorLdData);
- /* Make sure sfbNLines is never greater than sfbWidth due to unaccuracies (e.g. sfbEnergyLdData[sfbGrp+sfb] = 0x80000000) */
- peChanData->sfbNLines[sfbGrp+sfb] = fMin(sfbWidth, peChanData->sfbNLines[sfbGrp+sfb]);
- }
- else {
- peChanData->sfbNLines[sfbGrp+sfb] = 0;
- }
- }
- }
-}
-
-/*
- formula for one sfb:
- pe = n * ld(en/thr), if ld(en/thr) >= C1
- pe = n * (C2 + C3 * ld(en/thr)), if ld(en/thr) < C1
- n: estimated number of lines in sfb,
- ld(x) = log(x)/log(2)
-
- constPart is sfbPe without the threshold part n*ld(thr) or n*C3*ld(thr)
-*/
-void FDKaacEnc_calcSfbPe(PE_CHANNEL_DATA *RESTRICT peChanData,
- const FIXP_DBL *RESTRICT sfbEnergyLdData,
- const FIXP_DBL *RESTRICT sfbThresholdLdData,
- const INT sfbCnt,
- const INT sfbPerGroup,
- const INT maxSfbPerGroup,
- const INT *isBook,
- const INT *isScale)
-{
- INT sfbGrp,sfb;
- INT nLines;
- FIXP_DBL logDataRatio;
- INT lastValIs = 0;
-
- peChanData->pe = 0;
- peChanData->constPart = 0;
- peChanData->nActiveLines = 0;
-
- for(sfbGrp = 0;sfbGrp < sfbCnt;sfbGrp+=sfbPerGroup){
- for (sfb=0; sfb<maxSfbPerGroup; sfb++) {
- if ((FIXP_DBL)sfbEnergyLdData[sfbGrp+sfb] > (FIXP_DBL)sfbThresholdLdData[sfbGrp+sfb]) {
- logDataRatio = (FIXP_DBL)(sfbEnergyLdData[sfbGrp+sfb] - sfbThresholdLdData[sfbGrp+sfb]);
- nLines = peChanData->sfbNLines[sfbGrp+sfb];
- if (logDataRatio >= C1LdData) {
- /* scale sfbPe and sfbConstPart with PE_CONSTPART_SHIFT */
- peChanData->sfbPe[sfbGrp+sfb] = fMultDiv2(logDataRatio, (FIXP_DBL)(nLines<<(LD_DATA_SHIFT+PE_CONSTPART_SHIFT+1)));
- peChanData->sfbConstPart[sfbGrp+sfb] =
- fMultDiv2(sfbEnergyLdData[sfbGrp+sfb], (FIXP_DBL)(nLines<<(LD_DATA_SHIFT+PE_CONSTPART_SHIFT+1))); ;
-
- }
- else {
- /* scale sfbPe and sfbConstPart with PE_CONSTPART_SHIFT */
- peChanData->sfbPe[sfbGrp+sfb] =
- fMultDiv2(((FIXP_DBL)C2LdData + fMult(C3LdData,logDataRatio)), (FIXP_DBL)(nLines<<(LD_DATA_SHIFT+PE_CONSTPART_SHIFT+1)));
-
- peChanData->sfbConstPart[sfbGrp+sfb] =
- fMultDiv2(((FIXP_DBL)C2LdData + fMult(C3LdData,sfbEnergyLdData[sfbGrp+sfb])),
- (FIXP_DBL)(nLines<<(LD_DATA_SHIFT+PE_CONSTPART_SHIFT+1))) ;
-
- nLines = fMultI(C3LdData, nLines);
- }
- peChanData->sfbNActiveLines[sfbGrp+sfb] = nLines;
- }
- else if( isBook[sfbGrp+sfb] ) {
- /* provide for cost of scale factor for Intensity */
- INT delta = isScale[sfbGrp+sfb] - lastValIs;
- lastValIs = isScale[sfbGrp+sfb];
- peChanData->sfbPe[sfbGrp+sfb] = FDKaacEnc_bitCountScalefactorDelta(delta)<<PE_CONSTPART_SHIFT;
- peChanData->sfbConstPart[sfbGrp+sfb] = 0;
- peChanData->sfbNActiveLines[sfbGrp+sfb] = 0;
- }
- else {
- peChanData->sfbPe[sfbGrp+sfb] = 0;
- peChanData->sfbConstPart[sfbGrp+sfb] = 0;
- peChanData->sfbNActiveLines[sfbGrp+sfb] = 0;
- }
- /* sum up peChanData values */
- peChanData->pe += peChanData->sfbPe[sfbGrp+sfb];
- peChanData->constPart += peChanData->sfbConstPart[sfbGrp+sfb];
- peChanData->nActiveLines += peChanData->sfbNActiveLines[sfbGrp+sfb];
- }
- }
- /* correct scaled pe and constPart values */
- peChanData->pe>>=PE_CONSTPART_SHIFT;
- peChanData->constPart>>=PE_CONSTPART_SHIFT;
-}
diff --git a/libAACenc/src/line_pe.h b/libAACenc/src/line_pe.h
deleted file mode 100644
index 3d5cfd5..0000000
--- a/libAACenc/src/line_pe.h
+++ /dev/null
@@ -1,139 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M. Werner
- contents/description: Perceptual entropie module
-
-******************************************************************************/
-#ifndef __LINE_PE_H
-#define __LINE_PE_H
-
-
-#include "common_fix.h"
-
-#include "psy_const.h"
-
-#define PE_CONSTPART_SHIFT FRACT_BITS
-
-typedef struct {
- /* calculated by FDKaacEnc_prepareSfbPe */
- INT sfbNLines[MAX_GROUPED_SFB]; /* number of relevant lines in sfb */
- /* the rest is calculated by FDKaacEnc_calcSfbPe */
- INT sfbPe[MAX_GROUPED_SFB]; /* pe for each sfb */
- INT sfbConstPart[MAX_GROUPED_SFB]; /* constant part for each sfb */
- INT sfbNActiveLines[MAX_GROUPED_SFB]; /* number of active lines in sfb */
- INT pe; /* sum of sfbPe */
- INT constPart; /* sum of sfbConstPart */
- INT nActiveLines; /* sum of sfbNActiveLines */
-} PE_CHANNEL_DATA;
-
-typedef struct {
- PE_CHANNEL_DATA peChannelData[(2)];
- INT pe;
- INT constPart;
- INT nActiveLines;
- INT offset;
-} PE_DATA;
-
-
-void FDKaacEnc_prepareSfbPe(PE_CHANNEL_DATA *peChanData,
- const FIXP_DBL *sfbEnergyLdData,
- const FIXP_DBL *sfbThresholdLdData,
- const FIXP_DBL *sfbFormFactorLdData,
- const INT *sfbOffset,
- const INT sfbCnt,
- const INT sfbPerGroup,
- const INT maxSfbPerGroup);
-
-void FDKaacEnc_calcSfbPe(PE_CHANNEL_DATA *RESTRICT peChanData,
- const FIXP_DBL *RESTRICT sfbEnergyLdData,
- const FIXP_DBL *RESTRICT sfbThresholdLdData,
- const INT sfbCnt,
- const INT sfbPerGroup,
- const INT maxSfbPerGroup,
- const INT *isBook,
- const INT *isScale);
-
-#endif
diff --git a/libAACenc/src/metadata_compressor.cpp b/libAACenc/src/metadata_compressor.cpp
deleted file mode 100644
index 876de57..0000000
--- a/libAACenc/src/metadata_compressor.cpp
+++ /dev/null
@@ -1,1038 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/********************** Fraunhofer IIS FDK AAC Encoder lib ******************
-
- Author(s): M. Neusinger
- Description: Compressor for AAC Metadata Generator
-
-******************************************************************************/
-
-
-#include "metadata_compressor.h"
-#include "channel_map.h"
-
-
-#define LOG2 0.69314718056f /* natural logarithm of 2 */
-#define ILOG2 1.442695041f /* 1/LOG2 */
-#define FIXP_ILOG2_DIV2 (FL2FXCONST_DBL(ILOG2/2))
-
-/*----------------- defines ----------------------*/
-
-#define MAX_DRC_CHANNELS (8) /*!< Max number of audio input channels. */
-#define DOWNMIX_SHIFT (3) /*!< Max 8 channel. */
-#define WEIGHTING_FILTER_SHIFT (2) /*!< Scaling used in weighting filter. */
-
-#define METADATA_INT_BITS 10
-#define METADATA_LINT_BITS 20
-#define METADATA_INT_SCALE (INT64(1)<<(METADATA_INT_BITS))
-#define METADATA_FRACT_BITS (DFRACT_BITS-1-METADATA_INT_BITS)
-#define METADATA_FRACT_SCALE (INT64(1)<<(METADATA_FRACT_BITS))
-
-/**
- * Enum for channel assignment.
- */
-enum {
- L = 0,
- R = 1,
- C = 2,
- LFE = 3,
- LS = 4,
- RS = 5,
- S = 6,
- LS2 = 7,
- RS2 = 8
-};
-
-/*--------------- structure definitions --------------------*/
-
-/**
- * Structure holds weighting filter filter states.
- */
-struct WEIGHTING_STATES {
- FIXP_DBL x1;
- FIXP_DBL x2;
- FIXP_DBL y1;
- FIXP_DBL y2;
-};
-
-/**
- * Dynamic Range Control compressor structure.
- */
-struct DRC_COMP {
-
- FIXP_DBL maxBoostThr[2]; /*!< Max boost threshold. */
- FIXP_DBL boostThr[2]; /*!< Boost threshold. */
- FIXP_DBL earlyCutThr[2]; /*!< Early cut threshold. */
- FIXP_DBL cutThr[2]; /*!< Cut threshold. */
- FIXP_DBL maxCutThr[2]; /*!< Max cut threshold. */
-
- FIXP_DBL boostFac[2]; /*!< Precalculated factor for boost compression. */
- FIXP_DBL earlyCutFac[2]; /*!< Precalculated factor for early cut compression. */
- FIXP_DBL cutFac[2]; /*!< Precalculated factor for cut compression. */
-
- FIXP_DBL maxBoost[2]; /*!< Maximum boost. */
- FIXP_DBL maxCut[2]; /*!< Maximum cut. */
- FIXP_DBL maxEarlyCut[2]; /*!< Maximum early cut. */
-
- FIXP_DBL fastAttack[2]; /*!< Fast attack coefficient. */
- FIXP_DBL fastDecay[2]; /*!< Fast release coefficient. */
- FIXP_DBL slowAttack[2]; /*!< Slow attack coefficient. */
- FIXP_DBL slowDecay[2]; /*!< Slow release coefficient. */
- UINT holdOff[2]; /*!< Hold time in blocks. */
-
- FIXP_DBL attackThr[2]; /*!< Slow/fast attack threshold. */
- FIXP_DBL decayThr[2]; /*!< Slow/fast release threshold. */
-
- DRC_PROFILE profile[2]; /*!< DRC profile. */
- INT blockLength; /*!< Block length in samples. */
- UINT sampleRate; /*!< Sample rate. */
- CHANNEL_MODE chanConfig; /*!< Channel configuration. */
-
- UCHAR useWeighting; /*!< Use weighting filter. */
-
- UINT channels; /*!< Number of channels. */
- UINT fullChannels; /*!< Number of full range channels. */
- INT channelIdx[9]; /*!< Offsets of interleaved channel samples (L, R, C, LFE, Ls, Rs, S, Ls2, Rs2). */
-
- FIXP_DBL smoothLevel[2]; /*!< level smoothing states */
- FIXP_DBL smoothGain[2]; /*!< gain smoothing states */
- UINT holdCnt[2]; /*!< hold counter */
-
- FIXP_DBL limGain[2]; /*!< limiter gain */
- FIXP_DBL limDecay; /*!< limiter decay (linear) */
- FIXP_DBL prevPeak[2]; /*!< max peak of previous block (stereo/mono)*/
-
- WEIGHTING_STATES filter[MAX_DRC_CHANNELS]; /*!< array holds weighting filter states */
-
-};
-
-/*---------------- constants -----------------------*/
-
-/**
- * Profile tables.
- */
-static const FIXP_DBL tabMaxBoostThr[] = {
- (FIXP_DBL)(-43<<METADATA_FRACT_BITS),
- (FIXP_DBL)(-53<<METADATA_FRACT_BITS),
- (FIXP_DBL)(-55<<METADATA_FRACT_BITS),
- (FIXP_DBL)(-65<<METADATA_FRACT_BITS),
- (FIXP_DBL)(-50<<METADATA_FRACT_BITS),
- (FIXP_DBL)(-40<<METADATA_FRACT_BITS)
-};
-static const FIXP_DBL tabBoostThr[] = {
- (FIXP_DBL)(-31<<METADATA_FRACT_BITS),
- (FIXP_DBL)(-41<<METADATA_FRACT_BITS),
- (FIXP_DBL)(-31<<METADATA_FRACT_BITS),
- (FIXP_DBL)(-41<<METADATA_FRACT_BITS),
- (FIXP_DBL)(-31<<METADATA_FRACT_BITS),
- (FIXP_DBL)(-31<<METADATA_FRACT_BITS)
-};
-static const FIXP_DBL tabEarlyCutThr[] = {
- (FIXP_DBL)(-26<<METADATA_FRACT_BITS),
- (FIXP_DBL)(-21<<METADATA_FRACT_BITS),
- (FIXP_DBL)(-26<<METADATA_FRACT_BITS),
- (FIXP_DBL)(-21<<METADATA_FRACT_BITS),
- (FIXP_DBL)(-26<<METADATA_FRACT_BITS),
- (FIXP_DBL)(-20<<METADATA_FRACT_BITS)
-};
-static const FIXP_DBL tabCutThr[] = {
- (FIXP_DBL)(-16<<METADATA_FRACT_BITS),
- (FIXP_DBL)(-11<<METADATA_FRACT_BITS),
- (FIXP_DBL)(-16<<METADATA_FRACT_BITS),
- (FIXP_DBL)(-21<<METADATA_FRACT_BITS),
- (FIXP_DBL)(-16<<METADATA_FRACT_BITS),
- (FIXP_DBL)(-10<<METADATA_FRACT_BITS)
-};
-static const FIXP_DBL tabMaxCutThr[] = {
- (FIXP_DBL)(4<<METADATA_FRACT_BITS),
- (FIXP_DBL)(9<<METADATA_FRACT_BITS),
- (FIXP_DBL)(4<<METADATA_FRACT_BITS),
- (FIXP_DBL)(9<<METADATA_FRACT_BITS),
- (FIXP_DBL)(4<<METADATA_FRACT_BITS),
- (FIXP_DBL)(4<<METADATA_FRACT_BITS)
-};
-static const FIXP_DBL tabBoostRatio[] = {
- FL2FXCONST_DBL( ((1.f/2.f) - 1.f) ),
- FL2FXCONST_DBL( ((1.f/2.f) - 1.f) ),
- FL2FXCONST_DBL( ((1.f/2.f) - 1.f) ),
- FL2FXCONST_DBL( ((1.f/2.f) - 1.f) ),
- FL2FXCONST_DBL( ((1.f/5.f) - 1.f) ),
- FL2FXCONST_DBL( ((1.f/5.f) - 1.f) )
-};
-static const FIXP_DBL tabEarlyCutRatio[] = {
- FL2FXCONST_DBL( ((1.f/2.f) - 1.f) ),
- FL2FXCONST_DBL( ((1.f/2.f) - 1.f) ),
- FL2FXCONST_DBL( ((1.f/2.f) - 1.f) ),
- FL2FXCONST_DBL( ((1.f/1.f) - 1.f) ),
- FL2FXCONST_DBL( ((1.f/2.f) - 1.f) ),
- FL2FXCONST_DBL( ((1.f/2.f) - 1.f) )
-};
-static const FIXP_DBL tabCutRatio[] = {
- FL2FXCONST_DBL( ((1.f/20.f) - 1.f) ),
- FL2FXCONST_DBL( ((1.f/20.f) - 1.f) ),
- FL2FXCONST_DBL( ((1.f/20.f) - 1.f) ),
- FL2FXCONST_DBL( ((1.f/ 2.f) - 1.f) ),
- FL2FXCONST_DBL( ((1.f/20.f) - 1.f) ),
- FL2FXCONST_DBL( ((1.f/20.f) - 1.f) )
-};
-static const FIXP_DBL tabMaxBoost[] = {
- (FIXP_DBL)( 6<<METADATA_FRACT_BITS),
- (FIXP_DBL)( 6<<METADATA_FRACT_BITS),
- (FIXP_DBL)(12<<METADATA_FRACT_BITS),
- (FIXP_DBL)(12<<METADATA_FRACT_BITS),
- (FIXP_DBL)(15<<METADATA_FRACT_BITS),
- (FIXP_DBL)(15<<METADATA_FRACT_BITS)
-};
-static const FIXP_DBL tabMaxCut[] = {
- (FIXP_DBL)(24<<METADATA_FRACT_BITS),
- (FIXP_DBL)(24<<METADATA_FRACT_BITS),
- (FIXP_DBL)(24<<METADATA_FRACT_BITS),
- (FIXP_DBL)(15<<METADATA_FRACT_BITS),
- (FIXP_DBL)(24<<METADATA_FRACT_BITS),
- (FIXP_DBL)(24<<METADATA_FRACT_BITS)
-};
-static const FIXP_DBL tabFastAttack[] = {
- FL2FXCONST_DBL((10.f/1000.f)/METADATA_INT_SCALE),
- FL2FXCONST_DBL((10.f/1000.f)/METADATA_INT_SCALE),
- FL2FXCONST_DBL((10.f/1000.f)/METADATA_INT_SCALE),
- FL2FXCONST_DBL((10.f/1000.f)/METADATA_INT_SCALE),
- FL2FXCONST_DBL((10.f/1000.f)/METADATA_INT_SCALE),
- FL2FXCONST_DBL( (0.f/1000.f)/METADATA_INT_SCALE)
-};
-static const FIXP_DBL tabFastDecay[] = {
- FL2FXCONST_DBL((1000.f/1000.f)/METADATA_INT_SCALE),
- FL2FXCONST_DBL((1000.f/1000.f)/METADATA_INT_SCALE),
- FL2FXCONST_DBL((1000.f/1000.f)/METADATA_INT_SCALE),
- FL2FXCONST_DBL((1000.f/1000.f)/METADATA_INT_SCALE),
- FL2FXCONST_DBL( (200.f/1000.f)/METADATA_INT_SCALE),
- FL2FXCONST_DBL( (0.f/1000.f)/METADATA_INT_SCALE)
-};
-static const FIXP_DBL tabSlowAttack[] = {
- FL2FXCONST_DBL((100.f/1000.f)/METADATA_INT_SCALE),
- FL2FXCONST_DBL((100.f/1000.f)/METADATA_INT_SCALE),
- FL2FXCONST_DBL((100.f/1000.f)/METADATA_INT_SCALE),
- FL2FXCONST_DBL((100.f/1000.f)/METADATA_INT_SCALE),
- FL2FXCONST_DBL((100.f/1000.f)/METADATA_INT_SCALE),
- FL2FXCONST_DBL( (0.f/1000.f)/METADATA_INT_SCALE)
-};
-static const FIXP_DBL tabSlowDecay[] = {
- FL2FXCONST_DBL( (3000.f/1000.f)/METADATA_INT_SCALE),
- FL2FXCONST_DBL( (3000.f/1000.f)/METADATA_INT_SCALE),
- FL2FXCONST_DBL((10000.f/1000.f)/METADATA_INT_SCALE),
- FL2FXCONST_DBL( (3000.f/1000.f)/METADATA_INT_SCALE),
- FL2FXCONST_DBL( (1000.f/1000.f)/METADATA_INT_SCALE),
- FL2FXCONST_DBL( (0.f/1000.f)/METADATA_INT_SCALE)
-};
-
-static const INT tabHoldOff[] = { 10, 10, 10, 10, 10, 0 };
-
-static const FIXP_DBL tabAttackThr[] = {
- (FIXP_DBL)(15<<METADATA_FRACT_BITS),
- (FIXP_DBL)(15<<METADATA_FRACT_BITS),
- (FIXP_DBL)(15<<METADATA_FRACT_BITS),
- (FIXP_DBL)(15<<METADATA_FRACT_BITS),
- (FIXP_DBL)(10<<METADATA_FRACT_BITS),
- (FIXP_DBL)(0<<METADATA_FRACT_BITS)
-};
-static const FIXP_DBL tabDecayThr[] = {
- (FIXP_DBL)(20<<METADATA_FRACT_BITS),
- (FIXP_DBL)(20<<METADATA_FRACT_BITS),
- (FIXP_DBL)(20<<METADATA_FRACT_BITS),
- (FIXP_DBL)(20<<METADATA_FRACT_BITS),
- (FIXP_DBL)(10<<METADATA_FRACT_BITS),
- (FIXP_DBL)( 0<<METADATA_FRACT_BITS)
-};
-
-/**
- * Weighting filter coefficients (biquad bandpass).
- */
-static const FIXP_DBL b0 = FL2FXCONST_DBL(0.53050662f); /* b1 = 0, b2 = -b0 */
-static const FIXP_DBL a1 = FL2FXCONST_DBL(-0.95237983f), a2 = FL2FXCONST_DBL(-0.02248836f); /* a0 = 1 */
-
-
-/*------------- function definitions ----------------*/
-
-/**
- * \brief Calculate scaling factor for denoted processing block.
- *
- * \param blockLength Length of processing block.
- *
- * \return shiftFactor
- */
-static UINT getShiftFactor(
- const UINT length
- )
-{
- UINT ldN;
- for(ldN=1;(((UINT)1)<<ldN) < length;ldN++);
-
- return ldN;
-}
-
-/**
- * \brief Sum up fixpoint values with best possible accuracy.
- *
- * \param value1 First input value.
- * \param q1 Scaling factor of first input value.
- * \param pValue2 Pointer to second input value, will be modified on return.
- * \param pQ2 Pointer to second scaling factor, will be modified on return.
- *
- * \return void
- */
-static void fixpAdd(
- const FIXP_DBL value1,
- const int q1,
- FIXP_DBL *const pValue2,
- int *const pQ2
- )
-{
- const int headroom1 = fNormz(fixp_abs(value1))-1;
- const int headroom2 = fNormz(fixp_abs(*pValue2))-1;
- int resultScale = fixMax(q1-headroom1, (*pQ2)-headroom2);
-
- if ( (value1!=FL2FXCONST_DBL(0.f)) && (*pValue2!=FL2FXCONST_DBL(0.f)) ) {
- resultScale++;
- }
-
- *pValue2 = scaleValue(value1, q1-resultScale) + scaleValue(*pValue2, (*pQ2)-resultScale);
- *pQ2 = (*pValue2!=(FIXP_DBL)0) ? resultScale : DFRACT_BITS-1;
-}
-
-/**
- * \brief Function for converting time constant to filter coefficient.
- *
- * \param t Time constant.
- * \param sampleRate Sampling rate in Hz.
- * \param blockLength Length of processing block in samples per channel.
- *
- * \return result = 1.0 - exp(-1.0/((t) * (f)))
- */
-static FIXP_DBL tc2Coeff(
- const FIXP_DBL t,
- const INT sampleRate,
- const INT blockLength
- )
-{
- FIXP_DBL sampleRateFract;
- FIXP_DBL blockLengthFract;
- FIXP_DBL f, product;
- FIXP_DBL exponent, result;
- INT e_res;
-
- /* f = sampleRate/blockLength */
- sampleRateFract = (FIXP_DBL)(sampleRate<<(DFRACT_BITS-1-METADATA_LINT_BITS));
- blockLengthFract = (FIXP_DBL)(blockLength<<(DFRACT_BITS-1-METADATA_LINT_BITS));
- f = fDivNorm(sampleRateFract, blockLengthFract, &e_res);
- f = scaleValue(f, e_res-METADATA_INT_BITS); /* convert to METADATA_FRACT */
-
- /* product = t*f */
- product = fMultNorm(t, f, &e_res);
- product = scaleValue(product, e_res+METADATA_INT_BITS); /* convert to METADATA_FRACT */
-
- /* exponent = (-1.0/((t) * (f))) */
- exponent = fDivNorm(METADATA_FRACT_SCALE, product, &e_res);
- exponent = scaleValue(exponent, e_res-METADATA_INT_BITS); /* convert to METADATA_FRACT */
-
- /* exponent * ld(e) */
- exponent = fMult(exponent,FIXP_ILOG2_DIV2)<<1; /* e^(x) = 2^(x*ld(e)) */
-
- /* exp(-1.0/((t) * (f))) */
- result = f2Pow(-exponent, DFRACT_BITS-1-METADATA_FRACT_BITS, &e_res);
-
- /* result = 1.0 - exp(-1.0/((t) * (f))) */
- result = (FIXP_DBL)MAXVAL_DBL - scaleValue(result, e_res);
-
- return result;
-}
-
-INT FDK_DRC_Generator_Open(
- HDRC_COMP *phDrcComp
- )
-{
- INT err = 0;
- HDRC_COMP hDcComp = NULL;
-
- if (phDrcComp == NULL) {
- err = -1;
- goto bail;
- }
-
- /* allocate memory */
- hDcComp = (HDRC_COMP)FDKcalloc(1, sizeof(DRC_COMP));
-
- if (hDcComp == NULL) {
- err = -1;
- goto bail;
- }
-
- FDKmemclear(hDcComp, sizeof(DRC_COMP));
-
- /* Return drc compressor instance */
- *phDrcComp = hDcComp;
- return err;
-bail:
- FDK_DRC_Generator_Close(&hDcComp);
- return err;
-}
-
-INT FDK_DRC_Generator_Close(
- HDRC_COMP *phDrcComp
- )
-{
- if (phDrcComp == NULL) {
- return -1;
- }
- if (*phDrcComp != NULL) {
- FDKfree(*phDrcComp);
- *phDrcComp = NULL;
- }
- return 0;
-}
-
-
-INT FDK_DRC_Generator_Initialize(
- HDRC_COMP drcComp,
- const DRC_PROFILE profileLine,
- const DRC_PROFILE profileRF,
- const INT blockLength,
- const UINT sampleRate,
- const CHANNEL_MODE channelMode,
- const CHANNEL_ORDER channelOrder,
- const UCHAR useWeighting
- )
-{
- int i;
- CHANNEL_MAPPING channelMapping;
-
- drcComp->limDecay = FL2FXCONST_DBL( ((0.006f / 256) * blockLength) / METADATA_INT_SCALE );
-
- /* Save parameters. */
- drcComp->blockLength = blockLength;
- drcComp->sampleRate = sampleRate;
- drcComp->chanConfig = channelMode;
- drcComp->useWeighting = useWeighting;
-
- if (FDK_DRC_Generator_setDrcProfile(drcComp, profileLine, profileRF)!=0) { /* expects initialized blockLength and sampleRate */
- return (-1);
- }
-
- /* Set number of channels and channel offsets. */
- if (FDKaacEnc_InitChannelMapping(channelMode, channelOrder, &channelMapping)!=AAC_ENC_OK) {
- return (-2);
- }
-
- for (i = 0; i < 9; i++) drcComp->channelIdx[i] = -1;
-
- switch (channelMode) {
- case MODE_1: /* mono */
- drcComp->channelIdx[C] = channelMapping.elInfo[0].ChannelIndex[0];
- break;
- case MODE_2: /* stereo */
- drcComp->channelIdx[L] = channelMapping.elInfo[0].ChannelIndex[0];
- drcComp->channelIdx[R] = channelMapping.elInfo[0].ChannelIndex[1];
- break;
- case MODE_1_2: /* 3ch */
- drcComp->channelIdx[L] = channelMapping.elInfo[1].ChannelIndex[0];
- drcComp->channelIdx[R] = channelMapping.elInfo[1].ChannelIndex[1];
- drcComp->channelIdx[C] = channelMapping.elInfo[0].ChannelIndex[0];
- break;
- case MODE_1_2_1: /* 4ch */
- drcComp->channelIdx[L] = channelMapping.elInfo[1].ChannelIndex[0];
- drcComp->channelIdx[R] = channelMapping.elInfo[1].ChannelIndex[1];
- drcComp->channelIdx[C] = channelMapping.elInfo[0].ChannelIndex[0];
- drcComp->channelIdx[S] = channelMapping.elInfo[2].ChannelIndex[0];
- break;
- case MODE_1_2_2: /* 5ch */
- drcComp->channelIdx[L] = channelMapping.elInfo[1].ChannelIndex[0];
- drcComp->channelIdx[R] = channelMapping.elInfo[1].ChannelIndex[1];
- drcComp->channelIdx[C] = channelMapping.elInfo[0].ChannelIndex[0];
- drcComp->channelIdx[LS] = channelMapping.elInfo[2].ChannelIndex[0];
- drcComp->channelIdx[RS] = channelMapping.elInfo[2].ChannelIndex[1];
- break;
- case MODE_1_2_2_1: /* 5.1 ch */
- drcComp->channelIdx[L] = channelMapping.elInfo[1].ChannelIndex[0];
- drcComp->channelIdx[R] = channelMapping.elInfo[1].ChannelIndex[1];
- drcComp->channelIdx[C] = channelMapping.elInfo[0].ChannelIndex[0];
- drcComp->channelIdx[LFE] = channelMapping.elInfo[3].ChannelIndex[0];
- drcComp->channelIdx[LS] = channelMapping.elInfo[2].ChannelIndex[0];
- drcComp->channelIdx[RS] = channelMapping.elInfo[2].ChannelIndex[1];
- break;
- case MODE_1_2_2_2_1: /* 7.1 ch */
- case MODE_7_1_FRONT_CENTER:
- drcComp->channelIdx[L] = channelMapping.elInfo[2].ChannelIndex[0]; /* l */
- drcComp->channelIdx[R] = channelMapping.elInfo[2].ChannelIndex[1]; /* r */
- drcComp->channelIdx[C] = channelMapping.elInfo[0].ChannelIndex[0]; /* c */
- drcComp->channelIdx[LFE] = channelMapping.elInfo[4].ChannelIndex[0]; /* lfe */
- drcComp->channelIdx[LS] = channelMapping.elInfo[3].ChannelIndex[0]; /* ls */
- drcComp->channelIdx[RS] = channelMapping.elInfo[3].ChannelIndex[1]; /* rs */
- drcComp->channelIdx[LS2] = channelMapping.elInfo[1].ChannelIndex[0]; /* lc */
- drcComp->channelIdx[RS2] = channelMapping.elInfo[1].ChannelIndex[1]; /* rc */
- break;
- case MODE_7_1_REAR_SURROUND:
- drcComp->channelIdx[L] = channelMapping.elInfo[1].ChannelIndex[0]; /* l */
- drcComp->channelIdx[R] = channelMapping.elInfo[1].ChannelIndex[1]; /* r */
- drcComp->channelIdx[C] = channelMapping.elInfo[0].ChannelIndex[0]; /* c */
- drcComp->channelIdx[LFE] = channelMapping.elInfo[4].ChannelIndex[0]; /* lfe */
- drcComp->channelIdx[LS] = channelMapping.elInfo[3].ChannelIndex[0]; /* lrear */
- drcComp->channelIdx[RS] = channelMapping.elInfo[3].ChannelIndex[1]; /* rrear */
- drcComp->channelIdx[LS2] = channelMapping.elInfo[2].ChannelIndex[0]; /* ls */
- drcComp->channelIdx[RS2] = channelMapping.elInfo[2].ChannelIndex[1]; /* rs */
- break;
- case MODE_1_1:
- case MODE_1_1_1_1:
- case MODE_1_1_1_1_1_1:
- case MODE_1_1_1_1_1_1_1_1:
- case MODE_1_1_1_1_1_1_1_1_1_1_1_1:
- case MODE_2_2:
- case MODE_2_2_2:
- case MODE_2_2_2_2:
- case MODE_2_2_2_2_2_2:
- default:
- return (-1);
- }
-
- drcComp->fullChannels = channelMapping.nChannelsEff;
- drcComp->channels = channelMapping.nChannels;
-
- /* Init states. */
- drcComp->smoothLevel[0] = drcComp->smoothLevel[1] = (FIXP_DBL)(-135<<METADATA_FRACT_BITS);
-
- FDKmemclear(drcComp->smoothGain, sizeof(drcComp->smoothGain));
- FDKmemclear(drcComp->holdCnt, sizeof(drcComp->holdCnt));
- FDKmemclear(drcComp->limGain, sizeof(drcComp->limGain));
- FDKmemclear(drcComp->prevPeak, sizeof(drcComp->prevPeak));
- FDKmemclear(drcComp->filter, sizeof(drcComp->filter));
-
- return (0);
-}
-
-
-INT FDK_DRC_Generator_setDrcProfile(
- HDRC_COMP drcComp,
- const DRC_PROFILE profileLine,
- const DRC_PROFILE profileRF
- )
-{
- int profileIdx, i;
-
- drcComp->profile[0] = profileLine;
- drcComp->profile[1] = profileRF;
-
- for (i = 0; i < 2; i++) {
- /* get profile index */
- switch (drcComp->profile[i]) {
- case DRC_NONE:
- case DRC_FILMSTANDARD: profileIdx = 0; break;
- case DRC_FILMLIGHT: profileIdx = 1; break;
- case DRC_MUSICSTANDARD: profileIdx = 2; break;
- case DRC_MUSICLIGHT: profileIdx = 3; break;
- case DRC_SPEECH: profileIdx = 4; break;
- case DRC_DELAY_TEST: profileIdx = 5; break;
- default: return (-1);
- }
-
- /* get parameters for selected profile */
- if (profileIdx >= 0) {
- drcComp->maxBoostThr[i] = tabMaxBoostThr[profileIdx];
- drcComp->boostThr[i] = tabBoostThr[profileIdx];
- drcComp->earlyCutThr[i] = tabEarlyCutThr[profileIdx];
- drcComp->cutThr[i] = tabCutThr[profileIdx];
- drcComp->maxCutThr[i] = tabMaxCutThr[profileIdx];
-
- drcComp->boostFac[i] = tabBoostRatio[profileIdx];
- drcComp->earlyCutFac[i] = tabEarlyCutRatio[profileIdx];
- drcComp->cutFac[i] = tabCutRatio[profileIdx];
-
- drcComp->maxBoost[i] = tabMaxBoost[profileIdx];
- drcComp->maxCut[i] = tabMaxCut[profileIdx];
- drcComp->maxEarlyCut[i] = - fMult((drcComp->cutThr[i] - drcComp->earlyCutThr[i]), drcComp->earlyCutFac[i]); /* no scaling after mult needed, earlyCutFac is in FIXP_DBL */
-
- drcComp->fastAttack[i] = tc2Coeff(tabFastAttack[profileIdx], drcComp->sampleRate, drcComp->blockLength);
- drcComp->fastDecay[i] = tc2Coeff(tabFastDecay[profileIdx], drcComp->sampleRate, drcComp->blockLength);
- drcComp->slowAttack[i] = tc2Coeff(tabSlowAttack[profileIdx], drcComp->sampleRate, drcComp->blockLength);
- drcComp->slowDecay[i] = tc2Coeff(tabSlowDecay[profileIdx], drcComp->sampleRate, drcComp->blockLength);
- drcComp->holdOff[i] = tabHoldOff[profileIdx] * 256 / drcComp->blockLength;
-
- drcComp->attackThr[i] = tabAttackThr[profileIdx];
- drcComp->decayThr[i] = tabDecayThr[profileIdx];
- }
-
- drcComp->smoothGain[i] = FL2FXCONST_DBL(0.f);
- }
- return (0);
-}
-
-
-INT FDK_DRC_Generator_Calc(
- HDRC_COMP drcComp,
- const INT_PCM * const inSamples,
- const INT dialnorm,
- const INT drc_TargetRefLevel,
- const INT comp_TargetRefLevel,
- FIXP_DBL clev,
- FIXP_DBL slev,
- INT * const pDynrng,
- INT * const pCompr
- )
-{
- int i, c;
- FIXP_DBL peak[2];
-
-
- /**************************************************************************
- * compressor
- **************************************************************************/
- if ((drcComp->profile[0] != DRC_NONE) || (drcComp->profile[1] != DRC_NONE)) {
- /* Calc loudness level */
- FIXP_DBL level_b = FL2FXCONST_DBL(0.f);
- int level_e = DFRACT_BITS-1;
-
- /* Increase energy time resolution with shorter processing blocks. 32 is an empiric value. */
- const int granuleLength = fixMin(32, drcComp->blockLength);
-
- if (drcComp->useWeighting) {
- FIXP_DBL x1, x2, y, y1, y2;
- /* sum of filter coefficients about 2.5 -> squared value is 6.25
- WEIGHTING_FILTER_SHIFT is 2 -> scaling about 16, therefore reduce granuleShift by 1.
- */
- const int granuleShift = getShiftFactor(granuleLength)-1;
-
- for (c = 0; c < (int)drcComp->channels; c++) {
- const INT_PCM* pSamples = &inSamples[c];
-
- if (c == drcComp->channelIdx[LFE]) {
- continue; /* skip LFE */
- }
-
- /* get filter states */
- x1 = drcComp->filter[c].x1;
- x2 = drcComp->filter[c].x2;
- y1 = drcComp->filter[c].y1;
- y2 = drcComp->filter[c].y2;
-
- i = 0;
-
- do {
-
- int offset = i;
- FIXP_DBL accu = FL2FXCONST_DBL(0.f);
-
- for (i=offset; i < fixMin(offset+granuleLength,drcComp->blockLength); i++) {
- /* apply weighting filter */
- FIXP_DBL x = FX_PCM2FX_DBL((FIXP_PCM)pSamples[i*drcComp->channels]) >> WEIGHTING_FILTER_SHIFT;
-
- /* y = b0 * (x - x2) - a1 * y1 - a2 * y2; */
- y = fMult(b0,x-x2) - fMult(a1,y1) - fMult(a2,y2);
-
- x2 = x1;
- x1 = x;
- y2 = y1;
- y1 = y;
-
- accu += fPow2Div2(y)>>(granuleShift-1); /* partial energy */
- } /* i */
-
- fixpAdd(accu, granuleShift+2*WEIGHTING_FILTER_SHIFT, &level_b, &level_e); /* sup up partial energies */
-
- } while ( i < drcComp->blockLength );
-
-
- /* save filter states */
- drcComp->filter[c].x1 = x1;
- drcComp->filter[c].x2 = x2;
- drcComp->filter[c].y1 = y1;
- drcComp->filter[c].y2 = y2;
- } /* c */
- } /* weighting */
- else {
- const int granuleShift = getShiftFactor(granuleLength);
-
- for (c = 0; c < (int)drcComp->channels; c++) {
- const INT_PCM* pSamples = &inSamples[c];
-
- if ((int)c == drcComp->channelIdx[LFE]) {
- continue; /* skip LFE */
- }
-
- i = 0;
-
- do {
- int offset = i;
- FIXP_DBL accu = FL2FXCONST_DBL(0.f);
-
- for (i=offset; i < fixMin(offset+granuleLength,drcComp->blockLength); i++) {
- /* partial energy */
- accu += fPow2Div2((FIXP_PCM)pSamples[i*drcComp->channels])>>(granuleShift-1);
- } /* i */
-
- fixpAdd(accu, granuleShift, &level_b, &level_e); /* sup up partial energies */
-
- } while ( i < drcComp->blockLength );
- }
- } /* weighting */
-
- /*
- * Convert to dBFS, apply dialnorm
- */
- /* level scaling */
-
- /* descaled level in ld64 representation */
- FIXP_DBL ldLevel = CalcLdData(level_b) + (FIXP_DBL)((level_e-12)<<(DFRACT_BITS-1-LD_DATA_SHIFT)) - CalcLdData((FIXP_DBL)(drcComp->blockLength<<(DFRACT_BITS-1-12)));
-
- /* if (level < 1e-10) level = 1e-10f; */
- ldLevel = FDKmax(ldLevel, FL2FXCONST_DBL(-0.51905126482615036685473741085772f));
-
- /* level = 10 * log(level)/log(10) + 3;
- * = 10*log(2)/log(10) * ld(level) + 3;
- * = 10 * 0.30102999566398119521373889472449 * ld(level) + 3
- * = 10 * (0.30102999566398119521373889472449 * ld(level) + 0.3)
- * = 10 * (0.30102999566398119521373889472449 * ld64(level) + 0.3/64) * 64
- *
- * additional scaling with METADATA_FRACT_BITS:
- * = 10 * (0.30102999566398119521373889472449 * ld64(level) + 0.3/64) * 64 * 2^(METADATA_FRACT_BITS)
- * = 10 * (0.30102999566398119521373889472449 * ld64(level) + 0.3/64) * 2^(METADATA_FRACT_BITS+LD_DATA_SHIFT)
- * = 10*2^(METADATA_FRACT_BITS+LD_DATA_SHIFT) * ( 0.30102999566398119521373889472449 * ld64(level) + 0.3/64 )
- * */
- FIXP_DBL level = fMult((FIXP_DBL)(10<<(METADATA_FRACT_BITS+LD_DATA_SHIFT)), fMult( FL2FXCONST_DBL(0.30102999566398119521373889472449f), ldLevel) + (FIXP_DBL)(FL2FXCONST_DBL(0.3f)>>LD_DATA_SHIFT) );
-
- /* level -= dialnorm + 31 */ /* this is fixed to Dolby-ReferenceLevel as compressor profiles are defined relative to this */
- level -= ((FIXP_DBL)(dialnorm<<(METADATA_FRACT_BITS-16)) + (FIXP_DBL)(31<<METADATA_FRACT_BITS));
-
- for (i = 0; i < 2; i++) {
- if (drcComp->profile[i] == DRC_NONE) {
- /* no compression */
- drcComp->smoothGain[i] = FL2FXCONST_DBL(0.f);
- }
- else {
- FIXP_DBL gain, alpha, lvl2smthlvl;
-
- /* calc static gain */
- if (level <= drcComp->maxBoostThr[i]) {
- /* max boost */
- gain = drcComp->maxBoost[i];
- }
- else if (level < drcComp->boostThr[i]) {
- /* boost range */
- gain = fMult((level - drcComp->boostThr[i]),drcComp->boostFac[i]);
- }
- else if (level <= drcComp->earlyCutThr[i]) {
- /* null band */
- gain = FL2FXCONST_DBL(0.f);
- }
- else if (level <= drcComp->cutThr[i]) {
- /* early cut range */
- gain = fMult((level - drcComp->earlyCutThr[i]), drcComp->earlyCutFac[i]);
- }
- else if (level < drcComp->maxCutThr[i]) {
- /* cut range */
- gain = fMult((level - drcComp->cutThr[i]), drcComp->cutFac[i]) - drcComp->maxEarlyCut[i];
- }
- else {
- /* max cut */
- gain = -drcComp->maxCut[i];
- }
-
- /* choose time constant */
- lvl2smthlvl = level - drcComp->smoothLevel[i];
- if (gain < drcComp->smoothGain[i]) {
- /* attack */
- if (lvl2smthlvl > drcComp->attackThr[i]) {
- /* fast attack */
- alpha = drcComp->fastAttack[i];
- }
- else {
- /* slow attack */
- alpha = drcComp->slowAttack[i];
- }
- }
- else {
- /* release */
- if (lvl2smthlvl < -drcComp->decayThr[i]) {
- /* fast release */
- alpha = drcComp->fastDecay[i];
- }
- else {
- /* slow release */
- alpha = drcComp->slowDecay[i];
- }
- }
-
- /* smooth gain & level */
- if ((gain < drcComp->smoothGain[i]) || (drcComp->holdCnt[i] == 0)) { /* hold gain unless we have an attack or hold period is over */
- FIXP_DBL accu;
-
- /* drcComp->smoothLevel[i] = (1-alpha) * drcComp->smoothLevel[i] + alpha * level; */
- accu = fMult(((FIXP_DBL)MAXVAL_DBL-alpha), drcComp->smoothLevel[i]);
- accu += fMult(alpha,level);
- drcComp->smoothLevel[i] = accu;
-
- /* drcComp->smoothGain[i] = (1-alpha) * drcComp->smoothGain[i] + alpha * gain; */
- accu = fMult(((FIXP_DBL)MAXVAL_DBL-alpha), drcComp->smoothGain[i]);
- accu += fMult(alpha,gain);
- drcComp->smoothGain[i] = accu;
- }
-
- /* hold counter */
- if (drcComp->holdCnt[i]) {
- drcComp->holdCnt[i]--;
- }
- if (gain < drcComp->smoothGain[i]) {
- drcComp->holdCnt[i] = drcComp->holdOff[i];
- }
- } /* profile != DRC_NONE */
- } /* for i=1..2 */
- } else {
- /* no compression */
- drcComp->smoothGain[0] = FL2FXCONST_DBL(0.f);
- drcComp->smoothGain[1] = FL2FXCONST_DBL(0.f);
- }
-
- /**************************************************************************
- * limiter
- **************************************************************************/
-
- /* find peak level */
- peak[0] = peak[1] = FL2FXCONST_DBL(0.f);
- for (i = 0; i < drcComp->blockLength; i++) {
- FIXP_DBL tmp;
- const INT_PCM* pSamples = &inSamples[i*drcComp->channels];
- INT_PCM maxSample = 0;
-
- /* single channels */
- for (c = 0; c < (int)drcComp->channels; c++) {
- maxSample = FDKmax(maxSample, fAbs(pSamples[c]));
- }
- peak[0] = fixMax(peak[0], FX_PCM2FX_DBL(maxSample)>>DOWNMIX_SHIFT);
-
- /* Lt/Rt downmix */
- if (drcComp->fullChannels > 2) {
- /* Lt */
- tmp = FL2FXCONST_DBL(0.f);
-
- if (drcComp->channelIdx[LS] >= 0) tmp -= fMultDiv2(FL2FXCONST_DBL(0.707f), (FIXP_PCM)pSamples[drcComp->channelIdx[LS]])>>(DOWNMIX_SHIFT-1); /* Ls */
- if (drcComp->channelIdx[LS2] >= 0) tmp -= fMultDiv2(FL2FXCONST_DBL(0.707f), (FIXP_PCM)pSamples[drcComp->channelIdx[LS2]])>>(DOWNMIX_SHIFT-1); /* Ls2 */
- if (drcComp->channelIdx[RS] >= 0) tmp -= fMultDiv2(FL2FXCONST_DBL(0.707f), (FIXP_PCM)pSamples[drcComp->channelIdx[RS]])>>(DOWNMIX_SHIFT-1); /* Rs */
- if (drcComp->channelIdx[RS2] >= 0) tmp -= fMultDiv2(FL2FXCONST_DBL(0.707f), (FIXP_PCM)pSamples[drcComp->channelIdx[RS2]])>>(DOWNMIX_SHIFT-1); /* Rs2 */
- if ((drcComp->channelIdx[LS] >= 0) && (drcComp->channelIdx[LS2] >= 0)) tmp = fMult(FL2FXCONST_DBL(0.707f), tmp); /* 7.1ch */
- if (drcComp->channelIdx[S] >= 0) tmp -= fMultDiv2(FL2FXCONST_DBL(0.707f), (FIXP_PCM)pSamples[drcComp->channelIdx[S]])>>(DOWNMIX_SHIFT-1); /* S */
- if (drcComp->channelIdx[C] >= 0) tmp += fMultDiv2(FL2FXCONST_DBL(0.707f), (FIXP_PCM)pSamples[drcComp->channelIdx[C]])>>(DOWNMIX_SHIFT-1); /* C */
- tmp += (FX_PCM2FX_DBL((FIXP_PCM)pSamples[drcComp->channelIdx[L]])>>DOWNMIX_SHIFT); /* L */
-
- peak[0] = fixMax(peak[0], fixp_abs(tmp));
-
- /* Rt */
- tmp = FL2FXCONST_DBL(0.f);
- if (drcComp->channelIdx[LS] >= 0) tmp += fMultDiv2(FL2FXCONST_DBL(0.707f), (FIXP_PCM)pSamples[drcComp->channelIdx[LS]])>>(DOWNMIX_SHIFT-1); /* Ls */
- if (drcComp->channelIdx[LS2] >= 0) tmp += fMultDiv2(FL2FXCONST_DBL(0.707f), (FIXP_PCM)pSamples[drcComp->channelIdx[LS2]])>>(DOWNMIX_SHIFT-1); /* Ls2 */
- if (drcComp->channelIdx[RS] >= 0) tmp += fMultDiv2(FL2FXCONST_DBL(0.707f), (FIXP_PCM)pSamples[drcComp->channelIdx[RS]])>>(DOWNMIX_SHIFT-1); /* Rs */
- if (drcComp->channelIdx[RS2] >= 0) tmp += fMultDiv2(FL2FXCONST_DBL(0.707f), (FIXP_PCM)pSamples[drcComp->channelIdx[RS2]])>>(DOWNMIX_SHIFT-1); /* Rs2 */
- if ((drcComp->channelIdx[RS] >= 0) && (drcComp->channelIdx[RS2] >= 0)) tmp = fMult(FL2FXCONST_DBL(0.707f), tmp); /* 7.1ch */
- if (drcComp->channelIdx[S] >= 0) tmp += fMultDiv2(FL2FXCONST_DBL(0.707f), (FIXP_PCM)pSamples[drcComp->channelIdx[S]])>>(DOWNMIX_SHIFT-1); /* S */
- if (drcComp->channelIdx[C] >= 0) tmp += fMultDiv2(FL2FXCONST_DBL(0.707f), (FIXP_PCM)pSamples[drcComp->channelIdx[C]])>>(DOWNMIX_SHIFT-1); /* C */
- tmp += (FX_PCM2FX_DBL((FIXP_PCM)pSamples[drcComp->channelIdx[R]])>>DOWNMIX_SHIFT); /* R */
-
- peak[0] = fixMax(peak[0], fixp_abs(tmp));
- }
-
- /* Lo/Ro downmix */
- if (drcComp->fullChannels > 2) {
- /* Lo */
- tmp = FL2FXCONST_DBL(0.f);
- if (drcComp->channelIdx[LS] >= 0) tmp += fMultDiv2(slev, (FIXP_PCM)pSamples[drcComp->channelIdx[LS]])>>(DOWNMIX_SHIFT-1); /* Ls */
- if (drcComp->channelIdx[LS2] >= 0) tmp += fMultDiv2(slev, (FIXP_PCM)pSamples[drcComp->channelIdx[LS2]])>>(DOWNMIX_SHIFT-1); /* Ls2 */
- if ((drcComp->channelIdx[LS] >= 0) && (drcComp->channelIdx[LS2] >= 0)) tmp = fMult(FL2FXCONST_DBL(0.707f), tmp); /* 7.1ch */
- if (drcComp->channelIdx[S] >= 0) tmp += fMultDiv2(slev, fMult(FL2FXCONST_DBL(0.7f), (FIXP_PCM)pSamples[drcComp->channelIdx[S]]))>>(DOWNMIX_SHIFT-1); /* S */
- if (drcComp->channelIdx[C] >= 0) tmp += fMultDiv2(clev, (FIXP_PCM)pSamples[drcComp->channelIdx[C]])>>(DOWNMIX_SHIFT-1); /* C */
- tmp += (FX_PCM2FX_DBL((FIXP_PCM)pSamples[drcComp->channelIdx[L]])>>DOWNMIX_SHIFT); /* L */
-
- peak[0] = fixMax(peak[0], fixp_abs(tmp));
-
- /* Ro */
- tmp = FL2FXCONST_DBL(0.f);
- if (drcComp->channelIdx[RS] >= 0) tmp += fMultDiv2(slev, (FIXP_PCM)pSamples[drcComp->channelIdx[RS]])>>(DOWNMIX_SHIFT-1); /* Rs */
- if (drcComp->channelIdx[RS2] >= 0) tmp += fMultDiv2(slev, (FIXP_PCM)pSamples[drcComp->channelIdx[RS2]])>>(DOWNMIX_SHIFT-1); /* Rs2 */
- if ((drcComp->channelIdx[RS] >= 0) && (drcComp->channelIdx[RS2] >= 0)) tmp = fMult(FL2FXCONST_DBL(0.707f), tmp); /* 7.1ch */
- if (drcComp->channelIdx[S] >= 0) tmp += fMultDiv2(slev, fMult(FL2FXCONST_DBL(0.7f), (FIXP_PCM)pSamples[drcComp->channelIdx[S]]))>>(DOWNMIX_SHIFT-1); /* S */
- if (drcComp->channelIdx[C] >= 0) tmp += fMultDiv2(clev, (FIXP_PCM)pSamples[drcComp->channelIdx[C]])>>(DOWNMIX_SHIFT-1); /* C */
- tmp += (FX_PCM2FX_DBL((FIXP_PCM)pSamples[drcComp->channelIdx[R]])>>DOWNMIX_SHIFT); /* R */
-
- peak[0] = fixMax(peak[0], fixp_abs(tmp));
- }
-
- peak[1] = fixMax(peak[0], peak[1]);
-
- /* Mono Downmix - for comp_val only */
- if (drcComp->fullChannels > 1) {
- tmp = FL2FXCONST_DBL(0.f);
- if (drcComp->channelIdx[LS] >= 0) tmp += fMultDiv2(slev, (FIXP_PCM)pSamples[drcComp->channelIdx[LS]])>>(DOWNMIX_SHIFT-1); /* Ls */
- if (drcComp->channelIdx[LS2] >= 0) tmp += fMultDiv2(slev, (FIXP_PCM)pSamples[drcComp->channelIdx[LS2]])>>(DOWNMIX_SHIFT-1); /* Ls2 */
- if (drcComp->channelIdx[RS] >= 0) tmp += fMultDiv2(slev, (FIXP_PCM)pSamples[drcComp->channelIdx[RS]])>>(DOWNMIX_SHIFT-1); /* Rs */
- if (drcComp->channelIdx[RS2] >= 0) tmp += fMultDiv2(slev, (FIXP_PCM)pSamples[drcComp->channelIdx[RS2]])>>(DOWNMIX_SHIFT-1); /* Rs2 */
- if ((drcComp->channelIdx[LS] >= 0) && (drcComp->channelIdx[LS2] >= 0)) tmp = fMult(FL2FXCONST_DBL(0.707f), tmp); /* 7.1ch */
- /*if ((drcComp->channelIdx[RS] >= 0) && (drcComp->channelIdx[RS2] >= 0)) tmp *=0.707f;*/ /* 7.1ch */
- if (drcComp->channelIdx[S] >= 0) tmp += fMultDiv2(slev, fMult(FL2FXCONST_DBL(0.7f), (FIXP_PCM)pSamples[drcComp->channelIdx[S]]))>>(DOWNMIX_SHIFT-1); /* S */
- if (drcComp->channelIdx[C] >= 0) tmp += fMult(clev, (FIXP_PCM)pSamples[drcComp->channelIdx[C]])>>(DOWNMIX_SHIFT-1); /* C (2*clev) */
- tmp += (FX_PCM2FX_DBL((FIXP_PCM)pSamples[drcComp->channelIdx[L]])>>DOWNMIX_SHIFT); /* L */
- tmp += (FX_PCM2FX_DBL((FIXP_PCM)pSamples[drcComp->channelIdx[R]])>>DOWNMIX_SHIFT); /* R */
-
- peak[1] = fixMax(peak[1], fixp_abs(tmp));
- }
- }
-
- for (i=0; i<2; i++) {
- FIXP_DBL tmp = drcComp->prevPeak[i];
- drcComp->prevPeak[i] = peak[i];
- peak[i] = fixMax(peak[i], tmp);
-
- /*
- * Convert to dBFS, apply dialnorm
- */
- /* descaled peak in ld64 representation */
- FIXP_DBL ld_peak = CalcLdData(peak[i]) + (FIXP_DBL)((LONG)DOWNMIX_SHIFT<<(DFRACT_BITS-1-LD_DATA_SHIFT));
-
- /* if (peak < 1e-6) level = 1e-6f; */
- ld_peak = FDKmax(ld_peak, FL2FXCONST_DBL(-0.31143075889569022011284244651463f));
-
- /* peak[i] = 20 * log(peak[i])/log(10) + 0.2f + (drcComp->smoothGain[i]*2^METADATA_FRACT_BITS)
- * peak[i] = 20 * log(2)/log(10) * ld(peak[i]) + 0.2f + (drcComp->smoothGain[i]*2^METADATA_FRACT_BITS)
- * peak[i] = 10 * 2*0.30102999566398119521373889472449 * ld(peak[i]) + 0.2f + (drcComp->smoothGain[i]*2^METADATA_FRACT_BITS)
- *
- * additional scaling with METADATA_FRACT_BITS:
- * peak[i] = (10 * 2*0.30102999566398119521373889472449 * ld64(peak[i]) * 64 + 0.2f + (drcComp->smoothGain[i]*2^METADATA_FRACT_BITS))*2^(-METADATA_FRACT_BITS)
- * peak[i] = 10*2^(METADATA_FRACT_BITS+LD_DATA_SHIFT) * 2*0.30102999566398119521373889472449 * ld64(peak[i])
- * + 0.2f*2^(-METADATA_FRACT_BITS) + drcComp->smoothGain[i]
- */
- peak[i] = fMult((FIXP_DBL)(10<<(METADATA_FRACT_BITS+LD_DATA_SHIFT)), fMult( FL2FX_DBL(2*0.30102999566398119521373889472449f), ld_peak));
- peak[i] += (FL2FX_DBL(0.5f)>>METADATA_INT_BITS); /* add a little bit headroom */
- peak[i] += drcComp->smoothGain[i];
- }
-
- /* peak -= dialnorm + 31; */ /* this is Dolby style only */
- peak[0] -= (FIXP_DBL)((dialnorm-drc_TargetRefLevel)<<(METADATA_FRACT_BITS-16)); /* peak[0] -= dialnorm - drc_TargetRefLevel */
-
- /* peak += 11; */ /* this is Dolby style only */ /* RF mode output is 11dB higher */
- /*peak += comp_TargetRefLevel - drc_TargetRefLevel;*/
- peak[1] -= (FIXP_DBL)((dialnorm-comp_TargetRefLevel)<<(METADATA_FRACT_BITS-16)); /* peak[1] -= dialnorm - comp_TargetRefLevel */
-
- /* limiter gain */
- drcComp->limGain[0] += drcComp->limDecay; /* linear limiter release */
- drcComp->limGain[0] = fixMin(drcComp->limGain[0], -peak[0]);
-
- drcComp->limGain[1] += 2*drcComp->limDecay; /* linear limiter release */
- drcComp->limGain[1] = fixMin(drcComp->limGain[1], -peak[1]);
-
- /*************************************************************************/
-
- /* apply limiting, return DRC gains*/
- {
- FIXP_DBL tmp;
-
- tmp = drcComp->smoothGain[0];
- if (drcComp->limGain[0] < FL2FXCONST_DBL(0.f)) {
- tmp += drcComp->limGain[0];
- }
- *pDynrng = (LONG) scaleValue(tmp, -(METADATA_FRACT_BITS-16));
-
- tmp = drcComp->smoothGain[1];
- if (drcComp->limGain[1] < FL2FXCONST_DBL(0.f)) {
- tmp += drcComp->limGain[1];
- }
- *pCompr = (LONG) scaleValue(tmp, -(METADATA_FRACT_BITS-16));
- }
-
- return 0;
-}
-
-
-DRC_PROFILE FDK_DRC_Generator_getDrcProfile(const HDRC_COMP drcComp)
-{
- return drcComp->profile[0];
-}
-
-DRC_PROFILE FDK_DRC_Generator_getCompProfile(const HDRC_COMP drcComp)
-{
- return drcComp->profile[1];
-}
-
-
diff --git a/libAACenc/src/metadata_compressor.h b/libAACenc/src/metadata_compressor.h
deleted file mode 100644
index ff639b5..0000000
--- a/libAACenc/src/metadata_compressor.h
+++ /dev/null
@@ -1,252 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/********************** Fraunhofer IIS FDK AAC Encoder lib ******************
-
- Author(s): M. Neusinger
- Description: Compressor for AAC Metadata Generator
-
-******************************************************************************/
-
-#ifndef _METADATA_COMPRESSOR_H
-#define _METADATA_COMPRESSOR_H
-
-
-#include "FDK_audio.h"
-#include "common_fix.h"
-
-#include "aacenc.h"
-
-
-/**
- * DRC compression profiles.
- */
-typedef enum DRC_PROFILE {
- DRC_NONE = 0,
- DRC_FILMSTANDARD = 1,
- DRC_FILMLIGHT = 2,
- DRC_MUSICSTANDARD = 3,
- DRC_MUSICLIGHT = 4,
- DRC_SPEECH = 5,
- DRC_DELAY_TEST = 6
-
-} DRC_PROFILE;
-
-
-/**
- * DRC Compressor handle.
- */
-typedef struct DRC_COMP DRC_COMP, *HDRC_COMP;
-
-/**
- * \brief Open a DRC Compressor instance.
- *
- * Allocate memory for a compressor instance.
- *
- * \param phDrcComp A pointer to a compressor handle. Initialized on return.
- *
- * \return
- * - 0, on succes.
- * - unequal 0, on failure.
- */
-INT FDK_DRC_Generator_Open(
- HDRC_COMP *phDrcComp
- );
-
-
-/**
- * \brief Close the DRC Compressor instance.
- *
- * Deallocate instance and free whole memory.
- *
- * \param phDrcComp Pointer to the compressor handle to be deallocated.
- *
- * \return
- * - 0, on succes.
- * - unequal 0, on failure.
- */
-INT FDK_DRC_Generator_Close(
- HDRC_COMP *phDrcComp
- );
-
-/**
- * \brief Configure DRC Compressor.
- *
- * \param drcComp Compressor handle.
- * \param profileLine DRC profile for line mode.
- * \param profileRF DRC profile for RF mode.
- * \param blockLength Length of processing block in samples per channel.
- * \param sampleRate Sampling rate in Hz.
- * \param channelMode Channel configuration.
- * \param channelOrder Channel order, MPEG or WAV.
- * \param useWeighting Use weighting filter for loudness calculation
- *
- * \return
- * - 0, on success,
- * - unequal 0, on failure
- */
-INT FDK_DRC_Generator_Initialize(
- HDRC_COMP drcComp,
- const DRC_PROFILE profileLine,
- const DRC_PROFILE profileRF,
- const INT blockLength,
- const UINT sampleRate,
- const CHANNEL_MODE channelMode,
- const CHANNEL_ORDER channelOrder,
- const UCHAR useWeighting
- );
-
-/**
- * \brief Calculate DRC Compressor Gain.
- *
- * \param drcComp Compressor handle.
- * \param inSamples Pointer to interleaved input audio samples.
- * \param dialnorm Dialog Level in dB (typically -31...-1).
- * \param drc_TargetRefLevel
- * \param comp_TargetRefLevel
- * \param clev Downmix center mix factor (typically 0.707, 0.595 or 0.5)
- * \param slev Downmix surround mix factor (typically 0.707, 0.5, or 0)
- * \param dynrng Pointer to variable receiving line mode DRC gain in dB
- * \param compr Pointer to variable receiving RF mode DRC gain in dB
- *
- * \return
- * - 0, on success,
- * - unequal 0, on failure
- */
-INT FDK_DRC_Generator_Calc(
- HDRC_COMP drcComp,
- const INT_PCM * const inSamples,
- const INT dialnorm,
- const INT drc_TargetRefLevel,
- const INT comp_TargetRefLevel,
- FIXP_DBL clev,
- FIXP_DBL slev,
- INT * const dynrng,
- INT * const compr
- );
-
-
-/**
- * \brief Configure DRC Compressor Profile.
- *
- * \param drcComp Compressor handle.
- * \param profileLine DRC profile for line mode.
- * \param profileRF DRC profile for RF mode.
- *
- * \return
- * - 0, on success,
- * - unequal 0, on failure
- */
-INT FDK_DRC_Generator_setDrcProfile(
- HDRC_COMP drcComp,
- const DRC_PROFILE profileLine,
- const DRC_PROFILE profileRF
- );
-
-
-/**
- * \brief Get DRC profile for line mode.
- *
- * \param drcComp Compressor handle.
- *
- * \return Current Profile.
- */
-DRC_PROFILE FDK_DRC_Generator_getDrcProfile(
- const HDRC_COMP drcComp
- );
-
-
-/**
- * \brief Get DRC profile for RF mode.
- *
- * \param drcComp Compressor handle.
- *
- * \return Current Profile.
- */
-DRC_PROFILE FDK_DRC_Generator_getCompProfile(
- const HDRC_COMP drcComp
- );
-
-
-#endif /* _METADATA_COMPRESSOR_H */
-
diff --git a/libAACenc/src/metadata_main.cpp b/libAACenc/src/metadata_main.cpp
deleted file mode 100644
index e920793..0000000
--- a/libAACenc/src/metadata_main.cpp
+++ /dev/null
@@ -1,871 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/********************** Fraunhofer IIS FDK AAC Encoder lib ******************
-
- Author(s): V. Bacigalupo
- Description: Metadata Encoder library interface functions
-
-******************************************************************************/
-
-
-#include "metadata_main.h"
-#include "metadata_compressor.h"
-#include "FDK_bitstream.h"
-#include "FDK_audio.h"
-#include "genericStds.h"
-
-/*----------------- defines ----------------------*/
-#define MAX_DRC_BANDS (1<<4)
-#define MAX_DRC_CHANNELS (8)
-#define MAX_DRC_FRAMELEN (2*1024)
-
-/*--------------- structure definitions --------------------*/
-
-typedef struct AAC_METADATA
-{
- /* MPEG: Dynamic Range Control */
- struct {
- UCHAR prog_ref_level_present;
- SCHAR prog_ref_level;
-
- UCHAR dyn_rng_sgn[MAX_DRC_BANDS];
- UCHAR dyn_rng_ctl[MAX_DRC_BANDS];
-
- UCHAR drc_bands_present;
- UCHAR drc_band_incr;
- UCHAR drc_band_top[MAX_DRC_BANDS];
- UCHAR drc_interpolation_scheme;
- AACENC_METADATA_DRC_PROFILE drc_profile;
- INT drc_TargetRefLevel; /* used for Limiter */
-
- /* excluded channels */
- UCHAR excluded_chns_present;
- UCHAR exclude_mask[2]; /* MAX_NUMBER_CHANNELS/8 */
- } mpegDrc;
-
- /* ETSI: addtl ancillary data */
- struct {
- /* Heavy Compression */
- UCHAR compression_on; /* flag, if compression value should be written */
- UCHAR compression_value; /* compression value */
- AACENC_METADATA_DRC_PROFILE comp_profile;
- INT comp_TargetRefLevel; /* used for Limiter */
- INT timecode_coarse_status;
- INT timecode_fine_status;
- } etsiAncData;
-
- SCHAR centerMixLevel; /* center downmix level (0...7, according to table) */
- SCHAR surroundMixLevel; /* surround downmix level (0...7, according to table) */
- UCHAR WritePCEMixDwnIdx; /* flag */
- UCHAR DmxLvl_On; /* flag */
-
- UCHAR dolbySurroundMode;
-
- UCHAR metadataMode; /* indicate meta data mode in current frame (delay line) */
-
-} AAC_METADATA;
-
-struct FDK_METADATA_ENCODER
-{
- INT metadataMode;
- HDRC_COMP hDrcComp;
- AACENC_MetaData submittedMetaData;
-
- INT nAudioDataDelay;
- INT nMetaDataDelay;
- INT nChannels;
-
- INT_PCM audioDelayBuffer[MAX_DRC_CHANNELS*MAX_DRC_FRAMELEN];
- int audioDelayIdx;
-
- AAC_METADATA metaDataBuffer[3];
- int metaDataDelayIdx;
-
- UCHAR drcInfoPayload[12];
- UCHAR drcDsePayload[8];
-
- INT matrix_mixdown_idx;
- AACENC_EXT_PAYLOAD exPayload[2];
- INT nExtensions;
-
- INT finalizeMetaData; /* Delay switch off by one frame and write default configuration to
- finalize the metadata setup. */
-};
-
-
-/*---------------- constants -----------------------*/
-static const AACENC_MetaData defaultMetaDataSetup = {
- AACENC_METADATA_DRC_NONE,
- AACENC_METADATA_DRC_NONE,
- -(31<<16),
- -(31<<16),
- 0,
- -(31<<16),
- 0,
- 0,
- 0,
- 0,
- 0
-};
-
-static const FIXP_DBL dmxTable[8] = {
- ((FIXP_DBL)MAXVAL_DBL), FL2FXCONST_DBL(0.841f), FL2FXCONST_DBL(0.707f), FL2FXCONST_DBL(0.596f),
- FL2FXCONST_DBL(0.500f), FL2FXCONST_DBL(0.422f), FL2FXCONST_DBL(0.355f), FL2FXCONST_DBL(0.000f)
-};
-
-static const UCHAR surmix2matrix_mixdown_idx[8] = {
- 0, 0, 0, 1, 1, 2, 2, 3
-};
-
-
-/*--------------- function declarations --------------------*/
-static FDK_METADATA_ERROR WriteMetadataPayload(
- const HANDLE_FDK_METADATA_ENCODER hMetaData,
- const AAC_METADATA * const pMetadata
- );
-
-static INT WriteDynamicRangeInfoPayload(
- const AAC_METADATA* const pMetadata,
- UCHAR* const pExtensionPayload
- );
-
-static INT WriteEtsiAncillaryDataPayload(
- const AAC_METADATA* const pMetadata,
- UCHAR* const pExtensionPayload
- );
-
-static FDK_METADATA_ERROR CompensateAudioDelay(
- HANDLE_FDK_METADATA_ENCODER hMetaDataEnc,
- INT_PCM * const pAudioSamples,
- const INT nAudioSamples
- );
-
-static FDK_METADATA_ERROR LoadSubmittedMetadata(
- const AACENC_MetaData * const hMetadata,
- const INT nChannels,
- const INT metadataMode,
- AAC_METADATA * const pAacMetaData
- );
-
-static FDK_METADATA_ERROR ProcessCompressor(
- AAC_METADATA *pMetadata,
- HDRC_COMP hDrcComp,
- const INT_PCM * const pSamples,
- const INT nSamples
- );
-
-/*------------- function definitions ----------------*/
-
-static DRC_PROFILE convertProfile(AACENC_METADATA_DRC_PROFILE aacProfile)
-{
- DRC_PROFILE drcProfile = DRC_NONE;
-
- switch(aacProfile) {
- case AACENC_METADATA_DRC_NONE: drcProfile = DRC_NONE; break;
- case AACENC_METADATA_DRC_FILMSTANDARD: drcProfile = DRC_FILMSTANDARD; break;
- case AACENC_METADATA_DRC_FILMLIGHT: drcProfile = DRC_FILMLIGHT; break;
- case AACENC_METADATA_DRC_MUSICSTANDARD: drcProfile = DRC_MUSICSTANDARD; break;
- case AACENC_METADATA_DRC_MUSICLIGHT: drcProfile = DRC_MUSICLIGHT; break;
- case AACENC_METADATA_DRC_SPEECH: drcProfile = DRC_SPEECH; break;
- default: drcProfile = DRC_NONE; break;
- }
- return drcProfile;
-}
-
-
-/* convert dialog normalization to program reference level */
-/* NOTE: this only is correct, if the decoder target level is set to -31dB for line mode / -20dB for RF mode */
-static UCHAR dialnorm2progreflvl(const INT d)
-{
- return ((UCHAR)FDKmax(0, FDKmin((-d + (1<<13)) >> 14, 127)));
-}
-
-/* convert program reference level to dialog normalization */
-static INT progreflvl2dialnorm(const UCHAR p)
-{
- return -((INT)(p<<(16-2)));
-}
-
-/* encode downmix levels to Downmixing_levels_MPEG4 */
-static SCHAR encodeDmxLvls(const SCHAR cmixlev, const SCHAR surmixlev)
-{
- SCHAR dmxLvls = 0;
- dmxLvls |= 0x80 | (cmixlev << 4); /* center_mix_level_on */
- dmxLvls |= 0x08 | surmixlev; /* surround_mix_level_on */
-
- return dmxLvls;
-}
-
-/* encode AAC DRC gain (ISO/IEC 14496-3:2005 4.5.2.7) */
-static void encodeDynrng(INT gain, UCHAR* const dyn_rng_ctl, UCHAR* const dyn_rng_sgn )
-{
- if(gain < 0)
- {
- *dyn_rng_sgn = 1;
- gain = -gain;
- }
- else
- {
- *dyn_rng_sgn = 0;
- }
- gain = FDKmin(gain,(127<<14));
-
- *dyn_rng_ctl = (UCHAR)((gain + (1<<13)) >> 14);
-}
-
-/* decode AAC DRC gain (ISO/IEC 14496-3:2005 4.5.2.7) */
-static INT decodeDynrng(const UCHAR dyn_rng_ctl, const UCHAR dyn_rng_sgn)
-{
- INT tmp = ((INT)dyn_rng_ctl << (16-2));
- if (dyn_rng_sgn) tmp = -tmp;
-
- return tmp;
-}
-
-/* encode AAC compression value (ETSI TS 101 154 page 99) */
-static UCHAR encodeCompr(INT gain)
-{
- UCHAR x, y;
- INT tmp;
-
- /* tmp = (int)((48.164f - gain) / 6.0206f * 15 + 0.5f); */
- tmp = ((3156476 - gain) * 15 + 197283) / 394566;
-
- if (tmp >= 240) {
- return 0xFF;
- }
- else if (tmp < 0) {
- return 0;
- }
- else {
- x = tmp / 15;
- y = tmp % 15;
- }
-
- return (x << 4) | y;
-}
-
-/* decode AAC compression value (ETSI TS 101 154 page 99) */
-static INT decodeCompr(const UCHAR compr)
-{
- INT gain;
- SCHAR x = compr >> 4; /* 4 MSB of compr */
- UCHAR y = (compr & 0x0F); /* 4 LSB of compr */
-
- /* gain = (INT)((48.164f - 6.0206f * x - 0.4014f * y) ); */
- gain = (INT)( scaleValue(((LONG)FL2FXCONST_DBL(6.0206f/128.f)*(8-x) - (LONG)FL2FXCONST_DBL(0.4014f/128.f)*y), -(DFRACT_BITS-1-7-16)) );
-
- return gain;
-}
-
-
-FDK_METADATA_ERROR FDK_MetadataEnc_Open(
- HANDLE_FDK_METADATA_ENCODER *phMetaData
- )
-{
- FDK_METADATA_ERROR err = METADATA_OK;
- HANDLE_FDK_METADATA_ENCODER hMetaData = NULL;
-
- if (phMetaData == NULL) {
- err = METADATA_INVALID_HANDLE;
- goto bail;
- }
-
- /* allocate memory */
- hMetaData = (HANDLE_FDK_METADATA_ENCODER) FDKcalloc(1, sizeof(FDK_METADATA_ENCODER) );
-
- if (hMetaData == NULL) {
- err = METADATA_MEMORY_ERROR;
- goto bail;
- }
-
- FDKmemclear(hMetaData, sizeof(FDK_METADATA_ENCODER));
-
- /* Allocate DRC Compressor. */
- if (FDK_DRC_Generator_Open(&hMetaData->hDrcComp)!=0) {
- err = METADATA_MEMORY_ERROR;
- goto bail;
- }
-
- /* Return metadata instance */
- *phMetaData = hMetaData;
-
- return err;
-
-bail:
- FDK_MetadataEnc_Close(&hMetaData);
- return err;
-}
-
-FDK_METADATA_ERROR FDK_MetadataEnc_Close(
- HANDLE_FDK_METADATA_ENCODER *phMetaData
- )
-{
- FDK_METADATA_ERROR err = METADATA_OK;
-
- if (phMetaData == NULL) {
- err = METADATA_INVALID_HANDLE;
- goto bail;
- }
-
- if (*phMetaData != NULL) {
- FDK_DRC_Generator_Close(&(*phMetaData)->hDrcComp);
- FDKfree(*phMetaData);
- *phMetaData = NULL;
- }
-bail:
- return err;
-}
-
-FDK_METADATA_ERROR FDK_MetadataEnc_Init(
- HANDLE_FDK_METADATA_ENCODER hMetaData,
- const INT resetStates,
- const INT metadataMode,
- const INT audioDelay,
- const UINT frameLength,
- const UINT sampleRate,
- const UINT nChannels,
- const CHANNEL_MODE channelMode,
- const CHANNEL_ORDER channelOrder
- )
-{
- FDK_METADATA_ERROR err = METADATA_OK;
- int i, nFrames, delay;
-
- if (hMetaData==NULL) {
- err = METADATA_INVALID_HANDLE;
- goto bail;
- }
-
- /* Determine values for delay compensation. */
- for (nFrames=0, delay=audioDelay-frameLength; delay>0; delay-=frameLength, nFrames++);
-
- if ( (hMetaData->nChannels>MAX_DRC_CHANNELS) || ((-delay)>MAX_DRC_FRAMELEN) ) {
- err = METADATA_INIT_ERROR;
- goto bail;
- }
-
- /* Initialize with default setup. */
- FDKmemcpy(&hMetaData->submittedMetaData, &defaultMetaDataSetup, sizeof(AACENC_MetaData));
-
- hMetaData->finalizeMetaData = 0; /* finalize meta data only while on/off switching, else disabled */
-
- /* Reset delay lines. */
- if ( resetStates || (hMetaData->nAudioDataDelay!=-delay) || (hMetaData->nChannels!=(INT)nChannels) )
- {
- FDKmemclear(hMetaData->audioDelayBuffer, sizeof(hMetaData->audioDelayBuffer));
- FDKmemclear(hMetaData->metaDataBuffer, sizeof(hMetaData->metaDataBuffer));
- hMetaData->audioDelayIdx = 0;
- hMetaData->metaDataDelayIdx = 0;
- }
- else {
- /* Enable meta data. */
- if ( (hMetaData->metadataMode==0) && (metadataMode!=0) ) {
- /* disable meta data in all delay lines */
- for (i=0; i<(int)(sizeof(hMetaData->metaDataBuffer)/sizeof(AAC_METADATA)); i++) {
- LoadSubmittedMetadata(&hMetaData->submittedMetaData, nChannels, 0, &hMetaData->metaDataBuffer[i]);
- }
- }
-
- /* Disable meta data.*/
- if ( (hMetaData->metadataMode!=0) && (metadataMode==0) ) {
- hMetaData->finalizeMetaData = hMetaData->metadataMode;
- }
- }
-
- /* Initialize delay. */
- hMetaData->nAudioDataDelay = -delay;
- hMetaData->nMetaDataDelay = nFrames;
- hMetaData->nChannels = nChannels;
- hMetaData->metadataMode = metadataMode;
-
- /* Initialize compressor. */
- if (metadataMode != 0) {
- if ( FDK_DRC_Generator_Initialize(
- hMetaData->hDrcComp,
- DRC_NONE,
- DRC_NONE,
- frameLength,
- sampleRate,
- channelMode,
- channelOrder,
- 1) != 0)
- {
- err = METADATA_INIT_ERROR;
- }
- }
-bail:
- return err;
-}
-
-static FDK_METADATA_ERROR ProcessCompressor(
- AAC_METADATA *pMetadata,
- HDRC_COMP hDrcComp,
- const INT_PCM * const pSamples,
- const INT nSamples
- )
-{
- FDK_METADATA_ERROR err = METADATA_OK;
-
- INT dynrng, compr;
- DRC_PROFILE profileDrc = convertProfile(pMetadata->mpegDrc.drc_profile);
- DRC_PROFILE profileComp = convertProfile(pMetadata->etsiAncData.comp_profile);
-
- if ( (pMetadata==NULL) || (hDrcComp==NULL) ) {
- err = METADATA_INVALID_HANDLE;
- return err;
- }
-
- /* first, check if profile is same as last frame
- * otherwise, update setup */
- if ( (profileDrc != FDK_DRC_Generator_getDrcProfile(hDrcComp))
- || (profileComp != FDK_DRC_Generator_getCompProfile(hDrcComp)) )
- {
- FDK_DRC_Generator_setDrcProfile(hDrcComp, profileDrc, profileComp);
- }
-
- /* Sanity check */
- if (profileComp == DRC_NONE) {
- pMetadata->etsiAncData.compression_value = 0x80; /* to ensure no external values will be written if not configured */
- }
-
- /* in case of embedding external values, copy this now (limiter may overwrite them) */
- dynrng = decodeDynrng(pMetadata->mpegDrc.dyn_rng_ctl[0], pMetadata->mpegDrc.dyn_rng_sgn[0]);
- compr = decodeCompr(pMetadata->etsiAncData.compression_value);
-
- /* Call compressor */
- if (FDK_DRC_Generator_Calc(hDrcComp,
- pSamples,
- progreflvl2dialnorm(pMetadata->mpegDrc.prog_ref_level),
- pMetadata->mpegDrc.drc_TargetRefLevel,
- pMetadata->etsiAncData.comp_TargetRefLevel,
- dmxTable[pMetadata->centerMixLevel],
- dmxTable[pMetadata->surroundMixLevel],
- &dynrng,
- &compr) != 0)
- {
- err = METADATA_ENCODE_ERROR;
- goto bail;
- }
-
- /* Write DRC values */
- pMetadata->mpegDrc.drc_band_incr = 0;
- encodeDynrng(dynrng, pMetadata->mpegDrc.dyn_rng_ctl, pMetadata->mpegDrc.dyn_rng_sgn);
- pMetadata->etsiAncData.compression_value = encodeCompr(compr);
-
-bail:
- return err;
-}
-
-FDK_METADATA_ERROR FDK_MetadataEnc_Process(
- HANDLE_FDK_METADATA_ENCODER hMetaDataEnc,
- INT_PCM * const pAudioSamples,
- const INT nAudioSamples,
- const AACENC_MetaData * const pMetadata,
- AACENC_EXT_PAYLOAD ** ppMetaDataExtPayload,
- UINT * nMetaDataExtensions,
- INT * matrix_mixdown_idx
- )
-{
- FDK_METADATA_ERROR err = METADATA_OK;
- int metaDataDelayWriteIdx, metaDataDelayReadIdx, metadataMode;
-
- /* Where to write new meta data info */
- metaDataDelayWriteIdx = hMetaDataEnc->metaDataDelayIdx;
-
- /* How to write the data */
- metadataMode = hMetaDataEnc->metadataMode;
-
- /* Compensate meta data delay. */
- hMetaDataEnc->metaDataDelayIdx++;
- if (hMetaDataEnc->metaDataDelayIdx > hMetaDataEnc->nMetaDataDelay) hMetaDataEnc->metaDataDelayIdx = 0;
-
- /* Where to read pending meta data info from. */
- metaDataDelayReadIdx = hMetaDataEnc->metaDataDelayIdx;
-
- /* Submit new data if available. */
- if (pMetadata!=NULL) {
- FDKmemcpy(&hMetaDataEnc->submittedMetaData, pMetadata, sizeof(AACENC_MetaData));
- }
-
- /* Write one additional frame with default configuration of meta data. Ensure defined behaviour on decoder side. */
- if ( (hMetaDataEnc->finalizeMetaData!=0) && (hMetaDataEnc->metadataMode==0)) {
- FDKmemcpy(&hMetaDataEnc->submittedMetaData, &defaultMetaDataSetup, sizeof(AACENC_MetaData));
- metadataMode = hMetaDataEnc->finalizeMetaData;
- hMetaDataEnc->finalizeMetaData = 0;
- }
-
- /* Get last submitted data. */
- if ( (err = LoadSubmittedMetadata(
- &hMetaDataEnc->submittedMetaData,
- hMetaDataEnc->nChannels,
- metadataMode,
- &hMetaDataEnc->metaDataBuffer[metaDataDelayWriteIdx])) != METADATA_OK )
- {
- goto bail;
- }
-
- /* Calculate compressor if necessary and updata meta data info */
- if (hMetaDataEnc->metaDataBuffer[metaDataDelayWriteIdx].metadataMode != 0) {
- if ( (err = ProcessCompressor(
- &hMetaDataEnc->metaDataBuffer[metaDataDelayWriteIdx],
- hMetaDataEnc->hDrcComp,
- pAudioSamples,
- nAudioSamples)) != METADATA_OK)
- {
- /* Get last submitted data again. */
- LoadSubmittedMetadata(
- &hMetaDataEnc->submittedMetaData,
- hMetaDataEnc->nChannels,
- metadataMode,
- &hMetaDataEnc->metaDataBuffer[metaDataDelayWriteIdx]);
- }
- }
-
- /* Convert Meta Data side info to bitstream data. */
- if ( (err = WriteMetadataPayload(hMetaDataEnc, &hMetaDataEnc->metaDataBuffer[metaDataDelayReadIdx])) != METADATA_OK ) {
- goto bail;
- }
-
- /* Assign meta data to output */
- *ppMetaDataExtPayload = hMetaDataEnc->exPayload;
- *nMetaDataExtensions = hMetaDataEnc->nExtensions;
- *matrix_mixdown_idx = hMetaDataEnc->matrix_mixdown_idx;
-
-bail:
- /* Compensate audio delay, reset err status. */
- err = CompensateAudioDelay(hMetaDataEnc, pAudioSamples, nAudioSamples);
-
- return err;
-}
-
-
-static FDK_METADATA_ERROR CompensateAudioDelay(
- HANDLE_FDK_METADATA_ENCODER hMetaDataEnc,
- INT_PCM * const pAudioSamples,
- const INT nAudioSamples
- )
-{
- FDK_METADATA_ERROR err = METADATA_OK;
-
- if (hMetaDataEnc->nAudioDataDelay) {
- int i, delaySamples = hMetaDataEnc->nAudioDataDelay*hMetaDataEnc->nChannels;
-
- for (i = 0; i < nAudioSamples; i++) {
- INT_PCM tmp = pAudioSamples[i];
- pAudioSamples[i] = hMetaDataEnc->audioDelayBuffer[hMetaDataEnc->audioDelayIdx];
- hMetaDataEnc->audioDelayBuffer[hMetaDataEnc->audioDelayIdx] = tmp;
-
- hMetaDataEnc->audioDelayIdx++;
- if (hMetaDataEnc->audioDelayIdx >= delaySamples) hMetaDataEnc->audioDelayIdx = 0;
- }
- }
-
- return err;
-}
-
-/*-----------------------------------------------------------------------------
-
- functionname: WriteMetadataPayload
- description: fills anc data and extension payload
- returns: Error status
-
- ------------------------------------------------------------------------------*/
-static FDK_METADATA_ERROR WriteMetadataPayload(
- const HANDLE_FDK_METADATA_ENCODER hMetaData,
- const AAC_METADATA * const pMetadata
- )
-{
- FDK_METADATA_ERROR err = METADATA_OK;
-
- if ( (hMetaData==NULL) || (pMetadata==NULL) ) {
- err = METADATA_INVALID_HANDLE;
- goto bail;
- }
-
- hMetaData->nExtensions = 0;
- hMetaData->matrix_mixdown_idx = -1;
-
- /* AAC-DRC */
- if (pMetadata->metadataMode != 0)
- {
- hMetaData->exPayload[hMetaData->nExtensions].pData = hMetaData->drcInfoPayload;
- hMetaData->exPayload[hMetaData->nExtensions].dataType = EXT_DYNAMIC_RANGE;
- hMetaData->exPayload[hMetaData->nExtensions].associatedChElement = -1;
-
- hMetaData->exPayload[hMetaData->nExtensions].dataSize =
- WriteDynamicRangeInfoPayload(pMetadata, hMetaData->exPayload[hMetaData->nExtensions].pData);
-
- hMetaData->nExtensions++;
-
- /* Matrix Mixdown Coefficient in PCE */
- if (pMetadata->WritePCEMixDwnIdx) {
- hMetaData->matrix_mixdown_idx = surmix2matrix_mixdown_idx[pMetadata->surroundMixLevel];
- }
-
- /* ETSI TS 101 154 (DVB) - MPEG4 ancillary_data() */
- if (pMetadata->metadataMode == 2) /* MP4_METADATA_MPEG_ETSI */
- {
- hMetaData->exPayload[hMetaData->nExtensions].pData = hMetaData->drcDsePayload;
- hMetaData->exPayload[hMetaData->nExtensions].dataType = EXT_DATA_ELEMENT;
- hMetaData->exPayload[hMetaData->nExtensions].associatedChElement = -1;
-
- hMetaData->exPayload[hMetaData->nExtensions].dataSize =
- WriteEtsiAncillaryDataPayload(pMetadata,hMetaData->exPayload[hMetaData->nExtensions].pData);
-
- hMetaData->nExtensions++;
- } /* metadataMode == 2 */
-
- } /* metadataMode != 0 */
-
-bail:
- return err;
-}
-
-static INT WriteDynamicRangeInfoPayload(
- const AAC_METADATA* const pMetadata,
- UCHAR* const pExtensionPayload
- )
-{
- const INT pce_tag_present = 0; /* yet fixed setting! */
- const INT prog_ref_lev_res_bits = 0;
- INT i, drc_num_bands = 1;
-
- FDK_BITSTREAM bsWriter;
- FDKinitBitStream(&bsWriter, pExtensionPayload, 16, 0, BS_WRITER);
-
- /* dynamic_range_info() */
- FDKwriteBits(&bsWriter, pce_tag_present, 1); /* pce_tag_present */
- if (pce_tag_present) {
- FDKwriteBits(&bsWriter, 0x0, 4); /* pce_instance_tag */
- FDKwriteBits(&bsWriter, 0x0, 4); /* drc_tag_reserved_bits */
- }
-
- /* Exclude channels */
- FDKwriteBits(&bsWriter, (pMetadata->mpegDrc.excluded_chns_present) ? 1 : 0, 1); /* excluded_chns_present*/
-
- /* Multiband DRC */
- FDKwriteBits(&bsWriter, (pMetadata->mpegDrc.drc_bands_present) ? 1 : 0, 1); /* drc_bands_present */
- if (pMetadata->mpegDrc.drc_bands_present)
- {
- FDKwriteBits(&bsWriter, pMetadata->mpegDrc.drc_band_incr, 4); /* drc_band_incr */
- FDKwriteBits(&bsWriter, pMetadata->mpegDrc.drc_interpolation_scheme, 4); /* drc_interpolation_scheme */
- drc_num_bands += pMetadata->mpegDrc.drc_band_incr;
- for (i=0; i<drc_num_bands; i++) {
- FDKwriteBits(&bsWriter, pMetadata->mpegDrc.drc_band_top[i], 8); /* drc_band_top */
- }
- }
-
- /* Program Reference Level */
- FDKwriteBits(&bsWriter, pMetadata->mpegDrc.prog_ref_level_present, 1); /* prog_ref_level_present */
- if (pMetadata->mpegDrc.prog_ref_level_present)
- {
- FDKwriteBits(&bsWriter, pMetadata->mpegDrc.prog_ref_level, 7); /* prog_ref_level */
- FDKwriteBits(&bsWriter, prog_ref_lev_res_bits, 1); /* prog_ref_level_reserved_bits */
- }
-
- /* DRC Values */
- for (i=0; i<drc_num_bands; i++) {
- FDKwriteBits(&bsWriter, (pMetadata->mpegDrc.dyn_rng_sgn[i]) ? 1 : 0, 1); /* dyn_rng_sgn[ */
- FDKwriteBits(&bsWriter, pMetadata->mpegDrc.dyn_rng_ctl[i], 7); /* dyn_rng_ctl */
- }
-
- /* return number of valid bits in extension payload. */
- return FDKgetValidBits(&bsWriter);
-}
-
-static INT WriteEtsiAncillaryDataPayload(
- const AAC_METADATA* const pMetadata,
- UCHAR* const pExtensionPayload
- )
-{
- FDK_BITSTREAM bsWriter;
- FDKinitBitStream(&bsWriter, pExtensionPayload, 16, 0, BS_WRITER);
-
- /* ancillary_data_sync */
- FDKwriteBits(&bsWriter, 0xBC, 8);
-
- /* bs_info */
- FDKwriteBits(&bsWriter, 0x3, 2); /* mpeg_audio_type */
- FDKwriteBits(&bsWriter, pMetadata->dolbySurroundMode, 2); /* dolby_surround_mode */
- FDKwriteBits(&bsWriter, 0x0, 4); /* reserved */
-
- /* ancillary_data_status */
- FDKwriteBits(&bsWriter, 0, 3); /* 3 bit Reserved, set to "0" */
- FDKwriteBits(&bsWriter, (pMetadata->DmxLvl_On) ? 1 : 0, 1); /* downmixing_levels_MPEG4_status */
- FDKwriteBits(&bsWriter, 0, 1); /* Reserved, set to "0" */
- FDKwriteBits(&bsWriter, (pMetadata->etsiAncData.compression_on) ? 1 : 0, 1); /* audio_coding_mode_and_compression status */
- FDKwriteBits(&bsWriter, (pMetadata->etsiAncData.timecode_coarse_status) ? 1 : 0, 1); /* coarse_grain_timecode_status */
- FDKwriteBits(&bsWriter, (pMetadata->etsiAncData.timecode_fine_status) ? 1 : 0, 1); /* fine_grain_timecode_status */
-
- /* downmixing_levels_MPEG4_status */
- if (pMetadata->DmxLvl_On) {
- FDKwriteBits(&bsWriter, encodeDmxLvls(pMetadata->centerMixLevel, pMetadata->surroundMixLevel), 8);
- }
-
- /* audio_coding_mode_and_compression_status */
- if (pMetadata->etsiAncData.compression_on) {
- FDKwriteBits(&bsWriter, 0x01, 8); /* audio coding mode */
- FDKwriteBits(&bsWriter, pMetadata->etsiAncData.compression_value, 8); /* compression value */
- }
-
- /* grain-timecode coarse/fine */
- if (pMetadata->etsiAncData.timecode_coarse_status) {
- FDKwriteBits(&bsWriter, 0x0, 16); /* not yet supported */
- }
-
- if (pMetadata->etsiAncData.timecode_fine_status) {
- FDKwriteBits(&bsWriter, 0x0, 16); /* not yet supported */
- }
-
- return FDKgetValidBits(&bsWriter);
-}
-
-
-static FDK_METADATA_ERROR LoadSubmittedMetadata(
- const AACENC_MetaData * const hMetadata,
- const INT nChannels,
- const INT metadataMode,
- AAC_METADATA * const pAacMetaData
- )
-{
- FDK_METADATA_ERROR err = METADATA_OK;
-
- if (pAacMetaData==NULL) {
- err = METADATA_INVALID_HANDLE;
- }
- else {
- /* init struct */
- FDKmemclear(pAacMetaData, sizeof(AAC_METADATA));
-
- if (hMetadata!=NULL) {
- /* convert data */
- pAacMetaData->mpegDrc.drc_profile = hMetadata->drc_profile;
- pAacMetaData->etsiAncData.comp_profile = hMetadata->comp_profile;
- pAacMetaData->mpegDrc.drc_TargetRefLevel = hMetadata->drc_TargetRefLevel;
- pAacMetaData->etsiAncData.comp_TargetRefLevel= hMetadata->comp_TargetRefLevel;
- pAacMetaData->mpegDrc.prog_ref_level_present = hMetadata->prog_ref_level_present;
- pAacMetaData->mpegDrc.prog_ref_level = dialnorm2progreflvl(hMetadata->prog_ref_level);
-
- pAacMetaData->centerMixLevel = hMetadata->centerMixLevel;
- pAacMetaData->surroundMixLevel = hMetadata->surroundMixLevel;
- pAacMetaData->WritePCEMixDwnIdx = hMetadata->PCE_mixdown_idx_present;
- pAacMetaData->DmxLvl_On = hMetadata->ETSI_DmxLvl_present;
-
- pAacMetaData->etsiAncData.compression_on = 1;
-
-
- if (nChannels == 2) {
- pAacMetaData->dolbySurroundMode = hMetadata->dolbySurroundMode; /* dolby_surround_mode */
- } else {
- pAacMetaData->dolbySurroundMode = 0;
- }
-
- pAacMetaData->etsiAncData.timecode_coarse_status = 0; /* not yet supported - attention: Update GetEstMetadataBytesPerFrame() if enable this! */
- pAacMetaData->etsiAncData.timecode_fine_status = 0; /* not yet supported - attention: Update GetEstMetadataBytesPerFrame() if enable this! */
-
- pAacMetaData->metadataMode = metadataMode;
- }
- else {
- pAacMetaData->metadataMode = 0; /* there is no configuration available */
- }
- }
-
- return err;
-}
-
-INT FDK_MetadataEnc_GetDelay(
- HANDLE_FDK_METADATA_ENCODER hMetadataEnc
- )
-{
- INT delay = 0;
-
- if (hMetadataEnc!=NULL) {
- delay = hMetadataEnc->nAudioDataDelay;
- }
-
- return delay;
-}
-
-
diff --git a/libAACenc/src/metadata_main.h b/libAACenc/src/metadata_main.h
deleted file mode 100644
index bfc8ae1..0000000
--- a/libAACenc/src/metadata_main.h
+++ /dev/null
@@ -1,224 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/********************** Fraunhofer IIS FDK AAC Encoder lib ******************
-
- Author(s): V. Bacigalupo
- Description: Metadata Encoder library interface functions
-
-******************************************************************************/
-
-#ifndef _METADATA_MAIN_H
-#define _METADATA_MAIN_H
-
-
-/* Includes ******************************************************************/
-#include "aacenc_lib.h"
-#include "aacenc.h"
-
-
-/* Defines *******************************************************************/
-
-/* Data Types ****************************************************************/
-
-typedef enum {
- METADATA_OK = 0x0000, /*!< No error happened. All fine. */
- METADATA_INVALID_HANDLE = 0x0020, /*!< Handle passed to function call was invalid. */
- METADATA_MEMORY_ERROR = 0x0021, /*!< Memory allocation failed. */
- METADATA_INIT_ERROR = 0x0040, /*!< General initialization error. */
- METADATA_ENCODE_ERROR = 0x0060 /*!< The encoding process was interrupted by an unexpected error. */
-
-} FDK_METADATA_ERROR;
-
-/**
- * Meta Data handle.
- */
-typedef struct FDK_METADATA_ENCODER *HANDLE_FDK_METADATA_ENCODER;
-
-
-/**
- * \brief Open a Meta Data instance.
- *
- * \param phMetadataEnc A pointer to a Meta Data handle to be allocated. Initialized on return.
- *
- * \return
- * - METADATA_OK, on succes.
- * - METADATA_INVALID_HANDLE, METADATA_MEMORY_ERROR, on failure.
- */
-FDK_METADATA_ERROR FDK_MetadataEnc_Open(
- HANDLE_FDK_METADATA_ENCODER *phMetadataEnc
- );
-
-
-/**
- * \brief Initialize a Meta Data instance.
- *
- * \param hMetadataEnc Meta Data handle.
- * \param resetStates Indication for full reset of all states.
- * \param metadataMode Configures metat data output format (0,1,2).
- * \param audioDelay Delay cause by the audio encoder.
- * \param frameLength Number of samples to be processes within one frame.
- * \param sampleRate Sampling rat in Hz of audio input signal.
- * \param nChannels Number of audio input channels.
- * \param channelMode Channel configuration which is used by the encoder.
- * \param channelOrder Channel order of the input data. (WAV, MPEG)
- *
- * \return
- * - METADATA_OK, on succes.
- * - METADATA_INVALID_HANDLE, METADATA_INIT_ERROR, on failure.
- */
-FDK_METADATA_ERROR FDK_MetadataEnc_Init(
- HANDLE_FDK_METADATA_ENCODER hMetadataEnc,
- const INT resetStates,
- const INT metadataMode,
- const INT audioDelay,
- const UINT frameLength,
- const UINT sampleRate,
- const UINT nChannels,
- const CHANNEL_MODE channelMode,
- const CHANNEL_ORDER channelOrder
- );
-
-
-/**
- * \brief Calculate Meta Data processing.
- *
- * This function treats all step necessary for meta data processing.
- * - Receive new meta data and make usable.
- * - Calculate DRC compressor and extract meta data info.
- * - Make meta data available for extern use.
- * - Apply audio data and meta data delay compensation.
- *
- * \param hMetadataEnc Meta Data handle.
- * \param pAudioSamples Pointer to audio input data. Existing function overwrites audio data with delayed audio samples.
- * \param nAudioSamples Number of input audio samples to be prcessed.
- * \param pMetadata Pointer to Metat Data input.
- * \param ppMetaDataExtPayload Pointer to extension payload array. Filled on return.
- * \param nMetaDataExtensions Pointer to variable to describe number of available extension payloads. Filled on return.
- * \param matrix_mixdown_idx Pointer to variable for matrix mixdown coefficient. Filled on return.
- *
- * \return
- * - METADATA_OK, on succes.
- * - METADATA_INVALID_HANDLE, METADATA_ENCODE_ERROR, on failure.
- */
-FDK_METADATA_ERROR FDK_MetadataEnc_Process(
- HANDLE_FDK_METADATA_ENCODER hMetadataEnc,
- INT_PCM * const pAudioSamples,
- const INT nAudioSamples,
- const AACENC_MetaData * const pMetadata,
- AACENC_EXT_PAYLOAD ** ppMetaDataExtPayload,
- UINT * nMetaDataExtensions,
- INT * matrix_mixdown_idx
- );
-
-
-/**
- * \brief Close the Meta Data instance.
- *
- * Deallocate instance and free whole memory.
- *
- * \param phMetaData Pointer to the Meta Data handle to be deallocated.
- *
- * \return
- * - METADATA_OK, on succes.
- * - METADATA_INVALID_HANDLE, on failure.
- */
-FDK_METADATA_ERROR FDK_MetadataEnc_Close(
- HANDLE_FDK_METADATA_ENCODER *phMetaData
- );
-
-
-/**
- * \brief Get Meta Data Encoder delay.
- *
- * \param hMetadataEnc Meta Data Encoder handle.
- *
- * \return Delay caused by Meta Data module.
- */
-INT FDK_MetadataEnc_GetDelay(
- HANDLE_FDK_METADATA_ENCODER hMetadataEnc
- );
-
-
-#endif /* _METADATA_MAIN_H */
-
diff --git a/libAACenc/src/ms_stereo.cpp b/libAACenc/src/ms_stereo.cpp
deleted file mode 100644
index 306d490..0000000
--- a/libAACenc/src/ms_stereo.cpp
+++ /dev/null
@@ -1,251 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M.Werner
- contents/description: MS stereo processing
-
-******************************************************************************/
-#include "ms_stereo.h"
-
-#include "psy_const.h"
-
-/* static const float scaleMinThres = 1.0f; */ /* 0.75f for 3db boost */
-
-void FDKaacEnc_MsStereoProcessing(PSY_DATA *RESTRICT psyData[(2)],
- PSY_OUT_CHANNEL* psyOutChannel[2],
- const INT *isBook,
- INT *msDigest, /* output */
- INT *msMask, /* output */
- const INT sfbCnt,
- const INT sfbPerGroup,
- const INT maxSfbPerGroup,
- const INT *sfbOffset)
-{
- FIXP_DBL *sfbEnergyLeft = psyData[0]->sfbEnergy.Long; /* modified where msMask==1 */
- FIXP_DBL *sfbEnergyRight = psyData[1]->sfbEnergy.Long; /* modified where msMask==1 */
- const FIXP_DBL *sfbEnergyMid = psyData[0]->sfbEnergyMS.Long;
- const FIXP_DBL *sfbEnergySide = psyData[1]->sfbEnergyMS.Long;
- FIXP_DBL *sfbThresholdLeft = psyData[0]->sfbThreshold.Long; /* modified where msMask==1 */
- FIXP_DBL *sfbThresholdRight = psyData[1]->sfbThreshold.Long; /* modified where msMask==1 */
-
- FIXP_DBL *sfbSpreadEnLeft = psyData[0]->sfbSpreadEnergy.Long;
- FIXP_DBL *sfbSpreadEnRight = psyData[1]->sfbSpreadEnergy.Long;
-
- FIXP_DBL *sfbEnergyLeftLdData = psyOutChannel[0]->sfbEnergyLdData; /* modified where msMask==1 */
- FIXP_DBL *sfbEnergyRightLdData = psyOutChannel[1]->sfbEnergyLdData; /* modified where msMask==1 */
- FIXP_DBL *sfbEnergyMidLdData = psyData[0]->sfbEnergyMSLdData;
- FIXP_DBL *sfbEnergySideLdData = psyData[1]->sfbEnergyMSLdData;
- FIXP_DBL *sfbThresholdLeftLdData = psyOutChannel[0]->sfbThresholdLdData; /* modified where msMask==1 */
- FIXP_DBL *sfbThresholdRightLdData = psyOutChannel[1]->sfbThresholdLdData; /* modified where msMask==1 */
-
- FIXP_DBL *mdctSpectrumLeft = psyData[0]->mdctSpectrum; /* modified where msMask==1 */
- FIXP_DBL *mdctSpectrumRight = psyData[1]->mdctSpectrum; /* modified where msMask==1 */
-
- INT sfb,sfboffs, j; /* loop counters */
- FIXP_DBL pnlrLdData, pnmsLdData;
- FIXP_DBL minThresholdLdData;
- FIXP_DBL minThreshold;
- INT useMS;
-
- INT msMaskTrueSomewhere = 0; /* to determine msDigest */
- INT numMsMaskFalse = 0; /* number of non-intensity bands where L/R coding is used */
-
- for(sfb=0; sfb<sfbCnt; sfb+=sfbPerGroup) {
- for(sfboffs=0;sfboffs<maxSfbPerGroup;sfboffs++) {
-
- if ( (isBook==NULL) ? 1 : (isBook[sfb+sfboffs] == 0) ) {
- FIXP_DBL tmp;
-
-/*
- minThreshold=min(sfbThresholdLeft[sfb+sfboffs], sfbThresholdRight[sfb+sfboffs])*scaleMinThres;
- pnlr = (sfbThresholdLeft[sfb+sfboffs]/
- max(sfbEnergyLeft[sfb+sfboffs],sfbThresholdLeft[sfb+sfboffs]))*
- (sfbThresholdRight[sfb+sfboffs]/
- max(sfbEnergyRight[sfb+sfboffs],sfbThresholdRight[sfb+sfboffs]));
- pnms = (minThreshold/max(sfbEnergyMid[sfb+sfboffs],minThreshold))*
- (minThreshold/max(sfbEnergySide[sfb+sfboffs],minThreshold));
- useMS = (pnms > pnlr);
-*/
-
- /* we assume that scaleMinThres == 1.0f and we can drop it */
- minThresholdLdData = fixMin(sfbThresholdLeftLdData[sfb+sfboffs], sfbThresholdRightLdData[sfb+sfboffs]);
-
- /* pnlrLdData = sfbThresholdLeftLdData[sfb+sfboffs] -
- max(sfbEnergyLeftLdData[sfb+sfboffs], sfbThresholdLeftLdData[sfb+sfboffs]) +
- sfbThresholdRightLdData[sfb+sfboffs] -
- max(sfbEnergyRightLdData[sfb+sfboffs], sfbThresholdRightLdData[sfb+sfboffs]); */
- tmp = fixMax(sfbEnergyLeftLdData[sfb+sfboffs], sfbThresholdLeftLdData[sfb+sfboffs]);
- pnlrLdData = (sfbThresholdLeftLdData[sfb+sfboffs]>>1) - (tmp>>1);
- pnlrLdData = pnlrLdData + (sfbThresholdRightLdData[sfb+sfboffs]>>1);
- tmp = fixMax(sfbEnergyRightLdData[sfb+sfboffs], sfbThresholdRightLdData[sfb+sfboffs]);
- pnlrLdData = pnlrLdData - (tmp>>1);
-
- /* pnmsLdData = minThresholdLdData - max(sfbEnergyMidLdData[sfb+sfboffs], minThresholdLdData) +
- minThresholdLdData - max(sfbEnergySideLdData[sfb+sfboffs], minThresholdLdData); */
- tmp = fixMax(sfbEnergyMidLdData[sfb+sfboffs], minThresholdLdData);
- pnmsLdData = minThresholdLdData - (tmp>>1);
- tmp = fixMax(sfbEnergySideLdData[sfb+sfboffs], minThresholdLdData);
- pnmsLdData = pnmsLdData - (tmp>>1);
- useMS = (pnmsLdData > (pnlrLdData));
-
-
- if (useMS) {
- msMask[sfb+sfboffs] = 1;
- msMaskTrueSomewhere = 1;
- for(j=sfbOffset[sfb+sfboffs]; j<sfbOffset[sfb+sfboffs+1]; j++) {
- FIXP_DBL specL, specR;
- specL = mdctSpectrumLeft[j]>>1;
- specR = mdctSpectrumRight[j]>>1;
- mdctSpectrumLeft[j] = specL + specR;
- mdctSpectrumRight[j] = specL - specR;
- }
- minThreshold = fixMin(sfbThresholdLeft[sfb+sfboffs], sfbThresholdRight[sfb+sfboffs]);
- sfbThresholdLeft[sfb+sfboffs] = sfbThresholdRight[sfb+sfboffs] = minThreshold;
- sfbThresholdLeftLdData[sfb+sfboffs] = sfbThresholdRightLdData[sfb+sfboffs] = minThresholdLdData;
- sfbEnergyLeft[sfb+sfboffs] = sfbEnergyMid[sfb+sfboffs];
- sfbEnergyRight[sfb+sfboffs] = sfbEnergySide[sfb+sfboffs];
- sfbEnergyLeftLdData[sfb+sfboffs] = sfbEnergyMidLdData[sfb+sfboffs];
- sfbEnergyRightLdData[sfb+sfboffs] = sfbEnergySideLdData[sfb+sfboffs];
-
- sfbSpreadEnLeft[sfb+sfboffs] = sfbSpreadEnRight[sfb+sfboffs] =
- fixMin( sfbSpreadEnLeft[sfb+sfboffs],
- sfbSpreadEnRight[sfb+sfboffs] ) >> 1;
-
- }
- else {
- msMask[sfb+sfboffs] = 0;
- numMsMaskFalse++;
- } /* useMS */
- } /* isBook */
- else {
- /* keep mDigest from IS module */
- if (msMask[sfb+sfboffs]) {
- msMaskTrueSomewhere = 1;
- }
- /* prohibit MS_MASK_ALL in combination with IS */
- numMsMaskFalse = 9;
- } /* isBook */
- } /* sfboffs */
- } /* sfb */
-
-
- if(msMaskTrueSomewhere == 1) {
- if ((numMsMaskFalse == 0) || ((numMsMaskFalse < maxSfbPerGroup) && (numMsMaskFalse < 9))) {
- *msDigest = SI_MS_MASK_ALL;
- /* loop through M/S bands; if msMask==0, set it to 1 and apply M/S */
- for (sfb = 0; sfb < sfbCnt; sfb += sfbPerGroup) {
- for (sfboffs = 0; sfboffs < maxSfbPerGroup; sfboffs++) {
- if (( (isBook == NULL) ? 1 : (isBook[sfb+sfboffs] == 0) ) && (msMask[sfb+sfboffs] == 0)) {
- msMask[sfb+sfboffs] = 1;
- /* apply M/S coding */
- for(j=sfbOffset[sfb+sfboffs]; j<sfbOffset[sfb+sfboffs+1]; j++) {
- FIXP_DBL specL, specR;
- specL = mdctSpectrumLeft[j]>>1;
- specR = mdctSpectrumRight[j]>>1;
- mdctSpectrumLeft[j] = specL + specR;
- mdctSpectrumRight[j] = specL - specR;
- }
- minThreshold = fixMin(sfbThresholdLeft[sfb+sfboffs], sfbThresholdRight[sfb+sfboffs]);
- sfbThresholdLeft[sfb+sfboffs] = sfbThresholdRight[sfb+sfboffs] = minThreshold;
- minThresholdLdData = fixMin(sfbThresholdLeftLdData[sfb+sfboffs], sfbThresholdRightLdData[sfb+sfboffs]);
- sfbThresholdLeftLdData[sfb+sfboffs] = sfbThresholdRightLdData[sfb+sfboffs] = minThresholdLdData;
- sfbEnergyLeft[sfb+sfboffs] = sfbEnergyMid[sfb+sfboffs];
- sfbEnergyRight[sfb+sfboffs] = sfbEnergySide[sfb+sfboffs];
- sfbEnergyLeftLdData[sfb+sfboffs] = sfbEnergyMidLdData[sfb+sfboffs];
- sfbEnergyRightLdData[sfb+sfboffs] = sfbEnergySideLdData[sfb+sfboffs];
-
- sfbSpreadEnLeft[sfb+sfboffs] = sfbSpreadEnRight[sfb+sfboffs] =
- fixMin( sfbSpreadEnLeft[sfb+sfboffs],
- sfbSpreadEnRight[sfb+sfboffs] ) >> 1;
- }
- }
- }
- } else {
- *msDigest = SI_MS_MASK_SOME;
- }
- } else {
- *msDigest = SI_MS_MASK_NONE;
- }
-}
diff --git a/libAACenc/src/ms_stereo.h b/libAACenc/src/ms_stereo.h
deleted file mode 100644
index 2f3addb..0000000
--- a/libAACenc/src/ms_stereo.h
+++ /dev/null
@@ -1,107 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M.Werner
- contents/description: MS stereo processing
-
-******************************************************************************/
-
-#ifndef __MS_STEREO_H__
-#define __MS_STEREO_H__
-
-
-#include "interface.h"
-
-void FDKaacEnc_MsStereoProcessing(PSY_DATA *RESTRICT psyData[(2)],
- PSY_OUT_CHANNEL* psyOutChannel[2],
- const INT *isBook,
- INT *msDigest, /* output */
- INT *msMask, /* output */
- const INT sfbCnt,
- const INT sfbPerGroup,
- const INT maxSfbPerGroup,
- const INT *sfbOffset);
-
-#endif
diff --git a/libAACenc/src/noisedet.cpp b/libAACenc/src/noisedet.cpp
deleted file mode 100644
index f3c51de..0000000
--- a/libAACenc/src/noisedet.cpp
+++ /dev/null
@@ -1,228 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M. Lohwasser
- contents/description: noisedet.c
- Routines for Noise Detection
-
-******************************************************************************/
-
-#include "noisedet.h"
-
-#include "aacenc_pns.h"
-#include "pnsparam.h"
-
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_fuzzyIsSmaller
- description: Fuzzy value calculation for "testVal is smaller than refVal"
- returns: fuzzy value
- input: test and ref Value,
- low and high Lim
- output: return fuzzy value
-
-*****************************************************************************/
-static FIXP_SGL FDKaacEnc_fuzzyIsSmaller( FIXP_DBL testVal,
- FIXP_DBL refVal,
- FIXP_DBL loLim,
- FIXP_DBL hiLim )
-{
- if (refVal <= FL2FXCONST_DBL(0.0))
- return( FL2FXCONST_SGL(0.0f) );
- else if (testVal >= fMult((hiLim>>1)+(loLim>>1), refVal))
- return( FL2FXCONST_SGL(0.0f) );
- else return( (FIXP_SGL)MAXVAL_SGL );
-}
-
-
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_noiseDetect
- description: detect tonal sfb's; two tests
- Powerdistribution:
- sfb splittet in four regions,
- compare the energy in all sections
- PsychTonality:
- compare tonality from chaosmeasure with reftonality
- returns:
- input: spectrum of one large mdct
- number of sfb's
- pointer to offset of sfb's
- pointer to noiseFuzzyMeasure (modified)
- noiseparams struct
- pointer to sfb energies
- pointer to tonality calculated in chaosmeasure
- output: noiseFuzzy Measure
-
-*****************************************************************************/
-
-void FDKaacEnc_noiseDetect(FIXP_DBL *RESTRICT mdctSpectrum,
- INT *RESTRICT sfbMaxScaleSpec,
- INT sfbActive,
- const INT *RESTRICT sfbOffset,
- FIXP_SGL *RESTRICT noiseFuzzyMeasure,
- NOISEPARAMS *np,
- FIXP_SGL *RESTRICT sfbtonality )
-
-{
- int i, k, sfb, sfbWidth;
- FIXP_SGL fuzzy, fuzzyTotal;
- FIXP_DBL refVal, testVal;
-
- /***** Start detection phase *****/
- /* Start noise detection for each band based on a number of checks */
- for (sfb=0; sfb<sfbActive; sfb++) {
-
- fuzzyTotal = (FIXP_SGL)MAXVAL_SGL;
- sfbWidth = sfbOffset[sfb+1] - sfbOffset[sfb];
-
- /* Reset output for lower bands or too small bands */
- if (sfb < np->startSfb || sfbWidth < np->minSfbWidth) {
- noiseFuzzyMeasure[sfb] = FL2FXCONST_SGL(0.0f);
- continue;
- }
-
- if ( (np->detectionAlgorithmFlags & USE_POWER_DISTRIBUTION) && (fuzzyTotal > FL2FXCONST_SGL(0.5f)) ) {
- FIXP_DBL fhelp1, fhelp2, fhelp3, fhelp4, maxVal, minVal;
- INT leadingBits = fixMax(0,(sfbMaxScaleSpec[sfb] - 3)); /* max sfbWidth = 96/4 ; 2^5=32 => 5/2 = 3 (spc*spc) */
-
- /* check power distribution in four regions */
- fhelp1 = fhelp2 = fhelp3 = fhelp4 = FL2FXCONST_DBL(0.0f);
- k = sfbWidth >>2; /* Width of a quarter band */
-
- for (i=sfbOffset[sfb]; i<sfbOffset[sfb]+k; i++) {
- fhelp1 = fPow2AddDiv2(fhelp1, mdctSpectrum[i]<<leadingBits);
- fhelp2 = fPow2AddDiv2(fhelp2, mdctSpectrum[i+k]<<leadingBits);
- fhelp3 = fPow2AddDiv2(fhelp3, mdctSpectrum[i+2*k]<<leadingBits);
- fhelp4 = fPow2AddDiv2(fhelp4, mdctSpectrum[i+3*k]<<leadingBits);
- }
-
- /* get max into fhelp: */
- maxVal = fixMax(fhelp1, fhelp2);
- maxVal = fixMax(maxVal, fhelp3);
- maxVal = fixMax(maxVal, fhelp4);
-
- /* get min into fhelp1: */
- minVal = fixMin(fhelp1, fhelp2);
- minVal = fixMin(minVal, fhelp3);
- minVal = fixMin(minVal, fhelp4);
-
- /* Normalize min and max Val */
- leadingBits = CountLeadingBits(maxVal);
- testVal = maxVal << leadingBits;
- refVal = minVal << leadingBits;
-
- /* calculate fuzzy value for power distribution */
- testVal = fMultDiv2(testVal, np->powDistPSDcurve[sfb]);
-
- fuzzy = FDKaacEnc_fuzzyIsSmaller(testVal, /* 1/2 * maxValue * PSDcurve */
- refVal, /* 1 * minValue */
- FL2FXCONST_DBL(0.495), /* 1/2 * loLim (0.99f/2) */
- FL2FXCONST_DBL(0.505)); /* 1/2 * hiLim (1.01f/2) */
-
- fuzzyTotal = fixMin(fuzzyTotal, fuzzy);
- }
-
- if ( (np->detectionAlgorithmFlags & USE_PSYCH_TONALITY) && (fuzzyTotal > FL2FXCONST_SGL(0.5f)) ) {
- /* Detection with tonality-value of psych. acoustic (here: 1 is tonal!)*/
-
- testVal = FX_SGL2FX_DBL(sfbtonality[sfb])>>1; /* 1/2 * sfbTonality */
- refVal = np->refTonality;
-
- fuzzy = FDKaacEnc_fuzzyIsSmaller(testVal,
- refVal,
- FL2FXCONST_DBL(0.45f), /* 1/2 * loLim (0.9f/2) */
- FL2FXCONST_DBL(0.55f)); /* 1/2 * hiLim (1.1f/2) */
-
- fuzzyTotal = fixMin(fuzzyTotal, fuzzy);
- }
-
-
- /* Output of final result */
- noiseFuzzyMeasure[sfb] = fuzzyTotal;
- }
-}
diff --git a/libAACenc/src/noisedet.h b/libAACenc/src/noisedet.h
deleted file mode 100644
index 8d5e365..0000000
--- a/libAACenc/src/noisedet.h
+++ /dev/null
@@ -1,108 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M. Lohwasser
- contents/description: noisedet.h
-
-******************************************************************************/
-
-#ifndef __NOISEDET_H
-#define __NOISEDET_H
-
-#include "common_fix.h"
-
-#include "pnsparam.h"
-#include "psy_data.h"
-
-
-void FDKaacEnc_noiseDetect( FIXP_DBL *mdctSpectrum,
- INT *sfbMaxScaleSpec,
- INT sfbActive,
- const INT *sfbOffset,
- FIXP_SGL noiseFuzzyMeasure[],
- NOISEPARAMS *np,
- FIXP_SGL *sfbtonality );
-
-#endif
diff --git a/libAACenc/src/pns_func.h b/libAACenc/src/pns_func.h
deleted file mode 100644
index efa44ef..0000000
--- a/libAACenc/src/pns_func.h
+++ /dev/null
@@ -1,150 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M. Lohwasser
- contents/description: pns_func.h
-
-******************************************************************************/
-
-#ifndef _PNS_FUNC_H
-#define _PNS_FUNC_H
-
-#include "common_fix.h"
-
-#include "aacenc_pns.h"
-#include "psy_data.h"
-
-
-
-AAC_ENCODER_ERROR FDKaacEnc_InitPnsConfiguration(PNS_CONFIG *pnsConf,
- INT bitRate,
- INT sampleRate,
- INT usePns,
- INT sfbCnt,
- const INT *sfbOffset,
- const INT numChan,
- const INT isLC );
-
-void FDKaacEnc_PnsDetect( PNS_CONFIG *pnsConf,
- PNS_DATA *pnsData,
- const INT lastWindowSequence,
- const INT sfbActive,
- const INT maxSfbPerGroup,
- FIXP_DBL *sfbThresholdLdData,
- const INT *sfbOffset,
- FIXP_DBL *mdctSpectrum,
- INT *sfbMaxScaleSpec,
- FIXP_SGL *sfbtonality,
- int tnsOrder,
- INT tnsPredictionGain,
- INT tnsActive,
- FIXP_DBL *sfbEnergyLdData,
- INT *noiseNrg );
-
-void FDKaacEnc_CodePnsChannel( const INT sfbActive,
- PNS_CONFIG *pnsConf,
- INT *pnsFlag,
- FIXP_DBL *sfbEnergy,
- INT *noiseNrg,
- FIXP_DBL *sfbThreshold );
-
-void FDKaacEnc_PreProcessPnsChannelPair( const INT sfbActive,
- FIXP_DBL *sfbEnergyLeft,
- FIXP_DBL *sfbEnergyRight,
- FIXP_DBL *sfbEnergyLeftLD,
- FIXP_DBL *sfbEnergyRightLD,
- FIXP_DBL *sfbEnergyMid,
- PNS_CONFIG *pnsConfLeft,
- PNS_DATA *pnsDataLeft,
- PNS_DATA *pnsDataRight );
-
-void FDKaacEnc_PostProcessPnsChannelPair( const INT sfbActive,
- PNS_CONFIG *pnsConf,
- PNS_DATA *pnsDataLeft,
- PNS_DATA *pnsDataRight,
- INT *msMask,
- INT *msDigest );
-
-#endif /* _PNS_FUNC_H */
diff --git a/libAACenc/src/pnsparam.cpp b/libAACenc/src/pnsparam.cpp
deleted file mode 100644
index afc5bdd..0000000
--- a/libAACenc/src/pnsparam.cpp
+++ /dev/null
@@ -1,308 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M.Lohwasser
- contents/description: PNS parameters depending on bitrate and bandwidth
-
-******************************************************************************/
-
-#include "pnsparam.h"
-#include "psy_configuration.h"
-
-typedef struct {
- SHORT startFreq;
- /* Parameters for detection */
- FIXP_SGL refPower;
- FIXP_SGL refTonality;
- SHORT tnsGainThreshold; /* scaled by TNS_PREDGAIN_SCALE (=1000) */
- SHORT tnsPNSGainThreshold; /* scaled by TNS_PREDGAIN_SCALE (=1000) */
- FIXP_SGL gapFillThr;
- SHORT minSfbWidth;
- USHORT detectionAlgorithmFlags;
-} PNS_INFO_TAB;
-
-
-typedef struct {
- ULONG brFrom;
- ULONG brTo;
- UCHAR S22050;
- UCHAR S24000;
- UCHAR S32000;
- UCHAR S44100;
- UCHAR S48000;
-} AUTO_PNS_TAB;
-
-static const AUTO_PNS_TAB levelTable_mono[]= {
- {0, 11999, 1, 1, 1, 1, 1,},
- {12000, 19999, 1, 1, 1, 1, 1,},
- {20000, 28999, 2, 1, 1, 1, 1,},
- {29000, 40999, 4, 4, 4, 2, 2,},
- {41000, 55999, 9, 9, 7, 7, 7,},
- {56000, 79999, 0, 0, 0, 9, 9,},
- {80000, 99999, 0, 0, 0, 0, 0,},
- {100000,999999, 0, 0, 0, 0, 0,},
-};
-
-static const AUTO_PNS_TAB levelTable_stereo[]= {
- {0, 11999, 1, 1, 1, 1, 1,},
- {12000, 19999, 3, 1, 1, 1, 1,},
- {20000, 28999, 3, 3, 3, 2, 2,},
- {29000, 40999, 7, 6, 6, 5, 5,},
- {41000, 55999, 9, 9, 7, 7, 7,},
- {56000, 79999, 0, 0, 0, 0, 0,},
- {80000, 99999, 0, 0, 0, 0, 0,},
- {100000,999999, 0, 0, 0, 0, 0,},
-};
-
-
-static const PNS_INFO_TAB pnsInfoTab[] = {
-/*0 pns off */
-/*1*/ { 4000, FL2FXCONST_SGL(0.04), FL2FXCONST_SGL(0.06), 1150, 1200, FL2FXCONST_SGL(0.02), 8,
- USE_POWER_DISTRIBUTION | USE_PSYCH_TONALITY | USE_TNS_GAIN_THR | USE_TNS_PNS /*| JUST_LONG_WINDOW*/ },
-/*2*/ { 4000, FL2FXCONST_SGL(0.04), FL2FXCONST_SGL(0.07), 1130, 1300, FL2FXCONST_SGL(0.05), 8,
- USE_POWER_DISTRIBUTION | USE_PSYCH_TONALITY | USE_TNS_GAIN_THR | USE_TNS_PNS /*| JUST_LONG_WINDOW*/ },
-/*3*/ { 4100, FL2FXCONST_SGL(0.04), FL2FXCONST_SGL(0.07), 1100, 1400, FL2FXCONST_SGL(0.10), 8,
- USE_POWER_DISTRIBUTION | USE_PSYCH_TONALITY | USE_TNS_GAIN_THR | USE_TNS_PNS /*| JUST_LONG_WINDOW*/ },
-/*4*/ { 4100, FL2FXCONST_SGL(0.03), FL2FXCONST_SGL(0.10), 1100, 1400, FL2FXCONST_SGL(0.15), 8,
- USE_POWER_DISTRIBUTION | USE_PSYCH_TONALITY | USE_TNS_GAIN_THR | USE_TNS_PNS /*| JUST_LONG_WINDOW*/ },
-/*5*/ { 4300, FL2FXCONST_SGL(0.03), FL2FXCONST_SGL(0.10), 1100, 1400, FL2FXCONST_SGL(0.15), 8,
- USE_POWER_DISTRIBUTION | USE_PSYCH_TONALITY | USE_TNS_GAIN_THR | USE_TNS_PNS | JUST_LONG_WINDOW },
-/*6*/ { 5000, FL2FXCONST_SGL(0.03), FL2FXCONST_SGL(0.10), 1100, 1400, FL2FXCONST_SGL(0.25), 8,
- USE_POWER_DISTRIBUTION | USE_PSYCH_TONALITY | USE_TNS_GAIN_THR | USE_TNS_PNS | JUST_LONG_WINDOW },
-/*7*/ { 5500, FL2FXCONST_SGL(0.03), FL2FXCONST_SGL(0.12), 1100, 1400, FL2FXCONST_SGL(0.35), 8,
- USE_POWER_DISTRIBUTION | USE_PSYCH_TONALITY | USE_TNS_GAIN_THR | USE_TNS_PNS | JUST_LONG_WINDOW },
-/*8*/ { 6000, FL2FXCONST_SGL(0.03), FL2FXCONST_SGL(0.12), 1080, 1400, FL2FXCONST_SGL(0.40), 8,
- USE_POWER_DISTRIBUTION | USE_PSYCH_TONALITY | USE_TNS_GAIN_THR | USE_TNS_PNS | JUST_LONG_WINDOW },
-/*9*/ { 6000, FL2FXCONST_SGL(0.03), FL2FXCONST_SGL(0.14), 1070, 1400, FL2FXCONST_SGL(0.45), 8,
- USE_POWER_DISTRIBUTION | USE_PSYCH_TONALITY | USE_TNS_GAIN_THR | USE_TNS_PNS | JUST_LONG_WINDOW },
-};
-
-static const AUTO_PNS_TAB levelTable_lowComplexity[]= {
- {0, 27999, 0, 0, 0, 0, 0,},
- {28000, 31999, 2, 2, 2, 2, 2,},
- {32000, 47999, 3, 3, 3, 3, 3,},
- {48000, 48000, 4, 4, 4, 4, 4,},
- {48001, 999999, 0, 0, 0, 0, 0,},
-};
-
-/* conversion of old LC tuning tables to new (LD enc) structure (only entries which are actually used were converted) */
-static const PNS_INFO_TAB pnsInfoTab_lowComplexity[] = {
-/*0 pns off */
- /* DEFAULT parameter set */
-/*1*/ { 4100, FL2FXCONST_SGL(0.03), FL2FXCONST_SGL(0.16), 1100, 1400, FL2FXCONST_SGL(0.5), 16,
- USE_POWER_DISTRIBUTION | USE_PSYCH_TONALITY | USE_TNS_GAIN_THR | USE_TNS_PNS | JUST_LONG_WINDOW },
-/*2*/ { 4100, FL2FXCONST_SGL(0.05), FL2FXCONST_SGL(0.10), 1410, 1400, FL2FXCONST_SGL(0.5), 16,
- USE_POWER_DISTRIBUTION | USE_PSYCH_TONALITY | USE_TNS_GAIN_THR | USE_TNS_PNS | JUST_LONG_WINDOW },
-/*3*/ { 4100, FL2FXCONST_SGL(0.05), FL2FXCONST_SGL(0.10), 1100, 1400, FL2FXCONST_SGL(0.5), 16,
- USE_POWER_DISTRIBUTION | USE_PSYCH_TONALITY | USE_TNS_GAIN_THR | USE_TNS_PNS | JUST_LONG_WINDOW },
- /* LOWSUBST -> PNS is used less often than with DEFAULT parameter set (for br: 48000 - 79999) */
-/*4*/ { 4100, FL2FXCONST_SGL(0.20), FL2FXCONST_SGL(0.10), 1410, 1400, FL2FXCONST_SGL(0.5), 16,
- USE_POWER_DISTRIBUTION | USE_PSYCH_TONALITY | USE_TNS_GAIN_THR | USE_TNS_PNS | JUST_LONG_WINDOW },
-};
-
-/****************************************************************************
- function to look up used pns level
-****************************************************************************/
-int FDKaacEnc_lookUpPnsUse (int bitRate, int sampleRate, int numChan, const int isLC) {
-
- int hUsePns=0, size, i;
- const AUTO_PNS_TAB *levelTable;
-
- if (isLC) {
- levelTable = &levelTable_lowComplexity[0];
- size = sizeof(levelTable_lowComplexity);
- } else
- { /* (E)LD */
- levelTable = (numChan > 1) ? &levelTable_stereo[0] : &levelTable_mono[0];
- size = (numChan > 1) ? sizeof(levelTable_stereo) : sizeof(levelTable_mono);
- }
-
- for(i = 0; i < (int) (size/sizeof(AUTO_PNS_TAB)); i++) {
- if(((ULONG)bitRate >= levelTable[i].brFrom) &&
- ((ULONG)bitRate <= levelTable[i].brTo) )
- break;
- }
-
- /* sanity check */
- if ((int)(sizeof(pnsInfoTab)/sizeof(PNS_INFO_TAB)) < i ) {
- return (PNS_TABLE_ERROR);
- }
-
- switch (sampleRate) {
- case 22050: hUsePns = levelTable[i].S22050; break;
- case 24000: hUsePns = levelTable[i].S24000; break;
- case 32000: hUsePns = levelTable[i].S32000; break;
- case 44100: hUsePns = levelTable[i].S44100; break;
- case 48000: hUsePns = levelTable[i].S48000; break;
- default:
- if (isLC) {
- hUsePns = levelTable[i].S48000;
- }
- break;
- }
-
- return (hUsePns);
-}
-
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_GetPnsParam
- description: Gets PNS parameters depending on bitrate and bandwidth
- returns: error status
- input: Noiseparams struct, bitrate, sampling rate,
- number of sfb's, pointer to sfb offset
- output: PNS parameters
-
-*****************************************************************************/
-AAC_ENCODER_ERROR FDKaacEnc_GetPnsParam(NOISEPARAMS *np,
- INT bitRate,
- INT sampleRate,
- INT sfbCnt,
- const INT *sfbOffset,
- INT *usePns,
- INT numChan,
- const int isLC)
-
-{
- int i, hUsePns;
- const PNS_INFO_TAB *pnsInfo;
-
- if (isLC) {
- np->detectionAlgorithmFlags = IS_LOW_COMLEXITY;
- pnsInfo = pnsInfoTab_lowComplexity;
- }
- else
- {
- np->detectionAlgorithmFlags = 0;
- pnsInfo = pnsInfoTab;
- }
-
- if (*usePns<=0)
- return AAC_ENC_OK;
-
- /* new pns params */
- hUsePns = FDKaacEnc_lookUpPnsUse (bitRate, sampleRate, numChan, isLC);
- if (hUsePns == 0) {
- *usePns = 0;
- return AAC_ENC_OK;
- }
- if (hUsePns == PNS_TABLE_ERROR)
- return AAC_ENC_PNS_TABLE_ERROR;
-
- /* select correct row of tuning table */
- pnsInfo += hUsePns-1;
-
- np->startSfb = FDKaacEnc_FreqToBandWithRounding( pnsInfo->startFreq,
- sampleRate,
- sfbCnt,
- sfbOffset );
-
- np->detectionAlgorithmFlags |= pnsInfo->detectionAlgorithmFlags;
-
- np->refPower = FX_SGL2FX_DBL(pnsInfo->refPower);
- np->refTonality = FX_SGL2FX_DBL(pnsInfo->refTonality);
- np->tnsGainThreshold = pnsInfo->tnsGainThreshold;
- np->tnsPNSGainThreshold = pnsInfo->tnsPNSGainThreshold;
- np->minSfbWidth = pnsInfo->minSfbWidth;
-
- np->gapFillThr = (FIXP_SGL)pnsInfo->gapFillThr;
-
- /* assuming a constant dB/Hz slope in the signal's PSD curve,
- the detection threshold needs to be corrected for the width of the band */
- for ( i = 0; i < (sfbCnt-1); i++)
- {
- INT qtmp, sfbWidth;
- FIXP_DBL tmp;
-
- sfbWidth = sfbOffset[i+1]-sfbOffset[i];
-
- tmp = fPow(np->refPower, 0, sfbWidth, DFRACT_BITS-1-5, &qtmp);
- np->powDistPSDcurve[i] = (FIXP_SGL)((LONG)(scaleValue(tmp, qtmp) >> 16));
- }
- np->powDistPSDcurve[sfbCnt] = np->powDistPSDcurve[sfbCnt-1];
-
- return AAC_ENC_OK;
-}
diff --git a/libAACenc/src/pnsparam.h b/libAACenc/src/pnsparam.h
deleted file mode 100644
index 08bb83e..0000000
--- a/libAACenc/src/pnsparam.h
+++ /dev/null
@@ -1,141 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M. Lohwasser
- contents/description: PNS parameters depending on bitrate and bandwidth
-
-******************************************************************************/
-
-#ifndef __PNSPARAM_H
-#define __PNSPARAM_H
-
-#include "aacenc.h"
-#include "common_fix.h"
-#include "psy_const.h"
-
-#define NUM_PNSINFOTAB 4
-#define PNS_TABLE_ERROR -1
-
-/* detection algorithm flags */
-#define USE_POWER_DISTRIBUTION (1<<0)
-#define USE_PSYCH_TONALITY (1<<1)
-#define USE_TNS_GAIN_THR (1<<2)
-#define USE_TNS_PNS (1<<3)
-#define JUST_LONG_WINDOW (1<<4)
-/* additional algorithm flags */
-#define IS_LOW_COMLEXITY (1<<5)
-
-typedef struct
-{
- /* PNS start band */
- short startSfb;
-
- /* detection algorithm flags */
- USHORT detectionAlgorithmFlags;
-
- /* Parameters for detection */
- FIXP_DBL refPower;
- FIXP_DBL refTonality;
- INT tnsGainThreshold;
- INT tnsPNSGainThreshold;
- INT minSfbWidth;
- FIXP_SGL powDistPSDcurve[MAX_GROUPED_SFB];
- FIXP_SGL gapFillThr;
-} NOISEPARAMS;
-
-int FDKaacEnc_lookUpPnsUse (int bitRate, int sampleRate, int numChan, const int isLC);
-
-/****** Definition of prototypes ******/
-
-AAC_ENCODER_ERROR FDKaacEnc_GetPnsParam(NOISEPARAMS *np,
- INT bitRate,
- INT sampleRate,
- INT sfbCnt,
- const INT *sfbOffset,
- INT *usePns,
- INT numChan,
- const INT isLC);
-
-#endif
diff --git a/libAACenc/src/pre_echo_control.cpp b/libAACenc/src/pre_echo_control.cpp
deleted file mode 100644
index 3dfd8ed..0000000
--- a/libAACenc/src/pre_echo_control.cpp
+++ /dev/null
@@ -1,170 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M.Werner
- contents/description: Pre echo control
-
-******************************************************************************/
-
-#include "pre_echo_control.h"
-#include "psy_configuration.h"
-
-void FDKaacEnc_InitPreEchoControl(FIXP_DBL *RESTRICT pbThresholdNm1,
- INT *calcPreEcho,
- INT numPb,
- FIXP_DBL *RESTRICT sfbPcmQuantThreshold,
- INT *mdctScalenm1)
-{
- *mdctScalenm1 = PCM_QUANT_THR_SCALE>>1;
-
- FDKmemcpy(pbThresholdNm1, sfbPcmQuantThreshold, numPb*sizeof(FIXP_DBL));
-
- *calcPreEcho = 1;
-}
-
-
-void FDKaacEnc_PreEchoControl(FIXP_DBL *RESTRICT pbThresholdNm1,
- INT calcPreEcho,
- INT numPb,
- INT maxAllowedIncreaseFactor,
- FIXP_SGL minRemainingThresholdFactor,
- FIXP_DBL *RESTRICT pbThreshold,
- INT mdctScale,
- INT *mdctScalenm1)
-{
- int i;
- FIXP_DBL tmpThreshold1, tmpThreshold2;
- int scaling;
-
- /* If lastWindowSequence in previous frame was start- or stop-window,
- skip preechocontrol calculation */
- if (calcPreEcho==0) {
- /* copy thresholds to internal memory */
- FDKmemcpy(pbThresholdNm1, pbThreshold, numPb*sizeof(FIXP_DBL));
- *mdctScalenm1 = mdctScale;
- return;
- }
-
- if ( mdctScale > *mdctScalenm1 ) {
- /* if current thresholds are downscaled more than the ones from the last block */
- scaling = 2*(mdctScale-*mdctScalenm1);
- for(i = 0; i < numPb; i++) {
-
- /* multiplication with return data type fract ist equivalent to int multiplication */
- FDK_ASSERT(scaling>=0);
- tmpThreshold1 = maxAllowedIncreaseFactor * (pbThresholdNm1[i]>>scaling);
- tmpThreshold2 = fMult(minRemainingThresholdFactor, pbThreshold[i]);
-
- FIXP_DBL tmp = pbThreshold[i];
-
- /* copy thresholds to internal memory */
- pbThresholdNm1[i] = tmp;
-
- tmp = fixMin(tmp, tmpThreshold1);
- pbThreshold[i] = fixMax(tmp, tmpThreshold2);
- }
- }
- else {
- /* if thresholds of last block are more downscaled than the current ones */
- scaling = 2*(*mdctScalenm1-mdctScale);
- for(i = 0; i < numPb; i++) {
-
- /* multiplication with return data type fract ist equivalent to int multiplication */
- tmpThreshold1 = (maxAllowedIncreaseFactor>>1) * pbThresholdNm1[i];
- tmpThreshold2 = fMult(minRemainingThresholdFactor, pbThreshold[i]);
-
- /* copy thresholds to internal memory */
- pbThresholdNm1[i] = pbThreshold[i];
-
- FDK_ASSERT(scaling>=0);
- if((pbThreshold[i]>>(scaling+1)) > tmpThreshold1) {
- pbThreshold[i] = tmpThreshold1<<(scaling+1);
- }
- pbThreshold[i] = fixMax(pbThreshold[i], tmpThreshold2);
- }
- }
-
- *mdctScalenm1 = mdctScale;
-}
diff --git a/libAACenc/src/pre_echo_control.h b/libAACenc/src/pre_echo_control.h
deleted file mode 100644
index 9224db0..0000000
--- a/libAACenc/src/pre_echo_control.h
+++ /dev/null
@@ -1,114 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M.Werner
- contents/description: Pre echo control
-
-******************************************************************************/
-
-#ifndef __PRE_ECHO_CONTROL_H
-#define __PRE_ECHO_CONTROL_H
-
-#include "common_fix.h"
-
-
-void FDKaacEnc_InitPreEchoControl(FIXP_DBL *pbThresholdnm1,
- INT *calcPreEcho,
- INT numPb,
- FIXP_DBL *sfbPcmQuantThreshold,
- INT *mdctScalenm1);
-
-
-void FDKaacEnc_PreEchoControl(FIXP_DBL *pbThresholdNm1,
- INT calcPreEcho,
- INT numPb,
- INT maxAllowedIncreaseFactor,
- FIXP_SGL minRemainingThresholdFactor,
- FIXP_DBL *pbThreshold,
- INT mdctScale,
- INT *mdctScalenm1);
-
-#endif
-
diff --git a/libAACenc/src/psy_configuration.cpp b/libAACenc/src/psy_configuration.cpp
deleted file mode 100644
index 3533231..0000000
--- a/libAACenc/src/psy_configuration.cpp
+++ /dev/null
@@ -1,828 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M.Werner
- contents/description: Psychoaccoustic configuration
-
-******************************************************************************/
-
-#include "psy_configuration.h"
-#include "adj_thr.h"
-#include "aacEnc_rom.h"
-
-#include "genericStds.h"
-
-#include "FDK_trigFcts.h"
-
-typedef struct{
- LONG sampleRate;
- const SFB_PARAM_LONG *paramLong;
- const SFB_PARAM_SHORT *paramShort;
-}SFB_INFO_TAB;
-
-
-static const SFB_INFO_TAB sfbInfoTab[] = {
- {8000, &p_FDKaacEnc_8000_long_1024, &p_FDKaacEnc_8000_short_128},
- {11025, &p_FDKaacEnc_11025_long_1024, &p_FDKaacEnc_11025_short_128},
- {12000, &p_FDKaacEnc_12000_long_1024, &p_FDKaacEnc_12000_short_128},
- {16000, &p_FDKaacEnc_16000_long_1024, &p_FDKaacEnc_16000_short_128},
- {22050, &p_FDKaacEnc_22050_long_1024, &p_FDKaacEnc_22050_short_128},
- {24000, &p_FDKaacEnc_24000_long_1024, &p_FDKaacEnc_24000_short_128},
- {32000, &p_FDKaacEnc_32000_long_1024, &p_FDKaacEnc_32000_short_128},
- {44100, &p_FDKaacEnc_44100_long_1024, &p_FDKaacEnc_44100_short_128},
- {48000, &p_FDKaacEnc_48000_long_1024, &p_FDKaacEnc_48000_short_128},
- {64000, &p_FDKaacEnc_64000_long_1024, &p_FDKaacEnc_64000_short_128},
- {88200, &p_FDKaacEnc_88200_long_1024, &p_FDKaacEnc_88200_short_128},
- {96000, &p_FDKaacEnc_96000_long_1024, &p_FDKaacEnc_96000_short_128}
-
-};
-
-
-
-const SFB_PARAM_LONG p_FDKaacEnc_8000_long_960 = {
- 40,
- { 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 16,
- 16, 16, 16, 16, 16, 16, 20, 20, 20, 20, 24, 24, 24, 28,
- 28, 32, 36, 36, 40, 44, 48, 52, 56, 60, 64, 16 }
-};
-const SFB_PARAM_SHORT p_FDKaacEnc_8000_short_120 = {
- 15,
- { 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 12, 16, 20, 12 }
-};
-
-const SFB_PARAM_LONG p_FDKaacEnc_11025_long_960 = {
- 42,
- { 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 12, 12, 12,
- 12, 12, 12, 12, 12, 12, 16, 16, 16, 16, 20, 20, 20, 24,
- 24, 28, 28, 32, 36, 40, 40, 44, 48, 52, 56, 60, 64, 64 }
-};
-const SFB_PARAM_SHORT p_FDKaacEnc_11025_short_120 = {
- 15,
- { 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 12, 12, 16, 20, 12 }
-};
-
-const SFB_PARAM_LONG p_FDKaacEnc_12000_long_960 = {
- 42,
- { 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 12, 12, 12,
- 12, 12, 12, 12, 12, 12, 16, 16, 16, 16, 20, 20, 20, 24,
- 24, 28, 28, 32, 36, 40, 40, 44, 48, 52, 56, 60, 64, 64 }
-};
-const SFB_PARAM_SHORT p_FDKaacEnc_12000_short_120 = {
- 15,
- { 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 12, 12, 16, 20, 12 }
-};
-
-const SFB_PARAM_LONG p_FDKaacEnc_16000_long_960 = {
- 42,
- { 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 12, 12, 12,
- 12, 12, 12, 12, 12, 12, 16, 16, 16, 16, 20, 20, 20, 24,
- 24, 28, 28, 32, 36, 40, 40, 44, 48, 52, 56, 60, 64, 64 }
-};
-const SFB_PARAM_SHORT p_FDKaacEnc_16000_short_120 = {
- 15,
- { 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 12, 12, 16, 20, 12 }
-};
-
-const SFB_PARAM_LONG p_FDKaacEnc_22050_long_960 = {
- 46,
- { 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8,
- 8, 8, 8, 8, 8, 8, 8, 12, 12, 12, 12, 16, 16, 16,
- 20, 20, 24, 24, 28, 28, 32, 36, 36, 40, 44, 48, 52, 52,
- 64, 64, 64, 64 }
-};
-const SFB_PARAM_SHORT p_FDKaacEnc_22050_short_120 = {
- 15,
- { 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 12, 12, 16, 16, 12 }
-};
-
-const SFB_PARAM_LONG p_FDKaacEnc_24000_long_960 = {
- 46,
- { 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8,
- 8, 8, 8, 8, 8, 8, 8, 12, 12, 12, 12, 16, 16, 16,
- 20, 20, 24, 24, 28, 28, 32, 36, 36, 40, 44, 48, 52, 52,
- 64, 64, 64, 64 }
-};
-const SFB_PARAM_SHORT p_FDKaacEnc_24000_short_120 = {
- 15,
- { 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 12, 12, 16, 16, 12 }
-};
-
-const SFB_PARAM_LONG p_FDKaacEnc_32000_long_960 = {
- 49,
- { 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8, 8, 8, 12, 12, 12,
- 12, 16, 16, 20, 20, 24, 24, 28, 28, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
- 32, 32, 32, 32, 32, 32, 32, 32, 32 }
-};
-
-const SFB_PARAM_SHORT p_FDKaacEnc_32000_short_120 = {
- 14,
- { 4, 4, 4, 4, 4, 8, 8, 8, 12, 12, 12, 16, 16, 8 }
-};
-
-const SFB_PARAM_LONG p_FDKaacEnc_44100_long_960 = {
- 49,
- { 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8,
- 8, 8, 8, 12, 12, 12, 12, 16, 16, 20, 20, 24, 24, 28,
- 28, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
- 32, 32, 32, 32, 32, 32, 32 }
-};
-
-const SFB_PARAM_SHORT p_FDKaacEnc_44100_short_120 = {
- 14,
- { 4, 4, 4, 4, 4, 8, 8, 8, 12, 12, 12, 16, 16, 8 }
-};
-
-const SFB_PARAM_LONG p_FDKaacEnc_48000_long_960 = {
- 49,
- { 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8,
- 8, 8, 8, 12, 12, 12, 12, 16, 16, 20, 20, 24, 24, 28,
- 28, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
- 32, 32, 32, 32, 32, 32, 32 }
-};
-const SFB_PARAM_SHORT p_FDKaacEnc_48000_short_120 = {
- 14,
- { 4, 4, 4, 4, 4, 8, 8, 8, 12, 12, 12, 16, 16, 8 }
-};
-
-const SFB_PARAM_LONG p_FDKaacEnc_64000_long_960 = {
- 46,
- { 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 12, 12,
- 12, 16, 16, 16, 20, 24, 24, 28, 36, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
- 40, 40, 40, 40, 40, 16 }
-};
-const SFB_PARAM_SHORT p_FDKaacEnc_64000_short_120 = {
- 12,
- { 4, 4, 4, 4, 4, 4, 8, 8, 8, 16, 28, 28 }
-};
-
-const SFB_PARAM_LONG p_FDKaacEnc_88200_long_960 = {
- 40,
- { 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8, 12,
- 12, 12, 12, 12, 16, 16, 24, 28, 36, 44, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64 }
-};
-const SFB_PARAM_SHORT p_FDKaacEnc_88200_short_120 = {
- 12,
- { 4, 4, 4, 4, 4, 4, 8, 8, 8, 16, 28, 28 }
-};
-
-const SFB_PARAM_LONG p_FDKaacEnc_96000_long_960 = {
- 40,
- { 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8, 12,
- 12, 12, 12, 12, 16, 16, 24, 28, 36, 44, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64 }
-};
-const SFB_PARAM_SHORT p_FDKaacEnc_96000_short_120 = {
- 12,
- { 4, 4, 4, 4, 4, 4, 8, 8, 8, 16, 28, 28 }
-};
-
-
-static const SFB_INFO_TAB sfbInfoTab960[] = {
- { 8000, &p_FDKaacEnc_8000_long_960, &p_FDKaacEnc_8000_short_120},
- {11025, &p_FDKaacEnc_11025_long_960, &p_FDKaacEnc_11025_short_120},
- {12000, &p_FDKaacEnc_12000_long_960, &p_FDKaacEnc_12000_short_120},
- {16000, &p_FDKaacEnc_16000_long_960, &p_FDKaacEnc_16000_short_120},
- {22050, &p_FDKaacEnc_22050_long_960, &p_FDKaacEnc_22050_short_120},
- {24000, &p_FDKaacEnc_24000_long_960, &p_FDKaacEnc_24000_short_120},
- {32000, &p_FDKaacEnc_32000_long_960, &p_FDKaacEnc_32000_short_120},
- {44100, &p_FDKaacEnc_44100_long_960, &p_FDKaacEnc_44100_short_120},
- {48000, &p_FDKaacEnc_48000_long_960, &p_FDKaacEnc_48000_short_120},
- {64000, &p_FDKaacEnc_64000_long_960, &p_FDKaacEnc_64000_short_120},
- {88200, &p_FDKaacEnc_88200_long_960, &p_FDKaacEnc_88200_short_120},
- {96000, &p_FDKaacEnc_96000_long_960, &p_FDKaacEnc_96000_short_120},
-};
-
-
-/* 22050 and 24000 Hz */
-static const SFB_PARAM_LONG p_22050_long_512 = {
- 31,
- { 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 8, 8, 8, 12, 12, 12, 16, 20, 24,
- 28, 32, 32, 32, 32, 32, 32, 32, 32, 32,
- 32}
-};
-
-/* 32000 Hz */
-static const SFB_PARAM_LONG p_32000_long_512 = {
- 37,
- { 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 4, 4, 4, 8, 8, 8, 8, 8, 12,
- 12, 12, 12, 16, 16, 16, 20, 24, 24, 28,
- 32, 32, 32, 32, 32, 32, 32}
-};
-
-/* 44100 Hz */
-static const SFB_PARAM_LONG p_44100_long_512 = {
- 36,
- {4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 4, 4, 4, 4, 8, 8, 8, 8, 8,
- 12, 12, 12, 12, 16, 20, 24, 28, 32, 32,
- 32, 32, 32, 32, 32, 52}
-};
-
-static const SFB_INFO_TAB sfbInfoTabLD512[] = {
- { 8000, &p_22050_long_512, NULL},
- {11025, &p_22050_long_512, NULL},
- {12000, &p_22050_long_512, NULL},
- {16000, &p_22050_long_512, NULL},
- {22050, &p_22050_long_512, NULL},
- {24000, &p_22050_long_512, NULL},
- {32000, &p_32000_long_512, NULL},
- {44100, &p_44100_long_512, NULL},
- {48000, &p_44100_long_512, NULL},
- {64000, &p_44100_long_512, NULL},
- {88200, &p_44100_long_512, NULL},
- {96000, &p_44100_long_512, NULL},
-
-};
-
-
-/* 22050 and 24000 Hz */
-static const SFB_PARAM_LONG p_22050_long_480 = {
- 30,
- { 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 8, 8, 8, 12, 12, 12, 16, 20, 24,
- 28, 32, 32, 32, 32, 32, 32, 32, 32, 32}
-};
-
-/* 32000 Hz */
-static const SFB_PARAM_LONG p_32000_long_480 = {
- 37,
- { 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 4, 4, 4, 4, 4, 8, 8, 8, 8,
- 8, 8, 12, 12, 12, 16, 16, 20, 24, 32,
- 32, 32, 32, 32, 32, 32, 32}
-};
-
-/* 44100 Hz */
-static const SFB_PARAM_LONG p_44100_long_480 = {
- 35,
- { 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 4, 4, 4, 8, 8, 8, 8, 8, 12,
- 12, 12, 12, 12, 16, 16, 24, 28, 32, 32,
- 32, 32, 32, 32, 48}
-};
-
-static const SFB_INFO_TAB sfbInfoTabLD480[] = {
- { 8000, &p_22050_long_480, NULL},
- {11025, &p_22050_long_480, NULL},
- {12000, &p_22050_long_480, NULL},
- {16000, &p_22050_long_480, NULL},
- {22050, &p_22050_long_480, NULL},
- {24000, &p_22050_long_480, NULL},
- {32000, &p_32000_long_480, NULL},
- {44100, &p_44100_long_480, NULL},
- {48000, &p_44100_long_480, NULL},
- {64000, &p_44100_long_480, NULL},
- {88200, &p_44100_long_480, NULL},
- {96000, &p_44100_long_480, NULL},
-
-};
-
-/* Fixed point precision definitions */
-#define Q_BARCVAL (25)
-
-static AAC_ENCODER_ERROR FDKaacEnc_initSfbTable(LONG sampleRate, INT blockType, INT granuleLength, INT *sfbOffset, INT *sfbCnt)
-{
- INT i, specStartOffset = 0;
- const UCHAR* sfbWidth = NULL;
- const SFB_INFO_TAB *sfbInfo = NULL;
- int size;
-
- /*
- select table
- */
- switch(granuleLength) {
- case 1024:
- sfbInfo = sfbInfoTab;
- size = (INT)(sizeof(sfbInfoTab)/sizeof(SFB_INFO_TAB));
- break;
- case 960:
- sfbInfo = sfbInfoTab960;
- size = (INT)(sizeof(sfbInfoTab960)/sizeof(SFB_INFO_TAB));
- break;
- case 512:
- sfbInfo = sfbInfoTabLD512;
- size = sizeof(sfbInfoTabLD512);
- break;
- case 480:
- sfbInfo = sfbInfoTabLD480;
- size = sizeof(sfbInfoTabLD480);
- break;
- default:
- return AAC_ENC_INVALID_FRAME_LENGTH;
- }
-
- for(i = 0; i < size; i++){
- if(sfbInfo[i].sampleRate == sampleRate){
- switch(blockType){
- case LONG_WINDOW:
- case START_WINDOW:
- case STOP_WINDOW:
- sfbWidth = sfbInfo[i].paramLong->sfbWidth;
- *sfbCnt = sfbInfo[i].paramLong->sfbCnt;
- break;
- case SHORT_WINDOW:
- sfbWidth = sfbInfo[i].paramShort->sfbWidth;
- *sfbCnt = sfbInfo[i].paramShort->sfbCnt;
- granuleLength /= TRANS_FAC;
- break;
- }
- break;
- }
- }
- if (i == size) {
- return AAC_ENC_UNSUPPORTED_SAMPLINGRATE;
- }
-
- /*
- calc sfb offsets
- */
- for(i = 0; i < *sfbCnt; i++){
- sfbOffset[i] = specStartOffset;
- specStartOffset += sfbWidth[i];
- if (specStartOffset >= granuleLength) {
- i++;
- break;
- }
- }
- *sfbCnt = fixMin(i,*sfbCnt);
- sfbOffset[*sfbCnt] = fixMin(specStartOffset,granuleLength);
-
- return AAC_ENC_OK;
-}
-
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_BarcLineValue
- description: Calculates barc value for one frequency line
- returns: barc value of line
- input: number of lines in transform, index of line to check, Fs
- output:
-
-*****************************************************************************/
-static FIXP_DBL FDKaacEnc_BarcLineValue(INT noOfLines, INT fftLine, LONG samplingFreq)
-{
-
- FIXP_DBL FOURBY3EM4 = (FIXP_DBL)0x45e7b273; /* 4.0/3 * 0.0001 in q43 */
- FIXP_DBL PZZZ76 = (FIXP_DBL)0x639d5e4a; /* 0.00076 in q41 */
- FIXP_DBL ONE3P3 = (FIXP_DBL)0x35333333; /* 13.3 in q26 */
- FIXP_DBL THREEP5 = (FIXP_DBL)0x1c000000; /* 3.5 in q27 */
- FIXP_DBL INV480 = (FIXP_DBL)0x44444444; // 1/480 in q39
-
- FIXP_DBL center_freq, x1, x2;
- FIXP_DBL bvalFFTLine, atan1, atan2;
-
- /* Theoritical maximum of center_freq (samp_freq*0.5) is 96khz * 0.5 = 48000 */
- /* Theoritical maximum of x1 is 1.3333333e-4f * center_freq = 6.4, can keep in q28 */
- /* Theoritical maximum of x2 is 0.00076f * center_freq = 36.48, can keep in q25 */
-
- center_freq = fftLine * samplingFreq; /* q11 or q8 */
-
- switch (noOfLines) {
- case 1024:
- center_freq = center_freq << 2; /* q13 */
- break;
- case 960:
- center_freq = fMult(center_freq, INV480) << 3;
- break;
- case 128:
- center_freq = center_freq << 5; /* q13 */
- break;
- case 120:
- center_freq = fMult(center_freq, INV480) << 6;
- break;
- case 512:
- center_freq = (fftLine * samplingFreq) << 3; // q13
- break;
- case 480:
- center_freq = fMult(center_freq, INV480) << 4; // q13
- break;
- default:
- center_freq = (FIXP_DBL)0;
- }
-
- x1 = fMult(center_freq, FOURBY3EM4); /* q13 * q43 - (DFRACT_BITS-1) = q25 */
- x2 = fMult(center_freq, PZZZ76) << 2; /* q13 * q41 - (DFRACT_BITS-1) + 2 = q25 */
-
- atan1 = fixp_atan(x1);
- atan2 = fixp_atan(x2);
-
- /* q25 (q26 * q30 - (DFRACT_BITS-1)) + q25 (q27 * q30 * q30) */
- bvalFFTLine = fMult(ONE3P3, atan2) + fMult(THREEP5, fMult(atan1, atan1));
- return(bvalFFTLine);
-
-}
-
-/*
- do not consider energies below a certain input signal level,
- i.e. of -96dB or 1 bit at 16 bit PCM resolution,
- might need to be configurable to e.g. 24 bit PCM Input or a lower
- resolution for low bit rates
-*/
-static void FDKaacEnc_InitMinPCMResolution(int numPb,
- int *pbOffset,
- FIXP_DBL *sfbPCMquantThreshold)
-{
- /* PCM_QUANT_NOISE = FDKpow(10.0f, - 20.f / 10.0f) * ABS_LOW * NORM_PCM_ENERGY * FDKpow(2,PCM_QUANT_THR_SCALE) */
- #define PCM_QUANT_NOISE ((FIXP_DBL)0x00547062)
-
- for( int i = 0; i < numPb; i++ ) {
- sfbPCMquantThreshold[i] = (pbOffset[i+1] - pbOffset[i]) * PCM_QUANT_NOISE;
- }
-}
-
-static FIXP_DBL getMaskFactor(
- const FIXP_DBL dbVal_fix,
- const INT dbVal_e,
- const FIXP_DBL ten_fix,
- const INT ten_e
- )
-{
- INT q_msk;
- FIXP_DBL mask_factor;
-
- mask_factor = fPow(ten_fix, DFRACT_BITS-1-ten_e, -dbVal_fix, DFRACT_BITS-1-dbVal_e, &q_msk);
- q_msk = fixMin(DFRACT_BITS-1,fixMax(-(DFRACT_BITS-1),q_msk));
-
- if ( (q_msk>0) && (mask_factor>(FIXP_DBL)MAXVAL_DBL>>q_msk) ) {
- mask_factor = (FIXP_DBL)MAXVAL_DBL;
- }
- else {
- mask_factor = scaleValue(mask_factor, q_msk);
- }
-
- return (mask_factor);
-}
-
-static void FDKaacEnc_initSpreading(INT numPb,
- FIXP_DBL *pbBarcValue,
- FIXP_DBL *pbMaskLoFactor,
- FIXP_DBL *pbMaskHiFactor,
- FIXP_DBL *pbMaskLoFactorSprEn,
- FIXP_DBL *pbMaskHiFactorSprEn,
- const LONG bitrate,
- const INT blockType)
-
-{
- INT i;
- FIXP_DBL MASKLOWSPREN, MASKHIGHSPREN;
-
- FIXP_DBL MASKHIGH = (FIXP_DBL)0x30000000; /* 1.5 in q29 */
- FIXP_DBL MASKLOW = (FIXP_DBL)0x60000000; /* 3.0 in q29 */
- FIXP_DBL MASKLOWSPRENLONG = (FIXP_DBL)0x60000000; /* 3.0 in q29 */
- FIXP_DBL MASKHIGHSPRENLONG = (FIXP_DBL)0x40000000; /* 2.0 in q29 */
- FIXP_DBL MASKHIGHSPRENLONGLOWBR = (FIXP_DBL)0x30000000; /* 1.5 in q29 */
- FIXP_DBL MASKLOWSPRENSHORT = (FIXP_DBL)0x40000000; /* 2.0 in q29 */
- FIXP_DBL MASKHIGHSPRENSHORT = (FIXP_DBL)0x30000000; /* 1.5 in q29 */
- FIXP_DBL TEN = (FIXP_DBL)0x50000000; /* 10.0 in q27 */
-
- if (blockType != SHORT_WINDOW)
- {
- MASKLOWSPREN = MASKLOWSPRENLONG;
- MASKHIGHSPREN = (bitrate>20000)?MASKHIGHSPRENLONG:MASKHIGHSPRENLONGLOWBR;
- }
- else
- {
- MASKLOWSPREN = MASKLOWSPRENSHORT;
- MASKHIGHSPREN = MASKHIGHSPRENSHORT;
- }
-
- for(i=0; i<numPb; i++)
- {
- if (i > 0)
- {
- pbMaskHiFactor[i] = getMaskFactor(
- fMult(MASKHIGH, (pbBarcValue[i] - pbBarcValue[i-1])), 23,
- TEN, 27);
-
- pbMaskLoFactor[i-1] = getMaskFactor(
- fMult(MASKLOW, (pbBarcValue[i] - pbBarcValue[i-1])), 23,
- TEN, 27);
-
- pbMaskHiFactorSprEn[i] = getMaskFactor(
- fMult(MASKHIGHSPREN, (pbBarcValue[i] - pbBarcValue[i-1])), 23,
- TEN, 27);
-
- pbMaskLoFactorSprEn[i-1] = getMaskFactor(
- fMult(MASKLOWSPREN, (pbBarcValue[i] - pbBarcValue[i-1])), 23,
- TEN, 27);
- }
- else
- {
- pbMaskHiFactor[i] = (FIXP_DBL)0;
- pbMaskLoFactor[numPb-1] = (FIXP_DBL)0;
- pbMaskHiFactorSprEn[i] = (FIXP_DBL)0;
- pbMaskLoFactorSprEn[numPb-1] = (FIXP_DBL)0;
- }
- }
-}
-
-static void FDKaacEnc_initBarcValues(INT numPb,
- INT *pbOffset,
- INT numLines,
- INT samplingFrequency,
- FIXP_DBL *pbBval)
-{
- INT i;
- FIXP_DBL MAX_BARC = (FIXP_DBL)0x30000000; /* 24.0 in q25 */
-
- for(i=0; i<numPb; i++)
- {
- FIXP_DBL v1, v2, cur_bark;
- v1 = FDKaacEnc_BarcLineValue(numLines, pbOffset[i], samplingFrequency);
- v2 = FDKaacEnc_BarcLineValue(numLines, pbOffset[i+1], samplingFrequency);
- cur_bark = (v1 >> 1) + (v2 >> 1);
- pbBval[i] = fixMin(cur_bark, MAX_BARC);
- }
-}
-
-static void FDKaacEnc_initMinSnr(const LONG bitrate,
- const LONG samplerate,
- const INT numLines,
- const INT *sfbOffset,
- const INT sfbActive,
- const INT blockType,
- FIXP_DBL *sfbMinSnrLdData)
-{
- INT sfb;
-
- /* Fix conversion variables */
- INT qbfac, qperwin, qdiv, qpeprt_const, qpeprt;
- INT qtmp, qsnr, sfbWidth;
-
- FIXP_DBL MAX_BARC = (FIXP_DBL)0x30000000; /* 24.0 in q25 */
- FIXP_DBL MAX_BARCP1 = (FIXP_DBL)0x32000000; /* 25.0 in q25 */
- FIXP_DBL BITS2PEFAC = (FIXP_DBL)0x4b851eb8; /* 1.18 in q30 */
- FIXP_DBL PERS2P4 = (FIXP_DBL)0x624dd2f2; /* 0.024 in q36 */
- FIXP_DBL ONEP5 = (FIXP_DBL)0x60000000; /* 1.5 in q30 */
- FIXP_DBL MAX_SNR = (FIXP_DBL)0x33333333; /* 0.8 in q30 */
- FIXP_DBL MIN_SNR = (FIXP_DBL)0x003126e9; /* 0.003 in q30 */
-
- FIXP_DBL barcFactor, pePerWindow, pePart, barcWidth;
- FIXP_DBL pePart_const, tmp, snr, one_qsnr, one_point5;
-
- /* relative number of active barks */
- barcFactor = fDivNorm(fixMin(FDKaacEnc_BarcLineValue(numLines, sfbOffset[sfbActive], samplerate), MAX_BARC),
- MAX_BARCP1, &qbfac);
-
- qbfac = DFRACT_BITS-1-qbfac;
-
- pePerWindow = fDivNorm(bitrate, samplerate, &qperwin);
- qperwin = DFRACT_BITS-1-qperwin;
- pePerWindow = fMult(pePerWindow, BITS2PEFAC); qperwin = qperwin + 30 - (DFRACT_BITS-1);
- pePerWindow = fMult(pePerWindow, PERS2P4); qperwin = qperwin + 36 - (DFRACT_BITS-1);
-
- switch (numLines) {
- case 1024:
- qperwin = qperwin - 10;
- break;
- case 128:
- qperwin = qperwin - 7;
- break;
- case 512:
- qperwin = qperwin - 9;
- break;
- case 480:
- qperwin = qperwin - 9;
- pePerWindow = fMult(pePerWindow, FL2FXCONST_DBL(480.f/512.f));
- break;
- case 960:
- pePerWindow = fMult(pePerWindow, FL2FXCONST_DBL(960.f/1024.f));
- qperwin = qperwin - 10;
- break;
- case 120:
- pePerWindow = fMult(pePerWindow, FL2FXCONST_DBL(120.f/128.f));
- qperwin = qperwin - 7;
- break;
- }
-
- /* for short blocks it is assumed that more bits are available */
- if (blockType == SHORT_WINDOW)
- {
- pePerWindow = fMult(pePerWindow, ONEP5);
- qperwin = qperwin + 30 - (DFRACT_BITS-1);
- }
- pePart_const = fDivNorm(pePerWindow, barcFactor, &qdiv); qpeprt_const = qperwin - qbfac + DFRACT_BITS-1-qdiv;
-
- for (sfb = 0; sfb < sfbActive; sfb++)
- {
- barcWidth = FDKaacEnc_BarcLineValue(numLines, sfbOffset[sfb+1], samplerate) -
- FDKaacEnc_BarcLineValue(numLines, sfbOffset[sfb], samplerate);
-
- /* adapt to sfb bands */
- pePart = fMult(pePart_const, barcWidth); qpeprt = qpeprt_const + 25 - (DFRACT_BITS-1);
-
- /* pe -> snr calculation */
- sfbWidth = (sfbOffset[sfb+1] - sfbOffset[sfb]);
- pePart = fDivNorm(pePart, sfbWidth, &qdiv); qpeprt += DFRACT_BITS-1-qdiv;
-
- tmp = f2Pow(pePart, DFRACT_BITS-1-qpeprt, &qtmp);
- qtmp = DFRACT_BITS-1-qtmp;
-
- /* Subtract 1.5 */
- qsnr = fixMin(qtmp, 30);
- tmp = tmp >> (qtmp - qsnr);
-
- if((30+1-qsnr) > (DFRACT_BITS-1))
- one_point5 = (FIXP_DBL)0;
- else
- one_point5 = (FIXP_DBL)(ONEP5 >> (30+1-qsnr));
-
- snr = (tmp>>1) - (one_point5); qsnr -= 1;
-
- /* max(snr, 1.0) */
- if(qsnr > 0)
- one_qsnr = (FIXP_DBL)(1 << qsnr);
- else
- one_qsnr = (FIXP_DBL)0;
-
- snr = fixMax(one_qsnr, snr);
-
- /* 1/snr */
- snr = fDivNorm(one_qsnr, snr, &qsnr);
- qsnr = DFRACT_BITS-1-qsnr;
- snr = (qsnr > 30)? (snr>>(qsnr-30)):snr;
-
- /* upper limit is -1 dB */
- snr = (snr > MAX_SNR) ? MAX_SNR : snr;
-
- /* lower limit is -25 dB */
- snr = (snr < MIN_SNR) ? MIN_SNR : snr;
- snr = snr << 1;
-
- sfbMinSnrLdData[sfb] = CalcLdData(snr);
- }
-}
-
-AAC_ENCODER_ERROR FDKaacEnc_InitPsyConfiguration(INT bitrate,
- INT samplerate,
- INT bandwidth,
- INT blocktype,
- INT granuleLength,
- INT useIS,
- PSY_CONFIGURATION *psyConf,
- FB_TYPE filterbank)
-{
- AAC_ENCODER_ERROR ErrorStatus;
- INT sfb;
- FIXP_DBL sfbBarcVal[MAX_SFB];
- const INT frameLengthLong = granuleLength;
- const INT frameLengthShort = granuleLength/TRANS_FAC;
-
- FDKmemclear(psyConf, sizeof(PSY_CONFIGURATION));
- psyConf->granuleLength = granuleLength;
- psyConf->filterbank = filterbank;
-
- psyConf->allowIS = (useIS) && ( (bitrate/bandwidth) < 5 );
-
- /* init sfb table */
- ErrorStatus = FDKaacEnc_initSfbTable(samplerate,blocktype,granuleLength,psyConf->sfbOffset,&psyConf->sfbCnt);
- if (ErrorStatus != AAC_ENC_OK)
- return ErrorStatus;
-
- /* calculate barc values for each pb */
- FDKaacEnc_initBarcValues(psyConf->sfbCnt,
- psyConf->sfbOffset,
- psyConf->sfbOffset[psyConf->sfbCnt],
- samplerate,
- sfbBarcVal);
-
- FDKaacEnc_InitMinPCMResolution(psyConf->sfbCnt,
- psyConf->sfbOffset,
- psyConf->sfbPcmQuantThreshold);
-
- /* calculate spreading function */
- FDKaacEnc_initSpreading(psyConf->sfbCnt,
- sfbBarcVal,
- psyConf->sfbMaskLowFactor,
- psyConf->sfbMaskHighFactor,
- psyConf->sfbMaskLowFactorSprEn,
- psyConf->sfbMaskHighFactorSprEn,
- bitrate,
- blocktype);
-
- /* init ratio */
-
- psyConf->maxAllowedIncreaseFactor = 2; /* integer */
- psyConf->minRemainingThresholdFactor = (FIXP_SGL)0x0148; /* FL2FXCONST_SGL(0.01f); */ /* fract */
-
- psyConf->clipEnergy = (FIXP_DBL)0x773593ff; /* FL2FXCONST_DBL(1.0e9*NORM_PCM_ENERGY); */
-
- if (blocktype!=SHORT_WINDOW) {
- psyConf->lowpassLine = (INT)((2*bandwidth*frameLengthLong)/samplerate);
- psyConf->lowpassLineLFE = LFE_LOWPASS_LINE;
- }
- else {
- psyConf->lowpassLine = (INT)((2*bandwidth*frameLengthShort)/samplerate);
- psyConf->lowpassLineLFE = 0; /* LFE only in lonf blocks */
- /* psyConf->clipEnergy /= (TRANS_FAC * TRANS_FAC); */
- psyConf->clipEnergy >>= 6;
- }
-
- for (sfb = 0; sfb < psyConf->sfbCnt; sfb++){
- if (psyConf->sfbOffset[sfb] >= psyConf->lowpassLine)
- break;
- }
- psyConf->sfbActive = sfb;
-
- for (sfb = 0; sfb < psyConf->sfbCnt; sfb++){
- if (psyConf->sfbOffset[sfb] >= psyConf->lowpassLineLFE)
- break;
- }
- psyConf->sfbActiveLFE = sfb;
-
- /* calculate minSnr */
- FDKaacEnc_initMinSnr(bitrate,
- samplerate,
- psyConf->sfbOffset[psyConf->sfbCnt],
- psyConf->sfbOffset,
- psyConf->sfbActive,
- blocktype,
- psyConf->sfbMinSnrLdData);
-
- return AAC_ENC_OK;
-}
-
diff --git a/libAACenc/src/psy_configuration.h b/libAACenc/src/psy_configuration.h
deleted file mode 100644
index 3629246..0000000
--- a/libAACenc/src/psy_configuration.h
+++ /dev/null
@@ -1,165 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M.Werner
- contents/description: Psychoaccoustic configuration
-
-******************************************************************************/
-
-#ifndef _PSY_CONFIGURATION_H
-#define _PSY_CONFIGURATION_H
-
-
-#include "aacenc.h"
-#include "common_fix.h"
-
-#include "psy_const.h"
-#include "aacenc_tns.h"
-#include "aacenc_pns.h"
-
-#define THR_SHIFTBITS 4
-#define PCM_QUANT_THR_SCALE 16
-
-#define C_RATIO (FIXP_DBL)0x02940a10 /* FL2FXCONST_DBL(0.001258925f) << THR_SHIFTBITS; */ /* pow(10.0f, -(29.0f/10.0f)) */
-
-typedef struct{
-
- INT sfbCnt; /* number of existing sf bands */
- INT sfbActive; /* number of sf bands containing energy after lowpass */
- INT sfbActiveLFE;
- INT sfbOffset[MAX_SFB+1];
-
- INT filterbank; /* LC, LD or ELD */
-
- FIXP_DBL sfbPcmQuantThreshold[MAX_SFB];
-
- INT maxAllowedIncreaseFactor; /* preecho control */
- FIXP_SGL minRemainingThresholdFactor;
-
- INT lowpassLine;
- INT lowpassLineLFE;
- FIXP_DBL clipEnergy; /* for level dependend tmn */
-
- FIXP_DBL sfbMaskLowFactor[MAX_SFB];
- FIXP_DBL sfbMaskHighFactor[MAX_SFB];
-
- FIXP_DBL sfbMaskLowFactorSprEn[MAX_SFB];
- FIXP_DBL sfbMaskHighFactorSprEn[MAX_SFB];
-
- FIXP_DBL sfbMinSnrLdData[MAX_SFB]; /* minimum snr (formerly known as bmax) */
-
- TNS_CONFIG tnsConf;
- PNS_CONFIG pnsConf;
-
- INT granuleLength;
- INT allowIS;
-
-}PSY_CONFIGURATION;
-
-
-typedef struct{
- UCHAR sfbCnt; /* Number of scalefactor bands */
- UCHAR sfbWidth[MAX_SFB_LONG]; /* Width of scalefactor bands for long blocks */
-}SFB_PARAM_LONG;
-
-typedef struct{
- UCHAR sfbCnt; /* Number of scalefactor bands */
- UCHAR sfbWidth[MAX_SFB_SHORT]; /* Width of scalefactor bands for short blocks */
-}SFB_PARAM_SHORT;
-
-
-AAC_ENCODER_ERROR FDKaacEnc_InitPsyConfiguration(INT bitrate,
- INT samplerate,
- INT bandwidth,
- INT blocktype,
- INT granuleLength,
- INT useIS,
- PSY_CONFIGURATION *psyConf,
- FB_TYPE filterbank);
-
-#endif /* _PSY_CONFIGURATION_H */
-
-
-
diff --git a/libAACenc/src/psy_const.h b/libAACenc/src/psy_const.h
deleted file mode 100644
index 15a69c9..0000000
--- a/libAACenc/src/psy_const.h
+++ /dev/null
@@ -1,161 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M.Werner
- contents/description: Global psychoaccoustic constants
-
-******************************************************************************/
-#ifndef _PSYCONST_H
-#define _PSYCONST_H
-
-
-#define TRUE 1
-#define FALSE 0
-
- #define TRANS_FAC 8 /* encoder short long ratio */
-
-#define FRAME_LEN_LONG_960 (960)
-#define FRAME_MAXLEN_SHORT ((1024)/TRANS_FAC)
-#define FRAME_LEN_SHORT_128 ((1024)/TRANS_FAC)
-
-/* Filterbank type*/
-enum FB_TYPE {
- FB_LC = 0,
- FB_LD = 1,
- FB_ELD = 2
-};
-
-/* Block types */
-#define N_BLOCKTYPES 6
-enum
-{
- LONG_WINDOW = 0,
- START_WINDOW,
- SHORT_WINDOW,
- STOP_WINDOW,
- _LOWOV_WINDOW, /* Do not use this block type out side of block_switch.cpp */
- WRONG_WINDOW
-};
-
-/* Window shapes */
-enum
-{
- SINE_WINDOW = 0,
- KBD_WINDOW = 1,
- LOL_WINDOW = 2 /* Low OverLap window shape for AAC-LD */
-};
-
-/*
- MS stuff
-*/
-enum
-{
- SI_MS_MASK_NONE = 0,
- SI_MS_MASK_SOME = 1,
- SI_MS_MASK_ALL = 2
-};
-
-
- #define MAX_NO_OF_GROUPS 4
- #define MAX_SFB_LONG 51 /* 51 for a memory optimized implementation, maybe 64 for convenient debugging */
- #define MAX_SFB_SHORT 15 /* 15 for a memory optimized implementation, maybe 16 for convenient debugging */
-
-#define MAX_SFB (MAX_SFB_SHORT > MAX_SFB_LONG ? MAX_SFB_SHORT : MAX_SFB_LONG) /* = 51 */
-#define MAX_GROUPED_SFB (MAX_NO_OF_GROUPS*MAX_SFB_SHORT > MAX_SFB_LONG ? \
- MAX_NO_OF_GROUPS*MAX_SFB_SHORT : MAX_SFB_LONG) /* = 60 */
-
-#define MAX_INPUT_BUFFER_SIZE (2*(1024)) /* 2048 */
-
-
-#define PCM_LEVEL 1.0f
-#define NORM_PCM (PCM_LEVEL/32768.0f)
-#define NORM_PCM_ENERGY (NORM_PCM*NORM_PCM)
-#define LOG_NORM_PCM -15
-
-#define TNS_PREDGAIN_SCALE (1000)
-
-#define LFE_LOWPASS_LINE 12
-
-#endif /* _PSYCONST_H */
diff --git a/libAACenc/src/psy_data.h b/libAACenc/src/psy_data.h
deleted file mode 100644
index 7183955..0000000
--- a/libAACenc/src/psy_data.h
+++ /dev/null
@@ -1,152 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M.Werner
- contents/description: Psychoaccoustic data
-
-******************************************************************************/
-
-#ifndef _PSY_DATA_H
-#define _PSY_DATA_H
-
-
-#include "block_switch.h"
-
-/* Be careful with MAX_SFB_LONG as length of the .Long arrays.
- * sfbEnergy.Long and sfbEnergyMS.Long and sfbThreshold.Long are used as a temporary storage for the regrouped
- * short energies and thresholds between FDKaacEnc_groupShortData() and BuildInterface() in FDKaacEnc_psyMain().
- * The space required for this is MAX_GROUPED_SFB ( = MAX_NO_OF_GROUPS*MAX_SFB_SHORT ).
- * However, this is not important if unions are used (which is not possible with pfloat). */
-
-typedef shouldBeUnion{
- FIXP_DBL Long[MAX_GROUPED_SFB];
- FIXP_DBL Short[TRANS_FAC][MAX_SFB_SHORT];
-}SFB_THRESHOLD;
-
-typedef shouldBeUnion{
- FIXP_DBL Long[MAX_GROUPED_SFB];
- FIXP_DBL Short[TRANS_FAC][MAX_SFB_SHORT];
-}SFB_ENERGY;
-
-typedef shouldBeUnion{
- FIXP_DBL Long[MAX_GROUPED_SFB];
- FIXP_DBL Short[TRANS_FAC][MAX_SFB_SHORT];
-}SFB_LD_ENERGY;
-
-typedef shouldBeUnion{
- INT Long[MAX_GROUPED_SFB];
- INT Short[TRANS_FAC][MAX_SFB_SHORT];
-}SFB_MAX_SCALE;
-
-
-typedef struct{
- INT_PCM* psyInputBuffer;
- FIXP_DBL overlapAddBuffer[1024];
-
- BLOCK_SWITCHING_CONTROL blockSwitchingControl; /* block switching */
- FIXP_DBL sfbThresholdnm1[MAX_SFB]; /* FDKaacEnc_PreEchoControl */
- INT mdctScalenm1; /* scale of last block's mdct (FDKaacEnc_PreEchoControl) */
- INT calcPreEcho;
- INT isLFE;
-}PSY_STATIC;
-
-
-typedef struct{
- FIXP_DBL *mdctSpectrum;
- SFB_THRESHOLD sfbThreshold; /* adapt */
- SFB_ENERGY sfbEnergy; /* sfb energies */
- SFB_LD_ENERGY sfbEnergyLdData; /* sfb energies in ldData format */
- SFB_MAX_SCALE sfbMaxScaleSpec;
- SFB_ENERGY sfbEnergyMS; /* mid/side sfb energies */
- FIXP_DBL sfbEnergyMSLdData[MAX_GROUPED_SFB]; /* mid/side sfb energies in ldData format */
- SFB_ENERGY sfbSpreadEnergy;
- INT mdctScale; /* exponent of data in mdctSpectrum */
- INT groupedSfbOffset[MAX_GROUPED_SFB+1];
- INT sfbActive;
- INT lowpassLine;
-}PSY_DATA;
-
-
-#endif /* _PSY_DATA_H */
diff --git a/libAACenc/src/psy_main.cpp b/libAACenc/src/psy_main.cpp
deleted file mode 100644
index a544b1b..0000000
--- a/libAACenc/src/psy_main.cpp
+++ /dev/null
@@ -1,1380 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M.Werner
- contents/description: Psychoaccoustic major function block
-
-******************************************************************************/
-
-#include "psy_const.h"
-
-#include "block_switch.h"
-#include "transform.h"
-#include "spreading.h"
-#include "pre_echo_control.h"
-#include "band_nrg.h"
-#include "psy_configuration.h"
-#include "psy_data.h"
-#include "ms_stereo.h"
-#include "interface.h"
-#include "psy_main.h"
-#include "grp_data.h"
-#include "tns_func.h"
-#include "pns_func.h"
-#include "tonality.h"
-#include "aacEnc_ram.h"
-#include "intensity.h"
-
-
-
-/* blending to reduce gibbs artifacts */
-#define FADE_OUT_LEN 6
-static const FIXP_DBL fadeOutFactor[FADE_OUT_LEN] = {1840644096, 1533870080, 1227096064, 920322048, 613548032, 306774016};
-
-/* forward definitions */
-
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_PsyNew
- description: allocates memory for psychoacoustic
- returns: an error code
- input: pointer to a psych handle
-
-*****************************************************************************/
-AAC_ENCODER_ERROR FDKaacEnc_PsyNew(PSY_INTERNAL **phpsy,
- const INT nElements,
- const INT nChannels
- ,UCHAR *dynamic_RAM
- )
-{
- AAC_ENCODER_ERROR ErrorStatus;
- PSY_INTERNAL *hPsy;
- INT i;
-
- hPsy = GetRam_aacEnc_PsyInternal();
- *phpsy = hPsy;
- if (hPsy == NULL) {
- ErrorStatus = AAC_ENC_NO_MEMORY;
- goto bail;
- }
-
- for (i=0; i<nElements; i++) {
- /* PSY_ELEMENT */
- hPsy->psyElement[i] = GetRam_aacEnc_PsyElement(i);
- if (hPsy->psyElement[i] == NULL) {
- ErrorStatus = AAC_ENC_NO_MEMORY;
- goto bail;
- }
- }
-
- for (i=0; i<nChannels; i++) {
- /* PSY_STATIC */
- hPsy->pStaticChannels[i] = GetRam_aacEnc_PsyStatic(i);
- if (hPsy->pStaticChannels[i]==NULL) {
- ErrorStatus = AAC_ENC_NO_MEMORY;
- goto bail;
- }
- /* AUDIO INPUT BUFFER */
- hPsy->pStaticChannels[i]->psyInputBuffer = GetRam_aacEnc_PsyInputBuffer(i);
- if (hPsy->pStaticChannels[i]->psyInputBuffer==NULL) {
- ErrorStatus = AAC_ENC_NO_MEMORY;
- goto bail;
- }
- }
-
- /* reusable psych memory */
- hPsy->psyDynamic = GetRam_aacEnc_PsyDynamic(0, dynamic_RAM);
-
- return AAC_ENC_OK;
-
-bail:
- FDKaacEnc_PsyClose(phpsy, NULL);
-
- return ErrorStatus;
-}
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_PsyOutNew
- description: allocates memory for psyOut struc
- returns: an error code
- input: pointer to a psych handle
-
-*****************************************************************************/
-AAC_ENCODER_ERROR FDKaacEnc_PsyOutNew(PSY_OUT **phpsyOut,
- const INT nElements,
- const INT nChannels,
- const INT nSubFrames
- ,UCHAR *dynamic_RAM
- )
-{
- AAC_ENCODER_ERROR ErrorStatus;
- int n, i;
- int elInc = 0, chInc = 0;
-
- for (n=0; n<nSubFrames; n++) {
- phpsyOut[n] = GetRam_aacEnc_PsyOut(n);
-
- if (phpsyOut[n] == NULL) {
- ErrorStatus = AAC_ENC_NO_MEMORY;
- goto bail;
- }
-
- for (i=0; i<nChannels; i++) {
- phpsyOut[n]->pPsyOutChannels[i] = GetRam_aacEnc_PsyOutChannel(chInc++);
- }
-
- for (i=0; i<nElements; i++) {
- phpsyOut[n]->psyOutElement[i] = GetRam_aacEnc_PsyOutElements(elInc++);
- if (phpsyOut[n]->psyOutElement[i] == NULL) {
- ErrorStatus = AAC_ENC_NO_MEMORY;
- goto bail;
- }
- }
- } /* nSubFrames */
-
- return AAC_ENC_OK;
-
-bail:
- FDKaacEnc_PsyClose(NULL, phpsyOut);
- return ErrorStatus;
-}
-
-
-AAC_ENCODER_ERROR FDKaacEnc_psyInitStates(PSY_INTERNAL *hPsy,
- PSY_STATIC* psyStatic,
- AUDIO_OBJECT_TYPE audioObjectType)
-{
- /* init input buffer */
- FDKmemclear(psyStatic->psyInputBuffer, MAX_INPUT_BUFFER_SIZE*sizeof(INT_PCM));
-
- FDKaacEnc_InitBlockSwitching(&psyStatic->blockSwitchingControl,
- isLowDelay(audioObjectType)
- );
-
- return AAC_ENC_OK;
-}
-
-
-AAC_ENCODER_ERROR FDKaacEnc_psyInit(PSY_INTERNAL *hPsy,
- PSY_OUT **phpsyOut,
- const INT nSubFrames,
- const INT nMaxChannels,
- const AUDIO_OBJECT_TYPE audioObjectType,
- CHANNEL_MAPPING *cm)
-{
- AAC_ENCODER_ERROR ErrorStatus = AAC_ENC_OK;
- int i, ch, n, chInc = 0, resetChannels = 3;
-
- if ( (nMaxChannels>2) && (cm->nChannels==2) ) {
- chInc = 1;
- FDKaacEnc_psyInitStates(hPsy, hPsy->pStaticChannels[0], audioObjectType);
- }
-
- if ( (nMaxChannels==2) ) {
- resetChannels = 0;
- }
-
- for (i=0; i<cm->nElements; i++) {
- for (ch=0; ch<cm->elInfo[i].nChannelsInEl; ch++) {
- if (cm->elInfo[i].elType!=ID_LFE) {
- hPsy->psyElement[i]->psyStatic[ch] = hPsy->pStaticChannels[chInc];
- if (chInc>=resetChannels) {
- FDKaacEnc_psyInitStates(hPsy, hPsy->psyElement[i]->psyStatic[ch], audioObjectType);
- }
- hPsy->psyElement[i]->psyStatic[ch]->isLFE = 0;
- }
- else {
- hPsy->psyElement[i]->psyStatic[ch] = hPsy->pStaticChannels[nMaxChannels-1];
- hPsy->psyElement[i]->psyStatic[ch]->isLFE = 1;
- }
- chInc++;
- }
- }
-
- for (n=0; n<nSubFrames; n++) {
- chInc = 0;
- for (i=0; i<cm->nElements; i++) {
- for (ch=0; ch<cm->elInfo[i].nChannelsInEl; ch++) {
- phpsyOut[n]->psyOutElement[i]->psyOutChannel[ch] = phpsyOut[n]->pPsyOutChannels[chInc++];
- }
- }
- }
-
- return ErrorStatus;
-}
-
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_psyMainInit
- description: initializes psychoacoustic
- returns: an error code
-
-*****************************************************************************/
-
-AAC_ENCODER_ERROR FDKaacEnc_psyMainInit(PSY_INTERNAL *hPsy,
- AUDIO_OBJECT_TYPE audioObjectType,
- CHANNEL_MAPPING *cm,
- INT sampleRate,
- INT granuleLength,
- INT bitRate,
- INT tnsMask,
- INT bandwidth,
- INT usePns,
- INT useIS,
- UINT syntaxFlags,
- ULONG initFlags)
-{
- AAC_ENCODER_ERROR ErrorStatus;
- int i, ch;
- int channelsEff = cm->nChannelsEff;
- int tnsChannels = 0;
- FB_TYPE filterBank;
-
-
- switch(FDKaacEnc_GetMonoStereoMode(cm->encMode)) {
- /* ... and map to tnsChannels */
- case EL_MODE_MONO: tnsChannels = 1; break;
- case EL_MODE_STEREO: tnsChannels = 2; break;
- default: tnsChannels = 0;
- }
-
- switch (audioObjectType)
- {
- default: filterBank = FB_LC; break;
- case AOT_ER_AAC_LD: filterBank = FB_LD; break;
- case AOT_ER_AAC_ELD: filterBank = FB_ELD; break;
- }
-
- hPsy->granuleLength = granuleLength;
-
- ErrorStatus = FDKaacEnc_InitPsyConfiguration(bitRate/channelsEff, sampleRate, bandwidth, LONG_WINDOW, hPsy->granuleLength, useIS, &(hPsy->psyConf[0]), filterBank);
- if (ErrorStatus != AAC_ENC_OK)
- return ErrorStatus;
-
- ErrorStatus = FDKaacEnc_InitTnsConfiguration(
- (bitRate*tnsChannels)/channelsEff,
- sampleRate,
- tnsChannels,
- LONG_WINDOW,
- hPsy->granuleLength,
- (syntaxFlags&AC_SBR_PRESENT)?1:0,
- &(hPsy->psyConf[0].tnsConf),
- &hPsy->psyConf[0],
- (INT)(tnsMask&2),
- (INT)(tnsMask&8) );
-
- if (ErrorStatus != AAC_ENC_OK)
- return ErrorStatus;
-
- if (granuleLength > 512) {
- ErrorStatus = FDKaacEnc_InitPsyConfiguration(bitRate/channelsEff, sampleRate, bandwidth, SHORT_WINDOW, hPsy->granuleLength, useIS, &hPsy->psyConf[1], filterBank);
- if (ErrorStatus != AAC_ENC_OK)
- return ErrorStatus;
-
- ErrorStatus = FDKaacEnc_InitTnsConfiguration(
- (bitRate*tnsChannels)/channelsEff,
- sampleRate,
- tnsChannels,
- SHORT_WINDOW,
- hPsy->granuleLength,
- (syntaxFlags&AC_SBR_PRESENT)?1:0,
- &hPsy->psyConf[1].tnsConf,
- &hPsy->psyConf[1],
- (INT)(tnsMask&1),
- (INT)(tnsMask&4) );
-
- if (ErrorStatus != AAC_ENC_OK)
- return ErrorStatus;
-
- }
-
-
- for (i=0; i<cm->nElements; i++) {
- for (ch=0; ch<cm->elInfo[i].nChannelsInEl; ch++) {
- if (initFlags) {
- /* reset states */
- FDKaacEnc_psyInitStates(hPsy, hPsy->psyElement[i]->psyStatic[ch], audioObjectType);
- }
-
- FDKaacEnc_InitPreEchoControl(hPsy->psyElement[i]->psyStatic[ch]->sfbThresholdnm1,
- &hPsy->psyElement[i]->psyStatic[ch]->calcPreEcho,
- hPsy->psyConf[0].sfbCnt,
- hPsy->psyConf[0].sfbPcmQuantThreshold,
- &hPsy->psyElement[i]->psyStatic[ch]->mdctScalenm1);
- }
- }
-
- ErrorStatus = FDKaacEnc_InitPnsConfiguration(&hPsy->psyConf[0].pnsConf,
- bitRate/channelsEff,
- sampleRate,
- usePns,
- hPsy->psyConf[0].sfbCnt,
- hPsy->psyConf[0].sfbOffset,
- cm->elInfo[0].nChannelsInEl,
- (hPsy->psyConf[0].filterbank == FB_LC));
- if (ErrorStatus != AAC_ENC_OK)
- return ErrorStatus;
-
- ErrorStatus = FDKaacEnc_InitPnsConfiguration(&hPsy->psyConf[1].pnsConf,
- bitRate/channelsEff,
- sampleRate,
- usePns,
- hPsy->psyConf[1].sfbCnt,
- hPsy->psyConf[1].sfbOffset,
- cm->elInfo[1].nChannelsInEl,
- (hPsy->psyConf[1].filterbank == FB_LC));
- return ErrorStatus;
-}
-
-
-static
-void FDKaacEnc_deinterleaveInputBuffer(INT_PCM *pOutputSamples,
- INT_PCM *pInputSamples,
- INT nSamples,
- INT nChannels)
-{
- INT k;
- /* deinterlave input samples and write to output buffer */
- for (k=0; k<nSamples; k++) {
- pOutputSamples[k] = pInputSamples[k*nChannels];
- }
-}
-
-
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_psyMain
- description: psychoacoustic
- returns: an error code
-
- This function assumes that enough input data is in the modulo buffer.
-
-*****************************************************************************/
-
-AAC_ENCODER_ERROR FDKaacEnc_psyMain(INT channels,
- PSY_ELEMENT *psyElement,
- PSY_DYNAMIC *psyDynamic,
- PSY_CONFIGURATION *psyConf,
- PSY_OUT_ELEMENT *RESTRICT psyOutElement,
- INT_PCM *pInput,
- INT *chIdx,
- INT totalChannels
- )
-{
- INT commonWindow = 1;
- INT maxSfbPerGroup[(2)];
- INT mdctSpectrum_e;
- INT ch; /* counts through channels */
- INT w; /* counts through windows */
- INT sfb; /* counts through scalefactor bands */
- INT line; /* counts through lines */
-
- PSY_CONFIGURATION *RESTRICT hPsyConfLong = &psyConf[0];
- PSY_CONFIGURATION *RESTRICT hPsyConfShort = &psyConf[1];
- PSY_OUT_CHANNEL **RESTRICT psyOutChannel = psyOutElement->psyOutChannel;
- FIXP_SGL sfbTonality[(2)][MAX_SFB_LONG];
-
- PSY_STATIC **RESTRICT psyStatic = psyElement->psyStatic;
-
- PSY_DATA *RESTRICT psyData[(2)];
- TNS_DATA *RESTRICT tnsData[(2)];
- PNS_DATA *RESTRICT pnsData[(2)];
-
- INT zeroSpec = TRUE; /* means all spectral lines are zero */
-
- INT blockSwitchingOffset;
-
- PSY_CONFIGURATION *RESTRICT hThisPsyConf[(2)];
- INT windowLength[(2)];
- INT nWindows[(2)];
- INT wOffset;
-
- INT maxSfb[(2)];
- INT *pSfbMaxScaleSpec[(2)];
- FIXP_DBL *pSfbEnergy[(2)];
- FIXP_DBL *pSfbSpreadEnergy[(2)];
- FIXP_DBL *pSfbEnergyLdData[(2)];
- FIXP_DBL *pSfbEnergyMS[(2)];
- FIXP_DBL *pSfbThreshold[(2)];
-
- INT isShortWindow[(2)];
-
-
- if (hPsyConfLong->filterbank == FB_LC) {
- blockSwitchingOffset = psyConf->granuleLength + (9*psyConf->granuleLength/(2*TRANS_FAC));
- } else {
- blockSwitchingOffset = psyConf->granuleLength;
- }
-
- for(ch = 0; ch < channels; ch++)
- {
- psyData[ch] = &psyDynamic->psyData[ch];
- tnsData[ch] = &psyDynamic->tnsData[ch];
- pnsData[ch] = &psyDynamic->pnsData[ch];
-
- psyData[ch]->mdctSpectrum = psyOutChannel[ch]->mdctSpectrum;
- }
-
- /* block switching */
- if (hPsyConfLong->filterbank != FB_ELD)
- {
- int err;
-
- for(ch = 0; ch < channels; ch++)
- {
- C_ALLOC_SCRATCH_START(pTimeSignal, INT_PCM, (1024))
-
- /* deinterleave input data and use for block switching */
- FDKaacEnc_deinterleaveInputBuffer( pTimeSignal,
- &pInput[chIdx[ch]],
- psyConf->granuleLength,
- totalChannels);
-
-
- FDKaacEnc_BlockSwitching (&psyStatic[ch]->blockSwitchingControl,
- psyConf->granuleLength,
- psyStatic[ch]->isLFE,
- pTimeSignal
- );
-
-
- /* fill up internal input buffer, to 2xframelength samples */
- FDKmemcpy(psyStatic[ch]->psyInputBuffer+blockSwitchingOffset,
- pTimeSignal,
- (2*psyConf->granuleLength-blockSwitchingOffset)*sizeof(INT_PCM));
-
- C_ALLOC_SCRATCH_END(pTimeSignal, INT_PCM, (1024))
- }
-
- /* synch left and right block type */
- err = FDKaacEnc_SyncBlockSwitching(&psyStatic[0]->blockSwitchingControl,
- &psyStatic[1]->blockSwitchingControl,
- channels,
- commonWindow);
-
- if (err) {
- return AAC_ENC_UNSUPPORTED_AOT; /* mixed up LC and LD */
- }
-
- }
- else {
- for(ch = 0; ch < channels; ch++)
- {
- /* deinterleave input data and use for block switching */
- FDKaacEnc_deinterleaveInputBuffer( psyStatic[ch]->psyInputBuffer + blockSwitchingOffset,
- &pInput[chIdx[ch]],
- psyConf->granuleLength,
- totalChannels);
- }
- }
-
- for(ch = 0; ch < channels; ch++)
- isShortWindow[ch]=(psyStatic[ch]->blockSwitchingControl.lastWindowSequence == SHORT_WINDOW);
-
- /* set parameters according to window length */
- for(ch = 0; ch < channels; ch++)
- {
- if(isShortWindow[ch]) {
- hThisPsyConf[ch] = hPsyConfShort;
- windowLength[ch] = psyConf->granuleLength/TRANS_FAC;
- nWindows[ch] = TRANS_FAC;
- maxSfb[ch] = MAX_SFB_SHORT;
-
- pSfbMaxScaleSpec[ch] = psyData[ch]->sfbMaxScaleSpec.Short[0];
- pSfbEnergy[ch] = psyData[ch]->sfbEnergy.Short[0];
- pSfbSpreadEnergy[ch] = psyData[ch]->sfbSpreadEnergy.Short[0];
- pSfbEnergyLdData[ch] = psyData[ch]->sfbEnergyLdData.Short[0];
- pSfbEnergyMS[ch] = psyData[ch]->sfbEnergyMS.Short[0];
- pSfbThreshold[ch] = psyData[ch]->sfbThreshold.Short[0];
-
- } else
- {
- hThisPsyConf[ch] = hPsyConfLong;
- windowLength[ch] = psyConf->granuleLength;
- nWindows[ch] = 1;
- maxSfb[ch] = MAX_GROUPED_SFB;
-
- pSfbMaxScaleSpec[ch] = psyData[ch]->sfbMaxScaleSpec.Long;
- pSfbEnergy[ch] = psyData[ch]->sfbEnergy.Long;
- pSfbSpreadEnergy[ch] = psyData[ch]->sfbSpreadEnergy.Long;
- pSfbEnergyLdData[ch] = psyData[ch]->sfbEnergyLdData.Long;
- pSfbEnergyMS[ch] = psyData[ch]->sfbEnergyMS.Long;
- pSfbThreshold[ch] = psyData[ch]->sfbThreshold.Long;
- }
- }
-
- /* Transform and get mdctScaling for all channels and windows. */
- for(ch = 0; ch < channels; ch++)
- {
- /* update number of active bands */
- if (psyStatic[ch]->isLFE) {
- psyData[ch]->sfbActive = hThisPsyConf[ch]->sfbActiveLFE;
- psyData[ch]->lowpassLine = hThisPsyConf[ch]->lowpassLineLFE;
- } else
- {
- psyData[ch]->sfbActive = hThisPsyConf[ch]->sfbActive;
- psyData[ch]->lowpassLine = hThisPsyConf[ch]->lowpassLine;
- }
-
- for(w = 0; w < nWindows[ch]; w++) {
-
- wOffset = w*windowLength[ch];
-
- FDKaacEnc_Transform_Real( psyStatic[ch]->psyInputBuffer + wOffset,
- psyData[ch]->mdctSpectrum+wOffset,
- psyStatic[ch]->blockSwitchingControl.lastWindowSequence,
- psyStatic[ch]->blockSwitchingControl.windowShape,
- &psyStatic[ch]->blockSwitchingControl.lastWindowShape,
- psyConf->granuleLength,
- &mdctSpectrum_e,
- hThisPsyConf[ch]->filterbank
- ,psyStatic[ch]->overlapAddBuffer
- );
-
- /* Low pass / highest sfb */
- FDKmemclear(&psyData[ch]->mdctSpectrum[psyData[ch]->lowpassLine+wOffset],
- (windowLength[ch]-psyData[ch]->lowpassLine)*sizeof(FIXP_DBL));
-
- if (hPsyConfLong->filterbank != FB_LC) {
- /* Do blending to reduce gibbs artifacts */
- for (int i=0; i<FADE_OUT_LEN; i++) {
- psyData[ch]->mdctSpectrum[psyData[ch]->lowpassLine+wOffset - FADE_OUT_LEN + i] = fMult(psyData[ch]->mdctSpectrum[psyData[ch]->lowpassLine+wOffset - FADE_OUT_LEN + i], fadeOutFactor[i]);
- }
- }
-
-
- /* Check for zero spectrum. These loops will usually terminate very, very early. */
- for(line=0; (line<psyData[ch]->lowpassLine) && (zeroSpec==TRUE); line++) {
- if (psyData[ch]->mdctSpectrum[line+wOffset] != (FIXP_DBL)0) {
- zeroSpec = FALSE;
- break;
- }
- }
-
- } /* w loop */
-
- psyData[ch]->mdctScale = mdctSpectrum_e;
-
- /* rotate internal time samples */
- FDKmemmove(psyStatic[ch]->psyInputBuffer,
- psyStatic[ch]->psyInputBuffer+psyConf->granuleLength,
- psyConf->granuleLength*sizeof(INT_PCM));
-
-
- /* ... and get remaining samples from input buffer */
- FDKaacEnc_deinterleaveInputBuffer( psyStatic[ch]->psyInputBuffer+psyConf->granuleLength,
- &pInput[ (2*psyConf->granuleLength-blockSwitchingOffset)*totalChannels + chIdx[ch] ],
- blockSwitchingOffset-psyConf->granuleLength,
- totalChannels);
-
- } /* ch */
-
- /* Do some rescaling to get maximum possible accuracy for energies */
- if ( zeroSpec == FALSE) {
-
- /* Calc possible spectrum leftshift for each sfb (1 means: 1 bit left shift is possible without overflow) */
- INT minSpecShift = MAX_SHIFT_DBL;
- INT nrgShift = MAX_SHIFT_DBL;
- INT finalShift = MAX_SHIFT_DBL;
- FIXP_DBL currNrg = 0;
- FIXP_DBL maxNrg = 0;
-
- for(ch = 0; ch < channels; ch++) {
- for(w = 0; w < nWindows[ch]; w++) {
- wOffset = w*windowLength[ch];
- FDKaacEnc_CalcSfbMaxScaleSpec(psyData[ch]->mdctSpectrum+wOffset,
- hThisPsyConf[ch]->sfbOffset,
- pSfbMaxScaleSpec[ch]+w*maxSfb[ch],
- psyData[ch]->sfbActive);
-
- for (sfb = 0; sfb<psyData[ch]->sfbActive; sfb++)
- minSpecShift = fixMin(minSpecShift, (pSfbMaxScaleSpec[ch]+w*maxSfb[ch])[sfb]);
- }
-
- }
-
- /* Calc possible energy leftshift for each sfb (1 means: 1 bit left shift is possible without overflow) */
- for(ch = 0; ch < channels; ch++) {
- for(w = 0; w < nWindows[ch]; w++) {
- wOffset = w*windowLength[ch];
- currNrg = FDKaacEnc_CheckBandEnergyOptim(psyData[ch]->mdctSpectrum+wOffset,
- pSfbMaxScaleSpec[ch]+w*maxSfb[ch],
- hThisPsyConf[ch]->sfbOffset,
- psyData[ch]->sfbActive,
- pSfbEnergy[ch]+w*maxSfb[ch],
- pSfbEnergyLdData[ch]+w*maxSfb[ch],
- minSpecShift-4);
-
- maxNrg = fixMax(maxNrg, currNrg);
- }
- }
-
- if ( maxNrg != (FIXP_DBL)0 ) {
- nrgShift = (CountLeadingBits(maxNrg)>>1) + (minSpecShift-4);
- }
-
- /* 2check: Hasn't this decision to be made for both channels? */
- /* For short windows 1 additional bit headroom is necessary to prevent overflows when summing up energies in FDKaacEnc_groupShortData() */
- if(isShortWindow[0]) nrgShift--;
-
- /* both spectrum and energies mustn't overflow */
- finalShift = fixMin(minSpecShift, nrgShift);
-
- /* do not shift more than 3 bits more to the left than signal without blockfloating point
- * would be to avoid overflow of scaled PCM quantization thresholds */
- if (finalShift > psyData[0]->mdctScale + 3 )
- finalShift = psyData[0]->mdctScale + 3;
-
- FDK_ASSERT(finalShift >= 0); /* right shift is not allowed */
-
- /* correct sfbEnergy and sfbEnergyLdData with new finalShift */
- FIXP_DBL ldShift = finalShift * FL2FXCONST_DBL(2.0/64);
- for(ch = 0; ch < channels; ch++) {
- for(w = 0; w < nWindows[ch]; w++) {
- for(sfb=0; sfb<psyData[ch]->sfbActive; sfb++) {
- INT scale = fixMax(0, (pSfbMaxScaleSpec[ch]+w*maxSfb[ch])[sfb]-4);
- scale = fixMin((scale-finalShift)<<1, DFRACT_BITS-1);
- if (scale >= 0) (pSfbEnergy[ch]+w*maxSfb[ch])[sfb] >>= (scale);
- else (pSfbEnergy[ch]+w*maxSfb[ch])[sfb] <<= (-scale);
- (pSfbThreshold[ch]+w*maxSfb[ch])[sfb] = fMult((pSfbEnergy[ch]+w*maxSfb[ch])[sfb], C_RATIO);
- (pSfbEnergyLdData[ch]+w*maxSfb[ch])[sfb] += ldShift;
- }
- }
- }
-
- if ( finalShift != 0 ) {
- for (ch = 0; ch < channels; ch++) {
- for(w = 0; w < nWindows[ch]; w++) {
- wOffset = w*windowLength[ch];
- for(line=0; line<psyData[ch]->lowpassLine; line++) {
- psyData[ch]->mdctSpectrum[line+wOffset] <<= finalShift;
- }
- /* update sfbMaxScaleSpec */
- for (sfb = 0; sfb<psyData[ch]->sfbActive; sfb++)
- (pSfbMaxScaleSpec[ch]+w*maxSfb[ch])[sfb] -= finalShift;
- }
- /* update mdctScale */
- psyData[ch]->mdctScale -= finalShift;
- }
- }
-
- } else {
- /* all spectral lines are zero */
- for (ch = 0; ch < channels; ch++) {
- psyData[ch]->mdctScale = 0; /* otherwise mdctScale would be for example 7 and PCM quantization thresholds would be shifted
- * 14 bits to the right causing some of them to become 0 (which causes problems later) */
- /* clear sfbMaxScaleSpec */
- for(w = 0; w < nWindows[ch]; w++) {
- for (sfb = 0; sfb<psyData[ch]->sfbActive; sfb++) {
- (pSfbMaxScaleSpec[ch]+w*maxSfb[ch])[sfb] = 0;
- (pSfbEnergy[ch]+w*maxSfb[ch])[sfb] = (FIXP_DBL)0;
- (pSfbEnergyLdData[ch]+w*maxSfb[ch])[sfb] = FL2FXCONST_DBL(-1.0f);
- (pSfbThreshold[ch]+w*maxSfb[ch])[sfb] = (FIXP_DBL)0;
- }
- }
- }
- }
-
- /* Advance psychoacoustics: Tonality and TNS */
- if (psyStatic[0]->isLFE) {
- tnsData[0]->dataRaw.Long.subBlockInfo.tnsActive = 0;
- }
- else
- {
-
- for(ch = 0; ch < channels; ch++) {
- if (!isShortWindow[ch]) {
- /* tonality */
- FDKaacEnc_CalculateFullTonality( psyData[ch]->mdctSpectrum,
- pSfbMaxScaleSpec[ch],
- pSfbEnergyLdData[ch],
- sfbTonality[ch],
- psyData[ch]->sfbActive,
- hThisPsyConf[ch]->sfbOffset,
- hThisPsyConf[ch]->pnsConf.usePns);
- }
- }
-
- if (hPsyConfLong->tnsConf.tnsActive || hPsyConfShort->tnsConf.tnsActive) {
- INT tnsActive[TRANS_FAC];
- INT nrgScaling[2] = {0,0};
- INT tnsSpecShift = 0;
-
- for(ch = 0; ch < channels; ch++) {
- for(w = 0; w < nWindows[ch]; w++) {
-
- wOffset = w*windowLength[ch];
- /* TNS */
- FDKaacEnc_TnsDetect(
- tnsData[ch],
- &hThisPsyConf[ch]->tnsConf,
- &psyOutChannel[ch]->tnsInfo,
- hThisPsyConf[ch]->sfbCnt,
- psyData[ch]->mdctSpectrum+wOffset,
- w,
- psyStatic[ch]->blockSwitchingControl.lastWindowSequence
- );
- }
- }
-
- if (channels == 2) {
- FDKaacEnc_TnsSync(
- tnsData[1],
- tnsData[0],
- &psyOutChannel[1]->tnsInfo,
- &psyOutChannel[0]->tnsInfo,
-
- psyStatic[1]->blockSwitchingControl.lastWindowSequence,
- psyStatic[0]->blockSwitchingControl.lastWindowSequence,
- &hThisPsyConf[1]->tnsConf);
- }
-
- FDK_ASSERT(commonWindow==1); /* all checks for TNS do only work for common windows (which is always set)*/
- for(w = 0; w < nWindows[0]; w++)
- {
- if (isShortWindow[0])
- tnsActive[w] = tnsData[0]->dataRaw.Short.subBlockInfo[w].tnsActive ||
- ((channels == 2) ? tnsData[1]->dataRaw.Short.subBlockInfo[w].tnsActive : 0);
- else
- tnsActive[w] = tnsData[0]->dataRaw.Long.subBlockInfo.tnsActive ||
- ((channels == 2) ? tnsData[1]->dataRaw.Long.subBlockInfo.tnsActive : 0);
- }
-
- for(ch = 0; ch < channels; ch++) {
- if (tnsActive[0] && !isShortWindow[ch]) {
- /* Scale down spectrum if tns is active in one of the two channels with same lastWindowSequence */
- /* first part of threshold calculation; it's not necessary to update sfbMaxScaleSpec */
- INT shift = 1;
- for(sfb=0; sfb<hThisPsyConf[ch]->lowpassLine; sfb++) {
- psyData[ch]->mdctSpectrum[sfb] = psyData[ch]->mdctSpectrum[sfb] >> shift;
- }
-
- /* update thresholds */
- for (sfb=0; sfb<psyData[ch]->sfbActive; sfb++) {
- pSfbThreshold[ch][sfb] >>= (2*shift);
- }
-
- psyData[ch]->mdctScale += shift; /* update mdctScale */
-
- /* calc sfbEnergies after tnsEncode again ! */
-
- }
- }
-
- for(ch = 0; ch < channels; ch++) {
- for(w = 0; w < nWindows[ch]; w++)
- {
- wOffset = w*windowLength[ch];
- FDKaacEnc_TnsEncode(
- &psyOutChannel[ch]->tnsInfo,
- tnsData[ch],
- hThisPsyConf[ch]->sfbCnt,
- &hThisPsyConf[ch]->tnsConf,
- hThisPsyConf[ch]->sfbOffset[psyData[ch]->sfbActive],/*hThisPsyConf[ch]->lowpassLine*/ /* filter stops before that line ! */
- psyData[ch]->mdctSpectrum+wOffset,
- w,
- psyStatic[ch]->blockSwitchingControl.lastWindowSequence);
-
- if(tnsActive[w]) {
- /* Calc sfb-bandwise mdct-energies for left and right channel again, */
- /* if tns active in current channel or in one channel with same lastWindowSequence left and right */
- FDKaacEnc_CalcSfbMaxScaleSpec(psyData[ch]->mdctSpectrum+wOffset,
- hThisPsyConf[ch]->sfbOffset,
- pSfbMaxScaleSpec[ch]+w*maxSfb[ch],
- psyData[ch]->sfbActive);
- }
- }
- }
-
- for(ch = 0; ch < channels; ch++) {
- for(w = 0; w < nWindows[ch]; w++) {
-
- if (tnsActive[w]) {
-
- if (isShortWindow[ch]) {
- FDKaacEnc_CalcBandEnergyOptimShort(psyData[ch]->mdctSpectrum+w*windowLength[ch],
- pSfbMaxScaleSpec[ch]+w*maxSfb[ch],
- hThisPsyConf[ch]->sfbOffset,
- psyData[ch]->sfbActive,
- pSfbEnergy[ch]+w*maxSfb[ch]);
- }
- else {
- nrgScaling[ch] = /* with tns, energy calculation can overflow; -> scaling */
- FDKaacEnc_CalcBandEnergyOptimLong(psyData[ch]->mdctSpectrum,
- pSfbMaxScaleSpec[ch],
- hThisPsyConf[ch]->sfbOffset,
- psyData[ch]->sfbActive,
- pSfbEnergy[ch],
- pSfbEnergyLdData[ch]);
- tnsSpecShift = fixMax(tnsSpecShift, nrgScaling[ch]); /* nrgScaling is set only if nrg would have an overflow */
- }
- } /* if tnsActive */
- }
- } /* end channel loop */
-
- /* adapt scaling to prevent nrg overflow, only for long blocks */
- for(ch = 0; ch < channels; ch++) {
- if ( (tnsSpecShift!=0) && !isShortWindow[ch] ) {
- /* scale down spectrum, nrg's and thresholds, if there was an overflow in sfbNrg calculation after tns */
- for(line=0; line<hThisPsyConf[ch]->lowpassLine; line++) {
- psyData[ch]->mdctSpectrum[line] >>= tnsSpecShift;
- }
- INT scale = (tnsSpecShift-nrgScaling[ch])<<1;
- for(sfb=0; sfb<psyData[ch]->sfbActive; sfb++) {
- pSfbEnergyLdData[ch][sfb] -= scale*FL2FXCONST_DBL(1.0/LD_DATA_SCALING);
- pSfbEnergy[ch][sfb] >>= scale;
- pSfbThreshold[ch][sfb] >>= (tnsSpecShift<<1);
- }
- psyData[ch]->mdctScale += tnsSpecShift; /* update mdctScale; not necessary to update sfbMaxScaleSpec */
-
- }
- } /* end channel loop */
-
- } /* TNS active */
- } /* !isLFE */
-
-
-
-
-
-
- /* Advance thresholds */
- for(ch = 0; ch < channels; ch++) {
- INT headroom;
-
- FIXP_DBL clipEnergy;
- INT energyShift = psyData[ch]->mdctScale*2 ;
- INT clipNrgShift = energyShift - THR_SHIFTBITS ;
-
- if(isShortWindow[ch])
- headroom = 6;
- else
- headroom = 0;
-
- if (clipNrgShift >= 0)
- clipEnergy = hThisPsyConf[ch]->clipEnergy >> clipNrgShift ;
- else if (clipNrgShift>=-headroom)
- clipEnergy = hThisPsyConf[ch]->clipEnergy << -clipNrgShift ;
- else
- clipEnergy = (FIXP_DBL)MAXVAL_DBL ;
-
- for(w = 0; w < nWindows[ch]; w++)
- {
- INT i;
- /* limit threshold to avoid clipping */
- for (i=0; i<psyData[ch]->sfbActive; i++) {
- *(pSfbThreshold[ch]+w*maxSfb[ch]+i) = fixMin(*(pSfbThreshold[ch]+w*maxSfb[ch]+i), clipEnergy);
- }
-
- /* spreading */
- FDKaacEnc_SpreadingMax(psyData[ch]->sfbActive,
- hThisPsyConf[ch]->sfbMaskLowFactor,
- hThisPsyConf[ch]->sfbMaskHighFactor,
- pSfbThreshold[ch]+w*maxSfb[ch]);
-
-
- /* PCM quantization threshold */
- energyShift += PCM_QUANT_THR_SCALE;
- if (energyShift>=0) {
- energyShift = fixMin(DFRACT_BITS-1,energyShift);
- for (i=0; i<psyData[ch]->sfbActive;i++) {
- *(pSfbThreshold[ch]+w*maxSfb[ch]+i) = fixMax(*(pSfbThreshold[ch]+w*maxSfb[ch]+i) >> THR_SHIFTBITS,
- (hThisPsyConf[ch]->sfbPcmQuantThreshold[i] >> energyShift));
- }
- } else {
- energyShift = fixMin(DFRACT_BITS-1,-energyShift);
- for (i=0; i<psyData[ch]->sfbActive;i++) {
- *(pSfbThreshold[ch]+w*maxSfb[ch]+i) = fixMax(*(pSfbThreshold[ch]+w*maxSfb[ch]+i) >> THR_SHIFTBITS,
- (hThisPsyConf[ch]->sfbPcmQuantThreshold[i] << energyShift));
- }
- }
-
- if (!psyStatic[ch]->isLFE)
- {
- /* preecho control */
- if(psyStatic[ch]->blockSwitchingControl.lastWindowSequence == STOP_WINDOW) {
- /* prevent FDKaacEnc_PreEchoControl from comparing stop
- thresholds with short thresholds */
- for (i=0; i<psyData[ch]->sfbActive;i++) {
- psyStatic[ch]->sfbThresholdnm1[i] = (FIXP_DBL)MAXVAL_DBL;
- }
-
- psyStatic[ch]->mdctScalenm1 = 0;
- psyStatic[ch]->calcPreEcho = 0;
- }
-
- FDKaacEnc_PreEchoControl( psyStatic[ch]->sfbThresholdnm1,
- psyStatic[ch]->calcPreEcho,
- psyData[ch]->sfbActive,
- hThisPsyConf[ch]->maxAllowedIncreaseFactor,
- hThisPsyConf[ch]->minRemainingThresholdFactor,
- pSfbThreshold[ch]+w*maxSfb[ch],
- psyData[ch]->mdctScale,
- &psyStatic[ch]->mdctScalenm1);
-
- psyStatic[ch]->calcPreEcho = 1;
-
- if(psyStatic[ch]->blockSwitchingControl.lastWindowSequence == START_WINDOW)
- {
- /* prevent FDKaacEnc_PreEchoControl in next frame to compare start
- thresholds with short thresholds */
- for (i=0; i<psyData[ch]->sfbActive;i++) {
- psyStatic[ch]->sfbThresholdnm1[i] = (FIXP_DBL)MAXVAL_DBL;
- }
-
- psyStatic[ch]->mdctScalenm1 = 0;
- psyStatic[ch]->calcPreEcho = 0;
- }
-
- }
-
- /* spread energy to avoid hole detection */
- FDKmemcpy(pSfbSpreadEnergy[ch]+w*maxSfb[ch], pSfbEnergy[ch]+w*maxSfb[ch], psyData[ch]->sfbActive*sizeof(FIXP_DBL));
-
- FDKaacEnc_SpreadingMax(psyData[ch]->sfbActive,
- hThisPsyConf[ch]->sfbMaskLowFactorSprEn,
- hThisPsyConf[ch]->sfbMaskHighFactorSprEn,
- pSfbSpreadEnergy[ch]+w*maxSfb[ch]);
- }
- }
-
- /* Calc bandwise energies for mid and side channel. Do it only if 2 channels exist */
- if (channels==2) {
- for(w = 0; w < nWindows[1]; w++) {
- wOffset = w*windowLength[1];
- FDKaacEnc_CalcBandNrgMSOpt(psyData[0]->mdctSpectrum+wOffset,
- psyData[1]->mdctSpectrum+wOffset,
- pSfbMaxScaleSpec[0]+w*maxSfb[0],
- pSfbMaxScaleSpec[1]+w*maxSfb[1],
- hThisPsyConf[1]->sfbOffset,
- psyData[0]->sfbActive,
- pSfbEnergyMS[0]+w*maxSfb[0],
- pSfbEnergyMS[1]+w*maxSfb[1],
- (psyStatic[1]->blockSwitchingControl.lastWindowSequence != SHORT_WINDOW),
- psyData[0]->sfbEnergyMSLdData,
- psyData[1]->sfbEnergyMSLdData);
- }
- }
-
- /* group short data (maxSfb[ch] for short blocks is determined here) */
- for(ch=0;ch<channels;ch++)
- {
- INT noSfb, i;
- if(isShortWindow[ch])
- {
- int sfbGrp;
- noSfb = psyStatic[ch]->blockSwitchingControl.noOfGroups * hPsyConfShort->sfbCnt;
- /* At this point, energies and thresholds are copied/regrouped from the ".Short" to the ".Long" arrays */
- FDKaacEnc_groupShortData( psyData[ch]->mdctSpectrum,
- &psyData[ch]->sfbThreshold,
- &psyData[ch]->sfbEnergy,
- &psyData[ch]->sfbEnergyMS,
- &psyData[ch]->sfbSpreadEnergy,
- hPsyConfShort->sfbCnt,
- psyData[ch]->sfbActive,
- hPsyConfShort->sfbOffset,
- hPsyConfShort->sfbMinSnrLdData,
- psyData[ch]->groupedSfbOffset,
- &maxSfbPerGroup[ch],
- psyOutChannel[ch]->sfbMinSnrLdData,
- psyStatic[ch]->blockSwitchingControl.noOfGroups,
- psyStatic[ch]->blockSwitchingControl.groupLen,
- psyConf[1].granuleLength);
-
-
- /* calculate ldData arrays (short values are in .Long-arrays after FDKaacEnc_groupShortData) */
- for (sfbGrp = 0; sfbGrp < noSfb; sfbGrp += hPsyConfShort->sfbCnt) {
- LdDataVector(&psyData[ch]->sfbEnergy.Long[sfbGrp], &psyOutChannel[ch]->sfbEnergyLdData[sfbGrp], psyData[ch]->sfbActive);
- }
-
- /* calc sfbThrld and set Values smaller 2^-31 to 2^-33*/
- for (sfbGrp = 0; sfbGrp < noSfb; sfbGrp += hPsyConfShort->sfbCnt) {
- LdDataVector(&psyData[ch]->sfbThreshold.Long[sfbGrp], &psyOutChannel[ch]->sfbThresholdLdData[sfbGrp], psyData[ch]->sfbActive);
- for (sfb=0;sfb<psyData[ch]->sfbActive;sfb++) {
- psyOutChannel[ch]->sfbThresholdLdData[sfbGrp+sfb] =
- fixMax(psyOutChannel[ch]->sfbThresholdLdData[sfbGrp+sfb], FL2FXCONST_DBL(-0.515625f));
- }
- }
-
- if ( channels==2 ) {
- for (sfbGrp = 0; sfbGrp < noSfb; sfbGrp += hPsyConfShort->sfbCnt) {
- LdDataVector(&psyData[ch]->sfbEnergyMS.Long[sfbGrp], &psyData[ch]->sfbEnergyMSLdData[sfbGrp], psyData[ch]->sfbActive);
- }
- }
-
- FDKmemcpy(psyOutChannel[ch]->sfbOffsets, psyData[ch]->groupedSfbOffset, (MAX_GROUPED_SFB+1)*sizeof(INT));
-
- } else {
- /* maxSfb[ch] for long blocks */
- for (sfb = psyData[ch]->sfbActive-1; sfb >= 0; sfb--) {
- for (line = hPsyConfLong->sfbOffset[sfb+1]-1; line >= hPsyConfLong->sfbOffset[sfb]; line--) {
- if (psyData[ch]->mdctSpectrum[line] != FL2FXCONST_SGL(0.0f)) break;
- }
- if (line > hPsyConfLong->sfbOffset[sfb]) break;
- }
- maxSfbPerGroup[ch] = sfb + 1;
- /* ensure at least one section in ICS; workaround for existing decoder crc implementation */
- maxSfbPerGroup[ch] = fixMax(fixMin(5,psyData[ch]->sfbActive),maxSfbPerGroup[ch]);
-
- /* sfbNrgLdData is calculated in FDKaacEnc_advancePsychLong, copy in psyOut structure */
- FDKmemcpy(psyOutChannel[ch]->sfbEnergyLdData, psyData[ch]->sfbEnergyLdData.Long, psyData[ch]->sfbActive*sizeof(FIXP_DBL));
-
- FDKmemcpy(psyOutChannel[ch]->sfbOffsets, hPsyConfLong->sfbOffset, (MAX_GROUPED_SFB+1)*sizeof(INT));
-
- /* sfbMinSnrLdData modified in adjust threshold, copy necessary */
- FDKmemcpy(psyOutChannel[ch]->sfbMinSnrLdData, hPsyConfLong->sfbMinSnrLdData, psyData[ch]->sfbActive*sizeof(FIXP_DBL));
-
- /* sfbEnergyMSLdData ist already calculated in FDKaacEnc_CalcBandNrgMSOpt; only in long case */
-
- /* calc sfbThrld and set Values smaller 2^-31 to 2^-33*/
- LdDataVector(psyData[ch]->sfbThreshold.Long, psyOutChannel[ch]->sfbThresholdLdData, psyData[ch]->sfbActive);
- for (i=0;i<psyData[ch]->sfbActive;i++) {
- psyOutChannel[ch]->sfbThresholdLdData[i] =
- fixMax(psyOutChannel[ch]->sfbThresholdLdData[i], FL2FXCONST_DBL(-0.515625f));
- }
-
-
- }
-
-
- }
-
-
- /*
- Intensity parameter intialization.
- */
- for(ch=0;ch<channels;ch++) {
- FDKmemclear(psyOutChannel[ch]->isBook, MAX_GROUPED_SFB*sizeof(INT));
- FDKmemclear(psyOutChannel[ch]->isScale, MAX_GROUPED_SFB*sizeof(INT));
- }
-
- for(ch=0;ch<channels;ch++) {
- INT win = (isShortWindow[ch]?1:0);
- if (!psyStatic[ch]->isLFE)
- {
- /* PNS Decision */
- FDKaacEnc_PnsDetect( &(psyConf[0].pnsConf),
- pnsData[ch],
- psyStatic[ch]->blockSwitchingControl.lastWindowSequence,
- psyData[ch]->sfbActive,
- maxSfbPerGroup[ch], /* count of Sfb which are not zero. */
- psyOutChannel[ch]->sfbThresholdLdData,
- psyConf[win].sfbOffset,
- psyData[ch]->mdctSpectrum,
- psyData[ch]->sfbMaxScaleSpec.Long,
- sfbTonality[ch],
- psyOutChannel[ch]->tnsInfo.order[0][0],
- tnsData[ch]->dataRaw.Long.subBlockInfo.predictionGain,
- tnsData[ch]->dataRaw.Long.subBlockInfo.tnsActive,
- psyOutChannel[ch]->sfbEnergyLdData,
- psyOutChannel[ch]->noiseNrg );
- } /* !isLFE */
- }
-
- /*
- stereo Processing
- */
- if(channels == 2)
- {
- psyOutElement->toolsInfo.msDigest = MS_NONE;
- psyOutElement->commonWindow = commonWindow;
- if (psyOutElement->commonWindow)
- maxSfbPerGroup[0] = maxSfbPerGroup[1] =
- fixMax(maxSfbPerGroup[0], maxSfbPerGroup[1]);
-
- if(psyStatic[0]->blockSwitchingControl.lastWindowSequence != SHORT_WINDOW)
- {
- /* PNS preprocessing depending on ms processing: PNS not in Short Window! */
- FDKaacEnc_PreProcessPnsChannelPair(
- psyData[0]->sfbActive,
- (&psyData[0]->sfbEnergy)->Long,
- (&psyData[1]->sfbEnergy)->Long,
- psyOutChannel[0]->sfbEnergyLdData,
- psyOutChannel[1]->sfbEnergyLdData,
- psyData[0]->sfbEnergyMS.Long,
- &(psyConf[0].pnsConf),
- pnsData[0],
- pnsData[1]);
-
- FDKaacEnc_IntensityStereoProcessing(
- psyData[0]->sfbEnergy.Long,
- psyData[1]->sfbEnergy.Long,
- psyData[0]->mdctSpectrum,
- psyData[1]->mdctSpectrum,
- psyData[0]->sfbThreshold.Long,
- psyData[1]->sfbThreshold.Long,
- psyOutChannel[1]->sfbThresholdLdData,
- psyData[0]->sfbSpreadEnergy.Long,
- psyData[1]->sfbSpreadEnergy.Long,
- psyOutChannel[0]->sfbEnergyLdData,
- psyOutChannel[1]->sfbEnergyLdData,
- &psyOutElement->toolsInfo.msDigest,
- psyOutElement->toolsInfo.msMask,
- psyConf[0].sfbCnt,
- psyConf[0].sfbCnt,
- maxSfbPerGroup[0],
- psyConf[0].sfbOffset,
- psyConf[0].allowIS && commonWindow,
- psyOutChannel[1]->isBook,
- psyOutChannel[1]->isScale,
- pnsData);
-
- FDKaacEnc_MsStereoProcessing(
- psyData,
- psyOutChannel,
- psyOutChannel[1]->isBook,
- &psyOutElement->toolsInfo.msDigest,
- psyOutElement->toolsInfo.msMask,
- psyData[0]->sfbActive,
- psyData[0]->sfbActive,
- maxSfbPerGroup[0],
- psyOutChannel[0]->sfbOffsets);
-
- /* PNS postprocessing */
- FDKaacEnc_PostProcessPnsChannelPair(psyData[0]->sfbActive,
- &(psyConf[0].pnsConf),
- pnsData[0],
- pnsData[1],
- psyOutElement->toolsInfo.msMask,
- &psyOutElement->toolsInfo.msDigest);
-
- } else {
- FDKaacEnc_IntensityStereoProcessing(
- psyData[0]->sfbEnergy.Long,
- psyData[1]->sfbEnergy.Long,
- psyData[0]->mdctSpectrum,
- psyData[1]->mdctSpectrum,
- psyData[0]->sfbThreshold.Long,
- psyData[1]->sfbThreshold.Long,
- psyOutChannel[1]->sfbThresholdLdData,
- psyData[0]->sfbSpreadEnergy.Long,
- psyData[1]->sfbSpreadEnergy.Long,
- psyOutChannel[0]->sfbEnergyLdData,
- psyOutChannel[1]->sfbEnergyLdData,
- &psyOutElement->toolsInfo.msDigest,
- psyOutElement->toolsInfo.msMask,
- psyStatic[0]->blockSwitchingControl.noOfGroups*hPsyConfShort->sfbCnt,
- psyConf[1].sfbCnt,
- maxSfbPerGroup[0],
- psyData[0]->groupedSfbOffset,
- psyConf[0].allowIS && commonWindow,
- psyOutChannel[1]->isBook,
- psyOutChannel[1]->isScale,
- pnsData);
-
- /* it's OK to pass the ".Long" arrays here. They contain grouped short data since FDKaacEnc_groupShortData() */
- FDKaacEnc_MsStereoProcessing( psyData,
- psyOutChannel,
- psyOutChannel[1]->isBook,
- &psyOutElement->toolsInfo.msDigest,
- psyOutElement->toolsInfo.msMask,
- psyStatic[0]->blockSwitchingControl.noOfGroups*hPsyConfShort->sfbCnt,
- hPsyConfShort->sfbCnt,
- maxSfbPerGroup[0],
- psyOutChannel[0]->sfbOffsets);
- }
- }
-
- /*
- PNS Coding
- */
- for(ch=0;ch<channels;ch++) {
- if (psyStatic[ch]->isLFE) {
- /* no PNS coding */
- for(sfb = 0; sfb < psyData[ch]->sfbActive; sfb++) {
- psyOutChannel[ch]->noiseNrg[sfb] = NO_NOISE_PNS;
- }
- } else
- {
- FDKaacEnc_CodePnsChannel(psyData[ch]->sfbActive,
- &(psyConf[ch].pnsConf),
- pnsData[ch]->pnsFlag,
- psyData[ch]->sfbEnergyLdData.Long,
- psyOutChannel[ch]->noiseNrg, /* this is the energy that will be written to the bitstream */
- psyOutChannel[ch]->sfbThresholdLdData);
- }
- }
-
- /*
- build output
- */
- for(ch=0;ch<channels;ch++)
- {
- INT j, grp, mask;
-
- psyOutChannel[ch]->maxSfbPerGroup = maxSfbPerGroup[ch];
- psyOutChannel[ch]->mdctScale = psyData[ch]->mdctScale;
-
- if(isShortWindow[ch]==0) {
-
- psyOutChannel[ch]->sfbCnt = hPsyConfLong->sfbActive;
- psyOutChannel[ch]->sfbPerGroup = hPsyConfLong->sfbActive;
- psyOutChannel[ch]->lastWindowSequence = psyStatic[ch]->blockSwitchingControl.lastWindowSequence;
- psyOutChannel[ch]->windowShape = psyStatic[ch]->blockSwitchingControl.windowShape;
- }
- else {
- INT sfbCnt = psyStatic[ch]->blockSwitchingControl.noOfGroups*hPsyConfShort->sfbCnt;
-
- psyOutChannel[ch]->sfbCnt = sfbCnt;
- psyOutChannel[ch]->sfbPerGroup = hPsyConfShort->sfbCnt;
- psyOutChannel[ch]->lastWindowSequence = SHORT_WINDOW;
- psyOutChannel[ch]->windowShape = SINE_WINDOW;
- }
-
- /* generate grouping mask */
- mask = 0;
- for (grp = 0; grp < psyStatic[ch]->blockSwitchingControl.noOfGroups; grp++)
- {
- mask <<= 1;
- for (j=1; j<psyStatic[ch]->blockSwitchingControl.groupLen[grp]; j++) {
- mask = (mask<<1) | 1 ;
- }
- }
- psyOutChannel[ch]->groupingMask = mask;
-
- /* build interface */
- FDKmemcpy(psyOutChannel[ch]->groupLen,psyStatic[ch]->blockSwitchingControl.groupLen,MAX_NO_OF_GROUPS*sizeof(INT));
- FDKmemcpy(psyOutChannel[ch]->sfbEnergy,(&psyData[ch]->sfbEnergy)->Long, MAX_GROUPED_SFB*sizeof(FIXP_DBL));
- FDKmemcpy(psyOutChannel[ch]->sfbSpreadEnergy,(&psyData[ch]->sfbSpreadEnergy)->Long, MAX_GROUPED_SFB*sizeof(FIXP_DBL));
-// FDKmemcpy(psyOutChannel[ch]->mdctSpectrum, psyData[ch]->mdctSpectrum, (1024)*sizeof(FIXP_DBL));
- }
-
- return AAC_ENC_OK;
-}
-
-
-void FDKaacEnc_PsyClose(PSY_INTERNAL **phPsyInternal,
- PSY_OUT **phPsyOut)
-{
- int n, i;
-
-
- if(phPsyInternal!=NULL) {
- PSY_INTERNAL *hPsyInternal = *phPsyInternal;
-
- if (hPsyInternal)
- {
- for (i=0; i<(8); i++) {
- if (hPsyInternal->pStaticChannels[i]) {
- if (hPsyInternal->pStaticChannels[i]->psyInputBuffer)
- FreeRam_aacEnc_PsyInputBuffer(&hPsyInternal->pStaticChannels[i]->psyInputBuffer); /* AUDIO INPUT BUFFER */
-
- FreeRam_aacEnc_PsyStatic(&hPsyInternal->pStaticChannels[i]); /* PSY_STATIC */
- }
- }
-
- for (i=0; i<(8); i++) {
- if (hPsyInternal->psyElement[i])
- FreeRam_aacEnc_PsyElement(&hPsyInternal->psyElement[i]); /* PSY_ELEMENT */
- }
-
-
- FreeRam_aacEnc_PsyInternal(phPsyInternal);
- }
- }
-
- if (phPsyOut!=NULL) {
- for (n=0; n<(1); n++) {
- if (phPsyOut[n])
- {
- for (i=0; i<(8); i++) {
- if (phPsyOut[n]->pPsyOutChannels[i])
- FreeRam_aacEnc_PsyOutChannel(&phPsyOut[n]->pPsyOutChannels[i]); /* PSY_OUT_CHANNEL */
- }
-
- for (i=0; i<(8); i++) {
- if (phPsyOut[n]->psyOutElement[i])
- FreeRam_aacEnc_PsyOutElements(&phPsyOut[n]->psyOutElement[i]); /* PSY_OUT_ELEMENTS */
- }
-
- FreeRam_aacEnc_PsyOut(&phPsyOut[n]);
- }
- }
- }
-}
diff --git a/libAACenc/src/psy_main.h b/libAACenc/src/psy_main.h
deleted file mode 100644
index 7bdcc38..0000000
--- a/libAACenc/src/psy_main.h
+++ /dev/null
@@ -1,174 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M.Werner
- contents/description: Psychoaccoustic major function block
-
-******************************************************************************/
-
-#ifndef _PSYMAIN_H
-#define _PSYMAIN_H
-
-
-#include "psy_configuration.h"
-#include "qc_data.h"
-#include "aacenc_pns.h"
-
-/*
- psych internal
-*/
-typedef struct {
-
- PSY_STATIC* psyStatic[(2)];
-
-}PSY_ELEMENT;
-
-typedef struct {
-
- PSY_DATA psyData[(2)];
- TNS_DATA tnsData[(2)];
- PNS_DATA pnsData[(2)];
-
-}PSY_DYNAMIC;
-
-
-typedef struct {
-
- PSY_CONFIGURATION psyConf[2]; /* LONG / SHORT */
- PSY_ELEMENT* psyElement[(8)];
- PSY_STATIC* pStaticChannels[(8)];
- PSY_DYNAMIC* psyDynamic;
- INT granuleLength;
-
-}PSY_INTERNAL;
-
-
-AAC_ENCODER_ERROR FDKaacEnc_PsyNew(PSY_INTERNAL **phpsy,
- const INT nElements,
- const INT nChannels
- ,UCHAR *dynamic_RAM
- );
-
-AAC_ENCODER_ERROR FDKaacEnc_PsyOutNew(PSY_OUT **phpsyOut,
- const INT nElements,
- const INT nChannels,
- const INT nSubFrames
- ,UCHAR *dynamic_RAM
- );
-
-AAC_ENCODER_ERROR FDKaacEnc_psyInit(PSY_INTERNAL *hPsy,
- PSY_OUT **phpsyOut,
- const INT nSubFrames,
- const INT nMaxChannels,
- const AUDIO_OBJECT_TYPE audioObjectType,
- CHANNEL_MAPPING *cm);
-
-AAC_ENCODER_ERROR FDKaacEnc_psyMainInit(PSY_INTERNAL *hPsy,
- AUDIO_OBJECT_TYPE audioObjectType,
- CHANNEL_MAPPING *cm,
- INT sampleRate,
- INT granuleLength,
- INT bitRate,
- INT tnsMask,
- INT bandwidth,
- INT usePns,
- INT useIS,
- UINT syntaxFlags,
- ULONG initFlags);
-
-AAC_ENCODER_ERROR FDKaacEnc_psyMain(INT channels,
- PSY_ELEMENT *psyElement,
- PSY_DYNAMIC *psyDynamic,
- PSY_CONFIGURATION *psyConf,
- PSY_OUT_ELEMENT *psyOutElement,
- INT_PCM *pInput,
- INT *chIdx,
- INT totalChannels
- );
-
-void FDKaacEnc_PsyClose(PSY_INTERNAL **phPsyInternal,
- PSY_OUT **phPsyOut);
-
-#endif /* _PSYMAIN_H */
diff --git a/libAACenc/src/qc_data.h b/libAACenc/src/qc_data.h
deleted file mode 100644
index a9309c8..0000000
--- a/libAACenc/src/qc_data.h
+++ /dev/null
@@ -1,278 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M. Werner
- contents/description: Quantizing & coding data
-
-******************************************************************************/
-
-#ifndef _QC_DATA_H
-#define _QC_DATA_H
-
-
-#include "psy_const.h"
-#include "dyn_bits.h"
-#include "adj_thr_data.h"
-#include "line_pe.h"
-#include "FDK_audio.h"
-#include "interface.h"
-
-
-typedef enum {
- QCDATA_BR_MODE_INVALID = -1,
- QCDATA_BR_MODE_CBR = 0,
- QCDATA_BR_MODE_VBR_1 = 1, /* 32 kbps/channel */
- QCDATA_BR_MODE_VBR_2 = 2, /* 40 kbps/channel */
- QCDATA_BR_MODE_VBR_3 = 3, /* 48 kbps/channel */
- QCDATA_BR_MODE_VBR_4 = 4, /* 64 kbps/channel */
- QCDATA_BR_MODE_VBR_5 = 5, /* 96 kbps/channel */
- QCDATA_BR_MODE_FF = 6, /* Fixed frame mode. */
- QCDATA_BR_MODE_SFR = 7 /* Superframe mode. */
-
-
-} QCDATA_BR_MODE;
-
-typedef struct {
- MP4_ELEMENT_ID elType;
- INT instanceTag;
- INT nChannelsInEl;
- INT ChannelIndex[2];
- FIXP_DBL relativeBits;
-} ELEMENT_INFO;
-
-typedef struct {
- CHANNEL_MODE encMode;
- INT nChannels;
- INT nChannelsEff;
- INT nElements;
- ELEMENT_INFO elInfo[(8)];
-} CHANNEL_MAPPING;
-
-typedef struct {
- INT paddingRest;
-} PADDING;
-
-
-/* Quantizing & coding stage */
-
-struct QC_INIT{
- CHANNEL_MAPPING* channelMapping;
- INT sceCpe; /* not used yet */
- INT maxBits; /* maximum number of bits in reservoir */
- INT averageBits; /* average number of bits we should use */
- INT bitRes;
- INT sampleRate; /* output sample rate */
- INT advancedBitsToPe; /* if set, calc bits2PE factor depending on samplerate */
- INT staticBits; /* Bits per frame consumed by transport layers. */
- QCDATA_BR_MODE bitrateMode;
- INT meanPe;
- INT chBitrate;
- INT invQuant;
- INT maxIterations; /* Maximum number of allowed iterations before FDKaacEnc_crashRecovery() is applied. */
- FIXP_DBL maxBitFac;
- INT bitrate;
- INT nSubFrames; /* helper variable */
- INT minBits; /* minimal number of bits in one frame*/
-
- PADDING padding;
-};
-
-typedef struct
-{
- FIXP_DBL mdctSpectrum[(1024)];
-
- SHORT quantSpec[(1024)];
-
- UINT maxValueInSfb[MAX_GROUPED_SFB];
- INT scf[MAX_GROUPED_SFB];
- INT globalGain;
- SECTION_DATA sectionData;
-
- FIXP_DBL sfbFormFactorLdData[MAX_GROUPED_SFB];
-
- FIXP_DBL sfbThresholdLdData[MAX_GROUPED_SFB];
- FIXP_DBL sfbMinSnrLdData[MAX_GROUPED_SFB];
- FIXP_DBL sfbEnergyLdData[MAX_GROUPED_SFB];
- FIXP_DBL sfbEnergy[MAX_GROUPED_SFB];
- FIXP_DBL sfbWeightedEnergyLdData[MAX_GROUPED_SFB];
-
- FIXP_DBL sfbEnFacLd[MAX_GROUPED_SFB];
-
- FIXP_DBL sfbSpreadEnergy[MAX_GROUPED_SFB];
-
-} QC_OUT_CHANNEL;
-
-
-typedef struct
-{
- EXT_PAYLOAD_TYPE type; /* type of the extension payload */
- INT nPayloadBits; /* size of the payload */
- UCHAR *pPayload; /* pointer to payload */
-
-} QC_OUT_EXTENSION;
-
-
-typedef struct
-{
- INT staticBitsUsed; /* for verification purposes */
- INT dynBitsUsed; /* for verification purposes */
-
- INT extBitsUsed; /* bit consumption of extended fill elements */
- INT nExtensions; /* number of extension payloads for this element */
- QC_OUT_EXTENSION extension[(1)]; /* reffering extension payload */
-
- INT grantedDynBits;
-
- INT grantedPe;
- INT grantedPeCorr;
-
- PE_DATA peData;
-
- QC_OUT_CHANNEL *qcOutChannel[(2)];
-
-
-} QC_OUT_ELEMENT;
-
-typedef struct
-{
- QC_OUT_ELEMENT *qcElement[(8)];
- QC_OUT_CHANNEL *pQcOutChannels[(8)];
- QC_OUT_EXTENSION extension[(2+2)]; /* global extension payload */
- INT nExtensions; /* number of extension payloads for this AU */
- INT maxDynBits; /* maximal allowed dynamic bits in frame */
- INT grantedDynBits; /* granted dynamic bits in frame */
- INT totFillBits; /* fill bits */
- INT elementExtBits; /* element associated extension payload bits, e.g. sbr, drc ... */
- INT globalExtBits; /* frame/au associated extension payload bits (anc data ...) */
- INT staticBits; /* aac side info bits */
-
- INT totalNoRedPe;
- INT totalGrantedPeCorr;
-
- INT usedDynBits; /* number of dynamic bits in use */
- INT alignBits; /* AU alignment bits */
- INT totalBits; /* sum of static, dyn, sbr, fill, align and dse bits */
-
-} QC_OUT;
-
-typedef struct {
- INT chBitrateEl; /* channel bitrate in element (totalbitrate*el_relativeBits/el_channels) */
- INT maxBitsEl; /* used in crash recovery */
- INT bitResLevelEl; /* update bitreservoir level in each call of FDKaacEnc_QCMain */
- INT maxBitResBitsEl; /* nEffChannels*6144 - averageBitsInFrame */
- FIXP_DBL relativeBitsEl; /* Bits relative to total Bits*/
-} ELEMENT_BITS;
-
-typedef struct
-{
- /* this is basically struct QC_INIT */
-
- INT globHdrBits;
- INT maxBitsPerFrame; /* maximal allowed bits per frame, 6144*nChannelsEff */
- INT minBitsPerFrame; /* minimal allowd bits per fram, superframing - DRM */
- INT nElements;
- QCDATA_BR_MODE bitrateMode;
- INT bitDistributionMode; /* 0: full bitreservoir, 1: reduced bitreservoir, 2: disabled bitreservoir */
- INT bitResTot;
- INT bitResTotMax;
- INT maxIterations; /* Maximum number of allowed iterations before FDKaacEnc_crashRecovery() is applied. */
- INT invQuant;
-
- FIXP_DBL vbrQualFactor;
- FIXP_DBL maxBitFac;
-
- PADDING padding;
-
- ELEMENT_BITS *elementBits[(8)];
- BITCNTR_STATE *hBitCounter;
- ADJ_THR_STATE *hAdjThr;
-
-} QC_STATE;
-
-#endif /* _QC_DATA_H */
-
-
-
-
diff --git a/libAACenc/src/qc_main.cpp b/libAACenc/src/qc_main.cpp
deleted file mode 100644
index 9866a3a..0000000
--- a/libAACenc/src/qc_main.cpp
+++ /dev/null
@@ -1,1644 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M. Werner
- contents/description: Quantizing & coding
-
-******************************************************************************/
-#include <stdio.h>
-#include "qc_main.h"
-#include "quantize.h"
-#include "interface.h"
-#include "adj_thr.h"
-#include "sf_estim.h"
-#include "bit_cnt.h"
-#include "dyn_bits.h"
-#include "channel_map.h"
-#include "aacEnc_ram.h"
-
-#include "genericStds.h"
-
-
-typedef struct {
- QCDATA_BR_MODE bitrateMode;
- LONG vbrQualFactor;
-} TAB_VBR_QUAL_FACTOR;
-
-static const TAB_VBR_QUAL_FACTOR tableVbrQualFactor[] = {
- {QCDATA_BR_MODE_CBR, FL2FXCONST_DBL(0.00f)},
- {QCDATA_BR_MODE_VBR_1, FL2FXCONST_DBL(0.160f)}, /* 32 kbps mono AAC-LC + SBR + PS */
- {QCDATA_BR_MODE_VBR_2, FL2FXCONST_DBL(0.148f)}, /* 64 kbps stereo AAC-LC + SBR */
- {QCDATA_BR_MODE_VBR_3, FL2FXCONST_DBL(0.135f)}, /* 80 - 96 kbps stereo AAC-LC */
- {QCDATA_BR_MODE_VBR_4, FL2FXCONST_DBL(0.111f)}, /* 128 kbps stereo AAC-LC */
- {QCDATA_BR_MODE_VBR_5, FL2FXCONST_DBL(0.070f)}, /* 192 kbps stereo AAC-LC */
- {QCDATA_BR_MODE_SFR, FL2FXCONST_DBL(0.00f)},
- {QCDATA_BR_MODE_FF, FL2FXCONST_DBL(0.00f)}
-};
-
-static INT isConstantBitrateMode(
- const QCDATA_BR_MODE bitrateMode
- )
-{
- return ( ((bitrateMode==QCDATA_BR_MODE_CBR) || (bitrateMode==QCDATA_BR_MODE_SFR) || (bitrateMode==QCDATA_BR_MODE_FF)) ? 1 : 0 );
-}
-
-
-
-typedef enum{
- FRAME_LEN_BYTES_MODULO = 1,
- FRAME_LEN_BYTES_INT = 2
-}FRAME_LEN_RESULT_MODE;
-
-/* forward declarations */
-
-static INT FDKaacEnc_calcMaxValueInSfb(INT sfbCnt,
- INT maxSfbPerGroup,
- INT sfbPerGroup,
- INT *RESTRICT sfbOffset,
- SHORT *RESTRICT quantSpectrum,
- UINT *RESTRICT maxValue);
-
-static void FDKaacEnc_crashRecovery(INT nChannels,
- PSY_OUT_ELEMENT* psyOutElement,
- QC_OUT* qcOut,
- QC_OUT_ELEMENT *qcElement,
- INT bitsToSave,
- AUDIO_OBJECT_TYPE aot,
- UINT syntaxFlags,
- SCHAR epConfig);
-
-static
-AAC_ENCODER_ERROR FDKaacEnc_reduceBitConsumption(int* iterations,
- const int maxIterations,
- int gainAdjustment,
- int* chConstraintsFulfilled,
- int* calculateQuant,
- int nChannels,
- PSY_OUT_ELEMENT* psyOutElement,
- QC_OUT* qcOut,
- QC_OUT_ELEMENT* qcOutElement,
- ELEMENT_BITS* elBits,
- AUDIO_OBJECT_TYPE aot,
- UINT syntaxFlags,
- SCHAR epConfig);
-
-
-void FDKaacEnc_QCClose (QC_STATE **phQCstate, QC_OUT **phQC);
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_calcFrameLen
- description:
- returns:
- input:
- output:
-
-*****************************************************************************/
-static INT FDKaacEnc_calcFrameLen(INT bitRate,
- INT sampleRate,
- INT granuleLength,
- FRAME_LEN_RESULT_MODE mode)
-{
-
- INT result;
-
- result = ((granuleLength)>>3)*(bitRate);
-
- switch(mode) {
- case FRAME_LEN_BYTES_MODULO:
- result %= sampleRate;
- break;
- case FRAME_LEN_BYTES_INT:
- result /= sampleRate;
- break;
- }
- return(result);
-}
-
-/*****************************************************************************
-
- functionname:FDKaacEnc_framePadding
- description: Calculates if padding is needed for actual frame
- returns:
- input:
- output:
-
-*****************************************************************************/
-static INT FDKaacEnc_framePadding(INT bitRate,
- INT sampleRate,
- INT granuleLength,
- INT *paddingRest)
-{
- INT paddingOn;
- INT difference;
-
- paddingOn = 0;
-
- difference = FDKaacEnc_calcFrameLen( bitRate,
- sampleRate,
- granuleLength,
- FRAME_LEN_BYTES_MODULO );
- *paddingRest-=difference;
-
- if (*paddingRest <= 0 ) {
- paddingOn = 1;
- *paddingRest += sampleRate;
- }
-
- return( paddingOn );
-}
-
-
-/*********************************************************************************
-
- functionname: FDKaacEnc_QCOutNew
- description:
- return:
-
-**********************************************************************************/
-AAC_ENCODER_ERROR FDKaacEnc_QCOutNew(QC_OUT **phQC,
- const INT nElements,
- const INT nChannels,
- const INT nSubFrames
- ,UCHAR *dynamic_RAM
- )
-{
- AAC_ENCODER_ERROR ErrorStatus;
- int n, i;
- int elInc = 0, chInc = 0;
-
- for (n=0; n<nSubFrames; n++) {
- phQC[n] = GetRam_aacEnc_QCout(n);
- if (phQC[n] == NULL) {
- ErrorStatus = AAC_ENC_NO_MEMORY;
- goto QCOutNew_bail;
- }
-
- for (i=0; i<nChannels; i++) {
- phQC[n]->pQcOutChannels[i] = GetRam_aacEnc_QCchannel(chInc, dynamic_RAM);
- if ( phQC[n]->pQcOutChannels[i] == NULL
- )
- {
- ErrorStatus = AAC_ENC_NO_MEMORY;
- goto QCOutNew_bail;
- }
- chInc++;
- } /* nChannels */
-
- for (i=0; i<nElements; i++) {
- phQC[n]->qcElement[i] = GetRam_aacEnc_QCelement(elInc);
- if (phQC[n]->qcElement[i] == NULL)
- {
- ErrorStatus = AAC_ENC_NO_MEMORY;
- goto QCOutNew_bail;
- }
- elInc++;
- } /* nElements */
-
- } /* nSubFrames */
-
-
- return AAC_ENC_OK;
-
-QCOutNew_bail:
- return ErrorStatus;
-}
-
-/*********************************************************************************
-
- functionname: FDKaacEnc_QCOutInit
- description:
- return:
-
-**********************************************************************************/
-AAC_ENCODER_ERROR FDKaacEnc_QCOutInit(QC_OUT *phQC[(1)],
- const INT nSubFrames,
- const CHANNEL_MAPPING *cm)
-{
- INT n,i,ch;
-
- for (n=0; n<nSubFrames; n++) {
- INT chInc = 0;
- for (i=0; i<cm->nElements; i++) {
- for (ch=0; ch<cm->elInfo[i].nChannelsInEl; ch++) {
- phQC[n]->qcElement[i]->qcOutChannel[ch] = phQC[n]->pQcOutChannels[chInc];
- chInc++;
- } /* chInEl */
- } /* nElements */
- } /* nSubFrames */
-
- return AAC_ENC_OK;
-}
-
-/*********************************************************************************
-
- functionname: FDKaacEnc_QCNew
- description:
- return:
-
-**********************************************************************************/
-AAC_ENCODER_ERROR FDKaacEnc_QCNew(QC_STATE **phQC,
- INT nElements
- ,UCHAR* dynamic_RAM
- )
-{
- AAC_ENCODER_ERROR ErrorStatus;
- int i;
-
- QC_STATE* hQC = GetRam_aacEnc_QCstate();
- *phQC = hQC;
- if (hQC == NULL) {
- ErrorStatus = AAC_ENC_NO_MEMORY;
- goto QCNew_bail;
- }
-
- if (FDKaacEnc_AdjThrNew(&hQC->hAdjThr, nElements)) {
- ErrorStatus = AAC_ENC_NO_MEMORY;
- goto QCNew_bail;
- }
-
- if (FDKaacEnc_BCNew(&(hQC->hBitCounter), dynamic_RAM)) {
- ErrorStatus = AAC_ENC_NO_MEMORY;
- goto QCNew_bail;
- }
-
- for (i=0; i<nElements; i++) {
- hQC->elementBits[i] = GetRam_aacEnc_ElementBits(i);
- if (hQC->elementBits[i] == NULL) {
- ErrorStatus = AAC_ENC_NO_MEMORY;
- goto QCNew_bail;
- }
- }
-
- return AAC_ENC_OK;
-
-QCNew_bail:
- FDKaacEnc_QCClose(phQC, NULL);
- return ErrorStatus;
-}
-
-/*********************************************************************************
-
- functionname: FDKaacEnc_QCInit
- description:
- return:
-
-**********************************************************************************/
-AAC_ENCODER_ERROR FDKaacEnc_QCInit(QC_STATE *hQC,
- struct QC_INIT *init)
-{
- hQC->maxBitsPerFrame = init->maxBits;
- hQC->minBitsPerFrame = init->minBits;
- hQC->nElements = init->channelMapping->nElements;
- hQC->bitResTotMax = init->bitRes;
- hQC->bitResTot = init->bitRes;
- hQC->maxBitFac = init->maxBitFac;
- hQC->bitrateMode = init->bitrateMode;
- hQC->invQuant = init->invQuant;
- hQC->maxIterations = init->maxIterations;
-
- if ( isConstantBitrateMode(hQC->bitrateMode) ) {
- INT bitresPerChannel = (hQC->bitResTotMax / init->channelMapping->nChannelsEff);
- /* 0: full bitreservoir, 1: reduced bitreservoir, 2: disabled bitreservoir */
- hQC->bitDistributionMode = (bitresPerChannel>100) ? 0 : (bitresPerChannel>0) ? 1 : 2;
- }
- else {
- hQC->bitDistributionMode = 0; /* full bitreservoir */
- }
-
-
- hQC->padding.paddingRest = init->padding.paddingRest;
-
- hQC->globHdrBits = init->staticBits; /* Bit overhead due to transport */
-
- FDKaacEnc_InitElementBits(hQC,
- init->channelMapping,
- init->bitrate,
- (init->averageBits/init->nSubFrames) - hQC->globHdrBits,
- hQC->maxBitsPerFrame/init->channelMapping->nChannelsEff);
-
- switch(hQC->bitrateMode){
- case QCDATA_BR_MODE_CBR:
- case QCDATA_BR_MODE_VBR_1:
- case QCDATA_BR_MODE_VBR_2:
- case QCDATA_BR_MODE_VBR_3:
- case QCDATA_BR_MODE_VBR_4:
- case QCDATA_BR_MODE_VBR_5:
- case QCDATA_BR_MODE_SFR:
- case QCDATA_BR_MODE_FF:
- if((int)hQC->bitrateMode < (int)(sizeof(tableVbrQualFactor)/sizeof(TAB_VBR_QUAL_FACTOR))){
- hQC->vbrQualFactor = (FIXP_DBL)tableVbrQualFactor[hQC->bitrateMode].vbrQualFactor;
- } else {
- hQC->vbrQualFactor = FL2FXCONST_DBL(0.f); /* default setting */
- }
- break;
- case QCDATA_BR_MODE_INVALID:
- default:
- hQC->vbrQualFactor = FL2FXCONST_DBL(0.f);
- break;
- }
-
- FDKaacEnc_AdjThrInit(
- hQC->hAdjThr,
- init->meanPe,
- hQC->elementBits, /* or channelBitrates, was: channelBitrate */
- hQC->invQuant,
- init->channelMapping->nElements,
- init->channelMapping->nChannelsEff,
- init->sampleRate, /* output sample rate */
- init->advancedBitsToPe, /* if set, calc bits2PE factor depending on samplerate */
- hQC->vbrQualFactor
- );
-
- return AAC_ENC_OK;
-}
-
-
-
-/*********************************************************************************
-
- functionname: FDKaacEnc_QCMainPrepare
- description:
- return:
-
-**********************************************************************************/
-AAC_ENCODER_ERROR FDKaacEnc_QCMainPrepare(ELEMENT_INFO *elInfo,
- ATS_ELEMENT* RESTRICT adjThrStateElement,
- PSY_OUT_ELEMENT* RESTRICT psyOutElement,
- QC_OUT_ELEMENT* RESTRICT qcOutElement,
- AUDIO_OBJECT_TYPE aot,
- UINT syntaxFlags,
- SCHAR epConfig
- )
-{
- AAC_ENCODER_ERROR ErrorStatus = AAC_ENC_OK;
- INT nChannels = elInfo->nChannelsInEl;
-
- PSY_OUT_CHANNEL** RESTRICT psyOutChannel = psyOutElement->psyOutChannel; /* may be modified in-place */
-
- FDKaacEnc_CalcFormFactor(qcOutElement->qcOutChannel, psyOutChannel, nChannels);
-
- /* prepare and calculate PE without reduction */
- FDKaacEnc_peCalculation(&qcOutElement->peData, psyOutChannel, qcOutElement->qcOutChannel, &psyOutElement->toolsInfo, adjThrStateElement, nChannels);
-
- ErrorStatus = FDKaacEnc_ChannelElementWrite( NULL, elInfo, NULL,
- psyOutElement,
- psyOutElement->psyOutChannel,
- syntaxFlags,
- aot,
- epConfig,
- &qcOutElement->staticBitsUsed,
- 0 );
-
- return ErrorStatus;
-}
-
-/*********************************************************************************
-
- functionname: FDKaacEnc_AdjustBitrate
- description: adjusts framelength via padding on a frame to frame basis,
- to achieve a bitrate that demands a non byte aligned
- framelength
- return: errorcode
-
-**********************************************************************************/
-AAC_ENCODER_ERROR FDKaacEnc_AdjustBitrate(QC_STATE *RESTRICT hQC,
- CHANNEL_MAPPING *RESTRICT cm,
- INT *avgTotalBits,
- INT bitRate, /* total bitrate */
- INT sampleRate, /* output sampling rate */
- INT granuleLength) /* frame length */
-{
- INT paddingOn=0;
- INT frameLen;
- //fprintf(stderr, "hQC->padding.paddingRest=%d bytes! (before)\n", hQC->padding.paddingRest);
-
- /* Do we need an extra padding byte? */
- paddingOn = FDKaacEnc_framePadding(bitRate,
- sampleRate,
- granuleLength,
- &hQC->padding.paddingRest);
- //fprintf(stderr, "hQC->padding.paddingRest=%d bytes! (after)\n", hQC->padding.paddingRest);
-
- frameLen = paddingOn + FDKaacEnc_calcFrameLen(bitRate,
- sampleRate,
- granuleLength,
- FRAME_LEN_BYTES_INT);
-
- //fprintf(stderr, "frameLen=%d bytes!\n", frameLen);
-
- *avgTotalBits = frameLen<<3;
-
- return AAC_ENC_OK;
-}
-
-static AAC_ENCODER_ERROR FDKaacEnc_distributeElementDynBits(QC_STATE* hQC,
- QC_OUT_ELEMENT* qcElement[(8)],
- CHANNEL_MAPPING* cm,
- INT codeBits)
-{
-
- INT i, firstEl = cm->nElements-1;
- INT totalBits = 0;
-
- for (i=(cm->nElements-1); i>=0; i--) {
- if ((cm->elInfo[i].elType == ID_SCE) || (cm->elInfo[i].elType == ID_CPE) ||
- (cm->elInfo[i].elType == ID_LFE))
- {
- qcElement[i]->grantedDynBits = (INT)fMult(hQC->elementBits[i]->relativeBitsEl, (FIXP_DBL)codeBits);
- totalBits += qcElement[i]->grantedDynBits;
- firstEl = i;
- }
- }
- qcElement[firstEl]->grantedDynBits += codeBits - totalBits;
-
- return AAC_ENC_OK;
-}
-
-/**
- * \brief Verify whether minBitsPerFrame criterion can be satisfied.
- *
- * This function evaluates the bit consumption only if minBitsPerFrame parameter is not 0.
- * In hyperframing mode the difference between grantedDynBits and usedDynBits of all sub frames
- * results the number of fillbits to be written.
- * This bits can be distrubitued in superframe to reach minBitsPerFrame bit consumption in single AU's.
- * The return value denotes if enough desired fill bits are available to achieve minBitsPerFrame in all frames.
- * This check can only be used within superframes.
- *
- * \param qcOut Pointer to coding data struct.
- * \param minBitsPerFrame Minimal number of bits to be consumed in each frame.
- * \param nSubFrames Number of frames in superframe
- *
- * \return
- * - 1: all fine
- * - 0: criterion not fulfilled
- */
-static int checkMinFrameBitsDemand(
- QC_OUT** qcOut,
- const INT minBitsPerFrame,
- const INT nSubFrames
- )
-{
- int result = 1; /* all fine*/
- return result;
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/*********************************************************************************
-
- functionname: FDKaacEnc_getMinimalStaticBitdemand
- description: calculate minmal size of static bits by reduction ,
- to zero spectrum and deactivating tns and MS
- return: number of static bits
-
-**********************************************************************************/
-static int FDKaacEnc_getMinimalStaticBitdemand(CHANNEL_MAPPING* cm,
- PSY_OUT** psyOut)
-{
- AUDIO_OBJECT_TYPE aot = AOT_AAC_LC;
- UINT syntaxFlags = 0;
- SCHAR epConfig = -1;
- int i, bitcount = 0;
-
- for (i=0; i<cm->nElements; i++) {
- ELEMENT_INFO elInfo = cm->elInfo[i];
-
- if ( (elInfo.elType == ID_SCE)
- || (elInfo.elType == ID_CPE)
- || (elInfo.elType == ID_LFE) )
- {
- INT minElBits = 0;
-
- FDKaacEnc_ChannelElementWrite( NULL, &elInfo, NULL,
- psyOut[0]->psyOutElement[i],
- psyOut[0]->psyOutElement[i]->psyOutChannel,
- syntaxFlags,
- aot,
- epConfig,
- &minElBits,
- 1 );
- bitcount += minElBits;
- }
- }
-
- return bitcount;
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-static AAC_ENCODER_ERROR FDKaacEnc_prepareBitDistribution(QC_STATE* hQC,
- PSY_OUT** psyOut,
- QC_OUT** qcOut,
- CHANNEL_MAPPING* cm,
- QC_OUT_ELEMENT* qcElement[(1)][(8)],
- INT avgTotalBits,
- INT *totalAvailableBits,
- INT *avgTotalDynBits)
-{
- int i;
- /* get maximal allowed dynamic bits */
- qcOut[0]->grantedDynBits = (fixMin(hQC->maxBitsPerFrame, avgTotalBits) - hQC->globHdrBits)&~7;
- qcOut[0]->grantedDynBits -= (qcOut[0]->globalExtBits + qcOut[0]->staticBits + qcOut[0]->elementExtBits);
- qcOut[0]->maxDynBits = ((hQC->maxBitsPerFrame)&~7) - (qcOut[0]->globalExtBits + qcOut[0]->staticBits + qcOut[0]->elementExtBits);
- /* assure that enough bits are available */
- if ((qcOut[0]->grantedDynBits+hQC->bitResTot) < 0) {
- /* crash recovery allows to reduce static bits to a minimum */
- if ( (qcOut[0]->grantedDynBits+hQC->bitResTot) < (FDKaacEnc_getMinimalStaticBitdemand(cm, psyOut)-qcOut[0]->staticBits) )
- return AAC_ENC_BITRES_TOO_LOW;
- }
-
- /* distribute dynamic bits to each element */
- FDKaacEnc_distributeElementDynBits(hQC,
- qcElement[0],
- cm,
- qcOut[0]->grantedDynBits);
-
- *avgTotalDynBits = 0; /*frameDynBits;*/
-
- *totalAvailableBits = avgTotalBits;
-
- /* sum up corrected granted PE */
- qcOut[0]->totalGrantedPeCorr = 0;
-
- for (i=0; i<cm->nElements; i++)
- {
- ELEMENT_INFO elInfo = cm->elInfo[i];
- int nChannels = elInfo.nChannelsInEl;
-
- if ((elInfo.elType == ID_SCE) || (elInfo.elType == ID_CPE) ||
- (elInfo.elType == ID_LFE))
- {
- /* for ( all sub frames ) ... */
- FDKaacEnc_DistributeBits(hQC->hAdjThr,
- hQC->hAdjThr->adjThrStateElem[i],
- psyOut[0]->psyOutElement[i]->psyOutChannel,
- &qcElement[0][i]->peData,
- &qcElement[0][i]->grantedPe,
- &qcElement[0][i]->grantedPeCorr,
- nChannels,
- psyOut[0]->psyOutElement[i]->commonWindow,
- qcElement[0][i]->grantedDynBits,
- hQC->elementBits[i]->bitResLevelEl,
- hQC->elementBits[i]->maxBitResBitsEl,
- hQC->maxBitFac,
- hQC->bitDistributionMode);
-
- *totalAvailableBits += hQC->elementBits[i]->bitResLevelEl;
- /* get total corrected granted PE */
- qcOut[0]->totalGrantedPeCorr += qcElement[0][i]->grantedPeCorr;
- } /* -end- if(ID_SCE || ID_CPE || ID_LFE) */
-
- } /* -end- element loop */
-
- *totalAvailableBits = FDKmin(hQC->maxBitsPerFrame, (*totalAvailableBits));
-
- return AAC_ENC_OK;
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-static AAC_ENCODER_ERROR FDKaacEnc_updateUsedDynBits(INT* sumDynBitsConsumed,
- QC_OUT_ELEMENT* qcElement[(8)],
- CHANNEL_MAPPING* cm)
-{
- INT i;
-
- *sumDynBitsConsumed = 0;
-
- for (i=0; i<cm->nElements; i++)
- {
- ELEMENT_INFO elInfo = cm->elInfo[i];
-
- if ((elInfo.elType == ID_SCE) || (elInfo.elType == ID_CPE) ||
- (elInfo.elType == ID_LFE))
- {
- /* sum up bits consumed */
- *sumDynBitsConsumed += qcElement[i]->dynBitsUsed;
- } /* -end- if(ID_SCE || ID_CPE || ID_LFE) */
-
- } /* -end- element loop */
-
- return AAC_ENC_OK;
-}
-
-
-static INT FDKaacEnc_getTotalConsumedDynBits(QC_OUT** qcOut,
- INT nSubFrames)
-{
- INT c, totalBits=0;
-
- /* sum up bit consumption for all sub frames */
- for (c=0; c<nSubFrames; c++)
- {
- /* bit consumption not valid if dynamic bits
- not available in one sub frame */
- if (qcOut[c]->usedDynBits==-1) return -1;
- totalBits += qcOut[c]->usedDynBits;
- }
-
- return totalBits;
-
-}
-
-static INT FDKaacEnc_getTotalConsumedBits(QC_OUT** qcOut,
- QC_OUT_ELEMENT* qcElement[(1)][(8)],
- CHANNEL_MAPPING* cm,
- INT globHdrBits,
- INT nSubFrames)
-{
- int c, i;
- int totalUsedBits = 0;
-
- for (c = 0 ; c < nSubFrames ; c++ )
- {
- int dataBits = 0;
- for (i=0; i<cm->nElements; i++)
- {
- if ((cm->elInfo[i].elType == ID_SCE) || (cm->elInfo[i].elType == ID_CPE) ||
- (cm->elInfo[i].elType == ID_LFE))
- {
- dataBits += qcElement[c][i]->dynBitsUsed + qcElement[c][i]->staticBitsUsed + qcElement[c][i]->extBitsUsed;
- }
- }
- dataBits += qcOut[c]->globalExtBits;
-
- totalUsedBits += (8 - (dataBits) % 8) % 8;
- totalUsedBits += dataBits + globHdrBits; /* header bits for every frame */
- }
- return totalUsedBits;
-}
-
-static AAC_ENCODER_ERROR FDKaacEnc_BitResRedistribution(
- QC_STATE *const hQC,
- const CHANNEL_MAPPING *const cm,
- const INT avgTotalBits
- )
-{
- /* check bitreservoir fill level */
- if (hQC->bitResTot < 0) {
- return AAC_ENC_BITRES_TOO_LOW;
- }
- else if (hQC->bitResTot > hQC->bitResTotMax) {
- return AAC_ENC_BITRES_TOO_HIGH;
- }
- else {
- INT i, firstEl = cm->nElements-1;
- INT totalBits = 0, totalBits_max = 0;
-
- int totalBitreservoir = FDKmin(hQC->bitResTot, (hQC->maxBitsPerFrame-avgTotalBits));
- int totalBitreservoirMax = FDKmin(hQC->bitResTotMax, (hQC->maxBitsPerFrame-avgTotalBits));
-
- int sc_bitResTot = CountLeadingBits(totalBitreservoir);
- int sc_bitResTotMax = CountLeadingBits(totalBitreservoirMax);
-
- for (i=(cm->nElements-1); i>=0; i--) {
- if ((cm->elInfo[i].elType == ID_SCE) || (cm->elInfo[i].elType == ID_CPE) ||
- (cm->elInfo[i].elType == ID_LFE))
- {
- hQC->elementBits[i]->bitResLevelEl = (INT)fMult(hQC->elementBits[i]->relativeBitsEl, (FIXP_DBL)(totalBitreservoir<<sc_bitResTot))>>sc_bitResTot;
- totalBits += hQC->elementBits[i]->bitResLevelEl;
-
- hQC->elementBits[i]->maxBitResBitsEl = (INT)fMult(hQC->elementBits[i]->relativeBitsEl, (FIXP_DBL)(totalBitreservoirMax<<sc_bitResTotMax))>>sc_bitResTotMax;
- totalBits_max += hQC->elementBits[i]->maxBitResBitsEl;
-
- firstEl = i;
- }
- }
- hQC->elementBits[firstEl]->bitResLevelEl += totalBitreservoir - totalBits;
- hQC->elementBits[firstEl]->maxBitResBitsEl += totalBitreservoirMax - totalBits_max;
- }
-
- return AAC_ENC_OK;
-}
-
-
-AAC_ENCODER_ERROR FDKaacEnc_QCMain(QC_STATE* RESTRICT hQC,
- PSY_OUT** psyOut,
- QC_OUT** qcOut,
- INT avgTotalBits,
- CHANNEL_MAPPING* cm
- ,AUDIO_OBJECT_TYPE aot,
- UINT syntaxFlags,
- SCHAR epConfig
- )
-{
- int i, c;
- AAC_ENCODER_ERROR ErrorStatus = AAC_ENC_OK;
- INT avgTotalDynBits = 0; /* maximal allowed dynamic bits for all frames */
- INT totalAvailableBits = 0;
- INT nSubFrames = 1;
-
- /*-------------------------------------------- */
- /* redistribute total bitreservoir to elements */
- ErrorStatus = FDKaacEnc_BitResRedistribution(hQC, cm, avgTotalBits);
- if (ErrorStatus != AAC_ENC_OK) {
- return ErrorStatus;
- }
-
- /*-------------------------------------------- */
- /* fastenc needs one time threshold simulation,
- in case of multiple frames, one more guess has to be calculated */
-
- /*-------------------------------------------- */
- /* helper pointer */
- QC_OUT_ELEMENT* qcElement[(1)][(8)];
-
- /* work on a copy of qcChannel and qcElement */
- for (i=0; i<cm->nElements; i++)
- {
- ELEMENT_INFO elInfo = cm->elInfo[i];
-
- if ((elInfo.elType == ID_SCE) || (elInfo.elType == ID_CPE) ||
- (elInfo.elType == ID_LFE))
- {
- /* for ( all sub frames ) ... */
- for (c = 0 ; c < nSubFrames ; c++ )
- {
- {
- qcElement[c][i] = qcOut[c]->qcElement[i];
- }
- }
- }
- }
-
- /*-------------------------------------------- */
- /*-------------------------------------------- */
- if ( isConstantBitrateMode(hQC->bitrateMode) )
- {
- /* calc granted dynamic bits for sub frame and
- distribute it to each element */
- ErrorStatus = FDKaacEnc_prepareBitDistribution(
- hQC,
- psyOut,
- qcOut,
- cm,
- qcElement,
- avgTotalBits,
- &totalAvailableBits,
- &avgTotalDynBits);
-
- if (ErrorStatus != AAC_ENC_OK) {
- return ErrorStatus;
- }
- }
- else {
- qcOut[0]->grantedDynBits = ((hQC->maxBitsPerFrame - (hQC->globHdrBits))&~7)
- - (qcOut[0]->globalExtBits + qcOut[0]->staticBits + qcOut[0]->elementExtBits);
- qcOut[0]->maxDynBits = qcOut[0]->grantedDynBits;
-
- totalAvailableBits = hQC->maxBitsPerFrame;
- avgTotalDynBits = 0;
- }
-
-#ifdef PNS_PRECOUNT_ENABLE
- /* Calculate estimated pns bits and substract them from grantedDynBits to get a more accurate number of available bits. */
- if (syntaxFlags & (AC_LD|AC_ELD))
- {
- int estimatedPnsBits = 0, ch;
-
- for (ch=0; ch<cm->nChannels; ch++) {
- qcOut[0]->pQcOutChannels[ch]->sectionData.noiseNrgBits = noisePreCount(psyOut[0]->pPsyOutChannels[ch]->noiseNrg, psyOut[0]->pPsyOutChannels[ch]->maxSfbPerGroup);
- estimatedPnsBits += qcOut[0]->pQcOutChannels[ch]->sectionData.noiseNrgBits;
- }
- qcOut[0]->grantedDynBits -= estimatedPnsBits;
- }
-#endif
-
- /* for ( all sub frames ) ... */
- for (c = 0 ; c < nSubFrames ; c++ )
- {
- /* for CBR and VBR mode */
- FDKaacEnc_AdjustThresholds(hQC->hAdjThr->adjThrStateElem,
- qcElement[c],
- qcOut[c],
- psyOut[c]->psyOutElement,
- isConstantBitrateMode(hQC->bitrateMode),
- cm);
-
- } /* -end- sub frame counter */
-
- /*-------------------------------------------- */
- INT iterations[(1)][(8)];
- INT chConstraintsFulfilled[(1)][(8)][(2)];
- INT calculateQuant[(1)][(8)][(2)];
- INT constraintsFulfilled[(1)][(8)];
- /*-------------------------------------------- */
-
-
- /* for ( all sub frames ) ... */
- for (c = 0 ; c < nSubFrames ; c++ )
- {
- for (i=0; i<cm->nElements; i++)
- {
- ELEMENT_INFO elInfo = cm->elInfo[i];
- INT ch, nChannels = elInfo.nChannelsInEl;
-
- if ((elInfo.elType == ID_SCE) || (elInfo.elType == ID_CPE) ||
- (elInfo.elType == ID_LFE))
- {
- /* Turn thresholds into scalefactors, optimize bit consumption and verify conformance */
- FDKaacEnc_EstimateScaleFactors(psyOut[c]->psyOutElement[i]->psyOutChannel,
- qcElement[c][i]->qcOutChannel,
- hQC->invQuant,
- cm->elInfo[i].nChannelsInEl);
-
-
- /*-------------------------------------------- */
- constraintsFulfilled[c][i] = 1;
- iterations[c][i] = 0 ;
-
- for (ch = 0; ch < nChannels; ch++)
- {
- chConstraintsFulfilled[c][i][ch] = 1;
- calculateQuant[c][i][ch] = 1;
- }
-
- /*-------------------------------------------- */
-
- } /* -end- if(ID_SCE || ID_CPE || ID_LFE) */
-
- } /* -end- element loop */
-
- qcOut[c]->usedDynBits = -1;
-
- } /* -end- sub frame counter */
-
-
-
- INT quantizationDone = 0;
- INT sumDynBitsConsumedTotal = 0;
- INT decreaseBitConsumption = -1; /* no direction yet! */
-
- /*-------------------------------------------- */
- /* -start- Quantization loop ... */
- /*-------------------------------------------- */
- do /* until max allowed bits per frame and maxDynBits!=-1*/
- {
- quantizationDone = 0;
-
- c = 0; /* get frame to process */
-
- for (i=0; i<cm->nElements; i++)
- {
- ELEMENT_INFO elInfo = cm->elInfo[i];
- INT ch, nChannels = elInfo.nChannelsInEl;
-
- if ((elInfo.elType == ID_SCE) || (elInfo.elType == ID_CPE) ||
- (elInfo.elType == ID_LFE))
- {
- do /* until spectral values < MAX_QUANT */
- {
- /*-------------------------------------------- */
- if (!constraintsFulfilled[c][i])
- {
- FDKaacEnc_reduceBitConsumption(&iterations[c][i],
- hQC->maxIterations,
- (decreaseBitConsumption) ? 1 : -1,
- chConstraintsFulfilled[c][i],
- calculateQuant[c][i],
- nChannels,
- psyOut[c]->psyOutElement[i],
- qcOut[c],
- qcElement[c][i],
- hQC->elementBits[i],
- aot,
- syntaxFlags,
- epConfig);
- }
-
- /*-------------------------------------------- */
- /*-------------------------------------------- */
- constraintsFulfilled[c][i] = 1 ;
-
- /*-------------------------------------------- */
- /* quantize spectrum (per each channel) */
- for (ch = 0; ch < nChannels; ch++)
- {
- /*-------------------------------------------- */
- chConstraintsFulfilled[c][i][ch] = 1;
-
- /*-------------------------------------------- */
-
- if (calculateQuant[c][i][ch])
- {
- QC_OUT_CHANNEL* qcOutCh = qcElement[c][i]->qcOutChannel[ch];
- PSY_OUT_CHANNEL* psyOutCh = psyOut[c]->psyOutElement[i]->psyOutChannel[ch];
-
- calculateQuant[c][i][ch] = 0; /* calculate quantization only if necessary */
-
- /*-------------------------------------------- */
- FDKaacEnc_QuantizeSpectrum(psyOutCh->sfbCnt,
- psyOutCh->maxSfbPerGroup,
- psyOutCh->sfbPerGroup,
- psyOutCh->sfbOffsets,
- qcOutCh->mdctSpectrum,
- qcOutCh->globalGain,
- qcOutCh->scf,
- qcOutCh->quantSpec) ;
-
- /*-------------------------------------------- */
- if (FDKaacEnc_calcMaxValueInSfb(psyOutCh->sfbCnt,
- psyOutCh->maxSfbPerGroup,
- psyOutCh->sfbPerGroup,
- psyOutCh->sfbOffsets,
- qcOutCh->quantSpec,
- qcOutCh->maxValueInSfb) > MAX_QUANT)
- {
- chConstraintsFulfilled[c][i][ch] = 0;
- constraintsFulfilled[c][i] = 0 ;
- /* if quanizted value out of range; increase global gain! */
- decreaseBitConsumption = 1;
- }
-
- /*-------------------------------------------- */
-
- } /* if calculateQuant[c][i][ch] */
-
- } /* channel loop */
-
- /*-------------------------------------------- */
- /* quantize spectrum (per each channel) */
-
- /*-------------------------------------------- */
-
- } while (!constraintsFulfilled[c][i]) ; /* does not regard bit consumption */
-
-
- /*-------------------------------------------- */
- /*-------------------------------------------- */
- qcElement[c][i]->dynBitsUsed = 0 ; /* reset dynamic bits */
-
- /* quantization valid in current channel! */
- for (ch = 0; ch < nChannels; ch++)
- {
- QC_OUT_CHANNEL* qcOutCh = qcElement[c][i]->qcOutChannel[ch];
- PSY_OUT_CHANNEL *psyOutCh = psyOut[c]->psyOutElement[i]->psyOutChannel[ch];
-
- /* count dynamic bits */
- INT chDynBits = FDKaacEnc_dynBitCount(hQC->hBitCounter,
- qcOutCh->quantSpec,
- qcOutCh->maxValueInSfb,
- qcOutCh->scf,
- psyOutCh->lastWindowSequence,
- psyOutCh->sfbCnt,
- psyOutCh->maxSfbPerGroup,
- psyOutCh->sfbPerGroup,
- psyOutCh->sfbOffsets,
- &qcOutCh->sectionData,
- psyOutCh->noiseNrg,
- psyOutCh->isBook,
- psyOutCh->isScale,
- syntaxFlags) ;
-
- /* sum up dynamic channel bits */
- qcElement[c][i]->dynBitsUsed += chDynBits;
- }
-
- /* save dynBitsUsed for correction of bits2pe relation */
- if(hQC->hAdjThr->adjThrStateElem[i]->dynBitsLast==-1) {
- hQC->hAdjThr->adjThrStateElem[i]->dynBitsLast = qcElement[c][i]->dynBitsUsed;
- }
- } /* -end- if(ID_SCE || ID_CPE || ID_LFE) */
-
- } /* -end- element loop */
-
- /* update dynBits of current subFrame */
- FDKaacEnc_updateUsedDynBits(&qcOut[c]->usedDynBits,
- qcElement[c],
- cm);
-
- /* get total consumed bits, dyn bits in all sub frames have to be valid */
- sumDynBitsConsumedTotal = FDKaacEnc_getTotalConsumedDynBits(qcOut, nSubFrames);
-
- if (sumDynBitsConsumedTotal==-1)
- {
- quantizationDone = 0; /* bit consumption not valid in all sub frames */
- }
- else
- {
- int sumBitsConsumedTotal = FDKaacEnc_getTotalConsumedBits(qcOut, qcElement, cm, hQC->globHdrBits, nSubFrames);
-
- /* in all frames are valid dynamic bits */
- if ( ((sumBitsConsumedTotal < totalAvailableBits) || qcOut[c]->usedDynBits==0) && (decreaseBitConsumption==1) && checkMinFrameBitsDemand(qcOut,hQC->minBitsPerFrame,nSubFrames)
- /*()*/ )
- {
- quantizationDone = 1; /* exit bit adjustment */
- }
- if (sumBitsConsumedTotal > totalAvailableBits && (decreaseBitConsumption==0) )
-// /*()*/ )
- {
- quantizationDone = 0; /* reset! */
- break;
- }
- }
-
-
- /*-------------------------------------------- */
-
- int emergencyIterations = 1;
- int dynBitsOvershoot = 0;
-
- for (c = 0 ; c < nSubFrames ; c++ )
- {
- for (i=0; i<cm->nElements; i++)
- {
- ELEMENT_INFO elInfo = cm->elInfo[i];
-
- if ((elInfo.elType == ID_SCE) || (elInfo.elType == ID_CPE) ||
- (elInfo.elType == ID_LFE))
- {
- /* iteration limitation */
- emergencyIterations &= ((iterations[c][i] < hQC->maxIterations) ? 0 : 1);
- }
- }
- /* detection if used dyn bits exceeds the maximal allowed criterion */
- dynBitsOvershoot |= ((qcOut[c]->usedDynBits > qcOut[c]->maxDynBits) ? 1 : 0);
- }
-
- if (quantizationDone==0 || dynBitsOvershoot)
- {
-
- int sumBitsConsumedTotal = FDKaacEnc_getTotalConsumedBits(qcOut, qcElement, cm, hQC->globHdrBits, nSubFrames);
-
- if ( (sumDynBitsConsumedTotal >= avgTotalDynBits) || (sumDynBitsConsumedTotal==0) ) {
- quantizationDone = 1;
- }
- if (emergencyIterations && (sumBitsConsumedTotal < totalAvailableBits)) {
- quantizationDone = 1;
- }
- if ((sumBitsConsumedTotal > totalAvailableBits) || !checkMinFrameBitsDemand(qcOut,hQC->minBitsPerFrame,nSubFrames)) {
- quantizationDone = 0;
- }
- if ((sumBitsConsumedTotal < totalAvailableBits) && checkMinFrameBitsDemand(qcOut,hQC->minBitsPerFrame,nSubFrames)) {
- decreaseBitConsumption = 0;
- }
- else {
- decreaseBitConsumption = 1;
- }
-
- if (dynBitsOvershoot) {
- quantizationDone = 0;
- decreaseBitConsumption = 1;
- }
-
- /* reset constraints fullfilled flags */
- FDKmemclear(constraintsFulfilled, sizeof(constraintsFulfilled));
- FDKmemclear(chConstraintsFulfilled, sizeof(chConstraintsFulfilled));
-
-
- }/* quantizationDone */
-
- } while (!quantizationDone) ;
-
- /*-------------------------------------------- */
- /* ... -end- Quantization loop */
- /*-------------------------------------------- */
-
- /*-------------------------------------------- */
- /*-------------------------------------------- */
-
- return AAC_ENC_OK;
-}
-
-
-static AAC_ENCODER_ERROR FDKaacEnc_reduceBitConsumption(int* iterations,
- const int maxIterations,
- int gainAdjustment,
- int* chConstraintsFulfilled,
- int* calculateQuant,
- int nChannels,
- PSY_OUT_ELEMENT* psyOutElement,
- QC_OUT* qcOut,
- QC_OUT_ELEMENT* qcOutElement,
- ELEMENT_BITS* elBits,
- AUDIO_OBJECT_TYPE aot,
- UINT syntaxFlags,
- SCHAR epConfig)
-{
- int ch;
-
- /** SOLVING PROBLEM **/
- if ((*iterations)++ >= maxIterations)
- {
- if (qcOutElement->dynBitsUsed==0) {
- }
- /* crash recovery */
- else {
- INT bitsToSave = 0;
- if ( (bitsToSave = fixMax((qcOutElement->dynBitsUsed + 8) - (elBits->bitResLevelEl + qcOutElement->grantedDynBits),
- (qcOutElement->dynBitsUsed + qcOutElement->staticBitsUsed + 8) - (elBits->maxBitsEl))) > 0 )
- {
- FDKaacEnc_crashRecovery(nChannels,
- psyOutElement,
- qcOut,
- qcOutElement,
- bitsToSave,
- aot,
- syntaxFlags,
- epConfig) ;
- }
- else
- {
- for (ch = 0; ch < nChannels; ch++)
- {
- qcOutElement->qcOutChannel[ch]->globalGain += 1;
- }
- }
- for (ch = 0; ch < nChannels; ch++)
- {
- calculateQuant[ch] = 1;
- }
- }
- }
- else /* iterations >= maxIterations */
- {
- /* increase gain (+ next iteration) */
- for (ch = 0; ch < nChannels; ch++)
- {
- if(!chConstraintsFulfilled[ch])
- {
- qcOutElement->qcOutChannel[ch]->globalGain += gainAdjustment ;
- calculateQuant[ch] = 1; /* global gain has changed, recalculate quantization in next iteration! */
- }
- }
- }
-
- return AAC_ENC_OK;
-}
-
-AAC_ENCODER_ERROR FDKaacEnc_updateFillBits(CHANNEL_MAPPING* cm,
- QC_STATE* qcKernel,
- ELEMENT_BITS* RESTRICT elBits[(8)],
- QC_OUT** qcOut)
-{
- switch (qcKernel->bitrateMode) {
- case QCDATA_BR_MODE_SFR:
- break;
-
- case QCDATA_BR_MODE_FF:
- break;
-
- case QCDATA_BR_MODE_VBR_1:
- case QCDATA_BR_MODE_VBR_2:
- case QCDATA_BR_MODE_VBR_3:
- case QCDATA_BR_MODE_VBR_4:
- case QCDATA_BR_MODE_VBR_5:
- qcOut[0]->totFillBits = (qcOut[0]->grantedDynBits - qcOut[0]->usedDynBits)&7; /* precalculate alignment bits */
- break;
-
- case QCDATA_BR_MODE_CBR:
- case QCDATA_BR_MODE_INVALID:
- default:
- INT bitResSpace = qcKernel->bitResTotMax - qcKernel->bitResTot ;
- /* processing fill-bits */
- INT deltaBitRes = qcOut[0]->grantedDynBits - qcOut[0]->usedDynBits ;
- qcOut[0]->totFillBits = fixMax((deltaBitRes&7), (deltaBitRes - (fixMax(0,bitResSpace-7)&~7)));
- break;
- } /* switch (qcKernel->bitrateMode) */
-
- return AAC_ENC_OK;
-}
-
-
-
-
-/*********************************************************************************
-
- functionname: FDKaacEnc_calcMaxValueInSfb
- description:
- return:
-
-**********************************************************************************/
-
-static INT FDKaacEnc_calcMaxValueInSfb(INT sfbCnt,
- INT maxSfbPerGroup,
- INT sfbPerGroup,
- INT *RESTRICT sfbOffset,
- SHORT *RESTRICT quantSpectrum,
- UINT *RESTRICT maxValue)
-{
- INT sfbOffs,sfb;
- INT maxValueAll = 0;
-
- for (sfbOffs=0;sfbOffs<sfbCnt;sfbOffs+=sfbPerGroup)
- for (sfb = 0; sfb < maxSfbPerGroup; sfb++)
- {
- INT line;
- INT maxThisSfb = 0;
- for (line = sfbOffset[sfbOffs+sfb]; line < sfbOffset[sfbOffs+sfb+1]; line++)
- {
- INT tmp = fixp_abs(quantSpectrum[line]);
- maxThisSfb = fixMax(tmp, maxThisSfb);
- }
-
- maxValue[sfbOffs+sfb] = maxThisSfb;
- maxValueAll = fixMax(maxThisSfb, maxValueAll);
- }
- return maxValueAll;
-}
-
-
-/*********************************************************************************
-
- functionname: FDKaacEnc_updateBitres
- description:
- return:
-
-**********************************************************************************/
-void FDKaacEnc_updateBitres(CHANNEL_MAPPING *cm,
- QC_STATE* qcKernel,
- QC_OUT** qcOut)
-{
- switch (qcKernel->bitrateMode) {
- case QCDATA_BR_MODE_FF:
- case QCDATA_BR_MODE_VBR_1:
- case QCDATA_BR_MODE_VBR_2:
- case QCDATA_BR_MODE_VBR_3:
- case QCDATA_BR_MODE_VBR_4:
- case QCDATA_BR_MODE_VBR_5:
- /* variable bitrate */
- qcKernel->bitResTot = FDKmin(qcKernel->maxBitsPerFrame, qcKernel->bitResTotMax);
- break;
-
- case QCDATA_BR_MODE_CBR:
- case QCDATA_BR_MODE_SFR:
- case QCDATA_BR_MODE_INVALID:
- default:
- int c = 0;
- /* constant bitrate */
- {
- qcKernel->bitResTot += qcOut[c]->grantedDynBits - (qcOut[c]->usedDynBits + qcOut[c]->totFillBits + qcOut[c]->alignBits);
- }
- break;
- }
-}
-
-/*********************************************************************************
-
- functionname: FDKaacEnc_FinalizeBitConsumption
- description:
- return:
-
-**********************************************************************************/
-AAC_ENCODER_ERROR FDKaacEnc_FinalizeBitConsumption(CHANNEL_MAPPING *cm,
- QC_STATE *qcKernel,
- QC_OUT *qcOut,
- QC_OUT_ELEMENT** qcElement,
- HANDLE_TRANSPORTENC hTpEnc,
- AUDIO_OBJECT_TYPE aot,
- UINT syntaxFlags,
- SCHAR epConfig)
-{
- QC_OUT_EXTENSION fillExtPayload;
- INT totFillBits, alignBits;
-
- /* Get total consumed bits in AU */
- qcOut->totalBits = qcOut->staticBits + qcOut->usedDynBits + qcOut->totFillBits +
- qcOut->elementExtBits + qcOut->globalExtBits;
-#if 1
- if (qcKernel->bitrateMode==QCDATA_BR_MODE_CBR) {
-
- /* Now we can get the exact transport bit amount, and hopefully it is equal to the estimated value */
- INT exactTpBits = transportEnc_GetStaticBits(hTpEnc, qcOut->totalBits);
-
- if (exactTpBits != qcKernel->globHdrBits) {
- INT diffFillBits = 0;
-
- /* How many bits can be taken by bitreservoir */
- const INT bitresSpace = qcKernel->bitResTotMax - (qcKernel->bitResTot + (qcOut->grantedDynBits - (qcOut->usedDynBits + qcOut->totFillBits) ) );
-
- /* Number of bits which can be moved to bitreservoir. */
- const INT bitsToBitres = qcKernel->globHdrBits - exactTpBits;
- FDK_ASSERT(bitsToBitres>=0); /* is always positive */
-
- /* If bitreservoir can not take all bits, move ramaining bits to fillbits */
- diffFillBits = FDKmax(0, bitsToBitres - bitresSpace);
-
- /* Assure previous alignment */
- diffFillBits = (diffFillBits+7)&~7;
-
- /* Move as many bits as possible to bitreservoir */
- qcKernel->bitResTot += (bitsToBitres-diffFillBits);
-
- /* Write remaing bits as fill bits */
- qcOut->totFillBits += diffFillBits;
- qcOut->totalBits += diffFillBits;
- qcOut->grantedDynBits += diffFillBits;
-
- /* Get new header bits */
- qcKernel->globHdrBits = transportEnc_GetStaticBits(hTpEnc, qcOut->totalBits);
-
- if (qcKernel->globHdrBits != exactTpBits) {
- /* In previous step, fill bits and corresponding total bits were changed when bitreservoir was completely filled.
- Now we can take the too much taken bits caused by header overhead from bitreservoir.
- */
- qcKernel->bitResTot -= (qcKernel->globHdrBits - exactTpBits);
- }
- }
-
- } /* MODE_CBR */
-#endif
- /* Update exact number of consumed header bits. */
- qcKernel->globHdrBits = transportEnc_GetStaticBits(hTpEnc, qcOut->totalBits);
-
- /* Save total fill bits and distribut to alignment and fill bits */
- totFillBits = qcOut->totFillBits;
-
- /* fake a fill extension payload */
- FDKmemclear(&fillExtPayload, sizeof(QC_OUT_EXTENSION));
-
- fillExtPayload.type = EXT_FILL_DATA;
- fillExtPayload.nPayloadBits = totFillBits;
-
- /* ask bitstream encoder how many of that bits can be written in a fill extension data entity */
- qcOut->totFillBits = FDKaacEnc_writeExtensionData( NULL,
- &fillExtPayload,
- 0, 0,
- syntaxFlags,
- aot,
- epConfig );
-
- //fprintf(stderr, "FinalizeBitConsumption(): totFillBits=%d, qcOut->totFillBits=%d \n", totFillBits, qcOut->totFillBits);
-
- /* now distribute extra fillbits and alignbits */
- alignBits = 7 - (qcOut->staticBits + qcOut->usedDynBits + qcOut->elementExtBits
- + qcOut->totFillBits + qcOut->globalExtBits -1)%8;
-
- /* Maybe we could remove this */
- if( ((alignBits + qcOut->totFillBits - totFillBits)==8) && (qcOut->totFillBits>8) )
- qcOut->totFillBits -= 8;
-
- qcOut->totalBits = qcOut->staticBits + qcOut->usedDynBits + qcOut->totFillBits +
- alignBits + qcOut->elementExtBits + qcOut->globalExtBits;
-
- if ( (qcOut->totalBits>qcKernel->maxBitsPerFrame) || (qcOut->totalBits<qcKernel->minBitsPerFrame) ) {
- return AAC_ENC_QUANT_ERROR;
- }
-
- qcOut->alignBits = alignBits;
-
- return AAC_ENC_OK;
-}
-
-
-
-/*********************************************************************************
-
- functionname: FDKaacEnc_crashRecovery
- description: fulfills constraints by means of brute force...
- => bits are saved by cancelling out spectral lines!!
- (beginning at the highest frequencies)
- return: errorcode
-
-**********************************************************************************/
-
-static void FDKaacEnc_crashRecovery(INT nChannels,
- PSY_OUT_ELEMENT* psyOutElement,
- QC_OUT* qcOut,
- QC_OUT_ELEMENT *qcElement,
- INT bitsToSave,
- AUDIO_OBJECT_TYPE aot,
- UINT syntaxFlags,
- SCHAR epConfig)
-{
- INT ch ;
- INT savedBits = 0 ;
- INT sfb, sfbGrp ;
- INT bitsPerScf[(2)][MAX_GROUPED_SFB] ;
- INT sectionToScf[(2)][MAX_GROUPED_SFB] ;
- INT *sfbOffset ;
- INT sect, statBitsNew ;
- QC_OUT_CHANNEL **qcChannel = qcElement->qcOutChannel;
- PSY_OUT_CHANNEL **psyChannel = psyOutElement->psyOutChannel;
-
- /* create a table which converts frq-bins to bit-demand... [bitsPerScf] */
- /* ...and another one which holds the corresponding sections [sectionToScf] */
- for (ch = 0; ch < nChannels; ch++)
- {
- sfbOffset = psyChannel[ch]->sfbOffsets ;
-
- for (sect = 0; sect < qcChannel[ch]->sectionData.noOfSections; sect++)
- {
- INT sfb ;
- INT codeBook = qcChannel[ch]->sectionData.huffsection[sect].codeBook ;
-
- for (sfb = qcChannel[ch]->sectionData.huffsection[sect].sfbStart;
- sfb < qcChannel[ch]->sectionData.huffsection[sect].sfbStart +
- qcChannel[ch]->sectionData.huffsection[sect].sfbCnt;
- sfb++)
- {
- bitsPerScf[ch][sfb] = 0;
- if ( (codeBook != CODE_BOOK_PNS_NO) /*&&
- (sfb < (qcChannel[ch]->sectionData.noOfGroups*qcChannel[ch]->sectionData.maxSfbPerGroup))*/ )
- {
- INT sfbStartLine = sfbOffset[sfb] ;
- INT noOfLines = sfbOffset[sfb+1] - sfbStartLine ;
- bitsPerScf[ch][sfb] = FDKaacEnc_countValues(&(qcChannel[ch]->quantSpec[sfbStartLine]), noOfLines, codeBook) ;
- }
- sectionToScf[ch][sfb] = sect ;
- }
-
- }
- }
-
- /* LOWER [maxSfb] IN BOTH CHANNELS!! */
- /* Attention: in case of stereo: maxSfbL == maxSfbR, GroupingL == GroupingR ; */
-
- for (sfb = qcChannel[0]->sectionData.maxSfbPerGroup-1; sfb >= 0; sfb--)
- {
- for (sfbGrp = 0; sfbGrp < psyChannel[0]->sfbCnt; sfbGrp += psyChannel[0]->sfbPerGroup)
- {
- for (ch = 0; ch < nChannels; ch++)
- {
- int sect = sectionToScf[ch][sfbGrp+sfb];
- qcChannel[ch]->sectionData.huffsection[sect].sfbCnt-- ;
- savedBits += bitsPerScf[ch][sfbGrp+sfb] ;
-
- if (qcChannel[ch]->sectionData.huffsection[sect].sfbCnt == 0) {
- savedBits += (psyChannel[ch]->lastWindowSequence!=SHORT_WINDOW) ? FDKaacEnc_sideInfoTabLong[0]
- : FDKaacEnc_sideInfoTabShort[0];
- }
- }
- }
-
- /* ...have enough bits been saved? */
- if (savedBits >= bitsToSave)
- break ;
-
- } /* sfb loop */
-
- /* if not enough bits saved,
- clean whole spectrum and remove side info overhead */
- if (sfb == -1) {
- sfb = 0 ;
- }
-
- for (ch = 0; ch < nChannels; ch++)
- {
- qcChannel[ch]->sectionData.maxSfbPerGroup = sfb ;
- psyChannel[ch]->maxSfbPerGroup = sfb ;
- /* when no spectrum is coded save tools info in bitstream */
- if(sfb==0) {
- FDKmemclear(&psyChannel[ch]->tnsInfo, sizeof(TNS_INFO));
- FDKmemclear(&psyOutElement->toolsInfo, sizeof(TOOLSINFO));
- }
- }
- /* dynamic bits will be updated in iteration loop */
-
- { /* if stop sfb has changed save bits in side info, e.g. MS or TNS coding */
- ELEMENT_INFO elInfo;
-
- FDKmemclear(&elInfo, sizeof(ELEMENT_INFO));
- elInfo.nChannelsInEl = nChannels;
- elInfo.elType = (nChannels == 2) ? ID_CPE : ID_SCE;
-
- FDKaacEnc_ChannelElementWrite( NULL, &elInfo, NULL,
- psyOutElement,
- psyChannel,
- syntaxFlags,
- aot,
- epConfig,
- &statBitsNew,
- 0 );
- }
-
- savedBits = qcElement->staticBitsUsed - statBitsNew;
-
- /* update static and dynamic bits */
- qcElement->staticBitsUsed -= savedBits;
- qcElement->grantedDynBits += savedBits;
-
- qcOut->staticBits -= savedBits;
- qcOut->grantedDynBits += savedBits;
- qcOut->maxDynBits += savedBits;
-
-
-}
-
-
-
-void FDKaacEnc_QCClose (QC_STATE **phQCstate, QC_OUT **phQC)
-{
- int n, i;
-
- if (phQC!=NULL) {
-
- for (n=0;n<(1);n++) {
- if (phQC[n] != NULL) {
- QC_OUT *hQC = phQC[n];
- for (i=0; i<(8); i++) {
- }
-
- for (i=0; i<(8); i++) {
- if (hQC->qcElement[i])
- FreeRam_aacEnc_QCelement(&hQC->qcElement[i]);
- }
-
- FreeRam_aacEnc_QCout(&phQC[n]);
- }
- }
- }
-
- if (phQCstate!=NULL) {
- if (*phQCstate != NULL) {
- QC_STATE *hQCstate = *phQCstate;
-
- if (hQCstate->hAdjThr != NULL)
- FDKaacEnc_AdjThrClose(&hQCstate->hAdjThr);
-
- if (hQCstate->hBitCounter != NULL)
- FDKaacEnc_BCClose(&hQCstate->hBitCounter);
-
- for (i=0; i<(8); i++) {
- if (hQCstate->elementBits[i]!=NULL) {
- FreeRam_aacEnc_ElementBits(&hQCstate->elementBits[i]);
- }
- }
- FreeRam_aacEnc_QCstate(phQCstate);
- }
- }
-}
-
diff --git a/libAACenc/src/qc_main.h b/libAACenc/src/qc_main.h
deleted file mode 100644
index 4e8c042..0000000
--- a/libAACenc/src/qc_main.h
+++ /dev/null
@@ -1,170 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M. Werner
- contents/description: Quantizing & coding
-
-******************************************************************************/
-#ifndef _QC_MAIN_H
-#define _QC_MAIN_H
-
-
-#include "aacenc.h"
-#include "qc_data.h"
-#include "interface.h"
-#include "psy_main.h"
-#include "tpenc_lib.h"
-
-/* Quantizing & coding stage */
-
-AAC_ENCODER_ERROR FDKaacEnc_QCOutNew(QC_OUT **phQC,
- const INT nElements,
- const INT nChannels,
- const INT nSubFrames
- ,UCHAR *dynamic_RAM
- );
-
-AAC_ENCODER_ERROR FDKaacEnc_QCOutInit(QC_OUT *phQC[(1)],
- const INT nSubFrames,
- const CHANNEL_MAPPING *cm);
-
-AAC_ENCODER_ERROR FDKaacEnc_QCNew(QC_STATE **phQC,
- INT nElements
- ,UCHAR* dynamic_RAM
- );
-
-AAC_ENCODER_ERROR FDKaacEnc_QCInit(QC_STATE *hQC, struct QC_INIT *init);
-
-AAC_ENCODER_ERROR FDKaacEnc_QCMainPrepare(
- ELEMENT_INFO *elInfo,
- ATS_ELEMENT* RESTRICT adjThrStateElement,
- PSY_OUT_ELEMENT* RESTRICT psyOutElement,
- QC_OUT_ELEMENT* RESTRICT qcOutElement, /* returns error code */
- AUDIO_OBJECT_TYPE aot,
- UINT syntaxFlags,
- SCHAR epConfig
- );
-
-
-AAC_ENCODER_ERROR FDKaacEnc_QCMain(QC_STATE* RESTRICT hQC,
- PSY_OUT** psyOut,
- QC_OUT** qcOut,
- INT avgTotalBits,
- CHANNEL_MAPPING* cm
- ,AUDIO_OBJECT_TYPE aot,
- UINT syntaxFlags,
- SCHAR epConfig
- );
-
-AAC_ENCODER_ERROR FDKaacEnc_updateFillBits(CHANNEL_MAPPING* cm,
- QC_STATE* qcKernel,
- ELEMENT_BITS* RESTRICT elBits[(8)],
- QC_OUT** qcOut);
-
-
-void FDKaacEnc_updateBitres( CHANNEL_MAPPING *cm,
- QC_STATE *qcKernel,
- QC_OUT **qcOut);
-
-AAC_ENCODER_ERROR FDKaacEnc_FinalizeBitConsumption( CHANNEL_MAPPING *cm,
- QC_STATE *hQC,
- QC_OUT *qcOut,
- QC_OUT_ELEMENT** qcElement,
- HANDLE_TRANSPORTENC hTpEnc,
- AUDIO_OBJECT_TYPE aot,
- UINT syntaxFlags,
- SCHAR epConfig
- );
-
-AAC_ENCODER_ERROR FDKaacEnc_AdjustBitrate(QC_STATE *RESTRICT hQC,
- CHANNEL_MAPPING *RESTRICT cm,
- INT *avgTotalBits,
- INT bitRate,
- INT sampleRate,
- INT granuleLength);
-
-void FDKaacEnc_QCClose (QC_STATE **phQCstate, QC_OUT **phQC);
-
-#endif /* _QC_MAIN_H */
diff --git a/libAACenc/src/quantize.cpp b/libAACenc/src/quantize.cpp
deleted file mode 100644
index 5380e35..0000000
--- a/libAACenc/src/quantize.cpp
+++ /dev/null
@@ -1,395 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M.Werner
- contents/description: Quantization
-
-******************************************************************************/
-
-#include "quantize.h"
-
-#include "aacEnc_rom.h"
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_quantizeLines
- description: quantizes spectrum lines
- returns:
- input: global gain, number of lines to process, spectral data
- output: quantized spectrum
-
-*****************************************************************************/
-static void FDKaacEnc_quantizeLines(INT gain,
- INT noOfLines,
- FIXP_DBL *mdctSpectrum,
- SHORT *quaSpectrum)
-{
- int line;
- FIXP_DBL k = FL2FXCONST_DBL(-0.0946f + 0.5f)>>16;
- FIXP_QTD quantizer = FDKaacEnc_quantTableQ[(-gain)&3];
- INT quantizershift = ((-gain)>>2)+1;
-
-
- for (line = 0; line < noOfLines; line++)
- {
- FIXP_DBL accu = fMultDiv2(mdctSpectrum[line],quantizer);
-
- if (accu < FL2FXCONST_DBL(0.0f))
- {
- accu=-accu;
- /* normalize */
- INT accuShift = CntLeadingZeros(accu) - 1; /* CountLeadingBits() is not necessary here since test value is always > 0 */
- accu <<= accuShift;
- INT tabIndex = (INT)(accu>>(DFRACT_BITS-2-MANT_DIGITS))&(~MANT_SIZE);
- INT totalShift = quantizershift-accuShift+1;
- accu = fMultDiv2(FDKaacEnc_mTab_3_4[tabIndex],FDKaacEnc_quantTableE[totalShift&3]);
- totalShift = (16-4)-(3*(totalShift>>2));
- FDK_ASSERT(totalShift >=0); /* MAX_QUANT_VIOLATION */
- accu >>= fixMin(totalShift,DFRACT_BITS-1);
- quaSpectrum[line] = (SHORT)(-((LONG)(k + accu) >> (DFRACT_BITS-1-16)));
- }
- else if(accu > FL2FXCONST_DBL(0.0f))
- {
- /* normalize */
- INT accuShift = CntLeadingZeros(accu) - 1; /* CountLeadingBits() is not necessary here since test value is always > 0 */
- accu <<= accuShift;
- INT tabIndex = (INT)(accu>>(DFRACT_BITS-2-MANT_DIGITS))&(~MANT_SIZE);
- INT totalShift = quantizershift-accuShift+1;
- accu = fMultDiv2(FDKaacEnc_mTab_3_4[tabIndex],FDKaacEnc_quantTableE[totalShift&3]);
- totalShift = (16-4)-(3*(totalShift>>2));
- FDK_ASSERT(totalShift >=0); /* MAX_QUANT_VIOLATION */
- accu >>= fixMin(totalShift,DFRACT_BITS-1);
- quaSpectrum[line] = (SHORT)((LONG)(k + accu) >> (DFRACT_BITS-1-16));
- }
- else
- quaSpectrum[line]=0;
- }
-}
-
-
-/*****************************************************************************
-
- functionname:iFDKaacEnc_quantizeLines
- description: iquantizes spectrum lines
- mdctSpectrum = iquaSpectrum^4/3 *2^(0.25*gain)
- input: global gain, number of lines to process,quantized spectrum
- output: spectral data
-
-*****************************************************************************/
-static void FDKaacEnc_invQuantizeLines(INT gain,
- INT noOfLines,
- SHORT *quantSpectrum,
- FIXP_DBL *mdctSpectrum)
-
-{
- INT iquantizermod;
- INT iquantizershift;
- INT line;
-
- iquantizermod = gain&3;
- iquantizershift = gain>>2;
-
- for (line = 0; line < noOfLines; line++) {
-
- if(quantSpectrum[line] < 0) {
- FIXP_DBL accu;
- INT ex,specExp,tabIndex;
- FIXP_DBL s,t;
-
- accu = (FIXP_DBL) -quantSpectrum[line];
-
- ex = CountLeadingBits(accu);
- accu <<= ex;
- specExp = (DFRACT_BITS-1) - ex;
-
- FDK_ASSERT(specExp < 14); /* this fails if abs(value) > 8191 */
-
- tabIndex = (INT)(accu>>(DFRACT_BITS-2-MANT_DIGITS))&(~MANT_SIZE);
-
- /* calculate "mantissa" ^4/3 */
- s = FDKaacEnc_mTab_4_3Elc[tabIndex];
-
- /* get approperiate exponent multiplier for specExp^3/4 combined with scfMod */
- t = FDKaacEnc_specExpMantTableCombElc[iquantizermod][specExp];
-
- /* multiply "mantissa" ^4/3 with exponent multiplier */
- accu = fMult(s,t);
-
- /* get approperiate exponent shifter */
- specExp = FDKaacEnc_specExpTableComb[iquantizermod][specExp]-1; /* -1 to avoid overflows in accu */
-
- if ((-iquantizershift-specExp) < 0)
- accu <<= -(-iquantizershift-specExp);
- else
- accu >>= -iquantizershift-specExp;
-
- mdctSpectrum[line] = -accu;
- }
- else if (quantSpectrum[line] > 0) {
- FIXP_DBL accu;
- INT ex,specExp,tabIndex;
- FIXP_DBL s,t;
-
- accu = (FIXP_DBL)(INT)quantSpectrum[line];
-
- ex = CountLeadingBits(accu);
- accu <<= ex;
- specExp = (DFRACT_BITS-1) - ex;
-
- FDK_ASSERT(specExp < 14); /* this fails if abs(value) > 8191 */
-
- tabIndex = (INT)(accu>>(DFRACT_BITS-2-MANT_DIGITS))&(~MANT_SIZE);
-
- /* calculate "mantissa" ^4/3 */
- s = FDKaacEnc_mTab_4_3Elc[tabIndex];
-
- /* get approperiate exponent multiplier for specExp^3/4 combined with scfMod */
- t = FDKaacEnc_specExpMantTableCombElc[iquantizermod][specExp];
-
- /* multiply "mantissa" ^4/3 with exponent multiplier */
- accu = fMult(s,t);
-
- /* get approperiate exponent shifter */
- specExp = FDKaacEnc_specExpTableComb[iquantizermod][specExp]-1; /* -1 to avoid overflows in accu */
-
- if (( -iquantizershift-specExp) < 0)
- accu <<= -(-iquantizershift-specExp);
- else
- accu >>= -iquantizershift-specExp;
-
- mdctSpectrum[line] = accu;
- }
- else {
- mdctSpectrum[line] = FL2FXCONST_DBL(0.0f);
- }
- }
-}
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_QuantizeSpectrum
- description: quantizes the entire spectrum
- returns:
- input: number of scalefactor bands to be quantized, ...
- output: quantized spectrum
-
-*****************************************************************************/
-void FDKaacEnc_QuantizeSpectrum(INT sfbCnt,
- INT maxSfbPerGroup,
- INT sfbPerGroup,
- INT *sfbOffset,
- FIXP_DBL *mdctSpectrum,
- INT globalGain,
- INT *scalefactors,
- SHORT *quantizedSpectrum)
-{
- INT sfbOffs,sfb;
-
- /* in FDKaacEnc_quantizeLines quaSpectrum is calculated with:
- spec^(3/4) * 2^(-3/16*QSS) * 2^(3/4*scale) + k
- simplify scaling calculation and reduce QSS before:
- spec^(3/4) * 2^(-3/16*(QSS - 4*scale)) */
-
- for(sfbOffs=0;sfbOffs<sfbCnt;sfbOffs+=sfbPerGroup)
- for (sfb = 0; sfb < maxSfbPerGroup; sfb++)
- {
- INT scalefactor = scalefactors[sfbOffs+sfb] ;
-
- FDKaacEnc_quantizeLines(globalGain - scalefactor, /* QSS */
- sfbOffset[sfbOffs+sfb+1] - sfbOffset[sfbOffs+sfb],
- mdctSpectrum + sfbOffset[sfbOffs+sfb],
- quantizedSpectrum + sfbOffset[sfbOffs+sfb]);
- }
-}
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_calcSfbDist
- description: calculates distortion of quantized values
- returns: distortion
- input: gain, number of lines to process, spectral data
- output:
-
-*****************************************************************************/
-FIXP_DBL FDKaacEnc_calcSfbDist(FIXP_DBL *mdctSpectrum,
- SHORT *quantSpectrum,
- INT noOfLines,
- INT gain
- )
-{
- INT i,scale;
- FIXP_DBL xfsf;
- FIXP_DBL diff;
- FIXP_DBL invQuantSpec;
-
- xfsf = FL2FXCONST_DBL(0.0f);
-
- for (i=0; i<noOfLines; i++) {
- /* quantization */
- FDKaacEnc_quantizeLines(gain,
- 1,
- &mdctSpectrum[i],
- &quantSpectrum[i]);
-
- if (fAbs(quantSpectrum[i])>MAX_QUANT) {
- return FL2FXCONST_DBL(0.0f);
- }
- /* inverse quantization */
- FDKaacEnc_invQuantizeLines(gain,1,&quantSpectrum[i],&invQuantSpec);
-
- /* dist */
- diff = fixp_abs(fixp_abs(invQuantSpec) - fixp_abs(mdctSpectrum[i]>>1));
-
- scale = CountLeadingBits(diff);
- diff = scaleValue(diff, scale);
- diff = fPow2(diff);
- scale = fixMin(2*(scale-1), DFRACT_BITS-1);
-
- diff = scaleValue(diff, -scale);
-
- xfsf = xfsf + diff;
- }
-
- xfsf = CalcLdData(xfsf);
-
- return xfsf;
-}
-
-/*****************************************************************************
-
- functionname: FDKaacEnc_calcSfbQuantEnergyAndDist
- description: calculates energy and distortion of quantized values
- returns:
- input: gain, number of lines to process, quantized spectral data,
- spectral data
- output: energy, distortion
-
-*****************************************************************************/
-void FDKaacEnc_calcSfbQuantEnergyAndDist(FIXP_DBL *mdctSpectrum,
- SHORT *quantSpectrum,
- INT noOfLines,
- INT gain,
- FIXP_DBL *en,
- FIXP_DBL *dist)
-{
- INT i,scale;
- FIXP_DBL invQuantSpec;
- FIXP_DBL diff;
-
- FIXP_DBL energy = FL2FXCONST_DBL(0.0f);
- FIXP_DBL distortion = FL2FXCONST_DBL(0.0f);
-
- for (i=0; i<noOfLines; i++) {
-
- if (fAbs(quantSpectrum[i])>MAX_QUANT) {
- *en = FL2FXCONST_DBL(0.0f);
- *dist = FL2FXCONST_DBL(0.0f);
- return;
- }
-
- /* inverse quantization */
- FDKaacEnc_invQuantizeLines(gain,1,&quantSpectrum[i],&invQuantSpec);
-
- /* energy */
- energy += fPow2(invQuantSpec);
-
- /* dist */
- diff = fixp_abs(fixp_abs(invQuantSpec) - fixp_abs(mdctSpectrum[i]>>1));
-
- scale = CountLeadingBits(diff);
- diff = scaleValue(diff, scale);
- diff = fPow2(diff);
-
- scale = fixMin(2*(scale-1), DFRACT_BITS-1);
-
- diff = scaleValue(diff, -scale);
-
- distortion += diff;
- }
-
- *en = CalcLdData(energy)+FL2FXCONST_DBL(0.03125f);
- *dist = CalcLdData(distortion);
-}
-
diff --git a/libAACenc/src/quantize.h b/libAACenc/src/quantize.h
deleted file mode 100644
index 975b98e..0000000
--- a/libAACenc/src/quantize.h
+++ /dev/null
@@ -1,119 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M.Werner
- contents/description: Quantization
-
-******************************************************************************/
-
-#ifndef _QUANTIZE_H_
-#define _QUANTIZE_H_
-
-#include "common_fix.h"
-
-/* quantizing */
-
-#define MAX_QUANT 8191
-
-void FDKaacEnc_QuantizeSpectrum(INT sfbCnt,
- INT maxSfbPerGroup,
- INT sfbPerGroup,
- INT *sfbOffset, FIXP_DBL *mdctSpectrum,
- INT globalGain, INT *scalefactors,
- SHORT *quantizedSpectrum);
-
-FIXP_DBL FDKaacEnc_calcSfbDist(FIXP_DBL *mdctSpectrum,
- SHORT *quantSpectrum,
- INT noOfLines,
- INT gain);
-
-void FDKaacEnc_calcSfbQuantEnergyAndDist(FIXP_DBL *mdctSpectrum,
- SHORT *quantSpectrum,
- INT noOfLines,
- INT gain,
- FIXP_DBL *en,
- FIXP_DBL *dist);
-
-#endif /* _QUANTIZE_H_ */
diff --git a/libAACenc/src/sf_estim.cpp b/libAACenc/src/sf_estim.cpp
deleted file mode 100644
index 72b75a6..0000000
--- a/libAACenc/src/sf_estim.cpp
+++ /dev/null
@@ -1,1301 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M. Werner
- contents/description: Scale factor estimation
-
-******************************************************************************/
-
-#include "sf_estim.h"
-#include "aacEnc_rom.h"
-#include "quantize.h"
-#include "bit_cnt.h"
-
-
-
-
-#define AS_PE_FAC_SHIFT 7
-#define DIST_FAC_SHIFT 3
-#define AS_PE_FAC_FLOAT (float)(1 << AS_PE_FAC_SHIFT)
-static const INT MAX_SCF_DELTA = 60;
-
-
-static const FIXP_DBL PE_C1 = FL2FXCONST_DBL(3.0f/AS_PE_FAC_FLOAT); /* (log(8.0)/log(2)) >> AS_PE_FAC_SHIFT */
-static const FIXP_DBL PE_C2 = FL2FXCONST_DBL(1.3219281f/AS_PE_FAC_FLOAT); /* (log(2.5)/log(2)) >> AS_PE_FAC_SHIFT */
-static const FIXP_DBL PE_C3 = FL2FXCONST_DBL(0.5593573f); /* 1-C2/C1 */
-
-
-/*
- Function; FDKaacEnc_FDKaacEnc_CalcFormFactorChannel
-
- Description: Calculates the formfactor
-
- sf: scale factor of the mdct spectrum
- sfbFormFactorLdData is scaled with the factor 1/(((2^sf)^0.5) * (2^FORM_FAC_SHIFT))
-*/
-static void
-FDKaacEnc_FDKaacEnc_CalcFormFactorChannel(FIXP_DBL *RESTRICT sfbFormFactorLdData,
- PSY_OUT_CHANNEL *RESTRICT psyOutChan)
-{
- INT j, sfb, sfbGrp;
- FIXP_DBL formFactor;
-
- int tmp0 = psyOutChan->sfbCnt;
- int tmp1 = psyOutChan->maxSfbPerGroup;
- int step = psyOutChan->sfbPerGroup;
- for(sfbGrp = 0; sfbGrp < tmp0; sfbGrp += step) {
- for (sfb = 0; sfb < tmp1; sfb++) {
- formFactor = FL2FXCONST_DBL(0.0f);
- /* calc sum of sqrt(spec) */
- for(j=psyOutChan->sfbOffsets[sfbGrp+sfb]; j<psyOutChan->sfbOffsets[sfbGrp+sfb+1]; j++ ) {
- formFactor += sqrtFixp(fixp_abs(psyOutChan->mdctSpectrum[j]))>>FORM_FAC_SHIFT;
- }
- sfbFormFactorLdData[sfbGrp+sfb] = CalcLdData(formFactor);
- }
- /* set sfbFormFactor for sfbs with zero spec to zero. Just for debugging. */
- for ( ; sfb < psyOutChan->sfbPerGroup; sfb++) {
- sfbFormFactorLdData[sfbGrp+sfb] = FL2FXCONST_DBL(-1.0f);
- }
- }
-}
-
-/*
- Function: FDKaacEnc_CalcFormFactor
-
- Description: Calls FDKaacEnc_FDKaacEnc_CalcFormFactorChannel() for each channel
-*/
-
-void
-FDKaacEnc_CalcFormFactor(QC_OUT_CHANNEL *qcOutChannel[(2)],
- PSY_OUT_CHANNEL *psyOutChannel[(2)],
- const INT nChannels)
-{
- INT j;
- for (j=0; j<nChannels; j++) {
- FDKaacEnc_FDKaacEnc_CalcFormFactorChannel(qcOutChannel[j]->sfbFormFactorLdData, psyOutChannel[j]);
- }
-}
-
-/*
- Function: FDKaacEnc_calcSfbRelevantLines
-
- Description: Calculates sfbNRelevantLines
-
- sfbNRelevantLines is scaled with the factor 1/((2^FORM_FAC_SHIFT) * 2.0)
-*/
-static void
-FDKaacEnc_calcSfbRelevantLines( const FIXP_DBL *const sfbFormFactorLdData,
- const FIXP_DBL *const sfbEnergyLdData,
- const FIXP_DBL *const sfbThresholdLdData,
- const INT *const sfbOffsets,
- const INT sfbCnt,
- const INT sfbPerGroup,
- const INT maxSfbPerGroup,
- FIXP_DBL *sfbNRelevantLines)
-{
- INT sfbOffs, sfb;
- FIXP_DBL sfbWidthLdData;
- FIXP_DBL asPeFacLdData = FL2FXCONST_DBL(0.109375); /* AS_PE_FAC_SHIFT*ld64(2) */
- FIXP_DBL accu;
-
- /* sfbNRelevantLines[i] = 2^( (sfbFormFactorLdData[i] - 0.25 * (sfbEnergyLdData[i] - ld64(sfbWidth[i]/(2^7)) - AS_PE_FAC_SHIFT*ld64(2)) * 64); */
-
- FDKmemclear(sfbNRelevantLines, sfbCnt * sizeof(FIXP_DBL));
-
- for (sfbOffs=0; sfbOffs<sfbCnt; sfbOffs+=sfbPerGroup) {
- for(sfb=0; sfb<maxSfbPerGroup; sfb++) {
- /* calc sum of sqrt(spec) */
- if((FIXP_DBL)sfbEnergyLdData[sfbOffs+sfb] > (FIXP_DBL)sfbThresholdLdData[sfbOffs+sfb]) {
- INT sfbWidth = sfbOffsets[sfbOffs+sfb+1] - sfbOffsets[sfbOffs+sfb];
-
- /* avgFormFactorLdData = sqrtFixp(sqrtFixp(sfbEnergyLdData[sfbOffs+sfb]/sfbWidth)); */
- /* sfbNRelevantLines[sfbOffs+sfb] = sfbFormFactor[sfbOffs+sfb] / avgFormFactorLdData; */
- sfbWidthLdData = (FIXP_DBL)(sfbWidth << (DFRACT_BITS-1-AS_PE_FAC_SHIFT));
- sfbWidthLdData = CalcLdData(sfbWidthLdData);
-
- accu = sfbEnergyLdData[sfbOffs+sfb] - sfbWidthLdData - asPeFacLdData;
- accu = sfbFormFactorLdData[sfbOffs+sfb] - (accu >> 2);
-
- sfbNRelevantLines[sfbOffs+sfb] = CalcInvLdData(accu) >> 1;
- }
- }
- }
-}
-
-/*
- Function: FDKaacEnc_countSingleScfBits
-
- Description:
-
- scfBitsFract is scaled by 1/(2^(2*AS_PE_FAC_SHIFT))
-*/
-static FIXP_DBL FDKaacEnc_countSingleScfBits(INT scf, INT scfLeft, INT scfRight)
-{
- FIXP_DBL scfBitsFract;
-
- scfBitsFract = (FIXP_DBL) ( FDKaacEnc_bitCountScalefactorDelta(scfLeft-scf)
- + FDKaacEnc_bitCountScalefactorDelta(scf-scfRight) );
-
- scfBitsFract = scfBitsFract << (DFRACT_BITS-1-(2*AS_PE_FAC_SHIFT));
-
- return scfBitsFract; /* output scaled by 1/(2^(2*AS_PE_FAC)) */
-}
-
-/*
- Function: FDKaacEnc_calcSingleSpecPe
-
- specPe is scaled by 1/(2^(2*AS_PE_FAC_SHIFT))
-*/
-static FIXP_DBL FDKaacEnc_calcSingleSpecPe(INT scf, FIXP_DBL sfbConstPePart, FIXP_DBL nLines)
-{
- FIXP_DBL specPe = FL2FXCONST_DBL(0.0f);
- FIXP_DBL ldRatio;
- FIXP_DBL scfFract;
-
- scfFract = (FIXP_DBL)(scf << (DFRACT_BITS-1-AS_PE_FAC_SHIFT));
-
- ldRatio = sfbConstPePart - fMult(FL2FXCONST_DBL(0.375f),scfFract);
-
- if (ldRatio >= PE_C1) {
- specPe = fMult(FL2FXCONST_DBL(0.7f),fMult(nLines,ldRatio));
- }
- else {
- specPe = fMult(FL2FXCONST_DBL(0.7f),fMult(nLines,(PE_C2 + fMult(PE_C3,ldRatio))));
- }
-
- return specPe; /* output scaled by 1/(2^(2*AS_PE_FAC)) */
-}
-
-/*
- Function: FDKaacEnc_countScfBitsDiff
-
- scfBitsDiff is scaled by 1/(2^(2*AS_PE_FAC_SHIFT))
-*/
-static FIXP_DBL FDKaacEnc_countScfBitsDiff(INT *scfOld,
- INT *scfNew,
- INT sfbCnt,
- INT startSfb,
- INT stopSfb)
-{
- FIXP_DBL scfBitsFract;
- INT scfBitsDiff = 0;
- INT sfb = 0, sfbLast;
- INT sfbPrev, sfbNext;
-
- /* search for first relevant sfb */
- sfbLast = startSfb;
- while ((sfbLast<stopSfb) && (scfOld[sfbLast]==FDK_INT_MIN))
- sfbLast++;
- /* search for previous relevant sfb and count diff */
- sfbPrev = startSfb - 1;
- while ((sfbPrev>=0) && (scfOld[sfbPrev]==FDK_INT_MIN))
- sfbPrev--;
- if (sfbPrev>=0)
- scfBitsDiff += FDKaacEnc_bitCountScalefactorDelta(scfNew[sfbPrev]-scfNew[sfbLast]) -
- FDKaacEnc_bitCountScalefactorDelta(scfOld[sfbPrev]-scfOld[sfbLast]);
- /* now loop through all sfbs and count diffs of relevant sfbs */
- for (sfb=sfbLast+1; sfb<stopSfb; sfb++) {
- if (scfOld[sfb]!=FDK_INT_MIN) {
- scfBitsDiff += FDKaacEnc_bitCountScalefactorDelta(scfNew[sfbLast]-scfNew[sfb]) -
- FDKaacEnc_bitCountScalefactorDelta(scfOld[sfbLast]-scfOld[sfb]);
- sfbLast = sfb;
- }
- }
- /* search for next relevant sfb and count diff */
- sfbNext = stopSfb;
- while ((sfbNext<sfbCnt) && (scfOld[sfbNext]==FDK_INT_MIN))
- sfbNext++;
- if (sfbNext<sfbCnt)
- scfBitsDiff += FDKaacEnc_bitCountScalefactorDelta(scfNew[sfbLast]-scfNew[sfbNext]) -
- FDKaacEnc_bitCountScalefactorDelta(scfOld[sfbLast]-scfOld[sfbNext]);
-
- scfBitsFract = (FIXP_DBL) (scfBitsDiff << (DFRACT_BITS-1-(2*AS_PE_FAC_SHIFT)));
-
- return scfBitsFract;
-}
-
-/*
- Function: FDKaacEnc_calcSpecPeDiff
-
- specPeDiff is scaled by 1/(2^(2*AS_PE_FAC_SHIFT))
-*/
-static FIXP_DBL FDKaacEnc_calcSpecPeDiff(PSY_OUT_CHANNEL *psyOutChan,
- QC_OUT_CHANNEL *qcOutChannel,
- INT *scfOld,
- INT *scfNew,
- FIXP_DBL *sfbConstPePart,
- FIXP_DBL *sfbFormFactorLdData,
- FIXP_DBL *sfbNRelevantLines,
- INT startSfb,
- INT stopSfb)
-{
- FIXP_DBL specPeDiff = FL2FXCONST_DBL(0.0f);
- FIXP_DBL scfFract = FL2FXCONST_DBL(0.0f);
- INT sfb;
-
- /* loop through all sfbs and count pe difference */
- for (sfb=startSfb; sfb<stopSfb; sfb++) {
- if (scfOld[sfb]!=FDK_INT_MIN) {
- FIXP_DBL ldRatioOld, ldRatioNew, pOld, pNew;
-
- /* sfbConstPePart[sfb] = (float)log(psyOutChan->sfbEnergy[sfb] * 6.75f / sfbFormFactor[sfb]) * LOG2_1; */
- /* 0.02152255861f = log(6.75)/log(2)/AS_PE_FAC_FLOAT; LOG2_1 is 1.0 for log2 */
- /* 0.09375f = log(64.0)/log(2.0)/64.0 = scale of sfbFormFactorLdData */
- if (sfbConstPePart[sfb] == (FIXP_DBL)FDK_INT_MIN)
- sfbConstPePart[sfb] = ((psyOutChan->sfbEnergyLdData[sfb] - sfbFormFactorLdData[sfb] - FL2FXCONST_DBL(0.09375f)) >> 1) + FL2FXCONST_DBL(0.02152255861f);
-
- scfFract = (FIXP_DBL) (scfOld[sfb] << (DFRACT_BITS-1-AS_PE_FAC_SHIFT));
- ldRatioOld = sfbConstPePart[sfb] - fMult(FL2FXCONST_DBL(0.375f),scfFract);
-
- scfFract = (FIXP_DBL) (scfNew[sfb] << (DFRACT_BITS-1-AS_PE_FAC_SHIFT));
- ldRatioNew = sfbConstPePart[sfb] - fMult(FL2FXCONST_DBL(0.375f),scfFract);
-
- if (ldRatioOld >= PE_C1)
- pOld = ldRatioOld;
- else
- pOld = PE_C2 + fMult(PE_C3,ldRatioOld);
-
- if (ldRatioNew >= PE_C1)
- pNew = ldRatioNew;
- else
- pNew = PE_C2 + fMult(PE_C3,ldRatioNew);
-
- specPeDiff += fMult(FL2FXCONST_DBL(0.7f),fMult(sfbNRelevantLines[sfb],(pNew - pOld)));
- }
- }
-
- return specPeDiff;
-}
-
-/*
- Function: FDKaacEnc_improveScf
-
- Description: Calculate the distortion by quantization and inverse quantization of the spectrum with
- various scalefactors. The scalefactor which provides the best results will be used.
-*/
-static INT FDKaacEnc_improveScf(FIXP_DBL *spec,
- SHORT *quantSpec,
- SHORT *quantSpecTmp,
- INT sfbWidth,
- FIXP_DBL threshLdData,
- INT scf,
- INT minScf,
- FIXP_DBL *distLdData,
- INT *minScfCalculated
- )
-{
- FIXP_DBL sfbDistLdData;
- INT scfBest = scf;
- INT k;
- FIXP_DBL distFactorLdData = FL2FXCONST_DBL(-0.0050301265); /* ld64(1/1.25) */
-
- /* calc real distortion */
- sfbDistLdData = FDKaacEnc_calcSfbDist(spec,
- quantSpec,
- sfbWidth,
- scf);
- *minScfCalculated = scf;
- /* nmr > 1.25 -> try to improve nmr */
- if (sfbDistLdData > (threshLdData-distFactorLdData)) {
- INT scfEstimated = scf;
- FIXP_DBL sfbDistBestLdData = sfbDistLdData;
- INT cnt;
- /* improve by bigger scf ? */
- cnt = 0;
-
- while ((sfbDistLdData > (threshLdData-distFactorLdData)) && (cnt++ < 3)) {
- scf++;
- sfbDistLdData = FDKaacEnc_calcSfbDist(spec,
- quantSpecTmp,
- sfbWidth,
- scf);
-
- if (sfbDistLdData < sfbDistBestLdData) {
- scfBest = scf;
- sfbDistBestLdData = sfbDistLdData;
- for (k=0; k<sfbWidth; k++)
- quantSpec[k] = quantSpecTmp[k];
- }
- }
- /* improve by smaller scf ? */
- cnt = 0;
- scf = scfEstimated;
- sfbDistLdData = sfbDistBestLdData;
- while ((sfbDistLdData > (threshLdData-distFactorLdData)) && (cnt++ < 1) && (scf > minScf)) {
- scf--;
- sfbDistLdData = FDKaacEnc_calcSfbDist(spec,
- quantSpecTmp,
- sfbWidth,
- scf);
-
- if (sfbDistLdData < sfbDistBestLdData) {
- scfBest = scf;
- sfbDistBestLdData = sfbDistLdData;
- for (k=0; k<sfbWidth; k++)
- quantSpec[k] = quantSpecTmp[k];
- }
- *minScfCalculated = scf;
- }
- *distLdData = sfbDistBestLdData;
- }
- else { /* nmr <= 1.25 -> try to find bigger scf to use less bits */
- FIXP_DBL sfbDistBestLdData = sfbDistLdData;
- FIXP_DBL sfbDistAllowedLdData = fixMin(sfbDistLdData-distFactorLdData,threshLdData);
- int cnt;
- for (cnt=0; cnt<3; cnt++) {
- scf++;
- sfbDistLdData = FDKaacEnc_calcSfbDist(spec,
- quantSpecTmp,
- sfbWidth,
- scf);
-
- if (sfbDistLdData < sfbDistAllowedLdData) {
- *minScfCalculated = scfBest+1;
- scfBest = scf;
- sfbDistBestLdData = sfbDistLdData;
- for (k=0; k<sfbWidth; k++)
- quantSpec[k] = quantSpecTmp[k];
- }
- }
- *distLdData = sfbDistBestLdData;
- }
-
- /* return best scalefactor */
- return scfBest;
-}
-
-/*
- Function: FDKaacEnc_assimilateSingleScf
-
-*/
-static void FDKaacEnc_assimilateSingleScf(PSY_OUT_CHANNEL *psyOutChan,
- QC_OUT_CHANNEL *qcOutChannel,
- SHORT *quantSpec,
- SHORT *quantSpecTmp,
- INT *scf,
- INT *minScf,
- FIXP_DBL *sfbDist,
- FIXP_DBL *sfbConstPePart,
- FIXP_DBL *sfbFormFactorLdData,
- FIXP_DBL *sfbNRelevantLines,
- INT *minScfCalculated,
- INT restartOnSuccess)
-{
- INT sfbLast, sfbAct, sfbNext;
- INT scfAct, *scfLast, *scfNext, scfMin, scfMax;
- INT sfbWidth, sfbOffs;
- FIXP_DBL enLdData;
- FIXP_DBL sfbPeOld, sfbPeNew;
- FIXP_DBL sfbDistNew;
- INT i, k;
- INT success = 0;
- FIXP_DBL deltaPe = FL2FXCONST_DBL(0.0f);
- FIXP_DBL deltaPeNew, deltaPeTmp;
- INT prevScfLast[MAX_GROUPED_SFB], prevScfNext[MAX_GROUPED_SFB];
- FIXP_DBL deltaPeLast[MAX_GROUPED_SFB];
- INT updateMinScfCalculated;
-
- for (i=0; i<psyOutChan->sfbCnt; i++) {
- prevScfLast[i] = FDK_INT_MAX;
- prevScfNext[i] = FDK_INT_MAX;
- deltaPeLast[i] = (FIXP_DBL)FDK_INT_MAX;
- }
-
- sfbLast = -1;
- sfbAct = -1;
- sfbNext = -1;
- scfLast = 0;
- scfNext = 0;
- scfMin = FDK_INT_MAX;
- scfMax = FDK_INT_MAX;
- do {
- /* search for new relevant sfb */
- sfbNext++;
- while ((sfbNext < psyOutChan->sfbCnt) && (scf[sfbNext] == FDK_INT_MIN))
- sfbNext++;
- if ((sfbLast>=0) && (sfbAct>=0) && (sfbNext<psyOutChan->sfbCnt)) {
- /* relevant scfs to the left and to the right */
- scfAct = scf[sfbAct];
- scfLast = scf + sfbLast;
- scfNext = scf + sfbNext;
- scfMin = fixMin(*scfLast, *scfNext);
- scfMax = fixMax(*scfLast, *scfNext);
- }
- else if ((sfbLast==-1) && (sfbAct>=0) && (sfbNext<psyOutChan->sfbCnt)) {
- /* first relevant scf */
- scfAct = scf[sfbAct];
- scfLast = &scfAct;
- scfNext = scf + sfbNext;
- scfMin = *scfNext;
- scfMax = *scfNext;
- }
- else if ((sfbLast>=0) && (sfbAct>=0) && (sfbNext==psyOutChan->sfbCnt)) {
- /* last relevant scf */
- scfAct = scf[sfbAct];
- scfLast = scf + sfbLast;
- scfNext = &scfAct;
- scfMin = *scfLast;
- scfMax = *scfLast;
- }
- if (sfbAct>=0)
- scfMin = fixMax(scfMin, minScf[sfbAct]);
-
- if ((sfbAct >= 0) &&
- (sfbLast>=0 || sfbNext<psyOutChan->sfbCnt) &&
- (scfAct > scfMin) &&
- (scfAct <= scfMin+MAX_SCF_DELTA) &&
- (scfAct >= scfMax-MAX_SCF_DELTA) &&
- (*scfLast != prevScfLast[sfbAct] ||
- *scfNext != prevScfNext[sfbAct] ||
- deltaPe < deltaPeLast[sfbAct])) {
- /* bigger than neighbouring scf found, try to use smaller scf */
- success = 0;
-
- sfbWidth = psyOutChan->sfbOffsets[sfbAct+1] - psyOutChan->sfbOffsets[sfbAct];
- sfbOffs = psyOutChan->sfbOffsets[sfbAct];
-
- /* estimate required bits for actual scf */
- enLdData = qcOutChannel->sfbEnergyLdData[sfbAct];
-
- /* sfbConstPePart[sfbAct] = (float)log(6.75f*en/sfbFormFactor[sfbAct]) * LOG2_1; */
- /* 0.02152255861f = log(6.75)/log(2)/AS_PE_FAC_FLOAT; LOG2_1 is 1.0 for log2 */
- /* 0.09375f = log(64.0)/log(2.0)/64.0 = scale of sfbFormFactorLdData */
- if (sfbConstPePart[sfbAct] == (FIXP_DBL)FDK_INT_MIN) {
- sfbConstPePart[sfbAct] = ((enLdData - sfbFormFactorLdData[sfbAct] - FL2FXCONST_DBL(0.09375f)) >> 1) + FL2FXCONST_DBL(0.02152255861f);
- }
-
- sfbPeOld = FDKaacEnc_calcSingleSpecPe(scfAct,sfbConstPePart[sfbAct],sfbNRelevantLines[sfbAct])
- +FDKaacEnc_countSingleScfBits(scfAct, *scfLast, *scfNext);
-
- deltaPeNew = deltaPe;
- updateMinScfCalculated = 1;
-
- do {
- /* estimate required bits for smaller scf */
- scfAct--;
- /* check only if the same check was not done before */
- if (scfAct < minScfCalculated[sfbAct] && scfAct>=scfMax-MAX_SCF_DELTA){
- /* estimate required bits for new scf */
- sfbPeNew = FDKaacEnc_calcSingleSpecPe(scfAct,sfbConstPePart[sfbAct],sfbNRelevantLines[sfbAct])
- +FDKaacEnc_countSingleScfBits(scfAct,*scfLast, *scfNext);
-
- /* use new scf if no increase in pe and
- quantization error is smaller */
- deltaPeTmp = deltaPe + sfbPeNew - sfbPeOld;
- /* 0.0006103515625f = 10.0f/(2^(2*AS_PE_FAC_SHIFT)) */
- if (deltaPeTmp < FL2FXCONST_DBL(0.0006103515625f)) {
- /* distortion of new scf */
- sfbDistNew = FDKaacEnc_calcSfbDist(qcOutChannel->mdctSpectrum+sfbOffs,
- quantSpecTmp+sfbOffs,
- sfbWidth,
- scfAct);
-
- if (sfbDistNew < sfbDist[sfbAct]) {
- /* success, replace scf by new one */
- scf[sfbAct] = scfAct;
- sfbDist[sfbAct] = sfbDistNew;
-
- for (k=0; k<sfbWidth; k++)
- quantSpec[sfbOffs+k] = quantSpecTmp[sfbOffs+k];
-
- deltaPeNew = deltaPeTmp;
- success = 1;
- }
- /* mark as already checked */
- if (updateMinScfCalculated)
- minScfCalculated[sfbAct] = scfAct;
- }
- else {
- /* from this scf value on not all new values have been checked */
- updateMinScfCalculated = 0;
- }
- }
- } while (scfAct > scfMin);
-
- deltaPe = deltaPeNew;
-
- /* save parameters to avoid multiple computations of the same sfb */
- prevScfLast[sfbAct] = *scfLast;
- prevScfNext[sfbAct] = *scfNext;
- deltaPeLast[sfbAct] = deltaPe;
- }
-
- if (success && restartOnSuccess) {
- /* start again at first sfb */
- sfbLast = -1;
- sfbAct = -1;
- sfbNext = -1;
- scfLast = 0;
- scfNext = 0;
- scfMin = FDK_INT_MAX;
- scfMax = FDK_INT_MAX;
- success = 0;
- }
- else {
- /* shift sfbs for next band */
- sfbLast = sfbAct;
- sfbAct = sfbNext;
- }
- } while (sfbNext < psyOutChan->sfbCnt);
-}
-
-/*
- Function: FDKaacEnc_assimilateMultipleScf
-
-*/
-static void FDKaacEnc_assimilateMultipleScf(PSY_OUT_CHANNEL *psyOutChan,
- QC_OUT_CHANNEL *qcOutChannel,
- SHORT *quantSpec,
- SHORT *quantSpecTmp,
- INT *scf,
- INT *minScf,
- FIXP_DBL *sfbDist,
- FIXP_DBL *sfbConstPePart,
- FIXP_DBL *sfbFormFactorLdData,
- FIXP_DBL *sfbNRelevantLines)
-{
- INT sfb, startSfb, stopSfb;
- INT scfTmp[MAX_GROUPED_SFB], scfMin, scfMax, scfAct;
- INT possibleRegionFound;
- INT sfbWidth, sfbOffs, i, k;
- FIXP_DBL sfbDistNew[MAX_GROUPED_SFB], distOldSum, distNewSum;
- INT deltaScfBits;
- FIXP_DBL deltaSpecPe;
- FIXP_DBL deltaPe = FL2FXCONST_DBL(0.0f);
- FIXP_DBL deltaPeNew;
- INT sfbCnt = psyOutChan->sfbCnt;
-
- /* calc min and max scalfactors */
- scfMin = FDK_INT_MAX;
- scfMax = FDK_INT_MIN;
- for (sfb=0; sfb<sfbCnt; sfb++) {
- if (scf[sfb]!=FDK_INT_MIN) {
- scfMin = fixMin(scfMin, scf[sfb]);
- scfMax = fixMax(scfMax, scf[sfb]);
- }
- }
-
- if (scfMax != FDK_INT_MIN && scfMax <= scfMin+MAX_SCF_DELTA) {
-
- scfAct = scfMax;
-
- do {
- /* try smaller scf */
- scfAct--;
- for (i=0; i<MAX_GROUPED_SFB; i++)
- scfTmp[i] = scf[i];
- stopSfb = 0;
- do {
- /* search for region where all scfs are bigger than scfAct */
- sfb = stopSfb;
- while (sfb<sfbCnt && (scf[sfb]==FDK_INT_MIN || scf[sfb] <= scfAct))
- sfb++;
- startSfb = sfb;
- sfb++;
- while (sfb<sfbCnt && (scf[sfb]==FDK_INT_MIN || scf[sfb] > scfAct))
- sfb++;
- stopSfb = sfb;
-
- /* check if in all sfb of a valid region scfAct >= minScf[sfb] */
- possibleRegionFound = 0;
- if (startSfb < sfbCnt) {
- possibleRegionFound = 1;
- for (sfb=startSfb; sfb<stopSfb; sfb++) {
- if (scf[sfb] != FDK_INT_MIN)
- if (scfAct < minScf[sfb]) {
- possibleRegionFound = 0;
- break;
- }
- }
- }
-
- if (possibleRegionFound) { /* region found */
-
- /* replace scfs in region by scfAct */
- for (sfb=startSfb; sfb<stopSfb; sfb++) {
- if (scfTmp[sfb] != FDK_INT_MIN)
- scfTmp[sfb] = scfAct;
- }
-
- /* estimate change in bit demand for new scfs */
- deltaScfBits = FDKaacEnc_countScfBitsDiff(scf,scfTmp,sfbCnt,startSfb,stopSfb);
-
- deltaSpecPe = FDKaacEnc_calcSpecPeDiff(psyOutChan, qcOutChannel, scf, scfTmp, sfbConstPePart,
- sfbFormFactorLdData, sfbNRelevantLines,
- startSfb, stopSfb);
-
- deltaPeNew = deltaPe + (FIXP_DBL)deltaScfBits + deltaSpecPe;
-
- /* new bit demand small enough ? */
- /* 0.0006103515625f = 10.0f/(2^(2*AS_PE_FAC_SHIFT)) */
- if (deltaPeNew < FL2FXCONST_DBL(0.0006103515625f)) {
-
- /* quantize and calc sum of new distortion */
- distOldSum = distNewSum = FL2FXCONST_DBL(0.0f);
- for (sfb=startSfb; sfb<stopSfb; sfb++) {
- if (scfTmp[sfb] != FDK_INT_MIN) {
- distOldSum += CalcInvLdData(sfbDist[sfb]) >> DIST_FAC_SHIFT;
-
- sfbWidth = psyOutChan->sfbOffsets[sfb+1] - psyOutChan->sfbOffsets[sfb];
- sfbOffs = psyOutChan->sfbOffsets[sfb];
-
- sfbDistNew[sfb] = FDKaacEnc_calcSfbDist(qcOutChannel->mdctSpectrum+sfbOffs,
- quantSpecTmp+sfbOffs,
- sfbWidth,
- scfAct);
-
- if (sfbDistNew[sfb] >qcOutChannel->sfbThresholdLdData[sfb]) {
- /* no improvement, skip further dist. calculations */
- distNewSum = distOldSum << 1;
- break;
- }
- distNewSum += CalcInvLdData(sfbDistNew[sfb]) >> DIST_FAC_SHIFT;
- }
- }
- /* distortion smaller ? -> use new scalefactors */
- if (distNewSum < distOldSum) {
- deltaPe = deltaPeNew;
- for (sfb=startSfb; sfb<stopSfb; sfb++) {
- if (scf[sfb] != FDK_INT_MIN) {
- sfbWidth = psyOutChan->sfbOffsets[sfb+1] -
- psyOutChan->sfbOffsets[sfb];
- sfbOffs = psyOutChan->sfbOffsets[sfb];
- scf[sfb] = scfAct;
- sfbDist[sfb] = sfbDistNew[sfb];
-
- for (k=0; k<sfbWidth; k++)
- quantSpec[sfbOffs+k] = quantSpecTmp[sfbOffs+k];
- }
- }
- }
-
- }
- }
-
- } while (stopSfb <= sfbCnt);
-
- } while (scfAct > scfMin);
- }
-}
-
-/*
- Function: FDKaacEnc_FDKaacEnc_assimilateMultipleScf2
-
-*/
-static void FDKaacEnc_FDKaacEnc_assimilateMultipleScf2(PSY_OUT_CHANNEL *psyOutChan,
- QC_OUT_CHANNEL *qcOutChannel,
- SHORT *quantSpec,
- SHORT *quantSpecTmp,
- INT *scf,
- INT *minScf,
- FIXP_DBL *sfbDist,
- FIXP_DBL *sfbConstPePart,
- FIXP_DBL *sfbFormFactorLdData,
- FIXP_DBL *sfbNRelevantLines)
-{
- INT sfb, startSfb, stopSfb;
- INT scfTmp[MAX_GROUPED_SFB], scfAct, scfNew;
- INT scfPrev, scfNext, scfPrevNextMin, scfPrevNextMax, scfLo, scfHi;
- INT scfMin, scfMax;
- INT *sfbOffs = psyOutChan->sfbOffsets;
- FIXP_DBL sfbDistNew[MAX_GROUPED_SFB], sfbDistMax[MAX_GROUPED_SFB];
- FIXP_DBL distOldSum, distNewSum;
- INT deltaScfBits;
- FIXP_DBL deltaSpecPe;
- FIXP_DBL deltaPe = FL2FXCONST_DBL(0.0f);
- FIXP_DBL deltaPeNew = FL2FXCONST_DBL(0.0f);
- INT sfbCnt = psyOutChan->sfbCnt;
- INT bSuccess, bCheckScf;
- INT i,k;
-
- /* calc min and max scalfactors */
- scfMin = FDK_INT_MAX;
- scfMax = FDK_INT_MIN;
- for (sfb=0; sfb<sfbCnt; sfb++) {
- if (scf[sfb]!=FDK_INT_MIN) {
- scfMin = fixMin(scfMin, scf[sfb]);
- scfMax = fixMax(scfMax, scf[sfb]);
- }
- }
-
- stopSfb = 0;
- scfAct = FDK_INT_MIN;
- do {
- /* search for region with same scf values scfAct */
- scfPrev = scfAct;
-
- sfb = stopSfb;
- while (sfb<sfbCnt && (scf[sfb]==FDK_INT_MIN))
- sfb++;
- startSfb = sfb;
- scfAct = scf[startSfb];
- sfb++;
- while (sfb<sfbCnt && ((scf[sfb]==FDK_INT_MIN) || (scf[sfb]==scf[startSfb])))
- sfb++;
- stopSfb = sfb;
-
- if (stopSfb < sfbCnt)
- scfNext = scf[stopSfb];
- else
- scfNext = scfAct;
-
- if (scfPrev == FDK_INT_MIN)
- scfPrev = scfAct;
-
- scfPrevNextMax = fixMax(scfPrev, scfNext);
- scfPrevNextMin = fixMin(scfPrev, scfNext);
-
- /* try to reduce bits by checking scf values in the range
- scf[startSfb]...scfHi */
- scfHi = fixMax(scfPrevNextMax, scfAct);
- /* try to find a better solution by reducing the scf difference to
- the nearest possible lower scf */
- if (scfPrevNextMax >= scfAct)
- scfLo = fixMin(scfAct, scfPrevNextMin);
- else
- scfLo = scfPrevNextMax;
-
- if (startSfb < sfbCnt && scfHi-scfLo <= MAX_SCF_DELTA) { /* region found */
- /* 1. try to save bits by coarser quantization */
- if (scfHi > scf[startSfb]) {
- /* calculate the allowed distortion */
- for (sfb=startSfb; sfb<stopSfb; sfb++) {
- if (scf[sfb] != FDK_INT_MIN) {
- /* sfbDistMax[sfb] = (float)pow(qcOutChannel->sfbThreshold[sfb]*sfbDist[sfb]*sfbDist[sfb],1.0f/3.0f); */
- /* sfbDistMax[sfb] = fixMax(sfbDistMax[sfb],qcOutChannel->sfbEnergy[sfb]*FL2FXCONST_DBL(1.e-3f)); */
- /* -0.15571537944 = ld64(1.e-3f)*/
- sfbDistMax[sfb] = fMult(FL2FXCONST_DBL(1.0f/3.0f),qcOutChannel->sfbThresholdLdData[sfb])+fMult(FL2FXCONST_DBL(1.0f/3.0f),sfbDist[sfb])+fMult(FL2FXCONST_DBL(1.0f/3.0f),sfbDist[sfb]);
- sfbDistMax[sfb] = fixMax(sfbDistMax[sfb],qcOutChannel->sfbEnergyLdData[sfb]-FL2FXCONST_DBL(0.15571537944));
- sfbDistMax[sfb] = fixMin(sfbDistMax[sfb],qcOutChannel->sfbThresholdLdData[sfb]);
- }
- }
-
- /* loop over all possible scf values for this region */
- bCheckScf = 1;
- for (scfNew=scf[startSfb]+1; scfNew<=scfHi; scfNew++) {
- for (k=0; k<MAX_GROUPED_SFB; k++)
- scfTmp[k] = scf[k];
-
- /* replace scfs in region by scfNew */
- for (sfb=startSfb; sfb<stopSfb; sfb++) {
- if (scfTmp[sfb] != FDK_INT_MIN)
- scfTmp[sfb] = scfNew;
- }
-
- /* estimate change in bit demand for new scfs */
- deltaScfBits = FDKaacEnc_countScfBitsDiff(scf,scfTmp,sfbCnt,startSfb,stopSfb);
-
- deltaSpecPe = FDKaacEnc_calcSpecPeDiff(psyOutChan, qcOutChannel, scf, scfTmp, sfbConstPePart,
- sfbFormFactorLdData, sfbNRelevantLines,
- startSfb, stopSfb);
-
- deltaPeNew = deltaPe + (FIXP_DBL)deltaScfBits + deltaSpecPe;
-
- /* new bit demand small enough ? */
- if (deltaPeNew < FL2FXCONST_DBL(0.0f)) {
- bSuccess = 1;
-
- /* quantize and calc sum of new distortion */
- for (sfb=startSfb; sfb<stopSfb; sfb++) {
- if (scfTmp[sfb] != FDK_INT_MIN) {
- sfbDistNew[sfb] = FDKaacEnc_calcSfbDist(qcOutChannel->mdctSpectrum+sfbOffs[sfb],
- quantSpecTmp+sfbOffs[sfb],
- sfbOffs[sfb+1]-sfbOffs[sfb],
- scfNew);
-
- if (sfbDistNew[sfb] > sfbDistMax[sfb]) {
- /* no improvement, skip further dist. calculations */
- bSuccess = 0;
- if (sfbDistNew[sfb] == qcOutChannel->sfbEnergyLdData[sfb]) {
- /* if whole sfb is already quantized to 0, further
- checks with even coarser quant. are useless*/
- bCheckScf = 0;
- }
- break;
- }
- }
- }
- if (bCheckScf==0) /* further calculations useless ? */
- break;
- /* distortion small enough ? -> use new scalefactors */
- if (bSuccess) {
- deltaPe = deltaPeNew;
- for (sfb=startSfb; sfb<stopSfb; sfb++) {
- if (scf[sfb] != FDK_INT_MIN) {
- scf[sfb] = scfNew;
- sfbDist[sfb] = sfbDistNew[sfb];
-
- for (k=0; k<sfbOffs[sfb+1]-sfbOffs[sfb]; k++)
- quantSpec[sfbOffs[sfb]+k] = quantSpecTmp[sfbOffs[sfb]+k];
- }
- }
- }
- }
- }
- }
-
- /* 2. only if coarser quantization was not successful, try to find
- a better solution by finer quantization and reducing bits for
- scalefactor coding */
- if (scfAct==scf[startSfb] &&
- scfLo < scfAct &&
- scfMax-scfMin <= MAX_SCF_DELTA) {
-
- int bminScfViolation = 0;
-
- for (k=0; k<MAX_GROUPED_SFB; k++)
- scfTmp[k] = scf[k];
-
- scfNew = scfLo;
-
- /* replace scfs in region by scfNew and
- check if in all sfb scfNew >= minScf[sfb] */
- for (sfb=startSfb; sfb<stopSfb; sfb++) {
- if (scfTmp[sfb] != FDK_INT_MIN) {
- scfTmp[sfb] = scfNew;
- if (scfNew < minScf[sfb])
- bminScfViolation = 1;
- }
- }
-
- if (!bminScfViolation) {
- /* estimate change in bit demand for new scfs */
- deltaScfBits = FDKaacEnc_countScfBitsDiff(scf,scfTmp,sfbCnt,startSfb,stopSfb);
-
- deltaSpecPe = FDKaacEnc_calcSpecPeDiff(psyOutChan, qcOutChannel, scf, scfTmp, sfbConstPePart,
- sfbFormFactorLdData, sfbNRelevantLines,
- startSfb, stopSfb);
-
- deltaPeNew = deltaPe + (FIXP_DBL)deltaScfBits + deltaSpecPe;
- }
-
- /* new bit demand small enough ? */
- if (!bminScfViolation && deltaPeNew < FL2FXCONST_DBL(0.0f)) {
-
- /* quantize and calc sum of new distortion */
- distOldSum = distNewSum = FL2FXCONST_DBL(0.0f);
- for (sfb=startSfb; sfb<stopSfb; sfb++) {
- if (scfTmp[sfb] != FDK_INT_MIN) {
- distOldSum += CalcInvLdData(sfbDist[sfb]) >> DIST_FAC_SHIFT;
-
- sfbDistNew[sfb] = FDKaacEnc_calcSfbDist(qcOutChannel->mdctSpectrum+sfbOffs[sfb],
- quantSpecTmp+sfbOffs[sfb],
- sfbOffs[sfb+1]-sfbOffs[sfb],
- scfNew);
-
- if (sfbDistNew[sfb] > qcOutChannel->sfbThresholdLdData[sfb]) {
- /* no improvement, skip further dist. calculations */
- distNewSum = distOldSum << 1;
- break;
- }
- distNewSum += CalcInvLdData(sfbDistNew[sfb]) >> DIST_FAC_SHIFT;
- }
- }
- /* distortion smaller ? -> use new scalefactors */
- if (distNewSum < fMult(FL2FXCONST_DBL(0.8f),distOldSum)) {
- deltaPe = deltaPeNew;
- for (sfb=startSfb; sfb<stopSfb; sfb++) {
- if (scf[sfb] != FDK_INT_MIN) {
- scf[sfb] = scfNew;
- sfbDist[sfb] = sfbDistNew[sfb];
-
- for (k=0; k<sfbOffs[sfb+1]-sfbOffs[sfb]; k++)
- quantSpec[sfbOffs[sfb]+k] = quantSpecTmp[sfbOffs[sfb]+k];
- }
- }
- }
- }
- }
-
- /* 3. try to find a better solution (save bits) by only reducing the
- scalefactor without new quantization */
- if (scfMax-scfMin <= MAX_SCF_DELTA-3) { /* 3 bec. scf is reduced 3 times,
- see for loop below */
-
- for (k=0; k<sfbCnt; k++)
- scfTmp[k] = scf[k];
-
- for (i=0; i<3; i++) {
- scfNew = scfTmp[startSfb]-1;
- /* replace scfs in region by scfNew */
- for (sfb=startSfb; sfb<stopSfb; sfb++) {
- if (scfTmp[sfb] != FDK_INT_MIN)
- scfTmp[sfb] = scfNew;
- }
- /* estimate change in bit demand for new scfs */
- deltaScfBits = FDKaacEnc_countScfBitsDiff(scf,scfTmp,sfbCnt,startSfb,stopSfb);
- deltaPeNew = deltaPe + (FIXP_DBL)deltaScfBits;
- /* new bit demand small enough ? */
- if (deltaPeNew <= FL2FXCONST_DBL(0.0f)) {
-
- bSuccess = 1;
- distOldSum = distNewSum = FL2FXCONST_DBL(0.0f);
- for (sfb=startSfb; sfb<stopSfb; sfb++) {
- if (scfTmp[sfb] != FDK_INT_MIN) {
- FIXP_DBL sfbEnQ;
- /* calc the energy and distortion of the quantized spectrum for
- a smaller scf */
- FDKaacEnc_calcSfbQuantEnergyAndDist(qcOutChannel->mdctSpectrum+sfbOffs[sfb],
- quantSpec+sfbOffs[sfb],
- sfbOffs[sfb+1]-sfbOffs[sfb], scfNew,
- &sfbEnQ, &sfbDistNew[sfb]);
-
- distOldSum += CalcInvLdData(sfbDist[sfb]) >> DIST_FAC_SHIFT;
- distNewSum += CalcInvLdData(sfbDistNew[sfb]) >> DIST_FAC_SHIFT;
-
- /* 0.00259488556167 = ld64(1.122f) */
- /* -0.00778722686652 = ld64(0.7079f) */
- if ((sfbDistNew[sfb] > (sfbDist[sfb]+FL2FXCONST_DBL(0.00259488556167f))) || (sfbEnQ < (qcOutChannel->sfbEnergyLdData[sfb] - FL2FXCONST_DBL(0.00778722686652f)))){
- bSuccess = 0;
- break;
- }
- }
- }
- /* distortion smaller ? -> use new scalefactors */
- if (distNewSum < distOldSum && bSuccess) {
- deltaPe = deltaPeNew;
- for (sfb=startSfb; sfb<stopSfb; sfb++) {
- if (scf[sfb] != FDK_INT_MIN) {
- scf[sfb] = scfNew;
- sfbDist[sfb] = sfbDistNew[sfb];
- }
- }
- }
- }
- }
- }
- }
- } while (stopSfb <= sfbCnt);
-
-}
-
-static void
-FDKaacEnc_FDKaacEnc_EstimateScaleFactorsChannel(QC_OUT_CHANNEL *qcOutChannel,
- PSY_OUT_CHANNEL *psyOutChannel,
- INT *RESTRICT scf,
- INT *RESTRICT globalGain,
- FIXP_DBL *RESTRICT sfbFormFactorLdData
- ,const INT invQuant,
- SHORT *RESTRICT quantSpec
- )
-{
- INT i, j, sfb, sfbOffs;
- INT scfInt;
- INT maxSf;
- INT minSf;
- FIXP_DBL threshLdData;
- FIXP_DBL energyLdData;
- FIXP_DBL energyPartLdData;
- FIXP_DBL thresholdPartLdData;
- FIXP_DBL scfFract;
- FIXP_DBL maxSpec;
- FIXP_DBL absSpec;
- INT minScfCalculated[MAX_GROUPED_SFB];
- FIXP_DBL sfbDistLdData[MAX_GROUPED_SFB];
- C_ALLOC_SCRATCH_START(quantSpecTmp, SHORT, (1024));
- INT minSfMaxQuant[MAX_GROUPED_SFB];
-
- FIXP_DBL threshConstLdData=FL2FXCONST_DBL(0.04304511722f); /* log10(6.75)/log10(2.0)/64.0 */
- FIXP_DBL convConst=FL2FXCONST_DBL(0.30102999566f); /* log10(2.0) */
- FIXP_DBL c1Const=FL2FXCONST_DBL(-0.27083183594f); /* C1 = -69.33295 => C1/2^8 */
-
-
-
- if (invQuant>0) {
- FDKmemclear(quantSpec, (1024)*sizeof(SHORT));
- }
-
- /* scfs without energy or with thresh>energy are marked with FDK_INT_MIN */
- for(i=0; i<psyOutChannel->sfbCnt; i++) {
- scf[i] = FDK_INT_MIN;
- }
-
- for (i=0; i<MAX_GROUPED_SFB; i++) {
- minSfMaxQuant[i] = FDK_INT_MIN;
- }
-
- for (sfbOffs=0; sfbOffs<psyOutChannel->sfbCnt; sfbOffs+=psyOutChannel->sfbPerGroup) {
- for(sfb=0; sfb<psyOutChannel->maxSfbPerGroup; sfb++) {
-
- threshLdData = qcOutChannel->sfbThresholdLdData[sfbOffs+sfb];
- energyLdData = qcOutChannel->sfbEnergyLdData[sfbOffs+sfb];
-
- sfbDistLdData[sfbOffs+sfb] = energyLdData;
-
-
- if (energyLdData > threshLdData) {
- FIXP_DBL tmp;
-
- /* energyPart = (float)log10(sfbFormFactor[sfbOffs+sfb]); */
- /* 0.09375f = log(64.0)/log(2.0)/64.0 = scale of sfbFormFactorLdData */
- energyPartLdData = sfbFormFactorLdData[sfbOffs+sfb] + FL2FXCONST_DBL(0.09375f);
-
- /* influence of allowed distortion */
- /* thresholdPart = (float)log10(6.75*thresh+FLT_MIN); */
- thresholdPartLdData = threshConstLdData + threshLdData;
-
- /* scf calc */
- /* scfFloat = 8.8585f * (thresholdPart - energyPart); */
- scfFract = thresholdPartLdData - energyPartLdData;
- /* conversion from log2 to log10 */
- scfFract = fMult(convConst,scfFract);
- /* (8.8585f * scfFract)/8 = 8/8 * scfFract + 0.8585 * scfFract/8 */
- scfFract = scfFract + fMult(FL2FXCONST_DBL(0.8585f),scfFract >> 3);
-
- /* integer scalefactor */
- /* scfInt = (int)floor(scfFloat); */
- scfInt = (INT)(scfFract>>((DFRACT_BITS-1)-3-LD_DATA_SHIFT)); /* 3 bits => scfFract/8.0; 6 bits => ld64 */
-
- /* maximum of spectrum */
- maxSpec = FL2FXCONST_DBL(0.0f);
-
- for(j=psyOutChannel->sfbOffsets[sfbOffs+sfb]; j<psyOutChannel->sfbOffsets[sfbOffs+sfb+1]; j++ ){
- absSpec = fixp_abs(qcOutChannel->mdctSpectrum[j]);
- maxSpec = (absSpec > maxSpec) ? absSpec : maxSpec;
- }
-
- /* lower scf limit to avoid quantized values bigger than MAX_QUANT */
- /* C1 = -69.33295f, C2 = 5.77078f = 4/log(2) */
- /* minSfMaxQuant[sfbOffs+sfb] = (int)ceil(C1 + C2*log(maxSpec)); */
- /* C1/2^8 + 4/log(2.0)*log(maxSpec)/2^8 => C1/2^8 + log(maxSpec)/log(2.0)*4/2^8 => C1/2^8 + log(maxSpec)/log(2.0)/64.0 */
-
- //minSfMaxQuant[sfbOffs+sfb] = ((INT) ((c1Const + CalcLdData(maxSpec)) >> ((DFRACT_BITS-1)-8))) + 1;
- tmp = CalcLdData(maxSpec);
- if (c1Const>FL2FXCONST_DBL(-1.f)-tmp) {
- minSfMaxQuant[sfbOffs+sfb] = ((INT) ((c1Const + tmp) >> ((DFRACT_BITS-1)-8))) + 1;
- }
- else {
- minSfMaxQuant[sfbOffs+sfb] = ((INT) (FL2FXCONST_DBL(-1.f) >> ((DFRACT_BITS-1)-8))) + 1;
- }
-
- scfInt = fixMax(scfInt, minSfMaxQuant[sfbOffs+sfb]);
-
-
- /* find better scalefactor with analysis by synthesis */
- if (invQuant>0) {
- scfInt = FDKaacEnc_improveScf(qcOutChannel->mdctSpectrum+psyOutChannel->sfbOffsets[sfbOffs+sfb],
- quantSpec+psyOutChannel->sfbOffsets[sfbOffs+sfb],
- quantSpecTmp+psyOutChannel->sfbOffsets[sfbOffs+sfb],
- psyOutChannel->sfbOffsets[sfbOffs+sfb+1]-psyOutChannel->sfbOffsets[sfbOffs+sfb],
- threshLdData, scfInt, minSfMaxQuant[sfbOffs+sfb],
- &sfbDistLdData[sfbOffs+sfb], &minScfCalculated[sfbOffs+sfb]
- );
- }
- scf[sfbOffs+sfb] = scfInt;
- }
- }
- }
-
-
- if (invQuant>1) {
- /* try to decrease scf differences */
- FIXP_DBL sfbConstPePart[MAX_GROUPED_SFB];
- FIXP_DBL sfbNRelevantLines[MAX_GROUPED_SFB];
-
- for (i=0; i<psyOutChannel->sfbCnt; i++)
- sfbConstPePart[i] = (FIXP_DBL)FDK_INT_MIN;
-
- FDKaacEnc_calcSfbRelevantLines( sfbFormFactorLdData,
- qcOutChannel->sfbEnergyLdData,
- qcOutChannel->sfbThresholdLdData,
- psyOutChannel->sfbOffsets,
- psyOutChannel->sfbCnt,
- psyOutChannel->sfbPerGroup,
- psyOutChannel->maxSfbPerGroup,
- sfbNRelevantLines);
-
-
- FDKaacEnc_assimilateSingleScf(psyOutChannel, qcOutChannel, quantSpec, quantSpecTmp, scf,
- minSfMaxQuant, sfbDistLdData, sfbConstPePart,
- sfbFormFactorLdData, sfbNRelevantLines, minScfCalculated, 1);
-
-
- FDKaacEnc_assimilateMultipleScf(psyOutChannel, qcOutChannel, quantSpec, quantSpecTmp, scf,
- minSfMaxQuant, sfbDistLdData, sfbConstPePart,
- sfbFormFactorLdData, sfbNRelevantLines);
-
-
- FDKaacEnc_FDKaacEnc_assimilateMultipleScf2(psyOutChannel, qcOutChannel, quantSpec, quantSpecTmp, scf,
- minSfMaxQuant, sfbDistLdData, sfbConstPePart,
- sfbFormFactorLdData, sfbNRelevantLines);
-
- }
-
-
- /* get min scalefac */
- minSf = FDK_INT_MAX;
- for (sfbOffs=0; sfbOffs<psyOutChannel->sfbCnt; sfbOffs+=psyOutChannel->sfbPerGroup) {
- for (sfb = 0; sfb < psyOutChannel->maxSfbPerGroup; sfb++) {
- if (scf[sfbOffs+sfb]!=FDK_INT_MIN)
- minSf = fixMin(minSf,scf[sfbOffs+sfb]);
- }
- }
-
- /* limit scf delta */
- for (sfbOffs=0; sfbOffs<psyOutChannel->sfbCnt; sfbOffs+=psyOutChannel->sfbPerGroup) {
- for (sfb = 0; sfb < psyOutChannel->maxSfbPerGroup; sfb++) {
- if ((scf[sfbOffs+sfb] != FDK_INT_MIN) && (minSf+MAX_SCF_DELTA) < scf[sfbOffs+sfb]) {
- scf[sfbOffs+sfb] = minSf + MAX_SCF_DELTA;
- if (invQuant > 0) { /* changed bands need to be quantized again */
- sfbDistLdData[sfbOffs+sfb] =
- FDKaacEnc_calcSfbDist(qcOutChannel->mdctSpectrum+psyOutChannel->sfbOffsets[sfbOffs+sfb],
- quantSpec+psyOutChannel->sfbOffsets[sfbOffs+sfb],
- psyOutChannel->sfbOffsets[sfbOffs+sfb+1]-psyOutChannel->sfbOffsets[sfbOffs+sfb],
- scf[sfbOffs+sfb]
- );
- }
- }
- }
- }
-
-
- /* get max scalefac for global gain */
- maxSf = FDK_INT_MIN;
- for (sfbOffs=0; sfbOffs<psyOutChannel->sfbCnt; sfbOffs+=psyOutChannel->sfbPerGroup) {
- for (sfb = 0; sfb < psyOutChannel->maxSfbPerGroup; sfb++) {
- maxSf = fixMax(maxSf,scf[sfbOffs+sfb]);
- }
- }
-
- /* calc loop scalefactors, if spec is not all zero (i.e. maxSf == -99) */
- if( maxSf > FDK_INT_MIN ) {
- *globalGain = maxSf;
- for (sfbOffs=0; sfbOffs<psyOutChannel->sfbCnt; sfbOffs+=psyOutChannel->sfbPerGroup) {
- for (sfb = 0; sfb < psyOutChannel->maxSfbPerGroup; sfb++) {
- if( scf[sfbOffs+sfb] == FDK_INT_MIN ) {
- scf[sfbOffs+sfb] = 0;
- /* set band explicitely to zero */
- for(j=psyOutChannel->sfbOffsets[sfbOffs+sfb]; j<psyOutChannel->sfbOffsets[sfbOffs+sfb+1]; j++ ) {
- qcOutChannel->mdctSpectrum[j] = FL2FXCONST_DBL(0.0f);
- }
- }
- else {
- scf[sfbOffs+sfb] = maxSf - scf[sfbOffs+sfb];
- }
- }
- }
- }
- else{
- *globalGain = 0;
- /* set spectrum explicitely to zero */
- for (sfbOffs=0; sfbOffs<psyOutChannel->sfbCnt; sfbOffs+=psyOutChannel->sfbPerGroup) {
- for (sfb = 0; sfb < psyOutChannel->maxSfbPerGroup; sfb++) {
- scf[sfbOffs+sfb] = 0;
- /* set band explicitely to zero */
- for(j=psyOutChannel->sfbOffsets[sfbOffs+sfb]; j<psyOutChannel->sfbOffsets[sfbOffs+sfb+1]; j++ ) {
- qcOutChannel->mdctSpectrum[j] = FL2FXCONST_DBL(0.0f);
- }
- }
- }
- }
-
- /* free quantSpecTmp from scratch */
- C_ALLOC_SCRATCH_END(quantSpecTmp, SHORT, (1024));
-
-
-}
-
-void
-FDKaacEnc_EstimateScaleFactors(PSY_OUT_CHANNEL *psyOutChannel[],
- QC_OUT_CHANNEL* qcOutChannel[],
- const int invQuant,
- const int nChannels)
-{
- int ch;
-
- for (ch = 0; ch < nChannels; ch++)
- {
- FDKaacEnc_FDKaacEnc_EstimateScaleFactorsChannel(qcOutChannel[ch],
- psyOutChannel[ch],
- qcOutChannel[ch]->scf,
- &qcOutChannel[ch]->globalGain,
- qcOutChannel[ch]->sfbFormFactorLdData
- ,invQuant,
- qcOutChannel[ch]->quantSpec
- );
- }
-
-}
-
diff --git a/libAACenc/src/sf_estim.h b/libAACenc/src/sf_estim.h
deleted file mode 100644
index b5ac000..0000000
--- a/libAACenc/src/sf_estim.h
+++ /dev/null
@@ -1,117 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M. Werner
- contents/description: Scale factor estimation
-
-******************************************************************************/
-
-#ifndef _SF_ESTIM_H
-#define _SF_ESTIM_H
-
-#include "common_fix.h"
-
-
-#include "psy_const.h"
-#include "qc_data.h"
-#include "interface.h"
-
-#define FORM_FAC_SHIFT 6
-
-
-void
-FDKaacEnc_CalcFormFactor(QC_OUT_CHANNEL *qcOutChannel[(2)],
- PSY_OUT_CHANNEL *psyOutChannel[(2)],
- const INT nChannels);
-
-void
-FDKaacEnc_EstimateScaleFactors(PSY_OUT_CHANNEL *psyOutChannel[],
- QC_OUT_CHANNEL* qcOutChannel[],
- const int invQuant,
- const int nChannels);
-
-
-
-#endif
diff --git a/libAACenc/src/spreading.cpp b/libAACenc/src/spreading.cpp
deleted file mode 100644
index 852da1e..0000000
--- a/libAACenc/src/spreading.cpp
+++ /dev/null
@@ -1,114 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M.Werner
- contents/description: Spreading of energy
-
-******************************************************************************/
-
-#include "spreading.h"
-
-void FDKaacEnc_SpreadingMax(const INT pbCnt,
- const FIXP_DBL *RESTRICT maskLowFactor,
- const FIXP_DBL *RESTRICT maskHighFactor,
- FIXP_DBL *RESTRICT pbSpreadEnergy)
-{
- int i;
- FIXP_DBL delay;
-
- /* slope to higher frequencies */
- delay = pbSpreadEnergy[0];
- for (i=1; i<pbCnt; i++) {
- delay = fixMax(pbSpreadEnergy[i], fMult(maskHighFactor[i], delay));
- pbSpreadEnergy[i] = delay;
- }
-
- /* slope to lower frequencies */
- delay = pbSpreadEnergy[pbCnt-1];
- for (i=pbCnt-2; i>=0; i--) {
- delay = fixMax(pbSpreadEnergy[i], fMult(maskLowFactor[i],delay));
- pbSpreadEnergy[i] = delay;
- }
-}
diff --git a/libAACenc/src/spreading.h b/libAACenc/src/spreading.h
deleted file mode 100644
index e1b506c..0000000
--- a/libAACenc/src/spreading.h
+++ /dev/null
@@ -1,102 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M.Werner
- contents/description: Spreading of energy and weighted tonality
-
-******************************************************************************/
-
-#ifndef _SPREADING_H
-#define _SPREADING_H
-
-#include "common_fix.h"
-
-
-void FDKaacEnc_SpreadingMax(const INT pbCnt,
- const FIXP_DBL *RESTRICT maskLowFactor,
- const FIXP_DBL *RESTRICT maskHighFactor,
- FIXP_DBL *RESTRICT pbSpreadEnergy);
-
-#endif /* #ifndef _SPREADING_H */
diff --git a/libAACenc/src/tns_func.h b/libAACenc/src/tns_func.h
deleted file mode 100644
index 6ee0edb..0000000
--- a/libAACenc/src/tns_func.h
+++ /dev/null
@@ -1,144 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: Alex Goeschel
- contents/description: Temporal noise shaping
-
-******************************************************************************/
-
-#ifndef _TNS_FUNC_H
-#define _TNS_FUNC_H
-
-#include "common_fix.h"
-
-#include "psy_configuration.h"
-
-AAC_ENCODER_ERROR FDKaacEnc_InitTnsConfiguration(INT bitrate,
- INT samplerate,
- INT channels,
- INT blocktype,
- INT granuleLength,
- INT ldSbrPresent,
- TNS_CONFIG *tnsConfig,
- PSY_CONFIGURATION *psyConfig,
- INT active,
- INT useTnsPeak );
-
-INT FDKaacEnc_TnsDetect(
- TNS_DATA *tnsData,
- const TNS_CONFIG *tC,
- TNS_INFO* tnsInfo,
- INT sfbCnt,
- FIXP_DBL *spectrum,
- INT subBlockNumber,
- INT blockType
- );
-
-
-
-void FDKaacEnc_TnsSync(
- TNS_DATA *tnsDataDest,
- const TNS_DATA *tnsDataSrc,
- TNS_INFO *tnsInfoDest,
- TNS_INFO *tnsInfoSrc,
- const INT blockTypeDest,
- const INT blockTypeSrc,
- const TNS_CONFIG *tC
- );
-
-INT FDKaacEnc_TnsEncode(
- TNS_INFO* tnsInfo,
- TNS_DATA* tnsData,
- const INT numOfSfb,
- const TNS_CONFIG *tC,
- const INT lowPassLine,
- FIXP_DBL* spectrum,
- const INT subBlockNumber,
- const INT blockType
- );
-
-
-
-#endif /* _TNS_FUNC_H */
diff --git a/libAACenc/src/tonality.cpp b/libAACenc/src/tonality.cpp
deleted file mode 100644
index 7246a34..0000000
--- a/libAACenc/src/tonality.cpp
+++ /dev/null
@@ -1,204 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- author: M. Werner
- contents/description: Convert chaos measure to the tonality index
-
-******************************************************************************/
-
-#include "tonality.h"
-#include "chaosmeasure.h"
-
-static const FIXP_DBL normlog = (FIXP_DBL)0xd977d949; /*FL2FXCONST_DBL(-0.4342944819f * FDKlog(2.0)/FDKlog(2.7182818)); */
-
-static void FDKaacEnc_CalcSfbTonality(FIXP_DBL *RESTRICT spectrum,
- INT *RESTRICT sfbMaxScaleSpec,
- FIXP_DBL *RESTRICT chaosMeasure,
- FIXP_SGL *RESTRICT sfbTonality,
- INT sfbCnt,
- const INT *RESTRICT sfbOffset,
- FIXP_DBL *RESTRICT sfbEnergyLD64 );
-
-
-void FDKaacEnc_CalculateFullTonality(FIXP_DBL *RESTRICT spectrum,
- INT *RESTRICT sfbMaxScaleSpec,
- FIXP_DBL *RESTRICT sfbEnergyLD64,
- FIXP_SGL *RESTRICT sfbTonality,
- INT sfbCnt,
- const INT *sfbOffset,
- INT usePns)
-{
- INT j;
-#if defined(ARCH_PREFER_MULT_32x16)
- FIXP_SGL alpha_0 = FL2FXCONST_SGL(0.25f); /* used in smooth ChaosMeasure */
- FIXP_SGL alpha_1 = FL2FXCONST_SGL(1.0f-0.25f); /* used in smooth ChaosMeasure */
-#else
- FIXP_DBL alpha_0 = FL2FXCONST_DBL(0.25f); /* used in smooth ChaosMeasure */
- FIXP_DBL alpha_1 = FL2FXCONST_DBL(1.0f-0.25f); /* used in smooth ChaosMeasure */
-#endif
- INT numberOfLines = sfbOffset[sfbCnt];
-
- if (!usePns)
- return;
-
- C_ALLOC_SCRATCH_START(chaosMeasurePerLine, FIXP_DBL, (1024));
- /* calculate chaos measure */
- FDKaacEnc_CalculateChaosMeasure(spectrum,
- numberOfLines,
- chaosMeasurePerLine);
-
- /* smooth ChaosMeasure */
- for (j=1;j<numberOfLines;j++) {
- FIXP_DBL tmp = fMultDiv2(alpha_1, chaosMeasurePerLine[j]);
- chaosMeasurePerLine[j] = fMultAdd(tmp, alpha_0, chaosMeasurePerLine[j-1]);
- }
-
- FDKaacEnc_CalcSfbTonality(spectrum,
- sfbMaxScaleSpec,
- chaosMeasurePerLine,
- sfbTonality,
- sfbCnt,
- sfbOffset,
- sfbEnergyLD64);
-
- C_ALLOC_SCRATCH_END(chaosMeasurePerLine, FIXP_DBL, (1024));
-}
-
-
-/*****************************************************************************
-
- functionname: CalculateTonalityIndex
- description: computes tonality values out of unpredictability values
- limits range and computes log()
- returns:
- input: ptr to energies, ptr to chaos measure values,
- number of sfb
- output: sfb wise tonality values
-
-*****************************************************************************/
-static void FDKaacEnc_CalcSfbTonality(FIXP_DBL *RESTRICT spectrum,
- INT *RESTRICT sfbMaxScaleSpec,
- FIXP_DBL *RESTRICT chaosMeasure,
- FIXP_SGL *RESTRICT sfbTonality,
- INT sfbCnt,
- const INT *RESTRICT sfbOffset,
- FIXP_DBL *RESTRICT sfbEnergyLD64 )
-{
- INT i, j;
-
- for (i=0; i<sfbCnt; i++) {
- FIXP_DBL chaosMeasureSfbLD64;
- INT shiftBits = fixMax(0,sfbMaxScaleSpec[i] - 4); /* max sfbWidth = 96 ; 2^7=128 => 7/2 = 4 (spc*spc) */
-
- FIXP_DBL chaosMeasureSfb = FL2FXCONST_DBL(0.0);
-
- /* calc chaosMeasurePerSfb */
- for (j=(sfbOffset[i+1]-sfbOffset[i])-1; j>=0; j--) {
- FIXP_DBL tmp = (*spectrum++)<<shiftBits;
- FIXP_DBL lineNrg = fMultDiv2(tmp, tmp);
- chaosMeasureSfb = fMultAddDiv2(chaosMeasureSfb, lineNrg, *chaosMeasure++);
- }
-
- /* calc tonalityPerSfb */
- if (chaosMeasureSfb != FL2FXCONST_DBL(0.0))
- {
- /* add ld(convtone)/64 and 2/64 bec.fMultDiv2 */
- chaosMeasureSfbLD64 = CalcLdData((chaosMeasureSfb)) - sfbEnergyLD64[i];
- chaosMeasureSfbLD64 += FL2FXCONST_DBL(3.0f/64) - ((FIXP_DBL)(shiftBits)<<(DFRACT_BITS-6));
-
- if (chaosMeasureSfbLD64 > FL2FXCONST_DBL(-0.0519051) ) /* > ld(0.05)+ld(2) */
- {
- if (chaosMeasureSfbLD64 <= FL2FXCONST_DBL(0.0) )
- sfbTonality[i] = FX_DBL2FX_SGL(fMultDiv2( chaosMeasureSfbLD64 , normlog ) << 7);
- else
- sfbTonality[i] = FL2FXCONST_SGL(0.0);
- }
- else
- sfbTonality[i] = (FIXP_SGL)MAXVAL_SGL;
- }
- else
- sfbTonality[i] = (FIXP_SGL)MAXVAL_SGL;
- }
-}
diff --git a/libAACenc/src/tonality.h b/libAACenc/src/tonality.h
deleted file mode 100644
index fbe78ee..0000000
--- a/libAACenc/src/tonality.h
+++ /dev/null
@@ -1,108 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- author: M. Lohwasser
- contents/description: Calculate tonality index
-
-******************************************************************************/
-
-#ifndef __TONALITY_H
-#define __TONALITY_H
-
-#include "common_fix.h"
-
-
-#include "chaosmeasure.h"
-
-
-void FDKaacEnc_CalculateFullTonality( FIXP_DBL *RESTRICT spectrum,
- INT *RESTRICT sfbMaxScaleSpec,
- FIXP_DBL *RESTRICT sfbEnergyLD64,
- FIXP_SGL *RESTRICT sfbTonality,
- INT sfbCnt,
- const INT *sfbOffset,
- INT usePns);
-
-#endif
diff --git a/libAACenc/src/transform.cpp b/libAACenc/src/transform.cpp
deleted file mode 100644
index 690b82e..0000000
--- a/libAACenc/src/transform.cpp
+++ /dev/null
@@ -1,264 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/*****************************************************************************
-
- Description: FDKaacLdEnc_MdctTransform480:
- The module FDKaacLdEnc_MdctTransform will perform the MDCT.
- The MDCT supports the sine window and
- the zero padded window. The algorithm of the MDCT
- can be divided in Windowing, PreModulation, Fft and
- PostModulation.
-
-******************************************************************************/
-
-#include "transform.h"
-
-#include "dct.h"
-#include "psy_const.h"
-#include "aacEnc_rom.h"
-#include "FDK_tools_rom.h"
-
-INT FDKaacEnc_Transform_Real (const INT_PCM * pTimeData,
- FIXP_DBL *RESTRICT mdctData,
- const INT blockType,
- const INT windowShape,
- INT *prevWindowShape,
- const INT frameLength,
- INT *mdctData_e,
- INT filterType
- ,FIXP_DBL * RESTRICT overlapAddBuffer
- )
-{
- const INT_PCM * RESTRICT timeData;
-
- INT i;
- /* tl: transform length
- fl: left window slope length
- nl: left window slope offset
- fr: right window slope length
- nr: right window slope offset
- See FDK_tools/doc/intern/mdct.tex for more detail. */
- int tl, fl, nl, fr, nr;
-
- const FIXP_WTP * RESTRICT pLeftWindowPart;
- const FIXP_WTP * RESTRICT pRightWindowPart;
-
- /*
- * MDCT scale:
- * + 1: fMultDiv2() in windowing.
- * + 1: Because of factor 1/2 in Princen-Bradley compliant windowed TDAC.
- */
- *mdctData_e = 1+1;
-
- tl = frameLength;
- timeData = pTimeData;
-
- switch( blockType ) {
- case LONG_WINDOW:
- {
- int offset = (windowShape == LOL_WINDOW) ? ((frameLength * 3)>>2) : 0;
- fl = frameLength - offset;
- fr = frameLength - offset;
- }
- break;
- case STOP_WINDOW:
- fl = frameLength >> 3;
- fr = frameLength;
- break;
- case START_WINDOW: /* or StopStartSequence */
- fl = frameLength;
- fr = frameLength >> 3;
- break;
- case SHORT_WINDOW:
- fl = fr = frameLength >> 3;
- tl >>= 3;
- timeData = pTimeData + 3*fl + (fl/2);
- break;
- default:
- FDK_ASSERT(0);
- return -1;
- break;
- }
-
- /* Taken from FDK_tools/src/mdct.cpp Derive NR and NL */
- nr = (tl - fr)>>1;
- nl = (tl - fl)>>1;
-
- pLeftWindowPart = FDKgetWindowSlope(fl, *prevWindowShape);
- pRightWindowPart = FDKgetWindowSlope(fr, windowShape);
-
- /* windowing */
- if (filterType != FB_ELD)
- {
- /* Left window slope offset */
- for (i=0; i<nl ; i++)
- {
-#if SAMPLE_BITS == DFRACT_BITS /* SPC_BITS and DFRACT_BITS should be equal. */
- mdctData[(tl/2)+i] = - (FIXP_DBL) timeData[tl-i-1] >> ( 1 );
-#else
- mdctData[(tl/2)+i] = - (FIXP_DBL) timeData[tl-i-1] << (DFRACT_BITS - SAMPLE_BITS - 1);
-#endif
- }
- /* Left window slope */
- for (i=0; i<fl/2; i++)
- {
- FIXP_DBL tmp0;
- tmp0 = fMultDiv2((FIXP_PCM)timeData[i+nl], pLeftWindowPart[i].v.im);
- mdctData[(tl/2)+i+nl] = fMultSubDiv2(tmp0, (FIXP_PCM)timeData[tl-nl-i-1], pLeftWindowPart[i].v.re);
- }
-
- /* Right window slope offset */
- for(i=0; i<nr; i++)
- {
-#if SAMPLE_BITS == DFRACT_BITS /* This should be SPC_BITS instead of DFRACT_BITS. */
- mdctData[(tl/2)-1-i] = - (FIXP_DBL) timeData[tl+i] >> (1);
-#else
- mdctData[(tl/2)-1-i] = - (FIXP_DBL) timeData[tl+i] << (DFRACT_BITS - SAMPLE_BITS - 1);
-#endif
- }
- /* Right window slope */
- for (i=0; i<fr/2; i++)
- {
- FIXP_DBL tmp1;
- tmp1 = fMultDiv2((FIXP_PCM)timeData[tl+nr+i], pRightWindowPart[i].v.re);
- mdctData[(tl/2)-nr-i-1] = -fMultAddDiv2(tmp1, (FIXP_PCM)timeData[(tl*2)-nr-i-1], pRightWindowPart[i].v.im);
- }
- }
-
- if (filterType == FB_ELD)
- {
- const FIXP_WTB *pWindowELD=NULL;
- int i, N = frameLength, L = frameLength;
-
- if (frameLength == 512) {
- pWindowELD = ELDAnalysis512;
- } else {
- pWindowELD = ELDAnalysis480;
- }
-
- for(i=0;i<N/4;i++)
- {
- FIXP_DBL z0, outval;
-
- z0 = (fMult((FIXP_PCM)timeData[L+N*3/4-1-i], pWindowELD[N/2-1-i])<< (WTS0-1)) + (fMult((FIXP_PCM)timeData[L+N*3/4+i], pWindowELD[N/2+i])<< (WTS0-1));
-
- outval = (fMultDiv2((FIXP_PCM)timeData[L+N*3/4-1-i], pWindowELD[N+N/2-1-i]) >> (-WTS1));
- outval += (fMultDiv2((FIXP_PCM)timeData[L+N*3/4+i], pWindowELD[N+N/2+i]) >> (-WTS1) );
- outval += (fMultDiv2(overlapAddBuffer[N/2+i], pWindowELD[2*N+i])>> (-WTS2-1));
-
- overlapAddBuffer[N/2+i] = overlapAddBuffer[i];
-
- overlapAddBuffer[i] = z0;
- mdctData[i] = overlapAddBuffer[N/2+i] + (fMultDiv2(overlapAddBuffer[N+N/2-1-i], pWindowELD[2*N+N/2+i]) >> (-WTS2-1));
-
- mdctData[N-1-i] = outval;
- overlapAddBuffer[N+N/2-1-i] = outval;
- }
-
- for(i=N/4;i<N/2;i++)
- {
- FIXP_DBL z0, outval;
-
- z0 = fMult((FIXP_PCM)timeData[L+N*3/4-1-i], pWindowELD[N/2-1-i]) << (WTS0-1);
-
- outval = (fMultDiv2((FIXP_PCM)timeData[L+N*3/4-1-i], pWindowELD[N+N/2-1-i]) >> (-WTS1)) ;
- outval += (fMultDiv2(overlapAddBuffer[N/2+i], pWindowELD[2*N+i]) >> (-WTS2-1));
-
- overlapAddBuffer[N/2+i] = overlapAddBuffer[i] + (fMult((FIXP_PCM)timeData[L-N/4+i], pWindowELD[N/2+i])<< (WTS0-1) );
-
- overlapAddBuffer[i] = z0;
- mdctData[i] = overlapAddBuffer[N/2+i] + (fMultDiv2(overlapAddBuffer[N+N/2-1-i], pWindowELD[2*N+N/2+i]) >> (-WTS2-1));
-
- mdctData[N-1-i] = outval;
- overlapAddBuffer[N+N/2-1-i] = outval;
- }
- }
-
- dct_IV(mdctData, tl, mdctData_e);
-
- *prevWindowShape = windowShape;
-
- return 0;
-}
-
diff --git a/libAACenc/src/transform.h b/libAACenc/src/transform.h
deleted file mode 100644
index 5053174..0000000
--- a/libAACenc/src/transform.h
+++ /dev/null
@@ -1,123 +0,0 @@
-
-/* -----------------------------------------------------------------------------------------------------------
-Software License for The Fraunhofer FDK AAC Codec Library for Android
-
-© Copyright 1995 - 2013 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
------------------------------------------------------------------------------------------------------------ */
-
-/******************************** MPEG Audio Encoder **************************
-
- Initial author: M. Werner
- contents/description: MDCT Transform
-
-******************************************************************************/
-
-#ifndef _TRANSFORM_H
-#define _TRANSFORM_H
-
-#include "common_fix.h"
-
-#define WTS0 1
-#define WTS1 0
-#define WTS2 -2
-
-/**
- * \brief: Performe MDCT transform of time domain data.
- * \param timeData pointer to time domain input signal.
- * \param mdctData pointer to store frequency domain output data.
- * \param blockType index indicating the type of block. Either
- * LONG_WINDOW, START_WINDOW, SHORT_WINDOW or STOP_WINDOW.
- * \param windowShape index indicating the window slope type to be used.
- * Values allowed are either SINE_WINDOW or KBD_WINDOW.
- * \param frameLength length of the block.
- * \param mdctData_e pointer to an INT where the exponent of the frequency
- * domain output data is stored into.
- * \return 0 in case of success, non-zero in case of error (inconsistent parameters).
- */
-INT FDKaacEnc_Transform_Real (const INT_PCM *timeData,
- FIXP_DBL *RESTRICT mdctData,
- const INT blockType,
- const INT windowShape,
- INT *prevWindowShape,
- const INT frameLength,
- INT *mdctData_e,
- INT filterType
- ,FIXP_DBL * RESTRICT overlapAddBuffer
- );
-#endif