Merge pull request #121 from davidgiven/amiga

Add support for writing Amiga disks.

.github/workflows/ccpp.yml

@@ -0,0 +1,34 @@
+name: C/C++ CI
+
+on: [push]
+
+jobs:
+  build-linux:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v1
+    - name: apt
+      run: sudo apt install libusb-1.0-0-dev libsqlite3-dev ninja-build
+    - name: make
+      run: make
+
+  build-macos:
+    runs-on: macos-latest
+    steps:
+    - uses: actions/checkout@v1
+    - name: brew
+      run: brew install sqlite pkg-config libusb ninja
+    - name: make
+      run: make
+
+#  build-windows:
+#    runs-on: windows-latest
+#    steps:
+#    - uses: numworks/setup-msys2@v1
+#      with:
+#        msystem: MSYS
+#    - uses: actions/checkout@v1
+#    - name: pacman
+#      run: msys2do pacman -S --noconfirm --needed make ninja mingw-w64-i686-libusb mingw-w64-i686-sqlite3 mingw-w64-i686-zlib mingw-w64-i686-gcc zip
+#    - name: make
+#      run: msys2do make

.travis.yml

@@ -1,39 +0,0 @@
-language: shell
-git:
-    depth: 1
-
-matrix:
-    include:
-        -
-            os: linux
-            sudo: false
-            dist: xenial
-            compiler: gcc
-            env: CXX=g++-8
-            script:
-            - make
-        -
-            os: osx
-            osx_image: xcode10.2
-            compiler: clang
-            env:
-            - HOMEBREW_NO_INSTALL_CLEANUP=1
-
-addons:
-    apt:
-        sources:
-        - llvm-toolchain-precise-3.8
-        - ubuntu-toolchain-r-test
-        packages:
-        - ninja-build
-        - libusb-1.0-0-dev
-        - libsqlite3-dev
-        - g++-8
-    homebrew:
-        packages:
-        - ninja
-
-script:
-- make
-
-

Makefile

@@ -13,6 +13,13 @@ export LDFLAGS +=
 export LIBS = -static -lz -lsqlite3 -lusb-1.0
 export EXTENSION = .exe
 else
+
+packages-exist = $(shell pkg-config --exists $(PACKAGES) && echo yes)
+ifneq ($(packages-exist),yes)
+$(warning These pkg-config packages are installed: $(shell pkg-config --list-all | sort | awk '{print $$1}'))
+$(error You must have these pkg-config packages installed: $(PACKAGES))
+endif
+
 export CXX = g++
 export AR = ar rcs
 export STRIP = strip

README.md

@@ -89,7 +89,7 @@ people who've had it work).
 | [Brother 120kB](doc/disk-brother.md)     |  🦄   |        |                                     |
 | [Brother 240kB](doc/disk-brother.md)     |  🦄   |   🦄   |                                     |
 | [Brother FB-100](doc/disk-fb100.md)      |  🦖   |        | Tandy Model 100, Husky Hunter, knitting machines |
-| [Macintosh 800kB](doc/disk-macintosh.md) |  🦄   |        | and probably the 400kB too          |
+| [Macintosh 800kB](doc/disk-macintosh.md) |  🦖   |        | and probably the 400kB too          |
 | [TRS-80](doc/disk-trs80.md)              |  🦖   |        | a minor variation of the IBM scheme |
 {: .datatable }
 

arch/amiga/amiga.cc

