Renamed project files and folders

Aaru.Core/Devices/Dumping/CompactDisc/Data.cs

@@ -0,0 +1,428 @@
+// /***************************************************************************
+// The Disc Image Chef
+// ----------------------------------------------------------------------------
+//
+// Filename       : CompactDisc.cs
+// Author(s)      : Natalia Portillo <claunia@claunia.com>
+//
+// Component      : Core algorithms.
+//
+// --[ Description ] ----------------------------------------------------------
+//
+//     Dumps CDs and DDCDs.
+//
+// --[ License ] --------------------------------------------------------------
+//
+//     This program is free software: you can redistribute it and/or modify
+//     it under the terms of the GNU General Public License as
+//     published by the Free Software Foundation, either version 3 of the
+//     License, or (at your option) any later version.
+//
+//     This program is distributed in the hope that it will be useful,
+//     but WITHOUT ANY WARRANTY; without even the implied warranty of
+//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//     GNU General Public License for more details.
+//
+//     You should have received a copy of the GNU General Public License
+//     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ----------------------------------------------------------------------------
+// Copyright © 2011-2020 Natalia Portillo
+// ****************************************************************************/
+
+using System;
+using System.Linq;
+using DiscImageChef.CommonTypes.Enums;
+using DiscImageChef.CommonTypes.Extents;
+using DiscImageChef.CommonTypes.Structs;
+using DiscImageChef.Console;
+using DiscImageChef.Core.Logging;
+using DiscImageChef.Decoders.SCSI;
+using DiscImageChef.Devices;
+using Schemas;
+
+// ReSharper disable JoinDeclarationAndInitializer
+// ReSharper disable InlineOutVariableDeclaration
+// ReSharper disable TooWideLocalVariableScope
+
+namespace DiscImageChef.Core.Devices.Dumping
+{
+    partial class Dump
+    {
+        /// <summary>Reads all CD user data</summary>
+        /// <param name="audioExtents">Extents with audio sectors</param>
+        /// <param name="blocks">Total number of positive sectors</param>
+        /// <param name="blockSize">Size of the read sector in bytes</param>
+        /// <param name="currentSpeed">Current read speed</param>
+        /// <param name="currentTry">Current dump hardware try</param>
+        /// <param name="extents">Extents</param>
+        /// <param name="ibgLog">IMGBurn log</param>
+        /// <param name="imageWriteDuration">Duration of image write</param>
+        /// <param name="lastSector">Last sector number</param>
+        /// <param name="leadOutExtents">Lead-out extents</param>
+        /// <param name="maxSpeed">Maximum speed</param>
+        /// <param name="mhddLog">MHDD log</param>
+        /// <param name="minSpeed">Minimum speed</param>
+        /// <param name="newTrim">Is trim a new one?</param>
+        /// <param name="nextData">Next cluster of sectors is all data</param>
+        /// <param name="offsetBytes">Read offset</param>
+        /// <param name="read6">Device supports READ(6)</param>
+        /// <param name="read10">Device supports READ(10)</param>
+        /// <param name="read12">Device supports READ(12)</param>
+        /// <param name="read16">Device supports READ(16)</param>
+        /// <param name="readcd">Device supports READ CD</param>
+        /// <param name="sectorsForOffset">Sectors needed to fix offset</param>
+        /// <param name="subSize">Subchannel size in bytes</param>
+        /// <param name="supportedSubchannel">Drive's maximum supported subchannel</param>
+        /// <param name="supportsLongSectors">Supports reading EDC and ECC</param>
+        /// <param name="totalDuration">Total commands duration</param>
+        void ReadCdData(ExtentsULong audioExtents, ulong blocks, uint blockSize, ref double currentSpeed,
+                        DumpHardwareType currentTry, ExtentsULong extents, IbgLog ibgLog, ref double imageWriteDuration,
+                        long lastSector, ExtentsULong leadOutExtents, ref double maxSpeed, MhddLog mhddLog,
+                        ref double minSpeed, out bool newTrim, bool nextData, int offsetBytes, bool read6, bool read10,
+                        bool read12, bool read16, bool readcd, int sectorsForOffset, uint subSize,
+                        MmcSubchannel supportedSubchannel, bool supportsLongSectors, ref double totalDuration,
+                        Track[] tracks)
+        {
+            ulong      sectorSpeedStart = 0;               // Used to calculate correct speed
+            DateTime   timeSpeedStart   = DateTime.UtcNow; // Time of start for speed calculation
+            uint       blocksToRead     = 0;               // How many sectors to read at once
+            bool       sense            = true;            // Sense indicator
+            byte[]     cmdBuf           = null;            // Data buffer
+            byte[]     senseBuf         = null;            // Sense buffer
+            double     cmdDuration      = 0;               // Command execution time
+            const uint sectorSize       = 2352;            // Full sector size
+            byte[]     tmpBuf;                             // Temporary buffer
+            newTrim = false;
+
+            InitProgress?.Invoke();
+
+            bool crossingLeadOut       = false;
+            bool failedCrossingLeadOut = false;
+
+            for(ulong i = _resume.NextBlock; (long)i <= lastSector; i += blocksToRead)
+            {
+                if(_aborted)
+                {
+                    currentTry.Extents = ExtentsConverter.ToMetadata(extents);
+                    UpdateStatus?.Invoke("Aborted!");
+                    _dumpLog.WriteLine("Aborted!");
+
+                    break;
+                }
+
+                while(leadOutExtents.Contains(i))
+                {
+                    i++;
+                }
+
+                if((long)i > lastSector)
+                    break;
+
+                uint firstSectorToRead = (uint)i;
+
+                Track track = tracks.OrderBy(t => t.TrackStartSector).LastOrDefault(t => i >= t.TrackStartSector);
+
+                blocksToRead = 0;
+                bool inData = nextData;
+
+                for(ulong j = i; j < i + _maximumReadable; j++)
+                {
+                    if(j > (ulong)lastSector)
+                    {
+                        if(!failedCrossingLeadOut)
+                            blocksToRead += (uint)sectorsForOffset;
+
+                        if(sectorsForOffset > 0)
+                            crossingLeadOut = true;
+
+                        break;
+                    }
+
+                    if(nextData)
+                    {
+                        if(audioExtents.Contains(j))
+                        {
+                            nextData = false;
+
+                            break;
+                        }
+
+                        blocksToRead++;
+                    }
+                    else
+                    {
+                        if(!audioExtents.Contains(j))
+                        {
+                            nextData = true;
+
+                            break;
+                        }
+
+                        blocksToRead++;
+                    }
+                }
+
+                if(track.TrackSequence                          != 0 &&
+                   (i + blocksToRead) - (ulong)sectorsForOffset > track.TrackEndSector + 1)
+                    blocksToRead = (uint)(((track.TrackEndSector + 1) - i) + (ulong)sectorsForOffset);
+
+                if(blocksToRead == 1)
+                    blocksToRead += (uint)sectorsForOffset;
+
+                if(_fixOffset && !inData)
+                {
+                    // TODO: FreeBSD bug
+                    if(offsetBytes < 0)
+                    {
+                        if(i == 0)
+                            firstSectorToRead = uint.MaxValue - (uint)(sectorsForOffset - 1); // -1
+                        else
+                            firstSectorToRead -= (uint)sectorsForOffset;
+                    }
+                }
+
+                #pragma warning disable RECS0018 // Comparison of floating point numbers with equality operator
+
+                // ReSharper disable CompareOfFloatsByEqualityOperator
+                if(currentSpeed > maxSpeed &&
+                   currentSpeed != 0)
+                    maxSpeed = currentSpeed;
+
+                if(currentSpeed < minSpeed &&
+                   currentSpeed != 0)
+                    minSpeed = currentSpeed;
+
+                // ReSharper restore CompareOfFloatsByEqualityOperator
+
+                #pragma warning restore RECS0018 // Comparison of floating point numbers with equality operator
+
+                UpdateProgress?.Invoke($"Reading sector {i} of {blocks} ({currentSpeed:F3} MiB/sec.)", (long)i,
+                                       (long)blocks);
+
+                if(readcd)
+                {
+                    sense = _dev.ReadCd(out cmdBuf, out senseBuf, firstSectorToRead, blockSize, blocksToRead,
+                                        MmcSectorTypes.AllTypes, false, false, true, MmcHeaderCodes.AllHeaders, true,
+                                        true, MmcErrorField.None, supportedSubchannel, _dev.Timeout, out cmdDuration);
+
+                    totalDuration += cmdDuration;
+                }
+                else if(read16)
+                {
+                    sense = _dev.Read16(out cmdBuf, out senseBuf, 0, false, true, false, firstSectorToRead, blockSize,
+                                        0, blocksToRead, false, _dev.Timeout, out cmdDuration);
+                }
+                else if(read12)
+                {
+                    sense = _dev.Read12(out cmdBuf, out senseBuf, 0, false, true, false, false, firstSectorToRead,
+                                        blockSize, 0, blocksToRead, false, _dev.Timeout, out cmdDuration);
+                }
+                else if(read10)
+                {
+                    sense = _dev.Read10(out cmdBuf, out senseBuf, 0, false, true, false, false, firstSectorToRead,
+                                        blockSize, 0, (ushort)blocksToRead, _dev.Timeout, out cmdDuration);
+                }
+                else if(read6)
+                {
+                    sense = _dev.Read6(out cmdBuf, out senseBuf, firstSectorToRead, blockSize, (byte)blocksToRead,
+                                       _dev.Timeout, out cmdDuration);
+                }
+
+                if(!sense &&
+                   !_dev.Error)
+                {
+                    // Because one block has been partially used to fix the offset
+                    if(_fixOffset &&
+                       !inData    &&
+                       offsetBytes != 0)
+                    {
+                        int offsetFix = offsetBytes < 0 ? (int)(sectorSize - (offsetBytes * -1)) : offsetBytes;
+
+                        if(supportedSubchannel != MmcSubchannel.None)
+                        {
+                            // De-interleave subchannel
+                            byte[] data = new byte[sectorSize * blocksToRead];
+                            byte[] sub  = new byte[subSize    * blocksToRead];
+
+                            for(int b = 0; b < blocksToRead; b++)
+                            {
+                                Array.Copy(cmdBuf, (int)(0 + (b * blockSize)), data, sectorSize * b,
+                                           sectorSize);
+
+                                Array.Copy(cmdBuf, (int)(sectorSize + (b * blockSize)), sub, subSize * b, subSize);
+                            }
+
+                            if(failedCrossingLeadOut)
+                            {
+                                blocksToRead += (uint)sectorsForOffset;
+
+                                tmpBuf = new byte[sectorSize * blocksToRead];
+                                Array.Copy(data, 0, tmpBuf, 0, data.Length);
+                                data   = tmpBuf;
+                                tmpBuf = new byte[subSize * blocksToRead];
+                                Array.Copy(sub, 0, tmpBuf, 0, sub.Length);
+                                sub = tmpBuf;
+                            }
+
+                            tmpBuf = new byte[sectorSize * (blocksToRead - sectorsForOffset)];
+                            Array.Copy(data, offsetFix, tmpBuf, 0, tmpBuf.Length);
+                            data = tmpBuf;
+
+                            blocksToRead -= (uint)sectorsForOffset;
+
+                            // Re-interleave subchannel
+                            cmdBuf = new byte[blockSize * blocksToRead];
+
+                            for(int b = 0; b < blocksToRead; b++)
+                            {
+                                Array.Copy(data, sectorSize * b, cmdBuf, (int)(0 + (b * blockSize)),
+                                           sectorSize);
+
+                                Array.Copy(sub, subSize * b, cmdBuf, (int)(sectorSize + (b * blockSize)), subSize);
+                            }
+                        }
+                        else
+                        {
+                            if(failedCrossingLeadOut)
+                            {
+                                blocksToRead += (uint)sectorsForOffset;
+
+                                tmpBuf = new byte[blockSize * blocksToRead];
+                                Array.Copy(cmdBuf, 0, tmpBuf, 0, cmdBuf.Length);
+                                cmdBuf = tmpBuf;
+                            }
+
+                            tmpBuf = new byte[blockSize * (blocksToRead - sectorsForOffset)];
+                            Array.Copy(cmdBuf, offsetFix, tmpBuf, 0, tmpBuf.Length);
+                            cmdBuf       =  tmpBuf;
+                            blocksToRead -= (uint)sectorsForOffset;
+                        }
+                    }
+
+                    mhddLog.Write(i, cmdDuration);
+                    ibgLog.Write(i, currentSpeed * 1024);
+                    extents.Add(i, blocksToRead, true);
+                    DateTime writeStart = DateTime.Now;
+
+                    if(supportedSubchannel != MmcSubchannel.None)
+                    {
+                        byte[] data = new byte[sectorSize * blocksToRead];
+                        byte[] sub  = new byte[subSize    * blocksToRead];
+
+                        for(int b = 0; b < blocksToRead; b++)
+                        {
+                            Array.Copy(cmdBuf, (int)(0 + (b * blockSize)), data, sectorSize * b, sectorSize);
+
+                            Array.Copy(cmdBuf, (int)(sectorSize + (b * blockSize)), sub, subSize * b, subSize);
+                        }
+
+                        _outputPlugin.WriteSectorsLong(data, i, blocksToRead);
+                        _outputPlugin.WriteSectorsTag(sub, i, blocksToRead, SectorTagType.CdSectorSubchannel);
+                    }
+                    else
+                    {
+                        if(supportsLongSectors)
+                        {
+                            _outputPlugin.WriteSectorsLong(cmdBuf, i, blocksToRead);
+                        }
+                        else
+                        {
+                            if(cmdBuf.Length % sectorSize == 0)
+                            {
+                                byte[] data = new byte[2048 * blocksToRead];
+
+                                for(int b = 0; b < blocksToRead; b++)
+                                    Array.Copy(cmdBuf, (int)(16 + (b * blockSize)), data, 2048 * b, 2048);
+
+                                _outputPlugin.WriteSectors(data, i, blocksToRead);
+                            }
+                            else
+                            {
+                                _outputPlugin.WriteSectorsLong(cmdBuf, i, blocksToRead);
+                            }
+                        }
+                    }
+
+                    imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
+                }
+                else
+                {
+                    if(crossingLeadOut && Sense.DecodeFixed(senseBuf)?.ASC == 0x21)
+                    {
+                        failedCrossingLeadOut = true;
+                        blocksToRead          = 0;
+
+                        continue;
+                    }
+
+                    // TODO: Reset device after X errors
+                    if(_stopOnError)
+                        return; // TODO: Return more cleanly
+
+                    if(i + _skip > blocks)
+                        _skip = (uint)(blocks - i);
+
+                    // Write empty data
+                    DateTime writeStart = DateTime.Now;
+
+                    if(supportedSubchannel != MmcSubchannel.None)
+                    {
+                        _outputPlugin.WriteSectorsLong(new byte[sectorSize * _skip], i, _skip);
+
+                        _outputPlugin.WriteSectorsTag(new byte[subSize * _skip], i, _skip,
+                                                      SectorTagType.CdSectorSubchannel);
+                    }
+                    else
+                    {
+                        if(supportsLongSectors)
+                        {
+                            _outputPlugin.WriteSectorsLong(new byte[blockSize * _skip], i, _skip);
+                        }
+                        else
+                        {
+                            if(cmdBuf.Length % sectorSize == 0)
+                                _outputPlugin.WriteSectors(new byte[2048 * _skip], i, _skip);
+                            else
+                                _outputPlugin.WriteSectorsLong(new byte[blockSize * _skip], i, _skip);
+                        }
+                    }
+
+                    imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
+
+                    for(ulong b = i; b < i + _skip; b++)
+                        _resume.BadBlocks.Add(b);
+
+                    DicConsole.DebugWriteLine("Dump-Media", "READ error:\n{0}", Sense.PrettifySense(senseBuf));
+                    mhddLog.Write(i, cmdDuration < 500 ? 65535 : cmdDuration);
+
+                    ibgLog.Write(i, 0);
+                    _dumpLog.WriteLine("Skipping {0} blocks from errored block {1}.", _skip, i);
+                    i       += _skip - blocksToRead;
+                    newTrim =  true;
+                }
+
+                sectorSpeedStart += blocksToRead;
+
+                _resume.NextBlock = i + blocksToRead;
+
+                double elapsed = (DateTime.UtcNow - timeSpeedStart).TotalSeconds;
+
+                if(elapsed < 1)
+                    continue;
+
+                currentSpeed     = (sectorSpeedStart * blockSize) / (1048576 * elapsed);
+                sectorSpeedStart = 0;
+                timeSpeedStart   = DateTime.UtcNow;
+            }
+
+            EndProgress?.Invoke();
+
+            if(!failedCrossingLeadOut)
+                return;
+
+            _dumpLog.WriteLine("Failed crossing into Lead-Out, dump may not be correct.");
+            UpdateStatus?.Invoke("Failed crossing into Lead-Out, dump may not be correct.");
+        }
+    }
+}

