mirror of
https://github.com/aaru-dps/Aaru.Server.git
synced 2025-12-16 19:24:27 +00:00
861 lines
30 KiB
C#
861 lines
30 KiB
C#
// /***************************************************************************
|
|
// The Disc Image Chef
|
|
// ----------------------------------------------------------------------------
|
|
//
|
|
// Filename : ZZZRawImage.cs
|
|
// Author(s) : Natalia Portillo <claunia@claunia.com>
|
|
//
|
|
// Component : Disc image plugins.
|
|
//
|
|
// --[ Description ] ----------------------------------------------------------
|
|
//
|
|
// Manages raw image, that is, user data sector by sector copy.
|
|
//
|
|
// --[ License ] --------------------------------------------------------------
|
|
//
|
|
// This library is free software; you can redistribute it and/or modify
|
|
// it under the terms of the GNU Lesser General Public License as
|
|
// published by the Free Software Foundation; either version 2.1 of the
|
|
// License, or (at your option) any later version.
|
|
//
|
|
// This library is distributed in the hope that it will be useful, but
|
|
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
// Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public
|
|
// License along with this library; if not, see <http://www.gnu.org/licenses/>.
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
// Copyright © 2011-2017 Natalia Portillo
|
|
// ****************************************************************************/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using DiscImageChef.CommonTypes;
|
|
using DiscImageChef.Console;
|
|
using DiscImageChef.Filters;
|
|
|
|
namespace DiscImageChef.ImagePlugins
|
|
{
|
|
// Checked using several images and strings inside Apple's DiskImages.framework
|
|
class ZZZRawImage : ImagePlugin
|
|
{
|
|
#region Internal variables
|
|
|
|
Filter rawImageFilter;
|
|
bool differentTrackZeroSize;
|
|
|
|
#endregion
|
|
|
|
public ZZZRawImage()
|
|
{
|
|
Name = "Raw Disk Image";
|
|
// Non-random UUID to recognize this specific plugin
|
|
PluginUUID = new Guid("12345678-AAAA-BBBB-CCCC-123456789000");
|
|
ImageInfo = new ImageInfo();
|
|
ImageInfo.readableSectorTags = new List<SectorTagType>();
|
|
ImageInfo.readableMediaTags = new List<MediaTagType>();
|
|
ImageInfo.imageHasPartitions = false;
|
|
ImageInfo.imageHasSessions = false;
|
|
ImageInfo.imageVersion = null;
|
|
ImageInfo.imageApplication = null;
|
|
ImageInfo.imageApplicationVersion = null;
|
|
ImageInfo.imageCreator = null;
|
|
ImageInfo.imageComments = null;
|
|
ImageInfo.mediaManufacturer = null;
|
|
ImageInfo.mediaModel = null;
|
|
ImageInfo.mediaSerialNumber = null;
|
|
ImageInfo.mediaBarcode = null;
|
|
ImageInfo.mediaPartNumber = null;
|
|
ImageInfo.mediaSequence = 0;
|
|
ImageInfo.lastMediaSequence = 0;
|
|
ImageInfo.driveManufacturer = null;
|
|
ImageInfo.driveModel = null;
|
|
ImageInfo.driveSerialNumber = null;
|
|
ImageInfo.driveFirmwareRevision = null;
|
|
}
|
|
|
|
public override bool IdentifyImage(Filter imageFilter)
|
|
{
|
|
// Check if file is not multiple of 512
|
|
if((imageFilter.GetDataForkLength() % 512) != 0)
|
|
{
|
|
// Check known disk sizes with sectors smaller than 512
|
|
switch(imageFilter.GetDataForkLength())
|
|
{
|
|
#region Commodore
|
|
case 174848:
|
|
case 175531:
|
|
case 197376:
|
|
case 351062:
|
|
case 822400:
|
|
#endregion Commodore
|
|
case 81664:
|
|
case 116480:
|
|
case 242944:
|
|
case 256256:
|
|
case 287488:
|
|
case 306432:
|
|
case 495872:
|
|
case 988416:
|
|
case 995072:
|
|
case 1021696:
|
|
case 1146624:
|
|
case 1177344:
|
|
case 1222400:
|
|
case 1304320:
|
|
case 1255168:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public override bool OpenImage(Filter imageFilter)
|
|
{
|
|
Stream stream = imageFilter.GetDataForkStream();
|
|
stream.Seek(0, SeekOrigin.Begin);
|
|
|
|
string extension = Path.GetExtension(imageFilter.GetFilename()).ToLower();
|
|
if(extension == ".iso" && (imageFilter.GetDataForkLength() % 2048) == 0)
|
|
ImageInfo.sectorSize = 2048;
|
|
else if(extension == ".d81" && imageFilter.GetDataForkLength() == 819200)
|
|
ImageInfo.sectorSize = 256;
|
|
else
|
|
{
|
|
switch(imageFilter.GetDataForkLength())
|
|
{
|
|
case 242944:
|
|
case 256256:
|
|
case 495872:
|
|
case 92160:
|
|
case 133120:
|
|
ImageInfo.sectorSize = 128;
|
|
break;
|
|
case 116480:
|
|
case 287488: // T0S0 = 128bps
|
|
case 988416: // T0S0 = 128bps
|
|
case 995072: // T0S0 = 128bps, T0S1 = 256bps
|
|
case 1021696: // T0S0 = 128bps, T0S1 = 256bps
|
|
case 232960:
|
|
case 143360:
|
|
case 286720:
|
|
case 512512:
|
|
case 102400:
|
|
case 204800:
|
|
case 163840:
|
|
case 327680:
|
|
case 655360:
|
|
case 80384: // T0S0 = 128bps
|
|
case 325632: // T0S0 = 128bps, T0S1 = 256bps
|
|
case 653312: // T0S0 = 128bps, T0S1 = 256bps
|
|
#region Commodore
|
|
case 174848:
|
|
case 175531:
|
|
case 196608:
|
|
case 197376:
|
|
case 349696:
|
|
case 351062:
|
|
case 822400:
|
|
#endregion Commodore
|
|
ImageInfo.sectorSize = 256;
|
|
break;
|
|
case 81664:
|
|
ImageInfo.sectorSize = 319;
|
|
break;
|
|
case 306432: // T0S0 = 128bps
|
|
case 1146624: // T0S0 = 128bps, T0S1 = 256bps
|
|
case 1177344: // T0S0 = 128bps, T0S1 = 256bps
|
|
ImageInfo.sectorSize = 512;
|
|
break;
|
|
case 1222400: // T0S0 = 128bps, T0S1 = 256bps
|
|
case 1304320: // T0S0 = 128bps, T0S1 = 256bps
|
|
case 1255168: // T0S0 = 128bps, T0S1 = 256bps
|
|
case 1261568:
|
|
case 1310720:
|
|
ImageInfo.sectorSize = 1024;
|
|
break;
|
|
default:
|
|
ImageInfo.sectorSize = 512;
|
|
break;
|
|
}
|
|
}
|
|
|
|
ImageInfo.imageSize = (ulong)imageFilter.GetDataForkLength();
|
|
ImageInfo.imageCreationTime = imageFilter.GetCreationTime();
|
|
ImageInfo.imageLastModificationTime = imageFilter.GetLastWriteTime();
|
|
ImageInfo.imageName = Path.GetFileNameWithoutExtension(imageFilter.GetFilename());
|
|
differentTrackZeroSize = false;
|
|
rawImageFilter = imageFilter;
|
|
|
|
switch(imageFilter.GetDataForkLength())
|
|
{
|
|
case 242944:
|
|
ImageInfo.sectors = 1898;
|
|
break;
|
|
case 256256:
|
|
ImageInfo.sectors = 2002;
|
|
break;
|
|
case 495872:
|
|
ImageInfo.sectors = 3874;
|
|
break;
|
|
case 116480:
|
|
ImageInfo.sectors = 455;
|
|
break;
|
|
case 287488: // T0S0 = 128bps
|
|
ImageInfo.sectors = 1136;
|
|
differentTrackZeroSize = true;
|
|
break;
|
|
case 988416: // T0S0 = 128bps
|
|
ImageInfo.sectors = 3874;
|
|
differentTrackZeroSize = true;
|
|
break;
|
|
case 995072: // T0S0 = 128bps, T0S1 = 256bps
|
|
ImageInfo.sectors = 3900;
|
|
differentTrackZeroSize = true;
|
|
break;
|
|
case 1021696: // T0S0 = 128bps, T0S1 = 256bps
|
|
ImageInfo.sectors = 4004;
|
|
differentTrackZeroSize = true;
|
|
break;
|
|
case 81664:
|
|
ImageInfo.sectors = 256;
|
|
break;
|
|
case 306432: // T0S0 = 128bps
|
|
ImageInfo.sectors = 618;
|
|
differentTrackZeroSize = true;
|
|
break;
|
|
case 1146624: // T0S0 = 128bps, T0S1 = 256bps
|
|
ImageInfo.sectors = 2272;
|
|
differentTrackZeroSize = true;
|
|
break;
|
|
case 1177344: // T0S0 = 128bps, T0S1 = 256bps
|
|
ImageInfo.sectors = 2332;
|
|
differentTrackZeroSize = true;
|
|
break;
|
|
case 1222400: // T0S0 = 128bps, T0S1 = 256bps
|
|
ImageInfo.sectors = 1236;
|
|
differentTrackZeroSize = true;
|
|
break;
|
|
case 1304320: // T0S0 = 128bps, T0S1 = 256bps
|
|
ImageInfo.sectors = 1316;
|
|
differentTrackZeroSize = true;
|
|
break;
|
|
case 1255168: // T0S0 = 128bps, T0S1 = 256bps
|
|
ImageInfo.sectors = 1268;
|
|
differentTrackZeroSize = true;
|
|
break;
|
|
case 80384: // T0S0 = 128bps
|
|
ImageInfo.sectors = 322;
|
|
differentTrackZeroSize = true;
|
|
break;
|
|
case 325632: // T0S0 = 128bps, T0S1 = 256bps
|
|
ImageInfo.sectors = 1280;
|
|
differentTrackZeroSize = true;
|
|
break;
|
|
case 653312: // T0S0 = 128bps, T0S1 = 256bps
|
|
ImageInfo.sectors = 2560;
|
|
differentTrackZeroSize = true;
|
|
break;
|
|
case 1880064: // IBM XDF, 3,5", real number of sectors
|
|
ImageInfo.sectors = 670;
|
|
ImageInfo.sectorSize = 8192; // Biggest sector size
|
|
differentTrackZeroSize = true;
|
|
break;
|
|
case 175531:
|
|
ImageInfo.sectors = 683;
|
|
break;
|
|
case 197375:
|
|
ImageInfo.sectors = 768;
|
|
break;
|
|
case 351062:
|
|
ImageInfo.sectors = 1366;
|
|
break;
|
|
case 822400:
|
|
ImageInfo.sectors = 3200;
|
|
break;
|
|
default:
|
|
ImageInfo.sectors = ImageInfo.imageSize / ImageInfo.sectorSize;
|
|
break;
|
|
}
|
|
|
|
ImageInfo.mediaType = CalculateDiskType();
|
|
|
|
switch(ImageInfo.mediaType)
|
|
{
|
|
case MediaType.CD:
|
|
case MediaType.DVDPR:
|
|
case MediaType.DVDR:
|
|
case MediaType.DVDRDL:
|
|
case MediaType.DVDPRDL:
|
|
case MediaType.BDR:
|
|
case MediaType.BDRXL:
|
|
ImageInfo.xmlMediaType = XmlMediaType.OpticalDisc;
|
|
break;
|
|
default:
|
|
ImageInfo.xmlMediaType = XmlMediaType.BlockMedia;
|
|
break;
|
|
}
|
|
|
|
// Sharp X68000 SASI hard disks
|
|
if(extension == ".hdf")
|
|
{
|
|
if(ImageInfo.imageSize % 256 == 0)
|
|
{
|
|
ImageInfo.sectorSize = 256;
|
|
ImageInfo.sectors = ImageInfo.imageSize / ImageInfo.sectorSize;
|
|
ImageInfo.mediaType = MediaType.GENERIC_HDD;
|
|
}
|
|
}
|
|
|
|
DicConsole.VerboseWriteLine("Raw disk image contains a disk of type {0}", ImageInfo.mediaType);
|
|
|
|
return true;
|
|
}
|
|
|
|
public override bool ImageHasPartitions()
|
|
{
|
|
return ImageInfo.imageHasPartitions;
|
|
}
|
|
|
|
public override ulong GetImageSize()
|
|
{
|
|
return ImageInfo.imageSize;
|
|
}
|
|
|
|
public override ulong GetSectors()
|
|
{
|
|
return ImageInfo.sectors;
|
|
}
|
|
|
|
public override uint GetSectorSize()
|
|
{
|
|
return ImageInfo.sectorSize;
|
|
}
|
|
|
|
public override byte[] ReadSector(ulong sectorAddress)
|
|
{
|
|
return ReadSectors(sectorAddress, 1);
|
|
}
|
|
|
|
public override byte[] ReadSectors(ulong sectorAddress, uint length)
|
|
{
|
|
if(differentTrackZeroSize)
|
|
{
|
|
throw new NotImplementedException("Not yet implemented");
|
|
}
|
|
else
|
|
{
|
|
if(sectorAddress > ImageInfo.sectors - 1)
|
|
throw new ArgumentOutOfRangeException(nameof(sectorAddress), "Sector address not found");
|
|
|
|
if(sectorAddress + length > ImageInfo.sectors)
|
|
throw new ArgumentOutOfRangeException(nameof(length), "Requested more sectors than available");
|
|
|
|
byte[] buffer = new byte[length * ImageInfo.sectorSize];
|
|
|
|
Stream stream = rawImageFilter.GetDataForkStream();
|
|
|
|
stream.Seek((long)(sectorAddress * ImageInfo.sectorSize), SeekOrigin.Begin);
|
|
|
|
stream.Read(buffer, 0, (int)(length * ImageInfo.sectorSize));
|
|
|
|
return buffer;
|
|
|
|
}
|
|
}
|
|
|
|
public override string GetImageFormat()
|
|
{
|
|
return "Raw disk image (sector by sector copy)";
|
|
}
|
|
|
|
public override DateTime GetImageCreationTime()
|
|
{
|
|
return ImageInfo.imageCreationTime;
|
|
}
|
|
|
|
public override DateTime GetImageLastModificationTime()
|
|
{
|
|
return ImageInfo.imageLastModificationTime;
|
|
}
|
|
|
|
public override string GetImageName()
|
|
{
|
|
return ImageInfo.imageName;
|
|
}
|
|
|
|
public override MediaType GetMediaType()
|
|
{
|
|
return ImageInfo.mediaType;
|
|
}
|
|
|
|
public override bool? VerifySector(ulong sectorAddress)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
public override bool? VerifySector(ulong sectorAddress, uint track)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
public override bool? VerifySectors(ulong sectorAddress, uint length, 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 override 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 override bool? VerifyMediaImage()
|
|
{
|
|
return null;
|
|
}
|
|
|
|
public override List<Track> GetTracks()
|
|
{
|
|
if(ImageInfo.xmlMediaType == XmlMediaType.OpticalDisc)
|
|
{
|
|
Track trk = new Track();
|
|
trk.TrackBytesPerSector = (int)ImageInfo.sectorSize;
|
|
trk.TrackEndSector = ImageInfo.sectors - 1;
|
|
trk.TrackFile = rawImageFilter.GetFilename();
|
|
trk.TrackFileOffset = 0;
|
|
trk.TrackFileType = "BINARY";
|
|
trk.TrackRawBytesPerSector = (int)ImageInfo.sectorSize;
|
|
trk.TrackSequence = 1;
|
|
trk.TrackStartSector = 0;
|
|
trk.TrackSubchannelType = TrackSubchannelType.None;
|
|
trk.TrackType = TrackType.Data;
|
|
trk.TrackSession = 1;
|
|
List<Track> lst = new List<Track>();
|
|
lst.Add(trk);
|
|
return lst;
|
|
}
|
|
|
|
throw new FeatureUnsupportedImageException("Feature not supported by image format");
|
|
}
|
|
|
|
public override List<Track> GetSessionTracks(Session session)
|
|
{
|
|
if(ImageInfo.xmlMediaType == XmlMediaType.OpticalDisc)
|
|
{
|
|
if(session.SessionSequence != 1)
|
|
throw new ArgumentOutOfRangeException(nameof(session), "Only a single session is supported");
|
|
|
|
Track trk = new Track();
|
|
trk.TrackBytesPerSector = (int)ImageInfo.sectorSize;
|
|
trk.TrackEndSector = ImageInfo.sectors - 1;
|
|
trk.TrackFilter = rawImageFilter;
|
|
trk.TrackFile = rawImageFilter.GetFilename();
|
|
trk.TrackFileOffset = 0;
|
|
trk.TrackFileType = "BINARY";
|
|
trk.TrackRawBytesPerSector = (int)ImageInfo.sectorSize;
|
|
trk.TrackSequence = 1;
|
|
trk.TrackStartSector = 0;
|
|
trk.TrackSubchannelType = TrackSubchannelType.None;
|
|
trk.TrackType = TrackType.Data;
|
|
trk.TrackSession = 1;
|
|
List<Track> lst = new List<Track>();
|
|
lst.Add(trk);
|
|
return lst;
|
|
}
|
|
|
|
throw new FeatureUnsupportedImageException("Feature not supported by image format");
|
|
}
|
|
|
|
public override List<Track> GetSessionTracks(ushort session)
|
|
{
|
|
if(ImageInfo.xmlMediaType == XmlMediaType.OpticalDisc)
|
|
{
|
|
if(session != 1)
|
|
throw new ArgumentOutOfRangeException(nameof(session), "Only a single session is supported");
|
|
|
|
Track trk = new Track();
|
|
trk.TrackBytesPerSector = (int)ImageInfo.sectorSize;
|
|
trk.TrackEndSector = ImageInfo.sectors - 1;
|
|
trk.TrackFilter = rawImageFilter;
|
|
trk.TrackFile = rawImageFilter.GetFilename();
|
|
trk.TrackFileOffset = 0;
|
|
trk.TrackFileType = "BINARY";
|
|
trk.TrackRawBytesPerSector = (int)ImageInfo.sectorSize;
|
|
trk.TrackSequence = 1;
|
|
trk.TrackStartSector = 0;
|
|
trk.TrackSubchannelType = TrackSubchannelType.None;
|
|
trk.TrackType = TrackType.Data;
|
|
trk.TrackSession = 1;
|
|
List<Track> lst = new List<Track>();
|
|
lst.Add(trk);
|
|
return lst;
|
|
}
|
|
|
|
throw new FeatureUnsupportedImageException("Feature not supported by image format");
|
|
}
|
|
|
|
public override List<Session> GetSessions()
|
|
{
|
|
if(ImageInfo.xmlMediaType == XmlMediaType.OpticalDisc)
|
|
{
|
|
Session sess = new Session();
|
|
sess.EndSector = ImageInfo.sectors - 1;
|
|
sess.EndTrack = 1;
|
|
sess.SessionSequence = 1;
|
|
sess.StartSector = 0;
|
|
sess.StartTrack = 1;
|
|
List<Session> lst = new List<Session>();
|
|
lst.Add(sess);
|
|
return lst;
|
|
}
|
|
|
|
throw new FeatureUnsupportedImageException("Feature not supported by image format");
|
|
}
|
|
|
|
public override byte[] ReadSector(ulong sectorAddress, uint track)
|
|
{
|
|
if(ImageInfo.xmlMediaType == XmlMediaType.OpticalDisc)
|
|
{
|
|
if(track != 1)
|
|
throw new ArgumentOutOfRangeException(nameof(track), "Only a single session is supported");
|
|
|
|
return ReadSector(sectorAddress);
|
|
}
|
|
|
|
throw new FeatureUnsupportedImageException("Feature not supported by image format");
|
|
}
|
|
|
|
public override byte[] ReadSectors(ulong sectorAddress, uint length, uint track)
|
|
{
|
|
if(ImageInfo.xmlMediaType == XmlMediaType.OpticalDisc)
|
|
{
|
|
if(track != 1)
|
|
throw new ArgumentOutOfRangeException(nameof(track), "Only a single session is supported");
|
|
|
|
return ReadSectors(sectorAddress, length);
|
|
}
|
|
|
|
throw new FeatureUnsupportedImageException("Feature not supported by image format");
|
|
}
|
|
|
|
public override byte[] ReadSectorLong(ulong sectorAddress, uint track)
|
|
{
|
|
if(ImageInfo.xmlMediaType == XmlMediaType.OpticalDisc)
|
|
{
|
|
if(track != 1)
|
|
throw new ArgumentOutOfRangeException(nameof(track), "Only a single session is supported");
|
|
|
|
return ReadSector(sectorAddress);
|
|
}
|
|
|
|
throw new FeatureUnsupportedImageException("Feature not supported by image format");
|
|
}
|
|
|
|
public override byte[] ReadSectorsLong(ulong sectorAddress, uint length, uint track)
|
|
{
|
|
if(ImageInfo.xmlMediaType == XmlMediaType.OpticalDisc)
|
|
{
|
|
if(track != 1)
|
|
throw new ArgumentOutOfRangeException(nameof(track), "Only a single session is supported");
|
|
|
|
return ReadSectors(sectorAddress, length);
|
|
}
|
|
|
|
throw new FeatureUnsupportedImageException("Feature not supported by image format");
|
|
}
|
|
|
|
#region Private methods
|
|
|
|
MediaType CalculateDiskType()
|
|
{
|
|
if(ImageInfo.sectorSize == 2048)
|
|
{
|
|
if(ImageInfo.sectors <= 360000)
|
|
return MediaType.CD;
|
|
if(ImageInfo.sectors <= 2295104)
|
|
return MediaType.DVDPR;
|
|
if(ImageInfo.sectors <= 2298496)
|
|
return MediaType.DVDR;
|
|
if(ImageInfo.sectors <= 4171712)
|
|
return MediaType.DVDRDL;
|
|
if(ImageInfo.sectors <= 4173824)
|
|
return MediaType.DVDPRDL;
|
|
if(ImageInfo.sectors <= 24438784)
|
|
return MediaType.BDR;
|
|
if(ImageInfo.sectors <= 62500864)
|
|
return MediaType.BDRXL;
|
|
return MediaType.Unknown;
|
|
}
|
|
else
|
|
{
|
|
switch(ImageInfo.imageSize)
|
|
{
|
|
case 80384:
|
|
return MediaType.ECMA_66;
|
|
case 81664:
|
|
return MediaType.IBM23FD;
|
|
case 92160:
|
|
return MediaType.ATARI_525_SD;
|
|
case 102400:
|
|
return MediaType.ACORN_525_SS_SD_40;
|
|
case 116480:
|
|
return MediaType.Apple32SS;
|
|
case 133120:
|
|
return MediaType.ATARI_525_ED;
|
|
case 143360:
|
|
return MediaType.Apple33SS;
|
|
case 163840:
|
|
return MediaType.DOS_525_SS_DD_8;
|
|
case 184320:
|
|
return MediaType.DOS_525_SS_DD_9;
|
|
case 204800:
|
|
return MediaType.ACORN_525_SS_SD_80;
|
|
case 232960:
|
|
return MediaType.Apple32DS;
|
|
case 242944:
|
|
return MediaType.IBM33FD_128;
|
|
case 256256:
|
|
return MediaType.ECMA_54;
|
|
case 286720:
|
|
return MediaType.Apple33DS;
|
|
case 287488:
|
|
return MediaType.IBM33FD_256;
|
|
case 306432:
|
|
return MediaType.IBM33FD_512;
|
|
case 325632:
|
|
return MediaType.ECMA_70;
|
|
case 327680:
|
|
return MediaType.DOS_525_DS_DD_8;
|
|
case 368640:
|
|
return MediaType.DOS_525_DS_DD_9;
|
|
case 409600:
|
|
return MediaType.AppleSonySS;
|
|
case 495872:
|
|
return MediaType.IBM43FD_128;
|
|
case 512512:
|
|
return MediaType.ECMA_59;
|
|
case 653312:
|
|
return MediaType.ECMA_78;
|
|
case 655360:
|
|
return MediaType.ACORN_525_DS_DD;
|
|
case 737280:
|
|
return MediaType.DOS_35_DS_DD_9;
|
|
case 819200:
|
|
if(ImageInfo.sectorSize == 256)
|
|
return MediaType.CBM_35_DD;
|
|
return MediaType.AppleSonyDS;
|
|
case 839680:
|
|
return MediaType.FDFORMAT_35_DD;
|
|
case 901120:
|
|
return MediaType.CBM_AMIGA_35_DD;
|
|
case 988416:
|
|
return MediaType.IBM43FD_256;
|
|
case 995072:
|
|
return MediaType.IBM53FD_256;
|
|
case 1021696:
|
|
return MediaType.ECMA_99_26;
|
|
case 1146624:
|
|
return MediaType.IBM53FD_512;
|
|
case 1177344:
|
|
return MediaType.ECMA_99_15;
|
|
case 1222400:
|
|
return MediaType.IBM53FD_1024;
|
|
case 1228800:
|
|
return MediaType.DOS_525_HD;
|
|
case 1255168:
|
|
return MediaType.ECMA_69_8;
|
|
case 1261568:
|
|
return MediaType.NEC_8_DD;
|
|
case 1304320:
|
|
return MediaType.ECMA_99_8;
|
|
case 1310720:
|
|
return MediaType.NEC_525_HD;
|
|
case 1427456:
|
|
return MediaType.FDFORMAT_525_HD;
|
|
case 1474560:
|
|
return MediaType.DOS_35_HD;
|
|
case 1720320:
|
|
return MediaType.DMF;
|
|
case 1763328:
|
|
return MediaType.FDFORMAT_35_HD;
|
|
case 1802240:
|
|
return MediaType.CBM_AMIGA_35_HD;
|
|
case 1880064:
|
|
return MediaType.XDF_35;
|
|
case 1884160:
|
|
return MediaType.XDF_35;
|
|
case 2949120:
|
|
return MediaType.DOS_35_ED;
|
|
case 40387584:
|
|
return MediaType.PocketZip;
|
|
case 127923200:
|
|
return MediaType.ECMA_154;
|
|
case 229632000:
|
|
return MediaType.ECMA_201;
|
|
case 481520640:
|
|
return MediaType.ECMA_183_512;
|
|
case 533403648:
|
|
return MediaType.ECMA_183;
|
|
case 596787200:
|
|
return MediaType.ECMA_184_512;
|
|
case 654540800:
|
|
return MediaType.ECMA_184;
|
|
#region Commodore
|
|
case 174848:
|
|
case 175531:
|
|
return MediaType.CBM_1540;
|
|
case 196608:
|
|
case 197376:
|
|
return MediaType.CBM_1540_Ext;
|
|
case 349696:
|
|
case 351062:
|
|
return MediaType.CBM_1571;
|
|
#endregion Commodore
|
|
default:
|
|
return MediaType.GENERIC_HDD;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Unsupported features
|
|
|
|
public override byte[] ReadSectorTag(ulong sectorAddress, SectorTagType tag)
|
|
{
|
|
throw new FeatureUnsupportedImageException("Feature not supported by image format");
|
|
}
|
|
|
|
public override byte[] ReadSectorsTag(ulong sectorAddress, uint length, SectorTagType tag)
|
|
{
|
|
throw new FeatureUnsupportedImageException("Feature not supported by image format");
|
|
}
|
|
|
|
public override byte[] ReadSectorLong(ulong sectorAddress)
|
|
{
|
|
throw new FeatureUnsupportedImageException("Feature not supported by image format");
|
|
}
|
|
|
|
public override byte[] ReadSectorsLong(ulong sectorAddress, uint length)
|
|
{
|
|
throw new FeatureUnsupportedImageException("Feature not supported by image format");
|
|
}
|
|
|
|
public override string GetImageVersion()
|
|
{
|
|
return ImageInfo.imageVersion;
|
|
}
|
|
|
|
public override string GetImageApplication()
|
|
{
|
|
return ImageInfo.imageApplication;
|
|
}
|
|
|
|
public override string GetImageApplicationVersion()
|
|
{
|
|
return ImageInfo.imageApplicationVersion;
|
|
}
|
|
|
|
public override byte[] ReadDiskTag(MediaTagType tag)
|
|
{
|
|
throw new FeatureUnsupportedImageException("Feature not supported by image format");
|
|
}
|
|
|
|
public override string GetImageCreator()
|
|
{
|
|
return ImageInfo.imageCreator;
|
|
}
|
|
|
|
public override string GetImageComments()
|
|
{
|
|
return ImageInfo.imageComments;
|
|
}
|
|
|
|
public override string GetMediaManufacturer()
|
|
{
|
|
return ImageInfo.mediaManufacturer;
|
|
}
|
|
|
|
public override string GetMediaModel()
|
|
{
|
|
return ImageInfo.mediaModel;
|
|
}
|
|
|
|
public override string GetMediaSerialNumber()
|
|
{
|
|
return ImageInfo.mediaSerialNumber;
|
|
}
|
|
|
|
public override string GetMediaBarcode()
|
|
{
|
|
return ImageInfo.mediaBarcode;
|
|
}
|
|
|
|
public override string GetMediaPartNumber()
|
|
{
|
|
return ImageInfo.mediaPartNumber;
|
|
}
|
|
|
|
public override int GetMediaSequence()
|
|
{
|
|
return ImageInfo.mediaSequence;
|
|
}
|
|
|
|
public override int GetLastDiskSequence()
|
|
{
|
|
return ImageInfo.lastMediaSequence;
|
|
}
|
|
|
|
public override string GetDriveManufacturer()
|
|
{
|
|
return ImageInfo.driveManufacturer;
|
|
}
|
|
|
|
public override string GetDriveModel()
|
|
{
|
|
return ImageInfo.driveModel;
|
|
}
|
|
|
|
public override string GetDriveSerialNumber()
|
|
{
|
|
return ImageInfo.driveSerialNumber;
|
|
}
|
|
|
|
public override List<Partition> GetPartitions()
|
|
{
|
|
throw new FeatureUnsupportedImageException("Feature not supported by image format");
|
|
}
|
|
|
|
public override byte[] ReadSectorTag(ulong sectorAddress, uint track, SectorTagType tag)
|
|
{
|
|
throw new FeatureUnsupportedImageException("Feature not supported by image format");
|
|
}
|
|
|
|
public override byte[] ReadSectorsTag(ulong sectorAddress, uint length, uint track, SectorTagType tag)
|
|
{
|
|
throw new FeatureUnsupportedImageException("Feature not supported by image format");
|
|
}
|
|
|
|
#endregion Unsupported features
|
|
}
|
|
}
|
|
|