Merge pull request #354 from tdaede/fdi

Add FDI format reader.

doc/using.md

@@ -262,6 +262,11 @@ FluxEngine also supports a number of file system image formats. When using the
   Read from a [DIM image file](https://www.pc98.org/project/doc/dim.html),
   commonly used by X68000 emulators. **Read Only.**
   
+  - `<filename.fdi>`
+
+  Read from a [FDI image file](https://www.pc98.org/project/doc/hdi.html),
+  commonly used by PC-98 emulators. **Read Only.**
+  
   - `<filename.ldbs>`
 
 	Write to a [LDBS generic image

lib/imagereader/fdiimagereader.cc

@@ -0,0 +1,94 @@
+#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 FDI format:
+// https://www.pc98.org/project/doc/hdi.html
+
+class FdiImageReader : public ImageReader
+{
+public:
+	FdiImageReader(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(32);
+        inputFile.read((char*) header.begin(), header.size());
+        ByteReader headerReader(header);
+        if (headerReader.seek(0).read_le32() != 0)
+            Error() << "FDI: could not find FDI header, is this a FDI file?";
+
+        // we currently don't use fddType but it could be used to automatically select
+        // profile parameters in the future
+        //
+        int fddType = headerReader.seek(4).read_le32();
+        int headerSize = headerReader.seek(0x08).read_le32();
+        int sectorSize = headerReader.seek(0x10).read_le32();
+        int sectorsPerTrack = headerReader.seek(0x14).read_le32();
+        int sides = headerReader.seek(0x18).read_le32();
+        int tracks = headerReader.seek(0x1c).read_le32();
+
+        inputFile.seekg(headerSize);
+
+        Image image;
+		int trackCount = 0;
+        for (int track = 0; track < tracks; track++)
+        {
+			if (inputFile.eof())
+				break;
+			int physicalCylinder = track;
+
+            for (int side = 0; side < sides; 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("FDI: read {} tracks, {} sides, {} kB total\n",
+                        geometry.numTracks, geometry.numSides,
+						inputFile.tellg() / 1024);
+        return image;
+	}
+
+};
+
+std::unique_ptr<ImageReader> ImageReader::createFdiImageReader(
+	const ImageReaderProto& config)
+{
+    return std::unique_ptr<ImageReader>(new FdiImageReader(config));
+}
+

lib/imagereader/imagereader.cc

@@ -17,6 +17,9 @@ std::unique_ptr<ImageReader> ImageReader::create(const ImageReaderProto& config)
 		case ImageReaderProto::kDim:
 			return ImageReader::createDimImageReader(config);
 
+		case ImageReaderProto::kFdi:
+			return ImageReader::createFdiImageReader(config);
+
 		case ImageReaderProto::kImd:
 			return ImageReader::createIMDImageReader(config);
 
@@ -54,6 +57,8 @@ void ImageReader::updateConfigForFilename(ImageReaderProto* proto, const std::st
 		{".d81",      [&]() { proto->mutable_img(); }},
 		{".dim",      [&]() { proto->mutable_dim(); }},
 		{".diskcopy", [&]() { proto->mutable_diskcopy(); }},
+		{".fdi",      [&]() { proto->mutable_fdi(); }},
+		{".FDI",      [&]() { proto->mutable_fdi(); }},
 		{".img",      [&]() { proto->mutable_img(); }},
 		{".st",       [&]() { proto->mutable_img(); }},
 		{".nsi",      [&]() { proto->mutable_nsi(); }},

lib/imagereader/imagereader.h

@@ -24,6 +24,7 @@ public:
     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);
+    static std::unique_ptr<ImageReader> createFdiImageReader(const ImageReaderProto& config);
 
 public:
 	virtual Image readImage() = 0;

lib/imagereader/imagereader.proto

@@ -39,6 +39,7 @@ message D64InputProto {}
 message NsiInputProto {}
 message Td0InputProto {}
 message DimInputProto {}
+message FdiInputProto {}
 
 message ImageReaderProto {
 	optional string filename = 1 [(help) = "filename of input sector image"];
@@ -51,6 +52,7 @@ message ImageReaderProto {
 		NsiInputProto nsi = 7;
 		Td0InputProto td0 = 8;
 		DimInputProto dim = 9;
+		FdiInputProto fdi = 10;
 	}
 }
 

mkninja.sh

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