Aaru.Core/Devices/Dumping/CompactDisc/Error.cs

@@ -0,0 +1,412 @@
+// /***************************************************************************
+// The Disc Image Chef
+// ----------------------------------------------------------------------------
+//
+// Filename       : CompactDisc.cs
+// Author(s)      : Natalia Portillo <claunia@claunia.com>
+//
+// Component      : Core algorithms.
+//
+// --[ Description ] ----------------------------------------------------------
+//
+//     Dumps CDs and DDCDs.
+//
+// --[ License ] --------------------------------------------------------------
+//
+//     This program is free software: you can redistribute it and/or modify
+//     it under the terms of the GNU General Public License as
+//     published by the Free Software Foundation, either version 3 of the
+//     License, or (at your option) any later version.
+//
+//     This program is distributed in the hope that it will be useful,
+//     but WITHOUT ANY WARRANTY; without even the implied warranty of
+//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//     GNU General Public License for more details.
+//
+//     You should have received a copy of the GNU General Public License
+//     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ----------------------------------------------------------------------------
+// Copyright © 2011-2020 Natalia Portillo
+// ****************************************************************************/
+
+using System;
+using System.Collections.Generic;
+using DiscImageChef.CommonTypes.Enums;
+using DiscImageChef.CommonTypes.Extents;
+using DiscImageChef.CommonTypes.Structs.Devices.SCSI;
+using DiscImageChef.Console;
+using DiscImageChef.Decoders.SCSI;
+using DiscImageChef.Devices;
+using Schemas;
+
+// ReSharper disable JoinDeclarationAndInitializer
+// ReSharper disable InlineOutVariableDeclaration
+// ReSharper disable TooWideLocalVariableScope
+
+namespace DiscImageChef.Core.Devices.Dumping
+{
+    partial class Dump
+    {
+        void RetryCdUserData(ExtentsULong audioExtents, uint blockSize, DumpHardwareType currentTry,
+                             ExtentsULong extents, int offsetBytes, bool readcd, int sectorsForOffset, uint subSize,
+                             MmcSubchannel supportedSubchannel, ref double totalDuration)
+        {
+            bool       sense  = true;     // Sense indicator
+            byte[]     cmdBuf = null;     // Data buffer
+            double     cmdDuration;       // Command execution time
+            const uint sectorSize = 2352; // Full sector size
+            byte[]     tmpBuf;            // Temporary buffer
+            byte[]     senseBuf = null;   // Sense buffer
+
+            if(_resume.BadBlocks.Count <= 0 ||
+               _aborted                     ||
+               _retryPasses <= 0)
+                return;
+
+            int  pass              = 1;
+            bool forward           = true;
+            bool runningPersistent = false;
+
+            Modes.ModePage? currentModePage = null;
+            byte[]          md6;
+            byte[]          md10;
+
+            if(_persistent)
+            {
+                Modes.ModePage_01_MMC pgMmc;
+
+                sense = _dev.ModeSense6(out cmdBuf, out _, false, ScsiModeSensePageControl.Current, 0x01, _dev.Timeout,
+                                        out _);
+
+                if(sense)
+                {
+                    sense = _dev.ModeSense10(out cmdBuf, out _, false, ScsiModeSensePageControl.Current, 0x01,
+                                             _dev.Timeout, out _);
+
+                    if(!sense)
+                    {
+                        Modes.DecodedMode? dcMode10 =
+                            Modes.DecodeMode10(cmdBuf, PeripheralDeviceTypes.MultiMediaDevice);
+
+                        if(dcMode10?.Pages != null)
+                            foreach(Modes.ModePage modePage in dcMode10.Value.Pages)
+                                if(modePage.Page    == 0x01 &&
+                                   modePage.Subpage == 0x00)
+                                    currentModePage = modePage;
+                    }
+                }
+                else
+                {
+                    Modes.DecodedMode? dcMode6 = Modes.DecodeMode6(cmdBuf, PeripheralDeviceTypes.MultiMediaDevice);
+
+                    if(dcMode6?.Pages != null)
+                        foreach(Modes.ModePage modePage in dcMode6.Value.Pages)
+                            if(modePage.Page    == 0x01 &&
+                               modePage.Subpage == 0x00)
+                                currentModePage = modePage;
+                }
+
+                if(currentModePage == null)
+                {
+                    pgMmc = new Modes.ModePage_01_MMC
+                    {
+                        PS = false, ReadRetryCount = 32, Parameter = 0x00
+                    };
+
+                    currentModePage = new Modes.ModePage
+                    {
+                        Page = 0x01, Subpage = 0x00, PageResponse = Modes.EncodeModePage_01_MMC(pgMmc)
+                    };
+                }
+
+                pgMmc = new Modes.ModePage_01_MMC
+                {
+                    PS = false, ReadRetryCount = 255, Parameter = 0x20
+                };
+
+                var md = new Modes.DecodedMode
+                {
+                    Header = new Modes.ModeHeader(), Pages = new[]
+                    {
+                        new Modes.ModePage
+                        {
+                            Page = 0x01, Subpage = 0x00, PageResponse = Modes.EncodeModePage_01_MMC(pgMmc)
+                        }
+                    }
+                };
+
+                md6  = Modes.EncodeMode6(md, _dev.ScsiType);
+                md10 = Modes.EncodeMode10(md, _dev.ScsiType);
+
+                UpdateStatus?.Invoke("Sending MODE SELECT to drive (return damaged blocks).");
+                _dumpLog.WriteLine("Sending MODE SELECT to drive (return damaged blocks).");
+                sense = _dev.ModeSelect(md6, out senseBuf, true, false, _dev.Timeout, out _);
+
+                if(sense)
+                    sense = _dev.ModeSelect10(md10, out senseBuf, true, false, _dev.Timeout, out _);
+
+                if(sense)
+                {
+                    UpdateStatus?.
+                        Invoke("Drive did not accept MODE SELECT command for persistent error reading, try another drive.");
+
+                    DicConsole.DebugWriteLine("Error: {0}", Sense.PrettifySense(senseBuf));
+
+                    _dumpLog.WriteLine("Drive did not accept MODE SELECT command for persistent error reading, try another drive.");
+                }
+                else
+                {
+                    runningPersistent = true;
+                }
+            }
+
+            InitProgress?.Invoke();
+            cdRepeatRetry:
+            ulong[]     tmpArray              = _resume.BadBlocks.ToArray();
+            List<ulong> sectorsNotEvenPartial = new List<ulong>();
+
+            foreach(ulong badSector in tmpArray)
+            {
+                if(_aborted)
+                {
+                    currentTry.Extents = ExtentsConverter.ToMetadata(extents);
+                    _dumpLog.WriteLine("Aborted!");
+
+                    break;
+                }
+
+                PulseProgress?.Invoke(string.Format("Retrying sector {0}, pass {1}, {3}{2}", badSector, pass,
+                                                    forward ? "forward" : "reverse",
+                                                    runningPersistent ? "recovering partial data, " : ""));
+
+                byte sectorsToReRead   = 1;
+                uint badSectorToReRead = (uint)badSector;
+
+                if(_fixOffset                       &&
+                   audioExtents.Contains(badSector) &&
+                   offsetBytes != 0)
+                {
+                    if(offsetBytes > 0)
+                    {
+                        badSectorToReRead -= (uint)sectorsForOffset;
+                    }
+
+                    sectorsToReRead = (byte)(sectorsForOffset + 1);
+                }
+
+                if(readcd)
+                {
+                    sense = _dev.ReadCd(out cmdBuf, out senseBuf, badSectorToReRead, blockSize, sectorsToReRead,
+                                        MmcSectorTypes.AllTypes, false, false, true, MmcHeaderCodes.AllHeaders, true,
+                                        true, MmcErrorField.None, supportedSubchannel, _dev.Timeout, out cmdDuration);
+
+                    totalDuration += cmdDuration;
+                }
+
+                if(sense || _dev.Error)
+                {
+                    if(!runningPersistent)
+                        continue;
+
+                    FixedSense? decSense = Sense.DecodeFixed(senseBuf);
+
+                    // MEDIUM ERROR, retry with ignore error below
+                    if(decSense.HasValue &&
+                       decSense.Value.ASC == 0x11)
+                        if(!sectorsNotEvenPartial.Contains(badSector))
+                            sectorsNotEvenPartial.Add(badSector);
+                }
+
+                // Because one block has been partially used to fix the offset
+                if(_fixOffset                       &&
+                   audioExtents.Contains(badSector) &&
+                   offsetBytes != 0)
+                {
+                    int offsetFix = offsetBytes > 0 ? (int)(sectorSize - (offsetBytes * -1)) : offsetBytes;
+
+                    if(supportedSubchannel != MmcSubchannel.None)
+                    {
+                        // De-interleave subchannel
+                        byte[] data = new byte[sectorSize * sectorsToReRead];
+                        byte[] sub  = new byte[subSize    * sectorsToReRead];
+
+                        for(int b = 0; b < sectorsToReRead; b++)
+                        {
+                            Array.Copy(cmdBuf, (int)(0 + (b * blockSize)), data, sectorSize * b, sectorSize);
+
+                            Array.Copy(cmdBuf, (int)(sectorSize + (b * blockSize)), sub, subSize * b, subSize);
+                        }
+
+                        tmpBuf = new byte[sectorSize * (sectorsToReRead - sectorsForOffset)];
+                        Array.Copy(data, offsetFix, tmpBuf, 0, tmpBuf.Length);
+                        data = tmpBuf;
+
+                        // Re-interleave subchannel
+                        cmdBuf = new byte[blockSize * sectorsToReRead];
+
+                        for(int b = 0; b < sectorsToReRead; b++)
+                        {
+                            Array.Copy(data, sectorSize * b, cmdBuf, (int)(0 + (b * blockSize)), sectorSize);
+
+                            Array.Copy(sub, subSize * b, cmdBuf, (int)(sectorSize + (b * blockSize)), subSize);
+                        }
+                    }
+                    else
+                    {
+                        tmpBuf = new byte[blockSize * (sectorsToReRead - sectorsForOffset)];
+                        Array.Copy(cmdBuf, offsetFix, tmpBuf, 0, tmpBuf.Length);
+                        cmdBuf = tmpBuf;
+                    }
+                }
+
+                if(!sense &&
+                   !_dev.Error)
+                {
+                    _resume.BadBlocks.Remove(badSector);
+                    extents.Add(badSector);
+                    UpdateStatus?.Invoke($"Correctly retried sector {badSector} in pass {pass}.");
+                    _dumpLog.WriteLine("Correctly retried sector {0} in pass {1}.", badSector, pass);
+                    sectorsNotEvenPartial.Remove(badSector);
+                }
+
+                if(supportedSubchannel != MmcSubchannel.None)
+                {
+                    byte[] data = new byte[sectorSize];
+                    byte[] sub  = new byte[subSize];
+                    Array.Copy(cmdBuf, 0, data, 0, sectorSize);
+                    Array.Copy(cmdBuf, sectorSize, sub, 0, subSize);
+                    _outputPlugin.WriteSectorLong(data, badSector);
+                    _outputPlugin.WriteSectorTag(sub, badSector, SectorTagType.CdSectorSubchannel);
+                }
+                else
+                {
+                    _outputPlugin.WriteSectorLong(cmdBuf, badSector);
+                }
+            }
+
+            if(pass < _retryPasses &&
+               !_aborted           &&
+               _resume.BadBlocks.Count > 0)
+            {
+                pass++;
+                forward = !forward;
+                _resume.BadBlocks.Sort();
+                _resume.BadBlocks.Reverse();
+
+                goto cdRepeatRetry;
+            }
+
+            EndProgress?.Invoke();
+
+            // TODO: Enable when underlying images support lead-outs
+            /*
+                RetryCdLeadOuts(blocks, blockSize, ref currentSpeed, currentTry, extents, ibgLog, ref imageWriteDuration,
+                       leadOutExtents, ref maxSpeed, mhddLog, ref minSpeed, read6, read10, read12, read16, readcd,
+                       supportedSubchannel, subSize, ref totalDuration);
+                */
+
+            // Try to ignore read errors, on some drives this allows to recover partial even if damaged data
+            if(_persistent && sectorsNotEvenPartial.Count > 0)
+            {
+                var pgMmc = new Modes.ModePage_01_MMC
+                {
+                    PS = false, ReadRetryCount = 255, Parameter = 0x01
+                };
+
+                var md = new Modes.DecodedMode
+                {
+                    Header = new Modes.ModeHeader(), Pages = new[]
+                    {
+                        new Modes.ModePage
+                        {
+                            Page = 0x01, Subpage = 0x00, PageResponse = Modes.EncodeModePage_01_MMC(pgMmc)
+                        }
+                    }
+                };
+
+                md6  = Modes.EncodeMode6(md, _dev.ScsiType);
+                md10 = Modes.EncodeMode10(md, _dev.ScsiType);
+
+                _dumpLog.WriteLine("Sending MODE SELECT to drive (ignore error correction).");
+                sense = _dev.ModeSelect(md6, out senseBuf, true, false, _dev.Timeout, out _);
+
+                if(sense)
+                    sense = _dev.ModeSelect10(md10, out senseBuf, true, false, _dev.Timeout, out _);
+
+                if(!sense)
+                {
+                    runningPersistent = true;
+
+                    InitProgress?.Invoke();
+
+                    foreach(ulong badSector in sectorsNotEvenPartial)
+                    {
+                        if(_aborted)
+                        {
+                            currentTry.Extents = ExtentsConverter.ToMetadata(extents);
+                            _dumpLog.WriteLine("Aborted!");
+
+                            break;
+                        }
+
+                        PulseProgress?.Invoke($"Trying to get partial data for sector {badSector}");
+
+                        if(readcd)
+                        {
+                            sense = _dev.ReadCd(out cmdBuf, out senseBuf, (uint)badSector, blockSize, 1,
+                                                MmcSectorTypes.AllTypes, false, false, true, MmcHeaderCodes.AllHeaders,
+                                                true, true, MmcErrorField.None, supportedSubchannel, _dev.Timeout,
+                                                out cmdDuration);
+
+                            totalDuration += cmdDuration;
+                        }
+
+                        if(sense || _dev.Error)
+                            continue;
+
+                        _dumpLog.WriteLine("Got partial data for sector {0} in pass {1}.", badSector, pass);
+
+                        if(supportedSubchannel != MmcSubchannel.None)
+                        {
+                            byte[] data = new byte[sectorSize];
+                            byte[] sub  = new byte[subSize];
+                            Array.Copy(cmdBuf, 0, data, 0, sectorSize);
+                            Array.Copy(cmdBuf, sectorSize, sub, 0, subSize);
+                            _outputPlugin.WriteSectorLong(data, badSector);
+                            _outputPlugin.WriteSectorTag(sub, badSector, SectorTagType.CdSectorSubchannel);
+                        }
+                        else
+                        {
+                            _outputPlugin.WriteSectorLong(cmdBuf, badSector);
+                        }
+                    }
+
+                    EndProgress?.Invoke();
+                }
+            }
+
+            if(runningPersistent && currentModePage.HasValue)
+            {
+                var md = new Modes.DecodedMode
+                {
+                    Header = new Modes.ModeHeader(), Pages = new[]
+                    {
+                        currentModePage.Value
+                    }
+                };
+
+                md6  = Modes.EncodeMode6(md, _dev.ScsiType);
+                md10 = Modes.EncodeMode10(md, _dev.ScsiType);
+
+                _dumpLog.WriteLine("Sending MODE SELECT to drive (return device to previous status).");
+                sense = _dev.ModeSelect(md6, out senseBuf, true, false, _dev.Timeout, out _);
+
+                if(sense)
+                    _dev.ModeSelect10(md10, out senseBuf, true, false, _dev.Timeout, out _);
+            }
+
+            EndProgress?.Invoke();
+        }
+    }
+}

