Upgrade to FDKv2

Bug: 71430241
Test: CTS DecoderTest and DecoderTestAacDrc

original-Change-Id: Iaa20f749b8a04d553b20247cfe1a8930ebbabe30

Apply clang-format also on header files.

original-Change-Id: I14de1ef16bbc79ec0283e745f98356a10efeb2e4

Fixes for MPEG-D DRC

original-Change-Id: If1de2d74bbbac84b3f67de3b88b83f6a23b8a15c

Catch unsupported tw_mdct at an early stage

original-Change-Id: Ied9dd00d754162a0e3ca1ae3e6b854315d818afe

Fixing PVC transition frames

original-Change-Id: Ib75725abe39252806c32d71176308f2c03547a4e

Move qmf bands sanity check

original-Change-Id: Iab540c3013c174d9490d2ae100a4576f51d8dbc4

Initialize scaling variable

original-Change-Id: I3c4087101b70e998c71c1689b122b0d7762e0f9e

Add 16 qmf band configuration to getSlotNrgHQ()

original-Change-Id: I49a5d30f703a1b126ff163df9656db2540df21f1

Always apply byte alignment at the end of the AudioMuxElement

original-Change-Id: I42d560287506d65d4c3de8bfe3eb9a4ebeb4efc7

Setup SBR element only if no parse error exists

original-Change-Id: I1915b73704bc80ab882b9173d6bec59cbd073676

Additional array index check in HCR

original-Change-Id: I18cc6e501ea683b5009f1bbee26de8ddd04d8267

Fix fade-in index selection in concealment module

original-Change-Id: Ibf802ed6ed8c05e9257e1f3b6d0ac1162e9b81c1

Enable explicit backward compatible parser for AAC_LD

original-Change-Id: I27e9c678dcb5d40ed760a6d1e06609563d02482d

Skip spatial specific config in explicit backward compatible ASC

original-Change-Id: Iff7cc365561319e886090cedf30533f562ea4d6e

Update flags description in decoder API

original-Change-Id: I9a5b4f8da76bb652f5580cbd3ba9760425c43830

Add QMF domain reset function

original-Change-Id: I4f89a8a2c0277d18103380134e4ed86996e9d8d6

DRC upgrade v2.1.0

original-Change-Id: I5731c0540139dab220094cd978ef42099fc45b74

Fix integer overflow in sqrtFixp_lookup()

original-Change-Id: I429a6f0d19aa2cc957e0f181066f0ca73968c914

Fix integer overflow in invSqrtNorm2()

original-Change-Id: I84de5cbf9fb3adeb611db203fe492fabf4eb6155

Fix integer overflow in GenerateRandomVector()

original-Change-Id: I3118a641008bd9484d479e5b0b1ee2b5d7d44d74

Fix integer overflow in adjustTimeSlot_EldGrid()

original-Change-Id: I29d503c247c5c8282349b79df940416a512fb9d5

Fix integer overflow in FDKsbrEnc_codeEnvelope()

original-Change-Id: I6b34b61ebb9d525b0c651ed08de2befc1f801449

Follow-up on: Fix integer overflow in adjustTimeSlot_EldGrid()

original-Change-Id: I6f8f578cc7089e5eb7c7b93e580b72ca35ad689a

Fix integer overflow in get_pk_v2()

original-Change-Id: I63375bed40d45867f6eeaa72b20b1f33e815938c

Fix integer overflow in Syn_filt_zero()

original-Change-Id: Ie0c02fdfbe03988f9d3b20d10cd9fe4c002d1279

Fix integer overflow in CFac_CalcFacSignal()

original-Change-Id: Id2d767c40066c591b51768e978eb8af3b803f0c5

Fix integer overflow in FDKaacEnc_FDKaacEnc_calcPeNoAH()

original-Change-Id: Idcbd0f4a51ae2550ed106aa6f3d678d1f9724841

Fix integer overflow in sbrDecoder_calculateGainVec()

original-Change-Id: I7081bcbe29c5cede9821b38d93de07c7add2d507

Fix integer overflow in CLpc_SynthesisLattice()

original-Change-Id: I4a95ddc18de150102352d4a1845f06094764c881

Fix integer overflow in Pred_Lt4()

original-Change-Id: I4dbd012b2de7d07c3e70a47b92e3bfae8dbc750a

Fix integer overflow in FDKsbrEnc_InitSbrFastTransientDetector()

original-Change-Id: I788cbec1a4a00f44c2f3a72ad7a4afa219807d04

Fix unsigned integer overflow in FDKaacEnc_WriteBitstream()

original-Change-Id: I68fc75166e7d2cd5cd45b18dbe3d8c2a92f1822a

Fix unsigned integer overflow in FDK_MetadataEnc_Init()

original-Change-Id: Ie8d025f9bcdb2442c704bd196e61065c03c10af4

Fix overflow in pseudo random number generators

original-Change-Id: I3e2551ee01356297ca14e3788436ede80bd5513c

Fix unsigned integer overflow in sbrDecoder_Parse()

original-Change-Id: I3f231b2f437e9c37db4d5b964164686710eee971

Fix unsigned integer overflow in longsub()

original-Change-Id: I73c2bc50415cac26f1f5a29e125bbe75f9180a6e

Fix unsigned integer overflow in CAacDecoder_DecodeFrame()

original-Change-Id: Ifce2db4b1454b46fa5f887e9d383f1cc43b291e4

Fix overflow at CLpdChannelStream_Read()

original-Change-Id: Idb9d822ce3a4272e4794b643644f5434e2d4bf3f

Fix unsigned integer overflow in Hcr_State_BODY_SIGN_ESC__ESC_WORD()

original-Change-Id: I1ccf77c0015684b85534c5eb97162740a870b71c

Fix unsigned integer overflow in UsacConfig_Parse()

original-Change-Id: Ie6d27f84b6ae7eef092ecbff4447941c77864d9f

Fix unsigned integer overflow in aacDecoder_drcParse()

original-Change-Id: I713f28e883eea3d70b6fa56a7b8f8c22bcf66ca0

Fix unsigned integer overflow in aacDecoder_drcReadCompression()

original-Change-Id: Ia34dfeb88c4705c558bce34314f584965cafcf7a

Fix unsigned integer overflow in CDataStreamElement_Read()