@@ -0,0 +1,101 @@
+#include "globals.h"
+#include "record.h"
+#include "decoders/decoders.h"
+#include "amiga.h"
+#include "bytes.h"
+#include "fmt/format.h"
+
+uint32_t amigaChecksum(const Bytes& bytes)
+{
+    ByteReader br(bytes);
+    uint32_t checksum = 0;
+
+    assert((bytes.size() & 3) == 0);
+    while (!br.eof())
+        checksum ^= br.read_be32();
+
+    return checksum & 0x55555555;
+}
+
+static uint8_t everyother(uint16_t x)
+{
+	                  /* aabb ccdd eeff gghh */
+	x &= 0x6666;      /* 0ab0 0cd0 0ef0 0gh0 */
+	x >>= 1;          /* 00ab 00cd 00ef 00gh */
+	x |= x << 2;      /* abab cdcd efef ghgh */
+	x &= 0x3c3c;      /* 00ab cd00 00ef gh00 */
+	x >>= 2;          /* 0000 abcd 0000 efgh */
+	x |= x >> 4;      /* 0000 abcd abcd efgh */
+	return x;
+}
+
+Bytes amigaInterleave(const Bytes& input)
+{
+	Bytes output;
+	ByteWriter bw(output);
+
+	/* Write all odd bits. (Numbering starts at 0...) */
+
+	{
+		ByteReader br(input);
+		while (!br.eof())
+		{
+			uint16_t x = br.read_be16();
+			x &= 0xaaaa;       /* a0b0 c0d0 e0f0 g0h0 */
+			x |= x >> 1;       /* aabb ccdd eeff gghh */
+			x = everyother(x); /* 0000 0000 abcd efgh */
+			bw.write_8(x);
+		}
+	}
+
+	/* Write all even bits. */
+
+	{
+		ByteReader br(input);
+		while (!br.eof())
+		{
+			uint16_t x = br.read_be16();
+			x &= 0x5555;       /* 0a0b 0c0d 0e0f 0g0h */
+			x |= x << 1;       /* aabb ccdd eeff gghh */
+			x = everyother(x); /* 0000 0000 abcd efgh */
+			bw.write_8(x);
+		}
+	}
+
+	return output;
+}
+
+Bytes amigaDeinterleave(const uint8_t*& input, size_t len)
+{
+    assert(!(len & 1));
+    const uint8_t* odds = &input[0];
+    const uint8_t* evens = &input[len/2];
+    Bytes output;
+    ByteWriter bw(output);
+
+    for (size_t i=0; i<len/2; i++)
+    {
+        uint8_t o = *odds++;
+        uint8_t e = *evens++;
+
+        /* This is the 'Interleave bits with 64-bit multiply' technique from
+         * http://graphics.stanford.edu/~seander/bithacks.html#InterleaveBMN
+         */
+        uint16_t result =
+            (((e * 0x0101010101010101ULL & 0x8040201008040201ULL)
+                * 0x0102040810204081ULL >> 49) & 0x5555) |
+            (((o * 0x0101010101010101ULL & 0x8040201008040201ULL)
+                * 0x0102040810204081ULL >> 48) & 0xAAAA);
+        
+        bw.write_be16(result);
+    }
+
+    input += len;
+    return output;
+}
+
+Bytes amigaDeinterleave(const Bytes& input)
+{
+	const uint8_t* ptr = input.cbegin();
+	return amigaDeinterleave(ptr, input.size());
+}

arch/amiga/amiga.h

@@ -1,12 +1,17 @@
 #ifndef AMIGA_H
 #define AMIGA_H
 
+#include "encoders/encoders.h"
+
 #define AMIGA_SECTOR_RECORD 0xaaaa44894489LL
 
+#define AMIGA_TRACKS_PER_DISK 80
+#define AMIGA_SECTORS_PER_TRACK 11
 #define AMIGA_RECORD_SIZE 0x21f
 
 class Sector;
 class Fluxmap;
+class SectorSet;
 
 class AmigaDecoder : public AbstractDecoder
 {
@@ -17,4 +22,20 @@ public:
     void decodeSectorRecord();
 };
 
+class AmigaEncoder : public AbstractEncoder
+{
+public:
+	virtual ~AmigaEncoder() {}
+
+public:
+    std::unique_ptr<Fluxmap> encode(int physicalTrack, int physicalSide, const SectorSet& allSectors);
+};
+
+extern FlagGroup amigaEncoderFlags;
+
+extern uint32_t amigaChecksum(const Bytes& bytes);
+extern Bytes amigaInterleave(const Bytes& input);
+extern Bytes amigaDeinterleave(const uint8_t*& input, size_t len);
+extern Bytes amigaDeinterleave(const Bytes& input);
+
 #endif

