1
2 /* -----------------------------------------------------------------------------------------------------------
3 Software License for The Fraunhofer FDK AAC Codec Library for Android
4
5 � Copyright 1995 - 2015 Fraunhofer-Gesellschaft zur F�rderung der angewandten Forschung e.V.
6 All rights reserved.
7
8 1. INTRODUCTION
9 The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software that implements
10 the MPEG Advanced Audio Coding ("AAC") encoding and decoding scheme for digital audio.
11 This FDK AAC Codec software is intended to be used on a wide variety of Android devices.
12
13 AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient general perceptual
14 audio codecs. AAC-ELD is considered the best-performing full-bandwidth communications codec by
15 independent studies and is widely deployed. AAC has been standardized by ISO and IEC as part
16 of the MPEG specifications.
17
18 Patent licenses for necessary patent claims for the FDK AAC Codec (including those of Fraunhofer)
19 may be obtained through Via Licensing (www.vialicensing.com) or through the respective patent owners
20 individually for the purpose of encoding or decoding bit streams in products that are compliant with
21 the ISO/IEC MPEG audio standards. Please note that most manufacturers of Android devices already license
22 these patent claims through Via Licensing or directly from the patent owners, and therefore FDK AAC Codec
23 software may already be covered under those patent licenses when it is used for those licensed purposes only.
24
25 Commercially-licensed AAC software libraries, including floating-point versions with enhanced sound quality,
26 are also available from Fraunhofer. Users are encouraged to check the Fraunhofer website for additional
27 applications information and documentation.
28
29 2. COPYRIGHT LICENSE
30
31 Redistribution and use in source and binary forms, with or without modification, are permitted without
32 payment of copyright license fees provided that you satisfy the following conditions:
33
34 You must retain the complete text of this software license in redistributions of the FDK AAC Codec or
35 your modifications thereto in source code form.
36
37 You must retain the complete text of this software license in the documentation and/or other materials
38 provided with redistributions of the FDK AAC Codec or your modifications thereto in binary form.
39 You must make available free of charge copies of the complete source code of the FDK AAC Codec and your
40 modifications thereto to recipients of copies in binary form.
41
42 The name of Fraunhofer may not be used to endorse or promote products derived from this library without
43 prior written permission.
44
45 You may not charge copyright license fees for anyone to use, copy or distribute the FDK AAC Codec
46 software or your modifications thereto.
47
48 Your modified versions of the FDK AAC Codec must carry prominent notices stating that you changed the software
49 and the date of any change. For modified versions of the FDK AAC Codec, the term
50 "Fraunhofer FDK AAC Codec Library for Android" must be replaced by the term
51 "Third-Party Modified Version of the Fraunhofer FDK AAC Codec Library for Android."
52
53 3. NO PATENT LICENSE
54
55 NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without limitation the patents of Fraunhofer,
56 ARE GRANTED BY THIS SOFTWARE LICENSE. Fraunhofer provides no warranty of patent non-infringement with
57 respect to this software.
58
59 You may use this FDK AAC Codec software or modifications thereto only for purposes that are authorized
60 by appropriate patent licenses.
61
62 4. DISCLAIMER
63
64 This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright holders and contributors
65 "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, including but not limited to the implied warranties
66 of merchantability and fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
67 CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, or consequential damages,
68 including but not limited to procurement of substitute goods or services; loss of use, data, or profits,
69 or business interruption, however caused and on any theory of liability, whether in contract, strict
70 liability, or tort (including negligence), arising in any way out of the use of this software, even if
71 advised of the possibility of such damage.
72
73 5. CONTACT INFORMATION
74
75 Fraunhofer Institute for Integrated Circuits IIS
76 Attention: Audio and Multimedia Departments - FDK AAC LL
77 Am Wolfsmantel 33
78 91058 Erlangen, Germany
79
80 www.iis.fraunhofer.de/amm
81 amm-info@iis.fraunhofer.de
82 ----------------------------------------------------------------------------------------------------------- */
83
84 /******************************** MPEG Audio Encoder **************************
85
86 Initial author: M. Werner
87 contents/description: Quantizing & coding
88
89 ******************************************************************************/
90
91 #include "qc_main.h"
92 #include "quantize.h"
93 #include "interface.h"
94 #include "adj_thr.h"
95 #include "sf_estim.h"
96 #include "bit_cnt.h"
97 #include "dyn_bits.h"
98 #include "channel_map.h"
99 #include "aacEnc_ram.h"
100
101 #include "genericStds.h"
102
103
104 typedef struct {
105 QCDATA_BR_MODE bitrateMode;
106 LONG vbrQualFactor;
107 } TAB_VBR_QUAL_FACTOR;
108
109 static const TAB_VBR_QUAL_FACTOR tableVbrQualFactor[] = {
110 {QCDATA_BR_MODE_VBR_1, FL2FXCONST_DBL(0.160f)}, /* 32 kbps mono AAC-LC + SBR + PS */
111 {QCDATA_BR_MODE_VBR_2, FL2FXCONST_DBL(0.148f)}, /* 64 kbps stereo AAC-LC + SBR */
112 {QCDATA_BR_MODE_VBR_3, FL2FXCONST_DBL(0.135f)}, /* 80 - 96 kbps stereo AAC-LC */
113 {QCDATA_BR_MODE_VBR_4, FL2FXCONST_DBL(0.111f)}, /* 128 kbps stereo AAC-LC */
114 {QCDATA_BR_MODE_VBR_5, FL2FXCONST_DBL(0.070f)} /* 192 kbps stereo AAC-LC */
115 };
116
isConstantBitrateMode(const QCDATA_BR_MODE bitrateMode)117 static INT isConstantBitrateMode(
118 const QCDATA_BR_MODE bitrateMode
119 )
120 {
121 return ( ((bitrateMode==QCDATA_BR_MODE_CBR) || (bitrateMode==QCDATA_BR_MODE_SFR) || (bitrateMode==QCDATA_BR_MODE_FF)) ? 1 : 0 );
122 }
123
124
125
126 typedef enum{
127 FRAME_LEN_BYTES_MODULO = 1,
128 FRAME_LEN_BYTES_INT = 2
129 }FRAME_LEN_RESULT_MODE;
130
131 /* forward declarations */
132
133 static INT FDKaacEnc_calcMaxValueInSfb(INT sfbCnt,
134 INT maxSfbPerGroup,
135 INT sfbPerGroup,
136 INT *RESTRICT sfbOffset,
137 SHORT *RESTRICT quantSpectrum,
138 UINT *RESTRICT maxValue);
139
140 static void FDKaacEnc_crashRecovery(INT nChannels,
141 PSY_OUT_ELEMENT* psyOutElement,
142 QC_OUT* qcOut,
143 QC_OUT_ELEMENT *qcElement,
144 INT bitsToSave,
145 AUDIO_OBJECT_TYPE aot,
146 UINT syntaxFlags,
147 SCHAR epConfig);
148
149 static
150 AAC_ENCODER_ERROR FDKaacEnc_reduceBitConsumption(int* iterations,
151 const int maxIterations,
152 int gainAdjustment,
153 int* chConstraintsFulfilled,
154 int* calculateQuant,
155 int nChannels,
156 PSY_OUT_ELEMENT* psyOutElement,
157 QC_OUT* qcOut,
158 QC_OUT_ELEMENT* qcOutElement,
159 ELEMENT_BITS* elBits,
160 AUDIO_OBJECT_TYPE aot,
161 UINT syntaxFlags,
162 SCHAR epConfig);
163
164
165 void FDKaacEnc_QCClose (QC_STATE **phQCstate, QC_OUT **phQC);
166
167 /*****************************************************************************
168
169 functionname: FDKaacEnc_calcFrameLen
170 description:
171 returns:
172 input:
173 output:
174
175 *****************************************************************************/
FDKaacEnc_calcFrameLen(INT bitRate,INT sampleRate,INT granuleLength,FRAME_LEN_RESULT_MODE mode)176 static INT FDKaacEnc_calcFrameLen(INT bitRate,
177 INT sampleRate,
178 INT granuleLength,
179 FRAME_LEN_RESULT_MODE mode)
180 {
181
182 INT result;
183
184 result = ((granuleLength)>>3)*(bitRate);
185
186 switch(mode) {
187 case FRAME_LEN_BYTES_MODULO:
188 result %= sampleRate;
189 break;
190 case FRAME_LEN_BYTES_INT:
191 result /= sampleRate;
192 break;
193 }
194 return(result);
195 }
196
197 /*****************************************************************************
198
199 functionname:FDKaacEnc_framePadding
200 description: Calculates if padding is needed for actual frame
201 returns:
202 input:
203 output:
204
205 *****************************************************************************/
FDKaacEnc_framePadding(INT bitRate,INT sampleRate,INT granuleLength,INT * paddingRest)206 static INT FDKaacEnc_framePadding(INT bitRate,
207 INT sampleRate,
208 INT granuleLength,
209 INT *paddingRest)
210 {
211 INT paddingOn;
212 INT difference;
213
214 paddingOn = 0;
215
216 difference = FDKaacEnc_calcFrameLen( bitRate,
217 sampleRate,
218 granuleLength,
219 FRAME_LEN_BYTES_MODULO );
220 *paddingRest-=difference;
221
222 if (*paddingRest <= 0 ) {
223 paddingOn = 1;
224 *paddingRest += sampleRate;
225 }
226
227 return( paddingOn );
228 }
229
230
231 /*********************************************************************************
232
233 functionname: FDKaacEnc_QCOutNew
234 description:
235 return:
236
237 **********************************************************************************/
FDKaacEnc_QCOutNew(QC_OUT ** phQC,const INT nElements,const INT nChannels,const INT nSubFrames,UCHAR * dynamic_RAM)238 AAC_ENCODER_ERROR FDKaacEnc_QCOutNew(QC_OUT **phQC,
239 const INT nElements,
240 const INT nChannels,
241 const INT nSubFrames
242 ,UCHAR *dynamic_RAM
243 )
244 {
245 AAC_ENCODER_ERROR ErrorStatus;
246 int n, i;
247 int elInc = 0, chInc = 0;
248
249 for (n=0; n<nSubFrames; n++) {
250 phQC[n] = GetRam_aacEnc_QCout(n);
251 if (phQC[n] == NULL) {
252 ErrorStatus = AAC_ENC_NO_MEMORY;
253 goto QCOutNew_bail;
254 }
255
256 for (i=0; i<nChannels; i++) {
257 phQC[n]->pQcOutChannels[i] = GetRam_aacEnc_QCchannel(chInc, dynamic_RAM);
258 if ( phQC[n]->pQcOutChannels[i] == NULL
259 )
260 {
261 ErrorStatus = AAC_ENC_NO_MEMORY;
262 goto QCOutNew_bail;
263 }
264 chInc++;
265 } /* nChannels */
266
267 for (i=0; i<nElements; i++) {
268 phQC[n]->qcElement[i] = GetRam_aacEnc_QCelement(elInc);
269 if (phQC[n]->qcElement[i] == NULL)
270 {
271 ErrorStatus = AAC_ENC_NO_MEMORY;
272 goto QCOutNew_bail;
273 }
274 elInc++;
275 } /* nElements */
276
277 } /* nSubFrames */
278
279
280 return AAC_ENC_OK;
281
282 QCOutNew_bail:
283 return ErrorStatus;
284 }
285
286 /*********************************************************************************
287
288 functionname: FDKaacEnc_QCOutInit
289 description:
290 return:
291
292 **********************************************************************************/
FDKaacEnc_QCOutInit(QC_OUT * phQC[(1)],const INT nSubFrames,const CHANNEL_MAPPING * cm)293 AAC_ENCODER_ERROR FDKaacEnc_QCOutInit(QC_OUT *phQC[(1)],
294 const INT nSubFrames,
295 const CHANNEL_MAPPING *cm)
296 {
297 INT n,i,ch;
298
299 for (n=0; n<nSubFrames; n++) {
300 INT chInc = 0;
301 for (i=0; i<cm->nElements; i++) {
302 for (ch=0; ch<cm->elInfo[i].nChannelsInEl; ch++) {
303 phQC[n]->qcElement[i]->qcOutChannel[ch] = phQC[n]->pQcOutChannels[chInc];
304 chInc++;
305 } /* chInEl */
306 } /* nElements */
307 } /* nSubFrames */
308
309 return AAC_ENC_OK;
310 }
311
312 /*********************************************************************************
313
314 functionname: FDKaacEnc_QCNew
315 description:
316 return:
317
318 **********************************************************************************/
FDKaacEnc_QCNew(QC_STATE ** phQC,INT nElements,UCHAR * dynamic_RAM)319 AAC_ENCODER_ERROR FDKaacEnc_QCNew(QC_STATE **phQC,
320 INT nElements
321 ,UCHAR* dynamic_RAM
322 )
323 {
324 AAC_ENCODER_ERROR ErrorStatus;
325 int i;
326
327 QC_STATE* hQC = GetRam_aacEnc_QCstate();
328 *phQC = hQC;
329 if (hQC == NULL) {
330 ErrorStatus = AAC_ENC_NO_MEMORY;
331 goto QCNew_bail;
332 }
333
334 if (FDKaacEnc_AdjThrNew(&hQC->hAdjThr, nElements)) {
335 ErrorStatus = AAC_ENC_NO_MEMORY;
336 goto QCNew_bail;
337 }
338
339 if (FDKaacEnc_BCNew(&(hQC->hBitCounter), dynamic_RAM)) {
340 ErrorStatus = AAC_ENC_NO_MEMORY;
341 goto QCNew_bail;
342 }
343
344 for (i=0; i<nElements; i++) {
345 hQC->elementBits[i] = GetRam_aacEnc_ElementBits(i);
346 if (hQC->elementBits[i] == NULL) {
347 ErrorStatus = AAC_ENC_NO_MEMORY;
348 goto QCNew_bail;
349 }
350 }
351
352 return AAC_ENC_OK;
353
354 QCNew_bail:
355 FDKaacEnc_QCClose(phQC, NULL);
356 return ErrorStatus;
357 }
358
359 /*********************************************************************************
360
361 functionname: FDKaacEnc_QCInit
362 description:
363 return:
364
365 **********************************************************************************/
FDKaacEnc_QCInit(QC_STATE * hQC,struct QC_INIT * init)366 AAC_ENCODER_ERROR FDKaacEnc_QCInit(QC_STATE *hQC,
367 struct QC_INIT *init)
368 {
369 int i;
370 hQC->maxBitsPerFrame = init->maxBits;
371 hQC->minBitsPerFrame = init->minBits;
372 hQC->nElements = init->channelMapping->nElements;
373 hQC->bitResTotMax = init->bitRes;
374 hQC->bitResTot = init->bitRes;
375 hQC->maxBitFac = init->maxBitFac;
376 hQC->bitrateMode = init->bitrateMode;
377 hQC->invQuant = init->invQuant;
378 hQC->maxIterations = init->maxIterations;
379
380 if ( isConstantBitrateMode(hQC->bitrateMode) ) {
381 INT bitresPerChannel = (hQC->bitResTotMax / init->channelMapping->nChannelsEff);
382 /* 0: full bitreservoir, 1: reduced bitreservoir, 2: disabled bitreservoir */
383 hQC->bitDistributionMode = (bitresPerChannel>BITRES_MIN_LD) ? 0 : (bitresPerChannel>0) ? 1 : 2;
384 }
385 else {
386 hQC->bitDistributionMode = 0; /* full bitreservoir */
387 }
388
389
390 hQC->padding.paddingRest = init->padding.paddingRest;
391
392 hQC->globHdrBits = init->staticBits; /* Bit overhead due to transport */
393
394 FDKaacEnc_InitElementBits(hQC,
395 init->channelMapping,
396 init->bitrate,
397 (init->averageBits/init->nSubFrames) - hQC->globHdrBits,
398 hQC->maxBitsPerFrame/init->channelMapping->nChannelsEff);
399
400 hQC->vbrQualFactor = FL2FXCONST_DBL(0.f);
401 for (i=0; i<(int)(sizeof(tableVbrQualFactor)/sizeof(TAB_VBR_QUAL_FACTOR)); i++) {
402 if (hQC->bitrateMode==tableVbrQualFactor[i].bitrateMode) {
403 hQC->vbrQualFactor = (FIXP_DBL)tableVbrQualFactor[i].vbrQualFactor;
404 break;
405 }
406 }
407
408 if (init->channelMapping->nChannelsEff == 1 &&
409 (init->bitrate / init->channelMapping->nChannelsEff) < 32000 &&
410 init->advancedBitsToPe != 0
411 )
412 {
413 hQC->dZoneQuantEnable = 1;
414 } else {
415 hQC->dZoneQuantEnable = 0;
416 }
417
418 FDKaacEnc_AdjThrInit(
419 hQC->hAdjThr,
420 init->meanPe,
421 hQC->elementBits, /* or channelBitrates, was: channelBitrate */
422 hQC->invQuant,
423 init->channelMapping->nElements,
424 init->channelMapping->nChannelsEff,
425 init->sampleRate, /* output sample rate */
426 init->advancedBitsToPe, /* if set, calc bits2PE factor depending on samplerate */
427 hQC->vbrQualFactor,
428 hQC->dZoneQuantEnable
429 );
430
431 return AAC_ENC_OK;
432 }
433
434
435
436 /*********************************************************************************
437
438 functionname: FDKaacEnc_QCMainPrepare
439 description:
440 return:
441
442 **********************************************************************************/
FDKaacEnc_QCMainPrepare(ELEMENT_INFO * elInfo,ATS_ELEMENT * RESTRICT adjThrStateElement,PSY_OUT_ELEMENT * RESTRICT psyOutElement,QC_OUT_ELEMENT * RESTRICT qcOutElement,AUDIO_OBJECT_TYPE aot,UINT syntaxFlags,SCHAR epConfig)443 AAC_ENCODER_ERROR FDKaacEnc_QCMainPrepare(ELEMENT_INFO *elInfo,
444 ATS_ELEMENT* RESTRICT adjThrStateElement,
445 PSY_OUT_ELEMENT* RESTRICT psyOutElement,
446 QC_OUT_ELEMENT* RESTRICT qcOutElement,
447 AUDIO_OBJECT_TYPE aot,
448 UINT syntaxFlags,
449 SCHAR epConfig
450 )
451 {
452 AAC_ENCODER_ERROR ErrorStatus = AAC_ENC_OK;
453 INT nChannels = elInfo->nChannelsInEl;
454
455 PSY_OUT_CHANNEL** RESTRICT psyOutChannel = psyOutElement->psyOutChannel; /* may be modified in-place */
456
457 FDKaacEnc_CalcFormFactor(qcOutElement->qcOutChannel, psyOutChannel, nChannels);
458
459 /* prepare and calculate PE without reduction */
460 FDKaacEnc_peCalculation(&qcOutElement->peData, psyOutChannel, qcOutElement->qcOutChannel, &psyOutElement->toolsInfo, adjThrStateElement, nChannels);
461
462 ErrorStatus = FDKaacEnc_ChannelElementWrite( NULL, elInfo, NULL,
463 psyOutElement,
464 psyOutElement->psyOutChannel,
465 syntaxFlags,
466 aot,
467 epConfig,
468 &qcOutElement->staticBitsUsed,
469 0 );
470
471 return ErrorStatus;
472 }
473
474 /*********************************************************************************
475
476 functionname: FDKaacEnc_AdjustBitrate
477 description: adjusts framelength via padding on a frame to frame basis,
478 to achieve a bitrate that demands a non byte aligned
479 framelength
480 return: errorcode
481
482 **********************************************************************************/
FDKaacEnc_AdjustBitrate(QC_STATE * RESTRICT hQC,CHANNEL_MAPPING * RESTRICT cm,INT * avgTotalBits,INT bitRate,INT sampleRate,INT granuleLength)483 AAC_ENCODER_ERROR FDKaacEnc_AdjustBitrate(QC_STATE *RESTRICT hQC,
484 CHANNEL_MAPPING *RESTRICT cm,
485 INT *avgTotalBits,
486 INT bitRate, /* total bitrate */
487 INT sampleRate, /* output sampling rate */
488 INT granuleLength) /* frame length */
489 {
490 INT paddingOn;
491 INT frameLen;
492
493 /* Do we need an extra padding byte? */
494 paddingOn = FDKaacEnc_framePadding(bitRate,
495 sampleRate,
496 granuleLength,
497 &hQC->padding.paddingRest);
498
499 frameLen = paddingOn + FDKaacEnc_calcFrameLen(bitRate,
500 sampleRate,
501 granuleLength,
502 FRAME_LEN_BYTES_INT);
503
504 *avgTotalBits = frameLen<<3;
505
506 return AAC_ENC_OK;
507 }
508
FDKaacEnc_distributeElementDynBits(QC_STATE * hQC,QC_OUT_ELEMENT * qcElement[(8)],CHANNEL_MAPPING * cm,INT codeBits)509 static AAC_ENCODER_ERROR FDKaacEnc_distributeElementDynBits(QC_STATE* hQC,
510 QC_OUT_ELEMENT* qcElement[(8)],
511 CHANNEL_MAPPING* cm,
512 INT codeBits)
513 {
514
515 INT i, firstEl = cm->nElements-1;
516 INT totalBits = 0;
517
518 for (i=(cm->nElements-1); i>=0; i--) {
519 if ((cm->elInfo[i].elType == ID_SCE) || (cm->elInfo[i].elType == ID_CPE) ||
520 (cm->elInfo[i].elType == ID_LFE))
521 {
522 qcElement[i]->grantedDynBits = (INT)fMult(hQC->elementBits[i]->relativeBitsEl, (FIXP_DBL)codeBits);
523 totalBits += qcElement[i]->grantedDynBits;
524 firstEl = i;
525 }
526 }
527 qcElement[firstEl]->grantedDynBits += codeBits - totalBits;
528
529 return AAC_ENC_OK;
530 }
531
532 /**
533 * \brief Verify whether minBitsPerFrame criterion can be satisfied.
534 *
535 * This function evaluates the bit consumption only if minBitsPerFrame parameter is not 0.
536 * In hyperframing mode the difference between grantedDynBits and usedDynBits of all sub frames
537 * results the number of fillbits to be written.
538 * This bits can be distrubitued in superframe to reach minBitsPerFrame bit consumption in single AU's.
539 * The return value denotes if enough desired fill bits are available to achieve minBitsPerFrame in all frames.
540 * This check can only be used within superframes.
541 *
542 * \param qcOut Pointer to coding data struct.
543 * \param minBitsPerFrame Minimal number of bits to be consumed in each frame.
544 * \param nSubFrames Number of frames in superframe
545 *
546 * \return
547 * - 1: all fine
548 * - 0: criterion not fulfilled
549 */
checkMinFrameBitsDemand(QC_OUT ** qcOut,const INT minBitsPerFrame,const INT nSubFrames)550 static int checkMinFrameBitsDemand(
551 QC_OUT** qcOut,
552 const INT minBitsPerFrame,
553 const INT nSubFrames
554 )
555 {
556 int result = 1; /* all fine*/
557 return result;
558 }
559
560 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
561
562 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
563 /*********************************************************************************
564
565 functionname: FDKaacEnc_getMinimalStaticBitdemand
566 description: calculate minmal size of static bits by reduction ,
567 to zero spectrum and deactivating tns and MS
568 return: number of static bits
569
570 **********************************************************************************/
FDKaacEnc_getMinimalStaticBitdemand(CHANNEL_MAPPING * cm,PSY_OUT ** psyOut)571 static int FDKaacEnc_getMinimalStaticBitdemand(CHANNEL_MAPPING* cm,
572 PSY_OUT** psyOut)
573 {
574 AUDIO_OBJECT_TYPE aot = AOT_AAC_LC;
575 UINT syntaxFlags = 0;
576 SCHAR epConfig = -1;
577 int i, bitcount = 0;
578
579 for (i=0; i<cm->nElements; i++) {
580 ELEMENT_INFO elInfo = cm->elInfo[i];
581
582 if ( (elInfo.elType == ID_SCE)
583 || (elInfo.elType == ID_CPE)
584 || (elInfo.elType == ID_LFE) )
585 {
586 INT minElBits = 0;
587
588 FDKaacEnc_ChannelElementWrite( NULL, &elInfo, NULL,
589 psyOut[0]->psyOutElement[i],
590 psyOut[0]->psyOutElement[i]->psyOutChannel,
591 syntaxFlags,
592 aot,
593 epConfig,
594 &minElBits,
595 1 );
596 bitcount += minElBits;
597 }
598 }
599
600 return bitcount;
601 }
602
603 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
604
FDKaacEnc_prepareBitDistribution(QC_STATE * hQC,PSY_OUT ** psyOut,QC_OUT ** qcOut,CHANNEL_MAPPING * cm,QC_OUT_ELEMENT * qcElement[(1)][(8)],INT avgTotalBits,INT * totalAvailableBits,INT * avgTotalDynBits)605 static AAC_ENCODER_ERROR FDKaacEnc_prepareBitDistribution(QC_STATE* hQC,
606 PSY_OUT** psyOut,
607 QC_OUT** qcOut,
608 CHANNEL_MAPPING* cm,
609 QC_OUT_ELEMENT* qcElement[(1)][(8)],
610 INT avgTotalBits,
611 INT *totalAvailableBits,
612 INT *avgTotalDynBits)
613 {
614 int i;
615 /* get maximal allowed dynamic bits */
616 qcOut[0]->grantedDynBits = (fixMin(hQC->maxBitsPerFrame, avgTotalBits) - hQC->globHdrBits)&~7;
617 qcOut[0]->grantedDynBits -= (qcOut[0]->globalExtBits + qcOut[0]->staticBits + qcOut[0]->elementExtBits);
618 qcOut[0]->maxDynBits = ((hQC->maxBitsPerFrame)&~7) - (qcOut[0]->globalExtBits + qcOut[0]->staticBits + qcOut[0]->elementExtBits);
619 /* assure that enough bits are available */
620 if ((qcOut[0]->grantedDynBits+hQC->bitResTot) < 0) {
621 /* crash recovery allows to reduce static bits to a minimum */
622 if ( (qcOut[0]->grantedDynBits+hQC->bitResTot) < (FDKaacEnc_getMinimalStaticBitdemand(cm, psyOut)-qcOut[0]->staticBits) )
623 return AAC_ENC_BITRES_TOO_LOW;
624 }
625
626 /* distribute dynamic bits to each element */
627 FDKaacEnc_distributeElementDynBits(hQC,
628 qcElement[0],
629 cm,
630 qcOut[0]->grantedDynBits);
631
632 *avgTotalDynBits = 0; /*frameDynBits;*/
633
634 *totalAvailableBits = avgTotalBits;
635
636 /* sum up corrected granted PE */
637 qcOut[0]->totalGrantedPeCorr = 0;
638
639 for (i=0; i<cm->nElements; i++)
640 {
641 ELEMENT_INFO elInfo = cm->elInfo[i];
642 int nChannels = elInfo.nChannelsInEl;
643
644 if ((elInfo.elType == ID_SCE) || (elInfo.elType == ID_CPE) ||
645 (elInfo.elType == ID_LFE))
646 {
647 /* for ( all sub frames ) ... */
648 FDKaacEnc_DistributeBits(hQC->hAdjThr,
649 hQC->hAdjThr->adjThrStateElem[i],
650 psyOut[0]->psyOutElement[i]->psyOutChannel,
651 &qcElement[0][i]->peData,
652 &qcElement[0][i]->grantedPe,
653 &qcElement[0][i]->grantedPeCorr,
654 nChannels,
655 psyOut[0]->psyOutElement[i]->commonWindow,
656 qcElement[0][i]->grantedDynBits,
657 hQC->elementBits[i]->bitResLevelEl,
658 hQC->elementBits[i]->maxBitResBitsEl,
659 hQC->maxBitFac,
660 hQC->bitDistributionMode);
661
662 *totalAvailableBits += hQC->elementBits[i]->bitResLevelEl;
663 /* get total corrected granted PE */
664 qcOut[0]->totalGrantedPeCorr += qcElement[0][i]->grantedPeCorr;
665 } /* -end- if(ID_SCE || ID_CPE || ID_LFE) */
666
667 } /* -end- element loop */
668
669 *totalAvailableBits = FDKmin(hQC->maxBitsPerFrame, (*totalAvailableBits));
670
671 return AAC_ENC_OK;
672 }
673
674 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
FDKaacEnc_updateUsedDynBits(INT * sumDynBitsConsumed,QC_OUT_ELEMENT * qcElement[(8)],CHANNEL_MAPPING * cm)675 static AAC_ENCODER_ERROR FDKaacEnc_updateUsedDynBits(INT* sumDynBitsConsumed,
676 QC_OUT_ELEMENT* qcElement[(8)],
677 CHANNEL_MAPPING* cm)
678 {
679 INT i;
680
681 *sumDynBitsConsumed = 0;
682
683 for (i=0; i<cm->nElements; i++)
684 {
685 ELEMENT_INFO elInfo = cm->elInfo[i];
686
687 if ((elInfo.elType == ID_SCE) || (elInfo.elType == ID_CPE) ||
688 (elInfo.elType == ID_LFE))
689 {
690 /* sum up bits consumed */
691 *sumDynBitsConsumed += qcElement[i]->dynBitsUsed;
692 } /* -end- if(ID_SCE || ID_CPE || ID_LFE) */
693
694 } /* -end- element loop */
695
696 return AAC_ENC_OK;
697 }
698
699
FDKaacEnc_getTotalConsumedDynBits(QC_OUT ** qcOut,INT nSubFrames)700 static INT FDKaacEnc_getTotalConsumedDynBits(QC_OUT** qcOut,
701 INT nSubFrames)
702 {
703 INT c, totalBits=0;
704
705 /* sum up bit consumption for all sub frames */
706 for (c=0; c<nSubFrames; c++)
707 {
708 /* bit consumption not valid if dynamic bits
709 not available in one sub frame */
710 if (qcOut[c]->usedDynBits==-1) return -1;
711 totalBits += qcOut[c]->usedDynBits;
712 }
713
714 return totalBits;
715
716 }
717
FDKaacEnc_getTotalConsumedBits(QC_OUT ** qcOut,QC_OUT_ELEMENT * qcElement[(1)][(8)],CHANNEL_MAPPING * cm,INT globHdrBits,INT nSubFrames)718 static INT FDKaacEnc_getTotalConsumedBits(QC_OUT** qcOut,
719 QC_OUT_ELEMENT* qcElement[(1)][(8)],
720 CHANNEL_MAPPING* cm,
721 INT globHdrBits,
722 INT nSubFrames)
723 {
724 int c, i;
725 int totalUsedBits = 0;
726
727 for (c = 0 ; c < nSubFrames ; c++ )
728 {
729 int dataBits = 0;
730 for (i=0; i<cm->nElements; i++)
731 {
732 if ((cm->elInfo[i].elType == ID_SCE) || (cm->elInfo[i].elType == ID_CPE) ||
733 (cm->elInfo[i].elType == ID_LFE))
734 {
735 dataBits += qcElement[c][i]->dynBitsUsed + qcElement[c][i]->staticBitsUsed + qcElement[c][i]->extBitsUsed;
736 }
737 }
738 dataBits += qcOut[c]->globalExtBits;
739
740 totalUsedBits += (8 - (dataBits) % 8) % 8;
741 totalUsedBits += dataBits + globHdrBits; /* header bits for every frame */
742 }
743 return totalUsedBits;
744 }
745
FDKaacEnc_BitResRedistribution(QC_STATE * const hQC,const CHANNEL_MAPPING * const cm,const INT avgTotalBits)746 static AAC_ENCODER_ERROR FDKaacEnc_BitResRedistribution(
747 QC_STATE *const hQC,
748 const CHANNEL_MAPPING *const cm,
749 const INT avgTotalBits
750 )
751 {
752 /* check bitreservoir fill level */
753 if (hQC->bitResTot < 0) {
754 return AAC_ENC_BITRES_TOO_LOW;
755 }
756 else if (hQC->bitResTot > hQC->bitResTotMax) {
757 return AAC_ENC_BITRES_TOO_HIGH;
758 }
759 else {
760 INT i, firstEl = cm->nElements-1;
761 INT totalBits = 0, totalBits_max = 0;
762
763 int totalBitreservoir = FDKmin(hQC->bitResTot, (hQC->maxBitsPerFrame-avgTotalBits));
764 int totalBitreservoirMax = FDKmin(hQC->bitResTotMax, (hQC->maxBitsPerFrame-avgTotalBits));
765
766 int sc_bitResTot = CountLeadingBits(totalBitreservoir);
767 int sc_bitResTotMax = CountLeadingBits(totalBitreservoirMax);
768
769 for (i=(cm->nElements-1); i>=0; i--) {
770 if ((cm->elInfo[i].elType == ID_SCE) || (cm->elInfo[i].elType == ID_CPE) ||
771 (cm->elInfo[i].elType == ID_LFE))
772 {
773 hQC->elementBits[i]->bitResLevelEl = (INT)fMult(hQC->elementBits[i]->relativeBitsEl, (FIXP_DBL)(totalBitreservoir<<sc_bitResTot))>>sc_bitResTot;
774 totalBits += hQC->elementBits[i]->bitResLevelEl;
775
776 hQC->elementBits[i]->maxBitResBitsEl = (INT)fMult(hQC->elementBits[i]->relativeBitsEl, (FIXP_DBL)(totalBitreservoirMax<<sc_bitResTotMax))>>sc_bitResTotMax;
777 totalBits_max += hQC->elementBits[i]->maxBitResBitsEl;
778
779 firstEl = i;
780 }
781 }
782 hQC->elementBits[firstEl]->bitResLevelEl += totalBitreservoir - totalBits;
783 hQC->elementBits[firstEl]->maxBitResBitsEl += totalBitreservoirMax - totalBits_max;
784 }
785
786 return AAC_ENC_OK;
787 }
788
789
FDKaacEnc_QCMain(QC_STATE * RESTRICT hQC,PSY_OUT ** psyOut,QC_OUT ** qcOut,INT avgTotalBits,CHANNEL_MAPPING * cm,AUDIO_OBJECT_TYPE aot,UINT syntaxFlags,SCHAR epConfig)790 AAC_ENCODER_ERROR FDKaacEnc_QCMain(QC_STATE* RESTRICT hQC,
791 PSY_OUT** psyOut,
792 QC_OUT** qcOut,
793 INT avgTotalBits,
794 CHANNEL_MAPPING* cm
795 ,AUDIO_OBJECT_TYPE aot,
796 UINT syntaxFlags,
797 SCHAR epConfig
798 )
799 {
800 int i, c;
801 AAC_ENCODER_ERROR ErrorStatus = AAC_ENC_OK;
802 INT avgTotalDynBits = 0; /* maximal allowed dynamic bits for all frames */
803 INT totalAvailableBits = 0;
804 INT nSubFrames = 1;
805
806 /*-------------------------------------------- */
807 /* redistribute total bitreservoir to elements */
808 ErrorStatus = FDKaacEnc_BitResRedistribution(hQC, cm, avgTotalBits);
809 if (ErrorStatus != AAC_ENC_OK) {
810 return ErrorStatus;
811 }
812
813 /*-------------------------------------------- */
814 /* fastenc needs one time threshold simulation,
815 in case of multiple frames, one more guess has to be calculated */
816
817 /*-------------------------------------------- */
818 /* helper pointer */
819 QC_OUT_ELEMENT* qcElement[(1)][(8)];
820
821 /* work on a copy of qcChannel and qcElement */
822 for (i=0; i<cm->nElements; i++)
823 {
824 ELEMENT_INFO elInfo = cm->elInfo[i];
825
826 if ((elInfo.elType == ID_SCE) || (elInfo.elType == ID_CPE) ||
827 (elInfo.elType == ID_LFE))
828 {
829 /* for ( all sub frames ) ... */
830 for (c = 0 ; c < nSubFrames ; c++ )
831 {
832 {
833 qcElement[c][i] = qcOut[c]->qcElement[i];
834 }
835 }
836 }
837 }
838
839 /*-------------------------------------------- */
840 /*-------------------------------------------- */
841 if ( isConstantBitrateMode(hQC->bitrateMode) )
842 {
843 /* calc granted dynamic bits for sub frame and
844 distribute it to each element */
845 ErrorStatus = FDKaacEnc_prepareBitDistribution(
846 hQC,
847 psyOut,
848 qcOut,
849 cm,
850 qcElement,
851 avgTotalBits,
852 &totalAvailableBits,
853 &avgTotalDynBits);
854
855 if (ErrorStatus != AAC_ENC_OK) {
856 return ErrorStatus;
857 }
858 }
859 else {
860 qcOut[0]->grantedDynBits = ((hQC->maxBitsPerFrame - (hQC->globHdrBits))&~7)
861 - (qcOut[0]->globalExtBits + qcOut[0]->staticBits + qcOut[0]->elementExtBits);
862 qcOut[0]->maxDynBits = qcOut[0]->grantedDynBits;
863
864 totalAvailableBits = hQC->maxBitsPerFrame;
865 avgTotalDynBits = 0;
866 }
867
868 #ifdef PNS_PRECOUNT_ENABLE
869 /* Calculate estimated pns bits and substract them from grantedDynBits to get a more accurate number of available bits. */
870 if (syntaxFlags & (AC_LD|AC_ELD))
871 {
872 int estimatedPnsBits = 0, ch;
873
874 for (ch=0; ch<cm->nChannels; ch++) {
875 qcOut[0]->pQcOutChannels[ch]->sectionData.noiseNrgBits = noisePreCount(psyOut[0]->pPsyOutChannels[ch]->noiseNrg, psyOut[0]->pPsyOutChannels[ch]->maxSfbPerGroup);
876 estimatedPnsBits += qcOut[0]->pQcOutChannels[ch]->sectionData.noiseNrgBits;
877 }
878 qcOut[0]->grantedDynBits -= estimatedPnsBits;
879 }
880 #endif
881
882 /* for ( all sub frames ) ... */
883 for (c = 0 ; c < nSubFrames ; c++ )
884 {
885 /* for CBR and VBR mode */
886 FDKaacEnc_AdjustThresholds(hQC->hAdjThr->adjThrStateElem,
887 qcElement[c],
888 qcOut[c],
889 psyOut[c]->psyOutElement,
890 isConstantBitrateMode(hQC->bitrateMode),
891 hQC->hAdjThr->maxIter2ndGuess,
892 cm);
893
894 } /* -end- sub frame counter */
895
896 /*-------------------------------------------- */
897 INT iterations[(1)][(8)];
898 INT chConstraintsFulfilled[(1)][(8)][(2)];
899 INT calculateQuant[(1)][(8)][(2)];
900 INT constraintsFulfilled[(1)][(8)];
901 /*-------------------------------------------- */
902
903
904 /* for ( all sub frames ) ... */
905 for (c = 0 ; c < nSubFrames ; c++ )
906 {
907 for (i=0; i<cm->nElements; i++)
908 {
909 ELEMENT_INFO elInfo = cm->elInfo[i];
910 INT ch, nChannels = elInfo.nChannelsInEl;
911
912 if ((elInfo.elType == ID_SCE) || (elInfo.elType == ID_CPE) ||
913 (elInfo.elType == ID_LFE))
914 {
915 /* Turn thresholds into scalefactors, optimize bit consumption and verify conformance */
916 FDKaacEnc_EstimateScaleFactors(psyOut[c]->psyOutElement[i]->psyOutChannel,
917 qcElement[c][i]->qcOutChannel,
918 hQC->invQuant,
919 hQC->dZoneQuantEnable,
920 cm->elInfo[i].nChannelsInEl);
921
922
923 /*-------------------------------------------- */
924 constraintsFulfilled[c][i] = 1;
925 iterations[c][i] = 0 ;
926
927 for (ch = 0; ch < nChannels; ch++)
928 {
929 chConstraintsFulfilled[c][i][ch] = 1;
930 calculateQuant[c][i][ch] = 1;
931 }
932
933 /*-------------------------------------------- */
934
935 } /* -end- if(ID_SCE || ID_CPE || ID_LFE) */
936
937 } /* -end- element loop */
938
939 qcOut[c]->usedDynBits = -1;
940
941 } /* -end- sub frame counter */
942
943
944
945 INT quantizationDone = 0;
946 INT sumDynBitsConsumedTotal = 0;
947 INT decreaseBitConsumption = -1; /* no direction yet! */
948
949 /*-------------------------------------------- */
950 /* -start- Quantization loop ... */
951 /*-------------------------------------------- */
952 do /* until max allowed bits per frame and maxDynBits!=-1*/
953 {
954 quantizationDone = 0;
955
956 c = 0; /* get frame to process */
957
958 for (i=0; i<cm->nElements; i++)
959 {
960 ELEMENT_INFO elInfo = cm->elInfo[i];
961 INT ch, nChannels = elInfo.nChannelsInEl;
962
963 if ((elInfo.elType == ID_SCE) || (elInfo.elType == ID_CPE) ||
964 (elInfo.elType == ID_LFE))
965 {
966 do /* until spectral values < MAX_QUANT */
967 {
968 /*-------------------------------------------- */
969 if (!constraintsFulfilled[c][i])
970 {
971 FDKaacEnc_reduceBitConsumption(&iterations[c][i],
972 hQC->maxIterations,
973 (decreaseBitConsumption) ? 1 : -1,
974 chConstraintsFulfilled[c][i],
975 calculateQuant[c][i],
976 nChannels,
977 psyOut[c]->psyOutElement[i],
978 qcOut[c],
979 qcElement[c][i],
980 hQC->elementBits[i],
981 aot,
982 syntaxFlags,
983 epConfig);
984 }
985
986 /*-------------------------------------------- */
987 /*-------------------------------------------- */
988 constraintsFulfilled[c][i] = 1 ;
989
990 /*-------------------------------------------- */
991 /* quantize spectrum (per each channel) */
992 for (ch = 0; ch < nChannels; ch++)
993 {
994 /*-------------------------------------------- */
995 chConstraintsFulfilled[c][i][ch] = 1;
996
997 /*-------------------------------------------- */
998
999 if (calculateQuant[c][i][ch])
1000 {
1001 QC_OUT_CHANNEL* qcOutCh = qcElement[c][i]->qcOutChannel[ch];
1002 PSY_OUT_CHANNEL* psyOutCh = psyOut[c]->psyOutElement[i]->psyOutChannel[ch];
1003
1004 calculateQuant[c][i][ch] = 0; /* calculate quantization only if necessary */
1005
1006 /*-------------------------------------------- */
1007 FDKaacEnc_QuantizeSpectrum(psyOutCh->sfbCnt,
1008 psyOutCh->maxSfbPerGroup,
1009 psyOutCh->sfbPerGroup,
1010 psyOutCh->sfbOffsets,
1011 qcOutCh->mdctSpectrum,
1012 qcOutCh->globalGain,
1013 qcOutCh->scf,
1014 qcOutCh->quantSpec,
1015 hQC->dZoneQuantEnable);
1016
1017 /*-------------------------------------------- */
1018 if (FDKaacEnc_calcMaxValueInSfb(psyOutCh->sfbCnt,
1019 psyOutCh->maxSfbPerGroup,
1020 psyOutCh->sfbPerGroup,
1021 psyOutCh->sfbOffsets,
1022 qcOutCh->quantSpec,
1023 qcOutCh->maxValueInSfb) > MAX_QUANT)
1024 {
1025 chConstraintsFulfilled[c][i][ch] = 0;
1026 constraintsFulfilled[c][i] = 0 ;
1027 /* if quanizted value out of range; increase global gain! */
1028 decreaseBitConsumption = 1;
1029 }
1030
1031 /*-------------------------------------------- */
1032
1033 } /* if calculateQuant[c][i][ch] */
1034
1035 } /* channel loop */
1036
1037 /*-------------------------------------------- */
1038 /* quantize spectrum (per each channel) */
1039
1040 /*-------------------------------------------- */
1041
1042 } while (!constraintsFulfilled[c][i]) ; /* does not regard bit consumption */
1043
1044
1045 /*-------------------------------------------- */
1046 /*-------------------------------------------- */
1047 qcElement[c][i]->dynBitsUsed = 0 ; /* reset dynamic bits */
1048
1049 /* quantization valid in current channel! */
1050 for (ch = 0; ch < nChannels; ch++)
1051 {
1052 QC_OUT_CHANNEL* qcOutCh = qcElement[c][i]->qcOutChannel[ch];
1053 PSY_OUT_CHANNEL *psyOutCh = psyOut[c]->psyOutElement[i]->psyOutChannel[ch];
1054
1055 /* count dynamic bits */
1056 INT chDynBits = FDKaacEnc_dynBitCount(hQC->hBitCounter,
1057 qcOutCh->quantSpec,
1058 qcOutCh->maxValueInSfb,
1059 qcOutCh->scf,
1060 psyOutCh->lastWindowSequence,
1061 psyOutCh->sfbCnt,
1062 psyOutCh->maxSfbPerGroup,
1063 psyOutCh->sfbPerGroup,
1064 psyOutCh->sfbOffsets,
1065 &qcOutCh->sectionData,
1066 psyOutCh->noiseNrg,
1067 psyOutCh->isBook,
1068 psyOutCh->isScale,
1069 syntaxFlags) ;
1070
1071 /* sum up dynamic channel bits */
1072 qcElement[c][i]->dynBitsUsed += chDynBits;
1073 }
1074
1075 /* save dynBitsUsed for correction of bits2pe relation */
1076 if(hQC->hAdjThr->adjThrStateElem[i]->dynBitsLast==-1) {
1077 hQC->hAdjThr->adjThrStateElem[i]->dynBitsLast = qcElement[c][i]->dynBitsUsed;
1078 }
1079 } /* -end- if(ID_SCE || ID_CPE || ID_LFE) */
1080
1081 } /* -end- element loop */
1082
1083 /* update dynBits of current subFrame */
1084 FDKaacEnc_updateUsedDynBits(&qcOut[c]->usedDynBits,
1085 qcElement[c],
1086 cm);
1087
1088 /* get total consumed bits, dyn bits in all sub frames have to be valid */
1089 sumDynBitsConsumedTotal = FDKaacEnc_getTotalConsumedDynBits(qcOut, nSubFrames);
1090
1091 if (sumDynBitsConsumedTotal==-1)
1092 {
1093 quantizationDone = 0; /* bit consumption not valid in all sub frames */
1094 }
1095 else
1096 {
1097 int sumBitsConsumedTotal = FDKaacEnc_getTotalConsumedBits(qcOut, qcElement, cm, hQC->globHdrBits, nSubFrames);
1098
1099 /* in all frames are valid dynamic bits */
1100 if ( ((sumBitsConsumedTotal < totalAvailableBits) || qcOut[c]->usedDynBits==0) && (decreaseBitConsumption==1) && checkMinFrameBitsDemand(qcOut,hQC->minBitsPerFrame,nSubFrames)
1101 /*()*/ )
1102 {
1103 quantizationDone = 1; /* exit bit adjustment */
1104 }
1105 if (sumBitsConsumedTotal > totalAvailableBits && (decreaseBitConsumption==0) )
1106 // /*()*/ )
1107 {
1108 quantizationDone = 0; /* reset! */
1109 break;
1110 }
1111 }
1112
1113
1114 /*-------------------------------------------- */
1115
1116 int emergencyIterations = 1;
1117 int dynBitsOvershoot = 0;
1118
1119 for (c = 0 ; c < nSubFrames ; c++ )
1120 {
1121 for (i=0; i<cm->nElements; i++)
1122 {
1123 ELEMENT_INFO elInfo = cm->elInfo[i];
1124
1125 if ((elInfo.elType == ID_SCE) || (elInfo.elType == ID_CPE) ||
1126 (elInfo.elType == ID_LFE))
1127 {
1128 /* iteration limitation */
1129 emergencyIterations &= ((iterations[c][i] < hQC->maxIterations) ? 0 : 1);
1130 }
1131 }
1132 /* detection if used dyn bits exceeds the maximal allowed criterion */
1133 dynBitsOvershoot |= ((qcOut[c]->usedDynBits > qcOut[c]->maxDynBits) ? 1 : 0);
1134 }
1135
1136 if (quantizationDone==0 || dynBitsOvershoot)
1137 {
1138
1139 int sumBitsConsumedTotal = FDKaacEnc_getTotalConsumedBits(qcOut, qcElement, cm, hQC->globHdrBits, nSubFrames);
1140
1141 if ( (sumDynBitsConsumedTotal >= avgTotalDynBits) || (sumDynBitsConsumedTotal==0) ) {
1142 quantizationDone = 1;
1143 }
1144 if (emergencyIterations && (sumBitsConsumedTotal < totalAvailableBits)) {
1145 quantizationDone = 1;
1146 }
1147 if ((sumBitsConsumedTotal > totalAvailableBits) || !checkMinFrameBitsDemand(qcOut,hQC->minBitsPerFrame,nSubFrames)) {
1148 quantizationDone = 0;
1149 }
1150 if ((sumBitsConsumedTotal < totalAvailableBits) && checkMinFrameBitsDemand(qcOut,hQC->minBitsPerFrame,nSubFrames)) {
1151 decreaseBitConsumption = 0;
1152 }
1153 else {
1154 decreaseBitConsumption = 1;
1155 }
1156
1157 if (dynBitsOvershoot) {
1158 quantizationDone = 0;
1159 decreaseBitConsumption = 1;
1160 }
1161
1162 /* reset constraints fullfilled flags */
1163 FDKmemclear(constraintsFulfilled, sizeof(constraintsFulfilled));
1164 FDKmemclear(chConstraintsFulfilled, sizeof(chConstraintsFulfilled));
1165
1166
1167 }/* quantizationDone */
1168
1169 } while (!quantizationDone) ;
1170
1171 /*-------------------------------------------- */
1172 /* ... -end- Quantization loop */
1173 /*-------------------------------------------- */
1174
1175 /*-------------------------------------------- */
1176 /*-------------------------------------------- */
1177
1178 return AAC_ENC_OK;
1179 }
1180
1181
FDKaacEnc_reduceBitConsumption(int * iterations,const int maxIterations,int gainAdjustment,int * chConstraintsFulfilled,int * calculateQuant,int nChannels,PSY_OUT_ELEMENT * psyOutElement,QC_OUT * qcOut,QC_OUT_ELEMENT * qcOutElement,ELEMENT_BITS * elBits,AUDIO_OBJECT_TYPE aot,UINT syntaxFlags,SCHAR epConfig)1182 static AAC_ENCODER_ERROR FDKaacEnc_reduceBitConsumption(int* iterations,
1183 const int maxIterations,
1184 int gainAdjustment,
1185 int* chConstraintsFulfilled,
1186 int* calculateQuant,
1187 int nChannels,
1188 PSY_OUT_ELEMENT* psyOutElement,
1189 QC_OUT* qcOut,
1190 QC_OUT_ELEMENT* qcOutElement,
1191 ELEMENT_BITS* elBits,
1192 AUDIO_OBJECT_TYPE aot,
1193 UINT syntaxFlags,
1194 SCHAR epConfig)
1195 {
1196 int ch;
1197
1198 /** SOLVING PROBLEM **/
1199 if ((*iterations)++ >= maxIterations)
1200 {
1201 if (qcOutElement->dynBitsUsed==0) {
1202 }
1203 /* crash recovery */
1204 else {
1205 INT bitsToSave = 0;
1206 if ( (bitsToSave = fixMax((qcOutElement->dynBitsUsed + 8) - (elBits->bitResLevelEl + qcOutElement->grantedDynBits),
1207 (qcOutElement->dynBitsUsed + qcOutElement->staticBitsUsed + 8) - (elBits->maxBitsEl))) > 0 )
1208 {
1209 FDKaacEnc_crashRecovery(nChannels,
1210 psyOutElement,
1211 qcOut,
1212 qcOutElement,
1213 bitsToSave,
1214 aot,
1215 syntaxFlags,
1216 epConfig) ;
1217 }
1218 else
1219 {
1220 for (ch = 0; ch < nChannels; ch++)
1221 {
1222 qcOutElement->qcOutChannel[ch]->globalGain += 1;
1223 }
1224 }
1225 for (ch = 0; ch < nChannels; ch++)
1226 {
1227 calculateQuant[ch] = 1;
1228 }
1229 }
1230 }
1231 else /* iterations >= maxIterations */
1232 {
1233 /* increase gain (+ next iteration) */
1234 for (ch = 0; ch < nChannels; ch++)
1235 {
1236 if(!chConstraintsFulfilled[ch])
1237 {
1238 qcOutElement->qcOutChannel[ch]->globalGain += gainAdjustment ;
1239 calculateQuant[ch] = 1; /* global gain has changed, recalculate quantization in next iteration! */
1240 }
1241 }
1242 }
1243
1244 return AAC_ENC_OK;
1245 }
1246
FDKaacEnc_updateFillBits(CHANNEL_MAPPING * cm,QC_STATE * qcKernel,ELEMENT_BITS * RESTRICT elBits[(8)],QC_OUT ** qcOut)1247 AAC_ENCODER_ERROR FDKaacEnc_updateFillBits(CHANNEL_MAPPING* cm,
1248 QC_STATE* qcKernel,
1249 ELEMENT_BITS* RESTRICT elBits[(8)],
1250 QC_OUT** qcOut)
1251 {
1252 switch (qcKernel->bitrateMode) {
1253 case QCDATA_BR_MODE_SFR:
1254 break;
1255
1256 case QCDATA_BR_MODE_FF:
1257 break;
1258
1259 case QCDATA_BR_MODE_VBR_1:
1260 case QCDATA_BR_MODE_VBR_2:
1261 case QCDATA_BR_MODE_VBR_3:
1262 case QCDATA_BR_MODE_VBR_4:
1263 case QCDATA_BR_MODE_VBR_5:
1264 qcOut[0]->totFillBits = (qcOut[0]->grantedDynBits - qcOut[0]->usedDynBits)&7; /* precalculate alignment bits */
1265 qcOut[0]->totalBits = qcOut[0]->staticBits + qcOut[0]->usedDynBits + qcOut[0]->totFillBits + qcOut[0]->elementExtBits + qcOut[0]->globalExtBits;
1266 qcOut[0]->totFillBits += ( fixMax(0, qcKernel->minBitsPerFrame - qcOut[0]->totalBits) + 7) & ~7;
1267 break;
1268
1269 case QCDATA_BR_MODE_CBR:
1270 case QCDATA_BR_MODE_INVALID:
1271 default:
1272 INT bitResSpace = qcKernel->bitResTotMax - qcKernel->bitResTot ;
1273 /* processing fill-bits */
1274 INT deltaBitRes = qcOut[0]->grantedDynBits - qcOut[0]->usedDynBits ;
1275 qcOut[0]->totFillBits = fixMax((deltaBitRes&7), (deltaBitRes - (fixMax(0,bitResSpace-7)&~7)));
1276 qcOut[0]->totalBits = qcOut[0]->staticBits + qcOut[0]->usedDynBits + qcOut[0]->totFillBits + qcOut[0]->elementExtBits + qcOut[0]->globalExtBits;
1277 qcOut[0]->totFillBits += ( fixMax(0, qcKernel->minBitsPerFrame - qcOut[0]->totalBits) + 7) & ~7;
1278 break;
1279 } /* switch (qcKernel->bitrateMode) */
1280
1281 return AAC_ENC_OK;
1282 }
1283
1284
1285
1286
1287 /*********************************************************************************
1288
1289 functionname: FDKaacEnc_calcMaxValueInSfb
1290 description:
1291 return:
1292
1293 **********************************************************************************/
1294
FDKaacEnc_calcMaxValueInSfb(INT sfbCnt,INT maxSfbPerGroup,INT sfbPerGroup,INT * RESTRICT sfbOffset,SHORT * RESTRICT quantSpectrum,UINT * RESTRICT maxValue)1295 static INT FDKaacEnc_calcMaxValueInSfb(INT sfbCnt,
1296 INT maxSfbPerGroup,
1297 INT sfbPerGroup,
1298 INT *RESTRICT sfbOffset,
1299 SHORT *RESTRICT quantSpectrum,
1300 UINT *RESTRICT maxValue)
1301 {
1302 INT sfbOffs,sfb;
1303 INT maxValueAll = 0;
1304
1305 for (sfbOffs=0;sfbOffs<sfbCnt;sfbOffs+=sfbPerGroup)
1306 for (sfb = 0; sfb < maxSfbPerGroup; sfb++)
1307 {
1308 INT line;
1309 INT maxThisSfb = 0;
1310 for (line = sfbOffset[sfbOffs+sfb]; line < sfbOffset[sfbOffs+sfb+1]; line++)
1311 {
1312 INT tmp = fixp_abs(quantSpectrum[line]);
1313 maxThisSfb = fixMax(tmp, maxThisSfb);
1314 }
1315
1316 maxValue[sfbOffs+sfb] = maxThisSfb;
1317 maxValueAll = fixMax(maxThisSfb, maxValueAll);
1318 }
1319 return maxValueAll;
1320 }
1321
1322
1323 /*********************************************************************************
1324
1325 functionname: FDKaacEnc_updateBitres
1326 description:
1327 return:
1328
1329 **********************************************************************************/
FDKaacEnc_updateBitres(CHANNEL_MAPPING * cm,QC_STATE * qcKernel,QC_OUT ** qcOut)1330 void FDKaacEnc_updateBitres(CHANNEL_MAPPING *cm,
1331 QC_STATE* qcKernel,
1332 QC_OUT** qcOut)
1333 {
1334 switch (qcKernel->bitrateMode) {
1335 case QCDATA_BR_MODE_FF:
1336 case QCDATA_BR_MODE_VBR_1:
1337 case QCDATA_BR_MODE_VBR_2:
1338 case QCDATA_BR_MODE_VBR_3:
1339 case QCDATA_BR_MODE_VBR_4:
1340 case QCDATA_BR_MODE_VBR_5:
1341 /* variable bitrate */
1342 qcKernel->bitResTot = FDKmin(qcKernel->maxBitsPerFrame, qcKernel->bitResTotMax);
1343 break;
1344
1345 case QCDATA_BR_MODE_CBR:
1346 case QCDATA_BR_MODE_SFR:
1347 case QCDATA_BR_MODE_INVALID:
1348 default:
1349 int c = 0;
1350 /* constant bitrate */
1351 {
1352 qcKernel->bitResTot += qcOut[c]->grantedDynBits - (qcOut[c]->usedDynBits + qcOut[c]->totFillBits + qcOut[c]->alignBits);
1353 }
1354 break;
1355 }
1356 }
1357
1358 /*********************************************************************************
1359
1360 functionname: FDKaacEnc_FinalizeBitConsumption
1361 description:
1362 return:
1363
1364 **********************************************************************************/
FDKaacEnc_FinalizeBitConsumption(CHANNEL_MAPPING * cm,QC_STATE * qcKernel,QC_OUT * qcOut,QC_OUT_ELEMENT ** qcElement,HANDLE_TRANSPORTENC hTpEnc,AUDIO_OBJECT_TYPE aot,UINT syntaxFlags,SCHAR epConfig)1365 AAC_ENCODER_ERROR FDKaacEnc_FinalizeBitConsumption(CHANNEL_MAPPING *cm,
1366 QC_STATE *qcKernel,
1367 QC_OUT *qcOut,
1368 QC_OUT_ELEMENT** qcElement,
1369 HANDLE_TRANSPORTENC hTpEnc,
1370 AUDIO_OBJECT_TYPE aot,
1371 UINT syntaxFlags,
1372 SCHAR epConfig)
1373 {
1374 QC_OUT_EXTENSION fillExtPayload;
1375 INT totFillBits, alignBits;
1376
1377 /* Get total consumed bits in AU */
1378 qcOut->totalBits = qcOut->staticBits + qcOut->usedDynBits + qcOut->totFillBits +
1379 qcOut->elementExtBits + qcOut->globalExtBits;
1380
1381 if (qcKernel->bitrateMode==QCDATA_BR_MODE_CBR) {
1382
1383 /* Now we can get the exact transport bit amount, and hopefully it is equal to the estimated value */
1384 INT exactTpBits = transportEnc_GetStaticBits(hTpEnc, qcOut->totalBits);
1385
1386 if (exactTpBits != qcKernel->globHdrBits) {
1387 INT diffFillBits = 0;
1388
1389 /* How many bits can be taken by bitreservoir */
1390 const INT bitresSpace = qcKernel->bitResTotMax - (qcKernel->bitResTot + (qcOut->grantedDynBits - (qcOut->usedDynBits + qcOut->totFillBits) ) );
1391
1392 /* Number of bits which can be moved to bitreservoir. */
1393 const INT bitsToBitres = qcKernel->globHdrBits - exactTpBits;
1394 FDK_ASSERT(bitsToBitres>=0); /* is always positive */
1395
1396 /* If bitreservoir can not take all bits, move ramaining bits to fillbits */
1397 diffFillBits = FDKmax(0, bitsToBitres - bitresSpace);
1398
1399 /* Assure previous alignment */
1400 diffFillBits = (diffFillBits+7)&~7;
1401
1402 /* Move as many bits as possible to bitreservoir */
1403 qcKernel->bitResTot += (bitsToBitres-diffFillBits);
1404
1405 /* Write remaing bits as fill bits */
1406 qcOut->totFillBits += diffFillBits;
1407 qcOut->totalBits += diffFillBits;
1408 qcOut->grantedDynBits += diffFillBits;
1409
1410 /* Get new header bits */
1411 qcKernel->globHdrBits = transportEnc_GetStaticBits(hTpEnc, qcOut->totalBits);
1412
1413 if (qcKernel->globHdrBits != exactTpBits) {
1414 /* In previous step, fill bits and corresponding total bits were changed when bitreservoir was completely filled.
1415 Now we can take the too much taken bits caused by header overhead from bitreservoir.
1416 */
1417 qcKernel->bitResTot -= (qcKernel->globHdrBits - exactTpBits);
1418 }
1419 }
1420
1421 } /* MODE_CBR */
1422
1423 /* Update exact number of consumed header bits. */
1424 qcKernel->globHdrBits = transportEnc_GetStaticBits(hTpEnc, qcOut->totalBits);
1425
1426 /* Save total fill bits and distribut to alignment and fill bits */
1427 totFillBits = qcOut->totFillBits;
1428
1429 /* fake a fill extension payload */
1430 FDKmemclear(&fillExtPayload, sizeof(QC_OUT_EXTENSION));
1431
1432 fillExtPayload.type = EXT_FILL_DATA;
1433 fillExtPayload.nPayloadBits = totFillBits;
1434
1435 /* ask bitstream encoder how many of that bits can be written in a fill extension data entity */
1436 qcOut->totFillBits = FDKaacEnc_writeExtensionData( NULL,
1437 &fillExtPayload,
1438 0, 0,
1439 syntaxFlags,
1440 aot,
1441 epConfig );
1442
1443 /* now distribute extra fillbits and alignbits */
1444 alignBits = 7 - (qcOut->staticBits + qcOut->usedDynBits + qcOut->elementExtBits
1445 + qcOut->totFillBits + qcOut->globalExtBits -1)%8;
1446
1447 /* Maybe we could remove this */
1448 if( ((alignBits + qcOut->totFillBits - totFillBits)==8) && (qcOut->totFillBits>8) )
1449 qcOut->totFillBits -= 8;
1450
1451 qcOut->totalBits = qcOut->staticBits + qcOut->usedDynBits + qcOut->totFillBits +
1452 alignBits + qcOut->elementExtBits + qcOut->globalExtBits;
1453
1454 if ( (qcOut->totalBits>qcKernel->maxBitsPerFrame) || (qcOut->totalBits<qcKernel->minBitsPerFrame) ) {
1455 return AAC_ENC_QUANT_ERROR;
1456 }
1457
1458 qcOut->alignBits = alignBits;
1459
1460 return AAC_ENC_OK;
1461 }
1462
1463
1464
1465 /*********************************************************************************
1466
1467 functionname: FDKaacEnc_crashRecovery
1468 description: fulfills constraints by means of brute force...
1469 => bits are saved by cancelling out spectral lines!!
1470 (beginning at the highest frequencies)
1471 return: errorcode
1472
1473 **********************************************************************************/
1474
FDKaacEnc_crashRecovery(INT nChannels,PSY_OUT_ELEMENT * psyOutElement,QC_OUT * qcOut,QC_OUT_ELEMENT * qcElement,INT bitsToSave,AUDIO_OBJECT_TYPE aot,UINT syntaxFlags,SCHAR epConfig)1475 static void FDKaacEnc_crashRecovery(INT nChannels,
1476 PSY_OUT_ELEMENT* psyOutElement,
1477 QC_OUT* qcOut,
1478 QC_OUT_ELEMENT *qcElement,
1479 INT bitsToSave,
1480 AUDIO_OBJECT_TYPE aot,
1481 UINT syntaxFlags,
1482 SCHAR epConfig)
1483 {
1484 INT ch ;
1485 INT savedBits = 0 ;
1486 INT sfb, sfbGrp ;
1487 INT bitsPerScf[(2)][MAX_GROUPED_SFB] ;
1488 INT sectionToScf[(2)][MAX_GROUPED_SFB] ;
1489 INT *sfbOffset ;
1490 INT sect, statBitsNew ;
1491 QC_OUT_CHANNEL **qcChannel = qcElement->qcOutChannel;
1492 PSY_OUT_CHANNEL **psyChannel = psyOutElement->psyOutChannel;
1493
1494 /* create a table which converts frq-bins to bit-demand... [bitsPerScf] */
1495 /* ...and another one which holds the corresponding sections [sectionToScf] */
1496 for (ch = 0; ch < nChannels; ch++)
1497 {
1498 sfbOffset = psyChannel[ch]->sfbOffsets ;
1499
1500 for (sect = 0; sect < qcChannel[ch]->sectionData.noOfSections; sect++)
1501 {
1502 INT sfb ;
1503 INT codeBook = qcChannel[ch]->sectionData.huffsection[sect].codeBook ;
1504
1505 for (sfb = qcChannel[ch]->sectionData.huffsection[sect].sfbStart;
1506 sfb < qcChannel[ch]->sectionData.huffsection[sect].sfbStart +
1507 qcChannel[ch]->sectionData.huffsection[sect].sfbCnt;
1508 sfb++)
1509 {
1510 bitsPerScf[ch][sfb] = 0;
1511 if ( (codeBook != CODE_BOOK_PNS_NO) /*&&
1512 (sfb < (qcChannel[ch]->sectionData.noOfGroups*qcChannel[ch]->sectionData.maxSfbPerGroup))*/ )
1513 {
1514 INT sfbStartLine = sfbOffset[sfb] ;
1515 INT noOfLines = sfbOffset[sfb+1] - sfbStartLine ;
1516 bitsPerScf[ch][sfb] = FDKaacEnc_countValues(&(qcChannel[ch]->quantSpec[sfbStartLine]), noOfLines, codeBook) ;
1517 }
1518 sectionToScf[ch][sfb] = sect ;
1519 }
1520
1521 }
1522 }
1523
1524 /* LOWER [maxSfb] IN BOTH CHANNELS!! */
1525 /* Attention: in case of stereo: maxSfbL == maxSfbR, GroupingL == GroupingR ; */
1526
1527 for (sfb = qcChannel[0]->sectionData.maxSfbPerGroup-1; sfb >= 0; sfb--)
1528 {
1529 for (sfbGrp = 0; sfbGrp < psyChannel[0]->sfbCnt; sfbGrp += psyChannel[0]->sfbPerGroup)
1530 {
1531 for (ch = 0; ch < nChannels; ch++)
1532 {
1533 int sect = sectionToScf[ch][sfbGrp+sfb];
1534 qcChannel[ch]->sectionData.huffsection[sect].sfbCnt-- ;
1535 savedBits += bitsPerScf[ch][sfbGrp+sfb] ;
1536
1537 if (qcChannel[ch]->sectionData.huffsection[sect].sfbCnt == 0) {
1538 savedBits += (psyChannel[ch]->lastWindowSequence!=SHORT_WINDOW) ? FDKaacEnc_sideInfoTabLong[0]
1539 : FDKaacEnc_sideInfoTabShort[0];
1540 }
1541 }
1542 }
1543
1544 /* ...have enough bits been saved? */
1545 if (savedBits >= bitsToSave)
1546 break ;
1547
1548 } /* sfb loop */
1549
1550 /* if not enough bits saved,
1551 clean whole spectrum and remove side info overhead */
1552 if (sfb == -1) {
1553 sfb = 0 ;
1554 }
1555
1556 for (ch = 0; ch < nChannels; ch++)
1557 {
1558 qcChannel[ch]->sectionData.maxSfbPerGroup = sfb ;
1559 psyChannel[ch]->maxSfbPerGroup = sfb ;
1560 /* when no spectrum is coded save tools info in bitstream */
1561 if(sfb==0) {
1562 FDKmemclear(&psyChannel[ch]->tnsInfo, sizeof(TNS_INFO));
1563 FDKmemclear(&psyOutElement->toolsInfo, sizeof(TOOLSINFO));
1564 }
1565 }
1566 /* dynamic bits will be updated in iteration loop */
1567
1568 { /* if stop sfb has changed save bits in side info, e.g. MS or TNS coding */
1569 ELEMENT_INFO elInfo;
1570
1571 FDKmemclear(&elInfo, sizeof(ELEMENT_INFO));
1572 elInfo.nChannelsInEl = nChannels;
1573 elInfo.elType = (nChannels == 2) ? ID_CPE : ID_SCE;
1574
1575 FDKaacEnc_ChannelElementWrite( NULL, &elInfo, NULL,
1576 psyOutElement,
1577 psyChannel,
1578 syntaxFlags,
1579 aot,
1580 epConfig,
1581 &statBitsNew,
1582 0 );
1583 }
1584
1585 savedBits = qcElement->staticBitsUsed - statBitsNew;
1586
1587 /* update static and dynamic bits */
1588 qcElement->staticBitsUsed -= savedBits;
1589 qcElement->grantedDynBits += savedBits;
1590
1591 qcOut->staticBits -= savedBits;
1592 qcOut->grantedDynBits += savedBits;
1593 qcOut->maxDynBits += savedBits;
1594
1595
1596 }
1597
1598
1599
FDKaacEnc_QCClose(QC_STATE ** phQCstate,QC_OUT ** phQC)1600 void FDKaacEnc_QCClose (QC_STATE **phQCstate, QC_OUT **phQC)
1601 {
1602 int n, i;
1603
1604 if (phQC!=NULL) {
1605
1606 for (n=0;n<(1);n++) {
1607 if (phQC[n] != NULL) {
1608 QC_OUT *hQC = phQC[n];
1609 for (i=0; i<(8); i++) {
1610 }
1611
1612 for (i=0; i<(8); i++) {
1613 if (hQC->qcElement[i])
1614 FreeRam_aacEnc_QCelement(&hQC->qcElement[i]);
1615 }
1616
1617 FreeRam_aacEnc_QCout(&phQC[n]);
1618 }
1619 }
1620 }
1621
1622 if (phQCstate!=NULL) {
1623 if (*phQCstate != NULL) {
1624 QC_STATE *hQCstate = *phQCstate;
1625
1626 if (hQCstate->hAdjThr != NULL)
1627 FDKaacEnc_AdjThrClose(&hQCstate->hAdjThr);
1628
1629 if (hQCstate->hBitCounter != NULL)
1630 FDKaacEnc_BCClose(&hQCstate->hBitCounter);
1631
1632 for (i=0; i<(8); i++) {
1633 if (hQCstate->elementBits[i]!=NULL) {
1634 FreeRam_aacEnc_ElementBits(&hQCstate->elementBits[i]);
1635 }
1636 }
1637 FreeRam_aacEnc_QCstate(phQCstate);
1638 }
1639 }
1640 }
1641
1642