summaryrefslogtreecommitdiff
path: root/apps/codecs/libfaad/sbr_qmf.c
diff options
context:
space:
mode:
Diffstat (limited to 'apps/codecs/libfaad/sbr_qmf.c')
-rw-r--r--apps/codecs/libfaad/sbr_qmf.c371
1 files changed, 138 insertions, 233 deletions
diff --git a/apps/codecs/libfaad/sbr_qmf.c b/apps/codecs/libfaad/sbr_qmf.c
index 5486cd283d..7b70cc6a5e 100644
--- a/apps/codecs/libfaad/sbr_qmf.c
+++ b/apps/codecs/libfaad/sbr_qmf.c
@@ -38,6 +38,16 @@
38#include "sbr_qmf_c.h" 38#include "sbr_qmf_c.h"
39#include "sbr_syntax.h" 39#include "sbr_syntax.h"
40 40
41#ifdef FIXED_POINT
42 #define FAAD_SYNTHESIS_SCALE(X) ((X)>>1)
43 #define FAAD_ANALYSIS_SCALE1(X) ((X)>>4)
44 #define FAAD_ANALYSIS_SCALE2(X) ((X))
45#else
46 #define FAAD_ANALYSIS_SCALE1(X) ((X)*scale)
47 #define FAAD_ANALYSIS_SCALE1(X) ((X))
48 #define FAAD_ANALYSIS_SCALE2(X) (2.*(X))
49#endif
50
41qmfa_info *qmfa_init(uint8_t channels) 51qmfa_info *qmfa_init(uint8_t channels)
42{ 52{
43 qmfa_info *qmfa = (qmfa_info*)faad_malloc(sizeof(qmfa_info)); 53 qmfa_info *qmfa = (qmfa_info*)faad_malloc(sizeof(qmfa_info));
@@ -68,40 +78,44 @@ void sbr_qmf_analysis_32(sbr_info *sbr, qmfa_info *qmfa, const real_t *input,
68{ 78{
69 ALIGN real_t u[64]; 79 ALIGN real_t u[64];
70#ifndef SBR_LOW_POWER 80#ifndef SBR_LOW_POWER
71 static ALIGN real_t in_real[32], in_imag[32], out_real[32], out_imag[32]; 81 ALIGN real_t real[32];
82 ALIGN real_t imag[32];
72#else 83#else
73 ALIGN real_t y[32]; 84 ALIGN real_t y[32];
74#endif 85#endif
75 uint16_t in = 0; 86 qmf_t *pX;
76 uint8_t l; 87 uint32_t in = 0;
88 uint32_t l, idx0, idx1;
77 89
78 /* qmf subsample l */ 90 /* qmf subsample l */
79 for (l = 0; l < sbr->numTimeSlotsRate; l++) 91 for (l = 0; l < sbr->numTimeSlotsRate; l++)
80 { 92 {
81 int16_t n; 93 int32_t n;
82 94
83 /* shift input buffer x */ 95 /* shift input buffer x */
84 /* input buffer is not shifted anymore, x is implemented as double ringbuffer */ 96 /* input buffer is not shifted anymore, x is implemented as double ringbuffer */
85 //memmove(qmfa->x + 32, qmfa->x, (320-32)*sizeof(real_t)); 97 //memmove(qmfa->x + 32, qmfa->x, (320-32)*sizeof(real_t));
86 98
87 /* add new samples to input buffer x */ 99 /* add new samples to input buffer x */
88 for (n = 32 - 1; n >= 0; n--) 100 idx0 = qmfa->x_index + 31; idx1 = idx0 + 320;
101 for (n = 32 - 1; n >= 0; n-=4)
89 { 102 {
90#ifdef FIXED_POINT 103 qmfa->x[idx0--] = qmfa->x[idx1--] = (input[in++]);
91 qmfa->x[qmfa->x_index + n] = qmfa->x[qmfa->x_index + n + 320] = (input[in++]) >> 4; 104 qmfa->x[idx0--] = qmfa->x[idx1--] = (input[in++]);
92#else 105 qmfa->x[idx0--] = qmfa->x[idx1--] = (input[in++]);
93 qmfa->x[qmfa->x_index + n] = qmfa->x[qmfa->x_index + n + 320] = input[in++]; 106 qmfa->x[idx0--] = qmfa->x[idx1--] = (input[in++]);
94#endif
95 } 107 }
96 108
97 /* window and summation to create array u */ 109 /* window and summation to create array u */
98 for (n = 0; n < 64; n++) 110 for (n = 0; n < 64; n++)
99 { 111 {
100 u[n] = MUL_F(qmfa->x[qmfa->x_index + n], qmf_c[2*n]) + 112 idx0 = qmfa->x_index + n; idx1 = n * 2;
101 MUL_F(qmfa->x[qmfa->x_index + n + 64], qmf_c[2*(n + 64)]) + 113 u[n] = FAAD_ANALYSIS_SCALE1(
102 MUL_F(qmfa->x[qmfa->x_index + n + 128], qmf_c[2*(n + 128)]) + 114 MUL_F(qmfa->x[idx0 ], qmf_c[idx1]) +
103 MUL_F(qmfa->x[qmfa->x_index + n + 192], qmf_c[2*(n + 192)]) + 115 MUL_F(qmfa->x[idx0 + 64], qmf_c[idx1 + 2 * 64]) +
104 MUL_F(qmfa->x[qmfa->x_index + n + 256], qmf_c[2*(n + 256)]); 116 MUL_F(qmfa->x[idx0 + 128], qmf_c[idx1 + 2 * 128]) +
117 MUL_F(qmfa->x[idx0 + 192], qmf_c[idx1 + 2 * 192]) +
118 MUL_F(qmfa->x[idx0 + 256], qmf_c[idx1 + 2 * 256]));
105 } 119 }
106 120
107 /* update ringbuffer index */ 121 /* update ringbuffer index */
@@ -123,64 +137,52 @@ void sbr_qmf_analysis_32(sbr_info *sbr, qmfa_info *qmfa, const real_t *input,
123 { 137 {
124 if (n < kx) 138 if (n < kx)
125 { 139 {
126#ifdef FIXED_POINT 140 QMF_RE(X[l + offset][n]) = FAAD_ANALYSIS_SCALE2(u[n]);
127 QMF_RE(X[l + offset][n]) = u[n] /*<< 1*/;
128#else
129 QMF_RE(X[l + offset][n]) = 2. * u[n];
130#endif
131 } else { 141 } else {
132 QMF_RE(X[l + offset][n]) = 0; 142 QMF_RE(X[l + offset][n]) = 0;
133 } 143 }
134 } 144 }
135#else 145#else /* #ifdef SBR_LOW_POWER */
136 146
137 // Reordering of data moved from DCT_IV to here 147 // Reordering of data moved from DCT_IV to here
138 in_imag[31] = u[1]; 148 idx0 = 30; idx1 = 63;
139 in_real[0] = u[0]; 149 imag[31] = u[ 1]; real[ 0] = u[ 0];
140 for (n = 1; n < 31; n++) 150 for (n = 1; n < 31; n+=3)
141 { 151 {
142 in_imag[31 - n] = u[n+1]; 152 imag[idx0--] = u[n+1]; real[n ] = -u[idx1--];
143 in_real[n] = -u[64-n]; 153 imag[idx0--] = u[n+2]; real[n+1] = -u[idx1--];
154 imag[idx0--] = u[n+3]; real[n+2] = -u[idx1--];
144 } 155 }
145 in_imag[0] = u[32]; 156 imag[ 0] = u[32]; real[31] = -u[33];
146 in_real[31] = -u[33];
147 157
148 // dct4_kernel is DCT_IV without reordering which is done before and after FFT 158 // dct4_kernel is DCT_IV without reordering which is done before and after FFT
149 dct4_kernel(in_real, in_imag, out_real, out_imag); 159 dct4_kernel(real, imag);
150 160
151 // Reordering of data moved from DCT_IV to here 161 // Reordering of data moved from DCT_IV to here
152 for (n = 0; n < 16; n++) { 162 /* Step 1: Calculate all non-zero pairs */
153 if (2*n+1 < kx) { 163 pX = X[l + offset];
154#ifdef FIXED_POINT 164 for (n = 0; n < kx/2; n++) {
155 QMF_RE(X[l + offset][2*n]) = out_real[n]; 165 idx0 = 2*n; idx1 = idx0 + 1;
156 QMF_IM(X[l + offset][2*n]) = out_imag[n]; 166 QMF_RE(pX[idx0]) = FAAD_ANALYSIS_SCALE2( real[n ]);
157 QMF_RE(X[l + offset][2*n+1]) = -out_imag[31-n]; 167 QMF_IM(pX[idx0]) = FAAD_ANALYSIS_SCALE2( imag[n ]);
158 QMF_IM(X[l + offset][2*n+1]) = -out_real[31-n]; 168 QMF_RE(pX[idx1]) = FAAD_ANALYSIS_SCALE2(-imag[31-n]);
159#else 169 QMF_IM(pX[idx1]) = FAAD_ANALYSIS_SCALE2(-real[31-n]);
160 QMF_RE(X[l + offset][2*n]) = 2. * out_real[n];
161 QMF_IM(X[l + offset][2*n]) = 2. * out_imag[n];
162 QMF_RE(X[l + offset][2*n+1]) = -2. * out_imag[31-n];
163 QMF_IM(X[l + offset][2*n+1]) = -2. * out_real[31-n];
164#endif
165 } else {
166 if (2*n < kx) {
167#ifdef FIXED_POINT
168 QMF_RE(X[l + offset][2*n]) = out_real[n];
169 QMF_IM(X[l + offset][2*n]) = out_imag[n];
170#else
171 QMF_RE(X[l + offset][2*n]) = 2. * out_real[n];
172 QMF_IM(X[l + offset][2*n]) = 2. * out_imag[n];
173#endif
174 }
175 else {
176 QMF_RE(X[l + offset][2*n]) = 0;
177 QMF_IM(X[l + offset][2*n]) = 0;
178 }
179 QMF_RE(X[l + offset][2*n+1]) = 0;
180 QMF_IM(X[l + offset][2*n+1]) = 0;
181 }
182 } 170 }
183#endif 171 /* Step 2: Calculate a single pair with half zero'ed */
172 if (kx&1) {
173 idx0 = 2*n; idx1 = idx0 + 1;
174 QMF_RE(pX[idx0]) = FAAD_ANALYSIS_SCALE2( real[n]);
175 QMF_IM(pX[idx0]) = FAAD_ANALYSIS_SCALE2( imag[n]);
176 QMF_RE(pX[idx1]) = QMF_IM(pX[idx1]) = 0;
177 n++;
178 }
179 /* Step 3: All other are zero'ed */
180 for (; n < 16; n++) {
181 idx0 = 2*n; idx1 = idx0 + 1;
182 QMF_RE(pX[idx0]) = QMF_IM(pX[idx0]) = 0;
183 QMF_RE(pX[idx1]) = QMF_IM(pX[idx1]) = 0;
184 }
185#endif /* #ifdef SBR_LOW_POWER */
184 } 186 }
185} 187}
186 188
@@ -297,7 +299,7 @@ void sbr_qmf_synthesis_32(sbr_info *sbr, qmfs_info *qmfs, qmf_t X[MAX_NTSRHFG][6
297 for (k = 0; k < 32; k++) 299 for (k = 0; k < 32; k++)
298 { 300 {
299 output[out++] = MUL_F(qmfs->v[qmfs->v_index + k], qmf_c[2*k]) + 301 output[out++] = MUL_F(qmfs->v[qmfs->v_index + k], qmf_c[2*k]) +
300 MUL_F(qmfs->v[qmfs->v_index + 96 + k], qmf_c[64 + 2*k]) + 302 MUL_F(qmfs->v[qmfs->v_index + 96 + k], qmf_c[ 64 + 2*k]) +
301 MUL_F(qmfs->v[qmfs->v_index + 128 + k], qmf_c[128 + 2*k]) + 303 MUL_F(qmfs->v[qmfs->v_index + 128 + k], qmf_c[128 + 2*k]) +
302 MUL_F(qmfs->v[qmfs->v_index + 224 + k], qmf_c[192 + 2*k]) + 304 MUL_F(qmfs->v[qmfs->v_index + 224 + k], qmf_c[192 + 2*k]) +
303 MUL_F(qmfs->v[qmfs->v_index + 256 + k], qmf_c[256 + 2*k]) + 305 MUL_F(qmfs->v[qmfs->v_index + 256 + k], qmf_c[256 + 2*k]) +
@@ -384,17 +386,26 @@ void sbr_qmf_synthesis_64(sbr_info *sbr, qmfs_info *qmfs, qmf_t X[MAX_NTSRHFG][6
384 qmfs->v_index = (1280-128); 386 qmfs->v_index = (1280-128);
385 } 387 }
386} 388}
387#else 389#else /* #ifdef SBR_LOW_POWER */
390
391#define FAAD_CMPLX_PRETWIDDLE_SUB(k) \
392 (MUL_F(QMF_RE(X[l][k]), RE(qmf32_pre_twiddle[k])) - \
393 MUL_F(QMF_IM(X[l][k]), IM(qmf32_pre_twiddle[k]))) \
394
395#define FAAD_CMPLX_PRETWIDDLE_ADD(k) \
396 (MUL_F(QMF_IM(X[l][k]), RE(qmf32_pre_twiddle[k])) + \
397 MUL_F(QMF_RE(X[l][k]), IM(qmf32_pre_twiddle[k]))) \
398
388void sbr_qmf_synthesis_32(sbr_info *sbr, qmfs_info *qmfs, qmf_t X[MAX_NTSRHFG][64], 399void sbr_qmf_synthesis_32(sbr_info *sbr, qmfs_info *qmfs, qmf_t X[MAX_NTSRHFG][64],
389 real_t *output) 400 real_t *output)
390{ 401{
391 ALIGN real_t x1[32], x2[32]; 402 ALIGN real_t x1[32];
403 ALIGN real_t x2[32];
392#ifndef FIXED_POINT 404#ifndef FIXED_POINT
393 real_t scale = 1.f/64.f; 405 real_t scale = 1.f/64.f;
394#endif 406#endif
395 int16_t n, k, out = 0; 407 int32_t n, k, idx0, idx1, out = 0;
396 uint8_t l; 408 uint32_t l;
397
398 409
399 /* qmf subsample l */ 410 /* qmf subsample l */
400 for (l = 0; l < sbr->numTimeSlotsRate; l++) 411 for (l = 0; l < sbr->numTimeSlotsRate; l++)
@@ -405,43 +416,43 @@ void sbr_qmf_synthesis_32(sbr_info *sbr, qmfs_info *qmfs, qmf_t X[MAX_NTSRHFG][6
405 416
406 /* calculate 64 samples */ 417 /* calculate 64 samples */
407 /* complex pre-twiddle */ 418 /* complex pre-twiddle */
408 for (k = 0; k < 32; k++) 419 for (k = 0; k < 32;)
409 { 420 {
410 x1[k] = MUL_F(QMF_RE(X[l][k]), RE(qmf32_pre_twiddle[k])) - MUL_F(QMF_IM(X[l][k]), IM(qmf32_pre_twiddle[k])); 421 x1[k] = FAAD_CMPLX_PRETWIDDLE_SUB(k); x2[k] = FAAD_CMPLX_PRETWIDDLE_ADD(k); k++;
411 x2[k] = MUL_F(QMF_IM(X[l][k]), RE(qmf32_pre_twiddle[k])) + MUL_F(QMF_RE(X[l][k]), IM(qmf32_pre_twiddle[k])); 422 x1[k] = FAAD_CMPLX_PRETWIDDLE_SUB(k); x2[k] = FAAD_CMPLX_PRETWIDDLE_ADD(k); k++;
412 423 x1[k] = FAAD_CMPLX_PRETWIDDLE_SUB(k); x2[k] = FAAD_CMPLX_PRETWIDDLE_ADD(k); k++;
413#ifndef FIXED_POINT 424 x1[k] = FAAD_CMPLX_PRETWIDDLE_SUB(k); x2[k] = FAAD_CMPLX_PRETWIDDLE_ADD(k); k++;
414 x1[k] *= scale;
415 x2[k] *= scale;
416#else
417 x1[k] >>= 1;
418 x2[k] >>= 1;
419#endif
420 } 425 }
421 426
422 /* transform */ 427 /* transform */
423 DCT4_32(x1, x1); 428 DCT4_32(x1, x1);
424 DST4_32(x2, x2); 429 DST4_32(x2, x2);
425 430
426 for (n = 0; n < 32; n++) 431 idx0 = qmfs->v_index;
432 idx1 = qmfs->v_index + 63;
433 for (n = 0; n < 32; n+=2)
427 { 434 {
428 qmfs->v[qmfs->v_index + n] = qmfs->v[qmfs->v_index + 640 + n] = -x1[n] + x2[n]; 435 qmfs->v[idx0] = qmfs->v[idx0 + 640] = -x1[n ] + x2[n ]; idx0++;
429 qmfs->v[qmfs->v_index + 63 - n] = qmfs->v[qmfs->v_index + 640 + 63 - n] = x1[n] + x2[n]; 436 qmfs->v[idx1] = qmfs->v[idx1 + 640] = x1[n ] + x2[n ]; idx1--;
437 qmfs->v[idx0] = qmfs->v[idx0 + 640] = -x1[n+1] + x2[n+1]; idx0++;
438 qmfs->v[idx1] = qmfs->v[idx1 + 640] = x1[n+1] + x2[n+1]; idx1--;
430 } 439 }
431 440
432 /* calculate 32 output samples and window */ 441 /* calculate 32 output samples and window */
433 for (k = 0; k < 32; k++) 442 for (k = 0; k < 32; k++)
434 { 443 {
435 output[out++] = MUL_F(qmfs->v[qmfs->v_index + k], qmf_c[2*k]) + 444 idx0 = qmfs->v_index + k; idx1 = 2*k;
436 MUL_F(qmfs->v[qmfs->v_index + 96 + k], qmf_c[64 + 2*k]) + 445 output[out++] = FAAD_SYNTHESIS_SCALE(
437 MUL_F(qmfs->v[qmfs->v_index + 128 + k], qmf_c[128 + 2*k]) + 446 MUL_F(qmfs->v[idx0 ], qmf_c[idx1 ]) +
438 MUL_F(qmfs->v[qmfs->v_index + 224 + k], qmf_c[192 + 2*k]) + 447 MUL_F(qmfs->v[idx0 + 96], qmf_c[idx1 + 64]) +
439 MUL_F(qmfs->v[qmfs->v_index + 256 + k], qmf_c[256 + 2*k]) + 448 MUL_F(qmfs->v[idx0 + 128], qmf_c[idx1 + 128]) +
440 MUL_F(qmfs->v[qmfs->v_index + 352 + k], qmf_c[320 + 2*k]) + 449 MUL_F(qmfs->v[idx0 + 224], qmf_c[idx1 + 192]) +
441 MUL_F(qmfs->v[qmfs->v_index + 384 + k], qmf_c[384 + 2*k]) + 450 MUL_F(qmfs->v[idx0 + 256], qmf_c[idx1 + 256]) +
442 MUL_F(qmfs->v[qmfs->v_index + 480 + k], qmf_c[448 + 2*k]) + 451 MUL_F(qmfs->v[idx0 + 352], qmf_c[idx1 + 320]) +
443 MUL_F(qmfs->v[qmfs->v_index + 512 + k], qmf_c[512 + 2*k]) + 452 MUL_F(qmfs->v[idx0 + 384], qmf_c[idx1 + 384]) +
444 MUL_F(qmfs->v[qmfs->v_index + 608 + k], qmf_c[576 + 2*k]); 453 MUL_F(qmfs->v[idx0 + 480], qmf_c[idx1 + 448]) +
454 MUL_F(qmfs->v[idx0 + 512], qmf_c[idx1 + 512]) +
455 MUL_F(qmfs->v[idx0 + 608], qmf_c[idx1 + 576]));
445 } 456 }
446 457
447 /* update ringbuffer index */ 458 /* update ringbuffer index */
@@ -454,31 +465,18 @@ void sbr_qmf_synthesis_32(sbr_info *sbr, qmfs_info *qmfs, qmf_t X[MAX_NTSRHFG][6
454void sbr_qmf_synthesis_64(sbr_info *sbr, qmfs_info *qmfs, qmf_t X[MAX_NTSRHFG][64], 465void sbr_qmf_synthesis_64(sbr_info *sbr, qmfs_info *qmfs, qmf_t X[MAX_NTSRHFG][64],
455 real_t *output) 466 real_t *output)
456{ 467{
457// ALIGN real_t x1[64], x2[64]; 468 ALIGN real_t real1[32];
458#ifndef SBR_LOW_POWER 469 ALIGN real_t imag1[32];
459 static ALIGN real_t in_real1[32], in_imag1[32], out_real1[32], out_imag1[32]; 470 ALIGN real_t real2[32];
460 static ALIGN real_t in_real2[32], in_imag2[32], out_real2[32], out_imag2[32]; 471 ALIGN real_t imag2[32];
461#endif
462 qmf_t * pX; 472 qmf_t * pX;
463 real_t * pring_buffer_1, * pring_buffer_3; 473 real_t * p_buf_1, * p_buf_3;
464// real_t * ptemp_1, * ptemp_2;
465#ifdef PREFER_POINTERS
466 // These pointers are used if target platform has autoinc address generators
467 real_t * pring_buffer_2, * pring_buffer_4;
468 real_t * pring_buffer_5, * pring_buffer_6;
469 real_t * pring_buffer_7, * pring_buffer_8;
470 real_t * pring_buffer_9, * pring_buffer_10;
471 const real_t * pqmf_c_1, * pqmf_c_2, * pqmf_c_3, * pqmf_c_4;
472 const real_t * pqmf_c_5, * pqmf_c_6, * pqmf_c_7, * pqmf_c_8;
473 const real_t * pqmf_c_9, * pqmf_c_10;
474#endif // #ifdef PREFER_POINTERS
475#ifndef FIXED_POINT 474#ifndef FIXED_POINT
476 real_t scale = 1.f/64.f; 475 real_t scale = 1.f/64.f;
477#endif 476#endif
478 int16_t n, k, out = 0; 477 int32_t n, k, idx0, idx1, out = 0;
479 uint8_t l; 478 uint32_t l;
480 479
481
482 /* qmf subsample l */ 480 /* qmf subsample l */
483 for (l = 0; l < sbr->numTimeSlotsRate; l++) 481 for (l = 0; l < sbr->numTimeSlotsRate; l++)
484 { 482 {
@@ -487,139 +485,46 @@ void sbr_qmf_synthesis_64(sbr_info *sbr, qmfs_info *qmfs, qmf_t X[MAX_NTSRHFG][6
487 //memmove(qmfs->v + 128, qmfs->v, (1280-128)*sizeof(real_t)); 485 //memmove(qmfs->v + 128, qmfs->v, (1280-128)*sizeof(real_t));
488 486
489 /* calculate 128 samples */ 487 /* calculate 128 samples */
490#ifndef FIXED_POINT
491
492 pX = X[l]; 488 pX = X[l];
493 489 for (k = 0; k < 32; k++)
494 in_imag1[31] = scale*QMF_RE(pX[1]);
495 in_real1[0] = scale*QMF_RE(pX[0]);
496 in_imag2[31] = scale*QMF_IM(pX[63-1]);
497 in_real2[0] = scale*QMF_IM(pX[63-0]);
498 for (k = 1; k < 31; k++)
499 {
500 in_imag1[31 - k] = scale*QMF_RE(pX[2*k + 1]);
501 in_real1[ k] = scale*QMF_RE(pX[2*k ]);
502 in_imag2[31 - k] = scale*QMF_IM(pX[63 - (2*k + 1)]);
503 in_real2[ k] = scale*QMF_IM(pX[63 - (2*k )]);
504 }
505 in_imag1[0] = scale*QMF_RE(pX[63]);
506 in_real1[31] = scale*QMF_RE(pX[62]);
507 in_imag2[0] = scale*QMF_IM(pX[63-63]);
508 in_real2[31] = scale*QMF_IM(pX[63-62]);
509
510#else
511
512 pX = X[l];
513
514 in_imag1[31] = QMF_RE(pX[1]) >> 1;
515 in_real1[0] = QMF_RE(pX[0]) >> 1;
516 in_imag2[31] = QMF_IM(pX[62]) >> 1;
517 in_real2[0] = QMF_IM(pX[63]) >> 1;
518 for (k = 1; k < 31; k++)
519 { 490 {
520 in_imag1[31 - k] = QMF_RE(pX[2*k + 1]) >> 1; 491 idx0 = 2*k; idx1 = idx0+1;
521 in_real1[ k] = QMF_RE(pX[2*k ]) >> 1; 492 real1[ k] = QMF_RE(pX[idx0]); imag2[ k] = QMF_IM(pX[idx0]);
522 in_imag2[31 - k] = QMF_IM(pX[63 - (2*k + 1)]) >> 1; 493 imag1[31-k] = QMF_RE(pX[idx1]); real2[31-k] = QMF_IM(pX[idx1]);
523 in_real2[ k] = QMF_IM(pX[63 - (2*k )]) >> 1;
524 } 494 }
525 in_imag1[0] = QMF_RE(pX[63]) >> 1; 495
526 in_real1[31] = QMF_RE(pX[62]) >> 1;
527 in_imag2[0] = QMF_IM(pX[0]) >> 1;
528 in_real2[31] = QMF_IM(pX[1]) >> 1;
529
530#endif
531
532
533 // dct4_kernel is DCT_IV without reordering which is done before and after FFT 496 // dct4_kernel is DCT_IV without reordering which is done before and after FFT
534 dct4_kernel(in_real1, in_imag1, out_real1, out_imag1); 497 dct4_kernel(real1, imag1);
535 dct4_kernel(in_real2, in_imag2, out_real2, out_imag2); 498 dct4_kernel(real2, imag2);
536 499
537 500 p_buf_1 = qmfs->v + qmfs->v_index;
538 pring_buffer_1 = qmfs->v + qmfs->v_index; 501 p_buf_3 = p_buf_1 + 1280;
539 pring_buffer_3 = pring_buffer_1 + 1280;
540#ifdef PREFER_POINTERS
541 pring_buffer_2 = pring_buffer_1 + 127;
542 pring_buffer_4 = pring_buffer_1 + (1280 + 127);
543#endif // #ifdef PREFER_POINTERS
544// ptemp_1 = x1;
545// ptemp_2 = x2;
546#ifdef PREFER_POINTERS
547 for (n = 0; n < 32; n ++)
548 {
549 //real_t x1 = *ptemp_1++;
550 //real_t x2 = *ptemp_2++;
551 // pring_buffer_3 and pring_buffer_4 are needed only for double ring buffer
552 *pring_buffer_1++ = *pring_buffer_3++ = out_real2[n] - out_real1[n];
553 *pring_buffer_2-- = *pring_buffer_4-- = out_real2[n] + out_real1[n];
554 //x1 = *ptemp_1++;
555 //x2 = *ptemp_2++;
556 *pring_buffer_1++ = *pring_buffer_3++ = out_imag2[31-n] + out_imag1[31-n];
557 *pring_buffer_2-- = *pring_buffer_4-- = out_imag2[31-n] - out_imag1[31-n];
558 }
559#else // #ifdef PREFER_POINTERS
560 502
503 idx0 = 0; idx1 = 127;
561 for (n = 0; n < 32; n++) 504 for (n = 0; n < 32; n++)
562 { 505 {
563 // pring_buffer_3 and pring_buffer_4 are needed only for double ring buffer 506 p_buf_1[idx0] = p_buf_3[idx0] = real2[ n] - real1[ n]; idx0++;
564 pring_buffer_1[2*n] = pring_buffer_3[2*n] = out_real2[n] - out_real1[n]; 507 p_buf_1[idx1] = p_buf_3[idx1] = real2[ n] + real1[ n]; idx1--;
565 pring_buffer_1[127-2*n] = pring_buffer_3[127-2*n] = out_real2[n] + out_real1[n]; 508 p_buf_1[idx0] = p_buf_3[idx0] = imag2[31-n] + imag1[31-n]; idx0++;
566 pring_buffer_1[2*n+1] = pring_buffer_3[2*n+1] = out_imag2[31-n] + out_imag1[31-n]; 509 p_buf_1[idx1] = p_buf_3[idx1] = imag2[31-n] - imag1[31-n]; idx1--;
567 pring_buffer_1[127-(2*n+1)] = pring_buffer_3[127-(2*n+1)] = out_imag2[31-n] - out_imag1[31-n];
568 } 510 }
569 511
570#endif // #ifdef PREFER_POINTERS 512 p_buf_1 = qmfs->v + qmfs->v_index;
571
572 pring_buffer_1 = qmfs->v + qmfs->v_index;
573#ifdef PREFER_POINTERS
574 pring_buffer_2 = pring_buffer_1 + 192;
575 pring_buffer_3 = pring_buffer_1 + 256;
576 pring_buffer_4 = pring_buffer_1 + (256 + 192);
577 pring_buffer_5 = pring_buffer_1 + 512;
578 pring_buffer_6 = pring_buffer_1 + (512 + 192);
579 pring_buffer_7 = pring_buffer_1 + 768;
580 pring_buffer_8 = pring_buffer_1 + (768 + 192);
581 pring_buffer_9 = pring_buffer_1 + 1024;
582 pring_buffer_10 = pring_buffer_1 + (1024 + 192);
583 pqmf_c_1 = qmf_c;
584 pqmf_c_2 = qmf_c + 64;
585 pqmf_c_3 = qmf_c + 128;
586 pqmf_c_4 = qmf_c + 192;
587 pqmf_c_5 = qmf_c + 256;
588 pqmf_c_6 = qmf_c + 320;
589 pqmf_c_7 = qmf_c + 384;
590 pqmf_c_8 = qmf_c + 448;
591 pqmf_c_9 = qmf_c + 512;
592 pqmf_c_10 = qmf_c + 576;
593#endif // #ifdef PREFER_POINTERS
594 513
595 /* calculate 64 output samples and window */ 514 /* calculate 64 output samples and window */
596 for (k = 0; k < 64; k++) 515 for (k = 0; k < 64; k++)
597 { 516 {
598#ifdef PREFER_POINTERS 517 output[out++] = FAAD_SYNTHESIS_SCALE(
599 output[out++] = 518 MUL_F(p_buf_1[k ], qmf_c[k ]) +
600 MUL_F(*pring_buffer_1++, *pqmf_c_1++) + 519 MUL_F(p_buf_1[k+ 192 ], qmf_c[k+ 64]) +
601 MUL_F(*pring_buffer_2++, *pqmf_c_2++) + 520 MUL_F(p_buf_1[k+ 256 ], qmf_c[k+128]) +
602 MUL_F(*pring_buffer_3++, *pqmf_c_3++) + 521 MUL_F(p_buf_1[k+ 256+192], qmf_c[k+192]) +
603 MUL_F(*pring_buffer_4++, *pqmf_c_4++) + 522 MUL_F(p_buf_1[k+ 512 ], qmf_c[k+256]) +
604 MUL_F(*pring_buffer_5++, *pqmf_c_5++) + 523 MUL_F(p_buf_1[k+ 512+192], qmf_c[k+320]) +
605 MUL_F(*pring_buffer_6++, *pqmf_c_6++) + 524 MUL_F(p_buf_1[k+ 768 ], qmf_c[k+384]) +
606 MUL_F(*pring_buffer_7++, *pqmf_c_7++) + 525 MUL_F(p_buf_1[k+ 768+192], qmf_c[k+448]) +
607 MUL_F(*pring_buffer_8++, *pqmf_c_8++) + 526 MUL_F(p_buf_1[k+1024 ], qmf_c[k+512]) +
608 MUL_F(*pring_buffer_9++, *pqmf_c_9++) + 527 MUL_F(p_buf_1[k+1024+192], qmf_c[k+576]));
609 MUL_F(*pring_buffer_10++, *pqmf_c_10++);
610#else // #ifdef PREFER_POINTERS
611 output[out++] =
612 MUL_F(pring_buffer_1[k+0], qmf_c[k+0]) +
613 MUL_F(pring_buffer_1[k+192], qmf_c[k+64]) +
614 MUL_F(pring_buffer_1[k+256], qmf_c[k+128]) +
615 MUL_F(pring_buffer_1[k+(256+192)], qmf_c[k+192]) +
616 MUL_F(pring_buffer_1[k+512], qmf_c[k+256]) +
617 MUL_F(pring_buffer_1[k+(512+192)], qmf_c[k+320]) +
618 MUL_F(pring_buffer_1[k+768], qmf_c[k+384]) +
619 MUL_F(pring_buffer_1[k+(768+192)], qmf_c[k+448]) +
620 MUL_F(pring_buffer_1[k+1024], qmf_c[k+512]) +
621 MUL_F(pring_buffer_1[k+(1024+192)], qmf_c[k+576]);
622#endif // #ifdef PREFER_POINTERS
623 } 528 }
624 529
625 /* update ringbuffer index */ 530 /* update ringbuffer index */
@@ -628,6 +533,6 @@ void sbr_qmf_synthesis_64(sbr_info *sbr, qmfs_info *qmfs, qmf_t X[MAX_NTSRHFG][6
628 qmfs->v_index = (1280 - 128); 533 qmfs->v_index = (1280 - 128);
629 } 534 }
630} 535}
631#endif 536#endif /* #ifdef SBR_LOW_POWER */
632 537
633#endif 538#endif /* #ifdef SBR_DEC */
generated by cgit v1.2.3 (git 2.39.1) at 2024-09-17 21:46:22 +0000