mirror of
https://github.com/aaru-dps/Aaru.git
synced 2025-12-16 19:24:25 +00:00
1387 lines
80 KiB
C#
1387 lines
80 KiB
C#
// /***************************************************************************
|
|
// The Disc Image Chef
|
|
// ----------------------------------------------------------------------------
|
|
//
|
|
// Filename : MediaInfo.cs
|
|
// Author(s) : Natalia Portillo <claunia@claunia.com>
|
|
//
|
|
// Component : Verbs.
|
|
//
|
|
// --[ Description ] ----------------------------------------------------------
|
|
//
|
|
// Implements the 'media-info' verb.
|
|
//
|
|
// --[ License ] --------------------------------------------------------------
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as
|
|
// published by the Free Software Foundation, either version 3 of the
|
|
// License, or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
// Copyright © 2011-2018 Natalia Portillo
|
|
// ****************************************************************************/
|
|
|
|
using System;
|
|
using System.Linq;
|
|
using System.Threading;
|
|
using DiscImageChef.CommonTypes;
|
|
using DiscImageChef.Console;
|
|
using DiscImageChef.Core;
|
|
using DiscImageChef.Decoders.Bluray;
|
|
using DiscImageChef.Decoders.CD;
|
|
using DiscImageChef.Decoders.DVD;
|
|
using DiscImageChef.Decoders.SCSI;
|
|
using DiscImageChef.Decoders.SCSI.MMC;
|
|
using DiscImageChef.Decoders.SCSI.SSC;
|
|
using DiscImageChef.Decoders.Xbox;
|
|
using DiscImageChef.Devices;
|
|
using BCA = DiscImageChef.Decoders.Bluray.BCA;
|
|
using Cartridge = DiscImageChef.Decoders.DVD.Cartridge;
|
|
using DDS = DiscImageChef.Decoders.DVD.DDS;
|
|
using DMI = DiscImageChef.Decoders.Xbox.DMI;
|
|
using Spare = DiscImageChef.Decoders.DVD.Spare;
|
|
|
|
namespace DiscImageChef.Commands
|
|
{
|
|
static class MediaInfo
|
|
{
|
|
internal static void DoMediaInfo(MediaInfoOptions options)
|
|
{
|
|
DicConsole.DebugWriteLine("Media-Info command", "--debug={0}", options.Debug);
|
|
DicConsole.DebugWriteLine("Media-Info command", "--verbose={0}", options.Verbose);
|
|
DicConsole.DebugWriteLine("Media-Info command", "--device={0}", options.DevicePath);
|
|
DicConsole.DebugWriteLine("Media-Info command", "--output-prefix={0}", options.OutputPrefix);
|
|
|
|
if(options.DevicePath.Length == 2 && options.DevicePath[1] == ':' && options.DevicePath[0] != '/' &&
|
|
char.IsLetter(options.DevicePath[0]))
|
|
options.DevicePath = "\\\\.\\" + char.ToUpper(options.DevicePath[0]) + ':';
|
|
|
|
Device dev = new Device(options.DevicePath);
|
|
|
|
if(dev.Error)
|
|
{
|
|
DicConsole.ErrorWriteLine("Error {0} opening device.", dev.LastError);
|
|
return;
|
|
}
|
|
|
|
Core.Statistics.AddDevice(dev);
|
|
|
|
switch(dev.Type)
|
|
{
|
|
case DeviceType.ATA:
|
|
DoAtaMediaInfo();
|
|
break;
|
|
case DeviceType.MMC:
|
|
case DeviceType.SecureDigital:
|
|
DoSdMediaInfo();
|
|
break;
|
|
case DeviceType.NVMe:
|
|
DoNvmeMediaInfo(options.OutputPrefix, dev);
|
|
break;
|
|
case DeviceType.ATAPI:
|
|
case DeviceType.SCSI:
|
|
DoScsiMediaInfo(options.OutputPrefix, dev);
|
|
break;
|
|
default: throw new NotSupportedException("Unknown device type.");
|
|
}
|
|
|
|
Core.Statistics.AddCommand("media-info");
|
|
}
|
|
|
|
static void DoAtaMediaInfo()
|
|
{
|
|
DicConsole.ErrorWriteLine("Please use device-info command for ATA devices.");
|
|
}
|
|
|
|
static void DoNvmeMediaInfo(string outputPrefix, Device dev)
|
|
{
|
|
throw new NotImplementedException("NVMe devices not yet supported.");
|
|
}
|
|
|
|
static void DoSdMediaInfo()
|
|
{
|
|
DicConsole.ErrorWriteLine("Please use device-info command for MMC/SD devices.");
|
|
}
|
|
|
|
static void DoScsiMediaInfo(string outputPrefix, Device dev)
|
|
{
|
|
byte[] cmdBuf;
|
|
byte[] senseBuf;
|
|
bool sense;
|
|
MediaType dskType = MediaType.Unknown;
|
|
ulong blocks = 0;
|
|
uint blockSize = 0;
|
|
int resets = 0;
|
|
|
|
if(dev.IsRemovable)
|
|
{
|
|
deviceGotReset:
|
|
sense = dev.ScsiTestUnitReady(out senseBuf, dev.Timeout, out _);
|
|
if(sense)
|
|
{
|
|
FixedSense? decSense = Sense.DecodeFixed(senseBuf);
|
|
if(decSense.HasValue)
|
|
{
|
|
// Just retry, for 5 times
|
|
if(decSense.Value.ASC == 0x29)
|
|
{
|
|
resets++;
|
|
if(resets < 5) goto deviceGotReset;
|
|
}
|
|
|
|
if(decSense.Value.ASC == 0x3A)
|
|
{
|
|
int leftRetries = 5;
|
|
while(leftRetries > 0)
|
|
{
|
|
DicConsole.WriteLine("\rWaiting for drive to become ready");
|
|
Thread.Sleep(2000);
|
|
sense = dev.ScsiTestUnitReady(out senseBuf, dev.Timeout, out _);
|
|
if(!sense) break;
|
|
|
|
leftRetries--;
|
|
}
|
|
|
|
if(sense)
|
|
{
|
|
DicConsole.ErrorWriteLine("Please insert media in drive");
|
|
return;
|
|
}
|
|
}
|
|
else if(decSense.Value.ASC == 0x04 && decSense.Value.ASCQ == 0x01)
|
|
{
|
|
int leftRetries = 10;
|
|
while(leftRetries > 0)
|
|
{
|
|
DicConsole.WriteLine("\rWaiting for drive to become ready");
|
|
Thread.Sleep(2000);
|
|
sense = dev.ScsiTestUnitReady(out senseBuf, dev.Timeout, out _);
|
|
if(!sense) break;
|
|
|
|
leftRetries--;
|
|
}
|
|
|
|
if(sense)
|
|
{
|
|
DicConsole.ErrorWriteLine("Error testing unit was ready:\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DicConsole.ErrorWriteLine("Error testing unit was ready:\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DicConsole.ErrorWriteLine("Unknown testing unit was ready.");
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
Modes.DecodedMode? decMode = null;
|
|
PeripheralDeviceTypes devType = dev.ScsiType;
|
|
|
|
sense = dev.ModeSense10(out byte[] modeBuf, out senseBuf, false, true, ScsiModeSensePageControl.Current,
|
|
0x3F, 0xFF, 5, out _);
|
|
if(sense || dev.Error)
|
|
sense = dev.ModeSense10(out modeBuf, out senseBuf, false, true, ScsiModeSensePageControl.Current, 0x3F,
|
|
0x00, 5, out _);
|
|
|
|
if(!sense && !dev.Error) decMode = Modes.DecodeMode10(modeBuf, devType);
|
|
|
|
if(sense || dev.Error || !decMode.HasValue)
|
|
{
|
|
sense = dev.ModeSense6(out modeBuf, out senseBuf, false, ScsiModeSensePageControl.Current, 0x3F, 0x00,
|
|
5, out _);
|
|
if(sense || dev.Error)
|
|
sense = dev.ModeSense6(out modeBuf, out senseBuf, false, ScsiModeSensePageControl.Current, 0x3F,
|
|
0x00, 5, out _);
|
|
if(sense || dev.Error) sense = dev.ModeSense(out modeBuf, out senseBuf, 5, out _);
|
|
|
|
if(!sense && !dev.Error) decMode = Modes.DecodeMode6(modeBuf, devType);
|
|
}
|
|
|
|
if(!sense)
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_scsi_modesense.bin", "SCSI MODE SENSE", modeBuf);
|
|
|
|
byte scsiMediumType = 0;
|
|
byte scsiDensityCode = 0;
|
|
bool containsFloppyPage = false;
|
|
|
|
if(decMode.HasValue)
|
|
{
|
|
scsiMediumType = (byte)decMode.Value.Header.MediumType;
|
|
if(decMode.Value.Header.BlockDescriptors != null && decMode.Value.Header.BlockDescriptors.Length >= 1)
|
|
scsiDensityCode = (byte)decMode.Value.Header.BlockDescriptors[0].Density;
|
|
|
|
containsFloppyPage =
|
|
decMode.Value.Pages.Aggregate(containsFloppyPage,
|
|
(current, modePage) => current | (modePage.Page == 0x05));
|
|
}
|
|
|
|
switch(dev.ScsiType)
|
|
{
|
|
case PeripheralDeviceTypes.DirectAccess:
|
|
case PeripheralDeviceTypes.MultiMediaDevice:
|
|
case PeripheralDeviceTypes.OCRWDevice:
|
|
case PeripheralDeviceTypes.OpticalDevice:
|
|
case PeripheralDeviceTypes.SimplifiedDevice:
|
|
case PeripheralDeviceTypes.WriteOnceDevice:
|
|
sense = dev.ReadCapacity(out cmdBuf, out senseBuf, dev.Timeout, out _);
|
|
if(!sense)
|
|
{
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readcapacity.bin", "SCSI READ CAPACITY",
|
|
cmdBuf);
|
|
blocks = (ulong)((cmdBuf[0] << 24) + (cmdBuf[1] << 16) + (cmdBuf[2] << 8) + cmdBuf[3]);
|
|
blockSize = (uint)((cmdBuf[5] << 24) + (cmdBuf[5] << 16) + (cmdBuf[6] << 8) + cmdBuf[7]);
|
|
}
|
|
|
|
if(sense || blocks == 0xFFFFFFFF)
|
|
{
|
|
sense = dev.ReadCapacity16(out cmdBuf, out senseBuf, dev.Timeout, out _);
|
|
|
|
if(sense && blocks == 0)
|
|
if(dev.ScsiType != PeripheralDeviceTypes.MultiMediaDevice)
|
|
{
|
|
DicConsole.ErrorWriteLine("Unable to get media capacity");
|
|
DicConsole.ErrorWriteLine("{0}", Sense.PrettifySense(senseBuf));
|
|
}
|
|
|
|
if(!sense)
|
|
{
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readcapacity16.bin",
|
|
"SCSI READ CAPACITY(16)", cmdBuf);
|
|
byte[] temp = new byte[8];
|
|
|
|
Array.Copy(cmdBuf, 0, temp, 0, 8);
|
|
Array.Reverse(temp);
|
|
blocks = BitConverter.ToUInt64(temp, 0);
|
|
blockSize = (uint)((cmdBuf[5] << 24) + (cmdBuf[5] << 16) + (cmdBuf[6] << 8) + cmdBuf[7]);
|
|
}
|
|
}
|
|
|
|
if(blocks != 0 && blockSize != 0)
|
|
{
|
|
blocks++;
|
|
DicConsole.WriteLine("Media has {0} blocks of {1} bytes/each. (for a total of {2} bytes)",
|
|
blocks, blockSize, blocks * blockSize);
|
|
}
|
|
break;
|
|
case PeripheralDeviceTypes.SequentialAccess:
|
|
byte[] medBuf;
|
|
|
|
sense = dev.ReportDensitySupport(out byte[] seqBuf, out senseBuf, false, dev.Timeout, out _);
|
|
if(!sense)
|
|
{
|
|
sense = dev.ReportDensitySupport(out medBuf, out senseBuf, true, dev.Timeout, out _);
|
|
|
|
if(!sense && !seqBuf.SequenceEqual(medBuf))
|
|
{
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_ssc_reportdensitysupport_media.bin",
|
|
"SSC REPORT DENSITY SUPPORT (MEDIA)", seqBuf);
|
|
DensitySupport.DensitySupportHeader? dens = DensitySupport.DecodeDensity(seqBuf);
|
|
if(dens.HasValue)
|
|
{
|
|
DicConsole.WriteLine("Densities supported by currently inserted media:");
|
|
DicConsole.WriteLine(DensitySupport.PrettifyDensity(dens));
|
|
}
|
|
}
|
|
}
|
|
|
|
sense = dev.ReportDensitySupport(out seqBuf, out senseBuf, true, false, dev.Timeout, out _);
|
|
if(!sense)
|
|
{
|
|
sense = dev.ReportDensitySupport(out medBuf, out senseBuf, true, true, dev.Timeout, out _);
|
|
|
|
if(!sense && !seqBuf.SequenceEqual(medBuf))
|
|
{
|
|
DataFile.WriteTo("Media-Info command", outputPrefix,
|
|
"_ssc_reportdensitysupport_medium_media.bin",
|
|
"SSC REPORT DENSITY SUPPORT (MEDIUM & MEDIA)", seqBuf);
|
|
DensitySupport.MediaTypeSupportHeader? meds = DensitySupport.DecodeMediumType(seqBuf);
|
|
if(meds.HasValue)
|
|
{
|
|
DicConsole.WriteLine("Medium types currently inserted in device:");
|
|
DicConsole.WriteLine(DensitySupport.PrettifyMediumType(meds));
|
|
}
|
|
DicConsole.WriteLine(DensitySupport.PrettifyMediumType(seqBuf));
|
|
}
|
|
}
|
|
|
|
// TODO: Get a machine where 16-byte CDBs don't get DID_ABORT
|
|
/*
|
|
sense = dev.ReadAttribute(out seqBuf, out senseBuf, ScsiAttributeAction.List, 0, dev.Timeout, out _);
|
|
if (sense)
|
|
DicConsole.ErrorWriteLine("SCSI READ ATTRIBUTE:\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
|
|
else
|
|
{
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_scsi_readattribute.bin", "SCSI READ ATTRIBUTE", seqBuf);
|
|
}
|
|
*/
|
|
break;
|
|
}
|
|
|
|
if(dev.ScsiType == PeripheralDeviceTypes.MultiMediaDevice)
|
|
{
|
|
sense = dev.GetConfiguration(out cmdBuf, out senseBuf, 0, MmcGetConfigurationRt.Current, dev.Timeout,
|
|
out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ GET CONFIGURATION:\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
{
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_getconfiguration_current.bin",
|
|
"SCSI GET CONFIGURATION", cmdBuf);
|
|
|
|
Features.SeparatedFeatures ftr = Features.Separate(cmdBuf);
|
|
|
|
DicConsole.DebugWriteLine("Media-Info command", "GET CONFIGURATION current profile is {0:X4}h",
|
|
ftr.CurrentProfile);
|
|
|
|
switch(ftr.CurrentProfile)
|
|
{
|
|
case 0x0001:
|
|
dskType = MediaType.GENERIC_HDD;
|
|
break;
|
|
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;
|
|
break;
|
|
case 0x0011:
|
|
dskType = MediaType.DVDR;
|
|
break;
|
|
case 0x0012:
|
|
dskType = MediaType.DVDRAM;
|
|
break;
|
|
case 0x0013:
|
|
case 0x0014:
|
|
dskType = MediaType.DVDRW;
|
|
break;
|
|
case 0x0015:
|
|
case 0x0016:
|
|
dskType = MediaType.DVDRDL;
|
|
break;
|
|
case 0x0017:
|
|
dskType = MediaType.DVDRWDL;
|
|
break;
|
|
case 0x0018:
|
|
dskType = MediaType.DVDDownload;
|
|
break;
|
|
case 0x001A:
|
|
dskType = MediaType.DVDPRW;
|
|
break;
|
|
case 0x001B:
|
|
dskType = MediaType.DVDPR;
|
|
break;
|
|
case 0x0020:
|
|
dskType = MediaType.DDCD;
|
|
break;
|
|
case 0x0021:
|
|
dskType = MediaType.DDCDR;
|
|
break;
|
|
case 0x0022:
|
|
dskType = MediaType.DDCDRW;
|
|
break;
|
|
case 0x002A:
|
|
dskType = MediaType.DVDPRWDL;
|
|
break;
|
|
case 0x002B:
|
|
dskType = MediaType.DVDPRDL;
|
|
break;
|
|
case 0x0040:
|
|
dskType = MediaType.BDROM;
|
|
break;
|
|
case 0x0041:
|
|
case 0x0042:
|
|
dskType = MediaType.BDR;
|
|
break;
|
|
case 0x0043:
|
|
dskType = MediaType.BDRE;
|
|
break;
|
|
case 0x0050:
|
|
dskType = MediaType.HDDVDROM;
|
|
break;
|
|
case 0x0051:
|
|
dskType = MediaType.HDDVDR;
|
|
break;
|
|
case 0x0052:
|
|
dskType = MediaType.HDDVDRAM;
|
|
break;
|
|
case 0x0053:
|
|
dskType = MediaType.HDDVDRW;
|
|
break;
|
|
case 0x0058:
|
|
dskType = MediaType.HDDVDRDL;
|
|
break;
|
|
case 0x005A:
|
|
dskType = MediaType.HDDVDRWDL;
|
|
break;
|
|
}
|
|
}
|
|
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.Dvd, 0, 0,
|
|
MmcDiscStructureFormat.RecognizedFormatLayers, 0, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command",
|
|
"READ DISC STRUCTURE: Recognized Format Layers\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_formatlayers.bin",
|
|
"SCSI READ DISC STRUCTURE", cmdBuf);
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.Dvd, 0, 0,
|
|
MmcDiscStructureFormat.WriteProtectionStatus, 0, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: Write Protection Status\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_writeprotection.bin",
|
|
"SCSI READ DISC STRUCTURE", cmdBuf);
|
|
|
|
// More like a drive information
|
|
/*
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.CapabilityList, 0, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: Capability List\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
|
|
else
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_capabilitylist.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
|
|
*/
|
|
|
|
#region All DVD and HD DVD types
|
|
if(dskType == MediaType.DVDDownload || dskType == MediaType.DVDPR || dskType == MediaType.DVDPRDL ||
|
|
dskType == MediaType.DVDPRW || dskType == MediaType.DVDPRWDL || dskType == MediaType.DVDR ||
|
|
dskType == MediaType.DVDRAM || dskType == MediaType.DVDRDL || dskType == MediaType.DVDROM ||
|
|
dskType == MediaType.DVDRW || dskType == MediaType.DVDRWDL || dskType == MediaType.HDDVDR ||
|
|
dskType == MediaType.HDDVDRAM || dskType == MediaType.HDDVDRDL || dskType == MediaType.HDDVDROM ||
|
|
dskType == MediaType.HDDVDRW || dskType == MediaType.HDDVDRWDL)
|
|
{
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.Dvd, 0, 0,
|
|
MmcDiscStructureFormat.PhysicalInformation, 0, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: PFI\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
{
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_pfi.bin",
|
|
"SCSI READ DISC STRUCTURE", cmdBuf);
|
|
PFI.PhysicalFormatInformation? decPfi = PFI.Decode(cmdBuf);
|
|
if(decPfi.HasValue)
|
|
{
|
|
DicConsole.WriteLine("PFI:\n{0}", PFI.Prettify(decPfi));
|
|
|
|
// False book types
|
|
if(dskType == MediaType.DVDROM)
|
|
switch(decPfi.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 = decPfi.Value.PartVersion == 6 ? MediaType.DVDRDL : MediaType.DVDR;
|
|
break;
|
|
case DiskCategory.DVDRAM:
|
|
dskType = MediaType.DVDRAM;
|
|
break;
|
|
default:
|
|
dskType = MediaType.DVDROM;
|
|
break;
|
|
case DiskCategory.DVDRW:
|
|
dskType = decPfi.Value.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.Value.DiscSize == DVDSize.Eighty
|
|
? MediaType.GOD
|
|
: MediaType.WOD;
|
|
break;
|
|
case DiskCategory.UMD:
|
|
dskType = MediaType.UMD;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.Dvd, 0, 0,
|
|
MmcDiscStructureFormat.DiscManufacturingInformation, 0, dev.Timeout,
|
|
out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: DMI\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
{
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_dmi.bin",
|
|
"SCSI READ DISC STRUCTURE", cmdBuf);
|
|
if(DMI.IsXbox(cmdBuf))
|
|
{
|
|
dskType = MediaType.XGD;
|
|
DicConsole.WriteLine("Xbox DMI:\n{0}", DMI.PrettifyXbox(cmdBuf));
|
|
}
|
|
else if(DMI.IsXbox360(cmdBuf))
|
|
{
|
|
dskType = MediaType.XGD2;
|
|
DicConsole.WriteLine("Xbox 360 DMI:\n{0}", DMI.PrettifyXbox360(cmdBuf));
|
|
|
|
// 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;
|
|
}
|
|
}
|
|
}
|
|
#endregion All DVD and HD DVD types
|
|
|
|
#region DVD-ROM
|
|
if(dskType == MediaType.DVDDownload || dskType == MediaType.DVDROM)
|
|
{
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.Dvd, 0, 0,
|
|
MmcDiscStructureFormat.CopyrightInformation, 0, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: CMI\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
{
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_cmi.bin",
|
|
"SCSI READ DISC STRUCTURE", cmdBuf);
|
|
DicConsole.WriteLine("Lead-In CMI:\n{0}", CSS_CPRM.PrettifyLeadInCopyright(cmdBuf));
|
|
}
|
|
}
|
|
#endregion DVD-ROM
|
|
|
|
#region DVD-ROM and HD DVD-ROM
|
|
switch(dskType)
|
|
{
|
|
case MediaType.DVDDownload:
|
|
case MediaType.DVDROM:
|
|
case MediaType.HDDVDROM:
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.Dvd, 0, 0,
|
|
MmcDiscStructureFormat.BurstCuttingArea, 0, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: BCA\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_bca.bin",
|
|
"SCSI READ DISC STRUCTURE", cmdBuf);
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.Dvd, 0, 0,
|
|
MmcDiscStructureFormat.DvdAacs, 0, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: DVD AACS\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_aacs.bin",
|
|
"SCSI READ DISC STRUCTURE", cmdBuf);
|
|
break;
|
|
case MediaType.DVDRAM:
|
|
case MediaType.HDDVDRAM:
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.Dvd, 0, 0,
|
|
MmcDiscStructureFormat.DvdramDds, 0, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: DDS\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
{
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvdram_dds.bin",
|
|
"SCSI READ DISC STRUCTURE", cmdBuf);
|
|
DicConsole.WriteLine("Disc Definition Structure:\n{0}", DDS.Prettify(cmdBuf));
|
|
}
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.Dvd, 0, 0,
|
|
MmcDiscStructureFormat.DvdramMediumStatus, 0, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: Medium Status\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
{
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvdram_status.bin",
|
|
"SCSI READ DISC STRUCTURE", cmdBuf);
|
|
DicConsole.WriteLine("Medium Status:\n{0}", Cartridge.Prettify(cmdBuf));
|
|
}
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.Dvd, 0, 0,
|
|
MmcDiscStructureFormat.DvdramSpareAreaInformation, 0, dev.Timeout,
|
|
out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: SAI\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
{
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvdram_spare.bin",
|
|
"SCSI READ DISC STRUCTURE", cmdBuf);
|
|
DicConsole.WriteLine("Spare Area Information:\n{0}", Spare.Prettify(cmdBuf));
|
|
}
|
|
break;
|
|
case MediaType.DVDR:
|
|
case MediaType.HDDVDR:
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.Dvd, 0, 0,
|
|
MmcDiscStructureFormat.LastBorderOutRmd, 0, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command",
|
|
"READ DISC STRUCTURE: Last-Out Border RMD\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_lastrmd.bin",
|
|
"SCSI READ DISC STRUCTURE", cmdBuf);
|
|
break;
|
|
}
|
|
#endregion DVD-ROM and HD DVD-ROM
|
|
|
|
#region Require drive authentication, won't work
|
|
/*
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.DiscKey, 0, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: Disc Key\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
|
|
else
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_disckey.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.SectorCopyrightInformation, 0, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: Sector CMI\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
|
|
else
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_sectorcmi.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.MediaIdentifier, 0, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: Media ID\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
|
|
else
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_mediaid.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.MediaKeyBlock, 0, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: MKB\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
|
|
else
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_mkb.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.AACSVolId, 0, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: AACS Volume ID\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
|
|
else
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_aacsvolid.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.AACSMediaSerial, 0, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: AACS Media Serial Number\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
|
|
else
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_aacssn.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.AACSMediaId, 0, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: AACS Media ID\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
|
|
else
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_aacsmediaid.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.AACSMKB, 0, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: AACS MKB\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
|
|
else
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_aacsmkb.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.AACSLBAExtents, 0, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: AACS LBA Extents\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
|
|
else
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_aacslbaextents.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.AACSMKBCPRM, 0, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: AACS CPRM MKB\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
|
|
else
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_aacscprmmkb.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.DVD, 0, 0, MmcDiscStructureFormat.AACSDataKeys, 0, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: AACS Data Keys\n{0}", Decoders.SCSI.Sense.PrettifySense(senseBuf));
|
|
else
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_aacsdatakeys.bin", "SCSI READ DISC STRUCTURE", cmdBuf);
|
|
*/
|
|
#endregion Require drive authentication, won't work
|
|
|
|
#region DVD-RAM and HD DVD-RAM
|
|
#endregion DVD-RAM and HD DVD-RAM
|
|
|
|
#region DVD-R and HD DVD-R
|
|
#endregion DVD-R and HD DVD-R
|
|
|
|
#region DVD-R and DVD-RW
|
|
if(dskType == MediaType.DVDR || dskType == MediaType.DVDRW)
|
|
{
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.Dvd, 0, 0,
|
|
MmcDiscStructureFormat.PreRecordedInfo, 0, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: Pre-Recorded Info\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_pri.bin",
|
|
"SCSI READ DISC STRUCTURE", cmdBuf);
|
|
}
|
|
#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:
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.Dvd, 0, 0,
|
|
MmcDiscStructureFormat.DvdrMediaIdentifier, 0, dev.Timeout,
|
|
out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: DVD-R Media ID\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvdr_mediaid.bin",
|
|
"SCSI READ DISC STRUCTURE", cmdBuf);
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.Dvd, 0, 0,
|
|
MmcDiscStructureFormat.DvdrPhysicalInformation, 0, dev.Timeout,
|
|
out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: DVD-R PFI\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvdr_pfi.bin",
|
|
"SCSI READ DISC STRUCTURE", cmdBuf);
|
|
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:
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.Dvd, 0, 0,
|
|
MmcDiscStructureFormat.Adip, 0, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: ADIP\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd+_adip.bin",
|
|
"SCSI READ DISC STRUCTURE", cmdBuf);
|
|
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.Dvd, 0, 0,
|
|
MmcDiscStructureFormat.Dcb, 0, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: DCB\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd+_dcb.bin",
|
|
"SCSI READ DISC STRUCTURE", cmdBuf);
|
|
break;
|
|
#endregion All DVD+
|
|
|
|
#region HD DVD-ROM
|
|
case MediaType.HDDVDROM:
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.Dvd, 0, 0,
|
|
MmcDiscStructureFormat.HddvdCopyrightInformation, 0, dev.Timeout,
|
|
out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: HDDVD CMI\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_hddvd_cmi.bin",
|
|
"SCSI READ DISC STRUCTURE", cmdBuf);
|
|
break;
|
|
#endregion HD DVD-ROM
|
|
}
|
|
|
|
#region HD DVD-R
|
|
if(dskType == MediaType.HDDVDR)
|
|
{
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.Dvd, 0, 0,
|
|
MmcDiscStructureFormat.HddvdrMediumStatus, 0, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command",
|
|
"READ DISC STRUCTURE: HDDVD-R Medium Status\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_hddvdr_status.bin",
|
|
"SCSI READ DISC STRUCTURE", cmdBuf);
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.Dvd, 0, 0,
|
|
MmcDiscStructureFormat.HddvdrLastRmd, 0, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: Last RMD\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_hddvdr_lastrmd.bin",
|
|
"SCSI READ DISC STRUCTURE", cmdBuf);
|
|
}
|
|
#endregion HD DVD-R
|
|
|
|
#region DVD-R DL, DVD-RW DL, DVD+R DL, DVD+RW DL
|
|
if(dskType == MediaType.DVDPRDL || dskType == MediaType.DVDRDL || dskType == MediaType.DVDRWDL ||
|
|
dskType == MediaType.DVDPRWDL)
|
|
{
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.Dvd, 0, 0,
|
|
MmcDiscStructureFormat.DvdrLayerCapacity, 0, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: Layer Capacity\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvdr_layercap.bin",
|
|
"SCSI READ DISC STRUCTURE", cmdBuf);
|
|
}
|
|
#endregion DVD-R DL, DVD-RW DL, DVD+R DL, DVD+RW DL
|
|
|
|
switch(dskType)
|
|
{
|
|
#region DVD-R DL
|
|
case MediaType.DVDRDL:
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.Dvd, 0, 0,
|
|
MmcDiscStructureFormat.MiddleZoneStart, 0, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command",
|
|
"READ DISC STRUCTURE: Middle Zone Start\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_mzs.bin",
|
|
"SCSI READ DISC STRUCTURE", cmdBuf);
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.Dvd, 0, 0,
|
|
MmcDiscStructureFormat.JumpIntervalSize, 0, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command",
|
|
"READ DISC STRUCTURE: Jump Interval Size\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_jis.bin",
|
|
"SCSI READ DISC STRUCTURE", cmdBuf);
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.Dvd, 0, 0,
|
|
MmcDiscStructureFormat.ManualLayerJumpStartLba, 0, dev.Timeout,
|
|
out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command",
|
|
"READ DISC STRUCTURE: Manual Layer Jump Start LBA\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_manuallj.bin",
|
|
"SCSI READ DISC STRUCTURE", cmdBuf);
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.Dvd, 0, 0,
|
|
MmcDiscStructureFormat.RemapAnchorPoint, 0, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command",
|
|
"READ DISC STRUCTURE: Remap Anchor Point\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
DataFile.WriteTo("Media-Info command", outputPrefix,
|
|
"_readdiscstructure_dvd_remapanchor.bin", "SCSI READ DISC STRUCTURE",
|
|
cmdBuf);
|
|
break;
|
|
#endregion DVD-R DL
|
|
|
|
#region All Blu-ray
|
|
case MediaType.BDR:
|
|
case MediaType.BDRE:
|
|
case MediaType.BDROM:
|
|
case MediaType.BDRXL:
|
|
case MediaType.BDREXL:
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.Bd, 0, 0,
|
|
MmcDiscStructureFormat.DiscInformation, 0, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: DI\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
{
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_bd_di.bin",
|
|
"SCSI READ DISC STRUCTURE", cmdBuf);
|
|
DicConsole.WriteLine("Blu-ray Disc Information:\n{0}", DI.Prettify(cmdBuf));
|
|
}
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.Bd, 0, 0,
|
|
MmcDiscStructureFormat.Pac, 0, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: PAC\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_bd_pac.bin",
|
|
"SCSI READ DISC STRUCTURE", cmdBuf);
|
|
break;
|
|
#endregion All Blu-ray
|
|
}
|
|
|
|
switch(dskType)
|
|
{
|
|
#region BD-ROM only
|
|
case MediaType.BDROM:
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.Bd, 0, 0,
|
|
MmcDiscStructureFormat.BdBurstCuttingArea, 0, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: BCA\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
{
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_bd_bca.bin",
|
|
"SCSI READ DISC STRUCTURE", cmdBuf);
|
|
DicConsole.WriteLine("Blu-ray Burst Cutting Area:\n{0}", BCA.Prettify(cmdBuf));
|
|
}
|
|
break;
|
|
#endregion BD-ROM only
|
|
|
|
#region Writable Blu-ray only
|
|
case MediaType.BDR:
|
|
case MediaType.BDRE:
|
|
case MediaType.BDRXL:
|
|
case MediaType.BDREXL:
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.Bd, 0, 0,
|
|
MmcDiscStructureFormat.BdDds, 0, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: DDS\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
{
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_bd_dds.bin",
|
|
"SCSI READ DISC STRUCTURE", cmdBuf);
|
|
DicConsole.WriteLine("Blu-ray Disc Definition Structure:\n{0}",
|
|
Decoders.Bluray.DDS.Prettify(cmdBuf));
|
|
}
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.Bd, 0, 0,
|
|
MmcDiscStructureFormat.CartridgeStatus, 0, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command",
|
|
"READ DISC STRUCTURE: Cartridge Status\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
{
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_bd_cartstatus.bin",
|
|
"SCSI READ DISC STRUCTURE", cmdBuf);
|
|
DicConsole.WriteLine("Blu-ray Cartridge Status:\n{0}", DI.Prettify(cmdBuf));
|
|
}
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.Bd, 0, 0,
|
|
MmcDiscStructureFormat.BdSpareAreaInformation, 0, dev.Timeout,
|
|
out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command",
|
|
"READ DISC STRUCTURE: Spare Area Information\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
{
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_bd_spare.bin",
|
|
"SCSI READ DISC STRUCTURE", cmdBuf);
|
|
DicConsole.WriteLine("Blu-ray Spare Area Information:\n{0}", DI.Prettify(cmdBuf));
|
|
}
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.Bd, 0, 0,
|
|
MmcDiscStructureFormat.RawDfl, 0, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: Raw DFL\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_bd_dfl.bin",
|
|
"SCSI READ DISC STRUCTURE", cmdBuf);
|
|
sense = dev.ReadDiscInformation(out cmdBuf, out senseBuf,
|
|
MmcDiscInformationDataTypes.TrackResources, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ DISC INFORMATION 001b\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
{
|
|
DicConsole.WriteLine("Track Resources Information:\n{0}", DiscInformation.Prettify(cmdBuf));
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscinformation_001b.bin",
|
|
"SCSI READ DISC INFORMATION", cmdBuf);
|
|
}
|
|
sense = dev.ReadDiscInformation(out cmdBuf, out senseBuf,
|
|
MmcDiscInformationDataTypes.PowResources, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ DISC INFORMATION 010b\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
{
|
|
DicConsole.WriteLine("POW Resources Information:\n{0}", DiscInformation.Prettify(cmdBuf));
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscinformation_010b.bin",
|
|
"SCSI READ DISC INFORMATION", cmdBuf);
|
|
}
|
|
break;
|
|
#endregion Writable Blu-ray only
|
|
|
|
#region CDs
|
|
case MediaType.CD:
|
|
case MediaType.CDR:
|
|
case MediaType.CDROM:
|
|
case MediaType.CDRW:
|
|
case MediaType.Unknown:
|
|
TOC.CDTOC? toc = null;
|
|
|
|
// We discarded all discs that falsify a TOC before requesting a real TOC
|
|
// No TOC, no CD (or an empty one)
|
|
bool tocSense = dev.ReadTocPmaAtip(out cmdBuf, out senseBuf, false, 0, 0, dev.Timeout, out _);
|
|
if(tocSense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ TOC/PMA/ATIP: TOC\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
{
|
|
toc = TOC.Decode(cmdBuf);
|
|
DicConsole.WriteLine("TOC:\n{0}", TOC.Prettify(toc));
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_toc.bin", "SCSI READ TOC/PMA/ATIP",
|
|
cmdBuf);
|
|
|
|
// As we have a TOC we know it is a CD
|
|
if(dskType == MediaType.Unknown) dskType = MediaType.CD;
|
|
}
|
|
|
|
// ATIP exists on blank CDs
|
|
sense = dev.ReadAtip(out cmdBuf, out senseBuf, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ TOC/PMA/ATIP: ATIP\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
{
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_atip.bin", "SCSI READ TOC/PMA/ATIP",
|
|
cmdBuf);
|
|
ATIP.CDATIP? atip = ATIP.Decode(cmdBuf);
|
|
if(atip.HasValue)
|
|
{
|
|
DicConsole.WriteLine("ATIP:\n{0}", ATIP.Prettify(atip));
|
|
// Only CD-R and CD-RW have ATIP
|
|
dskType = atip.Value.DiscType ? MediaType.CDRW : MediaType.CDR;
|
|
}
|
|
}
|
|
|
|
// We got a TOC, get information about a recorded/mastered CD
|
|
if(!tocSense)
|
|
{
|
|
sense = dev.ReadDiscInformation(out cmdBuf, out senseBuf,
|
|
MmcDiscInformationDataTypes.DiscInformation, dev.Timeout,
|
|
out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ DISC INFORMATION 000b\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
{
|
|
DiscInformation.StandardDiscInformation? discInfo = DiscInformation.Decode000b(cmdBuf);
|
|
if(discInfo.HasValue)
|
|
{
|
|
DicConsole.WriteLine("Standard Disc Information:\n{0}",
|
|
DiscInformation.Prettify000b(discInfo));
|
|
DataFile.WriteTo("Media-Info command", outputPrefix,
|
|
"_readdiscinformation_000b.bin", "SCSI READ DISC INFORMATION",
|
|
cmdBuf);
|
|
|
|
// If it is a read-only CD, check CD type if available
|
|
if(dskType == MediaType.CD)
|
|
switch(discInfo.Value.DiscType)
|
|
{
|
|
case 0x10:
|
|
dskType = MediaType.CDI;
|
|
break;
|
|
case 0x20:
|
|
dskType = MediaType.CDROMXA;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
int sessions = 1;
|
|
int firstTrackLastSession = 0;
|
|
|
|
sense = dev.ReadSessionInfo(out cmdBuf, out senseBuf, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ TOC/PMA/ATIP: Session info\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
{
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_session.bin",
|
|
"SCSI READ TOC/PMA/ATIP", cmdBuf);
|
|
Session.CDSessionInfo? session = Session.Decode(cmdBuf);
|
|
DicConsole.WriteLine("Session information:\n{0}", Session.Prettify(session));
|
|
if(session.HasValue)
|
|
{
|
|
sessions = session.Value.LastCompleteSession;
|
|
firstTrackLastSession = session.Value.TrackDescriptors[0].TrackNumber;
|
|
}
|
|
}
|
|
|
|
if(dskType == MediaType.CD)
|
|
{
|
|
bool hasDataTrack = false;
|
|
bool hasAudioTrack = false;
|
|
bool allFirstSessionTracksAreAudio = true;
|
|
bool hasVideoTrack = false;
|
|
|
|
if(toc.HasValue)
|
|
foreach(TOC.CDTOCTrackDataDescriptor track in toc.Value.TrackDescriptors)
|
|
{
|
|
if(track.TrackNumber == 1 &&
|
|
((TocControl)(track.CONTROL & 0x0D) == TocControl.DataTrack ||
|
|
(TocControl)(track.CONTROL & 0x0D) == TocControl.DataTrackIncremental))
|
|
allFirstSessionTracksAreAudio &= firstTrackLastSession != 1;
|
|
|
|
if((TocControl)(track.CONTROL & 0x0D) == TocControl.DataTrack ||
|
|
(TocControl)(track.CONTROL & 0x0D) == TocControl.DataTrackIncremental)
|
|
{
|
|
hasDataTrack = true;
|
|
allFirstSessionTracksAreAudio &= track.TrackNumber >= firstTrackLastSession;
|
|
}
|
|
else hasAudioTrack = true;
|
|
|
|
hasVideoTrack |= track.ADR == 4;
|
|
}
|
|
|
|
if(hasDataTrack && hasAudioTrack && allFirstSessionTracksAreAudio && sessions == 2)
|
|
dskType = MediaType.CDPLUS;
|
|
if(!hasDataTrack && hasAudioTrack && sessions == 1) dskType = MediaType.CDDA;
|
|
if(hasDataTrack && !hasAudioTrack && sessions == 1) dskType = MediaType.CDROM;
|
|
if(hasVideoTrack && !hasDataTrack && sessions == 1) dskType = MediaType.CDV;
|
|
}
|
|
|
|
sense = dev.ReadRawToc(out cmdBuf, out senseBuf, 1, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ TOC/PMA/ATIP: Raw TOC\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
{
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_rawtoc.bin",
|
|
"SCSI READ TOC/PMA/ATIP", cmdBuf);
|
|
DicConsole.WriteLine("Raw TOC:\n{0}", FullTOC.Prettify(cmdBuf));
|
|
}
|
|
sense = dev.ReadPma(out cmdBuf, out senseBuf, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ TOC/PMA/ATIP: PMA\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
{
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_pma.bin",
|
|
"SCSI READ TOC/PMA/ATIP", cmdBuf);
|
|
DicConsole.WriteLine("PMA:\n{0}", PMA.Prettify(cmdBuf));
|
|
}
|
|
|
|
sense = dev.ReadCdText(out cmdBuf, out senseBuf, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ TOC/PMA/ATIP: CD-TEXT\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
{
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_cdtext.bin",
|
|
"SCSI READ TOC/PMA/ATIP", cmdBuf);
|
|
if(CDTextOnLeadIn.Decode(cmdBuf).HasValue)
|
|
DicConsole.WriteLine("CD-TEXT on Lead-In:\n{0}", CDTextOnLeadIn.Prettify(cmdBuf));
|
|
}
|
|
}
|
|
|
|
break;
|
|
#endregion CDs
|
|
}
|
|
|
|
#region Nintendo
|
|
if(dskType == MediaType.Unknown && blocks > 0)
|
|
{
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.Dvd, 0, 0,
|
|
MmcDiscStructureFormat.PhysicalInformation, 0, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: PFI\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
{
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_pfi.bin",
|
|
"SCSI READ DISC STRUCTURE", cmdBuf);
|
|
PFI.PhysicalFormatInformation? nintendoPfi = PFI.Decode(cmdBuf);
|
|
if(nintendoPfi != null)
|
|
{
|
|
DicConsole.WriteLine("PFI:\n{0}", PFI.Prettify(cmdBuf));
|
|
if(nintendoPfi.Value.DiskCategory == DiskCategory.Nintendo &&
|
|
nintendoPfi.Value.PartVersion == 15)
|
|
switch(nintendoPfi.Value.DiscSize)
|
|
{
|
|
case DVDSize.Eighty:
|
|
dskType = MediaType.GOD;
|
|
break;
|
|
case DVDSize.OneTwenty:
|
|
dskType = MediaType.WOD;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.Dvd, 0, 0,
|
|
MmcDiscStructureFormat.DiscManufacturingInformation, 0, dev.Timeout,
|
|
out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ DISC STRUCTURE: DMI\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_readdiscstructure_dvd_dmi.bin",
|
|
"SCSI READ DISC STRUCTURE", cmdBuf);
|
|
}
|
|
#endregion Nintendo
|
|
}
|
|
|
|
#region Xbox
|
|
switch(dskType)
|
|
{
|
|
case MediaType.XGD:
|
|
case MediaType.XGD2:
|
|
case MediaType.XGD3:
|
|
// We need to get INQUIRY to know if it is a Kreon drive
|
|
Inquiry.SCSIInquiry? inq;
|
|
|
|
sense = dev.ScsiInquiry(out byte[] inqBuffer, out senseBuf);
|
|
if(!sense)
|
|
{
|
|
inq = Inquiry.Decode(inqBuffer);
|
|
if(inq.HasValue && inq.Value.KreonPresent)
|
|
{
|
|
sense = dev.KreonExtractSs(out cmdBuf, out senseBuf, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "KREON EXTRACT SS:\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_xbox_ss.bin", "KREON EXTRACT SS",
|
|
cmdBuf);
|
|
|
|
if(SS.Decode(cmdBuf).HasValue)
|
|
DicConsole.WriteLine("Xbox Security Sector:\n{0}", SS.Prettify(cmdBuf));
|
|
|
|
ulong l0Video, l1Video, middleZone, gameSize, totalSize, layerBreak;
|
|
|
|
// Get video partition size
|
|
DicConsole.DebugWriteLine("Dump-media command", "Getting video partition size");
|
|
sense = dev.KreonLock(out senseBuf, dev.Timeout, out _);
|
|
if(sense)
|
|
{
|
|
DicConsole.ErrorWriteLine("Cannot lock drive, not continuing.");
|
|
return;
|
|
}
|
|
|
|
sense = dev.ReadCapacity(out cmdBuf, out senseBuf, dev.Timeout, out _);
|
|
if(sense)
|
|
{
|
|
DicConsole.ErrorWriteLine("Cannot get disc capacity.");
|
|
return;
|
|
}
|
|
|
|
totalSize = (ulong)((cmdBuf[0] << 24) + (cmdBuf[1] << 16) + (cmdBuf[2] << 8) + cmdBuf[3]);
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.Dvd, 0, 0,
|
|
MmcDiscStructureFormat.PhysicalInformation, 0, 0, out _);
|
|
if(sense)
|
|
{
|
|
DicConsole.ErrorWriteLine("Cannot get PFI.");
|
|
return;
|
|
}
|
|
|
|
DicConsole.DebugWriteLine("Dump-media command", "Video partition total size: {0} sectors",
|
|
totalSize);
|
|
l0Video = PFI.Decode(cmdBuf).Value.Layer0EndPSN -
|
|
PFI.Decode(cmdBuf).Value.DataAreaStartPSN + 1;
|
|
l1Video = totalSize - l0Video + 1;
|
|
|
|
// Get game partition size
|
|
DicConsole.DebugWriteLine("Dump-media command", "Getting game partition size");
|
|
sense = dev.KreonUnlockXtreme(out senseBuf, dev.Timeout, out _);
|
|
if(sense)
|
|
{
|
|
DicConsole.ErrorWriteLine("Cannot unlock drive, not continuing.");
|
|
return;
|
|
}
|
|
|
|
sense = dev.ReadCapacity(out cmdBuf, out senseBuf, dev.Timeout, out _);
|
|
if(sense)
|
|
{
|
|
DicConsole.ErrorWriteLine("Cannot get disc capacity.");
|
|
return;
|
|
}
|
|
|
|
gameSize = (ulong)((cmdBuf[0] << 24) + (cmdBuf[1] << 16) + (cmdBuf[2] << 8) + cmdBuf[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");
|
|
sense = dev.KreonUnlockWxripper(out senseBuf, dev.Timeout, out _);
|
|
if(sense)
|
|
{
|
|
DicConsole.ErrorWriteLine("Cannot unlock drive, not continuing.");
|
|
return;
|
|
}
|
|
|
|
sense = dev.ReadCapacity(out cmdBuf, out senseBuf, dev.Timeout, out _);
|
|
if(sense)
|
|
{
|
|
DicConsole.ErrorWriteLine("Cannot get disc capacity.");
|
|
return;
|
|
}
|
|
|
|
totalSize = (ulong)((cmdBuf[0] << 24) + (cmdBuf[1] << 16) + (cmdBuf[2] << 8) + cmdBuf[3]);
|
|
sense = dev.ReadDiscStructure(out cmdBuf, out senseBuf, MmcDiscStructureMediaType.Dvd, 0, 0,
|
|
MmcDiscStructureFormat.PhysicalInformation, 0, 0, out _);
|
|
if(sense)
|
|
{
|
|
DicConsole.ErrorWriteLine("Cannot get PFI.");
|
|
return;
|
|
}
|
|
|
|
DicConsole.DebugWriteLine("Dump-media command", "Unlocked total size: {0} sectors",
|
|
totalSize);
|
|
middleZone =
|
|
totalSize - (PFI.Decode(cmdBuf).Value.Layer0EndPSN -
|
|
PFI.Decode(cmdBuf).Value.DataAreaStartPSN + 1) - gameSize + 1;
|
|
|
|
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();
|
|
}
|
|
}
|
|
|
|
break;
|
|
case MediaType.Unknown:
|
|
dskType = MediaTypeFromScsi.Get((byte)dev.ScsiType, dev.Manufacturer, dev.Model, scsiMediumType,
|
|
scsiDensityCode, blocks, blockSize);
|
|
break;
|
|
}
|
|
#endregion Xbox
|
|
|
|
if(dskType == MediaType.Unknown && dev.IsUsb && containsFloppyPage) dskType = MediaType.FlashDrive;
|
|
|
|
DicConsole.WriteLine("Media identified as {0}", dskType);
|
|
Core.Statistics.AddMedia(dskType, true);
|
|
|
|
sense = dev.ReadMediaSerialNumber(out cmdBuf, out senseBuf, dev.Timeout, out _);
|
|
if(sense)
|
|
DicConsole.DebugWriteLine("Media-Info command", "READ MEDIA SERIAL NUMBER\n{0}",
|
|
Sense.PrettifySense(senseBuf));
|
|
else
|
|
{
|
|
DataFile.WriteTo("Media-Info command", outputPrefix, "_mediaserialnumber.bin",
|
|
"SCSI READ MEDIA SERIAL NUMBER", cmdBuf);
|
|
if(cmdBuf.Length < 4) return;
|
|
|
|
DicConsole.Write("Media Serial Number: ");
|
|
for(int i = 4; i < cmdBuf.Length; i++) DicConsole.Write("{0:X2}", cmdBuf[i]);
|
|
|
|
DicConsole.WriteLine();
|
|
}
|
|
}
|
|
}
|
|
} |