Separate CRC16 IBM and CRC16 CCITT contexts, use cached tables.

.idea/.idea.DiscImageChef/.idea/contentModel.xml

@@ -3,8 +3,10 @@
   <component name="ContentModelStore">
     <e p="$APPLICATION_CONFIG_DIR$/consoles/db" t="IncludeRecursive" />
     <e p="$APPLICATION_PLUGINS_DIR$/puppet/lib/stubs" t="IncludeRecursive" />
+    <e p="$APPLICATION_CONFIG_DIR$/scratches" t="IncludeRecursive" />
     <e p="$USER_HOME$/.Rider2019.3/system/extResources" t="IncludeRecursive" />
     <e p="$USER_HOME$/.Rider2019.3/system/resharper-host/local/Transient/ReSharperHost/v193/SolutionCaches/_DiscImageChef.-1491758497.00" t="ExcludeRecursive" />
+    <e p="$USER_HOME$/.config/git/ignore" t="IncludeRecursive" />
     <e p="$USER_HOME$/.nuget/packages/sqlitepclraw.lib.e_sqlite3.linux/1.1.12/runtimes/linux-x64/native/libe_sqlite3.so" t="Include" />
     <e p="$PROJECT_DIR$" t="IncludeFlat">
       <e p=".git/info/exclude" t="IncludeRecursive" />
@@ -88,7 +90,9 @@
       <e p="DiscImageChef.Checksums" t="IncludeRecursive">
         <e p="Adler32Context.cs" t="Include" />
         <e p="CDChecksums.cs" t="Include" />
+        <e p="CRC16CCITTContext.cs" t="Include" />
         <e p="CRC16Context.cs" t="Include" />
+        <e p="CRC16IBMContext.cs" t="Include" />
         <e p="CRC32Context.cs" t="Include" />
         <e p="CRC64Context.cs" t="Include" />
         <e p="DiscImageChef.Checksums.csproj" t="IncludeRecursive" />

DiscImageChef.Checksums/CDChecksums.cs

@@ -33,44 +33,17 @@
 
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using DiscImageChef.Console;
 
 namespace DiscImageChef.Checksums
 {
-    /// <summary>
+    /// <summary>Implements ReedSolomon and CRC32 algorithms as used by CD-ROM</summary>
-    ///     Implements ReedSolomon and CRC32 algorithms as used by CD-ROM
-    /// </summary>
     public static class CdChecksums
     {
         static byte[] eccFTable;
         static byte[] eccBTable;
         static uint[] edcTable;
 
-        static readonly ushort[] CcittCrc16Table =
-        {
-            0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7, 0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c,
-            0xd1ad, 0xe1ce, 0xf1ef, 0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6, 0x9339, 0x8318,
-            0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de, 0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4,
-            0x5485, 0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d, 0x3653, 0x2672, 0x1611, 0x0630,
-            0x76d7, 0x66f6, 0x5695, 0x46b4, 0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc, 0x48c4,
-            0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823, 0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969,
-            0xa90a, 0xb92b, 0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12, 0xdbfd, 0xcbdc, 0xfbbf,
-            0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a, 0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
-            0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49, 0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13,
-            0x2e32, 0x1e51, 0x0e70, 0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78, 0x9188, 0x81a9,
-            0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f, 0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046,
-            0x6067, 0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e, 0x02b1, 0x1290, 0x22f3, 0x32d2,
-            0x4235, 0x5214, 0x6277, 0x7256, 0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d, 0x34e2,
-            0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405, 0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e,
-            0xc71d, 0xd73c, 0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634, 0xd94c, 0xc96d, 0xf90e,
-            0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab, 0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
-            0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a, 0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1,
-            0x1ad0, 0x2ab3, 0x3a92, 0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9, 0x7c26, 0x6c07,
-            0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1, 0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9,
-            0x9ff8, 0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
-        };
-
         public static bool? CheckCdSector(byte[] buffer)
         {
             switch(buffer.Length)
@@ -87,14 +60,19 @@ namespace DiscImageChef.Checksums
                     bool? subchannelStatus = CheckCdSectorSubChannel(subchannel);
                     bool? status           = null;
 
-                    if(channelStatus == false || subchannelStatus == false) status = false;
+                    if(channelStatus    == false ||
+                       subchannelStatus == false)
+                        status = false;
+
                     switch(channelStatus)
                     {
                         case null when subchannelStatus == true:
                             status = true;
+
                             break;
                         case true when subchannelStatus == null:
                             status = true;
+
                             break;
                     }
 
@@ -118,7 +96,10 @@ namespace DiscImageChef.Checksums
                 uint j   = (uint)((i << 1) ^ ((i & 0x80) == 0x80 ? 0x11D : 0));
                 eccFTable[i]     = (byte)j;
                 eccBTable[i ^ j] = (byte)i;
-                for(j = 0; j < 8; j++) edc = (edc >> 1) ^ ((edc & 1) > 0 ? 0xD8018001 : 0);
+
+                for(j = 0; j < 8; j++)
+                    edc = (edc >> 1) ^ ((edc & 1) > 0 ? 0xD8018001 : 0);
+
                 edcTable[i] = edc;
             }
         }
@@ -128,24 +109,32 @@ namespace DiscImageChef.Checksums
         {
             uint size = majorCount * minorCount;
             uint major;
+
             for(major = 0; major < majorCount; major++)
             {
-                uint index = (major >> 1) * majorMult + (major & 1);
+                uint index = ((major >> 1) * majorMult) + (major & 1);
                 byte eccA  = 0;
                 byte eccB  = 0;
                 uint minor;
+
                 for(minor = 0; minor < minorCount; minor++)
                 {
                     byte temp = index < 4 ? address[index] : data[index - 4];
                     index += minorInc;
-                    if(index >= size) index -= size;
+
+                    if(index >= size)
+                        index -= size;
+
                     eccA ^= temp;
                     eccB ^= temp;
                     eccA =  eccFTable[eccA];
                 }
 
                 eccA = eccBTable[eccFTable[eccA] ^ eccB];
-                if(ecc[major] != eccA || ecc[major + majorCount] != (eccA ^ eccB)) return false;
+
+                if(ecc[major]              != eccA ||
+                   ecc[major + majorCount] != (eccA ^ eccB))
+                    return false;
             }
 
             return true;
@@ -155,10 +144,19 @@ namespace DiscImageChef.Checksums
         {
             EccInit();
 
-            if(channel[0x000] != 0x00 || channel[0x001] != 0xFF || channel[0x002] != 0xFF || channel[0x003] != 0xFF ||
+            if(channel[0x000] != 0x00 ||
-               channel[0x004] != 0xFF || channel[0x005] != 0xFF || channel[0x006] != 0xFF || channel[0x007] != 0xFF ||
+               channel[0x001] != 0xFF ||
-               channel[0x008] != 0xFF || channel[0x009] != 0xFF || channel[0x00A] != 0xFF ||
+               channel[0x002] != 0xFF ||
-               channel[0x00B] != 0x00) return null;
+               channel[0x003] != 0xFF ||
+               channel[0x004] != 0xFF ||
+               channel[0x005] != 0xFF ||
+               channel[0x006] != 0xFF ||
+               channel[0x007] != 0xFF ||
+               channel[0x008] != 0xFF ||
+               channel[0x009] != 0xFF ||
+               channel[0x00A] != 0xFF ||
+               channel[0x00B] != 0x00)
+                return null;
 
             //DicConsole.DebugWriteLine("CD checksums", "Data sector, address {0:X2}:{1:X2}:{2:X2}", channel[0x00C],
             //                          channel[0x00D], channel[0x00E]);
@@ -173,6 +171,7 @@ namespace DiscImageChef.Checksums
                         DicConsole.DebugWriteLine("CD checksums",
                                                   "Mode 0 sector with error at address: {0:X2}:{1:X2}:{2:X2}",
                                                   channel[0x00C], channel[0x00D], channel[0x00E]);
+
                         return false;
                     }
 
@@ -185,12 +184,18 @@ namespace DiscImageChef.Checksums
                 //                          channel[0x00C], channel[0x00D], channel[0x00E]);
 
                 if(channel[0x814] != 0x00 || // reserved (8 bytes)
-                   channel[0x815] != 0x00 || channel[0x816] != 0x00 || channel[0x817] != 0x00 ||
+                   channel[0x815] != 0x00 ||
-                   channel[0x818] != 0x00 || channel[0x819] != 0x00 || channel[0x81A] != 0x00 || channel[0x81B] != 0x00)
+                   channel[0x816] != 0x00 ||
+                   channel[0x817] != 0x00 ||
+                   channel[0x818] != 0x00 ||
+                   channel[0x819] != 0x00 ||
+                   channel[0x81A] != 0x00 ||
+                   channel[0x81B] != 0x00)
                 {
                     DicConsole.DebugWriteLine("CD checksums",
                                               "Mode 1 sector with data in reserved bytes at address: {0:X2}:{1:X2}:{2:X2}",
                                               channel[0x00C], channel[0x00D], channel[0x00E]);
+
                     return false;
                 }
 
@@ -213,6 +218,7 @@ namespace DiscImageChef.Checksums
                     DicConsole.DebugWriteLine("CD checksums",
                                               "Mode 1 sector at address: {0:X2}:{1:X2}:{2:X2}, fails ECC P check",
                                               channel[0x00C], channel[0x00D], channel[0x00E]);
+
                 if(failedEccQ)
                     DicConsole.DebugWriteLine("CD checksums",
                                               "Mode 1 sector at address: {0:X2}:{1:X2}:{2:X2}, fails ECC Q check",
@@ -221,11 +227,13 @@ namespace DiscImageChef.Checksums
                 uint storedEdc     = BitConverter.ToUInt32(channel, 0x810);
                 uint calculatedEdc = ComputeEdc(0, channel, 0x810);
 
-                if(calculatedEdc == storedEdc) return !failedEccP && !failedEccQ;
+                if(calculatedEdc == storedEdc)
+                    return!failedEccP && !failedEccQ;
 
                 DicConsole.DebugWriteLine("CD checksums",
                                           "Mode 1 sector at address: {0:X2}:{1:X2}:{2:X2}, got CRC 0x{3:X8} expected 0x{4:X8}",
                                           channel[0x00C], channel[0x00D], channel[0x00E], calculatedEdc, storedEdc);
+
                 return false;
             }
 
@@ -238,29 +246,38 @@ namespace DiscImageChef.Checksums
 
                 if((channel[0x012] & 0x20) == 0x20) // mode 2 form 2
                 {
-                    if(channel[0x010] != channel[0x014] || channel[0x011] != channel[0x015] ||
+                    if(channel[0x010] != channel[0x014] ||
-                       channel[0x012] != channel[0x016] || channel[0x013] != channel[0x017])
+                       channel[0x011] != channel[0x015] ||
+                       channel[0x012] != channel[0x016] ||
+                       channel[0x013] != channel[0x017])
                         DicConsole.DebugWriteLine("CD checksums",
                                                   "Subheader copies differ in mode 2 form 2 sector at address: {0:X2}:{1:X2}:{2:X2}",
                                                   channel[0x00C], channel[0x00D], channel[0x00E]);
 
                     uint storedEdc = BitConverter.ToUInt32(mode2Sector, 0x91C);
+
                     // No CRC stored!
-                    if(storedEdc == 0x00000000) return true;
+                    if(storedEdc == 0x00000000)
+                        return true;
 
                     uint calculatedEdc = ComputeEdc(0, mode2Sector, 0x91C);
 
-                    if(calculatedEdc == storedEdc || storedEdc == 0x00000000) return true;
+                    if(calculatedEdc == storedEdc ||
+                       storedEdc     == 0x00000000)
+                        return true;
 
                     DicConsole.DebugWriteLine("CD checksums",
                                               "Mode 2 form 2 sector at address: {0:X2}:{1:X2}:{2:X2}, got CRC 0x{3:X8} expected 0x{4:X8}",
                                               channel[0x00C], channel[0x00D], channel[0x00E], calculatedEdc, storedEdc);
+
                     return false;
                 }
                 else
                 {
-                    if(channel[0x010] != channel[0x014] || channel[0x011] != channel[0x015] ||
+                    if(channel[0x010] != channel[0x014] ||
-                       channel[0x012] != channel[0x016] || channel[0x013] != channel[0x017])
+                       channel[0x011] != channel[0x015] ||
+                       channel[0x012] != channel[0x016] ||
+                       channel[0x013] != channel[0x017])
                         DicConsole.DebugWriteLine("CD checksums",
                                                   "Subheader copies differ in mode 2 form 1 sector at address: {0:X2}:{1:X2}:{2:X2}",
                                                   channel[0x00C], channel[0x00D], channel[0x00E]);
@@ -279,6 +296,7 @@ namespace DiscImageChef.Checksums
                         DicConsole.DebugWriteLine("CD checksums",
                                                   "Mode 2 form 1 sector at address: {0:X2}:{1:X2}:{2:X2}, fails ECC P check",
                                                   channel[0x00C], channel[0x00D], channel[0x00E]);
+
                     if(failedEccQ)
                         DicConsole.DebugWriteLine("CD checksums",
                                                   "Mode 2 form 1 sector at address: {0:X2}:{1:X2}:{2:X2}, fails ECC Q check",
@@ -287,24 +305,29 @@ namespace DiscImageChef.Checksums
                     uint storedEdc     = BitConverter.ToUInt32(mode2Sector, 0x808);
                     uint calculatedEdc = ComputeEdc(0, mode2Sector, 0x808);
 
-                    if(calculatedEdc == storedEdc) return !failedEccP && !failedEccQ;
+                    if(calculatedEdc == storedEdc)
+                        return!failedEccP && !failedEccQ;
 
                     DicConsole.DebugWriteLine("CD checksums",
                                               "Mode 1 sector at address: {0:X2}:{1:X2}:{2:X2}, got CRC 0x{3:X8} expected 0x{4:X8}",
                                               channel[0x00C], channel[0x00D], channel[0x00E], calculatedEdc, storedEdc);
+
                     return false;
                 }
             }
 
             DicConsole.DebugWriteLine("CD checksums", "Unknown mode {0} sector at address: {1:X2}:{2:X2}:{3:X2}",
                                       channel[0x00F], channel[0x00C], channel[0x00D], channel[0x00E]);
+
             return null;
         }
 
         static uint ComputeEdc(uint edc, IReadOnlyList<byte> src, int size)
         {
             int pos = 0;
-            for(; size > 0; size--) edc = (edc >> 8) ^ edcTable[(edc ^ src[pos++]) & 0xFF];
+
+            for(; size > 0; size--)
+                edc = (edc >> 8) ^ edcTable[(edc ^ src[pos++]) & 0xFF];
 
             return edc;
         }
