libSACenc/src/sacenc_nlc_enc.cpp

/* -----------------------------------------------------------------------------
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
----------------------------------------------------------------------------- */

/*********************** MPEG surround encoder library *************************

   Author(s):   Karsten Linzmeier

   Description: Noiseless Coding
                Huffman encoder

*******************************************************************************/

/* Includes ******************************************************************/
#include "sacenc_nlc_enc.h"

#include "genericStds.h"
#include "fixpoint_math.h"

#include "sacenc_const.h"
#include "sacenc_huff_tab.h"
#include "sacenc_paramextract.h"

/* Defines *******************************************************************/
#define PAIR_SHIFT 4
#define PAIR_MASK 0xf

#define PBC_MIN_BANDS 5

typedef enum {
  BACKWARDS = 0x0,
  FORWARDS = 0x1

} DIRECTION;

typedef enum {
  DIFF_FREQ = 0x0,
  DIFF_TIME = 0x1

} DIFF_TYPE;

typedef enum {
  HUFF_1D = 0x0,
  HUFF_2D = 0x1

} CODING_SCHEME;

typedef enum {
  FREQ_PAIR = 0x0,
  TIME_PAIR = 0x1

} PAIRING;

/* Data Types ****************************************************************/

/* Constants *****************************************************************/
static const UCHAR lavHuffVal[4] = {0, 2, 6, 7};
static const UCHAR lavHuffLen[4] = {1, 2, 3, 3};

static const UCHAR lav_step_CLD[] = {0, 0, 0, 0, 1, 1, 2, 2, 3, 3};
static const UCHAR lav_step_ICC[] = {0, 0, 1, 1, 2, 2, 3, 3};

/* Function / Class Declarations *********************************************/

/* Function / Class Definition ***********************************************/
static void split_lsb(const SHORT *const in_data, SHORT offset,
                      const INT num_val, SHORT *const out_data_lsb,
                      SHORT *const out_data_msb) {
  int i;

  for (i = 0; i < num_val; i++) {
    SHORT val = in_data[i] + offset;
    if (out_data_lsb != NULL) out_data_lsb[i] = val & 0x0001;
    if (out_data_msb != NULL) out_data_msb[i] = val >> 1;
  }
}

static void apply_lsb_coding(HANDLE_FDK_BITSTREAM strm,
                             const SHORT *const in_data_lsb, const UINT num_lsb,
                             const INT num_val) {
  int i;

  for (i = 0; i < num_val; i++) {
    FDKwriteBits(strm, in_data_lsb[i], num_lsb);
  }
}

static void calc_diff_freq(const SHORT *const in_data, SHORT *const out_data,
                           const INT num_val) {
  int i;
  out_data[0] = in_data[0];

  for (i = 1; i < num_val; i++) {
    out_data[i] = in_data[i] - in_data[i - 1];
  }
}

static void calc_diff_time(const SHORT *const in_data,
                           const SHORT *const prev_data, SHORT *const out_data,
                           const INT num_val) {
  int i;
  out_data[0] = in_data[0];
  out_data[1] = prev_data[0];

  for (i = 0; i < num_val; i++) {
    out_data[i + 2] = in_data[i] - prev_data[i];
  }
}

static INT sym_check(SHORT data[2], const INT lav, SHORT *const pSym_bits) {
  UCHAR symBits = 0;
  int sum_val = data[0] + data[1];
  int diff_val = data[0] - data[1];
  int num_sbits = 0;

  if (sum_val != 0) {
    int sum_neg = (sum_val < 0) ? 1 : 0;
    if (sum_neg) {
      sum_val = -sum_val;
      diff_val = -diff_val;
    }
    symBits = (symBits << 1) | sum_neg;
    num_sbits++;
  }

  if (diff_val != 0) {
    int diff_neg = (diff_val < 0) ? 1 : 0;
    if (diff_neg) {
      diff_val = -diff_val;
    }
    symBits = (symBits << 1) | diff_neg;
    num_sbits++;
  }

  if (pSym_bits != NULL) {
    *pSym_bits = symBits;
  }

  if (sum_val % 2) {
    data[0] = lav - sum_val / 2;
    data[1] = lav - diff_val / 2;
  } else {
    data[0] = sum_val / 2;
    data[1] = diff_val / 2;
  }

  return num_sbits;
}

static INT ilog2(UINT i) {
  int l = 0;

  if (i) i--;
  while (i > 0) {
    i >>= 1;
    l++;
  }

  return l;
}

static SHORT calc_pcm_bits(const SHORT num_val, const SHORT num_levels) {
  SHORT num_complete_chunks = 0, rest_chunk_size = 0;
  SHORT max_grp_len = 0, bits_pcm = 0;
  int chunk_levels, i;

  switch (num_levels) {
    case 3:
      max_grp_len = 5;
      break;
    case 6:
      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;
    default:
      max_grp_len = 1;
  }

  num_complete_chunks = num_val / max_grp_len;
  rest_chunk_size = num_val % max_grp_len;

  chunk_levels = 1;
  for (i = 1; i <= max_grp_len; i++) {
    chunk_levels *= num_levels;
  }

  bits_pcm = (SHORT)(ilog2(chunk_levels) * num_complete_chunks);
  bits_pcm += (SHORT)(ilog2(num_levels) * rest_chunk_size);

  return bits_pcm;
}

