Merge pull request #348 from tdaede/dim

Add DIM format reader.

doc/using.md

@@ -256,6 +256,11 @@ FluxEngine also supports a number of file system image formats. When using the
 
 	Read from a JV3 image file, commonly used by TRS-80 emulators. **Read
 	only.**
+
+  - `<filename.dim>`
+
+  Read from a [DIM image file](https://www.pc98.org/project/doc/dim.html),
+  commonly used by X68000 emulators. **Read Only.**
   
   - `<filename.ldbs>`
 

lib/imagereader/dimimagereader.cc

@@ -0,0 +1,114 @@
+#include "globals.h"
+#include "flags.h"
+#include "sector.h"
+#include "imagereader/imagereader.h"
+#include "image.h"
+#include "lib/config.pb.h"
+#include "imagereader/imagereaderimpl.h"
+#include "fmt/format.h"
+#include <algorithm>
+#include <iostream>
+#include <fstream>
+
+// reader based on this partial documentation of the DIM format:
+// https://www.pc98.org/project/doc/dim.html
+
+class DimImageReader : public ImageReader
+{
+public:
+	DimImageReader(const ImageReaderProto& config):
+		ImageReader(config)
+	{}
+
+	Image readImage()
+	{
+        std::ifstream inputFile(_config.filename(), std::ios::in | std::ios::binary);
+        if (!inputFile.is_open())
+            Error() << "cannot open input file";
+
+        Bytes header(256);
+        inputFile.read((char*) header.begin(), header.size());
+        if (header.slice(0xAB, 13) != Bytes("DIFC HEADER  "))
+            Error() << "DIM: could not find DIM header, is this a DIM file?";
+
+        // the DIM header technically has a bit field for sectors present,
+        // however it is currently ignored by this reader
+
+        char mediaByte = header[0];
+        int tracks;
+        int sectorsPerTrack;
+        int sectorSize;
+        switch (mediaByte) {
+            case 0:
+                tracks = 77;
+                sectorsPerTrack = 8;
+                sectorSize = 1024;
+                break;
+            case 1:
+                tracks = 80;
+                sectorsPerTrack = 9;
+                sectorSize = 1024;
+                break;
+            case 2:
+                tracks = 80;
+                sectorsPerTrack = 15;
+                sectorSize = 512;
+                break;
+            case 3:
+                tracks = 80;
+                sectorsPerTrack = 18;
+                sectorSize = 512;
+                break;
+            default:
+                Error() << "DIM: unsupported media byte";
+                break;
+        }
+
+        Image image;
+		int trackCount = 0;
+        for (int track = 0; track < tracks; track++)
+        {
+			if (inputFile.eof())
+				break;
+			int physicalCylinder = track;
+
+            for (int side = 0; side < 2; side++)
+            {
+                std::vector<unsigned> sectors;
+                for (int i = 0; i < sectorsPerTrack; i++)
+                    sectors.push_back(i + 1);
+
+                for (int sectorId : sectors)
+                {
+                    Bytes data(sectorSize);
+                    inputFile.read((char*) data.begin(), data.size());
+
+					const auto& sector = image.put(physicalCylinder, side, sectorId);
+                    sector->status = Sector::OK;
+                    sector->logicalTrack = track;
+					sector->physicalCylinder = physicalCylinder;
+                    sector->logicalSide = sector->physicalHead = side;
+                    sector->logicalSector = sectorId;
+                    sector->data = data;
+                }
+            }
+
+			trackCount++;
+        }
+
+		image.calculateSize();
+		const Geometry& geometry = image.getGeometry();
+        std::cout << fmt::format("DIM: read {} tracks, {} sides, {} kB total\n",
+                        geometry.numTracks, geometry.numSides,
+						inputFile.tellg() / 1024);
+        return image;
+	}
+
+};
+
+std::unique_ptr<ImageReader> ImageReader::createDimImageReader(
+	const ImageReaderProto& config)
+{
+    return std::unique_ptr<ImageReader>(new DimImageReader(config));
+}
+

lib/imagereader/imagereader.cc

@@ -14,6 +14,9 @@ std::unique_ptr<ImageReader> ImageReader::create(const ImageReaderProto& config)
 {
 	switch (config.format_case())
 	{
+		case ImageReaderProto::kDim:
+			return ImageReader::createDimImageReader(config);
+
 		case ImageReaderProto::kImd:
 			return ImageReader::createIMDImageReader(config);
 
@@ -49,6 +52,7 @@ void ImageReader::updateConfigForFilename(ImageReaderProto* proto, const std::st
 		{".jv3",      [&]() { proto->mutable_jv3(); }},
 		{".d64",      [&]() { proto->mutable_d64(); }},
 		{".d81",      [&]() { proto->mutable_img(); }},
+		{".dim",      [&]() { proto->mutable_dim(); }},
 		{".diskcopy", [&]() { proto->mutable_diskcopy(); }},
 		{".img",      [&]() { proto->mutable_img(); }},
 		{".st",       [&]() { proto->mutable_img(); }},

lib/imagereader/imagereader.h

@@ -23,6 +23,7 @@ public:
     static std::unique_ptr<ImageReader> createIMDImageReader(const ImageReaderProto& config);
     static std::unique_ptr<ImageReader> createNsiImageReader(const ImageReaderProto& config);
     static std::unique_ptr<ImageReader> createTd0ImageReader(const ImageReaderProto& config);
+    static std::unique_ptr<ImageReader> createDimImageReader(const ImageReaderProto& config);
 
 public:
 	virtual Image readImage() = 0;

lib/imagereader/imagereader.proto

@@ -38,6 +38,7 @@ message Jv3InputProto {}
 message D64InputProto {}
 message NsiInputProto {}
 message Td0InputProto {}
+message DimInputProto {}
 
 message ImageReaderProto {
 	optional string filename = 1 [(help) = "filename of input sector image"];
@@ -49,6 +50,7 @@ message ImageReaderProto {
 		D64InputProto d64 = 6;
 		NsiInputProto nsi = 7;
 		Td0InputProto td0 = 8;
+		DimInputProto dim = 9;
 	}
 }
 

mkninja.sh

@@ -372,6 +372,7 @@ buildlibrary libbackend.a \
     lib/imagereader/jv3imagereader.cc \
     lib/imagereader/nsiimagereader.cc \
     lib/imagereader/td0imagereader.cc \
+    lib/imagereader/dimimagereader.cc \
     lib/imagewriter/d64imagewriter.cc \
     lib/imagewriter/diskcopyimagewriter.cc \
     lib/imagewriter/imagewriter.cc \