Aaru.Core/Devices/Dumping/CompactDisc/LeadOuts.cs

@@ -0,0 +1,347 @@
+// /***************************************************************************
+// The Disc Image Chef
+// ----------------------------------------------------------------------------
+//
+// Filename       : CompactDisc.cs
+// Author(s)      : Natalia Portillo <claunia@claunia.com>
+//
+// Component      : Core algorithms.
+//
+// --[ Description ] ----------------------------------------------------------
+//
+//     Dumps CDs and DDCDs.
+//
+// --[ License ] --------------------------------------------------------------
+//
+//     This program is free software: you can redistribute it and/or modify
+//     it under the terms of the GNU General Public License as
+//     published by the Free Software Foundation, either version 3 of the
+//     License, or (at your option) any later version.
+//
+//     This program is distributed in the hope that it will be useful,
+//     but WITHOUT ANY WARRANTY; without even the implied warranty of
+//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//     GNU General Public License for more details.
+//
+//     You should have received a copy of the GNU General Public License
+//     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ----------------------------------------------------------------------------
+// Copyright © 2011-2020 Natalia Portillo
+// ****************************************************************************/
+
+using System;
+using DiscImageChef.CommonTypes.Enums;
+using DiscImageChef.CommonTypes.Extents;
+using DiscImageChef.Core.Logging;
+using DiscImageChef.Devices;
+using Schemas;
+
+// ReSharper disable JoinDeclarationAndInitializer
+// ReSharper disable InlineOutVariableDeclaration
+// ReSharper disable TooWideLocalVariableScope
+
+namespace DiscImageChef.Core.Devices.Dumping
+{
+    partial class Dump
+    {
+        /// <summary>Dumps inter-session lead-outs</summary>
+        /// <param name="blocks">Total number of positive sectors</param>
+        /// <param name="blockSize">Size of the read sector in bytes</param>
+        /// <param name="currentSpeed">Current read speed</param>
+        /// <param name="currentTry">Current dump hardware try</param>
+        /// <param name="extents">Extents</param>
+        /// <param name="ibgLog">IMGBurn log</param>
+        /// <param name="imageWriteDuration">Duration of image write</param>
+        /// <param name="leadOutExtents">Lead-out extents</param>
+        /// <param name="maxSpeed">Maximum speed</param>
+        /// <param name="mhddLog">MHDD log</param>
+        /// <param name="minSpeed">Minimum speed</param>
+        /// <param name="read6">Device supports READ(6)</param>
+        /// <param name="read10">Device supports READ(10)</param>
+        /// <param name="read12">Device supports READ(12)</param>
+        /// <param name="read16">Device supports READ(16)</param>
+        /// <param name="readcd">Device supports READ CD</param>
+        /// <param name="supportedSubchannel">Drive's maximum supported subchannel</param>
+        /// <param name="subSize">Subchannel size in bytes</param>
+        /// <param name="totalDuration">Total commands duration</param>
+        void DumpCdLeadOuts(ulong blocks, uint blockSize, ref double currentSpeed, DumpHardwareType currentTry,
+                            ExtentsULong extents, IbgLog ibgLog, ref double imageWriteDuration,
+                            ExtentsULong leadOutExtents, ref double maxSpeed, MhddLog mhddLog, ref double minSpeed,
+                            bool read6, bool read10, bool read12, bool read16, bool readcd,
+                            MmcSubchannel supportedSubchannel, uint subSize, ref double totalDuration)
+        {
+            byte[]     cmdBuf     = null; // Data buffer
+            const uint sectorSize = 2352; // Full sector size
+            bool       sense      = true; // Sense indicator
+
+            UpdateStatus?.Invoke("Reading lead-outs");
+            _dumpLog.WriteLine("Reading lead-outs");
+
+            InitProgress?.Invoke();
+
+            foreach((ulong item1, ulong item2) in leadOutExtents.ToArray())
+                for(ulong i = item1; i <= item2; i++)
+                {
+                    if(_aborted)
+                    {
+                        currentTry.Extents = ExtentsConverter.ToMetadata(extents);
+                        _dumpLog.WriteLine("Aborted!");
+
+                        break;
+                    }
+
+                    double cmdDuration = 0;
+
+                    #pragma warning disable RECS0018 // Comparison of floating point numbers with equality operator
+
+                    // ReSharper disable CompareOfFloatsByEqualityOperator
+                    if(currentSpeed > maxSpeed &&
+                       currentSpeed != 0)
+                        maxSpeed = currentSpeed;
+
+                    if(currentSpeed < minSpeed &&
+                       currentSpeed != 0)
+                        minSpeed = currentSpeed;
+
+                    // ReSharper restore CompareOfFloatsByEqualityOperator
+                    #pragma warning restore RECS0018 // Comparison of floating point numbers with equality operator
+
+                    PulseProgress?.Invoke($"Reading sector {i} at lead-out ({currentSpeed:F3} MiB/sec.)");
+
+                    if(readcd)
+                    {
+                        sense = _dev.ReadCd(out cmdBuf, out _, (uint)i, blockSize, 1, MmcSectorTypes.AllTypes, false,
+                                            false, true, MmcHeaderCodes.AllHeaders, true, true, MmcErrorField.None,
+                                            supportedSubchannel, _dev.Timeout, out cmdDuration);
+
+                        totalDuration += cmdDuration;
+                    }
+                    else if(read16)
+                        sense = _dev.Read16(out cmdBuf, out _, 0, false, true, false, i, blockSize, 0, 1, false,
+                                            _dev.Timeout, out cmdDuration);
+                    else if(read12)
+                        sense = _dev.Read12(out cmdBuf, out _, 0, false, true, false, false, (uint)i, blockSize, 0, 1,
+                                            false, _dev.Timeout, out cmdDuration);
+                    else if(read10)
+                        sense = _dev.Read10(out cmdBuf, out _, 0, false, true, false, false, (uint)i, blockSize, 0, 1,
+                                            _dev.Timeout, out cmdDuration);
+                    else if(read6)
+                        sense = _dev.Read6(out cmdBuf, out _, (uint)i, blockSize, 1, _dev.Timeout, out cmdDuration);
+
+                    if(!sense &&
+                       !_dev.Error)
+                    {
+                        mhddLog.Write(i, cmdDuration);
+                        ibgLog.Write(i, currentSpeed * 1024);
+                        extents.Add(i, _maximumReadable, true);
+                        leadOutExtents.Remove(i);
+                        DateTime writeStart = DateTime.Now;
+
+                        if(supportedSubchannel != MmcSubchannel.None)
+                        {
+                            byte[] data = new byte[sectorSize * _maximumReadable];
+                            byte[] sub  = new byte[subSize    * _maximumReadable];
+
+                            for(int b = 0; b < _maximumReadable; b++)
+                            {
+                                Array.Copy(cmdBuf, (int)(0 + (b * blockSize)), data, sectorSize * b, sectorSize);
+
+                                Array.Copy(cmdBuf, (int)(sectorSize + (b * blockSize)), sub, subSize * b, subSize);
+                            }
+
+                            _outputPlugin.WriteSectorsLong(data, i, _maximumReadable);
+                            _outputPlugin.WriteSectorsTag(sub, i, _maximumReadable, SectorTagType.CdSectorSubchannel);
+                        }
+                        else
+                            _outputPlugin.WriteSectors(cmdBuf, i, _maximumReadable);
+
+                        imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
+                    }
+                    else
+                    {
+                        // TODO: Reset device after X errors
+                        if(_stopOnError)
+                            return; // TODO: Return more cleanly
+
+                        // Write empty data
+                        DateTime writeStart = DateTime.Now;
+
+                        if(supportedSubchannel != MmcSubchannel.None)
+                        {
+                            _outputPlugin.WriteSectorsLong(new byte[sectorSize * _skip], i, 1);
+
+                            _outputPlugin.WriteSectorsTag(new byte[subSize * _skip], i, 1,
+                                                          SectorTagType.CdSectorSubchannel);
+                        }
+                        else
+                            _outputPlugin.WriteSectors(new byte[blockSize * _skip], i, 1);
+
+                        imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
+
+                        mhddLog.Write(i, cmdDuration < 500 ? 65535 : cmdDuration);
+
+                        ibgLog.Write(i, 0);
+                    }
+
+                    double newSpeed = ((double)blockSize * _maximumReadable) / 1048576 / (cmdDuration / 1000);
+
+                    if(!double.IsInfinity(newSpeed))
+                        currentSpeed = newSpeed;
+
+                    _resume.NextBlock = i + 1;
+                }
+
+            EndProgress?.Invoke();
+        }
+
+        /// <summary>Retries inter-session lead-outs</summary>
+        /// <param name="blocks">Total number of positive sectors</param>
+        /// <param name="blockSize">Size of the read sector in bytes</param>
+        /// <param name="currentSpeed">Current read speed</param>
+        /// <param name="currentTry">Current dump hardware try</param>
+        /// <param name="extents">Extents</param>
+        /// <param name="ibgLog">IMGBurn log</param>
+        /// <param name="imageWriteDuration">Duration of image write</param>
+        /// <param name="leadOutExtents">Lead-out extents</param>
+        /// <param name="maxSpeed">Maximum speed</param>
+        /// <param name="mhddLog">MHDD log</param>
+        /// <param name="minSpeed">Minimum speed</param>
+        /// <param name="read6">Device supports READ(6)</param>
+        /// <param name="read10">Device supports READ(10)</param>
+        /// <param name="read12">Device supports READ(12)</param>
+        /// <param name="read16">Device supports READ(16)</param>
+        /// <param name="readcd">Device supports READ CD</param>
+        /// <param name="supportedSubchannel">Drive's maximum supported subchannel</param>
+        /// <param name="subSize">Subchannel size in bytes</param>
+        /// <param name="totalDuration">Total commands duration</param>
+        void RetryCdLeadOuts(ulong blocks, uint blockSize, ref double currentSpeed, DumpHardwareType currentTry,
+                             ExtentsULong extents, IbgLog ibgLog, ref double imageWriteDuration,
+                             ExtentsULong leadOutExtents, ref double maxSpeed, MhddLog mhddLog, ref double minSpeed,
+                             bool read6, bool read10, bool read12, bool read16, bool readcd,
+                             MmcSubchannel supportedSubchannel, uint subSize, ref double totalDuration)
+        {
+            byte[]     cmdBuf     = null; // Data buffer
+            const uint sectorSize = 2352; // Full sector size
+            bool       sense      = true; // Sense indicator
+
+            _dumpLog.WriteLine("Retrying lead-outs");
+
+            InitProgress?.Invoke();
+
+            foreach((ulong item1, ulong item2) in leadOutExtents.ToArray())
+                for(ulong i = item1; i <= item2; i++)
+                {
+                    if(_aborted)
+                    {
+                        currentTry.Extents = ExtentsConverter.ToMetadata(extents);
+                        _dumpLog.WriteLine("Aborted!");
+
+                        break;
+                    }
+
+                    double cmdDuration = 0;
+
+                    #pragma warning disable RECS0018 // Comparison of floating point numbers with equality operator
+
+                    // ReSharper disable CompareOfFloatsByEqualityOperator
+                    if(currentSpeed > maxSpeed &&
+                       currentSpeed != 0)
+                        maxSpeed = currentSpeed;
+
+                    if(currentSpeed < minSpeed &&
+                       currentSpeed != 0)
+                        minSpeed = currentSpeed;
+
+                    // ReSharper restore CompareOfFloatsByEqualityOperator
+                    #pragma warning restore RECS0018 // Comparison of floating point numbers with equality operator
+
+                    PulseProgress?.Invoke(string.Format("Reading sector {0} at lead-out ({1:F3} MiB/sec.)", i, blocks,
+                                                        currentSpeed));
+
+                    if(readcd)
+                    {
+                        sense = _dev.ReadCd(out cmdBuf, out _, (uint)i, blockSize, 1, MmcSectorTypes.AllTypes, false,
+                                            false, true, MmcHeaderCodes.AllHeaders, true, true, MmcErrorField.None,
+                                            supportedSubchannel, _dev.Timeout, out cmdDuration);
+
+                        totalDuration += cmdDuration;
+                    }
+                    else if(read16)
+                        sense = _dev.Read16(out cmdBuf, out _, 0, false, true, false, i, blockSize, 0, 1, false,
+                                            _dev.Timeout, out cmdDuration);
+                    else if(read12)
+                        sense = _dev.Read12(out cmdBuf, out _, 0, false, true, false, false, (uint)i, blockSize, 0, 1,
+                                            false, _dev.Timeout, out cmdDuration);
+                    else if(read10)
+                        sense = _dev.Read10(out cmdBuf, out _, 0, false, true, false, false, (uint)i, blockSize, 0, 1,
+                                            _dev.Timeout, out cmdDuration);
+                    else if(read6)
+                        sense = _dev.Read6(out cmdBuf, out _, (uint)i, blockSize, 1, _dev.Timeout, out cmdDuration);
+
+                    if(!sense &&
+                       !_dev.Error)
+                    {
+                        mhddLog.Write(i, cmdDuration);
+                        ibgLog.Write(i, currentSpeed * 1024);
+                        extents.Add(i, _maximumReadable, true);
+                        leadOutExtents.Remove(i);
+                        DateTime writeStart = DateTime.Now;
+
+                        if(supportedSubchannel != MmcSubchannel.None)
+                        {
+                            byte[] data = new byte[sectorSize * _maximumReadable];
+                            byte[] sub  = new byte[subSize    * _maximumReadable];
+
+                            for(int b = 0; b < _maximumReadable; b++)
+                            {
+                                Array.Copy(cmdBuf, (int)(0 + (b * blockSize)), data, sectorSize * b,
+                                           sectorSize);
+
+                                Array.Copy(cmdBuf, (int)(sectorSize + (b * blockSize)), sub, subSize * b, subSize);
+                            }
+
+                            _outputPlugin.WriteSectorsLong(data, i, _maximumReadable);
+                            _outputPlugin.WriteSectorsTag(sub, i, _maximumReadable, SectorTagType.CdSectorSubchannel);
+                        }
+                        else
+                            _outputPlugin.WriteSectors(cmdBuf, i, _maximumReadable);
+
+                        imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
+                    }
+                    else
+                    {
+                        // TODO: Reset device after X errors
+                        if(_stopOnError)
+                            return; // TODO: Return more cleanly
+
+                        // Write empty data
+                        DateTime writeStart = DateTime.Now;
+
+                        if(supportedSubchannel != MmcSubchannel.None)
+                        {
+                            _outputPlugin.WriteSectorsLong(new byte[sectorSize * _skip], i, 1);
+
+                            _outputPlugin.WriteSectorsTag(new byte[subSize * _skip], i, 1,
+                                                          SectorTagType.CdSectorSubchannel);
+                        }
+                        else
+                            _outputPlugin.WriteSectors(new byte[blockSize * _skip], i, 1);
+
+                        imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
+
+                        mhddLog.Write(i, cmdDuration < 500 ? 65535 : cmdDuration);
+
+                        ibgLog.Write(i, 0);
+                    }
+
+                    double newSpeed = ((double)blockSize * _maximumReadable) / 1048576 / (cmdDuration / 1000);
+
+                    if(!double.IsInfinity(newSpeed))
+                        currentSpeed = newSpeed;
+                }
+
+            EndProgress?.Invoke();
+        }
+    }
+}

