Converted ImageInfo in public structure, use it to cache and

interchange information about disc image.

DiscImageChef/ImagePlugins/CDRWin.cs

@@ -284,6 +284,20 @@ namespace DiscImageChef.ImagePlugins
 
         #endregion
 
+        #region Accesible variables
+
+        ImageInfo _imageInfo;
+
+        public ImageInfo ImageInfo
+        {
+            get
+            {
+                return _imageInfo;
+            }
+        }
+
+        #endregion
+
         #region Methods
 
         public CDRWin(PluginBase Core)
@@ -291,7 +305,25 @@ namespace DiscImageChef.ImagePlugins
             Name = "CDRWin cuesheet";
             PluginUUID = new Guid("664568B2-15D4-4E64-8A7A-20BDA8B8386F");
             imagePath = "";
+            _imageInfo = new ImageInfo();
+            _imageInfo.readableSectorTags = new List<SectorTagType>();
+            _imageInfo.readableDiskTags = new List<DiskTagType>();
+            _imageInfo.imageHasPartitions = true;
+            _imageInfo.imageHasSessions = true;
+            _imageInfo.imageVersion = null;
+            _imageInfo.imageApplicationVersion = null;
+            _imageInfo.imageName = null;
+            _imageInfo.imageCreator = null;
+            _imageInfo.diskManufacturer = null;
+            _imageInfo.diskModel = null;
+            _imageInfo.diskPartNumber = null;
+            _imageInfo.diskSequence = 0;
+            _imageInfo.lastDiskSequence = 0;
+            _imageInfo.driveManufacturer = null;
+            _imageInfo.driveModel = null;
+            _imageInfo.driveSerialNumber = null;
         }
+
         // Due to .cue format, this method must parse whole file, ignoring errors (those will be thrown by OpenImage()).
         public override bool IdentifyImage(string imagePath)
         {
@@ -1186,6 +1218,106 @@ namespace DiscImageChef.ImagePlugins
                     }
                 }
 
+                foreach (CDRWinTrack track in discimage.tracks)
+                    _imageInfo.imageSize += track.bps * track.sectors;
+                foreach (CDRWinTrack track in discimage.tracks)
+                    _imageInfo.sectors += track.sectors;
+
+                if (discimage.disktype == DiskType.CDG || discimage.disktype == DiskType.CDEG || discimage.disktype == DiskType.CDMIDI)
+                    _imageInfo.sectorSize = 2448; // CD+G subchannels ARE user data, as CD+G are useless without them
+                else if (discimage.disktype != DiskType.CDROMXA && discimage.disktype != DiskType.CDDA && discimage.disktype != DiskType.CDI && discimage.disktype != DiskType.CDPLUS)
+                    _imageInfo.sectorSize = 2048; // Only data tracks
+                else
+                    _imageInfo.sectorSize = 2352; // All others
+
+                if (discimage.mcn != null)
+                    _imageInfo.readableDiskTags.Add(DiskTagType.CD_MCN);
+                if (discimage.cdtextfile != null)
+                    _imageInfo.readableDiskTags.Add(DiskTagType.CD_TEXT);
+
+                // Detect ISOBuster extensions
+                if (discimage.disktypestr != null || discimage.comment.ToLower().Contains("isobuster") || discimage.sessions.Count > 1)
+                    _imageInfo.imageApplication = "ISOBuster";
+                else
+                    _imageInfo.imageApplication = "CDRWin";
+
+                FileInfo fi = new FileInfo(discimage.tracks[0].trackfile.datafile);
+
+                _imageInfo.imageCreationTime = fi.CreationTimeUtc;
+                _imageInfo.imageLastModificationTime = fi.LastWriteTimeUtc;
+
+                _imageInfo.imageComments = discimage.comment;
+                _imageInfo.diskSerialNumber = discimage.mcn;
+                _imageInfo.diskBarcode = discimage.barcode;
+                _imageInfo.diskType = discimage.disktype;
+
+                foreach(CDRWinTrack track in discimage.tracks)
+                {
+                    switch(track.tracktype)
+                    {
+                        case CDRWinTrackTypeAudio:
+                            {
+                                if(!_imageInfo.readableSectorTags.Contains(SectorTagType.CDTrackISRC))
+                                    _imageInfo.readableSectorTags.Add(SectorTagType.CDTrackISRC);
+                                if(!_imageInfo.readableSectorTags.Contains(SectorTagType.CDTrackFlags))
+                                    _imageInfo.readableSectorTags.Add(SectorTagType.CDTrackFlags);
+                                break;
+                            }
+                        case CDRWinTrackTypeCDG:
+                            {
+                                if(!_imageInfo.readableSectorTags.Contains(SectorTagType.CDTrackISRC))
+                                    _imageInfo.readableSectorTags.Add(SectorTagType.CDTrackISRC);
+                                if(!_imageInfo.readableSectorTags.Contains(SectorTagType.CDTrackFlags))
+                                    _imageInfo.readableSectorTags.Add(SectorTagType.CDTrackFlags);
+                                if(!_imageInfo.readableSectorTags.Contains(SectorTagType.CDSectorSubchannel))
+                                    _imageInfo.readableSectorTags.Add(SectorTagType.CDSectorSubchannel);
+                                break;
+                            }
+                        case CDRWinTrackTypeMode2Formless:
+                        case CDRWinTrackTypeCDI:
+                            {
+                                if(!_imageInfo.readableSectorTags.Contains(SectorTagType.CDSectorSubHeader))
+                                    _imageInfo.readableSectorTags.Add(SectorTagType.CDSectorSubHeader);
+                                if(!_imageInfo.readableSectorTags.Contains(SectorTagType.CDSectorEDC))
+                                    _imageInfo.readableSectorTags.Add(SectorTagType.CDSectorEDC);
+                                break;
+                            }
+                        case CDRWinTrackTypeMode2Raw:
+                        case CDRWinTrackTypeCDIRaw:
+                            {
+                                if(!_imageInfo.readableSectorTags.Contains(SectorTagType.CDSectorSync))
+                                    _imageInfo.readableSectorTags.Add(SectorTagType.CDSectorSync);
+                                if(!_imageInfo.readableSectorTags.Contains(SectorTagType.CDSectorHeader))
+                                    _imageInfo.readableSectorTags.Add(SectorTagType.CDSectorHeader);
+                                if(!_imageInfo.readableSectorTags.Contains(SectorTagType.CDSectorSubHeader))
+                                    _imageInfo.readableSectorTags.Add(SectorTagType.CDSectorSubHeader);
+                                if(!_imageInfo.readableSectorTags.Contains(SectorTagType.CDSectorEDC))
+                                    _imageInfo.readableSectorTags.Add(SectorTagType.CDSectorEDC);
+                                break;
+                            }
+                        case CDRWinTrackTypeMode1Raw:
+                            {
+                                if(!_imageInfo.readableSectorTags.Contains(SectorTagType.CDSectorSync))
+                                    _imageInfo.readableSectorTags.Add(SectorTagType.CDSectorSync);
+                                if(!_imageInfo.readableSectorTags.Contains(SectorTagType.CDSectorHeader))
+                                    _imageInfo.readableSectorTags.Add(SectorTagType.CDSectorHeader);
+                                if(!_imageInfo.readableSectorTags.Contains(SectorTagType.CDSectorSubHeader))
+                                    _imageInfo.readableSectorTags.Add(SectorTagType.CDSectorSubHeader);
+                                if(!_imageInfo.readableSectorTags.Contains(SectorTagType.CDSectorECC))
+                                    _imageInfo.readableSectorTags.Add(SectorTagType.CDSectorECC);
+                                if(!_imageInfo.readableSectorTags.Contains(SectorTagType.CDSectorECC_P))
+                                    _imageInfo.readableSectorTags.Add(SectorTagType.CDSectorECC_P);
+                                if(!_imageInfo.readableSectorTags.Contains(SectorTagType.CDSectorECC_Q))
+                                    _imageInfo.readableSectorTags.Add(SectorTagType.CDSectorECC_Q);
+                                if(!_imageInfo.readableSectorTags.Contains(SectorTagType.CDSectorEDC))
+                                    _imageInfo.readableSectorTags.Add(SectorTagType.CDSectorEDC);
+                                break;
+                            }
+                        default:
+                            break;
+                    }
+                }
+
                 return true;
             }
             catch (Exception ex)