@@ -323,7 +346,10 @@ namespace DiscImageChef.Checksums
             byte[] cdSubRwPack4 = new byte[24];
 
             int i = 0;
-            for(int j = 0; j < 12; j++) qSubChannel[j] = 0;
+
+            for(int j = 0; j < 12; j++)
+                qSubChannel[j] = 0;
+
             for(int j = 0; j < 18; j++)
             {
                 cdTextPack1[j] = 0;
@@ -353,92 +379,154 @@ namespace DiscImageChef.Checksums
             }
 
             i = 0;
+
             for(int j = 0; j < 18; j++)
             {
-                if(j < 18) cdTextPack1[j] = (byte)(cdTextPack1[j]   | ((subchannel[i++] & 0x3F) << 2));
+                if(j < 18)
-                if(j < 18) cdTextPack1[j] = (byte)(cdTextPack1[j++] | ((subchannel[i]   & 0xC0) >> 4));
+                    cdTextPack1[j] = (byte)(cdTextPack1[j] | ((subchannel[i++] & 0x3F) << 2));
-                if(j < 18) cdTextPack1[j] = (byte)(cdTextPack1[j]   | ((subchannel[i++] & 0x0F) << 4));
+
-                if(j < 18) cdTextPack1[j] = (byte)(cdTextPack1[j++] | ((subchannel[i]   & 0x3C) >> 2));
+                if(j < 18)
-                if(j < 18) cdTextPack1[j] = (byte)(cdTextPack1[j]   | ((subchannel[i++] & 0x03) << 6));
+                    cdTextPack1[j] = (byte)(cdTextPack1[j++] | ((subchannel[i] & 0xC0) >> 4));
-                if(j < 18) cdTextPack1[j] = (byte)(cdTextPack1[j]   | (subchannel[i++] & 0x3F));
+
+                if(j < 18)
+                    cdTextPack1[j] = (byte)(cdTextPack1[j] | ((subchannel[i++] & 0x0F) << 4));
+
+                if(j < 18)
+                    cdTextPack1[j] = (byte)(cdTextPack1[j++] | ((subchannel[i] & 0x3C) >> 2));
+
+                if(j < 18)
+                    cdTextPack1[j] = (byte)(cdTextPack1[j] | ((subchannel[i++] & 0x03) << 6));
+
+                if(j < 18)
+                    cdTextPack1[j] = (byte)(cdTextPack1[j] | (subchannel[i++] & 0x3F));
             }
 
             for(int j = 0; j < 18; j++)
             {
-                if(j < 18) cdTextPack2[j] = (byte)(cdTextPack2[j]   | ((subchannel[i++] & 0x3F) << 2));
+                if(j < 18)
-                if(j < 18) cdTextPack2[j] = (byte)(cdTextPack2[j++] | ((subchannel[i]   & 0xC0) >> 4));
+                    cdTextPack2[j] = (byte)(cdTextPack2[j] | ((subchannel[i++] & 0x3F) << 2));
-                if(j < 18) cdTextPack2[j] = (byte)(cdTextPack2[j]   | ((subchannel[i++] & 0x0F) << 4));
+
-                if(j < 18) cdTextPack2[j] = (byte)(cdTextPack2[j++] | ((subchannel[i]   & 0x3C) >> 2));
+                if(j < 18)
-                if(j < 18) cdTextPack2[j] = (byte)(cdTextPack2[j]   | ((subchannel[i++] & 0x03) << 6));
+                    cdTextPack2[j] = (byte)(cdTextPack2[j++] | ((subchannel[i] & 0xC0) >> 4));
-                if(j < 18) cdTextPack2[j] = (byte)(cdTextPack2[j]   | (subchannel[i++] & 0x3F));
+
+                if(j < 18)
+                    cdTextPack2[j] = (byte)(cdTextPack2[j] | ((subchannel[i++] & 0x0F) << 4));
+
+                if(j < 18)
+                    cdTextPack2[j] = (byte)(cdTextPack2[j++] | ((subchannel[i] & 0x3C) >> 2));
+
+                if(j < 18)
+                    cdTextPack2[j] = (byte)(cdTextPack2[j] | ((subchannel[i++] & 0x03) << 6));
+
+                if(j < 18)
+                    cdTextPack2[j] = (byte)(cdTextPack2[j] | (subchannel[i++] & 0x3F));
             }
 
             for(int j = 0; j < 18; j++)
             {
-                if(j < 18) cdTextPack3[j] = (byte)(cdTextPack3[j]   | ((subchannel[i++] & 0x3F) << 2));
+                if(j < 18)
-                if(j < 18) cdTextPack3[j] = (byte)(cdTextPack3[j++] | ((subchannel[i]   & 0xC0) >> 4));
+                    cdTextPack3[j] = (byte)(cdTextPack3[j] | ((subchannel[i++] & 0x3F) << 2));
-                if(j < 18) cdTextPack3[j] = (byte)(cdTextPack3[j]   | ((subchannel[i++] & 0x0F) << 4));
+
-                if(j < 18) cdTextPack3[j] = (byte)(cdTextPack3[j++] | ((subchannel[i]   & 0x3C) >> 2));
+                if(j < 18)
-                if(j < 18) cdTextPack3[j] = (byte)(cdTextPack3[j]   | ((subchannel[i++] & 0x03) << 6));
+                    cdTextPack3[j] = (byte)(cdTextPack3[j++] | ((subchannel[i] & 0xC0) >> 4));
-                if(j < 18) cdTextPack3[j] = (byte)(cdTextPack3[j]   | (subchannel[i++] & 0x3F));
+
+                if(j < 18)
+                    cdTextPack3[j] = (byte)(cdTextPack3[j] | ((subchannel[i++] & 0x0F) << 4));
+
+                if(j < 18)
+                    cdTextPack3[j] = (byte)(cdTextPack3[j++] | ((subchannel[i] & 0x3C) >> 2));
+
+                if(j < 18)
+                    cdTextPack3[j] = (byte)(cdTextPack3[j] | ((subchannel[i++] & 0x03) << 6));
+
+                if(j < 18)
+                    cdTextPack3[j] = (byte)(cdTextPack3[j] | (subchannel[i++] & 0x3F));
             }
 
             for(int j = 0; j < 18; j++)
             {
-                if(j < 18) cdTextPack4[j] = (byte)(cdTextPack4[j]   | ((subchannel[i++] & 0x3F) << 2));
+                if(j < 18)
-                if(j < 18) cdTextPack4[j] = (byte)(cdTextPack4[j++] | ((subchannel[i]   & 0xC0) >> 4));
+                    cdTextPack4[j] = (byte)(cdTextPack4[j] | ((subchannel[i++] & 0x3F) << 2));
-                if(j < 18) cdTextPack4[j] = (byte)(cdTextPack4[j]   | ((subchannel[i++] & 0x0F) << 4));
+
-                if(j < 18) cdTextPack4[j] = (byte)(cdTextPack4[j++] | ((subchannel[i]   & 0x3C) >> 2));
+                if(j < 18)
-                if(j < 18) cdTextPack4[j] = (byte)(cdTextPack4[j]   | ((subchannel[i++] & 0x03) << 6));
+                    cdTextPack4[j] = (byte)(cdTextPack4[j++] | ((subchannel[i] & 0xC0) >> 4));
-                if(j < 18) cdTextPack4[j] = (byte)(cdTextPack4[j]   | (subchannel[i++] & 0x3F));
+
+                if(j < 18)
+                    cdTextPack4[j] = (byte)(cdTextPack4[j] | ((subchannel[i++] & 0x0F) << 4));
+
+                if(j < 18)
+                    cdTextPack4[j] = (byte)(cdTextPack4[j++] | ((subchannel[i] & 0x3C) >> 2));
+
+                if(j < 18)
+                    cdTextPack4[j] = (byte)(cdTextPack4[j] | ((subchannel[i++] & 0x03) << 6));
+
+                if(j < 18)
+                    cdTextPack4[j] = (byte)(cdTextPack4[j] | (subchannel[i++] & 0x3F));
             }
 
             i = 0;
-            for(int j = 0; j < 24; j++) cdSubRwPack1[j] = (byte)(subchannel[i++] & 0x3F);
+
-            for(int j = 0; j < 24; j++) cdSubRwPack2[j] = (byte)(subchannel[i++] & 0x3F);
+            for(int j = 0; j < 24; j++)
-            for(int j = 0; j < 24; j++) cdSubRwPack3[j] = (byte)(subchannel[i++] & 0x3F);
+                cdSubRwPack1[j] = (byte)(subchannel[i++] & 0x3F);
-            for(int j = 0; j < 24; j++) cdSubRwPack4[j] = (byte)(subchannel[i++] & 0x3F);
+
+            for(int j = 0; j < 24; j++)
+                cdSubRwPack2[j] = (byte)(subchannel[i++] & 0x3F);
+
+            for(int j = 0; j < 24; j++)
+                cdSubRwPack3[j] = (byte)(subchannel[i++] & 0x3F);
+
+            for(int j = 0; j < 24; j++)
+                cdSubRwPack4[j] = (byte)(subchannel[i++] & 0x3F);
 
             switch(cdSubRwPack1[0])
             {
                 case 0x00:
                     DicConsole.DebugWriteLine("CD checksums", "Detected Zero Pack in subchannel");
+
                     break;
                 case 0x08:
                     DicConsole.DebugWriteLine("CD checksums", "Detected Line Graphics Pack in subchannel");
+
                     break;
                 case 0x09:
                     DicConsole.DebugWriteLine("CD checksums", "Detected CD+G Pack in subchannel");
+
                     break;
                 case 0x0A:
                     DicConsole.DebugWriteLine("CD checksums", "Detected CD+EG Pack in subchannel");
+
                     break;
                 case 0x14:
                     DicConsole.DebugWriteLine("CD checksums", "Detected CD-TEXT Pack in subchannel");
+
                     break;
                 case 0x18:
                     DicConsole.DebugWriteLine("CD checksums", "Detected CD+MIDI Pack in subchannel");
+
                     break;
                 case 0x38:
                     DicConsole.DebugWriteLine("CD checksums", "Detected User Pack in subchannel");
+
                     break;
                 default:
                     DicConsole.DebugWriteLine("CD checksums",
                                               "Detected unknown Pack type in subchannel: mode {0}, item {1}",
                                               Convert.ToString(cdSubRwPack1[0] & 0x38, 2),
                                               Convert.ToString(cdSubRwPack1[0] & 0x07, 2));
+
                     break;
             }
 
             ushort qSubChannelCrc    = BigEndianBitConverter.ToUInt16(qSubChannel, 10);
             byte[] qSubChannelForCrc = new byte[10];
             Array.Copy(qSubChannel, 0, qSubChannelForCrc, 0, 10);
