diff options
Diffstat (limited to 'apps/codecs/libfaad/sbr_qmf.c')
-rw-r--r-- | apps/codecs/libfaad/sbr_qmf.c | 371 |
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 | |||
41 | qmfa_info *qmfa_init(uint8_t channels) | 51 | qmfa_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 | |||
388 | void sbr_qmf_synthesis_32(sbr_info *sbr, qmfs_info *qmfs, qmf_t X[MAX_NTSRHFG][64], | 399 | void 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 | |||
454 | void sbr_qmf_synthesis_64(sbr_info *sbr, qmfs_info *qmfs, qmf_t X[MAX_NTSRHFG][64], | 465 | void 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 */ |