arch/amiga/decoder.cc

@@ -21,47 +21,6 @@
          
 static const FluxPattern SECTOR_PATTERN(48, AMIGA_SECTOR_RECORD);
 
-static Bytes deinterleave(const uint8_t*& input, size_t len)
-{
-    assert(!(len & 1));
-    const uint8_t* odds = &input[0];
-    const uint8_t* evens = &input[len/2];
-    Bytes output;
-    ByteWriter bw(output);
-
-    for (size_t i=0; i<len/2; i++)
-    {
-        uint8_t o = *odds++;
-        uint8_t e = *evens++;
-
-        /* This is the 'Interleave bits with 64-bit multiply' technique from
-         * http://graphics.stanford.edu/~seander/bithacks.html#InterleaveBMN
-         */
-        uint16_t result =
-            (((e * 0x0101010101010101ULL & 0x8040201008040201ULL)
-                * 0x0102040810204081ULL >> 49) & 0x5555) |
-            (((o * 0x0101010101010101ULL & 0x8040201008040201ULL)
-                * 0x0102040810204081ULL >> 48) & 0xAAAA);
-        
-        bw.write_be16(result);
-    }
-
-    input += len;
-    return output;
-}
-
-static uint32_t checksum(const Bytes& bytes)
-{
-    ByteReader br(bytes);
-    uint32_t checksum = 0;
-
-    assert((bytes.size() & 3) == 0);
-    while (!br.eof())
-        checksum ^= br.read_be32();
-
-    return checksum & 0x55555555;
-}
-
 AbstractDecoder::RecordType AmigaDecoder::advanceToNextRecord()
 {
     _sector->clock = _fmr->seekToPattern(SECTOR_PATTERN);
@@ -78,22 +37,22 @@ void AmigaDecoder::decodeSectorRecord()
 
     const uint8_t* ptr = bytes.begin() + 3;
 
-    Bytes header = deinterleave(ptr, 4);
-    Bytes recoveryinfo = deinterleave(ptr, 16);
+    Bytes header = amigaDeinterleave(ptr, 4);
+    Bytes recoveryinfo = amigaDeinterleave(ptr, 16);
 
     _sector->logicalTrack = header[1] >> 1;
     _sector->logicalSide = header[1] & 1;
     _sector->logicalSector = header[2];
 
-    uint32_t wantedheaderchecksum = deinterleave(ptr, 4).reader().read_be32();
-    uint32_t gotheaderchecksum = checksum(rawbytes.slice(6, 40));
+    uint32_t wantedheaderchecksum = amigaDeinterleave(ptr, 4).reader().read_be32();
+    uint32_t gotheaderchecksum = amigaChecksum(rawbytes.slice(6, 40));
     if (gotheaderchecksum != wantedheaderchecksum)
         return;
 
-    uint32_t wanteddatachecksum = deinterleave(ptr, 4).reader().read_be32();
-    uint32_t gotdatachecksum = checksum(rawbytes.slice(62, 1024));
+    uint32_t wanteddatachecksum = amigaDeinterleave(ptr, 4).reader().read_be32();
+    uint32_t gotdatachecksum = amigaChecksum(rawbytes.slice(62, 1024));
 
     _sector->data.clear();
-    _sector->data.writer().append(deinterleave(ptr, 512)).append(recoveryinfo);
+    _sector->data.writer().append(amigaDeinterleave(ptr, 512)).append(recoveryinfo);
     _sector->status = (gotdatachecksum == wanteddatachecksum) ? Sector::OK : Sector::BAD_CHECKSUM;
 }

arch/amiga/encoder.cc

