aaru-dps/Aaru.Server
1
0
Fork 0
mirror of https://github.com/aaru-dps/Aaru.Server.git synced 2025-12-16 19:24:27 +00:00
Code Issues Packages Projects Releases Wiki Activity

REFACTOR: Reformat code.

Browse Source
This commit is contained in:
Natalia Portillo
2017-12-19 20:33:03 +00:00
parent 77edc7c91c
commit e6f6ace80b
704 changed files with 82627 additions and 83641 deletions
Download Patch File Download Diff File Expand all files Collapse all files

847
DiscImageChef.Server/App_Start/Ata.cs
View File

File diff suppressed because it is too large Load Diff

52
DiscImageChef.Server/App_Start/ScsiEvpd.cs
View File

@@ -42,28 +42,19 @@ namespace DiscImageChef.Server.App_Start
foreach(pageType evpd in pages)
{
string decoded;
if(evpd.page >= 0x01 && evpd.page <= 0x7F)
decoded = Decoders.SCSI.EVPD.DecodeASCIIPage(evpd.value);
else if(evpd.page == 0x81)
decoded = Decoders.SCSI.EVPD.PrettifyPage_81(evpd.value);
else if(evpd.page == 0x82)
decoded = Decoders.SCSI.EVPD.DecodePage82(evpd.value);
else if(evpd.page == 0x83)
decoded = Decoders.SCSI.EVPD.PrettifyPage_83(evpd.value);
else if(evpd.page == 0x84)
decoded = Decoders.SCSI.EVPD.PrettifyPage_84(evpd.value);
else if(evpd.page == 0x85)
decoded = Decoders.SCSI.EVPD.PrettifyPage_85(evpd.value);
else if(evpd.page == 0x86)
decoded = Decoders.SCSI.EVPD.PrettifyPage_86(evpd.value);
else if(evpd.page == 0x89)
decoded = Decoders.SCSI.EVPD.PrettifyPage_89(evpd.value);
else if(evpd.page == 0xB0)
decoded = Decoders.SCSI.EVPD.PrettifyPage_B0(evpd.value);
if(evpd.page >= 0x01 && evpd.page <= 0x7F) decoded = Decoders.SCSI.EVPD.DecodeASCIIPage(evpd.value);
else if(evpd.page == 0x81) decoded = Decoders.SCSI.EVPD.PrettifyPage_81(evpd.value);
else if(evpd.page == 0x82) decoded = Decoders.SCSI.EVPD.DecodePage82(evpd.value);
else if(evpd.page == 0x83) decoded = Decoders.SCSI.EVPD.PrettifyPage_83(evpd.value);
else if(evpd.page == 0x84) decoded = Decoders.SCSI.EVPD.PrettifyPage_84(evpd.value);
else if(evpd.page == 0x85) decoded = Decoders.SCSI.EVPD.PrettifyPage_85(evpd.value);
else if(evpd.page == 0x86) decoded = Decoders.SCSI.EVPD.PrettifyPage_86(evpd.value);
else if(evpd.page == 0x89) decoded = Decoders.SCSI.EVPD.PrettifyPage_89(evpd.value);
else if(evpd.page == 0xB0) decoded = Decoders.SCSI.EVPD.PrettifyPage_B0(evpd.value);
else if(evpd.page == 0xB2)
decoded = string.Format("TapeAlert Supported Flags Bitmap: 0x{0:X16}<br/>", Decoders.SCSI.EVPD.DecodePageB2(evpd.value));
else if(evpd.page == 0xB4)
decoded = Decoders.SCSI.EVPD.DecodePageB4(evpd.value);
decoded = string.Format("TapeAlert Supported Flags Bitmap: 0x{0:X16}<br/>",
Decoders.SCSI.EVPD.DecodePageB2(evpd.value));
else if(evpd.page == 0xB4) decoded = Decoders.SCSI.EVPD.DecodePageB4(evpd.value);
else if(evpd.page == 0xC0 && vendor.Trim() == "quantum")
decoded = Decoders.SCSI.EVPD.PrettifyPage_C0_Quantum(evpd.value);
else if(evpd.page == 0xC0 && vendor.Trim() == "seagate")
@@ -74,22 +65,21 @@ namespace DiscImageChef.Server.App_Start
decoded = Decoders.SCSI.EVPD.PrettifyPage_C1_IBM(evpd.value);
else if((evpd.page == 0xC0 || evpd.page == 0xC1) && vendor.Trim() == "certance")
decoded = Decoders.SCSI.EVPD.PrettifyPage_C0_C1_Certance(evpd.value);
else if((evpd.page == 0xC2 || evpd.page == 0xC3 || evpd.page == 0xC4 || evpd.page == 0xC5 || evpd.page == 0xC6) &&
else if((evpd.page == 0xC2 || evpd.page == 0xC3 || evpd.page == 0xC4 || evpd.page == 0xC5 ||
evpd.page == 0xC6) &&
vendor.Trim() == "certance")
decoded = Decoders.SCSI.EVPD.PrettifyPage_C2_C3_C4_C5_C6_Certance(evpd.value);
else if((evpd.page == 0xC0 || evpd.page == 0xC1 || evpd.page == 0xC2 || evpd.page == 0xC3 || evpd.page == 0xC4 || evpd.page == 0xC5) &&
vendor.Trim() == "hp")
decoded = Decoders.SCSI.EVPD.PrettifyPage_C0_to_C5_HP(evpd.value);
else if((evpd.page == 0xC0 || evpd.page == 0xC1 || evpd.page == 0xC2 || evpd.page == 0xC3 ||
evpd.page == 0xC4 || evpd.page == 0xC5) &&
vendor.Trim() == "hp") decoded = Decoders.SCSI.EVPD.PrettifyPage_C0_to_C5_HP(evpd.value);
else if(evpd.page == 0xDF && vendor.Trim() == "certance")
decoded = Decoders.SCSI.EVPD.PrettifyPage_DF_Certance(evpd.value);
else
decoded = "Undecoded";
else decoded = "Undecoded";
if(!string.IsNullOrEmpty(decoded)) decoded = decoded.Replace("\n", "<br/>");
if(!string.IsNullOrEmpty(decoded))
decoded = decoded.Replace("\n", "<br/>");
evpdPages.Add(string.Format("EVPD page {0:X2}h", evpd.page), decoded);
}
}
}
}
}

159
DiscImageChef.Server/App_Start/ScsiInquiry.cs
View File

