1 /*++ 2 3 Copyright (c) 2004 - 2006, Intel Corporation. All rights reserved.<BR> 4 This program and the accompanying materials 5 are licensed and made available under the terms and conditions of the BSD License 6 which accompanies this distribution. The full text of the license may be found at 7 http://opensource.org/licenses/bsd-license.php 8 9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 11 12 Module Name: 13 14 Decompress.c 15 16 Abstract: 17 18 Decompressor. Algorithm Ported from OPSD code (Decomp.asm) 19 20 --*/ 21 22 #include "TianoCommon.h" 23 24 25 // 26 // Decompression algorithm begins here 27 // 28 #define BITBUFSIZ 32 29 #define MAXMATCH 256 30 #define THRESHOLD 3 31 #define CODE_BIT 16 32 #define UINT8_MAX 0xff 33 #define BAD_TABLE - 1 34 35 // 36 // C: Char&Len Set; P: Position Set; T: exTra Set 37 // 38 #define NC (0xff + MAXMATCH + 2 - THRESHOLD) 39 #define CBIT 9 40 #define MAXPBIT 5 41 #define TBIT 5 42 #define MAXNP ((1U << MAXPBIT) - 1) 43 #define NT (CODE_BIT + 3) 44 #if NT > MAXNP 45 #define NPT NT 46 #else 47 #define NPT MAXNP 48 #endif 49 50 typedef struct { 51 UINT8 *mSrcBase; // Starting address of compressed data 52 UINT8 *mDstBase; // Starting address of decompressed data 53 UINT32 mOutBuf; 54 UINT32 mInBuf; 55 56 UINT16 mBitCount; 57 UINT32 mBitBuf; 58 UINT32 mSubBitBuf; 59 UINT16 mBlockSize; 60 UINT32 mCompSize; 61 UINT32 mOrigSize; 62 63 UINT16 mBadTableFlag; 64 65 UINT16 mLeft[2 * NC - 1]; 66 UINT16 mRight[2 * NC - 1]; 67 UINT8 mCLen[NC]; 68 UINT8 mPTLen[NPT]; 69 UINT16 mCTable[4096]; 70 UINT16 mPTTable[256]; 71 72 // 73 // The length of the field 'Position Set Code Length Array Size' in Block Header. 74 // For EFI 1.1 de/compression algorithm, mPBit = 4 75 // For Tiano de/compression algorithm, mPBit = 5 76 // 77 UINT8 mPBit; 78 } SCRATCH_DATA; 79 80 STATIC 81 VOID 82 FillBuf ( 83 IN SCRATCH_DATA *Sd, 84 IN UINT16 NumOfBits 85 ) 86 /*++ 87 88 Routine Description: 89 90 Shift mBitBuf NumOfBits left. Read in NumOfBits of bits from source. 91 92 Arguments: 93 94 Sd - The global scratch data 95 NumOfBits - The number of bits to shift and read. 96 97 Returns: (VOID) 98 99 --*/ 100 { 101 Sd->mBitBuf = (UINT32) (Sd->mBitBuf << NumOfBits); 102 103 while (NumOfBits > Sd->mBitCount) { 104 105 Sd->mBitBuf |= (UINT32) (Sd->mSubBitBuf << (NumOfBits = (UINT16) (NumOfBits - Sd->mBitCount))); 106 107 if (Sd->mCompSize > 0) { 108 // 109 // Get 1 byte into SubBitBuf 110 // 111 Sd->mCompSize--; 112 Sd->mSubBitBuf = 0; 113 Sd->mSubBitBuf = Sd->mSrcBase[Sd->mInBuf++]; 114 Sd->mBitCount = 8; 115 116 } else { 117 // 118 // No more bits from the source, just pad zero bit. 119 // 120 Sd->mSubBitBuf = 0; 121 Sd->mBitCount = 8; 122 123 } 124 } 125 126 Sd->mBitCount = (UINT16) (Sd->mBitCount - NumOfBits); 127 Sd->mBitBuf |= Sd->mSubBitBuf >> Sd->mBitCount; 128 } 129 130 STATIC 131 UINT32 132 GetBits ( 133 IN SCRATCH_DATA *Sd, 134 IN UINT16 NumOfBits 135 ) 136 /*++ 137 138 Routine Description: 139 140 Get NumOfBits of bits out from mBitBuf. Fill mBitBuf with subsequent 141 NumOfBits of bits from source. Returns NumOfBits of bits that are 142 popped out. 143 144 Arguments: 145 146 Sd - The global scratch data. 147 NumOfBits - The number of bits to pop and read. 148 149 Returns: 150 151 The bits that are popped out. 152 153 --*/ 154 { 155 UINT32 OutBits; 156 157 OutBits = (UINT32) (Sd->mBitBuf >> (BITBUFSIZ - NumOfBits)); 158 159 FillBuf (Sd, NumOfBits); 160 161 return OutBits; 162 } 163 164 STATIC 165 UINT16 166 MakeTable ( 167 IN SCRATCH_DATA *Sd, 168 IN UINT16 NumOfChar, 169 IN UINT8 *BitLen, 170 IN UINT16 TableBits, 171 OUT UINT16 *Table 172 ) 173 /*++ 174 175 Routine Description: 176 177 Creates Huffman Code mapping table according to code length array. 178 179 Arguments: 180 181 Sd - The global scratch data 182 NumOfChar - Number of symbols in the symbol set 183 BitLen - Code length array 184 TableBits - The width of the mapping table 185 Table - The table 186 187 Returns: 188 189 0 - OK. 190 BAD_TABLE - The table is corrupted. 191 192 --*/ 193 { 194 UINT16 Count[17]; 195 UINT16 Weight[17]; 196 UINT16 Start[18]; 197 UINT16 *Pointer; 198 UINT16 Index3; 199 UINT16 Index; 200 UINT16 Len; 201 UINT16 Char; 202 UINT16 JuBits; 203 UINT16 Avail; 204 UINT16 NextCode; 205 UINT16 Mask; 206 207 for (Index = 1; Index <= 16; Index++) { 208 Count[Index] = 0; 209 } 210 211 for (Index = 0; Index < NumOfChar; Index++) { 212 Count[BitLen[Index]]++; 213 } 214 215 Start[1] = 0; 216 217 for (Index = 1; Index <= 16; Index++) { 218 Start[Index + 1] = (UINT16) (Start[Index] + (Count[Index] << (16 - Index))); 219 } 220 221 if (Start[17] != 0) { 222 /*(1U << 16)*/ 223 return (UINT16) BAD_TABLE; 224 } 225 226 JuBits = (UINT16) (16 - TableBits); 227 228 for (Index = 1; Index <= TableBits; Index++) { 229 Start[Index] >>= JuBits; 230 Weight[Index] = (UINT16) (1U << (TableBits - Index)); 231 } 232 233 while (Index <= 16) { 234 Weight[Index++] = (UINT16) (1U << (16 - Index)); 235 } 236 237 Index = (UINT16) (Start[TableBits + 1] >> JuBits); 238 239 if (Index != 0) { 240 Index3 = (UINT16) (1U << TableBits); 241 while (Index != Index3) { 242 Table[Index++] = 0; 243 } 244 } 245 246 Avail = NumOfChar; 247 Mask = (UINT16) (1U << (15 - TableBits)); 248 249 for (Char = 0; Char < NumOfChar; Char++) { 250 251 Len = BitLen[Char]; 252 if (Len == 0) { 253 continue; 254 } 255 256 NextCode = (UINT16) (Start[Len] + Weight[Len]); 257 258 if (Len <= TableBits) { 259 260 for (Index = Start[Len]; Index < NextCode; Index++) { 261 Table[Index] = Char; 262 } 263 264 } else { 265 266 Index3 = Start[Len]; 267 Pointer = &Table[Index3 >> JuBits]; 268 Index = (UINT16) (Len - TableBits); 269 270 while (Index != 0) { 271 if (*Pointer == 0) { 272 Sd->mRight[Avail] = Sd->mLeft[Avail] = 0; 273 *Pointer = Avail++; 274 } 275 276 if (Index3 & Mask) { 277 Pointer = &Sd->mRight[*Pointer]; 278 } else { 279 Pointer = &Sd->mLeft[*Pointer]; 280 } 281 282 Index3 <<= 1; 283 Index--; 284 } 285 286 *Pointer = Char; 287 288 } 289 290 Start[Len] = NextCode; 291 } 292 // 293 // Succeeds 294 // 295 return 0; 296 } 297 298 STATIC 299 UINT32 300 DecodeP ( 301 IN SCRATCH_DATA *Sd 302 ) 303 /*++ 304 305 Routine Description: 306 307 Decodes a position value. 308 309 Arguments: 310 311 Sd - the global scratch data 312 313 Returns: 314 315 The position value decoded. 316 317 --*/ 318 { 319 UINT16 Val; 320 UINT32 Mask; 321 UINT32 Pos; 322 323 Val = Sd->mPTTable[Sd->mBitBuf >> (BITBUFSIZ - 8)]; 324 325 if (Val >= MAXNP) { 326 Mask = 1U << (BITBUFSIZ - 1 - 8); 327 328 do { 329 330 if (Sd->mBitBuf & Mask) { 331 Val = Sd->mRight[Val]; 332 } else { 333 Val = Sd->mLeft[Val]; 334 } 335 336 Mask >>= 1; 337 } while (Val >= MAXNP); 338 } 339 // 340 // Advance what we have read 341 // 342 FillBuf (Sd, Sd->mPTLen[Val]); 343 344 Pos = Val; 345 if (Val > 1) { 346 Pos = (UINT32) ((1U << (Val - 1)) + GetBits (Sd, (UINT16) (Val - 1))); 347 } 348 349 return Pos; 350 } 351 352 STATIC 353 UINT16 354 ReadPTLen ( 355 IN SCRATCH_DATA *Sd, 356 IN UINT16 nn, 357 IN UINT16 nbit, 358 IN UINT16 Special 359 ) 360 /*++ 361 362 Routine Description: 363 364 Reads code lengths for the Extra Set or the Position Set 365 366 Arguments: 367 368 Sd - The global scratch data 369 nn - Number of symbols 370 nbit - Number of bits needed to represent nn 371 Special - The special symbol that needs to be taken care of 372 373 Returns: 374 375 0 - OK. 376 BAD_TABLE - Table is corrupted. 377 378 --*/ 379 { 380 UINT16 Number; 381 UINT16 CharC; 382 UINT16 Index; 383 UINT32 Mask; 384 385 Number = (UINT16) GetBits (Sd, nbit); 386 387 if (Number == 0) { 388 CharC = (UINT16) GetBits (Sd, nbit); 389 390 for (Index = 0; Index < 256; Index++) { 391 Sd->mPTTable[Index] = CharC; 392 } 393 394 for (Index = 0; Index < nn; Index++) { 395 Sd->mPTLen[Index] = 0; 396 } 397 398 return 0; 399 } 400 401 Index = 0; 402 403 while (Index < Number) { 404 405 CharC = (UINT16) (Sd->mBitBuf >> (BITBUFSIZ - 3)); 406 407 if (CharC == 7) { 408 Mask = 1U << (BITBUFSIZ - 1 - 3); 409 while (Mask & Sd->mBitBuf) { 410 Mask >>= 1; 411 CharC += 1; 412 } 413 } 414 415 FillBuf (Sd, (UINT16) ((CharC < 7) ? 3 : CharC - 3)); 416 417 Sd->mPTLen[Index++] = (UINT8) CharC; 418 419 if (Index == Special) { 420 CharC = (UINT16) GetBits (Sd, 2); 421 while ((INT16) (--CharC) >= 0) { 422 Sd->mPTLen[Index++] = 0; 423 } 424 } 425 } 426 427 while (Index < nn) { 428 Sd->mPTLen[Index++] = 0; 429 } 430 431 return MakeTable (Sd, nn, Sd->mPTLen, 8, Sd->mPTTable); 432 } 433 434 STATIC 435 VOID 436 ReadCLen ( 437 SCRATCH_DATA *Sd 438 ) 439 /*++ 440 441 Routine Description: 442 443 Reads code lengths for Char&Len Set. 444 445 Arguments: 446 447 Sd - the global scratch data 448 449 Returns: (VOID) 450 451 --*/ 452 { 453 UINT16 Number; 454 UINT16 CharC; 455 UINT16 Index; 456 UINT32 Mask; 457 458 Number = (UINT16) GetBits (Sd, CBIT); 459 460 if (Number == 0) { 461 CharC = (UINT16) GetBits (Sd, CBIT); 462 463 for (Index = 0; Index < NC; Index++) { 464 Sd->mCLen[Index] = 0; 465 } 466 467 for (Index = 0; Index < 4096; Index++) { 468 Sd->mCTable[Index] = CharC; 469 } 470 471 return ; 472 } 473 474 Index = 0; 475 while (Index < Number) { 476 477 CharC = Sd->mPTTable[Sd->mBitBuf >> (BITBUFSIZ - 8)]; 478 if (CharC >= NT) { 479 Mask = 1U << (BITBUFSIZ - 1 - 8); 480 481 do { 482 483 if (Mask & Sd->mBitBuf) { 484 CharC = Sd->mRight[CharC]; 485 } else { 486 CharC = Sd->mLeft[CharC]; 487 } 488 489 Mask >>= 1; 490 491 } while (CharC >= NT); 492 } 493 // 494 // Advance what we have read 495 // 496 FillBuf (Sd, Sd->mPTLen[CharC]); 497 498 if (CharC <= 2) { 499 500 if (CharC == 0) { 501 CharC = 1; 502 } else if (CharC == 1) { 503 CharC = (UINT16) (GetBits (Sd, 4) + 3); 504 } else if (CharC == 2) { 505 CharC = (UINT16) (GetBits (Sd, CBIT) + 20); 506 } 507 508 while ((INT16) (--CharC) >= 0) { 509 Sd->mCLen[Index++] = 0; 510 } 511 512 } else { 513 514 Sd->mCLen[Index++] = (UINT8) (CharC - 2); 515 516 } 517 } 518 519 while (Index < NC) { 520 Sd->mCLen[Index++] = 0; 521 } 522 523 MakeTable (Sd, NC, Sd->mCLen, 12, Sd->mCTable); 524 525 return ; 526 } 527 528 STATIC 529 UINT16 530 DecodeC ( 531 SCRATCH_DATA *Sd 532 ) 533 /*++ 534 535 Routine Description: 536 537 Decode a character/length value. 538 539 Arguments: 540 541 Sd - The global scratch data. 542 543 Returns: 544 545 The value decoded. 546 547 --*/ 548 { 549 UINT16 Index2; 550 UINT32 Mask; 551 552 if (Sd->mBlockSize == 0) { 553 // 554 // Starting a new block 555 // 556 Sd->mBlockSize = (UINT16) GetBits (Sd, 16); 557 Sd->mBadTableFlag = ReadPTLen (Sd, NT, TBIT, 3); 558 if (Sd->mBadTableFlag != 0) { 559 return 0; 560 } 561 562 ReadCLen (Sd); 563 564 Sd->mBadTableFlag = ReadPTLen (Sd, MAXNP, Sd->mPBit, (UINT16) (-1)); 565 if (Sd->mBadTableFlag != 0) { 566 return 0; 567 } 568 } 569 570 Sd->mBlockSize--; 571 Index2 = Sd->mCTable[Sd->mBitBuf >> (BITBUFSIZ - 12)]; 572 573 if (Index2 >= NC) { 574 Mask = 1U << (BITBUFSIZ - 1 - 12); 575 576 do { 577 if (Sd->mBitBuf & Mask) { 578 Index2 = Sd->mRight[Index2]; 579 } else { 580 Index2 = Sd->mLeft[Index2]; 581 } 582 583 Mask >>= 1; 584 } while (Index2 >= NC); 585 } 586 // 587 // Advance what we have read 588 // 589 FillBuf (Sd, Sd->mCLen[Index2]); 590 591 return Index2; 592 } 593 594 STATIC 595 VOID 596 Decode ( 597 SCRATCH_DATA *Sd 598 ) 599 /*++ 600 601 Routine Description: 602 603 Decode the source data and put the resulting data into the destination buffer. 604 605 Arguments: 606 607 Sd - The global scratch data 608 609 Returns: (VOID) 610 611 --*/ 612 { 613 UINT16 BytesRemain; 614 UINT32 DataIdx; 615 UINT16 CharC; 616 617 BytesRemain = (UINT16) (-1); 618 619 DataIdx = 0; 620 621 for (;;) { 622 CharC = DecodeC (Sd); 623 if (Sd->mBadTableFlag != 0) { 624 return ; 625 } 626 627 if (CharC < 256) { 628 // 629 // Process an Original character 630 // 631 if (Sd->mOutBuf >= Sd->mOrigSize) { 632 return ; 633 } else { 634 Sd->mDstBase[Sd->mOutBuf++] = (UINT8) CharC; 635 } 636 637 } else { 638 // 639 // Process a Pointer 640 // 641 CharC = (UINT16) (CharC - (UINT8_MAX + 1 - THRESHOLD)); 642 643 BytesRemain = CharC; 644 645 DataIdx = Sd->mOutBuf - DecodeP (Sd) - 1; 646 647 BytesRemain--; 648 while ((INT16) (BytesRemain) >= 0) { 649 Sd->mDstBase[Sd->mOutBuf++] = Sd->mDstBase[DataIdx++]; 650 if (Sd->mOutBuf >= Sd->mOrigSize) { 651 return ; 652 } 653 654 BytesRemain--; 655 } 656 } 657 } 658 659 return ; 660 } 661 662 EFI_STATUS 663 GetInfo ( 664 IN VOID *Source, 665 IN UINT32 SrcSize, 666 OUT UINT32 *DstSize, 667 OUT UINT32 *ScratchSize 668 ) 669 /*++ 670 671 Routine Description: 672 673 The internal implementation of *_DECOMPRESS_PROTOCOL.GetInfo(). 674 675 Arguments: 676 677 Source - The source buffer containing the compressed data. 678 SrcSize - The size of source buffer 679 DstSize - The size of destination buffer. 680 ScratchSize - The size of scratch buffer. 681 682 Returns: 683 684 EFI_SUCCESS - The size of destination buffer and the size of scratch buffer are successull retrieved. 685 EFI_INVALID_PARAMETER - The source data is corrupted 686 687 --*/ 688 { 689 UINT8 *Src; 690 691 *ScratchSize = sizeof (SCRATCH_DATA); 692 693 Src = Source; 694 if (SrcSize < 8) { 695 return EFI_INVALID_PARAMETER; 696 } 697 698 *DstSize = Src[4] + (Src[5] << 8) + (Src[6] << 16) + (Src[7] << 24); 699 return EFI_SUCCESS; 700 } 701 702 EFI_STATUS 703 Decompress ( 704 IN VOID *Source, 705 IN UINT32 SrcSize, 706 IN OUT VOID *Destination, 707 IN UINT32 DstSize, 708 IN OUT VOID *Scratch, 709 IN UINT32 ScratchSize, 710 IN UINT8 Version 711 ) 712 /*++ 713 714 Routine Description: 715 716 The internal implementation of *_DECOMPRESS_PROTOCOL.Decompress(). 717 718 Arguments: 719 720 Source - The source buffer containing the compressed data. 721 SrcSize - The size of source buffer 722 Destination - The destination buffer to store the decompressed data 723 DstSize - The size of destination buffer. 724 Scratch - The buffer used internally by the decompress routine. This buffer is needed to store intermediate data. 725 ScratchSize - The size of scratch buffer. 726 Version - The version of de/compression algorithm. 727 Version 1 for EFI 1.1 de/compression algorithm. 728 Version 2 for Tiano de/compression algorithm. 729 730 Returns: 731 732 EFI_SUCCESS - Decompression is successfull 733 EFI_INVALID_PARAMETER - The source data is corrupted 734 735 --*/ 736 { 737 UINT32 Index; 738 UINT32 CompSize; 739 UINT32 OrigSize; 740 EFI_STATUS Status; 741 SCRATCH_DATA *Sd; 742 UINT8 *Src; 743 UINT8 *Dst; 744 745 Status = EFI_SUCCESS; 746 Src = Source; 747 Dst = Destination; 748 749 if (ScratchSize < sizeof (SCRATCH_DATA)) { 750 return EFI_INVALID_PARAMETER; 751 } 752 753 Sd = (SCRATCH_DATA *) Scratch; 754 755 if (SrcSize < 8) { 756 return EFI_INVALID_PARAMETER; 757 } 758 759 CompSize = Src[0] + (Src[1] << 8) + (Src[2] << 16) + (Src[3] << 24); 760 OrigSize = Src[4] + (Src[5] << 8) + (Src[6] << 16) + (Src[7] << 24); 761 762 // 763 // If compressed file size is 0, return 764 // 765 if (OrigSize == 0) { 766 return Status; 767 } 768 769 if (SrcSize < CompSize + 8) { 770 return EFI_INVALID_PARAMETER; 771 } 772 773 if (DstSize != OrigSize) { 774 return EFI_INVALID_PARAMETER; 775 } 776 777 Src = Src + 8; 778 779 for (Index = 0; Index < sizeof (SCRATCH_DATA); Index++) { 780 ((UINT8 *) Sd)[Index] = 0; 781 } 782 // 783 // The length of the field 'Position Set Code Length Array Size' in Block Header. 784 // For EFI 1.1 de/compression algorithm(Version 1), mPBit = 4 785 // For Tiano de/compression algorithm(Version 2), mPBit = 5 786 // 787 switch (Version) { 788 case 1: 789 Sd->mPBit = 4; 790 break; 791 792 case 2: 793 Sd->mPBit = 5; 794 break; 795 796 default: 797 // 798 // Currently, only have 2 versions 799 // 800 return EFI_INVALID_PARAMETER; 801 } 802 803 Sd->mSrcBase = Src; 804 Sd->mDstBase = Dst; 805 Sd->mCompSize = CompSize; 806 Sd->mOrigSize = OrigSize; 807 808 // 809 // Fill the first BITBUFSIZ bits 810 // 811 FillBuf (Sd, BITBUFSIZ); 812 813 // 814 // Decompress it 815 // 816 Decode (Sd); 817 818 if (Sd->mBadTableFlag != 0) { 819 // 820 // Something wrong with the source 821 // 822 Status = EFI_INVALID_PARAMETER; 823 } 824 825 return Status; 826 } 827 828 EFI_STATUS 829 EFIAPI 830 EfiGetInfo ( 831 IN VOID *Source, 832 IN UINT32 SrcSize, 833 OUT UINT32 *DstSize, 834 OUT UINT32 *ScratchSize 835 ) 836 /*++ 837 838 Routine Description: 839 840 The implementation is same as that of EFI_DECOMPRESS_PROTOCOL.GetInfo(). 841 842 Arguments: 843 844 This - The protocol instance pointer 845 Source - The source buffer containing the compressed data. 846 SrcSize - The size of source buffer 847 DstSize - The size of destination buffer. 848 ScratchSize - The size of scratch buffer. 849 850 Returns: 851 852 EFI_SUCCESS - The size of destination buffer and the size of scratch buffer are successull retrieved. 853 EFI_INVALID_PARAMETER - The source data is corrupted 854 855 --*/ 856 { 857 return GetInfo ( 858 Source, 859 SrcSize, 860 DstSize, 861 ScratchSize 862 ); 863 } 864 865 EFI_STATUS 866 EFIAPI 867 EfiDecompress ( 868 IN VOID *Source, 869 IN UINT32 SrcSize, 870 IN OUT VOID *Destination, 871 IN UINT32 DstSize, 872 IN OUT VOID *Scratch, 873 IN UINT32 ScratchSize 874 ) 875 /*++ 876 877 Routine Description: 878 879 The implementation is same as that of EFI_DECOMPRESS_PROTOCOL.Decompress(). 880 881 Arguments: 882 883 This - The protocol instance pointer 884 Source - The source buffer containing the compressed data. 885 SrcSize - The size of source buffer 886 Destination - The destination buffer to store the decompressed data 887 DstSize - The size of destination buffer. 888 Scratch - The buffer used internally by the decompress routine. This buffer is needed to store intermediate data. 889 ScratchSize - The size of scratch buffer. 890 891 Returns: 892 893 EFI_SUCCESS - Decompression is successfull 894 EFI_INVALID_PARAMETER - The source data is corrupted 895 896 --*/ 897 { 898 // 899 // For EFI 1.1 de/compression algorithm, the version is 1. 900 // 901 return Decompress ( 902 Source, 903 SrcSize, 904 Destination, 905 DstSize, 906 Scratch, 907 ScratchSize, 908 1 909 ); 910 } 911 912 EFI_STATUS 913 EFIAPI 914 TianoGetInfo ( 915 IN VOID *Source, 916 IN UINT32 SrcSize, 917 OUT UINT32 *DstSize, 918 OUT UINT32 *ScratchSize 919 ) 920 /*++ 921 922 Routine Description: 923 924 The implementation is same as that of EFI_TIANO_DECOMPRESS_PROTOCOL.GetInfo(). 925 926 Arguments: 927 928 This - The protocol instance pointer 929 Source - The source buffer containing the compressed data. 930 SrcSize - The size of source buffer 931 DstSize - The size of destination buffer. 932 ScratchSize - The size of scratch buffer. 933 934 Returns: 935 936 EFI_SUCCESS - The size of destination buffer and the size of scratch buffer are successull retrieved. 937 EFI_INVALID_PARAMETER - The source data is corrupted 938 939 --*/ 940 { 941 return GetInfo ( 942 Source, 943 SrcSize, 944 DstSize, 945 ScratchSize 946 ); 947 } 948 949 EFI_STATUS 950 EFIAPI 951 TianoDecompress ( 952 IN VOID *Source, 953 IN UINT32 SrcSize, 954 IN OUT VOID *Destination, 955 IN UINT32 DstSize, 956 IN OUT VOID *Scratch, 957 IN UINT32 ScratchSize 958 ) 959 /*++ 960 961 Routine Description: 962 963 The implementation is same as that of EFI_TIANO_DECOMPRESS_PROTOCOL.Decompress(). 964 965 Arguments: 966 967 This - The protocol instance pointer 968 Source - The source buffer containing the compressed data. 969 SrcSize - The size of source buffer 970 Destination - The destination buffer to store the decompressed data 971 DstSize - The size of destination buffer. 972 Scratch - The buffer used internally by the decompress routine. This buffer is needed to store intermediate data. 973 ScratchSize - The size of scratch buffer. 974 975 Returns: 976 977 EFI_SUCCESS - Decompression is successfull 978 EFI_INVALID_PARAMETER - The source data is corrupted 979 980 --*/ 981 { 982 // 983 // For Tiano de/compression algorithm, the version is 2. 984 // 985 return Decompress ( 986 Source, 987 SrcSize, 988 Destination, 989 DstSize, 990 Scratch, 991 ScratchSize, 992 2 993 ); 994 } 995 996