static void apply_pcm_coding(HANDLE_FDK_BITSTREAM strm,
                             const SHORT *const in_data_1,
                             const SHORT *const in_data_2, const SHORT offset,
                             const SHORT num_val, const SHORT num_levels) {
  SHORT i = 0, j = 0, idx = 0;
  SHORT max_grp_len = 0, grp_len = 0, next_val = 0;
  int grp_val = 0, chunk_levels = 0;

  SHORT pcm_chunk_size[7] = {0};

  switch (num_levels) {
    case 3:
      max_grp_len = 5;
      break;
    case 5:
      max_grp_len = 3;
      break;
    case 6:
      max_grp_len = 5;
      break;
    case 7:
      max_grp_len = 6;
      break;
    case 9:
      max_grp_len = 5;
      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;
    default:
      max_grp_len = 1;
  }

  chunk_levels = 1;
  for (i = 1; i <= max_grp_len; i++) {
    chunk_levels *= num_levels;
    pcm_chunk_size[i] = ilog2(chunk_levels);
  }

  for (i = 0; i < num_val; i += max_grp_len) {
    grp_len = FDKmin(max_grp_len, num_val - i);
    grp_val = 0;
    for (j = 0; j < grp_len; j++) {
      idx = i + j;
      if (in_data_2 == NULL) {
        next_val = in_data_1[idx];
      } else if (in_data_1 == NULL) {
        next_val = in_data_2[idx];
      } else {
        next_val = ((idx % 2) ? in_data_2[idx / 2] : in_data_1[idx / 2]);
      }
      next_val += offset;
      grp_val = grp_val * num_levels + next_val;
    }

    FDKwriteBits(strm, grp_val, pcm_chunk_size[grp_len]);
  }
}

static UINT huff_enc_1D(HANDLE_FDK_BITSTREAM strm, const DATA_TYPE data_type,
                        const INT dim1, SHORT *const in_data,
                        const SHORT num_val, const SHORT p0_flag) {
  int i, offset = 0;
  UINT huffBits = 0;

  HUFF_ENTRY part0 = {0};
  const HUFF_ENTRY *pHuffTab = NULL;

  switch (data_type) {
    case t_CLD:
      pHuffTab = fdk_sacenc_huffCLDTab.h1D[dim1];
      break;
    case t_ICC:
      pHuffTab = fdk_sacenc_huffICCTab.h1D[dim1];
      break;
  }

  if (p0_flag) {
    switch (data_type) {
      case t_CLD:
        part0 = fdk_sacenc_huffPart0Tab.cld[in_data[0]];
        break;
      case t_ICC:
        part0 = fdk_sacenc_huffPart0Tab.icc[in_data[0]];
        break;
    }
    huffBits += FDKwriteBits(strm, HUFF_VALUE(part0), HUFF_LENGTH(part0));
    offset = 1;
  }

  for (i = offset; i < num_val; i++) {
    int id_sign = 0;
    int id = in_data[i];

    if (id != 0) {
      id_sign = 0;
      if (id < 0) {
        id = -id;
        id_sign = 1;
      }
    }

    huffBits +=
        FDKwriteBits(strm, HUFF_VALUE(pHuffTab[id]), HUFF_LENGTH(pHuffTab[id]));

    if (id != 0) {
      huffBits += FDKwriteBits(strm, id_sign, 1);
    }
  } /* for i */

  return huffBits;
}

static void getHuffEntry(const INT lav, const DATA_TYPE data_type, const INT i,
                         const SHORT tab_idx_2D[2], const SHORT in_data[][2],
                         HUFF_ENTRY *const pEntry, HUFF_ENTRY *const pEscape) {
  const HUFF_CLD_TAB_2D *pCLD2dTab =
      &fdk_sacenc_huffCLDTab.h2D[tab_idx_2D[0]][tab_idx_2D[1]];
  const HUFF_ICC_TAB_2D *pICC2dTab =
      &fdk_sacenc_huffICCTab.h2D[tab_idx_2D[0]][tab_idx_2D[1]];

  switch (lav) {
    case 1: {
      const LAV1_2D *pLav1 = NULL;
      switch (data_type) {
        case t_CLD:
          pLav1 = NULL;
          break;
        case t_ICC:
          pLav1 = &pICC2dTab->lav1;
          break;
      }
      if (pLav1 != NULL) {
        *pEntry = pLav1->entry[in_data[i][0]][in_data[i][1]];
        *pEscape = pLav1->escape;
      }
    } break;
    case 3: {
      const LAV3_2D *pLav3 = NULL;
      switch (data_type) {
        case t_CLD:
          pLav3 = &pCLD2dTab->lav3;
          break;
        case t_ICC:
          pLav3 = &pICC2dTab->lav3;
          break;
      }
      if (pLav3 != NULL) {
        *pEntry = pLav3->entry[in_data[i][0]][in_data[i][1]];
        *pEscape = pLav3->escape;
      }
    } break;
    case 5: {
      const LAV5_2D *pLav5 = NULL;
      switch (data_type) {
        case t_CLD:
          pLav5 = &pCLD2dTab->lav5;
          break;
        case t_ICC:
          pLav5 = &pICC2dTab->lav5;
          break;
      }
      if (pLav5 != NULL) {
        *pEntry = pLav5->entry[in_data[i][0]][in_data[i][1]];
        *pEscape = pLav5->escape;
      }
    } break;
    case 7: {
      const LAV7_2D *pLav7 = NULL;
      switch (data_type) {
        case t_CLD:
          pLav7 = &pCLD2dTab->lav7;
          break;
        case t_ICC:
          pLav7 = &pICC2dTab->lav7;
          break;
      }
      if (pLav7 != NULL) {
        *pEntry = pLav7->entry[in_data[i][0]][in_data[i][1]];
        *pEscape = pLav7->escape;
      }
    } break;
    case 9: {
      const LAV9_2D *pLav9 = NULL;
      switch (data_type) {
        case t_CLD:
          pLav9 = &pCLD2dTab->lav9;
          break;
        case t_ICC:
          pLav9 = NULL;
          break;
      }
      if (pLav9 != NULL) {
        *pEntry = pLav9->entry[in_data[i][0]][in_data[i][1]];
        *pEscape = pLav9->escape;
      }
    } break;
  }
}

