More code cleanup after decoding optimization

.hgignore

@@ -17,3 +17,4 @@ ttalib-1.1/x64
 *.opensdf
 CUETools.AVX/Win32
 CUETools.AVX/x64
+CUETools/TestResults/

CUETools.Codecs.ALAC/ALACWriter.cs

@@ -86,8 +86,6 @@ namespace CUETools.Codecs.ALAC
 		int _totalSize = 0;
 		int _windowsize = 0, _windowcount = 0;
 
-		Crc8 crc8;
-		Crc16 crc16;
 		ALACFrame frame;
 		ALACReader verify;
 
@@ -119,8 +117,6 @@ namespace CUETools.Codecs.ALAC
 			eparams.set_defaults(_compressionLevel);
 			eparams.padding_size = 4096;
 
-			crc8 = new Crc8();
-			crc16 = new Crc16();
 			frame = new ALACFrame(_pcm.ChannelCount == 2 ? 5 : _pcm.ChannelCount);
 			chunk_pos = new List<int>();
 		}

CUETools.Codecs.FLACCL/FLACCLWriter.cs

@@ -250,7 +250,6 @@ namespace CUETools.Codecs.FLACCL
 			eparams.padding_size = _settings.Padding;
 
 			crc8 = new Crc8();
-			crc16 = new Crc16();
 		}
 
 		public FLACCLWriter(string path, AudioPCMConfig pcm)
@@ -1060,7 +1059,7 @@ namespace CUETools.Codecs.FLACCL
 		void output_frame_footer(FlacFrame frame)
 		{
 			frame.writer.flush();
-			ushort crc = crc16.ComputeChecksum(frame.writer.Buffer, frame.writer_offset, frame.writer.Length - frame.writer_offset);
+			ushort crc = Crc16.ComputeChecksum(0, frame.writer.Buffer, frame.writer_offset, frame.writer.Length - frame.writer_offset);
 			frame.writer.writebits(16, crc);
 			frame.writer.flush();
 		}

CUETools.Codecs.FLAKE/FlakeReader.cs

@@ -39,7 +39,6 @@ namespace CUETools.Codecs.FLAKE
 		SeekPoint[] seek_table;
 
 		Crc8 crc8;
-		Crc16 crc16;
 		FlacFrame frame;
 		BitReader framereader;
 		AudioPCMConfig pcm;
@@ -83,7 +82,6 @@ namespace CUETools.Codecs.FLAKE
 			_IO = IO != null ? IO : new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, 0x10000);
 
 			crc8 = new Crc8();
-			crc16 = new Crc16();
 			
 			_framesBuffer = new byte[0x20000];
 			decode_metadata();
