Add interface for writing sector tags that are not included in a long sector.

DiscImageChef.DiscImages/Anex86.cs

@@ -498,6 +498,18 @@ namespace DiscImageChef.DiscImages
             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;
+        }
+
         [StructLayout(LayoutKind.Sequential, Pack = 1)]
         struct Anex86Header
         {

DiscImageChef.DiscImages/CDRWin.cs

@@ -177,8 +177,11 @@ namespace DiscImageChef.DiscImages
         ImageInfo    imageInfo;
         Stream       imageStream;
         /// <summary>Dictionary, index is track #, value is TrackFile</summary>
-        Dictionary<uint, ulong>      offsetmap;
+        Dictionary<uint, ulong> offsetmap;
-        bool                         separateTracksWriting;
+        bool                    separateTracksWriting;
+
+        Dictionary<byte, byte>       trackFlags;
+        Dictionary<byte, string>     trackIsrcs;
         string                       writingBaseName;
         Dictionary<uint, FileStream> writingStreams;
         List<Track>                  writingTracks;
@@ -624,10 +627,10 @@ namespace DiscImageChef.DiscImages
                                 throw new
                                     FeatureUnsupportedImageException($"Found FLAGS field in incorrect place at line {lineNumber}");
 
-                            currenttrack.FlagDcp  |= matchFile.Groups["dcp"].Value  == "DCP";
+                            currenttrack.FlagDcp  |= matchFlags.Groups["dcp"].Value  == "DCP";
-                            currenttrack.Flag4ch  |= matchFile.Groups["quad"].Value == "4CH";
+                            currenttrack.Flag4ch  |= matchFlags.Groups["quad"].Value == "4CH";
-                            currenttrack.FlagPre  |= matchFile.Groups["pre"].Value  == "PRE";
+                            currenttrack.FlagPre  |= matchFlags.Groups["pre"].Value  == "PRE";
-                            currenttrack.FlagScms |= matchFile.Groups["scms"].Value == "SCMS";
+                            currenttrack.FlagScms |= matchFlags.Groups["scms"].Value == "SCMS";
                         }
                         else if(matchGenre.Success)
                         {
@@ -1451,7 +1454,10 @@ namespace DiscImageChef.DiscImages
 
                     return new[] {(byte)flags};
                 }
-                case SectorTagType.CdTrackIsrc: return Encoding.UTF8.GetBytes(dicTrack.Isrc);
+                case SectorTagType.CdTrackIsrc:
+                    if(dicTrack.Isrc == null) return null;
+
+                    return Encoding.UTF8.GetBytes(dicTrack.Isrc);
                 case SectorTagType.CdTrackText:
                     throw new FeatureSupportedButNotImplementedImageException("Feature not yet implemented");
                 default: throw new ArgumentException("Unsupported tag requested", nameof(tag));
@@ -1903,6 +1909,9 @@ namespace DiscImageChef.DiscImages
                 Tracks   = new List<CdrWinTrack>()
             };
 
+            trackFlags = new Dictionary<byte, byte>();
+            trackIsrcs = new Dictionary<byte, string>();
+
             IsWriting    = true;
             ErrorMessage = null;
             return true;
@@ -2209,6 +2218,20 @@ namespace DiscImageChef.DiscImages
 
                 (byte minute, byte second, byte frame) msf = LbaToMsf(track.TrackStartSector);
                 descriptorStream.WriteLine("  TRACK {0:D2} {1}", track.TrackSequence, GetTrackMode(track));
+
+                if(trackFlags.TryGetValue((byte)track.TrackSequence, out byte flagsByte))
+                    if(flagsByte != 0 && flagsByte != (byte)CdFlags.DataTrack)
+                    {
+                        CdFlags flags = (CdFlags)flagsByte;
+                        descriptorStream.WriteLine("    FLAGS{0}{1}{2}",
+                                                   flags.HasFlag(CdFlags.CopyPermitted) ? " DCP" : "",
+                                                   flags.HasFlag(CdFlags.FourChannel) ? " 4CH" : "",
+                                                   flags.HasFlag(CdFlags.PreEmphasis) ? " PRE" : "");
+                    }
+
+                if(trackIsrcs.TryGetValue((byte)track.TrackSequence, out string isrc))
+                    descriptorStream.WriteLine("    FLAGS {0}", isrc);
+
                 descriptorStream.WriteLine("    INDEX {0:D2} {1:D2}:{2:D2}:{3:D2}", 1, msf.minute, msf.second,
                                            msf.frame);
             }
@@ -2226,6 +2249,53 @@ namespace DiscImageChef.DiscImages
             return false;
         }
 