-            ushort calculatedQcrc = CalculateCCITT_CRC16(qSubChannelForCrc);
+            ushort calculatedQcrc = CRC16CCITTContext.Calculate(qSubChannelForCrc);
 
             if(qSubChannelCrc != calculatedQcrc)
             {
                 DicConsole.DebugWriteLine("CD checksums", "Q subchannel CRC 0x{0:X4}, expected 0x{1:X4}",
                                           calculatedQcrc, qSubChannelCrc);
+
                 status = false;
             }
 
@@ -447,12 +535,14 @@ namespace DiscImageChef.Checksums
                 ushort cdTextPack1Crc    = BigEndianBitConverter.ToUInt16(cdTextPack1, 16);
                 byte[] cdTextPack1ForCrc = new byte[16];
                 Array.Copy(cdTextPack1, 0, cdTextPack1ForCrc, 0, 16);
-                ushort calculatedCdtp1Crc = CalculateCCITT_CRC16(cdTextPack1ForCrc);
+                ushort calculatedCdtp1Crc = CRC16CCITTContext.Calculate(cdTextPack1ForCrc);
 
-                if(cdTextPack1Crc != calculatedCdtp1Crc && cdTextPack1Crc != 0)
+                if(cdTextPack1Crc != calculatedCdtp1Crc &&
+                   cdTextPack1Crc != 0)
                 {
                     DicConsole.DebugWriteLine("CD checksums", "CD-Text Pack 1 CRC 0x{0:X4}, expected 0x{1:X4}",
                                               cdTextPack1Crc, calculatedCdtp1Crc);
+
                     status = false;
                 }
             }
@@ -462,14 +552,17 @@ namespace DiscImageChef.Checksums
                 ushort cdTextPack2Crc    = BigEndianBitConverter.ToUInt16(cdTextPack2, 16);
                 byte[] cdTextPack2ForCrc = new byte[16];
                 Array.Copy(cdTextPack2, 0, cdTextPack2ForCrc, 0, 16);
-                ushort calculatedCdtp2Crc = CalculateCCITT_CRC16(cdTextPack2ForCrc);
+                ushort calculatedCdtp2Crc = CRC16CCITTContext.Calculate(cdTextPack2ForCrc);
+
                 DicConsole.DebugWriteLine("CD checksums", "Cyclic CDTP2 0x{0:X4}, Calc CDTP2 0x{1:X4}", cdTextPack2Crc,
                                           calculatedCdtp2Crc);
 
-                if(cdTextPack2Crc != calculatedCdtp2Crc && cdTextPack2Crc != 0)
+                if(cdTextPack2Crc != calculatedCdtp2Crc &&
+                   cdTextPack2Crc != 0)
                 {
                     DicConsole.DebugWriteLine("CD checksums", "CD-Text Pack 2 CRC 0x{0:X4}, expected 0x{1:X4}",
                                               cdTextPack2Crc, calculatedCdtp2Crc);
+
                     status = false;
                 }
             }
@@ -479,45 +572,40 @@ namespace DiscImageChef.Checksums
                 ushort cdTextPack3Crc    = BigEndianBitConverter.ToUInt16(cdTextPack3, 16);
                 byte[] cdTextPack3ForCrc = new byte[16];
                 Array.Copy(cdTextPack3, 0, cdTextPack3ForCrc, 0, 16);
-                ushort calculatedCdtp3Crc = CalculateCCITT_CRC16(cdTextPack3ForCrc);
+                ushort calculatedCdtp3Crc = CRC16CCITTContext.Calculate(cdTextPack3ForCrc);
+
                 DicConsole.DebugWriteLine("CD checksums", "Cyclic CDTP3 0x{0:X4}, Calc CDTP3 0x{1:X4}", cdTextPack3Crc,
                                           calculatedCdtp3Crc);
 
-                if(cdTextPack3Crc != calculatedCdtp3Crc && cdTextPack3Crc != 0)
+                if(cdTextPack3Crc != calculatedCdtp3Crc &&
+                   cdTextPack3Crc != 0)
                 {
                     DicConsole.DebugWriteLine("CD checksums", "CD-Text Pack 3 CRC 0x{0:X4}, expected 0x{1:X4}",
                                               cdTextPack3Crc, calculatedCdtp3Crc);
+
                     status = false;
                 }
             }
 
-            if((cdTextPack4[0] & 0x80) != 0x80) return status;
+            if((cdTextPack4[0] & 0x80) != 0x80)
+                return status;
 
             ushort cdTextPack4Crc    = BigEndianBitConverter.ToUInt16(cdTextPack4, 16);
             byte[] cdTextPack4ForCrc = new byte[16];
             Array.Copy(cdTextPack4, 0, cdTextPack4ForCrc, 0, 16);
-            ushort calculatedCdtp4Crc = CalculateCCITT_CRC16(cdTextPack4ForCrc);
+            ushort calculatedCdtp4Crc = CRC16CCITTContext.Calculate(cdTextPack4ForCrc);
+
             DicConsole.DebugWriteLine("CD checksums", "Cyclic CDTP4 0x{0:X4}, Calc CDTP4 0x{1:X4}", cdTextPack4Crc,
                                       calculatedCdtp4Crc);
 
-            if(cdTextPack4Crc == calculatedCdtp4Crc || cdTextPack4Crc == 0) return status;
+            if(cdTextPack4Crc == calculatedCdtp4Crc ||
+               cdTextPack4Crc == 0)
+                return status;
 
             DicConsole.DebugWriteLine("CD checksums", "CD-Text Pack 4 CRC 0x{0:X4}, expected 0x{1:X4}", cdTextPack4Crc,
                                       calculatedCdtp4Crc);
 
             return false;
         }
-
-        static ushort CalculateCCITT_CRC16(byte[] buffer)
-        {
-            ushort crc16 =
-                buffer.Aggregate<byte, ushort>(0,
-                                               (current, t) =>
-                                                   (ushort)(CcittCrc16Table[(current >> 8) ^ t] ^ (current << 8)));
-
-            crc16 = (ushort)~crc16;
-
-            return crc16;
-        }
     }
 }

DiscImageChef.Checksums/CRC16CCITTContext.cs

@@ -0,0 +1,63 @@
+namespace DiscImageChef.Checksums
+{
+    public class CRC16CCITTContext : Crc16Context
+    {
+        public const ushort CRC16_CCITT_POLY = 0x8408;
+        public const ushort CRC16_CCITT_SEED = 0x0000;
+        static readonly ushort[] _ccittCrc16Table =
+        {
+            0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7, 0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c,
+            0xd1ad, 0xe1ce, 0xf1ef, 0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6, 0x9339, 0x8318,
+            0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de, 0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4,
+            0x5485, 0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d, 0x3653, 0x2672, 0x1611, 0x0630,
+            0x76d7, 0x66f6, 0x5695, 0x46b4, 0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc, 0x48c4,
+            0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823, 0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969,
+            0xa90a, 0xb92b, 0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12, 0xdbfd, 0xcbdc, 0xfbbf,
+            0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a, 0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
+            0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49, 0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13,
+            0x2e32, 0x1e51, 0x0e70, 0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78, 0x9188, 0x81a9,
+            0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f, 0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046,
+            0x6067, 0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e, 0x02b1, 0x1290, 0x22f3, 0x32d2,
+            0x4235, 0x5214, 0x6277, 0x7256, 0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d, 0x34e2,
+            0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405, 0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e,
+            0xc71d, 0xd73c, 0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634, 0xd94c, 0xc96d, 0xf90e,
+            0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab, 0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
+            0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a, 0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1,
+            0x1ad0, 0x2ab3, 0x3a92, 0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9, 0x7c26, 0x6c07,
+            0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1, 0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9,
+            0x9ff8, 0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
+        };
+
+        public CRC16CCITTContext() : base(CRC16_CCITT_POLY, CRC16_CCITT_SEED, _ccittCrc16Table, true) { }
+
+        /// <summary>Gets the hash of a file</summary>
+        /// <param name="filename">File path.</param>
+        public static byte[] File(string filename)
+        {
+            File(filename, out byte[] hash);
+
+            return hash;
+        }
+
+        /// <summary>Gets the hash of a file in hexadecimal and as a byte array.</summary>
+        /// <param name="filename">File path.</param>
+        /// <param name="hash">Byte array of the hash value.</param>
+        public static string File(string filename, out byte[] hash) =>
+            File(filename, out hash, CRC16_CCITT_POLY, CRC16_CCITT_SEED, _ccittCrc16Table, true);
+
+        /// <summary>Gets the hash of the specified data buffer.</summary>
+        /// <param name="data">Data buffer.</param>
+        /// <param name="len">Length of the data buffer to hash.</param>
+        /// <param name="hash">Byte array of the hash value.</param>
+        public static string Data(byte[] data, uint len, out byte[] hash) =>
+            Data(data, len, out hash, CRC16_CCITT_POLY, CRC16_CCITT_SEED, _ccittCrc16Table, true);
+
+        /// <summary>Gets the hash of the specified data buffer.</summary>
+        /// <param name="data">Data buffer.</param>
+        /// <param name="hash">Byte array of the hash value.</param>
+        public static string Data(byte[] data, out byte[] hash) => Data(data, (uint)data.Length, out hash);
+
+        public static ushort Calculate(byte[] buffer) =>
+            Calculate(buffer, CRC16_CCITT_POLY, CRC16_CCITT_SEED, _ccittCrc16Table, true);
+    }
+}

DiscImageChef.Checksums/CRC16Context.cs

@@ -31,208 +31,196 @@
 // ****************************************************************************/
 
 using System.IO;
