path: root/libMpegTPEnc/src/tpenc_asc.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 transport format encoder library *********************

   Author(s):

   Description:

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

#include "tp_data.h"

#include "tpenc_lib.h"
#include "tpenc_asc.h"
#include "FDK_bitstream.h"
#include "genericStds.h"

#include "FDK_crc.h"

#define PCE_HEIGHT_EXT_SYNC (0xAC)
#define HEIGHT_NORMAL 0
#define HEIGHT_TOP 1
#define HEIGHT_BOTTOM 2
#define MAX_FRONT_ELEMENTS 8
#define MAX_SIDE_ELEMENTS 3
#define MAX_BACK_ELEMENTS 4

/**
 *  Describe additional PCE height information for front, side and back channel
 * elements.
 */
typedef struct {
  UCHAR
  num_front_height_channel_elements[2];      /*!< Number of front channel
                                                elements in top [0] and bottom
                                                [1] plane. */
  UCHAR num_side_height_channel_elements[2]; /*!< Number of side channel
                                                elements in top [0] and bottom
                                                [1] plane. */
  UCHAR num_back_height_channel_elements[2]; /*!< Number of back channel
                                                elements in top [0] and bottom
                                                [1] plane. */
} PCE_HEIGHT_NUM;

/**
 *  Describe a PCE based on placed channel elements and element type sequence.
 */
typedef struct {
  UCHAR num_front_channel_elements; /*!< Number of front channel elements. */
  UCHAR num_side_channel_elements;  /*!< Number of side channel elements. */
  UCHAR num_back_channel_elements;  /*!< Number of back channel elements. */
  UCHAR num_lfe_channel_elements;   /*!< Number of lfe channel elements. */
  const MP4_ELEMENT_ID
      *pEl_type; /*!< List contains sequence describing the elements
                      in present channel mode. (MPEG order) */
  const PCE_HEIGHT_NUM *pHeight_num;
} PCE_CONFIGURATION;

/**
 *  Map an incoming channel mode to a existing PCE configuration entry.
 */
typedef struct {
  CHANNEL_MODE channel_mode; /*!< Present channel mode. */
  PCE_CONFIGURATION
  pce_configuration; /*!< Program config element description. */

} CHANNEL_CONFIGURATION;

/**
 * The following arrays provide the IDs of the consecutive elements for each
 * mode.
 */
static const MP4_ELEMENT_ID elType_1[] = {ID_SCE};
static const MP4_ELEMENT_ID elType_2[] = {ID_CPE};
static const MP4_ELEMENT_ID elType_1_2[] = {ID_SCE, ID_CPE};
static const MP4_ELEMENT_ID elType_1_2_1[] = {ID_SCE, ID_CPE, ID_SCE};
static const MP4_ELEMENT_ID elType_1_2_2[] = {ID_SCE, ID_CPE, ID_CPE};
static const MP4_ELEMENT_ID elType_1_2_2_1[] = {ID_SCE, ID_CPE, ID_CPE, ID_LFE};
static const MP4_ELEMENT_ID elType_1_2_2_2_1[] = {ID_SCE, ID_CPE, ID_CPE,
                                                  ID_CPE, ID_LFE};
static const MP4_ELEMENT_ID elType_6_1[] = {ID_SCE, ID_CPE, ID_CPE, ID_SCE,
                                            ID_LFE};
static const MP4_ELEMENT_ID elType_7_1_back[] = {ID_SCE, ID_CPE, ID_CPE, ID_CPE,
                                                 ID_LFE};
static const MP4_ELEMENT_ID elType_7_1_top_front[] = {ID_SCE, ID_CPE, ID_CPE,
                                                      ID_LFE, ID_CPE};
static const MP4_ELEMENT_ID elType_7_1_rear_surround[] = {
    ID_SCE, ID_CPE, ID_CPE, ID_CPE, ID_LFE};
static const MP4_ELEMENT_ID elType_7_1_front_center[] = {ID_SCE, ID_CPE, ID_CPE,
                                                         ID_CPE, ID_LFE};

/**
 * The following arrays provide information on how many front, side and back
 * elements are assigned to the top or bottom plane for each mode that comprises
 * height information.
 */
static const PCE_HEIGHT_NUM heightNum_7_1_top_front = {{1, 0}, {0, 0}, {0, 0}};

