public override void CalculateHashes(byte[] rom, IHashWorkManager worker, float startProgress, float endProgress)
{
// Hashes are calculated using the thread pool due to the fact that NDS roms are MASSIVE
worker.QueueTask((SimpleDelegate) delegate {
if (!worker.AbortPending)
{
worker.AddHashes(rom, 0, rom.Length, () => worker.AbortPending, HashFlags.SHA256, HashFlags.FileHash, HashFlags.RomHash);
}
});
worker.QueueTask((SimpleDelegate) delegate {
if (!worker.AbortPending)
{
worker.AddHashes(rom, 0, rom.Length, () => worker.AbortPending, HashFlags.SHA1, HashFlags.FileHash, HashFlags.RomHash);
}
});
worker.QueueTask((SimpleDelegate) delegate {
if (!worker.AbortPending)
{
worker.AddHashes(rom, 0, rom.Length, () => worker.AbortPending, HashFlags.CRC32, HashFlags.FileHash, HashFlags.RomHash);
}
});
worker.QueueTask((SimpleDelegate) delegate {
if (!worker.AbortPending)
{
worker.AddHashes(rom, 0, rom.Length, () => worker.AbortPending, HashFlags.MD5, HashFlags.FileHash, HashFlags.RomHash);
}
});
// Can not return until all hashes are ready
worker.WaitAll();
}
public override void CalculateHashes(byte[] rom, IHashWorkManager worker, float startProgress, float endProgress)
{
iNesHeader header = null;
if (rom.Length > 0x10)
{
header = new iNesHeader(rom, 0);
}
if (header != null && header.MagicNumberIsCorrect) // Headered
{
worker.AddHashes(rom, 0, rom.Length, () => worker.AbortPending, RomHash.AllHashAlgorithms, HashFlags.FileHash);
// Calculate headerless hashes and PRG/CHR hashes
int ROMSize = header.PrgRomSize + header.ChrRomSize;
ROMSize = Math.Min(ROMSize, rom.Length - 0x10);
worker.AddHashes(rom, 0x10, ROMSize, () => worker.AbortPending, RomHash.AllHashAlgorithms, HashFlags.RomHash);
}
else
{
// Unheadered (file hash IS rom hash)
worker.AddHashes(rom, 0, rom.Length, () => worker.AbortPending, RomHash.AllHashAlgorithms, HashFlags.FileHash, HashFlags.RomHash);
}
}
public override void CalculateHashes(byte[] rom, IHashWorkManager worker, float startProgress, float endProgress)
{
iNesHeader header = null;
if (rom.Length > 0x10)
{
header = new iNesHeader(rom, 0);
}
if (SNES.HasExternalHeader(rom)) // Headered
{
worker.AddHashes(rom, 0, rom.Length, () => worker.AbortPending, RomHash.AllHashAlgorithms, HashFlags.FileHash);
// Calculate headerless hashes
int ROMSize = rom.Length - SNES.ExternalHeaderSize;
ROMSize = Math.Min(ROMSize, rom.Length - SNES.ExternalHeaderSize);
worker.AddHashes(rom, SNES.ExternalHeaderSize, ROMSize, () => worker.AbortPending, RomHash.AllHashAlgorithms, HashFlags.RomHash);
}
else
{
// Unheadered (file hash IS rom hash)
worker.AddHashes(rom, 0, rom.Length, () => worker.AbortPending, RomHash.AllHashAlgorithms, HashFlags.FileHash, HashFlags.RomHash);
}
}
public override void CalculateHashes(byte[] rom, IHashWorkManager worker, float startProgress, float endProgress)
{
if (HasFdsMagicNumber(rom)) // Headered
{
worker.AddHashes(rom, 0, rom.Length, () => worker.AbortPending, RomHash.AllHashAlgorithms, HashFlags.FileHash);
// Calculate headerless hashes and PRG/CHR hashes
int ROMSize = rom.Length - 0x10;
worker.AddHashes(rom, 0x10, ROMSize, () => worker.AbortPending, RomHash.AllHashAlgorithms, HashFlags.RomHash);
}
else
{
// Unheadered (file hash IS rom hash)
worker.AddHashes(rom, 0, rom.Length, () => worker.AbortPending, RomHash.AllHashAlgorithms, HashFlags.FileHash, HashFlags.RomHash);
}
}
public override void CalculateHashes(byte[] rom, IHashWorkManager worker, float startProgress, float endProgress)
{
bool eHeader, iHeader, interleaved, s32X;
iHeader = Gen.HasInternalHeader(rom, out interleaved, out eHeader, out s32X);
byte[] binRomImage = GetBinFormat(rom);
this.BinRomImage = new WeakReference(binRomImage);
if (binRomImage == rom)
{
worker.AddHashes(rom, 0, rom.Length, () => worker.AbortPending, RomHash.AllHashAlgorithms, HashFlags.FileHash, HashFlags.RomHash);
}
else
{
worker.AddHashes(rom, 0, rom.Length, () => worker.AbortPending, RomHash.AllHashAlgorithms, HashFlags.FileHash);
worker.AddHashes(binRomImage, 0, binRomImage.Length, () => worker.AbortPending, RomHash.AllHashAlgorithms, HashFlags.RomHash);
}
}
public override void CalculateHashes(byte[] rom, IHashWorkManager worker, float startProgress, float endProgress)
{
worker.AddHashes(rom, 0, rom.Length, () => worker.AbortPending, RomHash.AllHashAlgorithms, HashFlags.FileHash, HashFlags.RomHash);
}
/// <summary> /// Gets a set of hashes relevant to this platform based on the ROM provided. /// </summary> /// <param name="rom"></param> /// <param name="worker"></param> /// <param name="startProgress">The progress percentage before hashing starts.</param> /// <param name="endProgress">The progress percentage to report when hashing completes.</param> /// <returns>A list of hashes for the ROM, or null if the work manager aborts the operation.</returns> public abstract void CalculateHashes(byte[] rom, IHashWorkManager worker, float startProgress, float endProgress);
/// <summary>
/// Calculates ROM data and produces extended ROM info
/// </summary>
/// <param name="rom">ROM image</param>
/// <param name="platform">ROM platform, or Platform.UnknownPlatform</param>
/// <param name="miscPlatform">Null, or, optionally, the name of the unsupported platform is Platform.Unknown is specified</param>
/// <param name="findDbMatches">Specify true to search relevant databases for matches</param>
/// <param name="extendedData">Specify true to produce extended data</param>
/// <param name="worker">Work manager</param>
/// <returns>An intialized RomData object, or null if the worker aborted the operation</returns>
public static RomData GetRomData(byte[] rom, Platform platform, string miscPlatform, bool findDbMatches, bool extendedData, IHashWorkManager worker)
{
bool abort = false;
RomData result = new RomData();
result.Platform = platform;
result.MiscPlatform = miscPlatform;
result.FileSize = rom.Length;
//IdentifyPlatform(rom, extension, result, platformPrompt, platformPromptTitle);
worker.CheckIn(.1f, out abort);
if (abort)
{
return(null);
}
if (result.Platform != null)
{
result.Platform.InitRomData(result, rom);
result.RomSize = result.Platform.GetRomSize(rom);
result.FormatName = result.Platform.GetRomFormatName(rom);
result.ExternalHeader = result.Platform.HasHeader(rom);
worker.CheckIn(.2f, out abort);
if (abort)
{
return(null);
}
result.Platform.CalculateHashes(rom, worker, 0.2f, 0.6f);
var hashes = worker.Hashes;
if (hashes != null)
{
result._Hashes.AddRange(hashes); // May return null if operation aborted
}
result._Hashes.Sort((RomHash a, RomHash b) => (int)a.Type - (int)b.Type); // Sort (ordering isn't meaningful, but will be consistent)
worker.CheckIn(0.6f, out abort); if (abort)
{
return(null);
}
if (findDbMatches)
{
FindDbMatches(result);
}
worker.CheckIn(0.8f, out abort); if (abort)
{
return(null);
}
if (extendedData)
{
result.ExtendedData = result.Platform.GetExtendedInfo(rom, result);
}
else
{
result.DatabaseMatches = new List <DBMatch>().AsReadOnly();
result.ExtendedData = new List <RomDataCategory>();
}
}
else
{
result.RomSize = result.FileSize;
result.FormatName = "unknown";
result.ExternalHeader = null;
result.DatabaseMatches = new List <DBMatch>().AsReadOnly();
result.ExtendedData = new List <RomDataCategory>();
}
worker.CheckIn(1f, out abort);
return(result);
}
public override void CalculateHashes(byte[] rom, IHashWorkManager worker, float startProgress, float endProgress)
{
// N64 hashes are calculated using the thread pool because the ROMs tend to be large
bool byteswapped = N64.IsByteswapped(rom) == N64ByteSwap.Swapped;
byte[] swappedRom = new byte[rom.Length];
// Watch out for odd # of bytes!
int len = rom.Length & (~1);
for (int i = 0; i < len; i += 2)
{
swappedRom[i] = rom[i + 1];
swappedRom[i + 1] = rom[i];
}
HashFlags originalType = byteswapped ? HashFlags.RomHash_ByteSwap : HashFlags.RomHash;
HashFlags swappedType = byteswapped ? HashFlags.RomHash : HashFlags.RomHash_ByteSwap;
worker.QueueTask((SimpleDelegate) delegate {
if (!worker.AbortPending)
{
worker.AddHashes(rom, 0, rom.Length, () => worker.AbortPending, HashFlags.SHA256, originalType, HashFlags.FileHash);
}
});
worker.QueueTask((SimpleDelegate) delegate {
if (!worker.AbortPending)
{
worker.AddHashes(rom, 0, rom.Length, () => worker.AbortPending, HashFlags.SHA1, originalType, HashFlags.FileHash);
}
});
worker.QueueTask((SimpleDelegate) delegate {
if (!worker.AbortPending)
{
worker.AddHashes(rom, 0, rom.Length, () => worker.AbortPending, HashFlags.CRC32, originalType, HashFlags.FileHash);
}
});
worker.QueueTask((SimpleDelegate) delegate {
if (!worker.AbortPending)
{
worker.AddHashes(rom, 0, rom.Length, () => worker.AbortPending, HashFlags.MD5, originalType, HashFlags.FileHash);
}
});
// We can not byte-swap the ROM while it is being hashed
worker.WaitAll();
worker.QueueTask((SimpleDelegate) delegate {
if (!worker.AbortPending)
{
worker.AddHashes(swappedRom, 0, swappedRom.Length, () => worker.AbortPending, HashFlags.SHA256, swappedType);
}
});
worker.QueueTask((SimpleDelegate) delegate {
if (!worker.AbortPending)
{
worker.AddHashes(swappedRom, 0, swappedRom.Length, () => worker.AbortPending, HashFlags.SHA1, swappedType);
}
});
worker.QueueTask((SimpleDelegate) delegate {
if (!worker.AbortPending)
{
worker.AddHashes(swappedRom, 0, swappedRom.Length, () => worker.AbortPending, HashFlags.CRC32, swappedType);
}
});
worker.QueueTask((SimpleDelegate) delegate {
if (!worker.AbortPending)
{
worker.AddHashes(swappedRom, 0, swappedRom.Length, () => worker.AbortPending, HashFlags.MD5, swappedType);
}
});
// We can not return until all hashes are calculated
worker.WaitAll();
}
