/src/aac/libDRCdec/src/drcDec_tools.cpp

Source
/* -----------------------------------------------------------------------------
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-D DRC decoder library **************************

   Author(s):

   Description:

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

#include "drcDec_types.h"
#include "drcDec_tools.h"
#include "fixpoint_math.h"
#include "drcDecoder.h"

int getDeltaTmin(const int sampleRate) {
  /* half_ms = round (0.0005 * sampleRate); */
  int half_ms = (sampleRate + 1000) / 2000;
  int deltaTmin = 1;
  if (sampleRate < 1000) {
    return DE_NOT_OK;
  }
  while (deltaTmin <= half_ms) {
    deltaTmin = deltaTmin << 1;
  }
  return deltaTmin;
}

DRC_COEFFICIENTS_UNI_DRC* selectDrcCoefficients(
    HANDLE_UNI_DRC_CONFIG hUniDrcConfig, const int location) {
  int n;
  int c = -1;
  for (n = 0; n < hUniDrcConfig->drcCoefficientsUniDrcCount; n++) {
    if (hUniDrcConfig->drcCoefficientsUniDrc[n].drcLocation == location) {
      c = n;
    }
  }
  if (c >= 0) {
    return &(hUniDrcConfig->drcCoefficientsUniDrc[c]);
  }
  return NULL; /* possible during bitstream parsing */
}

DRC_INSTRUCTIONS_UNI_DRC* selectDrcInstructions(
    HANDLE_UNI_DRC_CONFIG hUniDrcConfig, const int drcSetId) {
  int i;
  for (i = 0; i < hUniDrcConfig->drcInstructionsCountInclVirtual; i++) {
    if (hUniDrcConfig->drcInstructionsUniDrc[i].drcSetId == drcSetId) {
      return &(hUniDrcConfig->drcInstructionsUniDrc[i]);
    }
  }
  return NULL;
}

DOWNMIX_INSTRUCTIONS* selectDownmixInstructions(
    HANDLE_UNI_DRC_CONFIG hUniDrcConfig, const int downmixId) {
  int i;
  for (i = 0; i < hUniDrcConfig->downmixInstructionsCount; i++) {
    if (hUniDrcConfig->downmixInstructions[i].downmixId == downmixId) {
      return &(hUniDrcConfig->downmixInstructions[i]);
    }
  }
  return NULL;
}