+        public bool WriteSectorTag(byte[] data, ulong sectorAddress, SectorTagType tag)
+        {
+            if(!IsWriting)
+            {
+                ErrorMessage = "Tried to write on a non-writable image";
+                return false;
+            }
+
+            Track track =
+                writingTracks.FirstOrDefault(trk => sectorAddress >= trk.TrackStartSector &&
+                                                    sectorAddress <= trk.TrackEndSector);
+
+            if(track.TrackSequence == 0)
+            {
+                ErrorMessage = $"Can't found track containing {sectorAddress}";
+                return false;
+            }
+
+            switch(tag)
+            {
+                case SectorTagType.CdTrackFlags:
+                {
+                    if(data.Length != 1)
+                    {
+                        ErrorMessage = "Incorrect data size for track flags";
+                        return false;
+                    }
+
+                    trackFlags.Add((byte)track.TrackSequence, data[0]);
+                    return true;
+                }
+                case SectorTagType.CdTrackIsrc:
+                {
+                    if(data != null) trackIsrcs.Add((byte)track.TrackSequence, Encoding.UTF8.GetString(data));
+                    return true;
+                }
+                default:
+                    ErrorMessage = $"Unsupported tag type {tag}";
+                    return false;
+            }
+        }
+
+        public bool WriteSectorsTag(byte[] data, ulong sectorAddress, uint length, SectorTagType tag)
+        {
+            throw new NotImplementedException();
+        }
+
         public bool SetMetadata(ImageInfo metadata)
         {
             discimage.Barcode = metadata.MediaBarcode;

DiscImageChef.DiscImages/CisCopy.cs

@@ -646,6 +646,18 @@ namespace DiscImageChef.DiscImages
             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;
+        }
+
         [SuppressMessage("ReSharper", "InconsistentNaming")]
         enum DiskType : byte
         {

DiscImageChef.DiscImages/DiskCopy42.cs

@@ -1149,6 +1149,18 @@ namespace DiscImageChef.DiscImages
             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;
+        }
+
         // DiskCopy 4.2 header, big-endian, data-fork, start of file, 84 bytes
         struct Dc42Header
         {

DiscImageChef.DiscImages/DriDiskCopy.cs

@@ -550,6 +550,18 @@ namespace DiscImageChef.DiscImages
             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;
+        }
+
         [StructLayout(LayoutKind.Sequential, Pack = 1)]
         struct DriFooter
         {

DiscImageChef.DiscImages/IWritableImage.cs

@@ -107,9 +107,9 @@ namespace DiscImageChef.DiscImages
         bool WriteSectors(byte[] data, ulong sectorAddress, uint length);
 
         /// <summary>
-        ///     Writes a sector to the image with tags attached
+        ///     Writes a sector to the image with main channel tags attached
         /// </summary>
-        /// <param name="data">Sector data with its tags attached</param>
+        /// <param name="data">Sector data with its main channel tags attached</param>
         /// <param name="sectorAddress">Sector address</param>
         /// <returns><c>true</c> if operating completed successfully, <c>false</c> otherwise</returns>
         bool WriteSectorLong(byte[] data, ulong sectorAddress);
@@ -117,7 +117,7 @@ namespace DiscImageChef.DiscImages
         /// <summary>
         ///     Writes several sectors to the image
         /// </summary>
-        /// <param name="data">Sector data with their tags attached</param>
+        /// <param name="data">Sector data with their main channel tags attached</param>
         /// <param name="sectorAddress">Sector starting address</param>
         /// <param name="length">How many sectors to write</param>
         /// <returns><c>true</c> if operating completed successfully, <c>false</c> otherwise</returns>
@@ -151,5 +151,24 @@ namespace DiscImageChef.DiscImages
         /// <param name="sectorsPerTrack">Sectors per track</param>
         /// <returns><c>true</c> if operating completed successfully, <c>false</c> otherwise</returns>
         bool SetGeometry(uint cylinders, uint heads, uint sectorsPerTrack);
+
+        /// <summary>
+        ///     Writes parallel or subchannel sector tag for one sector
+        /// </summary>
+        /// <param name="data">Tag data to write</param>
+        /// <param name="sectorAddress">Sector address</param>
+        /// <param name="tag">Tag type</param>
+        /// <returns><c>true</c> if operating completed successfully, <c>false</c> otherwise</returns>
+        bool WriteSectorTag(byte[] data, ulong sectorAddress, SectorTagType tag);
+        
+        /// <summary>
+        ///     Writes parallel or subchannel sector tag for several sector
+        /// </summary>
+        /// <param name="data">Tag data to write</param>
+        /// <param name="sectorAddress">Starting sector address</param>
+        /// <param name="length">How many sectors to write</param>
+        /// <param name="tag">Tag type</param>
+        /// <returns><c>true</c> if operating completed successfully, <c>false</c> otherwise</returns>
+        bool WriteSectorsTag(byte[] data, ulong sectorAddress, uint length, SectorTagType tag);
     }
 }

