mirror of
https://github.com/claunia/SabreTools.git
synced 2025-12-16 19:14:27 +00:00
338 lines
10 KiB
C#
338 lines
10 KiB
C#
using System.Text;
|
|
using System.Xml.Serialization;
|
|
|
|
using SabreTools.Core;
|
|
using SabreTools.Core.Tools;
|
|
using SabreTools.FileTypes;
|
|
using Newtonsoft.Json;
|
|
|
|
namespace SabreTools.DatItems
|
|
{
|
|
/// <summary>
|
|
/// Represents Aaruformat images which use internal hashes
|
|
/// </summary>
|
|
[JsonObject("media"), XmlRoot("media")]
|
|
public class Media : DatItem
|
|
{
|
|
#region Private instance variables
|
|
|
|
private byte[] _md5; // 16 bytes
|
|
private byte[] _sha1; // 20 bytes
|
|
private byte[] _sha256; // 32 bytes
|
|
private byte[] _spamsum; // variable bytes
|
|
|
|
#endregion
|
|
|
|
#region Fields
|
|
|
|
/// <summary>
|
|
/// Name of the item
|
|
/// </summary>
|
|
[JsonProperty("name")]
|
|
[XmlElement("name")]
|
|
public string Name { get; set; }
|
|
|
|
/// <summary>
|
|
/// Data MD5 hash
|
|
/// </summary>
|
|
[JsonProperty("md5", DefaultValueHandling = DefaultValueHandling.Ignore)]
|
|
[XmlElement("md5")]
|
|
public string MD5
|
|
{
|
|
get { return _md5.IsNullOrEmpty() ? null : Utilities.ByteArrayToString(_md5); }
|
|
set { _md5 = Utilities.StringToByteArray(CleanMD5(value)); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Data SHA-1 hash
|
|
/// </summary>
|
|
[JsonProperty("sha1", DefaultValueHandling = DefaultValueHandling.Ignore)]
|
|
[XmlElement("sha1")]
|
|
public string SHA1
|
|
{
|
|
get { return _sha1.IsNullOrEmpty() ? null : Utilities.ByteArrayToString(_sha1); }
|
|
set { _sha1 = Utilities.StringToByteArray(CleanSHA1(value)); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Data SHA-256 hash
|
|
/// </summary>
|
|
[JsonProperty("sha256", DefaultValueHandling = DefaultValueHandling.Ignore)]
|
|
[XmlElement("sha256")]
|
|
public string SHA256
|
|
{
|
|
get { return _sha256.IsNullOrEmpty() ? null : Utilities.ByteArrayToString(_sha256); }
|
|
set { _sha256 = Utilities.StringToByteArray(CleanSHA256(value)); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// File SpamSum fuzzy hash
|
|
/// </summary>
|
|
[JsonProperty("spamsum", DefaultValueHandling = DefaultValueHandling.Ignore)]
|
|
[XmlElement("spamsum")]
|
|
public string SpamSum
|
|
{
|
|
get { return _spamsum.IsNullOrEmpty() ? null : Encoding.UTF8.GetString(_spamsum); }
|
|
set { _spamsum = Encoding.UTF8.GetBytes(value ?? string.Empty); }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Accessors
|
|
|
|
/// <inheritdoc/>
|
|
public override string GetName() => Name;
|
|
|
|
/// <inheritdoc/>
|
|
public override void SetName(string name) => Name = name;
|
|
|
|
#endregion
|
|
|
|
#region Constructors
|
|
|
|
/// <summary>
|
|
/// Create a default, empty Media object
|
|
/// </summary>
|
|
public Media()
|
|
{
|
|
Name = string.Empty;
|
|
ItemType = ItemType.Media;
|
|
DupeType = 0x00;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create a Media object from a BaseFile
|
|
/// </summary>
|
|
/// <param name="baseFile"></param>
|
|
public Media(BaseFile baseFile)
|
|
{
|
|
Name = baseFile.Filename;
|
|
_md5 = baseFile.MD5;
|
|
_sha1 = baseFile.SHA1;
|
|
_sha256 = baseFile.SHA256;
|
|
_spamsum = baseFile.SpamSum;
|
|
|
|
ItemType = ItemType.Media;
|
|
DupeType = 0x00;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Cloning Methods
|
|
|
|
public override object Clone()
|
|
{
|
|
return new Media()
|
|
{
|
|
ItemType = this.ItemType,
|
|
DupeType = this.DupeType,
|
|
|
|
Machine = this.Machine.Clone() as Machine,
|
|
Source = this.Source.Clone() as Source,
|
|
Remove = this.Remove,
|
|
|
|
Name = this.Name,
|
|
_md5 = this._md5,
|
|
_sha1 = this._sha1,
|
|
_sha256 = this._sha256,
|
|
_spamsum = this._spamsum,
|
|
};
|
|
}
|
|
|
|
/// <summary>
|
|
/// Convert Media object to a BaseFile
|
|
/// </summary>
|
|
public BaseFile ConvertToBaseFile()
|
|
{
|
|
return new BaseFile()
|
|
{
|
|
Filename = this.Name,
|
|
Parent = this.Machine?.Name,
|
|
MD5 = this._md5,
|
|
SHA1 = this._sha1,
|
|
SHA256 = this._sha256,
|
|
SpamSum = this._spamsum,
|
|
};
|
|
}
|
|
|
|
/// <summary>
|
|
/// Convert a media to the closest Rom approximation
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public Rom ConvertToRom()
|
|
{
|
|
var rom = new Rom()
|
|
{
|
|
ItemType = ItemType.Rom,
|
|
DupeType = this.DupeType,
|
|
|
|
Machine = this.Machine.Clone() as Machine,
|
|
Source = this.Source.Clone() as Source,
|
|
Remove = this.Remove,
|
|
|
|
Name = this.Name + ".aif",
|
|
MD5 = this.MD5,
|
|
SHA1 = this.SHA1,
|
|
SHA256 = this.SHA256,
|
|
SpamSum = this.SpamSum,
|
|
};
|
|
|
|
return rom;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Comparision Methods
|
|
|
|
public override bool Equals(DatItem other)
|
|
{
|
|
bool dupefound = false;
|
|
|
|
// If we don't have a Media, return false
|
|
if (ItemType != other.ItemType)
|
|
return dupefound;
|
|
|
|
// Otherwise, treat it as a Media
|
|
Media newOther = other as Media;
|
|
|
|
// If we get a partial match
|
|
if (HashMatch(newOther))
|
|
dupefound = true;
|
|
|
|
return dupefound;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Fill any missing size and hash information from another Media
|
|
/// </summary>
|
|
/// <param name="other">Media to fill information from</param>
|
|
public void FillMissingInformation(Media other)
|
|
{
|
|
if (_md5.IsNullOrEmpty() && !other._md5.IsNullOrEmpty())
|
|
_md5 = other._md5;
|
|
|
|
if (_sha1.IsNullOrEmpty() && !other._sha1.IsNullOrEmpty())
|
|
_sha1 = other._sha1;
|
|
|
|
if (_sha256.IsNullOrEmpty() && !other._sha256.IsNullOrEmpty())
|
|
_sha256 = other._sha256;
|
|
|
|
if (_spamsum.IsNullOrEmpty() && !other._spamsum.IsNullOrEmpty())
|
|
_spamsum = other._spamsum;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get unique duplicate suffix on name collision
|
|
/// </summary>
|
|
/// <returns>String representing the suffix</returns>
|
|
public string GetDuplicateSuffix()
|
|
{
|
|
if (!_md5.IsNullOrEmpty())
|
|
return $"_{MD5}";
|
|
else if (!_sha1.IsNullOrEmpty())
|
|
return $"_{SHA1}";
|
|
else if (!_sha256.IsNullOrEmpty())
|
|
return $"_{SHA256}";
|
|
else if (!_spamsum.IsNullOrEmpty())
|
|
return $"_{SpamSum}";
|
|
else
|
|
return "_1";
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns if there are no, non-empty hashes in common with another Media
|
|
/// </summary>
|
|
/// <param name="other">Media to compare against</param>
|
|
/// <returns>True if at least one hash is not mutually exclusive, false otherwise</returns>
|
|
private bool HasCommonHash(Media other)
|
|
{
|
|
return !(_md5.IsNullOrEmpty() ^ other._md5.IsNullOrEmpty())
|
|
|| !(_sha1.IsNullOrEmpty() ^ other._sha1.IsNullOrEmpty())
|
|
|| !(_sha256.IsNullOrEmpty() ^ other._sha256.IsNullOrEmpty())
|
|
|| !(_spamsum.IsNullOrEmpty() ^ other._spamsum.IsNullOrEmpty());
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns if the Media contains any hashes
|
|
/// </summary>
|
|
/// <returns>True if any hash exists, false otherwise</returns>
|
|
private bool HasHashes()
|
|
{
|
|
return !_md5.IsNullOrEmpty()
|
|
|| !_sha1.IsNullOrEmpty()
|
|
|| !_sha256.IsNullOrEmpty()
|
|
|| !_spamsum.IsNullOrEmpty();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns if any hashes are common with another Media
|
|
/// </summary>
|
|
/// <param name="other">Media to compare against</param>
|
|
/// <returns>True if any hashes are in common, false otherwise</returns>
|
|
private bool HashMatch(Media other)
|
|
{
|
|
// If either have no hashes, we return false, otherwise this would be a false positive
|
|
if (!HasHashes() || !other.HasHashes())
|
|
return false;
|
|
|
|
// If neither have hashes in common, we return false, otherwise this would be a false positive
|
|
if (!HasCommonHash(other))
|
|
return false;
|
|
|
|
// Return if all hashes match according to merge rules
|
|
return ConditionalHashEquals(_md5, other._md5)
|
|
&& ConditionalHashEquals(_sha1, other._sha1)
|
|
&& ConditionalHashEquals(_spamsum, other._spamsum);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Sorting and Merging
|
|
|
|
/// <summary>
|
|
/// Get the dictionary key that should be used for a given item and bucketing type
|
|
/// </summary>
|
|
/// <param name="bucketedBy">Field enum representing what key to get</param>
|
|
/// <param name="lower">True if the key should be lowercased (default), false otherwise</param>
|
|
/// <param name="norename">True if games should only be compared on game and file name, false if system and source are counted</param>
|
|
/// <returns>String representing the key to be used for the DatItem</returns>
|
|
public override string GetKey(Field bucketedBy, bool lower = true, bool norename = true)
|
|
{
|
|
// Set the output key as the default blank string
|
|
string key = string.Empty;
|
|
|
|
// Now determine what the key should be based on the bucketedBy value
|
|
switch (bucketedBy)
|
|
{
|
|
case Field.DatItem_MD5:
|
|
key = MD5;
|
|
break;
|
|
|
|
case Field.DatItem_SHA1:
|
|
key = SHA1;
|
|
break;
|
|
|
|
case Field.DatItem_SHA256:
|
|
key = SHA256;
|
|
break;
|
|
|
|
case Field.DatItem_SpamSum:
|
|
key = SpamSum;
|
|
break;
|
|
|
|
// Let the base handle generic stuff
|
|
default:
|
|
return base.GetKey(bucketedBy, lower, norename);
|
|
}
|
|
|
|
// Double and triple check the key for corner cases
|
|
if (key == null)
|
|
key = string.Empty;
|
|
|
|
return key;
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|