1
2 /* -----------------------------------------------------------------------------------------------------------
3 Software License for The Fraunhofer FDK AAC Codec Library for Android
4
5 � Copyright 1995 - 2013 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 parametric stereo decoder
87 */
88
89 #include "psdec.h"
90
91
92
93 #include "FDK_bitbuffer.h"
94 #include "psdec_hybrid.h"
95
96 #include "sbr_rom.h"
97 #include "sbr_ram.h"
98
99 #include "FDK_tools_rom.h"
100
101 #include "genericStds.h"
102
103 #include "FDK_trigFcts.h"
104
105
106 /********************************************************************/
107 /* MLQUAL DEFINES */
108 /********************************************************************/
109
110 #define FRACT_ZERO FRACT_BITS-1
111 /********************************************************************/
112
113 SBR_ERROR ResetPsDec( HANDLE_PS_DEC h_ps_d );
114
115 void ResetPsDeCor( HANDLE_PS_DEC h_ps_d );
116
117
118 /***** HELPERS *****/
119
120 static void assignTimeSlotsPS (FIXP_DBL *bufAdr, FIXP_DBL **bufPtr, const int numSlots, const int numChan);
121
122
123
124 /*******************/
125
126 #define DIV3 FL2FXCONST_DBL(1.f/3.f) /* division 3.0 */
127 #define DIV1_5 FL2FXCONST_DBL(2.f/3.f) /* division 1.5 */
128
129 /***************************************************************************/
130 /*!
131 \brief Creates one instance of the PS_DEC struct
132
133 \return Error info
134
135 ****************************************************************************/
136 int
CreatePsDec(HANDLE_PS_DEC * h_PS_DEC,int aacSamplesPerFrame)137 CreatePsDec( HANDLE_PS_DEC *h_PS_DEC, /*!< pointer to the module state */
138 int aacSamplesPerFrame
139 )
140 {
141 SBR_ERROR errorInfo = SBRDEC_OK;
142 HANDLE_PS_DEC h_ps_d;
143 int i;
144
145 if (*h_PS_DEC == NULL) {
146 /* Get ps dec ram */
147 h_ps_d = GetRam_ps_dec();
148 if (h_ps_d == NULL) {
149 errorInfo = SBRDEC_MEM_ALLOC_FAILED;
150 goto bail;
151 }
152 } else {
153 /* Reset an open instance */
154 h_ps_d = *h_PS_DEC;
155 }
156
157 /* initialisation */
158 switch (aacSamplesPerFrame) {
159 case 960:
160 h_ps_d->noSubSamples = 30; /* col */
161 break;
162 case 1024:
163 h_ps_d->noSubSamples = 32; /* col */
164 break;
165 default:
166 h_ps_d->noSubSamples = -1;
167 break;
168 }
169
170 if (h_ps_d->noSubSamples > MAX_NUM_COL
171 || h_ps_d->noSubSamples <= 0)
172 {
173 goto bail;
174 }
175 h_ps_d->noChannels = NO_QMF_CHANNELS; /* row */
176
177 h_ps_d->psDecodedPrv = 0;
178 h_ps_d->procFrameBased = -1;
179 for (i = 0; i < (1)+1; i++) {
180 h_ps_d->bPsDataAvail[i] = ppt_none;
181 }
182
183
184 for (i = 0; i < (1)+1; i++) {
185 FDKmemclear(&h_ps_d->bsData[i].mpeg, sizeof(MPEG_PS_BS_DATA));
186 }
187
188 errorInfo = ResetPsDec( h_ps_d );
189
190 if ( errorInfo != SBRDEC_OK )
191 goto bail;
192
193 ResetPsDeCor( h_ps_d );
194
195 *h_PS_DEC = h_ps_d;
196
197
198
199 return 0;
200
201 bail:
202 DeletePsDec(&h_ps_d);
203
204 return -1;
205 } /*END CreatePsDec */
206
207 /***************************************************************************/
208 /*!
209 \brief Delete one instance of the PS_DEC struct
210
211 \return Error info
212
213 ****************************************************************************/
214 int
DeletePsDec(HANDLE_PS_DEC * h_PS_DEC)215 DeletePsDec( HANDLE_PS_DEC *h_PS_DEC) /*!< pointer to the module state */
216 {
217 if (*h_PS_DEC == NULL) {
218 return -1;
219 }
220
221
222 FreeRam_ps_dec(h_PS_DEC);
223
224
225 return 0;
226 } /*END DeletePsDec */
227
228 /***************************************************************************/
229 /*!
230 \brief resets some values of the PS handle to default states
231
232 \return
233
234 ****************************************************************************/
ResetPsDec(HANDLE_PS_DEC h_ps_d)235 SBR_ERROR ResetPsDec( HANDLE_PS_DEC h_ps_d ) /*!< pointer to the module state */
236 {
237 SBR_ERROR errorInfo = SBRDEC_OK;
238 INT i;
239
240 const UCHAR noQmfBandsInHybrid20 = 3;
241 /* const UCHAR noQmfBandsInHybrid34 = 5; */
242
243 const UCHAR aHybridResolution20[] = { HYBRID_8_CPLX,
244 HYBRID_2_REAL,
245 HYBRID_2_REAL };
246
247 h_ps_d->specificTo.mpeg.delayBufIndex = 0;
248
249 /* explicitly init state variables to safe values (until first ps header arrives) */
250
251 h_ps_d->specificTo.mpeg.lastUsb = 0;
252
253 h_ps_d->specificTo.mpeg.scaleFactorPsDelayBuffer = -(DFRACT_BITS-1);
254
255 FDKmemclear(h_ps_d->specificTo.mpeg.aDelayBufIndexDelayQmf, (NO_QMF_CHANNELS-FIRST_DELAY_SB)*sizeof(UCHAR));
256 h_ps_d->specificTo.mpeg.noSampleDelay = delayIndexQmf[0];
257
258 for (i=0 ; i < NO_SERIAL_ALLPASS_LINKS; i++) {
259 h_ps_d->specificTo.mpeg.aDelayRBufIndexSer[i] = 0;
260 }
261
262 h_ps_d->specificTo.mpeg.pAaRealDelayBufferQmf[0] = h_ps_d->specificTo.mpeg.aaQmfDelayBufReal;
263
264 assignTimeSlotsPS ( h_ps_d->specificTo.mpeg.pAaRealDelayBufferQmf[0] + (NO_QMF_CHANNELS-FIRST_DELAY_SB),
265 &h_ps_d->specificTo.mpeg.pAaRealDelayBufferQmf[1],
266 h_ps_d->specificTo.mpeg.noSampleDelay-1,
267 (NO_DELAY_BUFFER_BANDS-FIRST_DELAY_SB));
268
269 h_ps_d->specificTo.mpeg.pAaImagDelayBufferQmf[0] = h_ps_d->specificTo.mpeg.aaQmfDelayBufImag;
270
271 assignTimeSlotsPS ( h_ps_d->specificTo.mpeg.pAaImagDelayBufferQmf[0] + (NO_QMF_CHANNELS-FIRST_DELAY_SB),
272 &h_ps_d->specificTo.mpeg.pAaImagDelayBufferQmf[1],
273 h_ps_d->specificTo.mpeg.noSampleDelay-1,
274 (NO_DELAY_BUFFER_BANDS-FIRST_DELAY_SB));
275
276 /* Hybrid Filter Bank 1 creation. */
277 errorInfo = InitHybridFilterBank ( &h_ps_d->specificTo.mpeg.hybrid,
278 h_ps_d->noSubSamples,
279 noQmfBandsInHybrid20,
280 aHybridResolution20 );
281
282 for ( i = 0; i < NO_IID_GROUPS; i++ )
283 {
284 h_ps_d->specificTo.mpeg.h11rPrev[i] = FL2FXCONST_DBL(0.5f);
285 h_ps_d->specificTo.mpeg.h12rPrev[i] = FL2FXCONST_DBL(0.5f);
286 }
287
288 FDKmemclear( h_ps_d->specificTo.mpeg.h21rPrev, sizeof( h_ps_d->specificTo.mpeg.h21rPrev ) );
289 FDKmemclear( h_ps_d->specificTo.mpeg.h22rPrev, sizeof( h_ps_d->specificTo.mpeg.h22rPrev ) );
290
291 return errorInfo;
292 }
293
294 /***************************************************************************/
295 /*!
296 \brief clear some buffers used in decorrelation process
297
298 \return
299
300 ****************************************************************************/
ResetPsDeCor(HANDLE_PS_DEC h_ps_d)301 void ResetPsDeCor( HANDLE_PS_DEC h_ps_d ) /*!< pointer to the module state */
302 {
303 INT i;
304
305 FDKmemclear(h_ps_d->specificTo.mpeg.aPeakDecayFastBin, NO_MID_RES_BINS*sizeof(FIXP_DBL));
306 FDKmemclear(h_ps_d->specificTo.mpeg.aPrevNrgBin, NO_MID_RES_BINS*sizeof(FIXP_DBL));
307 FDKmemclear(h_ps_d->specificTo.mpeg.aPrevPeakDiffBin, NO_MID_RES_BINS*sizeof(FIXP_DBL));
308 FDKmemclear(h_ps_d->specificTo.mpeg.aPowerPrevScal, NO_MID_RES_BINS*sizeof(SCHAR));
309
310 for (i=0 ; i < FIRST_DELAY_SB ; i++) {
311 FDKmemclear(h_ps_d->specificTo.mpeg.aaaRealDelayRBufferSerQmf[i], NO_DELAY_LENGTH_VECTORS*sizeof(FIXP_DBL));
312 FDKmemclear(h_ps_d->specificTo.mpeg.aaaImagDelayRBufferSerQmf[i], NO_DELAY_LENGTH_VECTORS*sizeof(FIXP_DBL));
313 }
314 for (i=0 ; i < NO_SUB_QMF_CHANNELS ; i++) {
315 FDKmemclear(h_ps_d->specificTo.mpeg.aaaRealDelayRBufferSerSubQmf[i], NO_DELAY_LENGTH_VECTORS*sizeof(FIXP_DBL));
316 FDKmemclear(h_ps_d->specificTo.mpeg.aaaImagDelayRBufferSerSubQmf[i], NO_DELAY_LENGTH_VECTORS*sizeof(FIXP_DBL));
317 }
318
319 }
320
321 /*******************************************************************************/
322
323 /* slot based funcion prototypes */
324
325 static void deCorrelateSlotBased( HANDLE_PS_DEC h_ps_d,
326
327 FIXP_DBL *mHybridRealLeft,
328 FIXP_DBL *mHybridImagLeft,
329 SCHAR sf_mHybridLeft,
330
331 FIXP_DBL *rIntBufferLeft,
332 FIXP_DBL *iIntBufferLeft,
333 SCHAR sf_IntBuffer,
334
335 FIXP_DBL *mHybridRealRight,
336 FIXP_DBL *mHybridImagRight,
337
338 FIXP_DBL *rIntBufferRight,
339 FIXP_DBL *iIntBufferRight );
340
341 static void applySlotBasedRotation( HANDLE_PS_DEC h_ps_d,
342
343 FIXP_DBL *mHybridRealLeft,
344 FIXP_DBL *mHybridImagLeft,
345
346 FIXP_DBL *QmfLeftReal,
347 FIXP_DBL *QmfLeftImag,
348
349 FIXP_DBL *mHybridRealRight,
350 FIXP_DBL *mHybridImagRight,
351
352 FIXP_DBL *QmfRightReal,
353 FIXP_DBL *QmfRightImag
354 );
355
356
357 /***************************************************************************/
358 /*!
359 \brief Get scale factor for all ps delay buffer.
360
361 \return
362
363 ****************************************************************************/
364 static
getScaleFactorPsStatesBuffer(HANDLE_PS_DEC h_ps_d)365 int getScaleFactorPsStatesBuffer(HANDLE_PS_DEC h_ps_d)
366 {
367 INT i;
368 int scale = DFRACT_BITS-1;
369
370 for (i=0; i<NO_QMF_BANDS_HYBRID20; i++) {
371 scale = fMin(scale, getScalefactor(h_ps_d->specificTo.mpeg.hybrid.mQmfBufferRealSlot[i], NO_SUB_QMF_CHANNELS));
372 scale = fMin(scale, getScalefactor(h_ps_d->specificTo.mpeg.hybrid.mQmfBufferImagSlot[i], NO_SUB_QMF_CHANNELS));
373 }
374
375 for (i=0; i<NO_SAMPLE_DELAY_ALLPASS; i++) {
376 scale = fMin(scale, getScalefactor(h_ps_d->specificTo.mpeg.aaRealDelayBufferQmf[i], FIRST_DELAY_SB));
377 scale = fMin(scale, getScalefactor(h_ps_d->specificTo.mpeg.aaImagDelayBufferQmf[i], FIRST_DELAY_SB));
378 }
379
380 for (i=0; i<NO_SAMPLE_DELAY_ALLPASS; i++) {
381 scale = fMin(scale, getScalefactor(h_ps_d->specificTo.mpeg.aaRealDelayBufferSubQmf[i], NO_SUB_QMF_CHANNELS));
382 scale = fMin(scale, getScalefactor(h_ps_d->specificTo.mpeg.aaImagDelayBufferSubQmf[i], NO_SUB_QMF_CHANNELS));
383 }
384
385 for (i=0; i<FIRST_DELAY_SB; i++) {
386 scale = fMin(scale, getScalefactor(h_ps_d->specificTo.mpeg.aaaRealDelayRBufferSerQmf[i], NO_DELAY_LENGTH_VECTORS));
387 scale = fMin(scale, getScalefactor(h_ps_d->specificTo.mpeg.aaaImagDelayRBufferSerQmf[i], NO_DELAY_LENGTH_VECTORS));
388 }
389
390 for (i=0; i<NO_SUB_QMF_CHANNELS; i++) {
391 scale = fMin(scale, getScalefactor(h_ps_d->specificTo.mpeg.aaaRealDelayRBufferSerSubQmf[i], NO_DELAY_LENGTH_VECTORS));
392 scale = fMin(scale, getScalefactor(h_ps_d->specificTo.mpeg.aaaImagDelayRBufferSerSubQmf[i], NO_DELAY_LENGTH_VECTORS));
393 }
394
395 for (i=0; i<MAX_DELAY_BUFFER_SIZE; i++)
396 {
397 INT len;
398 if (i==0)
399 len = NO_QMF_CHANNELS-FIRST_DELAY_SB;
400 else
401 len = NO_DELAY_BUFFER_BANDS-FIRST_DELAY_SB;
402
403 scale = fMin(scale, getScalefactor(h_ps_d->specificTo.mpeg.pAaRealDelayBufferQmf[i], len));
404 scale = fMin(scale, getScalefactor(h_ps_d->specificTo.mpeg.pAaImagDelayBufferQmf[i], len));
405 }
406
407 return (scale);
408 }
409
410 /***************************************************************************/
411 /*!
412 \brief Rescale all ps delay buffer.
413
414 \return
415
416 ****************************************************************************/
417 static
scalePsStatesBuffer(HANDLE_PS_DEC h_ps_d,int scale)418 void scalePsStatesBuffer(HANDLE_PS_DEC h_ps_d,
419 int scale)
420 {
421 INT i;
422
423 if (scale < 0)
424 scale = fixMax((INT)scale,(INT)-(DFRACT_BITS-1));
425 else
426 scale = fixMin((INT)scale,(INT)DFRACT_BITS-1);
427
428 for (i=0; i<NO_QMF_BANDS_HYBRID20; i++) {
429 scaleValues( h_ps_d->specificTo.mpeg.hybrid.mQmfBufferRealSlot[i], NO_SUB_QMF_CHANNELS, scale );
430 scaleValues( h_ps_d->specificTo.mpeg.hybrid.mQmfBufferImagSlot[i], NO_SUB_QMF_CHANNELS, scale );
431 }
432
433 for (i=0; i<NO_SAMPLE_DELAY_ALLPASS; i++) {
434 scaleValues( h_ps_d->specificTo.mpeg.aaRealDelayBufferQmf[i], FIRST_DELAY_SB, scale );
435 scaleValues( h_ps_d->specificTo.mpeg.aaImagDelayBufferQmf[i], FIRST_DELAY_SB, scale );
436 }
437
438 for (i=0; i<NO_SAMPLE_DELAY_ALLPASS; i++) {
439 scaleValues( h_ps_d->specificTo.mpeg.aaRealDelayBufferSubQmf[i], NO_SUB_QMF_CHANNELS, scale );
440 scaleValues( h_ps_d->specificTo.mpeg.aaImagDelayBufferSubQmf[i], NO_SUB_QMF_CHANNELS, scale );
441 }
442
443 for (i=0; i<FIRST_DELAY_SB; i++) {
444 scaleValues( h_ps_d->specificTo.mpeg.aaaRealDelayRBufferSerQmf[i], NO_DELAY_LENGTH_VECTORS, scale );
445 scaleValues( h_ps_d->specificTo.mpeg.aaaImagDelayRBufferSerQmf[i], NO_DELAY_LENGTH_VECTORS, scale );
446 }
447
448 for (i=0; i<NO_SUB_QMF_CHANNELS; i++) {
449 scaleValues( h_ps_d->specificTo.mpeg.aaaRealDelayRBufferSerSubQmf[i], NO_DELAY_LENGTH_VECTORS, scale );
450 scaleValues( h_ps_d->specificTo.mpeg.aaaImagDelayRBufferSerSubQmf[i], NO_DELAY_LENGTH_VECTORS, scale );
451 }
452
453 for (i=0; i<MAX_DELAY_BUFFER_SIZE; i++) {
454 INT len;
455 if (i==0)
456 len = NO_QMF_CHANNELS-FIRST_DELAY_SB;
457 else
458 len = NO_DELAY_BUFFER_BANDS-FIRST_DELAY_SB;
459
460 scaleValues( h_ps_d->specificTo.mpeg.pAaRealDelayBufferQmf[i], len, scale );
461 scaleValues( h_ps_d->specificTo.mpeg.pAaImagDelayBufferQmf[i], len, scale );
462 }
463
464 scale <<= 1;
465
466 scaleValues( h_ps_d->specificTo.mpeg.aPeakDecayFastBin, NO_MID_RES_BINS, scale );
467 scaleValues( h_ps_d->specificTo.mpeg.aPrevPeakDiffBin, NO_MID_RES_BINS, scale );
468 scaleValues( h_ps_d->specificTo.mpeg.aPrevNrgBin, NO_MID_RES_BINS, scale );
469 }
470
471 /***************************************************************************/
472 /*!
473 \brief Scale input channel to the same scalefactor and rescale hybrid
474 filterbank values
475
476 \return
477
478 ****************************************************************************/
479
scalFilterBankValues(HANDLE_PS_DEC h_ps_d,FIXP_DBL ** fixpQmfReal,FIXP_DBL ** fixpQmfImag,int lsb,int scaleFactorLowBandSplitLow,int scaleFactorLowBandSplitHigh,SCHAR * scaleFactorLowBand_lb,SCHAR * scaleFactorLowBand_hb,int scaleFactorHighBands,INT * scaleFactorHighBand,INT noCols)480 void scalFilterBankValues( HANDLE_PS_DEC h_ps_d,
481 FIXP_DBL **fixpQmfReal,
482 FIXP_DBL **fixpQmfImag,
483 int lsb,
484 int scaleFactorLowBandSplitLow,
485 int scaleFactorLowBandSplitHigh,
486 SCHAR *scaleFactorLowBand_lb,
487 SCHAR *scaleFactorLowBand_hb,
488 int scaleFactorHighBands,
489 INT *scaleFactorHighBand,
490 INT noCols
491 )
492 {
493 INT maxScal;
494
495 INT i;
496
497 scaleFactorHighBands = -scaleFactorHighBands;
498 scaleFactorLowBandSplitLow = -scaleFactorLowBandSplitLow;
499 scaleFactorLowBandSplitHigh = -scaleFactorLowBandSplitHigh;
500
501 /* get max scale factor */
502 maxScal = fixMax(scaleFactorHighBands,fixMax(scaleFactorLowBandSplitLow, scaleFactorLowBandSplitHigh ));
503
504 {
505 int headroom = getScaleFactorPsStatesBuffer(h_ps_d);
506 maxScal = fixMax(maxScal,(INT)(h_ps_d->specificTo.mpeg.scaleFactorPsDelayBuffer-headroom));
507 maxScal += 1;
508 }
509
510 /* scale whole left channel to the same scale factor */
511
512 /* low band ( overlap buffer ) */
513 if ( maxScal != scaleFactorLowBandSplitLow ) {
514 INT scale = scaleFactorLowBandSplitLow - maxScal;
515 for ( i=0; i<(6); i++ ) {
516 scaleValues( fixpQmfReal[i], lsb, scale );
517 scaleValues( fixpQmfImag[i], lsb, scale );
518 }
519 }
520 /* low band ( current frame ) */
521 if ( maxScal != scaleFactorLowBandSplitHigh ) {
522 INT scale = scaleFactorLowBandSplitHigh - maxScal;
523 /* for ( i=(6); i<(6)+MAX_NUM_COL; i++ ) { */
524 for ( i=(6); i<(6)+noCols; i++ ) {
525 scaleValues( fixpQmfReal[i], lsb, scale );
526 scaleValues( fixpQmfImag[i], lsb, scale );
527 }
528 }
529 /* high band */
530 if ( maxScal != scaleFactorHighBands ) {
531 INT scale = scaleFactorHighBands - maxScal;
532 /* for ( i=0; i<MAX_NUM_COL; i++ ) { */
533 for ( i=0; i<noCols; i++ ) {
534 scaleValues( &fixpQmfReal[i][lsb], (64)-lsb, scale );
535 scaleValues( &fixpQmfImag[i][lsb], (64)-lsb, scale );
536 }
537 }
538
539 if ( maxScal != h_ps_d->specificTo.mpeg.scaleFactorPsDelayBuffer )
540 scalePsStatesBuffer(h_ps_d,(h_ps_d->specificTo.mpeg.scaleFactorPsDelayBuffer-maxScal));
541
542 h_ps_d->specificTo.mpeg.hybrid.sf_mQmfBuffer = maxScal;
543 h_ps_d->specificTo.mpeg.scaleFactorPsDelayBuffer = maxScal;
544
545 *scaleFactorHighBand += maxScal - scaleFactorHighBands;
546
547 h_ps_d->rescal = maxScal - scaleFactorLowBandSplitHigh;
548 h_ps_d->sf_IntBuffer = maxScal;
549
550 *scaleFactorLowBand_lb += maxScal - scaleFactorLowBandSplitLow;
551 *scaleFactorLowBand_hb += maxScal - scaleFactorLowBandSplitHigh;
552 }
553
rescalFilterBankValues(HANDLE_PS_DEC h_ps_d,FIXP_DBL ** QmfBufferReal,FIXP_DBL ** QmfBufferImag,int lsb,INT noCols)554 void rescalFilterBankValues( HANDLE_PS_DEC h_ps_d, /* parametric stereo decoder handle */
555 FIXP_DBL **QmfBufferReal, /* qmf filterbank values */
556 FIXP_DBL **QmfBufferImag, /* qmf filterbank values */
557 int lsb, /* sbr start subband */
558 INT noCols)
559 {
560 int i;
561 /* scale back 6 timeslots look ahead for hybrid filterbank to original value */
562 for ( i=noCols; i<noCols + (6); i++ ) {
563 scaleValues( QmfBufferReal[i], lsb, h_ps_d->rescal );
564 scaleValues( QmfBufferImag[i], lsb, h_ps_d->rescal );
565 }
566 }
567
568 /***************************************************************************/
569 /*!
570 \brief Generate decorrelated side channel using allpass/delay
571
572 \return
573
574 ****************************************************************************/
575 static void
deCorrelateSlotBased(HANDLE_PS_DEC h_ps_d,FIXP_DBL * mHybridRealLeft,FIXP_DBL * mHybridImagLeft,SCHAR sf_mHybridLeft,FIXP_DBL * rIntBufferLeft,FIXP_DBL * iIntBufferLeft,SCHAR sf_IntBuffer,FIXP_DBL * mHybridRealRight,FIXP_DBL * mHybridImagRight,FIXP_DBL * rIntBufferRight,FIXP_DBL * iIntBufferRight)576 deCorrelateSlotBased( HANDLE_PS_DEC h_ps_d, /*!< pointer to the module state */
577
578 FIXP_DBL *mHybridRealLeft, /*!< left (mono) hybrid values real */
579 FIXP_DBL *mHybridImagLeft, /*!< left (mono) hybrid values imag */
580 SCHAR sf_mHybridLeft, /*!< scalefactor for left (mono) hybrid bands */
581
582 FIXP_DBL *rIntBufferLeft, /*!< real qmf bands left (mono) (38x64) */
583 FIXP_DBL *iIntBufferLeft, /*!< real qmf bands left (mono) (38x64) */
584 SCHAR sf_IntBuffer, /*!< scalefactor for all left and right qmf bands */
585
586 FIXP_DBL *mHybridRealRight, /*!< right (decorrelated) hybrid values real */
587 FIXP_DBL *mHybridImagRight, /*!< right (decorrelated) hybrid values imag */
588
589 FIXP_DBL *rIntBufferRight, /*!< real qmf bands right (decorrelated) (38x64) */
590 FIXP_DBL *iIntBufferRight ) /*!< real qmf bands right (decorrelated) (38x64) */
591 {
592
593 INT i, m, sb, gr, bin;
594
595 FIXP_DBL peakDiff, nrg, transRatio;
596
597 FIXP_DBL *RESTRICT aaLeftReal;
598 FIXP_DBL *RESTRICT aaLeftImag;
599
600 FIXP_DBL *RESTRICT aaRightReal;
601 FIXP_DBL *RESTRICT aaRightImag;
602
603 FIXP_DBL *RESTRICT pRealDelayBuffer;
604 FIXP_DBL *RESTRICT pImagDelayBuffer;
605
606 C_ALLOC_SCRATCH_START(aaPowerSlot, FIXP_DBL, NO_MID_RES_BINS);
607 C_ALLOC_SCRATCH_START(aaTransRatioSlot, FIXP_DBL, NO_MID_RES_BINS);
608
609 /*!
610 <pre>
611 parameter index qmf bands hybrid bands
612 ----------------------------------------------------------------------------
613 0 0 0,7
614 1 0 1,6
615 2 0 2
616 3 0 3 HYBRID BANDS
617 4 1 9
618 5 1 8
619 6 2 10
620 7 2 11
621 ----------------------------------------------------------------------------
622 8 3
623 9 4
624 10 5
625 11 6
626 12 7
627 13 8
628 14 9,10 (2 ) QMF BANDS
629 15 11 - 13 (3 )
630 16 14 - 17 (4 )
631 17 18 - 22 (5 )
632 18 23 - 34 (12)
633 19 35 - 63 (29)
634 ----------------------------------------------------------------------------
635 </pre>
636 */
637
638 #define FLTR_SCALE 3
639
640 /* hybrid bands (parameter index 0 - 7) */
641 aaLeftReal = mHybridRealLeft;
642 aaLeftImag = mHybridImagLeft;
643
644 aaPowerSlot[0] = ( fMultAddDiv2( fMultDiv2(aaLeftReal[0], aaLeftReal[0]), aaLeftImag[0], aaLeftImag[0] ) >> FLTR_SCALE ) +
645 ( fMultAddDiv2( fMultDiv2(aaLeftReal[7], aaLeftReal[7]), aaLeftImag[7], aaLeftImag[7] ) >> FLTR_SCALE );
646
647 aaPowerSlot[1] = ( fMultAddDiv2( fMultDiv2(aaLeftReal[1], aaLeftReal[1]), aaLeftImag[1], aaLeftImag[1] ) >> FLTR_SCALE ) +
648 ( fMultAddDiv2( fMultDiv2(aaLeftReal[6], aaLeftReal[6]), aaLeftImag[6], aaLeftImag[6] ) >> FLTR_SCALE );
649
650 aaPowerSlot[2] = fMultAddDiv2( fMultDiv2(aaLeftReal[2], aaLeftReal[2]), aaLeftImag[2], aaLeftImag[2] ) >> FLTR_SCALE;
651 aaPowerSlot[3] = fMultAddDiv2( fMultDiv2(aaLeftReal[3], aaLeftReal[3]), aaLeftImag[3], aaLeftImag[3] ) >> FLTR_SCALE;
652
653 aaPowerSlot[4] = fMultAddDiv2( fMultDiv2(aaLeftReal[9], aaLeftReal[9]), aaLeftImag[9], aaLeftImag[9] ) >> FLTR_SCALE;
654 aaPowerSlot[5] = fMultAddDiv2( fMultDiv2(aaLeftReal[8], aaLeftReal[8]), aaLeftImag[8], aaLeftImag[8] ) >> FLTR_SCALE;
655
656 aaPowerSlot[6] = fMultAddDiv2( fMultDiv2(aaLeftReal[10], aaLeftReal[10]), aaLeftImag[10], aaLeftImag[10] ) >> FLTR_SCALE;
657 aaPowerSlot[7] = fMultAddDiv2( fMultDiv2(aaLeftReal[11], aaLeftReal[11]), aaLeftImag[11], aaLeftImag[11] ) >> FLTR_SCALE;
658
659 /* qmf bands (parameter index 8 - 19) */
660 for ( bin = 8; bin < NO_MID_RES_BINS; bin++ ) {
661 FIXP_DBL slotNrg = FL2FXCONST_DBL(0.f);
662
663 for ( i = groupBorders20[bin+2]; i < groupBorders20[bin+3]; i++ ) { /* max loops: 29 */
664 slotNrg += fMultAddDiv2 ( fMultDiv2(rIntBufferLeft[i], rIntBufferLeft[i]), iIntBufferLeft[i], iIntBufferLeft[i]) >> FLTR_SCALE;
665 }
666 aaPowerSlot[bin] = slotNrg;
667
668 }
669
670
671 /* calculation of transient ratio */
672 for (bin=0; bin < NO_MID_RES_BINS; bin++) { /* noBins = 20 ( BASELINE_PS ) */
673
674 h_ps_d->specificTo.mpeg.aPeakDecayFastBin[bin] = fMult( h_ps_d->specificTo.mpeg.aPeakDecayFastBin[bin], PEAK_DECAY_FACTOR );
675
676 if (h_ps_d->specificTo.mpeg.aPeakDecayFastBin[bin] < aaPowerSlot[bin]) {
677 h_ps_d->specificTo.mpeg.aPeakDecayFastBin[bin] = aaPowerSlot[bin];
678 }
679
680 /* calculate PSmoothPeakDecayDiffNrg */
681 peakDiff = fMultAdd ( (h_ps_d->specificTo.mpeg.aPrevPeakDiffBin[bin]>>1),
682 INT_FILTER_COEFF, h_ps_d->specificTo.mpeg.aPeakDecayFastBin[bin] - aaPowerSlot[bin] - h_ps_d->specificTo.mpeg.aPrevPeakDiffBin[bin]);
683
684 /* save peakDiff for the next frame */
685 h_ps_d->specificTo.mpeg.aPrevPeakDiffBin[bin] = peakDiff;
686
687 nrg = h_ps_d->specificTo.mpeg.aPrevNrgBin[bin] + fMult( INT_FILTER_COEFF, aaPowerSlot[bin] - h_ps_d->specificTo.mpeg.aPrevNrgBin[bin] );
688
689 /* Negative energies don't exist. But sometimes they appear due to rounding. */
690
691 nrg = fixMax(nrg,FL2FXCONST_DBL(0.f));
692
693 /* save nrg for the next frame */
694 h_ps_d->specificTo.mpeg.aPrevNrgBin[bin] = nrg;
695
696 nrg = fMult( nrg, TRANSIENT_IMPACT_FACTOR );
697
698 /* save transient impact factor */
699 if ( peakDiff <= nrg || peakDiff == FL2FXCONST_DBL(0.0) ) {
700 aaTransRatioSlot[bin] = (FIXP_DBL)MAXVAL_DBL /* FL2FXCONST_DBL(1.0f)*/;
701 }
702 else if ( nrg <= FL2FXCONST_DBL(0.0f) ) {
703 aaTransRatioSlot[bin] = FL2FXCONST_DBL(0.f);
704 }
705 else {
706 /* scale to denominator */
707 INT scale_left = fixMax(0, CntLeadingZeros(peakDiff) - 1);
708 aaTransRatioSlot[bin] = schur_div( nrg<<scale_left, peakDiff<<scale_left, 16);
709 }
710 } /* bin */
711
712
713
714
715 #define DELAY_GROUP_OFFSET 20
716 #define NR_OF_DELAY_GROUPS 2
717
718 FIXP_DBL rTmp, iTmp, rTmp0, iTmp0, rR0, iR0;
719
720 INT TempDelay = h_ps_d->specificTo.mpeg.delayBufIndex; /* set delay indices */
721
722 pRealDelayBuffer = h_ps_d->specificTo.mpeg.aaRealDelayBufferSubQmf[TempDelay];
723 pImagDelayBuffer = h_ps_d->specificTo.mpeg.aaImagDelayBufferSubQmf[TempDelay];
724
725 aaLeftReal = mHybridRealLeft;
726 aaLeftImag = mHybridImagLeft;
727 aaRightReal = mHybridRealRight;
728 aaRightImag = mHybridImagRight;
729
730 /************************/
731 /* ICC groups : 0 - 9 */
732 /************************/
733
734 /* gr = ICC groups */
735 for (gr=0; gr < SUBQMF_GROUPS; gr++) {
736
737 transRatio = aaTransRatioSlot[bins2groupMap20[gr]];
738
739 /* sb = subQMF/QMF subband */
740 sb = groupBorders20[gr];
741
742 /* Update delay buffers, sample delay allpass = 2 */
743 rTmp0 = pRealDelayBuffer[sb];
744 iTmp0 = pImagDelayBuffer[sb];
745
746 pRealDelayBuffer[sb] = aaLeftReal[sb];
747 pImagDelayBuffer[sb] = aaLeftImag[sb];
748
749 /* delay by fraction */
750 cplxMultDiv2(&rR0, &iR0, rTmp0, iTmp0, aaFractDelayPhaseFactorReSubQmf20[sb], aaFractDelayPhaseFactorImSubQmf20[sb]);
751 rR0<<=1;
752 iR0<<=1;
753
754 FIXP_DBL *pAaaRealDelayRBufferSerSubQmf = h_ps_d->specificTo.mpeg.aaaRealDelayRBufferSerSubQmf[sb];
755 FIXP_DBL *pAaaImagDelayRBufferSerSubQmf = h_ps_d->specificTo.mpeg.aaaImagDelayRBufferSerSubQmf[sb];
756
757 for (m=0; m<NO_SERIAL_ALLPASS_LINKS ; m++) {
758
759 INT tmpDelayRSer = h_ps_d->specificTo.mpeg.aDelayRBufIndexSer[m];
760
761 /* get delayed values from according buffer : m(0)=3; m(1)=4; m(2)=5; */
762 rTmp0 = pAaaRealDelayRBufferSerSubQmf[tmpDelayRSer];
763 iTmp0 = pAaaImagDelayRBufferSerSubQmf[tmpDelayRSer];
764
765 /* delay by fraction */
766 cplxMultDiv2(&rTmp, &iTmp, rTmp0, iTmp0, aaFractDelayPhaseFactorSerReSubQmf20[sb][m], aaFractDelayPhaseFactorSerImSubQmf20[sb][m]);
767
768 rTmp = (rTmp - fMultDiv2(aAllpassLinkDecaySer[m], rR0)) << 1;
769 iTmp = (iTmp - fMultDiv2(aAllpassLinkDecaySer[m], iR0)) << 1;
770
771 pAaaRealDelayRBufferSerSubQmf[tmpDelayRSer] = rR0 + fMult(aAllpassLinkDecaySer[m], rTmp);
772 pAaaImagDelayRBufferSerSubQmf[tmpDelayRSer] = iR0 + fMult(aAllpassLinkDecaySer[m], iTmp);
773
774 rR0 = rTmp;
775 iR0 = iTmp;
776
777 pAaaRealDelayRBufferSerSubQmf += aAllpassLinkDelaySer[m];
778 pAaaImagDelayRBufferSerSubQmf += aAllpassLinkDelaySer[m];
779
780 } /* m */
781
782 /* duck if a past transient is found */
783 aaRightReal[sb] = fMult(transRatio, rR0);
784 aaRightImag[sb] = fMult(transRatio, iR0);
785
786 } /* gr */
787
788
789 scaleValues( mHybridRealLeft, NO_SUB_QMF_CHANNELS, -SCAL_HEADROOM );
790 scaleValues( mHybridImagLeft, NO_SUB_QMF_CHANNELS, -SCAL_HEADROOM );
791 scaleValues( mHybridRealRight, NO_SUB_QMF_CHANNELS, -SCAL_HEADROOM );
792 scaleValues( mHybridImagRight, NO_SUB_QMF_CHANNELS, -SCAL_HEADROOM );
793
794
795 /************************/
796
797 aaLeftReal = rIntBufferLeft;
798 aaLeftImag = iIntBufferLeft;
799 aaRightReal = rIntBufferRight;
800 aaRightImag = iIntBufferRight;
801
802 pRealDelayBuffer = h_ps_d->specificTo.mpeg.aaRealDelayBufferQmf[TempDelay];
803 pImagDelayBuffer = h_ps_d->specificTo.mpeg.aaImagDelayBufferQmf[TempDelay];
804
805 /************************/
806 /* ICC groups : 10 - 19 */
807 /************************/
808
809
810 /* gr = ICC groups */
811 for (gr=SUBQMF_GROUPS; gr < NO_IID_GROUPS - NR_OF_DELAY_GROUPS; gr++) {
812
813 transRatio = aaTransRatioSlot[bins2groupMap20[gr]];
814
815 /* sb = subQMF/QMF subband */
816 for (sb = groupBorders20[gr]; sb < groupBorders20[gr+1]; sb++) {
817 FIXP_DBL resR, resI;
818
819 /* decayScaleFactor = 1.0f + decay_cutoff * DECAY_SLOPE - DECAY_SLOPE * sb; DECAY_SLOPE = 0.05 */
820 FIXP_DBL decayScaleFactor = decayScaleFactTable[sb];
821
822 /* Update delay buffers, sample delay allpass = 2 */
823 rTmp0 = pRealDelayBuffer[sb];
824 iTmp0 = pImagDelayBuffer[sb];
825
826 pRealDelayBuffer[sb] = aaLeftReal[sb];
827 pImagDelayBuffer[sb] = aaLeftImag[sb];
828
829 /* delay by fraction */
830 cplxMultDiv2(&rR0, &iR0, rTmp0, iTmp0, aaFractDelayPhaseFactorReQmf[sb], aaFractDelayPhaseFactorImQmf[sb]);
831 rR0<<=1;
832 iR0<<=1;
833
834 resR = fMult(decayScaleFactor, rR0);
835 resI = fMult(decayScaleFactor, iR0);
836
837 FIXP_DBL *pAaaRealDelayRBufferSerQmf = h_ps_d->specificTo.mpeg.aaaRealDelayRBufferSerQmf[sb];
838 FIXP_DBL *pAaaImagDelayRBufferSerQmf = h_ps_d->specificTo.mpeg.aaaImagDelayRBufferSerQmf[sb];
839
840 for (m=0; m<NO_SERIAL_ALLPASS_LINKS ; m++) {
841
842 INT tmpDelayRSer = h_ps_d->specificTo.mpeg.aDelayRBufIndexSer[m];
843
844 /* get delayed values from according buffer : m(0)=3; m(1)=4; m(2)=5; */
845 rTmp0 = pAaaRealDelayRBufferSerQmf[tmpDelayRSer];
846 iTmp0 = pAaaImagDelayRBufferSerQmf[tmpDelayRSer];
847
848 /* delay by fraction */
849 cplxMultDiv2(&rTmp, &iTmp, rTmp0, iTmp0, aaFractDelayPhaseFactorSerReQmf[sb][m], aaFractDelayPhaseFactorSerImQmf[sb][m]);
850
851 rTmp = (rTmp - fMultDiv2(aAllpassLinkDecaySer[m], resR))<<1;
852 iTmp = (iTmp - fMultDiv2(aAllpassLinkDecaySer[m], resI))<<1;
853
854 resR = fMult(decayScaleFactor, rTmp);
855 resI = fMult(decayScaleFactor, iTmp);
856
857 pAaaRealDelayRBufferSerQmf[tmpDelayRSer] = rR0 + fMult(aAllpassLinkDecaySer[m], resR);
858 pAaaImagDelayRBufferSerQmf[tmpDelayRSer] = iR0 + fMult(aAllpassLinkDecaySer[m], resI);
859
860 rR0 = rTmp;
861 iR0 = iTmp;
862
863 pAaaRealDelayRBufferSerQmf += aAllpassLinkDelaySer[m];
864 pAaaImagDelayRBufferSerQmf += aAllpassLinkDelaySer[m];
865
866 } /* m */
867
868 /* duck if a past transient is found */
869 aaRightReal[sb] = fMult(transRatio, rR0);
870 aaRightImag[sb] = fMult(transRatio, iR0);
871
872 } /* sb */
873 } /* gr */
874
875 /************************/
876 /* ICC groups : 20, 21 */
877 /************************/
878
879
880 /* gr = ICC groups */
881 for (gr=DELAY_GROUP_OFFSET; gr < NO_IID_GROUPS; gr++) {
882
883 INT sbStart = groupBorders20[gr];
884 INT sbStop = groupBorders20[gr+1];
885
886 UCHAR *pDelayBufIdx = &h_ps_d->specificTo.mpeg.aDelayBufIndexDelayQmf[sbStart-FIRST_DELAY_SB];
887
888 transRatio = aaTransRatioSlot[bins2groupMap20[gr]];
889
890 /* sb = subQMF/QMF subband */
891 for (sb = sbStart; sb < sbStop; sb++) {
892
893 /* Update delay buffers */
894 rR0 = h_ps_d->specificTo.mpeg.pAaRealDelayBufferQmf[*pDelayBufIdx][sb-FIRST_DELAY_SB];
895 iR0 = h_ps_d->specificTo.mpeg.pAaImagDelayBufferQmf[*pDelayBufIdx][sb-FIRST_DELAY_SB];
896
897 h_ps_d->specificTo.mpeg.pAaRealDelayBufferQmf[*pDelayBufIdx][sb-FIRST_DELAY_SB] = aaLeftReal[sb];
898 h_ps_d->specificTo.mpeg.pAaImagDelayBufferQmf[*pDelayBufIdx][sb-FIRST_DELAY_SB] = aaLeftImag[sb];
899
900 /* duck if a past transient is found */
901 aaRightReal[sb] = fMult(transRatio, rR0);
902 aaRightImag[sb] = fMult(transRatio, iR0);
903
904 if (++(*pDelayBufIdx) >= delayIndexQmf[sb]) {
905 *pDelayBufIdx = 0;
906 }
907 pDelayBufIdx++;
908
909 } /* sb */
910 } /* gr */
911
912
913 /* Update delay buffer index */
914 if (++h_ps_d->specificTo.mpeg.delayBufIndex >= NO_SAMPLE_DELAY_ALLPASS)
915 h_ps_d->specificTo.mpeg.delayBufIndex = 0;
916
917 for (m=0; m<NO_SERIAL_ALLPASS_LINKS ; m++) {
918 if (++h_ps_d->specificTo.mpeg.aDelayRBufIndexSer[m] >= aAllpassLinkDelaySer[m])
919 h_ps_d->specificTo.mpeg.aDelayRBufIndexSer[m] = 0;
920 }
921
922
923 scaleValues( &rIntBufferLeft[NO_QMF_BANDS_HYBRID20], NO_QMF_CHANNELS-NO_QMF_BANDS_HYBRID20, -SCAL_HEADROOM );
924 scaleValues( &iIntBufferLeft[NO_QMF_BANDS_HYBRID20], NO_QMF_CHANNELS-NO_QMF_BANDS_HYBRID20, -SCAL_HEADROOM );
925 scaleValues( &rIntBufferRight[NO_QMF_BANDS_HYBRID20], NO_QMF_CHANNELS-NO_QMF_BANDS_HYBRID20, -SCAL_HEADROOM );
926 scaleValues( &iIntBufferRight[NO_QMF_BANDS_HYBRID20], NO_QMF_CHANNELS-NO_QMF_BANDS_HYBRID20, -SCAL_HEADROOM );
927
928 /* free memory on scratch */
929 C_ALLOC_SCRATCH_END(aaTransRatioSlot, FIXP_DBL, NO_MID_RES_BINS);
930 C_ALLOC_SCRATCH_END(aaPowerSlot, FIXP_DBL, NO_MID_RES_BINS);
931 }
932
933
initSlotBasedRotation(HANDLE_PS_DEC h_ps_d,int env,int usb)934 void initSlotBasedRotation( HANDLE_PS_DEC h_ps_d, /*!< pointer to the module state */
935 int env,
936 int usb
937 ) {
938
939 INT group = 0;
940 INT bin = 0;
941 INT noIidSteps;
942
943 /* const UCHAR *pQuantizedIIDs;*/
944
945 FIXP_SGL invL;
946 FIXP_DBL ScaleL, ScaleR;
947 FIXP_DBL Alpha, Beta;
948 FIXP_DBL h11r, h12r, h21r, h22r;
949
950 const FIXP_DBL *PScaleFactors;
951
952 /* Overwrite old values in delay buffers when upper subband is higher than in last frame */
953 if (env == 0) {
954
955 if ((usb > h_ps_d->specificTo.mpeg.lastUsb) && h_ps_d->specificTo.mpeg.lastUsb) {
956
957 INT i,k,length;
958
959 for (i=h_ps_d->specificTo.mpeg.lastUsb ; i < FIRST_DELAY_SB; i++) {
960 FDKmemclear(h_ps_d->specificTo.mpeg.aaaRealDelayRBufferSerQmf[i], NO_DELAY_LENGTH_VECTORS*sizeof(FIXP_DBL));
961 FDKmemclear(h_ps_d->specificTo.mpeg.aaaImagDelayRBufferSerQmf[i], NO_DELAY_LENGTH_VECTORS*sizeof(FIXP_DBL));
962 }
963
964 for (k=0 ; k<NO_SAMPLE_DELAY_ALLPASS; k++) {
965 FDKmemclear(h_ps_d->specificTo.mpeg.pAaRealDelayBufferQmf[k], FIRST_DELAY_SB*sizeof(FIXP_DBL));
966 }
967 length = (usb-FIRST_DELAY_SB)*sizeof(FIXP_DBL);
968 if(length>0) {
969 FDKmemclear(h_ps_d->specificTo.mpeg.pAaRealDelayBufferQmf[0], length);
970 FDKmemclear(h_ps_d->specificTo.mpeg.pAaImagDelayBufferQmf[0], length);
971 }
972 length = (fixMin(NO_DELAY_BUFFER_BANDS,(INT)usb)-FIRST_DELAY_SB)*sizeof(FIXP_DBL);
973 if(length>0) {
974 for (k=1 ; k < h_ps_d->specificTo.mpeg.noSampleDelay; k++) {
975 FDKmemclear(h_ps_d->specificTo.mpeg.pAaRealDelayBufferQmf[k], length);
976 FDKmemclear(h_ps_d->specificTo.mpeg.pAaImagDelayBufferQmf[k], length);
977 }
978 }
979 }
980 h_ps_d->specificTo.mpeg.lastUsb = usb;
981 } /* env == 0 */
982
983 if (h_ps_d->bsData[h_ps_d->processSlot].mpeg.bFineIidQ)
984 {
985 PScaleFactors = ScaleFactorsFine; /* values are shiftet right by one */
986 noIidSteps = NO_IID_STEPS_FINE;
987 /*pQuantizedIIDs = quantizedIIDsFine;*/
988 }
989
990 else
991 {
992 PScaleFactors = ScaleFactors; /* values are shiftet right by one */
993 noIidSteps = NO_IID_STEPS;
994 /*pQuantizedIIDs = quantizedIIDs;*/
995 }
996
997
998 /* dequantize and decode */
999 for ( group = 0; group < NO_IID_GROUPS; group++ ) {
1000
1001 bin = bins2groupMap20[group];
1002
1003 /*!
1004 <h3> type 'A' rotation </h3>
1005 mixing procedure R_a, used in baseline version<br>
1006
1007 Scale-factor vectors c1 and c2 are precalculated in initPsTables () and stored in
1008 scaleFactors[] and scaleFactorsFine[] = pScaleFactors [].
1009 From the linearized IID parameters (intensity differences), two scale factors are
1010 calculated. They are used to obtain the coefficients h11... h22.
1011 */
1012
1013 /* ScaleR and ScaleL are scaled by 1 shift right */
1014
1015 ScaleR = PScaleFactors[noIidSteps + h_ps_d->specificTo.mpeg.coef.aaIidIndexMapped[env][bin]];
1016 ScaleL = PScaleFactors[noIidSteps - h_ps_d->specificTo.mpeg.coef.aaIidIndexMapped[env][bin]];
1017
1018 Beta = fMult (fMult( Alphas[h_ps_d->specificTo.mpeg.coef.aaIccIndexMapped[env][bin]], ( ScaleR - ScaleL )), FIXP_SQRT05);
1019 Alpha = Alphas[h_ps_d->specificTo.mpeg.coef.aaIccIndexMapped[env][bin]]>>1;
1020
1021 /* Alpha and Beta are now both scaled by 2 shifts right */
1022
1023 /* calculate the coefficients h11... h22 from scale-factors and ICC parameters */
1024
1025 /* h values are scaled by 1 shift right */
1026 {
1027 FIXP_DBL trigData[4];
1028
1029 inline_fixp_cos_sin(Beta + Alpha, Beta - Alpha, 2, trigData);
1030 h11r = fMult( ScaleL, trigData[0]);
1031 h12r = fMult( ScaleR, trigData[2]);
1032 h21r = fMult( ScaleL, trigData[1]);
1033 h22r = fMult( ScaleR, trigData[3]);
1034 }
1035 /*****************************************************************************************/
1036 /* Interpolation of the matrices H11... H22: */
1037 /* */
1038 /* H11(k,n) = H11(k,n[e]) + (n-n[e]) * (H11(k,n[e+1] - H11(k,n[e])) / (n[e+1] - n[e]) */
1039 /* ... */
1040 /*****************************************************************************************/
1041
1042 /* invL = 1/(length of envelope) */
1043 invL = FX_DBL2FX_SGL(GetInvInt(h_ps_d->bsData[h_ps_d->processSlot].mpeg.aEnvStartStop[env + 1] - h_ps_d->bsData[h_ps_d->processSlot].mpeg.aEnvStartStop[env]));
1044
1045 h_ps_d->specificTo.mpeg.coef.H11r[group] = h_ps_d->specificTo.mpeg.h11rPrev[group];
1046 h_ps_d->specificTo.mpeg.coef.H12r[group] = h_ps_d->specificTo.mpeg.h12rPrev[group];
1047 h_ps_d->specificTo.mpeg.coef.H21r[group] = h_ps_d->specificTo.mpeg.h21rPrev[group];
1048 h_ps_d->specificTo.mpeg.coef.H22r[group] = h_ps_d->specificTo.mpeg.h22rPrev[group];
1049
1050 h_ps_d->specificTo.mpeg.coef.DeltaH11r[group] = fMult ( h11r - h_ps_d->specificTo.mpeg.coef.H11r[group], invL );
1051 h_ps_d->specificTo.mpeg.coef.DeltaH12r[group] = fMult ( h12r - h_ps_d->specificTo.mpeg.coef.H12r[group], invL );
1052 h_ps_d->specificTo.mpeg.coef.DeltaH21r[group] = fMult ( h21r - h_ps_d->specificTo.mpeg.coef.H21r[group], invL );
1053 h_ps_d->specificTo.mpeg.coef.DeltaH22r[group] = fMult ( h22r - h_ps_d->specificTo.mpeg.coef.H22r[group], invL );
1054
1055 /* update prev coefficients for interpolation in next envelope */
1056
1057 h_ps_d->specificTo.mpeg.h11rPrev[group] = h11r;
1058 h_ps_d->specificTo.mpeg.h12rPrev[group] = h12r;
1059 h_ps_d->specificTo.mpeg.h21rPrev[group] = h21r;
1060 h_ps_d->specificTo.mpeg.h22rPrev[group] = h22r;
1061
1062 } /* group loop */
1063 }
1064
1065
applySlotBasedRotation(HANDLE_PS_DEC h_ps_d,FIXP_DBL * mHybridRealLeft,FIXP_DBL * mHybridImagLeft,FIXP_DBL * QmfLeftReal,FIXP_DBL * QmfLeftImag,FIXP_DBL * mHybridRealRight,FIXP_DBL * mHybridImagRight,FIXP_DBL * QmfRightReal,FIXP_DBL * QmfRightImag)1066 static void applySlotBasedRotation( HANDLE_PS_DEC h_ps_d, /*!< pointer to the module state */
1067
1068 FIXP_DBL *mHybridRealLeft, /*!< hybrid values real left */
1069 FIXP_DBL *mHybridImagLeft, /*!< hybrid values imag left */
1070
1071 FIXP_DBL *QmfLeftReal, /*!< real bands left qmf channel */
1072 FIXP_DBL *QmfLeftImag, /*!< imag bands left qmf channel */
1073
1074 FIXP_DBL *mHybridRealRight, /*!< hybrid values real right */
1075 FIXP_DBL *mHybridImagRight, /*!< hybrid values imag right */
1076
1077 FIXP_DBL *QmfRightReal, /*!< real bands right qmf channel */
1078 FIXP_DBL *QmfRightImag /*!< imag bands right qmf channel */
1079 )
1080 {
1081 INT group;
1082 INT subband;
1083
1084 FIXP_DBL *RESTRICT HybrLeftReal;
1085 FIXP_DBL *RESTRICT HybrLeftImag;
1086 FIXP_DBL *RESTRICT HybrRightReal;
1087 FIXP_DBL *RESTRICT HybrRightImag;
1088
1089 FIXP_DBL tmpLeft, tmpRight;
1090
1091
1092 /**********************************************************************************************/
1093 /*!
1094 <h2> Mapping </h2>
1095
1096 The number of stereo bands that is actually used depends on the number of availble
1097 parameters for IID and ICC:
1098 <pre>
1099 nr. of IID para.| nr. of ICC para. | nr. of Stereo bands
1100 ----------------|------------------|-------------------
1101 10,20 | 10,20 | 20
1102 10,20 | 34 | 34
1103 34 | 10,20 | 34
1104 34 | 34 | 34
1105 </pre>
1106 In the case the number of parameters for IIS and ICC differs from the number of stereo
1107 bands, a mapping from the lower number to the higher number of parameters is applied.
1108 Index mapping of IID and ICC parameters is already done in psbitdec.cpp. Further mapping is
1109 not needed here in baseline version.
1110 **********************************************************************************************/
1111
1112 /************************************************************************************************/
1113 /*!
1114 <h2> Mixing </h2>
1115
1116 To generate the QMF subband signals for the subband samples n = n[e]+1 ,,, n_[e+1] the
1117 parameters at position n[e] and n[e+1] are required as well as the subband domain signals
1118 s_k(n) and d_k(n) for n = n[e]+1... n_[e+1]. n[e] represents the start position for
1119 envelope e. The border positions n[e] are handled in DecodePS().
1120
1121 The stereo sub subband signals are constructed as:
1122 <pre>
1123 l_k(n) = H11(k,n) s_k(n) + H21(k,n) d_k(n)
1124 r_k(n) = H21(k,n) s_k(n) + H22(k,n) d_k(n)
1125 </pre>
1126 In order to obtain the matrices H11(k,n)... H22 (k,n), the vectors h11(b)... h22(b) need to
1127 be calculated first (b: parameter index). Depending on ICC mode either mixing procedure R_a
1128 or R_b is used for that. For both procedures, the parameters for parameter position n[e+1]
1129 is used.
1130 ************************************************************************************************/
1131
1132
1133 /************************************************************************************************/
1134 /*!
1135 <h2>Phase parameters </h2>
1136 With disabled phase parameters (which is the case in baseline version), the H-matrices are
1137 just calculated by:
1138
1139 <pre>
1140 H11(k,n[e+1] = h11(b(k))
1141 (...)
1142 b(k): parameter index according to mapping table
1143 </pre>
1144
1145 <h2>Processing of the samples in the sub subbands </h2>
1146 this loop includes the interpolation of the coefficients Hxx
1147 ************************************************************************************************/
1148
1149
1150 /* loop thru all groups ... */
1151 HybrLeftReal = mHybridRealLeft;
1152 HybrLeftImag = mHybridImagLeft;
1153 HybrRightReal = mHybridRealRight;
1154 HybrRightImag = mHybridImagRight;
1155
1156 /******************************************************/
1157 /* construct stereo sub subband signals according to: */
1158 /* */
1159 /* l_k(n) = H11(k,n) s_k(n) + H21(k,n) d_k(n) */
1160 /* r_k(n) = H12(k,n) s_k(n) + H22(k,n) d_k(n) */
1161 /******************************************************/
1162 for ( group = 0; group < SUBQMF_GROUPS; group++ ) {
1163
1164 h_ps_d->specificTo.mpeg.coef.H11r[group] += h_ps_d->specificTo.mpeg.coef.DeltaH11r[group];
1165 h_ps_d->specificTo.mpeg.coef.H12r[group] += h_ps_d->specificTo.mpeg.coef.DeltaH12r[group];
1166 h_ps_d->specificTo.mpeg.coef.H21r[group] += h_ps_d->specificTo.mpeg.coef.DeltaH21r[group];
1167 h_ps_d->specificTo.mpeg.coef.H22r[group] += h_ps_d->specificTo.mpeg.coef.DeltaH22r[group];
1168
1169 subband = groupBorders20[group];
1170
1171 tmpLeft = fMultAddDiv2( fMultDiv2(h_ps_d->specificTo.mpeg.coef.H11r[group], HybrLeftReal[subband]), h_ps_d->specificTo.mpeg.coef.H21r[group], HybrRightReal[subband]);
1172 tmpRight = fMultAddDiv2( fMultDiv2(h_ps_d->specificTo.mpeg.coef.H12r[group], HybrLeftReal[subband]), h_ps_d->specificTo.mpeg.coef.H22r[group], HybrRightReal[subband]);
1173 HybrLeftReal [subband] = tmpLeft<<1;
1174 HybrRightReal[subband] = tmpRight<<1;
1175
1176 tmpLeft = fMultAdd( fMultDiv2(h_ps_d->specificTo.mpeg.coef.H11r[group], HybrLeftImag[subband]), h_ps_d->specificTo.mpeg.coef.H21r[group], HybrRightImag[subband]);
1177 tmpRight = fMultAdd( fMultDiv2(h_ps_d->specificTo.mpeg.coef.H12r[group], HybrLeftImag[subband]), h_ps_d->specificTo.mpeg.coef.H22r[group], HybrRightImag[subband]);
1178 HybrLeftImag [subband] = tmpLeft;
1179 HybrRightImag[subband] = tmpRight;
1180 }
1181
1182 /* continue in the qmf buffers */
1183 HybrLeftReal = QmfLeftReal;
1184 HybrLeftImag = QmfLeftImag;
1185 HybrRightReal = QmfRightReal;
1186 HybrRightImag = QmfRightImag;
1187
1188 for (; group < NO_IID_GROUPS; group++ ) {
1189
1190 h_ps_d->specificTo.mpeg.coef.H11r[group] += h_ps_d->specificTo.mpeg.coef.DeltaH11r[group];
1191 h_ps_d->specificTo.mpeg.coef.H12r[group] += h_ps_d->specificTo.mpeg.coef.DeltaH12r[group];
1192 h_ps_d->specificTo.mpeg.coef.H21r[group] += h_ps_d->specificTo.mpeg.coef.DeltaH21r[group];
1193 h_ps_d->specificTo.mpeg.coef.H22r[group] += h_ps_d->specificTo.mpeg.coef.DeltaH22r[group];
1194
1195 for ( subband = groupBorders20[group]; subband < groupBorders20[group + 1]; subband++ )
1196 {
1197 tmpLeft = fMultAdd( fMultDiv2(h_ps_d->specificTo.mpeg.coef.H11r[group], HybrLeftReal[subband]), h_ps_d->specificTo.mpeg.coef.H21r[group], HybrRightReal[subband]);
1198 tmpRight = fMultAdd( fMultDiv2(h_ps_d->specificTo.mpeg.coef.H12r[group], HybrLeftReal[subband]), h_ps_d->specificTo.mpeg.coef.H22r[group], HybrRightReal[subband]);
1199 HybrLeftReal [subband] = tmpLeft;
1200 HybrRightReal[subband] = tmpRight;
1201
1202 tmpLeft = fMultAdd( fMultDiv2(h_ps_d->specificTo.mpeg.coef.H11r[group], HybrLeftImag[subband]), h_ps_d->specificTo.mpeg.coef.H21r[group], HybrRightImag[subband]);
1203 tmpRight = fMultAdd( fMultDiv2(h_ps_d->specificTo.mpeg.coef.H12r[group], HybrLeftImag[subband]), h_ps_d->specificTo.mpeg.coef.H22r[group], HybrRightImag[subband]);
1204 HybrLeftImag [subband] = tmpLeft;
1205 HybrRightImag[subband] = tmpRight;
1206
1207 } /* subband */
1208 }
1209 }
1210
1211
1212 /***************************************************************************/
1213 /*!
1214 \brief Applies IID, ICC, IPD and OPD parameters to the current frame.
1215
1216 \return none
1217
1218 ****************************************************************************/
1219 void
ApplyPsSlot(HANDLE_PS_DEC h_ps_d,FIXP_DBL ** rIntBufferLeft,FIXP_DBL ** iIntBufferLeft,FIXP_DBL * rIntBufferRight,FIXP_DBL * iIntBufferRight)1220 ApplyPsSlot( HANDLE_PS_DEC h_ps_d, /*!< handle PS_DEC*/
1221 FIXP_DBL **rIntBufferLeft, /*!< real bands left qmf channel (38x64) */
1222 FIXP_DBL **iIntBufferLeft, /*!< imag bands left qmf channel (38x64) */
1223 FIXP_DBL *rIntBufferRight, /*!< real bands right qmf channel (38x64) */
1224 FIXP_DBL *iIntBufferRight /*!< imag bands right qmf channel (38x64) */
1225 )
1226 {
1227
1228 /*!
1229 The 64-band QMF representation of the monaural signal generated by the SBR tool
1230 is used as input of the PS tool. After the PS processing, the outputs of the left
1231 and right hybrid synthesis filterbanks are used to generate the stereo output
1232 signal.
1233
1234 <pre>
1235
1236 ------------- ---------- -------------
1237 | Hybrid | M_n[k,m] | | L_n[k,m] | Hybrid | l[n]
1238 m[n] --->| analysis |--------->| |--------->| synthesis |----->
1239 | filter bank | | | | filter bank |
1240 ------------- | Stereo | -------------
1241 | | recon- |
1242 | | stuction |
1243 \|/ | |
1244 ------------- | |
1245 | De- | D_n[k,m] | |
1246 | correlation |--------->| |
1247 ------------- | | -------------
1248 | | R_n[k,m] | Hybrid | r[n]
1249 | |--------->| synthesis |----->
1250 IID, ICC ------------------------>| | | filter bank |
1251 (IPD, OPD) ---------- -------------
1252
1253 m[n]: QMF represantation of the mono input
1254 M_n[k,m]: (sub-)sub-band domain signals of the mono input
1255 D_n[k,m]: decorrelated (sub-)sub-band domain signals
1256 L_n[k,m]: (sub-)sub-band domain signals of the left output
1257 R_n[k,m]: (sub-)sub-band domain signals of the right output
1258 l[n],r[n]: left/right output signals
1259
1260 </pre>
1261 */
1262
1263 /* get temporary hybrid qmf values of one timeslot */
1264 C_ALLOC_SCRATCH_START(hybridRealLeft, FIXP_DBL, NO_SUB_QMF_CHANNELS);
1265 C_ALLOC_SCRATCH_START(hybridImagLeft, FIXP_DBL, NO_SUB_QMF_CHANNELS);
1266 C_ALLOC_SCRATCH_START(hybridRealRight, FIXP_DBL, NO_SUB_QMF_CHANNELS);
1267 C_ALLOC_SCRATCH_START(hybridImagRight, FIXP_DBL, NO_SUB_QMF_CHANNELS);
1268
1269 SCHAR sf_IntBuffer = h_ps_d->sf_IntBuffer;
1270
1271 /* clear workbuffer */
1272 FDKmemclear(hybridRealLeft, NO_SUB_QMF_CHANNELS*sizeof(FIXP_DBL));
1273 FDKmemclear(hybridImagLeft, NO_SUB_QMF_CHANNELS*sizeof(FIXP_DBL));
1274 FDKmemclear(hybridRealRight, NO_SUB_QMF_CHANNELS*sizeof(FIXP_DBL));
1275 FDKmemclear(hybridImagRight, NO_SUB_QMF_CHANNELS*sizeof(FIXP_DBL));
1276
1277
1278 /*!
1279 Hybrid analysis filterbank:
1280 The lower 3 (5) of the 64 QMF subbands are further split to provide better frequency resolution.
1281 for PS processing.
1282 For the 10 and 20 stereo bands configuration, the QMF band H_0(w) is split
1283 up into 8 (sub-) sub-bands and the QMF bands H_1(w) and H_2(w) are spit into 2 (sub-)
1284 4th. (See figures 8.20 and 8.22 of ISO/IEC 14496-3:2001/FDAM 2:2004(E) )
1285 */
1286
1287
1288 if (h_ps_d->procFrameBased == 1) /* If we have switched from frame to slot based processing */
1289 { /* fill hybrid delay buffer. */
1290 h_ps_d->procFrameBased = 0;
1291
1292 fillHybridDelayLine( rIntBufferLeft,
1293 iIntBufferLeft,
1294 hybridRealLeft,
1295 hybridImagLeft,
1296 hybridRealRight,
1297 hybridImagRight,
1298 &h_ps_d->specificTo.mpeg.hybrid );
1299 }
1300
1301 slotBasedHybridAnalysis ( rIntBufferLeft[HYBRID_FILTER_DELAY], /* qmf filterbank values */
1302 iIntBufferLeft[HYBRID_FILTER_DELAY], /* qmf filterbank values */
1303 hybridRealLeft, /* hybrid filterbank values */
1304 hybridImagLeft, /* hybrid filterbank values */
1305 &h_ps_d->specificTo.mpeg.hybrid); /* hybrid filterbank handle */
1306
1307
1308 SCHAR hybridScal = h_ps_d->specificTo.mpeg.hybrid.sf_mQmfBuffer;
1309
1310
1311 /*!
1312 Decorrelation:
1313 By means of all-pass filtering and delaying, the (sub-)sub-band samples s_k(n) are
1314 converted into de-correlated (sub-)sub-band samples d_k(n).
1315 - k: frequency in hybrid spectrum
1316 - n: time index
1317 */
1318
1319 deCorrelateSlotBased( h_ps_d, /* parametric stereo decoder handle */
1320 hybridRealLeft, /* left hybrid time slot */
1321 hybridImagLeft,
1322 hybridScal, /* scale factor of left hybrid time slot */
1323 rIntBufferLeft[0], /* left qmf time slot */
1324 iIntBufferLeft[0],
1325 sf_IntBuffer, /* scale factor of left and right qmf time slot */
1326 hybridRealRight, /* right hybrid time slot */
1327 hybridImagRight,
1328 rIntBufferRight, /* right qmf time slot */
1329 iIntBufferRight );
1330
1331
1332
1333 /*!
1334 Stereo Processing:
1335 The sets of (sub-)sub-band samples s_k(n) and d_k(n) are processed according to
1336 the stereo cues which are defined per stereo band.
1337 */
1338
1339
1340 applySlotBasedRotation( h_ps_d, /* parametric stereo decoder handle */
1341 hybridRealLeft, /* left hybrid time slot */
1342 hybridImagLeft,
1343 rIntBufferLeft[0], /* left qmf time slot */
1344 iIntBufferLeft[0],
1345 hybridRealRight, /* right hybrid time slot */
1346 hybridImagRight,
1347 rIntBufferRight, /* right qmf time slot */
1348 iIntBufferRight );
1349
1350
1351
1352
1353 /*!
1354 Hybrid synthesis filterbank:
1355 The stereo processed hybrid subband signals l_k(n) and r_k(n) are fed into the hybrid synthesis
1356 filterbanks which are identical to the 64 complex synthesis filterbank of the SBR tool. The
1357 input to the filterbank are slots of 64 QMF samples. For each slot the filterbank outputs one
1358 block of 64 samples of one reconstructed stereo channel. The hybrid synthesis filterbank is
1359 computed seperatly for the left and right channel.
1360 */
1361
1362
1363 /* left channel */
1364 slotBasedHybridSynthesis ( hybridRealLeft, /* one timeslot of hybrid filterbank values */
1365 hybridImagLeft,
1366 rIntBufferLeft[0], /* one timeslot of qmf filterbank values */
1367 iIntBufferLeft[0],
1368 &h_ps_d->specificTo.mpeg.hybrid ); /* hybrid filterbank handle */
1369
1370 /* right channel */
1371 slotBasedHybridSynthesis ( hybridRealRight, /* one timeslot of hybrid filterbank values */
1372 hybridImagRight,
1373 rIntBufferRight, /* one timeslot of qmf filterbank values */
1374 iIntBufferRight,
1375 &h_ps_d->specificTo.mpeg.hybrid ); /* hybrid filterbank handle */
1376
1377
1378
1379
1380
1381
1382
1383 /* free temporary hybrid qmf values of one timeslot */
1384 C_ALLOC_SCRATCH_END(hybridImagRight, FIXP_DBL, NO_SUB_QMF_CHANNELS);
1385 C_ALLOC_SCRATCH_END(hybridRealRight, FIXP_DBL, NO_SUB_QMF_CHANNELS);
1386 C_ALLOC_SCRATCH_END(hybridImagLeft, FIXP_DBL, NO_SUB_QMF_CHANNELS);
1387 C_ALLOC_SCRATCH_END(hybridRealLeft, FIXP_DBL, NO_SUB_QMF_CHANNELS);
1388
1389 }/* END ApplyPsSlot */
1390
1391
1392 /***************************************************************************/
1393 /*!
1394
1395 \brief assigns timeslots to an array
1396
1397 \return
1398
1399 ****************************************************************************/
1400
assignTimeSlotsPS(FIXP_DBL * bufAdr,FIXP_DBL ** bufPtr,const int numSlots,const int numChan)1401 static void assignTimeSlotsPS (FIXP_DBL *bufAdr,
1402 FIXP_DBL **bufPtr,
1403 const int numSlots,
1404 const int numChan)
1405 {
1406 FIXP_DBL *ptr;
1407 int slot;
1408 ptr = bufAdr;
1409 for(slot=0; slot < numSlots; slot++) {
1410 bufPtr [slot] = ptr;
1411 ptr += numChan;
1412 }
1413 }
1414
1415