+using System.Linq;
 using System.Text;
 using DiscImageChef.CommonTypes.Interfaces;
 
 namespace DiscImageChef.Checksums
 {
-    /// <summary>
+    /// <summary>Implements a CRC16 algorithm</summary>
-    ///     Implements a CRC16 algorithm
-    /// </summary>
     public class Crc16Context : IChecksum
     {
-        public const ushort CRC16_IBM_POLY   = 0xA001;
+        protected ushort _finalSeed;
-        public const ushort CRC16_IBM_SEED   = 0x0000;
+        protected ushort _hashInt;
-        public const ushort CRC16_CCITT_POLY = 0x8408;
+        protected bool   _inverse;
-        public const ushort CRC16_CCITT_SEED = 0x0000;
 
-        readonly ushort   finalSeed;
+        protected ushort[] _table;
-        readonly ushort[] table;
-        ushort            hashInt;
 
-        /// <summary>
+        /// <summary>Initializes the CRC16 table with a custom polynomial and seed</summary>
-        ///     Initializes the CRC16 table and seed as CRC16-IBM
+        public Crc16Context(ushort polynomial, ushort seed, ushort[] table, bool inverse)
-        /// </summary>
-        public Crc16Context()
         {
-            hashInt   = CRC16_IBM_SEED;
+            _hashInt   = seed;
-            finalSeed = CRC16_IBM_SEED;
+            _finalSeed = seed;
+            _inverse   = inverse;
 
-            table = new ushort[256];
+            _table = table ?? GenerateTable(polynomial, inverse);
-            for(int i = 0; i < 256; i++)
-            {
-                ushort entry = (ushort)i;
-                for(int j = 0; j < 8; j++)
-                    if((entry & 1) == 1) entry = (ushort)((entry >> 1) ^ CRC16_IBM_POLY);
-                    else entry                 = (ushort)(entry >> 1);
-
-                table[i] = entry;
-            }
         }
 
-        /// <summary>
+        /// <summary>Updates the hash with data.</summary>
-        ///     Initializes the CRC16 table with a custom polynomial and seed
-        /// </summary>
-        public Crc16Context(ushort polynomial, ushort seed)
-        {
-            hashInt   = seed;
-            finalSeed = seed;
-
-            table = new ushort[256];
-            for(int i = 0; i < 256; i++)
-            {
-                ushort entry = (ushort)i;
-                for(int j = 0; j < 8; j++)
-                    if((entry & 1) == 1) entry = (ushort)((entry >> 1) ^ polynomial);
-                    else entry                 = (ushort)(entry >> 1);
-
-                table[i] = entry;
-            }
-        }
-
-        /// <summary>
-        ///     Updates the hash with data.
-        /// </summary>
         /// <param name="data">Data buffer.</param>
         /// <param name="len">Length of buffer to hash.</param>
         public void Update(byte[] data, uint len)
         {
-            for(int i = 0; i < len; i++) hashInt = (ushort)((hashInt >> 8) ^ table[data[i] ^ (hashInt & 0xFF)]);
+            for(int i = 0; i < len; i++)
-        }
-
-        /// <summary>
-        ///     Updates the hash with data.
-        /// </summary>
-        /// <param name="data">Data buffer.</param>
-        public void Update(byte[] data)
             {
-            Update(data, (uint)data.Length);
+                if(_inverse)
+                    _hashInt = (ushort)(_table[(_hashInt >> 8) ^ data[i]] ^ (_hashInt << 8));
+                else
+                    _hashInt = (ushort)((_hashInt >> 8) ^ _table[data[i] ^ (_hashInt & 0xFF)]);
+            }
         }
 
-        /// <summary>
+        /// <summary>Updates the hash with data.</summary>
-        ///     Returns a byte array of the hash value.
+        /// <param name="data">Data buffer.</param>
-        /// </summary>
+        public void Update(byte[] data) => Update(data, (uint)data.Length);
-        public byte[] Final() => BigEndianBitConverter.GetBytes((ushort)(hashInt ^ finalSeed));
 
-        /// <summary>
+        /// <summary>Returns a byte array of the hash value.</summary>
-        ///     Returns a hexadecimal representation of the hash value.
+        public byte[] Final() => BigEndianBitConverter.GetBytes((ushort)(_hashInt ^ _finalSeed));
-        /// </summary>
+
+        /// <summary>Returns a hexadecimal representation of the hash value.</summary>
         public string End()
         {
-            StringBuilder crc16Output = new StringBuilder();
+            var crc16Output = new StringBuilder();
 
-            for(int i = 0; i < BigEndianBitConverter.GetBytes((ushort)(hashInt ^ finalSeed)).Length; i++)
+            ushort final = (ushort)(_hashInt ^ _finalSeed);
-                crc16Output.Append(BigEndianBitConverter.GetBytes((ushort)(hashInt ^ finalSeed))[i].ToString("x2"));
+
+            if(_inverse)
+                final = (ushort)~final;
+
+            byte[] finalBytes = BigEndianBitConverter.GetBytes(final);
+
+            for(int i = 0; i < finalBytes.Length; i++)
+                crc16Output.Append(finalBytes[i].ToString("x2"));
 
             return crc16Output.ToString();
         }
 
-        /// <summary>
+        static ushort[] GenerateTable(ushort polynomial, bool inverseTable)
-        ///     Gets the hash of a file
-        /// </summary>
-        /// <param name="filename">File path.</param>
-        public static byte[] File(string filename)
         {
-            File(filename, out byte[] hash);
+            ushort[] table = new ushort[256];
-            return hash;
-        }
 
-        /// <summary>
+            if(!inverseTable)
-        ///     Gets the hash of a file in hexadecimal and as a byte array.
+                for(uint i = 0; i < 256; i++)
-        /// </summary>
-        /// <param name="filename">File path.</param>
-        /// <param name="hash">Byte array of the hash value.</param>
-        public static string File(string filename, out byte[] hash) =>
-            File(filename, out hash, CRC16_IBM_POLY, CRC16_IBM_SEED);
-
-        /// <summary>
-        ///     Gets the hash of a file in hexadecimal and as a byte array.
-        /// </summary>
-        /// <param name="filename">File path.</param>
-        /// <param name="hash">Byte array of the hash value.</param>
-        public static string File(string filename, out byte[] hash, ushort polynomial, ushort seed)
                 {
-            FileStream fileStream = new FileStream(filename, FileMode.Open);
+                    uint entry = i;
 
-            ushort localhashInt = seed;
-
-            ushort[] localTable = new ushort[256];
-            for(int i = 0; i < 256; i++)
-            {
-                ushort entry = (ushort)i;
                     for(int j = 0; j < 8; j++)
-                    if((entry & 1) == 1) entry = (ushort)((entry >> 1) ^ polynomial);
+                        if((entry & 1) == 1)
-                    else entry                 = (ushort)(entry >> 1);
+                            entry = (entry >> 1) ^ polynomial;
+                        else
+                            entry = entry >> 1;
 
-                localTable[i] = entry;
+                    table[i] = (ushort)entry;
                 }
+            else
+            {
+                for(uint i = 0; i < 256; i++)
+                {
+                    uint entry = i << 8;
+
+                    for(uint j = 0; j < 8; j++)
+                    {
+                        if((entry & 0x8000) > 0)
+                            entry = (entry << 1) ^ polynomial;
+                        else
+                            entry <<= 1;
+
+                        table[i] = (ushort)entry;
+                    }
+                }
+            }
+
+            return table;
+        }
+
+        /// <summary>Gets the hash of a file in hexadecimal and as a byte array.</summary>
+        /// <param name="filename">File path.</param>
+        /// <param name="hash">Byte array of the hash value.</param>
+        public static string File(string filename, out byte[] hash, ushort polynomial, ushort seed, ushort[] table,
+                                  bool inverse)
+        {
+            var fileStream = new FileStream(filename, FileMode.Open);
+
+            ushort localHashInt = seed;
+
+            ushort[] localTable = table ?? GenerateTable(polynomial, inverse);
 
             for(int i = 0; i < fileStream.Length; i++)
-                localhashInt =
+                if(inverse)
-                    (ushort)((localhashInt >> 8) ^ localTable[fileStream.ReadByte() ^ (localhashInt & 0xff)]);
+                    localHashInt =
+                        (ushort)(localTable[(localHashInt >> 8) ^ fileStream.ReadByte()] ^ (localHashInt << 8));
+                else
+                    localHashInt =
+                        (ushort)((localHashInt >> 8) ^ localTable[fileStream.ReadByte() ^ (localHashInt & 0xff)]);
 
-            localhashInt ^= seed;
+            localHashInt ^= seed;
-            hash         =  BigEndianBitConverter.GetBytes(localhashInt);
 
-            StringBuilder crc16Output = new StringBuilder();
+            if(inverse)
+                localHashInt = (ushort)~localHashInt;
 
-            foreach(byte h in hash) crc16Output.Append(h.ToString("x2"));
+            hash = BigEndianBitConverter.GetBytes(localHashInt);
+
+            var crc16Output = new StringBuilder();
+
+            foreach(byte h in hash)
+                crc16Output.Append(h.ToString("x2"));
 
             fileStream.Close();
 
             return crc16Output.ToString();
         }
 
-        /// <summary>
+        /// <summary>Gets the hash of the specified data buffer.</summary>
-        ///     Gets the hash of the specified data buffer.
-        /// </summary>
-        /// <param name="data">Data buffer.</param>
-        /// <param name="len">Length of the data buffer to hash.</param>
-        /// <param name="hash">Byte array of the hash value.</param>
-        public static string Data(byte[] data, uint len, out byte[] hash) =>
-            Data(data, len, out hash, CRC16_IBM_POLY, CRC16_IBM_SEED);
-
-        /// <summary>
-        ///     Gets the hash of the specified data buffer.
-        /// </summary>
         /// <param name="data">Data buffer.</param>
         /// <param name="len">Length of the data buffer to hash.</param>
         /// <param name="hash">Byte array of the hash value.</param>
         /// <param name="polynomial">CRC polynomial</param>
         /// <param name="seed">CRC seed</param>
-        public static string Data(byte[] data, uint len, out byte[] hash, ushort polynomial, ushort seed)
+        public static string Data(byte[] data, uint len, out byte[] hash, ushort polynomial, ushort seed,
+                                  ushort[] table, bool inverse)
         {
-            ushort localhashInt = seed;
+            ushort localHashInt = seed;
 
-            ushort[] localTable = new ushort[256];
+            ushort[] localTable = table ?? GenerateTable(polynomial, inverse);
-            for(int i = 0; i < 256; i++)
-            {
-                ushort entry = (ushort)i;
-                for(int j = 0; j < 8; j++)
-                    if((entry & 1) == 1) entry = (ushort)((entry >> 1) ^ polynomial);
-                    else entry                 = (ushort)(entry >> 1);
-
-                localTable[i] = entry;
-            }
 
             for(int i = 0; i < len; i++)
-                localhashInt = (ushort)((localhashInt >> 8) ^ localTable[data[i] ^ (localhashInt & 0xff)]);
+                if(inverse)
+                    localHashInt = (ushort)(localTable[(localHashInt >> 8) ^ data[i]] ^ (localHashInt << 8));
+                else
+                    localHashInt = (ushort)((localHashInt >> 8) ^ localTable[data[i] ^ (localHashInt & 0xff)]);
 
-            localhashInt ^= seed;
+            localHashInt ^= seed;
-            hash         =  BigEndianBitConverter.GetBytes(localhashInt);
 
-            StringBuilder crc16Output = new StringBuilder();
+            if(inverse)
+                localHashInt = (ushort)~localHashInt;
 
-            foreach(byte h in hash) crc16Output.Append(h.ToString("x2"));
+            hash = BigEndianBitConverter.GetBytes(localHashInt);
+
+            var crc16Output = new StringBuilder();
+
+            foreach(byte h in hash)
+                crc16Output.Append(h.ToString("x2"));
 
             return crc16Output.ToString();
         }
 
-        /// <summary>
+        public static ushort Calculate(byte[] buffer, ushort polynomial, ushort seed, ushort[] table, bool inverse)
-        ///     Gets the hash of the specified data buffer.
+        {
-        /// </summary>
+            ushort[] localTable = table ?? GenerateTable(polynomial, inverse);
-        /// <param name="data">Data buffer.</param>
+
-        /// <param name="hash">Byte array of the hash value.</param>
+            ushort crc16 =
-        public static string Data(byte[] data, out byte[] hash) => Data(data, (uint)data.Length, out hash);
+                buffer.Aggregate<byte, ushort>(0,
+                                               (current, b) =>
+                                                   inverse ? (ushort)(localTable[(current >> 8) ^ b] ^ (current << 8))
+                                                       : (ushort)((current >> 8) ^
+                                                                  localTable[b ^ (current & 0xff)]));
+
+            crc16 ^= seed;
+
+            if(inverse)
+                crc16 = (ushort)~crc16;
+
+            return crc16;
+        }
     }
 }

DiscImageChef.Checksums/CRC16IBMContext.cs