/**
 * \brief Table contains all supported channel modes and according PCE
 configuration description.
 *
 * The mode identifier is followed by the number of front, side, back, and LFE
 elements.
 * These are followed by a pointer to the IDs of the consecutive elements
 (ID_SCE, ID_CPE, ID_LFE).
 *
 * For some modes (MODE_7_1_TOP_FRONT and MODE_22_2) additional height
 information is transmitted.
 * In this case the additional pointer provides information on how many front,
 side and back elements
 * are assigned to the top or bottom plane.The elements are arranged in the
 following order: normal height (front, side, back, LFE), top height (front,
 side, back), bottom height (front, side, back).
 *
 *
 * E.g. MODE_7_1_TOP_FRONT means:
 *                          - 3 elements are front channel elements.
 *                          - 0 elements are side channel elements.
 *                          - 1 element is back channel element.
 *                          - 1 element is an LFE channel element.
 *                          - the element order is ID_SCE, ID_CPE, ID_CPE,
 ID_LFE, ID_CPE.
 *                          - 1 of the front elements is in the top plane.
 *
 * This leads to the following mapping for the cconsecutive elements in the
 MODE_7_1_TOP_FRONT bitstream:
 *                          - ID_SCE -> normal height front,
                            - ID_CPE -> normal height front,
                            - ID_CPE -> normal height back,
                            - ID_LFE -> normal height LFE,
                            - ID_CPE -> top height front.
 */
static const CHANNEL_CONFIGURATION pceConfigTab[] = {
    {MODE_1,
     {1, 0, 0, 0, elType_1,
      NULL}}, /* don't transmit height information in this mode */
    {MODE_2,
     {1, 0, 0, 0, elType_2,
      NULL}}, /* don't transmit height information in this mode */
    {MODE_1_2,
     {2, 0, 0, 0, elType_1_2,
      NULL}}, /* don't transmit height information in this mode */
    {MODE_1_2_1,
     {2, 0, 1, 0, elType_1_2_1,
      NULL}}, /* don't transmit height information in this mode */
    {MODE_1_2_2,
     {2, 0, 1, 0, elType_1_2_2,
      NULL}}, /* don't transmit height information in this mode */
    {MODE_1_2_2_1,
     {2, 0, 1, 1, elType_1_2_2_1,
      NULL}}, /* don't transmit height information in this mode */
    {MODE_1_2_2_2_1,
     {3, 0, 1, 1, elType_1_2_2_2_1,
      NULL}}, /* don't transmit height information in this mode */

    {MODE_6_1,
     {2, 0, 2, 1, elType_6_1,
      NULL}}, /* don't transmit height information in this mode */
    {MODE_7_1_BACK,
     {2, 0, 2, 1, elType_7_1_back,
      NULL}}, /* don't transmit height information in this mode */
    {MODE_7_1_TOP_FRONT,
     {3, 0, 1, 1, elType_7_1_top_front, &heightNum_7_1_top_front}},

    {MODE_7_1_REAR_SURROUND,
     {2, 0, 2, 1, elType_7_1_rear_surround,
      NULL}}, /* don't transmit height information in this mode */
    {MODE_7_1_FRONT_CENTER,
     {3, 0, 1, 1, elType_7_1_front_center,
      NULL}} /* don't transmit height information in this mode */
};

/**
 * \brief  Get program config element description for existing channel mode.
 *
 * \param channel_mode          Current channel mode.
 *
 * \return
 *          - Pointer to PCE_CONFIGURATION entry, on success.
 *          - NULL, on failure.
 */
static const PCE_CONFIGURATION *getPceEntry(const CHANNEL_MODE channel_mode) {
  UINT i;
  const PCE_CONFIGURATION *pce_config = NULL;

  for (i = 0; i < (sizeof(pceConfigTab) / sizeof(CHANNEL_CONFIGURATION)); i++) {
    if (pceConfigTab[i].channel_mode == channel_mode) {
      pce_config = &pceConfigTab[i].pce_configuration;
      break;
    }
  }

  return pce_config;
}

int getChannelConfig(const CHANNEL_MODE channel_mode,
                     const UCHAR channel_config_zero) {
  INT chan_config = 0;

  if (channel_config_zero != 0) {
    chan_config = 0;
  } else {
    switch (channel_mode) {
      case MODE_1:
        chan_config = 1;
        break;
      case MODE_2:
        chan_config = 2;
        break;
      case MODE_1_2:
        chan_config = 3;
        break;
      case MODE_1_2_1:
        chan_config = 4;
        break;
      case MODE_1_2_2:
        chan_config = 5;
        break;
      case MODE_1_2_2_1:
        chan_config = 6;
        break;
      case MODE_1_2_2_2_1:
        chan_config = 7;
        break;
      case MODE_6_1:
        chan_config = 11;
        break;
      case MODE_7_1_BACK:
        chan_config = 12;
        break;
      case MODE_7_1_TOP_FRONT:
        chan_config = 14;
        break;
      default:
        chan_config = 0;
    }
  }

  return chan_config;
}

