From 4de10d0c347900d98d20efcadbbc0c6e35891186 Mon Sep 17 00:00:00 2001
From: Natalia Portillo <claunia@claunia.com>
Date: Tue, 28 Dec 2021 00:14:33 +0000
Subject: [PATCH] Clarify interface usage.

---
 .../.idea/runConfigurations/Aaru.xml          |   2 +-
 Aaru.CommonTypes                              |   2 +-
 Aaru.Core/Aaru.Core.csproj                    |   1 +
 Aaru.Core/Devices/Dumping/ATA.cs              |  45 +++---
 .../Devices/Dumping/CompactDisc/CdiReady.cs   |  19 +--
 Aaru.Core/Devices/Dumping/CompactDisc/Data.cs |  45 +++---
 Aaru.Core/Devices/Dumping/CompactDisc/Dump.cs |  65 ++++----
 .../Devices/Dumping/CompactDisc/Error.cs      |  28 ++--
 .../Devices/Dumping/CompactDisc/LeadOuts.cs   |  46 +++---
 Aaru.Core/Devices/Dumping/CompactDisc/Trim.cs |  15 +-
 Aaru.Core/Devices/Dumping/Dump.cs             |   4 +-
 Aaru.Core/Devices/Dumping/MiniDisc.cs         |  33 ++--
 .../PlayStationPortable/MemoryStick.cs        |  27 ++--
 .../Dumping/PlayStationPortable/UMD.cs        |  29 ++--
 Aaru.Core/Devices/Dumping/SSC.cs              |  60 +++----
 Aaru.Core/Devices/Dumping/Sbc/Data.cs         |  26 ++--
 Aaru.Core/Devices/Dumping/Sbc/Dump.cs         |  73 ++++-----
 Aaru.Core/Devices/Dumping/Sbc/Error.cs        |  19 ++-
 Aaru.Core/Devices/Dumping/Sbc/Optical.cs      |   6 +-
 Aaru.Core/Devices/Dumping/Sbc/Trim.cs         |   6 +-
 Aaru.Core/Devices/Dumping/SecureDigital.cs    |  49 +++---
 Aaru.Core/Devices/Dumping/XGD.cs              |  43 +++---
 Aaru.Core/Media/CompactDisc.cs                |   2 +-
 .../Windows/ImageConvertViewModel.cs          |   4 +-
 Aaru.Images/Register.cs                       |   2 +-
 Aaru/Commands/Formats.cs                      |   2 +-
 Aaru/Commands/Image/Convert.cs                | 146 +++++++++---------
 Aaru/Commands/Image/Options.cs                |   2 +-
 Aaru/Commands/Media/Dump.cs                   |  10 +-
 29 files changed, 419 insertions(+), 392 deletions(-)

diff --git a/.idea/.idea.Aaru/.idea/runConfigurations/Aaru.xml b/.idea/.idea.Aaru/.idea/runConfigurations/Aaru.xml
index 70e1a9c6c..40360c4cb 100644
--- a/.idea/.idea.Aaru/.idea/runConfigurations/Aaru.xml
+++ b/.idea/.idea.Aaru/.idea/runConfigurations/Aaru.xml
@@ -1,7 +1,7 @@
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="Aaru" type="DotNetProject" factoryName=".NET Project">
     <option name="EXE_PATH" value="$PROJECT_DIR$/Aaru/bin/Debug/net6/aaru" />
-    <option name="PROGRAM_PARAMETERS" value="i info &quot;Addams Family Values (Europe) (En,Fr,De).sfc&quot;" />
+    <option name="PROGRAM_PARAMETERS" value="m dump /dev/sda foo.sfc" />
     <option name="WORKING_DIRECTORY" value="$USER_HOME$/Desktop" />
     <option name="PASS_PARENT_ENVS" value="1" />
     <option name="USE_EXTERNAL_CONSOLE" value="0" />
diff --git a/Aaru.CommonTypes b/Aaru.CommonTypes
index ac7cef9a7..ddb07568c 160000
--- a/Aaru.CommonTypes
+++ b/Aaru.CommonTypes
@@ -1 +1 @@
-Subproject commit ac7cef9a7167754b3d2fd924ba61fd4f648decec
+Subproject commit ddb07568c2ea4ce483ad0a36b3773fc8888f03f3
diff --git a/Aaru.Core/Aaru.Core.csproj b/Aaru.Core/Aaru.Core.csproj
index 110e5418c..030bf7fa7 100644
--- a/Aaru.Core/Aaru.Core.csproj
+++ b/Aaru.Core/Aaru.Core.csproj
@@ -71,6 +71,7 @@
     <Compile Include="Devices\Dumping\CompactDisc\Tracks.cs" />
     <Compile Include="Devices\Dumping\CompactDisc\Trim.cs" />
     <Compile Include="Devices\Dumping\Dump.cs" />
+    <Compile Include="Devices\Dumping\LinearMemory\Retrode.cs" />
     <Compile Include="Devices\Dumping\Metadata.cs" />
     <Compile Include="Devices\Dumping\MiniDisc.cs" />
     <Compile Include="Devices\Dumping\PlayStationPortable\MemoryStick.cs" />
diff --git a/Aaru.Core/Devices/Dumping/ATA.cs b/Aaru.Core/Devices/Dumping/ATA.cs
index 5553e0633..0ef489861 100644
--- a/Aaru.Core/Devices/Dumping/ATA.cs
+++ b/Aaru.Core/Devices/Dumping/ATA.cs
@@ -57,6 +57,7 @@ namespace Aaru.Core.Devices.Dumping
         void Ata()
         {
             bool recoveredError;
+            var  outputFormat = _outputPlugin as IWritableImage;
 
             if(_dumpRaw)
             {
@@ -183,7 +184,7 @@ namespace Aaru.Core.Devices.Dumping
 
                     if(_dev.IsUsb                  &&
                        _dev.UsbDescriptors != null &&
-                       !_outputPlugin.SupportedMediaTags.Contains(MediaTagType.USB_Descriptors))
+                       !outputFormat.SupportedMediaTags.Contains(MediaTagType.USB_Descriptors))
                     {
                         ret = false;
                         _dumpLog.WriteLine("Output format does not support USB descriptors.");
@@ -192,14 +193,14 @@ namespace Aaru.Core.Devices.Dumping
 
                     if(_dev.IsPcmcia    &&
                        _dev.Cis != null &&
-                       !_outputPlugin.SupportedMediaTags.Contains(MediaTagType.PCMCIA_CIS))
+                       !outputFormat.SupportedMediaTags.Contains(MediaTagType.PCMCIA_CIS))
                     {
                         ret = false;
                         _dumpLog.WriteLine("Output format does not support PCMCIA CIS descriptors.");
                         ErrorMessage("Output format does not support PCMCIA CIS descriptors.");
                     }
 
-                    if(!_outputPlugin.SupportedMediaTags.Contains(MediaTagType.ATA_IDENTIFY))
+                    if(!outputFormat.SupportedMediaTags.Contains(MediaTagType.ATA_IDENTIFY))
                     {
                         ret = false;
                         _dumpLog.WriteLine("Output format does not support ATA IDENTIFY.");
@@ -223,22 +224,22 @@ namespace Aaru.Core.Devices.Dumping
                     mediaType = MediaTypeFromDevice.GetFromAta(_dev.Manufacturer, _dev.Model, _dev.IsRemovable,
                                                                _dev.IsCompactFlash, _dev.IsPcmcia, blocks);
 
-                    ret = _outputPlugin.Create(_outputPath, mediaType, _formatOptions, blocks, blockSize);
+                    ret = outputFormat.Create(_outputPath, mediaType, _formatOptions, blocks, blockSize);
 
                     // Cannot create image
                     if(!ret)
                     {
                         _dumpLog.WriteLine("Error creating output image, not continuing.");
-                        _dumpLog.WriteLine(_outputPlugin.ErrorMessage);
+                        _dumpLog.WriteLine(outputFormat.ErrorMessage);
 
                         StoppingErrorMessage?.Invoke("Error creating output image, not continuing." +
-                                                     Environment.NewLine + _outputPlugin.ErrorMessage);
+                                                     Environment.NewLine + outputFormat.ErrorMessage);
 
                         return;
                     }
 
                     // Setting geometry
-                    _outputPlugin.SetGeometry(cylinders, heads, sectors);
+                    outputFormat.SetGeometry(cylinders, heads, sectors);
 
                     if(ataReader.IsLba)
                     {
@@ -297,7 +298,7 @@ namespace Aaru.Core.Devices.Dumping
                                 mhddLog.Write(i, duration);
                                 ibgLog.Write(i, currentSpeed * 1024);
                                 DateTime writeStart = DateTime.Now;
-                                _outputPlugin.WriteSectors(cmdBuf, i, blocksToRead);
+                                outputFormat.WriteSectors(cmdBuf, i, blocksToRead);
                                 imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
                                 extents.Add(i, blocksToRead, true);
                             }
@@ -313,7 +314,7 @@ namespace Aaru.Core.Devices.Dumping
 
                                 ibgLog.Write(i, 0);
                                 DateTime writeStart = DateTime.Now;
-                                _outputPlugin.WriteSectors(new byte[blockSize * _skip], i, _skip);
+                                outputFormat.WriteSectors(new byte[blockSize * _skip], i, _skip);
                                 imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
                                 _dumpLog.WriteLine("Skipping {0} blocks from errored block {1}.", _skip, i);
                                 i       += _skip - blocksToRead;
@@ -394,7 +395,7 @@ namespace Aaru.Core.Devices.Dumping
 
                                 _resume.BadBlocks.Remove(badSector);
                                 extents.Add(badSector);
-                                _outputPlugin.WriteSector(cmdBuf, badSector);
+                                outputFormat.WriteSector(cmdBuf, badSector);
                             }
 
                             EndProgress?.Invoke();
@@ -440,12 +441,12 @@ namespace Aaru.Core.Devices.Dumping
                                 {
                                     _resume.BadBlocks.Remove(badSector);
                                     extents.Add(badSector);
-                                    _outputPlugin.WriteSector(cmdBuf, badSector);
+                                    outputFormat.WriteSector(cmdBuf, badSector);
                                     UpdateStatus?.Invoke($"Correctly retried block {badSector} in pass {pass}.");
                                     _dumpLog.WriteLine("Correctly retried block {0} in pass {1}.", badSector, pass);
                                 }
                                 else if(_persistent)
-                                    _outputPlugin.WriteSector(cmdBuf, badSector);
+                                    outputFormat.WriteSector(cmdBuf, badSector);
                             }
 
                             if(pass < _retryPasses &&
@@ -519,7 +520,7 @@ namespace Aaru.Core.Devices.Dumping
                                         ibgLog.Write(currentBlock, currentSpeed * 1024);
                                         DateTime writeStart = DateTime.Now;
 
-                                        _outputPlugin.WriteSector(cmdBuf,
+                                        outputFormat.WriteSector(cmdBuf,
                                                                   (ulong)((((cy * heads) + hd) * sectors) + (sc - 1)));
 
                                         imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
@@ -536,7 +537,7 @@ namespace Aaru.Core.Devices.Dumping
                                         ibgLog.Write(currentBlock, 0);
                                         DateTime writeStart = DateTime.Now;
 
-                                        _outputPlugin.WriteSector(new byte[blockSize],
+                                        outputFormat.WriteSector(new byte[blockSize],
                                                                   (ulong)((((cy * heads) + hd) * sectors) + (sc - 1)));
 
                                         imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
@@ -586,7 +587,7 @@ namespace Aaru.Core.Devices.Dumping
                     foreach(ulong bad in _resume.BadBlocks)
                         _dumpLog.WriteLine("Sector {0} could not be read.", bad);
 
-                    _outputPlugin.SetDumpHardware(_resume.Tries);
+                    outputFormat.SetDumpHardware(_resume.Tries);
 
                     // TODO: Non-removable
                     var metadata = new CommonTypes.Structs.ImageInfo
@@ -595,17 +596,17 @@ namespace Aaru.Core.Devices.Dumping
                         ApplicationVersion = Version.GetVersion()
                     };
 
-                    if(!_outputPlugin.SetMetadata(metadata))
+                    if(!outputFormat.SetMetadata(metadata))
                         ErrorMessage?.Invoke("Error {0} setting metadata, continuing..." + Environment.NewLine +
-                                             _outputPlugin.ErrorMessage);
+                                             outputFormat.ErrorMessage);
 
                     if(_preSidecar != null)
-                        _outputPlugin.SetCicmMetadata(_preSidecar);
+                        outputFormat.SetCicmMetadata(_preSidecar);
 
                     _dumpLog.WriteLine("Closing output file.");
                     UpdateStatus?.Invoke("Closing output file.");
                     DateTime closeStart = DateTime.Now;
-                    _outputPlugin.Close();
+                    outputFormat.Close();
                     DateTime closeEnd = DateTime.Now;
                     UpdateStatus?.Invoke($"Closed in {(closeEnd - closeStart).TotalSeconds} seconds.");
                     _dumpLog.WriteLine("Closed in {0} seconds.", (closeEnd - closeStart).TotalSeconds);
@@ -620,15 +621,15 @@ namespace Aaru.Core.Devices.Dumping
 
                     double totalChkDuration = 0;
 
-                    _outputPlugin.WriteMediaTag(ataIdentify, MediaTagType.ATA_IDENTIFY);
+                    outputFormat.WriteMediaTag(ataIdentify, MediaTagType.ATA_IDENTIFY);
 
                     if(_dev.IsUsb &&
                        _dev.UsbDescriptors != null)
-                        _outputPlugin.WriteMediaTag(_dev.UsbDescriptors, MediaTagType.USB_Descriptors);
+                        outputFormat.WriteMediaTag(_dev.UsbDescriptors, MediaTagType.USB_Descriptors);
 
                     if(_dev.IsPcmcia &&
                        _dev.Cis != null)
-                        _outputPlugin.WriteMediaTag(_dev.Cis, MediaTagType.PCMCIA_CIS);
+                        outputFormat.WriteMediaTag(_dev.Cis, MediaTagType.PCMCIA_CIS);
 
                     if(_metadata)
                     {
diff --git a/Aaru.Core/Devices/Dumping/CompactDisc/CdiReady.cs b/Aaru.Core/Devices/Dumping/CompactDisc/CdiReady.cs
index aaba47b83..ecc3fe0fa 100644
--- a/Aaru.Core/Devices/Dumping/CompactDisc/CdiReady.cs
+++ b/Aaru.Core/Devices/Dumping/CompactDisc/CdiReady.cs
@@ -163,6 +163,7 @@ namespace Aaru.Core.Devices.Dumping
             const uint sectorSize = 2352;                  // Full sector size
             Track      firstTrack = tracks.FirstOrDefault(t => t.Sequence == 1);
             uint       blocksToRead; // How many sectors to read at once
+            var        outputOptical = _outputPlugin as IWritableOpticalImage;
 
             if(firstTrack is null)
                 return;
@@ -264,17 +265,17 @@ namespace Aaru.Core.Devices.Dumping
                                 if(cdiReadyReadAsAudio)
                                     data = Sector.Scramble(data);
 
-                                _outputPlugin.WriteSectorsLong(data, i + r, 1);
+                                outputOptical.WriteSectorsLong(data, i + r, 1);
 
                                 bool indexesChanged = Media.CompactDisc.WriteSubchannelToImage(supportedSubchannel,
                                     desiredSubchannel, sub, i + r, 1, subLog, isrcs, 1, ref mcn, tracks,
-                                    subchannelExtents, _fixSubchannelPosition, _outputPlugin, _fixSubchannel,
+                                    subchannelExtents, _fixSubchannelPosition, outputOptical, _fixSubchannel,
                                     _fixSubchannelCrc, _dumpLog, UpdateStatus, smallestPregapLbaPerTrack, true);
 
                                 // Set tracks and go back
                                 if(indexesChanged)
                                 {
-                                    (_outputPlugin as IWritableOpticalImage).SetTracks(tracks.ToList());
+                                    (outputOptical as IWritableOpticalImage).SetTracks(tracks.ToList());
                                     i -= _maximumReadable;
 
                                     continue;
@@ -282,7 +283,7 @@ namespace Aaru.Core.Devices.Dumping
                             }
                             else
                             {
-                                _outputPlugin.WriteSectorsLong(cmdBuf, i + r, 1);
+                                outputOptical.WriteSectorsLong(cmdBuf, i + r, 1);
                             }
 
                             imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
@@ -349,17 +350,17 @@ namespace Aaru.Core.Devices.Dumping
                             Array.Copy(cmdBuf, (int)(sectorSize + (b * blockSize)), sub, subSize * b, subSize);
                         }
 
-                        _outputPlugin.WriteSectorsLong(data, i, blocksToRead);
+                        outputOptical.WriteSectorsLong(data, i, blocksToRead);
 
                         bool indexesChanged = Media.CompactDisc.WriteSubchannelToImage(supportedSubchannel,
                             desiredSubchannel, sub, i, blocksToRead, subLog, isrcs, 1, ref mcn, tracks,
-                            subchannelExtents, _fixSubchannelPosition, _outputPlugin, _fixSubchannel,
+                            subchannelExtents, _fixSubchannelPosition, outputOptical, _fixSubchannel,
                             _fixSubchannelCrc, _dumpLog, UpdateStatus, smallestPregapLbaPerTrack, true);
 
                         // Set tracks and go back
                         if(indexesChanged)
                         {
-                            (_outputPlugin as IWritableOpticalImage).SetTracks(tracks.ToList());
+                            (outputOptical as IWritableOpticalImage).SetTracks(tracks.ToList());
                             i -= blocksToRead;
 
                             continue;
@@ -379,10 +380,10 @@ namespace Aaru.Core.Devices.Dumping
                                 Array.Copy(tmpData, 0, data, sectorSize * b, sectorSize);
                             }
 
-                            _outputPlugin.WriteSectorsLong(data, i, blocksToRead);
+                            outputOptical.WriteSectorsLong(data, i, blocksToRead);
                         }
                         else
-                            _outputPlugin.WriteSectorsLong(cmdBuf, i, blocksToRead);
+                            outputOptical.WriteSectorsLong(cmdBuf, i, blocksToRead);
                     }
 
                     imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
diff --git a/Aaru.Core/Devices/Dumping/CompactDisc/Data.cs b/Aaru.Core/Devices/Dumping/CompactDisc/Data.cs
index c47643c24..30d76b4e4 100644
--- a/Aaru.Core/Devices/Dumping/CompactDisc/Data.cs
+++ b/Aaru.Core/Devices/Dumping/CompactDisc/Data.cs
@@ -107,6 +107,7 @@ namespace Aaru.Core.Devices.Dumping
             const uint sectorSize  = 2352;                 // Full sector size
             newTrim = false;
             PlextorSubchannel supportedPlextorSubchannel;
+            var               outputFormat = _outputPlugin as IWritableImage;
 
             switch(supportedSubchannel)
             {
@@ -487,7 +488,7 @@ namespace Aaru.Core.Devices.Dumping
                                 Array.Copy(cmdBuf, sectorSize, sub, 0, subSize);
 
                                 if(supportsLongSectors)
-                                    _outputPlugin.WriteSectorsLong(data, i + r, 1);
+                                    outputFormat.WriteSectorsLong(data, i + r, 1);
                                 else
                                 {
                                     var    cooked = new MemoryStream();
@@ -500,19 +501,19 @@ namespace Aaru.Core.Devices.Dumping
                                         cooked.Write(cookedSector, 0, cookedSector.Length);
                                     }
 
-                                    _outputPlugin.WriteSectors(cooked.ToArray(), i, blocksToRead);
+                                    outputFormat.WriteSectors(cooked.ToArray(), i, blocksToRead);
                                 }
 
                                 bool indexesChanged = Media.CompactDisc.WriteSubchannelToImage(supportedSubchannel,
                                     desiredSubchannel, sub, i + r, 1, subLog, isrcs, (byte)track.Sequence,
-                                    ref mcn, tracks, subchannelExtents, _fixSubchannelPosition, _outputPlugin,
+                                    ref mcn, tracks, subchannelExtents, _fixSubchannelPosition, outputFormat as IWritableOpticalImage,
                                     _fixSubchannel, _fixSubchannelCrc, _dumpLog, UpdateStatus,
                                     smallestPregapLbaPerTrack, true);
 
                                 // Set tracks and go back
                                 if(indexesChanged)
                                 {
-                                    (_outputPlugin as IWritableOpticalImage).SetTracks(tracks.ToList());
+                                    (outputFormat as IWritableOpticalImage).SetTracks(tracks.ToList());
                                     i -= blocksToRead;
 
                                     continue;
@@ -521,7 +522,7 @@ namespace Aaru.Core.Devices.Dumping
                             else
                             {
                                 if(supportsLongSectors)
-                                    _outputPlugin.WriteSectorsLong(cmdBuf, i + r, 1);
+                                    outputFormat.WriteSectorsLong(cmdBuf, i + r, 1);
                                 else
                                 {
                                     var    cooked = new MemoryStream();
@@ -534,7 +535,7 @@ namespace Aaru.Core.Devices.Dumping
                                         cooked.Write(cookedSector, 0, cookedSector.Length);
                                     }
 
-                                    _outputPlugin.WriteSectors(cooked.ToArray(), i, blocksToRead);
+                                    outputFormat.WriteSectors(cooked.ToArray(), i, blocksToRead);
                                 }
                             }
 