@@ -0,0 +1,64 @@
+namespace DiscImageChef.Checksums
+{
+    public class CRC16IBMContext : Crc16Context
+    {
+        const ushort CRC16_IBM_POLY = 0xA001;
+        const ushort CRC16_IBM_SEED = 0x0000;
+
+        static readonly ushort[] _ibmCrc16Table =
+        {
+            0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241, 0xC601, 0x06C0, 0x0780, 0xC741, 0x0500,
+            0xC5C1, 0xC481, 0x0440, 0xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40, 0x0A00, 0xCAC1,
+            0xCB81, 0x0B40, 0xC901, 0x09C0, 0x0880, 0xC841, 0xD801, 0x18C0, 0x1980, 0xD941, 0x1B00, 0xDBC1, 0xDA81,
+            0x1A40, 0x1E00, 0xDEC1, 0xDF81, 0x1F40, 0xDD01, 0x1DC0, 0x1C80, 0xDC41, 0x1400, 0xD4C1, 0xD581, 0x1540,
+            0xD701, 0x17C0, 0x1680, 0xD641, 0xD201, 0x12C0, 0x1380, 0xD341, 0x1100, 0xD1C1, 0xD081, 0x1040, 0xF001,
+            0x30C0, 0x3180, 0xF141, 0x3300, 0xF3C1, 0xF281, 0x3240, 0x3600, 0xF6C1, 0xF781, 0x3740, 0xF501, 0x35C0,
+            0x3480, 0xF441, 0x3C00, 0xFCC1, 0xFD81, 0x3D40, 0xFF01, 0x3FC0, 0x3E80, 0xFE41, 0xFA01, 0x3AC0, 0x3B80,
+            0xFB41, 0x3900, 0xF9C1, 0xF881, 0x3840, 0x2800, 0xE8C1, 0xE981, 0x2940, 0xEB01, 0x2BC0, 0x2A80, 0xEA41,
+            0xEE01, 0x2EC0, 0x2F80, 0xEF41, 0x2D00, 0xEDC1, 0xEC81, 0x2C40, 0xE401, 0x24C0, 0x2580, 0xE541, 0x2700,
+            0xE7C1, 0xE681, 0x2640, 0x2200, 0xE2C1, 0xE381, 0x2340, 0xE101, 0x21C0, 0x2080, 0xE041, 0xA001, 0x60C0,
+            0x6180, 0xA141, 0x6300, 0xA3C1, 0xA281, 0x6240, 0x6600, 0xA6C1, 0xA781, 0x6740, 0xA501, 0x65C0, 0x6480,
+            0xA441, 0x6C00, 0xACC1, 0xAD81, 0x6D40, 0xAF01, 0x6FC0, 0x6E80, 0xAE41, 0xAA01, 0x6AC0, 0x6B80, 0xAB41,
+            0x6900, 0xA9C1, 0xA881, 0x6840, 0x7800, 0xB8C1, 0xB981, 0x7940, 0xBB01, 0x7BC0, 0x7A80, 0xBA41, 0xBE01,
+            0x7EC0, 0x7F80, 0xBF41, 0x7D00, 0xBDC1, 0xBC81, 0x7C40, 0xB401, 0x74C0, 0x7580, 0xB541, 0x7700, 0xB7C1,
+            0xB681, 0x7640, 0x7200, 0xB2C1, 0xB381, 0x7340, 0xB101, 0x71C0, 0x7080, 0xB041, 0x5000, 0x90C1, 0x9181,
+            0x5140, 0x9301, 0x53C0, 0x5280, 0x9241, 0x9601, 0x56C0, 0x5780, 0x9741, 0x5500, 0x95C1, 0x9481, 0x5440,
+            0x9C01, 0x5CC0, 0x5D80, 0x9D41, 0x5F00, 0x9FC1, 0x9E81, 0x5E40, 0x5A00, 0x9AC1, 0x9B81, 0x5B40, 0x9901,
+            0x59C0, 0x5880, 0x9841, 0x8801, 0x48C0, 0x4980, 0x8941, 0x4B00, 0x8BC1, 0x8A81, 0x4A40, 0x4E00, 0x8EC1,
+            0x8F81, 0x4F40, 0x8D01, 0x4DC0, 0x4C80, 0x8C41, 0x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680,
+            0x8641, 0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040
+        };
+
+        public CRC16IBMContext() : base(CRC16_IBM_POLY, CRC16_IBM_SEED, _ibmCrc16Table, false) { }
+
+        /// <summary>Gets the hash of a file</summary>
+        /// <param name="filename">File path.</param>
+        public static byte[] File(string filename)
+        {
+            File(filename, out byte[] hash);
+
+            return hash;
+        }
+
+        /// <summary>Gets the hash of a file in hexadecimal and as a byte array.</summary>
+        /// <param name="filename">File path.</param>
+        /// <param name="hash">Byte array of the hash value.</param>
+        public static string File(string filename, out byte[] hash) =>
+            File(filename, out hash, CRC16_IBM_POLY, CRC16_IBM_SEED, _ibmCrc16Table, false);
+
+        /// <summary>Gets the hash of the specified data buffer.</summary>
+        /// <param name="data">Data buffer.</param>
+        /// <param name="len">Length of the data buffer to hash.</param>
+        /// <param name="hash">Byte array of the hash value.</param>
+        public static string Data(byte[] data, uint len, out byte[] hash) =>
+            Data(data, len, out hash, CRC16_IBM_POLY, CRC16_IBM_SEED, _ibmCrc16Table, false);
+
+        /// <summary>Gets the hash of the specified data buffer.</summary>
+        /// <param name="data">Data buffer.</param>
+        /// <param name="hash">Byte array of the hash value.</param>
+        public static string Data(byte[] data, out byte[] hash) => Data(data, (uint)data.Length, out hash);
+
+        public static ushort Calculate(byte[] buffer) =>
+            Calculate(buffer, CRC16_IBM_POLY, CRC16_IBM_SEED, _ibmCrc16Table, false);
+    }
+}

DiscImageChef.Checksums/DiscImageChef.Checksums.csproj

@@ -46,6 +46,8 @@
     <Reference Include="System" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="CRC16CCITTContext.cs" />
+    <Compile Include="CRC16IBMContext.cs" />
     <Compile Include="Register.cs" />
     <Compile Include="SpamSumContext.cs" />
     <Compile Include="Adler32Context.cs" />

DiscImageChef.Core/Checksum.cs

@@ -42,63 +42,54 @@ namespace DiscImageChef.Core
     [Flags]
     public enum EnableChecksum
     {
-        Adler32 = 1,
+        Adler32 = 1, Crc16         = 2, Crc32         = 4,
-        Crc16   = 2,
+        Crc64   = 8, Md5           = 16, Sha1         = 64,
-        Crc32   = 4,
+        Sha256  = 128, Sha384      = 256, Sha512      = 512,
-        Crc64   = 8,
+        SpamSum = 1024, Fletcher16 = 2048, Fletcher32 = 4096,
-        Md5     = 16,
+        All = Adler32 | Crc16 | Crc32 | Crc64 | Md5 | Sha1 | Sha256 | Sha384 | Sha512 | SpamSum | Fletcher16 |
-        Sha1       = 64,
+              Fletcher32
-        Sha256     = 128,
-        Sha384     = 256,
-        Sha512     = 512,
-        SpamSum    = 1024,
-        Fletcher16 = 2048,
-        Fletcher32 = 4096,
-        All = Adler32 | Crc16 | Crc32 | Crc64 | Md5 | Sha1 | Sha256 | Sha384 | Sha512 | SpamSum | Fletcher16 | Fletcher32
     }
 
-    /// <summary>
+    /// <summary>Checksums and hashes data, with different algorithms multithreaded</summary>
-    ///     Checksums and hashes data, with different algorithms multithreaded
-    /// </summary>
     public class Checksum
     {
-        IChecksum      adler32Ctx;
+        readonly IChecksum      adler32Ctx;
         HashPacket              adlerPkt;
         Thread                  adlerThread;
-        IChecksum      crc16Ctx;
+        readonly IChecksum      crc16Ctx;
         HashPacket              crc16Pkt;
         Thread                  crc16Thread;
-        IChecksum      crc32Ctx;
+        readonly IChecksum      crc32Ctx;
         HashPacket              crc32Pkt;
         Thread                  crc32Thread;
-        IChecksum      crc64Ctx;
+        readonly IChecksum      crc64Ctx;
         HashPacket              crc64Pkt;
         Thread                  crc64Thread;
-        EnableChecksum enabled;
+        readonly EnableChecksum enabled;
-        IChecksum      f16Ctx;
+        readonly IChecksum      f16Ctx;
         HashPacket              f16Pkt;
         Thread                  f16Thread;
-        IChecksum      f32Ctx;
+        readonly IChecksum      f32Ctx;
         HashPacket              f32Pkt;
         Thread                  f32Thread;
-        IChecksum      md5Ctx;
+        readonly IChecksum      md5Ctx;
         HashPacket              md5Pkt;
         Thread                  md5Thread;
-        IChecksum      sha1Ctx;
+        readonly IChecksum      sha1Ctx;
         HashPacket              sha1Pkt;
         Thread                  sha1Thread;
-        IChecksum      sha256Ctx;
+        readonly IChecksum      sha256Ctx;
         HashPacket              sha256Pkt;
         Thread                  sha256Thread;
-        IChecksum      sha384Ctx;
+        readonly IChecksum      sha384Ctx;
         HashPacket              sha384Pkt;
         Thread                  sha384Thread;
-        IChecksum      sha512Ctx;
+        readonly IChecksum      sha512Ctx;
         HashPacket              sha512Pkt;
         Thread                  sha512Thread;
         HashPacket              spamsumPkt;
         Thread                  spamsumThread;
-        IChecksum      ssctx;
+        readonly IChecksum      ssctx;
 
         public Checksum(EnableChecksum enabled = EnableChecksum.All)
         {
@@ -107,73 +98,121 @@ namespace DiscImageChef.Core
             if(enabled.HasFlag(EnableChecksum.Adler32))
             {
                 adler32Ctx = new Adler32Context();
-                adlerPkt   = new HashPacket {Context = adler32Ctx};
+
+                adlerPkt = new HashPacket
+                {
+                    Context = adler32Ctx
+                };
             }
 
             if(enabled.HasFlag(EnableChecksum.Crc16))
             {
-                crc16Ctx = new Crc16Context();
+                crc16Ctx = new CRC16IBMContext();
-                crc16Pkt = new HashPacket {Context = crc16Ctx};
+
+                crc16Pkt = new HashPacket
+                {
+                    Context = crc16Ctx
+                };
             }
 
             if(enabled.HasFlag(EnableChecksum.Crc32))
             {
                 crc32Ctx = new Crc32Context();
-                crc32Pkt = new HashPacket {Context = crc32Ctx};
+
+                crc32Pkt = new HashPacket
+                {
+                    Context = crc32Ctx
+                };
             }
 
             if(enabled.HasFlag(EnableChecksum.Crc64))
             {
                 crc64Ctx = new Crc64Context();
-                crc64Pkt = new HashPacket {Context = crc64Ctx};
+
+                crc64Pkt = new HashPacket
+                {
+                    Context = crc64Ctx
+                };
             }
 
             if(enabled.HasFlag(EnableChecksum.Md5))
             {
                 md5Ctx = new Md5Context();
-                md5Pkt = new HashPacket {Context = md5Ctx};
+
+                md5Pkt = new HashPacket
+                {
+                    Context = md5Ctx
+                };
             }
 
             if(enabled.HasFlag(EnableChecksum.Sha1))
             {
                 sha1Ctx = new Sha1Context();
-                sha1Pkt = new HashPacket {Context = sha1Ctx};
+
+                sha1Pkt = new HashPacket
+                {
+                    Context = sha1Ctx
+                };
             }
 
             if(enabled.HasFlag(EnableChecksum.Sha256))
             {
                 sha256Ctx = new Sha256Context();
-                sha256Pkt = new HashPacket {Context = sha256Ctx};
+
+                sha256Pkt = new HashPacket
+                {
+                    Context = sha256Ctx
+                };
             }
 
             if(enabled.HasFlag(EnableChecksum.Sha384))
             {
                 sha384Ctx = new Sha384Context();
-                sha384Pkt = new HashPacket {Context = sha384Ctx};
+
+                sha384Pkt = new HashPacket
+                {
+                    Context = sha384Ctx
+                };
             }
 
             if(enabled.HasFlag(EnableChecksum.Sha512))
             {
                 sha512Ctx = new Sha512Context();
-                sha512Pkt = new HashPacket {Context = sha512Ctx};
+
+                sha512Pkt = new HashPacket
+                {
+                    Context = sha512Ctx
+                };
             }
 
             if(enabled.HasFlag(EnableChecksum.SpamSum))
             {
                 ssctx = new SpamSumContext();
-                spamsumPkt = new HashPacket {Context = ssctx};
+
+                spamsumPkt = new HashPacket
+                {
+                    Context = ssctx
+                };
             }
 
             if(enabled.HasFlag(EnableChecksum.Fletcher16))
             {
                 f16Ctx = new Fletcher16Context();
-                f16Pkt = new HashPacket {Context = f16Ctx};
+
+                f16Pkt = new HashPacket
+                {
+                    Context = f16Ctx
+                };
             }
 
             if(enabled.HasFlag(EnableChecksum.Fletcher32))
             {
                 f32Ctx = new Fletcher32Context();
-                f32Pkt = new HashPacket {Context = f32Ctx};
+
+                f32Pkt = new HashPacket
+                {
+                    Context = f32Ctx
+                };
             }
 
             adlerThread   = new Thread(UpdateHash);
@@ -264,23 +303,54 @@ namespace DiscImageChef.Core
                 f32Thread.Start(f32Pkt);
             }
 
-            while(adlerThread.IsAlive || crc16Thread.IsAlive || crc32Thread.IsAlive || crc64Thread.IsAlive ||
+            while(adlerThread.IsAlive   ||
+                  crc16Thread.IsAlive   ||
+                  crc32Thread.IsAlive   ||
+                  crc64Thread.IsAlive   ||
                   md5Thread.IsAlive     ||
-                  sha1Thread.IsAlive    || sha256Thread.IsAlive || sha384Thread.IsAlive || sha512Thread.IsAlive ||
+                  sha1Thread.IsAlive    ||
-                  spamsumThread.IsAlive || f16Thread.IsAlive    || f32Thread.IsAlive) { }
+                  sha256Thread.IsAlive  ||
+                  sha384Thread.IsAlive  ||
+                  sha512Thread.IsAlive  ||
+                  spamsumThread.IsAlive ||
+                  f16Thread.IsAlive     ||
+                  f32Thread.IsAlive) { }
 
-            if(enabled.HasFlag(EnableChecksum.SpamSum)) adlerThread = new Thread(UpdateHash);
+            if(enabled.HasFlag(EnableChecksum.SpamSum))
-            if(enabled.HasFlag(EnableChecksum.SpamSum)) crc16Thread = new Thread(UpdateHash);
+                adlerThread = new Thread(UpdateHash);
-            if(enabled.HasFlag(EnableChecksum.SpamSum)) crc32Thread = new Thread(UpdateHash);
+
-            if(enabled.HasFlag(EnableChecksum.SpamSum)) crc64Thread = new Thread(UpdateHash);
+            if(enabled.HasFlag(EnableChecksum.SpamSum))
-            if(enabled.HasFlag(EnableChecksum.SpamSum)) md5Thread   = new Thread(UpdateHash);
+                crc16Thread = new Thread(UpdateHash);
-            if(enabled.HasFlag(EnableChecksum.SpamSum)) sha1Thread    = new Thread(UpdateHash);
+
-            if(enabled.HasFlag(EnableChecksum.SpamSum)) sha256Thread  = new Thread(UpdateHash);
+            if(enabled.HasFlag(EnableChecksum.SpamSum))
-            if(enabled.HasFlag(EnableChecksum.SpamSum)) sha384Thread  = new Thread(UpdateHash);
+                crc32Thread = new Thread(UpdateHash);
-            if(enabled.HasFlag(EnableChecksum.SpamSum)) sha512Thread  = new Thread(UpdateHash);
+
-            if(enabled.HasFlag(EnableChecksum.SpamSum)) spamsumThread = new Thread(UpdateHash);
+            if(enabled.HasFlag(EnableChecksum.SpamSum))
-            if(enabled.HasFlag(EnableChecksum.SpamSum)) f16Thread     = new Thread(UpdateHash);
+                crc64Thread = new Thread(UpdateHash);
-            if(enabled.HasFlag(EnableChecksum.SpamSum)) f32Thread     = new Thread(UpdateHash);
+
+            if(enabled.HasFlag(EnableChecksum.SpamSum))
+                md5Thread = new Thread(UpdateHash);
+
+            if(enabled.HasFlag(EnableChecksum.SpamSum))
+                sha1Thread = new Thread(UpdateHash);
+
+            if(enabled.HasFlag(EnableChecksum.SpamSum))
+                sha256Thread = new Thread(UpdateHash);
+
+            if(enabled.HasFlag(EnableChecksum.SpamSum))
+                sha384Thread = new Thread(UpdateHash);
+
+            if(enabled.HasFlag(EnableChecksum.SpamSum))
+                sha512Thread = new Thread(UpdateHash);
+
+            if(enabled.HasFlag(EnableChecksum.SpamSum))
+                spamsumThread = new Thread(UpdateHash);
+
+            if(enabled.HasFlag(EnableChecksum.SpamSum))
+                f16Thread = new Thread(UpdateHash);
+
+            if(enabled.HasFlag(EnableChecksum.SpamSum))
+                f32Thread = new Thread(UpdateHash);
         }
 
         public List<ChecksumType> End()