original-Change-Id: Iae896cc1d11f0a893d21be6aa90bd3e60a2c25f0

Fix unsigned integer overflow in transportDec_AdjustEndOfAccessUnit()

original-Change-Id: I64cf29a153ee784bb4a16fdc088baabebc0007dc

Fix unsigned integer overflow in transportDec_GetAuBitsRemaining()

original-Change-Id: I975b3420faa9c16a041874ba0db82e92035962e4

Fix unsigned integer overflow in extractExtendedData()

original-Change-Id: I2a59eb09e2053cfb58dfb75fcecfad6b85a80a8f

Fix signed integer overflow in CAacDecoder_ExtPayloadParse()

original-Change-Id: I4ad5ca4e3b83b5d964f1c2f8c5e7b17c477c7929

Fix unsigned integer overflow in CAacDecoder_DecodeFrame()

original-Change-Id: I29a39df77d45c52a0c9c5c83c1ba81f8d0f25090

Follow-up on: Fix integer overflow in CLpc_SynthesisLattice()

original-Change-Id: I8fb194ffc073a3432a380845be71036a272d388f

Fix signed integer overflow in _interpolateDrcGain()

original-Change-Id: I879ec9ab14005069a7c47faf80e8bc6e03d22e60

Fix unsigned integer overflow in FDKreadBits()

original-Change-Id: I1f47a6a8037ff70375aa8844947d5681bb4287ad

Fix unsigned integer overflow in FDKbyteAlign()

original-Change-Id: Id5f3a11a0c9e50fc6f76ed6c572dbd4e9f2af766

Fix unsigned integer overflow in FDK_get32()

original-Change-Id: I9d33b8e97e3d38cbb80629cb859266ca0acdce96

Fix unsigned integer overflow in FDK_pushBack()

original-Change-Id: Ic87f899bc8c6acf7a377a8ca7f3ba74c3a1e1c19

Fix unsigned integer overflow in FDK_pushForward()

original-Change-Id: I3b754382f6776a34be1602e66694ede8e0b8effc

Fix unsigned integer overflow in ReadPsData()

original-Change-Id: I25361664ba8139e32bbbef2ca8c106a606ce9c37

Fix signed integer overflow in E_UTIL_residu()

original-Change-Id: I8c3abd1f437ee869caa8fb5903ce7d3d641b6aad

REVERT: Follow-up on: Integer overflow in CLpc_SynthesisLattice().

original-Change-Id: I3d340099acb0414795c8dfbe6362bc0a8f045f9b

Follow-up on: Fix integer overflow in CLpc_SynthesisLattice()

original-Change-Id: I4aedb8b3a187064e9f4d985175aa55bb99cc7590

Follow-up on: Fix unsigned integer overflow in aacDecoder_drcParse()

original-Change-Id: I2aa2e13916213bf52a67e8b0518e7bf7e57fb37d

Fix integer overflow in acelp

original-Change-Id: Ie6390c136d84055f8b728aefbe4ebef6e029dc77

Fix unsigned integer overflow in aacDecoder_UpdateBitStreamCounters()

original-Change-Id: I391ffd97ddb0b2c184cba76139bfb356a3b4d2e2

Adjust concealment default settings

original-Change-Id: I6a95db935a327c47df348030bcceafcb29f54b21

Saturate estimatedStartPos

original-Change-Id: I27be2085e0ae83ec9501409f65e003f6bcba1ab6

Negative shift exponent in _interpolateDrcGain()

original-Change-Id: I18edb26b26d002aafd5e633d4914960f7a359c29

Negative shift exponent in calculateICC()

original-Change-Id: I3dcd2ae98d2eb70ee0d59750863cbb2a6f4f8aba

Too large shift exponent in FDK_put()

original-Change-Id: Ib7d9aaa434d2d8de4a13b720ca0464b31ca9b671

Too large shift exponent in CalcInvLdData()

original-Change-Id: I43e6e78d4cd12daeb1dcd5d82d1798bdc2550262

Member access within null pointer of type SBR_CHANNEL

original-Change-Id: Idc5e4ea8997810376d2f36bbdf628923b135b097

Member access within null pointer of type CpePersistentData

original-Change-Id: Ib6c91cb0d37882768e5baf63324e429589de0d9d

Member access within null pointer FDKaacEnc_psyMain()

original-Change-Id: I7729b7f4479970531d9dc823abff63ca52e01997

Member access within null pointer FDKaacEnc_GetPnsParam()

original-Change-Id: I9aa3b9f3456ae2e0f7483dbd5b3dde95fc62da39

Member access within null pointer FDKsbrEnc_EnvEncodeFrame()

original-Change-Id: I67936f90ea714e90b3e81bc0dd1472cc713eb23a

Add HCR sanity check

original-Change-Id: I6c1d9732ebcf6af12f50b7641400752f74be39f7

Fix memory issue for HBE edge case with 8:3 SBR

original-Change-Id: I11ea58a61e69fbe8bf75034b640baee3011e63e9

Additional SBR parametrization sanity check for ELD

original-Change-Id: Ie26026fbfe174c2c7b3691f6218b5ce63e322140

Add MPEG-D DRC channel layout check

original-Change-Id: Iea70a74f171b227cce636a9eac4ba662777a2f72

Additional out-of-bounds checks in MPEG-D DRC

original-Change-Id: Ife4a8c3452c6fde8a0a09e941154a39a769777d4

Change-Id: Ic63cb2f628720f54fe9b572b0cb528e2599c624e

1 files changed, 1063 insertions, 0 deletions