Aaru.Core/Devices/Dumping/CompactDisc/Pregap.cs

@@ -0,0 +1,695 @@
+// /***************************************************************************
+// The Disc Image Chef
+// ----------------------------------------------------------------------------
+//
+// Filename       : CompactDisc.cs
+// Author(s)      : Natalia Portillo <claunia@claunia.com>
+//
+// Component      : Core algorithms.
+//
+// --[ Description ] ----------------------------------------------------------
+//
+//     Dumps CDs and DDCDs.
+//
+// --[ License ] --------------------------------------------------------------
+//
+//     This program is free software: you can redistribute it and/or modify
+//     it under the terms of the GNU General Public License as
+//     published by the Free Software Foundation, either version 3 of the
+//     License, or (at your option) any later version.
+//
+//     This program is distributed in the hope that it will be useful,
+//     but WITHOUT ANY WARRANTY; without even the implied warranty of
+//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//     GNU General Public License for more details.
+//
+//     You should have received a copy of the GNU General Public License
+//     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ----------------------------------------------------------------------------
+// Copyright © 2011-2020 Natalia Portillo
+// ****************************************************************************/
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using DiscImageChef.Checksums;
+using DiscImageChef.CommonTypes.Enums;
+using DiscImageChef.CommonTypes.Structs;
+using DiscImageChef.Console;
+using DiscImageChef.Core.Logging;
+using DiscImageChef.Devices;
+
+// ReSharper disable JoinDeclarationAndInitializer
+// ReSharper disable InlineOutVariableDeclaration
+// ReSharper disable TooWideLocalVariableScope
+
+namespace DiscImageChef.Core.Devices.Dumping
+{
+    partial class Dump
+    {
+        // TODO: Fix offset
+        void ReadCdFirstTrackPregap(uint blockSize, ref double currentSpeed, Dictionary<MediaTagType, byte[]> mediaTags,
+                                    MmcSubchannel supportedSubchannel, ref double totalDuration)
+        {
+            bool     sense;                           // Sense indicator
+            byte[]   cmdBuf;                          // Data buffer
+            double   cmdDuration;                     // Command execution time
+            DateTime timeSpeedStart;                  // Time of start for speed calculation
+            ulong    sectorSpeedStart            = 0; // Used to calculate correct speed
+            bool     gotFirstTrackPregap         = false;
+            int      firstTrackPregapSectorsGood = 0;
+            var      firstTrackPregapMs          = new MemoryStream();
+
+            _dumpLog.WriteLine("Reading first track pregap");
+            UpdateStatus?.Invoke("Reading first track pregap");
+            InitProgress?.Invoke();
+            timeSpeedStart = DateTime.UtcNow;
+
+            for(int firstTrackPregapBlock = -150; firstTrackPregapBlock < 0 && _resume.NextBlock == 0;
+                firstTrackPregapBlock++)
+            {
+                if(_aborted)
+                {
+                    _dumpLog.WriteLine("Aborted!");
+                    UpdateStatus?.Invoke("Aborted!");
+
+                    break;
+                }
+
+                PulseProgress?.
+                    Invoke($"Trying to read first track pregap sector {firstTrackPregapBlock} ({currentSpeed:F3} MiB/sec.)");
+
+                sense = _dev.ReadCd(out cmdBuf, out _, (uint)firstTrackPregapBlock, blockSize, 1,
+                                    MmcSectorTypes.AllTypes, false, false, true, MmcHeaderCodes.AllHeaders, true, true,
+                                    MmcErrorField.None, supportedSubchannel, _dev.Timeout, out cmdDuration);
+
+                if(!sense &&
+                   !_dev.Error)
+                {
+                    firstTrackPregapMs.Write(cmdBuf, 0, (int)blockSize);
+                    gotFirstTrackPregap = true;
+                    firstTrackPregapSectorsGood++;
+                    totalDuration += cmdDuration;
+                }
+                else
+                {
+                    // Write empty data
+                    if(gotFirstTrackPregap)
+                        firstTrackPregapMs.Write(new byte[blockSize], 0, (int)blockSize);
+                }
+
+                sectorSpeedStart++;
+
+                double elapsed = (DateTime.UtcNow - timeSpeedStart).TotalSeconds;
+
+                if(elapsed < 1)
+                    continue;
+
+                currentSpeed     = (sectorSpeedStart * blockSize) / (1048576 * elapsed);
+                sectorSpeedStart = 0;
+                timeSpeedStart   = DateTime.UtcNow;
+            }
+
+            if(firstTrackPregapSectorsGood > 0)
+                mediaTags.Add(MediaTagType.CD_FirstTrackPregap, firstTrackPregapMs.ToArray());
+
+            EndProgress?.Invoke();
+            UpdateStatus?.Invoke($"Got {firstTrackPregapSectorsGood} first track pregap sectors.");
+            _dumpLog.WriteLine("Got {0} first track pregap sectors.", firstTrackPregapSectorsGood);
+
+            firstTrackPregapMs.Close();
+        }
+
+        public static void SolveTrackPregaps(Device dev, DumpLog dumpLog, UpdateStatusHandler updateStatus,
+                                             Track[] tracks, bool supportsPqSubchannel, bool supportsRwSubchannel,
+                                             Database.Models.Device dbDev, out bool inexactPositioning)
+        {
+            bool                  sense  = true; // Sense indicator
+            byte[]                subBuf = null;
+            int                   posQ;
+            uint                  retries;
+            bool?                 bcd = null;
+            byte[]                crc;
+            Dictionary<uint, int> pregaps = new Dictionary<uint, int>();
+            inexactPositioning = false;
+
+            if(!supportsPqSubchannel &&
+               !supportsRwSubchannel)
+                return;
+
+            // Check if subchannel is BCD
+            for(retries = 0; retries < 10; retries++)
+            {
+                sense = supportsRwSubchannel ? GetSectorForPregapRaw(dev, 11, dbDev, out subBuf)
+                            : GetSectorForPregapQ16(dev, 11, dbDev, out subBuf);
+
+                if(sense)
+                    continue;
+
+                bcd = (subBuf[9] & 0x10) > 0;
+
+                break;
+            }
+
+            DicConsole.DebugWriteLine("Pregap calculator", bcd == true
+                                                               ? "Subchannel is BCD"
+                                                               : bcd == false
+                                                                   ? "Subchannel is not BCD"
+                                                                   : "Could not detect drive subchannel BCD");
+
+            if(bcd is null)
+            {
+                dumpLog?.WriteLine("Could not detect if drive subchannel is BCD or not, pregaps could not be calculated, dump may be incorrect...");
+
+                updateStatus?.
+                    Invoke("Could not detect if drive subchannel is BCD or not, pregaps could not be calculated, dump may be incorrect...");
+
+                return;
+            }
+
+            // Initialize the dictionary
+            for(int i = 0; i < tracks.Length; i++)
+                pregaps[tracks[i].TrackSequence] = 0;
+
+            foreach(Track track in tracks)
+            {
+                int trackRetries = 0;
+
+                // First track of each session has at least 150 sectors of pregap and is not readable always
+                if(tracks.Where(t => t.TrackSession == track.TrackSession).OrderBy(t => t.TrackSequence).
+                          FirstOrDefault().TrackSequence == track.TrackSequence)
+                {
+                    DicConsole.DebugWriteLine("Pregap calculator", "Skipping track {0}", track.TrackSequence);
+
+                    if(track.TrackSequence > 1)
+                        pregaps[track.TrackSequence] = 150;
+
+                    continue;
+                }
+
+                DicConsole.DebugWriteLine("Pregap calculator", "Track {0}", track.TrackSequence);
+
+                int   lba           = (int)track.TrackStartSector - 1;
+                bool  pregapFound   = false;
+                Track previousTrack = tracks.FirstOrDefault(t => t.TrackSequence == track.TrackSequence - 1);
+
+                bool goneBack                      = false;
+                bool goFront                       = false;
+                bool forward                       = false;
+                bool crcOk                         = false;
+                bool previousPregapIsPreviousTrack = false;
+
+                // Check if pregap is 0
+                for(retries = 0; retries < 10 && !pregapFound; retries++)
+                {
+                    sense = supportsRwSubchannel ? GetSectorForPregapRaw(dev, (uint)lba, dbDev, out subBuf)
+                                : GetSectorForPregapQ16(dev, (uint)lba, dbDev, out subBuf);
+
+                    if(sense)
+                    {
+                        DicConsole.DebugWriteLine("Pregap calculator", "LBA: {0}, Try {1}, Sense {2}", lba, retries + 1,
+                                                  sense);
+
+                        continue;
+                    }
+
+                    if(bcd == false)
+                        BinaryToBcdQ(subBuf);
+
+                    CRC16CCITTContext.Data(subBuf, 10, out crc);
+
+                    DicConsole.DebugWriteLine("Pregap calculator",
+                                              "LBA: {0}, Try {1}, Sense {2}, Q: {3:X2} {4:X2} {5:X2} {6:X2} {7:X2} {8:X2} {9:X2} {10:X2} {11:X2} {12:X2} CRC 0x{13:X2}{14:X2}, Calculated CRC: 0x{15:X2}{16:X2}",
+                                              lba, retries + 1, sense, subBuf[0], subBuf[1], subBuf[2], subBuf[3],
+                                              subBuf[4], subBuf[5], subBuf[6], subBuf[7], subBuf[8], subBuf[9],
+                                              subBuf[10], subBuf[11], crc[0], crc[1]);
+
+                    crcOk = crc[0] == subBuf[10] && crc[1] == subBuf[11];
+
+                    // Try to do a simple correction
+                    if(!crcOk)
+                    {
+                        // Data track cannot have 11xxb in CONTROL
+                        if((subBuf[0] & 0x40) > 0)
+                            subBuf[0] &= 0x7F;
+
+                        // ADR only uses two bits
+                        subBuf[0] &= 0xF3;
+
+                        // Don't care about other Q modes
+                        if((subBuf[0] & 0xF) == 1)
+                        {
+                            // ZERO only used in DDCD
+                            subBuf[6] = 0;
+
+                            // Fix BCD numbering
+                            for(int i = 1; i < 10; i++)
+                            {
+                                if((subBuf[i] & 0xF0) > 0xA0)
+                                    subBuf[i] &= 0x7F;
+
+                                if((subBuf[i] & 0x0F) > 0x0A)
+                                    subBuf[i] &= 0xF7;
+                            }
+                        }
+
+                        CRC16CCITTContext.Data(subBuf, 10, out crc);
+
+                        crcOk = crc[0] == subBuf[10] && crc[1] == subBuf[11];
+
+                        if(crcOk)
+                        {
+                            DicConsole.DebugWriteLine("Pregap calculator",
+                                                      "LBA: {0}, Try {1}, Sense {2}, Q (FIXED): {3:X2} {4:X2} {5:X2} {6:X2} {7:X2} {8:X2} {9:X2} {10:X2} {11:X2} {12:X2} CRC 0x{13:X2}{14:X2}, Calculated CRC: 0x{15:X2}{16:X2}",
+                                                      lba, retries + 1, sense, subBuf[0], subBuf[1], subBuf[2],
+                                                      subBuf[3], subBuf[4], subBuf[5], subBuf[6], subBuf[7], subBuf[8],
+                                                      subBuf[9], subBuf[10], subBuf[11], crc[0], crc[1]);
+                        }
+                        else
+                            continue;
+                    }
+
+                    BcdToBinaryQ(subBuf);
+
+                    // Q position
+                    if((subBuf[0] & 0xF) != 1)
+                        continue;
+
+                    posQ = ((subBuf[7] * 60 * 75) + (subBuf[8] * 75) + subBuf[9]) - 150;
+
+                    if(subBuf[1] != track.TrackSequence - 1 ||
+                       subBuf[2] == 0                       ||
+                       posQ      != lba)
+                        break;
+
+                    pregaps[track.TrackSequence] = 0;
+
+                    pregapFound = true;
+                }
+
+                if(pregapFound)
+                    continue;
+
+                // Calculate pregap
+                lba = (int)track.TrackStartSector - 150;
+
+                while(lba > (int)previousTrack.TrackStartSector &&
+                      lba <= (int)track.TrackStartSector)
+                {
+                    // Some drives crash if you try to read just before the previous read, so seek away first
+                    if(!forward)
+                        sense = supportsRwSubchannel ? GetSectorForPregapRaw(dev, (uint)lba - 10, dbDev, out subBuf)
+                                    : GetSectorForPregapQ16(dev, (uint)lba                  - 10, dbDev, out subBuf);
+
+                    for(retries = 0; retries < 10; retries++)
+                    {
+                        sense = supportsRwSubchannel ? GetSectorForPregapRaw(dev, (uint)lba, dbDev, out subBuf)
+                                    : GetSectorForPregapQ16(dev, (uint)lba, dbDev, out subBuf);
+
+                        if(sense)
+                            continue;
+
+                        if(bcd == false)
+                            BinaryToBcdQ(subBuf);
+
+                        CRC16CCITTContext.Data(subBuf, 10, out crc);
+
+                        DicConsole.DebugWriteLine("Pregap calculator",
+                                                  "LBA: {0}, Try {1}, Sense {2}, Q: {3:X2} {4:X2} {5:X2} {6:X2} {7:X2} {8:X2} {9:X2} {10:X2} {11:X2} {12:X2} CRC 0x{13:X2}{14:X2}, Calculated CRC: 0x{15:X2}{16:X2}",
+                                                  lba, retries + 1, sense, subBuf[0], subBuf[1], subBuf[2], subBuf[3],
+                                                  subBuf[4], subBuf[5], subBuf[6], subBuf[7], subBuf[8], subBuf[9],
+                                                  subBuf[10], subBuf[11], crc[0], crc[1]);
+
+                        crcOk = crc[0] == subBuf[10] && crc[1] == subBuf[11];
+
+                        // Try to do a simple correction
+                        if(!crcOk)
+                        {
+                            // Data track cannot have 11xxb in CONTROL
+                            if((subBuf[0] & 0x40) > 0)
+                                subBuf[0] &= 0x7F;
+
+                            // ADR only uses two bits
+                            subBuf[0] &= 0xF3;
+
+                            // Don't care about other Q modes
+                            if((subBuf[0] & 0xF) == 1)
+                            {
+                                // ZERO only used in DDCD
+                                subBuf[6] = 0;
+
+                                // Fix BCD numbering
+                                for(int i = 1; i < 10; i++)
+                                {
+                                    if((subBuf[i] & 0xF0) > 0xA0)
+                                        subBuf[i] &= 0x7F;
+
+                                    if((subBuf[i] & 0x0F) > 0x0A)
+                                        subBuf[i] &= 0xF7;
+                                }
+                            }
+
+                            CRC16CCITTContext.Data(subBuf, 10, out crc);
+
+                            crcOk = crc[0] == subBuf[10] && crc[1] == subBuf[11];
+
+                            if(crcOk)
+                            {
+                                DicConsole.DebugWriteLine("Pregap calculator",
+                                                          "LBA: {0}, Try {1}, Sense {2}, Q (FIXED): {3:X2} {4:X2} {5:X2} {6:X2} {7:X2} {8:X2} {9:X2} {10:X2} {11:X2} {12:X2} CRC 0x{13:X2}{14:X2}, Calculated CRC: 0x{15:X2}{16:X2}",
+                                                          lba, retries + 1, sense, subBuf[0], subBuf[1], subBuf[2],
+                                                          subBuf[3], subBuf[4], subBuf[5], subBuf[6], subBuf[7],
+                                                          subBuf[8], subBuf[9], subBuf[10], subBuf[11], crc[0], crc[1]);
+
+                                break;
+                            }
+                        }
+
+                        if(crcOk)
+                            break;
+                    }
+
+                    if(retries == 10)
+                    {
+                        if(sense)
+                        {
+                            trackRetries++;
+
+                            if(trackRetries >= 10)
+                            {
+                                if(pregaps[track.TrackSequence] == 0)
+                                {
+                                    if((previousTrack.TrackType == TrackType.Audio &&
+                                        track.TrackType         != TrackType.Audio) ||
+                                       (previousTrack.TrackType != TrackType.Audio &&
+                                        track.TrackType         == TrackType.Audio))
+                                    {
+                                        dumpLog?.
+                                            WriteLine($"Could not read subchannel for this track, supposing 150 sectors.");
+
+                                        updateStatus?.
+                                            Invoke($"Could not read subchannel for this track, supposing 150 sectors.");
+                                    }
+                                    else
+                                    {
+                                        dumpLog?.
+                                            WriteLine($"Could not read subchannel for this track, supposing 0 sectors.");
+
+                                        updateStatus?.
+                                            Invoke($"Could not read subchannel for this track, supposing 0 sectors.");
+                                    }
+                                }
+                                else
+                                {
+                                    dumpLog?.
+                                        WriteLine($"Could not read subchannel for this track, supposing {pregaps[track.TrackSequence]} sectors.");
+
+                                    updateStatus?.
+                                        Invoke($"Could not read subchannel for this track, supposing {pregaps[track.TrackSequence]} sectors.");
+                                }
+
+                                break;
+                            }
+
+                            dumpLog?.WriteLine($"Could not read subchannel for sector {lba}");
+                            updateStatus?.Invoke($"Could not read subchannel for sector {lba}");
+
+                            lba++;
+                            forward = true;
+
+                            continue;
+                        }
+
+                        dumpLog?.WriteLine($"Could not get correct subchannel for sector {lba}");
+                        updateStatus?.Invoke($"Could not get correct subchannel for sector {lba}");
+                    }
+
+                    if(subBuf.All(b => b == 0))
+                    {
+                        inexactPositioning = true;
+
+                        DicConsole.DebugWriteLine("Pregap calculator", "All Q empty for LBA {0}", lba);
+
+                        break;
+                    }
+
+                    BcdToBinaryQ(subBuf);
+
+                    // If it's not Q position
+                    if((subBuf[0] & 0xF) != 1)
+                    {
+                        // This means we already searched back, so search forward
+                        if(goFront)
+                        {
+                            lba++;
+                            forward = true;
+
+                            if(lba == (int)previousTrack.TrackStartSector)
+                                break;
+
+                            continue;
+                        }
+
+                        // Search back
+                        goneBack = true;
+                        lba--;
+                        forward = false;
+
+                        continue;
+                    }
+
+                    // Previous track
+                    if(subBuf[1] < track.TrackSequence)
+                    {
+                        lba++;
+                        forward                       = true;
+                        previousPregapIsPreviousTrack = true;
+
+                        // Already gone back, so go forward
+                        if(goneBack)
+                            goFront = true;
+
+                        continue;
+                    }
+
+                    // Same track, but not pregap
+                    if(subBuf[1] == track.TrackSequence &&
+                       subBuf[2] > 0)
+                    {
+                        lba--;
+                        forward = false;
+
+                        if(previousPregapIsPreviousTrack)
+                            break;
+
+                        continue;
+                    }
+
+                    previousPregapIsPreviousTrack = false;
+
+                    // Pregap according to Q position
+                    posQ = ((subBuf[7] * 60 * 75) + (subBuf[8] * 75)                   + subBuf[9]) - 150;
+                    int diff    = posQ                                                 - lba;
+                    int pregapQ = (subBuf[3] * 60 * 75) + (subBuf[4] * 75) + subBuf[5] + 1;
+
+                    // If we obtained a Q from a previous sector, or we just came back from the previous track Q, sum the difference
+                    if(diff < 0 || forward)
+                        pregapQ += diff;
+
+                    if(diff != 0)
+                    {
+                        DicConsole.DebugWriteLine("Pregap calculator", "Invalid Q position for LBA {0}, got {1}", lba,
+                                                  posQ);
+
+                        inexactPositioning = true;
+                    }
+
+                    // Bigger than known change, otherwise we found it
+                    if(pregapQ > pregaps[track.TrackSequence])
+                    {
+                        // If CRC is not OK, only accept pregaps less than 10 sectors longer than previously now
+                        if(crcOk || pregapQ - pregaps[track.TrackSequence] < 10)
+                        {
+                            DicConsole.DebugWriteLine("Pregap calculator", "Pregap for track {0}: {1}",
+                                                      track.TrackSequence, pregapQ);
+
+                            pregaps[track.TrackSequence] = pregapQ;
+                        }
+
+                        // We are going forward, so we have already been in the previous track, so add 1 to pregap and get out of here
+                        else if(forward)
+                        {
+                            pregaps[track.TrackSequence]++;
+
+                            break;
+                        }
+                    }
+                    else if(pregapQ == pregaps[track.TrackSequence])
+                        break;
+
+                    lba--;
+                    forward = false;
+                }
+            }
+
+            for(int i = 0; i < tracks.Length; i++)
+            {
+                tracks[i].TrackPregap      =  (ulong)pregaps[tracks[i].TrackSequence];
+                tracks[i].TrackStartSector -= tracks[i].TrackPregap;
+
+            #if DEBUG
+                dumpLog?.WriteLine($"Track {tracks[i].TrackSequence} pregap is {tracks[i].TrackPregap} sectors");
+                updateStatus?.Invoke($"Track {tracks[i].TrackSequence} pregap is {tracks[i].TrackPregap} sectors");
+            #endif
+            }
+        }
+
+        static bool GetSectorForPregapRaw(Device dev, uint lba, Database.Models.Device dbDev, out byte[] subBuf)
+        {
+            byte[] cmdBuf;
+            bool   sense;
+            subBuf = null;
+
+            sense = dev.ReadCd(out cmdBuf, out _, lba, 2448, 1, MmcSectorTypes.AllTypes, false, false, true,
+                               MmcHeaderCodes.AllHeaders, true, true, MmcErrorField.None, MmcSubchannel.Raw,
+                               dev.Timeout, out _);
+
+            if(sense)
+                sense = dev.ReadCd(out cmdBuf, out _, lba, 2448, 1, MmcSectorTypes.Cdda, false, false, false,
+                                   MmcHeaderCodes.None, true, false, MmcErrorField.None, MmcSubchannel.Raw, dev.Timeout,
+                                   out _);
+
+            if(!sense)
+            {
+                byte[] tmpBuf = new byte[96];
+                Array.Copy(cmdBuf, 2352, tmpBuf, 0, 96);
+                subBuf = DeinterleaveQ(tmpBuf);
+            }
+            else
+            {
+                sense = dev.ReadCd(out cmdBuf, out _, lba, 96, 1, MmcSectorTypes.AllTypes, false, false, false,
+                                   MmcHeaderCodes.None, false, false, MmcErrorField.None, MmcSubchannel.Raw,
+                                   dev.Timeout, out _);
+
+                if(sense)
+                    sense = dev.ReadCd(out cmdBuf, out _, lba, 96, 1, MmcSectorTypes.Cdda, false, false, false,
+                                       MmcHeaderCodes.None, false, false, MmcErrorField.None, MmcSubchannel.Raw,
+                                       dev.Timeout, out _);
+
+                if(!sense)
+                {
+                    subBuf = DeinterleaveQ(cmdBuf);
+                }
+                else if(dbDev?.ATAPI?.RemovableMedias?.Any(d => d.SupportsPlextorReadCDDA == true) == true ||
+                        dbDev?.SCSI?.RemovableMedias?.Any(d => d.SupportsPlextorReadCDDA  == true) == true ||
+                        dev.Manufacturer.ToLowerInvariant()                                        == "plextor")
+                    sense = dev.PlextorReadCdDa(out cmdBuf, out _, lba, 2448, 1, PlextorSubchannel.All, dev.Timeout,
+                                                out _);
+
+                {
+                    if(!sense)
+                    {
+                        byte[] tmpBuf = new byte[96];
+                        Array.Copy(cmdBuf, 0, tmpBuf, 0, 96);
+                        subBuf = DeinterleaveQ(tmpBuf);
+                    }
+                }
+            }
+
+            return sense;
+        }
+
+        static bool GetSectorForPregapQ16(Device dev, uint lba, Database.Models.Device dbDev, out byte[] subBuf)
+        {
+            byte[] cmdBuf;
+            bool   sense;
+            subBuf = null;
+
+            sense = dev.ReadCd(out cmdBuf, out _, lba, 2368, 1, MmcSectorTypes.AllTypes, false, false, true,
+                               MmcHeaderCodes.AllHeaders, true, true, MmcErrorField.None, MmcSubchannel.Q16,
+                               dev.Timeout, out _);
+
+            if(sense)
+                sense = dev.ReadCd(out cmdBuf, out _, lba, 2368, 1, MmcSectorTypes.Cdda, false, false, false,
+                                   MmcHeaderCodes.None, true, false, MmcErrorField.None, MmcSubchannel.Q16, dev.Timeout,
+                                   out _);
+
+            if(!sense)
+            {
+                subBuf = new byte[16];
+                Array.Copy(cmdBuf, 2352, subBuf, 0, 16);
+            }
+            else
+            {
+                sense = dev.ReadCd(out cmdBuf, out _, lba, 16, 1, MmcSectorTypes.AllTypes, false, false, false,
+                                   MmcHeaderCodes.None, false, false, MmcErrorField.None, MmcSubchannel.Q16,
+                                   dev.Timeout, out _);
+
+                if(sense)
+                    sense = dev.ReadCd(out cmdBuf, out _, lba, 16, 1, MmcSectorTypes.Cdda, false, false, false,
+                                       MmcHeaderCodes.None, false, false, MmcErrorField.None, MmcSubchannel.Q16,
+                                       dev.Timeout, out _);
+
+                if(!sense)
+                    subBuf = cmdBuf;
+            }
+
+            return sense;
+        }
+
+        static byte[] DeinterleaveQ(byte[] subchannel)
+        {
+            int[] q = new int[subchannel.Length / 8];
+
+            // De-interlace Q subchannel
+            for(int iq = 0; iq < subchannel.Length; iq += 8)
+            {
+                q[iq / 8] =  (subchannel[iq] & 0x40) << 1;
+                q[iq / 8] += subchannel[iq + 1] & 0x40;
+                q[iq / 8] += (subchannel[iq + 2] & 0x40) >> 1;
+                q[iq / 8] += (subchannel[iq + 3] & 0x40) >> 2;
+                q[iq / 8] += (subchannel[iq + 4] & 0x40) >> 3;
+                q[iq / 8] += (subchannel[iq + 5] & 0x40) >> 4;
+                q[iq / 8] += (subchannel[iq + 6] & 0x40) >> 5;
+                q[iq / 8] += (subchannel[iq + 7] & 0x40) >> 6;
+            }
+
+            byte[] deQ = new byte[q.Length];
+
+            for(int iq = 0; iq < q.Length; iq++)
+            {
+                deQ[iq] = (byte)q[iq];
+            }
+
+            return deQ;
+        }
+
+        static void BinaryToBcdQ(byte[] q)
+        {
+            q[1] = (byte)(((q[1] / 10) << 4) + (q[1] % 10));
+            q[2] = (byte)(((q[2] / 10) << 4) + (q[2] % 10));
+            q[3] = (byte)(((q[3] / 10) << 4) + (q[3] % 10));
+            q[4] = (byte)(((q[4] / 10) << 4) + (q[4] % 10));
+            q[5] = (byte)(((q[5] / 10) << 4) + (q[5] % 10));
+            q[6] = (byte)(((q[6] / 10) << 4) + (q[6] % 10));
+            q[7] = (byte)(((q[7] / 10) << 4) + (q[7] % 10));
+            q[8] = (byte)(((q[8] / 10) << 4) + (q[8] % 10));
+            q[9] = (byte)(((q[9] / 10) << 4) + (q[9] % 10));
+        }
+
+        static void BcdToBinaryQ(byte[] q)
+        {
+            q[1] = (byte)(((q[1] / 16) * 10) + (q[1] & 0x0F));
+            q[2] = (byte)(((q[2] / 16) * 10) + (q[2] & 0x0F));
+            q[3] = (byte)(((q[3] / 16) * 10) + (q[3] & 0x0F));
+            q[4] = (byte)(((q[4] / 16) * 10) + (q[4] & 0x0F));
+            q[5] = (byte)(((q[5] / 16) * 10) + (q[5] & 0x0F));
+            q[6] = (byte)(((q[6] / 16) * 10) + (q[6] & 0x0F));
+            q[7] = (byte)(((q[7] / 16) * 10) + (q[7] & 0x0F));
+            q[8] = (byte)(((q[8] / 16) * 10) + (q[8] & 0x0F));
+            q[9] = (byte)(((q[9] / 16) * 10) + (q[9] & 0x0F));
+        }
+    }
+}

