aaru-dps/Aaru
1
0
Fork 0
mirror of https://github.com/aaru-dps/Aaru.git synced 2025-12-16 19:24:25 +00:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Natalia Portillo
2020-01-04 18:18:20 +00:00
parent 951aa79cce
commit c55d6f8ebb
9 changed files with 923 additions and 437 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
.idea/.idea.DiscImageChef/.idea/contentModel.xml generated
View File

@@ -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" />

286
DiscImageChef.Checksums/CDChecksums.cs
View File

@@ -33,44 +33,17 @@
using System;
using System.Collections.Generic;
using System.Linq;
using DiscImageChef.Console;
namespace DiscImageChef.Checksums
{
/// <summary>
/// Implements ReedSolomon and CRC32 algorithms as used by CD-ROM
/// </summary>
/// <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 ||
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;
if(channel[0x000] != 0x00 ||
channel[0x001] != 0xFF ||
channel[0x002] != 0xFF ||
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[0x818] != 0x00 || channel[0x819] != 0x00 || channel[0x81A] != 0x00 || channel[0x81B] != 0x00)
channel[0x815] != 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] ||
channel[0x012] != channel[0x016] || channel[0x013] != channel[0x017])
if(channel[0x010] != channel[0x014] ||
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] ||
channel[0x012] != channel[0x016] || channel[0x013] != channel[0x017])
if(channel[0x010] != channel[0x014] ||
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) cdTextPack1[j] = (byte)(cdTextPack1[j++] | ((subchannel[i] & 0xC0) >> 4));
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));
if(j < 18)
cdTextPack1[j] = (byte)(cdTextPack1[j] | ((subchannel[i++] & 0x3F) << 2));
if(j < 18)
cdTextPack1[j] = (byte)(cdTextPack1[j++] | ((subchannel[i] & 0xC0) >> 4));
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) cdTextPack2[j] = (byte)(cdTextPack2[j++] | ((subchannel[i] & 0xC0) >> 4));
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));
if(j < 18)
cdTextPack2[j] = (byte)(cdTextPack2[j] | ((subchannel[i++] & 0x3F) << 2));
if(j < 18)
cdTextPack2[j] = (byte)(cdTextPack2[j++] | ((subchannel[i] & 0xC0) >> 4));
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) cdTextPack3[j] = (byte)(cdTextPack3[j++] | ((subchannel[i] & 0xC0) >> 4));
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));
if(j < 18)
cdTextPack3[j] = (byte)(cdTextPack3[j] | ((subchannel[i++] & 0x3F) << 2));
if(j < 18)
cdTextPack3[j] = (byte)(cdTextPack3[j++] | ((subchannel[i] & 0xC0) >> 4));
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) cdTextPack4[j] = (byte)(cdTextPack4[j++] | ((subchannel[i] & 0xC0) >> 4));
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));
if(j < 18)
cdTextPack4[j] = (byte)(cdTextPack4[j] | ((subchannel[i++] & 0x3F) << 2));
if(j < 18)
cdTextPack4[j] = (byte)(cdTextPack4[j++] | ((subchannel[i] & 0xC0) >> 4));
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++) cdSubRwPack3[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++)
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++)
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;
}
}
}

63
DiscImageChef.Checksums/CRC16CCITTContext.cs Normal file
View File

@@ -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);
}
}

270
DiscImageChef.Checksums/CRC16Context.cs
View File

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

64
DiscImageChef.Checksums/CRC16IBMContext.cs Normal file
View File

@@ -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);
}
}

2
DiscImageChef.Checksums/DiscImageChef.Checksums.csproj
View File

@@ -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" />

461
DiscImageChef.Core/Checksum.cs
View File