@@ -549,22 +550,22 @@ namespace Aaru.Core.Devices.Dumping
 
                             if(supportedSubchannel != MmcSubchannel.None)
                             {
-                                _outputPlugin.WriteSectorsLong(new byte[sectorSize], i + r, 1);
+                                outputFormat.WriteSectorsLong(new byte[sectorSize], i + r, 1);
 
                                 if(desiredSubchannel != MmcSubchannel.None)
-                                    _outputPlugin.WriteSectorsTag(new byte[subSize], i + r, 1,
+                                    outputFormat.WriteSectorsTag(new byte[subSize], i + r, 1,
                                                                   SectorTagType.CdSectorSubchannel);
                             }
                             else
                             {
                                 if(supportsLongSectors)
-                                    _outputPlugin.WriteSectorsLong(new byte[blockSize], i + r, 1);
+                                    outputFormat.WriteSectorsLong(new byte[blockSize], i + r, 1);
                                 else
                                 {
                                     if(cmdBuf.Length % sectorSize == 0)
-                                        _outputPlugin.WriteSectors(new byte[2048], i + r, 1);
+                                        outputFormat.WriteSectors(new byte[2048], i + r, 1);
                                     else
-                                        _outputPlugin.WriteSectorsLong(new byte[blockSize], i + r, 1);
+                                        outputFormat.WriteSectorsLong(new byte[blockSize], i + r, 1);
                                 }
                             }
 
@@ -631,7 +632,7 @@ namespace Aaru.Core.Devices.Dumping
                         }
 
                         if(supportsLongSectors)
-                            _outputPlugin.WriteSectorsLong(data, i, blocksToRead);
+                            outputFormat.WriteSectorsLong(data, i, blocksToRead);
                         else
                         {
                             var    cooked = new MemoryStream();
@@ -644,19 +645,19 @@ namespace Aaru.Core.Devices.Dumping
                                 cooked.Write(cookedSector, 0, cookedSector.Length);
                             }
 
-                            _outputPlugin.WriteSectors(cooked.ToArray(), i, blocksToRead);
+                            outputFormat.WriteSectors(cooked.ToArray(), i, blocksToRead);
                         }
 
                         bool indexesChanged = Media.CompactDisc.WriteSubchannelToImage(supportedSubchannel,
                             desiredSubchannel, sub, i, blocksToRead, subLog, isrcs, (byte)track.Sequence,
-                            ref mcn, tracks, subchannelExtents, _fixSubchannelPosition, _outputPlugin,
+                            ref mcn, tracks, subchannelExtents, _fixSubchannelPosition, outputFormat as IWritableOpticalImage,
                             _fixSubchannel, _fixSubchannelCrc, _dumpLog, UpdateStatus, smallestPregapLbaPerTrack,
                             true);
 
                         // Set tracks and go back
                         if(indexesChanged)
                         {
-                            (_outputPlugin as IWritableOpticalImage).SetTracks(tracks.ToList());
+                            (outputFormat as IWritableOpticalImage).SetTracks(tracks.ToList());
                             i -= blocksToRead;
 
                             continue;
@@ -665,7 +666,7 @@ namespace Aaru.Core.Devices.Dumping
                     else
                     {
                         if(supportsLongSectors)
-                            _outputPlugin.WriteSectorsLong(cmdBuf, i, blocksToRead);
+                            outputFormat.WriteSectorsLong(cmdBuf, i, blocksToRead);
                         else
                         {
                             var    cooked = new MemoryStream();
@@ -678,7 +679,7 @@ namespace Aaru.Core.Devices.Dumping
                                 cooked.Write(cookedSector, 0, cookedSector.Length);
                             }
 
-                            _outputPlugin.WriteSectors(cooked.ToArray(), i, blocksToRead);
+                            outputFormat.WriteSectors(cooked.ToArray(), i, blocksToRead);
                         }
                     }
 
