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

Move optical disc exclusive methods to new interfaces.

Browse Source
This commit is contained in:
Natalia Portillo
2019-01-20 20:11:10 +00:00
parent 287d761dff
commit 640c57b87a
144 changed files with 869 additions and 2708 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
.idea/.idea.DiscImageChef/.idea/contentModel.xml generated
View File

@@ -120,11 +120,14 @@
<e p="IFilter.cs" t="Include" />
<e p="IFloppyImage.cs" t="Include" />
<e p="IMediaImage.cs" t="Include" />
<e p="IOpticalMediaImage.cs" t="Include" />
<e p="IPartition.cs" t="Include" />
<e p="IPartitionableMediaImage.cs" t="Include" />
<e p="IPluginRegister.cs" t="Include" />
<e p="IReadOnlyFilesystem.cs" t="Include" />
<e p="IWritableFloppyImage.cs" t="Include" />
<e p="IWritableImage.cs" t="Include" />
<e p="IWritableOpticalImage.cs" t="Include" />
</e>
<e p="Interop" t="Include">
<e p="DetectOS.cs" t="Include" />
@@ -1026,7 +1029,6 @@
<e p="Read.cs" t="Include" />
<e p="Structs.cs" t="Include" />
<e p="SuperCardPro.cs" t="Include" />
<e p="Unsupported.cs" t="Include" />
</e>
<e p="T98" t="Include">
<e p="Identify.cs" t="Include" />

3
DiscImageChef.CommonTypes/DiscImageChef.CommonTypes.csproj
View File

@@ -69,11 +69,14 @@
<Compile Include="Interfaces\IFilter.cs" />
<Compile Include="Interfaces\IFloppyImage.cs" />
<Compile Include="Interfaces\IMediaImage.cs" />
<Compile Include="Interfaces\IOpticalMediaImage.cs" />
<Compile Include="Interfaces\IPartition.cs" />
<Compile Include="Interfaces\IPartitionableMediaImage.cs" />
<Compile Include="Interfaces\IPluginRegister.cs" />
<Compile Include="Interfaces\IReadOnlyFilesystem.cs" />
<Compile Include="Interfaces\IWritableFloppyImage.cs" />
<Compile Include="Interfaces\IWritableImage.cs" />
<Compile Include="Interfaces\IWritableOpticalImage.cs" />
<Compile Include="Interop\DetectOS.cs" />
<Compile Include="Interop\PlatformID.cs" />
<Compile Include="Interop\Version.cs" />

107
DiscImageChef.CommonTypes/Interfaces/IMediaImage.cs
View File

@@ -9,7 +9,8 @@
//
// --[ Description ] ----------------------------------------------------------
//
// Defines interface to be implemented by disc image plugins.
// Defines interface to be implemented by block addressable disk image
// plugins.
//
// --[ License ] --------------------------------------------------------------
//
@@ -62,23 +63,6 @@ namespace DiscImageChef.CommonTypes.Interfaces
/// </summary>
/// <value>The image format.</value>
string Format { get; }
/// <summary>
/// Gets an array partitions. Typically only useful for optical disc
/// images where each track and index means a different partition, as
/// reads can be relative to them.
/// </summary>
/// <value>The partitions.</value>
List<Partition> Partitions { get; }
/// <summary>
/// Gets the disc track extents (start, length).
/// </summary>
/// <value>The track extents.</value>
List<Track> Tracks { get; }
/// <summary>
/// Gets the sessions (optical discs only).
/// </summary>
/// <value>The sessions.</value>
List<Session> Sessions { get; }
/// <summary>List of dump hardware used to create the image from real media</summary>
List<DumpHardwareType> DumpHardware { get; }
/// <summary>Gets the CICM XML metadata for the image</summary>
@@ -120,23 +104,6 @@ namespace DiscImageChef.CommonTypes.Interfaces
/// <param name="tag">Tag type.</param>
byte[] ReadSectorTag(ulong sectorAddress, SectorTagType tag);
/// <summary>
/// Reads a sector's user data, relative to track.
/// </summary>
/// <returns>The sector's user data.</returns>
/// <param name="sectorAddress">Sector address (relative LBA).</param>
/// <param name="track">Track.</param>
byte[] ReadSector(ulong sectorAddress, uint track);
/// <summary>
/// Reads a sector's tag, relative to track.
/// </summary>
/// <returns>The sector's tag.</returns>
/// <param name="sectorAddress">Sector address (relative LBA).</param>
/// <param name="track">Track.</param>
/// <param name="tag">Tag type.</param>
byte[] ReadSectorTag(ulong sectorAddress, uint track, SectorTagType tag);
/// <summary>
/// Reads user data from several sectors.
/// </summary>
@@ -154,25 +121,6 @@ namespace DiscImageChef.CommonTypes.Interfaces
/// <param name="tag">Tag type.</param>
byte[] ReadSectorsTag(ulong sectorAddress, uint length, SectorTagType tag);
/// <summary>
/// Reads user data from several sectors, relative to track.
/// </summary>
/// <returns>The sectors user data.</returns>
/// <param name="sectorAddress">Starting sector address (relative LBA).</param>
/// <param name="length">How many sectors to read.</param>
/// <param name="track">Track.</param>
byte[] ReadSectors(ulong sectorAddress, uint length, uint track);
/// <summary>
/// Reads tag from several sectors, relative to track.
/// </summary>
/// <returns>The sectors tag.</returns>
/// <param name="sectorAddress">Starting sector address (relative LBA).</param>
/// <param name="length">How many sectors to read.</param>
/// <param name="track">Track.</param>
/// <param name="tag">Tag type.</param>
byte[] ReadSectorsTag(ulong sectorAddress, uint length, uint track, SectorTagType tag);
/// <summary>
/// Reads a complete sector (user data + all tags).
/// </summary>
@@ -180,14 +128,6 @@ namespace DiscImageChef.CommonTypes.Interfaces
/// <param name="sectorAddress">Sector address (LBA).</param>
byte[] ReadSectorLong(ulong sectorAddress);
/// <summary>
/// Reads a complete sector (user data + all tags), relative to track.
/// </summary>
/// <returns>The complete sector. Format depends on disk type.</returns>
/// <param name="sectorAddress">Sector address (relative LBA).</param>
/// <param name="track">Track.</param>
byte[] ReadSectorLong(ulong sectorAddress, uint track);
/// <summary>
/// Reads several complete sector (user data + all tags).
/// </summary>
@@ -196,29 +136,6 @@ namespace DiscImageChef.CommonTypes.Interfaces
/// <param name="length">How many sectors to read.</param>
byte[] ReadSectorsLong(ulong sectorAddress, uint length);
/// <summary>
/// Reads several complete sector (user data + all tags), relative to track.
/// </summary>
/// <returns>The complete sectors. Format depends on disk type.</returns>
/// <param name="sectorAddress">Starting sector address (relative LBA).</param>
/// <param name="length">How many sectors to read.</param>
/// <param name="track">Track.</param>
byte[] ReadSectorsLong(ulong sectorAddress, uint length, uint track);
/// <summary>
/// Gets the disc track extents for a specified session.
/// </summary>
/// <returns>The track exents for that session.</returns>
/// <param name="session">Session.</param>
List<Track> GetSessionTracks(Session session);
/// <summary>
/// Gets the disc track extents for a specified session.
/// </summary>
/// <returns>The track exents for that session.</returns>
/// <param name="session">Session.</param>
List<Track> GetSessionTracks(ushort session);
/// <summary>
/// Verifies a sector.
/// </summary>
@@ -226,14 +143,6 @@ namespace DiscImageChef.CommonTypes.Interfaces
/// <param name="sectorAddress">Sector address (LBA).</param>
bool? VerifySector(ulong sectorAddress);
/// <summary>
/// Verifies a sector, relative to track.
/// </summary>
/// <returns>True if correct, false if incorrect, null if uncheckable.</returns>
/// <param name="sectorAddress">Sector address (relative LBA).</param>
/// <param name="track">Track.</param>
bool? VerifySector(ulong sectorAddress, uint track);
/// <summary>
/// Verifies several sectors.
/// </summary>
@@ -244,18 +153,6 @@ namespace DiscImageChef.CommonTypes.Interfaces
/// <param name="unknownLbas">List of uncheckable sectors</param>
bool? VerifySectors(ulong sectorAddress, uint length, out List<ulong> failingLbas, out List<ulong> unknownLbas);
/// <summary>
/// Verifies several sectors, relative to track.
/// </summary>
/// <returns>True if all are correct, false if any is incorrect, null if any is uncheckable.</returns>
/// <param name="sectorAddress">Starting sector address (relative LBA).</param>
/// <param name="length">How many sectors to read.</param>
/// <param name="track">Track.</param>
/// <param name="failingLbas">List of incorrect sectors</param>
/// <param name="unknownLbas">List of uncheckable sectors</param>
bool? VerifySectors(ulong sectorAddress, uint length, uint track, out List<ulong> failingLbas,
out List<ulong> unknownLbas);
/// <summary>
/// Verifies media image internal checksum.
/// </summary>

140
DiscImageChef.CommonTypes/Interfaces/IOpticalMediaImage.cs Normal file
View File

@@ -0,0 +1,140 @@
// /***************************************************************************
// The Disc Image Chef
// ----------------------------------------------------------------------------
//
// Filename : IOpticalMediaImage.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
// Component : Disc image plugins.
//
// --[ Description ] ----------------------------------------------------------
//
// Defines interface to be implemented by optical disc image plugins.
//
// --[ 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.
//
// ----------------------------------------------------------------------------
// Copyright © 2011-2019 Natalia Portillo
// ****************************************************************************/
using System.Collections.Generic;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Structs;
namespace DiscImageChef.CommonTypes.Interfaces
{
/// <summary>
/// Abstract class to implement disk image reading plugins.
/// </summary>
public interface IOpticalMediaImage : IMediaImage, IPartitionableMediaImage
{
/// <summary>
/// Gets the disc track extents (start, length).
/// </summary>
/// <value>The track extents.</value>
List<Track> Tracks { get; }
/// <summary>
/// Gets the sessions (optical discs only).
/// </summary>
/// <value>The sessions.</value>
List<Session> Sessions { get; }
/// <summary>
/// Reads a sector's user data, relative to track.
/// </summary>
/// <returns>The sector's user data.</returns>
/// <param name="sectorAddress">Sector address (relative LBA).</param>
/// <param name="track">Track.</param>
byte[] ReadSector(ulong sectorAddress, uint track);
/// <summary>
/// Reads a sector's tag, relative to track.
/// </summary>
/// <returns>The sector's tag.</returns>
/// <param name="sectorAddress">Sector address (relative LBA).</param>
/// <param name="track">Track.</param>
/// <param name="tag">Tag type.</param>
byte[] ReadSectorTag(ulong sectorAddress, uint track, SectorTagType tag);
/// <summary>
/// Reads user data from several sectors, relative to track.
/// </summary>
/// <returns>The sectors user data.</returns>
/// <param name="sectorAddress">Starting sector address (relative LBA).</param>
/// <param name="length">How many sectors to read.</param>
/// <param name="track">Track.</param>
byte[] ReadSectors(ulong sectorAddress, uint length, uint track);
/// <summary>
/// Reads tag from several sectors, relative to track.
/// </summary>
/// <returns>The sectors tag.</returns>
/// <param name="sectorAddress">Starting sector address (relative LBA).</param>
/// <param name="length">How many sectors to read.</param>
/// <param name="track">Track.</param>
/// <param name="tag">Tag type.</param>
byte[] ReadSectorsTag(ulong sectorAddress, uint length, uint track, SectorTagType tag);
/// <summary>
/// Reads a complete sector (user data + all tags), relative to track.
/// </summary>
/// <returns>The complete sector. Format depends on disk type.</returns>
/// <param name="sectorAddress">Sector address (relative LBA).</param>
/// <param name="track">Track.</param>
byte[] ReadSectorLong(ulong sectorAddress, uint track);
/// <summary>
/// Reads several complete sector (user data + all tags), relative to track.
/// </summary>
/// <returns>The complete sectors. Format depends on disk type.</returns>
/// <param name="sectorAddress">Starting sector address (relative LBA).</param>
/// <param name="length">How many sectors to read.</param>
/// <param name="track">Track.</param>
byte[] ReadSectorsLong(ulong sectorAddress, uint length, uint track);
/// <summary>
/// Gets the disc track extents for a specified session.
/// </summary>
/// <returns>The track exents for that session.</returns>
/// <param name="session">Session.</param>
List<Track> GetSessionTracks(Session session);
/// <summary>
/// Gets the disc track extents for a specified session.
/// </summary>
/// <returns>The track exents for that session.</returns>
/// <param name="session">Session.</param>
List<Track> GetSessionTracks(ushort session);
/// <summary>
/// Verifies several sectors, relative to track.
/// </summary>
/// <returns>True if all are correct, false if any is incorrect, null if any is uncheckable.</returns>
/// <param name="sectorAddress">Starting sector address (relative LBA).</param>
/// <param name="length">How many sectors to read.</param>
/// <param name="track">Track.</param>
/// <param name="failingLbas">List of incorrect sectors</param>
/// <param name="unknownLbas">List of uncheckable sectors</param>
bool? VerifySectors(ulong sectorAddress, uint length, uint track, out List<ulong> failingLbas,
out List<ulong> unknownLbas);
}
}