@@ -57,7 +57,8 @@ namespace DiscImageChef.Server.App_Start
scsiOneValue.Add("Device is connected but unsupported.");
break;
default:
scsiOneValue.Add(string.Format("Vendor value {0} set in Peripheral Qualifier field.", inquiry.PeripheralQualifier));
scsiOneValue.Add(string.Format("Vendor value {0} set in Peripheral Qualifier field.",
inquiry.PeripheralQualifier));
break;
}
@@ -133,7 +134,8 @@ namespace DiscImageChef.Server.App_Start
scsiOneValue.Add("Unknown or no device type");
break;
default:
scsiOneValue.Add(string.Format("Unknown device type field value 0x{0:X2}", inquiry.PeripheralDeviceType));
scsiOneValue.Add(string.Format("Unknown device type field value 0x{0:X2}",
inquiry.PeripheralDeviceType));
break;
}
@@ -161,7 +163,9 @@ namespace DiscImageChef.Server.App_Start
scsiOneValue.Add("Device claims to comply with ANSI X3.408:2005 (SPC-4)");
break;
default:
scsiOneValue.Add(string.Format("Device claims to comply with unknown SCSI ANSI standard value 0x{0:X2})", inquiry.ANSIVersion));
scsiOneValue
.Add(string.Format("Device claims to comply with unknown SCSI ANSI standard value 0x{0:X2})",
inquiry.ANSIVersion));
break;
}
@@ -174,7 +178,9 @@ namespace DiscImageChef.Server.App_Start
scsiOneValue.Add("Device claims to comply ECMA-111: Small Computer System Interface SCSI");
break;
default:
scsiOneValue.Add(string.Format("Device claims to comply with unknown SCSI ECMA standard value 0x{0:X2})", inquiry.ECMAVersion));
scsiOneValue
.Add(string.Format("Device claims to comply with unknown SCSI ECMA standard value 0x{0:X2})",
inquiry.ECMAVersion));
break;
}
@@ -187,62 +193,39 @@ namespace DiscImageChef.Server.App_Start
scsiOneValue.Add("Device claims to comply with ISO/IEC 9316:1995");
break;
default:
scsiOneValue.Add(string.Format("Device claims to comply with unknown SCSI ISO/IEC standard value 0x{0:X2})", inquiry.ISOVersion));
scsiOneValue
.Add(string.Format("Device claims to comply with unknown SCSI ISO/IEC standard value 0x{0:X2})",
inquiry.ISOVersion));
break;
}
if(inquiry.Removable)
scsiOneValue.Add("Device is removable");
if(inquiry.AERCSupported)
scsiOneValue.Add("Device supports Asynchronous Event Reporting Capability");
if(inquiry.TerminateTaskSupported)
scsiOneValue.Add("Device supports TERMINATE TASK command");
if(inquiry.NormalACA)
scsiOneValue.Add("Device supports setting Normal ACA");
if(inquiry.HierarchicalLUN)
scsiOneValue.Add("Device supports LUN hierarchical addressing");
if(inquiry.StorageArrayController)
scsiOneValue.Add("Device contains an embedded storage array controller");
if(inquiry.AccessControlCoordinator)
scsiOneValue.Add("Device contains an Access Control Coordinator");
if(inquiry.ThirdPartyCopy)
scsiOneValue.Add("Device supports third-party copy commands");
if(inquiry.Protection)
scsiOneValue.Add("Device supports protection information");
if(inquiry.BasicQueueing)
scsiOneValue.Add("Device supports basic queueing");
if(inquiry.EnclosureServices)
scsiOneValue.Add("Device contains an embedded enclosure services component");
if(inquiry.MultiPortDevice)
scsiOneValue.Add("Multi-port device");
if(inquiry.MediumChanger)
scsiOneValue.Add("Device contains or is attached to a medium changer");
if(inquiry.ACKRequests)
scsiOneValue.Add("Device supports request and acknowledge handshakes");
if(inquiry.Address32)
scsiOneValue.Add("Device supports 32-bit wide SCSI addresses");
if(inquiry.Address16)
scsiOneValue.Add("Device supports 16-bit wide SCSI addresses");
if(inquiry.RelativeAddressing)
scsiOneValue.Add("Device supports relative addressing");
if(inquiry.WideBus32)
scsiOneValue.Add("Device supports 32-bit wide data transfers");
if(inquiry.WideBus16)
scsiOneValue.Add("Device supports 16-bit wide data transfers");
if(inquiry.SyncTransfer)
scsiOneValue.Add("Device supports synchronous data transfer");
if(inquiry.LinkedCommands)
scsiOneValue.Add("Device supports linked commands");
if(inquiry.Removable) scsiOneValue.Add("Device is removable");
if(inquiry.AERCSupported) scsiOneValue.Add("Device supports Asynchronous Event Reporting Capability");
if(inquiry.TerminateTaskSupported) scsiOneValue.Add("Device supports TERMINATE TASK command");
if(inquiry.NormalACA) scsiOneValue.Add("Device supports setting Normal ACA");
if(inquiry.HierarchicalLUN) scsiOneValue.Add("Device supports LUN hierarchical addressing");
if(inquiry.StorageArrayController) scsiOneValue.Add("Device contains an embedded storage array controller");
if(inquiry.AccessControlCoordinator) scsiOneValue.Add("Device contains an Access Control Coordinator");
if(inquiry.ThirdPartyCopy) scsiOneValue.Add("Device supports third-party copy commands");
if(inquiry.Protection) scsiOneValue.Add("Device supports protection information");
if(inquiry.BasicQueueing) scsiOneValue.Add("Device supports basic queueing");
if(inquiry.EnclosureServices) scsiOneValue.Add("Device contains an embedded enclosure services component");
if(inquiry.MultiPortDevice) scsiOneValue.Add("Multi-port device");
if(inquiry.MediumChanger) scsiOneValue.Add("Device contains or is attached to a medium changer");
if(inquiry.ACKRequests) scsiOneValue.Add("Device supports request and acknowledge handshakes");
if(inquiry.Address32) scsiOneValue.Add("Device supports 32-bit wide SCSI addresses");
if(inquiry.Address16) scsiOneValue.Add("Device supports 16-bit wide SCSI addresses");
if(inquiry.RelativeAddressing) scsiOneValue.Add("Device supports relative addressing");
if(inquiry.WideBus32) scsiOneValue.Add("Device supports 32-bit wide data transfers");
if(inquiry.WideBus16) scsiOneValue.Add("Device supports 16-bit wide data transfers");
if(inquiry.SyncTransfer) scsiOneValue.Add("Device supports synchronous data transfer");
if(inquiry.LinkedCommands) scsiOneValue.Add("Device supports linked commands");
if(inquiry.TranferDisable)
scsiOneValue.Add("Device supports CONTINUE TASK and TARGET TRANSFER DISABLE commands");
if(inquiry.QAS)
scsiOneValue.Add("Device supports Quick Arbitration and Selection");
if(inquiry.TaggedCommandQueue)
scsiOneValue.Add("Device supports TCQ queue");
if(inquiry.IUS)
scsiOneValue.Add("Device supports information unit transfers");
if(inquiry.SoftReset)
scsiOneValue.Add("Device implements RESET as a soft reset");
if(inquiry.QAS) scsiOneValue.Add("Device supports Quick Arbitration and Selection");
if(inquiry.TaggedCommandQueue) scsiOneValue.Add("Device supports TCQ queue");
if(inquiry.IUS) scsiOneValue.Add("Device supports information unit transfers");
if(inquiry.SoftReset) scsiOneValue.Add("Device implements RESET as a soft reset");
switch((TGPSValues)inquiry.AsymmetricalLUNAccess)
{
@@ -259,7 +242,8 @@ namespace DiscImageChef.Server.App_Start
scsiOneValue.Add("Device supports implicit and explicit assymetrical access");
break;
default:
scsiOneValue.Add(string.Format("Unknown value in TPGS field 0x{0:X2}", inquiry.AsymmetricalLUNAccess));
scsiOneValue.Add(string.Format("Unknown value in TPGS field 0x{0:X2}",
inquiry.AsymmetricalLUNAccess));
break;
}
@@ -278,7 +262,8 @@ namespace DiscImageChef.Server.App_Start
scsiOneValue.Add("Device supports ST and DT clocking");
break;
default:
scsiOneValue.Add(string.Format("Unknown value in SPI clocking field 0x{0:X2}", inquiry.SPIClocking));
scsiOneValue.Add(string.Format("Unknown value in SPI clocking field 0x{0:X2}",
inquiry.SPIClocking));
break;
}
@@ -289,8 +274,7 @@ namespace DiscImageChef.Server.App_Start
switch(VersionDescriptor)
{
case 0xFFFF:
case 0x0000:
break;
case 0x0000: break;
case 0x0020:
scsiOneValue.Add("Device complies with SAM (no version claimed)");
break;
@@ -418,10 +402,12 @@ namespace DiscImageChef.Server.App_Start
scsiOneValue.Add("Device complies with SES ANSI INCITS 305-1998");
break;
case 0x01DD:
scsiOneValue.Add("Device complies with SES T10/1212 revision 08b w/ Amendment ANSI INCITS.305/AM1-2000");
scsiOneValue
.Add("Device complies with SES T10/1212 revision 08b w/ Amendment ANSI INCITS.305/AM1-2000");
break;
case 0x01DE:
scsiOneValue.Add("Device complies with SES ANSI INCITS 305-1998 w/ Amendment ANSI INCITS.305/AM1-2000");
scsiOneValue
.Add("Device complies with SES ANSI INCITS 305-1998 w/ Amendment ANSI INCITS.305/AM1-2000");
break;
case 0x01E0:
scsiOneValue.Add("Device complies with SCC-2 (no version claimed)");
@@ -757,7 +743,8 @@ namespace DiscImageChef.Server.App_Start
scsiOneValue.Add("Device complies with MMC-6 ANSI INCITS 468-2010");
break;
case 0x04E7:
scsiOneValue.Add("Device complies with MMC-6 ANSI INCITS 468-2010 + MMC-6/AM1 ANSI INCITS 468-2010/AM 1");
scsiOneValue
.Add("Device complies with MMC-6 ANSI INCITS 468-2010 + MMC-6/AM1 ANSI INCITS 468-2010/AM 1");
break;
case 0x0500:
scsiOneValue.Add("Device complies with ADC-3 (no version claimed)");
@@ -949,7 +936,8 @@ namespace DiscImageChef.Server.App_Start
case 0x097D:
case 0x097E:
case 0x097F:
scsiOneValue.Add(string.Format("Device complies with iSCSI revision {0}", VersionDescriptor & 0x1F));
scsiOneValue.Add(string.Format("Device complies with iSCSI revision {0}",
VersionDescriptor & 0x1F));
break;
case 0x0980:
scsiOneValue.Add("Device complies with SBP-3 (no version claimed)");
@@ -1042,10 +1030,12 @@ namespace DiscImageChef.Server.App_Start
scsiOneValue.Add("Device complies with SPI ANSI INCITS 253-1995");
break;
case 0x0ABB:
scsiOneValue.Add("Device complies with SPI T10/0855-D revision 15a with SPI Amnd revision 3a");
scsiOneValue
.Add("Device complies with SPI T10/0855-D revision 15a with SPI Amnd revision 3a");
break;
case 0x0ABC:
scsiOneValue.Add("Device complies with SPI ANSI INCITS 253-1995 with SPI Amnd ANSI INCITS 253/AM1-1998");
scsiOneValue
.Add("Device complies with SPI ANSI INCITS 253-1995 with SPI Amnd ANSI INCITS 253/AM1-1998");
break;
case 0x0AC0:
scsiOneValue.Add("Device complies with Fast-20 (no version claimed)");
@@ -1186,7 +1176,8 @@ namespace DiscImageChef.Server.App_Start
scsiOneValue.Add("Device complies with SAS-2.1 ANSI INCITS 478-2011");
break;
case 0x0C4F:
scsiOneValue.Add("Device complies with SAS-2.1 ANSI INCITS 478-2011 w/ Amnd 1 ANSI INCITS 478/AM1-2014");
scsiOneValue
.Add("Device complies with SAS-2.1 ANSI INCITS 478-2011 w/ Amnd 1 ANSI INCITS 478/AM1-2014");
break;
case 0x0C52:
scsiOneValue.Add("Device complies with SAS-2.1 ISO/IEC 14776-153");
@@ -1213,7 +1204,8 @@ namespace DiscImageChef.Server.App_Start
scsiOneValue.Add("Device complies with FC-PH ANSI INCITS 230-1994");
break;
case 0x0D3C:
scsiOneValue.Add("Device complies with FC-PH ANSI INCITS 230-1994 with Amnd 1 ANSI INCITS 230/AM1-1996");
scsiOneValue
.Add("Device complies with FC-PH ANSI INCITS 230-1994 with Amnd 1 ANSI INCITS 230/AM1-1996");
break;
case 0x0D40:
scsiOneValue.Add("Device complies with FC-AL (no version claimed)");
@@ -1228,7 +1220,8 @@ namespace DiscImageChef.Server.App_Start
scsiOneValue.Add("Device complies with FC-AL-2 T11/1133-D revision 7.0");
break;
case 0x0D63:
scsiOneValue.Add("Device complies with FC-AL-2 ANSI INCITS 332-1999 with AM1-2003 & AM2-2006");
scsiOneValue
.Add("Device complies with FC-AL-2 ANSI INCITS 332-1999 with AM1-2003 & AM2-2006");
break;
case 0x0D64:
scsiOneValue.Add("Device complies with FC-AL-2 ANSI INCITS 332-1999 with Amnd 2 AM2-2006");
@@ -1285,7 +1278,8 @@ namespace DiscImageChef.Server.App_Start
scsiOneValue.Add("Device complies with FC-FS-2 ANSI INCITS 242-2007");
break;
case 0x0E03:
scsiOneValue.Add("Device complies with FC-FS-2 ANSI INCITS 242-2007 with AM1 ANSI INCITS 242/AM1-2007");
scsiOneValue
.Add("Device complies with FC-FS-2 ANSI INCITS 242-2007 with AM1 ANSI INCITS 242/AM1-2007");
break;
case 0x0E20:
scsiOneValue.Add("Device complies with FC-LS (no version claimed)");
@@ -1342,7 +1336,8 @@ namespace DiscImageChef.Server.App_Start
scsiOneValue.Add("Device complies with FC 10GFC ISO/IEC 14165-116 with AM1");
break;
case 0x0EA6:
scsiOneValue.Add("Device complies with FC 10GFC ANSI INCITS 364-2003 with AM1 ANSI INCITS 364/AM1-2007");
scsiOneValue
.Add("Device complies with FC 10GFC ANSI INCITS 364-2003 with AM1 ANSI INCITS 364/AM1-2007");
break;
case 0x0EC0:
scsiOneValue.Add("Device complies with FC-SP-2 (no version claimed)");
@@ -1522,19 +1517,23 @@ namespace DiscImageChef.Server.App_Start
scsiOneValue.Add("Device complies with ATA/ATAPI-8 ATA8-AAM (no version claimed)");
break;
case 0x1621:
scsiOneValue.Add("Device complies with ATA/ATAPI-8 ATA8-APT Parallel Transport (no version claimed)");
scsiOneValue
.Add("Device complies with ATA/ATAPI-8 ATA8-APT Parallel Transport (no version claimed)");
break;
case 0x1622:
scsiOneValue.Add("Device complies with ATA/ATAPI-8 ATA8-AST Serial Transport (no version claimed)");
scsiOneValue
.Add("Device complies with ATA/ATAPI-8 ATA8-AST Serial Transport (no version claimed)");
break;
case 0x1623:
scsiOneValue.Add("Device complies with ATA/ATAPI-8 ATA8-ACS ATA/ATAPI Command Set (no version claimed)");
scsiOneValue
.Add("Device complies with ATA/ATAPI-8 ATA8-ACS ATA/ATAPI Command Set (no version claimed)");
break;
case 0x1628:
scsiOneValue.Add("Device complies with ATA/ATAPI-8 ATA8-AAM ANSI INCITS 451-2008");
break;
case 0x162A:
scsiOneValue.Add("Device complies with ATA/ATAPI-8 ATA8-ACS ANSI INCITS 452-2009 w/ Amendment 1");
scsiOneValue
.Add("Device complies with ATA/ATAPI-8 ATA8-ACS ANSI INCITS 452-2009 w/ Amendment 1");
break;
case 0x1728:
scsiOneValue.Add("Device complies with Universal Serial Bus Specification, Revision 1.1");
@@ -1543,7 +1542,8 @@ namespace DiscImageChef.Server.App_Start
scsiOneValue.Add("Device complies with Universal Serial Bus Specification, Revision 2.0");
break;
case 0x1730:
scsiOneValue.Add("Device complies with USB Mass Storage Class Bulk-Only Transport, Revision 1.0");
scsiOneValue
.Add("Device complies with USB Mass Storage Class Bulk-Only Transport, Revision 1.0");
break;
case 0x1740:
scsiOneValue.Add("Device complies with UAS (no version claimed)");
@@ -1624,7 +1624,8 @@ namespace DiscImageChef.Server.App_Start
scsiOneValue.Add("Device complies with SPL ANSI INCITS 476-2011");
break;
case 0x20A8:
scsiOneValue.Add("Device complies with SPL ANSI INCITS 476-2011 + SPL AM1 INCITS 476/AM1 2012");
scsiOneValue
.Add("Device complies with SPL ANSI INCITS 476-2011 + SPL AM1 INCITS 476/AM1 2012");
break;
case 0x20AA:
scsiOneValue.Add("Device complies with SPL ISO/IEC 14776-261:2012");
@@ -1696,12 +1697,14 @@ namespace DiscImageChef.Server.App_Start
scsiOneValue.Add("Device complies with IEEE 1667-2009");
break;
default:
scsiOneValue.Add(string.Format("Device complies with unknown standard code 0x{0:X4}", VersionDescriptor));
scsiOneValue.Add(string.Format("Device complies with unknown standard code 0x{0:X4}",
VersionDescriptor));
break;
}
}
}
return scsiOneValue;
}
}
}
}

296
DiscImageChef.Server/App_Start/ScsiMmcFeatures.cs
View File

