Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / frameworks / base / 0e59729b104e48c7d935026f565c4b45f1f37d12 / . / media / libstagefright / codecs / aacdec / sbr_dec.cpp
blob: 8fcc3ced21a5b05e8a4bb2fc1786047df8ae9b64 [file] [log] [blame]
Andreas Huberdacaa732009-12-07 09:56:32 -0800[diff] [blame]1/* ------------------------------------------------------------------
2 * Copyright (C) 1998-2009 PacketVideo
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
13 * express or implied.
14 * See the License for the specific language governing permissions
15 * and limitations under the License.
16 * -------------------------------------------------------------------
17 */
18/*
19
20 Filename: sbr_dec.c
21
22------------------------------------------------------------------------------
23 REVISION HISTORY
24
25
26 Who: Date: MM/DD/YYYY
27 Description:
28
29------------------------------------------------------------------------------
30 INPUT AND OUTPUT DEFINITIONS
31
32
33
34------------------------------------------------------------------------------
35 FUNCTION DESCRIPTION
36
37 sbr decoder core function
38
39------------------------------------------------------------------------------
40 REQUIREMENTS
41
42
43------------------------------------------------------------------------------
44 REFERENCES
45
46SC 29 Software Copyright Licencing Disclaimer:
47
48This software module was originally developed by
49 Coding Technologies
50
51and edited by
52 -
53
54in the course of development of the ISO/IEC 13818-7 and ISO/IEC 14496-3
55standards for reference purposes and its performance may not have been
56optimized. This software module is an implementation of one or more tools as
57specified by the ISO/IEC 13818-7 and ISO/IEC 14496-3 standards.
58ISO/IEC gives users free license to this software module or modifications
59thereof for use in products claiming conformance to audiovisual and
60image-coding related ITU Recommendations and/or ISO/IEC International
61Standards. ISO/IEC gives users the same free license to this software module or
62modifications thereof for research purposes and further ISO/IEC standardisation.
63Those intending to use this software module in products are advised that its
64use may infringe existing patents. ISO/IEC have no liability for use of this
65software module or modifications thereof. Copyright is not released for
66products that do not conform to audiovisual and image-coding related ITU
67Recommendations and/or ISO/IEC International Standards.
68The original developer retains full right to modify and use the code for its
69own purpose, assign or donate the code to a third party and to inhibit third
70parties from using the code for products that do not conform to audiovisual and
71image-coding related ITU Recommendations and/or ISO/IEC International Standards.
72This copyright notice must be included in all copies or derivative works.
73Copyright (c) ISO/IEC 2002.
74
75------------------------------------------------------------------------------
76 PSEUDO-CODE
77
78------------------------------------------------------------------------------
79*/
80
81
82/*----------------------------------------------------------------------------
83; INCLUDES
84----------------------------------------------------------------------------*/
85#ifdef AAC_PLUS
86
87
88#include "s_sbr_frame_data.h"
89#include "calc_sbr_synfilterbank.h"
90#include "calc_sbr_anafilterbank.h"
91#include "calc_sbr_envelope.h"
92#include "sbr_generate_high_freq.h"
93#include "sbr_dec.h"
94#include "decode_noise_floorlevels.h"
95#include "aac_mem_funcs.h"
96#include "fxp_mul32.h"
97
98/*----------------------------------------------------------------------------
99; MACROS
100; Define module specific macros here
101----------------------------------------------------------------------------*/
102
103
104/*----------------------------------------------------------------------------
105; DEFINES
106; Include all pre-processor statements here. Include conditional
107; compile variables also.
108----------------------------------------------------------------------------*/
109
110/*----------------------------------------------------------------------------
111; LOCAL FUNCTION DEFINITIONS
112; Function Prototype declaration
113----------------------------------------------------------------------------*/
114/*----------------------------------------------------------------------------
115; LOCAL STORE/BUFFER/POINTER DEFINITIONS
116; Variable declaration - defined here and used outside this module
117----------------------------------------------------------------------------*/
118
119
120/*----------------------------------------------------------------------------
121; EXTERNAL FUNCTION REFERENCES
122; Declare functions defined elsewhere and referenced in this module
123----------------------------------------------------------------------------*/
124#include "pv_audio_type_defs.h"
125
126#ifdef PARAMETRICSTEREO
127
128#include "ps_applied.h"
129#include "ps_init_stereo_mixing.h"
130
131#endif
132
133/*----------------------------------------------------------------------------
134; EXTERNAL GLOBAL STORE/BUFFER/POINTER REFERENCES
135; Declare variables used in this module but defined elsewhere
136----------------------------------------------------------------------------*/
137
138/*----------------------------------------------------------------------------
139; FUNCTION CODE
140----------------------------------------------------------------------------*/
141
142void sbr_dec(Int16 *inPcmData,
143 Int16 *ftimeOutPtr,
144 SBR_FRAME_DATA * hFrameData,
145 int32_t applyProcessing,
146 SBR_DEC *sbrDec,
147#ifdef HQ_SBR
148#ifdef PARAMETRICSTEREO
149 Int16 * ftimeOutPtrPS,
150 HANDLE_PS_DEC hParametricStereoDec,
151#endif
152#endif
153 tDec_Int_File *pVars)
154{
155 int32_t i;
156 int32_t j;
157 int32_t m;
158
159 int32_t *frameInfo = hFrameData->frameInfo;
160 Int num_qmf_bands;
161
162#ifdef HQ_SBR
163#ifdef PARAMETRICSTEREO
164
165 int32_t env;
166
167 int32_t *qmf_PS_generated_Real;
168 int32_t *qmf_PS_generated_Imag;
169
170 int32_t *Sr_x;
171 int32_t *Si_x;
172
173
174#endif
175#endif
176
177 int32_t(*scratch_mem)[64];
178 Int16 *circular_buffer_s;
179
180 int32_t k;
181 int32_t *Sr;
182 int32_t *Si;
183 int32_t *ptr_tmp1;
184 int32_t *ptr_tmp2;
185 scratch_mem = pVars->scratch.scratch_mem;
186
187
188 if (applyProcessing)
189 {
190 num_qmf_bands = sbrDec->lowSubband;
191 }
192 else
193 {
194 num_qmf_bands = 32; /* becomes a resampler by 2 */
195 }
196
197 /* -------------------------------------------------- */
198 /*
199 * Re-Load Buffers
200 */
201 pv_memmove(&hFrameData->sbrQmfBufferReal[0],
202 &hFrameData->HistsbrQmfBufferReal[0],
203 6*SBR_NUM_BANDS*sizeof(*hFrameData->sbrQmfBufferReal));
204#ifdef HQ_SBR
205
206
207 if (sbrDec->LC_aacP_DecoderFlag == OFF)
208 {
209 pv_memmove(&hFrameData->sbrQmfBufferImag[0],
210 &hFrameData->HistsbrQmfBufferImag[0],
211 6*SBR_NUM_BANDS*sizeof(*hFrameData->sbrQmfBufferImag));
212 }
213#endif
214 /* -------------------------------------------------- */
215
216
217 /*
218 * low band codec signal subband filtering
219 */
220
221 for (i = 0; i < 32; i++)
222 {
223
224 if (sbrDec->LC_aacP_DecoderFlag == ON)
225 {
226
227 calc_sbr_anafilterbank_LC(hFrameData->codecQmfBufferReal[sbrDec->bufWriteOffs + i],
228 &inPcmData[319] + (i << 5),
229 scratch_mem,
230 num_qmf_bands);
231
232 }
233#ifdef HQ_SBR
234 else
235 {
236
237 calc_sbr_anafilterbank(hFrameData->codecQmfBufferReal[sbrDec->bufWriteOffs + i],
238 hFrameData->codecQmfBufferImag[sbrDec->bufWriteOffs + i],
239 &inPcmData[319] + (i << 5),
240 scratch_mem,
241 num_qmf_bands);
242 }
243#endif
244
245 }
246
247 if (pVars->ltp_buffer_state)
248 {
249 pv_memcpy(&inPcmData[-1024-288], &inPcmData[1024], 288*sizeof(*inPcmData));
250 }
251 else
252 {
253 pv_memcpy(&inPcmData[1024 + 288], &inPcmData[1024], 288*sizeof(*inPcmData));
254 }
255
256
257 if (applyProcessing)
258 {
259
260 /*
261 * Inverse filtering of lowband + HF generation
262 */
263
264 if (sbrDec->LC_aacP_DecoderFlag == ON)
265 {
266
267 sbr_generate_high_freq((int32_t(*)[32])(hFrameData->codecQmfBufferReal + sbrDec->bufReadOffs),
268 NULL,
269 (int32_t *)(hFrameData->sbrQmfBufferReal),
270 NULL,
271 hFrameData->sbr_invf_mode,
272 hFrameData->sbr_invf_mode_prev,
273 &(sbrDec->FreqBandTableNoise[1]),
274 sbrDec->NoNoiseBands,
275 sbrDec->lowSubband,
276 sbrDec->V_k_master,
277 sbrDec->Num_Master,
278 sbrDec->outSampleRate,
279 frameInfo,
280 hFrameData->degreeAlias,
281 scratch_mem,
282 hFrameData->BwVector,/* */
283 hFrameData->BwVectorOld,
284 &(sbrDec->Patch),
285 sbrDec->LC_aacP_DecoderFlag,
286 &(sbrDec->highSubband));
287
288
289 /*
290 * Adjust envelope of current frame.
291 */
292
293 calc_sbr_envelope(hFrameData,
294 (int32_t *)(hFrameData->sbrQmfBufferReal),
295 NULL,
296 sbrDec->FreqBandTable,
297 sbrDec->NSfb,
298 sbrDec->FreqBandTableNoise,
299 sbrDec->NoNoiseBands,
300 hFrameData->reset_flag,
301 hFrameData->degreeAlias,
302 &(hFrameData->harm_index),
303 &(hFrameData->phase_index),
304 hFrameData->hFp,
305 &(hFrameData->sUp),
306 sbrDec->limSbc,
307 sbrDec->gateMode,
308#ifdef HQ_SBR
309 NULL,
310 NULL,
311 NULL,
312 NULL,
313#endif
314 scratch_mem,
315 sbrDec->Patch,
316 sbrDec->sqrt_cache,
317 sbrDec->LC_aacP_DecoderFlag);
318 }
319#ifdef HQ_SBR
320 else
321 {
322
323 sbr_generate_high_freq((int32_t(*)[32])(hFrameData->codecQmfBufferReal + sbrDec->bufReadOffs),
324 (int32_t(*)[32])(hFrameData->codecQmfBufferImag + sbrDec->bufReadOffs),
325 (int32_t *)(hFrameData->sbrQmfBufferReal),
326 (int32_t *)(hFrameData->sbrQmfBufferImag),
327 hFrameData->sbr_invf_mode,
328 hFrameData->sbr_invf_mode_prev,
329 &(sbrDec->FreqBandTableNoise[1]),
330 sbrDec->NoNoiseBands,
331 sbrDec->lowSubband,
332 sbrDec->V_k_master,
333 sbrDec->Num_Master,
334 sbrDec->outSampleRate,
335 frameInfo,
336 NULL,
337 scratch_mem,
338 hFrameData->BwVector,
339 hFrameData->BwVectorOld,
340 &(sbrDec->Patch),
341 sbrDec->LC_aacP_DecoderFlag,
342 &(sbrDec->highSubband));
343
344 /*
345 * Adjust envelope of current frame.
346 */
347
348 calc_sbr_envelope(hFrameData,
349 (int32_t *)(hFrameData->sbrQmfBufferReal),
350 (int32_t *)(hFrameData->sbrQmfBufferImag),
351 sbrDec->FreqBandTable,
352 sbrDec->NSfb,
353 sbrDec->FreqBandTableNoise,
354 sbrDec->NoNoiseBands,
355 hFrameData->reset_flag,
356 NULL,
357 &(hFrameData->harm_index),
358 &(hFrameData->phase_index),
359 hFrameData->hFp,
360 &(hFrameData->sUp),
361 sbrDec->limSbc,
362 sbrDec->gateMode,
363 hFrameData->fBuf_man,
364 hFrameData->fBuf_exp,
365 hFrameData->fBufN_man,
366 hFrameData->fBufN_exp,
367 scratch_mem,
368 sbrDec->Patch,
369 sbrDec->sqrt_cache,
370 sbrDec->LC_aacP_DecoderFlag);
371
372 }
373#endif
374
375
376 }
377 else /* else for applyProcessing */
378 {
379 /* no sbr, set high band buffers to zero */
380
381 for (i = 0; i < SBR_NUM_COLUMNS; i++)
382 {
383 pv_memset((void *)&hFrameData->sbrQmfBufferReal[i*SBR_NUM_BANDS],
384 0,
385 SBR_NUM_BANDS*sizeof(*hFrameData->sbrQmfBufferReal));
386
387#ifdef HQ_SBR
388 pv_memset((void *)&hFrameData->sbrQmfBufferImag[i*SBR_NUM_BANDS],
389 0,
390 SBR_NUM_BANDS*sizeof(*hFrameData->sbrQmfBufferImag));
391
392#endif
393 }
394
395 }
396
397
398 /*
399 * Synthesis subband filtering.
400 */
401
402#ifdef HQ_SBR
403
404#ifdef PARAMETRICSTEREO
405
406
407 /*
408 * psPresentFlag set implies hParametricStereoDec !=NULL, second condition is
409 * is just here to prevent CodeSonar warnings.
410 */
411 if ((pVars->mc_info.psPresentFlag) && (applyProcessing) &&
412 (hParametricStereoDec != NULL))
413 {
414
415 /*
416 * qmfBufferReal uses the rigth aac channel ( perChan[1] is not used)
417 * followed by the buffer fxpCoef[2][2048] which makes a total of
418 * 2349 + 2048*2 = 6445
419 * These 2 matrices (qmfBufferReal & qmfBufferImag) are
420 * [2][38][64] == 4864 int32_t
421 */
422
423
424 tDec_Int_Chan *tmpx = &pVars->perChan[1];
425 /*
426 * dereferencing type-punned pointer avoid
427 * breaking strict-aliasing rules
428 */
429 int32_t *tmp = (int32_t *)tmpx;
430 hParametricStereoDec->qmfBufferReal = (int32_t(*)[64]) tmp;
431
432 tmp = (int32_t *) & hParametricStereoDec->qmfBufferReal[38][0];
433 hParametricStereoDec->qmfBufferImag = (int32_t(*)[64]) tmp;
434
435 for (i = 0; i < 32; i++)
436 {
437 Int xoverBand;
438
439 if (i < ((hFrameData->frameInfo[1]) << 1))
440 {
441 xoverBand = sbrDec->prevLowSubband;
442 }
443 else
444 {
445 xoverBand = sbrDec->lowSubband;
446 }
447
448 if (xoverBand > sbrDec->highSubband)
449 {
450 xoverBand = 32; /* error condition, default to upsampling mode */
451 }
452
453 m = sbrDec->bufReadOffs + i; /* 2 + i */
454
455 Sr_x = hParametricStereoDec->qmfBufferReal[i];
456 Si_x = hParametricStereoDec->qmfBufferImag[i];
457
458
459
460 for (int32_t j = 0; j < xoverBand; j++)
461 {
462 Sr_x[j] = shft_lft_1(hFrameData->codecQmfBufferReal[m][j]);
463 Si_x[j] = shft_lft_1(hFrameData->codecQmfBufferImag[m][j]);
464 }
465
466
467
468
469 pv_memcpy(&Sr_x[xoverBand],
470 &hFrameData->sbrQmfBufferReal[i*SBR_NUM_BANDS],
471 (sbrDec->highSubband - xoverBand)*sizeof(*Sr_x));
472
473 pv_memcpy(&Si_x[xoverBand],
474 &hFrameData->sbrQmfBufferImag[i*SBR_NUM_BANDS],
475 (sbrDec->highSubband - xoverBand)*sizeof(*Si_x));
476
477 pv_memset((void *)&Sr_x[sbrDec->highSubband],
478 0,
479 (64 - sbrDec->highSubband)*sizeof(*Sr_x));
480
481 pv_memset((void *)&Si_x[sbrDec->highSubband],
482 0,
483 (64 - sbrDec->highSubband)*sizeof(*Si_x));
484
485
486 }
487
488 for (i = 32; i < 32 + 6; i++)
489 {
490 m = sbrDec->bufReadOffs + i; /* 2 + i */
491
492 for (int32_t j = 0; j < 5; j++)
493 {
494 hParametricStereoDec->qmfBufferReal[i][j] = shft_lft_1(hFrameData->codecQmfBufferReal[m][j]);
495 hParametricStereoDec->qmfBufferImag[i][j] = shft_lft_1(hFrameData->codecQmfBufferImag[m][j]);
496 }
497
498 }
499
500
501 /*
502 * Update Buffers
503 */
504 for (i = 0; i < sbrDec->bufWriteOffs; i++) /* sbrDec->bufWriteOffs set to 8 and unchanged */
505 {
506 j = sbrDec->noCols + i; /* sbrDec->noCols set to 32 and unchanged */
507
508 pv_memmove(hFrameData->codecQmfBufferReal[i], /* to */
509 hFrameData->codecQmfBufferReal[j], /* from */
510 sizeof(*hFrameData->codecQmfBufferReal[i]) << 5);
511
512 pv_memmove(hFrameData->codecQmfBufferImag[i],
513 hFrameData->codecQmfBufferImag[j],
514 sizeof(*hFrameData->codecQmfBufferImag[i]) << 5);
515 }
516
517
518 pv_memmove(&hFrameData->HistsbrQmfBufferReal[0],
519 &hFrameData->sbrQmfBufferReal[32*SBR_NUM_BANDS],
520 6*SBR_NUM_BANDS*sizeof(*hFrameData->sbrQmfBufferReal));
521
522 pv_memmove(&hFrameData->HistsbrQmfBufferImag[0],
523 &hFrameData->sbrQmfBufferImag[32*SBR_NUM_BANDS],
524 6*SBR_NUM_BANDS*sizeof(*hFrameData->sbrQmfBufferImag));
525
526
527 /*
528 * Needs whole QMF matrix formed before applying
529 * Parametric stereo processing.
530 */
531
532 qmf_PS_generated_Real = scratch_mem[0];
533 qmf_PS_generated_Imag = scratch_mem[1];
534 env = 0;
535
536 /*
537 * Set circular buffer for Left channel
538 */
539
540 circular_buffer_s = (Int16 *)scratch_mem[7];
541
542
543 if (pVars->mc_info.bDownSampledSbr)
544 {
545 pv_memmove(&circular_buffer_s[2048],
546 hFrameData->V,
547 640*sizeof(*circular_buffer_s));
548 }
549 else
550 {
551 pv_memmove(&circular_buffer_s[4096],
552 hFrameData->V,
553 1152*sizeof(*circular_buffer_s));
554
555 }
556
557
558 /*
559 * Set Circular buffer for PS hybrid analysis
560 */
561 for (i = 0, j = 0; i < 3; i++)
562 {
563
564 pv_memmove(&scratch_mem[2][32 + j ],
565 hParametricStereoDec->hHybrid->mQmfBufferReal[i],
566 HYBRID_FILTER_LENGTH_m_1*sizeof(*hParametricStereoDec->hHybrid->mQmfBufferReal));
567 pv_memmove(&scratch_mem[2][32 + j + 44],
568 hParametricStereoDec->hHybrid->mQmfBufferImag[i],
569 HYBRID_FILTER_LENGTH_m_1*sizeof(*hParametricStereoDec->hHybrid->mQmfBufferImag));
570 j += 88;
571 }
572
573 pv_memset((void *)&qmf_PS_generated_Real[hParametricStereoDec->usb],
574 0,
575 (64 - hParametricStereoDec->usb)*sizeof(*qmf_PS_generated_Real));
576
577 pv_memset((void *)&qmf_PS_generated_Imag[hParametricStereoDec->usb],
578 0,
579 (64 - hParametricStereoDec->usb)*sizeof(*qmf_PS_generated_Imag));
580
581
582 for (i = 0; i < 32; i++)
583 {
584 if (i == (Int)hParametricStereoDec-> aEnvStartStop[env])
585 {
586 ps_init_stereo_mixing(hParametricStereoDec, env, sbrDec->highSubband);
587 env++;
588 }
589
590
591 ps_applied(hParametricStereoDec,
592 &hParametricStereoDec->qmfBufferReal[i],
593 &hParametricStereoDec->qmfBufferImag[i],
594 qmf_PS_generated_Real,
595 qmf_PS_generated_Imag,
596 scratch_mem[2],
597 i);
598
599 /* Create time samples for regular mono channel */
600
601 if (pVars->mc_info.bDownSampledSbr)
602 {
603 calc_sbr_synfilterbank(hParametricStereoDec->qmfBufferReal[i], /* realSamples */
604 hParametricStereoDec->qmfBufferImag[i], /* imagSamples */
605 ftimeOutPtr + (i << 6),
606 &circular_buffer_s[1984 - (i<<6)],
607 pVars->mc_info.bDownSampledSbr);
608 }
609 else
610 {
611 calc_sbr_synfilterbank(hParametricStereoDec->qmfBufferReal[i], /* realSamples */
612 hParametricStereoDec->qmfBufferImag[i], /* imagSamples */
613 ftimeOutPtr + (i << 7),
614 &circular_buffer_s[3968 - (i<<7)],
615 pVars->mc_info.bDownSampledSbr);
616
617 }
618
619 pv_memmove(hParametricStereoDec->qmfBufferReal[i], qmf_PS_generated_Real, 64*sizeof(*qmf_PS_generated_Real));
620 pv_memmove(hParametricStereoDec->qmfBufferImag[i], qmf_PS_generated_Imag, 64*sizeof(*qmf_PS_generated_Real));
621
622 }
623
624
625 /*
626 * Save Circular buffer history used on PS hybrid analysis
627 */
628
629 for (i = 0, j = 0; i < 3; i++)
630 {
631 pv_memmove(hParametricStereoDec->hHybrid->mQmfBufferReal[i],
632 &scratch_mem[2][ 64 + j ],
633 HYBRID_FILTER_LENGTH_m_1*sizeof(*hParametricStereoDec->hHybrid->mQmfBufferReal));
634
635 pv_memmove(hParametricStereoDec->hHybrid->mQmfBufferImag[i],
636 &scratch_mem[2][ 64 + j + 44],
637 HYBRID_FILTER_LENGTH_m_1*sizeof(*hParametricStereoDec->hHybrid->mQmfBufferImag));
638
639 j += 88;
640 }
641
642 pv_memmove(hFrameData->V, &circular_buffer_s[0], 1152*sizeof(*circular_buffer_s));
643
644 /*
645 * Set circular buffer for Right channel
646 */
647
648 circular_buffer_s = (Int16 *)scratch_mem[5];
649
650 if (pVars->mc_info.bDownSampledSbr)
651 {
652 pv_memmove(&circular_buffer_s[2048],
653 (int32_t *)hParametricStereoDec->R_ch_qmf_filter_history,
654 640*sizeof(*circular_buffer_s));
655 }
656 else
657 {
658 pv_memmove(&circular_buffer_s[4096],
659 (int32_t *)hParametricStereoDec->R_ch_qmf_filter_history,
660 1152*sizeof(*circular_buffer_s));
661
662 }
663
664
665 for (i = 0; i < 32; i++)
666 {
667 if (pVars->mc_info.bDownSampledSbr)
668 {
669
670 calc_sbr_synfilterbank(hParametricStereoDec->qmfBufferReal[i], /* realSamples */
671 hParametricStereoDec->qmfBufferImag[i], /* imagSamples */
672 ftimeOutPtrPS + (i << 6),
673 &circular_buffer_s[1984 - (i<<6)],
674 pVars->mc_info.bDownSampledSbr);
675 }
676 else
677 {
678 calc_sbr_synfilterbank(hParametricStereoDec->qmfBufferReal[i], /* realSamples */
679 hParametricStereoDec->qmfBufferImag[i], /* imagSamples */
680 ftimeOutPtrPS + (i << 7),
681 &circular_buffer_s[3968 - (i<<7)],
682 pVars->mc_info.bDownSampledSbr);
683 }
684
685 }
686
687 if (pVars->mc_info.bDownSampledSbr)
688 {
689 pv_memmove((int32_t *)hParametricStereoDec->R_ch_qmf_filter_history, &circular_buffer_s[0], 640*sizeof(*circular_buffer_s));
690 }
691 else
692 {
693 pv_memmove((int32_t *)hParametricStereoDec->R_ch_qmf_filter_history, &circular_buffer_s[0], 1152*sizeof(*circular_buffer_s));
694 }
695
696
697
698
699
700 }
701 else /* else -- sbrEnablePS */
702 {
703
704#endif /* PARAMETRICSTEREO */
705#endif /* HQ_SBR */
706
707 /*
708 * Use shared aac memory as continuous buffer
709 */
710
711
712 Sr = scratch_mem[0];
713 Si = scratch_mem[1];
714
715 circular_buffer_s = (Int16*)scratch_mem[2];
716
717 if (pVars->mc_info.bDownSampledSbr)
718 {
719
720 pv_memmove(&circular_buffer_s[2048],
721 hFrameData->V,
722 640*sizeof(*circular_buffer_s));
723 }
724 else
725 {
726 pv_memmove(&circular_buffer_s[4096],
727 hFrameData->V,
728 1152*sizeof(*circular_buffer_s));
729 }
730
731 for (i = 0; i < 32; i++)
732 {
733 Int xoverBand;
734
735 if (applyProcessing)
736 {
737 if (i < ((hFrameData->frameInfo[1]) << 1))
738 {
739 xoverBand = sbrDec->prevLowSubband;
740
741 }
742 else
743 {
744 xoverBand = sbrDec->lowSubband;
745 }
746
747 if (xoverBand > sbrDec->highSubband)
748 {
749 xoverBand = 32; /* error condition, default to upsampling mode */
750 }
751 }
752 else
753 {
754 xoverBand = 32;
755 sbrDec->highSubband = 32;
756 }
757
758
759 m = sbrDec->bufReadOffs + i; /* sbrDec->bufReadOffs == 2 */
760
761
762 ptr_tmp1 = (hFrameData->codecQmfBufferReal[m]);
763 ptr_tmp2 = Sr;
764
765 if (sbrDec->LC_aacP_DecoderFlag == ON)
766 {
767
768 for (k = (xoverBand >> 1); k != 0; k--)
769 {
770 *(ptr_tmp2++) = (*(ptr_tmp1++)) >> 9;
771 *(ptr_tmp2++) = (*(ptr_tmp1++)) >> 9;
772 }
773 if (xoverBand & 1)
774 {
775 *(ptr_tmp2++) = (*(ptr_tmp1)) >> 9;
776 }
777
778 ptr_tmp1 = &hFrameData->sbrQmfBufferReal[i*SBR_NUM_BANDS];
779
780
781 for (k = xoverBand; k < sbrDec->highSubband; k++)
782 {
783 *(ptr_tmp2++) = (*(ptr_tmp1++)) << 1;
784 }
785
786 pv_memset((void *)ptr_tmp2,
787 0,
788 (64 - sbrDec->highSubband)*sizeof(*ptr_tmp2));
789
790
791 if (pVars->mc_info.bDownSampledSbr)
792 {
793 calc_sbr_synfilterbank_LC(Sr, /* realSamples */
794 ftimeOutPtr + (i << 6),
795 &circular_buffer_s[1984 - (i<<6)],
796 pVars->mc_info.bDownSampledSbr);
797 }
798 else
799 {
800 calc_sbr_synfilterbank_LC(Sr, /* realSamples */
801 ftimeOutPtr + (i << 7),
802 &circular_buffer_s[3968 - (i<<7)],
803 pVars->mc_info.bDownSampledSbr);
804 }
805 }
806#ifdef HQ_SBR
807 else
808 {
809
810 for (k = xoverBand; k != 0; k--)
811 {
812 *(ptr_tmp2++) = shft_lft_1(*(ptr_tmp1++));
813 }
814
815 ptr_tmp1 = &hFrameData->sbrQmfBufferReal[i*SBR_NUM_BANDS];
816 ptr_tmp2 = &Sr[xoverBand];
817
818
819 for (k = xoverBand; k < sbrDec->highSubband; k++)
820 {
821 *(ptr_tmp2++) = (*(ptr_tmp1++));
822 }
823
824 pv_memset((void *)ptr_tmp2,
825 0,
826 (64 - sbrDec->highSubband)*sizeof(*ptr_tmp2));
827
828
829 ptr_tmp1 = (hFrameData->codecQmfBufferImag[m]);
830 ptr_tmp2 = Si;
831
832 for (k = (xoverBand >> 1); k != 0; k--)
833 {
834 *(ptr_tmp2++) = shft_lft_1(*(ptr_tmp1++));
835 *(ptr_tmp2++) = shft_lft_1(*(ptr_tmp1++));
836 }
837 if (xoverBand & 1)
838 {
839 *(ptr_tmp2) = shft_lft_1(*(ptr_tmp1));
840 }
841
842 ptr_tmp1 = &hFrameData->sbrQmfBufferImag[i*SBR_NUM_BANDS];
843 ptr_tmp2 = &Si[xoverBand];
844
845 for (k = xoverBand; k < sbrDec->highSubband; k++)
846 {
847 *(ptr_tmp2++) = (*(ptr_tmp1++));
848 }
849
850 pv_memset((void *)ptr_tmp2,
851 0,
852 (64 - sbrDec->highSubband)*sizeof(*ptr_tmp2));
853
854
855 if (pVars->mc_info.bDownSampledSbr)
856 {
857 calc_sbr_synfilterbank(Sr, /* realSamples */
858 Si, /* imagSamples */
859 ftimeOutPtr + (i << 6),
860 &circular_buffer_s[1984 - (i<<6)],
861 pVars->mc_info.bDownSampledSbr);
862 }
863 else
864 {
865 calc_sbr_synfilterbank(Sr, /* realSamples */
866 Si, /* imagSamples */
867 ftimeOutPtr + (i << 7),
868 &circular_buffer_s[3968 - (i<<7)],
869 pVars->mc_info.bDownSampledSbr);
870 }
871 }
872#endif
873
874 }
875
876 if (pVars->mc_info.bDownSampledSbr)
877 {
878 pv_memmove(hFrameData->V, &circular_buffer_s[0], 640*sizeof(*circular_buffer_s));
879 }
880 else
881 {
882 pv_memmove(hFrameData->V, &circular_buffer_s[0], 1152*sizeof(*circular_buffer_s));
883 }
884
885
886
887
888 /*
889 * Update Buffers
890 */
891 for (i = 0; i < sbrDec->bufWriteOffs; i++) /* sbrDec->bufWriteOffs set to 8 and unchanged */
892 {
893 j = sbrDec->noCols + i; /* sbrDec->noCols set to 32 and unchanged */
894
895 pv_memmove(hFrameData->codecQmfBufferReal[i], /* to */
896 hFrameData->codecQmfBufferReal[j], /* from */
897 sizeof(*hFrameData->codecQmfBufferReal[i]) << 5);
898 }
899
900
901 pv_memmove(&hFrameData->HistsbrQmfBufferReal[0],
902 &hFrameData->sbrQmfBufferReal[32*SBR_NUM_BANDS],
903 6*SBR_NUM_BANDS*sizeof(*hFrameData->sbrQmfBufferReal));
904
905#ifdef HQ_SBR
906 if (sbrDec->LC_aacP_DecoderFlag == OFF)
907 {
908 for (i = 0; i < sbrDec->bufWriteOffs; i++) /* sbrDec->bufWriteOffs set to 6 and unchanged */
909 {
910 j = sbrDec->noCols + i; /* sbrDec->noCols set to 32 and unchanged */
911
912
913 pv_memmove(hFrameData->codecQmfBufferImag[i],
914 hFrameData->codecQmfBufferImag[j],
915 sizeof(*hFrameData->codecQmfBufferImag[i]) << 5);
916
917 }
918
919 pv_memmove(&hFrameData->HistsbrQmfBufferImag[0],
920 &hFrameData->sbrQmfBufferImag[32*SBR_NUM_BANDS],
921 6*SBR_NUM_BANDS*sizeof(*hFrameData->sbrQmfBufferImag));
922 }
923#endif
924
925
926#ifdef HQ_SBR
927#ifdef PARAMETRICSTEREO
928 }
929#endif
930#endif
931
932
933 hFrameData->reset_flag = 0;
934 if (applyProcessing)
935 {
936 sbrDec->prevLowSubband = sbrDec->lowSubband;
937 }
938
939}
940
941
942#endif /* AAC_PLUS */