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 /**************************** SBR encoder library ******************************
96
97 Author(s): Andreas Ehret, Tobias Chalupka
98
99 Description: SBR encoder top level processing.
100
101 *******************************************************************************/
102
103 #include "sbr_encoder.h"
104
105 #include "sbrenc_ram.h"
106 #include "sbrenc_rom.h"
107 #include "sbrenc_freq_sca.h"
108 #include "env_bit.h"
109 #include "cmondata.h"
110 #include "sbr_misc.h"
111 #include "sbr.h"
112 #include "qmf.h"
113
114 #include "ps_main.h"
115
116 #define SBRENCODER_LIB_VL0 4
117 #define SBRENCODER_LIB_VL1 0
118 #define SBRENCODER_LIB_VL2 0
119
120 /***************************************************************************/
121 /*
122 * SBR Delay balancing definitions.
123 */
124
125 /*
126 input buffer (1ch)
127
128 |------------ 1537 -------------|-----|---------- 2048 -------------|
129 (core2sbr delay ) ds (read, core and ds area)
130 */
131
132 #define SFB(dwnsmp) \
133 (32 << (dwnsmp - \
134 1)) /* SBR Frequency bands: 64 for dual-rate, 32 for single-rate */
135 #define STS(fl) \
136 (((fl) == 1024) ? 32 \
137 : 30) /* SBR Time Slots: 32 for core frame length 1024, 30 \
138 for core frame length 960 */
139
140 #define DELAY_QMF_ANA(dwnsmp) \
141 ((320 << ((dwnsmp)-1)) - (32 << ((dwnsmp)-1))) /* Full bandwidth */
142 #define DELAY_HYB_ANA (10 * 64) /* + 0.5 */ /* */
143 #define DELAY_HYB_SYN (6 * 64 - 32) /* */
144 #define DELAY_QMF_POSTPROC(dwnsmp) \
145 (32 * (dwnsmp)) /* QMF postprocessing delay */
146 #define DELAY_DEC_QMF(dwnsmp) (6 * SFB(dwnsmp)) /* Decoder QMF overlap */
147 #define DELAY_QMF_SYN(dwnsmp) \
148 (1 << (dwnsmp - \
149 1)) /* QMF_NO_POLY/2=2.5, rounded down to 2, half for single-rate */
150 #define DELAY_QMF_DS (32) /* QMF synthesis for downsampled time signal */
151
152 /* Delay in QMF paths */
153 #define DELAY_SBR(fl, dwnsmp) \
154 (DELAY_QMF_ANA(dwnsmp) + (SFB(dwnsmp) * STS(fl) - 1) + DELAY_QMF_SYN(dwnsmp))
155 #define DELAY_PS(fl, dwnsmp) \
156 (DELAY_QMF_ANA(dwnsmp) + DELAY_HYB_ANA + DELAY_DEC_QMF(dwnsmp) + \
157 (SFB(dwnsmp) * STS(fl) - 1) + DELAY_HYB_SYN + DELAY_QMF_SYN(dwnsmp))
158 #define DELAY_ELDSBR(fl, dwnsmp) \
159 ((((fl) / 2) * (dwnsmp)) - 1 + DELAY_QMF_POSTPROC(dwnsmp))
160 #define DELAY_ELDv2SBR(fl, dwnsmp) \
161 ((((fl) / 2) * (dwnsmp)) - 1 + 80 * (dwnsmp)) /* 80 is the delay caused \
162 by the sum of the CLD \
163 analysis and the MPSLD \
164 synthesis filterbank */
165
166 /* Delay in core path (core and downsampler not taken into account) */
167 #define DELAY_COREPATH_SBR(fl, dwnsmp) \
168 ((DELAY_QMF_ANA(dwnsmp) + DELAY_DEC_QMF(dwnsmp) + DELAY_QMF_SYN(dwnsmp)))
169 #define DELAY_COREPATH_ELDSBR(fl, dwnsmp) ((DELAY_QMF_POSTPROC(dwnsmp)))
170 #define DELAY_COREPATH_ELDv2SBR(fl, dwnsmp) (128 * (dwnsmp)) /* 4 slots */
171 #define DELAY_COREPATH_PS(fl, dwnsmp) \
172 ((DELAY_QMF_ANA(dwnsmp) + DELAY_QMF_DS + \
173 /*(DELAY_AAC(fl)*2) + */ DELAY_QMF_ANA(dwnsmp) + DELAY_DEC_QMF(dwnsmp) + \
174 DELAY_HYB_SYN + DELAY_QMF_SYN(dwnsmp))) /* 2048 - 463*2 */
175
176 /* Delay differences between SBR- and downsampled path for SBR and SBR+PS */
177 #define DELAY_AAC2SBR(fl, dwnsmp) \
178 ((DELAY_COREPATH_SBR(fl, dwnsmp)) - DELAY_SBR((fl), (dwnsmp)))
179 #define DELAY_ELD2SBR(fl, dwnsmp) \
180 ((DELAY_COREPATH_ELDSBR(fl, dwnsmp)) - DELAY_ELDSBR(fl, dwnsmp))
181 #define DELAY_AAC2PS(fl, dwnsmp) \
182 ((DELAY_COREPATH_PS(fl, dwnsmp)) - DELAY_PS(fl, dwnsmp)) /* 2048 - 463*2 */
183
184 /* Assumption: The sample delay resulting of of DELAY_AAC2PS is always smaller
185 * than the sample delay implied by DELAY_AAC2SBR */
186 #define MAX_DS_FILTER_DELAY \
187 (5) /* the additional max downsampler filter delay (source fs) */
188 #define MAX_SAMPLE_DELAY \
189 (DELAY_AAC2SBR(1024, 2) + MAX_DS_FILTER_DELAY) /* maximum delay: frame \
190 length of 1024 and \
191 dual-rate sbr */
192
193 /***************************************************************************/
194
195 /*************** Delay parameters for sbrEncoder_Init_delay() **************/
196 typedef struct {
197 int dsDelay; /* the delay of the (time-domain) downsampler itself */
198 int delay; /* overall delay / samples */
199 int sbrDecDelay; /* SBR decoder's delay */
200 int corePathOffset; /* core path offset / samples; added by
201 sbrEncoder_Init_delay() */
202 int sbrPathOffset; /* SBR path offset / samples; added by
203 sbrEncoder_Init_delay() */
204 int bitstrDelay; /* bitstream delay / frames; added by sbrEncoder_Init_delay()
205 */
206 int delayInput2Core; /* delay of the input to the core / samples */
207 } DELAY_PARAM;
208 /***************************************************************************/
209
210 #define INVALID_TABLE_IDX -1
211
212 /***************************************************************************/
213 /*!
214
215 \brief Selects the SBR tuning settings to use dependent on number of
216 channels, bitrate, sample rate and core coder
217
218 \return Index to the appropriate table
219
220 ****************************************************************************/
221 #define DISTANCE_CEIL_VALUE 5000000
getSbrTuningTableIndex(UINT bitrate,UINT numChannels,UINT sampleRate,AUDIO_OBJECT_TYPE core,UINT * pBitRateClosest)222 static INT getSbrTuningTableIndex(
223 UINT bitrate, /*! the total bitrate in bits/sec */
224 UINT numChannels, /*! the number of channels for the core coder */
225 UINT sampleRate, /*! the sampling rate of the core coder */
226 AUDIO_OBJECT_TYPE core, UINT *pBitRateClosest) {
227 int i, bitRateClosestLowerIndex = -1, bitRateClosestUpperIndex = -1,
228 found = 0;
229 UINT bitRateClosestUpper = 0, bitRateClosestLower = DISTANCE_CEIL_VALUE;
230
231 #define isForThisCore(i) \
232 ((sbrTuningTable[i].coreCoder == CODEC_AACLD && core == AOT_ER_AAC_ELD) || \
233 (sbrTuningTable[i].coreCoder == CODEC_AAC && core != AOT_ER_AAC_ELD))
234
235 for (i = 0; i < sbrTuningTableSize; i++) {
236 if (isForThisCore(i)) /* tuning table is for this core codec */
237 {
238 if (numChannels == sbrTuningTable[i].numChannels &&
239 sampleRate == sbrTuningTable[i].sampleRate) {
240 found = 1;
241 if ((bitrate >= sbrTuningTable[i].bitrateFrom) &&
242 (bitrate < sbrTuningTable[i].bitrateTo)) {
243 return i;
244 } else {
245 if (sbrTuningTable[i].bitrateFrom > bitrate) {
246 if (sbrTuningTable[i].bitrateFrom < bitRateClosestLower) {
247 bitRateClosestLower = sbrTuningTable[i].bitrateFrom;
248 bitRateClosestLowerIndex = i;
249 }
250 }
251 if (sbrTuningTable[i].bitrateTo <= bitrate) {
252 if (sbrTuningTable[i].bitrateTo > bitRateClosestUpper) {
253 bitRateClosestUpper = sbrTuningTable[i].bitrateTo - 1;
254 bitRateClosestUpperIndex = i;
255 }
256 }
257 }
258 }
259 }
260 }
261
262 if (bitRateClosestUpperIndex >= 0) {
263 return bitRateClosestUpperIndex;
264 }
265
266 if (pBitRateClosest != NULL) {
267 /* If there was at least one matching tuning entry pick the least distance
268 * bit rate */
269 if (found) {
270 int distanceUpper = DISTANCE_CEIL_VALUE,
271 distanceLower = DISTANCE_CEIL_VALUE;
272 if (bitRateClosestLowerIndex >= 0) {
273 distanceLower =
274 sbrTuningTable[bitRateClosestLowerIndex].bitrateFrom - bitrate;
275 }
276 if (bitRateClosestUpperIndex >= 0) {
277 distanceUpper =
278 bitrate - sbrTuningTable[bitRateClosestUpperIndex].bitrateTo;
279 }
280 if (distanceUpper < distanceLower) {
281 *pBitRateClosest = bitRateClosestUpper;
282 } else {
283 *pBitRateClosest = bitRateClosestLower;
284 }
285 } else {
286 *pBitRateClosest = 0;
287 }
288 }
289
290 return INVALID_TABLE_IDX;
291 }
292
293 /***************************************************************************/
294 /*!
295
296 \brief Selects the PS tuning settings to use dependent on bitrate
297 and core coder
298
299 \return Index to the appropriate table
300
301 ****************************************************************************/
getPsTuningTableIndex(UINT bitrate,UINT * pBitRateClosest)302 static INT getPsTuningTableIndex(UINT bitrate, UINT *pBitRateClosest) {
303 INT i, paramSets = sizeof(psTuningTable) / sizeof(psTuningTable[0]);
304 int bitRateClosestLowerIndex = -1, bitRateClosestUpperIndex = -1;
305 UINT bitRateClosestUpper = 0, bitRateClosestLower = DISTANCE_CEIL_VALUE;
306
307 for (i = 0; i < paramSets; i++) {
308 if ((bitrate >= psTuningTable[i].bitrateFrom) &&
309 (bitrate < psTuningTable[i].bitrateTo)) {
310 return i;
311 } else {
312 if (psTuningTable[i].bitrateFrom > bitrate) {
313 if (psTuningTable[i].bitrateFrom < bitRateClosestLower) {
314 bitRateClosestLower = psTuningTable[i].bitrateFrom;
315 bitRateClosestLowerIndex = i;
316 }
317 }
318 if (psTuningTable[i].bitrateTo <= bitrate) {
319 if (psTuningTable[i].bitrateTo > bitRateClosestUpper) {
320 bitRateClosestUpper = psTuningTable[i].bitrateTo - 1;
321 bitRateClosestUpperIndex = i;
322 }
323 }
324 }
325 }
326
327 if (bitRateClosestUpperIndex >= 0) {
328 return bitRateClosestUpperIndex;
329 }
330
331 if (pBitRateClosest != NULL) {
332 int distanceUpper = DISTANCE_CEIL_VALUE,
333 distanceLower = DISTANCE_CEIL_VALUE;
334 if (bitRateClosestLowerIndex >= 0) {
335 distanceLower =
336 sbrTuningTable[bitRateClosestLowerIndex].bitrateFrom - bitrate;
337 }
338 if (bitRateClosestUpperIndex >= 0) {
339 distanceUpper =
340 bitrate - sbrTuningTable[bitRateClosestUpperIndex].bitrateTo;
341 }
342 if (distanceUpper < distanceLower) {
343 *pBitRateClosest = bitRateClosestUpper;
344 } else {
345 *pBitRateClosest = bitRateClosestLower;
346 }
347 }
348
349 return INVALID_TABLE_IDX;
350 }
351
352 /***************************************************************************/
353 /*!
354
355 \brief In case of downsampled SBR we may need to lower the stop freq
356 of a tuning setting to fit into the lower half of the
357 spectrum ( which is sampleRate/4 )
358
359 \return the adapted stop frequency index (-1 -> error)
360
361 \ingroup SbrEncCfg
362
363 ****************************************************************************/
FDKsbrEnc_GetDownsampledStopFreq(const INT sampleRateCore,const INT startFreq,INT stopFreq,const INT downSampleFactor)364 static INT FDKsbrEnc_GetDownsampledStopFreq(const INT sampleRateCore,
365 const INT startFreq, INT stopFreq,
366 const INT downSampleFactor) {
367 INT maxStopFreqRaw = sampleRateCore / 2;
368 INT startBand, stopBand;
369 HANDLE_ERROR_INFO err;
370
371 while (stopFreq > 0 && FDKsbrEnc_getSbrStopFreqRAW(stopFreq, sampleRateCore) >
372 maxStopFreqRaw) {
373 stopFreq--;
374 }
375
376 if (FDKsbrEnc_getSbrStopFreqRAW(stopFreq, sampleRateCore) > maxStopFreqRaw)
377 return -1;
378
379 err = FDKsbrEnc_FindStartAndStopBand(
380 sampleRateCore << (downSampleFactor - 1), sampleRateCore,
381 32 << (downSampleFactor - 1), startFreq, stopFreq, &startBand, &stopBand);
382 if (err) return -1;
383
384 return stopFreq;
385 }
386
387 /***************************************************************************/
388 /*!
389
390 \brief tells us, if for the given coreCoder, bitrate, number of channels
391 and input sampling rate an SBR setting is available. If yes, it
392 tells us also the core sampling rate we would need to run with
393
394 \return a flag indicating success: yes (1) or no (0)
395
396 ****************************************************************************/
FDKsbrEnc_IsSbrSettingAvail(UINT bitrate,UINT vbrMode,UINT numOutputChannels,UINT sampleRateInput,UINT sampleRateCore,AUDIO_OBJECT_TYPE core)397 static UINT FDKsbrEnc_IsSbrSettingAvail(
398 UINT bitrate, /*! the total bitrate in bits/sec */
399 UINT vbrMode, /*! the vbr paramter, 0 means constant bitrate */
400 UINT numOutputChannels, /*! the number of channels for the core coder */
401 UINT sampleRateInput, /*! the input sample rate [in Hz] */
402 UINT sampleRateCore, /*! the core's sampling rate */
403 AUDIO_OBJECT_TYPE core) {
404 INT idx = INVALID_TABLE_IDX;
405
406 if (sampleRateInput < 16000) return 0;
407
408 if (bitrate == 0) {
409 /* map vbr quality to bitrate */
410 if (vbrMode < 30)
411 bitrate = 24000;
412 else if (vbrMode < 40)
413 bitrate = 28000;
414 else if (vbrMode < 60)
415 bitrate = 32000;
416 else if (vbrMode < 75)
417 bitrate = 40000;
418 else
419 bitrate = 48000;
420 bitrate *= numOutputChannels;
421 }
422
423 idx = getSbrTuningTableIndex(bitrate, numOutputChannels, sampleRateCore, core,
424 NULL);
425
426 return (idx == INVALID_TABLE_IDX ? 0 : 1);
427 }
428
429 /***************************************************************************/
430 /*!
431
432 \brief Adjusts the SBR settings according to the chosen core coder
433 settings which are accessible via config->codecSettings
434
435 \return A flag indicating success: yes (1) or no (0)
436
437 ****************************************************************************/
FDKsbrEnc_AdjustSbrSettings(const sbrConfigurationPtr config,UINT bitRate,UINT numChannels,UINT sampleRateCore,UINT sampleRateSbr,UINT transFac,UINT standardBitrate,UINT vbrMode,UINT useSpeechConfig,UINT lcsMode,UINT bParametricStereo,AUDIO_OBJECT_TYPE core)438 static UINT FDKsbrEnc_AdjustSbrSettings(
439 const sbrConfigurationPtr config, /*! output, modified */
440 UINT bitRate, /*! the total bitrate in bits/sec */
441 UINT numChannels, /*! the core coder number of channels */
442 UINT sampleRateCore, /*! the core coder sampling rate in Hz */
443 UINT sampleRateSbr, /*! the sbr coder sampling rate in Hz */
444 UINT transFac, /*! the short block to long block ratio */
445 UINT standardBitrate, /*! the standard bitrate per channel in bits/sec */
446 UINT vbrMode, /*! the vbr paramter, 0 poor quality .. 100 high quality*/
447 UINT useSpeechConfig, /*!< adapt tuning parameters for speech ? */
448 UINT lcsMode, /*! the low complexity stereo mode */
449 UINT bParametricStereo, /*!< use parametric stereo */
450 AUDIO_OBJECT_TYPE core) /* Core audio codec object type */
451 {
452 INT idx = INVALID_TABLE_IDX;
453 /* set the core codec settings */
454 config->codecSettings.bitRate = bitRate;
455 config->codecSettings.nChannels = numChannels;
456 config->codecSettings.sampleFreq = sampleRateCore;
457 config->codecSettings.transFac = transFac;
458 config->codecSettings.standardBitrate = standardBitrate;
459
460 if (bitRate < 28000) {
461 config->threshold_AmpRes_FF_m = (FIXP_DBL)MAXVAL_DBL;
462 config->threshold_AmpRes_FF_e = 7;
463 } else if (bitRate >= 28000 && bitRate <= 48000) {
464 /* The float threshold is 75
465 0.524288f is fractional part of RELAXATION, the quotaMatrix and therefore
466 tonality are scaled by this 2/3 is because the original implementation
467 divides the tonality values by 3, here it's divided by 2 128 compensates
468 the necessary shiftfactor of 7 */
469 config->threshold_AmpRes_FF_m =
470 FL2FXCONST_DBL(75.0f * 0.524288f / (2.0f / 3.0f) / 128.0f);
471 config->threshold_AmpRes_FF_e = 7;
472 } else if (bitRate > 48000) {
473 config->threshold_AmpRes_FF_m = FL2FXCONST_DBL(0);
474 config->threshold_AmpRes_FF_e = 0;
475 }
476
477 if (bitRate == 0) {
478 /* map vbr quality to bitrate */
479 if (vbrMode < 30)
480 bitRate = 24000;
481 else if (vbrMode < 40)
482 bitRate = 28000;
483 else if (vbrMode < 60)
484 bitRate = 32000;
485 else if (vbrMode < 75)
486 bitRate = 40000;
487 else
488 bitRate = 48000;
489 bitRate *= numChannels;
490 /* fix to enable mono vbrMode<40 @ 44.1 of 48kHz */
491 if (numChannels == 1) {
492 if (sampleRateSbr == 44100 || sampleRateSbr == 48000) {
493 if (vbrMode < 40) bitRate = 32000;
494 }
495 }
496 }
497
498 idx =
499 getSbrTuningTableIndex(bitRate, numChannels, sampleRateCore, core, NULL);
500
501 if (idx != INVALID_TABLE_IDX) {
502 config->startFreq = sbrTuningTable[idx].startFreq;
503 config->stopFreq = sbrTuningTable[idx].stopFreq;
504 if (useSpeechConfig) {
505 config->startFreq = sbrTuningTable[idx].startFreqSpeech;
506 config->stopFreq = sbrTuningTable[idx].stopFreqSpeech;
507 }
508
509 /* Adapt stop frequency in case of downsampled SBR - only 32 bands then */
510 if (1 == config->downSampleFactor) {
511 INT dsStopFreq = FDKsbrEnc_GetDownsampledStopFreq(
512 sampleRateCore, config->startFreq, config->stopFreq,
513 config->downSampleFactor);
514 if (dsStopFreq < 0) {
515 return 0;
516 }
517
518 config->stopFreq = dsStopFreq;
519 }
520
521 config->sbr_noise_bands = sbrTuningTable[idx].numNoiseBands;
522 if (core == AOT_ER_AAC_ELD) config->init_amp_res_FF = SBR_AMP_RES_1_5;
523 config->noiseFloorOffset = sbrTuningTable[idx].noiseFloorOffset;
524
525 config->ana_max_level = sbrTuningTable[idx].noiseMaxLevel;
526 config->stereoMode = sbrTuningTable[idx].stereoMode;
527 config->freqScale = sbrTuningTable[idx].freqScale;
528
529 if (numChannels == 1) {
530 /* stereo case */
531 switch (core) {
532 case AOT_AAC_LC:
533 if (bitRate <= (useSpeechConfig ? 24000U : 20000U)) {
534 config->freq_res_fixfix[0] = FREQ_RES_LOW; /* set low frequency
535 resolution for
536 non-split frames */
537 config->freq_res_fixfix[1] = FREQ_RES_LOW; /* set low frequency
538 resolution for split
539 frames */
540 }
541 break;
542 case AOT_ER_AAC_ELD:
543 if (bitRate < 36000)
544 config->freq_res_fixfix[1] = FREQ_RES_LOW; /* set low frequency
545 resolution for split
546 frames */
547 if (bitRate < 26000) {
548 config->freq_res_fixfix[0] = FREQ_RES_LOW; /* set low frequency
549 resolution for
550 non-split frames */
551 config->fResTransIsLow =
552 1; /* for transient frames, set low frequency resolution */
553 }
554 break;
555 default:
556 break;
557 }
558 } else {
559 /* stereo case */
560 switch (core) {
561 case AOT_AAC_LC:
562 if (bitRate <= 28000) {
563 config->freq_res_fixfix[0] = FREQ_RES_LOW; /* set low frequency
564 resolution for
565 non-split frames */
566 config->freq_res_fixfix[1] = FREQ_RES_LOW; /* set low frequency
567 resolution for split
568 frames */
569 }
570 break;
571 case AOT_ER_AAC_ELD:
572 if (bitRate < 72000) {
573 config->freq_res_fixfix[1] = FREQ_RES_LOW; /* set low frequency
574 resolution for split
575 frames */
576 }
577 if (bitRate < 52000) {
578 config->freq_res_fixfix[0] = FREQ_RES_LOW; /* set low frequency
579 resolution for
580 non-split frames */
581 config->fResTransIsLow =
582 1; /* for transient frames, set low frequency resolution */
583 }
584 break;
585 default:
586 break;
587 }
588 if (bitRate <= 28000) {
589 /*
590 additionally restrict frequency resolution in FIXFIX frames
591 to further reduce SBR payload size */
592 config->freq_res_fixfix[0] = FREQ_RES_LOW;
593 config->freq_res_fixfix[1] = FREQ_RES_LOW;
594 }
595 }
596
597 /* adjust usage of parametric coding dependent on bitrate and speech config
598 * flag */
599 if (useSpeechConfig) config->parametricCoding = 0;
600
601 if (core == AOT_ER_AAC_ELD) {
602 if (bitRate < 28000) config->init_amp_res_FF = SBR_AMP_RES_3_0;
603 config->SendHeaderDataTime = -1;
604 }
605
606 if (numChannels == 1) {
607 if (bitRate < 16000) {
608 config->parametricCoding = 0;
609 }
610 } else {
611 if (bitRate < 20000) {
612 config->parametricCoding = 0;
613 }
614 }
615
616 config->useSpeechConfig = useSpeechConfig;
617
618 /* PS settings */
619 config->bParametricStereo = bParametricStereo;
620
621 return 1;
622 } else {
623 return 0;
624 }
625 }
626
627 /*****************************************************************************
628
629 functionname: FDKsbrEnc_InitializeSbrDefaults
630 description: initializes the SBR configuration
631 returns: error status
632 input: - core codec type,
633 - factor of SBR to core frame length,
634 - core frame length
635 output: initialized SBR configuration
636
637 *****************************************************************************/
FDKsbrEnc_InitializeSbrDefaults(sbrConfigurationPtr config,INT downSampleFactor,UINT codecGranuleLen,const INT isLowDelay)638 static UINT FDKsbrEnc_InitializeSbrDefaults(sbrConfigurationPtr config,
639 INT downSampleFactor,
640 UINT codecGranuleLen,
641 const INT isLowDelay) {
642 if ((downSampleFactor < 1 || downSampleFactor > 2) ||
643 (codecGranuleLen * downSampleFactor > 64 * 32))
644 return (0); /* error */
645
646 config->SendHeaderDataTime = 1000;
647 config->useWaveCoding = 0;
648 config->crcSbr = 0;
649 config->dynBwSupported = 1;
650 if (isLowDelay)
651 config->tran_thr = 6000;
652 else
653 config->tran_thr = 13000;
654
655 config->parametricCoding = 1;
656
657 config->sbrFrameSize = codecGranuleLen * downSampleFactor;
658 config->downSampleFactor = downSampleFactor;
659
660 /* sbr default parameters */
661 config->sbr_data_extra = 0;
662 config->amp_res = SBR_AMP_RES_3_0;
663 config->tran_fc = 0;
664 config->tran_det_mode = 1;
665 config->spread = 1;
666 config->stat = 0;
667 config->e = 1;
668 config->deltaTAcrossFrames = 1;
669 config->dF_edge_1stEnv = FL2FXCONST_DBL(0.3f);
670 config->dF_edge_incr = FL2FXCONST_DBL(0.3f);
671
672 config->sbr_invf_mode = INVF_SWITCHED;
673 config->sbr_xpos_mode = XPOS_LC;
674 config->sbr_xpos_ctrl = SBR_XPOS_CTRL_DEFAULT;
675 config->sbr_xpos_level = 0;
676 config->useSaPan = 0;
677 config->dynBwEnabled = 0;
678
679 /* the following parameters are overwritten by the
680 FDKsbrEnc_AdjustSbrSettings() function since they are included in the
681 tuning table */
682 config->stereoMode = SBR_SWITCH_LRC;
683 config->ana_max_level = 6;
684 config->noiseFloorOffset = 0;
685 config->startFreq = 5; /* 5.9 respectively 6.0 kHz at fs = 44.1/48 kHz */
686 config->stopFreq = 9; /* 16.2 respectively 16.8 kHz at fs = 44.1/48 kHz */
687 config->freq_res_fixfix[0] = FREQ_RES_HIGH; /* non-split case */
688 config->freq_res_fixfix[1] = FREQ_RES_HIGH; /* split case */
689 config->fResTransIsLow = 0; /* for transient frames, set variable frequency
690 resolution according to freqResTable */
691
692 /* header_extra_1 */
693 config->freqScale = SBR_FREQ_SCALE_DEFAULT;
694 config->alterScale = SBR_ALTER_SCALE_DEFAULT;
695 config->sbr_noise_bands = SBR_NOISE_BANDS_DEFAULT;
696
697 /* header_extra_2 */
698 config->sbr_limiter_bands = SBR_LIMITER_BANDS_DEFAULT;
699 config->sbr_limiter_gains = SBR_LIMITER_GAINS_DEFAULT;
700 config->sbr_interpol_freq = SBR_INTERPOL_FREQ_DEFAULT;
701 config->sbr_smoothing_length = SBR_SMOOTHING_LENGTH_DEFAULT;
702
703 return 1;
704 }
705
706 /*****************************************************************************
707
708 functionname: DeleteEnvChannel
709 description: frees memory of one SBR channel
710 returns: -
711 input: handle of channel
712 output: released handle
713
714 *****************************************************************************/
deleteEnvChannel(HANDLE_ENV_CHANNEL hEnvCut)715 static void deleteEnvChannel(HANDLE_ENV_CHANNEL hEnvCut) {
716 if (hEnvCut) {
717 FDKsbrEnc_DeleteTonCorrParamExtr(&hEnvCut->TonCorr);
718
719 FDKsbrEnc_deleteExtractSbrEnvelope(&hEnvCut->sbrExtractEnvelope);
720 }
721 }
722
723 /*****************************************************************************
724
725 functionname: sbrEncoder_ChannelClose
726 description: close the channel coding handle
727 returns:
728 input: phSbrChannel
729 output:
730
731 *****************************************************************************/
sbrEncoder_ChannelClose(HANDLE_SBR_CHANNEL hSbrChannel)732 static void sbrEncoder_ChannelClose(HANDLE_SBR_CHANNEL hSbrChannel) {
733 if (hSbrChannel != NULL) {
734 deleteEnvChannel(&hSbrChannel->hEnvChannel);
735 }
736 }
737
738 /*****************************************************************************
739
740 functionname: sbrEncoder_ElementClose
741 description: close the channel coding handle
742 returns:
743 input: phSbrChannel
744 output:
745
746 *****************************************************************************/
sbrEncoder_ElementClose(HANDLE_SBR_ELEMENT * phSbrElement)747 static void sbrEncoder_ElementClose(HANDLE_SBR_ELEMENT *phSbrElement) {
748 HANDLE_SBR_ELEMENT hSbrElement = *phSbrElement;
749
750 if (hSbrElement != NULL) {
751 if (hSbrElement->sbrConfigData.v_k_master)
752 FreeRam_Sbr_v_k_master(&hSbrElement->sbrConfigData.v_k_master);
753 if (hSbrElement->sbrConfigData.freqBandTable[LO])
754 FreeRam_Sbr_freqBandTableLO(
755 &hSbrElement->sbrConfigData.freqBandTable[LO]);
756 if (hSbrElement->sbrConfigData.freqBandTable[HI])
757 FreeRam_Sbr_freqBandTableHI(
758 &hSbrElement->sbrConfigData.freqBandTable[HI]);
759
760 FreeRam_SbrElement(phSbrElement);
761 }
762 return;
763 }
764
sbrEncoder_Close(HANDLE_SBR_ENCODER * phSbrEncoder)765 void sbrEncoder_Close(HANDLE_SBR_ENCODER *phSbrEncoder) {
766 HANDLE_SBR_ENCODER hSbrEncoder = *phSbrEncoder;
767
768 if (hSbrEncoder != NULL) {
769 int el, ch;
770
771 for (el = 0; el < (8); el++) {
772 if (hSbrEncoder->sbrElement[el] != NULL) {
773 sbrEncoder_ElementClose(&hSbrEncoder->sbrElement[el]);
774 }
775 }
776
777 /* Close sbr Channels */
778 for (ch = 0; ch < (8); ch++) {
779 if (hSbrEncoder->pSbrChannel[ch]) {
780 sbrEncoder_ChannelClose(hSbrEncoder->pSbrChannel[ch]);
781 FreeRam_SbrChannel(&hSbrEncoder->pSbrChannel[ch]);
782 }
783
784 if (hSbrEncoder->QmfAnalysis[ch].FilterStates)
785 FreeRam_Sbr_QmfStatesAnalysis(
786 (FIXP_QAS **)&hSbrEncoder->QmfAnalysis[ch].FilterStates);
787 }
788
789 if (hSbrEncoder->hParametricStereo)
790 PSEnc_Destroy(&hSbrEncoder->hParametricStereo);
791 if (hSbrEncoder->qmfSynthesisPS.FilterStates)
792 FreeRam_PsQmfStatesSynthesis(
793 (FIXP_DBL **)&hSbrEncoder->qmfSynthesisPS.FilterStates);
794
795 /* Release Overlay */
796 if (hSbrEncoder->pSBRdynamic_RAM)
797 FreeRam_SbrDynamic_RAM((FIXP_DBL **)&hSbrEncoder->pSBRdynamic_RAM);
798
799 FreeRam_SbrEncoder(phSbrEncoder);
800 }
801 }
802
803 /*****************************************************************************
804
805 functionname: updateFreqBandTable
806 description: updates vk_master
807 returns: -
808 input: config handle
809 output: error info
810
811 *****************************************************************************/
updateFreqBandTable(HANDLE_SBR_CONFIG_DATA sbrConfigData,HANDLE_SBR_HEADER_DATA sbrHeaderData,const INT downSampleFactor)812 static INT updateFreqBandTable(HANDLE_SBR_CONFIG_DATA sbrConfigData,
813 HANDLE_SBR_HEADER_DATA sbrHeaderData,
814 const INT downSampleFactor) {
815 INT k0, k2;
816
817 if (FDKsbrEnc_FindStartAndStopBand(
818 sbrConfigData->sampleFreq,
819 sbrConfigData->sampleFreq >> (downSampleFactor - 1),
820 sbrConfigData->noQmfBands, sbrHeaderData->sbr_start_frequency,
821 sbrHeaderData->sbr_stop_frequency, &k0, &k2))
822 return (1);
823
824 if (FDKsbrEnc_UpdateFreqScale(
825 sbrConfigData->v_k_master, &sbrConfigData->num_Master, k0, k2,
826 sbrHeaderData->freqScale, sbrHeaderData->alterScale))
827 return (1);
828
829 sbrHeaderData->sbr_xover_band = 0;
830
831 if (FDKsbrEnc_UpdateHiRes(sbrConfigData->freqBandTable[HI],
832 &sbrConfigData->nSfb[HI], sbrConfigData->v_k_master,
833 sbrConfigData->num_Master,
834 &sbrHeaderData->sbr_xover_band))
835 return (1);
836
837 FDKsbrEnc_UpdateLoRes(
838 sbrConfigData->freqBandTable[LO], &sbrConfigData->nSfb[LO],
839 sbrConfigData->freqBandTable[HI], sbrConfigData->nSfb[HI]);
840
841 sbrConfigData->xOverFreq =
842 (sbrConfigData->freqBandTable[LOW_RES][0] * sbrConfigData->sampleFreq /
843 sbrConfigData->noQmfBands +
844 1) >>
845 1;
846
847 return (0);
848 }
849
850 /*****************************************************************************
851
852 functionname: resetEnvChannel
853 description: resets parameters and allocates memory
854 returns: error status
855 input:
856 output: hEnv
857
858 *****************************************************************************/
resetEnvChannel(HANDLE_SBR_CONFIG_DATA sbrConfigData,HANDLE_SBR_HEADER_DATA sbrHeaderData,HANDLE_ENV_CHANNEL hEnv)859 static INT resetEnvChannel(HANDLE_SBR_CONFIG_DATA sbrConfigData,
860 HANDLE_SBR_HEADER_DATA sbrHeaderData,
861 HANDLE_ENV_CHANNEL hEnv) {
862 /* note !!! hEnv->encEnvData.noOfnoisebands will be updated later in function
863 * FDKsbrEnc_extractSbrEnvelope !!!*/
864 hEnv->TonCorr.sbrNoiseFloorEstimate.noiseBands =
865 sbrHeaderData->sbr_noise_bands;
866
867 if (FDKsbrEnc_ResetTonCorrParamExtr(
868 &hEnv->TonCorr, sbrConfigData->xposCtrlSwitch,
869 sbrConfigData->freqBandTable[HI][0], sbrConfigData->v_k_master,
870 sbrConfigData->num_Master, sbrConfigData->sampleFreq,
871 sbrConfigData->freqBandTable, sbrConfigData->nSfb,
872 sbrConfigData->noQmfBands))
873 return (1);
874
875 hEnv->sbrCodeNoiseFloor.nSfb[LO] =
876 hEnv->TonCorr.sbrNoiseFloorEstimate.noNoiseBands;
877 hEnv->sbrCodeNoiseFloor.nSfb[HI] =
878 hEnv->TonCorr.sbrNoiseFloorEstimate.noNoiseBands;
879
880 hEnv->sbrCodeEnvelope.nSfb[LO] = sbrConfigData->nSfb[LO];
881 hEnv->sbrCodeEnvelope.nSfb[HI] = sbrConfigData->nSfb[HI];
882
883 hEnv->encEnvData.noHarmonics = sbrConfigData->nSfb[HI];
884
885 hEnv->sbrCodeEnvelope.upDate = 0;
886 hEnv->sbrCodeNoiseFloor.upDate = 0;
887
888 return (0);
889 }
890
891 /* ****************************** FDKsbrEnc_SbrGetXOverFreq
892 * ******************************/
893 /**
894 * @fn
895 * @brief calculates the closest possible crossover frequency
896 * @return the crossover frequency SBR accepts
897 *
898 */
FDKsbrEnc_SbrGetXOverFreq(HANDLE_SBR_ELEMENT hEnv,INT xoverFreq)899 static INT FDKsbrEnc_SbrGetXOverFreq(
900 HANDLE_SBR_ELEMENT hEnv, /*!< handle to SBR encoder instance */
901 INT xoverFreq) /*!< from core coder suggested crossover frequency */
902 {
903 INT band;
904 INT lastDiff, newDiff;
905 INT cutoffSb;
906
907 UCHAR *RESTRICT pVKMaster = hEnv->sbrConfigData.v_k_master;
908
909 /* Check if there is a matching cutoff frequency in the master table */
910 cutoffSb = (4 * xoverFreq * hEnv->sbrConfigData.noQmfBands /
911 hEnv->sbrConfigData.sampleFreq +
912 1) >>
913 1;
914 lastDiff = cutoffSb;
915 for (band = 0; band < hEnv->sbrConfigData.num_Master; band++) {
916 newDiff = fixp_abs((INT)pVKMaster[band] - cutoffSb);
917
918 if (newDiff >= lastDiff) {
919 band--;
920 break;
921 }
922
923 lastDiff = newDiff;
924 }
925
926 return ((pVKMaster[band] * hEnv->sbrConfigData.sampleFreq /
927 hEnv->sbrConfigData.noQmfBands +
928 1) >>
929 1);
930 }
931
932 /*****************************************************************************
933
934 functionname: FDKsbrEnc_EnvEncodeFrame
935 description: performs the sbr envelope calculation for one element
936 returns:
937 input:
938 output:
939
940 *****************************************************************************/
FDKsbrEnc_EnvEncodeFrame(HANDLE_SBR_ENCODER hEnvEncoder,int iElement,INT_PCM * samples,UINT samplesBufSize,UINT * sbrDataBits,UCHAR * sbrData,int clearOutput)941 INT FDKsbrEnc_EnvEncodeFrame(
942 HANDLE_SBR_ENCODER hEnvEncoder, int iElement,
943 INT_PCM *samples, /*!< time samples, always deinterleaved */
944 UINT samplesBufSize, /*!< time buffer channel stride */
945 UINT *sbrDataBits, /*!< Size of SBR payload */
946 UCHAR *sbrData, /*!< SBR payload */
947 int clearOutput /*!< Do not consider any input signal */
948 ) {
949 HANDLE_SBR_ELEMENT hSbrElement = NULL;
950 FDK_CRCINFO crcInfo;
951 INT crcReg;
952 INT ch;
953 INT band;
954 INT cutoffSb;
955 INT newXOver;
956
957 if (hEnvEncoder == NULL) return -1;
958
959 hSbrElement = hEnvEncoder->sbrElement[iElement];
960
961 if (hSbrElement == NULL) return -1;
962
963 /* header bitstream handling */
964 HANDLE_SBR_BITSTREAM_DATA sbrBitstreamData = &hSbrElement->sbrBitstreamData;
965
966 INT psHeaderActive = 0;
967 sbrBitstreamData->HeaderActive = 0;
968
969 /* Anticipate PS header because of internal PS bitstream delay in order to be
970 * in sync with SBR header. */
971 if (sbrBitstreamData->CountSendHeaderData ==
972 (sbrBitstreamData->NrSendHeaderData - 1)) {
973 psHeaderActive = 1;
974 }
975
976 /* Signal SBR header to be written into bitstream */
977 if (sbrBitstreamData->CountSendHeaderData == 0) {
978 sbrBitstreamData->HeaderActive = 1;
979 }
980
981 /* Increment header interval counter */
982 if (sbrBitstreamData->NrSendHeaderData == 0) {
983 sbrBitstreamData->CountSendHeaderData = 1;
984 } else {
985 if (sbrBitstreamData->CountSendHeaderData >= 0) {
986 sbrBitstreamData->CountSendHeaderData++;
987 sbrBitstreamData->CountSendHeaderData %=
988 sbrBitstreamData->NrSendHeaderData;
989 }
990 }
991
992 if (hSbrElement->CmonData.dynBwEnabled) {
993 INT i;
994 for (i = 4; i > 0; i--)
995 hSbrElement->dynXOverFreqDelay[i] = hSbrElement->dynXOverFreqDelay[i - 1];
996
997 hSbrElement->dynXOverFreqDelay[0] = hSbrElement->CmonData.dynXOverFreqEnc;
998 if (hSbrElement->dynXOverFreqDelay[1] > hSbrElement->dynXOverFreqDelay[2])
999 newXOver = hSbrElement->dynXOverFreqDelay[2];
1000 else
1001 newXOver = hSbrElement->dynXOverFreqDelay[1];
1002
1003 /* has the crossover frequency changed? */
1004 if (hSbrElement->sbrConfigData.dynXOverFreq != newXOver) {
1005 /* get corresponding master band */
1006 cutoffSb = ((4 * newXOver * hSbrElement->sbrConfigData.noQmfBands /
1007 hSbrElement->sbrConfigData.sampleFreq) +
1008 1) >>
1009 1;
1010
1011 for (band = 0; band < hSbrElement->sbrConfigData.num_Master; band++) {
1012 if (cutoffSb == hSbrElement->sbrConfigData.v_k_master[band]) break;
1013 }
1014 FDK_ASSERT(band < hSbrElement->sbrConfigData.num_Master);
1015
1016 hSbrElement->sbrConfigData.dynXOverFreq = newXOver;
1017 hSbrElement->sbrHeaderData.sbr_xover_band = band;
1018 hSbrElement->sbrBitstreamData.HeaderActive = 1;
1019 psHeaderActive = 1; /* ps header is one frame delayed */
1020
1021 /*
1022 update vk_master table
1023 */
1024 if (updateFreqBandTable(&hSbrElement->sbrConfigData,
1025 &hSbrElement->sbrHeaderData,
1026 hEnvEncoder->downSampleFactor))
1027 return (1);
1028
1029 /* reset SBR channels */
1030 INT nEnvCh = hSbrElement->sbrConfigData.nChannels;
1031 for (ch = 0; ch < nEnvCh; ch++) {
1032 if (resetEnvChannel(&hSbrElement->sbrConfigData,
1033 &hSbrElement->sbrHeaderData,
1034 &hSbrElement->sbrChannel[ch]->hEnvChannel))
1035 return (1);
1036 }
1037 }
1038 }
1039
1040 /*
1041 allocate space for dummy header and crc
1042 */
1043 crcReg = FDKsbrEnc_InitSbrBitstream(
1044 &hSbrElement->CmonData,
1045 hSbrElement->payloadDelayLine[hEnvEncoder->nBitstrDelay],
1046 MAX_PAYLOAD_SIZE * sizeof(UCHAR), &crcInfo,
1047 hSbrElement->sbrConfigData.sbrSyntaxFlags);
1048
1049 /* Temporal Envelope Data */
1050 SBR_FRAME_TEMP_DATA _fData;
1051 SBR_FRAME_TEMP_DATA *fData = &_fData;
1052 SBR_ENV_TEMP_DATA eData[MAX_NUM_CHANNELS];
1053
1054 /* Init Temporal Envelope Data */
1055 {
1056 int i;
1057
1058 FDKmemclear(&eData[0], sizeof(SBR_ENV_TEMP_DATA));
1059 FDKmemclear(&eData[1], sizeof(SBR_ENV_TEMP_DATA));
1060 FDKmemclear(fData, sizeof(SBR_FRAME_TEMP_DATA));
1061
1062 for (i = 0; i < MAX_NUM_NOISE_VALUES; i++) fData->res[i] = FREQ_RES_HIGH;
1063 }
1064
1065 if (!clearOutput) {
1066 /*
1067 * Transform audio data into QMF domain
1068 */
1069 for (ch = 0; ch < hSbrElement->sbrConfigData.nChannels; ch++) {
1070 HANDLE_ENV_CHANNEL h_envChan = &hSbrElement->sbrChannel[ch]->hEnvChannel;
1071 HANDLE_SBR_EXTRACT_ENVELOPE sbrExtrEnv = &h_envChan->sbrExtractEnvelope;
1072
1073 if (hSbrElement->elInfo.fParametricStereo == 0) {
1074 QMF_SCALE_FACTOR tmpScale;
1075 FIXP_DBL **pQmfReal, **pQmfImag;
1076 C_AALLOC_SCRATCH_START(qmfWorkBuffer, FIXP_DBL, 64 * 2)
1077
1078 /* Obtain pointers to QMF buffers. */
1079 pQmfReal = sbrExtrEnv->rBuffer;
1080 pQmfImag = sbrExtrEnv->iBuffer;
1081
1082 qmfAnalysisFiltering(
1083 hSbrElement->hQmfAnalysis[ch], pQmfReal, pQmfImag, &tmpScale,
1084 samples + hSbrElement->elInfo.ChannelIndex[ch] * samplesBufSize, 0,
1085 1, qmfWorkBuffer);
1086
1087 h_envChan->qmfScale = tmpScale.lb_scale + 7;
1088
1089 C_AALLOC_SCRATCH_END(qmfWorkBuffer, FIXP_DBL, 64 * 2)
1090
1091 } /* fParametricStereo == 0 */
1092
1093 /*
1094 Parametric Stereo processing
1095 */
1096 if (hSbrElement->elInfo.fParametricStereo) {
1097 INT error = noError;
1098
1099 /* Limit Parametric Stereo to one instance */
1100 FDK_ASSERT(ch == 0);
1101
1102 if (error == noError) {
1103 /* parametric stereo processing:
1104 - input:
1105 o left and right time domain samples
1106 - processing:
1107 o stereo qmf analysis
1108 o stereo hybrid analysis
1109 o ps parameter extraction
1110 o downmix + hybrid synthesis
1111 - output:
1112 o downmixed qmf data is written to sbrExtrEnv->rBuffer and
1113 sbrExtrEnv->iBuffer
1114 */
1115 SCHAR qmfScale;
1116 INT_PCM *pSamples[2] = {
1117 samples + hSbrElement->elInfo.ChannelIndex[0] * samplesBufSize,
1118 samples + hSbrElement->elInfo.ChannelIndex[1] * samplesBufSize};
1119 error = FDKsbrEnc_PSEnc_ParametricStereoProcessing(
1120 hEnvEncoder->hParametricStereo, pSamples, samplesBufSize,
1121 hSbrElement->hQmfAnalysis, sbrExtrEnv->rBuffer,
1122 sbrExtrEnv->iBuffer,
1123 samples + hSbrElement->elInfo.ChannelIndex[ch] * samplesBufSize,
1124 &hEnvEncoder->qmfSynthesisPS, &qmfScale, psHeaderActive);
1125 h_envChan->qmfScale = (int)qmfScale;
1126 }
1127
1128 } /* if (hEnvEncoder->hParametricStereo) */
1129
1130 /*
1131
1132 Extract Envelope relevant things from QMF data
1133
1134 */
1135 FDKsbrEnc_extractSbrEnvelope1(&hSbrElement->sbrConfigData,
1136 &hSbrElement->sbrHeaderData,
1137 &hSbrElement->sbrBitstreamData, h_envChan,
1138 &hSbrElement->CmonData, &eData[ch], fData);
1139
1140 } /* hEnvEncoder->sbrConfigData.nChannels */
1141 }
1142
1143 /*
1144 Process Envelope relevant things and calculate envelope data and write
1145 payload
1146 */
1147 FDKsbrEnc_extractSbrEnvelope2(
1148 &hSbrElement->sbrConfigData, &hSbrElement->sbrHeaderData,
1149 (hSbrElement->elInfo.fParametricStereo) ? hEnvEncoder->hParametricStereo
1150 : NULL,
1151 &hSbrElement->sbrBitstreamData, &hSbrElement->sbrChannel[0]->hEnvChannel,
1152 (hSbrElement->sbrConfigData.stereoMode != SBR_MONO)
1153 ? &hSbrElement->sbrChannel[1]->hEnvChannel
1154 : NULL,
1155 &hSbrElement->CmonData, eData, fData, clearOutput);
1156
1157 hSbrElement->sbrBitstreamData.rightBorderFIX = 0;
1158
1159 /*
1160 format payload, calculate crc
1161 */
1162 FDKsbrEnc_AssembleSbrBitstream(&hSbrElement->CmonData, &crcInfo, crcReg,
1163 hSbrElement->sbrConfigData.sbrSyntaxFlags);
1164
1165 /*
1166 save new payload, set to zero length if greater than MAX_PAYLOAD_SIZE
1167 */
1168 hSbrElement->payloadDelayLineSize[hEnvEncoder->nBitstrDelay] =
1169 FDKgetValidBits(&hSbrElement->CmonData.sbrBitbuf);
1170
1171 if (hSbrElement->payloadDelayLineSize[hEnvEncoder->nBitstrDelay] >
1172 (MAX_PAYLOAD_SIZE << 3))
1173 hSbrElement->payloadDelayLineSize[hEnvEncoder->nBitstrDelay] = 0;
1174
1175 /* While filling the Delay lines, sbrData is NULL */
1176 if (sbrData) {
1177 *sbrDataBits = hSbrElement->payloadDelayLineSize[0];
1178 FDKmemcpy(sbrData, hSbrElement->payloadDelayLine[0],
1179 (hSbrElement->payloadDelayLineSize[0] + 7) >> 3);
1180 }
1181
1182 /* delay header active flag */
1183 if (hSbrElement->sbrBitstreamData.HeaderActive == 1) {
1184 hSbrElement->sbrBitstreamData.HeaderActiveDelay =
1185 1 + hEnvEncoder->nBitstrDelay;
1186 } else {
1187 if (hSbrElement->sbrBitstreamData.HeaderActiveDelay > 0) {
1188 hSbrElement->sbrBitstreamData.HeaderActiveDelay--;
1189 }
1190 }
1191
1192 return (0);
1193 }
1194
1195 /*****************************************************************************
1196
1197 functionname: FDKsbrEnc_Downsample
1198 description: performs downsampling and delay compensation of the core path
1199 returns:
1200 input:
1201 output:
1202
1203 *****************************************************************************/
FDKsbrEnc_Downsample(HANDLE_SBR_ENCODER hSbrEncoder,INT_PCM * samples,UINT samplesBufSize,UINT numChannels,UINT * sbrDataBits,UCHAR * sbrData,int clearOutput)1204 INT FDKsbrEnc_Downsample(
1205 HANDLE_SBR_ENCODER hSbrEncoder,
1206 INT_PCM *samples, /*!< time samples, always deinterleaved */
1207 UINT samplesBufSize, /*!< time buffer size per channel */
1208 UINT numChannels, /*!< number of channels */
1209 UINT *sbrDataBits, /*!< Size of SBR payload */
1210 UCHAR *sbrData, /*!< SBR payload */
1211 int clearOutput /*!< Do not consider any input signal */
1212 ) {
1213 HANDLE_SBR_ELEMENT hSbrElement = NULL;
1214 INT nOutSamples;
1215 int el;
1216 if (hSbrEncoder->downSampleFactor > 1) {
1217 /* Do downsampling */
1218
1219 /* Loop over elements (LFE is handled later) */
1220 for (el = 0; el < hSbrEncoder->noElements; el++) {
1221 hSbrElement = hSbrEncoder->sbrElement[el];
1222 if (hSbrEncoder->sbrElement[el] != NULL) {
1223 if (hSbrEncoder->downsamplingMethod == SBRENC_DS_TIME) {
1224 int ch;
1225 int nChannels = hSbrElement->sbrConfigData.nChannels;
1226
1227 for (ch = 0; ch < nChannels; ch++) {
1228 FDKaacEnc_Downsample(
1229 &hSbrElement->sbrChannel[ch]->downSampler,
1230 samples +
1231 hSbrElement->elInfo.ChannelIndex[ch] * samplesBufSize +
1232 hSbrEncoder->bufferOffset / numChannels,
1233 hSbrElement->sbrConfigData.frameSize,
1234 samples + hSbrElement->elInfo.ChannelIndex[ch] * samplesBufSize,
1235 &nOutSamples);
1236 }
1237 }
1238 }
1239 }
1240
1241 /* Handle LFE (if existing) */
1242 if (hSbrEncoder->lfeChIdx != -1) { /* lfe downsampler */
1243 FDKaacEnc_Downsample(&hSbrEncoder->lfeDownSampler,
1244 samples + hSbrEncoder->lfeChIdx * samplesBufSize +
1245 hSbrEncoder->bufferOffset / numChannels,
1246 hSbrEncoder->frameSize,
1247 samples + hSbrEncoder->lfeChIdx * samplesBufSize,
1248 &nOutSamples);
1249 }
1250 } else {
1251 /* No downsampling. Still, some buffer shifting for correct delay */
1252 int samples2Copy = hSbrEncoder->frameSize;
1253 if (hSbrEncoder->bufferOffset / (int)numChannels < samples2Copy) {
1254 for (int c = 0; c < (int)numChannels; c++) {
1255 /* Do memmove while taking care of overlapping memory areas. (memcpy
1256 does not necessarily take care) Distinguish between oeverlapping and
1257 non overlapping version due to reasons of complexity. */
1258 FDKmemmove(samples + c * samplesBufSize,
1259 samples + c * samplesBufSize +
1260 hSbrEncoder->bufferOffset / numChannels,
1261 samples2Copy * sizeof(INT_PCM));
1262 }
1263 } else {
1264 for (int c = 0; c < (int)numChannels; c++) {
1265 /* Simple memcpy since the memory areas are not overlapping */
1266 FDKmemcpy(samples + c * samplesBufSize,
1267 samples + c * samplesBufSize +
1268 hSbrEncoder->bufferOffset / numChannels,
1269 samples2Copy * sizeof(INT_PCM));
1270 }
1271 }
1272 }
1273
1274 return 0;
1275 }
1276
1277 /*****************************************************************************
1278
1279 functionname: createEnvChannel
1280 description: initializes parameters and allocates memory
1281 returns: error status
1282 input:
1283 output: hEnv
1284
1285 *****************************************************************************/
1286
createEnvChannel(HANDLE_ENV_CHANNEL hEnv,INT channel,UCHAR * dynamic_RAM)1287 static INT createEnvChannel(HANDLE_ENV_CHANNEL hEnv, INT channel,
1288 UCHAR *dynamic_RAM) {
1289 FDKmemclear(hEnv, sizeof(struct ENV_CHANNEL));
1290
1291 if (FDKsbrEnc_CreateTonCorrParamExtr(&hEnv->TonCorr, channel)) {
1292 return (1);
1293 }
1294
1295 if (FDKsbrEnc_CreateExtractSbrEnvelope(&hEnv->sbrExtractEnvelope, channel,
1296 /*chan*/ 0, dynamic_RAM)) {
1297 return (1);
1298 }
1299
1300 return 0;
1301 }
1302
1303 /*****************************************************************************
1304
1305 functionname: initEnvChannel
1306 description: initializes parameters
1307 returns: error status
1308 input:
1309 output:
1310
1311 *****************************************************************************/
initEnvChannel(HANDLE_SBR_CONFIG_DATA sbrConfigData,HANDLE_SBR_HEADER_DATA sbrHeaderData,HANDLE_ENV_CHANNEL hEnv,sbrConfigurationPtr params,ULONG statesInitFlag,INT chanInEl,UCHAR * dynamic_RAM)1312 static INT initEnvChannel(HANDLE_SBR_CONFIG_DATA sbrConfigData,
1313 HANDLE_SBR_HEADER_DATA sbrHeaderData,
1314 HANDLE_ENV_CHANNEL hEnv, sbrConfigurationPtr params,
1315 ULONG statesInitFlag, INT chanInEl,
1316 UCHAR *dynamic_RAM) {
1317 int frameShift, tran_off = 0;
1318 INT e;
1319 INT tran_fc;
1320 INT timeSlots, timeStep, startIndex;
1321 INT noiseBands[2] = {3, 3};
1322
1323 e = 1 << params->e;
1324
1325 FDK_ASSERT(params->e >= 0);
1326
1327 hEnv->encEnvData.freq_res_fixfix[0] = params->freq_res_fixfix[0];
1328 hEnv->encEnvData.freq_res_fixfix[1] = params->freq_res_fixfix[1];
1329 hEnv->encEnvData.fResTransIsLow = params->fResTransIsLow;
1330
1331 hEnv->fLevelProtect = 0;
1332
1333 hEnv->encEnvData.ldGrid =
1334 (sbrConfigData->sbrSyntaxFlags & SBR_SYNTAX_LOW_DELAY) ? 1 : 0;
1335
1336 hEnv->encEnvData.sbr_xpos_mode = (XPOS_MODE)params->sbr_xpos_mode;
1337
1338 if (hEnv->encEnvData.sbr_xpos_mode == XPOS_SWITCHED) {
1339 /*
1340 no other type than XPOS_MDCT or XPOS_SPEECH allowed,
1341 but enable switching
1342 */
1343 sbrConfigData->switchTransposers = TRUE;
1344 hEnv->encEnvData.sbr_xpos_mode = XPOS_MDCT;
1345 } else {
1346 sbrConfigData->switchTransposers = FALSE;
1347 }
1348
1349 hEnv->encEnvData.sbr_xpos_ctrl = params->sbr_xpos_ctrl;
1350
1351 /* extended data */
1352 if (params->parametricCoding) {
1353 hEnv->encEnvData.extended_data = 1;
1354 } else {
1355 hEnv->encEnvData.extended_data = 0;
1356 }
1357
1358 hEnv->encEnvData.extension_size = 0;
1359
1360 startIndex = QMF_FILTER_PROTOTYPE_SIZE - sbrConfigData->noQmfBands;
1361
1362 switch (params->sbrFrameSize) {
1363 case 2304:
1364 timeSlots = 18;
1365 break;
1366 case 2048:
1367 case 1024:
1368 case 512:
1369 timeSlots = 16;
1370 break;
1371 case 1920:
1372 case 960:
1373 case 480:
1374 timeSlots = 15;
1375 break;
1376 case 1152:
1377 timeSlots = 9;
1378 break;
1379 default:
1380 return (1); /* Illegal frame size */
1381 }
1382
1383 timeStep = sbrConfigData->noQmfSlots / timeSlots;
1384
1385 if (FDKsbrEnc_InitTonCorrParamExtr(
1386 params->sbrFrameSize, &hEnv->TonCorr, sbrConfigData, timeSlots,
1387 params->sbr_xpos_ctrl, params->ana_max_level,
1388 sbrHeaderData->sbr_noise_bands, params->noiseFloorOffset,
1389 params->useSpeechConfig))
1390 return (1);
1391
1392 hEnv->encEnvData.noOfnoisebands =
1393 hEnv->TonCorr.sbrNoiseFloorEstimate.noNoiseBands;
1394
1395 noiseBands[0] = hEnv->encEnvData.noOfnoisebands;
1396 noiseBands[1] = hEnv->encEnvData.noOfnoisebands;
1397
1398 hEnv->encEnvData.sbr_invf_mode = (INVF_MODE)params->sbr_invf_mode;
1399
1400 if (hEnv->encEnvData.sbr_invf_mode == INVF_SWITCHED) {
1401 hEnv->encEnvData.sbr_invf_mode = INVF_MID_LEVEL;
1402 hEnv->TonCorr.switchInverseFilt = TRUE;
1403 } else {
1404 hEnv->TonCorr.switchInverseFilt = FALSE;
1405 }
1406
1407 tran_fc = params->tran_fc;
1408
1409 if (tran_fc == 0) {
1410 tran_fc = fixMin(
1411 5000, FDKsbrEnc_getSbrStartFreqRAW(sbrHeaderData->sbr_start_frequency,
1412 params->codecSettings.sampleFreq));
1413 }
1414
1415 tran_fc =
1416 (tran_fc * 4 * sbrConfigData->noQmfBands / sbrConfigData->sampleFreq +
1417 1) >>
1418 1;
1419
1420 if (sbrConfigData->sbrSyntaxFlags & SBR_SYNTAX_LOW_DELAY) {
1421 frameShift = LD_PRETRAN_OFF;
1422 tran_off = LD_PRETRAN_OFF + FRAME_MIDDLE_SLOT_512LD * timeStep;
1423 } else {
1424 frameShift = 0;
1425 switch (timeSlots) {
1426 /* The factor of 2 is by definition. */
1427 case NUMBER_TIME_SLOTS_2048:
1428 tran_off = 8 + FRAME_MIDDLE_SLOT_2048 * timeStep;
1429 break;
1430 case NUMBER_TIME_SLOTS_1920:
1431 tran_off = 7 + FRAME_MIDDLE_SLOT_1920 * timeStep;
1432 break;
1433 default:
1434 return 1;
1435 }
1436 }
1437 if (FDKsbrEnc_InitExtractSbrEnvelope(
1438 &hEnv->sbrExtractEnvelope, sbrConfigData->noQmfSlots,
1439 sbrConfigData->noQmfBands, startIndex, timeSlots, timeStep, tran_off,
1440 statesInitFlag, chanInEl, dynamic_RAM, sbrConfigData->sbrSyntaxFlags))
1441 return (1);
1442
1443 if (FDKsbrEnc_InitSbrCodeEnvelope(&hEnv->sbrCodeEnvelope, sbrConfigData->nSfb,
1444 params->deltaTAcrossFrames,
1445 params->dF_edge_1stEnv,
1446 params->dF_edge_incr))
1447 return (1);
1448
1449 if (FDKsbrEnc_InitSbrCodeEnvelope(&hEnv->sbrCodeNoiseFloor, noiseBands,
1450 params->deltaTAcrossFrames, 0, 0))
1451 return (1);
1452
1453 sbrConfigData->initAmpResFF = params->init_amp_res_FF;
1454
1455 if (FDKsbrEnc_InitSbrHuffmanTables(&hEnv->encEnvData, &hEnv->sbrCodeEnvelope,
1456 &hEnv->sbrCodeNoiseFloor,
1457 sbrHeaderData->sbr_amp_res))
1458 return (1);
1459
1460 FDKsbrEnc_initFrameInfoGenerator(
1461 &hEnv->SbrEnvFrame, params->spread, e, params->stat, timeSlots,
1462 hEnv->encEnvData.freq_res_fixfix, hEnv->encEnvData.fResTransIsLow,
1463 hEnv->encEnvData.ldGrid);
1464
1465 if (sbrConfigData->sbrSyntaxFlags & SBR_SYNTAX_LOW_DELAY)
1466
1467 {
1468 INT bandwidth_qmf_slot =
1469 (sbrConfigData->sampleFreq >> 1) / (sbrConfigData->noQmfBands);
1470 if (FDKsbrEnc_InitSbrFastTransientDetector(
1471 &hEnv->sbrFastTransientDetector, sbrConfigData->noQmfSlots,
1472 bandwidth_qmf_slot, sbrConfigData->noQmfBands,
1473 sbrConfigData->freqBandTable[0][0]))
1474 return (1);
1475 }
1476
1477 /* The transient detector has to be initialized also if the fast transient
1478 detector was active, because the values from the transient detector
1479 structure are used. */
1480 if (FDKsbrEnc_InitSbrTransientDetector(
1481 &hEnv->sbrTransientDetector, sbrConfigData->sbrSyntaxFlags,
1482 sbrConfigData->frameSize, sbrConfigData->sampleFreq, params, tran_fc,
1483 sbrConfigData->noQmfSlots, sbrConfigData->noQmfBands,
1484 hEnv->sbrExtractEnvelope.YBufferWriteOffset,
1485 hEnv->sbrExtractEnvelope.YBufferSzShift, frameShift, tran_off))
1486 return (1);
1487
1488 sbrConfigData->xposCtrlSwitch = params->sbr_xpos_ctrl;
1489
1490 hEnv->encEnvData.noHarmonics = sbrConfigData->nSfb[HI];
1491 hEnv->encEnvData.addHarmonicFlag = 0;
1492
1493 return (0);
1494 }
1495
sbrEncoder_Open(HANDLE_SBR_ENCODER * phSbrEncoder,INT nElements,INT nChannels,INT supportPS)1496 INT sbrEncoder_Open(HANDLE_SBR_ENCODER *phSbrEncoder, INT nElements,
1497 INT nChannels, INT supportPS) {
1498 INT i;
1499 INT errorStatus = 1;
1500 HANDLE_SBR_ENCODER hSbrEncoder = NULL;
1501
1502 if (phSbrEncoder == NULL) {
1503 goto bail;
1504 }
1505
1506 hSbrEncoder = GetRam_SbrEncoder();
1507 if (hSbrEncoder == NULL) {
1508 goto bail;
1509 }
1510 FDKmemclear(hSbrEncoder, sizeof(SBR_ENCODER));
1511
1512 if (NULL ==
1513 (hSbrEncoder->pSBRdynamic_RAM = (UCHAR *)GetRam_SbrDynamic_RAM())) {
1514 goto bail;
1515 }
1516 hSbrEncoder->dynamicRam = hSbrEncoder->pSBRdynamic_RAM;
1517
1518 /* Create SBR elements */
1519 for (i = 0; i < nElements; i++) {
1520 hSbrEncoder->sbrElement[i] = GetRam_SbrElement(i);
1521 if (hSbrEncoder->sbrElement[i] == NULL) {
1522 goto bail;
1523 }
1524 FDKmemclear(hSbrEncoder->sbrElement[i], sizeof(SBR_ELEMENT));
1525 hSbrEncoder->sbrElement[i]->sbrConfigData.freqBandTable[LO] =
1526 GetRam_Sbr_freqBandTableLO(i);
1527 hSbrEncoder->sbrElement[i]->sbrConfigData.freqBandTable[HI] =
1528 GetRam_Sbr_freqBandTableHI(i);
1529 hSbrEncoder->sbrElement[i]->sbrConfigData.v_k_master =
1530 GetRam_Sbr_v_k_master(i);
1531 if ((hSbrEncoder->sbrElement[i]->sbrConfigData.freqBandTable[LO] == NULL) ||
1532 (hSbrEncoder->sbrElement[i]->sbrConfigData.freqBandTable[HI] == NULL) ||
1533 (hSbrEncoder->sbrElement[i]->sbrConfigData.v_k_master == NULL)) {
1534 goto bail;
1535 }
1536 }
1537
1538 /* Create SBR channels */
1539 for (i = 0; i < nChannels; i++) {
1540 hSbrEncoder->pSbrChannel[i] = GetRam_SbrChannel(i);
1541 if (hSbrEncoder->pSbrChannel[i] == NULL) {
1542 goto bail;
1543 }
1544
1545 if (createEnvChannel(&hSbrEncoder->pSbrChannel[i]->hEnvChannel, i,
1546 hSbrEncoder->dynamicRam)) {
1547 goto bail;
1548 }
1549 }
1550
1551 /* Create QMF States */
1552 for (i = 0; i < fixMax(nChannels, (supportPS) ? 2 : 0); i++) {
1553 hSbrEncoder->QmfAnalysis[i].FilterStates = GetRam_Sbr_QmfStatesAnalysis(i);
1554 if (hSbrEncoder->QmfAnalysis[i].FilterStates == NULL) {
1555 goto bail;
1556 }
1557 }
1558
1559 /* Create Parametric Stereo handle */
1560 if (supportPS) {
1561 if (PSEnc_Create(&hSbrEncoder->hParametricStereo)) {
1562 goto bail;
1563 }
1564
1565 hSbrEncoder->qmfSynthesisPS.FilterStates = GetRam_PsQmfStatesSynthesis();
1566 if (hSbrEncoder->qmfSynthesisPS.FilterStates == NULL) {
1567 goto bail;
1568 }
1569 } /* supportPS */
1570
1571 *phSbrEncoder = hSbrEncoder;
1572
1573 errorStatus = 0;
1574 return errorStatus;
1575
1576 bail:
1577 /* Close SBR encoder instance */
1578 sbrEncoder_Close(&hSbrEncoder);
1579 return errorStatus;
1580 }
1581
FDKsbrEnc_Reallocate(HANDLE_SBR_ENCODER hSbrEncoder,SBR_ELEMENT_INFO elInfo[(8)],const INT noElements)1582 static INT FDKsbrEnc_Reallocate(HANDLE_SBR_ENCODER hSbrEncoder,
1583 SBR_ELEMENT_INFO elInfo[(8)],
1584 const INT noElements) {
1585 INT totalCh = 0;
1586 INT totalQmf = 0;
1587 INT coreEl;
1588 INT el = -1;
1589
1590 hSbrEncoder->lfeChIdx = -1; /* default value, until lfe found */
1591
1592 for (coreEl = 0; coreEl < noElements; coreEl++) {
1593 /* SBR only handles SCE and CPE's */
1594 if (elInfo[coreEl].elType == ID_SCE || elInfo[coreEl].elType == ID_CPE) {
1595 el++;
1596 } else {
1597 if (elInfo[coreEl].elType == ID_LFE) {
1598 hSbrEncoder->lfeChIdx = elInfo[coreEl].ChannelIndex[0];
1599 }
1600 continue;
1601 }
1602
1603 SBR_ELEMENT_INFO *pelInfo = &elInfo[coreEl];
1604 HANDLE_SBR_ELEMENT hSbrElement = hSbrEncoder->sbrElement[el];
1605
1606 int ch;
1607 for (ch = 0; ch < pelInfo->nChannelsInEl; ch++) {
1608 hSbrElement->sbrChannel[ch] = hSbrEncoder->pSbrChannel[totalCh];
1609 totalCh++;
1610 }
1611 /* analysis QMF */
1612 for (ch = 0;
1613 ch < ((pelInfo->fParametricStereo) ? 2 : pelInfo->nChannelsInEl);
1614 ch++) {
1615 hSbrElement->elInfo.ChannelIndex[ch] = pelInfo->ChannelIndex[ch];
1616 hSbrElement->hQmfAnalysis[ch] = &hSbrEncoder->QmfAnalysis[totalQmf++];
1617 }
1618
1619 /* Copy Element info */
1620 hSbrElement->elInfo.elType = pelInfo->elType;
1621 hSbrElement->elInfo.instanceTag = pelInfo->instanceTag;
1622 hSbrElement->elInfo.nChannelsInEl = pelInfo->nChannelsInEl;
1623 hSbrElement->elInfo.fParametricStereo = pelInfo->fParametricStereo;
1624 hSbrElement->elInfo.fDualMono = pelInfo->fDualMono;
1625 } /* coreEl */
1626
1627 return 0;
1628 }
1629
1630 /*****************************************************************************
1631
1632 functionname: FDKsbrEnc_bsBufInit
1633 description: initializes bitstream buffer
1634 returns: initialized bitstream buffer in env encoder
1635 input:
1636 output: hEnv
1637
1638 *****************************************************************************/
FDKsbrEnc_bsBufInit(HANDLE_SBR_ELEMENT hSbrElement,int nBitstrDelay)1639 static INT FDKsbrEnc_bsBufInit(HANDLE_SBR_ELEMENT hSbrElement,
1640 int nBitstrDelay) {
1641 UCHAR *bitstreamBuffer;
1642
1643 /* initialize the bitstream buffer */
1644 bitstreamBuffer = hSbrElement->payloadDelayLine[nBitstrDelay];
1645 FDKinitBitStream(&hSbrElement->CmonData.sbrBitbuf, bitstreamBuffer,
1646 MAX_PAYLOAD_SIZE * sizeof(UCHAR), 0, BS_WRITER);
1647
1648 return (0);
1649 }
1650
1651 /*****************************************************************************
1652
1653 functionname: FDKsbrEnc_EnvInit
1654 description: initializes parameters
1655 returns: error status
1656 input:
1657 output: hEnv
1658
1659 *****************************************************************************/
FDKsbrEnc_EnvInit(HANDLE_SBR_ELEMENT hSbrElement,sbrConfigurationPtr params,INT * coreBandWith,AUDIO_OBJECT_TYPE aot,int nElement,const int headerPeriod,ULONG statesInitFlag,const SBRENC_DS_TYPE downsamplingMethod,UCHAR * dynamic_RAM)1660 static INT FDKsbrEnc_EnvInit(HANDLE_SBR_ELEMENT hSbrElement,
1661 sbrConfigurationPtr params, INT *coreBandWith,
1662 AUDIO_OBJECT_TYPE aot, int nElement,
1663 const int headerPeriod, ULONG statesInitFlag,
1664 const SBRENC_DS_TYPE downsamplingMethod,
1665 UCHAR *dynamic_RAM) {
1666 int ch, i;
1667
1668 if ((params->codecSettings.nChannels < 1) ||
1669 (params->codecSettings.nChannels > MAX_NUM_CHANNELS)) {
1670 return (1);
1671 }
1672
1673 /* init and set syntax flags */
1674 hSbrElement->sbrConfigData.sbrSyntaxFlags = 0;
1675
1676 switch (aot) {
1677 case AOT_ER_AAC_ELD:
1678 hSbrElement->sbrConfigData.sbrSyntaxFlags |= SBR_SYNTAX_LOW_DELAY;
1679 break;
1680 default:
1681 break;
1682 }
1683 if (params->crcSbr) {
1684 hSbrElement->sbrConfigData.sbrSyntaxFlags |= SBR_SYNTAX_CRC;
1685 }
1686
1687 hSbrElement->sbrConfigData.noQmfBands = 64 >> (2 - params->downSampleFactor);
1688 switch (hSbrElement->sbrConfigData.noQmfBands) {
1689 case 64:
1690 hSbrElement->sbrConfigData.noQmfSlots = params->sbrFrameSize >> 6;
1691 break;
1692 case 32:
1693 hSbrElement->sbrConfigData.noQmfSlots = params->sbrFrameSize >> 5;
1694 break;
1695 default:
1696 hSbrElement->sbrConfigData.noQmfSlots = params->sbrFrameSize >> 6;
1697 return (2);
1698 }
1699
1700 /*
1701 now initialize sbrConfigData, sbrHeaderData and sbrBitstreamData,
1702 */
1703 hSbrElement->sbrConfigData.nChannels = params->codecSettings.nChannels;
1704
1705 if (params->codecSettings.nChannels == 2) {
1706 if ((hSbrElement->elInfo.elType == ID_CPE) &&
1707 ((hSbrElement->elInfo.fDualMono == 1))) {
1708 hSbrElement->sbrConfigData.stereoMode = SBR_LEFT_RIGHT;
1709 } else {
1710 hSbrElement->sbrConfigData.stereoMode = params->stereoMode;
1711 }
1712 } else {
1713 hSbrElement->sbrConfigData.stereoMode = SBR_MONO;
1714 }
1715
1716 hSbrElement->sbrConfigData.frameSize = params->sbrFrameSize;
1717
1718 hSbrElement->sbrConfigData.sampleFreq =
1719 params->downSampleFactor * params->codecSettings.sampleFreq;
1720
1721 hSbrElement->sbrBitstreamData.CountSendHeaderData = 0;
1722 if (params->SendHeaderDataTime > 0) {
1723 if (headerPeriod == -1) {
1724 hSbrElement->sbrBitstreamData.NrSendHeaderData = (INT)(
1725 params->SendHeaderDataTime * hSbrElement->sbrConfigData.sampleFreq /
1726 (1000 * hSbrElement->sbrConfigData.frameSize));
1727 hSbrElement->sbrBitstreamData.NrSendHeaderData =
1728 fixMax(hSbrElement->sbrBitstreamData.NrSendHeaderData, 1);
1729 } else {
1730 /* assure header period at least once per second */
1731 hSbrElement->sbrBitstreamData.NrSendHeaderData = fixMin(
1732 fixMax(headerPeriod, 1), (hSbrElement->sbrConfigData.sampleFreq /
1733 hSbrElement->sbrConfigData.frameSize));
1734 }
1735 } else {
1736 hSbrElement->sbrBitstreamData.NrSendHeaderData = 0;
1737 }
1738
1739 hSbrElement->sbrHeaderData.sbr_data_extra = params->sbr_data_extra;
1740 hSbrElement->sbrBitstreamData.HeaderActive = 0;
1741 hSbrElement->sbrBitstreamData.rightBorderFIX = 0;
1742 hSbrElement->sbrHeaderData.sbr_start_frequency = params->startFreq;
1743 hSbrElement->sbrHeaderData.sbr_stop_frequency = params->stopFreq;
1744 hSbrElement->sbrHeaderData.sbr_xover_band = 0;
1745 hSbrElement->sbrHeaderData.sbr_lc_stereo_mode = 0;
1746
1747 /* data_extra */
1748 if (params->sbr_xpos_ctrl != SBR_XPOS_CTRL_DEFAULT)
1749 hSbrElement->sbrHeaderData.sbr_data_extra = 1;
1750
1751 hSbrElement->sbrHeaderData.sbr_amp_res = (AMP_RES)params->amp_res;
1752
1753 /* header_extra_1 */
1754 hSbrElement->sbrHeaderData.freqScale = params->freqScale;
1755 hSbrElement->sbrHeaderData.alterScale = params->alterScale;
1756 hSbrElement->sbrHeaderData.sbr_noise_bands = params->sbr_noise_bands;
1757 hSbrElement->sbrHeaderData.header_extra_1 = 0;
1758
1759 if ((params->freqScale != SBR_FREQ_SCALE_DEFAULT) ||
1760 (params->alterScale != SBR_ALTER_SCALE_DEFAULT) ||
1761 (params->sbr_noise_bands != SBR_NOISE_BANDS_DEFAULT)) {
1762 hSbrElement->sbrHeaderData.header_extra_1 = 1;
1763 }
1764
1765 /* header_extra_2 */
1766 hSbrElement->sbrHeaderData.sbr_limiter_bands = params->sbr_limiter_bands;
1767 hSbrElement->sbrHeaderData.sbr_limiter_gains = params->sbr_limiter_gains;
1768
1769 if ((hSbrElement->sbrConfigData.sampleFreq > 48000) &&
1770 (hSbrElement->sbrHeaderData.sbr_start_frequency >= 9)) {
1771 hSbrElement->sbrHeaderData.sbr_limiter_gains = SBR_LIMITER_GAINS_INFINITE;
1772 }
1773
1774 hSbrElement->sbrHeaderData.sbr_interpol_freq = params->sbr_interpol_freq;
1775 hSbrElement->sbrHeaderData.sbr_smoothing_length =
1776 params->sbr_smoothing_length;
1777 hSbrElement->sbrHeaderData.header_extra_2 = 0;
1778
1779 if ((params->sbr_limiter_bands != SBR_LIMITER_BANDS_DEFAULT) ||
1780 (params->sbr_limiter_gains != SBR_LIMITER_GAINS_DEFAULT) ||
1781 (params->sbr_interpol_freq != SBR_INTERPOL_FREQ_DEFAULT) ||
1782 (params->sbr_smoothing_length != SBR_SMOOTHING_LENGTH_DEFAULT)) {
1783 hSbrElement->sbrHeaderData.header_extra_2 = 1;
1784 }
1785
1786 /* other switches */
1787 hSbrElement->sbrConfigData.useWaveCoding = params->useWaveCoding;
1788 hSbrElement->sbrConfigData.useParametricCoding = params->parametricCoding;
1789 hSbrElement->sbrConfigData.thresholdAmpResFF_m =
1790 params->threshold_AmpRes_FF_m;
1791 hSbrElement->sbrConfigData.thresholdAmpResFF_e =
1792 params->threshold_AmpRes_FF_e;
1793
1794 /* init freq band table */
1795 if (updateFreqBandTable(&hSbrElement->sbrConfigData,
1796 &hSbrElement->sbrHeaderData,
1797 params->downSampleFactor)) {
1798 return (1);
1799 }
1800
1801 /* now create envelope ext and QMF for each available channel */
1802 for (ch = 0; ch < hSbrElement->sbrConfigData.nChannels; ch++) {
1803 if (initEnvChannel(&hSbrElement->sbrConfigData, &hSbrElement->sbrHeaderData,
1804 &hSbrElement->sbrChannel[ch]->hEnvChannel, params,
1805 statesInitFlag, ch, dynamic_RAM)) {
1806 return (1);
1807 }
1808
1809 } /* nChannels */
1810
1811 /* reset and intialize analysis qmf */
1812 for (ch = 0; ch < ((hSbrElement->elInfo.fParametricStereo)
1813 ? 2
1814 : hSbrElement->sbrConfigData.nChannels);
1815 ch++) {
1816 int err;
1817 UINT qmfFlags =
1818 (hSbrElement->sbrConfigData.sbrSyntaxFlags & SBR_SYNTAX_LOW_DELAY)
1819 ? QMF_FLAG_CLDFB
1820 : 0;
1821 if (statesInitFlag)
1822 qmfFlags &= ~QMF_FLAG_KEEP_STATES;
1823 else
1824 qmfFlags |= QMF_FLAG_KEEP_STATES;
1825
1826 err = qmfInitAnalysisFilterBank(
1827 hSbrElement->hQmfAnalysis[ch],
1828 (FIXP_QAS *)hSbrElement->hQmfAnalysis[ch]->FilterStates,
1829 hSbrElement->sbrConfigData.noQmfSlots,
1830 hSbrElement->sbrConfigData.noQmfBands,
1831 hSbrElement->sbrConfigData.noQmfBands,
1832 hSbrElement->sbrConfigData.noQmfBands, qmfFlags);
1833 if (0 != err) {
1834 return err;
1835 }
1836 }
1837
1838 /* */
1839 hSbrElement->CmonData.xOverFreq = hSbrElement->sbrConfigData.xOverFreq;
1840 hSbrElement->CmonData.dynBwEnabled =
1841 (params->dynBwSupported && params->dynBwEnabled);
1842 hSbrElement->CmonData.dynXOverFreqEnc =
1843 FDKsbrEnc_SbrGetXOverFreq(hSbrElement, hSbrElement->CmonData.xOverFreq);
1844 for (i = 0; i < 5; i++)
1845 hSbrElement->dynXOverFreqDelay[i] = hSbrElement->CmonData.dynXOverFreqEnc;
1846 hSbrElement->CmonData.sbrNumChannels = hSbrElement->sbrConfigData.nChannels;
1847 hSbrElement->sbrConfigData.dynXOverFreq = hSbrElement->CmonData.xOverFreq;
1848
1849 /* Update Bandwith to be passed to the core encoder */
1850 *coreBandWith = hSbrElement->CmonData.xOverFreq;
1851
1852 return (0);
1853 }
1854
sbrEncoder_GetInBufferSize(int noChannels)1855 INT sbrEncoder_GetInBufferSize(int noChannels) {
1856 INT temp;
1857
1858 temp = (2048);
1859 temp += 1024 + MAX_SAMPLE_DELAY;
1860 temp *= noChannels;
1861 temp *= sizeof(INT_PCM);
1862 return temp;
1863 }
1864
1865 /*
1866 * Encode Dummy SBR payload frames to fill the delay lines.
1867 */
FDKsbrEnc_DelayCompensation(HANDLE_SBR_ENCODER hEnvEnc,INT_PCM * timeBuffer,UINT timeBufferBufSize)1868 static INT FDKsbrEnc_DelayCompensation(HANDLE_SBR_ENCODER hEnvEnc,
1869 INT_PCM *timeBuffer,
1870 UINT timeBufferBufSize) {
1871 int n, el;
1872
1873 for (n = hEnvEnc->nBitstrDelay; n > 0; n--) {
1874 for (el = 0; el < hEnvEnc->noElements; el++) {
1875 if (FDKsbrEnc_EnvEncodeFrame(
1876 hEnvEnc, el,
1877 timeBuffer + hEnvEnc->downsampledOffset / hEnvEnc->nChannels,
1878 timeBufferBufSize, NULL, NULL, 1))
1879 return -1;
1880 }
1881 sbrEncoder_UpdateBuffers(hEnvEnc, timeBuffer, timeBufferBufSize);
1882 }
1883 return 0;
1884 }
1885
sbrEncoder_LimitBitRate(UINT bitRate,UINT numChannels,UINT coreSampleRate,AUDIO_OBJECT_TYPE aot)1886 UINT sbrEncoder_LimitBitRate(UINT bitRate, UINT numChannels,
1887 UINT coreSampleRate, AUDIO_OBJECT_TYPE aot) {
1888 UINT newBitRate = bitRate;
1889 INT index;
1890
1891 FDK_ASSERT(numChannels > 0 && numChannels <= 2);
1892 if (aot == AOT_PS) {
1893 if (numChannels == 1) {
1894 index = getPsTuningTableIndex(bitRate, &newBitRate);
1895 if (index == INVALID_TABLE_IDX) {
1896 bitRate = newBitRate;
1897 }
1898 } else {
1899 return 0;
1900 }
1901 }
1902 index = getSbrTuningTableIndex(bitRate, numChannels, coreSampleRate, aot,
1903 &newBitRate);
1904 if (index != INVALID_TABLE_IDX) {
1905 newBitRate = bitRate;
1906 }
1907
1908 return newBitRate;
1909 }
1910
sbrEncoder_IsSingleRatePossible(AUDIO_OBJECT_TYPE aot)1911 UINT sbrEncoder_IsSingleRatePossible(AUDIO_OBJECT_TYPE aot) {
1912 UINT isPossible = (AOT_PS == aot) ? 0 : 1;
1913 return isPossible;
1914 }
1915
1916 /*****************************************************************************/
1917 /* */
1918 /*functionname: sbrEncoder_Init_delay */
1919 /*description: Determine Delay balancing and new encoder delay */
1920 /* */
1921 /*returns: - error status */
1922 /*input: - frame length of the core (i.e. e.g. AAC) */
1923 /* - number of channels */
1924 /* - downsample factor (1 for downsampled, 2 for dual-rate SBR) */
1925 /* - low delay presence */
1926 /* - ps presence */
1927 /* - downsampling method: QMF-, time domain or no downsampling */
1928 /* - various delay values (see DELAY_PARAM struct description) */
1929 /* */
1930 /*Example: Delay balancing for a HE-AACv1 encoder (time-domain downsampling) */
1931 /*========================================================================== */
1932 /* */
1933 /* +--------+ +--------+ +--------+ +--------+ +--------+ */
1934 /* |core | |ds 2:1 | |AAC | |QMF | |QMF | */
1935 /* +-+path +------------+ +-+core +-+analysis+-+overlap +-+ */
1936 /* | |offset | | | | | |32 bands| | | | */
1937 /* | +--------+ +--------+ +--------+ +--------+ +--------+ | */
1938 /* | core path +-------++ */
1939 /* | |QMF | */
1940 /*->+ +synth. +-> */
1941 /* | |64 bands| */
1942 /* | +-------++ */
1943 /* | +--------+ +--------+ +--------+ +--------+ | */
1944 /* | |SBR path| |QMF | |subband | |bs delay| | */
1945 /* +-+offset +-+analysis+-+sample +-+(full +-----------------------+ */
1946 /* | | |64 bands| |buffer | | frames)| */
1947 /* +--------+ +--------+ +--------+ +--------+ */
1948 /* SBR path */
1949 /* */
1950 /*****************************************************************************/
sbrEncoder_Init_delay(const int coreFrameLength,const int numChannels,const int downSampleFactor,const int lowDelay,const int usePs,const int is212,const SBRENC_DS_TYPE downsamplingMethod,DELAY_PARAM * hDelayParam)1951 static INT sbrEncoder_Init_delay(
1952 const int coreFrameLength, /* input */
1953 const int numChannels, /* input */
1954 const int downSampleFactor, /* input */
1955 const int lowDelay, /* input */
1956 const int usePs, /* input */
1957 const int is212, /* input */
1958 const SBRENC_DS_TYPE downsamplingMethod, /* input */
1959 DELAY_PARAM *hDelayParam /* input/output */
1960 ) {
1961 int delayCorePath = 0; /* delay in core path */
1962 int delaySbrPath = 0; /* delay difference in QMF aka SBR path */
1963 int delayInput2Core = 0; /* delay from the input to the core */
1964 int delaySbrDec = 0; /* delay of the decoder's SBR module */
1965
1966 int delayCore = hDelayParam->delay; /* delay of the core */
1967
1968 /* Added delay by the SBR delay initialization */
1969 int corePathOffset = 0; /* core path */
1970 int sbrPathOffset = 0; /* sbr path */
1971 int bitstreamDelay = 0; /* sbr path, framewise */
1972
1973 int flCore = coreFrameLength; /* core frame length */
1974
1975 int returnValue = 0; /* return value - 0 means: no error */
1976
1977 /* 1) Calculate actual delay for core and SBR path */
1978 if (is212) {
1979 delayCorePath = DELAY_COREPATH_ELDv2SBR(flCore, downSampleFactor);
1980 delaySbrPath = DELAY_ELDv2SBR(flCore, downSampleFactor);
1981 delaySbrDec = ((flCore) / 2) * (downSampleFactor);
1982 } else if (lowDelay) {
1983 delayCorePath = DELAY_COREPATH_ELDSBR(flCore, downSampleFactor);
1984 delaySbrPath = DELAY_ELDSBR(flCore, downSampleFactor);
1985 delaySbrDec = DELAY_QMF_POSTPROC(downSampleFactor);
1986 } else if (usePs) {
1987 delayCorePath = DELAY_COREPATH_PS(flCore, downSampleFactor);
1988 delaySbrPath = DELAY_PS(flCore, downSampleFactor);
1989 delaySbrDec = DELAY_COREPATH_SBR(flCore, downSampleFactor);
1990 } else {
1991 delayCorePath = DELAY_COREPATH_SBR(flCore, downSampleFactor);
1992 delaySbrPath = DELAY_SBR(flCore, downSampleFactor);
1993 delaySbrDec = DELAY_COREPATH_SBR(flCore, downSampleFactor);
1994 }
1995 delayCorePath += delayCore * downSampleFactor;
1996 delayCorePath +=
1997 (downsamplingMethod == SBRENC_DS_TIME) ? hDelayParam->dsDelay : 0;
1998
1999 /* 2) Manage coupling of paths */
2000 if (downsamplingMethod == SBRENC_DS_QMF && delayCorePath > delaySbrPath) {
2001 /* In case of QMF downsampling, both paths are coupled, i.e. the SBR path
2002 offset would be added to both the SBR path and to the core path
2003 as well, thus making it impossible to achieve delay balancing.
2004 To overcome that problem, a framewise delay is added to the SBR path
2005 first, until the overall delay of the core path is shorter than
2006 the delay of the SBR path. When this is achieved, the missing delay
2007 difference can be added as downsampled offset to the core path.
2008 */
2009 while (delayCorePath > delaySbrPath) {
2010 /* Add one frame delay to SBR path */
2011 delaySbrPath += flCore * downSampleFactor;
2012 bitstreamDelay += 1;
2013 }
2014 }
2015
2016 /* 3) Calculate necessary additional delay to balance the paths */
2017 if (delayCorePath > delaySbrPath) {
2018 /* Delay QMF input */
2019 while (delayCorePath > delaySbrPath + (int)flCore * (int)downSampleFactor) {
2020 /* Do bitstream frame-wise delay balancing if there are
2021 more than SBR framelength samples delay difference */
2022 delaySbrPath += flCore * downSampleFactor;
2023 bitstreamDelay += 1;
2024 }
2025 /* Multiply input offset by input channels */
2026 corePathOffset = 0;
2027 sbrPathOffset = (delayCorePath - delaySbrPath) * numChannels;
2028 } else {
2029 /* Delay AAC data */
2030 /* Multiply downsampled offset by AAC core channels. Divide by 2 because of
2031 half samplerate of downsampled data. */
2032 corePathOffset = ((delaySbrPath - delayCorePath) * numChannels) >>
2033 (downSampleFactor - 1);
2034 sbrPathOffset = 0;
2035 }
2036
2037 /* 4) Calculate delay from input to core */
2038 if (usePs) {
2039 delayInput2Core =
2040 (DELAY_QMF_ANA(downSampleFactor) + DELAY_QMF_DS + DELAY_HYB_SYN) +
2041 (downSampleFactor * corePathOffset) + 1;
2042 } else if (downsamplingMethod == SBRENC_DS_TIME) {
2043 delayInput2Core = corePathOffset + hDelayParam->dsDelay;
2044 } else {
2045 delayInput2Core = corePathOffset;
2046 }
2047
2048 /* 6) Set output parameters */
2049 hDelayParam->delay = FDKmax(delayCorePath, delaySbrPath); /* overall delay */
2050 hDelayParam->sbrDecDelay = delaySbrDec; /* SBR decoder delay */
2051 hDelayParam->delayInput2Core = delayInput2Core; /* delay input - core */
2052 hDelayParam->bitstrDelay = bitstreamDelay; /* bitstream delay, in frames */
2053 hDelayParam->corePathOffset = corePathOffset; /* offset added to core path */
2054 hDelayParam->sbrPathOffset = sbrPathOffset; /* offset added to SBR path */
2055
2056 return returnValue;
2057 }
2058
2059 /*****************************************************************************
2060
2061 functionname: sbrEncoder_Init
2062 description: initializes the SBR encoder
2063 returns: error status
2064
2065 *****************************************************************************/
sbrEncoder_Init(HANDLE_SBR_ENCODER hSbrEncoder,SBR_ELEMENT_INFO elInfo[(8)],int noElements,INT_PCM * inputBuffer,UINT inputBufferBufSize,INT * coreBandwidth,INT * inputBufferOffset,INT * numChannels,const UINT syntaxFlags,INT * coreSampleRate,UINT * downSampleFactor,INT * frameLength,AUDIO_OBJECT_TYPE aot,int * delay,int transformFactor,const int headerPeriod,ULONG statesInitFlag)2066 INT sbrEncoder_Init(HANDLE_SBR_ENCODER hSbrEncoder,
2067 SBR_ELEMENT_INFO elInfo[(8)], int noElements,
2068 INT_PCM *inputBuffer, UINT inputBufferBufSize,
2069 INT *coreBandwidth, INT *inputBufferOffset,
2070 INT *numChannels, const UINT syntaxFlags,
2071 INT *coreSampleRate, UINT *downSampleFactor,
2072 INT *frameLength, AUDIO_OBJECT_TYPE aot, int *delay,
2073 int transformFactor, const int headerPeriod,
2074 ULONG statesInitFlag) {
2075 HANDLE_ERROR_INFO errorInfo = noError;
2076 sbrConfiguration sbrConfig[(8)];
2077 INT error = 0;
2078 INT lowestBandwidth;
2079 /* Save input parameters */
2080 INT inputSampleRate = *coreSampleRate;
2081 int coreFrameLength = *frameLength;
2082 int inputBandWidth = *coreBandwidth;
2083 int inputChannels = *numChannels;
2084
2085 SBRENC_DS_TYPE downsamplingMethod = SBRENC_DS_NONE;
2086 int highestSbrStartFreq, highestSbrStopFreq;
2087 int lowDelay = 0;
2088 int usePs = 0;
2089 int is212 = 0;
2090
2091 DELAY_PARAM delayParam;
2092
2093 /* check whether SBR setting is available for the current encoder
2094 * configuration (bitrate, samplerate) */
2095 if (!sbrEncoder_IsSingleRatePossible(aot)) {
2096 *downSampleFactor = 2;
2097 }
2098
2099 if (aot == AOT_PS) {
2100 usePs = 1;
2101 }
2102 if (aot == AOT_ER_AAC_ELD) {
2103 lowDelay = 1;
2104 } else if (aot == AOT_ER_AAC_LD) {
2105 error = 1;
2106 goto bail;
2107 }
2108
2109 /* Parametric Stereo */
2110 if (usePs) {
2111 if (*numChannels == 2 && noElements == 1) {
2112 /* Override Element type in case of Parametric stereo */
2113 elInfo[0].elType = ID_SCE;
2114 elInfo[0].fParametricStereo = 1;
2115 elInfo[0].nChannelsInEl = 1;
2116 /* core encoder gets downmixed mono signal */
2117 *numChannels = 1;
2118 } else {
2119 error = 1;
2120 goto bail;
2121 }
2122 } /* usePs */
2123
2124 /* set the core's sample rate */
2125 switch (*downSampleFactor) {
2126 case 1:
2127 *coreSampleRate = inputSampleRate;
2128 downsamplingMethod = SBRENC_DS_NONE;
2129 break;
2130 case 2:
2131 *coreSampleRate = inputSampleRate >> 1;
2132 downsamplingMethod = usePs ? SBRENC_DS_QMF : SBRENC_DS_TIME;
2133 break;
2134 default:
2135 *coreSampleRate = inputSampleRate >> 1;
2136 return 0; /* return error */
2137 }
2138
2139 /* check whether SBR setting is available for the current encoder
2140 * configuration (bitrate, coreSampleRate) */
2141 {
2142 int el, coreEl;
2143
2144 /* Check if every element config is feasible */
2145 for (coreEl = 0; coreEl < noElements; coreEl++) {
2146 /* SBR only handles SCE and CPE's */
2147 if (elInfo[coreEl].elType != ID_SCE && elInfo[coreEl].elType != ID_CPE) {
2148 continue;
2149 }
2150 /* check if desired configuration is available */
2151 if (!FDKsbrEnc_IsSbrSettingAvail(elInfo[coreEl].bitRate, 0,
2152 elInfo[coreEl].nChannelsInEl,
2153 inputSampleRate, *coreSampleRate, aot)) {
2154 error = 1;
2155 goto bail;
2156 }
2157 }
2158
2159 hSbrEncoder->nChannels = *numChannels;
2160 hSbrEncoder->frameSize = coreFrameLength * *downSampleFactor;
2161 hSbrEncoder->downsamplingMethod = downsamplingMethod;
2162 hSbrEncoder->downSampleFactor = *downSampleFactor;
2163 hSbrEncoder->estimateBitrate = 0;
2164 hSbrEncoder->inputDataDelay = 0;
2165 is212 = ((aot == AOT_ER_AAC_ELD) && (syntaxFlags & AC_LD_MPS)) ? 1 : 0;
2166
2167 /* Open SBR elements */
2168 el = -1;
2169 highestSbrStartFreq = highestSbrStopFreq = 0;
2170 lowestBandwidth = 99999;
2171
2172 /* Loop through each core encoder element and get a matching SBR element
2173 * config */
2174 for (coreEl = 0; coreEl < noElements; coreEl++) {
2175 /* SBR only handles SCE and CPE's */
2176 if (elInfo[coreEl].elType == ID_SCE || elInfo[coreEl].elType == ID_CPE) {
2177 el++;
2178 } else {
2179 continue;
2180 }
2181
2182 /* Set parametric Stereo Flag. */
2183 if (usePs) {
2184 elInfo[coreEl].fParametricStereo = 1;
2185 } else {
2186 elInfo[coreEl].fParametricStereo = 0;
2187 }
2188
2189 /*
2190 * Init sbrConfig structure
2191 */
2192 if (!FDKsbrEnc_InitializeSbrDefaults(&sbrConfig[el], *downSampleFactor,
2193 coreFrameLength, IS_LOWDELAY(aot))) {
2194 error = 1;
2195 goto bail;
2196 }
2197
2198 /*
2199 * Modify sbrConfig structure according to Element parameters
2200 */
2201 if (!FDKsbrEnc_AdjustSbrSettings(
2202 &sbrConfig[el], elInfo[coreEl].bitRate,
2203 elInfo[coreEl].nChannelsInEl, *coreSampleRate, inputSampleRate,
2204 transformFactor, 24000, 0, 0, /* useSpeechConfig */
2205 0, /* lcsMode */
2206 usePs, /* bParametricStereo */
2207 aot)) {
2208 error = 1;
2209 goto bail;
2210 }
2211
2212 /* Find common frequency border for all SBR elements */
2213 highestSbrStartFreq =
2214 fixMax(highestSbrStartFreq, sbrConfig[el].startFreq);
2215 highestSbrStopFreq = fixMax(highestSbrStopFreq, sbrConfig[el].stopFreq);
2216
2217 } /* first element loop */
2218
2219 /* Set element count (can be less than core encoder element count) */
2220 hSbrEncoder->noElements = el + 1;
2221
2222 FDKsbrEnc_Reallocate(hSbrEncoder, elInfo, noElements);
2223
2224 for (el = 0; el < hSbrEncoder->noElements; el++) {
2225 int bandwidth = *coreBandwidth;
2226
2227 /* Use lowest common bandwidth */
2228 sbrConfig[el].startFreq = highestSbrStartFreq;
2229 sbrConfig[el].stopFreq = highestSbrStopFreq;
2230
2231 /* initialize SBR element, and get core bandwidth */
2232 error = FDKsbrEnc_EnvInit(hSbrEncoder->sbrElement[el], &sbrConfig[el],
2233 &bandwidth, aot, el, headerPeriod,
2234 statesInitFlag, hSbrEncoder->downsamplingMethod,
2235 hSbrEncoder->dynamicRam);
2236
2237 if (error != 0) {
2238 error = 2;
2239 goto bail;
2240 }
2241
2242 /* Get lowest core encoder bandwidth to be returned later. */
2243 lowestBandwidth = fixMin(lowestBandwidth, bandwidth);
2244
2245 } /* second element loop */
2246
2247 /* Initialize a downsampler for each channel in each SBR element */
2248 if (hSbrEncoder->downsamplingMethod == SBRENC_DS_TIME) {
2249 for (el = 0; el < hSbrEncoder->noElements; el++) {
2250 HANDLE_SBR_ELEMENT hSbrEl = hSbrEncoder->sbrElement[el];
2251 INT Wc, ch;
2252
2253 Wc = 500; /* Cutoff frequency with full bandwidth */
2254
2255 for (ch = 0; ch < hSbrEl->elInfo.nChannelsInEl; ch++) {
2256 FDKaacEnc_InitDownsampler(&hSbrEl->sbrChannel[ch]->downSampler, Wc,
2257 *downSampleFactor);
2258 FDK_ASSERT(hSbrEl->sbrChannel[ch]->downSampler.delay <=
2259 MAX_DS_FILTER_DELAY);
2260 }
2261 } /* third element loop */
2262
2263 /* lfe */
2264 FDKaacEnc_InitDownsampler(&hSbrEncoder->lfeDownSampler, 0,
2265 *downSampleFactor);
2266 }
2267
2268 /* Get delay information */
2269 delayParam.dsDelay =
2270 hSbrEncoder->sbrElement[0]->sbrChannel[0]->downSampler.delay;
2271 delayParam.delay = *delay;
2272
2273 error = sbrEncoder_Init_delay(coreFrameLength, *numChannels,
2274 *downSampleFactor, lowDelay, usePs, is212,
2275 downsamplingMethod, &delayParam);
2276
2277 if (error != 0) {
2278 error = 3;
2279 goto bail;
2280 }
2281
2282 hSbrEncoder->nBitstrDelay = delayParam.bitstrDelay;
2283 hSbrEncoder->sbrDecDelay = delayParam.sbrDecDelay;
2284 hSbrEncoder->inputDataDelay = delayParam.delayInput2Core;
2285
2286 /* Assign core encoder Bandwidth */
2287 *coreBandwidth = lowestBandwidth;
2288
2289 /* Estimate sbr bitrate, 2.5 kBit/s per sbr channel */
2290 hSbrEncoder->estimateBitrate += 2500 * (*numChannels);
2291
2292 /* Initialize bitstream buffer for each element */
2293 for (el = 0; el < hSbrEncoder->noElements; el++) {
2294 FDKsbrEnc_bsBufInit(hSbrEncoder->sbrElement[el], delayParam.bitstrDelay);
2295 }
2296
2297 /* initialize parametric stereo */
2298 if (usePs) {
2299 PSENC_CONFIG psEncConfig;
2300 FDK_ASSERT(hSbrEncoder->noElements == 1);
2301 INT psTuningTableIdx = getPsTuningTableIndex(elInfo[0].bitRate, NULL);
2302
2303 psEncConfig.frameSize = coreFrameLength; // sbrConfig.sbrFrameSize;
2304 psEncConfig.qmfFilterMode = 0;
2305 psEncConfig.sbrPsDelay = 0;
2306
2307 /* tuning parameters */
2308 if (psTuningTableIdx != INVALID_TABLE_IDX) {
2309 psEncConfig.nStereoBands = psTuningTable[psTuningTableIdx].nStereoBands;
2310 psEncConfig.maxEnvelopes = psTuningTable[psTuningTableIdx].nEnvelopes;
2311 psEncConfig.iidQuantErrorThreshold =
2312 (FIXP_DBL)psTuningTable[psTuningTableIdx].iidQuantErrorThreshold;
2313
2314 /* calculation is not quite linear, increased number of envelopes causes
2315 * more bits */
2316 /* assume avg. 50 bits per frame for 10 stereo bands / 1 envelope
2317 * configuration */
2318 hSbrEncoder->estimateBitrate +=
2319 ((((*coreSampleRate) * 5 * psEncConfig.nStereoBands *
2320 psEncConfig.maxEnvelopes) /
2321 hSbrEncoder->frameSize));
2322
2323 } else {
2324 error = ERROR(CDI, "Invalid ps tuning table index.");
2325 goto bail;
2326 }
2327
2328 qmfInitSynthesisFilterBank(
2329 &hSbrEncoder->qmfSynthesisPS,
2330 (FIXP_DBL *)hSbrEncoder->qmfSynthesisPS.FilterStates,
2331 hSbrEncoder->sbrElement[0]->sbrConfigData.noQmfSlots,
2332 hSbrEncoder->sbrElement[0]->sbrConfigData.noQmfBands >> 1,
2333 hSbrEncoder->sbrElement[0]->sbrConfigData.noQmfBands >> 1,
2334 hSbrEncoder->sbrElement[0]->sbrConfigData.noQmfBands >> 1,
2335 (statesInitFlag) ? 0 : QMF_FLAG_KEEP_STATES);
2336
2337 if (errorInfo == noError) {
2338 /* update delay */
2339 psEncConfig.sbrPsDelay =
2340 FDKsbrEnc_GetEnvEstDelay(&hSbrEncoder->sbrElement[0]
2341 ->sbrChannel[0]
2342 ->hEnvChannel.sbrExtractEnvelope);
2343
2344 errorInfo =
2345 PSEnc_Init(hSbrEncoder->hParametricStereo, &psEncConfig,
2346 hSbrEncoder->sbrElement[0]->sbrConfigData.noQmfSlots,
2347 hSbrEncoder->sbrElement[0]->sbrConfigData.noQmfBands,
2348 hSbrEncoder->dynamicRam);
2349 }
2350 }
2351
2352 hSbrEncoder->downsampledOffset = delayParam.corePathOffset;
2353 hSbrEncoder->bufferOffset = delayParam.sbrPathOffset;
2354 *delay = delayParam.delay;
2355
2356 { hSbrEncoder->downmixSize = coreFrameLength * (*numChannels); }
2357
2358 /* Delay Compensation: fill bitstream delay buffer with zero input signal */
2359 if (hSbrEncoder->nBitstrDelay > 0) {
2360 error = FDKsbrEnc_DelayCompensation(hSbrEncoder, inputBuffer,
2361 inputBufferBufSize);
2362 if (error != 0) goto bail;
2363 }
2364
2365 /* Set Output frame length */
2366 *frameLength = coreFrameLength * *downSampleFactor;
2367 /* Input buffer offset */
2368 *inputBufferOffset =
2369 fixMax(delayParam.sbrPathOffset, delayParam.corePathOffset);
2370 }
2371
2372 return error;
2373
2374 bail:
2375 /* Restore input settings */
2376 *coreSampleRate = inputSampleRate;
2377 *frameLength = coreFrameLength;
2378 *numChannels = inputChannels;
2379 *coreBandwidth = inputBandWidth;
2380
2381 return error;
2382 }
2383
sbrEncoder_EncodeFrame(HANDLE_SBR_ENCODER hSbrEncoder,INT_PCM * samples,UINT samplesBufSize,UINT sbrDataBits[(8)],UCHAR sbrData[(8)][MAX_PAYLOAD_SIZE])2384 INT sbrEncoder_EncodeFrame(HANDLE_SBR_ENCODER hSbrEncoder, INT_PCM *samples,
2385 UINT samplesBufSize, UINT sbrDataBits[(8)],
2386 UCHAR sbrData[(8)][MAX_PAYLOAD_SIZE]) {
2387 INT error;
2388 int el;
2389
2390 for (el = 0; el < hSbrEncoder->noElements; el++) {
2391 if (hSbrEncoder->sbrElement[el] != NULL) {
2392 error = FDKsbrEnc_EnvEncodeFrame(
2393 hSbrEncoder, el,
2394 samples + hSbrEncoder->downsampledOffset / hSbrEncoder->nChannels,
2395 samplesBufSize, &sbrDataBits[el], sbrData[el], 0);
2396 if (error) return error;
2397 }
2398 }
2399
2400 error = FDKsbrEnc_Downsample(
2401 hSbrEncoder,
2402 samples + hSbrEncoder->downsampledOffset / hSbrEncoder->nChannels,
2403 samplesBufSize, hSbrEncoder->nChannels, &sbrDataBits[el], sbrData[el], 0);
2404 if (error) return error;
2405
2406 return 0;
2407 }
2408
sbrEncoder_UpdateBuffers(HANDLE_SBR_ENCODER hSbrEncoder,INT_PCM * timeBuffer,UINT timeBufferBufSize)2409 INT sbrEncoder_UpdateBuffers(HANDLE_SBR_ENCODER hSbrEncoder,
2410 INT_PCM *timeBuffer, UINT timeBufferBufSize) {
2411 if (hSbrEncoder->downsampledOffset > 0) {
2412 int c;
2413 int nd = hSbrEncoder->downmixSize / hSbrEncoder->nChannels;
2414
2415 for (c = 0; c < hSbrEncoder->nChannels; c++) {
2416 /* Move delayed downsampled data */
2417 FDKmemcpy(timeBuffer + timeBufferBufSize * c,
2418 timeBuffer + timeBufferBufSize * c + nd,
2419 sizeof(INT_PCM) *
2420 (hSbrEncoder->downsampledOffset / hSbrEncoder->nChannels));
2421 }
2422 } else {
2423 int c;
2424
2425 for (c = 0; c < hSbrEncoder->nChannels; c++) {
2426 /* Move delayed input data */
2427 FDKmemcpy(
2428 timeBuffer + timeBufferBufSize * c,
2429 timeBuffer + timeBufferBufSize * c + hSbrEncoder->frameSize,
2430 sizeof(INT_PCM) * hSbrEncoder->bufferOffset / hSbrEncoder->nChannels);
2431 }
2432 }
2433 if (hSbrEncoder->nBitstrDelay > 0) {
2434 int el;
2435
2436 for (el = 0; el < hSbrEncoder->noElements; el++) {
2437 FDKmemmove(
2438 hSbrEncoder->sbrElement[el]->payloadDelayLine[0],
2439 hSbrEncoder->sbrElement[el]->payloadDelayLine[1],
2440 sizeof(UCHAR) * (hSbrEncoder->nBitstrDelay * MAX_PAYLOAD_SIZE));
2441
2442 FDKmemmove(&hSbrEncoder->sbrElement[el]->payloadDelayLineSize[0],
2443 &hSbrEncoder->sbrElement[el]->payloadDelayLineSize[1],
2444 sizeof(UINT) * (hSbrEncoder->nBitstrDelay));
2445 }
2446 }
2447 return 0;
2448 }
2449
sbrEncoder_SendHeader(HANDLE_SBR_ENCODER hSbrEncoder)2450 INT sbrEncoder_SendHeader(HANDLE_SBR_ENCODER hSbrEncoder) {
2451 INT error = -1;
2452 if (hSbrEncoder) {
2453 int el;
2454 for (el = 0; el < hSbrEncoder->noElements; el++) {
2455 if ((hSbrEncoder->noElements == 1) &&
2456 (hSbrEncoder->sbrElement[0]->elInfo.fParametricStereo == 1)) {
2457 hSbrEncoder->sbrElement[el]->sbrBitstreamData.CountSendHeaderData =
2458 hSbrEncoder->sbrElement[el]->sbrBitstreamData.NrSendHeaderData - 1;
2459 } else {
2460 hSbrEncoder->sbrElement[el]->sbrBitstreamData.CountSendHeaderData = 0;
2461 }
2462 }
2463 error = 0;
2464 }
2465 return error;
2466 }
2467
sbrEncoder_ContainsHeader(HANDLE_SBR_ENCODER hSbrEncoder)2468 INT sbrEncoder_ContainsHeader(HANDLE_SBR_ENCODER hSbrEncoder) {
2469 INT sbrHeader = 1;
2470 if (hSbrEncoder) {
2471 int el;
2472 for (el = 0; el < hSbrEncoder->noElements; el++) {
2473 sbrHeader &=
2474 (hSbrEncoder->sbrElement[el]->sbrBitstreamData.HeaderActiveDelay == 1)
2475 ? 1
2476 : 0;
2477 }
2478 }
2479 return sbrHeader;
2480 }
2481
sbrEncoder_GetHeaderDelay(HANDLE_SBR_ENCODER hSbrEncoder)2482 INT sbrEncoder_GetHeaderDelay(HANDLE_SBR_ENCODER hSbrEncoder) {
2483 INT delay = -1;
2484
2485 if (hSbrEncoder) {
2486 if ((hSbrEncoder->noElements == 1) &&
2487 (hSbrEncoder->sbrElement[0]->elInfo.fParametricStereo == 1)) {
2488 delay = hSbrEncoder->nBitstrDelay + 1;
2489 } else {
2490 delay = hSbrEncoder->nBitstrDelay;
2491 }
2492 }
2493 return delay;
2494 }
sbrEncoder_GetBsDelay(HANDLE_SBR_ENCODER hSbrEncoder)2495 INT sbrEncoder_GetBsDelay(HANDLE_SBR_ENCODER hSbrEncoder) {
2496 INT delay = -1;
2497
2498 if (hSbrEncoder) {
2499 delay = hSbrEncoder->nBitstrDelay;
2500 }
2501 return delay;
2502 }
2503
sbrEncoder_SAPPrepare(HANDLE_SBR_ENCODER hSbrEncoder)2504 INT sbrEncoder_SAPPrepare(HANDLE_SBR_ENCODER hSbrEncoder) {
2505 INT error = -1;
2506 if (hSbrEncoder) {
2507 int el;
2508 for (el = 0; el < hSbrEncoder->noElements; el++) {
2509 hSbrEncoder->sbrElement[el]->sbrBitstreamData.rightBorderFIX = 1;
2510 }
2511 error = 0;
2512 }
2513 return error;
2514 }
2515
sbrEncoder_GetEstimateBitrate(HANDLE_SBR_ENCODER hSbrEncoder)2516 INT sbrEncoder_GetEstimateBitrate(HANDLE_SBR_ENCODER hSbrEncoder) {
2517 INT estimateBitrate = 0;
2518
2519 if (hSbrEncoder) {
2520 estimateBitrate += hSbrEncoder->estimateBitrate;
2521 }
2522
2523 return estimateBitrate;
2524 }
2525
sbrEncoder_GetInputDataDelay(HANDLE_SBR_ENCODER hSbrEncoder)2526 INT sbrEncoder_GetInputDataDelay(HANDLE_SBR_ENCODER hSbrEncoder) {
2527 INT delay = -1;
2528
2529 if (hSbrEncoder) {
2530 delay = hSbrEncoder->inputDataDelay;
2531 }
2532 return delay;
2533 }
2534
sbrEncoder_GetSbrDecDelay(HANDLE_SBR_ENCODER hSbrEncoder)2535 INT sbrEncoder_GetSbrDecDelay(HANDLE_SBR_ENCODER hSbrEncoder) {
2536 INT delay = -1;
2537
2538 if (hSbrEncoder) {
2539 delay = hSbrEncoder->sbrDecDelay;
2540 }
2541 return delay;
2542 }
2543
sbrEncoder_GetLibInfo(LIB_INFO * info)2544 INT sbrEncoder_GetLibInfo(LIB_INFO *info) {
2545 int i;
2546
2547 if (info == NULL) {
2548 return -1;
2549 }
2550 /* search for next free tab */
2551 for (i = 0; i < FDK_MODULE_LAST; i++) {
2552 if (info[i].module_id == FDK_NONE) break;
2553 }
2554 if (i == FDK_MODULE_LAST) {
2555 return -1;
2556 }
2557 info += i;
2558
2559 info->module_id = FDK_SBRENC;
2560 info->version =
2561 LIB_VERSION(SBRENCODER_LIB_VL0, SBRENCODER_LIB_VL1, SBRENCODER_LIB_VL2);
2562 LIB_VERSION_STRING(info);
2563 #ifdef __ANDROID__
2564 info->build_date = "";
2565 info->build_time = "";
2566 #else
2567 info->build_date = __DATE__;
2568 info->build_time = __TIME__;
2569 #endif
2570 info->title = "SBR Encoder";
2571
2572 /* Set flags */
2573 info->flags = 0 | CAPF_SBR_HQ | CAPF_SBR_PS_MPEG;
2574 /* End of flags */
2575
2576 return 0;
2577 }
2578