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 /*!
85 \file
86 \brief Envelope extraction
87 The functions provided by this module are mostly called by applySBR(). After it is
88 determined that there is valid SBR data, sbrGetHeaderData() might be called if the current
89 SBR data contains an \ref SBR_HEADER_ELEMENT as opposed to a \ref SBR_STANDARD_ELEMENT. This function
90 may return various error codes as defined in #SBR_HEADER_STATUS . Most importantly it returns HEADER_RESET when decoder
91 settings need to be recalculated according to the SBR specifications. In that case applySBR()
92 will initiatite the required re-configuration.
93
94 The header data is stored in a #SBR_HEADER_DATA structure.
95
96 The actual SBR data for the current frame is decoded into SBR_FRAME_DATA stuctures by sbrGetChannelPairElement()
97 [for stereo streams] and sbrGetSingleChannelElement() [for mono streams]. There is no fractional arithmetic involved.
98
99 Once the information is extracted, the data needs to be further prepared before the actual decoding process.
100 This is done in decodeSbrData().
101
102 \sa Description of buffer management in applySBR(). \ref documentationOverview
103
104 <h1>About the SBR data format:</h1>
105
106 Each frame includes SBR data (side chain information), and can be either the \ref SBR_HEADER_ELEMENT or the \ref SBR_STANDARD_ELEMENT.
107 Parts of the data can be protected by a CRC checksum.
108
109 \anchor SBR_HEADER_ELEMENT <h2>The SBR_HEADER_ELEMENT</h2>
110
111 The SBR_HEADER_ELEMENT can be transmitted with every frame, however, it typically is send every second or so. It contains fundamental
112 information such as SBR sampling frequency and frequency range as well as control signals that do not require frequent changes. It also
113 includes the \ref SBR_STANDARD_ELEMENT.
114
115 Depending on the changes between the information in a current SBR_HEADER_ELEMENT and the previous SBR_HEADER_ELEMENT, the SBR decoder might need
116 to be reset and reconfigured (e.g. new tables need to be calculated).
117
118 \anchor SBR_STANDARD_ELEMENT <h2>The SBR_STANDARD_ELEMENT</h2>
119
120 This data can be subdivided into "side info" and "raw data", where side info is defined as signals needed to decode the raw data
121 and some decoder tuning signals. Raw data is referred to as PCM and Huffman coded envelope and noise floor estimates. The side info also
122 includes information about the time-frequency grid for the current frame.
123
124 \sa \ref documentationOverview
125 */
126
127 #include "env_extr.h"
128
129 #include "sbr_ram.h"
130 #include "sbr_rom.h"
131 #include "huff_dec.h"
132
133
134 #include "psbitdec.h"
135
136 #define DRM_PARAMETRIC_STEREO 0
137 #define EXTENSION_ID_PS_CODING 2
138
139
140 static int extractFrameInfo (HANDLE_FDK_BITSTREAM hBs,
141 HANDLE_SBR_HEADER_DATA hHeaderData,
142 HANDLE_SBR_FRAME_DATA h_frame_data,
143 const UINT nrOfChannels,
144 const UINT flags
145 );
146
147
148 static int sbrGetEnvelope (HANDLE_SBR_HEADER_DATA hHeaderData,
149 HANDLE_SBR_FRAME_DATA h_frame_data,
150 HANDLE_FDK_BITSTREAM hBs,
151 const UINT flags);
152
153 static void sbrGetDirectionControlData (HANDLE_SBR_FRAME_DATA hFrameData,
154 HANDLE_FDK_BITSTREAM hBs);
155
156 static void sbrGetNoiseFloorData (HANDLE_SBR_HEADER_DATA hHeaderData,
157 HANDLE_SBR_FRAME_DATA h_frame_data,
158 HANDLE_FDK_BITSTREAM hBs);
159
160 static int checkFrameInfo (FRAME_INFO *pFrameInfo, int numberOfTimeSlots, int overlap, int timeStep);
161
162 SBR_ERROR
initHeaderData(HANDLE_SBR_HEADER_DATA hHeaderData,const int sampleRateIn,const int sampleRateOut,const int samplesPerFrame,const UINT flags)163 initHeaderData (
164 HANDLE_SBR_HEADER_DATA hHeaderData,
165 const int sampleRateIn,
166 const int sampleRateOut,
167 const int samplesPerFrame,
168 const UINT flags
169 )
170 {
171 HANDLE_FREQ_BAND_DATA hFreq = &hHeaderData->freqBandData;
172 SBR_ERROR sbrError = SBRDEC_OK;
173 int numAnalysisBands;
174
175 if ( sampleRateIn == sampleRateOut ) {
176 hHeaderData->sbrProcSmplRate = sampleRateOut<<1;
177 numAnalysisBands = 32;
178 } else {
179 hHeaderData->sbrProcSmplRate = sampleRateOut;
180 if ( (sampleRateOut>>1) == sampleRateIn) {
181 /* 1:2 */
182 numAnalysisBands = 32;
183 } else if ( (sampleRateOut>>2) == sampleRateIn ) {
184 /* 1:4 */
185 numAnalysisBands = 32;
186 } else if ( (sampleRateOut*3)>>3 == (sampleRateIn*8)>>3 ) {
187 /* 3:8, 3/4 core frame length */
188 numAnalysisBands = 24;
189 } else {
190 sbrError = SBRDEC_UNSUPPORTED_CONFIG;
191 goto bail;
192 }
193 }
194
195 /* Fill in default values first */
196 hHeaderData->syncState = SBR_NOT_INITIALIZED;
197 hHeaderData->status = 0;
198 hHeaderData->frameErrorFlag = 0;
199
200 hHeaderData->bs_info.ampResolution = 1;
201 hHeaderData->bs_info.xover_band = 0;
202 hHeaderData->bs_info.sbr_preprocessing = 0;
203
204 hHeaderData->bs_data.startFreq = 5;
205 hHeaderData->bs_data.stopFreq = 0;
206 hHeaderData->bs_data.freqScale = 2;
207 hHeaderData->bs_data.alterScale = 1;
208 hHeaderData->bs_data.noise_bands = 2;
209 hHeaderData->bs_data.limiterBands = 2;
210 hHeaderData->bs_data.limiterGains = 2;
211 hHeaderData->bs_data.interpolFreq = 1;
212 hHeaderData->bs_data.smoothingLength = 1;
213
214 hHeaderData->timeStep = (flags & SBRDEC_ELD_GRID) ? 1 : 2;
215
216 /* Setup pointers to frequency band tables */
217 hFreq->freqBandTable[0] = hFreq->freqBandTableLo;
218 hFreq->freqBandTable[1] = hFreq->freqBandTableHi;
219
220 /* Patch some entries */
221 if (sampleRateOut > 24000) { /* Trigger an error if SBR is going to be processed without */
222 hHeaderData->bs_data.startFreq = 7; /* having read these frequency values from bit stream before. */
223 hHeaderData->bs_data.stopFreq = 3;
224 }
225
226 /* One SBR timeslot corresponds to the amount of samples equal to the amount of analysis bands, divided by the timestep. */
227 hHeaderData->numberTimeSlots = (samplesPerFrame/numAnalysisBands) >> (hHeaderData->timeStep - 1);
228 if (hHeaderData->numberTimeSlots > (16)) {
229 sbrError = SBRDEC_UNSUPPORTED_CONFIG;
230 }
231
232 hHeaderData->numberOfAnalysisBands = numAnalysisBands;
233
234 bail:
235 return sbrError;
236 }
237
238
239 /*!
240 \brief Initialize the SBR_PREV_FRAME_DATA struct
241 */
242 void
initSbrPrevFrameData(HANDLE_SBR_PREV_FRAME_DATA h_prev_data,int timeSlots)243 initSbrPrevFrameData (HANDLE_SBR_PREV_FRAME_DATA h_prev_data, /*!< handle to struct SBR_PREV_FRAME_DATA */
244 int timeSlots) /*!< Framelength in SBR-timeslots */
245 {
246 int i;
247
248 /* Set previous energy and noise levels to 0 for the case
249 that decoding starts in the middle of a bitstream */
250 for (i=0; i < MAX_FREQ_COEFFS; i++)
251 h_prev_data->sfb_nrg_prev[i] = (FIXP_DBL)0;
252 for (i=0; i < MAX_NOISE_COEFFS; i++)
253 h_prev_data->prevNoiseLevel[i] = (FIXP_DBL)0;
254 for (i=0; i < MAX_INVF_BANDS; i++)
255 h_prev_data->sbr_invf_mode[i] = INVF_OFF;
256
257 h_prev_data->stopPos = timeSlots;
258 h_prev_data->coupling = COUPLING_OFF;
259 h_prev_data->ampRes = 0;
260 }
261
262
263 /*!
264 \brief Read header data from bitstream
265
266 \return error status - 0 if ok
267 */
268 SBR_HEADER_STATUS
sbrGetHeaderData(HANDLE_SBR_HEADER_DATA hHeaderData,HANDLE_FDK_BITSTREAM hBs,const UINT flags,const int fIsSbrData)269 sbrGetHeaderData (HANDLE_SBR_HEADER_DATA hHeaderData,
270 HANDLE_FDK_BITSTREAM hBs,
271 const UINT flags,
272 const int fIsSbrData)
273 {
274 SBR_HEADER_DATA_BS *pBsData;
275 SBR_HEADER_DATA_BS lastHeader;
276 SBR_HEADER_DATA_BS_INFO lastInfo;
277 int headerExtra1=0, headerExtra2=0;
278
279 /* Copy SBR bit stream header to temporary header */
280 lastHeader = hHeaderData->bs_data;
281 lastInfo = hHeaderData->bs_info;
282
283 /* Read new header from bitstream */
284 {
285 pBsData = &hHeaderData->bs_data;
286 }
287
288 {
289 hHeaderData->bs_info.ampResolution = FDKreadBits (hBs, 1);
290 }
291
292 pBsData->startFreq = FDKreadBits (hBs, 4);
293 pBsData->stopFreq = FDKreadBits (hBs, 4);
294
295 {
296 hHeaderData->bs_info.xover_band = FDKreadBits (hBs, 3);
297 FDKreadBits (hBs, 2);
298 }
299
300 headerExtra1 = FDKreadBits (hBs, 1);
301 headerExtra2 = FDKreadBits (hBs, 1);
302
303 /* Handle extra header information */
304 if( headerExtra1)
305 {
306 pBsData->freqScale = FDKreadBits (hBs, 2);
307 pBsData->alterScale = FDKreadBits (hBs, 1);
308 pBsData->noise_bands = FDKreadBits (hBs, 2);
309 }
310 else {
311 pBsData->freqScale = 2;
312 pBsData->alterScale = 1;
313 pBsData->noise_bands = 2;
314 }
315
316 if (headerExtra2) {
317 pBsData->limiterBands = FDKreadBits (hBs, 2);
318 pBsData->limiterGains = FDKreadBits (hBs, 2);
319 pBsData->interpolFreq = FDKreadBits (hBs, 1);
320 pBsData->smoothingLength = FDKreadBits (hBs, 1);
321 }
322 else {
323 pBsData->limiterBands = 2;
324 pBsData->limiterGains = 2;
325 pBsData->interpolFreq = 1;
326 pBsData->smoothingLength = 1;
327 }
328
329 /* Look for new settings. IEC 14496-3, 4.6.18.3.1 */
330 if(hHeaderData->syncState < SBR_HEADER ||
331 lastHeader.startFreq != pBsData->startFreq ||
332 lastHeader.stopFreq != pBsData->stopFreq ||
333 lastHeader.freqScale != pBsData->freqScale ||
334 lastHeader.alterScale != pBsData->alterScale ||
335 lastHeader.noise_bands != pBsData->noise_bands ||
336 lastInfo.xover_band != hHeaderData->bs_info.xover_band) {
337 return HEADER_RESET; /* New settings */
338 }
339
340 return HEADER_OK;
341 }
342
343 /*!
344 \brief Get missing harmonics parameters (only used for AAC+SBR)
345
346 \return error status - 0 if ok
347 */
348 int
sbrGetSyntheticCodedData(HANDLE_SBR_HEADER_DATA hHeaderData,HANDLE_SBR_FRAME_DATA hFrameData,HANDLE_FDK_BITSTREAM hBs)349 sbrGetSyntheticCodedData(HANDLE_SBR_HEADER_DATA hHeaderData,
350 HANDLE_SBR_FRAME_DATA hFrameData,
351 HANDLE_FDK_BITSTREAM hBs)
352 {
353 int i, bitsRead = 0;
354
355 int flag = FDKreadBits(hBs,1);
356 bitsRead++;
357
358 if(flag){
359 for(i=0;i<hHeaderData->freqBandData.nSfb[1];i++){
360 hFrameData->addHarmonics[i] = FDKreadBits (hBs, 1 );
361 bitsRead++;
362 }
363 }
364 else {
365 for(i=0; i<MAX_FREQ_COEFFS; i++)
366 hFrameData->addHarmonics[i] = 0;
367 }
368 return(bitsRead);
369 }
370
371 /*!
372 \brief Reads extension data from the bitstream
373
374 The bitstream format allows up to 4 kinds of extended data element.
375 Extended data may contain several elements, each identified by a 2-bit-ID.
376 So far, no extended data elements are defined hence the first 2 parameters
377 are unused. The data should be skipped in order to update the number
378 of read bits for the consistency check in applySBR().
379 */
extractExtendedData(HANDLE_SBR_HEADER_DATA hHeaderData,HANDLE_FDK_BITSTREAM hBs,HANDLE_PS_DEC hParametricStereoDec)380 static int extractExtendedData(
381 HANDLE_SBR_HEADER_DATA hHeaderData, /*!< handle to SBR header */
382 HANDLE_FDK_BITSTREAM hBs /*!< Handle to the bit buffer */
383 ,HANDLE_PS_DEC hParametricStereoDec /*!< Parametric Stereo Decoder */
384 ) {
385 INT nBitsLeft;
386 int extended_data;
387 int i, frameOk = 1;
388
389
390 extended_data = FDKreadBits(hBs, 1);
391
392 if (extended_data) {
393 int cnt;
394 int bPsRead = 0;
395
396 cnt = FDKreadBits(hBs, 4);
397 if (cnt == (1<<4)-1)
398 cnt += FDKreadBits(hBs, 8);
399
400
401 nBitsLeft = 8 * cnt;
402
403 /* sanity check for cnt */
404 if (nBitsLeft > (INT)FDKgetValidBits(hBs)) {
405 /* limit nBitsLeft */
406 nBitsLeft = (INT)FDKgetValidBits(hBs);
407 /* set frame error */
408 frameOk = 0;
409 }
410
411 while (nBitsLeft > 7) {
412 int extension_id = FDKreadBits(hBs, 2);
413 nBitsLeft -= 2;
414
415 switch(extension_id) {
416
417
418
419 case EXTENSION_ID_PS_CODING:
420
421 /* Read PS data from bitstream */
422
423 if (hParametricStereoDec != NULL) {
424 if(bPsRead && !hParametricStereoDec->bsData[hParametricStereoDec->bsReadSlot].mpeg.bPsHeaderValid) {
425 cnt = nBitsLeft >> 3; /* number of remaining bytes */
426 for (i=0; i<cnt; i++)
427 FDKreadBits(hBs, 8);
428 nBitsLeft -= cnt * 8;
429 } else {
430 nBitsLeft -= ReadPsData(hParametricStereoDec, hBs, nBitsLeft);
431 bPsRead = 1;
432 }
433 }
434
435 /* parametric stereo detected, could set channelMode accordingly here */
436 /* */
437 /* "The usage of this parametric stereo extension to HE-AAC is */
438 /* signalled implicitly in the bitstream. Hence, if an sbr_extension() */
439 /* with bs_extension_id==EXTENSION_ID_PS is found in the SBR part of */
440 /* the bitstream, a decoder supporting the combination of SBR and PS */
441 /* shall operate the PS tool to generate a stereo output signal." */
442 /* source: ISO/IEC 14496-3:2001/FDAM 2:2004(E) */
443
444 break;
445
446
447 default:
448 cnt = nBitsLeft >> 3; /* number of remaining bytes */
449 for (i=0; i<cnt; i++)
450 FDKreadBits(hBs, 8);
451 nBitsLeft -= cnt * 8;
452 break;
453 }
454 }
455
456 if (nBitsLeft < 0) {
457 frameOk = 0;
458 goto bail;
459 }
460 else {
461 /* Read fill bits for byte alignment */
462 FDKreadBits(hBs, nBitsLeft);
463 }
464 }
465
466 bail:
467 return (frameOk);
468 }
469
470
471 /*!
472 \brief Read bitstream elements of one channel
473
474 \return SbrFrameOK: 1=ok, 0=error
475 */
476 int
sbrGetSingleChannelElement(HANDLE_SBR_HEADER_DATA hHeaderData,HANDLE_SBR_FRAME_DATA hFrameData,HANDLE_FDK_BITSTREAM hBs,HANDLE_PS_DEC hParametricStereoDec,const UINT flags,const int overlap)477 sbrGetSingleChannelElement (HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static control data */
478 HANDLE_SBR_FRAME_DATA hFrameData, /*!< Control data of current frame */
479 HANDLE_FDK_BITSTREAM hBs, /*!< Handle to struct BIT_BUF */
480 HANDLE_PS_DEC hParametricStereoDec, /*!< Handle to PS decoder */
481 const UINT flags,
482 const int overlap
483 )
484 {
485 int i;
486
487
488 hFrameData->coupling = COUPLING_OFF;
489
490 {
491 /* Reserved bits */
492 if (FDKreadBits(hBs, 1)) { /* bs_data_extra */
493 FDKreadBits(hBs, 4);
494 if (flags & SBRDEC_SYNTAX_SCAL) {
495 FDKreadBits(hBs, 4);
496 }
497 }
498 }
499
500 if (flags & SBRDEC_SYNTAX_SCAL) {
501 FDKreadBits (hBs, 1); /* bs_coupling */
502 }
503
504 /*
505 Grid control
506 */
507 if ( !extractFrameInfo ( hBs, hHeaderData, hFrameData, 1, flags) )
508 return 0;
509
510 if ( !checkFrameInfo (&hFrameData->frameInfo, hHeaderData->numberTimeSlots, overlap, hHeaderData->timeStep) )
511 return 0;
512
513
514 /*
515 Fetch domain vectors (time or frequency direction for delta-coding)
516 */
517 sbrGetDirectionControlData (hFrameData, hBs);
518
519 for (i=0; i<hHeaderData->freqBandData.nInvfBands; i++) {
520 hFrameData->sbr_invf_mode[i] =
521 (INVF_MODE) FDKreadBits (hBs, 2);
522 }
523
524
525
526 /* raw data */
527 if ( !sbrGetEnvelope (hHeaderData, hFrameData, hBs, flags) )
528 return 0;
529
530
531 sbrGetNoiseFloorData (hHeaderData, hFrameData, hBs);
532
533 sbrGetSyntheticCodedData(hHeaderData, hFrameData, hBs);
534
535 {
536 /* sbr extended data */
537 if (! extractExtendedData(
538 hHeaderData,
539 hBs
540 ,hParametricStereoDec
541 )) {
542 return 0;
543 }
544 }
545
546 return 1;
547 }
548
549
550
551 /*!
552 \brief Read bitstream elements of a channel pair
553 \return SbrFrameOK
554 */
555 int
sbrGetChannelPairElement(HANDLE_SBR_HEADER_DATA hHeaderData,HANDLE_SBR_FRAME_DATA hFrameDataLeft,HANDLE_SBR_FRAME_DATA hFrameDataRight,HANDLE_FDK_BITSTREAM hBs,const UINT flags,const int overlap)556 sbrGetChannelPairElement (HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static control data */
557 HANDLE_SBR_FRAME_DATA hFrameDataLeft, /*!< Dynamic control data for first channel */
558 HANDLE_SBR_FRAME_DATA hFrameDataRight,/*!< Dynamic control data for second channel */
559 HANDLE_FDK_BITSTREAM hBs, /*!< handle to struct BIT_BUF */
560 const UINT flags,
561 const int overlap )
562 {
563 int i, bit;
564
565
566 /* Reserved bits */
567 if (FDKreadBits(hBs, 1)) { /* bs_data_extra */
568 FDKreadBits(hBs, 4);
569 FDKreadBits(hBs, 4);
570 }
571
572 /* Read coupling flag */
573 bit = FDKreadBits (hBs, 1);
574
575 if (bit) {
576 hFrameDataLeft->coupling = COUPLING_LEVEL;
577 hFrameDataRight->coupling = COUPLING_BAL;
578 }
579 else {
580 hFrameDataLeft->coupling = COUPLING_OFF;
581 hFrameDataRight->coupling = COUPLING_OFF;
582 }
583
584
585 /*
586 Grid control
587 */
588 if ( !extractFrameInfo (hBs, hHeaderData, hFrameDataLeft, 2, flags) )
589 return 0;
590
591 if ( !checkFrameInfo (&hFrameDataLeft->frameInfo, hHeaderData->numberTimeSlots, overlap, hHeaderData->timeStep) )
592 return 0;
593
594 if (hFrameDataLeft->coupling) {
595 FDKmemcpy (&hFrameDataRight->frameInfo, &hFrameDataLeft->frameInfo, sizeof(FRAME_INFO));
596 hFrameDataRight->ampResolutionCurrentFrame = hFrameDataLeft->ampResolutionCurrentFrame;
597 }
598 else {
599 if ( !extractFrameInfo (hBs, hHeaderData, hFrameDataRight, 2, flags) )
600 return 0;
601
602 if ( !checkFrameInfo (&hFrameDataRight->frameInfo, hHeaderData->numberTimeSlots, overlap, hHeaderData->timeStep) )
603 return 0;
604 }
605
606 /*
607 Fetch domain vectors (time or frequency direction for delta-coding)
608 */
609 sbrGetDirectionControlData (hFrameDataLeft, hBs);
610 sbrGetDirectionControlData (hFrameDataRight, hBs);
611
612 for (i=0; i<hHeaderData->freqBandData.nInvfBands; i++) {
613 hFrameDataLeft->sbr_invf_mode[i] = (INVF_MODE) FDKreadBits (hBs, 2);
614 }
615
616 if (hFrameDataLeft->coupling) {
617 for (i=0; i<hHeaderData->freqBandData.nInvfBands; i++) {
618 hFrameDataRight->sbr_invf_mode[i] = hFrameDataLeft->sbr_invf_mode[i];
619 }
620
621
622 if ( !sbrGetEnvelope (hHeaderData, hFrameDataLeft, hBs, flags) ) {
623 return 0;
624 }
625
626 sbrGetNoiseFloorData (hHeaderData, hFrameDataLeft, hBs);
627
628 if ( !sbrGetEnvelope (hHeaderData, hFrameDataRight, hBs, flags) ) {
629 return 0;
630 }
631 }
632 else {
633
634 for (i=0; i<hHeaderData->freqBandData.nInvfBands; i++) {
635 hFrameDataRight->sbr_invf_mode[i] = (INVF_MODE) FDKreadBits (hBs, 2);
636 }
637
638
639
640 if ( !sbrGetEnvelope (hHeaderData, hFrameDataLeft, hBs, flags) )
641 return 0;
642
643 if ( !sbrGetEnvelope (hHeaderData, hFrameDataRight, hBs, flags) )
644 return 0;
645
646 sbrGetNoiseFloorData (hHeaderData, hFrameDataLeft, hBs);
647
648 }
649 sbrGetNoiseFloorData (hHeaderData, hFrameDataRight, hBs);
650
651 sbrGetSyntheticCodedData(hHeaderData, hFrameDataLeft, hBs);
652 sbrGetSyntheticCodedData(hHeaderData, hFrameDataRight, hBs);
653
654 {
655 if (! extractExtendedData(
656 hHeaderData,
657 hBs
658 ,NULL
659 ) ) {
660 return 0;
661 }
662 }
663
664 return 1;
665 }
666
667
668
669
670 /*!
671 \brief Read direction control data from bitstream
672 */
673 void
sbrGetDirectionControlData(HANDLE_SBR_FRAME_DATA h_frame_data,HANDLE_FDK_BITSTREAM hBs)674 sbrGetDirectionControlData (HANDLE_SBR_FRAME_DATA h_frame_data, /*!< handle to struct SBR_FRAME_DATA */
675 HANDLE_FDK_BITSTREAM hBs) /*!< handle to struct BIT_BUF */
676 {
677 int i;
678
679 for (i = 0; i < h_frame_data->frameInfo.nEnvelopes; i++) {
680 h_frame_data->domain_vec[i] = FDKreadBits (hBs, 1);
681 }
682
683 for (i = 0; i < h_frame_data->frameInfo.nNoiseEnvelopes; i++) {
684 h_frame_data->domain_vec_noise[i] = FDKreadBits (hBs, 1);
685 }
686 }
687
688
689
690 /*!
691 \brief Read noise-floor-level data from bitstream
692 */
693 void
sbrGetNoiseFloorData(HANDLE_SBR_HEADER_DATA hHeaderData,HANDLE_SBR_FRAME_DATA h_frame_data,HANDLE_FDK_BITSTREAM hBs)694 sbrGetNoiseFloorData (HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static control data */
695 HANDLE_SBR_FRAME_DATA h_frame_data, /*!< handle to struct SBR_FRAME_DATA */
696 HANDLE_FDK_BITSTREAM hBs) /*!< handle to struct BIT_BUF */
697 {
698 int i,j;
699 int delta;
700 COUPLING_MODE coupling;
701 int noNoiseBands = hHeaderData->freqBandData.nNfb;
702
703 Huffman hcb_noiseF;
704 Huffman hcb_noise;
705 int envDataTableCompFactor;
706
707 coupling = h_frame_data->coupling;
708
709
710 /*
711 Select huffman codebook depending on coupling mode
712 */
713 if (coupling == COUPLING_BAL) {
714 hcb_noise = (Huffman)&FDK_sbrDecoder_sbr_huffBook_NoiseBalance11T;
715 hcb_noiseF = (Huffman)&FDK_sbrDecoder_sbr_huffBook_EnvBalance11F; /* "sbr_huffBook_NoiseBalance11F" */
716 envDataTableCompFactor = 1;
717 }
718 else {
719 hcb_noise = (Huffman)&FDK_sbrDecoder_sbr_huffBook_NoiseLevel11T;
720 hcb_noiseF = (Huffman)&FDK_sbrDecoder_sbr_huffBook_EnvLevel11F; /* "sbr_huffBook_NoiseLevel11F" */
721 envDataTableCompFactor = 0;
722 }
723
724 /*
725 Read raw noise-envelope data
726 */
727 for (i=0; i<h_frame_data->frameInfo.nNoiseEnvelopes; i++) {
728
729
730 if (h_frame_data->domain_vec_noise[i] == 0) {
731 if (coupling == COUPLING_BAL) {
732 h_frame_data->sbrNoiseFloorLevel[i*noNoiseBands] =
733 (FIXP_SGL) (((int)FDKreadBits (hBs, 5)) << envDataTableCompFactor);
734 }
735 else {
736 h_frame_data->sbrNoiseFloorLevel[i*noNoiseBands] =
737 (FIXP_SGL) (int)FDKreadBits (hBs, 5);
738 }
739
740 for (j = 1; j < noNoiseBands; j++) {
741 delta = DecodeHuffmanCW(hcb_noiseF, hBs);
742 h_frame_data->sbrNoiseFloorLevel[i*noNoiseBands+j] = (FIXP_SGL) (delta << envDataTableCompFactor);
743 }
744 }
745 else {
746 for (j = 0; j < noNoiseBands; j++) {
747 delta = DecodeHuffmanCW(hcb_noise, hBs);
748 h_frame_data->sbrNoiseFloorLevel[i*noNoiseBands+j] = (FIXP_SGL) (delta << envDataTableCompFactor);
749 }
750 }
751 }
752 }
753
754
755 /*!
756 \brief Read envelope data from bitstream
757 */
758 static int
sbrGetEnvelope(HANDLE_SBR_HEADER_DATA hHeaderData,HANDLE_SBR_FRAME_DATA h_frame_data,HANDLE_FDK_BITSTREAM hBs,const UINT flags)759 sbrGetEnvelope (HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static control data */
760 HANDLE_SBR_FRAME_DATA h_frame_data, /*!< handle to struct SBR_FRAME_DATA */
761 HANDLE_FDK_BITSTREAM hBs, /*!< handle to struct BIT_BUF */
762 const UINT flags)
763 {
764 int i, j;
765 UCHAR no_band[MAX_ENVELOPES];
766 int delta = 0;
767 int offset = 0;
768 COUPLING_MODE coupling = h_frame_data->coupling;
769 int ampRes = hHeaderData->bs_info.ampResolution;
770 int nEnvelopes = h_frame_data->frameInfo.nEnvelopes;
771 int envDataTableCompFactor;
772 int start_bits, start_bits_balance;
773 Huffman hcb_t, hcb_f;
774
775 h_frame_data->nScaleFactors = 0;
776
777 if ( (h_frame_data->frameInfo.frameClass == 0) && (nEnvelopes == 1) ) {
778 if (flags & SBRDEC_ELD_GRID)
779 ampRes = h_frame_data->ampResolutionCurrentFrame;
780 else
781 ampRes = 0;
782 }
783 h_frame_data->ampResolutionCurrentFrame = ampRes;
784
785 /*
786 Set number of bits for first value depending on amplitude resolution
787 */
788 if(ampRes == 1)
789 {
790 start_bits = 6;
791 start_bits_balance = 5;
792 }
793 else
794 {
795 start_bits = 7;
796 start_bits_balance = 6;
797 }
798
799 /*
800 Calculate number of values for each envelope and alltogether
801 */
802 for (i = 0; i < nEnvelopes; i++) {
803 no_band[i] = hHeaderData->freqBandData.nSfb[h_frame_data->frameInfo.freqRes[i]];
804 h_frame_data->nScaleFactors += no_band[i];
805 }
806 if (h_frame_data->nScaleFactors > MAX_NUM_ENVELOPE_VALUES)
807 return 0;
808
809 /*
810 Select Huffman codebook depending on coupling mode and amplitude resolution
811 */
812 if (coupling == COUPLING_BAL) {
813 envDataTableCompFactor = 1;
814 if (ampRes == 0) {
815 hcb_t = (Huffman)&FDK_sbrDecoder_sbr_huffBook_EnvBalance10T;
816 hcb_f = (Huffman)&FDK_sbrDecoder_sbr_huffBook_EnvBalance10F;
817 }
818 else {
819 hcb_t = (Huffman)&FDK_sbrDecoder_sbr_huffBook_EnvBalance11T;
820 hcb_f = (Huffman)&FDK_sbrDecoder_sbr_huffBook_EnvBalance11F;
821 }
822 }
823 else {
824 envDataTableCompFactor = 0;
825 if (ampRes == 0) {
826 hcb_t = (Huffman)&FDK_sbrDecoder_sbr_huffBook_EnvLevel10T;
827 hcb_f = (Huffman)&FDK_sbrDecoder_sbr_huffBook_EnvLevel10F;
828 }
829 else {
830 hcb_t = (Huffman)&FDK_sbrDecoder_sbr_huffBook_EnvLevel11T;
831 hcb_f = (Huffman)&FDK_sbrDecoder_sbr_huffBook_EnvLevel11F;
832 }
833 }
834
835 /*
836 Now read raw envelope data
837 */
838 for (j = 0, offset = 0; j < nEnvelopes; j++) {
839
840
841 if (h_frame_data->domain_vec[j] == 0) {
842 if (coupling == COUPLING_BAL) {
843 h_frame_data->iEnvelope[offset] =
844 (FIXP_SGL) (( (int)FDKreadBits(hBs, start_bits_balance)) << envDataTableCompFactor);
845 }
846 else {
847 h_frame_data->iEnvelope[offset] =
848 (FIXP_SGL) (int)FDKreadBits (hBs, start_bits);
849 }
850 }
851
852 for (i = (1 - h_frame_data->domain_vec[j]); i < no_band[j]; i++) {
853
854 if (h_frame_data->domain_vec[j] == 0) {
855 delta = DecodeHuffmanCW(hcb_f, hBs);
856 }
857 else {
858 delta = DecodeHuffmanCW(hcb_t, hBs);
859 }
860
861 h_frame_data->iEnvelope[offset + i] = (FIXP_SGL) (delta << envDataTableCompFactor);
862 }
863 offset += no_band[j];
864 }
865
866 #if ENV_EXP_FRACT
867 /* Convert from int to scaled fract (ENV_EXP_FRACT bits for the fractional part) */
868 for (i = 0; i < h_frame_data->nScaleFactors; i++) {
869 h_frame_data->iEnvelope[i] <<= ENV_EXP_FRACT;
870 }
871 #endif
872
873 return 1;
874 }
875
876
877 //static const FRAME_INFO v_frame_info1_8 = { 0, 1, {0, 8}, {1}, -1, 1, {0, 8} };
878 static const FRAME_INFO v_frame_info2_8 = { 0, 2, {0, 4, 8}, {1, 1}, -1, 2, {0, 4, 8} };
879 static const FRAME_INFO v_frame_info4_8 = { 0, 4, {0, 2, 4, 6, 8}, {1, 1, 1, 1}, -1, 2, {0, 4, 8} };
880
881 /***************************************************************************/
882 /*!
883 \brief Generates frame info for FIXFIXonly frame class used for low delay version
884
885 \return nothing
886 ****************************************************************************/
generateFixFixOnly(FRAME_INFO * hSbrFrameInfo,int tranPosInternal,int numberTimeSlots)887 static void generateFixFixOnly ( FRAME_INFO *hSbrFrameInfo,
888 int tranPosInternal,
889 int numberTimeSlots
890 )
891 {
892 int nEnv, i, tranIdx;
893 const int *pTable;
894
895 switch (numberTimeSlots) {
896 case 8:
897 pTable = FDK_sbrDecoder_envelopeTable_8[tranPosInternal];
898 break;
899 case 15:
900 pTable = FDK_sbrDecoder_envelopeTable_15[tranPosInternal];
901 break;
902 case 16:
903 pTable = FDK_sbrDecoder_envelopeTable_16[tranPosInternal];
904 break;
905 default:
906 FDK_ASSERT(0);
907 /* in case assertion checks are disabled, force a definite memory fault at first access */
908 pTable = NULL;
909 break;
910 }
911
912 /* look number of envelopes in table */
913 nEnv = pTable[0];
914 /* look up envelope distribution in table */
915 for (i=1; i<nEnv; i++)
916 hSbrFrameInfo->borders[i] = pTable[i+2];
917 /* open and close frame border */
918 hSbrFrameInfo->borders[0] = 0;
919 hSbrFrameInfo->borders[nEnv] = numberTimeSlots;
920 hSbrFrameInfo->nEnvelopes = nEnv;
921
922 /* transient idx */
923 tranIdx = hSbrFrameInfo->tranEnv = pTable[1];
924
925 /* add noise floors */
926 hSbrFrameInfo->bordersNoise[0] = 0;
927 hSbrFrameInfo->bordersNoise[1] = hSbrFrameInfo->borders[tranIdx?tranIdx:1];
928 hSbrFrameInfo->bordersNoise[2] = numberTimeSlots;
929 /* nEnv is always > 1, so nNoiseEnvelopes is always 2 (IEC 14496-3 4.6.19.3.2) */
930 hSbrFrameInfo->nNoiseEnvelopes = 2;
931 }
932
933 /*!
934 \brief Extracts LowDelaySBR control data from the bitstream.
935
936 \return zero for bitstream error, one for correct.
937 */
938 static int
extractLowDelayGrid(HANDLE_FDK_BITSTREAM hBitBuf,HANDLE_SBR_HEADER_DATA hHeaderData,HANDLE_SBR_FRAME_DATA h_frame_data,int timeSlots)939 extractLowDelayGrid (HANDLE_FDK_BITSTREAM hBitBuf, /*!< bitbuffer handle */
940 HANDLE_SBR_HEADER_DATA hHeaderData,
941 HANDLE_SBR_FRAME_DATA h_frame_data, /*!< contains the FRAME_INFO struct to be filled */
942 int timeSlots
943 )
944 {
945 FRAME_INFO * pFrameInfo = &h_frame_data->frameInfo;
946 INT numberTimeSlots = hHeaderData->numberTimeSlots;
947 INT temp = 0, k;
948
949 /* FIXFIXonly framing case */
950 h_frame_data->frameInfo.frameClass = 0;
951
952 /* get the transient position from the bitstream */
953 switch (timeSlots){
954 case 8:
955 /* 3bit transient position (temp={0;..;7}) */
956 temp = FDKreadBits( hBitBuf, 3);
957 break;
958
959 case 16:
960 case 15:
961 /* 4bit transient position (temp={0;..;15}) */
962 temp = FDKreadBits( hBitBuf, 4);
963 break;
964
965 default:
966 return 0;
967 }
968
969 /* calculate borders according to the transient position */
970 generateFixFixOnly ( pFrameInfo,
971 temp,
972 numberTimeSlots
973 );
974
975 /* decode freq res: */
976 for (k = 0; k < pFrameInfo->nEnvelopes; k++) {
977 pFrameInfo->freqRes[k] = (UCHAR) FDKreadBits (hBitBuf, 1); /* f = F [1 bits] */
978 }
979
980
981 return 1;
982 }
983
984 /*!
985 \brief Extract the frame information (structure FRAME_INFO) from the bitstream
986 \return Zero for bitstream error, one for correct.
987 */
988 int
extractFrameInfo(HANDLE_FDK_BITSTREAM hBs,HANDLE_SBR_HEADER_DATA hHeaderData,HANDLE_SBR_FRAME_DATA h_frame_data,const UINT nrOfChannels,const UINT flags)989 extractFrameInfo ( HANDLE_FDK_BITSTREAM hBs, /*!< bitbuffer handle */
990 HANDLE_SBR_HEADER_DATA hHeaderData, /*!< Static control data */
991 HANDLE_SBR_FRAME_DATA h_frame_data, /*!< pointer to memory where the frame-info will be stored */
992 const UINT nrOfChannels,
993 const UINT flags
994 )
995 {
996 FRAME_INFO * pFrameInfo = &h_frame_data->frameInfo;
997 int numberTimeSlots = hHeaderData->numberTimeSlots;
998 int pointer_bits = 0, nEnv = 0, b = 0, border, i, n = 0,
999 k, p, aL, aR, nL, nR,
1000 temp = 0, staticFreqRes;
1001 UCHAR frameClass;
1002
1003 if (flags & SBRDEC_ELD_GRID) {
1004 /* CODEC_AACLD (LD+SBR) only uses the normal 0 Grid for non-transient Frames and the LowDelayGrid for transient Frames */
1005 frameClass = FDKreadBits (hBs, 1); /* frameClass = [1 bit] */
1006 if ( frameClass == 1 ) {
1007 /* if frameClass == 1, extract LowDelaySbrGrid, otherwise extract normal SBR-Grid for FIXIFX */
1008 /* extract the AACLD-Sbr-Grid */
1009 pFrameInfo->frameClass = frameClass;
1010 extractLowDelayGrid (hBs, hHeaderData, h_frame_data, numberTimeSlots);
1011 return 1;
1012 }
1013 } else
1014 {
1015 frameClass = FDKreadBits (hBs, 2); /* frameClass = C [2 bits] */
1016 }
1017
1018
1019 switch (frameClass) {
1020 case 0:
1021 temp = FDKreadBits (hBs, 2); /* E [2 bits ] */
1022 nEnv = (int) (1 << temp); /* E -> e */
1023
1024 if ((flags & SBRDEC_ELD_GRID) && (nEnv == 1))
1025 h_frame_data->ampResolutionCurrentFrame = FDKreadBits( hBs, 1); /* new ELD Syntax 07-11-09 */
1026
1027 staticFreqRes = FDKreadBits (hBs, 1);
1028
1029 {
1030 if (nEnv > MAX_ENVELOPES_HEAAC)
1031 return 0;
1032 }
1033
1034 b = nEnv + 1;
1035 switch (nEnv) {
1036 case 1:
1037 switch (numberTimeSlots) {
1038 case 15:
1039 FDKmemcpy (pFrameInfo, &FDK_sbrDecoder_sbr_frame_info1_15, sizeof(FRAME_INFO));
1040 break;
1041 case 16:
1042 FDKmemcpy (pFrameInfo, &FDK_sbrDecoder_sbr_frame_info1_16, sizeof(FRAME_INFO));
1043 break;
1044 default:
1045 FDK_ASSERT(0);
1046 }
1047 break;
1048 case 2:
1049 switch (numberTimeSlots) {
1050 case 15:
1051 FDKmemcpy (pFrameInfo, &FDK_sbrDecoder_sbr_frame_info2_15, sizeof(FRAME_INFO));
1052 break;
1053 case 16:
1054 FDKmemcpy (pFrameInfo, &FDK_sbrDecoder_sbr_frame_info2_16, sizeof(FRAME_INFO));
1055 break;
1056 default:
1057 FDK_ASSERT(0);
1058 }
1059 break;
1060 case 4:
1061 switch (numberTimeSlots) {
1062 case 15:
1063 FDKmemcpy (pFrameInfo, &FDK_sbrDecoder_sbr_frame_info4_15, sizeof(FRAME_INFO));
1064 break;
1065 case 16:
1066 FDKmemcpy (pFrameInfo, &FDK_sbrDecoder_sbr_frame_info4_16, sizeof(FRAME_INFO));
1067 break;
1068 default:
1069 FDK_ASSERT(0);
1070 }
1071 break;
1072 case 8:
1073 #if (MAX_ENVELOPES >= 8)
1074 switch (numberTimeSlots) {
1075 case 15:
1076 FDKmemcpy (pFrameInfo, &FDK_sbrDecoder_sbr_frame_info8_15, sizeof(FRAME_INFO));
1077 break;
1078 case 16:
1079 FDKmemcpy (pFrameInfo, &FDK_sbrDecoder_sbr_frame_info8_16, sizeof(FRAME_INFO));
1080 break;
1081 default:
1082 FDK_ASSERT(0);
1083 }
1084 break;
1085 #else
1086 return 0;
1087 #endif
1088 }
1089 /* Apply correct freqRes (High is default) */
1090 if (!staticFreqRes) {
1091 for (i = 0; i < nEnv ; i++)
1092 pFrameInfo->freqRes[i] = 0;
1093 }
1094
1095 break;
1096 case 1:
1097 case 2:
1098 temp = FDKreadBits (hBs, 2); /* A [2 bits] */
1099
1100 n = FDKreadBits (hBs, 2); /* n = N [2 bits] */
1101
1102 nEnv = n + 1; /* # envelopes */
1103 b = nEnv + 1; /* # borders */
1104
1105 break;
1106 }
1107
1108 switch (frameClass) {
1109 case 1:
1110 /* Decode borders: */
1111 pFrameInfo->borders[0] = 0; /* first border */
1112 border = temp + numberTimeSlots; /* A -> aR */
1113 i = b-1; /* frame info index for last border */
1114 pFrameInfo->borders[i] = border; /* last border */
1115
1116 for (k = 0; k < n; k++) {
1117 temp = FDKreadBits (hBs, 2);/* R [2 bits] */
1118 border -= (2 * temp + 2); /* R -> r */
1119 pFrameInfo->borders[--i] = border;
1120 }
1121
1122
1123 /* Decode pointer: */
1124 pointer_bits = DFRACT_BITS - 1 - CountLeadingBits((FIXP_DBL)(n+1));
1125 p = FDKreadBits (hBs, pointer_bits); /* p = P [pointer_bits bits] */
1126
1127 if (p > n+1)
1128 return 0;
1129
1130 pFrameInfo->tranEnv = p ? n + 2 - p : -1;
1131
1132
1133 /* Decode freq res: */
1134 for (k = n; k >= 0; k--) {
1135 pFrameInfo->freqRes[k] = FDKreadBits (hBs, 1); /* f = F [1 bits] */
1136 }
1137
1138
1139 /* Calculate noise floor middle border: */
1140 if (p == 0 || p == 1)
1141 pFrameInfo->bordersNoise[1] = pFrameInfo->borders[n];
1142 else
1143 pFrameInfo->bordersNoise[1] = pFrameInfo->borders[pFrameInfo->tranEnv];
1144
1145 break;
1146
1147 case 2:
1148 /* Decode borders: */
1149 border = temp; /* A -> aL */
1150 pFrameInfo->borders[0] = border; /* first border */
1151
1152 for (k = 1; k <= n; k++) {
1153 temp = FDKreadBits (hBs, 2);/* R [2 bits] */
1154 border += (2 * temp + 2); /* R -> r */
1155 pFrameInfo->borders[k] = border;
1156 }
1157 pFrameInfo->borders[k] = numberTimeSlots; /* last border */
1158
1159
1160 /* Decode pointer: */
1161 pointer_bits = DFRACT_BITS - 1 - CountLeadingBits((FIXP_DBL)(n+1));
1162 p = FDKreadBits (hBs, pointer_bits); /* p = P [pointer_bits bits] */
1163 if (p > n+1)
1164 return 0;
1165
1166 if (p == 0 || p == 1)
1167 pFrameInfo->tranEnv = -1;
1168 else
1169 pFrameInfo->tranEnv = p - 1;
1170
1171
1172
1173 /* Decode freq res: */
1174 for (k = 0; k <= n; k++) {
1175 pFrameInfo->freqRes[k] = FDKreadBits(hBs, 1); /* f = F [1 bits] */
1176 }
1177
1178
1179
1180 /* Calculate noise floor middle border: */
1181 switch (p) {
1182 case 0:
1183 pFrameInfo->bordersNoise[1] = pFrameInfo->borders[1];
1184 break;
1185 case 1:
1186 pFrameInfo->bordersNoise[1] = pFrameInfo->borders[n];
1187 break;
1188 default:
1189 pFrameInfo->bordersNoise[1] = pFrameInfo->borders[pFrameInfo->tranEnv];
1190 break;
1191 }
1192
1193 break;
1194
1195 case 3:
1196 /* v_ctrlSignal = [frameClass,aL,aR,nL,nR,v_rL,v_rR,p,v_fLR]; */
1197
1198 aL = FDKreadBits (hBs, 2); /* AL [2 bits], AL -> aL */
1199
1200 aR = FDKreadBits (hBs, 2) + numberTimeSlots; /* AR [2 bits], AR -> aR */
1201
1202 nL = FDKreadBits (hBs, 2); /* nL = NL [2 bits] */
1203
1204 nR = FDKreadBits (hBs, 2); /* nR = NR [2 bits] */
1205
1206
1207
1208 /*-------------------------------------------------------------------------
1209 Calculate help variables
1210 --------------------------------------------------------------------------*/
1211
1212 /* general: */
1213 nEnv = nL + nR + 1; /* # envelopes */
1214 if (nEnv > MAX_ENVELOPES)
1215 return 0;
1216 b = nEnv + 1; /* # borders */
1217
1218
1219
1220 /*-------------------------------------------------------------------------
1221 Decode envelopes
1222 --------------------------------------------------------------------------*/
1223
1224
1225 /* L-borders: */
1226 border = aL; /* first border */
1227 pFrameInfo->borders[0] = border;
1228
1229 for (k = 1; k <= nL; k++) {
1230 temp = FDKreadBits (hBs, 2);/* R [2 bits] */
1231 border += (2 * temp + 2); /* R -> r */
1232 pFrameInfo->borders[k] = border;
1233 }
1234
1235
1236 /* R-borders: */
1237 border = aR; /* last border */
1238 i = nEnv;
1239
1240 pFrameInfo->borders[i] = border;
1241
1242 for (k = 0; k < nR; k++) {
1243 temp = FDKreadBits (hBs, 2);/* R [2 bits] */
1244 border -= (2 * temp + 2); /* R -> r */
1245 pFrameInfo->borders[--i] = border;
1246 }
1247
1248
1249 /* decode pointer: */
1250 pointer_bits = DFRACT_BITS - 1 - CountLeadingBits((FIXP_DBL)(nL+nR+1));
1251 p = FDKreadBits (hBs, pointer_bits); /* p = P [pointer_bits bits] */
1252
1253 if (p > nL+nR+1)
1254 return 0;
1255
1256 pFrameInfo->tranEnv = p ? b - p : -1;
1257
1258
1259
1260 /* decode freq res: */
1261 for (k = 0; k < nEnv; k++) {
1262 pFrameInfo->freqRes[k] = FDKreadBits(hBs, 1); /* f = F [1 bits] */
1263 }
1264
1265
1266
1267 /*-------------------------------------------------------------------------
1268 Decode noise floors
1269 --------------------------------------------------------------------------*/
1270 pFrameInfo->bordersNoise[0] = aL;
1271
1272 if (nEnv == 1) {
1273 /* 1 noise floor envelope: */
1274 pFrameInfo->bordersNoise[1] = aR;
1275 }
1276 else {
1277 /* 2 noise floor envelopes */
1278 if (p == 0 || p == 1)
1279 pFrameInfo->bordersNoise[1] = pFrameInfo->borders[nEnv - 1];
1280 else
1281 pFrameInfo->bordersNoise[1] = pFrameInfo->borders[pFrameInfo->tranEnv];
1282 pFrameInfo->bordersNoise[2] = aR;
1283 }
1284 break;
1285 }
1286
1287
1288 /*
1289 Store number of envelopes, noise floor envelopes and frame class
1290 */
1291 pFrameInfo->nEnvelopes = nEnv;
1292
1293 if (nEnv == 1)
1294 pFrameInfo->nNoiseEnvelopes = 1;
1295 else
1296 pFrameInfo->nNoiseEnvelopes = 2;
1297
1298 pFrameInfo->frameClass = frameClass;
1299
1300 if (pFrameInfo->frameClass == 2 || pFrameInfo->frameClass == 1) {
1301 /* calculate noise floor first and last borders: */
1302 pFrameInfo->bordersNoise[0] = pFrameInfo->borders[0];
1303 pFrameInfo->bordersNoise[pFrameInfo->nNoiseEnvelopes] = pFrameInfo->borders[nEnv];
1304 }
1305
1306
1307 return 1;
1308 }
1309
1310
1311 /*!
1312 \brief Check if the frameInfo vector has reasonable values.
1313 \return Zero for error, one for correct
1314 */
1315 static int
checkFrameInfo(FRAME_INFO * pFrameInfo,int numberOfTimeSlots,int overlap,int timeStep)1316 checkFrameInfo (FRAME_INFO * pFrameInfo, /*!< pointer to frameInfo */
1317 int numberOfTimeSlots, /*!< QMF time slots per frame */
1318 int overlap, /*!< Amount of overlap QMF time slots */
1319 int timeStep) /*!< QMF slots to SBR slots step factor */
1320 {
1321 int maxPos,i,j;
1322 int startPos;
1323 int stopPos;
1324 int tranEnv;
1325 int startPosNoise;
1326 int stopPosNoise;
1327 int nEnvelopes = pFrameInfo->nEnvelopes;
1328 int nNoiseEnvelopes = pFrameInfo->nNoiseEnvelopes;
1329
1330 if(nEnvelopes < 1 || nEnvelopes > MAX_ENVELOPES)
1331 return 0;
1332
1333 if(nNoiseEnvelopes > MAX_NOISE_ENVELOPES)
1334 return 0;
1335
1336 startPos = pFrameInfo->borders[0];
1337 stopPos = pFrameInfo->borders[nEnvelopes];
1338 tranEnv = pFrameInfo->tranEnv;
1339 startPosNoise = pFrameInfo->bordersNoise[0];
1340 stopPosNoise = pFrameInfo->bordersNoise[nNoiseEnvelopes];
1341
1342 if (overlap < 0 || overlap > (6)) {
1343 return 0;
1344 }
1345 if (timeStep < 1 || timeStep > 2) {
1346 return 0;
1347 }
1348 maxPos = numberOfTimeSlots + (overlap/timeStep);
1349
1350 /* Check that the start and stop positions of the frame are reasonable values. */
1351 if( (startPos < 0) || (startPos >= stopPos) )
1352 return 0;
1353 if( startPos > maxPos-numberOfTimeSlots ) /* First env. must start in or directly after the overlap buffer */
1354 return 0;
1355 if( stopPos < numberOfTimeSlots ) /* One complete frame must be ready for output after processing */
1356 return 0;
1357 if(stopPos > maxPos)
1358 return 0;
1359
1360 /* Check that the start border for every envelope is strictly later in time */
1361 for(i=0;i<nEnvelopes;i++) {
1362 if(pFrameInfo->borders[i] >= pFrameInfo->borders[i+1])
1363 return 0;
1364 }
1365
1366 /* Check that the envelope to be shortened is actually among the envelopes */
1367 if(tranEnv>nEnvelopes)
1368 return 0;
1369
1370
1371 /* Check the noise borders */
1372 if(nEnvelopes==1 && nNoiseEnvelopes>1)
1373 return 0;
1374
1375 if(startPos != startPosNoise || stopPos != stopPosNoise)
1376 return 0;
1377
1378
1379 /* Check that the start border for every noise-envelope is strictly later in time*/
1380 for(i=0; i<nNoiseEnvelopes; i++) {
1381 if(pFrameInfo->bordersNoise[i] >= pFrameInfo->bordersNoise[i+1])
1382 return 0;
1383 }
1384
1385 /* Check that every noise border is the same as an envelope border*/
1386 for(i=0; i<nNoiseEnvelopes; i++) {
1387 startPosNoise = pFrameInfo->bordersNoise[i];
1388
1389 for(j=0; j<nEnvelopes; j++) {
1390 if(pFrameInfo->borders[j] == startPosNoise)
1391 break;
1392 }
1393 if(j==nEnvelopes)
1394 return 0;
1395 }
1396
1397 return 1;
1398 }
1399