@@ -42,63 +42,54 @@ namespace DiscImageChef.Core
[Flags]
public enum EnableChecksum
{
Adler32 = 1,
Crc16 = 2,
Crc32 = 4,
Crc64 = 8,
Md5 = 16,
Sha1 = 64,
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
Adler32 = 1, Crc16 = 2, Crc32 = 4,
Crc64 = 8, Md5 = 16, Sha1 = 64,
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>
/// Checksums and hashes data, with different algorithms multithreaded
/// </summary>
/// <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;
IChecksum f16Ctx;
readonly EnableChecksum enabled;
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();
crc16Pkt = new HashPacket {Context = crc16Ctx};
crc16Ctx = new CRC16IBMContext();
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 ||
spamsumThread.IsAlive || f16Thread.IsAlive || f32Thread.IsAlive) { }
sha1Thread.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)) crc16Thread = 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)) 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);
if(enabled.HasFlag(EnableChecksum.SpamSum))
adlerThread = new Thread(UpdateHash);
if(enabled.HasFlag(EnableChecksum.SpamSum))
crc16Thread = 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))
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);
Thread crc16ThreadData = new Thread(UpdateHash);
Thread crc32ThreadData = new Thread(UpdateHash);
Thread crc64ThreadData = new Thread(UpdateHash);
Thread md5ThreadData = new Thread(UpdateHash);
Thread sha1ThreadData = new Thread(UpdateHash);
Thread sha256ThreadData = new Thread(UpdateHash);
Thread sha384ThreadData = new Thread(UpdateHash);
Thread sha512ThreadData = new Thread(UpdateHash);
Thread spamsumThreadData = new Thread(UpdateHash);
Thread f16ThreadData = new Thread(UpdateHash);
Thread f32ThreadData = new Thread(UpdateHash);
var adlerThreadData = new Thread(UpdateHash);
var crc16ThreadData = new Thread(UpdateHash);
var crc32ThreadData = new Thread(UpdateHash);
var crc64ThreadData = new Thread(UpdateHash);
var md5ThreadData = new Thread(UpdateHash);
var sha1ThreadData = new Thread(UpdateHash);
var sha256ThreadData = new Thread(UpdateHash);
var sha384ThreadData = new Thread(UpdateHash);
var sha512ThreadData = new Thread(UpdateHash);
var spamsumThreadData = new Thread(UpdateHash);
var f16ThreadData = 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();
HashPacket crc16PktData = new HashPacket {Context = crc16CtxData, Data = data};
crc16CtxData = new CRC16IBMContext();
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 ||
crc64ThreadData.IsAlive || md5ThreadData.IsAlive ||
sha1ThreadData.IsAlive || sha256ThreadData.IsAlive || sha384ThreadData.IsAlive ||
sha512ThreadData.IsAlive || spamsumThreadData.IsAlive || f16ThreadData.IsAlive ||
while(adlerThreadData.IsAlive ||
crc16ThreadData.IsAlive ||
crc32ThreadData.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)
{
((HashPacket)packet).Context.Update(((HashPacket)packet).Data);
}
static void UpdateHash(object packet) => ((HashPacket)packet).Context.Update(((HashPacket)packet).Data);
#endregion Threading helpers
}
}

59
DiscImageChef.DiscImages/CPCDSK/Read.cs
View File

@@ -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) &&
!du54Id.SequenceEqual(header.magic)) return false;
if(!cpcdskId.SequenceEqual(header.magic) &&
!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
? trackInfo.sectorsInfo[k - 1].len
int sectLen = extended ? 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);
imageInfo.ImageSize += (ulong)(header.tracksizeTable[i * header.sides + j] * 256) - 256;
stream.Seek(header.tracksizeTable[(i * header.sides) + j] * 256, SeekOrigin.Current);
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++)
{

39
DiscImageChef.DiscImages/WCDiskImage/Read.cs
View File

@@ -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[2] == 1 || fheader.extraTracks[3] == 1) imageInfo.Cylinders++;
if(fheader.extraTracks[0] == 1 ||
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>
/// Read a whole track and cache it
/// </summary>
/// <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;