static UINT huff_enc_2D(HANDLE_FDK_BITSTREAM strm, const DATA_TYPE data_type,
                        SHORT tab_idx_2D[2], SHORT lav_idx, SHORT in_data[][2],
                        SHORT num_val, SHORT stride, SHORT *p0_data[2]) {
  SHORT i = 0, lav = 0, num_sbits = 0, sym_bits = 0, escIdx = 0;
  SHORT esc_data[2][MAXBANDS] = {{0}};

  UINT huffBits = 0;

  const HUFF_ENTRY *pHuffEntry = NULL;

  switch (data_type) {
    case t_CLD:
      lav = 2 * lav_idx + 3; /* LAV */
      pHuffEntry = fdk_sacenc_huffPart0Tab.cld;
      break;
    case t_ICC:
      lav = 2 * lav_idx + 1; /* LAV */
      pHuffEntry = fdk_sacenc_huffPart0Tab.icc;
      break;
  }

  /* Partition 0 */
  if (p0_data[0] != NULL) {
    HUFF_ENTRY entry = pHuffEntry[*p0_data[0]];
    huffBits += FDKwriteBits(strm, HUFF_VALUE(entry), HUFF_LENGTH(entry));
  }
  if (p0_data[1] != NULL) {
    HUFF_ENTRY entry = pHuffEntry[*p0_data[1]];
    huffBits += FDKwriteBits(strm, HUFF_VALUE(entry), HUFF_LENGTH(entry));
  }

  for (i = 0; i < num_val; i += stride) {
    HUFF_ENTRY entry = {0};
    HUFF_ENTRY escape = {0};

    esc_data[0][escIdx] = in_data[i][0] + lav;
    esc_data[1][escIdx] = in_data[i][1] + lav;

    num_sbits = sym_check(in_data[i], lav, &sym_bits);

    getHuffEntry(lav, data_type, i, tab_idx_2D, in_data, &entry, &escape);

    huffBits += FDKwriteBits(strm, HUFF_VALUE(entry), HUFF_LENGTH(entry));

    if ((HUFF_VALUE(entry) == HUFF_VALUE(escape)) &&
        (HUFF_LENGTH(entry) == HUFF_LENGTH(escape))) {
      escIdx++;
    } else {
      huffBits += FDKwriteBits(strm, sym_bits, num_sbits);
    }
  } /* for i */

  if (escIdx > 0) {
    huffBits += calc_pcm_bits(2 * escIdx, (2 * lav + 1));
    if (strm != NULL) {
      apply_pcm_coding(strm, esc_data[0], esc_data[1], 0 /*offset*/, 2 * escIdx,
                       (2 * lav + 1));
    }
  }

  return huffBits;
}

static SCHAR get_next_lav_step(const INT lav, const DATA_TYPE data_type) {
  SCHAR lav_step = 0;

  switch (data_type) {
    case t_CLD:
      lav_step = (lav > 9) ? -1 : lav_step_CLD[lav];
      break;
    case t_ICC:
      lav_step = (lav > 7) ? -1 : lav_step_ICC[lav];
      break;
  }

  return lav_step;
}

static INT diff_type_offset(const DIFF_TYPE diff_type) {
  int offset = 0;
  switch (diff_type) {
    case DIFF_FREQ:
      offset = 0;
      break;
    case DIFF_TIME:
      offset = 2;
      break;
  }
  return offset;
}

