Add writing support to 2MG disk image.

DiscImageChef.DiscImages/Apple2MG.cs

@@ -34,6 +34,8 @@ using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
+using System.Linq;
+using System.Runtime.InteropServices;
 using System.Text;
 using DiscImageChef.CommonTypes;
 using DiscImageChef.Console;
@@ -41,7 +43,7 @@ using DiscImageChef.Filters;
 
 namespace DiscImageChef.DiscImages
 {
-    public class Apple2Mg : IMediaImage
+    public class Apple2Mg : IWritableImage
     {
         /// <summary>
         ///     Magic number, "2IMG"
@@ -75,6 +77,10 @@ namespace DiscImageChef.DiscImages
         ///     Disk image created by CiderPress, "CdrP"
         /// </summary>
         const uint CREATOR_CIDER = 0x50726443;
+        /// <summary>
+        ///     Disk image created by DiscImageChef, "dic "
+        /// </summary>
+        const uint CREATOR_DIC = 0x20636964;
 
         const uint DOS_SECTOR_ORDER    = 0x00000000;
         const uint PRODOS_SECTOR_ORDER = 0x00000001;
@@ -87,6 +93,7 @@ namespace DiscImageChef.DiscImages
         IFilter     a2MgImageFilter;
         A2ImgHeader imageHeader;
         ImageInfo   imageInfo;
+        FileStream  writingStream;
 
         public Apple2Mg()
         {
@@ -204,8 +211,10 @@ namespace DiscImageChef.DiscImages
                 DicConsole.DebugWriteLine("2MG plugin", "Detected incorrect endian on data size field, correcting.");
             }
 
-            DicConsole.DebugWriteLine("2MG plugin", "ImageHeader.magic = \"{0}\"", Encoding.ASCII.GetString(magic));
+            DicConsole.DebugWriteLine("2MG plugin", "ImageHeader.magic = \"{0}\"",
-            DicConsole.DebugWriteLine("2MG plugin", "ImageHeader.creator = \"{0}\"", Encoding.ASCII.GetString(creator));
+                                      Encoding.ASCII.GetString(magic));
+            DicConsole.DebugWriteLine("2MG plugin", "ImageHeader.creator = \"{0}\"",
+                                      Encoding.ASCII.GetString(creator));
             DicConsole.DebugWriteLine("2MG plugin", "ImageHeader.headerSize = {0}",         imageHeader.HeaderSize);
             DicConsole.DebugWriteLine("2MG plugin", "ImageHeader.version = {0}",            imageHeader.Version);
             DicConsole.DebugWriteLine("2MG plugin", "ImageHeader.imageFormat = {0}",        imageHeader.ImageFormat);
@@ -337,20 +346,6 @@ namespace DiscImageChef.DiscImages
             return true;
         }
 
-        MediaType GetMediaType()
-        {
-            switch(imageInfo.Sectors)
-            {
-                case 455: return MediaType.Apple32SS;
-                case 910: return MediaType.Apple32DS;
-                case 560: return MediaType.Apple33SS;
-                case 1120: return MediaType.Apple33DS;
-                case 800: return MediaType.AppleSonySS;
-                case 1600: return MediaType.AppleSonyDS;
-                default: return MediaType.Unknown;
-            }
-        }
-
         public byte[] ReadSector(ulong sectorAddress)
         {
             return ReadSectors(sectorAddress, 1);
@@ -471,7 +466,243 @@ namespace DiscImageChef.DiscImages
             return null;
         }
 
+        public IEnumerable<MediaTagType>  SupportedMediaTags  => new MediaTagType[] { };
+        public IEnumerable<SectorTagType> SupportedSectorTags => new SectorTagType[] { };
+        public IEnumerable<MediaType>     SupportedMediaTypes =>
+            new[]
+            {
+                MediaType.Apple32SS, MediaType.Apple32DS, MediaType.Apple33SS, MediaType.Apple33DS,
+                MediaType.AppleSonySS, MediaType.AppleSonyDS, MediaType.Unknown, MediaType.GENERIC_HDD
+            };
+        public IEnumerable<(string name, Type type, string description)> SupportedOptions =>
+            new (string name, Type type, string description)[] { };
+        public IEnumerable<string> KnownExtensions => new[] {".2mg"};
+        public bool                IsWriting       { get; private set; }
+        public string              ErrorMessage    { get; private set; }
+
+        public bool Create(string path, MediaType mediaType, Dictionary<string, string> options, ulong sectors,
+                           uint   sectorSize)
+        {
+            switch(mediaType)
+            {
+                case MediaType.Apple32SS when sectorSize != 256:
+                case MediaType.Apple32DS when sectorSize != 256:
+                case MediaType.Apple33SS when sectorSize != 256:
+                case MediaType.Apple33DS when sectorSize != 256:
+                {
+                    ErrorMessage = "Unsupported sector size";
+                    return false;
+                }
+                default:
+                    if(sectorSize != 512)
+                    {
+                        ErrorMessage = "Unsupported sector size";
+                        return false;
+                    }
+
+                    break;
+            }
+
+            if(!SupportedMediaTypes.Contains(mediaType))
+            {
+                ErrorMessage = $"Unsupported media format {mediaType}";
+                return false;
+            }
+
+            if(sectors * sectorSize > uint.MaxValue)
+            {
+                ErrorMessage = "Too many sectors";
+                return false;
+            }
+
+            imageInfo = new ImageInfo {MediaType = mediaType, SectorSize = sectorSize, Sectors = sectors};
+
+            try { writingStream = new FileStream(path, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.None); }
+            catch(IOException e)
+            {
+                ErrorMessage = $"Could not create new image file, exception {e.Message}";
+                return false;
+            }
+
+            IsWriting    = true;
+            ErrorMessage = null;
+            return true;
+        }
+
+        public bool WriteMediaTag(byte[] data, MediaTagType tag)
+        {
+            ErrorMessage = "Writing media tags is not supported.";
+            return false;
+        }
+
+        public bool WriteSector(byte[] data, ulong sectorAddress)
+        {
+            if(!IsWriting)
+            {
+                ErrorMessage = "Tried to write on a non-writable image";
+                return false;
+            }
+
+            if(data.Length != imageInfo.SectorSize)
+            {
+                ErrorMessage = "Incorrect data size";
+                return false;
+            }
+
+            if(sectorAddress >= imageInfo.Sectors)
+            {
+                ErrorMessage = "Tried to write past image size";
+                return false;
+            }
+
+            writingStream.Seek(Marshal.SizeOf(typeof(A2ImgHeader)) + (long)(sectorAddress * imageInfo.SectorSize),
+                               SeekOrigin.Begin);
+            writingStream.Write(data, 0, data.Length);
+
+            ErrorMessage = "";
+            return true;
+        }
+
+        public bool WriteSectors(byte[] data, ulong sectorAddress, uint length)
+        {
+            if(!IsWriting)
+            {
+                ErrorMessage = "Tried to write on a non-writable image";
+                return false;
+            }
+
+            if(data.Length % imageInfo.SectorSize != 0)
+            {
+                ErrorMessage = "Incorrect data size";
+                return false;
+            }
+
+            if(sectorAddress + length > imageInfo.Sectors)
+            {
+                ErrorMessage = "Tried to write past image size";
+                return false;
+            }
+
+            writingStream.Seek(Marshal.SizeOf(typeof(A2ImgHeader)) + (long)(sectorAddress * imageInfo.SectorSize),
+                               SeekOrigin.Begin);
+            writingStream.Write(data, 0, data.Length);
+
+            ErrorMessage = "";
+            return true;
+        }
+
+        public bool WriteSectorLong(byte[] data, ulong sectorAddress)
+        {
+            ErrorMessage = "Writing sectors with tags is not supported.";
+            return false;
+        }
+
+        public bool WriteSectorsLong(byte[] data, ulong sectorAddress, uint length)
+        {
+            ErrorMessage = "Writing sectors with tags is not supported.";
+            return false;
+        }
+
+        public bool SetTracks(List<Track> tracks)
+        {
+            ErrorMessage = "Unsupported feature";
+            return false;
+        }
+
+        // TODO: Add metadata to creator chunk
+        public bool Close()
+        {
+            if(!IsWriting)
+            {
+                ErrorMessage = "Image is not opened for writing";
+                return false;
+            }
+
+            imageHeader = new A2ImgHeader
+            {
+                Blocks      = (uint)imageInfo.Sectors,
+                Creator     = CREATOR_DIC,
+                DataOffset  = (uint)Marshal.SizeOf(typeof(A2ImgHeader)),
+                DataSize    = (uint)(imageInfo.Sectors * imageInfo.SectorSize),
+                HeaderSize  = (ushort)Marshal.SizeOf(typeof(A2ImgHeader)),
+                ImageFormat = imageInfo.SectorSize == 512 ? PRODOS_SECTOR_ORDER : DOS_SECTOR_ORDER,
+                Magic       = MAGIC,
+                Version     = 1
+            };
+
+            if(imageInfo.LastMediaSequence != 0)
+            {
+                imageHeader.Flags =  VALID_VOLUME_NUMBER;
+                imageHeader.Flags += (uint)(imageInfo.MediaSequence & VOLUME_NUMBER_MASK);
+            }
+
+            if(!string.IsNullOrWhiteSpace(imageInfo.Comments))
+            {
+                byte[] commentBytes = Encoding.UTF8.GetBytes(imageInfo.Comments);
+                writingStream.Seek(0, SeekOrigin.End);
+                imageHeader.CommentOffset = (uint)writingStream.Position;
+                imageHeader.CommentSize   = (uint)commentBytes.Length;
+                writingStream.Write(commentBytes, 0, commentBytes.Length);
+            }
+
+            byte[] hdr    = new byte[Marshal.SizeOf(imageHeader)];
+            IntPtr hdrPtr = Marshal.AllocHGlobal(Marshal.SizeOf(imageHeader));
+            Marshal.StructureToPtr(imageHeader, hdrPtr, true);
+            Marshal.Copy(hdrPtr, hdr, 0, hdr.Length);
+            Marshal.FreeHGlobal(hdrPtr);
+
+            writingStream.Seek(0, SeekOrigin.Begin);
+            writingStream.Write(hdr, 0, hdr.Length);
+
+            writingStream.Flush();
+            writingStream.Close();
+            IsWriting = false;
+
+            return true;
+        }
+
+        public bool SetMetadata(ImageInfo metadata)
+        {
+            imageInfo.Comments          = metadata.Comments;
+            imageInfo.MediaSequence     = metadata.MediaSequence;
+            imageInfo.LastMediaSequence = metadata.LastMediaSequence;
+            return true;
+        }
+
+        public bool SetGeometry(uint cylinders, uint heads, uint sectorsPerTrack)
+        {
+            // Geometry is not stored in image
+            return true;
+        }
+
+        public bool WriteSectorTag(byte[] data, ulong sectorAddress, SectorTagType tag)
+        {
+            ErrorMessage = "Unsupported feature";
+            return false;
+        }
+
+        public bool WriteSectorsTag(byte[] data, ulong sectorAddress, uint length, SectorTagType tag)
+        {
+            ErrorMessage = "Unsupported feature";
+            return false;
+        }
+
+        MediaType GetMediaType()
+        {
+            switch(imageInfo.Sectors)
+            {
+                case 455:  return MediaType.Apple32SS;
+                case 910:  return MediaType.Apple32DS;
+                case 560:  return MediaType.Apple33SS;
+                case 1120: return MediaType.Apple33DS;
+                case 800:  return MediaType.AppleSonySS;
+                case 1600: return MediaType.AppleSonyDS;
+                default:   return MediaType.Unknown;
+            }
+        }
+
         [SuppressMessage("ReSharper", "NotAccessedField.Local")]
+        [StructLayout(LayoutKind.Sequential, Pack = 1)]
         struct A2ImgHeader
         {
             /// <summary>