claunia/SabreTools
1
0
Fork 0
mirror of https://github.com/claunia/SabreTools.git synced 2025-12-16 19:14:27 +00:00
Code Issues Packages Projects Releases Wiki Activity

[CHDFile] Tidy code, fix a few things

Browse Source
This commit is contained in:
Matt Nadareski
2017-10-31 02:00:31 -07:00
parent c9cad432ad
commit 9c46dd6f01
3 changed files with 156 additions and 169 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
RombaSharp/RombaSharp.Helpers.cs
View File

@@ -129,7 +129,7 @@ namespace RombaSharp
if (lowerCaseDats.Contains(input.ToLowerInvariant()))
{
string fullpath = Path.GetFullPath(datRootDats[lowerCaseDats.IndexOf(input.ToLowerInvariant())]);
string sha1 = FileTools.GetFileInfo(fullpath).SHA1;
string sha1 = ((Rom)FileTools.GetFileInfo(fullpath)).SHA1;
foundDats.Add(sha1, fullpath);
}
else

27
SabreTools.Library/Data/Constants.cs
View File

@@ -56,12 +56,37 @@ namespace SabreTools.Library.Data
#region CHD header values
public readonly static byte[] CHDSignature = { 0x4d, 0x43, 0x6f, 0x6d, 0x70, 0x72, 0x48, 0x44 }; // "MComprHD"
// CHD signature - "MComprHD"
public readonly static byte[] CHDSignatureBytes = { 0x4d, 0x43, 0x6f, 0x6d, 0x70, 0x72, 0x48, 0x44 };
public const ulong CHDSignature = 0x4d436f6d70724844;
// Header versions and sizes
public const int CHD_HEADER_VERSION = 5;
public const int CHD_V3_HEADER_SIZE = 120;
public const int CHD_V4_HEADER_SIZE = 108;
public const int CHD_V5_HEADER_SIZE = 124;
// Key offsets within the header (V3)
public const long CHDv3MapOffsetOffset = 0; // offset of map offset field
public const long CHDv3MetaOffsetOffset = 36; // offset of metaoffset field
public const long CHDv3SHA1Offset = 80; // offset of SHA1 field
public const long CHDv3RawSHA1Offset = 0; // offset of raw SHA1 field
public const long CHDv3ParentSHA1Offset = 100; // offset of parent SHA1 field
// Key offsets within the header (V4)
public const long CHDv4MapOffsetOffset = 0; // offset of map offset field
public const long CHDv4MetaOffsetOffset = 36; // offset of metaoffset field
public const long CHDv4SHA1Offset = 48; // offset of SHA1 field
public const long CHDv4RawSHA1Offset = 88; // offset of raw SHA1 field
public const long CHDv4ParentSHA1Offset = 68; // offset of parent SHA1 field
// Key offsets within the header (V5)
public const long CHDv5MapOffsetOffset = 40; // offset of map offset field
public const long CHDv5MetaOffsetOffset = 48; // offset of metaoffset field
public const long CHDv5SHA1Offset = 84; // offset of SHA1 field
public const long CHDv5RawSHA1Offset = 64; // offset of raw SHA1 field
public const long CHDv5ParentSHA1Offset = 104; // offset of parent SHA1 field
#endregion
#region Database schema

296
SabreTools.Library/External/CHDFile.cs vendored
View File