@@ -113,7 +111,6 @@ namespace CUETools.Codecs.FLAKE
 		{
 			pcm = _pcm;
 			crc8 = new Crc8();
-			crc16 = new Crc16();
 
 			samplesBuffer = new int[Flake.MAX_BLOCKSIZE * PCM.ChannelCount];
 			residualBuffer = new int[Flake.MAX_BLOCKSIZE * PCM.ChannelCount];
@@ -622,8 +619,15 @@ namespace CUETools.Codecs.FLAKE
 				decode_frame_header(framereader, frame);
 				decode_subframes(framereader, frame);
 				framereader.flush();
-				ushort crc_1 = do_crc ? crc16.ComputeChecksum(framereader.Buffer + pos, framereader.Position - pos) : (ushort)0;
+                framereader.get_crc16();
-				ushort crc_2 = (ushort)framereader.readbits(16);
+                framereader.get_crc16();
+                framereader.get_crc16();
+                framereader.get_crc16();
+                framereader.get_crc16();
+                framereader.get_crc16();
+                framereader.get_crc16();
+                ushort crc_1 = framereader.get_crc16();
+				ushort crc_2 = framereader.read_ushort();
                 if (do_crc && crc_1 != crc_2)
                     throw new Exception("frame crc mismatch");
 				restore_samples(frame);
@@ -645,7 +649,7 @@ namespace CUETools.Codecs.FLAKE
 		{
 			byte x;
 			int i, id;
-			bool first = true;
+			//bool first = true;
 			byte[] FLAC__STREAM_SYNC_STRING = new byte[] { (byte)'f', (byte)'L', (byte)'a', (byte)'C' };
 			byte[] ID3V2_TAG_ = new byte[] { (byte)'I', (byte)'D', (byte)'3' };
 
@@ -656,7 +660,7 @@ namespace CUETools.Codecs.FLAKE
 				x = _framesBuffer[0];
 				if (x == FLAC__STREAM_SYNC_STRING[i])
 				{
-					first = true;
+					//first = true;
 					i++;
 					id = 0;
 					continue;
@@ -740,9 +744,9 @@ namespace CUETools.Codecs.FLAKE
 						seek_table = new SeekPoint[num_entries];
                         for (int e = 0; e < num_entries; e++)
                         {
-							seek_table[e].number = (long)bitreader.readbits64(Flake.FLAC__STREAM_METADATA_SEEKPOINT_SAMPLE_NUMBER_LEN);
+                            seek_table[e].number = bitreader.read_long();
-							seek_table[e].offset = (long)bitreader.readbits64(Flake.FLAC__STREAM_METADATA_SEEKPOINT_STREAM_OFFSET_LEN);
+                            seek_table[e].offset = bitreader.read_long();
-							seek_table[e].framesize = (int)bitreader.readbits(Flake.FLAC__STREAM_METADATA_SEEKPOINT_FRAME_SAMPLES_LEN);
+                            seek_table[e].framesize = (int)bitreader.read_ushort();
                         }
 					}
 					if (_framesBufferLength < 4 + len)

CUETools.Codecs.FLAKE/FlakeWriter.cs

@@ -109,7 +109,6 @@ namespace CUETools.Codecs.FLAKE
 		int _windowsize = 0, _windowcount = 0;
 
 		Crc8 crc8;
-		Crc16 crc16;
 		MD5 md5;
 
 		FlacFrame frame;
@@ -146,7 +145,6 @@ namespace CUETools.Codecs.FLAKE
 			eparams.padding_size = 8192;
 
 			crc8 = new Crc8();
-			crc16 = new Crc16();
 			frame = new FlacFrame(channels * 2);
 		}
 
@@ -1445,7 +1443,7 @@ new int[] { // 30
 		void output_frame_footer(BitWriter bitwriter)
 		{
 			bitwriter.flush();
-			ushort crc = crc16.ComputeChecksum(frame_buffer, 0, bitwriter.Length);
+			ushort crc = Crc16.ComputeChecksum(0, frame_buffer, 0, bitwriter.Length);
 			bitwriter.writebits(16, crc);
 			bitwriter.flush();
 		}

CUETools.Codecs/BitReader.cs

@@ -75,6 +75,7 @@ namespace CUETools.Codecs
         private int buffer_len_m;
         private int have_bits_m;
         private ulong cache_m;
+        private ushort crc16_m;
 
 		public int Position
 		{
@@ -96,6 +97,7 @@ namespace CUETools.Codecs
 			buffer_len_m = 0;
 			have_bits_m = 0;
 			cache_m = 0;
+            crc16_m = 0;
 		}
 
 		public BitReader(byte* _buffer, int _pos, int _len)
@@ -110,6 +112,7 @@ namespace CUETools.Codecs
 			buffer_len_m = _len;
 			have_bits_m = 0;
             cache_m = 0;
+            crc16_m = 0;
 			fill();
 		}
 
@@ -118,7 +121,9 @@ namespace CUETools.Codecs
             while (have_bits_m < 56)
             {
                 have_bits_m += 8;
-                cache_m |= (ulong)*(bptr_m++) << (64 - have_bits_m);
+                byte b = *(bptr_m++);
+                cache_m |= (ulong)b << (64 - have_bits_m);
+                crc16_m = (ushort)((crc16_m << 8) ^ Crc16.table[(crc16_m >> 8) ^ b]);
             }
         }
 
@@ -136,6 +141,36 @@ namespace CUETools.Codecs
             have_bits_m -= bits;
 		}
 
