From f507d71ead4dcc516d6be1b5b3cd61f900abb4a4 Mon Sep 17 00:00:00 2001 From: vit9696 Date: Tue, 8 May 2018 19:22:07 +0300 Subject: [PATCH] Backport decompression updates from new_engine --- LZMA/LzmaCompress.c | 109 +- LZMA/LzmaCompress.h | 19 +- LZMA/LzmaDecompress.c | 115 +- LZMA/LzmaDecompress.h | 34 +- Tiano/EfiTianoCompress.c | 2280 ++++++++++++++------------- Tiano/EfiTianoCompress.h | 131 +- Tiano/EfiTianoCompressLegacy.c | 2696 ++++++++++++++++---------------- Tiano/EfiTianoDecompress.c | 1044 ++++++------- Tiano/EfiTianoDecompress.h | 158 +- basetypes.h | 3 +- ffsengine.cpp | 19 +- 11 files changed, 3296 insertions(+), 3312 deletions(-) diff --git a/LZMA/LzmaCompress.c b/LZMA/LzmaCompress.c index d2b5f5e..f6fc545 100644 --- a/LZMA/LzmaCompress.c +++ b/LZMA/LzmaCompress.c @@ -25,8 +25,8 @@ static ISzAlloc SzAllocForLzma = { &AllocForLzma, &FreeForLzma }; SRes OnProgress(void *p, UInt64 inSize, UInt64 outSize) { - (void)p; (void)inSize; (void)outSize; - return SZ_OK; + (void)p; (void)inSize; (void)outSize; + return SZ_OK; } static ICompressProgress g_ProgressCallback = { &OnProgress }; @@ -35,75 +35,76 @@ STATIC UINT64 EFIAPI RShiftU64 ( - UINT64 Operand, - UINT32 Count + UINT64 Operand, + UINT32 Count ) { - return Operand >> Count; + return Operand >> Count; } VOID -SetEncodedSizeOfBuf ( - UINT64 EncodedSize, - UINT8 *EncodedData +SetEncodedSizeOfBuf( + UINT64 EncodedSize, + UINT8* EncodedData ) { - INT32 Index; + INT32 Index; - EncodedData[LZMA_PROPS_SIZE] = EncodedSize & 0xFF; - for (Index = LZMA_PROPS_SIZE + 1; Index <= LZMA_PROPS_SIZE + 7; Index++) - { - EncodedSize = RShiftU64(EncodedSize, 8); - EncodedData[Index] = EncodedSize & 0xFF; - } + EncodedData[LZMA_PROPS_SIZE] = EncodedSize & 0xFF; + for (Index = LZMA_PROPS_SIZE + 1; Index <= LZMA_PROPS_SIZE + 7; Index++) + { + EncodedSize = RShiftU64(EncodedSize, 8); + EncodedData[Index] = EncodedSize & 0xFF; + } } -INT32 +EFI_STATUS EFIAPI -LzmaCompress( - CONST UINT8 *Source, - UINTN SourceSize, - UINT8 *Destination, - UINTN *DestinationSize +LzmaCompress ( + CONST UINT8 *Source, + UINT32 SourceSize, + UINT8 *Destination, + UINT32 *DestinationSize ) { - SRes LzmaResult; - CLzmaEncProps props; - SizeT propsSize = LZMA_PROPS_SIZE; - SizeT destLen = SourceSize + SourceSize / 3 + 128; + SRes LzmaResult; + CLzmaEncProps props; + SizeT propsSize = LZMA_PROPS_SIZE; + SizeT destLen = SourceSize + SourceSize / 3 + 128; - if (*DestinationSize < destLen) - { - *DestinationSize = (UINTN)destLen; - return ERR_BUFFER_TOO_SMALL; - } + if (*DestinationSize < (UINT32)destLen) + { + *DestinationSize = (UINT32)destLen; + return EFI_BUFFER_TOO_SMALL; + } - LzmaEncProps_Init(&props); - props.dictSize = LZMA_DICTIONARY_SIZE; - props.level = 9; - props.fb = 273; + LzmaEncProps_Init(&props); + // TODO: need to detect this instead of hardcoding + props.dictSize = LZMA_DICTIONARY_SIZE; + props.level = 9; + props.fb = 273; - LzmaResult = LzmaEncode( - (Byte*)((UINT8*)Destination + LZMA_HEADER_SIZE), - &destLen, - Source, - SourceSize, - &props, - (UINT8*)Destination, - &propsSize, - props.writeEndMark, - &g_ProgressCallback, - &SzAllocForLzma, - &SzAllocForLzma); + LzmaResult = LzmaEncode( + (Byte*)((UINT8*)Destination + LZMA_HEADER_SIZE), + &destLen, + Source, + (SizeT)SourceSize, + &props, + (UINT8*)Destination, + &propsSize, + props.writeEndMark, + &g_ProgressCallback, + &SzAllocForLzma, + &SzAllocForLzma); - *DestinationSize = destLen + LZMA_HEADER_SIZE; + *DestinationSize = (UINT32)(destLen + LZMA_HEADER_SIZE); - SetEncodedSizeOfBuf(SourceSize, Destination); + SetEncodedSizeOfBuf(SourceSize, Destination); - if (LzmaResult == SZ_OK) { - return ERR_SUCCESS; - } - else { - return ERR_INVALID_PARAMETER; - } + if (LzmaResult == SZ_OK) { + return EFI_SUCCESS; + } + else { + return EFI_INVALID_PARAMETER; + } } diff --git a/LZMA/LzmaCompress.h b/LZMA/LzmaCompress.h index 20bc427..bc098b1 100644 --- a/LZMA/LzmaCompress.h +++ b/LZMA/LzmaCompress.h @@ -11,8 +11,8 @@ */ -#ifndef __LZMACOMPRESS_H__ -#define __LZMACOMPRESS_H__ +#ifndef LZMACOMPRESS_H +#define LZMACOMPRESS_H #include "SDK/C/Types.h" #include "../basetypes.h" @@ -24,16 +24,17 @@ extern "C" { #define LZMA_DICTIONARY_SIZE 0x800000 #define _LZMA_SIZE_OPT - INT32 + EFI_STATUS EFIAPI - LzmaCompress( - const UINT8 *Source, - UINTN SourceSize, - UINT8 *Destination, - UINTN *DestinationSize + LzmaCompress ( + const UINT8 *Source, + UINT32 SourceSize, + UINT8 *Destination, + UINT32 *DestinationSize ); #ifdef __cplusplus } #endif -#endif + +#endif // LZMACOMPRESS_H diff --git a/LZMA/LzmaDecompress.c b/LZMA/LzmaDecompress.c index 2f97278..17aac44 100644 --- a/LZMA/LzmaDecompress.c +++ b/LZMA/LzmaDecompress.c @@ -19,12 +19,12 @@ WITHWARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. UINT64 EFIAPI -LShiftU64( - UINT64 Operand, - UINT32 Count -) +LShiftU64 ( + UINT64 Operand, + UINT32 Count + ) { - return Operand << Count; + return Operand << Count; } static void * AllocForLzma(void *p, size_t size) { (void)p; return malloc(size); } @@ -39,19 +39,19 @@ Get the size of the uncompressed buffer by parsing EncodeData header. @return The size of the uncompressed buffer. */ UINT64 -GetDecodedSizeOfBuf( - UINT8 *EncodedData -) +GetDecodedSizeOfBuf ( + UINT8 *EncodedData + ) { - UINT64 DecodedSize; - INT32 Index; + UINT64 DecodedSize; + INT32 Index; - // Parse header - DecodedSize = 0; - for (Index = LZMA_PROPS_SIZE + 7; Index >= LZMA_PROPS_SIZE; Index--) - DecodedSize = LShiftU64(DecodedSize, 8) + EncodedData[Index]; + // Parse header + DecodedSize = 0; + for (Index = LZMA_PROPS_SIZE + 7; Index >= LZMA_PROPS_SIZE; Index--) + DecodedSize = LShiftU64(DecodedSize, 8) + EncodedData[Index]; - return DecodedSize; + return DecodedSize; } // @@ -85,18 +85,27 @@ DestinationSize and the size of the scratch buffer was returned ScratchSize. */ -INT32 +EFI_STATUS EFIAPI -LzmaGetInfo( - CONST VOID *Source, - UINTN SourceSize, - UINTN *DestinationSize -) +LzmaGetInfo ( + CONST VOID *Source, + UINT32 SourceSize, + UINT32 *DestinationSize + ) { - ASSERT(SourceSize >= LZMA_HEADER_SIZE); (void)SourceSize; + UINT64 DecodedSize; + ASSERT(SourceSize >= LZMA_HEADER_SIZE); + (void)SourceSize; - *DestinationSize = (UINTN)GetDecodedSizeOfBuf((UINT8*)Source); - return ERR_SUCCESS; + DecodedSize = GetDecodedSizeOfBuf((UINT8*)Source); + + if (DecodedSize <= UINT32_MAX) { + *DestinationSize = (UINT32)DecodedSize; + return ERR_SUCCESS; + } + else { + return ERR_INVALID_PARAMETER; + } } /* @@ -118,38 +127,38 @@ the uncompressed buffer is returned Destination. The source buffer specified by Source is corrupted (not a valid compressed format). */ -INT32 +EFI_STATUS EFIAPI -LzmaDecompress( - CONST VOID *Source, - UINTN SourceSize, - VOID *Destination -) +LzmaDecompress ( + CONST VOID *Source, + UINT32 SourceSize, + VOID *Destination + ) { - SRes LzmaResult; - ELzmaStatus Status; - SizeT DecodedBufSize; - SizeT EncodedDataSize; + SRes LzmaResult; + ELzmaStatus Status; + SizeT DecodedBufSize; + SizeT EncodedDataSize; - DecodedBufSize = (SizeT)GetDecodedSizeOfBuf((UINT8*)Source); - EncodedDataSize = (SizeT)(SourceSize - LZMA_HEADER_SIZE); + DecodedBufSize = (SizeT)GetDecodedSizeOfBuf((UINT8*)Source); + EncodedDataSize = (SizeT)(SourceSize - LZMA_HEADER_SIZE); - LzmaResult = LzmaDecode( - (Byte*)Destination, - &DecodedBufSize, - (Byte*)((UINT8*)Source + LZMA_HEADER_SIZE), - &EncodedDataSize, - (CONST Byte*) Source, - LZMA_PROPS_SIZE, - LZMA_FINISH_END, - &Status, - &SzAllocForLzma - ); + LzmaResult = LzmaDecode( + (Byte*)Destination, + &DecodedBufSize, + (Byte*)((UINT8*)Source + LZMA_HEADER_SIZE), + &EncodedDataSize, + (CONST Byte*) Source, + LZMA_PROPS_SIZE, + LZMA_FINISH_END, + &Status, + &SzAllocForLzma + ); - if (LzmaResult == SZ_OK) { - return ERR_SUCCESS; - } - else { - return ERR_INVALID_PARAMETER; - } + if (LzmaResult == SZ_OK) { + return ERR_SUCCESS; + } + else { + return ERR_INVALID_PARAMETER; + } } diff --git a/LZMA/LzmaDecompress.h b/LZMA/LzmaDecompress.h index 78d4ac0..b7b0f0f 100644 --- a/LZMA/LzmaDecompress.h +++ b/LZMA/LzmaDecompress.h @@ -11,8 +11,8 @@ */ -#ifndef __LZMADECOMPRESS_H__ -#define __LZMADECOMPRESS_H__ +#ifndef LZMADECOMPRESS_H +#define LZMADECOMPRESS_H #include "../basetypes.h" #include "SDK/C/LzmaDec.h" @@ -23,13 +23,6 @@ extern "C" { #define LZMA_HEADER_SIZE (LZMA_PROPS_SIZE + 8) - UINT64 - EFIAPI - LShiftU64( - UINT64 Operand, - UINT32 Count - ); - /* Given a Lzma compressed source buffer, this function retrieves the size of the uncompressed buffer and the size of the scratch buffer required @@ -57,12 +50,12 @@ extern "C" { buffer was returned ScratchSize. */ - INT32 + EFI_STATUS EFIAPI - LzmaGetInfo( - const VOID *Source, - UINTN SourceSize, - UINTN *DestinationSize + LzmaGetInfo ( + CONST VOID *Source, + UINT32 SourceSize, + UINT32 *DestinationSize ); /* @@ -84,15 +77,16 @@ extern "C" { The source buffer specified by Source is corrupted (not a valid compressed format). */ - INT32 + EFI_STATUS EFIAPI - LzmaDecompress( - const VOID *Source, - UINTN SourceSize, - VOID *Destination + LzmaDecompress ( + CONST VOID *Source, + UINT32 SourceSize, + VOID *Destination ); #ifdef __cplusplus } #endif -#endif + +#endif // LZMADECOMPRESS_H diff --git a/Tiano/EfiTianoCompress.c b/Tiano/EfiTianoCompress.c index 31c0e37..afd2ec2 100644 --- a/Tiano/EfiTianoCompress.c +++ b/Tiano/EfiTianoCompress.c @@ -1,18 +1,18 @@ /** @file -Compression routine. The compression algorithm is a mixture of LZ77 and Huffman -coding. LZ77 transforms the source data into a sequence of Original Characters -and Pointers to repeated strings. This sequence is further divided into Blocks +Compression routine. The compression algorithm is a mixture of LZ77 and Huffman +coding. LZ77 transforms the source data into a sequence of Original Characters +and Pointers to repeated strings. This sequence is further divided into Blocks and Huffman codings are applied to each Block. Copyright (c) 2014, Nikolaj Schlej Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.
-This program and the accompanying materials -are licensed and made available under the terms and conditions of the BSD License -which accompanies this distribution. The full text of the license may be found at -http://opensource.org/licenses/bsd-license.php - -THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, -WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. +This program and the accompanying materials +are licensed and made available under the terms and conditions of the BSD License +which accompanies this distribution. The full text of the license may be found at +http://opensource.org/licenses/bsd-license.php + +THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. **/ @@ -52,9 +52,9 @@ UINT8 gPBIT = 4; #define NT (CODE_BIT + 3) #define TBIT 5 #if NT > NP -#define NPT NT + #define NPT NT #else -#define NPT NP + #define NPT NP #endif // @@ -62,163 +62,163 @@ UINT8 gPBIT = 4; // STATIC -VOID +VOID PutDword( - IN UINT32 Data -); + IN UINT32 Data + ); STATIC -EFI_STATUS -AllocateMemory(VOID); +EFI_STATUS +AllocateMemory (VOID); STATIC VOID -FreeMemory(VOID); +FreeMemory (VOID); -STATIC -VOID -InitSlide(VOID); +STATIC +VOID +InitSlide (VOID); -STATIC -NODE -Child( - IN NODE q, - IN UINT8 c -); +STATIC +NODE +Child ( + IN NODE q, + IN UINT8 c + ); -STATIC -VOID -MakeChild( - IN NODE q, - IN UINT8 c, - IN NODE r -); +STATIC +VOID +MakeChild ( + IN NODE q, + IN UINT8 c, + IN NODE r + ); + +STATIC +VOID +Split ( + IN NODE Old + ); -STATIC -VOID -Split( - IN NODE Old -); +STATIC +VOID +InsertNode (VOID); + +STATIC +VOID +DeleteNode (VOID); -STATIC -VOID -InsertNode(VOID); +STATIC +VOID +GetNextMatch (VOID); + +STATIC +EFI_STATUS +Encode (VOID); -STATIC -VOID -DeleteNode(VOID); +STATIC +VOID +CountTFreq (VOID); -STATIC -VOID -GetNextMatch(VOID); +STATIC +VOID +WritePTLen ( + IN INT32 n, + IN INT32 nbit, + IN INT32 Special + ); -STATIC -EFI_STATUS -Encode(VOID); +STATIC +VOID +WriteCLen (VOID); + +STATIC +VOID +EncodeC ( + IN INT32 c + ); -STATIC -VOID -CountTFreq(VOID); +STATIC +VOID +EncodeP ( + IN UINT32 p + ); -STATIC -VOID -WritePTLen( - IN INT32 n, - IN INT32 nbit, - IN INT32 Special -); +STATIC +VOID +SendBlock (VOID); + +STATIC +VOID +Output ( + IN UINT32 c, + IN UINT32 p + ); -STATIC -VOID -WriteCLen(VOID); +STATIC +VOID +HufEncodeStart (VOID); + +STATIC +VOID +HufEncodeEnd (VOID); + +STATIC +VOID +MakeCrcTable (VOID); + +STATIC +VOID +PutBits ( + IN INT32 n, + IN UINT32 x + ); + +STATIC +INT32 +FreadCrc ( + OUT UINT8 *p, + IN INT32 n + ); + +STATIC +VOID +InitPutBits (VOID); + +STATIC +VOID +CountLen ( + IN INT32 i + ); -STATIC -VOID -EncodeC( - IN INT32 c -); +STATIC +VOID +MakeLen ( + IN INT32 Root + ); + +STATIC +VOID +DownHeap ( + IN INT32 i + ); -STATIC -VOID -EncodeP( - IN UINT32 p -); - -STATIC -VOID -SendBlock(VOID); - -STATIC -VOID -Output( - IN UINT32 c, - IN UINT32 p -); - -STATIC -VOID -HufEncodeStart(VOID); - -STATIC -VOID -HufEncodeEnd(VOID); - -STATIC -VOID -MakeCrcTable(VOID); - -STATIC -VOID -PutBits( - IN INT32 n, - IN UINT32 x -); - -STATIC -INT32 -FreadCrc( - OUT UINT8 *p, - IN INT32 n -); - -STATIC -VOID -InitPutBits(VOID); - -STATIC -VOID -CountLen( - IN INT32 i -); - -STATIC -VOID -MakeLen( - IN INT32 Root -); - -STATIC -VOID -DownHeap( - IN INT32 i -); - -STATIC -VOID -MakeCode( - IN INT32 n, - IN UINT8 Len[], - OUT UINT16 Code[] -); - -STATIC -INT32 -MakeTree( - IN INT32 NParm, - IN UINT16 FreqParm[], - OUT UINT8 LenParm[], - OUT UINT16 CodeParm[] -); +STATIC +VOID +MakeCode ( + IN INT32 n, + IN UINT8 Len[], + OUT UINT16 Code[] + ); + +STATIC +INT32 +MakeTree ( + IN INT32 NParm, + IN UINT16 FreqParm[], + OUT UINT8 LenParm[], + OUT UINT16 CodeParm[] + ); // @@ -234,8 +234,8 @@ STATIC UINT32 mBufSiz = 0, mOutputPos, mOutputMask, mSubBitBuf, mCrc; STATIC UINT32 mCompSize, mOrigSize; STATIC UINT16 *mFreq, *mSortPtr, mLenCnt[17], mLeft[2 * NC - 1], mRight[2 * NC - 1], -mCrcTable[UINT8_MAX + 1], mCFreq[2 * NC - 1], mCCode[NC], -mPFreq[2 * NP - 1], mPTCode[NPT], mTFreq[2 * NT - 1]; + mCrcTable[UINT8_MAX + 1], mCFreq[2 * NC - 1],mCCode[NC], + mPFreq[2 * NP - 1], mPTCode[NPT], mTFreq[2 * NT - 1]; STATIC NODE mPos, mMatchPos, mAvail, *mPosition, *mParent, *mPrev, *mNext = NULL; @@ -245,12 +245,12 @@ STATIC NODE mPos, mMatchPos, mAvail, *mPosition, *mParent, *mPrev, *mNext = NU // EFI_STATUS -EfiCompress( - IN CONST VOID *SrcBuffer, - IN UINT32 SrcSize, - IN VOID *DstBuffer, - IN OUT UINT32 *DstSize -) +EfiCompress ( + IN CONST VOID *SrcBuffer, + IN UINT32 SrcSize, + IN VOID *DstBuffer, + IN OUT UINT32 *DstSize + ) /*++ Routine Description: @@ -263,89 +263,88 @@ Arguments: SrcSize - The size of source data DstBuffer - The buffer to store the compressed data DstSize - On input, the size of DstBuffer; On output, - the size of the actual compressed data. + the size of the actual compressed data. Returns: EFI_BUFFER_TOO_SMALL - The DstBuffer is too small. In this case, - DstSize contains the size needed. + DstSize contains the size needed. EFI_SUCCESS - Compression is successful. --*/ { - EFI_STATUS Status = EFI_SUCCESS; + EFI_STATUS Status = EFI_SUCCESS; + + // + // Initializations + // + mBufSiz = 0; + mBuf = NULL; + mText = NULL; + mLevel = NULL; + mChildCount = NULL; + mPosition = NULL; + mParent = NULL; + mPrev = NULL; + mNext = NULL; + gPBIT = 4; + + mSrc = (UINT8*)SrcBuffer; + mSrcUpperLimit = mSrc + SrcSize; + mDst = DstBuffer; + mDstUpperLimit = mDst + *DstSize; - // - // Initializations - // - mBufSiz = 0; - mBuf = NULL; - mText = NULL; - mLevel = NULL; - mChildCount = NULL; - mPosition = NULL; - mParent = NULL; - mPrev = NULL; - mNext = NULL; - gPBIT = 4; + PutDword(0L); + PutDword(0L); + + MakeCrcTable (); - mSrc = (UINT8*)SrcBuffer; - mSrcUpperLimit = mSrc + SrcSize; - mDst = DstBuffer; - mDstUpperLimit = mDst + *DstSize; + mOrigSize = mCompSize = 0; + mCrc = INIT_CRC; + + // + // Compress it + // + + Status = Encode(); + if (EFI_ERROR (Status)) { + return EFI_OUT_OF_RESOURCES; + } + + // + // Null terminate the compressed data + // + if (mDst < mDstUpperLimit) { + *mDst++ = 0; + } + + // + // Fill in compressed size and original size + // + mDst = DstBuffer; + PutDword(mCompSize+1); + PutDword(mOrigSize); - PutDword(0L); - PutDword(0L); - - MakeCrcTable(); - - mOrigSize = mCompSize = 0; - mCrc = INIT_CRC; - - // - // Compress it - // - - Status = Encode(); - if (EFI_ERROR(Status)) { - return EFI_OUT_OF_RESOURCES; - } - - // - // Null terminate the compressed data - // - if (mDst < mDstUpperLimit) { - *mDst++ = 0; - } - - // - // Fill in compressed size and original size - // - mDst = DstBuffer; - PutDword(mCompSize + 1); - PutDword(mOrigSize); - - // - // Return - // - - if (mCompSize + 1 + 8 > *DstSize) { - *DstSize = mCompSize + 1 + 8; - return EFI_BUFFER_TOO_SMALL; - } - else { - *DstSize = mCompSize + 1 + 8; - return EFI_SUCCESS; - } + // + // Return + // + + if (mCompSize + 1 + 8 > *DstSize) { + *DstSize = mCompSize + 1 + 8; + return EFI_BUFFER_TOO_SMALL; + } else { + *DstSize = mCompSize + 1 + 8; + return EFI_SUCCESS; + } } EFI_STATUS TianoCompress( - IN CONST VOID *SrcBuffer, - IN UINT32 SrcSize, - IN VOID *DstBuffer, - IN OUT UINT32 *DstSize +IN CONST VOID *SrcBuffer, +IN UINT32 SrcSize, +IN VOID *DstBuffer, +IN OUT UINT32 *DstSize ) /*++ @@ -369,118 +368,118 @@ EFI_SUCCESS - Compression is successful. --*/ { - EFI_STATUS Status = EFI_SUCCESS; + EFI_STATUS Status = EFI_SUCCESS; - // - // Initializations - // - mBufSiz = 0; - mBuf = NULL; - mText = NULL; - mLevel = NULL; - mChildCount = NULL; - mPosition = NULL; - mParent = NULL; - mPrev = NULL; - mNext = NULL; - gPBIT = 5; + // + // Initializations + // + mBufSiz = 0; + mBuf = NULL; + mText = NULL; + mLevel = NULL; + mChildCount = NULL; + mPosition = NULL; + mParent = NULL; + mPrev = NULL; + mNext = NULL; + gPBIT = 5; - mSrc = (UINT8*)SrcBuffer; - mSrcUpperLimit = mSrc + SrcSize; - mDst = DstBuffer; - mDstUpperLimit = mDst + *DstSize; + mSrc = (UINT8*)SrcBuffer; + mSrcUpperLimit = mSrc + SrcSize; + mDst = DstBuffer; + mDstUpperLimit = mDst + *DstSize; - PutDword(0L); - PutDword(0L); + PutDword(0L); + PutDword(0L); - MakeCrcTable(); + MakeCrcTable(); - mOrigSize = mCompSize = 0; - mCrc = INIT_CRC; + mOrigSize = mCompSize = 0; + mCrc = INIT_CRC; - // - // Compress it - // + // + // Compress it + // - Status = Encode(); - if (EFI_ERROR(Status)) { - return EFI_OUT_OF_RESOURCES; - } + Status = Encode(); + if (EFI_ERROR(Status)) { + return EFI_OUT_OF_RESOURCES; + } - // - // Null terminate the compressed data - // - if (mDst < mDstUpperLimit) { - *mDst++ = 0; - } + // + // Null terminate the compressed data + // + if (mDst < mDstUpperLimit) { + *mDst++ = 0; + } - // - // Fill in compressed size and original size - // - mDst = DstBuffer; - PutDword(mCompSize + 1); - PutDword(mOrigSize); + // + // Fill in compressed size and original size + // + mDst = DstBuffer; + PutDword(mCompSize + 1); + PutDword(mOrigSize); - // - // Return - // + // + // Return + // - if (mCompSize + 1 + 8 > *DstSize) { - *DstSize = mCompSize + 1 + 8; - return EFI_BUFFER_TOO_SMALL; - } - else { - *DstSize = mCompSize + 1 + 8; - return EFI_SUCCESS; - } + if (mCompSize + 1 + 8 > *DstSize) { + *DstSize = mCompSize + 1 + 8; + return EFI_BUFFER_TOO_SMALL; + } + else { + *DstSize = mCompSize + 1 + 8; + return EFI_SUCCESS; + } } -STATIC -VOID +STATIC +VOID PutDword( - IN UINT32 Data -) + IN UINT32 Data + ) /*++ Routine Description: Put a dword to output stream - + Arguments: Data - the dword to put - + Returns: (VOID) - + --*/ { - if (mDst < mDstUpperLimit) { - *mDst++ = (UINT8)(((UINT8)(Data)) & 0xff); - } + if (mDst < mDstUpperLimit) { + *mDst++ = (UINT8)(((UINT8)(Data )) & 0xff); + } - if (mDst < mDstUpperLimit) { - *mDst++ = (UINT8)(((UINT8)(Data >> 0x08)) & 0xff); - } + if (mDst < mDstUpperLimit) { + *mDst++ = (UINT8)(((UINT8)(Data >> 0x08)) & 0xff); + } - if (mDst < mDstUpperLimit) { - *mDst++ = (UINT8)(((UINT8)(Data >> 0x10)) & 0xff); - } + if (mDst < mDstUpperLimit) { + *mDst++ = (UINT8)(((UINT8)(Data >> 0x10)) & 0xff); + } - if (mDst < mDstUpperLimit) { - *mDst++ = (UINT8)(((UINT8)(Data >> 0x18)) & 0xff); - } + if (mDst < mDstUpperLimit) { + *mDst++ = (UINT8)(((UINT8)(Data >> 0x18)) & 0xff); + } } STATIC EFI_STATUS -AllocateMemory() +AllocateMemory () /*++ Routine Description: Allocate memory spaces for data structures used in compression process - + Argements: (VOID) Returns: @@ -490,421 +489,423 @@ Returns: --*/ { - UINT32 i; + UINT32 i; + + mText = malloc (WNDSIZ * 2 + MAXMATCH); + if (!mText) return EFI_OUT_OF_RESOURCES; + for (i = 0 ; i < WNDSIZ * 2 + MAXMATCH; i ++) { + mText[i] = 0; + } - mText = malloc(WNDSIZ * 2 + MAXMATCH); - if (NULL == mText) - return EFI_OUT_OF_RESOURCES; + mLevel = malloc((WNDSIZ + UINT8_MAX + 1) * sizeof(*mLevel)); + if (!mLevel) return EFI_OUT_OF_RESOURCES; + mChildCount = malloc((WNDSIZ + UINT8_MAX + 1) * sizeof(*mChildCount)); + if (!mChildCount) return EFI_OUT_OF_RESOURCES; + mPosition = malloc((WNDSIZ + UINT8_MAX + 1) * sizeof(*mPosition)); + if (!mPosition) return EFI_OUT_OF_RESOURCES; + mParent = malloc(WNDSIZ * 2 * sizeof(*mParent)); + if (!mParent) return EFI_OUT_OF_RESOURCES; + mPrev = malloc(WNDSIZ * 2 * sizeof(*mPrev)); + if (!mPrev) return EFI_OUT_OF_RESOURCES; + mNext = malloc((MAX_HASH_VAL + 1) * sizeof(*mNext)); + if (!mNext) return EFI_OUT_OF_RESOURCES; - for (i = 0; i < WNDSIZ * 2 + MAXMATCH; i++) { - mText[i] = 0; - } - - mLevel = malloc((WNDSIZ + UINT8_MAX + 1) * sizeof(*mLevel)); - mChildCount = malloc((WNDSIZ + UINT8_MAX + 1) * sizeof(*mChildCount)); - mPosition = malloc((WNDSIZ + UINT8_MAX + 1) * sizeof(*mPosition)); - mParent = malloc(WNDSIZ * 2 * sizeof(*mParent)); - mPrev = malloc(WNDSIZ * 2 * sizeof(*mPrev)); - mNext = malloc((MAX_HASH_VAL + 1) * sizeof(*mNext)); - - mBufSiz = 16 * 1024U; - while ((mBuf = malloc(mBufSiz)) == NULL) { - mBufSiz = (mBufSiz / 10U) * 9U; - if (mBufSiz < 4 * 1024U) { - return EFI_OUT_OF_RESOURCES; - } - } - mBuf[0] = 0; - - return EFI_SUCCESS; + mBufSiz = 16 * 1024U; + while ((mBuf = malloc(mBufSiz)) == NULL) { + mBufSiz = (mBufSiz / 10U) * 9U; + if (mBufSiz < 4 * 1024U) { + return EFI_OUT_OF_RESOURCES; + } + } + mBuf[0] = 0; + + return EFI_SUCCESS; } VOID -FreeMemory() +FreeMemory () /*++ Routine Description: Called when compression is completed to free memory previously allocated. - + Arguments: (VOID) Returns: (VOID) --*/ { - if (mText) { - free(mText); - } + if (mText) { + free (mText); + } + + if (mLevel) { + free (mLevel); + } + + if (mChildCount) { + free (mChildCount); + } + + if (mPosition) { + free (mPosition); + } + + if (mParent) { + free (mParent); + } + + if (mPrev) { + free (mPrev); + } + + if (mNext) { + free (mNext); + } + + if (mBuf) { + free (mBuf); + } - if (mLevel) { - free(mLevel); - } - - if (mChildCount) { - free(mChildCount); - } - - if (mPosition) { - free(mPosition); - } - - if (mParent) { - free(mParent); - } - - if (mPrev) { - free(mPrev); - } - - if (mNext) { - free(mNext); - } - - if (mBuf) { - free(mBuf); - } - - return; + return; } -STATIC -VOID -InitSlide() +STATIC +VOID +InitSlide () /*++ Routine Description: Initialize String Info Log data structures - + Arguments: (VOID) Returns: (VOID) --*/ { - NODE i; + NODE i; - for (i = WNDSIZ; i <= (NODE)(WNDSIZ + UINT8_MAX); i++) { - mLevel[i] = 1; - mPosition[i] = NIL; /* sentinel */ - } - for (i = WNDSIZ; i < (NODE)(WNDSIZ * 2); i++) { - mParent[i] = NIL; - } - mAvail = 1; - for (i = 1; i < (NODE)(WNDSIZ - 1); i++) { - mNext[i] = (NODE)(i + 1); - } - - mNext[WNDSIZ - 1] = NIL; - for (i = WNDSIZ * 2; i <= (NODE)MAX_HASH_VAL; i++) { - mNext[i] = NIL; - } + for (i = WNDSIZ; i <= (NODE)(WNDSIZ + UINT8_MAX); i++) { + mLevel[i] = 1; + mPosition[i] = NIL; /* sentinel */ + } + for (i = WNDSIZ; i < (NODE)(WNDSIZ * 2); i++) { + mParent[i] = NIL; + } + mAvail = 1; + for (i = 1; i < (NODE)(WNDSIZ - 1); i++) { + mNext[i] = (NODE)(i + 1); + } + + mNext[WNDSIZ - 1] = NIL; + for (i = WNDSIZ * 2; i <= (NODE)MAX_HASH_VAL; i++) { + mNext[i] = NIL; + } } -STATIC -NODE -Child( - IN NODE q, - IN UINT8 c -) +STATIC +NODE +Child ( + IN NODE q, + IN UINT8 c + ) /*++ Routine Description: Find child node given the parent node and the edge character - + Arguments: q - the parent node c - the edge character - + Returns: - The child node (NIL if not found) - + The child node (NIL if not found) + --*/ { - NODE r; - - r = mNext[HASH(q, c)]; - mParent[NIL] = q; /* sentinel */ - while (mParent[r] != q) { - r = mNext[r]; - } - - return r; + NODE r; + + r = mNext[HASH(q, c)]; + mParent[NIL] = q; /* sentinel */ + while (mParent[r] != q) { + r = mNext[r]; + } + + return r; } -STATIC -VOID -MakeChild( - IN NODE q, - IN UINT8 c, - IN NODE r -) +STATIC +VOID +MakeChild ( + IN NODE q, + IN UINT8 c, + IN NODE r + ) /*++ Routine Description: Create a new child for a given parent node. - + Arguments: q - the parent node c - the edge character r - the child node - + Returns: (VOID) --*/ { - NODE h, t; - - h = (NODE)HASH(q, c); - t = mNext[h]; - mNext[h] = r; - mNext[r] = t; - mPrev[t] = r; - mPrev[r] = h; - mParent[r] = q; - mChildCount[q]++; + NODE h, t; + + h = (NODE)HASH(q, c); + t = mNext[h]; + mNext[h] = r; + mNext[r] = t; + mPrev[t] = r; + mPrev[r] = h; + mParent[r] = q; + mChildCount[q]++; } -STATIC -VOID +STATIC +VOID Split ( - IN NODE Old -) + NODE Old + ) /*++ Routine Description: Split a node. - + Arguments: Old - the node to split - + Returns: (VOID) --*/ { - NODE New, t; + NODE New, t; - New = mAvail; - mAvail = mNext[New]; - mChildCount[New] = 0; - t = mPrev[Old]; - mPrev[New] = t; - mNext[t] = New; - t = mNext[Old]; - mNext[New] = t; - mPrev[t] = New; - mParent[New] = mParent[Old]; - mLevel[New] = (UINT8)mMatchLen; - mPosition[New] = mPos; - MakeChild(New, mText[mMatchPos + mMatchLen], Old); - MakeChild(New, mText[mPos + mMatchLen], mPos); + New = mAvail; + mAvail = mNext[New]; + mChildCount[New] = 0; + t = mPrev[Old]; + mPrev[New] = t; + mNext[t] = New; + t = mNext[Old]; + mNext[New] = t; + mPrev[t] = New; + mParent[New] = mParent[Old]; + mLevel[New] = (UINT8)mMatchLen; + mPosition[New] = mPos; + MakeChild(New, mText[mMatchPos + mMatchLen], Old); + MakeChild(New, mText[mPos + mMatchLen], mPos); } -STATIC -VOID -InsertNode() +STATIC +VOID +InsertNode () /*++ Routine Description: Insert string info for current position into the String Info Log - + Arguments: (VOID) Returns: (VOID) --*/ { - NODE q, r, j, t; - UINT8 c, *t1, *t2; - - if (mMatchLen >= 4) { - - // - // We have just got a long match, the target tree - // can be located by MatchPos + 1. Travese the tree - // from bottom up to get to a proper starting point. - // The usage of PERC_FLAG ensures proper node deletion - // in DeleteNode() later. - // - - mMatchLen--; - r = (INT16)((mMatchPos + 1) | WNDSIZ); - while ((q = mParent[r]) == NIL) { - r = mNext[r]; - } - while (mLevel[q] >= mMatchLen) { - r = q; q = mParent[q]; - } - t = q; - while (mPosition[t] < 0) { - mPosition[t] = mPos; - t = mParent[t]; - } - if (t < (NODE)WNDSIZ) { - mPosition[t] = (NODE)(mPos | PERC_FLAG); - } - } - else { - - // - // Locate the target tree - // - - q = (INT16)(mText[mPos] + WNDSIZ); - c = mText[mPos + 1]; - if ((r = Child(q, c)) == NIL) { - MakeChild(q, c, mPos); - mMatchLen = 1; - return; - } - mMatchLen = 2; - } - - // - // Traverse down the tree to find a match. - // Update Position value along the route. - // Node split or creation is involved. - // - - for (; ; ) { - if (r >= (NODE)WNDSIZ) { - j = MAXMATCH; - mMatchPos = r; - } - else { - j = mLevel[r]; - mMatchPos = (NODE)(mPosition[r] & ~PERC_FLAG); - } - if (mMatchPos >= mPos) { - mMatchPos -= WNDSIZ; - } - t1 = &mText[mPos + mMatchLen]; - t2 = &mText[mMatchPos + mMatchLen]; - while (mMatchLen < j) { - if (*t1 != *t2) { - Split(r); - return; - } - mMatchLen++; - t1++; - t2++; - } - if (mMatchLen >= MAXMATCH) { - break; - } - mPosition[r] = mPos; - q = r; - if ((r = Child(q, *t1)) == NIL) { - MakeChild(q, *t1, mPos); - return; - } - mMatchLen++; - } - t = mPrev[r]; - mPrev[mPos] = t; - mNext[t] = mPos; - t = mNext[r]; - mNext[mPos] = t; - mPrev[t] = mPos; - mParent[mPos] = q; - mParent[r] = NIL; - - // - // Special usage of 'next' - // - mNext[r] = mPos; + NODE q, r, j, t; + UINT8 c, *t1, *t2; + if (mMatchLen >= 4) { + + // + // We have just got a long match, the target tree + // can be located by MatchPos + 1. Travese the tree + // from bottom up to get to a proper starting point. + // The usage of PERC_FLAG ensures proper node deletion + // in DeleteNode() later. + // + + mMatchLen--; + r = (INT16)((mMatchPos + 1) | WNDSIZ); + while ((q = mParent[r]) == NIL) { + r = mNext[r]; + } + while (mLevel[q] >= mMatchLen) { + r = q; q = mParent[q]; + } + t = q; + while (mPosition[t] < 0) { + mPosition[t] = mPos; + t = mParent[t]; + } + if (t < (NODE)WNDSIZ) { + mPosition[t] = (NODE)(mPos | PERC_FLAG); + } + } else { + + // + // Locate the target tree + // + + q = (INT16)(mText[mPos] + WNDSIZ); + c = mText[mPos + 1]; + if ((r = Child(q, c)) == NIL) { + MakeChild(q, c, mPos); + mMatchLen = 1; + return; + } + mMatchLen = 2; + } + + // + // Traverse down the tree to find a match. + // Update Position value along the route. + // Node split or creation is involved. + // + + for ( ; ; ) { + if (r >= (NODE)WNDSIZ) { + j = MAXMATCH; + mMatchPos = r; + } else { + j = mLevel[r]; + mMatchPos = (NODE)(mPosition[r] & ~PERC_FLAG); + } + if (mMatchPos >= mPos) { + mMatchPos -= WNDSIZ; + } + t1 = &mText[mPos + mMatchLen]; + t2 = &mText[mMatchPos + mMatchLen]; + while (mMatchLen < j) { + if (*t1 != *t2) { + Split(r); + return; + } + mMatchLen++; + t1++; + t2++; + } + if (mMatchLen >= MAXMATCH) { + break; + } + mPosition[r] = mPos; + q = r; + if ((r = Child(q, *t1)) == NIL) { + MakeChild(q, *t1, mPos); + return; + } + mMatchLen++; + } + t = mPrev[r]; + mPrev[mPos] = t; + mNext[t] = mPos; + t = mNext[r]; + mNext[mPos] = t; + mPrev[t] = mPos; + mParent[mPos] = q; + mParent[r] = NIL; + + // + // Special usage of 'next' + // + mNext[r] = mPos; + } -STATIC -VOID -DeleteNode() +STATIC +VOID +DeleteNode () /*++ Routine Description: Delete outdated string info. (The Usage of PERC_FLAG ensures a clean deletion) - + Arguments: (VOID) Returns: (VOID) --*/ { - NODE q, r, s, t, u; + NODE q, r, s, t, u; - if (mParent[mPos] == NIL) { - return; - } - - r = mPrev[mPos]; - s = mNext[mPos]; - mNext[r] = s; - mPrev[s] = r; - r = mParent[mPos]; - mParent[mPos] = NIL; - if (r >= (NODE)WNDSIZ || --mChildCount[r] > 1) { - return; - } - t = (NODE)(mPosition[r] & ~PERC_FLAG); - if (t >= mPos) { - t -= WNDSIZ; - } - s = t; - q = mParent[r]; - while ((u = mPosition[q]) & PERC_FLAG) { - u &= ~PERC_FLAG; - if (u >= mPos) { - u -= WNDSIZ; - } - if (u > s) { - s = u; - } - mPosition[q] = (INT16)(s | WNDSIZ); - q = mParent[q]; - } - if (q < (NODE)WNDSIZ) { - if (u >= mPos) { - u -= WNDSIZ; - } - if (u > s) { - s = u; - } - mPosition[q] = (INT16)(s | WNDSIZ | PERC_FLAG); - } - s = Child(r, mText[t + mLevel[r]]); - t = mPrev[s]; - u = mNext[s]; - mNext[t] = u; - mPrev[u] = t; - t = mPrev[r]; - mNext[t] = s; - mPrev[s] = t; - t = mNext[r]; - mPrev[t] = s; - mNext[s] = t; - mParent[s] = mParent[r]; - mParent[r] = NIL; - mNext[r] = mAvail; - mAvail = r; + if (mParent[mPos] == NIL) { + return; + } + + r = mPrev[mPos]; + s = mNext[mPos]; + mNext[r] = s; + mPrev[s] = r; + r = mParent[mPos]; + mParent[mPos] = NIL; + if (r >= (NODE)WNDSIZ || --mChildCount[r] > 1) { + return; + } + t = (NODE)(mPosition[r] & ~PERC_FLAG); + if (t >= mPos) { + t -= WNDSIZ; + } + s = t; + q = mParent[r]; + while ((u = mPosition[q]) & PERC_FLAG) { + u &= ~PERC_FLAG; + if (u >= mPos) { + u -= WNDSIZ; + } + if (u > s) { + s = u; + } + mPosition[q] = (INT16)(s | WNDSIZ); + q = mParent[q]; + } + if (q < (NODE)WNDSIZ) { + if (u >= mPos) { + u -= WNDSIZ; + } + if (u > s) { + s = u; + } + mPosition[q] = (INT16)(s | WNDSIZ | PERC_FLAG); + } + s = Child(r, mText[t + mLevel[r]]); + t = mPrev[s]; + u = mNext[s]; + mNext[t] = u; + mPrev[u] = t; + t = mPrev[r]; + mNext[t] = s; + mPrev[s] = t; + t = mNext[r]; + mPrev[t] = s; + mNext[s] = t; + mParent[s] = mParent[r]; + mParent[r] = NIL; + mNext[r] = mAvail; + mAvail = r; } -STATIC -VOID -GetNextMatch() +STATIC +VOID +GetNextMatch () /*++ Routine Description: @@ -918,22 +919,22 @@ Returns: (VOID) --*/ { - INT32 n; + INT32 n; - mRemainder--; - if (++mPos == WNDSIZ * 2) { - memmove(&mText[0], &mText[WNDSIZ], WNDSIZ + MAXMATCH); - n = FreadCrc(&mText[WNDSIZ + MAXMATCH], WNDSIZ); - mRemainder += n; - mPos = WNDSIZ; - } - DeleteNode(); - InsertNode(); + mRemainder--; + if (++mPos == WNDSIZ * 2) { + memmove(&mText[0], &mText[WNDSIZ], WNDSIZ + MAXMATCH); + n = FreadCrc(&mText[WNDSIZ + MAXMATCH], WNDSIZ); + mRemainder += n; + mPos = WNDSIZ; + } + DeleteNode(); + InsertNode(); } STATIC EFI_STATUS -Encode() +Encode () /*++ Routine Description: @@ -943,338 +944,323 @@ Routine Description: Arguments: (VOID) Returns: - + EFI_SUCCESS - The compression is successful EFI_OUT_0F_RESOURCES - Not enough memory for compression process --*/ { - EFI_STATUS Status; - INT32 LastMatchLen; - NODE LastMatchPos; + EFI_STATUS Status; + INT32 LastMatchLen; + NODE LastMatchPos; - Status = AllocateMemory(); - if (EFI_ERROR(Status)) { - FreeMemory(); - return Status; - } + Status = AllocateMemory(); + if (EFI_ERROR(Status)) { + FreeMemory(); + return Status; + } - InitSlide(); + InitSlide(); + + HufEncodeStart(); - HufEncodeStart(); - - mRemainder = FreadCrc(&mText[WNDSIZ], WNDSIZ + MAXMATCH); - - mMatchLen = 0; - mPos = WNDSIZ; - InsertNode(); - if (mMatchLen > mRemainder) { - mMatchLen = mRemainder; - } - while (mRemainder > 0) { - LastMatchLen = mMatchLen; - LastMatchPos = mMatchPos; - GetNextMatch(); - if (mMatchLen > mRemainder) { - mMatchLen = mRemainder; - } - - if (mMatchLen > LastMatchLen || LastMatchLen < THRESHOLD) { - - // - // Not enough benefits are gained by outputting a pointer, - // so just output the original character - // - - Output(mText[mPos - 1], 0); - } - else { - - // - // Outputting a pointer is beneficial enough, do it. - // - - Output(LastMatchLen + (UINT8_MAX + 1 - THRESHOLD), - (mPos - LastMatchPos - 2) & (WNDSIZ - 1)); - while (--LastMatchLen > 0) { - GetNextMatch(); - } - if (mMatchLen > mRemainder) { - mMatchLen = mRemainder; - } - } - } - - HufEncodeEnd(); - FreeMemory(); - return EFI_SUCCESS; + mRemainder = FreadCrc(&mText[WNDSIZ], WNDSIZ + MAXMATCH); + + mMatchLen = 0; + mPos = WNDSIZ; + InsertNode(); + if (mMatchLen > mRemainder) { + mMatchLen = mRemainder; + } + while (mRemainder > 0) { + LastMatchLen = mMatchLen; + LastMatchPos = mMatchPos; + GetNextMatch(); + if (mMatchLen > mRemainder) { + mMatchLen = mRemainder; + } + + if (mMatchLen > LastMatchLen || LastMatchLen < THRESHOLD) { + + // + // Not enough benefits are gained by outputting a pointer, + // so just output the original character + // + + Output(mText[mPos - 1], 0); + } else { + + // + // Outputting a pointer is beneficial enough, do it. + // + + Output(LastMatchLen + (UINT8_MAX + 1 - THRESHOLD), + (mPos - LastMatchPos - 2) & (WNDSIZ - 1)); + while (--LastMatchLen > 0) { + GetNextMatch(); + } + if (mMatchLen > mRemainder) { + mMatchLen = mRemainder; + } + } + } + + HufEncodeEnd(); + FreeMemory(); + return EFI_SUCCESS; } -STATIC -VOID -CountTFreq() +STATIC +VOID +CountTFreq () /*++ Routine Description: Count the frequencies for the Extra Set - + Arguments: (VOID) Returns: (VOID) --*/ { - INT32 i, k, n, Count; + INT32 i, k, n, Count; - for (i = 0; i < NT; i++) { - mTFreq[i] = 0; - } - n = NC; - while (n > 0 && mCLen[n - 1] == 0) { - n--; - } - i = 0; - while (i < n) { - k = mCLen[i++]; - if (k == 0) { - Count = 1; - while (i < n && mCLen[i] == 0) { - i++; - Count++; - } - if (Count <= 2) { - mTFreq[0] = (UINT16)(mTFreq[0] + Count); - } - else if (Count <= 18) { - mTFreq[1]++; - } - else if (Count == 19) { - mTFreq[0]++; - mTFreq[1]++; - } - else { - mTFreq[2]++; - } - } - else { - mTFreq[k + 2]++; - } - } + for (i = 0; i < NT; i++) { + mTFreq[i] = 0; + } + n = NC; + while (n > 0 && mCLen[n - 1] == 0) { + n--; + } + i = 0; + while (i < n) { + k = mCLen[i++]; + if (k == 0) { + Count = 1; + while (i < n && mCLen[i] == 0) { + i++; + Count++; + } + if (Count <= 2) { + mTFreq[0] = (UINT16)(mTFreq[0] + Count); + } else if (Count <= 18) { + mTFreq[1]++; + } else if (Count == 19) { + mTFreq[0]++; + mTFreq[1]++; + } else { + mTFreq[2]++; + } + } else { + mTFreq[k + 2]++; + } + } } -STATIC -VOID -WritePTLen( - IN INT32 n, - IN INT32 nbit, - IN INT32 Special -) +STATIC +VOID +WritePTLen ( + IN INT32 n, + IN INT32 nbit, + IN INT32 Special + ) /*++ Routine Description: Outputs the code length array for the Extra Set or the Position Set. - + Arguments: n - the number of symbols nbit - the number of bits needed to represent 'n' Special - the special symbol that needs to be take care of - + Returns: (VOID) --*/ { - INT32 i, k; + INT32 i, k; - while (n > 0 && mPTLen[n - 1] == 0) { - n--; - } - PutBits(nbit, n); - i = 0; - while (i < n) { - k = mPTLen[i++]; - if (k <= 6) { - PutBits(3, k); - } - else { - PutBits(k - 3, (1U << (k - 3)) - 2); - } - if (i == Special) { - while (i < 6 && mPTLen[i] == 0) { - i++; - } - PutBits(2, (i - 3) & 3); - } - } + while (n > 0 && mPTLen[n - 1] == 0) { + n--; + } + PutBits(nbit, n); + i = 0; + while (i < n) { + k = mPTLen[i++]; + if (k <= 6) { + PutBits(3, k); + } else { + PutBits(k - 3, (1U << (k - 3)) - 2); + } + if (i == Special) { + while (i < 6 && mPTLen[i] == 0) { + i++; + } + PutBits(2, (i - 3) & 3); + } + } } -STATIC -VOID -WriteCLen() +STATIC +VOID +WriteCLen () /*++ Routine Description: Outputs the code length array for Char&Length Set - + Arguments: (VOID) Returns: (VOID) --*/ { - INT32 i, k, n, Count; + INT32 i, k, n, Count; - n = NC; - while (n > 0 && mCLen[n - 1] == 0) { - n--; - } - PutBits(CBIT, n); - i = 0; - while (i < n) { - k = mCLen[i++]; - if (k == 0) { - Count = 1; - while (i < n && mCLen[i] == 0) { - i++; - Count++; - } - if (Count <= 2) { - for (k = 0; k < Count; k++) { - PutBits(mPTLen[0], mPTCode[0]); - } - } - else if (Count <= 18) { - PutBits(mPTLen[1], mPTCode[1]); - PutBits(4, Count - 3); - } - else if (Count == 19) { - PutBits(mPTLen[0], mPTCode[0]); - PutBits(mPTLen[1], mPTCode[1]); - PutBits(4, 15); - } - else { - PutBits(mPTLen[2], mPTCode[2]); - PutBits(CBIT, Count - 20); - } - } - else { - PutBits(mPTLen[k + 2], mPTCode[k + 2]); - } - } + n = NC; + while (n > 0 && mCLen[n - 1] == 0) { + n--; + } + PutBits(CBIT, n); + i = 0; + while (i < n) { + k = mCLen[i++]; + if (k == 0) { + Count = 1; + while (i < n && mCLen[i] == 0) { + i++; + Count++; + } + if (Count <= 2) { + for (k = 0; k < Count; k++) { + PutBits(mPTLen[0], mPTCode[0]); + } + } else if (Count <= 18) { + PutBits(mPTLen[1], mPTCode[1]); + PutBits(4, Count - 3); + } else if (Count == 19) { + PutBits(mPTLen[0], mPTCode[0]); + PutBits(mPTLen[1], mPTCode[1]); + PutBits(4, 15); + } else { + PutBits(mPTLen[2], mPTCode[2]); + PutBits(CBIT, Count - 20); + } + } else { + PutBits(mPTLen[k + 2], mPTCode[k + 2]); + } + } } -STATIC -VOID -EncodeC( - IN INT32 c -) +STATIC +VOID +EncodeC ( + IN INT32 c + ) { - PutBits(mCLen[c], mCCode[c]); + PutBits(mCLen[c], mCCode[c]); } -STATIC -VOID -EncodeP( - IN UINT32 p -) +STATIC +VOID +EncodeP ( + IN UINT32 p + ) { - UINT32 c, q; + UINT32 c, q; - c = 0; - q = p; - while (q) { - q >>= 1; - c++; - } - PutBits(mPTLen[c], mPTCode[c]); - if (c > 1) { - PutBits(c - 1, p & (0xFFFFU >> (17 - c))); - } + c = 0; + q = p; + while (q) { + q >>= 1; + c++; + } + PutBits(mPTLen[c], mPTCode[c]); + if (c > 1) { + PutBits(c - 1, p & (0xFFFFU >> (17 - c))); + } } -STATIC -VOID -SendBlock() +STATIC +VOID +SendBlock () /*++ Routine Description: Huffman code the block and output it. - + Argument: (VOID) Returns: (VOID) --*/ { - UINT32 i, k, Flags, Root, Pos, Size; - Flags = 0; + UINT32 i, k, Flags, Root, Pos, Size; + Flags = 0; - Root = MakeTree(NC, mCFreq, mCLen, mCCode); - Size = mCFreq[Root]; - PutBits(16, Size); - if (Root >= NC) { - CountTFreq(); - Root = MakeTree(NT, mTFreq, mPTLen, mPTCode); - if (Root >= NT) { - WritePTLen(NT, TBIT, 3); - } - else { - PutBits(TBIT, 0); - PutBits(TBIT, Root); - } - WriteCLen(); - } - else { - PutBits(TBIT, 0); - PutBits(TBIT, 0); - PutBits(CBIT, 0); - PutBits(CBIT, Root); - } - Root = MakeTree(NP, mPFreq, mPTLen, mPTCode); - if (Root >= NP) { - WritePTLen(NP, gPBIT, -1); - } - else { - PutBits(gPBIT, 0); - PutBits(gPBIT, Root); - } - Pos = 0; - for (i = 0; i < Size; i++) { - if (i % UINT8_BIT == 0) { - Flags = mBuf[Pos++]; - } - else { - Flags <<= 1; - } - if (Flags & (1U << (UINT8_BIT - 1))) { - EncodeC(mBuf[Pos++] + (1U << UINT8_BIT)); - k = mBuf[Pos++] << UINT8_BIT; - k += mBuf[Pos++]; - EncodeP(k); - } - else { - EncodeC(mBuf[Pos++]); - } - } - for (i = 0; i < NC; i++) { - mCFreq[i] = 0; - } - for (i = 0; i < NP; i++) { - mPFreq[i] = 0; - } + Root = MakeTree(NC, mCFreq, mCLen, mCCode); + Size = mCFreq[Root]; + PutBits(16, Size); + if (Root >= NC) { + CountTFreq(); + Root = MakeTree(NT, mTFreq, mPTLen, mPTCode); + if (Root >= NT) { + WritePTLen(NT, TBIT, 3); + } else { + PutBits(TBIT, 0); + PutBits(TBIT, Root); + } + WriteCLen(); + } else { + PutBits(TBIT, 0); + PutBits(TBIT, 0); + PutBits(CBIT, 0); + PutBits(CBIT, Root); + } + Root = MakeTree(NP, mPFreq, mPTLen, mPTCode); + if (Root >= NP) { + WritePTLen(NP, gPBIT, -1); + } else { + PutBits(gPBIT, 0); + PutBits(gPBIT, Root); + } + Pos = 0; + for (i = 0; i < Size; i++) { + if (i % UINT8_BIT == 0) { + Flags = mBuf[Pos++]; + } else { + Flags <<= 1; + } + if (Flags & (1U << (UINT8_BIT - 1))) { + EncodeC(mBuf[Pos++] + (1U << UINT8_BIT)); + k = mBuf[Pos++] << UINT8_BIT; + k += mBuf[Pos++]; + EncodeP(k); + } else { + EncodeC(mBuf[Pos++]); + } + } + for (i = 0; i < NC; i++) { + mCFreq[i] = 0; + } + for (i = 0; i < NP; i++) { + mPFreq[i] = 0; + } } -STATIC -VOID -Output( - IN UINT32 c, - IN UINT32 p -) +STATIC +VOID +Output ( + IN UINT32 c, + IN UINT32 p + ) /*++ Routine Description: @@ -1290,90 +1276,89 @@ Returns: (VOID) --*/ { - STATIC UINT32 CPos; + STATIC UINT32 CPos; - if ((mOutputMask >>= 1) == 0) { - mOutputMask = 1U << (UINT8_BIT - 1); - if (mOutputPos >= mBufSiz - 3 * UINT8_BIT) { - SendBlock(); - mOutputPos = 0; - } - CPos = mOutputPos++; - mBuf[CPos] = 0; - } - mBuf[mOutputPos++] = (UINT8)c; - mCFreq[c]++; - if (c >= (1U << UINT8_BIT)) { - mBuf[CPos] |= mOutputMask; - mBuf[mOutputPos++] = (UINT8)(p >> UINT8_BIT); - mBuf[mOutputPos++] = (UINT8)p; - c = 0; - while (p) { - p >>= 1; - c++; - } - mPFreq[c]++; - } + if ((mOutputMask >>= 1) == 0) { + mOutputMask = 1U << (UINT8_BIT - 1); + if (mOutputPos >= mBufSiz - 3 * UINT8_BIT) { + SendBlock(); + mOutputPos = 0; + } + CPos = mOutputPos++; + mBuf[CPos] = 0; + } + mBuf[mOutputPos++] = (UINT8) c; + mCFreq[c]++; + if (c >= (1U << UINT8_BIT)) { + mBuf[CPos] |= mOutputMask; + mBuf[mOutputPos++] = (UINT8)(p >> UINT8_BIT); + mBuf[mOutputPos++] = (UINT8) p; + c = 0; + while (p) { + p >>= 1; + c++; + } + mPFreq[c]++; + } } STATIC VOID -HufEncodeStart() +HufEncodeStart () { - INT32 i; + INT32 i; - for (i = 0; i < NC; i++) { - mCFreq[i] = 0; - } - for (i = 0; i < NP; i++) { - mPFreq[i] = 0; - } - mOutputPos = mOutputMask = 0; - InitPutBits(); - return; + for (i = 0; i < NC; i++) { + mCFreq[i] = 0; + } + for (i = 0; i < NP; i++) { + mPFreq[i] = 0; + } + mOutputPos = mOutputMask = 0; + InitPutBits(); + return; } -STATIC -VOID -HufEncodeEnd() +STATIC +VOID +HufEncodeEnd () { - SendBlock(); - - // - // Flush remaining bits - // - PutBits(UINT8_BIT - 1, 0); - - return; + SendBlock(); + + // + // Flush remaining bits + // + PutBits(UINT8_BIT - 1, 0); + + return; } -STATIC -VOID -MakeCrcTable() +STATIC +VOID +MakeCrcTable () { - UINT32 i, j, r; + UINT32 i, j, r; - for (i = 0; i <= UINT8_MAX; i++) { - r = i; - for (j = 0; j < UINT8_BIT; j++) { - if (r & 1) { - r = (r >> 1) ^ CRCPOLY; - } - else { - r >>= 1; - } - } - mCrcTable[i] = (UINT16)r; - } + for (i = 0; i <= UINT8_MAX; i++) { + r = i; + for (j = 0; j < UINT8_BIT; j++) { + if (r & 1) { + r = (r >> 1) ^ CRCPOLY; + } else { + r >>= 1; + } + } + mCrcTable[i] = (UINT16)r; + } } -STATIC -VOID -PutBits( - IN INT32 n, - IN UINT32 x -) +STATIC +VOID +PutBits ( + IN INT32 n, + IN UINT32 x + ) /*++ Routine Description: @@ -1383,53 +1368,51 @@ Routine Description: Argments: n - the rightmost n bits of the data is used - x - the data + x - the data Returns: (VOID) --*/ { - UINT8 Temp; + UINT8 Temp; + + if (n < mBitCount) { + mSubBitBuf |= x << (mBitCount -= n); + } else { + + Temp = (UINT8)(mSubBitBuf | (x >> (n -= mBitCount))); + if (mDst < mDstUpperLimit) { + *mDst++ = Temp; + } + mCompSize++; - if (n < mBitCount) { - mSubBitBuf |= x << (mBitCount -= n); - } - else { - - Temp = (UINT8)(mSubBitBuf | (x >> (n -= mBitCount))); - if (mDst < mDstUpperLimit) { - *mDst++ = Temp; - } - mCompSize++; - - if (n < UINT8_BIT) { - mSubBitBuf = x << (mBitCount = UINT8_BIT - n); - } - else { - - Temp = (UINT8)(x >> (n - UINT8_BIT)); - if (mDst < mDstUpperLimit) { - *mDst++ = Temp; - } - mCompSize++; - - mSubBitBuf = x << (mBitCount = 2 * UINT8_BIT - n); - } - } + if (n < UINT8_BIT) { + mSubBitBuf = x << (mBitCount = UINT8_BIT - n); + } else { + + Temp = (UINT8)(x >> (n - UINT8_BIT)); + if (mDst < mDstUpperLimit) { + *mDst++ = Temp; + } + mCompSize++; + + mSubBitBuf = x << (mBitCount = 2 * UINT8_BIT - n); + } + } } -STATIC -INT32 -FreadCrc( - OUT UINT8 *p, - IN INT32 n -) +STATIC +INT32 +FreadCrc ( + OUT UINT8 *p, + IN INT32 n + ) /*++ Routine Description: Read in source data - + Arguments: p - the buffer to hold the data @@ -1438,157 +1421,156 @@ Arguments: Returns: number of bytes actually read - + --*/ { - INT32 i; + INT32 i; - for (i = 0; mSrc < mSrcUpperLimit && i < n; i++) { - *p++ = *mSrc++; - } - n = i; + for (i = 0; mSrc < mSrcUpperLimit && i < n; i++) { + *p++ = *mSrc++; + } + n = i; - p -= n; - mOrigSize += n; - while (--i >= 0) { - UPDATE_CRC(*p++); - } - return n; + p -= n; + mOrigSize += n; + while (--i >= 0) { + UPDATE_CRC(*p++); + } + return n; } -STATIC -VOID -InitPutBits() +STATIC +VOID +InitPutBits () { - mBitCount = UINT8_BIT; - mSubBitBuf = 0; + mBitCount = UINT8_BIT; + mSubBitBuf = 0; } -STATIC -VOID -CountLen( - IN INT32 i -) +STATIC +VOID +CountLen ( + IN INT32 i + ) /*++ Routine Description: Count the number of each code length for a Huffman tree. - + Arguments: i - the top node - + Returns: (VOID) --*/ { - STATIC INT32 Depth = 0; + STATIC INT32 Depth = 0; - if (i < mN) { - mLenCnt[(Depth < 16) ? Depth : 16]++; - } - else { - Depth++; - CountLen(mLeft[i]); - CountLen(mRight[i]); - Depth--; - } + if (i < mN) { + mLenCnt[(Depth < 16) ? Depth : 16]++; + } else { + Depth++; + CountLen(mLeft [i]); + CountLen(mRight[i]); + Depth--; + } } -STATIC -VOID -MakeLen( - IN INT32 Root -) +STATIC +VOID +MakeLen ( + IN INT32 Root + ) /*++ Routine Description: Create code length array for a Huffman tree - + Arguments: Root - the root of the tree --*/ { - INT32 i, k; - UINT32 Cum; + INT32 i, k; + UINT32 Cum; - for (i = 0; i <= 16; i++) { - mLenCnt[i] = 0; - } - CountLen(Root); - - // - // Adjust the length count array so that - // no code will be generated longer than its designated length - // - - Cum = 0; - for (i = 16; i > 0; i--) { - Cum += mLenCnt[i] << (16 - i); - } - while (Cum != (1U << 16)) { - mLenCnt[16]--; - for (i = 15; i > 0; i--) { - if (mLenCnt[i] != 0) { - mLenCnt[i]--; - mLenCnt[i + 1] += 2; - break; - } - } - Cum--; - } - for (i = 16; i > 0; i--) { - k = mLenCnt[i]; - while (--k >= 0) { - mLen[*mSortPtr++] = (UINT8)i; - } - } + for (i = 0; i <= 16; i++) { + mLenCnt[i] = 0; + } + CountLen(Root); + + // + // Adjust the length count array so that + // no code will be generated longer than its designated length + // + + Cum = 0; + for (i = 16; i > 0; i--) { + Cum += mLenCnt[i] << (16 - i); + } + while (Cum != (1U << 16)) { + mLenCnt[16]--; + for (i = 15; i > 0; i--) { + if (mLenCnt[i] != 0) { + mLenCnt[i]--; + mLenCnt[i+1] += 2; + break; + } + } + Cum--; + } + for (i = 16; i > 0; i--) { + k = mLenCnt[i]; + while (--k >= 0) { + mLen[*mSortPtr++] = (UINT8)i; + } + } } -STATIC -VOID -DownHeap( - IN INT32 i -) +STATIC +VOID +DownHeap ( + IN INT32 i + ) { - INT32 j, k; + INT32 j, k; - // - // priority queue: send i-th entry down heap - // - - k = mHeap[i]; - while ((j = 2 * i) <= mHeapSize) { - if (j < mHeapSize && mFreq[mHeap[j]] > mFreq[mHeap[j + 1]]) { - j++; - } - if (mFreq[k] <= mFreq[mHeap[j]]) { - break; - } - mHeap[i] = mHeap[j]; - i = j; - } - mHeap[i] = (INT16)k; + // + // priority queue: send i-th entry down heap + // + + k = mHeap[i]; + while ((j = 2 * i) <= mHeapSize) { + if (j < mHeapSize && mFreq[mHeap[j]] > mFreq[mHeap[j + 1]]) { + j++; + } + if (mFreq[k] <= mFreq[mHeap[j]]) { + break; + } + mHeap[i] = mHeap[j]; + i = j; + } + mHeap[i] = (INT16)k; } -STATIC -VOID -MakeCode( - IN INT32 n, - IN UINT8 Len[], - OUT UINT16 Code[] -) +STATIC +VOID +MakeCode ( + IN INT32 n, + IN UINT8 Len[], + OUT UINT16 Code[] + ) /*++ Routine Description: Assign code to each symbol based on the code length array - + Arguments: n - number of symbols @@ -1599,101 +1581,101 @@ Returns: (VOID) --*/ { - INT32 i; - UINT16 Start[18]; + INT32 i; + UINT16 Start[18]; - Start[1] = 0; - for (i = 1; i <= 16; i++) { - Start[i + 1] = (UINT16)((Start[i] + mLenCnt[i]) << 1); - } - for (i = 0; i < n; i++) { - Code[i] = Start[Len[i]]++; - } + Start[1] = 0; + for (i = 1; i <= 16; i++) { + Start[i + 1] = (UINT16)((Start[i] + mLenCnt[i]) << 1); + } + for (i = 0; i < n; i++) { + Code[i] = Start[Len[i]]++; + } } -STATIC -INT32 -MakeTree( - IN INT32 NParm, - IN UINT16 FreqParm[], - OUT UINT8 LenParm[], - OUT UINT16 CodeParm[] -) +STATIC +INT32 +MakeTree ( + IN INT32 NParm, + IN UINT16 FreqParm[], + OUT UINT8 LenParm[], + OUT UINT16 CodeParm[] + ) /*++ Routine Description: Generates Huffman codes given a frequency distribution of symbols - + Arguments: NParm - number of symbols FreqParm - frequency of each symbol LenParm - code length for each symbol CodeParm - code for each symbol - + Returns: Root of the Huffman tree. - + --*/ { - INT32 i, j, k, Avail; + INT32 i, j, k, Avail; + + // + // make tree, calculate len[], return root + // - // - // make tree, calculate len[], return root - // - - mN = NParm; - mFreq = FreqParm; - mLen = LenParm; - Avail = mN; - mHeapSize = 0; - mHeap[1] = 0; - for (i = 0; i < mN; i++) { - mLen[i] = 0; - if (mFreq[i]) { - mHeap[++mHeapSize] = (INT16)i; - } - } - if (mHeapSize < 2) { - CodeParm[mHeap[1]] = 0; - return mHeap[1]; - } - for (i = mHeapSize / 2; i >= 1; i--) { - - // - // make priority queue - // - DownHeap(i); - } - mSortPtr = CodeParm; - do { - i = mHeap[1]; - if (i < mN) { - *mSortPtr++ = (UINT16)i; - } - mHeap[1] = mHeap[mHeapSize--]; - DownHeap(1); - j = mHeap[1]; - if (j < mN) { - *mSortPtr++ = (UINT16)j; - } - k = Avail++; - mFreq[k] = (UINT16)(mFreq[i] + mFreq[j]); - mHeap[1] = (INT16)k; - DownHeap(1); - mLeft[k] = (UINT16)i; - mRight[k] = (UINT16)j; - } while (mHeapSize > 1); - - mSortPtr = CodeParm; - MakeLen(k); - MakeCode(NParm, LenParm, CodeParm); - - // - // return root - // - return k; + mN = NParm; + mFreq = FreqParm; + mLen = LenParm; + Avail = mN; + mHeapSize = 0; + mHeap[1] = 0; + for (i = 0; i < mN; i++) { + mLen[i] = 0; + if (mFreq[i]) { + mHeap[++mHeapSize] = (INT16)i; + } + } + if (mHeapSize < 2) { + CodeParm[mHeap[1]] = 0; + return mHeap[1]; + } + for (i = mHeapSize / 2; i >= 1; i--) { + + // + // make priority queue + // + DownHeap(i); + } + mSortPtr = CodeParm; + do { + i = mHeap[1]; + if (i < mN) { + *mSortPtr++ = (UINT16)i; + } + mHeap[1] = mHeap[mHeapSize--]; + DownHeap(1); + j = mHeap[1]; + if (j < mN) { + *mSortPtr++ = (UINT16)j; + } + k = Avail++; + mFreq[k] = (UINT16)(mFreq[i] + mFreq[j]); + mHeap[1] = (INT16)k; + DownHeap(1); + mLeft[k] = (UINT16)i; + mRight[k] = (UINT16)j; + } while (mHeapSize > 1); + + mSortPtr = CodeParm; + MakeLen(k); + MakeCode(NParm, LenParm, CodeParm); + + // + // return root + // + return k; } diff --git a/Tiano/EfiTianoCompress.h b/Tiano/EfiTianoCompress.h index b317cfd..9dc042e 100644 --- a/Tiano/EfiTianoCompress.h +++ b/Tiano/EfiTianoCompress.h @@ -20,8 +20,8 @@ Header file for compression routine. */ -#ifndef _EFITIANOCOMPRESS_H_ -#define _EFITIANOCOMPRESS_H_ +#ifndef EFITIANOCOMPRESS_H +#define EFITIANOCOMPRESS_H #include #include @@ -32,84 +32,87 @@ Header file for compression routine. extern "C" { #endif - /*++ + /*++ - Routine Description: + Routine Description: - Tiano compression routine. + Tiano compression routine. - Arguments: + Arguments: - SrcBuffer - The buffer storing the source data - SrcSize - The size of source data - DstBuffer - The buffer to store the compressed data - DstSize - On input, the size of DstBuffer; On output, - the size of the actual compressed data. + SrcBuffer - The buffer storing the source data + SrcSize - The size of source data + DstBuffer - The buffer to store the compressed data + DstSize - On input, the size of DstBuffer; On output, + the size of the actual compressed data. - Returns: + Returns: - EFI_BUFFER_TOO_SMALL - The DstBuffer is too small. this case, - DstSize contains the size needed. - EFI_SUCCESS - Compression is successful. - EFI_OUT_OF_RESOURCES - No resource to complete function. - EFI_INVALID_PARAMETER - Parameter supplied is wrong. + EFI_BUFFER_TOO_SMALL - The DstBuffer is too small. this case, + DstSize contains the size needed. + EFI_SUCCESS - Compression is successful. + EFI_OUT_OF_RESOURCES - No resource to complete function. + EFI_INVALID_PARAMETER - Parameter supplied is wrong. - --*/ - EFI_STATUS - TianoCompress( - IN CONST VOID *SrcBuffer, - IN UINT32 SrcSize, - IN VOID *DstBuffer, - IN OUT UINT32 *DstSize - ); + --*/ + EFI_STATUS + TianoCompress( + CONST VOID *SrcBuffer, + UINT32 SrcSize, + VOID *DstBuffer, + UINT32 *DstSize + ) + ; - EFI_STATUS - TianoCompressLegacy( - CONST VOID *SrcBuffer, - UINT32 SrcSize, - VOID *DstBuffer, - UINT32 *DstSize - ); - /*++ + EFI_STATUS + TianoCompressLegacy( + CONST VOID *SrcBuffer, + UINT32 SrcSize, + VOID *DstBuffer, + UINT32 *DstSize + ) + ; + /*++ - Routine Description: + Routine Description: - EFI 1.1 compression routine. + EFI 1.1 compression routine. - Arguments: + Arguments: - SrcBuffer - The buffer storing the source data - SrcSize - The size of source data - DstBuffer - The buffer to store the compressed data - DstSize - On input, the size of DstBuffer; On output, - the size of the actual compressed data. + SrcBuffer - The buffer storing the source data + SrcSize - The size of source data + DstBuffer - The buffer to store the compressed data + DstSize - On input, the size of DstBuffer; On output, + the size of the actual compressed data. - Returns: + Returns: - EFI_BUFFER_TOO_SMALL - The DstBuffer is too small. this case, - DstSize contains the size needed. - EFI_SUCCESS - Compression is successful. - EFI_OUT_OF_RESOURCES - No resource to complete function. - EFI_INVALID_PARAMETER - Parameter supplied is wrong. + EFI_BUFFER_TOO_SMALL - The DstBuffer is too small. this case, + DstSize contains the size needed. + EFI_SUCCESS - Compression is successful. + EFI_OUT_OF_RESOURCES - No resource to complete function. + EFI_INVALID_PARAMETER - Parameter supplied is wrong. - --*/ - EFI_STATUS - EfiCompress( - IN CONST VOID *SrcBuffer, - IN UINT32 SrcSize, - IN VOID *DstBuffer, - IN OUT UINT32 *DstSize - ); - - EFI_STATUS - EfiCompressLegacy( - CONST VOID *SrcBuffer, - UINT32 SrcSize, - VOID *DstBuffer, - UINT32 *DstSize - ); + --*/ + EFI_STATUS + EfiCompress( + CONST VOID *SrcBuffer, + UINT32 SrcSize, + VOID *DstBuffer, + UINT32 *DstSize + ) + ; + EFI_STATUS + EfiCompressLegacy( + CONST VOID *SrcBuffer, + UINT32 SrcSize, + VOID *DstBuffer, + UINT32 *DstSize + ) + ; #ifdef __cplusplus } #endif -#endif +#endif // EFITIANOCOMPRESS_H diff --git a/Tiano/EfiTianoCompressLegacy.c b/Tiano/EfiTianoCompressLegacy.c index 9aed6f1..11e071c 100644 --- a/Tiano/EfiTianoCompressLegacy.c +++ b/Tiano/EfiTianoCompressLegacy.c @@ -71,190 +71,190 @@ typedef INT32 NODE; // STATIC -VOID -PutDword( - UINT32 Data + VOID + PutDword( + UINT32 Data + ); + +STATIC + INT32 + AllocateMemory ( + VOID + ); + +STATIC + VOID + FreeMemory ( + VOID + ); + +STATIC + VOID + InitSlide ( + VOID + ); + +STATIC + NODE + Child ( + NODE NodeQ, + UINT8 CharC + ); + +STATIC + VOID + MakeChild ( + NODE NodeQ, + UINT8 CharC, + NODE NodeR + ); + +STATIC + VOID + Split ( + NODE Old + ); + +STATIC + VOID + InsertNode ( + VOID + ); + +STATIC + VOID + DeleteNode ( + VOID + ); + +STATIC + VOID + GetNextMatch ( + VOID + ); + +STATIC + INT32 + Encode ( + VOID + ); + +STATIC + VOID + CountTFreq ( + VOID + ); + +STATIC + VOID + WritePTLen ( + INT32 Number, + INT32 nbit, + INT32 Special + ); + +STATIC + VOID + WriteCLen ( + VOID + ); + +STATIC + VOID + EncodeC ( + INT32 Value + ); + +STATIC + VOID + EncodeP ( + UINT32 Value + ); + +STATIC + VOID + SendBlock ( + VOID + ); + +STATIC + VOID + Output ( + UINT32 c, + UINT32 p + ); + +STATIC + VOID + HufEncodeStart ( + VOID + ); + +STATIC + VOID + HufEncodeEnd ( + VOID + ); + +STATIC + VOID + MakeCrcTable ( + VOID + ); + +STATIC + VOID + PutBits ( + INT32 Number, + UINT32 Value + ); + +STATIC + INT32 + FreadCrc ( + UINT8 *Pointer, + INT32 Number + ); + +STATIC + VOID + InitPutBits ( + VOID + ); + +STATIC + VOID + CountLen ( + INT32 Index + ); + +STATIC + VOID + MakeLen ( + INT32 Root + ); + +STATIC + VOID + DownHeap ( + INT32 Index + ); + +STATIC + VOID + MakeCode ( + INT32 Number, + UINT8 Len[ ], + UINT16 Code[] ); STATIC -INT32 -AllocateMemory( - VOID -); - -STATIC -VOID -FreeMemory( - VOID -); - -STATIC -VOID -InitSlide( - VOID -); - -STATIC -NODE -Child( - NODE NodeQ, - UINT8 CharC -); - -STATIC -VOID -MakeChild( - NODE NodeQ, - UINT8 CharC, - NODE NodeR -); - -STATIC -VOID -Split( - NODE Old -); - -STATIC -VOID -InsertNode( - VOID -); - -STATIC -VOID -DeleteNode( - VOID -); - -STATIC -VOID -GetNextMatch( - VOID -); - -STATIC -INT32 -Encode( - VOID -); - -STATIC -VOID -CountTFreq( - VOID -); - -STATIC -VOID -WritePTLen( - INT32 Number, - INT32 nbit, - INT32 Special -); - -STATIC -VOID -WriteCLen( - VOID -); - -STATIC -VOID -EncodeC( - INT32 Value -); - -STATIC -VOID -EncodeP( - UINT32 Value -); - -STATIC -VOID -SendBlock( - VOID -); - -STATIC -VOID -Output( - UINT32 c, - UINT32 p -); - -STATIC -VOID -HufEncodeStart( - VOID -); - -STATIC -VOID -HufEncodeEnd( - VOID -); - -STATIC -VOID -MakeCrcTable( - VOID -); - -STATIC -VOID -PutBits( - INT32 Number, - UINT32 Value -); - -STATIC -INT32 -FreadCrc( - UINT8 *Pointer, - INT32 Number -); - -STATIC -VOID -InitPutBits( - VOID -); - -STATIC -VOID -CountLen( - INT32 Index -); - -STATIC -VOID -MakeLen( - INT32 Root -); - -STATIC -VOID -DownHeap( - INT32 Index -); - -STATIC -VOID -MakeCode( - INT32 Number, - UINT8 Len[], - UINT16 Code[] -); - -STATIC -INT32 -MakeTree( - INT32 NParm, - UINT16 FreqParm[], - UINT8 LenParm[], - UINT16 CodeParm[] + INT32 + MakeTree ( + INT32 NParm, + UINT16 FreqParm[], + UINT8 LenParm[ ], + UINT16 CodeParm[] ); // @@ -269,7 +269,7 @@ STATIC UINT32 mBufSiz = 0, mOutputPos, mOutputMask, mSubBitBuf, mCrc; STATIC UINT32 mCompSize, mOrigSize; STATIC UINT16 *mFreq, *mSortPtr, mLenCnt[17], mLeft[2 * NC - 1], mRight[2 * NC - 1], mCrcTable[UINT8_MAX + 1], -mCFreq[2 * NC - 1], mCCode[NC], mPFreq[2 * NP - 1], mPTCode[NPT], mTFreq[2 * NT - 1]; + mCFreq[2 * NC - 1], mCCode[NC], mPFreq[2 * NP - 1], mPTCode[NPT], mTFreq[2 * NT - 1]; STATIC UINT8 mPbit; @@ -280,10 +280,10 @@ STATIC NODE mPos, mMatchPos, mAvail, *mPosition, *mParent, *mPrev, *mNext = NU // EFI_STATUS EfiCompressLegacy( - CONST VOID *SrcBuffer, - UINT32 SrcSize, - VOID *DstBuffer, - UINT32 *DstSize +CONST VOID *SrcBuffer, +UINT32 SrcSize, +VOID *DstBuffer, +UINT32 *DstSize ) /*++ @@ -309,1573 +309,1557 @@ EFI_INVALID_PARAMETER - Parameter supplied is wrong. --*/ { - INT32 Status; + INT32 Status; - // - // Initializations - // - mPbit = 4; + // + // Initializations + // + mPbit = 4; - mBufSiz = 0; - mBuf = NULL; - mText = NULL; - mLevel = NULL; - mChildCount = NULL; - mPosition = NULL; - mParent = NULL; - mPrev = NULL; - mNext = NULL; + mBufSiz = 0; + mBuf = NULL; + mText = NULL; + mLevel = NULL; + mChildCount = NULL; + mPosition = NULL; + mParent = NULL; + mPrev = NULL; + mNext = NULL; - mSrc = (UINT8*)SrcBuffer; - mSrcUpperLimit = mSrc + SrcSize; - mDst = DstBuffer; - mDstUpperLimit = mDst + *DstSize; + mSrc = (UINT8*) SrcBuffer; + mSrcUpperLimit = mSrc + SrcSize; + mDst = DstBuffer; + mDstUpperLimit = mDst + *DstSize; - PutDword(0L); - PutDword(0L); + PutDword(0L); + PutDword(0L); - MakeCrcTable(); + MakeCrcTable(); - mOrigSize = mCompSize = 0; - mCrc = INIT_CRC; + mOrigSize = mCompSize = 0; + mCrc = INIT_CRC; - // - // Compress it - // - Status = Encode(); - if (Status) { - return EFI_OUT_OF_RESOURCES; - } - // - // Null terminate the compressed data - // - if (mDst < mDstUpperLimit) { - *mDst++ = 0; - } - // - // Fill compressed size and original size - // - mDst = DstBuffer; - PutDword(mCompSize + 1); - PutDword(mOrigSize); + // + // Compress it + // + Status = Encode(); + if (Status) { + return EFI_OUT_OF_RESOURCES; + } + // + // Null terminate the compressed data + // + if (mDst < mDstUpperLimit) { + *mDst++ = 0; + } + // + // Fill compressed size and original size + // + mDst = DstBuffer; + PutDword(mCompSize + 1); + PutDword(mOrigSize); - // - // Return - // - if (mCompSize + 1 + 8 > *DstSize) { - *DstSize = mCompSize + 1 + 8; - return EFI_BUFFER_TOO_SMALL; - } - else { - *DstSize = mCompSize + 1 + 8; - return EFI_SUCCESS; - } + // + // Return + // + if (mCompSize + 1 + 8 > *DstSize) { + *DstSize = mCompSize + 1 + 8; + return EFI_BUFFER_TOO_SMALL; + } + else { + *DstSize = mCompSize + 1 + 8; + return EFI_SUCCESS; + } } EFI_STATUS -TianoCompressLegacy( - CONST VOID *SrcBuffer, - UINT32 SrcSize, - VOID *DstBuffer, - UINT32 *DstSize +TianoCompressLegacy ( +CONST VOID *SrcBuffer, +UINT32 SrcSize, +VOID *DstBuffer, +UINT32 *DstSize ) -/*++ + /*++ -Routine Description: + Routine Description: -The internal implementation of [Efi/Tiano]Compress(). + The internal implementation of [Efi/Tiano]Compress(). -Arguments: + Arguments: -SrcBuffer - The buffer storing the source data -SrcSize - The size of source data -DstBuffer - The buffer to store the compressed data -DstSize - On input, the size of DstBuffer; On output, -the size of the actual compressed data. -Version - The version of de/compression algorithm. -Version 1 for UEFI 2.0 de/compression algorithm. -Version 2 for Tiano de/compression algorithm. + SrcBuffer - The buffer storing the source data + SrcSize - The size of source data + DstBuffer - The buffer to store the compressed data + DstSize - On input, the size of DstBuffer; On output, + the size of the actual compressed data. + Version - The version of de/compression algorithm. + Version 1 for UEFI 2.0 de/compression algorithm. + Version 2 for Tiano de/compression algorithm. -Returns: + Returns: -EFI_BUFFER_TOO_SMALL - The DstBuffer is too small. this case, -DstSize contains the size needed. -EFI_SUCCESS - Compression is successful. -EFI_OUT_OF_RESOURCES - No resource to complete function. -EFI_INVALID_PARAMETER - Parameter supplied is wrong. + EFI_BUFFER_TOO_SMALL - The DstBuffer is too small. this case, + DstSize contains the size needed. + EFI_SUCCESS - Compression is successful. + EFI_OUT_OF_RESOURCES - No resource to complete function. + EFI_INVALID_PARAMETER - Parameter supplied is wrong. ---*/ + --*/ { - INT32 Status; + INT32 Status; - // - // Initializations - // - mPbit = 5; + // + // Initializations + // + mPbit = 5; - mBufSiz = 0; - mBuf = NULL; - mText = NULL; - mLevel = NULL; - mChildCount = NULL; - mPosition = NULL; - mParent = NULL; - mPrev = NULL; - mNext = NULL; + mBufSiz = 0; + mBuf = NULL; + mText = NULL; + mLevel = NULL; + mChildCount = NULL; + mPosition = NULL; + mParent = NULL; + mPrev = NULL; + mNext = NULL; - mSrc = (UINT8*)SrcBuffer; - mSrcUpperLimit = mSrc + SrcSize; - mDst = DstBuffer; - mDstUpperLimit = mDst + *DstSize; + mSrc = (UINT8*) SrcBuffer; + mSrcUpperLimit = mSrc + SrcSize; + mDst = DstBuffer; + mDstUpperLimit = mDst +*DstSize; - PutDword(0L); - PutDword(0L); + PutDword (0L); + PutDword (0L); - MakeCrcTable(); + MakeCrcTable (); - mOrigSize = mCompSize = 0; - mCrc = INIT_CRC; + mOrigSize = mCompSize = 0; + mCrc = INIT_CRC; - // - // Compress it - // - Status = Encode(); - if (Status) { - return EFI_OUT_OF_RESOURCES; - } - // - // Null terminate the compressed data - // - if (mDst < mDstUpperLimit) { - *mDst++ = 0; - } - // - // Fill compressed size and original size - // - mDst = DstBuffer; - PutDword(mCompSize + 1); - PutDword(mOrigSize); + // + // Compress it + // + Status = Encode (); + if (Status) { + return EFI_OUT_OF_RESOURCES; + } + // + // Null terminate the compressed data + // + if (mDst < mDstUpperLimit) { + *mDst++ = 0; + } + // + // Fill compressed size and original size + // + mDst = DstBuffer; + PutDword (mCompSize + 1); + PutDword (mOrigSize); - // - // Return - // - if (mCompSize + 1 + 8 > *DstSize) { - *DstSize = mCompSize + 1 + 8; - return EFI_BUFFER_TOO_SMALL; - } - else { - *DstSize = mCompSize + 1 + 8; - return EFI_SUCCESS; - } + // + // Return + // + if (mCompSize + 1 + 8 > *DstSize) { + *DstSize = mCompSize + 1 + 8; + return EFI_BUFFER_TOO_SMALL; + } else { + *DstSize = mCompSize + 1 + 8; + return EFI_SUCCESS; + } } STATIC -VOID -PutDword( - UINT32 Data -) -/*++ + VOID + PutDword ( + UINT32 Data + ) + /*++ -Routine Description: + Routine Description: -Put a DWORD to output stream + Put a DWORD to output stream -Arguments: + Arguments: -Data - the DWORD to put + Data - the DWORD to put -Returns: (VOID) + Returns: (VOID) ---*/ + --*/ { - if (mDst < mDstUpperLimit) { - *mDst++ = (UINT8)(((UINT8)(Data)) & 0xff); - } + if (mDst < mDstUpperLimit) { + *mDst++ = (UINT8) (((UINT8) (Data)) & 0xff); + } - if (mDst < mDstUpperLimit) { - *mDst++ = (UINT8)(((UINT8)(Data >> 0x08)) & 0xff); - } + if (mDst < mDstUpperLimit) { + *mDst++ = (UINT8) (((UINT8) (Data >> 0x08)) & 0xff); + } - if (mDst < mDstUpperLimit) { - *mDst++ = (UINT8)(((UINT8)(Data >> 0x10)) & 0xff); - } + if (mDst < mDstUpperLimit) { + *mDst++ = (UINT8) (((UINT8) (Data >> 0x10)) & 0xff); + } - if (mDst < mDstUpperLimit) { - *mDst++ = (UINT8)(((UINT8)(Data >> 0x18)) & 0xff); - } + if (mDst < mDstUpperLimit) { + *mDst++ = (UINT8) (((UINT8) (Data >> 0x18)) & 0xff); + } } STATIC -INT32 -AllocateMemory( - VOID -) -/*++ + INT32 + AllocateMemory ( + VOID + ) + /*++ -Routine Description: + Routine Description: -Allocate memory spaces for data structures used compression process + Allocate memory spaces for data structures used compression process -Arguments: -VOID + Arguments: + VOID -Returns: + Returns: -EFI_SUCCESS - Memory is allocated successfully -EFI_OUT_OF_RESOURCES - Allocation fails + EFI_SUCCESS - Memory is allocated successfully + EFI_OUT_OF_RESOURCES - Allocation fails ---*/ + --*/ { - UINT32 Index; + UINT32 Index; - mText = malloc(WNDSIZ * 2 + MAXMATCH); - if (NULL == mText) - return EFI_OUT_OF_RESOURCES; + mText = malloc (WNDSIZ * 2 + MAXMATCH); + if (!mText) return EFI_OUT_OF_RESOURCES; + for (Index = 0; Index < WNDSIZ * 2 + MAXMATCH; Index++) { + mText[Index] = 0; + } - for (Index = 0; Index < WNDSIZ * 2 + MAXMATCH; Index++) { - mText[Index] = 0; - } + mLevel = malloc ((WNDSIZ + UINT8_MAX + 1) * sizeof (*mLevel)); + if (!mLevel) return EFI_OUT_OF_RESOURCES; + mChildCount = malloc ((WNDSIZ + UINT8_MAX + 1) * sizeof (*mChildCount)); + if (!mChildCount) return EFI_OUT_OF_RESOURCES; + mPosition = malloc ((WNDSIZ + UINT8_MAX + 1) * sizeof (*mPosition)); + if (!mPosition) return EFI_OUT_OF_RESOURCES; + mParent = malloc (WNDSIZ * 2 * sizeof (*mParent)); + if (!mParent) return EFI_OUT_OF_RESOURCES; + mPrev = malloc (WNDSIZ * 2 * sizeof (*mPrev)); + if (!mPrev) return EFI_OUT_OF_RESOURCES; + mNext = malloc ((MAX_HASH_VAL + 1) * sizeof (*mNext)); + if (!mNext) return EFI_OUT_OF_RESOURCES; - mLevel = malloc((WNDSIZ + UINT8_MAX + 1) * sizeof(*mLevel)); - mChildCount = malloc((WNDSIZ + UINT8_MAX + 1) * sizeof(*mChildCount)); - mPosition = malloc((WNDSIZ + UINT8_MAX + 1) * sizeof(*mPosition)); - mParent = malloc(WNDSIZ * 2 * sizeof(*mParent)); - mPrev = malloc(WNDSIZ * 2 * sizeof(*mPrev)); - mNext = malloc((MAX_HASH_VAL + 1) * sizeof(*mNext)); + mBufSiz = BLKSIZ; + mBuf = malloc (mBufSiz); + while (mBuf == NULL) { + mBufSiz = (mBufSiz / 10U) * 9U; + if (mBufSiz < 4 * 1024U) { + return EFI_OUT_OF_RESOURCES; + } - mBufSiz = BLKSIZ; - mBuf = malloc(mBufSiz); - while (mBuf == NULL) { - mBufSiz = (mBufSiz / 10U) * 9U; - if (mBufSiz < 4 * 1024U) { - return EFI_OUT_OF_RESOURCES; - } + mBuf = malloc (mBufSiz); + } - mBuf = malloc(mBufSiz); - } + mBuf[0] = 0; - mBuf[0] = 0; - - return EFI_SUCCESS; + return EFI_SUCCESS; } VOID -FreeMemory( - VOID -) -/*++ + FreeMemory ( + VOID + ) + /*++ -Routine Description: + Routine Description: -Called when compression is completed to free memory previously allocated. + Called when compression is completed to free memory previously allocated. -Arguments: (VOID) + Arguments: (VOID) -Returns: (VOID) + Returns: (VOID) ---*/ + --*/ { - if (mText != NULL) { - free(mText); - } + if (mText != NULL) { + free (mText); + } - if (mLevel != NULL) { - free(mLevel); - } + if (mLevel != NULL) { + free (mLevel); + } - if (mChildCount != NULL) { - free(mChildCount); - } + if (mChildCount != NULL) { + free (mChildCount); + } - if (mPosition != NULL) { - free(mPosition); - } + if (mPosition != NULL) { + free (mPosition); + } - if (mParent != NULL) { - free(mParent); - } + if (mParent != NULL) { + free (mParent); + } - if (mPrev != NULL) { - free(mPrev); - } + if (mPrev != NULL) { + free (mPrev); + } - if (mNext != NULL) { - free(mNext); - } + if (mNext != NULL) { + free (mNext); + } - if (mBuf != NULL) { - free(mBuf); - } + if (mBuf != NULL) { + free (mBuf); + } - return; + return ; } STATIC -VOID -InitSlide( - VOID -) -/*++ + VOID + InitSlide ( + VOID + ) + /*++ -Routine Description: + Routine Description: -Initialize String Info Log data structures + Initialize String Info Log data structures -Arguments: (VOID) + Arguments: (VOID) -Returns: (VOID) + Returns: (VOID) ---*/ + --*/ { - NODE Index; + NODE Index; - for (Index = (NODE)WNDSIZ; Index <= (NODE)WNDSIZ + UINT8_MAX; Index++) { - mLevel[Index] = 1; - mPosition[Index] = NIL; // sentinel - } + for (Index = (NODE) WNDSIZ; Index <= (NODE) WNDSIZ + UINT8_MAX; Index++) { + mLevel[Index] = 1; + mPosition[Index] = NIL; // sentinel + } - for (Index = (NODE)WNDSIZ; Index < (NODE)WNDSIZ * 2; Index++) { - mParent[Index] = NIL; - } + for (Index = (NODE) WNDSIZ; Index < (NODE) WNDSIZ * 2; Index++) { + mParent[Index] = NIL; + } - mAvail = 1; - for (Index = 1; Index < (NODE)WNDSIZ - 1; Index++) { - mNext[Index] = (NODE)(Index + 1); - } + mAvail = 1; + for (Index = 1; Index < (NODE) WNDSIZ - 1; Index++) { + mNext[Index] = (NODE) (Index + 1); + } - mNext[WNDSIZ - 1] = NIL; - for (Index = (NODE)WNDSIZ * 2; Index <= (NODE)MAX_HASH_VAL; Index++) { - mNext[Index] = NIL; - } + mNext[WNDSIZ - 1] = NIL; + for (Index = (NODE) WNDSIZ * 2; Index <= (NODE) MAX_HASH_VAL; Index++) { + mNext[Index] = NIL; + } } STATIC -NODE -Child( - NODE NodeQ, - UINT8 CharC -) -/*++ + NODE + Child ( + NODE NodeQ, + UINT8 CharC + ) + /*++ -Routine Description: + Routine Description: -Find child node given the parent node and the edge character + Find child node given the parent node and the edge character -Arguments: + Arguments: -NodeQ - the parent node -CharC - the edge character + NodeQ - the parent node + CharC - the edge character -Returns: + Returns: -The child node (NIL if not found) + The child node (NIL if not found) ---*/ + --*/ { - NODE NodeR; + NODE NodeR; - NodeR = mNext[HASH(NodeQ, CharC)]; - // - // sentinel - // - mParent[NIL] = NodeQ; - while (mParent[NodeR] != NodeQ) { - NodeR = mNext[NodeR]; - } + NodeR = mNext[HASH (NodeQ, CharC)]; + // + // sentinel + // + mParent[NIL] = NodeQ; + while (mParent[NodeR] != NodeQ) { + NodeR = mNext[NodeR]; + } - return NodeR; + return NodeR; } STATIC -VOID -MakeChild( - NODE Parent, - UINT8 CharC, - NODE Child -) -/*++ + VOID + MakeChild ( + NODE Parent, + UINT8 CharC, + NODE Child + ) + /*++ -Routine Description: + Routine Description: -Create a new child for a given parent node. + Create a new child for a given parent node. -Arguments: + Arguments: -Parent - the parent node -CharC - the edge character -Child - the child node + Parent - the parent node + CharC - the edge character + Child - the child node -Returns: (VOID) + Returns: (VOID) ---*/ + --*/ { - NODE Node1; - NODE Node2; + NODE Node1; + NODE Node2; - Node1 = (NODE)HASH(Parent, CharC); - Node2 = mNext[Node1]; - mNext[Node1] = Child; - mNext[Child] = Node2; - mPrev[Node2] = Child; - mPrev[Child] = Node1; - mParent[Child] = Parent; - mChildCount[Parent]++; + Node1 = (NODE) HASH (Parent, CharC); + Node2 = mNext[Node1]; + mNext[Node1] = Child; + mNext[Child] = Node2; + mPrev[Node2] = Child; + mPrev[Child] = Node1; + mParent[Child] = Parent; + mChildCount[Parent]++; } STATIC -VOID -Split( - NODE Old -) -/*++ + VOID + Split ( + NODE Old + ) + /*++ -Routine Description: + Routine Description: -Split a node. + Split a node. -Arguments: + Arguments: -Old - the node to split + Old - the node to split -Returns: (VOID) + Returns: (VOID) ---*/ + --*/ { - NODE New; - NODE TempNode; + NODE New; + NODE TempNode; - New = mAvail; - mAvail = mNext[New]; - mChildCount[New] = 0; - TempNode = mPrev[Old]; - mPrev[New] = TempNode; - mNext[TempNode] = New; - TempNode = mNext[Old]; - mNext[New] = TempNode; - mPrev[TempNode] = New; - mParent[New] = mParent[Old]; - mLevel[New] = (UINT8)mMatchLen; - mPosition[New] = mPos; - MakeChild(New, mText[mMatchPos + mMatchLen], Old); - MakeChild(New, mText[mPos + mMatchLen], mPos); + New = mAvail; + mAvail = mNext[New]; + mChildCount[New] = 0; + TempNode = mPrev[Old]; + mPrev[New] = TempNode; + mNext[TempNode] = New; + TempNode = mNext[Old]; + mNext[New] = TempNode; + mPrev[TempNode] = New; + mParent[New] = mParent[Old]; + mLevel[New] = (UINT8) mMatchLen; + mPosition[New] = mPos; + MakeChild (New, mText[mMatchPos + mMatchLen], Old); + MakeChild (New, mText[mPos + mMatchLen], mPos); } STATIC -VOID -InsertNode( - VOID -) -/*++ + VOID + InsertNode ( + VOID + ) + /*++ -Routine Description: + Routine Description: -Insert string info for current position into the String Info Log + Insert string info for current position into the String Info Log -Arguments: (VOID) + Arguments: (VOID) -Returns: (VOID) + Returns: (VOID) ---*/ + --*/ { - NODE NodeQ; - NODE NodeR; - NODE Index2; - NODE NodeT; - UINT8 CharC; - UINT8 *t1; - UINT8 *t2; + NODE NodeQ; + NODE NodeR; + NODE Index2; + NODE NodeT; + UINT8 CharC; + UINT8 *t1; + UINT8 *t2; - if (mMatchLen >= 4) { - // - // We have just got a long match, the target tree - // can be located by MatchPos + 1. Traverse the tree - // from bottom up to get to a proper starting point. - // The usage of PERC_FLAG ensures proper node deletion - // DeleteNode() later. - // - mMatchLen--; - NodeR = (NODE)((mMatchPos + 1) | WNDSIZ); - NodeQ = mParent[NodeR]; - while (NodeQ == NIL) { - NodeR = mNext[NodeR]; - NodeQ = mParent[NodeR]; - } + if (mMatchLen >= 4) { + // + // We have just got a long match, the target tree + // can be located by MatchPos + 1. Traverse the tree + // from bottom up to get to a proper starting point. + // The usage of PERC_FLAG ensures proper node deletion + // DeleteNode() later. + // + mMatchLen--; + NodeR = (NODE) ((mMatchPos + 1) | WNDSIZ); + NodeQ = mParent[NodeR]; + while (NodeQ == NIL) { + NodeR = mNext[NodeR]; + NodeQ = mParent[NodeR]; + } - while (mLevel[NodeQ] >= mMatchLen) { - NodeR = NodeQ; - NodeQ = mParent[NodeQ]; - } + while (mLevel[NodeQ] >= mMatchLen) { + NodeR = NodeQ; + NodeQ = mParent[NodeQ]; + } - NodeT = NodeQ; - while (mPosition[NodeT] < 0) { - mPosition[NodeT] = mPos; - NodeT = mParent[NodeT]; - } + NodeT = NodeQ; + while (mPosition[NodeT] < 0) { + mPosition[NodeT] = mPos; + NodeT = mParent[NodeT]; + } - if (NodeT < (NODE)WNDSIZ) { - mPosition[NodeT] = (NODE)(mPos | (UINT32)PERC_FLAG); - } - } - else { - // - // Locate the target tree - // - NodeQ = (NODE)(mText[mPos] + WNDSIZ); - CharC = mText[mPos + 1]; - NodeR = Child(NodeQ, CharC); - if (NodeR == NIL) { - MakeChild(NodeQ, CharC, mPos); - mMatchLen = 1; - return; - } + if (NodeT < (NODE) WNDSIZ) { + mPosition[NodeT] = (NODE) (mPos | (UINT32) PERC_FLAG); + } + } else { + // + // Locate the target tree + // + NodeQ = (NODE) (mText[mPos] + WNDSIZ); + CharC = mText[mPos + 1]; + NodeR = Child (NodeQ, CharC); + if (NodeR == NIL) { + MakeChild (NodeQ, CharC, mPos); + mMatchLen = 1; + return ; + } - mMatchLen = 2; - } - // - // Traverse down the tree to find a match. - // Update Position value along the route. - // Node split or creation is involved. - // - for (;;) { - if (NodeR >= (NODE)WNDSIZ) { - Index2 = MAXMATCH; - mMatchPos = NodeR; - } - else { - Index2 = mLevel[NodeR]; - mMatchPos = (NODE)(mPosition[NodeR] & (UINT32)~PERC_FLAG); - } + mMatchLen = 2; + } + // + // Traverse down the tree to find a match. + // Update Position value along the route. + // Node split or creation is involved. + // + for (;;) { + if (NodeR >= (NODE) WNDSIZ) { + Index2 = MAXMATCH; + mMatchPos = NodeR; + } else { + Index2 = mLevel[NodeR]; + mMatchPos = (NODE) (mPosition[NodeR] & (UINT32)~PERC_FLAG); + } - if (mMatchPos >= mPos) { - mMatchPos -= WNDSIZ; - } + if (mMatchPos >= mPos) { + mMatchPos -= WNDSIZ; + } - t1 = &mText[mPos + mMatchLen]; - t2 = &mText[mMatchPos + mMatchLen]; - while (mMatchLen < Index2) { - if (*t1 != *t2) { - Split(NodeR); - return; - } + t1 = &mText[mPos + mMatchLen]; + t2 = &mText[mMatchPos + mMatchLen]; + while (mMatchLen < Index2) { + if (*t1 != *t2) { + Split (NodeR); + return ; + } - mMatchLen++; - t1++; - t2++; - } + mMatchLen++; + t1++; + t2++; + } - if (mMatchLen >= MAXMATCH) { - break; - } + if (mMatchLen >= MAXMATCH) { + break; + } - mPosition[NodeR] = mPos; - NodeQ = NodeR; - NodeR = Child(NodeQ, *t1); - if (NodeR == NIL) { - MakeChild(NodeQ, *t1, mPos); - return; - } + mPosition[NodeR] = mPos; + NodeQ = NodeR; + NodeR = Child (NodeQ, *t1); + if (NodeR == NIL) { + MakeChild (NodeQ, *t1, mPos); + return ; + } - mMatchLen++; - } + mMatchLen++; + } - NodeT = mPrev[NodeR]; - mPrev[mPos] = NodeT; - mNext[NodeT] = mPos; - NodeT = mNext[NodeR]; - mNext[mPos] = NodeT; - mPrev[NodeT] = mPos; - mParent[mPos] = NodeQ; - mParent[NodeR] = NIL; + NodeT = mPrev[NodeR]; + mPrev[mPos] = NodeT; + mNext[NodeT] = mPos; + NodeT = mNext[NodeR]; + mNext[mPos] = NodeT; + mPrev[NodeT] = mPos; + mParent[mPos] = NodeQ; + mParent[NodeR] = NIL; - // - // Special usage of 'next' - // - mNext[NodeR] = mPos; + // + // Special usage of 'next' + // + mNext[NodeR] = mPos; } STATIC -VOID -DeleteNode( - VOID -) -/*++ + VOID + DeleteNode ( + VOID + ) + /*++ -Routine Description: + Routine Description: -Delete outdated string info. (The Usage of PERC_FLAG -ensures a clean deletion) + Delete outdated string info. (The Usage of PERC_FLAG + ensures a clean deletion) -Arguments: (VOID) + Arguments: (VOID) -Returns: (VOID) + Returns: (VOID) ---*/ + --*/ { - NODE NodeQ; - NODE NodeR; - NODE NodeS; - NODE NodeT; - NODE NodeU; + NODE NodeQ; + NODE NodeR; + NODE NodeS; + NODE NodeT; + NODE NodeU; - if (mParent[mPos] == NIL) { - return; - } + if (mParent[mPos] == NIL) { + return ; + } - NodeR = mPrev[mPos]; - NodeS = mNext[mPos]; - mNext[NodeR] = NodeS; - mPrev[NodeS] = NodeR; - NodeR = mParent[mPos]; - mParent[mPos] = NIL; - if (NodeR >= (NODE)WNDSIZ) { - return; - } + NodeR = mPrev[mPos]; + NodeS = mNext[mPos]; + mNext[NodeR] = NodeS; + mPrev[NodeS] = NodeR; + NodeR = mParent[mPos]; + mParent[mPos] = NIL; + if (NodeR >= (NODE) WNDSIZ) { + return ; + } - mChildCount[NodeR]--; - if (mChildCount[NodeR] > 1) { - return; - } + mChildCount[NodeR]--; + if (mChildCount[NodeR] > 1) { + return ; + } - NodeT = (NODE)(mPosition[NodeR] & (UINT32)~PERC_FLAG); - if (NodeT >= mPos) { - NodeT -= WNDSIZ; - } + NodeT = (NODE) (mPosition[NodeR] & (UINT32)~PERC_FLAG); + if (NodeT >= mPos) { + NodeT -= WNDSIZ; + } - NodeS = NodeT; - NodeQ = mParent[NodeR]; - NodeU = mPosition[NodeQ]; - while (NodeU & (UINT32)PERC_FLAG) { - NodeU &= (UINT32)~PERC_FLAG; - if (NodeU >= mPos) { - NodeU -= WNDSIZ; - } + NodeS = NodeT; + NodeQ = mParent[NodeR]; + NodeU = mPosition[NodeQ]; + while (NodeU & (UINT32) PERC_FLAG) { + NodeU &= (UINT32)~PERC_FLAG; + if (NodeU >= mPos) { + NodeU -= WNDSIZ; + } - if (NodeU > NodeS) { - NodeS = NodeU; - } + if (NodeU > NodeS) { + NodeS = NodeU; + } - mPosition[NodeQ] = (NODE)(NodeS | WNDSIZ); - NodeQ = mParent[NodeQ]; - NodeU = mPosition[NodeQ]; - } + mPosition[NodeQ] = (NODE) (NodeS | WNDSIZ); + NodeQ = mParent[NodeQ]; + NodeU = mPosition[NodeQ]; + } - if (NodeQ < (NODE)WNDSIZ) { - if (NodeU >= mPos) { - NodeU -= WNDSIZ; - } + if (NodeQ < (NODE) WNDSIZ) { + if (NodeU >= mPos) { + NodeU -= WNDSIZ; + } - if (NodeU > NodeS) { - NodeS = NodeU; - } + if (NodeU > NodeS) { + NodeS = NodeU; + } - mPosition[NodeQ] = (NODE)(NodeS | WNDSIZ | (UINT32)PERC_FLAG); - } + mPosition[NodeQ] = (NODE) (NodeS | WNDSIZ | (UINT32) PERC_FLAG); + } - NodeS = Child(NodeR, mText[NodeT + mLevel[NodeR]]); - NodeT = mPrev[NodeS]; - NodeU = mNext[NodeS]; - mNext[NodeT] = NodeU; - mPrev[NodeU] = NodeT; - NodeT = mPrev[NodeR]; - mNext[NodeT] = NodeS; - mPrev[NodeS] = NodeT; - NodeT = mNext[NodeR]; - mPrev[NodeT] = NodeS; - mNext[NodeS] = NodeT; - mParent[NodeS] = mParent[NodeR]; - mParent[NodeR] = NIL; - mNext[NodeR] = mAvail; - mAvail = NodeR; + NodeS = Child (NodeR, mText[NodeT + mLevel[NodeR]]); + NodeT = mPrev[NodeS]; + NodeU = mNext[NodeS]; + mNext[NodeT] = NodeU; + mPrev[NodeU] = NodeT; + NodeT = mPrev[NodeR]; + mNext[NodeT] = NodeS; + mPrev[NodeS] = NodeT; + NodeT = mNext[NodeR]; + mPrev[NodeT] = NodeS; + mNext[NodeS] = NodeT; + mParent[NodeS] = mParent[NodeR]; + mParent[NodeR] = NIL; + mNext[NodeR] = mAvail; + mAvail = NodeR; } STATIC -VOID -GetNextMatch( - VOID -) -/*++ + VOID + GetNextMatch ( + VOID + ) + /*++ -Routine Description: + Routine Description: -Advance the current position (read new data if needed). -Delete outdated string info. Find a match string for current position. + Advance the current position (read new data if needed). + Delete outdated string info. Find a match string for current position. -Arguments: (VOID) + Arguments: (VOID) -Returns: (VOID) + Returns: (VOID) ---*/ + --*/ { - INT32 Number; + INT32 Number; - mRemainder--; - mPos++; - if (mPos == WNDSIZ * 2) { - memmove(&mText[0], &mText[WNDSIZ], WNDSIZ + MAXMATCH); - Number = FreadCrc(&mText[WNDSIZ + MAXMATCH], WNDSIZ); - mRemainder += Number; - mPos = WNDSIZ; - } + mRemainder--; + mPos++; + if (mPos == WNDSIZ * 2) { + memmove (&mText[0], &mText[WNDSIZ], WNDSIZ + MAXMATCH); + Number = FreadCrc (&mText[WNDSIZ + MAXMATCH], WNDSIZ); + mRemainder += Number; + mPos = WNDSIZ; + } - DeleteNode(); - InsertNode(); + DeleteNode (); + InsertNode (); } STATIC -INT32 -Encode( - VOID -) -/*++ + INT32 + Encode ( + VOID + ) + /*++ -Routine Description: + Routine Description: -The mac controlling routine for compression process. + The mac controlling routine for compression process. -Arguments: (VOID) + Arguments: (VOID) -Returns: + Returns: -EFI_SUCCESS - The compression is successful -EFI_OUT_0F_RESOURCES - Not enough memory for compression process + EFI_SUCCESS - The compression is successful + EFI_OUT_0F_RESOURCES - Not enough memory for compression process ---*/ + --*/ { - INT32 Status; - INT32 LastMatchLen; - NODE LastMatchPos; + INT32 Status; + INT32 LastMatchLen; + NODE LastMatchPos; - Status = AllocateMemory(); - if (Status) { - FreeMemory(); - return Status; - } + Status = AllocateMemory (); + if (Status) { + FreeMemory (); + return Status; + } - InitSlide(); + InitSlide (); - HufEncodeStart(); + HufEncodeStart (); - mRemainder = FreadCrc(&mText[WNDSIZ], WNDSIZ + MAXMATCH); + mRemainder = FreadCrc (&mText[WNDSIZ], WNDSIZ + MAXMATCH); - mMatchLen = 0; - mPos = WNDSIZ; - InsertNode(); - if (mMatchLen > mRemainder) { - mMatchLen = mRemainder; - } + mMatchLen = 0; + mPos = WNDSIZ; + InsertNode (); + if (mMatchLen > mRemainder) { + mMatchLen = mRemainder; + } - while (mRemainder > 0) { - LastMatchLen = mMatchLen; - LastMatchPos = mMatchPos; - GetNextMatch(); - if (mMatchLen > mRemainder) { - mMatchLen = mRemainder; - } + while (mRemainder > 0) { + LastMatchLen = mMatchLen; + LastMatchPos = mMatchPos; + GetNextMatch (); + if (mMatchLen > mRemainder) { + mMatchLen = mRemainder; + } - if (mMatchLen > LastMatchLen || LastMatchLen < THRESHOLD) { - // - // Not enough benefits are gained by outputting a pointer, - // so just output the original character - // - Output(mText[mPos - 1], 0); + if (mMatchLen > LastMatchLen || LastMatchLen < THRESHOLD) { + // + // Not enough benefits are gained by outputting a pointer, + // so just output the original character + // + Output (mText[mPos - 1], 0); - } - else { + } else { - if (LastMatchLen == THRESHOLD) { - if (((mPos - LastMatchPos - 2) & (WNDSIZ - 1)) > (1U << 11)) { - Output(mText[mPos - 1], 0); - continue; - } - } - // - // Outputting a pointer is beneficial enough, do it. - // - Output( - LastMatchLen + (UINT8_MAX + 1 - THRESHOLD), - (mPos - LastMatchPos - 2) & (WNDSIZ - 1) - ); - LastMatchLen--; - while (LastMatchLen > 0) { - GetNextMatch(); - LastMatchLen--; - } + if (LastMatchLen == THRESHOLD) { + if (((mPos - LastMatchPos - 2) & (WNDSIZ - 1)) > (1U << 11)) { + Output (mText[mPos - 1], 0); + continue; + } + } + // + // Outputting a pointer is beneficial enough, do it. + // + Output ( + LastMatchLen + (UINT8_MAX + 1 - THRESHOLD), + (mPos - LastMatchPos - 2) & (WNDSIZ - 1) + ); + LastMatchLen--; + while (LastMatchLen > 0) { + GetNextMatch (); + LastMatchLen--; + } - if (mMatchLen > mRemainder) { - mMatchLen = mRemainder; - } - } - } + if (mMatchLen > mRemainder) { + mMatchLen = mRemainder; + } + } + } - HufEncodeEnd(); - FreeMemory(); - return EFI_SUCCESS; + HufEncodeEnd (); + FreeMemory (); + return EFI_SUCCESS; } STATIC -VOID -CountTFreq( - VOID -) -/*++ + VOID + CountTFreq ( + VOID + ) + /*++ -Routine Description: + Routine Description: -Count the frequencies for the Extra Set + Count the frequencies for the Extra Set -Arguments: (VOID) + Arguments: (VOID) -Returns: (VOID) + Returns: (VOID) ---*/ + --*/ { - INT32 Index; - INT32 Index3; - INT32 Number; - INT32 Count; + INT32 Index; + INT32 Index3; + INT32 Number; + INT32 Count; - for (Index = 0; Index < NT; Index++) { - mTFreq[Index] = 0; - } + for (Index = 0; Index < NT; Index++) { + mTFreq[Index] = 0; + } - Number = NC; - while (Number > 0 && mCLen[Number - 1] == 0) { - Number--; - } + Number = NC; + while (Number > 0 && mCLen[Number - 1] == 0) { + Number--; + } - Index = 0; - while (Index < Number) { - Index3 = mCLen[Index++]; - if (Index3 == 0) { - Count = 1; - while (Index < Number && mCLen[Index] == 0) { - Index++; - Count++; - } + Index = 0; + while (Index < Number) { + Index3 = mCLen[Index++]; + if (Index3 == 0) { + Count = 1; + while (Index < Number && mCLen[Index] == 0) { + Index++; + Count++; + } - if (Count <= 2) { - mTFreq[0] = (UINT16)(mTFreq[0] + Count); - } - else if (Count <= 18) { - mTFreq[1]++; - } - else if (Count == 19) { - mTFreq[0]++; - mTFreq[1]++; - } - else { - mTFreq[2]++; - } - } - else { - mTFreq[Index3 + 2]++; - } - } + if (Count <= 2) { + mTFreq[0] = (UINT16) (mTFreq[0] + Count); + } else if (Count <= 18) { + mTFreq[1]++; + } else if (Count == 19) { + mTFreq[0]++; + mTFreq[1]++; + } else { + mTFreq[2]++; + } + } else { + mTFreq[Index3 + 2]++; + } + } } STATIC -VOID -WritePTLen( - INT32 Number, - INT32 nbit, - INT32 Special -) -/*++ + VOID + WritePTLen ( + INT32 Number, + INT32 nbit, + INT32 Special + ) + /*++ -Routine Description: + Routine Description: -Outputs the code length array for the Extra Set or the Position Set. + Outputs the code length array for the Extra Set or the Position Set. -Arguments: + Arguments: -Number - the number of symbols -nbit - the number of bits needed to represent 'n' -Special - the special symbol that needs to be take care of + Number - the number of symbols + nbit - the number of bits needed to represent 'n' + Special - the special symbol that needs to be take care of -Returns: (VOID) + Returns: (VOID) ---*/ + --*/ { - INT32 Index; - INT32 Index3; + INT32 Index; + INT32 Index3; - while (Number > 0 && mPTLen[Number - 1] == 0) { - Number--; - } + while (Number > 0 && mPTLen[Number - 1] == 0) { + Number--; + } - PutBits(nbit, Number); - Index = 0; - while (Index < Number) { - Index3 = mPTLen[Index++]; - if (Index3 <= 6) { - PutBits(3, Index3); - } - else { - PutBits(Index3 - 3, (1U << (Index3 - 3)) - 2); - } + PutBits (nbit, Number); + Index = 0; + while (Index < Number) { + Index3 = mPTLen[Index++]; + if (Index3 <= 6) { + PutBits (3, Index3); + } else { + PutBits (Index3 - 3, (1U << (Index3 - 3)) - 2); + } - if (Index == Special) { - while (Index < 6 && mPTLen[Index] == 0) { - Index++; - } + if (Index == Special) { + while (Index < 6 && mPTLen[Index] == 0) { + Index++; + } - PutBits(2, (Index - 3) & 3); - } - } + PutBits (2, (Index - 3) & 3); + } + } } STATIC -VOID -WriteCLen( - VOID -) -/*++ + VOID + WriteCLen ( + VOID + ) + /*++ -Routine Description: + Routine Description: -Outputs the code length array for Char&Length Set + Outputs the code length array for Char&Length Set -Arguments: (VOID) + Arguments: (VOID) -Returns: (VOID) + Returns: (VOID) ---*/ + --*/ { - INT32 Index; - INT32 Index3; - INT32 Number; - INT32 Count; + INT32 Index; + INT32 Index3; + INT32 Number; + INT32 Count; - Number = NC; - while (Number > 0 && mCLen[Number - 1] == 0) { - Number--; - } + Number = NC; + while (Number > 0 && mCLen[Number - 1] == 0) { + Number--; + } - PutBits(CBIT, Number); - Index = 0; - while (Index < Number) { - Index3 = mCLen[Index++]; - if (Index3 == 0) { - Count = 1; - while (Index < Number && mCLen[Index] == 0) { - Index++; - Count++; - } + PutBits (CBIT, Number); + Index = 0; + while (Index < Number) { + Index3 = mCLen[Index++]; + if (Index3 == 0) { + Count = 1; + while (Index < Number && mCLen[Index] == 0) { + Index++; + Count++; + } - if (Count <= 2) { - for (Index3 = 0; Index3 < Count; Index3++) { - PutBits(mPTLen[0], mPTCode[0]); - } - } - else if (Count <= 18) { - PutBits(mPTLen[1], mPTCode[1]); - PutBits(4, Count - 3); - } - else if (Count == 19) { - PutBits(mPTLen[0], mPTCode[0]); - PutBits(mPTLen[1], mPTCode[1]); - PutBits(4, 15); - } - else { - PutBits(mPTLen[2], mPTCode[2]); - PutBits(CBIT, Count - 20); - } - } - else { - PutBits(mPTLen[Index3 + 2], mPTCode[Index3 + 2]); - } - } + if (Count <= 2) { + for (Index3 = 0; Index3 < Count; Index3++) { + PutBits (mPTLen[0], mPTCode[0]); + } + } else if (Count <= 18) { + PutBits (mPTLen[1], mPTCode[1]); + PutBits (4, Count - 3); + } else if (Count == 19) { + PutBits (mPTLen[0], mPTCode[0]); + PutBits (mPTLen[1], mPTCode[1]); + PutBits (4, 15); + } else { + PutBits (mPTLen[2], mPTCode[2]); + PutBits (CBIT, Count - 20); + } + } else { + PutBits (mPTLen[Index3 + 2], mPTCode[Index3 + 2]); + } + } } STATIC -VOID -EncodeC( - INT32 Value -) + VOID + EncodeC ( + INT32 Value + ) { - PutBits(mCLen[Value], mCCode[Value]); + PutBits (mCLen[Value], mCCode[Value]); } STATIC -VOID -EncodeP( - UINT32 Value -) + VOID + EncodeP ( + UINT32 Value + ) { - UINT32 Index; - UINT32 NodeQ; + UINT32 Index; + UINT32 NodeQ; - Index = 0; - NodeQ = Value; - while (NodeQ) { - NodeQ >>= 1; - Index++; - } + Index = 0; + NodeQ = Value; + while (NodeQ) { + NodeQ >>= 1; + Index++; + } - PutBits(mPTLen[Index], mPTCode[Index]); - if (Index > 1) { - PutBits(Index - 1, Value & (0xFFFFFFFFU >> (32 - Index + 1))); - } + PutBits (mPTLen[Index], mPTCode[Index]); + if (Index > 1) { + PutBits (Index - 1, Value & (0xFFFFFFFFU >> (32 - Index + 1))); + } } STATIC -VOID -SendBlock( - VOID -) -/*++ + VOID + SendBlock ( + VOID + ) + /*++ -Routine Description: + Routine Description: -Huffman code the block and output it. + Huffman code the block and output it. -Arguments: -(VOID) + Arguments: + (VOID) -Returns: -(VOID) + Returns: + (VOID) ---*/ + --*/ { - UINT32 Index; - UINT32 Index2; - UINT32 Index3; - UINT32 Flags; - UINT32 Root; - UINT32 Pos; - UINT32 Size; - Flags = 0; + UINT32 Index; + UINT32 Index2; + UINT32 Index3; + UINT32 Flags; + UINT32 Root; + UINT32 Pos; + UINT32 Size; + Flags = 0; - Root = MakeTree(NC, mCFreq, mCLen, mCCode); - Size = mCFreq[Root]; - PutBits(16, Size); - if (Root >= NC) { - CountTFreq(); - Root = MakeTree(NT, mTFreq, mPTLen, mPTCode); - if (Root >= NT) { - WritePTLen(NT, TBIT, 3); - } - else { - PutBits(TBIT, 0); - PutBits(TBIT, Root); - } + Root = MakeTree (NC, mCFreq, mCLen, mCCode); + Size = mCFreq[Root]; + PutBits (16, Size); + if (Root >= NC) { + CountTFreq (); + Root = MakeTree (NT, mTFreq, mPTLen, mPTCode); + if (Root >= NT) { + WritePTLen (NT, TBIT, 3); + } else { + PutBits (TBIT, 0); + PutBits (TBIT, Root); + } - WriteCLen(); - } - else { - PutBits(TBIT, 0); - PutBits(TBIT, 0); - PutBits(CBIT, 0); - PutBits(CBIT, Root); - } + WriteCLen (); + } else { + PutBits (TBIT, 0); + PutBits (TBIT, 0); + PutBits (CBIT, 0); + PutBits (CBIT, Root); + } - Root = MakeTree(NP, mPFreq, mPTLen, mPTCode); - if (Root >= NP) { - WritePTLen(NP, mPbit, -1); - } - else { - PutBits(mPbit, 0); - PutBits(mPbit, Root); - } + Root = MakeTree (NP, mPFreq, mPTLen, mPTCode); + if (Root >= NP) { + WritePTLen (NP, mPbit, -1); + } else { + PutBits (mPbit, 0); + PutBits (mPbit, Root); + } - Pos = 0; - for (Index = 0; Index < Size; Index++) { - if (Index % UINT8_BIT == 0) { - Flags = mBuf[Pos++]; - } - else { - Flags <<= 1; - } + Pos = 0; + for (Index = 0; Index < Size; Index++) { + if (Index % UINT8_BIT == 0) { + Flags = mBuf[Pos++]; + } else { + Flags <<= 1; + } - if (Flags & (1U << (UINT8_BIT - 1))) { - EncodeC(mBuf[Pos++] + (1U << UINT8_BIT)); - Index3 = mBuf[Pos++]; - for (Index2 = 0; Index2 < 3; Index2++) { - Index3 <<= UINT8_BIT; - Index3 += mBuf[Pos++]; - } + if (Flags & (1U << (UINT8_BIT - 1))) { + EncodeC (mBuf[Pos++] + (1U << UINT8_BIT)); + Index3 = mBuf[Pos++]; + for (Index2 = 0; Index2 < 3; Index2++) { + Index3 <<= UINT8_BIT; + Index3 += mBuf[Pos++]; + } - EncodeP(Index3); - } - else { - EncodeC(mBuf[Pos++]); - } - } + EncodeP (Index3); + } else { + EncodeC (mBuf[Pos++]); + } + } - for (Index = 0; Index < NC; Index++) { - mCFreq[Index] = 0; - } + for (Index = 0; Index < NC; Index++) { + mCFreq[Index] = 0; + } - for (Index = 0; Index < NP; Index++) { - mPFreq[Index] = 0; - } + for (Index = 0; Index < NP; Index++) { + mPFreq[Index] = 0; + } } STATIC -VOID -Output( - UINT32 CharC, - UINT32 Pos -) -/*++ + VOID + Output ( + UINT32 CharC, + UINT32 Pos + ) + /*++ -Routine Description: + Routine Description: -Outputs an Original Character or a Pointer + Outputs an Original Character or a Pointer -Arguments: + Arguments: -CharC - The original character or the 'String Length' element of a Pointer -Pos - The 'Position' field of a Pointer + CharC - The original character or the 'String Length' element of a Pointer + Pos - The 'Position' field of a Pointer -Returns: (VOID) + Returns: (VOID) ---*/ + --*/ { - STATIC UINT32 CPos; + STATIC UINT32 CPos; - if ((mOutputMask >>= 1) == 0) { - mOutputMask = 1U << (UINT8_BIT - 1); - // - // Check the buffer overflow per outputting UINT8_BIT symbols - // which is an Original Character or a Pointer. The biggest - // symbol is a Pointer which occupies 5 bytes. - // - if (mOutputPos >= mBufSiz - 5 * UINT8_BIT) { - SendBlock(); - mOutputPos = 0; - } + if ((mOutputMask >>= 1) == 0) { + mOutputMask = 1U << (UINT8_BIT - 1); + // + // Check the buffer overflow per outputting UINT8_BIT symbols + // which is an Original Character or a Pointer. The biggest + // symbol is a Pointer which occupies 5 bytes. + // + if (mOutputPos >= mBufSiz - 5 * UINT8_BIT) { + SendBlock (); + mOutputPos = 0; + } - CPos = mOutputPos++; - mBuf[CPos] = 0; - } + CPos = mOutputPos++; + mBuf[CPos] = 0; + } - mBuf[mOutputPos++] = (UINT8)CharC; - mCFreq[CharC]++; - if (CharC >= (1U << UINT8_BIT)) { - mBuf[CPos] |= mOutputMask; - mBuf[mOutputPos++] = (UINT8)(Pos >> 24); - mBuf[mOutputPos++] = (UINT8)(Pos >> 16); - mBuf[mOutputPos++] = (UINT8)(Pos >> (UINT8_BIT)); - mBuf[mOutputPos++] = (UINT8)Pos; - CharC = 0; - while (Pos) { - Pos >>= 1; - CharC++; - } + mBuf[mOutputPos++] = (UINT8) CharC; + mCFreq[CharC]++; + if (CharC >= (1U << UINT8_BIT)) { + mBuf[CPos] |= mOutputMask; + mBuf[mOutputPos++] = (UINT8) (Pos >> 24); + mBuf[mOutputPos++] = (UINT8) (Pos >> 16); + mBuf[mOutputPos++] = (UINT8) (Pos >> (UINT8_BIT)); + mBuf[mOutputPos++] = (UINT8) Pos; + CharC = 0; + while (Pos) { + Pos >>= 1; + CharC++; + } - mPFreq[CharC]++; - } + mPFreq[CharC]++; + } } STATIC -VOID -HufEncodeStart( - VOID -) + VOID + HufEncodeStart ( + VOID + ) { - INT32 Index; + INT32 Index; - for (Index = 0; Index < NC; Index++) { - mCFreq[Index] = 0; - } + for (Index = 0; Index < NC; Index++) { + mCFreq[Index] = 0; + } - for (Index = 0; Index < NP; Index++) { - mPFreq[Index] = 0; - } + for (Index = 0; Index < NP; Index++) { + mPFreq[Index] = 0; + } - mOutputPos = mOutputMask = 0; - InitPutBits(); - return; + mOutputPos = mOutputMask = 0; + InitPutBits (); + return ; } STATIC -VOID -HufEncodeEnd( - VOID -) + VOID + HufEncodeEnd ( + VOID + ) { - SendBlock(); + SendBlock (); - // - // Flush remaining bits - // - PutBits(UINT8_BIT - 1, 0); + // + // Flush remaining bits + // + PutBits (UINT8_BIT - 1, 0); - return; + return ; } STATIC -VOID -MakeCrcTable( - VOID -) + VOID + MakeCrcTable ( + VOID + ) { - UINT32 Index; - UINT32 Index2; - UINT32 Temp; + UINT32 Index; + UINT32 Index2; + UINT32 Temp; - for (Index = 0; Index <= UINT8_MAX; Index++) { - Temp = Index; - for (Index2 = 0; Index2 < UINT8_BIT; Index2++) { - if (Temp & 1) { - Temp = (Temp >> 1) ^ CRCPOLY; - } - else { - Temp >>= 1; - } - } + for (Index = 0; Index <= UINT8_MAX; Index++) { + Temp = Index; + for (Index2 = 0; Index2 < UINT8_BIT; Index2++) { + if (Temp & 1) { + Temp = (Temp >> 1) ^ CRCPOLY; + } else { + Temp >>= 1; + } + } - mCrcTable[Index] = (UINT16)Temp; - } + mCrcTable[Index] = (UINT16) Temp; + } } STATIC -VOID -PutBits( - INT32 Number, - UINT32 Value -) -/*++ + VOID + PutBits ( + INT32 Number, + UINT32 Value + ) + /*++ -Routine Description: + Routine Description: -Outputs rightmost n bits of x + Outputs rightmost n bits of x -Arguments: + Arguments: -Number - the rightmost n bits of the data is used -x - the data + Number - the rightmost n bits of the data is used + x - the data -Returns: (VOID) + Returns: (VOID) ---*/ + --*/ { - UINT8 Temp; + UINT8 Temp; - while (Number >= mBitCount) { - // - // Number -= mBitCount should never equal to 32 - // - Temp = (UINT8)(mSubBitBuf | (Value >> (Number -= mBitCount))); - if (mDst < mDstUpperLimit) { - *mDst++ = Temp; - } + while (Number >= mBitCount) { + // + // Number -= mBitCount should never equal to 32 + // + Temp = (UINT8) (mSubBitBuf | (Value >> (Number -= mBitCount))); + if (mDst < mDstUpperLimit) { + *mDst++ = Temp; + } - mCompSize++; - mSubBitBuf = 0; - mBitCount = UINT8_BIT; - } + mCompSize++; + mSubBitBuf = 0; + mBitCount = UINT8_BIT; + } - mSubBitBuf |= Value << (mBitCount -= Number); + mSubBitBuf |= Value << (mBitCount -= Number); } STATIC -INT32 -FreadCrc( - UINT8 *Pointer, - INT32 Number -) -/*++ + INT32 + FreadCrc ( + UINT8 *Pointer, + INT32 Number + ) + /*++ -Routine Description: + Routine Description: -Read source data + Read source data -Arguments: + Arguments: -Pointer - the buffer to hold the data -Number - number of bytes to read + Pointer - the buffer to hold the data + Number - number of bytes to read -Returns: + Returns: -number of bytes actually read + number of bytes actually read ---*/ + --*/ { - INT32 Index; + INT32 Index; - for (Index = 0; mSrc < mSrcUpperLimit && Index < Number; Index++) { - *Pointer++ = *mSrc++; - } + for (Index = 0; mSrc < mSrcUpperLimit && Index < Number; Index++) { + *Pointer++ = *mSrc++; + } - Number = Index; + Number = Index; - Pointer -= Number; - mOrigSize += Number; - Index--; - while (Index >= 0) { - UPDATE_CRC(*Pointer++); - Index--; - } + Pointer -= Number; + mOrigSize += Number; + Index--; + while (Index >= 0) { + UPDATE_CRC (*Pointer++); + Index--; + } - return Number; + return Number; } STATIC -VOID -InitPutBits( - VOID -) + VOID + InitPutBits ( + VOID + ) { - mBitCount = UINT8_BIT; - mSubBitBuf = 0; + mBitCount = UINT8_BIT; + mSubBitBuf = 0; } STATIC -VOID -CountLen( - INT32 Index -) -/*++ + VOID + CountLen ( + INT32 Index + ) + /*++ -Routine Description: + Routine Description: -Count the number of each code length for a Huffman tree. + Count the number of each code length for a Huffman tree. -Arguments: + Arguments: -Index - the top node + Index - the top node -Returns: (VOID) + Returns: (VOID) ---*/ + --*/ { - STATIC INT32 Depth = 0; + STATIC INT32 Depth = 0; - if (Index < mN) { - mLenCnt[(Depth < 16) ? Depth : 16]++; - } - else { - Depth++; - CountLen(mLeft[Index]); - CountLen(mRight[Index]); - Depth--; - } + if (Index < mN) { + mLenCnt[(Depth < 16) ? Depth : 16]++; + } else { + Depth++; + CountLen (mLeft[Index]); + CountLen (mRight[Index]); + Depth--; + } } STATIC -VOID -MakeLen( - INT32 Root -) -/*++ + VOID + MakeLen ( + INT32 Root + ) + /*++ -Routine Description: + Routine Description: -Create code length array for a Huffman tree + Create code length array for a Huffman tree -Arguments: + Arguments: -Root - the root of the tree + Root - the root of the tree -Returns: + Returns: -VOID + VOID ---*/ + --*/ { - INT32 Index; - INT32 Index3; - UINT32 Cum; + INT32 Index; + INT32 Index3; + UINT32 Cum; - for (Index = 0; Index <= 16; Index++) { - mLenCnt[Index] = 0; - } + for (Index = 0; Index <= 16; Index++) { + mLenCnt[Index] = 0; + } - CountLen(Root); + CountLen (Root); - // - // Adjust the length count array so that - // no code will be generated longer than its designated length - // - Cum = 0; - for (Index = 16; Index > 0; Index--) { - Cum += mLenCnt[Index] << (16 - Index); - } + // + // Adjust the length count array so that + // no code will be generated longer than its designated length + // + Cum = 0; + for (Index = 16; Index > 0; Index--) { + Cum += mLenCnt[Index] << (16 - Index); + } - while (Cum != (1U << 16)) { - mLenCnt[16]--; - for (Index = 15; Index > 0; Index--) { - if (mLenCnt[Index] != 0) { - mLenCnt[Index]--; - mLenCnt[Index + 1] += 2; - break; - } - } + while (Cum != (1U << 16)) { + mLenCnt[16]--; + for (Index = 15; Index > 0; Index--) { + if (mLenCnt[Index] != 0) { + mLenCnt[Index]--; + mLenCnt[Index + 1] += 2; + break; + } + } - Cum--; - } + Cum--; + } - for (Index = 16; Index > 0; Index--) { - Index3 = mLenCnt[Index]; - Index3--; - while (Index3 >= 0) { - mLen[*mSortPtr++] = (UINT8)Index; - Index3--; - } - } + for (Index = 16; Index > 0; Index--) { + Index3 = mLenCnt[Index]; + Index3--; + while (Index3 >= 0) { + mLen[*mSortPtr++] = (UINT8) Index; + Index3--; + } + } } STATIC -VOID -DownHeap( - INT32 Index -) + VOID + DownHeap ( + INT32 Index + ) { - INT32 Index2; - INT32 Index3; + INT32 Index2; + INT32 Index3; - // - // priority queue: send Index-th entry down heap - // - Index3 = mHeap[Index]; - Index2 = 2 * Index; - while (Index2 <= mHeapSize) { - if (Index2 < mHeapSize && mFreq[mHeap[Index2]] > mFreq[mHeap[Index2 + 1]]) { - Index2++; - } + // + // priority queue: send Index-th entry down heap + // + Index3 = mHeap[Index]; + Index2 = 2 * Index; + while (Index2 <= mHeapSize) { + if (Index2 < mHeapSize && mFreq[mHeap[Index2]] > mFreq[mHeap[Index2 + 1]]) { + Index2++; + } - if (mFreq[Index3] <= mFreq[mHeap[Index2]]) { - break; - } + if (mFreq[Index3] <= mFreq[mHeap[Index2]]) { + break; + } - mHeap[Index] = mHeap[Index2]; - Index = Index2; - Index2 = 2 * Index; - } + mHeap[Index] = mHeap[Index2]; + Index = Index2; + Index2 = 2 * Index; + } - mHeap[Index] = (INT16)Index3; + mHeap[Index] = (INT16) Index3; } STATIC -VOID -MakeCode( - INT32 Number, - UINT8 Len[], - UINT16 Code[] + VOID + MakeCode ( + INT32 Number, + UINT8 Len[ ], + UINT16 Code[] ) -/*++ + /*++ -Routine Description: + Routine Description: -Assign code to each symbol based on the code length array + Assign code to each symbol based on the code length array -Arguments: + Arguments: -Number - number of symbols -Len - the code length array -Code - stores codes for each symbol + Number - number of symbols + Len - the code length array + Code - stores codes for each symbol -Returns: (VOID) + Returns: (VOID) ---*/ + --*/ { - INT32 Index; - UINT16 Start[18]; + INT32 Index; + UINT16 Start[18]; - Start[1] = 0; - for (Index = 1; Index <= 16; Index++) { - Start[Index + 1] = (UINT16)((Start[Index] + mLenCnt[Index]) << 1); - } + Start[1] = 0; + for (Index = 1; Index <= 16; Index++) { + Start[Index + 1] = (UINT16) ((Start[Index] + mLenCnt[Index]) << 1); + } - for (Index = 0; Index < Number; Index++) { - Code[Index] = Start[Len[Index]]++; - } + for (Index = 0; Index < Number; Index++) { + Code[Index] = Start[Len[Index]]++; + } } STATIC -INT32 -MakeTree( - INT32 NParm, - UINT16 FreqParm[], - UINT8 LenParm[], - UINT16 CodeParm[] + INT32 + MakeTree ( + INT32 NParm, + UINT16 FreqParm[], + UINT8 LenParm[ ], + UINT16 CodeParm[] ) -/*++ + /*++ -Routine Description: + Routine Description: -Generates Huffman codes given a frequency distribution of symbols + Generates Huffman codes given a frequency distribution of symbols -Arguments: + Arguments: -NParm - number of symbols -FreqParm - frequency of each symbol -LenParm - code length for each symbol -CodeParm - code for each symbol + NParm - number of symbols + FreqParm - frequency of each symbol + LenParm - code length for each symbol + CodeParm - code for each symbol -Returns: + Returns: -Root of the Huffman tree. + Root of the Huffman tree. ---*/ + --*/ { - INT32 Index; - INT32 Index2; - INT32 Index3; - INT32 Avail; + INT32 Index; + INT32 Index2; + INT32 Index3; + INT32 Avail; - // - // make tree, calculate len[], return root - // - mN = NParm; - mFreq = FreqParm; - mLen = LenParm; - Avail = mN; - mHeapSize = 0; - mHeap[1] = 0; - for (Index = 0; Index < mN; Index++) { - mLen[Index] = 0; - if (mFreq[Index]) { - mHeapSize++; - mHeap[mHeapSize] = (INT16)Index; - } - } + // + // make tree, calculate len[], return root + // + mN = NParm; + mFreq = FreqParm; + mLen = LenParm; + Avail = mN; + mHeapSize = 0; + mHeap[1] = 0; + for (Index = 0; Index < mN; Index++) { + mLen[Index] = 0; + if (mFreq[Index]) { + mHeapSize++; + mHeap[mHeapSize] = (INT16) Index; + } + } - if (mHeapSize < 2) { - CodeParm[mHeap[1]] = 0; - return mHeap[1]; - } + if (mHeapSize < 2) { + CodeParm[mHeap[1]] = 0; + return mHeap[1]; + } - for (Index = mHeapSize / 2; Index >= 1; Index--) { - // - // make priority queue - // - DownHeap(Index); - } + for (Index = mHeapSize / 2; Index >= 1; Index--) { + // + // make priority queue + // + DownHeap (Index); + } - mSortPtr = CodeParm; - do { - Index = mHeap[1]; - if (Index < mN) { - *mSortPtr++ = (UINT16)Index; - } + mSortPtr = CodeParm; + do { + Index = mHeap[1]; + if (Index < mN) { + *mSortPtr++ = (UINT16) Index; + } - mHeap[1] = mHeap[mHeapSize--]; - DownHeap(1); - Index2 = mHeap[1]; - if (Index2 < mN) { - *mSortPtr++ = (UINT16)Index2; - } + mHeap[1] = mHeap[mHeapSize--]; + DownHeap (1); + Index2 = mHeap[1]; + if (Index2 < mN) { + *mSortPtr++ = (UINT16) Index2; + } - Index3 = Avail++; - mFreq[Index3] = (UINT16)(mFreq[Index] + mFreq[Index2]); - mHeap[1] = (INT16)Index3; - DownHeap(1); - mLeft[Index3] = (UINT16)Index; - mRight[Index3] = (UINT16)Index2; - } while (mHeapSize > 1); + Index3 = Avail++; + mFreq[Index3] = (UINT16) (mFreq[Index] + mFreq[Index2]); + mHeap[1] = (INT16) Index3; + DownHeap (1); + mLeft[Index3] = (UINT16) Index; + mRight[Index3] = (UINT16) Index2; + } while (mHeapSize > 1); - mSortPtr = CodeParm; - MakeLen(Index3); - MakeCode(NParm, LenParm, CodeParm); + mSortPtr = CodeParm; + MakeLen (Index3); + MakeCode (NParm, LenParm, CodeParm); - // - // return root - // - return Index3; + // + // return root + // + return Index3; } diff --git a/Tiano/EfiTianoDecompress.c b/Tiano/EfiTianoDecompress.c index 10449f1..7f2f31a 100644 --- a/Tiano/EfiTianoDecompress.c +++ b/Tiano/EfiTianoDecompress.c @@ -50,40 +50,40 @@ Decompressor. Algorithm Ported from OPSD code (Decomp.asm) #endif typedef struct { - UINT8 *mSrcBase; // Starting address of compressed data - UINT8 *mDstBase; // Starting address of decompressed data - UINT32 mOutBuf; - UINT32 mInBuf; + UINT8 *mSrcBase; // Starting address of compressed data + UINT8 *mDstBase; // Starting address of decompressed data + UINT32 mOutBuf; + UINT32 mInBuf; - UINT16 mBitCount; - UINT32 mBitBuf; - UINT32 mSubBitBuf; - UINT16 mBlockSize; - UINT32 mCompSize; - UINT32 mOrigSize; + UINT16 mBitCount; + UINT32 mBitBuf; + UINT32 mSubBitBuf; + UINT16 mBlockSize; + UINT32 mCompSize; + UINT32 mOrigSize; - UINT16 mBadTableFlag; + UINT16 mBadTableFlag; - UINT16 mLeft[2 * NC - 1]; - UINT16 mRight[2 * NC - 1]; - UINT8 mCLen[NC]; - UINT8 mPTLen[NPT]; - UINT16 mCTable[4096]; - UINT16 mPTTable[256]; + UINT16 mLeft[2 * NC - 1]; + UINT16 mRight[2 * NC - 1]; + UINT8 mCLen[NC]; + UINT8 mPTLen[NPT]; + UINT16 mCTable[4096]; + UINT16 mPTTable[256]; - // - // The length of the field 'Position Set Code Length Array Size' in Block Header. - // For EFI 1.1 de/compression algorithm, mPBit = 4 - // For Tiano de/compression algorithm, mPBit = 5 - // - UINT8 mPBit; + // + // The length of the field 'Position Set Code Length Array Size' in Block Header. + // For EFI 1.1 de/compression algorithm, mPBit = 4 + // For Tiano de/compression algorithm, mPBit = 5 + // + UINT8 mPBit; } SCRATCH_DATA; STATIC VOID FillBuf( - IN SCRATCH_DATA *Sd, - IN UINT16 NumOfBits +IN SCRATCH_DATA *Sd, +IN UINT16 NumOfBits ) /*++ @@ -100,38 +100,38 @@ Returns: (VOID) --*/ { - Sd->mBitBuf = (UINT32) (((UINT64)Sd->mBitBuf) << NumOfBits); + Sd->mBitBuf = (UINT32) (((UINT64)Sd->mBitBuf) << NumOfBits); - while (NumOfBits > Sd->mBitCount) { - Sd->mBitBuf |= (UINT32) (((UINT64)Sd->mSubBitBuf) << (NumOfBits = (UINT16) (NumOfBits - Sd->mBitCount))); + while (NumOfBits > Sd->mBitCount) { + Sd->mBitBuf |= (UINT32) (((UINT64)Sd->mSubBitBuf) << (NumOfBits = (UINT16) (NumOfBits - Sd->mBitCount))); - if (Sd->mCompSize > 0) { - // - // Get 1 byte into SubBitBuf - // - Sd->mCompSize--; - Sd->mSubBitBuf = 0; - Sd->mSubBitBuf = Sd->mSrcBase[Sd->mInBuf++]; - Sd->mBitCount = 8; - } - else { - // - // No more bits from the source, just pad zero bit. - // - Sd->mSubBitBuf = 0; - Sd->mBitCount = 8; - } - } + if (Sd->mCompSize > 0) { + // + // Get 1 byte into SubBitBuf + // + Sd->mCompSize--; + Sd->mSubBitBuf = 0; + Sd->mSubBitBuf = Sd->mSrcBase[Sd->mInBuf++]; + Sd->mBitCount = 8; + } + else { + // + // No more bits from the source, just pad zero bit. + // + Sd->mSubBitBuf = 0; + Sd->mBitCount = 8; + } + } - Sd->mBitCount = (UINT16)(Sd->mBitCount - NumOfBits); - Sd->mBitBuf |= Sd->mSubBitBuf >> Sd->mBitCount; + Sd->mBitCount = (UINT16)(Sd->mBitCount - NumOfBits); + Sd->mBitBuf |= Sd->mSubBitBuf >> Sd->mBitCount; } STATIC UINT32 GetBits( - IN SCRATCH_DATA *Sd, - IN UINT16 NumOfBits +IN SCRATCH_DATA *Sd, +IN UINT16 NumOfBits ) /*++ @@ -152,23 +152,23 @@ The bits that are popped out. --*/ { - UINT32 OutBits; + UINT32 OutBits; - OutBits = (UINT32)(Sd->mBitBuf >> (BITBUFSIZ - NumOfBits)); + OutBits = (UINT32)(Sd->mBitBuf >> (BITBUFSIZ - NumOfBits)); - FillBuf(Sd, NumOfBits); + FillBuf(Sd, NumOfBits); - return OutBits; + return OutBits; } STATIC UINT16 MakeTable( - IN SCRATCH_DATA *Sd, - IN UINT16 NumOfChar, - IN UINT8 *BitLen, - IN UINT16 TableBits, - OUT UINT16 *Table +IN SCRATCH_DATA *Sd, +IN UINT16 NumOfChar, +IN UINT8 *BitLen, +IN UINT16 TableBits, +OUT UINT16 *Table ) /*++ @@ -191,140 +191,140 @@ BAD_TABLE - The table is corrupted. --*/ { - UINT16 Count[17]; - UINT16 Weight[17]; - UINT16 Start[18]; - UINT16 *Pointer; - UINT16 Index3; - UINT16 Index; - UINT16 Len; - UINT16 Char; - UINT16 JuBits; - UINT16 Avail; - UINT16 NextCode; - UINT16 Mask; + UINT16 Count[17]; + UINT16 Weight[17]; + UINT16 Start[18]; + UINT16 *Pointer; + UINT16 Index3; + UINT16 Index; + UINT16 Len; + UINT16 Char; + UINT16 JuBits; + UINT16 Avail; + UINT16 NextCode; + UINT16 Mask; - // - // TableBits should not be greater than 16. - // - if (TableBits >= (sizeof(Count) / sizeof(UINT16))) { - return (UINT16)BAD_TABLE; - } + // + // TableBits should not be greater than 16. + // + if (TableBits >= (sizeof(Count) / sizeof(UINT16))) { + return (UINT16)BAD_TABLE; + } - // - // Initialize Count array starting from Index 0, as there is a possibility of Count array being uninitialized. - // - for (Index = 0; Index <= 16; Index++) { - Count[Index] = 0; - } + // + // Initialize Count array starting from Index 0, as there is a possibility of Count array being uninitialized. + // + for (Index = 0; Index <= 16; Index++) { + Count[Index] = 0; + } - for (Index = 0; Index < NumOfChar; Index++) { - // - // Count array index should not be greater than or equal to its size. - // - if (BitLen[Index] < (sizeof(Count) / sizeof(UINT16))) { - Count[BitLen[Index]]++; - } - else { - return (UINT16)BAD_TABLE; - } - } + for (Index = 0; Index < NumOfChar; Index++) { + // + // Count array index should not be greater than or equal to its size. + // + if (BitLen[Index] < (sizeof(Count) / sizeof(UINT16))) { + Count[BitLen[Index]]++; + } + else { + return (UINT16)BAD_TABLE; + } + } - Start[0] = 0; - Start[1] = 0; + Start[0] = 0; + Start[1] = 0; - for (Index = 1; Index <= 16; Index++) { - Start[Index + 1] = (UINT16)(Start[Index] + (Count[Index] << (16 - Index))); - } + for (Index = 1; Index <= 16; Index++) { + Start[Index + 1] = (UINT16)(Start[Index] + (Count[Index] << (16 - Index))); + } - if (Start[17] != 0) { - /*(1U << 16)*/ - return (UINT16)BAD_TABLE; - } + if (Start[17] != 0) { + /*(1U << 16)*/ + return (UINT16)BAD_TABLE; + } - JuBits = (UINT16)(16 - TableBits); + JuBits = (UINT16)(16 - TableBits); - for (Index = 1; Index <= TableBits; Index++) { - Start[Index] >>= JuBits; - Weight[Index] = (UINT16)(1U << (TableBits - Index)); - } + for (Index = 1; Index <= TableBits; Index++) { + Start[Index] >>= JuBits; + Weight[Index] = (UINT16)(1U << (TableBits - Index)); + } - while (Index <= 16) { - Weight[Index] = (UINT16)(1U << (16 - Index)); - Index++; - } + while (Index <= 16) { + Weight[Index] = (UINT16)(1U << (16 - Index)); + Index++; + } - Index = (UINT16)(Start[TableBits + 1] >> JuBits); + Index = (UINT16)(Start[TableBits + 1] >> JuBits); - if (Index != 0) { - Index3 = (UINT16)(1U << TableBits); - while (Index != Index3) { - Table[Index++] = 0; - } - } + if (Index != 0) { + Index3 = (UINT16)(1U << TableBits); + while (Index != Index3) { + Table[Index++] = 0; + } + } - Avail = NumOfChar; - Mask = (UINT16)(1U << (15 - TableBits)); + Avail = NumOfChar; + Mask = (UINT16)(1U << (15 - TableBits)); - for (Char = 0; Char < NumOfChar; Char++) { - Len = BitLen[Char]; - if (Len == 0 || Len >= 17) { - continue; - } + for (Char = 0; Char < NumOfChar; Char++) { + Len = BitLen[Char]; + if (Len == 0 || Len >= 17) { + continue; + } - NextCode = (UINT16)(Start[Len] + Weight[Len]); + NextCode = (UINT16)(Start[Len] + Weight[Len]); - if (Len <= TableBits) { - for (Index = Start[Len]; Index < NextCode; Index++) { - // Check to prevent possible heap corruption - if (Index >= (UINT16)(1U << TableBits)) - return (UINT16)BAD_TABLE; - Table[Index] = Char; - } - } - else { - Index3 = Start[Len]; - Pointer = &Table[Index3 >> JuBits]; - Index = (UINT16)(Len - TableBits); + if (Len <= TableBits) { + for (Index = Start[Len]; Index < NextCode; Index++) { + // Check to prevent possible heap corruption + if (Index >= (UINT16)(1U << TableBits)) + return (UINT16)BAD_TABLE; + Table[Index] = Char; + } + } + else { + Index3 = Start[Len]; + Pointer = &Table[Index3 >> JuBits]; + Index = (UINT16)(Len - TableBits); - while (Index != 0) { - // - // Avail should be lesser than size of mRight and mLeft to prevent buffer overflow. - // - if ((*Pointer == 0) && (Avail < sizeof(Sd->mRight) / sizeof(UINT16)) && (Avail < sizeof(Sd->mLeft) / sizeof(UINT16))) { - Sd->mRight[Avail] = Sd->mLeft[Avail] = 0; - *Pointer = Avail++; - } + while (Index != 0) { + // + // Avail should be lesser than size of mRight and mLeft to prevent buffer overflow. + // + if ((*Pointer == 0) && (Avail < sizeof(Sd->mRight) / sizeof(UINT16)) && (Avail < sizeof(Sd->mLeft) / sizeof(UINT16))) { + Sd->mRight[Avail] = Sd->mLeft[Avail] = 0; + *Pointer = Avail++; + } - // - // *Pointer should be lesser than size of mRight and mLeft to prevent buffer overflow. - // - if ((Index3 & Mask) && (*Pointer < (sizeof(Sd->mRight) / sizeof(UINT16)))) { - Pointer = &Sd->mRight[*Pointer]; - } - else if (*Pointer < (sizeof(Sd->mLeft) / sizeof(UINT16))) { - Pointer = &Sd->mLeft[*Pointer]; - } + // + // *Pointer should be lesser than size of mRight and mLeft to prevent buffer overflow. + // + if ((Index3 & Mask) && (*Pointer < (sizeof(Sd->mRight) / sizeof(UINT16)))) { + Pointer = &Sd->mRight[*Pointer]; + } + else if (*Pointer < (sizeof(Sd->mLeft) / sizeof(UINT16))) { + Pointer = &Sd->mLeft[*Pointer]; + } - Index3 <<= 1; - Index--; - } + Index3 <<= 1; + Index--; + } - *Pointer = Char; - } + *Pointer = Char; + } - Start[Len] = NextCode; - } - // - // Succeeds - // - return 0; + Start[Len] = NextCode; + } + // + // Succeeds + // + return 0; } STATIC UINT32 DecodeP( - IN SCRATCH_DATA *Sd +IN SCRATCH_DATA *Sd ) /*++ @@ -342,46 +342,46 @@ The position value decoded. --*/ { - UINT16 Val; - UINT32 Mask; - UINT32 Pos; + UINT16 Val; + UINT32 Mask; + UINT32 Pos; - Val = Sd->mPTTable[Sd->mBitBuf >> (BITBUFSIZ - 8)]; + Val = Sd->mPTTable[Sd->mBitBuf >> (BITBUFSIZ - 8)]; - if (Val >= MAXNP) { - Mask = 1U << (BITBUFSIZ - 1 - 8); + if (Val >= MAXNP) { + Mask = 1U << (BITBUFSIZ - 1 - 8); - do { - if (Sd->mBitBuf & Mask) { - Val = Sd->mRight[Val]; - } - else { - Val = Sd->mLeft[Val]; - } + do { + if (Sd->mBitBuf & Mask) { + Val = Sd->mRight[Val]; + } + else { + Val = Sd->mLeft[Val]; + } - Mask >>= 1; - } while (Val >= MAXNP); - } - // - // Advance what we have read - // - FillBuf(Sd, Sd->mPTLen[Val]); + Mask >>= 1; + } while (Val >= MAXNP); + } + // + // Advance what we have read + // + FillBuf(Sd, Sd->mPTLen[Val]); - Pos = Val; - if (Val > 1) { - Pos = (UINT32)((1U << (Val - 1)) + GetBits(Sd, (UINT16)(Val - 1))); - } + Pos = Val; + if (Val > 1) { + Pos = (UINT32)((1U << (Val - 1)) + GetBits(Sd, (UINT16)(Val - 1))); + } - return Pos; + return Pos; } STATIC UINT16 ReadPTLen( - IN SCRATCH_DATA *Sd, - IN UINT16 nn, - IN UINT16 nbit, - IN UINT16 Special +IN SCRATCH_DATA *Sd, +IN UINT16 nn, +IN UINT16 nbit, +IN UINT16 Special ) /*++ @@ -403,76 +403,76 @@ BAD_TABLE - Table is corrupted. --*/ { - UINT16 Number; - UINT16 CharC; - UINT16 Index; - UINT32 Mask; + UINT16 Number; + UINT16 CharC; + UINT16 Index; + UINT32 Mask; - Number = (UINT16)GetBits(Sd, nbit); + Number = (UINT16)GetBits(Sd, nbit); - if ((Number > sizeof(Sd->mPTLen)) || (nn > sizeof(Sd->mPTLen))) { - // - // Fail if Number or nn is greater than size of mPTLen - // - return (UINT16)BAD_TABLE; - } + if ((Number > sizeof(Sd->mPTLen)) || (nn > sizeof(Sd->mPTLen))) { + // + // Fail if Number or nn is greater than size of mPTLen + // + return (UINT16)BAD_TABLE; + } - if (Number == 0) { - CharC = (UINT16)GetBits(Sd, nbit); + if (Number == 0) { + CharC = (UINT16)GetBits(Sd, nbit); - for (Index = 0; Index < 256; Index++) { - Sd->mPTTable[Index] = CharC; - } + for (Index = 0; Index < 256; Index++) { + Sd->mPTTable[Index] = CharC; + } - for (Index = 0; Index < nn; Index++) { - Sd->mPTLen[Index] = 0; - } + for (Index = 0; Index < nn; Index++) { + Sd->mPTLen[Index] = 0; + } - return 0; - } + return 0; + } - Index = 0; + Index = 0; - while (Index < Number) { - CharC = (UINT16)(Sd->mBitBuf >> (BITBUFSIZ - 3)); + while (Index < Number) { + CharC = (UINT16)(Sd->mBitBuf >> (BITBUFSIZ - 3)); - if (CharC == 7) { - Mask = 1U << (BITBUFSIZ - 1 - 3); - while (Mask & Sd->mBitBuf) { - Mask >>= 1; - CharC += 1; - } - } + if (CharC == 7) { + Mask = 1U << (BITBUFSIZ - 1 - 3); + while (Mask & Sd->mBitBuf) { + Mask >>= 1; + CharC += 1; + } + } - FillBuf(Sd, (UINT16)((CharC < 7) ? 3 : CharC - 3)); + FillBuf(Sd, (UINT16)((CharC < 7) ? 3 : CharC - 3)); - Sd->mPTLen[Index++] = (UINT8)CharC; + Sd->mPTLen[Index++] = (UINT8)CharC; - if (Index == Special) { - CharC = (UINT16)GetBits(Sd, 2); - while ((INT16)(--CharC) >= 0) { - if (Index >= sizeof(Sd->mPTLen)) { - // - // Fail if Index is greater than or equal to mPTLen - // - return (UINT16)BAD_TABLE; - } - Sd->mPTLen[Index++] = 0; - } - } - } + if (Index == Special) { + CharC = (UINT16)GetBits(Sd, 2); + while ((INT16)(--CharC) >= 0) { + if (Index >= sizeof(Sd->mPTLen)) { + // + // Fail if Index is greater than or equal to mPTLen + // + return (UINT16)BAD_TABLE; + } + Sd->mPTLen[Index++] = 0; + } + } + } - while (Index < nn) { - Sd->mPTLen[Index++] = 0; - } + while (Index < nn) { + Sd->mPTLen[Index++] = 0; + } - return MakeTable(Sd, nn, Sd->mPTLen, 8, Sd->mPTTable); + return MakeTable(Sd, nn, Sd->mPTLen, 8, Sd->mPTTable); } STATIC VOID ReadCLen( - SCRATCH_DATA *Sd +SCRATCH_DATA *Sd ) /*++ @@ -488,82 +488,82 @@ Returns: (VOID) --*/ { - UINT16 Number; - UINT16 CharC; - UINT16 Index; - UINT32 Mask; + UINT16 Number; + UINT16 CharC; + UINT16 Index; + UINT32 Mask; - Number = (UINT16)GetBits(Sd, CBIT); + Number = (UINT16)GetBits(Sd, CBIT); - if (Number == 0) { - CharC = (UINT16)GetBits(Sd, CBIT); + if (Number == 0) { + CharC = (UINT16)GetBits(Sd, CBIT); - for (Index = 0; Index < NC; Index++) { - Sd->mCLen[Index] = 0; - } + for (Index = 0; Index < NC; Index++) { + Sd->mCLen[Index] = 0; + } - for (Index = 0; Index < 4096; Index++) { - Sd->mCTable[Index] = CharC; - } + for (Index = 0; Index < 4096; Index++) { + Sd->mCTable[Index] = CharC; + } - return; - } + return; + } - Index = 0; - while (Index < Number) { - CharC = Sd->mPTTable[Sd->mBitBuf >> (BITBUFSIZ - 8)]; - if (CharC >= NT) { - Mask = 1U << (BITBUFSIZ - 1 - 8); + Index = 0; + while (Index < Number) { + CharC = Sd->mPTTable[Sd->mBitBuf >> (BITBUFSIZ - 8)]; + if (CharC >= NT) { + Mask = 1U << (BITBUFSIZ - 1 - 8); - do { - if (Mask & Sd->mBitBuf) { - CharC = Sd->mRight[CharC]; - } - else { - CharC = Sd->mLeft[CharC]; - } + do { + if (Mask & Sd->mBitBuf) { + CharC = Sd->mRight[CharC]; + } + else { + CharC = Sd->mLeft[CharC]; + } - Mask >>= 1; - } while (CharC >= NT); - } - // - // Advance what we have read - // - FillBuf(Sd, Sd->mPTLen[CharC]); + Mask >>= 1; + } while (CharC >= NT); + } + // + // Advance what we have read + // + FillBuf(Sd, Sd->mPTLen[CharC]); - if (CharC <= 2) { - if (CharC == 0) { - CharC = 1; - } - else if (CharC == 1) { - CharC = (UINT16)(GetBits(Sd, 4) + 3); - } - else if (CharC == 2) { - CharC = (UINT16)(GetBits(Sd, CBIT) + 20); - } + if (CharC <= 2) { + if (CharC == 0) { + CharC = 1; + } + else if (CharC == 1) { + CharC = (UINT16)(GetBits(Sd, 4) + 3); + } + else if (CharC == 2) { + CharC = (UINT16)(GetBits(Sd, CBIT) + 20); + } - while ((INT16)(--CharC) >= 0) { - Sd->mCLen[Index++] = 0; - } - } - else { - Sd->mCLen[Index++] = (UINT8)(CharC - 2); - } - } + while ((INT16)(--CharC) >= 0) { + Sd->mCLen[Index++] = 0; + } + } + else { + Sd->mCLen[Index++] = (UINT8)(CharC - 2); + } + } - while (Index < NC) { - Sd->mCLen[Index++] = 0; - } + while (Index < NC) { + Sd->mCLen[Index++] = 0; + } - MakeTable(Sd, NC, Sd->mCLen, 12, Sd->mCTable); + MakeTable(Sd, NC, Sd->mCLen, 12, Sd->mCTable); - return; + return; } STATIC UINT16 DecodeC( - SCRATCH_DATA *Sd +SCRATCH_DATA *Sd ) /*++ @@ -581,56 +581,56 @@ The value decoded. --*/ { - UINT16 Index2; - UINT32 Mask; + UINT16 Index2; + UINT32 Mask; - if (Sd->mBlockSize == 0) { - // - // Starting a new block - // - Sd->mBlockSize = (UINT16)GetBits(Sd, 16); - Sd->mBadTableFlag = ReadPTLen(Sd, NT, TBIT, 3); - if (Sd->mBadTableFlag != 0) { - return 0; - } + if (Sd->mBlockSize == 0) { + // + // Starting a new block + // + Sd->mBlockSize = (UINT16)GetBits(Sd, 16); + Sd->mBadTableFlag = ReadPTLen(Sd, NT, TBIT, 3); + if (Sd->mBadTableFlag != 0) { + return 0; + } - ReadCLen(Sd); + ReadCLen(Sd); - Sd->mBadTableFlag = ReadPTLen(Sd, MAXNP, Sd->mPBit, (UINT16)(-1)); - if (Sd->mBadTableFlag != 0) { - return 0; - } - } + Sd->mBadTableFlag = ReadPTLen(Sd, MAXNP, Sd->mPBit, (UINT16)(-1)); + if (Sd->mBadTableFlag != 0) { + return 0; + } + } - Sd->mBlockSize--; - Index2 = Sd->mCTable[Sd->mBitBuf >> (BITBUFSIZ - 12)]; + Sd->mBlockSize--; + Index2 = Sd->mCTable[Sd->mBitBuf >> (BITBUFSIZ - 12)]; - if (Index2 >= NC) { - Mask = 1U << (BITBUFSIZ - 1 - 12); + if (Index2 >= NC) { + Mask = 1U << (BITBUFSIZ - 1 - 12); - do { - if (Sd->mBitBuf & Mask) { - Index2 = Sd->mRight[Index2]; - } - else { - Index2 = Sd->mLeft[Index2]; - } + do { + if (Sd->mBitBuf & Mask) { + Index2 = Sd->mRight[Index2]; + } + else { + Index2 = Sd->mLeft[Index2]; + } - Mask >>= 1; - } while (Index2 >= NC); - } - // - // Advance what we have read - // - FillBuf(Sd, Sd->mCLen[Index2]); + Mask >>= 1; + } while (Index2 >= NC); + } + // + // Advance what we have read + // + FillBuf(Sd, Sd->mCLen[Index2]); - return Index2; + return Index2; } STATIC VOID Decode( - SCRATCH_DATA *Sd +SCRATCH_DATA *Sd ) /*++ @@ -646,66 +646,66 @@ Returns: (VOID) --*/ { - UINT16 BytesRemain; - UINT32 DataIdx; - UINT16 CharC; + UINT16 BytesRemain; + UINT32 DataIdx; + UINT16 CharC; - BytesRemain = (UINT16)(-1); + BytesRemain = (UINT16)(-1); - DataIdx = 0; + DataIdx = 0; - for (;;) { - CharC = DecodeC(Sd); - if (Sd->mBadTableFlag != 0) { - return; - } + for (;;) { + CharC = DecodeC(Sd); + if (Sd->mBadTableFlag != 0) { + return; + } - if (CharC < 256) { - // - // Process an Original character - // - if (Sd->mOutBuf >= Sd->mOrigSize) { - return; - } - else { - Sd->mDstBase[Sd->mOutBuf++] = (UINT8)CharC; - } - } - else { - // - // Process a Pointer - // - CharC = (UINT16)(CharC - (UINT8_MAX + 1 - THRESHOLD)); + if (CharC < 256) { + // + // Process an Original character + // + if (Sd->mOutBuf >= Sd->mOrigSize) { + return; + } + else { + Sd->mDstBase[Sd->mOutBuf++] = (UINT8)CharC; + } + } + else { + // + // Process a Pointer + // + CharC = (UINT16)(CharC - (UINT8_MAX + 1 - THRESHOLD)); - BytesRemain = CharC; + BytesRemain = CharC; - DataIdx = Sd->mOutBuf - DecodeP(Sd) - 1; + DataIdx = Sd->mOutBuf - DecodeP(Sd) - 1; - // Check to prevent possible heap corruption - if (DataIdx >= Sd->mOrigSize - BytesRemain) { - Sd->mBadTableFlag = 1; - return; - } + // Check to prevent possible heap corruption + if (DataIdx >= Sd->mOrigSize - BytesRemain) { + Sd->mBadTableFlag = 1; + return; + } - BytesRemain--; - while ((INT16)(BytesRemain) >= 0) { - Sd->mDstBase[Sd->mOutBuf++] = Sd->mDstBase[DataIdx++]; - if (Sd->mOutBuf >= Sd->mOrigSize) { - return; - } + BytesRemain--; + while ((INT16)(BytesRemain) >= 0) { + Sd->mDstBase[Sd->mOutBuf++] = Sd->mDstBase[DataIdx++]; + if (Sd->mOutBuf >= Sd->mOrigSize) { + return; + } - BytesRemain--; - } - } - } + BytesRemain--; + } + } + } } EFI_STATUS GetInfo( - IN const VOID *Source, - IN UINT32 SrcSize, - OUT UINT32 *DstSize, - OUT UINT32 *ScratchSize +IN const VOID *Source, +IN UINT32 SrcSize, +OUT UINT32 *DstSize, +OUT UINT32 *ScratchSize ) /*++ @@ -727,28 +727,28 @@ EFI_INVALID_PARAMETER - The source data is corrupted --*/ { - const UINT8 *Src; + const UINT8 *Src; - *ScratchSize = sizeof(SCRATCH_DATA); + *ScratchSize = sizeof(SCRATCH_DATA); - Src = Source; - if (SrcSize < 8) { - return EFI_INVALID_PARAMETER; - } + Src = Source; + if (SrcSize < 8) { + return EFI_INVALID_PARAMETER; + } - *DstSize = Src[4] + (Src[5] << 8) + (Src[6] << 16) + (Src[7] << 24); - return EFI_SUCCESS; + *DstSize = Src[4] + (Src[5] << 8) + (Src[6] << 16) + (Src[7] << 24); + return EFI_SUCCESS; } EFI_STATUS Decompress( - IN const VOID *Source, - IN UINT32 SrcSize, - IN OUT VOID *Destination, - IN UINT32 DstSize, - IN OUT VOID *Scratch, - IN UINT32 ScratchSize, - IN UINT8 Version +IN const VOID *Source, +IN UINT32 SrcSize, +IN OUT VOID *Destination, +IN UINT32 DstSize, +IN OUT VOID *Scratch, +IN UINT32 ScratchSize, +IN UINT8 Version ) /*++ @@ -775,104 +775,104 @@ EFI_INVALID_PARAMETER - The source data is corrupted --*/ { - UINT32 Index; - UINT32 CompSize; - UINT32 OrigSize; - EFI_STATUS Status; - SCRATCH_DATA *Sd; - const UINT8 *Src; - UINT8 *Dst; + UINT32 Index; + UINT32 CompSize; + UINT32 OrigSize; + EFI_STATUS Status; + SCRATCH_DATA *Sd; + const UINT8 *Src; + UINT8 *Dst; - Status = EFI_SUCCESS; - Src = Source; - Dst = Destination; + Status = EFI_SUCCESS; + Src = Source; + Dst = Destination; - if (ScratchSize < sizeof(SCRATCH_DATA)) { - return EFI_INVALID_PARAMETER; - } + if (ScratchSize < sizeof(SCRATCH_DATA)) { + return EFI_INVALID_PARAMETER; + } - Sd = (SCRATCH_DATA *)Scratch; + Sd = (SCRATCH_DATA *)Scratch; - if (SrcSize < 8) { - return EFI_INVALID_PARAMETER; - } + if (SrcSize < 8) { + return EFI_INVALID_PARAMETER; + } - CompSize = Src[0] + (Src[1] << 8) + (Src[2] << 16) + (Src[3] << 24); - OrigSize = Src[4] + (Src[5] << 8) + (Src[6] << 16) + (Src[7] << 24); + CompSize = Src[0] + (Src[1] << 8) + (Src[2] << 16) + (Src[3] << 24); + OrigSize = Src[4] + (Src[5] << 8) + (Src[6] << 16) + (Src[7] << 24); - // - // If compressed file size is 0, return - // - if (OrigSize == 0) { - return Status; - } + // + // If compressed file size is 0, return + // + if (OrigSize == 0) { + return Status; + } - if (SrcSize < CompSize + 8) { - return EFI_INVALID_PARAMETER; - } + if (SrcSize < CompSize + 8) { + return EFI_INVALID_PARAMETER; + } - if (DstSize != OrigSize) { - return EFI_INVALID_PARAMETER; - } + if (DstSize != OrigSize) { + return EFI_INVALID_PARAMETER; + } - Src = Src + 8; + Src = Src + 8; - for (Index = 0; Index < sizeof(SCRATCH_DATA); Index++) { - ((UINT8 *)Sd)[Index] = 0; - } - // - // The length of the field 'Position Set Code Length Array Size' in Block Header. - // For EFI 1.1 de/compression algorithm(Version 1), mPBit = 4 - // For Tiano de/compression algorithm(Version 2), mPBit = 5 - // - switch (Version) { - case 1: - Sd->mPBit = 4; - break; + for (Index = 0; Index < sizeof(SCRATCH_DATA); Index++) { + ((UINT8 *)Sd)[Index] = 0; + } + // + // The length of the field 'Position Set Code Length Array Size' in Block Header. + // For EFI 1.1 de/compression algorithm(Version 1), mPBit = 4 + // For Tiano de/compression algorithm(Version 2), mPBit = 5 + // + switch (Version) { + case 1: + Sd->mPBit = 4; + break; - case 2: - Sd->mPBit = 5; - break; + case 2: + Sd->mPBit = 5; + break; - default: - // - // Currently, only have 2 versions - // - return EFI_INVALID_PARAMETER; - } + default: + // + // Currently, only have 2 versions + // + return EFI_INVALID_PARAMETER; + } - Sd->mSrcBase = (UINT8*)Src; - Sd->mDstBase = Dst; - Sd->mCompSize = CompSize; - Sd->mOrigSize = OrigSize; + Sd->mSrcBase = (UINT8*)Src; + Sd->mDstBase = Dst; + Sd->mCompSize = CompSize; + Sd->mOrigSize = OrigSize; - // - // Fill the first BITBUFSIZ bits - // - FillBuf(Sd, BITBUFSIZ); + // + // Fill the first BITBUFSIZ bits + // + FillBuf(Sd, BITBUFSIZ); - // - // Decompress it - // - Decode(Sd); + // + // Decompress it + // + Decode(Sd); - if (Sd->mBadTableFlag != 0) { - // - // Something wrong with the source - // - Status = EFI_INVALID_PARAMETER; - } + if (Sd->mBadTableFlag != 0) { + // + // Something wrong with the source + // + Status = EFI_INVALID_PARAMETER; + } - return Status; + return Status; } EFI_STATUS EFIAPI EfiTianoGetInfo( - IN const VOID *Source, - IN UINT32 SrcSize, - OUT UINT32 *DstSize, - OUT UINT32 *ScratchSize +IN const VOID *Source, +IN UINT32 SrcSize, +OUT UINT32 *DstSize, +OUT UINT32 *ScratchSize ) /*++ @@ -895,23 +895,23 @@ EFI_INVALID_PARAMETER - The source data is corrupted --*/ { - return GetInfo( - Source, - SrcSize, - DstSize, - ScratchSize - ); + return GetInfo( + Source, + SrcSize, + DstSize, + ScratchSize + ); } EFI_STATUS EFIAPI EfiDecompress( - IN const VOID *Source, - IN UINT32 SrcSize, - IN OUT VOID *Destination, - IN UINT32 DstSize, - IN OUT VOID *Scratch, - IN UINT32 ScratchSize +IN const VOID *Source, +IN UINT32 SrcSize, +IN OUT VOID *Destination, +IN UINT32 DstSize, +IN OUT VOID *Scratch, +IN UINT32 ScratchSize ) /*++ @@ -936,29 +936,29 @@ EFI_INVALID_PARAMETER - The source data is corrupted --*/ { - // - // For EFI 1.1 de/compression algorithm, the version is 1. - // - return Decompress( - Source, - SrcSize, - Destination, - DstSize, - Scratch, - ScratchSize, - 1 - ); + // + // For EFI 1.1 de/compression algorithm, the version is 1. + // + return Decompress( + Source, + SrcSize, + Destination, + DstSize, + Scratch, + ScratchSize, + 1 + ); } EFI_STATUS EFIAPI TianoDecompress( - IN const VOID *Source, - IN UINT32 SrcSize, - IN OUT VOID *Destination, - IN UINT32 DstSize, - IN OUT VOID *Scratch, - IN UINT32 ScratchSize +IN const VOID *Source, +IN UINT32 SrcSize, +IN OUT VOID *Destination, +IN UINT32 DstSize, +IN OUT VOID *Scratch, +IN UINT32 ScratchSize ) /*++ @@ -983,16 +983,16 @@ EFI_INVALID_PARAMETER - The source data is corrupted --*/ { - // - // For Tiano de/compression algorithm, the version is 2. - // - return Decompress( - Source, - SrcSize, - Destination, - DstSize, - Scratch, - ScratchSize, - 2 - ); + // + // For Tiano de/compression algorithm, the version is 2. + // + return Decompress( + Source, + SrcSize, + Destination, + DstSize, + Scratch, + ScratchSize, + 2 + ); } diff --git a/Tiano/EfiTianoDecompress.h b/Tiano/EfiTianoDecompress.h index fe0eba5..f6efd6e 100644 --- a/Tiano/EfiTianoDecompress.h +++ b/Tiano/EfiTianoDecompress.h @@ -21,8 +21,8 @@ Providing both EFI and Tiano decompress algorithms. --*/ -#ifndef _EFITIANODECOMPRESS_H_ -#define _EFITIANODECOMPRESS_H_ +#ifndef EFITIANODECOMPRESS_H +#define EFITIANODECOMPRESS_H #include #include @@ -32,109 +32,107 @@ Providing both EFI and Tiano decompress algorithms. extern "C" { #endif - typedef struct { - UINT32 CompSize; - UINT32 OrigSize; - } EFI_TIANO_HEADER; +typedef struct EFI_TIANO_HEADER_ { + UINT32 CompSize; + UINT32 OrigSize; +} EFI_TIANO_HEADER; - EFI_STATUS - EfiTianoGetInfo( - IN const VOID *Source, - IN UINT32 SrcSize, - OUT UINT32 *DstSize, - OUT UINT32 *ScratchSize - ) - /*++ +EFI_STATUS +EFIAPI +EfiTianoGetInfo( + const VOID *Source, + UINT32 SrcSize, + UINT32 *DstSize, + UINT32 *ScratchSize + ) +/*++ - Routine Description: +Routine Description: - The implementation is same as that of EFI_DECOMPRESS_PROTOCOL.GetInfo(). +The implementation is same as that of EFI_DECOMPRESS_PROTOCOL.GetInfo(). - Arguments: +Arguments: - This - The protocol instance pointer - Source - The source buffer containing the compressed data. - SrcSize - The size of source buffer - DstSize - The size of destination buffer. - ScratchSize - The size of scratch buffer. +Source - The source buffer containing the compressed data. +SrcSize - The size of source buffer +DstSize - The size of destination buffer. +ScratchSize - The size of scratch buffer. - Returns: +Returns: - EFI_SUCCESS - The size of destination buffer and the size of scratch buffer are successfully retrieved. - EFI_INVALID_PARAMETER - The source data is corrupted +EFI_SUCCESS - The size of destination buffer and the size of scratch buffer are successfully retrieved. +EFI_INVALID_PARAMETER - The source data is corrupted - --*/ - ; +--*/ +; - EFI_STATUS - EFIAPI - EfiDecompress( - IN const VOID *Source, - IN UINT32 SrcSize, - IN OUT VOID *Destination, - IN UINT32 DstSize, - IN OUT VOID *Scratch, - IN UINT32 ScratchSize - ) - /*++ +EFI_STATUS +EFIAPI +EfiDecompress( + const VOID *Source, + UINT32 SrcSize, + VOID *Destination, + UINT32 DstSize, + VOID *Scratch, + UINT32 ScratchSize + ); +/*++ - Routine Description: +Routine Description: - The implementation is same as that of EFI_DECOMPRESS_PROTOCOL.Decompress(). +The implementation is same as that of EFI_DECOMPRESS_PROTOCOL.Decompress(). - Arguments: +Arguments: - This - The protocol instance pointer - Source - The source buffer containing the compressed data. - SrcSize - The size of source buffer - Destination - The destination buffer to store the decompressed data - DstSize - The size of destination buffer. - Scratch - The buffer used internally by the decompress routine. This buffer is needed to store intermediate data. - ScratchSize - The size of scratch buffer. +Source - The source buffer containing the compressed data. +SrcSize - The size of source buffer +Destination - The destination buffer to store the decompressed data +DstSize - The size of destination buffer. +Scratch - The buffer used internally by the decompress routine. This buffer is needed to store intermediate data. +ScratchSize - The size of scratch buffer. - Returns: +Returns: - EFI_SUCCESS - Decompression is successful - EFI_INVALID_PARAMETER - The source data is corrupted +EFI_SUCCESS - Decompression is successful +EFI_INVALID_PARAMETER - The source data is corrupted - --*/ - ; +--*/ +; - EFI_STATUS - EFIAPI - TianoDecompress( - IN const VOID *Source, - IN UINT32 SrcSize, - IN OUT VOID *Destination, - IN UINT32 DstSize, - IN OUT VOID *Scratch, - IN UINT32 ScratchSize - ) - /*++ +EFI_STATUS +EFIAPI +TianoDecompress( + const VOID *Source, + UINT32 SrcSize, + VOID *Destination, + UINT32 DstSize, + VOID *Scratch, + UINT32 ScratchSize + ) +/*++ - Routine Description: +Routine Description: - The implementation is same as that of EFI_TIANO_DECOMPRESS_PROTOCOL.Decompress(). +The implementation is same as that of EFI_TIANO_DECOMPRESS_PROTOCOL.Decompress(). - Arguments: +Arguments: - This - The protocol instance pointer - Source - The source buffer containing the compressed data. - SrcSize - The size of source buffer - Destination - The destination buffer to store the decompressed data - DstSize - The size of destination buffer. - Scratch - The buffer used internally by the decompress routine. This buffer is needed to store intermediate data. - ScratchSize - The size of scratch buffer. +Source - The source buffer containing the compressed data. +SrcSize - The size of source buffer +Destination - The destination buffer to store the decompressed data +DstSize - The size of destination buffer. +Scratch - The buffer used internally by the decompress routine. This buffer is needed to store intermediate data. +ScratchSize - The size of scratch buffer. - Returns: +Returns: - EFI_SUCCESS - Decompression is successful - EFI_INVALID_PARAMETER - The source data is corrupted +EFI_SUCCESS - Decompression is successful +EFI_INVALID_PARAMETER - The source data is corrupted - --*/ - ; +--*/ +; #ifdef __cplusplus } #endif -#endif +#endif // EFITIANODECOMPRESS_H diff --git a/basetypes.h b/basetypes.h index 3c07309..04c65b2 100644 --- a/basetypes.h +++ b/basetypes.h @@ -16,6 +16,7 @@ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. #include #include +#include typedef uint8_t BOOLEAN; typedef int8_t INT8; @@ -28,7 +29,7 @@ typedef int64_t INT64; typedef uint64_t UINT64; typedef char CHAR8; typedef uint16_t CHAR16; -typedef unsigned int UINTN; +typedef size_t UINTN; #define CONST const #define VOID void diff --git a/ffsengine.cpp b/ffsengine.cpp index 2ea6bb0..ea7c172 100644 --- a/ffsengine.cpp +++ b/ffsengine.cpp @@ -2741,7 +2741,13 @@ UINT8 FfsEngine::decompress(const QByteArray & compressedData, const UINT8 compr else if (algorithm) *algorithm = COMPRESSION_ALGORITHM_TIANO; - decompressedData = QByteArray((const char*)decompressed, decompressedSize); + if (decompressedSize > INT32_MAX) { + delete[] decompressed; + delete[] scratch; + return ERR_STANDARD_DECOMPRESSION_FAILED; + } + + decompressedData = QByteArray((const char*)decompressed, (int)decompressedSize); delete[] decompressed; delete[] scratch; @@ -2778,7 +2784,8 @@ UINT8 FfsEngine::decompress(const QByteArray & compressedData, const UINT8 compr } // Decompress section data again - if (ERR_SUCCESS != LzmaDecompress(data, dataSize, decompressed)) { + if (ERR_SUCCESS != LzmaDecompress(data, dataSize, decompressed) + || decompressedSize > INT32_MAX) { if (algorithm) *algorithm = COMPRESSION_ALGORITHM_UNKNOWN; delete[] decompressed; @@ -2787,13 +2794,17 @@ UINT8 FfsEngine::decompress(const QByteArray & compressedData, const UINT8 compr else { if (algorithm) *algorithm = COMPRESSION_ALGORITHM_IMLZMA; - decompressedData = QByteArray((const char*)decompressed, decompressedSize); + decompressedData = QByteArray((const char*)decompressed, (int)decompressedSize); } } else { + if (decompressedSize > INT32_MAX) { + delete[] decompressed; + return ERR_CUSTOMIZED_DECOMPRESSION_FAILED; + } if (algorithm) *algorithm = COMPRESSION_ALGORITHM_LZMA; - decompressedData = QByteArray((const char*)decompressed, decompressedSize); + decompressedData = QByteArray((const char*)decompressed, (int)decompressedSize); } delete[] decompressed;