/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-10-13 06:42

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	139k	int getDeltaTmin(const int sampleRate) {
109		/* half_ms = round (0.0005 * sampleRate); */
110	139k	int half_ms = (sampleRate + 1000) / 2000;
111	139k	int deltaTmin = 1;
112	139k	if (sampleRate < 1000) {
113	799	return DE_NOT_OK;
114	799	}
115	832k	while (deltaTmin <= half_ms) {
116	693k	deltaTmin = deltaTmin << 1;
117	693k	}
118	138k	return deltaTmin;
119	139k	}
120
121		DRC_COEFFICIENTS_UNI_DRC* selectDrcCoefficients(
122	1.88M	HANDLE_UNI_DRC_CONFIG hUniDrcConfig, const int location) {
123	1.88M	int n;
124	1.88M	int c = -1;
125	3.76M	for (n = 0; n < hUniDrcConfig->drcCoefficientsUniDrcCount; n++) {
126	1.87M	if (hUniDrcConfig->drcCoefficientsUniDrc[n].drcLocation == location) {
127	1.46M	c = n;
128	1.46M	}
129	1.87M	}
130	1.88M	if (c >= 0) {
131	894k	return &(hUniDrcConfig->drcCoefficientsUniDrc[c]);
132	894k	}
133	987k	return NULL; /* possible during bitstream parsing */
134	1.88M	}
135
136		DRC_INSTRUCTIONS_UNI_DRC* selectDrcInstructions(
137	859k	HANDLE_UNI_DRC_CONFIG hUniDrcConfig, const int drcSetId) {
138	859k	int i;
139	1.58M	for (i = 0; i < hUniDrcConfig->drcInstructionsCountInclVirtual; i++) {
140	1.58M	if (hUniDrcConfig->drcInstructionsUniDrc[i].drcSetId == drcSetId) {
141	859k	return &(hUniDrcConfig->drcInstructionsUniDrc[i]);
142	859k	}
143	1.58M	}
144	0	return NULL;
145	859k	}
146
147		DOWNMIX_INSTRUCTIONS* selectDownmixInstructions(
148	7.74k	HANDLE_UNI_DRC_CONFIG hUniDrcConfig, const int downmixId) {
149	7.74k	int i;
150	14.3k	for (i = 0; i < hUniDrcConfig->downmixInstructionsCount; i++) {
151	7.97k	if (hUniDrcConfig->downmixInstructions[i].downmixId == downmixId) {
152	1.32k	return &(hUniDrcConfig->downmixInstructions[i]);
153	1.32k	}
154	7.97k	}
155	6.42k	return NULL;
156	7.74k	}
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	1.12M	{
169	1.12M	int duckingSequence = -1;
170	1.12M	int c, n, g, match, idx;
171	1.12M	FIXP_SGL factor;
172	1.12M	FIXP_SGL uniqueScaling[8];
173
174	10.1M	for (g = 0; g < 8; g++) {
175	9.03M	uniqueIndex[g] = -10;
176	9.03M	uniqueScaling[g] = FIXP_SGL(-1.0f);
177	9.03M	}
178
179	1.12M	g = 0;
180
181	1.12M	if (drcSetEffect & EB_DUCK_OTHER) {
182	62.6k	for (c = 0; c < channelCount; c++) {
183	41.4k	match = 0;
184	41.4k	if (c >= 8) return DE_MEMORY_ERROR;
185	41.4k	idx = gainSetIndex[c];
186	41.4k	factor = duckingModificationForChannel[c].duckingScaling;
187	41.4k	if (idx < 0) {
188	26.9k	for (n = 0; n < g; n++) {
189	16.7k	if (uniqueScaling[n] == factor) {
190	12.8k	match = 1;
191	12.8k	groupForChannel[c] = n;
192	12.8k	break;
193	12.8k	}
194	16.7k	}
195	23.0k	if (match == 0) {
196	10.2k	if (g >= 8) return DE_MEMORY_ERROR;
197	10.2k	uniqueIndex[g] = idx;
198	10.2k	uniqueScaling[g] = factor;
199	10.2k	groupForChannel[c] = g;
200	10.2k	g++;
201	10.2k	}
202	23.0k	} else {
203	18.4k	if ((duckingSequence > 0) && (duckingSequence != idx)) {
204	991	return DE_NOT_OK;
205	991	}
206	17.4k	duckingSequence = idx;
207	17.4k	groupForChannel[c] = -1;
208	17.4k	}
209	41.4k	}
210	21.2k	if (duckingSequence == -1) {
211	7.91k	return DE_NOT_OK;
212	7.91k	}
213	1.10M	} else if (drcSetEffect & EB_DUCK_SELF) {
214	163k	for (c = 0; c < channelCount; c++) {
215	121k	match = 0;
216	121k	if (c >= 8) return DE_MEMORY_ERROR;
217	121k	idx = gainSetIndex[c];
218	121k	factor = duckingModificationForChannel[c].duckingScaling;
219	121k	if (idx >= 0) {
220	121k	for (n = 0; n < g; n++) {
221	77.4k	if ((uniqueIndex[n] == idx) && (uniqueScaling[n] == factor)) {
222	14.7k	match = 1;
223	14.7k	groupForChannel[c] = n;
224	14.7k	break;
225	14.7k	}
226	77.4k	}
227	58.4k	if (match == 0) {
228	43.6k	if (g >= 8) return DE_MEMORY_ERROR;
229	43.6k	uniqueIndex[g] = idx;
230	43.6k	uniqueScaling[g] = factor;
231	43.6k	groupForChannel[c] = g;
232	43.6k	g++;
233	43.6k	}
234	63.1k	} else {
235	63.1k	groupForChannel[c] = -1;
236	63.1k	}
237	121k	}
238	1.06M	} else { /* no ducking */
239	7.28M	for (c = 0; c < channelCount; c++) {
240	6.21M	if (c >= 8) return DE_MEMORY_ERROR;
241	6.21M	idx = gainSetIndex[c];
242	6.21M	match = 0;
243	6.21M	if (idx >= 0) {
244	305k	for (n = 0; n < g; n++) {
245	196k	if (uniqueIndex[n] == idx) {
246	94.3k	match = 1;
247	94.3k	groupForChannel[c] = n;
248	94.3k	break;
249	94.3k	}
250	196k	}
251	203k	if (match == 0) {
252	109k	if (g >= 8) return DE_MEMORY_ERROR;
253	109k	uniqueIndex[g] = idx;
254	109k	groupForChannel[c] = g;
255	109k	g++;
256	109k	}
257	6.01M	} else {
258	6.01M	groupForChannel[c] = -1;
259	6.01M	}
260	6.21M	}
261	1.06M	}
262	1.12M	*nDrcChannelGroups = g;
263
264	1.12M	if (drcSetEffect & (EB_DUCK_OTHER \| EB_DUCK_SELF)) {
265	107k	for (g = 0; g < *nDrcChannelGroups; g++) {
266	51.9k	if (drcSetEffect & EB_DUCK_OTHER) {
267	8.24k	uniqueIndex[g] = duckingSequence;
268	8.24k	}
269	51.9k	duckingModificationForChannelGroup[g].duckingScaling = uniqueScaling[g];
270	51.9k	if (uniqueScaling[g] != FL2FXCONST_SGL(1.0f / (float)(1 << 2))) {
271	23.0k	duckingModificationForChannelGroup[g].duckingScalingPresent = 1;
272	28.9k	} else {
273	28.9k	duckingModificationForChannelGroup[g].duckingScalingPresent = 0;
274	28.9k	}
275	51.9k	}
276	55.4k	}
277
278	1.12M	return DE_OK;
279	1.12M	}
280
281		FIXP_DBL
282	11.6k	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	11.6k	FIXP_DBL lin_m =
287	11.6k	f2Pow(fMult(dB_m, FL2FXCONST_DBL(0.1660964f * (float)(1 << 2))), dB_e - 2,
288	11.6k	pLin_e);
289
290	11.6k	return lin_m;
291	11.6k	}
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	26.4k	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	26.4k	FIXP_DBL lin_m =
319	26.4k	f2Pow(fMult(dB_m, FL2FXCONST_DBL(0.1666667f * (float)(1 << 2))), dB_e - 2,
320	26.4k	pLin_e);
321
322	26.4k	return lin_m;
323	26.4k	}
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	}