+        public long read_long()
+        {
+            return ((long)readbits(32) << 32) | readbits(32);
+        }
+
+        public ulong read_ulong()
+        {
+            return ((ulong)readbits(32) << 32) | readbits(32);
+        }
+
+        public int read_int()
+        {
+            return (int)readbits(sizeof(int));
+        }
+        
+        public uint read_uint()
+        {
+            return (uint)readbits(sizeof(uint));
+        }
+
+        public short read_short()
+        {
+            return (short)readbits(16);
+        }
+
+        public ushort read_ushort()
+        {
+            return (ushort)readbits(16);
+        }
+
 		/* supports reading 1 to 32 bits, in big endian format */
         public uint readbits(int bits)
         {
@@ -150,7 +185,7 @@ namespace CUETools.Codecs
 		{
 			if (bits <= 56)
 				return readbits(bits);
-			return (readbits(32) << bits - 32) | readbits(bits - 32);
+			return ((ulong)readbits(32) << bits - 32) | readbits(bits - 32);
 		}
 
 		/* reads a single bit */
@@ -168,7 +203,9 @@ namespace CUETools.Codecs
 			{
 				val += 8;
                 cache_m <<= 8;
-                cache_m |= (ulong)*(bptr_m++) << (64 - have_bits_m);
+                byte b = *(bptr_m++);
+                cache_m |= (ulong)b << (64 - have_bits_m);
+                crc16_m = (ushort)((crc16_m << 8) ^ Crc16.table[(crc16_m >> 8) ^ b]);
                 result = cache_m >> 56;
 			}
 			val += byte_to_unary_table[result];
@@ -185,6 +222,17 @@ namespace CUETools.Codecs
             }
         }
 