@@ -42,142 +42,85 @@ namespace DiscImageChef.Server.App_Start
{
if(ftr.SupportsAACS && ftr.AACSVersionSpecified)
mmcOneValue.Add(string.Format("Drive supports AACS version {0}", ftr.AACSVersion));
else if(ftr.SupportsAACS)
mmcOneValue.Add("Drive supports AACS");
if(ftr.AGIDsSpecified)
mmcOneValue.Add(string.Format("Drive supports {0} AGIDs concurrently", ftr.AGIDs));
else if(ftr.SupportsAACS) mmcOneValue.Add("Drive supports AACS");
if(ftr.AGIDsSpecified) mmcOneValue.Add(string.Format("Drive supports {0} AGIDs concurrently", ftr.AGIDs));
if(ftr.CanGenerateBindingNonce)
{
mmcOneValue.Add("Drive supports generating the binding nonce");
if(ftr.BindingNonceBlocksSpecified)
mmcOneValue.Add(string.Format("{0} media blocks are required for the binding nonce", ftr.BindingNonceBlocks));
mmcOneValue.Add(string.Format("{0} media blocks are required for the binding nonce",
ftr.BindingNonceBlocks));
}
if(ftr.BlocksPerReadableUnit > 1)
mmcOneValue.Add(string.Format("{0} logical blocks per media writable unit", ftr.BlocksPerReadableUnit));
if(ftr.BufferUnderrunFreeInDVD)
mmcOneValue.Add("Drive supports zero loss linking writing DVDs");
if(ftr.BufferUnderrunFreeInSAO)
mmcOneValue.Add("Drive supports zero loss linking in Session at Once Mode");
if(ftr.BufferUnderrunFreeInTAO)
mmcOneValue.Add("Drive supports zero loss linking in Track at Once Mode");
if(ftr.CanAudioScan)
mmcOneValue.Add("Drive supports the SCAN command");
if(ftr.CanEject)
mmcOneValue.Add("Drive can eject media");
if(ftr.CanEraseSector)
mmcOneValue.Add("Drive supports media that require erasing before writing");
if(ftr.CanExpandBDRESpareArea)
mmcOneValue.Add("Drive can expand the spare area on a formatted BD-RE disc");
if(ftr.CanFormat)
mmcOneValue.Add("Drive can format media into logical blocks");
if(ftr.CanFormatBDREWithoutSpare)
mmcOneValue.Add("Drive can format BD-RE with no spares allocated");
if(ftr.CanFormatQCert)
mmcOneValue.Add("Drive can format BD-RE discs with quick certification");
if(ftr.CanFormatCert)
mmcOneValue.Add("Drive can format BD-RE discs with full certification");
if(ftr.CanFormatFRF)
mmcOneValue.Add("Drive can fast re-format BD-RE discs");
if(ftr.CanFormatRRM)
mmcOneValue.Add("Drive can format BD-R discs with RRM format");
if(ftr.CanLoad)
mmcOneValue.Add("Drive can load media");
if(ftr.CanMuteSeparateChannels)
mmcOneValue.Add("Drive is able to mute channels separately");
if(ftr.CanOverwriteSAOTrack)
mmcOneValue.Add("Drive can overwrite a SAO track with another in CD-RWs");
if(ftr.CanOverwriteTAOTrack)
mmcOneValue.Add("Drive can overwrite a TAO track with another in CD-RWs");
if(ftr.CanPlayCDAudio)
mmcOneValue.Add("Drive has an analogue audio output");
if(ftr.CanPseudoOverwriteBDR)
mmcOneValue.Add("Drive can write BD-R on Pseudo-OVerwrite SRM mode");
if(ftr.CanReadAllDualR)
mmcOneValue.Add("Drive can read DVD-R DL from all recording modes");
if(ftr.CanReadAllDualRW)
mmcOneValue.Add("Drive can read DVD-RW DL from all recording modes");
if(ftr.CanReadBD)
mmcOneValue.Add("Drive can read BD-ROM");
if(ftr.CanReadBDR)
mmcOneValue.Add("Drive can read BD-R Ver.1");
if(ftr.CanReadBDRE1)
mmcOneValue.Add("Drive can read BD-RE Ver.1");
if(ftr.CanReadBDRE2)
mmcOneValue.Add("Drive can read BD-RE Ver.2");
if(ftr.CanReadBDROM)
mmcOneValue.Add("Drive can read BD-ROM Ver.1");
if(ftr.CanReadBluBCA)
mmcOneValue.Add("Drive can read BD's Burst Cutting Area");
if(ftr.CanReadCD)
mmcOneValue.Add("Drive can read CD-ROM");
if(ftr.BufferUnderrunFreeInDVD) mmcOneValue.Add("Drive supports zero loss linking writing DVDs");
if(ftr.BufferUnderrunFreeInSAO) mmcOneValue.Add("Drive supports zero loss linking in Session at Once Mode");
if(ftr.BufferUnderrunFreeInTAO) mmcOneValue.Add("Drive supports zero loss linking in Track at Once Mode");
if(ftr.CanAudioScan) mmcOneValue.Add("Drive supports the SCAN command");
if(ftr.CanEject) mmcOneValue.Add("Drive can eject media");
if(ftr.CanEraseSector) mmcOneValue.Add("Drive supports media that require erasing before writing");
if(ftr.CanExpandBDRESpareArea) mmcOneValue.Add("Drive can expand the spare area on a formatted BD-RE disc");
if(ftr.CanFormat) mmcOneValue.Add("Drive can format media into logical blocks");
if(ftr.CanFormatBDREWithoutSpare) mmcOneValue.Add("Drive can format BD-RE with no spares allocated");
if(ftr.CanFormatQCert) mmcOneValue.Add("Drive can format BD-RE discs with quick certification");
if(ftr.CanFormatCert) mmcOneValue.Add("Drive can format BD-RE discs with full certification");
if(ftr.CanFormatFRF) mmcOneValue.Add("Drive can fast re-format BD-RE discs");
if(ftr.CanFormatRRM) mmcOneValue.Add("Drive can format BD-R discs with RRM format");
if(ftr.CanLoad) mmcOneValue.Add("Drive can load media");
if(ftr.CanMuteSeparateChannels) mmcOneValue.Add("Drive is able to mute channels separately");
if(ftr.CanOverwriteSAOTrack) mmcOneValue.Add("Drive can overwrite a SAO track with another in CD-RWs");
if(ftr.CanOverwriteTAOTrack) mmcOneValue.Add("Drive can overwrite a TAO track with another in CD-RWs");
if(ftr.CanPlayCDAudio) mmcOneValue.Add("Drive has an analogue audio output");
if(ftr.CanPseudoOverwriteBDR) mmcOneValue.Add("Drive can write BD-R on Pseudo-OVerwrite SRM mode");
if(ftr.CanReadAllDualR) mmcOneValue.Add("Drive can read DVD-R DL from all recording modes");
if(ftr.CanReadAllDualRW) mmcOneValue.Add("Drive can read DVD-RW DL from all recording modes");
if(ftr.CanReadBD) mmcOneValue.Add("Drive can read BD-ROM");
if(ftr.CanReadBDR) mmcOneValue.Add("Drive can read BD-R Ver.1");
if(ftr.CanReadBDRE1) mmcOneValue.Add("Drive can read BD-RE Ver.1");
if(ftr.CanReadBDRE2) mmcOneValue.Add("Drive can read BD-RE Ver.2");
if(ftr.CanReadBDROM) mmcOneValue.Add("Drive can read BD-ROM Ver.1");
if(ftr.CanReadBluBCA) mmcOneValue.Add("Drive can read BD's Burst Cutting Area");
if(ftr.CanReadCD) mmcOneValue.Add("Drive can read CD-ROM");
if(ftr.CanWriteCDMRW && ftr.CanReadDVDPlusMRW && ftr.CanWriteDVDPlusMRW)
mmcOneValue.Add("Drive can read and write CD-MRW and DVD+MRW");
else if(ftr.CanReadDVDPlusMRW && ftr.CanWriteDVDPlusMRW)
mmcOneValue.Add("Drive can read and write DVD+MRW");
else if(ftr.CanWriteCDMRW && ftr.CanReadDVDPlusMRW)
mmcOneValue.Add("Drive and read DVD+MRW and read and write CD-MRW");
else if(ftr.CanWriteCDMRW)
mmcOneValue.Add("Drive can read and write CD-MRW");
else if(ftr.CanReadDVDPlusMRW)
mmcOneValue.Add("Drive can read CD-MRW and DVD+MRW");
else if(ftr.CanReadCDMRW)
mmcOneValue.Add("Drive can read CD-MRW");
if(ftr.CanReadCPRM_MKB)
mmcOneValue.Add("Drive supports reading Media Key Block of CPRM");
if(ftr.CanReadDDCD)
mmcOneValue.Add("Drive can read DDCDs");
if(ftr.CanReadDVD)
mmcOneValue.Add("Drive can read DVD");
if(ftr.CanWriteDVDPlusRW)
mmcOneValue.Add("Drive can read and write DVD+RW");
else if(ftr.CanReadDVDPlusRW)
mmcOneValue.Add("Drive can read DVD+RW");
if(ftr.CanWriteDVDPlusR)
mmcOneValue.Add("Drive can read and write DVD+R");
else if(ftr.CanReadDVDPlusR)
mmcOneValue.Add("Drive can read DVD+R");
if(ftr.CanWriteDVDPlusRDL)
mmcOneValue.Add("Drive can read and write DVD+R DL");
else if(ftr.CanReadDVDPlusRDL)
mmcOneValue.Add("Drive can read DVD+R DL");
if(ftr.CanReadDriveAACSCertificate)
mmcOneValue.Add("Drive supports reading the Drive Certificate");
else if(ftr.CanWriteCDMRW) mmcOneValue.Add("Drive can read and write CD-MRW");
else if(ftr.CanReadDVDPlusMRW) mmcOneValue.Add("Drive can read CD-MRW and DVD+MRW");
else if(ftr.CanReadCDMRW) mmcOneValue.Add("Drive can read CD-MRW");
if(ftr.CanReadCPRM_MKB) mmcOneValue.Add("Drive supports reading Media Key Block of CPRM");
if(ftr.CanReadDDCD) mmcOneValue.Add("Drive can read DDCDs");
if(ftr.CanReadDVD) mmcOneValue.Add("Drive can read DVD");
if(ftr.CanWriteDVDPlusRW) mmcOneValue.Add("Drive can read and write DVD+RW");
else if(ftr.CanReadDVDPlusRW) mmcOneValue.Add("Drive can read DVD+RW");
if(ftr.CanWriteDVDPlusR) mmcOneValue.Add("Drive can read and write DVD+R");
else if(ftr.CanReadDVDPlusR) mmcOneValue.Add("Drive can read DVD+R");
if(ftr.CanWriteDVDPlusRDL) mmcOneValue.Add("Drive can read and write DVD+R DL");
else if(ftr.CanReadDVDPlusRDL) mmcOneValue.Add("Drive can read DVD+R DL");
if(ftr.CanReadDriveAACSCertificate) mmcOneValue.Add("Drive supports reading the Drive Certificate");
if(ftr.CanReadHDDVD && ftr.CanReadHDDVDR && ftr.CanReadHDDVDRAM)
mmcOneValue.Add("Drive can read HD DVD-ROM, HD DVD-RW, HD DVD-R and HD DVD-RAM");
else if(ftr.CanReadHDDVD && ftr.CanReadHDDVDR)
mmcOneValue.Add("Drive can read HD DVD-ROM, HD DVD-RW and HD DVD-R");
else if(ftr.CanReadHDDVD && ftr.CanReadHDDVDRAM)
mmcOneValue.Add("Drive can read HD DVD-ROM, HD DVD-RW and HD DVD-RAM");
else if(ftr.CanReadHDDVD)
mmcOneValue.Add("Drive can read HD DVD-ROM and HD DVD-RW");
if(ftr.CanReadLeadInCDText)
mmcOneValue.Add("Drive can return CD-Text from Lead-In");
if(ftr.CanReadOldBDR)
mmcOneValue.Add("Drive can read BD-R pre-1.0");
if(ftr.CanReadOldBDRE)
mmcOneValue.Add("Drive can read BD-RE pre-1.0");
if(ftr.CanReadOldBDROM)
mmcOneValue.Add("Drive can read BD-ROM pre-1.0");
if(ftr.CanReadSpareAreaInformation)
mmcOneValue.Add("Drive can return Spare Area Information");
if(ftr.CanReportDriveSerial)
mmcOneValue.Add("Drive is to report drive serial number");
if(ftr.CanReportMediaSerial)
mmcOneValue.Add("Drive is to read media serial number");
if(ftr.CanTestWriteDDCDR)
mmcOneValue.Add("Drive can do a test writing with DDCD-R");
if(ftr.CanTestWriteDVD)
mmcOneValue.Add("Drive can do a test writing with DVDs");
if(ftr.CanTestWriteInSAO)
mmcOneValue.Add("Drive can do a test writing in Session at Once Mode");
if(ftr.CanTestWriteInTAO)
mmcOneValue.Add("Drive can do a test writing in Track at Once Mode");
if(ftr.CanUpgradeFirmware)
mmcOneValue.Add("Drive supports Microcode Upgrade");
if(ftr.ErrorRecoveryPage)
mmcOneValue.Add("Drive shall report Read/Write Error Recovery mode page");
if(ftr.Locked)
mmcOneValue.Add("Drive can lock media");
else if(ftr.CanReadHDDVD) mmcOneValue.Add("Drive can read HD DVD-ROM and HD DVD-RW");
if(ftr.CanReadLeadInCDText) mmcOneValue.Add("Drive can return CD-Text from Lead-In");
if(ftr.CanReadOldBDR) mmcOneValue.Add("Drive can read BD-R pre-1.0");
if(ftr.CanReadOldBDRE) mmcOneValue.Add("Drive can read BD-RE pre-1.0");
if(ftr.CanReadOldBDROM) mmcOneValue.Add("Drive can read BD-ROM pre-1.0");
if(ftr.CanReadSpareAreaInformation) mmcOneValue.Add("Drive can return Spare Area Information");
if(ftr.CanReportDriveSerial) mmcOneValue.Add("Drive is to report drive serial number");
if(ftr.CanReportMediaSerial) mmcOneValue.Add("Drive is to read media serial number");
if(ftr.CanTestWriteDDCDR) mmcOneValue.Add("Drive can do a test writing with DDCD-R");
if(ftr.CanTestWriteDVD) mmcOneValue.Add("Drive can do a test writing with DVDs");
if(ftr.CanTestWriteInSAO) mmcOneValue.Add("Drive can do a test writing in Session at Once Mode");
if(ftr.CanTestWriteInTAO) mmcOneValue.Add("Drive can do a test writing in Track at Once Mode");
if(ftr.CanUpgradeFirmware) mmcOneValue.Add("Drive supports Microcode Upgrade");
if(ftr.ErrorRecoveryPage) mmcOneValue.Add("Drive shall report Read/Write Error Recovery mode page");
if(ftr.Locked) mmcOneValue.Add("Drive can lock media");
if(ftr.LogicalBlockSize > 0)
mmcOneValue.Add(string.Format("{0} bytes per logical block", ftr.LogicalBlockSize));
if(ftr.MultiRead)
@@ -216,69 +159,47 @@ namespace DiscImageChef.Server.App_Start
mmcOneValue.Add("Drive uses a vendor unique interface");
break;
default:
mmcOneValue.Add(string.Format("Drive uses an unknown interface with code {0}", (uint)ftr.PhysicalInterfaceStandard));
mmcOneValue.Add(string.Format("Drive uses an unknown interface with code {0}",
(uint)ftr.PhysicalInterfaceStandard));
break;
}
if(ftr.PreventJumper)
mmcOneValue.Add("Drive power ups locked");
if(ftr.SupportsBusEncryption)
mmcOneValue.Add("Drive supports bus encryption");
if(ftr.CanWriteBD)
mmcOneValue.Add("Drive can write BD-R or BD-RE");
if(ftr.CanWriteBDR)
mmcOneValue.Add("Drive can write BD-R Ver.1");
if(ftr.CanWriteBDRE1)
mmcOneValue.Add("Drive can write BD-RE Ver.1");
if(ftr.CanWriteBDRE2)
mmcOneValue.Add("Drive can write BD-RE Ver.2");
if(ftr.CanWriteBusEncryptedBlocks)
mmcOneValue.Add("Drive supports writing with bus encryption");
if(ftr.CanWriteCDRW)
mmcOneValue.Add("Drive can write CD-RW");
if(ftr.CanWriteCDRWCAV)
mmcOneValue.Add("Drive can write High-Speed CD-RW");
if(ftr.CanWriteCDSAO && !ftr.CanWriteRaw)
mmcOneValue.Add("Drive can write CDs in Session at Once Mode:");
else if(!ftr.CanWriteCDSAO && ftr.CanWriteRaw)
mmcOneValue.Add("Drive can write CDs in raw Mode:");
if(ftr.PreventJumper) mmcOneValue.Add("Drive power ups locked");
if(ftr.SupportsBusEncryption) mmcOneValue.Add("Drive supports bus encryption");
if(ftr.CanWriteBD) mmcOneValue.Add("Drive can write BD-R or BD-RE");
if(ftr.CanWriteBDR) mmcOneValue.Add("Drive can write BD-R Ver.1");
if(ftr.CanWriteBDRE1) mmcOneValue.Add("Drive can write BD-RE Ver.1");
if(ftr.CanWriteBDRE2) mmcOneValue.Add("Drive can write BD-RE Ver.2");
if(ftr.CanWriteBusEncryptedBlocks) mmcOneValue.Add("Drive supports writing with bus encryption");
if(ftr.CanWriteCDRW) mmcOneValue.Add("Drive can write CD-RW");
if(ftr.CanWriteCDRWCAV) mmcOneValue.Add("Drive can write High-Speed CD-RW");
if(ftr.CanWriteCDSAO && !ftr.CanWriteRaw) mmcOneValue.Add("Drive can write CDs in Session at Once Mode:");
else if(!ftr.CanWriteCDSAO && ftr.CanWriteRaw) mmcOneValue.Add("Drive can write CDs in raw Mode:");
else if(ftr.CanWriteCDSAO && ftr.CanWriteRaw)
mmcOneValue.Add("Drive can write CDs in Session at Once and in Raw Modes:");
if(ftr.CanWriteCDTAO)
mmcOneValue.Add("Drive can write CDs in Track at Once Mode:");
if(ftr.CanWriteCSSManagedDVD)
mmcOneValue.Add("Drive can write CSS managed DVDs");
if(ftr.CanWriteDDCDR)
mmcOneValue.Add("Drive supports writing DDCD-R");
if(ftr.CanWriteDDCDRW)
mmcOneValue.Add("Drive supports writing DDCD-RW");
if(ftr.CanWriteDVDPlusRWDL)
mmcOneValue.Add("Drive can read and write DVD+RW DL");
else if(ftr.CanReadDVDPlusRWDL)
mmcOneValue.Add("Drive can read DVD+RW DL");
if(ftr.CanWriteCDTAO) mmcOneValue.Add("Drive can write CDs in Track at Once Mode:");
if(ftr.CanWriteCSSManagedDVD) mmcOneValue.Add("Drive can write CSS managed DVDs");
if(ftr.CanWriteDDCDR) mmcOneValue.Add("Drive supports writing DDCD-R");
if(ftr.CanWriteDDCDRW) mmcOneValue.Add("Drive supports writing DDCD-RW");
if(ftr.CanWriteDVDPlusRWDL) mmcOneValue.Add("Drive can read and write DVD+RW DL");
else if(ftr.CanReadDVDPlusRWDL) mmcOneValue.Add("Drive can read DVD+RW DL");
if(ftr.CanWriteDVDR && ftr.CanWriteDVDRW && ftr.CanWriteDVDRDL)
mmcOneValue.Add("Drive supports writing DVD-R, DVD-RW and DVD-R DL");
else if(ftr.CanWriteDVDR && ftr.CanWriteDVDRDL)
mmcOneValue.Add("Drive supports writing DVD-R and DVD-R DL");
else if(ftr.CanWriteDVDR && ftr.CanWriteDVDRW)
mmcOneValue.Add("Drive supports writing DVD-R and DVD-RW");
else if(ftr.CanWriteDVDR)
mmcOneValue.Add("Drive supports writing DVD-R");
else if(ftr.CanWriteDVDR && ftr.CanWriteDVDRW) mmcOneValue.Add("Drive supports writing DVD-R and DVD-RW");
else if(ftr.CanWriteDVDR) mmcOneValue.Add("Drive supports writing DVD-R");
if(ftr.CanWriteHDDVDR && ftr.CanWriteHDDVDRAM)
mmcOneValue.Add("Drive can write HD DVD-RW, HD DVD-R and HD DVD-RAM");
else if(ftr.CanWriteHDDVDR)
mmcOneValue.Add("Drive can write HD DVD-RW and HD DVD-R");
else if(ftr.CanWriteHDDVDRAM)
mmcOneValue.Add("Drive can write HD DVD-RW and HD DVD-RAM");
else if(ftr.CanWriteHDDVDR) mmcOneValue.Add("Drive can write HD DVD-RW and HD DVD-R");
else if(ftr.CanWriteHDDVDRAM) mmcOneValue.Add("Drive can write HD DVD-RW and HD DVD-RAM");
// TODO: Write HD DVD-RW
/*
else
mmcOneValue.Add("Drive can write HD DVD-RW");
*/
if(ftr.CanWriteOldBDR)
mmcOneValue.Add("Drive can write BD-R pre-1.0");
if(ftr.CanWriteOldBDRE)
mmcOneValue.Add("Drive can write BD-RE pre-1.0");
if(ftr.CanWriteOldBDR) mmcOneValue.Add("Drive can write BD-R pre-1.0");
if(ftr.CanWriteOldBDRE) mmcOneValue.Add("Drive can write BD-RE pre-1.0");
if(ftr.CanWriteRWSubchannelInTAO)
{
mmcOneValue.Add("Drive can write user provided data in the R-W subchannels in Track at Once Mode");
@@ -295,8 +216,7 @@ namespace DiscImageChef.Server.App_Start
{
mmcOneValue.Add("Drive contains an embedded changer");
if(ftr.ChangerIsSideChangeCapable)
mmcOneValue.Add("Drive can change disc side");
if(ftr.ChangerIsSideChangeCapable) mmcOneValue.Add("Drive can change disc side");
if(ftr.ChangerSupportsDiscPresent)
mmcOneValue.Add("Drive is able to report slots contents after a reset or change");
@@ -304,24 +224,17 @@ namespace DiscImageChef.Server.App_Start
}
if(ftr.SupportsCSS && ftr.CSSVersionSpecified)
mmcOneValue.Add(string.Format("Drive supports DVD CSS/CPPM version {0}", ftr.CSSVersion));
else if(ftr.SupportsCSS)
mmcOneValue.Add("Drive supports DVD CSS/CPRM");
else if(ftr.SupportsCSS) mmcOneValue.Add("Drive supports DVD CSS/CPRM");
if(ftr.SupportsCPRM && ftr.CPRMVersionSpecified)
mmcOneValue.Add(string.Format("Drive supports DVD CPPM version {0}", ftr.CPRMVersion));
else if(ftr.SupportsCPRM)
mmcOneValue.Add("Drive supports DVD CPRM");
if(ftr.DBML)
mmcOneValue.Add("Drive reports Device Busy Class events during medium loading/unloading");
if(ftr.DVDMultiRead)
mmcOneValue.Add("Drive conforms to DVD Multi Drive Read-only Specifications");
else if(ftr.SupportsCPRM) mmcOneValue.Add("Drive supports DVD CPRM");
if(ftr.DBML) mmcOneValue.Add("Drive reports Device Busy Class events during medium loading/unloading");
if(ftr.DVDMultiRead) mmcOneValue.Add("Drive conforms to DVD Multi Drive Read-only Specifications");
if(ftr.FirmwareDateSpecified)
mmcOneValue.Add(string.Format("Drive firmware is dated {0}", ftr.FirmwareDate));
if(ftr.SupportsC2)
mmcOneValue.Add("Drive supports C2 Error Pointers");
if(ftr.SupportsDAP)
mmcOneValue.Add("Drive supports the DAP bit in the READ CD and READ CD MSF commands");
if(ftr.SupportsDeviceBusyEvent)
mmcOneValue.Add("Drive supports Device Busy events");
if(ftr.SupportsC2) mmcOneValue.Add("Drive supports C2 Error Pointers");
if(ftr.SupportsDAP) mmcOneValue.Add("Drive supports the DAP bit in the READ CD and READ CD MSF commands");
if(ftr.SupportsDeviceBusyEvent) mmcOneValue.Add("Drive supports Device Busy events");
switch(ftr.LoadingMechanismType)
{
@@ -341,26 +254,21 @@ namespace DiscImageChef.Server.App_Start
mmcOneValue.Add("Drive is a changer using cartridges");
break;
default:
mmcOneValue.Add(string.Format("Drive uses unknown loading mechanism type {0}", ftr.LoadingMechanismType));
mmcOneValue.Add(string.Format("Drive uses unknown loading mechanism type {0}",
ftr.LoadingMechanismType));
break;
}
if(ftr.SupportsHybridDiscs)
mmcOneValue.Add("Drive is able to access Hybrid discs");
if(ftr.SupportsHybridDiscs) mmcOneValue.Add("Drive is able to access Hybrid discs");
if(ftr.SupportsModePage1Ch)
mmcOneValue.Add("Drive supports the Informational Exceptions Control mode page 1Ch");
if(ftr.SupportsOSSC)
mmcOneValue.Add("Drive supports the Trusted Computing Group Optical Security Subsystem Class");
if(ftr.SupportsPWP)
mmcOneValue.Add("Drive supports set/release of PWP status");
if(ftr.SupportsSWPP)
mmcOneValue.Add("Drive supports the SWPP bit of the Timeout and Protect mode page");
if(ftr.SupportsSecurDisc)
mmcOneValue.Add("Drive supports SecurDisc");
if(ftr.SupportsSeparateVolume)
mmcOneValue.Add("Drive supports separate volume per channel");
if(ftr.SupportsVCPS)
mmcOneValue.Add("Drive supports VCPS");
if(ftr.SupportsPWP) mmcOneValue.Add("Drive supports set/release of PWP status");
if(ftr.SupportsSWPP) mmcOneValue.Add("Drive supports the SWPP bit of the Timeout and Protect mode page");
if(ftr.SupportsSecurDisc) mmcOneValue.Add("Drive supports SecurDisc");
if(ftr.SupportsSeparateVolume) mmcOneValue.Add("Drive supports separate volume per channel");
if(ftr.SupportsVCPS) mmcOneValue.Add("Drive supports VCPS");
if(ftr.VolumeLevelsSpecified)
mmcOneValue.Add(string.Format("Drive has {0} volume levels", ftr.VolumeLevels + 1));
if(ftr.SupportsWriteProtectPAC)
@@ -372,4 +280,4 @@ namespace DiscImageChef.Server.App_Start
mmcOneValue.Add("");
}
}
}
}