@@ -1199,39 +1331,22 @@ namespace DiscImageChef.ImagePlugins
 
         public override bool ImageHasPartitions()
         {
-            // Even if they only have 1 track, there is a partition (track 1)
+            return _imageInfo.imageHasPartitions;
-            return true;
         }
 
         public override UInt64 GetImageSize()
         {
-            UInt64 size;
+            return _imageInfo.imageSize;
-
-            size = 0;
-            foreach (CDRWinTrack track in discimage.tracks)
-                size += track.bps * track.sectors;
-
-            return size;
         }
 
         public override UInt64 GetSectors()
         {
-            UInt64 sectors;
+            return _imageInfo.sectors;
-
-            sectors = 0;
-            foreach (CDRWinTrack track in discimage.tracks)
-                sectors += track.sectors;
-
-            return sectors;
         }
 
         public override UInt32 GetSectorSize()
         {
-            if (discimage.disktype == DiskType.CDG || discimage.disktype == DiskType.CDEG || discimage.disktype == DiskType.CDMIDI)
+            return _imageInfo.sectorSize;
-                return 2448; // CD+G subchannels ARE user data, as CD+G are useless without them
-            if (discimage.disktype != DiskType.CDROMXA && discimage.disktype != DiskType.CDDA && discimage.disktype != DiskType.CDI && discimage.disktype != DiskType.CDPLUS)
-                return 2048; // Only data tracks
-            return 2352; // All others
         }
 
         public override byte[] ReadDiskTag(DiskTagType tag)
@@ -1761,54 +1876,47 @@ namespace DiscImageChef.ImagePlugins
 
         public override string   GetImageVersion()
         {
-            return null;
+            return _imageInfo.imageVersion;
         }
 
         public override string   GetImageApplication()
         {
-            // Detect ISOBuster extensions
+            return _imageInfo.imageApplication;
-            if (discimage.disktypestr != null || discimage.comment.ToLower().Contains("isobuster") || discimage.sessions.Count > 1)
-                return "ISOBuster";
-            return "CDRWin";
         }
 
         public override string   GetImageApplicationVersion()
         {
-            throw new FeatureSupportedButNotImplementedImageException("Feature not yet implemented");
+            return _imageInfo.imageApplicationVersion;
         }
 
         public override DateTime GetImageCreationTime()
         {
-            FileInfo fi = new FileInfo(discimage.tracks[0].trackfile.datafile);
+            return _imageInfo.imageCreationTime;
-
-            return fi.CreationTimeUtc;
         }
 
         public override DateTime GetImageLastModificationTime()
         {
-            FileInfo fi = new FileInfo(discimage.tracks[0].trackfile.datafile);
+            return _imageInfo.imageLastModificationTime;
-
-            return fi.LastWriteTimeUtc;
         }
 
         public override string   GetImageComments()
         {
-            return discimage.comment;
+            return _imageInfo.imageComments;
         }
 
         public override string GetDiskSerialNumber()
         {
-            return discimage.mcn;
+            return _imageInfo.diskSerialNumber;
         }
 
         public override string GetDiskBarcode()
         {
-            return discimage.barcode;
+            return _imageInfo.diskBarcode;
         }
 
         public override DiskType GetDiskType()
         {
-            return discimage.disktype;
+            return _imageInfo.diskType;
         }
 
         public override List<PartPlugins.Partition> GetPartitions()
@@ -2013,54 +2121,53 @@ namespace DiscImageChef.ImagePlugins
 
         public override int    GetDiskSequence()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.diskSequence;
         }
 
         public override int    GetLastDiskSequence()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.lastDiskSequence;
         }
 
         public override string GetDriveManufacturer()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.driveManufacturer;
         }
 
         public override string GetDriveModel()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.driveModel;
         }
 
         public override string GetDriveSerialNumber()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.driveSerialNumber;
         }
 
         public override string GetDiskPartNumber()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.diskPartNumber;
         }
 
         public override string GetDiskManufacturer()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.diskManufacturer;
         }
 
         public override string GetDiskModel()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.diskModel;
         }
 
         public override string   GetImageName()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.imageName;
         }
 
         public override string   GetImageCreator()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.imageCreator;
         }
-
         #endregion
     }
 }

DiscImageChef/ImagePlugins/DiskCopy42.cs

@@ -117,10 +117,6 @@ namespace DiscImageChef.ImagePlugins
         UInt32 dataOffset;
         // Start of tags in disk image, after data sectors
         UInt32 tagOffset;
-        // Sectors
-        UInt32 sectors;
-        // Bytes per sector, should be 512
-        UInt32 bps;
         // Bytes per tag, should be 12
         UInt32 bptag;
         // Header of opened image
@@ -130,10 +126,44 @@ namespace DiscImageChef.ImagePlugins
 
         #endregion
 
+        #region Accesible variables
+
+        ImageInfo _imageInfo;
+
+        public ImageInfo ImageInfo
+        {
+            get
+            {
+                return _imageInfo;
+            }
+        }
+
+        #endregion
+
         public DiskCopy42(PluginBase Core)
         {
             Name = "Apple DiskCopy 4.2";
             PluginUUID = new Guid("0240B7B1-E959-4CDC-B0BD-386D6E467B88");
+            _imageInfo = new ImageInfo();
+            _imageInfo.readableSectorTags = new List<SectorTagType>();
+            _imageInfo.readableDiskTags = new List<DiskTagType>();
+            _imageInfo.imageHasPartitions = false;
+            _imageInfo.imageHasSessions = false;
+            _imageInfo.imageVersion = "4.2";
+            _imageInfo.imageApplication = "Apple DiskCopy";
+            _imageInfo.imageApplicationVersion = "4.2";
+            _imageInfo.imageCreator = null;
+            _imageInfo.imageComments = null;
+            _imageInfo.diskManufacturer = null;
+            _imageInfo.diskModel = null;
+            _imageInfo.diskSerialNumber = null;
+            _imageInfo.diskBarcode = null;
+            _imageInfo.diskPartNumber = null;
+            _imageInfo.diskSequence = 0;
+            _imageInfo.lastDiskSequence = 0;
+            _imageInfo.driveManufacturer = null;
+            _imageInfo.driveModel = null;
+            _imageInfo.driveSerialNumber = null;
         }
 
         public override bool IdentifyImage(string imagePath)
@@ -291,21 +321,53 @@ namespace DiscImageChef.ImagePlugins
 
             dataOffset = 0x54;
             tagOffset = header.tagSize != 0 ? 0x54 + header.dataSize : 0;
-            bps = 512;
+            _imageInfo.sectorSize = 512;
             bptag = (uint)(header.tagSize != 0 ? 12 : 0);
             dc42ImagePath = imagePath;
 
