lhaenc.cpp

awd bios文件的修改工具

        maPosition[mpPosition + lQ] = lS | DICSIZ | PERC_FLAG;
    }
    lS = child(lR, (byte)maText[mpText + lT + maLevel[mpLevel + lR]]);
    lT = maPrev[mpPrev + lS];
    lU = maNext[mpNext + lS];
    maNext[mpNext + lT] = lU;
    maPrev[mpPrev + lU] = lT;
    lT = maPrev[mpPrev + lR];
    maNext[mpNext + lT] = lS;
    maPrev[mpPrev + lS] = lT;
    lT = maNext[mpNext + lR];
    maPrev[mpPrev + lT] = lS;
    maNext[mpNext + lS] = lT;
    maParent[mpParent + lS] = maParent[mpParent + lR];
    maParent[mpParent + lR] = NIL;
    maNext[mpNext + lR] = mA;
    mA = lR;
}

void get_next_match()
{
	dword lN;
	mR--;
	if (mR == 1363)
	{
		mR = mR;
	}
    if (++mP == (DICSIZ * 2)) 
	{
        for (lN = 0;lN < DICSIZ + MAXMATCH;lN++)
		{
            maText[mpText + lN] = maText[mpText + DICSIZ + lN];
        }
        lN = mRead(DICSIZ + MAXMATCH, DICSIZ);
        mR = mR + lN;
        mP = DICSIZ;
    }
    delete_node();
    insert_node();
}


dword mRead(dword iP,dword iNP)
{
	dword lI;
    iNP = ((iNP > mlIn - mpIn) ? mlIn - mpIn : iNP);
    for (lI = 0;lI<iNP;lI++)
	{
        maText[mpText + iP + lI] = maIn[mpIn];
        mpIn++;
    }
	mSEQ++;
    return iNP;
}

/***** encoding *****/
void count_maTFreq()
{
	dword lI;
    dword lK;
    dword lN;
    dword lC;
    for (lI = 0;lI< NT;lI++)
	{
        maTFreq[mpTFreq + lI] = 0;
    }
    lN = NC;
    while ((lN > 0) && (maCLen[mpCLen + lN - 1] == 0))
	{
        lN--;
    }
    lI = 0;
    while (lI < lN)
	{
        lK = maCLen[mpCLen + lI++];
        if (lK == 0)
		{
            lC = 1;
            while ((lI < lN) && (maCLen[mpCLen + lI] == 0))
			{
                lI++;
                lC++;
            }
            while (0==0)
			{
				if (lC <= 2)
				{
					maTFreq[mpTFreq + 0] = maTFreq[mpTFreq + 0] + (word) lC;
					break;
				}
				if (lC <= 18)
				{
					maTFreq[mpTFreq + 1]++;
					break;
				}
				if (lC == 19)
				{
					maTFreq[mpTFreq]++;
					maTFreq[mpTFreq + 1]++;
					break;
				}

                maTFreq[mpTFreq + 2]++;
				break;
            }
        } 
		else 
		{
             maTFreq[mpTFreq + lK + 2]++;
        }
    }
}

void write_maPTLen(dword iNP,dword iNB ,dword iIS )
{
	dword lI;
	dword lK;
    while ((iNP > 0) && (maPTLen[mpPTLen + iNP - 1] == 0))
	{
        iNP--;
    }
    putbits (iNB, iNP);
    lI = 0;
    while (lI < iNP)
	{
        lK = maPTLen[mpPTLen + lI++];
        if (lK <= 6)
		{
            putbits( 3, lK);
        } 
		else 
		{
            putbits (lK - 3, (1 << (lK - 3)) - 2);
        }
        if (lI == iIS) 
		{
            while ((lI < 6) && (maPTLen[mpPTLen + lI] == 0))
			{
                lI++;
            }
            putbits (2, (lI - 3) & 3);
        }
    }
}

void write_maCLen()
{
	dword lI;
	byte lK;
	dword lN;
	dword lC;
    lN = NC;
    while ((lN > 0) && (maCLen[mpCLen + lN - 1] == 0))
	{
        lN--;
    }
    putbits (CBIT, lN);
    lI = 0;
    while (lI < lN)
	{
        lK = (byte)maCLen[mpCLen + lI++];
        if (lK == 0) 
		{
            lC = 1;
            while ((lI < lN) && (maCLen[mpCLen + lI] == 0))
			{
                lI++;
                lC++;
            }


            while (0==0)
			{
				if (lC <= 2)
				{
					for (lK = 0;lK< lC;lK++ )
					{
						putbits (maPTLen[mpPTLen + 0], maPTCode[mpPTCode + 0]);
					}
					break;
				}
				if (lC <= 18)
				{
					putbits (maPTLen[mpPTLen + 1], maPTCode[ mpPTCode + 1]);
					putbits (4, lC - 3);
					break;
				}
				if (lC == 19)
				{
					putbits (maPTLen[mpPTLen + 0], maPTCode[mpPTCode + 0]);
					putbits (maPTLen[mpPTLen + 1], maPTCode[mpPTCode + 1]);
					putbits (4, 15);
					break;
				}

                putbits (maPTLen[mpPTLen + 2], maPTCode[mpPTCode + 2]);
                putbits (CBIT, lC - 20);
				break;
            }
        } 
		else 
		{
			putbits( maPTLen[mpPTLen + lK + 2], maPTCode[mpPTCode + lK + 2]);
        }
    }
}