+        public ushort get_crc16()
+        {
+            if (have_bits_m == 0)
+                return crc16_m;
+            ushort crc = 0;
+            int n = have_bits_m >> 3;
+            for (int i = 0; i < n; i++)
+                crc = (ushort)((crc << 8) ^ Crc16.table[(crc >> 8) ^ (byte)(cache_m >> (56 - (i << 3)))]);
+            return Crc16.Substract(crc16_m, crc, n);
+        }
+
         public int readbits_signed(int bits)
 		{
 			int val = (int)readbits(bits);
@@ -252,11 +300,13 @@ namespace CUETools.Codecs
 		{
             fill();
             fixed (byte* unary_table = byte_to_unary_table)
+            fixed (ushort* t = Crc16.table)
             {
                 uint mask = (1U << k) - 1;
                 byte* bptr = bptr_m;
                 int have_bits = have_bits_m;
                 ulong cache = cache_m;
+                ushort crc = crc16_m;
                 for (int i = n; i > 0; i--)
                 {
                     uint bits;
@@ -264,14 +314,18 @@ namespace CUETools.Codecs
                     while ((bits = unary_table[cache >> 56]) == 8)
                     {
                         cache <<= 8;
-                        cache |= (ulong)*(bptr++) << (64 - have_bits);
+                        byte b = *(bptr++);
+                        cache |= (ulong)b << (64 - have_bits);
+                        crc = (ushort)((crc << 8) ^ t[(crc >> 8) ^ b]);
                     }
                     uint msbs = bits + ((uint)(bptr - orig_bptr) << 3);
                     // assumes k <= 41 (have_bits < 41 + 7 + 1 + 8 == 57, so we don't loose bits here)
                     while (have_bits < 56)
                     {
                         have_bits += 8;
-                        cache |= (ulong)*(bptr++) << (64 - have_bits);
+                        byte b = *(bptr++);
+                        cache |= (ulong)b << (64 - have_bits);
+                        crc = (ushort)((crc << 8) ^ t[(crc >> 8) ^ b]);
                     }
 
                     int btsk = k + (int)bits + 1;
@@ -283,6 +337,7 @@ namespace CUETools.Codecs
                 have_bits_m = have_bits;
                 cache_m = cache;
                 bptr_m = bptr;
+                crc16_m = crc;
             }
 		}
 	}

CUETools.Codecs/CRC/CRC16.cs

@@ -1,42 +1,159 @@
+using System;
 namespace CUETools.Codecs
 {
-	public class Crc16
+	public static class Crc16
 	{
-		ushort[] table = new ushort[256];
+        const int GF2_DIM = 16;
+        public static ushort[] table = new ushort[256];
+        private static readonly ushort[,] combineTable = new ushort[GF2_DIM, GF2_DIM];
+        private static readonly ushort[,] substractTable = new ushort[GF2_DIM, GF2_DIM];
 
-		public unsafe ushort ComputeChecksum(byte[] bytes, int pos, int count)
+		public static unsafe ushort ComputeChecksum(ushort crc, byte[] bytes, int pos, int count)
 		{
 			fixed (byte* bs = bytes)
-				return ComputeChecksum(bs + pos, count);
+				return ComputeChecksum(crc, bs + pos, count);
 		}
 
-		public unsafe ushort ComputeChecksum(byte* bytes, int count)
+        public static unsafe ushort ComputeChecksum(ushort crc, byte* bytes, int count)
 		{
-			ushort crc = 0;
 			fixed (ushort* t = table)
 				for (int i = count; i > 0; i--)
 					crc = (ushort)((crc << 8) ^ t[(crc >> 8) ^ *(bytes++)]);
 			return crc;
 		}
 
-		public Crc16()
+        const ushort polynomial = 0x8005;
+        const ushort reversePolynomial = 0xa001;
+        const ushort reversePolynomial2 = 0x4003;
+
+		static unsafe Crc16()
 		{
-			int bits = 16;
+            int poly = (polynomial + (1 << GF2_DIM));
-			int poly16 = 0x8005;
-			int poly = (poly16 + (1 << bits));
             for (ushort i = 0; i < table.Length; i++)
             {
                 int crc = i;
-				for (int j = 0; j < bits; j++)
+                for (int j = 0; j < GF2_DIM; j++)
                 {
-					if ((crc & (1U << (bits - 1))) != 0)
+                    if ((crc & (1U << (GF2_DIM - 1))) != 0)
                         crc = ((crc << 1) ^ poly);
                     else
                         crc <<= 1;
                 }
-			        //table[i] = (crc & ((1<<bits)-1));
+                table[i] = (ushort)(crc & ((1 << GF2_DIM) - 1));
-				table[i] = (ushort)(crc & 0xffff);
+            }
+
+            combineTable[0, 0] = reversePolynomial;
+            substractTable[0, GF2_DIM - 1] = reversePolynomial2;
+            for (int n = 1; n < GF2_DIM; n++)
+            {
+                combineTable[0, n] = (ushort)(1 << (n - 1));
+                substractTable[0, n - 1] = (ushort)(1 << n);
+            }
+            
+            fixed (ushort* ct = &combineTable[0, 0], st = &substractTable[0, 0])
+            {
+                //for (int i = 0; i < GF2_DIM; i++)
+                //	st[32 + i] = ct[i];
+                //invert_binary_matrix(st + 32, st, GF2_DIM);
+
+                for (int i = 1; i < GF2_DIM; i++)
+                {
+                    gf2_matrix_square(ct + i * GF2_DIM, ct + (i - 1) * GF2_DIM);
+                    gf2_matrix_square(st + i * GF2_DIM, st + (i - 1) * GF2_DIM);
                 }
             }
         }
+
+        private static unsafe ushort gf2_matrix_times(ushort* mat, ushort uvec)
+        {
+            int vec = ((int) uvec) << 16;
+            return (ushort)(
+                (*(mat++) & ((vec << 15) >> 31)) ^
+                (*(mat++) & ((vec << 14) >> 31)) ^
+                (*(mat++) & ((vec << 13) >> 31)) ^
+                (*(mat++) & ((vec << 12) >> 31)) ^
+                (*(mat++) & ((vec << 11) >> 31)) ^
+                (*(mat++) & ((vec << 10) >> 31)) ^
+                (*(mat++) & ((vec << 09) >> 31)) ^
+                (*(mat++) & ((vec << 08) >> 31)) ^
+                (*(mat++) & ((vec << 07) >> 31)) ^
+                (*(mat++) & ((vec << 06) >> 31)) ^
+                (*(mat++) & ((vec << 05) >> 31)) ^
+                (*(mat++) & ((vec << 04) >> 31)) ^
+                (*(mat++) & ((vec << 03) >> 31)) ^
+                (*(mat++) & ((vec << 02) >> 31)) ^
+                (*(mat++) & ((vec << 01) >> 31)) ^
+                (*(mat++) & (vec >> 31)));
+        }
+
+        private static unsafe void gf2_matrix_square(ushort* square, ushort* mat)
+        {
+            for (int n = 0; n < GF2_DIM; n++)
+                square[n] = gf2_matrix_times(mat, mat[n]);
+        }
+
+        public static unsafe ushort Combine(ushort crc1, ushort crc2, long len2)
+        {
+            crc1 = (ushort)Crc32.Reflect(crc1, 16);
+            crc2 = (ushort)Crc32.Reflect(crc2, 16);
+
+            /* degenerate case */
+            if (len2 == 0)
+                return crc1;
+            if (crc1 == 0)
+                return crc2;
+            if (len2 < 0)
+                throw new ArgumentException("crc.Combine length cannot be negative", "len2");
+
+            fixed (ushort* ct = &combineTable[0, 0])
+            {
+                int n = 3;
+                do
+                {
+                    /* apply zeros operator for this bit of len2 */
+                    if ((len2 & 1) != 0)
+                        crc1 = gf2_matrix_times(ct + GF2_DIM * n, crc1);
+                    len2 >>= 1;
+                    n = (n + 1) & (GF2_DIM - 1);
+                    /* if no more bits set, then done */
+                } while (len2 != 0);
+            }
+
+            /* return combined crc */
+            crc1 ^= crc2;
+            crc1 = (ushort)Crc32.Reflect(crc1, 16);
+            return crc1;
+        }
+
+        public static unsafe ushort Substract(ushort crc1, ushort crc2, long len2)
+        {
+            crc1 = (ushort)Crc32.Reflect(crc1, 16);
+            crc2 = (ushort)Crc32.Reflect(crc2, 16);
+            /* degenerate case */
+            if (len2 == 0)
+                return crc1;
+            if (len2 < 0)
+                throw new ArgumentException("crc.Combine length cannot be negative", "len2");
+
+            crc1 ^= crc2;
+
+            fixed (ushort* st = &substractTable[0, 0])
+            {
+                int n = 3;
+                do
+                {
+                    /* apply zeros operator for this bit of len2 */
+                    if ((len2 & 1) != 0)
+                        crc1 = gf2_matrix_times(st + GF2_DIM * n, crc1);
+                    len2 >>= 1;
+                    n = (n + 1) & (GF2_DIM - 1);
+                    /* if no more bits set, then done */
+                } while (len2 != 0);
+            }
+
+            /* return combined crc */
+            crc1 = (ushort)Crc32.Reflect(crc1, 16);
+            return crc1;
+        }
+    }
 }

CUETools.Codecs/CRC/CRC32.cs

@@ -42,7 +42,7 @@ namespace CUETools.Codecs
 			return crc;
 		}
 