static SHORT calc_huff_bits(SHORT *in_data_1, SHORT *in_data_2,
                            const DATA_TYPE data_type,
                            const DIFF_TYPE diff_type_1,
                            const DIFF_TYPE diff_type_2, const SHORT num_val,
                            SHORT *const lav_idx, SHORT *const cdg_scheme) {
  SHORT tab_idx_2D[2][2] = {{0}};
  SHORT tab_idx_1D[2] = {0};
  SHORT df_rest_flag[2] = {0};
  SHORT p0_flag[2] = {0};

  SHORT pair_vec[MAXBANDS][2] = {{0}};

  SHORT *p0_data_1[2] = {NULL};
  SHORT *p0_data_2[2] = {NULL};

  SHORT i = 0;
  SHORT lav_fp[2] = {0};

  SHORT bit_count_1D = 0;
  SHORT bit_count_2D_freq = 0;
  SHORT bit_count_min = 0;

  SHORT num_val_1_short = 0;
  SHORT num_val_2_short = 0;

  SHORT *in_data_1_short = NULL;
  SHORT *in_data_2_short = NULL;

  /* 1D Huffman coding */
  bit_count_1D = 1; /* HUFF_1D */

  num_val_1_short = num_val;
  num_val_2_short = num_val;

  if (in_data_1 != NULL) {
    in_data_1_short = in_data_1 + diff_type_offset(diff_type_1);
  }
  if (in_data_2 != NULL) {
    in_data_2_short = in_data_2 + diff_type_offset(diff_type_2);
  }

  p0_flag[0] = (diff_type_1 == DIFF_FREQ);
  p0_flag[1] = (diff_type_2 == DIFF_FREQ);

  tab_idx_1D[0] = (diff_type_1 == DIFF_FREQ) ? 0 : 1;
  tab_idx_1D[1] = (diff_type_2 == DIFF_FREQ) ? 0 : 1;

  if (in_data_1 != NULL) {
    bit_count_1D += huff_enc_1D(NULL, data_type, tab_idx_1D[0], in_data_1_short,
                                num_val_1_short, p0_flag[0]);
  }
  if (in_data_2 != NULL) {
    bit_count_1D += huff_enc_1D(NULL, data_type, tab_idx_1D[1], in_data_2_short,
                                num_val_2_short, p0_flag[1]);
  }

  bit_count_min = bit_count_1D;
  *cdg_scheme = HUFF_1D << PAIR_SHIFT;
  lav_idx[0] = lav_idx[1] = -1;

  /* Huffman 2D frequency pairs */
  bit_count_2D_freq = 1; /* HUFF_2D */

  num_val_1_short = num_val;
  num_val_2_short = num_val;

  if (in_data_1 != NULL) {
    in_data_1_short = in_data_1 + diff_type_offset(diff_type_1);
  }
  if (in_data_2 != NULL) {
    in_data_2_short = in_data_2 + diff_type_offset(diff_type_2);
  }

  lav_fp[0] = lav_fp[1] = 0;

  p0_data_1[0] = NULL;
  p0_data_1[1] = NULL;
  p0_data_2[0] = NULL;
  p0_data_2[1] = NULL;

  if (in_data_1 != NULL) {
    if (diff_type_1 == DIFF_FREQ) {
      p0_data_1[0] = &in_data_1[0];
      p0_data_1[1] = NULL;

      num_val_1_short -= 1;
      in_data_1_short += 1;
    }

    df_rest_flag[0] = num_val_1_short % 2;

    if (df_rest_flag[0]) num_val_1_short -= 1;

    for (i = 0; i < num_val_1_short - 1; i += 2) {
      pair_vec[i][0] = in_data_1_short[i];
      pair_vec[i][1] = in_data_1_short[i + 1];

      lav_fp[0] = FDKmax(lav_fp[0], fAbs(pair_vec[i][0]));
      lav_fp[0] = FDKmax(lav_fp[0], fAbs(pair_vec[i][1]));
    }

    tab_idx_2D[0][0] = (diff_type_1 == DIFF_TIME) ? 1 : 0;
    tab_idx_2D[0][1] = 0;

    tab_idx_1D[0] = (diff_type_1 == DIFF_FREQ) ? 0 : 1;

    lav_fp[0] = get_next_lav_step(lav_fp[0], data_type);

    if (lav_fp[0] != -1) bit_count_2D_freq += lavHuffLen[lav_fp[0]];
  }

  if (in_data_2 != NULL) {
    if (diff_type_2 == DIFF_FREQ) {
      p0_data_2[0] = NULL;
      p0_data_2[1] = &in_data_2[0];

      num_val_2_short -= 1;
      in_data_2_short += 1;
    }

    df_rest_flag[1] = num_val_2_short % 2;

    if (df_rest_flag[1]) num_val_2_short -= 1;

    for (i = 0; i < num_val_2_short - 1; i += 2) {
      pair_vec[i + 1][0] = in_data_2_short[i];
      pair_vec[i + 1][1] = in_data_2_short[i + 1];

      lav_fp[1] = FDKmax(lav_fp[1], fAbs(pair_vec[i + 1][0]));
      lav_fp[1] = FDKmax(lav_fp[1], fAbs(pair_vec[i + 1][1]));
    }

    tab_idx_2D[1][0] = (diff_type_2 == DIFF_TIME) ? 1 : 0;
    tab_idx_2D[1][1] = 0;

    tab_idx_1D[1] = (diff_type_2 == DIFF_FREQ) ? 0 : 1;

    lav_fp[1] = get_next_lav_step(lav_fp[1], data_type);

    if (lav_fp[1] != -1) bit_count_2D_freq += lavHuffLen[lav_fp[1]];
  }

  if ((lav_fp[0] != -1) && (lav_fp[1] != -1)) {
    if (in_data_1 != NULL) {
      bit_count_2D_freq +=
          huff_enc_2D(NULL, data_type, tab_idx_2D[0], lav_fp[0], pair_vec,
                      num_val_1_short, 2, p0_data_1);
    }
    if (in_data_2 != NULL) {
      bit_count_2D_freq +=
          huff_enc_2D(NULL, data_type, tab_idx_2D[1], lav_fp[1], pair_vec + 1,
                      num_val_2_short, 2, p0_data_2);
    }
    if (in_data_1 != NULL) {
      if (df_rest_flag[0])
        bit_count_2D_freq +=
            huff_enc_1D(NULL, data_type, tab_idx_1D[0],
                        in_data_1_short + num_val_1_short, 1, 0);
    }
    if (in_data_2 != NULL) {
      if (df_rest_flag[1])
        bit_count_2D_freq +=
            huff_enc_1D(NULL, data_type, tab_idx_1D[1],
                        in_data_2_short + num_val_2_short, 1, 0);
    }

    if (bit_count_2D_freq < bit_count_min) {
      bit_count_min = bit_count_2D_freq;
      *cdg_scheme = HUFF_2D << PAIR_SHIFT | FREQ_PAIR;
      lav_idx[0] = lav_fp[0];
      lav_idx[1] = lav_fp[1];
    }
  }

  return bit_count_min;
}