DiscImageChef.DiscImages/MaxiDisk.cs

@@ -542,6 +542,18 @@ namespace DiscImageChef.DiscImages
             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;
+        }
+
         [StructLayout(LayoutKind.Sequential, Pack = 1)]
         struct HdkHeader
         {

DiscImageChef.DiscImages/NHDr0.cs

@@ -506,6 +506,18 @@ namespace DiscImageChef.DiscImages
             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;
+        }
+
         [StructLayout(LayoutKind.Sequential, Pack = 1)]
         struct Nhdr0Header
         {

DiscImageChef.DiscImages/RayDIM.cs

@@ -464,6 +464,18 @@ namespace DiscImageChef.DiscImages
             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;
+        }
+
         public bool Close()
         {
             if(!IsWriting)

DiscImageChef.DiscImages/RsIde.cs

@@ -571,6 +571,18 @@ namespace DiscImageChef.DiscImages
             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;
+        }
+
         static byte[] ScrambleATAString(string text, int length)
         {
             byte[] inbuf = Encoding.ASCII.GetBytes(text);

DiscImageChef.DiscImages/SaveDskF.cs

@@ -544,6 +544,18 @@ namespace DiscImageChef.DiscImages
             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;
+        }
+
         [StructLayout(LayoutKind.Sequential, Pack = 1)]
         struct SaveDskFHeader
         {

DiscImageChef.DiscImages/T98.cs

@@ -407,6 +407,18 @@ namespace DiscImageChef.DiscImages
             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;
+        }
+
         public bool SetMetadata(ImageInfo metadata)
         {
             return true;

DiscImageChef.DiscImages/VHD.cs

@@ -1323,6 +1323,18 @@ namespace DiscImageChef.DiscImages
             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;
+        }
+
         static uint VhdChecksum(IEnumerable<byte> data)
         {
             uint checksum = data.Aggregate<byte, uint>(0, (current, b) => current + b);

DiscImageChef.DiscImages/VMware.cs

@@ -1145,6 +1145,18 @@ namespace DiscImageChef.DiscImages
             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;
+        }
+
         [StructLayout(LayoutKind.Sequential, Pack = 1)]
         struct VMwareExtentHeader
         {

DiscImageChef.DiscImages/Virtual98.cs

@@ -518,6 +518,18 @@ namespace DiscImageChef.DiscImages
             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;
+        }
+
         [StructLayout(LayoutKind.Sequential, Pack = 1)]
         struct Virtual98Header
         {

DiscImageChef.DiscImages/ZZZRawImage.cs

@@ -1000,6 +1000,18 @@ namespace DiscImageChef.DiscImages
             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;
+        }
+
         public bool WriteMediaTag(byte[] data, MediaTagType tag)
         {
             // TODO: Implement

DiscImageChef/Commands/ConvertImage.cs

@@ -321,6 +321,69 @@ namespace DiscImageChef.Commands
                 DicConsole.Write("\rConverting sectors {0} to {1} ({2:P2} done)", inputFormat.Info.Sectors,
                                  inputFormat.Info.Sectors, 1.0);
                 DicConsole.WriteLine();
+
+                foreach(SectorTagType tag in inputFormat.Info.ReadableSectorTags)
+                {
+                    if(!useLong) break;
+
+                    switch(tag)
+                    {
+                        case SectorTagType.AppleSectorTag:
+                        case SectorTagType.CdSectorSync:
+                        case SectorTagType.CdSectorHeader:
+                        case SectorTagType.CdSectorSubHeader:
+                        case SectorTagType.CdSectorEdc:
+                        case SectorTagType.CdSectorEccP:
+                        case SectorTagType.CdSectorEccQ:
+                        case SectorTagType.CdSectorEcc:
+                            // This tags are inline in long sector
+                            continue;
+                    }
+
+                    doneSectors = 0;
+                    while(doneSectors < inputFormat.Info.Sectors)
+                    {
+                        byte[] sector;
+
+                        uint sectorsToDo;
+                        if(inputFormat.Info.Sectors - doneSectors >= (ulong)options.Count)
+                            sectorsToDo  = (uint)options.Count;
+                        else sectorsToDo = (uint)(inputFormat.Info.Sectors - doneSectors);
+
+                        DicConsole.Write("\rConverting tag {2} for sectors {0} to {1} ({2:P2} done)", doneSectors,
+                                         doneSectors + sectorsToDo, doneSectors / (double)inputFormat.Info.Sectors,
+                                         tag);
+
+                        bool result;
+                        if(sectorsToDo == 1)
+                        {
+                            sector = inputFormat.ReadSectorTag(doneSectors, tag);
+                            result = outputFormat.WriteSectorTag(sector, doneSectors, tag);
+                        }
+                        else
+                        {
+                            sector = inputFormat.ReadSectorsTag(doneSectors, sectorsToDo, tag);
+                            result = outputFormat.WriteSectorsTag(sector, doneSectors, sectorsToDo, tag);
+                        }
+
+                        if(!result)
+                            if(options.Force)
+                                DicConsole.ErrorWriteLine("Error {0} writing sector {1}, continuing...",
+                                                          outputFormat.ErrorMessage, doneSectors);
+                            else
+                            {
+                                DicConsole.ErrorWriteLine("Error {0} writing sector {1}, not continuing...",
+                                                          outputFormat.ErrorMessage, doneSectors);
+                                return;
+                            }
+
+                        doneSectors += sectorsToDo;
+                    }
+
+                    DicConsole.Write("\rConverting tag {2} for sectors {0} to {1} ({2:P2} done)",
+                                     inputFormat.Info.Sectors, inputFormat.Info.Sectors, 1.0, tag);
+                    DicConsole.WriteLine();
+                }
             }
             else
                 foreach(Track track in tracks)
