diff --git a/common/crc.h b/common/crc.h index fa01921635e..9a47fc1df5c 100644 --- a/common/crc.h +++ b/common/crc.h @@ -23,7 +23,7 @@ * * Filename: crc.c * - * Description: Slow and fast implementations of the CRC standards. + * Description: Fast implementation of the CRC standards. * * Notes: * @@ -41,139 +41,44 @@ namespace Common { -template -class CRCCommon { -public: - CRCCommon(T poly, T init_remainder, T final_xor); - T finalize(T remainder) const; - T crcSlow(byte const message[], int nBytes) const; - T getInitRemainder() const { return reflectRemainder(_init_remainder); } - -protected: - const T _poly; - const T _init_remainder; - const T _final_xor; - - const int _width; - const int _topbit; - - template - static R reflect(R data); - - byte reflectData(byte x) const { return need_reflect ? reflect(x) : x; } - T reflectRemainder(T x) const { return need_reflect ? reflect(x) : x; } -}; - template -class CRCNormal : public CRCCommon { +class CRCNormal { public: CRCNormal(T poly, T init_remainder, T final_xor); T crcFast(byte const message[], int nBytes) const; T processByte(byte byteVal, T remainder) const; + T getInitRemainder() const { return _init_remainder; } + T finalize(T remainder) const { return remainder ^ _final_xor; } private: + const T _init_remainder; + const T _final_xor; + T _crcTable[256]; }; template -class CRCReflected : public CRCCommon { +class CRCReflected { public: CRCReflected(T poly, T init_remainder, T final_xor); T crcFast(byte const message[], int nBytes) const; T processByte(byte byteVal, T remainder) const; + T getInitRemainder() const { return _reflected_init_remainder; } + T finalize(T remainder) const { return remainder ^ _final_xor; } private: T _crcTable[256]; + const T _reflected_init_remainder; + const T _final_xor; }; -/********************************************************************* - * - * Function: reflect() - * - * Description: Reorder the bits of a binary sequence, by reflecting - * them about the middle position. - * - * Notes: No checking is done that nBits <= 32. - * - * Returns: The reflection of the original data. - * - *********************************************************************/ -template template -R CRCCommon::reflect(R data) { - R reflection = 0; - - /* - * Reflect the data about the center bit. - */ - for (byte bit = 0; bit < sizeof(R) * 8; ++bit) { - /* - * If the LSB bit is set, set the reflection of it. - */ - if (data & 0x01) { - reflection |= (1 << ((sizeof(R) * 8 - 1) - bit)); - } - - data = (data >> 1); - } - - return reflection; -} - - -/********************************************************************* - * - * Function: crcSlow() - * - * Description: Compute the CRC of a given message. - * - * Notes: - * - * Returns: The CRC of the message. - * - *********************************************************************/ -template -T CRCCommon::crcSlow(byte const message[], int nBytes) const { - T remainder = _init_remainder; - - /* - * Perform modulo-2 division, a byte at a time. - */ - for (int b = 0; b < nBytes; ++b) { - /* - * Bring the next byte into the remainder. - */ - remainder ^= reflectData(message[b]) << (_width - 8); - - /* - * Perform modulo-2 division, a bit at a time. - */ - for (byte bit = 8; bit > 0; --bit) { - /* - * Try to divide the current data bit. - */ - if (remainder & _topbit) { - remainder = (remainder << 1) ^ _poly; - } else { - remainder = (remainder << 1); - } - } - } - - /* - * The final remainder is the CRC result. - */ - return reflectRemainder(remainder) ^ _final_xor; -} - - -template -CRCCommon::CRCCommon(T poly, T init_remainder, T final_xor) : - _poly(poly), _init_remainder(init_remainder), _final_xor(final_xor), _width(8 * sizeof(T)), _topbit(1 << (8 * sizeof(T) - 1)) {} template -CRCNormal::CRCNormal(T poly, T init_remainder, T final_xor) : CRCCommon(poly, init_remainder, final_xor) { +CRCNormal::CRCNormal(T poly, T init_remainder, T final_xor) : _init_remainder(init_remainder), _final_xor(final_xor) { + const T topbit = 1ULL << (8 * sizeof(T) - 1); + /* * Compute the remainder of each possible dividend. */ @@ -181,7 +86,7 @@ CRCNormal::CRCNormal(T poly, T init_remainder, T final_xor) : CRCCommon_width - 8); + T remainder = dividend << (8 * sizeof(T) - 8); /* * Perform modulo-2 division, a bit at a time. @@ -190,8 +95,8 @@ CRCNormal::CRCNormal(T poly, T init_remainder, T final_xor) : CRCCommon_topbit) { - remainder = (remainder << 1) ^ this->_poly; + if (remainder & topbit) { + remainder = (remainder << 1) ^ poly; } else { remainder = (remainder << 1); } @@ -200,14 +105,12 @@ CRCNormal::CRCNormal(T poly, T init_remainder, T final_xor) : CRCCommon_crcTable[dividend] = remainder; + _crcTable[dividend] = remainder; } } template -CRCReflected::CRCReflected(T poly, T init_remainder, T final_xor) : CRCCommon(poly, init_remainder, final_xor) { - T reflected_poly = this->reflectRemainder(poly); - +CRCReflected::CRCReflected(T reflected_poly, T reflected_init_remainder, T final_xor) : _reflected_init_remainder(reflected_init_remainder), _final_xor(final_xor) { /* * Compute the remainder of each possible dividend. */ @@ -251,20 +154,20 @@ CRCReflected::CRCReflected(T poly, T init_remainder, T final_xor) : CRCCommon *********************************************************************/ template T CRCNormal::crcFast(byte const message[], int nBytes) const { - T remainder = this->_init_remainder; + T remainder = _init_remainder; /* * Divide the message by the polynomial, a byte at a time. */ for (int b = 0; b < nBytes; ++b) { - byte data = message[b] ^ (remainder >> (this->_width - 8)); - remainder = this->_crcTable[data] ^ (remainder << 8); + byte data = message[b] ^ (remainder >> (8 * sizeof(T) - 8)); + remainder = _crcTable[data] ^ (remainder << 8); } /* * The final remainder is the CRC. */ - return remainder ^ this->_final_xor; + return remainder ^ _final_xor; } /********************************************************************* @@ -280,39 +183,34 @@ T CRCNormal::crcFast(byte const message[], int nBytes) const { *********************************************************************/ template T CRCReflected::crcFast(byte const message[], int nBytes) const { - T remainder = this->reflectRemainder(this->_init_remainder); + T remainder = _reflected_init_remainder; /* * Divide the message by the polynomial, a byte at a time. */ for (int b = 0; b < nBytes; ++b) { byte data = message[b] ^ remainder; - remainder = this->_crcTable[data] ^ (remainder >> 8); + remainder = _crcTable[data] ^ (remainder >> 8); } /* * The final remainder is the CRC. */ - return remainder ^ this->_final_xor; + return remainder ^ _final_xor; } template T CRCNormal::processByte(byte byteVal, T remainder) const { - byte data = byteVal ^ (remainder >> (this->_width - 8)); + byte data = byteVal ^ (remainder >> (8 * sizeof(T) - 8)); - return this->_crcTable[data] ^ (remainder << 8); + return _crcTable[data] ^ (remainder << 8); } template T CRCReflected::processByte(byte byteVal, T remainder) const { byte data = byteVal ^ remainder; - return this->_crcTable[data] ^ (remainder >> 8); -} - -template -T CRCCommon::finalize(T remainder) const { - return remainder ^ _final_xor; + return _crcTable[data] ^ (remainder >> 8); } class CRC_CCITT : public CRCNormal { @@ -327,12 +225,12 @@ public: class CRC16 : public CRCReflected { public: - CRC16() : CRCReflected(0x8005, 0x0000, 0x0000) {} + CRC16() : CRCReflected(0xa001, 0x0000, 0x0000) {} }; class CRC32 : public CRCReflected { public: - CRC32() : CRCReflected(0x04C11DB7, 0xFFFFFFFF, 0xFFFFFFFF) {} + CRC32() : CRCReflected(0xEDB88320, 0xFFFFFFFF, 0xFFFFFFFF) {} }; } // End of namespace Common diff --git a/common/crc_slow.h b/common/crc_slow.h new file mode 100644 index 00000000000..f06adac9944 --- /dev/null +++ b/common/crc_slow.h @@ -0,0 +1,173 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + * + */ + +/********************************************************************** + * + * Filename: crc.c + * + * Description: Slow implementation of the CRC standards. + * + * Notes: + * + * + * Copyright (c) 2000 by Michael Barr. This software is placed into + * the public domain and may be used for any purpose. However, this + * notice must not be changed or removed and no warranty is either + * expressed or implied by its publication or distribution. + **********************************************************************/ + +#ifndef COMMON_CRC_SLOW_H +#define COMMON_CRC_SLOW_H + +#include "common/system.h" // For types. + +namespace Common { + +template +class CRCSlow { +public: + CRCSlow(T poly, T init_remainder, T final_xor, bool need_reflect); + T crcSlow(byte const message[], int nBytes) const; + +protected: + const T _poly; + const T _init_remainder; + const T _final_xor; + + const int _width; + const int _topbit; + + const bool _reflect; + + template + static R reflect(R data); + + byte reflectData(byte x) const { return _reflect ? reflect(x) : x; } + T reflectRemainder(T x) const { return _reflect ? reflect(x) : x; } +}; + +/********************************************************************* + * + * Function: reflect() + * + * Description: Reorder the bits of a binary sequence, by reflecting + * them about the middle position. + * + * Notes: No checking is done that nBits <= 32. + * + * Returns: The reflection of the original data. + * + *********************************************************************/ +template template +R CRCSlow::reflect(R data) { + R reflection = 0; + + /* + * Reflect the data about the center bit. + */ + for (byte bit = 0; bit < sizeof(R) * 8; ++bit) { + /* + * If the LSB bit is set, set the reflection of it. + */ + if (data & 0x01) { + reflection |= (1 << ((sizeof(R) * 8 - 1) - bit)); + } + + data = (data >> 1); + } + + return reflection; +} + + +/********************************************************************* + * + * Function: crcSlow() + * + * Description: Compute the CRC of a given message. + * + * Notes: + * + * Returns: The CRC of the message. + * + *********************************************************************/ +template +T CRCSlow::crcSlow(byte const message[], int nBytes) const { + T remainder = _init_remainder; + + /* + * Perform modulo-2 division, a byte at a time. + */ + for (int b = 0; b < nBytes; ++b) { + /* + * Bring the next byte into the remainder. + */ + remainder ^= reflectData(message[b]) << (_width - 8); + + /* + * Perform modulo-2 division, a bit at a time. + */ + for (byte bit = 8; bit > 0; --bit) { + /* + * Try to divide the current data bit. + */ + if (remainder & _topbit) { + remainder = (remainder << 1) ^ _poly; + } else { + remainder = (remainder << 1); + } + } + } + + /* + * The final remainder is the CRC result. + */ + return reflectRemainder(remainder) ^ _final_xor; +} + + +template +CRCSlow::CRCSlow(T poly, T init_remainder, T final_xor, bool need_reflect) : + _poly(poly), _init_remainder(init_remainder), _final_xor(final_xor), _width(8 * sizeof(T)), _topbit(1 << (8 * sizeof(T) - 1)), _reflect(need_reflect) {} + +class CRC_CCITT_Slow : public CRCSlow { +public: + CRC_CCITT_Slow() : CRCSlow(0x1021, 0xFFFF, 0x0000, false) {} +}; + +class CRC_BINHEX_Slow : public CRCSlow { +public: + CRC_BINHEX_Slow() : CRCSlow(0x1021, 0x0000, 0x0000, false) {} +}; + +class CRC16_Slow : public CRCSlow { +public: + CRC16_Slow() : CRCSlow(0x8005, 0x0000, 0x0000, true) {} +}; + +class CRC32_Slow : public CRCSlow { +public: + CRC32_Slow() : CRCSlow(0x04C11DB7, 0xFFFFFFFF, 0xFFFFFFFF, true) {} +}; + +} // End of namespace Common + +#endif diff --git a/test/common/crc.h b/test/common/crc.h index 0c4ccd9d0ba..92bdf76cf4c 100644 --- a/test/common/crc.h +++ b/test/common/crc.h @@ -1,6 +1,7 @@ #include #include "common/crc.h" +#include "common/crc_slow.h" namespace { const byte *testString = (const byte *)"The quick brown fox jumps over the lazy dog"; @@ -13,7 +14,6 @@ public: void test_crc32() { Common::CRC32 crc; TS_ASSERT_EQUALS(crc.crcFast(testString, testLen), 0x414fa339U); - TS_ASSERT_EQUALS(crc.crcSlow(testString, testLen), 0x414fa339U); uint32 running = crc.getInitRemainder(); for (const byte *ptr = testString; *ptr; ptr++) running = crc.processByte(*ptr, running); @@ -23,7 +23,6 @@ public: void test_crc16() { Common::CRC16 crc; TS_ASSERT_EQUALS(crc.crcFast(testString, testLen), 0xfcdfU); - TS_ASSERT_EQUALS(crc.crcSlow(testString, testLen), 0xfcdfU); uint16 running = crc.getInitRemainder(); for (const byte *ptr = testString; *ptr; ptr++) running = crc.processByte(*ptr, running); @@ -33,7 +32,6 @@ public: void test_crc_ccitt() { Common::CRC_CCITT crc; // aka ccitt-false TS_ASSERT_EQUALS(crc.crcFast(testString, testLen), 0x8fddU); - TS_ASSERT_EQUALS(crc.crcSlow(testString, testLen), 0x8fddU); uint16 running = crc.getInitRemainder(); for (const byte *ptr = testString; *ptr; ptr++) running = crc.processByte(*ptr, running); @@ -43,10 +41,29 @@ public: void test_crc_binhex() { Common::CRC_BINHEX crc; // Aka xmodem TS_ASSERT_EQUALS(crc.crcFast(testString, testLen), 0xf0c8U); - TS_ASSERT_EQUALS(crc.crcSlow(testString, testLen), 0xf0c8U); uint16 running = crc.getInitRemainder(); for (const byte *ptr = testString; *ptr; ptr++) running = crc.processByte(*ptr, running); TS_ASSERT_EQUALS(crc.finalize(running), 0xf0c8U); } + + void test_crc32_slow() { + Common::CRC32_Slow crc; + TS_ASSERT_EQUALS(crc.crcSlow(testString, testLen), 0x414fa339U); + } + + void test_crc16_slow() { + Common::CRC16_Slow crc; + TS_ASSERT_EQUALS(crc.crcSlow(testString, testLen), 0xfcdfU); + } + + void test_crc_ccitt_slow() { + Common::CRC_CCITT_Slow crc; // aka ccitt-false + TS_ASSERT_EQUALS(crc.crcSlow(testString, testLen), 0x8fddU); + } + + void test_crc_binhex_slow() { + Common::CRC_BINHEX_Slow crc; // Aka xmodem + TS_ASSERT_EQUALS(crc.crcSlow(testString, testLen), 0xf0c8U); + } };