/src/aac/libAACdec/src/usacdec_fac.cpp
Line | Count | Source (jump to first uncovered line) |
1 | | /* ----------------------------------------------------------------------------- |
2 | | Software License for The Fraunhofer FDK AAC Codec Library for Android |
3 | | |
4 | | © Copyright 1995 - 2019 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 | | /**************************** AAC decoder library ****************************** |
96 | | |
97 | | Author(s): Manuel Jander |
98 | | |
99 | | Description: USAC FAC |
100 | | |
101 | | *******************************************************************************/ |
102 | | |
103 | | #include "usacdec_fac.h" |
104 | | |
105 | | #include "usacdec_const.h" |
106 | | #include "usacdec_lpc.h" |
107 | | #include "usacdec_acelp.h" |
108 | | #include "usacdec_rom.h" |
109 | | #include "dct.h" |
110 | | #include "FDK_tools_rom.h" |
111 | | #include "mdct.h" |
112 | | |
113 | 0 | #define SPEC_FAC(ptr, i, gl) ((ptr) + ((i) * (gl))) |
114 | | |
115 | | FIXP_DBL *CLpd_FAC_GetMemory(CAacDecoderChannelInfo *pAacDecoderChannelInfo, |
116 | 0 | UCHAR mod[NB_DIV], int *pState) { |
117 | 0 | FIXP_DBL *ptr; |
118 | 0 | int i; |
119 | 0 | int k = 0; |
120 | 0 | int max_windows = 8; |
121 | |
|
122 | 0 | FDK_ASSERT(*pState >= 0 && *pState < max_windows); |
123 | | |
124 | | /* Look for free space to store FAC data. 2 FAC data blocks fit into each TCX |
125 | | * spectral data block. */ |
126 | 0 | for (i = *pState; i < max_windows; i++) { |
127 | 0 | if (mod[i >> 1] == 0) { |
128 | 0 | break; |
129 | 0 | } |
130 | 0 | } |
131 | |
|
132 | 0 | *pState = i + 1; |
133 | |
|
134 | 0 | if (i == max_windows) { |
135 | 0 | ptr = pAacDecoderChannelInfo->data.usac.fac_data0; |
136 | 0 | } else { |
137 | 0 | FDK_ASSERT(mod[(i >> 1)] == 0); |
138 | 0 | ptr = SPEC_FAC(pAacDecoderChannelInfo->pSpectralCoefficient, i, |
139 | 0 | pAacDecoderChannelInfo->granuleLength << k); |
140 | 0 | } |
141 | | |
142 | 0 | return ptr; |
143 | 0 | } |
144 | | |
145 | | int CLpd_FAC_Read(HANDLE_FDK_BITSTREAM hBs, FIXP_DBL *pFac, SCHAR *pFacScale, |
146 | 0 | int length, int use_gain, int frame) { |
147 | 0 | FIXP_DBL fac_gain; |
148 | 0 | int fac_gain_e = 0; |
149 | |
|
150 | 0 | if (use_gain) { |
151 | 0 | CLpd_DecodeGain(&fac_gain, &fac_gain_e, FDKreadBits(hBs, 7)); |
152 | 0 | } |
153 | |
|
154 | 0 | if (CLpc_DecodeAVQ(hBs, pFac, 1, 1, length) != 0) { |
155 | 0 | return -1; |
156 | 0 | } |
157 | | |
158 | 0 | { |
159 | 0 | int scale; |
160 | |
|
161 | 0 | scale = getScalefactor(pFac, length); |
162 | 0 | scaleValues(pFac, length, scale); |
163 | 0 | pFacScale[frame] = DFRACT_BITS - 1 - scale; |
164 | 0 | } |
165 | |
|
166 | 0 | if (use_gain) { |
167 | 0 | int i; |
168 | |
|
169 | 0 | pFacScale[frame] += fac_gain_e; |
170 | |
|
171 | 0 | for (i = 0; i < length; i++) { |
172 | 0 | pFac[i] = fMult(pFac[i], fac_gain); |
173 | 0 | } |
174 | 0 | } |
175 | 0 | return 0; |
176 | 0 | } |
177 | | |
178 | | /** |
179 | | * \brief Apply synthesis filter with zero input to x. The overall filter gain |
180 | | * is 1.0. |
181 | | * \param a LPC filter coefficients. |
182 | | * \param length length of the input/output data vector x. |
183 | | * \param x input/output vector, where the synthesis filter is applied in place. |
184 | | */ |
185 | | static void Syn_filt_zero(const FIXP_LPC a[], const INT a_exp, INT length, |
186 | 0 | FIXP_DBL x[]) { |
187 | 0 | int i, j; |
188 | 0 | FIXP_DBL L_tmp; |
189 | |
|
190 | 0 | for (i = 0; i < length; i++) { |
191 | 0 | L_tmp = (FIXP_DBL)0; |
192 | |
|
193 | 0 | for (j = 0; j < fMin(i, M_LP_FILTER_ORDER); j++) { |
194 | 0 | L_tmp -= fMultDiv2(a[j], x[i - (j + 1)]) >> (LP_FILTER_SCALE - 1); |
195 | 0 | } |
196 | |
|
197 | 0 | L_tmp = scaleValue(L_tmp, a_exp + LP_FILTER_SCALE); |
198 | 0 | x[i] = fAddSaturate(x[i], L_tmp); |
199 | 0 | } |
200 | 0 | } |
201 | | |
202 | | /* Table is also correct for coreCoderFrameLength = 768. Factor 3/4 is canceled |
203 | | out: gainFac = 0.5 * sqrt(fac_length/lFrame) |
204 | | */ |
205 | | static const FIXP_DBL gainFac[4] = {0x40000000, 0x2d413ccd, 0x20000000, |
206 | | 0x16a09e66}; |
207 | | |
208 | | void CFac_ApplyGains(FIXP_DBL fac_data[LFAC], const INT fac_length, |
209 | | const FIXP_DBL tcx_gain, const FIXP_DBL alfd_gains[], |
210 | 0 | const INT mod) { |
211 | 0 | FIXP_DBL facFactor; |
212 | 0 | int i; |
213 | |
|
214 | 0 | FDK_ASSERT((fac_length == 128) || (fac_length == 96)); |
215 | | |
216 | | /* 2) Apply gain factor to FAC data */ |
217 | 0 | facFactor = fMult(gainFac[mod], tcx_gain); |
218 | 0 | for (i = 0; i < fac_length; i++) { |
219 | 0 | fac_data[i] = fMult(fac_data[i], facFactor); |
220 | 0 | } |
221 | | |
222 | | /* 3) Apply spectrum deshaping using alfd_gains */ |
223 | 0 | for (i = 0; i < fac_length / 4; i++) { |
224 | 0 | int k; |
225 | |
|
226 | 0 | k = i >> (3 - mod); |
227 | 0 | fac_data[i] = fMult(fac_data[i], alfd_gains[k]) |
228 | 0 | << 1; /* alfd_gains is scaled by one bit. */ |
229 | 0 | } |
230 | 0 | } |
231 | | |
232 | | static void CFac_CalcFacSignal(FIXP_DBL *pOut, FIXP_DBL *pFac, |
233 | | const int fac_scale, const int fac_length, |
234 | | const FIXP_LPC A[M_LP_FILTER_ORDER], |
235 | | const INT A_exp, const int fAddZir, |
236 | 0 | const int isFdFac) { |
237 | 0 | FIXP_LPC wA[M_LP_FILTER_ORDER]; |
238 | 0 | FIXP_DBL tf_gain = (FIXP_DBL)0; |
239 | 0 | int wlength; |
240 | 0 | int scale = fac_scale; |
241 | | |
242 | | /* obtain tranform gain. */ |
243 | 0 | imdct_gain(&tf_gain, &scale, isFdFac ? 0 : fac_length); |
244 | | |
245 | | /* 4) Compute inverse DCT-IV of FAC data. Output scale of DCT IV is 16 bits. |
246 | | */ |
247 | 0 | dct_IV(pFac, fac_length, &scale); |
248 | | /* dct_IV scale = log2(fac_length). "- 7" is a factor of 2/128 */ |
249 | 0 | if (tf_gain != (FIXP_DBL)0) { /* non-radix 2 transform gain */ |
250 | 0 | int i; |
251 | |
|
252 | 0 | for (i = 0; i < fac_length; i++) { |
253 | 0 | pFac[i] = fMult(tf_gain, pFac[i]); |
254 | 0 | } |
255 | 0 | } |
256 | 0 | scaleValuesSaturate(pOut, pFac, fac_length, |
257 | 0 | scale); /* Avoid overflow issues and saturate. */ |
258 | |
|
259 | 0 | E_LPC_a_weight(wA, A, M_LP_FILTER_ORDER); |
260 | | |
261 | | /* We need the output of the IIR filter to be longer than "fac_length". |
262 | | For this reason we run it with zero input appended to the end of the input |
263 | | sequence, i.e. we generate its ZIR and extend the output signal.*/ |
264 | 0 | FDKmemclear(pOut + fac_length, fac_length * sizeof(FIXP_DBL)); |
265 | 0 | wlength = 2 * fac_length; |
266 | | |
267 | | /* 5) Apply weighted synthesis filter to FAC data, including optional Zir (5. |
268 | | * item 4). */ |
269 | 0 | Syn_filt_zero(wA, A_exp, wlength, pOut); |
270 | 0 | } |
271 | | |
272 | | INT CLpd_FAC_Mdct2Acelp(H_MDCT hMdct, FIXP_DBL *output, FIXP_DBL *pFac, |
273 | | const int fac_scale, FIXP_LPC *A, INT A_exp, |
274 | | INT nrOutSamples, const INT fac_length, |
275 | 0 | const INT isFdFac, UCHAR prevWindowShape) { |
276 | 0 | FIXP_DBL *pOvl; |
277 | 0 | FIXP_DBL *pOut0; |
278 | 0 | const FIXP_WTP *pWindow; |
279 | 0 | int i, fl, nrSamples = 0; |
280 | |
|
281 | 0 | FDK_ASSERT(fac_length <= 1024 / (4 * 2)); |
282 | | |
283 | 0 | fl = fac_length * 2; |
284 | |
|
285 | 0 | pWindow = FDKgetWindowSlope(fl, prevWindowShape); |
286 | | |
287 | | /* Adapt window slope length in case of frame loss. */ |
288 | 0 | if (hMdct->prev_fr != fl) { |
289 | 0 | int nl = 0; |
290 | 0 | imdct_adapt_parameters(hMdct, &fl, &nl, fac_length, pWindow, nrOutSamples); |
291 | 0 | FDK_ASSERT(nl == 0); |
292 | 0 | } |
293 | | |
294 | 0 | if (nrSamples < nrOutSamples) { |
295 | 0 | pOut0 = output; |
296 | 0 | nrSamples += hMdct->ov_offset; |
297 | | /* Purge buffered output. */ |
298 | 0 | FDKmemcpy(pOut0, hMdct->overlap.time, hMdct->ov_offset * sizeof(pOut0[0])); |
299 | 0 | hMdct->ov_offset = 0; |
300 | 0 | } |
301 | |
|
302 | 0 | pOvl = hMdct->overlap.freq + hMdct->ov_size - 1; |
303 | |
|
304 | 0 | if (nrSamples >= nrOutSamples) { |
305 | 0 | pOut0 = hMdct->overlap.time + hMdct->ov_offset; |
306 | 0 | hMdct->ov_offset += hMdct->prev_nr + fl / 2; |
307 | 0 | } else { |
308 | 0 | pOut0 = output + nrSamples; |
309 | 0 | nrSamples += hMdct->prev_nr + fl / 2; |
310 | 0 | } |
311 | 0 | if (hMdct->prevPrevAliasSymmetry == 0) { |
312 | 0 | for (i = 0; i < hMdct->prev_nr; i++) { |
313 | 0 | FIXP_DBL x = -(*pOvl--); |
314 | 0 | *pOut0 = IMDCT_SCALE_DBL(x); |
315 | 0 | pOut0++; |
316 | 0 | } |
317 | 0 | } else { |
318 | 0 | for (i = 0; i < hMdct->prev_nr; i++) { |
319 | 0 | FIXP_DBL x = (*pOvl--); |
320 | 0 | *pOut0 = IMDCT_SCALE_DBL(x); |
321 | 0 | pOut0++; |
322 | 0 | } |
323 | 0 | } |
324 | 0 | hMdct->prev_nr = 0; |
325 | |
|
326 | 0 | { |
327 | 0 | if (pFac != NULL) { |
328 | | /* Note: The FAC gain might have been applied directly after bit stream |
329 | | * parse in this case. */ |
330 | 0 | CFac_CalcFacSignal(pOut0, pFac, fac_scale, fac_length, A, A_exp, 0, |
331 | 0 | isFdFac); |
332 | 0 | } else { |
333 | | /* Clear buffer because of the overlap and ADD! */ |
334 | 0 | FDKmemclear(pOut0, fac_length * sizeof(FIXP_DBL)); |
335 | 0 | } |
336 | 0 | } |
337 | |
|
338 | 0 | i = 0; |
339 | |
|
340 | 0 | if (hMdct->prevPrevAliasSymmetry == 0) { |
341 | 0 | for (; i < fl / 2; i++) { |
342 | 0 | FIXP_DBL x0; |
343 | | |
344 | | /* Overlap Add */ |
345 | 0 | x0 = -fMult(*pOvl--, pWindow[i].v.re); |
346 | |
|
347 | 0 | *pOut0 = fAddSaturate(*pOut0, IMDCT_SCALE_DBL(x0)); |
348 | 0 | pOut0++; |
349 | 0 | } |
350 | 0 | } else { |
351 | 0 | for (; i < fl / 2; i++) { |
352 | 0 | FIXP_DBL x0; |
353 | | |
354 | | /* Overlap Add */ |
355 | 0 | x0 = fMult(*pOvl--, pWindow[i].v.re); |
356 | |
|
357 | 0 | *pOut0 = fAddSaturate(*pOut0, IMDCT_SCALE_DBL(x0)); |
358 | 0 | pOut0++; |
359 | 0 | } |
360 | 0 | } |
361 | 0 | if (hMdct->pFacZir != |
362 | 0 | 0) { /* this should only happen for ACELP -> TCX20 -> ACELP transition */ |
363 | 0 | FIXP_DBL *pOut = pOut0 - fl / 2; /* fl/2 == fac_length */ |
364 | 0 | for (i = 0; i < fl / 2; i++) { |
365 | 0 | pOut[i] = fAddSaturate(pOut[i], IMDCT_SCALE_DBL(hMdct->pFacZir[i])); |
366 | 0 | } |
367 | 0 | hMdct->pFacZir = NULL; |
368 | 0 | } |
369 | |
|
370 | 0 | hMdct->prev_fr = 0; |
371 | 0 | hMdct->prev_nr = 0; |
372 | 0 | hMdct->prev_tl = 0; |
373 | 0 | hMdct->prevPrevAliasSymmetry = hMdct->prevAliasSymmetry; |
374 | |
|
375 | 0 | return nrSamples; |
376 | 0 | } |
377 | | |
378 | | INT CLpd_FAC_Acelp2Mdct(H_MDCT hMdct, FIXP_DBL *output, FIXP_DBL *_pSpec, |
379 | | const SHORT spec_scale[], const int nSpec, |
380 | | FIXP_DBL *pFac, const int fac_scale, |
381 | | const INT fac_length, INT noOutSamples, const INT tl, |
382 | | const FIXP_WTP *wrs, const INT fr, FIXP_LPC A[16], |
383 | | INT A_exp, CAcelpStaticMem *acelp_mem, |
384 | | const FIXP_DBL gain, const int last_frame_lost, |
385 | | const int isFdFac, const UCHAR last_lpd_mode, |
386 | 0 | const int k, int currAliasingSymmetry) { |
387 | 0 | FIXP_DBL *pCurr, *pOvl, *pSpec; |
388 | 0 | const FIXP_WTP *pWindow; |
389 | 0 | const FIXP_WTB *FacWindowZir_conceal; |
390 | 0 | UCHAR doFacZirConceal = 0; |
391 | 0 | int doDeemph = 1; |
392 | 0 | const FIXP_WTB *FacWindowZir, *FacWindowSynth; |
393 | 0 | FIXP_DBL *pOut0 = output, *pOut1; |
394 | 0 | int w, i, fl, nl, nr, f_len, nrSamples = 0, s = 0, scale, total_gain_e; |
395 | 0 | FIXP_DBL *pF, *pFAC_and_FAC_ZIR = NULL; |
396 | 0 | FIXP_DBL total_gain = gain; |
397 | |
|
398 | 0 | FDK_ASSERT(fac_length <= 1024 / (4 * 2)); |
399 | 0 | switch (fac_length) { |
400 | | /* coreCoderFrameLength = 1024 */ |
401 | 0 | case 128: |
402 | 0 | pWindow = SineWindow256; |
403 | 0 | FacWindowZir = FacWindowZir128; |
404 | 0 | FacWindowSynth = FacWindowSynth128; |
405 | 0 | break; |
406 | 0 | case 64: |
407 | 0 | pWindow = SineWindow128; |
408 | 0 | FacWindowZir = FacWindowZir64; |
409 | 0 | FacWindowSynth = FacWindowSynth64; |
410 | 0 | break; |
411 | 0 | case 32: |
412 | 0 | pWindow = SineWindow64; |
413 | 0 | FacWindowZir = FacWindowZir32; |
414 | 0 | FacWindowSynth = FacWindowSynth32; |
415 | 0 | break; |
416 | | /* coreCoderFrameLength = 768 */ |
417 | 0 | case 96: |
418 | 0 | pWindow = SineWindow192; |
419 | 0 | FacWindowZir = FacWindowZir96; |
420 | 0 | FacWindowSynth = FacWindowSynth96; |
421 | 0 | break; |
422 | 0 | case 48: |
423 | 0 | pWindow = SineWindow96; |
424 | 0 | FacWindowZir = FacWindowZir48; |
425 | 0 | FacWindowSynth = FacWindowSynth48; |
426 | 0 | break; |
427 | 0 | default: |
428 | 0 | FDK_ASSERT(0); |
429 | 0 | return 0; |
430 | 0 | } |
431 | | |
432 | 0 | FacWindowZir_conceal = FacWindowSynth; |
433 | | /* Derive NR and NL */ |
434 | 0 | fl = fac_length * 2; |
435 | 0 | nl = (tl - fl) >> 1; |
436 | 0 | nr = (tl - fr) >> 1; |
437 | |
|
438 | 0 | if (noOutSamples > nrSamples) { |
439 | | /* Purge buffered output. */ |
440 | 0 | FDKmemcpy(pOut0, hMdct->overlap.time, hMdct->ov_offset * sizeof(pOut0[0])); |
441 | 0 | nrSamples = hMdct->ov_offset; |
442 | 0 | hMdct->ov_offset = 0; |
443 | 0 | } |
444 | |
|
445 | 0 | if (nrSamples >= noOutSamples) { |
446 | 0 | pOut1 = hMdct->overlap.time + hMdct->ov_offset; |
447 | 0 | if (hMdct->ov_offset < fac_length) { |
448 | 0 | pOut0 = output + nrSamples; |
449 | 0 | } else { |
450 | 0 | pOut0 = pOut1; |
451 | 0 | } |
452 | 0 | hMdct->ov_offset += fac_length + nl; |
453 | 0 | } else { |
454 | 0 | pOut1 = output + nrSamples; |
455 | 0 | pOut0 = output + nrSamples; |
456 | 0 | } |
457 | |
|
458 | 0 | { |
459 | 0 | pFAC_and_FAC_ZIR = CLpd_ACELP_GetFreeExcMem(acelp_mem, 2 * fac_length); |
460 | 0 | { |
461 | 0 | const FIXP_DBL *pTmp1, *pTmp2; |
462 | |
|
463 | 0 | doFacZirConceal |= ((last_frame_lost != 0) && (k == 0)); |
464 | 0 | doDeemph &= (last_lpd_mode != 4); |
465 | 0 | if (doFacZirConceal) { |
466 | | /* ACELP contribution in concealment case: |
467 | | Use ZIR with a modified ZIR window to preserve some more energy. |
468 | | Dont use FAC, which contains wrong information for concealed frame |
469 | | Dont use last ACELP samples, but double ZIR, instead (afterwards) */ |
470 | 0 | FDKmemclear(pFAC_and_FAC_ZIR, 2 * fac_length * sizeof(FIXP_DBL)); |
471 | 0 | FacWindowSynth = (FIXP_WTB *)pFAC_and_FAC_ZIR; |
472 | 0 | FacWindowZir = FacWindowZir_conceal; |
473 | 0 | } else { |
474 | 0 | CFac_CalcFacSignal(pFAC_and_FAC_ZIR, pFac, fac_scale + s, fac_length, A, |
475 | 0 | A_exp, 1, isFdFac); |
476 | 0 | } |
477 | | /* 6) Get windowed past ACELP samples and ACELP ZIR signal */ |
478 | | |
479 | | /* |
480 | | * Get ACELP ZIR (pFac[]) and ACELP past samples (pOut0[]) and add them |
481 | | * to the FAC synth signal contribution on pOut1[]. |
482 | | */ |
483 | 0 | { |
484 | 0 | { |
485 | 0 | CLpd_Acelp_Zir(A, A_exp, acelp_mem, fac_length, pFac, doDeemph); |
486 | |
|
487 | 0 | pTmp1 = pOut0; |
488 | 0 | pTmp2 = pFac; |
489 | 0 | } |
490 | |
|
491 | 0 | for (i = 0, w = 0; i < fac_length; i++) { |
492 | 0 | FIXP_DBL x; |
493 | | /* Div2 is compensated by table scaling */ |
494 | 0 | x = fMultDiv2(pTmp2[i], FacWindowZir[w]); |
495 | 0 | x += fMultDiv2(pTmp1[-i - 1], FacWindowSynth[w]); |
496 | 0 | pOut1[i] = fAddSaturate(x, pFAC_and_FAC_ZIR[i]); |
497 | 0 | w++; |
498 | 0 | } |
499 | 0 | } |
500 | |
|
501 | 0 | if (doFacZirConceal) { |
502 | | /* ZIR is the only ACELP contribution, so double it */ |
503 | 0 | scaleValues(pOut1, fac_length, 1); |
504 | 0 | } |
505 | 0 | } |
506 | 0 | } |
507 | |
|
508 | 0 | if (nrSamples < noOutSamples) { |
509 | 0 | nrSamples += fac_length + nl; |
510 | 0 | } |
511 | | |
512 | | /* Obtain transform gain */ |
513 | 0 | total_gain = gain; |
514 | 0 | total_gain_e = 0; |
515 | 0 | imdct_gain(&total_gain, &total_gain_e, tl); |
516 | | |
517 | | /* IMDCT overlap add */ |
518 | 0 | scale = total_gain_e; |
519 | 0 | pSpec = _pSpec; |
520 | | |
521 | | /* Note:when comming from an LPD frame (TCX/ACELP) the previous alisaing |
522 | | * symmetry must always be 0 */ |
523 | 0 | if (currAliasingSymmetry == 0) { |
524 | 0 | dct_IV(pSpec, tl, &scale); |
525 | 0 | } else { |
526 | 0 | FIXP_DBL _tmp[1024 + ALIGNMENT_DEFAULT / sizeof(FIXP_DBL)]; |
527 | 0 | FIXP_DBL *tmp = (FIXP_DBL *)ALIGN_PTR(_tmp); |
528 | 0 | C_ALLOC_ALIGNED_REGISTER(tmp, sizeof(_tmp)); |
529 | 0 | dst_III(pSpec, tmp, tl, &scale); |
530 | 0 | C_ALLOC_ALIGNED_UNREGISTER(tmp); |
531 | 0 | } |
532 | | |
533 | | /* Optional scaling of time domain - no yet windowed - of current spectrum */ |
534 | 0 | if (total_gain != (FIXP_DBL)0) { |
535 | 0 | for (i = 0; i < tl; i++) { |
536 | 0 | pSpec[i] = fMult(pSpec[i], total_gain); |
537 | 0 | } |
538 | 0 | } |
539 | 0 | int loc_scale = fixmin_I(spec_scale[0] + scale, (INT)DFRACT_BITS - 1); |
540 | 0 | scaleValuesSaturate(pSpec, tl, loc_scale); |
541 | |
|
542 | 0 | pOut1 += fl / 2 - 1; |
543 | 0 | pCurr = pSpec + tl - fl / 2; |
544 | |
|
545 | 0 | for (i = 0; i < fl / 2; i++) { |
546 | 0 | FIXP_DBL x1; |
547 | | |
548 | | /* FAC signal is already on pOut1, because of that the += operator. */ |
549 | 0 | x1 = fMult(*pCurr++, pWindow[i].v.re); |
550 | 0 | FDK_ASSERT((pOut1 >= hMdct->overlap.time && |
551 | 0 | pOut1 < hMdct->overlap.time + hMdct->ov_size) || |
552 | 0 | (pOut1 >= output && pOut1 < output + 1024)); |
553 | 0 | *pOut1 = fAddSaturate(*pOut1, IMDCT_SCALE_DBL(-x1)); |
554 | 0 | pOut1--; |
555 | 0 | } |
556 | | |
557 | | /* NL output samples TL/2+FL/2..TL. - current[FL/2..0] */ |
558 | 0 | pOut1 += (fl / 2) + 1; |
559 | |
|
560 | 0 | pFAC_and_FAC_ZIR += fac_length; /* set pointer to beginning of FAC ZIR */ |
561 | |
|
562 | 0 | if (nl == 0) { |
563 | | /* save pointer to write FAC ZIR data later */ |
564 | 0 | hMdct->pFacZir = pFAC_and_FAC_ZIR; |
565 | 0 | } else { |
566 | 0 | FDK_ASSERT(nl >= fac_length); |
567 | | /* FAC ZIR will be added now ... */ |
568 | 0 | hMdct->pFacZir = NULL; |
569 | 0 | } |
570 | | |
571 | 0 | pF = pFAC_and_FAC_ZIR; |
572 | 0 | f_len = fac_length; |
573 | |
|
574 | 0 | pCurr = pSpec + tl - fl / 2 - 1; |
575 | 0 | for (i = 0; i < nl; i++) { |
576 | 0 | FIXP_DBL x = -(*pCurr--); |
577 | | /* 5) (item 4) Synthesis filter Zir component, FAC ZIR (another one). */ |
578 | 0 | if (i < f_len) { |
579 | 0 | x = fAddSaturate(x, *pF++); |
580 | 0 | } |
581 | |
|
582 | 0 | FDK_ASSERT((pOut1 >= hMdct->overlap.time && |
583 | 0 | pOut1 < hMdct->overlap.time + hMdct->ov_size) || |
584 | 0 | (pOut1 >= output && pOut1 < output + 1024)); |
585 | 0 | *pOut1 = IMDCT_SCALE_DBL(x); |
586 | 0 | pOut1++; |
587 | 0 | } |
588 | | |
589 | 0 | hMdct->prev_nr = nr; |
590 | 0 | hMdct->prev_fr = fr; |
591 | 0 | hMdct->prev_wrs = wrs; |
592 | 0 | hMdct->prev_tl = tl; |
593 | 0 | hMdct->prevPrevAliasSymmetry = hMdct->prevAliasSymmetry; |
594 | 0 | hMdct->prevAliasSymmetry = currAliasingSymmetry; |
595 | 0 | fl = fr; |
596 | 0 | nl = nr; |
597 | |
|
598 | 0 | pOvl = pSpec + tl / 2 - 1; |
599 | 0 | pOut0 = pOut1; |
600 | |
|
601 | 0 | for (w = 1; w < nSpec; w++) /* for ACELP -> FD short */ |
602 | 0 | { |
603 | 0 | const FIXP_WTP *pWindow_prev; |
604 | | |
605 | | /* Setup window pointers */ |
606 | 0 | pWindow_prev = hMdct->prev_wrs; |
607 | | |
608 | | /* Current spectrum */ |
609 | 0 | pSpec = _pSpec + w * tl; |
610 | |
|
611 | 0 | scale = total_gain_e; |
612 | | |
613 | | /* For the second, third, etc. short frames the alisaing symmetry is equal, |
614 | | * either (0,0) or (1,1) */ |
615 | 0 | if (currAliasingSymmetry == 0) { |
616 | | /* DCT IV of current spectrum */ |
617 | 0 | dct_IV(pSpec, tl, &scale); |
618 | 0 | } else { |
619 | 0 | dst_IV(pSpec, tl, &scale); |
620 | 0 | } |
621 | | |
622 | | /* Optional scaling of time domain - no yet windowed - of current spectrum |
623 | | */ |
624 | | /* and de-scale current spectrum signal (time domain, no yet windowed) */ |
625 | 0 | if (total_gain != (FIXP_DBL)0) { |
626 | 0 | for (i = 0; i < tl; i++) { |
627 | 0 | pSpec[i] = fMult(pSpec[i], total_gain); |
628 | 0 | } |
629 | 0 | } |
630 | 0 | loc_scale = fixmin_I(spec_scale[w] + scale, (INT)DFRACT_BITS - 1); |
631 | 0 | scaleValuesSaturate(pSpec, tl, loc_scale); |
632 | |
|
633 | 0 | if (noOutSamples <= nrSamples) { |
634 | | /* Divert output first half to overlap buffer if we already got enough |
635 | | * output samples. */ |
636 | 0 | pOut0 = hMdct->overlap.time + hMdct->ov_offset; |
637 | 0 | hMdct->ov_offset += hMdct->prev_nr + fl / 2; |
638 | 0 | } else { |
639 | | /* Account output samples */ |
640 | 0 | nrSamples += hMdct->prev_nr + fl / 2; |
641 | 0 | } |
642 | | |
643 | | /* NR output samples 0 .. NR. -overlap[TL/2..TL/2-NR] */ |
644 | 0 | for (i = 0; i < hMdct->prev_nr; i++) { |
645 | 0 | FIXP_DBL x = -(*pOvl--); |
646 | 0 | *pOut0 = IMDCT_SCALE_DBL(x); |
647 | 0 | pOut0++; |
648 | 0 | } |
649 | |
|
650 | 0 | if (noOutSamples <= nrSamples) { |
651 | | /* Divert output second half to overlap buffer if we already got enough |
652 | | * output samples. */ |
653 | 0 | pOut1 = hMdct->overlap.time + hMdct->ov_offset + fl / 2 - 1; |
654 | 0 | hMdct->ov_offset += fl / 2 + nl; |
655 | 0 | } else { |
656 | 0 | pOut1 = pOut0 + (fl - 1); |
657 | 0 | nrSamples += fl / 2 + nl; |
658 | 0 | } |
659 | | |
660 | | /* output samples before window crossing point NR .. TL/2. |
661 | | * -overlap[TL/2-NR..TL/2-NR-FL/2] + current[NR..TL/2] */ |
662 | | /* output samples after window crossing point TL/2 .. TL/2+FL/2. |
663 | | * -overlap[0..FL/2] - current[TL/2..FL/2] */ |
664 | 0 | pCurr = pSpec + tl - fl / 2; |
665 | 0 | if (currAliasingSymmetry == 0) { |
666 | 0 | for (i = 0; i < fl / 2; i++) { |
667 | 0 | FIXP_DBL x0, x1; |
668 | |
|
669 | 0 | cplxMultDiv2(&x1, &x0, *pCurr++, -*pOvl--, pWindow_prev[i]); |
670 | 0 | *pOut0 = IMDCT_SCALE_DBL_LSH1(x0); |
671 | 0 | *pOut1 = IMDCT_SCALE_DBL_LSH1(-x1); |
672 | 0 | pOut0++; |
673 | 0 | pOut1--; |
674 | 0 | } |
675 | 0 | } else { |
676 | 0 | if (hMdct->prevPrevAliasSymmetry == 0) { |
677 | | /* Jump DST II -> DST IV for the second window */ |
678 | 0 | for (i = 0; i < fl / 2; i++) { |
679 | 0 | FIXP_DBL x0, x1; |
680 | |
|
681 | 0 | cplxMultDiv2(&x1, &x0, *pCurr++, -*pOvl--, pWindow_prev[i]); |
682 | 0 | *pOut0 = IMDCT_SCALE_DBL_LSH1(x0); |
683 | 0 | *pOut1 = IMDCT_SCALE_DBL_LSH1(x1); |
684 | 0 | pOut0++; |
685 | 0 | pOut1--; |
686 | 0 | } |
687 | 0 | } else { |
688 | | /* Jump DST IV -> DST IV from the second window on */ |
689 | 0 | for (i = 0; i < fl / 2; i++) { |
690 | 0 | FIXP_DBL x0, x1; |
691 | |
|
692 | 0 | cplxMultDiv2(&x1, &x0, *pCurr++, *pOvl--, pWindow_prev[i]); |
693 | 0 | *pOut0 = IMDCT_SCALE_DBL_LSH1(x0); |
694 | 0 | *pOut1 = IMDCT_SCALE_DBL_LSH1(x1); |
695 | 0 | pOut0++; |
696 | 0 | pOut1--; |
697 | 0 | } |
698 | 0 | } |
699 | 0 | } |
700 | |
|
701 | 0 | if (hMdct->pFacZir != 0) { |
702 | | /* add FAC ZIR of previous ACELP -> mdct transition */ |
703 | 0 | FIXP_DBL *pOut = pOut0 - fl / 2; |
704 | 0 | FDK_ASSERT(fl / 2 <= 128); |
705 | 0 | for (i = 0; i < fl / 2; i++) { |
706 | 0 | pOut[i] = fAddSaturate(pOut[i], IMDCT_SCALE_DBL(hMdct->pFacZir[i])); |
707 | 0 | } |
708 | 0 | hMdct->pFacZir = NULL; |
709 | 0 | } |
710 | 0 | pOut0 += (fl / 2); |
711 | | |
712 | | /* NL output samples TL/2+FL/2..TL. - current[FL/2..0] */ |
713 | 0 | pOut1 += (fl / 2) + 1; |
714 | 0 | pCurr = pSpec + tl - fl / 2 - 1; |
715 | 0 | for (i = 0; i < nl; i++) { |
716 | 0 | FIXP_DBL x = -(*pCurr--); |
717 | 0 | *pOut1 = IMDCT_SCALE_DBL(x); |
718 | 0 | pOut1++; |
719 | 0 | } |
720 | | |
721 | | /* Set overlap source pointer for next window pOvl = pSpec + tl/2 - 1; */ |
722 | 0 | pOvl = pSpec + tl / 2 - 1; |
723 | | |
724 | | /* Previous window values. */ |
725 | 0 | hMdct->prev_nr = nr; |
726 | 0 | hMdct->prev_fr = fr; |
727 | 0 | hMdct->prev_tl = tl; |
728 | 0 | hMdct->prev_wrs = pWindow_prev; |
729 | 0 | hMdct->prevPrevAliasSymmetry = hMdct->prevAliasSymmetry; |
730 | 0 | hMdct->prevAliasSymmetry = currAliasingSymmetry; |
731 | 0 | } |
732 | | |
733 | | /* Save overlap */ |
734 | | |
735 | 0 | pOvl = hMdct->overlap.freq + hMdct->ov_size - tl / 2; |
736 | 0 | FDK_ASSERT(pOvl >= hMdct->overlap.time + hMdct->ov_offset); |
737 | 0 | FDK_ASSERT(tl / 2 <= hMdct->ov_size); |
738 | 0 | for (i = 0; i < tl / 2; i++) { |
739 | 0 | pOvl[i] = _pSpec[i + (w - 1) * tl]; |
740 | 0 | } |
741 | |
|
742 | 0 | return nrSamples; |
743 | 0 | } |