Mercurial > audlegacy
comparison Plugins/Input/aac/libfaad2/sbr_qmf.c @ 61:fa848bd484d8 trunk
[svn] Move plugins to Plugins/
author | nenolod |
---|---|
date | Fri, 28 Oct 2005 22:58:11 -0700 |
parents | |
children | 0a2ad94e8607 |
comparison
equal
deleted
inserted
replaced
60:1771f253e1b2 | 61:fa848bd484d8 |
---|---|
1 /* | |
2 ** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding | |
3 ** Copyright (C) 2003 M. Bakker, Ahead Software AG, http://www.nero.com | |
4 ** | |
5 ** This program is free software; you can redistribute it and/or modify | |
6 ** it under the terms of the GNU General Public License as published by | |
7 ** the Free Software Foundation; either version 2 of the License, or | |
8 ** (at your option) any later version. | |
9 ** | |
10 ** This program is distributed in the hope that it will be useful, | |
11 ** but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 ** GNU General Public License for more details. | |
14 ** | |
15 ** You should have received a copy of the GNU General Public License | |
16 ** along with this program; if not, write to the Free Software | |
17 ** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. | |
18 ** | |
19 ** Any non-GPL usage of this software or parts of this software is strictly | |
20 ** forbidden. | |
21 ** | |
22 ** Commercial non-GPL licensing of this software is possible. | |
23 ** For more info contact Ahead Software through Mpeg4AAClicense@nero.com. | |
24 ** | |
25 ** $Id: sbr_qmf.c,v 1.17 2003/11/12 20:47:58 menno Exp $ | |
26 **/ | |
27 | |
28 #include "common.h" | |
29 #include "structs.h" | |
30 | |
31 #ifdef SBR_DEC | |
32 | |
33 | |
34 #include <stdlib.h> | |
35 #include <string.h> | |
36 #include "sbr_dct.h" | |
37 #include "sbr_qmf.h" | |
38 #include "sbr_qmf_c.h" | |
39 #include "sbr_syntax.h" | |
40 | |
41 | |
42 qmfa_info *qmfa_init(uint8_t channels) | |
43 { | |
44 qmfa_info *qmfa = (qmfa_info*)malloc(sizeof(qmfa_info)); | |
45 qmfa->x = (real_t*)malloc(channels * 10 * sizeof(real_t)); | |
46 memset(qmfa->x, 0, channels * 10 * sizeof(real_t)); | |
47 | |
48 qmfa->channels = channels; | |
49 | |
50 return qmfa; | |
51 } | |
52 | |
53 void qmfa_end(qmfa_info *qmfa) | |
54 { | |
55 if (qmfa) | |
56 { | |
57 if (qmfa->x) free(qmfa->x); | |
58 free(qmfa); | |
59 } | |
60 } | |
61 | |
62 void sbr_qmf_analysis_32(sbr_info *sbr, qmfa_info *qmfa, const real_t *input, | |
63 qmf_t X[MAX_NTSRHFG][32], uint8_t offset, uint8_t kx) | |
64 { | |
65 real_t u[64]; | |
66 #ifndef SBR_LOW_POWER | |
67 real_t x[64], y[64]; | |
68 #else | |
69 real_t y[32]; | |
70 #endif | |
71 uint16_t in = 0; | |
72 uint8_t l; | |
73 | |
74 /* qmf subsample l */ | |
75 for (l = 0; l < sbr->numTimeSlotsRate; l++) | |
76 { | |
77 int16_t n; | |
78 | |
79 /* shift input buffer x */ | |
80 memmove(qmfa->x + 32, qmfa->x, (320-32)*sizeof(real_t)); | |
81 | |
82 /* add new samples to input buffer x */ | |
83 for (n = 32 - 1; n >= 0; n--) | |
84 { | |
85 #ifdef FIXED_POINT | |
86 qmfa->x[n] = (input[in++]) >> 5; | |
87 #else | |
88 qmfa->x[n] = input[in++]; | |
89 #endif | |
90 } | |
91 | |
92 /* window and summation to create array u */ | |
93 for (n = 0; n < 64; n++) | |
94 { | |
95 u[n] = MUL_F(qmfa->x[n], qmf_c[2*n]) + | |
96 MUL_F(qmfa->x[n + 64], qmf_c[2*(n + 64)]) + | |
97 MUL_F(qmfa->x[n + 128], qmf_c[2*(n + 128)]) + | |
98 MUL_F(qmfa->x[n + 192], qmf_c[2*(n + 192)]) + | |
99 MUL_F(qmfa->x[n + 256], qmf_c[2*(n + 256)]); | |
100 } | |
101 | |
102 /* calculate 32 subband samples by introducing X */ | |
103 #ifdef SBR_LOW_POWER | |
104 y[0] = u[48]; | |
105 for (n = 1; n < 16; n++) | |
106 y[n] = u[n+48] + u[48-n]; | |
107 for (n = 16; n < 32; n++) | |
108 y[n] = -u[n-16] + u[48-n]; | |
109 | |
110 DCT3_32_unscaled(u, y); | |
111 | |
112 for (n = 0; n < 32; n++) | |
113 { | |
114 if (n < kx) | |
115 { | |
116 #ifdef FIXED_POINT | |
117 QMF_RE(X[l + offset][n]) = u[n] << 1; | |
118 #else | |
119 QMF_RE(X[l + offset][n]) = 2. * u[n]; | |
120 #endif | |
121 } else { | |
122 QMF_RE(X[l + offset][n]) = 0; | |
123 } | |
124 } | |
125 #else | |
126 x[0] = u[0]; | |
127 for (n = 0; n < 31; n++) | |
128 { | |
129 x[2*n+1] = u[n+1] + u[63-n]; | |
130 x[2*n+2] = u[n+1] - u[63-n]; | |
131 } | |
132 x[63] = u[32]; | |
133 | |
134 DCT4_64_kernel(y, x); | |
135 | |
136 for (n = 0; n < 32; n++) | |
137 { | |
138 if (n < kx) | |
139 { | |
140 #ifdef FIXED_POINT | |
141 QMF_RE(X[l + offset][n]) = y[n] << 1; | |
142 QMF_IM(X[l + offset][n]) = -y[63-n] << 1; | |
143 #else | |
144 QMF_RE(X[l + offset][n]) = 2. * y[n]; | |
145 QMF_IM(X[l + offset][n]) = -2. * y[63-n]; | |
146 #endif | |
147 } else { | |
148 QMF_RE(X[l + offset][n]) = 0; | |
149 QMF_IM(X[l + offset][n]) = 0; | |
150 } | |
151 } | |
152 #endif | |
153 } | |
154 } | |
155 | |
156 qmfs_info *qmfs_init(uint8_t channels) | |
157 { | |
158 qmfs_info *qmfs = (qmfs_info*)malloc(sizeof(qmfs_info)); | |
159 | |
160 qmfs->v[0] = (real_t*)malloc(channels * 10 * sizeof(real_t)); | |
161 memset(qmfs->v[0], 0, channels * 10 * sizeof(real_t)); | |
162 qmfs->v[1] = (real_t*)malloc(channels * 10 * sizeof(real_t)); | |
163 memset(qmfs->v[1], 0, channels * 10 * sizeof(real_t)); | |
164 | |
165 qmfs->v_index = 0; | |
166 | |
167 qmfs->channels = channels; | |
168 | |
169 return qmfs; | |
170 } | |
171 | |
172 void qmfs_end(qmfs_info *qmfs) | |
173 { | |
174 if (qmfs) | |
175 { | |
176 if (qmfs->v[0]) free(qmfs->v[0]); | |
177 if (qmfs->v[1]) free(qmfs->v[1]); | |
178 free(qmfs); | |
179 } | |
180 } | |
181 | |
182 #ifdef SBR_LOW_POWER | |
183 void sbr_qmf_synthesis_64(sbr_info *sbr, qmfs_info *qmfs, const qmf_t X[MAX_NTSRHFG][64], | |
184 real_t *output) | |
185 { | |
186 real_t x[64]; | |
187 int16_t n, k, out = 0; | |
188 uint8_t l; | |
189 | |
190 | |
191 /* qmf subsample l */ | |
192 for (l = 0; l < sbr->numTimeSlotsRate; l++) | |
193 { | |
194 real_t *v0, *v1; | |
195 | |
196 /* shift buffers */ | |
197 memmove(qmfs->v[0] + 64, qmfs->v[0], (640-64)*sizeof(real_t)); | |
198 memmove(qmfs->v[1] + 64, qmfs->v[1], (640-64)*sizeof(real_t)); | |
199 | |
200 v0 = qmfs->v[qmfs->v_index]; | |
201 v1 = qmfs->v[(qmfs->v_index + 1) & 0x1]; | |
202 qmfs->v_index = (qmfs->v_index + 1) & 0x1; | |
203 | |
204 /* calculate 128 samples */ | |
205 for (k = 0; k < 64; k++) | |
206 { | |
207 #ifdef FIXED_POINT | |
208 x[k] = QMF_RE(X[l][k]); | |
209 #else | |
210 x[k] = QMF_RE(X[l][k]) / 32.; | |
211 #endif | |
212 } | |
213 | |
214 DCT2_64_unscaled(x, x); | |
215 | |
216 for (n = 0; n < 32; n++) | |
217 { | |
218 v0[n+32] = x[n]; | |
219 v1[n] = x[n+32]; | |
220 } | |
221 v0[0] = v1[0]; | |
222 for (n = 1; n < 32; n++) | |
223 { | |
224 v0[32 - n] = v0[n + 32]; | |
225 v1[n + 32] = -v1[32 - n]; | |
226 } | |
227 v1[32] = 0; | |
228 | |
229 /* calculate 64 output samples and window */ | |
230 for (k = 0; k < 64; k++) | |
231 { | |
232 output[out++] = MUL_F(v0[k], qmf_c[k]) + | |
233 MUL_F(v0[64 + k], qmf_c[64 + k]) + | |
234 MUL_F(v0[128 + k], qmf_c[128 + k]) + | |
235 MUL_F(v0[192 + k], qmf_c[192 + k]) + | |
236 MUL_F(v0[256 + k], qmf_c[256 + k]) + | |
237 MUL_F(v0[320 + k], qmf_c[320 + k]) + | |
238 MUL_F(v0[384 + k], qmf_c[384 + k]) + | |
239 MUL_F(v0[448 + k], qmf_c[448 + k]) + | |
240 MUL_F(v0[512 + k], qmf_c[512 + k]) + | |
241 MUL_F(v0[576 + k], qmf_c[576 + k]); | |
242 } | |
243 } | |
244 } | |
245 #else | |
246 void sbr_qmf_synthesis_64(sbr_info *sbr, qmfs_info *qmfs, const qmf_t X[MAX_NTSRHFG][64], | |
247 real_t *output) | |
248 { | |
249 real_t x1[64], x2[64]; | |
250 real_t scale = 1.f/64.f; | |
251 int16_t n, k, out = 0; | |
252 uint8_t l; | |
253 | |
254 | |
255 /* qmf subsample l */ | |
256 for (l = 0; l < sbr->numTimeSlotsRate; l++) | |
257 { | |
258 real_t *v0, *v1; | |
259 | |
260 /* shift buffers */ | |
261 memmove(qmfs->v[0] + 64, qmfs->v[0], (640-64)*sizeof(real_t)); | |
262 memmove(qmfs->v[1] + 64, qmfs->v[1], (640-64)*sizeof(real_t)); | |
263 | |
264 v0 = qmfs->v[qmfs->v_index]; | |
265 v1 = qmfs->v[(qmfs->v_index + 1) & 0x1]; | |
266 qmfs->v_index = (qmfs->v_index + 1) & 0x1; | |
267 | |
268 /* calculate 128 samples */ | |
269 x1[0] = scale*QMF_RE(X[l][0]); | |
270 x2[63] = scale*QMF_IM(X[l][0]); | |
271 for (k = 0; k < 31; k++) | |
272 { | |
273 x1[2*k+1] = scale*(QMF_RE(X[l][2*k+1]) - QMF_RE(X[l][2*k+2])); | |
274 x1[2*k+2] = scale*(QMF_RE(X[l][2*k+1]) + QMF_RE(X[l][2*k+2])); | |
275 | |
276 x2[61 - 2*k] = scale*(QMF_IM(X[l][2*k+2]) - QMF_IM(X[l][2*k+1])); | |
277 x2[62 - 2*k] = scale*(QMF_IM(X[l][2*k+2]) + QMF_IM(X[l][2*k+1])); | |
278 } | |
279 x1[63] = scale*QMF_RE(X[l][63]); | |
280 x2[0] = scale*QMF_IM(X[l][63]); | |
281 | |
282 DCT4_64_kernel(x1, x1); | |
283 DCT4_64_kernel(x2, x2); | |
284 | |
285 for (n = 0; n < 32; n++) | |
286 { | |
287 v0[ 2*n] = x2[2*n] - x1[2*n]; | |
288 v1[63-2*n] = x2[2*n] + x1[2*n]; | |
289 v0[ 2*n+1] = -x2[2*n+1] - x1[2*n+1]; | |
290 v1[62-2*n] = -x2[2*n+1] + x1[2*n+1]; | |
291 } | |
292 | |
293 /* calculate 64 output samples and window */ | |
294 for (k = 0; k < 64; k++) | |
295 { | |
296 output[out++] = MUL_F(v0[k], qmf_c[k]) + | |
297 MUL_F(v0[64 + k], qmf_c[64 + k]) + | |
298 MUL_F(v0[128 + k], qmf_c[128 + k]) + | |
299 MUL_F(v0[192 + k], qmf_c[192 + k]) + | |
300 MUL_F(v0[256 + k], qmf_c[256 + k]) + | |
301 MUL_F(v0[320 + k], qmf_c[320 + k]) + | |
302 MUL_F(v0[384 + k], qmf_c[384 + k]) + | |
303 MUL_F(v0[448 + k], qmf_c[448 + k]) + | |
304 MUL_F(v0[512 + k], qmf_c[512 + k]) + | |
305 MUL_F(v0[576 + k], qmf_c[576 + k]); | |
306 } | |
307 } | |
308 } | |
309 #endif | |
310 | |
311 #endif |