-            sectors = header.dataSize / 512;
+            _imageInfo.sectors = header.dataSize / 512;
 
             if (header.tagSize != 0)
             {
-                if (header.tagSize / 12 != sectors)
+                if (header.tagSize / 12 != _imageInfo.sectors)
                 {
                     if (MainClass.isDebug)
                         Console.WriteLine("DEBUG (DC42 plugin): header.tagSize / 12 != sectors");
 
                     return false;
                 }
+
+                _imageInfo.readableSectorTags.Add(SectorTagType.AppleSectorTag);
+            }
+
+            _imageInfo.imageSize = _imageInfo.sectors * _imageInfo.sectorSize + _imageInfo.sectors * bptag;
+            _imageInfo.imageCreationTime = fi.CreationTimeUtc;
+            _imageInfo.imageLastModificationTime = fi.LastWriteTimeUtc;
+            _imageInfo.imageName = header.diskName;
+
+            switch (header.format)
+            {
+                case kSonyFormat400K:
+                    _imageInfo.diskType = DiskType.AppleSonySS;
+                    break;
+                case kSonyFormat800K:
+                    _imageInfo.diskType = DiskType.AppleSonyDS;
+                    break;
+                case kSonyFormat720K:
+                    _imageInfo.diskType = DiskType.DOS_35_DS_DD_9;
+                    break;
+                case kSonyFormat1440K:
+                    _imageInfo.diskType = DiskType.DOS_35_HD;
+                    break;
+                case kSonyFormat1680K:
+                    _imageInfo.diskType = DiskType.DMF;
+                    break;
+                case kSigmaFormatTwiggy:
+                    _imageInfo.diskType = DiskType.AppleFileWare;
+                    break;
+                default:
+                    _imageInfo.diskType = DiskType.Unknown;
+                    break;
             }
 
             return true;
@@ -313,22 +375,22 @@ namespace DiscImageChef.ImagePlugins
 
         public override bool ImageHasPartitions()
         {
-            return false;
+            return _imageInfo.imageHasPartitions;
         }
 
         public override UInt64 GetImageSize()
         {
-            return sectors * bps + sectors * bptag;
+            return _imageInfo.imageSize;
         }
 
         public override UInt64 GetSectors()
         {
-            return sectors;
+            return _imageInfo.sectors;
         }
 
         public override UInt32 GetSectorSize()
         {
-            return bps;
+            return _imageInfo.sectorSize;
         }
 
         public override byte[] ReadSector(UInt64 sectorAddress)
@@ -343,19 +405,19 @@ namespace DiscImageChef.ImagePlugins
 
         public override byte[] ReadSectors(UInt64 sectorAddress, UInt32 length)
         {
-            if (sectorAddress > sectors - 1)
+            if (sectorAddress > _imageInfo.sectors - 1)
                 throw new ArgumentOutOfRangeException("sectorAddress", "Sector address not found");
 
-            if (sectorAddress + length > sectors)
+            if (sectorAddress + length > _imageInfo.sectors)
                 throw new ArgumentOutOfRangeException("length", "Requested more sectors than available");
 
-            byte[] buffer = new byte[length * bps];
+            byte[] buffer = new byte[length * _imageInfo.sectorSize];
 
             FileStream stream = new FileStream(dc42ImagePath, FileMode.Open, FileAccess.Read);
 
-            stream.Seek((long)(dataOffset + sectorAddress * bps), SeekOrigin.Begin);
+            stream.Seek((long)(dataOffset + sectorAddress * _imageInfo.sectorSize), SeekOrigin.Begin);
 
-            stream.Read(buffer, 0, (int)(length * bps));
+            stream.Read(buffer, 0, (int)(length * _imageInfo.sectorSize));
 
             stream.Close();
 
@@ -370,10 +432,10 @@ namespace DiscImageChef.ImagePlugins
             if (header.tagSize == 0)
                 throw new FeatureNotPresentImageException("Disk image does not have tags");
 
-            if (sectorAddress > sectors - 1)
+            if (sectorAddress > _imageInfo.sectors - 1)
                 throw new ArgumentOutOfRangeException("sectorAddress", "Sector address not found");
 
-            if (sectorAddress + length > sectors)
+            if (sectorAddress + length > _imageInfo.sectors)
                 throw new ArgumentOutOfRangeException("length", "Requested more sectors than available");
 
             byte[] buffer = new byte[length * bptag];
@@ -396,10 +458,10 @@ namespace DiscImageChef.ImagePlugins
 
         public override byte[] ReadSectorsLong(UInt64 sectorAddress, UInt32 length)
         {
-            if (sectorAddress > sectors - 1)
+            if (sectorAddress > _imageInfo.sectors - 1)
                 throw new ArgumentOutOfRangeException("sectorAddress", "Sector address not found");
 
-            if (sectorAddress + length > sectors)
+            if (sectorAddress + length > _imageInfo.sectors)
                 throw new ArgumentOutOfRangeException("length", "Requested more sectors than available");
 
             byte[] data = ReadSectors(sectorAddress, length);
@@ -408,8 +470,8 @@ namespace DiscImageChef.ImagePlugins
 
             for (uint i = 0; i < length; i++)
             {
-                Array.Copy(data, i * (bps), buffer, i * (bps + bptag), bps);
+                Array.Copy(data, i * (_imageInfo.sectorSize), buffer, i * (_imageInfo.sectorSize + bptag), _imageInfo.sectorSize);
-                Array.Copy(tags, i * (bptag), buffer, i * (bps + bptag) + bps, bptag);
+                Array.Copy(tags, i * (bptag), buffer, i * (_imageInfo.sectorSize + bptag) + _imageInfo.sectorSize, bptag);
             }
 
             return buffer;
@@ -422,57 +484,37 @@ namespace DiscImageChef.ImagePlugins
 
         public override string   GetImageVersion()
         {
-            return "4.2";
+            return _imageInfo.imageVersion;
         }
 
         public override string   GetImageApplication()
         {
-            return "Apple DiskCopy";
+            return _imageInfo.imageApplication;
         }
 
         public override string   GetImageApplicationVersion()
         {
-            return "4.2";
+            return _imageInfo.imageApplicationVersion;
         }
 
         public override DateTime GetImageCreationTime()
         {
-            FileInfo fi = new FileInfo(dc42ImagePath);
+            return _imageInfo.imageCreationTime;
-
-            return fi.CreationTimeUtc;
         }
 
         public override DateTime GetImageLastModificationTime()
         {
-            FileInfo fi = new FileInfo(dc42ImagePath);
+            return _imageInfo.imageLastModificationTime;
-
-            return fi.LastWriteTimeUtc;
         }
 
         public override string   GetImageName()
         {
-            return header.diskName;
+            return _imageInfo.imageName;
         }
 
         public override DiskType GetDiskType()
         {
-            switch (header.format)
+            return _imageInfo.diskType;
-            {
-                case kSonyFormat400K:
-                    return DiskType.AppleSonySS;
-                case kSonyFormat800K:
-                    return DiskType.AppleSonyDS;
-                case kSonyFormat720K:
-                    return DiskType.DOS_35_DS_DD_9;
-                case kSonyFormat1440K:
-                    return DiskType.DOS_35_HD;
-                case kSonyFormat1680K:
-                    return DiskType.DMF;
-                case kSigmaFormatTwiggy:
-                    return DiskType.AppleFileWare;
-                default:
-                    return DiskType.Unknown;
-            }
         }
 
         #region Unsupported features
@@ -484,62 +526,62 @@ namespace DiscImageChef.ImagePlugins
 
         public override string GetImageCreator()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.imageCreator;
         }
 
         public override string   GetImageComments()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.imageComments;
         }
 
         public override string   GetDiskManufacturer()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.diskManufacturer;
         }
 
         public override string   GetDiskModel()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.diskModel;
         }
 
         public override string   GetDiskSerialNumber()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.diskSerialNumber;
         }
 
         public override string   GetDiskBarcode()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.diskBarcode;
         }
 
         public override string   GetDiskPartNumber()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.diskPartNumber;
         }
 
         public override int      GetDiskSequence()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.diskSequence;
         }
 
         public override int      GetLastDiskSequence()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.lastDiskSequence;
         }
 
         public override string GetDriveManufacturer()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.driveManufacturer;
         }
 
         public override string GetDriveModel()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.driveModel;
         }
 
         public override string GetDriveSerialNumber()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.driveSerialNumber;
         }
 
         public override List<PartPlugins.Partition> GetPartitions()