@@ -291,73 +361,122 @@ namespace DiscImageChef.Core
 
             if(enabled.HasFlag(EnableChecksum.All))
             {
-                chk = new ChecksumType {type = ChecksumTypeType.adler32, Value = adler32Ctx.End()};
+                chk = new ChecksumType
+                {
+                    type = ChecksumTypeType.adler32, Value = adler32Ctx.End()
+                };
+
                 chks.Add(chk);
             }
 
             if(enabled.HasFlag(EnableChecksum.Crc16))
             {
-                chk = new ChecksumType {type = ChecksumTypeType.crc16, Value = crc16Ctx.End()};
+                chk = new ChecksumType
+                {
+                    type = ChecksumTypeType.crc16, Value = crc16Ctx.End()
+                };
+
                 chks.Add(chk);
             }
 
             if(enabled.HasFlag(EnableChecksum.Crc32))
             {
-                chk = new ChecksumType {type = ChecksumTypeType.crc32, Value = crc32Ctx.End()};
+                chk = new ChecksumType
+                {
+                    type = ChecksumTypeType.crc32, Value = crc32Ctx.End()
+                };
+
                 chks.Add(chk);
             }
 
             if(enabled.HasFlag(EnableChecksum.Crc64))
             {
-                chk = new ChecksumType {type = ChecksumTypeType.crc64, Value = crc64Ctx.End()};
+                chk = new ChecksumType
+                {
+                    type = ChecksumTypeType.crc64, Value = crc64Ctx.End()
+                };
+
                 chks.Add(chk);
             }
 
             if(enabled.HasFlag(EnableChecksum.Md5))
             {
-                chk = new ChecksumType {type = ChecksumTypeType.md5, Value = md5Ctx.End()};
+                chk = new ChecksumType
+                {
+                    type = ChecksumTypeType.md5, Value = md5Ctx.End()
+                };
+
                 chks.Add(chk);
             }
 
             if(enabled.HasFlag(EnableChecksum.Sha1))
             {
-                chk = new ChecksumType {type = ChecksumTypeType.sha1, Value = sha1Ctx.End()};
+                chk = new ChecksumType
+                {
+                    type = ChecksumTypeType.sha1, Value = sha1Ctx.End()
+                };
+
                 chks.Add(chk);
             }
 
             if(enabled.HasFlag(EnableChecksum.Sha256))
             {
-                chk = new ChecksumType {type = ChecksumTypeType.sha256, Value = sha256Ctx.End()};
+                chk = new ChecksumType
+                {
+                    type = ChecksumTypeType.sha256, Value = sha256Ctx.End()
+                };
+
                 chks.Add(chk);
             }
 
             if(enabled.HasFlag(EnableChecksum.Sha384))
             {
-                chk = new ChecksumType {type = ChecksumTypeType.sha384, Value = sha384Ctx.End()};
+                chk = new ChecksumType
+                {
+                    type = ChecksumTypeType.sha384, Value = sha384Ctx.End()
+                };
+
                 chks.Add(chk);
             }
 
             if(enabled.HasFlag(EnableChecksum.Sha512))
             {
-                chk = new ChecksumType {type = ChecksumTypeType.sha512, Value = sha512Ctx.End()};
+                chk = new ChecksumType
+                {
+                    type = ChecksumTypeType.sha512, Value = sha512Ctx.End()
+                };
+
                 chks.Add(chk);
             }
 
             if(enabled.HasFlag(EnableChecksum.SpamSum))
             {
-                chk = new ChecksumType {type = ChecksumTypeType.spamsum, Value = ssctx.End()};
+                chk = new ChecksumType
+                {
+                    type = ChecksumTypeType.spamsum, Value = ssctx.End()
+                };
+
                 chks.Add(chk);
             }
 
             if(enabled.HasFlag(EnableChecksum.Fletcher16))
             {
-                chk = new ChecksumType {type = ChecksumTypeType.fletcher16, Value = f16Ctx.End()};
+                chk = new ChecksumType
+                {
+                    type = ChecksumTypeType.fletcher16, Value = f16Ctx.End()
+                };
+
                 chks.Add(chk);
             }
 
-            if(!enabled.HasFlag(EnableChecksum.Fletcher32)) return chks;
+            if(!enabled.HasFlag(EnableChecksum.Fletcher32))
+                return chks;
+
+            chk = new ChecksumType
+            {
+                type = ChecksumTypeType.fletcher32, Value = f32Ctx.End()
+            };
 
-            chk = new ChecksumType {type = ChecksumTypeType.fletcher32, Value = f32Ctx.End()};
             chks.Add(chk);
 
             return chks;
@@ -378,107 +497,174 @@ namespace DiscImageChef.Core
             IChecksum f16CtxData     = null;
             IChecksum f32CtxData     = null;
 
-            Thread adlerThreadData = new Thread(UpdateHash);
+            var adlerThreadData   = new Thread(UpdateHash);
-            Thread crc16ThreadData = new Thread(UpdateHash);
+            var crc16ThreadData   = new Thread(UpdateHash);
-            Thread crc32ThreadData = new Thread(UpdateHash);
+            var crc32ThreadData   = new Thread(UpdateHash);
-            Thread crc64ThreadData = new Thread(UpdateHash);
+            var crc64ThreadData   = new Thread(UpdateHash);
-            Thread md5ThreadData   = new Thread(UpdateHash);
+            var md5ThreadData     = new Thread(UpdateHash);
-            Thread sha1ThreadData    = new Thread(UpdateHash);
+            var sha1ThreadData    = new Thread(UpdateHash);
-            Thread sha256ThreadData  = new Thread(UpdateHash);
+            var sha256ThreadData  = new Thread(UpdateHash);
-            Thread sha384ThreadData  = new Thread(UpdateHash);
+            var sha384ThreadData  = new Thread(UpdateHash);
-            Thread sha512ThreadData  = new Thread(UpdateHash);
+            var sha512ThreadData  = new Thread(UpdateHash);
-            Thread spamsumThreadData = new Thread(UpdateHash);
+            var spamsumThreadData = new Thread(UpdateHash);
-            Thread f16ThreadData     = new Thread(UpdateHash);
+            var f16ThreadData     = new Thread(UpdateHash);
-            Thread f32ThreadData     = new Thread(UpdateHash);
+            var f32ThreadData     = new Thread(UpdateHash);
 
             if(enabled.HasFlag(EnableChecksum.Adler32))
             {
                 adler32CtxData = new Adler32Context();
-                HashPacket adlerPktData = new HashPacket {Context = adler32CtxData, Data = data};
+
+                var adlerPktData = new HashPacket
+                {
+                    Context = adler32CtxData, Data = data
+                };
+
                 adlerThreadData.Start(adlerPktData);
             }
 
             if(enabled.HasFlag(EnableChecksum.Crc16))
             {
-                crc16CtxData = new Crc16Context();
+                crc16CtxData = new CRC16IBMContext();
-                HashPacket crc16PktData = new HashPacket {Context = crc16CtxData, Data = data};
+
+                var crc16PktData = new HashPacket
+                {
+                    Context = crc16CtxData, Data = data
+                };
+
                 crc16ThreadData.Start(crc16PktData);
             }
 
             if(enabled.HasFlag(EnableChecksum.Crc32))
             {
                 crc32CtxData = new Crc32Context();
-                HashPacket crc32PktData = new HashPacket {Context = crc32CtxData, Data = data};
+
+                var crc32PktData = new HashPacket
+                {
+                    Context = crc32CtxData, Data = data
+                };
+
                 crc32ThreadData.Start(crc32PktData);
             }
 
             if(enabled.HasFlag(EnableChecksum.Crc64))
             {
                 crc64CtxData = new Crc64Context();
-                HashPacket crc64PktData = new HashPacket {Context = crc64CtxData, Data = data};
+
+                var crc64PktData = new HashPacket
+                {
+                    Context = crc64CtxData, Data = data
+                };
+
                 crc64ThreadData.Start(crc64PktData);
             }
 
             if(enabled.HasFlag(EnableChecksum.Md5))
             {
                 md5CtxData = new Md5Context();
-                HashPacket md5PktData = new HashPacket {Context = md5CtxData, Data = data};
+
+                var md5PktData = new HashPacket
+                {
+                    Context = md5CtxData, Data = data
+                };
+
                 md5ThreadData.Start(md5PktData);
             }
 
             if(enabled.HasFlag(EnableChecksum.Sha1))
             {
                 sha1CtxData = new Sha1Context();
-                HashPacket sha1PktData = new HashPacket {Context = sha1CtxData, Data = data};
+
+                var sha1PktData = new HashPacket
+                {
+                    Context = sha1CtxData, Data = data
+                };
+
                 sha1ThreadData.Start(sha1PktData);
             }
 
             if(enabled.HasFlag(EnableChecksum.Sha256))
             {
                 sha256CtxData = new Sha256Context();
-                HashPacket sha256PktData = new HashPacket {Context = sha256CtxData, Data = data};
+
+                var sha256PktData = new HashPacket
+                {
+                    Context = sha256CtxData, Data = data
+                };
+
                 sha256ThreadData.Start(sha256PktData);
             }
 
             if(enabled.HasFlag(EnableChecksum.Sha384))
             {
                 sha384CtxData = new Sha384Context();
-                HashPacket sha384PktData = new HashPacket {Context = sha384CtxData, Data = data};
+
+                var sha384PktData = new HashPacket
+                {
+                    Context = sha384CtxData, Data = data
+                };
+
                 sha384ThreadData.Start(sha384PktData);
             }
 
             if(enabled.HasFlag(EnableChecksum.Sha512))
             {
                 sha512CtxData = new Sha512Context();
-                HashPacket sha512PktData = new HashPacket {Context = sha512CtxData, Data = data};
+
+                var sha512PktData = new HashPacket
+                {
+                    Context = sha512CtxData, Data = data
+                };
+
                 sha512ThreadData.Start(sha512PktData);
             }
 
             if(enabled.HasFlag(EnableChecksum.SpamSum))
             {
                 ssctxData = new SpamSumContext();
-                HashPacket spamsumPktData = new HashPacket {Context = ssctxData, Data = data};
+
+                var spamsumPktData = new HashPacket
+                {
+                    Context = ssctxData, Data = data
+                };
+
                 spamsumThreadData.Start(spamsumPktData);
             }
 
             if(enabled.HasFlag(EnableChecksum.Fletcher16))
             {
                 f16CtxData = new Fletcher16Context();
-                HashPacket f16PktData = new HashPacket {Context = f16CtxData, Data = data};
+
+                var f16PktData = new HashPacket
+                {
+                    Context = f16CtxData, Data = data
+                };
+
                 f16ThreadData.Start(f16PktData);
             }
 
             if(enabled.HasFlag(EnableChecksum.Fletcher32))
             {
                 f32CtxData = new Fletcher32Context();
-                HashPacket f32PktData = new HashPacket {Context = f32CtxData, Data = data};
+
+                var f32PktData = new HashPacket
+                {
+                    Context = f32CtxData, Data = data
+                };
+
                 f32ThreadData.Start(f32PktData);
             }
 