138
DiscImageChef.Server/App_Start/ScsiMmcMode.cs
View File

@@ -39,29 +39,19 @@ namespace DiscImageChef.Server.App_Start
{
public static void Report(mmcModeType mode, ref List<string> mmcOneValue)
{
if(mode.PlaysAudio)
mmcOneValue.Add("Drive can play audio");
if(mode.ReadsMode2Form1)
mmcOneValue.Add("Drive can read sectors in Mode 2 Form 1 format");
if(mode.ReadsMode2Form2)
mmcOneValue.Add("Drive can read sectors in Mode 2 Form 2 format");
if(mode.SupportsMultiSession)
mmcOneValue.Add("Drive supports multi-session discs and/or Photo-CD");
if(mode.PlaysAudio) mmcOneValue.Add("Drive can play audio");
if(mode.ReadsMode2Form1) mmcOneValue.Add("Drive can read sectors in Mode 2 Form 1 format");
if(mode.ReadsMode2Form2) mmcOneValue.Add("Drive can read sectors in Mode 2 Form 2 format");
if(mode.SupportsMultiSession) mmcOneValue.Add("Drive supports multi-session discs and/or Photo-CD");
if(mode.CDDACommand)
mmcOneValue.Add("Drive can read digital audio");
if(mode.AccurateCDDA)
mmcOneValue.Add("Drive can continue from streaming loss");
if(mode.ReadsSubchannel)
mmcOneValue.Add("Drive can read uncorrected and interleaved R-W subchannels");
if(mode.CDDACommand) mmcOneValue.Add("Drive can read digital audio");
if(mode.AccurateCDDA) mmcOneValue.Add("Drive can continue from streaming loss");
if(mode.ReadsSubchannel) mmcOneValue.Add("Drive can read uncorrected and interleaved R-W subchannels");
if(mode.ReadsDeinterlavedSubchannel)
mmcOneValue.Add("Drive can read, deinterleave and correct R-W subchannels");
if(mode.ReturnsC2Pointers)
mmcOneValue.Add("Drive supports C2 pointers");
if(mode.ReadsUPC)
mmcOneValue.Add("Drive can read Media Catalogue Number");
if(mode.ReadsISRC)
mmcOneValue.Add("Drive can read ISRC");
if(mode.ReturnsC2Pointers) mmcOneValue.Add("Drive supports C2 pointers");
if(mode.ReadsUPC) mmcOneValue.Add("Drive can read Media Catalogue Number");
if(mode.ReadsISRC) mmcOneValue.Add("Drive can read ISRC");
switch(mode.LoadingMechanismType)
{
@@ -81,39 +71,32 @@ namespace DiscImageChef.Server.App_Start
mmcOneValue.Add("Drive is a changer using cartridges");
break;
default:
mmcOneValue.Add(string.Format("Drive uses unknown loading mechanism type {0}", mode.LoadingMechanismType));
mmcOneValue.Add(string.Format("Drive uses unknown loading mechanism type {0}",
mode.LoadingMechanismType));
break;
}
if(mode.CanLockMedia)
mmcOneValue.Add("Drive can lock media");
if(mode.CanLockMedia) mmcOneValue.Add("Drive can lock media");
if(mode.PreventJumperStatus)
{
mmcOneValue.Add("Drive power ups locked");
if(mode.LockStatus)
mmcOneValue.Add("Drive is locked, media cannot be ejected or inserted");
else
mmcOneValue.Add("Drive is not locked, media can be ejected and inserted");
if(mode.LockStatus) mmcOneValue.Add("Drive is locked, media cannot be ejected or inserted");
else mmcOneValue.Add("Drive is not locked, media can be ejected and inserted");
}
else
{
if(mode.LockStatus)
mmcOneValue.Add("Drive is locked, media cannot be ejected, but if empty, can be inserted");
else
mmcOneValue.Add("Drive is not locked, media can be ejected and inserted");
else mmcOneValue.Add("Drive is not locked, media can be ejected and inserted");
}
if(mode.CanEject)
mmcOneValue.Add("Drive can eject media");
if(mode.CanEject) mmcOneValue.Add("Drive can eject media");
if(mode.SeparateChannelMute)
mmcOneValue.Add("Each channel can be muted independently");
if(mode.SeparateChannelVolume)
mmcOneValue.Add("Each channel's volume can be controlled independently");
if(mode.SeparateChannelMute) mmcOneValue.Add("Each channel can be muted independently");
if(mode.SeparateChannelVolume) mmcOneValue.Add("Each channel's volume can be controlled independently");
if(mode.SupportedVolumeLevels > 0)
mmcOneValue.Add(string.Format("Drive supports {0} volume levels", mode.SupportedVolumeLevels));
if(mode.BufferSize > 0)
mmcOneValue.Add(string.Format("Drive has {0} Kbyte of buffer", mode.BufferSize));
if(mode.BufferSize > 0) mmcOneValue.Add(string.Format("Drive has {0} Kbyte of buffer", mode.BufferSize));
if(mode.MaximumSpeed > 0)
mmcOneValue.Add(string.Format("Drive's maximum reading speed is {0} Kbyte/sec.", mode.MaximumSpeed));
if(mode.CurrentSpeed > 0)
@@ -121,97 +104,86 @@ namespace DiscImageChef.Server.App_Start
if(mode.ReadsCDR)
{
if(mode.WritesCDR)
mmcOneValue.Add("Drive can read and write CD-R");
else
mmcOneValue.Add("Drive can read CD-R");
if(mode.WritesCDR) mmcOneValue.Add("Drive can read and write CD-R");
else mmcOneValue.Add("Drive can read CD-R");
if(mode.ReadsPacketCDR)
mmcOneValue.Add("Drive supports reading CD-R packet media");
if(mode.ReadsPacketCDR) mmcOneValue.Add("Drive supports reading CD-R packet media");
}
if(mode.ReadsCDRW)
{
if(mode.WritesCDRW)
mmcOneValue.Add("Drive can read and write CD-RW");
else
mmcOneValue.Add("Drive can read CD-RW");
if(mode.WritesCDRW) mmcOneValue.Add("Drive can read and write CD-RW");
else mmcOneValue.Add("Drive can read CD-RW");
}
if(mode.ReadsDVDROM)
mmcOneValue.Add("Drive can read DVD-ROM");
if(mode.ReadsDVDROM) mmcOneValue.Add("Drive can read DVD-ROM");
if(mode.ReadsDVDR)
{
if(mode.WritesDVDR)
mmcOneValue.Add("Drive can read and write DVD-R");
else
mmcOneValue.Add("Drive can read DVD-R");
if(mode.WritesDVDR) mmcOneValue.Add("Drive can read and write DVD-R");
else mmcOneValue.Add("Drive can read DVD-R");
}
if(mode.ReadsDVDRAM)
{
if(mode.WritesDVDRAM)
mmcOneValue.Add("Drive can read and write DVD-RAM");
else
mmcOneValue.Add("Drive can read DVD-RAM");
if(mode.WritesDVDRAM) mmcOneValue.Add("Drive can read and write DVD-RAM");
else mmcOneValue.Add("Drive can read DVD-RAM");
}
if(mode.CompositeAudioVideo)
mmcOneValue.Add("Drive can deliver a composite audio and video data stream");
if(mode.DigitalPort1)
mmcOneValue.Add("Drive supports IEC-958 digital output on port 1");
if(mode.DigitalPort2)
mmcOneValue.Add("Drive supports IEC-958 digital output on port 2");
if(mode.CompositeAudioVideo) mmcOneValue.Add("Drive can deliver a composite audio and video data stream");
if(mode.DigitalPort1) mmcOneValue.Add("Drive supports IEC-958 digital output on port 1");
if(mode.DigitalPort2) mmcOneValue.Add("Drive supports IEC-958 digital output on port 2");
if(mode.DeterministicSlotChanger)
mmcOneValue.Add("Drive contains a changer that can report the exact contents of the slots");
if(mode.CurrentWriteSpeedSelected > 0)
{
if(mode.RotationControlSelected == 0)
mmcOneValue.Add(string.Format("Drive's current writing speed is {0} Kbyte/sec. in CLV mode", mode.CurrentWriteSpeedSelected));
mmcOneValue.Add(string.Format("Drive's current writing speed is {0} Kbyte/sec. in CLV mode",
mode.CurrentWriteSpeedSelected));
else if(mode.RotationControlSelected == 1)
mmcOneValue.Add(string.Format("Drive's current writing speed is {0} Kbyte/sec. in pure CAV mode", mode.CurrentWriteSpeedSelected));
mmcOneValue.Add(string.Format("Drive's current writing speed is {0} Kbyte/sec. in pure CAV mode",
mode.CurrentWriteSpeedSelected));
}
else
{
if(mode.MaximumWriteSpeed > 0)
mmcOneValue.Add(string.Format("Drive's maximum writing speed is {0} Kbyte/sec.", mode.MaximumWriteSpeed));
mmcOneValue.Add(string.Format("Drive's maximum writing speed is {0} Kbyte/sec.",
mode.MaximumWriteSpeed));
if(mode.CurrentWriteSpeed > 0)
mmcOneValue.Add(string.Format("Drive's current writing speed is {0} Kbyte/sec.", mode.CurrentWriteSpeed));
mmcOneValue.Add(string.Format("Drive's current writing speed is {0} Kbyte/sec.",
mode.CurrentWriteSpeed));
}
if(mode.WriteSpeedPerformanceDescriptors != null)
{
foreach(Decoders.SCSI.Modes.ModePage_2A_WriteDescriptor descriptor in mode.WriteSpeedPerformanceDescriptors)
foreach(Decoders.SCSI.Modes.ModePage_2A_WriteDescriptor descriptor in
mode.WriteSpeedPerformanceDescriptors)
{
if(descriptor.WriteSpeed > 0)
{
if(descriptor.RotationControl == 0)
mmcOneValue.Add(string.Format("Drive supports writing at {0} Kbyte/sec. in CLV mode", descriptor.WriteSpeed));
mmcOneValue.Add(string.Format("Drive supports writing at {0} Kbyte/sec. in CLV mode",
descriptor.WriteSpeed));
else if(descriptor.RotationControl == 1)
mmcOneValue.Add(string.Format("Drive supports writing at is {0} Kbyte/sec. in pure CAV mode", descriptor.WriteSpeed));
mmcOneValue
.Add(string.Format("Drive supports writing at is {0} Kbyte/sec. in pure CAV mode",
descriptor.WriteSpeed));
}
}
}
if(mode.TestWrite)
mmcOneValue.Add("Drive supports test writing");
if(mode.TestWrite) mmcOneValue.Add("Drive supports test writing");
if(mode.ReadsBarcode)
mmcOneValue.Add("Drive can read barcode");
if(mode.ReadsBarcode) mmcOneValue.Add("Drive can read barcode");
if(mode.ReadsBothSides)
mmcOneValue.Add("Drive can read both sides of a disc");
if(mode.LeadInPW)
mmcOneValue.Add("Drive an read raw R-W subchannel from the Lead-In");
if(mode.ReadsBothSides) mmcOneValue.Add("Drive can read both sides of a disc");
if(mode.LeadInPW) mmcOneValue.Add("Drive an read raw R-W subchannel from the Lead-In");
if(mode.CSSandCPPMSupported)
mmcOneValue.Add("Drive supports DVD CSS and/or DVD CPPM");
if(mode.CSSandCPPMSupported) mmcOneValue.Add("Drive supports DVD CSS and/or DVD CPPM");
if(mode.BufferUnderRunProtection)
mmcOneValue.Add("Drive supports buffer under-run free recording");
if(mode.BufferUnderRunProtection) mmcOneValue.Add("Drive supports buffer under-run free recording");
mmcOneValue.Sort();
mmcOneValue.Add("");
}
}
}
}