@@ -0,0 +1,126 @@
+#include "globals.h"
+#include "record.h"
+#include "decoders/decoders.h"
+#include "encoders/encoders.h"
+#include "amiga.h"
+#include "crc.h"
+#include "sectorset.h"
+#include "writer.h"
+
+FlagGroup amigaEncoderFlags;
+
+static DoubleFlag clockRateUs(
+	{ "--clock-rate" },
+	"Encoded data clock rate (microseconds).",
+	2.00);
+
+static DoubleFlag postIndexGapMs(
+	{ "--post-index-gap" },
+	"Post-index gap before first sector header (milliseconds).",
+	0.5);
+
+static int charToInt(char c)
+{
+	if (isdigit(c))
+		return c - '0';
+	return 10 + tolower(c) - 'a';
+}
+
+static void write_bits(std::vector<bool>& bits, unsigned& cursor, const std::vector<bool>& src)
+{
+	for (bool bit : src)
+	{
+		if (cursor < bits.size())
+			bits[cursor++] = bit;
+	}
+}
+
+static void write_bits(std::vector<bool>& bits, unsigned& cursor, uint64_t data, int width)
+{
+	cursor += width;
+	for (int i=0; i<width; i++)
+	{
+		unsigned pos = cursor - i - 1;
+		if (pos < bits.size())
+			bits[pos] = data & 1;
+		data >>= 1;
+	}
+}
+
+static void write_interleaved_bytes(std::vector<bool>& bits, unsigned& cursor, const Bytes& bytes)
+{
+	assert(!(bytes.size() & 3));
+	Bytes interleaved = amigaInterleave(bytes);
+	encodeMfm(bits, cursor, interleaved);
+}
+
+static void write_interleaved_bytes(std::vector<bool>& bits, unsigned& cursor, uint32_t data)
+{
+	Bytes b(4);
+	ByteWriter bw(b);
+	bw.write_be32(data);
+	write_interleaved_bytes(bits, cursor, b);
+}
+
+static void write_sector(std::vector<bool>& bits, unsigned& cursor, const Sector* sector)
+{
+	if ((sector->data.size() != 512) && (sector->data.size() != 528))
+		Error() << "unsupported sector size --- you must pick 512 or 528";
+
+    write_bits(bits, cursor, AMIGA_SECTOR_RECORD, 6*8);
+
+	std::vector<bool> headerBits(20*16);
+	unsigned headerCursor = 0;
+
+	Bytes header = 
+		{
+			0xff, /* Amiga 1.0 format byte */
+			(uint8_t) ((sector->logicalTrack<<1) | sector->logicalSide),
+			(uint8_t) sector->logicalSector,
+			(uint8_t) (AMIGA_SECTORS_PER_TRACK - sector->logicalSector)
+		};
+	write_interleaved_bytes(headerBits, headerCursor, header);
+	Bytes recoveryInfo(16);
+	if (sector->data.size() == 528)
+		recoveryInfo = sector->data.slice(512, 16);
+	write_interleaved_bytes(headerBits, headerCursor, recoveryInfo);
+
+	std::vector<bool> dataBits(512*16);
+	unsigned dataCursor = 0;
+	write_interleaved_bytes(dataBits, dataCursor, sector->data);
+
+	write_bits(bits, cursor, headerBits);
+	uint32_t headerChecksum = amigaChecksum(toBytes(headerBits));
+	write_interleaved_bytes(bits, cursor, headerChecksum);
+	uint32_t dataChecksum = amigaChecksum(toBytes(dataBits));
+	write_interleaved_bytes(bits, cursor, dataChecksum);
+	write_bits(bits, cursor, dataBits);
+}
+
+std::unique_ptr<Fluxmap> AmigaEncoder::encode(
+	int physicalTrack, int physicalSide, const SectorSet& allSectors)
+{
+	if ((physicalTrack < 0) || (physicalTrack >= AMIGA_TRACKS_PER_DISK))
+		return std::unique_ptr<Fluxmap>();
+
+	int bitsPerRevolution = 200000.0 / clockRateUs;
+	std::vector<bool> bits(bitsPerRevolution);
+	unsigned cursor = 0;
+
+    fillBitmapTo(bits, cursor, postIndexGapMs * 1000 / clockRateUs, { true, false });
+
+	for (int sectorId=0; sectorId<AMIGA_SECTORS_PER_TRACK; sectorId++)
+	{
+		const auto& sectorData = allSectors.get(physicalTrack, physicalSide, sectorId);
+		write_sector(bits, cursor, sectorData);
+    }
+
+	if (cursor >= bits.size())
+		Error() << "track data overrun";
+	fillBitmapTo(bits, cursor, bits.size(), { true, false });
+
+	std::unique_ptr<Fluxmap> fluxmap(new Fluxmap);
+	fluxmap->appendBits(bits, clockRateUs*1e3);
+	return fluxmap;
+}
+