DRC_ERROR
deriveDrcChannelGroups(
    const int drcSetEffect,                                    /* in */
    const int channelCount,                                    /* in */
    const SCHAR* gainSetIndex,                                 /* in */
    const DUCKING_MODIFICATION* duckingModificationForChannel, /* in */
    UCHAR* nDrcChannelGroups,                                  /* out */
    SCHAR* uniqueIndex,     /* out (gainSetIndexForChannelGroup) */
    SCHAR* groupForChannel, /* out */
    DUCKING_MODIFICATION* duckingModificationForChannelGroup) /* out */
{
  int duckingSequence = -1;
  int c, n, g, match, idx;
  FIXP_SGL factor;
  FIXP_SGL uniqueScaling[8];

  for (g = 0; g < 8; g++) {
    uniqueIndex[g] = -10;
    uniqueScaling[g] = FIXP_SGL(-1.0f);
  }

  g = 0;

  if (drcSetEffect & EB_DUCK_OTHER) {
    for (c = 0; c < channelCount; c++) {
      match = 0;
      if (c >= 8) return DE_MEMORY_ERROR;
      idx = gainSetIndex[c];
      factor = duckingModificationForChannel[c].duckingScaling;
      if (idx < 0) {
        for (n = 0; n < g; n++) {
          if (uniqueScaling[n] == factor) {
            match = 1;
            groupForChannel[c] = n;
            break;
          }
        }
        if (match == 0) {
          if (g >= 8) return DE_MEMORY_ERROR;
          uniqueIndex[g] = idx;
          uniqueScaling[g] = factor;
          groupForChannel[c] = g;
          g++;
        }
      } else {
        if ((duckingSequence > 0) && (duckingSequence != idx)) {
          return DE_NOT_OK;
        }
        duckingSequence = idx;
        groupForChannel[c] = -1;
      }
    }
    if (duckingSequence == -1) {
      return DE_NOT_OK;
    }
  } else if (drcSetEffect & EB_DUCK_SELF) {
    for (c = 0; c < channelCount; c++) {
      match = 0;
      if (c >= 8) return DE_MEMORY_ERROR;
      idx = gainSetIndex[c];
      factor = duckingModificationForChannel[c].duckingScaling;
      if (idx >= 0) {
        for (n = 0; n < g; n++) {
          if ((uniqueIndex[n] == idx) && (uniqueScaling[n] == factor)) {
            match = 1;
            groupForChannel[c] = n;
            break;
          }
        }
        if (match == 0) {
          if (g >= 8) return DE_MEMORY_ERROR;
          uniqueIndex[g] = idx;
          uniqueScaling[g] = factor;
          groupForChannel[c] = g;
          g++;
        }
      } else {
        groupForChannel[c] = -1;
      }
    }
  } else { /* no ducking */
    for (c = 0; c < channelCount; c++) {
      if (c >= 8) return DE_MEMORY_ERROR;
      idx = gainSetIndex[c];
      match = 0;
      if (idx >= 0) {
        for (n = 0; n < g; n++) {
          if (uniqueIndex[n] == idx) {
            match = 1;
            groupForChannel[c] = n;
            break;
          }
        }
        if (match == 0) {
          if (g >= 8) return DE_MEMORY_ERROR;
          uniqueIndex[g] = idx;
          groupForChannel[c] = g;
          g++;
        }
      } else {
        groupForChannel[c] = -1;
      }
    }
  }
  *nDrcChannelGroups = g;

  if (drcSetEffect & (EB_DUCK_OTHER | EB_DUCK_SELF)) {
    for (g = 0; g < *nDrcChannelGroups; g++) {
      if (drcSetEffect & EB_DUCK_OTHER) {
        uniqueIndex[g] = duckingSequence;
      }
      duckingModificationForChannelGroup[g].duckingScaling = uniqueScaling[g];
      if (uniqueScaling[g] != FL2FXCONST_SGL(1.0f / (float)(1 << 2))) {
        duckingModificationForChannelGroup[g].duckingScalingPresent = 1;
      } else {
        duckingModificationForChannelGroup[g].duckingScalingPresent = 0;
      }
    }
  }

  return DE_OK;
}

FIXP_DBL
dB2lin(const FIXP_DBL dB_m, const int dB_e, int* pLin_e) {
  /* get linear value from dB.
     return lin_val = 10^(dB_val/20) = 2^(log2(10)/20*dB_val)
     with dB_val = dB_m *2^dB_e and lin_val = lin_m * 2^lin_e */
  FIXP_DBL lin_m =
      f2Pow(fMult(dB_m, FL2FXCONST_DBL(0.1660964f * (float)(1 << 2))), dB_e - 2,
            pLin_e);

  return lin_m;
}

FIXP_DBL
lin2dB(const FIXP_DBL lin_m, const int lin_e, int* pDb_e) {
  /* get dB value from linear value.
     return dB_val = 20*log10(lin_val)
     with dB_val = dB_m *2^dB_e and lin_val = lin_m * 2^lin_e */
  FIXP_DBL dB_m;

  if (lin_m == (FIXP_DBL)0) { /* return very small value representing -inf */
    dB_m = (FIXP_DBL)MINVAL_DBL;
    *pDb_e = DFRACT_BITS - 1;
  } else {
    /* 20*log10(lin_val) = 20/log2(10)*log2(lin_val) */
    dB_m = fMultDiv2(FL2FXCONST_DBL(6.02059991f / (float)(1 << 3)),
                     fLog2(lin_m, lin_e, pDb_e));
    *pDb_e += 3 + 1;
  }

  return dB_m;
}