void encode_c(dword iC)
{
    putbits( maCLen[mpCLen + iC], maCCode[mpCCode + iC]);
}

void encode_p(dword iP)
{
	dword lC;
	dword lQ;
    lC = 0;
    lQ = iP;
    while (lQ != 0)
	{
        lQ >>= 1;
        lC++;
    }
    putbits( maPTLen[mpPTLen + lC], maPTCode[mpPTCode + lC]);
    if (lC > 1)
	{
        putbits (lC - 1, iP & (65535 >> (17 - lC)));
    }
}

void send_block()
{
    dword lI ;
    dword lK ;
    dword lF ;
    dword lP ;
	dword lR;
	dword lS;
    lR = make_tree(NC, maCFreq  , maCLen , maCCode );
    lS = maCFreq[mpCFreq + lR];
    putbits (16, lS);
    if (lR >= NC) 
	{
        count_maTFreq();
        lR = make_tree(NT, maTFreq , maPTLen , maPTCode );
        if (lR >= NT) 
		{
            write_maPTLen( NT, TBIT, 3);
        }
		else 
		{
            putbits( TBIT, 0);
            putbits (TBIT, lR);
        }
        write_maCLen();
    } 
	else 
	{
        putbits (TBIT, 0);
        putbits (TBIT, 0);
        putbits (CBIT, 0);
        putbits (CBIT, lR);
    }
    lR = make_tree(NP, maPFreq , maPTLen , maPTCode );
    if (lR >= NP) 
	{
        write_maPTLen( NP, PBIT, -1);
    } 
	else 
	{
        putbits (PBIT, 0);
        putbits (PBIT, lR);
    }
    lP = 0;
    for (lI = 0;lI< lS ;lI++)
	{
        if (lI % CHAR_BIT == 0) 
		{
            lF = maBuf[mpBuf + lP++];
        }
		else 
		{
            lF <<=1;
        }
        if (lF & (1<< (CHAR_BIT - 1))) 
		{
            encode_c( maBuf[mpBuf + lP++] + (1<< CHAR_BIT));
            lK = (maBuf[mpBuf + lP++]<< CHAR_BIT);
            lK = lK + maBuf[mpBuf + lP++];
            encode_p (lK);
        } 
		else 
		{
            encode_c (maBuf[mpBuf + lP++]);
        }
    }
    for (lI = 0;lI<  NC + 1; lI++)
	{
        maCFreq[mpCFreq + lI] = 0;
    }
    for (lI = 0;lI<  NP + 1; lI++)
	{
        maPFreq[mpPFreq + lI] = 0;
    }
}

void Output(dword iC,dword  iP)
{
    mOM >>=1;
    if (mOM == 0)
	{
        mOM = 1<< (CHAR_BIT - 1);
        if (mOP >= mBfS - (3 * CHAR_BIT))
		{
            send_block();
            mOP = 0;
        }
        mCP = mOP++;
        maBuf[mpBuf + mCP] = 0;
    }
    maBuf[mpBuf + mOP++] = (byte) iC;
    maCFreq[mpCFreq + iC]++;
    if (iC >= (1<< CHAR_BIT)) 
	{
        maBuf[mpBuf + mCP] |= mOM;
        maBuf[mpBuf + mOP++] = (byte) (((word) iP )>> CHAR_BIT);
        maBuf[mpBuf + mOP++] = (byte) iP ;
        iC = 0;
        while (iP != 0)
		{
            iP >>=1;
            iC++;
        }
        maPFreq[mpPFreq + iC]++;
    }
}

void huf_encode_start()
{
	dword lI;
    mBfS = 16 * 1024;
    maBuf[mpBuf + 0] = 0;
    for (lI = 0;lI< NC + 1; lI++)
	{
        maCFreq[mpCFreq + lI] = 0;
    }
    for (lI = 0;lI< NP + 1; lI++)
	{
        maPFreq[mpPFreq + lI] = 0;
    }
    mOM = 0;
    mOP = mOM;
    init_putbits();
}

void huf_encode_end()
{
    send_block();
    putbits (CHAR_BIT - 1, 0);
}

void putbits(dword iNP , dword iX )
{
	if (mpOut >= mlIn)
	{
		mpOut++;
		return;
	}

    if (iNP < mBC)
	{
        mBC = mBC - iNP;
        mSBB = mSBB | (iX<< mBC);
    } 
	else 
	{
        iNP = iNP - mBC;
        maOut[mpOut] = (byte) (mSBB | iX>> iNP) ;
        mpOut++;
        
        if (iNP < CHAR_BIT)
		{
            mBC = CHAR_BIT - iNP;
            mSBB = (iX<< mBC);
        } 
		else 
		{
            maOut[mpOut] = (byte) (iX>> (iNP - CHAR_BIT));
            mpOut++;
            
            mBC = 2 * CHAR_BIT - iNP;
            mSBB = (iX<< mBC);
        }
    }
}

