Add writing support to cdrdao disc image.

DiscImageChef.DiscImages/CDRDAO.cs

@@ -46,7 +46,7 @@ namespace DiscImageChef.DiscImages
 {
     // TODO: Doesn't support compositing from several files
     // TODO: Doesn't support silences that are not in files
-    public class Cdrdao : IMediaImage
+    public class Cdrdao : IWritableImage
     {
         /// <summary>Audio track, 2352 bytes/sector</summary>
         const string CDRDAO_TRACK_TYPE_AUDIO = "AUDIO";
@@ -102,12 +102,19 @@ namespace DiscImageChef.DiscImages
         const string REGEX_LANGUAGE_MAPPING = @"^\s*(?<code>\d+)\s?\:\s?(?<language>\d+|\w+)";
 
         IFilter      cdrdaoFilter;
+        StreamWriter descriptorStream;
         CdrdaoDisc   discimage;
         ImageInfo    imageInfo;
         Stream       imageStream;
         /// <summary>Dictionary, index is track #, value is TrackFile</summary>
         Dictionary<uint, ulong>      offsetmap;
+        bool                         separateTracksWriting;
         StreamReader                 tocStream;
+        Dictionary<byte, byte>       trackFlags;
+        Dictionary<byte, string>     trackIsrcs;
+        string                       writingBaseName;
+        Dictionary<uint, FileStream> writingStreams;
+        List<Track>                  writingTracks;
 
         public Cdrdao()
         {
@@ -1469,6 +1476,604 @@ namespace DiscImageChef.DiscImages
             return null;
         }
 
+        // TODO: Decode CD-Text to text
+        public IEnumerable<MediaTagType>  SupportedMediaTags  => new[] {MediaTagType.CD_MCN};
+        public IEnumerable<SectorTagType> SupportedSectorTags =>
+            new[]
+            {
+                SectorTagType.CdSectorEcc, SectorTagType.CdSectorEccP, SectorTagType.CdSectorEccQ,
+                SectorTagType.CdSectorEdc, SectorTagType.CdSectorHeader, SectorTagType.CdSectorSubchannel,
+                SectorTagType.CdSectorSubHeader, SectorTagType.CdSectorSync, SectorTagType.CdTrackFlags,
+                SectorTagType.CdTrackIsrc
+            };
+        public IEnumerable<MediaType> SupportedMediaTypes =>
+            new[]
+            {
+                MediaType.CD, MediaType.CDDA, MediaType.CDEG, MediaType.CDG, MediaType.CDI, MediaType.CDMIDI,
+                MediaType.CDMRW, MediaType.CDPLUS, MediaType.CDR, MediaType.CDROM, MediaType.CDROMXA, MediaType.CDRW,
+                MediaType.CDV, MediaType.DDCD, MediaType.DDCDR, MediaType.DDCDRW, MediaType.JaguarCD, MediaType.MEGACD,
+                MediaType.PD650, MediaType.PD650_WORM, MediaType.PS1CD, MediaType.PS2CD, MediaType.SuperCDROM2,
+                MediaType.SVCD, MediaType.SATURNCD, MediaType.ThreeDO, MediaType.VCD, MediaType.VCDHD
+            };
+        public IEnumerable<(string name, Type type, string description)> SupportedOptions =>
+            new[] {("separate", typeof(bool), "Write each track to a separate file.")};
+        public IEnumerable<string> KnownExtensions => new[] {".toc"};
+        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)
+        {
+            if(options != null)
+            {
+                if(options.TryGetValue("separate", out string tmpValue))
+                {
+                    if(!bool.TryParse(tmpValue, out separateTracksWriting))
+                    {
+                        ErrorMessage = "Invalid value for split option";
+                        return false;
+                    }
+
+                    if(separateTracksWriting)
+                    {
+                        ErrorMessage = "Separate tracksnot yet implemented";
+                        return false;
+                    }
+                }
+            }
+            else separateTracksWriting = false;
+
+            if(!SupportedMediaTypes.Contains(mediaType))
+            {
+                ErrorMessage = $"Unsupport media format {mediaType}";
+                return false;
+            }
+
+            imageInfo = new ImageInfo {MediaType = mediaType, SectorSize = sectorSize, Sectors = sectors};
+
+            // TODO: Separate tracks
+            try
+            {
+                writingBaseName  = Path.Combine(Path.GetDirectoryName(path), Path.GetFileNameWithoutExtension(path));
+                descriptorStream = new StreamWriter(path, false, Encoding.ASCII);
+            }
+            catch(IOException e)
+            {
+                ErrorMessage = $"Could not create new image file, exception {e.Message}";
+                return false;
+            }
+
+            discimage = new CdrdaoDisc {Disktype = mediaType, Tracks = new List<CdrdaoTrack>()};
+
+            trackFlags = new Dictionary<byte, byte>();
+            trackIsrcs = new Dictionary<byte, string>();
+
+            IsWriting    = true;
+            ErrorMessage = null;
+            return true;
+        }
+
+        public bool WriteMediaTag(byte[] data, MediaTagType tag)
+        {
+            if(!IsWriting)
+            {
+                ErrorMessage = "Tried to write on a non-writable image";
+                return false;
+            }
+
+            switch(tag)
+            {
+                case MediaTagType.CD_MCN:
+                    discimage.Mcn = Encoding.ASCII.GetString(data);
+                    return true;
+                default:
+                    ErrorMessage = $"Unsupported media tag {tag}";
+                    return false;
+            }
+        }
+
+        public bool WriteSector(byte[] data, ulong sectorAddress)
+        {
+            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;
+            }
+
+            FileStream trackStream = writingStreams.FirstOrDefault(kvp => kvp.Key == track.TrackSequence).Value;
+
+            if(trackStream == null)
+            {
+                ErrorMessage = $"Can't found file containing {sectorAddress}";
+                return false;
+            }
+
+            if(track.TrackBytesPerSector != track.TrackRawBytesPerSector)
+            {
+                ErrorMessage = "Invalid write mode for this sector";
+                return false;
+            }
+
+            if(data.Length != track.TrackRawBytesPerSector)
+            {
+                ErrorMessage = "Incorrect data size";
+                return false;
+            }
+
+            if(track.TrackSubchannelType != TrackSubchannelType.None)
+            {
+                ErrorMessage = "Invalid subchannel mode for this sector";
+                return false;
+            }
+
+            trackStream.Seek((long)(track.TrackFileOffset + (sectorAddress - track.TrackStartSector) * (ulong)track.TrackRawBytesPerSector),
+                             SeekOrigin.Begin);
+            trackStream.Write(data, 0, data.Length);
+
+            return true;
+        }
+
+        public bool WriteSectors(byte[] data, ulong sectorAddress, uint length)
+        {
+            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;
+            }
+
+            FileStream trackStream = writingStreams.FirstOrDefault(kvp => kvp.Key == track.TrackSequence).Value;
+
+            if(trackStream == null)
+            {
+                ErrorMessage = $"Can't found file containing {sectorAddress}";
+                return false;
+            }
+
+            if(track.TrackBytesPerSector != track.TrackRawBytesPerSector)
+            {
+                ErrorMessage = "Invalid write mode for this sector";
+                return false;
+            }
+
+            if(sectorAddress + length > track.TrackEndSector + 1)
+            {
+                ErrorMessage = "Can't cross tracks";
+                return false;
+            }
+
+            if(data.Length % track.TrackRawBytesPerSector != 0)
+            {
+                ErrorMessage = "Incorrect data size";
+                return false;
+            }
+
+            if(track.TrackSubchannelType != TrackSubchannelType.None)
+            {
+                ErrorMessage = "Invalid subchannel mode for this sector";
+                return false;
+            }
+
+            trackStream.Seek((long)(track.TrackFileOffset + (sectorAddress - track.TrackStartSector) * (ulong)track.TrackRawBytesPerSector),
+                             SeekOrigin.Begin);
+            trackStream.Write(data, 0, data.Length);
+
+            return true;
+        }
+
+        public bool WriteSectorLong(byte[] data, ulong sectorAddress)
+        {
+            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;
+            }
+
+            FileStream trackStream = writingStreams.FirstOrDefault(kvp => kvp.Key == track.TrackSequence).Value;
+
+            if(trackStream == null)
+            {
+                ErrorMessage = $"Can't found file containing {sectorAddress}";
+                return false;
+            }
+
+            if(data.Length != track.TrackRawBytesPerSector)
+            {
+                ErrorMessage = "Incorrect data size";
+                return false;
+            }
+
+            uint subchannelSize = (uint)(track.TrackSubchannelType != TrackSubchannelType.None ? 96 : 0);
+
+            trackStream.Seek((long)(track.TrackFileOffset + (sectorAddress - track.TrackStartSector) * (ulong)(track.TrackRawBytesPerSector + subchannelSize)),
+                             SeekOrigin.Begin);
+            trackStream.Write(data, 0, data.Length);
+
+            return true;
+        }
+
+        public bool WriteSectorsLong(byte[] data, ulong sectorAddress, uint length)
+        {
+            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;
+            }
+
+            FileStream trackStream = writingStreams.FirstOrDefault(kvp => kvp.Key == track.TrackSequence).Value;
+
+            if(trackStream == null)
+            {
+                ErrorMessage = $"Can't found file containing {sectorAddress}";
+                return false;
+            }
+
+            if(sectorAddress + length > track.TrackEndSector + 1)
+            {
+                ErrorMessage = "Can't cross tracks";
+                return false;
+            }
+
+            if(data.Length % track.TrackRawBytesPerSector != 0)
+            {
+                ErrorMessage = "Incorrect data size";
+                return false;
+            }
+
+            uint subchannelSize = (uint)(track.TrackSubchannelType != TrackSubchannelType.None ? 96 : 0);
+
+            for(uint i = 0; i < length; i++)
+            {
+                trackStream.Seek((long)(track.TrackFileOffset + (i + sectorAddress - track.TrackStartSector) * (ulong)(track.TrackRawBytesPerSector + subchannelSize)),
+                                 SeekOrigin.Begin);
+                trackStream.Write(data, (int)(i * track.TrackRawBytesPerSector), track.TrackRawBytesPerSector);
+            }
+
+            return true;
+        }
+
+        public bool SetTracks(List<Track> tracks)
+        {
+            if(!IsWriting)
+            {
+                ErrorMessage = "Tried to write on a non-writable image";
+                return false;
+            }
+
+            if(tracks == null || tracks.Count == 0)
+            {
+                ErrorMessage = "Invalid tracks sent";
+                return false;
+            }
+
+            ulong currentOffset = 0;
+            writingTracks       = new List<Track>();
+            foreach(Track track in tracks.OrderBy(t => t.TrackSequence))
+            {
+                if(track.TrackSubchannelType == TrackSubchannelType.Q16 ||
+                   track.TrackSubchannelType == TrackSubchannelType.Q16Interleaved)
+                {
+                    ErrorMessage =
+                        $"Unsupported subchannel type {track.TrackSubchannelType} for track {track.TrackSequence}";
+                    return false;
+                }
+
+                Track newTrack     = track;
+                newTrack.TrackFile = separateTracksWriting
+                                         ? writingBaseName + $"_track{track.TrackSequence:D2}.bin"
+                                         : writingBaseName + ".bin";
+                newTrack.TrackFileOffset = separateTracksWriting ? 0 : currentOffset;
+                writingTracks.Add(newTrack);
+                currentOffset += (ulong)newTrack.TrackRawBytesPerSector *
+                                 (newTrack.TrackEndSector - newTrack.TrackStartSector + 1);
+
+                if(track.TrackSubchannelType != TrackSubchannelType.None)
+                    currentOffset += 96 * (newTrack.TrackEndSector - newTrack.TrackStartSector + 1);
+            }
+
+            writingStreams = new Dictionary<uint, FileStream>();
+            if(separateTracksWriting)
+                foreach(Track track in writingTracks)
+                    writingStreams.Add(track.TrackSequence,
+                                       new FileStream(track.TrackFile, FileMode.CreateNew, FileAccess.ReadWrite,
+                                                      FileShare.None));
+            else
+            {
+                FileStream jointstream = new FileStream(writingBaseName + ".bin", FileMode.CreateNew,
+                                                        FileAccess.ReadWrite, FileShare.None);
+                foreach(Track track in writingTracks) writingStreams.Add(track.TrackSequence, jointstream);
+            }
+
+            return true;
+        }
+
+        public bool Close()
+        {
+            if(!IsWriting)
+            {
+                ErrorMessage = "Image is not opened for writing";
+                return false;
+            }
+
+            if(separateTracksWriting)
+                foreach(FileStream writingStream in writingStreams.Values)
+                {
+                    writingStream.Flush();
+                    writingStream.Close();
+                }
+            else
+            {
+                writingStreams.First().Value.Flush();
+                writingStreams.First().Value.Close();
+            }
+
+            bool data  = writingTracks.Count(t => t.TrackType != TrackType.Audio) > 0;
+            bool mode2 = writingTracks.Count(t => t.TrackType == TrackType.CdMode2Form1 ||
+                                                  t.TrackType == TrackType.CdMode2Form2 ||
+                                                  t.TrackType == TrackType.CdMode2Formless) > 0;
+
+            if(mode2) descriptorStream.WriteLine("CD_ROM_XA");
+            else if(data)
+                descriptorStream.WriteLine("CD_ROM");
+            else
+                descriptorStream.WriteLine("CD_DA");
+
+            if(!string.IsNullOrWhiteSpace(discimage.Comment))
+            {
+                string[] commentLines = discimage.Comment.Split(new[] {'\n'}, StringSplitOptions.RemoveEmptyEntries);
+                foreach(string line in commentLines) descriptorStream.WriteLine("// {0}", line);
+            }
+
+            descriptorStream.WriteLine();
+
+            if(!string.IsNullOrEmpty(discimage.Mcn)) descriptorStream.WriteLine("CATALOG {0}", discimage.Mcn);
+
+            foreach(Track track in writingTracks)
+            {
+                descriptorStream.WriteLine();
+                descriptorStream.WriteLine("// Track {0}", track.TrackSequence);
+
+                string subchannelType;
+
+                switch(track.TrackSubchannelType)
+                {
+                    case TrackSubchannelType.Packed:
+                    case TrackSubchannelType.PackedInterleaved:
+                        subchannelType = " RW";
+                        break;
+                    case TrackSubchannelType.Raw:
+                    case TrackSubchannelType.RawInterleaved:
+                        subchannelType = " RW_RAW";
+                        break;
+                    default:
+                        subchannelType = "";
+                        break;
+                }
+
+                descriptorStream.WriteLine("TRACK {0}{1}", GetTrackMode(track), subchannelType);
+
+                trackFlags.TryGetValue((byte)track.TrackSequence, out byte flagsByte);
+
+                CdFlags flags = (CdFlags)flagsByte;
+
+                descriptorStream.WriteLine("{0}COPY", flags.HasFlag(CdFlags.CopyPermitted) ? "" : "NO ");
+
+                if(track.TrackType == TrackType.Audio)
+                {
+                    descriptorStream.WriteLine("{0}PRE_EMPHASIS", flags.HasFlag(CdFlags.PreEmphasis) ? "" : "NO ");
+                    descriptorStream.WriteLine("{0}_CHANNEL_AUDIO",
+                                               flags.HasFlag(CdFlags.FourChannel) ? "FOUR" : "TWO");
+                }
+
+                if(trackIsrcs.TryGetValue((byte)track.TrackSequence, out string isrc))
+                    descriptorStream.WriteLine("ISRC {0}", isrc);
+
+                (byte minute, byte second, byte frame)
+                    msf = LbaToMsf(track.TrackEndSector - track.TrackStartSector + 1);
+
+                descriptorStream.WriteLine("DATAFILE \"{0}\" #{1} {2:D2}:{3:D2}:{4:D2} // length in bytes: {5}",
+                                           Path.GetFileName(track.TrackFile), track.TrackFileOffset, msf.minute,
+                                           msf.second, msf.frame,
+                                           (track.TrackEndSector                - track.TrackStartSector + 1) *
+                                           (ulong)(track.TrackRawBytesPerSector +
+                                                   (track.TrackSubchannelType != TrackSubchannelType.None ? 96 : 0)));
+
+                descriptorStream.WriteLine();
+            }
+
+            descriptorStream.Flush();
+            descriptorStream.Close();
+            IsWriting = false;
+
+            return true;
+        }
+
+        public bool SetMetadata(ImageInfo metadata)
+        {
+            discimage.Barcode = metadata.MediaBarcode;
+            discimage.Comment = metadata.Comments;
+            return true;
+        }
+
+        public bool SetGeometry(uint cylinders, uint heads, uint sectorsPerTrack)
+        {
+            ErrorMessage = "Unsupported feature";
+            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;
+                }
+                case SectorTagType.CdSectorSubchannel:
+                {
+                    if(track.TrackSubchannelType == 0)
+                    {
+                        ErrorMessage =
+                            $"Trying to write subchannel to track {track.TrackSequence}, that does not have subchannel";
+                        return false;
+                    }
+
+                    if(data.Length != 96)
+                    {
+                        ErrorMessage = "Incorrect data size for subchannel";
+                        return false;
+                    }
+
+                    FileStream trackStream = writingStreams.FirstOrDefault(kvp => kvp.Key == track.TrackSequence).Value;
+
+                    if(trackStream == null)
+                    {
+                        ErrorMessage = $"Can't found file containing {sectorAddress}";
+                        return false;
+                    }
+
+                    trackStream
+                       .Seek((long)(track.TrackFileOffset + (sectorAddress - track.TrackStartSector) * (ulong)(track.TrackRawBytesPerSector + 96)) + track.TrackRawBytesPerSector,
+                             SeekOrigin.Begin);
+                    trackStream.Write(data, 0, data.Length);
+
+                    return true;
+                }
+                default:
+                    ErrorMessage = $"Unsupported tag type {tag}";
+                    return false;
+            }
+        }
+
+        public bool WriteSectorsTag(byte[] data, ulong sectorAddress, uint length, 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:
+                case SectorTagType.CdTrackIsrc: return WriteSectorTag(data, sectorAddress, tag);
+                case SectorTagType.CdSectorSubchannel:
+                {
+                    if(track.TrackSubchannelType == 0)
+                    {
+                        ErrorMessage =
+                            $"Trying to write subchannel to track {track.TrackSequence}, that does not have subchannel";
+                        return false;
+                    }
+
+                    if(data.Length % 96 != 0)
+                    {
+                        ErrorMessage = "Incorrect data size for subchannel";
+                        return false;
+                    }
+
+                    FileStream trackStream = writingStreams.FirstOrDefault(kvp => kvp.Key == track.TrackSequence).Value;
+
+                    if(trackStream == null)
+                    {
+                        ErrorMessage = $"Can't found file containing {sectorAddress}";
+                        return false;
+                    }
+
+                    for(uint i = 0; i < length; i++)
+                    {
+                        trackStream
+                           .Seek((long)(track.TrackFileOffset + (i + sectorAddress - track.TrackStartSector) * (ulong)(track.TrackRawBytesPerSector + 96)) + track.TrackRawBytesPerSector,
+                                 SeekOrigin.Begin);
+                        trackStream.Write(data, (int)(i * 96), 96);
+                    }
+
+                    return true;
+                }
+                default:
+                    ErrorMessage = $"Unsupported tag type {tag}";
+                    return false;
+            }
+        }
+
         static ushort CdrdaoTrackTypeToBytesPerSector(string trackType)
         {
             switch(trackType)
@@ -1517,6 +2122,35 @@ namespace DiscImageChef.DiscImages
             }
         }
 