Aaru.Core/Devices/Dumping/CompactDisc/Subchannel.cs

@@ -0,0 +1,64 @@
+// /***************************************************************************
+// The Disc Image Chef
+// ----------------------------------------------------------------------------
+//
+// Filename       : CompactDisc.cs
+// Author(s)      : Natalia Portillo <claunia@claunia.com>
+//
+// Component      : Core algorithms.
+//
+// --[ Description ] ----------------------------------------------------------
+//
+//     Dumps CDs and DDCDs.
+//
+// --[ License ] --------------------------------------------------------------
+//
+//     This program is free software: you can redistribute it and/or modify
+//     it under the terms of the GNU General Public License as
+//     published by the Free Software Foundation, either version 3 of the
+//     License, or (at your option) any later version.
+//
+//     This program is distributed in the hope that it will be useful,
+//     but WITHOUT ANY WARRANTY; without even the implied warranty of
+//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//     GNU General Public License for more details.
+//
+//     You should have received a copy of the GNU General Public License
+//     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ----------------------------------------------------------------------------
+// Copyright © 2011-2020 Natalia Portillo
+// ****************************************************************************/
+
+using DiscImageChef.Core.Logging;
+using DiscImageChef.Devices;
+
+// ReSharper disable JoinDeclarationAndInitializer
+// ReSharper disable InlineOutVariableDeclaration
+// ReSharper disable TooWideLocalVariableScope
+
+namespace DiscImageChef.Core.Devices.Dumping
+{
+    partial class Dump
+    {
+        public static bool SupportsRwSubchannel(Device dev, DumpLog dumpLog, UpdateStatusHandler updateStatus)
+        {
+            dumpLog?.WriteLine("Checking if drive supports full raw subchannel reading...");
+            updateStatus?.Invoke("Checking if drive supports full raw subchannel reading...");
+
+            return!dev.ReadCd(out _, out _, 0, 2352 + 96, 1, MmcSectorTypes.AllTypes, false, false, true,
+                              MmcHeaderCodes.AllHeaders, true, true, MmcErrorField.None, MmcSubchannel.Raw, dev.Timeout,
+                              out _);
+        }
+
+        public static bool SupportsPqSubchannel(Device dev, DumpLog dumpLog, UpdateStatusHandler updateStatus)
+        {
+            dumpLog?.WriteLine("Checking if drive supports PQ subchannel reading...");
+            updateStatus?.Invoke("Checking if drive supports PQ subchannel reading...");
+
+            return!dev.ReadCd(out _, out _, 0, 2352 + 16, 1, MmcSectorTypes.AllTypes, false, false, true,
+                              MmcHeaderCodes.AllHeaders, true, true, MmcErrorField.None, MmcSubchannel.Q16, dev.Timeout,
+                              out _);
+        }
+    }
+}

