public static int Invoke(bool verbose, bool debug, string cicmXml, string comments, int count, string creator,
string driveFirmwareRevision, string driveManufacturer, string driveModel,
string driveSerialNumber, bool force, string inputPath, int lastMediaSequence,
string mediaBarcode, string mediaManufacturer, string mediaModel,
string mediaPartNumber, int mediaSequence, string mediaSerialNumber, string mediaTitle,
string outputPath, string outputOptions, string resumeFile, string format)
{
MainClass.PrintCopyright();
if (debug)
{
AaruConsole.DebugWriteLineEvent += System.Console.Error.WriteLine;
}
if (verbose)
{
AaruConsole.VerboseWriteLineEvent += System.Console.WriteLine;
}
Statistics.AddCommand("convert-image");
AaruConsole.DebugWriteLine("Analyze command", "--cicm-xml={0}", cicmXml);
AaruConsole.DebugWriteLine("Analyze command", "--comments={0}", comments);
AaruConsole.DebugWriteLine("Analyze command", "--count={0}", count);
AaruConsole.DebugWriteLine("Analyze command", "--creator={0}", creator);
AaruConsole.DebugWriteLine("Analyze command", "--debug={0}", debug);
AaruConsole.DebugWriteLine("Analyze command", "--drive-manufacturer={0}", driveManufacturer);
AaruConsole.DebugWriteLine("Analyze command", "--drive-model={0}", driveModel);
AaruConsole.DebugWriteLine("Analyze command", "--drive-revision={0}", driveFirmwareRevision);
AaruConsole.DebugWriteLine("Analyze command", "--drive-serial={0}", driveSerialNumber);
AaruConsole.DebugWriteLine("Analyze command", "--force={0}", force);
AaruConsole.DebugWriteLine("Analyze command", "--format={0}", format);
AaruConsole.DebugWriteLine("Analyze command", "--input={0}", inputPath);
AaruConsole.DebugWriteLine("Analyze command", "--media-barcode={0}", mediaBarcode);
AaruConsole.DebugWriteLine("Analyze command", "--media-lastsequence={0}", lastMediaSequence);
AaruConsole.DebugWriteLine("Analyze command", "--media-manufacturer={0}", mediaManufacturer);
AaruConsole.DebugWriteLine("Analyze command", "--media-model={0}", mediaModel);
AaruConsole.DebugWriteLine("Analyze command", "--media-partnumber={0}", mediaPartNumber);
AaruConsole.DebugWriteLine("Analyze command", "--media-sequence={0}", mediaSequence);
AaruConsole.DebugWriteLine("Analyze command", "--media-serial={0}", mediaSerialNumber);
AaruConsole.DebugWriteLine("Analyze command", "--media-title={0}", mediaTitle);
AaruConsole.DebugWriteLine("Analyze command", "--options={0}", outputOptions);
AaruConsole.DebugWriteLine("Analyze command", "--output={0}", outputPath);
AaruConsole.DebugWriteLine("Analyze command", "--resume-file={0}", resumeFile);
AaruConsole.DebugWriteLine("Analyze command", "--verbose={0}", verbose);
Dictionary <string, string> parsedOptions = Core.Options.Parse(outputOptions);
AaruConsole.DebugWriteLine("Analyze command", "Parsed options:");
foreach (KeyValuePair <string, string> parsedOption in parsedOptions)
{
AaruConsole.DebugWriteLine("Analyze command", "{0} = {1}", parsedOption.Key, parsedOption.Value);
}
if (count == 0)
{
AaruConsole.ErrorWriteLine("Need to specify more than 0 sectors to copy at once");
return((int)ErrorNumber.InvalidArgument);
}
Resume resume = null;
CICMMetadataType sidecar = null;
MediaType mediaType;
var xs = new XmlSerializer(typeof(CICMMetadataType));
if (cicmXml != null)
{
if (File.Exists(cicmXml))
{
try
{
var sr = new StreamReader(cicmXml);
sidecar = (CICMMetadataType)xs.Deserialize(sr);
sr.Close();
}
catch (Exception ex)
{
AaruConsole.ErrorWriteLine("Incorrect metadata sidecar file, not continuing...");
AaruConsole.DebugWriteLine("Image conversion", $"{ex}");
return((int)ErrorNumber.InvalidSidecar);
}
}
else
{
AaruConsole.ErrorWriteLine("Could not find metadata sidecar, not continuing...");
return((int)ErrorNumber.FileNotFound);
}
}
xs = new XmlSerializer(typeof(Resume));
if (resumeFile != null)
{
if (File.Exists(resumeFile))
{
try
{
var sr = new StreamReader(resumeFile);
resume = (Resume)xs.Deserialize(sr);
sr.Close();
}
catch (Exception ex)
{
AaruConsole.ErrorWriteLine("Incorrect resume file, not continuing...");
AaruConsole.DebugWriteLine("Image conversion", $"{ex}");
return((int)ErrorNumber.InvalidResume);
}
}
else
{
AaruConsole.ErrorWriteLine("Could not find resume file, not continuing...");
return((int)ErrorNumber.FileNotFound);
}
}
var filtersList = new FiltersList();
IFilter inputFilter = filtersList.GetFilter(inputPath);
if (inputFilter == null)
{
AaruConsole.ErrorWriteLine("Cannot open specified file.");
return((int)ErrorNumber.CannotOpenFile);
}
if (File.Exists(outputPath))
{
AaruConsole.ErrorWriteLine("Output file already exists, not continuing.");
return((int)ErrorNumber.DestinationExists);
}
PluginBase plugins = GetPluginBase.Instance;
IMediaImage inputFormat = ImageFormat.Detect(inputFilter);
if (inputFormat == null)
{
AaruConsole.WriteLine("Input image format not identified, not proceeding with conversion.");
return((int)ErrorNumber.UnrecognizedFormat);
}
if (verbose)
{
AaruConsole.VerboseWriteLine("Input image format identified by {0} ({1}).", inputFormat.Name,
inputFormat.Id);
}
else
{
AaruConsole.WriteLine("Input image format identified by {0}.", inputFormat.Name);
}
try
{
if (!inputFormat.Open(inputFilter))
{
AaruConsole.WriteLine("Unable to open image format");
AaruConsole.WriteLine("No error given");
return((int)ErrorNumber.CannotOpenFormat);
}
mediaType = inputFormat.Info.MediaType;
// Obsolete types
#pragma warning disable 612
switch (mediaType)
{
case MediaType.SQ1500:
mediaType = MediaType.SyJet;
break;
case MediaType.Bernoulli:
mediaType = MediaType.Bernoulli10;
break;
case MediaType.Bernoulli2:
mediaType = MediaType.BernoulliBox2_20;
break;
}
#pragma warning restore 612
AaruConsole.DebugWriteLine("Convert-image command", "Correctly opened image file.");
AaruConsole.DebugWriteLine("Convert-image command", "Image without headers is {0} bytes.",
inputFormat.Info.ImageSize);
AaruConsole.DebugWriteLine("Convert-image command", "Image has {0} sectors.", inputFormat.Info.Sectors);
AaruConsole.DebugWriteLine("Convert-image command", "Image identifies media type as {0}.", mediaType);
Statistics.AddMediaFormat(inputFormat.Format);
Statistics.AddMedia(mediaType, false);
Statistics.AddFilter(inputFilter.Name);
}
catch (Exception ex)
{
AaruConsole.ErrorWriteLine("Unable to open image format");
AaruConsole.ErrorWriteLine("Error: {0}", ex.Message);
AaruConsole.DebugWriteLine("Convert-image command", "Stack trace: {0}", ex.StackTrace);
return((int)ErrorNumber.CannotOpenFormat);
}
List <IWritableImage> candidates = new List <IWritableImage>();
// Try extension
if (string.IsNullOrEmpty(format))
{
candidates.AddRange(plugins.WritableImages.Values.Where(t =>
t.KnownExtensions.
Contains(Path.GetExtension(outputPath))));
}
// Try Id
else if (Guid.TryParse(format, out Guid outId))
{
candidates.AddRange(plugins.WritableImages.Values.Where(t => t.Id.Equals(outId)));
}
// Try name
else
{
candidates.AddRange(plugins.WritableImages.Values.Where(t => string.Equals(t.Name, format,
StringComparison.
InvariantCultureIgnoreCase)));
}
if (candidates.Count == 0)
{
AaruConsole.WriteLine("No plugin supports requested extension.");
return((int)ErrorNumber.FormatNotFound);
}
if (candidates.Count > 1)
{
AaruConsole.WriteLine("More than one plugin supports requested extension.");
return((int)ErrorNumber.TooManyFormats);
}
IWritableImage outputFormat = candidates[0];
if (verbose)
{
AaruConsole.VerboseWriteLine("Output image format: {0} ({1}).", outputFormat.Name, outputFormat.Id);
}
else
{
AaruConsole.WriteLine("Output image format: {0}.", outputFormat.Name);
}
if (!outputFormat.SupportedMediaTypes.Contains(mediaType))
{
AaruConsole.ErrorWriteLine("Output format does not support media type, cannot continue...");
return((int)ErrorNumber.UnsupportedMedia);
}
foreach (MediaTagType mediaTag in inputFormat.Info.ReadableMediaTags)
{
if (outputFormat.SupportedMediaTags.Contains(mediaTag) || force)
{
continue;
}
AaruConsole.ErrorWriteLine("Converting image will lose media tag {0}, not continuing...", mediaTag);
AaruConsole.ErrorWriteLine("If you don't care, use force option.");
return((int)ErrorNumber.DataWillBeLost);
}
bool useLong = inputFormat.Info.ReadableSectorTags.Count != 0;
foreach (SectorTagType sectorTag in inputFormat.Info.ReadableSectorTags)
{
if (outputFormat.SupportedSectorTags.Contains(sectorTag))
{
continue;
}
if (force)
{
if (sectorTag != SectorTagType.CdTrackFlags &&
sectorTag != SectorTagType.CdTrackIsrc &&
sectorTag != SectorTagType.CdSectorSubchannel)
{
useLong = false;
}
continue;
}
AaruConsole.ErrorWriteLine("Converting image will lose sector tag {0}, not continuing...", sectorTag);
AaruConsole.
ErrorWriteLine("If you don't care, use force option. This will skip all sector tags converting only user data.");
return((int)ErrorNumber.DataWillBeLost);
}
if (!outputFormat.Create(outputPath, mediaType, parsedOptions, inputFormat.Info.Sectors,
inputFormat.Info.SectorSize))
{
AaruConsole.ErrorWriteLine("Error {0} creating output image.", outputFormat.ErrorMessage);
return((int)ErrorNumber.CannotCreateFormat);
}
var metadata = new ImageInfo
{
Application = "Aaru",
ApplicationVersion = Version.GetVersion(),
Comments = comments ?? inputFormat.Info.Comments,
Creator = creator ?? inputFormat.Info.Creator,
DriveFirmwareRevision = driveFirmwareRevision ?? inputFormat.Info.DriveFirmwareRevision,
DriveManufacturer = driveManufacturer ?? inputFormat.Info.DriveManufacturer,
DriveModel = driveModel ?? inputFormat.Info.DriveModel,
DriveSerialNumber = driveSerialNumber ?? inputFormat.Info.DriveSerialNumber,
LastMediaSequence = lastMediaSequence != 0 ? lastMediaSequence : inputFormat.Info.LastMediaSequence,
MediaBarcode = mediaBarcode ?? inputFormat.Info.MediaBarcode,
MediaManufacturer = mediaManufacturer ?? inputFormat.Info.MediaManufacturer,
MediaModel = mediaModel ?? inputFormat.Info.MediaModel,
MediaPartNumber = mediaPartNumber ?? inputFormat.Info.MediaPartNumber,
MediaSequence = mediaSequence != 0 ? mediaSequence : inputFormat.Info.MediaSequence,
MediaSerialNumber = mediaSerialNumber ?? inputFormat.Info.MediaSerialNumber,
MediaTitle = mediaTitle ?? inputFormat.Info.MediaTitle
};
if (!outputFormat.SetMetadata(metadata))
{
AaruConsole.ErrorWrite("Error {0} setting metadata, ", outputFormat.ErrorMessage);
if (!force)
{
AaruConsole.ErrorWriteLine("not continuing...");
return((int)ErrorNumber.WriteError);
}
AaruConsole.ErrorWriteLine("continuing...");
}
CICMMetadataType cicmMetadata = inputFormat.CicmMetadata;
List <DumpHardwareType> dumpHardware = inputFormat.DumpHardware;
foreach (MediaTagType mediaTag in inputFormat.Info.ReadableMediaTags)
{
if (force && !outputFormat.SupportedMediaTags.Contains(mediaTag))
{
continue;
}
AaruConsole.WriteLine("Converting media tag {0}", mediaTag);
byte[] tag = inputFormat.ReadDiskTag(mediaTag);
if (outputFormat.WriteMediaTag(tag, mediaTag))
{
continue;
}
if (force)
{
AaruConsole.ErrorWriteLine("Error {0} writing media tag, continuing...", outputFormat.ErrorMessage);
}
else
{
AaruConsole.ErrorWriteLine("Error {0} writing media tag, not continuing...",
outputFormat.ErrorMessage);
return((int)ErrorNumber.WriteError);
}
}
AaruConsole.WriteLine("{0} sectors to convert", inputFormat.Info.Sectors);
ulong doneSectors = 0;
if (inputFormat is IOpticalMediaImage inputOptical &&
outputFormat is IWritableOpticalImage outputOptical &&
inputOptical.Tracks != null)
{
if (!outputOptical.SetTracks(inputOptical.Tracks))
{
AaruConsole.ErrorWriteLine("Error {0} sending tracks list to output image.",
outputFormat.ErrorMessage);
return((int)ErrorNumber.WriteError);
}
foreach (Track track in inputOptical.Tracks)
{
doneSectors = 0;
ulong trackSectors = (track.TrackEndSector - track.TrackStartSector) + 1;
while (doneSectors < trackSectors)
{
byte[] sector;
uint sectorsToDo;
if (trackSectors - doneSectors >= (ulong)count)
{
sectorsToDo = (uint)count;
}
else
{
sectorsToDo = (uint)(trackSectors - doneSectors);
}
AaruConsole.Write("\rConverting sectors {0} to {1} in track {3} ({2:P2} done)",
doneSectors + track.TrackStartSector,
doneSectors + sectorsToDo + track.TrackStartSector,
(doneSectors + track.TrackStartSector) / (double)inputFormat.Info.Sectors,
track.TrackSequence);
bool useNotLong = false;
bool result = false;
if (useLong)
{
if (sectorsToDo == 1)
{
sector = inputFormat.ReadSectorLong(doneSectors + track.TrackStartSector);
result = outputFormat.WriteSectorLong(sector, doneSectors + track.TrackStartSector);
}
else
{
sector = inputFormat.ReadSectorsLong(doneSectors + track.TrackStartSector, sectorsToDo);
result = outputFormat.WriteSectorsLong(sector, doneSectors + track.TrackStartSector,
sectorsToDo);
}
if (!result &&
sector.Length % 2352 != 0)
{
if (!force)
{
AaruConsole.ErrorWriteLine("Input image is not returning raw sectors, use force if you want to continue...");
return((int)Errno.InOutError);
}
useNotLong = true;
}
}
if (!useLong || useNotLong)
{
if (sectorsToDo == 1)
{
sector = inputFormat.ReadSector(doneSectors + track.TrackStartSector);
result = outputFormat.WriteSector(sector, doneSectors + track.TrackStartSector);
}
else
{
sector = inputFormat.ReadSectors(doneSectors + track.TrackStartSector, sectorsToDo);
result = outputFormat.WriteSectors(sector, doneSectors + track.TrackStartSector,
sectorsToDo);
}
}
if (!result)
{
if (force)
{
AaruConsole.ErrorWriteLine("Error {0} writing sector {1}, continuing...",
outputFormat.ErrorMessage,
doneSectors + track.TrackStartSector);
}
else
{
AaruConsole.ErrorWriteLine("Error {0} writing sector {1}, not continuing...",
outputFormat.ErrorMessage,
doneSectors + track.TrackStartSector);
return((int)ErrorNumber.WriteError);
}
}
doneSectors += sectorsToDo;
}
}
AaruConsole.Write("\rConverting sectors {0} to {1} in track {3} ({2:P2} done)",
inputFormat.Info.Sectors, inputFormat.Info.Sectors, 1.0, inputOptical.Tracks.Count);
AaruConsole.WriteLine();
foreach (SectorTagType tag in inputFormat.Info.ReadableSectorTags.OrderBy(t => t))
{
if (!useLong)
{
break;
}
switch (tag)
{
case SectorTagType.AppleSectorTag:
case SectorTagType.CdSectorSync:
case SectorTagType.CdSectorHeader:
case SectorTagType.CdSectorSubHeader:
case SectorTagType.CdSectorEdc:
case SectorTagType.CdSectorEccP:
case SectorTagType.CdSectorEccQ:
case SectorTagType.CdSectorEcc:
// This tags are inline in long sector
continue;
}
if (force && !outputFormat.SupportedSectorTags.Contains(tag))
{
continue;
}
foreach (Track track in inputOptical.Tracks)
{
doneSectors = 0;
ulong trackSectors = (track.TrackEndSector - track.TrackStartSector) + 1;
byte[] sector;
bool result;
switch (tag)
{
case SectorTagType.CdTrackFlags:
case SectorTagType.CdTrackIsrc:
AaruConsole.Write("\rConverting tag {0} in track {1} ({2:P2} done).", tag,
track.TrackSequence,
track.TrackSequence / (double)inputOptical.Tracks.Count);
sector = inputFormat.ReadSectorTag(track.TrackStartSector, tag);
result = outputFormat.WriteSectorTag(sector, track.TrackStartSector, tag);
if (!result)
{
if (force)
{
AaruConsole.ErrorWriteLine("Error {0} writing tag, continuing...",
outputFormat.ErrorMessage);
}
else
{
AaruConsole.ErrorWriteLine("Error {0} writing tag, not continuing...",
outputFormat.ErrorMessage);
return((int)ErrorNumber.WriteError);
}
}
continue;
}
while (doneSectors < trackSectors)
{
uint sectorsToDo;
if (trackSectors - doneSectors >= (ulong)count)
{
sectorsToDo = (uint)count;
}
else
{
sectorsToDo = (uint)(trackSectors - doneSectors);
}
AaruConsole.Write("\rConverting tag {4} for sectors {0} to {1} in track {3} ({2:P2} done)",
doneSectors + track.TrackStartSector,
doneSectors + sectorsToDo + track.TrackStartSector,
(doneSectors + track.TrackStartSector) / (double)inputFormat.Info.Sectors,
track.TrackSequence, tag);
if (sectorsToDo == 1)
{
sector = inputFormat.ReadSectorTag(doneSectors + track.TrackStartSector, tag);
result = outputFormat.WriteSectorTag(sector, doneSectors + track.TrackStartSector, tag);
}
else
{
sector = inputFormat.ReadSectorsTag(doneSectors + track.TrackStartSector, sectorsToDo,
tag);
result = outputFormat.WriteSectorsTag(sector, doneSectors + track.TrackStartSector,
sectorsToDo, tag);
}
if (!result)
{
if (force)
{
AaruConsole.ErrorWriteLine("Error {0} writing tag for sector {1}, continuing...",
outputFormat.ErrorMessage,
doneSectors + track.TrackStartSector);
}
else
{
AaruConsole.
ErrorWriteLine("Error {0} writing tag for sector {1}, not continuing...",
outputFormat.ErrorMessage, doneSectors + track.TrackStartSector);
return((int)ErrorNumber.WriteError);
}
}
doneSectors += sectorsToDo;
}
}
switch (tag)
{
case SectorTagType.CdTrackFlags:
case SectorTagType.CdTrackIsrc:
AaruConsole.Write("\rConverting tag {0} in track {1} ({2:P2} done).", tag,
inputOptical.Tracks.Count, 1.0);
break;
default:
AaruConsole.Write("\rConverting tag {4} for sectors {0} to {1} in track {3} ({2:P2} done)",
inputFormat.Info.Sectors, inputFormat.Info.Sectors, 1.0,
inputOptical.Tracks.Count, tag);
break;
}
AaruConsole.WriteLine();
}
}
public static void DoConvert(ConvertImageOptions options)
{
DicConsole.DebugWriteLine("Analyze command", "--debug={0}", options.Debug);
DicConsole.DebugWriteLine("Analyze command", "--verbose={0}", options.Verbose);
DicConsole.DebugWriteLine("Analyze command", "--input={0}", options.InputFile);
DicConsole.DebugWriteLine("Analyze command", "--output={0}", options.OutputFile);
DicConsole.DebugWriteLine("Analyze command", "--format={0}", options.OutputFormat);
DicConsole.DebugWriteLine("Analyze command", "--count={0}", options.Count);
DicConsole.DebugWriteLine("Analyze command", "--force={0}", options.Force);
DicConsole.DebugWriteLine("Analyze command", "--creator={0}", options.Creator);
DicConsole.DebugWriteLine("Analyze command", "--media-title={0}", options.MediaTitle);
DicConsole.DebugWriteLine("Analyze command", "--comments={0}", options.Comments);
DicConsole.DebugWriteLine("Analyze command", "--media-manufacturer={0}", options.MediaManufacturer);
DicConsole.DebugWriteLine("Analyze command", "--media-model={0}", options.MediaModel);
DicConsole.DebugWriteLine("Analyze command", "--media-serial={0}", options.MediaSerialNumber);
DicConsole.DebugWriteLine("Analyze command", "--media-barcode={0}", options.MediaBarcode);
DicConsole.DebugWriteLine("Analyze command", "--media-partnumber={0}", options.MediaPartNumber);
DicConsole.DebugWriteLine("Analyze command", "--media-sequence={0}", options.MediaSequence);
DicConsole.DebugWriteLine("Analyze command", "--media-lastsequence={0}", options.LastMediaSequence);
DicConsole.DebugWriteLine("Analyze command", "--drive-manufacturer={0}", options.DriveManufacturer);
DicConsole.DebugWriteLine("Analyze command", "--drive-model={0}", options.DriveModel);
DicConsole.DebugWriteLine("Analyze command", "--drive-serial={0}", options.DriveSerialNumber);
DicConsole.DebugWriteLine("Analyze command", "--drive-revision={0}", options.DriveFirmwareRevision);
DicConsole.DebugWriteLine("Analyze command", "--cicm-xml={0}", options.CicmXml);
DicConsole.DebugWriteLine("Analyze command", "--resume-file={0}", options.ResumeFile);
DicConsole.DebugWriteLine("Analyze command", "--options={0}", options.Options);
Dictionary <string, string> parsedOptions = Options.Parse(options.Options);
DicConsole.DebugWriteLine("Analyze command", "Parsed options:");
foreach (KeyValuePair <string, string> parsedOption in parsedOptions)
{
DicConsole.DebugWriteLine("Analyze command", "{0} = {1}", parsedOption.Key, parsedOption.Value);
}
if (options.Count == 0)
{
DicConsole.ErrorWriteLine("Need to specify more than 0 sectors to copy at once");
return;
}
Resume resume = null;
CICMMetadataType sidecar = null;
XmlSerializer xs = new XmlSerializer(typeof(CICMMetadataType));
if (options.CicmXml != null)
{
if (File.Exists(options.CicmXml))
{
try
{
StreamReader sr = new StreamReader(options.CicmXml);
sidecar = (CICMMetadataType)xs.Deserialize(sr);
sr.Close();
}
catch
{
DicConsole.ErrorWriteLine("Incorrect metadata sidecar file, not continuing...");
return;
}
}
else
{
DicConsole.ErrorWriteLine("Could not find metadata sidecar, not continuing...");
return;
}
}
xs = new XmlSerializer(typeof(Resume));
if (options.ResumeFile != null)
{
if (File.Exists(options.ResumeFile))
{
try
{
StreamReader sr = new StreamReader(options.ResumeFile);
resume = (Resume)xs.Deserialize(sr);
sr.Close();
}
catch
{
DicConsole.ErrorWriteLine("Incorrect resume file, not continuing...");
return;
}
}
else
{
DicConsole.ErrorWriteLine("Could not find resume file, not continuing...");
return;
}
}
FiltersList filtersList = new FiltersList();
IFilter inputFilter = filtersList.GetFilter(options.InputFile);
if (inputFilter == null)
{
DicConsole.ErrorWriteLine("Cannot open specified file.");
return;
}
if (File.Exists(options.OutputFile))
{
DicConsole.ErrorWriteLine("Output file already exists, not continuing.");
return;
}
PluginBase plugins = GetPluginBase.Instance;
IMediaImage inputFormat = ImageFormat.Detect(inputFilter);
if (inputFormat == null)
{
DicConsole.WriteLine("Input image format not identified, not proceeding with conversion.");
return;
}
if (options.Verbose)
{
DicConsole.VerboseWriteLine("Input image format identified by {0} ({1}).", inputFormat.Name,
inputFormat.Id);
}
else
{
DicConsole.WriteLine("Input image format identified by {0}.", inputFormat.Name);
}
try
{
if (!inputFormat.Open(inputFilter))
{
DicConsole.WriteLine("Unable to open image format");
DicConsole.WriteLine("No error given");
return;
}
DicConsole.DebugWriteLine("Convert-image command", "Correctly opened image file.");
DicConsole.DebugWriteLine("Convert-image command", "Image without headers is {0} bytes.",
inputFormat.Info.ImageSize);
DicConsole.DebugWriteLine("Convert-image command", "Image has {0} sectors.", inputFormat.Info.Sectors);
DicConsole.DebugWriteLine("Convert-image command", "Image identifies media type as {0}.",
inputFormat.Info.MediaType);
Core.Statistics.AddMediaFormat(inputFormat.Format);
Core.Statistics.AddMedia(inputFormat.Info.MediaType, false);
Core.Statistics.AddFilter(inputFilter.Name);
}
catch (Exception ex)
{
DicConsole.ErrorWriteLine("Unable to open image format");
DicConsole.ErrorWriteLine("Error: {0}", ex.Message);
DicConsole.DebugWriteLine("Convert-image command", "Stack trace: {0}", ex.StackTrace);
return;
}
List <IWritableImage> candidates = new List <IWritableImage>();
// Try extension
if (string.IsNullOrEmpty(options.OutputFormat))
{
candidates.AddRange(plugins.WritableImages.Values.Where(t =>
t.KnownExtensions
.Contains(Path.GetExtension(options
.OutputFile))));
}
// Try Id
else if (Guid.TryParse(options.OutputFormat, out Guid outId))
{
candidates.AddRange(plugins.WritableImages.Values.Where(t => t.Id.Equals(outId)));
}
// Try name
else
{
candidates.AddRange(plugins.WritableImages.Values.Where(t => string.Equals(t.Name, options.OutputFormat,
StringComparison
.InvariantCultureIgnoreCase)));
}
if (candidates.Count == 0)
{
DicConsole.WriteLine("No plugin supports requested extension.");
return;
}
if (candidates.Count > 1)
{
DicConsole.WriteLine("More than one plugin supports requested extension.");
return;
}
IWritableImage outputFormat = candidates[0];
if (options.Verbose)
{
DicConsole.VerboseWriteLine("Output image format: {0} ({1}).", outputFormat.Name, outputFormat.Id);
}
else
{
DicConsole.WriteLine("Output image format: {0}.", outputFormat.Name);
}
if (!outputFormat.SupportedMediaTypes.Contains(inputFormat.Info.MediaType))
{
DicConsole.ErrorWriteLine("Output format does not support media type, cannot continue...");
return;
}
foreach (MediaTagType mediaTag in inputFormat.Info.ReadableMediaTags)
{
if (outputFormat.SupportedMediaTags.Contains(mediaTag) || options.Force)
{
continue;
}
DicConsole.ErrorWriteLine("Converting image will lose media tag {0}, not continuing...", mediaTag);
DicConsole.ErrorWriteLine("If you don't care, use force option.");
return;
}
bool useLong = inputFormat.Info.ReadableSectorTags.Count != 0;
foreach (SectorTagType sectorTag in inputFormat.Info.ReadableSectorTags)
{
if (outputFormat.SupportedSectorTags.Contains(sectorTag))
{
continue;
}
if (options.Force)
{
if (sectorTag != SectorTagType.CdTrackFlags && sectorTag != SectorTagType.CdTrackIsrc &&
sectorTag != SectorTagType.CdSectorSubchannel)
{
useLong = false;
}
continue;
}
DicConsole.ErrorWriteLine("Converting image will lose sector tag {0}, not continuing...", sectorTag);
DicConsole
.ErrorWriteLine("If you don't care, use force option. This will skip all sector tags converting only user data.");
return;
}
if (!outputFormat.Create(options.OutputFile, inputFormat.Info.MediaType, parsedOptions,
inputFormat.Info.Sectors, inputFormat.Info.SectorSize))
{
DicConsole.ErrorWriteLine("Error {0} creating output image.", outputFormat.ErrorMessage);
return;
}
CommonTypes.Structs.ImageInfo metadata = new CommonTypes.Structs.ImageInfo
{
Application = "DiscImageChef",
ApplicationVersion = Version.GetVersion(),
Comments = options.Comments ?? inputFormat.Info.Comments,
Creator = options.Creator ?? inputFormat.Info.Creator,
DriveFirmwareRevision = options.DriveFirmwareRevision ?? inputFormat.Info.DriveFirmwareRevision,
DriveManufacturer = options.DriveManufacturer ?? inputFormat.Info.DriveManufacturer,
DriveModel = options.DriveModel ?? inputFormat.Info.DriveModel,
DriveSerialNumber = options.DriveSerialNumber ?? inputFormat.Info.DriveSerialNumber,
LastMediaSequence =
options.LastMediaSequence != 0 ? options.LastMediaSequence : inputFormat.Info.LastMediaSequence,
MediaBarcode = options.MediaBarcode ?? inputFormat.Info.MediaBarcode,
MediaManufacturer = options.MediaManufacturer ?? inputFormat.Info.MediaManufacturer,
MediaModel = options.MediaModel ?? inputFormat.Info.MediaModel,
MediaPartNumber = options.MediaPartNumber ?? inputFormat.Info.MediaPartNumber,
MediaSequence = options.MediaSequence != 0 ? options.MediaSequence : inputFormat.Info.MediaSequence,
MediaSerialNumber = options.MediaSerialNumber ?? inputFormat.Info.MediaSerialNumber,
MediaTitle = options.MediaTitle ?? inputFormat.Info.MediaTitle
};
if (!outputFormat.SetMetadata(metadata))
{
DicConsole.ErrorWrite("Error {0} setting metadata, ", outputFormat.ErrorMessage);
if (!options.Force)
{
DicConsole.ErrorWriteLine("not continuing...");
return;
}
DicConsole.ErrorWriteLine("continuing...");
}
List <Track> tracks;
try { tracks = inputFormat.Tracks; }
catch (Exception) { tracks = null; }
CICMMetadataType cicmMetadata = inputFormat.CicmMetadata;
List <DumpHardwareType> dumpHardware = inputFormat.DumpHardware;
if (tracks != null)
{
if (!outputFormat.SetTracks(tracks))
{
DicConsole.ErrorWriteLine("Error {0} sending tracks list to output image.",
outputFormat.ErrorMessage);
return;
}
}
foreach (MediaTagType mediaTag in inputFormat.Info.ReadableMediaTags)
{
if (options.Force && !outputFormat.SupportedMediaTags.Contains(mediaTag))
{
continue;
}
DicConsole.WriteLine("Converting media tag {0}", mediaTag);
byte[] tag = inputFormat.ReadDiskTag(mediaTag);
if (outputFormat.WriteMediaTag(tag, mediaTag))
{
continue;
}
if (options.Force)
{
DicConsole.ErrorWriteLine("Error {0} writing media tag, continuing...", outputFormat.ErrorMessage);
}
else
{
DicConsole.ErrorWriteLine("Error {0} writing media tag, not continuing...",
outputFormat.ErrorMessage);
return;
}
}
DicConsole.WriteLine("{0} sectors to convert", inputFormat.Info.Sectors);
ulong doneSectors = 0;
if (tracks == null)
{
DicConsole.WriteLine("Setting geometry to {0} cylinders, {1} heads and {2} sectors per track",
inputFormat.Info.Cylinders, inputFormat.Info.Heads,
inputFormat.Info.SectorsPerTrack);
if (!outputFormat.SetGeometry(inputFormat.Info.Cylinders, inputFormat.Info.Heads,
inputFormat.Info.SectorsPerTrack))
{
DicConsole.ErrorWriteLine("Error {0} setting geometry, image may be incorrect, continuing...",
outputFormat.ErrorMessage);
}
while (doneSectors < inputFormat.Info.Sectors)
{
byte[] sector;
uint sectorsToDo;
if (inputFormat.Info.Sectors - doneSectors >= (ulong)options.Count)
{
sectorsToDo = (uint)options.Count;
}
else
{
sectorsToDo = (uint)(inputFormat.Info.Sectors - doneSectors);
}
DicConsole.Write("\rConverting sectors {0} to {1} ({2:P2} done)", doneSectors,
doneSectors + sectorsToDo, doneSectors / (double)inputFormat.Info.Sectors);
bool result;
if (useLong)
{
if (sectorsToDo == 1)
{
sector = inputFormat.ReadSectorLong(doneSectors);
result = outputFormat.WriteSectorLong(sector, doneSectors);
}
else
{
sector = inputFormat.ReadSectorsLong(doneSectors, sectorsToDo);
result = outputFormat.WriteSectorsLong(sector, doneSectors, sectorsToDo);
}
}
else
{
if (sectorsToDo == 1)
{
sector = inputFormat.ReadSector(doneSectors);
result = outputFormat.WriteSector(sector, doneSectors);
}
else
{
sector = inputFormat.ReadSectors(doneSectors, sectorsToDo);
result = outputFormat.WriteSectors(sector, doneSectors, sectorsToDo);
}
}
if (!result)
{
if (options.Force)
{
DicConsole.ErrorWriteLine("Error {0} writing sector {1}, continuing...",
outputFormat.ErrorMessage, doneSectors);
}
else
{
DicConsole.ErrorWriteLine("Error {0} writing sector {1}, not continuing...",
outputFormat.ErrorMessage, doneSectors);
return;
}
}
doneSectors += sectorsToDo;
}
DicConsole.Write("\rConverting sectors {0} to {1} ({2:P2} done)", inputFormat.Info.Sectors,
inputFormat.Info.Sectors, 1.0);
DicConsole.WriteLine();
foreach (SectorTagType tag in inputFormat.Info.ReadableSectorTags)
{
if (!useLong)
{
break;
}
switch (tag)
{
case SectorTagType.AppleSectorTag:
case SectorTagType.CdSectorSync:
case SectorTagType.CdSectorHeader:
case SectorTagType.CdSectorSubHeader:
case SectorTagType.CdSectorEdc:
case SectorTagType.CdSectorEccP:
case SectorTagType.CdSectorEccQ:
case SectorTagType.CdSectorEcc:
// This tags are inline in long sector
continue;
}
if (options.Force && !outputFormat.SupportedSectorTags.Contains(tag))
{
continue;
}
doneSectors = 0;
while (doneSectors < inputFormat.Info.Sectors)
{
byte[] sector;
uint sectorsToDo;
if (inputFormat.Info.Sectors - doneSectors >= (ulong)options.Count)
{
sectorsToDo = (uint)options.Count;
}
else
{
sectorsToDo = (uint)(inputFormat.Info.Sectors - doneSectors);
}
DicConsole.Write("\rConverting tag {2} for sectors {0} to {1} ({2:P2} done)", doneSectors,
doneSectors + sectorsToDo, doneSectors / (double)inputFormat.Info.Sectors,
tag);
bool result;
if (sectorsToDo == 1)
{
sector = inputFormat.ReadSectorTag(doneSectors, tag);
result = outputFormat.WriteSectorTag(sector, doneSectors, tag);
}
else
{
sector = inputFormat.ReadSectorsTag(doneSectors, sectorsToDo, tag);
result = outputFormat.WriteSectorsTag(sector, doneSectors, sectorsToDo, tag);
}
if (!result)
{
if (options.Force)
{
DicConsole.ErrorWriteLine("Error {0} writing sector {1}, continuing...",
outputFormat.ErrorMessage, doneSectors);
}
else
{
DicConsole.ErrorWriteLine("Error {0} writing sector {1}, not continuing...",
outputFormat.ErrorMessage, doneSectors);
return;
}
}
doneSectors += sectorsToDo;
}
DicConsole.Write("\rConverting tag {2} for sectors {0} to {1} ({2:P2} done)",
inputFormat.Info.Sectors, inputFormat.Info.Sectors, 1.0, tag);
DicConsole.WriteLine();
}
}
else
{
foreach (Track track in tracks)
{
doneSectors = 0;
ulong trackSectors = track.TrackEndSector - track.TrackStartSector + 1;
while (doneSectors < trackSectors)
{
byte[] sector;
uint sectorsToDo;
if (trackSectors - doneSectors >= (ulong)options.Count)
{
sectorsToDo = (uint)options.Count;
}
else
{
sectorsToDo =
(uint)(trackSectors - doneSectors);
}
DicConsole.Write("\rConverting sectors {0} to {1} in track {3} ({2:P2} done)",
doneSectors + track.TrackStartSector,
doneSectors + sectorsToDo + track.TrackStartSector,
(doneSectors + track.TrackStartSector) / (double)inputFormat.Info.Sectors,
track.TrackSequence);
bool result;
if (useLong)
{
if (sectorsToDo == 1)
{
sector = inputFormat.ReadSectorLong(doneSectors + track.TrackStartSector);
result = outputFormat.WriteSectorLong(sector, doneSectors + track.TrackStartSector);
}
else
{
sector = inputFormat.ReadSectorsLong(doneSectors + track.TrackStartSector, sectorsToDo);
result = outputFormat.WriteSectorsLong(sector, doneSectors + track.TrackStartSector,
sectorsToDo);
}
}
else
{
if (sectorsToDo == 1)
{
sector = inputFormat.ReadSector(doneSectors + track.TrackStartSector);
result = outputFormat.WriteSector(sector, doneSectors + track.TrackStartSector);
}
else
{
sector = inputFormat.ReadSectors(doneSectors + track.TrackStartSector, sectorsToDo);
result = outputFormat.WriteSectors(sector, doneSectors + track.TrackStartSector,
sectorsToDo);
}
}
if (!result)
{
if (options.Force)
{
DicConsole.ErrorWriteLine("Error {0} writing sector {1}, continuing...",
outputFormat.ErrorMessage, doneSectors);
}
else
{
DicConsole.ErrorWriteLine("Error {0} writing sector {1}, not continuing...",
outputFormat.ErrorMessage, doneSectors);
return;
}
}
doneSectors += sectorsToDo;
}
}
DicConsole.Write("\rConverting sectors {0} to {1} in track {3} ({2:P2} done)", inputFormat.Info.Sectors,
inputFormat.Info.Sectors, 1.0, tracks.Count);
DicConsole.WriteLine();
foreach (SectorTagType tag in inputFormat.Info.ReadableSectorTags.OrderBy(t => t))
{
if (!useLong)
{
break;
}
switch (tag)
{
case SectorTagType.AppleSectorTag:
case SectorTagType.CdSectorSync:
case SectorTagType.CdSectorHeader:
case SectorTagType.CdSectorSubHeader:
case SectorTagType.CdSectorEdc:
case SectorTagType.CdSectorEccP:
case SectorTagType.CdSectorEccQ:
case SectorTagType.CdSectorEcc:
// This tags are inline in long sector
continue;
}
if (options.Force && !outputFormat.SupportedSectorTags.Contains(tag))
{
continue;
}
foreach (Track track in tracks)
{
doneSectors = 0;
ulong trackSectors = track.TrackEndSector - track.TrackStartSector + 1;
byte[] sector;
bool result;
switch (tag)
{
case SectorTagType.CdTrackFlags:
case SectorTagType.CdTrackIsrc:
DicConsole.Write("\rConverting tag {0} in track {1} ({2:P2} done).", tag,
track.TrackSequence, track.TrackSequence / (double)tracks.Count);
sector = inputFormat.ReadSectorTag(track.TrackStartSector, tag);
result = outputFormat.WriteSectorTag(sector, track.TrackStartSector, tag);
if (!result)
{
if (options.Force)
{
DicConsole.ErrorWriteLine("Error {0} writing tag, continuing...",
outputFormat.ErrorMessage);
}
else
{
DicConsole.ErrorWriteLine("Error {0} writing tag, not continuing...",
outputFormat.ErrorMessage);
return;
}
}
continue;
}
while (doneSectors < trackSectors)
{
uint sectorsToDo;
if (trackSectors - doneSectors >= (ulong)options.Count)
{
sectorsToDo = (uint)options.Count;
}
else
{
sectorsToDo =
(uint)(trackSectors - doneSectors);
}
DicConsole.Write("\rConverting tag {4} for sectors {0} to {1} in track {3} ({2:P2} done)",
doneSectors + track.TrackStartSector,
doneSectors + sectorsToDo + track.TrackStartSector,
(doneSectors + track.TrackStartSector) / (double)inputFormat.Info.Sectors,
track.TrackSequence, tag);
if (sectorsToDo == 1)
{
sector = inputFormat.ReadSectorTag(doneSectors + track.TrackStartSector, tag);
result = outputFormat.WriteSectorTag(sector, doneSectors + track.TrackStartSector, tag);
}
else
{
sector = inputFormat.ReadSectorsTag(doneSectors + track.TrackStartSector, sectorsToDo,
tag);
result = outputFormat.WriteSectorsTag(sector, doneSectors + track.TrackStartSector,
sectorsToDo, tag);
}
if (!result)
{
if (options.Force)
{
DicConsole.ErrorWriteLine("Error {0} writing tag for sector {1}, continuing...",
outputFormat.ErrorMessage, doneSectors);
}
else
{
DicConsole.ErrorWriteLine("Error {0} writing tag for sector {1}, not continuing...",
outputFormat.ErrorMessage, doneSectors);
return;
}
}
doneSectors += sectorsToDo;
}
}
switch (tag)
{
case SectorTagType.CdTrackFlags:
case SectorTagType.CdTrackIsrc:
DicConsole.Write("\rConverting tag {0} in track {1} ({2:P2} done).", tag, tracks.Count,
1.0);
break;
default:
DicConsole.Write("\rConverting tag {4} for sectors {0} to {1} in track {3} ({2:P2} done)",
inputFormat.Info.Sectors, inputFormat.Info.Sectors, 1.0, tracks.Count,
tag);
break;
}
DicConsole.WriteLine();
}
}
bool ret = false;
if (resume != null || dumpHardware != null)
{
if (resume != null)
{
ret = outputFormat.SetDumpHardware(resume.Tries);
}
else if (dumpHardware != null)
{
ret = outputFormat.SetDumpHardware(dumpHardware);
}
if (ret)
{
DicConsole.WriteLine("Written dump hardware list to output image.");
}
}
ret = false;
if (sidecar != null || cicmMetadata != null)
{
if (sidecar != null)
{
ret = outputFormat.SetCicmMetadata(sidecar);
}
else if (cicmMetadata != null)
{
ret = outputFormat.SetCicmMetadata(cicmMetadata);
}
if (ret)
{
DicConsole.WriteLine("Written CICM XML metadata to output image.");
}
}
DicConsole.WriteLine("Closing output image.");
if (!outputFormat.Close())
{
DicConsole.ErrorWriteLine("Error {0} closing output image... Contents are not correct.",
outputFormat.ErrorMessage);
}
DicConsole.WriteLine();
DicConsole.WriteLine("Conversion done.");
Core.Statistics.AddCommand("convert-image");
}
public Errno Mount(IMediaImage imagePlugin, Partition partition, Encoding encoding,
Dictionary <string, string> options, string @namespace)
{
device = imagePlugin;
partitionStart = partition.Start;
Encoding = encoding ?? Encoding.GetEncoding("macintosh");
if (options == null)
{
options = GetDefaultOptions();
}
if (options.TryGetValue("debug", out string debugString))
{
bool.TryParse(debugString, out debug);
}
volMDB = new MFS_MasterDirectoryBlock();
mdbBlocks = device.ReadSector(2 + partitionStart);
bootBlocks = device.ReadSector(0 + partitionStart);
volMDB.drSigWord = BigEndianBitConverter.ToUInt16(mdbBlocks, 0x000);
if (volMDB.drSigWord != MFS_MAGIC)
{
return(Errno.InvalidArgument);
}
volMDB.drCrDate = BigEndianBitConverter.ToUInt32(mdbBlocks, 0x002);
volMDB.drLsBkUp = BigEndianBitConverter.ToUInt32(mdbBlocks, 0x006);
volMDB.drAtrb = BigEndianBitConverter.ToUInt16(mdbBlocks, 0x00A);
volMDB.drNmFls = BigEndianBitConverter.ToUInt16(mdbBlocks, 0x00C);
volMDB.drDirSt = BigEndianBitConverter.ToUInt16(mdbBlocks, 0x00E);
volMDB.drBlLen = BigEndianBitConverter.ToUInt16(mdbBlocks, 0x010);
volMDB.drNmAlBlks = BigEndianBitConverter.ToUInt16(mdbBlocks, 0x012);
volMDB.drAlBlkSiz = BigEndianBitConverter.ToUInt32(mdbBlocks, 0x014);
volMDB.drClpSiz = BigEndianBitConverter.ToUInt32(mdbBlocks, 0x018);
volMDB.drAlBlSt = BigEndianBitConverter.ToUInt16(mdbBlocks, 0x01C);
volMDB.drNxtFNum = BigEndianBitConverter.ToUInt32(mdbBlocks, 0x01E);
volMDB.drFreeBks = BigEndianBitConverter.ToUInt16(mdbBlocks, 0x022);
volMDB.drVNSiz = mdbBlocks[0x024];
byte[] variableSize = new byte[volMDB.drVNSiz + 1];
Array.Copy(mdbBlocks, 0x024, variableSize, 0, volMDB.drVNSiz + 1);
volMDB.drVN = StringHandlers.PascalToString(variableSize, Encoding);
directoryBlocks = device.ReadSectors(volMDB.drDirSt + partitionStart, volMDB.drBlLen);
int bytesInBlockMap = volMDB.drNmAlBlks * 12 / 8 + volMDB.drNmAlBlks * 12 % 8;
const int BYTES_BEFORE_BLOCK_MAP = 64;
int bytesInWholeMdb = bytesInBlockMap + BYTES_BEFORE_BLOCK_MAP;
int sectorsInWholeMdb = bytesInWholeMdb / (int)device.Info.SectorSize +
bytesInWholeMdb % (int)device.Info.SectorSize;
byte[] wholeMdb = device.ReadSectors(partitionStart + 2, (uint)sectorsInWholeMdb);
blockMapBytes = new byte[bytesInBlockMap];
Array.Copy(wholeMdb, BYTES_BEFORE_BLOCK_MAP, blockMapBytes, 0, blockMapBytes.Length);
int offset = 0;
blockMap = new uint[volMDB.drNmAlBlks + 2 + 1];
for (int i = 2; i < volMDB.drNmAlBlks + 2; i += 8)
{
uint tmp1 = 0;
uint tmp2 = 0;
uint tmp3 = 0;
if (offset + 4 <= blockMapBytes.Length)
{
tmp1 = BigEndianBitConverter.ToUInt32(blockMapBytes, offset);
}
if (offset + 4 + 4 <= blockMapBytes.Length)
{
tmp2 = BigEndianBitConverter.ToUInt32(blockMapBytes, offset + 4);
}
if (offset + 8 + 4 <= blockMapBytes.Length)
{
tmp3 = BigEndianBitConverter.ToUInt32(blockMapBytes, offset + 8);
}
if (i < blockMap.Length)
{
blockMap[i] = (tmp1 & 0xFFF00000) >> 20;
}
if (i + 2 < blockMap.Length)
{
blockMap[i + 1] = (tmp1 & 0xFFF00) >> 8;
}
if (i + 3 < blockMap.Length)
{
blockMap[i + 2] = ((tmp1 & 0xFF) << 4) + ((tmp2 & 0xF0000000) >> 28);
}
if (i + 4 < blockMap.Length)
{
blockMap[i + 3] = (tmp2 & 0xFFF0000) >> 16;
}
if (i + 5 < blockMap.Length)
{
blockMap[i + 4] = (tmp2 & 0xFFF0) >> 4;
}
if (i + 6 < blockMap.Length)
{
blockMap[i + 5] = ((tmp2 & 0xF) << 8) + ((tmp3 & 0xFF000000) >> 24);
}
if (i + 7 < blockMap.Length)
{
blockMap[i + 6] = (tmp3 & 0xFFF000) >> 12;
}
if (i + 8 < blockMap.Length)
{
blockMap[i + 7] = tmp3 & 0xFFF;
}
offset += 12;
}
if (device.Info.ReadableSectorTags.Contains(SectorTagType.AppleSectorTag))
{
mdbTags = device.ReadSectorTag(2 + partitionStart, SectorTagType.AppleSectorTag);
bootTags = device.ReadSectorTag(0 + partitionStart, SectorTagType.AppleSectorTag);
directoryTags = device.ReadSectorsTag(volMDB.drDirSt + partitionStart, volMDB.drBlLen,
SectorTagType.AppleSectorTag);
bitmapTags = device.ReadSectorsTag(partitionStart + 2, (uint)sectorsInWholeMdb,
SectorTagType.AppleSectorTag);
}
sectorsPerBlock = (int)(volMDB.drAlBlkSiz / device.Info.SectorSize);
if (!FillDirectory())
{
return(Errno.InvalidArgument);
}
mounted = true;
ushort bbSig = BigEndianBitConverter.ToUInt16(bootBlocks, 0x000);
if (bbSig != MFSBB_MAGIC)
{
bootBlocks = null;
}
XmlFsType = new FileSystemType();
if (volMDB.drLsBkUp > 0)
{
XmlFsType.BackupDate = DateHandlers.MacToDateTime(volMDB.drLsBkUp);
XmlFsType.BackupDateSpecified = true;
}
XmlFsType.Bootable = bbSig == MFSBB_MAGIC;
XmlFsType.Clusters = volMDB.drNmAlBlks;
XmlFsType.ClusterSize = volMDB.drAlBlkSiz;
if (volMDB.drCrDate > 0)
{
XmlFsType.CreationDate = DateHandlers.MacToDateTime(volMDB.drCrDate);
XmlFsType.CreationDateSpecified = true;
}
XmlFsType.Files = volMDB.drNmFls;
XmlFsType.FilesSpecified = true;
XmlFsType.FreeClusters = volMDB.drFreeBks;
XmlFsType.FreeClustersSpecified = true;
XmlFsType.Type = "MFS";
XmlFsType.VolumeName = volMDB.drVN;
return(Errno.NoError);
}
public bool Identify(IMediaImage imagePlugin, Partition partition)
{
try
{
if (imagePlugin.Info.ReadableSectorTags == null)
{
return(false);
}
if (!imagePlugin.Info.ReadableSectorTags.Contains(SectorTagType.AppleSectorTag))
{
return(false);
}
// Minimal LisaOS disk is 3.5" single sided double density, 800 sectors
if (imagePlugin.Info.Sectors < 800)
{
return(false);
}
int beforeMddf = -1;
// LisaOS searches sectors until tag tells MDDF resides there, so we'll search 100 sectors
for (int i = 0; i < 100; i++)
{
DecodeTag(imagePlugin.ReadSectorTag((ulong)i, SectorTagType.AppleSectorTag),
out LisaTag.PriamTag searchTag);
DicConsole.DebugWriteLine("LisaFS plugin", "Sector {0}, file ID 0x{1:X4}", i, searchTag.FileId);
if (beforeMddf == -1 && searchTag.FileId == FILEID_LOADER_SIGNED)
{
beforeMddf = i - 1;
}
if (searchTag.FileId != FILEID_MDDF)
{
continue;
}
byte[] sector = imagePlugin.ReadSector((ulong)i);
MDDF infoMddf = new MDDF
{
mddf_block = BigEndianBitConverter.ToUInt32(sector, 0x6C),
volsize_minus_one = BigEndianBitConverter.ToUInt32(sector, 0x70),
volsize_minus_mddf_minus_one = BigEndianBitConverter.ToUInt32(sector, 0x74),
vol_size = BigEndianBitConverter.ToUInt32(sector, 0x78),
blocksize = BigEndianBitConverter.ToUInt16(sector, 0x7C),
datasize = BigEndianBitConverter.ToUInt16(sector, 0x7E)
};
DicConsole.DebugWriteLine("LisaFS plugin", "Current sector = {0}", i);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.mddf_block = {0}", infoMddf.mddf_block);
DicConsole.DebugWriteLine("LisaFS plugin", "Disk size = {0} sectors", imagePlugin.Info.Sectors);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.vol_size = {0} sectors", infoMddf.vol_size);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.vol_size - 1 = {0}",
infoMddf.volsize_minus_one);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.vol_size - mddf.mddf_block -1 = {0}",
infoMddf.volsize_minus_mddf_minus_one);
DicConsole.DebugWriteLine("LisaFS plugin", "Disk sector = {0} bytes",
imagePlugin.Info.SectorSize);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.blocksize = {0} bytes", infoMddf.blocksize);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.datasize = {0} bytes", infoMddf.datasize);
if (infoMddf.mddf_block != i - beforeMddf)
{
return(false);
}
if (infoMddf.vol_size > imagePlugin.Info.Sectors)
{
return(false);
}
if (infoMddf.vol_size - 1 != infoMddf.volsize_minus_one)
{
return(false);
}
if (infoMddf.vol_size - i - 1 != infoMddf.volsize_minus_mddf_minus_one - beforeMddf)
{
return(false);
}
if (infoMddf.datasize > infoMddf.blocksize)
{
return(false);
}
if (infoMddf.blocksize < imagePlugin.Info.SectorSize)
{
return(false);
}
return(infoMddf.datasize == imagePlugin.Info.SectorSize);
}
return(false);
}
catch (Exception ex)
{
DicConsole.ErrorWriteLine("Exception {0}, {1}, {2}", ex.Message, ex.InnerException, ex.StackTrace);
return(false);
}
}
public void GetInformation(IMediaImage imagePlugin, Partition partition, out string information,
Encoding encoding)
{
Encoding = new LisaRoman();
information = "";
StringBuilder sb = new StringBuilder();
try
{
if (imagePlugin.Info.ReadableSectorTags == null)
{
return;
}
if (!imagePlugin.Info.ReadableSectorTags.Contains(SectorTagType.AppleSectorTag))
{
return;
}
// Minimal LisaOS disk is 3.5" single sided double density, 800 sectors
if (imagePlugin.Info.Sectors < 800)
{
return;
}
int beforeMddf = -1;
// LisaOS searches sectors until tag tells MDDF resides there, so we'll search 100 sectors
for (int i = 0; i < 100; i++)
{
DecodeTag(imagePlugin.ReadSectorTag((ulong)i, SectorTagType.AppleSectorTag),
out LisaTag.PriamTag searchTag);
DicConsole.DebugWriteLine("LisaFS plugin", "Sector {0}, file ID 0x{1:X4}", i, searchTag.FileId);
if (beforeMddf == -1 && searchTag.FileId == FILEID_LOADER_SIGNED)
{
beforeMddf = i - 1;
}
if (searchTag.FileId != FILEID_MDDF)
{
continue;
}
byte[] sector = imagePlugin.ReadSector((ulong)i);
MDDF infoMddf = new MDDF();
byte[] pString = new byte[33];
infoMddf.fsversion = BigEndianBitConverter.ToUInt16(sector, 0x00);
infoMddf.volid = BigEndianBitConverter.ToUInt64(sector, 0x02);
infoMddf.volnum = BigEndianBitConverter.ToUInt16(sector, 0x0A);
Array.Copy(sector, 0x0C, pString, 0, 33);
infoMddf.volname = StringHandlers.PascalToString(pString, Encoding);
infoMddf.unknown1 = sector[0x2D];
Array.Copy(sector, 0x2E, pString, 0, 33);
// Prevent garbage
infoMddf.password = pString[0] <= 32 ? StringHandlers.PascalToString(pString, Encoding) : "";
infoMddf.unknown2 = sector[0x4F];
infoMddf.machine_id = BigEndianBitConverter.ToUInt32(sector, 0x50);
infoMddf.master_copy_id = BigEndianBitConverter.ToUInt32(sector, 0x54);
uint lisaTime = BigEndianBitConverter.ToUInt32(sector, 0x58);
infoMddf.dtvc = DateHandlers.LisaToDateTime(lisaTime);
lisaTime = BigEndianBitConverter.ToUInt32(sector, 0x5C);
infoMddf.dtcc = DateHandlers.LisaToDateTime(lisaTime);
lisaTime = BigEndianBitConverter.ToUInt32(sector, 0x60);
infoMddf.dtvb = DateHandlers.LisaToDateTime(lisaTime);
lisaTime = BigEndianBitConverter.ToUInt32(sector, 0x64);
infoMddf.dtvs = DateHandlers.LisaToDateTime(lisaTime);
infoMddf.unknown3 = BigEndianBitConverter.ToUInt32(sector, 0x68);
infoMddf.mddf_block = BigEndianBitConverter.ToUInt32(sector, 0x6C);
infoMddf.volsize_minus_one = BigEndianBitConverter.ToUInt32(sector, 0x70);
infoMddf.volsize_minus_mddf_minus_one = BigEndianBitConverter.ToUInt32(sector, 0x74);
infoMddf.vol_size = BigEndianBitConverter.ToUInt32(sector, 0x78);
infoMddf.blocksize = BigEndianBitConverter.ToUInt16(sector, 0x7C);
infoMddf.datasize = BigEndianBitConverter.ToUInt16(sector, 0x7E);
infoMddf.unknown4 = BigEndianBitConverter.ToUInt16(sector, 0x80);
infoMddf.unknown5 = BigEndianBitConverter.ToUInt32(sector, 0x82);
infoMddf.unknown6 = BigEndianBitConverter.ToUInt32(sector, 0x86);
infoMddf.clustersize = BigEndianBitConverter.ToUInt16(sector, 0x8A);
infoMddf.fs_size = BigEndianBitConverter.ToUInt32(sector, 0x8C);
infoMddf.unknown7 = BigEndianBitConverter.ToUInt32(sector, 0x90);
infoMddf.srec_ptr = BigEndianBitConverter.ToUInt32(sector, 0x94);
infoMddf.unknown9 = BigEndianBitConverter.ToUInt16(sector, 0x98);
infoMddf.srec_len = BigEndianBitConverter.ToUInt16(sector, 0x9A);
infoMddf.unknown10 = BigEndianBitConverter.ToUInt32(sector, 0x9C);
infoMddf.unknown11 = BigEndianBitConverter.ToUInt32(sector, 0xA0);
infoMddf.unknown12 = BigEndianBitConverter.ToUInt32(sector, 0xA4);
infoMddf.unknown13 = BigEndianBitConverter.ToUInt32(sector, 0xA8);
infoMddf.unknown14 = BigEndianBitConverter.ToUInt32(sector, 0xAC);
infoMddf.filecount = BigEndianBitConverter.ToUInt16(sector, 0xB0);
infoMddf.unknown15 = BigEndianBitConverter.ToUInt32(sector, 0xB2);
infoMddf.unknown16 = BigEndianBitConverter.ToUInt32(sector, 0xB6);
infoMddf.freecount = BigEndianBitConverter.ToUInt32(sector, 0xBA);
infoMddf.unknown17 = BigEndianBitConverter.ToUInt16(sector, 0xBE);
infoMddf.unknown18 = BigEndianBitConverter.ToUInt32(sector, 0xC0);
infoMddf.overmount_stamp = BigEndianBitConverter.ToUInt64(sector, 0xC4);
infoMddf.serialization = BigEndianBitConverter.ToUInt32(sector, 0xCC);
infoMddf.unknown19 = BigEndianBitConverter.ToUInt32(sector, 0xD0);
infoMddf.unknown_timestamp = BigEndianBitConverter.ToUInt32(sector, 0xD4);
infoMddf.unknown20 = BigEndianBitConverter.ToUInt32(sector, 0xD8);
infoMddf.unknown21 = BigEndianBitConverter.ToUInt32(sector, 0xDC);
infoMddf.unknown22 = BigEndianBitConverter.ToUInt32(sector, 0xE0);
infoMddf.unknown23 = BigEndianBitConverter.ToUInt32(sector, 0xE4);
infoMddf.unknown24 = BigEndianBitConverter.ToUInt32(sector, 0xE8);
infoMddf.unknown25 = BigEndianBitConverter.ToUInt32(sector, 0xEC);
infoMddf.unknown26 = BigEndianBitConverter.ToUInt32(sector, 0xF0);
infoMddf.unknown27 = BigEndianBitConverter.ToUInt32(sector, 0xF4);
infoMddf.unknown28 = BigEndianBitConverter.ToUInt32(sector, 0xF8);
infoMddf.unknown29 = BigEndianBitConverter.ToUInt32(sector, 0xFC);
infoMddf.unknown30 = BigEndianBitConverter.ToUInt32(sector, 0x100);
infoMddf.unknown31 = BigEndianBitConverter.ToUInt32(sector, 0x104);
infoMddf.unknown32 = BigEndianBitConverter.ToUInt32(sector, 0x108);
infoMddf.unknown33 = BigEndianBitConverter.ToUInt32(sector, 0x10C);
infoMddf.unknown34 = BigEndianBitConverter.ToUInt32(sector, 0x110);
infoMddf.unknown35 = BigEndianBitConverter.ToUInt32(sector, 0x114);
infoMddf.backup_volid = BigEndianBitConverter.ToUInt64(sector, 0x118);
infoMddf.label_size = BigEndianBitConverter.ToUInt16(sector, 0x120);
infoMddf.fs_overhead = BigEndianBitConverter.ToUInt16(sector, 0x122);
infoMddf.result_scavenge = BigEndianBitConverter.ToUInt16(sector, 0x124);
infoMddf.boot_code = BigEndianBitConverter.ToUInt16(sector, 0x126);
infoMddf.boot_environ = BigEndianBitConverter.ToUInt16(sector, 0x6C);
infoMddf.unknown36 = BigEndianBitConverter.ToUInt32(sector, 0x12A);
infoMddf.unknown37 = BigEndianBitConverter.ToUInt32(sector, 0x12E);
infoMddf.unknown38 = BigEndianBitConverter.ToUInt32(sector, 0x132);
infoMddf.vol_sequence = BigEndianBitConverter.ToUInt16(sector, 0x136);
infoMddf.vol_left_mounted = sector[0x138];
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown1 = 0x{0:X2} ({0})", infoMddf.unknown1);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown2 = 0x{0:X2} ({0})", infoMddf.unknown2);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown3 = 0x{0:X8} ({0})", infoMddf.unknown3);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown4 = 0x{0:X4} ({0})", infoMddf.unknown4);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown5 = 0x{0:X8} ({0})", infoMddf.unknown5);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown6 = 0x{0:X8} ({0})", infoMddf.unknown6);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown7 = 0x{0:X8} ({0})", infoMddf.unknown7);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown9 = 0x{0:X4} ({0})", infoMddf.unknown9);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown10 = 0x{0:X8} ({0})", infoMddf.unknown10);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown11 = 0x{0:X8} ({0})", infoMddf.unknown11);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown12 = 0x{0:X8} ({0})", infoMddf.unknown12);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown13 = 0x{0:X8} ({0})", infoMddf.unknown13);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown14 = 0x{0:X8} ({0})", infoMddf.unknown14);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown15 = 0x{0:X8} ({0})", infoMddf.unknown15);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown16 = 0x{0:X8} ({0})", infoMddf.unknown16);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown17 = 0x{0:X4} ({0})", infoMddf.unknown17);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown18 = 0x{0:X8} ({0})", infoMddf.unknown18);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown19 = 0x{0:X8} ({0})", infoMddf.unknown19);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown20 = 0x{0:X8} ({0})", infoMddf.unknown20);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown21 = 0x{0:X8} ({0})", infoMddf.unknown21);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown22 = 0x{0:X8} ({0})", infoMddf.unknown22);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown23 = 0x{0:X8} ({0})", infoMddf.unknown23);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown24 = 0x{0:X8} ({0})", infoMddf.unknown24);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown25 = 0x{0:X8} ({0})", infoMddf.unknown25);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown26 = 0x{0:X8} ({0})", infoMddf.unknown26);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown27 = 0x{0:X8} ({0})", infoMddf.unknown27);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown28 = 0x{0:X8} ({0})", infoMddf.unknown28);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown29 = 0x{0:X8} ({0})", infoMddf.unknown29);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown30 = 0x{0:X8} ({0})", infoMddf.unknown30);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown31 = 0x{0:X8} ({0})", infoMddf.unknown31);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown32 = 0x{0:X8} ({0})", infoMddf.unknown32);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown33 = 0x{0:X8} ({0})", infoMddf.unknown33);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown34 = 0x{0:X8} ({0})", infoMddf.unknown34);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown35 = 0x{0:X8} ({0})", infoMddf.unknown35);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown36 = 0x{0:X8} ({0})", infoMddf.unknown36);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown37 = 0x{0:X8} ({0})", infoMddf.unknown37);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown38 = 0x{0:X8} ({0})", infoMddf.unknown38);
DicConsole.DebugWriteLine("LisaFS plugin", "mddf.unknown_timestamp = 0x{0:X8} ({0}, {1})",
infoMddf.unknown_timestamp,
DateHandlers.LisaToDateTime(infoMddf.unknown_timestamp));
if (infoMddf.mddf_block != i - beforeMddf)
{
return;
}
if (infoMddf.vol_size > imagePlugin.Info.Sectors)
{
return;
}
if (infoMddf.vol_size - 1 != infoMddf.volsize_minus_one)
{
return;
}
if (infoMddf.vol_size - i - 1 != infoMddf.volsize_minus_mddf_minus_one - beforeMddf)
{
return;
}
if (infoMddf.datasize > infoMddf.blocksize)
{
return;
}
if (infoMddf.blocksize < imagePlugin.Info.SectorSize)
{
return;
}
if (infoMddf.datasize != imagePlugin.Info.SectorSize)
{
return;
}
switch (infoMddf.fsversion)
{
case LISA_V1:
sb.AppendLine("LisaFS v1");
break;
case LISA_V2:
sb.AppendLine("LisaFS v2");
break;
case LISA_V3:
sb.AppendLine("LisaFS v3");
break;
default:
sb.AppendFormat("Uknown LisaFS version {0}", infoMddf.fsversion).AppendLine();
break;
}
sb.AppendFormat("Volume name: \"{0}\"", infoMddf.volname).AppendLine();
sb.AppendFormat("Volume password: \"{0}\"", infoMddf.password).AppendLine();
sb.AppendFormat("Volume ID: 0x{0:X16}", infoMddf.volid).AppendLine();
sb.AppendFormat("Backup volume ID: 0x{0:X16}", infoMddf.backup_volid).AppendLine();
sb.AppendFormat("Master copy ID: 0x{0:X8}", infoMddf.master_copy_id).AppendLine();
sb.AppendFormat("Volume is number {0} of {1}", infoMddf.volnum, infoMddf.vol_sequence).AppendLine();
sb.AppendFormat("Serial number of Lisa computer that created this volume: {0}", infoMddf.machine_id)
.AppendLine();
sb.AppendFormat("Serial number of Lisa computer that can use this volume's software {0}",
infoMddf.serialization).AppendLine();
sb.AppendFormat("Volume created on {0}", infoMddf.dtvc).AppendLine();
sb.AppendFormat("Some timestamp, says {0}", infoMddf.dtcc).AppendLine();
sb.AppendFormat("Volume backed up on {0}", infoMddf.dtvb).AppendLine();
sb.AppendFormat("Volume scavenged on {0}", infoMddf.dtvs).AppendLine();
sb.AppendFormat("MDDF is in block {0}", infoMddf.mddf_block + beforeMddf).AppendLine();
sb.AppendFormat("There are {0} reserved blocks before volume", beforeMddf).AppendLine();
sb.AppendFormat("{0} blocks minus one", infoMddf.volsize_minus_one).AppendLine();
sb.AppendFormat("{0} blocks minus one minus MDDF offset", infoMddf.volsize_minus_mddf_minus_one)
.AppendLine();
sb.AppendFormat("{0} blocks in volume", infoMddf.vol_size).AppendLine();
sb.AppendFormat("{0} bytes per sector (uncooked)", infoMddf.blocksize).AppendLine();
sb.AppendFormat("{0} bytes per sector", infoMddf.datasize).AppendLine();
sb.AppendFormat("{0} blocks per cluster", infoMddf.clustersize).AppendLine();
sb.AppendFormat("{0} blocks in filesystem", infoMddf.fs_size).AppendLine();
sb.AppendFormat("{0} files in volume", infoMddf.filecount).AppendLine();
sb.AppendFormat("{0} blocks free", infoMddf.freecount).AppendLine();
sb.AppendFormat("{0} bytes in LisaInfo", infoMddf.label_size).AppendLine();
sb.AppendFormat("Filesystem overhead: {0}", infoMddf.fs_overhead).AppendLine();
sb.AppendFormat("Scanvenger result code: 0x{0:X8}", infoMddf.result_scavenge).AppendLine();
sb.AppendFormat("Boot code: 0x{0:X8}", infoMddf.boot_code).AppendLine();
sb.AppendFormat("Boot environment: 0x{0:X8}", infoMddf.boot_environ).AppendLine();
sb.AppendFormat("Overmount stamp: 0x{0:X16}", infoMddf.overmount_stamp).AppendLine();
sb.AppendFormat("S-Records start at {0} and spans for {1} blocks",
infoMddf.srec_ptr + infoMddf.mddf_block + beforeMddf, infoMddf.srec_len)
.AppendLine();
sb.AppendLine(infoMddf.vol_left_mounted == 0 ? "Volume is clean" : "Volume is dirty");
information = sb.ToString();
XmlFsType = new FileSystemType();
if (DateTime.Compare(infoMddf.dtvb, DateHandlers.LisaToDateTime(0)) > 0)
{
XmlFsType.BackupDate = infoMddf.dtvb;
XmlFsType.BackupDateSpecified = true;
}
XmlFsType.Clusters = infoMddf.vol_size;
XmlFsType.ClusterSize = (uint)(infoMddf.clustersize * infoMddf.datasize);
if (DateTime.Compare(infoMddf.dtvc, DateHandlers.LisaToDateTime(0)) > 0)
{
XmlFsType.CreationDate = infoMddf.dtvc;
XmlFsType.CreationDateSpecified = true;
}
XmlFsType.Dirty = infoMddf.vol_left_mounted != 0;
XmlFsType.Files = infoMddf.filecount;
XmlFsType.FilesSpecified = true;
XmlFsType.FreeClusters = infoMddf.freecount;
XmlFsType.FreeClustersSpecified = true;
XmlFsType.Type = "LisaFS";
XmlFsType.VolumeName = infoMddf.volname;
XmlFsType.VolumeSerial = $"{infoMddf.volid:X16}";
return;
}
}
catch (Exception ex)
{
DicConsole.ErrorWriteLine("Exception {0}, {1}, {2}", ex.Message, ex.InnerException, ex.StackTrace);
}
}
/// <summary>
/// Mounts an Apple Lisa filesystem
/// </summary>
public Errno Mount(IMediaImage imagePlugin, Partition partition, Encoding encoding,
Dictionary <string, string> options, string @namespace)
{
try
{
device = imagePlugin;
Encoding = new LisaRoman();
// Lisa OS is unable to work on disks without tags.
// This code is designed like that.
// However with some effort the code may be modified to ignore them.
if (device.Info.ReadableSectorTags == null ||
!device.Info.ReadableSectorTags.Contains(SectorTagType.AppleSectorTag))
{
DicConsole.DebugWriteLine("LisaFS plugin", "Underlying device does not support Lisa tags");
return(Errno.InOutError);
}
// Minimal LisaOS disk is 3.5" single sided double density, 800 sectors
if (device.Info.Sectors < 800)
{
DicConsole.DebugWriteLine("LisaFS plugin", "Device is too small");
return(Errno.InOutError);
}
// MDDF cannot be at end of device, of course
volumePrefix = device.Info.Sectors;
// LisaOS searches sectors until tag tells MDDF resides there, so we'll search 100 sectors
for (ulong i = 0; i < 100; i++)
{
DecodeTag(device.ReadSectorTag(i, SectorTagType.AppleSectorTag), out LisaTag.PriamTag searchTag);
DicConsole.DebugWriteLine("LisaFS plugin", "Sector {0}, file ID 0x{1:X4}", i, searchTag.FileId);
if (volumePrefix == device.Info.Sectors && searchTag.FileId == FILEID_LOADER_SIGNED)
{
volumePrefix = i - 1;
}
if (searchTag.FileId != FILEID_MDDF)
{
continue;
}
devTagSize = device.ReadSectorTag(i, SectorTagType.AppleSectorTag).Length;
byte[] sector = device.ReadSector(i);
mddf = new MDDF();
byte[] pString = new byte[33];
mddf.fsversion = BigEndianBitConverter.ToUInt16(sector, 0x00);
mddf.volid = BigEndianBitConverter.ToUInt64(sector, 0x02);
mddf.volnum = BigEndianBitConverter.ToUInt16(sector, 0x0A);
Array.Copy(sector, 0x0C, pString, 0, 33);
mddf.volname = StringHandlers.PascalToString(pString, Encoding);
mddf.unknown1 = sector[0x2D];
Array.Copy(sector, 0x2E, pString, 0, 33);
// Prevent garbage
mddf.password = pString[0] <= 32 ? StringHandlers.PascalToString(pString, Encoding) : "";
mddf.unknown2 = sector[0x4F];
mddf.machine_id = BigEndianBitConverter.ToUInt32(sector, 0x50);
mddf.master_copy_id = BigEndianBitConverter.ToUInt32(sector, 0x54);
uint lisaTime = BigEndianBitConverter.ToUInt32(sector, 0x58);
mddf.dtvc = DateHandlers.LisaToDateTime(lisaTime);
lisaTime = BigEndianBitConverter.ToUInt32(sector, 0x5C);
mddf.dtcc = DateHandlers.LisaToDateTime(lisaTime);
lisaTime = BigEndianBitConverter.ToUInt32(sector, 0x60);
mddf.dtvb = DateHandlers.LisaToDateTime(lisaTime);
lisaTime = BigEndianBitConverter.ToUInt32(sector, 0x64);
mddf.dtvs = DateHandlers.LisaToDateTime(lisaTime);
mddf.unknown3 = BigEndianBitConverter.ToUInt32(sector, 0x68);
mddf.mddf_block = BigEndianBitConverter.ToUInt32(sector, 0x6C);
mddf.volsize_minus_one = BigEndianBitConverter.ToUInt32(sector, 0x70);
mddf.volsize_minus_mddf_minus_one = BigEndianBitConverter.ToUInt32(sector, 0x74);
mddf.vol_size = BigEndianBitConverter.ToUInt32(sector, 0x78);
mddf.blocksize = BigEndianBitConverter.ToUInt16(sector, 0x7C);
mddf.datasize = BigEndianBitConverter.ToUInt16(sector, 0x7E);
mddf.unknown4 = BigEndianBitConverter.ToUInt16(sector, 0x80);
mddf.unknown5 = BigEndianBitConverter.ToUInt32(sector, 0x82);
mddf.unknown6 = BigEndianBitConverter.ToUInt32(sector, 0x86);
mddf.clustersize = BigEndianBitConverter.ToUInt16(sector, 0x8A);
mddf.fs_size = BigEndianBitConverter.ToUInt32(sector, 0x8C);
mddf.unknown7 = BigEndianBitConverter.ToUInt32(sector, 0x90);
mddf.srec_ptr = BigEndianBitConverter.ToUInt32(sector, 0x94);
mddf.unknown9 = BigEndianBitConverter.ToUInt16(sector, 0x98);
mddf.srec_len = BigEndianBitConverter.ToUInt16(sector, 0x9A);
mddf.unknown10 = BigEndianBitConverter.ToUInt32(sector, 0x9C);
mddf.unknown11 = BigEndianBitConverter.ToUInt32(sector, 0xA0);
mddf.unknown12 = BigEndianBitConverter.ToUInt32(sector, 0xA4);
mddf.unknown13 = BigEndianBitConverter.ToUInt32(sector, 0xA8);
mddf.unknown14 = BigEndianBitConverter.ToUInt32(sector, 0xAC);
mddf.filecount = BigEndianBitConverter.ToUInt16(sector, 0xB0);
mddf.unknown15 = BigEndianBitConverter.ToUInt32(sector, 0xB2);
mddf.unknown16 = BigEndianBitConverter.ToUInt32(sector, 0xB6);
mddf.freecount = BigEndianBitConverter.ToUInt32(sector, 0xBA);
mddf.unknown17 = BigEndianBitConverter.ToUInt16(sector, 0xBE);
mddf.unknown18 = BigEndianBitConverter.ToUInt32(sector, 0xC0);
mddf.overmount_stamp = BigEndianBitConverter.ToUInt64(sector, 0xC4);
mddf.serialization = BigEndianBitConverter.ToUInt32(sector, 0xCC);
mddf.unknown19 = BigEndianBitConverter.ToUInt32(sector, 0xD0);
mddf.unknown_timestamp = BigEndianBitConverter.ToUInt32(sector, 0xD4);
mddf.unknown20 = BigEndianBitConverter.ToUInt32(sector, 0xD8);
mddf.unknown21 = BigEndianBitConverter.ToUInt32(sector, 0xDC);
mddf.unknown22 = BigEndianBitConverter.ToUInt32(sector, 0xE0);
mddf.unknown23 = BigEndianBitConverter.ToUInt32(sector, 0xE4);
mddf.unknown24 = BigEndianBitConverter.ToUInt32(sector, 0xE8);
mddf.unknown25 = BigEndianBitConverter.ToUInt32(sector, 0xEC);
mddf.unknown26 = BigEndianBitConverter.ToUInt32(sector, 0xF0);
mddf.unknown27 = BigEndianBitConverter.ToUInt32(sector, 0xF4);
mddf.unknown28 = BigEndianBitConverter.ToUInt32(sector, 0xF8);
mddf.unknown29 = BigEndianBitConverter.ToUInt32(sector, 0xFC);
mddf.unknown30 = BigEndianBitConverter.ToUInt32(sector, 0x100);
mddf.unknown31 = BigEndianBitConverter.ToUInt32(sector, 0x104);
mddf.unknown32 = BigEndianBitConverter.ToUInt32(sector, 0x108);
mddf.unknown33 = BigEndianBitConverter.ToUInt32(sector, 0x10C);
mddf.unknown34 = BigEndianBitConverter.ToUInt32(sector, 0x110);
mddf.unknown35 = BigEndianBitConverter.ToUInt32(sector, 0x114);
mddf.backup_volid = BigEndianBitConverter.ToUInt64(sector, 0x118);
mddf.label_size = BigEndianBitConverter.ToUInt16(sector, 0x120);
mddf.fs_overhead = BigEndianBitConverter.ToUInt16(sector, 0x122);
mddf.result_scavenge = BigEndianBitConverter.ToUInt16(sector, 0x124);
mddf.boot_code = BigEndianBitConverter.ToUInt16(sector, 0x126);
mddf.boot_environ = BigEndianBitConverter.ToUInt16(sector, 0x6C);
mddf.unknown36 = BigEndianBitConverter.ToUInt32(sector, 0x12A);
mddf.unknown37 = BigEndianBitConverter.ToUInt32(sector, 0x12E);
mddf.unknown38 = BigEndianBitConverter.ToUInt32(sector, 0x132);
mddf.vol_sequence = BigEndianBitConverter.ToUInt16(sector, 0x136);
mddf.vol_left_mounted = sector[0x138];
// Check that the MDDF is correct
if (mddf.mddf_block != i - volumePrefix ||
mddf.vol_size > device.Info.Sectors ||
mddf.vol_size - 1 !=
mddf.volsize_minus_one ||
mddf.vol_size - i - 1 !=
mddf.volsize_minus_mddf_minus_one - volumePrefix ||
mddf.datasize >
mddf.blocksize || mddf.blocksize < device.Info.SectorSize ||
mddf.datasize != device.Info.SectorSize)
{
DicConsole.DebugWriteLine("LisaFS plugin", "Incorrect MDDF found");
return(Errno.InvalidArgument);
}
// Check MDDF version
switch (mddf.fsversion)
{
case LISA_V1:
DicConsole.DebugWriteLine("LisaFS plugin", "Mounting LisaFS v1");
break;
case LISA_V2:
DicConsole.DebugWriteLine("LisaFS plugin", "Mounting LisaFS v2");
break;
case LISA_V3:
DicConsole.DebugWriteLine("LisaFS plugin", "Mounting LisaFS v3");
break;
default:
DicConsole.ErrorWriteLine("Cannot mount LisaFS version {0}", mddf.fsversion.ToString());
return(Errno.NotSupported);
}
// Initialize caches
extentCache = new Dictionary <short, ExtentFile>();
systemFileCache = new Dictionary <short, byte[]>();
fileCache = new Dictionary <short, byte[]>();
//catalogCache = new Dictionary<short, List<CatalogEntry>>();
fileSizeCache = new Dictionary <short, int>();
mounted = true;
if (options == null)
{
options = GetDefaultOptions();
}
if (options.TryGetValue("debug", out string debugString))
{
bool.TryParse(debugString, out debug);
}
if (debug)
{
printedExtents = new List <short>();
}
// Read the S-Records file
Errno error = ReadSRecords();
if (error != Errno.NoError)
{
DicConsole.ErrorWriteLine("Error {0} reading S-Records file.", error);
return(error);
}
directoryDtcCache = new Dictionary <short, DateTime> {
{ DIRID_ROOT, mddf.dtcc }
};
// Read the Catalog File
error = ReadCatalog();
if (error != Errno.NoError)
{
DicConsole.DebugWriteLine("LisaFS plugin", "Cannot read Catalog File, error {0}",
error.ToString());
mounted = false;
return(error);
}
// If debug, cache system files
if (debug)
{
error = ReadSystemFile(FILEID_BOOT_SIGNED, out _);
if (error != Errno.NoError)
{
DicConsole.DebugWriteLine("LisaFS plugin", "Unable to read boot blocks");
mounted = false;
return(error);
}
error = ReadSystemFile(FILEID_LOADER_SIGNED, out _);
if (error != Errno.NoError)
{
DicConsole.DebugWriteLine("LisaFS plugin", "Unable to read boot loader");
mounted = false;
return(error);
}
error = ReadSystemFile((short)FILEID_MDDF, out _);
if (error != Errno.NoError)
{
DicConsole.DebugWriteLine("LisaFS plugin", "Unable to read MDDF");
mounted = false;
return(error);
}
error = ReadSystemFile((short)FILEID_BITMAP, out _);
if (error != Errno.NoError)
{
DicConsole.DebugWriteLine("LisaFS plugin", "Unable to read volume bitmap");
mounted = false;
return(error);
}
error = ReadSystemFile((short)FILEID_SRECORD, out _);
if (error != Errno.NoError)
{
DicConsole.DebugWriteLine("LisaFS plugin", "Unable to read S-Records file");
mounted = false;
return(error);
}
}
// Create XML metadata for mounted filesystem
XmlFsType = new FileSystemType();
if (DateTime.Compare(mddf.dtvb, DateHandlers.LisaToDateTime(0)) > 0)
{
XmlFsType.BackupDate = mddf.dtvb;
XmlFsType.BackupDateSpecified = true;
}
XmlFsType.Clusters = mddf.vol_size;
XmlFsType.ClusterSize = (uint)(mddf.clustersize * mddf.datasize);
if (DateTime.Compare(mddf.dtvc, DateHandlers.LisaToDateTime(0)) > 0)
{
XmlFsType.CreationDate = mddf.dtvc;
XmlFsType.CreationDateSpecified = true;
}
XmlFsType.Dirty = mddf.vol_left_mounted != 0;
XmlFsType.Files = mddf.filecount;
XmlFsType.FilesSpecified = true;
XmlFsType.FreeClusters = mddf.freecount;
XmlFsType.FreeClustersSpecified = true;
XmlFsType.Type = "LisaFS";
XmlFsType.VolumeName = mddf.volname;
XmlFsType.VolumeSerial = $"{mddf.volid:X16}";
return(Errno.NoError);
}
DicConsole.DebugWriteLine("LisaFS plugin", "Not a Lisa filesystem");
return(Errno.NotSupported);
}
catch (Exception ex)
{
DicConsole.ErrorWriteLine("Exception {0}, {1}, {2}", ex.Message, ex.InnerException, ex.StackTrace);
return(Errno.InOutError);
}
}
public void Convert()
{
Environment.CurrentDirectory = DataFolder;
Resume resume = null;
CICMMetadataType sidecar = null;
var filtersList = new FiltersList();
IFilter inputFilter = filtersList.GetFilter(InputPath);
Assert.IsNotNull(inputFilter, "Cannot open specified file.");
string outputPath = Path.Combine(Path.GetTempPath(), SuggestedOutputFilename);
Assert.IsFalse(File.Exists(outputPath), "Output file already exists, not continuing.");
IMediaImage inputFormat = ImageFormat.Detect(inputFilter);
Assert.IsNotNull(inputFormat, "Input image format not identified, not proceeding with conversion.");
Assert.IsTrue(inputFormat.Open(inputFilter), "Unable to open image format");
Assert.IsTrue(OutputFormat.SupportedMediaTypes.Contains(inputFormat.Info.MediaType),
"Output format does not support media type, cannot continue...");
if (inputFormat.Info.ReadableSectorTags.Count == 0)
{
Assert.IsFalse(UseLong, "Input image does not support long sectors.");
}
var inputOptical = inputFormat as IOpticalMediaImage;
var outputOptical = OutputFormat as IWritableOpticalImage;
Assert.IsNotNull(inputOptical, "Could not treat existing image as optical disc.");
Assert.IsNotNull(outputOptical, "Could not treat new image as optical disc.");
Assert.IsNotNull(inputOptical.Tracks, "Existing image contains no tracks.");
Assert.IsTrue(outputOptical.Create(outputPath, inputFormat.Info.MediaType, ParsedOptions, inputFormat.Info.Sectors, inputFormat.Info.SectorSize),
$"Error {outputOptical.ErrorMessage} creating output image.");
var metadata = new ImageInfo
{
Application = "Aaru",
ApplicationVersion = Version.GetVersion(),
Comments = inputFormat.Info.Comments,
Creator = inputFormat.Info.Creator,
DriveFirmwareRevision = inputFormat.Info.DriveFirmwareRevision,
DriveManufacturer = inputFormat.Info.DriveManufacturer,
DriveModel = inputFormat.Info.DriveModel,
DriveSerialNumber = inputFormat.Info.DriveSerialNumber,
LastMediaSequence = inputFormat.Info.LastMediaSequence,
MediaBarcode = inputFormat.Info.MediaBarcode,
MediaManufacturer = inputFormat.Info.MediaManufacturer,
MediaModel = inputFormat.Info.MediaModel,
MediaPartNumber = inputFormat.Info.MediaPartNumber,
MediaSequence = inputFormat.Info.MediaSequence,
MediaSerialNumber = inputFormat.Info.MediaSerialNumber,
MediaTitle = inputFormat.Info.MediaTitle
};
Assert.IsTrue(outputOptical.SetMetadata(metadata),
$"Error {outputOptical.ErrorMessage} setting metadata, ");
CICMMetadataType cicmMetadata = inputFormat.CicmMetadata;
List <DumpHardwareType> dumpHardware = inputFormat.DumpHardware;
foreach (MediaTagType mediaTag in inputFormat.Info.ReadableMediaTags.Where(mediaTag =>
outputOptical.SupportedMediaTags.Contains(mediaTag)))
{
AaruConsole.WriteLine("Converting media tag {0}", mediaTag);
byte[] tag = inputFormat.ReadDiskTag(mediaTag);
Assert.IsTrue(outputOptical.WriteMediaTag(tag, mediaTag));
}
AaruConsole.WriteLine("{0} sectors to convert", inputFormat.Info.Sectors);
ulong doneSectors;
Assert.IsTrue(outputOptical.SetTracks(inputOptical.Tracks),
$"Error {outputOptical.ErrorMessage} sending tracks list to output image.");
foreach (Track track in inputOptical.Tracks)
{
doneSectors = 0;
ulong trackSectors = track.TrackEndSector - track.TrackStartSector + 1;
while (doneSectors < trackSectors)
{
byte[] sector;
uint sectorsToDo;
if (trackSectors - doneSectors >= SECTORS_TO_READ)
{
sectorsToDo = SECTORS_TO_READ;
}
else
{
sectorsToDo = (uint)(trackSectors - doneSectors);
}
bool useNotLong = false;
bool result = false;
if (UseLong)
{
if (sectorsToDo == 1)
{
sector = inputFormat.ReadSectorLong(doneSectors + track.TrackStartSector);
result = outputOptical.WriteSectorLong(sector, doneSectors + track.TrackStartSector);
}
else
{
sector = inputFormat.ReadSectorsLong(doneSectors + track.TrackStartSector, sectorsToDo);
result = outputOptical.WriteSectorsLong(sector, doneSectors + track.TrackStartSector,
sectorsToDo);
}
if (!result &&
sector.Length % 2352 != 0)
{
useNotLong = true;
}
}
if (!UseLong || useNotLong)
{
if (sectorsToDo == 1)
{
sector = inputFormat.ReadSector(doneSectors + track.TrackStartSector);
result = outputOptical.WriteSector(sector, doneSectors + track.TrackStartSector);
}
else
{
sector = inputFormat.ReadSectors(doneSectors + track.TrackStartSector, sectorsToDo);
result = outputOptical.WriteSectors(sector, doneSectors + track.TrackStartSector,
sectorsToDo);
}
}
Assert.IsTrue(result,
$"Error {outputOptical.ErrorMessage} writing sector {doneSectors + track.TrackStartSector}, not continuing...");
doneSectors += sectorsToDo;
}
}
Dictionary <byte, string> isrcs = new Dictionary <byte, string>();
Dictionary <byte, byte> trackFlags = new Dictionary <byte, byte>();
string mcn = null;
HashSet <int> subchannelExtents = new HashSet <int>();
Dictionary <byte, int> smallestPregapLbaPerTrack = new Dictionary <byte, int>();
Track[] tracks = new Track[inputOptical.Tracks.Count];
for (int i = 0; i < tracks.Length; i++)
{
tracks[i] = new Track
{
Indexes = new Dictionary <ushort, int>(),
TrackDescription = inputOptical.Tracks[i].TrackDescription,
TrackEndSector = inputOptical.Tracks[i].TrackEndSector,
TrackStartSector = inputOptical.Tracks[i].TrackStartSector,
TrackPregap = inputOptical.Tracks[i].TrackPregap,
TrackSequence = inputOptical.Tracks[i].TrackSequence,
TrackSession = inputOptical.Tracks[i].TrackSession,
TrackBytesPerSector = inputOptical.Tracks[i].TrackBytesPerSector,
TrackRawBytesPerSector = inputOptical.Tracks[i].TrackRawBytesPerSector,
TrackType = inputOptical.Tracks[i].TrackType,
TrackSubchannelType = inputOptical.Tracks[i].TrackSubchannelType
};
foreach (KeyValuePair <ushort, int> idx in inputOptical.Tracks[i].Indexes)
{
tracks[i].Indexes[idx.Key] = idx.Value;
}
}
foreach (SectorTagType tag in inputFormat.Info.ReadableSectorTags.Where(t => t == SectorTagType.CdTrackIsrc).
OrderBy(t => t))
{
foreach (Track track in tracks)
{
byte[] isrc = inputFormat.ReadSectorTag(track.TrackSequence, tag);
if (isrc is null)
{
continue;
}
isrcs[(byte)track.TrackSequence] = Encoding.UTF8.GetString(isrc);
}
}
foreach (SectorTagType tag in inputFormat.Info.ReadableSectorTags.
Where(t => t == SectorTagType.CdTrackFlags).OrderBy(t => t))
{
foreach (Track track in tracks)
{
byte[] flags = inputFormat.ReadSectorTag(track.TrackSequence, tag);
if (flags is null)
{
continue;
}
trackFlags[(byte)track.TrackSequence] = flags[0];
}
}
for (ulong s = 0; s < inputFormat.Info.Sectors; s++)
{
if (s > int.MaxValue)
{
break;
}
subchannelExtents.Add((int)s);
}
foreach (SectorTagType tag in inputFormat.Info.ReadableSectorTags.OrderBy(t => t).TakeWhile(tag => UseLong))
{
switch (tag)
{
case SectorTagType.AppleSectorTag:
case SectorTagType.CdSectorSync:
case SectorTagType.CdSectorHeader:
case SectorTagType.CdSectorSubHeader:
case SectorTagType.CdSectorEdc:
case SectorTagType.CdSectorEccP:
case SectorTagType.CdSectorEccQ:
case SectorTagType.CdSectorEcc:
// This tags are inline in long sector
continue;
}
if (!outputOptical.SupportedSectorTags.Contains(tag))
{
continue;
}
foreach (Track track in inputOptical.Tracks)
{
doneSectors = 0;
ulong trackSectors = track.TrackEndSector - track.TrackStartSector + 1;
byte[] sector;
bool result;
switch (tag)
{
case SectorTagType.CdTrackFlags:
case SectorTagType.CdTrackIsrc:
sector = inputFormat.ReadSectorTag(track.TrackSequence, tag);
result = outputOptical.WriteSectorTag(sector, track.TrackSequence, tag);
Assert.IsTrue(result, $"Error {outputOptical.ErrorMessage} writing tag, not continuing...");
continue;
}
while (doneSectors < trackSectors)
{
uint sectorsToDo;
if (trackSectors - doneSectors >= SECTORS_TO_READ)
{
sectorsToDo = SECTORS_TO_READ;
}
else
{
sectorsToDo = (uint)(trackSectors - doneSectors);
}
if (sectorsToDo == 1)
{
sector = inputFormat.ReadSectorTag(doneSectors + track.TrackStartSector, tag);
if (tag == SectorTagType.CdSectorSubchannel)
{
bool indexesChanged = CompactDisc.WriteSubchannelToImage(MmcSubchannel.Raw,
MmcSubchannel.Raw, sector, doneSectors + track.TrackStartSector, 1, null,
isrcs, (byte)track.TrackSequence, ref mcn, tracks, subchannelExtents, true,
outputOptical, true, true, null, null, smallestPregapLbaPerTrack, false);
if (indexesChanged)
{
outputOptical.SetTracks(tracks.ToList());
}
result = true;
}
else
{
result = outputOptical.WriteSectorTag(sector, doneSectors + track.TrackStartSector,
tag);
}
}
else
{
sector = inputFormat.ReadSectorsTag(doneSectors + track.TrackStartSector, sectorsToDo, tag);
if (tag == SectorTagType.CdSectorSubchannel)
{
bool indexesChanged = CompactDisc.WriteSubchannelToImage(MmcSubchannel.Raw,
MmcSubchannel.Raw, sector, doneSectors + track.TrackStartSector, sectorsToDo,
null, isrcs, (byte)track.TrackSequence, ref mcn, tracks, subchannelExtents,
true, outputOptical, true, true, null, null, smallestPregapLbaPerTrack, false);
if (indexesChanged)
{
outputOptical.SetTracks(tracks.ToList());
}
result = true;
}
else
{
result = outputOptical.WriteSectorsTag(sector, doneSectors + track.TrackStartSector,
sectorsToDo, tag);
}
}
Assert.IsTrue(result,
$"Error {outputOptical.ErrorMessage} writing tag for sector {doneSectors + track.TrackStartSector}, not continuing...");
doneSectors += sectorsToDo;
}
}
}
if (isrcs.Count > 0)
{
foreach (KeyValuePair <byte, string> isrc in isrcs)
{
outputOptical.WriteSectorTag(Encoding.UTF8.GetBytes(isrc.Value), isrc.Key,
SectorTagType.CdTrackIsrc);
}
}
if (trackFlags.Count > 0)
{
foreach ((byte track, byte flags) in trackFlags)
{
outputOptical.WriteSectorTag(new[]
{
flags
}, track, SectorTagType.CdTrackFlags);
}
}
if (mcn != null)
{
outputOptical.WriteMediaTag(Encoding.UTF8.GetBytes(mcn), MediaTagType.CD_MCN);
}
if (resume != null ||
dumpHardware != null)
{
if (resume != null)
{
outputOptical.SetDumpHardware(resume.Tries);
}
else if (dumpHardware != null)
{
outputOptical.SetDumpHardware(dumpHardware);
}
}
if (sidecar != null ||
cicmMetadata != null)
{
if (sidecar != null)
{
outputOptical.SetCicmMetadata(sidecar);
}
else if (cicmMetadata != null)
{
outputOptical.SetCicmMetadata(cicmMetadata);
}
}
Assert.True(outputOptical.Close(),
$"Error {outputOptical.ErrorMessage} closing output image... Contents are not correct.");
// Some images will never generate the same
if (Md5 != null)
{
string md5 = Md5Context.File(outputPath, out _);
Assert.AreEqual(Md5, md5, "Hashes are different");
}
File.Delete(outputPath);
}