void init_putbits()
{
    mBC = CHAR_BIT;
    mSBB = 0;
}

void count_len(dword iI)
{
    if (iI < mN )
	{
        maLenCnt[mpLenCnt + ((mD < 16)? mD: 16)]++;
    } 
	else 
	{
        mD++;
        count_len (maLeft[mpLeft + iI]);
        count_len (maRight[mpRight + iI]);
        mD--;
    }
}








dword make_tree(dword iNP , word * iAF , byte * iAL ,word * iAC ) 
{
    dword lI  ;
    dword lJ  ;
    dword lK  ;
    dword lA  ;
    mN = iNP;
    maFreq = iAF;
    maLen = iAL;
	maSortPtr = iAC;
    lA = mN;
    mHS = 0;
    maHeap[mpHeap + 1] = 0;
    for (lI = 0;lI< mN;lI++)
	{
        maLen[mpLen + lI] = 0;
        if (maFreq[mpFreq + lI] != 0)
		{
            maHeap[mpHeap + ++mHS] = lI;
        }
    }
    if (mHS < 2)
	{
        iAC[maHeap[mpHeap + 1]] = 0;
        return maHeap[mpHeap + 1];
    }
    for (lI = mHS / 2; lI > 1 -1; lI--)
	{
        downheap (lI);
    }
    //'what we really want here is access to iAC from the rest of this module
      //'for some reason this doesn't work nearly the same way it does in C
	mpSortPtr = 0;
    while (mHS > 1)
	{
        lI = maHeap[mpHeap + 1];
        if (lI < mN)
		{
            maSortPtr[mpSortPtr] = (word) lI;
            mpSortPtr++;
        }
        maHeap[mpHeap + 1] = maHeap[mpHeap + mHS--];
        downheap (1);
        lJ = maHeap[mpHeap + 1];
        if (lJ < mN)
		{
            maSortPtr[mpSortPtr] = (word) lJ;
            mpSortPtr++;
        }
        lK = lA++;
        maFreq[mpFreq + lK] = maFreq[mpFreq + lI] + maFreq[mpFreq + lJ];
        maHeap[mpHeap + 1] = lK;
        downheap (1);
        maLeft[mpLeft + lK] = lI;
        maRight[mpRight + lK] = lJ;
    }
	mpSortPtr = 0;
    make_len (lK);
    make_code (iNP, iAL, iAC);
    return lK;
}

void downheap(dword iI )
{
    dword lJ;
    dword lK;
    dword ltv1;
    dword ltv2;
    lK = maHeap[mpHeap + iI];
    while ((lJ = 2 * iI) <= mHS)
	{
        ltv1 = maFreq[mpFreq + maHeap[mpHeap + lJ]];
        ltv2 = maFreq[mpFreq + maHeap[mpHeap + lJ + 1]];
        if ((lJ < mHS) && (ltv1 > ltv2) )
		{
            lJ++;
        }
        if (maFreq[mpFreq + lK] <= maFreq[mpFreq + maHeap[mpHeap + lJ]])
		{ 
			break;
		}
        maHeap[ mpHeap + iI] = maHeap[ mpHeap + lJ];
        iI = lJ;
    }
    maHeap[mpHeap + iI] = lK;
}

void make_len(dword iR )
{
    dword lI ;
    dword lK ;
    dword lC ;
    for (lI = 0 ;lI < 16 + 1;lI++)
	{
        maLenCnt[mpLenCnt + lI] = 0;
    }
    count_len( iR);
    lC = 0;
    for (lI = 16 ;lI> 1 -1; lI--)
	{
        lC += ((maLenCnt[mpLenCnt + lI]) << (16 - lI));
    }
    while (lC != (1<< 16))
	{
        maLenCnt[mpLenCnt + 16]--;
        for (lI = 15 ;lI> 1-1; lI--)
		{
            if (maLenCnt[mpLenCnt + lI]!= 0)
			{
                maLenCnt[mpLenCnt + lI]--;
                maLenCnt[mpLenCnt + lI + 1] += 2;
                break;
            }
        }
        lC--;
    }

    for (lI = 16; lI > 1 -1;lI--)
	{
        lK = maLenCnt[mpLenCnt + lI];
        while (--lK != 0xFFFFFFFF)
		{
            maLen[mpLen + maSortPtr[mpSortPtr]] = (byte) lI;
            mpSortPtr++;
        }
    }
}

void make_code(dword iNP ,byte * iAL ,word * iAC )
{
	dword lI;
	word start[18];
	start[0] = 0;
    start[1] = 0;
    for (lI = 1; lI< 16 + 1; lI++)
	{
        start[lI + 1] = (start[lI] + maLenCnt[mpLenCnt + lI]) << 1;
    }
    for (lI = 0; lI < iNP + 1;lI++)
	{
        iAC[ lI] = start[iAL[lI]]++;
    }
}