Aaru.Core/Devices/Dumping/CompactDisc/Tags.cs

@@ -0,0 +1,147 @@
+// /***************************************************************************
+// The Disc Image Chef
+// ----------------------------------------------------------------------------
+//
+// Filename       : CompactDisc.cs
+// Author(s)      : Natalia Portillo <claunia@claunia.com>
+//
+// Component      : Core algorithms.
+//
+// --[ Description ] ----------------------------------------------------------
+//
+//     Dumps CDs and DDCDs.
+//
+// --[ License ] --------------------------------------------------------------
+//
+//     This program is free software: you can redistribute it and/or modify
+//     it under the terms of the GNU General Public License as
+//     published by the Free Software Foundation, either version 3 of the
+//     License, or (at your option) any later version.
+//
+//     This program is distributed in the hope that it will be useful,
+//     but WITHOUT ANY WARRANTY; without even the implied warranty of
+//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//     GNU General Public License for more details.
+//
+//     You should have received a copy of the GNU General Public License
+//     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ----------------------------------------------------------------------------
+// Copyright © 2011-2020 Natalia Portillo
+// ****************************************************************************/
+
+using System;
+using System.Collections.Generic;
+using DiscImageChef.CommonTypes;
+using DiscImageChef.CommonTypes.Enums;
+using DiscImageChef.Decoders.CD;
+using DiscImageChef.Decoders.SCSI.MMC;
+using DiscImageChef.Devices;
+
+// ReSharper disable JoinDeclarationAndInitializer
+// ReSharper disable InlineOutVariableDeclaration
+// ReSharper disable TooWideLocalVariableScope
+
+namespace DiscImageChef.Core.Devices.Dumping
+{
+    partial class Dump
+    {
+        /// <summary>Reads media tags from Compact Disc media</summary>
+        /// <param name="mediaType">Media type</param>
+        /// <param name="mediaTags">Media tags dictionary</param>
+        /// <param name="sessions">Sessions</param>
+        /// <param name="firstTrackLastSession">First track in last session</param>
+        void ReadCdTags(ref MediaType mediaType, Dictionary<MediaTagType, byte[]> mediaTags, out int sessions,
+                        out int firstTrackLastSession)
+        {
+            byte[] cmdBuf; // Data buffer
+            bool   sense;  // Sense indicator
+            byte[] tmpBuf; // Temporary buffer
+            sessions              = 1;
+            firstTrackLastSession = 1;
+
+            // ATIP exists on blank CDs
+            _dumpLog.WriteLine("Reading ATIP");
+            UpdateStatus?.Invoke("Reading ATIP");
+            sense = _dev.ReadAtip(out cmdBuf, out _, _dev.Timeout, out _);
+
+            if(!sense)
+            {
+                ATIP.CDATIP? atip = ATIP.Decode(cmdBuf);
+
+                if(atip.HasValue)
+                {
+                    // Only CD-R and CD-RW have ATIP
+                    mediaType = atip.Value.DiscType ? MediaType.CDRW : MediaType.CDR;
+
+                    tmpBuf = new byte[cmdBuf.Length - 4];
+                    Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
+                    mediaTags.Add(MediaTagType.CD_ATIP, tmpBuf);
+                }
+            }
+
+            _dumpLog.WriteLine("Reading Disc Information");
+            UpdateStatus?.Invoke("Reading Disc Information");
+
+            sense = _dev.ReadDiscInformation(out cmdBuf, out _, MmcDiscInformationDataTypes.DiscInformation,
+                                             _dev.Timeout, out _);
+
+            if(!sense)
+            {
+                DiscInformation.StandardDiscInformation? discInfo = DiscInformation.Decode000b(cmdBuf);
+
+                if(discInfo.HasValue &&
+                   mediaType == MediaType.CD)
+                    switch(discInfo.Value.DiscType)
+                    {
+                        case 0x10:
+                            mediaType = MediaType.CDI;
+
+                            break;
+                        case 0x20:
+                            mediaType = MediaType.CDROMXA;
+
+                            break;
+                    }
+            }
+
+            _dumpLog.WriteLine("Reading PMA");
+            UpdateStatus?.Invoke("Reading PMA");
+            sense = _dev.ReadPma(out cmdBuf, out _, _dev.Timeout, out _);
+
+            if(!sense &&
+               PMA.Decode(cmdBuf).HasValue)
+            {
+                tmpBuf = new byte[cmdBuf.Length - 4];
+                Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
+                mediaTags.Add(MediaTagType.CD_PMA, tmpBuf);
+            }
+
+            _dumpLog.WriteLine("Reading Session Information");
+            UpdateStatus?.Invoke("Reading Session Information");
+            sense = _dev.ReadSessionInfo(out cmdBuf, out _, _dev.Timeout, out _);
+
+            if(!sense)
+            {
+                Session.CDSessionInfo? session = Session.Decode(cmdBuf);
+
+                if(session.HasValue)
+                {
+                    sessions              = session.Value.LastCompleteSession;
+                    firstTrackLastSession = session.Value.TrackDescriptors[0].TrackNumber;
+                }
+            }
+
+            _dumpLog.WriteLine("Reading CD-Text from Lead-In");
+            UpdateStatus?.Invoke("Reading CD-Text from Lead-In");
+            sense = _dev.ReadCdText(out cmdBuf, out _, _dev.Timeout, out _);
+
+            if(sense || !CDTextOnLeadIn.Decode(cmdBuf).HasValue)
+                return;
+
+            tmpBuf = new byte[cmdBuf.Length - 4];
+            Array.Copy(cmdBuf, 4, tmpBuf, 0, cmdBuf.Length - 4);
+            mediaTags.Add(MediaTagType.CD_TEXT, tmpBuf);
+        }
+    }
+}

