mirror of
https://github.com/aaru-dps/Aaru.git
synced 2025-12-16 19:24:25 +00:00
452 lines
15 KiB
C#
452 lines
15 KiB
C#
// /***************************************************************************
|
|
// Aaru Data Preservation Suite
|
|
// ----------------------------------------------------------------------------
|
|
//
|
|
// Filename : Retrode.cs
|
|
// Author(s) : Natalia Portillo <claunia@claunia.com>
|
|
//
|
|
// Component : Dumping SNES/MD/GEN/MS/N64/GB/GB/GBA carts with a Retrode.
|
|
//
|
|
// --[ Description ] ----------------------------------------------------------
|
|
//
|
|
// Handles dumping using a Retrode.
|
|
//
|
|
// --[ License ] --------------------------------------------------------------
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as
|
|
// published by the Free Software Foundation, either version 3 of the
|
|
// License, or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
// Copyright © 2011-2022 Natalia Portillo
|
|
// ****************************************************************************/
|
|
|
|
namespace Aaru.Core.Devices.Dumping;
|
|
|
|
using System;
|
|
using System.Linq;
|
|
using Aaru.CommonTypes;
|
|
using Aaru.CommonTypes.Enums;
|
|
using Aaru.CommonTypes.Interfaces;
|
|
using Aaru.CommonTypes.Structs;
|
|
using Version = Aaru.CommonTypes.Interop.Version;
|
|
|
|
public partial class Dump
|
|
{
|
|
static readonly byte[] _sfcExtension =
|
|
{
|
|
0x53, 0x46, 0x43
|
|
};
|
|
|
|
static readonly byte[] _genesisExtension =
|
|
{
|
|
0x42, 0x49, 0x4E
|
|
};
|
|
|
|
static readonly byte[] _smsExtension =
|
|
{
|
|
0x53, 0x4D, 0x53
|
|
};
|
|
|
|
static readonly byte[] _z64Extension =
|
|
{
|
|
0x5A, 0x36, 0x34
|
|
};
|
|
|
|
static readonly byte[] _gbExtension =
|
|
{
|
|
0x47, 0x42, 0x20
|
|
};
|
|
|
|
static readonly byte[] _gbcExtension =
|
|
{
|
|
0x47, 0x42, 0x43
|
|
};
|
|
|
|
static readonly byte[] _gbaExtension =
|
|
{
|
|
0x47, 0x42, 0x41
|
|
};
|
|
|
|
/// <summary>Dumps a game cartridge using a Retrode adapter</summary>
|
|
void Retrode()
|
|
{
|
|
bool sense = _dev.Read10(out byte[] buffer, out _, 0, false, true, false, false, 0, 512, 0, 1, _dev.Timeout,
|
|
out _);
|
|
|
|
if(sense)
|
|
{
|
|
_dumpLog.WriteLine("Could not read...");
|
|
StoppingErrorMessage?.Invoke("Could not read...");
|
|
|
|
return;
|
|
}
|
|
|
|
var tmp = new byte[8];
|
|
|
|
Array.Copy(buffer, 0x36, tmp, 0, 8);
|
|
|
|
// UMDs are stored inside a FAT16 volume
|
|
if(!tmp.SequenceEqual(_fatSignature))
|
|
{
|
|
_dumpLog.WriteLine("Retrode partition not recognized, not dumping...");
|
|
StoppingErrorMessage?.Invoke("Retrode partition not recognized, not dumping...");
|
|
|
|
return;
|
|
}
|
|
|
|
var fatStart = (ushort)((buffer[0x0F] << 8) + buffer[0x0E]);
|
|
var sectorsPerFat = (ushort)((buffer[0x17] << 8) + buffer[0x16]);
|
|
var rootStart = (ushort)(sectorsPerFat * 2 + fatStart);
|
|
var rootSize = (ushort)(((buffer[0x12] << 8) + buffer[0x11]) * 32 / 512);
|
|
byte sectorsPerCluster = buffer[0x0D];
|
|
|
|
UpdateStatus?.Invoke($"Reading root directory in sector {rootStart}...");
|
|
_dumpLog.WriteLine("Reading root directory in sector {0}...", rootStart);
|
|
|
|
sense = _dev.Read10(out buffer, out _, 0, false, true, false, false, rootStart, 512, 0, 1, _dev.Timeout, out _);
|
|
|
|
if(sense)
|
|
{
|
|
StoppingErrorMessage?.Invoke("Could not read...");
|
|
_dumpLog.WriteLine("Could not read...");
|
|
|
|
return;
|
|
}
|
|
|
|
int romPos;
|
|
var sfcFound = false;
|
|
var genesisFound = false;
|
|
var smsFound = false;
|
|
var n64Found = false;
|
|
var gbFound = false;
|
|
var gbcFound = false;
|
|
var gbaFound = false;
|
|
tmp = new byte[3];
|
|
|
|
for(romPos = 0; romPos < buffer.Length; romPos += 0x20)
|
|
{
|
|
Array.Copy(buffer, romPos + 8, tmp, 0, 3);
|
|
|
|
if(tmp.SequenceEqual(_sfcExtension))
|
|
{
|
|
sfcFound = true;
|
|
|
|
break;
|
|
}
|
|
|
|
if(tmp.SequenceEqual(_genesisExtension))
|
|
{
|
|
genesisFound = true;
|
|
|
|
break;
|
|
}
|
|
|
|
if(tmp.SequenceEqual(_smsExtension))
|
|
{
|
|
smsFound = true;
|
|
|
|
break;
|
|
}
|
|
|
|
if(tmp.SequenceEqual(_z64Extension))
|
|
{
|
|
n64Found = true;
|
|
|
|
break;
|
|
}
|
|
|
|
if(tmp.SequenceEqual(_gbExtension))
|
|
{
|
|
gbFound = true;
|
|
|
|
break;
|
|
}
|
|
|
|
if(tmp.SequenceEqual(_gbcExtension))
|
|
{
|
|
gbcFound = true;
|
|
|
|
break;
|
|
}
|
|
|
|
if(tmp.SequenceEqual(_gbaExtension))
|
|
{
|
|
gbaFound = true;
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(!sfcFound &&
|
|
!genesisFound &&
|
|
!smsFound &&
|
|
!n64Found)
|
|
{
|
|
StoppingErrorMessage?.Invoke("No cartridge found, not dumping...");
|
|
_dumpLog.WriteLine("No cartridge found, not dumping...");
|
|
|
|
return;
|
|
}
|
|
|
|
var cluster = BitConverter.ToUInt16(buffer, romPos + 0x1A);
|
|
var romSize = BitConverter.ToUInt32(buffer, romPos + 0x1C);
|
|
|
|
MediaType mediaType = gbaFound
|
|
? MediaType.GameBoyAdvanceGamePak
|
|
: gbFound || gbcFound
|
|
? MediaType.GameBoyGamePak
|
|
: n64Found
|
|
? MediaType.N64GamePak
|
|
: smsFound
|
|
? MediaType.MasterSystemCartridge
|
|
: genesisFound
|
|
? MediaType.MegaDriveCartridge
|
|
: MediaType.SNESGamePak;
|
|
|
|
uint blocksToRead = 64;
|
|
double totalDuration = 0;
|
|
double currentSpeed = 0;
|
|
double maxSpeed = double.MinValue;
|
|
double minSpeed = double.MaxValue;
|
|
byte[] senseBuf;
|
|
|
|
if(_outputPlugin is not IByteAddressableImage outputBai ||
|
|
!outputBai.SupportedMediaTypes.Contains(mediaType))
|
|
{
|
|
_dumpLog.WriteLine("The specified format does not support the inserted cartridge...");
|
|
StoppingErrorMessage?.Invoke("The specified format does not support the inserted cartridge...");
|
|
|
|
return;
|
|
}
|
|
|
|
sense = _dev.Read10(out byte[] readBuffer, out _, 0, false, true, false, false, 0, 512, 0, 1, _dev.Timeout,
|
|
out _);
|
|
|
|
if(sense)
|
|
{
|
|
_dumpLog.WriteLine("Could not read...");
|
|
StoppingErrorMessage?.Invoke("Could not read...");
|
|
|
|
return;
|
|
}
|
|
|
|
var startSector = (uint)(rootStart + rootSize + (cluster - 2) * sectorsPerCluster);
|
|
uint romSectors = romSize / 512;
|
|
uint romRemaining = romSize % 512;
|
|
|
|
if(romSize > 1073741824)
|
|
UpdateStatus?.Invoke($"Cartridge has {romSize} bytes ({romSize / 1073741824d:F3} GiB)");
|
|
else if(romSize > 1048576)
|
|
UpdateStatus?.Invoke($"Cartridge has {romSize} bytes ({romSize / 1048576d:F3} MiB)");
|
|
else if(romSize > 1024)
|
|
UpdateStatus?.Invoke($"Cartridge has {romSize} bytes ({romSize / 1024d:F3} KiB)");
|
|
else
|
|
UpdateStatus?.Invoke($"Cartridge has {romSize} bytes");
|
|
|
|
UpdateStatus?.Invoke($"Media identified as {mediaType}.");
|
|
_dumpLog.WriteLine("Media identified as {0}.", mediaType);
|
|
|
|
ErrorNumber ret = outputBai.Create(_outputPath, mediaType, _formatOptions, romSize);
|
|
|
|
// Cannot create image
|
|
if(ret != ErrorNumber.NoError)
|
|
{
|
|
_dumpLog.WriteLine("Error {0} creating output image, not continuing.", ret);
|
|
_dumpLog.WriteLine(outputBai.ErrorMessage);
|
|
|
|
StoppingErrorMessage?.Invoke("Error creating output image, not continuing." + Environment.NewLine +
|
|
outputBai.ErrorMessage);
|
|
|
|
return;
|
|
}
|
|
|
|
DateTime start = DateTime.UtcNow;
|
|
double imageWriteDuration = 0;
|
|
|
|
DateTime timeSpeedStart = DateTime.UtcNow;
|
|
ulong sectorSpeedStart = 0;
|
|
InitProgress?.Invoke();
|
|
|
|
for(ulong i = 0; i < romSectors; i += blocksToRead)
|
|
{
|
|
if(_aborted)
|
|
{
|
|
UpdateStatus?.Invoke("Aborted!");
|
|
_dumpLog.WriteLine("Aborted!");
|
|
|
|
break;
|
|
}
|
|
|
|
if(romSectors - i < blocksToRead)
|
|
blocksToRead = (uint)(romSectors - i);
|
|
|
|
if(currentSpeed > maxSpeed &&
|
|
currentSpeed > 0)
|
|
maxSpeed = currentSpeed;
|
|
|
|
if(currentSpeed < minSpeed &&
|
|
currentSpeed > 0)
|
|
minSpeed = currentSpeed;
|
|
|
|
UpdateProgress?.Invoke($"Reading byte {i * 512} of {romSize} ({currentSpeed:F3} MiB/sec.)", (long)i * 512,
|
|
romSize);
|
|
|
|
sense = _dev.Read10(out readBuffer, out senseBuf, 0, false, true, false, false, (uint)(startSector + i),
|
|
512, 0, (ushort)blocksToRead, _dev.Timeout, out double cmdDuration);
|
|
|
|
totalDuration += cmdDuration;
|
|
|
|
if(!sense &&
|
|
!_dev.Error)
|
|
{
|
|
DateTime writeStart = DateTime.Now;
|
|
outputBai.WriteBytes(readBuffer, 0, readBuffer.Length, out _);
|
|
imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
|
|
}
|
|
else
|
|
{
|
|
_errorLog?.WriteLine(i, _dev.Error, _dev.LastError, senseBuf);
|
|
|
|
// TODO: Reset device after X errors
|
|
if(_stopOnError)
|
|
return; // TODO: Return more cleanly
|
|
|
|
_dumpLog.WriteLine("Skipping {0} bytes from errored byte {1}.", _skip * 512, i * 512);
|
|
i += _skip - blocksToRead;
|
|
}
|
|
|
|
sectorSpeedStart += blocksToRead;
|
|
|
|
double elapsed = (DateTime.UtcNow - timeSpeedStart).TotalSeconds;
|
|
|
|
if(elapsed <= 0)
|
|
continue;
|
|
|
|
currentSpeed = sectorSpeedStart * 512 / (1048576 * elapsed);
|
|
sectorSpeedStart = 0;
|
|
timeSpeedStart = DateTime.UtcNow;
|
|
}
|
|
|
|
if(romRemaining > 0 &&
|
|
!_aborted)
|
|
{
|
|
if(currentSpeed > maxSpeed &&
|
|
currentSpeed > 0)
|
|
maxSpeed = currentSpeed;
|
|
|
|
if(currentSpeed < minSpeed &&
|
|
currentSpeed > 0)
|
|
minSpeed = currentSpeed;
|
|
|
|
UpdateProgress?.Invoke($"Reading byte {romSectors * 512} of {romSize} ({currentSpeed:F3} MiB/sec.)",
|
|
(long)romSectors * 512, romSize);
|
|
|
|
sense = _dev.Read10(out readBuffer, out senseBuf, 0, false, true, false, false, romSectors, 512, 0, 1,
|
|
_dev.Timeout, out double cmdDuration);
|
|
|
|
totalDuration += cmdDuration;
|
|
|
|
if(!sense &&
|
|
!_dev.Error)
|
|
{
|
|
DateTime writeStart = DateTime.Now;
|
|
outputBai.WriteBytes(readBuffer, 0, (int)romRemaining, out _);
|
|
imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
|
|
}
|
|
else
|
|
{
|
|
_errorLog?.WriteLine(romSectors, _dev.Error, _dev.LastError, senseBuf);
|
|
|
|
// TODO: Reset device after X errors
|
|
if(_stopOnError)
|
|
return; // TODO: Return more cleanly
|
|
|
|
_dumpLog.WriteLine("Skipping {0} bytes from errored byte {1}.", _skip * 512, romSectors * 512);
|
|
}
|
|
}
|
|
|
|
DateTime end = DateTime.UtcNow;
|
|
EndProgress?.Invoke();
|
|
|
|
UpdateStatus?.Invoke($"Dump finished in {(end - start).TotalSeconds} seconds.");
|
|
|
|
UpdateStatus?.
|
|
Invoke($"Average dump speed {512 * (double)(romSectors + 1) / 1024 / (totalDuration / 1000):F3} KiB/sec.");
|
|
|
|
UpdateStatus?.
|
|
Invoke($"Average write speed {512 * (double)(romSectors + 1) / 1024 / imageWriteDuration:F3} KiB/sec.");
|
|
|
|
_dumpLog.WriteLine("Dump finished in {0} seconds.", (end - start).TotalSeconds);
|
|
|
|
_dumpLog.WriteLine("Average dump speed {0:F3} KiB/sec.",
|
|
512 * (double)(romSectors + 1) / 1024 / (totalDuration / 1000));
|
|
|
|
_dumpLog.WriteLine("Average write speed {0:F3} KiB/sec.",
|
|
512 * (double)(romSectors + 1) / 1024 / imageWriteDuration);
|
|
|
|
var metadata = new ImageInfo
|
|
{
|
|
Application = "Aaru",
|
|
ApplicationVersion = Version.GetVersion()
|
|
};
|
|
|
|
if(!outputBai.SetMetadata(metadata))
|
|
ErrorMessage?.Invoke("Error {0} setting metadata, continuing..." + Environment.NewLine +
|
|
outputBai.ErrorMessage);
|
|
|
|
// TODO: Set dump hardware
|
|
//outputBAI.SetDumpHardware();
|
|
|
|
if(_preSidecar != null)
|
|
outputBai.SetCicmMetadata(_preSidecar);
|
|
|
|
_dumpLog.WriteLine("Closing output file.");
|
|
UpdateStatus?.Invoke("Closing output file.");
|
|
DateTime closeStart = DateTime.Now;
|
|
outputBai.Close();
|
|
DateTime closeEnd = DateTime.Now;
|
|
_dumpLog.WriteLine("Closed in {0} seconds.", (closeEnd - closeStart).TotalSeconds);
|
|
|
|
if(_aborted)
|
|
{
|
|
UpdateStatus?.Invoke("Aborted!");
|
|
_dumpLog.WriteLine("Aborted!");
|
|
|
|
return;
|
|
}
|
|
|
|
double totalChkDuration = 0;
|
|
|
|
/* TODO: Create sidecar
|
|
if(_metadata)
|
|
WriteOpticalSidecar(blockSize, blocks, mediaType, null, null, 1, out totalChkDuration, null);
|
|
*/
|
|
UpdateStatus?.Invoke("");
|
|
|
|
UpdateStatus?.
|
|
Invoke($"Took a total of {(end - start).TotalSeconds:F3} seconds ({totalDuration / 1000:F3} processing commands, {totalChkDuration / 1000:F3} checksumming, {imageWriteDuration:F3} writing, {(closeEnd - closeStart).TotalSeconds:F3} closing).");
|
|
|
|
UpdateStatus?.
|
|
Invoke($"Average speed: {512 * (double)(romSectors + 1) / 1048576 / (totalDuration / 1000):F3} MiB/sec.");
|
|
|
|
if(maxSpeed > 0)
|
|
UpdateStatus?.Invoke($"Fastest speed burst: {maxSpeed:F3} MiB/sec.");
|
|
|
|
if(minSpeed is > 0 and < double.MaxValue)
|
|
UpdateStatus?.Invoke($"Slowest speed burst: {minSpeed:F3} MiB/sec.");
|
|
|
|
UpdateStatus?.Invoke("");
|
|
|
|
Statistics.AddMedia(mediaType, true);
|
|
}
|
|
} |