1 /* ------------------------------------------------------------------
2 * Copyright (C) 1998-2009 PacketVideo
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
13 * express or implied.
14 * See the License for the specific language governing permissions
15 * and limitations under the License.
16 * -------------------------------------------------------------------
17 */
18 /*
19 ------------------------------------------------------------------------------
20
21 PacketVideo Corp.
22 MP3 Decoder Library
23
24 Filename: pvmp3_decode_huff_cw.cpp
25
26 Funtions:
27 pvmp3_decode_huff_cw_tab0
28 pvmp3_decode_huff_cw_tab1
29 pvmp3_decode_huff_cw_tab2
30 pvmp3_decode_huff_cw_tab3
31 pvmp3_decode_huff_cw_tab5
32 pvmp3_decode_huff_cw_tab6
33 pvmp3_decode_huff_cw_tab7
34 pvmp3_decode_huff_cw_tab8
35 pvmp3_decode_huff_cw_tab9
36 pvmp3_decode_huff_cw_tab10
37 pvmp3_decode_huff_cw_tab11
38 pvmp3_decode_huff_cw_tab12
39 pvmp3_decode_huff_cw_tab13
40 pvmp3_decode_huff_cw_tab15
41 pvmp3_decode_huff_cw_tab16
42 pvmp3_decode_huff_cw_tab24
43 pvmp3_decode_huff_cw_tab32
44 pvmp3_decode_huff_cw_tab33
45
46 Date: 09/21/2007
47
48 ------------------------------------------------------------------------------
49 REVISION HISTORY
50
51
52 Description:
53
54 ------------------------------------------------------------------------------
55 INPUT AND OUTPUT DEFINITIONS
56
57 Inputs:
58 BITS *pMainData = pointer to input mp3 Main data bit stream
59
60
61 Outputs:
62 cw = bit field extracted from a leaf entry of packed mp3 Huffman Tables
63
64
65 ------------------------------------------------------------------------------
66 FUNCTION DESCRIPTION
67
68 These functions are used to decode huffman codewords from the input
69 bitstream using combined binary search and look-up table approach.
70
71 ------------------------------------------------------------------------------
72 REQUIREMENTS
73
74
75 ------------------------------------------------------------------------------
76 REFERENCES
77 [1] ISO MPEG Audio Subgroup Software Simulation Group (1996)
78 ISO 13818-3 MPEG-2 Audio Decoder - Lower Sampling Frequency Extension
79
80 [2] Introduction to Algorithms,
81 Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest.
82 The MIT press, 1990
83
84 [3] "Selecting an Optimal Huffman Decoder for AAC",
85 Vladimir Z. Mesarovic, et al.
86 AES 111th Convention, September 21-24, 2001, New York, USA
87
88 ------------------------------------------------------------------------------
89 PSEUDO-CODE
90
91 ------------------------------------------------------------------------------
92 */
93
94
95 /*----------------------------------------------------------------------------
96 ; INCLUDES
97 ----------------------------------------------------------------------------*/
98 #include "pv_mp3dec_fxd_op.h"
99 #include "pvmp3_tables.h"
100 #include "pvmp3_getbits.h"
101 #include "pvmp3_decode_huff_cw.h"
102
103 /*----------------------------------------------------------------------------
104 ; MACROS
105 ; Define module specific macros here
106 ----------------------------------------------------------------------------*/
107
108
109 /*----------------------------------------------------------------------------
110 ; DEFINES
111 ; Include all pre-processor statements here. Include conditional
112 ; compile variables also.
113 ----------------------------------------------------------------------------*/
114
115
116 /*----------------------------------------------------------------------------
117 ; LOCAL FUNCTION DEFINITIONS
118 ; Function Prototype declaration
119 ----------------------------------------------------------------------------*/
120
121 /*----------------------------------------------------------------------------
122 ; LOCAL STORE/BUFFER/POINTER DEFINITIONS
123 ; Variable declaration - defined here and used outside this module
124 ----------------------------------------------------------------------------*/
125
126 /*----------------------------------------------------------------------------
127 ; EXTERNAL FUNCTION REFERENCES
128 ; Declare functions defined elsewhere and referenced in this module
129 ----------------------------------------------------------------------------*/
130
131 /*----------------------------------------------------------------------------
132 ; EXTERNAL GLOBAL STORE/BUFFER/POINTER REFERENCES
133 ; Declare variables used in this module but defined elsewhere
134 ----------------------------------------------------------------------------*/
135
136 /*----------------------------------------------------------------------------
137 ; FUNCTION CODE
138 ----------------------------------------------------------------------------*/
139
pvmp3_decode_huff_cw_tab0(tmp3Bits * pMainData)140 uint16 pvmp3_decode_huff_cw_tab0(tmp3Bits *pMainData)
141 {
142 OSCL_UNUSED_ARG(pMainData);
143 return(0);
144
145 }
146
147 /*----------------------------------------------------------------------------
148 ; FUNCTION CODE
149 ----------------------------------------------------------------------------*/
pvmp3_decode_huff_cw_tab1(tmp3Bits * pMainData)150 uint16 pvmp3_decode_huff_cw_tab1(tmp3Bits *pMainData)
151 {
152 uint32 tmp;
153 uint16 cw;
154
155 tmp = getUpTo9bits(pMainData, 3); /* hufftable1 */
156
157 cw = *(huffTable_1 + tmp);
158 pMainData->usedBits -= (3 - (cw & 0xFF));
159 return(cw >> 8);
160
161 }
162
163
164 /*----------------------------------------------------------------------------
165 ; FUNCTION CODE
166 ----------------------------------------------------------------------------*/
pvmp3_decode_huff_cw_tab2(tmp3Bits * pMainData)167 uint16 pvmp3_decode_huff_cw_tab2(tmp3Bits *pMainData)
168 {
169 uint32 tmp;
170 uint16 cw;
171
172 tmp = getUpTo9bits(pMainData, 6); /* huffTable_2,3 */
173
174 if (tmp >> 3)
175 {
176 tmp = (tmp >> 3) - 1;
177 }
178 else
179 {
180 tmp = tmp + 7;
181 }
182
183 cw = *(huffTable_2 + tmp);
184 pMainData->usedBits -= (6 - (cw & 0xFF));
185
186 return(cw >> 8);
187 }
188
189
190 /*----------------------------------------------------------------------------
191 ; FUNCTION CODE
192 ----------------------------------------------------------------------------*/
pvmp3_decode_huff_cw_tab3(tmp3Bits * pMainData)193 uint16 pvmp3_decode_huff_cw_tab3(tmp3Bits *pMainData)
194 {
195 uint32 tmp;
196 uint16 cw;
197
198 tmp = getUpTo9bits(pMainData, 6); /* huffTable_2,3 */
199
200 if (tmp >> 3)
201 {
202 tmp = (tmp >> 3) - 1;
203 }
204 else
205 {
206 tmp = tmp + 7;
207 }
208
209 cw = *(huffTable_3 + tmp);
210 pMainData->usedBits -= (6 - (cw & 0xFF));
211
212 return(cw >> 8);
213 }
214
215
216 /*----------------------------------------------------------------------------
217 ; FUNCTION CODE
218 ----------------------------------------------------------------------------*/
pvmp3_decode_huff_cw_tab5(tmp3Bits * pMainData)219 uint16 pvmp3_decode_huff_cw_tab5(tmp3Bits *pMainData)
220 {
221 uint32 tmp;
222 uint16 cw;
223
224 tmp = getUpTo9bits(pMainData, 8); /* huffTable_5 */
225
226 if ((tmp >> 5))
227 {
228 tmp = (tmp >> 5) - 1;
229 }
230 else if ((tmp >> 1) >= 2)
231 {
232 tmp = (tmp >> 1) - 2 + 7;
233 }
234 else
235 {
236 tmp = (tmp & 3) + 21;
237 }
238
239 cw = *(huffTable_5 + tmp);
240 pMainData->usedBits -= (8 - (cw & 0xFF));
241
242 return(cw >> 8);
243 }
244
245 /*----------------------------------------------------------------------------
246 ; FUNCTION CODE
247 ----------------------------------------------------------------------------*/
pvmp3_decode_huff_cw_tab6(tmp3Bits * pMainData)248 uint16 pvmp3_decode_huff_cw_tab6(tmp3Bits *pMainData)
249 {
250 uint32 tmp;
251 uint16 cw;
252
253 tmp = getUpTo9bits(pMainData, 7); /* huffTable_6 */
254 if ((tmp >> 3) >= 3)
255 {
256 tmp = (tmp >> 3) - 3;
257 }
258 else if (tmp >> 1)
259 {
260 tmp = (tmp >> 1) - 1 + 13;
261 }
262 else
263 {
264 tmp = tmp + 24;
265 }
266
267 cw = *(huffTable_6 + tmp);
268 pMainData->usedBits -= (7 - (cw & 0xFF));
269
270 return(cw >> 8);
271 }
272
273
274 /*----------------------------------------------------------------------------
275 ; FUNCTION CODE
276 ----------------------------------------------------------------------------*/
pvmp3_decode_huff_cw_tab7(tmp3Bits * pMainData)277 uint16 pvmp3_decode_huff_cw_tab7(tmp3Bits *pMainData)
278 {
279 uint32 tmp;
280 uint16 cw;
281
282 tmp = getUpTo17bits(pMainData, 10); /* huffTable_7 */
283 if ((tmp >> 7) >= 2)
284 {
285 tmp = (tmp >> 7) - 2;
286 }
287 else if ((tmp >> 4) >= 7)
288 {
289 tmp = (tmp >> 4) - 7 + 6;
290 }
291 else if ((tmp >> 1) >= 2)
292 {
293 tmp = (tmp >> 1) - 2 + 15;
294 }
295 else
296 {
297 tmp = (tmp & 3) + 69;
298 }
299
300 cw = *(huffTable_7 + tmp);
301 pMainData->usedBits -= (10 - (cw & 0xFF));
302
303 return(cw >> 8);
304 }
305
306
307 /*----------------------------------------------------------------------------
308 ; FUNCTION CODE
309 ----------------------------------------------------------------------------*/
pvmp3_decode_huff_cw_tab8(tmp3Bits * pMainData)310 uint16 pvmp3_decode_huff_cw_tab8(tmp3Bits *pMainData)
311 {
312 uint32 tmp;
313 uint16 cw;
314
315 tmp = getUpTo17bits(pMainData, 11); /* huffTable_8 */
316 if ((tmp >> 7) >= 2)
317 {
318 tmp = (tmp >> 7) - 2;
319 }
320 else if ((tmp >> 5) >= 5)
321 {
322 tmp = (tmp >> 5) - 5 + 14;
323 }
324 else if ((tmp >> 2) >= 3)
325 {
326 tmp = (tmp >> 2) - 3 + 17;
327 }
328 else
329 {
330 tmp = (tmp) + 54;
331 }
332
333 cw = *(huffTable_8 + tmp);
334 pMainData->usedBits -= (11 - (cw & 0xFF));
335
336 return(cw >> 8);
337 }
338
339
340 /*----------------------------------------------------------------------------
341 ; FUNCTION CODE
342 ----------------------------------------------------------------------------*/
pvmp3_decode_huff_cw_tab9(tmp3Bits * pMainData)343 uint16 pvmp3_decode_huff_cw_tab9(tmp3Bits *pMainData)
344 {
345 uint32 tmp;
346 uint16 cw;
347
348 tmp = getUpTo9bits(pMainData, 9); /* huffTable_9 */
349 if ((tmp >> 5) >= 5)
350 {
351 tmp = (tmp >> 5) - 5;
352 }
353 else if ((tmp >> 3) >= 6)
354 {
355 tmp = (tmp >> 3) - 6 + 11;
356 }
357 else if ((tmp >> 1) >= 4)
358 {
359 tmp = (tmp >> 1) - 4 + 25;
360 }
361 else
362 {
363 tmp = tmp + 45;
364 }
365
366 cw = *(huffTable_9 + tmp);
367 pMainData->usedBits -= (9 - (cw & 0xFF));
368
369 return(cw >> 8);
370 }
371
372
373 /*----------------------------------------------------------------------------
374 ; FUNCTION CODE
375 ----------------------------------------------------------------------------*/
pvmp3_decode_huff_cw_tab10(tmp3Bits * pMainData)376 uint16 pvmp3_decode_huff_cw_tab10(tmp3Bits *pMainData)
377 {
378 uint32 tmp;
379 uint16 cw;
380
381 tmp = getUpTo17bits(pMainData, 11); /* huffTable_10 */
382 if (tmp >> 10)
383 {
384 tmp = (tmp >> 10) - 1;
385 }
386 else if ((tmp >> 7) >= 3)
387 {
388 tmp = (tmp >> 7) - 3 + 1;
389 }
390 else if ((tmp >> 5) >= 8)
391 {
392 tmp = (tmp >> 5) - 8 + 6;
393 }
394 else if ((tmp >> 3) >= 18)
395 {
396 tmp = (tmp >> 3) - 18 + 10;
397 }
398 else if ((tmp >> 2) >= 24)
399 {
400 tmp = (tmp >> 2) - 24 + 24;
401 }
402 else if ((tmp >> 1) >= 12)
403 {
404 tmp = (tmp >> 1) - 12 + 36;
405 }
406 else
407 {
408 tmp = (tmp) + 72;
409 }
410
411 cw = *(huffTable_10 + tmp);
412 pMainData->usedBits -= (11 - (cw & 0xFF));
413
414 return(cw >> 8);
415 }
416
417
418 /*----------------------------------------------------------------------------
419 ; FUNCTION CODE
420 ----------------------------------------------------------------------------*/
pvmp3_decode_huff_cw_tab11(tmp3Bits * pMainData)421 uint16 pvmp3_decode_huff_cw_tab11(tmp3Bits *pMainData)
422 {
423 uint32 tmp;
424 uint16 cw;
425
426 tmp = getUpTo17bits(pMainData, 11); /* huffTable_11 */
427 if ((tmp >> 8) >= 3)
428 {
429 tmp = (tmp >> 8) - 3;
430 }
431 else if ((tmp >> 6) >= 7)
432 {
433 tmp = (tmp >> 6) - 7 + 5;
434 }
435 else if ((tmp >> 3) >= 32)
436 {
437 tmp = (tmp >> 3) - 32 + 10;
438 }
439 else if ((tmp >> 2) >= 10)
440 {
441 tmp = (tmp >> 2) - 10 + 34;
442 }
443 else if ((tmp >> 1) >= 8)
444 {
445 tmp = (tmp >> 1) - 8 + 88;
446 }
447 else
448 {
449 tmp = (tmp & 0xFF) + 100;
450 }
451 cw = *(huffTable_11 + tmp);
452 pMainData->usedBits -= (11 - (cw & 0xFF));
453
454 return(cw >> 8);
455 }
456
457
458 /*----------------------------------------------------------------------------
459 ; FUNCTION CODE
460 ----------------------------------------------------------------------------*/
pvmp3_decode_huff_cw_tab12(tmp3Bits * pMainData)461 uint16 pvmp3_decode_huff_cw_tab12(tmp3Bits *pMainData)
462 {
463 uint32 tmp;
464 uint16 cw;
465
466 tmp = getUpTo17bits(pMainData, 10); /* huffTable_12 */
467 if ((tmp >> 7) >= 5)
468 {
469 tmp = (tmp >> 7) - 5;
470 }
471 else if ((tmp >> 5) >= 12)
472 {
473 tmp = (tmp >> 5) - 12 + 3;
474 }
475 else if ((tmp >> 4) >= 17)
476 {
477 tmp = (tmp >> 4) - 17 + 11;
478 }
479 else if ((tmp >> 2) >= 32)
480 {
481 tmp = (tmp >> 2) - 32 + 18;
482 }
483 else if ((tmp >> 1) >= 16)
484 {
485 tmp = (tmp >> 1) - 16 + 54;
486 }
487 else
488 {
489 tmp = (tmp & 0x1F) + 102;
490
491 }
492 cw = *(huffTable_12 + tmp);
493 pMainData->usedBits -= (10 - (cw & 0xFF));
494
495 return(cw >> 8);
496 }
497
498
499 /*----------------------------------------------------------------------------
500 ; FUNCTION CODE
501 ----------------------------------------------------------------------------*/
pvmp3_decode_huff_cw_tab13(tmp3Bits * pMainData)502 uint16 pvmp3_decode_huff_cw_tab13(tmp3Bits *pMainData)
503 {
504 uint32 tmp;
505 uint16 cw;
506
507 tmp = getNbits(pMainData, 19); /* huffTable_13 */
508 if (tmp >> 18)
509 {
510 tmp = 0;
511 }
512 else if ((tmp >> 15) >= 4)
513 {
514 tmp = (tmp >> 15) - 4 + 1;
515 }
516 else if ((tmp >> 11) >= 32)
517 {
518 tmp = (tmp >> 11) - 32 + 5;
519 }
520 else if ((tmp >> 9) >= 64)
521 {
522 tmp = (tmp >> 9) - 64 + 37;
523 }
524 else if ((tmp >> 8) >= 64)
525 {
526 tmp = (tmp >> 8) - 64 + 101;
527 }
528 else if ((tmp >> 7) >= 64)
529 {
530 tmp = (tmp >> 7) - 64 + 165;
531 }
532 else if ((tmp >> 6) >= 32)
533 {
534 tmp = (tmp >> 6) - 32 + 229;
535 }
536 else if ((tmp >> 5) >= 32)
537 {
538 tmp = (tmp >> 5) - 32 + 325;
539 }
540 else if ((tmp >> 4) >= 32)
541 {
542 tmp = (tmp >> 4) - 32 + 357;
543 }
544 else if ((tmp >> 3) >= 32)
545 {
546 tmp = (tmp >> 3) - 32 + 389;
547 }
548 else if ((tmp >> 2) >= 2)
549 {
550 tmp = (tmp >> 2) - 2 + 421;
551 }
552 else
553 {
554 tmp = (tmp & 0x7) + 483;
555 }
556
557 cw = *(huffTable_13 + tmp);
558 pMainData->usedBits -= (19 - (cw & 0xFF));
559
560 return(cw >> 8);
561 }
562
563
564 /*----------------------------------------------------------------------------
565 ; FUNCTION CODE
566 ----------------------------------------------------------------------------*/
pvmp3_decode_huff_cw_tab15(tmp3Bits * pMainData)567 uint16 pvmp3_decode_huff_cw_tab15(tmp3Bits *pMainData)
568 {
569 uint32 tmp;
570 uint16 cw;
571
572 tmp = getUpTo17bits(pMainData, 13); /* huffTable_15 */
573 if ((tmp >> 9) >= 10)
574 {
575 tmp = (tmp >> 9) - 10;
576 }
577 else if ((tmp >> 6) >= 39)
578 {
579 tmp = (tmp >> 6) - 39 + 6;
580 }
581 else if ((tmp >> 4) >= 62)
582 {
583 tmp = (tmp >> 4) - 62 + 47;
584 }
585 else if ((tmp >> 3) >= 60)
586 {
587 tmp = (tmp >> 3) - 60 + 141;
588 }
589 else if ((tmp >> 2) >= 64)
590 {
591 tmp = (tmp >> 2) - 64 + 205;
592 }
593 else if ((tmp >> 1) >= 32)
594 {
595 tmp = (tmp >> 1) - 32 + 261;
596 }
597 else
598 {
599 tmp = (tmp & 0x3f) + 357;
600 }
601
602 cw = *(huffTable_15 + tmp);
603 pMainData->usedBits -= (13 - (cw & 0xFF));
604
605 return(cw >> 8);
606 }
607
608
609 /*----------------------------------------------------------------------------
610 ; FUNCTION CODE
611 ----------------------------------------------------------------------------*/
pvmp3_decode_huff_cw_tab16(tmp3Bits * pMainData)612 uint16 pvmp3_decode_huff_cw_tab16(tmp3Bits *pMainData)
613 {
614 uint32 tmp;
615 uint16 cw;
616
617 tmp = getUpTo17bits(pMainData, 17); /* huffTable_16 */
618 if (tmp >> 16)
619 {
620 tmp = 0;
621 }
622 else if ((tmp >> 13) >= 4)
623 {
624 tmp = (tmp >> 13) - 4 + 1;
625 }
626 else if ((tmp >> 9) >= 38)
627 {
628 tmp = (tmp >> 9) - 38 + 5;
629 }
630 else if ((tmp >> 7) >= 94)
631 {
632 tmp = (tmp >> 7) - 94 + 31;
633 }
634 else if ((tmp >> 5) >= 214)
635 {
636 tmp = (tmp >> 5) - 214 + 89;
637 }
638 else if ((tmp >> 3) >= 704)
639 {
640 if ((tmp >> 4) >= 384)
641 {
642 tmp = (tmp >> 4) - 384 + 315;
643 }
644 else
645 {
646 tmp = (tmp >> 3) - 704 + 251;
647 }
648 }
649 else if ((tmp >> 8) >= 14)
650 {
651 tmp = (tmp >> 8) - 14 + 359;
652 }
653 else if ((tmp) >= 3456)
654 {
655 if ((tmp >> 2) >= 868)
656 {
657 tmp = (tmp >> 2) - 868 + 383;
658 }
659 else
660 {
661 tmp = (tmp) - 3456 + 367;
662 }
663 }
664 else
665 {
666 tmp = ((tmp >> 6) & 0x3f) + 411;
667 }
668
669 cw = *(huffTable_16 + tmp);
670 pMainData->usedBits -= (17 - (cw & 0xFF));
671
672 return(cw >> 8);
673 }
674
675
676
677 /*----------------------------------------------------------------------------
678 ; FUNCTION CODE
679 ----------------------------------------------------------------------------*/
pvmp3_decode_huff_cw_tab24(tmp3Bits * pMainData)680 uint16 pvmp3_decode_huff_cw_tab24(tmp3Bits *pMainData)
681 {
682 uint32 tmp;
683 uint16 cw;
684
685 tmp = getUpTo17bits(pMainData, 12); /* huffTable_24 */
686 if ((tmp >> 6) >= 41)
687 {
688 tmp = (tmp >> 6) - 41;
689 }
690 else if ((tmp >> 3) >= 218)
691 {
692 tmp = (tmp >> 3) - 218 + 23;
693 }
694 else if ((tmp >> 2) >= 336)
695 {
696 tmp = (tmp >> 2) - 336 + 133;
697 }
698 else if ((tmp >> 1) >= 520)
699 {
700 tmp = (tmp >> 1) - 520 + 233;
701 }
702 else if ((tmp) >= 1024)
703 {
704 tmp = (tmp) - 1024 + 385;
705 }
706 else if ((tmp >> 1) >= 352)
707 {
708 if ((tmp >> 8) == 3)
709 {
710 tmp = (tmp >> 8) - 3 + 433;
711 }
712 else
713 {
714 tmp = (tmp >> 1) - 352 + 401;
715 }
716 }
717 else
718 {
719 tmp = ((tmp >> 4) & 0x3f) + 434;
720 }
721
722 cw = *(huffTable_24 + tmp);
723 pMainData->usedBits -= (12 - (cw & 0xFF));
724
725 return(cw >> 8);
726 }
727
728
729 /*----------------------------------------------------------------------------
730 ; FUNCTION CODE
731 ----------------------------------------------------------------------------*/
pvmp3_decode_huff_cw_tab32(tmp3Bits * pMainData)732 uint16 pvmp3_decode_huff_cw_tab32(tmp3Bits *pMainData)
733 {
734 uint32 tmp = getUpTo9bits(pMainData, 6); /* huffTable_32 */
735 if ((tmp >> 5))
736 {
737 pMainData->usedBits -= 5;
738 return(0);
739 }
740 else
741 {
742 uint16 cw = *(huffTable_32 + (tmp & 0x1f));
743 pMainData->usedBits -= (6 - (cw & 0xFF));
744
745 return(cw >> 8);
746 }
747
748 }
749
750
pvmp3_decode_huff_cw_tab33(tmp3Bits * pMainData)751 uint16 pvmp3_decode_huff_cw_tab33(tmp3Bits *pMainData)
752 {
753
754 uint16 tmp = getUpTo9bits(pMainData, 4); /* huffTable_33 */
755
756 return((0x0f - tmp));
757 }
758
759