-		static uint Reflect(uint val, int ch)
+		internal static uint Reflect(uint val, int ch)
 		{
 			uint value = 0;
 			// Swap bit 0 for bit 7
@@ -56,7 +56,9 @@ namespace CUETools.Codecs
 			return value;
 		}
 
-		const uint ulPolynomial = 0x04c11db7;
+		const uint uPolynomial = 0x04c11db7;
+        const uint uReversePolynomial = 0xedb88320;
+        const uint uReversePolynomial2 = 0xdb710641;
 
 		private static readonly uint[,] combineTable;
 		private static readonly uint[,] substractTable;
@@ -122,13 +124,13 @@ namespace CUETools.Codecs
 			{
 				table[i] = Reflect(i, 8) << 24;
 				for (int j = 0; j < 8; j++)
-					table[i] = (table[i] << 1) ^ ((table[i] & (1U << 31)) == 0 ? 0 : ulPolynomial);
+					table[i] = (table[i] << 1) ^ ((table[i] & (1U << 31)) == 0 ? 0 : uPolynomial);
 				table[i] = Reflect(table[i], 32);
 			}
 			combineTable = new uint[GF2_DIM, GF2_DIM];
 			substractTable = new uint[GF2_DIM, GF2_DIM];
-			combineTable[0, 0] = 0xedb88320;           /* CRC-32 polynomial */
+            combineTable[0, 0] = uReversePolynomial;
-			substractTable[0, 31] = 0xdb710641;
+            substractTable[0, 31] = uReversePolynomial2;
 			for (int n = 1; n < GF2_DIM; n++)
 			{
 				combineTable[0, n] = 1U << (n - 1);
@@ -151,40 +153,43 @@ namespace CUETools.Codecs
 		const int GF2_DIM = 32;
 		//const int GF2_DIM2 = 67;
 
-		private static unsafe uint gf2_matrix_times(uint* mat, uint vec)
+        private static unsafe uint gf2_matrix_times(uint* umat, uint uvec)
         {
-			return *(mat++) * (vec & 1) ^
+            int vec = (int)uvec;
-			*(mat++) * ((vec >>= 1) & 1) ^
+            int* mat = (int*)umat;
-			*(mat++) * ((vec >>= 1) & 1) ^
+            return (uint)(
-			*(mat++) * ((vec >>= 1) & 1) ^
+                (*(mat++) & ((vec << 31) >> 31)) ^
-			*(mat++) * ((vec >>= 1) & 1) ^
+                (*(mat++) & ((vec << 30) >> 31)) ^
-			*(mat++) * ((vec >>= 1) & 1) ^
+                (*(mat++) & ((vec << 29) >> 31)) ^
-			*(mat++) * ((vec >>= 1) & 1) ^
+                (*(mat++) & ((vec << 28) >> 31)) ^
-			*(mat++) * ((vec >>= 1) & 1) ^
+                (*(mat++) & ((vec << 27) >> 31)) ^
-			*(mat++) * ((vec >>= 1) & 1) ^
+                (*(mat++) & ((vec << 26) >> 31)) ^
-			*(mat++) * ((vec >>= 1) & 1) ^
+                (*(mat++) & ((vec << 25) >> 31)) ^
-			*(mat++) * ((vec >>= 1) & 1) ^
+                (*(mat++) & ((vec << 24) >> 31)) ^
-			*(mat++) * ((vec >>= 1) & 1) ^
+                (*(mat++) & ((vec << 23) >> 31)) ^
-			*(mat++) * ((vec >>= 1) & 1) ^
+                (*(mat++) & ((vec << 22) >> 31)) ^
-			*(mat++) * ((vec >>= 1) & 1) ^
+                (*(mat++) & ((vec << 21) >> 31)) ^
-			*(mat++) * ((vec >>= 1) & 1) ^
+                (*(mat++) & ((vec << 20) >> 31)) ^
-			*(mat++) * ((vec >>= 1) & 1) ^
+                (*(mat++) & ((vec << 19) >> 31)) ^
-			*(mat++) * ((vec >>= 1) & 1) ^
+                (*(mat++) & ((vec << 18) >> 31)) ^
-			*(mat++) * ((vec >>= 1) & 1) ^
+                (*(mat++) & ((vec << 17) >> 31)) ^
-			*(mat++) * ((vec >>= 1) & 1) ^
+                (*(mat++) & ((vec << 16) >> 31)) ^
-			*(mat++) * ((vec >>= 1) & 1) ^
+                (*(mat++) & ((vec << 15) >> 31)) ^
-			*(mat++) * ((vec >>= 1) & 1) ^
+                (*(mat++) & ((vec << 14) >> 31)) ^
-			*(mat++) * ((vec >>= 1) & 1) ^
+                (*(mat++) & ((vec << 13) >> 31)) ^
-			*(mat++) * ((vec >>= 1) & 1) ^
+                (*(mat++) & ((vec << 12) >> 31)) ^
-			*(mat++) * ((vec >>= 1) & 1) ^
+                (*(mat++) & ((vec << 11) >> 31)) ^
-			*(mat++) * ((vec >>= 1) & 1) ^
+                (*(mat++) & ((vec << 10) >> 31)) ^
-			*(mat++) * ((vec >>= 1) & 1) ^
+                (*(mat++) & ((vec << 09) >> 31)) ^
-			*(mat++) * ((vec >>= 1) & 1) ^
+                (*(mat++) & ((vec << 08) >> 31)) ^
-			*(mat++) * ((vec >>= 1) & 1) ^
+                (*(mat++) & ((vec << 07) >> 31)) ^
-			*(mat++) * ((vec >>= 1) & 1) ^
+                (*(mat++) & ((vec << 06) >> 31)) ^
-			*(mat++) * ((vec >>= 1) & 1) ^
+                (*(mat++) & ((vec << 05) >> 31)) ^
-			*(mat++) * ((vec >>= 1) & 1) ^
+                (*(mat++) & ((vec << 04) >> 31)) ^
-			*(mat++) * ((vec >>= 1) & 1);
+                (*(mat++) & ((vec << 03) >> 31)) ^
+                (*(mat++) & ((vec << 02) >> 31)) ^
+                (*(mat++) & ((vec << 01) >> 31)) ^
+                (*(mat++) & (vec >> 31)));
         }
 
 		/* ========================================================================= */

CUETools/CUETools.TestCodecs/AccurateRipVerifyTest.cs

@@ -274,17 +274,28 @@ namespace CUETools.TestCodecs
 			var record0 = TestImageGenerator.CreateAccurateRipVerify("13 68 99 136", 2314, 0).OffsetSafeCRC;
 
 			Assert.AreEqual(
-				"8+lTDqEZidfayuC0LoxnL9Oluf4ywo1muFBu115XBgf254fKIdfVWZOcsQraS4eI\r\n" +
+                "xNabCDhnBPt45+ciq03CeqXDvZipuO5umMAVs6MWnHquaAQPCNK5p6aFqUwYn9pg\r\n" +
-				"NoLn7W3t0a16i745nEvikfw27ZsMR7gWPrXgXdsI2OdtjWTRL2Vra2dLe3WOl/Ru\r\n" +
+                "JRwA7N7y56iFkAAGocLf1W5WHb7+FZqfNpwFdbdDs+yRGAeUIvOoA+wiwPupDCAA\r\n" +
-				"wFa1jqbB3+xHiB8XNi+5VKRh3fj1o5RSXS6tOZUvBUFFqoyuZK/DkeIyZ4gkotYO\r\n" +
+                "oA/rwLNMdbHStlNj4x85VCsLIp5OpLY96gEM9dBtralauYpI1bMne+Iz0PZQYMOf\r\n" +
-				"MZSsx2JBr2tdBzHZMssUmfvWUrfJZAQD8wMv1epy7q0Mk3W/QetVz6cZZ+6rRctf\r\n" +
+                "ZR+siqD+PSKcB4ZVXUOFsLdnaE9PK2Nt+23eaCWz7Xb7DIk3y3N5/a/fpJKeI+wA\r\n" +
-				"PGqvWBgNfS/+e7LBo/49KYd16kEofaX8LuuNB/7YJ85a3W71soQovwWLkjm32Xqo\r\n" +
+                "Z9VQKoi8ZrovomELWl5qkggU729uIY1o/2qXBMWJ6DwS67sNe10bBt1MdqqkNdV7\r\n" +
-				"KpaUagu9QED1WEx7frfu95vYsQLV+vq6zULP6QOznUpU6n6LuMPQa5WNA4+chigC\r\n" +
+                "rmuw1evdP80ABMX8wDjxH3gIdozrGABX+st9/En+fiubdEtkhKdo96eI4Cqa41nW\r\n" +
-				"71GFeKTSO3bnS3xg8FMMqRtcTJleWF/7Bs3DkUZnxbkp4g8iZYZ3eMDc7A04AiYx\r\n" +
+                "4TvvD1UO5UrXS+gedLpa337w449cUVK3Yk7zDb5oAoJgK7jBHeetCdj/b30THmSA\r\n" +
-				"3tYvDi9WiEZMRWpvuHfoBzWU7HbfOk5+32yg8TyNyVlPq1cfFn/jwQrfNyztTyav\r\n" +
+                "pv30LKAcXgUpc602FPDH7m7GvsRrtiQ1r9ZHMyQ9NCBt2oWCv2Hac7jDW7N4vQgv\r\n" +
-				"96ZJS2aBroYAw2We5RC2oekmi+N75L6+eQB/4iZOxB9aGP1sALd/UZaJqZP8FcmW\r\n" +
+                "DJwm4nnn7H4WMZ/WziDfUVYYLVPlt/R/DXYnAlsVAj+kBHNlLojQG5A/bRqjDObN\r\n" +
-				"FJOXlBi/KW68TJvujz+2w/P7EaZ0L7llQAtoHwoJniuNN5WYXBlescGc+vyYr5df\r\n" +
+                "NsNjdI3IgVOQZHP1bkaKGQKQHAdeOGkU+HgaPVe0zKO+r2b5AwKCc66imdS6GGGk\r\n" +
-				"jrul+QMmQ4xMi10mglq7CMLVfZZFFgBdvGBrn1tL9bg=\r\n",
+                "v5xwtNiLb6aJhmuASiOZL8oFHT+W7MPFTVb7hQEg7Ck=\r\n",
+                //"8+lTDqEZidfayuC0LoxnL9Oluf4ywo1muFBu115XBgf254fKIdfVWZOcsQraS4eI\r\n" +
+                //"NoLn7W3t0a16i745nEvikfw27ZsMR7gWPrXgXdsI2OdtjWTRL2Vra2dLe3WOl/Ru\r\n" +
+                //"wFa1jqbB3+xHiB8XNi+5VKRh3fj1o5RSXS6tOZUvBUFFqoyuZK/DkeIyZ4gkotYO\r\n" +
+                //"MZSsx2JBr2tdBzHZMssUmfvWUrfJZAQD8wMv1epy7q0Mk3W/QetVz6cZZ+6rRctf\r\n" +
+                //"PGqvWBgNfS/+e7LBo/49KYd16kEofaX8LuuNB/7YJ85a3W71soQovwWLkjm32Xqo\r\n" +
+                //"KpaUagu9QED1WEx7frfu95vYsQLV+vq6zULP6QOznUpU6n6LuMPQa5WNA4+chigC\r\n" +
+                //"71GFeKTSO3bnS3xg8FMMqRtcTJleWF/7Bs3DkUZnxbkp4g8iZYZ3eMDc7A04AiYx\r\n" +
+                //"3tYvDi9WiEZMRWpvuHfoBzWU7HbfOk5+32yg8TyNyVlPq1cfFn/jwQrfNyztTyav\r\n" +
+                //"96ZJS2aBroYAw2We5RC2oekmi+N75L6+eQB/4iZOxB9aGP1sALd/UZaJqZP8FcmW\r\n" +
+                //"FJOXlBi/KW68TJvujz+2w/P7EaZ0L7llQAtoHwoJniuNN5WYXBlescGc+vyYr5df\r\n" +
+                //"jrul+QMmQ4xMi10mglq7CMLVfZZFFgBdvGBrn1tL9bg=\r\n",
 				TestImageGenerator.CreateAccurateRipVerify("13 68 99 136", 2314, 13).OffsetSafeCRC.Base64);
 
 			var offsets = new int[] { 1, 2, 3, 4, 8, 11, 15, 16, 31, 32, 255, 256, 597, 588, 588 * 5 - 1, 588 * 5, 4095, 4096, 4097, 5000 };

CUETools/CUETools.TestCodecs/Crc32Test.cs

@@ -80,6 +80,23 @@ namespace CUETools.TestCodecs
 			Assert.AreEqual<uint>(crcA, Crc32.Substract(crcAB, crcB, lenB), "CRC32 was not substracted correctly.");
 		}
 
+        /// <summary>
+        ///A test for Combine
+        ///</summary>
+        [TestMethod()]
+        public void CombineTest16()
+        {
+            int lenAB = testBytes.Length;
+            int lenA = 7;
+            int lenB = lenAB - lenA;
+            ushort crcAB = Crc16.ComputeChecksum(0, testBytes, 0, lenAB);
+            ushort crcA = Crc16.ComputeChecksum(0, testBytes, 0, lenA);
+            ushort crcB = Crc16.ComputeChecksum(0, testBytes, lenA, lenB);
+            Assert.AreEqual<uint>(crcAB, Crc16.Combine(crcA, crcB, lenB), "CRC16 was not combined correctly.");
+            Assert.AreEqual<uint>(crcB, Crc16.Combine(crcA, crcAB, lenB), "CRC16 was not substracted correctly.");
+            Assert.AreEqual<uint>(crcA, Crc16.Substract(crcAB, crcB, lenB), "CRC16 was not substracted correctly.");
+        }
+
 		/// <summary>
 		///A test for ComputeChecksum
 		///</summary>