arch/brother/encoder.cc

@@ -154,7 +154,7 @@ std::unique_ptr<Fluxmap> BrotherEncoder::encode(
 		write_sector_data(bits, cursor, sectorData->data);
 	}
 
-	if (cursor > bits.size())
+	if (cursor >= bits.size())
 		Error() << "track data overrun";
 	fillBitmapTo(bits, cursor, bits.size(), { true, false });
 

doc/building.md

@@ -182,7 +182,7 @@ install some support packages.
 
   - For Linux (this is Ubuntu, but this should apply to Debian too):
   `ninja-build`, `libusb-1.0-0-dev`, `libsqlite3-dev`.
-  - For OSX with Homebrew: `ninja`.
+  - For OSX with Homebrew: `ninja`, `libusb`, `pkg-config`, `sqlite`.
   - For Windows with MSYS2: `make`, `ninja`, `mingw-w64-i686-libusb`,
   `mingw-w64-i686-sqlite3`, `mingw-w64-i686-zlib`, `mingw-w64-i686-gcc`.
 

doc/disk-amiga.md

@@ -10,7 +10,7 @@ Bizarrely, the data in each sector is stored with all the odd bits first, and
 then all the even bits. This is tied into the checksum algorithm, which is
 distinctly subpar and not particularly good at detecting errors.
 
-Reading discs
+Reading disks
 -------------
 
 Just do:
@@ -34,6 +34,28 @@ You will end up with a 929280 byte long image which you probably _can't_ use
 in an emulator; each sector will contain the 512 bytes of user payload
 followed by the 16 bytes of metadata.
 