-            while(adlerThreadData.IsAlive || crc16ThreadData.IsAlive || crc32ThreadData.IsAlive ||
+            while(adlerThreadData.IsAlive   ||
-                  crc64ThreadData.IsAlive || md5ThreadData.IsAlive   ||
+                  crc16ThreadData.IsAlive   ||
-                  sha1ThreadData.IsAlive   || sha256ThreadData.IsAlive  || sha384ThreadData.IsAlive ||
+                  crc32ThreadData.IsAlive   ||
-                  sha512ThreadData.IsAlive || spamsumThreadData.IsAlive || f16ThreadData.IsAlive    ||
+                  crc64ThreadData.IsAlive   ||
+                  md5ThreadData.IsAlive     ||
+                  sha1ThreadData.IsAlive    ||
+                  sha256ThreadData.IsAlive  ||
+                  sha384ThreadData.IsAlive  ||
+                  sha512ThreadData.IsAlive  ||
+                  spamsumThreadData.IsAlive ||
+                  f16ThreadData.IsAlive     ||
                   f32ThreadData.IsAlive) { }
 
             List<ChecksumType> dataChecksums = new List<ChecksumType>();
@@ -486,73 +672,121 @@ namespace DiscImageChef.Core
 
             if(enabled.HasFlag(EnableChecksum.Adler32))
             {
-                chk = new ChecksumType {type = ChecksumTypeType.adler32, Value = adler32CtxData.End()};
+                chk = new ChecksumType
+                {
+                    type = ChecksumTypeType.adler32, Value = adler32CtxData.End()
+                };
+
                 dataChecksums.Add(chk);
             }
 
             if(enabled.HasFlag(EnableChecksum.Crc16))
             {
-                chk = new ChecksumType {type = ChecksumTypeType.crc16, Value = crc16CtxData.End()};
+                chk = new ChecksumType
+                {
+                    type = ChecksumTypeType.crc16, Value = crc16CtxData.End()
+                };
+
                 dataChecksums.Add(chk);
             }
 
             if(enabled.HasFlag(EnableChecksum.Crc32))
             {
-                chk = new ChecksumType {type = ChecksumTypeType.crc32, Value = crc32CtxData.End()};
+                chk = new ChecksumType
+                {
+                    type = ChecksumTypeType.crc32, Value = crc32CtxData.End()
+                };
+
                 dataChecksums.Add(chk);
             }
 
             if(enabled.HasFlag(EnableChecksum.Crc64))
             {
-                chk = new ChecksumType {type = ChecksumTypeType.crc64, Value = crc64CtxData.End()};
+                chk = new ChecksumType
+                {
+                    type = ChecksumTypeType.crc64, Value = crc64CtxData.End()
+                };
+
                 dataChecksums.Add(chk);
             }
 
             if(enabled.HasFlag(EnableChecksum.Md5))
             {
-                chk = new ChecksumType {type = ChecksumTypeType.md5, Value = md5CtxData.End()};
+                chk = new ChecksumType
+                {
+                    type = ChecksumTypeType.md5, Value = md5CtxData.End()
+                };
+
                 dataChecksums.Add(chk);
             }
 
             if(enabled.HasFlag(EnableChecksum.Sha1))
             {
-                chk = new ChecksumType {type = ChecksumTypeType.sha1, Value = sha1CtxData.End()};
+                chk = new ChecksumType
+                {
+                    type = ChecksumTypeType.sha1, Value = sha1CtxData.End()
+                };
+
                 dataChecksums.Add(chk);
             }
 
             if(enabled.HasFlag(EnableChecksum.Sha256))
             {
-                chk = new ChecksumType {type = ChecksumTypeType.sha256, Value = sha256CtxData.End()};
+                chk = new ChecksumType
+                {
+                    type = ChecksumTypeType.sha256, Value = sha256CtxData.End()
+                };
+
                 dataChecksums.Add(chk);
             }
 
             if(enabled.HasFlag(EnableChecksum.Sha384))
             {
-                chk = new ChecksumType {type = ChecksumTypeType.sha384, Value = sha384CtxData.End()};
+                chk = new ChecksumType
+                {
+                    type = ChecksumTypeType.sha384, Value = sha384CtxData.End()
+                };
+
                 dataChecksums.Add(chk);
             }
 
             if(enabled.HasFlag(EnableChecksum.Sha512))
             {
-                chk = new ChecksumType {type = ChecksumTypeType.sha512, Value = sha512CtxData.End()};
+                chk = new ChecksumType
+                {
+                    type = ChecksumTypeType.sha512, Value = sha512CtxData.End()
+                };
+
                 dataChecksums.Add(chk);
             }
 
             if(enabled.HasFlag(EnableChecksum.SpamSum))
             {
-                chk = new ChecksumType {type = ChecksumTypeType.spamsum, Value = ssctxData.End()};
+                chk = new ChecksumType
+                {
+                    type = ChecksumTypeType.spamsum, Value = ssctxData.End()
+                };
+
                 dataChecksums.Add(chk);
             }
 
             if(enabled.HasFlag(EnableChecksum.Fletcher16))
             {
-                chk = new ChecksumType {type = ChecksumTypeType.fletcher16, Value = f16CtxData.End()};
+                chk = new ChecksumType
+                {
+                    type = ChecksumTypeType.fletcher16, Value = f16CtxData.End()
+                };
+
                 dataChecksums.Add(chk);
             }
 
             if(enabled.HasFlag(EnableChecksum.Fletcher32))
             {
-                chk = new ChecksumType {type = ChecksumTypeType.fletcher32, Value = f32CtxData.End()};
+                chk = new ChecksumType
+                {
+                    type = ChecksumTypeType.fletcher32, Value = f32CtxData.End()
+                };
+
                 dataChecksums.Add(chk);
             }
 
@@ -566,10 +800,7 @@ namespace DiscImageChef.Core
             public byte[]    Data;
         }
 
-        static void UpdateHash(object packet)
+        static void UpdateHash(object packet) => ((HashPacket)packet).Context.Update(((HashPacket)packet).Data);
-        {
-            ((HashPacket)packet).Context.Update(((HashPacket)packet).Data);
-        }
         #endregion Threading helpers
     }
 }

DiscImageChef.DiscImages/CPCDSK/Read.cs

@@ -52,32 +52,41 @@ namespace DiscImageChef.DiscImages
             Stream stream = imageFilter.GetDataForkStream();
             stream.Seek(0, SeekOrigin.Begin);
 
-            if(stream.Length < 512) return false;
+            if(stream.Length < 512)
+                return false;
 
             byte[] headerB = new byte[256];
             stream.Read(headerB, 0, 256);
             CpcDiskInfo header = Marshal.ByteArrayToStructureLittleEndian<CpcDiskInfo>(headerB);
 
-            if(!cpcdskId.SequenceEqual(header.magic) && !edskId.SequenceEqual(header.magic) &&
+            if(!cpcdskId.SequenceEqual(header.magic) &&
-               !du54Id.SequenceEqual(header.magic)) return false;
+               !edskId.SequenceEqual(header.magic)   &&
+               !du54Id.SequenceEqual(header.magic))
+                return false;
 
             extended = edskId.SequenceEqual(header.magic);
             DicConsole.DebugWriteLine("CPCDSK plugin", "Extended = {0}", extended);
+
             DicConsole.DebugWriteLine("CPCDSK plugin", "header.magic = \"{0}\"",
                                       StringHandlers.CToString(header.magic));
+
             DicConsole.DebugWriteLine("CPCDSK plugin", "header.magic2 = \"{0}\"",
                                       StringHandlers.CToString(header.magic2));
+
             DicConsole.DebugWriteLine("CPCDSK plugin", "header.creator = \"{0}\"",
                                       StringHandlers.CToString(header.creator));
+
             DicConsole.DebugWriteLine("CPCDSK plugin", "header.tracks = {0}", header.tracks);
             DicConsole.DebugWriteLine("CPCDSK plugin", "header.sides = {0}", header.sides);
-            if(!extended) DicConsole.DebugWriteLine("CPCDSK plugin", "header.tracksize = {0}", header.tracksize);
+
+            if(!extended)
+                DicConsole.DebugWriteLine("CPCDSK plugin", "header.tracksize = {0}", header.tracksize);
             else
                 for(int i = 0; i < header.tracks; i++)
                 {
                     for(int j = 0; j < header.sides; j++)
                         DicConsole.DebugWriteLine("CPCDSK plugin", "Track {0} Side {1} size = {2}", i, j,
-                                                  header.tracksizeTable[i * header.sides + j] * 256);
+                                                  header.tracksizeTable[(i * header.sides) + j] * 256);
                 }
 
             ulong currentSector = 0;
@@ -89,12 +98,14 @@ namespace DiscImageChef.DiscImages
 
             // Seek to first track descriptor
             stream.Seek(256, SeekOrigin.Begin);