532
DiscImageChef.Server/App_Start/ScsiModeSense.cs
View File

@@ -38,12 +38,12 @@ namespace DiscImageChef.Server.App_Start
{
public static class ScsiModeSense
{
public static void Report(modeType modeSense, string vendor, PeripheralDeviceTypes deviceType, ref List<string> scsiOneValue, ref Dictionary<string, string> modePages)
public static void Report(modeType modeSense, string vendor, PeripheralDeviceTypes deviceType,
ref List<string> scsiOneValue, ref Dictionary<string, string> modePages)
{
if(modeSense.MediumTypeSpecified)
scsiOneValue.Add(string.Format("Medium type is {0:X2}h", modeSense.MediumType));
if(modeSense.WriteProtected)
scsiOneValue.Add("Device is write protected.");
if(modeSense.WriteProtected) scsiOneValue.Add("Device is write protected.");
if(modeSense.BlockDescriptors != null)
{
foreach(blockDescriptorType descriptor in modeSense.BlockDescriptors)
@@ -51,14 +51,12 @@ namespace DiscImageChef.Server.App_Start
if(descriptor.BlocksSpecified && descriptor.BlockLengthSpecified)
scsiOneValue.Add(string.Format("Density code {0:X2}h has {1} blocks of {2} bytes each",
descriptor.Density, descriptor.Blocks, descriptor.BlockLength));
else
scsiOneValue.Add(string.Format("Density code {0:X2}h", descriptor.Density));
else scsiOneValue.Add(string.Format("Density code {0:X2}h", descriptor.Density));
}
}
if(modeSense.DPOandFUA)
scsiOneValue.Add("Drive supports DPO and FUA bits");
if(modeSense.BlankCheckEnabled)
scsiOneValue.Add("Blank checking during write is enabled");
if(modeSense.DPOandFUA) scsiOneValue.Add("Drive supports DPO and FUA bits");
if(modeSense.BlankCheckEnabled) scsiOneValue.Add("Blank checking during write is enabled");
if(modeSense.BufferedModeSpecified)
{
switch(modeSense.BufferedMode)
@@ -85,327 +83,340 @@ namespace DiscImageChef.Server.App_Start
switch(page.page)
{
case 0x00:
{
if(deviceType == PeripheralDeviceTypes.MultiMediaDevice && page.subpage == 0)
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
Modes.PrettifyModePage_00_SFF(page.value));
else
{
if(deviceType == PeripheralDeviceTypes.MultiMediaDevice && page.subpage == 0)
modePages.Add(string.Format("MODE page {0:X2}h", page.page), Modes.PrettifyModePage_00_SFF(page.value));
if(page.subpage != 0)
modePages
.Add(string.Format("MODE page {0:X2}h subpage {1:X2}h", page.page, page.subpage),
"Unknown vendor mode page");
else
{
if(page.subpage != 0)
modePages.Add(string.Format("MODE page {0:X2}h subpage {1:X2}h", page.page, page.subpage), "Unknown vendor mode page");
else
modePages.Add(string.Format("MODE page {0:X2}h", page.page), "Unknown vendor mode page");
}
break;
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
"Unknown vendor mode page");
}
break;
}
case 0x01:
{
if(page.subpage == 0)
{
if(page.subpage == 0)
{
if(deviceType == PeripheralDeviceTypes.MultiMediaDevice)
modePages.Add(string.Format("MODE page {0:X2}h", page.page), Modes.PrettifyModePage_01_MMC(page.value));
else
modePages.Add(string.Format("MODE page {0:X2}h", page.page), Modes.PrettifyModePage_01(page.value));
}
if(deviceType == PeripheralDeviceTypes.MultiMediaDevice)
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
Modes.PrettifyModePage_01_MMC(page.value));
else
goto default;
break;
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
Modes.PrettifyModePage_01(page.value));
}
else goto default;
break;
}
case 0x02:
{
if(page.subpage == 0)
modePages.Add(string.Format("MODE page {0:X2}h", page.page), Modes.PrettifyModePage_02(page.value));
else
goto default;
{
if(page.subpage == 0)
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
Modes.PrettifyModePage_02(page.value));
else goto default;
break;
}
break;
}
case 0x03:
{
if(page.subpage == 0)
modePages.Add(string.Format("MODE page {0:X2}h", page.page), Modes.PrettifyModePage_03(page.value));
else
goto default;
{
if(page.subpage == 0)
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
Modes.PrettifyModePage_03(page.value));
else goto default;
break;
}
break;
}
case 0x04:
{
if(page.subpage == 0)
modePages.Add(string.Format("MODE page {0:X2}h", page.page), Modes.PrettifyModePage_04(page.value));
else
goto default;
{
if(page.subpage == 0)
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
Modes.PrettifyModePage_04(page.value));
else goto default;
break;
}
break;
}
case 0x05:
{
if(page.subpage == 0)
modePages.Add(string.Format("MODE page {0:X2}h", page.page), Modes.PrettifyModePage_05(page.value));
else
goto default;
{
if(page.subpage == 0)
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
Modes.PrettifyModePage_05(page.value));
else goto default;
break;
}
break;
}
case 0x06:
{
if(page.subpage == 0)
modePages.Add(string.Format("MODE page {0:X2}h", page.page), Modes.PrettifyModePage_06(page.value));
else
goto default;
{
if(page.subpage == 0)
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
Modes.PrettifyModePage_06(page.value));
else goto default;
break;
}
break;
}
case 0x07:
{
if(page.subpage == 0)
{
if(page.subpage == 0)
{
if(deviceType == PeripheralDeviceTypes.MultiMediaDevice)
modePages.Add(string.Format("MODE page {0:X2}h", page.page), Modes.PrettifyModePage_07_MMC(page.value));
else
modePages.Add(string.Format("MODE page {0:X2}h", page.page), Modes.PrettifyModePage_07(page.value));
}
if(deviceType == PeripheralDeviceTypes.MultiMediaDevice)
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
Modes.PrettifyModePage_07_MMC(page.value));
else
goto default;
break;
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
Modes.PrettifyModePage_07(page.value));
}
else goto default;
break;
}
case 0x08:
{
if(page.subpage == 0)
modePages.Add(string.Format("MODE page {0:X2}h", page.page), Modes.PrettifyModePage_08(page.value));
else
goto default;
{
if(page.subpage == 0)
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
Modes.PrettifyModePage_08(page.value));
else goto default;
break;
}
break;
}
case 0x0A:
{
if(page.subpage == 0)
modePages.Add(string.Format("MODE page {0:X2}h", page.page), Modes.PrettifyModePage_0A(page.value));
else if(page.subpage == 1)
modePages.Add(string.Format("MODE page {0:X2}h", page.page), Modes.PrettifyModePage_0A_S01(page.value));
else
goto default;
{
if(page.subpage == 0)
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
Modes.PrettifyModePage_0A(page.value));
else if(page.subpage == 1)
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
Modes.PrettifyModePage_0A_S01(page.value));
else goto default;
break;
}
break;
}
case 0x0B:
{
if(page.subpage == 0)
modePages.Add(string.Format("MODE page {0:X2}h", page.page), Modes.PrettifyModePage_0B(page.value));
else
goto default;
{
if(page.subpage == 0)
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
Modes.PrettifyModePage_0B(page.value));
else goto default;
break;
}
break;
}
case 0x0D:
{
if(page.subpage == 0)
modePages.Add(string.Format("MODE page {0:X2}h", page.page), Modes.PrettifyModePage_0D(page.value));
else
goto default;
{
if(page.subpage == 0)
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
Modes.PrettifyModePage_0D(page.value));
else goto default;
break;
}
break;
}
case 0x0E:
{
if(page.subpage == 0)
modePages.Add(string.Format("MODE page {0:X2}h", page.page), Modes.PrettifyModePage_0E(page.value));
else
goto default;
{
if(page.subpage == 0)
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
Modes.PrettifyModePage_0E(page.value));
else goto default;
break;
}
break;
}
case 0x0F:
{
if(page.subpage == 0)
modePages.Add(string.Format("MODE page {0:X2}h", page.page), Modes.PrettifyModePage_0F(page.value));
else
goto default;
{
if(page.subpage == 0)
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
Modes.PrettifyModePage_0F(page.value));
else goto default;
break;
}
break;
}
case 0x10:
{
if(page.subpage == 0)
{
if(page.subpage == 0)
{
if(deviceType == Decoders.SCSI.PeripheralDeviceTypes.SequentialAccess)
modePages.Add(string.Format("MODE page {0:X2}h", page.page), Modes.PrettifyModePage_10_SSC(page.value));
else
modePages.Add(string.Format("MODE page {0:X2}h", page.page), Modes.PrettifyModePage_10(page.value));
}
if(deviceType == Decoders.SCSI.PeripheralDeviceTypes.SequentialAccess)
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
Modes.PrettifyModePage_10_SSC(page.value));
else
goto default;
break;
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
Modes.PrettifyModePage_10(page.value));
}
else goto default;
break;
}
case 0x11:
{
if(page.subpage == 0)
modePages.Add(string.Format("MODE page {0:X2}h", page.page), Modes.PrettifyModePage_11(page.value));
else
goto default;
{
if(page.subpage == 0)
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
Modes.PrettifyModePage_11(page.value));
else goto default;
break;
}
break;
}
case 0x12:
case 0x13:
case 0x14:
{
if(page.subpage == 0)
modePages.Add(string.Format("MODE page {0:X2}h", page.page), Modes.PrettifyModePage_12_13_14(page.value));
else
goto default;
{
if(page.subpage == 0)
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
Modes.PrettifyModePage_12_13_14(page.value));
else goto default;
break;
}
break;
}
case 0x1A:
{
if(page.subpage == 0)
modePages.Add(string.Format("MODE page {0:X2}h", page.page), Modes.PrettifyModePage_1A(page.value));
else if(page.subpage == 1)
modePages.Add(string.Format("MODE page {0:X2}h", page.page), Modes.PrettifyModePage_1A_S01(page.value));
else
goto default;
{
if(page.subpage == 0)
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
Modes.PrettifyModePage_1A(page.value));
else if(page.subpage == 1)
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
Modes.PrettifyModePage_1A_S01(page.value));
else goto default;
break;
}
break;
}
case 0x1B:
{
if(page.subpage == 0)
modePages.Add(string.Format("MODE page {0:X2}h", page.page), Modes.PrettifyModePage_1B(page.value));
else
goto default;
{
if(page.subpage == 0)
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
Modes.PrettifyModePage_1B(page.value));
else goto default;
break;
}
break;
}
case 0x1C:
{
if(page.subpage == 0)
{
if(page.subpage == 0)
{
if(deviceType == PeripheralDeviceTypes.MultiMediaDevice)
modePages.Add(string.Format("MODE page {0:X2}h", page.page), Modes.PrettifyModePage_1C_SFF(page.value));
else
modePages.Add(string.Format("MODE page {0:X2}h", page.page), Modes.PrettifyModePage_1C(page.value));
}
else if(page.subpage == 1)
modePages.Add(string.Format("MODE page {0:X2}h", page.page), Modes.PrettifyModePage_1C_S01(page.value));
if(deviceType == PeripheralDeviceTypes.MultiMediaDevice)
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
Modes.PrettifyModePage_1C_SFF(page.value));
else
goto default;
break;
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
Modes.PrettifyModePage_1C(page.value));
}
else if(page.subpage == 1)
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
Modes.PrettifyModePage_1C_S01(page.value));
else goto default;
break;
}
case 0x1D:
{
if(page.subpage == 0)
modePages.Add(string.Format("MODE page {0:X2}h", page.page), Modes.PrettifyModePage_1D(page.value));
else
goto default;
{
if(page.subpage == 0)
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
Modes.PrettifyModePage_1D(page.value));
else goto default;
break;
}
break;
}
case 0x21:
{
if(vendor == "CERTANCE")
modePages.Add(string.Format("MODE page {0:X2}h", page.page), Modes.PrettifyCertanceModePage_21(page.value));
else
goto default;
{
if(vendor == "CERTANCE")
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
Modes.PrettifyCertanceModePage_21(page.value));
else goto default;
break;
}
break;
}
case 0x22:
{
if(vendor == "CERTANCE")
modePages.Add(string.Format("MODE page {0:X2}h", page.page), Modes.PrettifyCertanceModePage_22(page.value));
else
goto default;
{
if(vendor == "CERTANCE")
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
Modes.PrettifyCertanceModePage_22(page.value));
else goto default;
break;
}
break;
}
case 0x24:
{
if(vendor == "IBM")
modePages.Add(string.Format("MODE page {0:X2}h", page.page), Modes.PrettifyIBMModePage_24(page.value));
else
goto default;
{
if(vendor == "IBM")
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
Modes.PrettifyIBMModePage_24(page.value));
else goto default;
break;
}
break;
}
case 0x2A:
{
if(page.subpage == 0)
modePages.Add(string.Format("MODE page {0:X2}h", page.page), Modes.PrettifyModePage_2A(page.value));
else
goto default;
{
if(page.subpage == 0)
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
Modes.PrettifyModePage_2A(page.value));
else goto default;
break;
}
break;
}
case 0x2F:
{
if(vendor == "IBM")
modePages.Add(string.Format("MODE page {0:X2}h", page.page), Modes.PrettifyIBMModePage_2F(page.value));
else
goto default;
{
if(vendor == "IBM")
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
Modes.PrettifyIBMModePage_2F(page.value));
else goto default;
break;
}
break;
}
case 0x30:
{
if(Modes.IsAppleModePage_30(page.value))
modePages.Add("MODE page 30h", "Drive identifies as an Apple OEM drive");
else
goto default;
{
if(Modes.IsAppleModePage_30(page.value))
modePages.Add("MODE page 30h", "Drive identifies as an Apple OEM drive");
else goto default;
break;
}
break;
}
case 0x3B:
{
if(vendor == "HP")
modePages.Add(string.Format("MODE page {0:X2}h", page.page), Modes.PrettifyHPModePage_3B(page.value));
else
goto default;
{
if(vendor == "HP")
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
Modes.PrettifyHPModePage_3B(page.value));
else goto default;
break;
}
break;
}
case 0x3C:
{
if(vendor == "HP")
modePages.Add(string.Format("MODE page {0:X2}h", page.page), Modes.PrettifyHPModePage_3C(page.value));
else
goto default;
{
if(vendor == "HP")
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
Modes.PrettifyHPModePage_3C(page.value));
else goto default;
break;
}
break;
}
case 0x3D:
{
if(vendor == "IBM")
modePages.Add(string.Format("MODE page {0:X2}h", page.page), Modes.PrettifyIBMModePage_3D(page.value));
else if(vendor == "HP")
modePages.Add(string.Format("MODE page {0:X2}h", page.page), Modes.PrettifyHPModePage_3D(page.value));
else
goto default;
{
if(vendor == "IBM")
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
Modes.PrettifyIBMModePage_3D(page.value));
else if(vendor == "HP")
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
Modes.PrettifyHPModePage_3D(page.value));
else goto default;
break;
}
break;
}
case 0x3E:
{
if(vendor == "FUJITSU")
modePages.Add(string.Format("MODE page {0:X2}h", page.page), Modes.PrettifyFujitsuModePage_3E(page.value));
else if(vendor == "HP")
modePages.Add(string.Format("MODE page {0:X2}h", page.page), Modes.PrettifyHPModePage_3E(page.value));
else
goto default;
{
if(vendor == "FUJITSU")
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
Modes.PrettifyFujitsuModePage_3E(page.value));
else if(vendor == "HP")
modePages.Add(string.Format("MODE page {0:X2}h", page.page),
Modes.PrettifyHPModePage_3E(page.value));
else goto default;
break;
}
break;
}
default:
{
if(page.subpage != 0)
modePages.Add(string.Format("MODE page {0:X2}h subpage {1:X2}h", page.page, page.subpage), "Unknown mode page");
else
modePages.Add(string.Format("MODE page {0:X2}h", page.page), "Unknown mode page");
}
{
if(page.subpage != 0)
modePages
.Add(string.Format("MODE page {0:X2}h subpage {1:X2}h", page.page, page.subpage),
"Unknown mode page");
else modePages.Add(string.Format("MODE page {0:X2}h", page.page), "Unknown mode page");
}
break;
}
}
@@ -413,13 +424,12 @@ namespace DiscImageChef.Server.App_Start
Dictionary<string, string> newModePages = new Dictionary<string, string>();
foreach(KeyValuePair<string, string> kvp in modePages)
{
if(string.IsNullOrWhiteSpace(kvp.Value))
newModePages.Add(kvp.Key, "Undecoded");
else
newModePages.Add(kvp.Key, kvp.Value.Replace("\n", "<br/>"));
if(string.IsNullOrWhiteSpace(kvp.Value)) newModePages.Add(kvp.Key, "Undecoded");
else newModePages.Add(kvp.Key, kvp.Value.Replace("\n", "<br/>"));
}
modePages = newModePages;
}
}
}
}
}

