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 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 ----------------------------------------------------------------------------*/ 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 ----------------------------------------------------------------------------*/ 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 ----------------------------------------------------------------------------*/ 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 ----------------------------------------------------------------------------*/ 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 ----------------------------------------------------------------------------*/ 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 ----------------------------------------------------------------------------*/ 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 ----------------------------------------------------------------------------*/ 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 ----------------------------------------------------------------------------*/ 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 ----------------------------------------------------------------------------*/ 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 ----------------------------------------------------------------------------*/ 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 ----------------------------------------------------------------------------*/ 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 ----------------------------------------------------------------------------*/ 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 ----------------------------------------------------------------------------*/ 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 ----------------------------------------------------------------------------*/ 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 ----------------------------------------------------------------------------*/ 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 ----------------------------------------------------------------------------*/ 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 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
