2018-11-25 17:47:14 +00:00
|
|
|
// /***************************************************************************
|
2020-02-27 12:31:21 +00:00
|
|
|
// Aaru Data Preservation Suite
|
2018-11-25 17:47:14 +00:00
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
|
//
|
|
|
|
|
// Filename : DeviceReportV2.cs
|
|
|
|
|
// Author(s) : Natalia Portillo <claunia@claunia.com>
|
|
|
|
|
//
|
|
|
|
|
// Component : JSON metadata.
|
|
|
|
|
//
|
|
|
|
|
// --[ Description ] ----------------------------------------------------------
|
|
|
|
|
//
|
|
|
|
|
// Contains classes for a JSON device report.
|
|
|
|
|
//
|
|
|
|
|
// --[ License ] --------------------------------------------------------------
|
|
|
|
|
//
|
|
|
|
|
// Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
|
|
// copy of this software and associated documentation files (the
|
|
|
|
|
// "Software"), to deal in the Software without restriction, including
|
|
|
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
|
|
|
// distribute, sublicense, and/or sell copies of the Software, and to
|
|
|
|
|
// permit persons to whom the Software is furnished to do so, subject to
|
|
|
|
|
// the following conditions:
|
|
|
|
|
//
|
|
|
|
|
// The above copyright notice and this permission notice shall be included
|
|
|
|
|
// in all copies or substantial portions of the Software.
|
|
|
|
|
//
|
|
|
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
|
|
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
|
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
|
|
|
|
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
|
|
|
|
// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
|
|
|
|
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
|
|
|
|
// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
|
//
|
|
|
|
|
// ----------------------------------------------------------------------------
|
2020-01-03 17:51:28 +00:00
|
|
|
// Copyright © 2011-2020 Natalia Portillo
|
2018-11-25 17:47:14 +00:00
|
|
|
// ****************************************************************************/
|
|
|
|
|
|
|
|
|
|
using System;
|
2018-11-27 01:42:25 +00:00
|
|
|
using System.Collections.Generic;
|
2019-11-10 23:25:55 +00:00
|
|
|
using System.ComponentModel;
|
2018-11-26 23:16:54 +00:00
|
|
|
using System.ComponentModel.DataAnnotations;
|
2018-12-23 21:38:01 +00:00
|
|
|
using System.Linq;
|
2018-12-20 23:52:16 +00:00
|
|
|
using System.Text;
|
2020-02-27 00:33:15 +00:00
|
|
|
using Aaru.CommonTypes.Enums;
|
|
|
|
|
using Aaru.CommonTypes.Structs.Devices.ATA;
|
|
|
|
|
using Aaru.CommonTypes.Structs.Devices.SCSI;
|
|
|
|
|
using Aaru.CommonTypes.Structs.Devices.SCSI.Modes;
|
2018-11-26 23:16:54 +00:00
|
|
|
using Newtonsoft.Json;
|
2018-12-23 18:49:07 +00:00
|
|
|
|
2018-12-22 22:41:58 +00:00
|
|
|
// ReSharper disable VirtualMemberNeverOverridden.Global
|
|
|
|
|
// ReSharper disable VirtualMemberCallInConstructor
|
2018-11-25 17:47:14 +00:00
|
|
|
|
|
|
|
|
// ReSharper disable InconsistentNaming
|
|
|
|
|
// ReSharper disable UnusedAutoPropertyAccessor.Global
|
|
|
|
|
|
2020-02-27 00:33:15 +00:00
|
|
|
namespace Aaru.CommonTypes.Metadata
|
2018-11-25 17:47:14 +00:00
|
|
|
{
|
|
|
|
|
public class DeviceReportV2
|
|
|
|
|
{
|
2020-02-29 18:03:24 +00:00
|
|
|
public DeviceReportV2() {}
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
public DeviceReportV2(DeviceReport reportV1)
|
|
|
|
|
{
|
2019-11-03 01:41:48 +00:00
|
|
|
if(reportV1.USB != null)
|
|
|
|
|
USB = new Usb(reportV1.USB);
|
|
|
|
|
|
|
|
|
|
if(reportV1.FireWire != null)
|
|
|
|
|
FireWire = new FireWire(reportV1.FireWire);
|
|
|
|
|
|
|
|
|
|
if(reportV1.PCMCIA != null)
|
|
|
|
|
PCMCIA = new Pcmcia(reportV1.PCMCIA);
|
|
|
|
|
|
|
|
|
|
if(reportV1.CompactFlashSpecified)
|
|
|
|
|
CompactFlash = reportV1.CompactFlash;
|
|
|
|
|
|
2018-12-20 23:52:16 +00:00
|
|
|
if(reportV1.ATA != null)
|
|
|
|
|
{
|
|
|
|
|
ATA = new Ata(reportV1.ATA);
|
|
|
|
|
Type = DeviceType.ATA;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(reportV1.SCSI != null)
|
|
|
|
|
{
|
|
|
|
|
SCSI = new Scsi(reportV1.SCSI);
|
|
|
|
|
Type = DeviceType.SCSI;
|
2018-12-23 21:38:01 +00:00
|
|
|
|
|
|
|
|
if(SCSI.ModeSense?.ModePages?.FirstOrDefault(p => p.page == 0x2A)?.value != null)
|
|
|
|
|
{
|
|
|
|
|
if(SCSI.MultiMediaDevice != null)
|
|
|
|
|
SCSI.MultiMediaDevice.ModeSense2AData =
|
|
|
|
|
SCSI.ModeSense?.ModePages?.FirstOrDefault(p => p.page == 0x2A)?.value;
|
|
|
|
|
else if(SCSI.Inquiry?.PeripheralDeviceType == (byte)PeripheralDeviceTypes.MultiMediaDevice)
|
|
|
|
|
SCSI.MultiMediaDevice = new Mmc
|
|
|
|
|
{
|
|
|
|
|
ModeSense2AData = SCSI.ModeSense?.ModePages?.FirstOrDefault(p => p.page == 0x2A)?.value
|
|
|
|
|
};
|
|
|
|
|
}
|
2018-12-20 23:52:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(reportV1.ATAPI != null)
|
|
|
|
|
{
|
|
|
|
|
ATAPI = new Ata(reportV1.ATAPI);
|
|
|
|
|
Type = DeviceType.ATAPI;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(reportV1.MultiMediaCard != null)
|
|
|
|
|
{
|
|
|
|
|
MultiMediaCard = new MmcSd(reportV1.MultiMediaCard);
|
|
|
|
|
Type = DeviceType.MMC;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(reportV1.SecureDigital != null)
|
|
|
|
|
{
|
|
|
|
|
SecureDigital = new MmcSd(reportV1.SecureDigital);
|
|
|
|
|
Type = DeviceType.SecureDigital;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(reportV1.SCSI?.Inquiry != null)
|
|
|
|
|
{
|
|
|
|
|
Manufacturer = reportV1.SCSI.Inquiry.VendorIdentification;
|
|
|
|
|
Model = reportV1.SCSI.Inquiry.ProductIdentification;
|
|
|
|
|
Revision = reportV1.SCSI.Inquiry.ProductRevisionLevel;
|
|
|
|
|
}
|
2019-11-03 01:41:48 +00:00
|
|
|
else if(reportV1.ATA != null ||
|
|
|
|
|
reportV1.ATAPI != null)
|
2018-12-20 23:52:16 +00:00
|
|
|
{
|
|
|
|
|
ataType ata = reportV1.ATA ?? reportV1.ATAPI;
|
|
|
|
|
|
|
|
|
|
string[] split = ata.Model.Split(' ');
|
|
|
|
|
|
|
|
|
|
if(split.Length > 1)
|
|
|
|
|
{
|
|
|
|
|
Manufacturer = split[0];
|
|
|
|
|
Model = string.Join(" ", split, 1, split.Length - 1);
|
|
|
|
|
}
|
2019-11-03 01:41:48 +00:00
|
|
|
else
|
|
|
|
|
Model = ata.Model;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
Revision = ata.FirmwareRevision;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2018-11-26 23:16:54 +00:00
|
|
|
[JsonIgnore]
|
2020-07-10 18:18:10 +01:00
|
|
|
public int Id { get; set; }
|
|
|
|
|
public virtual Usb USB { get; set; }
|
|
|
|
|
public virtual FireWire FireWire { get; set; }
|
|
|
|
|
public virtual Pcmcia PCMCIA { get; set; }
|
|
|
|
|
public bool CompactFlash { get; set; }
|
|
|
|
|
public virtual Ata ATA { get; set; }
|
|
|
|
|
public virtual Ata ATAPI { get; set; }
|
|
|
|
|
public virtual Scsi SCSI { get; set; }
|
|
|
|
|
public virtual MmcSd MultiMediaCard { get; set; }
|
|
|
|
|
public virtual MmcSd SecureDigital { get; set; }
|
|
|
|
|
public virtual GdRomSwapDiscCapabilities GdRomSwapDiscCapabilities { get; set; }
|
2018-11-27 00:23:05 +00:00
|
|
|
|
|
|
|
|
public string Manufacturer { get; set; }
|
|
|
|
|
public string Model { get; set; }
|
|
|
|
|
public string Revision { get; set; }
|
|
|
|
|
public DeviceType Type { get; set; }
|
2018-11-25 17:47:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public class Usb
|
|
|
|
|
{
|
2020-02-29 18:03:24 +00:00
|
|
|
public Usb() {}
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
public Usb(usbType usb)
|
|
|
|
|
{
|
|
|
|
|
VendorID = usb.VendorID;
|
|
|
|
|
ProductID = usb.ProductID;
|
|
|
|
|
Manufacturer = usb.Manufacturer;
|
|
|
|
|
Product = usb.Product;
|
|
|
|
|
RemovableMedia = usb.RemovableMedia;
|
|
|
|
|
Descriptors = usb.Descriptors;
|
|
|
|
|
}
|
|
|
|
|
|
2018-11-26 23:16:54 +00:00
|
|
|
[JsonIgnore]
|
2019-11-17 23:10:05 +00:00
|
|
|
public int Id { get; set; }
|
|
|
|
|
[DisplayName("Vendor ID"), DisplayFormat(DataFormatString = "0x{0:X4}")]
|
|
|
|
|
public ushort VendorID { get; set; }
|
|
|
|
|
[DisplayName("Product ID"), DisplayFormat(DataFormatString = "0x{0:X4}")]
|
2019-11-24 19:15:29 +00:00
|
|
|
public ushort ProductID { get; set; }
|
|
|
|
|
public string Manufacturer { get; set; }
|
|
|
|
|
public string Product { get; set; }
|
|
|
|
|
[DisplayName("Removable media")]
|
|
|
|
|
public bool RemovableMedia { get; set; }
|
|
|
|
|
public byte[] Descriptors { get; set; }
|
2018-11-25 17:47:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public class FireWire
|
|
|
|
|
{
|
2020-02-29 18:03:24 +00:00
|
|
|
public FireWire() {}
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
public FireWire(firewireType firewire)
|
|
|
|
|
{
|
|
|
|
|
VendorID = firewire.VendorID;
|
|
|
|
|
ProductID = firewire.ProductID;
|
|
|
|
|
Manufacturer = firewire.Manufacturer;
|
|
|
|
|
Product = firewire.Product;
|
|
|
|
|
RemovableMedia = firewire.RemovableMedia;
|
|
|
|
|
}
|
|
|
|
|
|
2018-11-26 23:16:54 +00:00
|
|
|
[JsonIgnore]
|
2019-11-10 23:25:55 +00:00
|
|
|
public int Id { get; set; }
|
|
|
|
|
[DisplayName("Vendor ID"), DisplayFormat(ApplyFormatInEditMode = true, DataFormatString = "0x{0:X8}")]
|
|
|
|
|
public uint VendorID { get; set; }
|
|
|
|
|
[DisplayName("Product ID"), DisplayFormat(ApplyFormatInEditMode = true, DataFormatString = "0x{0:X8}")]
|
|
|
|
|
public uint ProductID { get; set; }
|
|
|
|
|
[DisplayFormat(NullDisplayText = "Unknown")]
|
|
|
|
|
public string Manufacturer { get; set; }
|
|
|
|
|
[DisplayFormat(NullDisplayText = "Unknown")]
|
|
|
|
|
public string Product { get; set; }
|
|
|
|
|
[DisplayName("Is media removable?")]
|
|
|
|
|
public bool RemovableMedia { get; set; }
|
2018-11-25 17:47:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public class Ata
|
|
|
|
|
{
|
2020-02-29 18:03:24 +00:00
|
|
|
public Ata() {}
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
public Ata(ataType ata)
|
|
|
|
|
{
|
|
|
|
|
Identify = ata.Identify;
|
|
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.ReadCapabilities != null)
|
|
|
|
|
ReadCapabilities = new TestedMedia(ata.ReadCapabilities, true);
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
if(ata.RemovableMedias != null)
|
|
|
|
|
{
|
|
|
|
|
RemovableMedias = new List<TestedMedia>();
|
|
|
|
|
|
|
|
|
|
foreach(testedMediaType ataRemovableMedia in ata.RemovableMedias)
|
|
|
|
|
RemovableMedias.Add(new TestedMedia(ataRemovableMedia, true));
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(Identify != null)
|
|
|
|
|
return;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
var identifyDevice = new Identify.IdentifyDevice();
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.AdditionalPIDSpecified)
|
|
|
|
|
identifyDevice.AdditionalPID = ata.AdditionalPID;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.APIOSupportedSpecified)
|
|
|
|
|
identifyDevice.APIOSupported = ata.APIOSupported;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.ATAPIByteCountSpecified)
|
|
|
|
|
identifyDevice.ATAPIByteCount = ata.ATAPIByteCount;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.BufferTypeSpecified)
|
|
|
|
|
identifyDevice.BufferType = ata.BufferType;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.BufferSizeSpecified)
|
|
|
|
|
identifyDevice.BufferSize = ata.BufferSize;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.CapabilitiesSpecified)
|
|
|
|
|
identifyDevice.Capabilities = ata.Capabilities;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.Capabilities2Specified)
|
|
|
|
|
identifyDevice.Capabilities2 = ata.Capabilities2;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.Capabilities3Specified)
|
|
|
|
|
identifyDevice.Capabilities3 = ata.Capabilities3;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.CFAPowerModeSpecified)
|
|
|
|
|
identifyDevice.CFAPowerMode = ata.CFAPowerMode;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.CommandSetSpecified)
|
|
|
|
|
identifyDevice.CommandSet = ata.CommandSet;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.CommandSet2Specified)
|
|
|
|
|
identifyDevice.CommandSet2 = ata.CommandSet2;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.CommandSet3Specified)
|
|
|
|
|
identifyDevice.CommandSet3 = ata.CommandSet3;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.CommandSet4Specified)
|
|
|
|
|
identifyDevice.CommandSet4 = ata.CommandSet4;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.CommandSet5Specified)
|
|
|
|
|
identifyDevice.CommandSet4 = ata.CommandSet4;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.CurrentAAMSpecified)
|
|
|
|
|
identifyDevice.CurrentAAM = ata.CurrentAAM;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.CurrentAPMSpecified)
|
|
|
|
|
identifyDevice.CurrentAPM = ata.CurrentAPM;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.DataSetMgmtSpecified)
|
|
|
|
|
identifyDevice.DataSetMgmt = ata.DataSetMgmt;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.DataSetMgmtSizeSpecified)
|
|
|
|
|
identifyDevice.DataSetMgmtSize = ata.DataSetMgmtSize;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.DeviceFormFactorSpecified)
|
|
|
|
|
identifyDevice.DeviceFormFactor = ata.DeviceFormFactor;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.DMAActiveSpecified)
|
|
|
|
|
identifyDevice.DMAActive = ata.DMAActive;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.DMASupportedSpecified)
|
|
|
|
|
identifyDevice.DMASupported = ata.DMASupported;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.DMATransferTimingModeSpecified)
|
|
|
|
|
identifyDevice.DMATransferTimingMode = ata.DMATransferTimingMode;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
if(ata.EnhancedSecurityEraseTimeSpecified)
|
|
|
|
|
identifyDevice.EnhancedSecurityEraseTime = ata.EnhancedSecurityEraseTime;
|
|
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.EnabledCommandSetSpecified)
|
|
|
|
|
identifyDevice.EnabledCommandSet = ata.EnabledCommandSet;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.EnabledCommandSet2Specified)
|
|
|
|
|
identifyDevice.EnabledCommandSet2 = ata.EnabledCommandSet2;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.EnabledCommandSet3Specified)
|
|
|
|
|
identifyDevice.EnabledCommandSet3 = ata.EnabledCommandSet3;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.EnabledCommandSet4Specified)
|
|
|
|
|
identifyDevice.EnabledCommandSet4 = ata.EnabledCommandSet4;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.EnabledSATAFeaturesSpecified)
|
|
|
|
|
identifyDevice.EnabledSATAFeatures = ata.EnabledSATAFeatures;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.ExtendedUserSectorsSpecified)
|
|
|
|
|
identifyDevice.ExtendedUserSectors = ata.ExtendedUserSectors;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.FreeFallSensitivitySpecified)
|
|
|
|
|
identifyDevice.FreeFallSensitivity = ata.FreeFallSensitivity;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.FirmwareRevisionSpecified)
|
|
|
|
|
identifyDevice.FirmwareRevision = ata.FirmwareRevision;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.GeneralConfigurationSpecified)
|
|
|
|
|
identifyDevice.GeneralConfiguration = ata.GeneralConfiguration;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.HardwareResetResultSpecified)
|
|
|
|
|
identifyDevice.HardwareResetResult = ata.HardwareResetResult;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.InterseekDelaySpecified)
|
|
|
|
|
identifyDevice.InterseekDelay = ata.InterseekDelay;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.MajorVersionSpecified)
|
|
|
|
|
identifyDevice.MajorVersion = ata.MajorVersion;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
if(ata.MasterPasswordRevisionCodeSpecified)
|
|
|
|
|
identifyDevice.MasterPasswordRevisionCode = ata.MasterPasswordRevisionCode;
|
|
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.MaxDownloadMicroMode3Specified)
|
|
|
|
|
identifyDevice.MaxDownloadMicroMode3 = ata.MaxDownloadMicroMode3;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.MaxQueueDepthSpecified)
|
|
|
|
|
identifyDevice.MaxQueueDepth = ata.MaxQueueDepth;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.MDMAActiveSpecified)
|
|
|
|
|
identifyDevice.MDMAActive = ata.MDMAActive;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.MDMASupportedSpecified)
|
|
|
|
|
identifyDevice.MDMASupported = ata.MDMASupported;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.MinDownloadMicroMode3Specified)
|
|
|
|
|
identifyDevice.MinDownloadMicroMode3 = ata.MinDownloadMicroMode3;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.MinMDMACycleTimeSpecified)
|
|
|
|
|
identifyDevice.MinMDMACycleTime = ata.MinMDMACycleTime;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.MinorVersionSpecified)
|
|
|
|
|
identifyDevice.MinorVersion = ata.MinorVersion;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.MinPIOCycleTimeNoFlowSpecified)
|
|
|
|
|
identifyDevice.MinPIOCycleTimeNoFlow = ata.MinPIOCycleTimeNoFlow;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.MinPIOCycleTimeFlowSpecified)
|
|
|
|
|
identifyDevice.MinPIOCycleTimeFlow = ata.MinPIOCycleTimeFlow;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.ModelSpecified)
|
|
|
|
|
identifyDevice.Model = ata.Model;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.MultipleMaxSectorsSpecified)
|
|
|
|
|
identifyDevice.MultipleMaxSectors = ata.MultipleMaxSectors;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.MultipleSectorNumberSpecified)
|
|
|
|
|
identifyDevice.MultipleSectorNumber = ata.MultipleSectorNumber;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.NVCacheCapsSpecified)
|
|
|
|
|
identifyDevice.NVCacheCaps = ata.NVCacheCaps;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.NVCacheSizeSpecified)
|
|
|
|
|
identifyDevice.NVCacheSize = ata.NVCacheSize;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.NVCacheWriteSpeedSpecified)
|
|
|
|
|
identifyDevice.NVCacheWriteSpeed = ata.NVCacheWriteSpeed;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.NVEstimatedSpinUpSpecified)
|
|
|
|
|
identifyDevice.NVEstimatedSpinUp = ata.NVEstimatedSpinUp;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.PacketBusReleaseSpecified)
|
|
|
|
|
identifyDevice.PacketBusRelease = ata.PacketBusRelease;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.PIOTransferTimingModeSpecified)
|
|
|
|
|
identifyDevice.PIOTransferTimingMode = ata.PIOTransferTimingMode;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.RecommendedAAMSpecified)
|
|
|
|
|
identifyDevice.RecommendedAAM = ata.RecommendedAAM;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.RecommendedMDMACycleTimeSpecified)
|
|
|
|
|
identifyDevice.RecMDMACycleTime = ata.RecommendedMDMACycleTime;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.RemovableStatusSetSpecified)
|
|
|
|
|
identifyDevice.RemovableStatusSet = ata.RemovableStatusSet;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.SATACapabilitiesSpecified)
|
|
|
|
|
identifyDevice.SATACapabilities = ata.SATACapabilities;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.SATACapabilities2Specified)
|
|
|
|
|
identifyDevice.SATACapabilities2 = ata.SATACapabilities2;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.SATAFeaturesSpecified)
|
|
|
|
|
identifyDevice.SATAFeatures = ata.SATAFeatures;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.SCTCommandTransportSpecified)
|
|
|
|
|
identifyDevice.SCTCommandTransport = ata.SCTCommandTransport;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.SectorsPerCardSpecified)
|
|
|
|
|
identifyDevice.SectorsPerCard = ata.SectorsPerCard;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.SecurityEraseTimeSpecified)
|
|
|
|
|
identifyDevice.SecurityEraseTime = ata.SecurityEraseTime;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.SecurityStatusSpecified)
|
|
|
|
|
identifyDevice.SecurityStatus = ata.SecurityStatus;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.ServiceBusyClearSpecified)
|
|
|
|
|
identifyDevice.ServiceBusyClear = ata.ServiceBusyClear;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.SpecificConfigurationSpecified)
|
|
|
|
|
identifyDevice.SpecificConfiguration = ata.SpecificConfiguration;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.StreamAccessLatencySpecified)
|
|
|
|
|
identifyDevice.StreamAccessLatency = ata.StreamAccessLatency;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.StreamMinReqSizeSpecified)
|
|
|
|
|
identifyDevice.StreamMinReqSize = ata.StreamMinReqSize;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
if(ata.StreamPerformanceGranularitySpecified)
|
|
|
|
|
identifyDevice.StreamPerformanceGranularity = ata.StreamPerformanceGranularity;
|
|
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.StreamTransferTimeDMASpecified)
|
|
|
|
|
identifyDevice.StreamTransferTimeDMA = ata.StreamTransferTimeDMA;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.StreamTransferTimePIOSpecified)
|
|
|
|
|
identifyDevice.StreamTransferTimePIO = ata.StreamTransferTimePIO;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.TransportMajorVersionSpecified)
|
|
|
|
|
identifyDevice.TransportMajorVersion = ata.TransportMajorVersion;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.TransportMinorVersionSpecified)
|
|
|
|
|
identifyDevice.TransportMinorVersion = ata.TransportMinorVersion;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.TrustedComputingSpecified)
|
|
|
|
|
identifyDevice.TrustedComputing = ata.TrustedComputing;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.UDMAActiveSpecified)
|
|
|
|
|
identifyDevice.UDMAActive = ata.UDMAActive;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.UDMASupportedSpecified)
|
|
|
|
|
identifyDevice.UDMASupported = ata.UDMASupported;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.WRVModeSpecified)
|
|
|
|
|
identifyDevice.WRVMode = ata.WRVMode;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.WRVSectorCountMode3Specified)
|
|
|
|
|
identifyDevice.WRVSectorCountMode3 = ata.WRVSectorCountMode3;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata.WRVSectorCountMode2Specified)
|
|
|
|
|
identifyDevice.WRVSectorCountMode2 = ata.WRVSectorCountMode2;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2020-01-11 20:55:47 +00:00
|
|
|
Identify = Structs.Devices.ATA.Identify.Encode(identifyDevice);
|
2018-12-20 23:52:16 +00:00
|
|
|
}
|
|
|
|
|
|
2020-01-11 20:55:47 +00:00
|
|
|
public Identify.IdentifyDevice? IdentifyDevice => Structs.Devices.ATA.Identify.Decode(Identify);
|
2018-12-23 21:38:01 +00:00
|
|
|
|
2018-11-26 23:16:54 +00:00
|
|
|
[JsonIgnore]
|
2018-12-23 18:49:07 +00:00
|
|
|
public int Id { get; set; }
|
|
|
|
|
public byte[] Identify { get; set; }
|
2018-12-22 22:41:58 +00:00
|
|
|
public virtual TestedMedia ReadCapabilities { get; set; }
|
|
|
|
|
public virtual List<TestedMedia> RemovableMedias { get; set; }
|
2018-11-25 17:47:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public class Chs
|
|
|
|
|
{
|
2020-02-29 18:03:24 +00:00
|
|
|
public Chs() {}
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
public Chs(chsType chs)
|
|
|
|
|
{
|
|
|
|
|
Cylinders = chs.Cylinders;
|
|
|
|
|
Heads = chs.Heads;
|
|
|
|
|
Sectors = chs.Sectors;
|
|
|
|
|
}
|
|
|
|
|
|
2018-11-26 23:16:54 +00:00
|
|
|
[JsonIgnore]
|
|
|
|
|
public int Id { get; set; }
|
2018-11-25 17:47:14 +00:00
|
|
|
public ushort Cylinders { get; set; }
|
|
|
|
|
public ushort Heads { get; set; }
|
|
|
|
|
public ushort Sectors { get; set; }
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public class Scsi
|
|
|
|
|
{
|
2020-02-29 18:03:24 +00:00
|
|
|
public Scsi() {}
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
public Scsi(scsiType scsi)
|
|
|
|
|
{
|
|
|
|
|
InquiryData = scsi.Inquiry.Data;
|
|
|
|
|
SupportsModeSense6 = scsi.SupportsModeSense6;
|
|
|
|
|
SupportsModeSense10 = scsi.SupportsModeSense10;
|
|
|
|
|
SupportsModeSubpages = scsi.SupportsModeSubpages;
|
2019-11-03 01:41:48 +00:00
|
|
|
|
|
|
|
|
if(scsi.ReadCapabilitiesSpecified &&
|
|
|
|
|
scsi.ReadCapabilities != null)
|
2018-12-20 23:52:16 +00:00
|
|
|
ReadCapabilities = new TestedMedia(scsi.ReadCapabilities, false);
|
|
|
|
|
|
|
|
|
|
if(scsi.RemovableMedias != null)
|
|
|
|
|
{
|
|
|
|
|
RemovableMedias = new List<TestedMedia>();
|
2019-11-03 01:41:48 +00:00
|
|
|
|
2018-12-20 23:52:16 +00:00
|
|
|
foreach(testedMediaType scsiRemovableMedia in scsi.RemovableMedias)
|
|
|
|
|
RemovableMedias.Add(new TestedMedia(scsiRemovableMedia, false));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ModeSense6Data = scsi.ModeSense6Data;
|
|
|
|
|
ModeSense10Data = scsi.ModeSense10Data;
|
|
|
|
|
|
|
|
|
|
if(scsi.EVPDPages != null)
|
|
|
|
|
{
|
|
|
|
|
EVPDPages = new List<ScsiPage>();
|
2019-11-03 01:41:48 +00:00
|
|
|
|
|
|
|
|
foreach(pageType evpdPage in scsi.EVPDPages)
|
|
|
|
|
EVPDPages.Add(new ScsiPage(evpdPage));
|
2018-12-20 23:52:16 +00:00
|
|
|
}
|
|
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(scsi.ModeSense != null)
|
|
|
|
|
ModeSense = new ScsiMode(scsi.ModeSense);
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(scsi.MultiMediaDevice != null)
|
|
|
|
|
MultiMediaDevice = new Mmc(scsi.MultiMediaDevice);
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(scsi.SequentialDevice != null)
|
|
|
|
|
SequentialDevice = new Ssc(scsi.SequentialDevice);
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(InquiryData != null)
|
|
|
|
|
return;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2020-01-11 20:55:47 +00:00
|
|
|
var inq = new Inquiry();
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(scsi.Inquiry.ANSIVersionSpecified)
|
|
|
|
|
inq.ANSIVersion = scsi.Inquiry.ANSIVersion;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(scsi.Inquiry.ECMAVersionSpecified)
|
|
|
|
|
inq.ECMAVersion = scsi.Inquiry.ECMAVersion;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(scsi.Inquiry.DeviceTypeModifierSpecified)
|
|
|
|
|
inq.DeviceTypeModifier = scsi.Inquiry.DeviceTypeModifier;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(scsi.Inquiry.ISOVersionSpecified)
|
|
|
|
|
inq.ISOVersion = scsi.Inquiry.ISOVersion;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
if(scsi.Inquiry.ProductIdentificationSpecified)
|
|
|
|
|
{
|
|
|
|
|
byte[] tmp = Encoding.ASCII.GetBytes(scsi.Inquiry.ProductIdentification);
|
|
|
|
|
inq.ProductIdentification = new byte[tmp.Length + 1];
|
|
|
|
|
Array.Copy(tmp, 0, inq.ProductIdentification, 0, tmp.Length);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(scsi.Inquiry.ProductRevisionLevelSpecified)
|
|
|
|
|
{
|
|
|
|
|
byte[] tmp = Encoding.ASCII.GetBytes(scsi.Inquiry.ProductRevisionLevel);
|
|
|
|
|
inq.ProductRevisionLevel = new byte[tmp.Length + 1];
|
|
|
|
|
Array.Copy(tmp, 0, inq.ProductRevisionLevel, 0, tmp.Length);
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(scsi.Inquiry.ResponseDataFormatSpecified)
|
|
|
|
|
inq.ResponseDataFormat = scsi.Inquiry.ResponseDataFormat;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
if(scsi.Inquiry.VendorIdentificationSpecified)
|
|
|
|
|
{
|
|
|
|
|
byte[] tmp = Encoding.ASCII.GetBytes(scsi.Inquiry.VendorIdentification);
|
|
|
|
|
inq.VendorIdentification = new byte[tmp.Length + 1];
|
|
|
|
|
Array.Copy(tmp, 0, inq.VendorIdentification, 0, tmp.Length);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
inq.ACC = scsi.Inquiry.AccessControlCoordinator;
|
|
|
|
|
inq.ACKREQQ = scsi.Inquiry.ACKRequests;
|
|
|
|
|
inq.AERC = scsi.Inquiry.AERCSupported;
|
|
|
|
|
inq.Addr16 = scsi.Inquiry.Address16;
|
|
|
|
|
inq.Addr32 = scsi.Inquiry.Address32;
|
|
|
|
|
inq.TPGS = (byte)scsi.Inquiry.AsymmetricalLUNAccess;
|
|
|
|
|
inq.BQue = scsi.Inquiry.BasicQueueing;
|
|
|
|
|
inq.EncServ = scsi.Inquiry.EnclosureServices;
|
|
|
|
|
inq.HiSup = scsi.Inquiry.HierarchicalLUN;
|
|
|
|
|
inq.IUS = scsi.Inquiry.IUS;
|
|
|
|
|
inq.Linked = scsi.Inquiry.LinkedCommands;
|
|
|
|
|
inq.MChngr = scsi.Inquiry.MediumChanger;
|
|
|
|
|
inq.MultiP = scsi.Inquiry.MultiPortDevice;
|
|
|
|
|
inq.NormACA = scsi.Inquiry.NormalACA;
|
|
|
|
|
inq.PeripheralDeviceType = (byte)scsi.Inquiry.PeripheralDeviceType;
|
|
|
|
|
inq.PeripheralQualifier = (byte)scsi.Inquiry.PeripheralQualifier;
|
|
|
|
|
inq.Protect = scsi.Inquiry.Protection;
|
|
|
|
|
inq.QAS = scsi.Inquiry.QAS;
|
|
|
|
|
inq.RelAddr = scsi.Inquiry.RelativeAddressing;
|
|
|
|
|
inq.RMB = scsi.Inquiry.Removable;
|
|
|
|
|
inq.CmdQue = scsi.Inquiry.TaggedCommandQueue;
|
|
|
|
|
inq.TrmTsk = scsi.Inquiry.TerminateTaskSupported;
|
|
|
|
|
inq.ThreePC = scsi.Inquiry.ThirdPartyCopy;
|
|
|
|
|
inq.TranDis = scsi.Inquiry.TranferDisable;
|
|
|
|
|
inq.SftRe = scsi.Inquiry.SoftReset;
|
|
|
|
|
inq.Clocking = (byte)scsi.Inquiry.SPIClocking;
|
|
|
|
|
inq.SCCS = scsi.Inquiry.StorageArrayController;
|
|
|
|
|
inq.Sync = scsi.Inquiry.SyncTransfer;
|
|
|
|
|
inq.VersionDescriptors = scsi.Inquiry.VersionDescriptors;
|
|
|
|
|
inq.WBus16 = scsi.Inquiry.WideBus16;
|
|
|
|
|
inq.WBus32 = scsi.Inquiry.WideBus32;
|
|
|
|
|
|
2020-01-11 20:55:47 +00:00
|
|
|
InquiryData = Structs.Devices.SCSI.Inquiry.Encode(inq);
|
2018-12-20 23:52:16 +00:00
|
|
|
}
|
|
|
|
|
|
2020-01-11 20:55:47 +00:00
|
|
|
public Inquiry? Inquiry => Structs.Devices.SCSI.Inquiry.Decode(InquiryData);
|
2018-12-23 21:38:01 +00:00
|
|
|
|
2018-11-26 23:16:54 +00:00
|
|
|
[JsonIgnore]
|
2019-11-24 19:15:29 +00:00
|
|
|
public int Id { get; set; }
|
|
|
|
|
[DisplayName("Data from INQUIRY command")]
|
|
|
|
|
public byte[] InquiryData { get; set; }
|
|
|
|
|
public virtual List<ScsiPage> EVPDPages { get; set; }
|
|
|
|
|
[DisplayName("Supports MODE SENSE(6)")]
|
|
|
|
|
public bool SupportsModeSense6 { get; set; }
|
|
|
|
|
[DisplayName("Supports MODE SENSE(10)")]
|
|
|
|
|
public bool SupportsModeSense10 { get; set; }
|
|
|
|
|
[DisplayName("Supports MODE SENSE with subpages")]
|
|
|
|
|
public bool SupportsModeSubpages { get; set; }
|
|
|
|
|
public virtual ScsiMode ModeSense { get; set; }
|
|
|
|
|
public virtual Mmc MultiMediaDevice { get; set; }
|
|
|
|
|
public virtual TestedMedia ReadCapabilities { get; set; }
|
|
|
|
|
public virtual List<TestedMedia> RemovableMedias { get; set; }
|
|
|
|
|
public virtual Ssc SequentialDevice { get; set; }
|
|
|
|
|
[DisplayName("Data from MODE SENSE(6) command")]
|
|
|
|
|
public byte[] ModeSense6Data { get; set; }
|
|
|
|
|
[DisplayName("Data from MODE SENSE(10) command")]
|
|
|
|
|
public byte[] ModeSense10Data { get; set; }
|
|
|
|
|
[DisplayName("Data from MODE SENSE(6) command (current)")]
|
|
|
|
|
public byte[] ModeSense6CurrentData { get; set; }
|
|
|
|
|
[DisplayName("Data from MODE SENSE(10) command (current)")]
|
|
|
|
|
public byte[] ModeSense10CurrentData { get; set; }
|
|
|
|
|
[DisplayName("Data from MODE SENSE(6) command (changeable)")]
|
|
|
|
|
public byte[] ModeSense6ChangeableData { get; set; }
|
|
|
|
|
[DisplayName("Data from MODE SENSE(10) command (changeable)")]
|
|
|
|
|
public byte[] ModeSense10ChangeableData { get; set; }
|
2019-12-26 23:29:28 +00:00
|
|
|
|
|
|
|
|
[JsonIgnore]
|
|
|
|
|
public int? SequentialDeviceId { get; set; }
|
2018-11-25 17:47:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public class ScsiMode
|
|
|
|
|
{
|
2020-02-29 18:03:24 +00:00
|
|
|
public ScsiMode() {}
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
public ScsiMode(modeType mode)
|
|
|
|
|
{
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mode.MediumTypeSpecified)
|
|
|
|
|
MediumType = mode.MediumType;
|
|
|
|
|
|
2018-12-20 23:52:16 +00:00
|
|
|
WriteProtected = mode.WriteProtected;
|
2019-11-03 01:41:48 +00:00
|
|
|
|
|
|
|
|
if(mode.SpeedSpecified)
|
|
|
|
|
Speed = mode.Speed;
|
|
|
|
|
|
|
|
|
|
if(mode.BufferedModeSpecified)
|
|
|
|
|
BufferedMode = mode.BufferedMode;
|
|
|
|
|
|
2018-12-20 23:52:16 +00:00
|
|
|
BlankCheckEnabled = mode.BlankCheckEnabled;
|
|
|
|
|
DPOandFUA = mode.DPOandFUA;
|
|
|
|
|
|
|
|
|
|
if(mode.ModePages != null)
|
|
|
|
|
{
|
|
|
|
|
ModePages = new List<ScsiPage>();
|
2019-11-03 01:41:48 +00:00
|
|
|
|
|
|
|
|
foreach(modePageType modePage in mode.ModePages)
|
|
|
|
|
ModePages.Add(new ScsiPage(modePage));
|
2018-12-20 23:52:16 +00:00
|
|
|
}
|
|
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mode.BlockDescriptors == null)
|
|
|
|
|
return;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
BlockDescriptors = new List<BlockDescriptor>();
|
2019-11-03 01:41:48 +00:00
|
|
|
|
2018-12-20 23:52:16 +00:00
|
|
|
foreach(blockDescriptorType blockDescriptor in mode.BlockDescriptors)
|
|
|
|
|
BlockDescriptors.Add(new BlockDescriptor(blockDescriptor));
|
|
|
|
|
}
|
|
|
|
|
|
2018-11-26 23:16:54 +00:00
|
|
|
[JsonIgnore]
|
2019-11-24 19:15:29 +00:00
|
|
|
public int Id { get; set; }
|
|
|
|
|
[DisplayName("Medium type code")]
|
|
|
|
|
public byte? MediumType { get; set; }
|
|
|
|
|
[DisplayName("Write protected")]
|
|
|
|
|
public bool WriteProtected { get; set; }
|
|
|
|
|
public virtual List<BlockDescriptor> BlockDescriptors { get; set; }
|
|
|
|
|
public byte? Speed { get; set; }
|
|
|
|
|
[DisplayName("Buffered mode")]
|
|
|
|
|
public byte? BufferedMode { get; set; }
|
|
|
|
|
[DisplayName("Blank check enabled")]
|
|
|
|
|
public bool BlankCheckEnabled { get; set; }
|
|
|
|
|
[DisplayName("DPO and FUA")]
|
|
|
|
|
public bool DPOandFUA { get; set; }
|
|
|
|
|
public virtual List<ScsiPage> ModePages { get; set; }
|
2018-11-25 17:47:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public class BlockDescriptor
|
|
|
|
|
{
|
2020-02-29 18:03:24 +00:00
|
|
|
public BlockDescriptor() {}
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
public BlockDescriptor(blockDescriptorType descriptor)
|
|
|
|
|
{
|
|
|
|
|
Density = descriptor.Density;
|
2019-11-03 01:41:48 +00:00
|
|
|
|
|
|
|
|
if(descriptor.BlocksSpecified)
|
|
|
|
|
Blocks = descriptor.Blocks;
|
|
|
|
|
|
|
|
|
|
if(descriptor.BlockLengthSpecified)
|
|
|
|
|
BlockLength = descriptor.BlockLength;
|
2018-12-20 23:52:16 +00:00
|
|
|
}
|
|
|
|
|
|
2018-11-26 23:16:54 +00:00
|
|
|
[JsonIgnore]
|
2019-11-24 19:15:29 +00:00
|
|
|
public int Id { get; set; }
|
|
|
|
|
public byte Density { get; set; }
|
|
|
|
|
public ulong? Blocks { get; set; }
|
|
|
|
|
[DisplayName("Block length (bytes)")]
|
|
|
|
|
public uint? BlockLength { get; set; }
|
2018-11-25 17:47:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public class ScsiPage
|
|
|
|
|
{
|
2020-02-29 18:03:24 +00:00
|
|
|
public ScsiPage() {}
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
public ScsiPage(pageType evpdPage)
|
|
|
|
|
{
|
|
|
|
|
page = evpdPage.page;
|
|
|
|
|
value = evpdPage.value;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public ScsiPage(modePageType modePage)
|
|
|
|
|
{
|
|
|
|
|
page = modePage.page;
|
|
|
|
|
subpage = modePage.subpage;
|
|
|
|
|
value = modePage.value;
|
|
|
|
|
}
|
|
|
|
|
|
2018-11-26 23:16:54 +00:00
|
|
|
[JsonIgnore]
|
|
|
|
|
public int Id { get; set; }
|
2018-11-25 17:47:14 +00:00
|
|
|
public byte page { get; set; }
|
2018-11-25 19:42:11 +00:00
|
|
|
public byte? subpage { get; set; }
|
2018-11-25 17:47:14 +00:00
|
|
|
public byte[] value { get; set; }
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public class Mmc
|
|
|
|
|
{
|
2020-02-29 18:03:24 +00:00
|
|
|
public Mmc() {}
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
public Mmc(mmcType mmc)
|
|
|
|
|
{
|
|
|
|
|
if(mmc.ModeSense2A != null)
|
2020-01-11 20:55:47 +00:00
|
|
|
ModeSense2AData = ModePage_2A.Encode(new ModePage_2A
|
2018-12-20 23:52:16 +00:00
|
|
|
{
|
2020-07-10 18:18:10 +01:00
|
|
|
AccurateCDDA = mmc.ModeSense2A.AccurateCDDA, BCK = mmc.ModeSense2A.BCK,
|
|
|
|
|
BufferSize = mmc.ModeSense2A.BufferSize, BUF = mmc.ModeSense2A.BufferUnderRunProtection,
|
|
|
|
|
Eject = mmc.ModeSense2A.CanEject, Lock = mmc.ModeSense2A.CanLockMedia,
|
|
|
|
|
CDDACommand = mmc.ModeSense2A.CDDACommand, Composite = mmc.ModeSense2A.CompositeAudioVideo,
|
|
|
|
|
CMRSupported = (ushort)(mmc.ModeSense2A.CSSandCPPMSupported ? 1 : 0),
|
|
|
|
|
CurrentSpeed = mmc.ModeSense2A.CurrentSpeed, CurrentWriteSpeed = mmc.ModeSense2A.CurrentWriteSpeed,
|
|
|
|
|
CurrentWriteSpeedSelected = mmc.ModeSense2A.CurrentWriteSpeedSelected,
|
|
|
|
|
SDP = mmc.ModeSense2A.DeterministicSlotChanger, DigitalPort1 = mmc.ModeSense2A.DigitalPort1,
|
|
|
|
|
DigitalPort2 = mmc.ModeSense2A.DigitalPort2, LeadInPW = mmc.ModeSense2A.LeadInPW,
|
|
|
|
|
LoadingMechanism = mmc.ModeSense2A.LoadingMechanismType, LockState = mmc.ModeSense2A.LockStatus,
|
|
|
|
|
LSBF = mmc.ModeSense2A.LSBF, MaximumSpeed = mmc.ModeSense2A.MaximumSpeed,
|
|
|
|
|
MaxWriteSpeed = mmc.ModeSense2A.MaximumWriteSpeed, AudioPlay = mmc.ModeSense2A.PlaysAudio,
|
|
|
|
|
PreventJumper = mmc.ModeSense2A.PreventJumperStatus, RCK = mmc.ModeSense2A.RCK,
|
|
|
|
|
ReadBarcode = mmc.ModeSense2A.ReadsBarcode, SCC = mmc.ModeSense2A.ReadsBothSides,
|
|
|
|
|
ReadCDR = mmc.ModeSense2A.ReadsCDR, ReadCDRW = mmc.ModeSense2A.ReadsCDRW,
|
|
|
|
|
DeinterlaveSubchannel = mmc.ModeSense2A.ReadsDeinterlavedSubchannel,
|
|
|
|
|
ReadDVDR = mmc.ModeSense2A.ReadsDVDR, ReadDVDRAM = mmc.ModeSense2A.ReadsDVDRAM,
|
|
|
|
|
ReadDVDROM = mmc.ModeSense2A.ReadsDVDROM, ISRC = mmc.ModeSense2A.ReadsISRC,
|
|
|
|
|
Mode2Form2 = mmc.ModeSense2A.ReadsMode2Form2, Mode2Form1 = mmc.ModeSense2A.ReadsMode2Form1,
|
|
|
|
|
Method2 = mmc.ModeSense2A.ReadsPacketCDR, Subchannel = mmc.ModeSense2A.ReadsSubchannel,
|
|
|
|
|
UPC = mmc.ModeSense2A.ReadsUPC, C2Pointer = mmc.ModeSense2A.ReturnsC2Pointers,
|
|
|
|
|
RotationControlSelected = mmc.ModeSense2A.RotationControlSelected,
|
|
|
|
|
SeparateChannelMute = mmc.ModeSense2A.SeparateChannelMute,
|
|
|
|
|
SeparateChannelVolume = mmc.ModeSense2A.SeparateChannelVolume, SSS = mmc.ModeSense2A.SSS,
|
|
|
|
|
MultiSession = mmc.ModeSense2A.SupportsMultiSession,
|
|
|
|
|
SupportedVolumeLevels = mmc.ModeSense2A.SupportedVolumeLevels,
|
|
|
|
|
TestWrite = mmc.ModeSense2A.TestWrite, WriteCDR = mmc.ModeSense2A.WritesCDR,
|
|
|
|
|
WriteCDRW = mmc.ModeSense2A.WritesCDRW, WriteDVDR = mmc.ModeSense2A.WritesDVDR,
|
|
|
|
|
WriteDVDRAM = mmc.ModeSense2A.WritesDVDRAM,
|
2019-11-03 01:41:48 +00:00
|
|
|
WriteSpeedPerformanceDescriptors = mmc.ModeSense2A.WriteSpeedPerformanceDescriptors
|
2018-12-23 21:38:01 +00:00
|
|
|
});
|
|
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mmc.Features != null)
|
|
|
|
|
Features = new MmcFeatures(mmc.Features);
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mmc.TestedMedia == null)
|
|
|
|
|
return;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
TestedMedia = new List<TestedMedia>();
|
2019-11-03 01:41:48 +00:00
|
|
|
|
|
|
|
|
foreach(testedMediaType mediaType in mmc.TestedMedia)
|
|
|
|
|
TestedMedia.Add(new TestedMedia(mediaType, false));
|
2018-12-20 23:52:16 +00:00
|
|
|
}
|
|
|
|
|
|
2018-11-26 23:16:54 +00:00
|
|
|
[JsonIgnore]
|
2018-12-23 21:38:01 +00:00
|
|
|
public int Id { get; set; }
|
2020-01-11 20:55:47 +00:00
|
|
|
public virtual ModePage_2A ModeSense2A => ModePage_2A.Decode(ModeSense2AData);
|
2018-12-23 21:38:01 +00:00
|
|
|
public virtual MmcFeatures Features { get; set; }
|
|
|
|
|
public virtual List<TestedMedia> TestedMedia { get; set; }
|
|
|
|
|
public byte[] ModeSense2AData { get; set; }
|
2019-11-13 00:29:47 +00:00
|
|
|
[JsonIgnore]
|
|
|
|
|
public int? FeaturesId { get; set; }
|
2018-11-25 17:47:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public class MmcFeatures
|
|
|
|
|
{
|
2020-02-29 18:03:24 +00:00
|
|
|
public MmcFeatures() {}
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
public MmcFeatures(mmcFeaturesType features)
|
|
|
|
|
{
|
2019-11-03 01:41:48 +00:00
|
|
|
if(features.PhysicalInterfaceStandardSpecified &&
|
|
|
|
|
!features.PhysicalInterfaceStandardNumberSpecified)
|
2018-12-23 18:49:07 +00:00
|
|
|
PhysicalInterfaceStandardNumber = (uint?)features.PhysicalInterfaceStandard;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
if(features.PhysicalInterfaceStandardNumberSpecified)
|
|
|
|
|
PhysicalInterfaceStandardNumber = features.PhysicalInterfaceStandardNumber;
|
|
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(features.AACSVersionSpecified)
|
|
|
|
|
AACSVersion = features.AACSVersion;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(features.AGIDsSpecified)
|
|
|
|
|
AGIDs = features.AGIDs;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(features.BindingNonceBlocksSpecified)
|
|
|
|
|
BindingNonceBlocks = features.BindingNonceBlocks;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(features.CPRMVersionSpecified)
|
|
|
|
|
CPRMVersion = features.CPRMVersion;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(features.CSSVersionSpecified)
|
|
|
|
|
CSSVersion = features.CSSVersion;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(features.LoadingMechanismTypeSpecified)
|
|
|
|
|
LoadingMechanismType = features.LoadingMechanismType;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(features.LogicalBlockSizeSpecified)
|
|
|
|
|
LogicalBlockSize = features.LogicalBlockSize;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(features.BlocksPerReadableUnitSpecified)
|
|
|
|
|
BlocksPerReadableUnit = features.BlocksPerReadableUnit;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(features.FirmwareDateSpecified)
|
|
|
|
|
FirmwareDate = features.FirmwareDate;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(features.VolumeLevelsSpecified)
|
|
|
|
|
VolumeLevels = features.VolumeLevels;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
BufferUnderrunFreeInDVD = features.BufferUnderrunFreeInDVD;
|
|
|
|
|
BufferUnderrunFreeInSAO = features.BufferUnderrunFreeInSAO;
|
|
|
|
|
BufferUnderrunFreeInTAO = features.BufferUnderrunFreeInTAO;
|
|
|
|
|
CanAudioScan = features.CanAudioScan;
|
|
|
|
|
CanEject = features.CanEject;
|
|
|
|
|
CanEraseSector = features.CanEraseSector;
|
|
|
|
|
CanExpandBDRESpareArea = features.CanExpandBDRESpareArea;
|
|
|
|
|
CanFormat = features.CanFormat;
|
|
|
|
|
CanFormatBDREWithoutSpare = features.CanFormatBDREWithoutSpare;
|
|
|
|
|
CanFormatCert = features.CanFormatCert;
|
|
|
|
|
CanFormatFRF = features.CanFormatFRF;
|
|
|
|
|
CanFormatQCert = features.CanFormatQCert;
|
|
|
|
|
CanFormatRRM = features.CanFormatRRM;
|
|
|
|
|
CanGenerateBindingNonce = features.CanGenerateBindingNonce;
|
|
|
|
|
CanLoad = features.CanLoad;
|
|
|
|
|
CanMuteSeparateChannels = features.CanMuteSeparateChannels;
|
|
|
|
|
CanOverwriteSAOTrack = features.CanOverwriteSAOTrack;
|
|
|
|
|
CanOverwriteTAOTrack = features.CanOverwriteTAOTrack;
|
|
|
|
|
CanPlayCDAudio = features.CanPlayCDAudio;
|
|
|
|
|
CanPseudoOverwriteBDR = features.CanPseudoOverwriteBDR;
|
|
|
|
|
CanReadAllDualR = features.CanReadAllDualR;
|
|
|
|
|
CanReadAllDualRW = features.CanReadAllDualRW;
|
|
|
|
|
CanReadBD = features.CanReadBD;
|
|
|
|
|
CanReadBDR = features.CanReadBDR;
|
|
|
|
|
CanReadBDRE1 = features.CanReadBDRE1;
|
|
|
|
|
CanReadBDRE2 = features.CanReadBDRE2;
|
|
|
|
|
CanReadBDROM = features.CanReadBDROM;
|
|
|
|
|
CanReadBluBCA = features.CanReadBluBCA;
|
|
|
|
|
CanReadCD = features.CanReadCD;
|
|
|
|
|
CanReadCDMRW = features.CanReadCDMRW;
|
|
|
|
|
CanReadCPRM_MKB = features.CanReadCPRM_MKB;
|
|
|
|
|
CanReadDDCD = features.CanReadDDCD;
|
|
|
|
|
CanReadDVD = features.CanReadDVD;
|
|
|
|
|
CanReadDVDPlusMRW = features.CanReadDVDPlusMRW;
|
|
|
|
|
CanReadDVDPlusR = features.CanReadDVDPlusR;
|
|
|
|
|
CanReadDVDPlusRDL = features.CanReadDVDPlusRDL;
|
|
|
|
|
CanReadDVDPlusRW = features.CanReadDVDPlusRW;
|
|
|
|
|
CanReadDVDPlusRWDL = features.CanReadDVDPlusRWDL;
|
|
|
|
|
CanReadDriveAACSCertificate = features.CanReadDriveAACSCertificate;
|
|
|
|
|
CanReadHDDVD = features.CanReadHDDVD;
|
|
|
|
|
CanReadHDDVDR = features.CanReadHDDVDR;
|
|
|
|
|
CanReadHDDVDRAM = features.CanReadHDDVDRAM;
|
|
|
|
|
CanReadLeadInCDText = features.CanReadLeadInCDText;
|
|
|
|
|
CanReadOldBDR = features.CanReadOldBDR;
|
|
|
|
|
CanReadOldBDRE = features.CanReadOldBDRE;
|
|
|
|
|
CanReadOldBDROM = features.CanReadOldBDROM;
|
|
|
|
|
CanReadSpareAreaInformation = features.CanReadSpareAreaInformation;
|
|
|
|
|
CanReportDriveSerial = features.CanReportDriveSerial;
|
|
|
|
|
CanReportMediaSerial = features.CanReportMediaSerial;
|
|
|
|
|
CanTestWriteDDCDR = features.CanTestWriteDDCDR;
|
|
|
|
|
CanTestWriteDVD = features.CanTestWriteDVD;
|
|
|
|
|
CanTestWriteInSAO = features.CanTestWriteInSAO;
|
|
|
|
|
CanTestWriteInTAO = features.CanTestWriteInTAO;
|
|
|
|
|
CanUpgradeFirmware = features.CanUpgradeFirmware;
|
|
|
|
|
CanWriteBD = features.CanWriteBD;
|
|
|
|
|
CanWriteBDR = features.CanWriteBDR;
|
|
|
|
|
CanWriteBDRE1 = features.CanWriteBDRE1;
|
|
|
|
|
CanWriteBDRE2 = features.CanWriteBDRE2;
|
|
|
|
|
CanWriteBusEncryptedBlocks = features.CanWriteBusEncryptedBlocks;
|
|
|
|
|
CanWriteCDMRW = features.CanWriteCDMRW;
|
|
|
|
|
CanWriteCDRW = features.CanWriteCDRW;
|
|
|
|
|
CanWriteCDRWCAV = features.CanWriteCDRWCAV;
|
|
|
|
|
CanWriteCDSAO = features.CanWriteCDSAO;
|
|
|
|
|
CanWriteCDTAO = features.CanWriteCDTAO;
|
|
|
|
|
CanWriteCSSManagedDVD = features.CanWriteCSSManagedDVD;
|
|
|
|
|
CanWriteDDCDR = features.CanWriteDDCDR;
|
|
|
|
|
CanWriteDDCDRW = features.CanWriteDDCDRW;
|
|
|
|
|
CanWriteDVDPlusMRW = features.CanWriteDVDPlusMRW;
|
|
|
|
|
CanWriteDVDPlusR = features.CanWriteDVDPlusR;
|
|
|
|
|
CanWriteDVDPlusRDL = features.CanWriteDVDPlusRDL;
|
|
|
|
|
CanWriteDVDPlusRW = features.CanWriteDVDPlusRW;
|
|
|
|
|
CanWriteDVDPlusRWDL = features.CanWriteDVDPlusRWDL;
|
|
|
|
|
CanWriteDVDR = features.CanWriteDVDR;
|
|
|
|
|
CanWriteDVDRDL = features.CanWriteDVDRDL;
|
|
|
|
|
CanWriteDVDRW = features.CanWriteDVDRW;
|
|
|
|
|
CanWriteHDDVDR = features.CanWriteHDDVDR;
|
|
|
|
|
CanWriteHDDVDRAM = features.CanWriteHDDVDRAM;
|
|
|
|
|
CanWriteOldBDR = features.CanWriteOldBDR;
|
|
|
|
|
CanWriteOldBDRE = features.CanWriteOldBDRE;
|
|
|
|
|
CanWritePackedSubchannelInTAO = features.CanWritePackedSubchannelInTAO;
|
|
|
|
|
CanWriteRWSubchannelInSAO = features.CanWriteRWSubchannelInSAO;
|
|
|
|
|
CanWriteRWSubchannelInTAO = features.CanWriteRWSubchannelInTAO;
|
|
|
|
|
CanWriteRaw = features.CanWriteRaw;
|
|
|
|
|
CanWriteRawMultiSession = features.CanWriteRawMultiSession;
|
|
|
|
|
CanWriteRawSubchannelInTAO = features.CanWriteRawSubchannelInTAO;
|
|
|
|
|
ChangerIsSideChangeCapable = features.ChangerIsSideChangeCapable;
|
|
|
|
|
ChangerSlots = features.ChangerSlots;
|
|
|
|
|
ChangerSupportsDiscPresent = features.ChangerSupportsDiscPresent;
|
|
|
|
|
DBML = features.DBML;
|
|
|
|
|
DVDMultiRead = features.DVDMultiRead;
|
|
|
|
|
EmbeddedChanger = features.EmbeddedChanger;
|
|
|
|
|
ErrorRecoveryPage = features.ErrorRecoveryPage;
|
|
|
|
|
Locked = features.Locked;
|
|
|
|
|
MultiRead = features.MultiRead;
|
|
|
|
|
PreventJumper = features.PreventJumper;
|
|
|
|
|
SupportsAACS = features.SupportsAACS;
|
|
|
|
|
SupportsBusEncryption = features.SupportsBusEncryption;
|
|
|
|
|
SupportsC2 = features.SupportsC2;
|
|
|
|
|
SupportsCPRM = features.SupportsCPRM;
|
|
|
|
|
SupportsCSS = features.SupportsCSS;
|
|
|
|
|
SupportsDAP = features.SupportsDAP;
|
|
|
|
|
SupportsDeviceBusyEvent = features.SupportsDeviceBusyEvent;
|
|
|
|
|
SupportsHybridDiscs = features.SupportsHybridDiscs;
|
|
|
|
|
SupportsModePage1Ch = features.SupportsModePage1Ch;
|
|
|
|
|
SupportsOSSC = features.SupportsOSSC;
|
|
|
|
|
SupportsPWP = features.SupportsPWP;
|
|
|
|
|
SupportsSWPP = features.SupportsSWPP;
|
|
|
|
|
SupportsSecurDisc = features.SupportsSecurDisc;
|
|
|
|
|
SupportsSeparateVolume = features.SupportsSeparateVolume;
|
|
|
|
|
SupportsVCPS = features.SupportsVCPS;
|
|
|
|
|
SupportsWriteInhibitDCB = features.SupportsWriteInhibitDCB;
|
|
|
|
|
SupportsWriteProtectPAC = features.SupportsWriteProtectPAC;
|
|
|
|
|
}
|
|
|
|
|
|
2018-11-26 23:16:54 +00:00
|
|
|
[JsonIgnore]
|
2019-11-24 19:15:29 +00:00
|
|
|
public int Id { get; set; }
|
|
|
|
|
[DisplayName("AACS version")]
|
|
|
|
|
public byte? AACSVersion { get; set; }
|
|
|
|
|
[DisplayName("AGIDs")]
|
|
|
|
|
public byte? AGIDs { get; set; }
|
|
|
|
|
[DisplayName("Binding nonce blocks")]
|
|
|
|
|
public byte? BindingNonceBlocks { get; set; }
|
|
|
|
|
[DisplayName("Blocks per redable unit")]
|
|
|
|
|
public ushort? BlocksPerReadableUnit { get; set; }
|
|
|
|
|
[DisplayName("Buffer under-run free in DVD writing")]
|
|
|
|
|
public bool BufferUnderrunFreeInDVD { get; set; }
|
|
|
|
|
[DisplayName("Buffer under-run free in SAO writing")]
|
|
|
|
|
public bool BufferUnderrunFreeInSAO { get; set; }
|
|
|
|
|
[DisplayName("Buffer under-run free in TAO writing")]
|
|
|
|
|
public bool BufferUnderrunFreeInTAO { get; set; }
|
|
|
|
|
[DisplayName("Can audio scan")]
|
|
|
|
|
public bool CanAudioScan { get; set; }
|
|
|
|
|
[DisplayName("Can eject")]
|
|
|
|
|
public bool CanEject { get; set; }
|
|
|
|
|
[DisplayName("Can erase sectors")]
|
|
|
|
|
public bool CanEraseSector { get; set; }
|
|
|
|
|
[DisplayName("Can expand BD-RE spare area")]
|
|
|
|
|
public bool CanExpandBDRESpareArea { get; set; }
|
|
|
|
|
[DisplayName("Can format media")]
|
|
|
|
|
public bool CanFormat { get; set; }
|
|
|
|
|
[DisplayName("Can format BD-RE without spare area")]
|
|
|
|
|
public bool CanFormatBDREWithoutSpare { get; set; }
|
|
|
|
|
[DisplayName("Can do a fully certified format")]
|
|
|
|
|
public bool CanFormatCert { get; set; }
|
|
|
|
|
[DisplayName("Can do a FRF format")]
|
|
|
|
|
public bool CanFormatFRF { get; set; }
|
|
|
|
|
[DisplayName("Can do a quick certified format")]
|
|
|
|
|
public bool CanFormatQCert { get; set; }
|
|
|
|
|
[DisplayName("Can do a RRM format")]
|
|
|
|
|
public bool CanFormatRRM { get; set; }
|
|
|
|
|
[DisplayName("Can generate binding nonce")]
|
|
|
|
|
public bool CanGenerateBindingNonce { get; set; }
|
|
|
|
|
[DisplayName("Can load")]
|
|
|
|
|
public bool CanLoad { get; set; }
|
|
|
|
|
[DisplayName("Can mute separate channels")]
|
|
|
|
|
public bool CanMuteSeparateChannels { get; set; }
|
|
|
|
|
[DisplayName("Can overwrite track in SAO")]
|
|
|
|
|
public bool CanOverwriteSAOTrack { get; set; }
|
|
|
|
|
[DisplayName("Can overwrite track in TAO")]
|
|
|
|
|
public bool CanOverwriteTAOTrack { get; set; }
|
|
|
|
|
[DisplayName("Can play CD-DA")]
|
|
|
|
|
public bool CanPlayCDAudio { get; set; }
|
|
|
|
|
[DisplayName("Can pseudo-overwrite BD-R")]
|
|
|
|
|
public bool CanPseudoOverwriteBDR { get; set; }
|
|
|
|
|
[DisplayName("Can read all dual-layer recordables")]
|
|
|
|
|
public bool CanReadAllDualR { get; set; }
|
|
|
|
|
[DisplayName("Can read all dual-layer rewritables")]
|
|
|
|
|
public bool CanReadAllDualRW { get; set; }
|
|
|
|
|
[DisplayName("Can read Blu-ray")]
|
|
|
|
|
public bool CanReadBD { get; set; }
|
|
|
|
|
[DisplayName("Can read BD-R")]
|
|
|
|
|
public bool CanReadBDR { get; set; }
|
|
|
|
|
[DisplayName("Can read BD-RE v1")]
|
|
|
|
|
public bool CanReadBDRE1 { get; set; }
|
|
|
|
|
[DisplayName("Can read BD-RE v2")]
|
|
|
|
|
public bool CanReadBDRE2 { get; set; }
|
|
|
|
|
[DisplayName("Can read BD-ROM")]
|
|
|
|
|
public bool CanReadBDROM { get; set; }
|
|
|
|
|
[DisplayName("Can read BCA from Blu-ray")]
|
|
|
|
|
public bool CanReadBluBCA { get; set; }
|
|
|
|
|
[DisplayName("Can read CD")]
|
|
|
|
|
public bool CanReadCD { get; set; }
|
|
|
|
|
[DisplayName("Can read CD-MRW")]
|
|
|
|
|
public bool CanReadCDMRW { get; set; }
|
|
|
|
|
[DisplayName("Can read CPRM's MKB")]
|
|
|
|
|
public bool CanReadCPRM_MKB { get; set; }
|
|
|
|
|
[DisplayName("Can read DDCD")]
|
|
|
|
|
public bool CanReadDDCD { get; set; }
|
|
|
|
|
[DisplayName("Can read DVD")]
|
|
|
|
|
public bool CanReadDVD { get; set; }
|
|
|
|
|
[DisplayName("Can read DVD+MRW")]
|
|
|
|
|
public bool CanReadDVDPlusMRW { get; set; }
|
|
|
|
|
[DisplayName("Can read DVD+R")]
|
|
|
|
|
public bool CanReadDVDPlusR { get; set; }
|
|
|
|
|
[DisplayName("Can read DVD+R DL")]
|
|
|
|
|
public bool CanReadDVDPlusRDL { get; set; }
|
|
|
|
|
[DisplayName("Can read DVD+RW")]
|
|
|
|
|
public bool CanReadDVDPlusRW { get; set; }
|
|
|
|
|
[DisplayName("Can read DVD+RW DL")]
|
|
|
|
|
public bool CanReadDVDPlusRWDL { get; set; }
|
|
|
|
|
[DisplayName("Can read drive's AACS certificate")]
|
|
|
|
|
public bool CanReadDriveAACSCertificate { get; set; }
|
|
|
|
|
[DisplayName("Can read HD DVD")]
|
|
|
|
|
public bool CanReadHDDVD { get; set; }
|
|
|
|
|
[DisplayName("Can read HD DVD-R")]
|
|
|
|
|
public bool CanReadHDDVDR { get; set; }
|
|
|
|
|
[DisplayName("Can read HD DVD-RAM")]
|
|
|
|
|
public bool CanReadHDDVDRAM { get; set; }
|
|
|
|
|
[DisplayName("Can read Lead-In's CD-TEXT")]
|
|
|
|
|
public bool CanReadLeadInCDText { get; set; }
|
|
|
|
|
[DisplayName("Can read old generation BD-R")]
|
|
|
|
|
public bool CanReadOldBDR { get; set; }
|
|
|
|
|
[DisplayName("Can read old generation BD-RE")]
|
|
|
|
|
public bool CanReadOldBDRE { get; set; }
|
|
|
|
|
[DisplayName("Can read old generation BD-ROM")]
|
|
|
|
|
public bool CanReadOldBDROM { get; set; }
|
|
|
|
|
[DisplayName("Can read spare area information")]
|
|
|
|
|
public bool CanReadSpareAreaInformation { get; set; }
|
|
|
|
|
[DisplayName("Can report drive serial number")]
|
|
|
|
|
public bool CanReportDriveSerial { get; set; }
|
|
|
|
|
[DisplayName("Can report media serial number")]
|
|
|
|
|
public bool CanReportMediaSerial { get; set; }
|
|
|
|
|
[DisplayName("Can test write DDCD-R")]
|
|
|
|
|
public bool CanTestWriteDDCDR { get; set; }
|
|
|
|
|
[DisplayName("Can test write DVD")]
|
|
|
|
|
public bool CanTestWriteDVD { get; set; }
|
|
|
|
|
[DisplayName("Can test write in SAO mode")]
|
|
|
|
|
public bool CanTestWriteInSAO { get; set; }
|
|
|
|
|
[DisplayName("Can test write in TAO mode")]
|
|
|
|
|
public bool CanTestWriteInTAO { get; set; }
|
|
|
|
|
[DisplayName("Can upgrade firmware")]
|
|
|
|
|
public bool CanUpgradeFirmware { get; set; }
|
|
|
|
|
[DisplayName("Can write Blu-ray")]
|
|
|
|
|
public bool CanWriteBD { get; set; }
|
|
|
|
|
[DisplayName("Can write BD-R")]
|
|
|
|
|
public bool CanWriteBDR { get; set; }
|
|
|
|
|
[DisplayName("Can write BD-RE v1")]
|
|
|
|
|
public bool CanWriteBDRE1 { get; set; }
|
|
|
|
|
[DisplayName("Can write BD-RE v2")]
|
|
|
|
|
public bool CanWriteBDRE2 { get; set; }
|
|
|
|
|
[DisplayName("Can write bus encrypted blocks")]
|
|
|
|
|
public bool CanWriteBusEncryptedBlocks { get; set; }
|
|
|
|
|
[DisplayName("Can write CD-MRW")]
|
|
|
|
|
public bool CanWriteCDMRW { get; set; }
|
|
|
|
|
[DisplayName("Can write CD-RW")]
|
|
|
|
|
public bool CanWriteCDRW { get; set; }
|
|
|
|
|
[DisplayName("Can write CD-RW CAV")]
|
|
|
|
|
public bool CanWriteCDRWCAV { get; set; }
|
|
|
|
|
[DisplayName("Can write CD in SAO mode")]
|
|
|
|
|
public bool CanWriteCDSAO { get; set; }
|
|
|
|
|
[DisplayName("Can write CD in TAO mode")]
|
|
|
|
|
public bool CanWriteCDTAO { get; set; }
|
|
|
|
|
[DisplayName("Can write CSS managed DVD")]
|
|
|
|
|
public bool CanWriteCSSManagedDVD { get; set; }
|
|
|
|
|
[DisplayName("Can write DDCD-R")]
|
|
|
|
|
public bool CanWriteDDCDR { get; set; }
|
|
|
|
|
[DisplayName("Can write DDCD-RW")]
|
|
|
|
|
public bool CanWriteDDCDRW { get; set; }
|
|
|
|
|
[DisplayName("Can write DVD+MRW")]
|
|
|
|
|
public bool CanWriteDVDPlusMRW { get; set; }
|
|
|
|
|
[DisplayName("Can write DVD+R")]
|
|
|
|
|
public bool CanWriteDVDPlusR { get; set; }
|
|
|
|
|
[DisplayName("Can write DVD+R DL")]
|
|
|
|
|
public bool CanWriteDVDPlusRDL { get; set; }
|
|
|
|
|
[DisplayName("Can write DVD+RW")]
|
|
|
|
|
public bool CanWriteDVDPlusRW { get; set; }
|
|
|
|
|
[DisplayName("Can write DVD+RW DL")]
|
|
|
|
|
public bool CanWriteDVDPlusRWDL { get; set; }
|
|
|
|
|
[DisplayName("Can write DVD-R")]
|
|
|
|
|
public bool CanWriteDVDR { get; set; }
|
|
|
|
|
[DisplayName("Can write DVD-R DL")]
|
|
|
|
|
public bool CanWriteDVDRDL { get; set; }
|
|
|
|
|
[DisplayName("Can write DVD-RW")]
|
|
|
|
|
public bool CanWriteDVDRW { get; set; }
|
|
|
|
|
[DisplayName("Can write HD DVD-R")]
|
|
|
|
|
public bool CanWriteHDDVDR { get; set; }
|
|
|
|
|
[DisplayName("Can write HD DVD-RAM")]
|
|
|
|
|
public bool CanWriteHDDVDRAM { get; set; }
|
|
|
|
|
[DisplayName("Can write old generation BD-R")]
|
|
|
|
|
public bool CanWriteOldBDR { get; set; }
|
|
|
|
|
[DisplayName("Can write old generation BD-RE")]
|
|
|
|
|
public bool CanWriteOldBDRE { get; set; }
|
|
|
|
|
[DisplayName("Can write packet subchannel in TAO")]
|
|
|
|
|
public bool CanWritePackedSubchannelInTAO { get; set; }
|
|
|
|
|
[DisplayName("Can write RW subchannel in SAO")]
|
|
|
|
|
public bool CanWriteRWSubchannelInSAO { get; set; }
|
|
|
|
|
[DisplayName("Can write RW subchannel in TAO")]
|
|
|
|
|
public bool CanWriteRWSubchannelInTAO { get; set; }
|
|
|
|
|
[DisplayName("Can write RAW-96 sectors")]
|
|
|
|
|
public bool CanWriteRaw { get; set; }
|
|
|
|
|
[DisplayName("Can write RAW-96 sectors in multisession")]
|
|
|
|
|
public bool CanWriteRawMultiSession { get; set; }
|
|
|
|
|
[DisplayName("Can write RAW-96 sectors in TAO")]
|
|
|
|
|
public bool CanWriteRawSubchannelInTAO { get; set; }
|
|
|
|
|
[DisplayName("Changer is side change capable")]
|
|
|
|
|
public bool ChangerIsSideChangeCapable { get; set; }
|
|
|
|
|
[DisplayName("Changer slots")]
|
|
|
|
|
public byte ChangerSlots { get; set; }
|
|
|
|
|
[DisplayName("Changer supports disc present")]
|
|
|
|
|
public bool ChangerSupportsDiscPresent { get; set; }
|
|
|
|
|
[DisplayName("CPRM version")]
|
|
|
|
|
public byte? CPRMVersion { get; set; }
|
|
|
|
|
[DisplayName("CSS version")]
|
|
|
|
|
public byte? CSSVersion { get; set; }
|
|
|
|
|
[DisplayName("DBML")]
|
|
|
|
|
public bool DBML { get; set; }
|
|
|
|
|
[DisplayName("DVD Multi-Read Specification")]
|
|
|
|
|
public bool DVDMultiRead { get; set; }
|
|
|
|
|
[DisplayName("Has an embedded changer")]
|
|
|
|
|
public bool EmbeddedChanger { get; set; }
|
|
|
|
|
[DisplayName("Has error recovery page")]
|
|
|
|
|
public bool ErrorRecoveryPage { get; set; }
|
|
|
|
|
[DisplayName("Firmware date")]
|
|
|
|
|
public DateTime? FirmwareDate { get; set; }
|
|
|
|
|
[DisplayName("Loading mechanism type")]
|
|
|
|
|
public byte? LoadingMechanismType { get; set; }
|
|
|
|
|
[DisplayName("Locked")]
|
|
|
|
|
public bool Locked { get; set; }
|
|
|
|
|
[DisplayName("Logical block size")]
|
|
|
|
|
public uint? LogicalBlockSize { get; set; }
|
|
|
|
|
[DisplayName("Multi-Read Specification")]
|
|
|
|
|
public bool MultiRead { get; set; }
|
|
|
|
|
[DisplayName("Physical interface standard")]
|
|
|
|
|
public PhysicalInterfaces? PhysicalInterfaceStandard => (PhysicalInterfaces?)PhysicalInterfaceStandardNumber;
|
|
|
|
|
[DisplayName("Physical interface standard number")]
|
|
|
|
|
public uint? PhysicalInterfaceStandardNumber { get; set; }
|
|
|
|
|
[DisplayName("Prevent eject jumper")]
|
|
|
|
|
public bool PreventJumper { get; set; }
|
|
|
|
|
[DisplayName("Supports AACS")]
|
|
|
|
|
public bool SupportsAACS { get; set; }
|
|
|
|
|
[DisplayName("Supports bus encryption")]
|
|
|
|
|
public bool SupportsBusEncryption { get; set; }
|
|
|
|
|
[DisplayName("Supports C2 pointers")]
|
|
|
|
|
public bool SupportsC2 { get; set; }
|
|
|
|
|
[DisplayName("Supports CPRM")]
|
|
|
|
|
public bool SupportsCPRM { get; set; }
|
|
|
|
|
[DisplayName("Supports CSS")]
|
|
|
|
|
public bool SupportsCSS { get; set; }
|
|
|
|
|
[DisplayName("Supports DAP")]
|
|
|
|
|
public bool SupportsDAP { get; set; }
|
|
|
|
|
[DisplayName("Supports device busy event")]
|
|
|
|
|
public bool SupportsDeviceBusyEvent { get; set; }
|
|
|
|
|
[DisplayName("Supports hybrid discs")]
|
|
|
|
|
public bool SupportsHybridDiscs { get; set; }
|
|
|
|
|
[DisplayName("Supports MODE PAGE 1Ch")]
|
|
|
|
|
public bool SupportsModePage1Ch { get; set; }
|
|
|
|
|
[DisplayName("Supports OSSC")]
|
|
|
|
|
public bool SupportsOSSC { get; set; }
|
|
|
|
|
[DisplayName("Supports PWP")]
|
|
|
|
|
public bool SupportsPWP { get; set; }
|
|
|
|
|
[DisplayName("Supports SWPP")]
|
|
|
|
|
public bool SupportsSWPP { get; set; }
|
|
|
|
|
[DisplayName("Supports SecurDisc")]
|
|
|
|
|
public bool SupportsSecurDisc { get; set; }
|
|
|
|
|
[DisplayName("Support separate volume levels")]
|
|
|
|
|
public bool SupportsSeparateVolume { get; set; }
|
|
|
|
|
[DisplayName("Supports VCPS")]
|
|
|
|
|
public bool SupportsVCPS { get; set; }
|
|
|
|
|
[DisplayName("Supports write inhibit DCB")]
|
|
|
|
|
public bool SupportsWriteInhibitDCB { get; set; }
|
|
|
|
|
[DisplayName("Supports write protect PAC")]
|
|
|
|
|
public bool SupportsWriteProtectPAC { get; set; }
|
|
|
|
|
[DisplayName("Volume levels")]
|
|
|
|
|
public ushort? VolumeLevels { get; set; }
|
|
|
|
|
[DisplayName("MMC FEATURES binary data")]
|
|
|
|
|
public byte[] BinaryData { get; set; }
|
2018-11-25 17:47:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public class TestedMedia
|
|
|
|
|
{
|
2018-11-26 23:16:54 +00:00
|
|
|
public Identify.IdentifyDevice? IdentifyDevice;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2020-02-29 18:03:24 +00:00
|
|
|
public TestedMedia() {}
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
public TestedMedia(testedMediaType mediaType, bool ata)
|
|
|
|
|
{
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.BlocksSpecified)
|
|
|
|
|
Blocks = mediaType.Blocks;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.BlockSizeSpecified)
|
|
|
|
|
BlockSize = mediaType.BlockSize;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.CanReadAACSSpecified)
|
|
|
|
|
CanReadAACS = mediaType.CanReadAACS;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.CanReadADIPSpecified)
|
|
|
|
|
CanReadADIP = mediaType.CanReadADIP;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.CanReadATIPSpecified)
|
|
|
|
|
CanReadATIP = mediaType.CanReadATIP;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.CanReadBCASpecified)
|
|
|
|
|
CanReadBCA = mediaType.CanReadBCA;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.CanReadC2PointersSpecified)
|
|
|
|
|
CanReadC2Pointers = mediaType.CanReadC2Pointers;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.CanReadCMISpecified)
|
|
|
|
|
CanReadCMI = mediaType.CanReadCMI;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
if(mediaType.CanReadCorrectedSubchannelSpecified)
|
|
|
|
|
CanReadCorrectedSubchannel = mediaType.CanReadCorrectedSubchannel;
|
|
|
|
|
|
|
|
|
|
if(mediaType.CanReadCorrectedSubchannelWithC2Specified)
|
|
|
|
|
CanReadCorrectedSubchannelWithC2 = mediaType.CanReadCorrectedSubchannelWithC2;
|
|
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.CanReadDCBSpecified)
|
|
|
|
|
CanReadDCB = mediaType.CanReadDCB;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.CanReadDDSSpecified)
|
|
|
|
|
CanReadDDS = mediaType.CanReadDDS;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.CanReadDMISpecified)
|
|
|
|
|
CanReadDMI = mediaType.CanReadDMI;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.CanReadDiscInformationSpecified)
|
|
|
|
|
CanReadDiscInformation = mediaType.CanReadDiscInformation;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.CanReadFullTOCSpecified)
|
|
|
|
|
CanReadFullTOC = mediaType.CanReadFullTOC;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.CanReadHDCMISpecified)
|
|
|
|
|
CanReadHDCMI = mediaType.CanReadHDCMI;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.CanReadLayerCapacitySpecified)
|
|
|
|
|
CanReadLayerCapacity = mediaType.CanReadLayerCapacity;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.CanReadLeadInSpecified)
|
|
|
|
|
CanReadFirstTrackPreGap = mediaType.CanReadLeadIn;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.CanReadLeadOutSpecified)
|
|
|
|
|
CanReadLeadOut = mediaType.CanReadLeadOut;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.CanReadMediaIDSpecified)
|
|
|
|
|
CanReadMediaID = mediaType.CanReadMediaID;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.CanReadMediaSerialSpecified)
|
|
|
|
|
CanReadMediaSerial = mediaType.CanReadMediaSerial;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.CanReadPACSpecified)
|
|
|
|
|
CanReadPAC = mediaType.CanReadPAC;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.CanReadPFISpecified)
|
|
|
|
|
CanReadPFI = mediaType.CanReadPFI;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.CanReadPMASpecified)
|
|
|
|
|
CanReadPMA = mediaType.CanReadPMA;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.CanReadPQSubchannelSpecified)
|
|
|
|
|
CanReadPQSubchannel = mediaType.CanReadPQSubchannel;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
if(mediaType.CanReadPQSubchannelWithC2Specified)
|
|
|
|
|
CanReadPQSubchannelWithC2 = mediaType.CanReadPQSubchannelWithC2;
|
|
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.CanReadPRISpecified)
|
|
|
|
|
CanReadPRI = mediaType.CanReadPRI;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.CanReadRWSubchannelSpecified)
|
|
|
|
|
CanReadRWSubchannel = mediaType.CanReadRWSubchannel;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
if(mediaType.CanReadRWSubchannelWithC2Specified)
|
|
|
|
|
CanReadRWSubchannelWithC2 = mediaType.CanReadRWSubchannelWithC2;
|
|
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.CanReadRecordablePFISpecified)
|
|
|
|
|
CanReadRecordablePFI = mediaType.CanReadRecordablePFI;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
if(mediaType.CanReadSpareAreaInformationSpecified)
|
|
|
|
|
CanReadSpareAreaInformation = mediaType.CanReadSpareAreaInformation;
|
|
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.CanReadTOCSpecified)
|
|
|
|
|
CanReadTOC = mediaType.CanReadTOC;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.DensitySpecified)
|
|
|
|
|
Density = mediaType.Density;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.LongBlockSizeSpecified)
|
|
|
|
|
LongBlockSize = mediaType.LongBlockSize;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.ManufacturerSpecified)
|
|
|
|
|
Manufacturer = mediaType.Manufacturer;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.MediumTypeSpecified)
|
|
|
|
|
MediumType = mediaType.MediumType;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.ModelSpecified)
|
|
|
|
|
Model = mediaType.Model;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
if(mediaType.SupportsHLDTSTReadRawDVDSpecified)
|
|
|
|
|
SupportsHLDTSTReadRawDVD = mediaType.SupportsHLDTSTReadRawDVD;
|
|
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.SupportsNECReadCDDASpecified)
|
|
|
|
|
SupportsNECReadCDDA = mediaType.SupportsNECReadCDDA;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.SupportsPioneerReadCDDASpecified)
|
|
|
|
|
SupportsPioneerReadCDDA = mediaType.SupportsPioneerReadCDDA;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
if(mediaType.SupportsPioneerReadCDDAMSFSpecified)
|
|
|
|
|
SupportsPioneerReadCDDAMSF = mediaType.SupportsPioneerReadCDDAMSF;
|
|
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.SupportsPlextorReadCDDASpecified)
|
|
|
|
|
SupportsPlextorReadCDDA = mediaType.SupportsPlextorReadCDDA;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
if(mediaType.SupportsPlextorReadRawDVDSpecified)
|
|
|
|
|
SupportsPlextorReadRawDVD = mediaType.SupportsPlextorReadRawDVD;
|
|
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.SupportsRead10Specified)
|
|
|
|
|
SupportsRead10 = mediaType.SupportsRead10;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.SupportsRead12Specified)
|
|
|
|
|
SupportsRead12 = mediaType.SupportsRead12;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.SupportsRead16Specified)
|
|
|
|
|
SupportsRead16 = mediaType.SupportsRead16;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
if(mediaType.SupportsReadSpecified)
|
|
|
|
|
{
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ata)
|
|
|
|
|
SupportsReadSectors = mediaType.SupportsRead;
|
|
|
|
|
else
|
|
|
|
|
SupportsRead6 = mediaType.SupportsRead;
|
2018-12-20 23:52:16 +00:00
|
|
|
}
|
|
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.SupportsReadCapacity16Specified)
|
|
|
|
|
SupportsReadCapacity16 = mediaType.SupportsReadCapacity16;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.SupportsReadCapacitySpecified)
|
|
|
|
|
SupportsReadCapacity = mediaType.SupportsReadCapacity;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.SupportsReadCdSpecified)
|
|
|
|
|
SupportsReadCd = mediaType.SupportsReadCd;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.SupportsReadCdMsfSpecified)
|
|
|
|
|
SupportsReadCdMsf = mediaType.SupportsReadCdMsf;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.SupportsReadCdRawSpecified)
|
|
|
|
|
SupportsReadCdRaw = mediaType.SupportsReadCdRaw;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.SupportsReadCdMsfRawSpecified)
|
|
|
|
|
SupportsReadCdMsfRaw = mediaType.SupportsReadCdMsfRaw;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.SupportsReadLong16Specified)
|
|
|
|
|
SupportsReadLong16 = mediaType.SupportsReadLong16;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.SupportsReadLongSpecified)
|
|
|
|
|
SupportsReadLong = mediaType.SupportsReadLong;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.LBASectorsSpecified)
|
|
|
|
|
LBASectors = mediaType.LBASectors;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.LBA48SectorsSpecified)
|
|
|
|
|
LBA48Sectors = mediaType.LBA48Sectors;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.LogicalAlignmentSpecified)
|
|
|
|
|
LogicalAlignment = mediaType.LogicalAlignment;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.NominalRotationRateSpecified)
|
|
|
|
|
NominalRotationRate = mediaType.NominalRotationRate;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.PhysicalBlockSizeSpecified)
|
|
|
|
|
PhysicalBlockSize = mediaType.PhysicalBlockSize;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.SolidStateDeviceSpecified)
|
|
|
|
|
SolidStateDevice = mediaType.SolidStateDevice;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.UnformattedBPTSpecified)
|
|
|
|
|
UnformattedBPT = mediaType.UnformattedBPT;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.UnformattedBPSSpecified)
|
|
|
|
|
UnformattedBPS = mediaType.UnformattedBPS;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.SupportsReadDmaLbaSpecified)
|
|
|
|
|
SupportsReadDmaLba = mediaType.SupportsReadDmaLba;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.SupportsReadDmaRetryLbaSpecified)
|
|
|
|
|
SupportsReadDmaRetryLba = mediaType.SupportsReadDmaRetryLba;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.SupportsReadLbaSpecified)
|
|
|
|
|
SupportsReadLba = mediaType.SupportsReadLba;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.SupportsReadRetryLbaSpecified)
|
|
|
|
|
SupportsReadRetryLba = mediaType.SupportsReadRetryLba;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.SupportsReadLongLbaSpecified)
|
|
|
|
|
SupportsReadLongLba = mediaType.SupportsReadLongLba;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
if(mediaType.SupportsReadLongRetryLbaSpecified)
|
|
|
|
|
SupportsReadLongRetryLba = mediaType.SupportsReadLongRetryLba;
|
|
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.SupportsSeekLbaSpecified)
|
|
|
|
|
SupportsSeekLba = mediaType.SupportsSeekLba;
|
|
|
|
|
|
|
|
|
|
if(mediaType.SupportsReadDmaLba48Specified)
|
|
|
|
|
SupportsReadDmaLba48 = mediaType.SupportsReadDmaLba48;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.SupportsReadLba48Specified)
|
|
|
|
|
SupportsReadLba48 = mediaType.SupportsReadLba48;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.SupportsReadDmaSpecified)
|
|
|
|
|
SupportsReadDma = mediaType.SupportsReadDma;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.SupportsReadDmaRetrySpecified)
|
|
|
|
|
SupportsReadDmaRetry = mediaType.SupportsReadDmaRetry;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.SupportsReadRetrySpecified)
|
|
|
|
|
SupportsReadRetry = mediaType.SupportsReadRetry;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.SupportsReadLongRetrySpecified)
|
|
|
|
|
SupportsReadLongRetry = mediaType.SupportsReadLongRetry;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.SupportsSeekSpecified)
|
|
|
|
|
SupportsSeek = mediaType.SupportsSeek;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.CHS != null)
|
|
|
|
|
CHS = new Chs(mediaType.CHS);
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(mediaType.CurrentCHS != null)
|
|
|
|
|
CurrentCHS = new Chs(mediaType.CurrentCHS);
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
MediaIsRecognized = mediaType.MediaIsRecognized;
|
|
|
|
|
MediumTypeName = mediaType.MediumTypeName;
|
|
|
|
|
ModeSense6Data = mediaType.ModeSense6Data;
|
|
|
|
|
ModeSense10Data = mediaType.ModeSense10Data;
|
|
|
|
|
}
|
|
|
|
|
|
2018-11-26 23:16:54 +00:00
|
|
|
[JsonIgnore]
|
2019-11-24 19:15:29 +00:00
|
|
|
public int Id { get; set; }
|
|
|
|
|
[DisplayName("IDENTIFY DEVICE data")]
|
|
|
|
|
public byte[] IdentifyData { get; set; }
|
|
|
|
|
[DisplayName("Blocks")]
|
|
|
|
|
public ulong? Blocks { get; set; }
|
|
|
|
|
[DisplayName("Bytes per block")]
|
|
|
|
|
public uint? BlockSize { get; set; }
|
|
|
|
|
[DisplayName("Can read AACS")]
|
|
|
|
|
public bool? CanReadAACS { get; set; }
|
|
|
|
|
[DisplayName("Can read ADIP")]
|
|
|
|
|
public bool? CanReadADIP { get; set; }
|
|
|
|
|
[DisplayName("Can read ATIP")]
|
|
|
|
|
public bool? CanReadATIP { get; set; }
|
|
|
|
|
[DisplayName("Can read BCA")]
|
|
|
|
|
public bool? CanReadBCA { get; set; }
|
|
|
|
|
[DisplayName("Can read C2 pointers")]
|
|
|
|
|
public bool? CanReadC2Pointers { get; set; }
|
|
|
|
|
[DisplayName("Can read Copyright Management Information")]
|
|
|
|
|
public bool? CanReadCMI { get; set; }
|
|
|
|
|
[DisplayName("Can read corrected subchannel")]
|
|
|
|
|
public bool? CanReadCorrectedSubchannel { get; set; }
|
|
|
|
|
[DisplayName("Can read corrected subchannel with C2 pointers")]
|
|
|
|
|
public bool? CanReadCorrectedSubchannelWithC2 { get; set; }
|
|
|
|
|
[DisplayName("Can read DCBs")]
|
|
|
|
|
public bool? CanReadDCB { get; set; }
|
|
|
|
|
[DisplayName("Can read DDS")]
|
|
|
|
|
public bool? CanReadDDS { get; set; }
|
|
|
|
|
[DisplayName("Can read DMI")]
|
|
|
|
|
public bool? CanReadDMI { get; set; }
|
|
|
|
|
[DisplayName("Can read disc information")]
|
|
|
|
|
public bool? CanReadDiscInformation { get; set; }
|
|
|
|
|
[DisplayName("Can read full TOC")]
|
|
|
|
|
public bool? CanReadFullTOC { get; set; }
|
|
|
|
|
[DisplayName("Can read HD-DVD Copyright Management Information")]
|
|
|
|
|
public bool? CanReadHDCMI { get; set; }
|
|
|
|
|
[DisplayName("Can read layer capacity")]
|
|
|
|
|
public bool? CanReadLayerCapacity { get; set; }
|
|
|
|
|
[DisplayName("Can read into first track pregap")]
|
|
|
|
|
public bool? CanReadFirstTrackPreGap { get; set; }
|
|
|
|
|
[DisplayName("Can read into Lead-In")]
|
|
|
|
|
public bool? CanReadLeadIn { get; set; }
|
|
|
|
|
[DisplayName("Can read into Lead-Out")]
|
|
|
|
|
public bool? CanReadLeadOut { get; set; }
|
|
|
|
|
[DisplayName("Can read media ID")]
|
|
|
|
|
public bool? CanReadMediaID { get; set; }
|
|
|
|
|
[DisplayName("Can read media serial number")]
|
|
|
|
|
public bool? CanReadMediaSerial { get; set; }
|
|
|
|
|
[DisplayName("Can read PAC")]
|
|
|
|
|
public bool? CanReadPAC { get; set; }
|
|
|
|
|
[DisplayName("Can read PFI")]
|
|
|
|
|
public bool? CanReadPFI { get; set; }
|
|
|
|
|
[DisplayName("Can read PMA")]
|
|
|
|
|
public bool? CanReadPMA { get; set; }
|
|
|
|
|
[DisplayName("Can read PQ subchannel")]
|
|
|
|
|
public bool? CanReadPQSubchannel { get; set; }
|
|
|
|
|
[DisplayName("Can read PQ subchannel with C2 pointers")]
|
|
|
|
|
public bool? CanReadPQSubchannelWithC2 { get; set; }
|
|
|
|
|
[DisplayName("Can read pre-recorded information")]
|
|
|
|
|
public bool? CanReadPRI { get; set; }
|
|
|
|
|
[DisplayName("Can read RW subchannel")]
|
|
|
|
|
public bool? CanReadRWSubchannel { get; set; }
|
|
|
|
|
[DisplayName("Can read RW subchannel with C2 pointers")]
|
|
|
|
|
public bool? CanReadRWSubchannelWithC2 { get; set; }
|
|
|
|
|
[DisplayName("Can read recordable PFI")]
|
|
|
|
|
public bool? CanReadRecordablePFI { get; set; }
|
|
|
|
|
[DisplayName("Can read spare area information")]
|
|
|
|
|
public bool? CanReadSpareAreaInformation { get; set; }
|
|
|
|
|
[DisplayName("Can read TOC")]
|
|
|
|
|
public bool? CanReadTOC { get; set; }
|
|
|
|
|
[DisplayName("Density code")]
|
|
|
|
|
public byte? Density { get; set; }
|
|
|
|
|
[DisplayName("Bytes per block in READ LONG commands")]
|
|
|
|
|
public uint? LongBlockSize { get; set; }
|
|
|
|
|
[DisplayName("Media manufacturer")]
|
|
|
|
|
public string Manufacturer { get; set; }
|
|
|
|
|
[DisplayName("Media recognized by drive?")]
|
|
|
|
|
public bool MediaIsRecognized { get; set; }
|
|
|
|
|
[DisplayName("Medium type code")]
|
|
|
|
|
public byte? MediumType { get; set; }
|
|
|
|
|
[DisplayName("Media type")]
|
|
|
|
|
public string MediumTypeName { get; set; }
|
|
|
|
|
[DisplayName("Media model")]
|
|
|
|
|
public string Model { get; set; }
|
|
|
|
|
[DisplayName("Can read scrambled DVD sectors using HL-DT-ST cache trick")]
|
|
|
|
|
public bool? SupportsHLDTSTReadRawDVD { get; set; }
|
|
|
|
|
[DisplayName("Supports NEC READ CD-DA command")]
|
|
|
|
|
public bool? SupportsNECReadCDDA { get; set; }
|
|
|
|
|
[DisplayName("Supports Pioneer READ CD-DA command")]
|
|
|
|
|
public bool? SupportsPioneerReadCDDA { get; set; }
|
|
|
|
|
[DisplayName("Supports Pioneer READ CD-DA MSF command")]
|
|
|
|
|
public bool? SupportsPioneerReadCDDAMSF { get; set; }
|
|
|
|
|
[DisplayName("Supports Plextor READ CD-DA command")]
|
|
|
|
|
public bool? SupportsPlextorReadCDDA { get; set; }
|
|
|
|
|
[DisplayName("Can read scrambled DVD sectors using Plextor vendor command")]
|
|
|
|
|
public bool? SupportsPlextorReadRawDVD { get; set; }
|
|
|
|
|
[DisplayName("Supports READ(10) command")]
|
|
|
|
|
public bool? SupportsRead10 { get; set; }
|
|
|
|
|
[DisplayName("Supports READ(12) command")]
|
|
|
|
|
public bool? SupportsRead12 { get; set; }
|
|
|
|
|
[DisplayName("Supports READ(16) command")]
|
|
|
|
|
public bool? SupportsRead16 { get; set; }
|
|
|
|
|
[DisplayName("Supports READ(6) command")]
|
|
|
|
|
public bool? SupportsRead6 { get; set; }
|
|
|
|
|
[DisplayName("Supports READ CAPACITY(16) command")]
|
|
|
|
|
public bool? SupportsReadCapacity16 { get; set; }
|
|
|
|
|
[DisplayName("Supports READ CAPACITY command")]
|
|
|
|
|
public bool? SupportsReadCapacity { get; set; }
|
|
|
|
|
[DisplayName("Supports READ CD command")]
|
|
|
|
|
public bool? SupportsReadCd { get; set; }
|
|
|
|
|
[DisplayName("Supports READ CD MSF command")]
|
|
|
|
|
public bool? SupportsReadCdMsf { get; set; }
|
|
|
|
|
[DisplayName("Supports full sector in READ CD command")]
|
|
|
|
|
public bool? SupportsReadCdRaw { get; set; }
|
|
|
|
|
[DisplayName("Supports full sector in READ CD MSF command")]
|
|
|
|
|
public bool? SupportsReadCdMsfRaw { get; set; }
|
|
|
|
|
[DisplayName("Supports READ LONG(16) command")]
|
|
|
|
|
public bool? SupportsReadLong16 { get; set; }
|
|
|
|
|
[DisplayName("Supports READ LONG command")]
|
|
|
|
|
public bool? SupportsReadLong { get; set; }
|
|
|
|
|
|
|
|
|
|
[DisplayName("Data from MODE SENSE(6) command")]
|
|
|
|
|
public byte[] ModeSense6Data { get; set; }
|
|
|
|
|
[DisplayName("Data from MODE SENSE(10) command")]
|
2018-11-25 17:47:14 +00:00
|
|
|
public byte[] ModeSense10Data { get; set; }
|
|
|
|
|
|
2019-11-24 19:15:29 +00:00
|
|
|
public virtual Chs CHS { get; set; }
|
|
|
|
|
public virtual Chs CurrentCHS { get; set; }
|
|
|
|
|
[DisplayName("Sectors in 28-bit LBA mode")]
|
|
|
|
|
public uint? LBASectors { get; set; }
|
|
|
|
|
[DisplayName("Sectors in 48-bit LBA mode")]
|
|
|
|
|
public ulong? LBA48Sectors { get; set; }
|
|
|
|
|
[DisplayName("Logical alignment")]
|
|
|
|
|
public ushort? LogicalAlignment { get; set; }
|
|
|
|
|
[DisplayName("Nominal rotation rate")]
|
|
|
|
|
public ushort? NominalRotationRate { get; set; }
|
|
|
|
|
[DisplayName("Bytes per block, physical")]
|
|
|
|
|
public uint? PhysicalBlockSize { get; set; }
|
|
|
|
|
[DisplayName("Is it a SSD?")]
|
|
|
|
|
public bool? SolidStateDevice { get; set; }
|
|
|
|
|
[DisplayName("Bytes per unformatted track")]
|
|
|
|
|
public ushort? UnformattedBPT { get; set; }
|
|
|
|
|
[DisplayName("Bytes per unformatted sector")]
|
|
|
|
|
public ushort? UnformattedBPS { get; set; }
|
|
|
|
|
|
|
|
|
|
[DisplayName("Supports READ DMA (LBA) command")]
|
|
|
|
|
public bool? SupportsReadDmaLba { get; set; }
|
|
|
|
|
[DisplayName("Supports READ DMA RETRY (LBA) command")]
|
|
|
|
|
public bool? SupportsReadDmaRetryLba { get; set; }
|
|
|
|
|
[DisplayName("Supports READ SECTORS (LBA) command")]
|
|
|
|
|
public bool? SupportsReadLba { get; set; }
|
|
|
|
|
[DisplayName("Supports READ SECTORS RETRY (LBA) command")]
|
|
|
|
|
public bool? SupportsReadRetryLba { get; set; }
|
|
|
|
|
[DisplayName("Supports READ SECTORS LONG (LBA) command")]
|
|
|
|
|
public bool? SupportsReadLongLba { get; set; }
|
|
|
|
|
[DisplayName("Supports READ SECTORS LONG RETRY (LBA) command")]
|
2018-11-25 17:47:14 +00:00
|
|
|
public bool? SupportsReadLongRetryLba { get; set; }
|
2019-11-24 19:15:29 +00:00
|
|
|
[DisplayName("Supports SEEK (LBA) command")]
|
|
|
|
|
public bool? SupportsSeekLba { get; set; }
|
2018-11-25 17:47:14 +00:00
|
|
|
|
2019-11-24 19:15:29 +00:00
|
|
|
[DisplayName("Supports READ DMA EXT command")]
|
2018-11-25 17:47:14 +00:00
|
|
|
public bool? SupportsReadDmaLba48 { get; set; }
|
2019-11-24 19:15:29 +00:00
|
|
|
[DisplayName("Supports READ SECTORS EXT command")]
|
|
|
|
|
public bool? SupportsReadLba48 { get; set; }
|
|
|
|
|
|
|
|
|
|
[DisplayName("Supports READ DMA command")]
|
|
|
|
|
public bool? SupportsReadDma { get; set; }
|
|
|
|
|
[DisplayName("Supports READ DMA RETRY command")]
|
|
|
|
|
public bool? SupportsReadDmaRetry { get; set; }
|
|
|
|
|
[DisplayName("Supports READ SECTORS RETRY command")]
|
|
|
|
|
public bool? SupportsReadRetry { get; set; }
|
|
|
|
|
[DisplayName("Supports READ SECTORS command")]
|
|
|
|
|
public bool? SupportsReadSectors { get; set; }
|
|
|
|
|
[DisplayName("Supports READ SECTORS LONG RETRY command")]
|
2018-11-25 17:47:14 +00:00
|
|
|
public bool? SupportsReadLongRetry { get; set; }
|
2019-11-24 19:15:29 +00:00
|
|
|
[DisplayName("Supports SEEK command")]
|
|
|
|
|
public bool? SupportsSeek { get; set; }
|
|
|
|
|
|
|
|
|
|
[DisplayName("Can read into inter-session Lead-In")]
|
|
|
|
|
public bool? CanReadingIntersessionLeadIn { get; set; }
|
|
|
|
|
[DisplayName("Can read into inter-session Lead-Out")]
|
|
|
|
|
public bool? CanReadingIntersessionLeadOut { get; set; }
|
|
|
|
|
[DisplayName("Data from inter-session Lead-In")]
|
|
|
|
|
public byte[] IntersessionLeadInData { get; set; }
|
|
|
|
|
[DisplayName("Data from inter-session Lead-Out")]
|
|
|
|
|
public byte[] IntersessionLeadOutData { get; set; }
|
2019-01-02 22:27:02 +00:00
|
|
|
|
2019-11-24 22:40:26 +00:00
|
|
|
[DisplayName("Can read scrambled data using READ CD command")]
|
|
|
|
|
public bool? CanReadCdScrambled { get; set; }
|
|
|
|
|
[DisplayName("Data from scrambled READ CD command")]
|
|
|
|
|
public byte[] ReadCdScrambledData { get; set; }
|
|
|
|
|
|
2019-11-10 00:00:36 +00:00
|
|
|
[JsonIgnore]
|
2019-11-10 01:07:11 +00:00
|
|
|
public int? AtaId { get; set; }
|
2019-11-17 18:11:51 +00:00
|
|
|
[JsonIgnore]
|
|
|
|
|
public int? ScsiId { get; set; }
|
2019-11-23 23:48:27 +00:00
|
|
|
[JsonIgnore]
|
|
|
|
|
public int? MmcId { get; set; }
|
2019-11-10 00:00:36 +00:00
|
|
|
|
2018-12-26 01:15:30 +00:00
|
|
|
#region SCSI data
|
2019-11-24 19:15:29 +00:00
|
|
|
[DisplayName("Data from READ(6) command")]
|
|
|
|
|
public byte[] Read6Data { get; set; }
|
|
|
|
|
[DisplayName("Data from READ(10) command")]
|
|
|
|
|
public byte[] Read10Data { get; set; }
|
|
|
|
|
[DisplayName("Data from READ(12) command")]
|
|
|
|
|
public byte[] Read12Data { get; set; }
|
|
|
|
|
[DisplayName("Data from READ(16) command")]
|
|
|
|
|
public byte[] Read16Data { get; set; }
|
|
|
|
|
[DisplayName("Data from READ LONG(10) command")]
|
2018-12-26 01:15:30 +00:00
|
|
|
public byte[] ReadLong10Data { get; set; }
|
2019-11-24 19:15:29 +00:00
|
|
|
[DisplayName("Data from READ LONG(16) command")]
|
2018-12-26 01:15:30 +00:00
|
|
|
public byte[] ReadLong16Data { get; set; }
|
|
|
|
|
#endregion
|
|
|
|
|
|
|
|
|
|
#region ATA data
|
2019-11-24 19:15:29 +00:00
|
|
|
[DisplayName("Data from READ SECTORS command")]
|
|
|
|
|
public byte[] ReadSectorsData { get; set; }
|
|
|
|
|
[DisplayName("Data from READ SECTORS RETRY command")]
|
2018-12-26 01:15:30 +00:00
|
|
|
public byte[] ReadSectorsRetryData { get; set; }
|
2019-11-24 19:15:29 +00:00
|
|
|
[DisplayName("Data from READ DMA command")]
|
|
|
|
|
public byte[] ReadDmaData { get; set; }
|
|
|
|
|
[DisplayName("Data from READ DMA RETRY command")]
|
|
|
|
|
public byte[] ReadDmaRetryData { get; set; }
|
|
|
|
|
[DisplayName("Data from READ SECTORS (LBA) command")]
|
|
|
|
|
public byte[] ReadLbaData { get; set; }
|
|
|
|
|
[DisplayName("Data from READ SECTORS RETRY (LBA) command")]
|
|
|
|
|
public byte[] ReadRetryLbaData { get; set; }
|
|
|
|
|
[DisplayName("Data from READ DMA (LBA) command")]
|
|
|
|
|
public byte[] ReadDmaLbaData { get; set; }
|
|
|
|
|
[DisplayName("Data from READ DMA RETRY (LBA) command")]
|
|
|
|
|
public byte[] ReadDmaRetryLbaData { get; set; }
|
|
|
|
|
[DisplayName("Data from READ SECTORS EXT command")]
|
|
|
|
|
public byte[] ReadLba48Data { get; set; }
|
|
|
|
|
[DisplayName("Data from READ DMA EXT command")]
|
|
|
|
|
public byte[] ReadDmaLba48Data { get; set; }
|
|
|
|
|
[DisplayName("Data from READ SECTORS LONG command")]
|
|
|
|
|
public byte[] ReadLongData { get; set; }
|
|
|
|
|
[DisplayName("Data from READ SECTORS LONG RETRY command")]
|
|
|
|
|
public byte[] ReadLongRetryData { get; set; }
|
|
|
|
|
[DisplayName("Data from READ SECTORS LONG (LBA) command")]
|
|
|
|
|
public byte[] ReadLongLbaData { get; set; }
|
|
|
|
|
[DisplayName("Data from READ SECTORS LONG RETRY (LBA) command")]
|
2018-12-26 01:15:30 +00:00
|
|
|
public byte[] ReadLongRetryLbaData { get; set; }
|
|
|
|
|
#endregion
|
|
|
|
|
|
|
|
|
|
#region CompactDisc data
|
2019-11-24 19:15:29 +00:00
|
|
|
[DisplayName("Data from READ TOC command")]
|
|
|
|
|
public byte[] TocData { get; set; }
|
|
|
|
|
[DisplayName("Data from READ FULL TOC command")]
|
|
|
|
|
public byte[] FullTocData { get; set; }
|
|
|
|
|
[DisplayName("Data from READ ATIP command")]
|
|
|
|
|
public byte[] AtipData { get; set; }
|
|
|
|
|
[DisplayName("Data from READ PMA command")]
|
|
|
|
|
public byte[] PmaData { get; set; }
|
|
|
|
|
[DisplayName("Data from READ CD command")]
|
|
|
|
|
public byte[] ReadCdData { get; set; }
|
|
|
|
|
[DisplayName("Data from READ CD MSF command")]
|
|
|
|
|
public byte[] ReadCdMsfData { get; set; }
|
|
|
|
|
[DisplayName("Data from READ CD (full sector) command")]
|
|
|
|
|
public byte[] ReadCdFullData { get; set; }
|
|
|
|
|
[DisplayName("Data from READ CD MSF (full sector) command")]
|
|
|
|
|
public byte[] ReadCdMsfFullData { get; set; }
|
|
|
|
|
[DisplayName("Data from track 1 pregap")]
|
|
|
|
|
public byte[] Track1PregapData { get; set; }
|
|
|
|
|
[DisplayName("Data from Lead-In")]
|
|
|
|
|
public byte[] LeadInData { get; set; }
|
|
|
|
|
[DisplayName("Data from Lead-Out")]
|
|
|
|
|
public byte[] LeadOutData { get; set; }
|
|
|
|
|
[DisplayName("Data from reading C2 pointers")]
|
|
|
|
|
public byte[] C2PointersData { get; set; }
|
|
|
|
|
[DisplayName("Data from reading with PQ subchannels")]
|
|
|
|
|
public byte[] PQSubchannelData { get; set; }
|
|
|
|
|
[DisplayName("Data from reading with RW subchannels")]
|
|
|
|
|
public byte[] RWSubchannelData { get; set; }
|
|
|
|
|
[DisplayName("Data from reading with corrected subchannels")]
|
|
|
|
|
public byte[] CorrectedSubchannelData { get; set; }
|
|
|
|
|
[DisplayName("Data from reading with PQ subchannels and C2 pointers")]
|
|
|
|
|
public byte[] PQSubchannelWithC2Data { get; set; }
|
|
|
|
|
[DisplayName("Data from reading with RW subchannels and C2 pointers")]
|
|
|
|
|
public byte[] RWSubchannelWithC2Data { get; set; }
|
|
|
|
|
[DisplayName("Data from reading with corrected subchannels and C2 pointers")]
|
2018-12-26 01:15:30 +00:00
|
|
|
public byte[] CorrectedSubchannelWithC2Data { get; set; }
|
|
|
|
|
#endregion
|
|
|
|
|
|
|
|
|
|
#region DVD data
|
2019-11-24 19:15:29 +00:00
|
|
|
[DisplayName("Data from PFI")]
|
|
|
|
|
public byte[] PfiData { get; set; }
|
|
|
|
|
[DisplayName("Data from DMI")]
|
|
|
|
|
public byte[] DmiData { get; set; }
|
|
|
|
|
[DisplayName("Data from DVD's Copyright Management Information")]
|
|
|
|
|
public byte[] CmiData { get; set; }
|
|
|
|
|
[DisplayName("Data from DVD's BCA")]
|
|
|
|
|
public byte[] DvdBcaData { get; set; }
|
|
|
|
|
[DisplayName("Data from DVD's AACS")]
|
|
|
|
|
public byte[] DvdAacsData { get; set; }
|
|
|
|
|
[DisplayName("Data from DVD's DDS")]
|
|
|
|
|
public byte[] DvdDdsData { get; set; }
|
|
|
|
|
[DisplayName("Data from DVD's Spare Area Information")]
|
|
|
|
|
public byte[] DvdSaiData { get; set; }
|
|
|
|
|
[DisplayName("Data from DVD's pre-recorded information")]
|
|
|
|
|
public byte[] PriData { get; set; }
|
|
|
|
|
[DisplayName("Data from embossed PFI")]
|
2018-12-26 01:15:30 +00:00
|
|
|
public byte[] EmbossedPfiData { get; set; }
|
2019-11-24 19:15:29 +00:00
|
|
|
[DisplayName("Data from ADIP")]
|
|
|
|
|
public byte[] AdipData { get; set; }
|
|
|
|
|
[DisplayName("Data from DCBs")]
|
|
|
|
|
public byte[] DcbData { get; set; }
|
|
|
|
|
[DisplayName("Data from HD-DVD's Copyright Management Information")]
|
|
|
|
|
public byte[] HdCmiData { get; set; }
|
|
|
|
|
[DisplayName("Data from DVD's layer information")]
|
|
|
|
|
public byte[] DvdLayerData { get; set; }
|
2018-12-26 01:15:30 +00:00
|
|
|
#endregion
|
|
|
|
|
|
|
|
|
|
#region Blu-ray data
|
2019-11-24 19:15:29 +00:00
|
|
|
[DisplayName("Data from Blu-ray's BCA")]
|
2018-12-26 01:15:30 +00:00
|
|
|
public byte[] BluBcaData { get; set; }
|
2019-11-24 19:15:29 +00:00
|
|
|
[DisplayName("Data from Blu-ray's DDS")]
|
2018-12-26 01:15:30 +00:00
|
|
|
public byte[] BluDdsData { get; set; }
|
2019-11-24 19:15:29 +00:00
|
|
|
[DisplayName("Data from Blu-ray's Spare Area Information")]
|
2018-12-26 01:15:30 +00:00
|
|
|
public byte[] BluSaiData { get; set; }
|
2019-11-24 19:15:29 +00:00
|
|
|
[DisplayName("Data from Blu-ray's Disc Information")]
|
|
|
|
|
public byte[] BluDiData { get; set; }
|
|
|
|
|
[DisplayName("Data from Blu-ray's PAC")]
|
2018-12-26 01:15:30 +00:00
|
|
|
public byte[] BluPacData { get; set; }
|
|
|
|
|
#endregion
|
|
|
|
|
|
|
|
|
|
#region Vendor data
|
2019-11-24 19:15:29 +00:00
|
|
|
[DisplayName("Data from Plextor's READ CD-DA command")]
|
|
|
|
|
public byte[] PlextorReadCddaData { get; set; }
|
|
|
|
|
[DisplayName("Data from Pioneer's READ CD-DA command")]
|
|
|
|
|
public byte[] PioneerReadCddaData { get; set; }
|
|
|
|
|
[DisplayName("Data from Pioneer's READ CD-DA MSF command")]
|
2018-12-26 01:15:30 +00:00
|
|
|
public byte[] PioneerReadCddaMsfData { get; set; }
|
2019-11-24 19:15:29 +00:00
|
|
|
[DisplayName("Data from NEC's READ CD-DA command")]
|
|
|
|
|
public byte[] NecReadCddaData { get; set; }
|
|
|
|
|
[DisplayName("Data from Plextor's scrambled DVD reading command")]
|
|
|
|
|
public byte[] PlextorReadRawDVDData { get; set; }
|
|
|
|
|
[DisplayName("Data from HL-DT-ST's scrambled DVD reading trick")]
|
|
|
|
|
public byte[] HLDTSTReadRawDVDData { get; set; }
|
2018-12-26 01:15:30 +00:00
|
|
|
#endregion
|
2018-11-25 17:47:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public class Ssc
|
|
|
|
|
{
|
2020-02-29 18:03:24 +00:00
|
|
|
public Ssc() {}
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
public Ssc(sscType ssc)
|
|
|
|
|
{
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ssc.BlockSizeGranularitySpecified)
|
|
|
|
|
BlockSizeGranularity = ssc.BlockSizeGranularity;
|
|
|
|
|
|
|
|
|
|
if(ssc.MaxBlockLengthSpecified)
|
|
|
|
|
MaxBlockLength = ssc.MaxBlockLength;
|
|
|
|
|
|
|
|
|
|
if(ssc.MinBlockLengthSpecified)
|
|
|
|
|
MinBlockLength = ssc.MinBlockLength;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ssc.SupportedDensities != null)
|
|
|
|
|
SupportedDensities = new List<SupportedDensity>(ssc.SupportedDensities);
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
if(ssc.SupportedMediaTypes != null)
|
|
|
|
|
{
|
|
|
|
|
SupportedMediaTypes = new List<SscSupportedMedia>();
|
2019-11-03 01:41:48 +00:00
|
|
|
|
2018-12-20 23:52:16 +00:00
|
|
|
foreach(SupportedMedia mediaType in ssc.SupportedMediaTypes)
|
|
|
|
|
SupportedMediaTypes.Add(new SscSupportedMedia(mediaType));
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ssc.TestedMedia == null)
|
|
|
|
|
return;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
TestedMedia = new List<TestedSequentialMedia>();
|
2019-11-03 01:41:48 +00:00
|
|
|
|
2018-12-20 23:52:16 +00:00
|
|
|
foreach(SequentialMedia testedMedia in ssc.TestedMedia)
|
|
|
|
|
TestedMedia.Add(new TestedSequentialMedia(testedMedia));
|
|
|
|
|
}
|
|
|
|
|
|
2018-11-26 23:16:54 +00:00
|
|
|
[JsonIgnore]
|
2019-11-24 19:15:29 +00:00
|
|
|
public int Id { get; set; }
|
|
|
|
|
[DisplayName("Block size granularity")]
|
2018-11-25 17:47:14 +00:00
|
|
|
public byte? BlockSizeGranularity { get; set; }
|
2019-11-24 19:15:29 +00:00
|
|
|
[DisplayName("Maximum block length")]
|
|
|
|
|
public uint? MaxBlockLength { get; set; }
|
|
|
|
|
[DisplayName("Minimum block length")]
|
|
|
|
|
public uint? MinBlockLength { get; set; }
|
2018-11-25 17:47:14 +00:00
|
|
|
|
2018-12-22 22:41:58 +00:00
|
|
|
public virtual List<SupportedDensity> SupportedDensities { get; set; }
|
|
|
|
|
public virtual List<SscSupportedMedia> SupportedMediaTypes { get; set; }
|
|
|
|
|
public virtual List<TestedSequentialMedia> TestedMedia { get; set; }
|
2018-11-25 17:47:14 +00:00
|
|
|
}
|
|
|
|
|
|
2018-11-26 23:16:54 +00:00
|
|
|
public class TestedSequentialMedia
|
2018-11-25 17:47:14 +00:00
|
|
|
{
|
2020-02-29 18:03:24 +00:00
|
|
|
public TestedSequentialMedia() {}
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
public TestedSequentialMedia(SequentialMedia media)
|
|
|
|
|
{
|
2019-11-03 01:41:48 +00:00
|
|
|
if(media.CanReadMediaSerialSpecified)
|
|
|
|
|
CanReadMediaSerial = media.CanReadMediaSerial;
|
|
|
|
|
|
|
|
|
|
if(media.DensitySpecified)
|
|
|
|
|
Density = media.Density;
|
|
|
|
|
|
2018-12-20 23:52:16 +00:00
|
|
|
Manufacturer = media.Manufacturer;
|
|
|
|
|
MediaIsRecognized = media.MediaIsRecognized;
|
2019-11-03 01:41:48 +00:00
|
|
|
|
|
|
|
|
if(media.MediumTypeSpecified)
|
|
|
|
|
MediumType = media.MediumType;
|
|
|
|
|
|
2018-12-20 23:52:16 +00:00
|
|
|
MediumTypeName = media.MediumTypeName;
|
|
|
|
|
Model = media.Model;
|
2019-11-03 01:41:48 +00:00
|
|
|
|
2018-12-20 23:52:16 +00:00
|
|
|
if(media.SupportedDensities != null)
|
|
|
|
|
SupportedDensities = new List<SupportedDensity>(media.SupportedDensities);
|
|
|
|
|
|
|
|
|
|
if(media.SupportedMediaTypes != null)
|
|
|
|
|
{
|
|
|
|
|
SupportedMediaTypes = new List<SscSupportedMedia>();
|
2019-11-03 01:41:48 +00:00
|
|
|
|
2018-12-20 23:52:16 +00:00
|
|
|
foreach(SupportedMedia supportedMedia in media.SupportedMediaTypes)
|
|
|
|
|
SupportedMediaTypes.Add(new SscSupportedMedia(supportedMedia));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ModeSense6Data = media.ModeSense6Data;
|
|
|
|
|
ModeSense10Data = media.ModeSense10Data;
|
|
|
|
|
}
|
|
|
|
|
|
2018-11-26 23:16:54 +00:00
|
|
|
[JsonIgnore]
|
2019-11-24 19:15:29 +00:00
|
|
|
public int Id { get; set; }
|
|
|
|
|
[DisplayName("Can read media serial?")]
|
|
|
|
|
public bool? CanReadMediaSerial { get; set; }
|
|
|
|
|
[DisplayName("Density code")]
|
|
|
|
|
public byte? Density { get; set; }
|
|
|
|
|
public string Manufacturer { get; set; }
|
|
|
|
|
[DisplayName("Media recognized by drive?")]
|
|
|
|
|
public bool MediaIsRecognized { get; set; }
|
|
|
|
|
[DisplayName("Medium type code")]
|
|
|
|
|
public byte? MediumType { get; set; }
|
|
|
|
|
[DisplayName("Medium type")]
|
|
|
|
|
public string MediumTypeName { get; set; }
|
2018-12-23 18:49:07 +00:00
|
|
|
public string Model { get; set; }
|
2018-12-22 22:41:58 +00:00
|
|
|
public virtual List<SupportedDensity> SupportedDensities { get; set; }
|
|
|
|
|
public virtual List<SscSupportedMedia> SupportedMediaTypes { get; set; }
|
2018-11-25 17:47:14 +00:00
|
|
|
|
|
|
|
|
public byte[] ModeSense6Data { get; set; }
|
|
|
|
|
public byte[] ModeSense10Data { get; set; }
|
2019-11-17 20:46:37 +00:00
|
|
|
|
|
|
|
|
[JsonIgnore]
|
|
|
|
|
public int? SscId { get; set; }
|
2018-11-25 17:47:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public class Pcmcia
|
|
|
|
|
{
|
2018-11-26 23:16:54 +00:00
|
|
|
public string[] AdditionalInformation;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
2020-02-29 18:03:24 +00:00
|
|
|
public Pcmcia() {}
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
public Pcmcia(pcmciaType pcmcia)
|
|
|
|
|
{
|
|
|
|
|
AdditionalInformation = pcmcia.AdditionalInformation;
|
|
|
|
|
CIS = pcmcia.CIS;
|
|
|
|
|
Compliance = pcmcia.Compliance;
|
2019-11-03 01:41:48 +00:00
|
|
|
|
|
|
|
|
if(pcmcia.ManufacturerCodeSpecified)
|
|
|
|
|
ManufacturerCode = pcmcia.ManufacturerCode;
|
|
|
|
|
|
|
|
|
|
if(pcmcia.CardCodeSpecified)
|
|
|
|
|
CardCode = pcmcia.CardCode;
|
|
|
|
|
|
2018-12-20 23:52:16 +00:00
|
|
|
Manufacturer = pcmcia.Manufacturer;
|
|
|
|
|
ProductName = pcmcia.ProductName;
|
|
|
|
|
}
|
|
|
|
|
|
2018-11-26 23:16:54 +00:00
|
|
|
[JsonIgnore]
|
2019-11-24 19:15:29 +00:00
|
|
|
public int Id { get; set; }
|
|
|
|
|
public byte[] CIS { get; set; }
|
|
|
|
|
public string Compliance { get; set; }
|
|
|
|
|
[DisplayName("Manufacturer code")]
|
2018-11-26 23:16:54 +00:00
|
|
|
public ushort? ManufacturerCode { get; set; }
|
2019-11-24 19:15:29 +00:00
|
|
|
[DisplayName("Card code")]
|
|
|
|
|
public ushort? CardCode { get; set; }
|
|
|
|
|
public string Manufacturer { get; set; }
|
|
|
|
|
[DisplayName("Product name")]
|
|
|
|
|
public string ProductName { get; set; }
|
2018-11-25 17:47:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public class MmcSd
|
|
|
|
|
{
|
2020-02-29 18:03:24 +00:00
|
|
|
public MmcSd() {}
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
public MmcSd(mmcsdType mmcSd)
|
|
|
|
|
{
|
|
|
|
|
CID = mmcSd.CID;
|
|
|
|
|
CSD = mmcSd.CSD;
|
|
|
|
|
OCR = mmcSd.OCR;
|
|
|
|
|
SCR = mmcSd.SCR;
|
|
|
|
|
ExtendedCSD = mmcSd.ExtendedCSD;
|
|
|
|
|
}
|
|
|
|
|
|
2018-11-26 23:16:54 +00:00
|
|
|
[JsonIgnore]
|
|
|
|
|
public int Id { get; set; }
|
2018-11-25 17:47:14 +00:00
|
|
|
public byte[] CID { get; set; }
|
|
|
|
|
public byte[] CSD { get; set; }
|
|
|
|
|
public byte[] OCR { get; set; }
|
|
|
|
|
public byte[] SCR { get; set; }
|
|
|
|
|
public byte[] ExtendedCSD { get; set; }
|
|
|
|
|
}
|
2018-11-26 23:16:54 +00:00
|
|
|
|
|
|
|
|
public class SscSupportedMedia
|
|
|
|
|
{
|
2020-02-29 18:03:24 +00:00
|
|
|
public SscSupportedMedia() {}
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
public SscSupportedMedia(SupportedMedia media)
|
|
|
|
|
{
|
|
|
|
|
MediumType = media.MediumType;
|
|
|
|
|
Width = media.Width;
|
|
|
|
|
Length = media.Length;
|
|
|
|
|
Organization = media.Organization;
|
|
|
|
|
Name = media.Name;
|
|
|
|
|
Description = media.Description;
|
2019-11-03 01:41:48 +00:00
|
|
|
|
|
|
|
|
if(media.DensityCodes == null)
|
|
|
|
|
return;
|
2018-12-20 23:52:16 +00:00
|
|
|
|
|
|
|
|
DensityCodes = new List<DensityCode>();
|
2019-11-03 01:41:48 +00:00
|
|
|
|
|
|
|
|
foreach(int densityCode in media.DensityCodes)
|
|
|
|
|
DensityCodes.Add(new DensityCode
|
|
|
|
|
{
|
|
|
|
|
Code = densityCode
|
|
|
|
|
});
|
2018-12-20 23:52:16 +00:00
|
|
|
}
|
|
|
|
|
|
2018-11-26 23:16:54 +00:00
|
|
|
[JsonIgnore]
|
2018-12-23 18:49:07 +00:00
|
|
|
public int Id { get; set; }
|
|
|
|
|
public byte MediumType { get; set; }
|
2018-12-22 22:41:58 +00:00
|
|
|
public virtual List<DensityCode> DensityCodes { get; set; }
|
2018-12-23 18:49:07 +00:00
|
|
|
public ushort Width { get; set; }
|
|
|
|
|
public ushort Length { get; set; }
|
|
|
|
|
public string Organization { get; set; }
|
|
|
|
|
public string Name { get; set; }
|
|
|
|
|
public string Description { get; set; }
|
2018-11-26 23:16:54 +00:00
|
|
|
}
|
|
|
|
|
|
2019-05-26 00:44:51 +01:00
|
|
|
public class DensityCode : IEquatable<DensityCode>
|
2018-11-26 23:16:54 +00:00
|
|
|
{
|
2019-11-03 01:41:48 +00:00
|
|
|
[JsonIgnore, Key]
|
2019-05-26 00:44:51 +01:00
|
|
|
public int Id { get; set; }
|
|
|
|
|
|
2018-11-26 23:16:54 +00:00
|
|
|
public int Code { get; set; }
|
2019-05-26 00:44:51 +01:00
|
|
|
|
|
|
|
|
public bool Equals(DensityCode other)
|
|
|
|
|
{
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ReferenceEquals(null, other))
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
if(ReferenceEquals(this, other))
|
|
|
|
|
return true;
|
2019-05-26 00:44:51 +01:00
|
|
|
|
|
|
|
|
return Code == other.Code;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public override bool Equals(object obj)
|
|
|
|
|
{
|
2019-11-03 01:41:48 +00:00
|
|
|
if(ReferenceEquals(null, obj))
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
if(ReferenceEquals(this, obj))
|
|
|
|
|
return true;
|
2019-05-26 00:44:51 +01:00
|
|
|
|
|
|
|
|
return obj.GetType() == GetType() && Equals((DensityCode)obj);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public override int GetHashCode() => Code;
|
2018-11-26 23:16:54 +00:00
|
|
|
}
|
2020-07-10 18:18:10 +01:00
|
|
|
|
|
|
|
|
public class GdRomSwapDiscCapabilities
|
|
|
|
|
{
|
|
|
|
|
[JsonIgnore, Key]
|
|
|
|
|
public int Id { get; set; }
|
|
|
|
|
|
2020-07-10 21:02:05 +01:00
|
|
|
public bool RecognizedSwapDisc { get; set; }
|
|
|
|
|
public bool TestCrashed { get; set; }
|
|
|
|
|
public byte SwapDiscLeadOutPMIN { get; set; }
|
|
|
|
|
public byte SwapDiscLeadOutPSEC { get; set; }
|
|
|
|
|
public byte SwapDiscLeadOutPFRAM { get; set; }
|
|
|
|
|
public int SwapDiscLeadOutStart { get; set; }
|
|
|
|
|
public bool Lba0Readable { get; set; }
|
|
|
|
|
public byte[] Lba0Data { get; set; }
|
|
|
|
|
public byte[] Lba0Sense { get; set; }
|
|
|
|
|
public string Lba0DecodedSense { get; set; }
|
|
|
|
|
public bool Lba0ScrambledReadable { get; set; }
|
|
|
|
|
public byte[] Lba0ScrambledData { get; set; }
|
|
|
|
|
public byte[] Lba0ScrambledSense { get; set; }
|
|
|
|
|
public string Lba0ScrambledDecodedSense { get; set; }
|
|
|
|
|
public bool Lba44990Readable { get; set; }
|
|
|
|
|
public byte[] Lba44990Data { get; set; }
|
|
|
|
|
public byte[] Lba44990Sense { get; set; }
|
|
|
|
|
public string Lba44990DecodedSense { get; set; }
|
|
|
|
|
public int Lba44990ReadableCluster { get; set; }
|
|
|
|
|
public bool Lba45000Readable { get; set; }
|
|
|
|
|
public byte[] Lba45000Data { get; set; }
|
|
|
|
|
public byte[] Lba45000Sense { get; set; }
|
|
|
|
|
public string Lba45000DecodedSense { get; set; }
|
|
|
|
|
public int Lba45000ReadableCluster { get; set; }
|
|
|
|
|
public bool Lba50000Readable { get; set; }
|
|
|
|
|
public byte[] Lba50000Data { get; set; }
|
|
|
|
|
public byte[] Lba50000Sense { get; set; }
|
|
|
|
|
public string Lba50000DecodedSense { get; set; }
|
|
|
|
|
public int Lba50000ReadableCluster { get; set; }
|
|
|
|
|
public bool Lba100000Readable { get; set; }
|
|
|
|
|
public byte[] Lba100000Data { get; set; }
|
|
|
|
|
public byte[] Lba100000Sense { get; set; }
|
|
|
|
|
public string Lba100000DecodedSense { get; set; }
|
|
|
|
|
public int Lba100000ReadableCluster { get; set; }
|
|
|
|
|
public bool Lba400000Readable { get; set; }
|
|
|
|
|
public byte[] Lba400000Data { get; set; }
|
|
|
|
|
public byte[] Lba400000Sense { get; set; }
|
|
|
|
|
public string Lba400000DecodedSense { get; set; }
|
|
|
|
|
public int Lba400000ReadableCluster { get; set; }
|
|
|
|
|
public bool Lba450000Readable { get; set; }
|
|
|
|
|
public byte[] Lba450000Data { get; set; }
|
|
|
|
|
public byte[] Lba450000Sense { get; set; }
|
|
|
|
|
public string Lba450000DecodedSense { get; set; }
|
|
|
|
|
public int Lba450000ReadableCluster { get; set; }
|
|
|
|
|
public bool Lba44990PqReadable { get; set; }
|
|
|
|
|
public byte[] Lba44990PqData { get; set; }
|
|
|
|
|
public byte[] Lba44990PqSense { get; set; }
|
|
|
|
|
public string Lba44990PqDecodedSense { get; set; }
|
|
|
|
|
public int Lba44990PqReadableCluster { get; set; }
|
|
|
|
|
public bool Lba45000PqReadable { get; set; }
|
|
|
|
|
public byte[] Lba45000PqData { get; set; }
|
|
|
|
|
public byte[] Lba45000PqSense { get; set; }
|
|
|
|
|
public string Lba45000PqDecodedSense { get; set; }
|
|
|
|
|
public int Lba45000PqReadableCluster { get; set; }
|
|
|
|
|
public bool Lba50000PqReadable { get; set; }
|
|
|
|
|
public byte[] Lba50000PqData { get; set; }
|
|
|
|
|
public byte[] Lba50000PqSense { get; set; }
|
|
|
|
|
public string Lba50000PqDecodedSense { get; set; }
|
|
|
|
|
public int Lba50000PqReadableCluster { get; set; }
|
|
|
|
|
public bool Lba100000PqReadable { get; set; }
|
|
|
|
|
public byte[] Lba100000PqData { get; set; }
|
|
|
|
|
public byte[] Lba100000PqSense { get; set; }
|
|
|
|
|
public string Lba100000PqDecodedSense { get; set; }
|
|
|
|
|
public int Lba100000PqReadableCluster { get; set; }
|
|
|
|
|
public bool Lba400000PqReadable { get; set; }
|
|
|
|
|
public byte[] Lba400000PqData { get; set; }
|
|
|
|
|
public byte[] Lba400000PqSense { get; set; }
|
|
|
|
|
public string Lba400000PqDecodedSense { get; set; }
|
|
|
|
|
public int Lba400000PqReadableCluster { get; set; }
|
|
|
|
|
public bool Lba450000PqReadable { get; set; }
|
|
|
|
|
public byte[] Lba450000PqData { get; set; }
|
|
|
|
|
public byte[] Lba450000PqSense { get; set; }
|
|
|
|
|
public string Lba450000PqDecodedSense { get; set; }
|
|
|
|
|
public int Lba450000PqReadableCluster { get; set; }
|
|
|
|
|
public bool Lba44990RwReadable { get; set; }
|
|
|
|
|
public byte[] Lba44990RwData { get; set; }
|
|
|
|
|
public byte[] Lba44990RwSense { get; set; }
|
|
|
|
|
public string Lba44990RwDecodedSense { get; set; }
|
|
|
|
|
public int Lba44990RwReadableCluster { get; set; }
|
|
|
|
|
public bool Lba45000RwReadable { get; set; }
|
|
|
|
|
public byte[] Lba45000RwData { get; set; }
|
|
|
|
|
public byte[] Lba45000RwSense { get; set; }
|
|
|
|
|
public string Lba45000RwDecodedSense { get; set; }
|
|
|
|
|
public int Lba45000RwReadableCluster { get; set; }
|
|
|
|
|
public bool Lba50000RwReadable { get; set; }
|
|
|
|
|
public byte[] Lba50000RwData { get; set; }
|
|
|
|
|
public byte[] Lba50000RwSense { get; set; }
|
|
|
|
|
public string Lba50000RwDecodedSense { get; set; }
|
|
|
|
|
public int Lba50000RwReadableCluster { get; set; }
|
|
|
|
|
public bool Lba100000RwReadable { get; set; }
|
|
|
|
|
public byte[] Lba100000RwData { get; set; }
|
|
|
|
|
public byte[] Lba100000RwSense { get; set; }
|
|
|
|
|
public string Lba100000RwDecodedSense { get; set; }
|
|
|
|
|
public int Lba100000RwReadableCluster { get; set; }
|
|
|
|
|
public bool Lba400000RwReadable { get; set; }
|
|
|
|
|
public byte[] Lba400000RwData { get; set; }
|
|
|
|
|
public byte[] Lba400000RwSense { get; set; }
|
|
|
|
|
public string Lba400000RwDecodedSense { get; set; }
|
|
|
|
|
public int Lba400000RwReadableCluster { get; set; }
|
|
|
|
|
public bool Lba450000RwReadable { get; set; }
|
|
|
|
|
public byte[] Lba450000RwData { get; set; }
|
|
|
|
|
public byte[] Lba450000RwSense { get; set; }
|
|
|
|
|
public string Lba450000RwDecodedSense { get; set; }
|
|
|
|
|
public int Lba450000RwReadableCluster { get; set; }
|
|
|
|
|
public bool Lba44990AudioReadable { get; set; }
|
|
|
|
|
public byte[] Lba44990AudioData { get; set; }
|
|
|
|
|
public byte[] Lba44990AudioSense { get; set; }
|
|
|
|
|
public string Lba44990AudioDecodedSense { get; set; }
|
|
|
|
|
public int Lba44990AudioReadableCluster { get; set; }
|
|
|
|
|
public bool Lba45000AudioReadable { get; set; }
|
|
|
|
|
public byte[] Lba45000AudioData { get; set; }
|
|
|
|
|
public byte[] Lba45000AudioSense { get; set; }
|
|
|
|
|
public string Lba45000AudioDecodedSense { get; set; }
|
|
|
|
|
public int Lba45000AudioReadableCluster { get; set; }
|
|
|
|
|
public bool Lba50000AudioReadable { get; set; }
|
|
|
|
|
public byte[] Lba50000AudioData { get; set; }
|
|
|
|
|
public byte[] Lba50000AudioSense { get; set; }
|
|
|
|
|
public string Lba50000AudioDecodedSense { get; set; }
|
|
|
|
|
public int Lba50000AudioReadableCluster { get; set; }
|
|
|
|
|
public bool Lba100000AudioReadable { get; set; }
|
|
|
|
|
public byte[] Lba100000AudioData { get; set; }
|
|
|
|
|
public byte[] Lba100000AudioSense { get; set; }
|
|
|
|
|
public string Lba100000AudioDecodedSense { get; set; }
|
|
|
|
|
public int Lba100000AudioReadableCluster { get; set; }
|
|
|
|
|
public bool Lba400000AudioReadable { get; set; }
|
|
|
|
|
public byte[] Lba400000AudioAudioData { get; set; }
|
|
|
|
|
public byte[] Lba400000AudioSense { get; set; }
|
|
|
|
|
public string Lba400000AudioDecodedSense { get; set; }
|
|
|
|
|
public int Lba400000AudioReadableCluster { get; set; }
|
|
|
|
|
public bool Lba450000AudioReadable { get; set; }
|
|
|
|
|
public byte[] Lba450000AudioData { get; set; }
|
|
|
|
|
public byte[] Lba450000AudioSense { get; set; }
|
|
|
|
|
public string Lba450000AudioDecodedSense { get; set; }
|
|
|
|
|
public int Lba450000AudioReadableCluster { get; set; }
|
|
|
|
|
public bool Lba44990AudioPqReadable { get; set; }
|
|
|
|
|
public byte[] Lba44990AudioPqData { get; set; }
|
|
|
|
|
public byte[] Lba44990AudioPqSense { get; set; }
|
|
|
|
|
public string Lba44990AudioPqDecodedSense { get; set; }
|
|
|
|
|
public int Lba44990AudioPqReadableCluster { get; set; }
|
|
|
|
|
public bool Lba45000AudioPqReadable { get; set; }
|
|
|
|
|
public byte[] Lba45000AudioPqData { get; set; }
|
|
|
|
|
public byte[] Lba45000AudioPqSense { get; set; }
|
|
|
|
|
public string Lba45000AudioPqDecodedSense { get; set; }
|
|
|
|
|
public int Lba45000AudioPqReadableCluster { get; set; }
|
|
|
|
|
public bool Lba50000AudioPqReadable { get; set; }
|
|
|
|
|
public byte[] Lba50000AudioPqData { get; set; }
|
|
|
|
|
public byte[] Lba50000AudioPqSense { get; set; }
|
|
|
|
|
public string Lba50000AudioPqDecodedSense { get; set; }
|
|
|
|
|
public int Lba50000AudioPqReadableCluster { get; set; }
|
|
|
|
|
public bool Lba100000AudioPqReadable { get; set; }
|
|
|
|
|
public byte[] Lba100000AudioPqData { get; set; }
|
|
|
|
|
public byte[] Lba100000AudioPqSense { get; set; }
|
|
|
|
|
public string Lba100000AudioPqDecodedSense { get; set; }
|
|
|
|
|
public int Lba100000AudioPqReadableCluster { get; set; }
|
|
|
|
|
public bool Lba400000AudioPqReadable { get; set; }
|
|
|
|
|
public byte[] Lba400000AudioPqData { get; set; }
|
|
|
|
|
public byte[] Lba400000AudioPqSense { get; set; }
|
|
|
|
|
public string Lba400000AudioPqDecodedSense { get; set; }
|
|
|
|
|
public int Lba400000AudioPqReadableCluster { get; set; }
|
|
|
|
|
public bool Lba450000AudioPqReadable { get; set; }
|
|
|
|
|
public byte[] Lba450000AudioPqData { get; set; }
|
|
|
|
|
public byte[] Lba450000AudioPqSense { get; set; }
|
|
|
|
|
public string Lba450000AudioPqDecodedSense { get; set; }
|
|
|
|
|
public int Lba450000AudioPqReadableCluster { get; set; }
|
|
|
|
|
public bool Lba44990AudioRwReadable { get; set; }
|
|
|
|
|
public byte[] Lba44990AudioRwData { get; set; }
|
|
|
|
|
public byte[] Lba44990AudioRwSense { get; set; }
|
|
|
|
|
public string Lba44990AudioRwDecodedSense { get; set; }
|
|
|
|
|
public int Lba44990AudioRwReadableCluster { get; set; }
|
|
|
|
|
public bool Lba45000AudioRwReadable { get; set; }
|
|
|
|
|
public byte[] Lba45000AudioRwData { get; set; }
|
|
|
|
|
public byte[] Lba45000AudioRwSense { get; set; }
|
|
|
|
|
public string Lba45000AudioRwDecodedSense { get; set; }
|
|
|
|
|
public int Lba45000AudioRwReadableCluster { get; set; }
|
|
|
|
|
public bool Lba50000AudioRwReadable { get; set; }
|
|
|
|
|
public byte[] Lba50000AudioRwData { get; set; }
|
|
|
|
|
public byte[] Lba50000AudioRwSense { get; set; }
|
|
|
|
|
public string Lba50000AudioRwDecodedSense { get; set; }
|
|
|
|
|
public int Lba50000AudioRwReadableCluster { get; set; }
|
|
|
|
|
public bool Lba100000AudioRwReadable { get; set; }
|
|
|
|
|
public byte[] Lba100000AudioRwData { get; set; }
|
|
|
|
|
public byte[] Lba100000AudioRwSense { get; set; }
|
|
|
|
|
public string Lba100000AudioRwDecodedSense { get; set; }
|
|
|
|
|
public int Lba100000AudioRwReadableCluster { get; set; }
|
|
|
|
|
public bool Lba400000AudioRwReadable { get; set; }
|
|
|
|
|
public byte[] Lba400000AudioRwData { get; set; }
|
|
|
|
|
public byte[] Lba400000AudioRwSense { get; set; }
|
|
|
|
|
public string Lba400000AudioRwDecodedSense { get; set; }
|
|
|
|
|
public int Lba400000AudioRwReadableCluster { get; set; }
|
|
|
|
|
public bool Lba450000AudioRwReadable { get; set; }
|
|
|
|
|
public byte[] Lba450000AudioRwData { get; set; }
|
|
|
|
|
public byte[] Lba450000AudioRwSense { get; set; }
|
|
|
|
|
public string Lba450000AudioRwDecodedSense { get; set; }
|
|
|
|
|
public int Lba450000AudioRwReadableCluster { get; set; }
|
|
|
|
|
public uint MinimumReadableSectorInHdArea { get; set; }
|
|
|
|
|
public uint MaximumReadableSectorInHdArea { get; set; }
|
|
|
|
|
public byte[] MaximumReadablePqInHdArea { get; set; }
|
|
|
|
|
public byte[] MaximumReadableRwInHdArea { get; set; }
|
2020-07-10 18:18:10 +01:00
|
|
|
}
|
2018-11-25 17:47:14 +00:00
|
|
|
}
|