DiscImageChef/ImagePlugins/ImagePlugin.cs

@@ -50,6 +50,8 @@ namespace DiscImageChef.ImagePlugins
         public string Name;
         /// <summary>Plugin UUID.</summary>
         public Guid PluginUUID;
+        /// <summary>Image information</summary>
+        public ImageInfo ImageInfo;
 
         protected ImagePlugin()
         {

DiscImageChef/ImagePlugins/TeleDisk.cs

@@ -191,21 +191,46 @@ namespace DiscImageChef.ImagePlugins
         TD0Header header;
         TDCommentBlockHeader commentHeader;
         byte[] commentBlock;
-        string comment;
-        DateTime creationDate;
-        DateTime modificationDate;
         Dictionary<UInt32, byte[]> sectorsData; // LBA, data
         UInt32 totalDiskSize;
-        UInt64 imageSizeWithoutHeaders;
+        #endregion
-        string imageName;
+
-        string telediskVersion;
+        #region Accesible variables
-        UInt32 biggestSectorSize;
+
+        ImageInfo _imageInfo;
+
+        public ImageInfo ImageInfo
+        {
+            get
+            {
+                return _imageInfo;
+            }
+        }
+
         #endregion
 
         public TeleDisk(PluginBase Core)
         {
             Name = "Sydex TeleDisk";
             PluginUUID = new Guid("0240B7B1-E959-4CDC-B0BD-386D6E467B88");
+            _imageInfo = new ImageInfo();
+            _imageInfo.readableSectorTags = new List<SectorTagType>();
+            _imageInfo.readableDiskTags = new List<DiskTagType>();
+            _imageInfo.imageHasPartitions = false;
+            _imageInfo.imageHasSessions = false;
+            _imageInfo.imageApplication = "Sydex TeleDisk";
+            _imageInfo.imageComments = null;
+            _imageInfo.imageCreator = null;
+            _imageInfo.diskManufacturer = null;
+            _imageInfo.diskModel = null;
+            _imageInfo.diskSerialNumber = null;
+            _imageInfo.diskBarcode = null;
+            _imageInfo.diskPartNumber = null;
+            _imageInfo.diskSequence = 0;
+            _imageInfo.lastDiskSequence = 0;
+            _imageInfo.driveManufacturer = null;
+            _imageInfo.driveModel = null;
+            _imageInfo.driveSerialNumber = null;
         }
 
         public override bool IdentifyImage(string imagePath)
@@ -294,8 +319,9 @@ namespace DiscImageChef.ImagePlugins
             header.sides = headerBytes[9];
             header.crc = BitConverter.ToUInt16(headerBytes, 10);
 
-            imageName = Path.GetFileNameWithoutExtension(imagePath);
+            _imageInfo.imageName = Path.GetFileNameWithoutExtension(imagePath);
-            telediskVersion = String.Format("{0}.{1}", (header.version & 0xF0) >> 4, header.version & 0x0F);
+            _imageInfo.imageVersion = String.Format("{0}.{1}", (header.version & 0xF0) >> 4, header.version & 0x0F);
+            _imageInfo.imageApplication = _imageInfo.imageVersion;
 
             byte[] headerBytesForCRC = new byte[10];
             Array.Copy(headerBytes, headerBytesForCRC, 10);
@@ -336,7 +362,7 @@ namespace DiscImageChef.ImagePlugins
             if (header.signature == tdAdvCompMagic)
                 throw new NotImplementedException("TeleDisk Advanced Compression support not yet implemented");
 
-            creationDate = DateTime.MinValue;
+            _imageInfo.imageCreationTime = DateTime.MinValue;
 
             if ((header.stepping & CommentBlockPresent) == CommentBlockPresent)
             {
@@ -385,27 +411,27 @@ namespace DiscImageChef.ImagePlugins
                         commentBlock[i]=0x0A;
                 }
 
-                comment = System.Text.Encoding.ASCII.GetString(commentBlock);
+                _imageInfo.imageComments = System.Text.Encoding.ASCII.GetString(commentBlock);
 
                 if(MainClass.isDebug)
                 {
                     Console.WriteLine("DEBUG (TeleDisk plugin): Comment");
-                    Console.WriteLine("DEBUG (TeleDisk plugin): {0}", comment);
+                    Console.WriteLine("DEBUG (TeleDisk plugin): {0}", _imageInfo.imageComments);
                 }
 
-                creationDate = new DateTime(commentHeader.year+1900, commentHeader.month+1, commentHeader.day,
+                _imageInfo.imageCreationTime = new DateTime(commentHeader.year+1900, commentHeader.month+1, commentHeader.day,
                                             commentHeader.hour, commentHeader.minute, commentHeader.second, DateTimeKind.Unspecified);
             }
 
             FileInfo fi = new FileInfo(imagePath);
-            if (creationDate == DateTime.MinValue)
+            if (_imageInfo.imageCreationTime == DateTime.MinValue)
-                creationDate = fi.CreationTimeUtc;
+                _imageInfo.imageCreationTime = fi.CreationTimeUtc;
-            modificationDate = fi.LastWriteTimeUtc;
+            _imageInfo.imageLastModificationTime = fi.LastWriteTimeUtc;
 
             if (MainClass.isDebug)
             {
-                Console.WriteLine("DEBUG (TeleDisk plugin): Image created on {0}", creationDate);
+                Console.WriteLine("DEBUG (TeleDisk plugin): Image created on {0}", _imageInfo.imageCreationTime);
-                Console.WriteLine("DEBUG (TeleDisk plugin): Image modified on {0}", modificationDate);
+                Console.WriteLine("DEBUG (TeleDisk plugin): Image modified on {0}", _imageInfo.imageLastModificationTime);
             }
 
             if (MainClass.isDebug)
@@ -413,9 +439,9 @@ namespace DiscImageChef.ImagePlugins
 
             totalDiskSize = 0;
             byte spt = 0;
-            imageSizeWithoutHeaders = 0;
+            _imageInfo.imageSize = 0;
             sectorsData = new Dictionary<uint, byte[]>();
-            biggestSectorSize = 0;
+            _imageInfo.sectorSize = 0;
             while (true)
             {
                 TDTrackHeader TDTrack = new TDTrackHeader();
@@ -492,7 +518,7 @@ namespace DiscImageChef.ImagePlugins
                         stream.Read(dataSizeBytes, 0, 2);
                         TDData.dataSize = BitConverter.ToUInt16(dataSizeBytes, 0);
                         TDData.dataSize--; // Sydex decided to including dataEncoding byte as part of it
-                        imageSizeWithoutHeaders += TDData.dataSize;
+                        _imageInfo.imageSize += TDData.dataSize;
                         TDData.dataEncoding = (byte)stream.ReadByte();
                         data = new byte[TDData.dataSize];
                         stream.Read(data, 0, TDData.dataSize);
@@ -561,32 +587,36 @@ namespace DiscImageChef.ImagePlugins
                             totalDiskSize += (uint)decodedData.Length;
                         }
                     }
