rle.inl

本人有关PLC测试源码

//===================================================================
inline int RLE_PCX_Decode (const BYTE* InBuffer, int nInSize, BYTE* OutBuffer)
{
	const BYTE     * pOutStart = OutBuffer ;
	while (nInSize-- > 0)
	{
		const BYTE    byData = *InBuffer++ ; // read byte and move ptr to next
		if ( (byData & 0xC0) == 0xC0 ) // Data >= 0xC0
		{
			const BYTE    cNum = byData & 0x3F ; // repeat current byte Num

            // error : we will copy current byte but the inbuffer is exhausted.
            if (nInSize <= 0)
            {
                assert(false) ; return (OutBuffer - pOutStart) ;
            }

			::memset (OutBuffer, *InBuffer++, cNum) ; // memset func will check "Num" =? 0
			OutBuffer += cNum ;
			nInSize-- ;
		}
		else
			*OutBuffer++ = byData ;
	}
	return (OutBuffer - pOutStart) ;
}
//===================================================================
inline int RLE_PCX_Encode (const BYTE* InBuffer, int nInSize, BYTE* OutBuffer)
{
	const BYTE    * pOutStart = OutBuffer ;
	while (nInSize-- > 0)
	{
              BYTE    cCount = 1 ;
        const BYTE    byData = *InBuffer++ ;
		while ( (cCount < 0x3F) && (nInSize != 0) )
			if (*InBuffer != byData) // Stat. the repeat BYTE
				break ;
			else
			{
				cCount++ ; InBuffer++ ; nInSize-- ;
			}

		if (cCount == 1) // unique
        {
			if ( (byData & 0xC0) == 0xC0 ) // Data >= 0xC0
			{
				*OutBuffer++ = 0xC1 ;
				*OutBuffer++ = byData ;
			}
			else
				*OutBuffer++ = byData ; // Data < 0xC0, write directly
        }
		else // repeat
		{
			*OutBuffer++ = 0xC0 | cCount ;
			*OutBuffer++ = byData ;
		}
	}
	return (OutBuffer - pOutStart) ;
}
//===================================================================
inline BYTE* RLE_TGA_DecodeLine (const BYTE* InBuffer, int iColorBit, int iNumPixel, BYTE * OutBuffer)
{
	iColorBit /= 8 ; // convert to bytes : 1,2,3,4
	while (iNumPixel > 0)
	{
		const BYTE    byData = *InBuffer++ ; // Next Byte
		if (byData & 0x80) // Data >= 0x80
		{
            const int    nNum = (byData & 0x7F) + 1 ; // number of repeat pixel
			iNumPixel -= nNum ;
			for (int i=0 ; i < nNum ; i++, OutBuffer += iColorBit)
                FCColor::CopyPixel (OutBuffer, InBuffer, iColorBit) ;
            InBuffer += iColorBit ;
		}
		else // directly copy Num - pixel
		{
            const int   Num = byData + 1, // non-repeat pixel
                        nSpan = Num * iColorBit ; // calculate numbers of copy bytes
			iNumPixel -= Num ;
			::memcpy (OutBuffer, InBuffer, nSpan) ;
			OutBuffer += nSpan ;
			InBuffer += nSpan ;
		}
	}
	return const_cast<BYTE*>(InBuffer) ;
}
//===================================================================
inline BYTE* RLE_TGA_EncodeLine (const BYTE * InBuffer, int iColorBit, int iNumPixel, BYTE * OutBuffer)
{
	iColorBit /= 8 ; // convert to bytes : 1,2,3,4
	while (iNumPixel > 0)
	{
		DWORD         Data = 0, Next = 0, Count = 1 ;
		FCColor::CopyPixel (&Data, InBuffer, iColorBit) ; // first pixel
		InBuffer += iColorBit ; iNumPixel-- ;
		while ((Count < 0x80) && (iNumPixel > 0)) // Stat. the repeat pixel
		{
			FCColor::CopyPixel (&Next, InBuffer, iColorBit) ; // next pixel
			if (Next != Data)
				break ;
			InBuffer += iColorBit ; iNumPixel-- ; Count++ ;
		}

		*OutBuffer++ = 0x80 | (BYTE)--Count ;
		FCColor::CopyPixel (OutBuffer, &Data, iColorBit) ;
		OutBuffer += iColorBit ;
	}
	return OutBuffer ;
}
//===================================================================
inline int RLE_TGA_Encode (const BYTE * InBuffer, int nInSize, BYTE * OutBuffer, int nPack)
{
    if (((nInSize * 8) % nPack) != 0)
        return 0 ;
    return ::RLE_TGA_EncodeLine (InBuffer, nPack, nInSize * 8 / nPack, OutBuffer) - OutBuffer ;
}
inline void RLE_TGA_Decode (const BYTE * InBuffer, int nOriSize, BYTE * OutBuffer, int nPack)
{
    ::RLE_TGA_DecodeLine (InBuffer, nPack, nOriSize * 8 / nPack, OutBuffer) ;
}
//===================================================================