Merge from master.

Author: davidgiven

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;