Fix and expand the layout support to allow libdsk altback layouts.

lib/algorithms/readerwriter.cc

@@ -347,7 +347,7 @@ ReadResult readGroup(FluxSourceIteratorHolder& fluxSourceIteratorHolder,
     ReadResult result = BAD_AND_CAN_NOT_RETRY;
 
     for (unsigned offset = 0; offset < trackInfo->groupSize;
-         offset += Layout::getHeadWidth())
+        offset += Layout::getHeadWidth())
     {
         log(BeginReadOperationLogMessage{
             trackInfo->physicalTrack + offset, trackInfo->physicalSide});
@@ -404,7 +404,7 @@ void writeTracks(FluxSink& fluxSink,
         for (;;)
         {
             for (int offset = 0; offset < trackInfo->groupSize;
-                 offset += Layout::getHeadWidth())
+                offset += Layout::getHeadWidth())
             {
                 unsigned physicalTrack = trackInfo->physicalTrack + offset;
 
@@ -734,7 +734,7 @@ void readDiskCommand(
     if (globalConfig()->decoder().has_write_csv_to())
         writer.writeCsv(
             *diskflux->image, globalConfig()->decoder().write_csv_to());
-    writer.writeMappedImage(*diskflux->image);
+    writer.writeImage(*diskflux->image);
 }
 
 void rawReadDiskCommand(FluxSource& fluxsource, FluxSink& fluxsink)

lib/config/flags.h

@@ -46,7 +46,7 @@ class Flag
 {
 public:
     Flag(const std::vector<std::string>& names, const std::string helptext);
-    virtual ~Flag(){};
+    virtual ~Flag() {};
 
     void checkInitialised() const
     {

lib/config/layout.proto

@@ -22,8 +22,9 @@ message LayoutProto
     enum Order
     {
         UNDEFINED = 0;
-        CHS = 1;
-        HCS = 2;
+        CHS = 1; // sort by cylinder, then head, then sector -- libdsk 'alt'
+        HCS = 2; // sort by head, then cylinder, then sector -- libdsk 'outout'
+        HCS_RH1 = 3; // as HCS, except the cylinder count for head 1 is reversed -- libdsk 'outback'
     }
 
     message LayoutdataProto
@@ -54,10 +55,12 @@ message LayoutProto
         [ default = 0, (help) = "number of tracks in image" ];
     optional int32 sides = 3
         [ default = 0, (help) = "number of sides in image" ];
-    optional Order order = 4
+    optional Order filesystem_track_order = 4
         [ default = CHS, (help) = "the order of sectors in the filesystem" ];
-    optional bool swap_sides = 5
+    optional Order image_track_order = 5
+        [ default = CHS, (help) = "the order of sectors in disk images" ];
+    optional bool swap_sides = 6
         [ default = false, (help) = "the sides are inverted on this disk" ];
-    optional FormatType format_type = 6
+    optional FormatType format_type = 7
         [ default = FORMATTYPE_UNKNOWN, (help) = "Format type of image" ];
 }

lib/data/image.cc

@@ -2,6 +2,7 @@
 #include "lib/data/sector.h"
 #include "lib/data/image.h"
 #include "lib/data/layout.h"
+#include "lib/config/config.h"
 
 Image::Image() {}
 
@@ -25,7 +26,8 @@ void Image::clear()
 void Image::createBlankImage()
 {
     clear();
-    for (const auto& trackAndHead : Layout::getTrackOrdering())
+    for (const auto& trackAndHead : Layout::getTrackOrdering(
+             globalConfig()->layout().filesystem_track_order()))
     {
         unsigned track = trackAndHead.first;
         unsigned side = trackAndHead.second;

lib/data/layout.cc

@@ -108,21 +108,21 @@ void Layout::getBounds(
 }
 
 std::vector<std::pair<int, int>> Layout::getTrackOrdering(
-    unsigned guessedTracks, unsigned guessedSides)
+    LayoutProto::Order ordering, unsigned guessedTracks, unsigned guessedSides)
 {
     auto layout = globalConfig()->layout();
     int tracks = layout.has_tracks() ? layout.tracks() : guessedTracks;
     int sides = layout.has_sides() ? layout.sides() : guessedSides;
 
-    std::vector<std::pair<int, int>> ordering;
-    switch (layout.order())
+    std::vector<std::pair<int, int>> trackList;
+    switch (ordering)
     {
         case LayoutProto::CHS:
         {
             for (int track = 0; track < tracks; track++)
             {
                 for (int side = 0; side < sides; side++)
-                    ordering.push_back(std::make_pair(track, side));
+                    trackList.push_back(std::make_pair(track, side));
             }
             break;
         }
@@ -132,16 +132,30 @@ std::vector<std::pair<int, int>> Layout::getTrackOrdering(
             for (int side = 0; side < sides; side++)
             {
                 for (int track = 0; track < tracks; track++)
-                    ordering.push_back(std::make_pair(track, side));
+                    trackList.push_back(std::make_pair(track, side));
+            }
+            break;
+        }
+
+        case LayoutProto::HCS_RH1:
+        {
+            for (int side = 0; side < sides; side++)
+            {
+                if (side == 0)
+                    for (int track = 0; track < tracks; track++)
+                        trackList.push_back(std::make_pair(track, side));
+                if (side == 1)
+                    for (int track = tracks; track >= 0; track--)
+                        trackList.push_back(std::make_pair(track - 1, side));
             }
             break;
         }
 
         default:
-            error("LAYOUT: invalid track ordering");
+            error("LAYOUT: invalid track trackList");
     }
 
-    return ordering;
+    return trackList;
 }
 
 std::vector<unsigned> Layout::expandSectorList(

lib/data/layout.h

@@ -2,6 +2,7 @@
 #define LAYOUT_H
 
 #include "lib/data/flux.h"
+#include "lib/config/layout.pb.h"
 
 class SectorListProto;
 class TrackInfo;
@@ -39,7 +40,9 @@ class Layout
     /* Returns a series of <track, side> pairs representing the filesystem
      * ordering of the disk, in logical numbers. */
     static std::vector<std::pair<int, int>> getTrackOrdering(
-        unsigned guessedTracks = 0, unsigned guessedSides = 0);
+        LayoutProto::Order ordering,
+        unsigned guessedTracks = 0,
+        unsigned guessedSides = 0);
 
     /* Returns the layout of a given track. */
     static std::shared_ptr<const TrackInfo> getLayoutOfTrack(

lib/decoders/decoders.h

@@ -98,10 +98,10 @@ class Decoder
     }
 
 protected:
-    virtual void beginTrack(){};
+    virtual void beginTrack() {};
     virtual nanoseconds_t advanceToNextRecord() = 0;
     virtual void decodeSectorRecord() = 0;
-    virtual void decodeDataRecord(){};
+    virtual void decodeDataRecord() {};
 
     const DecoderProto& _config;
     std::shared_ptr<TrackDataFlux> _trackdata;

lib/imagereader/d88imagereader.cc

@@ -93,7 +93,7 @@ class D88ImageReader : public ImageReader
             auto physical = layoutdata->mutable_physical();
 
             for (int sectorInTrack = 0; sectorInTrack < currentSectorsInTrack;
-                 sectorInTrack++)
+                sectorInTrack++)
             {
                 Bytes sectorHeader(0x10);
                 inputFile.read(

lib/imagereader/imagereader.cc

@@ -63,26 +63,3 @@ std::unique_ptr<ImageReader> ImageReader::create(const ImageReaderProto& config)
 }
 
 ImageReader::ImageReader(const ImageReaderProto& config): _config(config) {}
-
-std::unique_ptr<Image> ImageReader::readMappedImage()
-{
-    auto rawImage = readImage();
-
-    if (!_config.filesystem_sector_order())
-        return rawImage;
-
-    log("READER: converting from filesystem sector order to disk order");
-    std::set<std::shared_ptr<const Sector>> sectors;
-    for (const auto& e : *rawImage)
-    {
-        auto trackLayout =
-            Layout::getLayoutOfTrack(e->logicalTrack, e->logicalSide);
-        auto newSector = std::make_shared<Sector>();
-        *newSector = *e;
-        newSector->logicalSector =
-            trackLayout->filesystemToNaturalSectorMap.at(e->logicalSector);
-        sectors.insert(newSector);
-    }
-
-    return std::make_unique<Image>(sectors);
-}

lib/imagereader/imagereader.h

@@ -13,7 +13,7 @@ class ImageReader
 {
 public:
     ImageReader(const ImageReaderProto& config);
-    virtual ~ImageReader(){};
+    virtual ~ImageReader() {};
 
 public:
     static std::unique_ptr<ImageReader> create(Config& config);
@@ -51,15 +51,10 @@ class ImageReader
         return _extraConfig;
     }
 
-    /* Directly reads the image. */
+    /* Reads the image. */
 
     virtual std::unique_ptr<Image> readImage() = 0;
 
-    /* Reads the image, and then applies any optional mapping to go from
-     * filesystem ordering to disk ordering. */
-
-    std::unique_ptr<Image> readMappedImage();
-
 protected:
     const ImageReaderProto& _config;
     ConfigProto _extraConfig;

lib/imagereader/imagereader.proto

@@ -2,7 +2,12 @@ syntax = "proto2";
 
 import "lib/config/common.proto";
 
-message ImgInputOutputProto {}
+message ImgInputOutputProto {
+    optional bool filesystem_sector_order = 1 [
+        (help) = "read/write sector image in filesystem order",
+        default = false
+    ];
+}
 
 message DiskCopyInputProto {}
 message ImdInputProto {}
@@ -15,16 +20,12 @@ message FdiInputProto {}
 message D88InputProto {}
 message NfdInputProto {}
 
-// NEXT_TAG: 15
+// NEXT_TAG: 14
 message ImageReaderProto
 {
     optional string filename = 1 [ (help) = "filename of input sector image" ];
-    optional bool filesystem_sector_order = 13 [
-        (help) = "read/write sector image in filesystem order",
-        default = false
-    ];
 
-	optional ImageReaderWriterType type = 14
+	optional ImageReaderWriterType type = 13
 		[default = IMAGETYPE_NOT_SET, (help) = "input image type"];
 
 	optional ImgInputOutputProto img = 2;

lib/imagereader/imdimagereader.cc

@@ -301,7 +301,7 @@ class IMDImageReader : public ImageReader
 
                 switch (Status_Sector)
                 {
-                    // clang-format off
+                        // clang-format off
                     /* fluxengine knows of a few sector statussen but not all of the statussen in IMD.
                      *  // the statussen are in sector.h. Translation to fluxengine is as follows:
                      *	Statussen fluxengine							|	Status IMD		

lib/imagereader/imgimagereader.cc

@@ -31,8 +31,11 @@ class ImgImageReader : public ImageReader
                 "IMG: bad configuration; did you remember to set the "
                 "tracks, sides and trackdata fields in the layout?");
 
+        bool in_filesystem_order = _config.img().filesystem_sector_order();
         std::unique_ptr<Image> image(new Image);
-        for (const auto& p : Layout::getTrackOrdering())
+        for (const auto& p : Layout::getTrackOrdering(
+                 in_filesystem_order ? layout.filesystem_track_order()
+                                     : layout.image_track_order()))
         {
             int track = p.first;
             int side = p.second;
@@ -46,6 +49,9 @@ class ImgImageReader : public ImageReader
                 Bytes data(trackLayout->sectorSize);
                 inputFile.read((char*)data.begin(), data.size());
 
+                if (in_filesystem_order)
+                    sectorId =
+                        trackLayout->filesystemToNaturalSectorMap.at(sectorId);
                 const auto& sector = image->put(track, side, sectorId);
                 sector->status = Sector::OK;
                 sector->data = data;

lib/imagewriter/d88imagewriter.cc

@@ -65,15 +65,15 @@ class D88ImageWriter : public ImageWriter
         uint32_t trackOffset = 688;
 
         for (int track = 0; track < geometry.numTracks * geometry.numSides;
-             track++)
+            track++)
         {
             headerWriter.seek(0x20 + 4 * track);
             headerWriter.write_le32(trackOffset);
             int side = track & 1;
             std::vector<std::shared_ptr<const Sector>> sectors;
             for (int sectorId = geometry.firstSector;
-                 sectorId <= geometry.numSectors;
-                 sectorId++)
+                sectorId <= geometry.numSectors;
+                sectorId++)
             {
                 const auto& sector = image.get(track >> 1, side, sectorId);
                 if (sector)

lib/imagewriter/imagewriter.cc

@@ -173,27 +173,3 @@ void ImageWriter::printMap(const Image& image)
                   << std::endl;
     }
 }
-
-void ImageWriter::writeMappedImage(const Image& image)
-{
-    if (_config.filesystem_sector_order())
-    {
-        log("WRITER: converting from disk sector order to filesystem order");
-
-        std::set<std::shared_ptr<const Sector>> sectors;
-        for (const auto& e : image)
-        {
-            auto trackLayout =
-                Layout::getLayoutOfTrack(e->logicalTrack, e->logicalSide);
-            auto newSector = std::make_shared<Sector>();
-            *newSector = *e;
-            newSector->logicalSector =
-                trackLayout->naturalToFilesystemSectorMap.at(e->logicalSector);
-            sectors.insert(newSector);
-        }
-
-        writeImage(Image(sectors));
-    }
-    else
-        writeImage(image);
-}

lib/imagewriter/imagewriter.h

@@ -9,7 +9,7 @@ class ImageWriter
 {
 public:
     ImageWriter(const ImageWriterProto& config);
-    virtual ~ImageWriter(){};
+    virtual ~ImageWriter() {};
 
 public:
     static std::unique_ptr<ImageWriter> create(Config& config);
@@ -37,11 +37,8 @@ class ImageWriter
     void writeCsv(const Image& sectors, const std::string& filename);
 
     /* Writes a raw image. */
-    virtual void writeImage(const Image& sectors) = 0;
 
-    /* Writes an image applying any optional mapping from disk sector numbering
-     * to filesystem sector numbering. */
-    void writeMappedImage(const Image& sectors);
+    virtual void writeImage(const Image& sectors) = 0;
 
 protected:
     const ImageWriterProto& _config;

lib/imagewriter/imagewriter.proto

@@ -67,12 +67,8 @@ message ImdOutputProto
 message ImageWriterProto
 {
     optional string filename = 1 [ (help) = "filename of output sector image" ];
-    optional bool filesystem_sector_order = 10 [
-        (help) = "read/write sector image in filesystem order",
-        default = false
-    ];
 
-    optional ImageReaderWriterType type = 11
+    optional ImageReaderWriterType type = 10
         [ default = IMAGETYPE_NOT_SET, (help) = "image writer type" ];
 
     optional ImgInputOutputProto img = 2;