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