FIXP_DBL
approxDb2lin(const FIXP_DBL dB_m, const int dB_e, int* pLin_e) {
  /* get linear value from approximate dB.
     return lin_val = 2^(dB_val/6)
     with dB_val = dB_m *2^dB_e and lin_val = lin_m * 2^lin_e */
  FIXP_DBL lin_m =
      f2Pow(fMult(dB_m, FL2FXCONST_DBL(0.1666667f * (float)(1 << 2))), dB_e - 2,
            pLin_e);

  return lin_m;
}

int bitstreamContainsMultibandDrc(HANDLE_UNI_DRC_CONFIG hUniDrcConfig,
                                  const int downmixId) {
  int i, g, d, seq;
  DRC_INSTRUCTIONS_UNI_DRC* pInst;
  DRC_COEFFICIENTS_UNI_DRC* pCoef = NULL;
  int isMultiband = 0;

  pCoef = selectDrcCoefficients(hUniDrcConfig, LOCATION_SELECTED);
  if (pCoef == NULL) return 0;

  for (i = 0; i < hUniDrcConfig->drcInstructionsUniDrcCount; i++) {
    pInst = &(hUniDrcConfig->drcInstructionsUniDrc[i]);
    for (d = 0; d < pInst->downmixIdCount; d++) {
      if (downmixId == pInst->downmixId[d]) {
        for (g = 0; g < pInst->nDrcChannelGroups; g++) {
          seq = pInst->gainSetIndexForChannelGroup[g];
          if (pCoef->gainSet[seq].bandCount > 1) {
            isMultiband = 1;
          }
        }
      }
    }
  }

  return isMultiband;
}

FIXP_DBL getDownmixOffset(DOWNMIX_INSTRUCTIONS* pDown, int baseChannelCount) {
  FIXP_DBL downmixOffset = FL2FXCONST_DBL(1.0f / (1 << 1)); /* e = 1 */
  if ((pDown->bsDownmixOffset == 1) || (pDown->bsDownmixOffset == 2)) {
    int e_a, e_downmixOffset;
    FIXP_DBL a, q;
    if (baseChannelCount <= pDown->targetChannelCount) return downmixOffset;

    q = fDivNorm((FIXP_DBL)pDown->targetChannelCount,
                 (FIXP_DBL)baseChannelCount); /* e = 0 */
    a = lin2dB(q, 0, &e_a);
    if (pDown->bsDownmixOffset == 2) {
      e_a += 1; /* a *= 2 */
    }
    /* a = 0.5 * round (a) */
    a = fixp_round(a, e_a) >> 1;
    downmixOffset = dB2lin(a, e_a, &e_downmixOffset);
    downmixOffset = scaleValue(downmixOffset, e_downmixOffset - 1);
  }
  return downmixOffset;
}

Coverage Report

Created: 2025-12-31 06:47