CHANNEL_MODE transportEnc_GetChannelMode(int noChannels) {
  CHANNEL_MODE chMode;

  if (noChannels <= 8 && noChannels > 0)
    chMode = (CHANNEL_MODE)(
        (noChannels == 8) ? 7
                          : noChannels); /* see : iso/mpeg4 v1 audio subpart1*/
  else
    chMode = MODE_UNKNOWN;

  return chMode;
}

int transportEnc_writePCE(HANDLE_FDK_BITSTREAM hBs, CHANNEL_MODE channelMode,
                          INT sampleRate, int instanceTagPCE, int profile,
                          int matrixMixdownA, int pseudoSurroundEnable,
                          UINT alignAnchor) {
  int sampleRateIndex, i;
  const PCE_CONFIGURATION *config = NULL;
  const MP4_ELEMENT_ID *pEl_list = NULL;
  UCHAR cpeCnt = 0, sceCnt = 0, lfeCnt = 0, frntCnt = 0, sdCnt = 0, bckCnt = 0,
        isCpe = 0, tag = 0, normalFrontEnd = 0, normalSideEnd = 0,
        normalBackEnd = 0, topFrontEnd = 0, topSideEnd = 0, topBackEnd = 0,
        bottomFrontEnd = 0, bottomSideEnd = 0;
#ifdef FDK_ASSERT_ENABLE
  UCHAR bottomBackEnd = 0;
#endif
  enum elementDepth { FRONT, SIDE, BACK } elDepth;

  sampleRateIndex = getSamplingRateIndex(sampleRate, 4);
  if (sampleRateIndex == 15) {
    return -1;
  }

  if ((config = getPceEntry(channelMode)) == NULL) {
    return -1;
  }

  FDK_ASSERT(config->num_front_channel_elements <= MAX_FRONT_ELEMENTS);
  FDK_ASSERT(config->num_side_channel_elements <= MAX_SIDE_ELEMENTS);
  FDK_ASSERT(config->num_back_channel_elements <= MAX_BACK_ELEMENTS);

  UCHAR frontIsCpe[MAX_FRONT_ELEMENTS] = {0},
        frontTag[MAX_FRONT_ELEMENTS] = {0}, sideIsCpe[MAX_SIDE_ELEMENTS] = {0},
        sideTag[MAX_SIDE_ELEMENTS] = {0}, backIsCpe[MAX_BACK_ELEMENTS] = {0},
        backTag[MAX_BACK_ELEMENTS] = {0};

  /* Write general information */

  FDKwriteBits(hBs, instanceTagPCE, 4);  /* Element instance tag */
  FDKwriteBits(hBs, profile, 2);         /* Object type */
  FDKwriteBits(hBs, sampleRateIndex, 4); /* Sample rate index*/

  FDKwriteBits(hBs, config->num_front_channel_elements,
               4); /* Front channel Elements */
  FDKwriteBits(hBs, config->num_side_channel_elements,
               4); /* No Side Channel Elements */
  FDKwriteBits(hBs, config->num_back_channel_elements,
               4); /* No Back channel Elements */
  FDKwriteBits(hBs, config->num_lfe_channel_elements,
               2); /* No Lfe channel elements */

  FDKwriteBits(hBs, 0, 3); /* No assoc data elements */
  FDKwriteBits(hBs, 0, 4); /* No valid cc elements */
  FDKwriteBits(hBs, 0, 1); /* Mono mixdown present */
  FDKwriteBits(hBs, 0, 1); /* Stereo mixdown present */

  if (matrixMixdownA != 0 &&
      ((channelMode == MODE_1_2_2) || (channelMode == MODE_1_2_2_1))) {
    FDKwriteBits(hBs, 1, 1); /* Matrix mixdown present */
    FDKwriteBits(hBs, (matrixMixdownA - 1) & 0x3, 2); /* matrix_mixdown_idx */
    FDKwriteBits(hBs, (pseudoSurroundEnable) ? 1 : 0,
                 1); /* pseudo_surround_enable */
  } else {
    FDKwriteBits(hBs, 0, 1); /* Matrix mixdown not present */
  }

  if (config->pHeight_num != NULL) {
    /* we have up to three different height levels, and in each height level we
     * may have front, side and back channels. We need to know where each
     * section ends to correctly count the tags */
    normalFrontEnd = config->num_front_channel_elements -
                     config->pHeight_num->num_front_height_channel_elements[0] -
                     config->pHeight_num->num_front_height_channel_elements[1];
    normalSideEnd = normalFrontEnd + config->num_side_channel_elements -
                    config->pHeight_num->num_side_height_channel_elements[0] -
                    config->pHeight_num->num_side_height_channel_elements[1];
    normalBackEnd = normalSideEnd + config->num_back_channel_elements -
                    config->pHeight_num->num_back_height_channel_elements[0] -
                    config->pHeight_num->num_back_height_channel_elements[1];

    topFrontEnd =
        normalBackEnd + config->num_lfe_channel_elements +
        config->pHeight_num->num_front_height_channel_elements[0]; /* only
                                                                      normal
                                                                      height
                                                                      LFEs
                                                                      assumed */
    topSideEnd =
        topFrontEnd + config->pHeight_num->num_side_height_channel_elements[0];
    topBackEnd =
        topSideEnd + config->pHeight_num->num_back_height_channel_elements[0];

    bottomFrontEnd =
        topBackEnd + config->pHeight_num->num_front_height_channel_elements[1];
    bottomSideEnd = bottomFrontEnd +
                    config->pHeight_num->num_side_height_channel_elements[1];
#ifdef FDK_ASSERT_ENABLE
    bottomBackEnd = bottomSideEnd +
                    config->pHeight_num->num_back_height_channel_elements[1];
#endif

  } else {
    /* we have only one height level, so we don't care about top or bottom */
    normalFrontEnd = config->num_front_channel_elements;
    normalSideEnd = normalFrontEnd + config->num_side_channel_elements;
    normalBackEnd = normalSideEnd + config->num_back_channel_elements;
  }

  /* assign cpe and tag information to either front, side or back channels */

  pEl_list = config->pEl_type;

  for (i = 0; i < config->num_front_channel_elements +
                      config->num_side_channel_elements +
                      config->num_back_channel_elements +
                      config->num_lfe_channel_elements;
       i++) {
    if (*pEl_list == ID_LFE) {
      pEl_list++;
      continue;
    }
    isCpe = (*pEl_list++ == ID_CPE) ? 1 : 0;
    tag = (isCpe) ? cpeCnt++ : sceCnt++;

    if (i < normalFrontEnd)
      elDepth = FRONT;
    else if (i < normalSideEnd)
      elDepth = SIDE;
    else if (i < normalBackEnd)
      elDepth = BACK;
    else if (i < topFrontEnd)
      elDepth = FRONT;
    else if (i < topSideEnd)
      elDepth = SIDE;
    else if (i < topBackEnd)
      elDepth = BACK;
    else if (i < bottomFrontEnd)
      elDepth = FRONT;
    else if (i < bottomSideEnd)
      elDepth = SIDE;
    else {
      elDepth = BACK;
      FDK_ASSERT(i < bottomBackEnd); /* won't fail if implementation of pce
                                        configuration table is correct */
    }

    switch (elDepth) {
      case FRONT:
        FDK_ASSERT(frntCnt < config->num_front_channel_elements);
        frontIsCpe[frntCnt] = isCpe;
        frontTag[frntCnt++] = tag;
        break;
      case SIDE:
        FDK_ASSERT(sdCnt < config->num_side_channel_elements);
        sideIsCpe[sdCnt] = isCpe;
        sideTag[sdCnt++] = tag;
        break;
      case BACK:
        FDK_ASSERT(bckCnt < config->num_back_channel_elements);
        backIsCpe[bckCnt] = isCpe;
        backTag[bckCnt++] = tag;
        break;
    }
  }

  /* Write front channel isCpe and tags */
  for (i = 0; i < config->num_front_channel_elements; i++) {
    FDKwriteBits(hBs, frontIsCpe[i], 1);
    FDKwriteBits(hBs, frontTag[i], 4);
  }
  /* Write side channel isCpe and tags */
  for (i = 0; i < config->num_side_channel_elements; i++) {
    FDKwriteBits(hBs, sideIsCpe[i], 1);
    FDKwriteBits(hBs, sideTag[i], 4);
  }
  /* Write back channel isCpe and tags */
  for (i = 0; i < config->num_back_channel_elements; i++) {
    FDKwriteBits(hBs, backIsCpe[i], 1);
    FDKwriteBits(hBs, backTag[i], 4);
  }
  /* Write LFE information */
  for (i = 0; i < config->num_lfe_channel_elements; i++) {
    FDKwriteBits(hBs, lfeCnt++, 4); /* LFE channel Instance Tag. */
  }

  /* - num_valid_cc_elements always 0.
     - num_assoc_data_elements always 0. */

  /* Byte alignment: relative to alignAnchor
       ADTS: align with respect to the first bit of the raw_data_block()
       ADIF: align with respect to the first bit of the header
       LATM: align with respect to the first bit of the ASC */
  FDKbyteAlign(hBs, alignAnchor); /* Alignment */

  /* Write comment information */

  if (config->pHeight_num != NULL) {
    /* embed height information in comment field */

    INT commentBytes =
        1 /* PCE_HEIGHT_EXT_SYNC */
        + ((((config->num_front_channel_elements +
              config->num_side_channel_elements +
              config->num_back_channel_elements)
             << 1) +
            7) >>
           3) /* 2 bit height info per element, round up to full bytes */
        + 1;  /* CRC */

    FDKwriteBits(hBs, commentBytes, 8); /* comment size. */

    FDK_CRCINFO crcInfo; /* CRC state info */
    INT crcReg;

    FDKcrcInit(&crcInfo, 0x07, 0xFF, 8);
    crcReg = FDKcrcStartReg(&crcInfo, hBs, 0);

    FDKwriteBits(hBs, PCE_HEIGHT_EXT_SYNC, 8); /* indicate height extension */

    /* front channel height information */
    for (i = 0;
         i < config->num_front_channel_elements -
                 config->pHeight_num->num_front_height_channel_elements[0] -
                 config->pHeight_num->num_front_height_channel_elements[1];
         i++)
      FDKwriteBits(hBs, HEIGHT_NORMAL, 2);
    for (i = 0; i < config->pHeight_num->num_front_height_channel_elements[0];
         i++)
      FDKwriteBits(hBs, HEIGHT_TOP, 2);
    for (i = 0; i < config->pHeight_num->num_front_height_channel_elements[1];
         i++)
      FDKwriteBits(hBs, HEIGHT_BOTTOM, 2);

    /* side channel height information */
    for (i = 0;
         i < config->num_side_channel_elements -
                 config->pHeight_num->num_side_height_channel_elements[0] -
                 config->pHeight_num->num_side_height_channel_elements[1];
         i++)
      FDKwriteBits(hBs, HEIGHT_NORMAL, 2);
    for (i = 0; i < config->pHeight_num->num_side_height_channel_elements[0];
         i++)
      FDKwriteBits(hBs, HEIGHT_TOP, 2);
    for (i = 0; i < config->pHeight_num->num_side_height_channel_elements[1];
         i++)
      FDKwriteBits(hBs, HEIGHT_BOTTOM, 2);

    /* back channel height information */
    for (i = 0;
         i < config->num_back_channel_elements -
                 config->pHeight_num->num_back_height_channel_elements[0] -
                 config->pHeight_num->num_back_height_channel_elements[1];
         i++)
      FDKwriteBits(hBs, HEIGHT_NORMAL, 2);
    for (i = 0; i < config->pHeight_num->num_back_height_channel_elements[0];
         i++)
      FDKwriteBits(hBs, HEIGHT_TOP, 2);
    for (i = 0; i < config->pHeight_num->num_back_height_channel_elements[1];
         i++)
      FDKwriteBits(hBs, HEIGHT_BOTTOM, 2);

    FDKbyteAlign(hBs, alignAnchor); /* Alignment */

    FDKcrcEndReg(&crcInfo, hBs, crcReg);
    FDKwriteBits(hBs, FDKcrcGetCRC(&crcInfo), 8);

  } else {
    FDKwriteBits(hBs, 0,
                 8); /* Do no write any comment or height information. */
  }

  return 0;
}