+
             for(int i = 0; i < header.tracks; i++)
             {
                 for(int j = 0; j < header.sides; j++)
                 {
                     // Track not stored in image
-                    if(extended && header.tracksizeTable[i * header.sides + j] == 0) continue;
+                    if(extended && header.tracksizeTable[(i * header.sides) + j] == 0)
+                        continue;
 
                     long trackPos = stream.Position;
 
@@ -105,25 +116,34 @@ namespace DiscImageChef.DiscImages
                     if(!trackId.SequenceEqual(trackInfo.magic))
                     {
                         DicConsole.ErrorWriteLine("Not the expected track info.");
+
                         return false;
                     }
 
                     DicConsole.DebugWriteLine("CPCDSK plugin", "trackInfo[{1}:{2}].magic = \"{0}\"",
                                               StringHandlers.CToString(trackInfo.magic), i, j);
+
                     DicConsole.DebugWriteLine("CPCDSK plugin", "trackInfo[{1}:{2}].bps = {0}",
                                               SizeCodeToBytes(trackInfo.bps), i, j);
+
                     DicConsole.DebugWriteLine("CPCDSK plugin", "trackInfo[{1}:{2}].dataRate = {0}", trackInfo.dataRate,
                                               i, j);
+
                     DicConsole.DebugWriteLine("CPCDSK plugin", "trackInfo[{1}:{2}].filler = 0x{0:X2}", trackInfo.filler,
                                               i, j);
+
                     DicConsole.DebugWriteLine("CPCDSK plugin", "trackInfo[{1}:{2}].gap3 = 0x{0:X2}", trackInfo.gap3, i,
                                               j);
+
                     DicConsole.DebugWriteLine("CPCDSK plugin", "trackInfo[{1}:{2}].padding = {0}", trackInfo.padding, i,
                                               j);
+
                     DicConsole.DebugWriteLine("CPCDSK plugin", "trackInfo[{1}:{2}].recordingMode = {0}",
                                               trackInfo.recordingMode, i, j);
+
                     DicConsole.DebugWriteLine("CPCDSK plugin", "trackInfo[{1}:{2}].sectors = {0}", trackInfo.sectors, i,
                                               j);
+
                     DicConsole.DebugWriteLine("CPCDSK plugin", "trackInfo[{1}:{2}].side = {0}", trackInfo.side, i, j);
                     DicConsole.DebugWriteLine("CPCDSK plugin", "trackInfo[{1}:{2}].track = {0}", trackInfo.track, i, j);
 
@@ -140,21 +160,26 @@ namespace DiscImageChef.DiscImages
                     {
                         DicConsole.DebugWriteLine("CPCDSK plugin", "trackInfo[{1}:{2}].sector[{3}].id = 0x{0:X2}",
                                                   trackInfo.sectorsInfo[k - 1].id, i, j, k);
+
                         DicConsole.DebugWriteLine("CPCDSK plugin", "trackInfo[{1}:{2}].sector[{3}].len = {0}",
                                                   trackInfo.sectorsInfo[k - 1].len, i, j, k);
+
                         DicConsole.DebugWriteLine("CPCDSK plugin", "trackInfo[{1}:{2}].sector[{3}].side = {0}",
                                                   trackInfo.sectorsInfo[k - 1].side, i, j, k);
+
                         DicConsole.DebugWriteLine("CPCDSK plugin", "trackInfo[{1}:{2}].sector[{3}].size = {0}",
                                                   SizeCodeToBytes(trackInfo.sectorsInfo[k - 1].size), i, j, k);
+
                         DicConsole.DebugWriteLine("CPCDSK plugin", "trackInfo[{1}:{2}].sector[{3}].st1 = 0x{0:X2}",
                                                   trackInfo.sectorsInfo[k - 1].st1, i, j, k);
+
                         DicConsole.DebugWriteLine("CPCDSK plugin", "trackInfo[{1}:{2}].sector[{3}].st2 = 0x{0:X2}",
                                                   trackInfo.sectorsInfo[k - 1].st2, i, j, k);
+
                         DicConsole.DebugWriteLine("CPCDSK plugin", "trackInfo[{1}:{2}].sector[{3}].track = {0}",
                                                   trackInfo.sectorsInfo[k - 1].track, i, j, k);
 
-                        int sectLen = extended
+                        int sectLen = extended ? trackInfo.sectorsInfo[k - 1].len
-                                          ? trackInfo.sectorsInfo[k - 1].len
                                           : SizeCodeToBytes(trackInfo.sectorsInfo[k - 1].size);
 
                         byte[] sector = new byte[sectLen];
@@ -185,7 +210,7 @@ namespace DiscImageChef.DiscImages
                         amForCrc[6] = trackInfo.sectorsInfo[k - 1].id;
                         amForCrc[7] = (byte)trackInfo.sectorsInfo[k - 1].size;
 
-                        Crc16Context.Data(amForCrc, 8, out byte[] amCrc);
+                        CRC16IBMContext.Data(amForCrc, 8, out byte[] amCrc);
 
                         byte[] addressMark = new byte[22];
                         Array.Copy(amForCrc, 0, addressMark, 12, 8);
@@ -199,15 +224,17 @@ namespace DiscImageChef.DiscImages
                         sectors.Add(currentSector, thisTrackSectors[s]);
                         addressMarks.Add(currentSector, thisTrackAddressMarks[s]);
                         currentSector++;
+
                         if(thisTrackSectors[s].Length > imageInfo.SectorSize)
                             imageInfo.SectorSize = (uint)thisTrackSectors[s].Length;
                     }
 
                     stream.Seek(trackPos, SeekOrigin.Begin);
+
                     if(extended)
                     {
-                        stream.Seek(header.tracksizeTable[i * header.sides + j] * 256, SeekOrigin.Current);
+                        stream.Seek(header.tracksizeTable[(i * header.sides) + j] * 256, SeekOrigin.Current);
-                        imageInfo.ImageSize += (ulong)(header.tracksizeTable[i * header.sides + j] * 256) - 256;
+                        imageInfo.ImageSize += (ulong)(header.tracksizeTable[(i * header.sides) + j] * 256) - 256;
                     }
                     else
                     {
@@ -253,7 +280,8 @@ namespace DiscImageChef.DiscImages
 
         public byte[] ReadSector(ulong sectorAddress)
         {
-            if(sectors.TryGetValue(sectorAddress, out byte[] sector)) return sector;
+            if(sectors.TryGetValue(sectorAddress, out byte[] sector))
+                return sector;
 
             throw new ArgumentOutOfRangeException(nameof(sectorAddress), $"Sector address {sectorAddress} not found");
         }
@@ -267,7 +295,7 @@ namespace DiscImageChef.DiscImages
             if(sectorAddress + length > imageInfo.Sectors)
                 throw new ArgumentOutOfRangeException(nameof(length), "Requested more sectors than available");
 
-            MemoryStream ms = new MemoryStream();
+            var ms = new MemoryStream();
 
             for(uint i = 0; i < length; i++)
             {
@@ -283,7 +311,8 @@ namespace DiscImageChef.DiscImages
             if(tag != SectorTagType.FloppyAddressMark)
                 throw new FeatureUnsupportedImageException($"Tag {tag} not supported by image format");
 
-            if(addressMarks.TryGetValue(sectorAddress, out byte[] addressMark)) return addressMark;
+            if(addressMarks.TryGetValue(sectorAddress, out byte[] addressMark))
+                return addressMark;
 
             throw new ArgumentOutOfRangeException(nameof(sectorAddress), "Sector address not found");
         }
@@ -300,7 +329,7 @@ namespace DiscImageChef.DiscImages
             if(sectorAddress + length > imageInfo.Sectors)
                 throw new ArgumentOutOfRangeException(nameof(length), "Requested more sectors than available");
 
-            MemoryStream ms = new MemoryStream();
+            var ms = new MemoryStream();
 
             for(uint i = 0; i < length; i++)
             {

DiscImageChef.DiscImages/WCDiskImage/Read.cs

@@ -55,6 +55,7 @@ namespace DiscImageChef.DiscImages
             stream.Read(header, 0, 32);
 
             WCDiskImageFileHeader fheader = Marshal.ByteArrayToStructureLittleEndian<WCDiskImageFileHeader>(header);
+
             DicConsole.DebugWriteLine("d2f plugin",
                                       "Detected WC DISK IMAGE with {0} heads, {1} tracks and {2} sectors per track.",
                                       fheader.heads, fheader.cylinders, fheader.sectorsPerTrack);
@@ -71,6 +72,7 @@ namespace DiscImageChef.DiscImages
             imageInfo.CreationTime         = imageFilter.GetCreationTime();
             imageInfo.LastModificationTime = imageFilter.GetLastWriteTime();
             imageInfo.MediaTitle           = Path.GetFileNameWithoutExtension(imageFilter.GetFilename());
+
             imageInfo.MediaType = Geometry.GetMediaType(((ushort)imageInfo.Cylinders, (byte)imageInfo.Heads,
                                                          (ushort)imageInfo.SectorsPerTrack, 512, MediaEncoding.MFM,
                                                          false));
@@ -78,7 +80,8 @@ namespace DiscImageChef.DiscImages
             /* buffer the entire disk in memory */
             for(int cyl = 0; cyl < imageInfo.Cylinders; cyl++)
             {
-                for(int head = 0; head < imageInfo.Heads; head++) ReadTrack(stream, cyl, head);
+                for(int head = 0; head < imageInfo.Heads; head++)
+                    ReadTrack(stream, cyl, head);
             }
 
             /* if there are extra tracks, read them as well */
@@ -107,8 +110,13 @@ namespace DiscImageChef.DiscImages
             }
 
             /* adjust number of cylinders */
-            if(fheader.extraTracks[0] == 1 || fheader.extraTracks[1] == 1) imageInfo.Cylinders++;
+            if(fheader.extraTracks[0] == 1 ||
-            if(fheader.extraTracks[2] == 1 || fheader.extraTracks[3] == 1) imageInfo.Cylinders++;
+               fheader.extraTracks[1] == 1)
+                imageInfo.Cylinders++;
+
+            if(fheader.extraTracks[2] == 1 ||
+               fheader.extraTracks[3] == 1)
+                imageInfo.Cylinders++;
 
             /* read the comment and directory data if present */
             if(fheader.extraFlags.HasFlag(ExtraFlag.Comment))
@@ -116,6 +124,7 @@ namespace DiscImageChef.DiscImages
                 DicConsole.DebugWriteLine("d2f plugin", "Comment present, reading");
                 byte[] sheaderBuffer = new byte[6];
                 stream.Read(sheaderBuffer, 0, 6);
+
                 WCDiskImageSectorHeader sheader =
                     Marshal.ByteArrayToStructureLittleEndian<WCDiskImageSectorHeader>(sheaderBuffer);
 
@@ -133,6 +142,7 @@ namespace DiscImageChef.DiscImages
                 DicConsole.DebugWriteLine("d2f plugin", "Directory listing present, reading");
                 byte[] sheaderBuffer = new byte[6];
                 stream.Read(sheaderBuffer, 0, 6);
+
                 WCDiskImageSectorHeader sheader =
                     Marshal.ByteArrayToStructureLittleEndian<WCDiskImageSectorHeader>(sheaderBuffer);
 
@@ -145,11 +155,13 @@ namespace DiscImageChef.DiscImages
                 comments += Encoding.ASCII.GetString(dir);
             }
 
-            if(comments.Length > 0) imageInfo.Comments = comments;
+            if(comments.Length > 0)
+                imageInfo.Comments = comments;
 
             // save some variables for later use
             fileHeader    = fheader;
             wcImageFilter = imageFilter;
+
             return true;
         }
 
@@ -189,9 +201,7 @@ namespace DiscImageChef.DiscImages
             return result;
         }
 
-        /// <summary>
+        /// <summary>Read a whole track and cache it</summary>
-        ///     Read a whole track and cache it
-        /// </summary>
         /// <param name="stream">The stream to read from</param>
         /// <param name="cyl">The cylinder number of the track being read.</param>
         /// <param name="head">The head number of the track being read.</param>
@@ -206,30 +216,36 @@ namespace DiscImageChef.DiscImages
                 /* read the sector header */
                 byte[] sheaderBuffer = new byte[6];
                 stream.Read(sheaderBuffer, 0, 6);
+
                 WCDiskImageSectorHeader sheader =
                     Marshal.ByteArrayToStructureLittleEndian<WCDiskImageSectorHeader>(sheaderBuffer);
 
                 /* validate the sector header */
-                if(sheader.cylinder != cyl || sheader.head != head || sheader.sector != sect)
+                if(sheader.cylinder != cyl  ||
+                   sheader.head     != head ||
+                   sheader.sector   != sect)
                     throw new
-                        InvalidDataException(string.Format("Unexpected sector encountered. Found CHS {0},{1},{2} but expected {3},{4},{5}",
+                        InvalidDataException(string.
+                                                 Format("Unexpected sector encountered. Found CHS {0},{1},{2} but expected {3},{4},{5}",
                                                         sheader.cylinder, sheader.head, sheader.sector, cyl, head,
                                                         sect));
 
                 sectorData = new byte[512];
+
                 /* read the sector data */
                 switch(sheader.flag)
                 {
                     case SectorFlag.Normal: /* read a normal sector and store it in cache */
                         stream.Read(sectorData, 0, 512);
                         sectorCache[(cyl, head, sect)] = sectorData;
-                        Crc16Context.Data(sectorData, 512, out crc);
+                        CRC16IBMContext.Data(sectorData, 512, out crc);
                         calculatedCRC = (short)((256 * crc[0]) | crc[1]);
                         /*
                         DicConsole.DebugWriteLine("d2f plugin", "CHS {0},{1},{2}: Regular sector, stored CRC=0x{3:x4}, calculated CRC=0x{4:x4}",
                             cyl, head, sect, sheader.crc, 256 * crc[0] + crc[1]);
                          */
                         badSectors[(cyl, head, sect)] = sheader.crc != calculatedCRC;
+
                         if(calculatedCRC != sheader.crc)
                             DicConsole.DebugWriteLine("d2f plugin",
                                                       "CHS {0},{1},{2}: CRC mismatch: stored CRC=0x{3:x4}, calculated CRC=0x{4:x4}",
@@ -249,7 +265,8 @@ namespace DiscImageChef.DiscImages
                         DicConsole.DebugWriteLine("d2f plugin", "CHS {0},{1},{2}: RepeatByte sector, fill byte 0x{0:x2}",
                             cyl, head, sect, sheader.crc & 0xff);
                          */
-                        for(int i = 0; i < 512; i++) sectorData[i] = (byte)(sheader.crc & 0xff);
+                        for(int i = 0; i < 512; i++)
+                            sectorData[i] = (byte)(sheader.crc & 0xff);
 
                         sectorCache[(cyl, head, sect)] = sectorData;
                         badSectors[(cyl, head, sect)]  = false;