14
DiscImageChef.Server/App_Start/SscTestedMedia.cs
View File

@@ -43,14 +43,14 @@ namespace DiscImageChef.Server.App_Start
{
if(!string.IsNullOrWhiteSpace(media.MediumTypeName))
{
mediaOneValue.Add(string.Format("<i>Information for medium named \"{0}\"</i>", media.MediumTypeName));
mediaOneValue.Add(string.Format("<i>Information for medium named \"{0}\"</i>",
media.MediumTypeName));
if(media.MediumTypeSpecified)
mediaOneValue.Add(string.Format("Medium type code: {0:X2}h", media.MediumType));
}
else if(media.MediumTypeSpecified)
mediaOneValue.Add(string.Format("<i>Information for medium type {0:X2}h</i>", media.MediumType));
else
mediaOneValue.Add("<i>Information for unknown medium type</i>");
else mediaOneValue.Add("<i>Information for unknown medium type</i>");
if(!string.IsNullOrWhiteSpace(media.Manufacturer))
mediaOneValue.Add(string.Format("Medium manufactured by: {0}", media.Manufacturer));
@@ -59,13 +59,11 @@ namespace DiscImageChef.Server.App_Start
if(media.DensitySpecified)
mediaOneValue.Add(string.Format("Medium has density code {0:X2}h", media.Density));
if(media.CanReadMediaSerial)
mediaOneValue.Add("Drive can read medium serial number.");
if(media.MediaIsRecognized)
mediaOneValue.Add("DiscImageChef recognizes this medium.");
if(media.CanReadMediaSerial) mediaOneValue.Add("Drive can read medium serial number.");
if(media.MediaIsRecognized) mediaOneValue.Add("DiscImageChef recognizes this medium.");
mediaOneValue.Add("");
}
}
}
}
}

