diff --git a/.hgignore b/.hgignore index 7868f21..a0a8da9 100644 --- a/.hgignore +++ b/.hgignore @@ -17,3 +17,4 @@ ttalib-1.1/x64 *.opensdf CUETools.AVX/Win32 CUETools.AVX/x64 +CUETools/TestResults/ diff --git a/CUETools.Codecs.ALAC/ALACWriter.cs b/CUETools.Codecs.ALAC/ALACWriter.cs index 7e85824..5df3bf9 100644 --- a/CUETools.Codecs.ALAC/ALACWriter.cs +++ b/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(); } diff --git a/CUETools.Codecs.FLACCL/FLACCLWriter.cs b/CUETools.Codecs.FLACCL/FLACCLWriter.cs index 693e5b3..0cab007 100644 --- a/CUETools.Codecs.FLACCL/FLACCLWriter.cs +++ b/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(); } diff --git a/CUETools.Codecs.FLAKE/FlakeReader.cs b/CUETools.Codecs.FLAKE/FlakeReader.cs index 6659873..9a50e77 100644 --- a/CUETools.Codecs.FLAKE/FlakeReader.cs +++ b/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,10 +619,17 @@ 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; - ushort crc_2 = (ushort)framereader.readbits(16); - if (do_crc && crc_1 != crc_2) - throw new Exception("frame crc mismatch"); + framereader.get_crc16(); + 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); _samplesInBuffer = frame.blocksize; return framereader.Position - pos; @@ -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; @@ -738,12 +742,12 @@ namespace CUETools.Codecs.FLAKE { int num_entries = len / 18; 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].offset = (long)bitreader.readbits64(Flake.FLAC__STREAM_METADATA_SEEKPOINT_STREAM_OFFSET_LEN); - seek_table[e].framesize = (int)bitreader.readbits(Flake.FLAC__STREAM_METADATA_SEEKPOINT_FRAME_SAMPLES_LEN); - } + for (int e = 0; e < num_entries; e++) + { + seek_table[e].number = bitreader.read_long(); + seek_table[e].offset = bitreader.read_long(); + seek_table[e].framesize = (int)bitreader.read_ushort(); + } } if (_framesBufferLength < 4 + len) { diff --git a/CUETools.Codecs.FLAKE/FlakeWriter.cs b/CUETools.Codecs.FLAKE/FlakeWriter.cs index b390ffd..85024d4 100644 --- a/CUETools.Codecs.FLAKE/FlakeWriter.cs +++ b/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(); } diff --git a/CUETools.Codecs/BitReader.cs b/CUETools.Codecs/BitReader.cs index fe761ed..6dc2c38 100644 --- a/CUETools.Codecs/BitReader.cs +++ b/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]; @@ -183,9 +220,20 @@ namespace CUETools.Codecs cache_m <<= have_bits_m & 7; have_bits_m -= have_bits_m & 7; } - } + } - public int readbits_signed(int bits) + 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); val <<= (32 - 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; } } } diff --git a/CUETools.Codecs/CRC/CRC16.cs b/CUETools.Codecs/CRC/CRC16.cs index 6b11860..22ee5b6 100644 --- a/CUETools.Codecs/CRC/CRC16.cs +++ b/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 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++) - { - if ((crc & (1U << (bits - 1))) != 0) - crc = ((crc << 1) ^ poly); - else - crc <<= 1; - } - //table[i] = (crc & ((1<> 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; + } + } } diff --git a/CUETools.Codecs/CRC/CRC32.cs b/CUETools.Codecs/CRC/CRC32.cs index da24981..45a032d 100644 --- a/CUETools.Codecs/CRC/CRC32.cs +++ b/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 */ - substractTable[0, 31] = 0xdb710641; + combineTable[0, 0] = uReversePolynomial; + substractTable[0, 31] = uReversePolynomial2; for (int n = 1; n < GF2_DIM; n++) { combineTable[0, n] = 1U << (n - 1); @@ -151,41 +153,44 @@ namespace CUETools.Codecs const int GF2_DIM = 32; //const int GF2_DIM2 = 67; - private static unsafe uint gf2_matrix_times(uint* mat, uint vec) - { - return *(mat++) * (vec & 1) ^ - *(mat++) * ((vec >>= 1) & 1) ^ - *(mat++) * ((vec >>= 1) & 1) ^ - *(mat++) * ((vec >>= 1) & 1) ^ - *(mat++) * ((vec >>= 1) & 1) ^ - *(mat++) * ((vec >>= 1) & 1) ^ - *(mat++) * ((vec >>= 1) & 1) ^ - *(mat++) * ((vec >>= 1) & 1) ^ - *(mat++) * ((vec >>= 1) & 1) ^ - *(mat++) * ((vec >>= 1) & 1) ^ - *(mat++) * ((vec >>= 1) & 1) ^ - *(mat++) * ((vec >>= 1) & 1) ^ - *(mat++) * ((vec >>= 1) & 1) ^ - *(mat++) * ((vec >>= 1) & 1) ^ - *(mat++) * ((vec >>= 1) & 1) ^ - *(mat++) * ((vec >>= 1) & 1) ^ - *(mat++) * ((vec >>= 1) & 1) ^ - *(mat++) * ((vec >>= 1) & 1) ^ - *(mat++) * ((vec >>= 1) & 1) ^ - *(mat++) * ((vec >>= 1) & 1) ^ - *(mat++) * ((vec >>= 1) & 1) ^ - *(mat++) * ((vec >>= 1) & 1) ^ - *(mat++) * ((vec >>= 1) & 1) ^ - *(mat++) * ((vec >>= 1) & 1) ^ - *(mat++) * ((vec >>= 1) & 1) ^ - *(mat++) * ((vec >>= 1) & 1) ^ - *(mat++) * ((vec >>= 1) & 1) ^ - *(mat++) * ((vec >>= 1) & 1) ^ - *(mat++) * ((vec >>= 1) & 1) ^ - *(mat++) * ((vec >>= 1) & 1) ^ - *(mat++) * ((vec >>= 1) & 1) ^ - *(mat++) * ((vec >>= 1) & 1); - } + private static unsafe uint gf2_matrix_times(uint* umat, uint uvec) + { + int vec = (int)uvec; + int* mat = (int*)umat; + return (uint)( + (*(mat++) & ((vec << 31) >> 31)) ^ + (*(mat++) & ((vec << 30) >> 31)) ^ + (*(mat++) & ((vec << 29) >> 31)) ^ + (*(mat++) & ((vec << 28) >> 31)) ^ + (*(mat++) & ((vec << 27) >> 31)) ^ + (*(mat++) & ((vec << 26) >> 31)) ^ + (*(mat++) & ((vec << 25) >> 31)) ^ + (*(mat++) & ((vec << 24) >> 31)) ^ + (*(mat++) & ((vec << 23) >> 31)) ^ + (*(mat++) & ((vec << 22) >> 31)) ^ + (*(mat++) & ((vec << 21) >> 31)) ^ + (*(mat++) & ((vec << 20) >> 31)) ^ + (*(mat++) & ((vec << 19) >> 31)) ^ + (*(mat++) & ((vec << 18) >> 31)) ^ + (*(mat++) & ((vec << 17) >> 31)) ^ + (*(mat++) & ((vec << 16) >> 31)) ^ + (*(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(uint *square, uint *mat) diff --git a/CUETools/CUETools.TestCodecs/AccurateRipVerifyTest.cs b/CUETools/CUETools.TestCodecs/AccurateRipVerifyTest.cs index 1eb5614..ce79a84 100644 --- a/CUETools/CUETools.TestCodecs/AccurateRipVerifyTest.cs +++ b/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" + - "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", + "xNabCDhnBPt45+ciq03CeqXDvZipuO5umMAVs6MWnHquaAQPCNK5p6aFqUwYn9pg\r\n" + + "JRwA7N7y56iFkAAGocLf1W5WHb7+FZqfNpwFdbdDs+yRGAeUIvOoA+wiwPupDCAA\r\n" + + "oA/rwLNMdbHStlNj4x85VCsLIp5OpLY96gEM9dBtralauYpI1bMne+Iz0PZQYMOf\r\n" + + "ZR+siqD+PSKcB4ZVXUOFsLdnaE9PK2Nt+23eaCWz7Xb7DIk3y3N5/a/fpJKeI+wA\r\n" + + "Z9VQKoi8ZrovomELWl5qkggU729uIY1o/2qXBMWJ6DwS67sNe10bBt1MdqqkNdV7\r\n" + + "rmuw1evdP80ABMX8wDjxH3gIdozrGABX+st9/En+fiubdEtkhKdo96eI4Cqa41nW\r\n" + + "4TvvD1UO5UrXS+gedLpa337w449cUVK3Yk7zDb5oAoJgK7jBHeetCdj/b30THmSA\r\n" + + "pv30LKAcXgUpc602FPDH7m7GvsRrtiQ1r9ZHMyQ9NCBt2oWCv2Hac7jDW7N4vQgv\r\n" + + "DJwm4nnn7H4WMZ/WziDfUVYYLVPlt/R/DXYnAlsVAj+kBHNlLojQG5A/bRqjDObN\r\n" + + "NsNjdI3IgVOQZHP1bkaKGQKQHAdeOGkU+HgaPVe0zKO+r2b5AwKCc66imdS6GGGk\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 }; diff --git a/CUETools/CUETools.TestCodecs/Crc32Test.cs b/CUETools/CUETools.TestCodecs/Crc32Test.cs index b49408f..1183a25 100644 --- a/CUETools/CUETools.TestCodecs/Crc32Test.cs +++ b/CUETools/CUETools.TestCodecs/Crc32Test.cs @@ -80,6 +80,23 @@ namespace CUETools.TestCodecs Assert.AreEqual(crcA, Crc32.Substract(crcAB, crcB, lenB), "CRC32 was not substracted correctly."); } + /// + ///A test for Combine + /// + [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(crcAB, Crc16.Combine(crcA, crcB, lenB), "CRC16 was not combined correctly."); + Assert.AreEqual(crcB, Crc16.Combine(crcA, crcAB, lenB), "CRC16 was not substracted correctly."); + Assert.AreEqual(crcA, Crc16.Substract(crcAB, crcB, lenB), "CRC16 was not substracted correctly."); + } + /// ///A test for ComputeChecksum ///