int transportEnc_GetPCEBits(CHANNEL_MODE channelMode, int matrixMixdownA,
                            int bits) {
  const PCE_CONFIGURATION *config = NULL;

  if ((config = getPceEntry(channelMode)) == NULL) {
    return -1; /* unsupported channelmapping */
  }

  bits +=
      4 + 2 + 4; /* Element instance tag  + Object type + Sample rate index */
  bits += 4 + 4 + 4 + 2; /* No (front + side + back + lfe channel) elements */
  bits += 3 + 4;         /* No (assoc data + valid cc) elements */
  bits += 1 + 1 + 1;     /* Mono + Stereo + Matrix mixdown present */

  if (matrixMixdownA != 0 &&
      ((channelMode == MODE_1_2_2) || (channelMode == MODE_1_2_2_1))) {
    bits += 3; /* matrix_mixdown_idx + pseudo_surround_enable */
  }

  bits += (1 + 4) * (INT)config->num_front_channel_elements;
  bits += (1 + 4) * (INT)config->num_side_channel_elements;
  bits += (1 + 4) * (INT)config->num_back_channel_elements;
  bits += (4) * (INT)config->num_lfe_channel_elements;

  /* - num_valid_cc_elements always 0.
     - num_assoc_data_elements always 0. */

  if ((bits % 8) != 0) {
    bits += (8 - (bits % 8)); /* Alignment */
  }

  bits += 8; /* Comment field  bytes */

  if (config->pHeight_num != NULL) {
    /* Comment field (height extension) */

    bits +=
        8 /* PCE_HEIGHT_EXT_SYNC */
        +
        ((config->num_front_channel_elements +
          config->num_side_channel_elements + config->num_back_channel_elements)
         << 1) /* 2 bit height info per element */
        + 8;   /* CRC */

    if ((bits % 8) != 0) {
      bits += (8 - (bits % 8)); /* Alignment */
    }
  }

  return bits;
}