@@ -389,6 +452,79 @@ namespace DiscImageChef.Commands
                     DicConsole.Write("\rConverting sectors {0} to {1} in track {3} ({2:P2} done)", trackSectors,
                                      trackSectors, 1.0, track.TrackSequence);
                     DicConsole.WriteLine();
+
+                    foreach(SectorTagType tag in inputFormat.Info.ReadableSectorTags)
+                    {
+                        if(!useLong) break;
+
+                        doneSectors = 0;
+                        byte[] sector;
+                        bool   result;
+
+                        switch(tag)
+                        {
+                            case SectorTagType.AppleSectorTag:
+                            case SectorTagType.CdSectorSync:
+                            case SectorTagType.CdSectorHeader:
+                            case SectorTagType.CdSectorSubHeader:
+                            case SectorTagType.CdSectorEdc:
+                            case SectorTagType.CdSectorEccP:
+                            case SectorTagType.CdSectorEccQ:
+                            case SectorTagType.CdSectorEcc:
+                                // This tags are inline in long sector
+                                continue;
+                            case SectorTagType.CdTrackFlags:
+                            case SectorTagType.CdTrackIsrc:
+                                DicConsole.Write("\rConverting tag {0} in track {1}.", tag, track.TrackSequence);
+                                DicConsole.WriteLine();
+                                sector = inputFormat.ReadSectorTag(track.TrackStartSector, tag);
+                                result = outputFormat.WriteSectorTag(sector, track.TrackStartSector, tag);
+                                continue;
+                        }
+
+                        while(doneSectors < trackSectors)
+                        {
+                            uint sectorsToDo;
+                            if(trackSectors - doneSectors >= (ulong)options.Count) sectorsToDo = (uint)options.Count;
+                            else
+                                sectorsToDo =
+                                    (uint)(trackSectors - doneSectors);
+
+                            DicConsole.Write("\rConverting tag {4} for sectors {0} to {1} in track {3} ({2:P2} done)",
+                                             doneSectors, doneSectors + sectorsToDo, doneSectors / (double)trackSectors,
+                                             track.TrackSequence, tag);
+
+                            if(sectorsToDo == 1)
+                            {
+                                sector = inputFormat.ReadSectorTag(doneSectors           + track.TrackStartSector, tag);
+                                result = outputFormat.WriteSectorTag(sector, doneSectors + track.TrackStartSector, tag);
+                            }
+                            else
+                            {
+                                sector = inputFormat.ReadSectorsTag(doneSectors + track.TrackStartSector, sectorsToDo,
+                                                                    tag);
+                                result = outputFormat.WriteSectorsTag(sector, doneSectors + track.TrackStartSector,
+                                                                      sectorsToDo, tag);
+                            }
+
+                            if(!result)
+                                if(options.Force)
+                                    DicConsole.ErrorWriteLine("Error {0} writing sector {1}, continuing...",
+                                                              outputFormat.ErrorMessage, doneSectors);
+                                else
+                                {
+                                    DicConsole.ErrorWriteLine("Error {0} writing sector {1}, not continuing...",
+                                                              outputFormat.ErrorMessage, doneSectors);
+                                    return;
+                                }
+
+                            doneSectors += sectorsToDo;
+                        }
+
+                        DicConsole.Write("\rConverting tag {4} for sectors {0} to {1} in track {3} ({2:P2} done)",
+                                         trackSectors, trackSectors, 1.0, track.TrackSequence, tag);
+                        DicConsole.WriteLine();
+                    }
                 }
 
             if(tracks == null)