@@ -711,24 +712,24 @@ namespace Aaru.Core.Devices.Dumping
 
                     if(supportedSubchannel != MmcSubchannel.None)
                     {
-                        _outputPlugin.WriteSectorsLong(new byte[sectorSize * _skip], i, _skip);
+                        outputFormat.WriteSectorsLong(new byte[sectorSize * _skip], i, _skip);
 
                         if(desiredSubchannel != MmcSubchannel.None)
-                            _outputPlugin.WriteSectorsTag(new byte[subSize * _skip], i, _skip,
+                            outputFormat.WriteSectorsTag(new byte[subSize * _skip], i, _skip,
                                                           SectorTagType.CdSectorSubchannel);
                     }
                     else
                     {
                         if(supportsLongSectors)
                         {
-                            _outputPlugin.WriteSectorsLong(new byte[blockSize * _skip], i, _skip);
+                            outputFormat.WriteSectorsLong(new byte[blockSize * _skip], i, _skip);
                         }
                         else
                         {
                             if(cmdBuf.Length % sectorSize == 0)
-                                _outputPlugin.WriteSectors(new byte[2048 * _skip], i, _skip);
+                                outputFormat.WriteSectors(new byte[2048 * _skip], i, _skip);
                             else
-                                _outputPlugin.WriteSectorsLong(new byte[blockSize * _skip], i, _skip);
+                                outputFormat.WriteSectorsLong(new byte[blockSize * _skip], i, _skip);
                         }
                     }
 
diff --git a/Aaru.Core/Devices/Dumping/CompactDisc/Dump.cs b/Aaru.Core/Devices/Dumping/CompactDisc/Dump.cs
index 1a86cf7b0..b2cf95918 100644
--- a/Aaru.Core/Devices/Dumping/CompactDisc/Dump.cs
+++ b/Aaru.Core/Devices/Dumping/CompactDisc/Dump.cs
@@ -117,6 +117,7 @@ namespace Aaru.Core.Devices.Dumping
             HashSet<int>             subchannelExtents   = new();
             bool                     cdiReadyReadAsAudio = false;
             uint                     firstLba;
+            var                      outputOptical = _outputPlugin as IWritableOpticalImage;
 
             Dictionary<MediaTagType, byte[]> mediaTags                 = new(); // Media tags
             Dictionary<byte, int>            smallestPregapLbaPerTrack = new();
@@ -221,7 +222,7 @@ namespace Aaru.Core.Devices.Dumping
                 supportedSubchannel = MmcSubchannel.Q16;
 
             // Check if output format supports subchannels
-            if(!_outputPlugin.SupportedSectorTags.Contains(SectorTagType.CdSectorSubchannel) &&
+            if(!outputOptical.SupportedSectorTags.Contains(SectorTagType.CdSectorSubchannel) &&
                desiredSubchannel != MmcSubchannel.None)
             {
                 if(_force || _subchannel == DumpSubchannel.None)
@@ -416,7 +417,7 @@ namespace Aaru.Core.Devices.Dumping
                     Invoke("WARNING: The drive has returned incorrect Q positioning when calculating pregaps. A best effort has been tried but they may be incorrect.");
             }
 
-            if(!(_outputPlugin as IWritableOpticalImage).OpticalCapabilities.HasFlag(OpticalImageCapabilities.
+            if(!(outputOptical as IWritableOpticalImage).OpticalCapabilities.HasFlag(OpticalImageCapabilities.
                    CanStoreRawData))
             {
                 if(!_force)
@@ -435,7 +436,7 @@ namespace Aaru.Core.Devices.Dumping
                     Invoke("Output format does not support storing raw data, this may end in a loss of data, continuing...");
             }
 
-            if(!(_outputPlugin as IWritableOpticalImage).OpticalCapabilities.HasFlag(OpticalImageCapabilities.
+            if(!(outputOptical as IWritableOpticalImage).OpticalCapabilities.HasFlag(OpticalImageCapabilities.
                    CanStoreAudioTracks) &&
                tracks.Any(track => track.Type == TrackType.Audio))
             {
@@ -446,7 +447,7 @@ namespace Aaru.Core.Devices.Dumping
                 return;
             }
 
-            if(!(_outputPlugin as IWritableOpticalImage).OpticalCapabilities.HasFlag(OpticalImageCapabilities.
+            if(!(outputOptical as IWritableOpticalImage).OpticalCapabilities.HasFlag(OpticalImageCapabilities.
                    CanStorePregaps) &&
                tracks.Where(track => track.Sequence != tracks.First(t => t.Session == track.Session).Sequence).
                       Any(track => track.Pregap     > 0))
@@ -494,7 +495,7 @@ namespace Aaru.Core.Devices.Dumping
             // Read media tags
             ReadCdTags(ref dskType, mediaTags, out sessions, out firstTrackLastSession);
 
-            if(!(_outputPlugin as IWritableOpticalImage).OpticalCapabilities.HasFlag(OpticalImageCapabilities.
+            if(!(outputOptical as IWritableOpticalImage).OpticalCapabilities.HasFlag(OpticalImageCapabilities.
                    CanStoreSessions) &&
                sessions > 1)
             {
@@ -516,7 +517,7 @@ namespace Aaru.Core.Devices.Dumping
             }
 
             // Check if output format supports all disc tags we have retrieved so far
-            foreach(MediaTagType tag in mediaTags.Keys.Where(tag => !_outputPlugin.SupportedMediaTags.Contains(tag)))
+            foreach(MediaTagType tag in mediaTags.Keys.Where(tag => !outputOptical.SupportedMediaTags.Contains(tag)))
             {
                 if(_force)
                 {
@@ -687,7 +688,7 @@ namespace Aaru.Core.Devices.Dumping
                 }
             }
 
-            if(_outputPlugin.Id == new Guid("12345678-AAAA-BBBB-CCCC-123456789000"))
+            if(outputOptical.Id == new Guid("12345678-AAAA-BBBB-CCCC-123456789000"))
             {
                 if(tracks.Length > 1)
                 {
@@ -719,7 +720,7 @@ namespace Aaru.Core.Devices.Dumping
             // Check if something prevents from dumping the first track pregap
             if(_dumpFirstTrackPregap && readcd)
             {
-                if(!_outputPlugin.SupportedMediaTags.Contains(MediaTagType.CD_FirstTrackPregap))
+                if(!outputOptical.SupportedMediaTags.Contains(MediaTagType.CD_FirstTrackPregap))
                 {
                     if(_force)
                     {
@@ -814,30 +815,30 @@ namespace Aaru.Core.Devices.Dumping
             UpdateStatus?.Invoke($"SCSI device type: {_dev.ScsiType}.");
             UpdateStatus?.Invoke($"Media identified as {dskType}.");
 
-            ret = _outputPlugin.Create(_outputPath, dskType, _formatOptions, blocks,
+            ret = outputOptical.Create(_outputPath, dskType, _formatOptions, blocks,
                                        supportsLongSectors ? blockSize : 2048);
 
             // Cannot create image
             if(!ret)
             {
                 _dumpLog.WriteLine("Error creating output image, not continuing.");
-                _dumpLog.WriteLine(_outputPlugin.ErrorMessage);
+                _dumpLog.WriteLine(outputOptical.ErrorMessage);
 
                 StoppingErrorMessage?.Invoke("Error creating output image, not continuing." + Environment.NewLine +
-                                             _outputPlugin.ErrorMessage);
+                                             outputOptical.ErrorMessage);
 
                 return;
             }
 
-            ErrorNumber errno = _outputPlugin.ReadMediaTag(MediaTagType.CD_MCN, out byte[] mcnBytes);
+            ErrorNumber errno = outputOptical.ReadMediaTag(MediaTagType.CD_MCN, out byte[] mcnBytes);
 
             if(errno == ErrorNumber.NoError)
                 mcn = Encoding.ASCII.GetString(mcnBytes);
 
-            if((_outputPlugin as IWritableOpticalImage).Tracks != null)
-                foreach(Track imgTrack in (_outputPlugin as IWritableOpticalImage).Tracks)
+            if((outputOptical as IWritableOpticalImage).Tracks != null)
+                foreach(Track imgTrack in (outputOptical as IWritableOpticalImage).Tracks)
                 {
-                    errno = (_outputPlugin as IWritableOpticalImage).ReadSectorTag(imgTrack.Sequence,
+                    errno = (outputOptical as IWritableOpticalImage).ReadSectorTag(imgTrack.Sequence,
                         SectorTagType.CdTrackIsrc, out byte[] isrcBytes);
 
                     if(errno == ErrorNumber.NoError)
@@ -857,23 +858,23 @@ namespace Aaru.Core.Devices.Dumping
                 }
 
             // Send track list to output plugin. This may fail if subchannel is set but unsupported.
-            ret = (_outputPlugin as IWritableOpticalImage).SetTracks(tracks.ToList());
+            ret = (outputOptical as IWritableOpticalImage).SetTracks(tracks.ToList());
 
             if(!ret &&
                desiredSubchannel == MmcSubchannel.None)
             {
                 _dumpLog.WriteLine("Error sending tracks to output image, not continuing.");
-                _dumpLog.WriteLine(_outputPlugin.ErrorMessage);
+                _dumpLog.WriteLine(outputOptical.ErrorMessage);
 
                 StoppingErrorMessage?.Invoke("Error sending tracks to output image, not continuing." +
-                                             Environment.NewLine + _outputPlugin.ErrorMessage);
+                                             Environment.NewLine + outputOptical.ErrorMessage);
 
                 return;
             }
 
             // If a subchannel is supported, check if output plugin allows us to write it.
             if(desiredSubchannel != MmcSubchannel.None &&
-               !(_outputPlugin as IWritableOpticalImage).OpticalCapabilities.HasFlag(OpticalImageCapabilities.
+               !(outputOptical as IWritableOpticalImage).OpticalCapabilities.HasFlag(OpticalImageCapabilities.
                    CanStoreSubchannelRw))
             {
                 _dumpLog.WriteLine("Output image does not support subchannels, {0}continuing...", _force ? "" : "not ");
@@ -905,7 +906,7 @@ namespace Aaru.Core.Devices.Dumping
                 _dumpLog.WriteLine("Setting flags for track {0}...", track.Sequence);
                 UpdateStatus?.Invoke($"Setting flags for track {track.Sequence}...");
 
-                _outputPlugin.WriteSectorTag(new[]
+                outputOptical.WriteSectorTag(new[]
                 {
                     kvp.Value
                 }, kvp.Key, SectorTagType.CdTrackFlags);
@@ -1282,14 +1283,14 @@ namespace Aaru.Core.Devices.Dumping
                         continue;
                     }
 
-                    ret = _outputPlugin.WriteMediaTag(tag.Value, tag.Key);
+                    ret = outputOptical.WriteMediaTag(tag.Value, tag.Key);
 
                     if(ret || _force)
                         continue;
 
                     // Cannot write tag to image
                     _dumpLog.WriteLine($"Cannot write tag {tag.Key}.");
-                    StoppingErrorMessage?.Invoke(_outputPlugin.ErrorMessage);
+                    StoppingErrorMessage?.Invoke(outputOptical.ErrorMessage);
 
                     return;
                 }
@@ -1306,10 +1307,10 @@ namespace Aaru.Core.Devices.Dumping
             _resume.BadSubchannels.Sort();
 
             if(_generateSubchannels                                                         &&
-               _outputPlugin.SupportedSectorTags.Contains(SectorTagType.CdSectorSubchannel) &&
+               outputOptical.SupportedSectorTags.Contains(SectorTagType.CdSectorSubchannel) &&
                !_aborted)
                 Media.CompactDisc.GenerateSubchannels(subchannelExtents, tracks, trackFlags, blocks, subLog, _dumpLog,
-                                                      InitProgress, UpdateProgress, EndProgress, _outputPlugin);
+                                                      InitProgress, UpdateProgress, EndProgress, outputOptical);
 
             // TODO: Disc ID
             var metadata = new CommonTypes.Structs.ImageInfo
@@ -1318,19 +1319,19 @@ namespace Aaru.Core.Devices.Dumping
                 ApplicationVersion = Version.GetVersion()
             };
 
-            if(!_outputPlugin.SetMetadata(metadata))
+            if(!outputOptical.SetMetadata(metadata))
                 ErrorMessage?.Invoke("Error {0} setting metadata, continuing..." + Environment.NewLine +
-                                     _outputPlugin.ErrorMessage);
+                                     outputOptical.ErrorMessage);
 
-            _outputPlugin.SetDumpHardware(_resume.Tries);
+            outputOptical.SetDumpHardware(_resume.Tries);
 
             if(_preSidecar != null)
-                _outputPlugin.SetCicmMetadata(_preSidecar);
+                outputOptical.SetCicmMetadata(_preSidecar);
 
             foreach(KeyValuePair<byte, string> isrc in isrcs)
             {
                 // TODO: Track tags
-                if(!_outputPlugin.WriteSectorTag(Encoding.ASCII.GetBytes(isrc.Value), isrc.Key,
+                if(!outputOptical.WriteSectorTag(Encoding.ASCII.GetBytes(isrc.Value), isrc.Key,
                                                  SectorTagType.CdTrackIsrc))
                     continue;
 
@@ -1339,7 +1340,7 @@ namespace Aaru.Core.Devices.Dumping
             }
 
             if(mcn != null &&
-               _outputPlugin.WriteMediaTag(Encoding.ASCII.GetBytes(mcn), MediaTagType.CD_MCN))
+               outputOptical.WriteMediaTag(Encoding.ASCII.GetBytes(mcn), MediaTagType.CD_MCN))
             {
                 UpdateStatus?.Invoke($"Setting disc Media Catalogue Number to {mcn}");
                 _dumpLog.WriteLine("Setting disc Media Catalogue Number to {0}", mcn);
@@ -1366,12 +1367,12 @@ namespace Aaru.Core.Devices.Dumping
                     trk.Indexes.Remove(0);
             }
 
-            (_outputPlugin as IWritableOpticalImage).SetTracks(tracks.ToList());
+            (outputOptical as IWritableOpticalImage).SetTracks(tracks.ToList());
 
             _dumpLog.WriteLine("Closing output file.");
             UpdateStatus?.Invoke("Closing output file.");
             DateTime closeStart = DateTime.Now;
-            _outputPlugin.Close();
+            outputOptical.Close();
             DateTime closeEnd = DateTime.Now;
             UpdateStatus?.Invoke($"Closed in {(closeEnd - closeStart).TotalSeconds} seconds.");
 
diff --git a/Aaru.Core/Devices/Dumping/CompactDisc/Error.cs b/Aaru.Core/Devices/Dumping/CompactDisc/Error.cs
index 889272477..15a541e2e 100644
--- a/Aaru.Core/Devices/Dumping/CompactDisc/Error.cs
+++ b/Aaru.Core/Devices/Dumping/CompactDisc/Error.cs
@@ -85,6 +85,7 @@ namespace Aaru.Core.Devices.Dumping
             const uint        sectorSize = 2352; // Full sector size
             byte[]            senseBuf   = null; // Sense buffer
             PlextorSubchannel supportedPlextorSubchannel;
+            var               outputOptical = _outputPlugin as IWritableOpticalImage;
 
             switch(supportedSubchannel)
             {
@@ -360,28 +361,28 @@ namespace Aaru.Core.Devices.Dumping
                     Array.Copy(cmdBuf, sectorSize, sub, 0, subSize);
 
                     if(supportsLongSectors)
-                        _outputPlugin.WriteSectorLong(data, badSector);
+                        outputOptical.WriteSectorLong(data, badSector);
                     else
-                        _outputPlugin.WriteSector(Sector.GetUserData(data), badSector);
+                        outputOptical.WriteSector(Sector.GetUserData(data), badSector);
 
                     bool indexesChanged = Media.CompactDisc.WriteSubchannelToImage(supportedSubchannel,
                         desiredSubchannel, sub, badSector, 1, subLog, isrcs, (byte)track.Sequence, ref mcn,
-                        tracks, subchannelExtents, _fixSubchannelPosition, _outputPlugin, _fixSubchannel,
+                        tracks, subchannelExtents, _fixSubchannelPosition, outputOptical, _fixSubchannel,
                         _fixSubchannelCrc, _dumpLog, UpdateStatus, smallestPregapLbaPerTrack, true);
 
                     // Set tracks and go back
                     if(!indexesChanged)
                         continue;
 
-                    (_outputPlugin as IWritableOpticalImage).SetTracks(tracks.ToList());
+                    (outputOptical as IWritableOpticalImage).SetTracks(tracks.ToList());
                     i--;
                 }
                 else
                 {
                     if(supportsLongSectors)
-                        _outputPlugin.WriteSectorLong(cmdBuf, badSector);
+                        outputOptical.WriteSectorLong(cmdBuf, badSector);
                     else
-                        _outputPlugin.WriteSector(Sector.GetUserData(cmdBuf), badSector);
+                        outputOptical.WriteSector(Sector.GetUserData(cmdBuf), badSector);
                 }
             }
 
@@ -491,29 +492,29 @@ namespace Aaru.Core.Devices.Dumping
                             Array.Copy(cmdBuf, sectorSize, sub, 0, subSize);
 
                             if(supportsLongSectors)
-                                _outputPlugin.WriteSectorLong(data, badSector);
+                                outputOptical.WriteSectorLong(data, badSector);
                             else
-                                _outputPlugin.WriteSector(Sector.GetUserData(data), badSector);
+                                outputOptical.WriteSector(Sector.GetUserData(data), badSector);
 
                             bool indexesChanged = Media.CompactDisc.WriteSubchannelToImage(supportedSubchannel,
                                 desiredSubchannel, sub, badSector, 1, subLog, isrcs, (byte)track.Sequence,
-                                ref mcn, tracks, subchannelExtents, _fixSubchannelPosition, _outputPlugin,
+                                ref mcn, tracks, subchannelExtents, _fixSubchannelPosition, outputOptical,
                                 _fixSubchannel, _fixSubchannelCrc, _dumpLog, UpdateStatus,
                                 smallestPregapLbaPerTrack, true);
 
                             // Set tracks and go back
                             if(indexesChanged)
                             {
-                                (_outputPlugin as IWritableOpticalImage).SetTracks(tracks.ToList());
+                                (outputOptical as IWritableOpticalImage).SetTracks(tracks.ToList());
                                 i--;
                             }
                         }
                         else
                         {
                             if(supportsLongSectors)
-                                _outputPlugin.WriteSectorLong(cmdBuf, badSector);
+                                outputOptical.WriteSectorLong(cmdBuf, badSector);
                             else
-                                _outputPlugin.WriteSector(Sector.GetUserData(cmdBuf), badSector);
+                                outputOptical.WriteSector(Sector.GetUserData(cmdBuf), badSector);
                         }
                     }
 
@@ -567,6 +568,7 @@ namespace Aaru.Core.Devices.Dumping
             double            cmdDuration;     // Command execution time
             byte[]            senseBuf = null; // Sense buffer
             PlextorSubchannel supportedPlextorSubchannel;
+            var               outputOptical = _outputPlugin as IWritableOpticalImage;
 
             if(supportedSubchannel == MmcSubchannel.None ||
                desiredSubchannel   == MmcSubchannel.None)
@@ -660,7 +662,7 @@ namespace Aaru.Core.Devices.Dumping
 
                 Media.CompactDisc.WriteSubchannelToImage(supportedSubchannel, desiredSubchannel, cmdBuf, badSector, 5,
                                                          subLog, isrcs, (byte)track.Sequence, ref mcn, tracks,
-                                                         subchannelExtents, _fixSubchannelPosition, _outputPlugin,
+                                                         subchannelExtents, _fixSubchannelPosition, outputOptical,
                                                          _fixSubchannel, _fixSubchannelCrc, _dumpLog, UpdateStatus,
                                                          smallestPregapLbaPerTrack, true);
 
diff --git a/Aaru.Core/Devices/Dumping/CompactDisc/LeadOuts.cs b/Aaru.Core/Devices/Dumping/CompactDisc/LeadOuts.cs
index 02b027d62..b6707092e 100644
--- a/Aaru.Core/Devices/Dumping/CompactDisc/LeadOuts.cs
+++ b/Aaru.Core/Devices/Dumping/CompactDisc/LeadOuts.cs
@@ -83,10 +83,11 @@ namespace Aaru.Core.Devices.Dumping
                             Dictionary<byte, string> isrcs, ref string mcn, Track[] tracks,
                             HashSet<int> subchannelExtents, Dictionary<byte, int> smallestPregapLbaPerTrack)
         {
-            byte[]     cmdBuf     = null; // Data buffer
-            const uint sectorSize = 2352; // Full sector size
-            bool       sense      = true; // Sense indicator
-            byte[]     senseBuf   = null;
+            byte[]     cmdBuf        = null; // Data buffer
+            const uint sectorSize    = 2352; // Full sector size
+            bool       sense         = true; // Sense indicator
+            byte[]     senseBuf      = null;
+            var        outputOptical = _outputPlugin as IWritableOpticalImage;
 
             UpdateStatus?.Invoke("Reading lead-outs");
             _dumpLog.WriteLine("Reading lead-outs");
@@ -158,24 +159,24 @@ namespace Aaru.Core.Devices.Dumping
                                 Array.Copy(cmdBuf, (int)(sectorSize + (b * blockSize)), sub, subSize * b, subSize);
                             }
 
-                            _outputPlugin.WriteSectorsLong(data, i, _maximumReadable);
+                            outputOptical.WriteSectorsLong(data, i, _maximumReadable);
 
                             bool indexesChanged = Media.CompactDisc.WriteSubchannelToImage(supportedSubchannel,
                                 desiredSubchannel, sub, i, _maximumReadable, subLog, isrcs, 0xAA, ref mcn, tracks,
-                                subchannelExtents, _fixSubchannelPosition, _outputPlugin, _fixSubchannel,
+                                subchannelExtents, _fixSubchannelPosition, outputOptical, _fixSubchannel,
                                 _fixSubchannelCrc, _dumpLog, UpdateStatus, smallestPregapLbaPerTrack, true);
 
                             // Set tracks and go back
                             if(indexesChanged)
                             {
-                                (_outputPlugin as IWritableOpticalImage).SetTracks(tracks.ToList());
+                                (outputOptical as IWritableOpticalImage).SetTracks(tracks.ToList());
                                 i--;
 
                                 continue;
                             }
                         }
                         else
-                            _outputPlugin.WriteSectors(cmdBuf, i, _maximumReadable);
+                            outputOptical.WriteSectors(cmdBuf, i, _maximumReadable);
 
                         imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
                     }
@@ -192,13 +193,13 @@ namespace Aaru.Core.Devices.Dumping
 
                         if(supportedSubchannel != MmcSubchannel.None)
                         {
-                            _outputPlugin.WriteSectorsLong(new byte[sectorSize * _skip], i, 1);
+                            outputOptical.WriteSectorsLong(new byte[sectorSize * _skip], i, 1);
 
-                            _outputPlugin.WriteSectorsTag(new byte[subSize * _skip], i, 1,
+                            outputOptical.WriteSectorsTag(new byte[subSize * _skip], i, 1,
                                                           SectorTagType.CdSectorSubchannel);
                         }
                         else
-                            _outputPlugin.WriteSectors(new byte[blockSize * _skip], i, 1);
+                            outputOptical.WriteSectors(new byte[blockSize * _skip], i, 1);
 
                         imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
 
@@ -252,10 +253,11 @@ namespace Aaru.Core.Devices.Dumping
                              Dictionary<byte, string> isrcs, ref string mcn, Track[] tracks,
                              HashSet<int> subchannelExtents, Dictionary<byte, int> smallestPregapLbaPerTrack)
         {
-            byte[]     cmdBuf     = null; // Data buffer
-            const uint sectorSize = 2352; // Full sector size
-            bool       sense      = true; // Sense indicator
-            byte[]     senseBuf   = null;
+            byte[]     cmdBuf        = null; // Data buffer
+            const uint sectorSize    = 2352; // Full sector size
+            bool       sense         = true; // Sense indicator
+            byte[]     senseBuf      = null;
+            var        outputOptical = _outputPlugin as IWritableOpticalImage;
 
             _dumpLog.WriteLine("Retrying lead-outs");
 
@@ -326,24 +328,24 @@ namespace Aaru.Core.Devices.Dumping
                                 Array.Copy(cmdBuf, (int)(sectorSize + (b * blockSize)), sub, subSize * b, subSize);
                             }
 
-                            _outputPlugin.WriteSectorsLong(data, i, _maximumReadable);
+                            outputOptical.WriteSectorsLong(data, i, _maximumReadable);
 
                             bool indexesChanged = Media.CompactDisc.WriteSubchannelToImage(supportedSubchannel,
                                 desiredSubchannel, sub, i, _maximumReadable, subLog, isrcs, 0xAA, ref mcn, tracks,
-                                subchannelExtents, _fixSubchannelPosition, _outputPlugin, _fixSubchannel,
+                                subchannelExtents, _fixSubchannelPosition, outputOptical, _fixSubchannel,
                                 _fixSubchannelCrc, _dumpLog, UpdateStatus, smallestPregapLbaPerTrack, true);
 
                             // Set tracks and go back
                             if(indexesChanged)
                             {
-                                (_outputPlugin as IWritableOpticalImage).SetTracks(tracks.ToList());
+                                (outputOptical as IWritableOpticalImage).SetTracks(tracks.ToList());
                                 i--;
 
                                 continue;
                             }
                         }
                         else
-                            _outputPlugin.WriteSectors(cmdBuf, i, _maximumReadable);
+                            outputOptical.WriteSectors(cmdBuf, i, _maximumReadable);
 
                         imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
                     }
@@ -360,14 +362,14 @@ namespace Aaru.Core.Devices.Dumping
 
                         if(supportedSubchannel != MmcSubchannel.None)
                         {
-                            _outputPlugin.WriteSectorsLong(new byte[sectorSize * _skip], i, 1);
+                            outputOptical.WriteSectorsLong(new byte[sectorSize * _skip], i, 1);
 
                             if(desiredSubchannel != MmcSubchannel.None)
-                                _outputPlugin.WriteSectorsTag(new byte[subSize * _skip], i, 1,
+                                outputOptical.WriteSectorsTag(new byte[subSize * _skip], i, 1,
                                                               SectorTagType.CdSectorSubchannel);
                         }
                         else
-                            _outputPlugin.WriteSectors(new byte[blockSize * _skip], i, 1);
+                            outputOptical.WriteSectors(new byte[blockSize * _skip], i, 1);
 
                         imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
 
diff --git a/Aaru.Core/Devices/Dumping/CompactDisc/Trim.cs b/Aaru.Core/Devices/Dumping/CompactDisc/Trim.cs
index 5e972c677..c833d41f6 100644
--- a/Aaru.Core/Devices/Dumping/CompactDisc/Trim.cs
+++ b/Aaru.Core/Devices/Dumping/CompactDisc/Trim.cs
@@ -89,7 +89,8 @@ namespace Aaru.Core.Devices.Dumping
             double            cmdDuration = 0;    // Command execution time
             const uint        sectorSize  = 2352; // Full sector size
             PlextorSubchannel supportedPlextorSubchannel;
-            byte[]            senseBuf = null;
+            byte[]            senseBuf      = null;
+            var               outputOptical = _outputPlugin as IWritableOpticalImage;
 
             switch(supportedSubchannel)
             {
@@ -262,22 +263,22 @@ namespace Aaru.Core.Devices.Dumping
                     Array.Copy(cmdBuf, sectorSize, sub, 0, subSize);
 
                     if(supportsLongSectors)
-                        _outputPlugin.WriteSectorLong(data, badSector);
+                        outputOptical.WriteSectorLong(data, badSector);
                     else
-                        _outputPlugin.WriteSector(Sector.GetUserData(data), badSector);
+                        outputOptical.WriteSector(Sector.GetUserData(data), badSector);
 
                     ulong trkStartBefore = track.StartSector;
 
                     bool indexesChanged = Media.CompactDisc.WriteSubchannelToImage(supportedSubchannel,
                         desiredSubchannel, sub, badSector, 1, subLog, isrcs, (byte)track.Sequence, ref mcn,
-                        tracks, subchannelExtents, _fixSubchannelPosition, _outputPlugin, _fixSubchannel,
+                        tracks, subchannelExtents, _fixSubchannelPosition, outputOptical, _fixSubchannel,
                         _fixSubchannelCrc, _dumpLog, UpdateStatus, smallestPregapLbaPerTrack, true);
 
                     // Set tracks and go back
                     if(!indexesChanged)
                         continue;
 
-                    (_outputPlugin as IWritableOpticalImage).SetTracks(tracks.ToList());
+                    (outputOptical as IWritableOpticalImage).SetTracks(tracks.ToList());
 
                     if(track.StartSector != trkStartBefore &&
                        !_resume.BadBlocks.Contains(track.StartSector))
@@ -293,9 +294,9 @@ namespace Aaru.Core.Devices.Dumping
                 }
 
                 if(supportsLongSectors)
-                    _outputPlugin.WriteSectorLong(cmdBuf, badSector);
+                    outputOptical.WriteSectorLong(cmdBuf, badSector);
                 else
-                    _outputPlugin.WriteSector(Sector.GetUserData(cmdBuf), badSector);
+                    outputOptical.WriteSector(Sector.GetUserData(cmdBuf), badSector);
             }
 
             EndProgress?.Invoke();
diff --git a/Aaru.Core/Devices/Dumping/Dump.cs b/Aaru.Core/Devices/Dumping/Dump.cs
index be7454c8d..b2ff07ec4 100644
--- a/Aaru.Core/Devices/Dumping/Dump.cs
+++ b/Aaru.Core/Devices/Dumping/Dump.cs
@@ -81,7 +81,7 @@ namespace Aaru.Core.Devices.Dumping
         readonly bool                       _generateSubchannels;
         readonly bool                       _metadata;
         readonly string                     _outputPath;
-        readonly IWritableImage             _outputPlugin;
+        readonly IBaseWritableImage             _outputPlugin;
         readonly string                     _outputPrefix;
         readonly bool                       _persistent;
         readonly CICMMetadataType           _preSidecar;
@@ -148,7 +148,7 @@ namespace Aaru.Core.Devices.Dumping
         /// </param>
         /// <param name="storeEncrypted">Store encrypted data as is</param>
         /// <param name="titleKeys">Dump DVD CSS title keys</param>
-        public Dump(bool doResume, Device dev, string devicePath, IWritableImage outputPlugin, ushort retryPasses,
+        public Dump(bool doResume, Device dev, string devicePath, IBaseWritableImage outputPlugin, ushort retryPasses,
                     bool force, bool dumpRaw, bool persistent, bool stopOnError, Resume resume, DumpLog dumpLog,
                     Encoding encoding, string outputPrefix, string outputPath, Dictionary<string, string> formatOptions,
                     CICMMetadataType preSidecar, uint skip, bool metadata, bool trim, bool dumpFirstTrackPregap,
diff --git a/Aaru.Core/Devices/Dumping/MiniDisc.cs b/Aaru.Core/Devices/Dumping/MiniDisc.cs
index 289e49e47..b2e8fcd74 100644
--- a/Aaru.Core/Devices/Dumping/MiniDisc.cs
+++ b/Aaru.Core/Devices/Dumping/MiniDisc.cs
@@ -72,6 +72,7 @@ namespace Aaru.Core.Devices.Dumping
             Dictionary<MediaTagType, byte[]> mediaTags = new();
             byte[]                           cmdBuf;
             bool                             ret;
+            var                              outputFormat = _outputPlugin as IWritableImage;
 
             _dumpLog.WriteLine("Initializing reader.");
             var   scsiReader = new Reader(_dev, _dev.Timeout, null, _errorLog);
@@ -208,7 +209,7 @@ namespace Aaru.Core.Devices.Dumping
 
             ret = true;
 
-            foreach(MediaTagType tag in mediaTags.Keys.Where(tag => !_outputPlugin.SupportedMediaTags.Contains(tag)))
+            foreach(MediaTagType tag in mediaTags.Keys.Where(tag => !outputFormat.SupportedMediaTags.Contains(tag)))
             {
                 ret = false;
                 _dumpLog.WriteLine($"Output format does not support {tag}.");
@@ -236,16 +237,16 @@ namespace Aaru.Core.Devices.Dumping
 
             var mhddLog = new MhddLog(_outputPrefix + ".mhddlog.bin", _dev, blocks, blockSize, blocksToRead, _private);
             var ibgLog  = new IbgLog(_outputPrefix  + ".ibg", sbcProfile);
-            ret = _outputPlugin.Create(_outputPath, dskType, _formatOptions, blocks, blockSize);
+            ret = outputFormat.Create(_outputPath, dskType, _formatOptions, blocks, blockSize);
 
             // Cannot create image
             if(!ret)
             {
                 _dumpLog.WriteLine("Error creating output image, not continuing.");
-                _dumpLog.WriteLine(_outputPlugin.ErrorMessage);
+                _dumpLog.WriteLine(outputFormat.ErrorMessage);
 
                 StoppingErrorMessage?.Invoke("Error creating output image, not continuing." + Environment.NewLine +
-                                             _outputPlugin.ErrorMessage);
+                                             outputFormat.ErrorMessage);
 
                 return;
             }
@@ -273,7 +274,7 @@ namespace Aaru.Core.Devices.Dumping
                         UpdateStatus?.
                             Invoke($"Setting geometry to {rigidPage.Value.Cylinders} cylinders, {rigidPage.Value.Heads} heads, {(uint)(blocks / (rigidPage.Value.Cylinders * rigidPage.Value.Heads))} sectors per track");
 
-                        _outputPlugin.SetGeometry(rigidPage.Value.Cylinders, rigidPage.Value.Heads,
+                        outputFormat.SetGeometry(rigidPage.Value.Cylinders, rigidPage.Value.Heads,
                                                   (uint)(blocks / (rigidPage.Value.Cylinders * rigidPage.Value.Heads)));
 
                         setGeometry = true;
@@ -293,7 +294,7 @@ namespace Aaru.Core.Devices.Dumping
                         UpdateStatus?.
                             Invoke($"Setting geometry to {flexiblePage.Value.Cylinders} cylinders, {flexiblePage.Value.Heads} heads, {flexiblePage.Value.SectorsPerTrack} sectors per track");
 
-                        _outputPlugin.SetGeometry(flexiblePage.Value.Cylinders, flexiblePage.Value.Heads,
+                        outputFormat.SetGeometry(flexiblePage.Value.Cylinders, flexiblePage.Value.Heads,
                                                   flexiblePage.Value.SectorsPerTrack);
 
                         setGeometry = true;
@@ -362,7 +363,7 @@ namespace Aaru.Core.Devices.Dumping
                     mhddLog.Write(i, cmdDuration);
                     ibgLog.Write(i, currentSpeed * 1024);
                     DateTime writeStart = DateTime.Now;
-                    _outputPlugin.WriteSectors(readBuffer, i, blocksToRead);
+                    outputFormat.WriteSectors(readBuffer, i, blocksToRead);
                     imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
                     extents.Add(i, blocksToRead, true);
                 }
@@ -377,7 +378,7 @@ namespace Aaru.Core.Devices.Dumping
 
                     // Write empty data
                     DateTime writeStart = DateTime.Now;
-                    _outputPlugin.WriteSectors(new byte[blockSize * _skip], i, _skip);
+                    outputFormat.WriteSectors(new byte[blockSize * _skip], i, _skip);
                     imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
 
                     for(ulong b = i; b < i + _skip; b++)
@@ -463,7 +464,7 @@ namespace Aaru.Core.Devices.Dumping
 
                     _resume.BadBlocks.Remove(badSector);
                     extents.Add(badSector);
-                    _outputPlugin.WriteSector(readBuffer, badSector);
+                    outputFormat.WriteSector(readBuffer, badSector);
                 }
 
                 EndProgress?.Invoke();
@@ -603,12 +604,12 @@ namespace Aaru.Core.Devices.Dumping
                     {
                         _resume.BadBlocks.Remove(badSector);
                         extents.Add(badSector);
-                        _outputPlugin.WriteSector(readBuffer, badSector);
+                        outputFormat.WriteSector(readBuffer, badSector);
                         UpdateStatus?.Invoke($"Correctly retried block {badSector} in pass {pass}.");
                         _dumpLog.WriteLine("Correctly retried block {0} in pass {1}.", badSector, pass);
                     }
                     else if(runningPersistent)
-                        _outputPlugin.WriteSector(readBuffer, badSector);
+                        outputFormat.WriteSector(readBuffer, badSector);
                 }
 
                 if(pass < _retryPasses &&
@@ -654,7 +655,7 @@ namespace Aaru.Core.Devices.Dumping
 
             currentTry.Extents = ExtentsConverter.ToMetadata(extents);
 
-            _outputPlugin.SetDumpHardware(_resume.Tries);
+            outputFormat.SetDumpHardware(_resume.Tries);
 
             var metadata = new CommonTypes.Structs.ImageInfo
             {
@@ -662,17 +663,17 @@ namespace Aaru.Core.Devices.Dumping
                 ApplicationVersion = Version.GetVersion()
             };
 
-            if(!_outputPlugin.SetMetadata(metadata))
+            if(!outputFormat.SetMetadata(metadata))
                 ErrorMessage?.Invoke("Error {0} setting metadata, continuing..." + Environment.NewLine +
-                                     _outputPlugin.ErrorMessage);
+                                     outputFormat.ErrorMessage);
 
             if(_preSidecar != null)
-                _outputPlugin.SetCicmMetadata(_preSidecar);
+                outputFormat.SetCicmMetadata(_preSidecar);
 
             _dumpLog.WriteLine("Closing output file.");
             UpdateStatus?.Invoke("Closing output file.");
             DateTime closeStart = DateTime.Now;
-            _outputPlugin.Close();
+            outputFormat.Close();
             DateTime closeEnd = DateTime.Now;
             UpdateStatus?.Invoke($"Closed in {(closeEnd - closeStart).TotalSeconds} seconds.");
             _dumpLog.WriteLine("Closed in {0} seconds.", (closeEnd - closeStart).TotalSeconds);
diff --git a/Aaru.Core/Devices/Dumping/PlayStationPortable/MemoryStick.cs b/Aaru.Core/Devices/Dumping/PlayStationPortable/MemoryStick.cs
index c8df9a81a..4c6154822 100644
--- a/Aaru.Core/Devices/Dumping/PlayStationPortable/MemoryStick.cs
+++ b/Aaru.Core/Devices/Dumping/PlayStationPortable/MemoryStick.cs
@@ -69,6 +69,7 @@ namespace Aaru.Core.Devices.Dumping
             MediaType    dskType;
             bool         sense;
             byte[]       senseBuf;
+            var          outputFormat = _outputPlugin as IWritableImage;
 
             sense = _dev.ReadCapacity(out byte[] readBuffer, out _, _dev.Timeout, out _);
 
@@ -132,16 +133,16 @@ namespace Aaru.Core.Devices.Dumping
 
             var mhddLog = new MhddLog(_outputPrefix + ".mhddlog.bin", _dev, blocks, blockSize, blocksToRead, _private);
             var ibgLog  = new IbgLog(_outputPrefix  + ".ibg", sbcProfile);
-            ret = _outputPlugin.Create(_outputPath, dskType, _formatOptions, blocks, blockSize);
+            ret = outputFormat.Create(_outputPath, dskType, _formatOptions, blocks, blockSize);
 
             // Cannot create image
             if(!ret)
             {
                 _dumpLog.WriteLine("Error creating output image, not continuing.");
-                _dumpLog.WriteLine(_outputPlugin.ErrorMessage);
+                _dumpLog.WriteLine(outputFormat.ErrorMessage);
 
                 StoppingErrorMessage?.Invoke("Error creating output image, not continuing." + Environment.NewLine +
-                                             _outputPlugin.ErrorMessage);
+                                             outputFormat.ErrorMessage);
 
                 return;
             }
@@ -208,7 +209,7 @@ namespace Aaru.Core.Devices.Dumping
                     mhddLog.Write(i, cmdDuration);
                     ibgLog.Write(i, currentSpeed * 1024);
                     DateTime writeStart = DateTime.Now;
-                    _outputPlugin.WriteSectors(readBuffer, i, blocksToRead);
+                    outputFormat.WriteSectors(readBuffer, i, blocksToRead);
                     imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
                     extents.Add(i, blocksToRead, true);
                 }
@@ -225,7 +226,7 @@ namespace Aaru.Core.Devices.Dumping
 
                     // Write empty data
                     DateTime writeStart = DateTime.Now;
-                    _outputPlugin.WriteSectors(new byte[blockSize * _skip], i, _skip);
+                    outputFormat.WriteSectors(new byte[blockSize * _skip], i, _skip);
                     imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
 
                     for(ulong b = i; b < i + _skip; b++)
@@ -315,7 +316,7 @@ namespace Aaru.Core.Devices.Dumping
 
                     _resume.BadBlocks.Remove(badSector);
                     extents.Add(badSector);
-                    _outputPlugin.WriteSector(readBuffer, badSector);
+                    outputFormat.WriteSector(readBuffer, badSector);
                 }
 
                 EndProgress?.Invoke();
@@ -471,12 +472,12 @@ namespace Aaru.Core.Devices.Dumping
                     {
                         _resume.BadBlocks.Remove(badSector);
                         extents.Add(badSector);
-                        _outputPlugin.WriteSector(readBuffer, badSector);
+                        outputFormat.WriteSector(readBuffer, badSector);
                         UpdateStatus?.Invoke($"Correctly retried block {badSector} in pass {pass}.");
                         _dumpLog.WriteLine("Correctly retried block {0} in pass {1}.", badSector, pass);
                     }
                     else if(runningPersistent)
-                        _outputPlugin.WriteSector(readBuffer, badSector);
+                        outputFormat.WriteSector(readBuffer, badSector);
                 }
 
                 if(pass < _retryPasses &&
@@ -528,19 +529,19 @@ namespace Aaru.Core.Devices.Dumping
                 ApplicationVersion = Version.GetVersion()
             };
 
-            if(!_outputPlugin.SetMetadata(metadata))
+            if(!outputFormat.SetMetadata(metadata))
                 ErrorMessage?.Invoke("Error {0} setting metadata, continuing..." + Environment.NewLine +
-                                     _outputPlugin.ErrorMessage);
+                                     outputFormat.ErrorMessage);
 
-            _outputPlugin.SetDumpHardware(_resume.Tries);
+            outputFormat.SetDumpHardware(_resume.Tries);
 
             if(_preSidecar != null)
-                _outputPlugin.SetCicmMetadata(_preSidecar);
+                outputFormat.SetCicmMetadata(_preSidecar);
 
             _dumpLog.WriteLine("Closing output file.");
             UpdateStatus?.Invoke("Closing output file.");
             DateTime closeStart = DateTime.Now;
-            _outputPlugin.Close();
+            outputFormat.Close();
             DateTime closeEnd = DateTime.Now;
             UpdateStatus?.Invoke($"Closed in {(closeEnd - closeStart).TotalSeconds} seconds.");
             _dumpLog.WriteLine("Closed in {0} seconds.", (closeEnd - closeStart).TotalSeconds);
diff --git a/Aaru.Core/Devices/Dumping/PlayStationPortable/UMD.cs b/Aaru.Core/Devices/Dumping/PlayStationPortable/UMD.cs
index d8fb013e2..ce9117e51 100644
--- a/Aaru.Core/Devices/Dumping/PlayStationPortable/UMD.cs
+++ b/Aaru.Core/Devices/Dumping/PlayStationPortable/UMD.cs
@@ -65,6 +65,7 @@ namespace Aaru.Core.Devices.Dumping
             DateTime        start;
             DateTime        end;
             byte[]          senseBuf;
+            var             outputOptical = _outputPlugin as IWritableOpticalImage;
 
             bool sense = _dev.Read12(out byte[] readBuffer, out _, 0, false, true, false, false, 0, 512, 0, 1, false,
                                      _dev.Timeout, out _);
@@ -138,16 +139,16 @@ namespace Aaru.Core.Devices.Dumping
 
             var mhddLog = new MhddLog(_outputPrefix + ".mhddlog.bin", _dev, blocks, blockSize, blocksToRead, _private);
             var ibgLog  = new IbgLog(_outputPrefix  + ".ibg", 0x0010);
-            ret = _outputPlugin.Create(_outputPath, dskType, _formatOptions, blocks, blockSize);
+            ret = outputOptical.Create(_outputPath, dskType, _formatOptions, blocks, blockSize);
 
             // Cannot create image
             if(!ret)
             {
                 _dumpLog.WriteLine("Error creating output image, not continuing.");
-                _dumpLog.WriteLine(_outputPlugin.ErrorMessage);
+                _dumpLog.WriteLine(outputOptical.ErrorMessage);
 
                 StoppingErrorMessage?.Invoke("Error creating output image, not continuing." + Environment.NewLine +
-                                             _outputPlugin.ErrorMessage);
+                                             outputOptical.ErrorMessage);
 
                 return;
             }
@@ -155,7 +156,7 @@ namespace Aaru.Core.Devices.Dumping
             start = DateTime.UtcNow;
             double imageWriteDuration = 0;
 
-            (_outputPlugin as IWritableOpticalImage)?.SetTracks(new List<Track>
+            (outputOptical as IWritableOpticalImage)?.SetTracks(new List<Track>
             {
                 new Track
                 {
@@ -230,7 +231,7 @@ namespace Aaru.Core.Devices.Dumping
                     mhddLog.Write(i, cmdDuration);
                     ibgLog.Write(i, currentSpeed * 1024);
                     DateTime writeStart = DateTime.Now;
-                    _outputPlugin.WriteSectors(readBuffer, i, blocksToRead);
+                    outputOptical.WriteSectors(readBuffer, i, blocksToRead);
                     imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
                     extents.Add(i, blocksToRead, true);
                 }
@@ -247,7 +248,7 @@ namespace Aaru.Core.Devices.Dumping
 
                     // Write empty data
                     DateTime writeStart = DateTime.Now;
-                    _outputPlugin.WriteSectors(new byte[blockSize * _skip], i, _skip);
+                    outputOptical.WriteSectors(new byte[blockSize * _skip], i, _skip);
                     imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
 
                     for(ulong b = i; b < i + _skip; b++)
@@ -336,7 +337,7 @@ namespace Aaru.Core.Devices.Dumping
 
                     _resume.BadBlocks.Remove(badSector);
                     extents.Add(badSector);
-                    _outputPlugin.WriteSector(readBuffer, badSector);
+                    outputOptical.WriteSector(readBuffer, badSector);
                 }
 
                 EndProgress?.Invoke();
@@ -476,14 +477,14 @@ namespace Aaru.Core.Devices.Dumping
                     {
                         _resume.BadBlocks.Remove(badSector);
                         extents.Add(badSector);
-                        _outputPlugin.WriteSector(readBuffer, badSector);
+                        outputOptical.WriteSector(readBuffer, badSector);
 
                         UpdateStatus?.Invoke($"Correctly retried block {badSector} in pass {pass}.");
 
                         _dumpLog.WriteLine("Correctly retried block {0} in pass {1}.", badSector, pass);
                     }
                     else if(runningPersistent)
-                        _outputPlugin.WriteSector(readBuffer, badSector);
+                        outputOptical.WriteSector(readBuffer, badSector);
                 }
 
                 if(pass < _retryPasses &&
@@ -536,19 +537,19 @@ namespace Aaru.Core.Devices.Dumping
                 MediaPartNumber    = mediaPartNumber
             };
 
-            if(!_outputPlugin.SetMetadata(metadata))
+            if(!outputOptical.SetMetadata(metadata))
                 ErrorMessage?.Invoke("Error {0} setting metadata, continuing..." + Environment.NewLine +
-                                     _outputPlugin.ErrorMessage);
+                                     outputOptical.ErrorMessage);
 
-            _outputPlugin.SetDumpHardware(_resume.Tries);
+            outputOptical.SetDumpHardware(_resume.Tries);
 
             if(_preSidecar != null)
-                _outputPlugin.SetCicmMetadata(_preSidecar);
+                outputOptical.SetCicmMetadata(_preSidecar);
 
             _dumpLog.WriteLine("Closing output file.");
             UpdateStatus?.Invoke("Closing output file.");
             DateTime closeStart = DateTime.Now;
-            _outputPlugin.Close();
+            outputOptical.Close();
             DateTime closeEnd = DateTime.Now;
             _dumpLog.WriteLine("Closed in {0} seconds.", (closeEnd - closeStart).TotalSeconds);
 
diff --git a/Aaru.Core/Devices/Dumping/SSC.cs b/Aaru.Core/Devices/Dumping/SSC.cs
index 985aa0fde..2a972530a 100644
--- a/Aaru.Core/Devices/Dumping/SSC.cs
+++ b/Aaru.Core/Devices/Dumping/SSC.cs
@@ -71,6 +71,7 @@ namespace Aaru.Core.Devices.Dumping
             double        currentSpeed  = 0;
             double        maxSpeed      = double.MinValue;
             double        minSpeed      = double.MaxValue;
+            var           outputTape    = _outputPlugin as IWritableTapeImage;
 
             _dev.RequestSense(out byte[] senseBuf, _dev.Timeout, out double duration);
             decSense = Sense.Decode(senseBuf);
@@ -757,30 +758,30 @@ namespace Aaru.Core.Devices.Dumping
                 }
             }
 
