aboutsummaryrefslogtreecommitdiffstats
path: root/fdk-aac/libMpegTPDec/src/tpdec_asc.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'fdk-aac/libMpegTPDec/src/tpdec_asc.cpp')
-rw-r--r--fdk-aac/libMpegTPDec/src/tpdec_asc.cpp2592
1 files changed, 2592 insertions, 0 deletions
diff --git a/fdk-aac/libMpegTPDec/src/tpdec_asc.cpp b/fdk-aac/libMpegTPDec/src/tpdec_asc.cpp
new file mode 100644
index 0000000..28bc22d
--- /dev/null
+++ b/fdk-aac/libMpegTPDec/src/tpdec_asc.cpp
@@ -0,0 +1,2592 @@
+/* -----------------------------------------------------------------------------
+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 decoder library *********************
+
+ Author(s): Daniel Homm
+
+ Description:
+
+*******************************************************************************/
+
+#include "tpdec_lib.h"
+#include "tp_data.h"
+
+#include "FDK_crc.h"
+
+#include "common_fix.h"
+
+/**
+ * The following arrays provide the IDs of the consecutive elements for each
+ * channel configuration. Every channel_configuration has to be finalized with
+ * ID_NONE.
+ */
+static const MP4_ELEMENT_ID channel_configuration_0[] = {ID_NONE};
+static const MP4_ELEMENT_ID channel_configuration_1[] = {ID_SCE, ID_NONE};
+static const MP4_ELEMENT_ID channel_configuration_2[] = {ID_CPE, ID_NONE};
+static const MP4_ELEMENT_ID channel_configuration_3[] = {ID_SCE, ID_CPE,
+ ID_NONE};
+static const MP4_ELEMENT_ID channel_configuration_4[] = {ID_SCE, ID_CPE, ID_SCE,
+ ID_NONE};
+static const MP4_ELEMENT_ID channel_configuration_5[] = {ID_SCE, ID_CPE, ID_CPE,
+ ID_NONE};
+static const MP4_ELEMENT_ID channel_configuration_6[] = {ID_SCE, ID_CPE, ID_CPE,
+ ID_LFE, ID_NONE};
+static const MP4_ELEMENT_ID channel_configuration_7[] = {
+ ID_SCE, ID_CPE, ID_CPE, ID_CPE, ID_LFE, ID_NONE};
+static const MP4_ELEMENT_ID channel_configuration_8[] = {
+ ID_NONE}; /* reserved */
+static const MP4_ELEMENT_ID channel_configuration_9[] = {
+ ID_NONE}; /* reserved */
+static const MP4_ELEMENT_ID channel_configuration_10[] = {
+ ID_NONE}; /* reserved */
+static const MP4_ELEMENT_ID channel_configuration_11[] = {
+ ID_SCE, ID_CPE, ID_CPE, ID_SCE, ID_LFE, ID_NONE};
+static const MP4_ELEMENT_ID channel_configuration_12[] = {
+ ID_SCE, ID_CPE, ID_CPE, ID_CPE, ID_LFE, ID_NONE};
+static const MP4_ELEMENT_ID channel_configuration_13[] = {
+ ID_SCE, ID_CPE, ID_CPE, ID_CPE, ID_CPE, ID_SCE, ID_LFE, ID_LFE, ID_SCE,
+ ID_CPE, ID_CPE, ID_SCE, ID_CPE, ID_SCE, ID_SCE, ID_CPE, ID_NONE};
+static const MP4_ELEMENT_ID channel_configuration_14[] = {
+ ID_SCE, ID_CPE, ID_CPE, ID_LFE, ID_CPE, ID_NONE};
+
+static const MP4_ELEMENT_ID *channel_configuration_array[] = {
+ channel_configuration_0, channel_configuration_1,
+ channel_configuration_2, channel_configuration_3,
+ channel_configuration_4, channel_configuration_5,
+ channel_configuration_6, channel_configuration_7,
+ channel_configuration_8, channel_configuration_9,
+ channel_configuration_10, channel_configuration_11,
+ channel_configuration_12, channel_configuration_13,
+ channel_configuration_14};
+
+#define TP_USAC_MAX_CHANNEL_CONFIGURATION_INDEX (13)
+#define SC_CHANNEL_CONFIG_TAB_SIZE (TP_USAC_MAX_CHANNEL_CONFIGURATION_INDEX + 1)
+
+/* channel config structure used for sanity check */
+typedef struct {
+ SCHAR nCh; /* number of channels */
+ SCHAR nSCE; /* number of SCE's */
+ SCHAR nCPE; /* number of CPE's */
+ SCHAR nLFE; /* number of LFE's */
+} SC_CHANNEL_CONFIG;
+
+static const SC_CHANNEL_CONFIG sc_chan_config_tab[SC_CHANNEL_CONFIG_TAB_SIZE] =
+ {
+ /* nCh, nSCE, nCPE, nLFE, cci */
+ {0, 0, 0, 0}, /* 0 */
+ {1, 1, 0, 0}, /* 1 */
+ {2, 0, 1, 0}, /* 2 */
+ {3, 1, 1, 0}, /* 3 */
+ {4, 2, 1, 0}, /* 4 */
+ {5, 1, 2, 0}, /* 5 */
+ {6, 1, 2, 1}, /* 6 */
+ {8, 1, 3, 1}, /* 7 */
+ {2, 2, 0, 0}, /* 8 */
+ {3, 1, 1, 0}, /* 9 */
+ {4, 0, 2, 0}, /* 10 */
+ {7, 2, 2, 1}, /* 11 */
+ {8, 1, 3, 1}, /* 12 */
+ {24, 6, 8, 2} /* 13 */
+};
+
+void CProgramConfig_Reset(CProgramConfig *pPce) { pPce->elCounter = 0; }
+
+void CProgramConfig_Init(CProgramConfig *pPce) {
+ FDKmemclear(pPce, sizeof(CProgramConfig));
+ pPce->SamplingFrequencyIndex = 0xf;
+}
+
+int CProgramConfig_IsValid(const CProgramConfig *pPce) {
+ return ((pPce->isValid) ? 1 : 0);
+}
+
+#define PCE_HEIGHT_EXT_SYNC (0xAC)
+
+/*
+ * Read the extension for height info.
+ * return 0 if successfull,
+ * -1 if the CRC failed,
+ * -2 if invalid HeightInfo.
+ */
+static int CProgramConfig_ReadHeightExt(CProgramConfig *pPce,
+ HANDLE_FDK_BITSTREAM bs,
+ int *const bytesAvailable,
+ const UINT alignmentAnchor) {
+ int err = 0;
+ FDK_CRCINFO crcInfo; /* CRC state info */
+ INT crcReg;
+ FDKcrcInit(&crcInfo, 0x07, 0xFF, 8);
+ crcReg = FDKcrcStartReg(&crcInfo, bs, 0);
+ UINT startAnchor = FDKgetValidBits(bs);
+
+ FDK_ASSERT(pPce != NULL);
+ FDK_ASSERT(bs != NULL);
+ FDK_ASSERT(bytesAvailable != NULL);
+
+ if ((startAnchor >= 24) && (*bytesAvailable >= 3) &&
+ (FDKreadBits(bs, 8) == PCE_HEIGHT_EXT_SYNC)) {
+ int i;
+
+ for (i = 0; i < pPce->NumFrontChannelElements; i++) {
+ if ((pPce->FrontElementHeightInfo[i] = (UCHAR)FDKreadBits(bs, 2)) >=
+ PC_NUM_HEIGHT_LAYER) {
+ err = -2; /* height information is out of the valid range */
+ }
+ }
+ for (i = 0; i < pPce->NumSideChannelElements; i++) {
+ if ((pPce->SideElementHeightInfo[i] = (UCHAR)FDKreadBits(bs, 2)) >=
+ PC_NUM_HEIGHT_LAYER) {
+ err = -2; /* height information is out of the valid range */
+ }
+ }
+ for (i = 0; i < pPce->NumBackChannelElements; i++) {
+ if ((pPce->BackElementHeightInfo[i] = (UCHAR)FDKreadBits(bs, 2)) >=
+ PC_NUM_HEIGHT_LAYER) {
+ err = -2; /* height information is out of the valid range */
+ }
+ }
+ FDKbyteAlign(bs, alignmentAnchor);
+
+ FDKcrcEndReg(&crcInfo, bs, crcReg);
+ if ((USHORT)FDKreadBits(bs, 8) != FDKcrcGetCRC(&crcInfo)) {
+ /* CRC failed */
+ err = -1;
+ }
+ if (err != 0) {
+ /* Reset whole height information in case an error occured during parsing.
+ The return value ensures that pPce->isValid is set to 0 and implicit
+ channel mapping is used. */
+ FDKmemclear(pPce->FrontElementHeightInfo,
+ sizeof(pPce->FrontElementHeightInfo));
+ FDKmemclear(pPce->SideElementHeightInfo,
+ sizeof(pPce->SideElementHeightInfo));
+ FDKmemclear(pPce->BackElementHeightInfo,
+ sizeof(pPce->BackElementHeightInfo));
+ }
+ } else {
+ /* No valid extension data found -> restore the initial bitbuffer state */
+ FDKpushBack(bs, (INT)startAnchor - (INT)FDKgetValidBits(bs));
+ }
+
+ /* Always report the bytes read. */
+ *bytesAvailable -= ((INT)startAnchor - (INT)FDKgetValidBits(bs)) >> 3;
+
+ return (err);
+}
+
+void CProgramConfig_Read(CProgramConfig *pPce, HANDLE_FDK_BITSTREAM bs,
+ UINT alignmentAnchor) {
+ int i, err = 0;
+ int commentBytes;
+
+ pPce->NumEffectiveChannels = 0;
+ pPce->NumChannels = 0;
+ pPce->ElementInstanceTag = (UCHAR)FDKreadBits(bs, 4);
+ pPce->Profile = (UCHAR)FDKreadBits(bs, 2);
+ pPce->SamplingFrequencyIndex = (UCHAR)FDKreadBits(bs, 4);
+ pPce->NumFrontChannelElements = (UCHAR)FDKreadBits(bs, 4);
+ pPce->NumSideChannelElements = (UCHAR)FDKreadBits(bs, 4);
+ pPce->NumBackChannelElements = (UCHAR)FDKreadBits(bs, 4);
+ pPce->NumLfeChannelElements = (UCHAR)FDKreadBits(bs, 2);
+ pPce->NumAssocDataElements = (UCHAR)FDKreadBits(bs, 3);
+ pPce->NumValidCcElements = (UCHAR)FDKreadBits(bs, 4);
+
+ if ((pPce->MonoMixdownPresent = (UCHAR)FDKreadBits(bs, 1)) != 0) {
+ pPce->MonoMixdownElementNumber = (UCHAR)FDKreadBits(bs, 4);
+ }
+
+ if ((pPce->StereoMixdownPresent = (UCHAR)FDKreadBits(bs, 1)) != 0) {
+ pPce->StereoMixdownElementNumber = (UCHAR)FDKreadBits(bs, 4);
+ }
+
+ if ((pPce->MatrixMixdownIndexPresent = (UCHAR)FDKreadBits(bs, 1)) != 0) {
+ pPce->MatrixMixdownIndex = (UCHAR)FDKreadBits(bs, 2);
+ pPce->PseudoSurroundEnable = (UCHAR)FDKreadBits(bs, 1);
+ }
+
+ for (i = 0; i < pPce->NumFrontChannelElements; i++) {
+ pPce->FrontElementIsCpe[i] = (UCHAR)FDKreadBits(bs, 1);
+ pPce->FrontElementTagSelect[i] = (UCHAR)FDKreadBits(bs, 4);
+ pPce->NumChannels += pPce->FrontElementIsCpe[i] ? 2 : 1;
+ }
+
+ for (i = 0; i < pPce->NumSideChannelElements; i++) {
+ pPce->SideElementIsCpe[i] = (UCHAR)FDKreadBits(bs, 1);
+ pPce->SideElementTagSelect[i] = (UCHAR)FDKreadBits(bs, 4);
+ pPce->NumChannels += pPce->SideElementIsCpe[i] ? 2 : 1;
+ }
+
+ for (i = 0; i < pPce->NumBackChannelElements; i++) {
+ pPce->BackElementIsCpe[i] = (UCHAR)FDKreadBits(bs, 1);
+ pPce->BackElementTagSelect[i] = (UCHAR)FDKreadBits(bs, 4);
+ pPce->NumChannels += pPce->BackElementIsCpe[i] ? 2 : 1;
+ }
+
+ pPce->NumEffectiveChannels = pPce->NumChannels;
+
+ for (i = 0; i < pPce->NumLfeChannelElements; i++) {
+ pPce->LfeElementTagSelect[i] = (UCHAR)FDKreadBits(bs, 4);
+ pPce->NumChannels += 1;
+ }
+
+ for (i = 0; i < pPce->NumAssocDataElements; i++) {
+ pPce->AssocDataElementTagSelect[i] = (UCHAR)FDKreadBits(bs, 4);
+ }
+
+ for (i = 0; i < pPce->NumValidCcElements; i++) {
+ pPce->CcElementIsIndSw[i] = (UCHAR)FDKreadBits(bs, 1);
+ pPce->ValidCcElementTagSelect[i] = (UCHAR)FDKreadBits(bs, 4);
+ }
+
+ FDKbyteAlign(bs, alignmentAnchor);
+
+ pPce->CommentFieldBytes = (UCHAR)FDKreadBits(bs, 8);
+ commentBytes = pPce->CommentFieldBytes;
+
+ /* Search for height info extension and read it if available */
+ err = CProgramConfig_ReadHeightExt(pPce, bs, &commentBytes, alignmentAnchor);
+
+ for (i = 0; i < commentBytes; i++) {
+ UCHAR text;
+
+ text = (UCHAR)FDKreadBits(bs, 8);
+
+ if (i < PC_COMMENTLENGTH) {
+ pPce->Comment[i] = text;
+ }
+ }
+
+ pPce->isValid = (err) ? 0 : 1;
+}
+
+/*
+ * Compare two program configurations.
+ * Returns the result of the comparison:
+ * -1 - completely different
+ * 0 - completely equal
+ * 1 - different but same channel configuration
+ * 2 - different channel configuration but same number of channels
+ */
+int CProgramConfig_Compare(const CProgramConfig *const pPce1,
+ const CProgramConfig *const pPce2) {
+ int result = 0; /* Innocent until proven false. */
+
+ if (FDKmemcmp(pPce1, pPce2, sizeof(CProgramConfig)) !=
+ 0) { /* Configurations are not completely equal.
+ So look into details and analyse the channel configurations: */
+ result = -1;
+
+ if (pPce1->NumChannels ==
+ pPce2->NumChannels) { /* Now the logic changes. We first assume to have
+ the same channel configuration and then prove
+ if this assumption is true. */
+ result = 1;
+
+ /* Front channels */
+ if (pPce1->NumFrontChannelElements != pPce2->NumFrontChannelElements) {
+ result = 2; /* different number of front channel elements */
+ } else {
+ int el, numCh1 = 0, numCh2 = 0;
+ for (el = 0; el < pPce1->NumFrontChannelElements; el += 1) {
+ if (pPce1->FrontElementHeightInfo[el] !=
+ pPce2->FrontElementHeightInfo[el]) {
+ result = 2; /* different height info */
+ break;
+ }
+ numCh1 += pPce1->FrontElementIsCpe[el] ? 2 : 1;
+ numCh2 += pPce2->FrontElementIsCpe[el] ? 2 : 1;
+ }
+ if (numCh1 != numCh2) {
+ result = 2; /* different number of front channels */
+ }
+ }
+ /* Side channels */
+ if (pPce1->NumSideChannelElements != pPce2->NumSideChannelElements) {
+ result = 2; /* different number of side channel elements */
+ } else {
+ int el, numCh1 = 0, numCh2 = 0;
+ for (el = 0; el < pPce1->NumSideChannelElements; el += 1) {
+ if (pPce1->SideElementHeightInfo[el] !=
+ pPce2->SideElementHeightInfo[el]) {
+ result = 2; /* different height info */
+ break;
+ }
+ numCh1 += pPce1->SideElementIsCpe[el] ? 2 : 1;
+ numCh2 += pPce2->SideElementIsCpe[el] ? 2 : 1;
+ }
+ if (numCh1 != numCh2) {
+ result = 2; /* different number of side channels */
+ }
+ }
+ /* Back channels */
+ if (pPce1->NumBackChannelElements != pPce2->NumBackChannelElements) {
+ result = 2; /* different number of back channel elements */
+ } else {
+ int el, numCh1 = 0, numCh2 = 0;
+ for (el = 0; el < pPce1->NumBackChannelElements; el += 1) {
+ if (pPce1->BackElementHeightInfo[el] !=
+ pPce2->BackElementHeightInfo[el]) {
+ result = 2; /* different height info */
+ break;
+ }
+ numCh1 += pPce1->BackElementIsCpe[el] ? 2 : 1;
+ numCh2 += pPce2->BackElementIsCpe[el] ? 2 : 1;
+ }
+ if (numCh1 != numCh2) {
+ result = 2; /* different number of back channels */
+ }
+ }
+ /* LFE channels */
+ if (pPce1->NumLfeChannelElements != pPce2->NumLfeChannelElements) {
+ result = 2; /* different number of lfe channels */
+ }
+ /* LFEs are always SCEs so we don't need to count the channels. */
+ }
+ }
+
+ return result;
+}
+
+void CProgramConfig_GetDefault(CProgramConfig *pPce, const UINT channelConfig) {
+ FDK_ASSERT(pPce != NULL);
+
+ /* Init PCE */
+ CProgramConfig_Init(pPce);
+ pPce->Profile =
+ 1; /* Set AAC LC because it is the only supported object type. */
+
+ switch (channelConfig) {
+ /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+ case 32: /* 7.1 side channel configuration as defined in FDK_audio.h */
+ pPce->NumFrontChannelElements = 2;
+ pPce->FrontElementIsCpe[0] = 0;
+ pPce->FrontElementIsCpe[1] = 1;
+ pPce->NumSideChannelElements = 1;
+ pPce->SideElementIsCpe[0] = 1;
+ pPce->NumBackChannelElements = 1;
+ pPce->BackElementIsCpe[0] = 1;
+ pPce->NumLfeChannelElements = 1;
+ pPce->NumChannels = 8;
+ pPce->NumEffectiveChannels = 7;
+ pPce->isValid = 1;
+ break;
+ /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+ case 12: /* 3/0/4.1ch surround back */
+ pPce->BackElementIsCpe[1] = 1;
+ pPce->NumChannels += 1;
+ pPce->NumEffectiveChannels += 1;
+ FDK_FALLTHROUGH;
+ case 11: /* 3/0/3.1ch */
+ pPce->NumFrontChannelElements += 2;
+ pPce->FrontElementIsCpe[0] = 0;
+ pPce->FrontElementIsCpe[1] = 1;
+ pPce->NumBackChannelElements += 2;
+ pPce->BackElementIsCpe[0] = 1;
+ pPce->BackElementIsCpe[1] += 0;
+ pPce->NumLfeChannelElements += 1;
+ pPce->NumChannels += 7;
+ pPce->NumEffectiveChannels += 6;
+ pPce->isValid = 1;
+ break;
+ /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+ case 14: /* 2/0/0-3/0/2-0.1ch front height */
+ pPce->FrontElementHeightInfo[2] = 1; /* Top speaker */
+ FDK_FALLTHROUGH;
+ case 7: /* 5/0/2.1ch front */
+ pPce->NumFrontChannelElements += 1;
+ pPce->FrontElementIsCpe[2] = 1;
+ pPce->NumChannels += 2;
+ pPce->NumEffectiveChannels += 2;
+ FDK_FALLTHROUGH;
+ case 6: /* 3/0/2.1ch */
+ pPce->NumLfeChannelElements += 1;
+ pPce->NumChannels += 1;
+ FDK_FALLTHROUGH;
+ case 5: /* 3/0/2.0ch */
+ case 4: /* 3/0/1.0ch */
+ pPce->NumBackChannelElements += 1;
+ pPce->BackElementIsCpe[0] = (channelConfig > 4) ? 1 : 0;
+ pPce->NumChannels += (channelConfig > 4) ? 2 : 1;
+ pPce->NumEffectiveChannels += (channelConfig > 4) ? 2 : 1;
+ FDK_FALLTHROUGH;
+ case 3: /* 3/0/0.0ch */
+ pPce->NumFrontChannelElements += 1;
+ pPce->FrontElementIsCpe[1] = 1;
+ pPce->NumChannels += 2;
+ pPce->NumEffectiveChannels += 2;
+ FDK_FALLTHROUGH;
+ case 1: /* 1/0/0.0ch */
+ pPce->NumFrontChannelElements += 1;
+ pPce->FrontElementIsCpe[0] = 0;
+ pPce->NumChannels += 1;
+ pPce->NumEffectiveChannels += 1;
+ pPce->isValid = 1;
+ break;
+ /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+ case 2: /* 2/0/0.ch */
+ pPce->NumFrontChannelElements = 1;
+ pPce->FrontElementIsCpe[0] = 1;
+ pPce->NumChannels += 2;
+ pPce->NumEffectiveChannels += 2;
+ pPce->isValid = 1;
+ break;
+ /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+ default:
+ pPce->isValid = 0; /* To be explicit! */
+ break;
+ }
+
+ if (pPce->isValid) {
+ /* Create valid element instance tags */
+ int el, elTagSce = 0, elTagCpe = 0;
+
+ for (el = 0; el < pPce->NumFrontChannelElements; el += 1) {
+ pPce->FrontElementTagSelect[el] =
+ (pPce->FrontElementIsCpe[el]) ? elTagCpe++ : elTagSce++;
+ }
+ for (el = 0; el < pPce->NumSideChannelElements; el += 1) {
+ pPce->SideElementTagSelect[el] =
+ (pPce->SideElementIsCpe[el]) ? elTagCpe++ : elTagSce++;
+ }
+ for (el = 0; el < pPce->NumBackChannelElements; el += 1) {
+ pPce->BackElementTagSelect[el] =
+ (pPce->BackElementIsCpe[el]) ? elTagCpe++ : elTagSce++;
+ }
+ elTagSce = 0;
+ for (el = 0; el < pPce->NumLfeChannelElements; el += 1) {
+ pPce->LfeElementTagSelect[el] = elTagSce++;
+ }
+ }
+}
+
+/**
+ * \brief get implicit audio channel type for given channelConfig and MPEG
+ * ordered channel index
+ * \param channelConfig MPEG channelConfiguration from 1 upto 14
+ * \param index MPEG channel order index
+ * \return audio channel type.
+ */
+static void getImplicitAudioChannelTypeAndIndex(AUDIO_CHANNEL_TYPE *chType,
+ UCHAR *chIndex,
+ UINT channelConfig,
+ UINT index) {
+ if (index < 3) {
+ *chType = ACT_FRONT;
+ *chIndex = index;
+ } else {
+ switch (channelConfig) {
+ case 4: /* SCE, CPE, SCE */
+ case 5: /* SCE, CPE, CPE */
+ case 6: /* SCE, CPE, CPE, LFE */
+ switch (index) {
+ case 3:
+ case 4:
+ *chType = ACT_BACK;
+ *chIndex = index - 3;
+ break;
+ case 5:
+ *chType = ACT_LFE;
+ *chIndex = 0;
+ break;
+ }
+ break;
+ case 7: /* SCE,CPE,CPE,CPE,LFE */
+ switch (index) {
+ case 3:
+ case 4:
+ *chType = ACT_FRONT;
+ *chIndex = index;
+ break;
+ case 5:
+ case 6:
+ *chType = ACT_BACK;
+ *chIndex = index - 5;
+ break;
+ case 7:
+ *chType = ACT_LFE;
+ *chIndex = 0;
+ break;
+ }
+ break;
+ case 11: /* SCE,CPE,CPE,SCE,LFE */
+ if (index < 6) {
+ *chType = ACT_BACK;
+ *chIndex = index - 3;
+ } else {
+ *chType = ACT_LFE;
+ *chIndex = 0;
+ }
+ break;
+ case 12: /* SCE,CPE,CPE,CPE,LFE */
+ if (index < 7) {
+ *chType = ACT_BACK;
+ *chIndex = index - 3;
+ } else {
+ *chType = ACT_LFE;
+ *chIndex = 0;
+ }
+ break;
+ case 14: /* SCE,CPE,CPE,LFE,CPE */
+ switch (index) {
+ case 3:
+ case 4:
+ *chType = ACT_BACK;
+ *chIndex = index - 3;
+ break;
+ case 5:
+ *chType = ACT_LFE;
+ *chIndex = 0;
+ break;
+ case 6:
+ case 7:
+ *chType = ACT_FRONT_TOP;
+ *chIndex = index - 6; /* handle the top layer independently */
+ break;
+ }
+ break;
+ default:
+ *chType = ACT_NONE;
+ break;
+ }
+ }
+}
+
+int CProgramConfig_LookupElement(CProgramConfig *pPce, UINT channelConfig,
+ const UINT tag, const UINT channelIdx,
+ UCHAR chMapping[], AUDIO_CHANNEL_TYPE chType[],
+ UCHAR chIndex[], const UINT chDescrLen,
+ UCHAR *elMapping, MP4_ELEMENT_ID elList[],
+ MP4_ELEMENT_ID elType) {
+ if (channelConfig > 0) {
+ /* Constant channel mapping must have
+ been set during initialization. */
+ if (IS_CHANNEL_ELEMENT(elType)) {
+ *elMapping = pPce->elCounter;
+ if (elList[pPce->elCounter] != elType &&
+ !IS_USAC_CHANNEL_ELEMENT(elType)) {
+ /* Not in the list */
+ if ((channelConfig == 2) &&
+ (elType == ID_SCE)) { /* This scenario occurs with HE-AAC v2 streams
+ of buggy encoders. In other decoder
+ implementations decoding of this kind of
+ streams is desired. */
+ channelConfig = 1;
+ } else if ((elList[pPce->elCounter] == ID_LFE) &&
+ (elType ==
+ ID_SCE)) { /* Decode bitstreams which wrongly use ID_SCE
+ instead of ID_LFE element type. */
+ ;
+ } else {
+ return 0;
+ }
+ }
+ /* Assume all front channels */
+ getImplicitAudioChannelTypeAndIndex(
+ &chType[channelIdx], &chIndex[channelIdx], channelConfig, channelIdx);
+ if (elType == ID_CPE || elType == ID_USAC_CPE) {
+ chType[channelIdx + 1] = chType[channelIdx];
+ chIndex[channelIdx + 1] = chIndex[channelIdx] + 1;
+ }
+ pPce->elCounter++;
+ }
+ /* Accept all non-channel elements, too. */
+ return 1;
+ } else {
+ if ((!pPce->isValid) || (pPce->NumChannels > chDescrLen)) {
+ /* Implicit channel mapping. */
+ if (IS_USAC_CHANNEL_ELEMENT(elType)) {
+ *elMapping = pPce->elCounter++;
+ } else if (IS_MP4_CHANNEL_ELEMENT(elType)) {
+ /* Store all channel element IDs */
+ elList[pPce->elCounter] = elType;
+ *elMapping = pPce->elCounter++;
+ }
+ } else {
+ /* Accept the additional channel(s), only if the tag is in the lists */
+ int isCpe = 0, i;
+ /* Element counter */
+ int ec[PC_NUM_HEIGHT_LAYER] = {0};
+ /* Channel counters */
+ int cc[PC_NUM_HEIGHT_LAYER] = {0};
+ int fc[PC_NUM_HEIGHT_LAYER] = {0}; /* front channel counter */
+ int sc[PC_NUM_HEIGHT_LAYER] = {0}; /* side channel counter */
+ int bc[PC_NUM_HEIGHT_LAYER] = {0}; /* back channel counter */
+ int lc = 0; /* lfe channel counter */
+
+ /* General MPEG (PCE) composition rules:
+ - Over all:
+ <normal height channels><top height channels><bottom height
+ channels>
+ - Within each height layer:
+ <front channels><side channels><back channels>
+ - Exception:
+ The LFE channels have no height info and thus they are arranged at
+ the very end of the normal height layer channels.
+ */
+
+ switch (elType) {
+ case ID_CPE:
+ isCpe = 1;
+ FDK_FALLTHROUGH;
+ case ID_SCE:
+ /* search in front channels */
+ for (i = 0; i < pPce->NumFrontChannelElements; i++) {
+ int heightLayer = pPce->FrontElementHeightInfo[i];
+ if (isCpe == pPce->FrontElementIsCpe[i] &&
+ pPce->FrontElementTagSelect[i] == tag) {
+ int h, elIdx = ec[heightLayer], chIdx = cc[heightLayer];
+ AUDIO_CHANNEL_TYPE aChType =
+ (AUDIO_CHANNEL_TYPE)((heightLayer << 4) | ACT_FRONT);
+ for (h = heightLayer - 1; h >= 0; h -= 1) {
+ int el;
+ /* Count front channels/elements */
+ for (el = 0; el < pPce->NumFrontChannelElements; el += 1) {
+ if (pPce->FrontElementHeightInfo[el] == h) {
+ elIdx += 1;
+ chIdx += (pPce->FrontElementIsCpe[el]) ? 2 : 1;
+ }
+ }
+ /* Count side channels/elements */
+ for (el = 0; el < pPce->NumSideChannelElements; el += 1) {
+ if (pPce->SideElementHeightInfo[el] == h) {
+ elIdx += 1;
+ chIdx += (pPce->SideElementIsCpe[el]) ? 2 : 1;
+ }
+ }
+ /* Count back channels/elements */
+ for (el = 0; el < pPce->NumBackChannelElements; el += 1) {
+ if (pPce->BackElementHeightInfo[el] == h) {
+ elIdx += 1;
+ chIdx += (pPce->BackElementIsCpe[el]) ? 2 : 1;
+ }
+ }
+ if (h == 0) { /* normal height */
+ elIdx += pPce->NumLfeChannelElements;
+ chIdx += pPce->NumLfeChannelElements;
+ }
+ }
+ chMapping[chIdx] = channelIdx;
+ chType[chIdx] = aChType;
+ chIndex[chIdx] = fc[heightLayer];
+ if (isCpe) {
+ chMapping[chIdx + 1] = channelIdx + 1;
+ chType[chIdx + 1] = aChType;
+ chIndex[chIdx + 1] = fc[heightLayer] + 1;
+ }
+ *elMapping = elIdx;
+ return 1;
+ }
+ ec[heightLayer] += 1;
+ if (pPce->FrontElementIsCpe[i]) {
+ cc[heightLayer] += 2;
+ fc[heightLayer] += 2;
+ } else {
+ cc[heightLayer] += 1;
+ fc[heightLayer] += 1;
+ }
+ }
+ /* search in side channels */
+ for (i = 0; i < pPce->NumSideChannelElements; i++) {
+ int heightLayer = pPce->SideElementHeightInfo[i];
+ if (isCpe == pPce->SideElementIsCpe[i] &&
+ pPce->SideElementTagSelect[i] == tag) {
+ int h, elIdx = ec[heightLayer], chIdx = cc[heightLayer];
+ AUDIO_CHANNEL_TYPE aChType =
+ (AUDIO_CHANNEL_TYPE)((heightLayer << 4) | ACT_SIDE);
+ for (h = heightLayer - 1; h >= 0; h -= 1) {
+ int el;
+ /* Count front channels/elements */
+ for (el = 0; el < pPce->NumFrontChannelElements; el += 1) {
+ if (pPce->FrontElementHeightInfo[el] == h) {
+ elIdx += 1;
+ chIdx += (pPce->FrontElementIsCpe[el]) ? 2 : 1;
+ }
+ }
+ /* Count side channels/elements */
+ for (el = 0; el < pPce->NumSideChannelElements; el += 1) {
+ if (pPce->SideElementHeightInfo[el] == h) {
+ elIdx += 1;
+ chIdx += (pPce->SideElementIsCpe[el]) ? 2 : 1;
+ }
+ }
+ /* Count back channels/elements */
+ for (el = 0; el < pPce->NumBackChannelElements; el += 1) {
+ if (pPce->BackElementHeightInfo[el] == h) {
+ elIdx += 1;
+ chIdx += (pPce->BackElementIsCpe[el]) ? 2 : 1;
+ }
+ }
+ if (h ==
+ 0) { /* LFE channels belong to the normal height layer */
+ elIdx += pPce->NumLfeChannelElements;
+ chIdx += pPce->NumLfeChannelElements;
+ }
+ }
+ chMapping[chIdx] = channelIdx;
+ chType[chIdx] = aChType;
+ chIndex[chIdx] = sc[heightLayer];
+ if (isCpe) {
+ chMapping[chIdx + 1] = channelIdx + 1;
+ chType[chIdx + 1] = aChType;
+ chIndex[chIdx + 1] = sc[heightLayer] + 1;
+ }
+ *elMapping = elIdx;
+ return 1;
+ }
+ ec[heightLayer] += 1;
+ if (pPce->SideElementIsCpe[i]) {
+ cc[heightLayer] += 2;
+ sc[heightLayer] += 2;
+ } else {
+ cc[heightLayer] += 1;
+ sc[heightLayer] += 1;
+ }
+ }
+ /* search in back channels */
+ for (i = 0; i < pPce->NumBackChannelElements; i++) {
+ int heightLayer = pPce->BackElementHeightInfo[i];
+ if (isCpe == pPce->BackElementIsCpe[i] &&
+ pPce->BackElementTagSelect[i] == tag) {
+ int h, elIdx = ec[heightLayer], chIdx = cc[heightLayer];
+ AUDIO_CHANNEL_TYPE aChType =
+ (AUDIO_CHANNEL_TYPE)((heightLayer << 4) | ACT_BACK);
+ for (h = heightLayer - 1; h >= 0; h -= 1) {
+ int el;
+ /* Count front channels/elements */
+ for (el = 0; el < pPce->NumFrontChannelElements; el += 1) {
+ if (pPce->FrontElementHeightInfo[el] == h) {
+ elIdx += 1;
+ chIdx += (pPce->FrontElementIsCpe[el]) ? 2 : 1;
+ }
+ }
+ /* Count side channels/elements */
+ for (el = 0; el < pPce->NumSideChannelElements; el += 1) {
+ if (pPce->SideElementHeightInfo[el] == h) {
+ elIdx += 1;
+ chIdx += (pPce->SideElementIsCpe[el]) ? 2 : 1;
+ }
+ }
+ /* Count back channels/elements */
+ for (el = 0; el < pPce->NumBackChannelElements; el += 1) {
+ if (pPce->BackElementHeightInfo[el] == h) {
+ elIdx += 1;
+ chIdx += (pPce->BackElementIsCpe[el]) ? 2 : 1;
+ }
+ }
+ if (h == 0) { /* normal height */
+ elIdx += pPce->NumLfeChannelElements;
+ chIdx += pPce->NumLfeChannelElements;
+ }
+ }
+ chMapping[chIdx] = channelIdx;
+ chType[chIdx] = aChType;
+ chIndex[chIdx] = bc[heightLayer];
+ if (isCpe) {
+ chMapping[chIdx + 1] = channelIdx + 1;
+ chType[chIdx + 1] = aChType;
+ chIndex[chIdx + 1] = bc[heightLayer] + 1;
+ }
+ *elMapping = elIdx;
+ return 1;
+ }
+ ec[heightLayer] += 1;
+ if (pPce->BackElementIsCpe[i]) {
+ cc[heightLayer] += 2;
+ bc[heightLayer] += 2;
+ } else {
+ cc[heightLayer] += 1;
+ bc[heightLayer] += 1;
+ }
+ }
+ break;
+
+ case ID_LFE: { /* Unfortunately we have to go through all normal height
+ layer elements to get the position of the LFE
+ channels. Start with counting the front
+ channels/elements at normal height */
+ for (i = 0; i < pPce->NumFrontChannelElements; i += 1) {
+ int heightLayer = pPce->FrontElementHeightInfo[i];
+ ec[heightLayer] += 1;
+ cc[heightLayer] += (pPce->FrontElementIsCpe[i]) ? 2 : 1;
+ }
+ /* Count side channels/elements at normal height */
+ for (i = 0; i < pPce->NumSideChannelElements; i += 1) {
+ int heightLayer = pPce->SideElementHeightInfo[i];
+ ec[heightLayer] += 1;
+ cc[heightLayer] += (pPce->SideElementIsCpe[i]) ? 2 : 1;
+ }
+ /* Count back channels/elements at normal height */
+ for (i = 0; i < pPce->NumBackChannelElements; i += 1) {
+ int heightLayer = pPce->BackElementHeightInfo[i];
+ ec[heightLayer] += 1;
+ cc[heightLayer] += (pPce->BackElementIsCpe[i]) ? 2 : 1;
+ }
+
+ /* search in lfe channels */
+ for (i = 0; i < pPce->NumLfeChannelElements; i++) {
+ int elIdx =
+ ec[0]; /* LFE channels belong to the normal height layer */
+ int chIdx = cc[0];
+ if (pPce->LfeElementTagSelect[i] == tag) {
+ chMapping[chIdx] = channelIdx;
+ *elMapping = elIdx;
+ chType[chIdx] = ACT_LFE;
+ chIndex[chIdx] = lc;
+ return 1;
+ }
+ ec[0] += 1;
+ cc[0] += 1;
+ lc += 1;
+ }
+ } break;
+
+ /* Non audio elements */
+ case ID_CCE:
+ /* search in cce channels */
+ for (i = 0; i < pPce->NumValidCcElements; i++) {
+ if (pPce->ValidCcElementTagSelect[i] == tag) {
+ return 1;
+ }
+ }
+ break;
+ case ID_DSE:
+ /* search associated data elements */
+ for (i = 0; i < pPce->NumAssocDataElements; i++) {
+ if (pPce->AssocDataElementTagSelect[i] == tag) {
+ return 1;
+ }
+ }
+ break;
+ default:
+ return 0;
+ }
+ return 0; /* not found in any list */
+ }
+ }
+
+ return 1;
+}
+
+#define SPEAKER_PLANE_NORMAL 0
+#define SPEAKER_PLANE_TOP 1
+#define SPEAKER_PLANE_BOTTOM 2
+
+void CProgramConfig_GetChannelDescription(const UINT chConfig,
+ const CProgramConfig *pPce,
+ AUDIO_CHANNEL_TYPE chType[],
+ UCHAR chIndex[]) {
+ FDK_ASSERT(chType != NULL);
+ FDK_ASSERT(chIndex != NULL);
+
+ if ((chConfig == 0) && (pPce != NULL)) {
+ if (pPce->isValid) {
+ int spkPlane, chIdx = 0;
+ for (spkPlane = SPEAKER_PLANE_NORMAL; spkPlane <= SPEAKER_PLANE_BOTTOM;
+ spkPlane += 1) {
+ int elIdx, grpChIdx = 0;
+ for (elIdx = 0; elIdx < pPce->NumFrontChannelElements; elIdx += 1) {
+ if (pPce->FrontElementHeightInfo[elIdx] == spkPlane) {
+ chType[chIdx] = (AUDIO_CHANNEL_TYPE)((spkPlane << 4) | ACT_FRONT);
+ chIndex[chIdx++] = grpChIdx++;
+ if (pPce->FrontElementIsCpe[elIdx]) {
+ chType[chIdx] = (AUDIO_CHANNEL_TYPE)((spkPlane << 4) | ACT_FRONT);
+ chIndex[chIdx++] = grpChIdx++;
+ }
+ }
+ }
+ grpChIdx = 0;
+ for (elIdx = 0; elIdx < pPce->NumSideChannelElements; elIdx += 1) {
+ if (pPce->SideElementHeightInfo[elIdx] == spkPlane) {
+ chType[chIdx] = (AUDIO_CHANNEL_TYPE)((spkPlane << 4) | ACT_SIDE);
+ chIndex[chIdx++] = grpChIdx++;
+ if (pPce->SideElementIsCpe[elIdx]) {
+ chType[chIdx] = (AUDIO_CHANNEL_TYPE)((spkPlane << 4) | ACT_SIDE);
+ chIndex[chIdx++] = grpChIdx++;
+ }
+ }
+ }
+ grpChIdx = 0;
+ for (elIdx = 0; elIdx < pPce->NumBackChannelElements; elIdx += 1) {
+ if (pPce->BackElementHeightInfo[elIdx] == spkPlane) {
+ chType[chIdx] = (AUDIO_CHANNEL_TYPE)((spkPlane << 4) | ACT_BACK);
+ chIndex[chIdx++] = grpChIdx++;
+ if (pPce->BackElementIsCpe[elIdx]) {
+ chType[chIdx] = (AUDIO_CHANNEL_TYPE)((spkPlane << 4) | ACT_BACK);
+ chIndex[chIdx++] = grpChIdx++;
+ }
+ }
+ }
+ grpChIdx = 0;
+ if (spkPlane == SPEAKER_PLANE_NORMAL) {
+ for (elIdx = 0; elIdx < pPce->NumLfeChannelElements; elIdx += 1) {
+ chType[chIdx] = ACT_LFE;
+ chIndex[chIdx++] = grpChIdx++;
+ }
+ }
+ }
+ }
+ } else {
+ int chIdx;
+ for (chIdx = 0; chIdx < getNumberOfTotalChannels(chConfig); chIdx += 1) {
+ getImplicitAudioChannelTypeAndIndex(&chType[chIdx], &chIndex[chIdx],
+ chConfig, chIdx);
+ }
+ }
+}
+
+int CProgramConfig_GetPceChMap(const CProgramConfig *pPce, UCHAR pceChMap[],
+ const UINT pceChMapLen) {
+ const UCHAR *nElements = &pPce->NumFrontChannelElements;
+ const UCHAR *elHeight[3], *elIsCpe[3];
+ unsigned chIdx, plane, grp, offset, totCh[3], numCh[3][4];
+
+ FDK_ASSERT(pPce != NULL);
+ FDK_ASSERT(pceChMap != NULL);
+
+ /* Init counter: */
+ FDKmemclear(totCh, 3 * sizeof(unsigned));
+ FDKmemclear(numCh, 3 * 4 * sizeof(unsigned));
+
+ /* Analyse PCE: */
+ elHeight[0] = pPce->FrontElementHeightInfo;
+ elIsCpe[0] = pPce->FrontElementIsCpe;
+ elHeight[1] = pPce->SideElementHeightInfo;
+ elIsCpe[1] = pPce->SideElementIsCpe;
+ elHeight[2] = pPce->BackElementHeightInfo;
+ elIsCpe[2] = pPce->BackElementIsCpe;
+
+ for (plane = 0; plane <= SPEAKER_PLANE_BOTTOM; plane += 1) {
+ for (grp = 0; grp < 3; grp += 1) { /* front, side, back */
+ unsigned el;
+ for (el = 0; el < nElements[grp]; el += 1) {
+ if (elHeight[grp][el] == plane) {
+ unsigned elCh = elIsCpe[grp][el] ? 2 : 1;
+ numCh[plane][grp] += elCh;
+ totCh[plane] += elCh;
+ }
+ }
+ }
+ if (plane == SPEAKER_PLANE_NORMAL) {
+ unsigned elCh = pPce->NumLfeChannelElements;
+ numCh[plane][grp] += elCh;
+ totCh[plane] += elCh;
+ }
+ }
+ /* Sanity checks: */
+ chIdx = totCh[SPEAKER_PLANE_NORMAL] + totCh[SPEAKER_PLANE_TOP] +
+ totCh[SPEAKER_PLANE_BOTTOM];
+ if (chIdx > pceChMapLen) {
+ return -1;
+ }
+
+ /* Create map: */
+ offset = grp = 0;
+ unsigned grpThresh = numCh[SPEAKER_PLANE_NORMAL][grp];
+ for (chIdx = 0; chIdx < totCh[SPEAKER_PLANE_NORMAL]; chIdx += 1) {
+ while ((chIdx >= grpThresh) && (grp < 3)) {
+ offset += numCh[1][grp] + numCh[2][grp];
+ grp += 1;
+ grpThresh += numCh[SPEAKER_PLANE_NORMAL][grp];
+ }
+ pceChMap[chIdx] = chIdx + offset;
+ }
+ offset = 0;
+ for (grp = 0; grp < 4; grp += 1) { /* front, side, back and lfe */
+ offset += numCh[SPEAKER_PLANE_NORMAL][grp];
+ for (plane = SPEAKER_PLANE_TOP; plane <= SPEAKER_PLANE_BOTTOM; plane += 1) {
+ unsigned mapCh;
+ for (mapCh = 0; mapCh < numCh[plane][grp]; mapCh += 1) {
+ pceChMap[chIdx++] = offset;
+ offset += 1;
+ }
+ }
+ }
+ return 0;
+}
+
+int CProgramConfig_GetElementTable(const CProgramConfig *pPce,
+ MP4_ELEMENT_ID elList[],
+ const INT elListSize, UCHAR *pChMapIdx) {
+ int i, el = 0;
+
+ FDK_ASSERT(elList != NULL);
+ FDK_ASSERT(pChMapIdx != NULL);
+ FDK_ASSERT(pPce != NULL);
+
+ *pChMapIdx = 0;
+
+ if ((elListSize <
+ pPce->NumFrontChannelElements + pPce->NumSideChannelElements +
+ pPce->NumBackChannelElements + pPce->NumLfeChannelElements) ||
+ (pPce->NumChannels == 0)) {
+ return 0;
+ }
+
+ for (i = 0; i < pPce->NumFrontChannelElements; i += 1) {
+ elList[el++] = (pPce->FrontElementIsCpe[i]) ? ID_CPE : ID_SCE;
+ }
+
+ for (i = 0; i < pPce->NumSideChannelElements; i += 1) {
+ elList[el++] = (pPce->SideElementIsCpe[i]) ? ID_CPE : ID_SCE;
+ }
+
+ for (i = 0; i < pPce->NumBackChannelElements; i += 1) {
+ elList[el++] = (pPce->BackElementIsCpe[i]) ? ID_CPE : ID_SCE;
+ }
+
+ for (i = 0; i < pPce->NumLfeChannelElements; i += 1) {
+ elList[el++] = ID_LFE;
+ }
+
+ /* Find an corresponding channel configuration if possible */
+ switch (pPce->NumChannels) {
+ case 1:
+ case 2:
+ /* One and two channels have no alternatives. */
+ *pChMapIdx = pPce->NumChannels;
+ break;
+ case 3:
+ case 4:
+ case 5:
+ case 6: { /* Test if the number of channels can be used as channel config:
+ */
+ C_ALLOC_SCRATCH_START(tmpPce, CProgramConfig, 1);
+ /* Create a PCE for the config to test ... */
+ CProgramConfig_GetDefault(tmpPce, pPce->NumChannels);
+ /* ... and compare it with the given one. */
+ *pChMapIdx = (!(CProgramConfig_Compare(pPce, tmpPce) & 0xE))
+ ? pPce->NumChannels
+ : 0;
+ /* If compare result is 0 or 1 we can be sure that it is channel
+ * config 11. */
+ C_ALLOC_SCRATCH_END(tmpPce, CProgramConfig, 1);
+ } break;
+ case 7: {
+ C_ALLOC_SCRATCH_START(tmpPce, CProgramConfig, 1);
+ /* Create a PCE for the config to test ... */
+ CProgramConfig_GetDefault(tmpPce, 11);
+ /* ... and compare it with the given one. */
+ *pChMapIdx = (!(CProgramConfig_Compare(pPce, tmpPce) & 0xE)) ? 11 : 0;
+ /* If compare result is 0 or 1 we can be sure that it is channel
+ * config 11. */
+ C_ALLOC_SCRATCH_END(tmpPce, CProgramConfig, 1);
+ } break;
+ case 8: { /* Try the four possible 7.1ch configurations. One after the
+ other. */
+ UCHAR testCfg[4] = {32, 14, 12, 7};
+ C_ALLOC_SCRATCH_START(tmpPce, CProgramConfig, 1);
+ for (i = 0; i < 4; i += 1) {
+ /* Create a PCE for the config to test ... */
+ CProgramConfig_GetDefault(tmpPce, testCfg[i]);
+ /* ... and compare it with the given one. */
+ if (!(CProgramConfig_Compare(pPce, tmpPce) & 0xE)) {
+ /* If the compare result is 0 or 1 than the two channel configurations
+ * match. */
+ /* Explicit mapping of 7.1 side channel configuration to 7.1 rear
+ * channel mapping. */
+ *pChMapIdx = (testCfg[i] == 32) ? 12 : testCfg[i];
+ }
+ }
+ C_ALLOC_SCRATCH_END(tmpPce, CProgramConfig, 1);
+ } break;
+ default:
+ /* The PCE does not match any predefined channel configuration. */
+ *pChMapIdx = 0;
+ break;
+ }
+
+ return el;
+}
+
+static AUDIO_OBJECT_TYPE getAOT(HANDLE_FDK_BITSTREAM bs) {
+ int tmp = 0;
+
+ tmp = FDKreadBits(bs, 5);
+ if (tmp == AOT_ESCAPE) {
+ int tmp2 = FDKreadBits(bs, 6);
+ tmp = 32 + tmp2;
+ }
+
+ return (AUDIO_OBJECT_TYPE)tmp;
+}
+
+static INT getSampleRate(HANDLE_FDK_BITSTREAM bs, UCHAR *index, int nBits) {
+ INT sampleRate;
+ int idx;
+
+ idx = FDKreadBits(bs, nBits);
+ if (idx == (1 << nBits) - 1) {
+ if (FDKgetValidBits(bs) < 24) {
+ return 0;
+ }
+ sampleRate = FDKreadBits(bs, 24);
+ } else {
+ sampleRate = SamplingRateTable[idx];
+ }
+
+ *index = idx;
+
+ return sampleRate;
+}
+
+static TRANSPORTDEC_ERROR GaSpecificConfig_Parse(CSGaSpecificConfig *self,
+ CSAudioSpecificConfig *asc,
+ HANDLE_FDK_BITSTREAM bs,
+ UINT ascStartAnchor) {
+ TRANSPORTDEC_ERROR ErrorStatus = TRANSPORTDEC_OK;
+
+ self->m_frameLengthFlag = FDKreadBits(bs, 1);
+
+ self->m_dependsOnCoreCoder = FDKreadBits(bs, 1);
+
+ if (self->m_dependsOnCoreCoder) self->m_coreCoderDelay = FDKreadBits(bs, 14);
+
+ self->m_extensionFlag = FDKreadBits(bs, 1);
+
+ if (asc->m_channelConfiguration == 0) {
+ CProgramConfig_Read(&asc->m_progrConfigElement, bs, ascStartAnchor);
+ }
+
+ if ((asc->m_aot == AOT_AAC_SCAL) || (asc->m_aot == AOT_ER_AAC_SCAL)) {
+ self->m_layer = FDKreadBits(bs, 3);
+ }
+
+ if (self->m_extensionFlag) {
+ if (asc->m_aot == AOT_ER_BSAC) {
+ self->m_numOfSubFrame = FDKreadBits(bs, 5);
+ self->m_layerLength = FDKreadBits(bs, 11);
+ }
+
+ if ((asc->m_aot == AOT_ER_AAC_LC) || (asc->m_aot == AOT_ER_AAC_LTP) ||
+ (asc->m_aot == AOT_ER_AAC_SCAL) || (asc->m_aot == AOT_ER_AAC_LD)) {
+ asc->m_vcb11Flag = FDKreadBits(bs, 1); /* aacSectionDataResilienceFlag */
+ asc->m_rvlcFlag =
+ FDKreadBits(bs, 1); /* aacScalefactorDataResilienceFlag */
+ asc->m_hcrFlag = FDKreadBits(bs, 1); /* aacSpectralDataResilienceFlag */
+ }
+
+ self->m_extensionFlag3 = FDKreadBits(bs, 1);
+ }
+ return (ErrorStatus);
+}
+
+static INT skipSbrHeader(HANDLE_FDK_BITSTREAM hBs, int isUsac) {
+ /* Dummy parse SbrDfltHeader() */
+ INT dflt_header_extra1, dflt_header_extra2, bitsToSkip = 0;
+
+ if (!isUsac) {
+ bitsToSkip = 6;
+ FDKpushFor(hBs, 6); /* amp res 1, xover freq 3, reserved 2 */
+ }
+ bitsToSkip += 8;
+ FDKpushFor(hBs, 8); /* start / stop freq */
+ bitsToSkip += 2;
+ dflt_header_extra1 = FDKreadBit(hBs);
+ dflt_header_extra2 = FDKreadBit(hBs);
+ bitsToSkip += 5 * dflt_header_extra1 + 6 * dflt_header_extra2;
+ FDKpushFor(hBs, 5 * dflt_header_extra1 + 6 * dflt_header_extra2);
+
+ return bitsToSkip;
+}
+
+static INT ld_sbr_header(CSAudioSpecificConfig *asc, const INT dsFactor,
+ HANDLE_FDK_BITSTREAM hBs, CSTpCallBacks *cb) {
+ const int channelConfiguration = asc->m_channelConfiguration;
+ int i = 0, j = 0;
+ INT error = 0;
+ MP4_ELEMENT_ID element = ID_NONE;
+
+ /* check whether the channelConfiguration is defined in
+ * channel_configuration_array */
+ if (channelConfiguration < 0 ||
+ channelConfiguration > (INT)(sizeof(channel_configuration_array) /
+ sizeof(MP4_ELEMENT_ID **) -
+ 1)) {
+ return TRANSPORTDEC_PARSE_ERROR;
+ }
+
+ /* read elements of the passed channel_configuration until there is ID_NONE */
+ while ((element = channel_configuration_array[channelConfiguration][j]) !=
+ ID_NONE) {
+ /* Setup LFE element for upsampling too. This is essential especially for
+ * channel configs where the LFE element is not at the last position for
+ * example in channel config 13 or 14. It leads to memory leaks if the setup
+ * of the LFE element would be done later in the core. */
+ if (element == ID_SCE || element == ID_CPE || element == ID_LFE) {
+ error |= cb->cbSbr(
+ cb->cbSbrData, hBs, asc->m_samplingFrequency / dsFactor,
+ asc->m_extensionSamplingFrequency / dsFactor,
+ asc->m_samplesPerFrame / dsFactor, AOT_ER_AAC_ELD, element, i++, 0, 0,
+ asc->configMode, &asc->SbrConfigChanged, dsFactor);
+ if (error != TRANSPORTDEC_OK) {
+ goto bail;
+ }
+ }
+ j++;
+ }
+bail:
+ return error;
+}
+
+static TRANSPORTDEC_ERROR EldSpecificConfig_Parse(CSAudioSpecificConfig *asc,
+ HANDLE_FDK_BITSTREAM hBs,
+ CSTpCallBacks *cb) {
+ TRANSPORTDEC_ERROR ErrorStatus = TRANSPORTDEC_OK;
+ CSEldSpecificConfig *esc = &asc->m_sc.m_eldSpecificConfig;
+ ASC_ELD_EXT_TYPE eldExtType;
+ int eldExtLen, len, cnt, ldSbrLen = 0, eldExtLenSum, numSbrHeader = 0,
+ sbrIndex;
+
+ unsigned char downscale_fill_nibble;
+
+ FDKmemclear(esc, sizeof(CSEldSpecificConfig));
+
+ esc->m_frameLengthFlag = FDKreadBits(hBs, 1);
+ if (esc->m_frameLengthFlag) {
+ asc->m_samplesPerFrame = 480;
+ } else {
+ asc->m_samplesPerFrame = 512;
+ }
+
+ asc->m_vcb11Flag = FDKreadBits(hBs, 1);
+ asc->m_rvlcFlag = FDKreadBits(hBs, 1);
+ asc->m_hcrFlag = FDKreadBits(hBs, 1);
+
+ esc->m_sbrPresentFlag = FDKreadBits(hBs, 1);
+
+ if (esc->m_sbrPresentFlag == 1) {
+ esc->m_sbrSamplingRate =
+ FDKreadBits(hBs, 1); /* 0: single rate, 1: dual rate */
+ esc->m_sbrCrcFlag = FDKreadBits(hBs, 1);
+
+ asc->m_extensionSamplingFrequency = asc->m_samplingFrequency
+ << esc->m_sbrSamplingRate;
+
+ if (cb->cbSbr != NULL) {
+ /* ELD reduced delay mode: LD-SBR initialization has to know the downscale
+ information. Postpone LD-SBR initialization and read ELD extension
+ information first. */
+ switch (asc->m_channelConfiguration) {
+ case 1:
+ case 2:
+ numSbrHeader = 1;
+ break;
+ case 3:
+ numSbrHeader = 2;
+ break;
+ case 4:
+ case 5:
+ case 6:
+ numSbrHeader = 3;
+ break;
+ case 7:
+ case 11:
+ case 12:
+ case 14:
+ numSbrHeader = 4;
+ break;
+ default:
+ numSbrHeader = 0;
+ break;
+ }
+ for (sbrIndex = 0; sbrIndex < numSbrHeader; sbrIndex++) {
+ ldSbrLen += skipSbrHeader(hBs, 0);
+ }
+ } else {
+ return TRANSPORTDEC_UNSUPPORTED_FORMAT;
+ }
+ }
+ esc->m_useLdQmfTimeAlign = 0;
+
+ /* new ELD syntax */
+ eldExtLenSum = FDKgetValidBits(hBs);
+ esc->m_downscaledSamplingFrequency = asc->m_samplingFrequency;
+ /* parse ExtTypeConfigData */
+ while (
+ ((eldExtType = (ASC_ELD_EXT_TYPE)FDKreadBits(hBs, 4)) != ELDEXT_TERM) &&
+ ((INT)FDKgetValidBits(hBs) >= 0)) {
+ eldExtLen = len = FDKreadBits(hBs, 4);
+ if (len == 0xf) {
+ len = FDKreadBits(hBs, 8);
+ eldExtLen += len;
+
+ if (len == 0xff) {
+ len = FDKreadBits(hBs, 16);
+ eldExtLen += len;
+ }
+ }
+
+ switch (eldExtType) {
+ case ELDEXT_LDSAC:
+ esc->m_useLdQmfTimeAlign = 1;
+ if (cb->cbSsc != NULL) {
+ ErrorStatus = (TRANSPORTDEC_ERROR)cb->cbSsc(
+ cb->cbSscData, hBs, asc->m_aot,
+ asc->m_samplingFrequency << esc->m_sbrSamplingRate,
+ asc->m_samplesPerFrame << esc->m_sbrSamplingRate,
+ 1, /* stereoConfigIndex */
+ -1, /* nTimeSlots: read from bitstream */
+ eldExtLen, asc->configMode, &asc->SacConfigChanged);
+ if (ErrorStatus != TRANSPORTDEC_OK) {
+ return TRANSPORTDEC_PARSE_ERROR;
+ }
+ if (esc->m_downscaledSamplingFrequency != asc->m_samplingFrequency) {
+ return TRANSPORTDEC_UNSUPPORTED_FORMAT; /* ELDv2 w/ ELD downscaled
+ mode not allowed */
+ }
+ break;
+ }
+
+ FDK_FALLTHROUGH;
+ default:
+ for (cnt = 0; cnt < eldExtLen; cnt++) {
+ FDKreadBits(hBs, 8);
+ }
+ break;
+
+ case ELDEXT_DOWNSCALEINFO:
+ UCHAR tmpDownscaleFreqIdx;
+ esc->m_downscaledSamplingFrequency =
+ getSampleRate(hBs, &tmpDownscaleFreqIdx, 4);
+ if (esc->m_downscaledSamplingFrequency == 0) {
+ return TRANSPORTDEC_PARSE_ERROR;
+ }
+ downscale_fill_nibble = FDKreadBits(hBs, 4);
+ if (downscale_fill_nibble != 0x0) {
+ return TRANSPORTDEC_PARSE_ERROR;
+ }
+ if (esc->m_useLdQmfTimeAlign == 1) {
+ return TRANSPORTDEC_UNSUPPORTED_FORMAT; /* ELDv2 w/ ELD downscaled
+ mode not allowed */
+ }
+ break;
+ }
+ }
+
+ if ((INT)FDKgetValidBits(hBs) < 0) {
+ return TRANSPORTDEC_PARSE_ERROR;
+ }
+
+ if (esc->m_sbrPresentFlag == 1 && numSbrHeader != 0) {
+ INT dsFactor = 1; /* Downscale factor must be 1 or even for SBR */
+ if (esc->m_downscaledSamplingFrequency != 0) {
+ if (asc->m_samplingFrequency % esc->m_downscaledSamplingFrequency != 0) {
+ return TRANSPORTDEC_UNSUPPORTED_FORMAT;
+ }
+ dsFactor = asc->m_samplingFrequency / esc->m_downscaledSamplingFrequency;
+ if (dsFactor != 1 && (dsFactor)&1) {
+ return TRANSPORTDEC_UNSUPPORTED_FORMAT; /* SBR needs an even downscale
+ factor */
+ }
+ if (dsFactor != 1 && dsFactor != 2 && dsFactor != 4) {
+ dsFactor = 1; /* don't apply dsf for not yet supported even dsfs */
+ }
+ if ((INT)asc->m_samplesPerFrame % dsFactor != 0) {
+ return TRANSPORTDEC_UNSUPPORTED_FORMAT; /* frameSize/dsf must be an
+ integer number */
+ }
+ }
+ eldExtLenSum = eldExtLenSum - FDKgetValidBits(hBs);
+ FDKpushBack(hBs, eldExtLenSum + ldSbrLen);
+ if (0 != ld_sbr_header(asc, dsFactor, hBs, cb)) {
+ return TRANSPORTDEC_PARSE_ERROR;
+ }
+ FDKpushFor(hBs, eldExtLenSum);
+ }
+ return (ErrorStatus);
+}
+
+/*
+Subroutine to store config in UCHAR buffer. Bit stream position does not change.
+*/
+static UINT StoreConfigAsBitstream(
+ HANDLE_FDK_BITSTREAM hBs, const INT configSize_bits, /* If < 0 (> 0) config
+ to read is before
+ (after) current bit
+ stream position. */
+ UCHAR *configTargetBuffer, const USHORT configTargetBufferSize_bytes) {
+ FDK_BITSTREAM usacConf;
+ UINT const nBits = fAbs(configSize_bits);
+ UINT j, tmp;
+
+ if (nBits > 8 * (UINT)configTargetBufferSize_bytes) {
+ return 1;
+ }
+ FDKmemclear(configTargetBuffer, configTargetBufferSize_bytes);
+
+ FDKinitBitStream(&usacConf, configTargetBuffer, configTargetBufferSize_bytes,
+ nBits, BS_WRITER);
+ if (configSize_bits < 0) {
+ FDKpushBack(hBs, nBits);
+ }
+ for (j = nBits; j > 31; j -= 32) {
+ tmp = FDKreadBits(hBs, 32);
+ FDKwriteBits(&usacConf, tmp, 32);
+ }
+ if (j > 0) {
+ tmp = FDKreadBits(hBs, j);
+ FDKwriteBits(&usacConf, tmp, j);
+ }
+ FDKsyncCache(&usacConf);
+ if (configSize_bits > 0) {
+ FDKpushBack(hBs, nBits);
+ }
+
+ return 0;
+}
+
+/* maps coreSbrFrameLengthIndex to coreCoderFrameLength */
+static const USHORT usacFrameLength[8] = {768, 1024, 2048, 2048, 4096, 0, 0, 0};
+/* maps coreSbrFrameLengthIndex to sbrRatioIndex */
+static const UCHAR sbrRatioIndex[8] = {0, 0, 2, 3, 1, 0, 0, 0};
+
+/*
+ subroutine for parsing extension element configuration:
+ UsacExtElementConfig() q.v. ISO/IEC FDIS 23003-3:2011(E) Table 14
+ rsv603daExtElementConfig() q.v. ISO/IEC DIS 23008-3 Table 13
+*/
+static TRANSPORTDEC_ERROR extElementConfig(CSUsacExtElementConfig *extElement,
+ HANDLE_FDK_BITSTREAM hBs,
+ const CSTpCallBacks *cb,
+ const UCHAR numSignalsInGroup,
+ const UINT coreFrameLength,
+ const int subStreamIndex,
+ const AUDIO_OBJECT_TYPE aot) {
+ TRANSPORTDEC_ERROR ErrorStatus = TRANSPORTDEC_OK;
+
+ USAC_EXT_ELEMENT_TYPE usacExtElementType =
+ (USAC_EXT_ELEMENT_TYPE)escapedValue(hBs, 4, 8, 16);
+
+ /* recurve extension elements which are invalid for USAC */
+ if (aot == AOT_USAC) {
+ switch (usacExtElementType) {
+ case ID_EXT_ELE_FILL:
+ case ID_EXT_ELE_MPEGS:
+ case ID_EXT_ELE_SAOC:
+ case ID_EXT_ELE_AUDIOPREROLL:
+ case ID_EXT_ELE_UNI_DRC:
+ break;
+ default:
+ usacExtElementType = ID_EXT_ELE_UNKNOWN;
+ break;
+ }
+ }
+
+ extElement->usacExtElementType = usacExtElementType;
+ int usacExtElementConfigLength = escapedValue(hBs, 4, 8, 16);
+ extElement->usacExtElementConfigLength = (USHORT)usacExtElementConfigLength;
+ INT bsAnchor;
+
+ if (FDKreadBit(hBs)) /* usacExtElementDefaultLengthPresent */
+ extElement->usacExtElementDefaultLength = escapedValue(hBs, 8, 16, 0) + 1;
+ else
+ extElement->usacExtElementDefaultLength = 0;
+
+ extElement->usacExtElementPayloadFrag = FDKreadBit(hBs);
+
+ bsAnchor = (INT)FDKgetValidBits(hBs);
+
+ switch (usacExtElementType) {
+ case ID_EXT_ELE_UNKNOWN:
+ case ID_EXT_ELE_FILL:
+ break;
+ case ID_EXT_ELE_AUDIOPREROLL:
+ /* No configuration element */
+ extElement->usacExtElementHasAudioPreRoll = 1;
+ break;
+ case ID_EXT_ELE_UNI_DRC: {
+ if (cb->cbUniDrc != NULL) {
+ ErrorStatus = (TRANSPORTDEC_ERROR)cb->cbUniDrc(
+ cb->cbUniDrcData, hBs, usacExtElementConfigLength,
+ 0, /* uniDrcConfig */
+ subStreamIndex, 0, aot);
+ if (ErrorStatus != TRANSPORTDEC_OK) {
+ return ErrorStatus;
+ }
+ }
+ } break;
+ default:
+ break;
+ }
+
+ /* Adjust bit stream position. This is required because of byte alignment and
+ * unhandled extensions. */
+ {
+ INT left_bits = (usacExtElementConfigLength << 3) -
+ (bsAnchor - (INT)FDKgetValidBits(hBs));
+ if (left_bits >= 0) {
+ FDKpushFor(hBs, left_bits);
+ } else {
+ /* parsed too many bits */
+ ErrorStatus = TRANSPORTDEC_PARSE_ERROR;
+ }
+ }
+
+ return ErrorStatus;
+}
+
+/*
+ subroutine for parsing the USAC / RSVD60 configuration extension:
+ UsacConfigExtension() q.v. ISO/IEC FDIS 23003-3:2011(E) Table 15
+ rsv603daConfigExtension() q.v. ISO/IEC DIS 23008-3 Table 14
+*/
+static TRANSPORTDEC_ERROR configExtension(CSUsacConfig *usc,
+ HANDLE_FDK_BITSTREAM hBs,
+ const CSTpCallBacks *cb) {
+ TRANSPORTDEC_ERROR ErrorStatus = TRANSPORTDEC_OK;
+
+ int numConfigExtensions;
+ CONFIG_EXT_ID usacConfigExtType;
+ int usacConfigExtLength;
+
+ numConfigExtensions = (int)escapedValue(hBs, 2, 4, 8) + 1;
+ for (int confExtIdx = 0; confExtIdx < numConfigExtensions; confExtIdx++) {
+ INT nbits;
+ int loudnessInfoSetConfigExtensionPosition = FDKgetValidBits(hBs);
+ usacConfigExtType = (CONFIG_EXT_ID)escapedValue(hBs, 4, 8, 16);
+ usacConfigExtLength = (int)escapedValue(hBs, 4, 8, 16);
+
+ /* Start bit position of config extension */
+ nbits = (INT)FDKgetValidBits(hBs);
+
+ /* Return an error in case the bitbuffer fill level is too low. */
+ if (nbits < usacConfigExtLength * 8) {
+ return TRANSPORTDEC_PARSE_ERROR;
+ }
+
+ switch (usacConfigExtType) {
+ case ID_CONFIG_EXT_FILL:
+ for (int i = 0; i < usacConfigExtLength; i++) {
+ if (FDKreadBits(hBs, 8) != 0xa5) {
+ return TRANSPORTDEC_PARSE_ERROR;
+ }
+ }
+ break;
+ case ID_CONFIG_EXT_LOUDNESS_INFO: {
+ if (cb->cbUniDrc != NULL) {
+ ErrorStatus = (TRANSPORTDEC_ERROR)cb->cbUniDrc(
+ cb->cbUniDrcData, hBs, usacConfigExtLength,
+ 1, /* loudnessInfoSet */
+ 0, loudnessInfoSetConfigExtensionPosition, AOT_USAC);
+ if (ErrorStatus != TRANSPORTDEC_OK) {
+ return ErrorStatus;
+ }
+ }
+ } break;
+ default:
+ break;
+ }
+
+ /* Skip remaining bits. If too many bits were parsed, assume error. */
+ usacConfigExtLength =
+ 8 * usacConfigExtLength - (nbits - (INT)FDKgetValidBits(hBs));
+ if (usacConfigExtLength < 0) {
+ return TRANSPORTDEC_PARSE_ERROR;
+ }
+ FDKpushFor(hBs, usacConfigExtLength);
+ }
+
+ return ErrorStatus;
+}
+
+/* This function unifies decoder config parsing of USAC and RSV60:
+ rsv603daDecoderConfig() ISO/IEC DIS 23008-3 Table 8
+ UsacDecoderConfig() ISO/IEC FDIS 23003-3 Table 6
+ */
+static TRANSPORTDEC_ERROR UsacRsv60DecoderConfig_Parse(
+ CSAudioSpecificConfig *asc, HANDLE_FDK_BITSTREAM hBs,
+ const CSTpCallBacks *cb) {
+ TRANSPORTDEC_ERROR ErrorStatus = TRANSPORTDEC_OK;
+ CSUsacConfig *usc = &asc->m_sc.m_usacConfig;
+ int i, numberOfElements;
+ int channelElementIdx =
+ 0; /* index for elements which contain audio channels (sce, cpe, lfe) */
+ SC_CHANNEL_CONFIG sc_chan_config = {0, 0, 0, 0};
+
+ numberOfElements = (int)escapedValue(hBs, 4, 8, 16) + 1;
+ usc->m_usacNumElements = numberOfElements;
+ if (numberOfElements > TP_USAC_MAX_ELEMENTS) {
+ return TRANSPORTDEC_UNSUPPORTED_FORMAT;
+ }
+ usc->m_nUsacChannels = 0;
+ usc->m_channelConfigurationIndex = asc->m_channelConfiguration;
+
+ if (asc->m_aot == AOT_USAC) {
+ sc_chan_config = sc_chan_config_tab[usc->m_channelConfigurationIndex];
+
+ if (sc_chan_config.nCh > (SCHAR)TP_USAC_MAX_SPEAKERS) {
+ return TRANSPORTDEC_PARSE_ERROR;
+ }
+ }
+
+ for (i = 0; i < numberOfElements; i++) {
+ MP4_ELEMENT_ID usacElementType = (MP4_ELEMENT_ID)(
+ FDKreadBits(hBs, 2) | USAC_ID_BIT); /* set USAC_ID_BIT to map
+ usacElementType to
+ MP4_ELEMENT_ID enum */
+ usc->element[i].usacElementType = usacElementType;
+
+ /* sanity check: update element counter */
+ if (asc->m_aot == AOT_USAC) {
+ switch (usacElementType) {
+ case ID_USAC_SCE:
+ sc_chan_config.nSCE--;
+ break;
+ case ID_USAC_CPE:
+ sc_chan_config.nCPE--;
+ break;
+ case ID_USAC_LFE:
+ sc_chan_config.nLFE--;
+ break;
+ default:
+ break;
+ }
+ if (usc->m_channelConfigurationIndex) {
+ /* sanity check: no element counter may be smaller zero */
+ if (sc_chan_config.nCPE < 0 || sc_chan_config.nSCE < 0 ||
+ sc_chan_config.nLFE < 0) {
+ return TRANSPORTDEC_PARSE_ERROR;
+ }
+ }
+ }
+
+ switch (usacElementType) {
+ case ID_USAC_SCE:
+ /* UsacCoreConfig() ISO/IEC FDIS 23003-3 Table 10 */
+ if (FDKreadBit(hBs)) { /* tw_mdct */
+ return TRANSPORTDEC_UNSUPPORTED_FORMAT;
+ }
+ usc->element[i].m_noiseFilling = FDKreadBits(hBs, 1);
+ /* end of UsacCoreConfig() */
+ if (usc->m_sbrRatioIndex > 0) {
+ if (cb->cbSbr == NULL) {
+ return TRANSPORTDEC_UNKOWN_ERROR;
+ }
+ /* SbrConfig() ISO/IEC FDIS 23003-3 Table 11 */
+ usc->element[i].m_harmonicSBR = FDKreadBit(hBs);
+ usc->element[i].m_interTes = FDKreadBit(hBs);
+ usc->element[i].m_pvc = FDKreadBit(hBs);
+ if (cb->cbSbr(cb->cbSbrData, hBs, asc->m_samplingFrequency,
+ asc->m_extensionSamplingFrequency,
+ asc->m_samplesPerFrame, asc->m_aot, ID_SCE,
+ channelElementIdx, usc->element[i].m_harmonicSBR,
+ usc->element[i].m_stereoConfigIndex, asc->configMode,
+ &asc->SbrConfigChanged, 1)) {
+ return TRANSPORTDEC_PARSE_ERROR;
+ }
+ /* end of SbrConfig() */
+ }
+ usc->m_nUsacChannels += 1;
+ channelElementIdx++;
+ break;
+
+ case ID_USAC_CPE:
+ /* UsacCoreConfig() ISO/IEC FDIS 23003-3 Table 10 */
+ if (FDKreadBit(hBs)) { /* tw_mdct */
+ return TRANSPORTDEC_UNSUPPORTED_FORMAT;
+ }
+ usc->element[i].m_noiseFilling = FDKreadBits(hBs, 1);
+ /* end of UsacCoreConfig() */
+ if (usc->m_sbrRatioIndex > 0) {
+ if (cb->cbSbr == NULL) return TRANSPORTDEC_UNKOWN_ERROR;
+ /* SbrConfig() ISO/IEC FDIS 23003-3 */
+ usc->element[i].m_harmonicSBR = FDKreadBit(hBs);
+ usc->element[i].m_interTes = FDKreadBit(hBs);
+ usc->element[i].m_pvc = FDKreadBit(hBs);
+ {
+ INT bitsToSkip = skipSbrHeader(hBs, 1);
+ /* read stereoConfigIndex */
+ usc->element[i].m_stereoConfigIndex = FDKreadBits(hBs, 2);
+ /* rewind */
+ FDKpushBack(hBs, bitsToSkip + 2);
+ }
+ {
+ MP4_ELEMENT_ID el_type =
+ (usc->element[i].m_stereoConfigIndex == 1 ||
+ usc->element[i].m_stereoConfigIndex == 2)
+ ? ID_SCE
+ : ID_CPE;
+ if (cb->cbSbr(cb->cbSbrData, hBs, asc->m_samplingFrequency,
+ asc->m_extensionSamplingFrequency,
+ asc->m_samplesPerFrame, asc->m_aot, el_type,
+ channelElementIdx, usc->element[i].m_harmonicSBR,
+ usc->element[i].m_stereoConfigIndex, asc->configMode,
+ &asc->SbrConfigChanged, 1)) {
+ return TRANSPORTDEC_PARSE_ERROR;
+ }
+ }
+ /* end of SbrConfig() */
+
+ usc->element[i].m_stereoConfigIndex =
+ FDKreadBits(hBs, 2); /* Needed in RM5 syntax */
+
+ if (usc->element[i].m_stereoConfigIndex > 0) {
+ if (cb->cbSsc != NULL) {
+ int samplesPerFrame = asc->m_samplesPerFrame;
+
+ if (usc->m_sbrRatioIndex == 1) samplesPerFrame <<= 2;
+ if (usc->m_sbrRatioIndex == 2)
+ samplesPerFrame = (samplesPerFrame * 8) / 3;
+ if (usc->m_sbrRatioIndex == 3) samplesPerFrame <<= 1;
+
+ /* Mps212Config() ISO/IEC FDIS 23003-3 */
+ if (cb->cbSsc(cb->cbSscData, hBs, asc->m_aot,
+ asc->m_extensionSamplingFrequency, samplesPerFrame,
+ usc->element[i].m_stereoConfigIndex,
+ usc->m_coreSbrFrameLengthIndex,
+ 0, /* don't know the length */
+ asc->configMode, &asc->SacConfigChanged)) {
+ return TRANSPORTDEC_PARSE_ERROR;
+ }
+ /* end of Mps212Config() */
+ } else {
+ return TRANSPORTDEC_UNKOWN_ERROR;
+ }
+ }
+ } else {
+ usc->element[i].m_stereoConfigIndex = 0;
+ }
+ usc->m_nUsacChannels += 2;
+
+ channelElementIdx++;
+ break;
+
+ case ID_USAC_LFE:
+ usc->element[i].m_noiseFilling = 0;
+ usc->m_nUsacChannels += 1;
+ if (usc->m_sbrRatioIndex > 0) {
+ /* Use SBR for upsampling */
+ if (cb->cbSbr == NULL) return ErrorStatus = TRANSPORTDEC_UNKOWN_ERROR;
+ usc->element[i].m_harmonicSBR = (UCHAR)0;
+ usc->element[i].m_interTes = (UCHAR)0;
+ usc->element[i].m_pvc = (UCHAR)0;
+ if (cb->cbSbr(cb->cbSbrData, hBs, asc->m_samplingFrequency,
+ asc->m_extensionSamplingFrequency,
+ asc->m_samplesPerFrame, asc->m_aot, ID_LFE,
+ channelElementIdx, usc->element[i].m_harmonicSBR,
+ usc->element[i].m_stereoConfigIndex, asc->configMode,
+ &asc->SbrConfigChanged, 1)) {
+ return ErrorStatus = TRANSPORTDEC_PARSE_ERROR;
+ }
+ }
+ channelElementIdx++;
+ break;
+
+ case ID_USAC_EXT:
+ ErrorStatus = extElementConfig(&usc->element[i].extElement, hBs, cb, 0,
+ asc->m_samplesPerFrame, 0, asc->m_aot);
+
+ if (ErrorStatus) {
+ return ErrorStatus;
+ }
+ break;
+
+ default:
+ /* non USAC-element encountered */
+ return TRANSPORTDEC_PARSE_ERROR;
+ }
+ }
+
+ if (asc->m_aot == AOT_USAC) {
+ if (usc->m_channelConfigurationIndex) {
+ /* sanity check: all element counter must be zero */
+ if (sc_chan_config.nCPE | sc_chan_config.nSCE | sc_chan_config.nLFE) {
+ return TRANSPORTDEC_PARSE_ERROR;
+ }
+ } else {
+ /* sanity check: number of audio channels shall be equal to or smaller
+ * than the accumulated sum of all channels */
+ if ((INT)(-2 * sc_chan_config.nCPE - sc_chan_config.nSCE -
+ sc_chan_config.nLFE) < (INT)usc->numAudioChannels) {
+ return TRANSPORTDEC_PARSE_ERROR;
+ }
+ }
+ }
+
+ return ErrorStatus;
+}
+
+/* Mapping of coreSbrFrameLengthIndex defined by Table 70 in ISO/IEC 23003-3 */
+static TRANSPORTDEC_ERROR UsacConfig_SetCoreSbrFrameLengthIndex(
+ CSAudioSpecificConfig *asc, int coreSbrFrameLengthIndex) {
+ int sbrRatioIndex_val;
+
+ if (coreSbrFrameLengthIndex > 4) {
+ return TRANSPORTDEC_PARSE_ERROR; /* reserved values */
+ }
+ asc->m_sc.m_usacConfig.m_coreSbrFrameLengthIndex = coreSbrFrameLengthIndex;
+ asc->m_samplesPerFrame = usacFrameLength[coreSbrFrameLengthIndex];
+ sbrRatioIndex_val = sbrRatioIndex[coreSbrFrameLengthIndex];
+ asc->m_sc.m_usacConfig.m_sbrRatioIndex = sbrRatioIndex_val;
+
+ if (sbrRatioIndex_val > 0) {
+ asc->m_sbrPresentFlag = 1;
+ asc->m_extensionSamplingFrequency = asc->m_samplingFrequency;
+ asc->m_extensionSamplingFrequencyIndex = asc->m_samplingFrequencyIndex;
+ switch (sbrRatioIndex_val) {
+ case 1: /* sbrRatio = 4:1 */
+ asc->m_samplingFrequency >>= 2;
+ asc->m_samplesPerFrame >>= 2;
+ break;
+ case 2: /* sbrRatio = 8:3 */
+ asc->m_samplingFrequency = (asc->m_samplingFrequency * 3) / 8;
+ asc->m_samplesPerFrame = (asc->m_samplesPerFrame * 3) / 8;
+ break;
+ case 3: /* sbrRatio = 2:1 */
+ asc->m_samplingFrequency >>= 1;
+ asc->m_samplesPerFrame >>= 1;
+ break;
+ default:
+ return TRANSPORTDEC_PARSE_ERROR;
+ }
+ asc->m_samplingFrequencyIndex =
+ getSamplingRateIndex(asc->m_samplingFrequency, 4);
+ }
+
+ return TRANSPORTDEC_OK;
+}
+
+static TRANSPORTDEC_ERROR UsacConfig_Parse(CSAudioSpecificConfig *asc,
+ HANDLE_FDK_BITSTREAM hBs,
+ CSTpCallBacks *cb) {
+ int usacSamplingFrequency, channelConfigurationIndex, coreSbrFrameLengthIndex;
+ TRANSPORTDEC_ERROR err = TRANSPORTDEC_OK;
+
+ /* Start bit position of usacConfig */
+ INT nbits = (INT)FDKgetValidBits(hBs);
+
+ usacSamplingFrequency = getSampleRate(hBs, &asc->m_samplingFrequencyIndex, 5);
+ asc->m_samplingFrequency = (UINT)usacSamplingFrequency;
+
+ coreSbrFrameLengthIndex = FDKreadBits(hBs, 3);
+ if (UsacConfig_SetCoreSbrFrameLengthIndex(asc, coreSbrFrameLengthIndex) !=
+ TRANSPORTDEC_OK) {
+ return TRANSPORTDEC_PARSE_ERROR;
+ }
+
+ channelConfigurationIndex = FDKreadBits(hBs, 5);
+ if (channelConfigurationIndex > 2) {
+ return TRANSPORTDEC_PARSE_ERROR; /* only channelConfigurationIndex = [1,2]
+ are supported */
+ }
+
+ if (channelConfigurationIndex == 0) {
+ return TRANSPORTDEC_PARSE_ERROR; /* only channelConfigurationIndex = [1,2]
+ are supported */
+ }
+ asc->m_channelConfiguration = channelConfigurationIndex;
+
+ err = UsacRsv60DecoderConfig_Parse(asc, hBs, cb);
+ if (err != TRANSPORTDEC_OK) {
+ return err;
+ }
+
+ if (FDKreadBits(hBs, 1)) { /* usacConfigExtensionPresent */
+ err = configExtension(&asc->m_sc.m_usacConfig, hBs, cb);
+ if (err != TRANSPORTDEC_OK) {
+ return err;
+ }
+ }
+
+ /* sanity check whether number of channels signaled in UsacDecoderConfig()
+ matches the number of channels required by channelConfigurationIndex */
+ if ((channelConfigurationIndex > 0) &&
+ (sc_chan_config_tab[channelConfigurationIndex].nCh !=
+ asc->m_sc.m_usacConfig.m_nUsacChannels)) {
+ return TRANSPORTDEC_PARSE_ERROR;
+ }
+
+ /* Copy UsacConfig() to asc->m_sc.m_usacConfig.UsacConfig[] buffer. */
+ INT configSize_bits = (INT)FDKgetValidBits(hBs) - nbits;
+ StoreConfigAsBitstream(hBs, configSize_bits,
+ asc->m_sc.m_usacConfig.UsacConfig,
+ TP_USAC_MAX_CONFIG_LEN);
+ asc->m_sc.m_usacConfig.UsacConfigBits = fAbs(configSize_bits);
+
+ return err;
+}
+
+static TRANSPORTDEC_ERROR AudioSpecificConfig_ExtensionParse(
+ CSAudioSpecificConfig *self, HANDLE_FDK_BITSTREAM bs, CSTpCallBacks *cb) {
+ TP_ASC_EXTENSION_ID lastAscExt, ascExtId = ASCEXT_UNKOWN;
+ INT bitsAvailable = (INT)FDKgetValidBits(bs);
+
+ while (bitsAvailable >= 11) {
+ lastAscExt = ascExtId;
+ ascExtId = (TP_ASC_EXTENSION_ID)FDKreadBits(bs, 11);
+ bitsAvailable -= 11;
+
+ switch (ascExtId) {
+ case ASCEXT_SBR: /* 0x2b7 */
+ if ((self->m_extensionAudioObjectType != AOT_SBR) &&
+ (bitsAvailable >= 5)) {
+ self->m_extensionAudioObjectType = getAOT(bs);
+
+ if ((self->m_extensionAudioObjectType == AOT_SBR) ||
+ (self->m_extensionAudioObjectType ==
+ AOT_ER_BSAC)) { /* Get SBR extension configuration */
+ self->m_sbrPresentFlag = FDKreadBits(bs, 1);
+ if (self->m_aot == AOT_USAC && self->m_sbrPresentFlag > 0 &&
+ self->m_sc.m_usacConfig.m_sbrRatioIndex == 0) {
+ return TRANSPORTDEC_PARSE_ERROR;
+ }
+
+ if (self->m_sbrPresentFlag == 1) {
+ self->m_extensionSamplingFrequency = getSampleRate(
+ bs, &self->m_extensionSamplingFrequencyIndex, 4);
+
+ if ((INT)self->m_extensionSamplingFrequency <= 0) {
+ return TRANSPORTDEC_PARSE_ERROR;
+ }
+ }
+ if (self->m_extensionAudioObjectType == AOT_ER_BSAC) {
+ self->m_extensionChannelConfiguration = FDKreadBits(bs, 4);
+ }
+ }
+ /* Update counter because of variable length fields (AOT and sampling
+ * rate) */
+ bitsAvailable = (INT)FDKgetValidBits(bs);
+ }
+ break;
+ case ASCEXT_PS: /* 0x548 */
+ if ((lastAscExt == ASCEXT_SBR) &&
+ (self->m_extensionAudioObjectType == AOT_SBR) &&
+ (bitsAvailable > 0)) { /* Get PS extension configuration */
+ self->m_psPresentFlag = FDKreadBits(bs, 1);
+ bitsAvailable -= 1;
+ }
+ break;
+ case ASCEXT_MPS: /* 0x76a */
+ if (self->m_extensionAudioObjectType == AOT_MPEGS) break;
+ FDK_FALLTHROUGH;
+ case ASCEXT_LDMPS: /* 0x7cc */
+ if ((ascExtId == ASCEXT_LDMPS) &&
+ (self->m_extensionAudioObjectType == AOT_LD_MPEGS))
+ break;
+ if (bitsAvailable >= 1) {
+ bitsAvailable -= 1;
+ if (FDKreadBits(bs, 1)) { /* self->m_mpsPresentFlag */
+ int sscLen = FDKreadBits(bs, 8);
+ bitsAvailable -= 8;
+ if (sscLen == 0xFF) {
+ sscLen += FDKreadBits(bs, 16);
+ bitsAvailable -= 16;
+ }
+ FDKpushFor(bs, sscLen); /* Skip SSC to be able to read the next
+ extension if there is one. */
+
+ bitsAvailable -= sscLen * 8;
+ }
+ }
+ break;
+ case ASCEXT_SAOC:
+ if ((ascExtId == ASCEXT_SAOC) &&
+ (self->m_extensionAudioObjectType == AOT_SAOC))
+ break;
+ if (FDKreadBits(bs, 1)) { /* saocPresent */
+ int saocscLen = FDKreadBits(bs, 8);
+ bitsAvailable -= 8;
+ if (saocscLen == 0xFF) {
+ saocscLen += FDKreadBits(bs, 16);
+ bitsAvailable -= 16;
+ }
+ FDKpushFor(bs, saocscLen);
+ bitsAvailable -= saocscLen * 8;
+ }
+ break;
+ default:
+ /* Just ignore anything. */
+ return TRANSPORTDEC_OK;
+ }
+ }
+
+ return TRANSPORTDEC_OK;
+}
+
+/*
+ * API Functions
+ */
+
+void AudioSpecificConfig_Init(CSAudioSpecificConfig *asc) {
+ FDKmemclear(asc, sizeof(CSAudioSpecificConfig));
+
+ /* Init all values that should not be zero. */
+ asc->m_aot = AOT_NONE;
+ asc->m_samplingFrequencyIndex = 0xf;
+ asc->m_epConfig = -1;
+ asc->m_extensionAudioObjectType = AOT_NULL_OBJECT;
+ CProgramConfig_Init(&asc->m_progrConfigElement);
+}
+
+TRANSPORTDEC_ERROR AudioSpecificConfig_Parse(
+ CSAudioSpecificConfig *self, HANDLE_FDK_BITSTREAM bs,
+ int fExplicitBackwardCompatible, CSTpCallBacks *cb, UCHAR configMode,
+ UCHAR configChanged, AUDIO_OBJECT_TYPE m_aot) {
+ TRANSPORTDEC_ERROR ErrorStatus = TRANSPORTDEC_OK;
+ UINT ascStartAnchor = FDKgetValidBits(bs);
+ int frameLengthFlag = -1;
+
+ AudioSpecificConfig_Init(self);
+
+ self->configMode = configMode;
+ self->AacConfigChanged = configChanged;
+ self->SbrConfigChanged = configChanged;
+ self->SacConfigChanged = configChanged;
+
+ if (m_aot != AOT_NULL_OBJECT) {
+ self->m_aot = m_aot;
+ } else {
+ self->m_aot = getAOT(bs);
+ self->m_samplingFrequency =
+ getSampleRate(bs, &self->m_samplingFrequencyIndex, 4);
+ if (self->m_samplingFrequency <= 0 ||
+ (self->m_samplingFrequency > 96000 && self->m_aot != 39) ||
+ self->m_samplingFrequency > 4 * 96000) {
+ return TRANSPORTDEC_PARSE_ERROR;
+ }
+
+ self->m_channelConfiguration = FDKreadBits(bs, 4);
+
+ /* SBR extension ( explicit non-backwards compatible mode ) */
+ self->m_sbrPresentFlag = 0;
+ self->m_psPresentFlag = 0;
+
+ if (self->m_aot == AOT_SBR || self->m_aot == AOT_PS) {
+ self->m_extensionAudioObjectType = AOT_SBR;
+
+ self->m_sbrPresentFlag = 1;
+ if (self->m_aot == AOT_PS) {
+ self->m_psPresentFlag = 1;
+ }
+
+ self->m_extensionSamplingFrequency =
+ getSampleRate(bs, &self->m_extensionSamplingFrequencyIndex, 4);
+ self->m_aot = getAOT(bs);
+
+ switch (self->m_aot) {
+ case AOT_AAC_LC:
+ break;
+ case AOT_ER_BSAC:
+ break;
+ default:
+ return TRANSPORTDEC_UNSUPPORTED_FORMAT;
+ }
+
+ if (self->m_aot == AOT_ER_BSAC) {
+ self->m_extensionChannelConfiguration = FDKreadBits(bs, 4);
+ }
+ } else {
+ self->m_extensionAudioObjectType = AOT_NULL_OBJECT;
+ }
+ }
+
+ /* Parse whatever specific configs */
+ switch (self->m_aot) {
+ case AOT_AAC_LC:
+ case AOT_AAC_SCAL:
+ case AOT_ER_AAC_LC:
+ case AOT_ER_AAC_LD:
+ case AOT_ER_AAC_SCAL:
+ case AOT_ER_BSAC:
+ if ((ErrorStatus = GaSpecificConfig_Parse(&self->m_sc.m_gaSpecificConfig,
+ self, bs, ascStartAnchor)) !=
+ TRANSPORTDEC_OK) {
+ return (ErrorStatus);
+ }
+ frameLengthFlag = self->m_sc.m_gaSpecificConfig.m_frameLengthFlag;
+ break;
+ case AOT_MPEGS:
+ if (cb->cbSsc != NULL) {
+ if (cb->cbSsc(cb->cbSscData, bs, self->m_aot, self->m_samplingFrequency,
+ self->m_samplesPerFrame, 1,
+ -1, /* nTimeSlots: read from bitstream */
+ 0, /* don't know the length */
+ self->configMode, &self->SacConfigChanged)) {
+ return TRANSPORTDEC_UNSUPPORTED_FORMAT;
+ }
+ } else {
+ return TRANSPORTDEC_UNSUPPORTED_FORMAT;
+ }
+ break;
+ case AOT_ER_AAC_ELD:
+ if ((ErrorStatus = EldSpecificConfig_Parse(self, bs, cb)) !=
+ TRANSPORTDEC_OK) {
+ return (ErrorStatus);
+ }
+ frameLengthFlag = self->m_sc.m_eldSpecificConfig.m_frameLengthFlag;
+ self->m_sbrPresentFlag = self->m_sc.m_eldSpecificConfig.m_sbrPresentFlag;
+ self->m_extensionSamplingFrequency =
+ (self->m_sc.m_eldSpecificConfig.m_sbrSamplingRate + 1) *
+ self->m_samplingFrequency;
+ break;
+ case AOT_USAC:
+ if ((ErrorStatus = UsacConfig_Parse(self, bs, cb)) != TRANSPORTDEC_OK) {
+ return (ErrorStatus);
+ }
+ break;
+
+ default:
+ return TRANSPORTDEC_UNSUPPORTED_FORMAT;
+ }
+
+ /* Frame length */
+ switch (self->m_aot) {
+ case AOT_AAC_LC:
+ case AOT_AAC_SCAL:
+ case AOT_ER_AAC_LC:
+ case AOT_ER_AAC_SCAL:
+ case AOT_ER_BSAC:
+ /*case AOT_USAC:*/
+ if (!frameLengthFlag)
+ self->m_samplesPerFrame = 1024;
+ else
+ self->m_samplesPerFrame = 960;
+ break;
+ case AOT_ER_AAC_LD:
+ if (!frameLengthFlag)
+ self->m_samplesPerFrame = 512;
+ else
+ self->m_samplesPerFrame = 480;
+ break;
+ default:
+ break;
+ }
+
+ switch (self->m_aot) {
+ case AOT_ER_AAC_LC:
+ case AOT_ER_AAC_LD:
+ case AOT_ER_AAC_ELD:
+ case AOT_ER_AAC_SCAL:
+ case AOT_ER_CELP:
+ case AOT_ER_HVXC:
+ case AOT_ER_BSAC:
+ self->m_epConfig = FDKreadBits(bs, 2);
+
+ if (self->m_epConfig > 1) {
+ return TRANSPORTDEC_UNSUPPORTED_FORMAT; // EPCONFIG;
+ }
+ break;
+ default:
+ break;
+ }
+
+ if (fExplicitBackwardCompatible &&
+ (self->m_aot == AOT_AAC_LC || self->m_aot == AOT_ER_AAC_LD ||
+ self->m_aot == AOT_ER_BSAC)) {
+ ErrorStatus = AudioSpecificConfig_ExtensionParse(self, bs, cb);
+ }
+
+ /* Copy config() to asc->config[] buffer. */
+ if ((ErrorStatus == TRANSPORTDEC_OK) && (self->m_aot == AOT_USAC)) {
+ INT configSize_bits = (INT)FDKgetValidBits(bs) - (INT)ascStartAnchor;
+ StoreConfigAsBitstream(bs, configSize_bits, self->config,
+ TP_USAC_MAX_CONFIG_LEN);
+ self->configBits = fAbs(configSize_bits);
+ }
+
+ return (ErrorStatus);
+}
+
+static TRANSPORTDEC_ERROR Drm_xHEAACDecoderConfig(
+ CSAudioSpecificConfig *asc, HANDLE_FDK_BITSTREAM hBs, int audioMode,
+ CSTpCallBacks *cb /* use cb == NULL to signal config check only mode */
+) {
+ TRANSPORTDEC_ERROR ErrorStatus = TRANSPORTDEC_OK;
+ CSUsacConfig *usc = &asc->m_sc.m_usacConfig;
+ int elemIdx = 0;
+
+ usc->element[elemIdx].m_stereoConfigIndex = 0;
+
+ usc->m_usacNumElements = 1; /* Currently all extension elements are skipped
+ -> only one SCE or CPE. */
+
+ switch (audioMode) {
+ case 0: /* mono: ID_USAC_SCE */
+ usc->element[elemIdx].usacElementType = ID_USAC_SCE;
+ usc->m_nUsacChannels = 1;
+ usc->element[elemIdx].m_noiseFilling = FDKreadBits(hBs, 1);
+ if (usc->m_sbrRatioIndex > 0) {
+ if (cb == NULL) {
+ return ErrorStatus;
+ }
+ if (cb->cbSbr != NULL) {
+ usc->element[elemIdx].m_harmonicSBR = FDKreadBit(hBs);
+ usc->element[elemIdx].m_interTes = FDKreadBit(hBs);
+ usc->element[elemIdx].m_pvc = FDKreadBit(hBs);
+ if (cb->cbSbr(cb->cbSbrData, hBs, asc->m_samplingFrequency,
+ asc->m_extensionSamplingFrequency,
+ asc->m_samplesPerFrame, asc->m_aot, ID_SCE, elemIdx,
+ usc->element[elemIdx].m_harmonicSBR,
+ usc->element[elemIdx].m_stereoConfigIndex,
+ asc->configMode, &asc->SbrConfigChanged, 1)) {
+ return ErrorStatus = TRANSPORTDEC_PARSE_ERROR;
+ }
+ }
+ }
+ break;
+ case 2: /* stereo: ID_USAC_CPE */
+ usc->element[elemIdx].usacElementType = ID_USAC_CPE;
+ usc->m_nUsacChannels = 2;
+ usc->element[elemIdx].m_noiseFilling = FDKreadBits(hBs, 1);
+ if (usc->m_sbrRatioIndex > 0) {
+ usc->element[elemIdx].m_harmonicSBR = FDKreadBit(hBs);
+ usc->element[elemIdx].m_interTes = FDKreadBit(hBs);
+ usc->element[elemIdx].m_pvc = FDKreadBit(hBs);
+ {
+ INT bitsToSkip = skipSbrHeader(hBs, 1);
+ /* read stereoConfigIndex */
+ usc->element[elemIdx].m_stereoConfigIndex = FDKreadBits(hBs, 2);
+ /* rewind */
+ FDKpushBack(hBs, bitsToSkip + 2);
+ }
+ /*
+ The application of the following tools is mutually exclusive per audio
+ stream configuration (see clause 5.3.2, xHE-AAC codec configuration):
+ - MPS212 parametric stereo tool with residual coding
+ (stereoConfigIndex>1); and
+ - QMF based Harmonic Transposer (harmonicSBR==1).
+ */
+ if ((usc->element[elemIdx].m_stereoConfigIndex > 1) &&
+ usc->element[elemIdx].m_harmonicSBR) {
+ return ErrorStatus = TRANSPORTDEC_PARSE_ERROR;
+ }
+ /*
+ The 4:1 sbrRatio (sbrRatioIndex==1 in [11]) may only be employed:
+ - in mono operation; or
+ - in stereo operation if parametric stereo (MPS212) without residual
+ coding is applied, i.e. if stereoConfigIndex==1 (see clause 5.3.2,
+ xHE-AAC codec configuration).
+ */
+ if ((usc->m_sbrRatioIndex == 1) &&
+ (usc->element[elemIdx].m_stereoConfigIndex != 1)) {
+ return ErrorStatus = TRANSPORTDEC_PARSE_ERROR;
+ }
+ if (cb == NULL) {
+ return ErrorStatus;
+ }
+ {
+ MP4_ELEMENT_ID el_type =
+ (usc->element[elemIdx].m_stereoConfigIndex == 1 ||
+ usc->element[elemIdx].m_stereoConfigIndex == 2)
+ ? ID_SCE
+ : ID_CPE;
+ if (cb->cbSbr == NULL) return ErrorStatus = TRANSPORTDEC_UNKOWN_ERROR;
+ if (cb->cbSbr(cb->cbSbrData, hBs, asc->m_samplingFrequency,
+ asc->m_extensionSamplingFrequency,
+ asc->m_samplesPerFrame, asc->m_aot, el_type, elemIdx,
+ usc->element[elemIdx].m_harmonicSBR,
+ usc->element[elemIdx].m_stereoConfigIndex,
+ asc->configMode, &asc->SbrConfigChanged, 1)) {
+ return ErrorStatus = TRANSPORTDEC_PARSE_ERROR;
+ }
+ }
+ /*usc->element[elemIdx].m_stereoConfigIndex =*/FDKreadBits(hBs, 2);
+ if (usc->element[elemIdx].m_stereoConfigIndex > 0) {
+ if (cb->cbSsc != NULL) {
+ int samplesPerFrame = asc->m_samplesPerFrame;
+
+ if (usc->m_sbrRatioIndex == 1) samplesPerFrame <<= 2;
+ if (usc->m_sbrRatioIndex == 2)
+ samplesPerFrame = (samplesPerFrame * 8) / 3;
+ if (usc->m_sbrRatioIndex == 3) samplesPerFrame <<= 1;
+
+ ErrorStatus = (TRANSPORTDEC_ERROR)cb->cbSsc(
+ cb->cbSscData, hBs,
+ AOT_DRM_USAC, /* syntax differs from MPEG Mps212Config() */
+ asc->m_extensionSamplingFrequency, samplesPerFrame,
+ usc->element[elemIdx].m_stereoConfigIndex,
+ usc->m_coreSbrFrameLengthIndex, 0, /* don't know the length */
+ asc->configMode, &asc->SacConfigChanged);
+ } else {
+ /* ErrorStatus = TRANSPORTDEC_UNSUPPORTED_FORMAT; */
+ }
+ }
+ }
+ break;
+ default:
+ return TRANSPORTDEC_PARSE_ERROR;
+ }
+
+ return ErrorStatus;
+}
+
+TRANSPORTDEC_ERROR Drm_xHEAACStaticConfig(
+ CSAudioSpecificConfig *asc, HANDLE_FDK_BITSTREAM bs, int audioMode,
+ CSTpCallBacks *cb /* use cb == NULL to signal config check only mode */
+) {
+ int coreSbrFrameLengthIndexDrm = FDKreadBits(bs, 2);
+ if (UsacConfig_SetCoreSbrFrameLengthIndex(
+ asc, coreSbrFrameLengthIndexDrm + 1) != TRANSPORTDEC_OK) {
+ return TRANSPORTDEC_PARSE_ERROR;
+ }
+
+ asc->m_channelConfiguration = (audioMode) ? 2 : 1;
+
+ if (Drm_xHEAACDecoderConfig(asc, bs, audioMode, cb) != TRANSPORTDEC_OK) {
+ return TRANSPORTDEC_PARSE_ERROR;
+ }
+
+ return TRANSPORTDEC_OK;
+}
+
+/* Mapping of DRM audio sampling rate field to MPEG usacSamplingFrequencyIndex
+ */
+const UCHAR mapSr2MPEGIdx[8] = {
+ 0x1b, /* 9.6 kHz */
+ 0x09, /* 12.0 kHz */
+ 0x08, /* 16.0 kHz */
+ 0x17, /* 19.2 kHz */
+ 0x06, /* 24.0 kHz */
+ 0x05, /* 32.0 kHz */
+ 0x12, /* 38.4 kHz */
+ 0x03 /* 48.0 kHz */
+};
+
+TRANSPORTDEC_ERROR DrmRawSdcAudioConfig_Parse(
+ CSAudioSpecificConfig *self, HANDLE_FDK_BITSTREAM bs,
+ CSTpCallBacks *cb, /* use cb == NULL to signal config check only mode */
+ UCHAR configMode, UCHAR configChanged) {
+ TRANSPORTDEC_ERROR ErrorStatus = TRANSPORTDEC_OK;
+
+ AudioSpecificConfig_Init(self);
+
+ if ((INT)FDKgetValidBits(bs) < 16) {
+ ErrorStatus = TRANSPORTDEC_PARSE_ERROR;
+ goto bail;
+ } else {
+ /* DRM - Audio information data entity - type 9
+ - Short Id 2 bits (not part of the config buffer)
+ - Stream Id 2 bits (not part of the config buffer)
+ - audio coding 2 bits
+ - SBR flag 1 bit
+ - audio mode 2 bits
+ - audio sampling rate 3 bits
+ - text flag 1 bit
+ - enhancement flag 1 bit
+ - coder field 5 bits
+ - rfa 1 bit */
+
+ int audioCoding, audioMode, cSamplingFreq, coderField, sfIdx, sbrFlag;
+
+ self->configMode = configMode;
+ self->AacConfigChanged = configChanged;
+ self->SbrConfigChanged = configChanged;
+ self->SacConfigChanged = configChanged;
+
+ /* Read the SDC field */
+ audioCoding = FDKreadBits(bs, 2);
+ sbrFlag = FDKreadBits(bs, 1);
+ audioMode = FDKreadBits(bs, 2);
+ cSamplingFreq = FDKreadBits(bs, 3); /* audio sampling rate */
+
+ FDKreadBits(bs, 2); /* Text and enhancement flag */
+ coderField = FDKreadBits(bs, 5);
+ FDKreadBits(bs, 1); /* rfa */
+
+ /* Evaluate configuration and fill the ASC */
+ if (audioCoding == 3) {
+ sfIdx = (int)mapSr2MPEGIdx[cSamplingFreq];
+ sbrFlag = 0; /* rfa */
+ } else {
+ switch (cSamplingFreq) {
+ case 0: /* 8 kHz */
+ sfIdx = 11;
+ break;
+ case 1: /* 12 kHz */
+ sfIdx = 9;
+ break;
+ case 2: /* 16 kHz */
+ sfIdx = 8;
+ break;
+ case 3: /* 24 kHz */
+ sfIdx = 6;
+ break;
+ case 5: /* 48 kHz */
+ sfIdx = 3;
+ break;
+ case 4: /* reserved */
+ case 6: /* reserved */
+ case 7: /* reserved */
+ default:
+ ErrorStatus = TRANSPORTDEC_PARSE_ERROR;
+ goto bail;
+ }
+ }
+
+ self->m_samplingFrequencyIndex = sfIdx;
+ self->m_samplingFrequency = SamplingRateTable[sfIdx];
+
+ if (sbrFlag) {
+ UINT i;
+ int tmp = -1;
+ self->m_sbrPresentFlag = 1;
+ self->m_extensionAudioObjectType = AOT_SBR;
+ self->m_extensionSamplingFrequency = self->m_samplingFrequency << 1;
+ for (i = 0;
+ i < (sizeof(SamplingRateTable) / sizeof(SamplingRateTable[0]));
+ i++) {
+ if (SamplingRateTable[i] == self->m_extensionSamplingFrequency) {
+ tmp = i;
+ break;
+ }
+ }
+ self->m_extensionSamplingFrequencyIndex = tmp;
+ }
+
+ switch (audioCoding) {
+ case 0: /* AAC */
+ if ((coderField >> 2) && (audioMode != 1)) {
+ self->m_aot = AOT_DRM_SURROUND; /* Set pseudo AOT for Drm Surround */
+ } else {
+ self->m_aot = AOT_DRM_AAC; /* Set pseudo AOT for Drm AAC */
+ }
+ switch (audioMode) {
+ case 1: /* parametric stereo */
+ self->m_psPresentFlag = 1;
+ FDK_FALLTHROUGH;
+ case 0: /* mono */
+ self->m_channelConfiguration = 1;
+ break;
+ case 2: /* stereo */
+ self->m_channelConfiguration = 2;
+ break;
+ default:
+ ErrorStatus = TRANSPORTDEC_PARSE_ERROR;
+ goto bail;
+ }
+ self->m_vcb11Flag = 1;
+ self->m_hcrFlag = 1;
+ self->m_samplesPerFrame = 960;
+ self->m_epConfig = 1;
+ break;
+ case 1: /* CELP */
+ self->m_aot = AOT_ER_CELP;
+ self->m_channelConfiguration = 1;
+ break;
+ case 2: /* HVXC */
+ self->m_aot = AOT_ER_HVXC;
+ self->m_channelConfiguration = 1;
+ break;
+ case 3: /* xHE-AAC */
+ {
+ /* payload is MPEG conform -> no pseudo DRM AOT needed */
+ self->m_aot = AOT_USAC;
+ }
+ switch (audioMode) {
+ case 0: /* mono */
+ case 2: /* stereo */
+ /* codec specific config 8n bits */
+ ErrorStatus = Drm_xHEAACStaticConfig(self, bs, audioMode, cb);
+ break;
+ default:
+ ErrorStatus = TRANSPORTDEC_PARSE_ERROR;
+ goto bail;
+ }
+ break;
+ default:
+ ErrorStatus = TRANSPORTDEC_PARSE_ERROR;
+ self->m_aot = AOT_NONE;
+ break;
+ }
+
+ if (self->m_psPresentFlag && !self->m_sbrPresentFlag) {
+ ErrorStatus = TRANSPORTDEC_PARSE_ERROR;
+ goto bail;
+ }
+ }
+
+bail:
+ return (ErrorStatus);
+}