-                    if (decodedData.Length > biggestSectorSize)
+                    if (decodedData.Length > _imageInfo.sectorSize)
-                        biggestSectorSize = (uint)decodedData.Length;
+                        _imageInfo.sectorSize = (uint)decodedData.Length;
                 }
             }
+
+            _imageInfo.sectors = (ulong)sectorsData.Count;
+            _imageInfo.diskType = DecodeTeleDiskDiskType();
+
             stream.Close();
             return true;
         }
         
         public override bool ImageHasPartitions()
         {
-            return false;
+            return _imageInfo.imageHasPartitions;
         }
         
         public override UInt64 GetImageSize()
         {
-            return imageSizeWithoutHeaders;
+            return _imageInfo.imageSize;
         }
         
         public override UInt64 GetSectors()
         {
-            return (ulong)sectorsData.Count;
+            return _imageInfo.sectors;
         }
         
         public override UInt32 GetSectorSize()
         {
-            return biggestSectorSize;
+            return _imageInfo.sectorSize;
         }
         
         public override byte[] ReadSector(UInt64 sectorAddress)
@@ -650,212 +680,37 @@ namespace DiscImageChef.ImagePlugins
         
         public override string   GetImageVersion()
         {
-            return telediskVersion;
+            return _imageInfo.imageVersion;
         }
         
         public override string   GetImageApplication()
         {
-            return "Sydex TeleDisk";
+            return _imageInfo.imageApplication;
         }
         
         public override string   GetImageApplicationVersion()
         {
-            return telediskVersion;
+            return _imageInfo.imageApplicationVersion;
         }
         
         public override DateTime GetImageCreationTime()
         {
-            return creationDate;
+            return _imageInfo.imageCreationTime;
         }
         
         public override DateTime GetImageLastModificationTime()
         {
-            return modificationDate;
+            return _imageInfo.imageLastModificationTime;
         }
         
         public override string   GetImageName()
         {
-            return imageName;
+            return _imageInfo.imageName;
         }
         
         public override DiskType GetDiskType()
         {
-            switch (header.driveType)
+            return _imageInfo.diskType;
-            {
-                case DriveType525DD:
-                case DriveType525HD_DDDisk:
-                case DriveType525HD:
-                    {
-                        switch (totalDiskSize)
-                        {
-                            case 163840:
-                                {
-                                    // Acorn disk uses 256 bytes/sector
-                                    if(biggestSectorSize == 256)
-                                        return DiskType.ACORN_525_SS_DD_40;
-                                    else // DOS disks use 512 bytes/sector
-                                        return DiskType.DOS_525_SS_DD_8;
-                                }
-                            case 184320:
-                                {
-                                    // Atari disk uses 256 bytes/sector
-                                    if(biggestSectorSize == 256)
-                                        return DiskType.ATARI_525_DD;
-                                    else // DOS disks use 512 bytes/sector
-                                        return DiskType.DOS_525_SS_DD_9;
-                                }
-                            case 327680:
-                                {
-                                    // Acorn disk uses 256 bytes/sector
-                                    if(biggestSectorSize == 256)
-                                        return DiskType.ACORN_525_SS_DD_80;
-                                    else // DOS disks use 512 bytes/sector
-                                        return DiskType.DOS_525_DS_DD_8;
-                                }
-                            case 368640:
-                                return DiskType.DOS_525_DS_DD_9;
-                            case 1228800:
-                                return DiskType.DOS_525_HD;
-                            case 102400:
-                                return DiskType.ACORN_525_SS_SD_40;
-                            case 204800:
-                                return DiskType.ACORN_525_SS_SD_80;
-                            case 655360:
-                                return DiskType.ACORN_525_DS_DD;
-                            case 92160:
-                                return DiskType.ATARI_525_SD;
-                            case 133120:
-                                return DiskType.ATARI_525_ED;
-                            case 1310720:
-                                return DiskType.NEC_525_HD;
-                            case 1261568:
-                                return DiskType.SHARP_525;
-                            case 839680:
-                                return DiskType.FDFORMAT_525_DD;
-                            case 1304320:
-                                return DiskType.ECMA_99_8;
-                            case 1223424:
-                                return DiskType.ECMA_99_15;
-                            case 1061632:
-                                return DiskType.ECMA_99_26;
-                            case 80384:
-                                return DiskType.ECMA_66;
-                            case 325632:
-                                return DiskType.ECMA_70;
-                            case 653312:
-                                return DiskType.ECMA_78;
-                            case 737280:
-                                return DiskType.ECMA_78_2;
-                            default:
-                                {
-                                    if (MainClass.isDebug)
-                                        Console.WriteLine("DEBUG (TeleDisk plugin): Unknown 5,25\" disk with {0} bytes", totalDiskSize);
-                                    return DiskType.Unknown;
-                                }
-                        }
-                    }
-                case DriveType35DD:
-                case DriveType35ED:
-                case DriveType35HD:
-                    {
-                        switch (totalDiskSize)
-                        {
-                            case 327680:
-                                return DiskType.DOS_35_SS_DD_8;
-                            case 368640:
-                                return DiskType.DOS_35_SS_DD_9;
-                            case 655360:
-                                return DiskType.DOS_35_DS_DD_8;
-                            case 737280:
-                                return DiskType.DOS_35_DS_DD_9;
-                            case 1474560:
-                                return DiskType.DOS_35_HD;
-                            case 2949120:
-                                return DiskType.DOS_35_ED;
-                            case 1720320:
-                                return DiskType.DMF;
-                            case 1763328:
-                                return DiskType.DMF_82;
-                            case 1884160: // Irreal size, seen as BIOS with TSR, 23 sectors/track
-                            case 1860608: // Real data size, sum of all sectors
-                                return DiskType.XDF_35;
-                            case 819200:
-                                return DiskType.CBM_35_DD;
-                            case 901120:
-                                return DiskType.CBM_AMIGA_35_DD;
-                            case 1802240:
-                                return DiskType.CBM_AMIGA_35_HD;
-                            case 1310720:
-                                return DiskType.NEC_35_HD_8;
-                            case 1228800:
-                                return DiskType.NEC_35_HD_15;
-                            case 1261568:
-                                return DiskType.SHARP_35;
-                            default:
-                                {
-                                    if (MainClass.isDebug)
-                                        Console.WriteLine("DEBUG (TeleDisk plugin): Unknown 3,5\" disk with {0} bytes", totalDiskSize);
-                                    return DiskType.Unknown;
-                                }
-                        }
-                    }
-                case DriveType8inch:
-                    {
-                        switch (totalDiskSize)
-                        {
-                            case 81664:
-                                return DiskType.IBM23FD;
-                            case 242944:
-                                return DiskType.IBM33FD_128;
-                            case 287488:
-                                return DiskType.IBM33FD_256;
-                            case 306432:
-                                return DiskType.IBM33FD_512;
-                            case 499200:
-                                return DiskType.IBM43FD_128;
-                            case 574976:
-                                return DiskType.IBM43FD_256;
-                            case 995072:
-                                return DiskType.IBM53FD_256;
-                            case 1146624:
-                                return DiskType.IBM53FD_512;
-                            case 1222400:
-                                return DiskType.IBM53FD_1024;
-                            case 256256:
-                                // Same size, with same disk geometry, for DEC RX01, NEC and ECMA, return ECMA
-                                return DiskType.ECMA_54;
-                            case 512512:
-                                {
-                                    // DEC disk uses 256 bytes/sector
-                                    if(biggestSectorSize == 256)
-                                        return DiskType.RX02;
-                                    else // ECMA disks use 128 bytes/sector
-                                        return DiskType.ECMA_59;
-                                }
-                            case 1261568:
-                                return DiskType.NEC_8_DD;
-                            case 1255168:
-                                return DiskType.ECMA_69_8;
-                            case 1177344:
-                                return DiskType.ECMA_69_15;
-                            case 1021696:
-                                return DiskType.ECMA_69_26;
-                            default:
-                                {
-                                    if (MainClass.isDebug)
-                                        Console.WriteLine("DEBUG (TeleDisk plugin): Unknown 8\" disk with {0} bytes", totalDiskSize);
-                                    return DiskType.Unknown;
-                                }
-                        }
-                    }
-                default:
-                    {
-                        if (MainClass.isDebug)
-                            Console.WriteLine("DEBUG (TeleDisk plugin): Unknown drive type {1} with {0} bytes", totalDiskSize, header.driveType);
-                        return DiskType.Unknown;
-                    }
-
-            }
         }
 
         #region Private methods