Aaru.Core/Devices/Dumping/CompactDisc/Tracks.cs

@@ -0,0 +1,304 @@
+// /***************************************************************************
+// The Disc Image Chef
+// ----------------------------------------------------------------------------
+//
+// Filename       : CompactDisc.cs
+// Author(s)      : Natalia Portillo <claunia@claunia.com>
+//
+// Component      : Core algorithms.
+//
+// --[ Description ] ----------------------------------------------------------
+//
+//     Dumps CDs and DDCDs.
+//
+// --[ License ] --------------------------------------------------------------
+//
+//     This program is free software: you can redistribute it and/or modify
+//     it under the terms of the GNU General Public License as
+//     published by the Free Software Foundation, either version 3 of the
+//     License, or (at your option) any later version.
+//
+//     This program is distributed in the hope that it will be useful,
+//     but WITHOUT ANY WARRANTY; without even the implied warranty of
+//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//     GNU General Public License for more details.
+//
+//     You should have received a copy of the GNU General Public License
+//     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ----------------------------------------------------------------------------
+// Copyright © 2011-2020 Natalia Portillo
+// ****************************************************************************/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using DiscImageChef.CommonTypes;
+using DiscImageChef.CommonTypes.Enums;
+using DiscImageChef.CommonTypes.Structs;
+using DiscImageChef.Core.Logging;
+using DiscImageChef.Decoders.CD;
+using DiscImageChef.Devices;
+
+// ReSharper disable JoinDeclarationAndInitializer
+// ReSharper disable InlineOutVariableDeclaration
+// ReSharper disable TooWideLocalVariableScope
+
+namespace DiscImageChef.Core.Devices.Dumping
+{
+    partial class Dump
+    {
+        /// <summary>Reads the TOC, processes it, returns the track list and last sector</summary>
+        /// <param name="blockSize">Size of the read sector in bytes</param>
+        /// <param name="dev">Device</param>
+        /// <param name="dskType">Disc type</param>
+        /// <param name="dumpLog">Dump log</param>
+        /// <param name="force">Force dump enabled</param>
+        /// <param name="lastSector">Last sector number</param>
+        /// <param name="leadOutStarts">Lead-out starts</param>
+        /// <param name="mediaTags">Media tags</param>
+        /// <param name="stoppingErrorMessage">Stopping error message handler</param>
+        /// <param name="subType">Track subchannel type</param>
+        /// <param name="toc">Full CD TOC</param>
+        /// <param name="trackFlags">Track flags</param>
+        /// <param name="updateStatus">Update status handler</param>
+        /// <returns>List of tracks</returns>
+        public static Track[] GetCdTracks(ref uint blockSize, Device dev, MediaType dskType, DumpLog dumpLog,
+                                          bool force, out long lastSector, Dictionary<int, long> leadOutStarts,
+                                          Dictionary<MediaTagType, byte[]> mediaTags,
+                                          ErrorMessageHandler stoppingErrorMessage, TrackSubchannelType subType,
+                                          out FullTOC.CDFullTOC? toc, Dictionary<byte, byte> trackFlags,
+                                          UpdateStatusHandler updateStatus)
+        {
+            byte[]      cmdBuf     = null;              // Data buffer
+            const uint  sectorSize = 2352;              // Full sector size
+            bool        sense      = true;              // Sense indicator
+            List<Track> trackList  = new List<Track>(); // Tracks in disc
+            byte[]      tmpBuf;                         // Temporary buffer
+            toc        = null;
+            lastSector = 0;
+            TrackType leadoutTrackType = TrackType.Audio;
+
+            // We discarded all discs that falsify a TOC before requesting a real TOC
+            // No TOC, no CD (or an empty one)
+            dumpLog?.WriteLine("Reading full TOC");
+            updateStatus?.Invoke("Reading full TOC");
+            sense = dev.ReadRawToc(out cmdBuf, out _, 0, dev.Timeout, out _);
+
+            if(!sense)
+            {
+                toc = FullTOC.Decode(cmdBuf);
+
+                if(toc.HasValue)
+                {
+                    tmpBuf = new byte[cmdBuf.Length - 2];
+                    Array.Copy(cmdBuf, 2, tmpBuf, 0, cmdBuf.Length - 2);
+                    mediaTags?.Add(MediaTagType.CD_FullTOC, tmpBuf);
+                }
+            }
+
+            updateStatus?.Invoke("Building track map...");
+            dumpLog?.WriteLine("Building track map...");
+
+            if(toc.HasValue)
+            {
+                FullTOC.TrackDataDescriptor[] sortedTracks =
+                    toc.Value.TrackDescriptors.OrderBy(track => track.POINT).ToArray();
+
+                foreach(FullTOC.TrackDataDescriptor trk in sortedTracks.Where(trk => trk.ADR == 1 || trk.ADR == 4))
+                    if(trk.POINT >= 0x01 &&
+                       trk.POINT <= 0x63)
+                    {
+                        trackList.Add(new Track
+                        {
+                            TrackSequence = trk.POINT, TrackSession = trk.SessionNumber,
+                            TrackType = (TocControl)(trk.CONTROL & 0x0D) == TocControl.DataTrack ||
+                                        (TocControl)(trk.CONTROL & 0x0D) == TocControl.DataTrackIncremental
+                                            ? TrackType.Data : TrackType.Audio,
+                            TrackStartSector =
+                                (ulong)(((trk.PHOUR * 3600 * 75) + (trk.PMIN * 60 * 75) + (trk.PSEC * 75) +
+                                         trk.PFRAME) - 150),
+                            TrackBytesPerSector    = (int)sectorSize,
+                            TrackRawBytesPerSector = (int)sectorSize,
+                            TrackSubchannelType    = subType
+                        });
+
+                        trackFlags?.Add(trk.POINT, trk.CONTROL);
+                    }
+                    else if(trk.POINT == 0xA2)
+                    {
+                        int phour, pmin, psec, pframe;
+
+                        if(trk.PFRAME == 0)
+                        {
+                            pframe = 74;
+
+                            if(trk.PSEC == 0)
+                            {
+                                psec = 59;
+
+                                if(trk.PMIN == 0)
+                                {
+                                    pmin  = 59;
+                                    phour = trk.PHOUR - 1;
+                                }
+                                else
+                                {
+                                    pmin  = trk.PMIN - 1;
+                                    phour = trk.PHOUR;
+                                }
+                            }
+                            else
+                            {
+                                psec  = trk.PSEC - 1;
+                                pmin  = trk.PMIN;
+                                phour = trk.PHOUR;
+                            }
+                        }
+                        else
+                        {
+                            pframe = trk.PFRAME - 1;
+                            psec   = trk.PSEC;
+                            pmin   = trk.PMIN;
+                            phour  = trk.PHOUR;
+                        }
+
+                        lastSector = ((phour * 3600 * 75) + (pmin * 60 * 75) + (psec * 75) + pframe) - 150;
+                        leadOutStarts?.Add(trk.SessionNumber, lastSector                   + 1);
+                    }
+                    else if(trk.POINT == 0xA0 &&
+                            trk.ADR   == 1)
+                    {
+                        switch(trk.PSEC)
+                        {
+                            case 0x10:
+                                dskType = MediaType.CDI;
+
+                                break;
+                            case 0x20:
+                                if(dskType == MediaType.CD ||
+                                   dskType == MediaType.CDROM)
+                                    dskType = MediaType.CDROMXA;
+
+                                break;
+                        }
+
+                        leadoutTrackType =
+                            (TocControl)(trk.CONTROL & 0x0D) == TocControl.DataTrack ||
+                            (TocControl)(trk.CONTROL & 0x0D) == TocControl.DataTrackIncremental ? TrackType.Data
+                                : TrackType.Audio;
+                    }
+            }
+            else
+            {
+                updateStatus?.Invoke("Cannot read RAW TOC, requesting processed one...");
+                dumpLog?.WriteLine("Cannot read RAW TOC, requesting processed one...");
+                sense = dev.ReadToc(out cmdBuf, out _, false, 0, dev.Timeout, out _);
+
+                TOC.CDTOC? oldToc = TOC.Decode(cmdBuf);
+
+                if((sense || !oldToc.HasValue) &&
+                   !force)
+                {
+                    dumpLog?.WriteLine("Could not read TOC, if you want to continue, use force, and will try from LBA 0 to 360000...");
+
+                    stoppingErrorMessage?.
+                        Invoke("Could not read TOC, if you want to continue, use force, and will try from LBA 0 to 360000...");
+
+                    return null;
+                }
+
+                foreach(TOC.CDTOCTrackDataDescriptor trk in oldToc.
+                                                            Value.TrackDescriptors.OrderBy(t => t.TrackNumber).
+                                                            Where(trk => trk.ADR == 1 || trk.ADR == 4))
+                    if(trk.TrackNumber >= 0x01 &&
+                       trk.TrackNumber <= 0x63)
+                    {
+                        trackList.Add(new Track
+                        {
+                            TrackSequence = trk.TrackNumber, TrackSession = 1,
+                            TrackType = (TocControl)(trk.CONTROL & 0x0D) == TocControl.DataTrack ||
+                                        (TocControl)(trk.CONTROL & 0x0D) == TocControl.DataTrackIncremental
+                                            ? TrackType.Data : TrackType.Audio,
+                            TrackStartSector       = trk.TrackStartAddress, TrackBytesPerSector = (int)sectorSize,
+                            TrackRawBytesPerSector = (int)sectorSize, TrackSubchannelType       = subType
+                        });
+
+                        trackFlags?.Add(trk.TrackNumber, trk.CONTROL);
+                    }
+                    else if(trk.TrackNumber == 0xAA)
+                    {
+                        leadoutTrackType =
+                            (TocControl)(trk.CONTROL & 0x0D) == TocControl.DataTrack ||
+                            (TocControl)(trk.CONTROL & 0x0D) == TocControl.DataTrackIncremental ? TrackType.Data
+                                : TrackType.Audio;
+
+                        lastSector = trk.TrackStartAddress - 1;
+                    }
+            }
+
+            if(trackList.Count == 0)
+            {
+                updateStatus?.Invoke("No tracks found, adding a single track from 0 to Lead-Out");
+                dumpLog?.WriteLine("No tracks found, adding a single track from 0 to Lead-Out");
+
+                trackList.Add(new Track
+                {
+                    TrackSequence       = 1, TrackSession = 1, TrackType = leadoutTrackType,
+                    TrackStartSector    = 0,
+                    TrackBytesPerSector = (int)sectorSize, TrackRawBytesPerSector = (int)sectorSize,
+                    TrackSubchannelType = subType
+                });
+
+                trackFlags?.Add(1, (byte)(leadoutTrackType == TrackType.Audio ? 0 : 4));
+            }
+
+            if(lastSector == 0)
+            {
+                sense = dev.ReadCapacity16(out cmdBuf, out _, dev.Timeout, out _);
+
+                if(!sense)
+                {
+                    byte[] temp = new byte[8];
+
+                    Array.Copy(cmdBuf, 0, temp, 0, 8);
+                    Array.Reverse(temp);
+                    lastSector = (long)BitConverter.ToUInt64(temp, 0);
+                    blockSize  = (uint)((cmdBuf[5] << 24) + (cmdBuf[5] << 16) + (cmdBuf[6] << 8) + cmdBuf[7]);
+                }
+                else
+                {
+                    sense = dev.ReadCapacity(out cmdBuf, out _, dev.Timeout, out _);
+
+                    if(!sense)
+                    {
+                        lastSector = (cmdBuf[0] << 24) + (cmdBuf[1] << 16) + (cmdBuf[2] << 8) + cmdBuf[3];
+                        blockSize  = (uint)((cmdBuf[5] << 24) + (cmdBuf[5] << 16) + (cmdBuf[6] << 8) + cmdBuf[7]);
+                    }
+                }
+
+                if(lastSector <= 0)
+                {
+                    if(!force)
+                    {
+                        stoppingErrorMessage?.
+                            Invoke("Could not find Lead-Out, if you want to continue use force option and will continue until 360000 sectors...");
+
+                        dumpLog?.
+                            WriteLine("Could not find Lead-Out, if you want to continue use force option and will continue until 360000 sectors...");
+
+                        return null;
+                    }
+
+                    updateStatus?.
+                        Invoke("WARNING: Could not find Lead-Out start, will try to read up to 360000 sectors, probably will fail before...");
+
+                    dumpLog?.WriteLine("WARNING: Could not find Lead-Out start, will try to read up to 360000 sectors, probably will fail before...");
+                    lastSector = 360000;
+                }
+            }
+
+            return trackList.ToArray();
+        }
+    }
+}

