private void btnDouble_Click(object sender, EventArgs e)
{
if (TwoFileView)
{
if (SecondaryRom != null)
{
const string message = "The second ROM will be unloaded.";
const string title = "Remove second ROM";
if (MessageBox.Show(message, title, MessageBoxButtons.OKCancel, MessageBoxIcon.Warning) == DialogResult.OK)
{
SecondaryRom = null;
SecondaryRomFilename = SecondaryRomPath = null;
UpdateRomDisplay(false);
TwoFileView = false;
}
}
else
{
TwoFileView = false;
}
}
else
{
TwoFileView = true;
}
//btnDoubleROM.Checked = TwoFileView;
}
/// <summary>
/// Adds standard ROM details
/// </summary>
/// <param name="builder">Data builder</param>
/// <param name="rom">ROM image</param>
/// <param name="data">ROM information</param>
private void AddStandardData(RomExDataBuilder builder, byte[] rom, RomData data)
{
const string general = RomExDataBuilder.GeneralCat;
builder.AddData(general, "Platform", data.Platform.ID.GetDescription());
builder.AddData(general, "ROM format", data.FormatName);
if (data.ExternalHeader != null)
{
builder.AddData(general, "External Header", data.ExternalHeader.Value ? "Yes" : "No");
}
builder.AddData(general, "File Size", data.FileSize.ToString() + " (" + data.FileSize.ToString("x") + ")");
builder.AddData(general, "ROM Size", data.RomSize.ToString() + " (" + data.RomSize.ToString("x") + ")");
// ROM hashes
var crc32 = data.GetHash(HashFlags.RomHash | HashFlags.CRC32);
var sha1 = data.GetHash(HashFlags.RomHash | HashFlags.SHA1);
if (crc32 != null)
{
builder.AddData(general, RomHash.GetHashName(HashFlags.RomHash | HashFlags.CRC32), Hex.FormatHex(crc32.Value));
}
if (sha1 != null)
{
builder.AddData(general, RomHash.GetHashName(HashFlags.RomHash | HashFlags.SHA1), Hex.FormatHex(sha1.Value));
}
// File hashes as a last resort when ROM hashes aren't present
if (crc32 == null)
{
crc32 = data.GetHash(HashFlags.FileHash | HashFlags.CRC32);
if (crc32 != null)
{
builder.AddData(general, RomHash.GetHashName(HashFlags.FileHash | HashFlags.CRC32), Hex.FormatHex(crc32.Value));
}
}
if (sha1 == null)
{
sha1 = data.GetHash(HashFlags.FileHash | HashFlags.SHA1);
if (sha1 != null)
{
builder.AddData(general, RomHash.GetHashName(HashFlags.FileHash | HashFlags.SHA1), Hex.FormatHex(sha1.Value));
}
}
for (int i = 0; i < data.DatabaseMatches.Count; i++)
{
var match = data.DatabaseMatches[i];
builder.AddData(general, match.Database.Name + " entry", match.Entry.name);
}
for (int i = 0; i < data.Hashes.Count; i++)
{
builder.AddData(
RomExDataBuilder.HashesCat,
RomHash.GetHashName(data.Hashes[i].Type),
Hex.FormatHex(data.Hashes[i].Value));
}
}
private static void AddDbMatches(RomData data, List <DBMatch> matches, RomDB db)
{
var dbmatches = db.FindMatches(data.Hashes);
for (int i = 0; i < dbmatches.Count; i++)
{
matches.Add(new DBMatch(db, dbmatches[i]));
}
}
/// <summary>
/// Gets extended information for a ROM and associated RomData object.
/// </summary>
/// <param name="rom">A ROM file</param>
/// <param name="data">A RomData object with Platform and Hashes properties initialized.</param>
/// <returns></returns>
public IList <RomDataCategory> GetExtendedInfo(byte[] rom, RomData data)
{
var result = new RomExDataBuilder();
AddStandardData(result, rom, data);
AddPlatformExtendedData(result, rom, data);
return(result);
}
/// <summary>
/// Identifies whether the specified RomData object has been marked as byte-swapped
/// </summary>
/// <param name="data">RomData object to examine</param>
/// <returns>True if the RomData object has tag indicating it is byte-swapped</returns>
public static N64ByteSwap IsByteswapped(RomData data)
{
object value;
data.MiscData.TryGetValue(ByteswapTagID, out value);
if (value is N64ByteSwap)
{
return((N64ByteSwap)value);
}
return(N64ByteSwap.Unknown);
}
internal override void InitRomData(RomData data, byte[] rom)
{
base.InitRomData(data, rom);
int romOffset = SNES.HasExternalHeader(rom) ? SNES.ExternalHeaderSize : 0;
if (rom.Length - romOffset >= SnesHeader.MinimumRomSize)
{
SnesHeader snesheader = new SnesHeader(rom, romOffset);
data.MiscData.Add(DataTags.DecodedHeader, snesheader);
}
}
internal override void InitRomData(RomData data, byte[] rom)
{
base.InitRomData(data, rom);
bool eHeader, iHeader, interleaved, s32X;
iHeader = Gen.HasInternalHeader(rom, out interleaved, out eHeader, out s32X);
if (s32X)
{
data.MiscData.Add(Tag_32x, Tag_32x);
}
}
void worker_DoWork(object sender, DoWorkEventArgs e)
{
// Do stuff!
Hashes = _Hashes.AsReadOnly();
var rom = File.ReadAllBytes(RomPath);
if (rom.Length > Program.Config.FileSizeForImmediateBusyWindow)
{
immediateBusyForm = true;
UpdateBusyDisplay();
}
Platform platform = null;
string miscPlatform = null;
if (PromptForPlatform)
{
RomData.GetRomPlatform(rom, Path.GetExtension(RomPath).TrimStart('.'), "Select a platform.", "Select Platform", out platform, out miscPlatform);
}
else
{
RomData.GetRomPlatform(rom, Path.GetExtension(RomPath).TrimStart('.'), out platform, out miscPlatform);
}
bool userCancelledDialog = (platform == null); // See RomData.GetRomPlatform documentation
if (userCancelledDialog)
{
this.Platform = null;
Result = null;
}
else
{
this.Platform = platform;
Result = RomData.GetRomData(rom, platform, miscPlatform, !IsSecondaryROM, !IsSecondaryROM, this);
}
lock (StatusLock) {
Working = false;
if (Result == null)
{
Aborted = true;
}
else
{
Complete = true;
}
}
}
/// <summary>
/// Finds ROM database matches for a given RomData object, and populates the RomData object with those matches.
/// </summary>
/// <param name="data">A RomData object that has its hash list populated but not its db match list</param>
private static void FindDbMatches(RomData data)
{
List <DBMatch> matches = new List <DBMatch>();
if (data.Platform != null)
{
List <RomDB> processedDbs = new List <RomDB>();
// Recognized systems
foreach (var db in RomDB.GetDBs(data.Platform.ID))
{
AddDbMatches(data, matches, db);
processedDbs.Add(db);
}
if (!string.IsNullOrEmpty(data.MiscPlatform))
{
// Unrecognized system
foreach (var db in RomDB.GetAllDBs())
{
// Don't process same DB twice
bool platformMatch = false;
foreach (var platform in db.MiscPlatforms)
{
if (platform.Equals(data.MiscPlatform, StringComparison.OrdinalIgnoreCase))
{
platformMatch = true;
}
}
if (platformMatch)
{
AddDbMatches(data, matches, db);
processedDbs.Add(db);
}
}
}
}
data.DatabaseMatches = matches.AsReadOnly();
}
/// <summary>
/// Attempts to find the specified hash and append it to the string builder for RHDN-specific output.
/// </summary>
/// <param name="hashtype">The hash type (i.e. CRC32/MD5/SHA1). File/ROM/PRG/CHR should NOT be specified.</param>
/// <returns>True if ANYTHING was appended to the string builder.</returns>
/// <param name="rom"></param>
/// <param name="sb"></param>
private static bool AddHashToSB(StringBuilder sb, RomData rom, HashFlags hashtype)
{
string hashname = RomHash.GetHashName(HashFlags.RomHash | hashtype);
var hash = rom.GetHash(HashFlags.RomHash | hashtype);
if (hash == null)
{
hashname = hashname = RomHash.GetHashName(HashFlags.FileHash | hashtype);;
hash = rom.GetHash(HashFlags.FileHash | hashtype);
}
if (hash == null)
{
return(false);
}
sb.AppendLine(hashname + ": " + Hex.FormatHex(hash.Value));
return(true);
}
void secondaryHasher_WorkComplete(object sender, EventArgs e)
{
var hj = ((HashJob)sender);
hj.WorkComplete -= secondaryHasher_WorkComplete;
hj.WorkAborted -= secondaryHasher_Aborted;
if (this.IsDisposed)
{
return;
}
if (hj.Complete)
{
SecondaryRom = hj.Result;
SecondaryRomPath = pending_SecondaryRomPath;
SecondaryRomFilename = pending_SecondaryRomFilename;
UpdateRomDisplay(false);
}
ExitBusyMode();
}
protected override void AddPlatformExtendedData(Platform.RomExDataBuilder builder, byte[] rom, RomData data)
{
// Nope
}
internal override void InitRomData(RomData data, byte[] rom)
{
base.InitRomData(data, rom);
}
internal bool Is32X(RomData data)
{
return(data.MiscData.ContainsKey(Tag_32x));
}
protected override void AddPlatformExtendedData(Platform.RomExDataBuilder builder, byte[] rom, RomData data)
{
builder.AddData(RomExDataBuilder.GeneralCat, "Byte-swapped", N64.IsByteswapped(rom).GetDescription());
}
protected override void AddPlatformExtendedData(RomExDataBuilder builder, byte[] rom, RomData data)
{
byte[] romImage;
// If our previously de-interleaved ROM is still in memory, use that instead of re-de-interleaving
if (BinRomImage == null)
{
romImage = GetBinFormat(rom);
}
else
{
romImage = BinRomImage.Target as byte[];
if (romImage == null)
{
romImage = GetBinFormat(rom);
}
}
bool interleaved, ext, s32x;
bool InternalHeaderFound = Gen.HasInternalHeader(rom, out interleaved, out ext, out s32x);
builder.AddData(RomExDataBuilder.GeneralCat, "32X", s32x.AsYesNo());
builder.AddData(RomExDataBuilder.GeneralCat, "Internal Header Found", InternalHeaderFound.AsYesNo());
builder.AddData(RomExDataBuilder.GeneralCat, "Interleaved", interleaved.AsYesNo());
if (InternalHeaderFound)
{
const string hdr = RomExDataBuilder.HeaderCat;
GenHeader header = new GenHeader(romImage);
builder.AddData(hdr, "Platform", header.Platform);
builder.AddData(hdr, "Name", header.GameName);
builder.AddData(hdr, "International Name", header.AltName);
builder.AddData(hdr, "Copyright", GetCopyrightString(header.Copyright));
builder.AddData(hdr, "Memo", header.Memo);
builder.AddData(hdr, "Modem", header.Modem);
builder.AddData(hdr, "Product Type/ID", header.ProductID);
builder.AddData(hdr, "Region", header.Region);
builder.AddData(hdr, "ROM range", header.RomStart.ToString("X8") + "-" + header.RomEnd.ToString("X8"));
builder.AddData(hdr, "RAM range", header.RamStart.ToString("X8") + "-" + header.RamEnd.ToString("X8"));
builder.AddData(hdr, "Checksum", header.Checksum.ToString("X4"));
builder.AddData(hdr, "IO Devices", GetIOString(header.IOSupport));
}
}
protected override void AddPlatformExtendedData(RomExDataBuilder builder, byte[] rom, RomData data)
{
if (rom.Length >= GbHeader.GbHeaderOffset + GbHeader.GbHeaderSize)
{
var HeaderCat = RomExDataBuilder.HeaderCat;
var header = new GbHeader(rom, GbHeader.GbHeaderOffset);
builder.AddData(RomExDataBuilder.GeneralCat, "ROM checksum", header.RomChecksum.ToString("X4"));
builder.AddData(RomExDataBuilder.GeneralCat, "Checksum valid", header.RomChecksumValid.AsYesNo());
builder.AddData(HeaderCat, "Logo present", header.ValidGbLogo.AsYesNo());
builder.AddData(HeaderCat, "Header checksum", header.HeaderChecksum.ToString("X2"));
builder.AddData(HeaderCat, "Header checksum valid", header.HeaderChecksumValid.AsYesNo());
builder.AddData(HeaderCat, "ROM checksum", header.RomChecksum.ToString("X4"));
builder.AddData(HeaderCat, "ROM checksum valid", header.RomChecksumValid.AsYesNo());
builder.AddData(HeaderCat, "Title", header.Title);
builder.AddData(HeaderCat, "Manufacturer", header.Manufacturer);
builder.AddData(HeaderCat, "Gameboy Color support", header.CGBFlag.GetDescription());
builder.AddData(HeaderCat, "Super Gameboy support", header.SupportsSgb.AsYesNo());
builder.AddData(HeaderCat, "Cart type", header.CartType.GetDescription());
builder.AddData(HeaderCat, "ROM size", header.RomSize.GetDescription());
builder.AddData(HeaderCat, "RAM size", header.RamSize.GetDescription());
builder.AddData(HeaderCat, "Mask ROM version", header.RomVersion.ToString());
builder.AddData(HeaderCat, "Licensee code", "$" + header.Licensee.ToString("X2"));
builder.AddData(HeaderCat, "Licensee code (extended)", header.LicenseeEx);
}
}
/// <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);
}
/// <summary>
/// This is the first method called when initializing a RomData object.
/// Platform-specific information can be calculated and stored in the
/// RomData's MiscData collection.
/// </summary>
internal virtual void InitRomData(RomData data, byte[] rom)
{
}
internal override void InitRomData(RomData data, byte[] rom)
{
base.InitRomData(data, rom);
data.MiscData.Add(ByteswapTagID, N64.IsByteswapped(rom));
}
/// <summary> /// Override this method to populate the extended ROM data. /// </summary> /// <param name="builder">An object to assist in populating extended ROM data.</param> /// <param name="rom">ROM file</param> /// <param name="data">RomData object that has Platform and Hashes properties initialized.</param> protected abstract void AddPlatformExtendedData(RomExDataBuilder builder, byte[] rom, RomData data);
protected override void AddPlatformExtendedData(RomExDataBuilder builder, byte[] rom, RomData data)
{
if (rom.Length >= GbaHeader.GbaHeaderSize)
{
var HeaderCat = RomExDataBuilder.HeaderCat;
var header = new GbaHeader(rom, 0);
builder.AddData(HeaderCat, "Logo present", header.ValidGbaLogo.AsYesNo());
builder.AddData(HeaderCat, "Header checksum", header.HeaderChecksum.ToString("X2"));
builder.AddData(HeaderCat, "Header checksum valid", header.HeaderChecksumValid.AsYesNo());
builder.AddData(HeaderCat, "Title", header.Title);
builder.AddData(HeaderCat, "Game Maker", header.MakerCode);
builder.AddData(HeaderCat, "Game Code", header.GameCode);
builder.AddData(HeaderCat, "Mask ROM version", header.RomVersion.ToString());
}
}
protected override void AddPlatformExtendedData(RomExDataBuilder builder, byte[] rom, RomData data)
{
var checksum = SNES.CalculateChecksum(rom);
int romOffset = SNES.HasExternalHeader(rom) ? SNES.ExternalHeaderSize : 0;
string header = RomExDataBuilder.HeaderCat;
object o_snesheader;
SnesHeader snesheader;
if (data.MiscData.TryGetValue(DataTags.DecodedHeader, out o_snesheader))
{
//if (snesheader != null) {
snesheader = o_snesheader as SnesHeader;
builder.AddData(RomExDataBuilder.GeneralCat, "Checksum valid", (checksum == snesheader.Checksum) ? "Yes" : "No");
builder.AddData(header, "Mapping", snesheader.Mapping.ToString());
//builder.AddData(header,"Name", GetAscii
}
}
protected override void AddPlatformExtendedData(RomExDataBuilder builder, byte[] rom, RomData data)
{
var HeaderCat = RomExDataBuilder.HeaderCat;
if (rom.Length < 0x10)
{
return;
}
var header = new iNesHeader(rom, 0);
if (header.MagicNumberIsCorrect)
{
builder.AddData(HeaderCat, "CHR Banks", header.ChrRomCount.ToString());
builder.AddData(HeaderCat, "PRG Banks", header.PrgRomCount.ToString());
builder.AddData(HeaderCat, "Battery backed", header.BatteryPacked ? "Yes" : "No");
if ((int)header.Mapper > 9)
{
builder.AddData(HeaderCat, "Mapper", ((int)header.Mapper).ToString() + " ($" + (((int)header.Mapper).ToString("x")) + ") - " + header.Mapper.ToString());
}
else
{
builder.AddData(HeaderCat, "Mapper", ((int)header.Mapper).ToString() + " - " + header.Mapper.ToString());
}
builder.AddData(HeaderCat, "Mirroring", header.Mirroring.ToString());
builder.AddData(HeaderCat, "Region", header.PalFlagSet ? "PAL" : "NTSC");;
//builder.AddData(HeaderCat, "SRAM Present", header.SRamFlag ? "Yes" : "No"); ;
//builder.AddData(HeaderCat, "SRAM Size", (header.PrgRamCount * 8).ToString() + " kb");
builder.AddData(HeaderCat, "Trainer present", header.HasTrainer ? "Yes" : "No");
builder.AddData(HeaderCat, "Bus conflicts", header.HasBusConflicts ? "Yes" : "No");
builder.AddData(HeaderCat, "VS Unisystem", header.VsUnisystem ? "Yes" : "No");
builder.AddData(HeaderCat, "Playchoice 10", header.PlayChoice10 ? "Yes" : "No");
builder.AddData(HeaderCat, "iNES 2.0", header.iNES2_0 ? "Yes" : "No");
}
}
protected override void AddPlatformExtendedData(Platform.RomExDataBuilder builder, byte[] rom, RomData data)
{
string headerCat = RomExDataBuilder.HeaderCat;
SmsHeader header = new SmsHeader(rom, SmsHeader.HeaderOffset);
builder.AddData(RomExDataBuilder.GeneralCat, "Checksum valid", header.ChecksumValid.AsYesNo());
builder.AddData(headerCat, "Header present", header.HeaderPresent.AsYesNo());
builder.AddData(headerCat, "Checksum", header.Checksum.ToString("X4"));
builder.AddData(headerCat, "Checksum valid", header.ChecksumValid.AsYesNo());
if (header.HeaderPresent)
{
builder.AddData(headerCat, "Product Code", header.ProductCode);
builder.AddData(headerCat, "Region", header.Region.GetDescription());
builder.AddData(headerCat, "Version", header.Version.ToString());
builder.AddData(headerCat, "Size", header.Size.GetDescription());
}
}
protected override void AddPlatformExtendedData(RomExDataBuilder builder, byte[] rom, RomData data)
{
//var HeaderCat = RomExDataBuilder.HeaderCat;
}