-            bool ret = (_outputPlugin as IWritableTapeImage).SetTape();
+            bool ret = outputTape.SetTape();
 
             // Cannot set image to tape mode
             if(!ret)
             {
                 _dumpLog.WriteLine("Error setting output image in tape mode, not continuing.");
-                _dumpLog.WriteLine(_outputPlugin.ErrorMessage);
+                _dumpLog.WriteLine(outputTape.ErrorMessage);
 
                 StoppingErrorMessage?.Invoke("Error setting output image in tape mode, not continuing." +
-                                             Environment.NewLine + _outputPlugin.ErrorMessage);
+                                             Environment.NewLine + outputTape.ErrorMessage);
 
                 return;
             }
 
-            ret = _outputPlugin.Create(_outputPath, dskType, _formatOptions, 0, 0);
+            ret = outputTape.Create(_outputPath, dskType, _formatOptions, 0, 0);
 
             // Cannot create image
             if(!ret)
             {
                 _dumpLog.WriteLine("Error creating output image, not continuing.");
-                _dumpLog.WriteLine(_outputPlugin.ErrorMessage);
+                _dumpLog.WriteLine(outputTape.ErrorMessage);
 
                 StoppingErrorMessage?.Invoke("Error creating output image, not continuing." + Environment.NewLine +
-                                             _outputPlugin.ErrorMessage);
+                                             outputTape.ErrorMessage);
 
                 return;
             }
@@ -808,21 +809,20 @@ namespace Aaru.Core.Devices.Dumping
                 currentBlock = _resume.NextBlock;
 
                 currentTapeFile =
-                    (_outputPlugin as IWritableTapeImage).Files.FirstOrDefault(f => f.LastBlock ==
-                                                                                   (_outputPlugin as
-                                                                                           IWritableTapeImage)?.
-                                                                                   Files.Max(g => g.LastBlock));
+                    outputTape.Files.FirstOrDefault(f => f.LastBlock ==
+                                                         outputTape?.
+                                                         Files.Max(g => g.LastBlock));
 
                 currentTapePartition =
-                    (_outputPlugin as IWritableTapeImage).TapePartitions.FirstOrDefault(p => p.LastBlock ==
-                        (_outputPlugin as IWritableTapeImage)?.TapePartitions.Max(g => g.LastBlock));
+                    outputTape.TapePartitions.FirstOrDefault(p => p.LastBlock ==
+                                                                  outputTape?.TapePartitions.Max(g => g.LastBlock));
             }
 
             if(mode6Data != null)
-                _outputPlugin.WriteMediaTag(mode6Data, MediaTagType.SCSI_MODESENSE_6);
+                outputTape.WriteMediaTag(mode6Data, MediaTagType.SCSI_MODESENSE_6);
 
             if(mode10Data != null)
-                _outputPlugin.WriteMediaTag(mode10Data, MediaTagType.SCSI_MODESENSE_10);
+                outputTape.WriteMediaTag(mode10Data, MediaTagType.SCSI_MODESENSE_10);
 
             DateTime timeSpeedStart     = DateTime.UtcNow;
             ulong    currentSpeedSize   = 0;
@@ -849,10 +849,10 @@ namespace Aaru.Core.Devices.Dumping
                     currentTapeFile.LastBlock = currentBlock - 1;
 
                     if(currentTapeFile.LastBlock > currentTapeFile.FirstBlock)
-                        (_outputPlugin as IWritableTapeImage).AddFile(currentTapeFile);
+                        outputTape.AddFile(currentTapeFile);
 
                     currentTapePartition.LastBlock = currentBlock - 1;
-                    (_outputPlugin as IWritableTapeImage).AddPartition(currentTapePartition);
+                    outputTape.AddPartition(currentTapePartition);
 
                     currentPartition++;
 
@@ -945,7 +945,7 @@ namespace Aaru.Core.Devices.Dumping
                             StoppingErrorMessage?.Invoke("Drive could not go back one block. Sense follows..." +
                                                          Environment.NewLine + decSense.Value.Description);
 