Aaru.Core/Devices/Dumping/CompactDisc/Trim.cs

@@ -0,0 +1,210 @@
+// /***************************************************************************
+// The Disc Image Chef
+// ----------------------------------------------------------------------------
+//
+// Filename       : CompactDisc.cs
+// Author(s)      : Natalia Portillo <claunia@claunia.com>
+//
+// Component      : Core algorithms.
+//
+// --[ Description ] ----------------------------------------------------------
+//
+//     Dumps CDs and DDCDs.
+//
+// --[ License ] --------------------------------------------------------------
+//
+//     This program is free software: you can redistribute it and/or modify
+//     it under the terms of the GNU General Public License as
+//     published by the Free Software Foundation, either version 3 of the
+//     License, or (at your option) any later version.
+//
+//     This program is distributed in the hope that it will be useful,
+//     but WITHOUT ANY WARRANTY; without even the implied warranty of
+//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//     GNU General Public License for more details.
+//
+//     You should have received a copy of the GNU General Public License
+//     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// ----------------------------------------------------------------------------
+// Copyright © 2011-2020 Natalia Portillo
+// ****************************************************************************/
+
+using System;
+using DiscImageChef.CommonTypes.Enums;
+using DiscImageChef.CommonTypes.Extents;
+using DiscImageChef.Devices;
+using Schemas;
+
+// ReSharper disable JoinDeclarationAndInitializer
+// ReSharper disable InlineOutVariableDeclaration
+// ReSharper disable TooWideLocalVariableScope
+
+namespace DiscImageChef.Core.Devices.Dumping
+{
+    partial class Dump
+    {
+        void TrimCdUserData(ExtentsULong audioExtents, uint blockSize, DumpHardwareType currentTry,
+                            ExtentsULong extents, bool newTrim, int offsetBytes, bool read6, bool read10, bool read12,
+                            bool read16, bool readcd, int sectorsForOffset, uint subSize,
+                            MmcSubchannel supportedSubchannel, bool supportsLongSectors, ref double totalDuration)
+        {
+            DateTime   start;
+            DateTime   end;
+            bool       sense       = true; // Sense indicator
+            byte[]     cmdBuf      = null; // Data buffer
+            double     cmdDuration = 0;    // Command execution time
+            const uint sectorSize  = 2352; // Full sector size
+            byte[]     tmpBuf;             // Temporary buffer
+
+            if(_resume.BadBlocks.Count <= 0 ||
+               _aborted                     ||
+               !_trim                       ||
+               !newTrim)
+                return;
+
+            start = DateTime.UtcNow;
+            UpdateStatus?.Invoke("Trimming bad sectors");
+            _dumpLog.WriteLine("Trimming bad sectors");
+
+            ulong[] tmpArray = _resume.BadBlocks.ToArray();
+            InitProgress?.Invoke();
+
+            foreach(ulong badSector in tmpArray)
+            {
+                if(_aborted)
+                {
+                    currentTry.Extents = ExtentsConverter.ToMetadata(extents);
+                    UpdateStatus?.Invoke("Aborted!");
+                    _dumpLog.WriteLine("Aborted!");
+
+                    break;
+                }
+
+                PulseProgress?.Invoke($"Trimming sector {badSector}");
+
+                byte sectorsToTrim   = 1;
+                uint badSectorToRead = (uint)badSector;
+
+                if(_fixOffset                       &&
+                   audioExtents.Contains(badSector) &&
+                   offsetBytes != 0)
+                {
+                    if(offsetBytes > 0)
+                    {
+                        badSectorToRead -= (uint)sectorsForOffset;
+                    }
+
+                    sectorsToTrim = (byte)(sectorsForOffset + 1);
+                }
+
+                if(readcd)
+                    sense = _dev.ReadCd(out cmdBuf, out _, badSectorToRead, blockSize, sectorsToTrim,
+                                        MmcSectorTypes.AllTypes, false, false, true, MmcHeaderCodes.AllHeaders, true,
+                                        true, MmcErrorField.None, supportedSubchannel, _dev.Timeout, out cmdDuration);
+                else if(read16)
+                    sense = _dev.Read16(out cmdBuf, out _, 0, false, true, false, badSectorToRead, blockSize, 0,
+                                        sectorsToTrim, false, _dev.Timeout, out cmdDuration);
+                else if(read12)
+                    sense = _dev.Read12(out cmdBuf, out _, 0, false, true, false, false, badSectorToRead, blockSize, 0,
+                                        sectorsToTrim, false, _dev.Timeout, out cmdDuration);
+                else if(read10)
+                    sense = _dev.Read10(out cmdBuf, out _, 0, false, true, false, false, badSectorToRead, blockSize, 0,
+                                        sectorsToTrim, _dev.Timeout, out cmdDuration);
+                else if(read6)
+                    sense = _dev.Read6(out cmdBuf, out _, badSectorToRead, blockSize, sectorsToTrim, _dev.Timeout,
+                                       out cmdDuration);
+
+                totalDuration += cmdDuration;
+
+                if(sense || _dev.Error)
+                    continue;
+
+                if(!sense &&
+                   !_dev.Error)
+                {
+                    _resume.BadBlocks.Remove(badSector);
+                    extents.Add(badSector);
+                }
+
+                // Because one block has been partially used to fix the offset
+                if(_fixOffset                       &&
+                   audioExtents.Contains(badSector) &&
+                   offsetBytes != 0)
+                {
+                    int offsetFix = offsetBytes < 0 ? (int)(sectorSize - (offsetBytes * -1)) : offsetBytes;
+
+                    if(supportedSubchannel != MmcSubchannel.None)
+                    {
+                        // De-interleave subchannel
+                        byte[] data = new byte[sectorSize * sectorsToTrim];
+                        byte[] sub  = new byte[subSize    * sectorsToTrim];
+
+                        for(int b = 0; b < sectorsToTrim; b++)
+                        {
+                            Array.Copy(cmdBuf, (int)(0 + (b * blockSize)), data, sectorSize * b, sectorSize);
+
+                            Array.Copy(cmdBuf, (int)(sectorSize + (b * blockSize)), sub, subSize * b, subSize);
+                        }
+
+                        tmpBuf = new byte[sectorSize * (sectorsToTrim - sectorsForOffset)];
+                        Array.Copy(data, offsetFix, tmpBuf, 0, tmpBuf.Length);
+                        data = tmpBuf;
+
+                        // Re-interleave subchannel
+                        cmdBuf = new byte[blockSize * sectorsToTrim];
+
+                        for(int b = 0; b < sectorsToTrim; b++)
+                        {
+                            Array.Copy(data, sectorSize * b, cmdBuf, (int)(0 + (b * blockSize)), sectorSize);
+
+                            Array.Copy(sub, subSize * b, cmdBuf, (int)(sectorSize + (b * blockSize)), subSize);
+                        }
+                    }
+                    else
+                    {
+                        tmpBuf = new byte[blockSize * (sectorsToTrim - sectorsForOffset)];
+                        Array.Copy(cmdBuf, offsetFix, tmpBuf, 0, tmpBuf.Length);
+                        cmdBuf = tmpBuf;
+                    }
+                }
+
+                if(supportedSubchannel != MmcSubchannel.None)
+                {
+                    byte[] data = new byte[sectorSize];
+                    byte[] sub  = new byte[subSize];
+                    Array.Copy(cmdBuf, 0, data, 0, sectorSize);
+                    Array.Copy(cmdBuf, sectorSize, sub, 0, subSize);
+                    _outputPlugin.WriteSectorLong(data, badSector);
+                    _outputPlugin.WriteSectorTag(sub, badSector, SectorTagType.CdSectorSubchannel);
+                }
+                else
+                {
+                    if(supportsLongSectors)
+                    {
+                        _outputPlugin.WriteSectorLong(cmdBuf, badSector);
+                    }
+                    else
+                    {
+                        if(cmdBuf.Length % sectorSize == 0)
+                        {
+                            byte[] data = new byte[2048];
+                            Array.Copy(cmdBuf, 16, data, 0, 2048);
+
+                            _outputPlugin.WriteSector(data, badSector);
+                        }
+                        else
+                        {
+                            _outputPlugin.WriteSectorLong(cmdBuf, badSector);
+                        }
+                    }
+                }
+            }
+
+            EndProgress?.Invoke();
+            end = DateTime.UtcNow;
+            UpdateStatus?.Invoke($"Trimming finished in {(end - start).TotalSeconds} seconds.");
+            _dumpLog.WriteLine("Trimming finished in {0} seconds.", (end - start).TotalSeconds);
+        }
+    }
+}