static void writeAot(HANDLE_FDK_BITSTREAM hBitstreamBuffer,
                     AUDIO_OBJECT_TYPE aot) {
  int tmp = (int)aot;

  if (tmp > 31) {
    FDKwriteBits(hBitstreamBuffer, AOT_ESCAPE, 5);
    FDKwriteBits(hBitstreamBuffer, tmp - 32, 6); /* AudioObjectType */
  } else {
    FDKwriteBits(hBitstreamBuffer, tmp, 5);
  }
}

static void writeSampleRate(HANDLE_FDK_BITSTREAM hBs, int sampleRate,
                            int nBits) {
  int srIdx = getSamplingRateIndex(sampleRate, nBits);

  FDKwriteBits(hBs, srIdx, nBits);
  if (srIdx == (1 << nBits) - 1) {
    FDKwriteBits(hBs, sampleRate, 24);
  }
}

static int transportEnc_writeGASpecificConfig(HANDLE_FDK_BITSTREAM asc,
                                              CODER_CONFIG *config, int extFlg,
                                              UINT alignAnchor) {
  int aot = config->aot;
  int samplesPerFrame = config->samplesPerFrame;

  /* start of GASpecificConfig according to ISO/IEC 14496-3 Subpart 4, 4.4.1 */
  FDKwriteBits(asc,
               ((samplesPerFrame == 960 || samplesPerFrame == 480) ? 1 : 0),
               1); /* frameLengthFlag: 1 for a 960/480 (I)MDCT, 0 for a 1024/512
                      (I)MDCT*/
  FDKwriteBits(asc, 0,
               1); /* dependsOnCoreCoder: Sampling Rate Coder Specific, see in
                      ISO/IEC 14496-3 Subpart 4, 4.4.1 */
  FDKwriteBits(asc, extFlg,
               1); /* Extension Flag: Shall be 1 for aot = 17,19,20,21,22,23 */

  /* Write PCE if channel config is not 1-7 */
  if (getChannelConfig(config->channelMode, config->channelConfigZero) == 0) {
    transportEnc_writePCE(asc, config->channelMode, config->samplingRate, 0, 1,
                          config->matrixMixdownA,
                          (config->flags & CC_PSEUDO_SURROUND) ? 1 : 0,
                          alignAnchor);
  }
  if ((aot == AOT_AAC_SCAL) || (aot == AOT_ER_AAC_SCAL)) {
    FDKwriteBits(asc, 0, 3); /* layerNr */
  }
  if (extFlg) {
    if (aot == AOT_ER_BSAC) {
      FDKwriteBits(asc, config->BSACnumOfSubFrame, 5); /* numOfSubFrame */
      FDKwriteBits(asc, config->BSAClayerLength, 11);  /* layer_length */
    }
    if ((aot == AOT_ER_AAC_LC) || (aot == AOT_ER_AAC_LTP) ||
        (aot == AOT_ER_AAC_SCAL) || (aot == AOT_ER_AAC_LD)) {
      FDKwriteBits(asc, (config->flags & CC_VCB11) ? 1 : 0,
                   1); /* aacSectionDataResillienceFlag */
      FDKwriteBits(asc, (config->flags & CC_RVLC) ? 1 : 0,
                   1); /* aacScaleFactorDataResillienceFlag */
      FDKwriteBits(asc, (config->flags & CC_HCR) ? 1 : 0,
                   1); /* aacSpectralDataResillienceFlag */
    }
    FDKwriteBits(asc, 0, 1); /* extensionFlag3: reserved. Shall be '0' */
  }
  return 0;
}