static void apply_huff_coding(HANDLE_FDK_BITSTREAM strm, SHORT *const in_data_1,
                              SHORT *const in_data_2, const DATA_TYPE data_type,
                              const DIFF_TYPE diff_type_1,
                              const DIFF_TYPE diff_type_2, const SHORT num_val,
                              const SHORT *const lav_idx,
                              const SHORT cdg_scheme) {
  SHORT tab_idx_2D[2][2] = {{0}};
  SHORT tab_idx_1D[2] = {0};
  SHORT df_rest_flag[2] = {0};
  SHORT p0_flag[2] = {0};

  SHORT pair_vec[MAXBANDS][2] = {{0}};

  SHORT *p0_data_1[2] = {NULL};
  SHORT *p0_data_2[2] = {NULL};

  SHORT i = 0;

  SHORT num_val_1_short = num_val;
  SHORT num_val_2_short = num_val;

  SHORT *in_data_1_short = NULL;
  SHORT *in_data_2_short = NULL;

  /* Offset */
  if (in_data_1 != NULL) {
    in_data_1_short = in_data_1 + diff_type_offset(diff_type_1);
  }
  if (in_data_2 != NULL) {
    in_data_2_short = in_data_2 + diff_type_offset(diff_type_2);
  }

  /* Signalize coding scheme */
  FDKwriteBits(strm, cdg_scheme >> PAIR_SHIFT, 1);

  switch (cdg_scheme >> PAIR_SHIFT) {
    case HUFF_1D:

      p0_flag[0] = (diff_type_1 == DIFF_FREQ);
      p0_flag[1] = (diff_type_2 == DIFF_FREQ);

      tab_idx_1D[0] = (diff_type_1 == DIFF_FREQ) ? 0 : 1;
      tab_idx_1D[1] = (diff_type_2 == DIFF_FREQ) ? 0 : 1;

      if (in_data_1 != NULL) {
        huff_enc_1D(strm, data_type, tab_idx_1D[0], in_data_1_short,
                    num_val_1_short, p0_flag[0]);
      }
      if (in_data_2 != NULL) {
        huff_enc_1D(strm, data_type, tab_idx_1D[1], in_data_2_short,
                    num_val_2_short, p0_flag[1]);
      }
      break; /* HUFF_1D */

    case HUFF_2D:

      switch (cdg_scheme & PAIR_MASK) {
        case FREQ_PAIR:

          if (in_data_1 != NULL) {
            if (diff_type_1 == DIFF_FREQ) {
              p0_data_1[0] = &in_data_1[0];
              p0_data_1[1] = NULL;

              num_val_1_short -= 1;
              in_data_1_short += 1;
            }

            df_rest_flag[0] = num_val_1_short % 2;

            if (df_rest_flag[0]) num_val_1_short -= 1;

            for (i = 0; i < num_val_1_short - 1; i += 2) {
              pair_vec[i][0] = in_data_1_short[i];
              pair_vec[i][1] = in_data_1_short[i + 1];
            }

            tab_idx_2D[0][0] = (diff_type_1 == DIFF_TIME) ? 1 : 0;
            tab_idx_2D[0][1] = 0;

            tab_idx_1D[0] = (diff_type_1 == DIFF_FREQ) ? 0 : 1;
          } /* if( in_data_1 != NULL ) */

          if (in_data_2 != NULL) {
            if (diff_type_2 == DIFF_FREQ) {
              p0_data_2[0] = NULL;
              p0_data_2[1] = &in_data_2[0];

              num_val_2_short -= 1;
              in_data_2_short += 1;
            }

            df_rest_flag[1] = num_val_2_short % 2;

            if (df_rest_flag[1]) num_val_2_short -= 1;

            for (i = 0; i < num_val_2_short - 1; i += 2) {
              pair_vec[i + 1][0] = in_data_2_short[i];
              pair_vec[i + 1][1] = in_data_2_short[i + 1];
            }

            tab_idx_2D[1][0] = (diff_type_2 == DIFF_TIME) ? 1 : 0;
            tab_idx_2D[1][1] = 0;

            tab_idx_1D[1] = (diff_type_2 == DIFF_FREQ) ? 0 : 1;
          } /* if( in_data_2 != NULL ) */

          if (in_data_1 != NULL) {
            FDKwriteBits(strm, lavHuffVal[lav_idx[0]], lavHuffLen[lav_idx[0]]);
            huff_enc_2D(strm, data_type, tab_idx_2D[0], lav_idx[0], pair_vec,
                        num_val_1_short, 2, p0_data_1);
            if (df_rest_flag[0]) {
              huff_enc_1D(strm, data_type, tab_idx_1D[0],
                          in_data_1_short + num_val_1_short, 1, 0);
            }
          }
          if (in_data_2 != NULL) {
            FDKwriteBits(strm, lavHuffVal[lav_idx[1]], lavHuffLen[lav_idx[1]]);
            huff_enc_2D(strm, data_type, tab_idx_2D[1], lav_idx[1],
                        pair_vec + 1, num_val_2_short, 2, p0_data_2);
            if (df_rest_flag[1]) {
              huff_enc_1D(strm, data_type, tab_idx_1D[1],
                          in_data_2_short + num_val_2_short, 1, 0);
            }
          }
          break; /* FREQ_PAIR */

        case TIME_PAIR:

          if ((diff_type_1 == DIFF_FREQ) || (diff_type_2 == DIFF_FREQ)) {
            p0_data_1[0] = &in_data_1[0];
            p0_data_1[1] = &in_data_2[0];

            in_data_1_short += 1;
            in_data_2_short += 1;

            num_val_1_short -= 1;
          }

          for (i = 0; i < num_val_1_short; i++) {
            pair_vec[i][0] = in_data_1_short[i];
            pair_vec[i][1] = in_data_2_short[i];
          }

          tab_idx_2D[0][0] =
              ((diff_type_1 == DIFF_TIME) || (diff_type_2 == DIFF_TIME)) ? 1
                                                                         : 0;
          tab_idx_2D[0][1] = 1;

          FDKwriteBits(strm, lavHuffVal[lav_idx[0]], lavHuffLen[lav_idx[0]]);

          huff_enc_2D(strm, data_type, tab_idx_2D[0], lav_idx[0], pair_vec,
                      num_val_1_short, 1, p0_data_1);

          break; /* TIME_PAIR */
      }          /* switch( cdg_scheme & PAIR_MASK ) */

      break; /* HUFF_2D */

    default:
      break;
  } /* switch( cdg_scheme >> PAIR_SHIFT ) */
}