-                            _outputPlugin.Close();
+                            outputTape.Close();
                             _dumpLog.WriteLine("Drive could not go back one block. Sense follows...");
 
                             _dumpLog.WriteLine("Device not ready. Sense {0}h ASC {1:X2}h ASCQ {2:X2}h",
@@ -961,7 +961,7 @@ namespace Aaru.Core.Devices.Dumping
                     {
                         case SenseKeys.BlankCheck when currentBlock == 0:
                             StoppingErrorMessage?.Invoke("Cannot dump a blank tape...");
-                            _outputPlugin.Close();
+                            outputTape.Close();
                             _dumpLog.WriteLine("Cannot dump a blank tape...");
 
                             return;
@@ -1001,7 +1001,7 @@ namespace Aaru.Core.Devices.Dumping
                        (decSense.Value.ASCQ == 0x01 || filemark))
                     {
                         currentTapeFile.LastBlock = currentBlock - 1;
-                        (_outputPlugin as IWritableTapeImage).AddFile(currentTapeFile);
+                        outputTape.AddFile(currentTapeFile);
 
                         currentFile++;
 
@@ -1043,7 +1043,7 @@ namespace Aaru.Core.Devices.Dumping
 
                     // Write empty data
                     DateTime writeStart = DateTime.Now;
-                    _outputPlugin.WriteSector(new byte[blockSize], currentBlock);
+                    outputTape.WriteSector(new byte[blockSize], currentBlock);
                     imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
 
                     mhddLog.Write(currentBlock, duration < 500 ? 65535 : duration);
@@ -1055,7 +1055,7 @@ namespace Aaru.Core.Devices.Dumping
                     mhddLog.Write(currentBlock, duration);
                     ibgLog.Write(currentBlock, currentSpeed * 1024);
                     DateTime writeStart = DateTime.Now;
-                    _outputPlugin.WriteSector(cmdBuf, currentBlock);
+                    outputTape.WriteSector(cmdBuf, currentBlock);
                     imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
                     extents.Add(currentBlock, 1, true);
                 }
@@ -1082,10 +1082,10 @@ namespace Aaru.Core.Devices.Dumping
             if(_aborted)
             {
                 currentTapeFile.LastBlock = currentBlock - 1;
-                (_outputPlugin as IWritableTapeImage).AddFile(currentTapeFile);
+                outputTape.AddFile(currentTapeFile);
 
                 currentTapePartition.LastBlock = currentBlock - 1;
-                (_outputPlugin as IWritableTapeImage).AddPartition(currentTapePartition);
+                outputTape.AddPartition(currentTapePartition);
             }
 
             EndProgress?.Invoke();
@@ -1228,12 +1228,12 @@ namespace Aaru.Core.Devices.Dumping
                     {
                         _resume.BadBlocks.Remove(badBlock);
                         extents.Add(badBlock);
-                        _outputPlugin.WriteSector(cmdBuf, badBlock);
+                        outputTape.WriteSector(cmdBuf, badBlock);
                         UpdateStatus?.Invoke($"Correctly retried block {badBlock} in pass {pass}.");
                         _dumpLog.WriteLine("Correctly retried block {0} in pass {1}.", badBlock, pass);
                     }
                     else if(runningPersistent)
-                        _outputPlugin.WriteSector(cmdBuf, badBlock);
+                        outputTape.WriteSector(cmdBuf, badBlock);
                 }
 
                 if(pass < _retryPasses &&
@@ -1266,7 +1266,7 @@ namespace Aaru.Core.Devices.Dumping
 
             currentTry.Extents = ExtentsConverter.ToMetadata(extents);
 
-            _outputPlugin.SetDumpHardware(_resume.Tries);
+            outputTape.SetDumpHardware(_resume.Tries);
 
             // TODO: Media Serial Number
             var metadata = new CommonTypes.Structs.ImageInfo
@@ -1275,17 +1275,17 @@ namespace Aaru.Core.Devices.Dumping
                 ApplicationVersion = Version.GetVersion()
             };
 
-            if(!_outputPlugin.SetMetadata(metadata))
+            if(!outputTape.SetMetadata(metadata))
                 ErrorMessage?.Invoke("Error {0} setting metadata, continuing..." + Environment.NewLine +
-                                     _outputPlugin.ErrorMessage);
+                                     outputTape.ErrorMessage);
 
             if(_preSidecar != null)
-                _outputPlugin.SetCicmMetadata(_preSidecar);
+                outputTape.SetCicmMetadata(_preSidecar);
 
             _dumpLog.WriteLine("Closing output file.");
             UpdateStatus?.Invoke("Closing output file.");
             DateTime closeStart = DateTime.Now;
-            _outputPlugin.Close();
+            outputTape.Close();
             DateTime closeEnd = DateTime.Now;
             UpdateStatus?.Invoke($"Closed in {(closeEnd - closeStart).TotalSeconds} seconds.");
             _dumpLog.WriteLine("Closed in {0} seconds.", (closeEnd - closeStart).TotalSeconds);
diff --git a/Aaru.Core/Devices/Dumping/Sbc/Data.cs b/Aaru.Core/Devices/Dumping/Sbc/Data.cs
index 9f38d33e4..50f7c141f 100644
--- a/Aaru.Core/Devices/Dumping/Sbc/Data.cs
+++ b/Aaru.Core/Devices/Dumping/Sbc/Data.cs
@@ -29,6 +29,7 @@ using System;
 using System.Linq;
 using Aaru.CommonTypes.Enums;
 using Aaru.CommonTypes.Extents;
+using Aaru.CommonTypes.Interfaces;
 using Aaru.Core.Logging;
 using Aaru.Decoders.DVD;
 using Aaru.Decryption;
@@ -71,6 +72,7 @@ namespace Aaru.Core.Devices.Dumping
             DateTime timeSpeedStart = DateTime.UtcNow;
             byte[]   buffer;
             uint     blocksToRead = maxBlocksToRead;
+            var      outputFormat = _outputPlugin as IWritableImage;
 
             InitProgress?.Invoke();
 
@@ -129,7 +131,7 @@ namespace Aaru.Core.Devices.Dumping
                                 CSS_CPRM.TitleKey? titleKey = CSS.DecodeTitleKey(tmpBuf, dvdDecrypt.BusKey);
 
                                 if(titleKey.HasValue)