@@ -17,9 +17,58 @@ namespace SabreTools.Library.External
/// <summary>
/// This is code adapted from chd.h and chd.cpp in MAME
/// </summary>
/// <remrks>
/// ----------------------------------------------
/// Common CHD Header:
/// 0x00-0x07 - CHD signature
/// 0x08-0x0B - Header size
/// 0x0C-0x0F - CHD version
/// ----------------------------------------------
/// CHD v3 header layout:
/// 0x10-0x13 - Flags (1: Has parent SHA-1, 2: Disallow writes)
/// 0x14-0x17 - Compression
/// 0x18-0x1B - Hunk count
/// 0x1C-0x23 - Logical Bytes
/// 0x24-0x2C - Metadata Offset
/// ...
/// 0x4C-0x4F - Hunk Bytes
/// 0x50-0x63 - SHA-1
/// 0x64-0x77 - Parent SHA-1
/// 0x78-0x87 - Map
/// ----------------------------------------------
/// CHD v4 header layout:
/// 0x10-0x13 - Flags (1: Has parent SHA-1, 2: Disallow writes)
/// 0x14-0x17 - Compression
/// 0x18-0x1B - Hunk count
/// 0x1C-0x23 - Logical Bytes
/// 0x24-0x2C - Metadata Offset
/// ...
/// 0x2C-0x2F - Hunk Bytes
/// 0x30-0x43 - SHA-1
/// 0x44-0x57 - Parent SHA-1
/// 0x58-0x6b - Raw SHA-1
/// 0x6c-0x7b - Map
/// ----------------------------------------------
/// CHD v5 header layout:
/// 0x10-0x13 - Compression format 1
/// 0x14-0x17 - Compression format 2
/// 0x18-0x1B - Compression format 3
/// 0x1C-0x1F - Compression format 4
/// 0x20-0x27 - Logical Bytes
/// 0x28-0x2F - Map Offset
/// 0x30-0x37 - Metadata Offset
/// 0x38-0x3B - Hunk Bytes
/// 0x3C-0x3F - Unit Bytes
/// 0x40-0x53 - Raw SHA-1
/// 0x54-0x67 - SHA-1
/// 0x68-0x7b - Parent SHA-1
/// ----------------------------------------------
/// </remrks>
public class CHDFile
{
// core parameters from the header
// Core parameters from the header
private ulong m_signature; // signature
private uint m_headersize; // size of the header
private uint m_version; // version of the header
private ulong m_logicalbytes; // logical size of the raw CHD data in bytes
private ulong m_mapoffset; // offset of map
@@ -30,13 +79,6 @@ namespace SabreTools.Library.External
private ulong m_unitcount; // number of units represented
private CHDCodecType[] m_compression = new CHDCodecType[4]; // array of compression types used
// key offsets within the header
private long m_mapoffset_offset; // offset of map offset field
private long m_metaoffset_offset;// offset of metaoffset field
private long m_sha1_offset; // offset of SHA1 field
private long m_rawsha1_offset; // offset of raw SHA1 field
private long m_parentsha1_offset;// offset of paren SHA1 field
// map information
uint m_mapentrybytes; // length of each entry in a map
@@ -59,12 +101,12 @@ namespace SabreTools.Library.External
/// <summary>
/// Get internal metadata from a CHD
/// </summary>
/// <param name="fs">FileStreams of possible CHD</param>
/// <param name="fs">Stream of possible CHD</param>
/// <returns>A Disk object with internal SHA-1 on success, null on error, empty Disk otherwise</returns>
/// <remarks>
/// Original code had a "writable" param. This is not required for metadata checking
/// </remarks>
public DatItem GetCHDInfo(FileStream fs)
public DatItem GetCHDInfo(Stream fs)
{
// Create a blank Disk to populate and return
Disk datItem = new Disk();
@@ -73,97 +115,89 @@ namespace SabreTools.Library.External
BinaryReader br = new BinaryReader(fs);
// Read and verify the CHD signature
// read the raw header
byte[] signature = br.ReadBytes(8);
// verify the signature
bool correct = true;
for (int i = 0; i < signature.Length; i++)
{
correct &= (signature[i] == Constants.CHDSignature[i]);
}
if (!correct)
m_signature = br.ReadUInt64();
if (m_signature != Constants.CHDSignature)
{
// throw CHDERR_INVALID_FILE;
return null;
}
// only allow writes to the most recent version
br.BaseStream.Seek(12, SeekOrigin.Begin);
// Get the header size and version
m_headersize = br.ReadUInt32();
m_version = br.ReadUInt32();
// read the header if we support it
// Create a placeholder for the extracted SHA-1
byte[] sha1 = new byte[20];
switch (m_version)
// If we have a CHD v3 file, parse it accordingly
if (m_headersize == Constants.CHD_V3_HEADER_SIZE && m_version == 3)
{
case 3:
ParseV3Header(br, out sha1);
break;
case 4:
ParseV4Header(br, out sha1);
break;
case 5:
ParseV5Header(br, out sha1);
break;
default:
// throw CHDERR_UNSUPPORTED_VERSION;
return null;
sha1 = ParseCHDv3Header(br);
}
// If we have a CHD v4 file, parse it accordingly
else if (m_headersize == Constants.CHD_V4_HEADER_SIZE && m_version == 4)
{
sha1 = ParseCHDv4Header(br);
}
// If we have a CHD v5 file, parse it accordingly
else if (m_headersize == Constants.CHD_V5_HEADER_SIZE && m_version == 5)
{
sha1 = ParseCHDv5Header(br);
}
// If we don't have a valid combination, return null
else
{
// throw CHDERR_UNSUPPORTED_VERSION;
// throw CHDERR_INVALID_FILE;
return null;
}
// Set the SHA-1 of the Disk to return
datItem.SHA1 = BitConverter.ToString(sha1).Replace("-", string.Empty).ToLowerInvariant();
return datItem;
}
/// <summary>
/// Parse a CHD v3 header, populate the fields, and return the SHA-1
/// Get if file is a valid CHD
/// </summary>
/// <param name="br">BinaryReader representing the file to read</param>
/// <param name="sha1">Out parameter representing the SHA-1</param>
/// <returns>True if the header was parsed properly, false otherwise</returns>
/// <remarks>
/// CHD v3 header layout:
/// 0x00-0x07 - CHD signature
/// 0x08-0x0B - Header size
/// 0x0C-0x0F - [UNUSED]
/// 0x10-0x13 - Flags (1: Has parent SHA-1, 2: Disallow writes)
/// 0x14-0x17 - Compression
/// 0x18-0x1B - Hunk count
/// 0x1C-0x23 - Logical Bytes
/// 0x24-0x2C - Metadata Offset
/// ...
/// 0x4C-0x4F - Hunk Bytes
/// 0x50-0x63 - SHA-1
/// 0x64-0x77 - Parent SHA-1
/// 0x78-0x87 - Map
/// </remarks>
private bool ParseV3Header(BinaryReader br, out byte[] sha1)
/// <param name="filename">Filename of possible CHD</param>
/// <returns>True if a the file is a valid CHD, false otherwise</returns>
public bool IsValidCHD(string filename)
{
DatItem datItem = GetCHDInfo(filename);
return datItem != null
&& datItem.Type == ItemType.Disk
&& ((Disk)datItem).SHA1 != null;
}
/// <summary>
/// Get if stream is a valid CHD
/// </summary>
/// <param name="fs">Stream of possible CHD</param>
/// <returns>True if a the file is a valid CHD, false otherwise</returns>
public bool IsValidCHD(Stream fs)
{
DatItem datItem = GetCHDInfo(fs);
return datItem != null
&& datItem.Type == ItemType.Disk
&& ((Disk)datItem).SHA1 != null;
}
/// <summary>
/// Parse a CHD v3 header
/// </summary>
/// <param name="br">Binary reader representing the input stream</param>
/// <returns>The extracted SHA-1 on success, null otherwise</returns>
private byte[] ParseCHDv3Header(BinaryReader br)
{
// Set the blank SHA-1 hash
sha1 = null;
byte[] sha1 = new byte[20];
// Set offsets and defaults
m_mapoffset_offset = 0;
m_rawsha1_offset = 0;
m_mapoffset = 120;
m_metaoffset_offset = 36;
m_sha1_offset = 80;
m_parentsha1_offset = 100;
m_mapentrybytes = 16;
// Ensure the proper starting position
br.BaseStream.Seek(8, SeekOrigin.Begin);
// Verify header length
if (br.ReadInt32() != Constants.CHD_V3_HEADER_SIZE)
{
// throw CHDERR_INVALID_FILE;
return false;
}
// Skip over the 0x0C-0x0F block
br.ReadUInt32();
// Read the CHD flags
uint flags = br.ReadUInt32();
@@ -174,7 +208,7 @@ namespace SabreTools.Library.External
case 1: m_compression[0] = CHDCodecType.CHD_CODEC_ZLIB; break;
case 2: m_compression[0] = CHDCodecType.CHD_CODEC_ZLIB; break;
case 3: m_compression[0] = CHDCodecType.CHD_CODEC_AVHUFF; break;
default: /* throw CHDERR_UNKNOWN_COMPRESSION; */ return false;
default: /* throw CHDERR_UNKNOWN_COMPRESSION; */ return null;
}
m_compression[1] = m_compression[2] = m_compression[3] = CHDCodecType.CHD_CODEC_NONE;
@@ -186,63 +220,30 @@ namespace SabreTools.Library.External
br.BaseStream.Seek(76, SeekOrigin.Begin);
m_hunkbytes = br.ReadUInt32();
br.BaseStream.Seek(m_sha1_offset, SeekOrigin.Begin);
br.BaseStream.Seek(Constants.CHDv3SHA1Offset, SeekOrigin.Begin);
sha1 = br.ReadBytes(20);
// guess at the units based on snooping the metadata
// m_unitbytes = guess_unitbytes();
m_unitcount = (m_logicalbytes + m_unitbytes - 1) / m_unitbytes;
return true;
return sha1;
}
/// <summary>
/// Parse a CHD v4 header, populate the fields, and return the SHA-1
/// Parse a CHD v4 header
/// </summary>
/// <param name="br">BinaryReader representing the file to read</param>
/// <param name="sha1">Out parameter representing the SHA-1</param>
/// <returns>True if the header was parsed properly, false otherwise</returns>
/// <remarks>
/// CHD v4 header layout:
/// 0x00-0x07 - CHD signature
/// 0x08-0x0B - Header size
/// 0x0C-0x0F - [UNUSED]
/// 0x10-0x13 - Flags (1: Has parent SHA-1, 2: Disallow writes)
/// 0x14-0x17 - Compression
/// 0x18-0x1B - Hunk count
/// 0x1C-0x23 - Logical Bytes
/// 0x24-0x2C - Metadata Offset
/// ...
/// 0x2C-0x2F - Hunk Bytes
/// 0x30-0x43 - SHA-1
/// 0x44-0x57 - Parent SHA-1
/// 0x58-0x6b - Raw SHA-1
/// 0x6c-0x7b - Map
/// </remarks>
private bool ParseV4Header(BinaryReader br, out byte[] sha1)
/// <param name="br">Binary reader representing the input stream</param>
/// <returns>The extracted SHA-1 on success, null otherwise</returns>
private byte[] ParseCHDv4Header(BinaryReader br)
{
// Set the blank SHA-1 hash
sha1 = null;
byte[] sha1 = new byte[20];
// Set offsets and defaults
m_mapoffset_offset = 0;
m_metaoffset_offset = 36;
m_sha1_offset = 48;
m_parentsha1_offset = 68;
m_rawsha1_offset = 88;
m_mapoffset = 108;
m_mapentrybytes = 16;
// Ensure the proper starting position
br.BaseStream.Seek(8, SeekOrigin.Begin);
// Verify header length
if (br.ReadUInt32() != Constants.CHD_V4_HEADER_SIZE)
{
// throw CHDERR_INVALID_FILE;
return false;
}
// Read the CHD flags
uint flags = br.ReadUInt32();
@@ -253,7 +254,7 @@ namespace SabreTools.Library.External
case 1: m_compression[0] = CHDCodecType.CHD_CODEC_ZLIB; break;
case 2: m_compression[0] = CHDCodecType.CHD_CODEC_ZLIB; break;
case 3: m_compression[0] = CHDCodecType.CHD_CODEC_AVHUFF; break;
default: /* throw CHDERR_UNKNOWN_COMPRESSION; */ return false;
default: /* throw CHDERR_UNKNOWN_COMPRESSION; */ return null;
}
m_compression[1] = m_compression[2] = m_compression[3] = CHDCodecType.CHD_CODEC_NONE;
@@ -264,63 +265,25 @@ namespace SabreTools.Library.External
br.BaseStream.Seek(44, SeekOrigin.Begin);
m_hunkbytes = br.ReadUInt32();
br.BaseStream.Seek(m_sha1_offset, SeekOrigin.Begin);
br.BaseStream.Seek(Constants.CHDv4SHA1Offset, SeekOrigin.Begin);
sha1 = br.ReadBytes(20);
// guess at the units based on snooping the metadata
// m_unitbytes = guess_unitbytes();
m_unitcount = (m_logicalbytes + m_unitbytes - 1) / m_unitbytes;
return true;
return sha1;
}
/// <summary>
/// Parse a CHD v5 header, populate the fields, and return the SHA-1
/// Parse a CHD v5 header
/// </summary>
/// <param name="br">BinaryReader representing the file to read</param>
/// <param name="sha1">Out parameter representing the SHA-1</param>
/// <returns>True if the header was parsed properly, false otherwise</returns>
/// <remarks>
/// CHD v5 header layout:
/// 0x00-0x07 - CHD signature
/// 0x08-0x0B - Header size
/// 0x0C-0x0F - [UNUSED]
/// 0x10-0x13 - Compression format 1
/// 0x14-0x17 - Compression format 2
/// 0x18-0x1B - Compression format 3
/// 0x1C-0x1F - Compression format 4
/// 0x18-0x1B - Hunk count
/// 0x20-0x27 - Logical Bytes
/// 0x28-0x2F - Map Offset
/// 0x30-0x37 - Metadata Offset
/// 0x38-0x3B - Hunk Bytes
/// 0x3C-0x3F - Unit Bytes
/// 0x40-0x53 - Raw SHA-1
/// 0x54-0x67 - SHA-1
/// 0x68-0x7b - Parent SHA-1
/// </remarks>
private bool ParseV5Header(BinaryReader br, out byte[] sha1)
/// <param name="br">Binary reader representing the input stream</param>
/// <returns>The extracted SHA-1 on success, null otherwise</returns>
private byte[] ParseCHDv5Header(BinaryReader br)
{
// Set the blank SHA-1 hash
sha1 = null;
// Set offsets and defaults
m_mapoffset_offset = 40;
m_metaoffset_offset = 48;
m_rawsha1_offset = 64;
m_sha1_offset = 84;
m_parentsha1_offset = 104;
// Ensure the proper starting position
br.BaseStream.Seek(8, SeekOrigin.Begin);
// Verify header length
if (br.ReadUInt32() != Constants.CHD_V5_HEADER_SIZE)
{
// throw CHDERR_INVALID_FILE
return false;
}
byte[] sha1 = new byte[20];
// Determine compression
m_compression[0] = (CHDCodecType)br.ReadUInt32();
@@ -341,10 +304,9 @@ namespace SabreTools.Library.External
// determine properties of map entries
// m_mapentrybytes = compressed() ? 12 : 4;
br.BaseStream.Seek(m_sha1_offset, SeekOrigin.Begin);
br.BaseStream.Seek(Constants.CHDv5SHA1Offset, SeekOrigin.Begin);
sha1 = br.ReadBytes(20);
return true;
return sha1;
}
}
}