Mercurial > mplayer.hg

comparison libfaad2/sbr_e_nf.c @ 10989:3185f64f6350

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
synced with current cvs
author alex
date Fri, 03 Oct 2003 22:23:26 +0000
parents e989150f8216
children 4a370c80fe5c
comparison
equal deleted inserted replaced
10988:c2bff70784d5 10989:3185f64f6350
20 ** forbidden. 20 ** forbidden.
21 ** 21 **
22 ** Commercial non-GPL licensing of this software is possible. 22 ** Commercial non-GPL licensing of this software is possible.
23 ** For more info contact Ahead Software through Mpeg4AAClicense@nero.com. 23 ** For more info contact Ahead Software through Mpeg4AAClicense@nero.com.
24 ** 24 **
25 ** $Id: sbr_e_nf.c,v 1.1 2003/07/29 08:20:13 menno Exp $ 25 ** $Id: sbr_e_nf.c,v 1.4 2003/09/09 18:37:32 menno Exp $
26 **/ 26 **/
27 27
28 #include "common.h" 28 #include "common.h"
29 #include "structs.h" 29 #include "structs.h"
30 30
36 #include "sbr_e_nf.h" 36 #include "sbr_e_nf.h"
37 37
38 void extract_envelope_data(sbr_info *sbr, uint8_t ch) 38 void extract_envelope_data(sbr_info *sbr, uint8_t ch)
39 { 39 {
40 uint8_t l, k; 40 uint8_t l, k;
41
42 #if 0
43 if (sbr->frame == 19)
44 {
45 sbr->frame = 19;
46 }
47 #endif
48 41
49 for (l = 0; l < sbr->L_E[ch]; l++) 42 for (l = 0; l < sbr->L_E[ch]; l++)
50 { 43 {
51 if (sbr->bs_df_env[ch][l] == 0) 44 if (sbr->bs_df_env[ch][l] == 0)
52 { 45 {
111 } 104 }
112 } 105 }
113 } 106 }
114 } 107 }
115 } 108 }
116
117 #if 0
118 if (sbr->frame == 23)
119 {
120 int l, k;
121
122 for (l = 0; l < sbr->L_E[ch]; l++)
123 {
124 for (k = 0; k < sbr->n[sbr->f[ch][l]]; k++)
125 {
126 //printf("l:%d k:%d E:%d\n",l,k, sbr->E[ch][k][l]);
127 printf("%d\n", sbr->E[ch][k][l]);
128 }
129 }
130 printf("\n");
131 }
132 #endif
133 } 109 }
134 110
135 void extract_noise_floor_data(sbr_info *sbr, uint8_t ch) 111 void extract_noise_floor_data(sbr_info *sbr, uint8_t ch)
136 { 112 {
137 uint8_t l, k; 113 uint8_t l, k;
157 sbr->Q[ch][k][l] = sbr->Q[ch][k][l - 1] + sbr->Q[ch][k][l]; 133 sbr->Q[ch][k][l] = sbr->Q[ch][k][l - 1] + sbr->Q[ch][k][l];
158 } 134 }
159 } 135 }
160 } 136 }
161 } 137 }
162
163 #if 0
164 if (sbr->frame == 23)
165 {
166 int l, k;
167
168 for (l = 0; l < sbr->L_Q[ch]; l++)
169 {
170 for (k = 0; k < sbr->N_Q; k++)
171 {
172 //printf("l:%d k:%d E:%d\n",l,k, sbr->E[ch][k][l]);
173 printf("%d\n", sbr->Q[ch][k][l]);
174 }
175 }
176 printf("\n");
177 }
178 #endif
179 } 138 }
180 139
181 /* FIXME: pow() not needed */ 140 /* FIXME: pow() not needed */
182 void envelope_noise_dequantisation(sbr_info *sbr, uint8_t ch) 141 void envelope_noise_dequantisation(sbr_info *sbr, uint8_t ch)
183 { 142 {
184 if (sbr->bs_coupling == 0) 143 if (sbr->bs_coupling == 0)
185 { 144 {
186 uint8_t l, k; 145 uint8_t l, k;
187 #ifdef FIXED_POINT 146 real_t amp = (sbr->amp_res[ch]) ? 1.0f : 0.5f;
188 uint8_t amp = (sbr->amp_res[ch]) ? 0 : 1;
189 #else
190 real_t amp = (sbr->amp_res[ch]) ? 1.0 : 0.5;
191 #endif
192 147
193 for (l = 0; l < sbr->L_E[ch]; l++) 148 for (l = 0; l < sbr->L_E[ch]; l++)
194 { 149 {
195 for (k = 0; k < sbr->n[sbr->f[ch][l]]; k++) 150 for (k = 0; k < sbr->n[sbr->f[ch][l]]; k++)
196 { 151 {
197 #ifndef FIXED_POINT
198 /* +6 for the *64 */ 152 /* +6 for the *64 */
199 sbr->E_orig[ch][k][l] = pow(2, sbr->E[ch][k][l]*amp + 6); 153 sbr->E_orig[ch][k][l] = (real_t)pow(2, sbr->E[ch][k][l]*amp + 6);
200 #else
201 int8_t exp;
202
203 /* +6 for the *64 and -10 for the /32 in the synthesis QMF
204 * since this is a energy value: (x/32)^2 = (x^2)/1024
205 */
206 exp = (sbr->E[ch][k][l] >> amp) + 6 - 10;
207
208 // printf("%d\n", exp);
209
210 if (exp < 0)
211 sbr->E_orig[ch][k][l] = 0; //REAL_CONST(1) >> -exp;
212 else
213 sbr->E_orig[ch][k][l] = 1 << exp; //REAL_CONST(1) << exp;
214
215 if (amp && (sbr->E[ch][k][l] & 1))
216 sbr->E_orig[ch][k][l] = MUL(sbr->E_orig[ch][k][l], REAL_CONST(1.414213562));
217 #endif
218 } 154 }
219 } 155 }
220 156
221 for (l = 0; l < sbr->L_Q[ch]; l++) 157 for (l = 0; l < sbr->L_Q[ch]; l++)
222 { 158 {
223 for (k = 0; k < sbr->N_Q; k++) 159 for (k = 0; k < sbr->N_Q; k++)
224 { 160 {
225 if (sbr->Q[ch][k][l] < 0 || sbr->Q[ch][k][l] > 30) 161 if (sbr->Q[ch][k][l] < 0 || sbr->Q[ch][k][l] > 30)
226 sbr->Q_orig[ch][k][l] = 0; 162 sbr->Q_orig[ch][k][l] = 0;
227 else { 163 else {
228 #ifndef FIXED_POINT 164 sbr->Q_orig[ch][k][l] = (real_t)pow(2, NOISE_FLOOR_OFFSET - sbr->Q[ch][k][l]);
229 sbr->Q_orig[ch][k][l] = pow(2, NOISE_FLOOR_OFFSET - sbr->Q[ch][k][l]);
230 #else
231 int8_t exp = NOISE_FLOOR_OFFSET - sbr->Q[ch][k][l];
232 if (exp < 0)
233 sbr->Q_orig[ch][k][l] = REAL_CONST(1) >> -exp;
234 else
235 sbr->Q_orig[ch][k][l] = REAL_CONST(1) << exp;
236 #endif
237 } 165 }
238 } 166 }
239 } 167 }
240 } 168 }
241 } 169 }
242 170
243 void unmap_envelope_noise(sbr_info *sbr) 171 void unmap_envelope_noise(sbr_info *sbr)
244 { 172 {
245 uint8_t l, k; 173 uint8_t l, k;
246 #ifdef FIXED_POINT 174 real_t amp0 = (sbr->amp_res[0]) ? (real_t)1.0 : (real_t)0.5;
247 uint8_t amp0 = (sbr->amp_res[0]) ? 0 : 1; 175 real_t amp1 = (sbr->amp_res[1]) ? (real_t)1.0 : (real_t)0.5;
248 uint8_t amp1 = (sbr->amp_res[1]) ? 0 : 1;
249 #else
250 real_t amp0 = (sbr->amp_res[0]) ? 1.0 : 0.5;
251 real_t amp1 = (sbr->amp_res[1]) ? 1.0 : 0.5;
252 #endif
253 176
254 for (l = 0; l < sbr->L_E[0]; l++) 177 for (l = 0; l < sbr->L_E[0]; l++)
255 { 178 {
256 for (k = 0; k < sbr->n[sbr->f[0][l]]; k++) 179 for (k = 0; k < sbr->n[sbr->f[0][l]]; k++)
257 { 180 {
258 real_t l_temp, r_temp; 181 real_t l_temp, r_temp;
259 182
260 #ifdef FIXED_POINT 183 /* +6: * 64 ; +1: * 2 */
261 int8_t exp; 184 l_temp = (real_t)pow(2, sbr->E[0][k][l]*amp0 + 7);
262
263 /* +6: * 64 ; +1: * 2 ; -10: /1024 QMF */
264 exp = (sbr->E[0][k][l] >> amp0) - 3;
265
266 // printf("%d\n", exp);
267
268 if (exp < 0)
269 l_temp = REAL_CONST(1) >> -exp;
270 else
271 l_temp = REAL_CONST(1) << exp;
272
273 if (amp0 && (sbr->E[0][k][l] & 1))
274 l_temp = MUL(l_temp, REAL_CONST(1.414213562373095));
275
276 /* UN_MAP removed: (x / 4096) same as (x >> 12) */ 185 /* UN_MAP removed: (x / 4096) same as (x >> 12) */
277 exp = (sbr->E[1][k][l] >> amp1) - 12; 186 r_temp = (real_t)pow(2, sbr->E[1][k][l]*amp1 - 12);
278 187
279 // printf("%d\n", exp); 188 sbr->E_orig[1][k][l] = l_temp / ((real_t)1.0 + r_temp);
280
281 if (exp < 0)
282 r_temp = REAL_CONST(1) >> -exp;
283 else
284 r_temp = REAL_CONST(1) << exp;
285
286 if (amp1 && (sbr->E[1][k][l] & 1))
287 r_temp = MUL(r_temp, REAL_CONST(1.414213562373095));
288 #else
289 /* +6: * 64 ; +1: * 2 */
290 l_temp = pow(2, sbr->E[0][k][l]*amp0 + 7);
291 /* UN_MAP removed: (x / 4096) same as (x >> 12) */
292 r_temp = pow(2, sbr->E[1][k][l]*amp1 - 12);
293 #endif
294
295
296 #ifdef FIXED_POINT
297 {
298 real_t tmp = REAL_CONST(1.0) + r_temp;
299 sbr->E_orig[1][k][l] = SBR_DIV(l_temp, tmp);
300 }
301 #else
302 sbr->E_orig[1][k][l] = l_temp / (1.0 + r_temp);
303 #endif
304 sbr->E_orig[0][k][l] = MUL(r_temp, sbr->E_orig[1][k][l]); 189 sbr->E_orig[0][k][l] = MUL(r_temp, sbr->E_orig[1][k][l]);
305
306 #ifdef FIXED_POINT
307 sbr->E_orig[0][k][l] >>= REAL_BITS;
308 sbr->E_orig[1][k][l] >>= REAL_BITS;
309 #endif
310
311 //printf("%f\t%f\n", sbr->E_orig[0][k][l] /(float)(1<<REAL_BITS), sbr->E_orig[1][k][l] /(float)(1<<REAL_BITS));
312 //printf("%f\t%f\n", sbr->E_orig[0][k][l]/1024., sbr->E_orig[1][k][l]/1024.);
313 } 190 }
314 } 191 }
315 for (l = 0; l < sbr->L_Q[0]; l++) 192 for (l = 0; l < sbr->L_Q[0]; l++)
316 { 193 {
317 for (k = 0; k < sbr->N_Q; k++) 194 for (k = 0; k < sbr->N_Q; k++)
322 sbr->Q_orig[0][k][l] = 0; 199 sbr->Q_orig[0][k][l] = 0;
323 sbr->Q_orig[1][k][l] = 0; 200 sbr->Q_orig[1][k][l] = 0;
324 } else { 201 } else {
325 real_t l_temp, r_temp; 202 real_t l_temp, r_temp;
326 203
327 #ifndef FIXED_POINT 204 l_temp = (real_t)pow(2.0, NOISE_FLOOR_OFFSET - sbr->Q[0][k][l] + 1);
328 l_temp = pow(2.0, NOISE_FLOOR_OFFSET - sbr->Q[0][k][l] + 1); 205 r_temp = (real_t)pow(2.0, sbr->Q[1][k][l] - 12);
329 r_temp = pow(2.0, sbr->Q[1][k][l] - 12); 206
330 #else 207 sbr->Q_orig[1][k][l] = l_temp / ((real_t)1.0 + r_temp);
331 int8_t exp; 208 sbr->Q_orig[0][k][l] = MUL(r_temp, sbr->Q_orig[1][k][l]);
332 209 }
333 exp = NOISE_FLOOR_OFFSET - sbr->Q[0][k][l] + 1; 210 }
334 if (exp < 0) 211 }
335 l_temp = REAL_CONST(1) >> -exp; 212 }
336 else 213
337 l_temp = REAL_CONST(1) << exp;
338
339 exp = sbr->Q[1][k][l] - 12;
340 if (exp < 0)
341 r_temp = REAL_CONST(1) >> -exp;
342 else
343 r_temp = REAL_CONST(1) << exp;
344 #endif 214 #endif
345
346 #ifdef FIXED_POINT
347 sbr->Q_orig[1][k][l] = SBR_DIV(l_temp, (REAL_CONST(1.0) + r_temp));
348 #else
349 sbr->Q_orig[1][k][l] = l_temp / (1.0 + r_temp);
350 #endif
351 sbr->Q_orig[0][k][l] = MUL(r_temp, sbr->Q_orig[1][k][l]);
352 }
353 }
354 }
355 }
356
357 #endif