/*++\r
\r
-Copyright (c) 2004, Intel Corporation \r
+Copyright (c) 2006, Intel Corporation \r
All rights reserved. This program and the accompanying materials \r
are licensed and made available under the terms and conditions of the BSD License \r
which accompanies this distribution. The full text of the license may be found at \r
\r
--*/\r
\r
-#include "EfiCompress.h"\r
+#include "Compress.h"\r
+\r
\r
//\r
// Macro Definitions\r
//\r
-typedef INT32 NODE;\r
-#define UINT8_BIT 8\r
-#define THRESHOLD 3\r
-#define INIT_CRC 0\r
-#define WNDBIT 19\r
-#define WNDSIZ (1U << WNDBIT)\r
-#define MAXMATCH 256\r
-#define BLKSIZ (1U << 14) // 16 * 1024U\r
-#define PERC_FLAG 0x80000000U\r
-#define CODE_BIT 16\r
-#define NIL 0\r
-#define MAX_HASH_VAL (3 * WNDSIZ + (WNDSIZ / 512 + 1) * UINT8_MAX)\r
-#define HASH(p, c) ((p) + ((c) << (WNDBIT - 9)) + WNDSIZ * 2)\r
-#define CRCPOLY 0xA001\r
-#define UPDATE_CRC(c) mCrc = mCrcTable[(mCrc ^ (c)) & 0xFF] ^ (mCrc >> UINT8_BIT)\r
+\r
+typedef INT16 NODE;\r
+#define UINT8_MAX 0xff\r
+#define UINT8_BIT 8\r
+#define THRESHOLD 3\r
+#define INIT_CRC 0\r
+#define WNDBIT 13\r
+#define WNDSIZ (1U << WNDBIT)\r
+#define MAXMATCH 256\r
+#define PERC_FLAG 0x8000U\r
+#define CODE_BIT 16\r
+#define NIL 0\r
+#define MAX_HASH_VAL (3 * WNDSIZ + (WNDSIZ / 512 + 1) * UINT8_MAX)\r
+#define HASH(p, c) ((p) + ((c) << (WNDBIT - 9)) + WNDSIZ * 2)\r
+#define CRCPOLY 0xA001\r
+#define UPDATE_CRC(c) mCrc = mCrcTable[(mCrc ^ (c)) & 0xFF] ^ (mCrc >> UINT8_BIT)\r
\r
//\r
// C: the Char&Len Set; P: the Position Set; T: the exTra Set\r
//\r
-#define NC (UINT8_MAX + MAXMATCH + 2 - THRESHOLD)\r
-#define CBIT 9\r
-#define NP (WNDBIT + 1)\r
-#define PBIT 5\r
-#define NT (CODE_BIT + 3)\r
-#define TBIT 5\r
+\r
+#define NC (UINT8_MAX + MAXMATCH + 2 - THRESHOLD)\r
+#define CBIT 9\r
+#define NP (WNDBIT + 1)\r
+#define PBIT 4\r
+#define NT (CODE_BIT + 3)\r
+#define TBIT 5\r
#if NT > NP\r
-#define NPT NT\r
+ #define NPT NT\r
#else\r
-#define NPT NP\r
+ #define NPT NP\r
#endif\r
+\r
//\r
// Function Prototypes\r
//\r
-STATIC VOID PutDword(IN UINT32 Data);\r
\r
STATIC\r
-EFI_STATUS\r
+VOID \r
+PutDword(\r
+ IN UINT32 Data\r
+ );\r
+\r
+STATIC\r
+EFI_STATUS \r
AllocateMemory (\r
- VOID\r
);\r
\r
STATIC\r
VOID\r
FreeMemory (\r
- VOID\r
);\r
\r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
InitSlide (\r
- VOID\r
);\r
\r
-STATIC\r
-NODE\r
+STATIC \r
+NODE \r
Child (\r
- IN NODE NodeQ,\r
- IN UINT8 CharC\r
+ IN NODE q, \r
+ IN UINT8 c\r
);\r
\r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
MakeChild (\r
- IN NODE NodeQ,\r
- IN UINT8 CharC,\r
- IN NODE NodeR\r
+ IN NODE q, \r
+ IN UINT8 c, \r
+ IN NODE r\r
);\r
-\r
-STATIC\r
-VOID\r
+ \r
+STATIC \r
+VOID \r
Split (\r
IN NODE Old\r
);\r
\r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
InsertNode (\r
- VOID\r
);\r
-\r
-STATIC\r
-VOID\r
+ \r
+STATIC \r
+VOID \r
DeleteNode (\r
- VOID\r
);\r
\r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
GetNextMatch (\r
- VOID\r
);\r
-\r
-STATIC\r
-EFI_STATUS\r
+ \r
+STATIC \r
+EFI_STATUS \r
Encode (\r
- VOID\r
);\r
\r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
CountTFreq (\r
- VOID\r
);\r
\r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
WritePTLen (\r
- IN INT32 Number,\r
- IN INT32 nbit,\r
+ IN INT32 n, \r
+ IN INT32 nbit, \r
IN INT32 Special\r
);\r
\r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
WriteCLen (\r
- VOID\r
);\r
-\r
-STATIC\r
-VOID\r
+ \r
+STATIC \r
+VOID \r
EncodeC (\r
- IN INT32 Value\r
+ IN INT32 c\r
);\r
\r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
EncodeP (\r
- IN UINT32 Value\r
+ IN UINT32 p\r
);\r
\r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
SendBlock (\r
- VOID\r
);\r
-\r
-STATIC\r
-VOID\r
+ \r
+STATIC \r
+VOID \r
Output (\r
- IN UINT32 c,\r
+ IN UINT32 c, \r
IN UINT32 p\r
);\r
\r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
HufEncodeStart (\r
- VOID\r
);\r
-\r
-STATIC\r
-VOID\r
+ \r
+STATIC \r
+VOID \r
HufEncodeEnd (\r
- VOID\r
);\r
-\r
-STATIC\r
-VOID\r
+ \r
+STATIC \r
+VOID \r
MakeCrcTable (\r
- VOID\r
);\r
-\r
-STATIC\r
-VOID\r
+ \r
+STATIC \r
+VOID \r
PutBits (\r
- IN INT32 Number,\r
- IN UINT32 Value\r
+ IN INT32 n, \r
+ IN UINT32 x\r
);\r
-\r
-STATIC\r
-INT32\r
+ \r
+STATIC \r
+INT32 \r
FreadCrc (\r
- OUT UINT8 *Pointer,\r
- IN INT32 Number\r
+ OUT UINT8 *p, \r
+ IN INT32 n\r
);\r
-\r
-STATIC\r
-VOID\r
+ \r
+STATIC \r
+VOID \r
InitPutBits (\r
- VOID\r
);\r
-\r
-STATIC\r
-VOID\r
+ \r
+STATIC \r
+VOID \r
CountLen (\r
- IN INT32 Index\r
+ IN INT32 i\r
);\r
\r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
MakeLen (\r
IN INT32 Root\r
);\r
-\r
-STATIC\r
-VOID\r
+ \r
+STATIC \r
+VOID \r
DownHeap (\r
- IN INT32 Index\r
+ IN INT32 i\r
);\r
\r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
MakeCode (\r
- IN INT32 Number,\r
- IN UINT8 Len[ ],\r
+ IN INT32 n, \r
+ IN UINT8 Len[], \r
OUT UINT16 Code[]\r
);\r
-\r
-STATIC\r
-INT32\r
+ \r
+STATIC \r
+INT32 \r
MakeTree (\r
- IN INT32 NParm,\r
- IN UINT16 FreqParm[],\r
- OUT UINT8 LenParm[ ],\r
+ IN INT32 NParm, \r
+ IN UINT16 FreqParm[], \r
+ OUT UINT8 LenParm[], \r
OUT UINT16 CodeParm[]\r
);\r
\r
+\r
//\r
// Global Variables\r
//\r
-static UINT8 *mSrc, *mDst, *mSrcUpperLimit, *mDstUpperLimit;\r
\r
-static UINT8 *mLevel, *mText, *mChildCount, *mBuf, mCLen[NC], mPTLen[NPT], *mLen;\r
-static INT16 mHeap[NC + 1];\r
-static INT32 mRemainder, mMatchLen, mBitCount, mHeapSize, mN;\r
-static UINT32 mBufSiz = 0, mOutputPos, mOutputMask, mSubBitBuf, mCrc;\r
-static UINT32 mCompSize, mOrigSize;\r
+STATIC UINT8 *mSrc, *mDst, *mSrcUpperLimit, *mDstUpperLimit;\r
+\r
+STATIC UINT8 *mLevel, *mText, *mChildCount, *mBuf, mCLen[NC], mPTLen[NPT], *mLen;\r
+STATIC INT16 mHeap[NC + 1];\r
+STATIC INT32 mRemainder, mMatchLen, mBitCount, mHeapSize, mN;\r
+STATIC UINT32 mBufSiz = 0, mOutputPos, mOutputMask, mSubBitBuf, mCrc;\r
+STATIC UINT32 mCompSize, mOrigSize;\r
\r
-static UINT16 *mFreq, *mSortPtr, mLenCnt[17], mLeft[2 * NC - 1], mRight[2 * NC - 1], mCrcTable[UINT8_MAX + 1],\r
- mCFreq[2 * NC - 1], mCTable[4096], mCCode[NC], mPFreq[2 * NP - 1], mPTCode[NPT], mTFreq[2 * NT - 1];\r
+STATIC UINT16 *mFreq, *mSortPtr, mLenCnt[17], mLeft[2 * NC - 1], mRight[2 * NC - 1],\r
+ mCrcTable[UINT8_MAX + 1], mCFreq[2 * NC - 1], mCTable[4096], mCCode[NC],\r
+ mPFreq[2 * NP - 1], mPTCode[NPT], mTFreq[2 * NT - 1];\r
+\r
+STATIC NODE mPos, mMatchPos, mAvail, *mPosition, *mParent, *mPrev, *mNext = NULL;\r
\r
-static NODE mPos, mMatchPos, mAvail, *mPosition, *mParent, *mPrev, *mNext = NULL;\r
\r
//\r
// functions\r
//\r
+\r
EFI_STATUS\r
-Compress (\r
+EfiCompress (\r
IN UINT8 *SrcBuffer,\r
IN UINT32 SrcSize,\r
IN UINT8 *DstBuffer,\r
EFI_BUFFER_TOO_SMALL - The DstBuffer is too small. In this case,\r
DstSize contains the size needed.\r
EFI_SUCCESS - Compression is successful.\r
- EFI_OUT_OF_RESOURCES - No resource to complete function.\r
\r
--*/\r
{\r
- EFI_STATUS Status;\r
-\r
+ EFI_STATUS Status = EFI_SUCCESS;\r
+ \r
//\r
// Initializations\r
//\r
- mBufSiz = 0;\r
- mBuf = NULL;\r
- mText = NULL;\r
- mLevel = NULL;\r
- mChildCount = NULL;\r
- mPosition = NULL;\r
- mParent = NULL;\r
- mPrev = NULL;\r
- mNext = NULL;\r
-\r
- mSrc = SrcBuffer;\r
- mSrcUpperLimit = mSrc + SrcSize;\r
- mDst = DstBuffer;\r
- mDstUpperLimit = mDst +*DstSize;\r
-\r
- PutDword (0L);\r
- PutDword (0L);\r
+ mBufSiz = 0;\r
+ mBuf = NULL;\r
+ mText = NULL;\r
+ mLevel = NULL;\r
+ mChildCount = NULL;\r
+ mPosition = NULL;\r
+ mParent = NULL;\r
+ mPrev = NULL;\r
+ mNext = NULL;\r
\r
- MakeCrcTable ();\r
+ \r
+ mSrc = SrcBuffer;\r
+ mSrcUpperLimit = mSrc + SrcSize;\r
+ mDst = DstBuffer;\r
+ mDstUpperLimit = mDst + *DstSize;\r
\r
- mOrigSize = mCompSize = 0;\r
- mCrc = INIT_CRC;\r
+ PutDword(0L);\r
+ PutDword(0L);\r
+ \r
+ MakeCrcTable ();\r
\r
+ mOrigSize = mCompSize = 0;\r
+ mCrc = INIT_CRC;\r
+ \r
//\r
// Compress it\r
//\r
- Status = Encode ();\r
+ \r
+ Status = Encode();\r
if (EFI_ERROR (Status)) {\r
return EFI_OUT_OF_RESOURCES;\r
}\r
+ \r
//\r
// Null terminate the compressed data\r
//\r
if (mDst < mDstUpperLimit) {\r
*mDst++ = 0;\r
}\r
+ \r
//\r
// Fill in compressed size and original size\r
//\r
mDst = DstBuffer;\r
- PutDword (mCompSize + 1);\r
- PutDword (mOrigSize);\r
+ PutDword(mCompSize+1);\r
+ PutDword(mOrigSize);\r
\r
//\r
// Return\r
//\r
+ \r
if (mCompSize + 1 + 8 > *DstSize) {\r
*DstSize = mCompSize + 1 + 8;\r
return EFI_BUFFER_TOO_SMALL;\r
\r
}\r
\r
-STATIC\r
-VOID\r
-PutDword (\r
+STATIC \r
+VOID \r
+PutDword(\r
IN UINT32 Data\r
)\r
/*++\r
--*/\r
{\r
if (mDst < mDstUpperLimit) {\r
- *mDst++ = (UINT8) (((UINT8) (Data)) & 0xff);\r
+ *mDst++ = (UINT8)(((UINT8)(Data )) & 0xff);\r
}\r
\r
if (mDst < mDstUpperLimit) {\r
- *mDst++ = (UINT8) (((UINT8) (Data >> 0x08)) & 0xff);\r
+ *mDst++ = (UINT8)(((UINT8)(Data >> 0x08)) & 0xff);\r
}\r
\r
if (mDst < mDstUpperLimit) {\r
- *mDst++ = (UINT8) (((UINT8) (Data >> 0x10)) & 0xff);\r
+ *mDst++ = (UINT8)(((UINT8)(Data >> 0x10)) & 0xff);\r
}\r
\r
if (mDst < mDstUpperLimit) {\r
- *mDst++ = (UINT8) (((UINT8) (Data >> 0x18)) & 0xff);\r
+ *mDst++ = (UINT8)(((UINT8)(Data >> 0x18)) & 0xff);\r
}\r
}\r
\r
STATIC\r
EFI_STATUS\r
-AllocateMemory (\r
- VOID\r
- )\r
+AllocateMemory ()\r
/*++\r
\r
Routine Description:\r
\r
Allocate memory spaces for data structures used in compression process\r
\r
-Argements: \r
- VOID\r
+Argements: (VOID)\r
\r
Returns:\r
\r
\r
--*/\r
{\r
- UINT32 Index;\r
-\r
- mText = malloc (WNDSIZ * 2 + MAXMATCH);\r
- for (Index = 0; Index < WNDSIZ * 2 + MAXMATCH; Index++) {\r
- mText[Index] = 0;\r
+ UINT32 i;\r
+ \r
+ mText = malloc (WNDSIZ * 2 + MAXMATCH);\r
+ for (i = 0 ; i < WNDSIZ * 2 + MAXMATCH; i ++) {\r
+ mText[i] = 0;\r
}\r
\r
- mLevel = malloc ((WNDSIZ + UINT8_MAX + 1) * sizeof (*mLevel));\r
- mChildCount = malloc ((WNDSIZ + UINT8_MAX + 1) * sizeof (*mChildCount));\r
- mPosition = malloc ((WNDSIZ + UINT8_MAX + 1) * sizeof (*mPosition));\r
- mParent = malloc (WNDSIZ * 2 * sizeof (*mParent));\r
- mPrev = malloc (WNDSIZ * 2 * sizeof (*mPrev));\r
- mNext = malloc ((MAX_HASH_VAL + 1) * sizeof (*mNext));\r
-\r
- mBufSiz = BLKSIZ;\r
- mBuf = malloc (mBufSiz);\r
- while (mBuf == NULL) {\r
+ mLevel = malloc ((WNDSIZ + UINT8_MAX + 1) * sizeof(*mLevel));\r
+ mChildCount = malloc ((WNDSIZ + UINT8_MAX + 1) * sizeof(*mChildCount));\r
+ mPosition = malloc ((WNDSIZ + UINT8_MAX + 1) * sizeof(*mPosition));\r
+ mParent = malloc (WNDSIZ * 2 * sizeof(*mParent));\r
+ mPrev = malloc (WNDSIZ * 2 * sizeof(*mPrev));\r
+ mNext = malloc ((MAX_HASH_VAL + 1) * sizeof(*mNext));\r
+ \r
+ mBufSiz = 16 * 1024U;\r
+ while ((mBuf = malloc(mBufSiz)) == NULL) {\r
mBufSiz = (mBufSiz / 10U) * 9U;\r
if (mBufSiz < 4 * 1024U) {\r
return EFI_OUT_OF_RESOURCES;\r
}\r
-\r
- mBuf = malloc (mBufSiz);\r
}\r
-\r
mBuf[0] = 0;\r
-\r
+ \r
return EFI_SUCCESS;\r
}\r
\r
VOID\r
-FreeMemory (\r
- VOID\r
- )\r
+FreeMemory ()\r
/*++\r
\r
Routine Description:\r
\r
--*/\r
{\r
- if (mText != NULL) {\r
+ if (mText) {\r
free (mText);\r
}\r
-\r
- if (mLevel != NULL) {\r
+ \r
+ if (mLevel) {\r
free (mLevel);\r
}\r
-\r
- if (mChildCount != NULL) {\r
+ \r
+ if (mChildCount) {\r
free (mChildCount);\r
}\r
-\r
- if (mPosition != NULL) {\r
+ \r
+ if (mPosition) {\r
free (mPosition);\r
}\r
-\r
- if (mParent != NULL) {\r
+ \r
+ if (mParent) {\r
free (mParent);\r
}\r
-\r
- if (mPrev != NULL) {\r
+ \r
+ if (mPrev) {\r
free (mPrev);\r
}\r
-\r
- if (mNext != NULL) {\r
+ \r
+ if (mNext) {\r
free (mNext);\r
}\r
-\r
- if (mBuf != NULL) {\r
+ \r
+ if (mBuf) {\r
free (mBuf);\r
- }\r
+ } \r
\r
- return ;\r
+ return;\r
}\r
\r
-STATIC\r
-VOID\r
-InitSlide (\r
- VOID\r
- )\r
+\r
+STATIC \r
+VOID \r
+InitSlide ()\r
/*++\r
\r
Routine Description:\r
\r
--*/\r
{\r
- NODE Index;\r
+ NODE i;\r
\r
- for (Index = WNDSIZ; Index <= WNDSIZ + UINT8_MAX; Index++) {\r
- mLevel[Index] = 1;\r
- mPosition[Index] = NIL; /* sentinel */\r
+ for (i = WNDSIZ; i <= WNDSIZ + UINT8_MAX; i++) {\r
+ mLevel[i] = 1;\r
+ mPosition[i] = NIL; /* sentinel */\r
}\r
-\r
- for (Index = WNDSIZ; Index < WNDSIZ * 2; Index++) {\r
- mParent[Index] = NIL;\r
- }\r
-\r
+ for (i = WNDSIZ; i < WNDSIZ * 2; i++) {\r
+ mParent[i] = NIL;\r
+ } \r
mAvail = 1;\r
- for (Index = 1; Index < WNDSIZ - 1; Index++) {\r
- mNext[Index] = (NODE) (Index + 1);\r
+ for (i = 1; i < WNDSIZ - 1; i++) {\r
+ mNext[i] = (NODE)(i + 1);\r
}\r
-\r
+ \r
mNext[WNDSIZ - 1] = NIL;\r
- for (Index = WNDSIZ * 2; Index <= MAX_HASH_VAL; Index++) {\r
- mNext[Index] = NIL;\r
- }\r
+ for (i = WNDSIZ * 2; i <= MAX_HASH_VAL; i++) {\r
+ mNext[i] = NIL;\r
+ } \r
}\r
\r
-STATIC\r
-NODE\r
+\r
+STATIC \r
+NODE \r
Child (\r
- IN NODE NodeQ,\r
- IN UINT8 CharC\r
+ IN NODE q, \r
+ IN UINT8 c\r
)\r
/*++\r
\r
\r
Arguments:\r
\r
- NodeQ - the parent node\r
- CharC - the edge character\r
+ q - the parent node\r
+ c - the edge character\r
\r
Returns:\r
\r
\r
--*/\r
{\r
- NODE NodeR;\r
-\r
- NodeR = mNext[HASH (NodeQ, CharC)];\r
- //\r
- // sentinel\r
- //\r
- mParent[NIL] = NodeQ;\r
- while (mParent[NodeR] != NodeQ) {\r
- NodeR = mNext[NodeR];\r
+ NODE r;\r
+ \r
+ r = mNext[HASH(q, c)];\r
+ mParent[NIL] = q; /* sentinel */\r
+ while (mParent[r] != q) {\r
+ r = mNext[r];\r
}\r
-\r
- return NodeR;\r
+ \r
+ return r;\r
}\r
\r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
MakeChild (\r
- IN NODE Parent,\r
- IN UINT8 CharC,\r
- IN NODE Child\r
+ IN NODE q, \r
+ IN UINT8 c, \r
+ IN NODE r\r
)\r
/*++\r
\r
\r
Arguments:\r
\r
- Parent - the parent node\r
- CharC - the edge character\r
- Child - the child node\r
+ q - the parent node\r
+ c - the edge character\r
+ r - the child node\r
\r
Returns: (VOID)\r
\r
--*/\r
{\r
- NODE Node1;\r
- NODE Node2;\r
-\r
- Node1 = (NODE) HASH (Parent, CharC);\r
- Node2 = mNext[Node1];\r
- mNext[Node1] = Child;\r
- mNext[Child] = Node2;\r
- mPrev[Node2] = Child;\r
- mPrev[Child] = Node1;\r
- mParent[Child] = Parent;\r
- mChildCount[Parent]++;\r
+ NODE h, t;\r
+ \r
+ h = (NODE)HASH(q, c);\r
+ t = mNext[h];\r
+ mNext[h] = r;\r
+ mNext[r] = t;\r
+ mPrev[t] = r;\r
+ mPrev[r] = h;\r
+ mParent[r] = q;\r
+ mChildCount[q]++;\r
}\r
\r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
Split (\r
NODE Old\r
)\r
\r
--*/\r
{\r
- NODE New;\r
- NODE TempNode;\r
-\r
- New = mAvail;\r
- mAvail = mNext[New];\r
- mChildCount[New] = 0;\r
- TempNode = mPrev[Old];\r
- mPrev[New] = TempNode;\r
- mNext[TempNode] = New;\r
- TempNode = mNext[Old];\r
- mNext[New] = TempNode;\r
- mPrev[TempNode] = New;\r
- mParent[New] = mParent[Old];\r
- mLevel[New] = (UINT8) mMatchLen;\r
- mPosition[New] = mPos;\r
- MakeChild (New, mText[mMatchPos + mMatchLen], Old);\r
- MakeChild (New, mText[mPos + mMatchLen], mPos);\r
+ NODE New, t;\r
+\r
+ New = mAvail;\r
+ mAvail = mNext[New];\r
+ mChildCount[New] = 0;\r
+ t = mPrev[Old];\r
+ mPrev[New] = t;\r
+ mNext[t] = New;\r
+ t = mNext[Old];\r
+ mNext[New] = t;\r
+ mPrev[t] = New;\r
+ mParent[New] = mParent[Old];\r
+ mLevel[New] = (UINT8)mMatchLen;\r
+ mPosition[New] = mPos;\r
+ MakeChild(New, mText[mMatchPos + mMatchLen], Old);\r
+ MakeChild(New, mText[mPos + mMatchLen], mPos);\r
}\r
\r
-STATIC\r
-VOID\r
-InsertNode (\r
- VOID\r
- )\r
+STATIC \r
+VOID \r
+InsertNode ()\r
/*++\r
\r
Routine Description:\r
\r
--*/\r
{\r
- NODE NodeQ;\r
- NODE NodeR;\r
- NODE Index2;\r
- NODE NodeT;\r
- UINT8 CharC;\r
- UINT8 *t1;\r
- UINT8 *t2;\r
+ NODE q, r, j, t;\r
+ UINT8 c, *t1, *t2;\r
\r
if (mMatchLen >= 4) {\r
+ \r
//\r
// We have just got a long match, the target tree\r
// can be located by MatchPos + 1. Travese the tree\r
// The usage of PERC_FLAG ensures proper node deletion\r
// in DeleteNode() later.\r
//\r
+ \r
mMatchLen--;\r
- NodeR = (NODE) ((mMatchPos + 1) | WNDSIZ);\r
- NodeQ = mParent[NodeR];\r
- while (NodeQ == NIL) {\r
- NodeR = mNext[NodeR];\r
- NodeQ = mParent[NodeR];\r
+ r = (INT16)((mMatchPos + 1) | WNDSIZ);\r
+ while ((q = mParent[r]) == NIL) {\r
+ r = mNext[r];\r
}\r
-\r
- while (mLevel[NodeQ] >= mMatchLen) {\r
- NodeR = NodeQ;\r
- NodeQ = mParent[NodeQ];\r
+ while (mLevel[q] >= mMatchLen) {\r
+ r = q; q = mParent[q];\r
}\r
-\r
- NodeT = NodeQ;\r
- while (mPosition[NodeT] < 0) {\r
- mPosition[NodeT] = mPos;\r
- NodeT = mParent[NodeT];\r
- }\r
-\r
- if (NodeT < WNDSIZ) {\r
- mPosition[NodeT] = (NODE) (mPos | (UINT32) PERC_FLAG);\r
+ t = q;\r
+ while (mPosition[t] < 0) {\r
+ mPosition[t] = mPos;\r
+ t = mParent[t];\r
}\r
+ if (t < WNDSIZ) {\r
+ mPosition[t] = (NODE)(mPos | PERC_FLAG);\r
+ } \r
} else {\r
+ \r
//\r
// Locate the target tree\r
//\r
- NodeQ = (NODE) (mText[mPos] + WNDSIZ);\r
- CharC = mText[mPos + 1];\r
- NodeR = Child (NodeQ, CharC);\r
- if (NodeR == NIL) {\r
- MakeChild (NodeQ, CharC, mPos);\r
+ \r
+ q = (INT16)(mText[mPos] + WNDSIZ);\r
+ c = mText[mPos + 1];\r
+ if ((r = Child(q, c)) == NIL) {\r
+ MakeChild(q, c, mPos);\r
mMatchLen = 1;\r
- return ;\r
+ return;\r
}\r
-\r
mMatchLen = 2;\r
}\r
+ \r
//\r
// Traverse down the tree to find a match.\r
// Update Position value along the route.\r
// Node split or creation is involved.\r
//\r
- for (;;) {\r
- if (NodeR >= WNDSIZ) {\r
- Index2 = MAXMATCH;\r
- mMatchPos = NodeR;\r
+ \r
+ for ( ; ; ) {\r
+ if (r >= WNDSIZ) {\r
+ j = MAXMATCH;\r
+ mMatchPos = r;\r
} else {\r
- Index2 = mLevel[NodeR];\r
- mMatchPos = (NODE) (mPosition[NodeR] & (UINT32)~PERC_FLAG);\r
+ j = mLevel[r];\r
+ mMatchPos = (NODE)(mPosition[r] & ~PERC_FLAG);\r
}\r
-\r
if (mMatchPos >= mPos) {\r
mMatchPos -= WNDSIZ;\r
- }\r
-\r
- t1 = &mText[mPos + mMatchLen];\r
- t2 = &mText[mMatchPos + mMatchLen];\r
- while (mMatchLen < Index2) {\r
+ } \r
+ t1 = &mText[mPos + mMatchLen];\r
+ t2 = &mText[mMatchPos + mMatchLen];\r
+ while (mMatchLen < j) {\r
if (*t1 != *t2) {\r
- Split (NodeR);\r
- return ;\r
+ Split(r);\r
+ return;\r
}\r
-\r
mMatchLen++;\r
t1++;\r
t2++;\r
}\r
-\r
if (mMatchLen >= MAXMATCH) {\r
break;\r
}\r
-\r
- mPosition[NodeR] = mPos;\r
- NodeQ = NodeR;\r
- NodeR = Child (NodeQ, *t1);\r
- if (NodeR == NIL) {\r
- MakeChild (NodeQ, *t1, mPos);\r
- return ;\r
+ mPosition[r] = mPos;\r
+ q = r;\r
+ if ((r = Child(q, *t1)) == NIL) {\r
+ MakeChild(q, *t1, mPos);\r
+ return;\r
}\r
-\r
mMatchLen++;\r
}\r
-\r
- NodeT = mPrev[NodeR];\r
- mPrev[mPos] = NodeT;\r
- mNext[NodeT] = mPos;\r
- NodeT = mNext[NodeR];\r
- mNext[mPos] = NodeT;\r
- mPrev[NodeT] = mPos;\r
- mParent[mPos] = NodeQ;\r
- mParent[NodeR] = NIL;\r
-\r
+ t = mPrev[r];\r
+ mPrev[mPos] = t;\r
+ mNext[t] = mPos;\r
+ t = mNext[r];\r
+ mNext[mPos] = t;\r
+ mPrev[t] = mPos;\r
+ mParent[mPos] = q;\r
+ mParent[r] = NIL;\r
+ \r
//\r
// Special usage of 'next'\r
//\r
- mNext[NodeR] = mPos;\r
-\r
+ mNext[r] = mPos;\r
+ \r
}\r
\r
-STATIC\r
-VOID\r
-DeleteNode (\r
- VOID\r
- )\r
+STATIC \r
+VOID \r
+DeleteNode ()\r
/*++\r
\r
Routine Description:\r
\r
--*/\r
{\r
- NODE NodeQ;\r
- NODE NodeR;\r
- NODE NodeS;\r
- NODE NodeT;\r
- NODE NodeU;\r
+ NODE q, r, s, t, u;\r
\r
if (mParent[mPos] == NIL) {\r
- return ;\r
+ return;\r
}\r
-\r
- NodeR = mPrev[mPos];\r
- NodeS = mNext[mPos];\r
- mNext[NodeR] = NodeS;\r
- mPrev[NodeS] = NodeR;\r
- NodeR = mParent[mPos];\r
+ \r
+ r = mPrev[mPos];\r
+ s = mNext[mPos];\r
+ mNext[r] = s;\r
+ mPrev[s] = r;\r
+ r = mParent[mPos];\r
mParent[mPos] = NIL;\r
- if (NodeR >= WNDSIZ) {\r
- return ;\r
- }\r
-\r
- mChildCount[NodeR]--;\r
- if (mChildCount[NodeR] > 1) {\r
- return ;\r
- }\r
-\r
- NodeT = (NODE) (mPosition[NodeR] & (UINT32)~PERC_FLAG);\r
- if (NodeT >= mPos) {\r
- NodeT -= WNDSIZ;\r
- }\r
-\r
- NodeS = NodeT;\r
- NodeQ = mParent[NodeR];\r
- NodeU = mPosition[NodeQ];\r
- while (NodeU & (UINT32) PERC_FLAG) {\r
- NodeU &= (UINT32)~PERC_FLAG;\r
- if (NodeU >= mPos) {\r
- NodeU -= WNDSIZ;\r
+ if (r >= WNDSIZ || --mChildCount[r] > 1) {\r
+ return;\r
+ }\r
+ t = (NODE)(mPosition[r] & ~PERC_FLAG);\r
+ if (t >= mPos) {\r
+ t -= WNDSIZ;\r
+ }\r
+ s = t;\r
+ q = mParent[r];\r
+ while ((u = mPosition[q]) & PERC_FLAG) {\r
+ u &= ~PERC_FLAG;\r
+ if (u >= mPos) {\r
+ u -= WNDSIZ;\r
}\r
-\r
- if (NodeU > NodeS) {\r
- NodeS = NodeU;\r
+ if (u > s) {\r
+ s = u;\r
}\r
-\r
- mPosition[NodeQ] = (NODE) (NodeS | WNDSIZ);\r
- NodeQ = mParent[NodeQ];\r
- NodeU = mPosition[NodeQ];\r
+ mPosition[q] = (INT16)(s | WNDSIZ);\r
+ q = mParent[q];\r
}\r
-\r
- if (NodeQ < WNDSIZ) {\r
- if (NodeU >= mPos) {\r
- NodeU -= WNDSIZ;\r
+ if (q < WNDSIZ) {\r
+ if (u >= mPos) {\r
+ u -= WNDSIZ;\r
}\r
-\r
- if (NodeU > NodeS) {\r
- NodeS = NodeU;\r
+ if (u > s) {\r
+ s = u;\r
}\r
-\r
- mPosition[NodeQ] = (NODE) (NodeS | WNDSIZ | (UINT32) PERC_FLAG);\r
- }\r
-\r
- NodeS = Child (NodeR, mText[NodeT + mLevel[NodeR]]);\r
- NodeT = mPrev[NodeS];\r
- NodeU = mNext[NodeS];\r
- mNext[NodeT] = NodeU;\r
- mPrev[NodeU] = NodeT;\r
- NodeT = mPrev[NodeR];\r
- mNext[NodeT] = NodeS;\r
- mPrev[NodeS] = NodeT;\r
- NodeT = mNext[NodeR];\r
- mPrev[NodeT] = NodeS;\r
- mNext[NodeS] = NodeT;\r
- mParent[NodeS] = mParent[NodeR];\r
- mParent[NodeR] = NIL;\r
- mNext[NodeR] = mAvail;\r
- mAvail = NodeR;\r
+ mPosition[q] = (INT16)(s | WNDSIZ | PERC_FLAG);\r
+ }\r
+ s = Child(r, mText[t + mLevel[r]]);\r
+ t = mPrev[s];\r
+ u = mNext[s];\r
+ mNext[t] = u;\r
+ mPrev[u] = t;\r
+ t = mPrev[r];\r
+ mNext[t] = s;\r
+ mPrev[s] = t;\r
+ t = mNext[r];\r
+ mPrev[t] = s;\r
+ mNext[s] = t;\r
+ mParent[s] = mParent[r];\r
+ mParent[r] = NIL;\r
+ mNext[r] = mAvail;\r
+ mAvail = r;\r
}\r
\r
-STATIC\r
-VOID\r
-GetNextMatch (\r
- VOID\r
- )\r
+STATIC \r
+VOID \r
+GetNextMatch ()\r
/*++\r
\r
Routine Description:\r
\r
--*/\r
{\r
- INT32 Number;\r
+ INT32 n;\r
\r
mRemainder--;\r
- mPos++;\r
- if (mPos == WNDSIZ * 2) {\r
- memmove (&mText[0], &mText[WNDSIZ], WNDSIZ + MAXMATCH);\r
- Number = FreadCrc (&mText[WNDSIZ + MAXMATCH], WNDSIZ);\r
- mRemainder += Number;\r
+ if (++mPos == WNDSIZ * 2) {\r
+ memmove(&mText[0], &mText[WNDSIZ], WNDSIZ + MAXMATCH);\r
+ n = FreadCrc(&mText[WNDSIZ + MAXMATCH], WNDSIZ);\r
+ mRemainder += n;\r
mPos = WNDSIZ;\r
}\r
-\r
- DeleteNode ();\r
- InsertNode ();\r
+ DeleteNode();\r
+ InsertNode();\r
}\r
\r
STATIC\r
EFI_STATUS\r
-Encode (\r
- VOID\r
- )\r
+Encode ()\r
/*++\r
\r
Routine Description:\r
INT32 LastMatchLen;\r
NODE LastMatchPos;\r
\r
- Status = AllocateMemory ();\r
- if (EFI_ERROR (Status)) {\r
- FreeMemory ();\r
+ Status = AllocateMemory();\r
+ if (EFI_ERROR(Status)) {\r
+ FreeMemory();\r
return Status;\r
}\r
\r
- InitSlide ();\r
-\r
- HufEncodeStart ();\r
-\r
- mRemainder = FreadCrc (&mText[WNDSIZ], WNDSIZ + MAXMATCH);\r
+ InitSlide();\r
+ \r
+ HufEncodeStart();\r
\r
- mMatchLen = 0;\r
- mPos = WNDSIZ;\r
- InsertNode ();\r
+ mRemainder = FreadCrc(&mText[WNDSIZ], WNDSIZ + MAXMATCH);\r
+ \r
+ mMatchLen = 0;\r
+ mPos = WNDSIZ;\r
+ InsertNode();\r
if (mMatchLen > mRemainder) {\r
mMatchLen = mRemainder;\r
}\r
-\r
while (mRemainder > 0) {\r
- LastMatchLen = mMatchLen;\r
- LastMatchPos = mMatchPos;\r
- GetNextMatch ();\r
+ LastMatchLen = mMatchLen;\r
+ LastMatchPos = mMatchPos;\r
+ GetNextMatch();\r
if (mMatchLen > mRemainder) {\r
mMatchLen = mRemainder;\r
}\r
-\r
+ \r
if (mMatchLen > LastMatchLen || LastMatchLen < THRESHOLD) {\r
+ \r
//\r
// Not enough benefits are gained by outputting a pointer,\r
// so just output the original character\r
//\r
- Output (mText[mPos - 1], 0);\r
-\r
+ \r
+ Output(mText[mPos - 1], 0);\r
} else {\r
-\r
- if (LastMatchLen == THRESHOLD) {\r
- if (((mPos - LastMatchPos - 2) & (WNDSIZ - 1)) > (1U << 11)) {\r
- Output (mText[mPos - 1], 0);\r
- continue;\r
- }\r
- }\r
+ \r
//\r
// Outputting a pointer is beneficial enough, do it.\r
//\r
- Output (\r
- LastMatchLen + (UINT8_MAX + 1 - THRESHOLD),\r
- (mPos - LastMatchPos - 2) & (WNDSIZ - 1)\r
- );\r
- LastMatchLen--;\r
- while (LastMatchLen > 0) {\r
- GetNextMatch ();\r
- LastMatchLen--;\r
+ \r
+ Output(LastMatchLen + (UINT8_MAX + 1 - THRESHOLD),\r
+ (mPos - LastMatchPos - 2) & (WNDSIZ - 1));\r
+ while (--LastMatchLen > 0) {\r
+ GetNextMatch();\r
}\r
-\r
if (mMatchLen > mRemainder) {\r
mMatchLen = mRemainder;\r
}\r
}\r
}\r
-\r
- HufEncodeEnd ();\r
- FreeMemory ();\r
+ \r
+ HufEncodeEnd();\r
+ FreeMemory();\r
return EFI_SUCCESS;\r
}\r
\r
-STATIC\r
-VOID\r
-CountTFreq (\r
- VOID\r
- )\r
+STATIC \r
+VOID \r
+CountTFreq ()\r
/*++\r
\r
Routine Description:\r
\r
--*/\r
{\r
- INT32 Index;\r
- INT32 Index3;\r
- INT32 Number;\r
- INT32 Count;\r
+ INT32 i, k, n, Count;\r
\r
- for (Index = 0; Index < NT; Index++) {\r
- mTFreq[Index] = 0;\r
+ for (i = 0; i < NT; i++) {\r
+ mTFreq[i] = 0;\r
}\r
-\r
- Number = NC;\r
- while (Number > 0 && mCLen[Number - 1] == 0) {\r
- Number--;\r
+ n = NC;\r
+ while (n > 0 && mCLen[n - 1] == 0) {\r
+ n--;\r
}\r
-\r
- Index = 0;\r
- while (Index < Number) {\r
- Index3 = mCLen[Index++];\r
- if (Index3 == 0) {\r
+ i = 0;\r
+ while (i < n) {\r
+ k = mCLen[i++];\r
+ if (k == 0) {\r
Count = 1;\r
- while (Index < Number && mCLen[Index] == 0) {\r
- Index++;\r
+ while (i < n && mCLen[i] == 0) {\r
+ i++;\r
Count++;\r
}\r
-\r
if (Count <= 2) {\r
- mTFreq[0] = (UINT16) (mTFreq[0] + Count);\r
+ mTFreq[0] = (UINT16)(mTFreq[0] + Count);\r
} else if (Count <= 18) {\r
mTFreq[1]++;\r
} else if (Count == 19) {\r
mTFreq[2]++;\r
}\r
} else {\r
- mTFreq[Index3 + 2]++;\r
+ mTFreq[k + 2]++;\r
}\r
}\r
}\r
\r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
WritePTLen (\r
- IN INT32 Number,\r
- IN INT32 nbit,\r
+ IN INT32 n, \r
+ IN INT32 nbit, \r
IN INT32 Special\r
)\r
/*++\r
\r
Arguments:\r
\r
- Number - the number of symbols\r
+ n - the number of symbols\r
nbit - the number of bits needed to represent 'n'\r
Special - the special symbol that needs to be take care of\r
\r
\r
--*/\r
{\r
- INT32 Index;\r
- INT32 Index3;\r
+ INT32 i, k;\r
\r
- while (Number > 0 && mPTLen[Number - 1] == 0) {\r
- Number--;\r
+ while (n > 0 && mPTLen[n - 1] == 0) {\r
+ n--;\r
}\r
-\r
- PutBits (nbit, Number);\r
- Index = 0;\r
- while (Index < Number) {\r
- Index3 = mPTLen[Index++];\r
- if (Index3 <= 6) {\r
- PutBits (3, Index3);\r
+ PutBits(nbit, n);\r
+ i = 0;\r
+ while (i < n) {\r
+ k = mPTLen[i++];\r
+ if (k <= 6) {\r
+ PutBits(3, k);\r
} else {\r
- PutBits (Index3 - 3, (1U << (Index3 - 3)) - 2);\r
+ PutBits(k - 3, (1U << (k - 3)) - 2);\r
}\r
-\r
- if (Index == Special) {\r
- while (Index < 6 && mPTLen[Index] == 0) {\r
- Index++;\r
+ if (i == Special) {\r
+ while (i < 6 && mPTLen[i] == 0) {\r
+ i++;\r
}\r
-\r
- PutBits (2, (Index - 3) & 3);\r
+ PutBits(2, (i - 3) & 3);\r
}\r
}\r
}\r
\r
-STATIC\r
-VOID\r
-WriteCLen (\r
- VOID\r
- )\r
+STATIC \r
+VOID \r
+WriteCLen ()\r
/*++\r
\r
Routine Description:\r
\r
--*/\r
{\r
- INT32 Index;\r
- INT32 Index3;\r
- INT32 Number;\r
- INT32 Count;\r
-\r
- Number = NC;\r
- while (Number > 0 && mCLen[Number - 1] == 0) {\r
- Number--;\r
- }\r
+ INT32 i, k, n, Count;\r
\r
- PutBits (CBIT, Number);\r
- Index = 0;\r
- while (Index < Number) {\r
- Index3 = mCLen[Index++];\r
- if (Index3 == 0) {\r
+ n = NC;\r
+ while (n > 0 && mCLen[n - 1] == 0) {\r
+ n--;\r
+ }\r
+ PutBits(CBIT, n);\r
+ i = 0;\r
+ while (i < n) {\r
+ k = mCLen[i++];\r
+ if (k == 0) {\r
Count = 1;\r
- while (Index < Number && mCLen[Index] == 0) {\r
- Index++;\r
+ while (i < n && mCLen[i] == 0) {\r
+ i++;\r
Count++;\r
}\r
-\r
if (Count <= 2) {\r
- for (Index3 = 0; Index3 < Count; Index3++) {\r
- PutBits (mPTLen[0], mPTCode[0]);\r
+ for (k = 0; k < Count; k++) {\r
+ PutBits(mPTLen[0], mPTCode[0]);\r
}\r
} else if (Count <= 18) {\r
- PutBits (mPTLen[1], mPTCode[1]);\r
- PutBits (4, Count - 3);\r
+ PutBits(mPTLen[1], mPTCode[1]);\r
+ PutBits(4, Count - 3);\r
} else if (Count == 19) {\r
- PutBits (mPTLen[0], mPTCode[0]);\r
- PutBits (mPTLen[1], mPTCode[1]);\r
- PutBits (4, 15);\r
+ PutBits(mPTLen[0], mPTCode[0]);\r
+ PutBits(mPTLen[1], mPTCode[1]);\r
+ PutBits(4, 15);\r
} else {\r
- PutBits (mPTLen[2], mPTCode[2]);\r
- PutBits (CBIT, Count - 20);\r
+ PutBits(mPTLen[2], mPTCode[2]);\r
+ PutBits(CBIT, Count - 20);\r
}\r
} else {\r
- PutBits (mPTLen[Index3 + 2], mPTCode[Index3 + 2]);\r
+ PutBits(mPTLen[k + 2], mPTCode[k + 2]);\r
}\r
}\r
}\r
\r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
EncodeC (\r
- IN INT32 Value\r
+ IN INT32 c\r
)\r
{\r
- PutBits (mCLen[Value], mCCode[Value]);\r
+ PutBits(mCLen[c], mCCode[c]);\r
}\r
\r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
EncodeP (\r
- IN UINT32 Value\r
+ IN UINT32 p\r
)\r
{\r
- UINT32 Index;\r
- UINT32 NodeQ;\r
-\r
- Index = 0;\r
- NodeQ = Value;\r
- while (NodeQ) {\r
- NodeQ >>= 1;\r
- Index++;\r
- }\r
+ UINT32 c, q;\r
\r
- PutBits (mPTLen[Index], mPTCode[Index]);\r
- if (Index > 1) {\r
- PutBits (Index - 1, Value & (0xFFFFFFFFU >> (32 - Index + 1)));\r
+ c = 0;\r
+ q = p;\r
+ while (q) {\r
+ q >>= 1;\r
+ c++;\r
+ }\r
+ PutBits(mPTLen[c], mPTCode[c]);\r
+ if (c > 1) {\r
+ PutBits(c - 1, p & (0xFFFFU >> (17 - c)));\r
}\r
}\r
\r
-STATIC\r
-VOID\r
-SendBlock (\r
- VOID\r
- )\r
+STATIC \r
+VOID \r
+SendBlock ()\r
/*++\r
\r
Routine Description:\r
\r
Huffman code the block and output it.\r
\r
-Arguments: \r
- (VOID)\r
+Argument: (VOID)\r
\r
-Returns: \r
- (VOID)\r
+Returns: (VOID)\r
\r
--*/\r
{\r
- UINT32 Index;\r
- UINT32 Index2;\r
- UINT32 Index3;\r
- UINT32 Flags;\r
- UINT32 Root;\r
- UINT32 Pos;\r
- UINT32 Size;\r
+ UINT32 i, k, Flags, Root, Pos, Size;\r
Flags = 0;\r
\r
- Root = MakeTree (NC, mCFreq, mCLen, mCCode);\r
- Size = mCFreq[Root];\r
- PutBits (16, Size);\r
+ Root = MakeTree(NC, mCFreq, mCLen, mCCode);\r
+ Size = mCFreq[Root];\r
+ PutBits(16, Size);\r
if (Root >= NC) {\r
- CountTFreq ();\r
- Root = MakeTree (NT, mTFreq, mPTLen, mPTCode);\r
+ CountTFreq();\r
+ Root = MakeTree(NT, mTFreq, mPTLen, mPTCode);\r
if (Root >= NT) {\r
- WritePTLen (NT, TBIT, 3);\r
+ WritePTLen(NT, TBIT, 3);\r
} else {\r
- PutBits (TBIT, 0);\r
- PutBits (TBIT, Root);\r
+ PutBits(TBIT, 0);\r
+ PutBits(TBIT, Root);\r
}\r
-\r
- WriteCLen ();\r
+ WriteCLen();\r
} else {\r
- PutBits (TBIT, 0);\r
- PutBits (TBIT, 0);\r
- PutBits (CBIT, 0);\r
- PutBits (CBIT, Root);\r
+ PutBits(TBIT, 0);\r
+ PutBits(TBIT, 0);\r
+ PutBits(CBIT, 0);\r
+ PutBits(CBIT, Root);\r
}\r
-\r
- Root = MakeTree (NP, mPFreq, mPTLen, mPTCode);\r
+ Root = MakeTree(NP, mPFreq, mPTLen, mPTCode);\r
if (Root >= NP) {\r
- WritePTLen (NP, PBIT, -1);\r
+ WritePTLen(NP, PBIT, -1);\r
} else {\r
- PutBits (PBIT, 0);\r
- PutBits (PBIT, Root);\r
+ PutBits(PBIT, 0);\r
+ PutBits(PBIT, Root);\r
}\r
-\r
Pos = 0;\r
- for (Index = 0; Index < Size; Index++) {\r
- if (Index % UINT8_BIT == 0) {\r
+ for (i = 0; i < Size; i++) {\r
+ if (i % UINT8_BIT == 0) {\r
Flags = mBuf[Pos++];\r
} else {\r
Flags <<= 1;\r
}\r
-\r
if (Flags & (1U << (UINT8_BIT - 1))) {\r
- EncodeC (mBuf[Pos++] + (1U << UINT8_BIT));\r
- Index3 = mBuf[Pos++];\r
- for (Index2 = 0; Index2 < 3; Index2++) {\r
- Index3 <<= UINT8_BIT;\r
- Index3 += mBuf[Pos++];\r
- }\r
-\r
- EncodeP (Index3);\r
+ EncodeC(mBuf[Pos++] + (1U << UINT8_BIT));\r
+ k = mBuf[Pos++] << UINT8_BIT;\r
+ k += mBuf[Pos++];\r
+ EncodeP(k);\r
} else {\r
- EncodeC (mBuf[Pos++]);\r
+ EncodeC(mBuf[Pos++]);\r
}\r
}\r
-\r
- for (Index = 0; Index < NC; Index++) {\r
- mCFreq[Index] = 0;\r
+ for (i = 0; i < NC; i++) {\r
+ mCFreq[i] = 0;\r
}\r
-\r
- for (Index = 0; Index < NP; Index++) {\r
- mPFreq[Index] = 0;\r
+ for (i = 0; i < NP; i++) {\r
+ mPFreq[i] = 0;\r
}\r
}\r
\r
-STATIC\r
-VOID\r
+\r
+STATIC \r
+VOID \r
Output (\r
- IN UINT32 CharC,\r
- IN UINT32 Pos\r
+ IN UINT32 c, \r
+ IN UINT32 p\r
)\r
/*++\r
\r
\r
Arguments:\r
\r
- CharC - The original character or the 'String Length' element of a Pointer\r
- Pos - The 'Position' field of a Pointer\r
+ c - The original character or the 'String Length' element of a Pointer\r
+ p - The 'Position' field of a Pointer\r
\r
Returns: (VOID)\r
\r
--*/\r
{\r
- static UINT32 CPos;\r
+ STATIC UINT32 CPos;\r
\r
if ((mOutputMask >>= 1) == 0) {\r
mOutputMask = 1U << (UINT8_BIT - 1);\r
- //\r
- // Check the buffer overflow per outputing UINT8_BIT symbols\r
- // which is an Original Character or a Pointer. The biggest\r
- // symbol is a Pointer which occupies 5 bytes.\r
- //\r
- if (mOutputPos >= mBufSiz - 5 * UINT8_BIT) {\r
- SendBlock ();\r
+ if (mOutputPos >= mBufSiz - 3 * UINT8_BIT) {\r
+ SendBlock();\r
mOutputPos = 0;\r
}\r
-\r
- CPos = mOutputPos++;\r
- mBuf[CPos] = 0;\r
+ CPos = mOutputPos++; \r
+ mBuf[CPos] = 0;\r
}\r
-\r
- mBuf[mOutputPos++] = (UINT8) CharC;\r
- mCFreq[CharC]++;\r
- if (CharC >= (1U << UINT8_BIT)) {\r
+ mBuf[mOutputPos++] = (UINT8) c;\r
+ mCFreq[c]++;\r
+ if (c >= (1U << UINT8_BIT)) {\r
mBuf[CPos] |= mOutputMask;\r
- mBuf[mOutputPos++] = (UINT8) (Pos >> 24);\r
- mBuf[mOutputPos++] = (UINT8) (Pos >> 16);\r
- mBuf[mOutputPos++] = (UINT8) (Pos >> (UINT8_BIT));\r
- mBuf[mOutputPos++] = (UINT8) Pos;\r
- CharC = 0;\r
- while (Pos) {\r
- Pos >>= 1;\r
- CharC++;\r
+ mBuf[mOutputPos++] = (UINT8)(p >> UINT8_BIT);\r
+ mBuf[mOutputPos++] = (UINT8) p;\r
+ c = 0;\r
+ while (p) {\r
+ p >>= 1;\r
+ c++;\r
}\r
-\r
- mPFreq[CharC]++;\r
+ mPFreq[c]++;\r
}\r
}\r
\r
STATIC\r
VOID\r
-HufEncodeStart (\r
- VOID\r
- )\r
+HufEncodeStart ()\r
{\r
- INT32 Index;\r
+ INT32 i;\r
\r
- for (Index = 0; Index < NC; Index++) {\r
- mCFreq[Index] = 0;\r
+ for (i = 0; i < NC; i++) {\r
+ mCFreq[i] = 0;\r
}\r
-\r
- for (Index = 0; Index < NP; Index++) {\r
- mPFreq[Index] = 0;\r
+ for (i = 0; i < NP; i++) {\r
+ mPFreq[i] = 0;\r
}\r
-\r
mOutputPos = mOutputMask = 0;\r
- InitPutBits ();\r
- return ;\r
+ InitPutBits();\r
+ return;\r
}\r
\r
-STATIC\r
-VOID\r
-HufEncodeEnd (\r
- VOID\r
- )\r
+STATIC \r
+VOID \r
+HufEncodeEnd ()\r
{\r
- SendBlock ();\r
-\r
+ SendBlock();\r
+ \r
//\r
// Flush remaining bits\r
//\r
- PutBits (UINT8_BIT - 1, 0);\r
-\r
- return ;\r
+ PutBits(UINT8_BIT - 1, 0);\r
+ \r
+ return;\r
}\r
\r
-STATIC\r
-VOID\r
-MakeCrcTable (\r
- VOID\r
- )\r
+\r
+STATIC \r
+VOID \r
+MakeCrcTable ()\r
{\r
- UINT32 Index;\r
- UINT32 Index2;\r
- UINT32 Temp;\r
-\r
- for (Index = 0; Index <= UINT8_MAX; Index++) {\r
- Temp = Index;\r
- for (Index2 = 0; Index2 < UINT8_BIT; Index2++) {\r
- if (Temp & 1) {\r
- Temp = (Temp >> 1) ^ CRCPOLY;\r
+ UINT32 i, j, r;\r
+\r
+ for (i = 0; i <= UINT8_MAX; i++) {\r
+ r = i;\r
+ for (j = 0; j < UINT8_BIT; j++) {\r
+ if (r & 1) {\r
+ r = (r >> 1) ^ CRCPOLY;\r
} else {\r
- Temp >>= 1;\r
+ r >>= 1;\r
}\r
}\r
-\r
- mCrcTable[Index] = (UINT16) Temp;\r
+ mCrcTable[i] = (UINT16)r; \r
}\r
}\r
\r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
PutBits (\r
- IN INT32 Number,\r
- IN UINT32 Value\r
+ IN INT32 n, \r
+ IN UINT32 x\r
)\r
/*++\r
\r
\r
Outputs rightmost n bits of x\r
\r
-Arguments:\r
+Argments:\r
\r
- Number - the rightmost n bits of the data is used\r
+ n - the rightmost n bits of the data is used\r
x - the data \r
\r
Returns: (VOID)\r
\r
--*/\r
{\r
- UINT8 Temp;\r
-\r
- while (Number >= mBitCount) {\r
- //\r
- // Number -= mBitCount should never equal to 32\r
- //\r
- Temp = (UINT8) (mSubBitBuf | (Value >> (Number -= mBitCount)));\r
+ UINT8 Temp; \r
+ \r
+ if (n < mBitCount) {\r
+ mSubBitBuf |= x << (mBitCount -= n);\r
+ } else {\r
+ \r
+ Temp = (UINT8)(mSubBitBuf | (x >> (n -= mBitCount)));\r
if (mDst < mDstUpperLimit) {\r
*mDst++ = Temp;\r
}\r
-\r
mCompSize++;\r
- mSubBitBuf = 0;\r
- mBitCount = UINT8_BIT;\r
- }\r
\r
- mSubBitBuf |= Value << (mBitCount -= Number);\r
+ if (n < UINT8_BIT) {\r
+ mSubBitBuf = x << (mBitCount = UINT8_BIT - n);\r
+ } else {\r
+ \r
+ Temp = (UINT8)(x >> (n - UINT8_BIT));\r
+ if (mDst < mDstUpperLimit) {\r
+ *mDst++ = Temp;\r
+ }\r
+ mCompSize++;\r
+ \r
+ mSubBitBuf = x << (mBitCount = 2 * UINT8_BIT - n);\r
+ }\r
+ }\r
}\r
\r
-STATIC\r
-INT32\r
+STATIC \r
+INT32 \r
FreadCrc (\r
- OUT UINT8 *Pointer,\r
- IN INT32 Number\r
+ OUT UINT8 *p, \r
+ IN INT32 n\r
)\r
/*++\r
\r
\r
Arguments:\r
\r
- Pointer - the buffer to hold the data\r
- Number - number of bytes to read\r
+ p - the buffer to hold the data\r
+ n - number of bytes to read\r
\r
Returns:\r
\r
\r
--*/\r
{\r
- INT32 Index;\r
+ INT32 i;\r
\r
- for (Index = 0; mSrc < mSrcUpperLimit && Index < Number; Index++) {\r
- *Pointer++ = *mSrc++;\r
+ for (i = 0; mSrc < mSrcUpperLimit && i < n; i++) {\r
+ *p++ = *mSrc++;\r
}\r
+ n = i;\r
\r
- Number = Index;\r
-\r
- Pointer -= Number;\r
- mOrigSize += Number;\r
- Index--;\r
- while (Index >= 0) {\r
- UPDATE_CRC (*Pointer++);\r
- Index--;\r
+ p -= n;\r
+ mOrigSize += n;\r
+ while (--i >= 0) {\r
+ UPDATE_CRC(*p++);\r
}\r
-\r
- return Number;\r
+ return n;\r
}\r
\r
-STATIC\r
-VOID\r
-InitPutBits (\r
- VOID\r
- )\r
+\r
+STATIC \r
+VOID \r
+InitPutBits ()\r
{\r
- mBitCount = UINT8_BIT;\r
- mSubBitBuf = 0;\r
+ mBitCount = UINT8_BIT; \r
+ mSubBitBuf = 0;\r
}\r
\r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
CountLen (\r
- IN INT32 Index\r
+ IN INT32 i\r
)\r
/*++\r
\r
\r
Arguments:\r
\r
- Index - the top node\r
+ i - the top node\r
\r
Returns: (VOID)\r
\r
--*/\r
{\r
- static INT32 Depth = 0;\r
+ STATIC INT32 Depth = 0;\r
\r
- if (Index < mN) {\r
+ if (i < mN) {\r
mLenCnt[(Depth < 16) ? Depth : 16]++;\r
} else {\r
Depth++;\r
- CountLen (mLeft[Index]);\r
- CountLen (mRight[Index]);\r
+ CountLen(mLeft [i]);\r
+ CountLen(mRight[i]);\r
Depth--;\r
}\r
}\r
\r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
MakeLen (\r
IN INT32 Root\r
)\r
Arguments:\r
\r
Root - the root of the tree\r
- \r
-Returns:\r
-\r
- VOID\r
\r
--*/\r
{\r
- INT32 Index;\r
- INT32 Index3;\r
- UINT32 Cum;\r
+ INT32 i, k;\r
+ UINT32 Cum;\r
\r
- for (Index = 0; Index <= 16; Index++) {\r
- mLenCnt[Index] = 0;\r
+ for (i = 0; i <= 16; i++) {\r
+ mLenCnt[i] = 0;\r
}\r
-\r
- CountLen (Root);\r
-\r
+ CountLen(Root);\r
+ \r
//\r
// Adjust the length count array so that\r
// no code will be generated longer than its designated length\r
//\r
+ \r
Cum = 0;\r
- for (Index = 16; Index > 0; Index--) {\r
- Cum += mLenCnt[Index] << (16 - Index);\r
+ for (i = 16; i > 0; i--) {\r
+ Cum += mLenCnt[i] << (16 - i);\r
}\r
-\r
while (Cum != (1U << 16)) {\r
mLenCnt[16]--;\r
- for (Index = 15; Index > 0; Index--) {\r
- if (mLenCnt[Index] != 0) {\r
- mLenCnt[Index]--;\r
- mLenCnt[Index + 1] += 2;\r
+ for (i = 15; i > 0; i--) {\r
+ if (mLenCnt[i] != 0) {\r
+ mLenCnt[i]--;\r
+ mLenCnt[i+1] += 2;\r
break;\r
}\r
}\r
-\r
Cum--;\r
}\r
-\r
- for (Index = 16; Index > 0; Index--) {\r
- Index3 = mLenCnt[Index];\r
- Index3--;\r
- while (Index3 >= 0) {\r
- mLen[*mSortPtr++] = (UINT8) Index;\r
- Index3--;\r
+ for (i = 16; i > 0; i--) {\r
+ k = mLenCnt[i];\r
+ while (--k >= 0) {\r
+ mLen[*mSortPtr++] = (UINT8)i;\r
}\r
}\r
}\r
\r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
DownHeap (\r
- IN INT32 Index\r
+ IN INT32 i\r
)\r
{\r
- INT32 Index2;\r
- INT32 Index3;\r
+ INT32 j, k;\r
\r
//\r
- // priority queue: send Index-th entry down heap\r
+ // priority queue: send i-th entry down heap\r
//\r
- Index3 = mHeap[Index];\r
- Index2 = 2 * Index;\r
- while (Index2 <= mHeapSize) {\r
- if (Index2 < mHeapSize && mFreq[mHeap[Index2]] > mFreq[mHeap[Index2 + 1]]) {\r
- Index2++;\r
+ \r
+ k = mHeap[i];\r
+ while ((j = 2 * i) <= mHeapSize) {\r
+ if (j < mHeapSize && mFreq[mHeap[j]] > mFreq[mHeap[j + 1]]) {\r
+ j++;\r
}\r
-\r
- if (mFreq[Index3] <= mFreq[mHeap[Index2]]) {\r
+ if (mFreq[k] <= mFreq[mHeap[j]]) {\r
break;\r
}\r
-\r
- mHeap[Index] = mHeap[Index2];\r
- Index = Index2;\r
- Index2 = 2 * Index;\r
+ mHeap[i] = mHeap[j];\r
+ i = j;\r
}\r
-\r
- mHeap[Index] = (INT16) Index3;\r
+ mHeap[i] = (INT16)k;\r
}\r
\r
-STATIC\r
-VOID\r
+STATIC \r
+VOID \r
MakeCode (\r
- IN INT32 Number,\r
- IN UINT8 Len[ ],\r
+ IN INT32 n, \r
+ IN UINT8 Len[], \r
OUT UINT16 Code[]\r
)\r
/*++\r
\r
Arguments:\r
\r
- Number - number of symbols\r
+ n - number of symbols\r
Len - the code length array\r
Code - stores codes for each symbol\r
\r
\r
--*/\r
{\r
- INT32 Index;\r
- UINT16 Start[18];\r
+ INT32 i;\r
+ UINT16 Start[18];\r
\r
Start[1] = 0;\r
- for (Index = 1; Index <= 16; Index++) {\r
- Start[Index + 1] = (UINT16) ((Start[Index] + mLenCnt[Index]) << 1);\r
+ for (i = 1; i <= 16; i++) {\r
+ Start[i + 1] = (UINT16)((Start[i] + mLenCnt[i]) << 1);\r
}\r
-\r
- for (Index = 0; Index < Number; Index++) {\r
- Code[Index] = Start[Len[Index]]++;\r
+ for (i = 0; i < n; i++) {\r
+ Code[i] = Start[Len[i]]++;\r
}\r
}\r
\r
-STATIC\r
-INT32\r
+STATIC \r
+INT32 \r
MakeTree (\r
- IN INT32 NParm,\r
- IN UINT16 FreqParm[],\r
- OUT UINT8 LenParm[ ],\r
+ IN INT32 NParm, \r
+ IN UINT16 FreqParm[], \r
+ OUT UINT8 LenParm[], \r
OUT UINT16 CodeParm[]\r
)\r
/*++\r
\r
--*/\r
{\r
- INT32 Index;\r
- INT32 Index2;\r
- INT32 Index3;\r
- INT32 Avail;\r
-\r
+ INT32 i, j, k, Avail;\r
+ \r
//\r
// make tree, calculate len[], return root\r
//\r
- mN = NParm;\r
- mFreq = FreqParm;\r
- mLen = LenParm;\r
- Avail = mN;\r
+\r
+ mN = NParm;\r
+ mFreq = FreqParm;\r
+ mLen = LenParm;\r
+ Avail = mN;\r
mHeapSize = 0;\r
- mHeap[1] = 0;\r
- for (Index = 0; Index < mN; Index++) {\r
- mLen[Index] = 0;\r
- if (mFreq[Index]) {\r
- mHeapSize++;\r
- mHeap[mHeapSize] = (INT16) Index;\r
- }\r
+ mHeap[1] = 0;\r
+ for (i = 0; i < mN; i++) {\r
+ mLen[i] = 0;\r
+ if (mFreq[i]) {\r
+ mHeap[++mHeapSize] = (INT16)i;\r
+ } \r
}\r
-\r
if (mHeapSize < 2) {\r
CodeParm[mHeap[1]] = 0;\r
return mHeap[1];\r
}\r
-\r
- for (Index = mHeapSize / 2; Index >= 1; Index--) {\r
+ for (i = mHeapSize / 2; i >= 1; i--) {\r
+ \r
//\r
- // make priority queue\r
+ // make priority queue \r
//\r
- DownHeap (Index);\r
+ DownHeap(i);\r
}\r
-\r
mSortPtr = CodeParm;\r
do {\r
- Index = mHeap[1];\r
- if (Index < mN) {\r
- *mSortPtr++ = (UINT16) Index;\r
+ i = mHeap[1];\r
+ if (i < mN) {\r
+ *mSortPtr++ = (UINT16)i;\r
}\r
-\r
mHeap[1] = mHeap[mHeapSize--];\r
- DownHeap (1);\r
- Index2 = mHeap[1];\r
- if (Index2 < mN) {\r
- *mSortPtr++ = (UINT16) Index2;\r
+ DownHeap(1);\r
+ j = mHeap[1];\r
+ if (j < mN) {\r
+ *mSortPtr++ = (UINT16)j;\r
}\r
-\r
- Index3 = Avail++;\r
- mFreq[Index3] = (UINT16) (mFreq[Index] + mFreq[Index2]);\r
- mHeap[1] = (INT16) Index3;\r
- DownHeap (1);\r
- mLeft[Index3] = (UINT16) Index;\r
- mRight[Index3] = (UINT16) Index2;\r
+ k = Avail++;\r
+ mFreq[k] = (UINT16)(mFreq[i] + mFreq[j]);\r
+ mHeap[1] = (INT16)k;\r
+ DownHeap(1);\r
+ mLeft[k] = (UINT16)i;\r
+ mRight[k] = (UINT16)j;\r
} while (mHeapSize > 1);\r
-\r
+ \r
mSortPtr = CodeParm;\r
- MakeLen (Index3);\r
- MakeCode (NParm, LenParm, CodeParm);\r
-\r
+ MakeLen(k);\r
+ MakeCode(NParm, LenParm, CodeParm);\r
+ \r
//\r
// return root\r
//\r
- return Index3;\r
+ return k;\r
}\r
+\r
projects / mirror_edk2.git / blobdiff