1 /* |
|
2 * Copyright (c) 2010 Ixonos Plc. |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of the "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - Initial contribution |
|
11 * |
|
12 * Contributors: |
|
13 * Ixonos Plc |
|
14 * |
|
15 * Description: |
|
16 * |
|
17 */ |
|
18 |
|
19 |
|
20 /************************************************************************** |
|
21 layer3.cpp - MPEG-1, MPEG-2 LSF and MPEG-2.5 layer III bitstream parsing. |
|
22 |
|
23 Author(s): Juha Ojanpera |
|
24 Copyright (c) 1999-2004 by Nokia Research Center, Speech and Audio Systems. |
|
25 *************************************************************************/ |
|
26 |
|
27 /************************************************************************** |
|
28 External Objects Needed |
|
29 *************************************************************************/ |
|
30 |
|
31 /*-- Project Headers --*/ |
|
32 #include "mpaud.h" |
|
33 #include "mpheader.h" |
|
34 #include "mp3tables.h" |
|
35 |
|
36 |
|
37 |
|
38 //uint8 scalefac_buffer[54]; |
|
39 |
|
40 /************************************************************************** |
|
41 Title : III_get_side_info |
|
42 |
|
43 Purpose : Reads Layer III side information from the bitstream. |
|
44 |
|
45 Usage : y = III_get_side_info(mp, bs) |
|
46 |
|
47 Input : mp - MP3 decoder handle |
|
48 bs - input bitstream |
|
49 |
|
50 Output : y - TRUE on success, FALSE otherwise |
|
51 |
|
52 Author(s) : Juha Ojanpera |
|
53 *************************************************************************/ |
|
54 |
|
55 |
|
56 BOOL |
|
57 III_get_side_info(CMP_Stream *mp, TBitStream *bs) |
|
58 { |
|
59 uint16 i, j, k, flag; |
|
60 TGranule_Info *gr_info; |
|
61 |
|
62 /*-- Get the protected bits for the crc error checking. --*/ |
|
63 if(bs->dsp_buffer) |
|
64 { |
|
65 int16 sideLen = (GetSideInfoSlots(mp->header) >> 1) + 1; |
|
66 |
|
67 if(bs->bit_counter == 8) |
|
68 for(i = bs->buf_index, j = 0; j < sideLen; i++, j++) |
|
69 { |
|
70 DSP_BYTE wTmp = bs->dsp_buffer[MOD_OPCODE(i, bs->buf_mask)] << 8; |
|
71 wTmp |= (bs->dsp_buffer[MOD_OPCODE((i + 1), bs->buf_mask)] >> 8) & 255; |
|
72 mp->mp3_crc.crc_payload[j + 2] = wTmp; |
|
73 } |
|
74 else |
|
75 for(i = bs->buf_index, j = 0; j < sideLen; i++, j++) |
|
76 mp->mp3_crc.crc_payload[j + 2] = bs->dsp_buffer[MOD_OPCODE(i, bs->buf_mask)]; |
|
77 } |
|
78 |
|
79 if(version(mp->header) == MPEG_AUDIO_ID) /* MPEG-1 */ |
|
80 { |
|
81 mp->side_info->main_data_begin = BsGetBits(bs, 9); |
|
82 if(channels(mp->header) == 1) |
|
83 { |
|
84 mp->side_info->private_bits = BsGetBits(bs, 5); |
|
85 for(i = 0; i < 4; i++) |
|
86 mp->side_info->scfsi[0][i] = BsGetBits(bs, 1); |
|
87 } |
|
88 else |
|
89 { |
|
90 mp->side_info->private_bits = BsGetBits(bs, 3); |
|
91 for(i = 0; i < 2; i++) |
|
92 for(j = 0; j < 4; j++) |
|
93 mp->side_info->scfsi[i][j] = int16(BsGetBits(bs, 1)); |
|
94 } |
|
95 |
|
96 for(i = 0; i < 2; i++) |
|
97 { |
|
98 for(j = 0; j < channels(mp->header); j++) |
|
99 { |
|
100 gr_info = mp->side_info->ch_info[j]->gr_info[i]; |
|
101 |
|
102 gr_info->part2_3_length = BsGetBits(bs, 12); |
|
103 gr_info->big_values = BsGetBits(bs, 9) << 1; |
|
104 gr_info->global_gain = BsGetBits(bs, 8); |
|
105 gr_info->scalefac_compress = BsGetBits(bs, 4); |
|
106 |
|
107 gr_info->flags = 0; |
|
108 gr_info->flags |= (BsGetBits(bs, 1)) ? WINDOW_SWITCHING_FLAG : 0; |
|
109 |
|
110 if(win_switch(gr_info)) |
|
111 { |
|
112 /* block_type */ |
|
113 gr_info->flags |= BsGetBits(bs, 2); |
|
114 |
|
115 /* mixed_block_flag */ |
|
116 flag = BsGetBits(bs, 1); |
|
117 gr_info->flags |= (flag) ? MIXED_BLOCK_FLAG : 0; |
|
118 |
|
119 for(k = 0; k < 2; k++) |
|
120 gr_info->table_select[k] = BsGetBits(bs, 5); |
|
121 |
|
122 for(k = 0; k < 3; k++) |
|
123 gr_info->subblock_gain[k] = BsGetBits(bs, 3); |
|
124 |
|
125 /* Set region_count parameters since they are implicit in this case. */ |
|
126 if((gr_info->flags & 3) == 0) |
|
127 return (FALSE); /* This will trigger resync */ |
|
128 else |
|
129 if(short_block(gr_info) && !mixed_block(gr_info)) |
|
130 { |
|
131 gr_info->block_mode = SHORT_BLOCK_MODE; |
|
132 gr_info->region0_count = 7; |
|
133 } |
|
134 else |
|
135 { |
|
136 if(short_block(gr_info) && mixed_block(gr_info)) |
|
137 return (FALSE); /* mixed block are not allowed => resync */ |
|
138 else |
|
139 gr_info->block_mode = LONG_BLOCK_MODE; |
|
140 |
|
141 gr_info->region0_count = 7; |
|
142 } |
|
143 |
|
144 gr_info->region1_count = 20 - gr_info->region0_count; |
|
145 } |
|
146 else |
|
147 { |
|
148 gr_info->block_mode = LONG_BLOCK_MODE; |
|
149 for(k = 0; k < 3; k++) |
|
150 gr_info->table_select[k] = BsGetBits(bs, 5); |
|
151 gr_info->region0_count = BsGetBits(bs, 4); |
|
152 gr_info->region1_count = BsGetBits(bs, 3); |
|
153 |
|
154 gr_info->flags &= ~(uint32)3; /* block_type == 0 (LONG) */ |
|
155 } |
|
156 |
|
157 flag = BsGetBits(bs, 3); |
|
158 gr_info->flags |= (flag & 4) ? PRE_FLAG : 0; |
|
159 gr_info->flags |= (flag & 2) ? SCALEFAC_SCALE : 0; |
|
160 gr_info->flags |= (flag & 1) ? COUNT_1_TABLE_SELECT : 0; |
|
161 } |
|
162 } |
|
163 } |
|
164 else /* MPEG-2 LSF and MPEG-2.5 */ |
|
165 { |
|
166 mp->side_info->main_data_begin = BsGetBits(bs, 8); |
|
167 |
|
168 if(channels(mp->header) == 1) |
|
169 mp->side_info->private_bits = BsGetBits(bs, 1); |
|
170 else |
|
171 mp->side_info->private_bits = BsGetBits(bs, 2); |
|
172 |
|
173 for(i = 0; i < channels(mp->header); i++) |
|
174 { |
|
175 gr_info = mp->side_info->ch_info[i]->gr_info[0]; |
|
176 |
|
177 gr_info->part2_3_length = BsGetBits(bs, 12); |
|
178 gr_info->big_values = BsGetBits(bs, 9) << 1; |
|
179 gr_info->global_gain = BsGetBits(bs, 8); |
|
180 gr_info->scalefac_compress = BsGetBits(bs, 9); |
|
181 gr_info->flags = 0; |
|
182 gr_info->flags |= (BsGetBits(bs, 1)) ? WINDOW_SWITCHING_FLAG : 0; |
|
183 |
|
184 if(win_switch(gr_info)) |
|
185 { |
|
186 /* block_type */ |
|
187 gr_info->flags |= BsGetBits(bs, 2); |
|
188 |
|
189 /* mixed_block_flag */ |
|
190 flag = BsGetBits(bs, 1); |
|
191 gr_info->flags |= (flag) ? MIXED_BLOCK_FLAG : 0; |
|
192 |
|
193 for(k = 0; k < 2; k++) |
|
194 gr_info->table_select[k] = BsGetBits(bs, 5); |
|
195 |
|
196 for(k = 0; k < 3; k++) |
|
197 gr_info->subblock_gain[k] = BsGetBits(bs, 3); |
|
198 |
|
199 /* Set region_count parameters since they are implicit in this case. */ |
|
200 if((gr_info->flags & 3) == 0) |
|
201 return (FALSE); |
|
202 else |
|
203 if(short_block(gr_info) && !mixed_block(gr_info)) |
|
204 { |
|
205 gr_info->block_mode = SHORT_BLOCK_MODE; |
|
206 gr_info->region0_count = 5; |
|
207 } |
|
208 else |
|
209 { |
|
210 if(short_block(gr_info) && mixed_block(gr_info)) |
|
211 return (FALSE); |
|
212 else |
|
213 gr_info->block_mode = LONG_BLOCK_MODE; |
|
214 |
|
215 gr_info->region0_count = 7; |
|
216 } |
|
217 |
|
218 gr_info->region1_count = 20 - gr_info->region0_count; |
|
219 } |
|
220 else |
|
221 { |
|
222 gr_info->block_mode = LONG_BLOCK_MODE; |
|
223 for(k = 0; k < 3; k++) |
|
224 gr_info->table_select[k] = BsGetBits(bs, 5); |
|
225 gr_info->region0_count = BsGetBits(bs, 4); |
|
226 gr_info->region1_count = BsGetBits(bs, 3); |
|
227 |
|
228 gr_info->flags &= ~(uint32)3; /* block_type == 0 (LONG) */ |
|
229 } |
|
230 |
|
231 flag = BsGetBits(bs, 2); |
|
232 gr_info->flags |= (flag & 2) ? SCALEFAC_SCALE : 0; |
|
233 gr_info->flags |= (flag & 1) ? COUNT_1_TABLE_SELECT : 0; |
|
234 } |
|
235 } |
|
236 |
|
237 return (TRUE); |
|
238 } |
|
239 |
|
240 /* |
|
241 * Writes layer 3 side information (excluding granule specific info) |
|
242 * to the specified bitstream. For writing granule specific |
|
243 * parameters 'L3WriteGranule()' function should be used. |
|
244 */ |
|
245 INLINE void |
|
246 L3WriteCommonSideInfo(TBitStream *bs, CIII_Side_Info *sideInfo, TMPEG_Header *header) |
|
247 { |
|
248 int16 bits; |
|
249 uint32 dWord; |
|
250 |
|
251 bits = 9; |
|
252 dWord = sideInfo->main_data_begin; |
|
253 |
|
254 /*-- MPEG-1. --*/ |
|
255 if(version(header) == MPEG_AUDIO_ID) |
|
256 { |
|
257 if(channels(header) == 1) |
|
258 { |
|
259 bits = 18; |
|
260 dWord <<= 5; dWord |= sideInfo->private_bits; |
|
261 dWord <<= 1; dWord |= sideInfo->scfsi[0][0]; |
|
262 dWord <<= 1; dWord |= sideInfo->scfsi[0][1]; |
|
263 dWord <<= 1; dWord |= sideInfo->scfsi[0][2]; |
|
264 dWord <<= 1; dWord |= sideInfo->scfsi[0][3]; |
|
265 } |
|
266 else |
|
267 { |
|
268 bits = 20; |
|
269 dWord <<= 3; dWord |= sideInfo->private_bits; |
|
270 dWord <<= 1; dWord |= sideInfo->scfsi[0][0]; |
|
271 dWord <<= 1; dWord |= sideInfo->scfsi[0][1]; |
|
272 dWord <<= 1; dWord |= sideInfo->scfsi[0][2]; |
|
273 dWord <<= 1; dWord |= sideInfo->scfsi[0][3]; |
|
274 dWord <<= 1; dWord |= sideInfo->scfsi[1][0]; |
|
275 dWord <<= 1; dWord |= sideInfo->scfsi[1][1]; |
|
276 dWord <<= 1; dWord |= sideInfo->scfsi[1][2]; |
|
277 dWord <<= 1; dWord |= sideInfo->scfsi[1][3]; |
|
278 } |
|
279 } |
|
280 |
|
281 /*-- MPEG-2 LSF, MPEG-2.5. --*/ |
|
282 else |
|
283 { |
|
284 if(channels(header) == 1) |
|
285 { bits = 9; dWord <<= 1; } |
|
286 else |
|
287 { bits = 10; dWord <<= 2; } |
|
288 |
|
289 dWord |= sideInfo->private_bits; |
|
290 } |
|
291 |
|
292 BsPutBits(bs, bits, dWord); |
|
293 } |
|
294 |
|
295 /* |
|
296 * Writes granule specific parameters to the specified bitstream. |
|
297 * Please note that the MPEG frame may contain more than one granule |
|
298 * depending on the number of channels and version. So this function |
|
299 * may need to be called multiple times. |
|
300 */ |
|
301 INLINE void |
|
302 L3WriteGranule(TBitStream *bs, TGranule_Info *gr_info, BOOL mpeg1) |
|
303 { |
|
304 uint32 dWord; |
|
305 |
|
306 dWord = gr_info->part2_3_length << 9; |
|
307 dWord |= gr_info->big_values >> 1; |
|
308 dWord <<= 8; dWord |= gr_info->global_gain; |
|
309 |
|
310 BsPutBits(bs, 29, dWord); |
|
311 |
|
312 dWord = gr_info->scalefac_compress << 1; |
|
313 if(win_switch(gr_info)) |
|
314 { |
|
315 dWord |= 1; |
|
316 dWord <<= 2; dWord |= (gr_info->flags & 3); |
|
317 dWord <<= 1; if(mixed_block(gr_info)) dWord |= 1; |
|
318 dWord <<= 5; dWord |= gr_info->table_select[0]; |
|
319 dWord <<= 5; dWord |= gr_info->table_select[1]; |
|
320 dWord <<= 3; dWord |= gr_info->subblock_gain[0]; |
|
321 dWord <<= 3; dWord |= gr_info->subblock_gain[1]; |
|
322 dWord <<= 3; dWord |= gr_info->subblock_gain[2]; |
|
323 } |
|
324 else |
|
325 { |
|
326 dWord <<= 5; dWord |= gr_info->table_select[0]; |
|
327 dWord <<= 5; dWord |= gr_info->table_select[1]; |
|
328 dWord <<= 5; dWord |= gr_info->table_select[2]; |
|
329 dWord <<= 4; dWord |= gr_info->region0_count; |
|
330 dWord <<= 3; dWord |= gr_info->region1_count; |
|
331 } |
|
332 |
|
333 if(mpeg1) { dWord <<= 1; if(pre_flag(gr_info)) dWord |= 1; } |
|
334 else { BsPutBits(bs, 32, dWord); dWord = 0; } |
|
335 |
|
336 dWord <<= 1; if(scalefac_scale(gr_info)) dWord |= 1; |
|
337 dWord <<= 1; if(gr_info->flags & COUNT_1_TABLE_SELECT) dWord |= 1; |
|
338 |
|
339 BsPutBits(bs, (mpeg1) ? 30 : 2, dWord); |
|
340 } |
|
341 |
|
342 /* |
|
343 * Writes layer 3 side info to the specified bitstream. The side info |
|
344 * in this context includes the header and the actual side info |
|
345 * parameters. |
|
346 */ |
|
347 void |
|
348 L3WriteSideInfo(TBitStream *bs, CIII_Side_Info *sideInfo, TMPEG_Header *header) |
|
349 { |
|
350 BOOL mpeg1; |
|
351 int16 i, j, max_gr; |
|
352 |
|
353 mpeg1 = (version(header) == MPEG_AUDIO_ID) ? TRUE : FALSE; |
|
354 max_gr = (mpeg1) ? 2 : 1; |
|
355 |
|
356 /*-- Write common side info. --*/ |
|
357 L3WriteCommonSideInfo(bs, sideInfo, header); |
|
358 |
|
359 /*-- Write granule parameters. --*/ |
|
360 for(i = 0; i < max_gr; i++) |
|
361 for(j = 0; j < channels(header); j++) |
|
362 { |
|
363 TGranule_Info *gr_info = sideInfo->ch_info[j]->gr_info[i]; |
|
364 L3WriteGranule(bs, gr_info, mpeg1); |
|
365 } |
|
366 } |
|
367 |
|
368 /************************************************************************** |
|
369 Title : III_get_LSF_scale_data |
|
370 |
|
371 Purpose : Decodes scalafactors of MPEG-2 LSF and MPEG-2.5 bitstreams. |
|
372 |
|
373 Usage : III_get_LSF_scale_data(mp, gr, ch) |
|
374 |
|
375 Input : mp - MP3 stream parameters |
|
376 gr - granule number |
|
377 ch - channel number (left or right) |
|
378 |
|
379 Explanation : - |
|
380 |
|
381 Author(s) : Juha Ojanpera |
|
382 *************************************************************************/ |
|
383 |
|
384 static void |
|
385 III_get_LSF_scale_data(CMP_Stream *mp, int16 gr, int16 ch, uint8* scalefac_buffer) |
|
386 { |
|
387 int16 i, j, k, m = 0; |
|
388 int16 blocktypenumber = 0, blocknumber = 0; |
|
389 int16 scalefac_comp, int_scalefac_comp, new_slen[4] = {0, 0, 0, 0}; |
|
390 TGranule_Info *gr_info; |
|
391 |
|
392 gr_info = mp->side_info->ch_info[ch]->gr_info[gr]; |
|
393 scalefac_comp = gr_info->scalefac_compress; |
|
394 |
|
395 switch(gr_info->block_mode) |
|
396 { |
|
397 case SHORT_BLOCK_MODE: |
|
398 blocktypenumber = 1; |
|
399 break; |
|
400 |
|
401 case LONG_BLOCK_MODE: |
|
402 blocktypenumber = 0; |
|
403 break; |
|
404 |
|
405 default: |
|
406 break; |
|
407 } |
|
408 |
|
409 if(!((mode_extension(mp->header) == 1 || |
|
410 mode_extension(mp->header) == 3) && ch == 1)) |
|
411 { |
|
412 |
|
413 if(scalefac_comp < 400) |
|
414 { |
|
415 new_slen[0] = (scalefac_comp >> 4) / 5; |
|
416 new_slen[1] = (scalefac_comp >> 4) % 5; |
|
417 new_slen[2] = (scalefac_comp & 15) >> 2; |
|
418 new_slen[3] = (scalefac_comp & 3); |
|
419 |
|
420 blocknumber = 0; |
|
421 m = 4; |
|
422 } |
|
423 else if(scalefac_comp < 500) |
|
424 { |
|
425 scalefac_comp -= 400; |
|
426 |
|
427 new_slen[0] = (scalefac_comp >> 2) / 5; |
|
428 new_slen[1] = (scalefac_comp >> 2) % 5; |
|
429 new_slen[2] = scalefac_comp & 3; |
|
430 |
|
431 blocknumber = 1; |
|
432 m = 3; |
|
433 } |
|
434 else /*if(scalefac_comp < 512)*/ |
|
435 { |
|
436 scalefac_comp -= 500; |
|
437 |
|
438 new_slen[0] = scalefac_comp / 3; |
|
439 new_slen[1] = scalefac_comp % 3; |
|
440 |
|
441 gr_info->flags |= (uint32)PRE_FLAG; /* pre_flag = 1 */ |
|
442 |
|
443 blocknumber = 2; |
|
444 m = 2; |
|
445 } |
|
446 } |
|
447 |
|
448 if(((mode_extension(mp->header) == 1 || |
|
449 mode_extension(mp->header) == 3) && ch == 1)) |
|
450 { |
|
451 |
|
452 int_scalefac_comp = scalefac_comp >> 1; |
|
453 |
|
454 if(int_scalefac_comp < 180) |
|
455 { |
|
456 int16 tmp = int_scalefac_comp % 36; |
|
457 |
|
458 new_slen[0] = int_scalefac_comp / 36; |
|
459 new_slen[1] = tmp / 6; |
|
460 new_slen[2] = tmp % 6; |
|
461 |
|
462 blocknumber = 3; |
|
463 m = 3; |
|
464 } |
|
465 else if(int_scalefac_comp < 244) |
|
466 { |
|
467 int_scalefac_comp -= 180; |
|
468 |
|
469 new_slen[0] = (int_scalefac_comp & 63) >> 4; |
|
470 new_slen[1] = (int_scalefac_comp & 15) >> 2; |
|
471 new_slen[2] = int_scalefac_comp & 3; |
|
472 |
|
473 blocknumber = 4; |
|
474 m = 3; |
|
475 } |
|
476 else /*if(int_scalefac_comp < 255)*/ |
|
477 { |
|
478 int_scalefac_comp -= 244; |
|
479 |
|
480 new_slen[0] = int_scalefac_comp / 3; |
|
481 new_slen[1] = int_scalefac_comp % 3; |
|
482 |
|
483 blocknumber = 5; |
|
484 m = 2; |
|
485 } |
|
486 |
|
487 TIS_Info *is_info = &mp->side_info->is_info; |
|
488 is_info->is_len[0] = (1 << new_slen[0]) - 1; |
|
489 is_info->is_len[1] = (1 << new_slen[1]) - 1; |
|
490 is_info->is_len[2] = (1 << new_slen[2]) - 1; |
|
491 is_info->nr_sfb[0] = nr_of_sfb_block[blocknumber][blocktypenumber][0]; |
|
492 is_info->nr_sfb[1] = nr_of_sfb_block[blocknumber][blocktypenumber][1]; |
|
493 is_info->nr_sfb[2] = nr_of_sfb_block[blocknumber][blocktypenumber][2]; |
|
494 |
|
495 } |
|
496 |
|
497 |
|
498 Mem::Fill(scalefac_buffer, 54, 0); |
|
499 |
|
500 |
|
501 for(i = k = 0; i < m; i++) |
|
502 { |
|
503 |
|
504 if(new_slen[i] != 0) |
|
505 for(j = 0; j < nr_of_sfb_block[blocknumber][blocktypenumber][i]; j++, k++) |
|
506 { |
|
507 |
|
508 |
|
509 |
|
510 scalefac_buffer[k] = BsGetBits(mp->br, new_slen[i]); |
|
511 |
|
512 |
|
513 } |
|
514 else |
|
515 { |
|
516 |
|
517 |
|
518 if (i < 4) |
|
519 { |
|
520 k += nr_of_sfb_block[blocknumber][blocktypenumber][i]; |
|
521 } |
|
522 else |
|
523 { |
|
524 k += 0; |
|
525 } |
|
526 |
|
527 } |
|
528 |
|
529 } |
|
530 |
|
531 } |
|
532 |
|
533 /************************************************************************** |
|
534 Title : III_get_scale_factors |
|
535 |
|
536 Purpose : Reads the scale factors of layer III. |
|
537 |
|
538 Usage : III_get_scale_factors(mp, gr, ch) |
|
539 |
|
540 Input : mp - MP3 stream parameters |
|
541 gr - granule number |
|
542 ch - channel number (left or right) |
|
543 |
|
544 Author(s) : Juha Ojanpera |
|
545 *************************************************************************/ |
|
546 |
|
547 void III_get_scale_factors(CMP_Stream *mp, int16 gr, int16 ch) |
|
548 { |
|
549 uint8 *sf[3]; |
|
550 int16 i, sfb, bits, idx; |
|
551 TGranule_Info *gr_info; |
|
552 CIII_Scale_Factors *scale_fac; |
|
553 |
|
554 uint8* scalefac_buffer = NULL; |
|
555 TRAPD(error, scalefac_buffer = new (ELeave) uint8[54]); |
|
556 if (error != KErrNone) |
|
557 return; |
|
558 |
|
559 Mem::Fill(scalefac_buffer, 54, 0); |
|
560 |
|
561 gr_info = mp->side_info->ch_info[ch]->gr_info[gr]; |
|
562 |
|
563 scale_fac = mp->side_info->ch_info[ch]->scale_fac; |
|
564 |
|
565 idx = 0; |
|
566 if(mp->side_info->lsf) |
|
567 { |
|
568 III_get_LSF_scale_data(mp, gr, ch, scalefac_buffer); |
|
569 } |
|
570 |
|
571 |
|
572 switch(gr_info->block_mode) |
|
573 { |
|
574 case SHORT_BLOCK_MODE: |
|
575 sf[0] = scale_fac->scalefac_short[0]; |
|
576 sf[1] = scale_fac->scalefac_short[1]; |
|
577 sf[2] = scale_fac->scalefac_short[2]; |
|
578 if(mp->side_info->lsf) |
|
579 for(sfb = 0; sfb < 12; sfb++) |
|
580 { |
|
581 *sf[0]++ = scalefac_buffer[idx++]; |
|
582 *sf[1]++ = scalefac_buffer[idx++]; |
|
583 *sf[2]++ = scalefac_buffer[idx++]; |
|
584 } |
|
585 else |
|
586 for(i = 0; i < 2; i++) |
|
587 { |
|
588 bits = slen[i][gr_info->scalefac_compress]; |
|
589 if(bits) |
|
590 for(sfb = sfbtable.s[i]; sfb < sfbtable.s[i + 1]; sfb++) |
|
591 { |
|
592 *sf[0]++ = BsGetBits(mp->br, bits); |
|
593 *sf[1]++ = BsGetBits(mp->br, bits); |
|
594 *sf[2]++ = BsGetBits(mp->br, bits); |
|
595 } |
|
596 else |
|
597 for(sfb = sfbtable.s[i]; sfb < sfbtable.s[i + 1]; sfb++) |
|
598 { |
|
599 *sf[0]++ = 0; *sf[1]++ = 0; *sf[2]++ = 0; |
|
600 } |
|
601 } |
|
602 break; |
|
603 |
|
604 case LONG_BLOCK_MODE: |
|
605 sf[0] = scale_fac->scalefac_long; |
|
606 |
|
607 |
|
608 if(mp->side_info->lsf) |
|
609 for(i = 0; i < 21; i++) |
|
610 *sf[0]++ = scalefac_buffer[idx++]; |
|
611 else |
|
612 for(i = 0; i < 4; i++) |
|
613 { |
|
614 |
|
615 if(mp->side_info->scfsi[ch][i] == 0 || gr == 0) |
|
616 { |
|
617 bits = slen[i >> 1][gr_info->scalefac_compress]; |
|
618 if(bits) |
|
619 for(sfb = sfbtable.l[i]; sfb < sfbtable.l[i + 1]; sfb++) |
|
620 { |
|
621 |
|
622 *sf[0]++ = BsGetBits(mp->br, bits); |
|
623 |
|
624 } |
|
625 else |
|
626 for(sfb = sfbtable.l[i]; sfb < sfbtable.l[i + 1]; sfb++) |
|
627 *sf[0]++ = 0; |
|
628 } |
|
629 else |
|
630 sf[0] += sfbtable.l[i + 1] - sfbtable.l[i]; |
|
631 } |
|
632 break; |
|
633 |
|
634 default: |
|
635 break; |
|
636 } |
|
637 |
|
638 delete[] scalefac_buffer; |
|
639 |
|
640 } |
|
641 |
|
642 |
|
643 void |
|
644 init_III_reorder(int16 reorder_idx[2][MAX_MONO_SAMPLES], int16 *sfb_table, |
|
645 int16 *sfb_width_table) |
|
646 { |
|
647 int32 sfb, sfb_start, i; |
|
648 int32 window, freq, src_line, des_line; |
|
649 |
|
650 for(i = sfb = 0; sfb < MAX_SHORT_SFB_BANDS; sfb++) |
|
651 { |
|
652 sfb_start = sfb_table[sfb]; |
|
653 |
|
654 for(window = 0; window < 3; window++) |
|
655 for(freq = 0; freq < sfb_width_table[sfb]; freq++) |
|
656 { |
|
657 src_line = sfb_start * 3 + window * sfb_width_table[sfb] + freq; |
|
658 des_line = (sfb_start * 3) + window + (freq * 3); |
|
659 |
|
660 reorder_idx[0][i] = |
|
661 ((des_line / SSLIMIT) * SSLIMIT) + (des_line % SSLIMIT); |
|
662 |
|
663 reorder_idx[1][i++] = |
|
664 ((src_line / SSLIMIT) * SSLIMIT) + (src_line % SSLIMIT); |
|
665 } |
|
666 } |
|
667 } |
|
668 |
|
669 |
|
670 |
|
671 /************************************************************************** |
|
672 Title : III_reorder |
|
673 |
|
674 Purpose : Re-orders the input frame if short blocks are present. |
|
675 |
|
676 Usage : III_reorder(mp, gr, ch) |
|
677 |
|
678 Input : mp - MP3 stream parameters |
|
679 ch - channel number (left or right) |
|
680 gr - granule number |
|
681 |
|
682 Explanation : - |
|
683 |
|
684 Author(s) : Juha Ojanpera |
|
685 *************************************************************************/ |
|
686 |
|
687 void |
|
688 III_reorder(CMP_Stream *mp, int16 ch, int16 gr) |
|
689 { |
|
690 int16 i, sb_start; |
|
691 register int16 *id1, *id2; |
|
692 |
|
693 FLOAT* xr = NULL; |
|
694 TRAPD(error, xr = new (ELeave) FLOAT[MAX_MONO_SAMPLES]); |
|
695 if (error != KErrNone) |
|
696 return; |
|
697 |
|
698 register FLOAT *src, *dst; |
|
699 |
|
700 if(mp->side_info->ch_info[ch]->gr_info[gr]->block_mode == LONG_BLOCK_MODE) |
|
701 { |
|
702 delete[] xr; |
|
703 return; |
|
704 |
|
705 } |
|
706 |
|
707 sb_start = 0; |
|
708 |
|
709 id1 = &mp->reorder_idx[0][sb_start]; |
|
710 id2 = &mp->reorder_idx[1][sb_start]; |
|
711 |
|
712 /* |
|
713 * First re-order the short block to a temporary buffer |
|
714 * and then copy back to the input buffer. Not fully optimal, |
|
715 * a better way would be perhaps to do the re-ordering during the |
|
716 * dequantization but to my opinion that would complicate the code |
|
717 * too much. We also have to remember that short blocks do not occur |
|
718 * very frequently, so the penalty of having a separate re-ordering |
|
719 * routine is not so time consuming from the overall decoder complexity |
|
720 * point of view. |
|
721 */ |
|
722 src = &mp->buffer->ch_reconstructed[ch][0]; |
|
723 dst = &xr[0]; |
|
724 |
|
725 for(i = sb_start; i < MAX_MONO_SAMPLES; i++) |
|
726 dst[*id1++] = src[*id2++]; |
|
727 |
|
728 /* Copy back. */ |
|
729 for(i = sb_start; i < MAX_MONO_SAMPLES; i++) |
|
730 src[i] = dst[i]; |
|
731 |
|
732 delete[] xr; |
|
733 } |
|