@@ -989,6 +844,186 @@ namespace DiscImageChef.ImagePlugins
 
             return decodedData;
         }
+
+        private DiskType DecodeTeleDiskDiskType()
+        {
+            switch (header.driveType)
+            {
+                case DriveType525DD:
+                case DriveType525HD_DDDisk:
+                case DriveType525HD:
+                    {
+                        switch (totalDiskSize)
+                        {
+                            case 163840:
+                                {
+                                    // Acorn disk uses 256 bytes/sector
+                                    if(_imageInfo.sectorSize == 256)
+                                        return DiskType.ACORN_525_SS_DD_40;
+                                    else // DOS disks use 512 bytes/sector
+                                        return DiskType.DOS_525_SS_DD_8;
+                                }
+                            case 184320:
+                                {
+                                    // Atari disk uses 256 bytes/sector
+                                    if(_imageInfo.sectorSize == 256)
+                                        return DiskType.ATARI_525_DD;
+                                    else // DOS disks use 512 bytes/sector
+                                        return DiskType.DOS_525_SS_DD_9;
+                                }
+                            case 327680:
+                                {
+                                    // Acorn disk uses 256 bytes/sector
+                                    if(_imageInfo.sectorSize == 256)
+                                        return DiskType.ACORN_525_SS_DD_80;
+                                    else // DOS disks use 512 bytes/sector
+                                        return DiskType.DOS_525_DS_DD_8;
+                                }
+                            case 368640:
+                                return DiskType.DOS_525_DS_DD_9;
+                            case 1228800:
+                                return DiskType.DOS_525_HD;
+                            case 102400:
+                                return DiskType.ACORN_525_SS_SD_40;
+                            case 204800:
+                                return DiskType.ACORN_525_SS_SD_80;
+                            case 655360:
+                                return DiskType.ACORN_525_DS_DD;
+                            case 92160:
+                                return DiskType.ATARI_525_SD;
+                            case 133120:
+                                return DiskType.ATARI_525_ED;
+                            case 1310720:
+                                return DiskType.NEC_525_HD;
+                            case 1261568:
+                                return DiskType.SHARP_525;
+                            case 839680:
+                                return DiskType.FDFORMAT_525_DD;
+                            case 1304320:
+                                return DiskType.ECMA_99_8;
+                            case 1223424:
+                                return DiskType.ECMA_99_15;
+                            case 1061632:
+                                return DiskType.ECMA_99_26;
+                            case 80384:
+                                return DiskType.ECMA_66;
+                            case 325632:
+                                return DiskType.ECMA_70;
+                            case 653312:
+                                return DiskType.ECMA_78;
+                            case 737280:
+                                return DiskType.ECMA_78_2;
+                            default:
+                                {
+                                    if (MainClass.isDebug)
+                                        Console.WriteLine("DEBUG (TeleDisk plugin): Unknown 5,25\" disk with {0} bytes", totalDiskSize);
+                                    return DiskType.Unknown;
+                                }
+                        }
+                    }
+                case DriveType35DD:
+                case DriveType35ED:
+                case DriveType35HD:
+                    {
+                        switch (totalDiskSize)
+                        {
+                            case 327680:
+                                return DiskType.DOS_35_SS_DD_8;
+                            case 368640:
+                                return DiskType.DOS_35_SS_DD_9;
+                            case 655360:
+                                return DiskType.DOS_35_DS_DD_8;
+                            case 737280:
+                                return DiskType.DOS_35_DS_DD_9;
+                            case 1474560:
+                                return DiskType.DOS_35_HD;
+                            case 2949120:
+                                return DiskType.DOS_35_ED;
+                            case 1720320:
+                                return DiskType.DMF;
+                            case 1763328:
+                                return DiskType.DMF_82;
+                            case 1884160: // Irreal size, seen as BIOS with TSR, 23 sectors/track
+                            case 1860608: // Real data size, sum of all sectors
+                                return DiskType.XDF_35;
+                            case 819200:
+                                return DiskType.CBM_35_DD;
+                            case 901120:
+                                return DiskType.CBM_AMIGA_35_DD;
+                            case 1802240:
+                                return DiskType.CBM_AMIGA_35_HD;
+                            case 1310720:
+                                return DiskType.NEC_35_HD_8;
+                            case 1228800:
+                                return DiskType.NEC_35_HD_15;
+                            case 1261568:
+                                return DiskType.SHARP_35;
+                            default:
+                                {
+                                    if (MainClass.isDebug)
+                                        Console.WriteLine("DEBUG (TeleDisk plugin): Unknown 3,5\" disk with {0} bytes", totalDiskSize);
+                                    return DiskType.Unknown;
+                                }
+                        }
+                    }
+                case DriveType8inch:
+                    {
+                        switch (totalDiskSize)
+                        {
+                            case 81664:
+                                return DiskType.IBM23FD;
+                            case 242944:
+                                return DiskType.IBM33FD_128;
+                            case 287488:
+                                return DiskType.IBM33FD_256;
+                            case 306432:
+                                return DiskType.IBM33FD_512;
+                            case 499200:
+                                return DiskType.IBM43FD_128;
+                            case 574976:
+                                return DiskType.IBM43FD_256;
+                            case 995072:
+                                return DiskType.IBM53FD_256;
+                            case 1146624:
+                                return DiskType.IBM53FD_512;
+                            case 1222400:
+                                return DiskType.IBM53FD_1024;
+                            case 256256:
+                                // Same size, with same disk geometry, for DEC RX01, NEC and ECMA, return ECMA
+                                return DiskType.ECMA_54;
+                            case 512512:
+                                {
+                                    // DEC disk uses 256 bytes/sector
+                                    if(_imageInfo.sectorSize == 256)
+                                        return DiskType.RX02;
+                                    else // ECMA disks use 128 bytes/sector
+                                        return DiskType.ECMA_59;
+                                }
+                            case 1261568:
+                                return DiskType.NEC_8_DD;
+                            case 1255168:
+                                return DiskType.ECMA_69_8;
+                            case 1177344:
+                                return DiskType.ECMA_69_15;
+                            case 1021696:
+                                return DiskType.ECMA_69_26;
+                            default:
+                                {
+                                    if (MainClass.isDebug)
+                                        Console.WriteLine("DEBUG (TeleDisk plugin): Unknown 8\" disk with {0} bytes", totalDiskSize);
+                                    return DiskType.Unknown;
+                                }
+                        }
+                    }
+                default:
+                    {
+                        if (MainClass.isDebug)
+                            Console.WriteLine("DEBUG (TeleDisk plugin): Unknown drive type {1} with {0} bytes", totalDiskSize, header.driveType);
+                        return DiskType.Unknown;
+                    }
+
+            }
+        }
         #endregion
 
         #region Unsupported features