-                                    _outputPlugin.WriteSectorTag(new[]
+                                    outputFormat.WriteSectorTag(new[]
                                     {
                                         titleKey.Value.CMI
                                     }, i + j, SectorTagType.DvdCmi);
@@ -140,12 +142,12 @@ namespace Aaru.Core.Devices.Dumping
                                 if((titleKey.Value.CMI & 0x80) >> 7 == 0)
                                 {
                                     // The CMI indicates this sector is not encrypted.
-                                    _outputPlugin.WriteSectorTag(new byte[]
+                                    outputFormat.WriteSectorTag(new byte[]
                                     {
                                         0, 0, 0, 0, 0
                                     }, i + j, SectorTagType.DvdTitleKey);
 
-                                    _outputPlugin.WriteSectorTag(new byte[]
+                                    outputFormat.WriteSectorTag(new byte[]
                                     {
                                         0, 0, 0, 0, 0
                                     }, i + j, SectorTagType.DvdTitleKeyDecrypted);
@@ -159,12 +161,12 @@ namespace Aaru.Core.Devices.Dumping
                                 // not encrypted even if the CMI says it is.
                                 if(titleKey.Value.Key.All(k => k == 0))
                                 {
-                                    _outputPlugin.WriteSectorTag(new byte[]
+                                    outputFormat.WriteSectorTag(new byte[]
                                     {
                                         0, 0, 0, 0, 0
                                     }, i + j, SectorTagType.DvdTitleKey);
 
-                                    _outputPlugin.WriteSectorTag(new byte[]
+                                    outputFormat.WriteSectorTag(new byte[]
                                     {
                                         0, 0, 0, 0, 0
                                     }, i + j, SectorTagType.DvdTitleKeyDecrypted);
@@ -174,26 +176,26 @@ namespace Aaru.Core.Devices.Dumping
                                     continue;
                                 }
 
-                                _outputPlugin.WriteSectorTag(titleKey.Value.Key, i + j, SectorTagType.DvdTitleKey);
+                                outputFormat.WriteSectorTag(titleKey.Value.Key, i + j, SectorTagType.DvdTitleKey);
                                 _resume.MissingTitleKeys.Remove(i                  + j);
 
                                 CSS.DecryptTitleKey(0, discKey, titleKey.Value.Key, out tmpBuf);
-                                _outputPlugin.WriteSectorTag(tmpBuf, i + j, SectorTagType.DvdTitleKeyDecrypted);
+                                outputFormat.WriteSectorTag(tmpBuf, i + j, SectorTagType.DvdTitleKeyDecrypted);
                             }
                         }
 
                         if(!_storeEncrypted)
 
-                            // Todo: Flag in the _outputPlugin that a sector has been decrypted
+                            // Todo: Flag in the outputFormat that a sector has been decrypted
                         {
                             ErrorNumber errno =
-                                _outputPlugin.ReadSectorsTag(i, blocksToRead, SectorTagType.DvdCmi, out byte[] cmi);
+                                outputFormat.ReadSectorsTag(i, blocksToRead, SectorTagType.DvdCmi, out byte[] cmi);
 
                             if(errno != ErrorNumber.NoError)
                                 ErrorMessage?.Invoke($"Error retrieving CMI for sector {i}");
                             else
                             {
-                                errno = _outputPlugin.ReadSectorsTag(i, blocksToRead,
+                                errno = outputFormat.ReadSectorsTag(i, blocksToRead,
                                                                      SectorTagType.DvdTitleKeyDecrypted,
                                                                      out byte[] titleKey);
 
@@ -208,7 +210,7 @@ namespace Aaru.Core.Devices.Dumping
                     mhddLog.Write(i, cmdDuration);
                     ibgLog.Write(i, currentSpeed * 1024);
                     DateTime writeStart = DateTime.Now;
-                    _outputPlugin.WriteSectors(buffer, i, blocksToRead);
+                    outputFormat.WriteSectors(buffer, i, blocksToRead);
                     imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
                     extents.Add(i, blocksToRead, true);
                 }
@@ -239,7 +241,7 @@ namespace Aaru.Core.Devices.Dumping
 
                     // Write empty data
                     DateTime writeStart = DateTime.Now;
-                    _outputPlugin.WriteSectors(new byte[blockSize * _skip], i, _skip);
+                    outputFormat.WriteSectors(new byte[blockSize * _skip], i, _skip);
                     imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
 
                     for(ulong b = i; b < i + _skip; b++)
diff --git a/Aaru.Core/Devices/Dumping/Sbc/Dump.cs b/Aaru.Core/Devices/Dumping/Sbc/Dump.cs
index cad9b1ff4..c787ffa6c 100644
--- a/Aaru.Core/Devices/Dumping/Sbc/Dump.cs
+++ b/Aaru.Core/Devices/Dumping/Sbc/Dump.cs
@@ -87,6 +87,7 @@ namespace Aaru.Core.Devices.Dumping
             Modes.DecodedMode? decMode = null;
             bool               ret;
             ExtentsULong       blankExtents = null;
+            var                outputFormat = _outputPlugin as IWritableImage;
 
             if(opticalDisc)
                 switch(dskType)
@@ -317,7 +318,7 @@ namespace Aaru.Core.Devices.Dumping
 
             ret = true;
 
-            foreach(MediaTagType tag in mediaTags.Keys.Where(tag => !_outputPlugin.SupportedMediaTags.Contains(tag)))
+            foreach(MediaTagType tag in mediaTags.Keys.Where(tag => !outputFormat.SupportedMediaTags.Contains(tag)))
             {
                 ret = false;
                 _dumpLog.WriteLine($"Output format does not support {tag}.");
@@ -349,16 +350,16 @@ namespace Aaru.Core.Devices.Dumping
 
             if(!opticalDisc)
             {
-                ret = _outputPlugin.Create(_outputPath, dskType, _formatOptions, blocks, blockSize);
+                ret = outputFormat.Create(_outputPath, dskType, _formatOptions, blocks, blockSize);
 
                 // Cannot create image
                 if(!ret)
                 {
                     _dumpLog.WriteLine("Error creating output image, not continuing.");
-                    _dumpLog.WriteLine(_outputPlugin.ErrorMessage);
+                    _dumpLog.WriteLine(outputFormat.ErrorMessage);
 
                     StoppingErrorMessage?.Invoke("Error creating output image, not continuing." + Environment.NewLine +
-                                                 _outputPlugin.ErrorMessage);
+                                                 outputFormat.ErrorMessage);
 
                     return;
                 }
@@ -372,7 +373,7 @@ namespace Aaru.Core.Devices.Dumping
 
             if(opticalDisc)
             {
-                if(_outputPlugin is IWritableOpticalImage opticalPlugin)
+                if(outputFormat is IWritableOpticalImage opticalPlugin)
                 {
                     sense = _dev.ReadDiscInformation(out readBuffer, out _, MmcDiscInformationDataTypes.DiscInformation,
                                                      _dev.Timeout, out _);
@@ -505,16 +506,16 @@ namespace Aaru.Core.Devices.Dumping
                             else
                                 tracks = tracks.OrderBy(t => t.Sequence).ToList();
 
-                            ret = _outputPlugin.Create(_outputPath, dskType, _formatOptions, blocks, blockSize);
+                            ret = outputFormat.Create(_outputPath, dskType, _formatOptions, blocks, blockSize);
 
                             // Cannot create image
                             if(!ret)
                             {
                                 _dumpLog.WriteLine("Error creating output image, not continuing.");
-                                _dumpLog.WriteLine(_outputPlugin.ErrorMessage);
+                                _dumpLog.WriteLine(outputFormat.ErrorMessage);
 
                                 StoppingErrorMessage?.Invoke("Error creating output image, not continuing." +
-                                                             Environment.NewLine + _outputPlugin.ErrorMessage);
+                                                             Environment.NewLine + outputFormat.ErrorMessage);
 
                                 return;
                             }
@@ -588,7 +589,7 @@ namespace Aaru.Core.Devices.Dumping
                         UpdateStatus?.
                             Invoke($"Setting geometry to {rigidPage.Value.Cylinders} cylinders, {rigidPage.Value.Heads} heads, {(uint)(blocks / (rigidPage.Value.Cylinders * rigidPage.Value.Heads))} sectors per track");
 
-                        _outputPlugin.SetGeometry(rigidPage.Value.Cylinders, rigidPage.Value.Heads,
+                        outputFormat.SetGeometry(rigidPage.Value.Cylinders, rigidPage.Value.Heads,
                                                   (uint)(blocks / (rigidPage.Value.Cylinders * rigidPage.Value.Heads)));
 
                         setGeometry = true;
@@ -608,7 +609,7 @@ namespace Aaru.Core.Devices.Dumping
                         UpdateStatus?.
                             Invoke($"Setting geometry to {flexiblePage.Value.Cylinders} cylinders, {flexiblePage.Value.Heads} heads, {flexiblePage.Value.SectorsPerTrack} sectors per track");
 
-                        _outputPlugin.SetGeometry(flexiblePage.Value.Cylinders, flexiblePage.Value.Heads,
+                        outputFormat.SetGeometry(flexiblePage.Value.Cylinders, flexiblePage.Value.Heads,
                                                   flexiblePage.Value.SectorsPerTrack);
 
                         setGeometry = true;
@@ -617,16 +618,16 @@ namespace Aaru.Core.Devices.Dumping
 
             if(!imageCreated)
             {
-                ret = _outputPlugin.Create(_outputPath, dskType, _formatOptions, blocks, blockSize);
+                ret = outputFormat.Create(_outputPath, dskType, _formatOptions, blocks, blockSize);
 
                 // Cannot create image
                 if(!ret)
                 {
                     _dumpLog.WriteLine("Error creating output image, not continuing.");
-                    _dumpLog.WriteLine(_outputPlugin.ErrorMessage);
+                    _dumpLog.WriteLine(outputFormat.ErrorMessage);
 
                     StoppingErrorMessage?.Invoke("Error creating output image, not continuing." + Environment.NewLine +
-                                                 _outputPlugin.ErrorMessage);
+                                                 outputFormat.ErrorMessage);
 
                     return;
                 }
@@ -637,7 +638,7 @@ namespace Aaru.Core.Devices.Dumping
 
                     UpdateStatus?.Invoke("Creating single track as could not retrieve track list from drive.");
 
-                    (_outputPlugin as IWritableOpticalImage)?.SetTracks(new List<Track>
+                    (outputFormat as IWritableOpticalImage)?.SetTracks(new List<Track>
                     {
                         new()
                         {
@@ -784,7 +785,7 @@ namespace Aaru.Core.Devices.Dumping
                         continue;
                     }
 
-                    ret = _outputPlugin.WriteMediaTag(tag.Value, tag.Key);
+                    ret = outputFormat.WriteMediaTag(tag.Value, tag.Key);
 
                     if(ret || _force)
                         continue;
@@ -793,7 +794,7 @@ namespace Aaru.Core.Devices.Dumping
                     StoppingErrorMessage?.Invoke($"Cannot write tag {tag.Key}.");
 
                     _dumpLog.WriteLine($"Cannot write tag {tag.Key}." + Environment.NewLine +
-                                       _outputPlugin.ErrorMessage);
+                                       outputFormat.ErrorMessage);
 
                     return;
                 }
@@ -808,7 +809,7 @@ namespace Aaru.Core.Devices.Dumping
                     {
                         UpdateStatus?.Invoke("Reading USB descriptors.");
                         _dumpLog.WriteLine("Reading USB descriptors.");
-                        ret = _outputPlugin.WriteMediaTag(_dev.UsbDescriptors, MediaTagType.USB_Descriptors);
+                        ret = outputFormat.WriteMediaTag(_dev.UsbDescriptors, MediaTagType.USB_Descriptors);
 
                         if(!ret &&
                            !_force)
@@ -816,7 +817,7 @@ namespace Aaru.Core.Devices.Dumping
                             _dumpLog.WriteLine("Cannot write USB descriptors.");
 
                             StoppingErrorMessage?.Invoke("Cannot write USB descriptors." + Environment.NewLine +
-                                                         _outputPlugin.ErrorMessage);
+                                                         outputFormat.ErrorMessage);
 
                             return;
                         }
@@ -835,7 +836,7 @@ namespace Aaru.Core.Devices.Dumping
                             if(_private)
                                 cmdBuf = DeviceReport.ClearIdentify(cmdBuf);
 
-                            ret = _outputPlugin.WriteMediaTag(cmdBuf, MediaTagType.ATAPI_IDENTIFY);
+                            ret = outputFormat.WriteMediaTag(cmdBuf, MediaTagType.ATAPI_IDENTIFY);
 
                             if(!ret &&
                                !_force)
@@ -843,7 +844,7 @@ namespace Aaru.Core.Devices.Dumping
                                 _dumpLog.WriteLine("Cannot write ATAPI IDENTIFY PACKET DEVICE.");
 
                                 StoppingErrorMessage?.Invoke("Cannot write ATAPI IDENTIFY PACKET DEVICE." +
-                                                             Environment.NewLine + _outputPlugin.ErrorMessage);
+                                                             Environment.NewLine + outputFormat.ErrorMessage);
 
                                 return;
                             }
@@ -856,7 +857,7 @@ namespace Aaru.Core.Devices.Dumping
                     {
                         UpdateStatus?.Invoke("Requesting SCSI INQUIRY.");
                         _dumpLog.WriteLine("Requesting SCSI INQUIRY.");
-                        ret = _outputPlugin.WriteMediaTag(cmdBuf, MediaTagType.SCSI_INQUIRY);
+                        ret = outputFormat.WriteMediaTag(cmdBuf, MediaTagType.SCSI_INQUIRY);
 
                         if(!ret &&
                            !_force)
@@ -864,7 +865,7 @@ namespace Aaru.Core.Devices.Dumping
                             StoppingErrorMessage?.Invoke("Cannot write SCSI INQUIRY.");
 
                             _dumpLog.WriteLine("Cannot write SCSI INQUIRY." + Environment.NewLine +
-                                               _outputPlugin.ErrorMessage);
+                                               outputFormat.ErrorMessage);
 
                             return;
                         }
@@ -884,7 +885,7 @@ namespace Aaru.Core.Devices.Dumping
                            !_dev.Error)
                             if(Modes.DecodeMode10(cmdBuf, _dev.ScsiType).HasValue)
                             {
-                                ret = _outputPlugin.WriteMediaTag(cmdBuf, MediaTagType.SCSI_MODESENSE_10);
+                                ret = outputFormat.WriteMediaTag(cmdBuf, MediaTagType.SCSI_MODESENSE_10);
 
                                 if(!ret &&
                                    !_force)
@@ -892,7 +893,7 @@ namespace Aaru.Core.Devices.Dumping
                                     _dumpLog.WriteLine("Cannot write SCSI MODE SENSE (10).");
 
                                     StoppingErrorMessage?.Invoke("Cannot write SCSI MODE SENSE (10)." +
-                                                                 Environment.NewLine + _outputPlugin.ErrorMessage);
+                                                                 Environment.NewLine + outputFormat.ErrorMessage);
 
                                     return;
                                 }
@@ -915,7 +916,7 @@ namespace Aaru.Core.Devices.Dumping
                            !_dev.Error)
                             if(Modes.DecodeMode6(cmdBuf, _dev.ScsiType).HasValue)
                             {
-                                ret = _outputPlugin.WriteMediaTag(cmdBuf, MediaTagType.SCSI_MODESENSE_6);
+                                ret = outputFormat.WriteMediaTag(cmdBuf, MediaTagType.SCSI_MODESENSE_6);
 
                                 if(!ret &&
                                    !_force)
@@ -923,7 +924,7 @@ namespace Aaru.Core.Devices.Dumping
                                     _dumpLog.WriteLine("Cannot write SCSI MODE SENSE (6).");
 
                                     StoppingErrorMessage?.Invoke("Cannot write SCSI MODE SENSE (6)." +
-                                                                 Environment.NewLine + _outputPlugin.ErrorMessage);
+                                                                 Environment.NewLine + outputFormat.ErrorMessage);
 
                                     return;
                                 }
@@ -939,7 +940,7 @@ namespace Aaru.Core.Devices.Dumping
 
             currentTry.Extents = ExtentsConverter.ToMetadata(extents);
 
-            _outputPlugin.SetDumpHardware(_resume.Tries);
+            outputFormat.SetDumpHardware(_resume.Tries);
 
             // TODO: Media Serial Number
             // TODO: Non-removable drive information
@@ -949,17 +950,17 @@ namespace Aaru.Core.Devices.Dumping
                 ApplicationVersion = Version.GetVersion()
             };
 
-            if(!_outputPlugin.SetMetadata(metadata))
+            if(!outputFormat.SetMetadata(metadata))
                 ErrorMessage?.Invoke("Error {0} setting metadata, continuing..." + Environment.NewLine +
-                                     _outputPlugin.ErrorMessage);
+                                     outputFormat.ErrorMessage);
 
             if(_preSidecar != null)
-                _outputPlugin.SetCicmMetadata(_preSidecar);
+                outputFormat.SetCicmMetadata(_preSidecar);
 
             _dumpLog.WriteLine("Closing output file.");
             UpdateStatus?.Invoke("Closing output file.");
             DateTime closeStart = DateTime.Now;
-            _outputPlugin.Close();
+            outputFormat.Close();
             DateTime closeEnd = DateTime.Now;
             UpdateStatus?.Invoke($"Closed in {(closeEnd - closeStart).TotalSeconds} seconds.");
             _dumpLog.WriteLine("Closed in {0} seconds.", (closeEnd - closeStart).TotalSeconds);
@@ -1032,7 +1033,7 @@ namespace Aaru.Core.Devices.Dumping
                         {
                             if(_dev.IsUsb &&
                                _dev.UsbDescriptors != null)
-                                if(_outputPlugin.SupportedMediaTags.Contains(MediaTagType.USB_Descriptors))
+                                if(outputFormat.SupportedMediaTags.Contains(MediaTagType.USB_Descriptors))
                                     sidecar.BlockMedia[0].USB = new USBType
                                     {
                                         ProductID = _dev.UsbProductId,
@@ -1052,7 +1053,7 @@ namespace Aaru.Core.Devices.Dumping
                                 sense = _dev.AtapiIdentify(out cmdBuf, out _);
 
                                 if(!sense)
-                                    if(_outputPlugin.SupportedMediaTags.Contains(MediaTagType.ATAPI_IDENTIFY))
+                                    if(outputFormat.SupportedMediaTags.Contains(MediaTagType.ATAPI_IDENTIFY))
                                         sidecar.BlockMedia[0].ATA = new ATAType
                                         {
                                             Identify = new DumpType
@@ -1068,7 +1069,7 @@ namespace Aaru.Core.Devices.Dumping
 
                             if(!sense)
                             {
-                                if(_outputPlugin.SupportedMediaTags.Contains(MediaTagType.SCSI_INQUIRY))
+                                if(outputFormat.SupportedMediaTags.Contains(MediaTagType.SCSI_INQUIRY))
                                     sidecar.BlockMedia[0].SCSI = new SCSIType
                                     {
                                         Inquiry = new DumpType
@@ -1127,7 +1128,7 @@ namespace Aaru.Core.Devices.Dumping
                                 if(!sense &&
                                    !_dev.Error)
                                     if(Modes.DecodeMode10(cmdBuf, _dev.ScsiType).HasValue)
-                                        if(_outputPlugin.SupportedMediaTags.Contains(MediaTagType.SCSI_MODESENSE_10))
+                                        if(outputFormat.SupportedMediaTags.Contains(MediaTagType.SCSI_MODESENSE_10))
                                             sidecar.BlockMedia[0].SCSI.ModeSense10 = new DumpType
                                             {
                                                 Image     = _outputPath,
@@ -1151,7 +1152,7 @@ namespace Aaru.Core.Devices.Dumping
                                 if(!sense &&
                                    !_dev.Error)
                                     if(Modes.DecodeMode6(cmdBuf, _dev.ScsiType).HasValue)
-                                        if(_outputPlugin.SupportedMediaTags.Contains(MediaTagType.SCSI_MODESENSE_6))
+                                        if(outputFormat.SupportedMediaTags.Contains(MediaTagType.SCSI_MODESENSE_6))
                                             sidecar.BlockMedia[0].SCSI.ModeSense = new DumpType
                                             {
                                                 Image     = _outputPath,
diff --git a/Aaru.Core/Devices/Dumping/Sbc/Error.cs b/Aaru.Core/Devices/Dumping/Sbc/Error.cs
index 7b4cd87ec..9fe6998c8 100644
--- a/Aaru.Core/Devices/Dumping/Sbc/Error.cs
+++ b/Aaru.Core/Devices/Dumping/Sbc/Error.cs
@@ -28,6 +28,7 @@
 using System.Linq;
 using Aaru.CommonTypes.Enums;
 using Aaru.CommonTypes.Extents;
+using Aaru.CommonTypes.Interfaces;
 using Aaru.CommonTypes.Structs.Devices.SCSI;
 using Aaru.Console;
 using Aaru.Decoders.DVD;
@@ -65,7 +66,8 @@ namespace Aaru.Core.Devices.Dumping
             byte[]          md6;
             byte[]          md10;
             bool            blankCheck;
-            bool            newBlank = false;
+            bool            newBlank     = false;
+            var             outputFormat = _outputPlugin as IWritableImage;
 
             if(_persistent)
             {
@@ -265,13 +267,13 @@ namespace Aaru.Core.Devices.Dumping
                 {
                     _resume.BadBlocks.Remove(badSector);
                     extents.Add(badSector);
-                    _outputPlugin.WriteSector(buffer, badSector);
+                    outputFormat.WriteSector(buffer, badSector);
                     UpdateStatus?.Invoke($"Correctly retried block {badSector} in pass {pass}.");
                     _dumpLog.WriteLine("Correctly retried block {0} in pass {1}.", badSector, pass);
                 }
                 else if(runningPersistent)
                 {
-                    _outputPlugin.WriteSector(buffer, badSector);
+                    outputFormat.WriteSector(buffer, badSector);
                 }
             }
 
@@ -323,6 +325,7 @@ namespace Aaru.Core.Devices.Dumping
             bool   forward = true;
             bool   sense;
             byte[] buffer;
+            var    outputFormat = _outputPlugin as IWritableImage;
 
             InitProgress?.Invoke();
 
@@ -354,7 +357,7 @@ namespace Aaru.Core.Devices.Dumping
 
                     if(titleKey.HasValue)
                     {
-                        _outputPlugin.WriteSectorTag(new[]
+                        outputFormat.WriteSectorTag(new[]
                         {
                             titleKey.Value.CMI
                         }, missingKey, SectorTagType.DvdCmi);
@@ -364,12 +367,12 @@ namespace Aaru.Core.Devices.Dumping
                         if((titleKey.Value.CMI & 0x80) >> 7 == 0 ||
                            titleKey.Value.Key.All(k => k == 0))
                         {
-                            _outputPlugin.WriteSectorTag(new byte[]
+                            outputFormat.WriteSectorTag(new byte[]
                             {
                                 0, 0, 0, 0, 0
                             }, missingKey, SectorTagType.DvdTitleKey);
 
-                            _outputPlugin.WriteSectorTag(new byte[]
+                            outputFormat.WriteSectorTag(new byte[]
                             {
                                 0, 0, 0, 0, 0
                             }, missingKey, SectorTagType.DvdTitleKeyDecrypted);
@@ -380,13 +383,13 @@ namespace Aaru.Core.Devices.Dumping
                         }
                         else
                         {
-                            _outputPlugin.WriteSectorTag(titleKey.Value.Key, missingKey, SectorTagType.DvdTitleKey);
+                            outputFormat.WriteSectorTag(titleKey.Value.Key, missingKey, SectorTagType.DvdTitleKey);
                             _resume.MissingTitleKeys.Remove(missingKey);
 
                             if(discKey != null)
                             {
                                 CSS.DecryptTitleKey(0, discKey, titleKey.Value.Key, out buffer);
-                                _outputPlugin.WriteSectorTag(buffer, missingKey, SectorTagType.DvdTitleKeyDecrypted);
+                                outputFormat.WriteSectorTag(buffer, missingKey, SectorTagType.DvdTitleKeyDecrypted);
                             }
 
                             UpdateStatus?.Invoke($"Correctly retried title key {missingKey} in pass {pass}.");
diff --git a/Aaru.Core/Devices/Dumping/Sbc/Optical.cs b/Aaru.Core/Devices/Dumping/Sbc/Optical.cs
index 75e73684b..9c8347165 100644
--- a/Aaru.Core/Devices/Dumping/Sbc/Optical.cs
+++ b/Aaru.Core/Devices/Dumping/Sbc/Optical.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Linq;
 using Aaru.CommonTypes.Extents;
+using Aaru.CommonTypes.Interfaces;
 using Aaru.Console;
 using Aaru.Core.Logging;
 using Aaru.Decoders.SCSI;
@@ -52,6 +53,7 @@ namespace Aaru.Core.Devices.Dumping
             ulong      sectorSpeedStart = 0;
             DateTime   timeSpeedStart   = DateTime.UtcNow;
             bool       canMediumScan    = true;
+            var        outputFormat     = _outputPlugin as IWritableImage;
 
             InitProgress?.Invoke();
 
@@ -217,7 +219,7 @@ namespace Aaru.Core.Devices.Dumping
                         mhddLog.Write(i, cmdDuration);
                         ibgLog.Write(i, currentSpeed * 1024);
                         DateTime writeStart = DateTime.Now;
-                        _outputPlugin.WriteSectors(buffer, i, blocksToRead);
+                        outputFormat.WriteSectors(buffer, i, blocksToRead);
                         imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
                         extents.Add(i, blocksToRead, true);
                     }
@@ -232,7 +234,7 @@ namespace Aaru.Core.Devices.Dumping
 
                         // Write empty data
                         DateTime writeStart = DateTime.Now;
-                        _outputPlugin.WriteSectors(new byte[blockSize * _skip], i, _skip);
+                        outputFormat.WriteSectors(new byte[blockSize * _skip], i, _skip);
                         imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
 
                         for(ulong b = i; b < i + _skip; b++)
diff --git a/Aaru.Core/Devices/Dumping/Sbc/Trim.cs b/Aaru.Core/Devices/Dumping/Sbc/Trim.cs
index b4e889de3..22704cfd0 100644
--- a/Aaru.Core/Devices/Dumping/Sbc/Trim.cs
+++ b/Aaru.Core/Devices/Dumping/Sbc/Trim.cs
@@ -25,6 +25,7 @@
 // ****************************************************************************/
 
 using Aaru.CommonTypes.Extents;
+using Aaru.CommonTypes.Interfaces;
 using Schemas;
 
 // ReSharper disable JoinDeclarationAndInitializer
@@ -48,7 +49,8 @@ namespace Aaru.Core.Devices.Dumping
             bool    recoveredError;
             bool    blankCheck;
             byte[]  buffer;
-            bool    newBlank = false;
+            bool    newBlank     = false;
+            var     outputFormat = _outputPlugin as IWritableImage;
 
             foreach(ulong badSector in tmpArray)
             {
@@ -83,7 +85,7 @@ namespace Aaru.Core.Devices.Dumping
 
                 _resume.BadBlocks.Remove(badSector);
                 extents.Add(badSector);
-                _outputPlugin.WriteSector(buffer, badSector);
+                outputFormat.WriteSector(buffer, badSector);
             }
 
             if(newBlank)
diff --git a/Aaru.Core/Devices/Dumping/SecureDigital.cs b/Aaru.Core/Devices/Dumping/SecureDigital.cs
index 6e69d190c..4ac60a4ed 100644
--- a/Aaru.Core/Devices/Dumping/SecureDigital.cs
+++ b/Aaru.Core/Devices/Dumping/SecureDigital.cs
@@ -88,6 +88,7 @@ namespace Aaru.Core.Devices.Dumping
             bool         byteAddressed     = true;
             uint[]       response;
             bool         supportsCmd23 = false;
+            var          outputFormat  = _outputPlugin as IWritableImage;
 
             Dictionary<MediaTagType, byte[]> mediaTags = new();
 
@@ -422,7 +423,7 @@ namespace Aaru.Core.Devices.Dumping
 
             bool ret = true;
 
-            foreach(MediaTagType tag in mediaTags.Keys.Where(tag => !_outputPlugin.SupportedMediaTags.Contains(tag)))
+            foreach(MediaTagType tag in mediaTags.Keys.Where(tag => !outputFormat.SupportedMediaTags.Contains(tag)))
             {
                 ret = false;
                 _dumpLog.WriteLine($"Output format does not support {tag}.");
@@ -448,7 +449,7 @@ namespace Aaru.Core.Devices.Dumping
             var mhddLog = new MhddLog(_outputPrefix + ".mhddlog.bin", _dev, blocks, blockSize, blocksToRead, _private);
             var ibgLog  = new IbgLog(_outputPrefix  + ".ibg", sdProfile);
 
-            ret = _outputPlugin.Create(_outputPath,
+            ret = outputFormat.Create(_outputPath,
                                        _dev.Type == DeviceType.SecureDigital ? MediaType.SecureDigital : MediaType.MMC,
                                        _formatOptions, blocks, blockSize);
 
@@ -456,10 +457,10 @@ namespace Aaru.Core.Devices.Dumping
             if(!ret)
             {
                 _dumpLog.WriteLine("Error creating output image, not continuing.");
-                _dumpLog.WriteLine(_outputPlugin.ErrorMessage);
+                _dumpLog.WriteLine(outputFormat.ErrorMessage);
 
                 StoppingErrorMessage?.Invoke("Error creating output image, not continuing." + Environment.NewLine +
-                                             _outputPlugin.ErrorMessage);
+                                             outputFormat.ErrorMessage);
 
                 return;
             }
@@ -487,7 +488,7 @@ namespace Aaru.Core.Devices.Dumping
                 }
 
                 ret =
-                    _outputPlugin.WriteMediaTag(cid,
+                    outputFormat.WriteMediaTag(cid,
                                                 _dev.Type == DeviceType.SecureDigital ? MediaTagType.SD_CID
                                                     : MediaTagType.MMC_CID);
 
@@ -498,7 +499,7 @@ namespace Aaru.Core.Devices.Dumping
                     _dumpLog.WriteLine("Cannot write CID to output image.");
 
                     StoppingErrorMessage?.Invoke("Cannot write CID to output image." + Environment.NewLine +
-                                                 _outputPlugin.ErrorMessage);
+                                                 outputFormat.ErrorMessage);
 
                     return;
                 }
@@ -507,7 +508,7 @@ namespace Aaru.Core.Devices.Dumping
             if(csd != null)
             {
                 ret =
-                    _outputPlugin.WriteMediaTag(csd,
+                    outputFormat.WriteMediaTag(csd,
                                                 _dev.Type == DeviceType.SecureDigital ? MediaTagType.SD_CSD
                                                     : MediaTagType.MMC_CSD);
 
@@ -518,7 +519,7 @@ namespace Aaru.Core.Devices.Dumping
                     _dumpLog.WriteLine("Cannot write CSD to output image.");
 
                     StoppingErrorMessage?.Invoke("Cannot write CSD to output image." + Environment.NewLine +
-                                                 _outputPlugin.ErrorMessage);
+                                                 outputFormat.ErrorMessage);
 
                     return;
                 }
@@ -526,7 +527,7 @@ namespace Aaru.Core.Devices.Dumping
 
             if(ecsd != null)
             {
-                ret = _outputPlugin.WriteMediaTag(ecsd, MediaTagType.MMC_ExtendedCSD);
+                ret = outputFormat.WriteMediaTag(ecsd, MediaTagType.MMC_ExtendedCSD);
 
                 // Cannot write Extended CSD to image
                 if(!ret &&
@@ -535,7 +536,7 @@ namespace Aaru.Core.Devices.Dumping
                     _dumpLog.WriteLine("Cannot write Extended CSD to output image.");
 
                     StoppingErrorMessage?.Invoke("Cannot write Extended CSD to output image." + Environment.NewLine +
-                                                 _outputPlugin.ErrorMessage);
+                                                 outputFormat.ErrorMessage);
 
                     return;
                 }
@@ -544,7 +545,7 @@ namespace Aaru.Core.Devices.Dumping
             if(ocr != null)
             {
                 ret =
-                    _outputPlugin.WriteMediaTag(ocr,
+                    outputFormat.WriteMediaTag(ocr,
                                                 _dev.Type == DeviceType.SecureDigital ? MediaTagType.SD_OCR
                                                     : MediaTagType.MMC_OCR);
 
@@ -555,7 +556,7 @@ namespace Aaru.Core.Devices.Dumping
                     _dumpLog.WriteLine("Cannot write OCR to output image.");
 
                     StoppingErrorMessage?.Invoke("Cannot write OCR to output image." + Environment.NewLine +
-                                                 _outputPlugin.ErrorMessage);
+                                                 outputFormat.ErrorMessage);
 
                     return;
                 }
@@ -563,7 +564,7 @@ namespace Aaru.Core.Devices.Dumping
 
             if(scr != null)
             {
-                ret = _outputPlugin.WriteMediaTag(scr, MediaTagType.SD_SCR);
+                ret = outputFormat.WriteMediaTag(scr, MediaTagType.SD_SCR);
 
                 // Cannot write SCR to image
                 if(!ret &&
@@ -572,7 +573,7 @@ namespace Aaru.Core.Devices.Dumping
                     _dumpLog.WriteLine("Cannot write SCR to output image.");
 
                     StoppingErrorMessage?.Invoke("Cannot write SCR to output image." + Environment.NewLine +
-                                                 _outputPlugin.ErrorMessage);
+                                                 outputFormat.ErrorMessage);
 
                     return;
                 }
@@ -635,7 +636,7 @@ namespace Aaru.Core.Devices.Dumping
                     mhddLog.Write(i, duration);
                     ibgLog.Write(i, currentSpeed * 1024);
                     DateTime writeStart = DateTime.Now;
-                    _outputPlugin.WriteSectors(cmdBuf, i, blocksToRead);
+                    outputFormat.WriteSectors(cmdBuf, i, blocksToRead);
                     imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
                     extents.Add(i, blocksToRead, true);
                 }
@@ -653,7 +654,7 @@ namespace Aaru.Core.Devices.Dumping
 
                     ibgLog.Write(i, 0);
                     DateTime writeStart = DateTime.Now;
-                    _outputPlugin.WriteSectors(new byte[blockSize * _skip], i, _skip);
+                    outputFormat.WriteSectors(new byte[blockSize * _skip], i, _skip);
                     imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
                     _dumpLog.WriteLine("Skipping {0} blocks from errored block {1}.", _skip, i);
                     i       += _skip - blocksToRead;
@@ -738,7 +739,7 @@ namespace Aaru.Core.Devices.Dumping
 
                     _resume.BadBlocks.Remove(badSector);
                     extents.Add(badSector);
-                    _outputPlugin.WriteSector(cmdBuf, badSector);
+                    outputFormat.WriteSector(cmdBuf, badSector);
                 }
 
                 EndProgress?.Invoke();
@@ -788,12 +789,12 @@ namespace Aaru.Core.Devices.Dumping
                     {
                         _resume.BadBlocks.Remove(badSector);
                         extents.Add(badSector);
-                        _outputPlugin.WriteSector(cmdBuf, badSector);
+                        outputFormat.WriteSector(cmdBuf, badSector);
                         UpdateStatus?.Invoke($"Correctly retried block {badSector} in pass {pass}.");
                         _dumpLog.WriteLine("Correctly retried block {0} in pass {1}.", badSector, pass);
                     }
                     else if(runningPersistent)
-                        _outputPlugin.WriteSector(cmdBuf, badSector);
+                        outputFormat.WriteSector(cmdBuf, badSector);
                 }
 
                 if(pass < _retryPasses &&
@@ -816,7 +817,7 @@ namespace Aaru.Core.Devices.Dumping
 
             currentTry.Extents = ExtentsConverter.ToMetadata(extents);
 
-            _outputPlugin.SetDumpHardware(_resume.Tries);
+            outputFormat.SetDumpHardware(_resume.Tries);
 
             // TODO: Drive info
             var metadata = new CommonTypes.Structs.ImageInfo
@@ -825,17 +826,17 @@ namespace Aaru.Core.Devices.Dumping
                 ApplicationVersion = Version.GetVersion()
             };
 
-            if(!_outputPlugin.SetMetadata(metadata))
+            if(!outputFormat.SetMetadata(metadata))
                 ErrorMessage?.Invoke("Error {0} setting metadata, continuing..." + Environment.NewLine +
-                                     _outputPlugin.ErrorMessage);
+                                     outputFormat.ErrorMessage);
 
             if(_preSidecar != null)
-                _outputPlugin.SetCicmMetadata(_preSidecar);
+                outputFormat.SetCicmMetadata(_preSidecar);
 
             _dumpLog.WriteLine("Closing output file.");
             UpdateStatus?.Invoke("Closing output file.");
             DateTime closeStart = DateTime.Now;
-            _outputPlugin.Close();
+            outputFormat.Close();
             DateTime closeEnd = DateTime.Now;
             UpdateStatus?.Invoke($"Closed in {(closeEnd - closeStart).TotalSeconds} seconds.");
             _dumpLog.WriteLine("Closed in {0} seconds.", (closeEnd - closeStart).TotalSeconds);
diff --git a/Aaru.Core/Devices/Dumping/XGD.cs b/Aaru.Core/Devices/Dumping/XGD.cs
index a912f51d6..e1d917018 100644
--- a/Aaru.Core/Devices/Dumping/XGD.cs
+++ b/Aaru.Core/Devices/Dumping/XGD.cs
@@ -72,6 +72,7 @@ namespace Aaru.Core.Devices.Dumping
             double     currentSpeed  = 0;
             double     maxSpeed      = double.MinValue;
             double     minSpeed      = double.MaxValue;
+            var        outputFormat  = _outputPlugin as IWritableImage;
 
             if(DetectOS.GetRealPlatformID() != PlatformID.Win32NT)
             {
@@ -443,7 +444,7 @@ namespace Aaru.Core.Devices.Dumping
 
             bool ret = true;
 
-            foreach(MediaTagType tag in mediaTags.Keys.Where(tag => !_outputPlugin.SupportedMediaTags.Contains(tag)))
+            foreach(MediaTagType tag in mediaTags.Keys.Where(tag => !outputFormat.SupportedMediaTags.Contains(tag)))
             {
                 ret = false;
                 _dumpLog.WriteLine($"Output format does not support {tag}.");
@@ -471,16 +472,16 @@ namespace Aaru.Core.Devices.Dumping
 
             var mhddLog = new MhddLog(_outputPrefix + ".mhddlog.bin", _dev, blocks, blockSize, blocksToRead, _private);
             var ibgLog  = new IbgLog(_outputPrefix  + ".ibg", 0x0010);
-            ret = _outputPlugin.Create(_outputPath, dskType, _formatOptions, blocks, blockSize);
+            ret = outputFormat.Create(_outputPath, dskType, _formatOptions, blocks, blockSize);
 
             // Cannot create image
             if(!ret)
             {
                 _dumpLog.WriteLine("Error creating output image, not continuing.");
-                _dumpLog.WriteLine(_outputPlugin.ErrorMessage);
+                _dumpLog.WriteLine(outputFormat.ErrorMessage);
 
                 StoppingErrorMessage?.Invoke("Error creating output image, not continuing." + Environment.NewLine +
-                                             _outputPlugin.ErrorMessage);
+                                             outputFormat.ErrorMessage);
 
                 return;
             }
@@ -500,7 +501,7 @@ namespace Aaru.Core.Devices.Dumping
                extents    == null)
                 StoppingErrorMessage?.Invoke("Could not process resume file, not continuing...");
 
-            (_outputPlugin as IWritableOpticalImage).SetTracks(new List<Track>
+            (outputFormat as IWritableOpticalImage).SetTracks(new List<Track>
             {
                 new Track
                 {
@@ -611,7 +612,7 @@ namespace Aaru.Core.Devices.Dumping
                         mhddLog.Write(i, cmdDuration);
                         ibgLog.Write(i, currentSpeed * 1024);
                         DateTime writeStart = DateTime.Now;
-                        _outputPlugin.WriteSectors(readBuffer, i, blocksToRead);
+                        outputFormat.WriteSectors(readBuffer, i, blocksToRead);
                         imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
                         extents.Add(i, blocksToRead, true);
                     }
@@ -628,7 +629,7 @@ namespace Aaru.Core.Devices.Dumping
 
                         // Write empty data
                         DateTime writeStart = DateTime.Now;
-                        _outputPlugin.WriteSectors(new byte[blockSize * _skip], i, _skip);
+                        outputFormat.WriteSectors(new byte[blockSize * _skip], i, _skip);
                         imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
 
                         for(ulong b = i; b < i + _skip; b++)
@@ -689,7 +690,7 @@ namespace Aaru.Core.Devices.Dumping
 
                     // Write empty data
                     DateTime writeStart = DateTime.Now;
-                    _outputPlugin.WriteSectors(new byte[blockSize * blocksToRead], i, blocksToRead);
+                    outputFormat.WriteSectors(new byte[blockSize * blocksToRead], i, blocksToRead);
                     imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
                     blocksToRead       =  saveBlocksToRead;
                     extents.Add(i, blocksToRead, true);
@@ -733,7 +734,7 @@ namespace Aaru.Core.Devices.Dumping
 
                 // Write empty data
                 DateTime writeStart = DateTime.Now;
-                _outputPlugin.WriteSectors(new byte[blockSize * blocksToRead], middle + currentSector, blocksToRead);
+                outputFormat.WriteSectors(new byte[blockSize * blocksToRead], middle + currentSector, blocksToRead);
                 imageWriteDuration += (DateTime.Now                                   - writeStart).TotalSeconds;
                 extents.Add(currentSector, blocksToRead, true);
 
@@ -807,7 +808,7 @@ namespace Aaru.Core.Devices.Dumping
                     mhddLog.Write(currentSector, cmdDuration);
                     ibgLog.Write(currentSector, currentSpeed * 1024);
                     DateTime writeStart = DateTime.Now;
-                    _outputPlugin.WriteSectors(readBuffer, currentSector, blocksToRead);
+                    outputFormat.WriteSectors(readBuffer, currentSector, blocksToRead);
                     imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
                     extents.Add(currentSector, blocksToRead, true);
                 }
@@ -821,7 +822,7 @@ namespace Aaru.Core.Devices.Dumping
 
                     // Write empty data
                     DateTime writeStart = DateTime.Now;
-                    _outputPlugin.WriteSectors(new byte[blockSize * _skip], currentSector, _skip);
+                    outputFormat.WriteSectors(new byte[blockSize * _skip], currentSector, _skip);
                     imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
 
                     // TODO: Handle errors in video partition
@@ -943,7 +944,7 @@ namespace Aaru.Core.Devices.Dumping
 
                     _resume.BadBlocks.Remove(badSector);
                     extents.Add(badSector);
-                    _outputPlugin.WriteSector(readBuffer, badSector);
+                    outputFormat.WriteSector(readBuffer, badSector);
                 }
 
                 EndProgress?.Invoke();
@@ -1103,12 +1104,12 @@ namespace Aaru.Core.Devices.Dumping
                     {
                         _resume.BadBlocks.Remove(badSector);
                         extents.Add(badSector);
-                        _outputPlugin.WriteSector(readBuffer, badSector);
+                        outputFormat.WriteSector(readBuffer, badSector);
                         UpdateStatus?.Invoke($"Correctly retried block {badSector} in pass {pass}.");
                         _dumpLog.WriteLine("Correctly retried block {0} in pass {1}.", badSector, pass);
                     }
                     else if(runningPersistent)
-                        _outputPlugin.WriteSector(readBuffer, badSector);
+                        outputFormat.WriteSector(readBuffer, badSector);
                 }
 
                 if(pass < _retryPasses &&
@@ -1163,7 +1164,7 @@ namespace Aaru.Core.Devices.Dumping
                     continue;
                 }
 
-                ret = _outputPlugin.WriteMediaTag(tag.Value, tag.Key);
+                ret = outputFormat.WriteMediaTag(tag.Value, tag.Key);
 
                 if(ret || _force)
                     continue;
@@ -1172,7 +1173,7 @@ namespace Aaru.Core.Devices.Dumping
                 _dumpLog.WriteLine($"Cannot write tag {tag.Key}.");
 
                 StoppingErrorMessage?.Invoke($"Cannot write tag {tag.Key}." + Environment.NewLine +
-                                             _outputPlugin.ErrorMessage);
+                                             outputFormat.ErrorMessage);
 
                 return;
             }
@@ -1184,7 +1185,7 @@ namespace Aaru.Core.Devices.Dumping
 
             currentTry.Extents = ExtentsConverter.ToMetadata(extents);
 
-            _outputPlugin.SetDumpHardware(_resume.Tries);
+            outputFormat.SetDumpHardware(_resume.Tries);
 
             var metadata = new CommonTypes.Structs.ImageInfo
             {
@@ -1192,17 +1193,17 @@ namespace Aaru.Core.Devices.Dumping
                 ApplicationVersion = Version.GetVersion()
             };
 
-            if(!_outputPlugin.SetMetadata(metadata))
+            if(!outputFormat.SetMetadata(metadata))
                 ErrorMessage?.Invoke("Error {0} setting metadata, continuing..." + Environment.NewLine +
-                                     _outputPlugin.ErrorMessage);
+                                     outputFormat.ErrorMessage);
 
             if(_preSidecar != null)
-                _outputPlugin.SetCicmMetadata(_preSidecar);
+                outputFormat.SetCicmMetadata(_preSidecar);
 
             _dumpLog.WriteLine("Closing output file.");
             UpdateStatus?.Invoke("Closing output file.");
             DateTime closeStart = DateTime.Now;
-            _outputPlugin.Close();
+            outputFormat.Close();
             DateTime closeEnd = DateTime.Now;
             UpdateStatus?.Invoke($"Closed in {(closeEnd - closeStart).TotalSeconds} seconds.");
             _dumpLog.WriteLine("Closed in {0} seconds.", (closeEnd - closeStart).TotalSeconds);
diff --git a/Aaru.Core/Media/CompactDisc.cs b/Aaru.Core/Media/CompactDisc.cs
index 2547dc28e..8305fb504 100644
--- a/Aaru.Core/Media/CompactDisc.cs
+++ b/Aaru.Core/Media/CompactDisc.cs
@@ -69,7 +69,7 @@ namespace Aaru.Core.Media
                                                   byte[] sub, ulong sectorAddress, uint length, SubchannelLog subLog,
                                                   Dictionary<byte, string> isrcs, byte currentTrack, ref string mcn,
                                                   Track[] tracks, HashSet<int> subchannelExtents,
-                                                  bool fixSubchannelPosition, IWritableImage outputPlugin,
+                                                  bool fixSubchannelPosition, IWritableOpticalImage outputPlugin,
                                                   bool fixSubchannel, bool fixSubchannelCrc, DumpLog dumpLog,
                                                   UpdateStatusHandler updateStatus,
                                                   Dictionary<byte, int> smallestPregapLbaPerTrack, bool dumping)
diff --git a/Aaru.Gui/ViewModels/Windows/ImageConvertViewModel.cs b/Aaru.Gui/ViewModels/Windows/ImageConvertViewModel.cs
index 45aa72caa..058b3cd36 100644
--- a/Aaru.Gui/ViewModels/Windows/ImageConvertViewModel.cs
+++ b/Aaru.Gui/ViewModels/Windows/ImageConvertViewModel.cs
@@ -1173,7 +1173,7 @@ namespace Aaru.Gui.ViewModels.Windows
                                     bool indexesChanged = CompactDisc.WriteSubchannelToImage(MmcSubchannel.Raw,
                                         MmcSubchannel.Raw, sector, doneSectors, 1, null, isrcs,
                                         (byte)track.Sequence, ref mcn, tracks.ToArray(), subchannelExtents, false,
-                                        outputFormat, false, false, null, null, smallestPregapLbaPerTrack, false);
+                                        outputFormat as IWritableOpticalImage, false, false, null, null, smallestPregapLbaPerTrack, false);
 
                                     if(indexesChanged)
                                         outputOptical.SetTracks(tracks.ToList());
@@ -1224,7 +1224,7 @@ namespace Aaru.Gui.ViewModels.Windows
                                     bool indexesChanged = CompactDisc.WriteSubchannelToImage(MmcSubchannel.Raw,
                                         MmcSubchannel.Raw, sector, doneSectors, sectorsToDo, null, isrcs,
                                         (byte)track.Sequence, ref mcn, tracks.ToArray(), subchannelExtents, false,
-                                        outputFormat, false, false, null, null, smallestPregapLbaPerTrack, false);
+                                        outputFormat as IWritableOpticalImage, false, false, null, null, smallestPregapLbaPerTrack, false);
 
                                     if(indexesChanged)
                                         outputOptical.SetTracks(tracks.ToList());
diff --git a/Aaru.Images/Register.cs b/Aaru.Images/Register.cs
index 266805c29..efbc876a4 100644
--- a/Aaru.Images/Register.cs
+++ b/Aaru.Images/Register.cs
@@ -82,7 +82,7 @@ public sealed class Register : IPluginRegister
     /// <inheritdoc />
     public List<Type> GetAllWritableImagePlugins() => Assembly.GetExecutingAssembly().GetTypes().
                                                                Where(t => t.GetInterfaces().
-                                                                            Contains(typeof(IWritableImage))).
+                                                                            Contains(typeof(IBaseWritableImage))).
                                                                Where(t => t.IsClass).ToList();
 
     /// <inheritdoc />
