Mercurial > mplayer.hg
comparison libfaad2/sbr_syntax.c @ 10989:3185f64f6350
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_syntax.c,v 1.7 2003/07/29 08:20:13 menno Exp $ | 25 ** $Id: sbr_syntax.c,v 1.11 2003/09/30 16:32:02 menno Exp $ |
26 **/ | 26 **/ |
27 | 27 |
28 #include "common.h" | 28 #include "common.h" |
29 #include "structs.h" | 29 #include "structs.h" |
30 | 30 |
78 } | 78 } |
79 | 79 |
80 /* table 2 */ | 80 /* table 2 */ |
81 uint8_t sbr_extension_data(bitfile *ld, sbr_info *sbr, uint8_t id_aac) | 81 uint8_t sbr_extension_data(bitfile *ld, sbr_info *sbr, uint8_t id_aac) |
82 { | 82 { |
83 uint8_t result; | |
84 #ifdef DRM | |
85 uint8_t crc_len; | |
86 | |
87 if (sbr->Is_DRM_SBR) | |
88 faad_getbits(ld, 8); /* 8-bit CRC */ | |
89 else | |
90 #endif | |
91 { | |
83 uint8_t bs_extension_type = (uint8_t)faad_getbits(ld, 4 | 92 uint8_t bs_extension_type = (uint8_t)faad_getbits(ld, 4 |
84 DEBUGVAR(1,198,"sbr_bitstream(): bs_extension_type")); | 93 DEBUGVAR(1,198,"sbr_bitstream(): bs_extension_type")); |
85 | 94 |
86 if (bs_extension_type == EXT_SBR_DATA_CRC) | 95 if (bs_extension_type == EXT_SBR_DATA_CRC) |
87 { | 96 { |
88 sbr->bs_sbr_crc_bits = (uint16_t)faad_getbits(ld, 10 | 97 sbr->bs_sbr_crc_bits = (uint16_t)faad_getbits(ld, 10 |
89 DEBUGVAR(1,199,"sbr_bitstream(): bs_sbr_crc_bits")); | 98 DEBUGVAR(1,199,"sbr_bitstream(): bs_sbr_crc_bits")); |
90 } | 99 } |
100 } | |
91 | 101 |
92 sbr->bs_header_flag = faad_get1bit(ld | 102 sbr->bs_header_flag = faad_get1bit(ld |
93 DEBUGVAR(1,200,"sbr_bitstream(): bs_header_flag")); | 103 DEBUGVAR(1,200,"sbr_bitstream(): bs_header_flag")); |
104 | |
105 #ifdef DRM | |
106 if (sbr->Is_DRM_SBR) | |
107 { | |
108 /* Check CRC, get number of bits for check */ | |
109 if (id_aac == ID_SCE) | |
110 { | |
111 if (sbr->lcstereo_flag) | |
112 { | |
113 if (sbr->bs_header_flag) | |
114 crc_len = min(76, sbr->data_size_bits); | |
115 else | |
116 crc_len = min(47, sbr->data_size_bits); | |
117 } else { | |
118 if (sbr->bs_header_flag) | |
119 crc_len = min(74, sbr->data_size_bits); | |
120 else | |
121 crc_len = min(47, sbr->data_size_bits); | |
122 } | |
123 } else { | |
124 if (sbr->bs_header_flag) | |
125 crc_len = min(120, sbr->data_size_bits); | |
126 else | |
127 crc_len = min(93, sbr->data_size_bits); | |
128 } | |
129 | |
130 if ((result = faad_check_CRC(ld, crc_len)) > 0) | |
131 return result; | |
132 | |
133 /* Rewind and read bits again to set correct position in bit-stream */ | |
134 faad_rewindbits(ld); | |
135 faad_getbits(ld, 8); | |
136 faad_get1bit(ld); | |
137 } | |
138 #endif | |
139 | |
94 if (sbr->bs_header_flag) | 140 if (sbr->bs_header_flag) |
95 sbr_header(ld, sbr, id_aac); | 141 sbr_header(ld, sbr, id_aac); |
96 | 142 |
97 /* TODO: Reset? */ | 143 /* TODO: Reset? */ |
98 sbr_reset(sbr); | 144 sbr_reset(sbr); |
102 return 1; | 148 return 1; |
103 | 149 |
104 | 150 |
105 if (sbr->Reset || (sbr->bs_header_flag && sbr->just_seeked)) | 151 if (sbr->Reset || (sbr->bs_header_flag && sbr->just_seeked)) |
106 { | 152 { |
107 uint16_t k2; | 153 uint8_t k2; |
108 | 154 |
109 /* calculate the Master Frequency Table */ | 155 /* calculate the Master Frequency Table */ |
110 sbr->k0 = qmf_start_channel(sbr->bs_start_freq, sbr->bs_samplerate_mode, | 156 sbr->k0 = qmf_start_channel(sbr->bs_start_freq, sbr->bs_samplerate_mode, |
111 sbr->sample_rate); | 157 sbr->sample_rate); |
112 k2 = qmf_stop_channel(sbr->bs_stop_freq, sbr->sample_rate, sbr->k0); | 158 k2 = qmf_stop_channel(sbr->bs_stop_freq, sbr->sample_rate, sbr->k0); |
129 master_frequency_table_fs0(sbr, sbr->k0, k2, sbr->bs_alter_scale); | 175 master_frequency_table_fs0(sbr, sbr->k0, k2, sbr->bs_alter_scale); |
130 } else { | 176 } else { |
131 master_frequency_table(sbr, sbr->k0, k2, sbr->bs_freq_scale, | 177 master_frequency_table(sbr, sbr->k0, k2, sbr->bs_freq_scale, |
132 sbr->bs_alter_scale); | 178 sbr->bs_alter_scale); |
133 } | 179 } |
134 derived_frequency_table(sbr, sbr->bs_xover_band, k2); | 180 if ((result = derived_frequency_table(sbr, sbr->bs_xover_band, k2)) > 0) |
135 } | 181 return result; |
136 | 182 } |
137 sbr_data(ld, sbr, id_aac); | 183 |
184 if ((result = sbr_data(ld, sbr, id_aac)) > 0) | |
185 return result; | |
138 | 186 |
139 /* no error */ | 187 /* no error */ |
140 return 0; | 188 return 0; |
141 } | 189 } |
142 | 190 |
144 static void sbr_header(bitfile *ld, sbr_info *sbr, uint8_t id_aac) | 192 static void sbr_header(bitfile *ld, sbr_info *sbr, uint8_t id_aac) |
145 { | 193 { |
146 uint8_t bs_header_extra_1, bs_header_extra_2; | 194 uint8_t bs_header_extra_1, bs_header_extra_2; |
147 | 195 |
148 sbr->header_count++; | 196 sbr->header_count++; |
197 | |
198 #ifdef DRM | |
199 /* protocol_version (should be 0) */ | |
200 if (sbr->Is_DRM_SBR) | |
201 faad_getbits(ld, 2); | |
202 #endif | |
149 | 203 |
150 sbr->bs_amp_res = faad_get1bit(ld | 204 sbr->bs_amp_res = faad_get1bit(ld |
151 DEBUGVAR(1,203,"sbr_header(): bs_amp_res")); | 205 DEBUGVAR(1,203,"sbr_header(): bs_amp_res")); |
152 | 206 |
153 /* bs_start_freq and bs_stop_freq must define a fequency band that does | 207 /* bs_start_freq and bs_stop_freq must define a fequency band that does |
158 DEBUGVAR(1,205,"sbr_header(): bs_stop_freq")); | 212 DEBUGVAR(1,205,"sbr_header(): bs_stop_freq")); |
159 sbr->bs_xover_band = faad_getbits(ld, 3 | 213 sbr->bs_xover_band = faad_getbits(ld, 3 |
160 DEBUGVAR(1,206,"sbr_header(): bs_xover_band")); | 214 DEBUGVAR(1,206,"sbr_header(): bs_xover_band")); |
161 faad_getbits(ld, 2 | 215 faad_getbits(ld, 2 |
162 DEBUGVAR(1,207,"sbr_header(): bs_reserved_bits_hdr")); | 216 DEBUGVAR(1,207,"sbr_header(): bs_reserved_bits_hdr")); |
217 #ifdef DRM | |
218 if (sbr->Is_DRM_SBR) | |
219 sbr->bs_dataextra = faad_getbits(ld, 1); | |
220 #endif | |
163 bs_header_extra_1 = faad_get1bit(ld | 221 bs_header_extra_1 = faad_get1bit(ld |
164 DEBUGVAR(1,208,"sbr_header(): bs_header_extra_1")); | 222 DEBUGVAR(1,208,"sbr_header(): bs_header_extra_1")); |
165 bs_header_extra_2 = faad_get1bit(ld | 223 bs_header_extra_2 = faad_get1bit(ld |
166 DEBUGVAR(1,209,"sbr_header(): bs_header_extra_2")); | 224 DEBUGVAR(1,209,"sbr_header(): bs_header_extra_2")); |
225 #ifdef DRM | |
226 /* No low complexity stereo support so far */ | |
227 if ((sbr->lcstereo_flag) && (sbr->Is_DRM_SBR)) | |
228 faad_getbits(ld, 2); | |
229 #endif | |
167 | 230 |
168 if (bs_header_extra_1) | 231 if (bs_header_extra_1) |
169 { | 232 { |
170 sbr->bs_freq_scale = faad_getbits(ld, 2 | 233 sbr->bs_freq_scale = faad_getbits(ld, 2 |
171 DEBUGVAR(1,211,"sbr_header(): bs_freq_scale")); | 234 DEBUGVAR(1,211,"sbr_header(): bs_freq_scale")); |
172 sbr->bs_alter_scale = faad_get1bit(ld | 235 sbr->bs_alter_scale = faad_get1bit(ld |
173 DEBUGVAR(1,212,"sbr_header(): bs_alter_scale")); | 236 DEBUGVAR(1,212,"sbr_header(): bs_alter_scale")); |
174 sbr->bs_noise_bands = faad_getbits(ld, 2 | 237 sbr->bs_noise_bands = faad_getbits(ld, 2 |
175 DEBUGVAR(1,213,"sbr_header(): bs_noise_bands")); | 238 DEBUGVAR(1,213,"sbr_header(): bs_noise_bands")); |
176 } | 239 } else { |
240 /* Default values */ | |
241 sbr->bs_freq_scale = 2; | |
242 sbr->bs_alter_scale = 1; | |
243 sbr->bs_noise_bands = 2; | |
244 } | |
245 | |
177 if (bs_header_extra_2) | 246 if (bs_header_extra_2) |
178 { | 247 { |
179 sbr->bs_limiter_bands = faad_getbits(ld, 2 | 248 sbr->bs_limiter_bands = faad_getbits(ld, 2 |
180 DEBUGVAR(1,214,"sbr_header(): bs_limiter_bands")); | 249 DEBUGVAR(1,214,"sbr_header(): bs_limiter_bands")); |
181 sbr->bs_limiter_gains = faad_getbits(ld, 2 | 250 sbr->bs_limiter_gains = faad_getbits(ld, 2 |
182 DEBUGVAR(1,215,"sbr_header(): bs_limiter_gains")); | 251 DEBUGVAR(1,215,"sbr_header(): bs_limiter_gains")); |
183 sbr->bs_interpol_freq = faad_get1bit(ld | 252 sbr->bs_interpol_freq = faad_get1bit(ld |
184 DEBUGVAR(1,216,"sbr_header(): bs_interpol_freq")); | 253 DEBUGVAR(1,216,"sbr_header(): bs_interpol_freq")); |
185 sbr->bs_smoothing_mode = faad_get1bit(ld | 254 sbr->bs_smoothing_mode = faad_get1bit(ld |
186 DEBUGVAR(1,217,"sbr_header(): bs_smoothing_mode")); | 255 DEBUGVAR(1,217,"sbr_header(): bs_smoothing_mode")); |
256 #ifdef DRM | |
257 /* reserved */ | |
258 if (sbr->Is_DRM_SBR) | |
259 faad_get1bit(ld); | |
260 #endif | |
261 } else { | |
262 /* Default values */ | |
263 sbr->bs_limiter_bands = 2; | |
264 sbr->bs_limiter_gains = 2; | |
265 sbr->bs_interpol_freq = 1; | |
266 sbr->bs_smoothing_mode = 1; | |
187 } | 267 } |
188 | 268 |
189 #if 0 | 269 #if 0 |
190 /* print the header to screen */ | 270 /* print the header to screen */ |
191 printf("bs_amp_res: %d\n", sbr->bs_amp_res); | 271 printf("bs_amp_res: %d\n", sbr->bs_amp_res); |
208 printf("\n"); | 288 printf("\n"); |
209 #endif | 289 #endif |
210 } | 290 } |
211 | 291 |
212 /* table 4 */ | 292 /* table 4 */ |
213 static void sbr_data(bitfile *ld, sbr_info *sbr, uint8_t id_aac) | 293 static uint8_t sbr_data(bitfile *ld, sbr_info *sbr, uint8_t id_aac) |
214 { | 294 { |
295 uint8_t result; | |
215 #if 0 | 296 #if 0 |
216 sbr->bs_samplerate_mode = faad_get1bit(ld | 297 sbr->bs_samplerate_mode = faad_get1bit(ld |
217 DEBUGVAR(1,219,"sbr_data(): bs_samplerate_mode")); | 298 DEBUGVAR(1,219,"sbr_data(): bs_samplerate_mode")); |
218 #endif | 299 #endif |
219 | 300 |
220 sbr->rate = (sbr->bs_samplerate_mode) ? 2 : 1; | 301 sbr->rate = (sbr->bs_samplerate_mode) ? 2 : 1; |
221 | 302 |
303 #ifdef DRM | |
304 if (sbr->Is_DRM_SBR) | |
305 sbr->rate = 2; | |
306 #endif | |
307 | |
222 switch (id_aac) | 308 switch (id_aac) |
223 { | 309 { |
224 case ID_SCE: | 310 case ID_SCE: |
225 sbr_single_channel_element(ld, sbr); | 311 if ((result = sbr_single_channel_element(ld, sbr)) > 0) |
312 return result; | |
226 break; | 313 break; |
227 case ID_CPE: | 314 case ID_CPE: |
228 sbr_channel_pair_element(ld, sbr); | 315 if ((result = sbr_channel_pair_element(ld, sbr)) > 0) |
316 return result; | |
229 break; | 317 break; |
230 } | 318 } |
319 | |
320 return 0; | |
231 } | 321 } |
232 | 322 |
233 /* table 5 */ | 323 /* table 5 */ |
234 static void sbr_single_channel_element(bitfile *ld, sbr_info *sbr) | 324 static uint8_t sbr_single_channel_element(bitfile *ld, sbr_info *sbr) |
235 { | 325 { |
326 uint8_t result; | |
327 | |
328 #ifdef DRM | |
329 if (!sbr->Is_DRM_SBR) | |
330 #endif | |
331 { | |
236 if (faad_get1bit(ld | 332 if (faad_get1bit(ld |
237 DEBUGVAR(1,220,"sbr_single_channel_element(): bs_data_extra"))) | 333 DEBUGVAR(1,220,"sbr_single_channel_element(): bs_data_extra"))) |
238 { | 334 { |
239 faad_getbits(ld, 4 | 335 faad_getbits(ld, 4 |
240 DEBUGVAR(1,221,"sbr_single_channel_element(): bs_reserved_bits_data")); | 336 DEBUGVAR(1,221,"sbr_single_channel_element(): bs_reserved_bits_data")); |
241 } | 337 } |
242 | 338 } |
243 sbr_grid(ld, sbr, 0); | 339 |
340 if ((result = sbr_grid(ld, sbr, 0)) > 0) | |
341 return result; | |
244 sbr_dtdf(ld, sbr, 0); | 342 sbr_dtdf(ld, sbr, 0); |
245 invf_mode(ld, sbr, 0); | 343 invf_mode(ld, sbr, 0); |
344 #ifdef DRM | |
345 if (sbr->Is_DRM_SBR) | |
346 { | |
347 /* sbr mode not needed in V1.0. Should be set to 2 by a V1.0 encoder */ | |
348 faad_getbits(ld, 2); | |
349 | |
350 if (sbr->bs_dataextra) | |
351 faad_getbits(ld, 3); /* reserved */ | |
352 } | |
353 #endif | |
246 sbr_envelope(ld, sbr, 0); | 354 sbr_envelope(ld, sbr, 0); |
247 sbr_noise(ld, sbr, 0); | 355 sbr_noise(ld, sbr, 0); |
248 | 356 |
249 envelope_noise_dequantisation(sbr, 0); | 357 envelope_noise_dequantisation(sbr, 0); |
250 | 358 |
251 #if 0 | |
252 // TEMP | |
253 if (sbr->frame == 21) | |
254 { | |
255 int l, k; | |
256 | |
257 printf("\n"); | |
258 for (l = 0; l < sbr->L_E[0]; l++) | |
259 { | |
260 for (k = 0; k < sbr->n[sbr->f[0][l]]; k++) | |
261 { | |
262 //printf("%f\n", sbr->E_orig[0][k][l]); | |
263 printf("%f\n", sbr->E_orig[0][k][l] * 1024. / (float)(1 << REAL_BITS)); | |
264 } | |
265 } | |
266 } | |
267 // end TEMP | |
268 #endif | |
269 | |
270 #if 0 | |
271 // TEMP | |
272 { | |
273 int l, k; | |
274 | |
275 printf("\n"); | |
276 for (l = 0; l < sbr->L_Q[0]; l++) | |
277 { | |
278 for (k = 0; k < sbr->N_Q; k++) | |
279 { | |
280 printf("%f\n", sbr->Q_orig[0][k][l]); | |
281 } | |
282 } | |
283 } | |
284 // end TEMP | |
285 #endif | |
286 | |
287 memset(sbr->bs_add_harmonic[0], 0, 64*sizeof(uint8_t)); | 359 memset(sbr->bs_add_harmonic[0], 0, 64*sizeof(uint8_t)); |
288 | 360 |
361 #ifdef DRM | |
362 if (sbr->Is_DRM_SBR) | |
363 sbr->bs_add_harmonic_flag[0] = 0; | |
364 else | |
365 #endif | |
366 { | |
289 sbr->bs_add_harmonic_flag[0] = faad_get1bit(ld | 367 sbr->bs_add_harmonic_flag[0] = faad_get1bit(ld |
290 DEBUGVAR(1,223,"sbr_single_channel_element(): bs_add_harmonic_flag[0]")); | 368 DEBUGVAR(1,223,"sbr_single_channel_element(): bs_add_harmonic_flag[0]")); |
369 } | |
291 if (sbr->bs_add_harmonic_flag[0]) | 370 if (sbr->bs_add_harmonic_flag[0]) |
292 sinusoidal_coding(ld, sbr, 0); | 371 sinusoidal_coding(ld, sbr, 0); |
293 | 372 |
294 sbr->bs_extended_data = faad_get1bit(ld | 373 sbr->bs_extended_data = faad_get1bit(ld |
295 DEBUGVAR(1,224,"sbr_single_channel_element(): bs_extended_data[0]")); | 374 DEBUGVAR(1,224,"sbr_single_channel_element(): bs_extended_data[0]")); |
309 { | 388 { |
310 sbr->bs_extension_id = faad_getbits(ld, 2 | 389 sbr->bs_extension_id = faad_getbits(ld, 2 |
311 DEBUGVAR(1,227,"sbr_single_channel_element(): bs_extension_id")); | 390 DEBUGVAR(1,227,"sbr_single_channel_element(): bs_extension_id")); |
312 nr_bits_left -= 2; | 391 nr_bits_left -= 2; |
313 /* sbr_extension(ld, sbr, 0, nr_bits_left); */ | 392 /* sbr_extension(ld, sbr, 0, nr_bits_left); */ |
393 #ifdef DRM | |
394 if (!sbr->Is_DRM_SBR) | |
395 #endif | |
396 { | |
314 sbr->bs_extension_data = faad_getbits(ld, 6 | 397 sbr->bs_extension_data = faad_getbits(ld, 6 |
315 DEBUGVAR(1,279,"sbr_single_channel_element(): bs_extension_data")); | 398 DEBUGVAR(1,279,"sbr_single_channel_element(): bs_extension_data")); |
316 } | 399 } |
317 } | 400 } |
401 } | |
402 | |
403 return 0; | |
318 } | 404 } |
319 | 405 |
320 /* table 6 */ | 406 /* table 6 */ |
321 static void sbr_channel_pair_element(bitfile *ld, sbr_info *sbr) | 407 static uint8_t sbr_channel_pair_element(bitfile *ld, sbr_info *sbr) |
322 { | 408 { |
323 uint8_t n; | 409 uint8_t n, result; |
324 | 410 |
411 #ifdef DRM | |
412 if (!sbr->Is_DRM_SBR) | |
413 #endif | |
414 { | |
325 if (faad_get1bit(ld | 415 if (faad_get1bit(ld |
326 DEBUGVAR(1,228,"sbr_single_channel_element(): bs_data_extra"))) | 416 DEBUGVAR(1,228,"sbr_single_channel_element(): bs_data_extra"))) |
327 { | 417 { |
328 faad_getbits(ld, 4 | 418 faad_getbits(ld, 4 |
329 DEBUGVAR(1,228,"sbr_channel_pair_element(): bs_reserved_bits_data")); | 419 DEBUGVAR(1,228,"sbr_channel_pair_element(): bs_reserved_bits_data")); |
330 faad_getbits(ld, 4 | 420 faad_getbits(ld, 4 |
331 DEBUGVAR(1,228,"sbr_channel_pair_element(): bs_reserved_bits_data")); | 421 DEBUGVAR(1,228,"sbr_channel_pair_element(): bs_reserved_bits_data")); |
332 } | 422 } |
423 } | |
333 | 424 |
334 sbr->bs_coupling = faad_get1bit(ld | 425 sbr->bs_coupling = faad_get1bit(ld |
335 DEBUGVAR(1,228,"sbr_channel_pair_element(): bs_coupling")); | 426 DEBUGVAR(1,228,"sbr_channel_pair_element(): bs_coupling")); |
336 | 427 |
337 if (sbr->bs_coupling) | 428 if (sbr->bs_coupling) |
338 { | 429 { |
339 sbr_grid(ld, sbr, 0); | 430 if ((result = sbr_grid(ld, sbr, 0)) > 0) |
431 return result; | |
340 | 432 |
341 /* need to copy some data from left to right */ | 433 /* need to copy some data from left to right */ |
342 sbr->bs_frame_class[1] = sbr->bs_frame_class[0]; | 434 sbr->bs_frame_class[1] = sbr->bs_frame_class[0]; |
343 sbr->L_E[1] = sbr->L_E[0]; | 435 sbr->L_E[1] = sbr->L_E[0]; |
344 sbr->L_Q[1] = sbr->L_Q[0]; | 436 sbr->L_Q[1] = sbr->L_Q[0]; |
353 sbr->t_Q[1][n] = sbr->t_Q[0][n]; | 445 sbr->t_Q[1][n] = sbr->t_Q[0][n]; |
354 | 446 |
355 sbr_dtdf(ld, sbr, 0); | 447 sbr_dtdf(ld, sbr, 0); |
356 sbr_dtdf(ld, sbr, 1); | 448 sbr_dtdf(ld, sbr, 1); |
357 invf_mode(ld, sbr, 0); | 449 invf_mode(ld, sbr, 0); |
450 #ifdef DRM | |
451 if (sbr->Is_DRM_SBR) | |
452 { | |
453 /* sbr mode not needed in V1.0. Should be set to 2 by a V1.0 encoder */ | |
454 faad_getbits(ld, 2); | |
455 | |
456 if (sbr->bs_dataextra) | |
457 faad_getbits(ld, 3); /* reserved */ | |
458 } | |
459 #endif | |
358 | 460 |
359 /* more copying */ | 461 /* more copying */ |
360 for (n = 0; n < sbr->N_Q; n++) | 462 for (n = 0; n < sbr->N_Q; n++) |
361 sbr->bs_invf_mode[1][n] = sbr->bs_invf_mode[0][n]; | 463 sbr->bs_invf_mode[1][n] = sbr->bs_invf_mode[0][n]; |
362 | 464 |
366 sbr_noise(ld, sbr, 1); | 468 sbr_noise(ld, sbr, 1); |
367 | 469 |
368 memset(sbr->bs_add_harmonic[0], 0, 64*sizeof(uint8_t)); | 470 memset(sbr->bs_add_harmonic[0], 0, 64*sizeof(uint8_t)); |
369 memset(sbr->bs_add_harmonic[1], 0, 64*sizeof(uint8_t)); | 471 memset(sbr->bs_add_harmonic[1], 0, 64*sizeof(uint8_t)); |
370 | 472 |
473 #ifdef DRM | |
474 if (sbr->Is_DRM_SBR) | |
475 sbr->bs_add_harmonic_flag[0] = 0; | |
476 else | |
477 #endif | |
478 { | |
371 sbr->bs_add_harmonic_flag[0] = faad_get1bit(ld | 479 sbr->bs_add_harmonic_flag[0] = faad_get1bit(ld |
372 DEBUGVAR(1,231,"sbr_channel_pair_element(): bs_add_harmonic_flag[0]")); | 480 DEBUGVAR(1,231,"sbr_channel_pair_element(): bs_add_harmonic_flag[0]")); |
481 } | |
373 if (sbr->bs_add_harmonic_flag[0]) | 482 if (sbr->bs_add_harmonic_flag[0]) |
374 sinusoidal_coding(ld, sbr, 0); | 483 sinusoidal_coding(ld, sbr, 0); |
375 | 484 |
485 #ifdef DRM | |
486 if (sbr->Is_DRM_SBR) | |
487 sbr->bs_add_harmonic_flag[1] = 0; | |
488 else | |
489 #endif | |
490 { | |
376 sbr->bs_add_harmonic_flag[1] = faad_get1bit(ld | 491 sbr->bs_add_harmonic_flag[1] = faad_get1bit(ld |
377 DEBUGVAR(1,232,"sbr_channel_pair_element(): bs_add_harmonic_flag[1]")); | 492 DEBUGVAR(1,232,"sbr_channel_pair_element(): bs_add_harmonic_flag[1]")); |
493 } | |
378 if (sbr->bs_add_harmonic_flag[1]) | 494 if (sbr->bs_add_harmonic_flag[1]) |
379 sinusoidal_coding(ld, sbr, 1); | 495 sinusoidal_coding(ld, sbr, 1); |
380 } else { | 496 } else { |
381 sbr_grid(ld, sbr, 0); | 497 if ((result = sbr_grid(ld, sbr, 0)) > 0) |
382 sbr_grid(ld, sbr, 1); | 498 return result; |
499 if ((result = sbr_grid(ld, sbr, 1)) > 0) | |
500 return result; | |
383 sbr_dtdf(ld, sbr, 0); | 501 sbr_dtdf(ld, sbr, 0); |
384 sbr_dtdf(ld, sbr, 1); | 502 sbr_dtdf(ld, sbr, 1); |
385 invf_mode(ld, sbr, 0); | 503 invf_mode(ld, sbr, 0); |
386 invf_mode(ld, sbr, 1); | 504 invf_mode(ld, sbr, 1); |
505 #ifdef DRM | |
506 if (sbr->Is_DRM_SBR) | |
507 { | |
508 /* sbr mode not needed in V1.0. Should be set to 2 by a V1.0 encoder */ | |
509 faad_getbits(ld, 2); | |
510 faad_getbits(ld, 2); | |
511 | |
512 if (sbr->bs_dataextra) | |
513 faad_getbits(ld, 6); /* reserved */ | |
514 } | |
515 #endif | |
387 sbr_envelope(ld, sbr, 0); | 516 sbr_envelope(ld, sbr, 0); |
388 sbr_envelope(ld, sbr, 1); | 517 sbr_envelope(ld, sbr, 1); |
389 sbr_noise(ld, sbr, 0); | 518 sbr_noise(ld, sbr, 0); |
390 sbr_noise(ld, sbr, 1); | 519 sbr_noise(ld, sbr, 1); |
391 | 520 |
392 memset(sbr->bs_add_harmonic[0], 0, 64*sizeof(uint8_t)); | 521 memset(sbr->bs_add_harmonic[0], 0, 64*sizeof(uint8_t)); |
393 memset(sbr->bs_add_harmonic[1], 0, 64*sizeof(uint8_t)); | 522 memset(sbr->bs_add_harmonic[1], 0, 64*sizeof(uint8_t)); |
394 | 523 |
524 #ifdef DRM | |
525 if (sbr->Is_DRM_SBR) | |
526 sbr->bs_add_harmonic_flag[0] = 0; | |
527 else | |
528 #endif | |
529 { | |
395 sbr->bs_add_harmonic_flag[0] = faad_get1bit(ld | 530 sbr->bs_add_harmonic_flag[0] = faad_get1bit(ld |
396 DEBUGVAR(1,239,"sbr_channel_pair_element(): bs_add_harmonic_flag[0]")); | 531 DEBUGVAR(1,239,"sbr_channel_pair_element(): bs_add_harmonic_flag[0]")); |
532 } | |
397 if (sbr->bs_add_harmonic_flag[0]) | 533 if (sbr->bs_add_harmonic_flag[0]) |
398 sinusoidal_coding(ld, sbr, 0); | 534 sinusoidal_coding(ld, sbr, 0); |
399 | 535 |
536 #ifdef DRM | |
537 if (sbr->Is_DRM_SBR) | |
538 sbr->bs_add_harmonic_flag[1] = 0; | |
539 else | |
540 #endif | |
541 { | |
400 sbr->bs_add_harmonic_flag[1] = faad_get1bit(ld | 542 sbr->bs_add_harmonic_flag[1] = faad_get1bit(ld |
401 DEBUGVAR(1,240,"sbr_channel_pair_element(): bs_add_harmonic_flag[1]")); | 543 DEBUGVAR(1,240,"sbr_channel_pair_element(): bs_add_harmonic_flag[1]")); |
544 } | |
402 if (sbr->bs_add_harmonic_flag[1]) | 545 if (sbr->bs_add_harmonic_flag[1]) |
403 sinusoidal_coding(ld, sbr, 1); | 546 sinusoidal_coding(ld, sbr, 1); |
404 } | 547 } |
405 envelope_noise_dequantisation(sbr, 0); | 548 envelope_noise_dequantisation(sbr, 0); |
406 envelope_noise_dequantisation(sbr, 1); | 549 envelope_noise_dequantisation(sbr, 1); |
407 | 550 |
408 #if 0 | |
409 // TEMP | |
410 if (sbr->frame == 21) | |
411 { | |
412 int l, k; | |
413 | |
414 printf("\n"); | |
415 for (l = 0; l < sbr->L_E[0]; l++) | |
416 { | |
417 for (k = 0; k < sbr->n[sbr->f[0][l]]; k++) | |
418 { | |
419 printf("%f\n", sbr->E_orig[0][k][l]); | |
420 //printf("%f\n", sbr->E_orig[0][k][l] * 1024. / (float)(1 << REAL_BITS)); | |
421 } | |
422 } | |
423 } | |
424 // end TEMP | |
425 #endif | |
426 | |
427 if (sbr->bs_coupling) | 551 if (sbr->bs_coupling) |
428 unmap_envelope_noise(sbr); | 552 unmap_envelope_noise(sbr); |
429 | |
430 #if 0 | |
431 // TEMP | |
432 if (sbr->bs_coupling) | |
433 { | |
434 int l, k; | |
435 | |
436 printf("\n"); | |
437 for (l = 0; l < sbr->L_Q[0]; l++) | |
438 { | |
439 for (k = 0; k < sbr->N_Q; k++) | |
440 { | |
441 printf("%f\n", sbr->Q_orig[0][k][l]); | |
442 } | |
443 } | |
444 } | |
445 // end TEMP | |
446 #endif | |
447 | 553 |
448 sbr->bs_extended_data = faad_get1bit(ld | 554 sbr->bs_extended_data = faad_get1bit(ld |
449 DEBUGVAR(1,233,"sbr_channel_pair_element(): bs_extended_data[0]")); | 555 DEBUGVAR(1,233,"sbr_channel_pair_element(): bs_extended_data[0]")); |
450 if (sbr->bs_extended_data) | 556 if (sbr->bs_extended_data) |
451 { | 557 { |
463 { | 569 { |
464 sbr->bs_extension_id = faad_getbits(ld, 2 | 570 sbr->bs_extension_id = faad_getbits(ld, 2 |
465 DEBUGVAR(1,236,"sbr_channel_pair_element(): bs_extension_id")); | 571 DEBUGVAR(1,236,"sbr_channel_pair_element(): bs_extension_id")); |
466 nr_bits_left -= 2; | 572 nr_bits_left -= 2; |
467 /* sbr_extension(ld, sbr, 0, nr_bits_left); */ | 573 /* sbr_extension(ld, sbr, 0, nr_bits_left); */ |
574 #ifdef DRM | |
575 if (!sbr->Is_DRM_SBR) | |
576 #endif | |
577 { | |
468 sbr->bs_extension_data = faad_getbits(ld, 6 | 578 sbr->bs_extension_data = faad_getbits(ld, 6 |
469 DEBUGVAR(1,280,"sbr_single_channel_element(): bs_extension_data")); | 579 DEBUGVAR(1,280,"sbr_single_channel_element(): bs_extension_data")); |
470 } | 580 } |
471 } | 581 } |
582 } | |
583 | |
584 return 0; | |
472 } | 585 } |
473 | 586 |
474 /* table 7 */ | 587 /* table 7 */ |
475 static void sbr_grid(bitfile *ld, sbr_info *sbr, uint8_t ch) | 588 static uint8_t sbr_grid(bitfile *ld, sbr_info *sbr, uint8_t ch) |
476 { | 589 { |
477 uint8_t i, env, rel; | 590 uint8_t i, env, rel, result; |
478 uint8_t bs_abs_bord, bs_abs_bord_1; | 591 uint8_t bs_abs_bord, bs_abs_bord_1; |
479 uint16_t bs_num_env; | 592 uint16_t bs_num_env; |
480 | 593 |
481 sbr->bs_frame_class[ch] = faad_getbits(ld, 2 | 594 sbr->bs_frame_class[ch] = faad_getbits(ld, 2 |
482 DEBUGVAR(1,248,"sbr_grid(): bs_frame_class")); | 595 DEBUGVAR(1,248,"sbr_grid(): bs_frame_class")); |
483 | |
484 #if 0 | |
485 if (sbr->bs_frame_class[ch] != FIXFIX) | |
486 printf("%d", sbr->bs_frame_class[ch]); | |
487 #endif | |
488 | 596 |
489 switch (sbr->bs_frame_class[ch]) | 597 switch (sbr->bs_frame_class[ch]) |
490 { | 598 { |
491 case FIXFIX: | 599 case FIXFIX: |
492 i = faad_getbits(ld, 2 | 600 i = faad_getbits(ld, 2 |
498 DEBUGVAR(1,250,"sbr_grid(): bs_freq_res_flag")); | 606 DEBUGVAR(1,250,"sbr_grid(): bs_freq_res_flag")); |
499 for (env = 0; env < bs_num_env; env++) | 607 for (env = 0; env < bs_num_env; env++) |
500 sbr->f[ch][env] = i; | 608 sbr->f[ch][env] = i; |
501 | 609 |
502 sbr->abs_bord_lead[ch] = 0; | 610 sbr->abs_bord_lead[ch] = 0; |
503 sbr->abs_bord_trail[ch] = NO_TIME_SLOTS; | 611 sbr->abs_bord_trail[ch] = sbr->numTimeSlots; |
504 sbr->n_rel_lead[ch] = bs_num_env - 1; | 612 sbr->n_rel_lead[ch] = bs_num_env - 1; |
505 sbr->n_rel_trail[ch] = 0; | 613 sbr->n_rel_trail[ch] = 0; |
506 break; | 614 break; |
507 | 615 |
508 case FIXVAR: | 616 case FIXVAR: |
617 #ifdef DRM | |
618 if (sbr->Is_DRM_SBR) | |
619 { | |
620 bs_abs_bord = faad_getbits(ld, 3 | |
621 DEBUGVAR(1,251,"sbr_grid(): bs_abs_bord")) + sbr->numTimeSlots; | |
622 } else | |
623 #endif | |
624 { | |
509 bs_abs_bord = faad_getbits(ld, 2 | 625 bs_abs_bord = faad_getbits(ld, 2 |
510 DEBUGVAR(1,251,"sbr_grid(): bs_abs_bord")) + NO_TIME_SLOTS; | 626 DEBUGVAR(1,251,"sbr_grid(): bs_abs_bord")) + sbr->numTimeSlots; |
627 } | |
511 bs_num_env = faad_getbits(ld, 2 | 628 bs_num_env = faad_getbits(ld, 2 |
512 DEBUGVAR(1,252,"sbr_grid(): bs_num_env")) + 1; | 629 DEBUGVAR(1,252,"sbr_grid(): bs_num_env")) + 1; |
513 | 630 |
514 for (rel = 0; rel < bs_num_env-1; rel++) | 631 for (rel = 0; rel < bs_num_env-1; rel++) |
515 { | 632 { |
531 sbr->n_rel_lead[ch] = 0; | 648 sbr->n_rel_lead[ch] = 0; |
532 sbr->n_rel_trail[ch] = bs_num_env - 1; | 649 sbr->n_rel_trail[ch] = bs_num_env - 1; |
533 break; | 650 break; |
534 | 651 |
535 case VARFIX: | 652 case VARFIX: |
653 #ifdef DRM | |
654 if (sbr->Is_DRM_SBR) | |
655 { | |
656 bs_abs_bord = faad_getbits(ld, 3 | |
657 DEBUGVAR(1,256,"sbr_grid(): bs_abs_bord")); | |
658 } else | |
659 #endif | |
660 { | |
536 bs_abs_bord = faad_getbits(ld, 2 | 661 bs_abs_bord = faad_getbits(ld, 2 |
537 DEBUGVAR(1,256,"sbr_grid(): bs_abs_bord")); | 662 DEBUGVAR(1,256,"sbr_grid(): bs_abs_bord")); |
663 } | |
538 bs_num_env = faad_getbits(ld, 2 | 664 bs_num_env = faad_getbits(ld, 2 |
539 DEBUGVAR(1,257,"sbr_grid(): bs_num_env")) + 1; | 665 DEBUGVAR(1,257,"sbr_grid(): bs_num_env")) + 1; |
540 | 666 |
541 for (rel = 0; rel < bs_num_env-1; rel++) | 667 for (rel = 0; rel < bs_num_env-1; rel++) |
542 { | 668 { |
552 sbr->f[ch][env] = faad_get1bit(ld | 678 sbr->f[ch][env] = faad_get1bit(ld |
553 DEBUGVAR(1,260,"sbr_grid(): bs_freq_res")); | 679 DEBUGVAR(1,260,"sbr_grid(): bs_freq_res")); |
554 } | 680 } |
555 | 681 |
556 sbr->abs_bord_lead[ch] = bs_abs_bord; | 682 sbr->abs_bord_lead[ch] = bs_abs_bord; |
557 sbr->abs_bord_trail[ch] = NO_TIME_SLOTS; | 683 sbr->abs_bord_trail[ch] = sbr->numTimeSlots; |
558 sbr->n_rel_lead[ch] = bs_num_env - 1; | 684 sbr->n_rel_lead[ch] = bs_num_env - 1; |
559 sbr->n_rel_trail[ch] = 0; | 685 sbr->n_rel_trail[ch] = 0; |
560 break; | 686 break; |
561 | 687 |
562 case VARVAR: | 688 case VARVAR: |
689 #ifdef DRM | |
690 if (sbr->Is_DRM_SBR) | |
691 { | |
692 bs_abs_bord = faad_getbits(ld, 3 | |
693 DEBUGVAR(1,261,"sbr_grid(): bs_abs_bord_0")); | |
694 bs_abs_bord_1 = faad_getbits(ld, 3 | |
695 DEBUGVAR(1,262,"sbr_grid(): bs_abs_bord_1")) + sbr->numTimeSlots; | |
696 } | |
697 else | |
698 #endif | |
699 { | |
563 bs_abs_bord = faad_getbits(ld, 2 | 700 bs_abs_bord = faad_getbits(ld, 2 |
564 DEBUGVAR(1,261,"sbr_grid(): bs_abs_bord_0")); | 701 DEBUGVAR(1,261,"sbr_grid(): bs_abs_bord_0")); |
565 bs_abs_bord_1 = faad_getbits(ld, 2 | 702 bs_abs_bord_1 = faad_getbits(ld, 2 |
566 DEBUGVAR(1,262,"sbr_grid(): bs_abs_bord_1")) + NO_TIME_SLOTS; | 703 DEBUGVAR(1,262,"sbr_grid(): bs_abs_bord_1")) + sbr->numTimeSlots; |
704 } | |
567 sbr->bs_num_rel_0[ch] = faad_getbits(ld, 2 | 705 sbr->bs_num_rel_0[ch] = faad_getbits(ld, 2 |
568 DEBUGVAR(1,263,"sbr_grid(): bs_num_rel_0")); | 706 DEBUGVAR(1,263,"sbr_grid(): bs_num_rel_0")); |
569 sbr->bs_num_rel_1[ch] = faad_getbits(ld, 2 | 707 sbr->bs_num_rel_1[ch] = faad_getbits(ld, 2 |
570 DEBUGVAR(1,264,"sbr_grid(): bs_num_rel_1")); | 708 DEBUGVAR(1,264,"sbr_grid(): bs_num_rel_1")); |
571 | 709 |
607 sbr->L_Q[ch] = 2; | 745 sbr->L_Q[ch] = 2; |
608 else | 746 else |
609 sbr->L_Q[ch] = 1; | 747 sbr->L_Q[ch] = 1; |
610 | 748 |
611 /* TODO: this code can probably be integrated into the code above! */ | 749 /* TODO: this code can probably be integrated into the code above! */ |
612 envelope_time_border_vector(sbr, ch); | 750 if ((result = envelope_time_border_vector(sbr, ch)) > 0) |
751 return result; | |
613 noise_floor_time_border_vector(sbr, ch); | 752 noise_floor_time_border_vector(sbr, ch); |
753 | |
754 return 0; | |
614 } | 755 } |
615 | 756 |
616 /* table 8 */ | 757 /* table 8 */ |
617 static void sbr_dtdf(bitfile *ld, sbr_info *sbr, uint8_t ch) | 758 static void sbr_dtdf(bitfile *ld, sbr_info *sbr, uint8_t ch) |
618 { | 759 { |
634 /* table 9 */ | 775 /* table 9 */ |
635 static void invf_mode(bitfile *ld, sbr_info *sbr, uint8_t ch) | 776 static void invf_mode(bitfile *ld, sbr_info *sbr, uint8_t ch) |
636 { | 777 { |
637 uint8_t n; | 778 uint8_t n; |
638 | 779 |
639 for (n = 0; n < sbr->N_Q; n++) | 780 #ifdef DRM |
640 { | 781 if (sbr->Is_DRM_SBR) |
641 sbr->bs_invf_mode[ch][n] = faad_getbits(ld, 2 | 782 { |
783 /* Only one inv_mode in DRM */ | |
784 uint8_t invf_mode; | |
785 invf_mode = faad_getbits(ld, 2 | |
642 DEBUGVAR(1,271,"invf_mode(): bs_invf_mode")); | 786 DEBUGVAR(1,271,"invf_mode(): bs_invf_mode")); |
643 } | 787 for (n = 0; n < sbr->N_Q; n++) |
644 } | 788 sbr->bs_invf_mode[ch][n] = invf_mode; |
645 | 789 } else |
646 /* table 10 */ | 790 #endif |
647 static void sbr_envelope(bitfile *ld, sbr_info *sbr, uint8_t ch) | |
648 { | |
649 uint8_t env, band; | |
650 int8_t delta = 0; | |
651 sbr_huff_tab t_huff, f_huff; | |
652 | |
653 if ((sbr->L_E[ch] == 1) && (sbr->bs_frame_class[ch] == FIXFIX)) | |
654 sbr->amp_res[ch] = 0; | |
655 else | |
656 sbr->amp_res[ch] = sbr->bs_amp_res; | |
657 | |
658 if ((sbr->bs_coupling) && (ch == 1)) | |
659 { | |
660 delta = 1; | |
661 if (sbr->amp_res[ch]) | |
662 { | |
663 t_huff = t_huffman_env_bal_3_0dB; | |
664 f_huff = f_huffman_env_bal_3_0dB; | |
665 } else { | |
666 t_huff = t_huffman_env_bal_1_5dB; | |
667 f_huff = f_huffman_env_bal_1_5dB; | |
668 } | |
669 } else { | |
670 delta = 0; | |
671 if (sbr->amp_res[ch]) | |
672 { | |
673 t_huff = t_huffman_env_3_0dB; | |
674 f_huff = f_huffman_env_3_0dB; | |
675 } else { | |
676 t_huff = t_huffman_env_1_5dB; | |
677 f_huff = f_huffman_env_1_5dB; | |
678 } | |
679 } | |
680 | |
681 for (env = 0; env < sbr->L_E[ch]; env++) | |
682 { | |
683 if (sbr->bs_df_env[ch][env] == 0) | |
684 { | |
685 if ((sbr->bs_coupling == 1) && (ch == 1)) | |
686 { | 791 { |
687 if (sbr->amp_res[ch]) | 792 for (n = 0; n < sbr->N_Q; n++) |
688 { | |
689 sbr->E[ch][0][env] = (faad_getbits(ld, 5 | |
690 DEBUGVAR(1,272,"sbr_envelope(): bs_data_env")) << delta); | |
691 } else { | |
692 sbr->E[ch][0][env] = (faad_getbits(ld, 6 | |
693 DEBUGVAR(1,273,"sbr_envelope(): bs_data_env")) << delta); | |
694 } | |
695 } else { | |
696 if (sbr->amp_res[ch]) | |
697 { | |
698 sbr->E[ch][0][env] = (faad_getbits(ld, 6 | |
699 DEBUGVAR(1,274,"sbr_envelope(): bs_data_env")) << delta); | |
700 } else { | |
701 sbr->E[ch][0][env] = (faad_getbits(ld, 7 | |
702 DEBUGVAR(1,275,"sbr_envelope(): bs_data_env")) << delta); | |
703 } | |
704 } | |
705 | |
706 for (band = 1; band < sbr->n[sbr->f[ch][env]]; band++) | |
707 { | 793 { |
708 sbr->E[ch][band][env] = (sbr_huff_dec(ld, f_huff) << delta); | 794 sbr->bs_invf_mode[ch][n] = faad_getbits(ld, 2 |
709 } | 795 DEBUGVAR(1,271,"invf_mode(): bs_invf_mode")); |
710 | 796 } |
711 } else { | 797 } |
712 for (band = 0; band < sbr->n[sbr->f[ch][env]]; band++) | |
713 { | |
714 sbr->E[ch][band][env] = (sbr_huff_dec(ld, t_huff) << delta); | |
715 } | |
716 } | |
717 } | |
718 | |
719 #if 0 | |
720 // TEMP | |
721 if (sbr->frame == 19) | |
722 { | |
723 int l, k; | |
724 | |
725 printf("\n"); | |
726 for (l = 0; l < sbr->L_E[ch]; l++) | |
727 { | |
728 for (k = 0; k < sbr->n[sbr->f[ch][l]]; k++) | |
729 { | |
730 printf("l:%d k:%d E:%d\n",l, k, sbr->E[ch][k][l]); | |
731 } | |
732 } | |
733 } | |
734 // end TEMP | |
735 #endif | |
736 | |
737 extract_envelope_data(sbr, ch); | |
738 | |
739 #if 0 | |
740 // TEMP | |
741 if (sbr->frame == 21) | |
742 { | |
743 int l, k; | |
744 | |
745 printf("\n"); | |
746 for (l = 0; l < sbr->L_E[ch]; l++) | |
747 { | |
748 for (k = 0; k < sbr->n[sbr->f[ch][l]]; k++) | |
749 { | |
750 //printf("l:%d k:%d E:%d\n",l,k, sbr->E[ch][k][l]); | |
751 printf("%d\n", sbr->E[ch][k][l]); | |
752 } | |
753 } | |
754 } | |
755 // end TEMP | |
756 #endif | |
757 } | |
758 | |
759 /* table 11 */ | |
760 static void sbr_noise(bitfile *ld, sbr_info *sbr, uint8_t ch) | |
761 { | |
762 uint8_t noise, band; | |
763 int8_t delta = 0; | |
764 sbr_huff_tab t_huff, f_huff; | |
765 | |
766 if ((sbr->bs_coupling == 1) && (ch == 1)) | |
767 { | |
768 delta = 1; | |
769 t_huff = t_huffman_noise_bal_3_0dB; | |
770 f_huff = f_huffman_env_bal_3_0dB; | |
771 } else { | |
772 delta = 0; | |
773 t_huff = t_huffman_noise_3_0dB; | |
774 f_huff = f_huffman_env_3_0dB; | |
775 } | |
776 | |
777 for (noise = 0; noise < sbr->L_Q[ch]; noise++) | |
778 { | |
779 if(sbr->bs_df_noise[ch][noise] == 0) | |
780 { | |
781 if ((sbr->bs_coupling == 1) && (ch == 1)) | |
782 { | |
783 sbr->Q[ch][0][noise] = (faad_getbits(ld, 5 | |
784 DEBUGVAR(1,276,"sbr_noise(): bs_data_noise")) << delta); | |
785 } else { | |
786 sbr->Q[ch][0][noise] = (faad_getbits(ld, 5 | |
787 DEBUGVAR(1,277,"sbr_noise(): bs_data_noise")) << delta); | |
788 } | |
789 for (band = 1; band < sbr->N_Q; band++) | |
790 { | |
791 sbr->Q[ch][band][noise] = (sbr_huff_dec(ld, f_huff) << delta); | |
792 } | |
793 } else { | |
794 for (band = 0; band < sbr->N_Q; band++) | |
795 { | |
796 sbr->Q[ch][band][noise] = (sbr_huff_dec(ld, t_huff) << delta); | |
797 } | |
798 } | |
799 } | |
800 | |
801 extract_noise_floor_data(sbr, ch); | |
802 } | 798 } |
803 | 799 |
804 /* table 12 */ | 800 /* table 12 */ |
805 static void sinusoidal_coding(bitfile *ld, sbr_info *sbr, uint8_t ch) | 801 static void sinusoidal_coding(bitfile *ld, sbr_info *sbr, uint8_t ch) |
806 { | 802 { |