From a5ce9ab3d966b940a88fa92088d44a5872d683a0 Mon Sep 17 00:00:00 2001 From: Alex Matrosov Date: Sun, 29 Apr 2018 22:38:54 -0700 Subject: [PATCH] bugfix --- LZMA/LzmaCompress.c | 106 +- LZMA/LzmaCompress.h | 4 +- LZMA/LzmaDecompress.c | 90 +- LZMA/LzmaDecompress.h | 8 +- Tiano/EfiTianoCompress.c | 2289 +++++++++++----------- Tiano/EfiTianoCompress.h | 125 +- Tiano/EfiTianoCompressLegacy.c | 3317 ++++++++++++++++---------------- Tiano/EfiTianoDecompress.c | 1044 +++++----- Tiano/EfiTianoDecompress.h | 55 +- UEFIPatch/patches.txt | 9 +- ffsengine.h | 1 + types.cpp | 2 + types.h | 3 +- uefitool.cpp | 16 +- uefitool.h | 1 + uefitool.ui | 19 +- 16 files changed, 3575 insertions(+), 3514 deletions(-) diff --git a/LZMA/LzmaCompress.c b/LZMA/LzmaCompress.c index 622ca86..78c04a3 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 }; @@ -34,76 +34,76 @@ static ICompressProgress g_ProgressCallback = { &OnProgress }; STATIC UINT64 EFIAPI -RShiftU64( -UINT64 Operand, -UINT32 Count +RShiftU64 ( + 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 EFIAPI LzmaCompress( -CONST UINT8 *Source, -UINT32 SourceSize, -UINT8 *Destination, -UINT32 *DestinationSize + CONST UINT8 *Source, + UINTN SourceSize, + UINT8 *Destination, + UINTN *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 = destLen; - return ERR_BUFFER_TOO_SMALL; - } + if (*DestinationSize < destLen) + { + *DestinationSize = destLen; + return ERR_BUFFER_TOO_SMALL; + } - LzmaEncProps_Init(&props); - props.dictSize = LZMA_DICTIONARY_SIZE; - props.level = 9; - props.fb = 273; + LzmaEncProps_Init(&props); + 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, + SourceSize, + &props, + (UINT8*)Destination, + &propsSize, + props.writeEndMark, + &g_ProgressCallback, + &SzAllocForLzma, + &SzAllocForLzma); - *DestinationSize = destLen + LZMA_HEADER_SIZE; + *DestinationSize = destLen + LZMA_HEADER_SIZE; - SetEncodedSizeOfBuf((UINT64)SourceSize, Destination); + SetEncodedSizeOfBuf(SourceSize, Destination); - 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/LzmaCompress.h b/LZMA/LzmaCompress.h index 5767d1e..20bc427 100644 --- a/LZMA/LzmaCompress.h +++ b/LZMA/LzmaCompress.h @@ -28,9 +28,9 @@ extern "C" { EFIAPI LzmaCompress( const UINT8 *Source, - UINT32 SourceSize, + UINTN SourceSize, UINT8 *Destination, - UINT32 *DestinationSize + UINTN *DestinationSize ); #ifdef __cplusplus diff --git a/LZMA/LzmaDecompress.c b/LZMA/LzmaDecompress.c index 34e176d..2f97278 100644 --- a/LZMA/LzmaDecompress.c +++ b/LZMA/LzmaDecompress.c @@ -20,11 +20,11 @@ WITHWARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. UINT64 EFIAPI LShiftU64( -UINT64 Operand, -UINT32 Count + UINT64 Operand, + UINT32 Count ) { - return Operand << Count; + return Operand << Count; } static void * AllocForLzma(void *p, size_t size) { (void)p; return malloc(size); } @@ -40,18 +40,18 @@ Get the size of the uncompressed buffer by parsing EncodeData header. */ UINT64 GetDecodedSizeOfBuf( -UINT8 *EncodedData + 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; } // @@ -88,19 +88,15 @@ buffer was returned ScratchSize. INT32 EFIAPI LzmaGetInfo( -CONST VOID *Source, -UINT32 SourceSize, -UINT32 *DestinationSize + CONST VOID *Source, + UINTN SourceSize, + UINTN *DestinationSize ) { - UInt64 DecodedSize; + ASSERT(SourceSize >= LZMA_HEADER_SIZE); (void)SourceSize; - ASSERT(SourceSize >= LZMA_HEADER_SIZE); (void)SourceSize; - - DecodedSize = GetDecodedSizeOfBuf((UINT8*)Source); - - *DestinationSize = (UINT32)DecodedSize; - return ERR_SUCCESS; + *DestinationSize = (UINTN)GetDecodedSizeOfBuf((UINT8*)Source); + return ERR_SUCCESS; } /* @@ -125,35 +121,35 @@ The source buffer specified by Source is corrupted INT32 EFIAPI LzmaDecompress( -CONST VOID *Source, -UINT32 SourceSize, -VOID *Destination + CONST VOID *Source, + UINTN 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 d8e0fae..78d4ac0 100644 --- a/LZMA/LzmaDecompress.h +++ b/LZMA/LzmaDecompress.h @@ -61,8 +61,8 @@ extern "C" { EFIAPI LzmaGetInfo( const VOID *Source, - UINT32 SourceSize, - UINT32 *DestinationSize + UINTN SourceSize, + UINTN *DestinationSize ); /* @@ -88,8 +88,8 @@ extern "C" { EFIAPI LzmaDecompress( const VOID *Source, - UINT32 SourceSize, - VOID *Destination + UINTN SourceSize, + VOID *Destination ); #ifdef __cplusplus diff --git a/Tiano/EfiTianoCompress.c b/Tiano/EfiTianoCompress.c index 4f70fa5..31c0e37 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,177 +62,163 @@ UINT8 gPBIT = 4; // STATIC -VOID +VOID PutDword( - IN UINT32 Data - ); + IN UINT32 Data +); STATIC -EFI_STATUS -AllocateMemory ( - ); +EFI_STATUS +AllocateMemory(VOID); STATIC VOID -FreeMemory ( - ); +FreeMemory(VOID); -STATIC -VOID -InitSlide ( - ); +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 -Split ( - IN NODE Old - ); +STATIC +VOID +MakeChild( + IN NODE q, + IN UINT8 c, + IN NODE r +); -STATIC -VOID -InsertNode ( - ); - -STATIC -VOID -DeleteNode ( - ); +STATIC +VOID +Split( + IN NODE Old +); -STATIC -VOID -GetNextMatch ( - ); - -STATIC -EFI_STATUS -Encode ( - ); +STATIC +VOID +InsertNode(VOID); -STATIC -VOID -CountTFreq ( - ); +STATIC +VOID +DeleteNode(VOID); -STATIC -VOID -WritePTLen ( - IN INT32 n, - IN INT32 nbit, - IN INT32 Special - ); +STATIC +VOID +GetNextMatch(VOID); -STATIC -VOID -WriteCLen ( - ); - -STATIC -VOID -EncodeC ( - IN INT32 c - ); +STATIC +EFI_STATUS +Encode(VOID); -STATIC -VOID -EncodeP ( - IN UINT32 p - ); +STATIC +VOID +CountTFreq(VOID); -STATIC -VOID -SendBlock ( - ); - -STATIC -VOID -Output ( - IN UINT32 c, - IN UINT32 p - ); +STATIC +VOID +WritePTLen( + IN INT32 n, + IN INT32 nbit, + IN INT32 Special +); -STATIC -VOID -HufEncodeStart ( - ); - -STATIC -VOID -HufEncodeEnd ( - ); - -STATIC -VOID -MakeCrcTable ( - ); - -STATIC -VOID -PutBits ( - IN INT32 n, - IN UINT32 x - ); - -STATIC -INT32 -FreadCrc ( - OUT UINT8 *p, - IN INT32 n - ); - -STATIC -VOID -InitPutBits ( - ); - -STATIC -VOID -CountLen ( - IN INT32 i - ); +STATIC +VOID +WriteCLen(VOID); -STATIC -VOID -MakeLen ( - IN INT32 Root - ); - -STATIC -VOID -DownHeap ( - IN INT32 i - ); +STATIC +VOID +EncodeC( + IN INT32 c +); -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 +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[] +); // @@ -248,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; @@ -259,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: @@ -277,88 +263,89 @@ 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; - - // - // 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; + EFI_STATUS Status = EFI_SUCCESS; - PutDword(0L); - PutDword(0L); - - MakeCrcTable (); + // + // Initializations + // + mBufSiz = 0; + mBuf = NULL; + mText = NULL; + mLevel = NULL; + mChildCount = NULL; + mPosition = NULL; + mParent = NULL; + mPrev = NULL; + mNext = NULL; + gPBIT = 4; - 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); + mSrc = (UINT8*)SrcBuffer; + mSrcUpperLimit = mSrc + SrcSize; + mDst = DstBuffer; + mDstUpperLimit = mDst + *DstSize; - // - // Return - // - - if (mCompSize + 1 + 8 > *DstSize) { - *DstSize = mCompSize + 1 + 8; - return EFI_BUFFER_TOO_SMALL; - } else { - *DstSize = mCompSize + 1 + 8; - return EFI_SUCCESS; - } + 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; + } } 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 ) /*++ @@ -382,118 +369,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: @@ -503,416 +490,421 @@ Returns: --*/ { - UINT32 i; - - mText = malloc (WNDSIZ * 2 + MAXMATCH); - for (i = 0 ; i < WNDSIZ * 2 + MAXMATCH; i ++) { - mText[i] = 0; - } + UINT32 i; - 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; + mText = malloc(WNDSIZ * 2 + MAXMATCH); + if (NULL == mText) + 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; } VOID -FreeMemory () +FreeMemory() /*++ Routine Description: Called when compression is completed to free memory previously allocated. - + Arguments: (VOID) Returns: (VOID) --*/ { - 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 (mText) { + free(mText); + } - return; + 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; } -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 ( - NODE Old - ) + IN 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; + 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; - 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: @@ -926,22 +918,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: @@ -951,323 +943,338 @@ 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(); - - HufEncodeStart(); + InitSlide(); - 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; + 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; } -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: @@ -1283,89 +1290,90 @@ 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: @@ -1375,51 +1383,53 @@ Routine Description: Argments: n - the rightmost n bits of the data is used - x - the data + x - the data Returns: (VOID) --*/ { - UINT8 Temp; - - if (n < mBitCount) { - mSubBitBuf |= x << (mBitCount -= n); - } else { - - Temp = (UINT8)(mSubBitBuf | (x >> (n -= mBitCount))); - if (mDst < mDstUpperLimit) { - *mDst++ = Temp; - } - mCompSize++; + UINT8 Temp; - 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 < 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); + } + } } -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 @@ -1428,156 +1438,157 @@ 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 @@ -1588,101 +1599,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; - - // - // make tree, calculate len[], return root - // + INT32 i, j, k, Avail; - 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; + // + // 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; } diff --git a/Tiano/EfiTianoCompress.h b/Tiano/EfiTianoCompress.h index e5c2fb9..b317cfd 100644 --- a/Tiano/EfiTianoCompress.h +++ b/Tiano/EfiTianoCompress.h @@ -32,85 +32,82 @@ 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( - CONST VOID *SrcBuffer, - UINT32 SrcSize, - VOID *DstBuffer, - UINT32 *DstSize - ) - ; + --*/ + EFI_STATUS + TianoCompress( + IN CONST VOID *SrcBuffer, + IN UINT32 SrcSize, + IN VOID *DstBuffer, + IN OUT 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( - CONST VOID *SrcBuffer, - UINT32 SrcSize, - VOID *DstBuffer, - UINT32 *DstSize - ) - ; - EFI_STATUS - EfiCompressLegacy( - CONST VOID *SrcBuffer, - UINT32 SrcSize, - VOID *DstBuffer, - UINT32 *DstSize - ) - ; + --*/ + 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 + ); #ifdef __cplusplus } diff --git a/Tiano/EfiTianoCompressLegacy.c b/Tiano/EfiTianoCompressLegacy.c index 7142ca8..9aed6f1 100644 --- a/Tiano/EfiTianoCompressLegacy.c +++ b/Tiano/EfiTianoCompressLegacy.c @@ -71,190 +71,190 @@ typedef INT32 NODE; // STATIC - 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[] +VOID +PutDword( + UINT32 Data ); STATIC - INT32 - MakeTree ( - INT32 NParm, - UINT16 FreqParm[], - UINT8 LenParm[ ], - UINT16 CodeParm[] +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[] ); // @@ -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,1550 +309,1573 @@ 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); - for (Index = 0; Index < WNDSIZ * 2 + MAXMATCH; Index++) { - mText[Index] = 0; - } + mText = malloc(WNDSIZ * 2 + MAXMATCH); + if (NULL == mText) + 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)); + for (Index = 0; Index < WNDSIZ * 2 + MAXMATCH; Index++) { + mText[Index] = 0; + } - mBufSiz = BLKSIZ; - mBuf = malloc (mBufSiz); - while (mBuf == NULL) { - mBufSiz = (mBufSiz / 10U) * 9U; - if (mBufSiz < 4 * 1024U) { - 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)); - mBuf = malloc (mBufSiz); - } + mBufSiz = BLKSIZ; + mBuf = malloc(mBufSiz); + while (mBuf == NULL) { + mBufSiz = (mBufSiz / 10U) * 9U; + if (mBufSiz < 4 * 1024U) { + return EFI_OUT_OF_RESOURCES; + } - mBuf[0] = 0; + mBuf = malloc(mBufSiz); + } - return EFI_SUCCESS; + mBuf[0] = 0; + + return EFI_SUCCESS; } VOID - FreeMemory ( - VOID - ) - /*++ - - Routine Description: - - Called when compression is completed to free memory previously allocated. - - Arguments: (VOID) - - Returns: (VOID) - - --*/ -{ - if (mText != NULL) { - free (mText); - } - - if (mLevel != NULL) { - free (mLevel); - } - - if (mChildCount != NULL) { - free (mChildCount); - } - - if (mPosition != NULL) { - free (mPosition); - } - - if (mParent != NULL) { - free (mParent); - } - - if (mPrev != NULL) { - free (mPrev); - } - - if (mNext != NULL) { - free (mNext); - } - - if (mBuf != NULL) { - free (mBuf); - } - - return ; -} - -STATIC - VOID - InitSlide ( - VOID - ) - /*++ - - Routine Description: - - Initialize String Info Log data structures - - Arguments: (VOID) - - Returns: (VOID) - - --*/ -{ - 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 * 2; Index++) { - mParent[Index] = NIL; - } - - 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; - } -} - -STATIC - NODE - Child ( - NODE NodeQ, - UINT8 CharC - ) - /*++ - - Routine Description: - - Find child node given the parent node and the edge character - - Arguments: - - NodeQ - the parent node - CharC - the edge character - - Returns: - - The child node (NIL if not found) - - --*/ -{ - NODE NodeR; - - NodeR = mNext[HASH (NodeQ, CharC)]; - // - // sentinel - // - mParent[NIL] = NodeQ; - while (mParent[NodeR] != NodeQ) { - NodeR = mNext[NodeR]; - } - - return NodeR; -} - -STATIC - VOID - MakeChild ( - NODE Parent, - UINT8 CharC, - NODE Child - ) - /*++ - - Routine Description: - - Create a new child for a given parent node. - - Arguments: - - Parent - the parent node - CharC - the edge character - Child - the child node - - Returns: (VOID) - - --*/ -{ - 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]++; -} - -STATIC - VOID - Split ( - NODE Old - ) - /*++ - - Routine Description: - - Split a node. - - Arguments: - - Old - the node to split - - Returns: (VOID) - - --*/ -{ - 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); -} - -STATIC - VOID - InsertNode ( - VOID - ) - /*++ - - Routine Description: - - Insert string info for current position into the String Info Log - - Arguments: (VOID) - - Returns: (VOID) - - --*/ -{ - 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]; - } - - while (mLevel[NodeQ] >= mMatchLen) { - NodeR = NodeQ; - NodeQ = mParent[NodeQ]; - } - - 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 ; - } - - 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; - } - - t1 = &mText[mPos + mMatchLen]; - t2 = &mText[mMatchPos + mMatchLen]; - while (mMatchLen < Index2) { - if (*t1 != *t2) { - Split (NodeR); - return ; - } - - mMatchLen++; - t1++; - t2++; - } - - if (mMatchLen >= MAXMATCH) { - break; - } - - mPosition[NodeR] = mPos; - NodeQ = NodeR; - NodeR = Child (NodeQ, *t1); - if (NodeR == NIL) { - MakeChild (NodeQ, *t1, mPos); - return ; - } - - 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; - - // - // Special usage of 'next' - // - mNext[NodeR] = mPos; - -} - -STATIC - VOID - DeleteNode ( - VOID - ) - /*++ - - Routine Description: - - Delete outdated string info. (The Usage of PERC_FLAG - ensures a clean deletion) - - Arguments: (VOID) - - Returns: (VOID) - - --*/ -{ - NODE NodeQ; - NODE NodeR; - NODE NodeS; - NODE NodeT; - NODE NodeU; - - 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 ; - } - - mChildCount[NodeR]--; - if (mChildCount[NodeR] > 1) { - return ; - } - - 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; - } - - if (NodeU > NodeS) { - NodeS = NodeU; - } - - mPosition[NodeQ] = (NODE) (NodeS | WNDSIZ); - NodeQ = mParent[NodeQ]; - NodeU = mPosition[NodeQ]; - } - - if (NodeQ < (NODE) WNDSIZ) { - if (NodeU >= mPos) { - NodeU -= WNDSIZ; - } - - if (NodeU > NodeS) { - NodeS = NodeU; - } - - 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; -} - -STATIC - VOID - GetNextMatch ( - VOID - ) - /*++ - - Routine Description: - - Advance the current position (read new data if needed). - Delete outdated string info. Find a match string for current position. - - Arguments: (VOID) - - Returns: (VOID) - - --*/ -{ - 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; - } - - DeleteNode (); - InsertNode (); -} - -STATIC - INT32 - Encode ( - VOID - ) - /*++ - - Routine Description: - - The mac controlling routine for compression process. - - Arguments: (VOID) - - Returns: - - EFI_SUCCESS - The compression is successful - EFI_OUT_0F_RESOURCES - Not enough memory for compression process - - --*/ -{ - INT32 Status; - INT32 LastMatchLen; - NODE LastMatchPos; - - Status = AllocateMemory (); - if (Status) { - FreeMemory (); - return Status; - } - - InitSlide (); - - 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 { - - 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; - } - } - } - - HufEncodeEnd (); - FreeMemory (); - return EFI_SUCCESS; -} - -STATIC - VOID - CountTFreq ( - VOID - ) - /*++ - - Routine Description: - - Count the frequencies for the Extra Set - - Arguments: (VOID) - - Returns: (VOID) - - --*/ -{ - INT32 Index; - INT32 Index3; - INT32 Number; - INT32 Count; - - for (Index = 0; Index < NT; Index++) { - mTFreq[Index] = 0; - } - - 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++; - } - - 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 - ) - /*++ - - Routine Description: - - Outputs the code length array for the Extra Set or the Position Set. - - 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 - - Returns: (VOID) - - --*/ -{ - INT32 Index; - INT32 Index3; - - 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); - } - - if (Index == Special) { - while (Index < 6 && mPTLen[Index] == 0) { - Index++; - } - - PutBits (2, (Index - 3) & 3); - } - } -} - -STATIC - VOID - WriteCLen ( - VOID - ) - /*++ - - Routine Description: - - Outputs the code length array for Char&Length Set - - Arguments: (VOID) - - Returns: (VOID) - - --*/ -{ - INT32 Index; - INT32 Index3; - INT32 Number; - INT32 Count; - - 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++; - } - - 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 - ) -{ - PutBits (mCLen[Value], mCCode[Value]); -} - -STATIC - VOID - EncodeP ( - UINT32 Value - ) -{ - UINT32 Index; - UINT32 NodeQ; - - 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))); - } -} - -STATIC - VOID - SendBlock ( - VOID - ) - /*++ - - Routine Description: - - Huffman code the block and output it. - - Arguments: - (VOID) - - Returns: - (VOID) - - --*/ -{ - 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); - } - - 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); - } - - 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++]; - } - - EncodeP (Index3); - } else { - EncodeC (mBuf[Pos++]); - } - } - - for (Index = 0; Index < NC; Index++) { - mCFreq[Index] = 0; - } - - for (Index = 0; Index < NP; Index++) { - mPFreq[Index] = 0; - } -} - -STATIC - VOID - Output ( - UINT32 CharC, - UINT32 Pos - ) - /*++ - - Routine Description: - - Outputs an Original Character or a Pointer - - Arguments: - - CharC - The original character or the 'String Length' element of a Pointer - Pos - The 'Position' field of a Pointer - - Returns: (VOID) - - --*/ -{ - 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; - } - - 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++; - } - - mPFreq[CharC]++; - } -} - -STATIC - VOID - HufEncodeStart ( - VOID - ) -{ - INT32 Index; - - for (Index = 0; Index < NC; Index++) { - mCFreq[Index] = 0; - } - - for (Index = 0; Index < NP; Index++) { - mPFreq[Index] = 0; - } - - mOutputPos = mOutputMask = 0; - InitPutBits (); - return ; -} - -STATIC - VOID - HufEncodeEnd ( - VOID - ) -{ - SendBlock (); - - // - // Flush remaining bits - // - PutBits (UINT8_BIT - 1, 0); - - return ; -} - -STATIC - VOID - MakeCrcTable ( - VOID - ) -{ - 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; - } - } - - mCrcTable[Index] = (UINT16) Temp; - } -} - -STATIC - VOID - PutBits ( - INT32 Number, - UINT32 Value - ) - /*++ - - Routine Description: - - Outputs rightmost n bits of x - - Arguments: - - Number - the rightmost n bits of the data is used - x - the data - - Returns: (VOID) - - --*/ -{ - UINT8 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; - } - - mSubBitBuf |= Value << (mBitCount -= Number); -} - -STATIC - INT32 - FreadCrc ( - UINT8 *Pointer, - INT32 Number - ) - /*++ - - Routine Description: - - Read source data - - Arguments: - - Pointer - the buffer to hold the data - Number - number of bytes to read - - Returns: - - number of bytes actually read - - --*/ -{ - INT32 Index; - - for (Index = 0; mSrc < mSrcUpperLimit && Index < Number; Index++) { - *Pointer++ = *mSrc++; - } - - Number = Index; - - Pointer -= Number; - mOrigSize += Number; - Index--; - while (Index >= 0) { - UPDATE_CRC (*Pointer++); - Index--; - } - - return Number; -} - -STATIC - VOID - InitPutBits ( - VOID - ) -{ - mBitCount = UINT8_BIT; - mSubBitBuf = 0; -} - -STATIC - VOID - CountLen ( - INT32 Index - ) - /*++ - - Routine Description: - - Count the number of each code length for a Huffman tree. - - Arguments: - - Index - the top node - - Returns: (VOID) - - --*/ -{ - STATIC INT32 Depth = 0; - - if (Index < mN) { - mLenCnt[(Depth < 16) ? Depth : 16]++; - } else { - Depth++; - CountLen (mLeft[Index]); - CountLen (mRight[Index]); - Depth--; - } -} - -STATIC - VOID - MakeLen ( - INT32 Root - ) - /*++ - - Routine Description: - - Create code length array for a Huffman tree - - Arguments: - - Root - the root of the tree - - Returns: - - VOID - - --*/ -{ - INT32 Index; - INT32 Index3; - UINT32 Cum; - - for (Index = 0; Index <= 16; Index++) { - mLenCnt[Index] = 0; - } - - 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); - } - - while (Cum != (1U << 16)) { - mLenCnt[16]--; - for (Index = 15; Index > 0; Index--) { - if (mLenCnt[Index] != 0) { - mLenCnt[Index]--; - mLenCnt[Index + 1] += 2; - break; - } - } - - Cum--; - } - - for (Index = 16; Index > 0; Index--) { - Index3 = mLenCnt[Index]; - Index3--; - while (Index3 >= 0) { - mLen[*mSortPtr++] = (UINT8) Index; - Index3--; - } - } -} - -STATIC - VOID - DownHeap ( - INT32 Index - ) -{ - 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++; - } - - if (mFreq[Index3] <= mFreq[mHeap[Index2]]) { - break; - } - - mHeap[Index] = mHeap[Index2]; - Index = Index2; - Index2 = 2 * Index; - } - - mHeap[Index] = (INT16) Index3; -} - -STATIC - VOID - MakeCode ( - INT32 Number, - UINT8 Len[ ], - UINT16 Code[] +FreeMemory( + VOID ) - /*++ +/*++ - Routine Description: +Routine Description: - Assign code to each symbol based on the code length array +Called when compression is completed to free memory previously allocated. - Arguments: +Arguments: (VOID) - Number - number of symbols - Len - the code length array - Code - stores codes for each symbol +Returns: (VOID) - Returns: (VOID) - - --*/ +--*/ { - INT32 Index; - UINT16 Start[18]; + if (mText != NULL) { + free(mText); + } - Start[1] = 0; - for (Index = 1; Index <= 16; Index++) { - Start[Index + 1] = (UINT16) ((Start[Index] + mLenCnt[Index]) << 1); - } + if (mLevel != NULL) { + free(mLevel); + } - for (Index = 0; Index < Number; Index++) { - Code[Index] = Start[Len[Index]]++; - } + if (mChildCount != NULL) { + free(mChildCount); + } + + if (mPosition != NULL) { + free(mPosition); + } + + if (mParent != NULL) { + free(mParent); + } + + if (mPrev != NULL) { + free(mPrev); + } + + if (mNext != NULL) { + free(mNext); + } + + if (mBuf != NULL) { + free(mBuf); + } + + return; } STATIC - INT32 - MakeTree ( - INT32 NParm, - UINT16 FreqParm[], - UINT8 LenParm[ ], - UINT16 CodeParm[] +VOID +InitSlide( + VOID ) - /*++ +/*++ - Routine Description: +Routine Description: - Generates Huffman codes given a frequency distribution of symbols +Initialize String Info Log data structures - Arguments: +Arguments: (VOID) - NParm - number of symbols - FreqParm - frequency of each symbol - LenParm - code length for each symbol - CodeParm - code for each symbol +Returns: (VOID) - Returns: - - Root of the Huffman tree. - - --*/ +--*/ { - INT32 Index; - INT32 Index2; - INT32 Index3; - INT32 Avail; + NODE 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; - } - } + for (Index = (NODE)WNDSIZ; Index <= (NODE)WNDSIZ + UINT8_MAX; Index++) { + mLevel[Index] = 1; + mPosition[Index] = NIL; // sentinel + } - if (mHeapSize < 2) { - CodeParm[mHeap[1]] = 0; - return mHeap[1]; - } + for (Index = (NODE)WNDSIZ; Index < (NODE)WNDSIZ * 2; Index++) { + mParent[Index] = NIL; + } - for (Index = mHeapSize / 2; Index >= 1; Index--) { - // - // make priority queue - // - DownHeap (Index); - } + mAvail = 1; + for (Index = 1; Index < (NODE)WNDSIZ - 1; Index++) { + mNext[Index] = (NODE)(Index + 1); + } - 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; - } - - 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); - - // - // return root - // - return Index3; + 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 +) +/*++ + +Routine Description: + +Find child node given the parent node and the edge character + +Arguments: + +NodeQ - the parent node +CharC - the edge character + +Returns: + +The child node (NIL if not found) + +--*/ +{ + NODE NodeR; + + NodeR = mNext[HASH(NodeQ, CharC)]; + // + // sentinel + // + mParent[NIL] = NodeQ; + while (mParent[NodeR] != NodeQ) { + NodeR = mNext[NodeR]; + } + + return NodeR; +} + +STATIC +VOID +MakeChild( + NODE Parent, + UINT8 CharC, + NODE Child +) +/*++ + +Routine Description: + +Create a new child for a given parent node. + +Arguments: + +Parent - the parent node +CharC - the edge character +Child - the child node + +Returns: (VOID) + +--*/ +{ + 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]++; +} + +STATIC +VOID +Split( + NODE Old +) +/*++ + +Routine Description: + +Split a node. + +Arguments: + +Old - the node to split + +Returns: (VOID) + +--*/ +{ + 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); +} + +STATIC +VOID +InsertNode( + VOID +) +/*++ + +Routine Description: + +Insert string info for current position into the String Info Log + +Arguments: (VOID) + +Returns: (VOID) + +--*/ +{ + 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]; + } + + while (mLevel[NodeQ] >= mMatchLen) { + NodeR = NodeQ; + NodeQ = mParent[NodeQ]; + } + + 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; + } + + 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; + } + + t1 = &mText[mPos + mMatchLen]; + t2 = &mText[mMatchPos + mMatchLen]; + while (mMatchLen < Index2) { + if (*t1 != *t2) { + Split(NodeR); + return; + } + + mMatchLen++; + t1++; + t2++; + } + + if (mMatchLen >= MAXMATCH) { + break; + } + + mPosition[NodeR] = mPos; + NodeQ = NodeR; + NodeR = Child(NodeQ, *t1); + if (NodeR == NIL) { + MakeChild(NodeQ, *t1, mPos); + return; + } + + 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; + + // + // Special usage of 'next' + // + mNext[NodeR] = mPos; + +} + +STATIC +VOID +DeleteNode( + VOID +) +/*++ + +Routine Description: + +Delete outdated string info. (The Usage of PERC_FLAG +ensures a clean deletion) + +Arguments: (VOID) + +Returns: (VOID) + +--*/ +{ + NODE NodeQ; + NODE NodeR; + NODE NodeS; + NODE NodeT; + NODE NodeU; + + 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; + } + + mChildCount[NodeR]--; + if (mChildCount[NodeR] > 1) { + return; + } + + 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; + } + + if (NodeU > NodeS) { + NodeS = NodeU; + } + + mPosition[NodeQ] = (NODE)(NodeS | WNDSIZ); + NodeQ = mParent[NodeQ]; + NodeU = mPosition[NodeQ]; + } + + if (NodeQ < (NODE)WNDSIZ) { + if (NodeU >= mPos) { + NodeU -= WNDSIZ; + } + + if (NodeU > NodeS) { + NodeS = NodeU; + } + + 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; +} + +STATIC +VOID +GetNextMatch( + VOID +) +/*++ + +Routine Description: + +Advance the current position (read new data if needed). +Delete outdated string info. Find a match string for current position. + +Arguments: (VOID) + +Returns: (VOID) + +--*/ +{ + 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; + } + + DeleteNode(); + InsertNode(); +} + +STATIC +INT32 +Encode( + VOID +) +/*++ + +Routine Description: + +The mac controlling routine for compression process. + +Arguments: (VOID) + +Returns: + +EFI_SUCCESS - The compression is successful +EFI_OUT_0F_RESOURCES - Not enough memory for compression process + +--*/ +{ + INT32 Status; + INT32 LastMatchLen; + NODE LastMatchPos; + + Status = AllocateMemory(); + if (Status) { + FreeMemory(); + return Status; + } + + InitSlide(); + + 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 { + + 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; + } + } + } + + HufEncodeEnd(); + FreeMemory(); + return EFI_SUCCESS; +} + +STATIC +VOID +CountTFreq( + VOID +) +/*++ + +Routine Description: + +Count the frequencies for the Extra Set + +Arguments: (VOID) + +Returns: (VOID) + +--*/ +{ + INT32 Index; + INT32 Index3; + INT32 Number; + INT32 Count; + + for (Index = 0; Index < NT; Index++) { + mTFreq[Index] = 0; + } + + 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++; + } + + 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 +) +/*++ + +Routine Description: + +Outputs the code length array for the Extra Set or the Position Set. + +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 + +Returns: (VOID) + +--*/ +{ + INT32 Index; + INT32 Index3; + + 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); + } + + if (Index == Special) { + while (Index < 6 && mPTLen[Index] == 0) { + Index++; + } + + PutBits(2, (Index - 3) & 3); + } + } +} + +STATIC +VOID +WriteCLen( + VOID +) +/*++ + +Routine Description: + +Outputs the code length array for Char&Length Set + +Arguments: (VOID) + +Returns: (VOID) + +--*/ +{ + INT32 Index; + INT32 Index3; + INT32 Number; + INT32 Count; + + 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++; + } + + 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 +) +{ + PutBits(mCLen[Value], mCCode[Value]); +} + +STATIC +VOID +EncodeP( + UINT32 Value +) +{ + UINT32 Index; + UINT32 NodeQ; + + 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))); + } +} + +STATIC +VOID +SendBlock( + VOID +) +/*++ + +Routine Description: + +Huffman code the block and output it. + +Arguments: +(VOID) + +Returns: +(VOID) + +--*/ +{ + 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); + } + + 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); + } + + 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++]; + } + + EncodeP(Index3); + } + else { + EncodeC(mBuf[Pos++]); + } + } + + for (Index = 0; Index < NC; Index++) { + mCFreq[Index] = 0; + } + + for (Index = 0; Index < NP; Index++) { + mPFreq[Index] = 0; + } +} + +STATIC +VOID +Output( + UINT32 CharC, + UINT32 Pos +) +/*++ + +Routine Description: + +Outputs an Original Character or a Pointer + +Arguments: + +CharC - The original character or the 'String Length' element of a Pointer +Pos - The 'Position' field of a Pointer + +Returns: (VOID) + +--*/ +{ + 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; + } + + 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++; + } + + mPFreq[CharC]++; + } +} + +STATIC +VOID +HufEncodeStart( + VOID +) +{ + INT32 Index; + + for (Index = 0; Index < NC; Index++) { + mCFreq[Index] = 0; + } + + for (Index = 0; Index < NP; Index++) { + mPFreq[Index] = 0; + } + + mOutputPos = mOutputMask = 0; + InitPutBits(); + return; +} + +STATIC +VOID +HufEncodeEnd( + VOID +) +{ + SendBlock(); + + // + // Flush remaining bits + // + PutBits(UINT8_BIT - 1, 0); + + return; +} + +STATIC +VOID +MakeCrcTable( + VOID +) +{ + 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; + } + } + + mCrcTable[Index] = (UINT16)Temp; + } +} + +STATIC +VOID +PutBits( + INT32 Number, + UINT32 Value +) +/*++ + +Routine Description: + +Outputs rightmost n bits of x + +Arguments: + +Number - the rightmost n bits of the data is used +x - the data + +Returns: (VOID) + +--*/ +{ + UINT8 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; + } + + mSubBitBuf |= Value << (mBitCount -= Number); +} + +STATIC +INT32 +FreadCrc( + UINT8 *Pointer, + INT32 Number +) +/*++ + +Routine Description: + +Read source data + +Arguments: + +Pointer - the buffer to hold the data +Number - number of bytes to read + +Returns: + +number of bytes actually read + +--*/ +{ + INT32 Index; + + for (Index = 0; mSrc < mSrcUpperLimit && Index < Number; Index++) { + *Pointer++ = *mSrc++; + } + + Number = Index; + + Pointer -= Number; + mOrigSize += Number; + Index--; + while (Index >= 0) { + UPDATE_CRC(*Pointer++); + Index--; + } + + return Number; +} + +STATIC +VOID +InitPutBits( + VOID +) +{ + mBitCount = UINT8_BIT; + mSubBitBuf = 0; +} + +STATIC +VOID +CountLen( + INT32 Index +) +/*++ + +Routine Description: + +Count the number of each code length for a Huffman tree. + +Arguments: + +Index - the top node + +Returns: (VOID) + +--*/ +{ + STATIC INT32 Depth = 0; + + if (Index < mN) { + mLenCnt[(Depth < 16) ? Depth : 16]++; + } + else { + Depth++; + CountLen(mLeft[Index]); + CountLen(mRight[Index]); + Depth--; + } +} + +STATIC +VOID +MakeLen( + INT32 Root +) +/*++ + +Routine Description: + +Create code length array for a Huffman tree + +Arguments: + +Root - the root of the tree + +Returns: + +VOID + +--*/ +{ + INT32 Index; + INT32 Index3; + UINT32 Cum; + + for (Index = 0; Index <= 16; Index++) { + mLenCnt[Index] = 0; + } + + 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); + } + + while (Cum != (1U << 16)) { + mLenCnt[16]--; + for (Index = 15; Index > 0; Index--) { + if (mLenCnt[Index] != 0) { + mLenCnt[Index]--; + mLenCnt[Index + 1] += 2; + break; + } + } + + Cum--; + } + + for (Index = 16; Index > 0; Index--) { + Index3 = mLenCnt[Index]; + Index3--; + while (Index3 >= 0) { + mLen[*mSortPtr++] = (UINT8)Index; + Index3--; + } + } +} + +STATIC +VOID +DownHeap( + INT32 Index +) +{ + 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++; + } + + if (mFreq[Index3] <= mFreq[mHeap[Index2]]) { + break; + } + + mHeap[Index] = mHeap[Index2]; + Index = Index2; + Index2 = 2 * Index; + } + + mHeap[Index] = (INT16)Index3; +} + +STATIC +VOID +MakeCode( + INT32 Number, + UINT8 Len[], + UINT16 Code[] +) +/*++ + +Routine Description: + +Assign code to each symbol based on the code length array + +Arguments: + +Number - number of symbols +Len - the code length array +Code - stores codes for each symbol + +Returns: (VOID) + +--*/ +{ + INT32 Index; + UINT16 Start[18]; + + 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]]++; + } +} + +STATIC +INT32 +MakeTree( + INT32 NParm, + UINT16 FreqParm[], + UINT8 LenParm[], + 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 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; + } + } + + if (mHeapSize < 2) { + CodeParm[mHeap[1]] = 0; + return mHeap[1]; + } + + for (Index = mHeapSize / 2; Index >= 1; Index--) { + // + // make priority queue + // + DownHeap(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; + } + + 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); + + // + // return root + // + return Index3; } diff --git a/Tiano/EfiTianoDecompress.c b/Tiano/EfiTianoDecompress.c index 156392c..7300bb5 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)(Sd->mBitBuf << NumOfBits); + Sd->mBitBuf = (UINT32)(Sd->mBitBuf << NumOfBits); - while (NumOfBits > Sd->mBitCount) { - Sd->mBitBuf |= (UINT32)(Sd->mSubBitBuf << (NumOfBits = (UINT16)(NumOfBits - Sd->mBitCount))); + while (NumOfBits > Sd->mBitCount) { + Sd->mBitBuf |= (UINT32)(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 8fa3dcf..fe0eba5 100644 --- a/Tiano/EfiTianoDecompress.h +++ b/Tiano/EfiTianoDecompress.h @@ -37,14 +37,13 @@ extern "C" { UINT32 OrigSize; } EFI_TIANO_HEADER; - EFI_STATUS - EFIAPI - EfiTianoGetInfo( - const VOID *Source, - UINT32 SrcSize, - UINT32 *DstSize, - UINT32 *ScratchSize - ) + EFI_STATUS + EfiTianoGetInfo( + IN const VOID *Source, + IN UINT32 SrcSize, + OUT UINT32 *DstSize, + OUT UINT32 *ScratchSize + ) /*++ Routine Description: @@ -67,16 +66,16 @@ extern "C" { --*/ ; - EFI_STATUS - EFIAPI - EfiDecompress( - const VOID *Source, - UINT32 SrcSize, - VOID *Destination, - UINT32 DstSize, - VOID *Scratch, - UINT32 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 + ) /*++ Routine Description: @@ -101,16 +100,16 @@ extern "C" { --*/ ; - EFI_STATUS - EFIAPI - TianoDecompress( - const VOID *Source, - UINT32 SrcSize, - VOID *Destination, - UINT32 DstSize, - VOID *Scratch, - UINT32 ScratchSize - ) + 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 + ) /*++ Routine Description: diff --git a/UEFIPatch/patches.txt b/UEFIPatch/patches.txt index 9a8a4c8..4a78a8c 100644 --- a/UEFIPatch/patches.txt +++ b/UEFIPatch/patches.txt @@ -52,8 +52,9 @@ F7731B4C-58A2-4DF4-8980-5645D39ECE58 10 P:0FBA6C24380F:0FBA7424380F 299D6F8B-2EC9-4E40-9EC6-DDAA7EBF5FD9 10 P:81E10080000033C1:9090909090909090 299D6F8B-2EC9-4E40-9EC6-DDAA7EBF5FD9 12 P:81E10080000033C1:9090909090909090 -# PpmInitialize | Skylake-X -3FFCAE95-23CF-4967-94F5-16352F68E43B 10 P:742CB9E2000000:752CB9E2000000 +# SiInit | Skylake-X +D71C8BA4-4AF2-4D0D-B1BA-F2409F0C20D3 10 P:81E10080000033C1:9090909090909090 +D71C8BA4-4AF2-4D0D-B1BA-F2409F0C20D3 12 P:81E10080000033C1:9090909090909090 -# CpuInitPei | Skylake-X -01359D99-9446-456D-ADA4-50A711C03ADA 12 P:BE0080000023CE0B:BE0000000023CE0B \ No newline at end of file +# PpmInitialize | Skylake-X, Kaby Lake-X +3FFCAE95-23CF-4967-94F5-16352F68E43B 10 P:0FBAE80F:0FBAE00F \ No newline at end of file diff --git a/ffsengine.h b/ffsengine.h index 129f44b..8b2f327 100644 --- a/ffsengine.h +++ b/ffsengine.h @@ -95,6 +95,7 @@ public: UINT8 replace(const QModelIndex & index, const QByteArray & object, const UINT8 mode); UINT8 remove(const QModelIndex & index); UINT8 rebuild(const QModelIndex & index); + UINT8 doNotRebuild(const QModelIndex & index); UINT8 dump(const QModelIndex & index, const QString & path, const QString & filter = QString()); UINT8 patch(const QModelIndex & index, const QVector & patches); diff --git a/types.cpp b/types.cpp index d8dd01d..99442c1 100644 --- a/types.cpp +++ b/types.cpp @@ -150,6 +150,8 @@ QString actionTypeToQString(const UINT8 action) return QObject::tr("Rebuild"); case Actions::Rebase: return QObject::tr("Rebase"); + case Actions::DoNotRebuild: + return QObject::tr("Do not rebuild"); default: return QObject::tr("Unknown"); } diff --git a/types.h b/types.h index 7d71953..a5823cb 100644 --- a/types.h +++ b/types.h @@ -26,7 +26,8 @@ namespace Actions Replace, Remove, Rebuild, - Rebase + Rebase, + DoNotRebuild }; } diff --git a/uefitool.cpp b/uefitool.cpp index fbdc029..c4a84d7 100644 --- a/uefitool.cpp +++ b/uefitool.cpp @@ -17,7 +17,7 @@ UEFITool::UEFITool(QWidget *parent) : QMainWindow(parent), ui(new Ui::UEFITool), -version(tr("0.22.4")) +version(tr("0.23.0")) { clipboard = QApplication::clipboard(); @@ -43,6 +43,7 @@ version(tr("0.22.4")) connect(ui->actionReplaceBody, SIGNAL(triggered()), this, SLOT(replaceBody())); connect(ui->actionRemove, SIGNAL(triggered()), this, SLOT(remove())); connect(ui->actionRebuild, SIGNAL(triggered()), this, SLOT(rebuild())); + connect(ui->actionDoNotRebuild, SIGNAL(triggered()), this, SLOT(doNotRebuild())); connect(ui->actionMessagesCopy, SIGNAL(triggered()), this, SLOT(copyMessage())); connect(ui->actionMessagesCopyAll, SIGNAL(triggered()), this, SLOT(copyAllMessages())); connect(ui->actionMessagesClear, SIGNAL(triggered()), this, SLOT(clearMessages())); @@ -146,6 +147,7 @@ void UEFITool::populateUi(const QModelIndex ¤t) // Enable actions ui->actionExtract->setDisabled(model->hasEmptyHeader(current) && model->hasEmptyBody(current)); ui->actionRebuild->setEnabled(type == Types::Volume || type == Types::File || type == Types::Section); + ui->actionDoNotRebuild->setEnabled(type== Types::Region || type == Types::Volume || type == Types::File || type == Types::Section); ui->actionExtractBody->setDisabled(model->hasEmptyBody(current)); ui->actionRemove->setEnabled(type == Types::Volume || type == Types::File || type == Types::Section); ui->actionInsertInto->setEnabled((type == Types::Volume && subtype != Subtypes::UnknownVolume) || @@ -220,6 +222,18 @@ void UEFITool::rebuild() ui->actionSaveImageFile->setEnabled(true); } +void UEFITool::doNotRebuild() +{ + QModelIndex index = ui->structureTreeView->selectionModel()->currentIndex(); + if (!index.isValid()) + return; + + UINT8 result = ffsEngine->doNotRebuild(index); + + if (result == ERR_SUCCESS) + ui->actionSaveImageFile->setEnabled(true); +} + void UEFITool::remove() { QModelIndex index = ui->structureTreeView->selectionModel()->currentIndex(); diff --git a/uefitool.h b/uefitool.h index edac83b..ac7b00a 100644 --- a/uefitool.h +++ b/uefitool.h @@ -78,6 +78,7 @@ public: void replaceBody(); void rebuild(); + void doNotRebuild(); void remove(); diff --git a/uefitool.ui b/uefitool.ui index 8e0a19d..c921129 100644 --- a/uefitool.ui +++ b/uefitool.ui @@ -180,7 +180,7 @@ 0 0 800 - 21 + 31 @@ -225,6 +225,8 @@ + + @@ -243,6 +245,7 @@ + @@ -257,6 +260,7 @@ + @@ -275,6 +279,7 @@ + @@ -284,7 +289,6 @@ - @@ -536,6 +540,17 @@ Ctrl+Shift+O + + + false + + + &Do not rebuild + + + Ctrl+Shift+Space + +