static int transportEnc_writeELDSpecificConfig(HANDLE_FDK_BITSTREAM hBs,
                                               CODER_CONFIG *config,
                                               int epConfig,
                                               CSTpCallBacks *cb) {
  UINT frameLengthFlag = 0;
  switch (config->samplesPerFrame) {
    case 512:
    case 256:
    case 128:
    case 64:
      frameLengthFlag = 0;
      break;
    case 480:
    case 240:
    case 160:
    case 120:
    case 60:
      frameLengthFlag = 1;
      break;
  }

  FDKwriteBits(hBs, frameLengthFlag, 1);

  FDKwriteBits(hBs, (config->flags & CC_VCB11) ? 1 : 0, 1);
  FDKwriteBits(hBs, (config->flags & CC_RVLC) ? 1 : 0, 1);
  FDKwriteBits(hBs, (config->flags & CC_HCR) ? 1 : 0, 1);

  FDKwriteBits(hBs, (config->flags & CC_SBR) ? 1 : 0, 1); /* SBR header flag */
  if ((config->flags & CC_SBR)) {
    FDKwriteBits(hBs, (config->samplingRate == config->extSamplingRate) ? 0 : 1,
                 1); /* Samplerate Flag */
    FDKwriteBits(hBs, (config->flags & CC_SBRCRC) ? 1 : 0, 1); /* SBR CRC flag*/

    if (cb->cbSbr != NULL) {
      const PCE_CONFIGURATION *pPce;
      int e, sbrElementIndex = 0;

      pPce = getPceEntry(config->channelMode);

      for (e = 0; e < pPce->num_front_channel_elements +
                          pPce->num_side_channel_elements +
                          pPce->num_back_channel_elements +
                          pPce->num_lfe_channel_elements;
           e++) {
        if ((pPce->pEl_type[e] == ID_SCE) || (pPce->pEl_type[e] == ID_CPE)) {
          cb->cbSbr(cb->cbSbrData, hBs, 0, 0, 0, config->aot, pPce->pEl_type[e],
                    sbrElementIndex, 0, 0, 0, NULL, 1);
          sbrElementIndex++;
        }
      }
    }
  }

  if ((config->flags & CC_SAC) && (cb->cbSsc != NULL)) {
    FDKwriteBits(hBs, ELDEXT_LDSAC, 4);

    const INT eldExtLen =
        (cb->cbSsc(cb->cbSscData, NULL, config->aot, config->extSamplingRate, 0,
                   0, 0, 0, NULL) +
         7) >>
        3;
    INT cnt = eldExtLen;

    if (cnt < 0xF) {
      FDKwriteBits(hBs, cnt, 4);
    } else {
      FDKwriteBits(hBs, 0xF, 4);
      cnt -= 0xF;

      if (cnt < 0xFF) {
        FDKwriteBits(hBs, cnt, 8);
      } else {
        FDKwriteBits(hBs, 0xFF, 8);
        cnt -= 0xFF;

        FDK_ASSERT(cnt <= 0xFFFF);
        FDKwriteBits(hBs, cnt, 16);
      }
    }

    cb->cbSsc(cb->cbSscData, hBs, config->aot, config->extSamplingRate, 0, 0, 0,
              0, NULL);
  }

  if (config->downscaleSamplingRate != 0 &&
      config->downscaleSamplingRate != config->extSamplingRate) {
    /* downscale active */

    /* eldExtLenDsc: Number of bytes for the ELD downscale extension (srIdx
       needs 1 byte
       + downscaleSamplingRate needs additional 3 bytes) */
    int eldExtLenDsc = 1;
    int downscaleSamplingRate = config->downscaleSamplingRate;
    FDKwriteBits(hBs, ELDEXT_DOWNSCALEINFO, 4); /* ELDEXT_DOWNSCALEINFO */

    if ((downscaleSamplingRate != 96000) && (downscaleSamplingRate != 88200) &&
        (downscaleSamplingRate != 64000) && (downscaleSamplingRate != 48000) &&
        (downscaleSamplingRate != 44100) && (downscaleSamplingRate != 32000) &&
        (downscaleSamplingRate != 24000) && (downscaleSamplingRate != 22050) &&
        (downscaleSamplingRate != 16000) && (downscaleSamplingRate != 12000) &&
        (downscaleSamplingRate != 11025) && (downscaleSamplingRate != 8000) &&
        (downscaleSamplingRate != 7350)) {
      eldExtLenDsc = 4; /* length extends to 4 if downscaleSamplingRate's value
                           is not one of the listed values */
    }

    FDKwriteBits(hBs, eldExtLenDsc, 4);
    writeSampleRate(hBs, downscaleSamplingRate, 4);
    FDKwriteBits(hBs, 0x0, 4); /* fill_nibble */
  }

  FDKwriteBits(hBs, ELDEXT_TERM, 4); /* ELDEXT_TERM */

  return 0;
}