INT fdk_sacenc_ecDataPairEnc(HANDLE_FDK_BITSTREAM strm,
                             SHORT aaInData[][MAXBANDS],
                             SHORT aHistory[MAXBANDS],
                             const DATA_TYPE data_type, const INT setIdx,
                             const INT startBand, const INT dataBands,
                             const INT coarse_flag,
                             const INT independency_flag) {
  SHORT reset = 0, pb = 0;
  SHORT quant_levels = 0, quant_offset = 0, num_pcm_val = 0;

  SHORT splitLsb_flag = 0;
  SHORT pcmCoding_flag = 0;

  SHORT allowDiffTimeBack_flag = !independency_flag || (setIdx > 0);

  SHORT num_lsb_bits = -1;
  SHORT num_pcm_bits = -1;

  SHORT quant_data_lsb[2][MAXBANDS];
  SHORT quant_data_msb[2][MAXBANDS];

  SHORT quant_data_hist_lsb[MAXBANDS];
  SHORT quant_data_hist_msb[MAXBANDS];

  SHORT data_diff_freq[2][MAXBANDS];
  SHORT data_diff_time[2][MAXBANDS + 2];

  SHORT *p_quant_data_msb[2];
  SHORT *p_quant_data_hist_msb = NULL;

  SHORT min_bits_all = 0;
  SHORT min_found = 0;

  SHORT min_bits_df_df = -1;
  SHORT min_bits_df_dt = -1;
  SHORT min_bits_dtbw_df = -1;
  SHORT min_bits_dt_dt = -1;

  SHORT lav_df_df[2] = {-1, -1};
  SHORT lav_df_dt[2] = {-1, -1};
  SHORT lav_dtbw_df[2] = {-1, -1};
  SHORT lav_dt_dt[2] = {-1, -1};

  SHORT coding_scheme_df_df = 0;
  SHORT coding_scheme_df_dt = 0;
  SHORT coding_scheme_dtbw_df = 0;
  SHORT coding_scheme_dt_dt = 0;

  switch (data_type) {
    case t_CLD:
      if (coarse_flag) {
        splitLsb_flag = 0;
        quant_levels = 15;
        quant_offset = 7;
      } else {
        splitLsb_flag = 0;
        quant_levels = 31;
        quant_offset = 15;
      }
      break;
    case t_ICC:
      if (coarse_flag) {
        splitLsb_flag = 0;
        quant_levels = 4;
        quant_offset = 0;
      } else {
        splitLsb_flag = 0;
        quant_levels = 8;
        quant_offset = 0;
      }
      break;
  } /* switch( data_type ) */

  /* Split off LSB */
  if (splitLsb_flag) {
    split_lsb(aaInData[setIdx] + startBand, quant_offset, dataBands,
              quant_data_lsb[0], quant_data_msb[0]);

    split_lsb(aaInData[setIdx + 1] + startBand, quant_offset, dataBands,
              quant_data_lsb[1], quant_data_msb[1]);

    p_quant_data_msb[0] = quant_data_msb[0];
    p_quant_data_msb[1] = quant_data_msb[1];

    num_lsb_bits = 2 * dataBands;
  } else if (quant_offset != 0) {
    for (pb = 0; pb < dataBands; pb++) {
      quant_data_msb[0][pb] = aaInData[setIdx][startBand + pb] + quant_offset;
      quant_data_msb[1][pb] =
          aaInData[setIdx + 1][startBand + pb] + quant_offset;
    }

    p_quant_data_msb[0] = quant_data_msb[0];
    p_quant_data_msb[1] = quant_data_msb[1];

    num_lsb_bits = 0;
  } else {
    p_quant_data_msb[0] = aaInData[setIdx] + startBand;
    p_quant_data_msb[1] = aaInData[setIdx + 1] + startBand;

    num_lsb_bits = 0;
  }

  if (allowDiffTimeBack_flag) {
    if (splitLsb_flag) {
      split_lsb(aHistory + startBand, quant_offset, dataBands,
                quant_data_hist_lsb, quant_data_hist_msb);

      p_quant_data_hist_msb = quant_data_hist_msb;
    } else if (quant_offset != 0) {
      for (pb = 0; pb < dataBands; pb++) {
        quant_data_hist_msb[pb] = aHistory[startBand + pb] + quant_offset;
      }
      p_quant_data_hist_msb = quant_data_hist_msb;
    } else {
      p_quant_data_hist_msb = aHistory + startBand;
    }
  }

  /* Calculate frequency differences */
  calc_diff_freq(p_quant_data_msb[0], data_diff_freq[0], dataBands);

  calc_diff_freq(p_quant_data_msb[1], data_diff_freq[1], dataBands);

  /* Calculate time differences */
  if (allowDiffTimeBack_flag) {
    calc_diff_time(p_quant_data_msb[0], p_quant_data_hist_msb,
                   data_diff_time[0], dataBands);
  }

  calc_diff_time(p_quant_data_msb[1], p_quant_data_msb[0], data_diff_time[1],
                 dataBands);

  /* Calculate coding scheme with minumum bit consumption */

  /**********************************************************/
  num_pcm_bits = calc_pcm_bits(2 * dataBands, quant_levels);
  num_pcm_val = 2 * dataBands;

  /**********************************************************/

  min_bits_all = num_pcm_bits;

  /**********************************************************/
  /**********************************************************/

  /**********************************************************/
  min_bits_df_df =
      calc_huff_bits(data_diff_freq[0], data_diff_freq[1], data_type, DIFF_FREQ,
                     DIFF_FREQ, dataBands, lav_df_df, &coding_scheme_df_df);

  min_bits_df_df += 2;

  min_bits_df_df += num_lsb_bits;

  if (min_bits_df_df < min_bits_all) {
    min_bits_all = min_bits_df_df;
  }
  /**********************************************************/

  /**********************************************************/
  min_bits_df_dt =
      calc_huff_bits(data_diff_freq[0], data_diff_time[1], data_type, DIFF_FREQ,
                     DIFF_TIME, dataBands, lav_df_dt, &coding_scheme_df_dt);

  min_bits_df_dt += 2;

  min_bits_df_dt += num_lsb_bits;

  if (min_bits_df_dt < min_bits_all) {
    min_bits_all = min_bits_df_dt;
  }
  /**********************************************************/

  /**********************************************************/
  /**********************************************************/

  if (allowDiffTimeBack_flag) {
    /**********************************************************/
    min_bits_dtbw_df = calc_huff_bits(
        data_diff_time[0], data_diff_freq[1], data_type, DIFF_TIME, DIFF_FREQ,
        dataBands, lav_dtbw_df, &coding_scheme_dtbw_df);

    min_bits_dtbw_df += 2;

    min_bits_dtbw_df += num_lsb_bits;

    if (min_bits_dtbw_df < min_bits_all) {
      min_bits_all = min_bits_dtbw_df;
    }
    /**********************************************************/

    /**********************************************************/
    min_bits_dt_dt = calc_huff_bits(data_diff_time[0], data_diff_time[1],
                                    data_type, DIFF_TIME, DIFF_TIME, dataBands,
                                    lav_dt_dt, &coding_scheme_dt_dt);

    min_bits_dt_dt += 2;

    min_bits_dt_dt += num_lsb_bits;

    if (min_bits_dt_dt < min_bits_all) {
      min_bits_all = min_bits_dt_dt;
    }
    /**********************************************************/

  } /* if( allowDiffTimeBack_flag ) */

  /***************************/
  /* Start actual coding now */
  /***************************/

  /* PCM or Diff/Huff Coding? */
  pcmCoding_flag = (min_bits_all == num_pcm_bits);

  FDKwriteBits(strm, pcmCoding_flag, 1);

  if (pcmCoding_flag) {
    /* Grouped PCM Coding */
    apply_pcm_coding(strm, aaInData[setIdx] + startBand,
                     aaInData[setIdx + 1] + startBand, quant_offset,
                     num_pcm_val, quant_levels);
  } else {
    /* Diff/Huff Coding */

    min_found = 0;

    /*******************************************/
    if (min_bits_all == min_bits_df_df) {
      FDKwriteBits(strm, DIFF_FREQ, 1);
      FDKwriteBits(strm, DIFF_FREQ, 1);

      apply_huff_coding(strm, data_diff_freq[0], data_diff_freq[1], data_type,
                        DIFF_FREQ, DIFF_FREQ, dataBands, lav_df_df,
                        coding_scheme_df_df);

      min_found = 1;
    }
    /*******************************************/

    /*******************************************/
    if (!min_found && (min_bits_all == min_bits_df_dt)) {
      FDKwriteBits(strm, DIFF_FREQ, 1);
      FDKwriteBits(strm, DIFF_TIME, 1);

      apply_huff_coding(strm, data_diff_freq[0], data_diff_time[1], data_type,
                        DIFF_FREQ, DIFF_TIME, dataBands, lav_df_dt,
                        coding_scheme_df_dt);

      min_found = 1;
    }
    /*******************************************/

    /*******************************************/
    /*******************************************/

    if (allowDiffTimeBack_flag) {
      /*******************************************/
      if (!min_found && (min_bits_all == min_bits_dtbw_df)) {
        FDKwriteBits(strm, DIFF_TIME, 1);
        FDKwriteBits(strm, DIFF_FREQ, 1);

        apply_huff_coding(strm, data_diff_time[0], data_diff_freq[1], data_type,
                          DIFF_TIME, DIFF_FREQ, dataBands, lav_dtbw_df,
                          coding_scheme_dtbw_df);

        min_found = 1;
      }
      /*******************************************/

      /*******************************************/
      if (!min_found && (min_bits_all == min_bits_dt_dt)) {
        FDKwriteBits(strm, DIFF_TIME, 1);
        FDKwriteBits(strm, DIFF_TIME, 1);

        apply_huff_coding(strm, data_diff_time[0], data_diff_time[1], data_type,
                          DIFF_TIME, DIFF_TIME, dataBands, lav_dt_dt,
                          coding_scheme_dt_dt);
      }
      /*******************************************/

    } /* if( allowDiffTimeBack_flag ) */

    /* LSB coding */
    if (splitLsb_flag) {
      apply_lsb_coding(strm, quant_data_lsb[0], 1, dataBands);

      apply_lsb_coding(strm, quant_data_lsb[1], 1, dataBands);
    }

  } /* Diff/Huff/LSB coding */

  return reset;
}

