aboutsummaryrefslogtreecommitdiffstats
path: root/libSBRenc/src/ps_bitenc.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'libSBRenc/src/ps_bitenc.cpp')
-rw-r--r--libSBRenc/src/ps_bitenc.cpp830
1 files changed, 378 insertions, 452 deletions
diff --git a/libSBRenc/src/ps_bitenc.cpp b/libSBRenc/src/ps_bitenc.cpp
index 420ea15..e30af2a 100644
--- a/libSBRenc/src/ps_bitenc.cpp
+++ b/libSBRenc/src/ps_bitenc.cpp
@@ -1,74 +1,85 @@
-
-/* -----------------------------------------------------------------------------------------------------------
+/* -----------------------------------------------------------------------------
Software License for The Fraunhofer FDK AAC Codec Library for Android
-© Copyright 1995 - 2015 Fraunhofer-Gesellschaft zur Förderung der angewandten Forschung e.V.
- All rights reserved.
+© Copyright 1995 - 2018 Fraunhofer-Gesellschaft zur Förderung der angewandten
+Forschung e.V. All rights reserved.
1. INTRODUCTION
-The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software that implements
-the MPEG Advanced Audio Coding ("AAC") encoding and decoding scheme for digital audio.
-This FDK AAC Codec software is intended to be used on a wide variety of Android devices.
-
-AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient general perceptual
-audio codecs. AAC-ELD is considered the best-performing full-bandwidth communications codec by
-independent studies and is widely deployed. AAC has been standardized by ISO and IEC as part
-of the MPEG specifications.
-
-Patent licenses for necessary patent claims for the FDK AAC Codec (including those of Fraunhofer)
-may be obtained through Via Licensing (www.vialicensing.com) or through the respective patent owners
-individually for the purpose of encoding or decoding bit streams in products that are compliant with
-the ISO/IEC MPEG audio standards. Please note that most manufacturers of Android devices already license
-these patent claims through Via Licensing or directly from the patent owners, and therefore FDK AAC Codec
-software may already be covered under those patent licenses when it is used for those licensed purposes only.
-
-Commercially-licensed AAC software libraries, including floating-point versions with enhanced sound quality,
-are also available from Fraunhofer. Users are encouraged to check the Fraunhofer website for additional
-applications information and documentation.
+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:
+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 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
+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.
+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.
+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."
+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.
+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.
+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.
+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
@@ -79,37 +90,35 @@ Am Wolfsmantel 33
www.iis.fraunhofer.de/amm
amm-info@iis.fraunhofer.de
------------------------------------------------------------------------------------------------------------ */
-
-/***************************** MPEG Audio Encoder ***************************
+----------------------------------------------------------------------------- */
- Initial author: N. Rettelbach
- contents/description: Parametric Stereo bitstream encoder
+/**************************** SBR encoder library ******************************
-******************************************************************************/
+ Author(s): N. Rettelbach
-#include "ps_main.h"
+ Description: Parametric Stereo bitstream encoder
+*******************************************************************************/
-#include "ps_const.h"
#include "ps_bitenc.h"
-static
-inline UCHAR FDKsbrEnc_WriteBits_ps(HANDLE_FDK_BITSTREAM hBitStream, UINT value,
- const UINT numberOfBits)
-{
+#include "ps_main.h"
+
+static inline UCHAR FDKsbrEnc_WriteBits_ps(HANDLE_FDK_BITSTREAM hBitStream,
+ UINT value,
+ const UINT numberOfBits) {
/* hBitStream == NULL happens here intentionally */
- if(hBitStream!=NULL){
+ if (hBitStream != NULL) {
FDKwriteBits(hBitStream, value, numberOfBits);
}
return numberOfBits;
}
-#define SI_SBR_EXTENSION_SIZE_BITS 4
-#define SI_SBR_EXTENSION_ESC_COUNT_BITS 8
-#define SI_SBR_EXTENSION_ID_BITS 2
-#define EXTENSION_ID_PS_CODING 2
-#define PS_EXT_ID_V0 0
+#define SI_SBR_EXTENSION_SIZE_BITS 4
+#define SI_SBR_EXTENSION_ESC_COUNT_BITS 8
+#define SI_SBR_EXTENSION_ID_BITS 2
+#define EXTENSION_ID_PS_CODING 2
+#define PS_EXT_ID_V0 0
static const INT iidDeltaCoarse_Offset = 14;
static const INT iidDeltaCoarse_MaxVal = 28;
@@ -117,499 +126,425 @@ static const INT iidDeltaFine_Offset = 30;
static const INT iidDeltaFine_MaxVal = 60;
/* PS Stereo Huffmantable: iidDeltaFreqCoarse */
-static const UINT iidDeltaFreqCoarse_Length[] =
-{
- 17, 17, 17, 17, 16, 15, 13, 10, 9, 7,
- 6, 5, 4, 3, 1, 3, 4, 5, 6, 6,
- 8, 11, 13, 14, 14, 15, 17, 18, 18
-};
-static const UINT iidDeltaFreqCoarse_Code[] =
-{
- 0x0001fffb, 0x0001fffc, 0x0001fffd, 0x0001fffa, 0x0000fffc, 0x00007ffc, 0x00001ffd, 0x000003fe, 0x000001fe, 0x0000007e,
- 0x0000003c, 0x0000001d, 0x0000000d, 0x00000005, 0000000000, 0x00000004, 0x0000000c, 0x0000001c, 0x0000003d, 0x0000003e,
- 0x000000fe, 0x000007fe, 0x00001ffc, 0x00003ffc, 0x00003ffd, 0x00007ffd, 0x0001fffe, 0x0003fffe, 0x0003ffff
-};
+static const UINT iidDeltaFreqCoarse_Length[] = {
+ 17, 17, 17, 17, 16, 15, 13, 10, 9, 7, 6, 5, 4, 3, 1,
+ 3, 4, 5, 6, 6, 8, 11, 13, 14, 14, 15, 17, 18, 18};
+static const UINT iidDeltaFreqCoarse_Code[] = {
+ 0x0001fffb, 0x0001fffc, 0x0001fffd, 0x0001fffa, 0x0000fffc, 0x00007ffc,
+ 0x00001ffd, 0x000003fe, 0x000001fe, 0x0000007e, 0x0000003c, 0x0000001d,
+ 0x0000000d, 0x00000005, 0000000000, 0x00000004, 0x0000000c, 0x0000001c,
+ 0x0000003d, 0x0000003e, 0x000000fe, 0x000007fe, 0x00001ffc, 0x00003ffc,
+ 0x00003ffd, 0x00007ffd, 0x0001fffe, 0x0003fffe, 0x0003ffff};
/* PS Stereo Huffmantable: iidDeltaFreqFine */
-static const UINT iidDeltaFreqFine_Length[] =
-{
- 18, 18, 18, 18, 18, 18, 18, 18, 18, 17,
- 18, 17, 17, 16, 16, 15, 14, 14, 13, 12,
- 12, 11, 10, 10, 8, 7, 6, 5, 4, 3,
- 1, 3, 4, 5, 6, 7, 8, 9, 10, 11,
- 11, 12, 13, 14, 14, 15, 16, 16, 17, 17,
- 18, 17, 18, 18, 18, 18, 18, 18, 18, 18,
- 18
-};
-static const UINT iidDeltaFreqFine_Code[] =
-{
- 0x0001feb4, 0x0001feb5, 0x0001fd76, 0x0001fd77, 0x0001fd74, 0x0001fd75, 0x0001fe8a, 0x0001fe8b, 0x0001fe88, 0x0000fe80,
- 0x0001feb6, 0x0000fe82, 0x0000feb8, 0x00007f42, 0x00007fae, 0x00003faf, 0x00001fd1, 0x00001fe9, 0x00000fe9, 0x000007ea,
- 0x000007fb, 0x000003fb, 0x000001fb, 0x000001ff, 0x0000007c, 0x0000003c, 0x0000001c, 0x0000000c, 0000000000, 0x00000001,
- 0x00000001, 0x00000002, 0x00000001, 0x0000000d, 0x0000001d, 0x0000003d, 0x0000007d, 0x000000fc, 0x000001fc, 0x000003fc,
- 0x000003f4, 0x000007eb, 0x00000fea, 0x00001fea, 0x00001fd6, 0x00003fd0, 0x00007faf, 0x00007f43, 0x0000feb9, 0x0000fe83,
- 0x0001feb7, 0x0000fe81, 0x0001fe89, 0x0001fe8e, 0x0001fe8f, 0x0001fe8c, 0x0001fe8d, 0x0001feb2, 0x0001feb3, 0x0001feb0,
- 0x0001feb1
-};
+static const UINT iidDeltaFreqFine_Length[] = {
+ 18, 18, 18, 18, 18, 18, 18, 18, 18, 17, 18, 17, 17, 16, 16, 15,
+ 14, 14, 13, 12, 12, 11, 10, 10, 8, 7, 6, 5, 4, 3, 1, 3,
+ 4, 5, 6, 7, 8, 9, 10, 11, 11, 12, 13, 14, 14, 15, 16, 16,
+ 17, 17, 18, 17, 18, 18, 18, 18, 18, 18, 18, 18, 18};
+static const UINT iidDeltaFreqFine_Code[] = {
+ 0x0001feb4, 0x0001feb5, 0x0001fd76, 0x0001fd77, 0x0001fd74, 0x0001fd75,
+ 0x0001fe8a, 0x0001fe8b, 0x0001fe88, 0x0000fe80, 0x0001feb6, 0x0000fe82,
+ 0x0000feb8, 0x00007f42, 0x00007fae, 0x00003faf, 0x00001fd1, 0x00001fe9,
+ 0x00000fe9, 0x000007ea, 0x000007fb, 0x000003fb, 0x000001fb, 0x000001ff,
+ 0x0000007c, 0x0000003c, 0x0000001c, 0x0000000c, 0000000000, 0x00000001,
+ 0x00000001, 0x00000002, 0x00000001, 0x0000000d, 0x0000001d, 0x0000003d,
+ 0x0000007d, 0x000000fc, 0x000001fc, 0x000003fc, 0x000003f4, 0x000007eb,
+ 0x00000fea, 0x00001fea, 0x00001fd6, 0x00003fd0, 0x00007faf, 0x00007f43,
+ 0x0000feb9, 0x0000fe83, 0x0001feb7, 0x0000fe81, 0x0001fe89, 0x0001fe8e,
+ 0x0001fe8f, 0x0001fe8c, 0x0001fe8d, 0x0001feb2, 0x0001feb3, 0x0001feb0,
+ 0x0001feb1};
/* PS Stereo Huffmantable: iidDeltaTimeCoarse */
-static const UINT iidDeltaTimeCoarse_Length[] =
-{
- 19, 19, 19, 20, 20, 20, 17, 15, 12, 10,
- 8, 6, 4, 2, 1, 3, 5, 7, 9, 11,
- 13, 14, 17, 19, 20, 20, 20, 20, 20
-};
-static const UINT iidDeltaTimeCoarse_Code[] =
-{
- 0x0007fff9, 0x0007fffa, 0x0007fffb, 0x000ffff8, 0x000ffff9, 0x000ffffa, 0x0001fffd, 0x00007ffe, 0x00000ffe, 0x000003fe,
- 0x000000fe, 0x0000003e, 0x0000000e, 0x00000002, 0000000000, 0x00000006, 0x0000001e, 0x0000007e, 0x000001fe, 0x000007fe,
- 0x00001ffe, 0x00003ffe, 0x0001fffc, 0x0007fff8, 0x000ffffb, 0x000ffffc, 0x000ffffd, 0x000ffffe, 0x000fffff
-};
+static const UINT iidDeltaTimeCoarse_Length[] = {
+ 19, 19, 19, 20, 20, 20, 17, 15, 12, 10, 8, 6, 4, 2, 1,
+ 3, 5, 7, 9, 11, 13, 14, 17, 19, 20, 20, 20, 20, 20};
+static const UINT iidDeltaTimeCoarse_Code[] = {
+ 0x0007fff9, 0x0007fffa, 0x0007fffb, 0x000ffff8, 0x000ffff9, 0x000ffffa,
+ 0x0001fffd, 0x00007ffe, 0x00000ffe, 0x000003fe, 0x000000fe, 0x0000003e,
+ 0x0000000e, 0x00000002, 0000000000, 0x00000006, 0x0000001e, 0x0000007e,
+ 0x000001fe, 0x000007fe, 0x00001ffe, 0x00003ffe, 0x0001fffc, 0x0007fff8,
+ 0x000ffffb, 0x000ffffc, 0x000ffffd, 0x000ffffe, 0x000fffff};
/* PS Stereo Huffmantable: iidDeltaTimeFine */
-static const UINT iidDeltaTimeFine_Length[] =
-{
- 16, 16, 16, 16, 16, 16, 16, 16, 16, 15,
- 15, 15, 15, 15, 15, 14, 14, 13, 13, 13,
- 12, 12, 11, 10, 9, 9, 7, 6, 5, 3,
- 1, 2, 5, 6, 7, 8, 9, 10, 11, 11,
- 12, 12, 13, 13, 14, 14, 15, 15, 15, 15,
- 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
- 16
-};
-static const UINT iidDeltaTimeFine_Code[] =
-{
- 0x00004ed4, 0x00004ed5, 0x00004ece, 0x00004ecf, 0x00004ecc, 0x00004ed6, 0x00004ed8, 0x00004f46, 0x00004f60, 0x00002718,
- 0x00002719, 0x00002764, 0x00002765, 0x0000276d, 0x000027b1, 0x000013b7, 0x000013d6, 0x000009c7, 0x000009e9, 0x000009ed,
- 0x000004ee, 0x000004f7, 0x00000278, 0x00000139, 0x0000009a, 0x0000009f, 0x00000020, 0x00000011, 0x0000000a, 0x00000003,
- 0x00000001, 0000000000, 0x0000000b, 0x00000012, 0x00000021, 0x0000004c, 0x0000009b, 0x0000013a, 0x00000279, 0x00000270,
- 0x000004ef, 0x000004e2, 0x000009ea, 0x000009d8, 0x000013d7, 0x000013d0, 0x000027b2, 0x000027a2, 0x0000271a, 0x0000271b,
- 0x00004f66, 0x00004f67, 0x00004f61, 0x00004f47, 0x00004ed9, 0x00004ed7, 0x00004ecd, 0x00004ed2, 0x00004ed3, 0x00004ed0,
- 0x00004ed1
-};
-
-static const INT iccDelta_Offset = 7;
+static const UINT iidDeltaTimeFine_Length[] = {
+ 16, 16, 16, 16, 16, 16, 16, 16, 16, 15, 15, 15, 15, 15, 15, 14,
+ 14, 13, 13, 13, 12, 12, 11, 10, 9, 9, 7, 6, 5, 3, 1, 2,
+ 5, 6, 7, 8, 9, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15,
+ 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16};
+static const UINT iidDeltaTimeFine_Code[] = {
+ 0x00004ed4, 0x00004ed5, 0x00004ece, 0x00004ecf, 0x00004ecc, 0x00004ed6,
+ 0x00004ed8, 0x00004f46, 0x00004f60, 0x00002718, 0x00002719, 0x00002764,
+ 0x00002765, 0x0000276d, 0x000027b1, 0x000013b7, 0x000013d6, 0x000009c7,
+ 0x000009e9, 0x000009ed, 0x000004ee, 0x000004f7, 0x00000278, 0x00000139,
+ 0x0000009a, 0x0000009f, 0x00000020, 0x00000011, 0x0000000a, 0x00000003,
+ 0x00000001, 0000000000, 0x0000000b, 0x00000012, 0x00000021, 0x0000004c,
+ 0x0000009b, 0x0000013a, 0x00000279, 0x00000270, 0x000004ef, 0x000004e2,
+ 0x000009ea, 0x000009d8, 0x000013d7, 0x000013d0, 0x000027b2, 0x000027a2,
+ 0x0000271a, 0x0000271b, 0x00004f66, 0x00004f67, 0x00004f61, 0x00004f47,
+ 0x00004ed9, 0x00004ed7, 0x00004ecd, 0x00004ed2, 0x00004ed3, 0x00004ed0,
+ 0x00004ed1};
+
+static const INT iccDelta_Offset = 7;
static const INT iccDelta_MaxVal = 14;
/* PS Stereo Huffmantable: iccDeltaFreq */
-static const UINT iccDeltaFreq_Length[] =
-{
- 14, 14, 12, 10, 7, 5, 3, 1, 2, 4,
- 6, 8, 9, 11, 13
-};
-static const UINT iccDeltaFreq_Code[] =
-{
- 0x00003fff, 0x00003ffe, 0x00000ffe, 0x000003fe, 0x0000007e, 0x0000001e, 0x00000006, 0000000000, 0x00000002, 0x0000000e,
- 0x0000003e, 0x000000fe, 0x000001fe, 0x000007fe, 0x00001ffe
-};
+static const UINT iccDeltaFreq_Length[] = {14, 14, 12, 10, 7, 5, 3, 1,
+ 2, 4, 6, 8, 9, 11, 13};
+static const UINT iccDeltaFreq_Code[] = {
+ 0x00003fff, 0x00003ffe, 0x00000ffe, 0x000003fe, 0x0000007e,
+ 0x0000001e, 0x00000006, 0000000000, 0x00000002, 0x0000000e,
+ 0x0000003e, 0x000000fe, 0x000001fe, 0x000007fe, 0x00001ffe};
/* PS Stereo Huffmantable: iccDeltaTime */
-static const UINT iccDeltaTime_Length[] =
-{
- 14, 13, 11, 9, 7, 5, 3, 1, 2, 4,
- 6, 8, 10, 12, 14
-};
-static const UINT iccDeltaTime_Code[] =
-{
- 0x00003ffe, 0x00001ffe, 0x000007fe, 0x000001fe, 0x0000007e, 0x0000001e, 0x00000006, 0000000000, 0x00000002, 0x0000000e,
- 0x0000003e, 0x000000fe, 0x000003fe, 0x00000ffe, 0x00003fff
-};
-
-
+static const UINT iccDeltaTime_Length[] = {14, 13, 11, 9, 7, 5, 3, 1,
+ 2, 4, 6, 8, 10, 12, 14};
+static const UINT iccDeltaTime_Code[] = {
+ 0x00003ffe, 0x00001ffe, 0x000007fe, 0x000001fe, 0x0000007e,
+ 0x0000001e, 0x00000006, 0000000000, 0x00000002, 0x0000000e,
+ 0x0000003e, 0x000000fe, 0x000003fe, 0x00000ffe, 0x00003fff};
static const INT ipdDelta_Offset = 0;
static const INT ipdDelta_MaxVal = 7;
/* PS Stereo Huffmantable: ipdDeltaFreq */
-static const UINT ipdDeltaFreq_Length[] =
-{
- 1, 3, 4, 4, 4, 4, 4, 4
-};
-static const UINT ipdDeltaFreq_Code[] =
-{
- 0x00000001, 0000000000, 0x00000006, 0x00000004, 0x00000002, 0x00000003, 0x00000005, 0x00000007
-};
+static const UINT ipdDeltaFreq_Length[] = {1, 3, 4, 4, 4, 4, 4, 4};
+static const UINT ipdDeltaFreq_Code[] = {0x00000001, 0000000000, 0x00000006,
+ 0x00000004, 0x00000002, 0x00000003,
+ 0x00000005, 0x00000007};
/* PS Stereo Huffmantable: ipdDeltaTime */
-static const UINT ipdDeltaTime_Length[] =
-{
- 1, 3, 4, 5, 5, 4, 4, 3
-};
-static const UINT ipdDeltaTime_Code[] =
-{
- 0x00000001, 0x00000002, 0x00000002, 0x00000003, 0x00000002, 0000000000, 0x00000003, 0x00000003
-};
-
+static const UINT ipdDeltaTime_Length[] = {1, 3, 4, 5, 5, 4, 4, 3};
+static const UINT ipdDeltaTime_Code[] = {0x00000001, 0x00000002, 0x00000002,
+ 0x00000003, 0x00000002, 0000000000,
+ 0x00000003, 0x00000003};
static const INT opdDelta_Offset = 0;
static const INT opdDelta_MaxVal = 7;
/* PS Stereo Huffmantable: opdDeltaFreq */
-static const UINT opdDeltaFreq_Length[] =
-{
- 1, 3, 4, 4, 5, 5, 4, 3
-};
-static const UINT opdDeltaFreq_Code[] =
-{
- 0x00000001, 0x00000001, 0x00000006, 0x00000004, 0x0000000f, 0x0000000e, 0x00000005, 0000000000,
+static const UINT opdDeltaFreq_Length[] = {1, 3, 4, 4, 5, 5, 4, 3};
+static const UINT opdDeltaFreq_Code[] = {
+ 0x00000001, 0x00000001, 0x00000006, 0x00000004,
+ 0x0000000f, 0x0000000e, 0x00000005, 0000000000,
};
/* PS Stereo Huffmantable: opdDeltaTime */
-static const UINT opdDeltaTime_Length[] =
-{
- 1, 3, 4, 5, 5, 4, 4, 3
-};
-static const UINT opdDeltaTime_Code[] =
-{
- 0x00000001, 0x00000002, 0x00000001, 0x00000007, 0x00000006, 0000000000, 0x00000002, 0x00000003
-};
+static const UINT opdDeltaTime_Length[] = {1, 3, 4, 5, 5, 4, 4, 3};
+static const UINT opdDeltaTime_Code[] = {0x00000001, 0x00000002, 0x00000001,
+ 0x00000007, 0x00000006, 0000000000,
+ 0x00000002, 0x00000003};
-static INT getNoBands(const INT mode)
-{
+static INT getNoBands(const INT mode) {
INT noBands = 0;
switch (mode) {
- case 0: case 3: /* coarse */
+ case 0:
+ case 3: /* coarse */
noBands = PS_BANDS_COARSE;
break;
- case 1: case 4: /* mid */
+ case 1:
+ case 4: /* mid */
noBands = PS_BANDS_MID;
break;
- case 2: case 5: /* fine not supported */
- default: /* coarse as default */
+ case 2:
+ case 5: /* fine not supported */
+ default: /* coarse as default */
noBands = PS_BANDS_COARSE;
}
return noBands;
}
-static INT getIIDRes(INT iidMode)
-{
- if(iidMode<3)
+static INT getIIDRes(INT iidMode) {
+ if (iidMode < 3)
return PS_IID_RES_COARSE;
else
return PS_IID_RES_FINE;
}
-static INT
-encodeDeltaFreq(HANDLE_FDK_BITSTREAM hBitBuf,
- const INT *val,
- const INT nBands,
- const UINT *codeTable,
- const UINT *lengthTable,
- const INT tableOffset,
- const INT maxVal,
- INT *error)
-{
+static INT encodeDeltaFreq(HANDLE_FDK_BITSTREAM hBitBuf, const INT *val,
+ const INT nBands, const UINT *codeTable,
+ const UINT *lengthTable, const INT tableOffset,
+ const INT maxVal, INT *error) {
INT bitCnt = 0;
INT lastVal = 0;
INT band;
- for(band=0;band<nBands;band++) {
+ for (band = 0; band < nBands; band++) {
INT delta = (val[band] - lastVal) + tableOffset;
lastVal = val[band];
- if( (delta>maxVal) || (delta<0) ) {
+ if ((delta > maxVal) || (delta < 0)) {
*error = 1;
- delta = delta>0?maxVal:0;
+ delta = delta > 0 ? maxVal : 0;
}
- bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, codeTable[delta], lengthTable[delta]);
+ bitCnt +=
+ FDKsbrEnc_WriteBits_ps(hBitBuf, codeTable[delta], lengthTable[delta]);
}
return bitCnt;
}
-static INT
-encodeDeltaTime(HANDLE_FDK_BITSTREAM hBitBuf,
- const INT *val,
- const INT *valLast,
- const INT nBands,
- const UINT *codeTable,
- const UINT *lengthTable,
- const INT tableOffset,
- const INT maxVal,
- INT *error)
-{
+static INT encodeDeltaTime(HANDLE_FDK_BITSTREAM hBitBuf, const INT *val,
+ const INT *valLast, const INT nBands,
+ const UINT *codeTable, const UINT *lengthTable,
+ const INT tableOffset, const INT maxVal,
+ INT *error) {
INT bitCnt = 0;
INT band;
- for(band=0;band<nBands;band++) {
+ for (band = 0; band < nBands; band++) {
INT delta = (val[band] - valLast[band]) + tableOffset;
- if( (delta>maxVal) || (delta<0) ) {
+ if ((delta > maxVal) || (delta < 0)) {
*error = 1;
- delta = delta>0?maxVal:0;
+ delta = delta > 0 ? maxVal : 0;
}
- bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, codeTable[delta], lengthTable[delta]);
+ bitCnt +=
+ FDKsbrEnc_WriteBits_ps(hBitBuf, codeTable[delta], lengthTable[delta]);
}
return bitCnt;
}
-INT FDKsbrEnc_EncodeIid(HANDLE_FDK_BITSTREAM hBitBuf,
- const INT *iidVal,
- const INT *iidValLast,
- const INT nBands,
- const PS_IID_RESOLUTION res,
- const PS_DELTA mode,
- INT *error)
-{
+INT FDKsbrEnc_EncodeIid(HANDLE_FDK_BITSTREAM hBitBuf, const INT *iidVal,
+ const INT *iidValLast, const INT nBands,
+ const PS_IID_RESOLUTION res, const PS_DELTA mode,
+ INT *error) {
const UINT *codeTable;
const UINT *lengthTable;
INT bitCnt = 0;
bitCnt = 0;
- switch(mode) {
- case PS_DELTA_FREQ:
- switch(res) {
- case PS_IID_RES_COARSE:
- codeTable = iidDeltaFreqCoarse_Code;
- lengthTable = iidDeltaFreqCoarse_Length;
- bitCnt += encodeDeltaFreq(hBitBuf, iidVal, nBands, codeTable,
- lengthTable, iidDeltaCoarse_Offset,
- iidDeltaCoarse_MaxVal, error);
- break;
- case PS_IID_RES_FINE:
- codeTable = iidDeltaFreqFine_Code;
- lengthTable = iidDeltaFreqFine_Length;
- bitCnt += encodeDeltaFreq(hBitBuf, iidVal, nBands, codeTable,
- lengthTable, iidDeltaFine_Offset,
- iidDeltaFine_MaxVal, error);
- break;
- default:
- *error = 1;
- }
- break;
-
- case PS_DELTA_TIME:
- switch(res) {
- case PS_IID_RES_COARSE:
- codeTable = iidDeltaTimeCoarse_Code;
- lengthTable = iidDeltaTimeCoarse_Length;
- bitCnt += encodeDeltaTime(hBitBuf, iidVal, iidValLast, nBands, codeTable,
- lengthTable, iidDeltaCoarse_Offset,
- iidDeltaCoarse_MaxVal, error);
- break;
- case PS_IID_RES_FINE:
- codeTable = iidDeltaTimeFine_Code;
- lengthTable = iidDeltaTimeFine_Length;
- bitCnt += encodeDeltaTime(hBitBuf, iidVal, iidValLast, nBands, codeTable,
- lengthTable, iidDeltaFine_Offset,
- iidDeltaFine_MaxVal, error);
- break;
+ switch (mode) {
+ case PS_DELTA_FREQ:
+ switch (res) {
+ case PS_IID_RES_COARSE:
+ codeTable = iidDeltaFreqCoarse_Code;
+ lengthTable = iidDeltaFreqCoarse_Length;
+ bitCnt += encodeDeltaFreq(hBitBuf, iidVal, nBands, codeTable,
+ lengthTable, iidDeltaCoarse_Offset,
+ iidDeltaCoarse_MaxVal, error);
+ break;
+ case PS_IID_RES_FINE:
+ codeTable = iidDeltaFreqFine_Code;
+ lengthTable = iidDeltaFreqFine_Length;
+ bitCnt +=
+ encodeDeltaFreq(hBitBuf, iidVal, nBands, codeTable, lengthTable,
+ iidDeltaFine_Offset, iidDeltaFine_MaxVal, error);
+ break;
+ default:
+ *error = 1;
+ }
+ break;
+
+ case PS_DELTA_TIME:
+ switch (res) {
+ case PS_IID_RES_COARSE:
+ codeTable = iidDeltaTimeCoarse_Code;
+ lengthTable = iidDeltaTimeCoarse_Length;
+ bitCnt += encodeDeltaTime(
+ hBitBuf, iidVal, iidValLast, nBands, codeTable, lengthTable,
+ iidDeltaCoarse_Offset, iidDeltaCoarse_MaxVal, error);
+ break;
+ case PS_IID_RES_FINE:
+ codeTable = iidDeltaTimeFine_Code;
+ lengthTable = iidDeltaTimeFine_Length;
+ bitCnt += encodeDeltaTime(hBitBuf, iidVal, iidValLast, nBands,
+ codeTable, lengthTable, iidDeltaFine_Offset,
+ iidDeltaFine_MaxVal, error);
+ break;
+ default:
+ *error = 1;
+ }
+ break;
+
default:
*error = 1;
- }
- break;
-
- default:
- *error = 1;
}
return bitCnt;
}
-
-INT FDKsbrEnc_EncodeIcc(HANDLE_FDK_BITSTREAM hBitBuf,
- const INT *iccVal,
- const INT *iccValLast,
- const INT nBands,
- const PS_DELTA mode,
- INT *error)
-{
+INT FDKsbrEnc_EncodeIcc(HANDLE_FDK_BITSTREAM hBitBuf, const INT *iccVal,
+ const INT *iccValLast, const INT nBands,
+ const PS_DELTA mode, INT *error) {
const UINT *codeTable;
const UINT *lengthTable;
INT bitCnt = 0;
- switch(mode) {
- case PS_DELTA_FREQ:
- codeTable = iccDeltaFreq_Code;
- lengthTable = iccDeltaFreq_Length;
- bitCnt += encodeDeltaFreq(hBitBuf, iccVal, nBands, codeTable,
- lengthTable, iccDelta_Offset, iccDelta_MaxVal, error);
- break;
+ switch (mode) {
+ case PS_DELTA_FREQ:
+ codeTable = iccDeltaFreq_Code;
+ lengthTable = iccDeltaFreq_Length;
+ bitCnt += encodeDeltaFreq(hBitBuf, iccVal, nBands, codeTable, lengthTable,
+ iccDelta_Offset, iccDelta_MaxVal, error);
+ break;
- case PS_DELTA_TIME:
- codeTable = iccDeltaTime_Code;
- lengthTable = iccDeltaTime_Length;
+ case PS_DELTA_TIME:
+ codeTable = iccDeltaTime_Code;
+ lengthTable = iccDeltaTime_Length;
- bitCnt += encodeDeltaTime(hBitBuf, iccVal, iccValLast, nBands, codeTable,
- lengthTable, iccDelta_Offset, iccDelta_MaxVal, error);
- break;
+ bitCnt +=
+ encodeDeltaTime(hBitBuf, iccVal, iccValLast, nBands, codeTable,
+ lengthTable, iccDelta_Offset, iccDelta_MaxVal, error);
+ break;
- default:
- *error = 1;
+ default:
+ *error = 1;
}
return bitCnt;
}
-INT FDKsbrEnc_EncodeIpd(HANDLE_FDK_BITSTREAM hBitBuf,
- const INT *ipdVal,
- const INT *ipdValLast,
- const INT nBands,
- const PS_DELTA mode,
- INT *error)
-{
+INT FDKsbrEnc_EncodeIpd(HANDLE_FDK_BITSTREAM hBitBuf, const INT *ipdVal,
+ const INT *ipdValLast, const INT nBands,
+ const PS_DELTA mode, INT *error) {
const UINT *codeTable;
const UINT *lengthTable;
INT bitCnt = 0;
- switch(mode) {
- case PS_DELTA_FREQ:
- codeTable = ipdDeltaFreq_Code;
- lengthTable = ipdDeltaFreq_Length;
- bitCnt += encodeDeltaFreq(hBitBuf, ipdVal, nBands, codeTable,
- lengthTable, ipdDelta_Offset, ipdDelta_MaxVal, error);
- break;
+ switch (mode) {
+ case PS_DELTA_FREQ:
+ codeTable = ipdDeltaFreq_Code;
+ lengthTable = ipdDeltaFreq_Length;
+ bitCnt += encodeDeltaFreq(hBitBuf, ipdVal, nBands, codeTable, lengthTable,
+ ipdDelta_Offset, ipdDelta_MaxVal, error);
+ break;
- case PS_DELTA_TIME:
- codeTable = ipdDeltaTime_Code;
- lengthTable = ipdDeltaTime_Length;
+ case PS_DELTA_TIME:
+ codeTable = ipdDeltaTime_Code;
+ lengthTable = ipdDeltaTime_Length;
- bitCnt += encodeDeltaTime(hBitBuf, ipdVal, ipdValLast, nBands, codeTable,
- lengthTable, ipdDelta_Offset, ipdDelta_MaxVal, error);
- break;
+ bitCnt +=
+ encodeDeltaTime(hBitBuf, ipdVal, ipdValLast, nBands, codeTable,
+ lengthTable, ipdDelta_Offset, ipdDelta_MaxVal, error);
+ break;
- default:
- *error = 1;
+ default:
+ *error = 1;
}
return bitCnt;
}
-INT FDKsbrEnc_EncodeOpd(HANDLE_FDK_BITSTREAM hBitBuf,
- const INT *opdVal,
- const INT *opdValLast,
- const INT nBands,
- const PS_DELTA mode,
- INT *error)
-{
+INT FDKsbrEnc_EncodeOpd(HANDLE_FDK_BITSTREAM hBitBuf, const INT *opdVal,
+ const INT *opdValLast, const INT nBands,
+ const PS_DELTA mode, INT *error) {
const UINT *codeTable;
const UINT *lengthTable;
INT bitCnt = 0;
- switch(mode) {
- case PS_DELTA_FREQ:
- codeTable = opdDeltaFreq_Code;
- lengthTable = opdDeltaFreq_Length;
- bitCnt += encodeDeltaFreq(hBitBuf, opdVal, nBands, codeTable,
- lengthTable, opdDelta_Offset, opdDelta_MaxVal, error);
- break;
+ switch (mode) {
+ case PS_DELTA_FREQ:
+ codeTable = opdDeltaFreq_Code;
+ lengthTable = opdDeltaFreq_Length;
+ bitCnt += encodeDeltaFreq(hBitBuf, opdVal, nBands, codeTable, lengthTable,
+ opdDelta_Offset, opdDelta_MaxVal, error);
+ break;
- case PS_DELTA_TIME:
- codeTable = opdDeltaTime_Code;
- lengthTable = opdDeltaTime_Length;
+ case PS_DELTA_TIME:
+ codeTable = opdDeltaTime_Code;
+ lengthTable = opdDeltaTime_Length;
- bitCnt += encodeDeltaTime(hBitBuf, opdVal, opdValLast, nBands, codeTable,
- lengthTable, opdDelta_Offset, opdDelta_MaxVal, error);
- break;
+ bitCnt +=
+ encodeDeltaTime(hBitBuf, opdVal, opdValLast, nBands, codeTable,
+ lengthTable, opdDelta_Offset, opdDelta_MaxVal, error);
+ break;
- default:
- *error = 1;
+ default:
+ *error = 1;
}
return bitCnt;
}
-static INT encodeIpdOpd(HANDLE_PS_OUT psOut,
- HANDLE_FDK_BITSTREAM hBitBuf )
-{
+static INT encodeIpdOpd(HANDLE_PS_OUT psOut, HANDLE_FDK_BITSTREAM hBitBuf) {
INT bitCnt = 0;
- INT error = 0;
+ INT error = 0;
INT env;
FDKsbrEnc_WriteBits_ps(hBitBuf, psOut->enableIpdOpd, 1);
- if(psOut->enableIpdOpd==1) {
+ if (psOut->enableIpdOpd == 1) {
INT *ipdLast = psOut->ipdLast;
INT *opdLast = psOut->opdLast;
- for(env=0; env<psOut->nEnvelopes; env++) {
- bitCnt += FDKsbrEnc_WriteBits_ps( hBitBuf, psOut->deltaIPD[env], 1);
- bitCnt += FDKsbrEnc_EncodeIpd( hBitBuf,
- psOut->ipd[env],
- ipdLast,
- getNoBands(psOut->iidMode),
- psOut->deltaIPD[env],
- &error);
-
- bitCnt += FDKsbrEnc_WriteBits_ps( hBitBuf, psOut->deltaOPD[env], 1);
- bitCnt += FDKsbrEnc_EncodeOpd( hBitBuf,
- psOut->opd[env],
- opdLast,
- getNoBands(psOut->iidMode),
- psOut->deltaOPD[env],
- &error );
+ for (env = 0; env < psOut->nEnvelopes; env++) {
+ bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, psOut->deltaIPD[env], 1);
+ bitCnt += FDKsbrEnc_EncodeIpd(hBitBuf, psOut->ipd[env], ipdLast,
+ getNoBands(psOut->iidMode),
+ psOut->deltaIPD[env], &error);
+
+ bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, psOut->deltaOPD[env], 1);
+ bitCnt += FDKsbrEnc_EncodeOpd(hBitBuf, psOut->opd[env], opdLast,
+ getNoBands(psOut->iidMode),
+ psOut->deltaOPD[env], &error);
}
/* reserved bit */
- bitCnt += FDKsbrEnc_WriteBits_ps( hBitBuf, 0, 1);
+ bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, 0, 1);
}
-
return bitCnt;
}
-static INT getEnvIdx(const INT nEnvelopes, const INT frameClass)
-{
+static INT getEnvIdx(const INT nEnvelopes, const INT frameClass) {
INT envIdx = 0;
- switch(nEnvelopes) {
- case 0:
- envIdx = 0;
- break;
-
- case 1:
- if (frameClass==0)
- envIdx = 1;
- else
+ switch (nEnvelopes) {
+ case 0:
envIdx = 0;
- break;
+ break;
- case 2:
- if (frameClass==0)
- envIdx = 2;
- else
- envIdx = 1;
- break;
+ case 1:
+ if (frameClass == 0)
+ envIdx = 1;
+ else
+ envIdx = 0;
+ break;
+
+ case 2:
+ if (frameClass == 0)
+ envIdx = 2;
+ else
+ envIdx = 1;
+ break;
- case 3:
- envIdx = 2;
- break;
+ case 3:
+ envIdx = 2;
+ break;
- case 4:
- envIdx = 3;
- break;
+ case 4:
+ envIdx = 3;
+ break;
- default:
- /* unsupported number of envelopes */
- envIdx = 0;
+ default:
+ /* unsupported number of envelopes */
+ envIdx = 0;
}
return envIdx;
}
-
-static INT encodePSExtension(const HANDLE_PS_OUT psOut,
- HANDLE_FDK_BITSTREAM hBitBuf )
-{
+static INT encodePSExtension(const HANDLE_PS_OUT psOut,
+ HANDLE_FDK_BITSTREAM hBitBuf) {
INT bitCnt = 0;
- if(psOut->enableIpdOpd==1) {
+ if (psOut->enableIpdOpd == 1) {
INT ipdOpdBits = 0;
- INT extSize = (2 + encodeIpdOpd(psOut,NULL)+7)>>3;
+ INT extSize = (2 + encodeIpdOpd(psOut, NULL) + 7) >> 3;
- if(extSize<15) {
- bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, extSize, 4);
- }
- else {
- bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, 15 , 4);
- bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, (extSize-15), 8);
+ if (extSize < 15) {
+ bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, extSize, 4);
+ } else {
+ bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, 15, 4);
+ bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, (extSize - 15), 8);
}
/* write ipd opd data */
ipdOpdBits += FDKsbrEnc_WriteBits_ps(hBitBuf, PS_EXT_ID_V0, 2);
- ipdOpdBits += encodeIpdOpd(psOut, hBitBuf );
+ ipdOpdBits += encodeIpdOpd(psOut, hBitBuf);
/* byte align the ipd opd data */
- if(ipdOpdBits%8)
- ipdOpdBits += FDKsbrEnc_WriteBits_ps(hBitBuf, 0, (8-(ipdOpdBits%8)) );
+ if (ipdOpdBits % 8)
+ ipdOpdBits += FDKsbrEnc_WriteBits_ps(hBitBuf, 0, (8 - (ipdOpdBits % 8)));
bitCnt += ipdOpdBits;
}
@@ -617,77 +552,69 @@ static INT encodePSExtension(const HANDLE_PS_OUT psOut,
return (bitCnt);
}
-INT FDKsbrEnc_WritePSBitstream(const HANDLE_PS_OUT psOut,
- HANDLE_FDK_BITSTREAM hBitBuf )
-{
+INT FDKsbrEnc_WritePSBitstream(const HANDLE_PS_OUT psOut,
+ HANDLE_FDK_BITSTREAM hBitBuf) {
INT psExtEnable = 0;
INT bitCnt = 0;
INT error = 0;
INT env;
- if(psOut != NULL){
-
+ if (psOut != NULL) {
/* PS HEADER */
- bitCnt += FDKsbrEnc_WriteBits_ps( hBitBuf, psOut->enablePSHeader, 1);
+ bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, psOut->enablePSHeader, 1);
- if(psOut->enablePSHeader) {
-
- bitCnt += FDKsbrEnc_WriteBits_ps( hBitBuf, psOut->enableIID, 1);
- if(psOut->enableIID) {
- bitCnt += FDKsbrEnc_WriteBits_ps( hBitBuf, psOut->iidMode, 3);
+ if (psOut->enablePSHeader) {
+ bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, psOut->enableIID, 1);
+ if (psOut->enableIID) {
+ bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, psOut->iidMode, 3);
}
- bitCnt += FDKsbrEnc_WriteBits_ps( hBitBuf, psOut->enableICC, 1);
- if(psOut->enableICC) {
- bitCnt += FDKsbrEnc_WriteBits_ps( hBitBuf, psOut->iccMode, 3);
+ bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, psOut->enableICC, 1);
+ if (psOut->enableICC) {
+ bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, psOut->iccMode, 3);
}
- if(psOut->enableIpdOpd) {
+ if (psOut->enableIpdOpd) {
psExtEnable = 1;
}
- bitCnt += FDKsbrEnc_WriteBits_ps( hBitBuf, psExtEnable, 1);
+ bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, psExtEnable, 1);
}
/* Frame class, number of envelopes */
- bitCnt += FDKsbrEnc_WriteBits_ps( hBitBuf, psOut->frameClass, 1);
- bitCnt += FDKsbrEnc_WriteBits_ps( hBitBuf, getEnvIdx(psOut->nEnvelopes, psOut->frameClass), 2);
+ bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, psOut->frameClass, 1);
+ bitCnt += FDKsbrEnc_WriteBits_ps(
+ hBitBuf, getEnvIdx(psOut->nEnvelopes, psOut->frameClass), 2);
- if(psOut->frameClass==1) {
- for(env=0; env<psOut->nEnvelopes; env++) {
- bitCnt += FDKsbrEnc_WriteBits_ps( hBitBuf, psOut->frameBorder[env], 5);
+ if (psOut->frameClass == 1) {
+ for (env = 0; env < psOut->nEnvelopes; env++) {
+ bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, psOut->frameBorder[env], 5);
}
}
- if(psOut->enableIID==1) {
+ if (psOut->enableIID == 1) {
INT *iidLast = psOut->iidLast;
- for(env=0; env<psOut->nEnvelopes; env++) {
- bitCnt += FDKsbrEnc_WriteBits_ps( hBitBuf, psOut->deltaIID[env], 1);
- bitCnt += FDKsbrEnc_EncodeIid( hBitBuf,
- psOut->iid[env],
- iidLast,
- getNoBands(psOut->iidMode),
- (PS_IID_RESOLUTION)getIIDRes(psOut->iidMode),
- psOut->deltaIID[env],
- &error );
+ for (env = 0; env < psOut->nEnvelopes; env++) {
+ bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, psOut->deltaIID[env], 1);
+ bitCnt += FDKsbrEnc_EncodeIid(
+ hBitBuf, psOut->iid[env], iidLast, getNoBands(psOut->iidMode),
+ (PS_IID_RESOLUTION)getIIDRes(psOut->iidMode), psOut->deltaIID[env],
+ &error);
iidLast = psOut->iid[env];
}
}
- if(psOut->enableICC==1) {
+ if (psOut->enableICC == 1) {
INT *iccLast = psOut->iccLast;
- for(env=0; env<psOut->nEnvelopes; env++) {
- bitCnt += FDKsbrEnc_WriteBits_ps( hBitBuf, psOut->deltaICC[env], 1);
- bitCnt += FDKsbrEnc_EncodeIcc( hBitBuf,
- psOut->icc[env],
- iccLast,
- getNoBands(psOut->iccMode),
- psOut->deltaICC[env],
- &error);
+ for (env = 0; env < psOut->nEnvelopes; env++) {
+ bitCnt += FDKsbrEnc_WriteBits_ps(hBitBuf, psOut->deltaICC[env], 1);
+ bitCnt += FDKsbrEnc_EncodeIcc(hBitBuf, psOut->icc[env], iccLast,
+ getNoBands(psOut->iccMode),
+ psOut->deltaICC[env], &error);
iccLast = psOut->icc[env];
}
}
- if(psExtEnable!=0) {
+ if (psExtEnable != 0) {
bitCnt += encodePSExtension(psOut, hBitBuf);
}
@@ -695,4 +622,3 @@ INT FDKsbrEnc_WritePSBitstream(const HANDLE_PS_OUT psOut,
return bitCnt;
}
-
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-26 17:53:53 +0000