54
DiscImageChef.CommonTypes/Interfaces/IPartitionableMediaImage.cs Normal file
View File

@@ -0,0 +1,54 @@
// /***************************************************************************
// The Disc Image Chef
// ----------------------------------------------------------------------------
//
// Filename : IPartitionableMediaImage.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
// Component : Media image plugins.
//
// --[ Description ] ----------------------------------------------------------
//
// Defines interface to be implemented by image plugins that can contain
// partitioned medias, usually optical discs and some newer tapes.
//
// --[ 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.
//
// ----------------------------------------------------------------------------
// Copyright © 2011-2019 Natalia Portillo
// ****************************************************************************/
using System.Collections.Generic;
namespace DiscImageChef.CommonTypes.Interfaces
{
public interface IPartitionableMediaImage
{
/// <summary>
/// Gets an array partitions. Typically only useful for optical disc
/// images where each track and index means a different partition, as
/// reads can be relative to them.
/// </summary>
/// <value>The partitions.</value>
List<Partition> Partitions { get; }
}
}

7
DiscImageChef.CommonTypes/Interfaces/IWritableImage.cs
View File

@@ -131,13 +131,6 @@ namespace DiscImageChef.CommonTypes.Interfaces
/// <returns><c>true</c> if operating completed successfully, <c>false</c> otherwise</returns>
bool WriteSectorsLong(byte[] data, ulong sectorAddress, uint length);
/// <summary>
/// Sets tracks for optical media
/// </summary>
/// <param name="tracks">List of tracks</param>
/// <returns><c>true</c> if operating completed successfully, <c>false</c> otherwise</returns>
bool SetTracks(List<Track> tracks);
/// <summary>
/// Closes and flushes to disk the image
/// </summary>

53
DiscImageChef.CommonTypes/Interfaces/IWritableOpticalImage.cs Normal file
View File

@@ -0,0 +1,53 @@
// /***************************************************************************
// The Disc Image Chef
// ----------------------------------------------------------------------------
//
// Filename : IWritableOpticalImage.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
// Component : Disc image plugins.
//
// --[ Description ] ----------------------------------------------------------
//
// Defines interface to be implemented by writable image plugins.
//
// --[ 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.
//
// ----------------------------------------------------------------------------
// Copyright © 2011-2019 Natalia Portillo
// ****************************************************************************/
using System.Collections.Generic;
using DiscImageChef.CommonTypes.Structs;
namespace DiscImageChef.CommonTypes.Interfaces
{
public interface IWritableOpticalImage : IWritableImage, IOpticalMediaImage
{
/// <summary>
/// Sets tracks for optical media
/// </summary>
/// <param name="tracks">List of tracks</param>
/// <returns><c>true</c> if operating completed successfully, <c>false</c> otherwise</returns>
bool SetTracks(List<Track> tracks);
}
}

2
DiscImageChef.Core/Devices/Dumping/CompactDisc.cs
View File