diff --git a/Aaru/Commands/Formats.cs b/Aaru/Commands/Formats.cs
index 6f0716954..2c917c3c7 100644
--- a/Aaru/Commands/Formats.cs
+++ b/Aaru/Commands/Formats.cs
@@ -141,7 +141,7 @@ namespace Aaru.Commands
 
             table.AddColumn("Media image format");
 
-            foreach(KeyValuePair<string, IWritableImage> kvp in plugins.WritableImages)
+            foreach(KeyValuePair<string, IBaseWritableImage> kvp in plugins.WritableImages)
                 if(verbose)
                     table.AddRow(kvp.Value.Id.ToString(), Markup.Escape(kvp.Value.Name));
                 else
diff --git a/Aaru/Commands/Image/Convert.cs b/Aaru/Commands/Image/Convert.cs
index 21ca2ad9e..9ef25439b 100644
--- a/Aaru/Commands/Image/Convert.cs
+++ b/Aaru/Commands/Image/Convert.cs
@@ -559,7 +559,7 @@ internal sealed class ConvertImageCommand : Command
             return (int)ErrorNumber.CannotOpenFormat;
         }
 
-        List<IWritableImage> candidates = new();
+        List<IBaseWritableImage> candidates = new();
 
         // Try extension
         if(string.IsNullOrEmpty(format))
@@ -591,7 +591,7 @@ internal sealed class ConvertImageCommand : Command
             return (int)ErrorNumber.TooManyFormats;
         }
 
-        IWritableImage outputFormat = candidates[0];
+        IBaseWritableImage outputFormat = candidates[0];
 
         if(verbose)
             AaruConsole.VerboseWriteLine("Output image format: {0} ({1}).", outputFormat.Name, outputFormat.Id);
@@ -761,7 +761,7 @@ internal sealed class ConvertImageCommand : Command
                                 return;
                             }
 
-                            if(outputFormat.WriteMediaTag(tag, mediaTag))
+                            if((outputFormat as IWritableImage)?.WriteMediaTag(tag, mediaTag) == true)
                                 return;
 
                             if(force)