static int transportEnc_writeUsacSpecificConfig(HANDLE_FDK_BITSTREAM hBs,
                                                int extFlag, CODER_CONFIG *cc,
                                                CSTpCallBacks *cb) {
  FDK_BITSTREAM usacConf;
  int usacConfigBits = cc->rawConfigBits;

  if ((usacConfigBits <= 0) ||
      ((usacConfigBits + 7) / 8 > (int)sizeof(cc->rawConfig))) {
    return TRANSPORTENC_UNSUPPORTED_FORMAT;
  }
  FDKinitBitStream(&usacConf, cc->rawConfig, BUFSIZE_DUMMY_VALUE,
                   usacConfigBits, BS_READER);

  for (; usacConfigBits > 0; usacConfigBits--) {
    UINT tmp = FDKreadBit(&usacConf);
    FDKwriteBits(hBs, tmp, 1);
  }
  FDKsyncCache(hBs);

  return TRANSPORTENC_OK;
}

int transportEnc_writeASC(HANDLE_FDK_BITSTREAM asc, CODER_CONFIG *config,
                          CSTpCallBacks *cb) {
  UINT extFlag = 0;
  int err;
  int epConfig = 0;

  /* Required for the PCE. */
  UINT alignAnchor = FDKgetValidBits(asc);

  /* Extension Flag: Shall be 1 for aot = 17,19,20,21,22,23,39 */
  switch (config->aot) {
    case AOT_ER_AAC_LC:
    case AOT_ER_AAC_LTP:
    case AOT_ER_AAC_SCAL:
    case AOT_ER_TWIN_VQ:
    case AOT_ER_BSAC:
    case AOT_ER_AAC_LD:
    case AOT_ER_AAC_ELD:
    case AOT_USAC:
      extFlag = 1;
      break;
    default:
      break;
  }

  if (config->sbrSignaling == SIG_EXPLICIT_HIERARCHICAL && config->sbrPresent)
    writeAot(asc, config->extAOT);
  else
    writeAot(asc, config->aot);

  /* In case of USAC it is the output not the core sampling rate */
  writeSampleRate(asc, config->samplingRate, 4);

  /* Try to guess a reasonable channel mode if not given */
  if (config->channelMode == MODE_INVALID) {
    config->channelMode = transportEnc_GetChannelMode(config->noChannels);
    if (config->channelMode == MODE_INVALID) return -1;
  }

  FDKwriteBits(
      asc, getChannelConfig(config->channelMode, config->channelConfigZero), 4);

  if (config->sbrSignaling == SIG_EXPLICIT_HIERARCHICAL && config->sbrPresent) {
    writeSampleRate(asc, config->extSamplingRate, 4);
    writeAot(asc, config->aot);
  }

  switch (config->aot) {
    case AOT_AAC_MAIN:
    case AOT_AAC_LC:
    case AOT_AAC_SSR:
    case AOT_AAC_LTP:
    case AOT_AAC_SCAL:
    case AOT_TWIN_VQ:
    case AOT_ER_AAC_LC:
    case AOT_ER_AAC_LTP:
    case AOT_ER_AAC_SCAL:
    case AOT_ER_TWIN_VQ:
    case AOT_ER_BSAC:
    case AOT_ER_AAC_LD:
      err =
          transportEnc_writeGASpecificConfig(asc, config, extFlag, alignAnchor);
      if (err) return err;
      break;
    case AOT_ER_AAC_ELD:
      err = transportEnc_writeELDSpecificConfig(asc, config, epConfig, cb);
      if (err) return err;
      break;
    case AOT_USAC:
      err = transportEnc_writeUsacSpecificConfig(asc, extFlag, config, cb);
      if (err) {
        return err;
      }
      break;
    default:
      return -1;
  }

  switch (config->aot) {
    case AOT_ER_AAC_LC:
    case AOT_ER_AAC_LTP:
    case AOT_ER_AAC_SCAL:
    case AOT_ER_TWIN_VQ:
    case AOT_ER_BSAC:
    case AOT_ER_AAC_LD:
    case AOT_ER_CELP:
    case AOT_ER_HVXC:
    case AOT_ER_HILN:
    case AOT_ER_PARA:
    case AOT_ER_AAC_ELD:
      FDKwriteBits(asc, 0, 2); /* epconfig 0 */
      break;
    default:
      break;
  }

  /* backward compatible explicit signaling of extension AOT */
  if (config->sbrSignaling == SIG_EXPLICIT_BW_COMPATIBLE) {
    TP_ASC_EXTENSION_ID ascExtId = ASCEXT_UNKOWN;

    if (config->sbrPresent) {
      ascExtId = ASCEXT_SBR;
      FDKwriteBits(asc, ascExtId, 11);
      writeAot(asc, config->extAOT);
      FDKwriteBits(asc, 1, 1); /* sbrPresentFlag=1 */
      writeSampleRate(asc, config->extSamplingRate, 4);
      if (config->psPresent) {
        ascExtId = ASCEXT_PS;
        FDKwriteBits(asc, ascExtId, 11);
        FDKwriteBits(asc, 1, 1); /* psPresentFlag=1 */
      }
    }
  }

  /* Make sure all bits are sync'ed */
  FDKsyncCache(asc);

  return 0;
}