Mercurial > mplayer.hg
comparison libfaad2/sbr_syntax.c @ 12527:4a370c80fe5c
update to the 2.0 release of faad, patch by adland
author | diego |
---|---|
date | Wed, 02 Jun 2004 22:59:04 +0000 |
parents | 3185f64f6350 |
children | d81145997036 |
comparison
equal
deleted
inserted
replaced
12526:e183ad37d24c | 12527:4a370c80fe5c |
---|---|
1 /* | 1 /* |
2 ** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding | 2 ** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding |
3 ** Copyright (C) 2003 M. Bakker, Ahead Software AG, http://www.nero.com | 3 ** Copyright (C) 2003-2004 M. Bakker, Ahead Software AG, http://www.nero.com |
4 ** | 4 ** |
5 ** This program is free software; you can redistribute it and/or modify | 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 | 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 | 7 ** the Free Software Foundation; either version 2 of the License, or |
8 ** (at your option) any later version. | 8 ** (at your option) any later version. |
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.11 2003/09/30 16:32:02 menno Exp $ | 25 ** $Id: sbr_syntax.c,v 1.2 2003/10/03 22:22:27 alex Exp $ |
26 **/ | 26 **/ |
27 | 27 |
28 #include "common.h" | 28 #include "common.h" |
29 #include "structs.h" | 29 #include "structs.h" |
30 | 30 |
35 #include "sbr_huff.h" | 35 #include "sbr_huff.h" |
36 #include "sbr_fbt.h" | 36 #include "sbr_fbt.h" |
37 #include "sbr_tf_grid.h" | 37 #include "sbr_tf_grid.h" |
38 #include "sbr_e_nf.h" | 38 #include "sbr_e_nf.h" |
39 #include "bits.h" | 39 #include "bits.h" |
40 #ifdef PS_DEC | |
41 #include "ps_dec.h" | |
42 #endif | |
43 #ifdef DRM_PS | |
44 #include "drm_dec.h" | |
45 #endif | |
40 #include "analysis.h" | 46 #include "analysis.h" |
41 | 47 |
48 /* static function declarations */ | |
49 static void sbr_header(bitfile *ld, sbr_info *sbr); | |
50 static uint8_t sbr_data(bitfile *ld, sbr_info *sbr); | |
51 static uint16_t sbr_extension(bitfile *ld, sbr_info *sbr, | |
52 uint8_t bs_extension_id, uint16_t num_bits_left); | |
53 static uint8_t sbr_single_channel_element(bitfile *ld, sbr_info *sbr); | |
54 static uint8_t sbr_channel_pair_element(bitfile *ld, sbr_info *sbr); | |
55 static uint8_t sbr_grid(bitfile *ld, sbr_info *sbr, uint8_t ch); | |
56 static void sbr_dtdf(bitfile *ld, sbr_info *sbr, uint8_t ch); | |
57 static void invf_mode(bitfile *ld, sbr_info *sbr, uint8_t ch); | |
58 static void sinusoidal_coding(bitfile *ld, sbr_info *sbr, uint8_t ch); | |
59 | |
60 | |
42 static void sbr_reset(sbr_info *sbr) | 61 static void sbr_reset(sbr_info *sbr) |
43 { | 62 { |
63 #if 0 | |
64 printf("%d\n", sbr->bs_start_freq_prev); | |
65 printf("%d\n", sbr->bs_stop_freq_prev); | |
66 printf("%d\n", sbr->bs_freq_scale_prev); | |
67 printf("%d\n", sbr->bs_alter_scale_prev); | |
68 printf("%d\n", sbr->bs_xover_band_prev); | |
69 printf("%d\n\n", sbr->bs_noise_bands_prev); | |
70 #endif | |
71 | |
44 /* if these are different from the previous frame: Reset = 1 */ | 72 /* if these are different from the previous frame: Reset = 1 */ |
45 if ((sbr->bs_start_freq != sbr->bs_start_freq_prev) || | 73 if ((sbr->bs_start_freq != sbr->bs_start_freq_prev) || |
46 (sbr->bs_stop_freq != sbr->bs_stop_freq_prev) || | 74 (sbr->bs_stop_freq != sbr->bs_stop_freq_prev) || |
47 (sbr->bs_freq_scale != sbr->bs_freq_scale_prev) || | 75 (sbr->bs_freq_scale != sbr->bs_freq_scale_prev) || |
48 (sbr->bs_alter_scale != sbr->bs_alter_scale_prev)) | 76 (sbr->bs_alter_scale != sbr->bs_alter_scale_prev)) |
76 sbr->Reset = 1; | 104 sbr->Reset = 1; |
77 } | 105 } |
78 } | 106 } |
79 | 107 |
80 /* table 2 */ | 108 /* table 2 */ |
81 uint8_t sbr_extension_data(bitfile *ld, sbr_info *sbr, uint8_t id_aac) | 109 uint8_t sbr_extension_data(bitfile *ld, sbr_info *sbr, uint16_t cnt) |
82 { | 110 { |
83 uint8_t result; | 111 uint8_t result = 0; |
112 uint16_t num_align_bits = 0; | |
113 uint16_t num_sbr_bits = (uint16_t)faad_get_processed_bits(ld); | |
114 | |
84 #ifdef DRM | 115 #ifdef DRM |
85 uint8_t crc_len; | 116 if (!sbr->Is_DRM_SBR) |
86 | 117 #endif |
87 if (sbr->Is_DRM_SBR) | 118 { |
88 faad_getbits(ld, 8); /* 8-bit CRC */ | 119 uint8_t bs_extension_type = (uint8_t)faad_getbits(ld, 4 |
89 else | 120 DEBUGVAR(1,198,"sbr_bitstream(): bs_extension_type")); |
90 #endif | 121 |
91 { | 122 if (bs_extension_type == EXT_SBR_DATA_CRC) |
92 uint8_t bs_extension_type = (uint8_t)faad_getbits(ld, 4 | 123 { |
93 DEBUGVAR(1,198,"sbr_bitstream(): bs_extension_type")); | 124 sbr->bs_sbr_crc_bits = (uint16_t)faad_getbits(ld, 10 |
94 | 125 DEBUGVAR(1,199,"sbr_bitstream(): bs_sbr_crc_bits")); |
95 if (bs_extension_type == EXT_SBR_DATA_CRC) | 126 } |
96 { | |
97 sbr->bs_sbr_crc_bits = (uint16_t)faad_getbits(ld, 10 | |
98 DEBUGVAR(1,199,"sbr_bitstream(): bs_sbr_crc_bits")); | |
99 } | |
100 } | 127 } |
101 | 128 |
102 sbr->bs_header_flag = faad_get1bit(ld | 129 sbr->bs_header_flag = faad_get1bit(ld |
103 DEBUGVAR(1,200,"sbr_bitstream(): bs_header_flag")); | 130 DEBUGVAR(1,200,"sbr_bitstream(): bs_header_flag")); |
104 | 131 |
132 if (sbr->bs_header_flag) | |
133 sbr_header(ld, sbr); | |
134 | |
135 /* Reset? */ | |
136 sbr_reset(sbr); | |
137 | |
138 /* first frame should have a header */ | |
139 //if (!(sbr->frame == 0 && sbr->bs_header_flag == 0)) | |
140 if (sbr->header_count != 0) | |
141 { | |
142 if (sbr->Reset || (sbr->bs_header_flag && sbr->just_seeked)) | |
143 { | |
144 uint8_t k2; | |
145 | |
146 /* calculate the Master Frequency Table */ | |
147 sbr->k0 = qmf_start_channel(sbr->bs_start_freq, sbr->bs_samplerate_mode, | |
148 sbr->sample_rate); | |
149 k2 = qmf_stop_channel(sbr->bs_stop_freq, sbr->sample_rate, sbr->k0); | |
150 | |
151 /* check k0 and k2 */ | |
152 if (sbr->sample_rate >= 48000) | |
153 { | |
154 if ((k2 - sbr->k0) > 32) | |
155 result += 1; | |
156 } else if (sbr->sample_rate <= 32000) { | |
157 if ((k2 - sbr->k0) > 48) | |
158 result += 1; | |
159 } else { /* (sbr->sample_rate == 44100) */ | |
160 if ((k2 - sbr->k0) > 45) | |
161 result += 1; | |
162 } | |
163 | |
164 if (sbr->bs_freq_scale == 0) | |
165 { | |
166 result += master_frequency_table_fs0(sbr, sbr->k0, k2, | |
167 sbr->bs_alter_scale); | |
168 } else { | |
169 result += master_frequency_table(sbr, sbr->k0, k2, sbr->bs_freq_scale, | |
170 sbr->bs_alter_scale); | |
171 } | |
172 result += derived_frequency_table(sbr, sbr->bs_xover_band, k2); | |
173 | |
174 result = (result > 0) ? 1 : 0; | |
175 } | |
176 | |
177 if (result == 0) | |
178 result = sbr_data(ld, sbr); | |
179 } else { | |
180 result = 1; | |
181 } | |
182 | |
105 #ifdef DRM | 183 #ifdef DRM |
106 if (sbr->Is_DRM_SBR) | 184 if (!sbr->Is_DRM_SBR) |
107 { | 185 #endif |
108 /* Check CRC, get number of bits for check */ | 186 { |
109 if (id_aac == ID_SCE) | 187 num_sbr_bits = (uint16_t)faad_get_processed_bits(ld) - num_sbr_bits; |
110 { | 188 /* -4 does not apply, bs_extension_type is re-read in this function */ |
111 if (sbr->lcstereo_flag) | 189 num_align_bits = 8*cnt /*- 4*/ - num_sbr_bits; |
112 { | 190 |
113 if (sbr->bs_header_flag) | 191 while (num_align_bits > 7) |
114 crc_len = min(76, sbr->data_size_bits); | 192 { |
115 else | 193 faad_getbits(ld, 8 |
116 crc_len = min(47, sbr->data_size_bits); | 194 DEBUGVAR(1,999,"sbr_bitstream(): num_align_bits")); |
117 } else { | 195 num_align_bits -= 8; |
118 if (sbr->bs_header_flag) | 196 } |
119 crc_len = min(74, sbr->data_size_bits); | 197 faad_getbits(ld, num_align_bits |
120 else | 198 DEBUGVAR(1,999,"sbr_bitstream(): num_align_bits")); |
121 crc_len = min(47, sbr->data_size_bits); | 199 } |
122 } | 200 |
123 } else { | 201 return result; |
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 | |
140 if (sbr->bs_header_flag) | |
141 sbr_header(ld, sbr, id_aac); | |
142 | |
143 /* TODO: Reset? */ | |
144 sbr_reset(sbr); | |
145 | |
146 /* first frame should have a header */ | |
147 if (sbr->frame == 0 && sbr->bs_header_flag == 0) | |
148 return 1; | |
149 | |
150 | |
151 if (sbr->Reset || (sbr->bs_header_flag && sbr->just_seeked)) | |
152 { | |
153 uint8_t k2; | |
154 | |
155 /* calculate the Master Frequency Table */ | |
156 sbr->k0 = qmf_start_channel(sbr->bs_start_freq, sbr->bs_samplerate_mode, | |
157 sbr->sample_rate); | |
158 k2 = qmf_stop_channel(sbr->bs_stop_freq, sbr->sample_rate, sbr->k0); | |
159 | |
160 /* check k0 and k2 */ | |
161 if (sbr->sample_rate >= 48000) | |
162 { | |
163 if ((k2 - sbr->k0) > 32) | |
164 return 1; | |
165 } else if (sbr->sample_rate <= 32000) { | |
166 if ((k2 - sbr->k0) > 48) | |
167 return 1; | |
168 } else { /* (sbr->sample_rate == 44100) */ | |
169 if ((k2 - sbr->k0) > 45) | |
170 return 1; | |
171 } | |
172 | |
173 if (sbr->bs_freq_scale == 0) | |
174 { | |
175 master_frequency_table_fs0(sbr, sbr->k0, k2, sbr->bs_alter_scale); | |
176 } else { | |
177 master_frequency_table(sbr, sbr->k0, k2, sbr->bs_freq_scale, | |
178 sbr->bs_alter_scale); | |
179 } | |
180 if ((result = derived_frequency_table(sbr, sbr->bs_xover_band, k2)) > 0) | |
181 return result; | |
182 } | |
183 | |
184 if ((result = sbr_data(ld, sbr, id_aac)) > 0) | |
185 return result; | |
186 | |
187 /* no error */ | |
188 return 0; | |
189 } | 202 } |
190 | 203 |
191 /* table 3 */ | 204 /* table 3 */ |
192 static void sbr_header(bitfile *ld, sbr_info *sbr, uint8_t id_aac) | 205 static void sbr_header(bitfile *ld, sbr_info *sbr) |
193 { | 206 { |
194 uint8_t bs_header_extra_1, bs_header_extra_2; | 207 uint8_t bs_header_extra_1, bs_header_extra_2; |
195 | 208 |
196 sbr->header_count++; | 209 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 | |
203 | 210 |
204 sbr->bs_amp_res = faad_get1bit(ld | 211 sbr->bs_amp_res = faad_get1bit(ld |
205 DEBUGVAR(1,203,"sbr_header(): bs_amp_res")); | 212 DEBUGVAR(1,203,"sbr_header(): bs_amp_res")); |
206 | 213 |
207 /* bs_start_freq and bs_stop_freq must define a fequency band that does | 214 /* bs_start_freq and bs_stop_freq must define a fequency band that does |
208 not exceed 48 channels */ | 215 not exceed 48 channels */ |
209 sbr->bs_start_freq = faad_getbits(ld, 4 | 216 sbr->bs_start_freq = (uint8_t)faad_getbits(ld, 4 |
210 DEBUGVAR(1,204,"sbr_header(): bs_start_freq")); | 217 DEBUGVAR(1,204,"sbr_header(): bs_start_freq")); |
211 sbr->bs_stop_freq = faad_getbits(ld, 4 | 218 sbr->bs_stop_freq = (uint8_t)faad_getbits(ld, 4 |
212 DEBUGVAR(1,205,"sbr_header(): bs_stop_freq")); | 219 DEBUGVAR(1,205,"sbr_header(): bs_stop_freq")); |
213 sbr->bs_xover_band = faad_getbits(ld, 3 | 220 sbr->bs_xover_band = (uint8_t)faad_getbits(ld, 3 |
214 DEBUGVAR(1,206,"sbr_header(): bs_xover_band")); | 221 DEBUGVAR(1,206,"sbr_header(): bs_xover_band")); |
215 faad_getbits(ld, 2 | 222 faad_getbits(ld, 2 |
216 DEBUGVAR(1,207,"sbr_header(): bs_reserved_bits_hdr")); | 223 DEBUGVAR(1,207,"sbr_header(): bs_reserved_bits_hdr")); |
217 #ifdef DRM | 224 bs_header_extra_1 = (uint8_t)faad_get1bit(ld |
218 if (sbr->Is_DRM_SBR) | |
219 sbr->bs_dataextra = faad_getbits(ld, 1); | |
220 #endif | |
221 bs_header_extra_1 = faad_get1bit(ld | |
222 DEBUGVAR(1,208,"sbr_header(): bs_header_extra_1")); | 225 DEBUGVAR(1,208,"sbr_header(): bs_header_extra_1")); |
223 bs_header_extra_2 = faad_get1bit(ld | 226 bs_header_extra_2 = (uint8_t)faad_get1bit(ld |
224 DEBUGVAR(1,209,"sbr_header(): bs_header_extra_2")); | 227 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 | |
230 | 228 |
231 if (bs_header_extra_1) | 229 if (bs_header_extra_1) |
232 { | 230 { |
233 sbr->bs_freq_scale = faad_getbits(ld, 2 | 231 sbr->bs_freq_scale = (uint8_t)faad_getbits(ld, 2 |
234 DEBUGVAR(1,211,"sbr_header(): bs_freq_scale")); | 232 DEBUGVAR(1,211,"sbr_header(): bs_freq_scale")); |
235 sbr->bs_alter_scale = faad_get1bit(ld | 233 sbr->bs_alter_scale = (uint8_t)faad_get1bit(ld |
236 DEBUGVAR(1,212,"sbr_header(): bs_alter_scale")); | 234 DEBUGVAR(1,212,"sbr_header(): bs_alter_scale")); |
237 sbr->bs_noise_bands = faad_getbits(ld, 2 | 235 sbr->bs_noise_bands = (uint8_t)faad_getbits(ld, 2 |
238 DEBUGVAR(1,213,"sbr_header(): bs_noise_bands")); | 236 DEBUGVAR(1,213,"sbr_header(): bs_noise_bands")); |
239 } else { | 237 } else { |
240 /* Default values */ | 238 /* Default values */ |
241 sbr->bs_freq_scale = 2; | 239 sbr->bs_freq_scale = 2; |
242 sbr->bs_alter_scale = 1; | 240 sbr->bs_alter_scale = 1; |
243 sbr->bs_noise_bands = 2; | 241 sbr->bs_noise_bands = 2; |
244 } | 242 } |
245 | 243 |
246 if (bs_header_extra_2) | 244 if (bs_header_extra_2) |
247 { | 245 { |
248 sbr->bs_limiter_bands = faad_getbits(ld, 2 | 246 sbr->bs_limiter_bands = (uint8_t)faad_getbits(ld, 2 |
249 DEBUGVAR(1,214,"sbr_header(): bs_limiter_bands")); | 247 DEBUGVAR(1,214,"sbr_header(): bs_limiter_bands")); |
250 sbr->bs_limiter_gains = faad_getbits(ld, 2 | 248 sbr->bs_limiter_gains = (uint8_t)faad_getbits(ld, 2 |
251 DEBUGVAR(1,215,"sbr_header(): bs_limiter_gains")); | 249 DEBUGVAR(1,215,"sbr_header(): bs_limiter_gains")); |
252 sbr->bs_interpol_freq = faad_get1bit(ld | 250 sbr->bs_interpol_freq = (uint8_t)faad_get1bit(ld |
253 DEBUGVAR(1,216,"sbr_header(): bs_interpol_freq")); | 251 DEBUGVAR(1,216,"sbr_header(): bs_interpol_freq")); |
254 sbr->bs_smoothing_mode = faad_get1bit(ld | 252 sbr->bs_smoothing_mode = (uint8_t)faad_get1bit(ld |
255 DEBUGVAR(1,217,"sbr_header(): bs_smoothing_mode")); | 253 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 { | 254 } else { |
262 /* Default values */ | 255 /* Default values */ |
263 sbr->bs_limiter_bands = 2; | 256 sbr->bs_limiter_bands = 2; |
264 sbr->bs_limiter_gains = 2; | 257 sbr->bs_limiter_gains = 2; |
265 sbr->bs_interpol_freq = 1; | 258 sbr->bs_interpol_freq = 1; |
288 printf("\n"); | 281 printf("\n"); |
289 #endif | 282 #endif |
290 } | 283 } |
291 | 284 |
292 /* table 4 */ | 285 /* table 4 */ |
293 static uint8_t sbr_data(bitfile *ld, sbr_info *sbr, uint8_t id_aac) | 286 static uint8_t sbr_data(bitfile *ld, sbr_info *sbr) |
294 { | 287 { |
295 uint8_t result; | 288 uint8_t result; |
296 #if 0 | 289 #if 0 |
297 sbr->bs_samplerate_mode = faad_get1bit(ld | 290 sbr->bs_samplerate_mode = faad_get1bit(ld |
298 DEBUGVAR(1,219,"sbr_data(): bs_samplerate_mode")); | 291 DEBUGVAR(1,219,"sbr_data(): bs_samplerate_mode")); |
299 #endif | 292 #endif |
300 | 293 |
301 sbr->rate = (sbr->bs_samplerate_mode) ? 2 : 1; | 294 sbr->rate = (sbr->bs_samplerate_mode) ? 2 : 1; |
302 | 295 |
303 #ifdef DRM | 296 switch (sbr->id_aac) |
304 if (sbr->Is_DRM_SBR) | |
305 sbr->rate = 2; | |
306 #endif | |
307 | |
308 switch (id_aac) | |
309 { | 297 { |
310 case ID_SCE: | 298 case ID_SCE: |
311 if ((result = sbr_single_channel_element(ld, sbr)) > 0) | 299 if ((result = sbr_single_channel_element(ld, sbr)) > 0) |
312 return result; | 300 return result; |
313 break; | 301 break; |
314 case ID_CPE: | 302 case ID_CPE: |
315 if ((result = sbr_channel_pair_element(ld, sbr)) > 0) | 303 if ((result = sbr_channel_pair_element(ld, sbr)) > 0) |
316 return result; | 304 return result; |
317 break; | 305 break; |
318 } | 306 } |
319 | 307 |
320 return 0; | 308 return 0; |
321 } | 309 } |
322 | 310 |
323 /* table 5 */ | 311 /* table 5 */ |
324 static uint8_t sbr_single_channel_element(bitfile *ld, sbr_info *sbr) | 312 static uint8_t sbr_single_channel_element(bitfile *ld, sbr_info *sbr) |
325 { | 313 { |
326 uint8_t result; | 314 uint8_t result; |
327 | 315 |
328 #ifdef DRM | |
329 if (!sbr->Is_DRM_SBR) | |
330 #endif | |
331 { | |
332 if (faad_get1bit(ld | 316 if (faad_get1bit(ld |
333 DEBUGVAR(1,220,"sbr_single_channel_element(): bs_data_extra"))) | 317 DEBUGVAR(1,220,"sbr_single_channel_element(): bs_data_extra"))) |
334 { | 318 { |
335 faad_getbits(ld, 4 | 319 faad_getbits(ld, 4 |
336 DEBUGVAR(1,221,"sbr_single_channel_element(): bs_reserved_bits_data")); | 320 DEBUGVAR(1,221,"sbr_single_channel_element(): bs_reserved_bits_data")); |
337 } | 321 } |
338 } | 322 |
323 #ifdef DRM | |
324 /* bs_coupling, from sbr_channel_pair_base_element(bs_amp_res) */ | |
325 if (sbr->Is_DRM_SBR) | |
326 faad_get1bit(ld); | |
327 #endif | |
339 | 328 |
340 if ((result = sbr_grid(ld, sbr, 0)) > 0) | 329 if ((result = sbr_grid(ld, sbr, 0)) > 0) |
341 return result; | 330 return result; |
342 sbr_dtdf(ld, sbr, 0); | 331 sbr_dtdf(ld, sbr, 0); |
343 invf_mode(ld, sbr, 0); | 332 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 | |
354 sbr_envelope(ld, sbr, 0); | 333 sbr_envelope(ld, sbr, 0); |
355 sbr_noise(ld, sbr, 0); | 334 sbr_noise(ld, sbr, 0); |
356 | 335 |
357 envelope_noise_dequantisation(sbr, 0); | 336 envelope_noise_dequantisation(sbr, 0); |
358 | 337 |
359 memset(sbr->bs_add_harmonic[0], 0, 64*sizeof(uint8_t)); | 338 memset(sbr->bs_add_harmonic[0], 0, 64*sizeof(uint8_t)); |
360 | 339 |
361 #ifdef DRM | |
362 if (sbr->Is_DRM_SBR) | |
363 sbr->bs_add_harmonic_flag[0] = 0; | |
364 else | |
365 #endif | |
366 { | |
367 sbr->bs_add_harmonic_flag[0] = faad_get1bit(ld | 340 sbr->bs_add_harmonic_flag[0] = faad_get1bit(ld |
368 DEBUGVAR(1,223,"sbr_single_channel_element(): bs_add_harmonic_flag[0]")); | 341 DEBUGVAR(1,223,"sbr_single_channel_element(): bs_add_harmonic_flag[0]")); |
369 } | |
370 if (sbr->bs_add_harmonic_flag[0]) | 342 if (sbr->bs_add_harmonic_flag[0]) |
371 sinusoidal_coding(ld, sbr, 0); | 343 sinusoidal_coding(ld, sbr, 0); |
372 | 344 |
373 sbr->bs_extended_data = faad_get1bit(ld | 345 sbr->bs_extended_data = faad_get1bit(ld |
374 DEBUGVAR(1,224,"sbr_single_channel_element(): bs_extended_data[0]")); | 346 DEBUGVAR(1,224,"sbr_single_channel_element(): bs_extended_data[0]")); |
375 if (sbr->bs_extended_data) | 347 if (sbr->bs_extended_data) |
376 { | 348 { |
377 uint16_t nr_bits_left; | 349 uint16_t nr_bits_left; |
378 uint16_t cnt = faad_getbits(ld, 4 | 350 uint16_t cnt = (uint16_t)faad_getbits(ld, 4 |
379 DEBUGVAR(1,225,"sbr_single_channel_element(): bs_extension_size")); | 351 DEBUGVAR(1,225,"sbr_single_channel_element(): bs_extension_size")); |
380 if (cnt == 15) | 352 if (cnt == 15) |
381 { | 353 { |
382 cnt += faad_getbits(ld, 8 | 354 cnt += (uint16_t)faad_getbits(ld, 8 |
383 DEBUGVAR(1,226,"sbr_single_channel_element(): bs_esc_count")); | 355 DEBUGVAR(1,226,"sbr_single_channel_element(): bs_esc_count")); |
384 } | 356 } |
385 | 357 |
386 nr_bits_left = 8 * cnt; | 358 nr_bits_left = 8 * cnt; |
387 while (nr_bits_left > 7) | 359 while (nr_bits_left > 7) |
388 { | 360 { |
389 sbr->bs_extension_id = faad_getbits(ld, 2 | 361 sbr->bs_extension_id = (uint8_t)faad_getbits(ld, 2 |
390 DEBUGVAR(1,227,"sbr_single_channel_element(): bs_extension_id")); | 362 DEBUGVAR(1,227,"sbr_single_channel_element(): bs_extension_id")); |
391 nr_bits_left -= 2; | 363 nr_bits_left -= 2; |
392 /* sbr_extension(ld, sbr, 0, nr_bits_left); */ | 364 nr_bits_left -= sbr_extension(ld, sbr, sbr->bs_extension_id, nr_bits_left); |
393 #ifdef DRM | 365 } |
394 if (!sbr->Is_DRM_SBR) | 366 |
395 #endif | 367 /* Corrigendum */ |
396 { | 368 if (nr_bits_left > 0) |
397 sbr->bs_extension_data = faad_getbits(ld, 6 | 369 { |
398 DEBUGVAR(1,279,"sbr_single_channel_element(): bs_extension_data")); | 370 faad_getbits(ld, nr_bits_left |
399 } | 371 DEBUGVAR(1,280,"sbr_single_channel_element(): nr_bits_left")); |
400 } | 372 } |
401 } | 373 } |
402 | 374 |
403 return 0; | 375 return 0; |
404 } | 376 } |
405 | 377 |
406 /* table 6 */ | 378 /* table 6 */ |
407 static uint8_t sbr_channel_pair_element(bitfile *ld, sbr_info *sbr) | 379 static uint8_t sbr_channel_pair_element(bitfile *ld, sbr_info *sbr) |
408 { | 380 { |
409 uint8_t n, result; | 381 uint8_t n, result; |
410 | 382 |
411 #ifdef DRM | |
412 if (!sbr->Is_DRM_SBR) | |
413 #endif | |
414 { | |
415 if (faad_get1bit(ld | 383 if (faad_get1bit(ld |
416 DEBUGVAR(1,228,"sbr_single_channel_element(): bs_data_extra"))) | 384 DEBUGVAR(1,228,"sbr_single_channel_element(): bs_data_extra"))) |
417 { | 385 { |
418 faad_getbits(ld, 4 | 386 faad_getbits(ld, 4 |
419 DEBUGVAR(1,228,"sbr_channel_pair_element(): bs_reserved_bits_data")); | 387 DEBUGVAR(1,228,"sbr_channel_pair_element(): bs_reserved_bits_data")); |
420 faad_getbits(ld, 4 | 388 faad_getbits(ld, 4 |
421 DEBUGVAR(1,228,"sbr_channel_pair_element(): bs_reserved_bits_data")); | 389 DEBUGVAR(1,228,"sbr_channel_pair_element(): bs_reserved_bits_data")); |
422 } | |
423 } | 390 } |
424 | 391 |
425 sbr->bs_coupling = faad_get1bit(ld | 392 sbr->bs_coupling = faad_get1bit(ld |
426 DEBUGVAR(1,228,"sbr_channel_pair_element(): bs_coupling")); | 393 DEBUGVAR(1,228,"sbr_channel_pair_element(): bs_coupling")); |
427 | 394 |
445 sbr->t_Q[1][n] = sbr->t_Q[0][n]; | 412 sbr->t_Q[1][n] = sbr->t_Q[0][n]; |
446 | 413 |
447 sbr_dtdf(ld, sbr, 0); | 414 sbr_dtdf(ld, sbr, 0); |
448 sbr_dtdf(ld, sbr, 1); | 415 sbr_dtdf(ld, sbr, 1); |
449 invf_mode(ld, sbr, 0); | 416 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 | |
460 | 417 |
461 /* more copying */ | 418 /* more copying */ |
462 for (n = 0; n < sbr->N_Q; n++) | 419 for (n = 0; n < sbr->N_Q; n++) |
463 sbr->bs_invf_mode[1][n] = sbr->bs_invf_mode[0][n]; | 420 sbr->bs_invf_mode[1][n] = sbr->bs_invf_mode[0][n]; |
464 | 421 |
468 sbr_noise(ld, sbr, 1); | 425 sbr_noise(ld, sbr, 1); |
469 | 426 |
470 memset(sbr->bs_add_harmonic[0], 0, 64*sizeof(uint8_t)); | 427 memset(sbr->bs_add_harmonic[0], 0, 64*sizeof(uint8_t)); |
471 memset(sbr->bs_add_harmonic[1], 0, 64*sizeof(uint8_t)); | 428 memset(sbr->bs_add_harmonic[1], 0, 64*sizeof(uint8_t)); |
472 | 429 |
473 #ifdef DRM | |
474 if (sbr->Is_DRM_SBR) | |
475 sbr->bs_add_harmonic_flag[0] = 0; | |
476 else | |
477 #endif | |
478 { | |
479 sbr->bs_add_harmonic_flag[0] = faad_get1bit(ld | 430 sbr->bs_add_harmonic_flag[0] = faad_get1bit(ld |
480 DEBUGVAR(1,231,"sbr_channel_pair_element(): bs_add_harmonic_flag[0]")); | 431 DEBUGVAR(1,231,"sbr_channel_pair_element(): bs_add_harmonic_flag[0]")); |
481 } | |
482 if (sbr->bs_add_harmonic_flag[0]) | 432 if (sbr->bs_add_harmonic_flag[0]) |
483 sinusoidal_coding(ld, sbr, 0); | 433 sinusoidal_coding(ld, sbr, 0); |
484 | 434 |
485 #ifdef DRM | |
486 if (sbr->Is_DRM_SBR) | |
487 sbr->bs_add_harmonic_flag[1] = 0; | |
488 else | |
489 #endif | |
490 { | |
491 sbr->bs_add_harmonic_flag[1] = faad_get1bit(ld | 435 sbr->bs_add_harmonic_flag[1] = faad_get1bit(ld |
492 DEBUGVAR(1,232,"sbr_channel_pair_element(): bs_add_harmonic_flag[1]")); | 436 DEBUGVAR(1,232,"sbr_channel_pair_element(): bs_add_harmonic_flag[1]")); |
493 } | |
494 if (sbr->bs_add_harmonic_flag[1]) | 437 if (sbr->bs_add_harmonic_flag[1]) |
495 sinusoidal_coding(ld, sbr, 1); | 438 sinusoidal_coding(ld, sbr, 1); |
496 } else { | 439 } else { |
497 if ((result = sbr_grid(ld, sbr, 0)) > 0) | 440 if ((result = sbr_grid(ld, sbr, 0)) > 0) |
498 return result; | 441 return result; |
500 return result; | 443 return result; |
501 sbr_dtdf(ld, sbr, 0); | 444 sbr_dtdf(ld, sbr, 0); |
502 sbr_dtdf(ld, sbr, 1); | 445 sbr_dtdf(ld, sbr, 1); |
503 invf_mode(ld, sbr, 0); | 446 invf_mode(ld, sbr, 0); |
504 invf_mode(ld, sbr, 1); | 447 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 | |
516 sbr_envelope(ld, sbr, 0); | 448 sbr_envelope(ld, sbr, 0); |
517 sbr_envelope(ld, sbr, 1); | 449 sbr_envelope(ld, sbr, 1); |
518 sbr_noise(ld, sbr, 0); | 450 sbr_noise(ld, sbr, 0); |
519 sbr_noise(ld, sbr, 1); | 451 sbr_noise(ld, sbr, 1); |
520 | 452 |
521 memset(sbr->bs_add_harmonic[0], 0, 64*sizeof(uint8_t)); | 453 memset(sbr->bs_add_harmonic[0], 0, 64*sizeof(uint8_t)); |
522 memset(sbr->bs_add_harmonic[1], 0, 64*sizeof(uint8_t)); | 454 memset(sbr->bs_add_harmonic[1], 0, 64*sizeof(uint8_t)); |
523 | 455 |
524 #ifdef DRM | |
525 if (sbr->Is_DRM_SBR) | |
526 sbr->bs_add_harmonic_flag[0] = 0; | |
527 else | |
528 #endif | |
529 { | |
530 sbr->bs_add_harmonic_flag[0] = faad_get1bit(ld | 456 sbr->bs_add_harmonic_flag[0] = faad_get1bit(ld |
531 DEBUGVAR(1,239,"sbr_channel_pair_element(): bs_add_harmonic_flag[0]")); | 457 DEBUGVAR(1,239,"sbr_channel_pair_element(): bs_add_harmonic_flag[0]")); |
532 } | |
533 if (sbr->bs_add_harmonic_flag[0]) | 458 if (sbr->bs_add_harmonic_flag[0]) |
534 sinusoidal_coding(ld, sbr, 0); | 459 sinusoidal_coding(ld, sbr, 0); |
535 | 460 |
536 #ifdef DRM | |
537 if (sbr->Is_DRM_SBR) | |
538 sbr->bs_add_harmonic_flag[1] = 0; | |
539 else | |
540 #endif | |
541 { | |
542 sbr->bs_add_harmonic_flag[1] = faad_get1bit(ld | 461 sbr->bs_add_harmonic_flag[1] = faad_get1bit(ld |
543 DEBUGVAR(1,240,"sbr_channel_pair_element(): bs_add_harmonic_flag[1]")); | 462 DEBUGVAR(1,240,"sbr_channel_pair_element(): bs_add_harmonic_flag[1]")); |
544 } | |
545 if (sbr->bs_add_harmonic_flag[1]) | 463 if (sbr->bs_add_harmonic_flag[1]) |
546 sinusoidal_coding(ld, sbr, 1); | 464 sinusoidal_coding(ld, sbr, 1); |
547 } | 465 } |
548 envelope_noise_dequantisation(sbr, 0); | 466 envelope_noise_dequantisation(sbr, 0); |
549 envelope_noise_dequantisation(sbr, 1); | 467 envelope_noise_dequantisation(sbr, 1); |
554 sbr->bs_extended_data = faad_get1bit(ld | 472 sbr->bs_extended_data = faad_get1bit(ld |
555 DEBUGVAR(1,233,"sbr_channel_pair_element(): bs_extended_data[0]")); | 473 DEBUGVAR(1,233,"sbr_channel_pair_element(): bs_extended_data[0]")); |
556 if (sbr->bs_extended_data) | 474 if (sbr->bs_extended_data) |
557 { | 475 { |
558 uint16_t nr_bits_left; | 476 uint16_t nr_bits_left; |
559 uint16_t cnt = faad_getbits(ld, 4 | 477 uint16_t cnt = (uint16_t)faad_getbits(ld, 4 |
560 DEBUGVAR(1,234,"sbr_channel_pair_element(): bs_extension_size")); | 478 DEBUGVAR(1,234,"sbr_channel_pair_element(): bs_extension_size")); |
561 if (cnt == 15) | 479 if (cnt == 15) |
562 { | 480 { |
563 cnt += faad_getbits(ld, 8 | 481 cnt += (uint16_t)faad_getbits(ld, 8 |
564 DEBUGVAR(1,235,"sbr_channel_pair_element(): bs_esc_count")); | 482 DEBUGVAR(1,235,"sbr_channel_pair_element(): bs_esc_count")); |
565 } | 483 } |
566 | 484 |
567 nr_bits_left = 8 * cnt; | 485 nr_bits_left = 8 * cnt; |
568 while (nr_bits_left > 7) | 486 while (nr_bits_left > 7) |
569 { | 487 { |
570 sbr->bs_extension_id = faad_getbits(ld, 2 | 488 sbr->bs_extension_id = (uint8_t)faad_getbits(ld, 2 |
571 DEBUGVAR(1,236,"sbr_channel_pair_element(): bs_extension_id")); | 489 DEBUGVAR(1,236,"sbr_channel_pair_element(): bs_extension_id")); |
572 nr_bits_left -= 2; | 490 nr_bits_left -= 2; |
573 /* sbr_extension(ld, sbr, 0, nr_bits_left); */ | 491 sbr_extension(ld, sbr, sbr->bs_extension_id, nr_bits_left); |
574 #ifdef DRM | 492 } |
575 if (!sbr->Is_DRM_SBR) | 493 |
576 #endif | 494 /* Corrigendum */ |
577 { | 495 if (nr_bits_left > 0) |
578 sbr->bs_extension_data = faad_getbits(ld, 6 | 496 { |
579 DEBUGVAR(1,280,"sbr_single_channel_element(): bs_extension_data")); | 497 faad_getbits(ld, nr_bits_left |
580 } | 498 DEBUGVAR(1,280,"sbr_channel_pair_element(): nr_bits_left")); |
581 } | 499 } |
582 } | 500 } |
583 | 501 |
584 return 0; | 502 return 0; |
585 } | 503 } |
504 | |
505 /* integer log[2](x): input range [0,10) */ | |
506 static int8_t sbr_log2(const int8_t val) | |
507 { | |
508 int8_t log2tab[] = { 0, 0, 1, 2, 2, 3, 3, 3, 3, 4 }; | |
509 if (val < 10 && val >= 0) | |
510 return log2tab[val]; | |
511 else | |
512 return 0; | |
513 } | |
514 | |
586 | 515 |
587 /* table 7 */ | 516 /* table 7 */ |
588 static uint8_t sbr_grid(bitfile *ld, sbr_info *sbr, uint8_t ch) | 517 static uint8_t sbr_grid(bitfile *ld, sbr_info *sbr, uint8_t ch) |
589 { | 518 { |
590 uint8_t i, env, rel, result; | 519 uint8_t i, env, rel, result; |
591 uint8_t bs_abs_bord, bs_abs_bord_1; | 520 uint8_t bs_abs_bord, bs_abs_bord_1; |
592 uint16_t bs_num_env; | 521 uint8_t bs_num_env = 0; |
593 | 522 |
594 sbr->bs_frame_class[ch] = faad_getbits(ld, 2 | 523 sbr->bs_frame_class[ch] = (uint8_t)faad_getbits(ld, 2 |
595 DEBUGVAR(1,248,"sbr_grid(): bs_frame_class")); | 524 DEBUGVAR(1,248,"sbr_grid(): bs_frame_class")); |
596 | 525 |
597 switch (sbr->bs_frame_class[ch]) | 526 switch (sbr->bs_frame_class[ch]) |
598 { | 527 { |
599 case FIXFIX: | 528 case FIXFIX: |
600 i = faad_getbits(ld, 2 | 529 i = (uint8_t)faad_getbits(ld, 2 |
601 DEBUGVAR(1,249,"sbr_grid(): bs_num_env_raw")); | 530 DEBUGVAR(1,249,"sbr_grid(): bs_num_env_raw")); |
602 | 531 |
603 bs_num_env = min(1 << i, 5); | 532 bs_num_env = min(1 << i, 5); |
604 | 533 |
605 i = faad_get1bit(ld | 534 i = (uint8_t)faad_get1bit(ld |
606 DEBUGVAR(1,250,"sbr_grid(): bs_freq_res_flag")); | 535 DEBUGVAR(1,250,"sbr_grid(): bs_freq_res_flag")); |
607 for (env = 0; env < bs_num_env; env++) | 536 for (env = 0; env < bs_num_env; env++) |
608 sbr->f[ch][env] = i; | 537 sbr->f[ch][env] = i; |
609 | 538 |
610 sbr->abs_bord_lead[ch] = 0; | 539 sbr->abs_bord_lead[ch] = 0; |
612 sbr->n_rel_lead[ch] = bs_num_env - 1; | 541 sbr->n_rel_lead[ch] = bs_num_env - 1; |
613 sbr->n_rel_trail[ch] = 0; | 542 sbr->n_rel_trail[ch] = 0; |
614 break; | 543 break; |
615 | 544 |
616 case FIXVAR: | 545 case FIXVAR: |
617 #ifdef DRM | 546 bs_abs_bord = (uint8_t)faad_getbits(ld, 2 |
618 if (sbr->Is_DRM_SBR) | 547 DEBUGVAR(1,251,"sbr_grid(): bs_abs_bord")) + sbr->numTimeSlots; |
619 { | 548 bs_num_env = (uint8_t)faad_getbits(ld, 2 |
620 bs_abs_bord = faad_getbits(ld, 3 | |
621 DEBUGVAR(1,251,"sbr_grid(): bs_abs_bord")) + sbr->numTimeSlots; | |
622 } else | |
623 #endif | |
624 { | |
625 bs_abs_bord = faad_getbits(ld, 2 | |
626 DEBUGVAR(1,251,"sbr_grid(): bs_abs_bord")) + sbr->numTimeSlots; | |
627 } | |
628 bs_num_env = faad_getbits(ld, 2 | |
629 DEBUGVAR(1,252,"sbr_grid(): bs_num_env")) + 1; | 549 DEBUGVAR(1,252,"sbr_grid(): bs_num_env")) + 1; |
630 | 550 |
631 for (rel = 0; rel < bs_num_env-1; rel++) | 551 for (rel = 0; rel < bs_num_env-1; rel++) |
632 { | 552 { |
633 sbr->bs_rel_bord[ch][rel] = 2 * faad_getbits(ld, 2 | 553 sbr->bs_rel_bord[ch][rel] = 2 * (uint8_t)faad_getbits(ld, 2 |
634 DEBUGVAR(1,253,"sbr_grid(): bs_rel_bord")) + 2; | 554 DEBUGVAR(1,253,"sbr_grid(): bs_rel_bord")) + 2; |
635 } | 555 } |
636 i = int_log2((int32_t)(bs_num_env + 1)); | 556 i = sbr_log2(bs_num_env + 1); |
637 sbr->bs_pointer[ch] = faad_getbits(ld, i | 557 sbr->bs_pointer[ch] = (uint8_t)faad_getbits(ld, i |
638 DEBUGVAR(1,254,"sbr_grid(): bs_pointer")); | 558 DEBUGVAR(1,254,"sbr_grid(): bs_pointer")); |
639 | 559 |
640 for (env = 0; env < bs_num_env; env++) | 560 for (env = 0; env < bs_num_env; env++) |
641 { | 561 { |
642 sbr->f[ch][bs_num_env - env - 1] = faad_get1bit(ld | 562 sbr->f[ch][bs_num_env - env - 1] = (uint8_t)faad_get1bit(ld |
643 DEBUGVAR(1,255,"sbr_grid(): bs_freq_res")); | 563 DEBUGVAR(1,255,"sbr_grid(): bs_freq_res")); |
644 } | 564 } |
645 | 565 |
646 sbr->abs_bord_lead[ch] = 0; | 566 sbr->abs_bord_lead[ch] = 0; |
647 sbr->abs_bord_trail[ch] = bs_abs_bord; | 567 sbr->abs_bord_trail[ch] = bs_abs_bord; |
648 sbr->n_rel_lead[ch] = 0; | 568 sbr->n_rel_lead[ch] = 0; |
649 sbr->n_rel_trail[ch] = bs_num_env - 1; | 569 sbr->n_rel_trail[ch] = bs_num_env - 1; |
650 break; | 570 break; |
651 | 571 |
652 case VARFIX: | 572 case VARFIX: |
653 #ifdef DRM | 573 bs_abs_bord = (uint8_t)faad_getbits(ld, 2 |
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 { | |
661 bs_abs_bord = faad_getbits(ld, 2 | |
662 DEBUGVAR(1,256,"sbr_grid(): bs_abs_bord")); | 574 DEBUGVAR(1,256,"sbr_grid(): bs_abs_bord")); |
663 } | 575 bs_num_env = (uint8_t)faad_getbits(ld, 2 |
664 bs_num_env = faad_getbits(ld, 2 | |
665 DEBUGVAR(1,257,"sbr_grid(): bs_num_env")) + 1; | 576 DEBUGVAR(1,257,"sbr_grid(): bs_num_env")) + 1; |
666 | 577 |
667 for (rel = 0; rel < bs_num_env-1; rel++) | 578 for (rel = 0; rel < bs_num_env-1; rel++) |
668 { | 579 { |
669 sbr->bs_rel_bord[ch][rel] = 2 * faad_getbits(ld, 2 | 580 sbr->bs_rel_bord[ch][rel] = 2 * (uint8_t)faad_getbits(ld, 2 |
670 DEBUGVAR(1,258,"sbr_grid(): bs_rel_bord")) + 2; | 581 DEBUGVAR(1,258,"sbr_grid(): bs_rel_bord")) + 2; |
671 } | 582 } |
672 i = int_log2((int32_t)(bs_num_env + 1)); | 583 i = sbr_log2(bs_num_env + 1); |
673 sbr->bs_pointer[ch] = faad_getbits(ld, i | 584 sbr->bs_pointer[ch] = (uint8_t)faad_getbits(ld, i |
674 DEBUGVAR(1,259,"sbr_grid(): bs_pointer")); | 585 DEBUGVAR(1,259,"sbr_grid(): bs_pointer")); |
675 | 586 |
676 for (env = 0; env < bs_num_env; env++) | 587 for (env = 0; env < bs_num_env; env++) |
677 { | 588 { |
678 sbr->f[ch][env] = faad_get1bit(ld | 589 sbr->f[ch][env] = (uint8_t)faad_get1bit(ld |
679 DEBUGVAR(1,260,"sbr_grid(): bs_freq_res")); | 590 DEBUGVAR(1,260,"sbr_grid(): bs_freq_res")); |
680 } | 591 } |
681 | 592 |
682 sbr->abs_bord_lead[ch] = bs_abs_bord; | 593 sbr->abs_bord_lead[ch] = bs_abs_bord; |
683 sbr->abs_bord_trail[ch] = sbr->numTimeSlots; | 594 sbr->abs_bord_trail[ch] = sbr->numTimeSlots; |
684 sbr->n_rel_lead[ch] = bs_num_env - 1; | 595 sbr->n_rel_lead[ch] = bs_num_env - 1; |
685 sbr->n_rel_trail[ch] = 0; | 596 sbr->n_rel_trail[ch] = 0; |
686 break; | 597 break; |
687 | 598 |
688 case VARVAR: | 599 case VARVAR: |
689 #ifdef DRM | 600 bs_abs_bord = (uint8_t)faad_getbits(ld, 2 |
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 { | |
700 bs_abs_bord = faad_getbits(ld, 2 | |
701 DEBUGVAR(1,261,"sbr_grid(): bs_abs_bord_0")); | 601 DEBUGVAR(1,261,"sbr_grid(): bs_abs_bord_0")); |
702 bs_abs_bord_1 = faad_getbits(ld, 2 | 602 bs_abs_bord_1 = (uint8_t)faad_getbits(ld, 2 |
703 DEBUGVAR(1,262,"sbr_grid(): bs_abs_bord_1")) + sbr->numTimeSlots; | 603 DEBUGVAR(1,262,"sbr_grid(): bs_abs_bord_1")) + sbr->numTimeSlots; |
704 } | 604 sbr->bs_num_rel_0[ch] = (uint8_t)faad_getbits(ld, 2 |
705 sbr->bs_num_rel_0[ch] = faad_getbits(ld, 2 | |
706 DEBUGVAR(1,263,"sbr_grid(): bs_num_rel_0")); | 605 DEBUGVAR(1,263,"sbr_grid(): bs_num_rel_0")); |
707 sbr->bs_num_rel_1[ch] = faad_getbits(ld, 2 | 606 sbr->bs_num_rel_1[ch] = (uint8_t)faad_getbits(ld, 2 |
708 DEBUGVAR(1,264,"sbr_grid(): bs_num_rel_1")); | 607 DEBUGVAR(1,264,"sbr_grid(): bs_num_rel_1")); |
709 | 608 |
710 bs_num_env = min(5, sbr->bs_num_rel_0[ch] + sbr->bs_num_rel_1[ch] + 1); | 609 bs_num_env = min(5, sbr->bs_num_rel_0[ch] + sbr->bs_num_rel_1[ch] + 1); |
711 | 610 |
712 for (rel = 0; rel < sbr->bs_num_rel_0[ch]; rel++) | 611 for (rel = 0; rel < sbr->bs_num_rel_0[ch]; rel++) |
713 { | 612 { |
714 sbr->bs_rel_bord_0[ch][rel] = 2 * faad_getbits(ld, 2 | 613 sbr->bs_rel_bord_0[ch][rel] = 2 * (uint8_t)faad_getbits(ld, 2 |
715 DEBUGVAR(1,265,"sbr_grid(): bs_rel_bord")) + 2; | 614 DEBUGVAR(1,265,"sbr_grid(): bs_rel_bord")) + 2; |
716 } | 615 } |
717 for(rel = 0; rel < sbr->bs_num_rel_1[ch]; rel++) | 616 for(rel = 0; rel < sbr->bs_num_rel_1[ch]; rel++) |
718 { | 617 { |
719 sbr->bs_rel_bord_1[ch][rel] = 2 * faad_getbits(ld, 2 | 618 sbr->bs_rel_bord_1[ch][rel] = 2 * (uint8_t)faad_getbits(ld, 2 |
720 DEBUGVAR(1,266,"sbr_grid(): bs_rel_bord")) + 2; | 619 DEBUGVAR(1,266,"sbr_grid(): bs_rel_bord")) + 2; |
721 } | 620 } |
722 i = int_log2((int32_t)(sbr->bs_num_rel_0[ch] + sbr->bs_num_rel_1[ch] + 2)); | 621 i = sbr_log2(sbr->bs_num_rel_0[ch] + sbr->bs_num_rel_1[ch] + 2); |
723 sbr->bs_pointer[ch] = faad_getbits(ld, i | 622 sbr->bs_pointer[ch] = (uint8_t)faad_getbits(ld, i |
724 DEBUGVAR(1,267,"sbr_grid(): bs_pointer")); | 623 DEBUGVAR(1,267,"sbr_grid(): bs_pointer")); |
725 | 624 |
726 for (env = 0; env < bs_num_env; env++) | 625 for (env = 0; env < bs_num_env; env++) |
727 { | 626 { |
728 sbr->f[ch][env] = faad_get1bit(ld | 627 sbr->f[ch][env] = (uint8_t)faad_get1bit(ld |
729 DEBUGVAR(1,268,"sbr_grid(): bs_freq_res")); | 628 DEBUGVAR(1,268,"sbr_grid(): bs_freq_res")); |
730 } | 629 } |
731 | 630 |
732 sbr->abs_bord_lead[ch] = bs_abs_bord; | 631 sbr->abs_bord_lead[ch] = bs_abs_bord; |
733 sbr->abs_bord_trail[ch] = bs_abs_bord_1; | 632 sbr->abs_bord_trail[ch] = bs_abs_bord_1; |
739 if (sbr->bs_frame_class[ch] == VARVAR) | 638 if (sbr->bs_frame_class[ch] == VARVAR) |
740 sbr->L_E[ch] = min(bs_num_env, 5); | 639 sbr->L_E[ch] = min(bs_num_env, 5); |
741 else | 640 else |
742 sbr->L_E[ch] = min(bs_num_env, 4); | 641 sbr->L_E[ch] = min(bs_num_env, 4); |
743 | 642 |
643 if (sbr->L_E[ch] <= 0) | |
644 return 1; | |
645 | |
744 if (sbr->L_E[ch] > 1) | 646 if (sbr->L_E[ch] > 1) |
745 sbr->L_Q[ch] = 2; | 647 sbr->L_Q[ch] = 2; |
746 else | 648 else |
747 sbr->L_Q[ch] = 1; | 649 sbr->L_Q[ch] = 1; |
748 | 650 |
775 /* table 9 */ | 677 /* table 9 */ |
776 static void invf_mode(bitfile *ld, sbr_info *sbr, uint8_t ch) | 678 static void invf_mode(bitfile *ld, sbr_info *sbr, uint8_t ch) |
777 { | 679 { |
778 uint8_t n; | 680 uint8_t n; |
779 | 681 |
780 #ifdef DRM | 682 for (n = 0; n < sbr->N_Q; n++) |
781 if (sbr->Is_DRM_SBR) | 683 { |
782 { | 684 sbr->bs_invf_mode[ch][n] = (uint8_t)faad_getbits(ld, 2 |
783 /* Only one inv_mode in DRM */ | |
784 uint8_t invf_mode; | |
785 invf_mode = faad_getbits(ld, 2 | |
786 DEBUGVAR(1,271,"invf_mode(): bs_invf_mode")); | 685 DEBUGVAR(1,271,"invf_mode(): bs_invf_mode")); |
787 for (n = 0; n < sbr->N_Q; n++) | 686 } |
788 sbr->bs_invf_mode[ch][n] = invf_mode; | 687 } |
789 } else | 688 |
790 #endif | 689 static uint16_t sbr_extension(bitfile *ld, sbr_info *sbr, |
791 { | 690 uint8_t bs_extension_id, uint16_t num_bits_left) |
792 for (n = 0; n < sbr->N_Q; n++) | 691 { |
793 { | 692 switch (bs_extension_id) |
794 sbr->bs_invf_mode[ch][n] = faad_getbits(ld, 2 | 693 { |
795 DEBUGVAR(1,271,"invf_mode(): bs_invf_mode")); | 694 #ifdef PS_DEC |
796 } | 695 case EXTENSION_ID_PS: |
696 sbr->ps_used = 1; | |
697 return ps_data(&(sbr->ps), ld); | |
698 #endif | |
699 #ifdef DRM_PS | |
700 case DRM_PARAMETRIC_STEREO: | |
701 sbr->ps_used = 1; | |
702 return drm_ps_data(&(sbr->drm_ps), ld); | |
703 #endif | |
704 default: | |
705 sbr->bs_extension_data = (uint8_t)faad_getbits(ld, 6 | |
706 DEBUGVAR(1,279,"sbr_single_channel_element(): bs_extension_data")); | |
707 return 6; | |
797 } | 708 } |
798 } | 709 } |
799 | 710 |
800 /* table 12 */ | 711 /* table 12 */ |
801 static void sinusoidal_coding(bitfile *ld, sbr_info *sbr, uint8_t ch) | 712 static void sinusoidal_coding(bitfile *ld, sbr_info *sbr, uint8_t ch) |