@@ -1010,62 +1045,62 @@ namespace DiscImageChef.ImagePlugins
         
         public override string GetImageCreator()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.imageCreator;
         }
         
         public override string   GetImageComments()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.imageComments;
         }
         
         public override string   GetDiskManufacturer()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.diskManufacturer;
         }
         
         public override string   GetDiskModel()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.diskModel;
         }
         
         public override string   GetDiskSerialNumber()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.diskSerialNumber;
         }
         
         public override string   GetDiskBarcode()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.diskBarcode;
         }
         
         public override string   GetDiskPartNumber()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.diskPartNumber;
         }
         
         public override int      GetDiskSequence()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.diskSequence;
         }
         
         public override int      GetLastDiskSequence()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.lastDiskSequence;
         }
         
         public override string GetDriveManufacturer()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.driveManufacturer;
         }
         
         public override string GetDriveModel()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.driveModel;
         }
         
         public override string GetDriveSerialNumber()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.driveSerialNumber;
         }
         
         public override List<PartPlugins.Partition> GetPartitions()

DiscImageChef/ImagePlugins/ZZZRawImage.cs

@@ -46,22 +46,49 @@ namespace DiscImageChef.ImagePlugins
     class ZZZRawImage : ImagePlugin
     {
         #region Internal variables
-
-        UInt64 imageSize;
-        UInt64 sectors;
-        UInt32 sectorSize;
-        DateTime creationTime;
-        DateTime modificationTime;
-        string imageName;
         string rawImagePath;
         bool differentTrackZeroSize;
         #endregion
 
+        #region Accesible variables
+
+        ImageInfo _imageInfo;
+
+        public ImageInfo ImageInfo
+        {
+            get
+            {
+                return _imageInfo;
+            }
+        }
+
+        #endregion
+
         public ZZZRawImage(PluginBase Core)
         {
             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.readableDiskTags = new List<DiskTagType>();
+            _imageInfo.imageHasPartitions = false;
+            _imageInfo.imageHasSessions = false;
+            _imageInfo.imageVersion = null;
+            _imageInfo.imageApplication = null;
+            _imageInfo.imageApplicationVersion = null;
+            _imageInfo.imageCreator = null;
+            _imageInfo.imageComments = null;
+            _imageInfo.diskManufacturer = null;
+            _imageInfo.diskModel = null;
+            _imageInfo.diskSerialNumber = null;
+            _imageInfo.diskBarcode = null;
+            _imageInfo.diskPartNumber = null;
+            _imageInfo.diskSequence = 0;
+            _imageInfo.lastDiskSequence = 0;
+            _imageInfo.driveManufacturer = null;
+            _imageInfo.driveModel = null;
+            _imageInfo.driveSerialNumber = null;
         }
 
         public override bool IdentifyImage(string imagePath)
@@ -107,7 +134,7 @@ namespace DiscImageChef.ImagePlugins
             FileInfo fi = new FileInfo(imagePath);
             string extension = Path.GetExtension(imagePath).ToLower();
             if (extension == ".iso" && (fi.Length % 2048) == 0)
-                sectorSize = 2048;
+                _imageInfo.sectorSize = 2048;
             else
             {
                 switch (fi.Length)
@@ -117,7 +144,7 @@ namespace DiscImageChef.ImagePlugins
                     case 495872:
                     case 92160:
                     case 133120:
-                        sectorSize = 128;
+                        _imageInfo.sectorSize = 128;
                         break;
                     case 116480:
                     case 287488: // T0S0 = 128bps
@@ -136,136 +163,138 @@ namespace DiscImageChef.ImagePlugins
                     case 80384: // T0S0 = 128bps
                     case 325632: // T0S0 = 128bps, T0S1 = 256bps
                     case 653312: // T0S0 = 128bps, T0S1 = 256bps
-                        sectorSize = 256;
+                        _imageInfo.sectorSize = 256;
                         break;
                     case 81664:
-                        sectorSize = 319;
+                        _imageInfo.sectorSize = 319;
                         break;
                     case 306432: // T0S0 = 128bps
                     case 1146624: // T0S0 = 128bps, T0S1 = 256bps
                     case 1177344: // T0S0 = 128bps, T0S1 = 256bps
-                        sectorSize = 512;
+                        _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:
-                        sectorSize = 1024;
+                        _imageInfo.sectorSize = 1024;
                         break;
                     default:
-                        sectorSize = 512;
+                        _imageInfo.sectorSize = 512;
                         break;
                 }
             }
 
-            imageSize = (ulong)fi.Length;
+            _imageInfo.imageSize = (ulong)fi.Length;
-            creationTime = fi.CreationTimeUtc;
+            _imageInfo.imageCreationTime = fi.CreationTimeUtc;
-            modificationTime = fi.LastWriteTimeUtc;
+            _imageInfo.imageLastModificationTime = fi.LastWriteTimeUtc;
-            imageName = Path.GetFileNameWithoutExtension(imagePath);
+            _imageInfo.imageName = Path.GetFileNameWithoutExtension(imagePath);
             differentTrackZeroSize = false;
             rawImagePath = imagePath;
 
             switch (fi.Length)
             {
                 case 242944:
-                    sectors = 1898;
+                    _imageInfo.sectors = 1898;
                     break;
                 case 256256:
-                    sectors = 2002;
+                    _imageInfo.sectors = 2002;
                     break;
                 case 495872:
-                    sectors = 3874;
+                    _imageInfo.sectors = 3874;
                     break;
                 case 116480:
-                    sectors = 455;
+                    _imageInfo.sectors = 455;
                     break;
                 case 287488: // T0S0 = 128bps
-                    sectors = 1136;
+                    _imageInfo.sectors = 1136;
                     differentTrackZeroSize = true;
                     break;
                 case 988416: // T0S0 = 128bps
-                    sectors = 3874;
+                    _imageInfo.sectors = 3874;
                     differentTrackZeroSize = true;
                     break;
                 case 995072: // T0S0 = 128bps, T0S1 = 256bps
-                    sectors = 3900;
+                    _imageInfo.sectors = 3900;
                     differentTrackZeroSize = true;
                     break;
                 case 1021696: // T0S0 = 128bps, T0S1 = 256bps
-                    sectors = 4004;
+                    _imageInfo.sectors = 4004;
                     differentTrackZeroSize = true;
                     break;
                 case 81664:
-                    sectors = 256;
+                    _imageInfo.sectors = 256;
                     break;
                 case 306432: // T0S0 = 128bps
-                    sectors = 618;
+                    _imageInfo.sectors = 618;
                     differentTrackZeroSize = true;
                     break;
                 case 1146624: // T0S0 = 128bps, T0S1 = 256bps
-                    sectors = 2272;
+                    _imageInfo.sectors = 2272;
                     differentTrackZeroSize = true;
                     break;
                 case 1177344: // T0S0 = 128bps, T0S1 = 256bps
-                    sectors = 2332;
+                    _imageInfo.sectors = 2332;
                     differentTrackZeroSize = true;
                     break;
                 case 1222400: // T0S0 = 128bps, T0S1 = 256bps
-                    sectors = 1236;
+                    _imageInfo.sectors = 1236;
                     differentTrackZeroSize = true;
                     break;
                 case 1304320: // T0S0 = 128bps, T0S1 = 256bps
-                    sectors = 1316;
+                    _imageInfo.sectors = 1316;
                     differentTrackZeroSize = true;
                     break;
                 case 1255168: // T0S0 = 128bps, T0S1 = 256bps
-                    sectors = 1268;
+                    _imageInfo.sectors = 1268;
                     differentTrackZeroSize = true;
                     break;
                 case 80384: // T0S0 = 128bps
-                    sectors = 322;
+                    _imageInfo.sectors = 322;
                     differentTrackZeroSize = true;
                     break;
                 case 325632: // T0S0 = 128bps, T0S1 = 256bps
-                    sectors = 1280;
+                    _imageInfo.sectors = 1280;
                     differentTrackZeroSize = true;
                     break;
                 case 653312: // T0S0 = 128bps, T0S1 = 256bps
-                    sectors = 2560;
+                    _imageInfo.sectors = 2560;
                     differentTrackZeroSize = true;
                     break;
                 case 1880064: // IBM XDF, 3,5", real number of sectors
-                    sectors = 670;
+                    _imageInfo.sectors = 670;
-                    sectorSize = 8192; // Biggest sector size
+                    _imageInfo.sectorSize = 8192; // Biggest sector size
                     differentTrackZeroSize = true;
                     break;
                 default:
-                    sectors = imageSize / sectorSize;
+                    _imageInfo.sectors = _imageInfo.imageSize / _imageInfo.sectorSize;
                     break;
             }
 