diff --git a/libFDK/src/nlc_dec.cpp b/libFDK/src/nlc_dec.cpp
new file mode 100644
index 0000000..8a8ccfd
--- /dev/null
+++ b/libFDK/src/nlc_dec.cpp
@@ -0,0 +1,1063 @@
+/* -----------------------------------------------------------------------------
+Software License for The Fraunhofer FDK AAC Codec Library for Android
+
+© Copyright  1995 - 2018 Fraunhofer-Gesellschaft zur Förderung der angewandten
+Forschung e.V. All rights reserved.
+
+ 1.    INTRODUCTION
+The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software
+that implements the MPEG Advanced Audio Coding ("AAC") encoding and decoding
+scheme for digital audio. This FDK AAC Codec software is intended to be used on
+a wide variety of Android devices.
+
+AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient
+general perceptual audio codecs. AAC-ELD is considered the best-performing
+full-bandwidth communications codec by independent studies and is widely
+deployed. AAC has been standardized by ISO and IEC as part of the MPEG
+specifications.
+
+Patent licenses for necessary patent claims for the FDK AAC Codec (including
+those of Fraunhofer) may be obtained through Via Licensing
+(www.vialicensing.com) or through the respective patent owners individually for
+the purpose of encoding or decoding bit streams in products that are compliant
+with the ISO/IEC MPEG audio standards. Please note that most manufacturers of
+Android devices already license these patent claims through Via Licensing or
+directly from the patent owners, and therefore FDK AAC Codec software may
+already be covered under those patent licenses when it is used for those
+licensed purposes only.
+
+Commercially-licensed AAC software libraries, including floating-point versions
+with enhanced sound quality, are also available from Fraunhofer. Users are
+encouraged to check the Fraunhofer website for additional applications
+information and documentation.
+
+2.    COPYRIGHT LICENSE
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted without payment of copyright license fees provided that you
+satisfy the following conditions:
+
+You must retain the complete text of this software license in redistributions of
+the FDK AAC Codec or your modifications thereto in source code form.
+
+You must retain the complete text of this software license in the documentation
+and/or other materials provided with redistributions of the FDK AAC Codec or
+your modifications thereto in binary form. You must make available free of
+charge copies of the complete source code of the FDK AAC Codec and your
+modifications thereto to recipients of copies in binary form.
+
+The name of Fraunhofer may not be used to endorse or promote products derived
+from this library without prior written permission.
+
+You may not charge copyright license fees for anyone to use, copy or distribute
+the FDK AAC Codec software or your modifications thereto.
+
+Your modified versions of the FDK AAC Codec must carry prominent notices stating
+that you changed the software and the date of any change. For modified versions
+of the FDK AAC Codec, the term "Fraunhofer FDK AAC Codec Library for Android"
+must be replaced by the term "Third-Party Modified Version of the Fraunhofer FDK
+AAC Codec Library for Android."
+
+3.    NO PATENT LICENSE
+
+NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without
+limitation the patents of Fraunhofer, ARE GRANTED BY THIS SOFTWARE LICENSE.
+Fraunhofer provides no warranty of patent non-infringement with respect to this
+software.
+
+You may use this FDK AAC Codec software or modifications thereto only for
+purposes that are authorized by appropriate patent licenses.
+
+4.    DISCLAIMER
+
+This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright
+holders and contributors "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES,
+including but not limited to the implied warranties of merchantability and
+fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary,
+or consequential damages, including but not limited to procurement of substitute
+goods or services; loss of use, data, or profits, or business interruption,
+however caused and on any theory of liability, whether in contract, strict
+liability, or tort (including negligence), arising in any way out of the use of
+this software, even if advised of the possibility of such damage.
+
+5.    CONTACT INFORMATION
+
+Fraunhofer Institute for Integrated Circuits IIS
+Attention: Audio and Multimedia Departments - FDK AAC LL
+Am Wolfsmantel 33
+91058 Erlangen, Germany
+
+www.iis.fraunhofer.de/amm
+amm-info@iis.fraunhofer.de
+----------------------------------------------------------------------------- */
+
+/******************* Library for basic calculation routines ********************
+
+   Author(s):   Omer Osman
+
+   Description: SAC/SAOC Dec Noiseless Coding
+
+*******************************************************************************/
+
+#include "nlc_dec.h"
+#include "FDK_tools_rom.h"
+
+/* MAX_PARAMETER_BANDS defines array length in huffdec */
+
+#ifndef min
+#define min(a, b) (((a) < (b)) ? (a) : (b))
+#endif
+
+ERROR_t sym_restoreIPD(HANDLE_FDK_BITSTREAM strm, int lav, SCHAR data[2]) {
+  int sum_val = data[0] + data[1];
+  int diff_val = data[0] - data[1];
+
+  if (sum_val > lav) {
+    data[0] = -sum_val + (2 * lav + 1);
+    data[1] = -diff_val;
+  } else {
+    data[0] = sum_val;
+    data[1] = diff_val;
+  }
+
+  if (data[0] - data[1] != 0) {
+    ULONG sym_bit;
+    sym_bit = FDKreadBits(strm, 1);
+    if (sym_bit) {
+      int tmp;
+      tmp = data[0];
+      data[0] = data[1];
+      data[1] = tmp;
+    }
+  }
+
+  return HUFFDEC_OK;
+}
+
+static int ilog2(unsigned int i) {
+  int l = 0;
+
+  if (i) i--;
+  while (i > 0) {
+    i >>= 1;
+    l++;
+  }
+
+  return l;
+}
+
+static ERROR_t pcm_decode(HANDLE_FDK_BITSTREAM strm, SCHAR* out_data_1,
+                          SCHAR* out_data_2, int offset, int num_val,
+                          int num_levels) {
+  int i = 0, j = 0, idx = 0;
+  int max_grp_len = 0, next_val = 0;
+  ULONG tmp;
+
+  int pcm_chunk_size[7] = {0};
+
+  switch (num_levels) {
+    case 3:
+      max_grp_len = 5;
+      break;
+    case 7:
+      max_grp_len = 6;
+      break;
+    case 11:
+      max_grp_len = 2;
+      break;
+    case 13:
+      max_grp_len = 4;
+      break;
+    case 19:
+      max_grp_len = 4;
+      break;
+    case 25:
+      max_grp_len = 3;
+      break;
+    case 51:
+      max_grp_len = 4;
+      break;
+    case 4:
+    case 8:
+    case 15:
+    case 16:
+    case 26:
+    case 31:
+      max_grp_len = 1;
+      break;
+    default:
+      return HUFFDEC_NOTOK;
+  }
+
+  tmp = 1;
+  for (i = 1; i <= max_grp_len; i++) {
+    tmp *= num_levels;
+    pcm_chunk_size[i] = ilog2(tmp);
+  }
+
+  for (i = 0; i < num_val; i += max_grp_len) {
+    int grp_len, grp_val, data;
+    grp_len = min(max_grp_len, num_val - i);
+    data = FDKreadBits(strm, pcm_chunk_size[grp_len]);
+
+    grp_val = data;
+
+    for (j = 0; j < grp_len; j++) {
+      idx = i + (grp_len - j - 1);
+      next_val = grp_val % num_levels;
+
+      if (out_data_2 == NULL) {
+        out_data_1[idx] = next_val - offset;
+      } else if (out_data_1 == NULL) {
+        out_data_2[idx] = next_val - offset;
+      } else {
+        if (idx % 2) {
+          out_data_2[idx / 2] = next_val - offset;
+        } else {
+          out_data_1[idx / 2] = next_val - offset;
+        }
+      }
+
+      grp_val = (grp_val - next_val) / num_levels;
+    }
+  }
+
+  return HUFFDEC_OK;
+}
+
+static ERROR_t huff_read(HANDLE_FDK_BITSTREAM strm,
+                         const SHORT (*nodeTab)[MAX_ENTRIES][2],
+                         int* out_data) {
+  int node = 0;
+  int len = 0;
+
+  do {
+    ULONG next_bit;
+    next_bit = FDKreadBits(strm, 1);
+    len++;
+    node = (*nodeTab)[node][next_bit];
+  } while (node > 0);
+
+  *out_data = node;
+
+  return HUFFDEC_OK;
+}
+
+static ERROR_t huff_read_2D(HANDLE_FDK_BITSTREAM strm,
+                            const SHORT (*nodeTab)[MAX_ENTRIES][2],
+                            SCHAR out_data[2], int* escape) {
+  ERROR_t err = HUFFDEC_OK;
+
+  int huff_2D_8bit = 0;
+  int node = 0;
+
+  if ((err = huff_read(strm, nodeTab, &node)) != HUFFDEC_OK) {
+    goto bail;
+  }
+  *escape = (node == 0);
+
+  if (*escape) {
+    out_data[0] = 0;
+    out_data[1] = 1;
+  } else {
+    huff_2D_8bit = -(node + 1);
+    out_data[0] = huff_2D_8bit >> 4;
+    out_data[1] = huff_2D_8bit & 0xf;
+  }
+
+bail:
+  return err;
+}
+
+static ERROR_t sym_restore(HANDLE_FDK_BITSTREAM strm, int lav, SCHAR data[2]) {
+  ULONG sym_bit = 0;
+
+  int sum_val = data[0] + data[1];
+  int diff_val = data[0] - data[1];
+
+  if (sum_val > lav) {
+    data[0] = -sum_val + (2 * lav + 1);
+    data[1] = -diff_val;
+  } else {
+    data[0] = sum_val;
+    data[1] = diff_val;
+  }
+
+  if (data[0] + data[1] != 0) {
+    sym_bit = FDKreadBits(strm, 1);
+    if (sym_bit) {
+      data[0] = -data[0];
+      data[1] = -data[1];
+    }
+  }
+
+  if (data[0] - data[1] != 0) {
+    sym_bit = FDKreadBits(strm, 1);
+    if (sym_bit) {
+      int tmp;
+      tmp = data[0];
+      data[0] = data[1];
+      data[1] = tmp;
+    }
+  }
+
+  return HUFFDEC_OK;
+}
+
+static ERROR_t huff_dec_1D(HANDLE_FDK_BITSTREAM strm, const DATA_TYPE data_type,
+                           const INT dim1, SCHAR* out_data, const INT num_val,
+                           const INT p0_flag)
+
+{
+  ERROR_t err = HUFFDEC_OK;
+  int i = 0, node = 0, offset = 0;
+  int od = 0, od_sign = 0;
+  ULONG data = 0;
+  int bitsAvail = 0;
+
+  const SHORT(*partTab)[MAX_ENTRIES][2] = NULL;
+  const SHORT(*nodeTab)[MAX_ENTRIES][2] = NULL;
+
+  switch (data_type) {
+    case t_CLD:
+      partTab = (HANDLE_HUFF_NODE)&FDK_huffPart0Nodes.cld[0][0];
+      nodeTab = (HANDLE_HUFF_NODE)&FDK_huffCLDNodes.h1D[dim1]->nodeTab[0][0];
+      break;
+    case t_ICC:
+      partTab = (HANDLE_HUFF_NODE)&FDK_huffPart0Nodes.icc[0][0];
+      nodeTab = (HANDLE_HUFF_NODE)&FDK_huffICCNodes.h1D[dim1]->nodeTab[0][0];
+      break;
+    case t_OLD:
+      partTab = (HANDLE_HUFF_NODE)&FDK_huffPart0Nodes.old[0][0];
+      nodeTab = (HANDLE_HUFF_NODE)&huffOLDNodes.h1D[dim1]->nodeTab[0][0];
+      break;
+    case t_IPD:
+      partTab = (HANDLE_HUFF_NODE)&FDK_huffPart0Nodes.ipd[0][0];
+      nodeTab = (HANDLE_HUFF_NODE)&FDK_huffIPDNodes.h1D[dim1].nodeTab[0][0];
+      break;
+    default:
+      FDK_ASSERT(0);
+      err = HUFFDEC_NOTOK;
+      goto bail;
+  }
+
+  if (p0_flag) {
+    if ((err = huff_read(strm, partTab, &node)) != HUFFDEC_OK) {
+      goto bail;
+    }
+
+    out_data[0] = -(node + 1);
+    offset = 1;
+  }
+
+  for (i = offset; i < num_val; i++) {
+    bitsAvail = FDKgetValidBits(strm);
+    if (bitsAvail < 1) {
+      err = HUFFDEC_NOTOK;
+      goto bail;
+    }
+
+    if ((err = huff_read(strm, nodeTab, &node)) != HUFFDEC_OK) {
+      goto bail;
+    }
+    od = -(node + 1);
+
+    if (data_type != t_IPD) {
+      if (od != 0) {
+        bitsAvail = FDKgetValidBits(strm);
+        if (bitsAvail < 1) {
+          err = HUFFDEC_NOTOK;
+          goto bail;
+        }
+
+        data = FDKreadBits(strm, 1);
+        od_sign = data;
+
+        if (od_sign) od = -od;
+      }
+    }
+
+    out_data[i] = od;
+  }
+
+bail:
+  return err;
+}
+
+static ERROR_t huff_dec_2D(HANDLE_FDK_BITSTREAM strm, const DATA_TYPE data_type,
+                           const INT dim1, const INT dim2, SCHAR out_data[][2],
+                           const INT num_val, const INT stride,
+                           SCHAR* p0_data[2]) {
+  ERROR_t err = HUFFDEC_OK;
+  int i = 0, lav = 0, escape = 0, escCntr = 0;
+  int node = 0;
+  unsigned long data = 0;
+
+  SCHAR esc_data[2][28] = {{0}};
+  int escIdx[28] = {0};
+  const SHORT(*nodeTab)[MAX_ENTRIES][2] = NULL;
+
+  /* LAV */
+  if ((err =
+           huff_read(strm, (HANDLE_HUFF_NODE)&FDK_huffLavIdxNodes.nodeTab[0][0],
+                     &node)) != HUFFDEC_OK) {
+    goto bail;
+  }
+  data = -(node + 1);
+
+  switch (data_type) {
+    case t_CLD:
+      lav = 2 * data + 3; /* 3, 5, 7, 9 */
+      nodeTab = (HANDLE_HUFF_NODE)&FDK_huffPart0Nodes.cld[0][0];
+      break;
+    case t_ICC:
+      lav = 2 * data + 1; /* 1, 3, 5, 7 */
+      nodeTab = (HANDLE_HUFF_NODE)&FDK_huffPart0Nodes.icc[0][0];
+      break;
+    case t_OLD:
+      lav = 3 * data + 3;
+      nodeTab = (HANDLE_HUFF_NODE)&FDK_huffPart0Nodes.old[0][0];
+      break;
+    case t_IPD:
+      if (data == 0)
+        data = 3;
+      else
+        data--;
+      lav = 2 * data + 1; /* 1, 3, 5, 7 */
+      nodeTab = (HANDLE_HUFF_NODE)&FDK_huffPart0Nodes.ipd[0][0];
+      break;
+    default:
+      FDK_ASSERT(0);
+      err = HUFFDEC_NOTOK;
+      goto bail;
+  }
+
+  /* Partition 0 */
+  if (p0_data[0] != NULL) {
+    if ((err = huff_read(strm, nodeTab, &node)) != HUFFDEC_OK) {
+      goto bail;
+    }
+    *p0_data[0] = -(node + 1);
+  }
+  if (p0_data[1] != NULL) {
+    if ((err = huff_read(strm, nodeTab, &node)) != HUFFDEC_OK) {
+      goto bail;
+    }
+    *p0_data[1] = -(node + 1);
+  }
+
+  switch (data_type) {
+    case t_CLD:
+      switch (lav) {
+        case 3:
+          nodeTab =
+              (HANDLE_HUFF_NODE)&FDK_huffCLDNodes.h2D[dim1][dim2]->lav3[0][0];
+          break;
+        case 5:
+          nodeTab =
+              (HANDLE_HUFF_NODE)&FDK_huffCLDNodes.h2D[dim1][dim2]->lav5[0][0];
+          break;
+        case 7:
+          nodeTab =
+              (HANDLE_HUFF_NODE)&FDK_huffCLDNodes.h2D[dim1][dim2]->lav7[0][0];
+          break;
+        case 9:
+          nodeTab =
+              (HANDLE_HUFF_NODE)&FDK_huffCLDNodes.h2D[dim1][dim2]->lav9[0][0];
+          break;
+      }
+      break;
+    case t_ICC:
+      switch (lav) {
+        case 1:
+          nodeTab =
+              (HANDLE_HUFF_NODE)&FDK_huffICCNodes.h2D[dim1][dim2]->lav1[0][0];
+          break;
+        case 3:
+          nodeTab =
+              (HANDLE_HUFF_NODE)&FDK_huffICCNodes.h2D[dim1][dim2]->lav3[0][0];
+          break;
+        case 5:
+          nodeTab =
+              (HANDLE_HUFF_NODE)&FDK_huffICCNodes.h2D[dim1][dim2]->lav5[0][0];
+          break;
+        case 7:
+          nodeTab =
+              (HANDLE_HUFF_NODE)&FDK_huffICCNodes.h2D[dim1][dim2]->lav7[0][0];
+          break;
+      }
+      break;
+    case t_OLD:
+      switch (lav) {
+        case 3:
+          nodeTab = (HANDLE_HUFF_NODE)&huffOLDNodes.h2D[dim1][dim2]->lav3[0][0];
+          break;
+        case 6:
+          nodeTab = (HANDLE_HUFF_NODE)&huffOLDNodes.h2D[dim1][dim2]->lav6[0][0];
+          break;
+        case 9:
+          nodeTab = (HANDLE_HUFF_NODE)&huffOLDNodes.h2D[dim1][dim2]->lav9[0][0];
+          break;
+        case 12:
+          nodeTab =
+              (HANDLE_HUFF_NODE)&huffOLDNodes.h2D[dim1][dim2]->lav12[0][0];
+          break;
+      }
+      break;
+    case t_IPD:
+      switch (lav) {
+        case 1:
+          nodeTab =
+              (HANDLE_HUFF_NODE)&FDK_huffIPDNodes.h2D[dim1][dim2].lav1[0][0];
+          break;
+        case 3:
+          nodeTab =
+              (HANDLE_HUFF_NODE)&FDK_huffIPDNodes.h2D[dim1][dim2].lav3[0][0];
+          break;
+        case 5:
+          nodeTab =
+              (HANDLE_HUFF_NODE)&FDK_huffIPDNodes.h2D[dim1][dim2].lav5[0][0];
+          break;
+        case 7:
+          nodeTab =
+              (HANDLE_HUFF_NODE)&FDK_huffIPDNodes.h2D[dim1][dim2].lav7[0][0];
+          break;
+      }
+      break;
+    default:
+      break;
+  }
+
+  for (i = 0; i < num_val; i += stride) {
+    if ((err = huff_read_2D(strm, nodeTab, out_data[i], &escape)) !=
+        HUFFDEC_OK) {
+      goto bail;
+    }
+
+    if (escape) {
+      escIdx[escCntr++] = i;
+    } else {
+      if (data_type == t_IPD) {
+        if ((err = sym_restoreIPD(strm, lav, out_data[i])) != HUFFDEC_OK) {
+          goto bail;
+        }
+      } else {
+        if ((err = sym_restore(strm, lav, out_data[i])) != HUFFDEC_OK) {
+          goto bail;
+        }
+      }
+    }
+  } /* i */
+
+  if (escCntr > 0) {
+    if ((err = pcm_decode(strm, esc_data[0], esc_data[1], 0, 2 * escCntr,
+                          (2 * lav + 1))) != HUFFDEC_OK) {
+      goto bail;
+    }
+
+    for (i = 0; i < escCntr; i++) {
+      out_data[escIdx[i]][0] = esc_data[0][i] - lav;
+      out_data[escIdx[i]][1] = esc_data[1][i] - lav;
+    }
+  }
+bail:
+  return err;
+}
+
+static ERROR_t huff_decode(HANDLE_FDK_BITSTREAM strm, SCHAR* out_data_1,
+                           SCHAR* out_data_2, DATA_TYPE data_type,
+                           DIFF_TYPE diff_type_1, DIFF_TYPE diff_type_2,
+                           int num_val, CODING_SCHEME* cdg_scheme, int ldMode) {
+  ERROR_t err = HUFFDEC_OK;
+  DIFF_TYPE diff_type;
+
+  int i = 0;
+  ULONG data = 0;
+
+  SCHAR pair_vec[28][2];
+
+  SCHAR* p0_data_1[2] = {NULL, NULL};
+  SCHAR* p0_data_2[2] = {NULL, NULL};
+
+  int p0_flag[2];
+
+  int num_val_1_int = num_val;
+  int num_val_2_int = num_val;
+
+  SCHAR* out_data_1_int = out_data_1;
+  SCHAR* out_data_2_int = out_data_2;
+
+  int df_rest_flag_1 = 0;
+  int df_rest_flag_2 = 0;
+
+  int hufYY1;
+  int hufYY2;
+  int hufYY;
+
+  /* Coding scheme */
+  data = FDKreadBits(strm, 1);
+  *cdg_scheme = (CODING_SCHEME)(data << PAIR_SHIFT);
+
+  if (*cdg_scheme >> PAIR_SHIFT == HUFF_2D) {
+    if ((out_data_1 != NULL) && (out_data_2 != NULL) && (ldMode == 0)) {
+      data = FDKreadBits(strm, 1);
+      *cdg_scheme = (CODING_SCHEME)(*cdg_scheme | data);
+    } else {
+      *cdg_scheme = (CODING_SCHEME)(*cdg_scheme | FREQ_PAIR);
+    }
+  }
+
+  {
+    hufYY1 = diff_type_1;
+    hufYY2 = diff_type_2;
+  }
+
+  switch (*cdg_scheme >> PAIR_SHIFT) {
+    case HUFF_1D:
+      p0_flag[0] = (diff_type_1 == DIFF_FREQ);
+      p0_flag[1] = (diff_type_2 == DIFF_FREQ);
+      if (out_data_1 != NULL) {
+        if ((err = huff_dec_1D(strm, data_type, hufYY1, out_data_1,
+                               num_val_1_int, p0_flag[0])) != HUFFDEC_OK) {
+          goto bail;
+        }
+      }
+      if (out_data_2 != NULL) {
+        if ((err = huff_dec_1D(strm, data_type, hufYY2, out_data_2,
+                               num_val_2_int, p0_flag[1])) != HUFFDEC_OK) {
+          goto bail;
+        }
+      }
+
+      break; /* HUFF_1D */
+
+    case HUFF_2D:
+
+      switch (*cdg_scheme & PAIR_MASK) {
+        case FREQ_PAIR:
+
+          if (out_data_1 != NULL) {
+            if (diff_type_1 == DIFF_FREQ) {
+              p0_data_1[0] = &out_data_1[0];
+              p0_data_1[1] = NULL;
+
+              num_val_1_int -= 1;
+              out_data_1_int += 1;
+            }
+            df_rest_flag_1 = num_val_1_int % 2;
+            if (df_rest_flag_1) num_val_1_int -= 1;
+          }
+          if (out_data_2 != NULL) {
+            if (diff_type_2 == DIFF_FREQ) {
+              p0_data_2[0] = NULL;
+              p0_data_2[1] = &out_data_2[0];
+
+              num_val_2_int -= 1;
+              out_data_2_int += 1;
+            }
+            df_rest_flag_2 = num_val_2_int % 2;
+            if (df_rest_flag_2) num_val_2_int -= 1;
+          }
+
+          if (out_data_1 != NULL) {
+            if ((err = huff_dec_2D(strm, data_type, hufYY1, FREQ_PAIR, pair_vec,
+                                   num_val_1_int, 2, p0_data_1)) !=
+                HUFFDEC_OK) {
+              goto bail;
+            }
+            if (df_rest_flag_1) {
+              if ((err = huff_dec_1D(strm, data_type, hufYY1,
+                                     out_data_1_int + num_val_1_int, 1, 0)) !=
+                  HUFFDEC_OK) {
+                goto bail;
+              }
+            }
+          }
+          if (out_data_2 != NULL) {
+            if ((err = huff_dec_2D(strm, data_type, hufYY2, FREQ_PAIR,
+                                   pair_vec + 1, num_val_2_int, 2,
+                                   p0_data_2)) != HUFFDEC_OK) {
+              goto bail;
+            }
+            if (df_rest_flag_2) {
+              if ((err = huff_dec_1D(strm, data_type, hufYY2,
+                                     out_data_2_int + num_val_2_int, 1, 0)) !=
+                  HUFFDEC_OK) {
+                goto bail;
+              }
+            }
+          }
+
+          if (out_data_1 != NULL) {
+            for (i = 0; i < num_val_1_int - 1; i += 2) {
+              out_data_1_int[i] = pair_vec[i][0];
+              out_data_1_int[i + 1] = pair_vec[i][1];
+            }
+          }
+          if (out_data_2 != NULL) {
+            for (i = 0; i < num_val_2_int - 1; i += 2) {
+              out_data_2_int[i] = pair_vec[i + 1][0];
+              out_data_2_int[i + 1] = pair_vec[i + 1][1];
+            }
+          }
+          break; /* FREQ_PAIR */
+
+        case TIME_PAIR:
+          if (((diff_type_1 == DIFF_FREQ) || (diff_type_2 == DIFF_FREQ))) {
+            p0_data_1[0] = &out_data_1[0];
+            p0_data_1[1] = &out_data_2[0];
+
+            out_data_1_int += 1;
+            out_data_2_int += 1;
+
+            num_val_1_int -= 1;
+          }
+
+          if ((diff_type_1 == DIFF_TIME) || (diff_type_2 == DIFF_TIME)) {
+            diff_type = DIFF_TIME;
+          } else {
+            diff_type = DIFF_FREQ;
+          }
+          { hufYY = diff_type; }
+
+          if ((err = huff_dec_2D(strm, data_type, hufYY, TIME_PAIR, pair_vec,
+                                 num_val_1_int, 1, p0_data_1)) != HUFFDEC_OK) {
+            goto bail;
+          }
+
+          for (i = 0; i < num_val_1_int; i++) {
+            out_data_1_int[i] = pair_vec[i][0];
+            out_data_2_int[i] = pair_vec[i][1];
+          }
+
+          break; /* TIME_PAIR */
+
+        default:
+          break;
+      }
+
+      break; /* HUFF_2D */
+
+    default:
+      break;
+  }
+bail:
+  return err;
+}
+
+static void diff_freq_decode(const SCHAR* const diff_data,
+                             SCHAR* const out_data, const int num_val) {
+  int i = 0;
+  out_data[0] = diff_data[0];
+
+  for (i = 1; i < num_val; i++) {
+    out_data[i] = out_data[i - 1] + diff_data[i];
+  }
+}
+
+static void diff_time_decode_backwards(const SCHAR* const prev_data,
+                                       const SCHAR* const diff_data,
+                                       SCHAR* const out_data,
+                                       const int mixed_diff_type,
+                                       const int num_val) {
+  int i = 0; /* default start value*/
+
+  if (mixed_diff_type) {
+    out_data[0] = diff_data[0];
+    i = 1; /* new start value */
+  }
+  for (; i < num_val; i++) {
+    out_data[i] = prev_data[i] + diff_data[i];
+  }
+}
+
+static void diff_time_decode_forwards(const SCHAR* const prev_data,
+                                      const SCHAR* const diff_data,
+                                      SCHAR* const out_data,
+                                      const int mixed_diff_type,
+                                      const int num_val) {
+  int i = 0; /* default start value*/
+
+  if (mixed_diff_type) {
+    out_data[0] = diff_data[0];
+    i = 1; /* new start value */
+  }
+  for (; i < num_val; i++) {
+    out_data[i] = prev_data[i] - diff_data[i];
+  }
+}
+
+static ERROR_t attach_lsb(HANDLE_FDK_BITSTREAM strm, SCHAR* in_data_msb,
+                          int offset, int num_lsb, int num_val,
+                          SCHAR* out_data) {
+  int i = 0, lsb = 0;
+  ULONG data = 0;
+
+  for (i = 0; i < num_val; i++) {
+    int msb;
+    msb = in_data_msb[i];
+
+    if (num_lsb > 0) {
+      data = FDKreadBits(strm, num_lsb);
+      lsb = data;
+
+      out_data[i] = ((msb << num_lsb) | lsb) - offset;
+    } else
+      out_data[i] = msb - offset;
+  }
+
+  return HUFFDEC_OK; /* dummy */
+}
+
+ERROR_t EcDataPairDec(DECODER_TYPE DECODER, HANDLE_FDK_BITSTREAM strm,
+                      SCHAR* aaOutData1, SCHAR* aaOutData2, SCHAR* aHistory,
+                      DATA_TYPE data_type, int startBand, int dataBands,
+                      int pair_flag, int coarse_flag,
+                      int allowDiffTimeBack_flag)
+
+{
+  ERROR_t err = HUFFDEC_OK;
+
+  // int allowDiffTimeBack_flag = !independency_flag || (setIdx > 0);
+  int attachLsb_flag = 0;
+  int pcmCoding_flag = 0;
+
+  int mixed_time_pair = 0, numValPcm = 0;
+  int quant_levels = 0, quant_offset = 0;
+  ULONG data = 0;
+
+  SCHAR aaDataPair[2][28] = {{0}};
+  SCHAR aaDataDiff[2][28] = {{0}};
+
+  SCHAR aHistoryMsb[28] = {0};
+
+  SCHAR* pDataVec[2] = {NULL, NULL};
+
+  DIFF_TYPE diff_type[2] = {DIFF_FREQ, DIFF_FREQ};
+  CODING_SCHEME cdg_scheme = HUFF_1D;
+  DIRECTION direction = BACKWARDS;
+
+  switch (data_type) {
+    case t_CLD:
+      if (coarse_flag) {
+        attachLsb_flag = 0;
+        quant_levels = 15;
+        quant_offset = 7;
+      } else {
+        attachLsb_flag = 0;
+        quant_levels = 31;
+        quant_offset = 15;
+      }
+
+      break;
+
+    case t_ICC:
+      if (coarse_flag) {
+        attachLsb_flag = 0;
+        quant_levels = 4;
+        quant_offset = 0;
+      } else {
+        attachLsb_flag = 0;
+        quant_levels = 8;
+        quant_offset = 0;
+      }
+
+      break;
+
+    case t_OLD:
+      if (coarse_flag) {
+        attachLsb_flag = 0;
+        quant_levels = 8;
+        quant_offset = 0;
+      } else {
+        attachLsb_flag = 0;
+        quant_levels = 16;
+        quant_offset = 0;
+      }
+      break;
+
+    case t_NRG:
+      if (coarse_flag) {
+        attachLsb_flag = 0;
+        quant_levels = 32;
+        quant_offset = 0;
+      } else {
+        attachLsb_flag = 0;
+        quant_levels = 64;
+        quant_offset = 0;
+      }
+      break;
+
+    case t_IPD:
+      if (!coarse_flag) {
+        attachLsb_flag = 1;
+        quant_levels = 16;
+        quant_offset = 0;
+      } else {
+        attachLsb_flag = 0;
+        quant_levels = 8;
+        quant_offset = 0;
+      }
+      break;
+
+    default:
+      return HUFFDEC_NOTOK;
+  }
+
+  data = FDKreadBits(strm, 1);
+  pcmCoding_flag = data;
+
+  if (pcmCoding_flag) {
+    if (pair_flag) {
+      pDataVec[0] = aaDataPair[0];
+      pDataVec[1] = aaDataPair[1];
+      numValPcm = 2 * dataBands;
+    } else {
+      pDataVec[0] = aaDataPair[0];
+      pDataVec[1] = NULL;
+      numValPcm = dataBands;
+    }
+
+    err = pcm_decode(strm, pDataVec[0], pDataVec[1], quant_offset, numValPcm,
+                     quant_levels);
+    if (err != HUFFDEC_OK) return HUFFDEC_NOTOK;
+
+  } else { /* Differential/Huffman/LSB Coding */
+
+    if (pair_flag) {
+      pDataVec[0] = aaDataDiff[0];
+      pDataVec[1] = aaDataDiff[1];
+    } else {
+      pDataVec[0] = aaDataDiff[0];
+      pDataVec[1] = NULL;
+    }
+
+    diff_type[0] = DIFF_FREQ;
+    diff_type[1] = DIFF_FREQ;
+
+    direction = BACKWARDS;
+    {
+      if (pair_flag || allowDiffTimeBack_flag) {
+        data = FDKreadBits(strm, 1);
+        diff_type[0] = (DIFF_TYPE)data;
+      }
+
+      if (pair_flag &&
+          ((diff_type[0] == DIFF_FREQ) || allowDiffTimeBack_flag)) {
+        data = FDKreadBits(strm, 1);
+        diff_type[1] = (DIFF_TYPE)data;
+      }
+    }
+    /* Huffman decoding */
+    err = huff_decode(strm, pDataVec[0], pDataVec[1], data_type, diff_type[0],
+                      diff_type[1], dataBands, &cdg_scheme,
+                      (DECODER == SAOC_DECODER));
+    if (err != HUFFDEC_OK) {
+      return HUFFDEC_NOTOK;
+    }
+
+    {
+      /* Differential decoding */
+      if ((diff_type[0] == DIFF_TIME) || (diff_type[1] == DIFF_TIME)) {
+        if (DECODER == SAOC_DECODER) {
+          direction = BACKWARDS;
+        } else {
+          if (pair_flag) {
+            if ((diff_type[0] == DIFF_TIME) && !allowDiffTimeBack_flag) {
+              direction = FORWARDS;
+            } else if (diff_type[1] == DIFF_TIME) {
+              direction = BACKWARDS;
+            } else {
+              data = FDKreadBits(strm, 1);
+              direction = (DIRECTION)data;
+            }
+          } else {
+            direction = BACKWARDS;
+          }
+        }
+      }
+
+      mixed_time_pair = (diff_type[0] != diff_type[1]) &&
+                        ((cdg_scheme & PAIR_MASK) == TIME_PAIR);
+
+      if (direction == BACKWARDS) {
+        if (diff_type[0] == DIFF_FREQ) {
+          diff_freq_decode(aaDataDiff[0], aaDataPair[0], dataBands);
+        } else {
+          int i;
+          for (i = 0; i < dataBands; i++) {
+            aHistoryMsb[i] = aHistory[i + startBand] + quant_offset;
+            if (attachLsb_flag) {
+              aHistoryMsb[i] >>= 1;
+            }
+          }
+          diff_time_decode_backwards(aHistoryMsb, aaDataDiff[0], aaDataPair[0],
+                                     mixed_time_pair, dataBands);
+        }
+        if (diff_type[1] == DIFF_FREQ) {
+          diff_freq_decode(aaDataDiff[1], aaDataPair[1], dataBands);
+        } else {
+          diff_time_decode_backwards(aaDataPair[0], aaDataDiff[1],
+                                     aaDataPair[1], mixed_time_pair, dataBands);
+        }
+      } else {
+        /* diff_type[1] MUST BE DIFF_FREQ */
+        diff_freq_decode(aaDataDiff[1], aaDataPair[1], dataBands);
+
+        if (diff_type[0] == DIFF_FREQ) {
+          diff_freq_decode(aaDataDiff[0], aaDataPair[0], dataBands);
+        } else {
+          diff_time_decode_forwards(aaDataPair[1], aaDataDiff[0], aaDataPair[0],
+                                    mixed_time_pair, dataBands);
+        }
+      }
+    }
+
+    /* LSB decoding */
+    err = attach_lsb(strm, aaDataPair[0], quant_offset, attachLsb_flag ? 1 : 0,
+                     dataBands, aaDataPair[0]);
+    if (err != HUFFDEC_OK) goto bail;
+
+    if (pair_flag) {
+      err = attach_lsb(strm, aaDataPair[1], quant_offset,
+                       attachLsb_flag ? 1 : 0, dataBands, aaDataPair[1]);
+      if (err != HUFFDEC_OK) goto bail;
+    }
+  } /* End: Differential/Huffman/LSB Coding */
+
+  /* Copy data to output arrays */
+  FDKmemcpy(aaOutData1 + startBand, aaDataPair[0], sizeof(SCHAR) * dataBands);
+  if (pair_flag) {
+    FDKmemcpy(aaOutData2 + startBand, aaDataPair[1], sizeof(SCHAR) * dataBands);
+  }
+
+bail:
+  return err;
+}
+
+ERROR_t huff_dec_reshape(HANDLE_FDK_BITSTREAM strm, int* out_data,
+                         int num_val) {
+  ERROR_t err = HUFFDEC_OK;
+  int val_rcvd = 0, dummy = 0, i = 0, val = 0, len = 0;
+  SCHAR rl_data[2] = {0};
+
+  while (val_rcvd < num_val) {
+    err = huff_read_2D(strm,
+                       (HANDLE_HUFF_NODE)&FDK_huffReshapeNodes.nodeTab[0][0],
+                       rl_data, &dummy);
+    if (err != HUFFDEC_OK) goto bail;
+    val = rl_data[0];
+    len = rl_data[1] + 1;
+    if (val_rcvd + len > num_val) {
+      err = HUFFDEC_NOTOK;
+      goto bail;
+    }
+    for (i = val_rcvd; i < val_rcvd + len; i++) {
+      out_data[i] = val;
+    }
+    val_rcvd += len;
+  }
+bail:
+  return err;
+}