+        static (byte minute, byte second, byte frame) LbaToMsf(ulong sector)
+        {
+            return ((byte)(sector / 75 / 60), (byte)(sector / 75 % 60), (byte)(sector % 75));
+        }
+
+        static string GetTrackMode(Track track)
+        {
+            switch(track.TrackType)
+            {
+                case TrackType.Audio when track.TrackRawBytesPerSector == 2352:
+                    return CDRDAO_TRACK_TYPE_AUDIO;
+                case TrackType.Data:
+                    return CDRDAO_TRACK_TYPE_MODE1;
+                case TrackType.CdMode1 when track.TrackRawBytesPerSector == 2352:
+                    return CDRDAO_TRACK_TYPE_MODE1_RAW;
+                case TrackType.CdMode2Formless when track.TrackRawBytesPerSector != 2352:
+                    return CDRDAO_TRACK_TYPE_MODE2;
+                case TrackType.CdMode2Form1 when track.TrackRawBytesPerSector != 2352:
+                    return CDRDAO_TRACK_TYPE_MODE2_FORM1;
+                case TrackType.CdMode2Form2 when track.TrackRawBytesPerSector != 2352:
+                    return CDRDAO_TRACK_TYPE_MODE2_FORM2;
+                case TrackType.CdMode2Formless when track.TrackRawBytesPerSector == 2352:
+                case TrackType.CdMode2Form1 when track.TrackRawBytesPerSector    == 2352:
+                case TrackType.CdMode2Form2 when track.TrackRawBytesPerSector    == 2352:
+                    return CDRDAO_TRACK_TYPE_MODE2_RAW;
+                default: return CDRDAO_TRACK_TYPE_MODE1;
+            }
+        }
+
         [SuppressMessage("ReSharper", "NotAccessedField.Local")]
         struct CdrdaoTrackFile
         {