@@ -789,7 +789,7 @@ internal sealed class ConvertImageCommand : Command
         {
             if(!outputOptical.SetTracks(inputOptical.Tracks))
             {
-                AaruConsole.ErrorWriteLine("Error {0} sending tracks list to output image.", outputFormat.ErrorMessage);
+                AaruConsole.ErrorWriteLine("Error {0} sending tracks list to output image.", outputOptical.ErrorMessage);
 
                 return (int)ErrorNumber.WriteError;
             }
@@ -834,16 +834,16 @@ internal sealed class ConvertImageCommand : Command
                                     if(useLong)
                                     {
                                         errno = sectorsToDo == 1
-                                                    ? inputFormat.ReadSectorLong(doneSectors + track.StartSector,
+                                                    ? inputOptical.ReadSectorLong(doneSectors + track.StartSector,
                                                         out sector)
-                                                    : inputFormat.ReadSectorsLong(doneSectors + track.StartSector,
+                                                    : inputOptical.ReadSectorsLong(doneSectors + track.StartSector,
                                                         sectorsToDo, out sector);
 
                                         if(errno == ErrorNumber.NoError)
                                             result = sectorsToDo == 1
-                                                         ? outputFormat.WriteSectorLong(sector,
+                                                         ? outputOptical.WriteSectorLong(sector,
                                                              doneSectors + track.StartSector)
-                                                         : outputFormat.WriteSectorsLong(sector,
+                                                         : outputOptical.WriteSectorsLong(sector,
                                                              doneSectors + track.StartSector, sectorsToDo);
                                         else
                                         {
@@ -885,17 +885,17 @@ internal sealed class ConvertImageCommand : Command
                                     if(!useLong || useNotLong)
                                     {
                                         errno = sectorsToDo == 1
-                                                    ? inputFormat.ReadSector(doneSectors + track.StartSector,
+                                                    ? inputOptical.ReadSector(doneSectors + track.StartSector,
                                                                              out sector)
-                                                    : inputFormat.ReadSectors(doneSectors + track.StartSector,
-                                                                              sectorsToDo, out sector);
+                                                    : inputOptical.ReadSectors(doneSectors + track.StartSector,
+                                                                               sectorsToDo, out sector);
 
                                         if(errno == ErrorNumber.NoError)
                                         {
                                             result = sectorsToDo == 1
-                                                         ? outputFormat.WriteSector(sector,
+                                                         ? outputOptical.WriteSector(sector,
                                                              doneSectors + track.StartSector)
-                                                         : outputFormat.WriteSectors(sector,
+                                                         : outputOptical.WriteSectors(sector,
                                                              doneSectors + track.StartSector, sectorsToDo);
                                         }
                                         else
@@ -922,13 +922,13 @@ internal sealed class ConvertImageCommand : Command
                                     if(!result)
                                         if(force)
                                             AaruConsole.ErrorWriteLine("Error {0} writing sector {1}, continuing...",
-                                                                       outputFormat.ErrorMessage,
+                                                                       outputOptical.ErrorMessage,
                                                                        doneSectors + track.StartSector);
                                         else
                                         {
                                             AaruConsole.
                                                 ErrorWriteLine("Error {0} writing sector {1}, not continuing...",
-                                                               outputFormat.ErrorMessage,
+                                                               outputOptical.ErrorMessage,
                                                                doneSectors + track.StartSector);
 
                                             errno = ErrorNumber.WriteError;
@@ -976,12 +976,12 @@ internal sealed class ConvertImageCommand : Command
                     tracks[i].Indexes[idx.Key] = idx.Value;
             }
 
-            foreach(SectorTagType tag in inputFormat.Info.ReadableSectorTags.Where(t => t == SectorTagType.CdTrackIsrc).
+            foreach(SectorTagType tag in inputOptical.Info.ReadableSectorTags.Where(t => t == SectorTagType.CdTrackIsrc).
                                                      OrderBy(t => t))
             {
                 foreach(Track track in tracks)
                 {
-                    errno = inputFormat.ReadSectorTag(track.Sequence, tag, out byte[] isrc);
+                    errno = inputOptical.ReadSectorTag(track.Sequence, tag, out byte[] isrc);
 
                     if(errno != ErrorNumber.NoError)
                         continue;
@@ -990,12 +990,12 @@ internal sealed class ConvertImageCommand : Command
                 }
             }
 
-            foreach(SectorTagType tag in inputFormat.Info.ReadableSectorTags.
+            foreach(SectorTagType tag in inputOptical.Info.ReadableSectorTags.
                                                      Where(t => t == SectorTagType.CdTrackFlags).OrderBy(t => t))
             {
                 foreach(Track track in tracks)
                 {
-                    errno = inputFormat.ReadSectorTag(track.Sequence, tag, out byte[] flags);
+                    errno = inputOptical.ReadSectorTag(track.Sequence, tag, out byte[] flags);
 
                     if(errno != ErrorNumber.NoError)
                         continue;
@@ -1004,7 +1004,7 @@ internal sealed class ConvertImageCommand : Command
                 }
             }
 
-            for(ulong s = 0; s < inputFormat.Info.Sectors; s++)
+            for(ulong s = 0; s < inputOptical.Info.Sectors; s++)
             {
                 if(s > int.MaxValue)
                     break;
@@ -1012,7 +1012,7 @@ internal sealed class ConvertImageCommand : Command
                 subchannelExtents.Add((int)s);
             }
 
-            foreach(SectorTagType tag in inputFormat.Info.ReadableSectorTags.OrderBy(t => t).TakeWhile(tag => useLong))
+            foreach(SectorTagType tag in inputOptical.Info.ReadableSectorTags.OrderBy(t => t).TakeWhile(tag => useLong))
             {
                 switch(tag)
                 {
@@ -1028,7 +1028,7 @@ internal sealed class ConvertImageCommand : Command
                         continue;
                 }
 
-                if(force && !outputFormat.SupportedSectorTags.Contains(tag))
+                if(force && !outputOptical.SupportedSectorTags.Contains(tag))
                     continue;
 
                 errno = ErrorNumber.NoError;
@@ -1054,7 +1054,7 @@ internal sealed class ConvertImageCommand : Command
                                     {
                                         case SectorTagType.CdTrackFlags:
                                         case SectorTagType.CdTrackIsrc:
-                                            errno = inputFormat.ReadSectorTag(track.Sequence, tag, out sector);
+                                            errno = inputOptical.ReadSectorTag(track.Sequence, tag, out sector);
 
                                             if(errno == ErrorNumber.NoData)
                                             {
@@ -1064,19 +1064,19 @@ internal sealed class ConvertImageCommand : Command
                                             }
 
                                             if(errno == ErrorNumber.NoError)
-                                                result = outputFormat.WriteSectorTag(sector, track.Sequence, tag);
+                                                result = outputOptical.WriteSectorTag(sector, track.Sequence, tag);
                                             else
                                             {
                                                 if(force)
                                                 {
                                                     AaruConsole.ErrorWriteLine("Error {0} writing tag, continuing...",
-                                                                               outputFormat.ErrorMessage);
+                                                                               outputOptical.ErrorMessage);
 
                                                     continue;
                                                 }
 
                                                 AaruConsole.ErrorWriteLine("Error {0} writing tag, not continuing...",
-                                                                           outputFormat.ErrorMessage);
+                                                                           outputOptical.ErrorMessage);
 
                                                 errno = ErrorNumber.WriteError;
 
@@ -1086,12 +1086,12 @@ internal sealed class ConvertImageCommand : Command
                                             if(!result)
                                                 if(force)
                                                     AaruConsole.ErrorWriteLine("Error {0} writing tag, continuing...",
-                                                                               outputFormat.ErrorMessage);
+                                                                               outputOptical.ErrorMessage);
                                                 else
                                                 {
                                                     AaruConsole.
                                                         ErrorWriteLine("Error {0} writing tag, not continuing...",
-                                                                       outputFormat.ErrorMessage);
+                                                                       outputOptical.ErrorMessage);
 
                                                     errno = ErrorNumber.WriteError;
 
@@ -1121,7 +1121,7 @@ internal sealed class ConvertImageCommand : Command
 
                                         if(sectorsToDo == 1)
                                         {
-                                            errno = inputFormat.ReadSectorTag(doneSectors + track.StartSector, tag,
+                                            errno = inputOptical.ReadSectorTag(doneSectors + track.StartSector, tag,
                                                                               out sector);
 
                                             if(errno == ErrorNumber.NoError)
@@ -1133,7 +1133,7 @@ internal sealed class ConvertImageCommand : Command
                                                             MmcSubchannel.Raw, sector,
                                                             doneSectors + track.StartSector, 1, null, isrcs,
                                                             (byte)track.Sequence, ref mcn, tracks,
-                                                            subchannelExtents, fixSubchannelPosition, outputFormat,
+                                                            subchannelExtents, fixSubchannelPosition, outputOptical,
                                                             fixSubchannel, fixSubchannelCrc, null, null,
                                                             smallestPregapLbaPerTrack, false);
 
@@ -1144,7 +1144,7 @@ internal sealed class ConvertImageCommand : Command
                                                 }
                                                 else
                                                     result =
-                                                        outputFormat.WriteSectorTag(sector,
+                                                        outputOptical.WriteSectorTag(sector,
                                                             doneSectors + track.StartSector, tag);
                                             }
                                             else
@@ -1167,7 +1167,7 @@ internal sealed class ConvertImageCommand : Command
                                         }
                                         else
                                         {
-                                            errno = inputFormat.ReadSectorsTag(doneSectors + track.StartSector,
+                                            errno = inputOptical.ReadSectorsTag(doneSectors + track.StartSector,
                                                                                sectorsToDo, tag, out sector);
 
                                             if(errno == ErrorNumber.NoError)
@@ -1179,7 +1179,7 @@ internal sealed class ConvertImageCommand : Command
                                                             MmcSubchannel.Raw, sector,
                                                             doneSectors + track.StartSector, sectorsToDo, null,
                                                             isrcs, (byte)track.Sequence, ref mcn, tracks,
-                                                            subchannelExtents, fixSubchannelPosition, outputFormat,
+                                                            subchannelExtents, fixSubchannelPosition, outputOptical,
                                                             fixSubchannel, fixSubchannelCrc, null, null,
                                                             smallestPregapLbaPerTrack, false);
 
@@ -1190,7 +1190,7 @@ internal sealed class ConvertImageCommand : Command
                                                 }
                                                 else
                                                     result =
-                                                        outputFormat.WriteSectorsTag(sector,
+                                                        outputOptical.WriteSectorsTag(sector,
                                                             doneSectors + track.StartSector, sectorsToDo, tag);
                                             }
                                             else
@@ -1216,13 +1216,13 @@ internal sealed class ConvertImageCommand : Command
                                             if(force)
                                                 AaruConsole.
                                                     ErrorWriteLine("Error {0} writing tag for sector {1}, continuing...",
-                                                                   outputFormat.ErrorMessage,
+                                                                   outputOptical.ErrorMessage,
                                                                    doneSectors + track.StartSector);
                                             else
                                             {
                                                 AaruConsole.
                                                     ErrorWriteLine("Error {0} writing tag for sector {1}, not continuing...",
-                                                                   outputFormat.ErrorMessage,
+                                                                   outputOptical.ErrorMessage,
                                                                    doneSectors + track.StartSector);
 
                                                 errno = ErrorNumber.WriteError;
@@ -1260,40 +1260,42 @@ internal sealed class ConvertImageCommand : Command
                 outputOptical.WriteMediaTag(Encoding.UTF8.GetBytes(mcn), MediaTagType.CD_MCN);
 
             // TODO: Progress
-            if((inputFormat.Info.MediaType == MediaType.CD || inputFormat.Info.MediaType == MediaType.CDDA ||
-                inputFormat.Info.MediaType == MediaType.CDG || inputFormat.Info.MediaType == MediaType.CDEG ||
-                inputFormat.Info.MediaType == MediaType.CDI || inputFormat.Info.MediaType == MediaType.CDROM ||
-                inputFormat.Info.MediaType == MediaType.CDROMXA || inputFormat.Info.MediaType == MediaType.CDPLUS ||
-                inputFormat.Info.MediaType == MediaType.CDMO || inputFormat.Info.MediaType == MediaType.CDR ||
-                inputFormat.Info.MediaType == MediaType.CDRW || inputFormat.Info.MediaType == MediaType.CDMRW ||
-                inputFormat.Info.MediaType == MediaType.VCD || inputFormat.Info.MediaType == MediaType.SVCD ||
-                inputFormat.Info.MediaType == MediaType.PCD || inputFormat.Info.MediaType == MediaType.DTSCD ||
-                inputFormat.Info.MediaType == MediaType.CDMIDI || inputFormat.Info.MediaType == MediaType.CDV ||
-                inputFormat.Info.MediaType == MediaType.CDIREADY || inputFormat.Info.MediaType == MediaType.FMTOWNS ||
-                inputFormat.Info.MediaType == MediaType.PS1CD || inputFormat.Info.MediaType == MediaType.PS2CD ||
-                inputFormat.Info.MediaType == MediaType.MEGACD || inputFormat.Info.MediaType == MediaType.SATURNCD ||
-                inputFormat.Info.MediaType == MediaType.GDROM || inputFormat.Info.MediaType == MediaType.GDR ||
-                inputFormat.Info.MediaType == MediaType.MilCD || inputFormat.Info.MediaType == MediaType.SuperCDROM2 ||
-                inputFormat.Info.MediaType == MediaType.JaguarCD || inputFormat.Info.MediaType == MediaType.ThreeDO ||
-                inputFormat.Info.MediaType == MediaType.PCFX || inputFormat.Info.MediaType == MediaType.NeoGeoCD ||
-                inputFormat.Info.MediaType == MediaType.CDTV || inputFormat.Info.MediaType == MediaType.CD32 ||
-                inputFormat.Info.MediaType == MediaType.Playdia || inputFormat.Info.MediaType == MediaType.Pippin ||
-                inputFormat.Info.MediaType == MediaType.VideoNow ||
-                inputFormat.Info.MediaType == MediaType.VideoNowColor ||
-                inputFormat.Info.MediaType == MediaType.VideoNowXp || inputFormat.Info.MediaType == MediaType.CVD) &&
+            if((inputOptical.Info.MediaType == MediaType.CD || inputOptical.Info.MediaType == MediaType.CDDA ||
+                inputOptical.Info.MediaType == MediaType.CDG || inputOptical.Info.MediaType == MediaType.CDEG ||
+                inputOptical.Info.MediaType == MediaType.CDI || inputOptical.Info.MediaType == MediaType.CDROM ||
+                inputOptical.Info.MediaType == MediaType.CDROMXA || inputOptical.Info.MediaType == MediaType.CDPLUS ||
+                inputOptical.Info.MediaType == MediaType.CDMO || inputOptical.Info.MediaType == MediaType.CDR ||
+                inputOptical.Info.MediaType == MediaType.CDRW || inputOptical.Info.MediaType == MediaType.CDMRW ||
+                inputOptical.Info.MediaType == MediaType.VCD || inputOptical.Info.MediaType == MediaType.SVCD ||
+                inputOptical.Info.MediaType == MediaType.PCD || inputOptical.Info.MediaType == MediaType.DTSCD ||
+                inputOptical.Info.MediaType == MediaType.CDMIDI || inputOptical.Info.MediaType == MediaType.CDV ||
+                inputOptical.Info.MediaType == MediaType.CDIREADY || inputOptical.Info.MediaType == MediaType.FMTOWNS ||
+                inputOptical.Info.MediaType == MediaType.PS1CD || inputOptical.Info.MediaType == MediaType.PS2CD ||
+                inputOptical.Info.MediaType == MediaType.MEGACD || inputOptical.Info.MediaType == MediaType.SATURNCD ||
+                inputOptical.Info.MediaType == MediaType.GDROM || inputOptical.Info.MediaType == MediaType.GDR ||
+                inputOptical.Info.MediaType == MediaType.MilCD || inputOptical.Info.MediaType == MediaType.SuperCDROM2 ||
+                inputOptical.Info.MediaType == MediaType.JaguarCD || inputOptical.Info.MediaType == MediaType.ThreeDO ||
+                inputOptical.Info.MediaType == MediaType.PCFX || inputOptical.Info.MediaType == MediaType.NeoGeoCD ||
+                inputOptical.Info.MediaType == MediaType.CDTV || inputOptical.Info.MediaType == MediaType.CD32 ||
+                inputOptical.Info.MediaType == MediaType.Playdia || inputOptical.Info.MediaType == MediaType.Pippin ||
+                inputOptical.Info.MediaType == MediaType.VideoNow ||
+                inputOptical.Info.MediaType == MediaType.VideoNowColor ||
+                inputOptical.Info.MediaType == MediaType.VideoNowXp || inputOptical.Info.MediaType == MediaType.CVD) &&
                generateSubchannels)
             {
                 Core.Spectre.ProgressSingleSpinner(ctx =>
                 {
                     ctx.AddTask("Generating subchannels...").IsIndeterminate();
 
-                    CompactDisc.GenerateSubchannels(subchannelExtents, tracks, trackFlags, inputFormat.Info.Sectors,
-                                                    null, null, null, null, null, outputFormat);
+                    CompactDisc.GenerateSubchannels(subchannelExtents, tracks, trackFlags, inputOptical.Info.Sectors,
+                                                    null, null, null, null, null, outputOptical);
                 });
             }
         }
         else
         {
+            var outputMedia = outputFormat as IWritableImage;
+
             if(inputTape  == null ||
                outputTape == null ||
                !inputTape.IsTape)
@@ -1306,9 +1308,9 @@ internal sealed class ConvertImageCommand : Command
                 AaruConsole.WriteLine("Setting geometry to {0} cylinders, {1} heads and {2} sectors per track",
                                       chs.cylinders, chs.heads, chs.sectors);
 
-                if(!outputFormat.SetGeometry(chs.cylinders, chs.heads, chs.sectors))
+                if(!outputMedia.SetGeometry(chs.cylinders, chs.heads, chs.sectors))
                     AaruConsole.ErrorWriteLine("Error {0} setting geometry, image may be incorrect, continuing...",
-                                               outputFormat.ErrorMessage);
+                                               outputMedia.ErrorMessage);
             }
 
             ErrorNumber errno = ErrorNumber.NoError;
@@ -1344,8 +1346,8 @@ internal sealed class ConvertImageCommand : Command
                                                 : inputFormat.ReadSectorsLong(doneSectors, sectorsToDo, out sector);
 
                                     if(errno == ErrorNumber.NoError)
-                                        result = sectorsToDo == 1 ? outputFormat.WriteSectorLong(sector, doneSectors)
-                                                     : outputFormat.WriteSectorsLong(sector, doneSectors, sectorsToDo);
+                                        result = sectorsToDo == 1 ? outputMedia.WriteSectorLong(sector, doneSectors)
+                                                     : outputMedia.WriteSectorsLong(sector, doneSectors, sectorsToDo);
                                     else
                                     {
                                         result = true;
@@ -1369,8 +1371,8 @@ internal sealed class ConvertImageCommand : Command
                                                 : inputFormat.ReadSectors(doneSectors, sectorsToDo, out sector);
 
                                     if(errno == ErrorNumber.NoError)
-                                        result = sectorsToDo == 1 ? outputFormat.WriteSector(sector, doneSectors)
-                                                     : outputFormat.WriteSectors(sector, doneSectors, sectorsToDo);
+                                        result = sectorsToDo == 1 ? outputMedia.WriteSector(sector, doneSectors)
+                                                     : outputMedia.WriteSectors(sector, doneSectors, sectorsToDo);
                                     else
                                     {
                                         result = true;
@@ -1392,11 +1394,11 @@ internal sealed class ConvertImageCommand : Command
                                 if(!result)
                                     if(force)
                                         AaruConsole.ErrorWriteLine("Error {0} writing sector {1}, continuing...",
-                                                                   outputFormat.ErrorMessage, doneSectors);
+                                                                   outputMedia.ErrorMessage, doneSectors);
                                     else
                                     {
                                         AaruConsole.ErrorWriteLine("Error {0} writing sector {1}, not continuing...",
-                                                                   outputFormat.ErrorMessage, doneSectors);
+                                                                   outputMedia.ErrorMessage, doneSectors);
 
                                         errno = ErrorNumber.WriteError;
 
@@ -1425,7 +1427,7 @@ internal sealed class ConvertImageCommand : Command
                                         continue;
                                 }
 
-                                if(force && !outputFormat.SupportedSectorTags.Contains(tag))
+                                if(force && !outputMedia.SupportedSectorTags.Contains(tag))
                                     continue;
 
                                 doneSectors = 0;
@@ -1455,8 +1457,8 @@ internal sealed class ConvertImageCommand : Command
 
                                     if(errno == ErrorNumber.NoError)
                                         result = sectorsToDo == 1
-                                                     ? outputFormat.WriteSectorTag(sector, doneSectors, tag)
-                                                     : outputFormat.WriteSectorsTag(sector, doneSectors, sectorsToDo,
+                                                     ? outputMedia.WriteSectorTag(sector, doneSectors, tag)
+                                                     : outputMedia.WriteSectorsTag(sector, doneSectors, sectorsToDo,
                                                          tag);
                                     else
                                     {
@@ -1478,12 +1480,12 @@ internal sealed class ConvertImageCommand : Command
                                     if(!result)
                                         if(force)
                                             AaruConsole.ErrorWriteLine("Error {0} writing sector {1}, continuing...",
-                                                                       outputFormat.ErrorMessage, doneSectors);
+                                                                       outputMedia.ErrorMessage, doneSectors);
                                         else
                                         {
                                             AaruConsole.
                                                 ErrorWriteLine("Error {0} writing sector {1}, not continuing...",
-                                                               outputFormat.ErrorMessage, doneSectors);
+                                                               outputMedia.ErrorMessage, doneSectors);
 
                                             errno = ErrorNumber.WriteError;
 
diff --git a/Aaru/Commands/Image/Options.cs b/Aaru/Commands/Image/Options.cs
index 2435f3d42..26b606abf 100644
--- a/Aaru/Commands/Image/Options.cs
+++ b/Aaru/Commands/Image/Options.cs
@@ -87,7 +87,7 @@ namespace Aaru.Commands.Image
 
             AaruConsole.WriteLine("Read/Write media images options:");
 
-            foreach(KeyValuePair<string, IWritableImage> kvp in plugins.WritableImages)
+            foreach(KeyValuePair<string, IBaseWritableImage> kvp in plugins.WritableImages)
             {
                 List<(string name, Type type, string description, object @default)> options =
                     kvp.Value.SupportedOptions.ToList();
diff --git a/Aaru/Commands/Media/Dump.cs b/Aaru/Commands/Media/Dump.cs
index 123e78af9..8a9dd91c5 100644
--- a/Aaru/Commands/Media/Dump.cs
+++ b/Aaru/Commands/Media/Dump.cs
@@ -467,9 +467,9 @@ namespace Aaru.Commands.Media
             if(isResponse)
                 eject = true;
 
-            PluginBase           plugins    = GetPluginBase.Instance;
-            List<IWritableImage> candidates = new();
-            string               extension  = Path.GetExtension(outputPath);
+            PluginBase               plugins    = GetPluginBase.Instance;
+            List<IBaseWritableImage> candidates = new();
+            string                   extension  = Path.GetExtension(outputPath);
 
             // Try extension
             if(string.IsNullOrEmpty(format))
@@ -642,7 +642,7 @@ namespace Aaru.Commands.Media
                     }
 
                 plugins    = GetPluginBase.Instance;
-                candidates = new List<IWritableImage>();
+                candidates = new List<IBaseWritableImage>();
 
                 // Try extension
                 if(string.IsNullOrEmpty(format))
@@ -661,7 +661,7 @@ namespace Aaru.Commands.Media
                                                                                 StringComparison.
                                                                                     InvariantCultureIgnoreCase)));
 
-                IWritableImage outputFormat = candidates[0];
+                IBaseWritableImage outputFormat = candidates[0];
 
                 var dumpLog = new DumpLog(outputPrefix + ".log", dev, @private);