public DvdInfoViewModel(MediaType mediaType, [CanBeNull] byte[] pfi, [CanBeNull] byte[] dmi,
[CanBeNull] byte[] cmi, [CanBeNull] byte[] hdCopyrightInformation,
[CanBeNull] byte[] bca, [CanBeNull] byte[] aacs,
PFI.PhysicalFormatInformation?decodedPfi, Window view)
{
_dvdPfi = pfi;
_dvdDmi = dmi;
_dvdCmi = cmi;
_hddvdCopyrightInformation = hdCopyrightInformation;
_dvdBca = bca;
_dvdAacs = aacs;
_view = view;
SaveDvdPfiCommand = ReactiveCommand.Create(ExecuteSaveDvdPfiCommand);
SaveDvdDmiCommand = ReactiveCommand.Create(ExecuteSaveDvdDmiCommand);
SaveDvdCmiCommand = ReactiveCommand.Create(ExecuteSaveDvdCmiCommand);
SaveHdDvdCmiCommand = ReactiveCommand.Create(ExecuteSaveHdDvdCmiCommand);
SaveDvdBcaCommand = ReactiveCommand.Create(ExecuteSaveDvdBcaCommand);
SaveDvdAacsCommand = ReactiveCommand.Create(ExecuteSaveDvdAacsCommand);
/* TODO: Pass back
* switch(mediaType)
* {
* case MediaType.HDDVDROM:
* case MediaType.HDDVDRAM:
* case MediaType.HDDVDR:
* case MediaType.HDDVDRW:
* case MediaType.HDDVDRDL:
* case MediaType.HDDVDRWDL:
* Text = "HD DVD";
*
* break;
* default:
* Text = "DVD";
*
* break;
* }
*/
if (decodedPfi.HasValue)
{
DvdPfiText = PFI.Prettify(decodedPfi);
}
if (cmi != null)
{
DvdCmiText = CSS_CPRM.PrettifyLeadInCopyright(cmi);
}
SaveDvdPfiVisible = pfi != null;
SaveDvdDmiVisible = dmi != null;
SaveDvdCmiVisible = cmi != null;
SaveHdDvdCmiVisible = hdCopyrightInformation != null;
SaveDvdBcaVisible = bca != null;
SaveDvdAacsVisible = aacs != null;
}
internal void LoadData(MediaType mediaType, byte[] pfi, byte[] dmi, byte[] cmi,
byte[] hdCopyrightInformation,
byte[] bca, byte[] aacs, PFI.PhysicalFormatInformation?decodedPfi)
{
DvdPfi = pfi;
DvdDmi = dmi;
DvdCmi = cmi;
HddvdCopyrightInformation = hdCopyrightInformation;
DvdBca = bca;
DvdAacs = aacs;
switch (mediaType)
{
case MediaType.HDDVDROM:
case MediaType.HDDVDRAM:
case MediaType.HDDVDR:
case MediaType.HDDVDRW:
case MediaType.HDDVDRDL:
case MediaType.HDDVDRWDL:
Text = "HD DVD";
break;
default:
Text = "DVD";
break;
}
if (decodedPfi.HasValue)
{
grpDvdPfi.Visible = true;
txtDvdPfi.Text = PFI.Prettify(decodedPfi);
}
if (cmi != null)
{
grpDvdCmi.Visible = true;
txtDvdCmi.Text = CSS_CPRM.PrettifyLeadInCopyright(cmi);
btnSaveDvdCmi.Visible = true;
}
btnSaveDvdPfi.Visible = pfi != null;
btnSaveDvdDmi.Visible = dmi != null;
btnSaveDvdCmi.Visible = cmi != null;
btnSaveHdDvdCmi.Visible = hdCopyrightInformation != null;
btnSaveDvdBca.Visible = bca != null;
btnSaveDvdAacs.Visible = aacs != null;
Visible = grpDvdPfi.Visible || grpDvdCmi.Visible || btnSaveDvdPfi.Visible ||
btnSaveDvdDmi.Visible ||
btnSaveDvdCmi.Visible || btnSaveHdDvdCmi.Visible || btnSaveDvdBca.Visible ||
btnSaveDvdAacs.Visible;
}
/// <summary>Dumps an optical disc</summary>
void Mmc(ref MediaType dskType)
{
bool sense;
byte[] tmpBuf;
bool compactDisc = true;
bool isXbox = false;
_speedMultiplier = 1;
// TODO: Log not only what is it reading, but if it was read correctly or not.
sense = _dev.GetConfiguration(out byte[] cmdBuf, out _, 0, MmcGetConfigurationRt.Current, _dev.Timeout,
out _);
if (!sense)
{
Features.SeparatedFeatures ftr = Features.Separate(cmdBuf);
_dumpLog.WriteLine("Device reports current profile is 0x{0:X4}", ftr.CurrentProfile);
switch (ftr.CurrentProfile)
{
case 0x0001:
dskType = MediaType.GENERIC_HDD;
_speedMultiplier = -1;
goto default;
case 0x0002:
dskType = MediaType.PD650;
_speedMultiplier = -1;
goto default;
case 0x0005:
dskType = MediaType.CDMO;
break;
case 0x0008:
dskType = MediaType.CD;
break;
case 0x0009:
dskType = MediaType.CDR;
break;
case 0x000A:
dskType = MediaType.CDRW;
break;
case 0x0010:
dskType = MediaType.DVDROM;
_speedMultiplier = 9;
goto default;
case 0x0011:
dskType = MediaType.DVDR;
_speedMultiplier = 9;
goto default;
case 0x0012:
dskType = MediaType.DVDRAM;
_speedMultiplier = 9;
goto default;
case 0x0013:
case 0x0014:
dskType = MediaType.DVDRW;
_speedMultiplier = 9;
goto default;
case 0x0015:
case 0x0016:
dskType = MediaType.DVDRDL;
_speedMultiplier = 9;
goto default;
case 0x0017:
dskType = MediaType.DVDRWDL;
_speedMultiplier = 9;
goto default;
case 0x0018:
dskType = MediaType.DVDDownload;
_speedMultiplier = 9;
goto default;
case 0x001A:
dskType = MediaType.DVDPRW;
_speedMultiplier = 9;
goto default;
case 0x001B:
dskType = MediaType.DVDPR;
_speedMultiplier = 9;
goto default;
case 0x0020:
dskType = MediaType.DDCD;
goto default;
case 0x0021:
dskType = MediaType.DDCDR;
goto default;
case 0x0022:
dskType = MediaType.DDCDRW;
goto default;
case 0x002A:
dskType = MediaType.DVDPRWDL;
_speedMultiplier = 9;
goto default;
case 0x002B:
dskType = MediaType.DVDPRDL;
_speedMultiplier = 9;
goto default;
case 0x0040:
dskType = MediaType.BDROM;
_speedMultiplier = 30;
goto default;
case 0x0041:
case 0x0042:
dskType = MediaType.BDR;
_speedMultiplier = 30;
goto default;
case 0x0043:
dskType = MediaType.BDRE;
_speedMultiplier = 30;
goto default;
case 0x0050:
dskType = MediaType.HDDVDROM;
_speedMultiplier = 30;
goto default;
case 0x0051:
dskType = MediaType.HDDVDR;
_speedMultiplier = 30;
goto default;
case 0x0052:
dskType = MediaType.HDDVDRAM;
_speedMultiplier = 30;
goto default;
case 0x0053:
dskType = MediaType.HDDVDRW;
_speedMultiplier = 30;
goto default;
case 0x0058:
dskType = MediaType.HDDVDRDL;
_speedMultiplier = 30;
goto default;
case 0x005A:
dskType = MediaType.HDDVDRWDL;
_speedMultiplier = 30;
goto default;
default:
compactDisc = false;
break;
}
}
if (compactDisc)
{
CompactDisc(out dskType);
return;
}
var scsiReader = new Reader(_dev, _dev.Timeout, null, _dumpRaw);
ulong blocks = scsiReader.GetDeviceBlocks();
_dumpLog.WriteLine("Device reports disc has {0} blocks", blocks);
Dictionary <MediaTagType, byte[]> mediaTags = new Dictionary <MediaTagType, byte[]>();
if (dskType == MediaType.PD650)
{
switch (blocks + 1)
{
case 1281856:
dskType = MediaType.PD650_WORM;
break;
case 58620544:
dskType = MediaType.REV120;
break;
case 17090880:
dskType = MediaType.REV35;
break;
// TODO: Unknown value
default:
dskType = MediaType.REV70;
break;
}
}
#region Nintendo
switch (dskType)
{
case MediaType.Unknown when blocks > 0:
_dumpLog.WriteLine("Reading Physical Format Information");
sense = _dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.PhysicalInformation, 0, _dev.Timeout, out _);
if (!sense)
{
PFI.PhysicalFormatInformation?nintendoPfi = PFI.Decode(cmdBuf);
if (nintendoPfi != null)
{
if (nintendoPfi.Value.DiskCategory == DiskCategory.Nintendo &&
nintendoPfi.Value.PartVersion == 15)
{
_dumpLog.WriteLine("Dumping Nintendo GameCube or Wii discs is not yet implemented.");
StoppingErrorMessage?.
Invoke("Dumping Nintendo GameCube or Wii discs is not yet implemented.");
return;
}
}
}
break;
case MediaType.DVDDownload:
case MediaType.DVDPR:
case MediaType.DVDPRDL:
case MediaType.DVDPRW:
case MediaType.DVDPRWDL:
case MediaType.DVDR:
case MediaType.DVDRAM:
case MediaType.DVDRDL:
case MediaType.DVDROM:
case MediaType.DVDRW:
case MediaType.DVDRWDL:
case MediaType.HDDVDR:
case MediaType.HDDVDRAM:
case MediaType.HDDVDRDL:
case MediaType.HDDVDROM:
case MediaType.HDDVDRW:
case MediaType.HDDVDRWDL:
_dumpLog.WriteLine("Reading Physical Format Information");
sense = _dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.PhysicalInformation, 0, _dev.Timeout, out _);
if (!sense)
{
if (PFI.Decode(cmdBuf).HasValue)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVD_PFI, tmpBuf);
PFI.PhysicalFormatInformation decPfi = PFI.Decode(cmdBuf).Value;
UpdateStatus?.Invoke($"PFI:\n{PFI.Prettify(decPfi)}");
// False book types
if (dskType == MediaType.DVDROM)
{
switch (decPfi.DiskCategory)
{
case DiskCategory.DVDPR:
dskType = MediaType.DVDPR;
break;
case DiskCategory.DVDPRDL:
dskType = MediaType.DVDPRDL;
break;
case DiskCategory.DVDPRW:
dskType = MediaType.DVDPRW;
break;
case DiskCategory.DVDPRWDL:
dskType = MediaType.DVDPRWDL;
break;
case DiskCategory.DVDR:
dskType = decPfi.PartVersion == 6 ? MediaType.DVDRDL : MediaType.DVDR;
break;
case DiskCategory.DVDRAM:
dskType = MediaType.DVDRAM;
break;
default:
dskType = MediaType.DVDROM;
break;
case DiskCategory.DVDRW:
dskType = decPfi.PartVersion == 3 ? MediaType.DVDRWDL : MediaType.DVDRW;
break;
case DiskCategory.HDDVDR:
dskType = MediaType.HDDVDR;
break;
case DiskCategory.HDDVDRAM:
dskType = MediaType.HDDVDRAM;
break;
case DiskCategory.HDDVDROM:
dskType = MediaType.HDDVDROM;
break;
case DiskCategory.HDDVDRW:
dskType = MediaType.HDDVDRW;
break;
case DiskCategory.Nintendo:
dskType = decPfi.DiscSize == DVDSize.Eighty ? MediaType.GOD : MediaType.WOD;
break;
case DiskCategory.UMD:
dskType = MediaType.UMD;
break;
}
}
}
}
_dumpLog.WriteLine("Reading Disc Manufacturing Information");
sense = _dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.DiscManufacturingInformation, 0, _dev.Timeout,
out _);
if (!sense)
{
if (DMI.IsXbox(cmdBuf) ||
DMI.IsXbox360(cmdBuf))
{
if (DMI.IsXbox(cmdBuf))
{
dskType = MediaType.XGD;
}
else if (DMI.IsXbox360(cmdBuf))
{
dskType = MediaType.XGD2;
// All XGD3 all have the same number of blocks
if (blocks == 25063 || // Locked (or non compatible drive)
blocks == 4229664 || // Xtreme unlock
blocks == 4246304) // Wxripper unlock
{
dskType = MediaType.XGD3;
}
}
sense = _dev.ScsiInquiry(out byte[] inqBuf, out _);
if (sense ||
!Inquiry.Decode(inqBuf).HasValue ||
(Inquiry.Decode(inqBuf).HasValue&& !Inquiry.Decode(inqBuf).Value.KreonPresent))
{
_dumpLog.WriteLine("Dumping Xbox Game Discs requires a drive with Kreon firmware.");
StoppingErrorMessage?.
Invoke("Dumping Xbox Game Discs requires a drive with Kreon firmware.");
return;
}
if (_dumpRaw && !_force)
{
StoppingErrorMessage?.
Invoke("Not continuing. If you want to continue reading cooked data when raw is not available use the force option.");
// TODO: Exit more gracefully
return;
}
isXbox = true;
}
if (cmdBuf.Length == 2052)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVD_DMI, tmpBuf);
}
}
break;
}
#endregion Nintendo
#region All DVD and HD DVD types
#endregion All DVD and HD DVD types
#region DVD-ROM
if (dskType == MediaType.DVDDownload ||
dskType == MediaType.DVDROM)
{
_dumpLog.WriteLine("Reading Lead-in Copyright Information.");
sense = _dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.CopyrightInformation, 0, _dev.Timeout, out _);
if (!sense)
{
if (CSS_CPRM.DecodeLeadInCopyright(cmdBuf).HasValue)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVD_CMI, tmpBuf);
}
}
}
#endregion DVD-ROM
switch (dskType)
{
#region DVD-ROM and HD DVD-ROM
case MediaType.DVDDownload:
case MediaType.DVDROM:
case MediaType.HDDVDROM:
_dumpLog.WriteLine("Reading Burst Cutting Area.");
sense = _dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.BurstCuttingArea, 0, _dev.Timeout, out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVD_BCA, tmpBuf);
}
break;
#endregion DVD-ROM and HD DVD-ROM
#region DVD-RAM and HD DVD-RAM
case MediaType.DVDRAM:
case MediaType.HDDVDRAM:
_dumpLog.WriteLine("Reading Disc Description Structure.");
sense = _dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.DvdramDds, 0, _dev.Timeout, out _);
if (!sense)
{
if (DDS.Decode(cmdBuf).HasValue)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVDRAM_DDS, tmpBuf);
}
}
_dumpLog.WriteLine("Reading Spare Area Information.");
sense = _dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.DvdramSpareAreaInformation, 0, _dev.Timeout,
out _);
if (!sense)
{
if (Spare.Decode(cmdBuf).HasValue)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVDRAM_SpareArea, tmpBuf);
}
}
break;
#endregion DVD-RAM and HD DVD-RAM
#region DVD-R and DVD-RW
case MediaType.DVDR:
case MediaType.DVDRW:
_dumpLog.WriteLine("Reading Pre-Recorded Information.");
sense = _dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.PreRecordedInfo, 0, _dev.Timeout, out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVDR_PreRecordedInfo, tmpBuf);
}
break;
#endregion DVD-R and DVD-RW
}
switch (dskType)
{
#region DVD-R, DVD-RW and HD DVD-R
case MediaType.DVDR:
case MediaType.DVDRW:
case MediaType.HDDVDR:
_dumpLog.WriteLine("Reading Media Identifier.");
sense = _dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.DvdrMediaIdentifier, 0, _dev.Timeout, out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVDR_MediaIdentifier, tmpBuf);
}
_dumpLog.WriteLine("Reading Recordable Physical Information.");
sense = _dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.DvdrPhysicalInformation, 0, _dev.Timeout,
out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVDR_PFI, tmpBuf);
}
break;
#endregion DVD-R, DVD-RW and HD DVD-R
#region All DVD+
case MediaType.DVDPR:
case MediaType.DVDPRDL:
case MediaType.DVDPRW:
case MediaType.DVDPRWDL:
_dumpLog.WriteLine("Reading ADdress In Pregroove.");
sense = _dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.Adip, 0, _dev.Timeout, out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVD_ADIP, tmpBuf);
}
_dumpLog.WriteLine("Reading Disc Control Blocks.");
sense = _dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.Dcb, 0, _dev.Timeout, out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DCB, tmpBuf);
}
break;
#endregion All DVD+
#region HD DVD-ROM
case MediaType.HDDVDROM:
_dumpLog.WriteLine("Reading Lead-in Copyright Information.");
sense = _dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.HddvdCopyrightInformation, 0, _dev.Timeout,
out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.HDDVD_CPI, tmpBuf);
}
break;
#endregion HD DVD-ROM
#region All Blu-ray
case MediaType.BDR:
case MediaType.BDRE:
case MediaType.BDROM:
case MediaType.BDRXL:
case MediaType.BDREXL:
_dumpLog.WriteLine("Reading Disc Information.");
sense = _dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Bd, 0, 0,
MmcDiscStructureFormat.DiscInformation, 0, _dev.Timeout, out _);
if (!sense)
{
if (DI.Decode(cmdBuf).HasValue)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.BD_DI, tmpBuf);
}
}
// TODO: PAC
/*
* dumpLog.WriteLine("Reading PAC.");
* sense = dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Bd, 0, 0,
* MmcDiscStructureFormat.Pac, 0, dev.Timeout, out _);
* if(!sense)
* {
* tmpBuf = new byte[cmdBuf.Length - 4];
* Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
* mediaTags.Add(MediaTagType.PAC, tmpBuf);
* }*/
break;
#endregion All Blu-ray
}
switch (dskType)
{
#region BD-ROM only
case MediaType.BDROM:
_dumpLog.WriteLine("Reading Burst Cutting Area.");
sense = _dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Bd, 0, 0,
MmcDiscStructureFormat.BdBurstCuttingArea, 0, _dev.Timeout, out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.BD_BCA, tmpBuf);
}
break;
#endregion BD-ROM only
#region Writable Blu-ray only
case MediaType.BDR:
case MediaType.BDRE:
case MediaType.BDRXL:
case MediaType.BDREXL:
_dumpLog.WriteLine("Reading Disc Definition Structure.");
sense = _dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Bd, 0, 0,
MmcDiscStructureFormat.BdDds, 0, _dev.Timeout, out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.BD_DDS, tmpBuf);
}
_dumpLog.WriteLine("Reading Spare Area Information.");
sense = _dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Bd, 0, 0,
MmcDiscStructureFormat.BdSpareAreaInformation, 0, _dev.Timeout,
out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.BD_SpareArea, tmpBuf);
}
break;
#endregion Writable Blu-ray only
}
if (isXbox)
{
Xgd(mediaTags, ref dskType);
return;
}
Sbc(mediaTags, ref dskType, true);
}
/// <summary>Creates a metadata sidecar for an optical disc (e.g. CD, DVD, GD, BD, XGD, GOD)</summary>
/// <param name="image">Image</param>
/// <param name="filterId">Filter uuid</param>
/// <param name="imagePath">Image path</param>
/// <param name="fi">Image file information</param>
/// <param name="plugins">Image plugins</param>
/// <param name="imgChecksums">List of image checksums</param>
/// <param name="sidecar">Metadata sidecar</param>
void OpticalDisc(IOpticalMediaImage image, Guid filterId, string imagePath, FileInfo fi, PluginBase plugins,
List <ChecksumType> imgChecksums, ref CICMMetadataType sidecar, Encoding encoding)
{
if (aborted)
{
return;
}
sidecar.OpticalDisc = new[]
{
new OpticalDiscType
{
Checksums = imgChecksums.ToArray(), Image = new ImageType
{
format = image.Format, offset = 0, offsetSpecified = true, Value = Path.GetFileName(imagePath)
},
Size = (ulong)fi.Length, Sequence = new SequenceType
{
MediaTitle = image.Info.MediaTitle
}
}
};
if (image.Info.MediaSequence != 0 &&
image.Info.LastMediaSequence != 0)
{
sidecar.OpticalDisc[0].Sequence.MediaSequence = (uint)image.Info.MediaSequence;
sidecar.OpticalDisc[0].Sequence.TotalMedia = (uint)image.Info.LastMediaSequence;
}
else
{
sidecar.OpticalDisc[0].Sequence.MediaSequence = 1;
sidecar.OpticalDisc[0].Sequence.TotalMedia = 1;
}
MediaType dskType = image.Info.MediaType;
UpdateStatus("Hashing media tags...");
foreach (MediaTagType tagType in image.Info.ReadableMediaTags)
{
if (aborted)
{
return;
}
switch (tagType)
{
case MediaTagType.CD_ATIP:
sidecar.OpticalDisc[0].ATIP = new DumpType
{
Image = Path.GetFileName(imagePath),
Checksums = Checksum.GetChecksums(image.ReadDiskTag(MediaTagType.CD_ATIP)).ToArray(),
Size = (ulong)image.ReadDiskTag(MediaTagType.CD_ATIP).Length
};
ATIP.CDATIP?atip = ATIP.Decode(image.ReadDiskTag(MediaTagType.CD_ATIP));
if (atip.HasValue)
{
if (atip.Value.DDCD)
{
dskType = atip.Value.DiscType ? MediaType.DDCDRW : MediaType.DDCDR;
}
else
{
dskType = atip.Value.DiscType ? MediaType.CDRW : MediaType.CDR;
}
}
break;
case MediaTagType.DVD_BCA:
sidecar.OpticalDisc[0].BCA = new DumpType
{
Image = Path.GetFileName(imagePath),
Checksums = Checksum.GetChecksums(image.ReadDiskTag(MediaTagType.DVD_BCA)).ToArray(),
Size = (ulong)image.ReadDiskTag(MediaTagType.DVD_BCA).Length
};
break;
case MediaTagType.BD_BCA:
sidecar.OpticalDisc[0].BCA = new DumpType
{
Image = Path.GetFileName(imagePath),
Checksums = Checksum.GetChecksums(image.ReadDiskTag(MediaTagType.BD_BCA)).ToArray(),
Size = (ulong)image.ReadDiskTag(MediaTagType.BD_BCA).Length
};
break;
case MediaTagType.DVD_CMI:
sidecar.OpticalDisc[0].CMI = new DumpType
{
Image = Path.GetFileName(imagePath),
Checksums = Checksum.GetChecksums(image.ReadDiskTag(MediaTagType.DVD_CMI)).ToArray(),
Size = (ulong)image.ReadDiskTag(MediaTagType.DVD_CMI).Length
};
CSS_CPRM.LeadInCopyright?cmi =
CSS_CPRM.DecodeLeadInCopyright(image.ReadDiskTag(MediaTagType.DVD_CMI));
if (cmi.HasValue)
{
switch (cmi.Value.CopyrightType)
{
case CopyrightType.AACS:
sidecar.OpticalDisc[0].CopyProtection = "AACS";
break;
case CopyrightType.CSS:
sidecar.OpticalDisc[0].CopyProtection = "CSS";
break;
case CopyrightType.CPRM:
sidecar.OpticalDisc[0].CopyProtection = "CPRM";
break;
}
}
break;
case MediaTagType.DVD_DMI:
sidecar.OpticalDisc[0].DMI = new DumpType
{
Image = Path.GetFileName(imagePath),
Checksums = Checksum.GetChecksums(image.ReadDiskTag(MediaTagType.DVD_DMI)).ToArray(),
Size = (ulong)image.ReadDiskTag(MediaTagType.DVD_DMI).Length
};
if (DMI.IsXbox(image.ReadDiskTag(MediaTagType.DVD_DMI)))
{
dskType = MediaType.XGD;
sidecar.OpticalDisc[0].Dimensions = new DimensionsType
{
Diameter = 120, Thickness = 1.2
};
}
else if (DMI.IsXbox360(image.ReadDiskTag(MediaTagType.DVD_DMI)))
{
dskType = MediaType.XGD2;
sidecar.OpticalDisc[0].Dimensions = new DimensionsType
{
Diameter = 120, Thickness = 1.2
};
}
break;
case MediaTagType.DVD_PFI:
sidecar.OpticalDisc[0].PFI = new DumpType
{
Image = Path.GetFileName(imagePath),
Checksums = Checksum.GetChecksums(image.ReadDiskTag(MediaTagType.DVD_PFI)).ToArray(),
Size = (ulong)image.ReadDiskTag(MediaTagType.DVD_PFI).Length
};
PFI.PhysicalFormatInformation?pfi = PFI.Decode(image.ReadDiskTag(MediaTagType.DVD_PFI));
if (pfi.HasValue)
{
if (dskType != MediaType.XGD &&
dskType != MediaType.XGD2 &&
dskType != MediaType.XGD3 &&
dskType != MediaType.PS2DVD &&
dskType != MediaType.PS3DVD &&
dskType != MediaType.Nuon)
{
switch (pfi.Value.DiskCategory)
{
case DiskCategory.DVDPR:
dskType = MediaType.DVDPR;
break;
case DiskCategory.DVDPRDL:
dskType = MediaType.DVDPRDL;
break;
case DiskCategory.DVDPRW:
dskType = MediaType.DVDPRW;
break;
case DiskCategory.DVDPRWDL:
dskType = MediaType.DVDPRWDL;
break;
case DiskCategory.DVDR:
dskType = MediaType.DVDR;
break;
case DiskCategory.DVDRAM:
dskType = MediaType.DVDRAM;
break;
case DiskCategory.DVDROM:
dskType = MediaType.DVDROM;
break;
case DiskCategory.DVDRW:
dskType = MediaType.DVDRW;
break;
case DiskCategory.HDDVDR:
dskType = MediaType.HDDVDR;
break;
case DiskCategory.HDDVDRAM:
dskType = MediaType.HDDVDRAM;
break;
case DiskCategory.HDDVDROM:
dskType = MediaType.HDDVDROM;
break;
case DiskCategory.HDDVDRW:
dskType = MediaType.HDDVDRW;
break;
case DiskCategory.Nintendo:
dskType = MediaType.GOD;
break;
case DiskCategory.UMD:
dskType = MediaType.UMD;
break;
}
if (dskType == MediaType.DVDR &&
pfi.Value.PartVersion == 6)
{
dskType = MediaType.DVDRDL;
}
if (dskType == MediaType.DVDRW &&
pfi.Value.PartVersion == 3)
{
dskType = MediaType.DVDRWDL;
}
if (dskType == MediaType.GOD &&
pfi.Value.DiscSize == DVDSize.OneTwenty)
{
dskType = MediaType.WOD;
}
sidecar.OpticalDisc[0].Dimensions = new DimensionsType();
if (dskType == MediaType.UMD)
{
sidecar.OpticalDisc[0].Dimensions.Height = 64;
sidecar.OpticalDisc[0].Dimensions.HeightSpecified = true;
sidecar.OpticalDisc[0].Dimensions.Width = 63;
sidecar.OpticalDisc[0].Dimensions.WidthSpecified = true;
sidecar.OpticalDisc[0].Dimensions.Thickness = 4;
}
else
{
switch (pfi.Value.DiscSize)
{
case DVDSize.Eighty:
sidecar.OpticalDisc[0].Dimensions.Diameter = 80;
sidecar.OpticalDisc[0].Dimensions.DiameterSpecified = true;
sidecar.OpticalDisc[0].Dimensions.Thickness = 1.2;
break;
case DVDSize.OneTwenty:
sidecar.OpticalDisc[0].Dimensions.Diameter = 120;
sidecar.OpticalDisc[0].Dimensions.DiameterSpecified = true;
sidecar.OpticalDisc[0].Dimensions.Thickness = 1.2;
break;
}
}
}
}
break;
case MediaTagType.CD_PMA:
sidecar.OpticalDisc[0].PMA = new DumpType
{
Image = Path.GetFileName(imagePath),
Checksums = Checksum.GetChecksums(image.ReadDiskTag(MediaTagType.CD_PMA)).ToArray(),
Size = (ulong)image.ReadDiskTag(MediaTagType.CD_PMA).Length
};
break;
case MediaTagType.CD_FullTOC:
sidecar.OpticalDisc[0].TOC = new DumpType
{
Image = Path.GetFileName(imagePath),
Checksums = Checksum.GetChecksums(image.ReadDiskTag(MediaTagType.CD_FullTOC)).ToArray(),
Size = (ulong)image.ReadDiskTag(MediaTagType.CD_FullTOC).Length
};
break;
case MediaTagType.CD_FirstTrackPregap:
sidecar.OpticalDisc[0].FirstTrackPregrap = new[]
{
new BorderType
{
Image = Path.GetFileName(imagePath),
Checksums = Checksum.GetChecksums(image.ReadDiskTag(MediaTagType.CD_FirstTrackPregap)).
ToArray(),
Size = (ulong)image.ReadDiskTag(MediaTagType.CD_FirstTrackPregap).Length
}
};
break;
case MediaTagType.CD_LeadIn:
sidecar.OpticalDisc[0].LeadIn = new[]
{
new BorderType
{
Image = Path.GetFileName(imagePath),
Checksums = Checksum.GetChecksums(image.ReadDiskTag(MediaTagType.CD_LeadIn)).ToArray(),
Size = (ulong)image.ReadDiskTag(MediaTagType.CD_LeadIn).Length
}
};
break;
case MediaTagType.Xbox_SecuritySector:
if (sidecar.OpticalDisc[0].Xbox == null)
{
sidecar.OpticalDisc[0].Xbox = new XboxType();
}
sidecar.OpticalDisc[0].Xbox.SecuritySectors = new[]
{
new XboxSecuritySectorsType
{
RequestNumber = 0, RequestVersion = 1, SecuritySectors = new DumpType
{
Image = Path.GetFileName(imagePath),
Checksums = Checksum.
GetChecksums(image.ReadDiskTag(MediaTagType.Xbox_SecuritySector)).
ToArray(),
Size = (ulong)image.ReadDiskTag(MediaTagType.Xbox_SecuritySector).Length
}
}
};
break;
case MediaTagType.Xbox_PFI:
if (sidecar.OpticalDisc[0].Xbox == null)
{
sidecar.OpticalDisc[0].Xbox = new XboxType();
}
sidecar.OpticalDisc[0].Xbox.PFI = new DumpType
{
Image = Path.GetFileName(imagePath),
Checksums = Checksum.GetChecksums(image.ReadDiskTag(MediaTagType.Xbox_PFI)).ToArray(),
Size = (ulong)image.ReadDiskTag(MediaTagType.Xbox_PFI).Length
};
break;
case MediaTagType.Xbox_DMI:
if (sidecar.OpticalDisc[0].Xbox == null)
{
sidecar.OpticalDisc[0].Xbox = new XboxType();
}
sidecar.OpticalDisc[0].Xbox.DMI = new DumpType
{
Image = Path.GetFileName(imagePath),
Checksums = Checksum.GetChecksums(image.ReadDiskTag(MediaTagType.Xbox_DMI)).ToArray(),
Size = (ulong)image.ReadDiskTag(MediaTagType.Xbox_DMI).Length
};
break;
}
}
try
{
List <Session> sessions = image.Sessions;
sidecar.OpticalDisc[0].Sessions = (uint)(sessions?.Count ?? 1);
}
catch
{
sidecar.OpticalDisc[0].Sessions = 1;
}
List <Track> tracks = image.Tracks;
List <TrackType> trksLst = null;
if (tracks != null)
{
sidecar.OpticalDisc[0].Tracks = new uint[1];
sidecar.OpticalDisc[0].Tracks[0] = (uint)tracks.Count;
trksLst = new List <TrackType>();
}
if (sidecar.OpticalDisc[0].Dimensions == null &&
image.Info.MediaType != MediaType.Unknown)
{
sidecar.OpticalDisc[0].Dimensions = Dimensions.DimensionsFromMediaType(image.Info.MediaType);
}
if (aborted)
{
return;
}
InitProgress();
UpdateStatus("Checking filesystems");
List <Partition> partitions = Partitions.GetAll(image);
Partitions.AddSchemesToStats(partitions);
UpdateStatus("Hashing tracks...");
foreach (Track trk in tracks)
{
if (aborted)
{
EndProgress();
return;
}
var xmlTrk = new TrackType();
switch (trk.TrackType)
{
case CommonTypes.Enums.TrackType.Audio:
xmlTrk.TrackType1 = TrackTypeTrackType.audio;
break;
case CommonTypes.Enums.TrackType.CdMode2Form2:
xmlTrk.TrackType1 = TrackTypeTrackType.m2f2;
break;
case CommonTypes.Enums.TrackType.CdMode2Formless:
xmlTrk.TrackType1 = TrackTypeTrackType.mode2;
break;
case CommonTypes.Enums.TrackType.CdMode2Form1:
xmlTrk.TrackType1 = TrackTypeTrackType.m2f1;
break;
case CommonTypes.Enums.TrackType.CdMode1:
xmlTrk.TrackType1 = TrackTypeTrackType.mode1;
break;
case CommonTypes.Enums.TrackType.Data:
switch (sidecar.OpticalDisc[0].DiscType)
{
case "BD":
xmlTrk.TrackType1 = TrackTypeTrackType.bluray;
break;
case "DDCD":
xmlTrk.TrackType1 = TrackTypeTrackType.ddcd;
break;
case "DVD":
xmlTrk.TrackType1 = TrackTypeTrackType.dvd;
break;
case "HD DVD":
xmlTrk.TrackType1 = TrackTypeTrackType.hddvd;
break;
default:
xmlTrk.TrackType1 = TrackTypeTrackType.mode1;
break;
}
break;
}
xmlTrk.Sequence = new TrackSequenceType
{
Session = trk.TrackSession, TrackNumber = trk.TrackSequence
};
xmlTrk.StartSector = trk.TrackStartSector;
xmlTrk.EndSector = trk.TrackEndSector;
if (trk.Indexes != null &&
trk.Indexes.ContainsKey(0))
{
if (trk.Indexes.TryGetValue(0, out ulong idx0))
{
xmlTrk.StartSector = idx0;
}
}
switch (sidecar.OpticalDisc[0].DiscType)
{
case "CD":
case "GD":
xmlTrk.StartMSF = LbaToMsf((long)xmlTrk.StartSector);
xmlTrk.EndMSF = LbaToMsf((long)xmlTrk.EndSector);
break;
case "DDCD":
xmlTrk.StartMSF = DdcdLbaToMsf((long)xmlTrk.StartSector);
xmlTrk.EndMSF = DdcdLbaToMsf((long)xmlTrk.EndSector);
break;
}
xmlTrk.Image = new ImageType
{
Value = Path.GetFileName(trk.TrackFile), format = trk.TrackFileType
};
if (trk.TrackFileOffset > 0)
{
xmlTrk.Image.offset = trk.TrackFileOffset;
xmlTrk.Image.offsetSpecified = true;
}
xmlTrk.Size = ((xmlTrk.EndSector - xmlTrk.StartSector) + 1) * (ulong)trk.TrackRawBytesPerSector;
xmlTrk.BytesPerSector = (uint)trk.TrackBytesPerSector;
uint sectorsToRead = 512;
ulong sectors = (xmlTrk.EndSector - xmlTrk.StartSector) + 1;
ulong doneSectors = 0;
// If there is only one track, and it's the same as the image file (e.g. ".iso" files), don't re-checksum.
if (image.Id == new Guid("12345678-AAAA-BBBB-CCCC-123456789000") &&
// Only if filter is none...
(filterId == new Guid("12345678-AAAA-BBBB-CCCC-123456789000") ||
// ...or AppleDouble
filterId == new Guid("1b2165ee-c9df-4b21-bbbb-9e5892b2df4d")))
{
xmlTrk.Checksums = sidecar.OpticalDisc[0].Checksums;
}
else
{
UpdateProgress("Track {0} of {1}", trk.TrackSequence, tracks.Count);
// For fast debugging, skip checksum
//goto skipChecksum;
var trkChkWorker = new Checksum();
InitProgress2();
while (doneSectors < sectors)
{
if (aborted)
{
EndProgress();
EndProgress2();
return;
}
byte[] sector;
if (sectors - doneSectors >= sectorsToRead)
{
sector = image.ReadSectorsLong(doneSectors, sectorsToRead, xmlTrk.Sequence.TrackNumber);
UpdateProgress2("Hashings sector {0} of {1}", (long)doneSectors,
(long)((trk.TrackEndSector - trk.TrackStartSector) + 1));
doneSectors += sectorsToRead;
}
else
{
sector = image.ReadSectorsLong(doneSectors, (uint)(sectors - doneSectors),
xmlTrk.Sequence.TrackNumber);
UpdateProgress2("Hashings sector {0} of {1}", (long)doneSectors,
(long)((trk.TrackEndSector - trk.TrackStartSector) + 1));
doneSectors += sectors - doneSectors;
}
trkChkWorker.Update(sector);
}
List <ChecksumType> trkChecksums = trkChkWorker.End();
xmlTrk.Checksums = trkChecksums.ToArray();
EndProgress2();
}
if (trk.TrackSubchannelType != TrackSubchannelType.None)
{
xmlTrk.SubChannel = new SubChannelType
{
Image = new ImageType
{
Value = trk.TrackSubchannelFile
},
// TODO: Packed subchannel has different size?
Size = ((xmlTrk.EndSector - xmlTrk.StartSector) + 1) * 96
};
switch (trk.TrackSubchannelType)
{
case TrackSubchannelType.Packed:
case TrackSubchannelType.PackedInterleaved:
xmlTrk.SubChannel.Image.format = "rw";
break;
case TrackSubchannelType.Raw:
case TrackSubchannelType.RawInterleaved:
xmlTrk.SubChannel.Image.format = "rw_raw";
break;
case TrackSubchannelType.Q16:
case TrackSubchannelType.Q16Interleaved:
xmlTrk.SubChannel.Image.format = "q16";
break;
}
if (trk.TrackFileOffset > 0)
{
xmlTrk.SubChannel.Image.offset = trk.TrackSubchannelOffset;
xmlTrk.SubChannel.Image.offsetSpecified = true;
}
var subChkWorker = new Checksum();
sectors = (xmlTrk.EndSector - xmlTrk.StartSector) + 1;
doneSectors = 0;
InitProgress2();
while (doneSectors < sectors)
{
if (aborted)
{
EndProgress();
EndProgress2();
return;
}
byte[] sector;
if (sectors - doneSectors >= sectorsToRead)
{
sector = image.ReadSectorsTag(doneSectors, sectorsToRead, xmlTrk.Sequence.TrackNumber,
SectorTagType.CdSectorSubchannel);
UpdateProgress2("Hashings subchannel sector {0} of {1}", (long)doneSectors,
(long)((trk.TrackEndSector - trk.TrackStartSector) + 1));
doneSectors += sectorsToRead;
}
else
{
sector = image.ReadSectorsTag(doneSectors, (uint)(sectors - doneSectors),
xmlTrk.Sequence.TrackNumber,
SectorTagType.CdSectorSubchannel);
UpdateProgress2("Hashings subchannel sector {0} of {1}", (long)doneSectors,
(long)((trk.TrackEndSector - trk.TrackStartSector) + 1));
doneSectors += sectors - doneSectors;
}
subChkWorker.Update(sector);
}
List <ChecksumType> subChecksums = subChkWorker.End();
xmlTrk.SubChannel.Checksums = subChecksums.ToArray();
EndProgress2();
}
// For fast debugging, skip checksum
//skipChecksum:
List <Partition> trkPartitions = partitions.
Where(p => p.Start >= trk.TrackStartSector &&
p.End <= trk.TrackEndSector).ToList();
xmlTrk.FileSystemInformation = new PartitionType[1];
if (trkPartitions.Count > 0)
{
xmlTrk.FileSystemInformation = new PartitionType[trkPartitions.Count];
for (int i = 0; i < trkPartitions.Count; i++)
{
xmlTrk.FileSystemInformation[i] = new PartitionType
{
Description = trkPartitions[i].Description, EndSector = trkPartitions[i].End,
Name = trkPartitions[i].Name, Sequence = (uint)trkPartitions[i].Sequence,
StartSector = trkPartitions[i].Start, Type = trkPartitions[i].Type
};
List <FileSystemType> lstFs = new List <FileSystemType>();
foreach (IFilesystem plugin in plugins.PluginsList.Values)
{
try
{
if (aborted)
{
EndProgress();
return;
}
if (!plugin.Identify(image, trkPartitions[i]))
{
continue;
}
plugin.GetInformation(image, trkPartitions[i], out _, encoding);
lstFs.Add(plugin.XmlFsType);
Statistics.AddFilesystem(plugin.XmlFsType.Type);
switch (plugin.XmlFsType.Type)
{
case "Opera":
dskType = MediaType.ThreeDO;
break;
case "PC Engine filesystem":
dskType = MediaType.SuperCDROM2;
break;
case "Nintendo Wii filesystem":
dskType = MediaType.WOD;
break;
case "Nintendo Gamecube filesystem":
dskType = MediaType.GOD;
break;
}
}
}
static void DoScsiMediaInfo(bool debug, bool verbose, string outputPrefix, Devices.Device dev)
{
var scsiInfo = new ScsiInfo(dev);
if (!scsiInfo.MediaInserted)
{
return;
}
if (scsiInfo.DeviceInfo.ScsiModeSense6 != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_scsi_modesense6.bin", "SCSI MODE SENSE (6)",
scsiInfo.DeviceInfo.ScsiModeSense6);
}
if (scsiInfo.DeviceInfo.ScsiModeSense10 != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_scsi_modesense10.bin", "SCSI MODE SENSE (10)",
scsiInfo.DeviceInfo.ScsiModeSense10);
}
switch (dev.ScsiType)
{
case PeripheralDeviceTypes.DirectAccess:
case PeripheralDeviceTypes.MultiMediaDevice:
case PeripheralDeviceTypes.OCRWDevice:
case PeripheralDeviceTypes.OpticalDevice:
case PeripheralDeviceTypes.SimplifiedDevice:
case PeripheralDeviceTypes.WriteOnceDevice:
if (scsiInfo.ReadCapacity != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readcapacity.bin", "SCSI READ CAPACITY",
scsiInfo.ReadCapacity);
}
if (scsiInfo.ReadCapacity16 != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readcapacity16.bin",
"SCSI READ CAPACITY(16)", scsiInfo.ReadCapacity16);
}
if (scsiInfo.Blocks != 0 &&
scsiInfo.BlockSize != 0)
{
AaruConsole.WriteLine("Media has {0} blocks of {1} bytes/each. (for a total of {2} bytes)",
scsiInfo.Blocks, scsiInfo.BlockSize,
scsiInfo.Blocks * scsiInfo.BlockSize);
}
break;
case PeripheralDeviceTypes.SequentialAccess:
if (scsiInfo.DensitySupport != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_ssc_reportdensitysupport_media.bin",
"SSC REPORT DENSITY SUPPORT (MEDIA)", scsiInfo.DensitySupport);
if (scsiInfo.DensitySupportHeader.HasValue)
{
AaruConsole.WriteLine("Densities supported by currently inserted media:");
AaruConsole.WriteLine(DensitySupport.PrettifyDensity(scsiInfo.DensitySupportHeader));
}
}
if (scsiInfo.MediaTypeSupport != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix,
"_ssc_reportdensitysupport_medium_media.bin",
"SSC REPORT DENSITY SUPPORT (MEDIUM & MEDIA)", scsiInfo.MediaTypeSupport);
if (scsiInfo.MediaTypeSupportHeader.HasValue)
{
AaruConsole.WriteLine("Medium types currently inserted in device:");
AaruConsole.WriteLine(DensitySupport.PrettifyMediumType(scsiInfo.MediaTypeSupportHeader));
}
AaruConsole.WriteLine(DensitySupport.PrettifyMediumType(scsiInfo.MediaTypeSupport));
}
break;
}
if (dev.ScsiType == PeripheralDeviceTypes.MultiMediaDevice)
{
if (scsiInfo.MmcConfiguration != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_getconfiguration_current.bin",
"SCSI GET CONFIGURATION", scsiInfo.MmcConfiguration);
}
if (scsiInfo.RecognizedFormatLayers != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_formatlayers.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.RecognizedFormatLayers);
}
if (scsiInfo.WriteProtectionStatus != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_writeprotection.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.WriteProtectionStatus);
}
if (scsiInfo.DvdPfi != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_pfi.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdPfi);
if (scsiInfo.DecodedPfi.HasValue)
{
AaruConsole.WriteLine("PFI:\n{0}", PFI.Prettify(scsiInfo.DecodedPfi));
}
}
if (scsiInfo.DvdDmi != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_dmi.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdDmi);
if (DMI.IsXbox(scsiInfo.DvdDmi))
{
AaruConsole.WriteLine("Xbox DMI:\n{0}", DMI.PrettifyXbox(scsiInfo.DvdDmi));
}
else if (DMI.IsXbox360(scsiInfo.DvdDmi))
{
AaruConsole.WriteLine("Xbox 360 DMI:\n{0}", DMI.PrettifyXbox360(scsiInfo.DvdDmi));
}
}
if (scsiInfo.DvdCmi != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_cmi.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdCmi);
AaruConsole.WriteLine("Lead-In CMI:\n{0}", CSS_CPRM.PrettifyLeadInCopyright(scsiInfo.DvdCmi));
}
if (scsiInfo.DvdBca != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_bca.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdBca);
}
if (scsiInfo.DvdAacs != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_aacs.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdAacs);
}
if (scsiInfo.DvdRamDds != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvdram_dds.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdRamDds);
AaruConsole.WriteLine("Disc Definition Structure:\n{0}", DDS.Prettify(scsiInfo.DvdRamDds));
}
if (scsiInfo.DvdRamCartridgeStatus != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvdram_status.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdRamCartridgeStatus);
AaruConsole.WriteLine("Medium Status:\n{0}", Cartridge.Prettify(scsiInfo.DvdRamCartridgeStatus));
}
if (scsiInfo.DvdRamSpareArea != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvdram_spare.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdRamSpareArea);
AaruConsole.WriteLine("Spare Area Information:\n{0}", Spare.Prettify(scsiInfo.DvdRamSpareArea));
}
if (scsiInfo.LastBorderOutRmd != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_lastrmd.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.LastBorderOutRmd);
}
if (scsiInfo.DvdPreRecordedInfo != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_pri.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdPreRecordedInfo);
}
if (scsiInfo.DvdrMediaIdentifier != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvdr_mediaid.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdrMediaIdentifier);
}
if (scsiInfo.DvdrPhysicalInformation != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvdr_pfi.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdrPhysicalInformation);
}
if (scsiInfo.DvdPlusAdip != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd+_adip.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdPlusAdip);
}
if (scsiInfo.DvdPlusDcb != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd+_dcb.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdPlusDcb);
}
if (scsiInfo.HddvdCopyrightInformation != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_hddvd_cmi.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.HddvdCopyrightInformation);
}
if (scsiInfo.HddvdrMediumStatus != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_hddvdr_status.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.HddvdrMediumStatus);
}
if (scsiInfo.HddvdrLastRmd != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_hddvdr_lastrmd.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.HddvdrLastRmd);
}
if (scsiInfo.DvdrLayerCapacity != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvdr_layercap.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdrLayerCapacity);
}
if (scsiInfo.DvdrDlMiddleZoneStart != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_mzs.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdrDlMiddleZoneStart);
}
if (scsiInfo.DvdrDlJumpIntervalSize != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_jis.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdrDlJumpIntervalSize);
}
if (scsiInfo.DvdrDlManualLayerJumpStartLba != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_manuallj.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdrDlManualLayerJumpStartLba);
}
if (scsiInfo.DvdrDlRemapAnchorPoint != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_remapanchor.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdrDlRemapAnchorPoint);
}
if (scsiInfo.BlurayDiscInformation != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_bd_di.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.BlurayDiscInformation);
AaruConsole.WriteLine("Blu-ray Disc Information:\n{0}",
DI.Prettify(scsiInfo.BlurayDiscInformation));
}
if (scsiInfo.BlurayPac != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_bd_pac.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.BlurayPac);
}
if (scsiInfo.BlurayBurstCuttingArea != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_bd_bca.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.BlurayBurstCuttingArea);
AaruConsole.WriteLine("Blu-ray Burst Cutting Area:\n{0}",
BCA.Prettify(scsiInfo.BlurayBurstCuttingArea));
}
if (scsiInfo.BlurayDds != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_bd_dds.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.BlurayDds);
AaruConsole.WriteLine("Blu-ray Disc Definition Structure:\n{0}",
Decoders.Bluray.DDS.Prettify(scsiInfo.BlurayDds));
}
if (scsiInfo.BlurayCartridgeStatus != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_bd_cartstatus.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.BlurayCartridgeStatus);
AaruConsole.WriteLine("Blu-ray Cartridge Status:\n{0}",
Decoders.Bluray.Cartridge.Prettify(scsiInfo.BlurayCartridgeStatus));
}
if (scsiInfo.BluraySpareAreaInformation != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_bd_spare.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.BluraySpareAreaInformation);
AaruConsole.WriteLine("Blu-ray Spare Area Information:\n{0}",
Decoders.Bluray.Spare.Prettify(scsiInfo.BluraySpareAreaInformation));
}
if (scsiInfo.BlurayRawDfl != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_bd_dfl.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.BlurayRawDfl);
}
if (scsiInfo.BlurayTrackResources != null)
{
AaruConsole.WriteLine("Track Resources Information:\n{0}",
DiscInformation.Prettify(scsiInfo.BlurayTrackResources));
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscinformation_001b.bin",
"SCSI READ DISC INFORMATION", scsiInfo.BlurayTrackResources);
}
if (scsiInfo.BlurayPowResources != null)
{
AaruConsole.WriteLine("POW Resources Information:\n{0}",
DiscInformation.Prettify(scsiInfo.BlurayPowResources));
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscinformation_010b.bin",
"SCSI READ DISC INFORMATION", scsiInfo.BlurayPowResources);
}
if (scsiInfo.Toc != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_toc.bin", "SCSI READ TOC/PMA/ATIP",
scsiInfo.Toc);
if (scsiInfo.DecodedToc.HasValue)
{
AaruConsole.WriteLine("TOC:\n{0}", TOC.Prettify(scsiInfo.DecodedToc));
}
}
if (scsiInfo.Atip != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_atip.bin", "SCSI READ TOC/PMA/ATIP",
scsiInfo.Atip);
if (scsiInfo.DecodedAtip.HasValue)
{
AaruConsole.WriteLine("ATIP:\n{0}", ATIP.Prettify(scsiInfo.DecodedAtip));
}
}
if (scsiInfo.CompactDiscInformation != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscinformation_000b.bin",
"SCSI READ DISC INFORMATION", scsiInfo.CompactDiscInformation);
if (scsiInfo.DecodedCompactDiscInformation.HasValue)
{
AaruConsole.WriteLine("Standard Disc Information:\n{0}",
DiscInformation.Prettify000b(scsiInfo.DecodedCompactDiscInformation));
}
}
if (scsiInfo.Session != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_session.bin", "SCSI READ TOC/PMA/ATIP",
scsiInfo.Session);
if (scsiInfo.DecodedSession.HasValue)
{
AaruConsole.WriteLine("Session information:\n{0}", Session.Prettify(scsiInfo.DecodedSession));
}
}
if (scsiInfo.RawToc != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_rawtoc.bin", "SCSI READ TOC/PMA/ATIP",
scsiInfo.RawToc);
if (scsiInfo.FullToc.HasValue)
{
AaruConsole.WriteLine("Raw TOC:\n{0}", FullTOC.Prettify(scsiInfo.RawToc));
}
}
if (scsiInfo.Pma != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_pma.bin", "SCSI READ TOC/PMA/ATIP",
scsiInfo.Pma);
AaruConsole.WriteLine("PMA:\n{0}", PMA.Prettify(scsiInfo.Pma));
}
if (scsiInfo.CdTextLeadIn != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_cdtext.bin", "SCSI READ TOC/PMA/ATIP",
scsiInfo.CdTextLeadIn);
if (scsiInfo.DecodedCdTextLeadIn.HasValue)
{
AaruConsole.WriteLine("CD-TEXT on Lead-In:\n{0}",
CDTextOnLeadIn.Prettify(scsiInfo.DecodedCdTextLeadIn));
}
}
if (!string.IsNullOrEmpty(scsiInfo.Mcn))
{
AaruConsole.WriteLine("MCN: {0}", scsiInfo.Mcn);
}
if (scsiInfo.Isrcs != null)
{
foreach (KeyValuePair <byte, string> isrc in scsiInfo.Isrcs)
{
AaruConsole.WriteLine("Track's {0} ISRC: {1}", isrc.Key, isrc.Value);
}
}
if (scsiInfo.XboxSecuritySector != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_xbox_ss.bin", "KREON EXTRACT SS",
scsiInfo.XboxSecuritySector);
}
if (scsiInfo.DecodedXboxSecuritySector.HasValue)
{
AaruConsole.WriteLine("Xbox Security Sector:\n{0}",
SS.Prettify(scsiInfo.DecodedXboxSecuritySector));
}
if (scsiInfo.XgdInfo != null)
{
AaruConsole.WriteLine("Video layer 0 size: {0} sectors", scsiInfo.XgdInfo.L0Video);
AaruConsole.WriteLine("Video layer 1 size: {0} sectors", scsiInfo.XgdInfo.L1Video);
AaruConsole.WriteLine("Middle zone size: {0} sectors", scsiInfo.XgdInfo.MiddleZone);
AaruConsole.WriteLine("Game data size: {0} sectors", scsiInfo.XgdInfo.GameSize);
AaruConsole.WriteLine("Total size: {0} sectors", scsiInfo.XgdInfo.TotalSize);
AaruConsole.WriteLine("Real layer break: {0}", scsiInfo.XgdInfo.LayerBreak);
AaruConsole.WriteLine();
}
}
if (scsiInfo.MediaSerialNumber != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_mediaserialnumber.bin",
"SCSI READ MEDIA SERIAL NUMBER", scsiInfo.MediaSerialNumber);
AaruConsole.Write("Media Serial Number: ");
for (int i = 4; i < scsiInfo.MediaSerialNumber.Length; i++)
{
AaruConsole.Write("{0:X2}", scsiInfo.MediaSerialNumber[i]);
}
AaruConsole.WriteLine();
}
AaruConsole.WriteLine("Media identified as {0}", scsiInfo.MediaType);
Statistics.AddMedia(scsiInfo.MediaType, true);
if (scsiInfo.Toc != null ||
scsiInfo.RawToc != null)
{
uint blockSize = 2352;
Track[] tracks = Dump.GetCdTracks(ref blockSize, dev, scsiInfo.MediaType, null, false,
out long lastSector, null, null, null, TrackSubchannelType.None,
out _, null, null);
if (tracks != null)
{
bool supportsPqSubchannel = Dump.SupportsPqSubchannel(dev, null, null);
bool supportsRwSubchannel = Dump.SupportsRwSubchannel(dev, null, null);
// Open master database
var ctx = AaruContext.Create(Settings.Settings.MasterDbPath);
// Search for device in master database
Database.Models.Device dbDev =
ctx.Devices.FirstOrDefault(d => d.Manufacturer == dev.Manufacturer && d.Model == dev.Model &&
d.Revision == dev.FirmwareRevision);
Dump.SolveTrackPregaps(dev, null, null, tracks, supportsPqSubchannel, supportsRwSubchannel, dbDev,
out bool inexactPositioning);
for (int t = 1; t < tracks.Length; t++)
{
tracks[t - 1].TrackEndSector = tracks[t].TrackStartSector - 1;
}
tracks[tracks.Length - 1].TrackEndSector = (ulong)lastSector;
AaruConsole.WriteLine();
AaruConsole.WriteLine("Track calculations:");
if (inexactPositioning)
{
AaruConsole.
WriteLine("WARNING: The drive has returned incorrect Q positioning when calculating pregaps. A best effort has been tried but they may be incorrect.");
}
foreach (Track track in tracks)
{
AaruConsole.
WriteLine("Track {0} starts at LBA {1}, ends at LBA {2}, has a pregap of {3} sectors and is of type {4}",
track.TrackSequence, track.TrackStartSector, track.TrackEndSector,
track.TrackPregap, track.TrackType);
}
AaruConsole.WriteLine();
AaruConsole.WriteLine("Offsets:");
CdOffset cdOffset = null;
// Search for read offset in master database
cdOffset = ctx.CdOffsets.FirstOrDefault(d => d.Manufacturer == dev.Manufacturer &&
d.Model == dev.Model);
CompactDisc.GetOffset(cdOffset, dbDev, debug, dev, scsiInfo.MediaType, null, tracks, null,
out int?driveOffset, out int?combinedOffset, out _);
if (combinedOffset is null)
{
if (driveOffset is null)
{
AaruConsole.WriteLine("Drive reading offset not found in database.");
AaruConsole.WriteLine("Disc offset cannot be calculated.");
}
else
{
AaruConsole.
WriteLine($"Drive reading offset is {driveOffset} bytes ({driveOffset / 4} samples).");
AaruConsole.WriteLine("Disc write offset is unknown.");
}
}
else
{
int offsetBytes = combinedOffset.Value;
if (driveOffset is null)
{
AaruConsole.WriteLine("Drive reading offset not found in database.");
AaruConsole.
WriteLine($"Combined disc and drive offset are {offsetBytes} bytes ({offsetBytes / 4} samples).");
}
else
{
AaruConsole.
WriteLine($"Drive reading offset is {driveOffset} bytes ({driveOffset / 4} samples).");
AaruConsole.
WriteLine($"Combined offset is {offsetBytes} bytes ({offsetBytes / 4} samples)");
int?discOffset = offsetBytes - driveOffset;
AaruConsole.WriteLine($"Disc offset is {discOffset} bytes ({discOffset / 4} samples)");
}
}
}
}
dev.Close();
}
public pnlScsiInfo(ScsiInfo scsiInfo)
{
XamlReader.Load(this);
this.scsiInfo = scsiInfo;
Stream logo = ResourceHandler.GetResourceStream($"DiscImageChef.Gui.Assets.Logos.Media.{scsiInfo.MediaType}.svg");
/* if(logo != null)
* {
* svgMediaLogo.SvgStream = logo;
* svgMediaLogo.Visible = true;
* }
* else
* {*/
logo =
ResourceHandler.GetResourceStream($"DiscImageChef.Gui.Assets.Logos.Media.{scsiInfo.MediaType}.png");
if (logo != null)
{
imgMediaLogo.Image = new Bitmap(logo);
imgMediaLogo.Visible = true;
}
//}
switch (this.scsiInfo.MediaType)
{
case MediaType.HDDVDROM:
case MediaType.HDDVDRAM:
case MediaType.HDDVDR:
case MediaType.HDDVDRW:
case MediaType.HDDVDRDL:
case MediaType.HDDVDRWDL:
tabDvd.Text = "HD DVD";
break;
default:
tabDvd.Text = "DVD";
break;
}
switch (this.scsiInfo.MediaType)
{
case MediaType.DVDR:
tabDvdr.Text = "DVD-R";
break;
case MediaType.DVDRW:
tabDvdr.Text = "DVD-RW";
break;
case MediaType.DVDPR:
tabDvdr.Text = "DVD+R";
break;
case MediaType.DVDPRW:
tabDvdr.Text = "DVD+RW";
break;
case MediaType.DVDPRWDL:
tabDvdr.Text = "DVD+RW DL";
break;
case MediaType.DVDRDL:
tabDvdr.Text = "DVD-R DL";
break;
case MediaType.DVDPRDL:
tabDvdr.Text = "DVD+R DL";
break;
case MediaType.DVDRAM:
tabDvdr.Text = "DVD-RAM";
break;
case MediaType.DVDRWDL:
tabDvdr.Text = "DVD-RW DL";
break;
case MediaType.HDDVDRAM:
tabDvdr.Text = "HD DVD-RAM";
break;
case MediaType.HDDVDR:
tabDvdr.Text = "HD DVD-R";
break;
case MediaType.HDDVDRW:
tabDvdr.Text = "HD DVD-RW";
break;
case MediaType.HDDVDRDL:
tabDvdr.Text = "HD DVD-R DL";
break;
case MediaType.HDDVDRWDL:
tabDvdr.Text = "HD DVD-RW DL";
break;
}
txtType.Text = scsiInfo.MediaType.ToString();
lblMediaSize.Text =
$"Media has {scsiInfo.Blocks} blocks of {scsiInfo.BlockSize} bytes/each. (for a total of {scsiInfo.Blocks * scsiInfo.BlockSize} bytes)";
lblMediaSize.Visible = scsiInfo.Blocks != 0 && scsiInfo.BlockSize != 0;
if (scsiInfo.MediaSerialNumber != null)
{
stkMediaSerial.Visible = true;
StringBuilder sbSerial = new StringBuilder();
for (int i = 4; i < scsiInfo.MediaSerialNumber.Length; i++)
{
sbSerial.AppendFormat("{0:X2}", scsiInfo.MediaSerialNumber[i]);
}
txtMediaSerial.Text = sbSerial.ToString();
}
btnSaveReadMediaSerial.Visible = this.scsiInfo.MediaSerialNumber != null;
btnSaveReadCapacity.Visible = this.scsiInfo.ReadCapacity != null;
btnSaveReadCapacity16.Visible = this.scsiInfo.ReadCapacity16 != null;
btnSaveGetConfiguration.Visible = this.scsiInfo.MmcConfiguration != null;
btnSaveRecognizedFormatLayers.Visible = this.scsiInfo.RecognizedFormatLayers != null;
btnSaveWriteProtectionStatus.Visible = this.scsiInfo.WriteProtectionStatus != null;
tabMmc.Visible = btnSaveGetConfiguration.Visible || btnSaveRecognizedFormatLayers.Visible ||
btnSaveWriteProtectionStatus.Visible;
if (this.scsiInfo.DensitySupportHeader.HasValue)
{
grpDensitySupport.Visible = true;
txtDensitySupport.Text = DensitySupport.PrettifyDensity(scsiInfo.DensitySupportHeader);
}
if (this.scsiInfo.MediaTypeSupportHeader.HasValue)
{
grpMediumSupport.Visible = true;
txtMediumSupport.Text = DensitySupport.PrettifyMediumType(scsiInfo.MediaTypeSupportHeader);
}
btnSaveDensitySupport.Visible = scsiInfo.DensitySupport != null;
btnSaveMediumSupport.Visible = scsiInfo.MediaTypeSupport != null;
tabSsc.Visible = grpDensitySupport.Visible || grpMediumSupport.Visible || btnSaveDensitySupport.Visible ||
btnSaveMediumSupport.Visible;
if (this.scsiInfo.DecodedCompactDiscInformation.HasValue)
{
tabCdInformation.Visible = true;
txtCdInformation.Text = DiscInformation.Prettify000b(scsiInfo.DecodedCompactDiscInformation);
btnCdInformation.Visible = scsiInfo.CompactDiscInformation != null;
}
if (this.scsiInfo.DecodedToc.HasValue)
{
tabCdToc.Visible = true;
txtCdToc.Text = TOC.Prettify(scsiInfo.DecodedToc);
btnCdToc.Visible = scsiInfo.Toc != null;
}
if (this.scsiInfo.FullToc.HasValue)
{
tabCdFullToc.Visible = true;
txtCdFullToc.Text = FullTOC.Prettify(scsiInfo.FullToc);
btnCdFullToc.Visible = scsiInfo.RawToc != null;
}
if (this.scsiInfo.DecodedSession.HasValue)
{
tabCdSession.Visible = true;
txtCdSession.Text = Session.Prettify(scsiInfo.DecodedSession);
btnCdSession.Visible = scsiInfo.Session != null;
}
if (this.scsiInfo.DecodedCdTextLeadIn.HasValue)
{
tabCdText.Visible = true;
txtCdText.Text = CDTextOnLeadIn.Prettify(this.scsiInfo.DecodedCdTextLeadIn);
btnCdText.Visible = scsiInfo.CdTextLeadIn != null;
}
if (this.scsiInfo.DecodedAtip.HasValue)
{
tabCdAtip.Visible = true;
txtCdAtip.Text = ATIP.Prettify(this.scsiInfo.Atip);
btnCdAtip.Visible = scsiInfo.Atip != null;
}
if (!string.IsNullOrEmpty(scsiInfo.Mcn))
{
stkMcn.Visible = true;
txtMcn.Text = scsiInfo.Mcn;
}
if (this.scsiInfo.Isrcs != null && this.scsiInfo.Isrcs.Count > 0)
{
grpIsrcs.Visible = true;
TreeGridItemCollection isrcsItems = new TreeGridItemCollection();
grdIsrcs.Columns.Add(new GridColumn {
HeaderText = "ISRC", DataCell = new TextBoxCell(0)
});
grdIsrcs.Columns.Add(new GridColumn {
HeaderText = "Track", DataCell = new TextBoxCell(0)
});
grdIsrcs.AllowMultipleSelection = false;
grdIsrcs.ShowHeader = true;
grdIsrcs.DataStore = isrcsItems;
foreach (KeyValuePair <byte, string> isrc in this.scsiInfo.Isrcs)
{
isrcsItems.Add(new TreeGridItem {
Values = new object[] { isrc.Key.ToString(), isrc.Value }
});
}
}
btnCdPma.Visible = this.scsiInfo.Pma != null;
tabCdMisc.Visible = stkMcn.Visible || grpIsrcs.Visible || btnCdPma.Visible;
tabCd.Visible = tabCdInformation.Visible || tabCdToc.Visible || tabCdFullToc.Visible ||
tabCdSession.Visible || tabCdText.Visible || tabCdAtip.Visible || stkMcn.Visible ||
grpIsrcs.Visible || btnCdPma.Visible;
if (this.scsiInfo.DecodedPfi.HasValue)
{
grpDvdPfi.Visible = true;
txtDvdPfi.Text = PFI.Prettify(this.scsiInfo.DecodedPfi);
}
if (this.scsiInfo.DvdCmi != null)
{
grpDvdCmi.Visible = true;
txtDvdCmi.Text = CSS_CPRM.PrettifyLeadInCopyright(this.scsiInfo.DvdCmi);
btnSaveDvdCmi.Visible = true;
}
btnSaveDvdPfi.Visible = this.scsiInfo.DvdPfi != null;
btnSaveDvdDmi.Visible = this.scsiInfo.DvdDmi != null;
btnSaveDvdCmi.Visible = this.scsiInfo.DvdCmi != null;
btnSaveHdDvdCmi.Visible = this.scsiInfo.HddvdCopyrightInformation != null;
btnSaveDvdBca.Visible = this.scsiInfo.DvdBca != null;
btnSaveDvdAacs.Visible = this.scsiInfo.DvdAacs != null;
tabDvd.Visible = grpDvdPfi.Visible || grpDvdCmi.Visible || btnSaveDvdPfi.Visible ||
btnSaveDvdDmi.Visible ||
btnSaveDvdCmi.Visible || btnSaveHdDvdCmi.Visible || btnSaveDvdBca.Visible ||
btnSaveDvdAacs.Visible;
if (this.scsiInfo.XgdInfo != null)
{
stkXboxInformation.Visible = true;
txtXboxL0Video.Text = $"{this.scsiInfo.XgdInfo.L0Video} sectors";
txtXboxL1Video.Text = $"{this.scsiInfo.XgdInfo.L1Video} sectors";
txtXboxMiddleZone.Text = $"{this.scsiInfo.XgdInfo.MiddleZone} sectors";
txtXboxGameSize.Text = $"{this.scsiInfo.XgdInfo.GameSize} sectors";
txtXboxTotalSize.Text = $"{this.scsiInfo.XgdInfo.TotalSize} sectors";
txtXboxRealBreak.Text = this.scsiInfo.XgdInfo.LayerBreak.ToString();
}
if (this.scsiInfo.DvdDmi != null)
{
if (DMI.IsXbox(scsiInfo.DvdDmi))
{
grpXboxDmi.Visible = true;
txtXboxDmi.Text = DMI.PrettifyXbox(scsiInfo.DvdDmi);
}
else if (DMI.IsXbox360(scsiInfo.DvdDmi))
{
grpXboxDmi.Visible = true;
txtXboxDmi.Text = DMI.PrettifyXbox360(scsiInfo.DvdDmi);
}
}
if (this.scsiInfo.DecodedXboxSecuritySector.HasValue)
{
grpXboxSs.Visible = true;
txtXboxSs.Text = SS.Prettify(this.scsiInfo.DecodedXboxSecuritySector);
}
btnSaveXboxSs.Visible = this.scsiInfo.XboxSecuritySector != null;
tabXbox.Visible = stkXboxInformation.Visible || grpXboxDmi.Visible || grpXboxSs.Visible ||
btnSaveXboxSs.Visible;
if (this.scsiInfo.DvdRamDds != null)
{
grpDvdRamDds.Visible = true;
btnSaveDvdRamDds.Visible = true;
txtDvdRamDds.Text = DDS.Prettify(this.scsiInfo.DvdRamDds);
}
if (this.scsiInfo.DvdRamCartridgeStatus != null)
{
grpDvdRamCartridgeStatus.Visible = true;
btnSaveDvdRamCartridgeStatus.Visible = true;
txtDvdRamCartridgeStatus.Text = Cartridge.Prettify(this.scsiInfo.DvdRamCartridgeStatus);
}
if (this.scsiInfo.DvdRamSpareArea != null)
{
grpDvdRamSpareAreaInformation.Visible = true;
btnSaveDvdRamSpareAreaInformation.Visible = true;
txtDvdRamSpareAreaInformation.Text = Spare.Prettify(this.scsiInfo.DvdRamSpareArea);
}
btnSaveDvdRamDds.Visible = this.scsiInfo.DvdRamDds != null;
btnSaveDvdRamCartridgeStatus.Visible = this.scsiInfo.DvdRamCartridgeStatus != null;
btnSaveDvdRamSpareAreaInformation.Visible = this.scsiInfo.DvdRamSpareArea != null;
btnSaveLastBorderOutRmd.Visible = this.scsiInfo.LastBorderOutRmd != null;
btnSaveDvdPreRecordedInfo.Visible = this.scsiInfo.DvdPreRecordedInfo != null;
btnSaveDvdrMediaIdentifier.Visible = this.scsiInfo.DvdrMediaIdentifier != null;
btnSaveDvdrPhysicalInformation.Visible = this.scsiInfo.DvdrPhysicalInformation != null;
btnSaveHddvdrMediumStatus.Visible = this.scsiInfo.HddvdrMediumStatus != null;
btnSaveHddvdrLastRmd.Visible = this.scsiInfo.HddvdrLastRmd != null;
btnSaveDvdrLayerCapacity.Visible = this.scsiInfo.DvdrLayerCapacity != null;
btnSaveDvdrDlMiddleZoneStart.Visible = this.scsiInfo.DvdrDlMiddleZoneStart != null;
btnSaveDvdrDlJumpIntervalSize.Visible = this.scsiInfo.DvdrDlJumpIntervalSize != null;
btnSaveDvdrDlManualLayerJumpStartLba.Visible = this.scsiInfo.DvdrDlManualLayerJumpStartLba != null;
btnSaveDvdrDlRemapAnchorPoint.Visible = this.scsiInfo.DvdrDlRemapAnchorPoint != null;
btnSaveDvdPlusAdip.Visible = this.scsiInfo.DvdPlusAdip != null;
btnSaveDvdPlusDcb.Visible = this.scsiInfo.DvdPlusDcb != null;
tabDvdr.Visible = grpDvdRamDds.Visible || grpDvdRamCartridgeStatus.Visible ||
grpDvdRamSpareAreaInformation.Visible || btnSaveDvdRamDds.Visible ||
btnSaveDvdRamCartridgeStatus.Visible || btnSaveDvdRamSpareAreaInformation.Visible ||
btnSaveLastBorderOutRmd.Visible || btnSaveDvdPreRecordedInfo.Visible ||
btnSaveDvdrMediaIdentifier.Visible || btnSaveDvdrPhysicalInformation.Visible ||
btnSaveHddvdrMediumStatus.Visible || btnSaveHddvdrLastRmd.Visible ||
btnSaveDvdrLayerCapacity.Visible || btnSaveDvdrDlMiddleZoneStart.Visible ||
btnSaveDvdrDlJumpIntervalSize.Visible || btnSaveDvdrDlManualLayerJumpStartLba.Visible ||
btnSaveDvdrDlRemapAnchorPoint.Visible || btnSaveDvdPlusAdip.Visible ||
btnSaveDvdPlusDcb.Visible;
if (this.scsiInfo.BlurayDiscInformation != null)
{
grpBlurayDiscInformation.Visible = true;
btnSaveBlurayDiscInformation.Visible = true;
txtBlurayDiscInformation.Text = DI.Prettify(this.scsiInfo.BlurayDiscInformation);
}
if (this.scsiInfo.BlurayBurstCuttingArea != null)
{
grpBlurayBurstCuttingArea.Visible = true;
btnSaveBlurayBurstCuttingArea.Visible = true;
txtBlurayBurstCuttingArea.Text = BCA.Prettify(this.scsiInfo.BlurayBurstCuttingArea);
}
if (this.scsiInfo.BlurayDds != null)
{
grpBlurayDds.Visible = true;
btnSaveBlurayDds.Visible = true;
txtBlurayDds.Text = Decoders.Bluray.DDS.Prettify(this.scsiInfo.BlurayDds);
}
if (this.scsiInfo.BlurayCartridgeStatus != null)
{
grpBlurayCartridgeStatus.Visible = true;
btnSaveBlurayCartridgeStatus.Visible = true;
txtBlurayCartridgeStatus.Text =
Decoders.Bluray.Cartridge.Prettify(this.scsiInfo.BlurayCartridgeStatus);
}
if (this.scsiInfo.BluraySpareAreaInformation != null)
{
grpBluraySpareAreaInformation.Visible = true;
btnSaveBluraySpareAreaInformation.Visible = true;
txtBluraySpareAreaInformation.Text =
Decoders.Bluray.Spare.Prettify(this.scsiInfo.BluraySpareAreaInformation);
}
if (this.scsiInfo.BlurayPowResources != null)
{
grpBlurayPowResources.Visible = true;
btnSaveBlurayPowResources.Visible = true;
txtBlurayPowResources.Text = DiscInformation.Prettify(this.scsiInfo.BlurayPowResources);
}
if (this.scsiInfo.BlurayTrackResources != null)
{
grpBlurayTrackResources.Visible = true;
btnSaveBlurayTrackResources.Visible = true;
txtBlurayTrackResources.Text = DiscInformation.Prettify(this.scsiInfo.BlurayTrackResources);
}
btnSaveBlurayRawDfl.Visible = this.scsiInfo.BlurayRawDfl != null;
btnSaveBlurayPac.Visible = this.scsiInfo.BlurayPac != null;
tabBluray.Visible = grpBlurayDiscInformation.Visible || grpBlurayBurstCuttingArea.Visible ||
grpBlurayDds.Visible || grpBlurayCartridgeStatus.Visible ||
grpBluraySpareAreaInformation.Visible || grpBlurayPowResources.Visible ||
grpBlurayTrackResources.Visible || btnSaveBlurayRawDfl.Visible ||
btnSaveBlurayPac.Visible;
}
public pnlImageInfo(string imagePath, IFilter filter, IMediaImage imageFormat)
{
this.imagePath = imagePath;
this.filter = filter;
this.imageFormat = imageFormat;
XamlReader.Load(this);
Stream logo =
ResourceHandler
.GetResourceStream($"DiscImageChef.Gui.Assets.Logos.Media.{imageFormat.Info.MediaType}.svg");
/* if(logo != null)
* {
* svgMediaLogo.SvgStream = logo;
* svgMediaLogo.Visible = true;
* }
* else
* {*/
logo =
ResourceHandler
.GetResourceStream($"DiscImageChef.Gui.Assets.Logos.Media.{imageFormat.Info.MediaType}.png");
if (logo != null)
{
imgMediaLogo.Image = new Bitmap(logo);
imgMediaLogo.Visible = true;
}
//}
lblImagePath.Text = $"Path: {imagePath}";
lblFilter.Text = $"Filter: {filter.Name}";
lblImageFormat.Text = $"Image format identified by {imageFormat.Name} ({imageFormat.Id}).";
lblImageFormat.Text = !string.IsNullOrWhiteSpace(imageFormat.Info.Version)
? $"Format: {imageFormat.Format} version {imageFormat.Info.Version}"
: $"Format: {imageFormat.Format}";
lblImageSize.Text = $"Image without headers is {imageFormat.Info.ImageSize} bytes long";
lblSectors.Text =
$"Contains a media of {imageFormat.Info.Sectors} sectors with a maximum sector size of {imageFormat.Info.SectorSize} bytes (if all sectors are of the same size this would be {imageFormat.Info.Sectors * imageFormat.Info.SectorSize} bytes)";
lblMediaType.Text =
$"Contains a media of type {imageFormat.Info.MediaType} and XML type {imageFormat.Info.XmlMediaType}";
lblHasPartitions.Text = $"{(imageFormat.Info.HasPartitions ? "Has" : "Doesn't have")} partitions";
lblHasSessions.Text = $"{(imageFormat.Info.HasSessions ? "Has" : "Doesn't have")} sessions";
if (!string.IsNullOrWhiteSpace(imageFormat.Info.Application))
{
lblApplication.Visible = true;
lblApplication.Text = !string.IsNullOrWhiteSpace(imageFormat.Info.ApplicationVersion)
? $"Was created with {imageFormat.Info.Application} version {imageFormat.Info.ApplicationVersion}"
: $"Was created with {imageFormat.Info.Application}";
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.Creator))
{
lblCreator.Visible = true;
lblCreator.Text = $"Created by: {imageFormat.Info.Creator}";
}
if (imageFormat.Info.CreationTime != DateTime.MinValue)
{
lblCreationTime.Visible = true;
lblCreationTime.Text = $"Created on {imageFormat.Info.CreationTime}";
}
if (imageFormat.Info.LastModificationTime != DateTime.MinValue)
{
lblLastModificationTime.Visible = true;
lblLastModificationTime.Text = $"Last modified on {imageFormat.Info.LastModificationTime}";
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.Comments))
{
grpComments.Visible = true;
txtComments.Text = imageFormat.Info.Comments;
}
if (imageFormat.Info.MediaSequence != 0 && imageFormat.Info.LastMediaSequence != 0)
{
lblMediaSequence.Visible = true;
lblMediaSequence.Text =
$"Media is number {imageFormat.Info.MediaSequence} on a set of {imageFormat.Info.LastMediaSequence} medias";
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.MediaTitle))
{
lblMediaTitle.Visible = true;
lblMediaTitle.Text = $"Media title: {imageFormat.Info.MediaTitle}";
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.MediaManufacturer))
{
lblMediaManufacturer.Visible = true;
lblMediaManufacturer.Text = $"Media manufacturer: {imageFormat.Info.MediaManufacturer}";
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.MediaModel))
{
lblMediaModel.Visible = true;
lblMediaModel.Text = $"Media model: {imageFormat.Info.MediaModel}";
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.MediaSerialNumber))
{
lblMediaSerialNumber.Visible = true;
lblMediaSerialNumber.Text = $"Media serial number: {imageFormat.Info.MediaSerialNumber}";
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.MediaBarcode))
{
lblMediaBarcode.Visible = true;
lblMediaBarcode.Text = $"Media barcode: {imageFormat.Info.MediaBarcode}";
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.MediaPartNumber))
{
lblMediaPartNumber.Visible = true;
lblMediaPartNumber.Text = $"Media part number: {imageFormat.Info.MediaPartNumber}";
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.DriveManufacturer))
{
lblDriveManufacturer.Visible = true;
lblDriveManufacturer.Text = $"Drive manufacturer: {imageFormat.Info.DriveManufacturer}";
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.DriveModel))
{
lblDriveModel.Visible = true;
lblDriveModel.Text = $"Drive model: {imageFormat.Info.DriveModel}";
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.DriveSerialNumber))
{
lblDriveSerialNumber.Visible = true;
lblDriveSerialNumber.Text = $"Drive serial number: {imageFormat.Info.DriveSerialNumber}";
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.DriveFirmwareRevision))
{
lblDriveFirmwareRevision.Visible = true;
lblDriveFirmwareRevision.Text = $"Drive firmware info: {imageFormat.Info.DriveFirmwareRevision}";
}
if (imageFormat.Info.Cylinders > 0 && imageFormat.Info.Heads > 0 &&
imageFormat.Info.SectorsPerTrack > 0 &&
imageFormat.Info.XmlMediaType != XmlMediaType.OpticalDisc &&
(!(imageFormat is ITapeImage tapeImage) || !tapeImage.IsTape))
{
lblMediaGeometry.Visible = true;
lblMediaGeometry.Text =
$"Media geometry: {imageFormat.Info.Cylinders} cylinders, {imageFormat.Info.Heads} heads, {imageFormat.Info.SectorsPerTrack} sectors per track";
}
grpMediaInfo.Visible = lblMediaSequence.Visible || lblMediaTitle.Visible ||
lblMediaManufacturer.Visible ||
lblMediaModel.Visible || lblMediaSerialNumber.Visible ||
lblMediaBarcode.Visible ||
lblMediaPartNumber.Visible;
grpDriveInfo.Visible = lblDriveManufacturer.Visible || lblDriveModel.Visible ||
lblDriveSerialNumber.Visible || lblDriveFirmwareRevision.Visible ||
lblMediaGeometry.Visible;
if (imageFormat.Info.ReadableMediaTags != null && imageFormat.Info.ReadableMediaTags.Count > 0)
{
TreeGridItemCollection mediaTagList = new TreeGridItemCollection();
treeMediaTags.Columns.Add(new GridColumn {
HeaderText = "Tag", DataCell = new TextBoxCell(0)
});
treeMediaTags.AllowMultipleSelection = false;
treeMediaTags.ShowHeader = false;
treeMediaTags.DataStore = mediaTagList;
foreach (MediaTagType tag in imageFormat.Info.ReadableMediaTags.OrderBy(t => t))
{
mediaTagList.Add(new TreeGridItem {
Values = new object[] { tag.ToString() }
});
}
grpMediaTags.Visible = true;
}
if (imageFormat.Info.ReadableSectorTags != null && imageFormat.Info.ReadableSectorTags.Count > 0)
{
TreeGridItemCollection sectorTagList = new TreeGridItemCollection();
treeSectorTags.Columns.Add(new GridColumn {
HeaderText = "Tag", DataCell = new TextBoxCell(0)
});
treeSectorTags.AllowMultipleSelection = false;
treeSectorTags.ShowHeader = false;
treeSectorTags.DataStore = sectorTagList;
foreach (SectorTagType tag in imageFormat.Info.ReadableSectorTags.OrderBy(t => t))
{
sectorTagList.Add(new TreeGridItem {
Values = new object[] { tag.ToString() }
});
}
grpSectorTags.Visible = true;
}
PeripheralDeviceTypes scsiDeviceType = PeripheralDeviceTypes.DirectAccess;
byte[] scsiInquiryData = null;
Inquiry.SCSIInquiry?scsiInquiry = null;
Modes.DecodedMode? scsiMode = null;
byte[] scsiModeSense6 = null;
byte[] scsiModeSense10 = null;
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.SCSI_INQUIRY))
{
scsiInquiryData = imageFormat.ReadDiskTag(MediaTagType.SCSI_INQUIRY);
scsiDeviceType = (PeripheralDeviceTypes)(scsiInquiryData[0] & 0x1F);
scsiInquiry = Inquiry.Decode(scsiInquiryData);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.SCSI_MODESENSE_6))
{
scsiModeSense6 = imageFormat.ReadDiskTag(MediaTagType.SCSI_MODESENSE_6);
scsiMode = Modes.DecodeMode6(scsiModeSense6, scsiDeviceType);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.SCSI_MODESENSE_10))
{
scsiModeSense10 = imageFormat.ReadDiskTag(MediaTagType.SCSI_MODESENSE_10);
scsiMode = Modes.DecodeMode10(scsiModeSense10, scsiDeviceType);
}
tabScsiInfo tabScsiInfo = new tabScsiInfo();
tabScsiInfo.LoadData(scsiInquiryData, scsiInquiry, null, scsiMode, scsiDeviceType, scsiModeSense6,
scsiModeSense10, null);
tabInfos.Pages.Add(tabScsiInfo);
byte[] ataIdentify = null;
byte[] atapiIdentify = null;
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.ATA_IDENTIFY))
{
ataIdentify = imageFormat.ReadDiskTag(MediaTagType.ATA_IDENTIFY);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.ATAPI_IDENTIFY))
{
atapiIdentify = imageFormat.ReadDiskTag(MediaTagType.ATAPI_IDENTIFY);
}
tabAtaInfo tabAtaInfo = new tabAtaInfo();
tabAtaInfo.LoadData(ataIdentify, atapiIdentify, null);
tabInfos.Pages.Add(tabAtaInfo);
byte[] toc = null;
TOC.CDTOC? decodedToc = null;
byte[] fullToc = null;
FullTOC.CDFullTOC? decodedFullToc = null;
byte[] pma = null;
byte[] atip = null;
ATIP.CDATIP? decodedAtip = null;
byte[] cdtext = null;
CDTextOnLeadIn.CDText?decodedCdText = null;
string mediaCatalogueNumber = null;
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.CD_TOC))
{
toc = imageFormat.ReadDiskTag(MediaTagType.CD_TOC);
if (toc.Length > 0)
{
ushort dataLen = Swapping.Swap(BitConverter.ToUInt16(toc, 0));
if (dataLen + 2 != toc.Length)
{
byte[] tmp = new byte[toc.Length + 2];
Array.Copy(toc, 0, tmp, 2, toc.Length);
tmp[0] = (byte)((toc.Length & 0xFF00) >> 8);
tmp[1] = (byte)(toc.Length & 0xFF);
toc = tmp;
}
decodedToc = TOC.Decode(toc);
}
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.CD_FullTOC))
{
fullToc = imageFormat.ReadDiskTag(MediaTagType.CD_FullTOC);
if (fullToc.Length > 0)
{
ushort dataLen = Swapping.Swap(BitConverter.ToUInt16(fullToc, 0));
if (dataLen + 2 != fullToc.Length)
{
byte[] tmp = new byte[fullToc.Length + 2];
Array.Copy(fullToc, 0, tmp, 2, fullToc.Length);
tmp[0] = (byte)((fullToc.Length & 0xFF00) >> 8);
tmp[1] = (byte)(fullToc.Length & 0xFF);
fullToc = tmp;
}
decodedFullToc = FullTOC.Decode(fullToc);
}
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.CD_PMA))
{
pma = imageFormat.ReadDiskTag(MediaTagType.CD_PMA);
if (pma.Length > 0)
{
ushort dataLen = Swapping.Swap(BitConverter.ToUInt16(pma, 0));
if (dataLen + 2 != pma.Length)
{
byte[] tmp = new byte[pma.Length + 2];
Array.Copy(pma, 0, tmp, 2, pma.Length);
tmp[0] = (byte)((pma.Length & 0xFF00) >> 8);
tmp[1] = (byte)(pma.Length & 0xFF);
pma = tmp;
}
}
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.CD_ATIP))
{
atip = imageFormat.ReadDiskTag(MediaTagType.CD_ATIP);
uint dataLen = Swapping.Swap(BitConverter.ToUInt32(atip, 0));
if (dataLen + 4 != atip.Length)
{
byte[] tmp = new byte[atip.Length + 4];
Array.Copy(atip, 0, tmp, 4, atip.Length);
tmp[0] = (byte)((atip.Length & 0xFF000000) >> 24);
tmp[1] = (byte)((atip.Length & 0xFF0000) >> 16);
tmp[2] = (byte)((atip.Length & 0xFF00) >> 8);
tmp[3] = (byte)(atip.Length & 0xFF);
atip = tmp;
}
decodedAtip = ATIP.Decode(atip);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.CD_TEXT))
{
cdtext = imageFormat.ReadDiskTag(MediaTagType.CD_TEXT);
uint dataLen = Swapping.Swap(BitConverter.ToUInt32(cdtext, 0));
if (dataLen + 4 != cdtext.Length)
{
byte[] tmp = new byte[cdtext.Length + 4];
Array.Copy(cdtext, 0, tmp, 4, cdtext.Length);
tmp[0] = (byte)((cdtext.Length & 0xFF000000) >> 24);
tmp[1] = (byte)((cdtext.Length & 0xFF0000) >> 16);
tmp[2] = (byte)((cdtext.Length & 0xFF00) >> 8);
tmp[3] = (byte)(cdtext.Length & 0xFF);
cdtext = tmp;
}
decodedCdText = CDTextOnLeadIn.Decode(cdtext);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.CD_MCN))
{
byte[] mcn = imageFormat.ReadDiskTag(MediaTagType.CD_MCN);
mediaCatalogueNumber = Encoding.UTF8.GetString(mcn);
}
tabCompactDiscInfo tabCompactDiscInfo = new tabCompactDiscInfo();
tabCompactDiscInfo.LoadData(toc, atip, null, null, fullToc, pma, cdtext, decodedToc, decodedAtip, null,
decodedFullToc, decodedCdText, null, mediaCatalogueNumber, null);
tabInfos.Pages.Add(tabCompactDiscInfo);
byte[] dvdPfi = null;
byte[] dvdDmi = null;
byte[] dvdCmi = null;
byte[] hddvdCopyrightInformation = null;
byte[] dvdBca = null;
PFI.PhysicalFormatInformation?decodedPfi = null;
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVD_PFI))
{
dvdPfi = imageFormat.ReadDiskTag(MediaTagType.DVD_PFI);
decodedPfi = PFI.Decode(dvdPfi);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVD_DMI))
{
dvdDmi = imageFormat.ReadDiskTag(MediaTagType.DVD_DMI);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVD_CMI))
{
dvdCmi = imageFormat.ReadDiskTag(MediaTagType.DVD_CMI);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.HDDVD_CPI))
{
hddvdCopyrightInformation = imageFormat.ReadDiskTag(MediaTagType.HDDVD_CPI);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVD_BCA))
{
dvdBca = imageFormat.ReadDiskTag(MediaTagType.DVD_BCA);
}
tabDvdInfo tabDvdInfo = new tabDvdInfo();
tabDvdInfo.LoadData(imageFormat.Info.MediaType, dvdPfi, dvdDmi, dvdCmi, hddvdCopyrightInformation, dvdBca,
null, decodedPfi);
tabInfos.Pages.Add(tabDvdInfo);
byte[] dvdRamDds = null;
byte[] dvdRamCartridgeStatus = null;
byte[] dvdRamSpareArea = null;
byte[] lastBorderOutRmd = null;
byte[] dvdPreRecordedInfo = null;
byte[] dvdrMediaIdentifier = null;
byte[] dvdrPhysicalInformation = null;
byte[] hddvdrMediumStatus = null;
byte[] dvdrLayerCapacity = null;
byte[] dvdrDlMiddleZoneStart = null;
byte[] dvdrDlJumpIntervalSize = null;
byte[] dvdrDlManualLayerJumpStartLba = null;
byte[] dvdPlusAdip = null;
byte[] dvdPlusDcb = null;
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVDRAM_DDS))
{
dvdRamDds = imageFormat.ReadDiskTag(MediaTagType.DVDRAM_DDS);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVDRAM_MediumStatus))
{
dvdRamCartridgeStatus = imageFormat.ReadDiskTag(MediaTagType.DVDRAM_MediumStatus);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVDRAM_SpareArea))
{
dvdRamSpareArea = imageFormat.ReadDiskTag(MediaTagType.DVDRAM_SpareArea);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVDR_RMD))
{
lastBorderOutRmd = imageFormat.ReadDiskTag(MediaTagType.DVDR_RMD);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVDR_PreRecordedInfo))
{
dvdPreRecordedInfo = imageFormat.ReadDiskTag(MediaTagType.DVDR_PreRecordedInfo);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVDR_MediaIdentifier))
{
dvdrMediaIdentifier = imageFormat.ReadDiskTag(MediaTagType.DVDR_MediaIdentifier);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVDR_PFI))
{
dvdrPhysicalInformation = imageFormat.ReadDiskTag(MediaTagType.DVDR_PFI);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.HDDVD_MediumStatus))
{
hddvdrMediumStatus = imageFormat.ReadDiskTag(MediaTagType.HDDVD_MediumStatus);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVDDL_LayerCapacity))
{
dvdrLayerCapacity = imageFormat.ReadDiskTag(MediaTagType.DVDDL_LayerCapacity);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVDDL_MiddleZoneAddress))
{
dvdrDlMiddleZoneStart = imageFormat.ReadDiskTag(MediaTagType.DVDDL_MiddleZoneAddress);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVDDL_JumpIntervalSize))
{
dvdrDlJumpIntervalSize = imageFormat.ReadDiskTag(MediaTagType.DVDDL_JumpIntervalSize);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVDDL_ManualLayerJumpLBA))
{
dvdrDlManualLayerJumpStartLba = imageFormat.ReadDiskTag(MediaTagType.DVDDL_ManualLayerJumpLBA);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVD_ADIP))
{
dvdPlusAdip = imageFormat.ReadDiskTag(MediaTagType.DVD_ADIP);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DCB))
{
dvdPlusDcb = imageFormat.ReadDiskTag(MediaTagType.DCB);
}
tabDvdWritableInfo tabDvdWritableInfo = new tabDvdWritableInfo();
tabDvdWritableInfo.LoadData(imageFormat.Info.MediaType, dvdRamDds, dvdRamCartridgeStatus, dvdRamSpareArea,
lastBorderOutRmd, dvdPreRecordedInfo, dvdrMediaIdentifier,
dvdrPhysicalInformation, hddvdrMediumStatus, null, dvdrLayerCapacity,
dvdrDlMiddleZoneStart, dvdrDlJumpIntervalSize, dvdrDlManualLayerJumpStartLba,
null, dvdPlusAdip, dvdPlusDcb);
tabInfos.Pages.Add(tabDvdWritableInfo);
byte[] blurayBurstCuttingArea = null;
byte[] blurayCartridgeStatus = null;
byte[] blurayDds = null;
byte[] blurayDiscInformation = null;
byte[] blurayPowResources = null;
byte[] bluraySpareAreaInformation = null;
byte[] blurayTrackResources = null;
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.BD_BCA))
{
blurayBurstCuttingArea = imageFormat.ReadDiskTag(MediaTagType.BD_BCA);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.BD_CartridgeStatus))
{
blurayCartridgeStatus = imageFormat.ReadDiskTag(MediaTagType.BD_CartridgeStatus);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.BD_DDS))
{
blurayDds = imageFormat.ReadDiskTag(MediaTagType.BD_DDS);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.BD_DI))
{
blurayDiscInformation = imageFormat.ReadDiskTag(MediaTagType.BD_DI);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.MMC_POWResourcesInformation))
{
blurayPowResources = imageFormat.ReadDiskTag(MediaTagType.MMC_POWResourcesInformation);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.BD_SpareArea))
{
bluraySpareAreaInformation = imageFormat.ReadDiskTag(MediaTagType.BD_SpareArea);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.MMC_TrackResourcesInformation))
{
bluraySpareAreaInformation = imageFormat.ReadDiskTag(MediaTagType.MMC_TrackResourcesInformation);
}
tabBlurayInfo tabBlurayInfo = new tabBlurayInfo();
tabBlurayInfo.LoadData(blurayDiscInformation, blurayBurstCuttingArea, blurayDds, blurayCartridgeStatus,
bluraySpareAreaInformation, blurayPowResources, blurayTrackResources, null, null);
tabInfos.Pages.Add(tabBlurayInfo);
byte[] xboxDmi = null;
byte[] xboxSecuritySector = null;
SS.SecuritySector?decodedXboxSecuritySector = null;
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.Xbox_DMI))
{
xboxDmi = imageFormat.ReadDiskTag(MediaTagType.Xbox_DMI);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.Xbox_SecuritySector))
{
xboxSecuritySector = imageFormat.ReadDiskTag(MediaTagType.Xbox_SecuritySector);
decodedXboxSecuritySector = SS.Decode(xboxSecuritySector);
}
tabXboxInfo tabXboxInfo = new tabXboxInfo();
tabXboxInfo.LoadData(null, xboxDmi, xboxSecuritySector, decodedXboxSecuritySector);
tabInfos.Pages.Add(tabXboxInfo);
byte[] pcmciaCis = null;
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.PCMCIA_CIS))
{
pcmciaCis = imageFormat.ReadDiskTag(MediaTagType.PCMCIA_CIS);
}
tabPcmciaInfo tabPcmciaInfo = new tabPcmciaInfo();
tabPcmciaInfo.LoadData(pcmciaCis);
tabInfos.Pages.Add(tabPcmciaInfo);
DeviceType deviceType = DeviceType.Unknown;
byte[] cid = null;
byte[] csd = null;
byte[] ocr = null;
byte[] extendedCsd = null;
byte[] scr = null;
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.SD_CID))
{
cid = imageFormat.ReadDiskTag(MediaTagType.SD_CID);
deviceType = DeviceType.SecureDigital;
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.SD_CSD))
{
csd = imageFormat.ReadDiskTag(MediaTagType.SD_CSD);
deviceType = DeviceType.SecureDigital;
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.SD_OCR))
{
ocr = imageFormat.ReadDiskTag(MediaTagType.SD_OCR);
deviceType = DeviceType.SecureDigital;
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.SD_SCR))
{
scr = imageFormat.ReadDiskTag(MediaTagType.SD_SCR);
deviceType = DeviceType.SecureDigital;
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.MMC_CID))
{
cid = imageFormat.ReadDiskTag(MediaTagType.MMC_CID);
deviceType = DeviceType.MMC;
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.MMC_CSD))
{
csd = imageFormat.ReadDiskTag(MediaTagType.MMC_CSD);
deviceType = DeviceType.MMC;
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.MMC_OCR))
{
ocr = imageFormat.ReadDiskTag(MediaTagType.MMC_OCR);
deviceType = DeviceType.MMC;
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.MMC_ExtendedCSD))
{
extendedCsd = imageFormat.ReadDiskTag(MediaTagType.MMC_ExtendedCSD);
deviceType = DeviceType.MMC;
}
tabSdMmcInfo tabSdMmcInfo = new tabSdMmcInfo();
tabSdMmcInfo.LoadData(deviceType, cid, csd, ocr, extendedCsd, scr);
tabInfos.Pages.Add(tabSdMmcInfo);
if (imageFormat is IOpticalMediaImage opticalMediaImage)
{
try
{
if (opticalMediaImage.Sessions != null && opticalMediaImage.Sessions.Count > 0)
{
TreeGridItemCollection sessionList = new TreeGridItemCollection();
treeSessions.Columns.Add(new GridColumn
{
HeaderText = "Session", DataCell = new TextBoxCell(0)
});
treeSessions.Columns.Add(new GridColumn
{
HeaderText = "First track", DataCell = new TextBoxCell(1)
});
treeSessions.Columns.Add(new GridColumn
{
HeaderText = "Last track", DataCell = new TextBoxCell(2)
});
treeSessions.Columns.Add(new GridColumn {
HeaderText = "Start", DataCell = new TextBoxCell(3)
});
treeSessions.Columns.Add(new GridColumn {
HeaderText = "End", DataCell = new TextBoxCell(4)
});
treeSessions.AllowMultipleSelection = false;
treeSessions.ShowHeader = true;
treeSessions.DataStore = sessionList;
foreach (Session session in opticalMediaImage.Sessions)
{
sessionList.Add(new TreeGridItem
{
Values = new object[]
{
session.SessionSequence, session.StartTrack,
session.EndTrack, session.StartSector, session.EndSector
}
});
}
tabSessions.Visible = true;
}
}
catch
{
// ignored
}
try
{
if (opticalMediaImage.Tracks != null && opticalMediaImage.Tracks.Count > 0)
{
TreeGridItemCollection tracksList = new TreeGridItemCollection();
treeTracks.Columns.Add(new GridColumn {
HeaderText = "Track", DataCell = new TextBoxCell(0)
});
treeTracks.Columns.Add(new GridColumn {
HeaderText = "Type", DataCell = new TextBoxCell(1)
});
treeTracks.Columns.Add(new GridColumn {
HeaderText = "Bps", DataCell = new TextBoxCell(2)
});
treeTracks.Columns.Add(new GridColumn {
HeaderText = "Raw bps", DataCell = new TextBoxCell(3)
});
treeTracks.Columns.Add(new GridColumn
{
HeaderText = "Subchannel", DataCell = new TextBoxCell(4)
});
treeTracks.Columns.Add(new GridColumn {
HeaderText = "Pregap", DataCell = new TextBoxCell(5)
});
treeTracks.Columns.Add(new GridColumn {
HeaderText = "Start", DataCell = new TextBoxCell(6)
});
treeTracks.Columns.Add(new GridColumn {
HeaderText = "End", DataCell = new TextBoxCell(7)
});
treeTracks.AllowMultipleSelection = false;
treeTracks.ShowHeader = true;
treeTracks.DataStore = tracksList;
foreach (Track track in opticalMediaImage.Tracks)
{
tracksList.Add(new TreeGridItem
{
Values = new object[]
{
track.TrackSequence, track.TrackType,
track.TrackBytesPerSector, track.TrackRawBytesPerSector,
track.TrackSubchannelType, track.TrackPregap,
track.TrackStartSector, track.TrackEndSector
}
});
}
tabTracks.Visible = true;
}
}
catch
{
// ignored
}
}
if (imageFormat.DumpHardware == null)
{
return;
}
TreeGridItemCollection dumpHardwareList = new TreeGridItemCollection();
treeDumpHardware.Columns.Add(new GridColumn {
HeaderText = "Manufacturer", DataCell = new TextBoxCell(0)
});
treeDumpHardware.Columns.Add(new GridColumn {
HeaderText = "Model", DataCell = new TextBoxCell(1)
});
treeDumpHardware.Columns.Add(new GridColumn {
HeaderText = "Serial", DataCell = new TextBoxCell(2)
});
treeDumpHardware.Columns.Add(new GridColumn {
HeaderText = "Software", DataCell = new TextBoxCell(3)
});
treeDumpHardware.Columns.Add(new GridColumn {
HeaderText = "Version", DataCell = new TextBoxCell(4)
});
treeDumpHardware.Columns.Add(new GridColumn
{
HeaderText = "Operating system", DataCell = new TextBoxCell(5)
});
treeDumpHardware.Columns.Add(new GridColumn {
HeaderText = "Start", DataCell = new TextBoxCell(6)
});
treeDumpHardware.Columns.Add(new GridColumn {
HeaderText = "End", DataCell = new TextBoxCell(7)
});
treeDumpHardware.AllowMultipleSelection = false;
treeDumpHardware.ShowHeader = true;
treeDumpHardware.DataStore = dumpHardwareList;
foreach (DumpHardwareType dump in imageFormat.DumpHardware)
{
foreach (ExtentType extent in dump.Extents)
{
dumpHardwareList.Add(new TreeGridItem
{
Values = new object[]
{
dump.Manufacturer, dump.Model, dump.Serial, dump.Software.Name,
dump.Software.Version, dump.Software.OperatingSystem,
extent.Start, extent.End
}
});
}
}
tabDumpHardware.Visible = true;
}
/// <summary>
/// Dumps an optical disc
/// </summary>
/// <param name="dev">Device</param>
/// <param name="devicePath">Path to the device</param>
/// <param name="outputPrefix">Prefix for output data files</param>
/// <param name="outputPlugin">Plugin for output file</param>
/// <param name="retryPasses">How many times to retry</param>
/// <param name="force">Force to continue dump whenever possible</param>
/// <param name="dumpRaw">Dump raw/long sectors</param>
/// <param name="persistent">Store whatever data the drive returned on error</param>
/// <param name="stopOnError">Stop dump on first error</param>
/// <param name="resume">Information for dump resuming</param>
/// <param name="dumpLog">Dump logger</param>
/// <param name="encoding">Encoding to use when analyzing dump</param>
/// <param name="dskType">Disc type as detected in MMC layer</param>
/// <param name="dumpLeadIn">Try to read and dump as much Lead-in as possible</param>
/// <param name="outputPath">Path to output file</param>
/// <param name="formatOptions">Formats to pass to output file plugin</param>
/// <exception cref="NotImplementedException">If trying to dump GOD or WOD, or XGDs without a Kreon drive</exception>
internal static void Dump(Device dev, string devicePath,
IWritableImage outputPlugin, ushort retryPasses,
bool force, bool dumpRaw,
bool persistent, bool stopOnError, ref MediaType dskType,
ref Resume resume, ref DumpLog dumpLog,
bool dumpLeadIn, Encoding encoding,
string outputPrefix, string outputPath,
Dictionary <string, string> formatOptions,
CICMMetadataType preSidecar, uint skip,
bool nometadata, bool notrim)
{
bool sense;
ulong blocks;
byte[] tmpBuf;
bool compactDisc = true;
bool isXbox = false;
// TODO: Log not only what is it reading, but if it was read correctly or not.
sense = dev.GetConfiguration(out byte[] cmdBuf, out _, 0, MmcGetConfigurationRt.Current, dev.Timeout,
out _);
if (!sense)
{
Features.SeparatedFeatures ftr = Features.Separate(cmdBuf);
dumpLog.WriteLine("Device reports current profile is 0x{0:X4}", ftr.CurrentProfile);
switch (ftr.CurrentProfile)
{
case 0x0001:
dskType = MediaType.GENERIC_HDD;
goto default;
case 0x0005:
dskType = MediaType.CDMO;
break;
case 0x0008:
dskType = MediaType.CD;
break;
case 0x0009:
dskType = MediaType.CDR;
break;
case 0x000A:
dskType = MediaType.CDRW;
break;
case 0x0010:
dskType = MediaType.DVDROM;
goto default;
case 0x0011:
dskType = MediaType.DVDR;
goto default;
case 0x0012:
dskType = MediaType.DVDRAM;
goto default;
case 0x0013:
case 0x0014:
dskType = MediaType.DVDRW;
goto default;
case 0x0015:
case 0x0016:
dskType = MediaType.DVDRDL;
goto default;
case 0x0017:
dskType = MediaType.DVDRWDL;
goto default;
case 0x0018:
dskType = MediaType.DVDDownload;
goto default;
case 0x001A:
dskType = MediaType.DVDPRW;
goto default;
case 0x001B:
dskType = MediaType.DVDPR;
goto default;
case 0x0020:
dskType = MediaType.DDCD;
goto default;
case 0x0021:
dskType = MediaType.DDCDR;
goto default;
case 0x0022:
dskType = MediaType.DDCDRW;
goto default;
case 0x002A:
dskType = MediaType.DVDPRWDL;
goto default;
case 0x002B:
dskType = MediaType.DVDPRDL;
goto default;
case 0x0040:
dskType = MediaType.BDROM;
goto default;
case 0x0041:
case 0x0042:
dskType = MediaType.BDR;
goto default;
case 0x0043:
dskType = MediaType.BDRE;
goto default;
case 0x0050:
dskType = MediaType.HDDVDROM;
goto default;
case 0x0051:
dskType = MediaType.HDDVDR;
goto default;
case 0x0052:
dskType = MediaType.HDDVDRAM;
goto default;
case 0x0053:
dskType = MediaType.HDDVDRW;
goto default;
case 0x0058:
dskType = MediaType.HDDVDRDL;
goto default;
case 0x005A:
dskType = MediaType.HDDVDRWDL;
goto default;
default:
compactDisc = false;
break;
}
}
if (compactDisc)
{
CompactDisc.Dump(dev, devicePath, outputPlugin, retryPasses, force, dumpRaw, persistent, stopOnError,
ref dskType, ref resume, ref dumpLog, dumpLeadIn, encoding, outputPrefix, outputPath,
formatOptions, preSidecar, skip, nometadata, notrim);
return;
}
Reader scsiReader = new Reader(dev, dev.Timeout, null, dumpRaw);
blocks = scsiReader.GetDeviceBlocks();
dumpLog.WriteLine("Device reports disc has {0} blocks", blocks);
Dictionary <MediaTagType, byte[]> mediaTags = new Dictionary <MediaTagType, byte[]>();
#region Nintendo
switch (dskType)
{
case MediaType.Unknown when blocks > 0:
dumpLog.WriteLine("Reading Physical Format Information");
sense = dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.PhysicalInformation, 0, dev.Timeout, out _);
if (!sense)
{
PFI.PhysicalFormatInformation?nintendoPfi = PFI.Decode(cmdBuf);
if (nintendoPfi != null)
{
if (nintendoPfi.Value.DiskCategory == DiskCategory.Nintendo &&
nintendoPfi.Value.PartVersion == 15)
{
dumpLog.WriteLine("Dumping Nintendo GameCube or Wii discs is not yet implemented.");
throw new
NotImplementedException("Dumping Nintendo GameCube or Wii discs is not yet implemented.");
}
}
}
break;
case MediaType.DVDDownload:
case MediaType.DVDPR:
case MediaType.DVDPRDL:
case MediaType.DVDPRW:
case MediaType.DVDPRWDL:
case MediaType.DVDR:
case MediaType.DVDRAM:
case MediaType.DVDRDL:
case MediaType.DVDROM:
case MediaType.DVDRW:
case MediaType.DVDRWDL:
case MediaType.HDDVDR:
case MediaType.HDDVDRAM:
case MediaType.HDDVDRDL:
case MediaType.HDDVDROM:
case MediaType.HDDVDRW:
case MediaType.HDDVDRWDL:
dumpLog.WriteLine("Reading Physical Format Information");
sense = dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.PhysicalInformation, 0, dev.Timeout, out _);
if (!sense)
{
if (PFI.Decode(cmdBuf).HasValue)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVD_PFI, tmpBuf);
PFI.PhysicalFormatInformation decPfi = PFI.Decode(cmdBuf).Value;
DicConsole.WriteLine("PFI:\n{0}", PFI.Prettify(decPfi));
// False book types
if (dskType == MediaType.DVDROM)
{
switch (decPfi.DiskCategory)
{
case DiskCategory.DVDPR:
dskType = MediaType.DVDPR;
break;
case DiskCategory.DVDPRDL:
dskType = MediaType.DVDPRDL;
break;
case DiskCategory.DVDPRW:
dskType = MediaType.DVDPRW;
break;
case DiskCategory.DVDPRWDL:
dskType = MediaType.DVDPRWDL;
break;
case DiskCategory.DVDR:
dskType = decPfi.PartVersion == 6 ? MediaType.DVDRDL : MediaType.DVDR;
break;
case DiskCategory.DVDRAM:
dskType = MediaType.DVDRAM;
break;
default:
dskType = MediaType.DVDROM;
break;
case DiskCategory.DVDRW:
dskType = decPfi.PartVersion == 3 ? MediaType.DVDRWDL : MediaType.DVDRW;
break;
case DiskCategory.HDDVDR:
dskType = MediaType.HDDVDR;
break;
case DiskCategory.HDDVDRAM:
dskType = MediaType.HDDVDRAM;
break;
case DiskCategory.HDDVDROM:
dskType = MediaType.HDDVDROM;
break;
case DiskCategory.HDDVDRW:
dskType = MediaType.HDDVDRW;
break;
case DiskCategory.Nintendo:
dskType = decPfi.DiscSize == DVDSize.Eighty ? MediaType.GOD : MediaType.WOD;
break;
case DiskCategory.UMD:
dskType = MediaType.UMD;
break;
}
}
}
}
dumpLog.WriteLine("Reading Disc Manufacturing Information");
sense = dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.DiscManufacturingInformation, 0, dev.Timeout,
out _);
if (!sense)
{
if (DMI.IsXbox(cmdBuf) || DMI.IsXbox360(cmdBuf))
{
if (DMI.IsXbox(cmdBuf))
{
dskType = MediaType.XGD;
}
else if (DMI.IsXbox360(cmdBuf))
{
dskType = MediaType.XGD2;
// All XGD3 all have the same number of blocks
if (blocks == 25063 || // Locked (or non compatible drive)
blocks == 4229664 || // Xtreme unlock
blocks == 4246304) // Wxripper unlock
{
dskType = MediaType.XGD3;
}
}
sense = dev.ScsiInquiry(out byte[] inqBuf, out _);
if (sense || !Inquiry.Decode(inqBuf).HasValue || Inquiry.Decode(inqBuf).HasValue&&
!Inquiry.Decode(inqBuf).Value.KreonPresent)
{
dumpLog.WriteLine("Dumping Xbox Game Discs requires a drive with Kreon firmware.");
throw new
NotImplementedException("Dumping Xbox Game Discs requires a drive with Kreon firmware.");
}
if (dumpRaw && !force)
{
DicConsole
.ErrorWriteLine("Not continuing. If you want to continue reading cooked data when raw is not available use the force option.");
// TODO: Exit more gracefully
return;
}
isXbox = true;
}
if (cmdBuf.Length == 2052)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVD_DMI, tmpBuf);
}
}
break;
}
#endregion Nintendo
#region All DVD and HD DVD types
#endregion All DVD and HD DVD types
#region DVD-ROM
if (dskType == MediaType.DVDDownload || dskType == MediaType.DVDROM)
{
dumpLog.WriteLine("Reading Lead-in Copyright Information.");
sense = dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.CopyrightInformation, 0, dev.Timeout, out _);
if (!sense)
{
if (CSS_CPRM.DecodeLeadInCopyright(cmdBuf).HasValue)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVD_CMI, tmpBuf);
}
}
}
#endregion DVD-ROM
switch (dskType)
{
#region DVD-ROM and HD DVD-ROM
case MediaType.DVDDownload:
case MediaType.DVDROM:
case MediaType.HDDVDROM:
dumpLog.WriteLine("Reading Burst Cutting Area.");
sense = dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.BurstCuttingArea, 0, dev.Timeout, out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVD_BCA, tmpBuf);
}
break;
#endregion DVD-ROM and HD DVD-ROM
#region DVD-RAM and HD DVD-RAM
case MediaType.DVDRAM:
case MediaType.HDDVDRAM:
dumpLog.WriteLine("Reading Disc Description Structure.");
sense = dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.DvdramDds, 0, dev.Timeout, out _);
if (!sense)
{
if (DDS.Decode(cmdBuf).HasValue)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVDRAM_DDS, tmpBuf);
}
}
dumpLog.WriteLine("Reading Spare Area Information.");
sense = dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.DvdramSpareAreaInformation, 0, dev.Timeout,
out _);
if (!sense)
{
if (Spare.Decode(cmdBuf).HasValue)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVDRAM_SpareArea, tmpBuf);
}
}
break;
#endregion DVD-RAM and HD DVD-RAM
#region DVD-R and DVD-RW
case MediaType.DVDR:
case MediaType.DVDRW:
dumpLog.WriteLine("Reading Pre-Recorded Information.");
sense = dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.PreRecordedInfo, 0, dev.Timeout, out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVDR_PreRecordedInfo, tmpBuf);
}
break;
#endregion DVD-R and DVD-RW
}
switch (dskType)
{
#region DVD-R, DVD-RW and HD DVD-R
case MediaType.DVDR:
case MediaType.DVDRW:
case MediaType.HDDVDR:
dumpLog.WriteLine("Reading Media Identifier.");
sense = dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.DvdrMediaIdentifier, 0, dev.Timeout, out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVDR_MediaIdentifier, tmpBuf);
}
dumpLog.WriteLine("Reading Recordable Physical Information.");
sense = dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.DvdrPhysicalInformation, 0, dev.Timeout,
out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVDR_PFI, tmpBuf);
}
break;
#endregion DVD-R, DVD-RW and HD DVD-R
#region All DVD+
case MediaType.DVDPR:
case MediaType.DVDPRDL:
case MediaType.DVDPRW:
case MediaType.DVDPRWDL:
dumpLog.WriteLine("Reading ADdress In Pregroove.");
sense = dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.Adip, 0, dev.Timeout, out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVD_ADIP, tmpBuf);
}
dumpLog.WriteLine("Reading Disc Control Blocks.");
sense = dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.Dcb, 0, dev.Timeout, out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DCB, tmpBuf);
}
break;
#endregion All DVD+
#region HD DVD-ROM
case MediaType.HDDVDROM:
dumpLog.WriteLine("Reading Lead-in Copyright Information.");
sense = dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.HddvdCopyrightInformation, 0, dev.Timeout,
out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.HDDVD_CPI, tmpBuf);
}
break;
#endregion HD DVD-ROM
#region All Blu-ray
case MediaType.BDR:
case MediaType.BDRE:
case MediaType.BDROM:
case MediaType.BDRXL:
case MediaType.BDREXL:
dumpLog.WriteLine("Reading Disc Information.");
sense = dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Bd, 0, 0,
MmcDiscStructureFormat.DiscInformation, 0, dev.Timeout, out _);
if (!sense)
{
if (DI.Decode(cmdBuf).HasValue)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.BD_DI, tmpBuf);
}
}
// TODO: PAC
/*
* dumpLog.WriteLine("Reading PAC.");
* sense = dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Bd, 0, 0,
* MmcDiscStructureFormat.Pac, 0, dev.Timeout, out _);
* if(!sense)
* {
* tmpBuf = new byte[cmdBuf.Length - 4];
* Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
* mediaTags.Add(MediaTagType.PAC, tmpBuf);
* }*/
break;
#endregion All Blu-ray
}
switch (dskType)
{
#region BD-ROM only
case MediaType.BDROM:
dumpLog.WriteLine("Reading Burst Cutting Area.");
sense = dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Bd, 0, 0,
MmcDiscStructureFormat.BdBurstCuttingArea, 0, dev.Timeout, out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.BD_BCA, tmpBuf);
}
break;
#endregion BD-ROM only
#region Writable Blu-ray only
case MediaType.BDR:
case MediaType.BDRE:
case MediaType.BDRXL:
case MediaType.BDREXL:
dumpLog.WriteLine("Reading Disc Definition Structure.");
sense = dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Bd, 0, 0,
MmcDiscStructureFormat.BdDds, 0, dev.Timeout, out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.BD_DDS, tmpBuf);
}
dumpLog.WriteLine("Reading Spare Area Information.");
sense = dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Bd, 0, 0,
MmcDiscStructureFormat.BdSpareAreaInformation, 0, dev.Timeout, out _);
if (!sense)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.BD_SpareArea, tmpBuf);
}
break;
#endregion Writable Blu-ray only
}
if (isXbox)
{
Xgd.Dump(dev, devicePath, outputPlugin, retryPasses, force, dumpRaw, persistent, stopOnError, mediaTags,
ref dskType, ref resume, ref dumpLog, encoding, outputPrefix, outputPath, formatOptions,
preSidecar, skip, nometadata, notrim);
return;
}
Sbc.Dump(dev, devicePath, outputPlugin, retryPasses, force, dumpRaw, persistent, stopOnError, mediaTags,
ref dskType, true, ref resume, ref dumpLog, encoding, outputPrefix, outputPath, formatOptions,
preSidecar, skip, nometadata, notrim);
}
public static void PrintImageInfo(IMediaImage imageFormat)
{
DicConsole.WriteLine("Image information:");
if (!string.IsNullOrWhiteSpace(imageFormat.Info.Version))
{
DicConsole.WriteLine("Format: {0} version {1}", imageFormat.Format, imageFormat.Info.Version);
}
else
{
DicConsole.WriteLine("Format: {0}", imageFormat.Format);
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.Application) &&
!string.IsNullOrWhiteSpace(imageFormat.Info.ApplicationVersion))
{
DicConsole.WriteLine("Was created with {0} version {1}", imageFormat.Info.Application,
imageFormat.Info.ApplicationVersion);
}
else if (!string.IsNullOrWhiteSpace(imageFormat.Info.Application))
{
DicConsole.WriteLine("Was created with {0}", imageFormat.Info.Application);
}
DicConsole.WriteLine("Image without headers is {0} bytes long", imageFormat.Info.ImageSize);
DicConsole.WriteLine("Contains a media of {0} sectors with a maximum sector size of {1} bytes (if all sectors are of the same size this would be {2} bytes)",
imageFormat.Info.Sectors, imageFormat.Info.SectorSize,
imageFormat.Info.Sectors * imageFormat.Info.SectorSize);
if (!string.IsNullOrWhiteSpace(imageFormat.Info.Creator))
{
DicConsole.WriteLine("Created by: {0}", imageFormat.Info.Creator);
}
if (imageFormat.Info.CreationTime != DateTime.MinValue)
{
DicConsole.WriteLine("Created on {0}", imageFormat.Info.CreationTime);
}
if (imageFormat.Info.LastModificationTime != DateTime.MinValue)
{
DicConsole.WriteLine("Last modified on {0}", imageFormat.Info.LastModificationTime);
}
DicConsole.WriteLine("Contains a media of type {0} and XML type {1}", imageFormat.Info.MediaType,
imageFormat.Info.XmlMediaType);
DicConsole.WriteLine("{0} partitions", imageFormat.Info.HasPartitions ? "Has" : "Doesn't have");
DicConsole.WriteLine("{0} sessions", imageFormat.Info.HasSessions ? "Has" : "Doesn't have");
if (!string.IsNullOrWhiteSpace(imageFormat.Info.Comments))
{
DicConsole.WriteLine("Comments: {0}", imageFormat.Info.Comments);
}
if (imageFormat.Info.MediaSequence != 0 && imageFormat.Info.LastMediaSequence != 0)
{
DicConsole.WriteLine("Media is number {0} on a set of {1} medias", imageFormat.Info.MediaSequence,
imageFormat.Info.LastMediaSequence);
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.MediaTitle))
{
DicConsole.WriteLine("Media title: {0}", imageFormat.Info.MediaTitle);
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.MediaManufacturer))
{
DicConsole.WriteLine("Media manufacturer: {0}", imageFormat.Info.MediaManufacturer);
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.MediaModel))
{
DicConsole.WriteLine("Media model: {0}", imageFormat.Info.MediaModel);
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.MediaSerialNumber))
{
DicConsole.WriteLine("Media serial number: {0}", imageFormat.Info.MediaSerialNumber);
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.MediaBarcode))
{
DicConsole.WriteLine("Media barcode: {0}", imageFormat.Info.MediaBarcode);
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.MediaPartNumber))
{
DicConsole.WriteLine("Media part number: {0}", imageFormat.Info.MediaPartNumber);
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.DriveManufacturer))
{
DicConsole.WriteLine("Drive manufacturer: {0}", imageFormat.Info.DriveManufacturer);
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.DriveModel))
{
DicConsole.WriteLine("Drive model: {0}", imageFormat.Info.DriveModel);
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.DriveSerialNumber))
{
DicConsole.WriteLine("Drive serial number: {0}", imageFormat.Info.DriveSerialNumber);
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.DriveFirmwareRevision))
{
DicConsole.WriteLine("Drive firmware info: {0}", imageFormat.Info.DriveFirmwareRevision);
}
if (imageFormat.Info.Cylinders > 0 && imageFormat.Info.Heads > 0 &&
imageFormat.Info.SectorsPerTrack > 0 &&
imageFormat.Info.XmlMediaType != XmlMediaType.OpticalDisc)
{
DicConsole.WriteLine("Media geometry: {0} cylinders, {1} heads, {2} sectors per track",
imageFormat.Info.Cylinders, imageFormat.Info.Heads,
imageFormat.Info.SectorsPerTrack);
}
if (imageFormat.Info.ReadableMediaTags != null && imageFormat.Info.ReadableMediaTags.Count > 0)
{
DicConsole.WriteLine("Contains {0} readable media tags:", imageFormat.Info.ReadableMediaTags.Count);
foreach (MediaTagType tag in imageFormat.Info.ReadableMediaTags.OrderBy(t => t))
{
DicConsole.Write("{0} ", tag);
}
DicConsole.WriteLine();
}
if (imageFormat.Info.ReadableSectorTags != null && imageFormat.Info.ReadableSectorTags.Count > 0)
{
DicConsole.WriteLine("Contains {0} readable sector tags:", imageFormat.Info.ReadableSectorTags.Count);
foreach (SectorTagType tag in imageFormat.Info.ReadableSectorTags.OrderBy(t => t))
{
DicConsole.Write("{0} ", tag);
}
DicConsole.WriteLine();
}
DicConsole.WriteLine();
PeripheralDeviceTypes scsiDeviceType = PeripheralDeviceTypes.DirectAccess;
byte[] scsiVendorId = null;
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.SCSI_INQUIRY))
{
byte[] inquiry = imageFormat.ReadDiskTag(MediaTagType.SCSI_INQUIRY);
scsiDeviceType = (PeripheralDeviceTypes)(inquiry[0] & 0x1F);
if (inquiry.Length >= 16)
{
scsiVendorId = new byte[8];
Array.Copy(inquiry, 8, scsiVendorId, 0, 8);
}
DicConsole.WriteLine("SCSI INQUIRY contained in image:");
DicConsole.Write("{0}", Inquiry.Prettify(inquiry));
DicConsole.WriteLine();
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.ATA_IDENTIFY))
{
byte[] identify = imageFormat.ReadDiskTag(MediaTagType.ATA_IDENTIFY);
DicConsole.WriteLine("ATA IDENTIFY contained in image:");
DicConsole.Write("{0}", Identify.Prettify(identify));
DicConsole.WriteLine();
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.ATAPI_IDENTIFY))
{
byte[] identify = imageFormat.ReadDiskTag(MediaTagType.ATAPI_IDENTIFY);
DicConsole.WriteLine("ATAPI IDENTIFY contained in image:");
DicConsole.Write("{0}", Identify.Prettify(identify));
DicConsole.WriteLine();
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.SCSI_MODESENSE_10))
{
byte[] modeSense10 = imageFormat.ReadDiskTag(MediaTagType.SCSI_MODESENSE_10);
Modes.DecodedMode?decMode = Modes.DecodeMode10(modeSense10, scsiDeviceType);
if (decMode.HasValue)
{
DicConsole.WriteLine("SCSI MODE SENSE (10) contained in image:");
PrintScsiModePages.Print(decMode.Value, scsiDeviceType, scsiVendorId);
DicConsole.WriteLine();
}
}
else if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.SCSI_MODESENSE_6))
{
byte[] modeSense6 = imageFormat.ReadDiskTag(MediaTagType.SCSI_MODESENSE_6);
Modes.DecodedMode?decMode = Modes.DecodeMode6(modeSense6, scsiDeviceType);
if (decMode.HasValue)
{
DicConsole.WriteLine("SCSI MODE SENSE (6) contained in image:");
PrintScsiModePages.Print(decMode.Value, scsiDeviceType, scsiVendorId);
DicConsole.WriteLine();
}
}
else if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.SCSI_MODEPAGE_2A))
{
byte[] mode2A = imageFormat.ReadDiskTag(MediaTagType.SCSI_MODEPAGE_2A);
DicConsole.Write("{0}", Modes.PrettifyModePage_2A(mode2A));
DicConsole.WriteLine();
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.CD_FullTOC))
{
byte[] toc = imageFormat.ReadDiskTag(MediaTagType.CD_FullTOC);
if (toc.Length > 0)
{
ushort dataLen = Swapping.Swap(BitConverter.ToUInt16(toc, 0));
if (dataLen + 2 != toc.Length)
{
byte[] tmp = new byte[toc.Length + 2];
Array.Copy(toc, 0, tmp, 2, toc.Length);
tmp[0] = (byte)((toc.Length & 0xFF00) >> 8);
tmp[1] = (byte)(toc.Length & 0xFF);
toc = tmp;
}
DicConsole.WriteLine("CompactDisc Table of Contents contained in image:");
DicConsole.Write("{0}", FullTOC.Prettify(toc));
DicConsole.WriteLine();
}
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.CD_PMA))
{
byte[] pma = imageFormat.ReadDiskTag(MediaTagType.CD_PMA);
if (pma.Length > 0)
{
ushort dataLen = Swapping.Swap(BitConverter.ToUInt16(pma, 0));
if (dataLen + 2 != pma.Length)
{
byte[] tmp = new byte[pma.Length + 2];
Array.Copy(pma, 0, tmp, 2, pma.Length);
tmp[0] = (byte)((pma.Length & 0xFF00) >> 8);
tmp[1] = (byte)(pma.Length & 0xFF);
pma = tmp;
}
DicConsole.WriteLine("CompactDisc Power Management Area contained in image:");
DicConsole.Write("{0}", PMA.Prettify(pma));
DicConsole.WriteLine();
}
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.CD_ATIP))
{
byte[] atip = imageFormat.ReadDiskTag(MediaTagType.CD_ATIP);
uint dataLen = Swapping.Swap(BitConverter.ToUInt32(atip, 0));
if (dataLen + 4 != atip.Length)
{
byte[] tmp = new byte[atip.Length + 4];
Array.Copy(atip, 0, tmp, 4, atip.Length);
tmp[0] = (byte)((atip.Length & 0xFF000000) >> 24);
tmp[1] = (byte)((atip.Length & 0xFF0000) >> 16);
tmp[2] = (byte)((atip.Length & 0xFF00) >> 8);
tmp[3] = (byte)(atip.Length & 0xFF);
atip = tmp;
}
DicConsole.WriteLine("CompactDisc Absolute Time In Pregroove (ATIP) contained in image:");
DicConsole.Write("{0}", ATIP.Prettify(atip));
DicConsole.WriteLine();
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.CD_TEXT))
{
byte[] cdtext = imageFormat.ReadDiskTag(MediaTagType.CD_TEXT);
uint dataLen = Swapping.Swap(BitConverter.ToUInt32(cdtext, 0));
if (dataLen + 4 != cdtext.Length)
{
byte[] tmp = new byte[cdtext.Length + 4];
Array.Copy(cdtext, 0, tmp, 4, cdtext.Length);
tmp[0] = (byte)((cdtext.Length & 0xFF000000) >> 24);
tmp[1] = (byte)((cdtext.Length & 0xFF0000) >> 16);
tmp[2] = (byte)((cdtext.Length & 0xFF00) >> 8);
tmp[3] = (byte)(cdtext.Length & 0xFF);
cdtext = tmp;
}
DicConsole.WriteLine("CompactDisc Lead-in's CD-Text contained in image:");
DicConsole.Write("{0}", CDTextOnLeadIn.Prettify(cdtext));
DicConsole.WriteLine();
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.CD_MCN))
{
byte[] mcn = imageFormat.ReadDiskTag(MediaTagType.CD_MCN);
DicConsole.WriteLine("CompactDisc Media Catalogue Number contained in image: {0}",
Encoding.UTF8.GetString(mcn));
DicConsole.WriteLine();
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVD_PFI))
{
byte[] pfi = imageFormat.ReadDiskTag(MediaTagType.DVD_PFI);
DicConsole.WriteLine("DVD Physical Format Information contained in image:");
DicConsole.Write("{0}", PFI.Prettify(pfi));
DicConsole.WriteLine();
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVDRAM_DDS))
{
byte[] dds = imageFormat.ReadDiskTag(MediaTagType.DVDRAM_DDS);
DicConsole.WriteLine("DVD-RAM Disc Definition Structure contained in image:");
DicConsole.Write("{0}", DDS.Prettify(dds));
DicConsole.WriteLine();
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVDR_PFI))
{
byte[] pfi = imageFormat.ReadDiskTag(MediaTagType.DVDR_PFI);
DicConsole.WriteLine("DVD-R Physical Format Information contained in image:");
DicConsole.Write("{0}", PFI.Prettify(pfi));
DicConsole.WriteLine();
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.BD_DI))
{
byte[] di = imageFormat.ReadDiskTag(MediaTagType.BD_DI);
DicConsole.WriteLine("Bluray Disc Information contained in image:");
DicConsole.Write("{0}", DI.Prettify(di));
DicConsole.WriteLine();
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.BD_DDS))
{
byte[] dds = imageFormat.ReadDiskTag(MediaTagType.BD_DDS);
DicConsole.WriteLine("Bluray Disc Definition Structure contained in image:");
DicConsole.Write("{0}", Decoders.Bluray.DDS.Prettify(dds));
DicConsole.WriteLine();
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.PCMCIA_CIS))
{
byte[] cis = imageFormat.ReadDiskTag(MediaTagType.PCMCIA_CIS);
DicConsole.WriteLine("PCMCIA CIS:");
Tuple[] tuples = CIS.GetTuples(cis);
if (tuples != null)
{
foreach (Tuple tuple in tuples)
{
switch (tuple.Code)
{
case TupleCodes.CISTPL_NULL:
case TupleCodes.CISTPL_END: break;
case TupleCodes.CISTPL_DEVICEGEO:
case TupleCodes.CISTPL_DEVICEGEO_A:
DicConsole.WriteLine("{0}", CIS.PrettifyDeviceGeometryTuple(tuple));
break;
case TupleCodes.CISTPL_MANFID:
DicConsole.WriteLine("{0}", CIS.PrettifyManufacturerIdentificationTuple(tuple));
break;
case TupleCodes.CISTPL_VERS_1:
DicConsole.WriteLine("{0}", CIS.PrettifyLevel1VersionTuple(tuple));
break;
case TupleCodes.CISTPL_ALTSTR:
case TupleCodes.CISTPL_BAR:
case TupleCodes.CISTPL_BATTERY:
case TupleCodes.CISTPL_BYTEORDER:
case TupleCodes.CISTPL_CFTABLE_ENTRY:
case TupleCodes.CISTPL_CFTABLE_ENTRY_CB:
case TupleCodes.CISTPL_CHECKSUM:
case TupleCodes.CISTPL_CONFIG:
case TupleCodes.CISTPL_CONFIG_CB:
case TupleCodes.CISTPL_DATE:
case TupleCodes.CISTPL_DEVICE:
case TupleCodes.CISTPL_DEVICE_A:
case TupleCodes.CISTPL_DEVICE_OA:
case TupleCodes.CISTPL_DEVICE_OC:
case TupleCodes.CISTPL_EXTDEVIC:
case TupleCodes.CISTPL_FORMAT:
case TupleCodes.CISTPL_FORMAT_A:
case TupleCodes.CISTPL_FUNCE:
case TupleCodes.CISTPL_FUNCID:
case TupleCodes.CISTPL_GEOMETRY:
case TupleCodes.CISTPL_INDIRECT:
case TupleCodes.CISTPL_JEDEC_A:
case TupleCodes.CISTPL_JEDEC_C:
case TupleCodes.CISTPL_LINKTARGET:
case TupleCodes.CISTPL_LONGLINK_A:
case TupleCodes.CISTPL_LONGLINK_C:
case TupleCodes.CISTPL_LONGLINK_CB:
case TupleCodes.CISTPL_LONGLINK_MFC:
case TupleCodes.CISTPL_NO_LINK:
case TupleCodes.CISTPL_ORG:
case TupleCodes.CISTPL_PWR_MGMNT:
case TupleCodes.CISTPL_SPCL:
case TupleCodes.CISTPL_SWIL:
case TupleCodes.CISTPL_VERS_2:
DicConsole.DebugWriteLine("Device-Info command", "Found undecoded tuple ID {0}",
tuple.Code);
break;
default:
DicConsole.DebugWriteLine("Device-Info command", "Found unknown tuple ID 0x{0:X2}",
(byte)tuple.Code);
break;
}
}
}
else
{
DicConsole.DebugWriteLine("Device-Info command", "Could not get tuples");
}
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.SD_CID))
{
byte[] cid = imageFormat.ReadDiskTag(MediaTagType.SD_CID);
DicConsole.WriteLine("SecureDigital CID contained in image:");
DicConsole.Write("{0}", Decoders.SecureDigital.Decoders.PrettifyCID(cid));
DicConsole.WriteLine();
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.SD_CSD))
{
byte[] csd = imageFormat.ReadDiskTag(MediaTagType.SD_CSD);
DicConsole.WriteLine("SecureDigital CSD contained in image:");
DicConsole.Write("{0}", Decoders.SecureDigital.Decoders.PrettifyCSD(csd));
DicConsole.WriteLine();
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.SD_SCR))
{
byte[] scr = imageFormat.ReadDiskTag(MediaTagType.SD_SCR);
DicConsole.WriteLine("SecureDigital SCR contained in image:");
DicConsole.Write("{0}", Decoders.SecureDigital.Decoders.PrettifySCR(scr));
DicConsole.WriteLine();
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.SD_OCR))
{
byte[] ocr = imageFormat.ReadDiskTag(MediaTagType.SD_OCR);
DicConsole.WriteLine("SecureDigital OCR contained in image:");
DicConsole.Write("{0}", Decoders.SecureDigital.Decoders.PrettifyOCR(ocr));
DicConsole.WriteLine();
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.MMC_CID))
{
byte[] cid = imageFormat.ReadDiskTag(MediaTagType.MMC_CID);
DicConsole.WriteLine("MultiMediaCard CID contained in image:");
DicConsole.Write("{0}", Decoders.MMC.Decoders.PrettifyCID(cid));
DicConsole.WriteLine();
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.MMC_CSD))
{
byte[] csd = imageFormat.ReadDiskTag(MediaTagType.MMC_CSD);
DicConsole.WriteLine("MultiMediaCard CSD contained in image:");
DicConsole.Write("{0}", Decoders.MMC.Decoders.PrettifyCSD(csd));
DicConsole.WriteLine();
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.MMC_ExtendedCSD))
{
byte[] ecsd = imageFormat.ReadDiskTag(MediaTagType.MMC_ExtendedCSD);
DicConsole.WriteLine("MultiMediaCard ExtendedCSD contained in image:");
DicConsole.Write("{0}", Decoders.MMC.Decoders.PrettifyExtendedCSD(ecsd));
DicConsole.WriteLine();
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.MMC_OCR))
{
byte[] ocr = imageFormat.ReadDiskTag(MediaTagType.MMC_OCR);
DicConsole.WriteLine("MultiMediaCard OCR contained in image:");
DicConsole.Write("{0}", Decoders.MMC.Decoders.PrettifyOCR(ocr));
DicConsole.WriteLine();
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.Xbox_PFI))
{
byte[] xpfi = imageFormat.ReadDiskTag(MediaTagType.Xbox_PFI);
DicConsole.WriteLine("Xbox Physical Format Information contained in image:");
DicConsole.Write("{0}", PFI.Prettify(xpfi));
DicConsole.WriteLine();
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.Xbox_DMI))
{
byte[] xdmi = imageFormat.ReadDiskTag(MediaTagType.Xbox_DMI);
if (DMI.IsXbox(xdmi))
{
DMI.XboxDMI?xmi = DMI.DecodeXbox(xdmi);
if (xmi.HasValue)
{
DicConsole.WriteLine("Xbox DMI contained in image:");
DicConsole.Write("{0}", DMI.PrettifyXbox(xmi));
DicConsole.WriteLine();
}
}
if (DMI.IsXbox360(xdmi))
{
DMI.Xbox360DMI?xmi = DMI.DecodeXbox360(xdmi);
if (xmi.HasValue)
{
DicConsole.WriteLine("Xbox 360 DMI contained in image:");
DicConsole.Write("{0}", DMI.PrettifyXbox360(xmi));
DicConsole.WriteLine();
}
}
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.Xbox_SecuritySector))
{
byte[] toc = imageFormat.ReadDiskTag(MediaTagType.Xbox_SecuritySector);
DicConsole.WriteLine("Xbox Security Sectors contained in image:");
DicConsole.Write("{0}", SS.Prettify(toc));
DicConsole.WriteLine();
}
try
{
if (imageFormat.Sessions != null && imageFormat.Sessions.Count > 0)
{
DicConsole.WriteLine("Image sessions:");
DicConsole.WriteLine("{0,-9}{1,-13}{2,-12}{3,-12}{4,-12}", "Session", "First track", "Last track",
"Start", "End");
DicConsole.WriteLine("=========================================================");
foreach (Session session in imageFormat.Sessions)
{
DicConsole.WriteLine("{0,-9}{1,-13}{2,-12}{3,-12}{4,-12}", session.SessionSequence,
session.StartTrack, session.EndTrack, session.StartSector,
session.EndSector);
}
DicConsole.WriteLine();
}
}
catch
{
// ignored
}
try
{
if (imageFormat.Tracks != null && imageFormat.Tracks.Count > 0)
{
DicConsole.WriteLine("Image tracks:");
DicConsole.WriteLine("{0,-7}{1,-17}{2,-6}{3,-8}{4,-12}{5,-8}{6,-12}{7,-12}", "Track", "Type", "Bps",
"Raw bps", "Subchannel", "Pregap", "Start", "End");
DicConsole
.WriteLine("=================================================================================");
foreach (Track track in imageFormat.Tracks)
{
DicConsole.WriteLine("{0,-7}{1,-17}{2,-6}{3,-8}{4,-12}{5,-8}{6,-12}{7,-12}",
track.TrackSequence, track.TrackType, track.TrackBytesPerSector,
track.TrackRawBytesPerSector, track.TrackSubchannelType, track.TrackPregap,
track.TrackStartSector, track.TrackEndSector);
}
DicConsole.WriteLine();
}
}
catch
{
// ignored
}
if (imageFormat.DumpHardware == null)
{
return;
}
const string MANUFACTURER_STRING = "Manufacturer";
const string MODEL_STRING = "Model";
const string SERIAL_STRING = "Serial";
const string SOFTWARE_STRING = "Software";
const string VERSION_STRING = "Version";
const string OS_STRING = "Operating system";
const string START_STRING = "Start";
const string END_STRING = "End";
int manufacturerLen = MANUFACTURER_STRING.Length;
int modelLen = MODEL_STRING.Length;
int serialLen = SERIAL_STRING.Length;
int softwareLen = SOFTWARE_STRING.Length;
int versionLen = VERSION_STRING.Length;
int osLen = OS_STRING.Length;
int sectorLen = START_STRING.Length;
foreach (DumpHardwareType dump in imageFormat.DumpHardware)
{
if (dump.Manufacturer?.Length > manufacturerLen)
{
manufacturerLen = dump.Manufacturer.Length;
}
if (dump.Model?.Length > modelLen)
{
modelLen = dump.Model.Length;
}
if (dump.Serial?.Length > serialLen)
{
serialLen = dump.Serial.Length;
}
if (dump.Software?.Name?.Length > softwareLen)
{
softwareLen = dump.Software.Name.Length;
}
if (dump.Software?.Version?.Length > versionLen)
{
versionLen = dump.Software.Version.Length;
}
if (dump.Software?.OperatingSystem?.Length > osLen)
{
osLen = dump.Software.OperatingSystem.Length;
}
foreach (ExtentType extent in dump.Extents)
{
if ($"{extent.Start}".Length > sectorLen)
{
sectorLen = $"{extent.Start}".Length;
}
if ($"{extent.End}".Length > sectorLen)
{
sectorLen = $"{extent.End}".Length;
}
}
}
manufacturerLen += 2;
modelLen += 2;
serialLen += 2;
softwareLen += 2;
versionLen += 2;
osLen += 2;
sectorLen += 2;
sectorLen += 2;
char[] separator = new char[manufacturerLen + modelLen + serialLen + softwareLen + versionLen + osLen +
sectorLen + sectorLen];
for (int i = 0; i < separator.Length; i++)
{
separator[i] = '=';
}
string format =
$"{{0,-{manufacturerLen}}}{{1,-{modelLen}}}{{2,-{serialLen}}}{{3,-{softwareLen}}}{{4,-{versionLen}}}{{5,-{osLen}}}{{6,-{sectorLen}}}{{7,-{sectorLen}}}";
DicConsole.WriteLine("Dump hardware information:");
DicConsole.WriteLine(format, MANUFACTURER_STRING, MODEL_STRING, SERIAL_STRING, SOFTWARE_STRING,
VERSION_STRING, OS_STRING, START_STRING, END_STRING);
DicConsole.WriteLine(new string(separator));
foreach (DumpHardwareType dump in imageFormat.DumpHardware)
{
foreach (ExtentType extent in dump.Extents)
{
DicConsole.WriteLine(format, dump.Manufacturer, dump.Model, dump.Serial, dump.Software.Name,
dump.Software.Version, dump.Software.OperatingSystem, extent.Start,
extent.End);
}
}
DicConsole.WriteLine();
}
public ImageInfoViewModel(string imagePath, IFilter filter, IMediaImage imageFormat, Window view)
{
_imagePath = imagePath;
_filter = filter;
_imageFormat = imageFormat;
_view = view;
IAssetLoader assets = AvaloniaLocator.Current.GetService <IAssetLoader>();
MediaTagsList = new ObservableCollection <string>();
SectorTagsList = new ObservableCollection <string>();
Sessions = new ObservableCollection <Session>();
Tracks = new ObservableCollection <Track>();
DumpHardwareList = new ObservableCollection <DumpHardwareModel>();
EntropyCommand = ReactiveCommand.Create(ExecuteEntropyCommand);
VerifyCommand = ReactiveCommand.Create(ExecuteVerifyCommand);
ChecksumCommand = ReactiveCommand.Create(ExecuteChecksumCommand);
ConvertCommand = ReactiveCommand.Create(ExecuteConvertCommand);
CreateSidecarCommand = ReactiveCommand.Create(ExecuteCreateSidecarCommand);
ViewSectorsCommand = ReactiveCommand.Create(ExecuteViewSectorsCommand);
DecodeMediaTagCommand = ReactiveCommand.Create(ExecuteDecodeMediaTagCommand);
var genericHddIcon =
new Bitmap(assets.Open(new Uri("avares://Aaru.Gui/Assets/Icons/oxygen/32x32/drive-harddisk.png")));
var genericOpticalIcon =
new Bitmap(assets.Open(new Uri("avares://Aaru.Gui/Assets/Icons/oxygen/32x32/drive-optical.png")));
var genericFolderIcon =
new Bitmap(assets.Open(new Uri("avares://Aaru.Gui/Assets/Icons/oxygen/32x32/inode-directory.png")));
var mediaResource = new Uri($"avares://Aaru.Gui/Assets/Logos/Media/{imageFormat.Info.MediaType}.png");
MediaLogo = assets.Exists(mediaResource)
? new Bitmap(assets.Open(mediaResource))
: imageFormat.Info.XmlMediaType == XmlMediaType.BlockMedia
? genericHddIcon
: imageFormat.Info.XmlMediaType == XmlMediaType.OpticalDisc
? genericOpticalIcon
: genericFolderIcon;
ImagePathText = $"Path: {imagePath}";
FilterText = $"Filter: {filter.Name}";
ImageIdentifiedText = $"Image format identified by {imageFormat.Name} ({imageFormat.Id}).";
ImageFormatText = !string.IsNullOrWhiteSpace(imageFormat.Info.Version)
? $"Format: {imageFormat.Format} version {imageFormat.Info.Version}"
: $"Format: {imageFormat.Format}";
ImageSizeText = $"Image without headers is {imageFormat.Info.ImageSize} bytes long";
SectorsText =
$"Contains a media of {imageFormat.Info.Sectors} sectors with a maximum sector size of {imageFormat.Info.SectorSize} bytes (if all sectors are of the same size this would be {imageFormat.Info.Sectors * imageFormat.Info.SectorSize} bytes)";
MediaTypeText =
$"Contains a media of type {imageFormat.Info.MediaType} and XML type {imageFormat.Info.XmlMediaType}";
HasPartitionsText = $"{(imageFormat.Info.HasPartitions ? "Has" : "Doesn't have")} partitions";
HasSessionsText = $"{(imageFormat.Info.HasSessions ? "Has" : "Doesn't have")} sessions";
if (!string.IsNullOrWhiteSpace(imageFormat.Info.Application))
{
ApplicationText = !string.IsNullOrWhiteSpace(imageFormat.Info.ApplicationVersion)
? $"Was created with {imageFormat.Info.Application} version {imageFormat.Info.ApplicationVersion}"
: $"Was created with {imageFormat.Info.Application}";
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.Creator))
{
CreatorText = $"Created by: {imageFormat.Info.Creator}";
}
if (imageFormat.Info.CreationTime != DateTime.MinValue)
{
CreationTimeText = $"Created on {imageFormat.Info.CreationTime}";
}
if (imageFormat.Info.LastModificationTime != DateTime.MinValue)
{
LastModificationTimeText = $"Last modified on {imageFormat.Info.LastModificationTime}";
}
if (imageFormat.Info.MediaSequence != 0 &&
imageFormat.Info.LastMediaSequence != 0)
{
MediaSequenceText =
$"Media is number {imageFormat.Info.MediaSequence} on a set of {imageFormat.Info.LastMediaSequence} medias";
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.MediaTitle))
{
MediaTitleText = $"Media title: {imageFormat.Info.MediaTitle}";
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.MediaManufacturer))
{
MediaManufacturerText = $"Media manufacturer: {imageFormat.Info.MediaManufacturer}";
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.MediaModel))
{
MediaModelText = $"Media model: {imageFormat.Info.MediaModel}";
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.MediaSerialNumber))
{
MediaSerialNumberText = $"Media serial number: {imageFormat.Info.MediaSerialNumber}";
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.MediaBarcode))
{
MediaBarcodeText = $"Media barcode: {imageFormat.Info.MediaBarcode}";
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.MediaPartNumber))
{
MediaPartNumberText = $"Media part number: {imageFormat.Info.MediaPartNumber}";
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.DriveManufacturer))
{
DriveManufacturerText = $"Drive manufacturer: {imageFormat.Info.DriveManufacturer}";
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.DriveModel))
{
DriveModelText = $"Drive model: {imageFormat.Info.DriveModel}";
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.DriveSerialNumber))
{
DriveSerialNumberText = $"Drive serial number: {imageFormat.Info.DriveSerialNumber}";
}
if (!string.IsNullOrWhiteSpace(imageFormat.Info.DriveFirmwareRevision))
{
DriveFirmwareRevisionText = $"Drive firmware info: {imageFormat.Info.DriveFirmwareRevision}";
}
if (imageFormat.Info.Cylinders > 0 &&
imageFormat.Info.Heads > 0 &&
imageFormat.Info.SectorsPerTrack > 0 &&
imageFormat.Info.XmlMediaType != XmlMediaType.OpticalDisc &&
(!(imageFormat is ITapeImage tapeImage) || !tapeImage.IsTape))
{
MediaGeometryText =
$"Media geometry: {imageFormat.Info.Cylinders} cylinders, {imageFormat.Info.Heads} heads, {imageFormat.Info.SectorsPerTrack} sectors per track";
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Count > 0)
{
foreach (MediaTagType tag in imageFormat.Info.ReadableMediaTags.OrderBy(t => t))
{
MediaTagsList.Add(tag.ToString());
}
}
if (imageFormat.Info.ReadableSectorTags != null &&
imageFormat.Info.ReadableSectorTags.Count > 0)
{
foreach (SectorTagType tag in imageFormat.Info.ReadableSectorTags.OrderBy(t => t))
{
SectorTagsList.Add(tag.ToString());
}
}
PeripheralDeviceTypes scsiDeviceType = PeripheralDeviceTypes.DirectAccess;
byte[] scsiInquiryData = null;
Inquiry?scsiInquiry = null;
Modes.DecodedMode?scsiMode = null;
byte[] scsiModeSense6 = null;
byte[] scsiModeSense10 = null;
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.SCSI_INQUIRY))
{
scsiInquiryData = imageFormat.ReadDiskTag(MediaTagType.SCSI_INQUIRY);
scsiDeviceType = (PeripheralDeviceTypes)(scsiInquiryData[0] & 0x1F);
scsiInquiry = Inquiry.Decode(scsiInquiryData);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.SCSI_MODESENSE_6))
{
scsiModeSense6 = imageFormat.ReadDiskTag(MediaTagType.SCSI_MODESENSE_6);
scsiMode = Modes.DecodeMode6(scsiModeSense6, scsiDeviceType);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.SCSI_MODESENSE_10))
{
scsiModeSense10 = imageFormat.ReadDiskTag(MediaTagType.SCSI_MODESENSE_10);
scsiMode = Modes.DecodeMode10(scsiModeSense10, scsiDeviceType);
}
ScsiInfo = new ScsiInfo
{
DataContext = new ScsiInfoViewModel(scsiInquiryData, scsiInquiry, null, scsiMode, scsiDeviceType,
scsiModeSense6, scsiModeSense10, null, _view)
};
byte[] ataIdentify = null;
byte[] atapiIdentify = null;
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.ATA_IDENTIFY))
{
ataIdentify = imageFormat.ReadDiskTag(MediaTagType.ATA_IDENTIFY);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.ATAPI_IDENTIFY))
{
atapiIdentify = imageFormat.ReadDiskTag(MediaTagType.ATAPI_IDENTIFY);
}
AtaInfo = new AtaInfo
{
DataContext = new AtaInfoViewModel(ataIdentify, atapiIdentify, null, _view)
};
byte[] toc = null;
TOC.CDTOC? decodedToc = null;
byte[] fullToc = null;
FullTOC.CDFullTOC? decodedFullToc = null;
byte[] pma = null;
byte[] atip = null;
ATIP.CDATIP? decodedAtip = null;
byte[] cdtext = null;
CDTextOnLeadIn.CDText?decodedCdText = null;
string mediaCatalogueNumber = null;
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.CD_TOC))
{
toc = imageFormat.ReadDiskTag(MediaTagType.CD_TOC);
if (toc.Length > 0)
{
ushort dataLen = Swapping.Swap(BitConverter.ToUInt16(toc, 0));
if (dataLen + 2 != toc.Length)
{
byte[] tmp = new byte[toc.Length + 2];
Array.Copy(toc, 0, tmp, 2, toc.Length);
tmp[0] = (byte)((toc.Length & 0xFF00) >> 8);
tmp[1] = (byte)(toc.Length & 0xFF);
toc = tmp;
}
decodedToc = TOC.Decode(toc);
}
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.CD_FullTOC))
{
fullToc = imageFormat.ReadDiskTag(MediaTagType.CD_FullTOC);
if (fullToc.Length > 0)
{
ushort dataLen = Swapping.Swap(BitConverter.ToUInt16(fullToc, 0));
if (dataLen + 2 != fullToc.Length)
{
byte[] tmp = new byte[fullToc.Length + 2];
Array.Copy(fullToc, 0, tmp, 2, fullToc.Length);
tmp[0] = (byte)((fullToc.Length & 0xFF00) >> 8);
tmp[1] = (byte)(fullToc.Length & 0xFF);
fullToc = tmp;
}
decodedFullToc = FullTOC.Decode(fullToc);
}
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.CD_PMA))
{
pma = imageFormat.ReadDiskTag(MediaTagType.CD_PMA);
if (pma.Length > 0)
{
ushort dataLen = Swapping.Swap(BitConverter.ToUInt16(pma, 0));
if (dataLen + 2 != pma.Length)
{
byte[] tmp = new byte[pma.Length + 2];
Array.Copy(pma, 0, tmp, 2, pma.Length);
tmp[0] = (byte)((pma.Length & 0xFF00) >> 8);
tmp[1] = (byte)(pma.Length & 0xFF);
pma = tmp;
}
}
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.CD_ATIP))
{
atip = imageFormat.ReadDiskTag(MediaTagType.CD_ATIP);
uint dataLen = Swapping.Swap(BitConverter.ToUInt32(atip, 0));
if (dataLen + 4 != atip.Length)
{
byte[] tmp = new byte[atip.Length + 4];
Array.Copy(atip, 0, tmp, 4, atip.Length);
tmp[0] = (byte)((atip.Length & 0xFF000000) >> 24);
tmp[1] = (byte)((atip.Length & 0xFF0000) >> 16);
tmp[2] = (byte)((atip.Length & 0xFF00) >> 8);
tmp[3] = (byte)(atip.Length & 0xFF);
atip = tmp;
}
decodedAtip = ATIP.Decode(atip);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.CD_TEXT))
{
cdtext = imageFormat.ReadDiskTag(MediaTagType.CD_TEXT);
uint dataLen = Swapping.Swap(BitConverter.ToUInt32(cdtext, 0));
if (dataLen + 4 != cdtext.Length)
{
byte[] tmp = new byte[cdtext.Length + 4];
Array.Copy(cdtext, 0, tmp, 4, cdtext.Length);
tmp[0] = (byte)((cdtext.Length & 0xFF000000) >> 24);
tmp[1] = (byte)((cdtext.Length & 0xFF0000) >> 16);
tmp[2] = (byte)((cdtext.Length & 0xFF00) >> 8);
tmp[3] = (byte)(cdtext.Length & 0xFF);
cdtext = tmp;
}
decodedCdText = CDTextOnLeadIn.Decode(cdtext);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.CD_MCN))
{
byte[] mcn = imageFormat.ReadDiskTag(MediaTagType.CD_MCN);
mediaCatalogueNumber = Encoding.UTF8.GetString(mcn);
}
CompactDiscInfo = new CompactDiscInfo
{
DataContext = new CompactDiscInfoViewModel(toc, atip, null, null, fullToc, pma, cdtext, decodedToc,
decodedAtip, null, decodedFullToc, decodedCdText, null,
mediaCatalogueNumber, null, _view)
};
byte[] dvdPfi = null;
byte[] dvdDmi = null;
byte[] dvdCmi = null;
byte[] hddvdCopyrightInformation = null;
byte[] dvdBca = null;
PFI.PhysicalFormatInformation?decodedPfi = null;
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVD_PFI))
{
dvdPfi = imageFormat.ReadDiskTag(MediaTagType.DVD_PFI);
decodedPfi = PFI.Decode(dvdPfi);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVD_DMI))
{
dvdDmi = imageFormat.ReadDiskTag(MediaTagType.DVD_DMI);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVD_CMI))
{
dvdCmi = imageFormat.ReadDiskTag(MediaTagType.DVD_CMI);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.HDDVD_CPI))
{
hddvdCopyrightInformation = imageFormat.ReadDiskTag(MediaTagType.HDDVD_CPI);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVD_BCA))
{
dvdBca = imageFormat.ReadDiskTag(MediaTagType.DVD_BCA);
}
DvdInfo = new DvdInfo
{
DataContext = new DvdInfoViewModel(imageFormat.Info.MediaType, dvdPfi, dvdDmi, dvdCmi,
hddvdCopyrightInformation, dvdBca, null, decodedPfi, _view)
};
byte[] dvdRamDds = null;
byte[] dvdRamCartridgeStatus = null;
byte[] dvdRamSpareArea = null;
byte[] lastBorderOutRmd = null;
byte[] dvdPreRecordedInfo = null;
byte[] dvdrMediaIdentifier = null;
byte[] dvdrPhysicalInformation = null;
byte[] hddvdrMediumStatus = null;
byte[] dvdrLayerCapacity = null;
byte[] dvdrDlMiddleZoneStart = null;
byte[] dvdrDlJumpIntervalSize = null;
byte[] dvdrDlManualLayerJumpStartLba = null;
byte[] dvdPlusAdip = null;
byte[] dvdPlusDcb = null;
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVDRAM_DDS))
{
dvdRamDds = imageFormat.ReadDiskTag(MediaTagType.DVDRAM_DDS);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVDRAM_MediumStatus))
{
dvdRamCartridgeStatus = imageFormat.ReadDiskTag(MediaTagType.DVDRAM_MediumStatus);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVDRAM_SpareArea))
{
dvdRamSpareArea = imageFormat.ReadDiskTag(MediaTagType.DVDRAM_SpareArea);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVDR_RMD))
{
lastBorderOutRmd = imageFormat.ReadDiskTag(MediaTagType.DVDR_RMD);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVDR_PreRecordedInfo))
{
dvdPreRecordedInfo = imageFormat.ReadDiskTag(MediaTagType.DVDR_PreRecordedInfo);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVDR_MediaIdentifier))
{
dvdrMediaIdentifier = imageFormat.ReadDiskTag(MediaTagType.DVDR_MediaIdentifier);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVDR_PFI))
{
dvdrPhysicalInformation = imageFormat.ReadDiskTag(MediaTagType.DVDR_PFI);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.HDDVD_MediumStatus))
{
hddvdrMediumStatus = imageFormat.ReadDiskTag(MediaTagType.HDDVD_MediumStatus);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVDDL_LayerCapacity))
{
dvdrLayerCapacity = imageFormat.ReadDiskTag(MediaTagType.DVDDL_LayerCapacity);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVDDL_MiddleZoneAddress))
{
dvdrDlMiddleZoneStart = imageFormat.ReadDiskTag(MediaTagType.DVDDL_MiddleZoneAddress);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVDDL_JumpIntervalSize))
{
dvdrDlJumpIntervalSize = imageFormat.ReadDiskTag(MediaTagType.DVDDL_JumpIntervalSize);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVDDL_ManualLayerJumpLBA))
{
dvdrDlManualLayerJumpStartLba = imageFormat.ReadDiskTag(MediaTagType.DVDDL_ManualLayerJumpLBA);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DVD_ADIP))
{
dvdPlusAdip = imageFormat.ReadDiskTag(MediaTagType.DVD_ADIP);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.DCB))
{
dvdPlusDcb = imageFormat.ReadDiskTag(MediaTagType.DCB);
}
DvdWritableInfo = new DvdWritableInfo
{
DataContext = new DvdWritableInfoViewModel(imageFormat.Info.MediaType, dvdRamDds, dvdRamCartridgeStatus,
dvdRamSpareArea, lastBorderOutRmd, dvdPreRecordedInfo,
dvdrMediaIdentifier, dvdrPhysicalInformation,
hddvdrMediumStatus, null, dvdrLayerCapacity,
dvdrDlMiddleZoneStart, dvdrDlJumpIntervalSize,
dvdrDlManualLayerJumpStartLba, null, dvdPlusAdip, dvdPlusDcb,
_view)
};
byte[] blurayBurstCuttingArea = null;
byte[] blurayCartridgeStatus = null;
byte[] blurayDds = null;
byte[] blurayDiscInformation = null;
byte[] blurayPowResources = null;
byte[] bluraySpareAreaInformation = null;
byte[] blurayTrackResources = null;
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.BD_BCA))
{
blurayBurstCuttingArea = imageFormat.ReadDiskTag(MediaTagType.BD_BCA);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.BD_CartridgeStatus))
{
blurayCartridgeStatus = imageFormat.ReadDiskTag(MediaTagType.BD_CartridgeStatus);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.BD_DDS))
{
blurayDds = imageFormat.ReadDiskTag(MediaTagType.BD_DDS);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.BD_DI))
{
blurayDiscInformation = imageFormat.ReadDiskTag(MediaTagType.BD_DI);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.MMC_POWResourcesInformation))
{
blurayPowResources = imageFormat.ReadDiskTag(MediaTagType.MMC_POWResourcesInformation);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.BD_SpareArea))
{
bluraySpareAreaInformation = imageFormat.ReadDiskTag(MediaTagType.BD_SpareArea);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.MMC_TrackResourcesInformation))
{
bluraySpareAreaInformation = imageFormat.ReadDiskTag(MediaTagType.MMC_TrackResourcesInformation);
}
BlurayInfo = new BlurayInfo
{
DataContext = new BlurayInfoViewModel(blurayDiscInformation, blurayBurstCuttingArea, blurayDds,
blurayCartridgeStatus, bluraySpareAreaInformation,
blurayPowResources, blurayTrackResources, null, null, _view)
};
byte[] xboxDmi = null;
byte[] xboxSecuritySector = null;
SS.SecuritySector?decodedXboxSecuritySector = null;
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.Xbox_DMI))
{
xboxDmi = imageFormat.ReadDiskTag(MediaTagType.Xbox_DMI);
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.Xbox_SecuritySector))
{
xboxSecuritySector = imageFormat.ReadDiskTag(MediaTagType.Xbox_SecuritySector);
decodedXboxSecuritySector = SS.Decode(xboxSecuritySector);
}
XboxInfo = new XboxInfo
{
DataContext = new XboxInfoViewModel(null, xboxDmi, xboxSecuritySector, decodedXboxSecuritySector, _view)
};
byte[] pcmciaCis = null;
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.PCMCIA_CIS))
{
pcmciaCis = imageFormat.ReadDiskTag(MediaTagType.PCMCIA_CIS);
}
PcmciaInfo = new PcmciaInfo
{
DataContext = new PcmciaInfoViewModel(pcmciaCis, _view)
};
DeviceType deviceType = DeviceType.Unknown;
byte[] cid = null;
byte[] csd = null;
byte[] ocr = null;
byte[] extendedCsd = null;
byte[] scr = null;
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.SD_CID))
{
cid = imageFormat.ReadDiskTag(MediaTagType.SD_CID);
deviceType = DeviceType.SecureDigital;
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.SD_CSD))
{
csd = imageFormat.ReadDiskTag(MediaTagType.SD_CSD);
deviceType = DeviceType.SecureDigital;
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.SD_OCR))
{
ocr = imageFormat.ReadDiskTag(MediaTagType.SD_OCR);
deviceType = DeviceType.SecureDigital;
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.SD_SCR))
{
scr = imageFormat.ReadDiskTag(MediaTagType.SD_SCR);
deviceType = DeviceType.SecureDigital;
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.MMC_CID))
{
cid = imageFormat.ReadDiskTag(MediaTagType.MMC_CID);
deviceType = DeviceType.MMC;
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.MMC_CSD))
{
csd = imageFormat.ReadDiskTag(MediaTagType.MMC_CSD);
deviceType = DeviceType.MMC;
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.MMC_OCR))
{
ocr = imageFormat.ReadDiskTag(MediaTagType.MMC_OCR);
deviceType = DeviceType.MMC;
}
if (imageFormat.Info.ReadableMediaTags != null &&
imageFormat.Info.ReadableMediaTags.Contains(MediaTagType.MMC_ExtendedCSD))
{
extendedCsd = imageFormat.ReadDiskTag(MediaTagType.MMC_ExtendedCSD);
deviceType = DeviceType.MMC;
}
SdMmcInfo = new SdMmcInfo
{
DataContext = new SdMmcInfoViewModel(deviceType, cid, csd, ocr, extendedCsd, scr)
};
if (imageFormat is IOpticalMediaImage opticalMediaImage)
{
try
{
if (opticalMediaImage.Sessions != null &&
opticalMediaImage.Sessions.Count > 0)
{
foreach (Session session in opticalMediaImage.Sessions)
{
Sessions.Add(session);
}
}
}
catch
{
// ignored
}
try
{
if (opticalMediaImage.Tracks != null &&
opticalMediaImage.Tracks.Count > 0)
{
foreach (Track track in opticalMediaImage.Tracks)
{
Tracks.Add(track);
}
}
}
catch
{
// ignored
}
}
if (imageFormat.DumpHardware is null)
{
return;
}
foreach (DumpHardwareType dump in imageFormat.DumpHardware)
{
foreach (ExtentType extent in dump.Extents)
{
DumpHardwareList.Add(new DumpHardwareModel
{
Manufacturer = dump.Manufacturer, Model = dump.Model, Serial = dump.Serial,
SoftwareName = dump.Software.Name, SoftwareVersion = dump.Software.Version,
OperatingSystem = dump.Software.OperatingSystem, Start = extent.Start, End = extent.End
});
}
}
}
/// <summary>
/// Dumps an Xbox Game Disc using a Kreon drive
/// </summary>
/// <param name="dev">Device</param>
/// <param name="devicePath">Path to the device</param>
/// <param name="outputPrefix">Prefix for output data files</param>
/// <param name="outputPlugin">Plugin for output file</param>
/// <param name="retryPasses">How many times to retry</param>
/// <param name="force">Force to continue dump whenever possible</param>
/// <param name="dumpRaw">Dump raw/long sectors</param>
/// <param name="persistent">Store whatever data the drive returned on error</param>
/// <param name="stopOnError">Stop dump on first error</param>
/// <param name="resume">Information for dump resuming</param>
/// <param name="dumpLog">Dump logger</param>
/// <param name="encoding">Encoding to use when analyzing dump</param>
/// <param name="mediaTags">Media tags as retrieved in MMC layer</param>
/// <param name="dskType">Disc type as detected in MMC layer</param>
/// <param name="outputPath">Path to output file</param>
/// <param name="formatOptions">Formats to pass to output file plugin</param>
/// <exception cref="InvalidOperationException">
/// If the provided resume does not correspond with the current in progress
/// dump
/// </exception>
internal static void Dump(Device dev, string devicePath,
IWritableImage outputPlugin, ushort retryPasses,
bool force, bool dumpRaw,
bool persistent, bool stopOnError,
Dictionary <MediaTagType, byte[]> mediaTags, ref MediaType dskType,
ref Resume resume,
ref DumpLog dumpLog, Encoding encoding,
string outputPrefix, string outputPath,
Dictionary <string, string> formatOptions, CICMMetadataType preSidecar,
uint skip,
bool nometadata, bool notrim)
{
bool sense;
ulong blocks;
const uint BLOCK_SIZE = 2048;
uint blocksToRead = 64;
DateTime start;
DateTime end;
double totalDuration = 0;
double currentSpeed = 0;
double maxSpeed = double.MinValue;
double minSpeed = double.MaxValue;
bool aborted = false;
System.Console.CancelKeyPress += (sender, e) => e.Cancel = aborted = true;
if (mediaTags.ContainsKey(MediaTagType.DVD_PFI))
{
mediaTags.Remove(MediaTagType.DVD_PFI);
}
if (mediaTags.ContainsKey(MediaTagType.DVD_DMI))
{
mediaTags.Remove(MediaTagType.DVD_DMI);
}
dumpLog.WriteLine("Reading Xbox Security Sector.");
sense = dev.KreonExtractSs(out byte[] ssBuf, out byte[] senseBuf, dev.Timeout, out _);
if (sense)
{
dumpLog.WriteLine("Cannot get Xbox Security Sector, not continuing.");
DicConsole.ErrorWriteLine("Cannot get Xbox Security Sector, not continuing.");
return;
}
dumpLog.WriteLine("Decoding Xbox Security Sector.");
SS.SecuritySector?xboxSs = SS.Decode(ssBuf);
if (!xboxSs.HasValue)
{
dumpLog.WriteLine("Cannot decode Xbox Security Sector, not continuing.");
DicConsole.ErrorWriteLine("Cannot decode Xbox Security Sector, not continuing.");
return;
}
byte[] tmpBuf = new byte[ssBuf.Length - 4];
Array.Copy(ssBuf, 4, tmpBuf, 0, ssBuf.Length - 4);
mediaTags.Add(MediaTagType.Xbox_SecuritySector, tmpBuf);
ulong l0Video, l1Video, middleZone, gameSize, totalSize, layerBreak;
// Get video partition size
DicConsole.DebugWriteLine("Dump-media command", "Getting video partition size");
dumpLog.WriteLine("Locking drive.");
sense = dev.KreonLock(out senseBuf, dev.Timeout, out _);
if (sense)
{
dumpLog.WriteLine("Cannot lock drive, not continuing.");
DicConsole.ErrorWriteLine("Cannot lock drive, not continuing.");
return;
}
dumpLog.WriteLine("Getting video partition size.");
sense = dev.ReadCapacity(out byte[] readBuffer, out senseBuf, dev.Timeout, out _);
if (sense)
{
dumpLog.WriteLine("Cannot get disc capacity.");
DicConsole.ErrorWriteLine("Cannot get disc capacity.");
return;
}
totalSize = (ulong)((readBuffer[0] << 24) + (readBuffer[1] << 16) + (readBuffer[2] << 8) + readBuffer[3]);
dumpLog.WriteLine("Reading Physical Format Information.");
sense = dev.ReadDiscStructure(out readBuffer, out senseBuf, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.PhysicalInformation, 0, 0, out _);
if (sense)
{
dumpLog.WriteLine("Cannot get PFI.");
DicConsole.ErrorWriteLine("Cannot get PFI.");
return;
}
tmpBuf = new byte[readBuffer.Length - 4];
Array.Copy(readBuffer, 4, tmpBuf, 0, readBuffer.Length - 4);
mediaTags.Add(MediaTagType.DVD_PFI, tmpBuf);
DicConsole.DebugWriteLine("Dump-media command", "Video partition total size: {0} sectors", totalSize);
l0Video = PFI.Decode(readBuffer).Value.Layer0EndPSN - PFI.Decode(readBuffer).Value.DataAreaStartPSN + 1;
l1Video = totalSize - l0Video + 1;
dumpLog.WriteLine("Reading Disc Manufacturing Information.");
sense = dev.ReadDiscStructure(out readBuffer, out senseBuf, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.DiscManufacturingInformation, 0, 0, out _);
if (sense)
{
dumpLog.WriteLine("Cannot get DMI.");
DicConsole.ErrorWriteLine("Cannot get DMI.");
return;
}
tmpBuf = new byte[readBuffer.Length - 4];
Array.Copy(readBuffer, 4, tmpBuf, 0, readBuffer.Length - 4);
mediaTags.Add(MediaTagType.DVD_DMI, tmpBuf);
// Get game partition size
DicConsole.DebugWriteLine("Dump-media command", "Getting game partition size");
dumpLog.WriteLine("Unlocking drive (Xtreme).");
sense = dev.KreonUnlockXtreme(out senseBuf, dev.Timeout, out _);
if (sense)
{
dumpLog.WriteLine("Cannot unlock drive, not continuing.");
DicConsole.ErrorWriteLine("Cannot unlock drive, not continuing.");
return;
}
dumpLog.WriteLine("Getting game partition size.");
sense = dev.ReadCapacity(out readBuffer, out senseBuf, dev.Timeout, out _);
if (sense)
{
dumpLog.WriteLine("Cannot get disc capacity.");
DicConsole.ErrorWriteLine("Cannot get disc capacity.");
return;
}
gameSize = (ulong)((readBuffer[0] << 24) + (readBuffer[1] << 16) + (readBuffer[2] << 8) + readBuffer[3]) +
1;
DicConsole.DebugWriteLine("Dump-media command", "Game partition total size: {0} sectors", gameSize);
// Get middle zone size
DicConsole.DebugWriteLine("Dump-media command", "Getting middle zone size");
dumpLog.WriteLine("Unlocking drive (Wxripper).");
sense = dev.KreonUnlockWxripper(out senseBuf, dev.Timeout, out _);
if (sense)
{
dumpLog.WriteLine("Cannot unlock drive, not continuing.");
DicConsole.ErrorWriteLine("Cannot unlock drive, not continuing.");
return;
}
dumpLog.WriteLine("Getting disc size.");
sense = dev.ReadCapacity(out readBuffer, out senseBuf, dev.Timeout, out _);
if (sense)
{
dumpLog.WriteLine("Cannot get disc capacity.");
DicConsole.ErrorWriteLine("Cannot get disc capacity.");
return;
}
totalSize = (ulong)((readBuffer[0] << 24) + (readBuffer[1] << 16) + (readBuffer[2] << 8) + readBuffer[3]);
dumpLog.WriteLine("Reading Physical Format Information.");
sense = dev.ReadDiscStructure(out readBuffer, out senseBuf, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.PhysicalInformation, 0, 0, out _);
if (sense)
{
dumpLog.WriteLine("Cannot get PFI.");
DicConsole.ErrorWriteLine("Cannot get PFI.");
return;
}
DicConsole.DebugWriteLine("Dump-media command", "Unlocked total size: {0} sectors", totalSize);
blocks = totalSize + 1;
middleZone =
totalSize - (PFI.Decode(readBuffer).Value.Layer0EndPSN -
PFI.Decode(readBuffer).Value.DataAreaStartPSN +
1) - gameSize + 1;
tmpBuf = new byte[readBuffer.Length - 4];
Array.Copy(readBuffer, 4, tmpBuf, 0, readBuffer.Length - 4);
mediaTags.Add(MediaTagType.Xbox_PFI, tmpBuf);
dumpLog.WriteLine("Reading Disc Manufacturing Information.");
sense = dev.ReadDiscStructure(out readBuffer, out senseBuf, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.DiscManufacturingInformation, 0, 0, out _);
if (sense)
{
dumpLog.WriteLine("Cannot get DMI.");
DicConsole.ErrorWriteLine("Cannot get DMI.");
return;
}
tmpBuf = new byte[readBuffer.Length - 4];
Array.Copy(readBuffer, 4, tmpBuf, 0, readBuffer.Length - 4);
mediaTags.Add(MediaTagType.Xbox_DMI, tmpBuf);
totalSize = l0Video + l1Video + middleZone * 2 + gameSize;
layerBreak = l0Video + middleZone + gameSize / 2;
DicConsole.WriteLine("Video layer 0 size: {0} sectors", l0Video);
DicConsole.WriteLine("Video layer 1 size: {0} sectors", l1Video);
DicConsole.WriteLine("Middle zone size: {0} sectors", middleZone);
DicConsole.WriteLine("Game data size: {0} sectors", gameSize);
DicConsole.WriteLine("Total size: {0} sectors", totalSize);
DicConsole.WriteLine("Real layer break: {0}", layerBreak);
DicConsole.WriteLine();
dumpLog.WriteLine("Video layer 0 size: {0} sectors", l0Video);
dumpLog.WriteLine("Video layer 1 size: {0} sectors", l1Video);
dumpLog.WriteLine("Middle zone 0 size: {0} sectors", middleZone);
dumpLog.WriteLine("Game data 0 size: {0} sectors", gameSize);
dumpLog.WriteLine("Total 0 size: {0} sectors", totalSize);
dumpLog.WriteLine("Real layer break: {0}", layerBreak);
bool read12 = !dev.Read12(out readBuffer, out senseBuf, 0, false, true, false, false, 0, BLOCK_SIZE, 0, 1,
false, dev.Timeout, out _);
if (!read12)
{
dumpLog.WriteLine("Cannot read medium, aborting scan...");
DicConsole.ErrorWriteLine("Cannot read medium, aborting scan...");
return;
}
dumpLog.WriteLine("Using SCSI READ (12) command.");
DicConsole.WriteLine("Using SCSI READ (12) command.");
while (true)
{
if (read12)
{
sense = dev.Read12(out readBuffer, out senseBuf, 0, false, false, false, false, 0, BLOCK_SIZE, 0,
blocksToRead, false, dev.Timeout, out _);
if (sense || dev.Error)
{
blocksToRead /= 2;
}
}
if (!dev.Error || blocksToRead == 1)
{
break;
}
}
if (dev.Error)
{
dumpLog.WriteLine("Device error {0} trying to guess ideal transfer length.", dev.LastError);
DicConsole.ErrorWriteLine("Device error {0} trying to guess ideal transfer length.", dev.LastError);
return;
}
if (skip < blocksToRead)
{
skip = blocksToRead;
}
bool ret = true;
foreach (MediaTagType tag in mediaTags.Keys)
{
if (outputPlugin.SupportedMediaTags.Contains(tag))
{
continue;
}
ret = false;
dumpLog.WriteLine($"Output format does not support {tag}.");
DicConsole.ErrorWriteLine($"Output format does not support {tag}.");
}
if (!ret)
{
dumpLog.WriteLine("Several media tags not supported, {0}continuing...", force ? "" : "not ");
DicConsole.ErrorWriteLine("Several media tags not supported, {0}continuing...", force ? "" : "not ");
if (!force)
{
return;
}
}
dumpLog.WriteLine("Reading {0} sectors at a time.", blocksToRead);
DicConsole.WriteLine("Reading {0} sectors at a time.", blocksToRead);
MhddLog mhddLog = new MhddLog(outputPrefix + ".mhddlog.bin", dev, blocks, BLOCK_SIZE, blocksToRead);
IbgLog ibgLog = new IbgLog(outputPrefix + ".ibg", 0x0010);
ret = outputPlugin.Create(outputPath, dskType, formatOptions, blocks, BLOCK_SIZE);
// Cannot create image
if (!ret)
{
dumpLog.WriteLine("Error creating output image, not continuing.");
dumpLog.WriteLine(outputPlugin.ErrorMessage);
DicConsole.ErrorWriteLine("Error creating output image, not continuing.");
DicConsole.ErrorWriteLine(outputPlugin.ErrorMessage);
return;
}
start = DateTime.UtcNow;
double imageWriteDuration = 0;
double cmdDuration = 0;
uint saveBlocksToRead = blocksToRead;
DumpHardwareType currentTry = null;
ExtentsULong extents = null;
ResumeSupport.Process(true, true, totalSize, dev.Manufacturer, dev.Model, dev.Serial, dev.PlatformId,
ref resume, ref currentTry, ref extents);
if (currentTry == null || extents == null)
{
throw new NotImplementedException("Could not process resume file, not continuing...");
}
outputPlugin.SetTracks(new List <Track>
{
new Track
{
TrackBytesPerSector = (int)BLOCK_SIZE,
TrackEndSector = blocks - 1,
TrackSequence = 1,
TrackRawBytesPerSector = (int)BLOCK_SIZE,
TrackSubchannelType = TrackSubchannelType.None,
TrackSession = 1,
TrackType = TrackType.Data
}
});
ulong currentSector = resume.NextBlock;
if (resume.NextBlock > 0)
{
dumpLog.WriteLine("Resuming from block {0}.", resume.NextBlock);
}
bool newTrim = false;
dumpLog.WriteLine("Reading game partition.");
for (int e = 0; e <= 16; e++)
{
if (aborted)
{
resume.NextBlock = currentSector;
currentTry.Extents = ExtentsConverter.ToMetadata(extents);
dumpLog.WriteLine("Aborted!");
break;
}
if (currentSector >= blocks)
{
break;
}
ulong extentStart, extentEnd;
// Extents
if (e < 16)
{
if (xboxSs.Value.Extents[e].StartPSN <= xboxSs.Value.Layer0EndPSN)
{
extentStart = xboxSs.Value.Extents[e].StartPSN - 0x30000;
}
else
{
extentStart = (xboxSs.Value.Layer0EndPSN + 1) * 2 -
((xboxSs.Value.Extents[e].StartPSN ^ 0xFFFFFF) + 1) - 0x30000;
}
if (xboxSs.Value.Extents[e].EndPSN <= xboxSs.Value.Layer0EndPSN)
{
extentEnd = xboxSs.Value.Extents[e].EndPSN - 0x30000;
}
else
{
extentEnd = (xboxSs.Value.Layer0EndPSN + 1) * 2 -
((xboxSs.Value.Extents[e].EndPSN ^ 0xFFFFFF) + 1) - 0x30000;
}
}
// After last extent
else
{
extentStart = blocks;
extentEnd = blocks;
}
if (currentSector > extentEnd)
{
continue;
}
for (ulong i = currentSector; i < extentStart; i += blocksToRead)
{
saveBlocksToRead = blocksToRead;
if (aborted)
{
currentTry.Extents = ExtentsConverter.ToMetadata(extents);
dumpLog.WriteLine("Aborted!");
break;
}
if (extentStart - i < blocksToRead)
{
blocksToRead = (uint)(extentStart - i);
}
#pragma warning disable RECS0018 // Comparison of floating point numbers with equality operator
if (currentSpeed > maxSpeed && currentSpeed != 0)
{
maxSpeed = currentSpeed;
}
if (currentSpeed < minSpeed && currentSpeed != 0)
{
minSpeed = currentSpeed;
}
#pragma warning restore RECS0018 // Comparison of floating point numbers with equality operator
DicConsole.Write("\rReading sector {0} of {1} ({2:F3} MiB/sec.)", i, totalSize, currentSpeed);
sense = dev.Read12(out readBuffer, out senseBuf, 0, false, false, false, false, (uint)i, BLOCK_SIZE,
0, blocksToRead, false, dev.Timeout, out cmdDuration);
totalDuration += cmdDuration;
if (!sense && !dev.Error)
{
mhddLog.Write(i, cmdDuration);
ibgLog.Write(i, currentSpeed * 1024);
DateTime writeStart = DateTime.Now;
outputPlugin.WriteSectors(readBuffer, i, blocksToRead);
imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
extents.Add(i, blocksToRead, true);
}
else
{
// TODO: Reset device after X errors
if (stopOnError)
{
return; // TODO: Return more cleanly
}
if (i + skip > blocks)
{
skip = (uint)(blocks - i);
}
// Write empty data
DateTime writeStart = DateTime.Now;
outputPlugin.WriteSectors(new byte[BLOCK_SIZE * skip], i, skip);
imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
for (ulong b = i; b < i + skip; b++)
{
resume.BadBlocks.Add(b);
}
DicConsole.DebugWriteLine("Dump-Media", "READ error:\n{0}", Sense.PrettifySense(senseBuf));
mhddLog.Write(i, cmdDuration < 500 ? 65535 : cmdDuration);
ibgLog.Write(i, 0);
dumpLog.WriteLine("Skipping {0} blocks from errored block {1}.", skip, i);
i += skip - blocksToRead;
string[] senseLines = Sense.PrettifySense(senseBuf).Split(new[] { Environment.NewLine },
StringSplitOptions
.RemoveEmptyEntries);
foreach (string senseLine in senseLines)
{
dumpLog.WriteLine(senseLine);
}
newTrim = true;
}
double newSpeed =
(double)BLOCK_SIZE * blocksToRead / 1048576 / (cmdDuration / 1000);
if (!double.IsInfinity(newSpeed))
{
currentSpeed = newSpeed;
}
blocksToRead = saveBlocksToRead;
currentSector = i + 1;
resume.NextBlock = currentSector;
}
for (ulong i = extentStart; i <= extentEnd; i += blocksToRead)
{
saveBlocksToRead = blocksToRead;
if (aborted)
{
currentTry.Extents = ExtentsConverter.ToMetadata(extents);
dumpLog.WriteLine("Aborted!");
break;
}
if (extentEnd - i < blocksToRead)
{
blocksToRead = (uint)(extentEnd - i) + 1;
}
mhddLog.Write(i, cmdDuration);
ibgLog.Write(i, currentSpeed * 1024);
// Write empty data
DateTime writeStart = DateTime.Now;
outputPlugin.WriteSectors(new byte[BLOCK_SIZE * blocksToRead], i, blocksToRead);
imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
blocksToRead = saveBlocksToRead;
extents.Add(i, blocksToRead, true);
currentSector = i + 1;
resume.NextBlock = currentSector;
}
if (!aborted)
{
currentSector = extentEnd + 1;
}
}
// Middle Zone D
dumpLog.WriteLine("Writing Middle Zone D (empty).");
for (ulong middle = currentSector - blocks - 1; middle < middleZone - 1; middle += blocksToRead)
{
if (aborted)
{
currentTry.Extents = ExtentsConverter.ToMetadata(extents);
dumpLog.WriteLine("Aborted!");
break;
}
if (middleZone - 1 - middle < blocksToRead)
{
blocksToRead = (uint)(middleZone - 1 - middle);
}
DicConsole.Write("\rReading sector {0} of {1} ({2:F3} MiB/sec.)", middle + currentSector, totalSize,
currentSpeed);
mhddLog.Write(middle + currentSector, cmdDuration);
ibgLog.Write(middle + currentSector, currentSpeed * 1024);
// Write empty data
DateTime writeStart = DateTime.Now;
outputPlugin.WriteSectors(new byte[BLOCK_SIZE * blocksToRead], middle + currentSector, blocksToRead);
imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
extents.Add(currentSector, blocksToRead, true);
currentSector += blocksToRead;
resume.NextBlock = currentSector;
}
blocksToRead = saveBlocksToRead;
dumpLog.WriteLine("Locking drive.");
sense = dev.KreonLock(out senseBuf, dev.Timeout, out _);
if (sense)
{
dumpLog.WriteLine("Cannot lock drive, not continuing.");
DicConsole.ErrorWriteLine("Cannot lock drive, not continuing.");
return;
}
sense = dev.ReadCapacity(out readBuffer, out senseBuf, dev.Timeout, out _);
if (sense)
{
DicConsole.ErrorWriteLine("Cannot get disc capacity.");
return;
}
// Video Layer 1
dumpLog.WriteLine("Reading Video Layer 1.");
for (ulong l1 = currentSector - blocks - middleZone + l0Video; l1 < l0Video + l1Video; l1 += blocksToRead)
{
if (aborted)
{
currentTry.Extents = ExtentsConverter.ToMetadata(extents);
dumpLog.WriteLine("Aborted!");
break;
}
if (l0Video + l1Video - l1 < blocksToRead)
{
blocksToRead = (uint)(l0Video + l1Video - l1);
}
#pragma warning disable RECS0018 // Comparison of floating point numbers with equality operator
if (currentSpeed > maxSpeed && currentSpeed != 0)
{
maxSpeed = currentSpeed;
}
if (currentSpeed < minSpeed && currentSpeed != 0)
{
minSpeed = currentSpeed;
}
#pragma warning restore RECS0018 // Comparison of floating point numbers with equality operator
DicConsole.Write("\rReading sector {0} of {1} ({2:F3} MiB/sec.)", currentSector, totalSize,
currentSpeed);
sense = dev.Read12(out readBuffer, out senseBuf, 0, false, false, false, false, (uint)l1, BLOCK_SIZE, 0,
blocksToRead, false, dev.Timeout, out cmdDuration);
totalDuration += cmdDuration;
if (!sense && !dev.Error)
{
mhddLog.Write(currentSector, cmdDuration);
ibgLog.Write(currentSector, currentSpeed * 1024);
DateTime writeStart = DateTime.Now;
outputPlugin.WriteSectors(readBuffer, currentSector, blocksToRead);
imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
extents.Add(currentSector, blocksToRead, true);
}
else
{
// TODO: Reset device after X errors
if (stopOnError)
{
return; // TODO: Return more cleanly
}
// Write empty data
DateTime writeStart = DateTime.Now;
outputPlugin.WriteSectors(new byte[BLOCK_SIZE * skip], currentSector, skip);
imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
// TODO: Handle errors in video partition
//errored += blocksToRead;
//resume.BadBlocks.Add(l1);
DicConsole.DebugWriteLine("Dump-Media", "READ error:\n{0}", Sense.PrettifySense(senseBuf));
mhddLog.Write(l1, cmdDuration < 500 ? 65535 : cmdDuration);
ibgLog.Write(l1, 0);
dumpLog.WriteLine("Skipping {0} blocks from errored block {1}.", skip, l1);
l1 += skip - blocksToRead;
string[] senseLines = Sense.PrettifySense(senseBuf).Split(new[] { Environment.NewLine },
StringSplitOptions.RemoveEmptyEntries);
foreach (string senseLine in senseLines)
{
dumpLog.WriteLine(senseLine);
}
}
double newSpeed =
(double)BLOCK_SIZE * blocksToRead / 1048576 / (cmdDuration / 1000);
if (!double.IsInfinity(newSpeed))
{
currentSpeed = newSpeed;
}
currentSector += blocksToRead;
resume.NextBlock = currentSector;
}
dumpLog.WriteLine("Unlocking drive (Wxripper).");
sense = dev.KreonUnlockWxripper(out senseBuf, dev.Timeout, out _);
if (sense)
{
dumpLog.WriteLine("Cannot unlock drive, not continuing.");
DicConsole.ErrorWriteLine("Cannot unlock drive, not continuing.");
return;
}
sense = dev.ReadCapacity(out readBuffer, out senseBuf, dev.Timeout, out _);
if (sense)
{
DicConsole.ErrorWriteLine("Cannot get disc capacity.");
return;
}
end = DateTime.UtcNow;
DicConsole.WriteLine();
mhddLog.Close();
ibgLog.Close(dev, blocks, BLOCK_SIZE, (end - start).TotalSeconds, currentSpeed * 1024,
BLOCK_SIZE * (double)(blocks + 1) / 1024 / (totalDuration / 1000),
devicePath);
dumpLog.WriteLine("Dump finished in {0} seconds.", (end - start).TotalSeconds);
dumpLog.WriteLine("Average dump speed {0:F3} KiB/sec.",
(double)BLOCK_SIZE * (double)(blocks + 1) / 1024 / (totalDuration / 1000));
dumpLog.WriteLine("Average write speed {0:F3} KiB/sec.",
(double)BLOCK_SIZE * (double)(blocks + 1) / 1024 / imageWriteDuration);
#region Trimming
if (resume.BadBlocks.Count > 0 && !aborted && !notrim && newTrim)
{
start = DateTime.UtcNow;
dumpLog.WriteLine("Trimming bad sectors");
ulong[] tmpArray = resume.BadBlocks.ToArray();
foreach (ulong badSector in tmpArray)
{
if (aborted)
{
currentTry.Extents = ExtentsConverter.ToMetadata(extents);
dumpLog.WriteLine("Aborted!");
break;
}
DicConsole.Write("\rTrimming sector {0}", badSector);
sense = dev.Read12(out readBuffer, out senseBuf, 0, false, false, false, false, (uint)badSector,
BLOCK_SIZE, 0, 1, false, dev.Timeout, out cmdDuration);
totalDuration += cmdDuration;
if (sense || dev.Error)
{
continue;
}
resume.BadBlocks.Remove(badSector);
extents.Add(badSector);
outputPlugin.WriteSector(readBuffer, badSector);
}
DicConsole.WriteLine();
end = DateTime.UtcNow;
dumpLog.WriteLine("Trimmming finished in {0} seconds.", (end - start).TotalSeconds);
}
#endregion Trimming
#region Error handling
if (resume.BadBlocks.Count > 0 && !aborted && retryPasses > 0)
{
List <ulong> tmpList = new List <ulong>();
foreach (ulong ur in resume.BadBlocks)
{
for (ulong i = ur; i < ur + blocksToRead; i++)
{
tmpList.Add(i);
}
}
tmpList.Sort();
int pass = 1;
bool forward = true;
bool runningPersistent = false;
resume.BadBlocks = tmpList;
Modes.ModePage?currentModePage = null;
byte[] md6;
byte[] md10;
if (persistent)
{
Modes.ModePage_01_MMC pgMmc;
sense = dev.ModeSense6(out readBuffer, out _, false, ScsiModeSensePageControl.Current, 0x01,
dev.Timeout, out _);
if (sense)
{
sense = dev.ModeSense10(out readBuffer, out _, false, ScsiModeSensePageControl.Current,
0x01, dev.Timeout, out _);
if (!sense)
{
Modes.DecodedMode?dcMode10 =
Modes.DecodeMode10(readBuffer, PeripheralDeviceTypes.MultiMediaDevice);
if (dcMode10.HasValue)
{
foreach (Modes.ModePage modePage in dcMode10.Value.Pages)
{
if (modePage.Page == 0x01 && modePage.Subpage == 0x00)
{
currentModePage = modePage;
}
}
}
}
}
else
{
Modes.DecodedMode?dcMode6 =
Modes.DecodeMode6(readBuffer, PeripheralDeviceTypes.MultiMediaDevice);
if (dcMode6.HasValue)
{
foreach (Modes.ModePage modePage in dcMode6.Value.Pages)
{
if (modePage.Page == 0x01 && modePage.Subpage == 0x00)
{
currentModePage = modePage;
}
}
}
}
if (currentModePage == null)
{
pgMmc =
new Modes.ModePage_01_MMC {
PS = false, ReadRetryCount = 0x20, Parameter = 0x00
};
currentModePage = new Modes.ModePage
{
Page = 0x01,
Subpage = 0x00,
PageResponse = Modes.EncodeModePage_01_MMC(pgMmc)
};
}
pgMmc =
new Modes.ModePage_01_MMC {
PS = false, ReadRetryCount = 255, Parameter = 0x20
};
Modes.DecodedMode md = new Modes.DecodedMode
{
Header = new Modes.ModeHeader(),
Pages = new[]
{
new Modes.ModePage
{
Page = 0x01,
Subpage = 0x00,
PageResponse = Modes.EncodeModePage_01_MMC(pgMmc)
}
}
};
md6 = Modes.EncodeMode6(md, dev.ScsiType);
md10 = Modes.EncodeMode10(md, dev.ScsiType);
dumpLog.WriteLine("Sending MODE SELECT to drive (return damaged blocks).");
sense = dev.ModeSelect(md6, out senseBuf, true, false, dev.Timeout, out _);
if (sense)
{
sense = dev.ModeSelect10(md10, out senseBuf, true, false, dev.Timeout, out _);
}
if (sense)
{
DicConsole
.WriteLine("Drive did not accept MODE SELECT command for persistent error reading, try another drive.");
DicConsole.DebugWriteLine("Error: {0}", Sense.PrettifySense(senseBuf));
dumpLog.WriteLine("Drive did not accept MODE SELECT command for persistent error reading, try another drive.");
}
else
{
runningPersistent = true;
}
}
repeatRetry:
ulong[] tmpArray = resume.BadBlocks.ToArray();
foreach (ulong badSector in tmpArray)
{
if (aborted)
{
currentTry.Extents = ExtentsConverter.ToMetadata(extents);
dumpLog.WriteLine("Aborted!");
break;
}
DicConsole.Write("\rRetrying sector {0}, pass {1}, {3}{2}", badSector, pass,
forward ? "forward" : "reverse",
runningPersistent ? "recovering partial data, " : "");
sense = dev.Read12(out readBuffer, out senseBuf, 0, false, false, false, false, (uint)badSector,
BLOCK_SIZE, 0, 1, false, dev.Timeout, out cmdDuration);
totalDuration += cmdDuration;
if (!sense && !dev.Error)
{
resume.BadBlocks.Remove(badSector);
extents.Add(badSector);
outputPlugin.WriteSector(readBuffer, badSector);
dumpLog.WriteLine("Correctly retried block {0} in pass {1}.", badSector, pass);
}
else if (runningPersistent)
{
outputPlugin.WriteSector(readBuffer, badSector);
}
}
if (pass < retryPasses && !aborted && resume.BadBlocks.Count > 0)
{
pass++;
forward = !forward;
resume.BadBlocks.Sort();
resume.BadBlocks.Reverse();
goto repeatRetry;
}
if (runningPersistent && currentModePage.HasValue)
{
Modes.DecodedMode md = new Modes.DecodedMode
{
Header = new Modes.ModeHeader(),
Pages = new[] { currentModePage.Value }
};
md6 = Modes.EncodeMode6(md, dev.ScsiType);
md10 = Modes.EncodeMode10(md, dev.ScsiType);
dumpLog.WriteLine("Sending MODE SELECT to drive (return device to previous status).");
sense = dev.ModeSelect(md6, out senseBuf, true, false, dev.Timeout, out _);
if (sense)
{
dev.ModeSelect10(md10, out senseBuf, true, false, dev.Timeout, out _);
}
}
DicConsole.WriteLine();
}
#endregion Error handling
resume.BadBlocks.Sort();
currentTry.Extents = ExtentsConverter.ToMetadata(extents);
foreach (KeyValuePair <MediaTagType, byte[]> tag in mediaTags)
{
ret = outputPlugin.WriteMediaTag(tag.Value, tag.Key);
if (ret || force)
{
continue;
}
// Cannot write tag to image
dumpLog.WriteLine($"Cannot write tag {tag.Key}.");
throw new ArgumentException(outputPlugin.ErrorMessage);
}
resume.BadBlocks.Sort();
foreach (ulong bad in resume.BadBlocks)
{
dumpLog.WriteLine("Sector {0} could not be read.", bad);
}
currentTry.Extents = ExtentsConverter.ToMetadata(extents);
outputPlugin.SetDumpHardware(resume.Tries);
if (preSidecar != null)
{
outputPlugin.SetCicmMetadata(preSidecar);
}
dumpLog.WriteLine("Closing output file.");
DicConsole.WriteLine("Closing output file.");
DateTime closeStart = DateTime.Now;
outputPlugin.Close();
DateTime closeEnd = DateTime.Now;
dumpLog.WriteLine("Closed in {0} seconds.", (closeEnd - closeStart).TotalSeconds);
if (aborted)
{
dumpLog.WriteLine("Aborted!");
return;
}
double totalChkDuration = 0;
if (!nometadata)
{
dumpLog.WriteLine("Creating sidecar.");
FiltersList filters = new FiltersList();
IFilter filter = filters.GetFilter(outputPath);
IMediaImage inputPlugin = ImageFormat.Detect(filter);
if (!inputPlugin.Open(filter))
{
throw new ArgumentException("Could not open created image.");
}
DateTime chkStart = DateTime.UtcNow;
CICMMetadataType sidecar = Sidecar.Create(inputPlugin, outputPath, filter.Id, encoding);
end = DateTime.UtcNow;
if (preSidecar != null)
{
preSidecar.OpticalDisc = sidecar.OpticalDisc;
sidecar = preSidecar;
}
totalChkDuration = (end - chkStart).TotalMilliseconds;
dumpLog.WriteLine("Sidecar created in {0} seconds.", (end - chkStart).TotalSeconds);
dumpLog.WriteLine("Average checksum speed {0:F3} KiB/sec.",
(double)BLOCK_SIZE * (double)(blocks + 1) / 1024 / (totalChkDuration / 1000));
foreach (KeyValuePair <MediaTagType, byte[]> tag in mediaTags)
{
Mmc.AddMediaTagToSidecar(outputPath, tag, ref sidecar);
}
List <(ulong start, string type)> filesystems = new List <(ulong start, string type)>();
if (sidecar.OpticalDisc[0].Track != null)
{
filesystems.AddRange(from xmlTrack in sidecar.OpticalDisc[0].Track
where xmlTrack.FileSystemInformation != null
from partition in xmlTrack.FileSystemInformation
where partition.FileSystems != null
from fileSystem in partition.FileSystems
select((ulong)partition.StartSector, fileSystem.Type));
}
if (filesystems.Count > 0)
{
foreach (var filesystem in filesystems.Select(o => new { o.start, o.type }).Distinct())
{
dumpLog.WriteLine("Found filesystem {0} at sector {1}", filesystem.type, filesystem.start);
}
}
sidecar.OpticalDisc[0].Layers = new LayersType
{
type = LayersTypeType.OTP,
typeSpecified = true,
Sectors = new SectorsType[1]
};
sidecar.OpticalDisc[0].Layers.Sectors[0] = new SectorsType {
Value = (long)layerBreak
};
sidecar.OpticalDisc[0].Sessions = 1;
sidecar.OpticalDisc[0].Dimensions = Dimensions.DimensionsFromMediaType(dskType);
Metadata.MediaType.MediaTypeToString(dskType, out string xmlDskTyp, out string xmlDskSubTyp);
sidecar.OpticalDisc[0].DiscType = xmlDskTyp;
sidecar.OpticalDisc[0].DiscSubType = xmlDskSubTyp;
foreach (KeyValuePair <MediaTagType, byte[]> tag in mediaTags)
{
if (outputPlugin.SupportedMediaTags.Contains(tag.Key))
{
Mmc.AddMediaTagToSidecar(outputPath, tag, ref sidecar);
}
}
DicConsole.WriteLine("Writing metadata sidecar");
FileStream xmlFs = new FileStream(outputPrefix + ".cicm.xml", FileMode.Create);
XmlSerializer xmlSer = new XmlSerializer(typeof(CICMMetadataType));
xmlSer.Serialize(xmlFs, sidecar);
xmlFs.Close();
}
DicConsole.WriteLine();
DicConsole.WriteLine("Took a total of {0:F3} seconds ({1:F3} processing commands, {2:F3} checksumming, {3:F3} writing, {4:F3} closing).",
(end - start).TotalSeconds, totalDuration / 1000,
totalChkDuration / 1000,
imageWriteDuration, (closeEnd - closeStart).TotalSeconds);
DicConsole.WriteLine("Avegare speed: {0:F3} MiB/sec.",
(double)BLOCK_SIZE * (double)(blocks + 1) / 1048576 / (totalDuration / 1000));
DicConsole.WriteLine("Fastest speed burst: {0:F3} MiB/sec.", maxSpeed);
DicConsole.WriteLine("Slowest speed burst: {0:F3} MiB/sec.", minSpeed);
DicConsole.WriteLine("{0} sectors could not be read.", resume.BadBlocks.Count);
DicConsole.WriteLine();
Statistics.AddMedia(dskType, true);
}
static void DoScsiMediaInfo(string outputPrefix, Device dev)
{
ScsiInfo scsiInfo = new ScsiInfo(dev);
if (!scsiInfo.MediaInserted)
{
return;
}
if (scsiInfo.DeviceInfo.ScsiModeSense6 != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_scsi_modesense6.bin", "SCSI MODE SENSE (6)",
scsiInfo.DeviceInfo.ScsiModeSense6);
}
if (scsiInfo.DeviceInfo.ScsiModeSense10 != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_scsi_modesense10.bin", "SCSI MODE SENSE (10)",
scsiInfo.DeviceInfo.ScsiModeSense10);
}
switch (dev.ScsiType)
{
case PeripheralDeviceTypes.DirectAccess:
case PeripheralDeviceTypes.MultiMediaDevice:
case PeripheralDeviceTypes.OCRWDevice:
case PeripheralDeviceTypes.OpticalDevice:
case PeripheralDeviceTypes.SimplifiedDevice:
case PeripheralDeviceTypes.WriteOnceDevice:
if (scsiInfo.ReadCapacity != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readcapacity.bin", "SCSI READ CAPACITY",
scsiInfo.ReadCapacity);
}
if (scsiInfo.ReadCapacity16 != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readcapacity16.bin",
"SCSI READ CAPACITY(16)", scsiInfo.ReadCapacity16);
}
if (scsiInfo.Blocks != 0 && scsiInfo.BlockSize != 0)
{
DicConsole.WriteLine("Media has {0} blocks of {1} bytes/each. (for a total of {2} bytes)",
scsiInfo.Blocks, scsiInfo.BlockSize, scsiInfo.Blocks * scsiInfo.BlockSize);
}
break;
case PeripheralDeviceTypes.SequentialAccess:
if (scsiInfo.DensitySupport != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_ssc_reportdensitysupport_media.bin",
"SSC REPORT DENSITY SUPPORT (MEDIA)", scsiInfo.DensitySupport);
if (scsiInfo.DensitySupportHeader.HasValue)
{
DicConsole.WriteLine("Densities supported by currently inserted media:");
DicConsole.WriteLine(DensitySupport.PrettifyDensity(scsiInfo.DensitySupportHeader));
}
}
if (scsiInfo.MediaTypeSupport != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix,
"_ssc_reportdensitysupport_medium_media.bin",
"SSC REPORT DENSITY SUPPORT (MEDIUM & MEDIA)", scsiInfo.MediaTypeSupport);
if (scsiInfo.MediaTypeSupportHeader.HasValue)
{
DicConsole.WriteLine("Medium types currently inserted in device:");
DicConsole.WriteLine(DensitySupport.PrettifyMediumType(scsiInfo.MediaTypeSupportHeader));
}
DicConsole.WriteLine(DensitySupport.PrettifyMediumType(scsiInfo.MediaTypeSupport));
}
break;
}
if (dev.ScsiType == PeripheralDeviceTypes.MultiMediaDevice)
{
if (scsiInfo.MmcConfiguration != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_getconfiguration_current.bin",
"SCSI GET CONFIGURATION", scsiInfo.MmcConfiguration);
}
if (scsiInfo.RecognizedFormatLayers != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_formatlayers.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.RecognizedFormatLayers);
}
if (scsiInfo.WriteProtectionStatus != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_writeprotection.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.WriteProtectionStatus);
}
if (scsiInfo.DvdPfi != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_pfi.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdPfi);
if (scsiInfo.DecodedPfi.HasValue)
{
DicConsole.WriteLine("PFI:\n{0}", PFI.Prettify(scsiInfo.DecodedPfi));
}
}
if (scsiInfo.DvdDmi != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_dmi.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdDmi);
if (DMI.IsXbox(scsiInfo.DvdDmi))
{
DicConsole.WriteLine("Xbox DMI:\n{0}", DMI.PrettifyXbox(scsiInfo.DvdDmi));
}
else if (DMI.IsXbox360(scsiInfo.DvdDmi))
{
DicConsole.WriteLine("Xbox 360 DMI:\n{0}", DMI.PrettifyXbox360(scsiInfo.DvdDmi));
}
}
if (scsiInfo.DvdCmi != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_cmi.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdCmi);
DicConsole.WriteLine("Lead-In CMI:\n{0}", CSS_CPRM.PrettifyLeadInCopyright(scsiInfo.DvdCmi));
}
if (scsiInfo.DvdBca != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_bca.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdBca);
}
if (scsiInfo.DvdAacs != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_aacs.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdAacs);
}
if (scsiInfo.DvdRamDds != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvdram_dds.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdRamDds);
DicConsole.WriteLine("Disc Definition Structure:\n{0}", DDS.Prettify(scsiInfo.DvdRamDds));
}
if (scsiInfo.DvdRamCartridgeStatus != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvdram_status.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdRamCartridgeStatus);
DicConsole.WriteLine("Medium Status:\n{0}", Cartridge.Prettify(scsiInfo.DvdRamCartridgeStatus));
}
if (scsiInfo.DvdRamSpareArea != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvdram_spare.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdRamSpareArea);
DicConsole.WriteLine("Spare Area Information:\n{0}", Spare.Prettify(scsiInfo.DvdRamSpareArea));
}
if (scsiInfo.LastBorderOutRmd != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_lastrmd.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.LastBorderOutRmd);
}
if (scsiInfo.DvdPreRecordedInfo != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_pri.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdPreRecordedInfo);
}
if (scsiInfo.DvdrMediaIdentifier != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvdr_mediaid.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdrMediaIdentifier);
}
if (scsiInfo.DvdrPhysicalInformation != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvdr_pfi.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdrPhysicalInformation);
}
if (scsiInfo.DvdPlusAdip != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd+_adip.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdPlusAdip);
}
if (scsiInfo.DvdPlusDcb != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd+_dcb.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdPlusDcb);
}
if (scsiInfo.HddvdCopyrightInformation != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_hddvd_cmi.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.HddvdCopyrightInformation);
}
if (scsiInfo.HddvdrMediumStatus != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_hddvdr_status.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.HddvdrMediumStatus);
}
if (scsiInfo.HddvdrLastRmd != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_hddvdr_lastrmd.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.HddvdrLastRmd);
}
if (scsiInfo.DvdrLayerCapacity != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvdr_layercap.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdrLayerCapacity);
}
if (scsiInfo.DvdrDlMiddleZoneStart != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_mzs.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdrDlMiddleZoneStart);
}
if (scsiInfo.DvdrDlJumpIntervalSize != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_jis.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdrDlJumpIntervalSize);
}
if (scsiInfo.DvdrDlManualLayerJumpStartLba != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_manuallj.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdrDlManualLayerJumpStartLba);
}
if (scsiInfo.DvdrDlRemapAnchorPoint != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_remapanchor.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdrDlRemapAnchorPoint);
}
if (scsiInfo.BlurayDiscInformation != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_bd_di.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.BlurayDiscInformation);
DicConsole.WriteLine("Blu-ray Disc Information:\n{0}", DI.Prettify(scsiInfo.BlurayDiscInformation));
}
if (scsiInfo.BlurayPac != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_bd_pac.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.BlurayPac);
}
if (scsiInfo.BlurayBurstCuttingArea != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_bd_bca.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.BlurayBurstCuttingArea);
DicConsole.WriteLine("Blu-ray Burst Cutting Area:\n{0}",
BCA.Prettify(scsiInfo.BlurayBurstCuttingArea));
}
if (scsiInfo.BlurayDds != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_bd_dds.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.BlurayDds);
DicConsole.WriteLine("Blu-ray Disc Definition Structure:\n{0}",
Decoders.Bluray.DDS.Prettify(scsiInfo.BlurayDds));
}
if (scsiInfo.BlurayCartridgeStatus != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_bd_cartstatus.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.BlurayCartridgeStatus);
DicConsole.WriteLine("Blu-ray Cartridge Status:\n{0}",
Decoders.Bluray.Cartridge.Prettify(scsiInfo.BlurayCartridgeStatus));
}
if (scsiInfo.BluraySpareAreaInformation != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_bd_spare.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.BluraySpareAreaInformation);
DicConsole.WriteLine("Blu-ray Spare Area Information:\n{0}",
Decoders.Bluray.Spare.Prettify(scsiInfo.BluraySpareAreaInformation));
}
if (scsiInfo.BlurayRawDfl != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_bd_dfl.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.BlurayRawDfl);
}
if (scsiInfo.BlurayTrackResources != null)
{
DicConsole.WriteLine("Track Resources Information:\n{0}",
DiscInformation.Prettify(scsiInfo.BlurayTrackResources));
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscinformation_001b.bin",
"SCSI READ DISC INFORMATION", scsiInfo.BlurayTrackResources);
}
if (scsiInfo.BlurayPowResources != null)
{
DicConsole.WriteLine("POW Resources Information:\n{0}",
DiscInformation.Prettify(scsiInfo.BlurayPowResources));
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscinformation_010b.bin",
"SCSI READ DISC INFORMATION", scsiInfo.BlurayPowResources);
}
if (scsiInfo.Toc != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_toc.bin", "SCSI READ TOC/PMA/ATIP",
scsiInfo.Toc);
if (scsiInfo.DecodedToc.HasValue)
{
DicConsole.WriteLine("TOC:\n{0}", TOC.Prettify(scsiInfo.DecodedToc));
}
}
if (scsiInfo.Atip != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_atip.bin", "SCSI READ TOC/PMA/ATIP",
scsiInfo.Atip);
if (scsiInfo.DecodedAtip.HasValue)
{
DicConsole.WriteLine("ATIP:\n{0}", ATIP.Prettify(scsiInfo.DecodedAtip));
}
}
if (scsiInfo.CompactDiscInformation != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscinformation_000b.bin",
"SCSI READ DISC INFORMATION", scsiInfo.CompactDiscInformation);
if (scsiInfo.DecodedCompactDiscInformation.HasValue)
{
DicConsole.WriteLine("Standard Disc Information:\n{0}",
DiscInformation.Prettify000b(scsiInfo.DecodedCompactDiscInformation));
}
}
if (scsiInfo.Session != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_session.bin", "SCSI READ TOC/PMA/ATIP",
scsiInfo.Session);
if (scsiInfo.DecodedSession.HasValue)
{
DicConsole.WriteLine("Session information:\n{0}", Session.Prettify(scsiInfo.DecodedSession));
}
}
if (scsiInfo.RawToc != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_rawtoc.bin", "SCSI READ TOC/PMA/ATIP",
scsiInfo.RawToc);
if (scsiInfo.FullToc.HasValue)
{
DicConsole.WriteLine("Raw TOC:\n{0}", FullTOC.Prettify(scsiInfo.RawToc));
}
}
if (scsiInfo.Pma != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_pma.bin", "SCSI READ TOC/PMA/ATIP",
scsiInfo.Pma);
DicConsole.WriteLine("PMA:\n{0}", PMA.Prettify(scsiInfo.Pma));
}
if (scsiInfo.CdTextLeadIn != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_cdtext.bin", "SCSI READ TOC/PMA/ATIP",
scsiInfo.CdTextLeadIn);
if (scsiInfo.DecodedCdTextLeadIn.HasValue)
{
DicConsole.WriteLine("CD-TEXT on Lead-In:\n{0}",
CDTextOnLeadIn.Prettify(scsiInfo.DecodedCdTextLeadIn));
}
}
if (!string.IsNullOrEmpty(scsiInfo.Mcn))
{
DicConsole.WriteLine("MCN: {0}", scsiInfo.Mcn);
}
if (scsiInfo.Isrcs != null)
{
foreach (KeyValuePair <byte, string> isrc in scsiInfo.Isrcs)
{
DicConsole.WriteLine("Track's {0} ISRC: {1}", isrc.Key, isrc.Value);
}
}
if (scsiInfo.XboxSecuritySector != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_xbox_ss.bin", "KREON EXTRACT SS",
scsiInfo.XboxSecuritySector);
}
if (scsiInfo.DecodedXboxSecuritySector.HasValue)
{
DicConsole.WriteLine("Xbox Security Sector:\n{0}", SS.Prettify(scsiInfo.DecodedXboxSecuritySector));
}
if (scsiInfo.XgdInfo != null)
{
DicConsole.WriteLine("Video layer 0 size: {0} sectors", scsiInfo.XgdInfo.L0Video);
DicConsole.WriteLine("Video layer 1 size: {0} sectors", scsiInfo.XgdInfo.L1Video);
DicConsole.WriteLine("Middle zone size: {0} sectors", scsiInfo.XgdInfo.MiddleZone);
DicConsole.WriteLine("Game data size: {0} sectors", scsiInfo.XgdInfo.GameSize);
DicConsole.WriteLine("Total size: {0} sectors", scsiInfo.XgdInfo.TotalSize);
DicConsole.WriteLine("Real layer break: {0}", scsiInfo.XgdInfo.LayerBreak);
DicConsole.WriteLine();
}
}
if (scsiInfo.MediaSerialNumber != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_mediaserialnumber.bin",
"SCSI READ MEDIA SERIAL NUMBER", scsiInfo.MediaSerialNumber);
DicConsole.Write("Media Serial Number: ");
for (int i = 4; i < scsiInfo.MediaSerialNumber.Length; i++)
{
DicConsole.Write("{0:X2}", scsiInfo.MediaSerialNumber[i]);
}
DicConsole.WriteLine();
}
DicConsole.WriteLine("Media identified as {0}", scsiInfo.MediaType);
Core.Statistics.AddMedia(scsiInfo.MediaType, true);
}
// TODO: More graphically aware decoders
void OnCmbTagSelectedIndexChanged(object sender, EventArgs e)
{
if (!(cmbTag.SelectedValue is MediaTagWithData tagWithData))
{
return;
}
// TODO: Decoders should be able to handle tags with/without length header
txtPrintHex.Text = PrintHex.ByteArrayToHexArrayString(tagWithData.Data, HEX_COLUMNS);
tabDecoded.Visible = true;
switch (tagWithData.Tag)
{
case MediaTagType.CD_TOC:
txtDecoded.Text = TOC.Prettify(tagWithData.Data);
break;
case MediaTagType.CD_SessionInfo:
txtDecoded.Text = Session.Prettify(tagWithData.Data);
break;
case MediaTagType.CD_FullTOC:
txtDecoded.Text = FullTOC.Prettify(tagWithData.Data);
break;
case MediaTagType.CD_PMA:
txtDecoded.Text = PMA.Prettify(tagWithData.Data);
break;
case MediaTagType.CD_ATIP:
txtDecoded.Text = ATIP.Prettify(tagWithData.Data);
break;
case MediaTagType.CD_TEXT:
txtDecoded.Text = CDTextOnLeadIn.Prettify(tagWithData.Data);
break;
case MediaTagType.CD_MCN:
txtDecoded.Text = Encoding.ASCII.GetString(tagWithData.Data);
break;
case MediaTagType.DVD_PFI:
txtDecoded.Text = PFI.Prettify(tagWithData.Data);
break;
case MediaTagType.DVD_CMI:
txtDecoded.Text = CSS_CPRM.PrettifyLeadInCopyright(tagWithData.Data);
break;
case MediaTagType.DVDRAM_DDS:
txtDecoded.Text = DDS.Prettify(tagWithData.Data);
break;
case MediaTagType.DVDRAM_SpareArea:
txtDecoded.Text = Spare.Prettify(tagWithData.Data);
break;
case MediaTagType.DVDR_PFI:
txtDecoded.Text = PFI.Prettify(tagWithData.Data);
break;
case MediaTagType.HDDVD_MediumStatus:
txtDecoded.Text = PFI.Prettify(tagWithData.Data);
break;
case MediaTagType.BD_DI:
txtDecoded.Text = DI.Prettify(tagWithData.Data);
break;
case MediaTagType.BD_BCA:
txtDecoded.Text = BCA.Prettify(tagWithData.Data);
break;
case MediaTagType.BD_DDS:
txtDecoded.Text = Decoders.Bluray.DDS.Prettify(tagWithData.Data);
break;
case MediaTagType.BD_CartridgeStatus:
txtDecoded.Text = Cartridge.Prettify(tagWithData.Data);
break;
case MediaTagType.BD_SpareArea:
txtDecoded.Text = Decoders.Bluray.Spare.Prettify(tagWithData.Data);
break;
case MediaTagType.MMC_WriteProtection:
txtDecoded.Text = WriteProtect.PrettifyWriteProtectionStatus(tagWithData.Data);
break;
case MediaTagType.MMC_DiscInformation:
txtDecoded.Text = DiscInformation.Prettify(tagWithData.Data);
break;
case MediaTagType.SCSI_INQUIRY:
txtDecoded.Text = Inquiry.Prettify(tagWithData.Data);
break;
case MediaTagType.SCSI_MODEPAGE_2A:
txtDecoded.Text = Modes.PrettifyModePage_2A(tagWithData.Data);
break;
case MediaTagType.ATA_IDENTIFY:
case MediaTagType.ATAPI_IDENTIFY:
txtDecoded.Text = Identify.Prettify(tagWithData.Data);
break;
case MediaTagType.Xbox_SecuritySector:
txtDecoded.Text = SS.Prettify(tagWithData.Data);
break;
case MediaTagType.SCSI_MODESENSE_6:
txtDecoded.Text = Modes.PrettifyModeHeader6(tagWithData.Data, PeripheralDeviceTypes.DirectAccess);
break;
case MediaTagType.SCSI_MODESENSE_10:
txtDecoded.Text = Modes.PrettifyModeHeader10(tagWithData.Data, PeripheralDeviceTypes.DirectAccess);
break;
case MediaTagType.Xbox_DMI:
txtDecoded.Text = DMI.IsXbox360(tagWithData.Data)
? DMI.PrettifyXbox360(tagWithData.Data)
: DMI.PrettifyXbox(tagWithData.Data);
break;
default:
tabDecoded.Visible = false;
break;
}
}
/// <summary>Dumps an optical disc</summary>
void Mmc()
{
MediaType dskType = MediaType.Unknown;
bool sense;
byte[] tmpBuf;
bool compactDisc = true;
bool gotConfiguration = false;
bool isXbox = false;
DVDDecryption dvdDecrypt = null;
_speedMultiplier = 1;
// TODO: Log not only what is it reading, but if it was read correctly or not.
sense = _dev.GetConfiguration(out byte[] cmdBuf, out _, 0, MmcGetConfigurationRt.Current, _dev.Timeout,
out _);
if (!sense)
{
gotConfiguration = true;
Features.SeparatedFeatures ftr = Features.Separate(cmdBuf);
_dumpLog.WriteLine("Device reports current profile is 0x{0:X4}", ftr.CurrentProfile);
switch (ftr.CurrentProfile)
{
case 0x0001:
dskType = MediaType.GENERIC_HDD;
_speedMultiplier = -1;
goto default;
case 0x0002:
dskType = MediaType.PD650;
_speedMultiplier = -1;
goto default;
case 0x0005:
dskType = MediaType.CDMO;
break;
case 0x0008:
dskType = MediaType.CD;
break;
case 0x0009:
dskType = MediaType.CDR;
break;
case 0x000A:
dskType = MediaType.CDRW;
break;
case 0x0010:
dskType = MediaType.DVDROM;
_speedMultiplier = 9;
goto default;
case 0x0011:
dskType = MediaType.DVDR;
_speedMultiplier = 9;
goto default;
case 0x0012:
dskType = MediaType.DVDRAM;
_speedMultiplier = 9;
goto default;
case 0x0013:
case 0x0014:
dskType = MediaType.DVDRW;
_speedMultiplier = 9;
goto default;
case 0x0015:
case 0x0016:
dskType = MediaType.DVDRDL;
_speedMultiplier = 9;
goto default;
case 0x0017:
dskType = MediaType.DVDRWDL;
_speedMultiplier = 9;
goto default;
case 0x0018:
dskType = MediaType.DVDDownload;
_speedMultiplier = 9;
goto default;
case 0x001A:
dskType = MediaType.DVDPRW;
_speedMultiplier = 9;
goto default;
case 0x001B:
dskType = MediaType.DVDPR;
_speedMultiplier = 9;
goto default;
case 0x0020:
dskType = MediaType.DDCD;
goto default;
case 0x0021:
dskType = MediaType.DDCDR;
goto default;
case 0x0022:
dskType = MediaType.DDCDRW;
goto default;
case 0x002A:
dskType = MediaType.DVDPRWDL;
_speedMultiplier = 9;
goto default;
case 0x002B:
dskType = MediaType.DVDPRDL;
_speedMultiplier = 9;
goto default;
case 0x0040:
dskType = MediaType.BDROM;
_speedMultiplier = 30;
goto default;
case 0x0041:
case 0x0042:
dskType = MediaType.BDR;
_speedMultiplier = 30;
goto default;
case 0x0043:
dskType = MediaType.BDRE;
_speedMultiplier = 30;
goto default;
case 0x0050:
dskType = MediaType.HDDVDROM;
_speedMultiplier = 30;
goto default;
case 0x0051:
dskType = MediaType.HDDVDR;
_speedMultiplier = 30;
goto default;
case 0x0052:
dskType = MediaType.HDDVDRAM;
_speedMultiplier = 30;
goto default;
case 0x0053:
dskType = MediaType.HDDVDRW;
_speedMultiplier = 30;
goto default;
case 0x0058:
dskType = MediaType.HDDVDRDL;
_speedMultiplier = 30;
goto default;
case 0x005A:
dskType = MediaType.HDDVDRWDL;
_speedMultiplier = 30;
goto default;
default:
compactDisc = false;
break;
}
}
Modes.DecodedMode?decMode = null;
sense = _dev.ModeSense6(out cmdBuf, out _, true, ScsiModeSensePageControl.Current, 0x00, _dev.Timeout,
out _);
if (sense || _dev.Error)
{
sense = _dev.ModeSense6(out cmdBuf, out _, false, ScsiModeSensePageControl.Current, 0x00, _dev.Timeout,
out _);
if (!sense &&
!_dev.Error)
{
decMode = Modes.DecodeMode6(cmdBuf, PeripheralDeviceTypes.MultiMediaDevice);
}
}
else
{
decMode = Modes.DecodeMode6(cmdBuf, PeripheralDeviceTypes.MultiMediaDevice);
}
if (decMode is null)
{
sense = _dev.ModeSense10(out cmdBuf, out _, false, true, ScsiModeSensePageControl.Current, 0x3F, 0x00,
_dev.Timeout, out _);
if (sense || _dev.Error)
{
sense = _dev.ModeSense10(out cmdBuf, out _, false, false, ScsiModeSensePageControl.Current, 0x3F,
0x00, _dev.Timeout, out _);
if (sense || _dev.Error)
{
sense = _dev.ModeSense10(out cmdBuf, out _, false, true, ScsiModeSensePageControl.Current, 0x00,
0x00, _dev.Timeout, out _);
if (sense || _dev.Error)
{
sense = _dev.ModeSense10(out cmdBuf, out _, false, false, ScsiModeSensePageControl.Current,
0x00, 0x00, _dev.Timeout, out _);
if (!sense &&
!_dev.Error)
{
decMode = Modes.DecodeMode10(cmdBuf, PeripheralDeviceTypes.MultiMediaDevice);
}
}
else
{
decMode = Modes.DecodeMode10(cmdBuf, PeripheralDeviceTypes.MultiMediaDevice);
}
}
else
{
decMode = Modes.DecodeMode10(cmdBuf, PeripheralDeviceTypes.MultiMediaDevice);
}
}
else
{
decMode = Modes.DecodeMode10(cmdBuf, PeripheralDeviceTypes.MultiMediaDevice);
}
}
if (decMode.HasValue &&
_dev.IsUsb &&
!gotConfiguration &&
(decMode.Value.Header.MediumType == MediumTypes.UnknownBlockDevice ||
decMode.Value.Header.MediumType == MediumTypes.ReadOnlyBlockDevice ||
decMode.Value.Header.MediumType == MediumTypes.ReadWriteBlockDevice))
{
_speedMultiplier = -1;
Sbc(null, MediaType.Unknown, false);
return;
}
if (compactDisc)
{
_speedMultiplier *= 177;
CompactDisc();
return;
}
_speedMultiplier *= 150;
var scsiReader = new Reader(_dev, _dev.Timeout, null, _errorLog, _dumpRaw);
ulong blocks = scsiReader.GetDeviceBlocks();
_dumpLog.WriteLine("Device reports disc has {0} blocks", blocks);
Dictionary <MediaTagType, byte[]> mediaTags = new Dictionary <MediaTagType, byte[]>();
if (dskType == MediaType.PD650)
{
switch (blocks + 1)
{
case 1281856:
dskType = MediaType.PD650_WORM;
break;
case 58620544:
dskType = MediaType.REV120;
break;
case 17090880:
dskType = MediaType.REV35;
break;
case 34185728:
dskType = MediaType.REV70;
break;
}
}
#region Nintendo
switch (dskType)
{
case MediaType.Unknown when blocks > 0:
_dumpLog.WriteLine("Reading Physical Format Information");
sense = _dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.PhysicalInformation, 0, _dev.Timeout, out _);
if (!sense)
{
PFI.PhysicalFormatInformation?nintendoPfi = PFI.Decode(cmdBuf);
if (nintendoPfi?.DiskCategory == DiskCategory.Nintendo &&
nintendoPfi.Value.PartVersion == 15)
{
_dumpLog.WriteLine("Dumping Nintendo GameCube or Wii discs is not yet implemented.");
StoppingErrorMessage?.
Invoke("Dumping Nintendo GameCube or Wii discs is not yet implemented.");
return;
}
}
break;
case MediaType.DVDDownload:
case MediaType.DVDPR:
case MediaType.DVDPRDL:
case MediaType.DVDPRW:
case MediaType.DVDPRWDL:
case MediaType.DVDR:
case MediaType.DVDRAM:
case MediaType.DVDRDL:
case MediaType.DVDROM:
case MediaType.DVDRW:
case MediaType.DVDRWDL:
case MediaType.HDDVDR:
case MediaType.HDDVDRAM:
case MediaType.HDDVDRDL:
case MediaType.HDDVDROM:
case MediaType.HDDVDRW:
case MediaType.HDDVDRWDL:
_dumpLog.WriteLine("Reading Physical Format Information");
sense = _dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.PhysicalInformation, 0, _dev.Timeout, out _);
if (!sense)
{
if (PFI.Decode(cmdBuf).HasValue)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVD_PFI, tmpBuf);
PFI.PhysicalFormatInformation decPfi = PFI.Decode(cmdBuf).Value;
UpdateStatus?.Invoke($"PFI:\n{PFI.Prettify(decPfi)}");
// False book types
switch (decPfi.DiskCategory)
{
case DiskCategory.DVDPR:
dskType = MediaType.DVDPR;
break;
case DiskCategory.DVDPRDL:
dskType = MediaType.DVDPRDL;
break;
case DiskCategory.DVDPRW:
dskType = MediaType.DVDPRW;
break;
case DiskCategory.DVDPRWDL:
dskType = MediaType.DVDPRWDL;
break;
case DiskCategory.DVDR:
dskType = decPfi.PartVersion >= 6 ? MediaType.DVDRDL : MediaType.DVDR;
break;
case DiskCategory.DVDRAM:
dskType = MediaType.DVDRAM;
break;
default:
dskType = MediaType.DVDROM;
break;
case DiskCategory.DVDRW:
dskType = decPfi.PartVersion >= 15 ? MediaType.DVDRWDL : MediaType.DVDRW;
break;
case DiskCategory.HDDVDR:
dskType = MediaType.HDDVDR;
break;
case DiskCategory.HDDVDRAM:
dskType = MediaType.HDDVDRAM;
break;
case DiskCategory.HDDVDROM:
dskType = MediaType.HDDVDROM;
break;
case DiskCategory.HDDVDRW:
dskType = MediaType.HDDVDRW;
break;
case DiskCategory.Nintendo:
dskType = decPfi.DiscSize == DVDSize.Eighty ? MediaType.GOD : MediaType.WOD;
break;
case DiskCategory.UMD:
dskType = MediaType.UMD;
break;
}
}
}
_dumpLog.WriteLine("Reading Disc Manufacturing Information");
sense = _dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.DiscManufacturingInformation, 0, _dev.Timeout,
out _);
if (!sense)
{
if (DMI.IsXbox(cmdBuf) ||
DMI.IsXbox360(cmdBuf))
{
if (DMI.IsXbox(cmdBuf))
{
dskType = MediaType.XGD;
}
else if (DMI.IsXbox360(cmdBuf))
{
dskType = MediaType.XGD2;
// All XGD3 all have the same number of blocks
if (blocks + 1 == 25063 || // Locked (or non compatible drive)
blocks + 1 == 4229664 || // Xtreme unlock
blocks + 1 == 4246304) // Wxripper unlock
{
dskType = MediaType.XGD3;
}
}
isXbox = true;
sense = _dev.ScsiInquiry(out byte[] inqBuf, out _);
if (sense ||
!Inquiry.Decode(inqBuf).HasValue ||
(Inquiry.Decode(inqBuf).HasValue&& !Inquiry.Decode(inqBuf).Value.KreonPresent))
{
_dumpLog.WriteLine("Dumping Xbox Game Discs requires a drive with Kreon firmware.");
StoppingErrorMessage?.
Invoke("Dumping Xbox Game Discs requires a drive with Kreon firmware.");
if (!_force)
{
return;
}
isXbox = false;
}
if (_dumpRaw && !_force)
{
StoppingErrorMessage?.
Invoke("Not continuing. If you want to continue reading cooked data when raw is not available use the force option.");
// TODO: Exit more gracefully
return;
}
}
if (cmdBuf.Length == 2052)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVD_DMI, tmpBuf);
}
}
break;
}
#endregion Nintendo
#region All DVD and HD DVD types
#endregion All DVD and HD DVD types
#region DVD-ROM
if (dskType == MediaType.DVDDownload ||
dskType == MediaType.DVDROM)
{
_dumpLog.WriteLine("Reading Lead-in Copyright Information.");
sense = _dev.ReadDiscStructure(out cmdBuf, out _, MmcDiscStructureMediaType.Dvd, 0, 0,
MmcDiscStructureFormat.CopyrightInformation, 0, _dev.Timeout, out _);
if (!sense)
{
if (CSS_CPRM.DecodeLeadInCopyright(cmdBuf).HasValue)
{
tmpBuf = new byte[cmdBuf.Length - 4];
Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
mediaTags.Add(MediaTagType.DVD_CMI, tmpBuf);
CSS_CPRM.LeadInCopyright?cmi = CSS_CPRM.DecodeLeadInCopyright(cmdBuf);
if (cmi !.Value.CopyrightType == CopyrightType.NoProtection)
{
UpdateStatus?.Invoke("Drive reports no copy protection on disc.");
}
else
{
if (!Settings.Settings.Current.EnableDecryption)
{
UpdateStatus?.Invoke("Drive reports the disc uses copy protection. " +
"The dump will be incorrect unless decryption is enabled.");
}
else
{
if (cmi !.Value.CopyrightType == CopyrightType.CSS)
{
UpdateStatus?.Invoke("Drive reports disc uses CSS copy protection.");
dvdDecrypt = new DVDDecryption(_dev);
sense = dvdDecrypt.ReadBusKey(out cmdBuf, out _,
CSS_CPRM.DecodeLeadInCopyright(cmdBuf) !.Value.
CopyrightType, _dev.Timeout, out _);
if (!sense)
{
byte[] busKey = cmdBuf;
UpdateStatus?.Invoke("Reading disc key.");
sense = dvdDecrypt.ReadDiscKey(out cmdBuf, out _, _dev.Timeout, out _);
if (!sense)
{
CSS_CPRM.DiscKey?decodedDiscKey = CSS.DecodeDiscKey(cmdBuf, busKey);
sense = dvdDecrypt.ReadAsf(out cmdBuf, out _,
DvdCssKeyClass.DvdCssCppmOrCprm, _dev.Timeout,
out _);
if (!sense)
{
if (cmdBuf[7] == 1)
{
UpdateStatus?.Invoke("Disc and drive authentication succeeded.");
sense = dvdDecrypt.ReadRpc(out cmdBuf, out _,
DvdCssKeyClass.DvdCssCppmOrCprm,
_dev.Timeout, out _);
if (!sense)
{
CSS_CPRM.RegionalPlaybackControlState?rpc =
CSS_CPRM.DecodeRegionalPlaybackControlState(cmdBuf);
if (rpc.HasValue)
{
UpdateStatus?.Invoke(CSS.CheckRegion(rpc.Value, cmi.Value)
? "Disc and drive regions match."
: "Disc and drive regions do not match. The dump will be incorrect");
}
}
if (decodedDiscKey.HasValue)
{
mediaTags.Add(MediaTagType.DVD_DiscKey,
decodedDiscKey.Value.Key);
UpdateStatus?.Invoke("Decrypting disc key.");
CSS.DecryptDiscKey(decodedDiscKey.Value.Key,
out byte[] discKey);
if (discKey != null)
{
UpdateStatus?.Invoke("Decryption of disc key succeeded.");
mediaTags.Add(MediaTagType.DVD_DiscKey_Decrypted, discKey);
}
else
{
UpdateStatus?.Invoke("Decryption of disc key failed.");
}
}
}
}
}
}
}
else
{
UpdateStatus?.
Invoke($"Drive reports disc uses {CSS_CPRM.DecodeLeadInCopyright(cmdBuf)!.Value.CopyrightType.ToString()} copy protection. " +
"This is not yet supported and the dump will be incorrect.");
}
}
}
static void DoScsiMediaInfo(bool debug, string outputPrefix, Devices.Device dev)
{
var scsiInfo = new ScsiInfo(dev);
if (!scsiInfo.MediaInserted)
{
return;
}
if (scsiInfo.DeviceInfo.ScsiModeSense6 != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_scsi_modesense6.bin", "SCSI MODE SENSE (6)",
scsiInfo.DeviceInfo.ScsiModeSense6);
}
if (scsiInfo.DeviceInfo.ScsiModeSense10 != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_scsi_modesense10.bin", "SCSI MODE SENSE (10)",
scsiInfo.DeviceInfo.ScsiModeSense10);
}
switch (dev.ScsiType)
{
case PeripheralDeviceTypes.DirectAccess:
case PeripheralDeviceTypes.MultiMediaDevice:
case PeripheralDeviceTypes.OCRWDevice:
case PeripheralDeviceTypes.OpticalDevice:
case PeripheralDeviceTypes.SimplifiedDevice:
case PeripheralDeviceTypes.WriteOnceDevice:
case PeripheralDeviceTypes.BridgingExpander
when dev.Model.StartsWith("MDM", StringComparison.Ordinal) ||
dev.Model.StartsWith("MDH", StringComparison.Ordinal):
if (scsiInfo.ReadCapacity != null)
DataFile.WriteTo("Media-Info command", outputPrefix, "_readcapacity.bin", "SCSI READ CAPACITY",
scsiInfo.ReadCapacity);
if (scsiInfo.ReadCapacity16 != null)
DataFile.WriteTo("Media-Info command", outputPrefix, "_readcapacity16.bin",
"SCSI READ CAPACITY(16)", scsiInfo.ReadCapacity16);
if (scsiInfo.Blocks != 0 &&
scsiInfo.BlockSize != 0)
{
ulong totalSize = scsiInfo.Blocks * scsiInfo.BlockSize;
if (totalSize > 1099511627776)
{
AaruConsole.WriteLine("Media has {0} blocks of {1} bytes/each. (for a total of {2:F3} TiB)",
scsiInfo.Blocks, scsiInfo.BlockSize, totalSize / 1099511627776d);
}
else if (totalSize > 1073741824)
{
AaruConsole.WriteLine("Media has {0} blocks of {1} bytes/each. (for a total of {2:F3} GiB)",
scsiInfo.Blocks, scsiInfo.BlockSize, totalSize / 1073741824d);
}
else if (totalSize > 1048576)
{
AaruConsole.WriteLine("Media has {0} blocks of {1} bytes/each. (for a total of {2:F3} MiB)",
scsiInfo.Blocks, scsiInfo.BlockSize, totalSize / 1048576d);
}
else if (totalSize > 1024)
{
AaruConsole.WriteLine("Media has {0} blocks of {1} bytes/each. (for a total of {2:F3} KiB)",
scsiInfo.Blocks, scsiInfo.BlockSize, totalSize / 1024d);
}
else
{
AaruConsole.WriteLine("Media has {0} blocks of {1} bytes/each. (for a total of {2} bytes)",
scsiInfo.Blocks, scsiInfo.BlockSize, totalSize);
}
}
break;
case PeripheralDeviceTypes.SequentialAccess:
if (scsiInfo.DensitySupport != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_ssc_reportdensitysupport_media.bin",
"SSC REPORT DENSITY SUPPORT (MEDIA)", scsiInfo.DensitySupport);
if (scsiInfo.DensitySupportHeader.HasValue)
{
AaruConsole.WriteLine("Densities supported by currently inserted media:");
AaruConsole.WriteLine(DensitySupport.PrettifyDensity(scsiInfo.DensitySupportHeader));
}
}
if (scsiInfo.MediaTypeSupport != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix,
"_ssc_reportdensitysupport_medium_media.bin",
"SSC REPORT DENSITY SUPPORT (MEDIUM & MEDIA)", scsiInfo.MediaTypeSupport);
if (scsiInfo.MediaTypeSupportHeader.HasValue)
{
AaruConsole.WriteLine("Medium types currently inserted in device:");
AaruConsole.WriteLine(DensitySupport.PrettifyMediumType(scsiInfo.MediaTypeSupportHeader));
}
AaruConsole.WriteLine(DensitySupport.PrettifyMediumType(scsiInfo.MediaTypeSupport));
}
break;
}
if (dev.ScsiType == PeripheralDeviceTypes.MultiMediaDevice)
{
if (scsiInfo.MmcConfiguration != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_getconfiguration_current.bin",
"SCSI GET CONFIGURATION", scsiInfo.MmcConfiguration);
}
if (scsiInfo.RecognizedFormatLayers != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_formatlayers.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.RecognizedFormatLayers);
}
if (scsiInfo.WriteProtectionStatus != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_writeprotection.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.WriteProtectionStatus);
}
if (scsiInfo.DvdPfi != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_pfi.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdPfi);
if (scsiInfo.DecodedPfi.HasValue)
{
AaruConsole.WriteLine("PFI:\n{0}", PFI.Prettify(scsiInfo.DecodedPfi));
}
}
if (scsiInfo.DvdDmi != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_dmi.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdDmi);
if (DMI.IsXbox(scsiInfo.DvdDmi))
{
AaruConsole.WriteLine("Xbox DMI:\n{0}", DMI.PrettifyXbox(scsiInfo.DvdDmi));
}
else if (DMI.IsXbox360(scsiInfo.DvdDmi))
{
AaruConsole.WriteLine("Xbox 360 DMI:\n{0}", DMI.PrettifyXbox360(scsiInfo.DvdDmi));
}
}
if (scsiInfo.DvdCmi != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_cmi.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdCmi);
AaruConsole.WriteLine("Lead-In CMI:\n{0}", CSS_CPRM.PrettifyLeadInCopyright(scsiInfo.DvdCmi));
}
if (scsiInfo.DvdDiscKey != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_disckey.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdDiscKey);
}
if (scsiInfo.DvdSectorCmi != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_sectorcmi.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdSectorCmi);
}
if (scsiInfo.DvdBca != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_bca.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdBca);
}
if (scsiInfo.DvdAacs != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_aacs.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdAacs);
}
if (scsiInfo.DvdRamDds != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvdram_dds.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdRamDds);
AaruConsole.WriteLine("Disc Definition Structure:\n{0}", DDS.Prettify(scsiInfo.DvdRamDds));
}
if (scsiInfo.DvdRamCartridgeStatus != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvdram_status.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdRamCartridgeStatus);
AaruConsole.WriteLine("Medium Status:\n{0}", Cartridge.Prettify(scsiInfo.DvdRamCartridgeStatus));
}
if (scsiInfo.DvdRamSpareArea != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvdram_spare.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdRamSpareArea);
AaruConsole.WriteLine("Spare Area Information:\n{0}", Spare.Prettify(scsiInfo.DvdRamSpareArea));
}
if (scsiInfo.LastBorderOutRmd != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_lastrmd.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.LastBorderOutRmd);
}
if (scsiInfo.DvdPreRecordedInfo != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_pri.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdPreRecordedInfo);
if (scsiInfo.DecodedDvdPrePitInformation.HasValue)
{
AaruConsole.WriteLine("DVD-R(W) Pre-Recorded Information:\n{0}",
PRI.Prettify(scsiInfo.DecodedDvdPrePitInformation));
}
}
if (scsiInfo.DvdrMediaIdentifier != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvdr_mediaid.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdrMediaIdentifier);
}
if (scsiInfo.DvdrPhysicalInformation != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvdr_pfi.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdrPhysicalInformation);
if (scsiInfo.DecodedDvdrPfi.HasValue)
{
AaruConsole.WriteLine("DVD-R(W) PFI:\n{0}", PFI.Prettify(scsiInfo.DecodedDvdrPfi));
}
}
if (scsiInfo.DvdPlusAdip != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd+_adip.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdPlusAdip);
}
if (scsiInfo.DvdPlusDcb != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd+_dcb.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdPlusDcb);
}
if (scsiInfo.HddvdCopyrightInformation != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_hddvd_cmi.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.HddvdCopyrightInformation);
}
if (scsiInfo.HddvdrMediumStatus != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_hddvdr_status.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.HddvdrMediumStatus);
}
if (scsiInfo.HddvdrLastRmd != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_hddvdr_lastrmd.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.HddvdrLastRmd);
}
if (scsiInfo.DvdrLayerCapacity != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvdr_layercap.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdrLayerCapacity);
}
if (scsiInfo.DvdrDlMiddleZoneStart != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_mzs.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdrDlMiddleZoneStart);
}
if (scsiInfo.DvdrDlJumpIntervalSize != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_jis.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdrDlJumpIntervalSize);
}
if (scsiInfo.DvdrDlManualLayerJumpStartLba != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_manuallj.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdrDlManualLayerJumpStartLba);
}
if (scsiInfo.DvdrDlRemapAnchorPoint != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_remapanchor.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.DvdrDlRemapAnchorPoint);
}
if (scsiInfo.BlurayDiscInformation != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_bd_di.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.BlurayDiscInformation);
AaruConsole.WriteLine("Blu-ray Disc Information:\n{0}",
DI.Prettify(scsiInfo.BlurayDiscInformation));
}
if (scsiInfo.BlurayPac != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_bd_pac.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.BlurayPac);
}
if (scsiInfo.BlurayBurstCuttingArea != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_bd_bca.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.BlurayBurstCuttingArea);
AaruConsole.WriteLine("Blu-ray Burst Cutting Area:\n{0}",
BCA.Prettify(scsiInfo.BlurayBurstCuttingArea));
}
if (scsiInfo.BlurayDds != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_bd_dds.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.BlurayDds);
AaruConsole.WriteLine("Blu-ray Disc Definition Structure:\n{0}",
Decoders.Bluray.DDS.Prettify(scsiInfo.BlurayDds));
}
if (scsiInfo.BlurayCartridgeStatus != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_bd_cartstatus.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.BlurayCartridgeStatus);
AaruConsole.WriteLine("Blu-ray Cartridge Status:\n{0}",
Decoders.Bluray.Cartridge.Prettify(scsiInfo.BlurayCartridgeStatus));
}
if (scsiInfo.BluraySpareAreaInformation != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_bd_spare.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.BluraySpareAreaInformation);
AaruConsole.WriteLine("Blu-ray Spare Area Information:\n{0}",
Decoders.Bluray.Spare.Prettify(scsiInfo.BluraySpareAreaInformation));
}
if (scsiInfo.BlurayRawDfl != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_bd_dfl.bin",
"SCSI READ DISC STRUCTURE", scsiInfo.BlurayRawDfl);
}
if (scsiInfo.BlurayTrackResources != null)
{
AaruConsole.WriteLine("Track Resources Information:\n{0}",
DiscInformation.Prettify(scsiInfo.BlurayTrackResources));
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscinformation_001b.bin",
"SCSI READ DISC INFORMATION", scsiInfo.BlurayTrackResources);
}
if (scsiInfo.BlurayPowResources != null)
{
AaruConsole.WriteLine("POW Resources Information:\n{0}",
DiscInformation.Prettify(scsiInfo.BlurayPowResources));
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscinformation_010b.bin",
"SCSI READ DISC INFORMATION", scsiInfo.BlurayPowResources);
}
if (scsiInfo.Toc != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_toc.bin", "SCSI READ TOC/PMA/ATIP",
scsiInfo.Toc);
if (scsiInfo.DecodedToc.HasValue)
{
AaruConsole.WriteLine("TOC:\n{0}", TOC.Prettify(scsiInfo.DecodedToc));
}
}
if (scsiInfo.Atip != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_atip.bin", "SCSI READ TOC/PMA/ATIP",
scsiInfo.Atip);
if (scsiInfo.DecodedAtip != null)
{
AaruConsole.WriteLine("ATIP:\n{0}", ATIP.Prettify(scsiInfo.DecodedAtip));
}
}
if (scsiInfo.DiscInformation != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscinformation_000b.bin",
"SCSI READ DISC INFORMATION", scsiInfo.DiscInformation);
if (scsiInfo.DecodedDiscInformation.HasValue)
{
AaruConsole.WriteLine("Standard Disc Information:\n{0}",
DiscInformation.Prettify000b(scsiInfo.DecodedDiscInformation));
}
}
if (scsiInfo.Session != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_session.bin", "SCSI READ TOC/PMA/ATIP",
scsiInfo.Session);
if (scsiInfo.DecodedSession.HasValue)
{
AaruConsole.WriteLine("Session information:\n{0}", Session.Prettify(scsiInfo.DecodedSession));
}
}
if (scsiInfo.RawToc != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_rawtoc.bin", "SCSI READ TOC/PMA/ATIP",
scsiInfo.RawToc);
if (scsiInfo.FullToc.HasValue)
{
AaruConsole.WriteLine("Raw TOC:\n{0}", FullTOC.Prettify(scsiInfo.RawToc));
}
}
if (scsiInfo.Pma != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_pma.bin", "SCSI READ TOC/PMA/ATIP",
scsiInfo.Pma);
AaruConsole.WriteLine("PMA:\n{0}", PMA.Prettify(scsiInfo.Pma));
}
if (scsiInfo.CdTextLeadIn != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_cdtext.bin", "SCSI READ TOC/PMA/ATIP",
scsiInfo.CdTextLeadIn);
if (scsiInfo.DecodedCdTextLeadIn.HasValue)
{
AaruConsole.WriteLine("CD-TEXT on Lead-In:\n{0}",
CDTextOnLeadIn.Prettify(scsiInfo.DecodedCdTextLeadIn));
}
}
if (!string.IsNullOrEmpty(scsiInfo.Mcn))
{
AaruConsole.WriteLine("MCN: {0}", scsiInfo.Mcn);
}
if (scsiInfo.Isrcs != null)
{
foreach (KeyValuePair <byte, string> isrc in scsiInfo.Isrcs)
{
AaruConsole.WriteLine("Track's {0} ISRC: {1}", isrc.Key, isrc.Value);
}
}
if (scsiInfo.XboxSecuritySector != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_xbox_ss.bin", "KREON EXTRACT SS",
scsiInfo.XboxSecuritySector);
}
if (scsiInfo.DecodedXboxSecuritySector.HasValue)
{
AaruConsole.WriteLine("Xbox Security Sector:\n{0}",
SS.Prettify(scsiInfo.DecodedXboxSecuritySector));
}
if (scsiInfo.XgdInfo != null)
{
AaruConsole.WriteLine("Video layer 0 size: {0} sectors", scsiInfo.XgdInfo.L0Video);
AaruConsole.WriteLine("Video layer 1 size: {0} sectors", scsiInfo.XgdInfo.L1Video);
AaruConsole.WriteLine("Middle zone size: {0} sectors", scsiInfo.XgdInfo.MiddleZone);
AaruConsole.WriteLine("Game data size: {0} sectors", scsiInfo.XgdInfo.GameSize);
AaruConsole.WriteLine("Total size: {0} sectors", scsiInfo.XgdInfo.TotalSize);
AaruConsole.WriteLine("Real layer break: {0}", scsiInfo.XgdInfo.LayerBreak);
AaruConsole.WriteLine();
}
}
if (scsiInfo.MediaSerialNumber != null)
{
DataFile.WriteTo("Media-Info command", outputPrefix, "_mediaserialnumber.bin",
"SCSI READ MEDIA SERIAL NUMBER", scsiInfo.MediaSerialNumber);
AaruConsole.Write("Media Serial Number: ");
for (int i = 4; i < scsiInfo.MediaSerialNumber.Length; i++)
{
AaruConsole.Write("{0:X2}", scsiInfo.MediaSerialNumber[i]);
}
AaruConsole.WriteLine();
}
AaruConsole.WriteLine("Media identified as {0}", scsiInfo.MediaType);
Statistics.AddMedia(scsiInfo.MediaType, true);
if (scsiInfo.Toc != null ||
scsiInfo.RawToc != null)
{
Track[] tracks = Dump.GetCdTracks(dev, null, false, out long lastSector, null, null, null, out _, null,
null);
if (tracks != null)
{
uint firstLba = (uint)tracks.Min(t => t.TrackStartSector);
bool supportsPqSubchannel = Dump.SupportsPqSubchannel(dev, null, null, firstLba);
bool supportsRwSubchannel = Dump.SupportsRwSubchannel(dev, null, null, firstLba);
// Open main database
var ctx = AaruContext.Create(Settings.Settings.MainDbPath);
// Search for device in main database
Aaru.Database.Models.Device dbDev =
ctx.Devices.FirstOrDefault(d => d.Manufacturer == dev.Manufacturer && d.Model == dev.Model &&
d.Revision == dev.FirmwareRevision);
Dump.SolveTrackPregaps(dev, null, null, tracks, supportsPqSubchannel, supportsRwSubchannel, dbDev,
out bool inexactPositioning, false);
for (int t = 1; t < tracks.Length; t++)
{
tracks[t - 1].TrackEndSector = tracks[t].TrackStartSector - 1;
}
tracks[^ 1].TrackEndSector = (ulong)lastSector;