+Writing disks
+-------------
+
+Just do:
+
+```
+fluxengine write amiga -i amiga.adf
+```
+
+This will rake a normal 901120 byte long ADF file and write it to a DD disk.
+Note that writing to an HD disk will probably not work (this will depend on
+your drive and disk and potential FluxEngine bugs I'm still working on ---
+please [get in touch](https://github.com/davidgiven/fluxengine/issues/new) if
+you have any insight here).
+
+If you want to write the metadata as well, specify a 528 byte sector size for
+the output image and supply a 929280 byte long file as described above.
+
+```
+fluxengine write amiga -i amiga.adf:b=528
+```
+
 Useful references
 -----------------
 

doc/disk-macintosh.md

@@ -28,8 +28,16 @@ for example the Commodore 64 1541 drive, changed bitrate this way.
 But Macintosh disks used a constant bitrate and changed the speed that the
 disk spun instead to achieve the same effect...
 
-_Anyway_: FluxEngine will read them fine on a conventional drive. Because
-it's clever.
+_Anyway_: FluxEngine will read them fine on conventional drives.
+Because it's clever.
+
+**Big note.** Apparently --- and I'm still getting to the bottom of this ---
+some drives work and some don't. My drives produce about 90% good reads of
+known good disks. One rumour I've heard is that drives sometimes include
+filters which damage the signals at very particular intervals which Mac disks
+use, but frankly this seems unlikely; it could be a software issue at my end
+and I'm investigating. If you have any insight, please [get in
+touch](https://github.com/davidgiven/fluxengine/issues/new).
 
 Reading discs
 -------------

doc/faq.md

@@ -48,7 +48,7 @@ haven't had the chance to try it end-for-end. I really need a hard-sectored
 
 **Q.** Does it work with flippy disks?
 
-Uhhh... probably not.
+Uhhh... maybe?
 
 So the problem with flippy disks (5.25" single-sided disks which could be
 inserted upside down to read the second side) is the index hole. Trouble is,
@@ -79,16 +79,21 @@ the other. But a flippy disk has both sets of tracks in the same place,
 because they're both accessed using the side 0 head...
 
 The only real way round this is to modify a 5.25" drive. That's _seriously_
-not in FluxEngine's remit. Sorry.
+not in FluxEngine's remit, but I've had some [excellent documentation
+contributed](Index_sensor_mod_FDD_1.1.pdf) on how to do this. I've never done
+it myself; if you try this and it works/doesn't work, as always, [get in
+touch](https://github.com/davidgiven/fluxengine/issues/new).
 
-**Q.** Is this like KryoFlux / Catweasel / DiskFerret? Do you support KryoFlux
+**Q.** Is this like Supercard Pro / KryoFlux / Catweasel / DiskFerret? Do you
+*support KryoFlux
 stream files?
 
 **A.** It's very like all of these; the idea's old, and lots of people have
 tried it (you can get away with any sufficiently fast microcontroller and
 enough RAM). FluxEngine can read from KryoFlux stream files natively, and
-there's a tool which will let you convert at least one kind of Catweasel file
-to FluxEngine's native flux file format.
+there's a tool which will let you convert at least one kind of Catweasel
+files and Supercard Pro files to and from FluxEngine's native flux file
+format.
 
 **Q.** Can I use this to make exact copies of disks?
 

lib/decoders/decoders.h

@@ -20,6 +20,7 @@ extern void setDecoderManualClockRate(double clockrate_us);
 
 extern Bytes decodeFmMfm(std::vector<bool>::const_iterator start,
     std::vector<bool>::const_iterator end);
+extern void encodeMfm(std::vector<bool>& bits, unsigned& cursor, const Bytes& input);
 
 static inline Bytes decodeFmMfm(const std::vector<bool> bits)
 { return decodeFmMfm(bits.begin(), bits.end()); }

lib/decoders/fluxmapreader.cc

@@ -18,7 +18,7 @@ DoubleFlag pulseDebounceThreshold(
 static DoubleFlag clockDecodeThreshold(
     { "--bit-error-threshold" },
     "Amount of error to tolerate in pulse timing, in fractions of a clock.",
-    0.20);
+    0.40);
 
 static DoubleFlag clockIntervalBias(
     { "--clock-interval-bias" },

lib/decoders/fmmfm.cc

@@ -51,3 +51,25 @@ Bytes decodeFmMfm(
 
     return bytes;
 }
+
+void encodeMfm(std::vector<bool>& bits, unsigned& cursor, const Bytes& input)
+{
+    bool lastBit = false;
+    unsigned len = bits.size()-1;
+
+    for (uint8_t b : input)
+    {
+        for (int i=0; i<8; i++)
+        {
+            bool bit = b & 0x80;
+            b <<= 1;
+
+            if (cursor >= len)
+                return;
+            
+            bits[cursor++] = !lastBit && !bit;
+            bits[cursor++] = bit;
+            lastBit = bit;
+        }
+    }
+}

lib/reader.cc

@@ -219,10 +219,7 @@ void readDiskCommand(AbstractDecoder& decoder)
                 std::cout << "giving up" << std::endl
                           << "       ";
             else
-            {
 				std::cout << retry << " retries remaining" << std::endl;
-                track->fluxsource->recalibrate();
-            }
 		}
 
 		if (dumpRecords)

mkninja.sh

@@ -145,6 +145,8 @@ buildlibrary libbackend.a \
 	lib/imagewriter/ldbsimagewriter.cc \
     arch/aeslanier/decoder.cc \
     arch/amiga/decoder.cc \
+    arch/amiga/encoder.cc \
+    arch/amiga/amiga.cc \
     arch/apple2/decoder.cc \
     arch/brother/decoder.cc \
     arch/brother/encoder.cc \
@@ -214,6 +216,7 @@ buildlibrary libfrontend.a \
     src/fe-testbulktransport.cc \
     src/fe-testvoltages.cc \
     src/fe-upgradefluxfile.cc \
+    src/fe-writeamiga.cc \
     src/fe-writebrother.cc \
     src/fe-writeflux.cc \
     src/fe-writetestpattern.cc \
@@ -251,3 +254,4 @@ runtest fluxpattern-test    tests/fluxpattern.cc
 runtest fmmfm-test          tests/fmmfm.cc
 runtest kryoflux-test       tests/kryoflux.cc
 runtest ldbs-test           tests/ldbs.cc
+runtest amiga-test          tests/amiga.cc

src/fe-fluxtoscp.cc

@@ -85,7 +85,7 @@ int mainConvertFluxToScp(int argc, const char* argv[])
     fileheader.file_id[0] = 'S';
     fileheader.file_id[1] = 'C';
     fileheader.file_id[2] = 'P';
-    fileheader.file_id[3] = 0x18; /* Version 1.8 of the spec */
+    fileheader.version = 0x18; /* Version 1.8 of the spec */
     fileheader.type = diskType;
     fileheader.revolutions = 5;
     fileheader.start_track = 0;

src/fe-writeamiga.cc

@@ -0,0 +1,23 @@
+#include "globals.h"
+#include "flags.h"
+#include "decoders/decoders.h"
+#include "amiga/amiga.h"
+#include "writer.h"
+#include "fmt/format.h"
+#include "image.h"
+#include <fstream>
+
+static FlagGroup flags { &writerFlags, &amigaEncoderFlags };
+
+int mainWriteAmiga(int argc, const char* argv[])
+{
+    setWriterDefaultInput(":c=80:h=2:s=11:b=512");
+    setWriterDefaultDest(":d=0:t=0-79:s=0-1");
+    flags.parseFlags(argc, argv);
+
+	AmigaEncoder encoder;
+	writeDiskCommand(encoder);
+
+    return 0;
+}
+

src/fluxengine.cc

@@ -29,6 +29,7 @@ extern command_cb mainSeek;
 extern command_cb mainTestBulkTransport;
 extern command_cb mainTestVoltages;
 extern command_cb mainUpgradeFluxFile;
+extern command_cb mainWriteAmiga;
 extern command_cb mainWriteBrother;
 extern command_cb mainWriteFlux;
 extern command_cb mainWriteTestPattern;
@@ -81,6 +82,7 @@ static std::vector<Command> readables =
 
 static std::vector<Command> writeables =
 {
+    { "amiga",         mainWriteAmiga,    "Writes Amiga disks.", },
     { "brother",       mainWriteBrother,  "Writes 120kB and 240kB Brother word processor disks.", },
 };
 

tests/amiga.cc

@@ -0,0 +1,38 @@
+#include "globals.h"
+#include "bytes.h"
+#include "record.h"
+#include "decoders/decoders.h"
+#include "arch/amiga/amiga.h"
+#include <assert.h>
+
+static const Bytes testData = {
+    0x52, /* 0101 0010 */
+    0xff, /* 1111 1111 */
+    0x4a, /* 0100 1010 */
+    0x22, /* 0010 0010 */
+};
+static const Bytes testDataInterleaved = {
+    0x1f, /* 0001 1111 */
+    0x35, /* 0011 0101 */
+    0xcf, /* 1100 1111 */
+    0x80, /* 1000 0000 */
+};
+
+static void testInterleave(void)
+{
+    Bytes interleaved = amigaInterleave(testData);
+    assert(interleaved == testDataInterleaved);
+}
+
+static void testDeinterleave(void)
+{
+    Bytes deinterleaved = amigaDeinterleave(testDataInterleaved);
+    assert(deinterleaved == testData);
+}
+
+int main(int argc, const char* argv[])
+{
+    testDeinterleave();
+    testInterleave();
+    return 0;
+}