Switch to specialised CRC generator.

Author: TomHarte

src/CRC.hpp

@@ -1,122 +1,62 @@
-//
-//  CRC.hpp
-//  Clock Signal
-//
-//  Created by Thomas Harte on 18/09/2016.
-//  Copyright 2016 Thomas Harte. All rights reserved.
-//
-
 #pragma once
 
+#include <array>
+#include <bit>
 #include <cstddef>
 #include <cstdint>
+#include <numeric>
 
 namespace CRC {
-
-constexpr uint8_t reverse_byte(uint8_t byte) {
-	return
-		((byte & 0x80) ? 0x01 : 0x00) |
-		((byte & 0x40) ? 0x02 : 0x00) |
-		((byte & 0x20) ? 0x04 : 0x00) |
-		((byte & 0x10) ? 0x08 : 0x00) |
-		((byte & 0x08) ? 0x10 : 0x00) |
-		((byte & 0x04) ? 0x20 : 0x00) |
-		((byte & 0x02) ? 0x40 : 0x00) |
-		((byte & 0x01) ? 0x80 : 0x00);
-}
-
-/*! Provides a class capable of generating a CRC from source data. */
-template <typename IntType, IntType reset_value, IntType output_xor, bool reflect_input, bool reflect_output>
-class Generator {
+struct ByteSwapped16 {
 public:
-	/*!
-		Instantiates a CRC16 that will compute the CRC16 specified by the supplied
-		@c polynomial and @c reset_value.
-	*/
-	constexpr Generator(IntType polynomial) noexcept: value_(reset_value) {
-		const IntType top_bit = IntType(~(IntType(~0) >> 1));
-		for(int c = 0; c < 256; c++) {
-			IntType shift_value = IntType(c << multibyte_shift);
-			for(int b = 0; b < 8; b++) {
-				IntType exclusive_or = (shift_value&top_bit) ? polynomial : 0;
-				shift_value = IntType(shift_value << 1) ^ exclusive_or;
-			}
-			xor_table[c] = shift_value;
-		}
+	explicit constexpr ByteSwapped16(uint16_t original) noexcept {
+		value_ = std::rotl(original, 8);
 	}
+	ByteSwapped16() = default;
 
-	/// Resets the CRC to the reset value.
-	void reset() { value_ = reset_value; }
-
-	/// Updates the CRC to include @c byte.
-	void add(uint8_t byte) {
-		if constexpr (reflect_input) byte = reverse_byte(byte);
-		value_ = IntType((value_ << 8) ^ xor_table[(value_ >> multibyte_shift) ^ byte]);
-	}
-
-	/// @returns The current value of the CRC.
-	inline IntType get_value() const {
-		IntType result = value_ ^ output_xor;
-		if constexpr (reflect_output) {
-			IntType reflected_output = 0;
-			for(std::size_t c = 0; c < sizeof(IntType); ++c) {
-				reflected_output = IntType(reflected_output << 8) | IntType(reverse_byte(result & 0xff));
-				result >>= 8;
-			}
-			return reflected_output;
-		}
+	uint16_t raw() const {	return value_;	}
+	static ByteSwapped16 from_raw(const uint16_t raw) {
+		ByteSwapped16 result{};
+		result.value_ = raw;
 		return result;
 	}
 
-	/// Sets the current value of the CRC.
-	inline void set_value(IntType value) { value_ = value; }
-
-	/*!
-		A compound for:
-
-			reset()
-			[add all data from @c data]
-			get_value()
-	*/
-	template <typename Collection> IntType compute_crc(const Collection &data) {
-		return compute_crc(data.begin(), data.end());
-	}
-
-	/*!
-		A compound for:
-
-			reset()
-			[add all data from @c begin to @c end]
-			get_value()
-	*/
-	template <typename Iterator> IntType compute_crc(Iterator begin, Iterator end) {
-		reset();
-		while(begin != end) {
-			add(*begin);
-			++begin;
-		}
-		return get_value();
-	}
+	explicit operator uint16_t() const {	return std::rotl(value_, 8);	}
+	uint8_t high() const {	return uint8_t(value_ >> 0);	}
+	uint8_t low() const {	return uint8_t(value_ >> 8);	}
 
 private:
-	static constexpr int multibyte_shift = (sizeof(IntType) * 8) - 8;
-	IntType xor_table[256];
-	IntType value_;
-};
-
-/*!
-	Provides a generator of 16-bit CCITT CRCs, which amongst other uses are
-	those used by the FM and MFM disk encodings.
-*/
-struct CCITT: public Generator<uint16_t, 0xffff, 0x0000, false, false> {
-	CCITT(): Generator(0x1021) {}
-};
-
-/*!
-	Provides a generator of "standard 32-bit" CRCs.
-*/
-struct CRC32: public Generator<uint32_t, 0xffffffff, 0xffffffff, true, true> {
-	CRC32(): Generator(0x04c11db7) {}
+	uint16_t value_ = 0;
 };
 
+template <uint16_t polynomial = 0x1021, typename IteratorT>
+ByteSwapped16 crc16(IteratorT begin, const IteratorT end, const ByteSwapped16 initial = ByteSwapped16{0x0000}) {
+	// Generates an at-compile-time table mapping from the top byte of a 16-bit CRC in progress
+	// to the net XOR mask that results from bit-by-bit rotates to the left.
+	//
+	// The final table is byte swapped to simplify the loop below; the compiler proved
+	// trustworthy in spotting that these tables are independent of the type of IteratorT,
+	// including only one per polynomial in the produced binary.
+	static constexpr auto xor_table = [] {
+		constexpr uint16_t xor_masks[] = {0, std::rotl(uint16_t(polynomial ^ 1), 8)};
+		std::array<uint16_t, 256> table;
+
+		std::iota(table.begin(), table.end(), 0);
+		for(auto &value: table) {
+			for(int bit = 0; bit < 8; bit++) {
+				value = std::rotl(value, 1);
+				value ^= xor_masks[(value >> 8) & 1];
+			}
+		}
+		return table;
+	} ();
+
+	// Calculate the CRC in byte-swapped form so as slighltly to simplify the inner loop.
+	uint16_t crc = initial.raw();
+	while(begin != end) {
+		crc = xor_table[(*begin ^ crc) & 0xff] ^ (crc >> 8);
+		++begin;
+	}
+	return ByteSwapped16::from_raw(crc);
+}
 }

src/main.cpp

@@ -11,9 +11,6 @@
 namespace {
 
 class UEFWriter {
-private:
-	using CRCGenerator = CRC::Generator<uint16_t, 0x0000, 0x0000, false, false>;
-
 public:
 	UEFWriter(const std::string &file_name) {
 		file_ = fopen(file_name.c_str(), "wb");
@@ -30,7 +27,7 @@ class UEFWriter {
 
 	struct Chunk {
 	public:
-		Chunk(uint16_t id, FILE *file, CRCGenerator &crc_generator) : id_(id), file_(file), crc_generator_(crc_generator) {}
+		Chunk(uint16_t id, FILE *file) : id_(id), file_(file) {}
 
 		~Chunk() {
 			// Write chunk ID.
@@ -58,9 +55,9 @@ class UEFWriter {
 				chunk_contents_.push_back(*it);
 			}
 			if(append_crc) {
-				const uint16_t crc = crc_generator_.compute_crc(begin, end);
-				chunk_contents_.push_back(uint8_t(crc >> 8));
-				chunk_contents_.push_back(uint8_t(crc >> 0));
+				const auto crc = CRC::crc16(begin, end);
+				chunk_contents_.push_back(crc.high());
+				chunk_contents_.push_back(crc.low());
 			}
 		}
 
@@ -72,12 +69,11 @@ class UEFWriter {
 	private:
 		uint16_t id_;
 		FILE *file_;
-		CRCGenerator &crc_generator_;
 		std::vector<uint8_t> chunk_contents_;
 	};
 
 	Chunk chunk(const uint16_t id) {
-		return Chunk(id, file_, crc_generator_);
+		return Chunk(id, file_);
 	}
 
 	~UEFWriter() {
@@ -86,7 +82,6 @@ class UEFWriter {
 
 private:
 	FILE *file_ = nullptr;
-	inline static CRCGenerator crc_generator_{0x1021};
 };
 
 void print_help() {