+            _imageInfo.diskType = CalculateDiskType();
+
             return true;
         }
 
         public override bool ImageHasPartitions()
         {
-            return false;
+            return _imageInfo.imageHasPartitions;
         }
 
         public override UInt64 GetImageSize()
         {
-            return imageSize;
+            return _imageInfo.imageSize;
         }
 
         public override UInt64 GetSectors()
         {
-            return sectors;
+            return _imageInfo.sectors;
         }
 
         public override UInt32 GetSectorSize()
         {
-            return sectorSize;
+            return _imageInfo.sectorSize;
         }
 
         public override byte[] ReadSector(UInt64 sectorAddress)
@@ -281,19 +310,19 @@ namespace DiscImageChef.ImagePlugins
             }
             else
             {
-                if (sectorAddress > sectors - 1)
+                if (sectorAddress > _imageInfo.sectors - 1)
                     throw new ArgumentOutOfRangeException("sectorAddress", "Sector address not found");
 
-                if (sectorAddress + length > sectors)
+                if (sectorAddress + length > _imageInfo.sectors)
                     throw new ArgumentOutOfRangeException("length", "Requested more sectors than available");
 
-                byte[] buffer = new byte[length * sectorSize];
+                byte[] buffer = new byte[length * _imageInfo.sectorSize];
 
                 FileStream stream = new FileStream(rawImagePath, FileMode.Open, FileAccess.Read);
 
-                stream.Seek((long)(sectorAddress * sectorSize), SeekOrigin.Begin);
+                stream.Seek((long)(sectorAddress * _imageInfo.sectorSize), SeekOrigin.Begin);
 
-                stream.Read(buffer, 0, (int)(length * sectorSize));
+                stream.Read(buffer, 0, (int)(length * _imageInfo.sectorSize));
 
                 stream.Close();
 
@@ -309,42 +338,48 @@ namespace DiscImageChef.ImagePlugins
 
         public override DateTime GetImageCreationTime()
         {
-            return creationTime;
+            return _imageInfo.imageCreationTime;
         }
 
         public override DateTime GetImageLastModificationTime()
         {
-            return modificationTime;
+            return _imageInfo.imageLastModificationTime;
         }
 
         public override string   GetImageName()
         {
-            return imageName;
+            return _imageInfo.imageName;
         }
 
         public override DiskType GetDiskType()
         {
-            if (sectorSize == 2048)
+            return _imageInfo.diskType;
+        }
+
+        #region Private methods
+        private DiskType CalculateDiskType()
+        {
+            if (_imageInfo.sectorSize == 2048)
             {
-                if (sectors <= 360000)
+                if (_imageInfo.sectors <= 360000)
                     return DiskType.CD;
-                if (sectors <= 2295104)
+                if (_imageInfo.sectors <= 2295104)
                     return DiskType.DVDPR;
-                if (sectors <= 2298496)
+                if (_imageInfo.sectors <= 2298496)
                     return DiskType.DVDR;
-                if (sectors <= 4171712)
+                if (_imageInfo.sectors <= 4171712)
                     return DiskType.DVDRDL;
-                if (sectors <= 4173824)
+                if (_imageInfo.sectors <= 4173824)
                     return DiskType.DVDPRDL;
-                if (sectors <= 24438784)
+                if (_imageInfo.sectors <= 24438784)
                     return DiskType.BDR;
-                if (sectors <= 62500864)
+                if (_imageInfo.sectors <= 62500864)
                     return DiskType.BDRXL;
                 return DiskType.Unknown;
             }
             else
             {
-                switch (imageSize)
+                switch (_imageInfo.imageSize)
                 {
                     case 80384:
                         return DiskType.ECMA_66;
@@ -457,6 +492,7 @@ namespace DiscImageChef.ImagePlugins
                 }
             }
         }
+        #endregion
 
         #region Unsupported features
 
@@ -482,17 +518,17 @@ namespace DiscImageChef.ImagePlugins
 
         public override string   GetImageVersion()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.imageVersion;
         }
 
         public override string   GetImageApplication()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.imageApplication;
         }
 
         public override string   GetImageApplicationVersion()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.imageApplicationVersion;
         }
 
         public override byte[] ReadDiskTag(DiskTagType tag)
@@ -502,62 +538,62 @@ namespace DiscImageChef.ImagePlugins
 
         public override string GetImageCreator()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.imageCreator;
         }
 
         public override string   GetImageComments()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.imageComments;
         }
 
         public override string   GetDiskManufacturer()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.diskManufacturer;
         }
 
         public override string   GetDiskModel()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.diskModel;
         }
 
         public override string   GetDiskSerialNumber()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.diskSerialNumber;
         }
 
         public override string   GetDiskBarcode()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.diskBarcode;
         }
 
         public override string   GetDiskPartNumber()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.diskPartNumber;
         }
 
         public override int      GetDiskSequence()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.diskSequence;
         }
 
         public override int      GetLastDiskSequence()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.lastDiskSequence;
         }
 
         public override string GetDriveManufacturer()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.driveManufacturer;
         }
 
         public override string GetDriveModel()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.driveModel;
         }
 
         public override string GetDriveSerialNumber()
         {
-            throw new FeatureUnsupportedImageException("Feature not supported by image format");
+            return _imageInfo.driveSerialNumber;
         }
 
         public override List<PartPlugins.Partition> GetPartitions()

DiscImageChef/Plugins/LisaFS.cs

@@ -73,6 +73,9 @@ namespace DiscImageChef.Plugins
         {
             try
             {
+                if(!imagePlugin.ImageInfo.readableSectorTags.Contains(SectorTagType.AppleSectorTag))
+                    return false;
+
                 // LisaOS is big-endian
                 BigEndianBitConverter.IsLittleEndian = BitConverter.IsLittleEndian;
 
@@ -156,6 +159,9 @@ namespace DiscImageChef.Plugins
 
             try
             {
+                if(!imagePlugin.ImageInfo.readableSectorTags.Contains(SectorTagType.AppleSectorTag))
+                    return;
+
                 // LisaOS is big-endian
                 BigEndianBitConverter.IsLittleEndian = BitConverter.IsLittleEndian;