INT fdk_sacenc_ecDataSingleEnc(HANDLE_FDK_BITSTREAM strm,
                               SHORT aaInData[][MAXBANDS],
                               SHORT aHistory[MAXBANDS],
                               const DATA_TYPE data_type, const INT setIdx,
                               const INT startBand, const INT dataBands,
                               const INT coarse_flag,
                               const INT independency_flag) {
  SHORT reset = 0, pb = 0;
  SHORT quant_levels = 0, quant_offset = 0, num_pcm_val = 0;

  SHORT splitLsb_flag = 0;
  SHORT pcmCoding_flag = 0;

  SHORT allowDiffTimeBack_flag = !independency_flag || (setIdx > 0);

  SHORT num_lsb_bits = -1;
  SHORT num_pcm_bits = -1;

  SHORT quant_data_lsb[MAXBANDS];
  SHORT quant_data_msb[MAXBANDS];

  SHORT quant_data_hist_lsb[MAXBANDS];
  SHORT quant_data_hist_msb[MAXBANDS];

  SHORT data_diff_freq[MAXBANDS];
  SHORT data_diff_time[MAXBANDS + 2];

  SHORT *p_quant_data_msb;
  SHORT *p_quant_data_hist_msb = NULL;

  SHORT min_bits_all = 0;
  SHORT min_found = 0;

  SHORT min_bits_df = -1;
  SHORT min_bits_dt = -1;

  SHORT lav_df[2] = {-1, -1};
  SHORT lav_dt[2] = {-1, -1};

  SHORT coding_scheme_df = 0;
  SHORT coding_scheme_dt = 0;

  switch (data_type) {
    case t_CLD:
      if (coarse_flag) {
        splitLsb_flag = 0;
        quant_levels = 15;
        quant_offset = 7;
      } else {
        splitLsb_flag = 0;
        quant_levels = 31;
        quant_offset = 15;
      }
      break;
    case t_ICC:
      if (coarse_flag) {
        splitLsb_flag = 0;
        quant_levels = 4;
        quant_offset = 0;
      } else {
        splitLsb_flag = 0;
        quant_levels = 8;
        quant_offset = 0;
      }
      break;
  } /* switch( data_type ) */

  /* Split off LSB */
  if (splitLsb_flag) {
    split_lsb(aaInData[setIdx] + startBand, quant_offset, dataBands,
              quant_data_lsb, quant_data_msb);

    p_quant_data_msb = quant_data_msb;
    num_lsb_bits = dataBands;
  } else if (quant_offset != 0) {
    for (pb = 0; pb < dataBands; pb++) {
      quant_data_msb[pb] = aaInData[setIdx][startBand + pb] + quant_offset;
    }

    p_quant_data_msb = quant_data_msb;
    num_lsb_bits = 0;
  } else {
    p_quant_data_msb = aaInData[setIdx] + startBand;
    num_lsb_bits = 0;
  }

  if (allowDiffTimeBack_flag) {
    if (splitLsb_flag) {
      split_lsb(aHistory + startBand, quant_offset, dataBands,
                quant_data_hist_lsb, quant_data_hist_msb);

      p_quant_data_hist_msb = quant_data_hist_msb;
    } else if (quant_offset != 0) {
      for (pb = 0; pb < dataBands; pb++) {
        quant_data_hist_msb[pb] = aHistory[startBand + pb] + quant_offset;
      }
      p_quant_data_hist_msb = quant_data_hist_msb;
    } else {
      p_quant_data_hist_msb = aHistory + startBand;
    }
  }

  /* Calculate frequency differences */
  calc_diff_freq(p_quant_data_msb, data_diff_freq, dataBands);

  /* Calculate time differences */
  if (allowDiffTimeBack_flag) {
    calc_diff_time(p_quant_data_msb, p_quant_data_hist_msb, data_diff_time,
                   dataBands);
  }

  /* Calculate coding scheme with minumum bit consumption */

  /**********************************************************/
  num_pcm_bits = calc_pcm_bits(dataBands, quant_levels);
  num_pcm_val = dataBands;

  /**********************************************************/

  min_bits_all = num_pcm_bits;

  /**********************************************************/
  /**********************************************************/

  /**********************************************************/
  min_bits_df = calc_huff_bits(data_diff_freq, NULL, data_type, DIFF_FREQ,
                               DIFF_FREQ, dataBands, lav_df, &coding_scheme_df);

  if (allowDiffTimeBack_flag) min_bits_df += 1;

  min_bits_df += num_lsb_bits;

  if (min_bits_df < min_bits_all) {
    min_bits_all = min_bits_df;
  }
  /**********************************************************/

  /**********************************************************/
  if (allowDiffTimeBack_flag) {
    min_bits_dt =
        calc_huff_bits(data_diff_time, NULL, data_type, DIFF_TIME, DIFF_TIME,
                       dataBands, lav_dt, &coding_scheme_dt);

    min_bits_dt += 1;
    min_bits_dt += num_lsb_bits;

    if (min_bits_dt < min_bits_all) {
      min_bits_all = min_bits_dt;
    }
  } /* if( allowDiffTimeBack_flag ) */

  /***************************/
  /* Start actual coding now */
  /***************************/

  /* PCM or Diff/Huff Coding? */
  pcmCoding_flag = (min_bits_all == num_pcm_bits);

  FDKwriteBits(strm, pcmCoding_flag, 1);

  if (pcmCoding_flag) {
    /* Grouped PCM Coding */
    apply_pcm_coding(strm, aaInData[setIdx] + startBand, NULL, quant_offset,
                     num_pcm_val, quant_levels);
  } else {
    /* Diff/Huff Coding */

    min_found = 0;

    /*******************************************/
    if (min_bits_all == min_bits_df) {
      if (allowDiffTimeBack_flag) {
        FDKwriteBits(strm, DIFF_FREQ, 1);
      }

      apply_huff_coding(strm, data_diff_freq, NULL, data_type, DIFF_FREQ,
                        DIFF_FREQ, dataBands, lav_df, coding_scheme_df);

      min_found = 1;
    } /* if( min_bits_all == min_bits_df ) */
    /*******************************************/

    /*******************************************/
    if (allowDiffTimeBack_flag) {
      /*******************************************/
      if (!min_found && (min_bits_all == min_bits_dt)) {
        FDKwriteBits(strm, DIFF_TIME, 1);

        apply_huff_coding(strm, data_diff_time, NULL, data_type, DIFF_TIME,
                          DIFF_TIME, dataBands, lav_dt, coding_scheme_dt);
      }
      /*******************************************/

    } /* if( allowDiffTimeBack_flag ) */

    /* LSB coding */
    if (splitLsb_flag) {
      apply_lsb_coding(strm, quant_data_lsb, 1, dataBands);
    }

  } /* Diff/Huff/LSB coding */

  return reset;
}