@@ -85,7 +85,7 @@ namespace DiscImageChef.Core.Devices.Dumping
/// <exception cref="InvalidOperationException">If the resume file is invalid</exception>
/// <exception cref="ArgumentOutOfRangeException">If the track type is unknown (never)</exception>
internal static void Dump(Device dev, string devicePath,
IWritableImage outputPlugin, ushort retryPasses,
IWritableOpticalImage outputPlugin, ushort retryPasses,
bool force, bool dumpRaw,
bool persistent, bool stopOnError,
ref MediaType dskType,

2
DiscImageChef.Core/Devices/Dumping/MMC.cs
View File

@@ -77,7 +77,7 @@ namespace DiscImageChef.Core.Devices.Dumping
/// <param name="formatOptions">Formats to pass to output file plugin</param>
/// <exception cref="NotImplementedException">If trying to dump GOD or WOD, or XGDs without a Kreon drive</exception>
internal static void Dump(Device dev, string devicePath,
IWritableImage outputPlugin, ushort retryPasses,
IWritableOpticalImage outputPlugin, ushort retryPasses,
bool force, bool dumpRaw,
bool persistent, bool stopOnError, ref MediaType dskType,
ref Resume resume, ref DumpLog dumpLog,

20
DiscImageChef.Core/Devices/Dumping/PlayStationPortable.cs
View File

@@ -208,16 +208,20 @@ namespace DiscImageChef.Core.Devices.Dumping
return;
}
DumpUmd(dev, devicePath, outputPlugin, retryPasses, force, persistent, stopOnError,
ref resume, ref dumpLog,
encoding, outputPrefix, outputPath, formatOptions, preSidecar, skip, nometadata, notrim);
if(outputPlugin is IWritableOpticalImage opticalPlugin)
DumpUmd(dev, devicePath, opticalPlugin, retryPasses, force, persistent, stopOnError,
ref resume,
ref dumpLog, encoding, outputPrefix, outputPath, formatOptions, preSidecar, skip,
nometadata,
notrim);
else DicConsole.ErrorWriteLine("The specified plugin does not support storing optical disc images.");
}
static void DumpUmd(Device dev, string devicePath,
IWritableImage outputPlugin, ushort retryPasses, bool force,
bool persistent, bool stopOnError,
ref Resume resume, ref DumpLog dumpLog,
Encoding encoding, string outputPrefix,
static void DumpUmd(Device dev, string devicePath,
IWritableOpticalImage outputPlugin, ushort retryPasses,
bool force, bool persistent,
bool stopOnError, ref Resume resume, ref DumpLog dumpLog,
Encoding encoding, string outputPrefix,
string outputPath,
Dictionary<string, string> formatOptions, CICMMetadataType preSidecar,
uint skip,

33
DiscImageChef.Core/Devices/Dumping/SBC.cs
View File

@@ -283,19 +283,28 @@ namespace DiscImageChef.Core.Devices.Dumping
double imageWriteDuration = 0;
if(opticalDisc)
outputPlugin.SetTracks(new List<Track>
{
new Track
{
if(outputPlugin is IWritableOpticalImage opticalPlugin)
opticalPlugin.SetTracks(new List<Track>
{
TrackBytesPerSector = (int)blockSize,
TrackEndSector = blocks - 1,
TrackSequence = 1,
TrackRawBytesPerSector = (int)blockSize,
TrackSubchannelType = TrackSubchannelType.None,
TrackSession = 1,
TrackType = TrackType.Data
}
});
new Track
{
TrackBytesPerSector = (int)blockSize,
TrackEndSector = blocks - 1,
TrackSequence = 1,
TrackRawBytesPerSector = (int)blockSize,
TrackSubchannelType = TrackSubchannelType.None,
TrackSession = 1,
TrackType = TrackType.Data
}
});
else
{
dumpLog.WriteLine("The specified plugin does not support storing optical disc images..");
DicConsole.ErrorWriteLine("The specified plugin does not support storing optical disc images.");
return;
}
}
else if(decMode.HasValue)
{
bool setGeometry = false;

9
DiscImageChef.Core/Devices/Dumping/SCSI.cs
View File

@@ -209,9 +209,12 @@ namespace DiscImageChef.Core.Devices.Dumping
Ssc.Dump(dev, outputPrefix, devicePath, ref resume, ref dumpLog, preSidecar);
return;
case PeripheralDeviceTypes.MultiMediaDevice:
Mmc.Dump(dev, devicePath, outputPlugin, retryPasses, force, dumpRaw, persistent, stopOnError,
ref dskType, ref resume, ref dumpLog, dumpFirstTrackPregap, encoding, outputPrefix,
outputPath, formatOptions, preSidecar, skip, nometadata, notrim);
if(outputPlugin is IWritableOpticalImage opticalPlugin)
Mmc.Dump(dev, devicePath, opticalPlugin, retryPasses, force, dumpRaw, persistent, stopOnError,
ref dskType, ref resume, ref dumpLog, dumpFirstTrackPregap, encoding, outputPrefix,
outputPath, formatOptions, preSidecar, skip, nometadata, notrim);
else
DicConsole.ErrorWriteLine("The specified plugin does not support storing optical disc images.");
return;
default:
Sbc.Dump(dev, devicePath, outputPlugin, retryPasses, force, dumpRaw, persistent, stopOnError, null,

2
DiscImageChef.Core/Devices/Dumping/XGD.cs
View File

@@ -83,7 +83,7 @@ namespace DiscImageChef.Core.Devices.Dumping
/// dump
/// </exception>
internal static void Dump(Device dev, string devicePath,
IWritableImage outputPlugin, ushort retryPasses,
IWritableOpticalImage outputPlugin, ushort retryPasses,
bool force, bool dumpRaw,
bool persistent, bool stopOnError,
Dictionary<MediaTagType, byte[]> mediaTags, ref MediaType dskType,

10
DiscImageChef.Core/Entropy.cs
View File

@@ -64,9 +64,15 @@ namespace DiscImageChef.Core
{
List<EntropyResults> entropyResultses = new List<EntropyResults>();
if(!(inputFormat is IOpticalMediaImage opticalMediaImage))
{
DicConsole.ErrorWriteLine("The selected image does not support tracks.");
return entropyResultses.ToArray();
}
try
{
List<Track> inputTracks = inputFormat.Tracks;
List<Track> inputTracks = opticalMediaImage.Tracks;
InitProgressEvent?.Invoke();
@@ -93,7 +99,7 @@ namespace DiscImageChef.Core
?.Invoke($"Entropying sector {i + 1} of track {currentTrack.TrackSequence}",
(long)(currentTrack.TrackEndSector - (i + 1)),
(long)trackEntropy.Sectors);
byte[] sector = inputFormat.ReadSector(i, currentTrack.TrackSequence);
byte[] sector = opticalMediaImage.ReadSector(i, currentTrack.TrackSequence);
if(duplicatedSectors)
{

71
DiscImageChef.Core/ImageInfo.cs
View File

@@ -550,46 +550,49 @@ namespace DiscImageChef.Core
DicConsole.WriteLine();
}
try
if(imageFormat is IOpticalMediaImage opticalImage)
{
if(imageFormat.Sessions != null && imageFormat.Sessions.Count > 0)
try
{
DicConsole.WriteLine("Image sessions:");
DicConsole.WriteLine("{0,-9}{1,-13}{2,-12}{3,-12}{4,-12}", "Session", "First track", "Last track",
"Start", "End");
DicConsole.WriteLine("=========================================================");
foreach(Session session in imageFormat.Sessions)
DicConsole.WriteLine("{0,-9}{1,-13}{2,-12}{3,-12}{4,-12}", session.SessionSequence,
session.StartTrack, session.EndTrack, session.StartSector,
session.EndSector);
DicConsole.WriteLine();
if(opticalImage.Sessions != null && opticalImage.Sessions.Count > 0)
{
DicConsole.WriteLine("Image sessions:");
DicConsole.WriteLine("{0,-9}{1,-13}{2,-12}{3,-12}{4,-12}", "Session", "First track",
"Last track", "Start", "End");
DicConsole.WriteLine("=========================================================");
foreach(Session session in opticalImage.Sessions)
DicConsole.WriteLine("{0,-9}{1,-13}{2,-12}{3,-12}{4,-12}", session.SessionSequence,
session.StartTrack, session.EndTrack, session.StartSector,
session.EndSector);
DicConsole.WriteLine();
}
}
catch
{
// ignored
}
}
catch
{
// ignored
}
try
{
if(imageFormat.Tracks != null && imageFormat.Tracks.Count > 0)
try
{
DicConsole.WriteLine("Image tracks:");
DicConsole.WriteLine("{0,-7}{1,-17}{2,-6}{3,-8}{4,-12}{5,-8}{6,-12}{7,-12}", "Track", "Type", "Bps",
"Raw bps", "Subchannel", "Pregap", "Start", "End");
DicConsole
.WriteLine("=================================================================================");
foreach(Track track in imageFormat.Tracks)
DicConsole.WriteLine("{0,-7}{1,-17}{2,-6}{3,-8}{4,-12}{5,-8}{6,-12}{7,-12}",
track.TrackSequence, track.TrackType, track.TrackBytesPerSector,
track.TrackRawBytesPerSector, track.TrackSubchannelType, track.TrackPregap,
track.TrackStartSector, track.TrackEndSector);
DicConsole.WriteLine();
if(opticalImage.Tracks != null && opticalImage.Tracks.Count > 0)
{
DicConsole.WriteLine("Image tracks:");
DicConsole.WriteLine("{0,-7}{1,-17}{2,-6}{3,-8}{4,-12}{5,-8}{6,-12}{7,-12}", "Track", "Type",
"Bps", "Raw bps", "Subchannel", "Pregap", "Start", "End");
DicConsole
.WriteLine("=================================================================================");
foreach(Track track in opticalImage.Tracks)
DicConsole.WriteLine("{0,-7}{1,-17}{2,-6}{3,-8}{4,-12}{5,-8}{6,-12}{7,-12}",
track.TrackSequence, track.TrackType, track.TrackBytesPerSector,
track.TrackRawBytesPerSector, track.TrackSubchannelType,
track.TrackPregap, track.TrackStartSector, track.TrackEndSector);
DicConsole.WriteLine();
}
}
catch
{
// ignored
}
}
catch
{
// ignored
}
if(imageFormat.DumpHardware == null) return;

12
DiscImageChef.Core/Partitions.cs
View File

@@ -57,8 +57,8 @@ namespace DiscImageChef.Core
List<ulong> checkedLocations = new List<ulong>();
// Getting all partitions from device (e.g. tracks)
if(image.Info.HasPartitions)
foreach(Partition imagePartition in image.Partitions)
if(image is IPartitionableMediaImage partitionableImage)
foreach(Partition imagePartition in partitionableImage.Partitions)
{
foreach(IPartition partitionPlugin in plugins.PartPluginsList.Values)
if(partitionPlugin.GetInformation(image, out List<Partition> partitions, imagePartition.Start))
@@ -131,13 +131,15 @@ namespace DiscImageChef.Core
}
// Be sure that device partitions are not excluded if not mapped by any scheme...
if(image.Info.HasPartitions)
partitionableImage = image as IPartitionableMediaImage;
if(!(partitionableImage is null))
{
List<ulong> startLocations =
childPartitions.Select(detectedPartition => detectedPartition.Start).ToList();
childPartitions.AddRange(image.Partitions.Where(imagePartition =>
!startLocations.Contains(imagePartition.Start)));
childPartitions.AddRange(partitionableImage.Partitions.Where(imagePartition =>
!startLocations.Contains(imagePartition
.Start)));
}
Partition[] childArray = childPartitions

8
DiscImageChef.Core/Sidecar/OpticalDisc.cs
View File

@@ -62,9 +62,11 @@ namespace DiscImageChef.Core
/// <param name="plugins">Image plugins</param>
/// <param name="imgChecksums">List of image checksums</param>
/// <param name="sidecar">Metadata sidecar</param>
static void OpticalDisc(IMediaImage image, Guid filterId, string imagePath,
FileInfo fi, PluginBase plugins,
List<ChecksumType> imgChecksums, ref CICMMetadataType sidecar, Encoding encoding)
static void OpticalDisc(IOpticalMediaImage image, Guid filterId,
string imagePath, FileInfo fi,
PluginBase plugins, List<ChecksumType> imgChecksums,
ref CICMMetadataType sidecar,
Encoding encoding)
{
sidecar.OpticalDisc = new[]
{

12
DiscImageChef.Core/Sidecar/Sidecar.cs
View File

@@ -37,6 +37,7 @@ using System.Text;
using DiscImageChef.CommonTypes;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Interfaces;
using DiscImageChef.Console;
using Schemas;
namespace DiscImageChef.Core
@@ -102,7 +103,16 @@ namespace DiscImageChef.Core
switch(image.Info.XmlMediaType)
{
case XmlMediaType.OpticalDisc:
OpticalDisc(image, filterId, imagePath, fi, plugins, imgChecksums, ref sidecar, encoding);
if(image is IOpticalMediaImage opticalImage)
OpticalDisc(opticalImage, filterId, imagePath, fi, plugins, imgChecksums, ref sidecar,
encoding);
else
{
DicConsole
.ErrorWriteLine("The specified image says it contains an optical media but at the same time says it does not support them.");
DicConsole.ErrorWriteLine("Please open an issue at Github.");
}
break;
case XmlMediaType.BlockMedia:
BlockMedia(image, filterId, imagePath, fi, plugins, imgChecksums, ref sidecar, encoding);

2
DiscImageChef.DiscImages/Alcohol120/Alcohol120.cs
View File

@@ -38,7 +38,7 @@ using DiscImageChef.CommonTypes.Structs;
namespace DiscImageChef.DiscImages
{
public partial class Alcohol120 : IWritableImage
public partial class Alcohol120 : IWritableOpticalImage
{
AlcoholFooter alcFooter;
IFilter alcImage;

9
DiscImageChef.DiscImages/Anex86/Properties.cs
View File

@@ -34,7 +34,6 @@ using System;
using System.Collections.Generic;
using DiscImageChef.CommonTypes;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
using Schemas;
@@ -49,14 +48,6 @@ namespace DiscImageChef.DiscImages
public string Author => "Natalia Portillo";
public string Format => "Anex86 disk image";
public List<Partition> Partitions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> Tracks =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Session> Sessions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<DumpHardwareType> DumpHardware => null;
public CICMMetadataType CicmMetadata => null;

33
DiscImageChef.DiscImages/Anex86/Unsupported.cs
View File

@@ -30,11 +30,9 @@
// Copyright © 2011-2019 Natalia Portillo
// ****************************************************************************/
using System.Collections.Generic;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Interfaces;
using DiscImageChef.CommonTypes.Structs;
namespace DiscImageChef.DiscImages
{
@@ -46,44 +44,13 @@ namespace DiscImageChef.DiscImages
public byte[] ReadSectorTag(ulong sectorAddress, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorTag(ulong sectorAddress, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsTag(ulong sectorAddress, uint length, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectors(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsTag(ulong sectorAddress, uint length, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(Session session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(ushort session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySectors(ulong sectorAddress, uint length, uint track, out List<ulong> failingLbas,
out List<ulong> unknownLbas) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
}
}

6
DiscImageChef.DiscImages/Anex86/Write.cs
View File

@@ -153,12 +153,6 @@ namespace DiscImageChef.DiscImages
return false;
}
public bool SetTracks(List<Track> tracks)
{
ErrorMessage = "Unsupported feature";
return false;
}
public bool Close()
{
if(!IsWriting)

10
DiscImageChef.DiscImages/Apple2MG/Properties.cs
View File

@@ -34,7 +34,6 @@ using System;
using System.Collections.Generic;
using DiscImageChef.CommonTypes;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
using Schemas;
@@ -49,15 +48,6 @@ namespace DiscImageChef.DiscImages
public string Author => "Natalia Portillo";
public string Format => "Apple 2IMG";
public List<Partition> Partitions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> Tracks =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Session> Sessions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<DumpHardwareType> DumpHardware => null;
public CICMMetadataType CicmMetadata => null;

32
DiscImageChef.DiscImages/Apple2MG/Unsupported.cs
View File

@@ -33,7 +33,6 @@
using System.Collections.Generic;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
namespace DiscImageChef.DiscImages
{
@@ -45,44 +44,17 @@ namespace DiscImageChef.DiscImages
public byte[] ReadSectorTag(ulong sectorAddress, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorTag(ulong sectorAddress, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsTag(ulong sectorAddress, uint length, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectors(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsTag(ulong sectorAddress, uint length, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(Session session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(ushort session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySector(ulong sectorAddress) => null;
public bool? VerifySector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySectors(ulong sectorAddress, uint length, out List<ulong> failingLbas,
out List<ulong> unknownLbas)
{
@@ -93,10 +65,6 @@ namespace DiscImageChef.DiscImages
return null;
}
public bool? VerifySectors(ulong sectorAddress, uint length, uint track, out List<ulong> failingLbas,
out List<ulong> unknownLbas) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifyMediaImage() => null;
}
}

6
DiscImageChef.DiscImages/Apple2MG/Write.cs
View File

@@ -153,12 +153,6 @@ namespace DiscImageChef.DiscImages
return false;
}
public bool SetTracks(List<Track> tracks)
{
ErrorMessage = "Unsupported feature";
return false;
}
public bool Close()
{
if(!IsWriting)

12
DiscImageChef.DiscImages/AppleDOS/Properties.cs
View File

@@ -34,7 +34,6 @@ using System;
using System.Collections.Generic;
using DiscImageChef.CommonTypes;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
using Schemas;
@@ -52,15 +51,8 @@ namespace DiscImageChef.DiscImages
? "Apple ][ Interleaved Disk Image (ProDOS order)"
: "Apple ][ Interleaved Disk Image (DOS order)";
public List<Track> Tracks =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Session> Sessions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<DumpHardwareType> DumpHardware => null;
public CICMMetadataType CicmMetadata => null;
public List<Partition> Partitions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<DumpHardwareType> DumpHardware => null;
public CICMMetadataType CicmMetadata => null;
public IEnumerable<MediaTagType> SupportedMediaTags => new MediaTagType[] { };
public IEnumerable<SectorTagType> SupportedSectorTags => new SectorTagType[] { };
public IEnumerable<MediaType> SupportedMediaTypes => new[] {MediaType.Apple33SS};

38
DiscImageChef.DiscImages/AppleDOS/Unsupported.cs
View File

@@ -33,7 +33,6 @@
using System.Collections.Generic;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
namespace DiscImageChef.DiscImages
{
@@ -41,8 +40,6 @@ namespace DiscImageChef.DiscImages
{
public bool? VerifySector(ulong sectorAddress) => null;
public bool? VerifySector(ulong sectorAddress, uint track) => null;
public bool? VerifySectors(ulong sectorAddress, uint length, out List<ulong> failingLbas,
out List<ulong> unknownLbas)
{
@@ -54,37 +51,8 @@ namespace DiscImageChef.DiscImages
return null;
}
public bool? VerifySectors(ulong sectorAddress, uint length, uint track, out List<ulong> failingLbas,
out List<ulong> unknownLbas)
{
failingLbas = new List<ulong>();
unknownLbas = new List<ulong>();
for(ulong i = sectorAddress; i < sectorAddress + length; i++) unknownLbas.Add(i);
return null;
}
public bool? VerifyMediaImage() => null;
public List<Track> GetSessionTracks(Session session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(ushort session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectors(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorTag(ulong sectorAddress, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
@@ -99,11 +67,5 @@ namespace DiscImageChef.DiscImages
public byte[] ReadDiskTag(MediaTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorTag(ulong sectorAddress, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsTag(ulong sectorAddress, uint length, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
}
}

6
DiscImageChef.DiscImages/AppleDOS/Write.cs
View File

@@ -126,12 +126,6 @@ namespace DiscImageChef.DiscImages
return false;
}
public bool SetTracks(List<Track> tracks)
{
ErrorMessage = "Unsupported feature";
return false;
}
public bool Close()
{
if(!IsWriting)

19
DiscImageChef.DiscImages/AppleNIB/Properties.cs
View File

@@ -32,8 +32,6 @@
using System;
using System.Collections.Generic;
using DiscImageChef.CommonTypes;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
using Schemas;
@@ -43,19 +41,10 @@ namespace DiscImageChef.DiscImages
{
public ImageInfo Info => imageInfo;
public string Name => "Apple NIB";
public Guid Id => new Guid("AE171AE8-6747-49CC-B861-9D450B7CD42E");
public string Author => "Natalia Portillo";
public string Format => "Apple nibbles";
public List<Partition> Partitions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> Tracks =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Session> Sessions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public string Name => "Apple NIB";
public Guid Id => new Guid("AE171AE8-6747-49CC-B861-9D450B7CD42E");
public string Author => "Natalia Portillo";
public string Format => "Apple nibbles";
public List<DumpHardwareType> DumpHardware => null;
public CICMMetadataType CicmMetadata => null;
}

32
DiscImageChef.DiscImages/AppleNIB/Unsupported.cs
View File

@@ -33,7 +33,6 @@
using System.Collections.Generic;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
namespace DiscImageChef.DiscImages
{
@@ -42,35 +41,8 @@ namespace DiscImageChef.DiscImages
public byte[] ReadDiskTag(MediaTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorTag(ulong sectorAddress, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectors(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsTag(ulong sectorAddress, uint length, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(Session session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(ushort session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySector(ulong sectorAddress) => null;
public bool? VerifySector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySectors(ulong sectorAddress, uint length, out List<ulong> failingLbas,
out List<ulong> unknownLbas)
{
@@ -81,10 +53,6 @@ namespace DiscImageChef.DiscImages
return null;
}
public bool? VerifySectors(ulong sectorAddress, uint length, uint track, out List<ulong> failingLbas,
out List<ulong> unknownLbas) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifyMediaImage() => null;
}
}

9
DiscImageChef.DiscImages/Apridisk/Properties.cs
View File

@@ -34,7 +34,6 @@ using System;
using System.Collections.Generic;
using DiscImageChef.CommonTypes;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
using Schemas;
@@ -49,14 +48,6 @@ namespace DiscImageChef.DiscImages
public string Author => "Natalia Portillo";
public string Format => "ACT Apricot disk image";
public List<Partition> Partitions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> Tracks =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Session> Sessions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<DumpHardwareType> DumpHardware => null;
public CICMMetadataType CicmMetadata => null;

32
DiscImageChef.DiscImages/Apridisk/Unsupported.cs
View File

@@ -33,7 +33,6 @@
using System.Collections.Generic;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
namespace DiscImageChef.DiscImages
{
@@ -45,44 +44,17 @@ namespace DiscImageChef.DiscImages
public byte[] ReadSectorTag(ulong sectorAddress, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorTag(ulong sectorAddress, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsTag(ulong sectorAddress, uint length, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectors(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsTag(ulong sectorAddress, uint length, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(Session session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(ushort session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySector(ulong sectorAddress) => null;
public bool? VerifySector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySectors(ulong sectorAddress, uint length, out List<ulong> failingLbas,
out List<ulong> unknownLbas)
{
@@ -93,10 +65,6 @@ namespace DiscImageChef.DiscImages
return null;
}
public bool? VerifySectors(ulong sectorAddress, uint length, uint track, out List<ulong> failingLbas,
out List<ulong> unknownLbas) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifyMediaImage() => null;
}
}

6
DiscImageChef.DiscImages/Apridisk/Write.cs
View File

@@ -143,12 +143,6 @@ namespace DiscImageChef.DiscImages
return false;
}
public bool SetTracks(List<Track> tracks)
{
ErrorMessage = "Unsupported feature";
return false;
}
// TODO: Try if apridisk software supports finding other chunks, to extend metadata support
public bool Close()
{

17
DiscImageChef.DiscImages/BLU/Properties.cs
View File

@@ -34,7 +34,6 @@ using System;
using System.Collections.Generic;
using DiscImageChef.CommonTypes;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
using Schemas;
@@ -42,17 +41,11 @@ namespace DiscImageChef.DiscImages
{
public partial class Blu
{
public ImageInfo Info => imageInfo;
public string Name => "Basic Lisa Utility";
public Guid Id => new Guid("A153E2F8-4235-432D-9A7F-20807B0BCD74");
public string Author => "Natalia Portillo";
public string Format => "Basic Lisa Utility";
public List<Partition> Partitions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> Tracks =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Session> Sessions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public ImageInfo Info => imageInfo;
public string Name => "Basic Lisa Utility";
public Guid Id => new Guid("A153E2F8-4235-432D-9A7F-20807B0BCD74");
public string Author => "Natalia Portillo";
public string Format => "Basic Lisa Utility";
public List<DumpHardwareType> DumpHardware => null;
public CICMMetadataType CicmMetadata => null;
public IEnumerable<MediaTagType> SupportedMediaTags => new MediaTagType[] { };

39
DiscImageChef.DiscImages/BLU/Unsupported.cs
View File

@@ -30,10 +30,8 @@
// Copyright © 2011-2019 Natalia Portillo
// ****************************************************************************/
using System.Collections.Generic;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
namespace DiscImageChef.DiscImages
{
@@ -42,43 +40,6 @@ namespace DiscImageChef.DiscImages
public byte[] ReadDiskTag(MediaTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(Session session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(ushort session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorTag(ulong sectorAddress, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectors(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsTag(ulong sectorAddress, uint length, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySector(ulong sectorAddress, uint track) => null;
public bool? VerifySectors(ulong sectorAddress, uint length, uint track, out List<ulong> failingLbas,
out List<ulong> unknownLbas)
{
failingLbas = new List<ulong>();
unknownLbas = new List<ulong>();
for(ulong i = sectorAddress; i < sectorAddress + length; i++) unknownLbas.Add(i);
return null;
}
public bool? VerifyMediaImage() => null;
}
}

6
DiscImageChef.DiscImages/BLU/Write.cs
View File

@@ -306,12 +306,6 @@ namespace DiscImageChef.DiscImages
return true;
}
public bool SetTracks(List<Track> tracks)
{
ErrorMessage = "Unsupported feature";
return false;
}
public bool Close()
{
if(!IsWriting)

2
DiscImageChef.DiscImages/BlindWrite4/BlindWrite4.cs
View File

@@ -39,7 +39,7 @@ using DiscImageChef.CommonTypes.Structs;
namespace DiscImageChef.DiscImages
{
// TODO: Too many unknowns, plus a completely unknown footer, to make this writable
public partial class BlindWrite4 : IMediaImage
public partial class BlindWrite4 : IOpticalMediaImage
{
List<Bw4TrackDescriptor> bwTracks;
IFilter dataFilter, subFilter;

2
DiscImageChef.DiscImages/BlindWrite5/BlindWrite5.cs
View File

@@ -39,7 +39,7 @@ using DiscImageChef.CommonTypes.Structs;
namespace DiscImageChef.DiscImages
{
// TODO: Too many unknowns to make this writable
public partial class BlindWrite5 : IMediaImage
public partial class BlindWrite5 : IOpticalMediaImage
{
byte[] atip;
byte[] bca;

2
DiscImageChef.DiscImages/CDRDAO/CDRDAO.cs
View File

@@ -40,7 +40,7 @@ namespace DiscImageChef.DiscImages
{
// TODO: Doesn't support compositing from several files
// TODO: Doesn't support silences that are not in files
public partial class Cdrdao : IWritableImage
public partial class Cdrdao : IWritableOpticalImage
{
IFilter cdrdaoFilter;
StreamWriter descriptorStream;

2
DiscImageChef.DiscImages/CDRWin/CDRWin.cs
View File

@@ -39,7 +39,7 @@ using DiscImageChef.CommonTypes.Structs;
namespace DiscImageChef.DiscImages
{
// TODO: Implement track flags
public partial class CdrWin : IWritableImage
public partial class CdrWin : IWritableOpticalImage
{
IFilter cdrwinFilter;
StreamReader cueStream;

2
DiscImageChef.DiscImages/CHD/CHD.cs
View File

@@ -40,7 +40,7 @@ using DiscImageChef.CommonTypes.Structs;
namespace DiscImageChef.DiscImages
{
// TODO: Implement PCMCIA support
public partial class Chd : IMediaImage
public partial class Chd : IOpticalMediaImage
{
/// <summary>"MComprHD"</summary>
readonly byte[] chdTag = {0x4D, 0x43, 0x6F, 0x6D, 0x70, 0x72, 0x48, 0x44};

18
DiscImageChef.DiscImages/CPCDSK/Properties.cs
View File

@@ -32,8 +32,6 @@
using System;
using System.Collections.Generic;
using DiscImageChef.CommonTypes;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
using Schemas;
@@ -41,17 +39,11 @@ namespace DiscImageChef.DiscImages
{
public partial class Cpcdsk
{
public ImageInfo Info => imageInfo;
public string Name => "CPCEMU Disk-File and Extended CPC Disk-File";
public Guid Id => new Guid("724B16CC-ADB9-492E-BA07-CAEEC1012B16");
public string Format => extended ? "CPCEMU Extended disk image" : "CPCEMU disk image";
public string Author => "Natalia Portillo";
public List<Partition> Partitions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> Tracks =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Session> Sessions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public ImageInfo Info => imageInfo;
public string Name => "CPCEMU Disk-File and Extended CPC Disk-File";
public Guid Id => new Guid("724B16CC-ADB9-492E-BA07-CAEEC1012B16");
public string Format => extended ? "CPCEMU Extended disk image" : "CPCEMU disk image";
public string Author => "Natalia Portillo";
public List<DumpHardwareType> DumpHardware => null;
public CICMMetadataType CicmMetadata => null;
}

32
DiscImageChef.DiscImages/CPCDSK/Unsupported.cs
View File

@@ -33,7 +33,6 @@
using System.Collections.Generic;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
namespace DiscImageChef.DiscImages
{
@@ -42,41 +41,14 @@ namespace DiscImageChef.DiscImages
public byte[] ReadDiskTag(MediaTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorTag(ulong sectorAddress, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectors(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsTag(ulong sectorAddress, uint length, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(Session session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(ushort session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySector(ulong sectorAddress) => null;
public bool? VerifySector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySectors(ulong sectorAddress, uint length, out List<ulong> failingLbas,
out List<ulong> unknownLbas)
{
@@ -87,10 +59,10 @@ namespace DiscImageChef.DiscImages
return null;
}
public bool? VerifyMediaImage() => null;
public bool? VerifySectors(ulong sectorAddress, uint length, uint track, out List<ulong> failingLbas,
out List<ulong> unknownLbas) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifyMediaImage() => null;
}
}

15
DiscImageChef.DiscImages/CisCopy/Properties.cs
View File

@@ -34,7 +34,6 @@ using System;
using System.Collections.Generic;
using DiscImageChef.CommonTypes;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
using Schemas;
@@ -42,16 +41,10 @@ namespace DiscImageChef.DiscImages
{
public partial class CisCopy
{
public string Name => "CisCopy Disk Image (DC-File)";
public Guid Id => new Guid("EDF20CC7-6012-49E2-9E92-663A53E42130");
public string Format => "CisCopy";
public string Author => "Natalia Portillo";
public List<Partition> Partitions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> Tracks =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Session> Sessions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public string Name => "CisCopy Disk Image (DC-File)";
public Guid Id => new Guid("EDF20CC7-6012-49E2-9E92-663A53E42130");
public string Format => "CisCopy";
public string Author => "Natalia Portillo";
public ImageInfo Info => imageInfo;
public List<DumpHardwareType> DumpHardware => null;
public CICMMetadataType CicmMetadata => null;

38
DiscImageChef.DiscImages/CisCopy/Unsupported.cs
View File

@@ -33,7 +33,6 @@
using System.Collections.Generic;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
namespace DiscImageChef.DiscImages
{
@@ -54,34 +53,8 @@ namespace DiscImageChef.DiscImages
public byte[] ReadDiskTag(MediaTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(Session session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(ushort session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorTag(ulong sectorAddress, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectors(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsTag(ulong sectorAddress, uint length, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySector(ulong sectorAddress) => null;
public bool? VerifySector(ulong sectorAddress, uint track) => null;
public bool? VerifySectors(ulong sectorAddress, uint length, out List<ulong> failingLbas,
out List<ulong> unknownLbas)
{
@@ -93,17 +66,6 @@ namespace DiscImageChef.DiscImages
return null;
}
public bool? VerifySectors(ulong sectorAddress, uint length, uint track, out List<ulong> failingLbas,
out List<ulong> unknownLbas)
{
failingLbas = new List<ulong>();
unknownLbas = new List<ulong>();
for(ulong i = sectorAddress; i < sectorAddress + length; i++) unknownLbas.Add(i);
return null;
}
public bool? VerifyMediaImage() => null;
}
}

6
DiscImageChef.DiscImages/CisCopy/Write.cs
View File

@@ -203,12 +203,6 @@ namespace DiscImageChef.DiscImages
return false;
}
public bool SetTracks(List<Track> tracks)
{
ErrorMessage = "Unsupported feature";
return false;
}
public bool Close()
{
if(!IsWriting)

2
DiscImageChef.DiscImages/CloneCD/CloneCD.cs
View File

@@ -39,7 +39,7 @@ using DiscImageChef.CommonTypes.Structs;
namespace DiscImageChef.DiscImages
{
// TODO: CloneCD stores subchannel deinterleaved
public partial class CloneCd : IWritableImage
public partial class CloneCd : IWritableOpticalImage
{
string catalog; // TODO: Use it
IFilter ccdFilter;

18
DiscImageChef.DiscImages/CopyQM/Properties.cs
View File

@@ -32,8 +32,6 @@
using System;
using System.Collections.Generic;
using DiscImageChef.CommonTypes;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
using Schemas;
@@ -41,17 +39,11 @@ namespace DiscImageChef.DiscImages
{
public partial class CopyQm
{
public ImageInfo Info => imageInfo;
public string Name => "Sydex CopyQM";
public Guid Id => new Guid("147E927D-3A92-4E0C-82CD-142F5A4FA76D");
public string Format => "Sydex CopyQM";
public string Author => "Natalia Portillo";
public List<Partition> Partitions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> Tracks =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Session> Sessions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public ImageInfo Info => imageInfo;
public string Name => "Sydex CopyQM";
public Guid Id => new Guid("147E927D-3A92-4E0C-82CD-142F5A4FA76D");
public string Format => "Sydex CopyQM";
public string Author => "Natalia Portillo";
public List<DumpHardwareType> DumpHardware => null;
public CICMMetadataType CicmMetadata => null;
}

38
DiscImageChef.DiscImages/CopyQM/Unsupported.cs
View File

@@ -33,7 +33,6 @@
using System.Collections.Generic;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
namespace DiscImageChef.DiscImages
{
@@ -54,34 +53,8 @@ namespace DiscImageChef.DiscImages
public byte[] ReadDiskTag(MediaTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(Session session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(ushort session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorTag(ulong sectorAddress, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectors(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsTag(ulong sectorAddress, uint length, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySector(ulong sectorAddress) => null;
public bool? VerifySector(ulong sectorAddress, uint track) => null;
public bool? VerifySectors(ulong sectorAddress, uint length, out List<ulong> failingLbas,
out List<ulong> unknownLbas)
{
@@ -92,16 +65,5 @@ namespace DiscImageChef.DiscImages
return null;
}
public bool? VerifySectors(ulong sectorAddress, uint length, uint track, out List<ulong> failingLbas,
out List<ulong> unknownLbas)
{
failingLbas = new List<ulong>();
unknownLbas = new List<ulong>();
for(ulong i = sectorAddress; i < sectorAddress + length; i++) unknownLbas.Add(i);
return null;
}
}
}

18
DiscImageChef.DiscImages/D88/Properties.cs
View File

@@ -32,8 +32,6 @@
using System;
using System.Collections.Generic;
using DiscImageChef.CommonTypes;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
using Schemas;
@@ -41,17 +39,11 @@ namespace DiscImageChef.DiscImages
{
public partial class D88
{
public string Name => "D88 Disk Image";
public Guid Id => new Guid("669EDC77-EC41-4720-A88C-49C38CFFBAA0");
public ImageInfo Info => imageInfo;
public string Format => "D88 disk image";
public string Author => "Natalia Portillo";
public List<Partition> Partitions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> Tracks =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Session> Sessions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public string Name => "D88 Disk Image";
public Guid Id => new Guid("669EDC77-EC41-4720-A88C-49C38CFFBAA0");
public ImageInfo Info => imageInfo;
public string Format => "D88 disk image";
public string Author => "Natalia Portillo";
public List<DumpHardwareType> DumpHardware => null;
public CICMMetadataType CicmMetadata => null;
}

32
DiscImageChef.DiscImages/D88/Unsupported.cs
View File

@@ -33,7 +33,6 @@
using System.Collections.Generic;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
namespace DiscImageChef.DiscImages
{
@@ -45,44 +44,17 @@ namespace DiscImageChef.DiscImages
public byte[] ReadSectorTag(ulong sectorAddress, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorTag(ulong sectorAddress, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsTag(ulong sectorAddress, uint length, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectors(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsTag(ulong sectorAddress, uint length, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(Session session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(ushort session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySector(ulong sectorAddress) => null;
public bool? VerifySector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySectors(ulong sectorAddress, uint length, out List<ulong> failingLbas,
out List<ulong> unknownLbas)
{
@@ -93,10 +65,6 @@ namespace DiscImageChef.DiscImages
return null;
}
public bool? VerifySectors(ulong sectorAddress, uint length, uint track, out List<ulong> failingLbas,
out List<ulong> unknownLbas) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifyMediaImage() => null;
}
}

18
DiscImageChef.DiscImages/DART/Properties.cs
View File

@@ -32,8 +32,6 @@
using System;
using System.Collections.Generic;
using DiscImageChef.CommonTypes;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
using Schemas;
@@ -41,17 +39,11 @@ namespace DiscImageChef.DiscImages
{
public partial class Dart
{
public string Name => "Apple Disk Archival/Retrieval Tool";
public Guid Id => new Guid("B3E06BF8-F98D-4F9B-BBE2-342C373BAF3E");
public ImageInfo Info => imageInfo;
public string Author => "Natalia Portillo";
public string Format => "Apple Disk Archival/Retrieval Tool";
public List<Partition> Partitions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> Tracks =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Session> Sessions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public string Name => "Apple Disk Archival/Retrieval Tool";
public Guid Id => new Guid("B3E06BF8-F98D-4F9B-BBE2-342C373BAF3E");
public ImageInfo Info => imageInfo;
public string Author => "Natalia Portillo";
public string Format => "Apple Disk Archival/Retrieval Tool";
public List<DumpHardwareType> DumpHardware => null;
public CICMMetadataType CicmMetadata => null;
}

32
DiscImageChef.DiscImages/DART/Unsupported.cs
View File

@@ -33,7 +33,6 @@
using System.Collections.Generic;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
namespace DiscImageChef.DiscImages
{
@@ -42,35 +41,8 @@ namespace DiscImageChef.DiscImages
public byte[] ReadDiskTag(MediaTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorTag(ulong sectorAddress, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectors(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsTag(ulong sectorAddress, uint length, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(Session session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(ushort session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySector(ulong sectorAddress) => null;
public bool? VerifySector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySectors(ulong sectorAddress, uint length, out List<ulong> failingLbas,
out List<ulong> unknownLbas)
{
@@ -81,10 +53,6 @@ namespace DiscImageChef.DiscImages
return null;
}
public bool? VerifySectors(ulong sectorAddress, uint length, uint track, out List<ulong> failingLbas,
out List<ulong> unknownLbas) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifyMediaImage() => null;
}
}

32
DiscImageChef.DiscImages/DIM/Unsupported.cs
View File

@@ -33,7 +33,6 @@
using System.Collections.Generic;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
namespace DiscImageChef.DiscImages
{
@@ -45,44 +44,17 @@ namespace DiscImageChef.DiscImages
public byte[] ReadSectorTag(ulong sectorAddress, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorTag(ulong sectorAddress, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsTag(ulong sectorAddress, uint length, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectors(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsTag(ulong sectorAddress, uint length, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(Session session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(ushort session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySector(ulong sectorAddress) => null;
public bool? VerifySector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySectors(ulong sectorAddress, uint length, out List<ulong> failingLbas,
out List<ulong> unknownLbas)
{
@@ -93,10 +65,6 @@ namespace DiscImageChef.DiscImages
return null;
}
public bool? VerifySectors(ulong sectorAddress, uint length, uint track, out List<ulong> failingLbas,
out List<ulong> unknownLbas) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifyMediaImage() => null;
}
}

18
DiscImageChef.DiscImages/DiscFerret/Properties.cs
View File

@@ -32,8 +32,6 @@
using System;
using System.Collections.Generic;
using DiscImageChef.CommonTypes;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
using Schemas;
@@ -41,17 +39,11 @@ namespace DiscImageChef.DiscImages
{
public partial class DiscFerret
{
public string Name => "DiscFerret";
public Guid Id => new Guid("70EA7B9B-5323-42EB-9B40-8DDA37C5EB4D");
public ImageInfo Info => imageInfo;
public string Format => "DiscFerret";
public string Author => "Natalia Portillo";
public List<Partition> Partitions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> Tracks =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Session> Sessions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public string Name => "DiscFerret";
public Guid Id => new Guid("70EA7B9B-5323-42EB-9B40-8DDA37C5EB4D");
public ImageInfo Info => imageInfo;
public string Format => "DiscFerret";
public string Author => "Natalia Portillo";
public List<DumpHardwareType> DumpHardware => null;
public CICMMetadataType CicmMetadata => null;
}

34
DiscImageChef.DiscImages/DiscFerret/Unsupported.cs
View File

@@ -30,46 +30,12 @@
// Copyright © 2011-2019 Natalia Portillo
// ****************************************************************************/
using System.Collections.Generic;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
namespace DiscImageChef.DiscImages
{
public partial class DiscFerret
{
public byte[] ReadSectorLong(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorTag(ulong sectorAddress, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectors(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsTag(ulong sectorAddress, uint length, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(Session session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(ushort session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySectors(ulong sectorAddress, uint length, uint track, out List<ulong> failingLbas,
out List<ulong> unknownLbas) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifyMediaImage() =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
}

1
DiscImageChef.DiscImages/DiscImageChef.DiscImages.csproj
View File

@@ -366,7 +366,6 @@
<Compile Include="SuperCardPro\Read.cs" />
<Compile Include="SuperCardPro\Structs.cs" />
<Compile Include="SuperCardPro\SuperCardPro.cs" />
<Compile Include="SuperCardPro\Unsupported.cs" />
<Compile Include="T98\Identify.cs" />
<Compile Include="T98\Properties.cs" />
<Compile Include="T98\Read.cs" />

2
DiscImageChef.DiscImages/DiscImageChef/DiscImageChef.cs
View File

@@ -81,7 +81,7 @@ using SharpCompress.Compressors.LZMA;
namespace DiscImageChef.DiscImages
{
public partial class DiscImageChef : IWritableImage
public partial class DiscImageChef : IWritableOpticalImage
{
bool alreadyWrittenZero;
/// <summary>Cache of uncompressed blocks.</summary>

25
DiscImageChef.DiscImages/DiskCopy42/Properties.cs
View File

@@ -34,7 +34,6 @@ using System;
using System.Collections.Generic;
using DiscImageChef.CommonTypes;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
using Schemas;
@@ -42,23 +41,13 @@ namespace DiscImageChef.DiscImages
{
public partial class DiskCopy42
{
public ImageInfo Info => imageInfo;
public string Name => "Apple DiskCopy 4.2";
public Guid Id => new Guid("0240B7B1-E959-4CDC-B0BD-386D6E467B88");
public string Author => "Natalia Portillo";
public List<DumpHardwareType> DumpHardware => null;
public CICMMetadataType CicmMetadata => null;
public string Format => "Apple DiskCopy 4.2";
public List<Partition> Partitions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> Tracks =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Session> Sessions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public ImageInfo Info => imageInfo;
public string Name => "Apple DiskCopy 4.2";
public Guid Id => new Guid("0240B7B1-E959-4CDC-B0BD-386D6E467B88");
public string Author => "Natalia Portillo";
public List<DumpHardwareType> DumpHardware => null;
public CICMMetadataType CicmMetadata => null;
public string Format => "Apple DiskCopy 4.2";
public IEnumerable<MediaTagType> SupportedMediaTags => new MediaTagType[] { };
public IEnumerable<SectorTagType> SupportedSectorTags => new[] {SectorTagType.AppleSectorTag};
public IEnumerable<MediaType> SupportedMediaTypes =>

38
DiscImageChef.DiscImages/DiskCopy42/Unsupported.cs
View File

@@ -33,7 +33,6 @@
using System.Collections.Generic;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
namespace DiscImageChef.DiscImages
{
@@ -41,8 +40,6 @@ namespace DiscImageChef.DiscImages
{
public bool? VerifySector(ulong sectorAddress) => null;
public bool? VerifySector(ulong sectorAddress, uint track) => null;
public bool? VerifySectors(ulong sectorAddress, uint length, out List<ulong> failingLbas,
out List<ulong> unknownLbas)
{
@@ -54,42 +51,7 @@ namespace DiscImageChef.DiscImages
return null;
}
public bool? VerifySectors(ulong sectorAddress, uint length, uint track, out List<ulong> failingLbas,
out List<ulong> unknownLbas)
{
failingLbas = new List<ulong>();
unknownLbas = new List<ulong>();
for(ulong i = sectorAddress; i < sectorAddress + length; i++) unknownLbas.Add(i);
return null;
}
public byte[] ReadDiskTag(MediaTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(Session session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(ushort session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorTag(ulong sectorAddress, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectors(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsTag(ulong sectorAddress, uint length, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
}
}

6
DiscImageChef.DiscImages/DiskCopy42/Write.cs
View File

@@ -313,12 +313,6 @@ namespace DiscImageChef.DiscImages
return true;
}
public bool SetTracks(List<Track> tracks)
{
ErrorMessage = "Unsupported feature";
return false;
}
public bool Close()
{
if(!IsWriting)

18
DiscImageChef.DiscImages/DriDiskCopy/Properties.cs
View File

@@ -34,7 +34,6 @@ using System;
using System.Collections.Generic;
using DiscImageChef.CommonTypes;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
using Schemas;
@@ -44,19 +43,10 @@ namespace DiscImageChef.DiscImages
{
public ImageInfo Info => imageInfo;
public string Name => "Digital Research DiskCopy";
public Guid Id => new Guid("9F0BE551-8BAB-4038-8B5A-691F1BF5FFF3");
public string Author => "Natalia Portillo";
public string Format => "Digital Research DiskCopy";
public List<Partition> Partitions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> Tracks =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Session> Sessions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public string Name => "Digital Research DiskCopy";
public Guid Id => new Guid("9F0BE551-8BAB-4038-8B5A-691F1BF5FFF3");
public string Author => "Natalia Portillo";
public string Format => "Digital Research DiskCopy";
public List<DumpHardwareType> DumpHardware => null;
public CICMMetadataType CicmMetadata => null;
public IEnumerable<MediaTagType> SupportedMediaTags => new MediaTagType[] { };

38
DiscImageChef.DiscImages/DriDiskCopy/Unsupported.cs
View File

@@ -33,7 +33,6 @@
using System.Collections.Generic;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
namespace DiscImageChef.DiscImages
{
@@ -54,34 +53,8 @@ namespace DiscImageChef.DiscImages
public byte[] ReadDiskTag(MediaTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(Session session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(ushort session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorTag(ulong sectorAddress, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectors(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsTag(ulong sectorAddress, uint length, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySector(ulong sectorAddress) => null;
public bool? VerifySector(ulong sectorAddress, uint track) => null;
public bool? VerifySectors(ulong sectorAddress, uint length, out List<ulong> failingLbas,
out List<ulong> unknownLbas)
{
@@ -93,17 +66,6 @@ namespace DiscImageChef.DiscImages
return null;
}
public bool? VerifySectors(ulong sectorAddress, uint length, uint track, out List<ulong> failingLbas,
out List<ulong> unknownLbas)
{
failingLbas = new List<ulong>();
unknownLbas = new List<ulong>();
for(ulong i = sectorAddress; i < sectorAddress + length; i++) unknownLbas.Add(i);
return null;
}
public bool? VerifyMediaImage() => null;
}
}

6
DiscImageChef.DiscImages/DriDiskCopy/Write.cs
View File

@@ -176,12 +176,6 @@ namespace DiscImageChef.DiscImages
return false;
}
public bool SetTracks(List<Track> tracks)
{
ErrorMessage = "Unsupported feature";
return false;
}
public bool Close()
{
if(!IsWriting)

2
DiscImageChef.DiscImages/GDI/GDI.cs
View File

@@ -40,7 +40,7 @@ namespace DiscImageChef.DiscImages
{
// TODO: There seems no be no clear definition on how to treat pregaps that are not included in the file, so this is just appending it to start of track
// TODO: This format doesn't support to specify pregaps that are included in the file (like Redump ones)
public partial class Gdi : IMediaImage
public partial class Gdi : IOpticalMediaImage
{
ulong densitySeparationSectors;
GdiDisc discimage;

19
DiscImageChef.DiscImages/HDCopy/Properties.cs
View File

@@ -33,8 +33,6 @@
using System;
using System.Collections.Generic;
using DiscImageChef.CommonTypes;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
using Schemas;
@@ -44,19 +42,10 @@ namespace DiscImageChef.DiscImages
{
public ImageInfo Info => imageInfo;
public string Name => "HD-Copy disk image";
public Guid Id => new Guid("8D57483F-71A5-42EC-9B87-66AEC439C792");
public string Author => "Michael Drüing";
public string Format => "HD-Copy image";
public List<Partition> Partitions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> Tracks =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Session> Sessions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public string Name => "HD-Copy disk image";
public Guid Id => new Guid("8D57483F-71A5-42EC-9B87-66AEC439C792");
public string Author => "Michael Drüing";
public string Format => "HD-Copy image";
public List<DumpHardwareType> DumpHardware => null;
public CICMMetadataType CicmMetadata => null;
}

32
DiscImageChef.DiscImages/HDCopy/Unsupported.cs
View File

@@ -34,7 +34,6 @@
using System.Collections.Generic;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
namespace DiscImageChef.DiscImages
{
@@ -46,44 +45,17 @@ namespace DiscImageChef.DiscImages
public byte[] ReadSectorTag(ulong sectorAddress, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorTag(ulong sectorAddress, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsTag(ulong sectorAddress, uint length, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectors(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsTag(ulong sectorAddress, uint length, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(Session session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(ushort session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySector(ulong sectorAddress) => null;
public bool? VerifySector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySectors(ulong sectorAddress, uint length, out List<ulong> failingLbas,
out List<ulong> unknownLbas)
{
@@ -94,10 +66,6 @@ namespace DiscImageChef.DiscImages
return null;
}
public bool? VerifySectors(ulong sectorAddress, uint length, uint track, out List<ulong> failingLbas,
out List<ulong> unknownLbas) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifyMediaImage() => null;
}
}

22
DiscImageChef.DiscImages/IMD/Properties.cs
View File

@@ -32,8 +32,6 @@
using System;
using System.Collections.Generic;
using DiscImageChef.CommonTypes;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
using Schemas;
@@ -41,21 +39,11 @@ namespace DiscImageChef.DiscImages
{
public partial class Imd
{
public string Name => "Dunfield's IMD";
public Guid Id => new Guid("0D67162E-38A3-407D-9B1A-CF40080A48CB");
public ImageInfo Info => imageInfo;
public string Author => "Natalia Portillo";
public string Format => "IMageDisk";
public List<Partition> Partitions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> Tracks =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Session> Sessions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public string Name => "Dunfield's IMD";
public Guid Id => new Guid("0D67162E-38A3-407D-9B1A-CF40080A48CB");
public ImageInfo Info => imageInfo;
public string Author => "Natalia Portillo";
public string Format => "IMageDisk";
public List<DumpHardwareType> DumpHardware => null;
public CICMMetadataType CicmMetadata => null;
}

38
DiscImageChef.DiscImages/IMD/Unsupported.cs
View File

@@ -33,7 +33,6 @@
using System.Collections.Generic;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
namespace DiscImageChef.DiscImages
{
@@ -54,34 +53,8 @@ namespace DiscImageChef.DiscImages
public byte[] ReadDiskTag(MediaTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(Session session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(ushort session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorTag(ulong sectorAddress, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectors(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsTag(ulong sectorAddress, uint length, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySector(ulong sectorAddress) => null;
public bool? VerifySector(ulong sectorAddress, uint track) => null;
public bool? VerifySectors(ulong sectorAddress, uint length, out List<ulong> failingLbas,
out List<ulong> unknownLbas)
{
@@ -93,17 +66,6 @@ namespace DiscImageChef.DiscImages
return null;
}
public bool? VerifySectors(ulong sectorAddress, uint length, uint track, out List<ulong> failingLbas,
out List<ulong> unknownLbas)
{
failingLbas = new List<ulong>();
unknownLbas = new List<ulong>();
for(ulong i = sectorAddress; i < sectorAddress + length; i++) unknownLbas.Add(i);
return null;
}
public bool? VerifyMediaImage() => null;
}
}

20
DiscImageChef.DiscImages/KryoFlux/Properties.cs
View File

@@ -32,8 +32,6 @@
using System;
using System.Collections.Generic;
using DiscImageChef.CommonTypes;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
using Schemas;
@@ -41,18 +39,12 @@ namespace DiscImageChef.DiscImages
{
public partial class KryoFlux
{
public ImageInfo imageInfo;
public ImageInfo Info => imageInfo;
public string Author => "Natalia Portillo";
public string Name => "KryoFlux STREAM";
public Guid Id => new Guid("4DBC95E4-93EE-4F7A-9492-919887E60EFE");
public string Format => "KryoFlux STREAM";
public List<Partition> Partitions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Session> Sessions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> Tracks =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public ImageInfo imageInfo;
public ImageInfo Info => imageInfo;
public string Author => "Natalia Portillo";
public string Name => "KryoFlux STREAM";
public Guid Id => new Guid("4DBC95E4-93EE-4F7A-9492-919887E60EFE");
public string Format => "KryoFlux STREAM";
public List<DumpHardwareType> DumpHardware => null;
public CICMMetadataType CicmMetadata => null;
}

34
DiscImageChef.DiscImages/KryoFlux/Unsupported.cs
View File

@@ -30,46 +30,12 @@
// Copyright © 2011-2019 Natalia Portillo
// ****************************************************************************/
using System.Collections.Generic;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
namespace DiscImageChef.DiscImages
{
public partial class KryoFlux
{
public byte[] ReadSectorLong(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectors(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsTag(ulong sectorAddress, uint length, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorTag(ulong sectorAddress, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(Session session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(ushort session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySectors(ulong sectorAddress, uint length, uint track, out List<ulong> failingLbas,
out List<ulong> unknownLbas) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifyMediaImage() =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
}

21
DiscImageChef.DiscImages/MaxiDisk/Properties.cs
View File

@@ -34,7 +34,6 @@ using System;
using System.Collections.Generic;
using DiscImageChef.CommonTypes;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
using Schemas;
@@ -42,21 +41,11 @@ namespace DiscImageChef.DiscImages
{
public partial class MaxiDisk
{
public ImageInfo Info => imageInfo;
public string Author => "Natalia Portillo";
public string Name => "MAXI Disk image";
public Guid Id => new Guid("D27D924A-7034-466E-ADE1-B81EF37E469E");
public string Format => "MAXI Disk";
public List<Partition> Partitions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> Tracks =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Session> Sessions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public ImageInfo Info => imageInfo;
public string Author => "Natalia Portillo";
public string Name => "MAXI Disk image";
public Guid Id => new Guid("D27D924A-7034-466E-ADE1-B81EF37E469E");
public string Format => "MAXI Disk";
public List<DumpHardwareType> DumpHardware => null;
public CICMMetadataType CicmMetadata => null;
public IEnumerable<MediaTagType> SupportedMediaTags => new MediaTagType[] { };

43
DiscImageChef.DiscImages/MaxiDisk/Unsupported.cs
View File

@@ -54,34 +54,8 @@ namespace DiscImageChef.DiscImages
public byte[] ReadDiskTag(MediaTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(Session session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(ushort session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorTag(ulong sectorAddress, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectors(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsTag(ulong sectorAddress, uint length, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySector(ulong sectorAddress) => null;
public bool? VerifySector(ulong sectorAddress, uint track) => null;
public bool? VerifySectors(ulong sectorAddress, uint length, out List<ulong> failingLbas,
out List<ulong> unknownLbas)
{
@@ -93,17 +67,12 @@ namespace DiscImageChef.DiscImages
return null;
}
public bool? VerifySectors(ulong sectorAddress, uint length, uint track, out List<ulong> failingLbas,
out List<ulong> unknownLbas)
{
failingLbas = new List<ulong>();
unknownLbas = new List<ulong>();
for(ulong i = sectorAddress; i < sectorAddress + length; i++) unknownLbas.Add(i);
return null;
}
public bool? VerifyMediaImage() => null;
public List<Track> GetSessionTracks(Session session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(ushort session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
}
}

6
DiscImageChef.DiscImages/MaxiDisk/Write.cs
View File

@@ -176,12 +176,6 @@ namespace DiscImageChef.DiscImages
return false;
}
public bool SetTracks(List<Track> tracks)
{
ErrorMessage = "Unsupported feature";
return false;
}
public bool Close()
{
if(!IsWriting)

22
DiscImageChef.DiscImages/NDIF/Properties.cs
View File

@@ -32,8 +32,6 @@
using System;
using System.Collections.Generic;
using DiscImageChef.CommonTypes;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
using Schemas;
@@ -41,21 +39,11 @@ namespace DiscImageChef.DiscImages
{
public partial class Ndif
{
public ImageInfo Info => imageInfo;
public string Name => "Apple New Disk Image Format";
public Guid Id => new Guid("5A7FF7D8-491E-458D-8674-5B5EADBECC24");
public string Format => "Apple New Disk Image Format";
public string Author => "Natalia Portillo";
public List<Partition> Partitions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> Tracks =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Session> Sessions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public ImageInfo Info => imageInfo;
public string Name => "Apple New Disk Image Format";
public Guid Id => new Guid("5A7FF7D8-491E-458D-8674-5B5EADBECC24");
public string Format => "Apple New Disk Image Format";
public string Author => "Natalia Portillo";
public List<DumpHardwareType> DumpHardware => null;
public CICMMetadataType CicmMetadata => null;
}

32
DiscImageChef.DiscImages/NDIF/Unsupported.cs
View File

@@ -33,7 +33,6 @@
using System.Collections.Generic;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
namespace DiscImageChef.DiscImages
{
@@ -48,41 +47,14 @@ namespace DiscImageChef.DiscImages
public byte[] ReadDiskTag(MediaTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorTag(ulong sectorAddress, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectors(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsTag(ulong sectorAddress, uint length, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(Session session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(ushort session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySector(ulong sectorAddress) => null;
public bool? VerifySector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySectors(ulong sectorAddress, uint length, out List<ulong> failingLbas,
out List<ulong> unknownLbas)
{
@@ -93,10 +65,6 @@ namespace DiscImageChef.DiscImages
return null;
}
public bool? VerifySectors(ulong sectorAddress, uint length, uint track, out List<ulong> failingLbas,
out List<ulong> unknownLbas) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifyMediaImage() => null;
}
}

21
DiscImageChef.DiscImages/NHDr0/Properties.cs
View File

@@ -34,7 +34,6 @@ using System;
using System.Collections.Generic;
using DiscImageChef.CommonTypes;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
using Schemas;
@@ -42,21 +41,11 @@ namespace DiscImageChef.DiscImages
{
public partial class Nhdr0
{
public string Name => "T98-Next NHD r0 Disk Image";
public Guid Id => new Guid("6ECACD0A-8F4D-4465-8815-AEA000D370E3");
public ImageInfo Info => imageInfo;
public string Author => "Natalia Portillo";
public string Format => "NHDr0 disk image";
public List<Partition> Partitions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> Tracks =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Session> Sessions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public string Name => "T98-Next NHD r0 Disk Image";
public Guid Id => new Guid("6ECACD0A-8F4D-4465-8815-AEA000D370E3");
public ImageInfo Info => imageInfo;
public string Author => "Natalia Portillo";
public string Format => "NHDr0 disk image";
public List<DumpHardwareType> DumpHardware => null;
public CICMMetadataType CicmMetadata => null;
public IEnumerable<MediaTagType> SupportedMediaTags => new MediaTagType[] { };

32
DiscImageChef.DiscImages/NHDr0/Unsupported.cs
View File

@@ -33,7 +33,6 @@
using System.Collections.Generic;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
namespace DiscImageChef.DiscImages
{
@@ -45,44 +44,17 @@ namespace DiscImageChef.DiscImages
public byte[] ReadSectorTag(ulong sectorAddress, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorTag(ulong sectorAddress, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsTag(ulong sectorAddress, uint length, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectors(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsTag(ulong sectorAddress, uint length, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(Session session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(ushort session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySector(ulong sectorAddress) => null;
public bool? VerifySector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySectors(ulong sectorAddress, uint length, out List<ulong> failingLbas,
out List<ulong> unknownLbas)
{
@@ -93,10 +65,6 @@ namespace DiscImageChef.DiscImages
return null;
}
public bool? VerifySectors(ulong sectorAddress, uint length, uint track, out List<ulong> failingLbas,
out List<ulong> unknownLbas) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifyMediaImage() => null;
}
}

6
DiscImageChef.DiscImages/NHDr0/Write.cs
View File

@@ -150,12 +150,6 @@ namespace DiscImageChef.DiscImages
return false;
}
public bool SetTracks(List<Track> tracks)
{
ErrorMessage = "Unsupported feature";
return false;
}
public bool Close()
{
if(!IsWriting)

2
DiscImageChef.DiscImages/Nero/Nero.cs
View File

@@ -45,7 +45,7 @@ namespace DiscImageChef.DiscImages
{
[SuppressMessage("ReSharper", "NotAccessedField.Local")]
[SuppressMessage("ReSharper", "CollectionNeverQueried.Local")]
public partial class Nero : IMediaImage
public partial class Nero : IOpticalMediaImage
{
bool imageNewFormat;
Stream imageStream;

21
DiscImageChef.DiscImages/Parallels/Properties.cs
View File

@@ -34,7 +34,6 @@ using System;
using System.Collections.Generic;
using DiscImageChef.CommonTypes;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
using Schemas;
@@ -42,21 +41,11 @@ namespace DiscImageChef.DiscImages
{
public partial class Parallels
{
public string Name => "Parallels disk image";
public Guid Id => new Guid("E314DE35-C103-48A3-AD36-990F68523C46");
public ImageInfo Info => imageInfo;
public string Author => "Natalia Portillo";
public string Format => "Parallels";
public List<Partition> Partitions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> Tracks =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Session> Sessions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public string Name => "Parallels disk image";
public Guid Id => new Guid("E314DE35-C103-48A3-AD36-990F68523C46");
public ImageInfo Info => imageInfo;
public string Author => "Natalia Portillo";
public string Format => "Parallels";
public List<DumpHardwareType> DumpHardware => null;
public CICMMetadataType CicmMetadata => null;
public IEnumerable<MediaTagType> SupportedMediaTags => new MediaTagType[] { };

32
DiscImageChef.DiscImages/Parallels/Unsupported.cs
View File

@@ -33,7 +33,6 @@
using System.Collections.Generic;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
namespace DiscImageChef.DiscImages
{
@@ -48,41 +47,14 @@ namespace DiscImageChef.DiscImages
public byte[] ReadDiskTag(MediaTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorTag(ulong sectorAddress, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectors(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsTag(ulong sectorAddress, uint length, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(Session session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(ushort session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySector(ulong sectorAddress) => null;
public bool? VerifySector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySectors(ulong sectorAddress, uint length, out List<ulong> failingLbas,
out List<ulong> unknownLbas)
{
@@ -93,10 +65,6 @@ namespace DiscImageChef.DiscImages
return null;
}
public bool? VerifySectors(ulong sectorAddress, uint length, uint track, out List<ulong> failingLbas,
out List<ulong> unknownLbas) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifyMediaImage() => null;
}
}

6
DiscImageChef.DiscImages/Parallels/Write.cs
View File

@@ -197,12 +197,6 @@ namespace DiscImageChef.DiscImages
return false;
}
public bool SetTracks(List<Track> tracks)
{
ErrorMessage = "Unsupported feature";
return false;
}
public bool Close()
{
if(!IsWriting)

22
DiscImageChef.DiscImages/PartClone/Properties.cs
View File

@@ -32,8 +32,6 @@
using System;
using System.Collections.Generic;
using DiscImageChef.CommonTypes;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
using Schemas;
@@ -41,21 +39,11 @@ namespace DiscImageChef.DiscImages
{
public partial class PartClone
{
public string Name => "PartClone disk image";
public Guid Id => new Guid("AB1D7518-B548-4099-A4E2-C29C53DDE0C3");
public ImageInfo Info => imageInfo;
public string Author => "Natalia Portillo";
public string Format => "PartClone";
public List<Partition> Partitions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> Tracks =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Session> Sessions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public string Name => "PartClone disk image";
public Guid Id => new Guid("AB1D7518-B548-4099-A4E2-C29C53DDE0C3");
public ImageInfo Info => imageInfo;
public string Author => "Natalia Portillo";
public string Format => "PartClone";
public List<DumpHardwareType> DumpHardware => null;
public CICMMetadataType CicmMetadata => null;
}

32
DiscImageChef.DiscImages/PartClone/Unsupported.cs
View File

@@ -33,7 +33,6 @@
using System.Collections.Generic;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
namespace DiscImageChef.DiscImages
{
@@ -48,41 +47,14 @@ namespace DiscImageChef.DiscImages
public byte[] ReadDiskTag(MediaTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorTag(ulong sectorAddress, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectors(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsTag(ulong sectorAddress, uint length, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(Session session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(ushort session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySector(ulong sectorAddress) => null;
public bool? VerifySector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySectors(ulong sectorAddress, uint length, out List<ulong> failingLbas,
out List<ulong> unknownLbas)
{
@@ -93,10 +65,6 @@ namespace DiscImageChef.DiscImages
return null;
}
public bool? VerifySectors(ulong sectorAddress, uint length, uint track, out List<ulong> failingLbas,
out List<ulong> unknownLbas) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
// TODO: All blocks contain a CRC32 that's incompatible with current implementation. Need to check for compatibility.
public bool? VerifyMediaImage() => null;
}

20
DiscImageChef.DiscImages/Partimage/Properties.cs
View File

@@ -32,8 +32,6 @@
using System;
using System.Collections.Generic;
using DiscImageChef.CommonTypes;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
using Schemas;
@@ -43,20 +41,10 @@ namespace DiscImageChef.DiscImages
{
public ImageInfo Info => imageInfo;
public string Name => "Partimage disk image";
public Guid Id => new Guid("AAFDB99D-2B77-49EA-831C-C9BB58C68C95");
public string Author => "Natalia Portillo";
public string Format => "Partimage";
public List<Partition> Partitions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> Tracks =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Session> Sessions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public string Name => "Partimage disk image";
public Guid Id => new Guid("AAFDB99D-2B77-49EA-831C-C9BB58C68C95");
public string Author => "Natalia Portillo";
public string Format => "Partimage";
public List<DumpHardwareType> DumpHardware => null;
public CICMMetadataType CicmMetadata => null;
}

32
DiscImageChef.DiscImages/Partimage/Unsupported.cs
View File

@@ -33,7 +33,6 @@
using System.Collections.Generic;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
namespace DiscImageChef.DiscImages
{
@@ -48,41 +47,14 @@ namespace DiscImageChef.DiscImages
public byte[] ReadDiskTag(MediaTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorTag(ulong sectorAddress, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectors(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsTag(ulong sectorAddress, uint length, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(Session session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(ushort session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySector(ulong sectorAddress) => null;
public bool? VerifySector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySectors(ulong sectorAddress, uint length, out List<ulong> failingLbas,
out List<ulong> unknownLbas)
{
@@ -93,10 +65,6 @@ namespace DiscImageChef.DiscImages
return null;
}
public bool? VerifySectors(ulong sectorAddress, uint length, uint track, out List<ulong> failingLbas,
out List<ulong> unknownLbas) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
// TODO: All blocks contain a CRC32 that's incompatible with current implementation. Need to check for compatibility.
public bool? VerifyMediaImage() => null;
}

18
DiscImageChef.DiscImages/QCOW/Properties.cs
View File

@@ -34,7 +34,6 @@ using System;
using System.Collections.Generic;
using DiscImageChef.CommonTypes;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
using Schemas;
@@ -44,19 +43,10 @@ namespace DiscImageChef.DiscImages
{
public ImageInfo Info => imageInfo;
public string Name => "QEMU Copy-On-Write disk image";
public Guid Id => new Guid("A5C35765-9FE2-469D-BBBF-ACDEBDB7B954");
public string Author => "Natalia Portillo";
public string Format => "QEMU Copy-On-Write";
public List<Partition> Partitions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> Tracks =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Session> Sessions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public string Name => "QEMU Copy-On-Write disk image";
public Guid Id => new Guid("A5C35765-9FE2-469D-BBBF-ACDEBDB7B954");
public string Author => "Natalia Portillo";
public string Format => "QEMU Copy-On-Write";
public List<DumpHardwareType> DumpHardware => null;
public CICMMetadataType CicmMetadata => null;
public IEnumerable<MediaTagType> SupportedMediaTags => new MediaTagType[] { };

32
DiscImageChef.DiscImages/QCOW/Unsupported.cs
View File

@@ -33,7 +33,6 @@
using System.Collections.Generic;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
namespace DiscImageChef.DiscImages
{
@@ -48,41 +47,14 @@ namespace DiscImageChef.DiscImages
public byte[] ReadDiskTag(MediaTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorTag(ulong sectorAddress, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectors(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsTag(ulong sectorAddress, uint length, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(Session session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(ushort session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySector(ulong sectorAddress) => null;
public bool? VerifySector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySectors(ulong sectorAddress, uint length, out List<ulong> failingLbas,
out List<ulong> unknownLbas)
{
@@ -93,10 +65,6 @@ namespace DiscImageChef.DiscImages
return null;
}
public bool? VerifySectors(ulong sectorAddress, uint length, uint track, out List<ulong> failingLbas,
out List<ulong> unknownLbas) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifyMediaImage() => null;
}
}

6
DiscImageChef.DiscImages/QCOW/Write.cs
View File

@@ -246,12 +246,6 @@ namespace DiscImageChef.DiscImages
return false;
}
public bool SetTracks(List<Track> tracks)
{
ErrorMessage = "Unsupported feature";
return false;
}
public bool Close()
{
if(!IsWriting)

19
DiscImageChef.DiscImages/QCOW2/Properties.cs
View File

@@ -34,7 +34,6 @@ using System;
using System.Collections.Generic;
using DiscImageChef.CommonTypes;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
using Schemas;
@@ -44,20 +43,10 @@ namespace DiscImageChef.DiscImages
{
public ImageInfo Info => imageInfo;
public string Name => "QEMU Copy-On-Write disk image v2";
public Guid Id => new Guid("F20107CB-95B3-4398-894B-975261F1E8C5");
public string Author => "Natalia Portillo";
public string Format => "QEMU Copy-On-Write";
public List<Partition> Partitions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> Tracks =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Session> Sessions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public string Name => "QEMU Copy-On-Write disk image v2";
public Guid Id => new Guid("F20107CB-95B3-4398-894B-975261F1E8C5");
public string Author => "Natalia Portillo";
public string Format => "QEMU Copy-On-Write";
public List<DumpHardwareType> DumpHardware => null;
public CICMMetadataType CicmMetadata => null;
public IEnumerable<MediaTagType> SupportedMediaTags => new MediaTagType[] { };

32
DiscImageChef.DiscImages/QCOW2/Unsupported.cs
View File

@@ -33,7 +33,6 @@
using System.Collections.Generic;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
namespace DiscImageChef.DiscImages
{
@@ -48,41 +47,14 @@ namespace DiscImageChef.DiscImages
public byte[] ReadDiskTag(MediaTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorTag(ulong sectorAddress, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectors(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsTag(ulong sectorAddress, uint length, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(Session session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(ushort session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySector(ulong sectorAddress) => null;
public bool? VerifySector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySectors(ulong sectorAddress, uint length, out List<ulong> failingLbas,
out List<ulong> unknownLbas)
{
@@ -93,10 +65,6 @@ namespace DiscImageChef.DiscImages
return null;
}
public bool? VerifySectors(ulong sectorAddress, uint length, uint track, out List<ulong> failingLbas,
out List<ulong> unknownLbas) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifyMediaImage() => null;
}
}

6
DiscImageChef.DiscImages/QCOW2/Write.cs
View File

@@ -280,12 +280,6 @@ namespace DiscImageChef.DiscImages
return false;
}
public bool SetTracks(List<Track> tracks)
{
ErrorMessage = "Unsupported feature";
return false;
}
public bool Close()
{
if(!IsWriting)

19
DiscImageChef.DiscImages/QED/Properties.cs
View File

@@ -34,7 +34,6 @@ using System;
using System.Collections.Generic;
using DiscImageChef.CommonTypes;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
using Schemas;
@@ -44,20 +43,10 @@ namespace DiscImageChef.DiscImages
{
public ImageInfo Info => imageInfo;
public string Name => "QEMU Enhanced Disk image";
public Guid Id => new Guid("B9DBB155-A69A-4C10-BF91-96BF431B9BB6");
public string Author => "Natalia Portillo";
public string Format => "QEMU Enhanced Disk";
public List<Partition> Partitions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> Tracks =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Session> Sessions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public string Name => "QEMU Enhanced Disk image";
public Guid Id => new Guid("B9DBB155-A69A-4C10-BF91-96BF431B9BB6");
public string Author => "Natalia Portillo";
public string Format => "QEMU Enhanced Disk";
public List<DumpHardwareType> DumpHardware => null;
public CICMMetadataType CicmMetadata => null;

32
DiscImageChef.DiscImages/QED/Unsupported.cs
View File

@@ -33,7 +33,6 @@
using System.Collections.Generic;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
namespace DiscImageChef.DiscImages
{
@@ -48,41 +47,14 @@ namespace DiscImageChef.DiscImages
public byte[] ReadDiskTag(MediaTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorTag(ulong sectorAddress, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectors(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsTag(ulong sectorAddress, uint length, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(Session session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(ushort session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySector(ulong sectorAddress) => null;
public bool? VerifySector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifySectors(ulong sectorAddress, uint length, out List<ulong> failingLbas,
out List<ulong> unknownLbas)
{
@@ -93,10 +65,6 @@ namespace DiscImageChef.DiscImages
return null;
}
public bool? VerifySectors(ulong sectorAddress, uint length, uint track, out List<ulong> failingLbas,
out List<ulong> unknownLbas) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public bool? VerifyMediaImage() => null;
}
}

6
DiscImageChef.DiscImages/QED/Write.cs
View File

@@ -237,12 +237,6 @@ namespace DiscImageChef.DiscImages
return false;
}
public bool SetTracks(List<Track> tracks)
{
ErrorMessage = "Unsupported feature";
return false;
}
public bool Close()
{
if(!IsWriting)

21
DiscImageChef.DiscImages/RayDIM/Properties.cs
View File

@@ -34,7 +34,6 @@ using System;
using System.Collections.Generic;
using DiscImageChef.CommonTypes;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
using Schemas;
@@ -42,21 +41,11 @@ namespace DiscImageChef.DiscImages
{
public partial class RayDim
{
public string Name => "Ray Arachelian's Disk IMage";
public Guid Id => new Guid("F541F4E7-C1E3-4A2D-B07F-D863E87AB961");
public ImageInfo Info => imageInfo;
public string Author => "Natalia Portillo";
public string Format => "Ray Arachelian's Disk IMage";
public List<Partition> Partitions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> Tracks =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Session> Sessions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public string Name => "Ray Arachelian's Disk IMage";
public Guid Id => new Guid("F541F4E7-C1E3-4A2D-B07F-D863E87AB961");
public ImageInfo Info => imageInfo;
public string Author => "Natalia Portillo";
public string Format => "Ray Arachelian's Disk IMage";
public List<DumpHardwareType> DumpHardware => null;
public CICMMetadataType CicmMetadata => null;
public IEnumerable<MediaTagType> SupportedMediaTags => new MediaTagType[] { };

38
DiscImageChef.DiscImages/RayDIM/Unsupported.cs
View File

@@ -33,7 +33,6 @@
using System.Collections.Generic;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
namespace DiscImageChef.DiscImages
{
@@ -41,8 +40,6 @@ namespace DiscImageChef.DiscImages
{
public bool? VerifySector(ulong sectorAddress) => null;
public bool? VerifySector(ulong sectorAddress, uint track) => null;
public bool? VerifySectors(ulong sectorAddress, uint length, out List<ulong> failingLbas,
out List<ulong> unknownLbas)
{
@@ -54,17 +51,6 @@ namespace DiscImageChef.DiscImages
return null;
}
public bool? VerifySectors(ulong sectorAddress, uint length, uint track, out List<ulong> failingLbas,
out List<ulong> unknownLbas)
{
failingLbas = new List<ulong>();
unknownLbas = new List<ulong>();
for(ulong i = sectorAddress; i < sectorAddress + length; i++) unknownLbas.Add(i);
return null;
}
public bool? VerifyMediaImage() => null;
public byte[] ReadSectorTag(ulong sectorAddress, SectorTagType tag) =>
@@ -81,29 +67,5 @@ namespace DiscImageChef.DiscImages
public byte[] ReadDiskTag(MediaTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(Session session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> GetSessionTracks(ushort session) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSector(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorTag(ulong sectorAddress, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectors(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsTag(ulong sectorAddress, uint length, uint track, SectorTagType tag) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorLong(ulong sectorAddress, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public byte[] ReadSectorsLong(ulong sectorAddress, uint length, uint track) =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
}
}

6
DiscImageChef.DiscImages/RayDIM/Write.cs
View File

@@ -164,12 +164,6 @@ namespace DiscImageChef.DiscImages
return false;
}
public bool SetTracks(List<Track> tracks)
{
ErrorMessage = "Unsupported feature";
return false;
}
public bool SetGeometry(uint cylinders, uint heads, uint sectorsPerTrack) => true;
public bool WriteSectorTag(byte[] data, ulong sectorAddress, SectorTagType tag)

21
DiscImageChef.DiscImages/RsIde/Properties.cs
View File

@@ -34,7 +34,6 @@ using System;
using System.Collections.Generic;
using DiscImageChef.CommonTypes;
using DiscImageChef.CommonTypes.Enums;
using DiscImageChef.CommonTypes.Exceptions;
using DiscImageChef.CommonTypes.Structs;
using Schemas;
@@ -42,21 +41,11 @@ namespace DiscImageChef.DiscImages
{
public partial class RsIde
{
public string Name => "RS-IDE Hard Disk Image";
public Guid Id => new Guid("47C3E78D-2BE2-4BA5-AA6B-FEE27C86FC65");
public ImageInfo Info => imageInfo;
public string Author => "Natalia Portillo";
public string Format => "RS-IDE disk image";
public List<Partition> Partitions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Track> Tracks =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public List<Session> Sessions =>
throw new FeatureUnsupportedImageException("Feature not supported by image format");
public string Name => "RS-IDE Hard Disk Image";
public Guid Id => new Guid("47C3E78D-2BE2-4BA5-AA6B-FEE27C86FC65");
public ImageInfo Info => imageInfo;
public string Author => "Natalia Portillo";
public string Format => "RS-IDE disk image";
public List<DumpHardwareType> DumpHardware => null;
public CICMMetadataType CicmMetadata => null;
public IEnumerable<MediaTagType> SupportedMediaTags => new[] {MediaTagType.ATA_IDENTIFY};

Some files were not shown because too many files have changed in this diff Show More