187
DiscImageChef.Server/App_Start/TestedMedia.cs
View File

@@ -43,20 +43,19 @@ namespace DiscImageChef.Server.App_Start
{
if(!string.IsNullOrWhiteSpace(testedMedia.MediumTypeName))
{
mediaOneValue.Add(string.Format("<i>Information for medium named \"{0}\"</i>", testedMedia.MediumTypeName));
mediaOneValue.Add(string.Format("<i>Information for medium named \"{0}\"</i>",
testedMedia.MediumTypeName));
if(testedMedia.MediumTypeSpecified)
mediaOneValue.Add(string.Format("Medium type code: {0:X2}h", testedMedia.MediumType));
}
else if(testedMedia.MediumTypeSpecified)
mediaOneValue.Add(string.Format("<i>Information for medium type {0:X2}h</i>", testedMedia.MediumType));
else
mediaOneValue.Add("<i>Information for unknown medium type</i>");
mediaOneValue.Add(string.Format("<i>Information for medium type {0:X2}h</i>",
testedMedia.MediumType));
else mediaOneValue.Add("<i>Information for unknown medium type</i>");
if(testedMedia.MediaIsRecognized) mediaOneValue.Add("Drive recognizes this medium.");
else mediaOneValue.Add("Drive does not recognize this medium.");
if(testedMedia.MediaIsRecognized)
mediaOneValue.Add("Drive recognizes this medium.");
else
mediaOneValue.Add("Drive does not recognize this medium.");
if(!string.IsNullOrWhiteSpace(testedMedia.Manufacturer))
mediaOneValue.Add(string.Format("Medium manufactured by: {0}", testedMedia.Manufacturer));
if(!string.IsNullOrWhiteSpace(testedMedia.Model))
@@ -73,35 +72,55 @@ namespace DiscImageChef.Server.App_Start
if(testedMedia.BlocksSpecified && testedMedia.BlockSizeSpecified)
{
mediaOneValue.Add(string.Format("Medium has {0} blocks of {1} bytes each", testedMedia.Blocks, testedMedia.BlockSize));
mediaOneValue.Add(string.Format("Medium has {0} blocks of {1} bytes each", testedMedia.Blocks,
testedMedia.BlockSize));
if(((testedMedia.Blocks * testedMedia.BlockSize) / 1024 / 1024) > 1000000)
{
mediaOneValue.Add(string.Format("Medium size: {0} bytes, {1} Tb, {2:F2} TiB", testedMedia.Blocks * testedMedia.BlockSize,
(testedMedia.Blocks * testedMedia.BlockSize) / 1000 / 1000 / 1000 / 1000, (double)(testedMedia.Blocks * testedMedia.BlockSize) / 1024 / 1024 / 1024 / 1024));
mediaOneValue.Add(string.Format("Medium size: {0} bytes, {1} Tb, {2:F2} TiB",
testedMedia.Blocks * testedMedia.BlockSize,
(testedMedia.Blocks * testedMedia.BlockSize) / 1000 / 1000 /
1000 / 1000,
(double)(testedMedia.Blocks * testedMedia.BlockSize) / 1024 /
1024 / 1024 / 1024));
}
else if(((testedMedia.Blocks * testedMedia.BlockSize) / 1024 / 1024) > 1000)
{
mediaOneValue.Add(string.Format("Medium size: {0} bytes, {1} Gb, {2:F2} GiB", testedMedia.Blocks * testedMedia.BlockSize,
(testedMedia.Blocks * testedMedia.BlockSize) / 1000 / 1000 / 1000, (double)(testedMedia.Blocks * testedMedia.BlockSize) / 1024 / 1024 / 1024));
mediaOneValue.Add(string.Format("Medium size: {0} bytes, {1} Gb, {2:F2} GiB",
testedMedia.Blocks * testedMedia.BlockSize,
(testedMedia.Blocks * testedMedia.BlockSize) / 1000 / 1000 /
1000,
(double)(testedMedia.Blocks * testedMedia.BlockSize) / 1024 /
1024 / 1024));
}
else
{
mediaOneValue.Add(string.Format("Medium size: {0} bytes, {1} Mb, {2:F2} MiB", testedMedia.Blocks * testedMedia.BlockSize,
(testedMedia.Blocks * testedMedia.BlockSize) / 1000 / 1000, (double)(testedMedia.Blocks * testedMedia.BlockSize) / 1024 / 1024));
mediaOneValue.Add(string.Format("Medium size: {0} bytes, {1} Mb, {2:F2} MiB",
testedMedia.Blocks * testedMedia.BlockSize,
(testedMedia.Blocks * testedMedia.BlockSize) / 1000 / 1000,
(double)(testedMedia.Blocks * testedMedia.BlockSize) / 1024 /
1024));
}
}
if(testedMedia.CHS != null && testedMedia.CurrentCHS != null)
{
int currentSectors = testedMedia.CurrentCHS.Cylinders * testedMedia.CurrentCHS.Heads * testedMedia.CurrentCHS.Sectors;
mediaOneValue.Add(string.Format("Cylinders: {0} max., {1} current", testedMedia.CHS.Cylinders, testedMedia.CurrentCHS.Cylinders));
mediaOneValue.Add(string.Format("Heads: {0} max., {1} current", testedMedia.CHS.Heads, testedMedia.CurrentCHS.Heads));
mediaOneValue.Add(string.Format("Sectors per track: {0} max., {1} current", testedMedia.CHS.Sectors, testedMedia.CurrentCHS.Sectors));
mediaOneValue.Add(string.Format("Sectors addressable in CHS mode: {0} max., {1} current", testedMedia.CHS.Cylinders * testedMedia.CHS.Heads * testedMedia.CHS.Sectors,
currentSectors));
mediaOneValue.Add(string.Format("Medium size in CHS mode: {0} bytes, {1} Mb, {2:F2} MiB", (ulong)currentSectors * testedMedia.BlockSize,
((ulong)currentSectors * testedMedia.BlockSize) / 1000 / 1000, (double)((ulong)currentSectors * testedMedia.BlockSize) / 1024 / 1024));
int currentSectors = testedMedia.CurrentCHS.Cylinders * testedMedia.CurrentCHS.Heads *
testedMedia.CurrentCHS.Sectors;
mediaOneValue.Add(string.Format("Cylinders: {0} max., {1} current", testedMedia.CHS.Cylinders,
testedMedia.CurrentCHS.Cylinders));
mediaOneValue.Add(string.Format("Heads: {0} max., {1} current", testedMedia.CHS.Heads,
testedMedia.CurrentCHS.Heads));
mediaOneValue.Add(string.Format("Sectors per track: {0} max., {1} current", testedMedia.CHS.Sectors,
testedMedia.CurrentCHS.Sectors));
mediaOneValue.Add(string.Format("Sectors addressable in CHS mode: {0} max., {1} current",
testedMedia.CHS.Cylinders * testedMedia.CHS.Heads *
testedMedia.CHS.Sectors, currentSectors));
mediaOneValue.Add(string.Format("Medium size in CHS mode: {0} bytes, {1} Mb, {2:F2} MiB",
(ulong)currentSectors * testedMedia.BlockSize,
((ulong)currentSectors * testedMedia.BlockSize) / 1000 / 1000,
(double)((ulong)currentSectors * testedMedia.BlockSize) / 1024 /
1024));
}
else if(testedMedia.CHS != null)
{
@@ -110,73 +129,99 @@ namespace DiscImageChef.Server.App_Start
mediaOneValue.Add(string.Format("Heads: {0}", testedMedia.CHS.Heads));
mediaOneValue.Add(string.Format("Sectors per track: {0}", testedMedia.CHS.Sectors));
mediaOneValue.Add(string.Format("Sectors addressable in CHS mode: {0}", currentSectors));
mediaOneValue.Add(string.Format("Medium size in CHS mode: {0} bytes, {1} Mb, {2:F2} MiB", (ulong)currentSectors * testedMedia.BlockSize,
((ulong)currentSectors * testedMedia.BlockSize) / 1000 / 1000, (double)((ulong)currentSectors * testedMedia.BlockSize) / 1024 / 1024));
mediaOneValue.Add(string.Format("Medium size in CHS mode: {0} bytes, {1} Mb, {2:F2} MiB",
(ulong)currentSectors * testedMedia.BlockSize,
((ulong)currentSectors * testedMedia.BlockSize) / 1000 / 1000,
(double)((ulong)currentSectors * testedMedia.BlockSize) / 1024 /
1024));
}
if(testedMedia.LBASectorsSpecified)
{
mediaOneValue.Add(string.Format("Sectors addressable in sectors in 28-bit LBA mode: {0}", testedMedia.LBASectors));
mediaOneValue.Add(string.Format("Sectors addressable in sectors in 28-bit LBA mode: {0}",
testedMedia.LBASectors));
if((((ulong)testedMedia.LBASectors * testedMedia.BlockSize) / 1024 / 1024) > 1000000)
{
mediaOneValue.Add(string.Format("Medium size in 28-bit LBA mode: {0} bytes, {1} Tb, {2:F2} TiB", (ulong)testedMedia.LBASectors * testedMedia.BlockSize,
((ulong)testedMedia.LBASectors * testedMedia.BlockSize) / 1000 / 1000 / 1000 / 1000, (double)((ulong)testedMedia.LBASectors * testedMedia.BlockSize) / 1024 / 1024 / 1024 / 1024));
mediaOneValue.Add(string.Format("Medium size in 28-bit LBA mode: {0} bytes, {1} Tb, {2:F2} TiB",
(ulong)testedMedia.LBASectors * testedMedia.BlockSize,
((ulong)testedMedia.LBASectors * testedMedia.BlockSize) / 1000 /
1000 / 1000 / 1000,
(double)((ulong)testedMedia.LBASectors *
testedMedia.BlockSize) / 1024 / 1024 / 1024 / 1024));
}
else if((((ulong)testedMedia.LBASectors * testedMedia.BlockSize) / 1024 / 1024) > 1000)
{
mediaOneValue.Add(string.Format("Medium size in 28-bit LBA mode: {0} bytes, {1} Gb, {2:F2} GiB", (ulong)testedMedia.LBASectors * testedMedia.BlockSize,
((ulong)testedMedia.LBASectors * testedMedia.BlockSize) / 1000 / 1000 / 1000, (double)((ulong)testedMedia.LBASectors * testedMedia.BlockSize) / 1024 / 1024 / 1024));
mediaOneValue.Add(string.Format("Medium size in 28-bit LBA mode: {0} bytes, {1} Gb, {2:F2} GiB",
(ulong)testedMedia.LBASectors * testedMedia.BlockSize,
((ulong)testedMedia.LBASectors * testedMedia.BlockSize) / 1000 /
1000 / 1000,
(double)((ulong)testedMedia.LBASectors *
testedMedia.BlockSize) / 1024 / 1024 / 1024));
}
else
{
mediaOneValue.Add(string.Format("Medium size in 28-bit LBA mode: {0} bytes, {1} Mb, {2:F2} MiB", (ulong)testedMedia.LBASectors * testedMedia.BlockSize,
((ulong)testedMedia.LBASectors * testedMedia.BlockSize) / 1000 / 1000, (double)((ulong)testedMedia.LBASectors * testedMedia.BlockSize) / 1024 / 1024));
mediaOneValue.Add(string.Format("Medium size in 28-bit LBA mode: {0} bytes, {1} Mb, {2:F2} MiB",
(ulong)testedMedia.LBASectors * testedMedia.BlockSize,
((ulong)testedMedia.LBASectors * testedMedia.BlockSize) / 1000 /
1000,
(double)((ulong)testedMedia.LBASectors *
testedMedia.BlockSize) / 1024 / 1024));
}
}
if(testedMedia.LBA48SectorsSpecified)
{
mediaOneValue.Add(string.Format("Sectors addressable in sectors in 48-bit LBA mode: {0}", testedMedia.LBA48Sectors));
mediaOneValue.Add(string.Format("Sectors addressable in sectors in 48-bit LBA mode: {0}",
testedMedia.LBA48Sectors));
if(((testedMedia.LBA48Sectors * testedMedia.BlockSize) / 1024 / 1024) > 1000000)
{
mediaOneValue.Add(string.Format("Medium size in 48-bit LBA mode: {0} bytes, {1} Tb, {2:F2} TiB", testedMedia.LBA48Sectors * testedMedia.BlockSize,
(testedMedia.LBA48Sectors * testedMedia.BlockSize) / 1000 / 1000 / 1000 / 1000, (double)(testedMedia.LBA48Sectors * testedMedia.BlockSize) / 1024 / 1024 / 1024 / 1024));
mediaOneValue.Add(string.Format("Medium size in 48-bit LBA mode: {0} bytes, {1} Tb, {2:F2} TiB",
testedMedia.LBA48Sectors * testedMedia.BlockSize,
(testedMedia.LBA48Sectors * testedMedia.BlockSize) / 1000 /
1000 / 1000 / 1000,
(double)(testedMedia.LBA48Sectors * testedMedia.BlockSize) /
1024 / 1024 / 1024 / 1024));
}
else if(((testedMedia.LBA48Sectors * testedMedia.BlockSize) / 1024 / 1024) > 1000)
{
mediaOneValue.Add(string.Format("Medium size in 48-bit LBA mode: {0} bytes, {1} Gb, {2:F2} GiB", testedMedia.LBA48Sectors * testedMedia.BlockSize,
(testedMedia.LBA48Sectors * testedMedia.BlockSize) / 1000 / 1000 / 1000, (double)(testedMedia.LBA48Sectors * testedMedia.BlockSize) / 1024 / 1024 / 1024));
mediaOneValue.Add(string.Format("Medium size in 48-bit LBA mode: {0} bytes, {1} Gb, {2:F2} GiB",
testedMedia.LBA48Sectors * testedMedia.BlockSize,
(testedMedia.LBA48Sectors * testedMedia.BlockSize) / 1000 /
1000 / 1000,
(double)(testedMedia.LBA48Sectors * testedMedia.BlockSize) /
1024 / 1024 / 1024));
}
else
{
mediaOneValue.Add(string.Format("Medium size in 48-bit LBA mode: {0} bytes, {1} Mb, {2:F2} MiB", testedMedia.LBA48Sectors * testedMedia.BlockSize,
(testedMedia.LBA48Sectors * testedMedia.BlockSize) / 1000 / 1000, (double)(testedMedia.LBA48Sectors * testedMedia.BlockSize) / 1024 / 1024));
mediaOneValue.Add(string.Format("Medium size in 48-bit LBA mode: {0} bytes, {1} Mb, {2:F2} MiB",
testedMedia.LBA48Sectors * testedMedia.BlockSize,
(testedMedia.LBA48Sectors * testedMedia.BlockSize) / 1000 /
1000,
(double)(testedMedia.LBA48Sectors * testedMedia.BlockSize) /
1024 / 1024));
}
}
if(testedMedia.NominalRotationRateSpecified &&
testedMedia.NominalRotationRate != 0x0000 &&
if(testedMedia.NominalRotationRateSpecified && testedMedia.NominalRotationRate != 0x0000 &&
testedMedia.NominalRotationRate != 0xFFFF)
{
if(testedMedia.NominalRotationRate == 0x0001)
mediaOneValue.Add("Medium does not rotate.");
else
mediaOneValue.Add(string.Format("Medium rotates at {0} rpm", testedMedia.NominalRotationRate));
if(testedMedia.NominalRotationRate == 0x0001) mediaOneValue.Add("Medium does not rotate.");
else mediaOneValue.Add(string.Format("Medium rotates at {0} rpm", testedMedia.NominalRotationRate));
}
if(testedMedia.BlockSizeSpecified &&
testedMedia.PhysicalBlockSizeSpecified &&
if(testedMedia.BlockSizeSpecified && testedMedia.PhysicalBlockSizeSpecified &&
(testedMedia.BlockSize != testedMedia.PhysicalBlockSize) &&
(testedMedia.LogicalAlignment & 0x8000) == 0x0000 &&
(testedMedia.LogicalAlignment & 0x4000) == 0x4000)
(testedMedia.LogicalAlignment & 0x8000) == 0x0000 &&
(testedMedia.LogicalAlignment & 0x4000) == 0x4000)
{
mediaOneValue.Add(string.Format("Logical sector starts at offset {0} from physical sector", testedMedia.LogicalAlignment & 0x3FFF));
mediaOneValue.Add(string.Format("Logical sector starts at offset {0} from physical sector",
testedMedia.LogicalAlignment & 0x3FFF));
}
if(testedMedia.SupportsRead && ata)
mediaOneValue.Add("Device can use the READ SECTOR(S) command in CHS mode with this medium");
mediaOneValue.Add("Device can use the READ SECTOR(S) command in CHS mode with this medium");
if(testedMedia.SupportsReadRetry)
mediaOneValue.Add("Device can use the READ SECTOR(S) RETRY command in CHS mode with this medium");
if(testedMedia.SupportsReadDma)
@@ -191,7 +236,8 @@ namespace DiscImageChef.Server.App_Start
if(testedMedia.SupportsReadLba)
mediaOneValue.Add("Device can use the READ SECTOR(S) command in 28-bit LBA mode with this medium");
if(testedMedia.SupportsReadRetryLba)
mediaOneValue.Add("Device can use the READ SECTOR(S) RETRY command in 28-bit LBA mode with this medium");
mediaOneValue
.Add("Device can use the READ SECTOR(S) RETRY command in 28-bit LBA mode with this medium");
if(testedMedia.SupportsReadDmaLba)
mediaOneValue.Add("Device can use the READ DMA command in 28-bit LBA mode with this medium");
if(testedMedia.SupportsReadDmaRetryLba)
@@ -233,9 +279,11 @@ namespace DiscImageChef.Server.App_Start
if(testedMedia.SupportsReadCdMsf)
mediaOneValue.Add("Device can use the READ CD command with MM:SS:FF addressing with this medium");
if(testedMedia.SupportsReadCdRaw)
mediaOneValue.Add("Device can use the READ CD command with LBA addressing with this medium to read raw sector");
mediaOneValue
.Add("Device can use the READ CD command with LBA addressing with this medium to read raw sector");
if(testedMedia.SupportsReadCdMsfRaw)
mediaOneValue.Add("Device can use the READ CD command with MM:SS:FF addressing with this medium read raw sector");
mediaOneValue
.Add("Device can use the READ CD command with MM:SS:FF addressing with this medium read raw sector");
if(testedMedia.SupportsHLDTSTReadRawDVD)
mediaOneValue.Add("Device can use the HL-DT-ST vendor READ DVD (RAW) command with this medium");
@@ -256,8 +304,7 @@ namespace DiscImageChef.Server.App_Start
mediaOneValue.Add("Device can read the DVD ADress-In-Pregroove from this medium");
if(testedMedia.CanReadATIP)
mediaOneValue.Add("Device can read the CD Absolute-Time-In-Pregroove from this medium");
if(testedMedia.CanReadBCA)
mediaOneValue.Add("Device can read the Burst Cutting Area from this medium");
if(testedMedia.CanReadBCA) mediaOneValue.Add("Device can read the Burst Cutting Area from this medium");
if(testedMedia.CanReadC2Pointers)
mediaOneValue.Add("Device can report the C2 pointers when reading from this medium");
if(testedMedia.CanReadCMI)
@@ -265,7 +312,8 @@ namespace DiscImageChef.Server.App_Start
if(testedMedia.CanReadCorrectedSubchannel)
mediaOneValue.Add("Device can correct subchannels when reading from this medium");
if(testedMedia.CanReadCorrectedSubchannelWithC2)
mediaOneValue.Add("Device can correct subchannels and report the C2 pointers when reading from this medium");
mediaOneValue
.Add("Device can correct subchannels and report the C2 pointers when reading from this medium");
if(testedMedia.CanReadDCB)
mediaOneValue.Add("Device can read the Disc Control Blocks from this medium");
if(testedMedia.CanReadDDS)
@@ -280,16 +328,12 @@ namespace DiscImageChef.Server.App_Start
mediaOneValue.Add("Device can read the HD DVD Copyright Management Information from this medium");
if(testedMedia.CanReadLayerCapacity)
mediaOneValue.Add("Device can read the layer capacity from this medium");
if(testedMedia.CanReadLeadIn)
mediaOneValue.Add("Device can read the Lead-In from this medium");
if(testedMedia.CanReadLeadOut)
mediaOneValue.Add("Device can read the Lead-Out from this medium");
if(testedMedia.CanReadMediaID)
mediaOneValue.Add("Device can read the Media ID from this medium");
if(testedMedia.CanReadLeadIn) mediaOneValue.Add("Device can read the Lead-In from this medium");
if(testedMedia.CanReadLeadOut) mediaOneValue.Add("Device can read the Lead-Out from this medium");
if(testedMedia.CanReadMediaID) mediaOneValue.Add("Device can read the Media ID from this medium");
if(testedMedia.CanReadMediaSerial)
mediaOneValue.Add("Device can read the Media Serial Number from this medium");
if(testedMedia.CanReadPAC)
mediaOneValue.Add("Device can read the PAC from this medium");
if(testedMedia.CanReadPAC) mediaOneValue.Add("Device can read the PAC from this medium");
if(testedMedia.CanReadPFI)
mediaOneValue.Add("Device can read the Physical Format Information from this medium");
if(testedMedia.CanReadPMA)
@@ -297,22 +341,23 @@ namespace DiscImageChef.Server.App_Start
if(testedMedia.CanReadPQSubchannel)
mediaOneValue.Add("Device can read the P to Q subchannels from this medium");
if(testedMedia.CanReadPQSubchannelWithC2)
mediaOneValue.Add("Device can read the P to Q subchannels from this medium reporting the C2 pointers");
mediaOneValue
.Add("Device can read the P to Q subchannels from this medium reporting the C2 pointers");
if(testedMedia.CanReadPRI)
mediaOneValue.Add("Device can read the Pre-Recorded Information from this medium");
if(testedMedia.CanReadRWSubchannel)
mediaOneValue.Add("Device can read the R to W subchannels from this medium");
if(testedMedia.CanReadRWSubchannelWithC2)
mediaOneValue.Add("Device can read the R to W subchannels from this medium reporting the C2 pointers");
mediaOneValue
.Add("Device can read the R to W subchannels from this medium reporting the C2 pointers");
if(testedMedia.CanReadRecordablePFI)
mediaOneValue.Add("Device can read the Physical Format Information from Lead-In from this medium");
if(testedMedia.CanReadSpareAreaInformation)
mediaOneValue.Add("Device can read the Spare Area Information from this medium");
if(testedMedia.CanReadTOC)
mediaOneValue.Add("Device can read the Table of Contents from this medium");
if(testedMedia.CanReadTOC) mediaOneValue.Add("Device can read the Table of Contents from this medium");
mediaOneValue.Add("");
}
}
}
}
}

9
DiscImageChef.Server/App_Start/WebApiConfig.cs
View File

@@ -43,11 +43,8 @@ namespace DiscImageChef.Server
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.Routes.MapHttpRoute(name: "DefaultApi", routeTemplate: "api/{controller}/{id}",
defaults: new {id = RouteParameter.Optional});
}
}
}
}