Line	Count	Source
1		/* -----------------------------------------------------------------------------
2		Software License for The Fraunhofer FDK AAC Codec Library for Android
3
4		© Copyright 1995 - 2018 Fraunhofer-Gesellschaft zur Förderung der angewandten
5		Forschung e.V. All rights reserved.
6
7		1. INTRODUCTION
8		The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software
9		that implements the MPEG Advanced Audio Coding ("AAC") encoding and decoding
10		scheme for digital audio. This FDK AAC Codec software is intended to be used on
11		a wide variety of Android devices.
12
13		AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient
14		general perceptual audio codecs. AAC-ELD is considered the best-performing
15		full-bandwidth communications codec by independent studies and is widely
16		deployed. AAC has been standardized by ISO and IEC as part of the MPEG
17		specifications.
18
19		Patent licenses for necessary patent claims for the FDK AAC Codec (including
20		those of Fraunhofer) may be obtained through Via Licensing
21		(www.vialicensing.com) or through the respective patent owners individually for
22		the purpose of encoding or decoding bit streams in products that are compliant
23		with the ISO/IEC MPEG audio standards. Please note that most manufacturers of
24		Android devices already license these patent claims through Via Licensing or
25		directly from the patent owners, and therefore FDK AAC Codec software may
26		already be covered under those patent licenses when it is used for those
27		licensed purposes only.
28
29		Commercially-licensed AAC software libraries, including floating-point versions
30		with enhanced sound quality, are also available from Fraunhofer. Users are
31		encouraged to check the Fraunhofer website for additional applications
32		information and documentation.
33
34		2. COPYRIGHT LICENSE
35
36		Redistribution and use in source and binary forms, with or without modification,
37		are permitted without payment of copyright license fees provided that you
38		satisfy the following conditions:
39
40		You must retain the complete text of this software license in redistributions of
41		the FDK AAC Codec or your modifications thereto in source code form.
42
43		You must retain the complete text of this software license in the documentation
44		and/or other materials provided with redistributions of the FDK AAC Codec or
45		your modifications thereto in binary form. You must make available free of
46		charge copies of the complete source code of the FDK AAC Codec and your
47		modifications thereto to recipients of copies in binary form.
48
49		The name of Fraunhofer may not be used to endorse or promote products derived
50		from this library without prior written permission.
51
52		You may not charge copyright license fees for anyone to use, copy or distribute
53		the FDK AAC Codec software or your modifications thereto.
54
55		Your modified versions of the FDK AAC Codec must carry prominent notices stating
56		that you changed the software and the date of any change. For modified versions
57		of the FDK AAC Codec, the term "Fraunhofer FDK AAC Codec Library for Android"
58		must be replaced by the term "Third-Party Modified Version of the Fraunhofer FDK
59		AAC Codec Library for Android."
60
61		3. NO PATENT LICENSE
62
63		NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without
64		limitation the patents of Fraunhofer, ARE GRANTED BY THIS SOFTWARE LICENSE.
65		Fraunhofer provides no warranty of patent non-infringement with respect to this
66		software.
67
68		You may use this FDK AAC Codec software or modifications thereto only for
69		purposes that are authorized by appropriate patent licenses.
70
71		4. DISCLAIMER
72
73		This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright
74		holders and contributors "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES,
75		including but not limited to the implied warranties of merchantability and
76		fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
77		CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary,
78		or consequential damages, including but not limited to procurement of substitute
79		goods or services; loss of use, data, or profits, or business interruption,
80		however caused and on any theory of liability, whether in contract, strict
81		liability, or tort (including negligence), arising in any way out of the use of
82		this software, even if advised of the possibility of such damage.
83
84		5. CONTACT INFORMATION
85
86		Fraunhofer Institute for Integrated Circuits IIS
87		Attention: Audio and Multimedia Departments - FDK AAC LL
88		Am Wolfsmantel 33
89		91058 Erlangen, Germany
90
91		www.iis.fraunhofer.de/amm
92		amm-info@iis.fraunhofer.de
93		----------------------------------------------------------------------------- */
94
95		/*********************** MPEG-D DRC decoder library ************************
96
97		Author(s):
98
99		Description:
100
101		*******************************************************************************/
102
103		#include "drcDec_types.h"
104		#include "drcDec_tools.h"
105		#include "fixpoint_math.h"
106		#include "drcDecoder.h"
107
108	172k	int getDeltaTmin(const int sampleRate) {
109		/* half_ms = round (0.0005 * sampleRate); */
110	172k	int half_ms = (sampleRate + 1000) / 2000;
111	172k	int deltaTmin = 1;
112	172k	if (sampleRate < 1000) {
113	703	return DE_NOT_OK;
114	703	}
115	993k	while (deltaTmin <= half_ms) {
116	821k	deltaTmin = deltaTmin << 1;
117	821k	}
118	171k	return deltaTmin;
119	172k	}
120
121		DRC_COEFFICIENTS_UNI_DRC* selectDrcCoefficients(
122	1.76M	HANDLE_UNI_DRC_CONFIG hUniDrcConfig, const int location) {
123	1.76M	int n;
124	1.76M	int c = -1;
125	3.39M	for (n = 0; n < hUniDrcConfig->drcCoefficientsUniDrcCount; n++) {
126	1.63M	if (hUniDrcConfig->drcCoefficientsUniDrc[n].drcLocation == location) {
127	1.26M	c = n;
128	1.26M	}
129	1.63M	}
130	1.76M	if (c >= 0) {
131	791k	return &(hUniDrcConfig->drcCoefficientsUniDrc[c]);
132	791k	}
133	972k	return NULL; /* possible during bitstream parsing */
134	1.76M	}
135
136		DRC_INSTRUCTIONS_UNI_DRC* selectDrcInstructions(
137	882k	HANDLE_UNI_DRC_CONFIG hUniDrcConfig, const int drcSetId) {
138	882k	int i;
139	1.60M	for (i = 0; i < hUniDrcConfig->drcInstructionsCountInclVirtual; i++) {
140	1.60M	if (hUniDrcConfig->drcInstructionsUniDrc[i].drcSetId == drcSetId) {
141	882k	return &(hUniDrcConfig->drcInstructionsUniDrc[i]);
142	882k	}
143	1.60M	}
144	0	return NULL;
145	882k	}
146
147		DOWNMIX_INSTRUCTIONS* selectDownmixInstructions(
148	7.82k	HANDLE_UNI_DRC_CONFIG hUniDrcConfig, const int downmixId) {
149	7.82k	int i;
150	21.3k	for (i = 0; i < hUniDrcConfig->downmixInstructionsCount; i++) {
151	14.9k	if (hUniDrcConfig->downmixInstructions[i].downmixId == downmixId) {
152	1.34k	return &(hUniDrcConfig->downmixInstructions[i]);
153	1.34k	}
154	14.9k	}
155	6.48k	return NULL;
156	7.82k	}
157
158		DRC_ERROR
159		deriveDrcChannelGroups(
160		const int drcSetEffect, /* in */
161		const int channelCount, /* in */
162		const SCHAR* gainSetIndex, /* in */
163		const DUCKING_MODIFICATION* duckingModificationForChannel, /* in */
164		UCHAR* nDrcChannelGroups, /* out */
165		SCHAR* uniqueIndex, /* out (gainSetIndexForChannelGroup) */
166		SCHAR* groupForChannel, /* out */
167		DUCKING_MODIFICATION* duckingModificationForChannelGroup) /* out */
168	987k	{
169	987k	int duckingSequence = -1;
170	987k	int c, n, g, match, idx;
171	987k	FIXP_SGL factor;
172	987k	FIXP_SGL uniqueScaling[8];
173
174	8.89M	for (g = 0; g < 8; g++) {
175	7.90M	uniqueIndex[g] = -10;
176	7.90M	uniqueScaling[g] = FIXP_SGL(-1.0f);
177	7.90M	}
178
179	987k	g = 0;
180
181	987k	if (drcSetEffect & EB_DUCK_OTHER) {
182	40.5k	for (c = 0; c < channelCount; c++) {
183	23.8k	match = 0;
184	23.8k	if (c >= 8) return DE_MEMORY_ERROR;
185	23.8k	idx = gainSetIndex[c];
186	23.8k	factor = duckingModificationForChannel[c].duckingScaling;
187	23.8k	if (idx < 0) {
188	16.4k	for (n = 0; n < g; n++) {
189	12.5k	if (uniqueScaling[n] == factor) {
190	8.34k	match = 1;
191	8.34k	groupForChannel[c] = n;
192	8.34k	break;
193	8.34k	}
194	12.5k	}
195	12.2k	if (match == 0) {
196	3.89k	if (g >= 8) return DE_MEMORY_ERROR;
197	3.89k	uniqueIndex[g] = idx;
198	3.89k	uniqueScaling[g] = factor;
199	3.89k	groupForChannel[c] = g;
200	3.89k	g++;
201	3.89k	}
202	12.2k	} else {
203	11.6k	if ((duckingSequence > 0) && (duckingSequence != idx)) {
204	926	return DE_NOT_OK;
205	926	}
206	10.7k	duckingSequence = idx;
207	10.7k	groupForChannel[c] = -1;
208	10.7k	}
209	23.8k	}
210	16.6k	if (duckingSequence == -1) {
211	9.70k	return DE_NOT_OK;
212	9.70k	}
213	970k	} else if (drcSetEffect & EB_DUCK_SELF) {
214	75.0k	for (c = 0; c < channelCount; c++) {
215	54.2k	match = 0;
216	54.2k	if (c >= 8) return DE_MEMORY_ERROR;
217	54.2k	idx = gainSetIndex[c];
218	54.2k	factor = duckingModificationForChannel[c].duckingScaling;
219	54.2k	if (idx >= 0) {
220	83.5k	for (n = 0; n < g; n++) {
221	55.6k	if ((uniqueIndex[n] == idx) && (uniqueScaling[n] == factor)) {
222	5.49k	match = 1;
223	5.49k	groupForChannel[c] = n;
224	5.49k	break;
225	5.49k	}
226	55.6k	}
227	33.3k	if (match == 0) {
228	27.8k	if (g >= 8) return DE_MEMORY_ERROR;
229	27.8k	uniqueIndex[g] = idx;
230	27.8k	uniqueScaling[g] = factor;
231	27.8k	groupForChannel[c] = g;
232	27.8k	g++;
233	27.8k	}
234	33.3k	} else {
235	20.9k	groupForChannel[c] = -1;
236	20.9k	}
237	54.2k	}
238	949k	} else { /* no ducking */
239	6.03M	for (c = 0; c < channelCount; c++) {
240	5.08M	if (c >= 8) return DE_MEMORY_ERROR;
241	5.08M	idx = gainSetIndex[c];
242	5.08M	match = 0;
243	5.08M	if (idx >= 0) {
244	204k	for (n = 0; n < g; n++) {
245	139k	if (uniqueIndex[n] == idx) {
246	64.6k	match = 1;
247	64.6k	groupForChannel[c] = n;
248	64.6k	break;
249	64.6k	}
250	139k	}
251	129k	if (match == 0) {
252	64.8k	if (g >= 8) return DE_MEMORY_ERROR;
253	64.8k	uniqueIndex[g] = idx;
254	64.8k	groupForChannel[c] = g;
255	64.8k	g++;
256	64.8k	}
257	4.95M	} else {
258	4.95M	groupForChannel[c] = -1;
259	4.95M	}
260	5.08M	}
261	949k	}
262	977k	*nDrcChannelGroups = g;
263
264	977k	if (drcSetEffect & (EB_DUCK_OTHER \| EB_DUCK_SELF)) {
265	57.8k	for (g = 0; g < *nDrcChannelGroups; g++) {
266	30.0k	if (drcSetEffect & EB_DUCK_OTHER) {
267	2.23k	uniqueIndex[g] = duckingSequence;
268	2.23k	}
269	30.0k	duckingModificationForChannelGroup[g].duckingScaling = uniqueScaling[g];
270	30.0k	if (uniqueScaling[g] != FL2FXCONST_SGL(1.0f / (float)(1 << 2))) {
271	13.3k	duckingModificationForChannelGroup[g].duckingScalingPresent = 1;
272	16.6k	} else {
273	16.6k	duckingModificationForChannelGroup[g].duckingScalingPresent = 0;
274	16.6k	}
275	30.0k	}
276	27.7k	}
277
278	977k	return DE_OK;
279	987k	}
280
281		FIXP_DBL
282	21.2k	dB2lin(const FIXP_DBL dB_m, const int dB_e, int* pLin_e) {
283		/* get linear value from dB.
284		return lin_val = 10^(dB_val/20) = 2^(log2(10)/20*dB_val)
285		with dB_val = dB_m 2^dB_e and lin_val = lin_m 2^lin_e */
286	21.2k	FIXP_DBL lin_m =
287	21.2k	f2Pow(fMult(dB_m, FL2FXCONST_DBL(0.1660964f * (float)(1 << 2))), dB_e - 2,
288	21.2k	pLin_e);
289
290	21.2k	return lin_m;
291	21.2k	}
292
293		FIXP_DBL
294	0	lin2dB(const FIXP_DBL lin_m, const int lin_e, int* pDb_e) {
295		/* get dB value from linear value.
296		return dB_val = 20*log10(lin_val)
297		with dB_val = dB_m 2^dB_e and lin_val = lin_m 2^lin_e */
298	0	FIXP_DBL dB_m;
299
300	0	if (lin_m == (FIXP_DBL)0) { /* return very small value representing -inf */
301	0	dB_m = (FIXP_DBL)MINVAL_DBL;
302	0	*pDb_e = DFRACT_BITS - 1;
303	0	} else {
304		/* 20log10(lin_val) = 20/log2(10)log2(lin_val) */
305	0	dB_m = fMultDiv2(FL2FXCONST_DBL(6.02059991f / (float)(1 << 3)),
306	0	fLog2(lin_m, lin_e, pDb_e));
307	0	*pDb_e += 3 + 1;
308	0	}
309
310	0	return dB_m;
311	0	}
312
313		FIXP_DBL
314	89.6k	approxDb2lin(const FIXP_DBL dB_m, const int dB_e, int* pLin_e) {
315		/* get linear value from approximate dB.
316		return lin_val = 2^(dB_val/6)
317		with dB_val = dB_m 2^dB_e and lin_val = lin_m 2^lin_e */
318	89.6k	FIXP_DBL lin_m =
319	89.6k	f2Pow(fMult(dB_m, FL2FXCONST_DBL(0.1666667f * (float)(1 << 2))), dB_e - 2,
320	89.6k	pLin_e);
321
322	89.6k	return lin_m;
323	89.6k	}
324
325		int bitstreamContainsMultibandDrc(HANDLE_UNI_DRC_CONFIG hUniDrcConfig,
326	0	const int downmixId) {
327	0	int i, g, d, seq;
328	0	DRC_INSTRUCTIONS_UNI_DRC* pInst;
329	0	DRC_COEFFICIENTS_UNI_DRC* pCoef = NULL;
330	0	int isMultiband = 0;
331
332	0	pCoef = selectDrcCoefficients(hUniDrcConfig, LOCATION_SELECTED);
333	0	if (pCoef == NULL) return 0;
334
335	0	for (i = 0; i < hUniDrcConfig->drcInstructionsUniDrcCount; i++) {
336	0	pInst = &(hUniDrcConfig->drcInstructionsUniDrc[i]);
337	0	for (d = 0; d < pInst->downmixIdCount; d++) {
338	0	if (downmixId == pInst->downmixId[d]) {
339	0	for (g = 0; g < pInst->nDrcChannelGroups; g++) {
340	0	seq = pInst->gainSetIndexForChannelGroup[g];
341	0	if (pCoef->gainSet[seq].bandCount > 1) {
342	0	isMultiband = 1;
343	0	}
344	0	}
345	0	}
346	0	}
347	0	}
348
349	0	return isMultiband;
350	0	}
351
352	0	FIXP_DBL getDownmixOffset(DOWNMIX_INSTRUCTIONS* pDown, int baseChannelCount) {
353	0	FIXP_DBL downmixOffset = FL2FXCONST_DBL(1.0f / (1 << 1)); /* e = 1 */
354	0	if ((pDown->bsDownmixOffset == 1) \|\| (pDown->bsDownmixOffset == 2)) {
355	0	int e_a, e_downmixOffset;
356	0	FIXP_DBL a, q;
357	0	if (baseChannelCount <= pDown->targetChannelCount) return downmixOffset;
358
359	0	q = fDivNorm((FIXP_DBL)pDown->targetChannelCount,
360	0	(FIXP_DBL)baseChannelCount); /* e = 0 */
361	0	a = lin2dB(q, 0, &e_a);
362	0	if (pDown->bsDownmixOffset == 2) {
363	0	e_a += 1; /* a = 2 /
364	0	}
365		/* a = 0.5 * round (a) */
366	0	a = fixp_round(a, e_a) >> 1;
367	0	downmixOffset = dB2lin(a, e_a, &e_downmixOffset);
368	0	downmixOffset = scaleValue(downmixOffset, e_downmixOffset - 1);
369	0	}
370	0	return downmixOffset;
371	0	}