/src/fdk-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-04-01 07: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	264k	int getDeltaTmin(const int sampleRate) {
109		/* half_ms = round (0.0005 * sampleRate); */
110	264k	int half_ms = (sampleRate + 1000) / 2000;
111	264k	int deltaTmin = 1;
112	264k	if (sampleRate < 1000) {
113	5	return DE_NOT_OK;
114	5	}
115	1.49M	while (deltaTmin <= half_ms) {
116	1.23M	deltaTmin = deltaTmin << 1;
117	1.23M	}
118	264k	return deltaTmin;
119	264k	}
120
121		DRC_COEFFICIENTS_UNI_DRC* selectDrcCoefficients(
122	292k	HANDLE_UNI_DRC_CONFIG hUniDrcConfig, const int location) {
123	292k	int n;
124	292k	int c = -1;
125	356k	for (n = 0; n < hUniDrcConfig->drcCoefficientsUniDrcCount; n++) {
126	63.7k	if (hUniDrcConfig->drcCoefficientsUniDrc[n].drcLocation == location) {
127	53.3k	c = n;
128	53.3k	}
129	63.7k	}
130	292k	if (c >= 0) {
131	49.8k	return &(hUniDrcConfig->drcCoefficientsUniDrc[c]);
132	49.8k	}
133	243k	return NULL; /* possible during bitstream parsing */
134	292k	}
135
136		DRC_INSTRUCTIONS_UNI_DRC* selectDrcInstructions(
137	252k	HANDLE_UNI_DRC_CONFIG hUniDrcConfig, const int drcSetId) {
138	252k	int i;
139	271k	for (i = 0; i < hUniDrcConfig->drcInstructionsCountInclVirtual; i++) {
140	271k	if (hUniDrcConfig->drcInstructionsUniDrc[i].drcSetId == drcSetId) {
141	252k	return &(hUniDrcConfig->drcInstructionsUniDrc[i]);
142	252k	}
143	271k	}
144	0	return NULL;
145	252k	}
146
147		DOWNMIX_INSTRUCTIONS* selectDownmixInstructions(
148	108	HANDLE_UNI_DRC_CONFIG hUniDrcConfig, const int downmixId) {
149	108	int i;
150	201	for (i = 0; i < hUniDrcConfig->downmixInstructionsCount; i++) {
151	120	if (hUniDrcConfig->downmixInstructions[i].downmixId == downmixId) {
152	27	return &(hUniDrcConfig->downmixInstructions[i]);
153	27	}
154	120	}
155	81	return NULL;
156	108	}
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	12.1k	{
169	12.1k	int duckingSequence = -1;
170	12.1k	int c, n, g, match, idx;
171	12.1k	FIXP_SGL factor;
172	12.1k	FIXP_SGL uniqueScaling[8];
173
174	109k	for (g = 0; g < 8; g++) {
175	96.9k	uniqueIndex[g] = -10;
176	96.9k	uniqueScaling[g] = FIXP_SGL(-1.0f);
177	96.9k	}
178
179	12.1k	g = 0;
180
181	12.1k	if (drcSetEffect & EB_DUCK_OTHER) {
182	908	for (c = 0; c < channelCount; c++) {
183	728	match = 0;
184	728	if (c >= 8) return DE_MEMORY_ERROR;
185	728	idx = gainSetIndex[c];
186	728	factor = duckingModificationForChannel[c].duckingScaling;
187	728	if (idx < 0) {
188	126	for (n = 0; n < g; n++) {
189	81	if (uniqueScaling[n] == factor) {
190	61	match = 1;
191	61	groupForChannel[c] = n;
192	61	break;
193	61	}
194	81	}
195	106	if (match == 0) {
196	45	if (g >= 8) return DE_MEMORY_ERROR;
197	45	uniqueIndex[g] = idx;
198	45	uniqueScaling[g] = factor;
199	45	groupForChannel[c] = g;
200	45	g++;
201	45	}
202	622	} else {
203	622	if ((duckingSequence > 0) && (duckingSequence != idx)) {
204	16	return DE_NOT_OK;
205	16	}
206	606	duckingSequence = idx;
207	606	groupForChannel[c] = -1;
208	606	}
209	728	}
210	180	if (duckingSequence == -1) {
211	51	return DE_NOT_OK;
212	51	}
213	11.9k	} else if (drcSetEffect & EB_DUCK_SELF) {
214	9.36k	for (c = 0; c < channelCount; c++) {
215	6.24k	match = 0;
216	6.24k	if (c >= 8) return DE_MEMORY_ERROR;
217	6.24k	idx = gainSetIndex[c];
218	6.24k	factor = duckingModificationForChannel[c].duckingScaling;
219	6.24k	if (idx >= 0) {
220	7.20k	for (n = 0; n < g; n++) {
221	5.57k	if ((uniqueIndex[n] == idx) && (uniqueScaling[n] == factor)) {
222	4.44k	match = 1;
223	4.44k	groupForChannel[c] = n;
224	4.44k	break;
225	4.44k	}
226	5.57k	}
227	6.07k	if (match == 0) {
228	1.63k	if (g >= 8) return DE_MEMORY_ERROR;
229	1.63k	uniqueIndex[g] = idx;
230	1.63k	uniqueScaling[g] = factor;
231	1.63k	groupForChannel[c] = g;
232	1.63k	g++;
233	1.63k	}
234	6.07k	} else {
235	175	groupForChannel[c] = -1;
236	175	}
237	6.24k	}
238	8.81k	} else { /* no ducking */
239	34.3k	for (c = 0; c < channelCount; c++) {
240	25.5k	if (c >= 8) return DE_MEMORY_ERROR;
241	25.5k	idx = gainSetIndex[c];
242	25.5k	match = 0;
243	25.5k	if (idx >= 0) {
244	19.0k	for (n = 0; n < g; n++) {
245	15.7k	if (uniqueIndex[n] == idx) {
246	13.5k	match = 1;
247	13.5k	groupForChannel[c] = n;
248	13.5k	break;
249	13.5k	}
250	15.7k	}
251	16.8k	if (match == 0) {
252	3.30k	if (g >= 8) return DE_MEMORY_ERROR;
253	3.30k	uniqueIndex[g] = idx;
254	3.30k	groupForChannel[c] = g;
255	3.30k	g++;
256	3.30k	}
257	16.8k	} else {
258	8.67k	groupForChannel[c] = -1;
259	8.67k	}
260	25.5k	}
261	8.81k	}
262	12.0k	*nDrcChannelGroups = g;
263
264	12.0k	if (drcSetEffect & (EB_DUCK_OTHER \| EB_DUCK_SELF)) {
265	4.89k	for (g = 0; g < *nDrcChannelGroups; g++) {
266	1.65k	if (drcSetEffect & EB_DUCK_OTHER) {
267	22	uniqueIndex[g] = duckingSequence;
268	22	}
269	1.65k	duckingModificationForChannelGroup[g].duckingScaling = uniqueScaling[g];
270	1.65k	if (uniqueScaling[g] != FL2FXCONST_SGL(1.0f / (float)(1 << 2))) {
271	117	duckingModificationForChannelGroup[g].duckingScalingPresent = 1;
272	1.53k	} else {
273	1.53k	duckingModificationForChannelGroup[g].duckingScalingPresent = 0;
274	1.53k	}
275	1.65k	}
276	3.24k	}
277
278	12.0k	return DE_OK;
279	12.1k	}
280
281		FIXP_DBL
282	33.7k	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	33.7k	FIXP_DBL lin_m =
287	33.7k	f2Pow(fMult(dB_m, FL2FXCONST_DBL(0.1660964f * (float)(1 << 2))), dB_e - 2,
288	33.7k	pLin_e);
289
290	33.7k	return lin_m;
291	33.7k	}
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	38.7k	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	38.7k	FIXP_DBL lin_m =
319	38.7k	f2Pow(fMult(dB_m, FL2FXCONST_DBL(0.1666667f * (float)(1 << 2))), dB_e - 2,
320	38.7k	pLin_e);
321
322	38.7k	return lin_m;
323	38.7k	}
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	}