/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: 2026-01-13 06:51

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	150k	int getDeltaTmin(const int sampleRate) {
109		/* half_ms = round (0.0005 * sampleRate); */
110	150k	int half_ms = (sampleRate + 1000) / 2000;
111	150k	int deltaTmin = 1;
112	150k	if (sampleRate < 1000) {
113	543	return DE_NOT_OK;
114	543	}
115	891k	while (deltaTmin <= half_ms) {
116	741k	deltaTmin = deltaTmin << 1;
117	741k	}
118	150k	return deltaTmin;
119	150k	}
120
121		DRC_COEFFICIENTS_UNI_DRC* selectDrcCoefficients(
122	1.77M	HANDLE_UNI_DRC_CONFIG hUniDrcConfig, const int location) {
123	1.77M	int n;
124	1.77M	int c = -1;
125	3.50M	for (n = 0; n < hUniDrcConfig->drcCoefficientsUniDrcCount; n++) {
126	1.73M	if (hUniDrcConfig->drcCoefficientsUniDrc[n].drcLocation == location) {
127	1.27M	c = n;
128	1.27M	}
129	1.73M	}
130	1.77M	if (c >= 0) {
131	824k	return &(hUniDrcConfig->drcCoefficientsUniDrc[c]);
132	824k	}
133	948k	return NULL; /* possible during bitstream parsing */
134	1.77M	}
135
136		DRC_INSTRUCTIONS_UNI_DRC* selectDrcInstructions(
137	933k	HANDLE_UNI_DRC_CONFIG hUniDrcConfig, const int drcSetId) {
138	933k	int i;
139	1.74M	for (i = 0; i < hUniDrcConfig->drcInstructionsCountInclVirtual; i++) {
140	1.74M	if (hUniDrcConfig->drcInstructionsUniDrc[i].drcSetId == drcSetId) {
141	933k	return &(hUniDrcConfig->drcInstructionsUniDrc[i]);
142	933k	}
143	1.74M	}
144	0	return NULL;
145	933k	}
146
147		DOWNMIX_INSTRUCTIONS* selectDownmixInstructions(
148	8.13k	HANDLE_UNI_DRC_CONFIG hUniDrcConfig, const int downmixId) {
149	8.13k	int i;
150	20.7k	for (i = 0; i < hUniDrcConfig->downmixInstructionsCount; i++) {
151	14.0k	if (hUniDrcConfig->downmixInstructions[i].downmixId == downmixId) {
152	1.42k	return &(hUniDrcConfig->downmixInstructions[i]);
153	1.42k	}
154	14.0k	}
155	6.70k	return NULL;
156	8.13k	}
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	941k	{
169	941k	int duckingSequence = -1;
170	941k	int c, n, g, match, idx;
171	941k	FIXP_SGL factor;
172	941k	FIXP_SGL uniqueScaling[8];
173
174	8.47M	for (g = 0; g < 8; g++) {
175	7.53M	uniqueIndex[g] = -10;
176	7.53M	uniqueScaling[g] = FIXP_SGL(-1.0f);
177	7.53M	}
178
179	941k	g = 0;
180
181	941k	if (drcSetEffect & EB_DUCK_OTHER) {
182	53.3k	for (c = 0; c < channelCount; c++) {
183	32.2k	match = 0;
184	32.2k	if (c >= 8) return DE_MEMORY_ERROR;
185	32.2k	idx = gainSetIndex[c];
186	32.2k	factor = duckingModificationForChannel[c].duckingScaling;
187	32.2k	if (idx < 0) {
188	19.1k	for (n = 0; n < g; n++) {
189	12.4k	if (uniqueScaling[n] == factor) {
190	8.18k	match = 1;
191	8.18k	groupForChannel[c] = n;
192	8.18k	break;
193	8.18k	}
194	12.4k	}
195	14.8k	if (match == 0) {
196	6.71k	if (g >= 8) return DE_MEMORY_ERROR;
197	6.71k	uniqueIndex[g] = idx;
198	6.71k	uniqueScaling[g] = factor;
199	6.71k	groupForChannel[c] = g;
200	6.71k	g++;
201	6.71k	}
202	17.4k	} else {
203	17.4k	if ((duckingSequence > 0) && (duckingSequence != idx)) {
204	2.23k	return DE_NOT_OK;
205	2.23k	}
206	15.1k	duckingSequence = idx;
207	15.1k	groupForChannel[c] = -1;
208	15.1k	}
209	32.2k	}
210	21.0k	if (duckingSequence == -1) {
211	11.6k	return DE_NOT_OK;
212	11.6k	}
213	918k	} else if (drcSetEffect & EB_DUCK_SELF) {
214	138k	for (c = 0; c < channelCount; c++) {
215	100k	match = 0;
216	100k	if (c >= 8) return DE_MEMORY_ERROR;
217	100k	idx = gainSetIndex[c];
218	100k	factor = duckingModificationForChannel[c].duckingScaling;
219	100k	if (idx >= 0) {
220	121k	for (n = 0; n < g; n++) {
221	77.0k	if ((uniqueIndex[n] == idx) && (uniqueScaling[n] == factor)) {
222	8.28k	match = 1;
223	8.28k	groupForChannel[c] = n;
224	8.28k	break;
225	8.28k	}
226	77.0k	}
227	52.4k	if (match == 0) {
228	44.1k	if (g >= 8) return DE_MEMORY_ERROR;
229	44.1k	uniqueIndex[g] = idx;
230	44.1k	uniqueScaling[g] = factor;
231	44.1k	groupForChannel[c] = g;
232	44.1k	g++;
233	44.1k	}
234	52.4k	} else {
235	47.8k	groupForChannel[c] = -1;
236	47.8k	}
237	100k	}
238	880k	} else { /* no ducking */
239	5.92M	for (c = 0; c < channelCount; c++) {
240	5.04M	if (c >= 8) return DE_MEMORY_ERROR;
241	5.04M	idx = gainSetIndex[c];
242	5.04M	match = 0;
243	5.04M	if (idx >= 0) {
244	288k	for (n = 0; n < g; n++) {
245	190k	if (uniqueIndex[n] == idx) {
246	112k	match = 1;
247	112k	groupForChannel[c] = n;
248	112k	break;
249	112k	}
250	190k	}
251	210k	if (match == 0) {
252	98.6k	if (g >= 8) return DE_MEMORY_ERROR;
253	98.6k	uniqueIndex[g] = idx;
254	98.6k	groupForChannel[c] = g;
255	98.6k	g++;
256	98.6k	}
257	4.83M	} else {
258	4.83M	groupForChannel[c] = -1;
259	4.83M	}
260	5.04M	}
261	880k	}
262	927k	*nDrcChannelGroups = g;
263
264	927k	if (drcSetEffect & (EB_DUCK_OTHER \| EB_DUCK_SELF)) {
265	96.7k	for (g = 0; g < *nDrcChannelGroups; g++) {
266	48.9k	if (drcSetEffect & EB_DUCK_OTHER) {
267	4.80k	uniqueIndex[g] = duckingSequence;
268	4.80k	}
269	48.9k	duckingModificationForChannelGroup[g].duckingScaling = uniqueScaling[g];
270	48.9k	if (uniqueScaling[g] != FL2FXCONST_SGL(1.0f / (float)(1 << 2))) {
271	20.6k	duckingModificationForChannelGroup[g].duckingScalingPresent = 1;
272	28.2k	} else {
273	28.2k	duckingModificationForChannelGroup[g].duckingScalingPresent = 0;
274	28.2k	}
275	48.9k	}
276	47.8k	}
277
278	927k	return DE_OK;
279	941k	}
280
281		FIXP_DBL
282	19.0k	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	19.0k	FIXP_DBL lin_m =
287	19.0k	f2Pow(fMult(dB_m, FL2FXCONST_DBL(0.1660964f * (float)(1 << 2))), dB_e - 2,
288	19.0k	pLin_e);
289
290	19.0k	return lin_m;
291	19.0k	}
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	94.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	94.6k	FIXP_DBL lin_m =
319	94.6k	f2Pow(fMult(dB_m, FL2FXCONST_DBL(0.1666667f * (float)(1 << 2))), dB_e - 2,
320	94.6k	pLin_e);
321
322	94.6k	return lin_m;
323	94.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	}