/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-10 07:00

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	206k	int getDeltaTmin(const int sampleRate) {
109		/* half_ms = round (0.0005 * sampleRate); */
110	206k	int half_ms = (sampleRate + 1000) / 2000;
111	206k	int deltaTmin = 1;
112	206k	if (sampleRate < 1000) {
113	712	return DE_NOT_OK;
114	712	}
115	1.29M	while (deltaTmin <= half_ms) {
116	1.08M	deltaTmin = deltaTmin << 1;
117	1.08M	}
118	205k	return deltaTmin;
119	206k	}
120
121		DRC_COEFFICIENTS_UNI_DRC* selectDrcCoefficients(
122	2.03M	HANDLE_UNI_DRC_CONFIG hUniDrcConfig, const int location) {
123	2.03M	int n;
124	2.03M	int c = -1;
125	3.86M	for (n = 0; n < hUniDrcConfig->drcCoefficientsUniDrcCount; n++) {
126	1.82M	if (hUniDrcConfig->drcCoefficientsUniDrc[n].drcLocation == location) {
127	1.42M	c = n;
128	1.42M	}
129	1.82M	}
130	2.03M	if (c >= 0) {
131	877k	return &(hUniDrcConfig->drcCoefficientsUniDrc[c]);
132	877k	}
133	1.15M	return NULL; /* possible during bitstream parsing */
134	2.03M	}
135
136		DRC_INSTRUCTIONS_UNI_DRC* selectDrcInstructions(
137	1.10M	HANDLE_UNI_DRC_CONFIG hUniDrcConfig, const int drcSetId) {
138	1.10M	int i;
139	1.96M	for (i = 0; i < hUniDrcConfig->drcInstructionsCountInclVirtual; i++) {
140	1.96M	if (hUniDrcConfig->drcInstructionsUniDrc[i].drcSetId == drcSetId) {
141	1.10M	return &(hUniDrcConfig->drcInstructionsUniDrc[i]);
142	1.10M	}
143	1.96M	}
144	0	return NULL;
145	1.10M	}
146
147		DOWNMIX_INSTRUCTIONS* selectDownmixInstructions(
148	7.97k	HANDLE_UNI_DRC_CONFIG hUniDrcConfig, const int downmixId) {
149	7.97k	int i;
150	16.8k	for (i = 0; i < hUniDrcConfig->downmixInstructionsCount; i++) {
151	10.1k	if (hUniDrcConfig->downmixInstructions[i].downmixId == downmixId) {
152	1.29k	return &(hUniDrcConfig->downmixInstructions[i]);
153	1.29k	}
154	10.1k	}
155	6.68k	return NULL;
156	7.97k	}
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.07M	{
169	1.07M	int duckingSequence = -1;
170	1.07M	int c, n, g, match, idx;
171	1.07M	FIXP_SGL factor;
172	1.07M	FIXP_SGL uniqueScaling[8];
173
174	9.67M	for (g = 0; g < 8; g++) {
175	8.60M	uniqueIndex[g] = -10;
176	8.60M	uniqueScaling[g] = FIXP_SGL(-1.0f);
177	8.60M	}
178
179	1.07M	g = 0;
180
181	1.07M	if (drcSetEffect & EB_DUCK_OTHER) {
182	69.6k	for (c = 0; c < channelCount; c++) {
183	39.3k	match = 0;
184	39.3k	if (c >= 8) return DE_MEMORY_ERROR;
185	39.3k	idx = gainSetIndex[c];
186	39.3k	factor = duckingModificationForChannel[c].duckingScaling;
187	39.3k	if (idx < 0) {
188	23.8k	for (n = 0; n < g; n++) {
189	15.0k	if (uniqueScaling[n] == factor) {
190	11.0k	match = 1;
191	11.0k	groupForChannel[c] = n;
192	11.0k	break;
193	11.0k	}
194	15.0k	}
195	19.8k	if (match == 0) {
196	8.84k	if (g >= 8) return DE_MEMORY_ERROR;
197	8.84k	uniqueIndex[g] = idx;
198	8.84k	uniqueScaling[g] = factor;
199	8.84k	groupForChannel[c] = g;
200	8.84k	g++;
201	8.84k	}
202	19.8k	} else {
203	19.4k	if ((duckingSequence > 0) && (duckingSequence != idx)) {
204	894	return DE_NOT_OK;
205	894	}
206	18.5k	duckingSequence = idx;
207	18.5k	groupForChannel[c] = -1;
208	18.5k	}
209	39.3k	}
210	30.3k	if (duckingSequence == -1) {
211	17.0k	return DE_NOT_OK;
212	17.0k	}
213	1.04M	} else if (drcSetEffect & EB_DUCK_SELF) {
214	145k	for (c = 0; c < channelCount; c++) {
215	108k	match = 0;
216	108k	if (c >= 8) return DE_MEMORY_ERROR;
217	108k	idx = gainSetIndex[c];
218	108k	factor = duckingModificationForChannel[c].duckingScaling;
219	108k	if (idx >= 0) {
220	126k	for (n = 0; n < g; n++) {
221	84.3k	if ((uniqueIndex[n] == idx) && (uniqueScaling[n] == factor)) {
222	14.2k	match = 1;
223	14.2k	groupForChannel[c] = n;
224	14.2k	break;
225	14.2k	}
226	84.3k	}
227	56.8k	if (match == 0) {
228	42.6k	if (g >= 8) return DE_MEMORY_ERROR;
229	42.6k	uniqueIndex[g] = idx;
230	42.6k	uniqueScaling[g] = factor;
231	42.6k	groupForChannel[c] = g;
232	42.6k	g++;
233	42.6k	}
234	56.8k	} else {
235	51.7k	groupForChannel[c] = -1;
236	51.7k	}
237	108k	}
238	1.00M	} else { /* no ducking */
239	6.98M	for (c = 0; c < channelCount; c++) {
240	5.98M	if (c >= 8) return DE_MEMORY_ERROR;
241	5.98M	idx = gainSetIndex[c];
242	5.98M	match = 0;
243	5.98M	if (idx >= 0) {
244	295k	for (n = 0; n < g; n++) {
245	188k	if (uniqueIndex[n] == idx) {
246	85.6k	match = 1;
247	85.6k	groupForChannel[c] = n;
248	85.6k	break;
249	85.6k	}
250	188k	}
251	192k	if (match == 0) {
252	106k	if (g >= 8) return DE_MEMORY_ERROR;
253	106k	uniqueIndex[g] = idx;
254	106k	groupForChannel[c] = g;
255	106k	g++;
256	106k	}
257	5.78M	} else {
258	5.78M	groupForChannel[c] = -1;
259	5.78M	}
260	5.98M	}
261	1.00M	}
262	1.05M	*nDrcChannelGroups = g;
263
264	1.05M	if (drcSetEffect & (EB_DUCK_OTHER \| EB_DUCK_SELF)) {
265	99.4k	for (g = 0; g < *nDrcChannelGroups; g++) {
266	49.6k	if (drcSetEffect & EB_DUCK_OTHER) {
267	7.01k	uniqueIndex[g] = duckingSequence;
268	7.01k	}
269	49.6k	duckingModificationForChannelGroup[g].duckingScaling = uniqueScaling[g];
270	49.6k	if (uniqueScaling[g] != FL2FXCONST_SGL(1.0f / (float)(1 << 2))) {
271	22.5k	duckingModificationForChannelGroup[g].duckingScalingPresent = 1;
272	27.0k	} else {
273	27.0k	duckingModificationForChannelGroup[g].duckingScalingPresent = 0;
274	27.0k	}
275	49.6k	}
276	49.7k	}
277
278	1.05M	return DE_OK;
279	1.07M	}
280
281		FIXP_DBL
282	10.8k	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	10.8k	FIXP_DBL lin_m =
287	10.8k	f2Pow(fMult(dB_m, FL2FXCONST_DBL(0.1660964f * (float)(1 << 2))), dB_e - 2,
288	10.8k	pLin_e);
289
290	10.8k	return lin_m;
291	10.8k	}
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	22.5k	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	22.5k	FIXP_DBL lin_m =
319	22.5k	f2Pow(fMult(dB_m, FL2FXCONST_DBL(0.1666667f * (float)(1 << 2))), dB_e - 2,
320	22.5k	pLin_e);
321
322	22.5k	return lin_m;
323	22.5k	}
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	}